From 431358b2956808b6523f4507f68942785e5d6aff Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 21 Sep 2023 15:56:52 -0500 Subject: [PATCH 01/32] modified fail_transaction so it returns state instead of state, agent --- hydradx/model/amm/stableswap_amm.py | 47 +++++++++++++++++------------ 1 file changed, 27 insertions(+), 20 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index 1f103ca5..f9b20606 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -54,6 +54,10 @@ def n_coins(self) -> int: def d(self) -> float: return self.calculate_d() + def fail_transaction(self, error: str, **kwargs): + self.fail = error + return self + def has_converged(self, v0, v1) -> bool: diff = abs(v0 - v1) if (v1 <= v0 and diff < self.precision) or (v1 > v0 and diff <= self.precision): @@ -108,16 +112,19 @@ def calculate_y(self, reserves: list, d: float, max_iterations=128): return y # price is denominated in the first asset - @property - def spot_price(self): - x, y = self.liquidity.values() - return self.price_at_balance([x, y], self.d) - - # price is denominated in the first asset - def price_at_balance(self, balances: list, d: float): - x, y = balances + def spot_price(self, tkn: str, numeraire: str): + """ + return the price of TKN denominated in NUMÉRAIRE + """ c = self.amplification * self.n_coins ** (2 * self.n_coins) - return (x / y) * (c * x * y ** 2 + d ** 3) / (c * x ** 2 * y + d ** 3) + p = 1 + for x in self.liquidity.values(): + p *= x + x = self.liquidity[numeraire] + y = self.liquidity[tkn] + n = self.n_coins + d = self.d + return (x / y) * (c * y * p + d ** (n + 1)) / (c * x * p + d ** (n + 1)) def modified_balances(self, delta: dict = None, omit: list = ()): balances = copy.copy(self.liquidity) @@ -182,9 +189,9 @@ def swap( buy_quantity = (self.liquidity[tkn_buy] - self.calculate_y(reserves, self.d)) * (1 - self.trade_fee) if agent.holdings[tkn_sell] < sell_quantity: - return self.fail_transaction('Agent has insufficient funds.', agent) + return self.fail_transaction('Agent has insufficient funds.') elif self.liquidity[tkn_buy] <= buy_quantity: - return self.fail_transaction('Pool has insufficient liquidity.', agent) + return self.fail_transaction('Pool has insufficient liquidity.') new_agent = agent # .copy() if tkn_buy not in new_agent.holdings: @@ -207,7 +214,7 @@ def withdraw_asset( Calculate a withdrawal based on the asset quantity rather than the share quantity """ if quantity >= self.liquidity[tkn_remove]: - return self.fail_transaction(f'Not enough liquidity in {tkn_remove}.', agent) + return self.fail_transaction(f'Not enough liquidity in {tkn_remove}.') if quantity <= 0: raise ValueError('Withdraw quantity must be > 0.') @@ -215,7 +222,7 @@ def withdraw_asset( if shares_removed > agent.holdings[self.unique_id]: if fail_on_overdraw: - return self.fail_transaction('Agent tried to remove more shares than it owns.', agent) + return self.fail_transaction('Agent tried to remove more shares than it owns.') else: # just round down shares_removed = agent.holdings[self.unique_id] @@ -240,9 +247,9 @@ def remove_liquidity( # * Solve Eqn against y_i for D - _token_amount if shares_removed > agent.holdings[self.unique_id]: - return self.fail_transaction('Agent has insufficient funds.', agent) + return self.fail_transaction('Agent has insufficient funds.') elif shares_removed <= 0: - return self.fail_transaction('Withdraw quantity must be > 0.', agent) + return self.fail_transaction('Withdraw quantity must be > 0.') _fee = self.trade_fee _fee *= self.n_coins / 4 / (self.n_coins - 1) @@ -285,9 +292,9 @@ def add_liquidity( updated_d = self.calculate_d(self.modified_balances(delta={tkn_add: quantity})) if updated_d < initial_d: - return self.fail_transaction('invariant decreased for some reason', agent) + return self.fail_transaction('invariant decreased for some reason') if agent.holdings[tkn_add] < quantity: - return self.fail_transaction(f"Agent doesn't have enough {tkn_add}.", agent) + return self.fail_transaction(f"Agent doesn't have enough {tkn_add}.") self.liquidity[tkn_add] += quantity agent.holdings[tkn_add] -= quantity @@ -297,7 +304,7 @@ def add_liquidity( self.shares = updated_d elif self.shares < 0: - return self.fail_transaction('Shares cannot go below 0.', agent) + return self.fail_transaction('Shares cannot go below 0.') # why would this possibly happen? else: @@ -327,7 +334,7 @@ def buy_shares( if delta_tkn > agent.holdings[tkn_add]: if fail_overdraft: - return self.fail_transaction(f"Agent doesn't have enough {tkn_add}.", agent) + return self.fail_transaction(f"Agent doesn't have enough {tkn_add}.") else: # instead of failing, just round down delta_tkn = agent.holdings[tkn_add] @@ -358,7 +365,7 @@ def remove_uniform( delta_tkns[tkn] = share_fraction * self.liquidity[tkn] # delta_tkn is positive if delta_tkns[tkn] >= self.liquidity[tkn]: - return self.fail_transaction(f'Not enough liquidity in {tkn}.', agent) + return self.fail_transaction(f'Not enough liquidity in {tkn}.') if tkn not in agent.holdings: agent.holdings[tkn] = 0 From 484e6b405e2564f126bc01f3c8a0737fbf5c67c0 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 21 Sep 2023 15:58:12 -0500 Subject: [PATCH 02/32] added swap_one function --- hydradx/model/amm/stableswap_amm.py | 62 +++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index f9b20606..8892cfe8 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -203,6 +203,68 @@ def swap( return self + def swap_one( + self, + agent: Agent, + quantity: float, + tkn_sell: str = '', + tkn_buy: str = '', + ): + """ + This can be used when you want to change the price of one asset without changing the price of the others. + Specify one asset to buy or sell, and the quantity of each of the *other* assets to sell or buy. + The quantity of the specified asset to trade will be determined. + Caution: this will only work correctly if the pool is balanced (spot prices equal on all assets). + """ + if tkn_sell and tkn_buy: + raise ValueError('Cannot specify both buy and sell quantities.') + + if tkn_buy: + tkns_sell = list(filter(lambda t: t != tkn_buy, self.asset_list)) + for tkn in tkns_sell: + if tkn not in agent.holdings: + self.fail_transaction(f'Agent does not have any {tkn}.') + if min([agent.holdings[tkn] for tkn in tkns_sell]) < quantity: + return self.fail_transaction('Agent has insufficient funds.') + + sell_quantity = quantity + buy_quantity = (self.liquidity[tkn_buy] - self.calculate_y( + self.modified_balances(delta={tkn: quantity for tkn in tkns_sell}, omit=[tkn_buy]), + self.d + )) * (1 - self.trade_fee) + + if self.liquidity[tkn_buy] < buy_quantity: + return self.fail_transaction('Pool has insufficient liquidity.') + + for tkn in tkns_sell: + self.liquidity[tkn] += sell_quantity + agent.holdings[tkn] -= sell_quantity + self.liquidity[tkn_buy] -= buy_quantity + agent.holdings[tkn_buy] += buy_quantity + + elif tkn_sell: + tkns_buy = list(filter(lambda tkn: tkn != tkn_sell, self.asset_list)) + buy_quantity = quantity + + if min([self.liquidity[tkn] for tkn in tkns_buy]) < buy_quantity: + return self.fail_transaction('Pool has insufficient liquidity.') + + sell_quantity = (self.calculate_y( + self.modified_balances(delta={tkn: -quantity for tkn in tkns_buy}, omit=[tkn_sell]), + self.d + ) - self.liquidity[tkn_sell]) / (1 - self.trade_fee) + if agent.holdings[tkn_sell] < sell_quantity: + return self.fail_transaction(f'Agent has insufficient funds. {agent.holdings[tkn_sell]} < {quantity}') + for tkn in tkns_buy: + self.liquidity[tkn] -= buy_quantity + if tkn not in agent.holdings: + agent.holdings[tkn] = 0 + agent.holdings[tkn] += buy_quantity + self.liquidity[tkn_sell] += sell_quantity + agent.holdings[tkn_sell] -= sell_quantity + + return self + def withdraw_asset( self, agent: Agent, From 896e95caaee63f8ee11d7357aa777e6cda44c571 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 21 Sep 2023 15:58:33 -0500 Subject: [PATCH 03/32] added test_swap_one --- hydradx/tests/test_stableswap.py | 85 ++++++++++++++++++++++++++------ 1 file changed, 70 insertions(+), 15 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 1c318c56..0ea15ecc 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -18,10 +18,14 @@ asset_number_strategy = st.integers(min_value=2, max_value=5) -def stable_swap_equation(d: float, a: float, n: int, reserves: list): +def stable_swap_equation(pool: StableSwapPoolState): # d: float, a: float, n: int, reserves: list): """ this is the equation that should remain true at all times within a stableswap pool """ + a = pool.amplification + d = pool.d + n = pool.n_coins + reserves = list(pool.liquidity.values()) side1 = a * n ** n * sum(reserves) + d side2 = a * n ** n * d + d ** (n + 1) / (n ** n * functools.reduce(lambda i, j: i * j, reserves)) return side1 == pytest.approx(side2) @@ -70,7 +74,7 @@ def test_spot_price(token_a: int, token_b: int, amp: int): unique_id='stableswap' ) - spot_price_initial = initial_pool.spot_price + spot_price_initial = initial_pool.spot_price() trade_size=1 agent = Agent(holdings={"A": 100000, "B": 100000}) @@ -79,7 +83,7 @@ def test_spot_price(token_a: int, token_b: int, amp: int): delta_b = tokens["B"] - initial_pool.liquidity["B"] exec_price = delta_a / delta_b - spot_price_final = initial_pool.spot_price + spot_price_final = initial_pool.spot_price() if spot_price_initial > exec_price: raise AssertionError('Initial spot price should be lower than execution price.') @@ -205,12 +209,7 @@ def test_add_remove_liquidity(initial_pool: StableSwapPoolState): add_liquidity_state, add_liquidity_agent = stableswap.simulate_add_liquidity( initial_pool, old_agent=lp, quantity=10000, tkn_add=lp_tkn ) - if not stable_swap_equation( - add_liquidity_state.calculate_d(), - add_liquidity_state.amplification, - add_liquidity_state.n_coins, - add_liquidity_state.liquidity.values() - ): + if not stable_swap_equation(add_liquidity_state.calculate_d()): raise AssertionError('Stableswap equation does not hold after add liquidity operation.') remove_liquidity_state, remove_liquidity_agent = stableswap.simulate_remove_liquidity( @@ -219,12 +218,7 @@ def test_add_remove_liquidity(initial_pool: StableSwapPoolState): quantity=add_liquidity_agent.holdings[initial_pool.unique_id], tkn_remove=lp_tkn ) - if not stable_swap_equation( - remove_liquidity_state.calculate_d(), - remove_liquidity_state.amplification, - remove_liquidity_state.n_coins, - remove_liquidity_state.liquidity.values() - ): + if not stable_swap_equation(remove_liquidity_state.calculate_d()): raise AssertionError('Stableswap equation does not hold after remove liquidity operation.') if remove_liquidity_agent.holdings[lp_tkn] != pytest.approx(lp.holdings[lp_tkn]): raise AssertionError('LP did not get the same balance back when withdrawing liquidity.') @@ -335,3 +329,64 @@ def test_exploitability(initial_lp: int, trade_size: int): max_arb_size = arb_size else: break + + +@given( + st.integers(min_value=1, max_value=1000000), + st.floats(min_value=0, max_value=1, exclude_min=True, exclude_max=True) +) +def test_swap_one(amplification, swap_fraction): + initial_state = StableSwapPoolState( + tokens={ + 'USDA': 1000000, + 'USDB': 1000000, + 'USDC': 1000000, + 'USDD': 1000000, + }, amplification=amplification, trade_fee=0, + ) + stablecoin = initial_state.asset_list[-1] + tkn_sell = initial_state.asset_list[0] + buy_quantity = initial_state.liquidity[tkn_sell] * swap_fraction + initial_agent = Agent( + holdings={tkn_sell: 10000000000000} + ) + sell_agent = initial_agent.copy() + sell_state = initial_state.copy().swap_one( + agent=sell_agent, + tkn_sell=tkn_sell, + quantity=buy_quantity + ) + if not stable_swap_equation(sell_state): + raise AssertionError('Stableswap equation does not hold after swap operation.') + + for tkn in initial_state.asset_list: + if ( + sell_state.spot_price(tkn, stablecoin) + != pytest.approx(initial_state.spot_price(tkn, stablecoin)) + and tkn != tkn_sell + ): + raise AssertionError('Spot price changed for non-swapped token.') + + if sell_state.d != pytest.approx(initial_state.d): + raise AssertionError('D changed after sell operation.') + + tkn_buy = sell_state.asset_list[0] + buy_agent = sell_agent.copy() + buy_state = sell_state.copy().swap_one( + agent=buy_agent, + tkn_buy=tkn_buy, + quantity=buy_quantity + ) + if not stable_swap_equation(buy_state): + raise AssertionError('Stableswap equation does not hold after swap operation.') + + for tkn in initial_state.asset_list: + if ( + buy_state.spot_price(tkn, stablecoin) + != pytest.approx(initial_state.spot_price(tkn, stablecoin)) + and tkn != tkn_buy + ): + raise AssertionError('Spot price changed for non-swapped token.') + + if buy_state.d != pytest.approx(initial_state.d): + raise AssertionError('D changed after buy operation.') From d3b354a6889a0f80a462a207cbe442c3980aff56 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 21 Sep 2023 16:05:24 -0500 Subject: [PATCH 04/32] added price check for traded asset in test_swap_one() --- hydradx/tests/test_stableswap.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 0ea15ecc..c6a08821 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -333,7 +333,7 @@ def test_exploitability(initial_lp: int, trade_size: int): @given( st.integers(min_value=1, max_value=1000000), - st.floats(min_value=0, max_value=1, exclude_min=True, exclude_max=True) + st.floats(min_value=0.00000001, max_value=0.999999) ) def test_swap_one(amplification, swap_fraction): initial_state = StableSwapPoolState( @@ -367,6 +367,9 @@ def test_swap_one(amplification, swap_fraction): ): raise AssertionError('Spot price changed for non-swapped token.') + if sell_state.spot_price(tkn_sell, stablecoin) >= initial_state.spot_price(tkn_sell, stablecoin): + raise AssertionError('Spot price increased for swapped token.') + if sell_state.d != pytest.approx(initial_state.d): raise AssertionError('D changed after sell operation.') @@ -388,5 +391,8 @@ def test_swap_one(amplification, swap_fraction): ): raise AssertionError('Spot price changed for non-swapped token.') + if buy_state.spot_price(tkn_buy, stablecoin) <= sell_state.spot_price(tkn_buy, stablecoin): + raise AssertionError('Spot price decreased for swapped token.') + if buy_state.d != pytest.approx(initial_state.d): raise AssertionError('D changed after buy operation.') From 96d96742348c1c37d206801f141b84023f467963 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 12:49:50 -0500 Subject: [PATCH 05/32] notebook showing impermanent loss when one asset depegs out of a stableswap pool of four --- .../ImpermanentLossAnalysis4Assets.ipynb | 481 ++++++++++++++++++ 1 file changed, 481 insertions(+) create mode 100644 hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb new file mode 100644 index 00000000..a99edcb2 --- /dev/null +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Relationship between IL and price change in a stableswap pool

\n", + "Here we investigate the impermanent loss experienced by an LP in a stableswap pool when one of the assets depegs (its value deviates from 1USD). Because the assets in a stableswap pool are expected to remain stable, the pool is optimized to give a better execution price, with less slippage, at the expense of being more vulnerable to impermanent loss in the event of a price change. For the sake of simplicity, the LP both deposits and withdraws a proportional amount of each token (so that these trades don't induce further price changes). Note that the general dynamics and scale of the impermanent loss will hold regardless of which asset the LP chooses to deposit or withdraw.\n", + "

\n", + "An important parameter of the stableswap pool is its amplification, which affect the shape of the price curve. At an amplification of 0, the stableswap pool behaves identically to an XYK pool, whereas at an amplification of infinity, the price of each asset remains at exactly 1 until the pool runs out of liquidity. At an intermediate value, the price remains stable at a wider range of balances than it would in an XYK pool, but hits a 'cliff' when the balance shifts too far in either direction. Higher values give a more stable price but a steeper cliff, and are more appropriate when there is high confidence in the stability of the underlying assets. Here we will graph the IL dynamics for a range of amplification values." + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.614450927Z", + "start_time": "2023-07-06T20:00:30.645499714Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import glob\n", + "import random\n", + "import copy\n", + "import math\n", + "from IPython.display import display, Markdown\n", + "sys.path.append('../..')\n", + "\n", + "from model import processing\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from model import run\n", + "from model import plot_utils as pu\n", + "from model.amm.omnipool_amm import OmnipoolState, cash_out_omnipool, value_assets, usd_price, lrna_price\n", + "from model.amm.stableswap_amm import StableSwapPoolState\n", + "from model.amm.agents import Agent\n", + "from model.amm.trade_strategies import omnipool_arbitrage, invest_all, price_sensitive_trading\n", + "from model.amm.global_state import GlobalState, fluctuate_prices, historical_prices\n", + "\n", + "# same seed, same parameters = same simulation result\n", + "random.seed(42)\n", + "# price_list = processing.import_binance_prices(['BTC', 'ETH', 'DOT'], start_date='Jan 1 2023', days = 120)\n", + "\n", + "assets = {\n", + " 'USDA': {'usd price': 1, 'weight': 0.25},\n", + " 'USDB': {'usd price': 1, 'weight': 0.25},\n", + " 'USDC': {'usd price': 1, 'weight': 0.25},\n", + " 'USDD': {'usd price': 1, 'weight': 0.25}\n", + "}\n", + "\n", + "assert sum([t['weight'] for t in assets.values()]) == 1\n", + "\n", + "initial_tvl = 1000000\n", + "initial_state = GlobalState(\n", + " pools={\n", + " 'stableswap': StableSwapPoolState(\n", + " tokens={\n", + " tkn: initial_tvl * assets[tkn]['weight'] for tkn in assets\n", + " },\n", + " amplification=10,\n", + " trade_fee=0\n", + " )\n", + " },\n", + " agents = {\n", + " 'LP': Agent(\n", + " holdings={tkn: 1 for tkn in assets},\n", + " trade_strategy=invest_all('stableswap')\n", + " ),\n", + " 'Trader': Agent(\n", + " holdings={tkn: 10000000000000 for tkn in assets}\n", + " )\n", + " },\n", + " external_market={tkn: assets[tkn]['usd price'] for tkn in assets}\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.000995444390312422 247276.40443434505\n", + "156.87953617143862 -99990.00099990002\n", + "0.000977326252482079 247647.57879376572\n", + "199.71967208980743 -96686.31486433979\n", + "0.0009877770884735417 247944.91939021496\n", + "199.94530000067437 -92802.53170641157\n", + "0.000980612059546324 248217.79521216897\n", + "199.67437907817265 -90032.92489873343\n", + "0.000995282647861672 248441.28060711964\n", + "199.67207475942692 -88073.92649009275\n", + "0.0009588261640137211 248664.96721939923\n", + "199.42914906713446 -86684.69418227047\n", + "[[247276.40443434505, -99990.00099990002], [247647.57879376572, -96686.31486433979], [247944.91939021496, -92802.53170641157], [248217.79521216897, -90032.92489873343], [248441.28060711964, -88073.92649009275], [248664.96721939923, -86684.69418227047]]\n" + ] + } + ], + "source": [ + "invested_state = initial_state.agents['LP'].trade_strategy.execute(\n", + " initial_state.copy(),\n", + " agent_id='LP'\n", + ")\n", + "amps = [25, 50, 100, 200, 400, 800]\n", + "trade_range = [[200000, -100000]] * len(amps)\n", + "# print(trade_range)\n", + "for i, amp in enumerate(amps):\n", + " for j, target_price in enumerate([0.001, 200]):\n", + " invested_state.pools['stableswap'].amplification = amp\n", + " try_state = invested_state.copy()\n", + " spot_price = [1, 2000][j]\n", + " while (\n", + " spot_price > target_price \n", + " and not try_state.pools['stableswap'].fail\n", + " ):\n", + " # find the correct trade size to get the price we want\n", + " if j == 0:\n", + " trade_range[i][j] *= 1.0001\n", + " elif j == 1:\n", + " trade_range[i][j] /= 1.0001\n", + " try_state = invested_state.copy()\n", + " try_state.pools['stableswap'].swap_one(\n", + " agent=try_state.agents['Trader'],\n", + " tkn_sell='USDA',\n", + " quantity=trade_range[i][j]\n", + " )\n", + " spot_price = try_state.pools['stableswap'].spot_price('USDA', numeraire='USDD')\n", + " print(spot_price, trade_range[i][j])\n", + " if try_state.pools['stableswap'].fail:\n", + " print('trade failed, use a smaller initial value or a smaller growth factor')\n", + "\n", + " if i < len(amps) - 1:\n", + " trade_range[i+1] = copy.copy(trade_range[i])\n", + "print(trade_range)" + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[247276.40443434505, -99990.00099990002], [247647.57879376572, -96686.31486433979], [247944.91939021496, -92802.53170641157], [248217.79521216897, -90032.92489873343], [248441.28060711964, -88073.92649009275], [248664.96721939923, -86684.69418227047]]\n", + "4914.45636725769\n" + ] + } + ], + "source": [ + "test_state = invested_state.copy()\n", + "test_state.amplification=amps[0]\n", + "print(trade_range)\n", + "test_state.pools['stableswap'].swap_one(\n", + " agent=try_state.agents['Trader'],\n", + " tkn_sell='USDA',\n", + " quantity=trade_range[0][1]\n", + ")\n", + "print(test_state.pools['stableswap'].spot_price('USDA', 'USDD'))" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "246053.5617069576 -99495.52581609144\n", + "246422.9005177458 -96208.1772222133\n", + "246718.77069170662 -92343.60032862835\n", + "246990.29707550816 -89587.6899088051\n", + "247212.6772801334 -87638.37922982244\n", + "247435.25770701826 -86256.0170179487\n", + "simulation finished.\n" + ] + } + ], + "source": [ + "steps = 2000\n", + "amp_events = []\n", + "trade_sizes = []\n", + "for i, amp in enumerate(amps):\n", + " invested_state.pools['stableswap'].amplification = amp\n", + " events = []\n", + " trade_size_min, trade_size_max = trade_range[i][1], trade_range[i][0]\n", + " # trade_sizes.append([trade_size_min + j * (trade_size_max - trade_size_min) / steps for j in range(steps)][::-1])\n", + " # use a sigmoid function for a better price distribution VV\n", + " trade_sizes.append(\n", + " [(1 / (1 + math.exp(j / (steps - 1) * 12 - 6)) * 2 - 1) * (trade_size_max if j < steps / 2 else -trade_size_min) for j in range(steps)]\n", + " )\n", + " print(trade_sizes[-1][0], trade_sizes[-1][-1])\n", + " # trade to change the price of assets. \n", + " # We assume that whatever the resulting price is the new market price, and the trade is an arb trade.\n", + " \n", + " for trade_size in trade_sizes[-1]:\n", + " new_state = invested_state.copy()\n", + " new_state.pools['stableswap'].swap_one(\n", + " agent=new_state.agents['Trader'],\n", + " tkn_sell='USDA',\n", + " quantity=trade_size\n", + " )\n", + " if new_state.pools['stableswap'].fail:\n", + " print(f\"failed with trade size {trade_size}\")\n", + " new_state.external_market['USDA'] = new_state.pools['stableswap'].spot_price('USDA', numeraire='USDD')\n", + " events.append(new_state)\n", + " \n", + " for event in events:\n", + " # agent withdraws assets in equal proportion\n", + " event.pools['stableswap'].remove_uniform(\n", + " agent=event.agents['LP'],\n", + " shares_removed=event.agents['LP'].holdings['stableswap']\n", + " )\n", + "\n", + " amp_events.append(copy.deepcopy(events))\n", + " \n", + "print('simulation finished.')" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0053090963534165\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAAE/CAYAAADCGZOXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACtpklEQVR4nOzdd3gc1fX/8fdsX/XeJcu9904xzfQaIAkB0kggJKSQ9k1I8iM9IY0EAkkoISQU0zsG023Avfcq2ypWsbq02j7z+2NlWwYbr22tbPDn9TzL7o72zrmzKlhH555rWJaFiIiIiIiIiIic2GzHegIiIiIiIiIiInLsKUkkIiIiIiIiIiJKEomIiIiIiIiIiJJEIiIiIiIiIiKCkkQiIiIiIiIiIoKSRCIiIiIiIiIigpJEIiIiIkfMMIxTDcPYdKznISIiItIbDMuyjvUcRERERERERETkGFMlkYiIiMgRMAzDcaznICIiItKblCQSERER6cEwjB2GYdxiGMZ6wzBaDMP4j2EYHsMwTjcMo9owjB8ZhlEH/GfPsR5jSw3DeMYwjN2GYTQZhnFXj49dZxjGhu5zzjEMo98xuUARERGRg1CSSEREROTDrgHOBQYCQ4CfdR8vALKAfsANPQcYhmEHXgJ2AuVAMfBY98cuBX4CXA7kAu8CsxJ8DSIiIiKHRUkiERERkQ+7y7KsKsuymoHfAp/rPm4CP7csK2hZlv8DY6YARcAPLcvyWZYVsCzrve6P3Qj83rKsDZZlRYDfAeNUTSQiIiLHEyWJRERERD6sqsfjncSSPwC7LcsKHGRMKbCzOwn0Qf2AOwzDaDUMoxVoBgxi1UYiIiIixwU1XBQRERH5sNIej8uAXd2PP2pb2CqgzDAMxwESRVXAby3LeqQX5ygiIiLSq1RJJCIiIvJhNxmGUWIYRhbwU+DxOMYsBmqB2wzDSO5udn1y98f+BdxiGMZIAMMw0g3D+HRCZi4iIiJyhJQkEhEREfmwR4HXgApgG/CbQw2wLCsKXAwMAiqBauCz3R97FvgD8JhhGO3AWuD8hMxcRERE5AgZlvVRVdMiIiIiJxbDMHYAX7Us641jPRcRERGRvqRKIhERERERERERUZJIRERERERERES03ExERERERERERFAlkYiIiIiIiIiIoCSRiIiIiIiIiIgAjmM9gY+Sk5NjlZeXH+tpiIiIiIiIiIh8YixbtqzRsqzcDx4/rpNE5eXlLF269FhPQ0RERERERETkE8MwjJ0HOn5cLjczDONiwzDubWtrO9ZTERERERERERE5IRyXSSLLsl60LOuG9PT0Yz0VEREREREREZETwnGZJBIRERERERERkb6lJJGIiIiIiIiIiChJJCIiIiIiIiIiShKJiIiIiIiIiAhKEomIiIiIiIiICEoSiYiIiIiIiIgIShKJiIiIiIiIiAjgONYTOBDDMC4GLh40aNCxnoqIiIiIiIiIfIxZZhSiIaxoCCsS2vsYM9LjPgzRMJYZ7n4eib3OjIAZxoqGsacW4B545rG+nIQ6LpNElmW9CLw4adKk64/1XERERERERETk8FmWBZEA1p5bOHZPj8d7bux9How935PI6U7sxB6HsaLB2ONICDMS7L4PYYaCWNEwVjiW0DEjYaxId7LHtLAsY+8Ny8CCfY8/+LHuj/OB17uyshn0cyWJREREREREROQTxrIsCPuxwl2YIR9W2IcV6sIKd3Xf+7BCvn3P9z72YXWP2y/x84HkD5EAlsW+JIxp2y8h0/P4B5M1lmXDwo5l2bGw7UvWmEbsnKaFZR7omsAy3ViWB3PPecwe59x7ju4EkGGPxcEG2Lrj9owTu5lRi1Qrl0/6eicliUREREREREQ+RiwzihXswAp2YIY6sAIdWMF2zFAnVqA9drz747HH7VjBTqxg+74kT3eih1jNzIdjWGCZtliiZU9yx3Bj2TxguLEMJxaO7iRMLBFjml6sqAczamJFopiRCFYkcujrsQDLwLQMsLnB7sGyucFwYRmO7jjdyaLuBI8ZsTCjJmbExIxEMUMRzHAEyzxA5ugg14bDheFwg80FNicYDsCBuSdZZMaSRdGohRm2cNoKDu8T9TGkJJGIiIiIiIhIH7MsCyvUieVvxQy0YvpbsPwtmN3PrZ733cetYAdWqAMr5Dt0AJsDXKkYzhQsezKWLRnLSMey5WC57JgOAysaq5Axw5HuW4hoMIgZDGAG/R81eyAEtih2TzI2T3Ls3pWEZXdjM9yYOLFZDkzTwIwa3ckck2goihkKEwmGiAaCRPxBon4/VjR6gDjR7lsQw+HA4fFg93qxezzYUz04HB4smwsMB5blwDRtmBGIRsAMm0TDJtFglEgwQiQQJtIVIuwLEA2GD3JdkdjNMHAmuXGmeHEmuXGlenEkuUgb3P/Q7/vHnJJEIiIiIiIiIkfJMqOxJI+vEbOrEdPX1H3fiNnV/birKZYE8rdgBdrAPHiVjeFMwvBmYPNmYvNk4MgZDO40MNyYlhPTtGNFIRrpTvIEQ0SDAaL+LqJdnUTa2oj6WmM9eejovn0ghsOJPSmt+5aBKysNe1Iq9qQ0bN4UcHixTDvRMERDUaKhWLIlGggR8QcI+7roam8nXN9BuKODaKDpoNdjc7txJifjSErCkZyMJzcLR3Jy7FhyMja3B8tyEI3aMMMQCUYJ+yNE/GHC/jDhDj/BNh+hFh/B1k5CHV1Y5oGTZYbdhis1CVdqEs4UD57MNJwpblxJLpwpLpzJTpweB2AQDVtEQiZhf5RIIErIFyHUGcHfGsLfEqKtJkKgNYK/vZP+jdWMv+kwvzA+ZpQkEhERERERETkAy7Jiy7U664l21GF21mN21BHtrP9QMsjqauaAS7cMG7akbGxJOdiSsnDkDsPmzeiRAMrEcqZgRY1Y5UsoQtTvJ9LRQqStiXB7I5H6RiLtVUQ6WzlgIx7A5knGkZKJPTUDZ3Yx3vKRsefJGTiS02PJn+Q0cHiJBiNEghFCHT7CbW2EWlsJtbYSbGkltL2VUGstodZWzPCBK24cSUk409JwpqbiysggubQEV4oXZ7IbZ5ILZ5ITZ5IDp9eBFY0S9oUItPoItPgItPgJtAbw7Q4Q2NJOoD1MoC1CyHfgZW92h4U72cSVFMXtDZOREsadG8LlCeL2BHB7/Lg9flxuP263D8wwIb+Drg4PXe0efJ0pdLWk4KtMobEzla7OFHwdKXT5krFM+4c/XYaJJ6kLb7IPb1IXWck+vDmx5zkjCoCvx/nV8/GkJJGIiIiIiIiccCzLjCV/2qox23YR7dyTBKqPJYE6aol21kP4w8uuDHcqtuRcbEk5OLIHYiudgi05J5YISt6TEMrGlpyDZXMTbt1NuKWOcHMdoZZ6QrvriLTtIty2ikh7I1Ff+4cnaLPjSM3CmZ6NMzM/lvRJzcSRkokjJQN7Svfj1AzsyRnYnC4ifj/BxkYCTU0EGxvpamogWFVPsGk9gaZmgs1thH0HWEZmgCvJgSvZhivZIDkPXP3A5TFweboTMi4/TlcXTocPm+XHDAUIdEBXmx1/cxJdlcm0+lLo6kzG70umqzOWiDGjH047OJyhWCImyU96Uhf5WV14kvx4koN4kiN4UyJ4Ukw8qeDw2MHuxjJcBAPJdLan0dGSQkdrOs2tXjp3eOhocdHZ5KSz2UHIb/vwW+mApAxIzrKRXGojL9tOUpaDpGwnSVkuknPcJGW7Scry4E73YDhiS9iwOffdDAc4047kS+1jRUkiERERERER+cSxIkGi7bsw22uIttUQbasm2l7dnRSqIdq+C8wPVMo4PNhTC7Cl5OMoGIM7tQBbaj62lALsKfnYUvOxpxRguJL2Don42gjtribUtItwSz3hik2EW+YSaqkn3FxH1Ne2fwzDhiM9B2dGHu68UpIHjY89T8vBkZqGM8mNw+vE4QIj0gHhdgi1QbidSHsD/saN+KvaCbR04W8J4W+L4G+DQKeNaPjDCRKnK4jH68fj9ZOR5++uvgng9vpxuYN7b4YB2D1g94Ldi2nz4u/KwNeRRltDCp1tOfha3fhaXXS22PG3xZo692RzGiRlukjKdpM9IInSnCSSclJJykvDm5OKJysDT046Dm9yrFm03R272VxYhpNAa4C2ylaaKltpr2qjbWUr7VWxxx21HUT8+3++DJtBcl4KKYWpZI1NpV9hGilFqaTkp5Kcl0xSbjLJuSm4MzwYxv5zlQMzLOvAJV3Hg0mTJllLly491tMQERERERGR45AV6iLSuoNo8w6iLbFbpGU70ZYdmO217L/8y4gledJLsKUVY08vwd7j3pZagOFJ/1AywTJNwm27Y4mgxmpCu2ti943VBHfXYPr37/Vjc3txZmTjSkvFmZIUW3rlNXB5ojidQZxOP0akPZb8CbdBaN9jKxomFHTHqnC6b/6uJPxdSQR8yYTDrv1i2R0mntQo3jQDT7odT5oLT4YXd0YS7sw03BkZ2L2p4EwBR3L3LQWcsfuo6aazPkj7rnY6qlvoqNpN564mfLua8NU1Y0V7LG0zDJJy00kuyia5MJvkgiyS8jNIys0gKT8Db14m7vTkj0zGmFGTjpp2Wiqaaaloom1HK21VsURQW2UbYV9ov9d7Mr2kl2WQVpJOanEaqYVppBSmklKYSmpRGsl5KdgcH06MyaEZhrHMsqxJHzyuSiIRERERERE5bllmlGjrTiKNW4g2biHSvG1vUsj0Nez3WltSDvasclz9TsKe0Q97ejH2tBJs6SXY0wox7K6DRAEz6CdQtZFA3Q6CddsJ1m4jWLedUHPd/tu4GwauFCeuJIOM/CgudwS3sx2nvQWXvQ274wO7dIW7b+0GuDLAlUGEDLq6MujqKMPX4aarzUFXi0lXc5hoaF9ixuaw48nJwFuWS1pePt6CYrwFRXjy8vDm5+NMTT1khYxlmvjqWuiobKC9sp6Oyrruxw34apu795+P8WSlklyUQ/bIfpSdPYGUohySC7NIKcomKT8Tu8t5qE8XlmXhb+6KJYK2NdNS0UxrRRPN25pp29FCNLTv/XEmOUkryyC9NIOSk/qRXpoRSwqVZpBelo4rxX3IeNK7+ixJZBjGZcCFQBrwb8uyXuur2CIiIiIiInJ8s6Ihos3biTRuJtK4pUdSqAKiwb2vs6XkY8/sj2vQmTgyy7FnlmPP7I89sx82d+pHBLAg1E60ZSuBHSsJ7NpMsKGaYFMjwZYOwl09lzJZe5dlpeYEcHliS7Lc7iBOr4XhyQZ3FriywF0GrszY873HMsGVRZRUfE0hOmvb6dzViG9LFZ2VlQSbeuwCZovizc0iqaiIjIlFJBXtu3lycjBs8VXKWJaFf3cbrdt20Vaxi7ZttbHH2+uIBvZV6DiSPaSV5pEzqj/9L5hKWlkeqd03V4o33k8XAIG2AE2bd9O0cTdNm3bTuDF2C7Ts63tkc9rIKM8kc0A2A2YOInNAFhkDssgckEVSzkdXHknfO6rlZoZhPABcBDRYljWqx/HzgDsAO3C/ZVm39fhYJvBny7K+cqjza7mZiIiIiIjIJ4/Z1Uy4fh2RhnVE6tcRqV9PpGlrjy3hDewZpdhzBuPIHowjZwiOnMHYswdh8xygeXDYB1014N8FXbGb1VVDaHcVgYY6Ak1tBNrC+DvdhEP7qlMMWxS3N4gnGdzpbtwZqbhzcnFlF2FLKQB3LnjywNN9782LLdf64JI0yyLQ0EB7RQWd27fTWVlJZ2Ul/rq6vZU6NqeT5NJSksvKSCktJam4OJYMKijA5jx0hU5P0WCY1m27aN5YSeuWGlq37qK1Yhfhjn3JGU92GhkDi0gfUEj6gMK9ySBPdtphJ2bMqElLRTMNq+vYvaGBpo0NNG7cTWftvqV2rhQX2UNzyR6WS/bgHDIHZpM5IIu0knQtCTsOHWy52dEmiWYAncD/9iSJDMOwA5uBs4FqYAnwOcuy1nd//C/AI5ZlLT/U+ZUkEhERERER+XiLtu8ivGslkfq1scRQ/TrMjtq9H7elFuDIG4EjfwSOnKGxhFD2QAxnd1WLZUGgAXyV0Lkzdr/f451YgSZCAQ9dvmT8ncn4u5IJdHkx92xxboA7zYsnNwdPQSmekqF4SkfjLBiB4c78UNLno1iWhb+ujo6KCtq3baOjooKObdsId3bGQtlsJBUVxZJB3bfksjKSCgow7B/ecv1QIoEQrVtqaN5YSfPGKpo3VtJWUbu3X5Az1UvGgCLSBxbGkkLdiSFPRsphxwIwIybNWxtpWFNP/ZraWGJoXf3eSiu7y07WoGyyh+WRMyyX7KG55AzLJbX48JNPcuwkpCeRZVnzDMMo/8DhKcBWy7IqugM/BlxqGMYG4DbglXgSRCIiIiIiIvLxYgY7iNSuIrxrBeFdKwnvWonZWRf7oGHHkTMYV7/pOPJG4sgfgTNvJLbk7FglUMe22K3xFdi+FToqwLcTOivB3LfczLIgYmbQFSnD78+gq30s/mY/ZihWhWRzufGUDCGzZBieksF4SobgKRyAzeU5omsKtbfTvnkzrRs30rZ5Mx3bthHp6opdksNBSlkZedOnkzpwIGkDB5JcVobddfDeRx/Fsiw6KhvYvbqCxtUVNK7dQfuOur0JIXdGClnDSik+eRSZw0rJGlZGcmHWUSVnfA2d1C6rYdfSamqX1dCwpo5IIPZeOrxO8kblM/KqseSNLiB/dAFZg3NUGfQJloieRMVAVY/n1cBU4FvATCDdMIxBlmX960CDDcO4AbgBoKysLAHTExERERERkaNlWRbR1p2EKxcRqlpEuGY50aat7NlRzJ7VH1f5STgLx+MsGocjqxyjazu0b4H2rVDzH9i4FTq2gr9u/5O7syF1IGSNxyq5hGAwHV9TBF9tE11VFYRbG2Ovs4XwlvQjY8oIvOUjSeo3AndBOYbt8Ct2oLvJc00NbRs30rZpE60bN9JVUwPEKoRSysvJP+UU0gYOJHXgQFLKyg57qVhPEX+QpnU7aVxTwe7V22lcs51Quw+IVQjljOpP6eljyRxaStbwMpLyMo4qIWRGTRo3NMQSQktr2LWshvbKViBWIZQ3ppDR144nf0wheaPzyRyYjc2uhNCJpM8aV1uWdSdwZxyvuxe4F2LLzRI9LxERERERETk0yzKJNm4hVLkwlhSqXLS3SsjwZuAsnohnxKU48wbh9LqwBSqhbQO0PQk7fxlbGtaTtwjSBkHx+ZA6KPY4dSBWUjn+ul34tq7Et2ElXdtWEu1qB8CRnkPywHEkDRhLUvkIPCVDsDmPfAcsy7LwVVfTsmYNzWvW0LpuHeGOWJ8dZ2oq6UOHUnjGGWQMHUraoEHYPUdWjbRHJBCicc126pdtpn7pZprW7dhbJZTWv4CS08aQO2YAOWMGkNYvL+6m1Qe9PtNi9/oGqufvpGr+TmoWVRJsj1VlJeenUDixmHFfmkjhxGLyRhfgcGsD9BNdIr4CaoDSHs9Luo/FzTCMi4GLBw0a1JvzEhERERERkcMQbasmWDGX0Pa5hHbOx/K3ALEdxpwlk3HllOBKcmCP7MJoWwu75kBFj23p7V5IHwp5p0D6cMgYDmlDIXUAOJKAWKIm1FBJ58bFdG6cRefmZZiBWDWNK6+MtHGnkzxwHMmDxuPMLjrqvjddtbU0r1lDy5o1tKxdS6i1FQBPbi45kyeTOXIk6UOHklR09LHMSJSm9TupW7KJ+qWbaFyzHTMUwbAZZA0vY/g1Z5E7fhA5o/rjTk8+qlgQey9bK5rZOW87VfN3Uj2/kkBrrJl1Rnkmgy8eTun0fhRNLlEPITmgo2pcDdDdk+ilHo2rHcQaV59FLDm0BLjasqx1h3tuNa4WERERERHpO2awk3DlfIIV8whtn0u0uQKIJYVc+YNwpXpx2juwd23E6NgMVjQ20JEMGaMgY+S+ZFD6CEjpB8aHq2GiXR10bFhI58ZFdG5YTLglVpHkzC4kZdhUUodNIWnQeJxp2Ud9TdFQiNZ162hcvpymZcvoqo01zXZnZZE5ahSZo0eTNXo03vz8o44F4G9qp3bBenYtWE/twvWxHccMg8whJeRPHEz+pKHkjRuI8zC3mz+YsD9M9fyd7Hh7G9vf2kbbzlYAUovTKD25nNKT+lF6Uj9Siw+wK5ycsBLSuNowjFnA6UCOYRjVwM8ty/q3YRjfBOYAduCBI0kQiYiIiIiISOJFW6sIbp5DYMscwlVLwAyD3YUru4ik8nJcVhX28AqMwAoIAMmlkDkWyq+I3WeNi1UGHSAZ1FOosYb21fNoXzMP39aVYEaxeVNIGTKJ3HO+QMqwqbhyS3qluiXQ2MjuJUtoWr6c5jVrMINBbC4XmaNGUXLhhWSPG9crlUIQq95p3lBJzbtr2PX+Opo3xpbVebLTKD19LEXTR5I/eWivVArt0VHTztY5m9jx1jaqFlQSDURweByUnlzOxBum0u/0AaT3O7r+RXJiOupKokTosdzs+i1bthzr6YiIiIiIiHxiWJZFpG4Nwc1zCG6ZQ6RhAwD2pGTc3ghuYxdOVzC2K3zKAMiZAjmTIWs8ZI0Fd1bccfw71u1NDAVrY1VJ7sIBpI2eQeroU0jqNwLD3jtdULpqa2lYuJCGBQto7/490pufT/bEieRMmEDmqFHY3Ufev6gnM2rSuKaCqrdWUvXOSrrqWjBsBtmj+lN00kiKTh5J5uDio+4p1FPrjha2zN7I1tmbqFuxC4CM/ln0P3Mg5WcOpGRaGQ6PegpJfA5WSXRcJon20HIzERERERGRo2dZFpHalQTWPkNgw/OYviYAnJ4oblcnbm8AR0pWLCGUPXlfYsiTc9hxAlWbaF32Gm3L3yTcXAs2O8mDxpM2ZgZpo0/FlVPca9flq6mh/r33aFi4kM4dOwBIHTiQvOnTyZsyhaSS3qlMgtjOZw0rtrLz9WVUz11NoKkdm9NBwdRhlJ05juJTRuPOSOmVWHu0bm9m43Pr2Tp7I7vXx3o95Y0pYPAFwxh0/lCyBh39cjw5MSVkuZmIiIiIiIgcvyL16wgs+xeBzW907xBm4fYEcGcEcOeWYCueAXmnQv6pkNIfjjChEti1LZYYWvYGod1VYLOTOnwa+RfdQNroU7En9V4/nFBrK3XvvUfd3Lm0b90KhkHGsGEM/vKXyZs2DW9eXq/FAmjdtosdryxmx6tL6Gpoxe5xUXTSSErPHEfxSSN7rbfQHl1NPja/uIGNT6+jdnkNGFA0uYTTfj6TQRcMJa0kvVfjifR0XCaJtLuZiIiIiIjIEbAsonWLCCy5m8C2BUT8fsDC5Q6RXJyLe9Dp2IrPiiWFvEfXqDna1UHr0jm0LHgRf+UGMGykDJ1E7tmfJ23s6ThSMnrlkiDWfHr3okXUvvMOzStXYpkmqQMGMPhLX6Lg1FNxZ8W3BC5egZYOts9ezI5XFtOyuRrDbqNw2gjGfftTlMwYg8Pj6tV40VCUba9tZv2Ta9j5TgVmxCRneB6n/uxMhl02kpTC1F6NJ3IwWm4mIiIiIiLycRbpwqp5jdCq/+DfvoygzwQMnB4DT+kI3KOuwt7/UvAc/dIkyzTxbV5K84IXaF81FyscxFM8iMzpl5A+8exe2Y2sJ191NTWvvUbt228T7uzEk5tLwYwZFMyYQUpZWa/GsiyLhmVb2PLse1S/vRIzEiVrRD/6nz+FfmdPxJPV+4ma1p0trH10JeseW0VXYxcpBakMu3wkwz41itwRvVsRJdKTlpuJiIiIiIh8UvjroOololufwl+xGH+nC9O0Y3M6SBo8Fe/kr+Pod9YRLx/7oGhXB80LXqB53lOEGmuwJ6WROf0SsqZfjKd0aK/uomWGwzQsXEj1nDm0rluHYbeTO3UqxeecQ9bo0b3aDBog2NpJxcuL2Pbc+7TvrMeZ6mXwlTMYdNnJpA8o7NVYAGbEpOL1Lax+eAU751ZgGAb9Zw5izLXj6Xf6AGz23r0+kcNxXCaJtNxMRERERETkAzq2w47HsXY+Q3jXKrp8yQT9XsCLq2Qs3slfxz3kPAy7s9dCBmq20jTvSVoWv4IVCpA0cCz5F99I2tjTsTl7Z6ewPULt7VS/+irVs2cTamvDm5/PoGuvpfCss3BnZPRqLID2nfVsnPUW219eRDQYJmd0f6bd+nnKZk7o9eVkAKHOIGtnrWLF/Utor24jpTCVad87lVFXjSW1qPd6NokcDS03ExEREREROV75qmDHE7D9cazGJQT8XroCeUT8YQxXCt7x15A08UvYM3pv6ZVlWfg2LaHhtf/i27QEw+kmY/K5ZM/4DN7SIb0WZw9fTQ2VL75I7dtvY4ZCZE+YQNlFF5E1dmyvVw1ZlsXuldvY+MibVL+7BpvDTvl5kxl61RlkDu69Xdd66tjVzooHlrL2kRUE24MUTy1lwg1TGDBzMDaHqobk2NByMxERERERkY+DYAtsnwXbH4WG97Es8FtD8bUOwfR3Ys/pT+pp1+EddQWGK6nXwlqmSfvqueye8yD+yg040nMouPQmMk+6tFebUO/Rvm0b2598kt2LF2NzOCg47TTKLrmElNLSXo9lWRa1C9az5v7ZNK3dgSstmZFfPpchV87Am5OY3cJad7aw+M75bHhqDZZpMfjCYUz82lQKxhclJJ5Ib1CSSERERERE5Fgzo1D7Bmz9D1Q+B2YQM3UE/tTL6dq5CdPfgrNkMmknfQvXwDN7tQeQZUZpXfIqu+c8SLB+J67cUoqv/gkZUy7A5uz9ZVft27ZR8fjjNC5ZgiM5mf5XXknJBRckZEmZZVnsmr+ONffNpnn9TpILs5j0f59lwEXTErKkDPYlh9Y/uRqbw8aYz49nwg1TSS/LSEg8kd50XCaJ1JNIREREREROCJ07YPN9sO1/0FUN7iysgdfR5UvHt+Z5rMBCXANOJ/mkb+Mqm9qroS3Lon3l29S/dA/Buu14igdTet1vSR9/JobN3quxADq2b2fbo4/SuHQpjpQUBlx9NWUXXIAjObnXYwHULd7Iyn+80J0cymbKT66m/4VTsTsT82twx652Ft7+LuueiCWHxn5pIpO/MZ2UAm1fLx8f6kkkIiIiIiLSlywrVjW08S6ofil2rOg8rP6fx9/cgW/+3Zi+3bgGn03KKd/DWTiml8NbdG5cRP0L/8BfuRF3fnmsGfW4M3q1QmmPQGMj2x59lNp33sGRnEy/Sy6h9MILcST13lK5nlq31rDi789Ru2A9yYVZjPzyeQlNDoU6gyz9x0KW3bMIy7QY/fnxSg7JcU89iURERERERI6lUDts+y9svBvaN4EnF0bdgjXkBoI7V9A55zairZU4S6eSfsV9uEom9/oUAnXbqX3qdjo3LMKZXUjJ528lY8r5CakcinR1seOZZ6h88UWwLPpdeinlV16JM0GVQ127W1lzz8tUvLQAR7KH8d/5FEM+fRp2V+/t9taTGTFZO2slC/48j67GLoZeNoKTf3w66aUZCYkn0heUJBIREREREUkkfx2s/xts+ieE2yFnKpzyEJR/mnDjVjqevZlw1SIceSPI+OxDuAb0fkVPtKuD+tn30TT3SWxuL4VXfJesGVdic/R+AsWyLOrmzmXLgw8SamujYMYMBl5zDd68vF6PBWBGomx67G3W3PcyZjjKkM+ewajrzsOdnphkFMCuJdW8ecsrNG7YTfHUUi598DNqSC2fCEoSiYiIiIiIJEL7Nlj351gzaisM/a6EEd+H3CmYXc10vv4L/CsexvBkkHr+H/GOvarXK3os06RlwQvUvfAPor42sk6+jPyLbsSRmtmrcfborKpi4z330LpuHWlDhjDuZz8jLYG9Znev2sbi2x6jbdsuik4ZxcTvXUlqSW7C4vmbu3jvd2+zdtYqUovSuOi+yxl0/tCELNMTORaOyySRGleLiIiIiMjHVtsmWPVL2PE4GA4Y9CUY+QNIG4xlWQRWP07Hm7/CCnTgnfglUk79PjZvRq9PI1i/k5pHf4dv6wqSBo6j6NM/wFs6pNfjAESDQSoef5zKF17A7vUy/Otfp2jmTAybLSHxQh1dLP/bM1S8uICk/ExO/eMNlJw2JmHJGsuy2PD0Wub+4g2C7QEmfn0a0757Cq7kxOyQJnKsqHG1iIiIiIhIb+jcGUsObfsv2D0w9CYY8V1IKgQg2lZN+ys/IlTxDs6SyaSe93ucecN7fRpWNMLuNx+h4eX7MJxuCi//DpnTL05YAqVt82bW3XknXTU1FJ55JoO/8AVc6ekJiQWwa8F6Fv32EQJN7Qz73JmM+ur5OJM8CYvn293Jmz96lW1zNlM4qYSZt51HzvDELJ0T6StqXC0iIiIiIpII/npY9WvYci9gg2HfhtG3gDeWSLAsE/+y/9L59u8ASD3nt3gnfgHD6P0qm0Dddqoe/DmBqo2kjTuTos/8AGd6Tq/HATDDYSoef5wdzz6LOyuL8T//OdnjxiUkFkDYF2DFnc+y9dn3SOtfwIw/3kD2iH4Jiwew+aUNvPnjVwl3hZjx/85i/PWTsdkTUx0lcjxQkkhERERERORIRIOw4Q5Y/RuI+GHwdTDmZ5Bcuu8lnfW0v/AdQjvexdX/NNIu+CP29JJen4plWTS/9wy1T/8Nm9tL2fV/IH3cGb0eZ4/OqirW/uUvdO7cSdFZZzHky1/GkaBdywAa1+3g/Z8+gK+2meHXnsWYr12M3Z2YXcsAQr4Qb/74VTY+s5a8MQWcd8fFZA9JXK8jkeOFkkQiIiIiIiKHw7Kg6nlY+gPo2AYlF8Gkv0D6/v1+glteo+2l72NF/LHG1OOuTsiSr0hHC9WP/IaONe+SMnwaJZ+/NWHVQ5ZlUfvWW2y8914cXi/jfvpTciZ9aMVKr8bbNOttVvz9WZLyMph5z83kjUts79rGDQ289LVnaN3ewrTvncKUb5+M3dm7DcVFjldKEomIiIiIiMSrbTMs+gbUvgnpI2DmHCg+Z7+XWJEAHW/+Gv+yB3HkjyT90n/gyElMYsO3dSWVD/yEqK+Nwiu+S/bpn01Ys+iI38/Ge+6hbu5cMkePZtTNN+POykpILIBgm4+Fv36ImnlrKJkxhmm3fh5XWlLC4lmWxbrHVvHWz17Dnebmisc+R+nJ5QmLJ3I8UpJIRERERETkUKIhWPenWO8huwem3AlDvw62/X+lirbV0Pr0V4nUrSZpyg2knP5jDIe716djWRZNc5+g9um/4couovwbf8NbkpidywC6amtZ9fvf46upYcBVV9H/yisx7Imrrmndtot5P7iHrvoWJnzvSoZ+9vSEbjMfDUd5+2evsebhFZSeUs75d11Ccm5KwuKJHK+OyySRYRgXAxcPGpTYMkIREREREZFDalgAC26A1rXQ79Mw5Y69O5b1FNrxPq3P3ghmmPQr/4NnyDkHONnRM0MBamb9ntbFr5A6+lRKv/AL7EmpCYkF0Lx6NWv+9CcAJvz852SNGZOwWAA1767h/VsfxOFxMfOe75Izun9C4/mbu3jphmeoXlDJ5G9O56T/O03NqeWEdVwmiSzLehF4cdKkSdcf67mIiIiIiMgJKhqElbfC2j9BUjGc+QKUXvyhl1mWRdeS++l889fYswaQceX9OLIT8wfvcHsTO//1ffyVG8i76GvknfvlhC0vA6iaPZvN//43ScXFjL3lFpIKP5wc6y2WZbHhoTdYeffzZA4t4bQ/fY2k/MyExQNo2ryb57/0JJ11HZz390sYfvmohMYTOd4dl0kiERERERGRY6plLbx7LbSsgsHXw+S/gPPD1TqWGaXjtf+Hf/l/cQ85n7SL/4bNnZhlSoG67ez4x81EOlrod8OfSBszIyFxACzTZMt//0vlCy+QM3kyo26+GUdS4voBmVGTpX96nK3PvEfZzAlMu/XzODyuhMUDqFlcxfNffAK728Gnn7yWwonFCY0n8nGgJJGIiIiIiMgelgnr74Dlt4Ar/aDVQwBWqIvW579BaMvrJE37Biln3IJhJKaqp3PLcnbe80NsDicDbv4XSf1GJCQOgBkOs/6uu6ibN4/SCy9kyHXXJbRaKRoKM//W/1L11gpGfOFsxt50aUL7DwFUvL6Fl258lrTiNC6f9TnSitMTGk/k40JJIhEREREREYBgC7z3Rah+EUovgen3gTfvgC81fY20PPFFInWrST3ntyRN+lLCptW26h2qHvgprpwSyr/xV1zZRQmLFfH7Wf3HP9K8ciUDr72W8ssvT2jCJtzpZ97/3Uv90s2M/87lDL/mrITF2mP9k2t47fsvkTeqgMse+gxJ2ckJjynycaEkkYiIiIiISNNyeOdK6KqO7Vw27JtwkORItKOWlkc+S7S9hvQr/p2wBtUArctep+rBW/H2G07/b/wNe1JawmJFfD5W/OpXtG/dyvCbbqJ45syExQIIdXTx1jf/Tsvmaqb/4gv0v2BqQuMBrPrvMt76yRxKT+7HJQ9ciSul93eeE/k4U5JIRERERERObFsegIXfAE8unDcPcqcd9KXRthpaHv0Mpq+RzM/NwlU6JWHTalnwEtWP/IbkgWPp9/XbsXsSV/GyN0G0bRujf/hD8qYd/D3oDaFOP2996y5at9Rw6h9voOTU0QmNB7D64RW89ZM5DDh7MBfe8ykcbv06LPJB+q4QEREREZETkxmFZT+C9X+Bwpkw49FYouggIi07aXn0M1iBdjI/Nwtn8YSETa35vWepmfV7UoZNpd/X/oTN5UlYrA8liKYmtqIn3Onn7W/fTevmak657at9kiBa+9gq3vzRK/Q/c6ASRCIfQd8ZIiIiIiJy4gl3wLyrofolGPYtmHw72A7+61G0tZKWh6/AivjJvPpxnIVjEja1lsWvUvPYbaSOPJmy62/D5kzckqhoMMiK3/ymzxJEkUCId777D5o37OSU33+VkhmJex/32PjsOl7/wcv0O30AF913hRJEIh/huPzuMAzjYuDiQYMGHeupiIiIiIjIJ42vGt68EFrXwdS7Ydg3PvLl0c56WmZ9DivsJ/OaJ3Dmj0zY1NrXvEv1Q78kedAEyr76+4QmiMxIhNV/+hNtmzcz+gc/SHiCyIxEef+nD7B79XZO+e11lJ4+NqHxAHbO286cm1+kZFoZl9x/BQ7PcfkrsMhxI3H7GB4Fy7JetCzrhvR0bUMoIiIiIiK9qG0zvHIydG6Hs2YfMkFk+ltonXUNZmcDmZ99KKEJos7NS6m8/xa8pUPpd+OfE7rEzDJNNtx9N03LljHsa18jf/r0hMUCsCyLJX94jJp31zDph5+hbGbilurt0bC2jhe/+jRZg7O55IErcXidCY8p8nGnNKqIiIiIiJwYmpbDG+fFHp/7DmR/dKLCCvtpfeKLRJq3kfGZ/ya0B1GgtoKd9/4frpxiyr/xt4Q2qQbY+vDD1L7zDgM+9zlKzknc7mx7rLnvZbY9P5+R153HkCtnJDxeW1Urz37+cTwZHj710FW40xKXcBP5JDkuK4lERERERER6Vd08mHMG2L1w3nuHThBZJm0vfJtwzXLSL70bd//EJTYiHc3s+Od3sTndlN90B46UjITFAtj11lvsfPZZis89l/6f/nRCYwHsmLOUtfe/woCLpzPmaxclPF7IF+L5Lz1JNBjlU49cRUphasJjinxSKEkkIiIiIiKfbHVzYxVESUVw/vuQPuSQQzrf+QPBTbNJmXkrnmEXJGxqZijAjnt+QKS9mX43/gVXVkHCYgG0btzIhn/+k6wxYxh6/fUYhpHQeM0bK1n0m4fJHTeQyT++KuHxLMtizs0v0ry5kQv/9SmyB+ckNJ7IJ42Wm4mIiIiIyCdXw/uxJtUp5bElZt68Qw7xr3qcrgV34R1/LUmTr0/Y1CzLovqR3+Lfvpay6/9AUr8RCYsFENi9m9W33YYnN5fRP/gBNrs9ofH8Te3M++G9uDNSOPW267E7E//r5+I73mfr7E3M+H9n0W9G/4THE/mkUSWRiIiIiIh8Mu1eBG+cD0nFcM6bcSWIQtVLaH/lR7j6zyD1nN8ktPKlae4TtC2dQ/7FN5I+7oyExQGIhkKsuu02ouEw4265BWdqYpdgmZEo791yP8HWTmb86QY8WYlf8lXxxlbm/3kewy4fxYSvTUl4PJFPIiWJRERERETkk6dpBbx+Lnjy4Jy3IKnwkENMXyNtz96IPb2Y9E/9C8OeuN2wfBWrqXvmDlJHn0ruOV9KWJw9tjz4IB0VFYy6+WaSS0sTHm/NfbPZvXIbU356NVnDyhIer7O2gznfeZHcEfmc/cfzE76sTeSTSsvNRERERETkk6VzB7x5AbjSYgmi5OJDDrHMKG3P34TpbyXri89j86QnbHqRjhYq//0TnJn5lH7h5xi2xP7tvn7BAqpfeYWySy8ld/LkhMYCqFu8kXUPzmHgJSfR/7zEV/SYUZNXvvU80VCEC/95mba6FzkKShKJiIiIiMgnR6AJXj8PooHYErOU+KpYfO/+hdCO90i78C8480clbHqWaVL131uJdrZS/oN/Y09KS1gsgK66OjbcdRdpgwcz6JprEhoLINDcwfyf/5e08nwmfv/KhMcDWPL3+VQvqOSc2y8ic2B2n8QU+aTScjMREREREflkiPjhrYtjlURnvgAZ8TWCDm6fh+/9O/CM+SzesVcldIpNc5+kc8MiCq/8Lt7SoQmNZUajrL39djCMWKNqZ2IrbCzLYsGv/keoo4tTfnsdDq87ofEAdi2pZsHt7zL0shGM+MzohMcT+aTrsySRYRgDDMP4t2EYT/VVTBEREREROUFYFrx/HexeCKc+DPmnxjXM9LfS/tJ3sWcPIu3c3yZ0ioHaCuqev4vUUSeTdcrlCY0FsPPZZ2nfsoXhX/863rxDN+0+Wtuen0/t/PVM+M7lZAw69BK/oxX2h3n15hdJLUrjrN+fpz5EIr3gqJJEhmE8YBhGg2EYaz9w/DzDMDYZhrHVMIwfA1iWVWFZ1leOJp6IiIiIiMgBrf0D7HgMJvweyuNf5tQx56eYvkbSL7kTw+lN2PTMSJiq//4Cm9tL8dU/TXhCo3PnTioef5z8U04h/+STExoLwFffwvI7niF/4hAGXxFfgu5ozf/DXNp2tHDOXy7Enebpk5gin3RHW0n0IHBezwOGYdiBu4HzgRHA5wzDiK/OU0RERERE5HBVvwzLfwLlV8Go/4t7mH/dcwTWP0fyKd/FWTg2gROEhlfuJ1C1keLP3YIzPSehscxIhHV33okzOZmh11+f0FgQW2a2+HePYkVNpv7smoQ34obYMrPl9y9mzOfHU3pyecLjiZwojuq717KseUDzBw5PAbZ2Vw6FgMeAS48mjoiIiIiIyAG1bYJ5V0PWODj53xBnhU60o5aOOT/BWTyB5JO+mdAp+qs2s/u1/5Ex9ULSx52R0FgAO555ho6KCobdeCOutMQ2xgaoeGkhtQvWM+6mS0kpTmwCDCASiPDa918itSiNU392ZsLjiZxIEpHiLQaqejyvBooNw8g2DONfwHjDMG452GDDMG4wDGOpYRhLd+/enYDpiYiIiIjIJ0LED+9cCTYXnPEcOJLiHtox5/9hRYKkXXwHhi1xmz5bZpSaWb/DkZxO4RU3JyzOHr7qarY/+ST5p5xC3rRpCY/nb2pn+V+fJnfcQIZ8ekbC4wEs/edCWrY1M/OPF+BKSXxzbJETSeJ+Gn6AZVlNwI1xvO5e4F6ASZMmWYmel4iIiIiIfEwt/g60roWZr8a91T1AYPMcgptfIeX0W3BkDUjgBKFp3tP4d66n9Eu/wpGcntBYlmWx6b77sLtcDPlK37SDXfn354gGQkz9ad8sM2urbGXxXfMZfNEwyk9P7OdO5ESUiO/iGqC0x/OS7mNxMwzjYsMw7m1ra+vViYmIiIiIyCdExSzYch+M+jEUnxv3MDPYScecn+LIHU7S1K8lcIIQbm2g/sV/kjJ8KumT4p/jkWqYP5/m1asZeM01uDMyEh5v96ptbJ+9iGHXnEVav/yExwN459bXsdkMTvv5zD6JJ3KiSUSSaAkw2DCM/oZhuICrgBcO5wSWZb1oWdYN6emJzbSLiIiIiMjHUPtWWHAD5J4E4391WEM75/4Rs6OO1Av+gGF3JmiCMbue/AtWNELRZ3+U8N3MIn4/mx94gNQBAyg5N/EJKTMSZckfHycpP5NR15136AG9YNtrW6h4fQvTvn8qqUWJ77UkciI6qiSRYRizgAXAUMMwqg3D+IplWRHgm8AcYAPwhGVZ645+qiIiIiIicsIzI/DutWBzwoxZsfs4hWtX41/6AN4JX8BVPDGBk4TOjYtpX/k2eeddhzu3JKGxALY//jjB5maG3XADht2e8Hhbn32P1i01TLj5chzexPcFioajzPvVm2QNzmb8VyYnPJ7IieqoehJZlvW5gxyfDcw+0vMahnExcPGgQYOO9BQiIiIiIvJJtPaP0LgoliA6jD5ElmXR8fqt2JKySTn9xwmcYKxZde0zf8OZXUjOWVcnNBaAr6aGypdeomjmTNKHDk14vFCnnzX3vkz+xCGUnjk+4fEA1jyygtbtzVz2v89gdyY+CSZyokp8Z7EjoOVmIiIiIiLyIc2rYNUvoPwz0P+qwxoa3PAi4eolJJ/2f9g8iV2q1LLgRQI1Wym87FvYnImvstn2yCPYnE4GXnNNwmMBbPjf6wTbfIz/9qcSvowOINgRZOHt71F6Uj/KzxyY8HgiJ7LjMkkkIiIiIiKyn2gQ3vsCuLJg6j8Oa6gV9tPx9m9x5A3HO/bwkkuHK+rvpP7Ff5E0cCxp489KaCyA1o0baViwgH6XXdYnzaq76lvYOOst+p07iazh8VdyHY2ldy/A39TFqf/vzD5JSomcyI7LJJF2NxMRERERkf2s/i20rIaT7gdP9mEN7Vp8H2ZbNakzf4lhS+xSpd1zHiTS0UzhFd9NeELDsiy2/Pe/uDIzKbvkkoTG2mP1vS9jmRZjb7y4T+J17Gpn2X2LGfapkeSPKeyTmCInsuMySaTlZiIiIiIislfrelh7Gwz4PJRedFhDo531+Ob/HfeQ83GVn5ygCcaEW3fT+PZjZEy9gKR+IxIaC2D34sW0bdzIgKuuwuH1Jjxe67ZdbH95IUM+PYOU4pyExwNY+Nf3wLQ46Uen9Uk8kRPdcZkkEhERERERAcAyYcHXwJkKk/9y2MN979+JFQ2RcuZPEzC5/e1+/X9YZpT8C65PeCwzGmXrQw+RVFxM0VmJX9YGsPpfL+FI8jDyS+f2Sbz26jbWP7Ga0deOJ700o09iipzojsskkZabiYiIiIgIAFsegIb3YOKfwZN7WEOj7TX4Vz6Kd8xncWT1T9AEY8JtjTS//xyZUy7AlVOc0FgA9e+9R1dNDYOuvRZbH2x537q1huq5qxh61Rm4M1ISHg9g2b8WggGTbpzWJ/FE5DhNEmm5mYiIiIiI4K+HZT+E/Bkw6EuHPdw3/y6wLJJP/nbvz+0Ddr/xEFY0Qu55X054LMs02fHUU6T060fulCkJjwew7sHXcCS5GfrZ0/sknm93J2tmrWLElaNJLU7sbnQiss9xmSQSERERERFh6fch4oPp98BhNoGOttXgXzkL79jPYk8vSdAEY8LtTTS/+wwZk8/DnZvYWAANixbhq66m/MorMWyJ/5Wuo6qByjeWMfjyU3GnJyc8HsDyexdjhqJMvml6n8QTkRgliURERERE5PhT9w5UPAKjfgzpww57uG/+nQAkn5T4KqLGNx7BioTJ64sqIsti+5NPklRURP70vkmgrP/v6xgOO8OuPrNP4gVa/Kz673KGXDKcjP5ZfRJTRGKOyySRehKJiIiIiJzAzCgs/g4k94PRtxz28GhbNf5Vj+MdexX29MT2B4p0NNP07lNkTDoXd15ZQmMBNC1bRuf27ZRfcQVGH/Qi8tW3sH32IgZeehLenL5pB7LywaWEfSGmfPOkPoknIvscl0ki9SQSERERETmBbbkfWlbDpD+D4/C3dve9fycYBsknfysBk9vf7jcfwQqHyDv/uoTHsiyLiiefxJOXR8GMGQmPB7DhodexLIsRnz+7T+KFfCFW3L+UAecMJmd4Xp/EFJF9jsskkYiIiIiInKCCLbDip5B/GvS74rCHR1ur8K9+HO/Yz2FPS3AVUWcrzXOfIn3i2bjz+yU0FkDz6tW0b95M+eWXY3M4Eh7P39TOtufn0/+CqSQX9M2yr9UPLSfQ6mfKt1RFJHIsKEkkIiIiIiLHj1W/hFALTPnbYTerhu5eRIaN5JO+2ftz+4DGNx/FDAf6pIoIYPuTT+LOyqLozL7pDbTx0bcwwxFGfPGcPokXCURYds8iSk8pp3BCYhN8InJgShKJiIiIiMjxoXU9bLwLBl8PWeMOe3i0tRL/6ifwjrsGe1pR78+vh0hnK01znyB9wkw8Bf0TGgugZf16Wteto99ll2FzOhMeL9jmY8vT8yibOYG0sr5Z9rXu8VV0NfiY+m1VEYkcK8dlkkiNq0VERERETjCWBUu+C44UGP/rIzpF5/t3gGEn+aSbenlyH9b49izMkJ+88/qmimjHU0/hSk+n+Jy+qerZ/MQ7RLqCjPzSuX0SLxqOsvQfCymcWEzJSYlfuiciB3ZcJonUuFpERERE5ART/TLseg3G/QI8uYc9PNKyk8DqJ/GOvwZ7amHvz6+HaFc7Te88Qfq4M/EUDUxoLIC2LVtoWrGCsksvxe52Jzxe2Bdg0+PvUDxjNBmD+mbZ18Zn19Fe3caUb52EcQTLDEWkdxyXSSIRERERETmBREOxKqL0YTDsyKqAfO/fAXYnydP7oIrorccwAz7yzv9KwmNBrIrIkZJCyXnn9Um8Lc+8S6i9i5Ff7pt4ZtRkyV3zyR2RR/+Zg/okpogcmJJEIiIiIiJybG24Ezq2wqTbwXb4/XYizdsJrHmKpPHXYE8tSMAE94l2ddD4zmOkjTsDT3HiExodO3awe/Fiyi66CIfXm/B4kUCIjY+8ScGUYeSMLE94PICtr2yiZVszk1VFJHLMKUkkIiIiIiLHjr8BVv8aii+AkvOP6BR7qoiS+qKK6O3HMP2dfVpFZPd6Kb3wwj6JV/HiAgLNHYz8ct/0IrIsiyV/n0/mgCwGXzisT2KKyMEpSSQiIiIiIsfOip9BpAsm335EwyPNFQTWPk3ShM9jT8nv5cntL+rvpPHtx0gbexrekiEJjQXgq66mfv58Si+4AGdKSsLjRcMR1j/0OjljBpA3YXDC4wHseGsbDWvrmfzN6djs+vVU5Fg7Lr8LtbuZiIiIiMgJoHklbLkfhn0T0oce0Sl87/0N7C6SpiW+iqjpnccx/R3knf/VhMcC2PH009icTsouvrhv4r2ymK66FkZdd16fLPuyLItFd84ntTiNYZePSng8ETm04zJJpN3NREREREQ+4fZsee/OgrG3HtEpIk3bCKx7lqSJX8Secvg7oh2OqL+TxrdmkTr6VLylR5bQOhxddXXUzZtHybnn4uqD34vMqMn6/75O5rBSCqePSHg8gJqFldQurWbS16dhd9r7JKaIfLTjMkkkIiIiIiKfcJXPQt07MO7X4M48olP43vtrrIpo6td7d24H0DT3SaJd7eRf0EdVRE89heFw0O+yy/okXuUby+moamDkl87ts+bRi+6cT1JuMqOuGtsn8UTk0JQkEhERERGRvhUNwNIfQMYoGHL9EZ0i3LCBwLrnSJr81cRXEXV1sPuNh0kddQresuEJjQWxKqLat9+m+OyzcWdlJTyeGTVZ++/ZpA8opPT0vknY7FpSTeW87Uz82lQc3sPf0U5EEkNJIhERERER6Vtr/gCd22HK38DmOKJT+Ob9CcOdSvK0G3t3bgfQ+NYsTH8H+RclPhZ0VxHZ7ZRffnmfxKt8YzntO+oZ/dULMGx98yviwr++izc7ibFfnNAn8UQkPkoSiYiIiIhI32nbDGt+B+VXQeFZR3SKcM1ygpvnkDT1a9i8R7ZULV6RzlYa33qU9PFn4S1N/I5me6uIzjmn76uIzhyX8HgQqyLaOXc7k74xDWeSq09iikh8lCQSEREREZG+YVmw8Otg98KUvx7xaTrn/hEjKZukyYnvD7T79f9hhgLkXXRDwmMBbH/yyROiiigpJ4mxX1AVkcjxRkkiERERERHpGxUPQ91bMPE28BYc0SmCW98gtONdkk/6FjZ3Si9PcH/h1gaa5j5JxuRz8RT0T2gsgI4dO6h9+21Kzjuvb6qIIlHW3Pdyn1YR1SypilURfX26qohEjkNKEomIiIiISOJ11ca2vM+dBkOOrCrHigTpeOMX2LMHkTTxi708wQ+rffbvYFnkX9g3VURb/vtfHMnJ9P/0p/sk3uan5tFR2cC4b17WJ1VElmkx75dvklyQwpgvjE94PBE5fMdlksgwjIsNw7i3ra3tWE9FRERERESOlmXB/Osg0gUnPwjGkf0a0rXk30Sbt5N69i8x7ImtQvFtW0Xb0jnkzLwWV05xQmMBNC5fTvPKlQz4zGdwpqYmPF6wzcfa+2dTMHUYRSePTHg8gI3PrqNuxS5O+fEZqiISOU4dl0kiy7JetCzrhvT09GM9FREREREROVqb/gk1r8KkP0H60CM6RbStBt/7f8M9+BzcA07v3fl9gGVG2fXkn3Fm5pN3TuIrlqKhEJsfeABvYSEl552X8HgAa+6fTbjTz4TvXI5hGAmPF+4K8d7v3iZ/bCHDrxiV8HgicmSOyySRiIiIiIh8QuxeDEu+B0XnwtBvHNEpLMuiffYPwLJIPfuXvTzBD2t8axaBqk0UfOrb2NzehMfb8dRTdNXUMOyGG7A5nQmP17huB1uenMvAy04mY1Diq6QAFv71PTrrOjjtlzMxbIlPSonIkVGSSEREREREEsNfB+9cHmtSferDcIQVK/4VDxHaPo+UM3+GPaOslye5v0BtBfUv/ou0saeRPmFmQmMBdGzfzo5nnqHgtNPIHjcu4fGioTCLfv0wnpx0xn3zsoTHA6hdXsOyfy1i1NXjKJ5c2icxReTIKEkkIiIiIiK9L+yDty+HYDOc+Rx4co7sNHVr6Hj9F7j6n4Z3wud7d44fYIYCVP3n/2Fzeym66scJX4YV8ftZ8+c/40xLY8h11yU01h4r736Btopapvz4c7hSEl8lFfKFeO27L5FSkMqMW89KeDwROTpKEomIiIiISO+KBuDtS6FxEZz6EGSNO6LTmL5GWp++HltyNumX3oVxhA2v42FZFjWP/o7Arq2UfvFXONOyExZrT7yN//oXXXV1jPre93ClpSU0HkDlWyvYNOsthnzmNIpPSXxfIMuyeP0HL9NS0cw5f70Id6o74TFF5OgoSSQiIiIiIr0n3Alvfwpq34rtZNbviiM6jRnsoOXxazF9u8m4/F5sSVm9O88PaHj5XlqXvEr+RV8jdeT0hMYCqJg1i7p58xj4uc+RNSrxCZvGtdtZ+Mv/kT2qnPHfuTzh8QAW3zmfzS9s4OQfn07ZKeV9ElNEjo7jWE9AREREREQ+IXxV8ObF0LoWTroPBh7Z8jCzq5nWJ79EpGEDGZ/+D86i8b080X0sy2L3nAdpeOXfZJ50KbnnfjlhsfbY8cwzbH/ySYpmzqT8iiNLoh2Oli01vHPzP/FkpzHjjzdgdyb+18AVDyxh/h/nMuzyUUz6xrSExxOR3qEkkYiIiIiIHL2dz8DCGyEahLNehuJzj+g0kaattD71VaKtO0m/7J+4B57ZyxPdx4pG2PXUX2me9yTpk86l+HOJ7UNkRqNsfeghKp9/nvxTTmHYjTcmvO9R/dLNzPvhPTiSPZz592/hzUlPaDzLsljw53ks+tv7DDx3COf+9aKEX6OI9B4liURERERE5Mh1bIflt8COxyFrQmwXs4zhh30ayzIJrHqcjtdvBYebzKsewdXvpARMOCbYUEnVf3+Bf8dacs66loLLvolhS1w3jsDu3ay94w5a162j5PzzGfqVr2DY7QmLZ0ZN1j84hzX3zyatXz6n33ETyfmZCYsH0NXo4/UfzqbitS2M/OwYzrrtfGwOdTgR+ThRkkhERERERA5f6wbY+HfYcj8Ydhj3Sxh9C9ich3Uay7II7XgX37w/Ea5ZjrNsOumX3Ik9rSgh0450ttL45iM0vvUohtND6XW/JWPi2QmJBRDx+aicPZsdTz8NwIhvf5uiM85IWDzLsqhfsonlf3uG1q019Dt3EpN/dFVCdzKLBCOs/t9yFt3xPuGuEKf9YibjvzpZFUQiH0NKEomIiIiISHw6K6Hqedj5FNTPA5sLBn0ZxtwKycWHdSqzq5nAhhfwr3qMSN0abCn5pF30Vzyjr+z1Xcwsy8K/Yy0tC1+iZdFsrHCQjKkXUHDJN3Bm5PVqrD06d+6k9p13qH7tNaJdXeROncqQ667Dm5eYeOFOP1XvrGLTE+/QsrGK5MIsTvn9Vyg7a0JC4gF01naw7vFVrHlkJR272ik7tZzTfjGTnGGJuUYRSbw+SxIZhpEM/AMIAe9YlvVIX8UWEREREZHDFO6E9k3QvBIa3oeG+bHnAOkjYMLvYdB14D10QsCyLExfA5GGDYSrFhPa8R7hXSvBimLPGUrq+X/EO/pKDEfvbJFumVFCjTV0VazGt3UFnRsXE26px3C4yJhyHjlnfA5P0cBeiQWx6ws2NdG+dSvNa9bQvGoVXTU1GDYbudOmUX755aQN7L14ANFQmJYtNexesZX6ZVuoW7IRMxQhrTyfKbd8jvLzp+DwuHo1ZqDVT8OaOqoXVrLj7QrqV9UCUHpKOWf/5UL6zejfq/FEpO8ZlmUd+WDDeAC4CGiwLGtUj+PnAXcAduB+y7JuMwzj80CrZVkvGobxuGVZnz3U+SdNmmQtXbr0iOcnIiIiIiI9WCaE2yHU1n1rhWAjdNVA1y7w7wJfNbRvhq7qfePc2ZB7EuTPgNJLIH1Ij1NGsYIdWMF2zEA7pq+BaPsuzPZaoh21RFsriezehOVvjg0w7DiLxuLqdwru4RfhyBtxWMuSLDNKtKuDqL+TaFc7kbZGwi31hFsbCLfUE6zfQaB2O1Y4CIA9KY3kweNJG3sGaWNmYPemHN5bZllEAwEiPh8Rn49gczOBpiaCTU0EGhvxVVfjq6wk0tUFgM3tJnPECHImTSL/5JNxpR9+o2gzahLxBQh1dBFo6aCroZWuhlb8Da101jTSVlFLR/VurKgJQEppLsUnj6LsrPHkjO5/RL2VouEowbYA/hY/gVY/vrpO2qvbaK9qpb2qjaatTbRXtgJg2AwKJhTT/4wBDL1sJBnlie11JCK9zzCMZZZlTfrQ8aNMEs0AOoH/7UkSGYZhBzYDZwPVwBLgc8ClwCuWZa00DONRy7KuPtT5lSQSETl2LMsC6+D3WBaWZWHtffyBe9PCMk3MaOyeqIVpWVjRKJbZ4zX7Anbff+DcdI83TcyoSfck9s0D9v4jec+BPf9vsyImlmXGzt19zDRNMK3u85jd8wXM2Pz2HI+9JnYuK2piYfaI2/26PfNhz5zNvefCsmJj2HddlmnuGxubzb5z7jlm0j0Out+ofS/fc8w0e4zf75O25w3c927svaZ970+PAR8+/36n6znX/d7iDx84nH9OWPvmF9ewHp/rvV8nH/n6Dz450HXHd6oPnu/AQ6z957h/lHgv8sCvPdRzzD3fMvu/4CCfJ8s82GSs/e8/9Lbt+zqP3R3si+YDT3t+X+//xbrfQ+tAn5MPxjhQzA9MO8bkg2/Hh9+Wg5z7QNd8gICWaRzkNVaP77sPDut+U80PTtrc+yXE3u/9Hq/f89jqcW17/9P9s8oyu3+e7fkZE+0evuf4ntdGu3+u9Jy60eOpATYHFnYwnGA4sGwOwAbYYuc3ze6fQ9FYcsiMxM7b83ItY9+57U4MuwubwwMOLzjcGE4vGDYwrdg7Fo12z92EqIllRbt/VnfHiZqYZhSiEaxIOBb3QN8bhg3D6cLmSsLmTsLm9mL3JGNzefd+XiwrFs+Mmt3/P4qd34pGuu+jmNHumKEw0VAIMxLGilp736uebC43juRkHMkpOFNS9t5j2Lr/3xX7f4MZMTEjUcxwpPs+ihmJYEVMonuOBSOEA0Gi/iCRQLjHtRl7P12G3Y4rLRlvdjqe7HQ82WkkF2Tj8LoxI2b3e2VhRWL//zUjUSKBSPctTMTffd99LOwPE/GHCbQGCHUEP3R9AO4MD+kl6WT0zyJvdAF5owvIH1OAJyNxPY5EJPEOliQ6quVmlmXNMwyj/AOHpwBbLcuq6A78GLEEUTVQAqwk9n8aEZFPJDNqEvGHu//hFSHcFdp7H/ZHYh/rChMNRYiGo0RDUcxQtPux2f2PuBBhf4ho9z/qosEI0VC0e0zsH5pW1MSMxBIYZtSMJVyiFqZpYkX3JGm6ky0m3f9QpUeyh4PnDg7wD2ER+TgzPnAvcqIId98+igEcXrPtA/N13+qP4hzu7ttHaAQq9sTadeDXGGCz27A5bDg8ThweR+zmdex97s1OItUTe+7J9ODN9OLJ8OLpvk/KSSa9LB13mucorkdEPm4S0ZOoGKjq8bwamArcCdxlGMaFwIsHG2wYxg3ADQBlZWUJmJ6IyEezLItwV5iuRh/+xi66mnwEWgIE2/fcgt23AKHu+2BHkGBbMJbYCUYPHeTg0TGM7r/nGhYYVuxXOiN2fM/jvR/v4UDjbIYFBhiOnmMsDIP9zg1g0DMePY6xbww9xvX8GB883wFef4D7A1/HvvcCo3sO+73A2jO5Hr/2HqCcwOhxZ1jdJ973l+Ce1wlGj/ke4FjPuPu9yOgx/z0Bjb3vy4F+MT/wigrjIMf3G7r/wXh/19//QuNmfNSYOE/X55vaGAd8eOAjPb/ODvPcH/Wig1/zgT5wgNhxv2cfdbEHP8lHfZ0d+EvtAEcPFto44NH9j3306faxxfkNEc+3gnHgFxnxDP7gNfV4Pz5qedSHP9QdK/bDt8etx3kMo8fHgf2WC+35mG3fbPb+Z9+5DfY/h2EzYE8D6D3HezSE3rckyeh+z20H/1Ttnf+eOXe/1rDFYnef37B94N7Y/3X7Xaex53Uf8akwbHuvwzC6rwlb7DJ6nNOwdceyxeZiYIDNFpvXnq8Bmw1jz9w+6vNnMzBse+LZ9j7Hti+OYetxnj2v73m/59p6PN8XIL5vdMOIJXoMu9F9v/9jm8PAZus+5rDFYu/5+EG/h0REPlqfNa62LMsHfDmO190L3Aux5WaJnpeInFjC/jAdNe107Np369zVjq/BR1dTd1Ko0UckEDnoOZxJ3X+Jc9mwOcBmmNiI4kkK4XIEibpCsYTOnpvN3PfYbuBKduJw27A7DWx2C5stCkQgGoJIACsSxLDtGW/uS+gYFja7gcPjwua2Y3fYsNnN2M0IY5hBiAaxogEMzO6x1n43DAO724XN6cDutMfmbzexGREMghhWECPqx7BCe2PuG7vnGhzYnLFz2Bz22DXYTWxGCBtBDCuAYXZhEPnAeHq8D04MVzI4kzFcqRiuNAx3OrjSMFzp4EwFR3JsaYK9+xbPY7srtvWy4QSbvc++rkREREREPgkSkSSqAUp7PC/pPhY3wzAuBi4eNGhQb85LRE4AlmXhb+6itaKFlu3NtG5vpnV7C63bm2mvbifQ6v/QmKS8ZFLyUvDmJJM5IAuH28DoTtqYQT8RXyeh1lb8u5sxwyH2/2OgDW92Gp6cdJJycnBnpWB3AGYQKxLADHQS8bUTbm8m3NoI0fD+4x0O3JmZuDMzcWXm4UpLwWYHgzBEu7ACHZj+ZszO3UTa6zGsyP5/gLTZcabn4EjPxZlejD05DZvd6E4a+SHSgRVqgq4GrK4ajEjXh/6AaXizsKfmY0spw5aUg83pxGaLYhDEZnZgi7RgC9VjBGuwhWo//AdQmxO8hZBUBJ588OTEGpy6e9x7srsfZ4MrIzZGRERERESOK0fVuBqguyfRSz0aVzuINa4+i1hyaAlwtWVZ6w733GpcLSIfJdgRpHFjA43rG2jc0MDuDbtp3tJIsC2w9zWG3SCtNIPM/pmklWaQWpRGalEayQUpGFaISEc7ndX1tG2vo217HR076zEj+5aLOZM9JBdlk1KcQ0pRduxxUQ7uzGRMfzvh1ka6dtXgq6rCV1WFv6Fhv4alzrQ0vHl5ePPz8ey5z83FmZIEwTYi7XWE6rYTqK0gWFtBuLVhv2u0p2Tgyi7GlVOMK6cIZ2YBzoxcHClpGJF2LH8d0aatRBs3E2ncTLS1cl9TUsBwJWPPKMOe0Q97Rin29FJsqQXYknOwE8AWacDo2AJt66F1A7RvhEjXvgkYNkgqhdT+kNIfUsohqSSWEPIWxe7dWfstXxARERERkeNbonY3mwWcDuQQ69D2c8uy/m0YxgXA3wA78IBlWb89kvMrSSQie4S7QtSvrqNuxS5ql9fQsLZ+7zasAO50DznDc8kekkvmgCwy+mfFEkNlGdjsBh1Vu2nasJPm9ZU0b6ykZVMVEX8oNtgwSCnOJr1/Ien9C0jrX0haeT6pJbm40pIww2E6d+ygo6KC9q1bad+2DV9VFVY0lkwyHA6SiopIKS0lubSU5JISkoqK8BYU4PB6MYN+/FUb6dq5Hn/lBvw7NxDava91m+F0487vh6dwAO7CAbjzynDllODKKcLuTcEKdRGuX0ekbjXh2lWEa1cTbdrK3n4mNif2rAE4cgbjyB2KI2sg9sxYYsjwZmKYYWhdC03LoWlZ7NayGsweu5gkl0L6CEgfDunDIHVgd1KoTFU/IiIiIiKfMAlJEiVKj+Vm12/ZsuVYT0dEjgFfQyfVC3ZSvaCS2uW7aNzY0L39LKSXZ5I/poDcEfnkDM8jd3geKUWpe5tCRsMRmjdU0rBiK7tXbmX3qgrCnbFlZna3k8whJWQNLyNrWBmZQ4pJLcvH4XHtjR3u6KB140Za16+ndf162isqsCKxHkXO1FRSBw4kbeBAUgcOJKWsDG9BATb7vv43oZZ6fFtW4Nu6nK6K1QTrduyt7nFm5uMtG463dCjuooF4CgfgyinG6NE/J9pWQ6hqEeHKhYRrlhFp3Lx3vC05D0fhGJwFY3DkDcORMwR7ZjmGvUcix18PDe9B/Xux+5bVYHYnxJzpkD0BsiZA5mjIGBFLCjlTe/cTKCIiIiIix62PVZJoD1USiZw4Ai1+qubvjN3e30HzliYAXKluCsYXUTi+iIIJxRSMLyQpO3m/sZZp0ryxitoF66lbuommtTuIBmPb3ab1LyBv3ECyR/Une3gZaeUF2Bz7NzSOBgI0r1lD86pVtKxdS+fOnUCsQiht0CAyhg8nffBgUgcOxJOb+6EdbcKtDXSsX4hv63J8W1cQbqoFwOZNIXnAWLz9huPtNwJv6TCc6TkfuvZoWw3B7XMJ71xAqGoRZnusjZvhTsVZPAln0TichWNwFIzBnlrw4TfPVw27XoeGd2NJofbu5LrdCzlTIHcqZE+MJYZSB2hpmIiIiIjICe5jlSRSJZHIJ59lWTRvaaTija1UvL6F2qU1WKaFM8lJ8dRSSk7qR+nJ5eSNysdm/3BSI9DSQe3CDdQuWE/twg0EWzsByBxaSt74QeSNH0TuuIF4Mj9cIWNZFr7KShqXL6dpxQpaN2zAikSwuVxkDB9OxsiRZA4fTtrgwdjd7g+Pj0bwbVtFx/r5dK5bQGDXViDWPyh50HiSB00gedB4PMUD96sQ2js+7CdUuZBQxTsEK+YSbYr9nLMl5+IsnYKrdBrOsik4cocfcDwRP9TPhV2vQc2cWD8hiDWFzjsldss/JZYUsrs+PF5ERERERE5oH6sk0R6qJBL5ZLFMi5rFVWyZvZGK17fu7SmUNyqf/jMH0e/0ARSMK8LuPPDW5b76FqreXknVWyvYvaoCLAt3ZgqF04ZTOH0EhVOG48k68LIpyzRp27yZhgULaFi4kEBDrEF0clkZOePHkzV+PBnDh2N3HTipEg100bHufdpXvEXHhoWYAR/Y7CQPHEfqyOmkjJiOp2jQh6qM9jC7mglueZ3A5lcIbX8XIgGwu3GVTcM14DTcA07HnjPkoOPx10PV81D5LNS+HesnZHND/gwoPheKzoGMkaoSEhERERGRQzpYkshxLCYjIicOy7KoX1nLpufXs/nFDXTWdWD3OCg7pZzJ35hG/7MGkVqUdtDxnbuaqHxzOVVvr6Rp7Q4AMgYVMfqr51N8ymgyh5Zg2A6cGLGiUVrWr6dh/nwaFi0i1NKC4XCQNXYs/a+8kuzx4/HkfHj51x5Rfyfta96lfcWbdGxYhBUO4kjNIn3i2aSOPImUoZOxe5IPPr6jjuCmVwlumk2ociFYUWxpxXjHXYN74Bm4yqZhOL0Hf/M6KmJJocpnoWE+YEHKABj6dSg+L5YgcnzEeBERERERkcOgJJGIJERLRTPrn1jNxufX017Zit1lp/yMgcy49Uz6zxyMK/ngy6DCvgCVb61g+8uLaFgeW4qVNayMsd+4hNIzxpHWL/8jY/uqqqidO5fad94h2NSEze0mZ8IE8qZNI2fiRBzJB0/sWNEIHevm07LoZTrWvocVCePIyCPr5MtIH38mSQPGHHgJWDcz2Elw02wCa58mtON9wMKePZjk6TfhHnYBjvxRB68WAgjshu2PQ8XD0LgodixzLIz9OZR9KtZs+qPGi4iIiIiIHKHjcrmZehKJfDxF/GG2zN7E2lkrqV5QiWEzKDu1nKGXjmTgeUPwpHsOOtYyTeqXbqbi5YVUvb2KaCBEamke/S+YQvl5k0kpPnjFD8R2JKt7911q336b9q1bMWw2ssaPp/C008idMuWAvYV68ldtpmXRS7QumUO0swV7SiYZk88lfcJMkspHHbRaKTb3CKEd7xFY8xSBTa9AJIA9sxzPyMvxjLgER87gQ7xxXVD1QiwxVPMqWNFYYmjANdDvilizaRERERERkV6inkQikjCNGxpY/dByNj67jmB7kPTyTEZdNZYRnx5NSsFHb60ebPNR8dJCtjzzLp1Vu3GmeOl39kT6XziVnNH9P7LqxrIs2rdsofrVV6l/7z3McJiU/v0pPP10Ck49FXdm5kfGNoN+WpfOoWneUwSqN2M4nKSOOpXMaReSOmI6hv2jiy2jHXX4V87Cv/IRzI5aDE8GnuEX4xl9Bc7iSR9dMQTQsgY23QMVD0G4HZJKYomhAdfEKoZEREREREQSQD2JRKRXWaZFxRtbWXH/Yqre34ndbWfwhcMYddVYSqb3w7B9dIKkeUMlm5+ax87XlhINhskdO5AxN1xE6eljsbudHzk2GgxS9+67VL/6Kh3btmH3eCg880xKzj2X1P79Dzn3YP1Omt59mpaFL2H6O/EUD6LoMz8kfdI5OJLTP/q6LZPQjvfwL3+I4OY5YEVxDTgd79m/xD1oJobjoyuWiHTBjidh8z2we0Gs+XT5lTDoK1BwmhpPi4iIiIjIMaMkkYgclmBHkPVPrGbFA0tp29FCSmEqp/zkDEZfPQ5P5kc3UbZMk+q5q9nw8Bs0rtmO3eOi/wVTGXzFqWQOKTl07OZmqmbPpvrVV4n4fCSXljL0hhsoPO00HElJHx3bsuhYN5+mt2fRuXExht1B2vizyJ5xZazP0CGqfqxQF/7Vj9O15H6iLTswvFkkTf0a3vHX4MgsP+Tc6dwJG/4OW/8NoVZIGwqT/gIDvwie7EOPFxERERERSbDjMknUoyfRsZ6KiHTravSx/L4lrPrvMkIdQQonlXDyj05j0PlDD7pl/R7RYJjtryxmw8Nv0FHZQHJRNhO+dyUDLpqGK+XQu3P5qqrY+cIL1L7zDlY0Su7UqZRddBEZI0YcMrljRsK0LZ3D7jceJlhbgTMjj/yLbyTzpEtxph06ORPtrMe/9D90LX8IK9CKs3gCyTN+gGfoBYeuGgLYvRDW3Q6Vz8Se97sitjtZ/mlqQC0iIiIiIscV9SQSkY/UsaudZf9axJpHVhAJRhh84TAm3TiNgvFFhxwb6vSz5el32fTY2wSa2skcVsqIz59N6RnjsDk+OrEE0LpxIzueeYbGJUuwuVwUnXkmZZdcQlJh4SHHRv2dNL//HI1vP0aktQFP0SByzv48GRPPPmSvIYDI7k34Ft1DYN2zEA3jHno+SVNvwFUy+ZBjMaOxbevX/yWWJHKmw5AbYNg3IaXs0ONFREREREQSSD2JROSwtO5sYcndC1j/xGqwYNjlo5h803SyBh26+ibsC7Dp8XfY8MgbhDv8FEwdzohffpH8yUMP3cyZWHKo4rHHaF61CmdqKv0/8xlKL7gAV/pH9wuCWHKo8e3HaHxrFqa/g+Qhkyi55qekDJ8WV+xw/Tp8799BcOPL4PDgHXc1SZO/iiPr0L2OMMOwfRas/h20b4LUgTDlThj0ZXCmHHq8iIiIiIjIMaQkkYjsp7Oug0V/e4+1s1Zh2A1GXz2OiV+fRnppxiHHhrsCbH5yHhseeoNQu4/iU0cz+qsXkDU8vuqZ1o0bqXj8cZpXrsSZlsbgL36RkvPOw+7xHHJs1N9J4zuP0/jmo5j+DtLGnkbuuV8mqd+IuGKH69bge+9vBDe/iuFOJfnk75A0+avYkrIOPTgahG3/hTW3Qed2yBwDpz0BZZeD7dAVUyIiIiIiIscDJYlEBAB/cxdL/rGQlf9ZihUxGX3NOKZ8++RDbmEPEAmE2PLUPNb/73WCrZ0UnTyS0ddfSPaIfnHFbtu8mYrHHqNpxQqcaWkM+sIXKD3//LiTQ03vPE7jW7OIdrWTNmYGeRdcj7d0aFyxw7Wr6Hz3dkJb38Bwp5F8yvdImvwVbN6MQw+OBmDzvbD2j9BVAzlTYModUHKR+g2JiIiIiMjHznGZJFLjapG+E+oMsvy+JSy7ZxGhziDDrxjNtO+dQka/zEOONaMm219ayOp7X8K/u43CacMZfcOF5IyKY2kW0LVrF1sffpiGBQv2JodKzjsPh/fQzazNcJCmuU+x+7X/EPW1kzp6BvkXfBVv2bC4YkeattL5zh8IbpqN4c0g+bT/I2nil7F50g492IzA1gdh1S+hqxryZ8DJ/4HCmUoOiYiIiIjIx5YaV4ucoMyoybrHVjH/j3Ppauxi0PlDmP7D08gZmnvIsZZlUbtgPSv+/hxt23aRM7o/4751GXnj4kvshlpbqXjiCWpeew2b00m/yy6j7JJL4koOWaZJ69I51L/4L8LNtaQMn0bBJV/HWzY8rtjRjlp8796Of9XjGE4PSVNvJGnK9djch66YwjJhxxOw8lZo3wI5U2HC76DwzLhii4iIiIiIHA/UuFpE9qp8dztzf/kmjRsaKJpSwiX/+TSFE4rjGtu8sZIVdz5L/dLNpJTkcMrvv0LpmePjagod8fupfOEFdj73HGYoRPE559D/M5/BnXnoqiWAjg2LqHvu7wSqN+MpHRZrSD1sSlxjTX8rvgV307X0ATCjeCd+iZSTv40tOefQgy0LambD8p9CyyrIGAVnPA+lF6tySEREREREPjGUJBI5gbRsa2Ler9+i4vUtpJWmc+E9n2LwhcPiSvB0NbSy8u7n2fHKYtzpyUz8/pUMuvxU7M5D/xixTJNdb73FtkcfJdTSQu60aQy69lqSi+NLTPmrN1P37N/p3LgIZ3YhpV/6FekTz8Gw2Q4dOxqia+kD+N6/EyvQjmfU5aTM+AH2jDi3om9cAku+Dw3vxnYrO/UR6H8VGIeOLSIiIiIi8nGiJJHICSDQFmDh7e+y6sFlODwOTvnJGYz/ymQcnkP/CIiGwmyc9TbrHngFM2oy4ovnMOKL5+BKOfTSMIC2TZvYdP/9tG/dSvqQIYz5v/8jY1icfYM6W6l/8V80v/8c9qQUCq+4maxTr8TmdB1yrGVZBLe8TuebvyTasgPXwDNJOeMWnHnx7XaGrwqW/wQqHgZPHkz7Jwz+Ctic8Y0XERERERH5mFGSSOQTzLIsNjy1lnm/fpNAi59RnxvL9B/OIDk3Ja7xNe+vZfntT9NR1UDJjDFM+O4VpBTHsTwLCDY3s/Xhh6l9+21cmZmM/M53KDjttLiqlqxohKZ3n6b+pXsxg11kn/4Z8i/4KvakOJpKA5GGjXS88QtCO97Fnj2IjM8+jHvgGXGNJdwBa/4A6/8SW2Y2+icw+sfgjKNnkYiIiIiIyMfYcZkk0u5mIkevcWMDb/1kDjWLqiicUMyZj15F3qiCuMZ2VO9m2e1Pseu9taSW5XH6HTdRND2+ChwzHKbypZfY/sQTmJEI5ZdfTvmVV8bVlBqgc9MSdj11O8Fd20gZNoXCK76Lp2hgfLG7mumc9yf8Kx7GcKeRevav8U74PIY9juofMwpb/wMrfgaBeuh/dawpdUq/uGKLiIiIiIh83Gl3M5FPmFBnkIW3v8fy+xfjTvVw6s/OYORnx2LY4mgsHQix7j9z2PDwG9icdkZ95XyGXnVGXH2HAJpWrGDT/ffTtWsXOZMmMeTLXyapqCi+eTftovaZO2lf+RbO7EIKr/guaWPirTwK07XsQXzv/RUr2Il3whdIOfV72JKy4opN3Tuw+DvQshpyT4LJt0Pu1PjGioiIiIiIfMxodzORTzjLstjy0kbm/uINOus6GHX1OE655XS8WUlxjd+1YB1L/vA4vl1NlJ8/mXHfvIyk3Iy4xgabm9n8n/9Q/957JBUWMu5nPyNn4sS4xprhEI1vPETDnAfBMMi/+EZyzroGm9Md1/hQ1WI6Xr2FyO6NuPqfRurMn+PIHRrXWHzVsPSHsOMxSCmH056AfldqxzIRERERETkhKUkk8gnQurOFt255lZ1zt5M7Mp+L7r2cwolx7hzW2Mbyvz3NzteWkVaez1n/upn8CYPjGmtFo1S/9hpbH34YKxxmwFVXUX755dic8TV37ty8jF2P3Uawfifp48+i4IqbcWXmxzXW9DXS8dZvCKx5EltaMelX/Bv3kHPjqjwiGoL1f4XVvwYzAmN/DqN+BI74lsSJiIiIiIh8EilJJPIxZkZMVty/hPl/movNYeP0X53N2C9OxOaIY2t402Trc++z8q7niQbDjP7aRYz4/EzsrvgSPB3bt7Phn/+kfcsWssaMYdjXvhb30rJIRwu1z95B66LZuHKKKf/GHaSOnB7XWMuM4l/xMJ1z/4AV6iJp+jdJOfk7GK74KqaoeQ0WfwvaN0PpJTD5r5A6IL6xIiIiIiIin2BKEol8TO1e38DrP3iZ+lW19J85iLN+dx6pxfHt/tW6bReLfz+LxtUV5E8cwuQfX0Vav/gqeCJ+PxWPPUbVSy/hTE1l5M03UzBjRny9g0yTlgUvUPfcXZjBLnLP+zJ5534Zm8sTV+xw7SraX72FSO0qnP1OIu3c3+HIia/qic6dsOR7UPkMpA6Cs16GkgviGysiIiIiInICUJJI5GMmEoiw6G/vsfSfC3Gne7jgH5cx5JLhcSVpIoEQax94hQ0PvYErxcu0n3+B/hdMiW+JFrB78WI23ncfwcZGis85h0Gf/zzOlJS4xgZ2baNm1m10VawiedB4iq76EZ7C+Cp4TH8rnXP/gH/5Q9iSc0m79G48Iy6Nc2lZANb+Gdb8LvZ8/G9h5PfBHl/PIxERERERkROFkkQiHyPViyp544ezadnWzPArR3Paz8+KuzH17tUVLPzVQ3RUNjDgommM+/an8GTEl+AJtray6b77aJg/n+SyMkb/7ndkDB8e11gzFKB+9n00vvkodm8KJZ+/lYypF8ZXeWRZBDe8SMfrt2J2NZE0+TqST/0BNk98FVPUvgULb4T2LbGG1JP+Aill8Y0VERERERE5wShJJPIxEOwI8t5v32L1QytIK03n8kevot9p8VXhRAIhVv/rRTbOepvkgkzOvOtbFEwZFtdYy7KomzuXzf/+N5FAgIFXX02/T30KmyO+Hx2dm5ZQ8+jvCDXWkDn9Ygou+xaOlIy4xkbba2if81NCW17HUTCGjM8+jLNgVFxjCeyGpT+Abf+D1IEwcw4UnxPfWBERERERkRPUcZkkMgzjYuDiQYMGHeupiBxz29/axhs/nI2voZMJ10/hpP+bgTPJFdfYhpVbWfTrR+ioamDwlTMYd9OlOJPj6/8TaGxkwz//SdPy5aQPHcqIm24iubQ0rrHRrg5qn72TlvnP48orpf/N/yJl8IS4xlqWiX/Z/+h853dYlknKWbeSNPkrGLY4flxZFmx9EJb9AELtMPqnMOan2rVMREREREQkDoZlWcd6Dgc1adIka+nSpcd6GiLHRLAjyLxfvsHaWavIGpLDubdfRMH4OHcPC4RY9Y8X2PT4OyQXZDHt/11L/qQhcY21TJOa115jy//+h2WaDLrmGkovuADDbo9rfPuqudQ8/gciHS3knnUNeRd8Ne7G1JHdm2if/UPCNctw9T+NtPNvw54R5/Kwto2w4Eaonwt5J8O0eyBzZHxjRURERERETiCGYSyzLGvSB48fl5VEIie6nfO28/r3X6azroNJN01n+vdPxeGO79u1YcVWFv7mYTqrdjP4093VQ0nxJWm6amtZf/fdtK5bR9aYMQz/xjfw5se561lHM7ue/Atty17HUzyY8hv/grcsvr5FViSIb/7f8c2/C8OdQtold+IZeXn8janX/D52cyTD9Ptg8HVg2OKKLSIiIiIiIjFKEokcR0K+EO/+5i1W/285mQOz+OxzX6BwYnFcYyP+ICv/8QKbn5hLcmEWZ/3zO+RPjLN6KBql8sUX2TZrFjaHg+E33UTRWWfF3Vy6dfEr1D59O2bQT/7FN5J79hcw7PH9eAlVLaZ99g+JNm3FM/JyUmf+Altydlxj92tMPeCaWGNqb3xJLREREREREdmfkkQix4nqBTuZ872Xaa9qZcINUzj5/07D4XXGNbZh+ZZY9VB1I0M+cxrjbroUhze+Ld47d+5k/V130b51KzmTJzP8xhtxZ2XFNTbUXEfNrNvoXD+fpP6jKb72Z3gK+sc11gy00/n27/CveAhbegkZn30Y98Az4hr7ocbUZ78GRWfHN1ZEREREREQOSEkikWMs7A/z/u/fYcW/l5Bensmnn76Wkqnx9eGJ+IOsvPt5Nj8xl5TiHM76183kTxgc11gzHGbHM8+w/amncCQlMer73yf/5JPjqx4yTZrfe4a65+4Cy6Lw098ne8aVGLb4+hYFNr1Kx5yfYvoaSJpyPckzfojNlXzogT0bU4c7YMzPYPRP1JhaRERERESkFyhJJHIM7VpSzZzvvkTr9mbGfXkip/zkjLh3LqtftplFv3mEzl1NDL3qDMZ+/eK4q4fat21j/d//TufOnRTMmMGQr3wFV1paXGOD9TupfuQ3dG1bRcqwqRRffQuu7Pgaakc76+mY8zOCm2bjyBtOxpX/xlk0Lq6x+zemPgWm3wMZI+IbKyIiIiIiIoekJJHIMRAJRJj/p7ksu2cRacXpXPH41ZSdUh7X2HBXgJV3P8+WJ+eRUprLzH/dTN74QXGNNcNhKh5/nJ3PPosrI4OxP/kJuZMnxzXWikbY/eYjNLx8H4bTTcm1t5Ix7cI4+xaZ+FfOovOt32BFgqScfgtJU7+GYY9jOd1+jalT4KT7YdCX1ZhaRERERESklylJJNLH6lbsYs7NL9K8tYnR14xjxq1n4UqJrwKofulmFv76YXx1zbHqoW9cgsMTX+VR25YtrP/73/FVVVF45pkMue46nMlxLPEC/FWbqH7kNwSqNpE27kyKPvMDnOk5cY2NNG2lffaPCFctxFk2nbQL/ogja0BcY/dvTH1td2PqvPjGioiIiIiIyGFRkkikj0SCERb99T2W3L2A5PwULn/0KvqdFl+yJOwLsPKu59jy9LukluYx856byRsXX/VQNBRi++OPs+O553BnZjLuZz8jZ+LEuMaa4SANs//N7jcewpGcTtlXbyN9/JlxjbWiIXwL/4nvvTswnB7SLvgznrFXxbet/X6NqQfB2a9D0cy44oqIiIiIiMiRUZJIpA80rK1jzs0v0rhhNyM+M4bTfjETT7onrrF1izey6LeP4KtrYdjVZzLmxovjrx7avDlWPVRdTdHMmQz50pdwxFk95Nu2ippHfkOwfieZ0y6m4PJv40hOj2tsuGY57bP/j8juDbiHXUTqOb/GnhJHBZBlwbb/xhJE4XYY/VMY81M1phYREREREekDfZYkMgxjAPBTIN2yrCv7Kq7IsRQNR1n89/ksvuN9PFleLn3w0ww4O77dx8K+ACvufJatz75HalkeZ9/3PXLHxFd5FA0GqXjsMXa+8ALurCzG//znZI8bF9/YgI/6F/5B07yncGYWUP7NO0kdPi2usWbIh2/uH+ha8gC21AIyPv0f3IPPiWssbZtgwde6G1OfDNPvVWNqERERERGRPhRXksgwjAeAi4AGy7JG9Th+HnAHYAfutyzrtoOdw7KsCuArhmE8dXRTFvl4aNzQwJybX6RhbT3DLh/JGb86B09mfBUxdYs3svA3D9NV38rwa89i9A0XxV091LpxI+v//ne6du2i+JxzGPzFL+JISoprbMf6BdQ8+nvCrfVkn/YZ8i/+OnZPfGODW9+k/dVbMNt34Z3wBVLOuAWbO/XQA6NBWHMbrPkdOJJg+n0w+Do1phYREREREelj8VYSPQjcBfxvzwHDMOzA3cDZQDWwxDCMF4gljH7/gfHXWZbVcNSzFfkYMCMmS/+xgAW3v4s7zcPF91/BoPOHxjU23Oln+Z3Psu2590nrl3/Y1UPbHn2UyhdfxJOTw/hf/ILssWPjGhvxtVH79N9oXfQy7vx+DPjuvSQPjG+s6Wuk4/WfE1j/HPbswWR+4VlcJfHtmEbdO7Ft7ds3Qf+rYfLt4M2Pb6yIiIiIiIj0qriSRJZlzTMMo/wDh6cAW7srhDAM4zHgUsuyfk+s6kjkhNO0pZE5N79I/cpaBl80jDN/dy5J2fH1AKpduIFFv30E/+5Whl87k9E3XBh/9dD69ay/6y66amspOe88Bn3hCzi88VUtta18m12P/YGIr43cc79E3vlfweY89G5rlmURWPMkHW/+EivoI/nU75M8/SYMRxw7tQWaYNkPYet/IKU/zHwVis+Na74iIiIiIiKSGEfTk6gYqOrxvBqYerAXG4aRDfwWGG8Yxi3dyaQDve4G4AaAsrKyo5ieSN8xoybL71vM/D/Oxel1ccE/LmPopfH10wl1+llxxzNse34+aeX5nH3/98kZ1T+usdFAgK2PPELVyy/jzctjwq9+Rdbo0XGNDbc1suuJP9O+8i08JUMov+kOvKXxVTxFWnbS8cqPCO14F2fJJNLO/xOO3CGHHmhZUPEwLPkehFph1I9h7P+LLTMTERERERGRY6rPGldbltUE3BjH6+4F7gWYNGmSleh5iRytlopm5nz3JWqXVjPw3CGcddt5JOelxDV214J1LP7to/gb2xjxhbMZff2F2N3O+OKuXcv6u+/GX1dHyQUXMOjaa+OqHrIsi9ZFL1P79N8wQwHyL/kGuTOvxbAf+seBZUboWnw/nfP+hGFzkHru7/BO+DxGPP2D2rfAwq9D7ZuQOx2m3wOZ8SW0REREREREJPGOJklUA5T2eF7SfUzkhGCZFiseWML7v38Hu9vBeXdewrDLR2IYxiHHhtq7WP63p6l4aSFp/Qs4+w/XkzOyPK64Eb+frQ8/TPXs2XgLCpj461+TOWrUoQcCoaZaamb9ns4NC0kaMIbia36GpyC+uOG6NbTP/iGRujW4h5xL6jm/wZ5WdOiB0RCs/SOs/g3YPTDtnzDkBjWmFhEREREROc4cTZJoCTDYMIz+xJJDVwFX98akDMO4GLh40KBBvXE6kV7XurOF17//MtULKik/cyBn//ECUgrj2MkLqH53DUt+P4tASwcjv3Quo756PnZXfNVDzWvWsOHuu/E3NFB60UUMuuYa7B7PIcdZpknzu09T9/zdYFkUfvr7ZM/4NIbt0IkaK+yn892/0LXoXmxJ2aRffi/uoRfElQyj/t3YtvZtG6D8MzD5b5BUGMeVioiIiIiISF+LK0lkGMYs4HQgxzCMauDnlmX92zCMbwJziO1o9oBlWet6Y1KWZb0IvDhp0qTre+N8Ir3FsixWP7SCd3/9JobN4Oy/XMjIz46JK2ESbPOx7PYn2fHKEjIGFXHaX24ka3h8fbciXV1s+d//qJkzh6TCQib95jdkjIiv51GwfifVj/yGrm2rSBk2leKrb8GVHUcFEBDc/i4dr/yIaOtOvOOuIeWMn2DzZhx6YKARlv0Itj4Ayf3grJeh5IK4YoqIiIiIiMixEe/uZp87yPHZwOxenRGqJJLjU3tNG69//2Uq391B2anlnP2XC0krTo9rbNXbK1nyh8cItvkY9dXzGfnl87A74yvk271kCRvvuYdgSwtll1zCwKuvxu6OY/exaITGNx+h/uX7MJxuSq69lYxpF8aV0DK7mul469cEVj+BPas/mdc8iavfSYeerGXClvth+S0QaoeRP4SxPwdnfDu8iYiIiIiIyLFjWNbx2xt60qRJ1tKlS4/1NOQEZ1kW6x5bxdxfvIFlWsy49SxGXzs+rmRLoKWDpX9+ksrXl5E5pIRpt15L5pDSQ44DCLW2sunf/6b+vfdILitjxE03kT4kjh3EgK4d66h59LcEaraSNvZ0ij77fzjTcw45Lrat/RN0vPlrrGAHydO+TvLJ38FwHrohNk3LYeE3oHER5M+Aqf+AzJFxzVdERERERET6jmEYyyzLmvTB4322u5nIx1FnbQev/99sdry1jZLpZZxz+0Wkl2XENbbyjeUs+dPjhDv8jPnaRYz44jnYHPZDjrMsi7q5c9n8wANE/H4GXHUV5Zdfjs156L5F0YCP+hf+SdO8J3Gk5VB2/R9IH3dGXPON7N5M+6u3EK5aiLNkMqnn/R5n3vBDDwy1wor/B5v+Ae4cOOV/MOBaiKdnkYiIiIiIiBw3jsskkZabybFmWRYbnlrLOz9/nWgwwum/PptxX5qEYTt04sPf1M7SPz1O1VsryRpe9v/bu+/wqKu0/+PvM5Nk0hNCQkIJofdO6AgoVRTBXta6rrquu+v+tj3b27P7bNEtumtZXV1XV7GwdkFBadJJ6ARCIARCgBTS67Tz+2OiC5JksEAg+byui4vwZe58z8yZ70zmzn3uw/hHbyG+95n1AKovLmbP449zYssW4vr1Y+B99xHd/cz6FlVuX8XRlx/AU1FMxynXkDzvXpwR0UHjrKeOmrUPUbPhcYwriti5DxI+/Prg29pbCwdfgM3fgfoi6P81GPVrCIs/o/GKiIiIiIjI+UXLzUQ+oaqgkvd/sIS85QfoMqYbs/50OR16JQSNs9Zy6L0MMh58BW99A8PuuowBX5p+ZtVDfj9H3n2X/c89h7WWPjffTOqll2KcwWM95UUcfflBKrevxNWlN91u+hGRPYee0X1tOLCCqvd+hK/8MOFDryXmkp/iiOoYPLA8CzbeB8dXQuJYGP8odBx9RucUERERERGR1qXlZiJBWL9lx7+3suY3y/H7LNN+NZPht4/G4Qy+TXzNsRNs+v2LHFuXRcchPRn/05uJ65lyRuetyc8n69FHqdi7l4QRIxh4771EdOp0BuP1U7rmVY6/8QjW5yV5/n0kTf8Sxhn8svZVHadq2c9p2Ps2zo59zrwxtacadvwv7P4ThMbAhL9D369AsKojEREREREROe8pSSQClB8sZdn3FnNk/WFSJ/dgxh8uJT6tQ9A4v8/PvldWseOxNwEY9e1r6Hft1DNKLPk9Hg69/jq5L7+MMzycQd/4Bp0vvvjMGmIX7OfIwv+j7uAuogeMpcsNP8CV1C1onPX7qMv8F9Wrfo/1e4ma+n2ixn0VExJktzRr4dAiyPgO1ORDnztg9O8hPCnoOUVEREREROTCcF4midSTSM4Vv8/P1n9sZt0fVuEIdTLjgbkMuXH4GSVqynIK2PR/z3Ni9yE6TxzE2P+5gajOZ7BUCyjPymLP449Tk59Pp4kT6X/XXbji44OP111P0ZKnKX7/OZyRMXS77ZfEj5lzRuP1HN1G5bs/xHt8B2E9pxIz5/8I6dAj+GBLd8Cmb0LhKugwHKYshE6TgseJiIiIiIjIBUU9iaTdKskuZtl33uH41qP0nNGHGb+7lOjOMUHjfA0edj21hKznlhEWG8nob19L2qzRZ5aoqaoi59lnOfr++7gSExlw110kjR17RuOt3PkhR19+EE/pMeLHXUbnq+4nJDo+aJy/tpTqlb+lbttCHFFJxMz8Ba6BVwQfb/0J2PYz2Pc4hHWAkb+GvneBI3ifJBERERERETl/qSeRSCOfx0fGI+vZ+NBaQqPCuPRv8+m/YNAZJXkKt+Sw6TcvUJVfRM/LxjHq/qtwxZ/BDmIfbWv/z3/ira6m+/z59Lr+ekIiIoLGuksKOLroT1Tt/BBXSk96futxovuOCn5Ov4+6rc9RveoBrLuayHF3EzX5/+FwBUmE+X2w7wnY9pPA9vb9vwYjfgmu4M27RURERERE5MKlJJG0K4U7jrHsu4sp3l1IvysGcvH/ziIyMSponLuylq1/fY0Db6wjqktHLv7r1+k8buAZnbOmoIDsJ56gdMcOYvv1Y+BXv0pMz55B4/weNyUf/Juid/+JMQ5SrvwmiRffcEaNqd35m6la+mO8hbsJS5tEzKxfE5LUL/hgj68KLC0r2wEpF8PYh6DDme2UJiIiIiIiIhe28zJJpJ5E8kVz17hZ94dVbHs6g4jESOY9dTV95vQPGmetJf+DrWT88RUayqoYePMMht59GSHhYUFj/R4Pea++ysFFi3CGhTHgnnvoOnPmGW1rX7VnI0dffgB30WFiR15Cl6v/H6EdkoPG+aqLqF7xG+p3LsIR05m4Kx/HNeDy4FVSNfmQ8T3IewmiusPUVyDtajiD6ioRERERERFpG9STSNq8A0tzWPHj96g6VsmwW0Yx+YfTcMWGB42ryi8i44GXObZhDx36pzLuxzeRMKD7GZ2zdOdO9v7979QWFJA8eTL97rgDV0Lw5Vqe8iKO/ecvVGx5n7CkVLpc911iBk0IGmd9Hmoz/0nN6j9ivQ1Ejr+H6In3Y8IiWw701sLuB2Hn7wALQ34AQ74HIUHiRERERERE5IKlnkTS7lQfr2Llz5aR885eOvZP5PpHb6XLmODbxPsaPGQ9u5Td/1qKIzQksK39NVNwhASvAGooLSXn2Wc5vmoVEcnJjPzZz+g4cmTQOOvzUrLiJYoWP4n1++h0+T0kzbgZR2iQrekBd94aKpf+DF9JNmG9LiZm5i8J6dg7yAn9cOA52PpjqC2AtGsh/QGITgt6PhEREREREWmblCSSNsf6LTue28Ka367E5/Yy6X+mMvqr43GGBU/yHNu4h4w/vExVfhHdZ45m1LeuIjIpPmic3+sl/513yH3pJfweDz2uuYae11yD0xU8yVOVtZ5ji/5MQ2EeMUMm0eXa7xKW2DVonLc0l+rlv6Zh33s44lKJu+ZpXH1nBV9admwFZHwHSrdC4liY8iIkTw56PhEREREREWnblCSSNqVkbxHvf38JxzILSJ3cgxm/m0N8z+DLvGqLy9nyl1c5vCyT6NQkLn7463Qef2aNqUt37iT7ySepyc+n46hR9L/zTiK7dAka11B0mGOvPkTVzg8JS0ol7at/JGbI5KBJHn99BTVr/kJtxj8xIWFET/shkWO/ggkJsoSuIjvQd+jIW4G+Qxe9AD2vB+M4o/spIiIiIiIibdt5mSRS42r5tDx1Hjb+ZS2Zj28gLMbF7IfmMfDqIcETLl4f+xatZsff38bv8TL0rrkMunUWTldo0HPWl5SQ88wzFK5dS0RyMsN/+EMSx4wJek5fXTVF7z7NiRUvYkJdpCz4Bh2nXY8jtOVm2NbvpW7r81SvfhBbV0b48BuInvp9nNGdgg0Utv8Ssh+HkAgY9VsYeH/gaxEREREREZFGalwtFzRrLQfe28fKny2jqqCSQdcOZcrPphORELzxcvGOXDIeeJmy7Hw6jx9I+veuIyY1SMKFwK5lh996i4OvvIL1++lx1VWkLVgQdGmZ9fsp2/gOhW88greqlA7j55F8xb2ExiUGPWdD7iqq3v8lvpJsQrtPIGbGLwhNGdJykK8B9jwMO34D3irodw8M/wVEBL+PIiIiIiIi0napcbW0OeUHS1nxs2XkLT9AxwFJXPufm+k2PvjuY7XF5Wz72+vkLdlMRFIck//vTlKnjwzeywc4sW0b2U8+Se3RoySNHUu/L3+ZiOTgW9PXHtzJ0Vf+SN2hLCJ6DiHt3j8RmTYoaJy3ZD9Vy3+Fe/8HOOPTiLv6H7j6zWl5rNYPuS/Atp9CdR50nRtoSh0f/HwiIiIiIiLSfilJJBccT52HzX9bR8ajG3CGOZn6ixkMv300ztCWG1P73B6yF65g19NL8Hv9DL59NoNun0VoZJBePkBNQQE5zzxDSUYGEZ07M+InPyFx9Oigce7S4xS++Sjlm98lJC6Jbrf9kvgxQZI8gK+6mJo1f6Zu2/OYkHCiL/kJkelfxoS0UK1kLRQshi0/grIdkDASZj4BXWYGHaeIiIiIiIiIkkRyQTmwNLC0rDK/ggFXDeain0wnOjm6xRhrLUfX7CLzL/+hOr+YblOGMfJbVxHTLSno+TxVVeS+/DJHlizBERZGn1tvpfvll+MIbblnka+umuKl/6Jk+UIwhqTZt5M063ac4S0vg/O7a6jd+HdqNz6O9dQTMfJLRE3+Ns7oIGMtWgeZP4CiDyGmN0xZCD2uU1NqEREREREROWNKEskFoTyvjJU/W8bBD/bTsX8i1y76Et0mpAWNqzxUSOafF3FsXRaxPZLPeNcyv9fLkffeI/fFF/HW1tJ1xgx63Xgjrvj4FuOsz8uJD1+laMk/8FWXEz/2UpLn3UtYQkqQOA91216gZs2f8dcU4+o/l+hpPyCkY++WB1q2G7b+CPLfhPBkGPco9L0TnC03wRYRERERERH5pPMySaTdzeQj7ho3m/+6jswnNuIIcTLlp9MZcWd60KVlnuo6dj39LtkvrsDpCmXUt66m33VTcYS0HGet5URmJvueeYbaggIShg+n3x13EJ3WckLKWkvl9pUcf+NvuIvyieo3ms5X3k9E9wFB4xqyl1C98rf4SnMJ7TaWuKv/QVi30/qHnar6EGz7ORx4FkJjYOSvYeC3IDSq5TgRERERERGRZmh3MzkvWb8la9FO1v5uJTWF1YGlZT+6hOjOMS3G+b0+9r++lp1PvkNDeQ29501g2L3ziOgYG/Sc1YcOse+ZZyjdto3ILl3oe/vtJKanB+0fVHtwF8dee4jaA9txpfQk5cpvEDN4UtA4d/4mqpf/Gk9BJs6OfYm++Ee4+s5sOa6uCHb+FrIfBQwM+DoM/SGEdwx6/0RERERERERAu5vJBaRgcz6rfv4+hduPkTKyC/OevJrOo7u2GGOtpWDNLrb99TUq8wrpNKovo+6/ioSBwXc7qz9xgtwXX+To8uWERETQ78tfptucOUH7DjUUHabw7b9TkbmMkJgEutzwAxImXoFxtnxZeYqyqFn1AA05S3FEpxAz9wEihl2HcbQQV18Cux+AvX8DXz30vi2wnX108PsnIiIiIiIiciaUJJLzRmVBBWt+s4LsN7KISolmzsNXMODKwRhHyxU5pXsPs/Wh1yjM3EdsWjJTHryHrhcNDVrJ46mp4dBrr3H4rbewfj+pc+fS89prCYttuerIU15E0eKnKF3/JiYklKQ5XyZp5i04w1te6uU9sZ/q1X+kYc+bGFcs0VP/h8ixd2FCI5oPaiiF3X+CPQ+BtwZ63gjDfwZx/Vs8l4iIiIiIiMinpSSRtDpPrZvNj24g87ENWGDctyYx5r4JhEa23Hy5prCM7Y++Sd6STbjio0n/3nX0uXJy0L5Dfo+H/MWLyVu0CE91NSlTptD7ppuISE5uMc5bXU7x0mc5sfoV8PvoeNFVJM2+g9C4xBbjfOWHqV7zZ+p3LsKEhBM18ZtEjrsHR0R880Hucsj6C2T9GTyVgZ3Khv8c4ge1eC4RERERERGRz0pJImk1fp+fPYt2se6BVVQfq6LfFQO56MeXENstrsU4T3UdWc8uY+/C5VhrGXTrTAbdPpuw6BYqcgDr93N89WoOvPAC9cXFJIwYQZ9bbiG2V68W43z1NZSseJGS9/+Nv6E2sGPZ3LsIS2x5CZyv6hg1ax+mbttCMA4ix3yFqAn34YhqIankroQ9D0PWHwOJou5XBZJDCcNaPJeIiIiIiIjI56UkkZxz1loOrczlw98sp2RPMcnDOzP30QV0HZvaYpyvwcO+RavJeuY9GipqSJudzvB7ryC6S8tNm621nNi6lf3PPUd1Xh4xvXox8L776Dh8eItxfo+b0jWvUvTuP/FVlxE7fBrJl99DeJeWt6X315RQs/4Rarc8C34vESNuImrSN3HGdG4+yFMFex8J9B1qKIXUKwI9hzqObPFcIiIiIiIiIl8UJYnknCrccYwPf72c/LWHiEuLZ+5jC+g3b2CL/YP8Xh+5b29g1z8WU1tUTsq4AQy/9wo6Dmp5W3qAst27OfDCC5RnZRGRnMyQb3+b5EmTMA5HC+fzUL7xHYqWPI2n7DhR/ceQcsXXiOwxuMVz+WtOULPpCeoynsZ66wkfeg3Rk/8fzvgWmks3lMHevwaWlrnLoOtcGPELSBwT9L6JiIiIiIiIfJGUJJJzouJwOev+sIq9r+0mIiGCab+aybBbRuEMa75/kPX7yV++je2Pv0XV4SI6Dk5j/M9vJWVM8KbNFdnZHFi4kNLt2wnr0IH+d91F15kzW9yx7OPk0Lv/xFN6jIgeQ+h280+IHjC2xXP5qouo3fh4oHLIU49r0BVET/42IYl9mg+qKwr0G8p+JFBFlHoFDP0xJLV8LhEREREREZGz5bxMEhlj5gHz+vRp4UO2XBDqSmvZ9PA6tv8rE+MwjP3GRNK/Nh5XbHizMdZajm3IYvtjb1G2N5+4nilc9Ie76TZ1WNAdyyoPHCB34UJKMjMJjY2l7+23023OHJwuV7MxTSWHut74A6IHjm/xfL6qY9Ssf4y6bc+Dz0344AVETby/5eRQzRHY/SDseyKwlX2P62Doj9RzSERERERERFqdsda29hialZ6ebjMyMlp7GPIZNFQ1sPUfm8j8+yY8NW4GXz+MCd+ZQnTnmBbjircfYPtjb1G0JYeozh0Zevdl9JgzBoez+eVhANWHDnFg4UKKN24kJDqatAULSJ07l5CI5ptZN5UcSp57F9GDgiSHKgqoWf8IddsXgt9H+NBriJr4dUISWmiAXZULu34P+/8J1g+9boahP9RW9iIiIiIiInLOGWMyrbXpnzx+XlYSyYXLU+tm2zOZZDyygfryOvpc2o8J35tKYv+kFuOKtx9g55OLOb5pL+EJMYz+7rX0uXIyztCWn6I1+fnkvvwyhWvX4oyIoNcNN9D98ssJiYpqNqbJyqEbfhA8OVR+mJp1f6Nux8sARAy7jqiJX2+551DZ7kBy6OALYJzQ504Y8n2I6dni/RIRERERERE515Qkki+Et8HLzue3sunhddQW19Djkt5M/N4Ukoe1sKMXULRtP7v+seTj5NDI+6+k71UXERLR/PIwgKqDBzn4yisUbdiA0+Wix1VXkTZ/PqExzVcq+RvqKF37OsUfPI+3vIiItMFnlBzyFGVRu/4x6rPeAIczsFvZhPtwxnVtOsBaKFwFux6AgsXgjICB34TB34XILi3eLxEREREREZHWoiSRfC4+j4+sl3ew8S9rqTpaSbcJ3bn8iauCbmdftG0/O59cTOHm7Mbk0FX0vfoiQsLDWoyr2LePg4sWUbJ5M87ISHpcfTXd580jLDa2+THWVlKy6hVOrHgRX00FUX1G0u2mH7eYHLLW4snfSM36R3AfWI4JjSRyzJeJHHdP81vZ+31w+NVAcujEZnAlwohfQv+vQXhii/dLREREREREpLUpSSSfid/rZ8+ru9j40Foq8spIGdmFWX+6jNTJPVqsyinaup+d//hvcmjUt66mz1WTgyaHynbv5uArr1C6fTuh0dH0uvFGUi+7jNAWlpV5KkooWf4CpR++ir+hlpghk0mafTtRvZpvEm2tn4acZdSu/xuegi2YyI5ETfkekaNvwxHRoekgb22g19DuP0F1LsT0gfGPQe/bIKT5nkgiIiIiIiIi5xMlieRT8bl9ZL2yg01/W0/l4XKSBnXiin9eS6+ZfVqsyjm+aS9ZzyylMHPfGSeHrLWUbt/OwVdeoTwri7C4OPrceivd5sxpsSG1u6SA4mXPUrbhHazPS9zoGSTNuo2Irn2bP5fPTf3u16hZ/xi+Ezk44lKJmfUbIoZfjwlt5lz1xbD3b7D3EWg4AYnjIP0BSJ0PDmez5xIRERERERE5HylJJGfEW+9l94vb2fzIeqqOVpI8vDPTfjmDXjP7Npsc8vv8HFm5jax/LaN072EikuLOLDnk81G0YQOHXn+dyv37cXXsSL+vfIWuM2a0uJV93eG9FH/wPBWZyzBOJx3GXU7ijJtxdWp+6Zu/vpK67S9Qu+kf+KuOEdJpELHzHyF84OUYRzOXR3kW7HkYDvwrsI19t3kw5HvQaTK0UEUlIiIiIiIicj5Tkkha5KnzsPPfW8l4fAM1x6vpnN6NGX+4lLRpvZpNDvncHg4u3sSe596nKr+ImNROjPvxl+hx6RicYaHNnsvX0MDRDz7g8JtvUldYSGTnzgy49166XHwxjtCm46zfT9XutZR88AI1OZk4wqNIvORGEi+5idD45ndU85blUbv5aep3vIh11xCaNpHYyx4krOfUpu+X9UPBEsh6CI4tA4cLet8Mg74D8QNbfhBFRERERERELgBKEkmTGqoa2PHcFrb8fSO1JbV0m9CdOQ9dQeqktGaTQ56aeva/voa9LyynrriCDgNSmfzbO+k2bQQOp6PZc7krKshfsoQjixfjqaoirl8/+t5+O0ljxmCcTS/b8rvrKdu4mBMrFtJQeIjQDsmkXHk/CZPm44yIbjLmo2bUtZuepGHfe+AIIXzQFUSOvZvQlCFND85TBfufgb1/hcociOgCI38D/e5WM2oRERERERFpU5QkklNUF1az9anN7Hh2C+6qBtKm9mTctya3uFtZXUkF+xatJmfRatyVtSSP7sf4n91CytgBLTaxrj12jMNvvsnR5cvxu90kjhlDjwULiBs4sPlEVOUJSlcv4sTqRfhqKojoPoDUO/6XuJHTMc6mn87W56Z+z1vUbnoS7/GdmIgORE38BhHpt+OMTm56cFW5sOevsP9p8FQG+g1NWQhpV4Oj+WooERERERERkQvVOUsSGWMWAJcBscBT1tql5+rcElzp/hNkPr6BPf/Zhd/rp+9lAxh973hShjez3TtQllNA9sLl5L2Xgd/jpduUYQy6fRaJQ3o2G2OtpWLPHg6//TZFGzdiHA46T51K2vz5RKU2n4iqP3qAkhULKd/0LtbnIWbIRSRNv4nIPiOb74lUW0rd1n9Tm/kM/upCnB37EnPp74kYcnXTzaithePLA8mh/DfBOKHHtTDwfkga1/yDJyIiIiIiItIGnFGSyBjzNHA5UGStHXLS8TnAQ4AT+Ie19nfNfQ9r7evA68aYDsCDgJJE54GjGUfIeGwDB97bh9MVwpAbhzPqnnHEpzW93bv1+zm6PovshSs4vmkvzvAwes+fSP/rpxGb1kxVDuD3eDj+4Yfkv/MOVbm5hERFkTZ/Pt0vvxxXQkLT5/J5qdyxmhOrXqYmZwsm1EWHCfNIvPgGXMlpTcdYi/foVmozn6F+z9vgayCs1zQiL/sjYb2mNZ1QaigLLCnb9zhU7gNXIgz9EfS/F6K6Bn0MRURERERERNqCM60kegb4G/DsRweMMU7gEWAmcATYbIx5k0DC6LefiP+ytbao8eufNMZJK7F+S+77+8l4bD1HNx0hPD6Ccd+azIg7RhPZMarJGG+9m4OLN5L94goq8wqJSIpj+H3z6bNgEq64pmMAGkpLOfLuuxQsXYq7ooKo1FQGfPWrdJ46FWd4eNPnqiqldO3rlH74Kp7yIkI7diZlwTfoMGEeIdHxTd8nTx31WW9Qm/kvvMd3YMKiiRhxE5GjbiUkqV/TgyvZDHsfhbwXA7uUJU2Ayc8GqoecTY9NREREREREpK06oySRtXa1MabHJw6PBfZba3MBjDEvAvOttb8lUHV0ChMo4fgdsMRau+VzjVo+E3d1A7tf2sG2pzMozysjtlsc0/53JkNuGE5oZNNb0tcWlpHz6hr2v/ohDRU1JAzozoRf3Ub36aNwhjb/9KnYt4/8d96hcN06rM9H4ujRpF5+OQnDhjW7PKw2bzcnVr5Mxdb3sV4P0QPG0eX67xMzZBLG0XQDa29ZHnVbnqVu+0vY+nKcif2Jmf1/hA+5GoeriQbWnppAUij7MTiRCSFR0Pu2QNVQwvDgD6KIiIiIiIhIG/V5ehJ1BfJP+vcRoKXGLd8AZgBxxpg+1trHm7qRMeZu4G6A7t27f47hyUfK88rY9nQGu1/ajrvaTefRXZn4/an0vWwAjpDTdx2z1lKYsY+cRas5snoH1m/pNmUYA266hKQRvZtN8vjcborWr+fI4sVU7NuHMyKCbnPmkDp3LpGdm+5t5HfXU7H1A06seoW6Q1k4wqNImHQlCVOuITylR5Mx1u/DfWA5tZn/wp27AhwhuPrNIXL07YR2H9/0+Mr3BJaT7f8XeCogfgiMewR63QxhsWf8WIqIiIiIiIi0VeescbW19mHg4TO43RPAEwDp6en2bI+rrbLWkr8mj61PZZD7fg6OEAf95g1k5J1jSBnRpckYT3UduYs3kvOfD6k8eBxXXBQDbppO36smE921+e3ea48epWDpUo4uX46nqoqIzp3pd+eddLnkEkIiI5uMqT96gNJ1b1C+cTG+2kpcKT3pcv33iR97Kc7wppev+SoLqNv+EnXbX8RfWYAjOpmoi75DxIibcMakNHWHIO9lyHkKiteBIwzSrglUDXWaBC3svCYiIiIiIiLS3nyeJFEBcPJ2VN0aj31uxph5wLw+ffp8Ed+uXfHUutnz6m62Pb2ZE9klRHSMZNz9kxh262iik5tYfgWUHzjKvldWkbdkE946Nx0HpzH+57eSNmMUTlfT2737vV6KN2+m4L33KN2+HeNwkDRuHF1nzyZh6FCM4/QKpY+qhkrXvE5t7naMM4TYEZeQMGk+Uf3Sm6wAsj4PDfvfp27bC7gPrAAsYT2nEDH9p7j6zcE4PzE+a6F4A+x/Cg6+BN5qiBsA6Q9Cr1sgotOnfkxFRERERERE2gNj7ZkV6zT2JHr7o93NjDEhwD5gOoHk0GbgJmvt7i9qcOnp6TYjI+OL+nZtWkl2MTv/vZU9i3bSUNlA0uBkRt45hv7zBxESfnou0Nfg4fCKrRx4bS1FW/fjCAuhx6x0+l4zhY6Dmt45DKC+uJiCZcsoeP993GVluBIT6TprFl2nT292l7L6gv2Urn2Nsk1L8NdVE9apOwmTrqTDuLmExDS9i5q3NJe67S9Sv+Nl/DXFOKJTiBh+PRHDb8AZ38QyxPpiOPBcoGqoIivQa6jH9dD3zkBDalUNiYiIiIiIiABgjMm01qZ/8vgZVRIZYxYC04BEY8wR4OfW2qeMMV8H3iOwo9nTX2SCSILzNnjZvzibHc9toWBjPs4wJ30vG8DQW0bSdWxqk5U5ZTkFHHhjLXnvbsZdWUt010RGfGMBvedNwBXfdKWR3+ulJDOTo++/T8mWLWAtiaNG0XX2bBJHjcI4T28q7auvoWLLB5Sue526g7swIWHEjbyEhEkLiOwzsumqIW899XsXU7ftBTyH14Nx4uo7g4jhNxLW+2KM4xNPV78Xji4LVA3lvwl+DySNhwlPQs/rITTmsz2wIiIiIiIiIu3QGVcSnUsnLTe7Kycnp7WHc94pP1jKjue3kfXSdupK64jr0YFhN49k0HVDm9zC3lNTz6GlGex/Yx2lWYdwhIaQevEIes+fSPLovk0uDQOoPnyYo8uXc3zlStwVFYR16ECXSy6h66xZRHQ6fdmW9fupycmkbMPbVGxbgXXX40rpScKkBcSPvbTJ7euttXgKMqjf8Qr1e97CNlTijO9OxPAbCR923em9hqyF0m2Q+xzkvgD1heBKhN63Qp8vQ4fBn+UhFREREREREWk3mqskOi+TRB/RcrP/8jZ4yV2aw84XtnF49UGM09B7dj+G3TKK7pN7YBynVuZYaynZeZADb6zj8PuZeOvcxPXuQp8FE+kxe0yzVUPemhqOr1nD0Q8+oDInB+N0kpieTpfp0+k4ahSOJqqGGoryKdv4DuUbF+MpO44jIpr40TPpMP5yInoMabJqyFeeT92uRdTvXISvLA9CIwjvfynhQ68jrMckjPlE4qqmAA4+DweehfLd4AiFrpdB71ug2+XgDPvMj62IiIiIiIhIe/K5lptJ6ynaVcjul7ez9z+7qS+vI7pzDBO+exFDbhxBdMrpy6lqCsvIe3czBxdvpPLgcUIiwkiblU7v+RPpOLhH08u8/H7Kdu3i6AcfULRhA363m6ju3el7xx10njKFsPj402J8ddVUbP2Asg1vU3tgOxgH0QPHkbLg68QOm4IjLPy0GH9DNQ1736Fu5yuB5WRAaNpEoiZ9E1f/y3C4PpG48lTD4VcDiaFjywEbWE427lHocR2Ed/xMj6mIiIiIiIiInO68TBK1993N6kpr2fv6brJe2kHRrkKcYU56z+7H4BuG0/2iHjicp1bZeGrqyV+xjYNLNlGYsQ+sJWl4L8b+6CbSZo4mNOr0hA0ElpMdX72a46tXU19cTEhkJF0uuYQu06cT07v3aQkl6/NStWcjFRnvBZaTeRpwJfcgZf59xI+9lND4ppageXHnraV+5yLqsxeDtx5nQk+ipn6fiCFX44zrdmqA3wPHPoDcf8Ph18BbC9E9YfhPodfNENv38z24IiIiIiIiItIkLTc7T/h9fg6vPsiuF7eTuzQHn9tHp6EpDL5+GAMWDCa8Q8Rpty/cnM3BJRvJX7EdX72b6K6J9Jw7lh6XjiWmW1KT56k/cYLCDz/k2OrVVB88iHE4SBgxgs7TppE0dixOl+uU21u/n9rc7ZRnLKViy/v4aipwRMSctJxs8OnJJOvHcySD+t2vU7/3bWztCUx4HOEDryB82LWEdhl1aozfB4WrIO8lOPQfaDgBYfGBaqFet0CnSdqdTEREREREROQLouVm5yFrLUW7Ctn7n11kv5lFTWE14R0iGHbLKAZfP4ykwcmn3b485wh572aQ995m6oorCI2JoOelY+k5dyyJw3o1uZzMW1tL0fr1HF+9mtKdO8FaYvv2pd9XvkLKpEmnLSez1lJ/JIfyzPeoyFiKp6wQE+oidthU4sfMJnrgeBwhoafFeAt3BRJDe97EX3kUQsJx9Z1J+KD5uHpfjAk5qaLJ+qF4PRx8EQ4tgrrjgW3rU68IbF3fdTY4m66AEhEREREREZEv3nmZJGrry83KD5WR/dpu9r62m9L9J3CEOuh5SR8GXj2EnjP6EOI6dVoqDh7n0LJMDi/LpPJQIcbpoMukwfT8zji6ThqC0xV62jl8DQ2c2LKFwrVrKd68Gb/bTURKCj2vu47OU6YQ2aXLaTENxUeoyHiP8oylNBw/CA4nMYPGk3zFfcQOm4IzPPK0GG/JfuqzXqc+6w18pbngCCGs1zTCp/0QV99Zp/YZshZOZMDBlwJVQ7VHwOGCbpdBzxsCf4ecfg4REREREREROfu03OwcqSutZd+be9jz2m6OZRwBoOv4VAZcOYR+lw04bTlZ1ZFiDi/L5NCyLZTvLwBjSB7Vl+4zR5F6yUjCm9idzNfQwImtWylct46SzZvx1dcTGhtL8uTJdJ4yhdh+/U6rNGooPETF1uVUbFtBff5eACJ7jyB+zGziRk5vctt6b0kO9XvfoWHvO3iLsgBDWNpEXIPmEz5gLo6IDv+9sfVDyaZAf6G8RVCdG9iZrMvsQMVQ6hUQFvv5HlwREREREREROWNabtZKjm89yoY/r+HQqlz8Xj+JA5OY/KOL6b9gELFd4065bU1hGYffDySGSrMOAZA4rBejv3MN3aePIiIx7rTv73O7ObF1K0Xr1lG8aVMgMRQTQ8qUKXSaOJEOQ4actm19/bFcKrYup3LrcuqP7gcgoucQUq78JnGjZhCWkHLK7QNLyXbTsPcd6rMX4zsRiAntlk7MjF/iGjQPZ/RJS+P8HihcDYdeCySH6o6CCYHOl8CwH0P3K8HVARERERERERE5fyhJdJZ56z0UZxUy6u6xDLhyCEmDTt0BrPJQIUdWbid/5TZO7A4khhIGdGfkN6+k+4xRRKUknPY9T0kMbd6Mr64ukBi66KJAYmjo0FMSQ9Za6gtyPk4MNRTmgTFE9hpO52u+Q+yIaYR1+GT/Iz/eo9sCFUPZS/CVHwLjILT7eCJH34Gr/xycMSclk3z1cHQZHHoVjrwJDaXgjICuc6D7VYGlZEoMiYiIiIiIiJy3zsvlZif1JLorJyentYfzuVhrwYJxmI//XbbvCPkrtnFk5XYqco8BkDCwO6nThtN9xihiUk/fSt5TVUVJZiZFGzdSum3bxxVDSePGkTxpUqBiKOS/OT/r81Kbu4PKnR9SuWM17uJ8MA6i+o4ibuQlxA6fRmhc4qlj9XnwHNlMffa7NGQvxl91DByhhPWYjGvAXML7zsYR1fG/AQ1lUPBuoFqoYDF4ayA0DlLnBRJDXWerx5CIiIiIiIjIeaa55WbnZZLoI22lJ5Hf56dkRy75K7dzZOU2ao6VYhyGpJF9SJ02nG5ThzdZMVRXVETxpk0Ub9xIeVYW1u/HlZBA0tixJI0bd1piyFdfQ3XWBip3rqZq91p8NZUYZwhR/dIDiaFhUwmJObWax19XTkPuStw5y2jIXYGtrwCnC1fvabj6z8XVdyaO8MZlbtZCZTbkvw1H3oaiNWB9EJ4M3RcEEkMp08AZdhYfTRERERERERH5PNSTqJUc+XAnm37zPPWlVThCQ0gZO4Ahd15K14uGEt4h5pTbWmupzsujeNMmijZupPrgQQCiUlNJu/JKksaNI7Z3b4zD8XGMu6yQqsZqoZqcTKzXgzMqlpjBk4gdOoXogeNwRpza5NpbepCG/ctoyFmG5/BGsD5MZEdc/Wbj6jOTsF5TcYRFBW7sc8OxDyD/rUBiqOpA4HiHYTDkf6Db5ZA4Fhyn9j0SERERERERkQuLkkRnWXSXjnQa1ZfUi0fQZcIgQqNP3cXMW1dH2c6dlGRmUrJlCw0lJWAMcf370/e220gaO/aU7eqt30ftwZ1U7V5P5a4Pqc/PBiAsKZWOU68jduhFRPYahnGetPTM78VTsIWGnGU05Cz9uPF0SNIAIifci6vPTEK7jMR8lOipK4T9iwJJoaPvgacqsFV95+kw6DuB/kLR3c/yIyciIiIiIiIi55KWm51j1lpqjx6lJDOTE1u2ULZ7N9brxRkeTsLw4SSmp5OYno4rPv7jGE9FCdV7NlCVtYHqvRvw1VQGGk/3HEbssIuIGToFV3LaKdvb+yoLaMhdhTt3Je68NYFlZI5QwrqPx9V3Jq6+M3HGNyZ6fA1QtC6QEDr6HpRuCxyP6AKplweqhVIugdCoc/dAiYiIiIiIiMhZcUEtNzupcXVrD+UL4WtooGzXLkq2bOFEZiZ1hYVAYBlZ6mWXkThqFPEDB+IIDQUCTadrcrZQlbWBqqx11B/ZB0BITAIxQy4iZtAEogeMJSQ6/uNzWG89DfmbcB9YQUPuKnwlgQojR0znQG+hXtMCy8hcMY29hXJgz18DSaHjKwNNp00IdJoEI38T2JUsYSSclHgSERERERERkbZLlURnWeG6dex+6CH8bjeOsDAShg0jcfRoOo4aRUSnwC5m1lrcxflUZ2+mes9GqrM346+vAYeTqF7DiB40gZhBEwjv2vfjfkTWWnwnDuA+uCrQePrQOvDWgzOMsO7jCes1FVevi3Em9gtUGDWUBpJBR9+Do0uhOi8wwJg+0GUWdJkNnS+G0Jim74iIiIiIiIiItAkXVCVRWxKdlkbXmTNJHD2a+MGDcYYFdv7ylBdTtmkJNdmbqc7ejKcsUF0UGt+JuNEzA9VC/cec0nTaV3EEd95a3IfW4M5bh7/6OADOhF5EjPgSrl5TCes+ARMWCe5KKFwNGU/A8RWNS8hsIAmUMh0Gfz+wRX1Mr3P9kIiIiIiIiIjIeUiVROeIr7aS6n2ZVGdnUJO9mYbCPACcUbFE9U0nun860f3HENap+8e9hXzVxbgPrcVzaC3uvLX4yg8BYCI7EpY2ibC0iYT1nEJIhzTw1EDRWji+PJAUOpEZ2J7e4YJOEyDl4kBfoaRx4AhtrYdBRERERERERFqZKolaSfXeTRx/42/U5WeDtZiwcKL6jKTDxCuI7j/mlCVk/tpSGva9i/vQukBSqLGvkHHFEpY2gcgxdxKWNglnUn+MtwaKN0DeU7BhOZRsAr8n0FcoaRwM/WEgMZQ0AUIiWhqiiIiIiIiIiIiSRGebwxWBCQ2n06VfIbr/GCJ6DMYREoq1Fn/FEep3v4onfxPu/E34TuQEgkLCCUsdR8TQqwlLm0RIylBMfVGgUijvcdi0JrB8zPrAOKBjOgz6diAp1GkShEa3OCYRERERERERkU/ScrNzxFo/3uJsPPkbcedvwpO/CX/VMSBQKRTaLZ2w1LGEpo4jNGUYpjYPCtdAUeOfqgOBb+SMCFQKdZoc+JM0AcJiW++OiYiIiIiIiMgF5YJabmaMmQfM69OnT2sP5XNz52+mZv1f8RzJwNZXAOCITiE0dWxjUmgsIXEpmNItULwR9v0a1q6HhpLAN3AlBpJB/e8N/J0wEpxhrXiPRERERERERKQtOi+TRNbat4C30tPT72rtsXxuPje+0jzCB1xGaLcxhHYbjdNfhinZBCUrYf0foGLvf28fNwC6XQbJFwWSQrH9oLGRtYiIiIiIiIjI2XJeJonakrDkviTO/lqgSujIX2DHVvDVB/4zvBMkjoOeXwosIUscA2HxrTlcEREREREREWmnlCQ6246vgNU3gjMcOo6G/l+DxLGBpFBUmqqEREREREREROS8oCTR2dZ1NlyeCR2GgiO0tUcjIiIiIiIiItIkJYnOtrB46DiqtUchIiIiIiIiItIiR2sPQEREREREREREWp+SRCIiIiIiIiIioiSRiIiIiIiIiIicp0kiY8w8Y8wTFRUVrT0UEREREREREZF24bxMEllr37LW3h0XF9faQxERERERERERaRfOyySRiIiIiIiIiIicW0oSiYiIiIiIiIiIkkQiIiIiIiIiIqIkkYiIiIiIiIiIoCSRiIiIiIiIiIgAxlrb2mNoljGmGDjU2uP4AiQCJa09CGkVmvv2S3Pffmnu2y/NffuluW+/NPftl+a+fWpL855mrU365MHzOknUVhhjMqy16a09Djn3NPftl+a+/dLct1+a+/ZLc99+ae7bL819+9Qe5l3LzUREREREREREREkiERERERERERFRkuhceaK1ByCtRnPffmnu2y/NffuluW+/NPftl+a+/dLct09tft7Vk0hERERERERERFRJJCIiIiIiIiIiShKddcaYOcaYbGPMfmPMD1p7PPLFMsakGmNWGGOyjDG7jTH3Nx7/hTGmwBizrfHP3JNiftj4fMg2xsxuvdHL52WMyTPG7Gyc44zGYwnGmGXGmJzGvzs0HjfGmIcb536HMWZU645ePgtjTP+TruttxphKY8y3dM23XcaYp40xRcaYXScd+9TXuTHmtsbb5xhjbmuN+yJnrpl5f8AYs7dxbl8zxsQ3Hu9hjKk76fp//KSY0Y3vE/sbnxumFe6OfArNzP2nfo3XZ4ALTzNz/9JJ855njNnWeFzXfRvSwme6dvl+r+VmZ5ExxgnsA2YCR4DNwI3W2qxWHZh8YYwxnYHO1totxpgYIBNYAFwHVFtrH/zE7QcBC4GxQBfgfaCftdZ3TgcuXwhjTB6Qbq0tOenYH4BSa+3vGn8o7GCt/Z/GHyi/AcwFxgEPWWvHtca45YvR+BpfQGA+70DXfJtkjJkCVAPPWmuHNB77VNe5MSYByADSAUvgvWK0tbasFe6SnIFm5n0WsNxa6zXG/B6gcd57AG9/dLtPfJ9NwDeBjcBi4GFr7ZJzdDfkM2hm7n/Bp3iNb/xvfQa4wDQ195/4/z8CFdbaX+m6b1ta+Ex3O+3w/V6VRGfXWGC/tTbXWusGXgTmt/KY5AtkrT1mrd3S+HUVsAfo2kLIfOBFa22DtfYgsJ/A80TajvnAvxq//heBN5iPjj9rAzYA8Y1vSHLhmg4csNYeauE2uuYvcNba1UDpJw5/2ut8NrDMWlva+IPiMmDOWR+8fGZNzbu1dqm11tv4zw1At5a+R+Pcx1prN9jAb2Wf5b/PFTlPNXPNN6e513h9BrgAtTT3jdVA1xFICjZL1/2FqYXPdO3y/V5JorOrK5B/0r+P0HICQS5gjb9RGEngtwYAX28sP3z6o9JE9Jxoayyw1BiTaYy5u/FYsrX2WOPXx4Hkxq81923PDZz6w6Ku+fbj017neh60PV8GTq4M6GmM2WqMWWWMuajxWFcCc/0RzfuF7dO8xuuab3suAgqttTknHdN13wZ94jNdu3y/V5JI5AtgjIkG/gN8y1pbCTwG9AZGAMeAP7be6OQsmmytHQVcCtzXWKb8scbfIGlNbxtkjAkDrgBeaTyka76d0nXe/hhjfgx4gecbDx0DultrRwLfBl4wxsS21vjkrNBrvNzIqb8Y0nXfBjXxme5j7en9Xkmis6sASD3p390aj0kbYowJJfBi8ry19lUAa22htdZnrfUDT/Lf5SV6TrQh1tqCxr+LgNcIzHPhR8vIGv8uary55r5tuRTYYq0tBF3z7dCnvc71PGgjjDG3A5cDX2r8wEDjUqMTjV9nAgcI9KUp4NQlaZr3C9RneI3XNd+GGGNCgKuAlz46puu+7WnqMx3t9P1eSaKzazPQ1xjTs/G3zjcAb7bymOQL1Lg++Slgj7X2TycdP7nXzJXAR7skvAncYIxxGWN6An2BTedqvPLFMcZENTa2wxgTBcwiMM9vAh/tZHAb8Ebj128CtzbuhjCeQOPDY8iF6pTfKOqab3c+7XX+HjDLGNOhcZnKrMZjcgExxswBvg9cYa2tPel4UmMje4wxvQhc57mNc19pjBnf+PPCrfz3uSIXkM/wGq/PAG3LDGCvtfbjZWS67tuW5j7T0U7f70NaewBtWePuF18n8MRwAk9ba3e38rDkizUJuAXYaRq3xAR+BNxojBlBoCQxD7gHwFq72xjzMpBFoFT9Pu1ydMFKBl4LvKcQArxgrX3XGLMZeNkYcydwiECTQwjsbjGXQFPLWgK7YckFqDEpOJPG67rRH3TNt03GmIXANCDRGHME+DnwOz7FdW6tLTXG/C+BD44Av7LWnmljXGkFzcz7DwEXsKzxtX+DtfarwBTgV8YYD+AHvnrS/H4NeAaIINDDSDscneeamftpn/Y1Xp8BLjxNzb219ilO70EIuu7bmuY+07XL93vTWCkrIiIiIiIiIiLtmJabiYiIiIiIiIiIkkQiIiIiIiIiIqIkkYiIiIiIiIiIoCSRiIiIiIiIiIigJJGIiIiIiIiIiKAkkYiIiIiIiIiIoCSRiIiIiIiIiIigJJGIiIiIiIiIiAD/HxMx9Snl0GO+AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# colors = pu.color_gradient(len(amp_events), (255, 160, 0), (120, 0, 160))\n", + "# plt.figure(figsize=(20,5))\n", + "# for i in range(len(amps)):\n", + "# plt.plot(trade_sizes[i], color=colors[i])\n", + "# plt.title('trade size')\n", + "\n", + "# plt.figure(figsize=(20, 5))\n", + "# for i in range(len(amps)):\n", + "# usda_prices = pu.get_datastream(amp_events[i], asset='USDA')\n", + "# plt.plot(usda_prices, color=colors[i])\n", + "# plt.yscale('log')\n", + "# plt.title('price')\n", + "\n", + "# print(min(usda_prices))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 264, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "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" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "colors = pu.color_gradient(len(amp_events), (255, 160, 0), (120, 0, 160))\n", + "impermanent_loss = []\n", + "usda_prices = []\n", + "for i, events in enumerate(amp_events):\n", + " prices = [{tkn: event.external_market[tkn] for tkn in assets} for event in events]\n", + " withdraw_vals = [\n", + " value_assets(prices=prices[i], assets=event.agents['LP'].holdings)\n", + " for i, event in enumerate(events)\n", + " ]\n", + "\n", + " deposit_vals = [\n", + " value_assets(prices=prices[i], assets=initial_state.agents['LP'].holdings)\n", + " for i, event in enumerate(events)\n", + " ]\n", + " usda_prices.append([event.external_market['USDA'] for event in amp_events[i]])\n", + " impermanent_loss.append([withdraw_vals[i] / deposit_vals[i] - 1 for i in range(len(amp_events[i]))])\n", + "\n", + "# zoom in\n", + "plt.figure(figsize=(20,5))\n", + "plt.title('impermanent loss as a function of depegged asset price (small change)')\n", + "plt.xscale('log')\n", + "plt.grid()\n", + "plt.xticks(\n", + " [0.98, 0.99, 1, 1.01, 1.02],\n", + " ['$0.98', '$0.99', '$1.00', '$1.01', '$1.02']\n", + ")\n", + "plt.yticks(\n", + " [-0.002 * i for i in range(7)],\n", + " [f'-{round(0.2 * i * 10, 2) / 10}%' for i in range(7)]\n", + ")\n", + "\n", + "# clear default ticks\n", + "for t in plt.gca().xaxis.get_minor_ticks():\n", + " t.set_visible(False)\n", + "\n", + "for i, loss in enumerate(impermanent_loss):\n", + " price_min, price_max = 0.98, 1.02\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0]) + 1\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0])\n", + " plt.plot(usda_prices[i][start_range: end_range], loss[start_range: end_range], color=colors[i])\n", + "plt.legend(amps, loc='center', title='amplification')\n", + "\n", + "# medium zoom\n", + "plt.figure(figsize=(20,5))\n", + "plt.title('impermanent loss as a function of depegged asset price (medium change)')\n", + "plt.xscale('log')\n", + "plt.grid()\n", + "plt.xticks(\n", + " [0.8, 0.9, 1, 1.12, 1.25],\n", + " ['$0.80', '$0.90', '$1.00', '$1.12', '$1.25']\n", + ")\n", + "plt.yticks(\n", + " [-0.025 * i for i in range(6)],\n", + " [f'-{2.5 * i}%' for i in range(6)]\n", + ")\n", + "\n", + "for i, loss in enumerate(impermanent_loss):\n", + " price_min, price_max = 0.8, 1.25\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0]) + 1\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0])\n", + " plt.plot(usda_prices[i][start_range: end_range], loss[start_range: end_range], color=colors[i])\n", + "plt.legend(amps, loc='center', title='amplification')\n", + "\n", + "# zoom out\n", + "plt.figure(figsize=(20,5))\n", + "plt.title('impermanent loss as a function of depegged asset price (extreme change, log scale)')\n", + "plt.xscale('log')\n", + "plt.grid()\n", + "plt.yscale('log')\n", + "plt.yticks(\n", + " [1, 0.1, 0.01, 0.001],\n", + " ['0%', '-90%', '-99%', '-99.9%']\n", + ")\n", + "tick_prices = [0.001, 0.01, 0.1, 1, 10, 100, 1000]\n", + "plt.xticks(\n", + " tick_prices,\n", + " ['$0.001', '$0.01', '$0.10', '$1.00', '$10', '$100', '$1000']\n", + ")\n", + "if 1 in tick_prices:\n", + " tick_prices.remove(1)\n", + "\n", + "\n", + "for i, loss in enumerate(impermanent_loss):\n", + "\n", + " price_min, price_max = 0.01, 100\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0]) + 1\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0])\n", + " plt.plot(usda_prices[i][start_range: end_range], [1 + loss for loss in loss[start_range: end_range]], color=colors[i])\n", + "\n", + "plt.legend(amps, loc='center', title='amplification')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": 4 +} From 5d5cfd6b69901cb29654a25ce825eb89139fab7a Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:22:47 -0500 Subject: [PATCH 06/32] fixed test_buy_from_stableswap --- hydradx/tests/test_stableswap_subpools.py | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/hydradx/tests/test_stableswap_subpools.py b/hydradx/tests/test_stableswap_subpools.py index 48271f24..73ee13de 100644 --- a/hydradx/tests/test_stableswap_subpools.py +++ b/hydradx/tests/test_stableswap_subpools.py @@ -33,12 +33,7 @@ def test_buy_from_stable_swap(initial_state: oamm.OmnipoolState): return new_d = new_stable_pool.calculate_d() d = stable_pool.calculate_d() - if not (stable_swap_equation( - new_d, - new_stable_pool.amplification, - new_stable_pool.n_coins, - new_stable_pool.liquidity.values() - )): + if not stable_swap_equation(new_stable_pool): raise AssertionError("Stableswap equation didn't hold.") if not ( d * new_stable_pool.shares <= @@ -99,12 +94,7 @@ def test_sell_stableswap_for_omnipool(initial_state: oamm.OmnipoolState): if new_state.fail: # transaction failed, doesn't mean there is anything wrong with the mechanism return - if not (stable_swap_equation( - new_stable_pool.calculate_d(), - new_stable_pool.amplification, - new_stable_pool.n_coins, - new_stable_pool.liquidity.values() - )): + if not stable_swap_equation(new_stable_pool): raise AssertionError("Stableswap equation didn't hold.") if not ( stable_pool.calculate_d() * new_stable_pool.shares == From b684736916900d0bfbdaf21b1a2317addb0b0647 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:24:22 -0500 Subject: [PATCH 07/32] fixed references to stable_swap_equation and spot_price to reflect new parameters --- hydradx/tests/test_stableswap.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index c6a08821..6fb80a26 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -74,16 +74,16 @@ def test_spot_price(token_a: int, token_b: int, amp: int): unique_id='stableswap' ) - spot_price_initial = initial_pool.spot_price() + spot_price_initial = initial_pool.spot_price('B', 'A') - trade_size=1 + trade_size = 1 agent = Agent(holdings={"A": 100000, "B": 100000}) initial_pool.swap(agent, tkn_sell="A", tkn_buy="B", sell_quantity=trade_size) delta_a = initial_pool.liquidity["A"] - tokens["A"] delta_b = tokens["B"] - initial_pool.liquidity["B"] exec_price = delta_a / delta_b - spot_price_final = initial_pool.spot_price() + spot_price_final = initial_pool.spot_price('B', 'A') if spot_price_initial > exec_price: raise AssertionError('Initial spot price should be lower than execution price.') @@ -209,7 +209,7 @@ def test_add_remove_liquidity(initial_pool: StableSwapPoolState): add_liquidity_state, add_liquidity_agent = stableswap.simulate_add_liquidity( initial_pool, old_agent=lp, quantity=10000, tkn_add=lp_tkn ) - if not stable_swap_equation(add_liquidity_state.calculate_d()): + if not stable_swap_equation(add_liquidity_state): raise AssertionError('Stableswap equation does not hold after add liquidity operation.') remove_liquidity_state, remove_liquidity_agent = stableswap.simulate_remove_liquidity( @@ -218,7 +218,7 @@ def test_add_remove_liquidity(initial_pool: StableSwapPoolState): quantity=add_liquidity_agent.holdings[initial_pool.unique_id], tkn_remove=lp_tkn ) - if not stable_swap_equation(remove_liquidity_state.calculate_d()): + if not stable_swap_equation(remove_liquidity_state): raise AssertionError('Stableswap equation does not hold after remove liquidity operation.') if remove_liquidity_agent.holdings[lp_tkn] != pytest.approx(lp.holdings[lp_tkn]): raise AssertionError('LP did not get the same balance back when withdrawing liquidity.') @@ -323,9 +323,9 @@ def test_exploitability(initial_lp: int, trade_size: int): if profit > 0: raise AssertionError(f'Agent profited by exploit ({profit}).') - if initial_state.spot_price < final_state.spot_price: + if initial_state.spot_price('USDA', 'USDB') < final_state.spot_price('USDA', 'USDB'): min_arb_size = arb_size - elif initial_state.spot_price > final_state.spot_price: + elif initial_state.spot_price('USDA', 'USDB') > final_state.spot_price('USDA', 'USDB'): max_arb_size = arb_size else: break From 358e1558d35891b5ce6a55cf919665795a00f8ba Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:24:42 -0500 Subject: [PATCH 08/32] fixed stableswap_arbitrage --- hydradx/model/amm/trade_strategies.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/hydradx/model/amm/trade_strategies.py b/hydradx/model/amm/trade_strategies.py index e8ecb68e..7c6cf6d3 100644 --- a/hydradx/model/amm/trade_strategies.py +++ b/hydradx/model/amm/trade_strategies.py @@ -584,7 +584,10 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): balance_in = stable_pool.calculate_y( stable_pool.modified_balances(delta={buy_asset: -buy_amount}, omit=[sell_asset]), d ) - return stable_pool.price_at_balance([balance_in, balance_out], d) + balances = {tkn: stable_pool.liquidity[tkn] for tkn in stable_pool.asset_list} + balances[buy_asset] = balance_out + balances[sell_asset] = balance_in + return stable_pool.price_at_balance(balances, buy_asset, sell_asset) delta_y = find_agent_delta_y(target_price, price_after_trade, precision=precision) delta_x = ( From 672e21b3f49a104d3b9a107d4b8842c2bff6b384 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:28:51 -0500 Subject: [PATCH 09/32] re-added price_at_balance, which is used by arbitrageur in trade_strategies --- hydradx/model/amm/stableswap_amm.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index 8892cfe8..634008a1 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -116,12 +116,15 @@ def spot_price(self, tkn: str, numeraire: str): """ return the price of TKN denominated in NUMÉRAIRE """ + return self.price_at_balance(self.liquidity, tkn, numeraire) + + def price_at_balance(self, balances: dict, tkn: str, numeraire: str): c = self.amplification * self.n_coins ** (2 * self.n_coins) p = 1 - for x in self.liquidity.values(): + for x in balances.values(): p *= x - x = self.liquidity[numeraire] - y = self.liquidity[tkn] + x = balances[numeraire] + y = balances[tkn] n = self.n_coins d = self.d return (x / y) * (c * y * p + d ** (n + 1)) / (c * x * p + d ** (n + 1)) From 94c79f75edbe79b3830324e4d431d01b5ec6acf3 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:29:35 -0500 Subject: [PATCH 10/32] cleaned up --- .../ImpermanentLossAnalysis4Assets.ipynb | 81 ++----------------- 1 file changed, 8 insertions(+), 73 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index a99edcb2..b23799c8 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 250, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.614450927Z", @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 251, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -105,8 +105,7 @@ "0.000995282647861672 248441.28060711964\n", "199.67207475942692 -88073.92649009275\n", "0.0009588261640137211 248664.96721939923\n", - "199.42914906713446 -86684.69418227047\n", - "[[247276.40443434505, -99990.00099990002], [247647.57879376572, -96686.31486433979], [247944.91939021496, -92802.53170641157], [248217.79521216897, -90032.92489873343], [248441.28060711964, -88073.92649009275], [248664.96721939923, -86684.69418227047]]\n" + "199.42914906713446 -86684.69418227047\n" ] } ], @@ -145,44 +144,12 @@ "\n", " if i < len(amps) - 1:\n", " trade_range[i+1] = copy.copy(trade_range[i])\n", - "print(trade_range)" + "# print(trade_range)" ] }, { "cell_type": "code", - "execution_count": 252, - "metadata": { - "ExecuteTime": { - "end_time": "2023-07-06T20:00:31.857764207Z", - "start_time": "2023-07-06T20:00:31.681435289Z" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[247276.40443434505, -99990.00099990002], [247647.57879376572, -96686.31486433979], [247944.91939021496, -92802.53170641157], [248217.79521216897, -90032.92489873343], [248441.28060711964, -88073.92649009275], [248664.96721939923, -86684.69418227047]]\n", - "4914.45636725769\n" - ] - } - ], - "source": [ - "test_state = invested_state.copy()\n", - "test_state.amplification=amps[0]\n", - "print(trade_range)\n", - "test_state.pools['stableswap'].swap_one(\n", - " agent=try_state.agents['Trader'],\n", - " tkn_sell='USDA',\n", - " quantity=trade_range[0][1]\n", - ")\n", - "print(test_state.pools['stableswap'].spot_price('USDA', 'USDD'))" - ] - }, - { - "cell_type": "code", - "execution_count": 262, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -248,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 263, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -256,39 +223,7 @@ }, "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0053090963534165\n" - ] - }, - { - "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" - } - ], + "outputs": [], "source": [ "# colors = pu.color_gradient(len(amp_events), (255, 160, 0), (120, 0, 160))\n", "# plt.figure(figsize=(20,5))\n", @@ -308,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 264, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", From 90b831363bf0f942e91dd3cc1f87d09501651694 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:31:47 -0500 Subject: [PATCH 11/32] fixed and extended test_arbitrage for 4-asset pools --- hydradx/tests/test_stableswap.py | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 6fb80a26..ab4b9165 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -159,7 +159,7 @@ def test_buy_shares(initial_pool: StableSwapPoolState): raise AssertionError("Asset values don't match.") -@given(stableswap_config(asset_dict={'R1': 1000000, 'R2': 1000000}, trade_fee=0)) +@given(stableswap_config(asset_dict={'R1': 1000000, 'R2': 1000000, 'R3': 1000000, 'R4': 1000000}, trade_fee=0)) def test_arbitrage(stable_pool): initial_state = GlobalState( pools={ @@ -167,36 +167,38 @@ def test_arbitrage(stable_pool): }, agents={ 'Trader': Agent( - holdings={'R1': 1000000, 'R2': 1000000}, - trade_strategy=random_swaps(pool_id='R1/R2', amount={'R1': 10000, 'R2': 10000}, randomize_amount=True) + holdings={'R1': 1000000, 'R2': 1000000, 'R3': 1000000, 'R4': 1000000}, + trade_strategy=random_swaps( + pool_id='R1/R2', amount={'R1': 10000, 'R2': 10000, 'R3': 10000, 'R4': 10000}, randomize_amount=True + ) ), 'Arbitrageur': Agent( - holdings={'R1': 1000000, 'R2': 1000000}, + holdings={'R1': 1000000, 'R2': 1000000, 'R3': 1000000, 'R4': 1000000}, trade_strategy=stableswap_arbitrage(pool_id='R1/R2', minimum_profit=0, precision=0.000001) ) }, external_market={ 'R1': 1, - 'R2': 1 + 'R2': 1, + 'R3': 1, + 'R4': 1 }, # evolve_function = fluctuate_prices(volatility={'R1': 1, 'R2': 1}, trend = {'R1': 1, 'R1': 1}) ) - events = run.run(initial_state, time_steps=10, silent=True) + events = run.run(initial_state, time_steps=50, silent=True) # print(events[0].pools['R1/R2'].spot_price, events[-1].pools['R1/R2'].spot_price) if ( - events[0].pools['R1/R2'].spot_price - != pytest.approx(events[-1].pools['R1/R2'].spot_price) + events[0].pools['R1/R2'].spot_price('R1', 'R2') + != pytest.approx(events[-1].pools['R1/R2'].spot_price('R1', 'R2'), abs=0.000001) ): raise AssertionError(f"Arbitrageur didn't keep the price stable." f"({events[0].pools['R1/R2'].spot_price})" f"{events[-1].pools['R1/R2'].spot_price}") if ( - events[0].agents['Arbitrageur'].holdings['R1'] - + events[0].agents['Arbitrageur'].holdings['R2'] - > events[-1].agents['Arbitrageur'].holdings['R1'] - + events[-1].agents['Arbitrageur'].holdings['R2'] + sum(events[0].agents['Arbitrageur'].holdings.values()) + > sum(events[-1].agents['Arbitrageur'].holdings.values()) ): - raise AssertionError("Arbitrageur didn't make money.") + raise AssertionError("Arbitrageur lost money.") @given(stableswap_config(trade_fee=0)) From 196819457b869dd54e6fcacf17492c6394d133ac Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 22 Sep 2023 13:40:30 -0500 Subject: [PATCH 12/32] added some liquidity graphs at the bottom --- .../ImpermanentLossAnalysis4Assets.ipynb | 159 +++++++++++++++++- 1 file changed, 158 insertions(+), 1 deletion(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index b23799c8..0fe0f303 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -7,7 +7,7 @@ "

Relationship between IL and price change in a stableswap pool

\n", "Here we investigate the impermanent loss experienced by an LP in a stableswap pool when one of the assets depegs (its value deviates from 1USD). Because the assets in a stableswap pool are expected to remain stable, the pool is optimized to give a better execution price, with less slippage, at the expense of being more vulnerable to impermanent loss in the event of a price change. For the sake of simplicity, the LP both deposits and withdraws a proportional amount of each token (so that these trades don't induce further price changes). Note that the general dynamics and scale of the impermanent loss will hold regardless of which asset the LP chooses to deposit or withdraw.\n", "

\n", - "An important parameter of the stableswap pool is its amplification, which affect the shape of the price curve. At an amplification of 0, the stableswap pool behaves identically to an XYK pool, whereas at an amplification of infinity, the price of each asset remains at exactly 1 until the pool runs out of liquidity. At an intermediate value, the price remains stable at a wider range of balances than it would in an XYK pool, but hits a 'cliff' when the balance shifts too far in either direction. Higher values give a more stable price but a steeper cliff, and are more appropriate when there is high confidence in the stability of the underlying assets. Here we will graph the IL dynamics for a range of amplification values." + "An important parameter of the stableswap pool is its amplification, which affect the shape of the price curve. At an amplification of 0, the stableswap pool behaves identically to an XYK pool, whereas at an amplification of infinity, the price of each asset remains at exactly 1 until the pool runs out of liquidity. At an intermediate value, the price remains stable at a wider range of balances than it would in an XYK pool, but hits a 'cliff' when the balance shifts too far in either direction. Higher values give a more stable price but a steeper cliff, and are more appropriate when there is high confidence in the stability of the underlying assets. Here we will graph the IL dynamics for a range of amplification values in a pool with four assets." ] }, { @@ -384,6 +384,163 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "Amplification = 25" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIMAAAE/CAYAAADVOwNeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB0L0lEQVR4nO3dd5hcZfn/8fe9vfdNsukJ6T1hCaE3gYBSVKSpgCJYUNGfDfT7FdQvKjYUURQBCSoEBBHEUENvIb23Td0km2yv2T7P7485CZuwSXaT3T1TPq/rmmtnnjlz5j47k3tP7vMUc84hIiIiIiIiIiLRIcbvAEREREREREREpO+oGCQiIiIiIiIiEkVUDBIRERERERERiSIqBomIiIiIiIiIRBEVg0REREREREREooiKQSIiIiIiIiIiUUTFoD5iZmea2Y7DPP+Qmf1fX8bUG8zsNTP7gnf/02b2Yg/t9zkzu/YQzw03M2dmcUfaViTaKRcd836Vi0R6gHLRMe9XuUjkGCkPHfN+lYfCnIpBR8nMbjezv/sdRyhzzv3DOXdeD+3rAufcnO5ua2bXmdlbR/u+HZNnh7YD/nCY2SVmtszMas2s3MxeMbMR3nO3m1mrmdV5tw1mdo+ZFXTyXtd5SfOKo41Xoo9y0ZEpF3UtF3n7C5hZvXfbaWY/OtqYJbooFx2ZclHXz4vMLMPMfmtm2718tMl7nHe0sUvkUx46MuWhoz4n2mFmj5vZCUcbdyhSMUjkGJjZKOBh4FtAJjAC+APQ3mGzx5xz6UAO8HFgALC4k4LQtUAlcE1vxy0ikaUHc9Eu51yacy4NOBW43swu7YNDEJEI0BO5yMwSgPnARGA2kAGcBFQAM/vmSEQkXPX0ORGQDswC1gFvmtk5vX8UfUPFoCMws+95V0frzGy9mZ1jZrOB7wNXeJXC5d62nzOztd62m83si53s7/tedXKrmX36MO/7Ma+aWW1m75jZlCPElGRmjfuumJjZD8yszcwyvMc/MbPfevc/amZLvUppsZnd3mHf+7r03Whmu8ysxMy+fZS/uwOqvmZ2rpmtM7Mar/r6un3QZfGASr59uGthx+6NsWb2K+/3uBn46EHv+5qZfcHMxgN/Ak7yPqdqMzvBzPaYWWyH7T+x7zM8CtOALc65+S6ozjn3pHNu+8EbOudanXOrgSuAMoIJal8Mw4AzgBuB881swFHGIxFKuUi56Aim0QO56KDttgDvABOOMiaJQMpFykVHMI1jz0XXAEOBjzvn1jjnAs65UufcT5xz844yLokgykPKQ0cwjR48J/L2scM590PgfuDOo4wr5KgYdBhmNhb4KnCCVzk8H9jqnHse+CnBimKac26q95JS4GMEr2B8DrjLzGZ02OUAIA8YRLAXyH3eexz8vtOBB4EvArnAn4FnzCzxMDE1AQsJFhTwfm4DTunw+HXvfgPBP7RZBP+hftk+fOX3LGA0cB7wPTP7SJd+aYfgJcF/Af9D8HewqUNs3XUDwd/zdKAQuKyzjZxza4EvAe96n1OWc24hwStLHbtHfpZg9fhoLAHGmdldZnaWmaUd6QXOuXbgaeC0Ds3XAIucc08Ca4FD/iGS6KNcpFzUBT2Vi/Yzs9EEfzfvHWVMEmGUi5SLuqAnctFHgOedc/VHGYNEMOUh5aEu6PFzog7+Bcwws9SjjC2k+FoMMrMHzazUzFZ1cfvLzWyNma02s0d6Oz6CXckSgQlmFu+c2+qc23SojZ1z/3XObfKqh68DL/LhL9T/Oueavef/C1zeya5uBP7snFvgnGv3xlc2E+yedriYXgfO8Kq1U4C7vcdJwAnAG16crznnVnpXWlYAj/JBktrnR865BufcSuCvwFVd+YUdxoXAaufcE865VuC3wO6j3NflwG+dc8XOuUrgZ918/RzgMwBmlkMwYR/V98k5txk4k+AfkMeBcgtONnekpLOLYLfEfa7pEMMjaKiYHEi5SLnosHowFw30rtLVAhuABcBRj+uXiKNcpFx0WD2Ui3KBkqN5f4kKykPKQ4fVg+dEh9rGCBbtwp7fPYMeIjgW+Ii8K5S3Aqc45yYC3+i9sIKcc0Xe+9wOlJrZXDMbeJgYLzCz98ys0syqCf4D6zjRXZVzrqHD421AZ/sbBnzLOyGv9vY1BBh4hJheJ/jFnwGsBF4imERmAUXOuQovzhPN7FUzKzOzGoLV2YMn5CvuQpzdMbDjPp1z7qD3OOp9EYyvO/4OXORVdC8H3nTOHeqkow2IP6gtHmjd98A5955z7nLnXD7BPy6nAz84QgyDCM4PhJmdQnAs61zvuUeAyWY2rctHJBFNueiIcXaHctGB9ucizy4XvEqXQfBEp5HgCZqIctGR4+wO5aIDdcxFFcCHFtoQAeWhLsTZHcpDBzr4nOhQ2zig+gjbhQVfi0HOuTc46BduZseZ2fNmttjM3jSzcd5TNwB/cM5Vea8t7aMYH3HOnUowATg+GCPoDoo7EXgS+BXQ3zmXBcwjWDncJ/ugLmVDCVYXD1YM3OGdkO+7pTjnHj1CTO8AYwlOgvW6c26N9x4X8kEXRAgWG54BhjjnMgmO2+wYJwST25Hi7I6Sjvs0MzvoPRqAlA6PDzdnzgH78uI7FPehBud2Au8CnyDYBfFvh3n9dmD4QW0jOESCc8Fujv8CJh1qh2YWA1wEvOk1XUvw97/MzHYTvBK/r10EUC46QpzdoVzk6SQXHbyPGoKf0UWHiUuijHLRYePsDuUiTye56GWC8ydGxDAM6XnKQ4eNszuUhzxHOifq4OPAkoMKiGHL755BnbkP+Jpz7njg28AfvfYxwBgze9ur7napR9GxMLOxZna2l0iaCF4hDXhP7wGGe18cgASC3QPLgDYzu4ADxz3u8yMzSzCz0wiOq/xnJ9v8BfiSVyE2M0u14KRi6YeLyTm3F1gM3MQHyeUdgpXljskmHah0zjWZ2Uzg6k5i+F8zSzGziQTH1z52+N/WEf0XmGjBycDigK9zYEJZBpxuZkPNLJNgL7BDeRz4upkNNrNs4JbDbLsHGGzBlSk6ehj4LjCZYHI4lMeAz5nZTO+zGAN8E68Xj5mdamY3mFk/7/E44GI6mWPDzOIsOGnaowSP/TcW7CJ6OcGup9M63L4GXO39riTKKRcpF9HLuaizN7Rgd+orgdWHiUuiiHKRchF9k4v+RvA/3k+a2TgzizGzXAtO8nvhYWKTKKA8pDxEH58Tee8xyMxuA75AcKLyiBBSxSDvxPNk4J9mtozgxFz7uonGEZww60yC4yP/YmZZvRxSIvBzoJzg+Ml+fPCPYF+SqDCzJc65OoL/gB4Hqgj+A37moP3t9p7bBfwD+JJzbt3Bb+qcW0SwJ9Q93vZFwHVdiAmCSSUeeL/D43S88aierwA/NrM64IdezAd73Xvf+cCvnHMvdrJNlznnyoFPebFXEPws3+7w/EsE/2GvIJgwnz3M7v4CvAAsJzhB2OGSxSsE/yOz28zKO7Q/RbBy/5SXpA8V9wsEk9lfgRqCVxPmECxaQrCL4MXASjOrB5739v2LDru5wnuuhuB3ogI43jm3C7iU4B+Mh51zu/fdCE5QF0cXh1FKxFMuUi7q7Vy0z0ALru5RT/AKWw6a0F4+oFykXNTrucg510xwEul1BIfU1BL8/PL4oPe0RC/lIeWhPj0nAuoJTgQ+GTjzWH/vocSCQwN9DMBsOPCsc26SBZfZW++c+9A4YTP7E7DAOfdX7/F84Bav25f0EO/z2ALEO+faevm9XgP+7py7vzff5zDvvwn4onPuZT/eX0QOTblIREKBcpGI+E15SHpLSPUMcs7VAlvM7FOwv0vWvmUB/02wV9C+ZfDGAJt9CFMigJl9kuB41Vf8jkVEopdykYiEAuUiEfGb8lDf83U+EjN7lGCBJ8/MdgC3EeyOfq+Z/Q/B7nRzCXY3ewE4z8zWEFy+7zvOm31dpDu8ivcE4LPOucARNhcR6RXKRSISCpSLRMRvykP+8H2YmIiIiIiIiIiI9J2QGiYmIiIiIiIiIiK9S8UgEREREREREZEo4tucQXl5eW748OF+vb2I9JDFixeXO+fy/Y7jaCkXiUQG5SIRCQXhnotA+UgkEnQlF/lWDBo+fDiLFi3y6+1FpIeY2Ta/YzgWykUikUG5SERCQbjnIlA+EokEXclFGiYmIiIiIiIiIhJFVAwSEREREREREYkiKgaJiIiIiIiIiEQRFYNERERERERERKKIikEiIiIiIiIiIlFExSARERERERERkSiiYpCI9CgzSzKz981suZmtNrMfee0PmdkWM1vm3aZ57WZmd5tZkZmtMLMZHfZ1rZlt9G7Xdmg/3sxWeq+528zMa88xs5e87V8ys+w+PnwRCSHKRyISCpSLRCQUqRgkIj2tGTjbOTcVmAbMNrNZ3nPfcc5N827LvLYLgNHe7UbgXgievAC3AScCM4HbOpzA3Avc0OF1s732W4D5zrnRwHzvsYhEL+UjEQkFykUiEnJUDBKRHuWC6r2H8d7NHeYllwAPe697D8gyswLgfOAl51ylc64KeIngyVMBkOGce88554CHgUs77GuOd39Oh3YRiULKRyISCpSLRCQUxfkdwJGs2lnDyp01XDVzqN+hiEgXmVkssBgYBfzBObfAzL4M3GFmP8S7MuWcawYGAcUdXr7Daztc+45O2gH6O+dKvPu7gf49emAiclRa2wM0twVoaQvQ3NZOc2uAlvaA9zP4uLlt362dtnZHa3uAwdkpnDo675jeW/lIRPZpOyAXBfPNB/e9/NTh+da2AG2BAJnJCcyeNOCY3lu5SET2aQ+4A/OPdz7U1OH8qOPzre0B2todsTHGJ48f3GNxhHwx6IXVu/nja5v4+PRBJMXH+h2OiHSBc64dmGZmWcBTZjYJuJXgSUgCcB/wPeDHvRiDM7NOr7qZ2Y0Eu10zdKgKzSJH0tIWoHpvC5V7W6hsaKF6byuVDS1UNQTb6pvaaGhpo765nYbmNhqa26j3fjY0t9PSHjiq9/3o5IJjLgaFcj5SLhLpnrb2ANWNrcHc09BC1d4WKhtaqdobzEd1TW3Ut7Ttz0N1Xm5qaG6nvrmNlrajy0WTB2UeczEolHMRKB+JdEd7wFHT+EHuOTgf1Ta2HnAeVN+8LxcFz4+aWo8uF2WlxEdXMWh8QQbtAceGPXVMGZzldzgi0g3OuWozexWY7Zz7ldfcbGZ/Bb7tPd4JDOnwssFe207gzIPaX/PaB3eyPcAeMytwzpV4XaZLDxHXfQRPuigsLDxcN22RqFC9t4XN5Q1sq2hgV3UTu2uaKKlpoqSmkd01TVQ0tBzytWmJcaQnxZGaGLylJcaSm5pCWuIHbSkJsSTFx5AYF0tiXAwJcQffjyExPvg4PjaGhNgY4mKN1ISeO00JxXykXCRyoLqmVraUN7C1Yi8l1Y0H5KGSmibK6ptxh/iXkhwfS0byvjwUR2pCHIOzU0hLjN3flpIQ5+WiYM5JiI0h0ctN+3NR3AeP42ONuNgYkuJ6bmaNUMxFXlzKRyKexpZ2Lxc1sMvLRbs75KM9dc20Bzr/Z5IYF0NGcrx3HhRLakIcBZlJB5wnpSbGkeSd9xycf/afI8V/0BYfG0NcbDAn9aSQLwZNKMgAYG1JrYpBImHAzPKBVu9kJxk4F7izw4mIERyvvsp7yTPAV81sLsEJEWu87V4AftphYsTzgFudc5VmVutNvLgAuAb4fYd9XQv83Pv5dK8fsEgYqWpoYfWuWlbvqmHDnnq2lNezpbyBqr2tB2yXmRxPQWYSBZlJTBmcRf+MRHLTEslJSSA7NZ6c1ARyUhLISkkgoQf/k9TTlI9EQlNdUytrdtWyelctG/bUsbm8gS3lDZTVNR+wXXpiHAMykxiQmcTYAekMyEgiNy2RbC8H7ctH2SkJIT2CQLlIJDQ1trSzbncwF63bXcuW8ga2lDWwq6bpgO2S4mMYmJnMgMwkZh2Xy4CMJPLTE/fnn5zUhP15KTkhdHPRwUK+GDQ0J4XUhFjW7Kr1OxQR6ZoCYI43Nj4GeNw596yZveKdDBmwDPiSt/084EKgCNgLfA7AO7H5CbDQ2+7HzrlK7/5XgIeAZOA57wbBE53Hzex6YBtweW8dpEioa20PsHJnDe9vqWTxtipW76w54OSmf0YiI/PSuGByASPzUhmRl8qw3FQGZiWR0oM9cnymfCTis/aAY93uWt7fUskiLxdtrdi7//nc1ARG5qdy1th8RuSlMcLLRwOzkkhPivcx8h6lXCTiM+ccm8oagrloayUrd9awqayefR18MpLiGJmfxqyRucE8lJ/K8NxUhmSnkJEcR7BmG1nMHaqvZS8rLCx0ixYt6tK2n7z3HWLNePxLJ/VyVCLSXWa22DlX6HccR6s7uUgklDnn2LCnnvnr9vB2UTlLtlXT2NoOwIi8VCYNymTSwAwmDsxk4sAMslMTfI64ZykXiYSO7RV7mb9uD29tLGfh1kpqm9oAGJSVzORBmUwa9EEu6peR5HO0PSvccxEoH0nkKK1t4pV1pbyxsYz3t1RSXh8c9p6XlsDUwVlMHJjBhIHBnDQoKzmiCj5dyUVhcelvfEE6Ty/dhXMuoj4gERGRYxEIOBZsqeT5VSXMX1fKjqpGAMYNSOeKE4Ywc0QOJwzPIT890edIRSSSOedYubOG/64s4ZW1pWwsDa6iPiIvlY9OKdifiwZnp/gcqYhEuqLSep5dsYv5a0tZubMGgILMJE4fnc/METnMHJHDiLxU1RUIk2LQhIJM/v7ednZUNTIkR39EREQkuq3fXcdTS3fyzLKd7KppIik+hlNH5XHTWaM4a2w/BmRG1pV2EQlNxZV7+ffSnTy1bCebyxqIjzVOHJHLVTOHcva4fgzPS/U7RBGJAqV1TfxneQn/XrqTlTtrMIPpQ7L4zvljOWd8P8b2T1fxpxNhUQwaX5AOwJqSWhWDREQkKrW2B3hh9W7mvLOVhVuriI0xzhiTz/cuGMe5E/pH0jw/IhLCAgHHGxvLmPPOVl5dXwbAiSNyuPG0kVwwqYDMlIiZ50dEQphzjiXbq3jonW08t7KEtoBj8qBM/uej47l46sCIG4LaG8LizHHcgAxiDNbsquX8iQP8DkdERKTPNDS38bf3tvHQ21vZXdvE0JwUfnDheD4+YxB5aRr+JSJ9o6UtwJNLdnDfG5vZUt5AXloiXz9nNJcXDtbwLxHpM4GA4/nVu7n3tU2s3FlDemIc15w0nKtPHMKoful+hxdWjlgMMrMk4A0g0dv+CefcbQdtcx3wS2Cn13SPc+7+ngoyOSGW4XmprC3RimIiIhId9hWB7ntjM5UNLZwyKpc7Pj6JM8f2IzZGXZ1FpG/sKwLd80oRO6sbmTI4k99dOY0LJhWQEBfjd3giEiUCAcdzq3Zz9/yNrN9Tx8j8VH5y6SQ+MX0QqYlh0ccl5HTlt9YMnO2cqzezeOAtM3vOOffeQds95pz7as+HGDShIINlxdW9tXsREZGQEAg4nli8g1+8sJ7y+mbOGJPPzR8ZzYyh2X6HJiJRxDnHS2v2cMe8tWyr2Mu0IVnc8fFJnDEmX3NviEifWri1kh/9ZzWrdtYyql8av7tyGh+bMlAXx47REYtBLrj2fL33MN679fl69OMLMnh2RQk1ja1kJmsssoiIRJ7F2yq5/Zk1rNxZw/HDsrnvmuNVBBKRPrdxTx0/+s8a3ioqZ3S/NP563QmcOVZFIBHpW7uqG/npvLU8u6KEgswkfnvFNC6aqiJQT+lSfyoziwUWA6OAPzjnFnSy2SfN7HRgA/BN51xxz4UJEwZmALCupJYTR+b25K5FRER81dDcxi+eX8ecd7dRkJnE766cxsVTB+o/XiLSp1rbA9z72iZ+/8pGUhLiuP2iCXx61jDiYzUcTET6jnOOR97fzs/mraMtEODmc0bzpTOOIzkh1u/QIkqXikHOuXZgmpllAU+Z2STn3KoOm/wHeNQ512xmXwTmAGcfvB8zuxG4EWDo0KHdCnRCQbAYtFbFIBERiSDvbCrnu0+sYGd1I587ZTjfOX+sVgYTkT63Zlct3/7nctaU1HLR1IHcftEEcjVJvYj0seLKvXzvyRW8s6mCU0bl8vNPTNGK4r2kW2ebzrlqM3sVmA2s6tBe0WGz+4FfHOL19wH3ARQWFnZrqFm/9ERyUxNYo0mkRUQkArQHHL97eQO/f7WI4bmpPP7FkzhheI7fYYlIlHHO8ff3tvGTZ9eSkRzPnz97vFbvFRFfPL9qN995YjnOwU8/PpmrZg5RL+le1JXVxPKBVq8QlAycC9x50DYFzrkS7+HFwNqeDtTMGF+QwdqSup7etYiISJ8qrW3i63OX8t7mSi47fjA/vmSiegOJSJ+ra2rl1n+t5NkVJZwxJp+7rphGTmqC32GJSJRpaQvw8+fW8eDbW5gyOJM/XD1DvYH6QFfOPAuAOd68QTHA4865Z83sx8Ai59wzwNfN7GKgDagEruuNYCcMzOChd7bS1h4gTmOXRUQkDK3YUc0X5iyitqmVX142hU8VDvE7JBGJQtsqGvj8QwvZWrGX784ey5dOP44YTcoqIn2sor6ZL/19MQu3VnHdycO59cJxJMZpbqC+0JXVxFYA0ztp/2GH+7cCt/ZsaB82viCdlrYAm8sbGNM/vbffTkREpEc9v6qEbzy2jLy0RP590ymMG5Dhd0giEoUWba3kxr8tJuAcf7t+Jicfl+d3SCIShYpK6/n8QwvZU9vE3VdN5+KpA/0OKaqEVZ/0CQWZQHASaRWDREQknNz3xiZ+Om8d04dm8ZdrCsnTxKwi4oP/LN/Ftx5fzqDsZB687gRG5KX6HZKIRKH3Nldww8OLSIyLYe6Ns5g+NNvvkKJOWI21GpmfSkJsDGt2aRJpEREJD845fv3ien46bx0fnVzAozfMUiFIRHzx2MLtfH3uUqYNyeKpr5ysQpCI+OLV9aVc++D79M9I4qmvnKJCkE/CqmdQfGwMYwakaUUxEREJC845/u+/a3ngrS1cUTiEn35iMrGak0NEfPDgW1v48bNrOGNMPn/6zPEkJ2hODhHpe8+tLOHrc5cydkA6D3/+RE1a76Ow6hkEMH5ABmtVDBIRkRDnnOO2Z1bzwFtbuO7k4fxMhSAR8clf3tjMj59dw+yJA7jvGhWCRMQfz67YxU2PLGHK4CweuWGWCkE+C7ti0ISBGZTXt1Ba1+R3KCIiIof0ixfW8/C727jx9JHcdtEErdIjIr54ZMF27pi3lo9NKeCeq6drlR4R8cWr60r5xtxlFA7L4W/XzyQjKd7vkKJe2BWDxhcEV17RvEEiIhKq/vhaEfe+tolPnziUWy8Yh5kKQSLS955etpMf/HslZ4/rx11XTCMuNuxO/UUkAry3uYIv/X0x4wsyeOC6QlISwmq2mogVdn8R9hWD1pbU+RyJiIjIhz36/nZ+8fx6Lpk2kJ9cMkmFIBHxxavrS/l/jy9n5vAc/vjpGcSrECQiPli9q4YvzFnEkJwU5nx+JunqERQywu6vQmZyPIOykjWJtIiIhJw3N5bxP/9exZlj8/nVp6ZqaJiI+GLd7lq+9shSxvZP5/5rC0mK19AwEel7e2qbuP6hRaQnxfH36zVZdKgJu2IQBOcN0iTSIiISSjbuqeMr/1jC6H5p/P6q6boKLyK+KK0L/ucrNTGWB64r1FV4EfHF3pY2vjBnEXVNrTxw7QkMyEzyOyQ5SFieqY4vyGBzWT2NLe1+hyIiIkJFfTOfn7OQxLhYHrjuBP3nS0R80dTazg0PL6ayoYX7rzmBgsxkv0MSkSgUCDi++dgyVu+q4e6rpjNhYIbfIUknwrIYNKEgnYCDDXs0b5CIiPirPeD42qNLKa1t5v5rCxmUpf98iUjfc87xP/9exfLian575TQmD870OyQRiVL3vFrEC6v38IOPTuCc8f39DkcOIUyLQcE/bhoqJiIifvvNS+t5Z1MFP7l0EtOGZPkdjohEqccWFvPE4h18/exRnD9xgN/hiEiUenNjGXe9vIFLpw3k86cM9zscOYywLAYNzk4mLTFOk0iLiIivXlm3hz+8uokrCodweeEQv8MRkSi1amcNP3xmNaeNzuPmj4zxOxwRiVIlNY3cPHcZo/ul8dNPTNaKqiEuLItBMTHG+IJ09QwSERHfFFfu5ZuPLWdCQQY/umSi3+GISJSqaWzlK/9YQm5qAr+9YhqxWsVQRHzQ0hbgpn8sobm1nXs/czwpCXF+hyRHEJbFIAhOIr22pI5AwPkdiogcxMySzOx9M1tuZqvN7Ede+wgzW2BmRWb2mJkleO2J3uMi7/nhHfZ1q9e+3szO79A+22srMrNbOrR3+h4iPamtPcDX5y4l4Bx/+szxWrY5RCkXSaRzzvH9p1ayq7qRe66eQW5aot8hSSeUiyQa3PXyBpZsr+bOy6ZwXH6a3+FIF4R1Mai+uY0dVY1+hyIiH9YMnO2cmwpMA2ab2SzgTuAu59wooAq43tv+eqDKa7/L2w4zmwBcCUwEZgN/NLNYM4sF/gBcAEwArvK25TDvIdJj/vjaJpZur+aOj09maG6K3+HIoSkXSUT797Kd/HdFCd88dwzHD8v2Oxw5NOUiiWjvb6nkT69v4soThvCxKQP9Dke6KGyLQRMKgsvTad4gkdDjguq9h/HezQFnA0947XOAS737l3iP8Z4/x4KDjC8B5jrnmp1zW4AiYKZ3K3LObXbOtQBzgUu81xzqPUR6xLLian43fyOXTBvIxVN1whPKlIskku2o2ssP/72awmHZfOmM4/wORw5DuUgiWW1TK998bBlDc1L4349NOPILJGSEbTFo7IB0YkwriomEKu9K1TKgFHgJ2ARUO+favE12AIO8+4OAYgDv+Rogt2P7Qa85VHvuYd5D5JjtbWnjm48to396Ij++ZJLf4UgXKBdJJGoPOP7f48txwF2aJygsKBdJpLr9mdWU1DTym8unkZqoeYLCSdgWg5LiYxmRl6qeQSIhyjnX7pybBgwmeMVqnL8RfcDMbjSzRWa2qKyszO9wJIz8dN5atlY08KvLp5KZHO93ONIFykUSie5/czPvb6nktosmMCRHQ1XDQSjnIlA+kqPz3MoS/rVkJ189e7SGqoahsC0GAUwYmKmeQSIhzjlXDbwKnARkmdm+SwaDgZ3e/Z3AEADv+UygomP7Qa85VHvFYd6jY0z3OecKnXOF+fn5x3qIEiUWbK7g7+9t5/OnjODk4/L8Dke6SblIIsWW8gZ+89IGzpvQn8uOH+x3ONJNoZiLvLiUj6Rbqve28L9Pr2LSoAy+dvYov8ORoxDWxaDxBensqGqkprHV71BEpAMzyzezLO9+MnAusJbgyc9l3mbXAk9795/xHuM9/4pzznntV3qraowARgPvAwuB0d4KGQkEJ1N8xnvNod5D5Kg1tbZz679WMiQnmW+dN8bvcKSLlIsk0jjnuPVfK0iIi+Enl04iOCWMhDrlIolEd/x3LVV7W7nzk1OIjw3rskLUCutBfeO9SaTXldRy4shcn6MRkQ4KgDne6hYxwOPOuWfNbA0w18z+D1gKPOBt/wDwNzMrAioJnsTgnFttZo8Da4A24CbnXDuAmX0VeAGIBR50zq329vW9Q7yHyFH7/Ssb2VzewN+vP5GUhLD+0xltlIskojy2sJj3Nlfys09Mpn9Gkt/hSNcpF0lEeWtjOf9cvIMvn3kcEwdm+h2OHKWwPqOd6BWD1qoYJBJSnHMrgOmdtG8mOE7+4PYm4FOH2NcdwB2dtM8D5nX1PUSO1ppdtfz59c1cdvxgTh2t4WHhRLlIIklpbRN3zFvLiSNyuKJwyJFfICFDuUgiSWNLO99/aiUj8lK5+ZzRfocjxyCsi0H56YnkpiawtqTO71BERCQCtQcct/xrBVkp8fzPR8f7HY6IRLHbnllNc1uAn39yCjFaPUxEfHLXyxvYXrmXuTfOIik+1u9w5BgccXCfmSWZ2ftmttzMVpvZjzrZJtHMHjOzIjNbYGbDeyXaD78v4wsytKKYiIj0ikcWbGPFjhpuu2giWSkJfocjIlHq1XWlPLdqNzefM5oReal+hyMiUWrd7loeeGsLV80cwiyNzAl7XZnpqRk42zk3FZgGzDazWQdtcz1Q5ZwbBdwF3NmjUR7GhIEZrN9TR1t7oK/eUkREokBFfTO/fGE9p4zK5WNTCvwOR0SiVHNbOz/6z2pG5qVyw2kj/Q5HRKKUc47bnl5NelIc3z1/nN/hSA84YjHIBdV7D+O9mztos0uAOd79J4BzrI+WNxhfkE5LW4DN5Q198XYiIhIlfvnCeva2tPOjiydqxR4R8c39b25ha8Vebr94IglxWrFHRPzxnxUlLNhSyXfOH0t2qnpLR4Iu/UUxs1gzWwaUAi855xYctMkgoBjAOdcG1AB90m9sfIdJpEVERHrCsuJqHltUzOdPHcGoful+hyMiUWpXdSP3vFLE7IkDOH1Mvt/hiEiUamhu447/rmHyoEyuPGGo3+FID+lSMcg51+6cmwYMBmaa2aSjeTMzu9HMFpnZorKysqPZxYccl59GQmyM5g0SEZEeEQg4bnt6FflpiXzt7FF+hyMiUeyOeWsJOMf/fEwT2IuIf37/ShF7apv50SUTidUE9hGjW31NnXPVwKvA7IOe2gkMATCzOCATqOjk9fc55wqdc4X5+T1zdSM+NobR/dNYs0vFIBEROXb/XFzM8h01fP/C8aQnxfsdjohEqXeKyvnvihJuOmsUg7NT/A5HRKLUprJ6HnhrM586fjAzhmb7HY70oK6sJpZvZlne/WTgXGDdQZs9A1zr3b8MeMU5d/C8Qr1mfEGGlpcXEZFjVtfUyi+eX88Jw7O5ZNpAv8MRkSjVHnD86D9rGJKTzI2na9JoEfHPHf9dS1JcLN+drUmjI01XegYVAK+a2QpgIcE5g541sx+b2cXeNg8AuWZWBPw/4JbeCbdzEwoyKK9vprSuqS/fVkREIsyfXt9ERUML//uxCZo0WkR888TiYtbvqePWC8aTFB/rdzgiEqXeLirnlXWlfPXsUeSnJ/odjvSwuCNt4JxbAUzvpP2HHe43AZ/q2dC67oNJpOvol57kVxgiIhLGdlU3cv+bW7h02kCmDM7yOxwRiVINzW38+sUNzBiaxQWTBvgdjohEqUDAccd/1zIoK5lrTx7udzjSCyJifcoJWlFMRESO0a9eXI8Dvn3+WL9DEZEo9pc3N1Na18wPPqoeiiLin6eW7mRNSS3fnT1WPRQjVEQUgzJT4hmUlaxikIiIHJVVO2t4aulOPn/KCE3UKiK+Ka1t4s+vb+ajkws4fpgmahURfzS2tPOrF9czdXAmF03RHIqRKiKKQQDjC9K1opiIiHSbc8Fu0FnJ8XzlrOP8DkdEothvXtpAWyDAd2erh6KI+OfBt7dQUtPE9y8cT4yWko9YEVQMymBzeQNNre1+hyIiImHk1fWlvLu5gm98ZAwZWkpeRHyybnctjy8q5pqThjMsN9XvcEQkSpXVNfPHV4s4b0J/ThyZ63c40osiphg0oSCD9oBj4556v0MREZEw0dYe4Kfz1jEiL5WrTxzqdzgiEsV+Nm8daYlxfO3sUX6HIiJR7HfzN9DcFuCWC7SUfKSLmGLQvhXF1pTU+ByJiIiEi38t3UlRaT3fmz2W+NiI+ZMoImHm3U0VvL6hjK+ePYqslAS/wxGRKLW1vIG57xdz1cyhjMxP8zsc6WURc+Y7NCeF1IRY1pbU+R2KiIiEgea2dn738kamDs7k/IlavllE/OGc41cvrmdARhLXnDTc73BEJIr99uUNxMUaXztHPRSjQcQUg2JijHEFGazRimIiItIFjy7Yzs7qRr5z/jgt3ywivnl1fSmLt1Xx9XNGa/lmEfHNut21PL18F587ZQT90pP8Dkf6QMQUgyC4otjaklqcc36HIiIiIWxvSxv3vFrErJE5nDJKkyOKiD8CAccvX9jAsNwUPlU42O9wRCSK/frFDaQlxPHF00f6HYr0kQgrBmVQ19TGjqpGv0MREZEQ9tA7Wymvb+E7549VryAR8c1/V5awtqSWb35kjOYtExHfLN1exUtr9nDj6SM1b1kUiai/OhO8SaTXaqiYiIgcQk1jK396bRPnjOvH8cNy/A5HRKJUW3uAu17awNj+6Vw0daDf4YhIFPv1ixvITU3gc6eO8DsU6UMRVQwaOyAdMzRvkIiIHNJf3thMbVMb3zpvrN+hiEgU+9eSnWwub+Bb540hNkY9FEXEH+8UlfNWUTlfOWsUaYlxfocjfSiiikEpCXGMyE1VzyAREelUeX0zD769hY9NKWDCwAy/wxGRKNXc1s5vX97A1CFZnDuhv9/hiEiUcs7xyxfXU5CZxKdPHOp3ONLHIqoYBDB+oFYUExGRzv3x1U00twX4f+eO8TsUEYlijyzYzq6aJr5znuYtExH/zF9bytLt1VrNMEpFXDFoQkEGxZWN1DW1+h2KiIiEkF3Vjfz9vW1cNmMwI/PT/A5HRKLU3pY2/vBqESeNzNVqhiLim0DA8asX1zM8N4XLjtdqhtEo4opB4wvSAVi3u87nSEREJJT8/pWNAHz9I6N9jkREotlf3w6uZvhtrWYoIj56dmUJ63bX8c1ztZphtIq4T31CQSYAa3ZpqJiIiARtKW/g8UU7uPrEoQzKSvY7HBGJUjV7W/nz6/tWM8z2OxwRiVKt7QF+8+J6xg1I56IpWs0wWkVcMah/RiLZKfGaRFrEJ2Y2xMxeNbM1ZrbazG722m83s51mtsy7XdjhNbeaWZGZrTez8zu0z/baiszslg7tI8xsgdf+mJkleO2J3uMi7/nhfXjoEsLuemkDCbEx3HTWKL9DkT6iXCSh6L43N2k1wyikfCSh5snFO9hasZdvnTeWGK1mGLUirhhkZowvyFAxSMQ/bcC3nHMTgFnATWY2wXvuLufcNO82D8B77kpgIjAb+KOZxZpZLPAH4AJgAnBVh/3c6e1rFFAFXO+1Xw9Uee13edtJlFtbUsszy3fx+VOHk5+e6Hc40neUiySklNU189e3t3LR1IFazTD6KB9JyGhqbefu+RuZNiSLj4zv53c44qOIKwZBcBLpdbvraGsP+B2KSNRxzpU455Z49+uAtcCgw7zkEmCuc67ZObcFKAJmerci59xm51wLMBe4xIITLJwNPOG9fg5waYd9zfHuPwGcY5qQIer9+sUNZCTFceNpx/kdivQh5SIJNX98rYjmtgDf1LxlUUf5SELJvtUMv6t5y6JeRBaDxhdk0NwWYGtFg9+hiEQ1ryvydGCB1/RVM1thZg+a2b7JEgYBxR1etsNrO1R7LlDtnGs7qP2AfXnP13jbS5Sqb27jlXV7+PSsYWSmxPsdjvhEuUj85pzjP8tLmD1pgFYzjHLKR+K3/6zYxdTBmZw8Ks/vUMRnEVsMAlhTohXFRPxiZmnAk8A3nHO1wL3AccA0oAT4tY+x3Whmi8xsUVlZmV9hSB9YsaOagIMTR+T4HYr4RLlIQsHO6kbK65uZpVwU1ZSPxG8tbQFW76rlxJGqB0qEFoNG9UsjPta0opiIT8wsnuDJzj+cc/8CcM7tcc61O+cCwF8IdnUG2AkM6fDywV7bodorgCwzizuo/YB9ec9netsfwDl3n3Ou0DlXmJ+ff6yHKyFsWXE1AFMHZ/kah/hDuUhCxf5cNCTL1zjEP8pHEgrWltTS0hbQeZEAEVoMSoiLYVS/dE0iLeIDbxz6A8Ba59xvOrQXdNjs48Aq7/4zwJXeahcjgNHA+8BCYLS3OkYCwYkUn3HOOeBV4DLv9dcCT3fY17Xe/cuAV7ztJUotL65meG4K2akJfocifUy5SELJsu3VJMTFMG6AJo6ORspHEiqW76gGYNrQLF/jkNAQd+RNwtP4gnTe3Fjudxgi0egU4LPASjNb5rV9n+CKF9MAB2wFvgjgnFttZo8DawiutnGTc64dwMy+CrwAxAIPOudWe/v7HjDXzP4PWErwBAvv59/MrAioJHiSJFFsWXE1J6krdLRSLpKQsay4mkkDM0iIi8jrsHJkykcSEpZtryY/PZGBmUl+hyIh4IjFIDMbAjwM9CeYqO5zzv3uoG3OJFh93uI1/cs59+MejbSbJg7M5F9LdlJa10S/dH3ZRfqKc+4toLOlCeYd5jV3AHd00j6vs9c55zbzQVfqju1NwKe6E69ErpKaRvbUNjNNwzKiknKRhIrW9gCrdtVw9cxhfociPlE+klCxrLiaaUOytIqYAF0bJtYGfMs5NwGYBdxkZhM62e5N59w07+ZrIQhg0sBgN9xVO2t8jkRERPywbHs1ANOGZh9+QxGRXrR+dx1NrQENyxARX9XsbWVzeYMuksl+RywGOedKnHNLvPt1wFo+WKowZE0clIkZrNqpeYNERKLRsuJqEmJjGF+Q7ncoIhLF9k0ePV3/ARMRHy3z5gtSLpJ9ujVw2cyGA9OBBZ08fZKZLTez58xsYk8EdyzSEuMYkZfKSvUMEhGJSsuKqxk/MIPEuFi/QxGRKLasuJqc1AQGZyf7HYqIRLHlxdWYweTBmX6HIiGiy8UgM0sjuBziN5xzB3e3WQIMc85NBX4P/PsQ+7jRzBaZ2aKysrKjDLnrJg3M1DAxEZEo1B5wrNxZo6tfIuI7zdEhIqFgWXE1o/LTSE+K9zsUCRFdKgaZWTzBQtA/nHP/Ovh551ytc67euz8PiDezvE62u885V+icK8zPzz/G0I9s8qBMSmqaKK9v7vX3EhGR0LFhTx17W9o1Ll5EfFXb1MqmsnrlIhHxlXNuf2FaZJ8jFoMseBnjAWCtc+43h9hmgLcdZjbT229FTwZ6NCYNCnaBU+8gEZHosm+ODp30iIifVhTX4JxykYj4q7iykcqGFk1kLwc44tLywCnAZ4GVZrbMa/s+MBTAOfcn4DLgy2bWBjQCVzrnXM+H2z0TB32wotiZY/v5HI2IiPSVZduryUqJZ1huit+hiEgUW+5N2Dp1cJavcYhIdFtaXAWoMC0HOmIxyDn3FnDYQc7OuXuAe3oqqJ6SkRTP8NwUTSItIhJllhVXM3Ww5ugQEX8t3V7NyLxUMlM0R4eI+GdZcTVJ8TGM7a8VVuUD3VpNLBxNGpSp5eVFRKJIfXMbG0rrdPVLRHylOTpEJFQsL65m8qBM4mIj/r//0g0R/22YNCiTndWNVDW0+B2KiIj0gZU7vDk6NC5eRHy0s7qR8vpm5SIR8VVLW4BVu2pVmJYPifhi0GRvEmkNFRMRiQ77J4/WHB0i4iNNZC8ioWDd7lpa2gJMG5LtdygSYiK+GDRpoIpBIiLRZFlxFcNzU8hOTfA7FBGJYsu2V5MQF8O4ARl+hyIiUWx/YVq9FOUgEV8MykyJZ0hOMqt3qRgkIhINlhfX6Eq8iPhu+Y5qJg3MICEu4k+3RSSELSuuJj89kYGZSX6HIiEmKv46TR6UqZ5BIiJRYHdNE7trm5iqYpCI+Ki1PcDKnTXKRSLiO62wKocSFcWgSYMyKa5spHqvJpEWEYlky4qrAM3RISL+Wr+7jqbWgHKRiPiqZm8rm8samK4hYtKJ6CgGefMGrd6lJeZFRCLZ0uJq4mONCQM1R4eI+Gf5jmoApmvCVhHx0b5cpMK0dCYqikFaUUxEJDosL65mQkEGiXGxfociIlFs2fZqclITGJKT7HcoIhLFlhdXYwaTB2f6HYqEoKgoBmWnJjAoK5mVO1QMEhGJVO0Bx8odmjxaRPwXnKMjU3N0iIivlhVXc1x+GhlJ8X6HIiEoKopBEOwat29ZPRERiTwbS+toaGnX0qki4qu6plaKyuqZpiFiIuIj5xzLiqt1kUwOKaqKQTurGymra/Y7FBER6QXLtlcDMHVwlq9xiEh0W7mjBudQYVpEfLWjqpGKhhYVg+SQoqYYtG9pz+XqHSQiEpGW76gmMzmeEXmpfociIlFsqXeuOVVzdIiIj/aNilExSA4laopBkwZlEBtjGiomIhKhlm6vZuqQLM3RISK+WlZczYi8VLJSEvwORUSi2LLiahLjYhg7IN3vUCRERU0xKCUhjjH90/cvryciIpGjobmNDXvqmKYr8SLiI83RISKhYllxNZMHZRIfGzX/5Zduiqpvxr5JpAMB53coIiLSg1burCGgOTpExGclNU2U1TVriJiI+Kq1PcCqnTX7p0oR6UyUFYMyqWtqY0tFg9+hiIhID1q+f46OLF/jEJHotn+OjqFaSUxE/LN+dx3NbQH1UpTDirJiUPAP874VZ0REJDIsK65mSE4yuWmJfociIlFseXE1CbExjC/QHB0i4p+lmjxauiCqikGj+qWRmhCreYNEepGZDTGzV81sjZmtNrObvfYcM3vJzDZ6P7O9djOzu82syMxWmNmMDvu61tt+o5ld26H9eDNb6b3mbvNmDD7Ue0jkC87RoY9bDqR8JH1taXE1EwZmkBgX63coEkKUi6SvLdteTV5aAoOzk/0ORUJYVBWDYmOMyYMztaKYSO9qA77lnJsAzAJuMrMJwC3AfOfcaGC+9xjgAmC0d7sRuBeCJy/AbcCJwEzgtg4nMPcCN3R43Wyv/VDvIRFsT20TJTVNuvolnVE+kj7T1h5g5Y4a5SLpjHKR9KnlO6qZOlgrrMrhRVUxCIJDxdaW1NLU2u53KCIRyTlX4pxb4t2vA9YCg4BLgDneZnOAS737lwAPu6D3gCwzKwDOB15yzlU656qAl4DZ3nMZzrn3nHMOePigfXX2HhLB9s/RMUQTtsqBlI+kL20sraextV3FIPkQ5SLpS7VNrWwqq1cukiOKwmJQJq3tjjUltX6HIhLxzGw4MB1YAPR3zpV4T+0G+nv3BwHFHV62w2s7XPuOTto5zHtIBFtWXE1cjDFxoIpBcmjKR9LblmmODukC5SLpbSuKa3BaYVW6IAqLQcGelMs1VEykV5lZGvAk8A3n3AHVV++qlevN9z/ce5jZjWa2yMwWlZWV9WYY0geWba9mfEEGSfGao0M6F6r5SLkosizbXk1WSjzDclP8DkVCVKjmIi825aMIsay4CoApWmFVjiDqikEDMpPon5GoeYNEepGZxRM82fmHc+5fXvMerxsz3s9Sr30nMKTDywd7bYdrH9xJ++He4wDOufucc4XOucL8/PyjO0gJCe0Bx8qdNUzVEDE5hFDOR8pFkUVzdMjhhHIuAuWjSLKsuIaR+alkJsf7HYqEuCMWgw41+/1B2xxyxvtQNGNoNou3VfkdhkhE8laveABY65z7TYenngH2rXpxLfB0h/ZrvDwyC6jxujO/AJxnZtne5IjnAS94z9Wa2Szvva45aF+dvYdEqE1l9dQ3t2klMemU8pH0lYbmNjbsqdMQMemUcpH0Feect8Jqlt+hSBiI68I2+2a/X2Jm6cBiM3vJObemwzYdZ7w/keBs9if2eLQ95Phh2Ty3ajd7apvon5HkdzgikeYU4LPASjNb5rV9H/g58LiZXQ9sAy73npsHXAgUAXuBzwE45yrN7CfAQm+7HzvnKr37XwEeApKB57wbh3kPiVDLtlcDmqNDDkn5SPrEih01BDRHhxyacpH0iZ3VjZTXNzNd50XSBUcsBnmV5hLvfp2Z7Zv9vmMxaP+M98B7ZpZlZgUdJisLKYXDcwBYtLWKj04p8DkakcjinHsLOFQf+XM62d4BNx1iXw8CD3bSvgiY1El7RWfvIZFryfYqMpLiGJmX6ncoEoKUj6SvLNke7HE+TXN0SCeUi6SvLNl/kUw9puXIujVn0EGz33d0qJntQ9LEgRkkxcewaFvlkTcWEZGQtWR7FdOHZhMTozk6RMQ/S7dXMTI/lezUBL9DEZEotmRbFcnxsYwvSPc7FAkDXS4GHW72+27sIyRmqY+PjWHakCwWbdW8QSIi4aqmsZWNpfUcP0xXv0TEP845lmyv5vihykUi4q+l26uYMjiTuNioWydKjkKXviWHmP2+o0PNbH+AUJqlvnBYDmtKamlobvM1DhEROTrLiqtxLrgogIiIX7ZW7KWyoYUZKkyLiI+aWttZvatWF8mky7qymtihZr/v6FAz3oes44dn0x5wLNcS8yIiYWnJtipiDC0rLyK+WuKtUKv/gImIn1bsqKEt4HSRTLqsK6uJHWr2+6EAzrk/cYgZ70PZjKHZmMGibVWcPCrP73BERKSblmyvYkz/dNKT4v0ORUSi2OLtVaQnxTEqP83vUEQkii32CtPqpShd1ZXVxA43+/2+bQ45432oykyOZ2z/dBZt07xBIiLhJhBwLNtezUXTBvodiohEuSXbqpg2JEsT2YuIr5Zsr2JEXio5msheuiiqZ5Y6flg2S7ZV0R5wfociIiLdsLG0nrrmNk3YKiK+qmtqZf2eOg0RExFfOedYsq2K6UOz/A5FwkhUF4MKh2dT39zG+t11fociIiLdoK7QIhIKlhfXaCJ7EfHd9sq9VDS0qDAt3RLdxaBhOQAs2lbpcyQiItIdS7ZXkZOawPDcFL9DEZEotnhbFWYwTVfjRcRH+y+SqTAt3RDVxaDB2ckUZCaxYLOKQSIi4WTJtipmDM0iuOCliIg/lmyvYky/dDI0kb2I+GjJ9irSEuMY0z/d71AkjER1McjMOGlkLu9triA4B7aIiIS6qoYWNpc3aIiYiPgqEHAs2V6lXCQivlu8rZppQ7KI1UT20g1RXQwCmHVcLhUNLWzYU+93KCIi0gVLi9UVWkT8t6msnrqmNmZoiJiI+Cg4B26tCtPSbVFfDDppZC4A724q9zkSERHpisXbqoiNMaYOzvI7FBGJYvvm6NCErSLip+XF1QQcKkxLt0V9MWhITgqDs5N5d3OF36GIiEgXLNlWzYSCDJITYv0ORUSi2JLtVWSnxDMiL9XvUEQkii3xCtPTh6gwLd0T9cUgCPYOWrClkkBA8waJiISytvYAy4qrdSVeRHy3eFsVM4ZmayJ7EfHV4u1VjO6XRmaKJrKX7lExCDjpuFyq97aydnet36GIiMhhrNtdR2NrO9PVFVpEfFS9t4VNZZrIXkT8FQg4lm6v1jyKclRUDCJYDAJ4d5OGiomIhLL3t1QCcMLwHJ8jEZFotnBrcFhGoYpBIuKjDaV11DS2UjhcuUi6T8UgoCAzmeG5KbyneYNERELawq2VDMpKZmBWst+hiEgUW7i1koTYGKYOyfI7FBGJYgu9i2QzR+gimXSfikGek44LzhvU1h7wOxQREemEc46FWyt1wiMivnt/SyVTBmeSFK+J7EXEP+9vraJfeiJDc1L8DkXCkIpBnlNG5VHX1MbyHTV+hyIiIp3YUt5AeX2LhoiJiK/2trSxamcNJ6gwLSI+cs6xcEslJ4zI0UT2clRUDPKcOiqPGIPXN5T5HYqIiHRi4dZ9XaE1Ll5E/LNsezVtAcdMFaZFxEc7qhrZXdukXCRHTcUgT1ZKAlOHZPGGikEiIiHp/S1V5KQmcFx+mt+hiEgUe39rJWZoJTER8ZUW1ZBjpWJQB2eMyWf5jmqqGlr8DkVERA6ycGslhcOy1RVaRHy1cGsl4wZkkJkc73coIhLFFm2rJD0pjrED0v0ORcKUikEdnD4mH+fgraJyv0MREZEO9tQ2sb1yryaPFhFftbYHWLKtmplaxllEfPb+luBFstgYXSSTo6NiUAdTB2eRmRyveYNEREKMukKLSChYvauWxtZ2TR4tIr6qqG9mU1mDcpEcExWDOoiNMU4dnccbG8pwzvkdjoiIeBZurSQlIZaJAzP8DkVEothCrzCtCVtFxE8Lt1YBykVybFQMOsgZY/IprWtm3e46v0MRERHP+1sqmTE0m7hY/dkSEf+8v7WSYbkp9MtI8jsUEYliC7dWkhAXw+TBmX6HImFMZ9UHOWNMPgCvrCv1ORKR8GVmD5pZqZmt6tB2u5ntNLNl3u3CDs/damZFZrbezM7v0D7baysys1s6tI8wswVe+2NmluC1J3qPi7znh/fRIUsvqmlsZf2eOg0Rk25TLpKeFAg4Fm2tVC6SblMukp62cGsl04ZkkRgX63coEsZUDDpI/4wkpg7J4sU1e/wORSScPQTM7qT9LufcNO82D8DMJgBXAhO91/zRzGLNLBb4A3ABMAG4ytsW4E5vX6OAKuB6r/16oMprv8vbTsLc4m2VOAcnjNCErdJtD6FcJD1kU1k9VXtbNSxDjsZDKBdJD2lobmP1rlrlIjlmKgZ14rwJ/VleXM3umia/QxEJS865N4DKLm5+CTDXOdfsnNsCFAEzvVuRc26zc64FmAtcYsF1xc8GnvBePwe4tMO+5nj3nwDOMa1DHvYWbKkkPtaYPkTFIOke5SLpSQv2TWSvCVulm5SLpCct3lZFe8ApF8kxUzGoE+dN6A/AS2vVO0ikh33VzFZ43aX3/c9+EFDcYZsdXtuh2nOBaudc20HtB+zLe77G217C2HubKpg2JIvkBHWFlh6jXCTd9u7mCgZkJDE8N8XvUCRyKBdJt727uYK4GKNwmC6SybE5YjGoszGuBz1/ppnVdBjv+sOeD7NvjeqXxoi8VF7SUDGRnnQvcBwwDSgBfu1XIGZ2o5ktMrNFZWVlfoUhXVDb1MrKnTWcdFye36FI5FAukm5zzvHepgpOPi4XdayQHhIyuQiUj8LJO95FstTEOL9DkTDXlZ5BD9H5GNeO3uww3vXHxx6Wv8yMcyf0591N5dQ2tfodjkhEcM7tcc61O+cCwF8IdncG2AkM6bDpYK/tUO0VQJaZxR3UfsC+vOczve0PjuU+51yhc64wPz+/Jw5Pesn7mysJODhppC5kSs9QLpKjsWFPPRUNLcw6TrlIekYo5SIvHuWjMFDX1MqqnTWcpFwkPeCIxaBujnGNGOdN6E9ru+P19aqMi/QEMyvo8PDjwL7ehs8AV3orXowARgPvAwuB0d4KGQkEJ1N8xjnngFeBy7zXXws83WFf13r3LwNe8baXMPXu5goS4mKYPjTL71AkQigXydF4d1M5oMK09BzlIjkaC7dW0h5wykXSI3qqb9lJZrYc2AV82zm3uof265vpQ7PJS0tk3soSLpo60O9wRMKKmT0KnAnkmdkO4DbgTDObBjhgK/BFAOfcajN7HFgDtAE3Oefavf18FXgBiAUe7JBbvgfMNbP/A5YCD3jtDwB/M7MigkXsK3v3SKW3vbOpgsJh2STFa74g6T7lIukp72yqYEhOMkNyNF+QdJ9ykfSUd4qCF8lmaL4g6QE9UQxaAgxzztWb2YXAvwlWsD/EzG4EbgQYOnRoD7x174mNMT46eQBzFxZT19RKelK83yGJhA3n3FWdND/QSdu+7e8A7uikfR4wr5P2zXzQnbpjexPwqW4FKyGrqqGFtSW1fOvcMX6HImFKuUh6QiDgWLClkvMn9vc7FAlTykXSU97dXMGMoVm6SCY94phXE3PO1Trn6r3784B4M+t0ps9wG4t68bSBNLcFNJG0iIgPFmwJTmtw8ih1hRYR/6wpqaWmsZWTNZG9iPioem8La0pqlYukxxxzMcjMBpi3rIKZzfT22enEZOFmxtBsBmUl88zyXX6HIiISdd7ZVEFKQixTBmf5HYqIRLF3NwVPazVhq4j46b3NlTinXCQ954jDxA4xxjUewDn3J4KTkX3ZzNqARuDKSJmYzMy4aOpA7n9zM5UNLeSkJvgdkohI1Hh3UwWFw3OIjz3m6xYiIkft3c0VjMxLpX9Gkt+hiEgUe29zBcnxsUzVRTLpIUcsBh1ijGvH5+8B7umxiELMRVML+NPrm3huVQmfPnGY3+GIiESF0romNpbW88njB/sdiohEsbb2AO9vqeSSaVpMRET89c6mcgqHZ5MQp4tk0jP0TTqCCQUZjO6XxpOLd/gdiohI1HhvcyWgZZxFxF8rd9ZQ39ymYRki4qvy+mY27KlXLpIepWLQEZgZlxcOYcn2ajbuqfM7HBGRqPDupnLSE+OYODDD71BEJIq9480XNEuFaRHx0f65y5SLpAepGNQFH58xiPhY47GFxX6HIiIS8ZxzvLGhnJNH5RKn+YJExEdvbixjQkEGeWmJfociIlHszY1lZCTFaVEN6VE6y+6CvLREzp3QnyeX7KC5rd3vcEREItqW8gZ2Vjdy2uh8v0MRkSjW0NzG4m1VnDZGyziLiH/2XSQ7dXQesTHmdzgSQVQM6qIrThhK1d5WXlqzx+9QREQi2hsbygA4XcUgEfHRe5sraG13ykUi4qui0np21zYpF0mPUzGoi04dlcegrGQeWbDd71BERCLamxvLGZ6bwtDcFL9DEZEo9ubGcpLiYygcnu13KCISxV73LpKdNkbFIOlZKgZ1UWyM8elZQ3lnUwVrS2r9DkdEJCK1tAV4d3OFhoiJiO/e2FDGrJG5JMbF+h2KiESxNzeWc1x+KoOykv0ORSKMikHdcPXMoSTHx/LAW1v8DkVEJCIt3lbF3pZ2TtfVLxHxUXHlXjaXN2hYhoj4qqm1nQVbdJFMeoeKQd2QlZLAZccP5plluyita/I7HBGRiPPmxjLiYoxZI3P8DkVEothbReUAnK7Jo0XER4u2VtHUGuAMXSSTXqBiUDd97pThtAYC/P3dbX6HIiIScd7YWMaModmkJ8X7HYqIRLE3NpRRkJnEcflpfociIlHsjY1lJMTGcKIukkkvUDGom0bmp3Hu+P489M5Wahpb/Q5HRCRiVNQ3s2pnra7Ei4iv2toDvF1Uzumj8zHTMs4i4p83NpRRODyblIQ4v0ORCKRi0FH4+jmjqW1q40HNHSQi0mP2DcvQuHgR8dPyHTXUNrVxmgrTIuKj0tom1u2u03mR9BoVg47CpEGZzJ44gAff2kLNXvUOEhHpCa+uKyUnNYFJgzL9DkVEothr60uJMTh1lIpBIuKf19YHl5TXfEHSW1QMOkrfOHc0dc1t3PfmJr9DEREJe23tAV7bUMZZY/sRG6NhGSLin/lrSykclkNWSoLfoYhIFJu/bg8DM5MYX5DudygSoVQMOkrjBmRw8dSB3P/mFnZU7fU7HBGRsLZkezXVe1s5Z3w/v0MRkSi2q7qRNSW1ykUi4qum1nbe3FjO2eP7ae4y6TUqBh2DWy4Yhxn8bN46v0MREQlr89ftIT7WOG20hmWIiH9eWVcKoGKQiPhqwZZK9ra0c864/n6HIhFMxaBjMDArmS+fMYr/rizh3U0VfocjIhK2XllbyokjcrWkvIj46pV1pQzNSdGS8iLiq1fW7iEpPoaTjsv1OxSJYCoGHaMvnjGSwdnJ/OCplTS1tvsdjohI2NlesZeNpfWcPU5X4kXEP40t7bxdVM45GpYhIj5yzvHy2lJOHZVPUnys3+FIBFMx6Bglxcdy5yensLm8gV+9sN7vcEREws78dXsADcsQEX+9XVROc1tAwzJExFcb9tSzs7pR50XS61QM6gGnjMrjM7OG8sDbW3h/S6Xf4YiIhJVX1pUyql8aw3JT/Q5FRKLY/HWlpCbEMnNEjt+hiEgU23eR7KyxKgZJ71IxqIfcesF4huWk8LVHl1BW1+x3OCIiYaGuqZX3NldwjoaIiYiPnHO8sm4Pp4/JJyFOp8ci4p/5a0uZNCiDAZlJfociEU5/7XpIamIc937meGoaW/nao0toaw/4HZKISMh7fUMZre2Oc8ZrWIaI+GfFjhr21DYrF4mIr8rqmlmyvUrDVaVPqBjUg8YXZPDTj0/mvc2V/O/Tq3DO+R2SiEhIe27VbvLSEjh+WLbfoYhIFHtu1W7iYoyPaI4OEfHRi2t24xzMnjTA71AkCqgY1MM+MWMwN511HI++X8xdL2/0OxwRX5jZg2ZWamarOrTlmNlLZrbR+5nttZuZ3W1mRWa2wsxmdHjNtd72G83s2g7tx5vZSu81d5u37Muh3kNCU1NrO6+uK+W8iQOIjdHKPdLzlIukK5xzPL+qhJOOyyUrJcHvcCQCKRdJVz2/ajfDc1MYNyDd71AkCqgY1Au+fd5YLi8czN3zN/LH14r8DkfEDw8Bsw9quwWY75wbDcz3HgNcAIz2bjcC90LwBAa4DTgRmAnc1uEk5l7ghg6vm32E95AQ9PqGMva2tHOBrn5J73kI5SI5gnW769hasZcLJhX4HYpErodQLpIjqN7bwrubKpg9qQCvnifSq45YDOqskn3Q84esXkcrM+OnH5/MxVMH8ovn13Pn8+s0ZEyiinPuDeDgpfUuAeZ49+cAl3Zof9gFvQdkmVkBcD7wknOu0jlXBbwEzPaey3DOveeC/7AePmhfnb2HhKDnV+0mMzmeWSNz/Q5FIpRykXTFc6t2E2Nw3kTN0SG9Q7lIuuKlNXtoCzhdJJM+05WeQQ/x4Up2R51Wr6NdXGwMd10xjU+fOJR7X9vEzXOX0djS7ndYIn7q75wr8e7vBvaddQ8Cijtst8NrO1z7jk7aD/ceEmJa2gK8vHYP507oT3ysOqlKn1IukgM8v6qEE4bnkJeW6HcoEl2Ui+QAz6/azaCsZKYMzvQ7FIkSRzwDP0Qlu6NDVa+jXmyM8X+XTuI754/lPyt28Yl732FbRYPfYYn4zrty1avd5Q73HmZ2o5ktMrNFZWVlvRmGHMLbm8qpa2rT1S/xlXKRbCqrZ8OeeuUi8ZXfuQiUj/xW19TKmxvLOX/iAA0Rkz7TE5djD1Wl/pBoTDJmxk1njeLB605gZ9VeLvjdm/xjwTYNG5NotGdfodj7Weq17wSGdNhusNd2uPbBnbQf7j0O4Jy7zzlX6JwrzM/PP6aDkqPz/MrdpCXGceroPL9DkeijXCT7Pb9qNwCzNV+Q9L2QyUWgfOS3V9aV0tIe4ILJKkxL3+nTvvnRnGTOGtuP575xOjOGZvODp1bx2Qfep6i03u+wRPrSM8C+lS+uBZ7u0H6NN//YLKDG69L8AnCemWV7EySeB7zgPVdrZrO81TKuOWhfnb2HhJDW9gAvrtnN2eP6kRgX63c4En2Ui2S//64oYfrQLAZkJvkdikQf5SLZb97KEvLTEzl+qBZ8k77TE8WgQ1Wp5SCDspL52/Uz+cmlk1heXM3s377BT55dQ01jq9+hifQoM3sUeBcYa2Y7zOx64OfAuWa2EfiI9xhgHrAZKAL+AnwFwDlXCfwEWOjdfuy14W1zv/eaTcBzXvuh3kNCyBsbyqja28ol0wb6HYpEOOUiOZyNe+pYU1LLJVOVi6R3KRfJ4dTsbeXVdWVcNGUgMTEaIiZ9J64H9vEM8FUzm0twqcN91WvphJnx2VnDuGDSAH794gYefHsLTy7ZwQ2njeTak4eTltgTH4mIv5xzVx3iqXM62dYBNx1iPw8CD3bSvgiY1El7RWfvIaHl6WW7yEqJ57TR0dVDVPqecpEcztPLdhEbY3x0iopB0ruUi+Rwnl9dQkt7QBfJpM91ZWn5D1WyzexLZvYlb5NOq9dyeHlpifzsE5N59munUjgsm1++sJ5T73yFP7xaRENzm9/hiYj0iobmNl5as4ePTi4gIU6riImIP5xzPL18J6eMyiM/XauIiYh//r10FyPyUrWKmPS5I3ZDOUwle9/zh6xey5FNHJjJ/deewPLian778gZ++cJ67n9zM9efOoJrTh5ORlK83yGKiPSYF9fsprG1nUumdbrOgIhIn1iyvYriyka+cc4Yv0MRkSi2u6aJ97ZUcPM5o7WKmPQ5XZYNEVOHZPHXz83kqa+czPSh2fzqxQ2c+vNXuOulDdTs1ZxCIhIZnl62i0FZyRQO0wSJIuKfp5ftIjEuhvO1pLyI+Og/y3fhHLpIJr5QMSjETB+azYPXncB/vnoqs0bm8rv5Gznlzlf45QvrqGxo8Ts8EZGjVl7fzJsby7loqiZIFBH/tLYHeHZFCR+Z0F9zNYqIr/69bCdTB2cyIi/V71AkCqkYFKImD87kvmsKee7m0zhjTD5/fG0Tp975Cj+bt5ayuma/wxMR6bZnl++iPeC4dLomSBQR/7y5sYzKhhYu1ZV4EfHRxj11rN5Vq15B4htdDglx4wsy+MOnZ7BxTx33vFrEX97czJx3t3L1zGF88YyR9M9I8jtEEZEjcs7x2KIdTBqUwbgBGX6HIyJR7LGFxeSlJXDmWK1oKCL+eWxhMfGxplXExDfqGRQmRvdP53dXTufl/3cGH508kDnvbuW0X7zKj/6zWnMKiUjIW7WzlrUltVxROMTvUEQkipXVNTN/bSmfmDGY+FidBouIP1raAvxr6U4+Mr4/uWla0VD8ob+CYWZkfhq/vnwqr37rTD4+bRBz3tnKmb96lb+9t4229oDf4YmIdGruwu0kxsVwsbpCi4iP/rVkB20Bx+UqTIuIj15eu4fKhhauOEG5SPyjYlCYGpqbwp2XTeHZr53GmP7p/O+/V/Gx37/Fwq2VfocmInKAxpZ2nlm2iwsnF5CZHO93OCISpZxzPLawmMJh2Yzql+Z3OCISxR5bWMzAzCROG63hquIfFYPC3ISBGcy9cRZ//PQM6prauPzP73L7M6tpaG7zOzQREQCeW1VCXXObrsSLiK8Wbatic3kDl+tKvIj4aFd1I29sLOOy4wcTq9VVxUcqBkUAM+PCyQW8+M3Tufak4Tz0zlbO/+0bvF1U7ndoIiI8trCYYbkpzBqZ43coIhLFHltYTGpCLB+dXOB3KCISxZ5YvAPn4FO6SCY+UzEogqQmxnH7xRN5/IsnER8bw6fvX8DPnltLq+YSEhGfbNhTx4ItlVxxwhDMdPVLRPxR1dDCf5bv4uJpg0hN1GK6IuKPtvYAj76/ndNG5zEkJ8XvcCTKqRgUgWaOyOG5m0/j6hOH8ufXN/OpP71LceVev8MSkSg0552tJMTFcOUJQ/0ORUSi2GOLimluC3DtycP8DkVEotiLa/ZQUtPENScN9zsUERWDIlVSfCw//fhk/nD1DDaV1nPh3W8yf+0ev8MSkShS09jKv5bs5JKpA8lJTfA7HBGJUu0Bx9/e3caskTmMG5DhdzgiEsUeemcrg7OTOXtcP79DEVExKNJ9dEoB824+jWG5KXzh4UXc+9omnHN+hyUiUeCfi4ppbG3n2pOH+x2KiESxl9fuYWd1I9cpF4mIj9bsquX9LZVcc9IwTRwtIUHFoCgwJCeFf37xZD46uYA7n1/HNx9bRlNru99hiUgEaw84Hn53G4XDspk0KNPvcEQkis15ZysDM5P4yPj+fociIlFszjtbSYqP0eqqEjJUDIoSyQmx/P6q6Xz7vDH8e9kurnngfWoaW/0OS0Qi1KvrStleuVe9gkTEV+t31/HOpgo+c9Iw4mJ12isi/qhsaOHfy3by8emDyErR0HkJDfqrGEXMjK+ePZp7rp7O0uIqrvjzu+ypbfI7LBGJQH9+YxMDM5OYPWmA36GISBT78xubSI6P5SpNYi8iPprzzlaa2wJ87pQRfocisp+KQVHoY1MG8tfrZlJcuZdP3vsOm8vq/Q5JRCLIwq2VLNxaxQ2njyReV+JFxCc7qvbyzLJdXDVzKNmaxF5EfNLQ3Macd7fykfH9GdM/3e9wRPbTWXqUOnV0HnNvPInGlnYu//N7FJXW+R2SiESIP722iZzUBC0nLyK+uv/NLZjBF07TlXgR8c/chcVU723lK2cd53coIgdQMSiKTR6cyeNfOgkzuPK+BSoIicgxW7e7lvnrSrnu5OEkJ8T6HY6IRKmK+mbmLtzOpdMGMTAr2e9wRCRKtbQFuP/NzZw4IocZQ7P9DkfkACoGRbnj8tN49IZZHQpCGjImIkfvT69tIjUhlmtOGuZ3KCISxR7y5uf44hkj/Q5FRKLYv5ftpKSmiS+fqV5BEnpUDBJG9QsWhACu+st7bC1v8DkiEQlHG/fU8fTyXXxm1jCtlCEivqlqaOGvb29l9sQBjOqn+TlExB8tbQHunr+RSYMyOGNMvt/hiHyIikECBAtCc288kfaA47MPLqBUq4yJSDfd9fIGUhPi+OIZuvolIv750+ubaGhp45vnjvE7FBGJYo8vKmZHVSPfOm8sZuZ3OCIfomKQ7DeqXzp/ve4EKupbuObB96lpbPU7JBEJE6t21jBv5W4+f+oIcrRqj4j4pLS2iTnvbuXSaYO0ao+I+KaptZ3fv7KRwmHZnKleQRKiVAySA0wdksWfP3s8m8rquWHOIppa2/0OSUTCwK9fXE9mcrxW7RERX/3h1SJa2x3f+Mhov0MRkSj29/e2sae2mW+fr15BErq6VAwys9lmtt7Miszslk6ev87MysxsmXf7Qs+HKn3ltNH5/ObyaSzcVsnNc5cSCDi/QxKRELZgcwWvri/ji2eMJCMp3u9wRCRKba/YyyPvb+fywsEMy031OxwRiVI1ja388bVNnDoqj1kjc/0OR+SQjlgMMrNY4A/ABcAE4Cozm9DJpo8556Z5t/t7OE7pYxdNHcj/fHQCL6zewy9eWO93OBJBzGyrma30CseLvLYcM3vJzDZ6P7O9djOzu71C9Aozm9FhP9d62280s2s7tB/v7b/Ie60ux/Si9oDjx8+uoSAzic+drF5BEj6UiyLPHfPWEB8bw83naK4gCR/KRZHn9/M3UrW3hVsuGOd3KCKH1ZWeQTOBIufcZudcCzAXuKR3w5JQ8PlThvPpE4fyp9c38fiiYr/Dkchyllc4LvQe3wLMd86NBuZ7jyFYhB7t3W4E7oXgSRJwG3AiwRx1274TJW+bGzq8bnbvH070emJxMat31XLrheNJToj1OxyR7lIuihDvFJXzwuo93HTWKAZkJvkdjkh3KRdFiE1l9Tz0zlauKBzCpEGZfocjclhdKQYNAjpWAnZ4bQf7pFehfsLMhvRIdOIrM+P2iydy2ug8fvDUSt7bXOF3SBK5LgHmePfnAJd2aH/YBb0HZJlZAXA+8JJzrtI5VwW8BMz2nstwzr3nnHPAwx32JT2srqmVX76wnsJh2Vw0pcDvcER6gnJRGGprD/DjZ9cwODuZ609VD0WJCMpFYeqO/64lKT6Wb5031u9QRI6opyaQ/g8w3Dk3hWDymdPZRmZ2o5ktMrNFZWVlPfTW0pviY2O45+oZDM1J4Ut/X8zW8ga/Q5Lw54AXzWyxmd3otfV3zpV493cD/b37hypGH659Ryft0gvunr+RioYWbrtooiZHlHCkXBQhHn1/O+t21/GDC8eTFK8eihJ2lIsixKvrS3llXSlfP2cU+emJfocjckRdKQbtBDr29Bnste3nnKtwzjV7D+8Hju9sR865+5xzhc65wvx8LbEXLjKT43nwuhMw4It/W0xDc5vfIUl4O9U5N4NgV+ebzOz0jk96V656ddZyFaaP3aqdNTz49lauPGEIkwerG7SEJeWiCLC7polfPL+eU0blMnvSAL/DETkavuciUD46Vg3NbfzPU6s4Lj+Va08e7nc4Il3SlWLQQmC0mY0wswTgSuCZjht4XRD3uRhY23MhSigYlpvK76+awcbSOr775AqCf5dEus85t9P7WQo8RXBs+559ecT7Weptfqhi9OHaB3fSfnAMKkwfg7b2AN97cgU5qQnccsF4v8MROSrKReHPOcf//HsVrYEAP/34ZPVQlLAUCrnIe3/lo2Pw6xc3sLO6kTs/OYXEOPVQlPBwxGKQc64N+CrwAsEiz+POudVm9mMzu9jb7OtmttrMlgNfB67rrYDFP6eOzuO7s8fx3xUl/OXNzX6HI2HIzFLNLH3ffeA8YBXBAvO+lS+uBZ727j8DXOOtnjELqPG6Tb8AnGdm2d4EiecBL3jP1ZrZLG+1jGs67Et6yP1vbWH1rlp+fPFEMpO1lLyEH+WiyDBv5W5eXruH/3fuGC0lL2FJuSgyLN1exV/f2cJnZg2lcHiO3+GIdFlcVzZyzs0D5h3U9sMO928Fbu3Z0CQUffH0kazYUc3Pn1vHpIGZnDwqz++QJLz0B57yrt7GAY845543s4XA42Z2PbANuNzbfh5wIVAE7AU+B+CcqzSznxDsuQjwY+dcpXf/K8BDQDLwnHeTHlJUWsddL23gvAn9NSRDwplyUZgrr2/mtmdWMWlQBp8/RZNGS9hSLgpzTa3tfO/JFfRPT+K7s7WUvISXLhWDRPYxM35x2VQ27qnnq48u5T9fO5VBWcl+hyVhwjm3GZjaSXsFcE4n7Q646RD7ehB4sJP2RcCkYw5WPqS5rZ2vPbqM1MQ4/u/SSRqSIWFLuSi8Oef43hMrqG1q4+9fmEpcbE+thyLSt5SLwt/P5q1lw556HvrcCWQkqbe0hBf99ZRuS0uM48+fPZ7WtgBf+ftiWtoCfockIn3gl8+vZ21JLXd+cgr9MpL8DkdEotTf3tvG/HWl3HrBOMYNyPA7HBGJUq+s28Ocd7fx+VNGcObYfn6HI9JtKgbJURmZn8YvPzWV5Ttq+Nlzmi9cJNK9vqGM+98Kjoc/d0L/I79ARKQXrN9dxx3/XcuZY/O5Tiv2iIhPSmub+M4/VzBuQDrfnT3W73BEjoqKQXLUZk8awOdOGc5f397K86tK/A5HRHpJceVebp67lDH90/jBhRP8DkdEolTN3lZu/NsiMpLj+eVlUzVUVUR80dIW4Mv/WMLelnZ+f9V0kuK1epiEJxWD5JjcesF4pg7O5DtPrGB7xV6/wxGRHra3pY0bHl5EIOC477OFJCfohEdE+l57wPH1uUvZVd3Inz4zg/z0RL9DEpEodft/VrN4WxW//NQURvdP9zsckaOmYpAck4S4GO65egYG3PTIEprb2v0OSUR6SCDg+N6TK1m/p467r5rO8Dwt3Swi/vjVi+t5fUMZt188keOHaelmEfHHPxZs45EF2/nSGcfxsSkD/Q5H5JioGCTHbEhOCr/81FRW7qzhZ/PW+R2OiPSQO59fx3+W7+K754/TxIgi4pu/vbeNe1/bxNUnDuXTJw7zOxwRiVLz1+7hh0+v5syx+XznfM0TJOFPxSDpEedPHMD1p47goXe2Mm+l5g8SCXf3v7mZP7+xmWtOGsaXzhjpdzgiEqWeX1XCD59exTnj+vHjiyf6HY6IRKnF26q46ZElTByYwR+unkFsjOYsk/CnYpD0mO/NHsfUIVl874kVbKto8DscETlKTy7ewf/9dy0XTBrAbRdN1CStIuKLt4vK+frcZUwbksU9V88gLlanrSLS99btruX6OQvpn5HEg9edQGpinN8hifQI/VWVHpMQF8M9V00nJsb48t+X0NSq+YNEws3ji4r59hPLOWVULnddMU1XvkTEF69vKOPzDy1kRG4qD157giavFxFfrN5Vw1X3vUdSXCwPf34meWmavF4ih4pB0qOG5KTw2yumsaaklh88tQrnnN8hiUgXPfr+dr77xApOHZXHA9eeoKVSRcQXr64r5YaHFzEyP41Hb5xFdmqC3yGJSBRauaOGq/+ygOT4WB774iyG5WohDYksKgZJjztrXD++fs5onlyyg//3+HJ2VGnJeZFQ5pzj7vkbufVfKzljTD5/uaZQhSAR8cXji4q54eFFjO6XxiNfOJEcFYJExAevrS/lyvveJS0xjse+eJIKQRKRNOBResXN54ymrT3A/W9t4b8rSvjMrGF89exROqkTCTEtbQG+/9RKnli8g09MH8TPPzmFhDhdJxCRvuWc4zcvbeD3rxRx6qg8/viZGWQkxfsdlohEoUcWbOd/n17F2P7pPHjdCQzITPI7JJFeoWKQ9IrYGOO7s8fx2ZOG8duXNvLQO1t4fFExN54+kutPHaGJ10RCwJ7aJr726FLe31LJNz4ympvPGa3JokWkz9U2tXLLkyuYt3I3VxQO4f8+Pol4TRYtIn2spS3AT+et5aF3tnLm2HzuuXoGafo/i0QwfbulVxVkJnPnZVO44fQR/PKF9fzmpQ08/O42vn7OKK48Yah6IIj45O2icm6eu5SG5nZ+d+U0Lpk2yO+QRCQKrd5Vw03/WEJxVSPfv3AcN5w2UkVpEelzxZV7+eojS1i+o4bPnzKC7184TisYSsRTMUj6xKh+6fz5s4Us2V7Fnc+t44dPr+b+N7fwrfPGcNGUgcRoxSKRPtHU2s5dL2/gvjc2Myo/jUdvmMHo/ul+hyUiUaY94HjwrS388sX15KQk8NiNsygcnuN3WCISZZxzPLV0J7c/sxoH/OkzxzN70gC/wxLpEyoGSZ+aMTSbuTfO4rUNZfzi+fXcPHcZf3p9M18/exTnTxygopBIL1q0tZLvPrmCzWUNXHnCEH540QRSEvRnQET61sY9dXzniRUsK67mI+P7cecnp5Cr5ZpFpI+V1DTyg6dW8cq6Uo4fls1vLp+qiaIlquh/AdLnzIyzxvbjjNH5PLN8F7+bv5Ev/2MJY/qncdNZo/jYlIHEqigk0mNKa5v41Yvr+efiHQzMTOZv18/ktNH5foclIlGmtqmVP7xSxF/f3kpqYiy/u3IaF08dqGFhItKnmlrb+evbW/nDq0W0BQL88GMTuPbk4fr/h0QdFYPENzExxqXTB3HR1IE8u2IX97xSxM1zl/HblzfylTOP49LpgzSBpMgxaGhu469vb+GPr22itT3AF04dwc0fGaPJEEWkT7W0BXhsUTG/fWkDlXtb+OSMwXxv9jjy09UbSET6TiDg+O/KEu58fh07qhr5yPh+/O/HJqg3kEQt/Y9AfBcbY1wybRAXTRnIC6t3c/crRXzniRX8+sUNXHPyMK46YSjZWpJepMtqm1p5+J2tPPDWFqr2tnL+xP7cesF4hufpZEdE+k5TazuPLyrmT69tYldNEzNH5DDnYxOYNCjT79BEJIq0tQd4dkUJf3i1iI2l9YwbkM4/vnAip4zK8zs0EV+pGCQhIybGuGByAbMnDeDV9aU88NYWfvH8eu6ev5FPzBjM508Zzqh+muhW5FA2l9XzyILtPLaomLqmNs4e14+bzhrF8cOy/Q5NRKLI7pom5i7czj8WbKesrpnCYdnc8YnJnDkmX0PCRKTPVDW08OSSHfztvW1sq9jL2P7p3H3VdD46uUBDwkRQMUhCkJlx9rj+nD2uP+t21/LXt7byxOIdPLJgOyeOyOHywiFcOLmA5IRYv0MV8d3eljbmry1l7sLtvF1UQVyMcf6kAXz5jON09V1E+kxLW4C3isqY+34x89eVEnCO00fn86Urj2PWyBwVgUSkT7QHHO9vqeSfi4t5dkUJLW0BZgzN4vsXjufc8f21WI1IByoGSUgbNyCDOy+bwndnj2XuwmIeX1TMt/65nNufWc3Hpg7kU4WDmT4kSyeZElUaW9p5fUMZz67Yxfy1pTS2tjMoK5nvnD+WTxUOpl96kt8hikgUaGkL8N7mCp5dsYsXVu+hprGV3NQEbjhtJFfPHMrQ3BS/QxSRKNAecCzdXsWzK0qYt7KE0rpm0hLjuKJwCFefOJTxBRl+hygSklQMkrCQm5bITWeN4stnHMf7Wyt5fGExTy3dwaPvb2dQVjIXTh7AhZMLmKbCkEQg5xzr99TxxoYy3thQzvtbK2lpC5CTmsAnZgziY1MGMnNEjro8i0ivcs6xrWIvb2ws440NZby7qYKGlnbSEuM4d0J/PjalgNNG55MQp8UfRKR3ldQ08uaGcl7fWMbbReVU720lIS6Gs8bm87EpAzlnfD9SEvRfXZHD0b8QCSsxMcaskbnMGpnL7ZdM5IVVu3lu1W4eemcrf3lzCwMzk/jIhP6cMSafWSNzSdWqSRKGaptaWVFcw5LtVSzZXsXS7dXUNLYCMKZ/GtfMGsaZY/sxa2QOcVpxT0R6SWNLO6t21bBkW5WXj6opq2sGYGhOCh+fMYgzxvTjtNF5JMVr6LaI9I7mtnbWldTtz0NLtlWxs7oRgH7piXxkfH9OH5PPWWPzSU+K9zlakfDRpf8pm9ls4HdALHC/c+7nBz2fCDwMHA9UAFc457b2bKgiB8pIiudThUP4VOEQahpbeXnNHp5bVcI/F+3g4Xe3ER9rnDA8h9NG5zNzRDaTBmWSGKeTVQkdNY2tFFfupai0nnW769iwp471u+v2n+AAjO6XxuyJAzh+eDanjc6jIDPZx4hFJBI1NLdRXBXMRRt21+3PR9sq9+JccJthuSmcOiqPGcOyOW1UnlYnFJEe19Tazo6qRjaVebloTx0bdtexpbyBtkAwGQ3ISGLGsCw+d8pwThmVx7gB6RoVIHKUjlgMMrNY4A/AucAOYKGZPeOcW9Nhs+uBKufcKDO7ErgTuKI3AhbpTGZyPJ88fjCfPH4wzW3tLNpaxRsbynh9Qxl3Pr8OgITYGCYPzqRwWDaTB2cybkA6w3NT1bNCepxzjtrGNsrqmymvb6asLvhzV3UjxZWNFFftpbhyL7VNbftfEx9rHJefRuHwbK7uP5RJgzKZNiSLzGRd4RKRo+Oco6GlfX8O+iAXNVFctZcdlXsprmqksqFl/2tiDEbkpTJhYAaXTh/ExIGZTB+aRV5aoo9HIiLhbm9LG+V1LZR1yEV7apso9vLQ9sq9+3se7jM0J4Ux/dM5f+IAxhdkMGNYli6KifSgrvQMmgkUOec2A5jZXOASoGMx6BLgdu/+E8A9ZmbO7bueJNJ3EuNiOWVUHqeMyuPWC8dTXt/M4m1VLNpayaJtVTz49hZa24NfzYTYGI7rl8agrGT6ZySSl5ZIckIsCbExJMbHEB8bgwExZpgRvBG8D8GVz2I6tBlwdBcnuveio3mP7rxkRF4qo/und/9NQsSRejMejZ3VjazcUUNtUyt1TW3UNno/m1qpa2qltrGNuuZWKutbKK9voaU98KF9JMbFMDg7mSE5KcwYms2QnGSGZKcwql8aw/NSiVdhUiSi9EYuqvD+ptU2tX2Qe5paP8hN3s/KhhbK65tpav1wLoqPNQZlBXPR+QMz9+eikfmpHJefpiFfIhGmN3JRQ3Mb726qOPC8qPnA86Papjaq97ZQXtdMQ0v7h/YRY1CQmcyQnGTOGpvPkOwUhuSkMDwvldH90jTdg0gv68q/sEFAcYfHO4ATD7WNc67NzGqAXKC840ZmdiNwI8DQoUOPMmSR7slLS+T8iQM4f+IAINgFtai0nvX7huXsqWNH1V6WbK864OpoNPvSGcdxywXj/A7jqHSxN2O3vbmhjFv+tfKAtrTEODKS4khPiicjOY5+6UmM6Z9Ofnoi+WnB4mJ+evBnXloC2SkJWtJUJEr0Vi5at7uOG/+2+IC2lIRYMpLiSU+KIyM5npzUBEbmpXbIPx1yUXoCuamJmnBeJEr0Vi6qqG/hCw8vOqAtKT7mgFyUmRzP0JyU4DlResL+XLTvHCk3LUEXwkR81KflVufcfcB9AIWFheo1JL5Iio9l0qBMJg3K/NBz7QFHS1uA5rZ272fwiqpzEHAOR7DbvfPawHnPgfPud1d3XxN89959jzAfDtCV3ozddu6E/kwenElGUjwZSfGkJcXpP1Micji9koumDM7k2a+duv8/XOlJcRruLCKH0yu5aEBmEs989ZQOuSheKwmKhJmuFIN2AkM6PB7stXW2zQ4ziwMyCU4kLRJWYmOM5IRYkhPURT6MdaU3Y7flpiWSG95FMhHpW72Si9KT4ju9mCEicgi9kosS4mKYMjjrWHcjIj7qSvl2ITDazEaYWQJwJfDMQds8A1zr3b8MeEXzBYlIqDKzG81skZktKisr8zscEYlSykUiEiqUj0SizxGLQc65NuCrwAvAWuBx59xqM/uxmV3sbfYAkGtmRcD/A27prYBFRI7giL0ZnXP3OecKnXOF+fn5fRqciEQN5SIRCQVdGeWhfCQShbo0Z5Bzbh4w76C2H3a43wR8qmdDExE5Kvt7MxI82bkSuNrfkEQkCikXiUgoUC4SkU5pvT4RiSjeiob7ejPGAg8651b7HJaIRBnlIhEJBcpFInIoKgaJSMTprDejiEhfUy4SkVCgXCQindH6fyIiIiIiIiIiUUTFIBERERERERGRKKJikIiIiIiIiIhIFFExSEREREREREQkiqgYJCIiIiIiIiISRcw5588bm5UB27q4eR5Q3ovh+CmSjw0i+/h0bEHDnHP5vRlMb1IuOkAkH5+OLTwpF3Uukj9ziOzj07GFp6jJRaB81IGOLTzp2IKOmIt8KwZ1h5ktcs4V+h1Hb4jkY4PIPj4dW/SJ9N9LJB+fji08RfKxHYtI/71E8vHp2MJTJB/bsYrk342OLTzp2LpOw8RERERERERERKKIikEiIiIiIiIiIlEkXIpB9/kdQC+K5GODyD4+HVv0ifTfSyQfn44tPEXysR2LSP+9RPLx6djCUyQf27GK5N+Nji086di6KCzmDBIRERERERERkZ4RLj2DRERERERERESkB4R8McjMZpvZejMrMrNb/I7naJjZVjNbaWbLzGyR15ZjZi+Z2UbvZ7bXbmZ2t3e8K8xshr/RH8jMHjSzUjNb1aGt28diZtd62280s2v9OJaDHeLYbjeznd5nt8zMLuzw3K3esa03s/M7tIfcd9bMhpjZq2a2xsxWm9nNXntEfHZ9IRQ/1+5SLgqP77NyUfh+dn0hFD/X7lIuCo/vs3JR+H52fSEUP9fuiqRcBMpH4ZiPfM9FzrmQvQGxwCZgJJAALAcm+B3XURzHViDvoLZfALd4928B7vTuXwg8BxgwC1jgd/wHxX06MANYdbTHAuQAm72f2d797BA9ttuBb3ey7QTv+5gIjPC+p7Gh+p0FCoAZ3v10YIN3DBHx2fXB7y8kP9ejOA7lojD4PisXhe9n1we/v5D8XI/iOJSLwuD7rFwUvp9dH/z+QvJzPYrjiJhc5MWofOTCKx/5nYtCvWfQTKDIObfZOdcCzAUu8TmmnnIJMMe7Pwe4tEP7wy7oPSDLzAp8iK9Tzrk3gMqDmrt7LOcDLznnKp1zVcBLwOxeD/4IDnFsh3IJMNc51+yc2wIUEfy+huR31jlX4pxb4t2vA9YCg4iQz64PhOTn2kOUi0Ls+6xcFL6fXR8Iyc+1hygXhdj3WbkofD+7PhCSn2sPCctcBMpHHYRNPvI7F4V6MWgQUNzh8Q6vLdw44EUzW2xmN3pt/Z1zJd793UB/7344HnN3jyXcjvGrXje8B/d10SOMj83MhgPTgQVE/mfXUyLluJWLgsL1+6xcFEbH10si5biVi4LC9fusXBRGx9dLIuW4Iz0XQeR/pyMmH/mRi0K9GBQpTnXOzQAuAG4ys9M7PumccwSTUdiLpGPx3AscB0wDSoBf+xrNMTKzNOBJ4BvOudqOz0XgZycfplwUvpSLJJIoF4Uv5SKJJFGTiyDyjocIykd+5aJQLwbtBIZ0eDzYawsrzrmd3s9S4CmCXdT27Ota6P0s9TYPx2Pu7rGEzTE65/Y459qdcwHgLwQ/OwjDYzOzeIJJ5h/OuX95zRH72fWwiDhu5aL9wu77rFy0X8gfXy+LiONWLtov7L7PykX7hfzx9bKIOO4oyEUQwd/pSMlHfuaiUC8GLQRGm9kIM0sArgSe8TmmbjGzVDNL33cfOA9YRfA4rvU2uxZ42rv/DHCNN1P4LKCmQxexUNXdY3kBOM/Msr3ufOd5bSHnoLHAHyf42UHw2K40s0QzGwGMBt4nRL+zZmbAA8Ba59xvOjwVsZ9dDwvJz7U7lIvC+/usXBS+n10PC8nPtTuUi8L7+6xcFL6fXQ8Lyc+1O6IkF0EEf6cjIR/5nouczzODH+lGcMbsDQRn/v6B3/EcRfwjCc5UvhxYve8YgFxgPrAReBnI8doN+IN3vCuBQr+P4aDjeZRgN7xWgmMRrz+aYwE+T3AyryLgc34f12GO7W9e7Cu8f3wFHbb/gXds64ELQvk7C5xKsHvhCmCZd7swUj67Pvodhtzn2s34lYvC5PusXBS+n10f/Q5D7nPtZvzKRWHyfVYuCt/Pro9+hyH3uXYz/ojKRV6MykcfbB8W+cjvXGTeC0VEREREREREJAqE+jAxERERERERERHpQSoGiYiIiIiIiIhEERWDRERERERERESiiIpBIiIiIiIiIiJRRMUgEREREREREZEoomKQiIiIiIiIiEgUUTFIRERERERERCSKqBgkIiIiIiIiIhJF/j++U0EzU7uU8wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Amplification = 50" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Amplification = 100" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Amplification = 200" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Amplification = 400" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Amplification = 800" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(len(amps)):\n", + " display(Markdown(f\" Date: Mon, 25 Sep 2023 11:38:19 -0500 Subject: [PATCH 13/32] improved price accuracy for stableswap_arbitrage --- hydradx/model/amm/trade_strategies.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/hydradx/model/amm/trade_strategies.py b/hydradx/model/amm/trade_strategies.py index 7c6cf6d3..89c98be9 100644 --- a/hydradx/model/amm/trade_strategies.py +++ b/hydradx/model/amm/trade_strategies.py @@ -593,7 +593,7 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): delta_x = ( stable_pool.liquidity[sell_asset] - stable_pool.calculate_y(stable_pool.modified_balances(delta={buy_asset: -delta_y}, omit=[sell_asset]), d) - ) * (1 + stable_pool.trade_fee) + ) / (1 - stable_pool.trade_fee) projected_profit = ( delta_y * state.price(buy_asset) @@ -605,8 +605,12 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): # agent.trade_rejected += 1 return state - new_state = state.execute_swap(pool_id, agent_id, sell_asset, buy_asset, buy_quantity=delta_y) - return new_state + # agent = state.agents[agent_id] + # old_wealth = sum([state.price(tkn) * agent.holdings[tkn] for tkn in agent.holdings.keys()]) + # state.pools[pool_id].swap(agent, tkn_sell=sell_asset, tkn_buy=buy_asset, buy_quantity=delta_y) + # + # actual_profit = sum([state.price(tkn) * agent.holdings[tkn] for tkn in agent.holdings.keys()]) - old_wealth + return state return TradeStrategy(strategy, name='stableswap arbitrage') From 1247ebbdc51e0e96286f02763aad488deb88d8a7 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 11:44:21 -0500 Subject: [PATCH 14/32] extended test_spot_price for 4 assets --- hydradx/tests/test_stableswap.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index ab4b9165..c6dbd1f3 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -61,33 +61,36 @@ def test_swap_invariant(initial_pool: StableSwapPoolState): raise AssertionError('Some assets were lost along the way.') -@given(st.integers(min_value=1000,max_value=1000000), - st.integers(min_value=1000,max_value=1000000), - st.integers(min_value=10,max_value=1000) +@given(st.integers(min_value=1000, max_value=1000000), + st.integers(min_value=1000, max_value=1000000), + st.integers(min_value=1000, max_value=1000000), + st.integers(min_value=1000, max_value=1000000), + st.integers(min_value=10, max_value=1000), + st.integers(min_value=1, max_value=3) ) -def test_spot_price(token_a: int, token_b: int, amp: int): - tokens = {"A": token_a, "B": token_b} +def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: int, i: int): + tokens = {"A": token_a, "B": token_b, "C": token_c, "D": token_d} initial_pool = StableSwapPoolState( tokens=tokens, amplification=amp, trade_fee=0.0, unique_id='stableswap' ) - - spot_price_initial = initial_pool.spot_price('B', 'A') + tkns = ["A", "B", "C", "D"] + spot_price_initial = initial_pool.spot_price(tkns[i], "A") trade_size = 1 - agent = Agent(holdings={"A": 100000, "B": 100000}) - initial_pool.swap(agent, tkn_sell="A", tkn_buy="B", sell_quantity=trade_size) + agent = Agent(holdings={"A": 1.1, "B": 1.1, "C": 1.1, "D": 1.1}) + initial_pool.swap(agent, tkn_sell="A", tkn_buy=tkns[i], sell_quantity=trade_size) delta_a = initial_pool.liquidity["A"] - tokens["A"] - delta_b = tokens["B"] - initial_pool.liquidity["B"] + delta_b = tokens[tkns[i]] - initial_pool.liquidity[tkns[i]] exec_price = delta_a / delta_b - spot_price_final = initial_pool.spot_price('B', 'A') + spot_price_final = initial_pool.spot_price(tkns[i], "A") - if spot_price_initial > exec_price: + if spot_price_initial > exec_price and (spot_price_initial - exec_price)/spot_price_initial > 10e-7: raise AssertionError('Initial spot price should be lower than execution price.') - if exec_price > spot_price_final: + if exec_price > spot_price_final and (exec_price - spot_price_final)/spot_price_final > 10e-7: raise AssertionError('Execution price should be lower than final spot price.') From 7b8737f30536121193b3a686d4f261322db0e425 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 11:44:44 -0500 Subject: [PATCH 15/32] added headings to the graphs at the bottom --- .../ImpermanentLossAnalysis4Assets.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index 0fe0f303..25d01f9c 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -386,13 +386,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ - "Amplification = 25" + "

Amplification = 25

" ], "text/plain": [ "" @@ -416,7 +416,7 @@ { "data": { "text/markdown": [ - "Amplification = 50" + "

Amplification = 50

" ], "text/plain": [ "" @@ -440,7 +440,7 @@ { "data": { "text/markdown": [ - "Amplification = 100" + "

Amplification = 100

" ], "text/plain": [ "" @@ -464,7 +464,7 @@ { "data": { "text/markdown": [ - "Amplification = 200" + "

Amplification = 200

" ], "text/plain": [ "" @@ -488,7 +488,7 @@ { "data": { "text/markdown": [ - "Amplification = 400" + "

Amplification = 400

" ], "text/plain": [ "" @@ -512,7 +512,7 @@ { "data": { "text/markdown": [ - "Amplification = 800" + "

Amplification = 800

" ], "text/plain": [ "" @@ -536,7 +536,7 @@ ], "source": [ "for i in range(len(amps)):\n", - " display(Markdown(f\"Amplification = {amps[i]}\"))\n", " pu.plot(amp_events[i], pool='stableswap', prop='liquidity')\n", " plt.show()\n" ] From c7d86f4a1ee8d150ac87c14c2ecc36e735caf26a Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 13:06:00 -0500 Subject: [PATCH 16/32] modified stableswap_arbitrage to use original price_at_balance signature --- hydradx/model/amm/trade_strategies.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/hydradx/model/amm/trade_strategies.py b/hydradx/model/amm/trade_strategies.py index 89c98be9..15b93efb 100644 --- a/hydradx/model/amm/trade_strategies.py +++ b/hydradx/model/amm/trade_strategies.py @@ -584,10 +584,15 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): balance_in = stable_pool.calculate_y( stable_pool.modified_balances(delta={buy_asset: -buy_amount}, omit=[sell_asset]), d ) - balances = {tkn: stable_pool.liquidity[tkn] for tkn in stable_pool.asset_list} - balances[buy_asset] = balance_out - balances[sell_asset] = balance_in - return stable_pool.price_at_balance(balances, buy_asset, sell_asset) + balances = list(stable_pool.liquidity.values()) + balances[list(stable_pool.liquidity.keys()).index(buy_asset)] = balance_out + balances[list(stable_pool.liquidity.keys()).index(sell_asset)] = balance_in + return stable_pool.price_at_balance( + balances, + d=stable_pool.d, + i=list(stable_pool.liquidity.keys()).index(buy_asset), + n=list(stable_pool.liquidity.keys()).index(sell_asset) + ) delta_y = find_agent_delta_y(target_price, price_after_trade, precision=precision) delta_x = ( From 9e78abb6e9c4b657c82da4f2d5bf98d222c1eb37 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 13:06:36 -0500 Subject: [PATCH 17/32] put back spot_price to its original form and added price(tkn, denominator) --- hydradx/model/amm/stableswap_amm.py | 31 +++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index 634008a1..7e458861 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -112,21 +112,36 @@ def calculate_y(self, reserves: list, d: float, max_iterations=128): return y # price is denominated in the first asset - def spot_price(self, tkn: str, numeraire: str): + def spot_price(self, i: int): """ return the price of TKN denominated in NUMÉRAIRE """ - return self.price_at_balance(self.liquidity, tkn, numeraire) + balances = list(self.liquidity.values()) + if i == 0: # price of the numeraire is always 1 + return 1 + return self.price_at_balance(balances, self.d, i) - def price_at_balance(self, balances: dict, tkn: str, numeraire: str): + def price(self, tkn, denomination: str = ''): + """ + return the price of TKN denominated in NUMÉRAIRE + """ + if tkn == denomination: + return 1 + i = list(self.liquidity.keys()).index(tkn) + n = list(self.liquidity.keys()).index(denomination) + return self.price_at_balance( + balances=list(self.liquidity.values()), + d=self.d, + i=i, n=n + ) + + def price_at_balance(self, balances: list, d: float, i: int = 1, n: int = 0): c = self.amplification * self.n_coins ** (2 * self.n_coins) p = 1 - for x in balances.values(): + for x in balances: p *= x - x = balances[numeraire] - y = balances[tkn] - n = self.n_coins - d = self.d + x = balances[n] + y = balances[i] return (x / y) * (c * y * p + d ** (n + 1)) / (c * x * p + d ** (n + 1)) def modified_balances(self, delta: dict = None, omit: list = ()): From bead25bf217080877dee846e0a5479fce1922974 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 14:58:27 -0500 Subject: [PATCH 18/32] switched everything from spot_price to price() and increased accuracy of test_swap_one --- hydradx/tests/test_stableswap.py | 45 ++++++++++++++++---------------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index c6dbd1f3..6ecc49c3 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -77,7 +77,7 @@ def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: unique_id='stableswap' ) tkns = ["A", "B", "C", "D"] - spot_price_initial = initial_pool.spot_price(tkns[i], "A") + spot_price_initial = initial_pool.price(tkns[i], "A") trade_size = 1 agent = Agent(holdings={"A": 1.1, "B": 1.1, "C": 1.1, "D": 1.1}) @@ -86,11 +86,11 @@ def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: delta_b = tokens[tkns[i]] - initial_pool.liquidity[tkns[i]] exec_price = delta_a / delta_b - spot_price_final = initial_pool.spot_price(tkns[i], "A") + spot_price_final = initial_pool.price(tkns[i], "A") - if spot_price_initial > exec_price and (spot_price_initial - exec_price)/spot_price_initial > 10e-7: + if spot_price_initial > exec_price and (spot_price_initial - exec_price)/spot_price_initial > 10e-10: raise AssertionError('Initial spot price should be lower than execution price.') - if exec_price > spot_price_final and (exec_price - spot_price_final)/spot_price_final > 10e-7: + if exec_price > spot_price_final and (exec_price - spot_price_final)/spot_price_final > 10e-10: raise AssertionError('Execution price should be lower than final spot price.') @@ -189,14 +189,14 @@ def test_arbitrage(stable_pool): # evolve_function = fluctuate_prices(volatility={'R1': 1, 'R2': 1}, trend = {'R1': 1, 'R1': 1}) ) events = run.run(initial_state, time_steps=50, silent=True) - # print(events[0].pools['R1/R2'].spot_price, events[-1].pools['R1/R2'].spot_price) + # print(events[0].pools['R1/R2'].price, events[-1].pools['R1/R2'].price) if ( - events[0].pools['R1/R2'].spot_price('R1', 'R2') - != pytest.approx(events[-1].pools['R1/R2'].spot_price('R1', 'R2'), abs=0.000001) + events[0].pools['R1/R2'].price('R1', 'R2') + != pytest.approx(events[-1].pools['R1/R2'].price('R1', 'R2'), abs=0.000001) ): raise AssertionError(f"Arbitrageur didn't keep the price stable." - f"({events[0].pools['R1/R2'].spot_price})" - f"{events[-1].pools['R1/R2'].spot_price}") + f"({events[0].pools['R1/R2'].price})" + f"{events[-1].pools['R1/R2'].price}") if ( sum(events[0].agents['Arbitrageur'].holdings.values()) > sum(events[-1].agents['Arbitrageur'].holdings.values()) @@ -328,9 +328,9 @@ def test_exploitability(initial_lp: int, trade_size: int): if profit > 0: raise AssertionError(f'Agent profited by exploit ({profit}).') - if initial_state.spot_price('USDA', 'USDB') < final_state.spot_price('USDA', 'USDB'): + if initial_state.price('USDA', 'USDB') < final_state.price('USDA', 'USDB'): min_arb_size = arb_size - elif initial_state.spot_price('USDA', 'USDB') > final_state.spot_price('USDA', 'USDB'): + elif initial_state.price('USDA', 'USDB') > final_state.price('USDA', 'USDB'): max_arb_size = arb_size else: break @@ -338,15 +338,15 @@ def test_exploitability(initial_lp: int, trade_size: int): @given( st.integers(min_value=1, max_value=1000000), - st.floats(min_value=0.00000001, max_value=0.999999) + st.floats(min_value=0.00001, max_value=0.99999) ) def test_swap_one(amplification, swap_fraction): initial_state = StableSwapPoolState( tokens={ - 'USDA': 1000000, - 'USDB': 1000000, - 'USDC': 1000000, - 'USDD': 1000000, + 'USDA': mpf(1000000), + 'USDB': mpf(1000000), + 'USDC': mpf(1000000), + 'USDD': mpf(1000000), }, amplification=amplification, trade_fee=0, ) stablecoin = initial_state.asset_list[-1] @@ -366,13 +366,13 @@ def test_swap_one(amplification, swap_fraction): for tkn in initial_state.asset_list: if ( - sell_state.spot_price(tkn, stablecoin) - != pytest.approx(initial_state.spot_price(tkn, stablecoin)) + sell_state.price(tkn, stablecoin) + != pytest.approx(initial_state.price(tkn, stablecoin)) and tkn != tkn_sell ): raise AssertionError('Spot price changed for non-swapped token.') - if sell_state.spot_price(tkn_sell, stablecoin) >= initial_state.spot_price(tkn_sell, stablecoin): + if sell_state.price(tkn_sell, stablecoin) >= initial_state.price(tkn_sell, stablecoin): raise AssertionError('Spot price increased for swapped token.') if sell_state.d != pytest.approx(initial_state.d): @@ -390,14 +390,15 @@ def test_swap_one(amplification, swap_fraction): for tkn in initial_state.asset_list: if ( - buy_state.spot_price(tkn, stablecoin) - != pytest.approx(initial_state.spot_price(tkn, stablecoin)) + buy_state.price(tkn, stablecoin) + != pytest.approx(initial_state.price(tkn, stablecoin)) and tkn != tkn_buy ): raise AssertionError('Spot price changed for non-swapped token.') - if buy_state.spot_price(tkn_buy, stablecoin) <= sell_state.spot_price(tkn_buy, stablecoin): + if buy_state.price(tkn_buy, stablecoin) <= sell_state.price(tkn_buy, stablecoin): raise AssertionError('Spot price decreased for swapped token.') if buy_state.d != pytest.approx(initial_state.d): raise AssertionError('D changed after buy operation.') + From 1ff05af8926fbeb5a2ce76294ca25f4c27b17e1e Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 17:06:07 -0500 Subject: [PATCH 19/32] fixed stableswap_arbitrage --- hydradx/model/amm/trade_strategies.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/hydradx/model/amm/trade_strategies.py b/hydradx/model/amm/trade_strategies.py index 15b93efb..bcbcb081 100644 --- a/hydradx/model/amm/trade_strategies.py +++ b/hydradx/model/amm/trade_strategies.py @@ -591,7 +591,7 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): balances, d=stable_pool.d, i=list(stable_pool.liquidity.keys()).index(buy_asset), - n=list(stable_pool.liquidity.keys()).index(sell_asset) + j=list(stable_pool.liquidity.keys()).index(sell_asset) ) delta_y = find_agent_delta_y(target_price, price_after_trade, precision=precision) @@ -610,9 +610,9 @@ def price_after_trade(buy_amount: float = 0, sell_amount: float = 0): # agent.trade_rejected += 1 return state - # agent = state.agents[agent_id] + agent = state.agents[agent_id] # old_wealth = sum([state.price(tkn) * agent.holdings[tkn] for tkn in agent.holdings.keys()]) - # state.pools[pool_id].swap(agent, tkn_sell=sell_asset, tkn_buy=buy_asset, buy_quantity=delta_y) + state.pools[pool_id].swap(agent, tkn_sell=sell_asset, tkn_buy=buy_asset, buy_quantity=delta_y) # # actual_profit = sum([state.price(tkn) * agent.holdings[tkn] for tkn in agent.holdings.keys()]) - old_wealth return state From 4dd65ca5a610e44dbc0ab8e397b28ee37eea6360 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 17:06:48 -0500 Subject: [PATCH 20/32] removed randomness and fixed error message in test_arbitrage --- hydradx/tests/test_stableswap.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 6ecc49c3..439fe0eb 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -172,7 +172,7 @@ def test_arbitrage(stable_pool): 'Trader': Agent( holdings={'R1': 1000000, 'R2': 1000000, 'R3': 1000000, 'R4': 1000000}, trade_strategy=random_swaps( - pool_id='R1/R2', amount={'R1': 10000, 'R2': 10000, 'R3': 10000, 'R4': 10000}, randomize_amount=True + pool_id='R1/R2', amount={'R1': 10000, 'R2': 10000, 'R3': 10000, 'R4': 10000}, randomize_amount=False ) ), 'Arbitrageur': Agent( @@ -189,14 +189,13 @@ def test_arbitrage(stable_pool): # evolve_function = fluctuate_prices(volatility={'R1': 1, 'R2': 1}, trend = {'R1': 1, 'R1': 1}) ) events = run.run(initial_state, time_steps=50, silent=True) - # print(events[0].pools['R1/R2'].price, events[-1].pools['R1/R2'].price) if ( events[0].pools['R1/R2'].price('R1', 'R2') != pytest.approx(events[-1].pools['R1/R2'].price('R1', 'R2'), abs=0.000001) ): raise AssertionError(f"Arbitrageur didn't keep the price stable." - f"({events[0].pools['R1/R2'].price})" - f"{events[-1].pools['R1/R2'].price}") + f"({events[0].pools['R1/R2'].price('R1', 'R2')}," + f"{events[-1].pools['R1/R2'].price('R1', 'R2')}") if ( sum(events[0].agents['Arbitrageur'].holdings.values()) > sum(events[-1].agents['Arbitrageur'].holdings.values()) From ace036262e2848e966d748eadf22469ce8c42525 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 25 Sep 2023 17:07:13 -0500 Subject: [PATCH 21/32] updated with Colin's lastest spot price calculation --- hydradx/model/amm/stableswap_amm.py | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index 7e458861..c6316c63 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -128,21 +128,29 @@ def price(self, tkn, denomination: str = ''): if tkn == denomination: return 1 i = list(self.liquidity.keys()).index(tkn) - n = list(self.liquidity.keys()).index(denomination) + j = list(self.liquidity.keys()).index(denomination) return self.price_at_balance( balances=list(self.liquidity.values()), d=self.d, - i=i, n=n + i=i, j=j ) - def price_at_balance(self, balances: list, d: float, i: int = 1, n: int = 0): - c = self.amplification * self.n_coins ** (2 * self.n_coins) - p = 1 - for x in balances: - p *= x - x = balances[n] - y = balances[i] - return (x / y) * (c * y * p + d ** (n + 1)) / (c * x * p + d ** (n + 1)) + def price_at_balance(self, balances: list, d: float, i: int = 1, j: int = 0): + a = self.amplification + n = self.n_coins + ann = a * n ** n + + c = d + sorted_bal = sorted(balances) + for x in sorted_bal: + c = c * d / (n * x) + + xi = balances[i] + xj = balances[j] + + p = xj * (ann * xi + c) / (ann * xj + c) / xi + + return p def modified_balances(self, delta: dict = None, omit: list = ()): balances = copy.copy(self.liquidity) From 3cd4ea91f18dbd793e6f19d8d19c838cb698987e Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Tue, 26 Sep 2023 14:24:14 -0500 Subject: [PATCH 22/32] removed unnecessary check on invest_all --- hydradx/model/amm/trade_strategies.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/hydradx/model/amm/trade_strategies.py b/hydradx/model/amm/trade_strategies.py index bcbcb081..d633d621 100644 --- a/hydradx/model/amm/trade_strategies.py +++ b/hydradx/model/amm/trade_strategies.py @@ -160,9 +160,8 @@ def __init__(self, _when): self.done = False def execute(self, state: GlobalState, agent_id: str): - if self.done or state.time_step < self.when: + if state.time_step < self.when: return state - self.done = True agent: Agent = state.agents[agent_id] pool = state.pools[pool_id] From 540e04d2eee0bc64be9840124bf75473cb3597ea Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Tue, 26 Sep 2023 14:24:43 -0500 Subject: [PATCH 23/32] minor corrections on swap_one() --- hydradx/model/amm/stableswap_amm.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index c6316c63..ff3f666e 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -240,7 +240,7 @@ def swap_one( This can be used when you want to change the price of one asset without changing the price of the others. Specify one asset to buy or sell, and the quantity of each of the *other* assets to sell or buy. The quantity of the specified asset to trade will be determined. - Caution: this will only work correctly if the pool is balanced (spot prices equal on all assets). + Caution: this will only work correctly if the pool is initially balanced (spot prices equal on all assets). """ if tkn_sell and tkn_buy: raise ValueError('Cannot specify both buy and sell quantities.') @@ -269,7 +269,7 @@ def swap_one( agent.holdings[tkn_buy] += buy_quantity elif tkn_sell: - tkns_buy = list(filter(lambda tkn: tkn != tkn_sell, self.asset_list)) + tkns_buy = list(filter(lambda t: t != tkn_sell, self.asset_list)) buy_quantity = quantity if min([self.liquidity[tkn] for tkn in tkns_buy]) < buy_quantity: From fbe325dd08c7cf0e86a8ef3aacf251c536705e08 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Tue, 26 Sep 2023 14:41:49 -0500 Subject: [PATCH 24/32] updated function signatures and A values --- .../Stableswap/ImpermanentLossAnalysis.ipynb | 125 +++++++++--------- 1 file changed, 64 insertions(+), 61 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb index e292c5de..a9207d3f 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 27, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.614450927Z", @@ -43,7 +43,6 @@ "\n", "# same seed, same parameters = same simulation result\n", "random.seed(42)\n", - "# price_list = processing.import_binance_prices(['BTC', 'ETH', 'DOT'], start_date='Jan 1 2023', days = 120)\n", "\n", "assets = {\n", " 'USDA': {'usd price': 1, 'weight': 0.50},\n", @@ -80,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 28, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -98,33 +97,40 @@ } ], "source": [ - "amps = [12.5, 25, 50, 100, 200]\n", - "trade_range = [2300000, 1900000, 1700000, 1500000, 1100000]\n", + "amps = [12.5, 25, 50, 100, 200, 400, 800] # , 10000000]\n", + "trade_range = [2300000, 1900000, 1700000, 1500000, 1100000, 990000, 910000] # , 507800]\n", "steps = 5000\n", "amp_events = []\n", + "invested_state = initial_state.agents['LP'].trade_strategy.execute(\n", + " initial_state.copy(),\n", + " agent_id='LP'\n", + ")\n", "for i, amplification in enumerate(amps):\n", - " initial_state.pools['stableswap'].amplification = amplification\n", + " invested_state.pools['stableswap'].amplification = amplification\n", " trade_size_min, trade_size_max = -trade_range[i], trade_range[i]\n", " trade_sizes = [trade_size_min + i * (trade_size_max - trade_size_min) / steps for i in range(steps)]\n", " events = []\n", "\n", " for trade_size in trade_sizes:\n", " # trade to change the price of assets. \n", - " # We assume that whatever the resulting price is the new market price, and the trade is an arb trade.\n", - " events.append(\n", - " run.run(initial_state, time_steps=1, silent=True)[-1].execute_swap(\n", - " pool_id='stableswap',\n", - " agent_id='Trader',\n", - " tkn_sell='USDA' if trade_size > 0 else 'USDB',\n", - " tkn_buy='USDB' if trade_size > 0 else 'USDA',\n", - " sell_quantity=max(abs(trade_size), 0),\n", - " )\n", + " # We assume that the trade is an arb trade, and whatever the resulting price is the new market price.\n", + " \n", + " new_state = invested_state.copy()\n", + " new_state.pools['stableswap'].swap(\n", + " agent=new_state.agents['Trader'],\n", + " tkn_sell='USDA' if trade_size > 0 else 'USDB',\n", + " tkn_buy='USDB' if trade_size > 0 else 'USDA',\n", + " sell_quantity=max(abs(trade_size), 0),\n", " )\n", + " if new_state.pools['stableswap'].fail:\n", + " print(f\"failed with trade size {trade_size}\")\n", + " new_state.external_market['USDA'] = new_state.pools['stableswap'].price('USDA', 'USDB')\n", + " events.append(new_state)\n", "\n", + " # print(events[-1].external_market['USDA'])\n", " for event in events:\n", " # agent withdraws assets in equal proportion\n", - " StableSwapPoolState.execute_remove_uniform(\n", - " state=event.pools['stableswap'],\n", + " event.pools['stableswap'].remove_uniform(\n", " agent=event.agents['LP'],\n", " shares_removed=event.agents['LP'].holdings['stableswap']\n", " )\n", @@ -136,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 29, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -145,9 +151,29 @@ "tags": [] }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "withdraw vals: 38693.31110168434 - 38679.447716633935\n", + "deposit vals: 5459063.883129939 - 5452143.269209162\n", + "withdraw vals: 32601.062262776297 - 32589.52345404563\n", + "deposit vals: 5831307.125647275 - 5823661.37706083\n", + "withdraw vals: 29531.01450978018 - 29520.62730654679\n", + "deposit vals: 7996976.881893186 - 7986199.582767676\n", + "withdraw vals: 26450.267043381886 - 26441.0252924171\n", + "deposit vals: 10358550.001000993 - 10344056.134209413\n", + "withdraw vals: 20199.75214742055 - 20192.764888551454\n", + "deposit vals: 6476085.514061861 - 6465596.809359915\n", + "withdraw vals: 18434.186038222684 - 18427.799208916826\n", + "deposit vals: 8281060.5921689 - 8266515.91506627\n", + "withdraw vals: 17131.29648621797 - 17125.338529637313\n", + "deposit vals: 11240337.315232767 - 11218904.26952222\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -159,7 +185,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -171,7 +197,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -187,26 +213,21 @@ "impermanent_loss = []\n", "usda_prices = []\n", "for i, events in enumerate(amp_events):\n", - " \n", - " usda_prices.append([\n", - " 1 / event.pools['stableswap'].spot_price\n", - " for event in events\n", - " ])\n", - " \n", - " asset_value = [\n", - " value_assets(prices={'USDA': usda_prices[-1][i], 'USDB': 1}, assets=event.agents['LP'].holdings)\n", + " prices = [{tkn: event.external_market[tkn] for tkn in assets} for event in events]\n", + " withdraw_vals = [\n", + " value_assets(prices=prices[i], assets=event.agents['LP'].holdings)\n", " for i, event in enumerate(events)\n", " ]\n", "\n", - " deposit_value = [\n", - " value_assets(prices={'USDA': usda_prices[-1][i], 'USDB': 1}, assets=initial_state.agents['LP'].holdings)\n", + " deposit_vals = [\n", + " value_assets(prices=prices[i], assets=initial_state.agents['LP'].holdings)\n", " for i, event in enumerate(events)\n", " ]\n", + " print(f\"withdraw vals: {withdraw_vals[0]} - {withdraw_vals[1]}\")\n", + " print(f\"deposit vals: {deposit_vals[0]} - {deposit_vals[1]}\")\n", + " usda_prices.append([event.external_market['USDA'] for event in amp_events[i]])\n", + " impermanent_loss.append([withdraw_vals[i] / deposit_vals[i] - 1 for i in range(len(amp_events[i]))])\n", "\n", - " impermanent_loss.append([\n", - " asset_value[i] / deposit_value[i] - 1\n", - " for i, event in enumerate(events)\n", - " ])\n", "\n", "# display(Markdown(f'

Impermanent Loss Dynamics at {amps[i]} Amplification

'))\n", "\n", @@ -220,8 +241,8 @@ " ['$0.98', '$0.99', '$1.00', '$1.01', '$1.02']\n", ")\n", "plt.yticks(\n", - " [-0.001 * i for i in range(7)],\n", - " [f'-{round(0.1 * i * 10, 2) / 10}%' for i in range(7)]\n", + " [-0.002 * i for i in range(6)],\n", + " [f'-{round(0.2 * i * 10, 2) / 10}%' for i in range(6)]\n", ")\n", "\n", "for i, loss in enumerate(impermanent_loss):\n", @@ -246,13 +267,13 @@ " [f'-{2 * i}%' for i in range(6)]\n", ")\n", "\n", + "price_min, price_max = 0.80, 1.25\n", "for i, loss in enumerate(impermanent_loss):\n", - " center = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1))[0])\n", - " range_width = abs(center - usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1.27))[0]))\n", - " start_range = center - range_width\n", - " end_range = center + range_width\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0]) + 1\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0])\n", " plt.plot(usda_prices[i][start_range: end_range], loss[start_range: end_range], color=colors[i])\n", "plt.legend(amps, loc='center', title='amplification')\n", + "plt.show()\n", "\n", "# zoom out\n", "plt.figure(figsize=(20,5))\n", @@ -272,36 +293,18 @@ "if 1 in tick_prices:\n", " tick_prices.remove(1)\n", "\n", - "\n", "for i, loss in enumerate(impermanent_loss):\n", " center = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1))[0])\n", " range_width = abs(center - usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1010))[0]))\n", " start_range = center - range_width\n", " end_range = center + range_width\n", " plt.plot(usda_prices[i][start_range: end_range], [1 + loss for loss in loss[start_range: end_range]], color=colors[i])\n", - " # for price in tick_prices:\n", - " # best_match = usda_prices[i].index(sorted(usda_prices[i], key=lambda x: abs(x - price))[0])\n", - " # usda_price = usda_prices[i][best_match]\n", - " # l = loss[best_match]\n", - " # plt.annotate(\n", - " # text=f'{round(l * 100, 2)}%',\n", - " # xy=(usda_price, 1 + l),\n", - " # xytext=(25, 40) if i > 2 else (-50, 40),\n", - " # textcoords='offset points',\n", - " # arrowprops={'arrowstyle': '->'}\n", - " # )\n", + "\n", "plt.legend(amps, loc='center', title='amplification')\n", "\n", "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, @@ -326,7 +329,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.9.7" } }, "nbformat": 4, From a4c9e1cb6a810e12154dbd4b490b4e24100594f1 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Tue, 26 Sep 2023 15:17:05 -0500 Subject: [PATCH 25/32] tweaked graphs --- .../ImpermanentLossAnalysis4Assets.ipynb | 67 +++++++++---------- 1 file changed, 31 insertions(+), 36 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index 25d01f9c..f41bb56d 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -94,18 +94,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.000995444390312422 247276.40443434505\n", - "156.87953617143862 -99990.00099990002\n", - "0.000977326252482079 247647.57879376572\n", - "199.71967208980743 -96686.31486433979\n", + "0.0009954443903124222 247276.40443434505\n", + "156.87953617143856 -99990.00099990002\n", + "0.0009773262524820792 247647.57879376572\n", + "199.71967208980746 -96686.31486433979\n", "0.0009877770884735417 247944.91939021496\n", "199.94530000067437 -92802.53170641157\n", - "0.000980612059546324 248217.79521216897\n", + "0.0009806120595463234 248217.79521216897\n", "199.67437907817265 -90032.92489873343\n", "0.000995282647861672 248441.28060711964\n", "199.67207475942692 -88073.92649009275\n", - "0.0009588261640137211 248664.96721939923\n", - "199.42914906713446 -86684.69418227047\n" + "0.0009588261640137208 248664.96721939923\n", + "199.42914906713443 -86684.69418227047\n" ] } ], @@ -116,6 +116,7 @@ ")\n", "amps = [25, 50, 100, 200, 400, 800]\n", "trade_range = [[200000, -100000]] * len(amps)\n", + "adjustment_factor = 1.0001\n", "# print(trade_range)\n", "for i, amp in enumerate(amps):\n", " for j, target_price in enumerate([0.001, 200]):\n", @@ -126,21 +127,21 @@ " spot_price > target_price \n", " and not try_state.pools['stableswap'].fail\n", " ):\n", - " # find the correct trade size to get the price we want\n", + " # find the ~ correct trade size to get the price we want\n", " if j == 0:\n", - " trade_range[i][j] *= 1.0001\n", + " trade_range[i][j] *= adjustment_factor\n", " elif j == 1:\n", - " trade_range[i][j] /= 1.0001\n", + " trade_range[i][j] /= adjustment_factor\n", " try_state = invested_state.copy()\n", " try_state.pools['stableswap'].swap_one(\n", " agent=try_state.agents['Trader'],\n", " tkn_sell='USDA',\n", " quantity=trade_range[i][j]\n", " )\n", - " spot_price = try_state.pools['stableswap'].spot_price('USDA', numeraire='USDD')\n", + " spot_price = try_state.pools['stableswap'].price('USDA', 'USDD')\n", " print(spot_price, trade_range[i][j])\n", " if try_state.pools['stableswap'].fail:\n", - " print('trade failed, use a smaller initial value or a smaller growth factor')\n", + " print('trade failed, use a smaller initial value or a smaller adjustment factor')\n", "\n", " if i < len(amps) - 1:\n", " trade_range[i+1] = copy.copy(trade_range[i])\n", @@ -149,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -162,12 +163,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "246053.5617069576 -99495.52581609144\n", - "246422.9005177458 -96208.1772222133\n", - "246718.77069170662 -92343.60032862835\n", - "246990.29707550816 -89587.6899088051\n", - "247212.6772801334 -87638.37922982244\n", - "247435.25770701826 -86256.0170179487\n", "simulation finished.\n" ] } @@ -185,7 +180,7 @@ " trade_sizes.append(\n", " [(1 / (1 + math.exp(j / (steps - 1) * 12 - 6)) * 2 - 1) * (trade_size_max if j < steps / 2 else -trade_size_min) for j in range(steps)]\n", " )\n", - " print(trade_sizes[-1][0], trade_sizes[-1][-1])\n", + " # print(trade_sizes[-1][0], trade_sizes[-1][-1])\n", " # trade to change the price of assets. \n", " # We assume that whatever the resulting price is the new market price, and the trade is an arb trade.\n", " \n", @@ -198,7 +193,7 @@ " )\n", " if new_state.pools['stableswap'].fail:\n", " print(f\"failed with trade size {trade_size}\")\n", - " new_state.external_market['USDA'] = new_state.pools['stableswap'].spot_price('USDA', numeraire='USDD')\n", + " new_state.external_market['USDA'] = new_state.pools['stableswap'].price('USDA', 'USDD')\n", " events.append(new_state)\n", " \n", " for event in events:\n", @@ -215,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -243,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 25, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -278,7 +273,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -360,13 +355,13 @@ "plt.grid()\n", "plt.yscale('log')\n", "plt.yticks(\n", - " [1, 0.1, 0.01, 0.001],\n", - " ['0%', '-90%', '-99%', '-99.9%']\n", + " [1, 0.5, 0.25, 0.12, 0.06, 0.03],\n", + " ['0%', '-50%', '-75%', '-88%', '-94%', '-97%']\n", ")\n", - "tick_prices = [0.001, 0.01, 0.1, 1, 10, 100, 1000]\n", + "tick_prices = [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100]\n", "plt.xticks(\n", " tick_prices,\n", - " ['$0.001', '$0.01', '$0.10', '$1.00', '$10', '$100', '$1000']\n", + " ['$0.01', '$0.03', '$0.10', '$0.30', '$1.00', '$3', '$10', '$30', '$100']\n", ")\n", "if 1 in tick_prices:\n", " tick_prices.remove(1)\n", @@ -386,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -403,7 +398,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -427,7 +422,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -451,7 +446,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -475,7 +470,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -499,7 +494,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAAE/CAYAAADCGZOXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB4XElEQVR4nO3dd3yddfn/8deVnbSZbbrTvfem7CkUVAqKDBGqIhUFx0+/fsWvA8Q9QRwoIAKKFEQRhDLKni2d6R5pOpK0adLs0czz+f1x7tZQkiZNk9wn57yfj8d55JzPfZ9zrjvn9Mrd6/4Mc84hIiIiIiIiIiKRLcrvAERERERERERExH8qEomIiIiIiIiIiIpEIiIiIiIiIiKiIpGIiIiIiIiIiKAikYiIiIiIiIiIoCKRiIiIiIiIiIigIpHvzOwcM8s/zvYHzeyHPRlTdzCz18zsc979a83sxS563efMbHEb20aamTOzmPb2FYl0ykUn/brKRSJdQLnopF9XuUikCygXnfTrKhf1YioSdTEzu93M/uZ3HKHMOfeIc+7CLnqti51zD53ovmb2aTN7q7Pv2zKhtmh73x8TM1tkZuvNrNLMDpnZK2Y2ytt2u5k1mlmVd9thZr8zs8GtvNenvUR6VWfjlcijXNQ+5aKO5SLv9QJmVu3dCszs+52NWSKLclH7lIs6fl5kZilmdpeZ7fPy0S7vcf/Oxi6RQbmofcpFnT4vyjezx81sXmfjDjUqEol0AzMbCzwMfB1IBUYBvweaW+z2mHMuGcgALgcGAWtaKRQtBkqB67s7bhEJL12Yi/Y75/o65/oCZwA3mNllPXAIIhIGuiIXmVkc8DIwBVgIpACnAiXA/J45EhHpzbr6vAhIBhYA24A3zez87j+K7qciUSeZ2Te9q6lVZrbdzM43s4XA/wFXeVXFbG/fz5jZVm/fXDP7fCuv939eJXOPmV17nPf9iFf5LDezd8xsejsxJZjZ4SNXWMzs22bWZGYp3uMfmNld3v0Pm9k6r6qaZ2a3t3jtI90Cl5jZfjM7YGb/08nf3fsqxGb2ITPbZmYVXqX2dftvt8f3Vf3tg90TW3aRjDazX3q/x1zgw8e872tm9jkzmwT8ETjV+5zKzWyemR00s+gW+3/syGfYCTOB3c65l11QlXPun865fcfu6JxrdM5tBq4CigkmrSMxjADOBpYAF5nZoE7GI2FKuUi5qB0z6YJcdMx+u4F3gMmdjEnCkHKRclE7ZnLyueh6YDhwuXNui3Mu4Jwrcs79wDm3rJNxSZhRLlIuasdMuvC8yHuNfOfc94D7gZ91Mq6QoiJRJ5jZBOAWYJ5XZbwI2OOcex74McHqY1/n3AzvKUXARwhe8fgMcKeZzW7xkoOA/sBQgr1G7vXe49j3nQU8AHwe6Af8CXjazOKPE1MdsIpgoQHv517g9BaPX/fu1xD8A5xG8B/vF+yDV4rPBcYBFwLfNLMLOvRLa4OXGP8FfIfg72BXi9hO1I0Ef8+zgLnAFa3t5JzbCtwEvOt9TmnOuVUEr0S17GJ5HcFKc2esBSaa2Z1mdq6Z9W3vCc65ZuAp4MwWzdcDq51z/wS2Am3+cZLIo1ykXNQBXZWLjjKzcQR/Nys6GZOEGeUi5aIO6IpcdAHwvHOuupMxSJhTLlIu6oAuPy9q4V/AbDPr08nYQkbIFonM7AEzKzKzTR3c/0oz22Jmm83s790cXjMQD0w2s1jn3B7n3K62dnbOPeuc2+VVGl8HXuSDX7LvOufqve3PAle28lJLgD8551Y655q9sZv1BLu4HS+m14GzvcrudOBu73ECMA94w4vzNefcRu/KzAbgUf6buI74vnOuxjm3EfgLcE1HfmHHcQmw2Tn3hHOuEbgLKOzka10J3OWcy3POlQI/OcHnPwR8CsDMMggm8U59l5xzucA5BP+oPA4csuAEd+0lov0EuzYecX2LGP6OhpzJ+ykXKRcdVxfmoiHeFb1KYAewEuj0nAESdpSLlIuOq4tyUT/gQGfeXyKGcpFy0XF14XlRW/sYwWJerxayRSLgQYLjjdvlXdX8FnC6c24K8NXuCwuccznee9wOFJnZUjMbcpz4LjazFWZWamblBP/RtZxgr8w5V9Pi8V6gtdcbAXzdO1Ev914rCxjSTkyvE/zHMBvYCCwnmFgWADnOuRIvzlPM7FUzKzazCoKV3GMnAszrQJwnYkjL13TOuWPeo9OvRTC+E/E34KNe9fdK4E3nXFsnI01A7DFtsUDjkQfOuRXOuSudc5kE/+CcBXy7nRiGEpx/CDM7neA42aXetr8D08xsZoePSMKaclG7cZ4I5aL3O5qLPPtd8IpeCsGTn8MET9pElIvaj/NEKBe9X8tcVAJ8YIEPkSOUi9qN80QoF73fsedFbe3jgPJ29gt5IVskcs69wTEfhJmNMbPnzWyNmb1pZhO9TTcCv3fOlXnPLeqB+P7unDuDYFJw/Hf8oTsm5njgn8AvgYHOuTRgGcEq4xHpx3RLG06wEnmsPOBH3on6kVuSc+7RdmJ6B5hAcOKt151zW7z3uIT/dmOEYBHiaSDLOZdKcExoyzghmPDai/NEHGj5mmZmx7xHDZDU4vHx5uR532t58bXFfaDBuQLgXeBjBLsx/vU4z98HjDymbRRtJD0X7Cr5L2BqWy9oZlHAR4E3vabFBH//682skOCV+yPtIoByUTtxngjlIk8ruejY16gg+Bl99DhxSYRRLjpunCdCucjTSi56ieD8jL1+KId0H+Wi48Z5IpSLPO2dF7VwObD2mMJirxSyRaI23At8yTk3B/gf4A9e+3hgvJm97VWDO9QDqbPMbIKZnecllzqCV1QD3uaDwEjvywQQR7CLYTHQZGYX8/4xlUd838zizOxMgmM2/9HKPvcBN3nVZDOzPhacyCz5eDE552qBNcDN/DfhvEOwCt0yASUDpc65OjObD3yylRi+a2ZJZjaF4Njdx47/22rXs8AUC05AFgN8mfcnmfXAWWY23MxSCfYYa8vjwJfNbJiZpQO3Hmffg8AwC66U0dLDwP8C0wgmjLY8BnzGzOZ7n8V44P/h9foxszPM7EYzG+A9nghcSitzeJhZjAUnanuU4LH/2oLdTK8k2H11Zovbl4BPer8riXDKRcpFdHMuau0NLdgl+2pg83HikgiiXKRcRM/kor8S/M/4P81soplFmVk/C04sfMlxYpMIoVykXEQPnxd57zHUzG4DPkdwgvRer9cUibyT0tOAf5jZeoITgh3pchpDcKKucwiOv7zPzNK6MZx44KfAIYJjMwfw338YRxJHiZmtdc5VEfxH9ThQRvAf9dPHvF6ht20/8Ahwk3Nu27Fv6pxbTbDX1O+8/XOAT3cgJggmmljgvRaPk/HGunq+CNxhZlXA97yYj/W6974vA790zr3Yyj4d5pw7BHzCi72E4Of4dovtywn+Y99AMIk+c5yXuw94AcgmOCnZ8RLIKwT/g1NoZodatD9JsMr/pJe424r7BYIJ7i9ABcErDw8RLGRCsJvhpcBGM6sGnvde++ctXuYqb1sFwe9ECTDHObcfuIzgH5GHnXOFR24EJ8WLoYNDMSXsKRcpF3V3LjpiiAVXGqkmeDUuA02kL/+lXKRc1O25yDlXT3Dy6m0Eh+VUEvz8+vPf3tYS2ZSLlIt69LwIqCY4Afk04JyT/b2HCgsOLwxNZjYSeMY5N9WCywFud859YCyymf0RWOmc+4v3+GXgVq/7mHQB77PYDcQ655q6+b1eA/7mnLu/O9/nOO+/C/i8c+4lP95fRNqmXCQioUC5SERCgXKRdIde05PIOVcJ7DazT8DRrl1Hli/8N8FeREeW6xsP5PoQpvRyZvZxgmNhX/E7FhGJXMpFIhIKlItEJBQoF/WskJ3XxMweJVj46W9m+cBtBLu232Nm3yHYLW8pwW5rLwAXmtkWgssMfsN5s8GLdJRXHZ8MXOecC7Szu4hIt1AuEpFQoFwkIqFAuajntTvczMyyCE4UNZBg9e5e59xvjtnHgN8QnIm9Fvi0c26tt20x8B1v1x8657RkroiIiIiIiIhIiOlIkWgwMNg5t9bMkglOTHWZt0TfkX0uIbjq0iXAKcBvnHOnmFkGsBqYS7DAtIbgpE9l3XI0IiIiIiIiIiLSKe3OSeScO3CkV5A3C/xWYOgxuy0iuAqTc86tANK84tJFwHLnXKlXGFqOVmUSEREREREREQk5JzQnkTd7+iw+uMzkUCCvxeN8r62t9uPq37+/Gzly5ImEJiIhZs2aNYecc5l+x3EylItEej/lIhEJBcpFIhIq2stHHS4SmVlf4J/AV72VxrqUmS0BlgAMHz6c1atXd/VbiEgPMrO9fsdwskaOHKlcJNLLKReJSChQLhKRUNFePmp3uJn3IrEEC0SPOOf+1couBUBWi8fDvLa22j/AOXevc26uc25uZmavLrKLiIiIiIiIiPQ67RaJvJXL/gxsdc79uo3dngaut6AFQIVz7gD/XZo+3czSgQu9NhERERERERERCSEdGW52OnAdsNHM1ntt/wcMB3DO/RFYRnBlsxygFviMt63UzH4ArPKed4dzrrTLohcRERERERERkS7RkdXN3nLOmXNuunNupndb5pz7o1cgwlvV7Gbn3Bjn3DTn3OoWz3/AOTfWu/2lOw9GREKbmSWY2Xtmlm1mm83s+177g2a228zWe7eZXruZ2d1mlmNmG8xsdovXWmxmO73b4hbtc8xso/ecu73ekJhZhpkt9/Zf7vVuFJEIpFwkIqFAuUhEQlGH5iQSEeki9cB5zrkZwExgoTdEFeAbLQrR6722i4Fx3m0JcA8ET2yA24BTgPnAbS1Obu4BbmzxvIVe+63Ay865ccDL3mMRiUzKRSISCpSLRCTkqEgkIj3G63VY7T2M9W7uOE9ZBDzsPW8FkGZmg4GLgOXOuVLnXBmwnOCJ1WAgxTm3wjnngIeBy1q81kPe/YdatItIhFEuEpFQoFwkIqFIRSIR6VFmFu3Nb1ZE8IRmpbfpR17X6TvNLN5rGwrktXh6vtd2vPb8VtoBBnoT6gMUAgPbiG+Jma02s9XFxcWdOkYRCX3KRSISCpSLRCTUqEgkIj3KOdfsnJsJDAPmm9lU4FvARGAekAF8s5tjcLRxpc45d69zbq5zbm5mZmZ3hiEiPlIuEpFQoFwkIqFGRSIR8YVzrhx4FVjonDvgdZ2uB/5CcDw9QAGQ1eJpw7y247UPa6Ud4KDX7RrvZ1GXHpCI9ErKRSISCpSLRCRUxPgdQGeV1zbw3KZCzhjbn6yMJL/DEZEOMLNMoNE5V25micCHgJ+Z2WDn3AFvxY3LgE3eU54GbjGzpQQnY6zw9nsB+HGLSRkvBL7lnCs1s0pv0seVwPXAb1u81mLgp97Pp7r9gEXkuJxz1DUGONzYTG1DE3WNzTQ0ORqaAzQ2B2hsCtDQHKChKUBjs6OxOXB029XzhhMdZZ16X+UiEWnJOUd9U4DDDc0cbgze6hu9PNT8wTzU6D1uaA7wkWlDSE2K7dT7KheJSEvOBc+B6hoC1DY2cbihmfqm/+ai+iN5qOmDuensCZkMTUvskjh6bZGo8nAT3/rXRn76sWlcPX+43+GISMcMBh4ys2iCPRkfd849Y2aveCdKBqwHbvL2XwZcAuQAtcBnALyTnh8Aq7z97nDOlXr3vwg8CCQCz3k3CJ4EPW5mNwB7gSu76yBFIkVDU4CSmnqKq+opqW6gsq6RisONVNQ2/vf+4UYqDzdR0xA82altaKauMfjzcGNzp9/7Y7OGkRgX3dmnKxeJhJGm5gClNQ0UVdVTUtPQIvcEb0cf1zVSXd/M4YamYDGoofloYShwvOmij2PeyIxOF4lQLhIJK4GAo7S2geKqeg5V17/vPKhlHqo83EhVXdPR/HPk3OhwYzPNnUxG918/V0WiYemJJMVFs62wyu9QRKSDnHMbgFmttJ/Xxv4OuLmNbQ8AD7TSvhqY2kp7CXD+CYYsErGaA46DlXXsK60lr7SWvLLD5JfVUlQZLAoVV9dTWtPQ5vMTY6NJSYwhNTGWlIRY0pPiGJoWTWJcNImx0SR5PxPjYkiMjSIpLob42CjiY6KJizFio6OIi44iNsb7GR1FXEwUsdFGXHQU8TGdHzGvXCTSezjnKK6qJ6+slrzSw+wrrSW/rJbCI7moqp7Smvo2izxxMVGkJsZ6uSiYkwanJARzUYt8lPC+vBRNfEzLvBPVIifZ+3JSRp+4kzk25SKRXsI5R2lNA3llh73zomBOOlhZR1FVnVcYamizyBMbbcE85J0XJSfEMCA5Pph34qJJjI0hMS54PtQyH8XHHJOHjpwjxbTIS9FRpHW+WP0BvbZIFBVlTBiUzLbCSr9DERER6bWaA469JTXsOFjF9sLq4M+DVewtqaGx+b8nOlEGg1ISGJiawMj+ScwblU5m3wQyk+PJTI6nX9+4owWhlMQY4mM63ctHRCKQc478ssNHc9COwiq2H6xm96Fq6hoD79t3QHI8g1MTGJqWwMystKN5KLNvPP37xpGWdCQXxZIQq1wkIh3nnKOoqp5thUfyUBU7Dlaxq6iamob394Du1yeOwWkJZPaNZ/LgFAYktzgv6hNHWlLc0SJ1QmwUwRGkoa/XFokAJg5K5rlNhTjnes0vXERExE8l1fWs21fOurwy1u0rJzuv/OhJjxkMz0hi/MBkzp80gOEZSQzPSCIrPYkhaYnEnUTvHRGRlirrGlm/r/xoPlqfV055bePR7UPTEhk/sC+nj+nH8H7BPJSVkcSw9EQVfkSky9Q2NLEhvyKYi/aVsS6vnOKq+qPbM5PjmTAwmU/MzQqeE2UkkZWRSFZ6En3ie3U5pU29+qgmDkrh0ffyKKqqZ2BKgt/hiIiIhJy6xmbe213KWzmHeGNH8dFh2jFRxqTBKXx8zjCmDk1l4qBkxg7oS1Jcrz41EJEQ1dgcYN2+ct7aWcwbOw+xIb+cgAsWp8cPSGbhlEFMG5bKxEEpjBvYl5SErhs6ISJyRCDg2LS/gjd3HuLNncWs2Vt2tOf0qP59OGNsf2YMS2Xi4BTGD0w+qSGlvVWvPhOcOCgZgK0HKlUkEhER8VTVNfLKtiKWbTzAa9uLqW8KEBcdxZwR6XzjognMH5XB1CGpJzPxs4hIu+oam3ljRzHLNh7g5a1FVNU3EWUwIyuNW84dyymj+zF9WCrJKgiJSDdqag6wIreUZZsO8OLmQg5VB+dUnDQ4hc+ePopTRmcwMys9IgtCrenlRaIUALYXVnHOhAE+RyMiIuKfpuYAr+8o5rFVeby2o5iGpgADU+K5el4W504cwPxRGeolJCLdzjnHyt2lPLYqjxc3F1LT0ExaUiwLpw7i/EkDOHVMf1ITVRQSke63qaCCpav28eyGA5TVNpIUF815EwdwwaSBnD62P5nJ8X6HGJJ69dlialIsg1MTtMKZiIhErMKKOv6+ci+Pr86nsLKO/n3j+dQpI/jw9EHMykonKkpz9olI9yuvbeCxVXk8tiqP3EM1JCfE8NEZQ7hk2mBOHdOP2GjNaSYi3a+2oYkn1xXw6Hv72FRQSXxMFBdNGcSHpw/m7PGZmtOsA3p1kQjwVjhTkUhERCLLzoNV/OmNXJ5aX0BTwHH2+Exuv3QK508aoP+MiUiPKSg/zJ/f3M3SVfuobWhm3sh0bj53LJdMG6whrSLSY0prGnjonT08/O4eymobmTQ4hTsWTWHRjKGkduHy8JGg1xeJJg5K4e2cXBqbAzopFhGRsJdTVMUvXtjOC5sPkhAbxSfnD+dzZ44mKyPJ79BEJILsLz/MXS/t4F9rCwC4dMYQbjxrNJMGp/gcmYhEkvLaBv7w2i4efncPdY0BLpg0kM+fPZq5I9K1AnonhUGRKJnGZkducQ0TvImsRUREwk1hRR13vbSDx1fnkRQXw5fPG8vi00bSr6/G04tIz6mobeQPr+fw4Nt7cA4+tWAEN541mqFpiX6HJiIRpK6xmb+8vYc/vJZDdX0Tl80cyhfPGcO4gaoJnKzeXyQaHPwSbCusVJFIRETCTmNzgAfe2s1dL+2kKRDg06eN4uZzx6g4JCI9yjnHE2vy+fGyrZQfbuTyWUP52ofGMyxdvRhFpGe9vPUg33tqMwXlhzlv4gD+d+GEo4taycnr9UWi0f37EhttbCusYpHfwYiIiHShNXvL+PaTG9lWWMUFkwZw20enaFiZiPS4nKJqvv3kRlbuLmXOiHR+sGgqk4foP2Qi0rMKK+r4/n8289ymQsYO6MujNy7g1DH9/A4r7PT6IlFcTBRjMvuyXZNXi4hImGhoCnDnSzv44+u7GJSSwJ+um8NFUwb5HZaIRJhAwPHgO3v46fPbSIyN5icfm8ZVc7O0aqKI9Lins/fz7Sc30tAU4BsXTeDGM0cTF6M5ibtDry8SQXBeovd2l/odhoiIyEnbVVzNV5auY1NBJVfPy+I7H5lM3/iw+HMtIr1IUWUdX/9HNm/uPMT5Ewfw049PJzNZw1xFpGdV1TVy21Ob+de6AmYNT+POK2cysn8fv8MKa2Fx1jlhUAr/Xr+fisONpCZqeTsREemdnt1wgP/5RzbxsVH88VNzWDhVvYdEpOetyC3h5kfWUtPQxA8vm8q1pwzXKkEi0uN2HKzixodXk1day1fOH8eXzhtLjFY073ZhUSQ6Mnn19sIq5o/K8DkaERGRE9MccPzqxe384bVdzB6exh+uncOg1AS/wxKRCOOc4+F39/KDZ7YwvF8SS5cs0EpBIuKL5zcd4GuPZ9MnPobHPn8q80bq//k9pd0ikZk9AHwEKHLOTW1l+zeAa1u83iQg0zlXamZ7gCqgGWhyzs3tqsBbmjjoSJGoUkUiERHpVarrm/jS39fy6vZirpk/nNsvnUx8TLTfYYlIhGlsDvCdJzfx2Oo8zp84gDuvnklKgnroi0jPcs7xm5d3ctdLO5mZlcYfP6ULZz2tIz2JHgR+Bzzc2kbn3C+AXwCY2UeB/+ecazlB0LnOuUMnGedxDUpJIDUxlq2avFpERHqRQ9X1fPbBVWzeX8kPL5vKpxaM8DskEYlAtQ1N3PxIsFh9y7lj+dqHxmtyahHpcU3NAb7z700sXZXHFXOG8aPLp+rCmQ/aLRI5594ws5EdfL1rgEdPKqJOMDMmDkpm24HKnn5rERGRTskrreW6P6+ksLKOe6+bw/mTBvodkohEoLKaBj7z4Co25Jfz48un8clThvsdkohEoLrGZr706DqWbznIl84LFqs1F5o/umxOIjNLAhYCt7RodsCLZuaAPznn7u2q9zvWxEHJ/HNtAYGA05UPEREJabuKq7nm3hXUNwV45HMLmDMi3e+QRCQCFVfVc819K9hXWss9n5rDRVM0Wb6I9LzahiY+85dVvLenlO9fOoXFp430O6SI1pUTV38UePuYoWZnOOcKzGwAsNzMtjnn3mjtyWa2BFgCMHz4iV/BmDg4her6vRSUHyYrI6kT4YuIiHS/XK9AFHCOf9x0KuM1KayI+OBQdT2fvG8FBWWHeegz8zl1TD+/QxKRCHS4oZkbHlzNqj2l3HXVTBbNHOp3SBGvK9ePu5pjhpo55wq8n0XAk8D8tp7snLvXOTfXOTc3MzPzhN98gjd59TbNSyQiIiFqz6EarrlvBU0Bx99vXKACkYj4orSmgWvvW0leWS0PfHqeCkQi4ou6xmY+9/AqVu4u4ddXqkAUKrqkSGRmqcDZwFMt2vqYWfKR+8CFwKaueL/WTPBOtDUvkYiIhKIDFYf55H0raGgK8PcbT1GBSER8UVXXyKfuX8mekhr+vFgFIhHxR2NzgJv+toZ3dpXwy0/M4LJZKhCFinaHm5nZo8A5QH8zywduA2IBnHN/9Ha7HHjROVfT4qkDgSe9yaZigL87557vutDfr098DCP7JbFFRSIREQkxFYcb+fQDq6isa2LpkgVMHJTid0giEoEamoL/KdtxsIr7Fs/l9LH9/Q5JRCKQc45v/Wsjr20v5icfm8bHZg/zOyRpoSOrm13TgX0eBB48pi0XmNHZwDpjypBUNhZU9ORbioiIHFd9UzOf/+tqdhVX8+Bn5jN1aKrfIYlIBHLO8c1/buDtnBJ+ccV0zp0wwO+QRCRC3bl8B0+syecr54/jmvlaUTHUdOWcRL6bPCSFfaW1VNY1+h2KiIgIzjm+8Y8NrMgt5RefmM4Z43TVXkT88YsXtvPkugK+/qHxfGJult/hiEiEWvrePu5+JYer5mbx1QvG+R2OtCLsikQAW/ZryJmIiPjvD6/t4uns/XzjoglcPktdqUXEH0+tL+APr+3imvlZ3HLeWL/DEZEItWpPKd/59ybOHp/JDy+fijc1jYSYsCoSTVGRSEREQsSr24v45YvbuXTGEL54zhi/wxGRCLV5fwXf/OcG5o1M5/uX6j9lIuKPAxWH+cLf1pKVkcTd18wiNjqsShFhJaw+mQHJCWQmx7NZRSKRkGRmCWb2npllm9lmM/u+1z7KzFaaWY6ZPWZmcV57vPc4x9s+ssVrfctr325mF7VoX+i15ZjZrS3aW30Pke6w+1ANX350HZMGpfCzj0/Xf8pCjHKRRIrSmgaWPLyGtMQ4/nDtHOJiwurUv9dTLpJIUdfYzE1/XcPhhibuvW4OqYmxfockxxF2fymmDElh835NXi0SouqB85xzM4CZwEIzWwD8DLjTOTcWKANu8Pa/ASjz2u/09sPMJgNXA1OAhcAfzCzazKKB3wMXA5OBa7x9Oc57iHSp2oYmljy8mpgo40/XzSExLtrvkOSDlIsk7DUHHF96dC3F1fX86bo5ZCbH+x2SfJBykUSE7z21iez8Cn591UzGDUz2OxxpR9gViSYPTiGnqJr6pma/QxGRY7igau9hrHdzwHnAE177Q8Bl3v1F3mO87edbsEvGImCpc67eObcbyAHme7cc51yuc64BWAos8p7T1nuIdKnbntpMTnE1v71mNlkZSX6HI61QLpJI8IdXc3g7p4QfLJrCjKw0v8ORVigXSST497oCHl+dzy3njuWiKYP8Dkc6IOyKRFOGpNIUcOworG5/ZxHpcd6VrfVAEbAc2AWUO+eavF3ygaHe/aFAHoC3vQLo17L9mOe01d7vOO8h0mWeWl/AP9bkc/M5Y7WSWYhTLpJwtnpPKXe9vJNFM4dwpVYyC2nKRRLO9hyq4dtPbmTeyHStZNaLhGGRKDh5tYaciYQm51yzc24mMIzgFa6J/kb0fma2xMxWm9nq4uJiv8ORXmRvSQ3ffnITc0foRKg3UC6ScFVe28BXlq5nWHoiP7xME1WHOuUiCVcNTQG+9Og6YqKjuOvqWcRooupeI+w+qeEZSfSNj9Hk1SIhzjlXDrwKnAqkmVmMt2kYUODdLwCyALztqUBJy/ZjntNWe8lx3uPYuO51zs11zs3NzMw8mUOUCNLQFODLj64jyuCuq2fqRKgXUS6ScOKc49Z/bqSoqo7fXjOL5ARNDttbKBdJuPn589vYWFDBz6+YztC0RL/DkRMQdmexUVHG5MEpbDmgIpFIqDGzTDNL8+4nAh8CthI8KbrC220x8JR3/2nvMd72V5xzzmu/2lvlYxQwDngPWAWM81bsiCM4iePT3nPaeg+Rk/a7V3aSnV/Bzz4+nWHpmoco1CkXSbh6Yk0+z28u5BsXTWD6sDS/w5F2KBdJuHpn1yHuf2s3n1owXPMQ9UIx7e/S+0weksLjq/NoDjiio9TFViSEDAYe8lbbiAIed849Y2ZbgKVm9kNgHfBnb/8/A381sxyglODJDc65zWb2OLAFaAJuds41A5jZLcALQDTwgHNus/da32zjPUROyqaCCn7/2i4+NnsoF08b7Hc40jHKRRJ2DlQc5o7/bGH+qAw+d8Zov8ORjlEukrBTU9/E/z6xgZH9kvj2JZPbf4KEnLAtEtU2NLOnpIYxmX39DkdEPM65DcCsVtpzCY7DP7a9DvhEG6/1I+BHrbQvA5Z19D1ETkZ9UzNffzyb/n3juO0jU/wORzpIuUjCzZFhZk0Bxy+vmEGULpL2CspFEo5+8txWCsoP84/Pn0piXLTf4UgnhN1wM2g5ebWGnImISPf57cs5bD9YxU8+No3UJM39ISL+eHx1Hq/vKOZbl0xkeD8NeRURf7ydc4i/rdjHDaePYu7IDL/DkU4KyyLRuAHJxEabVjgTEZFusyG/nHte38UVc4Zx3sSBfocjIhGqoPwwP3hmKwtGZ/CpU0b4HY6IRKhqb5jZ6P59+J+LJvgdjpyEsBxuFhcTxfiByWwuUE8iERHpeo3NAf73iQ1k9o3nux/ReHsR8Ydzju88uZGAc/xCw8xExEe/eH4b+ysO88RNp5EQq2FmvVlY9iQCmDY0lY0FFQQn7xcREek6f3l7N9sKq/j+oimkJmqYmYj44/lNhby6vZivfWg8WRkaZiYi/tiQX87DK/ay+NSRzBmR7nc4cpLCtkg0fVgaFYcb2VtS63coIiISRvLLarlz+U4umDRQy7qKiG+q6hq5/T+bmTw4hU+fNtLvcEQkQjU1B/i/JzeS2Teer1843u9wpAuEcZEoFYANBZqXSEREus7tT28J/rxUw8xExD+/Xr6Doqp6fnT5VGKiw/aUXkRC3F9X7GVTQSW3fXQKyQnqXR0OwvYvyoRBycTHRLEhr9zvUEREJEy8sLmQl7Ye5KsXjGNYuoZ2iIg/NhVU8NA7e7j2lOHMGq6hHSLij8KKOn714g7OHp/JJdPUuzpchG2RKDY6islDUtiQr55EIiJy8mrqm7j96c1MHJTMZ88Y5Xc4IhKhmgOO/3tyIxl94vnGRRP9DkdEItgdz2ymsTnADxZNxUwT54eLsC0SAcwYlsam/RU0BzR5tYiInJy7X9nJgYo6fnT5VGI1tENEfPLoe/vYkF/Bdz8ySRPni4hv3thRzLKNhXz5/HEM76fe1eEkrM9ypw9LpbahmZyiar9DERGRXmz3oRoeeGs3V8wZxpwRGX6HIyIRqqK2kV+9uJ1TRmVw6YwhfocjIhGqsTnAHc9sYWS/JD53pnpXh5swLxKlAZCdX+5rHCIi0rv96NmtxEVH8b8XTfA7FBGJYHe9vIOKw41876OTNbRDRHzztxV7ySmq5jsfnkx8TLTf4UgXC+si0ej+fUiOj2GDikQiItJJb+4s5qWtB7nlvHEMSEnwOxwRiVA5RVX89d29XD1/OFOGpPodjohEqNKaBu5cvoMzx/Xn/EkD/A5HukG7RSIze8DMisxsUxvbzzGzCjNb792+12LbQjPbbmY5ZnZrVwbeEVFRxtShqZq8WkREOqWpOcAd/9nCiH5JfPaMkX6HIyIRyjnHHc9sJTEumq9/aLzf4YhIBLtz+Q5qGpr57kfUozFcdaQn0YPAwnb2edM5N9O73QFgZtHA74GLgcnANWY2+WSC7YzpWalsPVBJfVNzT7+1iIj0co+s3MfOomq+fckkdacWEd+8ur2IN3YU89ULxtOvb7zf4YhIhNpWWMkjK/dy3YIRjB+Y7Hc40k3aLRI5594ASjvx2vOBHOdcrnOuAVgKLOrE65yUGcPSaGx2bDtQ1dNvLSIivVhZTQO/Xr6DM8b250OTB/odjohEqIamAD94ZitjMvtw/akj/A5HRCKUc47vP72FlMRYvnrBOL/DkW7UVXMSnWpm2Wb2nJlN8dqGAnkt9sn32lplZkvMbLWZrS4uLu6isIIrnAGal0hERE7IXS/toKquUd2pRcRXD7+7h92HavjORyYTGx3W04mKSAh7cctB3s0t4esfGk9aUpzf4Ug36oq/NGuBEc65GcBvgX935kWcc/c65+Y65+ZmZmZ2QVhBQ9MS6d83nnV55V32miIiEt52H6rhkZX7+OQpw5kwSN2pRcQfFbWN/PaVHM4en8m5EzRBrIj4o7E5wM+e28a4AX25Zv5wv8ORbnbSRSLnXKVzrtq7vwyINbP+QAGQ1WLXYV5bjzIz5oxIY+3esp5+axER6aV+8cI24mOi+Mr5miBWRPzzh9dyqKxr5NaLJ/odiohEsMdW5ZF7qIZvLpxIjHo0hr2T/oTNbJB5/fDNbL73miXAKmCcmY0yszjgauDpk32/zpgzIp09JbUcqq734+1FRKQXWbuvjGUbC7nxrNFkJmuCWBHxR0H5Yf7yzh4+NmsYkwan+B2OiESomvom7nppJ/NHZmjJ+wgR094OZvYocA7Q38zygduAWADn3B+BK4AvmFkTcBi42jnngCYzuwV4AYgGHnDObe6Wo2jHnBHpAKzZW8ZFUwb5EYKIiPQCzjl+umwb/fvGc+OZo/0OR0Qi2K9e3A7A1y5Uj0YR8c99b+ZyqLqee6+fozkaI0S7RSLn3DXtbP8d8Ls2ti0DlnUutK4zZUgqcdFRrFWRSEREjuPlrUW8t6eUH1w2lT7x7f6JFBHpFlv2V/LkugKWnDmaoWmJfocjIhGquKqee9/I5eKpg5g9PN3vcKSHRMSAwoTYaKYOTWGN5iUSEZE2NDUH+Nnz2xjdvw9Xz8tq/wkiIt3kZ89vIyUhli+eM9bvUEQkgt398k4amgJ846IJfociPSgiikQQHHK2oaCC+qZmv0MREZEQ9MSafHYWVfO/CydomWkR8c07OYd4fUcxt5w7ltSkWL/DEZEIlVtczd/f28c184czOrOv3+FID4qYs+A5I9JpaAqweX+l36GIiEiIOdzQzJ0v7WD28DQNSxYR3wQCjp88t42haYlcd+oIv8MRkQj2ixe2kxATxZfPH+d3KNLDIqZINNubvHqthpyJiMgxHnh7Nwcr6/nWJZM0KaOI+OY/G/azsaCCr184noTYaL/DEZEItXZfGc9t0kqvkSpiikQDkhMYnpGkeYlEROR9Sqrruee1XVwwaSDzRmb4HY6IRKj6pmZ++eJ2Jg1O4bKZQ/0OR0QilFZ6lYgpEkFwyNnqvWU45/wORUREQsRvX8mhtqGJWy/WpIwi4p9HVuwjr/Qw37p4IlFR6tEoIv54yVvp9asXjNNKrxEq4opExVX17C2p9TsUkYhkZllm9qqZbTGzzWb2Fa/9djMrMLP13u2SFs/5lpnlmNl2M7uoRftCry3HzG5t0T7KzFZ67Y+ZWZzXHu89zvG2j+zBQ5cQta+klkdW7uWqeVmMHZDsdzjSQ5SLJNRU1jXy21d2csbY/pw1PtPvcKSHKBdJqGm50utVWuk1YkVUkWjB6H4ArNxd4nMkIhGrCfi6c24ysAC42cwme9vudM7N9G7LALxtVwNTgIXAH8ws2syigd8DFwOTgWtavM7PvNcaC5QBN3jtNwBlXvud3n4S4X7x4naio4yvXjDe71CkZykXSUj50+u7KKtt5NaLJ/odivQs5SIJKU+sySdHK71GvIj65Mdk9qF/33hW5Jb6HYpIRHLOHXDOrfXuVwFbgeNNvLAIWOqcq3fO7QZygPneLcc5l+ucawCWAossOOPwecAT3vMfAi5r8VoPefefAM43zVAc0Tbkl/Of7P187ozRDExJ8Dsc6UHKRRJKCivq+PNbu1k0cwhTh6b6HY70IOUiCSW1DU1a6VWACCsSmRkLRmfw7q4SzUsk4jOvW/MsYKXXdIuZbTCzB8ws3WsbCuS1eFq+19ZWez+g3DnXdEz7+17L217h7S8R6m8r9pKcEMPnz9akjJFMuUj89o/VedQ3BfifCzUvWiRTLhK/Ld9ykIOV9fzPRRO00muEi6giEQSHnBVW1mleIhEfmVlf4J/AV51zlcA9wBhgJnAA+JWPsS0xs9Vmtrq4uNivMKQHrM8rZ+6IdJITYv0ORXyiXCShYH1eOWMy+5KVkeR3KOIT5SIJBev2lZMYG818rfQa8SKySASwIlfzEon4wcxiCZ4IPeKc+xeAc+6gc67ZORcA7iPYbRqgAGg5a94wr62t9hIgzcxijml/32t521O9/d/HOXevc26uc25uZqYmDw1X1fVN7CyqZkZWmt+hiE+UiyQUOOfIzq9gxrA0v0MRnygXSajYkF/OtKGpxGguoogXcd+AMZl9yEyOV5FIxAfeWPc/A1udc79u0T64xW6XA5u8+08DV3srcIwCxgHvAauAcd6KHXEEJ3F82gXHkb4KXOE9fzHwVIvXWuzdvwJ4xWncacTaVFCBc6hIFKGUiyRU7K+o41B1PTOzNBdRJFIuklDR2Bxg0/5KZigXCRDT/i7hJTgvUT9W5JbinNN4S5GedTpwHbDRzNZ7bf9HcBWOmYAD9gCfB3DObTazx4EtBFcAudk51wxgZrcALwDRwAPOuc3e630TWGpmPwTWETz5wvv5VzPLAUoJnkBJhMrOKwfQ1fvIpVwkIeFILpquXBSplIskJGwvrKKhKaCLZwJEYJEIYMHoDP6TvZ89JbWM6t/H73BEIoZz7i2gtcrssuM850fAj1ppX9ba85xzufy3W3bL9jrgEycSr4Sv7PxysjISyegT53co4gPlIgkV2XnlxEVHMXFwst+hiA+UiyRUrNfFM2kh4oabwX/nJXo755DPkYiIiB+y8zQHiIj4b31eOZOGpBAfE+13KCISwbLzysnoE8ew9ES/Q5EQEJFFotH9+zA0LZE3dmiGfhGRSFNUVUdB+WFmqku1iPioOeDYWFDBzGGaA0RE/JWdX86MYamaikWACC0SmRlnjc/knV0lNDYH/A5HRER60Ia8CkCTVouIv3KKqqltaFYuEhFfacVXOVZEFokAzh6fSXV9E2v3lvkdioiI9KDs/HKio4wpQ1L8DkVEIlh2fjmggrWI+GtjvlZ8lfeL2CLRaWP7ERNlvK4hZyIiEWV9XjnjByaTFBeRazeISIjIzisnOT6GUf20iIqI+OdowVpzNYonYotEKQmxzB6eriKRiEgEcc6RnVfOzCzNASIi/srOL2d6VipRUZoDRET8k51XzvCMJK34KkdFbJEI4OwJmWzeX0lxVb3foYiISA/YU1JLZV2TrpaJiK/qGpvZdqBKuUhEfJedV66hZvI+EV0kOmtcJgBv7lRvIhGRSLBBc4CISAjYvL+SpoBTLhIRXxVV1bG/oo4ZWmVRWmi3SGRmD5hZkZltamP7tWa2wcw2mtk7ZjajxbY9Xvt6M1vdlYF3hSlDUujfN46XtxX5HYqIiPSA9XnlJMZGM25AX79DEZEIlp1XDsBMFYlExEdHVnxVLpKWOtKT6EFg4XG27wbOds5NA34A3HvM9nOdczOdc3M7F2L3iYoyLpg0kNe2FVHX2Ox3OCIi0s2y88qZOjSFmOiI7kgrIj7Lzi9nUEoCA1MS/A5FRCLYf1d8VU8i+a92z5Kdc28ApcfZ/o5z7sg68iuAYV0UW4+4aMogahqaeXdXid+hiIhIN2psDrBpf6XmABER323Ir2CGJtAXEZ8dWfE1MS7a71AkhHT1pdQbgOdaPHbAi2a2xsyWdPF7dYnTxvajb3wML2wu9DsUERHpRtsLq2hoCmgOEBHxVXltA7sP1TBdBWsR8ZFWfJW2dFmRyMzOJVgk+maL5jOcc7OBi4Gbzeys4zx/iZmtNrPVxcU9N5F0fEw050zIZPmWgzQHXI+9r4iI9Kz1mgNERELAhnzNASIi/tOKr9KWLikSmdl04H5gkXPu6Lgt51yB97MIeBKY39ZrOOfudc7Ndc7NzczM7IqwOuyiKYMoqWlg7b6y9ncWEZFeKTuvnIw+cQxLT/Q7FBGJYEcmrZ6m1YRExEdHcpF6WMuxTrpIZGbDgX8B1znndrRo72NmyUfuAxcCra6Q5rdzJmQSFx3F85s05ExEJFxl55czfVgqZuZ3KCISwbLzyxmd2YeUhFi/QxGRCKYVX6Ut7RaJzOxR4F1ggpnlm9kNZnaTmd3k7fI9oB/wh2OWuh8IvGVm2cB7wLPOuee74RhOWnJCLGeN78+zGw5oyJmISBiqrm9iZ1G1hneIiK+cc6zPq1AuEhHfZeeXM21oqlZ8lQ+IaW8H59w17Wz/HPC5VtpzgRmdD61nXTZrKC9tLWJlbgmnje3vdzgiItKFNuZX4Jy6VIuIv/ZX1HGoul5FIhHxVUNTgM37K1l86gi/Q5EQpLKh54JJA+kbH8OT6wr8DkVERLpYdn45gCZnFBFfHZ0DRLlIRHykFV/leFQk8iTERrNw6iCe31RIXWOz3+GIiEgXys4rZ3hGEhl94vwORUQiWHZeOXHRUUwcnOx3KCISwdbr4pkch4pELVw+ayhV9U28vLXI71BERKQLZeeV62qZiPhufV45k4akEB8T7XcoIhLBsvPK6acVX6UNKhK1sGB0PwamxPPEmjy/QxERkS5SVFnH/oo6Zmi5aRHxUXPAsbGggpnKRSLisyMXz7Tiq7RGRaIWoqOMK+dm8dqOYvJKa/0OR0REukB2fgWAJooVEV/lFFVT29DMzOFpfociIhGsqq6RnGKt+CptU5HoGFfPH44BS1ft8zsUERHpAtl55URHGVOG6Oq9iPhHk1aLSCjYWKAVX+X4VCQ6xtC0RM6bOIDHVuXR0BTwOxwRETlJ6/PKmTAwmcQ4zQEiIv5Zl1dOSkIMI/v18TsUEYlg648WrHXxTFqnIlErrl0wgkPVDbywudDvUERE5CQEAo7sfE1aLSL+OzIHSFSU5gAREf9k55Uzsl8SaUla8VVapyJRK84al8mIfknc/9ZunHN+hyMiIp20u6SGqromZqlIJCI+OtzQzPaDVRpqJiK+y86r0MUzOS4ViVoRHWUsOWs02XnlvJtb4nc4IiLSSUfnANHJkIj4aPP+CpoDTrlIRHxVWFFHYWWdCtZyXCoSteHjs4fRv28897y2y+9QRMKGmWWZ2atmtsXMNpvZV7z2DDNbbmY7vZ/pXruZ2d1mlmNmG8xsdovXWuztv9PMFrdon2NmG73n3G3e2p5tvYeEt+y8cpLiohk7oK/foUgIUS6SnqY5QKQ1ykXS07LzywFdPJPjU5GoDQmx0dxwxije3HmIjd7yySJy0pqArzvnJgMLgJvNbDJwK/Cyc24c8LL3GOBiYJx3WwLcA8ETG+A24BRgPnBbi5Obe4AbWzxvodfe1ntIGFufX8G0oalEaw4QeT/lIulR2fkVDElNYEBKgt+hSGhRLpIelZ1XTkyUMWVIit+hSAhTkeg4rl0wnNTEWH754na/QxEJC865A865td79KmArMBRYBDzk7fYQcJl3fxHwsAtaAaSZ2WDgImC5c67UOVcGLAcWettSnHMrXHBCsYePea3W3kPCVH1TM1v3VzJTV8vkGMpF0tOOTFot0pJykfS07PxyJg5OJiFWK75K21QkOo6UhFhuPncMr+8o5p2cQ36HIxJWzGwkMAtYCQx0zh3wNhUCA737Q4G8Fk/L99qO157fSjvHeQ8JU9sOVNHQHNB/zOS4lIuku5XWNLCvtFYFazku5SLpboGAY0NehXKRtEtFonZcf+pIhqQm8NPntxEIaKUzka5gZn2BfwJfdc5VttzmXenq1n9sx3sPM1tiZqvNbHVxcXF3hiHdTOPupT3KRdITlIukPcpF0hNyD9VQVd+kSaulXSoStSMhNpqvXTiBDfkVPLE2v/0niMhxmVkswROhR5xz//KaD3pdovF+FnntBUBWi6cP89qO1z6slfbjvcf7OOfudc7Ndc7NzczM7NxBSkhYn1dO/77xDEnVHCDyQcpF0lOy88qJMpg2VJNWywcpF0lPObLiq3oSSXtUJOqAj80aytwR6fx42VZKquv9Dkek1/JW1PgzsNU59+sWm54GjqzEsRh4qkX79d5qHguACq9r9AvAhWaW7k3MeCHwgret0swWeO91/TGv1dp7SJjKzitnZlYq3kIuIkcpF0lPys4rZ9yAZPrEx/gdioQY5SLpSdn55fSNj2F0plZ8leNTkagDoqKMH39sGtV1Tfxo2Va/wxHpzU4HrgPOM7P13u0S4KfAh8xsJ3CB9xhgGZAL5AD3AV8EcM6VAj8AVnm3O7w2vH3u956zC3jOa2/rPSQMVdY1squ4Rl2qpS3KRdIjnHNk51cwI0u9iKRVykXSY7LzyrXiq3SILml00PiByXzhnDH89pUcLpg0kEumDfY7JJFexzn3FtDWX6bzW9nfATe38VoPAA+00r4amNpKe0lr7yHhaUNeBaA5QKR1ykXSU/JKD1Na06BcJK1SLpKeUtfYzJYDldxwxmi/Q5FeQD2JTsCXzx/HjKw0bv3nBgrKD/sdjoiItOHIRLHTh+nqvYj4Z/2RSavVq1FEfLT1QCWNzY4ZOi+SDlCR6ATERkdx99UzCTj44iNrqWts9jskERFpxdq9ZYzO7ENaUpzfoYhIBFu7t4yE2CgmDkr2OxQRiWBr95UDMHtEur+BSK+gItEJGtGvD7++cgYb8sv5+uPZBALduiKliIicIOcc6/LKmZWlEyER8de6fWVMH5ZGTLROuUXEP2v3lTEkNYGBKVrxVdqnv1idcOGUQfzfxZN4duMBfrxsK8HhwSIiEgr2ltRSWtPA7BFpfociIhGsrrGZzfsrmT1cBWsR8de6vWXMUi8i6aAOFYnM7AEzKzKzTW1sNzO728xyzGyDmc1usW2xme30botbe35v9LkzR/Hp00Zy/1u7+clz21QoEhEJEWv3lQHoP2Yi4quNBRU0BRyzh6f5HYqIRLDCijr2V9TpvEg6rKOrmz0I/A54uI3tFwPjvNspwD3AKWaWAdwGzAUcsMbMnnbOlZ1M0KHAzLjto5MJOMe9b+RSXd/E9y+dQqy6E4uI+GrtvjL6xscwfqDmABER/6w7UrDW1XsR8dHRXKSCtXRQh4pEzrk3zGzkcXZZBDzsLcu4wszSzGwwcA6w3DlXCmBmy4GFwKMnFXWIMDO+f+kU+sTHcM9ru9hXUsvvPzmb1KRYv0MTEYlYa/eWMyMrleiotlYVFhHpfmv3ljM8I4n+feP9DkVEItjafWXExUQxZYhWNpOO6apuL0OBvBaP8722ttrDhpnxzYUT+fkV01m5u4RL7n6TVXtK/Q5LRCQi1dQ3sa1Qc4CIiL+cc6zdV6Yr9yLiu7X7ypk2NJW4GI14kY4JmW+KmS0xs9Vmtrq4uNjvcE7YlXOzeOzzpxIdZVz1p3f5+fPbONzQ7HdYIiIRJTu/nIDTfEQi4q+C8sMUVdVrqJmI+KqhKcDGggoVrOWEdFWRqADIavF4mNfWVvsHOOfudc7Ndc7NzczM7KKwetbs4ek8++Uz+PjsYfzhtV186M7XeWnLQU1qLSLSQ9btKwdglk6GRMRHa71cpIK1iPhp8/4KGpoCykVyQrqqSPQ0cL23ytkCoMI5dwB4AbjQzNLNLB240GsLW8kJsfziEzN49MYFJMZG87mHV3PNfStYs1dD0EREutvavWWMzuxDWlKc36GISARbu7eMxNhoJg7SBPoi4p+jBWv1apQT0KGJq83sUYKTUPc3s3yCK5bFAjjn/ggsAy4BcoBa4DPetlIz+wGwynupO45MYh3uTh3Tj2VfOZNHVuzld6/m8PF73uW8iQP4yvnjmJGV5nd4IiJhxznHurxyzps4wO9QRCTCrdtXxvRhqcRo1VsR8dHafWUMTUtkYEqC36FIL9LR1c2uaWe7A25uY9sDwAMnHlrvFxsdxadPH8WV87J48J09/On1XBb9/m1OG9OPL5wzhjPG9sdMq++IiHSFvSW1lNY0qEu1iPiqrrGZzfsrufGs0X6HIiIRbt3eMmapF5GcIF3e6AFJcTF88ZyxvH3reXz7kknsKq7muj+/x0d++xb/yd5Pc0BzFomInKy1+8oAmD0izd9ARCSibSyooCngVLAWEV8VVtSxv6JOuUhOmIpEPahvfAw3njWaN/73XH728WkcbmjmS4+u47xfvcbS9/bR0BTwO0QRkV5r7b4y+sbHMG6A5gAREf+s3RssWGsCfRHx09GLZ8pFcoJUJPJBfEw0V80bzvKvnc0fPzWblIRYbv3XRs795Wv89d091DU2+x2iiEivs3ZvOTOz0oiO0jBeEfHP2n1ljOiXRP++8X6HIiIRbO3eMuJiopgyJNXvUKSXUZHIR9FRxsKpg3n6ltN58DPzGJSawHef2sxZP3+V+9/MVbFIRKSDauqb2FZYqatlIuIr5xxr95VreIeI+G7tvjKmDU0lLkb/5ZcTo29MCDAzzpkwgCduOpW/33gKYzL78sNnt3LeL1/jn2vyCWjOIhGR48rOLyfg0OSMIuKr/LLDFFfVq2AtIr6qb2pm035dPJPOUZEohJgZp43pz6NLFrB0yQL6J8fz9X9k89HfvcU7OYf8Dk9EJGSt3lOGGbp6LyK+Wr23FIC5IzN8jkREItnG/AoamgLKRdIpKhKFqAWj+/HvL57Ob66eSXltI5+8fyVfXbqOQ9X1focmIhJyVu0pZcLAZFITY/0ORUQi2Hu7y0hOiGH8QE2gLyL+eW+PV7BWD2vpBBWJQlhUlLFo5lBe/vrZfPn8cTy78QAX/Pp1/rE6D+c0BE1EBKCpOcDavWXMH6WrZSLir1V7Spk7Il0T6IuIr1bvKWNMZh/6aQJ96QQViXqBhNhovvah8Sz78pmMzezLN57YwI0Pr6G0psHv0EREfLf1QBU1Dc3qUi0iviqtaSCnqFq5SER8FQg4Vu8pZZ5ykXSSikS9yLiByTz++VP57kcm88aOYhbe9QZva64iEYlwR7pUz9fJkIj4aPWRXKRejSLiox1FVVTWNalIJJ2mIlEvExVl3HDGKJ68+TSSE2L41J9X8rtXdmr4mYhErFW7S8nKSGRQaoLfoYhIBFu1p5S4mCimD0v1OxQRiWCrdqtgLSdHRaJeasqQVJ750plcOmMIv3xxB7f8fR21DU1+hyUi0qOcc6zeW8q8EToREhF/rdpTxoxhqcTHRPsdiohEsPf2lDEwJZ5h6Yl+hyK9lIpEvVhiXDR3XTWTb108kWWbDnDFPe9SVFnnd1giIj1m96EaDlU3ME9Xy0TER7UNTWwqqNDwDhHxlXOOVbuD8xGZaQJ96RwViXo5M+PzZ4/hgcXz2FNSw8f/+A57DtX4HZaISI9YvacMgHkjtcSriPhnfV45TQGnIpGI+Cq/7DCFlXXKRXJSVCQKE+dOHMCjNy6guq6JK/74Lpv3V/gdksgHmNkDZlZkZptatN1uZgVmtt67XdJi27fMLMfMtpvZRS3aF3ptOWZ2a4v2UWa20mt/zMzivPZ473GOt31kDx2ydLP39pSSnhTLmMy+focivYhykXS1VbvLMIPZI1Swlo5TLpKutnpvcD4iFYnkZKhIFEZmZKXxj5tOIy7auObeFSoUSSh6EFjYSvudzrmZ3m0ZgJlNBq4GpnjP+YOZRZtZNPB74GJgMnCNty/Az7zXGguUATd47TcAZV77nd5+EgZW7SllrrpUy4l7EOUi6UKr9pQyYWAyqYmxfocivcuDKBdJF3pvdxnJ8TFMGJTsdyjSi6lIFGbGDujL4zedSnJCLJ+6fyXbC6v8DknkKOfcG0BpB3dfBCx1ztU753YDOcB875bjnMt1zjUAS4FFFqwSnAc84T3/IeCyFq/1kHf/CeB8U1Wh1yuqrGNvSS3zdbVMTpBykXSlpuYAa/eVaSUhOWHKRdLVVu8pZc7IdKKj9HFK56lIFIaGpSfxyOdOITY6imvvX8mu4mq/QxJpzy1mtsHrdn2kr/5QIK/FPvleW1vt/YBy51zTMe3vey1ve4W3v/Riq47MR6T/mEnXUS6SE7blQCW1Dc0a3iFdSblITlhZTQM7i6qVi+SkqUgUpkb278Pfb1wAOBY/8B7FVfV+hyTSlnuAMcBM4ADwKz+DMbMlZrbazFYXFxf7GYq0Y9WeUhJjo5kyJMXvUCQ8KBdJp7y3W3OASJdSLpJOWbVHuUi6hopEYWzsgL78efE8DlXX87mHVnG4odnvkEQ+wDl30DnX7JwLAPcR7DYNUABktdh1mNfWVnsJkGZmMce0v++1vO2p3v6txXOvc26uc25uZmbmyR6edKN3d5Uwd2Q6sdH6UyYnT7lIOmtFbgkj+yUxKDXB71AkDCgXSWe9m1tCfEwUM7JS/Q5FejmdWYe5GVlp3H31LDYUVPCVpetoDji/QxJ5HzMb3OLh5cCRFT6eBq72VuAYBYwD3gNWAeO8FTviCE7i+LRzzgGvAld4z18MPNXitRZ7968AXvH2l16qpLqe7QerWDBaveOlaygXSWc0Bxwrd5dy6hjlIukaykXSWUcunsXHRPsdivRyMe3vIr3dhVMG8d0PT+aOZ7bwm5d28LULJ/gdkkQoM3sUOAfob2b5wG3AOWY2E3DAHuDzAM65zWb2OLAFaAJuds41e69zC/ACEA084Jzb7L3FN4GlZvZDYB3wZ6/9z8BfzSyH4ASRV3fvkUp3W5Eb7FKt/5hJZygXSVfZvL+CqromFaylU5SLpKuU1jSwrbCK/7lwvN+hSBhQkShCfOb0kWwrrOTuV3KYkZXG+ZMG+h2SRCDn3DWtNP+5lbYj+/8I+FEr7cuAZa205/Lfbtkt2+uAT5xQsBLS3s09RJ+4aKYNVZdqOXHKRdJV3t0VHKFzqopE0gnKRdJVVuZ6uUgXz6QLaLhZhDAz7lg0lalDU/jqY+vZc6jG75BERDrt3V0lzBuVofmIRMRX7+aWMDqzDwNSNB+RiPjn3dwSkuKimT4sze9QJAx06OzazBaa2XYzyzGzW1vZfqeZrfduO8ysvMW25hbbnu7C2OUEJcRGc8+1c4iOMr7wyFrqGjWRtYj0PkWVdewqrtGVexHxVWNzgFW7S5WLRMR3wfmIdPFMuka73yIziwZ+D1wMTAauMbPJLfdxzv0/59xM59xM4LfAv1psPnxkm3Pu0q4LXTojKyOJX185g60HKvnlC9v9DkdE5IS9qy7VIhICNhZUUNPQrFwkIr4qrqpnZ1G1CtbSZTpSapwP5Djncp1zDcBSYNFx9r8GeLQrgpPucd7EgVy3YAT3v7Wbt3Ye8jscEZETsiK3hOSEGKYM0XxEIuKfI/MRadJqEfHTCl08ky7WkSLRUCCvxeN8r+0DzGwEMAp4pUVzgpmtNrMVZnZZW29iZku8/VYXFxd3ICw5Gf93ySTGZPbh6/9YT1lNg9/hiIh02IrcUk4ZlUF0lPkdiohEsBW5JYwf2Jf+feP9DkVEItiK3BL6xscwdUiK36FImOjqQYtXA08cWY7RM8I5Nxf4JHCXmY1p7YnOuXudc3Odc3MzMzO7OCw5VmJcNL+5ehalNQ3c9vTm9p8gIhICCivq2H2oRlfuRcRXDU0BVu8p0/AOEfHdu7klzB+VQYzmI5Iu0pFvUgGQ1eLxMK+tNVdzzFAz51yB9zMXeA2YdcJRSreYOjSVm88dy9PZ+3l1W5Hf4YiItOvd3OAQWRWJRMRPG/LLOdyo+YhExF8HK+vILa5hwegMv0ORMNKRItEqYJyZjTKzOIKFoA+sUmZmE4F04N0WbelmFu/d7w+cDmzpisCla3zhnDGMG9CXbz+5ker6Jr/DERE5rrdzSkhLimXyYHWpFhH/vJ1TghmcMkpFIhHxzzu7ghfPThvT3+dIJJy0WyRyzjUBtwAvAFuBx51zm83sDjNruVrZ1cBS55xr0TYJWG1m2cCrwE+dcyoShZD4mGh++vHpHKis02pnIhLSnHO8tfMQp4/tT5TmIxIRH72VU8y0oamk94nzOxQRiWBv7jxERp84XTyTLhXTkZ2cc8uAZce0fe+Yx7e38rx3gGknEZ/0gDkj0ll86kgeencPi2YOYdbwdL9DEhH5gJyiagor6zhzrK6WiYh/quoaWbuvnJvOHu13KCISwZxzvKmLZ9INNLuVAPA/F01gQHI8tz+9mUDAtf8EEZEe9sbOYJfqM8apSCQi/nl3VwnNAceZ47TQioj4Z1thFcVV9Zyp8yLpYioSCQB942O49eKJZOdX8MTafL/DERH5gDd3FjM6sw/D0pP8DkVEItibOw+RFBfNbPW8FhEfvbmzGEBFIulyKhLJUZfNHMrs4Wn8/PltVNY1+h2OiMhR9U3NrMgt4SxduRcRn725s5hTR/cjLkan0SLinzd3HmLcgL4MTk30OxQJM/rrJkeZGd+/dColNQ3c/dJOv8MRETlqzZ4y6hoDulomIr7aV1LLnpJa5SIR8VVdYzMrd5dq2Kt0CxWJ5H2mDUvlqrlZPPjOHnYfqvE7HBERIDgfUWy0sWC0lpsWEf+8meMN7xiv/5iJiH/e211KQ1OAM8erYC1dT0Ui+YCvXTie2Ogofvnidr9DEREBgsM7Zg9Pp098hxblFBHpFm/uOMTQtERG9+/jdygiEsHe3FlMXHQUp4zK8DsUCUMqEskHDEhO4MYzR/HshgNsyC/3OxwRiXCHquvZvL+Ss3TlXkR81NQc4O1dhzhzXH/MtNy0iPjnzZ2HmDsynaQ4XTyTrqcikbTqxrNGk9Enjp89v83vUEQkwr2dcwjQ6h0i4q/s/Aqq6po0B4iI+Kqoso5thVXKRdJtVCSSViUnxHLLuWN5O6fk6PKKIiJ+eGVbEf36xDFlSKrfoYhIBHt1WxHRUcbpYzU3moj459XtRQCcrR7W0k1UJJI2XbtgOMPSE/npc9twzvkdjohEoKbmAK/vKOacCQOIjtLwDhHxzyvbipgzIp20pDi/QxGRCPbKtiIGpyYwaXCy36FImFKRSNoUHxPNVy8Yz+b9lSzfctDvcEQkAq3LK6e8tpHzJw3wOxQRiWAHKg6z5UAl509ULhIR/9Q3NfPmzkOcN3GA5kaTbqMikRzXZTOHMKJfEne/slO9iUSkx728tYiYKNN8RCLiq1e2BYd3qGAtIn5amVtKbUOzcpF0KxWJ5LhioqO4+dyxbCqoPHqCJCLSU17ZdpBTRmeQnBDrdygiEsFe2VrE8IwkxmT29TsUEYlgr2wrIiE2itPG6OKZdB8ViaRdl88aSlZGIr95Wb2JRKTn5JXWsuNgNedO0NUyEfHP4YZm3srR8A4R8Zdzjpe3HeT0Mf1JiI32OxwJYyoSSbtio6O4+ZyxbMiv4LUdWulMRHrGf4d3DPQ5EhGJZO/mHqK+KcB5mo9IRHy0q7iavNLDnKehZtLNVCSSDvnY7GEMTUvkNy+pN5GI9IyXtxUxun8fRvXv43coIhLBXt5aRFJcNKeMzvA7FBGJYC9vDV48U8FaupuKRNIhcTFR3HTOGNbnlbNyd6nf4YhImKupb2JFbolOhETEV845Xt1WxJnj+hMfo+EdIuKfl7cVMXlwCoNTE/0ORcKcikTSYZ+YM4x+feK4941cv0ORXsrMHjCzIjPb1KItw8yWm9lO72e6125mdreZ5ZjZBjOb3eI5i739d5rZ4hbtc8xso/ecu82bPKKt95DQ9caOYhqaAupSLd1CuUg6avP+SvZX1HH+RA17la6nXCQdVVrTwOo9pVrVTHqEikTSYQmx0Sw+bSSvbCtie2GV3+FI7/QgsPCYtluBl51z44CXvccAFwPjvNsS4B4IntgAtwGnAPOB21qc3NwD3NjieQvbeQ8JUc9tKiSjTxzzR2p4h3SLB1Eukg54btMBoqOMCyarSCTd4kGUi6QDlm8pJOBg4dRBfociEUBFIjkh1y0YQWJstHoTSac4594Ajh2vuAh4yLv/EHBZi/aHXdAKIM3MBgMXAcudc6XOuTJgObDQ25binFvhghNnPXzMa7X2HhKC6puaeWVbERdOHkhMtP5MSddTLpKOen5TIaeMyiCjT5zfoUgYUi6SjnpuUyFZGYlMHpzidygSAXT2LSckvU8cV83L4unsAg5UHPY7HAkPA51zB7z7hcCRy7VDgbwW++V7bcdrz2+l/XjvISHo7ZxDVNc3cZGulknPUi6S99l5sIpdxTVcrFwkPUu5SN6nsq6Rt3MOcfHUwXgjBkW6lYpEcsJuOGMUAQd/eXuP36FImPGudHXr8nntvYeZLTGz1Wa2uri4uDtDkTY8t7GQ5IQYTh/T3+9QJEIpFwkEr9wDXDhFRSLxh3KRALyytYjGZsdFykXSQ1QkkhOWlZHEJdMG8/eV+6isa/Q7HOn9DnpdovF+FnntBUBWi/2GeW3Hax/WSvvx3uMDnHP3OufmOufmZmZmdvqgpHMamwMs33qQCyYNJC5Gf6KkRykXyfs8v6mQOSPSGZiS4HcoElmUi+R9ntt0gIEp8czKSvM7FIkQHToDN7OFZrbdmxn/AxObmdmnzazYzNZ7t8+12NbqbPvSuy05czTV9U08sTq//Z1Fju9p4EhuWAw81aL9em81jwVAhdc1+gXgQjNL9yZmvBB4wdtWaWYLvNU7rj/mtVp7DwkxK3NLKa9t1NUy8YNykRy1r6SWLQcqWahcJD1PuUiOqm1o4vUdxVw0ZRBRURpqJj0jpr0dzCwa+D3wIYJjWVeZ2dPOuS3H7PqYc+6WY557ZLb9uQS7Ma7xnlvWJdGLb6YNS2XOiHQeencPnz5tpJKWdIiZPQqcA/Q3s3yC+eGnwONmdgOwF7jS230ZcAmQA9QCnwFwzpWa2Q+AVd5+dzjnjkz6+EWCK4UkAs95N47zHhJint98gMTYaM4er6uV0n2Ui6Q9z28OTteilYSkOykXSXte315MXWNAuUh6VLtFIoJLKeY453IBzGwpwRnxjy0StebobPvec5cTXHrx0c6FK6Hk06eN5EuPruO1HUWcN1Hz3Un7nHPXtLHp/Fb2dcDNbbzOA8ADrbSvBqa20l7S2ntIaGlqDvD8poOcMyGTxLhov8ORMKZcJO15dmMhU4emkJWR5HcoEsaUi6Q9z248QEafOOaPzPA7FIkgHRlu1taM+cf6uJltMLMnzOzIuNiOPld6oYVTBzEwJV4TWItIl3g3t4RD1fUsmjnE71BEJILtPlRDdl45l85QLhIR/1TXN/HS1oN8eNpgYqI1T6P0nK76tv0HGOmcmw4sBx460RfQzPm9T2x0FNctGMGbOw+RU1Tldzgi0sv9e91+kuNjOGfCAL9DEZEI9vT6/ZjBR1UkEhEfvbi5kLrGgC6eSY/rSJGorRnzj3LOlTjn6r2H9wNzOvrcFq+hmfN7oWvmDycuJoqH3tnrdygi0ovVNTbzwuZCFk4dREKshpqJiD+cczyVXcApozIYnJrodzgiEsGeWr+foWmJzB6e7ncoEmE6UiRaBYwzs1FmFgdcTXBG/KOOLKHouRTY6t1vdbb9kw9bQkW/vvFcOmMI/1ybT2Vdo9/hiEgv9cq2Iqrrm7hslkYki4h/Nu+vJLe4hkUzlYtExD+Hqut5K+cQi2YO0QJB0uPaLRI555qAWwgWd7YCjzvnNpvZHWZ2qbfbl81ss5llA18GPu09txQ4Mtv+Kt4/276EiU+fNpLahmYeX5XX/s4iIq14an0BmcnxLBjdz+9QRCSC/XtdAbHRxsVaSUhEfPTshgM0B5wK1uKLjqxuhnNuGcFlF1u2fa/F/W8B32rjua3Oti/hY+rQVOaOSOeRlfu44YxRmKnaLSIdV3G4kVe3FfOpBSOI1tUyEfFJc8Dxnw37OWfCANKS4vwOR0Qi2FPrC5g4KJkJg5L9DkUikKZJly5x7YLh7D5Uw7u7SvwORUR6mec2HqChWRMzioi/VuSWcLBSKyyKiL/2ltSwdl85lyoXiU9UJJIucfHUwaQlxfLIyn1+hyIivcxjq/MYN6Av04el+h2KiESwx1blkZoYywWTBvodiohEsMdX5xFl8LFZw/wORSKUikTSJRJio/n47GG8sLmQ4qr69p8gIgLsPFjFun3lXDUvS0NVRcQ3FbWNPL+5kMtmDtEKiyLim6bmAE+syefs8ZkMSk3wOxyJUCoSSZf55CnDaQo4Hl+tCaxFpGMeW5VHbLRxuVY1ExEf/Xt9AQ1NAa6cl+V3KCISwd7YWczBynquUi4SH6lIJF1mTGZfFozO4NH39hEIOL/DEZEQ19AU4F/rCrhg0kD69Y33OxwRiWCPrcpj6tAUpgzRsFcR8c9jq/Lo1yeO8yZq2Kv4R0Ui6VLXnjKC/LLDvLGz2O9QRCTEvbz1IKU1DbpyLyK+2lRQwZYDlVw1V7lIRPxTXFXPy1uL+NjsocTF6L/p4h99+6RLXTRlEP36xPF3TWAtIu14bHUeg1MTOGtcpt+hiEgEe2xVHvExUVw6U8NeRcQ/T67LpyngNNRMfKcikXSpuJgorpg7jJe3FVFYUed3OCISovaV1PL6jmI+MWcY0VGasFpE/FFd38ST6wq4ZNpgUhNj/Q5HRCJUIOD4+8p9zBmRztgByX6HIxFORSLpcp+cP5zmgOOxVZrAWkRa99cVe4g245OnjPA7FBGJYE+uzae6vonrT1UuEhH/vL6zmD0ltcpFEhJUJJIuN6JfH84c15+lq/bRrAmsReQYtQ1NPLYqj4umDtLyriLiG+ccD727lxnDUpk1PN3vcEQkgj30zh4yk+O5eOpgv0MRUZFIusdV87I4UFHHm5rAWkSO8e91+6msa+LTp430OxQRiWBv55SQU1TNYuUiEfHR7kM1vLa9mGtPGa4JqyUk6Fso3eJDkweSnhTL46s15ExE/ss5x0Pv7GHy4BTmjtCVexHxz4Pv7KF/3zg+PF1X7kXEPw+/u4fYaOOTpwz3OxQRQEUi6SbxMdFcNmsoy7cEl7gWEQF4N7eE7Qer+PRpIzHThNUi4o99JbW8vO0g18wfTnxMtN/hiEiEqq5v4onV+VwybTADkjUEX0KDikTSba6al0Vjs+PJdQV+hyIiIeJPr+fSv28cl84c4ncoIhLB7nszl9ioKD61QJPEioh//r5yL1X1TXz29FF+hyJylIpE0m0mDkphxrBUHl+Vh3OawFok0m3eX8HrO4r5zOmjSIjVlXsR8UdxVT2Pr87jY7OHMjBFV+5FxB/1Tc3c/+ZuTh/bjxlZaX6HI3KUikTSra6cl8X2g1Vk51f4HYqI+OyPr+fSNz5GV+5FxFcPvrObhuYAS84a7XcoIhLBnlxbQFFVPV84e6zfoYi8j4pE0q0+OmMICbFRPLZKE1iLRLJ9JbU8u2E/154ynNTEWL/DEZEIVVXXyMPv7uXiqYMYndnX73BEJEI1Bxz3vpHLtKGpnD62n9/hiLyPikTSrVISYrlk2mD+k72f2oYmv8MREZ/86Y1dxERF8dkzNOZeRPzzyMp9VNU1cdPZY/wORUQi2AubC8k9VMNNZ4/RQh4SclQkkm531dwsquubWLax0O9QRMQHeaW1PL46jyvmDtP8HyLim+r6Ju59I5czx/Vn+rA0v8MRkQjVHHDc9dIORmf2YeHUQX6HI/IBKhJJt5s/KoNR/fvwuIaciUSk376yEzPjS+dpzL2I+Ocvb+2mtKaBr184we9QRCSCPbNhPzsOVvP/LhhPdJR6EUnoUZFIup2Z8Ym5w3hvTym5xdV+hyMiPSi3uJp/ri3g2lOGMzg10e9wRCRCVdQ2cu+buVwwaSAztYqQiPiksTnAnct3MGlwCh+eNtjvcERapSKR9IgrZg8jOsr4x5p8v0MRkR5050s7iYuO4ovnqBeRiPjn3jd3UVXXxNcvHO93KCISwf65Jp89JbV8/UPjiVIvIglRKhJJjxiQksC5EzL555p8mpoDfocjIcjM9pjZRjNbb2arvbYMM1tuZju9n+leu5nZ3WaWY2YbzGx2i9dZ7O2/08wWt2if471+jvdc/WXuZpsKKnhmw34+c/pIMpPj/Q5HpEOUi8JPUWUdf3l7Dx+ZPphJg1P8DkekQ5SLws/hhmbufnknM7LSOH/SAL/DEWlTh4pEZrbQzLZ7SeTWVrZ/zcy2eEnpZTMb0WJbs5fc1pvZ010ZvPQuV87Noqiqnte2F/sdioSuc51zM51zc73HtwIvO+fGAS97jwEuBsZ5tyXAPRA8eQJuA04B5gO3HTmB8va5scXzFnb/4UQu5xx3PLOF9KQ4Pq9VhKT3US4KIz9/YTuNzQH+R3MRSe+jXBRG7n0jl/0VdXzr4ola0UxCWrtFIjOLBn5PMPlMBq4xs8nH7LYOmOucmw48Afy8xbbDXnKb6Zy7tIvill7o3IkDyEyO59H39vkdivQei4CHvPsPAZe1aH/YBa0A0sxsMHARsNw5V+qcKwOWAwu9bSnOuRXOOQc83OK1pBs8t6mQ93aX8rUPjSc1MdbvcEROlnJRL7Uhv5wn1uTz2TNGMbJ/H7/DETlZykW91IGKw/zx9V18eNpgFozu53c4IsfVkZ5E84Ec51yuc64BWEowER3lnHvVOVfrPVwBDOvaMCUcxEZHcfW8LF7ZXkReaW37T5BI44AXzWyNmS3x2gY65w549wuBgd79oUDL5fLyvbbjtee30v4BZrbEzFab2eriYvV664y6xmZ+vGwrEwclc/W8LL/DETlRykVhwjnHHf/ZQv++8dxyruZFk15HuSiM/Oy5bTQ7x60XT/Q7FJF2daRI1FZyacsNwHMtHid4iWWFmV124iFKOPnkKcOJMuOvK/b6HYqEnjOcc7MJ9lq82czOarnRu9LlujsI59y9zrm5zrm5mZmZ3f12Yem+N3LJLzvM9z4ymZhoTX0nvY5yUZh4Ons/q/eW8Y2LxpOcoB6N0usoF4WJNXtL+ff6/Sw5czRZGUl+hyPSri49ezezTwFzgV+0aB7hjaP9JHCXmbU6OYWq1JFhcGoiH542mPvfzOXf6wr8DkdCiHOuwPtZBDxJsBfjQa9LNN7PIm/3AqBlF5VhXtvx2oe10i5dLLe4mt++msMl0wZx2tj+focjcsKUi8JDWU0Dd/xnCzOGpXLFHPVolN5HuSg8NDQFuPWfGxmSmsAXztEcjdI7dKRI1FZyeR8zuwD4NnCpc67+SHuLBJcLvAbMau1NVKWOHD/9+DROGdWP//f4ep5Yk9/+EyTsmVkfM0s+ch+4ENgEPA0cWYljMfCUd/9p4HpvNY8FQIXX/foF4EIzS/cmZrwQeMHbVmlmC7zVO65v8VrSRQIBx7f+tZGEmChuv3SK3+GInDDlovDxo2VbqTjcyE8+Np1oLTMtvYxyUfi457Vd7Cyq5oeXT6VPfIzf4Yh0SEe+qauAcWY2imBx6GqCvYKOMrNZwJ+AhV61+0h7OlDrnKs3s/7A6bx/UmuJQElxMTzw6Xnc+PBqvvFENoGA40rNWxLpBgJPeis9xAB/d849b2argMfN7AZgL3Clt/8y4BIgB6gFPgPgnCs1sx8QzFsAdzjnSr37XwQeBBIJDoltOSxWusBjq/NYubuUn318GgOSE/wOR6QzlIvCwFs7D/HEmnxuPncMk4doyXvplZSLwkBOURW/fzWHS2cM4byJA9t/gkiIaLdI5JxrMrNbCFaio4EHnHObzewOYLVz7mmCw8v6Av/wktk+byWzScCfzCxAsNfST51zW7rpWKQXSYyL5v7Fc7nx4dX87z830BRwfPKU4X6HJT7xehrOaKW9BDi/lXYH3NzGaz0APNBK+2pg6kkHK63aX36YHy/byqmj+3HlXBV9pXdSLur9quoa+daTGxjdvw9fOm+c3+GIdIpyUe/X1BzgG09sICk+mu999NiFwUVCW4f6vDnnlhGsULds+16L+xe08bx3gGknE6CEr4TYaO67fi5f+Nsa/u/JjTQ7x3ULRvgdloicoOaA46uPrScQcPz049PwLhaIiPS4257aTEHZYR7//KkkxEb7HY6IRKi7X8lh3b5y7r5mFv37xvsdjsgJ0bIz4quE2Gj+eN0cLpg0gO/+exMPvr3b75BE5AT98fVdvLe7lDsWTWVEvz5+hyMiEeqp9QX8a10BXzpvHHNHZvgdjohEqFV7SvndKzv52OyhXDpjiN/hiJwwFYnEd/Ex0fzh2jlcOHkgt/9nC/e/met3SCLSQev2lXHn8h18dMYQPjZ7qN/hiEiEyiut5TtPbmLOiHS+dN5Yv8MRkQhVUdvIV5euZ1h6Encs0mg+6Z1UJJKQEBcTxe+vnc3FUwfxw2e3cu8bu/wOSUTaUVxVzxf+tpZBqQn88LKpGmYmIr443NDMkr+uwQzuumomMdE6vRWRntcccHzlsXUUVdXxm6tn0lermUkvpb+iEjJio6O4+5pZfGT6YH68bBt3Lt9BcB4+EQk1DU0Bbn5kLeWHG7j3urmkJsb6HZKIRCDnHN/85wa2FVZy9zWzyMpI8jskEYlQdy7fwWvbi7nto1OYNTzd73BEOk3lTQkpsdFR3HXVTBJjo/nNyzsprWng9kunEB2lHgoiocI5xw+e2cJ7e0r5zdUztcS0iPjmvjdzeTp7P9+4aALnTBjgdzgiEqGe23iA372aw9XzsrhWKzZLL6cikYScmOgofn7FdDL6xPGnN3Ipq23g11fOJC5GHd9EQsG9b+Ty1xV7+fxZo1k0U/MQiYg//pO9n588t40PTxvMF88Z43c4IhKhVu0p5auPrWfW8DS+v2iKht9Lr6cikYQkM+Nbl0wio08cP3luGxWHG/njp+bQR2N7RXz1r7X5/OS5bXxk+mC+uXCi3+GISIR6J+cQX388m3kjMvjVlTP0nzIR8cWOg1Xc8OAqhqYl8ufF84iPifY7JJGTpq4ZEtI+f/YYfn7FdN7ZVcIn71tBcVW93yGJRKyXthzkf5/YwGlj+vGrK2cQpWGgIuKD9XnlLPnrGkb2T+K+6+eSEKv/lIlIz9tbUsPiB94jPjaahz47n4w+cX6HJNIlVCSSkHfl3Cz+9Kk57DhYzWW/f5tthZV+hyQScV7cXMgXHlnD5CEp/PG6ObpSJiK+WLuvjOvuX0l6n1ge+ux8UpM0ab6I9Lw9h2q4+t4VHG5s5qHPzNek+RJWVCSSXuGCyQP5x02n0hQI8PE/vMOr24r8DkkkYjy/6QBffGQtU4ak8tcbTiElQf8pE5Get2ZvKdf/+T0y+sbx2JJTGZya6HdIIhKBcouruered6lrbObvn1ugBTwk7KhIJL3G1KGpPHXzGYzK7MMND63iz2/txjnnd1giYe2v7+7hi4+sZfqwVP56w3wtdS8ivnhhcyHX3r+SzOR4HltyKkPSVCASkZ63Zm8pH7/nHZqaHY8uUYFIwpOKRNKrDEpN4PHPn8qHJg/kB89s4f89tp7ahia/wxIJO4GA40fPbuG7T23mvIkD+NvnTiFZPYhExAcPvLWbm/62homDUvjHTacyKDXB75BEJAIt23iAa+5bSWpiLE984TQmDlKBSMKTloqSXicpLoZ7rp3D71/N4dcv7WDLgUru+dQcxmT29Ts0kbBQXtvA1x/P5uVtRSw+dQTf++gUojVJtYj0sLrGZm5/ejNLV+Vx0ZSB3HXVLBLjNB+aiPSs5oDjNy/v5Lev7GRWVhr3L56nSaolrKlIJL1SVJTxpfPHMWt4Ol9euo5Lf/sWP/34dD46Y4jfoYn0atl55XzxkbUUVdVxx6IpXLdghJaWFpEet+dQDV98ZC1bDlRy87lj+NqHJqhYLSI97lB1PV9Zuo63c0r4+Oxh/OjyqVpRUcKeikTSq50xrj/PfvkMbn5kLV96dB2vbCvi9kunaN4UkRPU2Bzg3jdyueulHQxITuAfN53GzKw0v8MSkQjjnOOxVXn88NmtxEQbf/n0PM6dOMDvsEQkAi3fcpD/e3IjlYcb+fnHp3PlvCy/QxLpESoSSa83ODWRxz5/Kr9/NYffvpLDitwSfvmJGZw+tr/foYn0ClsPVPKNJ7LZVFDJh6cN5keXTyUtSd2oRaRn5ZfV8q1/beTNnYdYMDqDX35iBsPStay0iPSsspoGbv/PZp5av5+Jg5J5+LPzmTRY8w9J5FCRSMJCbHQUX71gPOdOGMD/e2w9196/kmtPGc7/LpyoXkUibaiobeQ3L+/k4Xf3kJoYyx+unc0l0wb7HZaIRJi6xmbueyOXe17fhQE/uGwq184fTpSGl4lID2pqDvDoqjzuXL6DysONfPWCcXzxnLHExWitJ4ksKhJJWJmRlcazXz6TX7ywnQff2c0Lmw/y3Y9M4tIZQzSvioinvqmZpe/lcedLO6g43MjV87L4xkUTNQmjiPSo5oDjP9n7+fnz29hfUcfCKYP49ocnkZWh3kMi0nOcc7y2o5ifLNvKjoPVnDIqg9svnaLeQxKxVCSSsJMYF833PjqZj80eyref3MhXlq7nsVV5fOfDk5k8RMleItfhhmaWrtrHn17PpbCyjlNH9+O7H9G/CxHpWU3NAZ5av5/fv5ZDbnENU4ak8OurZrJgdD+/QxORCOKc46WtRfzulZ1k51cwPCOJP35qDhdNGaiLyxLRVCSSsDV1aCr/+uLp/H3lXn754g4+/Ns3uXzWUL5+4QSGpiX6HZ5Ij9lffpil7+3j7+/t41B1A/NHZfCLT0znjLH9dRIkIj2mrKaBf6zJ468r9pJXepiJg5L5/Sdnc/HUQRpaJiI9pqa+iafW7+fhd/ewrbCKrIxEfvKxaXxs9lDiY7RymYiKRBLWoqOM604dyaUzh3LPa7t44O3dPLPhAJ+cP5wlZ41miIpFEqYamgK8ubOYpavyeHnrQRxwzvhMbjp7DKfoar2I9JDmgOO93aX8Y3Uez2w8QENTgHkj0/neR6ZwwaQBKlSLSI9wzrEhv4In1uTz5LoCquubmDgomV99YgaLZg4hJlrzDokcoSKRRITUxFhuvXgi1586gjuX7+BvK/byyMq9XD5rKDedPYbRmX39DlHkpDU0BViRW8IzG/bz/KZCKuua6Ncnjs+fPYZPzh+ueT5EpEc0Bxzr9pXxzIYDPLvxAMVV9fSNj+GquVlcu2A4EwdpiKuIdD/nHFsOVPLshgM8s+EA+0priYuJ4iPTBnPtghHMHp6mQrVIK1QkkogyJC2RX3xiBl+5YBz3vZHL0lV5/GNNPmeNy+RTC0Zw3sQBRKvLu/QSzjn2ltTyxs5i3thRzLu7SqhpaKZvfAwXTh7IR2YM5oyxmVqVQ0S6XWFFHW/sKOb1ncW8nXOI8tpG4mKiOG/CAD4yYzDnTRxAUpxOO0Wke5XWNPBWziHe2BE8Nyqqqic6yjhtTD9uOXcsF00ZRGqSVj4WOR79tZaINCw9ie8vmsot543jryv2svS9fdz48GqGpCZw1bzhLJo5hJH9+/gdpsj71DU2s6mggrX7ylizt4y1+8oprqoHICsjkctnD+Xs8QM4c1x/EmI1pl5EukdDU4BthZWs9fLQ2n1l5JcdBiAzOZ7zJw7k7AmZnDshk+QE/WdMRLpHU3OAnOJq1u4N5qG1+8rILa4BgqMIzhjXn7PHZXL+pAH06xvvc7QivUeHikRmthD4DRAN3O+c++kx2+OBh4E5QAlwlXNuj7ftW8ANQDPwZefcC10WvchJykyO52sfGs+XzhvLy1sP8rcV+7jzpR3c+dIOpg9L5aPTh3DJ9MGa6Fp6VG1DE3mlh8kpqmb7wSq2F1ay42A1e0pqcC64z/CMJE4f0485I9I5Y1wmI/slqcu0iHSpusZm8ssOk1tczY6DVWwrrGLHwSpyi2toCgST0cCUeGYPT+fTp43k9LH9mTgoWblIRLpUY3OA/eWHyT1Uw47CKrYXVrH9YBU7i6ppaAoAkJ4Uy+zh6Xx89jBOG9OP6cPSNDpApJPaLRKZWTTwe+BDQD6wysyeds5tabHbDUCZc26smV0N/Ay4yswmA1cDU4AhwEtmNt4519zVByJyMmKjo1g4dTALpw7mQMVhnsk+wNPZ+/nRsq38aNlWJgxM5pyJmZwzfgBzR6YTq8ntpJNqG5o4VNVAcXUdxVX1FFc3cKD8MHllh8krrSW/rJZD1Q1H948yGNmvDxMHJXPpjCFMGZLCrOHpZCbripiIdF5dYzOHquuDeaiqnkPVDRRW/DcX5ZXVcrCy/n3PGZaeyMRByVwwaSCTBqcwe0Q6Q1ITVBQSkU5raApQUnMkDwV/FlbUk1dW650XHeZAxWG8ujQAg1ISGD8omdPG9GPS4OB5kS6WiXSdjvQkmg/kOOdyAcxsKbAIaFkkWgTc7t1/AvidBf+VLgKWOufqgd1mluO93rtdE75I1xucmsiNZ43mxrNGk1tczUtbD/LqtmL+/OZu/vR6LgmxUUwbmsrMrDSyMpJIToghOioKA8wgysy7b/Tk36qeeKu4mCjOmTCgB96pe7TXK7IzmpoDvLGzmMrDTVTWNVJ5uJGquiP3vZ91TZTXNnCoqp6ahg/WyGOijCFpiWRlJHLBpIFkZSSRlZHE6P59GDugr4aOiYSZ7shFAG/tPERJTT2VdU3H5KL/3q+obaS4up6quqZW4oIhqYkMS0/kzHGZZKUnkZWRyMj+fRg/MJm+8ZqlQCScdFcuWrO3lP3ldVTWebnncOPR86Iq77yo4nAjh6rrKa9tbPU1BiTHk5WRxPxRGWSlJzIsI4mR/fowfmBf0pLiuiJMEWlDR/7aDwXyWjzOB05pax/nXJOZVQD9vPYVxzx3aGtvYmZLgCUAw4cP70jsIt1udGZflmT2ZclZY6iqa+TtnBLe213KurwyHnpnLw3NAb9D7FH9+8az+jsX+B1Gp3SwV+QJc8BnH1z9vrb4mChSEmNJSYghOSGW1MRYhmckkdk3nszkePr3jfN+xjMgOZ6MPnFaelUkQnRXLgL4xhPZHKioO/o4LjqKlMQYUhJiSU6IISUxliGpiZzVIg8dyUWZyfH06xOvie5FIkR35qKfPb+d93aXHn0cE2XvOy9KSYxhQHJfTh3d72j+Ofb8SBfIRPwTMpeEnHP3AvcCzJ0717Wzu0iPS06IZeHUQSycOggIjo8ur22kqq6RgAuuNOUA5yDgHAHXc1/jnnqrmOhe3Y23I70iT1hsdBRP33I6feOD/wFLToghPkYnNiLSpm7JRQAPfHoesS0KQ/pPlogcR7floh9fPg3nnFcYiiUhNkpDwUR6kY4UiQqArBaPh3ltre2Tb2YxQCrBCaw78lyRXik2OurolQ/pFTrSK7JTvRqnD0s7+ehEJFJ0Wy6aNDilC8ITkQjRbblo7IC+XRCeiPilI32KVwHjzGyUmcURnIj66WP2eRpY7N2/AnjFOee89qvNLN7MRgHjgPe6JnQRka7nnLvXOTfXOTc3MzPT73BEJEIpF4lIKFAuEok87fYk8uYYugV4geCkZg845zab2R3Aaufc08Cfgb96E1OXEiwk4e33OMFui03AzVrZTER8op6NIhIKlItEJBQoF4lIqzo0J5Fzbhmw7Ji277W4Xwd8oo3n/gj40UnEKCLSFY72iiR4EnQ18El/QxKRCKRcJCKhQLlIRFoVMhNXi4h0p7Z6RfoclohEGOUiEQkFykUi0hYViUQkYrTWK1JEpKcpF4lIKFAuEpHWdGTiahERERERERERCXMqEomIiIiIiIiIiIpEIiIiIiIiIiKiIpGIiIiIiIiIiKAikYiIiIiIiIiIAOac8zuGDzCzYmBvB3fvDxzqxnD8pGPrnXRsQSOcc5ndGUx3Uy46SsfWO+nYgpSLwoeOrXcK52ODjh+fclH40LH1TuF8bNCF50YhWSQ6EWa22jk31+84uoOOrXfSsUWmcP7d6Nh6Jx1bZArn342OrXcK52OD8D++zgrn34uOrXcK52ODrj0+DTcTEREREREREREViUREREREREREJDyKRPf6HUA30rH1Tjq2yBTOvxsdW++kY4tM4fy70bH1TuF8bBD+x9dZ4fx70bH1TuF8bNCFx9fr5yQSEREREREREZGTFw49iURERERERERE5CT12iKRmS00s+1mlmNmt/odT2eY2R4z22hm681stdeWYWbLzWyn9zPdazczu9s73g1mNtvf6N/PzB4wsyIz29Si7YSPxcwWe/vvNLPFfhxLa9o4vtvNrMD7/Nab2SUttn3LO77tZnZRi/aQ+t6aWZaZvWpmW8xss5l9xWsPm8+uu4XaZ9oZ4ZSLILzzUbjmIlA+Olmh+JmeKOWi3vN9Vi7qvZ9ddwvFz7QzwikfKRcpF53wZ+ec63U3IBrYBYwG4oBsYLLfcXXiOPYA/Y9p+zlwq3f/VuBn3v1LgOcAAxYAK/2O/5i4zwJmA5s6eyxABpDr/Uz37qf7fWzHOb7bgf9pZd/J3ncyHhjlfVejQ/F7CwwGZnv3k4EdXvxh89l18+8v5D7TTh5H2OQiL8awzUfhmou8eJWPOv+7C8nPtBPHoVzUS77PykW997Pr5t9dSH6mnTyWsMlHykVH25WLOvjZ9daeRPOBHOdcrnOuAVgKLPI5pq6yCHjIu/8QcFmL9odd0AogzcwG+xBfq5xzbwClxzSf6LFcBCx3zpU658qA5cDCbg++A9o4vrYsApY65+qdc7uBHILf2ZD73jrnDjjn1nr3q4CtwFDC6LPrZiH3mXahXpmLILzzUbjmIlA+Okkh+Zl2EeWiEPw+Kxf13s+um4XkZ9qFemU+Ui46Srmog59dby0SDQXyWjzO99p6Gwe8aGZrzGyJ1zbQOXfAu18IDPTu98ZjPtFj6Y3HeIvXne+BI1396KXHZ2YjgVnASiLjs+sK4XLc4Z6LIPy/02GTi0D5qBPC5ZiVi/6rt36flYt60fF1g3A65nDPR+H+fVYuOonj661FonBxhnNuNnAxcLOZndVyo3POEUxQvV44HUsL9wBjgJnAAeBXvkZzEsysL/BP4KvOucqW28L0s5P3i5hcBOF3PIRRLgLlowinXNS7KRdJOImYfBROx+JRLjpJvbVIVABktXg8zGvrVZxzBd7PIuBJgl3dDh7pnuj9LPJ2743HfKLH0quO0Tl30DnX7JwLAPcR/Pyglx2fmcUSTDyPOOf+5TWH9WfXhcLiuCMgF0EYf6fDJReB8tFJCItjVi7q3d9n5aKjQv74ulHYHHME5KOw/T4rFx3V6ePrrUWiVcA4MxtlZnHA1cDTPsd0Qsysj5klH7kPXAhsIngci73dFgNPefefBq73Zi1fAFS06GYWqk70WF4ALjSzdK9b4IVeW0g6Zqzx5QQ/Pwge39VmFm9mo4BxwHuE4PfWzAz4M7DVOffrFpvC+rPrQiH3mZ6oCMlFEMbf6XDIRaB8dJJC8jM9EcpFvf/7rFzUez+7LhSSn+mJipB8FLbfZ+WiLvjsnM+zdnf2RnD27h0EZyL/tt/xdCL+0QRnTs8GNh85BqAf8DKwE3gJyPDaDfi9d7wbgbl+H8Mxx/Mowe58jQTHOd7QmWMBPktwErEc4DN+H1c7x/dXL/4N3j/KwS32/7Z3fNuBi0P1ewucQbCL4gZgvXe7JJw+ux74HYbUZ9qJ+MMqF3kxhm0+Ctdc5MWkfHRyv7+Q+0xPMH7lol70fVYu6r2fXQ/8/kLuM+3EMYRVPlIuUi460c/OvCeJiIiIiIiIiEgE663DzUREREREREREpAupSCQiIiIiIiIiIioSiYiIiIiIiIiIikQiIiIiIiIiIoKKRCIiIiIiIiIigopEIiIiIiIiIiKCikQiIiIiIiIiIoKKRCIiIiIiIiIiAvx/VJVodCGBcVMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -523,7 +518,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 4436a2a782e7f4dda87234296e5a84959e4591ef Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 28 Sep 2023 17:48:15 -0500 Subject: [PATCH 26/32] default to i=1 on stableswap.spot_price --- hydradx/model/amm/stableswap_amm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index ff3f666e..784681c2 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -112,7 +112,7 @@ def calculate_y(self, reserves: list, d: float, max_iterations=128): return y # price is denominated in the first asset - def spot_price(self, i: int): + def spot_price(self, i: int = 1): """ return the price of TKN denominated in NUMÉRAIRE """ From daeed83c11c243083a15ff0d1f0632af1c7b3c8d Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Thu, 28 Sep 2023 17:55:23 -0500 Subject: [PATCH 27/32] re-ran, cleaned up, and clarified --- .../ImpermanentLossAnalysis4Assets.ipynb | 190 +++--------------- 1 file changed, 25 insertions(+), 165 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index f41bb56d..7d5045c2 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -18,6 +18,9 @@ "end_time": "2023-07-06T20:00:31.614450927Z", "start_time": "2023-07-06T20:00:30.645499714Z" }, + "jupyter": { + "source_hidden": true + }, "tags": [] }, "outputs": [], @@ -81,12 +84,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, + "collapsed": true, + "jupyter": { + "outputs_hidden": true, + "source_hidden": true + }, "tags": [] }, "outputs": [ @@ -150,12 +158,15 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, + "jupyter": { + "source_hidden": true + }, "tags": [] }, "outputs": [ @@ -210,12 +221,15 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, + "jupyter": { + "source_hidden": true + }, "tags": [] }, "outputs": [], @@ -229,7 +243,7 @@ "# plt.figure(figsize=(20, 5))\n", "# for i in range(len(amps)):\n", "# usda_prices = pu.get_datastream(amp_events[i], asset='USDA')\n", - "# plt.plot(usda_prices, color=colors[i])\n", + "# plt.plot(trade_sizes[i], usda_prices, color=colors[i])\n", "# plt.yscale('log')\n", "# plt.title('price')\n", "\n", @@ -238,12 +252,15 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, + "jupyter": { + "source_hidden": true + }, "tags": [] }, "outputs": [ @@ -261,7 +278,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -337,8 +354,8 @@ " ['$0.80', '$0.90', '$1.00', '$1.12', '$1.25']\n", ")\n", "plt.yticks(\n", - " [-0.025 * i for i in range(6)],\n", - " [f'-{2.5 * i}%' for i in range(6)]\n", + " [-0.025 * i for i in range(7)],\n", + " [f'-{2.5 * i}%' for i in range(7)]\n", ")\n", "\n", "for i, loss in enumerate(impermanent_loss):\n", @@ -379,163 +396,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/markdown": [ - "

Amplification = 25

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "

Amplification = 50

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "

Amplification = 100

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "

Amplification = 200

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "

Amplification = 400

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "

Amplification = 800

" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for i in range(len(amps)):\n", - " display(Markdown(f\"

Amplification = {amps[i]}

\"))\n", - " pu.plot(amp_events[i], pool='stableswap', prop='liquidity')\n", - " plt.show()\n" - ] - }, { "cell_type": "code", "execution_count": null, From b32ee3ac14467c1b269bd5eae14284cb834d3539 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 29 Sep 2023 14:54:19 -0500 Subject: [PATCH 28/32] fixed amplification implementation to match what is in production --- hydradx/model/amm/stableswap_amm.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/hydradx/model/amm/stableswap_amm.py b/hydradx/model/amm/stableswap_amm.py index 24592683..27cb5624 100644 --- a/hydradx/model/amm/stableswap_amm.py +++ b/hydradx/model/amm/stableswap_amm.py @@ -47,7 +47,7 @@ def __init__( @property def ann(self) -> float: - return self.amplification * len(self.asset_list) ** len(self.asset_list) + return self.amplification * self.n_coins @property def n_coins(self) -> int: @@ -148,9 +148,8 @@ def price(self, tkn, denomination: str = ''): ) def price_at_balance(self, balances: list, d: float, i: int = 1, j: int = 0): - a = self.amplification n = self.n_coins - ann = a * n ** n + ann = self.ann c = d sorted_bal = sorted(balances) From aab28332815b2ade7a82b1ca9e8181c69bc4143a Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 29 Sep 2023 14:55:19 -0500 Subject: [PATCH 29/32] re-ran with updated amplification code --- .../ImpermanentLossAnalysis4Assets.ipynb | 52 ++++++++----------- 1 file changed, 22 insertions(+), 30 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb index 7d5045c2..173bac50 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis4Assets.ipynb @@ -84,17 +84,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, - "collapsed": true, - "jupyter": { - "outputs_hidden": true, - "source_hidden": true - }, "tags": [] }, "outputs": [ @@ -102,18 +97,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.0009954443903124222 247276.40443434505\n", - "156.87953617143856 -99990.00099990002\n", - "0.0009773262524820792 247647.57879376572\n", - "199.71967208980746 -96686.31486433979\n", - "0.0009877770884735417 247944.91939021496\n", - "199.94530000067437 -92802.53170641157\n", - "0.0009806120595463234 248217.79521216897\n", - "199.67437907817265 -90032.92489873343\n", - "0.000995282647861672 248441.28060711964\n", - "199.67207475942692 -88073.92649009275\n", - "0.0009588261640137208 248664.96721939923\n", - "199.42914906713443 -86684.69418227047\n" + "0.0009922574569619662 243741.31469126802\n", + "169.30634842333134 -199980.00199980004\n", + "0.0009946363848260013 244546.9493147412\n", + "199.97388507202805 -177651.41564271573\n", + "0.0009927823702901677 245257.12922252377\n", + "199.9723645376328 -153259.21073119974\n", + "0.0009933348564170553 245871.00838136944\n", + "199.90331793935485 -134402.2595698204\n", + "0.0009891511141421894 246412.49294065902\n", + "199.92331517957578 -120210.313331987\n", + "0.0009866484023805901 246881.09828147842\n", + "199.9139673305112 -109743.67008705313\n" ] } ], @@ -123,7 +118,7 @@ " agent_id='LP'\n", ")\n", "amps = [25, 50, 100, 200, 400, 800]\n", - "trade_range = [[200000, -100000]] * len(amps)\n", + "trade_range = [[200000, -200000]] * len(amps)\n", "adjustment_factor = 1.0001\n", "# print(trade_range)\n", "for i, amp in enumerate(amps):\n", @@ -158,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -221,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -252,21 +247,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", "start_time": "2023-07-06T20:00:31.681435289Z" }, - "jupyter": { - "source_hidden": true - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -278,7 +270,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIsAAAE/CAYAAADG7EOqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9dZhcV3rn/znF1N3VzMzdYpZlkBnH9jBPZiYTmMAk2WQ3u0l2f9lks7xhmGQnm2Qmw2SP2ZZl2bIki1nNzMxdXOf3x7ld1S11C1tSS30+z3Oeqrp47q0Ldb/1vt9XSCnRaDQajUaj0Wg0Go1Go9FoAEy3uwMajUaj0Wg0Go1Go9FoNJqVgxaLNBqNRqPRaDQajUaj0Wg0MbRYpNFoNBqNRqPRaDQajUajiaHFIo1Go9FoNBqNRqPRaDQaTQwtFmk0Go1Go9FoNBqNRqPRaGJosUij0Wg0Go1Go9FoNBqNRhNDi0UajUZzFyGEOC+E2H27+3E3IYT4QyHEv97uftxMhBAfFkJ0CSGmhRAbb+F6PyuEePNWrW/eencJIZqM7X3+Kqb/ZyHEf7kFXbtlCCGkEKLsdvfjZnGzroVCiF8SQvz5ci93iXXtE0J8xXh/W86Vi/qzWwjRfTv7sBhCiF8XQvyP290PjUajudvQYpFGo9HcRUgpa6WU+253P+4UhBBFxkOz5Xb35Tbzv4Ffk1J6pJQnb8YKFtvXUspvSykfuxnruwJ/BPy1sb0v3Ib1awxu1jl4M66FQggb8AfA/1rO5V4Nt/FcuRP4v8BnhRAZt7sjGo1GczehxSKNRqPRLCtCoe8vdxaFwPnb3YlbyGrb3lXDTRZ+nwPqpZQ9N3EdmmtESukHXgO+cLv7otFoNHcT+se8RqPR3EUIIdqFEI8Y7/9QCPFDIcS/CiGmhBBnhRAVQoj/IIQYNNKOHps37z4hxH8TQhwRQkwKIV4UQqTMG79DCHFQCDEuhDg9P8XDmPdPhBAHgFmgxIgW+BUj3WdKCPHHQohSYxmTQogfGP/UI4RIFkK8LIQYEkKMGe/zLlr+HwshDhjLelMIkXYNfVtq3veM13EjJWnnVezjZ40Ul3Fj2dXzxv2uEKLHWE+DEOJhY/g2IcQxY7sHhBB/usSyr7QfviiEaDWW3yaE+OwSy9kmhDhk9LFPCPHXc/v6ounsQohpwAycFkK0GMMXpCiJeWlYc6koQojfNo6jPiHEl+ZN6xRC/B8hRIcQYkII8b4QwrnYvja25/15894jhDhqzHdUCHHPvHGXPQYW2bZfEEI0CyFGhRA/E0LkGMNbgBLgJaMf9kXm3SiEOGGs5/uA46LxzwghThn796AQYt28ce1CnWMXjO/wn4QQjqucd5MQ4qSx3h8KIb4v5qW/CSH+nbG/e4UQX5n/PRnf5f8WQnQax9jXjf0+N++/nTfvl5fab8a0XxJC1Bn9aBVC/NK8cWnGcTlu7Nv9whCHxdLHv0kI8e+FEC1CiBGhzv25a8sVz0GhrmU/MvbHlPHdrL9on/+uEOIMMCOEsIiF10KzEOL3jPVPCSGOCyHyjXFVQoi3jG1pEEJ84jK75kng3XnrnYuK+pJQ19MxIcQvCyG2CiHOGPvory/ali8b+3ZMCPGGEKJw3rhHhRD1xvH/14CYNy52rohForHEwpS1Lwp1nvyZ0YdWoc6tLxr9HBRC/NxSGymESDGO216jny9cNH6pc/9p4/idNNbzh4vsq58zjtFhIcTvzxvvFEL8i7G+OuNY7543PkcI8WOhro1tQoivXdTtfcDTS22TRqPRaK4DKaVuuummm253SQPagUeM938I+IHHAQvwTaAN+H3ACvwC0DZv3n1AD7AGcAM/Bv7VGJcLjABPof5oeNT4nD5v3k6g1liXFZDAi0CiMTwAvI16UE8CLgA/Z8yfCnwUcAEJwA+BFy7qWwtQATiNz//9Gvq21LxFRj8tl9mnfzhvP1QAM8Y6rMC/A5oBG1AJdAE585Zdarw/BHzeeO8BdiyxriX3g/GdTAKVxudsoHaJ5WwGdhjfRRFQB/zmZbZRAmWX+fzPwH8x3u8GwqhULqux32eBZGP83xj7OBclQt0D2Bfb18AXgfeN9ynAGPB5o9+fNj6nXul7XGR7HgKGgU3Guv8KeG+x82SReW1AB/BbxvZ9DAjN2/6NwCCw3di+nzOWZ5+37HNAvrFNB65m3nnr/Q1jvR8BgvPmfQLoR51LLuBf539PwJ8BPzPWmQC8BPy3efMOED+3v3Pxd3zRPngaKEWJFQ8Y3+8mY9x/A75u9NEK3GdMd7nj/zeAD4A8Y1v/HvjuNZ6DIeO7sAK/g7qWWeft81PGPncuci38t8BZo48CWI8619xGn7+EOuY2oo6bmiX6cRT4+LzPc33/OkpQfAx1zX0ByECdA4PAA8b0z6GuF9XG+v4AOGiMSwOm5m3jb6HOs68scq5css9Q58P8acPGdpmB/4K6Pv+Nsf8fM9blWWI7XwG+DyQbfZnr/24uf+7vBtairsPrUMfc8xf1+f+izt/1qHtCtTH+v6OEuGTUcXIG6DbGmYDjwH9CnSclQCvw+Lw+bwJGr+e+qZtuuumm2+LttndAN91000235WtcKha9NW/ch4BpwGx8TjB+vHuNz/uY9/AN1KAeVs3A7wLfumhdbxAXe/YBf3TReAnsmvf5OPC78z7/H+DPl9iODcDYvM/7gD+Y9/lXgNeN91fTt6XmnXuAuVqx6D8CP5g3zoQS2HYDZagHw0cwHmLnTfce8J+BtGv8PmP7AfVgO44Sk5zXuJzfBH56mfHXKhb5WPigOogSp0zGuPWLrOOSfc3CB+DPA0cumucQ8MUrfY+LrOsfgf8577MHJTYUXXyeLDLv/UAvIOYNOzhv+/8O+OOL5mkg/kDdDvzyvHFPAS1XmtdYb89F631/3nr/H4b4Y3wum/ueUALIDIY4Y4zfiSEGG/POP7crLv6Or3D8vAD8hvH+j1AicNlF01zu+K8DHp73Odv4PubEzKs5Bz+46LzrA+6bt8+/fNE8se/Y2MfPLbLcTwL7Lxr298D/t0Q/moAnFjmmc+cNGwE+Oe/zjzGEWlSq1M9ftB2zqLTIL1y0jQLo5vrFoqZ549Ya02de1M8Ni2xjNhDFEIAuGrebJc79JfbXnwN/dlGf8+aNPwJ8ynh/sfjzFeJi0Xag86Jl/wfgn+Z9LgciV3M866abbrrpdnVNp6FpNBrN3c3AvPc+YFhKGZn3GdSD9Bxd8953oP49TkM9zHzcSGkYF0KMA/eiHiwWm3ep9V/82QMghHAJIf5eqNSlSZS44hVCmOdN3z/v/ey8fl9N35aa91rJQe0XAKSUUdR250opm1GizB8Cg0KI7wkj9Qn4edQDer1Q6VXPLLbwy+0HKeUM6uH2l4E+IcQrQoiqJZZTIVSqUL+xnP+K+h6XixEpZXje57l9moaKsGi5jmUu2LcGHajojDmu9nu8+HuaRj0c5y4x/cXz9kgp5UX9mKMQ+O2Ljrd8Y745Lj6Pcq5i3sXWO385ORd9nv8+HRVtdHzecl83hi8278X7eQFCiCeFEB8YqVnjKMFr7vj5X6jomDeN9KZ/D3CF478Q+Om8vtUBESDzcv24iFj/jfOum6X3+cXks/gxWQhsv+j7+CyQtcRyxlAi+8Vc1XXOWN9fzFvXKEoUyuWi78g4Di63TVfi4j4gpVyqX/PJR0XojC2x3KXOfYQQ24UQ7xipYhOoa9XF152lzuHLHd+FQM5F39PvsfD4SQAmluizRqPRaK4DLRZpNBqNZj75894XoP79H0b9cP+WlNI7r7mllP993vTzH3Kvld9GpYhsl1ImoqIsYJ5nx2W4mr4txbX2uRf14KI6J4RA7bMeACnld6SU9xrTSOB/GMObpJSfRqWm/A/gR0II9yLLv+x+kFK+IaV8FCWE1aNSOhbj74zx5cZyfo+r25dzzKLEhzmWeni+mGFUGk7pIuOutK8X7FuDAox9e41c/D25UWlHV7OsPiDX+G7n92OOLuBPLjreXFLK786b5uLzqPcq5l1svfOX04dKz1ls3DDq4b923nKTpJSeefNe3KdFEcrD6ceoCnmZUkov8CrxY3BKSvnbUsoS4Fng3wjDm2ip49/Y7icv2m6HVEbRV3sOxvovlEdSHvH9yhWW08Xix2QX8O5F/fJIKb+6xHLOoETf66UL+KWL1ueUUh7kou9o3rVlMWaM1+s5R6+mjylCCO91zPsdVCpkvpQyCZWed7XXncsd312oKLn5+y1BSvnUvGmqgdPX0WeNRqPRLIEWizQajUYzn88JIWqEEC5UusmPjEikfwU+JIR4XCizWIdQRsd5l1/cVZOAetgdF8r49v+7hnlvpG9DqJSLkqtc1w+Ap4UQDwshrChxJwAcFEJUCiEeMh62/cb2RAGEEJ8TQqQbERHjxrKiiyx/yf0ghMgUQjxnCB8BVErhYsuYW84kMG1EHy318LsUp4DPGPvzCVSa1BUxtu//AX9qGNKahTKytnPlff0qUCGE+IxQBsWfRKVCvnyNfQf4LvAlIcQGY93/FTgspWy/inkPoXxZviaEsAohPgJsmzf+/wK/bERRCCGEWyhj3/kRJ78qhMgzvsPfR/m/XGneQ6hom18ztv+5i9b7A2Obqo3z8z/OjTD2+/8F/kwY5cOFELlCiMfnzfvFeef25c4vG8rXZggICyGeRHncYCz3GSFEmSFmTBh9jl7u+EeJBn8iDDNnIUS6sX1w9efgZiHER4Qydf5N1DnwwRXmmeMbwB8LIcqN/b5OCJGKOrYqhBCfN75rq1Dm1NVLLOdVrvJcWIKvA/9BCFELIIRIEkJ83Bj3ClA7bxu/xhICkJRyCCV8fs44x77M4mLYNSOl7EOly/2tUIb7ViHE/VeazyABFZXkF0JsAz5zDav+AWrfJAshcoFfmzfuCDAllIm509jmNUKIrfOmecDot0aj0WiWCS0WaTQajWY+30L50/Sj0om+BiCl7EKZs/4e6uGuC2Uau1z3kT9HmZ4Oox4AX7/aGW+kb1LKWeBPgANGesOOK0zfAHwOZZg8jPKB+pCUMoh6wP7vxvB+VBTRfzBmfQI4L1Tlsb9A+XT4uJQ/Z+n9YAL+DSqaYhT1cLSUCPQ7qAe1KZSI8P0lpluK3zC2bRyVlvPCNcz7Oygz4aNGP/8HYLrSvpZSjgDPoAS4EZR5+DNSyuFr7DtSyj0oMeXHqIiFUuBTVzlvEGUu/UWj/58EfjJv/DGUOfxfo9KSmo1p5/Md4E2UD0sLymD4svPOW+/Po/b751BiRsAY/xrwl8A7xnxzQknAeP3dueFCpR7uQUWpzc3758BeY5q9l9n+KdR5/wOjj59BRYvMUW4sexolcP2tlPIdLn/8/4WxjDeFEFNG37cb67vac/BF1HcxhvK3+oiUMrTUdlzEnxrb8yZKRP1HlO/XFEoI+xTqvOpHHa+XVMgzeAmoEvH0umtCSvlTY/nfM76jc6gKaxjH+cdR+3AEtZ8PXGZxv4C6zo2gTM8PXk+fluDzqKjSepQn0W9e5Xy/AvyR8R3/J9Q+v1r+CJVa2IY6vn5E/NiPoK4NG4zxwygBMAlAqGqDTwH/cg3r02g0Gs0VEAtT4zUajUazWhFC7EMZOX/jdvdFo7lTEUK0o4yG9yzDsg4DX5dS/tMi46pRYoP9Ig+Zuw6hSrCXSSk/twL68ouoamm/ebv7cjcjhPgqSlS/YiSXEOLXUalv/+7m90yj0WhWD5bb3QGNRqPRaDQaDQghHkBV7hpGRXStY150mRDiw6hUKBcqQuWlu10oWmlIKf/hdvfhbkQIkY1KRTyEiqr6bVQE3hWRUv7VTeyaRqPRrFp0GppGo9FoNBrNyqASZdI7jnpY/pjhITPHL6HSglpQXkHX6kWl0axUbMDfo1Jn96LSDv/2tvZIo9FoVjk6DU2j0Wg0Go1Go9FoNBqNRhNDRxZpNBqNRqPRaDQajUaj0WhiaLFIo9FoNBqNRqPRaDQajUYTY8UbXKelpcmioqLb3Y1lZ2ZmBrfbfbu7odFoVij6GqHR3Fnoc1ajWZ3oc1+juTtZLef28ePHh6WU6YuNW/FiUVFREceOHbvd3Vh29u3bx+7du293NzQazQpFXyM0mjsLfc5qNKsTfe5rNHcnq+XcFkJ0LDVOp6FpNBqNRqPRaDQajUaj0WhiaLFIo9FoNBqNRqPRaDQajUYTQ4tFGo1Go9FoNBqNRqPRaDSaGFos0mg0Go1Go9FoNBqNRqPRxNBikUaj0Wg0Go1Go9FoNBqNJoYWizQajUaj0Wg0Go1Go9FoNDG0WKTRaDQajUaj0Wg0Go1Go4mxLGKRUPylEKJZCHFGCLHJGF4phDhuDNtpDLMIIfYIIVzLsW6NRqPRaDQajUaj0Wg0Gs3ysVyRRU8C5Ub7ReDvjOG/BPwG8BTwO8awrwL/KqWcXaZ1azQajUaj0Wg0Go1Go9FolgnLMi3nOeCbUkoJfCCE8AohsoEQ4DJaSAjhBT4EPLFM69VoNBqNRqO5dqSEiD/eogGIBJBhH9I/gQxOIAOTRH3jhKdGCc9MEZkN4J/y4xsNMN4vmRywMj1qJxwUhCMRXv7T72N3RXAnh0jKjOJJs2JPtuNIcGBxJ2B2JWDxJGOyuxE2N9g8CHsSwuIGixPMDjA7VTOZb/ce0mg0Go1Gs4pZLrEoF+ia97nbGPY3wDcBOyrK6D8C/1VKGb3cwoQQv4iKUCIzM5N9+/YtUzdXDtPT03fldmk0muVBXyM0misgI1ij01iik1ijk1gjk1iiE1ijU+q9nMYcncUUmcUcmcYcnEWEfYhwECIhCEeIRgThkJVQ0EYoZCMcshIOWQj4HYQCDkJBG36fg9kZD7NTHmamE/DNpBL0OwiHLYC4XAcxmaKYLWEs1hA2+xQ2xxBO1wwuzxQOlx+HcxabI4DVEsJqD2B3+LFYQ1isYcyWMGZrFLNNIsxmMJuRZhtRs5OoxUnU6iFsSSBicRMRLiImF2GTK/5eOImY3IRNHkKmBKLCAeJy/dVoNNeDvl9rNHcn+txePrFoUaSUncBuACFEGZAH1AkhvgXYgP8opWxcZL5/AP4BYMuWLXL37t03s5u3hX379nE3bpdGo1ke9DVCsyqJhsE/BL4+8PXHX2f7wD/3OgiBEQiOAxIpIRoxEYlYCIctRMJmolELkaiNaMRMJAyhKAQiZiUGhZ2EQ1YiYSuhkIVI2EI4ZCMUtBIK2Qj47QT8TkJ+O7MzLnwzHiUeBW2AQJgkCekRUgvBm28jpdiFI8lOV1cn6YlZzAwHmOr3MzUQZHYkgm9SEJhx4pvxzNtQqUQkSxiLNYjNEcDh8OFwzWK1B7HZA9gdPqy2MGazEpus1iBWWxCzJYLZPI3JMo7ZHMFiCeG0hjCbo5jMEYQpiskUxWQ2Xk0RNc5qQti9CHsy2FPAlgz2ZLClGK9Gs6cYLQ0c6WDzgtD1UDSapdD3a43m7kSf2zcgFgkhfhX4BePjUSB/3ug8oOeiWf4E+APga8A3gHbgvwKfvd4+aDQajUajuUOQUSX8zHSqNt0Zfz/TCbO9EBhS0108qzWZqC2DiPQSjuQQCWcTDgWJ+GaJzEwokWluWmEhassiIpMIh6wEZ0OEpqaR4bDKPAtbCJvTCMsEAhMhQr4QoaCNYNBJJOphZsyMf9ZFIOgkHFQ/k5JLvJR/qIbiB8vIXJ+N2XZpiljvvn2su8yPysBUgLGWEYbrBhg41c1w/SAT7ePMjgSYmYr1XkUWzYlI9gAOlw+b3Y/FGsZqC2NzBrBaAjGxyWw2Xu1gsUpMpjAm4cdsDmE2R1SEkjmCMEkwmTDbQpgsQ5jMA5hNIUz4MDGD2RzBZIoYIpOMd1yYwZ6qhCNHOtjT571Pi7+PDUsFk/V6jhCNRqPRaDQriOsWi6SUf4NKM0MI8TTwa0KI7wHbgQkpZd/ctEKIB4BeKWWTUQUtajRdEU2j0Wg0mrsBKVUk0FQLTDbDdCtMd8wTg7ohGlo4jzUJPAXgyoe0rUhHJlGRQDgQJjI7o7yCxroJ97cg/eOAoapYnVi8RZizahGWVMJBC8EpP4HhQfz97chQEBhHODxYUkuRjkT8EyFmekcIz84SjQqk1U1EJDM14ic4GyXgdxOKJuGflAiTIHdHPmVPVFLyWDlJ+d4b3j32BDtZG3LI2pDDmk9vjA2PBCOMtYwwVDfI4Ll+Bk71MNI4zPRYIDaNMEWxWEJGhFEIuyuE3TE9T1gKYXVEsbtNmC0RTNEZTMKnxlnCCJPE7HBicdkxh0yYzWFMzGCKjGOSYDLbFmSoCYsdkysJs8OF2WbFFBGYfSHMgSlMsgdzZAQRGr3MxqaBM+uiln3pMFuyTo3TaDQajWaFslxpaK+iKp41A7PAl+ZGCCEEKqLok8agfwC+baz7q8u0fo1Go9FoNDebaFgJQFMtMNVsvM5rEV98WmECVx64CyB9p3r1FKpXdwHSkUV4apDwwHnC/ecItZwnPLgf6Z+IL8LpxZJWiaP6GSxpFQhvCWG/xNfXxVTrGWaPniYycxYAk82JI78S7/bnCUXczAxMMV7fhL91GBjGlpqJOb2awBiMNQ8SDkSJCCthMpgcCICErI3ZVH24lopnq3Gne7gVmG1m0qozSKvOoPoja2LD/WM+husHGaobZOj8AINn+xhtHsU3E4FxQGQYYlEQq1UJSU5vFJstiEnOYDbEJbM5gi3BiS1ixRKMYJLTEBzFYo5iMiUACWA2Y01MwerxYHE5sNgkJlOASGgcMT2AnB26qNcOhGstZk8GZncyJocHs8OB2WrGbIliEj5M4TFEYAAG31fpg9EAl2CygTMTHFngmi8m5YArN94caToVTqPRaDSaW8yyiEVGFbRfvcy4R+d9rgM2Lcd6NRqNRqPR3ASCEzBRDxN1xqvRplpAxlO+MDsgoVS1nEchoSz+2VMYS0eKBmcID1wgPHCeUPNewgPnCA81QCSolmNxYM2oxlH9ISzp1VjSyjGnVSCFjdnWM8y2nmFm/wf4Ov4JGVbz2DMLSVy/G2fxOqKmJKY6+hg5dZrJA4eQ0Shml4vEihrshVsY75ii51wH0XAfJncqUVc5o70zRIJRvMVudvybbVQ9X0tyScqt3tNL4kh2krezkLydhbFhMioZbxtl8NwAg+cHGDzbz+CZPqbG/QCMDYPVITEJP1ZrEIs1hN0VxhmwYBkPQWgSs8mOxZKGySyxetzYkxOwuS1ECRGanET2d0NwKh7wY3JiS9uBLTkdqycBi8uK2RLFLGYhOEJ4qpdoz2lkcGbhBlidmJPyMSfdizk9H3NCBmanilQyWyUiPIHwDxjeVP1KhBw6rDypkAuXZbKB6yIB6ZKWo45HjUaj0Wg0y8JNNbjWaDQajUazQpFSpYaN18HkPEFook49vM9hskJCOXhrofAj6v2cIOTKviTiQ0ZChAfrCDV9h1DvSUK9p4iMNDMnAAhnMtbMNbi2/jyWzFqsmWswp5QgTGaiAR8zLaeYOHmUmca/x9fVoPppMuMsrCb1gY/jKl2PI6+GqfYuho4coe0fXyQwOgpCkFhaSv6zzxOOJDB4tpfG1+uQkV6cWRm4yjYw3DjLZNMUtoQgtZ/aQO0n1pG5IRtxh6RCCZMguTSV5NJUKp+rAUBKyXTfFIPnBhg636+EpLP9TPVMqplGwDoksFiCmIQ7lsrmSLLgkBYsviAyMG5EI4URIhGzKxNneiqOJBcWhyAqZgiMDTPTeh4ZmpceZ7VjS8/Dnr4VW0omFo8Li92E2RwE/xDRyR4i452Euo8iA1MLt8WeoMQkbwHmpO2Yswswe/MxJeRgcdhVmttsj9G64+9HT0L3yxCevXQH2VMvFZHc+SrNcS7d0eq+ad+PRqPRaDR3E1os0mg0Go3mbsc/DOPnYOysauNnYewchKfj01iTwFsNuU9CUhUkVqnXhBIwLf5zQUpJZKyDUO9Jwr0nlTg0cB7CKtJFuFKx5mzEUfMs1qw1WDJrMSXkxMSZaCiIr/0c0x/8I9ONR/G1n0dGwgizBVfxWjKe/Aru8k24imoJ+4MMHztG++uHGT3190T8fswOB6kbN5K6aQuhqJue/Rc4+Y8niPiDONO9pG/bxkQ/dH7QQzQ8QM62PHb+zm7Kn6nC6rw7TJiFECTkJJKQk0jpY+Wx4b7RWZW+dn6AoXMDDJ7rZ6xlFBlVop1lwoTdFUVEpjGbzVhtCVidJlzpbhxmM5ExP1M9AxCcVObYgDWxBHduNo6URKwuMxZzABEaI9DfztS595GReNSZ2ZWIPbMQe9b92AoLcaRkYHFaMOEnOtVNZLyLyEQX4dFWAq37YsfMHCZ3BubkIszJheo1ZSeWUvXZ5PBCaAJmeuYJShe1kRPgH7h0h9lTY6mQuPPnvTeaMwtMlxqYazQajUaz2tBikUaj0Wg0dwthH0xciItCc8LQ/Eghewp410LZFyGpRglESdXgyLii2bAMzhLqPUGw6yih3hOEek8hfYbRscWBNWstrk1fwJqzAWvOJkxJeQuidqSU+Hubmb5wiOn6o8y0nFKRKsKEs6CKtIc+g7tyC+6S9ZjsTnyDgwweOkT9v/yE8fp6iEaxp6aSvXs3qVu2EJUeOt46waH//jrByRlsiW5y79+EP5BA2ztdtJ/qwpnqYuNXtrLm0+tJKUu7CTt9ZeJMcVFwXzEF9xXHhoVmgwxdGGTwbD8DZ/oZONPHaKNARpU/k81tZnpWQngGs4xisSVgtnpwZyThSnUStUeYHpxkvOnsAnHHkZGBJ38dzoxUbB4bFmsIERglONzJ1LkDhA+9FJtWWKzYMgqwZxbiyNqFvbgQV2YRtgQPcnZQiUjjHYTH2omMdRBs20/07A8XbJtweJWI5C3EklxkiEqPYi4pxOTJjB9zkSD4elXlvdmuhVX4plqg/x0ITS7cccJiRCQVqGikxYQlW9Iyf1sajUaj0aw8tFik0Wg0Gs2diG9QpeTE2illOj1Xet7sUGJQzuOQvFYJRMlrVFWqq0y7ikwPEuo+SqjrCMHuo4T7z4GMAAJzWgX28kex5mzEmrMRS3olwnxptE54ZoLp+iNMX/iAqbpDhCeGAbBnl5Cy63k8FVtwl2/C7EoAYLa/n85XX2fw4EEmm5sB8BQVUfzRj5K+fTsmdzLtrx7h0H99iemuIcwOG7n3r8VTUEr3sWGOf6uJaDhK4e4Sdv/nRyl5tHzRUverEavLRs6WPHK25MWGhWaDDJ0fZOBMX1xAaoqCdAJgT7DgjwpGe2cgOGmYZqfgSE3Ak5WEPdEMwsdk5wDDJ09BNAKAMJtx5eTgKXwU19oMbAl2LLYwcnaI4GAn/u4mJk/tix+vgDU5C3tWkWqZ92Kv/ByOrCJMdgfR8U7C4x1ExtqN1kG47zSB+leMY3JuIU4s3sJ5UUnFWFJKMKc/hKk469KUw+AEzHTFq/bNtelOGDwAM99f6NMFYPOCpxg8RYu8FoH11pijazQajUZzM9FikUaj0Wg0KxkpYaYDRk4uFIdme+LTeIogeQMUf8oQhdYqs+lrSKeRUhIZaSHYfYRQ1xFC3UeJjLWrkRYH1pyNuHf+Ktb8bVhzN2FyLB5dIaNRfF31TF04xPT5g8y2nwcZxeRMIKF6O56anSRU78DqTY/NM9vXx8BrbzJ48CBTra0AJJaVUfaFL5Cxcyc2bwrd+05z7M9fpf+I8jHK2FxO1acfYXrMyrnvnWHknw5gT3Kw4ctbWP+FTXiLV45Z9UrG6rKRszWPnK1xASk4E2To/AADp5WANHimj9GWEEgVmeVIshG0mJiemCU6O4LFHMBkjmJ1F5JYkIYzzYXVHkFEpphobGLg/fdjyza7XCQUFuIpehzv9nwcSQ7M5gDh0R78/e0EBjqYOfACMhiPXDK7k3Bkl2DPLlGvJVtwZZdgSUhGRkJEJrqJXCwkLZLeJqwuzCklmFNKlICUarymlGBKjleiW0A0oiLzYkJSB0y3qzZRDz2vL6wCCGBPW1pI8hSBxXkD35hGo9FoNLcGLRZpNBqNRrNSiEZgshFGTywUh4JjarwwqZSxrAchZaPRNoA9+ZpXJaMRwoN1BDsOEOr8gGD3UaRPrUc4U7Dlb8O56fPY8rZhyVqDMNuWXFZ4aoypC4eUQFR/mMj0OAiBs6CajCe+hKdmJ67CGoQ5/rNjpqeHwYMHGTh4kOn2dgCSKioo/+IXydi5E0d6OiPn2jn3T3vpePM4oRk/7uwU1vz8kyTXVND8eitv/f4HBKeDZKzJ5NH//RSVz9feNV5EtxOb20butnxyt+XHhgWnAwyemxOQ+hg8089Iqx9Qopwz2Y7LYSHY6SdyoQeTnMVkkpjtDpJKd+DJTsKeYMLMLOGJfvreeYeI3xByTCZc2dkkFBXhKf0Q3ocKsad4IDhBcKADf18rgb5Wxo+9QdQX99kye5LniUjFOLLX4ax8HovHC4CUUaJTfYRHWomMqhYebSXcf4ZA/csLopqEKzUmHC14TS5EuHPBnQvsvHRnSakquE23xUWkufdjp6DrRYgGF87jyISEYnAXqVdPUfy9uwDM9hv6/jQajUajWQ60WKTRaDQaze1gLmJo+AgMH1Vt5HjcdNpkh+R1UPTxuDCUvBYsrutcXdQQhw4S6jxEsPMDpH8CAHNyEfbyx7Dlb8Oat1VVJ7tMqpqUkkB/G1Nn9zN5dj+zbWdBSsyeZBKqd5JQuxNP1XYsCQtFLN/AAP379zPw/vtMd3QAkFRVRcWXv0zGjh040tOZHRqn7dUjtL7yAZPtA5jtVvIf2kjxU9uZHpac/pcTdP3nH2K2mSl/ppoNX9xM1qacO6ai2Z2KzWMnb0cBeTsKYsMCk34lIJ3pi0UhjbTMAF4QXhKy3LicZib6fAw3tCLCMwgBJqsFb9kGEsvTcHptmM0BIjNDTDY3M3DgQGz5Vo8HT1ERnqIiEjZsJ+25QhxJToLDXQT6WvEbbfzIq0T9M7H5LAkp8Sgk49VR/WHMrsTYNDISJDLWSXh0oZAUbN2H/8z35225wJSUe4mQZE4pwZyUhzCZwZmpWvqOS3ecjMJsH8y0KwFpqk29n2pT537Hjy5KcxPgyolXHEwoBU9J/L095arTSDUajUajuRG0WKTRaDQaza3ANwgjRxeKQwHl34PJriKEyr4IqVsgdbOqRLZEFbKrQcoo4aF6Qh2HCHYcIth1COkbBwxxqPIpbIX3YCvYgTkx58rLi4SZaT7J5Nn9TJ19n+BwNwCO/Eoynvx5EtbcizO/CmEyLZgvOD7OwMGD9L/3HhMNDYAhEP38zyuBKC2NaCRK3wcXaPkfP6HnwDlkJEr6+lK2/8EjZG6ppv5nDbzy63uY6pkkITeRXf9+N2s+vR5Xmi6DfjuxJzrIv6eQ/HsKY8N8o7MMnO6j/1Qf/ad6GTjVy+xwCPBisqSQlO/B6TUxNTLLaHMDMmgISBYzSWVFJG+8B1eqQ/kb+UaZ6emi5623iAYCAAiTCVdurhKQimrwPvQUnsJChAgR7GuLRSH5+1oZ++BlooHZWN8sSWkL09myS3Dk34Oj4rEF2xUNTBMZayMy0hoTk8KjrYTO/RgZmIpPaLYpk+20ciyppZjTyrGklmFOLcNkM45NYVJRSe5cyNh16U6MRlRKaSwiyWhTLSrFzde3cHprkiEclSwUlBJKwZWnK7lpNBqNZtnQYpFGo9FoNMtNcFJFCY0YotDwEeV3AkYqWQ3kPwtpW1XzroXLpHldDcpzqJlg+/sEOw4S7DwUSyszewuwVzyBrWAntsKdmBNzr2qZkdlJpi4cYvLMfqYuHCTqm0ZYbHgqt5L2yGdJXHMv1uTMS+YLz84yePgwA/v3M3r6NDIaxVNURNnnP0/mvffizMgAYHZgjLPfeJWWFw8yOzCGIyWB6s89QsmHdhIJWzj1/47y2m9/g9BsiLydBez+I2VYbTKbLlmnZmXgTHFR9GApRQ+WAuq4nOqdZCAmHqk0tuB0EPBidaWTVODB7jXhm5ph4u1zRGaVgCTMJrylOSTXrsGTnYTNJSE0wWx3F+N1dQzs3x9bry0piYSSEhKKi0koeYiUh38eR0YG4YmhBQJSoK+V0Ys8kazJmThyynDklOLILcORU4Ytswpr1toF2yalRM6OLBCQIiMthIcbCTS9CdF4hJApIRtLWjnm1DIsRjOnlWFyZyyMgjOZVdU1TwFw/6U7NDQTF4+mWmCqFaZbYOy0keIWmrcsq0ppSygFT+lFolLJdUclajQajWZ1osUijUaj0WhuBBmF8ToYOhRvE/WAVOM9JZC+E6q/BmnbVDrZMlVLikwPEWzfT7DtPYLt+4lO9QNgSsrHXv6oETm0E3NS3hWWFCc43MPkmXeZPLufmeZTEI1gSUghacODJKy9D0/lNsyOSx86I8EgIydO0P/eewwfP040GMSZmUnhRz5C1n334SlQ6UvRcITu/Wdp/un79B08j4xKsrZXs+m3PkrOvWvoPdLD3v+4j7a3mzFbzVQ+V8PGr2wlY03Wsuwzza1FCEFibhKJuUmUP10FQDQSZaxlhP5TfQyc6qX/dB/dxweIhqKAF2dKNkkFHpyJEAjM0Ln3HOEZlZ4pzCaSirNIqbqftPszsCWYMUWnme3uZKqtjdEzZ5ARVR3N7HSSUFQUE5G8992LOy8PYTYTGu2LpbEFelvw9zYzXX8YGQkb67FgzyzCPk9AcuSWYfVmYHOnQf62BdsZS2sbaSIy0kx4uInwSAuhM99HBuMpcsKeeFEUkhGVlFyIWCyS0OpWVQwXM+CORmC2e56QZIhJUy0weAhCEwund2bPE5DKILFctYRysCVeunyNRqPRrGq0WKTRaDQazbUQnIChwzB00BCHDscfyuypyrek+NMqYih1CzjSlm3VMuQj2PmBEofa9hMeqgNAOJOxFd2Lrfh+7EX3YvYWXGFJ85YpJYG+ViZOvcPkqXfw9zSpTckpJf3Rz5O49j6chbWXpJeBqnw2du4c/e+9x+ChQ4RnZ7ElJZH76KNk3XcfiRUVsSiKmf5RWn52kJafHcI3OI4jNZGaLzxG6XP34Ej10vDieb771L8wXDeIM9XF9t+8l/Vf2IQ7Q5chv9swmU2kVqSTWpFO7SfWARAOhBmuG4xFH/Wf6qX/9IihuSaRkJuPN9+N3SOJRKbofv88rS9/AMwJSNmkVG8mf+dzOLxWRHSGmc52ptra6H377ZiZtrBY8BQUGBFIJSQUbyPlvk9gcTqJhkMEBzvx9zbj72nG39vMbMspJo69Ee+7M2FeBFIpjtxyHNklmJ0eLGllWNLKFmyrlJLodD/h4SYjCkmJScHWd/Gf+cG8nWLFnFI8LwppTkwqjae0XbojwVOoWvZDC8dJCYFRJRxNty4UlPrehpZvLpzekREXjhLntYSyZRO3NRqNRnNnocUijUaj0WiWQkZVdbLBQ3FxaPwCIFU6mXeNKlefvlO1xPJlNZ+V0Qjh/rME294j0PYeoZ7jEAmC2Y4tfyue2v+Arfh+Va1MXH1qloxG8XXWMXnqHSZOv0NwsAuEwFWyjuyP/iaJ6x7AlrZ0qtpMTw9977xD37vvEhgexux0krFjB1n330/y2rWYzMo3JRqO0HPgHM0vHKD34AUAsndUs+W3P07ufWvxjfk4880TnPnmCWaHZ0mrTufR//M0Vc/XYnHonyirCYvdQtaGHLI2xP2zAlMBBs/M9z/qY6p3EgBhTiK5pJikPBd2dxTpn6D73TO0vnQImDPRziG1Zj35n3wad4YbGZxkprODqdZWho4epfftt9WKhFDV2GJpbCWk7N6BLSkJgMjsFH4j+kiJSC2MH3ltgam2NSU7LiAZUUj2jAKE2YI5IRtzQjYUL0wzi/onVRSS0SIjzYSH6gk0vgEyEpvOlJiDJdVIaUuvwJKmmsnpXXqHCgGOVNXSt106PjyrhKPJJtWmjNfeN6DlnxdO68xeGIU0X0iyOK/wzWo0Go3mTkX/EtNoNBqNZo7QDAx/AINzUUMfxMvW25JV1FDRJ5UwlLbtpqRuRMY7CbS+q9LL2g8g/eMAWDJqcG35Mrbi+7Hlb0NYr+0hTUbCzLScYvLUPiZP7yM0PggmM57KLaQ99FkS192PNWnpKKjg5CQDBw7Q9847TDY1IUwmUjZupPznfo70rVsx2+PlvmeHxmn+6QFaXjyAb2gCZ3oStV96nNJn78GTk8rQ+QHe+rev0fDCeSKhCCWPlLPxK1vJ31Woq5ppYtgT7OTvKiJ/V1Fs2MzgtEpfO91L/6k+ek/2EhhXUUNWVzppVdUkZDuw2kJEp0dof/0oTT9W3kZmh42UyjxSqtdQ8Kmn8GQnIgOTTLe3MdXWxkRDAwPvvx9ff2qqEo/mopCq7iflvo8ihEBKSWi0f4GA5O9tZur8QZUeBgiLFXtmUTyNLacMR24plqR0hBCYHImYcjdhzd20YLtlJEhktN0QkebS2poJnf4uMhQ37Da5M7CkV2BOiwtIlvQKTM6FVQgXxeJS1RWT1146LjQNU81xIWlOTOp6CfyDC6d15S0hJJWC2X7psjUajUZzx6DFIo1Go9GsXvxDMHgABvarNnrC+EdfgLcGCj8ajxpKqlTRRMuMDPtValnLXgIt+4iMtgDKINde8XgstczkvvZ0tmgoyHTDESZPvcPkmfeIzEwgrHYSanaQ+eyvkLj23gXlxC+dP8TwiRP07dvH8LFjyHAYT1ER5V/8Iln33489Of5QKqVk8EQTjT98j+53TyMjUbJ31rD1332SnF1rEGYTHe+28fpvvUHX++1YXVbWfnYDG768leSSlGvfcZpViTvDQ+lj5ZQ+Vg6o4268bYz+k730n+yh72QvzW92GP5H4MkqIq0qFXe6BbPJT3hskOafvk/ke8oY2upxklKVT0p1FQWffIzEglQis+NMt7cz1drKVFsbwydOQFQtz+LxLPBBSiwtJb3mHsRcNF0oSGCgXYlHPU34e1uYbjzO+JHXYttgdieq9LXccpy5FTjyKrBnF2OyWAEQZpuKIEqvWLDtUkaJTvYSHmogPNyo2lAjodPfu0hESseSVoE5vVJVaktTrybXVZ5nVo+qzpiy4dJxwcl4FNJ8IanjxxAYmTehAHfBpUJSUiV4im+o0qNGo9Fobg36Sq3RaDSa1YGUqjz14H4YeF+9TtSrcSY7pG+HNb8LmfepCCKb96Z1JTzaRrDlHQKt7xDsOAhhP1gc2Ap24tr0BWwluzGnll5XlE006GfqwiEmTrzN1PkDRP0zmBxuEtbcS9LGh0io3oHJvnRUkpSSqZYW+vbto3//fkKTk9i8XvKfeors3btJKC5eMH1o2kfba0do+tF7TLT1Y0t0UfmpByn/yL0k5GcQCUWof+ECx79+mOG6QdxZHu79/QdZ+5kNOLw6hUVzYwghSC5JIbkkheqPKhPosD/M0PkB+k72GCJSL+37xtX0ZkFq5RpSar24vAIRncHX30vDd/cSDauIILvXQ0p1Aak15eR/7GG8pdlEZsZi4tFUayvdr79ONBgEwOxw4CkqIrG0lITSUhJLS0na/BjJ256M9TM8M2EISMoLyd/dxOj7P0WGAmoCkxlHdrEhIlXgzCvHkVeBxeOdt60mzEl5mJPysJc9HBseE5EM8WhOSLrYXNvkTldeSIZ4ZEmvVOlsVysigYqmTN2s2sUExualtDXHRaW278UjNEFVbUsohcRKJR7Nf11GjzeNRqPR3BhaLNJoNBrN3YmMwti5heLQbI8aZ/NCxi4o/SJk3quMqG9iyoQM+Qh2HCTQuo9gy14iY+0AmFOKcW74DPbSB7EV7Lzm1LI5oqGAIRDtYerMfqJBH2aPl6RNj5C04UHcFVswWW2XXYZ/ZIT+d9+lb98+Zrq6MFmtpG/bRvaDD5KyYUPMh2iO8ZZemn68n7ZXDxOeDZBSVcD2//g5Ch/djMVhIzAV4PjXD3PiG0eY7psitSqdx/7sGaqer8VsMy/RC43mxrE4LGRvziV7c9x3a3Zkhv4TSjjqO9lLx7sdBCaVUGPz2MhYt43UggQcHokMTjDd0c35f6pDRlVVQ2d6EqnVhaRUF5H3kQdIrswjMjXGZEsLU62tTLa00LNnD9FXXgHAZLOp9DVDPEooKcFdsh5PeTzlTEYjBAa7VARSdyO+7iamG44tiEKyJKXjzKtQIlJeOc68CmzpeQhT/BxaICKVxo2upZSGiNQQE5Iiw434z/4QGZyOTWdypSkRaUEkUgUmd+q17Xh7svJHWswjyT+i/N8mG2GyASYa1GvPaxANzltGCiRWLBSQEishsUyntWk0Gs0tRotFGo1Go7k7iARg5Fg8pWzwQLxKmSsXMu5TUUMZ96oy1DchpWwOKSWR0RYCLe8QbN1HsPODePRQ0S5cW7+CrfRBLMlF172OaCjAdN1hJk7sYfLsfqL+GczuJLxbnyBp08O4yzchzJe/zUdDIWX0u2cPI6dPQzRKUlUVVV/9Kpm7dmF1L6zCFA1H6HrnFE0/3s/giSZMNguFj2ym/OP3k1qj/Iam+6Y48Y/vc/ZfTxKcCpB/TyGP/M+nKHqwRPsRaW4brlQ3JY+WU/Kokb4WlYy1jtBnCEj9J3u58KM6omGVbpaY5yVjXRWJOU5sjhCRqVHGm7rofu9MbJnunFRSqwtIrS2i8OMP4C3PJTg+wlRLS0xE6tu7l+5XXwWUgOQpKiKxpCQmIrnz83FkFcHmR2PLDU+N4e9pwtetRCR/TxNTdR/EvZBsDhw5ZTgNAcmRV4EjpxSzY+H5KoTAnJSLOSn3UhFpqndBFJISkX60QEQSrlQlIKVXY8moMsSkSkz266iO5kgFx07I2LlweDQCMx1x8WjutfctaPmXeRtjAnfRpZFISZXKgFtfWzQajWbZ0WKRRqPRaO5MIgEYPgr970D/PlWtLKKMbkmqgqJPKHEo8z5wF970hwkZ9hPsOESgeY+KHhrvBMCcWoZr4+ewlT6ErWA7wuK47nVEQ0Gm6w8zcXwPk2ffMwSiRBVBtOkRPBWbrygQAUx3dNDz9tv079tHaGoKe2oqxR/9KNkPPogrO/uS6WcHx2l+4X1aXjiIb3gCd3YqG37teUqe3YnDqx4ch+sHOf71w9S/cB4ZkZQ/U8WWr+4gc92ly9NobjfCJEgpSyOlLI3aT6wDIOQLMXi2n/4TvbEUtuZXVfU1k8VEWnUeGfdvwpNhw2zyExgeYORCJ51vn4wtM6kkm9TaIlJrqyi973ESCzPwDw0uiEDqe/ddul9/XS3XasVTWEhCSUksjc1TUICnahueqniETjQUJNDfhr+7CV9PI/7uJiZOvs3ogZ/GprGl5SnhKK/cEJIqsCZnXiLSCiEwJ+ZiTszFXvpgbLgSkfrm+SE1EB5qwHf6OxDyxaYzJeXHxaP0avWaWoowXz56cVFMZkgoUY0nF44LTalIpIuFpIF3VTW3OawJl0YjJVUqnyTrQgFNo9FoNFePFos0Go1Gc2cQCcLwESUMDexTFcsiPkBAynqo+GXIekCllznSb02XpgcINu9VAlHbe8pk1urEVnQvru2/jL30QczeghtaRzQcUgLRiT1Mnn5XCUSuRJI2PqQEosqtVyUQhWdm6N+/n96332ayuRlhsZC+bRu5jzxCyrp1MYPeOS4xrI5KsndWs+33PkP2zhpMZhNSSroOtHPs64dp39uCxWll3Rc2sekr20gq8N7Qdms0txqr00rutnxyt+XHhs0MTqvUtRPKQLvxpXqC0yptyp7kIHN9NXlPp+FMNiGiU0y19dD1zmlaXjwIgNluJaWqgNTaQlJr11H1+LO4Mr34+vuVB5IRhTTw/vv0vPkmAMJiwVNQsMADyVNYiDO/Emd+JXO28lJKQuODKvqouxFfTxP+7iYmT+2N9d/sSlTV2IxUNmdeBfas4kXTUpWIlIM5MQd7ye7YcCmjRMa7CA/VqzZYT3iogWDLOxANq4lMFswppZeISGZvPuJ6ozitCYv7I8moSim+WEQaPABt3wVkfFp3ASRVq+athsQq9XqL7hEajUZzJ6PFIo1Go9GsTCJBGDmqxKH+fepBIGL8u528Hip+EbJ2Q+b9yufiFiClJDxwjkDTHgLNewj3nQLAlJiDY+3HsZc/gq3wnhuKHgJV5n66/ggTJ/Ywcfpdor4pTM4EkjYogchduSVWOelK/R07f57et99m8OBBosEgnsJCKr78ZbIeeABb4qWV0ML+IO2vH6XxB/sYb+7Fluim6tMPUvaR+0jIUw9Y0XCUhhcvcOzrHzB4ph9Xmot7/t0DrP/CJhzJ2rRac/fgzvBQ+ngFpY+rymTRSJTR5hH6T6jKa/0nejnxfnvM28hblEzWpl3klyRhd0UIT40yWtdB44/eI/odJeLYkz2k1hQZAtJWCp7/GLZEF76BgVj00VRLCwOHDtHz1lsACLMZtyEgzXkgeYqKsCVnYkvOJHHtfbE+R/wzykzbSGHzdTcxeuAFZNCIvDSZcWQVqwik/Eoc+VU48yowOxdPLxPChCW5EEtyIVQ8HhsuI0HCIy0LRKRQzwkCF16Mz2t1qaps6XMiUhWW9CrMnhsQa4QJ3Pmq5TyycFzYZ1RpmxOR6mG8TnnWzY9GsqcaIlLVQjHJXXBTU5Q1Go3mTkKLRRqNRqNZGUSCynNoLq1sgTi0Dip+AbIeVN5Djms0Xr0BZMhHsH2/IRC9TXS6HxBYczfieeB3sZU/giW9+ob9eGQ0ymzracaPvcnEiT1EZiYwOT0krntARRBVbbsqgQiUWXXf3r307t2Lr78fs8tF9oMPkvPwwySWlS3a15mBMZp+9B7NPz1AcHIGb1ku23//sxQ+vgWLQ0UhhHwhzn/vNMf//jCTXRMkl6TwyP98kuqPrsXi0D8pNHc/JrOJtMp00irTWfPpDQAEZ4IMnumj70QvfSd66NzfTv1PVBUyi9NK5vosch7fSGK2A4vJx3R3HyPn2+k9eF5VaQQ8+emk1hSqFLYN91L8iU9htlvxDw7GxKPJlhaGPviA3j17ACUgeQoLSSwrUwJSWRmeggLMDjfuknW4S9bF+i2jEYJD3fgMAcnf3cR0w9EFZtq2tFwceZU48yuM10qsSUtXJxNmG9aMaqwZ1QuGRwNTKo3NiEAKD9URaHwD/+nvxued74eUXqkikq7XD2k+FiekrFNtPjIKM10wUaeqYE7UKRGp8wUIfCM+ndmpUtjmBKQ5QSmxXBtsazSaVYf+ZafRaDSa20M0ZHgO7TM8hw7E//mdE4cyd6vIoVsoDgFEJnsJNKvooWD7AQj7ETY3tuIHsJc/ir30IUzuGy/xLKXE393E+LHXmTj+FqGxAYTVTuK6B/BueQxP9Y4rVjGbIxoKMXTsmDKrPnUKolGS16yh5JOfJGPnTsz2Sx90pJQMn2ml4Xvv0LXvNEhJ7v3rqPzUg2RsjItK/nEfp//5OCf/8Si+UR85W/PY/Z8fpeTRcoRJG8tqVjc2t428nYXk7SwE1Hk12T1B3/Ee+k700He8h5PfOBo3z85PInvzWioeeBhXsono7DhjjV0Mnmym441jAAizCW95Lqk1haStKSJ91yOUfOazCJPAPzSkBKTmZpXCduBALIXNZLXiKS5WEUiGiOTOy0OYzdgzC7FnFi4w0w5NjuDvasTX3YCvqx5/V+OCNDZLYmpMQHLmVeLIr8SWlntZcdxkT8CWuxlb7sL0scj0UDwKaaiB8FA9/tPfVem7c/Mupx/SfIQJPIWq5T6xcJx/OC4gzbWhQ0ZK29z8hrfSxdFISVU31i+NRqNZwQgp5ZWnuo1s2bJFHjt27HZ3Y9nZt28fu3fvvt3d0Gg0K5S78hoxV8q+723o2wMD70HYqLyTvFYJQ3NpZY4bF2KuqWsySrjvNIGmt1R62cB5AMzeAmxlj6r0svztCMvy/LMcGOxi/PibTBx9g8BAO5jMJNTswLvlcRLW3o/Z4brqZU13dtK7Zw99775LaHISe2qqiiJ66KFFzaoBIsEQHW+doPH7+xit78Sa4KTsuXso/9gDeHLiwtz0wDQn/uEwZ751ktBMkOKHy9j6azsXeLpoFHflOatZNsK+EAPn+uk/3kvv8W76TvQw06+uf2aHhcy1WWRvyiWlzIvNEWa2v5+R8x2MXuggNKPSxyxuB6kx/6MiUmuLcGV4kVLi6+9n0hCPJpubmWppIeJX85nsdlWBrayMpLIyEkpLcWVnI0yLp1tFfNPKA6m7EV9XA/7uBvx9bbFqbCaHG2deBQ7DQ8mZV4k9q+iqvNMuJu6HpCKQwkMNhAfriYy2LPBDsqSWYcmoNloNloxqTJ5LzbuXlfCsSmWLiUiGoDTZqP7sMAiYU7Gnr4+nss2JSbpKm0ZzR7Na7utCiONSyi2LjtNi0e1htRx8Go3m+rhrrhFTbYY49Db0vw3+ITU8sQKyH4ash5RAdIvFIQAZDhDsOEig8XUCTW8RnR4AYcKau0VFD5U9gjmtfNkeRkITw0wcf4vxY2/g67gAgLtsI0lbHidp40NYPN6rXlYkEFDRBG+9xUR9vTKr3rqVnIcfJnXDhkvMqufwDU/Q9JP9NP/kffyjUyQWZ1H5id0UP7UNizMuhI23jXLs7z7gwg/PEg1HqXyuhi2/spP0mowb2gd3M3fNOau5ZUz1TMYij/pO9DB4tp9IUAkyCTmJZG3KIXtTDok5LghPM97Uxcj5dsabeoiG1XTO9KS4/1FNISk1hdg8TpXW2tMTE4/mqrFFg8qc2+xykVhSQmJ5eSwKyZGRseT1LhoKxHyQfF0N+Lob8Hc3IUMBAITFhiOnVAlIeRU486tw5JZhsl2ff1vcD8kQkQbrCQ/WEZ3siU0jnMlYMqqxZtTEBCRLesUNe8ZdkWgYplpj4lF/wztkOceUkBSaik9nTVLCkbcWvDXGay248rSIpNHcAayW+/rlxCKdhqbRaDSa5cM/BH1749FD021quDMbch5XAlH2w8qY9DYQ9U8SaNlLoPF1gi3vIIPTCKsLW8lu7BWPq/Qy1/KZZUdmJ5k4uZfxY28y03QcpMSRX0XWh79G0uZHsSVnXtPypjs66HnrLfr27SM8M4MrJ4fyL36R7N27sSUlLTnfyIUOGr73Dp17ThANR8jZtYbKT+0ma1vVgofDwXMDHP2bgzS9XI/JaqL2k+vY/NUdeAuTl1y2RqO5PhJyE0nITaTiQ8rzJxwIM3R+ICYg9Z/openlegDMNjPptZlkb97E+mefwpUs8A0OMnqhk5HzHXS/e1otVAgSizLj/kc1xZTtuhez1UI0EmGmqysWeTTZ3EznSy8hwyqCx5qQQKIReTSXwmZPTUUIgclqx1VYg6uwJtZ/GY0QGOjA19WIv7sBX1cDkyf3MnbgBaMvJuyZqopbLJUtvxKz61Jj/YtZ6If0fGx41DdumGnXER68QGiwjtmT/wphf2ydqiqbmteSaUQhJeQsXxSSyQJJFarxLPUj28navVv5T/n64n5IE3UwcQG6X4bm/xef35oASTULRaSkGnVf1CKSRqNZQWixSKPRaDTXT2hapZPNiUNjZ9Rwa6Iyo675LSUOJVXfth/BkcleAk1vEmh8g2DHIYiGMLnScNQ8i73icWxF9y7rP9HRoJ/Js/sZP/oG0xcOIiNhbBn5ZDzx8yRteQxHVtG19X8uiujNN5loaEBYLGTecw+5jz6Kt7Z26UiAcITOvSdp/P4+hs+2YXE7KPvofVR8/AESC+IRQlJKeg53cfSvD9L+Tis2j43NX93Bpq9sxZ1xg2azGo3mqrHYLWRvyiV7Uy58RQ2b7p+i/2Qvvcd76D/Rw9l/PclJvxJ33JkesjflkP3I46ypSMFiCTLR3MXw+Xb6Dl2g7ZXDAJhsFlIq80mtLSJtbTGptRvJefhhhBBEQyGmOztV9JHRRn/yE2RU+SvZkpMX+B8llpVh83oBECYzjuwSHNklsE35AEkpCY32q8ijLiUgTTedYPzo67HttKZmx/yPVBRSJZak9KsSc0xOL7aCHdgKdsSGyWiEyHgH4YELSkQaqiPUe5JA3c9i0wiHd14amyEkpVchrMtYvVEIcOWolv3wwnH+YRi/AOPnlYA0fh66X1lCRJonIHlrtYik0WhuG1os0mg0Gs3VEwnC8OG4ODR0GGQYTHbI2AUb/0T9SE7drP59vQ1IKYkMNeBveoNA4xuE+9Q/7uaUYlzbfgF7xWNYczYhTIunal3XOqORWGWhyVP7iAZ9WJLSSX3gEyRteQxnwbVXS5vu6KD7jTfof/ddwrOzuHJzVRTRgw8uWvJ+Dv/YFM0/PUDTj9/DNzSBJz+dzb/9MUqe3oHVE38wklFJ655mjv7NIfqOdeNKc7Hr3+9m3Rc24Ui6yWkcGo3mqvBkJVD2ZCVlT1YCEAlFGK4bXGCe3fxaIwAmi4m0mgxyNpdQ/Qv34i3wEBwfZeRCByPn2mn+6fs0fO8dABwpCaSuKSJtTTGptUVk3vsAeY8/rtYRCDDd3q5S2JqamGxpYfj48VjlNntaWlxAMprVo4RlIQS21Gxsqdkkrd8d247w1FhcQOpuxNdVz+TpfbHxloQUHPlVOAuMll+FNfnqPImEyYwlpQRLSglUPxMbHvVPGh5I541IpDr8p783z1BbYE4pnueDVIM1oxpTUt7yeyE50iDrftXm4x9ZKCCNX4DuV6H5n+LTWDyXCkhaRNJoNLcA7Vl0m1gtOZAajeb6WDHXCClhsgl631St/x3DlFpA6pZ4WlnGLlWy+HZ1Mxoh1HNc+Q81vkFkrB0Aa85G7BVPYK94HHPq4iXjr3udc5XMjr7G+LE3CE8MY3J6SNr4MN6tT+Au23DNglTE749HETU2YrJaydi5k9zHHsNbU3PZ/k+09lH/3b20vXaEaDBM1vYqKj/5IDn31Cwwso2GozS8eIGjf3uIkfohEvOT2PLLO6j95DosTut174/Vzoo5ZzWrjtnhGUM46qX/RA/9p3oJzSoDZleaiywjWilrQzZ2T5SJlh6Gz7Yxcr6dqc5BtRAhSCrJJm1OQFpTRGJRFiazunaEfT6m2tpi4tFUczOzfX2xPrhycpT/UVkZSeXleIqLMdsuX8Es4p/B392kKrF11uPvasDfHzfSNnu8OPOVcDQnIllTsm/oOq4MtTtj4lF44ALhobrYPQNA2BNUJbaMhc1kcy+6zJty7vtHFgpIc4KSrz8+zZyINF9A8taAu0CLSBrNMrBa7uvas0ij0Wg0V09gTEUOzQlEMx1qeEIplH4esh9RKWb22+tjI8N+gm3v4W98g0DTW8jZETBZsRXdi2v7L2MvfxRzQtayrzc0NsD4sTcYO/Iagd4WVcmsdhfJ254kYe29mKzXXjFtqq2NnjffpO+994gYUUQVX/4yWQ88cNkoIikl/Ufqqf/OXvoOXcBst1Ly9HYqP/kgSSULK6GFfSHOff80x79+mMmuCVKr0nnir56l8tkaTJbFqyJpNJqVjyvNTeljFZQ+VgEoQXikYSiWutZ3vIfWN5sAECZBWnUG2ZtyKP3kJtIqUwhNjzFyroOR8+10vXOKlhcPAkb1teqCmHiUWltEck3csyg0M6NS15qaVPramTP0v/uuWo/ZjKewkMTycpIMEcmdl7fAfN/scOMu24C7bENsWDTox9/TpEy0O+vwddYztOdbcQHJnRgTkBz5lTgLqrGl5V61gCSECUtyEZbkIqh8Mr7ewPQ8LyQjCun8T5An4obV5uQiFYGUWYM1sxZLZi2mhJxr+KauAUcqOO6DzPsWDo+JSPMEpN7XoeWf49NYPEZlttqFvkhaRNJoNNeIjiy6TawWpVKj0Vwft/QaEQ3B8JG4ODR8RJW5tyaqamU5j6mWWHpr+nO5rgZnCLbsxV//KsGWt5HBGYQ9EXvpQ8p/qPRBTPaEZV9vxD/D5Ml3GDv6GjONx0BKnMVrSN72FEmbHrmmSmbxZfrpf/99et56i8m5KKJ77lFRRNWXT1uLBEO0v3GM+u/sZaKlF0dKAhUff4Cyj96Hw7vQZ8g/4efMN09w8htHmB2eJXtLHtt+bSfFD5chTPrBYbnQ93XNSsY3Okv/yd64efbJXoLTqjKaM9VF9uZccrbkkb05F1eKmfGmbkbOtzN8ro3xph5kRHkYubNTSVtbROqaYtJqi0iuzMNsi0ck+kdG4gKSISKFZ1Xal9nhIKG0lKSyMhWFVF6OI/3KXkVzldh8nXWGiFRPoLcZGVHeTSanB2d+Jc786lgEki0tb0FE5fUgpSQ60U1osE6lss1FIY22xaYRTi/TtlzSK+/BYghIltRyhPkWR2kGRi/1RBq/oAy357hYREpeA9414MrVIpJGswir5b5+ucgiLRbdJlbLwafRaK6Pm36NmGyZl1q2F0KTIEyQti0uDqVtA9PtT0uK+sYJNL9FoOE1Aq3vQtiPcKXiqHgCe9VT2ArvQZgvn+5wPchImOn6I4wdeZXJ0+8iQwFsabl4tz2Jd+uT2DOur6JbLIro3XeJ+Hy48/LIfewxsnfvxppweaHLPzZF00/ep+mH7+IfncJblkvVZx6k8LEtCx7YAGZHZjj5f49y6p+PE5wKUPRQKVt/dSe52/OX349Do+/rmjuKaCTKaNMwvcd66DvWTd/xHsZaRwHlfZS+JpOczUo8ylibQWhyXIlHZ9sZOd/O7MCYmtZqIbkiNyYepa0txp2TGrvGyGiU2b6+mHA00dTEVGtrrAKbLSlJ+R4Z4lFiWdlloylj/Q8FCfS14uuqj4lI/p5mZFgJYCaH2xCQqmJeSPaM/GXxqlNRSHWEB5SANNp8CKe/N16RzWzDklaBJbM2FoFkyajB5Ljydi07cyLSxSlt80Uka5IhHK2NC0jeNSq6SaNZxayW+7oWi1Ygq+Xg02g018eyXyOCE8pvaE4gmmpRw92FkPu4EoeyHrrtqWVzRGeG8Te+TqD+VYIdByAaxpSQjb3yKRyVT2LN37asBtVzSCnxd9UzduQ1Jo69SXhqFLM7kaRNj+Ld9iSu4rXXJbREgkEGDx6k+/XXmWhowGSzqYpmjz1GUlXVFZc50dZPw/f20vbqESKBEDm7aqn69ENkbq28ZN7p/imOf/0wZ/71JGF/iPKnq9j267vIWJN5zf3WXD36vq6505kdmaHveK8yzz7eTf/JXsJG5TVPdkIs+ihnSx7uDDvjjV0Mn2tn5FwbI3WdRPxKqLEne1TlNUM8SqkpxDbPXD9Wga2piQkjAmmmuztmoO3MzFzgf5RQWorZfuX0XhkJ4+81BKSueuWD1NOEDAUAMNldOPLKcRZUx4Qke1bRDd9L9u3bxwP330tkpJXQ4PmYiBQaOKfSow3M3gIsGbWxCCRrZi2mxJzbI94HRpVoNHYOxs/B2FkYPwvB8fg0zqxLBSRvLVgX927SaO42Vst9XXsWaTQazWojGoGRY9D7hhKHhj4AGVFh6FkPQvVvGqll5Ssm/Dwy2UOg4XX89a8S6lapcObkIlzbfhFH1VNYstcjxM3x1gmO9jN+9HXGj7xGoL8NYbGSsOZevNueJKF2FybL9UVYzfb30/Pmm/Tu2UNoagpXdjblX/oSOQ8+eMUoIiklA0cbqPvO2/QdVH5ExU9to/JTD5FUfKkX00TXOMf+9gPOf+800UiUqg+vYduv7ySlLO26+q7RaFYXrlQ3pY+VU/pYORCvvNZ7rJu+Yyp9renlegDMDguZ67LI2ZJH0YefYvsfZhOemjDEo3aGz7fT+/45tWAhSCrKVNFHa1QKW1JJMYmlpeQ98QSgDLRj1deamphoaGDg/ffV7CYT7oKCmHiUWF6Ou6AAk3mhyCPMFpz5FTjzK4BnASUgBfrb8XXWx0Sk0QMvIIMqCkjYHDjzKhaksdmzihDma3tEEiYLlvQKLOkVUPthtW4pic4MGuLReULGa6DxdUAJY8LhXeCBpNLYym5KtOwC7CnKD2m+J5KUKuJo7JwSjuaEpIavQ8QXn85TEheQkteq18QKuNl91mg0t5xliSwSQnwW+F1AAFPAV6WUp4UQ6cBPAS/wB1LKF4zpXzSm6b3SsnVkkUajWY1c1zXCN6jEoZ7XlEAUGCFWtWwutSx9x4r6QRcebSPQ8Cr+htcI954EwJJehb3yKexVT2JJv/aS81dLxD/L5Mm9jB1+hZmm4wC4Stfj3fok3s2PYHZdX8qAjEQYPn6c7tdfZ+TUKYQQpG3bRt4TT5Cydu0VfTQiwRAdbyo/ovFm5UdU/vEHKP/IvTiSLxWYxlpGOPLXh6j/yTmESVDziXVs+ZUdeAtXRpTYakHf1zWrgem+KXqPq7S1vmM9DJztIxpSfkZJRcnkbM6NRSAl5LoZa+iKCUgj59oITMwAYHHaSKkpJK3W8D9aW4wzdeE1NzA+vsD7aLKpidD0NAAmm42EkpKYeJRYVoYzK+uq7hcyGiEw0BEXkDrr8Xc3Eg0obyVhtSsBqbBGRSEVVmPPKFgyAulaz/1ocMaoxGaISIMXCA/WXZTGVq6ij2KRSDWYHElXvY5lJRqB6TYjAmleJNJkg/oTCkBYIKny0kikhGKV4q7R3IGslvv6TU9DE0LcA9RJKceEEE8Cfyil3C6E+BowCvwEeFVKuVsI8SFgs5TyD69m2Vos0mg0q5GrukZEIzB8WIlDPa+rSCIARwbkPgG5T6rKZY6VE1kipSQ8VK/8h+pfJTxUB4Alez2OyqewVz6JJfXmGWnLaJSZ5hOMffAykyffIRr0YUvPx7v9KZK3PoEtLfe6lx0YG6N3zx563noL/9AQ9pQUch97jJxHHsGRemXvB//4NM0/3k+j4UeUVJpD1WceouixLZjtl0Y2DV0Y5MhfHaDxpTosdgtrP7uRzb+8nYSc2+CLodH3dc2qJOwPM3i2XwlIx7rpPdbD7JAShKxuG1kbc8jZosSjzI05hKemGD7fzshZFX003thNNKwEB2WeXRxryRV5mCxxgUZKia+/PyYczfkfRYMq/c3q8cSEozkPJLvXe1XbIaNRgkNdzHbU4euqw9dRh7+rgWhQRdSY7C4VfWSIR6oKmzLRXo5zX0bDREbbYtFHKhJpYRqbKSl/QQSSSmO7+kpwy04kAJONl0YiTccNwLG4IKl2oYCUvFaluK2QqGaNZilWy339pqehSSkPzvv4AZBnvA8BLsAORIQQFuA3gQ8tx3o1Go1m1eHrh5550UPBMcOYegds+GPIexJSNq6of/KklIQHzuGve5lAwytGJRmBNX8bnkf+EEflU5iTrl+kuRoCQ92MH36VscOvEBrtw+Rwk7T1cZJ3PHPdPkSgtm38/Hm633iDwUOHkJEIKevXU/GlL5G2dSsmy5VvsxPt/TR89x3aXj1MJBAi+54aqj79EFnbFvcy6j/Zy+G/PEDrm03YPDa2/upONv3CNlxp2kdCo9HcWiwOCzlb88jZqn76SymZ7JpQqWvHlXn2kb88iIyqP6dTKtKMqmuVbPvwQyTmJjLW1M3w2VaGz7YzeKqZjjfVHx9mu5WUqoIFApIrOxtXdjZZ96n0qWgkwsx8/6PmZtp+/GOIqmgnR3r6QgPt0lIsTucl2yFMJuyZhdgzC0neplLj4hFIdfg6LjDbWcfI/h8j9xoeSE4PzvwqXMLDRGIEZ2E11pTs67qfCJNFRROllUPt87F9uXga2xvE09iSsGRclMaWVn7z09gAzHYl/CSvBT4dHx6aNsy050Ui9bwGzf8Un8aeYghH64xlrFOfrZ5LVqPRaG4fy25wLYT4HaBKSvkVIUQS8B0gE5WmVgtMSin/+QrL+EXgFwEyMzM3f+9731vWPq4Epqen8Xj0BVGj0SzO3DVCyAiJgQuk+A6T4j9CQrAJgIA5hVHHNkad2xhzbCZsXmHRJFLimGknYeQwiSNHsPkHkJiYSaphKnUrUylbiNi8N7cPIT/27rPY249hHW5DIghllhMo2kwwdw3cQGljGQgg6+uJnjkDo6NgtyNqajCtXYtIvnL6l5SSYMsQ0+81EqjvA4sJ16ZC3PdVYM1c/Lucrpug/4Vups5NYHZbSH8im/THs7G4tf3gSkDf1zWaxYn4I8y2TDPTNMVM0yQzTdNEZpRxttljwV3mwV2eiLs8AVepB/wBgp0jBDtUC/WMQ0SJP+ZkF9aCVGyFqdgKUrHmeBGWhX+OyFAIBgeRAwOxxsSEGikEpKQgsrJijZSUK6YHx4hGME8OYBnrxjLajWWsG/N4L0Kq/kVtLsLJeYRT8ggn5xFJziPqTFrWKBoR8WOf7cIx0xFr9tkuTFEVYSWFmYArH7+7CL+7EL+nGL8rH2l2LFsfrgdrZBx3qB13sA13qA13qBV3sA2LnI1N47PkMG0tYcZWwoy1hGlbCT5LDojlL2ih0VyJ1XJff/DBB29NNTQhxIPA3wL3SilHLhqXDPwA+DDwZ0Ay8H+klIcut0ydhqbRaFYds73U7/0Lqjxt0PeWqk4izJB+Tzy9LGX9iooegosiiOpfJjLWDsKMrehe7NXP4Kh4ApMr5eb2IRplpvEYYx+8wsTpd5BBP/bMQrw7niF56xNYk2+sIthUWxvdr71G//79RPx+EsvKyHviCTLvvfeqqvVEwxE695yg7ttvM9bQpfyIPnY/5R+5D0fKpX5EUko63m3jyF8eoOdwF640F5t+aTvrv7AJm+fK69PcOvR9XaO5OmRUMtY6Qq9hmt17rJvRxmEAhEmQXpNB9pa8mPeRO9PFeGMPw2fbGD7XxvDZNmYHxgAw2SwLo4/WFOPK8F6yzuDkZDz6qLGRiaYmwob/kdnhiEUfJVVUkFRRgT3l6u9V+97ew7ayHBWB1GmksPW1qlRxwJKQEktdm/NBsiYub1l6GY0YaWznVCRS/1mVxuZT+wlhwpxSijVrDZbMNbFXk9O7rP24ZqSEmQ4YPQNjZ4x0tjMqvc0Q4DA7VRW25HULI5FWUIq95u5ktdzXb4pnkRDiV4FfMD4+BaShzKyflFI2LjL9nwI/A8qBIPAj4CdSyscvtx4tFmk0mrueaAgGDxneQ6/B2Gk13JmthKHcJyHnEbjZkTjXgRKIzuOve+m2CUQAgcEuxg6/wvjhVwmN9WNyevBufpTkHc/gLFpzQ54OkWCQgQMH6Hn9dSYaGzHZbGTddx95TzxBYlnZVS0jNOOn5WcHqf/uXmb7x0gsyqTqMw9T/OS2Rf2IZFTS+lYTh//iAAOn+/BkJ7DlV3aw9tMbsDivPyJKc/PQ93WN5vrxj/voP9lLr+F71H+yl9CMipRxZbiVcfaWPHK25JGxNovgxHRMOBo+28ZofSfRoIpWcmUmx4SjtLXFJFfmYbYtvG5KKfH19TFhCEeTjY1Mtbcjw2oZ9rQ0kgzxKLGigsTS0iX/EFjs3I8G/fh7mpQHkpHGFhhoV+IIYPVmxAUko1k83uXbocY2Rid7lYDUf47QwFnC/eeITvXFplE+SGuwZBkCUtZazJ4b+1NlWQj7YOKCMtIeOxNv/qH4NM7suHA095pUrdLjNJplYLXc12+KZ5GU8m+AvzFWUIAysf78EkJROZAnpdwnhFgP+FHJtpcmDWs0Gs1qwNcP3a9Cz6vQ+xaEJlU1kYxdsOm/cbQvja2P/vyKNICMCUT1LxGoWygQuXb+6i0TiCK+aSZO7GHsg1eYbT0NwoSnejtZH/51Etfeh8l2YyH3s/399Lz+Or1796qy97m5VHz5y2Q/+CDWqwxL9g1P0PD9fTT9ZD+hKR8ZG8vY+m8/Sc6u2kXTHqKRKE0v13H4Lw8yUj9EUqGXR/7XU9R8bC1mmw7D12g0dycOr5OiB0spelAVOIhGoozUD8W8j3qP99D8mnrEMNvNZK7LNryS1lD1ucexJ9oZa+xm+GwbI4aI1LnnBAAmq4XkynzS1haTvraY1LXFuDOTceXk4MrJIdt4GIwEg0y1tqoIpMZGJpuaGDykEiCEyYS7sHCBgOTOzV0yfc1kc+AqXoureG1sWMQ/i7+7AV9nXUxEmjz9bmy8NTUbZ0E1rrkIpPwqzK5LI06vFiEE5qRc5QlYEf9vPjozYkQgnSPUf5bwwDkCja/F++5OXxB9ZMlai9lbcGuNtC1OSN2s2nx8A4ZwNE9EqvsriCofKYQZEiuVcJSyzqjOtg7c+Svy95RGs9JZrmpo3wA+CnQYg8Lz1SkhxA+A35dSNgkhMoAXgCTgP0kpf3y5ZevIIo1Gc1cgozByArpfge6X45XLXLnx6KHsh8GmSuOutGvE0gLRLuzVH7plApGMRphuOKaqmZ3ehwwFsGcVk7zjabxbn8TqTb/B5UcZPX2arldfZfj4cYQQpG/fTt4TT5C89uqNsCda+6j79h7aXz+GjETI272B6s8/Qlpt0aLTR0IR6n9yjiN/dYjxtlFSylPZ9rVdVD5bg8mystINNYuz0s5ZjeZuY2Zomr5jPfQe7ab3WDcDZ/qIhlSqUnJJSsxoO3tLHillqfhHJmORR3PRR5FACABnhjcWeZS2tpiUyvxFozyDExMx4WjuNTyrPHbMLhdJZWWM2e2se+QREisqrrr62hwR3/SC9LXZzjpCI72x8baM/FjkkaugGkd+JWbH8hcziAamCA9cWCAghYcaQapUOmFPVBXYjOgja+YazKmlCNMK8MyLhmGy6VIRaaYjPo01aV4UkhGJ5F0DthXm96hZUayW+/pNSUO7VWixSKPR3LGEplTUUPcrKoLI1w8ISN8BeU+rlrx+0X+7VsI1YqUIRACBgQ7GPniF8SOvEhofxORMwLvlMZVmVlhzw/94hmdm6N27l+7XXmO2rw+b10vuY4+R+9hjV1X2HtT+GjzZTN239tB74Bxmu5WSZ3dS9emHSMhbXMQKB8Kc/95pjv3tB0x2T5CxJpNtX9tF2ZOVCJP+F/ROYiWcsxrNaiLsDzNwpi8mHvUe7cY/pkrdO7xOsrfkKgFpSx5Z67MxWU2x6KO5FLaZXmWxarKYSa7KXyAguTKTL7m3yGiU2d7eBQLSVHv7guprSRUVMf+jhJKSq/KzW7Bd0+P4uurxzaWwddYRGhtQI4XAnlmEs6AKZ0GNSmXLq7jhSNrFkGE/4aEGQv3nCBsCUmiwDsJ+NYHFgTWjOhZ9ZM1agyW9EmG5vUbaMYITqhLb6DwvpLEz6rfZHJ7iS0WkhHIw6Uhezeq5r2uxaAWyWg4+jWbVMdmsIoe6X4GBd5UfkTUJch+HvGeUQbXjytEvt+saIaUkPGh4EN1mgSjin2Xi5NuMHfxZLM0soWYnyTueJmHtfZisN+5LMN3RQddrr9H/7rtE/H6SqqrIf+opMnbswGS9Om+gaDhC1zunqPv224xe6MCe7KHi4w9Q/rH7cXgXT1cL+0Kc/e4pjv3NB0z3T5G9OZftv7GLoodKb22ov2bZ0Pd1jeb2IqVkrGVUpa4Z4tFosyEGWU1krMmKiUc5W/NwZ3jwDU8wfK49lro2cqEjHn2UlhQ3zl5bTEpVwaLRR+/s2cPG3NwFApJ/SHnrCLMZT2FhLHUtqaICV3b21VdfMwhNDC8UkDouEJ4aVSNNZhy5ZbgKanAW1eAsrMGRVYwwL3/Uj4yGiYy0GD5IZ5WQNHAeGZg0+mLBklYeiz6yZK7BklmLyb5CKkpJCTOd83yQ5gy1Gy4y1F6jCokkrzde18UivzWrh9VyX9di0QpktRx8Gs1dTyQIg+/H08smDdu2pGojeugZyLgHTNdmSnwrrxFSSsJD9QQuvIi/7qWFAlHVMzgqn7xlApGUktm2s4wd+hkTx/cQDcxizywkeeeH8G57CmvSjVc/iUYiDB05QverrzJ27lzcsPrJJ0ksLb3q5YR9AVp+doj67+5lpneEhPwMqj77EMVPbcfisC06T8gX4uy3TnL07w4xOzhD7vZ8dvzWveTfW6RFojscfV/XaFYevtFZo+qaEo/6T/cR8SsT66RCL9mblXCUuzWP1Mp0ZDTKeHNPPH3tXBvT3apSm4o+UpXX0tcVk7auBFe6d9FzPzA2tjB9rbmZiE9FPVncbhV5NM//yJZ4belQUkrC44PMdlxQ6Wsd5/F11hH1qQpvwubAmV+Js7AGV2EtzsIabGm5N+U+I6UkMt6pUtf6zxIyqrFFZ+bMqAXmlBKs2esMI+11qhKbYwWlgEX8MF6nCoyMnYHR0zB2CgKj8Wk8xfPEI+PVU6y9kO5iVst9XYtFK5DVcvBpNHclvkGVVtb9CvS+qcypTTbI2q3EobynIaHkhlZxK64R4dFW/BdexH/hZ0SGG5VAVHiPiiC6hQIRQGhyhPHDrzJ26CUCA+2YbE6SNj9C8s5ncZWsW5YfuMHxcXreeovuN94gMDKCIyODvCeeIOfhh6/ph7pvZJLGH75L04/2E5ycIW1tMdWfe4Tc+9dhMi/+b3FwJsiZb57g+Nc/YHZ4lvx7Ctnxb+4lb2fhDW+XZmWg7+sazconEowweLbfqLqmBKTZoRkA7Il2sjfnxgSk7E05WF02/KNTKm3tTCtDZ1oZrYt7H7mzU4hmuql5eAfp60rwludislyawiQjEWZ6ehYISNOdnbH0NWdmpoo8mpe+drXRrbF1RKMEh7oMAcloXQ3IsKoqZ3Yn4iyowVWkxCNnQfWy/AGzFJHpAVWFrf9M7DU6GfdjMqcUY8lahzVrLdastViy1mJyrKDoHSlhtkcJSKOn46+Tjag6TYA10UhfmyciJa8Bi+u2dl2zPKyW+7oWi1Ygq+Xg02juCqSE0ZPx9LLho4BUZVvnooeyHwbr8oVZ36xrRGSiB3/dS/gvvEC4/ywgsOZvx1HzLI6qpzG5b94Px4uRkTBTFw4xdvBFJs8dgGgEV8k6knc+S9Kmh5fFxFNKyWRTE12vvsrAgQPIcJiUDRvIf+op0jZtQpiv3pdgsmOAum+/Tdurh4mGIuTdv47qzz9C+rqlhcHgdIBT/3ycE39/GN+oj4L7i9n+m7vI215ww9umWVno+7pGc+chpWSiYzzue3Ssm5GGIZAgzIL0mswFqWsJOYlEQmHGm3oYOtPK8JlWuo/WEZ1QUUNmh43U2kLS15aQtq6EtDVF2JdIR474/Uy2tCwQkAIjKm1OWCwkFBWRVFkZiz5yZmZe8x8nMhLG39vCbPt5fJ1KQPL3tsZSrqzJmUb0UU1MQDI7b17KWHRmWBlo958l1H9WCUgT3bHx5uQiVYkte53hg7QWkzP5pvXnugjNKC+k+SLSfC8kYYLEiosEpPXgytFRSHcYq+W+rsWiFchqOfg0mjuW0DT07THSy14BXx8gIG1b3Jw6ZeNNu/Ev5zUiMj1IoP4V/BdeJNR9FABLzkZDIHoGc2LOsqznagkMdDB26CXGDr9CeHIES0IK3u1PkbzzWRxZRcuyjkgwyMD779P92mtMNjdjdjrJeegh8p58Endu7jUta+h0C3Xf2kP3/rOYrGZKnt5B1WceIrEwc8l5ApN+Tv3TcU78wxH84z6KHipl+2/sImdL3o1ummaFou/rGs3dgX/CT9/xnpjvUd/JXsI+FUmUkJsYE45ytuaRVpXBe++/x9bq9QyfaWX4bBtDZ1oZa+hCRpQgk1iYSdq6YtLWlpC+roTEoswlPYsCo6NMNDbG2mRzM9GAKgtvS0pS0UdzAlJZGRan85q3Lxrw4etqUKlrHcr/KDhsCDZCYM8oVN5HBUpEcuSVL4tH4JL9mR1VHkh9Z4wopLNExjtj401J+Sr6KHtdLBLpVkY+XxUyCtPtMHpqoYg03R6fxp5qCEgb4iJSUjWYF09b19x+Vst9XYtFK5DVcvBpNHcUM93Q9RJ0/wz69kI0qEKMcx4zzKmfBGfGLenKjV4jor4x/A2vEbjwIsGOgyCjWDKqcdQ8h736WSzJtzb96RKzapOZhNpdpOz8EAlrdi2bEadvcJCeN96g5623CE1N4c7PJ/+pp8h64IFr+lEdjUTpee8Mdf+6h+GzbdgS3VR8/H4qPv4AjpSEJefzT/g5+Y9HOfmNowQm/BQ/UsaO37qXrA23VpDT3Hr0fV2juTuJhCIMXRiMiUe9R7uZ7ldRJFa3DXuRk9rH1pK7NY+sTbnYE+yE/UFGL3QwdLaN4bOtDJ9pIzCu/ISsCU5VdW1dCelri0mtLcLqXryCWDQSYaazk4mGhpiANNvTo0aaTHgKCkiaE5AqK6/LPBuMCmyddfEUtvbzMQNtYbbgyC3DaXgfuQprsGcVIW5ixbCobyxWhS0mII21x8abEnOV91H2WqxzAtItjIy+aoITCz2QRk+rqKSIUVHOZFWC0cUikmMFbssqZLXc17VYtAJZLQefRrOikVL9C9T1M9VGT6jhCaWQ/yzkfQgydt2Wf32u5xoRDUwTaHoD/4UXCba+C9Ew5pRiHNXP4ah5Dkt6xc3p7BIsZlZtyygg5Z5nl82sem49Y2fP0vXqqwwdVZFT6Vu3kv/00ySvWXNNYfuRQIjWVz6g7ttvM901hCc3jarPPETJMzuwOJf+Z9U/5uPEN45w8h+PEZwKUPpEBdt/814y12bd8PZp7gz0fV2jWR1IKZnqmYx5HjW+U4+/axYZlSoAuSojFnmUsyWPxHzlwzPVNWREH7UydKaNidY+kBJhEnjLclXVtXUq+sidk7rkvSs4ORlLW5tobGSysZHw7CwAFo9H+R7NS1+zuq89pVtKSWh8MCYczXZcUAbafuXvZLK7cBZU4SyowVlYjauoFmtK9k0t1BD1TxjeR3MC0hkio22x8aaE7AXpa5asdZg9t+YPvmsiGobJpou8kE4ZEewGzpx5Rtob1PuEcriJAp3mUlbLfV2LRSuQ1XLwaTQrjkgA+vfFBaLZbkCoimV5H1IiUVLVbc8rv9prhAz5CDS/jf/CiwRa9kLYjykxB0eNIRBlXptYshzcCrNqgLDPR98779D92mvMdHdjTUwk99FHyXv8cRzp6de0rODULE0/3k/D997BPzpFSnUBNZ9/lLwHNyxpWg2q0s7xvz/CqX86RmgmSPnTVWz/jV2k1y6doqa5O9H3dY1mdbJv3z52bt5J/8nemIDUf6KH4LQylnZnelTq2rY8crflk16TicliIjjtY+Rcu/I+OtvK8Ll2wjMq4sSRkhATjtLWFpNSVYDZvrjhtYxGlXl2QwOThoA03dmp/hAD3Hl5sfQ1b2Ul7ry8a/Lrm7+ewGBnzDx7tuMC/u7GuIG2x2tUXqvGWViLq7AGS8LN9RuKBqbmmWgrH6TISAtzBtQmT5aKPspcizXbEJASVuifOP6hhUbaY6dh/AJIVb0PsxO8ay4VkaxLRztrbozVcl+/nFi0PHH/Go1Gs5LxD6vqZV0/g543IDytKlXkPA75fwy5T92y9LLlQEaCBFvfxX/hZwSa3kAGZzC503Fu+AyOmmex5m5GiGsPQ7+xPi1uVp372T9YNrPqOWZ6euh+7TV69+4l4vORWFZGzde+RuauXZht1xYFNjs0TsN336Hpp+8TnvGTtb2ami88SuaWisuKWrPDMxz/+8Oc/ufjhHwhKj5Uzfbf2EVa1Z1zHGk0Go1mebAn2Cm8v5jC+4sBlco8Uj8UN84+2k3TK/UAWF1WsjfnkrMtn9yteVR99lFsbhvRSJSJ1r6499HZVrr3nQbAZDGTXFVA+joVfZS2thhXuhcAYTLhyc/Hk59P7iOPABCenWWyuTmWvjZ87Bh9e/cCYHY4SDSqrs1FINmSrlyFTJhMOLKKcGQVkbz9KbWd4RCB3uZY+tpsxwWmLhyKGWjb0nKVcFRUi7OoFmdeBSbb4il314PJnoCtcCe2wp2xYdHANOGB87Hoo1D/OYLNb8f6ZHJnYMlaY6SxGSlsCTc3KuqqcKRDziOqzREJwkTdQi+kzp9C0zeMCQQklkHyBkjdqLw0UzaAc4UKYpo7Di0WaTSau5OJxnj00NAB9SPBmQ0ln1XRQ1kPguXajSFvFzIaJthxUAlEDa8h/eMIhxdHzfNKICrYeVP9A5ZiMbPqtIc+vaxm1aD+0Rw9fZrOl19m5MQJhMVC5q5d5D/1FEkV155eN9kxQN239tD22hFkJELBI5uo/vyjpFTmX3a+mcFpjv3dB5z55gkiwQiVz9ew7Wu7SC3X/gIajUajUZjMJtJrM0mvzWT9FzcDGKlrXfQcUeLRB3+6P151rTaT3K355GzLI+fejZR/9D4A/KNTsbS14bOtNP14P/XfUaKPOzuFtLUlpK0rJn1dCd6yXEwW9TvA4nKRsm4dKevWASqtzNffv8D7qOOnP0VGlYDizMpa4H3kKSzEZLnyY6LJYsVZUI2zoBru+yigPAr9XfXMdlxgtv0cs62nmTj+5tyOwZlXvkBAsmcUXpfP0pJ9snuwFWzHVrA9NkwGZwkNnDfEozOE+88x07ovLiC50gzhaB2W7PVYc9Zj9qyACGGzTUUPpayPD5MSZnuUgDR6SlXrHTkGHT+MT+PMigtHKYaIlFCiKrVpNNeAFos0Gs3dQTQCQ4fiAtFkgxqevB7W/r4SiFI33VE3SimjhLqPqxSzupeIzg4jbG7sFY/jqHkOW/H9iNvgpxQN+pk4uZfRAy8w23LqpplVg5Fqtm8fXa+8wmxPD7bkZEo+9SlyH38cu9d7zcsbPtfGhW++Rfe7ZzDbLJQ+dw/Vn30YT+7lxZ7p/imO/u0hzn77FNFQhKoPr2H71+4huTT1OrdMo9FoNKuJhNxEKnNrqXyuFlBVM/tO9NJ7pIueI12c/fZJTv6j8t1LKvSSszWf3G155GzLZ8P9KoU7Egoz1titoo/OtDJ4qpmON5Vdh9lhI7W2kPS1JSr6aE0Rdq8HACEEruxsXNnZZBtpNZFAgMmWlpiANHr2LP3vvQeAyWYjsbR0gYBkT7m6CmRmhwt3+Sbc5Ztiw0ITw8r7qP08sx3nGT/6OqP7f6zW5fTgKqxR5tlFa3AW1iybp+EcwubClr8VW/7W2DAZ8hkCkpHG1ndmoYDkyVIeSNnrsGavx5q1HpN7BdzzhQB3nmr5z8SHB8dV5NHoybiI1PtWPI3NmmCkr80Tkby1uhqb5rJoz6LbxGrJgdRobiqhaeh9U4lD3a9AYFhVlsjcrcSh/A+B59ZW/VoOwoP1NLz252RMnyQ60Q0WB/ayh1Uls9KHENbbExHl625k9MCLjB99jahvGlt6vjKr3v70sv+wm+3vV6lme/YQnp0lsayM/GeeIfOeezBZF/dtWAopJX0fXODCN99i8HgTtkQX5R+7n8pP7L5sZTNQ/wQf/dtDnPvuKWREUv2xtWz7tZ14i1dY2V7NbUff1zWa1clynfuRUIShcwP0HOmi96iKQPKNKONqR7Iz7nu0NZ+MdVlY7OqPmZmBMYbPtCrvozOtjDV2IyNK8EgsylTRR2tV9FFiUeaSUTxSSgLDwyryyBCQJltakGElNtjT0pR4ZAhICSUl15z6HVtXNEpgsANf23kVfdRxAX9Pk/rjD7AmZ8Uij1xFtTjzqzDZb/5vHyUgnSPcd4ZQ32lCfWeIjDQT80BKzFXCUfb6WCSSyem96f26biIBGD+/UEAaPa3sGMCoxlajhKPUjSqdLWUD2BJvY6dXDqvlvq4Nrlcgq+Xg02iWnZke6H5JCUR9b6vy9rZkyHtKCUQ5j4Ptyrn3K43IRDf+Cy/iP/dTwkN1SEzYSx7AUfs89oonMNk9t6df/hkmjr/F6IEX8HVcQFhsJG54kJRdz+Mu37SsOf6xqmavvMLQ0aMIk4mMnTspeOYZEisu7yG0GNFwhM49J7jwrbcYb+rBmeGl+jMPU/rcPUuWKZ5jsnuCI391kPPfV34RNZ9Yx7Zfu4ekAu/1bp7mLkff1zWa1cnNOvellIy3jtJ7rFulrh3pYqxVlbM3281kbcghZ2u+UXUtF4dXiSlhX4CRuk6Gz7bFIpACE6qKmTXBqYSjedFHl6v0GQ2FmGpri6evNTTgHxoCQFgsJBQXxyKPvFVVONKu/4+jaNCPr7sRX/s5FYHUfp7QSK8aaTLjyC5RkUdFKgLJnlV0S9Lv4ybaSjwK950mMtYeG29OLsKStS4uImWtwWRfwabTMgpTLUb62kkYO6Ve/QPxaTwlCz2QUjYqK4fb7et0i1kt93UtFq1AVsvBp9HcMFIqU7+59LKR42p4QinkP6cEooxdYLrzsmqjs6P461/Gf+6nhLqPAGDN3Yyj9sMcH03hvseeuy39klLiaz/P6MEXmDj2FtGgD3t2CSm7nse77Uks7uUV4yKBAP3vvkvnK68w09mpqpo99hh5TzyBI/XaQ77D/iAtPztI/bf3MtM3QmJxFjWff4TCx7ditl7+OBnvGOPoXx/iwg/OIEyC2k+tZ+uv7iQx784TIDW3Fn1f12hWJ7fy3J8dnqH3aLcRfdTN4Nl+omEVRZRalU7uVpW2lrstn4TcRIQQSCmZ6hyMex+daWWirR+kRJhNJJfnkbZeVV5LX1+KK8N72T4ERkeZaGpSAlJDA5PNzUSDqiKaPTU1FnnkraoioaTkmqOB5xOeGlXm2e1GBFL7BaK+KQBMdhfOguoFEUhW760pMhH1jRPqP0u477SKQOo/oyLBARCYU0uxZq/DmrVeeSBl1iJsrlvSt+tmtm9e9JERiTTVHB/vyFjogZSyARLL7yh7h2tltdzXtVi0AlktB59Gc11EwzD4PnS+oNpMByAgfaeRXrYyyttfDzI4i7/pTfznf0qwdR9Ew5hTy3Gs+TCOmuexJKu0udtxjYjMTjJ25DXGDryIv7cZYXPg3fwoKbuex1m0ZtkrhfiHh+l69VV633qL0PQ0nqIiCp55hsz77ruu0PbA+DSNP3qPxh+8S2B8mrR1JdR84VFy711zRfPM8bZRjvzVQS786Cwmi4m1n93Ilq/uICFHh2Jrrg59X9doVie389wP+UL0nzR8j45203e8h+BUAABPVoJKW9uWT87WfNKq0zGZ1b0wODWrKq6dbmXoTAsj59qJBEKAYZxtCEfp60pIKs2JzbcY0XCY6fZ2xg3xaKKhAf/gIKCijxJLS0mqqlIC0jV4Hy2GlJLgYKchIKkIJH93IzKiUuUsSem4iuZVXyuoXtZqrJcjOjNCqF+lr4WNFLbodL8aKUxY0iqUcGR4IFkyqhGW5asMd1MIThpV2E7FRaTx8xBVxwoWNySvWyggJa8B8wrfrqtktdzXtVi0AlktB59Gc9WEZ5X/UOcLKs0sMAomO+Q8BgXPQd6H7qjy9vORkRDBtvfwn3+BQOPryNAspoRsHLXP46h9HktG7SVCzK26RkgpmW0+yeiBF5k4tRcZCuAsqCL5nufxbnkMs3N509+klEzU1dH58ssMHT6MBDK2byf/6afx1tRclyA1MzBG/bffpuXFA4R9QXLuXUPNFx4lY0PZFecdbxvl8F8epO7HZzFZzaz73Ea2/MpOPJm3J+1Pc+ei7+sazepkJZ370UiUkfoheo520Xukm57DXUz3q0gcm8dG9ubcmHF21sYcrC71x0w0HGGssZuh0y0MnVapa77hCQCsbgepa4pJN6KPUtcUYXVdXgwIjI7GhKPxhgamWlqIhpTA4EhPj6WuJVVWklBcfFWV15bc5lAQf3cjsx3nYybawaEuNVII7FnFhoC0BmdhLY6ckmUtxHE5IlP9qgJbzAPpNHJ2RI00WbCkVxn+R0YKW3olwnz9kVi3hEgQJi4sTGEbOwUhdZwhLOCtNvyP5ryQ1oM9+TZ2+vpYSef2zUSLRSuQ1XLwaTSXxT8C3S9D50+VUBTxgc0Lec9AwYeVUGS9Mx/apZSEeo7hP/dT/HUvIX2jCEcSjqpncNR+GGvBdsRlQndv9jUiPDXK2AevMHrwRYKDnZgcbrxbn1BRRPmVy76+SDDIwPvv0/XKK0y1tmLxeMh99FHynngCZ8b1iYDjLb3UfWsP7W+o6jFFj2+l+vOP4C3NufK87WMc/osDMZFo/Rc2seWrO3Bn3JnHm+b2o+/rGs3qZCWf+1JKpnom56WudTFcPwQSTBYTGWuzlOeR0dzpnth8M70jDJ1pZeh0C8Nn2hhv6VWpayaBtzyP9HUlKn1tfSnuzMsLAQu8jxoaGK+vJzCiRBOTzUZiWVnc+6iyEtt1VDudT3h6HF9HHbPt5/B1XGC2/RyRGSV+CasdZ0EVrqI1KgKpsBZrStayR08vhpSS6GSvkbp22jDSPoP0j6sJzHYsmTVYDQ8kS/Y6LGnliJVutSCjMNV2kZH2SfD1xafxFC30QErZBK6cFZ0lsJLP7eVEi0UrkNVy8Gk0lzDdDp0vQtcLMPCeusG48qDgedUy71fVGe5QwkMN+M//FN/5F4hOdKlKZuWP4qj9CPaSBxCWpY0k53MzrhEyGmW64QijB15g6sx7yEgYV8l6UnY9R9KmRzDZlj9sODA6Svfrr9P9xhuEJidx5+eT//TTZD/wAGbH9a1v8FQzF775Fr3vn8PssFH2/C6qPvMQ7qwrh7aPt49x5C8PqHQzq5n1n9/Ell/RIpHmxtH3dY1mdXKnnfv+cR99x3uUafaxLvpP9hIJqCpk3uIUcrcp36OcLXkkl6bERJTgtC9mmj10uoWR8+2EfcqryJWZTPr6klj6mrc0B5Pl8ubT/uHhWOTRREMDU62tscprzsxMJR4Z6WuewkJM5us3s5ZSEhrpNXyPVASSr6sBGVb9tySkGL5Ha3AVr8FZWHPL0teklETGO+P+R32nCfefRQaNimVWJ9bMNViz16kIpKz1mFNLLvuH44rBNzBPPDJeJ5uYqy6HIwNSNynhaO7VU7RiBKQ77dy+Xi4nFq1wmVKj0dzxSAljZ1R6WdcL6mYB4F0Da39PCUQpm1bMjeF6iEz0qEpm539CeLAOhAlb8f047v9t7BVP3rZKZnOExgcZO/QSo4d+RmikD7M7iZQHPk7KPc/hyC65KeucaGyk65VXGDhwABmNkrZlC/lPP03KunXX9e+djEbpOXCeum++ydDpVuxJbtb+4tNUfOx+7N4r79+LRaKNX96qRSKNRqPRrDocXifFD5dR/LBK1Q4Hwgye7Y9FH7W82cT5758BwJnqImdrHrlb88nZlkfm5kpydtYAKnVtvKmHoTMqdW3wVAsdb6oiJBaXnbQ1xYZ4VEJabRFWj3NhP9LScKSlkblrF6AikKdaW5mor2e8oYHRs2fpf+89AMwOx4Loo6TKSmyJV+8pKITAlpaLLS0X75bHjf6HCPQ2G5XXzuFrP8/U2f1zM2A3qq+5itcY1deKr+h/eD0IIbAkF2JJLsRR8ywAUkaJjLbGqq+F+s4we+o7cPQf1Tw2D5astUYFNiUimb2FtyQ66ppwZkLu46rNEZpWPkgjJ2H0BIycgN7/CVIJhdi8C8Wj1E13vZH2SkZHFt0mVotSqVmlRCMweECJQ50vwHQbIFTVsoLnVRWzxCv7yaxkVCWzV/Cff4FQ1wcAWHM34aj5MPbqD2H2pN/Q8m/0GiEjYabOH1RRROcPgozirthCyq7nSVy/G5P12g2kr0Q0FGLw0CE6X3mFycZGzE4nOQ8/TP5TT+HKzr6uZUZCYTreOEbdt95ioq0fd3YKVZ99mNJn78HiuPI2jHeMceQvD3Lhh2e0J5HmpqLv6xrN6uRuO/ellIy1jKjII8M4e6J9DACLw0LWxhwlIG3LJ3tzLvZER2y+2f5RwzRbRR9NtPQioyp1Lak0J2aanb6+BFdWymXFDSkl/qGhWOpaLPooqqq/uXJy4qlrVVW48/IQNxB9BKrQx2zHBWbbzjHbdg5f+zkis5MAmBxuwzh7TcwDyZJw63x4ZDRMZLiZUP/puIg0cAEiytBcOLyGefYGLDkbseasx+zJvGX9uyEifhg7FxePRk6oP5qjatuweFT62nwBKan6pldCvtvO7aXQaWgrkNVy8GlWEWEf9L6lBKKulyAwbBhUPwL5z0P+h9Q/DHcwMuwn0PQW/nM/IdDyDkRDmFPLcNR+WBlVJxct27qu9xoRHOll9OCLjB16mfDEEJbEVJJ3fIjke57Fnp63bP1bsM7xcbrffJPu118nODaGKzubvKefJuehh7A4nVdewCKEfQGaXzhA/bffZnZwHG9ZLtVfeITCRzZfMbQdYKJzXEUS/fAswixY97lNbPlVLRJpbh76vq7RrE5Ww7k/Mzg9z/eom8Fz/ciIVIVqqzOU59G2fHK35pOQG4/4CU37GD7fHjPNHj7XRnhWCQDODG9MOEpfV4q3PPeK9/dIIMBkc3PM92iioYHQpBJzzE4nSRUVC6KPrO4bSyWLVV9rV+LRbPs5/D3N6k9RwJaWp9LWjAgkR245Jsuts1KQkRDh4QZCvXMV2E4RHqwHqfpnSsjGmr0Ba45qlqx1mBx3SJXXaAjG6+IC0ugJlZ0QnlHjzQ6jEpshHqVuUlkL5quze7gaVsO5DVosWpGsloNPc5cTGDUMql+A3jdURTNrEuQ/owSi3MfBmnC7e3lDSBkl1PkBvnM/IVD/MjIwhcmThaP2ORy1H8GSeWkls+XgWq4RMhJm8ux+Rg+8wHTdB4AgoWYnybueI3HNvTet6sdUWxudL71E//79yHCY1I0byX/6aVI3brzuUO3g5CwNP3yXxu+9Q2BihoyNZdT83GNk77y6SmmLikS/sgNP1p19HGpWPvq+rtGsTlbjuR+cCdJ/ooeeo930Hu2m73gPoRnl/5OQm0jutnwVfbQ9n9SKdIRJ3b+j4QjjLb2GaXYrQ6dbmR0wopacNlJri0hfX0rauhLS1hZj81z+DycpJb7+/gWV16Y7OsCIPnLn5y8Qj9z/P3v/HR7Vfeb//88zRZpR770jkISQ6L13TLUBA+6JvXHi2ImTONn4m03x7v6StTd2qrOfbDbuiQ0Y08EUF9ERVQIJCURR773NSFPO74+jCDtulJFGwP24Lq7EkjjnllAZveZ+33d09E0fJXN2W7GUFvSGR51XzmJvqQd6hmfHplydfZSYgTEgrF+Ph6k2C7aaPGyVOVqAVHkaR1Nx7+v1wcna8bWokVqAFDb0mudpup3TAW1Fnz7C1ngKupu11ysGCBx2dYB28ChtE5vxxkLDO+VrW8KiAehO+eQTt6GOCq17qGQj1OzTnr3witaOlsXdow2o1rv+iFN/s9ddwJL3Htb8jThbK1GMXnimLsQ0bAUe8ZNRdDfX6vxVruV7RHdDVU8X0VbsLfUYAsIImriUwElL8QiK6JO6VIeDuhMnKN22jeb8fPQmE5EzZhC7cCHesbE3fF1LfQuFb39I0caD2Du7iJ6awdBH5hGaeW0zlVpKmzn2x8OcW38GRa+Q8eBIxn57ooREtzmbzUZ5eTlWq9XdpWC1WjHd4ND2vmIymYiJicFovHWXBggx0MljenDandQV1GrH1nq6jzpqtAHNpgBzb3AUPS6WsIwI9B5XH0N11DRp4VHP8bXmonJUpwqKQsCgyN6h2aGZSXhHBX9l8GK3WGgtKvrU8TVbu1aLwdv7avdRair+gwdj8PK6qfddVVVszbVYrpztCZDysZQWXB2e7R/aO/fIKyEdc1waOs8b67q+UU5LE7aqM9gqT/cGSM6OOu2VOqO2gS1yuNaBFDkSffCgPn+c6zKqqi3P+WR41HASrD3vn6IDv5R/GqQ9Ejz8v/LSd8rXtoRFA9Cd8sknbhOtl6B0o/anTpvPg38qxC3XZhAFj74tBs852mu0QdVn38NekweKHo+k6ZiGLcc0eD6Kx809oLgeX/Q9oncW0cFNtJ07DIDv0EkETbkH3/RJfdZFZLdYqPzwQ8p27MBSXY1nSAixCxcSPXcuRp8bP9rVVl5HwVt7ubw9G9XhIG7uaNIfmUdAcvQ1/f2WsmZtJtE/QqIHRjL2SQmJ7hRXrlzB19eX4OCv/gWir7W1teHrO3A+71RVpaGhgba2NhITE91djhC3LXlM/1mqqtJS0kxFthYeVWSX0XylEdDmHkWOiiaqJzyKHB2Nh/fVJxltnVYa8op75h71HF3r0J4QMIf49w7NDh0+iMAhMV95dE1VVTorK692HxUW0lFWpoUMioJPfHzv3CP/1FTM4eE3/fPEabdhrSjqnXvUeSWP7vpy7ZU6Pabo5E8Nz/YIi+vf7iNVxdlWia2y5+haZQ62qtzeDWyKhzeGiMye8GgExqiR6Pyi3P5z9pqpKnRW/lOAdAo6y6++je+gq+FR1HwIHvmZy9wpX9uyDU0IcX1UFZrztO6h0o3akDnQQqGRv9Q6iALS3Fujizi7O+i6sAvr2ffoLj4AqhND5HB85/w7nkOX3fSgalfpbqqh6fAWGg9vxd5ci8E/hND5Xydo0jI8gm9sePS1sNTWUrZjBxUffICjsxP/IUNIfvBBQidMuKk1tk1FFZx7Yw+lH5xEMehJWjKBoQ/NxSc65Jr+fktZTyfROi0kynx4lNZJFDlwflkXfc9qtZKQkHDrPIDtR4qiEBwcTF1dnbtLEULcYRRFISAhkICEQNJXZwLa3KOKf3QeZZdx7PeHtOHXeoWwjAiix8YSPV7buhYxLpWIcakAOB1OWi5V9g7Nrj9zmbKPTgM9R9eGJRI6fBBhIwYRPCwBo5fpM7V4R0fjHR1N1KxZANg7Omj5RPdR9YEDVOzeDYBHYGBveBSQmopvUhK66+zO1BmMeMUPxSt+KLBKu2dbk3ZsrTgfS3Eezcd30XjgPQD0Xn6Ye4ZmawFSOnqvvpstpCgKer9o9H7RmFIXAj0b2BouYavKwdYTHnUefwUcWoeUzisEQ294NAJj5HB0XkF9VuNNURTwjtb+xC65+nJLLTR+4ghbw0koeRec9s8Ni4SERUKIf1CdUH8CSt/TQqK2i2gbzKbA2N9qAZFPvLurdAnVaae7+CDWvPfoOr8L1daJzj8G74lPYRq2HEPIYHeXCIDqdFztIso/DKj4pI4n6N5n8MuY2mddRKqq0lJYSOm2bdRmZ6MAYZMmEbd4Mf4pKTd17brcS+S/vofKQ3kYvDxJvX82qffPwhzy1e3AAK3lLRz7wyHy151B0SlkPjSSsU9OkpDoDiZB0ReTj40QYqDwDvNhyOI0hizWnmzsauui6kR5b4CU++ZJTv3fMQCCkoN7O4+ix8cSMDiawCExDFk5DYDOmiYtPMq5RF3uJfJeeR9UFUWvI3BwDKEjBvV2H33e4wuDtzfBI0YQPGIEoB2x7ygvp7mggObz52kpKKDuqNZJrzMa8UtOxr8nPPJPScHD/9oes3zqnr6B+GVMxS9jqnZPp4Ou6uJPDc+uff+v2hO2gGd4wqeHZ0cm9dnjPgBF0WEIGYwhZDDmjHu1Gu1d2GsLrgZIlTl0X/wQ0GrUB8T3BEg9M5AiMlCM/XvE7rqYw7R5qtHzr76su1n7HUh8LjmG5iZ3SlubGOCcdqg92NNBtElrz1QMEDnr6hGzW3yD2T+oqoq9Jh9r3gas+VtwdtSiePphSluCadgKjLFjUQbIUTpbcy2n3v49/pVnsDXVYPANInDSUq2LKOTajmfdCKfdTu2RI5Ru3UrrxYsYvL2JnjeP2IULMYVcW8fP51FVlaqj58h/bTd1OZfwDPAhZfUMhtw7HQ+/azva1xsSrT+DoigMu38EY5+ciG/ULbLVQ/SJgoIC0tL6p8vRx8eH9vZ2Kisr+e53v8uGDRsAuO+++8jPz+e+++7DYrEwbdo05syZc13XLi4u5vDhw9x///0AnDhxgjfffJM//OEPN113f36MhLgTyWN617B32ak5U0VFttZ5VHminK5WbXOaT6SvFhz1hEfBKVeHZgN0t1uoP3uFulwtPGrIK8bRZdP+bkyINvNo+CBCRwzCL/7ajpl1NTXRUljYGx61Xr6MarcD4BUVdTU8Sk11yeBsAIel/Z+GZ+fhaNcGgCseJq1bKWEY5p7ja0b/G39sdqOcXW3Yq85g65l9ZKvKwdlaqb1S0WMIHYIxaiSGnhlIhpAUFP2tOTfvTvnalplFA9Cd8sknBiBHF1R92DODaIu24l5vgqgFEL8cYhaDZ6C7q3QZR0sF1vxNWPLew1F/AXRGPJNnYxq2As/kWSiGgTGQVnU6aC/IpvHgRlrzDoHToXURTbkHv8xpffpskq2tjYo9eyh7/326GhrwiowkdskSImfMwGC+8WeInA4nZR+d5tybe2k6X4ZXeCBpD85m0NJJGMzXtnmjtbyFY388TP66XAmJxGe4Iyz6pOrqaqZMmcLFixdvamZRVlYWL774Itu3b3dFqZ8iYZEQfUse0/cNp8NJQ2Fd78yjimNlvUOzPQNMRI25OjQ7PDPyU0OzHTY7TefLesIj7fhaV1PP3/X37g2OQocPIjA1Fr3xqx9jObq7abt4UQuPCgtpLizE1toKgMHH51Nzj/yTk9G7YOGBqqrYGiqvdh9dycNafh7VoYVWxqBIvBLSezuQzLEp6Iz9v9nM0V6LvSqndwaSrTIH1dqsvdJgwhgxDGPkiN5jbPrAW+P4+J3ytS1h0QB0p3zyiQHC1g4Vu7SAqHw72NrA6KcFQ/HLtaDoBtdKDkROaytdhTuw5L2HrfQIAMaYsdqg6rQl6MwDJwyztdT3ziKyNVZpXUQTFnPBEMm0xSv69N4d5eWUbt9O1ccf4+zuJigzk7glSwgeNeqmniFz2OwU7zzGuTf30lZWi198OGkPzyVhwdhrekAG0FrRwrE/fCIkum84Y5+chG+0hETiqi8KQu6++27KysqwWq08/fTTPP744/j4+PDEE0+wc+dOIiMj+dWvfsW//uu/Ulpayu9+9zuWLl3K66+/zqZNm2hpaaGiooIHH3yQX/ziF8DVsKi4uJjFixeTl5dHZmYmRUVFpKSk8MILL/DOO++wePFiVq5cyfHjx3n66afp6OjA09OTDz/8kIaGBh566CE6OjoAePnll5k0aRITJkygoKCAxMREHnnkEUaOHNkbHjU2NvLoo49y+fJlvLy8+Mtf/kJmZibPPfccpaWlXL58mdLSUr73ve/x3e9+95o/RkII15DH9P1DVVVaSrWh2ZU9AVLT5atDsyNGRmnh0fg4IkdF4eHj+am/21Za29t5VJdzmbayWgD0nkaC0xN6AqQkQjKS8PD56ifKVFXFUlVFc2Fhb3jUUVYGgKLX45uYqAVIaWn4p6TcVIf2JzltXVjKzvcOzu68koetqbrnvgZMMSna3KN/dB8F9/9galVVcTSXYKvM6QmRcrBVnwW7NqhcMQX0bl8z9MxA0vuE9WuN1+JO+dqWAddC3Im6mrRgqGQjVO4ChxU8QyBhtXbELHIW6Pv/2Ye+ojq66bqUpc0hKtoLji70QYl4T/shpvTlGAIHzrwl1emkvTCbxoObaD17AJwOvFPGEnH3U/gNn4HOYKQwK6tv7q2qNObmUrptGw2nTqEzGomYNo3YxYvxTUi4qWvbOq1c2nyYgrc/xFLbTFBqHFOe/xdipg9Hp7+28Km1ooXjfzxM3lotJMq4f4SEROK6vfrqqwQFBWGxWBg7diwrVqygo6ODWbNm8etf/5p77rmHn/70p+zdu5dz587xyCOPsHTpUgCOHTtGXl4eXl5ejB07lkWLFjFmzOc+hmLr1q0sXryYnJwc2traeOeddwDo7u5m9erVrFu3jrFjx9La2orZbCYsLIy9e/diMpkoKirivvvu48SJEzz//POf6izK+sTX/y9+8QtGjhzJ5s2b+eijj3j44YfJyckBoLCwkI8//pi2tjZSUlJ44oknMF7nIFYhhLgVKIpCQHwgAfGBpK/qGZpd107lsfLezqNjfziM6jyEolcITQ/vPbYWPS4Wv/hw/OLDGbR0EgCWhlbqz1ymtmfu0bk396C+5gRFISA5qrfzKGz4ILzCP/sko6IoeEVF4RUV1Ts429be3rtxraWwkIoPPqBsxw4ATKGhnwqPfBISbmhRiM7oiXdSJt5Jmb0vs7XU01mch6Xn+Frj4S00ZK0DwOAbpM09SsrAKzEDr7g0dJ59O1dIURQMgQkYAhMg/W5Amxdqrzv/qQCp4/DLoDq098sv6lPDsw2Rw9F5yjxKd5OwSIjbiaVaO1pWuhGqPgLVDl7RMPgbEL8CwiaD7vb5sldVFVvlKaxn38NasBXV0oRiDsI84n7MGSswRI4YUG2uttYGmo5so/HQZmwNleh9AgiZdR9Bk+/GMyyuT+/t6Oqiev9+Srdto6OsDA9/f5LWrCFm/nw8AgJu6tpdLR1cWJ/F+XX76G7tIGz0YCb87EEixqVe88e/raKVY388RN7aXACG3TeCcU9JSCRuzB/+8Ac2bdoEQFlZGUVFRXh4eLBgwQIAMjIy8PT0xGg0kpGRQXFxce/fnTt3LsHBwQAsX76cgwcPfmFY9EXOnz9PZGQkY8eOBcDPT/s87ujo4KmnniInJwe9Xs+FCxe+8loHDx7kvfe0jTmzZs2ioaGB1p6jD4sWLcLT0xNPT0/CwsKoqakhJibmumoVQohblXeoD4MXpTJ4kbY5rauti6qTFVRkl1J5vJwzfzvN6b8eByBwUBDR4+N6AyS/WH9iZ44gduYIQHvCqyG/pLf76MqObIre3a/dJzJI6zzKTCJ0xCD8kyI/twPb6ONDyOjRhIweDWizINuLi7Xw6Px5mgsKqDl4EAC9yYTf4MFXj66lpGD0vrEuf6N/CP7DZ+A/fAYAqsOOtfIyncVne7qPztJ2Vntf0OkxRQ/WgqPEDLyTMvql+0jRGTCGp2MMT4eRD2h12izYqvOwVZ3uCZFy6Tq/8x9/A31wMsao4RgjR2pdSGFpKIbb54nuW8Ht81ujEHeq9pKrK+5rDwEq+CZD+jNaB1HIGBggg5tdxdFSjuXsBqx5G3A0XgGDCc/B8zAPW45H0owBNUhPdTrpuHCChoMbac3dp3URDR5NxNJva11ERo8+vX9XYyPlu3ZRvns3ttZWfBISGPqd7xAxdep1r4L9Z511zRS+/REXNx7AbukmeloG6Y/MJyQj8Zqv0VbRyrGXD5P3Tg4Aw9YMZ+x3JuEXff2bRoQArSvngw8+4MiRI3h5eTFjxgysVitGo7H3wbBOp8PT07P3/9t7hpbCZzeIufIB9G9/+1vCw8PJzc3F6XRiusmZFv94HwD0ev2n3g8hhLjTePp6kjAjiYQZSYA2NLv2THXv3KOiHYXkvZ0DgE+EL9HjY4kaF0P0uDhCUkOJGJtCxFht66vT7qD5YkXPsbVLVB8/T/EuLXgy+pq14KhncHbw0Hj0np99TKUzGPBLTsYvORkWLwbAWl9Pc0FBb3hU/N57qE6to8k7NrY3PApITcUcEXFDP4MUvQFz7BDMsUMInqqNNLC3N/fMPjpL5+WzNGfvoHH/u4DWfaQdXdMCJHP8UHQefT/TUzGa8Ygdi0fs2N6XOTsbsVWf0YZnV+bQfSkL61ltoQR6D4zh6RiiRmrb16JGoA9MHFBPDN9uJCwS4lbUeklbcV+8ARq0H1wEDocRz2kBUUA63GbfOJ1d7docorPvXp1DFDcR74lP4ZmyEJ1pYHWg2NsaaTq6ncaDm+muL0fv7UfIjNUETbkHz/C+PxLXduUKpVu3Un3wIKrDQciYMcQtWULgsGE3/UO1rayWc299wJUd2ahOJ/HzRjP04XkEDIq69mtUtnL85cPkvZOLqqoSEgmXaWlpITAwEC8vLwoLCznas/74Wu3du5fGxkbMZjObN2/m1Vdfve4aUlJSqKqq4vjx44wdO5a2tjbMZjMtLS3ExMSg0+l44403cDi09ntfX1/a2to+91pTp07l73//Oz/72c/IysoiJCSkt1NJCCHEFzN4GogaG0PU2BjGPjkR1alSX1hHxbFSKrLLKM8u5fyWcwB4+v/T0OzhkQSlxhGUGkfK6pmoqkpHZUPvsbW63EtUHsoHQGc0EJQWd3VwdkYingE+n1uTKSSEiKlTiZg6FQC7xUJrUVHv1rWagwep2LMHAA9//96uo4C0NPwGDbrhJ/oMPgH4DZuC37ApgLZYxVp5SQuPev60nrnafWSOudp95JXYP91HADqvIDyTZuCZNEOrU1Vxtlb2bl6zVZzGkvsOlhPaz2bFHNDbeWTsCZF0XkF9XuedwqVhkaIoY4EjwBpVVTcoipICvA0YgW+qqnpEURQDsAtYqqpqpyvvL8RtreUClGzQ/jSe1l4WPBZGv6AFRH7J7q2vD6hOB93FB7Ge3YD1/E6wW9EHJuA97YeYh61EHxDr7hI/RVVVOi6epvHARlpzPkJ12PEaNIKwRY/jP3Jmn2+oUB0O6k6coHTbNprz89GbTETPm0fcokV4RV17kPNFmi6Uc+7NPZR+cArFoGfQ0omkPTgHn+hrH9rYXt3G8T8d4ezfTqOqKumrhzPuO5Pwi5GQSLjGggUL+POf/0xaWhopKSlMmDDhuv7+uHHjWLFiBeXl5Tz44IPXfQQNwMPDg3Xr1vGd73wHi8WC2Wzmgw8+4Nvf/jYrVqzgzTffZMGCBXj3HDnIzMxEr9czfPhwvva1rzFy5Mjeaz333HM8+uijZGZm4uXlxRtvvHHd9QghhABFpxA6NIzQoWGM+NqY3qHZlcfKe7qPSrny4UUA9CYDkSOjiBobQ/T4OKLGROMTHYJPdAhJi8YDYG1up/7MZep6AqTz73xEwVt7AfBPjOidexQ6fBDeUcGfG7YYzGaCMjMJytRmEKlOJx1lZb3hUfP589RlZ2v193QqBaSk4J+WRkBKyg2PElB0eswxQzDH/FP30SfCo6Yj22nY94nuo6Sr4ZE5Lq1/uo8UBb1/NHr/aExpWneW6rRjr7+AreK0Nv+o4jQdh34PqhMAfUA8xqiR2va1qJEYw9NRjH07p+l25bJtaIqi6IG9gBV4tScs+g2wESgGfq+q6gpFUb4DtKmq+vq1XFe2oYk7WvO5qwFR01ntZaETIX6lNoPIZ+AMbXYle90FLGffxZq3EWd7NYrJH1PaEkwZ92KMHj3g2k0dlnaasnfQeGAjXdVX0Jl9CZywiKDJd2OKTLqha17P9wi7xULlhx9StmMHlupqTKGhxC5cSNTcuTd8/v2TanMucu6NPVQeysfgbWLIiqmkrJmJOeTaA56OunZO/OkouW+dwmlzaCHRdyfhHxtw0/WJO5erN329/vrrnDhxgpdffvm6/25bWxu+vgNvGKdsQxOib8lj+ttLZ31H77G1imNl1OXVoDpVLWj65NDs8bF4hXz6MZbd2k3jOW3uUW3uJerPXMHWbgHAHOrfGxyFjhhEQHL0NS//6G5u1sKjnq1rrRcvovYcOzZHRn4qPPKOjb2pjbaf1Dv76MqZngApj+46beMbPWGTV2JGb4hkDIp022N0Z3cH9qozPd1Hp7BVnsbZVtVTqwFD2NDeo2vGqFHog5NQvmJMx53ytd1f29C+A7wHjP3Ey2yAV88fm6IoAcASYIEL7yvE7UNVoenM1YCopRBQIHwqjPsDxN0D3rfn8FJnRwPWc5uxnN2AvfoMKHo8Bs3EnPEcnoPnohj6/tmL62UpLaThwHs0n9iN2m3FHD+U6Ad/RsDouf3ybIultpayHTuo+OADHJ2d+KekkPzgg4ROmHBDGzY+SVVVqo6cI/+13dTlXsIzwIfhTyxh8MppePh6XfN1Ohs6OPH/ssl97QSObgdpKzMY/73JBMR/drOIEEIIIYQ7eYV4M3hhKoMXakOzu9v/MTRbC4/O/P00p1/RRkAEJQdrwdGEOGLGx+Eb7UfYqMGEjRpMOuB0OGm5XNU796gu5yKlH5wCwOBtImRYIqEjtI1rwenxGMyf34HuERBA2PjxhI3XOpqcNhutly71hkcNp09T1bNF0+DlhX9KSu/cI7/BgzGYb6yr5lOzj6atBMDe1qTNPrqsdR81HtlKw7712r39gj91dM0cl9ovj4cBdB7eeMRPxCN+Yu/LHG3V2CpzsFWdxl5xGmvee1hOad25iqcfnil34b/4N/1S363KJZ1FiqJEox03mwm8Cmzv6SyKA94EPIFvAo8A21RVzfqK6z0OPA4QHh4+eu3atTdd40DT3t6Oj8/nn2UVdxhVxaf7AqGd+wnt3IeXvQIVHc2m4dR5Tafeayrd+tvz7K3itOHTlIN/7X58mnNRVAdW7wSaQ6fQGjIJh8cAPJpk78azLBfTpaMYmspQ9Ua64kZgHTQRR6Drgrwv+x6hVlfjPHUK9aLWKq0MHoxu5EiUiIibvq/qVLGeKactqxB7ZTP6ADPe01PwGpuIzuPan1+wt9mo3VFJ3Z4qnN1OAieFErE8BlOEtAEL1/H39yc5eWAcwXU4HOhvMqTtCxcvXqSlpcXdZQhx25LH9HcWp91J5+V2Os630l7YSvv5NpwWbf6cR6gnPql++KT64Z3qh2e46TOdNvamTrqL67U/V+qx17SACugUjNGBeCSE4JEYgkdCMHqfawtaVFWFlhbUqirUykrUqipoaNBeqSgQGooSGYkSFaX9ceXnq9OBvqUaQ0MJxsZSDA0l6Nu1e6uKDkdANLbgOOzBcdiD43F6BbpvrqrqxMNSibn9Eua2SziMvtTF3fuFb36nfG3PnDnzCzuLXBUWvQu8pKrqUUVRXqcnLPqnt0kGfgl8F3gR8AB+pqrql+6NlWNo4rakOqH+GJS8p3UQtReDoofI2doRs7i7wRTq7ir7hKqq2CtPa8fMzm1FtTaj8w7DNGw5poyVGMMG5nEJa3UxjQc30nR0B05LG54RiQRNXU7guIXovVx/9OSfv0eoDgd1x45RsnUrLYWFGLy8iJ4/n9iFCzGFXPvMoC/i6LZxZecxzr21l/ayOvwSwhn68Fzi549Fb7z2kMjabOHUX45x+pXjdHd0k7JsKBO+P4Wg5JuvUYh/NpCOWMkxNCHuTPKY/s7mdDipL6il/Kg2NLviaCmWRu3omVeYNzHj44ieEEvM+DiCU0JRdJ8OSrpbO6k7e5n63MvU5V6iPr8YZ7d2xMw3LozQ4YMIGzmI0BHJ+ESHXPMxL1tHBy3/OLpWUEBLURHOri4ATKGhBKSl9f5x5dE1+Gz3UWdJPmq3FXBv99H1ulO+tvvkGJqiKE8C3+j5T39gbc8nbwiwUFEUu6qqmz/xV34J/BQtLPor2hyjXwEP3GgNQtxSVCfUHu45YvYedJaDzghR82D4LyB2KXjenh1EAI6WCq398+wGHI2XwGDCNGQBpsx78UiYgqIbeMsZVYed1twsGg68R8eFkyh6A34jZhE0dTneySP75Vx27zyi7dux1NRgDg9nyGOPETV79g23FX/6+l1c3HyIgr9/iKW2maC0OKa+8A1ipmde1wOHrlYrp/56nNP/d4yu1i4GL05lwg+mEpJye4aeQgghhBA6vY6wYRGEDYtg1L+MQ1VVGi82UNETHpUfKeXCtgIAPANMRI+L7Q2QwoZF4OHnRfTkYURPHgZoT941Fpb1Hl0r35fL5W3aFmBziL82NHvEIMJGJOM/KOoL5x4Zvb0JGTWKkFGjAHDa7bQXF9NcUEBzQQGNZ89SvV/bfmbw8uo9thaQlobf4MHoPW98KYvBNxC/jKn4ZWgb37TZRz2b13oCpNbcLEA76maKScErKQPvpEy8kjIxBoTd8L2Fa93wb2eqqv4J+NM/v/wTnUWbP/Gy6UClqqpFiqJ4Ac6eP9c++EKIW5HTAbUHtBX3pRvBUgU6T4heAKP+C2IXg0eAu6vsM86udrrO79TW3ZccAVSMsRPwnvAEnmmL0XkOvGfhAbobq2k8tJmmw1uwtzZgDIokfOm3CZy4BKNfcL/UoLa1UfTmm1Ts3o29sxP/1FSSH3mEsHHjUFxw1KW73ULRu/sofOdjuprbCRs9mAk/e5CIcanXFYJ1t3dx+pUTnPzfbLparCTfNYQJP5hG6FD5QS+EEEKIO4uiKAQPDiF4cAiZD41CVVVay1o+1Xl0eU8RAEYvY++2tejxsUSMiMJgMhKamURoZhI8NBfV6aTlSjV1py9S+09zj4w+ZkKHJxE6IpmwEYMISotD72H83Lp0PZvU/JKTiVuyBFVVsdTU9HYeNRcUcOmUdl1Fr8d30KDe8CggNfWGt65p1zNgjk3BHJvyidlHjXReyevdvNZ4cBMNH2ujZ4yBEXglZfYOzzbHDEHRD7wnle8Eff5RV7TfOn4KrO550V+Av/fc+4m+vr8Q/c5pg+p9WgdR6Saw1oLeDDELtSNmMYvAODBDEldQnQ66Sw5hPfsu1vPvg82irbuf+gzmjBXoA+LcXeLnUp1O2guO0nDgPdryDgEqvumTCZq6HN+hE1F0/TOLpPXSJUq3bsVx8CAlQNiECcQvXYp/SopLrm9tbuf8Ox9z4d192NotRE1OJ/3rC7QHJdehu6Ob3NdPcuL/HcXaZCFp7mAmPDOV8Iybn5skhBBCCHE7UBQF/7gA/OMCSF+VCUB7TTsV2T3hUXYph/97HwB6Dz0RI6OIHh9LzIQ4IsfE4OHtQcCgKAIGRTF45TRUVaWjqpG6nIva1rWcS1QeygdA52EgeGg8YSOSCR05iNCMJIw+n9+FrigKXhEReEVEENlz1MrW1kbL+fNaeFRYSPn771O6dSsAXpGR2sa1nvDIKzr6pjrsDb5B+GVOwy9zGqB1H1nKL/R0Hp2h83IuLSf3aLUaPfFKSMcrMbN385rBJ+CG7y2unUtmFvUlmVkkbgmObqj6UAuIyrZAVwMYvCFmCSSshKgFYLz5FeYDmb2+CMvZDVjz3sPZVoXi6Xd13X3MmAG37v4f7G1NNB3ZSsPBTdgaKjH4BhE4aSlBk+/BIziyX2pQnU7qT56kdOtWmvLy0JvNOFNTmfStb2EOc02HTmdtMwV/+4CLmw/h6LIRO3ME6V+fT1BK7HVdx2axceaNUxz/nyNYGjpJmDWIic9MJWJElEvqFOJ6DKR5PF82s6isrIyHH36YmpoaFEXh8ccf5+mnn+a5557j//7v/wgN1Y5r/upXv2LhwoUurWsgfYyEuB3JY3pxsyyNnVSeKKfiaBnl2aXUnq1GdagoeoWwjIjeY2vRY2MxBX42/LE2tVGXe5m6HK37qOl8GarDiaJTCBgc03NsTZt7ZA72u+a6/rF1rbmgoLcDydbWBoDR11c7utYTIPkNGoTO+PldTTfK1lRD55WzdFw+Q+fls1jKCrVTG4BnePzV8CgpE8/wBJfOXYI752u7T2YWCXHHc3RD1V4oflcLiLqbweinzR6KX6nNIjLc3pufnJ2NWM9twXL2XexVuT3r7mdgnv1zPIfMG5Dr7kEbst15KYeGA+/RmvMxqt2G9+BRRCx7Er/hM9AZXPvD7os4urqo+vhjSrdto7OyEs+QEAZ/7WtEz5nDwePHXRIUtVfUc+7NPVzeno3qdJIwfyxDH5mHf+L1dQDZLTbO/P00x18+QmddB3HTEpn4zFSixrhuA5wQtyuDwcBLL73EqFGjaGtrY/To0cydOxeA73//+/zwhz90c4VCCCHcxRzkxaB5Qxg0bwigHfGvOlnRe3Qt5zXtuD9ASFpo77G16PFx+IT7YAr0JXbGcGJnDAfA1mmlIa+Y2pyL1J2+xKXNh7iwLgsA39gwLTy6hqHZOqNRO4qWmgr0PH6urOw9ttZSWEj98eO9b+uXnHw1QEpNxXiTSx+MgeH4B4bjP2oOAM5uK5bSAjovn6Hj8lla8w7QdHSbdn+zL16Jw/BKysQ7MQNzQjp60+39RH1/kLBIiOvh6IaqD3oCos1aQOQRALHLIOFeiJwD+hsfCHcrUB02ui59jPXMeroufgBOG4bwdHzm/ALT0HvQ+wzcgcYOSzvNx96n4cB7dFVdRmf2IWjKcoKmLscUkdhvdXQ1NVG2cycVu3Zha2/HLzmZYT/4AWETJ6IzuObbcsvlKvLf2E3JnpMoeh2Dlk4k7cE5+ERf31Yye5edvHdyOPbHw3RUtxM7OZ7Ff1lO9Ljr60gS4k4WGRlJZKTWqejr60taWhoVFRVurkoIIcRA5OHjSfz0JOKnayMC7FY71TmVVBwtpTy7jHPrz5D7+kkAAhKDiJmgBUfRE2Lxi/HH6GUiYlwqEeO0kMdhs9NUWKaFR7mXKN935oaGZiuKgnd0NN7R0UTP0QKc7uZmmnuOrrUUFFC6bRslmzYB4B0TQ0BaWm+AZI6IuKmTBjoPE97JI/FOHkkoWnjVXVdGZ0/nUceVM9Tu+AuoKig6TNHJPbOPMvFOysAYHDVgTzoMVBIWCfFVeo+YvavNIOpuBqO/tt4+YVVPQOTh7ir7nK22AOuZdVjyNqJ2NqDzCsFrzNcxZd6LMWyou8v7Upay8zQceI+W47txdlswx6US/cC/ETB6HjrP/uv+ai8poWTrVqr370d1OAgdN06bR5SW5rIfXo2FpeS/tpuyrFwMJiMpa2aS9sBszCH+13UdR7eDvLW5HPvDIdqr2ogeH8tdf1xG7KR4l9QphNsc+x405rj2mkEjIO0/r+lNi4uLOX36NOPHj+fQoUO8/PLLvPnmm4wZM4aXXnqJwMBA19YmhBDilmYwGYiZEEfMhDjGAw6bg7q8GsqzS6k4WkbRzvPkvZMLgG+Un3ZkbXwcMRNiCRwUjN5oICQjkZCMxE8Pzc65pAVIOZc+NTQ7JDNRm3s0YhDBQ+O/cGg2gEdAAGHjxxM2fjygdc23XrzYO/eo5tAhKvbu7X3bT4ZHvomJN/UkqaIoeIbF4RkWR+CExdr9Le10Fuf1BkjNx96ncf8G7ePoF9wzNFvbumaOTUFnvL2f5L9ZEhYJ8XmcNi0gKl4PpZuhu6knIFr2iYDo9v/m4uxsxJq/GcvZ9dirz4LOiOfguZgzV+GRNANF3z/HtW6Es9tKy6kPaDiwEUtxHorRk4Ax8wiaugKv+P4Lt1RVpeH0aUq3bqUxNxedpyfRc+cSt2QJXpGum4lUm3OR/Nd2U3XkHEZfM8MeXUDK6hl4Bvhc13UcNgfn3j3Lsd8forW8hcjR0cz7zWLipibIszFC3KT29nZWrFjB7373O/z8/HjiiSf42c9+hqIo/OxnP+OZZ57h1VdfdXeZQgghBjC9URuEHTEyijHfmoDqVKkvrKPimBYelR4opnCjNvTaHOzVOzA7enwcIWmh6PS6q0OzV2jr7TuqGnq3rdXmXCL3sDbY+nqGZgPoPT0JTE8nMD0d0OZydpSV9YZHzQUF1B7Rupp0np74Dx7cO/fIf8gQDN43d3RMb/bBN20CvmkTeu7vwFp1uSc80gKk1twsABSDEXNsam945JWYgdH/+jrwb3cy4NpN7pSBWbcUpw2qPtICorLN0NWozSCKuxvi74WouXdEQKQ6bHRf/hjLmXfpKtqrHTOLyMCcsQpT+t3ovILcXeKX6qopoeHgRpqP7sDR2YpneAJBU5cTOH4heq9rH+p3sxzd3VTv30/p1q10lJXhGRRE7MKFRM+bd01nuK/le4SqqlQdLSD/tV3U5VzCM9CH1PtnM2TF1C/9Qf55nHYnBRvzyP7dQVpKmokYGcXEH04jfnqihERiwBpIw5u/bMA1gM1mY/HixcyfP58f/OAHn3l9cXExixcvJi8vz6V1DaSPkRC3I3lMLwYaVVVpvtJERXYp5Ue1jWutZS0AePp5EjU2lugJscSMjyMsIwK9x2c3/lqb26nrCY/qci/RWOiaodkAXY2NvXOPmgsLabtyBZxOUBR84uO1OUlDhxKQloYpxPXhjb2tsffYWuflM1hKClDt3QAYg6PwSszAOymTc43dTFm6GkV/e/fXyIBrIb7IPwKifxwx+0dA9I8ZRFHz7oiACMBeW4jl7HqseRtxdtTdUsfMVIed1rMHaNi/gY7zx0Gnx3/ETIKmrsB78Kh+DTu6W1oo37WL8vffp7ulBZ/ERNKffprwyZNdtiVCdTop33eG/Nd301hQildYAKOfWcmgZZMxmK7vSKTT4eT85nMc/e1Bmq80EpYRwbI3VpE4e5CEREK4iKqqPPbYY6SlpX0qKKqqquqdZbRp0yaGDRvmrhKFEELcJhRFITApiMCkIIbdNwKA1ooWKrLLqOgZmn3lw4sAGMxGIkdFET0hjpjxsUSMisZoNmIK8PnU0Gy7pYv6s1d6u48ubTn8maHZ2uDsLx+aDeAZFET45MmET57cc20LrUVFvQFSVVYW5bt2AWAKDe3tPApIS8M7Nvamt54ZfIPwGz4dv+HTAXDabVjLztN55Qwdl8/QUXSSlhO7CQDO7f8L5oR0bXB2UiZeicP69clnd5OwSNx5nDao+rgnINrYExD5agFR/L0QPQ/0A3OLl6v1bjM7sx579RnQGfBMnospcxWeg2YO6GNmALaWehoPb6Hx4CbszbUYAyMIX/ItAicu7fc20o6yMkq3baMqKwunzUbI6NHELVtG4LBhLgtdnHYHJR+c5Nzre2i5XIVPTAjjfnI/iYvGozde37dz1alyYds5jv7mII0XGwgdGsbSV1eSNG+whERCuNihQ4d46623yMjIYMSIEQD86le/4p133iEnJwdFUUhISOB///d/3VuoEEKI25JftD9+y/1JW649KdFZ30FFdlnv3KOjvzkAKuiMOsKHR/UOzY4aG4OnrycGs+enhmY77Q4aC0t75x59Zmj2yGTCev74J0Z8acBjMJsJyswkKDNTu7bDQXtJCc3nztFcUEDj2bNU79+vva23t9Z5lJZGwNCh+CUn3/STsTqDUdukljiMkFn3o6oqtsZqTuxYS4LJTueVs9TteYM6pwMAz4hEvJIyiLr3h+g8bu/fGSUsEncGpx2qP9a2mJVuhK4GMPhoM4ji74Xo+XdMQKQ67XRfzsKSu+7qMbPwYfjO/Q9MQ+9G5x3s7hK/lKqqdF48TcP+DbTkfAxOBz5pEwhe/a/4DpuMovtsK21f1tJ09iwlW7fScPIkOg8PImfOJG7JErxjXLdS3tFt48rOY5x7cw/t5fX4D4pi0n9+nbjZI9EZru/9VZ0qRTsLOfqbAzScryc4JYTFf1lO8l0pKDoJiYToC1OmTOHzjv0vXLjQDdUIIYS403mFeDN4USqDF2nhj7XFSuXxcip6wqOTf87m+MtHUHQKoenhn5h7FIs5yAudQU/IsERChiWS9uCczwzNrj19kdK92sY2Dz9vQkck9YRHgwkcEvOlj191ej1+SUn4JSURt3gxqqpiqanp3bjWXFBA/Unt2jqjEb/k5Ktzj1JTMfpc37zOf6YoCh7BkXTHjSSq54ips8tCZ8k5be7RlTN0XtHmod7uJCwSty+nHaqzeoZUb4Kuei0gil2qDam+gwIiAHvdeSxn1mPNew9nRx2KOQiv0Y9gylyFMTzd3eV9JYe14+ra+8pL6My+hMxYTdDU5XiGxfVrLU6bjeqDByndupX24mI8/P1Juu8+YubPx8P/+raOfRm7tZuLmw9R8LcPsNQ2EzQ0nmm/Xk701IzrbsFVVZVLuy9w5MUD1BfUEpQczML/uZshS9IkJBJCCCGEuIOZ/E0kzUkmaU4yALbObqpOVlBxrIyKo2Wc+dtpTv/1OABBQ0KIGR/bc3QtDp9IXxTdp4dmq6pKR2XP0OzTWnhUsf8sAAazByGZSYSN0DqPgtMT0Ht+cXeQoih4RUTgFRFB1MyZgDb2obmwsDc8KtmyheKNGwHwjosjsGfmUUBaGqbQ0Jv++Og8zfgMGY3PkNE3fa1biYRF4vbitEPNPi0gKtnYExB5Xw2IouaDof9Wpbub09KENX+Lts2sKrfnmNmcTxwzu775Nu5grbxEw4GNNB/bidPagSk2legHfkrAmHn93vppa2ujfM8eynbsoLupCe/YWNKefJKIadPQe7juY9ndbqHtowK2/Op9uprbCRs1mAk/e5CIcanXfURMVVWufHCRIy/upzavhoDEIO56eRlDlqah09/cmW8hhBBCCHH7MXp5EDc1kbipiQDYu+zUnqnWjq1ll1G4KZ8zb50GwD8+gOjxccRMiCNmYhx+sf4oioJPdAg+0SEkLRoPgKW+Res86gmPzvxlB6gqOmPPxrWRyYSOTCY0Mwmj95c/xvfw9yds/HjCxmvXdnR10VpURFNP91HVvn29c488Q0IISEvrDZBcMffoTiFhkbj19QZEPUfMrHVaQBSzpKeDaMEdFRBpx8z2YTnTc8zM0Y0hbCi+c/4dU/o9A/6YGfQMrM7NomH/e3QUnUQxeOA/eg7BU1diTkjv95k6nVVVlG7bRuVHH+Hs6iJoxAjiv/MdgkaMcGkt1uZ2zr/zMRfe3Yet3ULkpKEM+/oCQocPuu5rqapKSdZlDr+4n5qcKvzjA5j328WkLR+GziA/IIUQQgghxLUxeBqIGhtD1NgYeErboltXUEvF0VLKj5ZyeW8R59afAcA3yk/btjZBC5ACkoJQFAVziD9xc0YRN2cUAN2tndTl9oRHORc599Ze1Nd3o+gUAofE9s49Ch0xCFPAlx8t03t6EjhsGIE9iyJUh4P20tKrW9fy86k5cEB7X7y9CR4xgowf/rAPP2K3BwmLxK3J6YCa/T1HzN77REC0uCcguuuOCogA7HUXtG1mZ9/D2VGrHTMb9VDPMbNbY8OOrbmOxkObaDy0GXtLPcbgSCLuforAiUsx+AT0ez3NhYWUbNlCXXY2il5P5PTpxC1Zgk98vEvv01nXTMHfPuTipoM4umzEzhyBNSOYmQ/cc93XUlWV0gPFHHlxP1UnK/CL9WfuS4tIWzEMvbH/5jkJIYQQQojbk86gIzwjgvCMCEZ9YxyqU6XhQh3lR0spP1JK6f4rFG7MB8A73Kd35lHMxDiCBmvb0jz8vIiemkH01AzgkxvXtM6jixsPcP6djwDwT4zoCY8GEzZiEF7hgV9an6LX45uYiG9iIrELF6KqKta6ut6h2XzOHEHxWRIWiVuH6oTaQ3BlHZRsAGsNGLz+KSDycneV/cppab66zawqp+eY2WxMGavwTJ51SxwzU1WVjqKTNOzfQGvuPlCd+KRNJPj+n+A7dGK/DqwG7ZmIumPHKNmyhZbz5zH4+JCwYgWxCxfiGfjlP5iuV3tFPefe3Mvl7UdRnU4S5o9l6CPz8E+MICsr67qvV3aomMMv7qfyWDm+UX7MfuEu0ldloveQkEgIIYQQQvQNRacQkhpGSGoYI742RlsCc6mB8iNa51H50VIubC0AwBzspYVHE+OImRBPSGooik75zMY1R7eNxsKynmNrRRTvPsHFjQcB8I4K7t22FjoiGd/Y0C/t9lcUBXNYGOawMCJ7hlaLryZhkRjYVBXqj0HxOq2LqLNCG0odswgSVmv/e4cFRKrTTveV/VjOrKfrwm7tmFloGj5zfoE5fTk67/5dGX+jHJZ2mrJ30njgPbqqr6D39iNk5n3awOpQ120Su+Z6urqo/OgjSrduxVJdjTk8nJRvfIOoWbPQm1w7G6nlSjX5r++mZM8JFJ2OpCUTGPrQXHyib+zfrjy7lKMvHqDscAneET7M+uV80u8bjsFTvsULIYQQQoj+pSgKQckhBCWHkPnQKFRVpaWkubfzqOJoKRd3ngfAFGC+um1tYhyhQ8PQ6XXoPYyEZiYRmplE+iPzcDqcNBeV9w7NrjyUz5Ud2do1gv0+FR4FDIqUuUQuIL9JiIFHVaExB4rXagFRezHoPLTZQ6P/G2KXgNHX3VX2O3t90dVtZu01KOZAzCMfwpy5CkN4/8/xuVHWios07N9A87H3cXZbMMcPJebBn+M/ek6/D6wG6GpupnznTsp37cLW1obfkCEkP/wwYePGoehd25HTWFhK/uu7Kfs4F72nkZTVM0h9YDZeoQE3dL3KE+UceXE/pQeK8QrzZsZ/zCXjgZEYTPKtXYiBJiEhAV9fX/R6PQaDgRMnTtDY2Mjq1aspLi4mISGB9evXE+jiDkYhhBDC3RRFISAhkICEQIatGQ5Aa3nLpzqPLu2+AICHryfRY2OInqjNPArLiEBv1KPT6whKjSMoNY7UNTNRVZXWkprebWu1py9S+sEp7Rp+XoQOH9Q78ygoNQ6dQTrtr5f8RiEGjqb8noBoHbQWgWKAqDkw/BcQdzd4BLi7wn7n7GrDem4r1jNrsVWcAkWvHTPLXIVn8uxb4pgZgNNuozXnYxr2b6DzUg6K0ZOA0XMJmrYSr/ihbqmpo7yc0q1bqcrKwmm3EzpuHPHLluGfev0bx75Kbc5F8l/bTdWRcxh9zKR/fT4pa2Z+5bC+L1KdU8mRF/dT/PFlzMFeTPv5bDIfHoXR/MVrR4UQ7vfxxx8TEnK1g/D5559n9uzZPPvsszz//PM8//zzvPDCC26sUAghhOgffjH+DL03g6H3ajOL2qvaejqPSig/WsqVjy4BYPQyEjU2prfzKGJ4FHoPPYqi4J8QgX9CBMn3TAGgo6qhNziqPX2RigNnAdCbPLQupZHJhI0YRHB6AgbTrfF7lDtJWCTcq+VCzxGzddCcD4oOwmdA+o8gbjmYBv7mLldTVSe20qNYctdiLdwBdiv6kCH4zP4ZpvQV6H1C3V3iNbM11dBwcBNNhzZjb2vEIySaiHu+S+CExW4ZWK2qKs35+ZRs3Ur98ePoPDyInDWLuCVL8I6Odvm9qrMLyX9tF7WnL+IZ6MPwby9l8MppePjc2PD1uvwaDr+4n8t7ijAFmpnyk5mM+PpojF7yw06IW9GWLVt655M98sgjzJgxQ8IiIYQQdySfSF9S70kn9Z50ADpq2yk/qh1ZK88u49AL+wAwmAxEjo7umXkUR8TI6N6ueu/IYBIjg0lcOB4AS33L1Y1rpy9y9i87QFXRGfQEp8f3hEfJhGYmYbzBx+e3MwmLRP9ru6IdLyteqx03AwibCuNfhviVYA53a3nu4mitwHLmXaxn1uNoLkHx9MWcsRLz8DUYIl27or0vqapKx/nj2sDqswdAdeKbPpngaSvxSZvglvPDToeD2iNHKN2yhdaLFzH6+ZG0Zg0xCxbg4e/v0nupqkrF/jPkvbabxnMleIUFMPqZlQxaNvmGn8FouFDHkZcOULS9EE8/Tyb9aBoj/2UsHj6eLq1diDtB296fY6s559JrGsOHwoQffenbKIrCvHnzUBSFb37zmzz++OPU1NQQGRkJQEREBDU1NS6tSwghhLhVeYf5kLJ0KClLtVMIlsZOKrLLeo+uHXnpAKig99QTMTJK6zwaH0fUmOjeJ1LNIf7EzR5F3OxRAHS3dVKXe7k3PCp46wPOvb4HRacQMCSGsBHJvUfXhIRFor90lPcEROu0gdUAIeNhzG8g4V7w7v+BxgOBarfSdWE3ltx1dF/ZD6h4xE/Ge9oPMaXchWK8dRJuR2dbz8DqDXTVlKD39id09gMETbkHjxDXdu1cK7vFQuUHH1C6bRvWujq8IiNJ/da3iJwxA72na4MW1emk7KMc8l7dRfPFCnyiQxj3k/tJXDgOvceNHQ9rutzI0d8eoHBTPkYvD8Y/PZlRj4/DFHDrfF4IITQHDx4kOjqa2tpa5s6dS2pq6qderyjKLfOkgBBCCNHfzEFeJN+VQvJdKQBYmy1UHCvXOo+OlnLsD4dRnYfQGXSED4/s7TyKGhvT+wSrh68X0VOGET1lGAB2Sxf1ecXUnr5I3emLXNx0kPNrPwbAEObLuTIbQx+a6553eACQsEj0HUs1FG/QOohqD2kvCxoFo1/QVt37JLi1PHdRVRV7TZ52zCx/M6q1GZ1fNN5Tvoc5cxX6gDh3l3hdLOUXtIHVx3ehdlsxJwwj5uHn8B81G53RPZ0vXY2NlO3YQfnu3dg7OggYOpSUf/kXQsaMcXlnk9PuoOSDk+S/tpvWK9X4xYcz8bmHiZ835oYH6bWUNVPyl4vkHDyC3sPAmCcmMOaJCZiD7qzNf0L0Bd+5/9En121ra/vS10f3HHUNCwvjnnvu4dixY4SHh1NVVUVkZCRVVVWEhYX1SW1CCCHE7cYUYGbQvMEMmjcYgK62LiqPl2tH146UcvLP2Rx/+QiKXiEsI4KYCT3h0bhYTP7aUh2D2ZOIsSlEjNUCKIfNTmNBKXWnL1LwYTaOLpvb3r+BQMIi4VrWeijdCFfWQs0+UJ0QMAxG/Cckrga/we6u0G2cnY1Y8zdhyV2LvfYc6D0xpdyFafhqPBKmoCi3znpHp62b1pyPaNj/Hp2Xc7WB1WPnEzx1Bea4NLfV1V5SQsnWrVTv34/qdBI2YYI2tHrIEJffy2l3cOX9Y+S/vpv2sjr8B0Ux+ZePEjtrJDr9jf1btlW2cuwPh8h7JxdVURnx9TGMfWoi3qE3NghbCDEwdHR04HQ68fX1paOjgz179vDzn/+cpUuX8sYbb/Dss8/yxhtvsGzZMneXKoQQQtySPH09SZw1iMRZ2hEyW2c3lScqKD9SQkV2GTmvnuDkn7NBgbD0cKInxBEzMY7ocbG9T8jqjQZtEHZmErXxHmTMmOHG98j9JCwSN6+7GUo2aUfMqj4A1QF+QyDzp5CwGgLcs+1qIFCdDrqv7MOSu5auor3g6MYQORzf+b/CNHQZOnOAu0u8Lt2N1TQe3EjT4a3awOrQWCJXfI/ACYvRe/m5pSZVVWk8c4bSLVtoOH0anacnMfPnE7t4MV4RES6/n6PbxuXtRzn3xl46qhoITIll6gvfIGZ65g13LXXUtnPs5cOc/dtpVKdKxgMjsI9RmLH8zm17FeJ2UlNTwz333AOA3W7n/vvvZ8GCBYwdO5ZVq1bxyiuvEB8fz/r1691cqRBCCHF7MHp5ED8tkfhpiQDYLTaqTlf2dh6d+dtpTv/1OAAhaaFEj9c6j2ImxuEV4u3O0gcMCYvEjbG1QdlWuLIOKneB0wY+idoWs8TVEDgc7uDZC/bGy1jOrMN6dgPOtmoUcxBeox/BlLkaY5j7Om9uxNWB1e/SeuYAAL7DphA8fSU+KePcMrAawGm3U3PwICVbttBeXIxHQACDHniAmPnzMfr6uvx+dms3l7YcpuCtvXTWNhM8LIExP1pF1OT0G54z0tnQwYn/OUru6ydx2Bykr8pk/Pem4Bfj37shSQhx60tKSiI3N/czLw8ODubDDz90Q0VCCCHEncVgNhI7KZ7YSfEA2Lvs1ORW9Q7Mzl93htzXTwIQlByMEmfgQls4Q5bcWr+7uZKEReLa2TuhfLsWEFXsBIcVvGIg9TtaB1HI2Ds6IHJ2d9BVuB1L7jpsZdmg6PAYNBPz3P/Ec/AcFP2ttd7cYWnXBlbv30BXTTF6nwBC5z5E0JTleARHuq0ue0cHFXv3Urp9O10NDXjHxJD25JNETp+Oznhjg6S/9H6WLoo2HqDgbx9ibWglbGQyE37+EOFjU244JLI2Wzj5v9mcfuUEdouN1HvSmfD9KQQkBrm4eiGEEEIIIcQ/M3gaiB4XS/S4WMY/PRmHzUHtmWrKewZmlx4u5mRTtoRFQnwhRxdU7NJmEJVvA3sHmMJh8De0DqLQiXALzdpxNVVVsZWfwHJmLV3ntqLaOtEHJeEz8yeYhq1A7+v6Y1B9zVp9hYZ9G2jO3oGzqxNz/FBiHv4F/qPmuG1gNYC1vp7S7dup2LMHh8VC4LBhpD3xBMEjR/ZJd5Ot3cKFDfspfPsjuprbCR+bwuRfPkr4qBufu9XV1sXpvx7j1F+O0dXaxZAlaUx4ZirBg0NcWLkQQgghhBDieuiNeiJHRxM5OpqxT07k4w8/Zmz6GHeX5VYSFonPctqh6iNti1nJRrC1gGcIJD2odRCFTwPdjW15ul042qqxnt2A5cw6HI2XUTy88Ry6DHPmaowxY2659ceqw05r3kEa9r1Lx/njKAYj/qPnEjztXrwS0t1aW+vly5Ru2ULNoUOgqoRPmULc0qX4DRrUJ/frbu3k/LqPOb8ui+7WTqImp5P+9QWEZibd8DVtnd2cfvUEJ/9fNtZmC4MWDGHiM9MIHSqbj4QQQgghhBhoFL2CT4TrR1vcSiQsEhrVCbWHtQ6iknfBWgtGP4i7BxLXQORs0Ln+iM+tRHV001X0AZYza+m+9DGoToyx4/Ge9BSeqYvRedx6g9DsbU00HtlK4/73sDVVYwwMJ3zptwmatAyDb6Db6lJVlYbTpyndsoXGM2fQm0zELlpE3OLFmEJD++Se1uZ2zr/9Eeff3Ye9w0rM9OEMe3QBQWlxN3xNu8XGmbdOc+zlw1gaOkmcNYiJP5pGeKb7jvEJIYQQQgghxFeRsOhOpqrQeFoLiIrXQkcZ6E0QswQS74OYu7T/vsPZaguw5q7FkrcR1dKIzicC74lPYspchSHoxrtN3Kmz5BwN+96l5eReVHs33kPGELny+/hlTEXRu+/bgtNmo/rAAUq2bKGjtBTP4GCSH36Y6HnzMHr3TRhnqW+h8O0PKXrvAHarjbjZI0n/+gICB0ff8DXtXXby3snh2B8P01HdTuyUBCb9aBpRY2JcWLkQQgghhBBC9A0Ji+5ELYVaQHTlHWi9AIoBoufDqP+C2KVgvLPb7QCclmas5zZjObMee1Uu6Ix4DpmPefhqPBKno9yCx/Cctm5aTn1Aw753sZTko/P0InDSUoKnrcQU6d7Qy9beTvnu3ZTt2EF3UxM+CQmkP/004ZMn98nQaoDO2mbOvbWXS5sP4bTZiZ8/hvSvLcA/8cbnTDlsDs69e5bs3x2kraKV6PGxLHx5GTET411YuRBCCCGEEEL0LQmL7hTtJVC8TguIGnMABSJmQPoPIW45mILdXKD7qaqT7uKDWHPXYT3/Pji6MIQNxXfuf2BKvwed1625qaq7qYbGA+/ReGgLjvYmPMPjibz3hwSOX4je7OPW2iw1NZRu20blhx/isFoJGjGC+O9+l6Dhw/ts7lNHVQP5b+zh8rajqE4niQvHk/61efjG3vj8IKfDSeHGfI7+9gAtJc1EjIxi7ouLiJuacMvNrxJC9I1HH32U7du3ExYWRl5eHgCNjY2sXr2a4uJiEhISWL9+PYGBgaiqytNPP83OnTvx8vLi9ddfZ9SoUW5+D4QQQghxJ5Gw6HZmqYHid7WAqO6w9rKQ8TD2d5BwL3hFubW8gcLRXIblzHosZ9bhbK1AMQVgHnE/5uFrMEYMc3d5N0RVVTqKTtKw711ac/cB4JcxheDpq/BOGev2AKOlqEgbWn3kCIpOR8TUqcQtXYpvQkKf3bOtrJb81/dwZWc2ik5H0pIJDH14Hj5RNx6Uqk6VC9vOceSlAzRdaiRsWDjLXr+XxDnJbv8YCyEGlq997Ws89dRTPPzww70ve/7555k9ezbPPvsszz//PM8//zwvvPAC77//PkVFRRQVFZGdnc0TTzxBdna2G6sXQgghxJ1GwqLbTVcTlG7SAqLqj7TB1YEZMOpX2iYz31tzxo6rqfYuui7swpK7lu4rBwDwSJyGeda/4TlkPorh1pzV5LB20HzsfRr2vUtX9RX03v6EznmQoKnL8Qh2bzioOp3UnzxJyebNNJ87h8HLi/hly4hdtAhTcN91trVcqSb/9V2U7D6Bzmhg8MppDH1wDl7hNz7AW1VVLu26wJGX9lNfUEdwSgiL/285yXelSEgkhPhc06ZNo7i4+FMv27JlC1lZWQA88sgjzJgxgxdeeIEtW7bw8MMPoygKEyZMoLm5maqqKiIjZTi+EEIIIfqHhEW3A1sHlG/TAqKKXeDsBt9BkPETSFgDge5dfT6Q2GrPYclZizX/PVRLMzr/GLyn/gBz5mr0/jc+0NjdumpKaNj3Lk3ZO3BaOzDFphLz4M/xHz0HnYd7gy9HdzfVWVmUbN1KZ0UFptBQhjz6KFFz5mAwm/vsvk1FFeS/+j6lH+Wg9zSSev8sUu+fjTnE/4avqaoqVz68xJEX91N7tprApCDu+tMyhixJQ6fXubB6IURfqdzwG6zlF1x6TVPMEHznf+O6/15NTU1vABQREUFNTQ0AFRUVxMbG9r5dTEwMFRUVEhYJIYQQot+4LCxSFGUG8DvACNSrqjpdUZRQYBMQAPxUVdXNPW+7BXhCVdVKV93/juPogordWkBUvhXsnWCOgtQntU1mwWNAOhwAcFpbtWHVuWu1YdV6DzyHLMA84j48EqagKLfmL/mq00Fb3iEa9r1Le2E2it6A/6i5BE9fiTlhmNs7XGxtbZTt2kX5jh10t7Tgm5TEsB/8gLBJk9Dp+25AeGNBKXmv7qJ8Xy4GbxPpj8wj5f5ZmAJufD6TqqqUHijm8H/vo/p0JX5xAcz77WLSlg9DZ7g1P3+EEAOLoihu/74thBBCCPEPLgmLFEUJAP4HWKCqaqmiKP+YFHsf8GdgI7AT2KwoyhLgtARFN8DpgOqPtYCodCN0N4NnMCQ9pAVEYVPgFtzS1RdUVcVWlo0l9x2sBdvBbsUQmnbLD6sGsLc303RkKw3738PWWIUhIIzwJd8icNIyjH7uH1Ruqa2ldOtWKj74AGdXF8GjRxO/bBmBw/o2wKo7c5m8V9+n6vA5jL5mMr6xkJTVM/Hw87qp65YfLeXwr/dRcbQM3yg/5vz3XQxdlYneKF9rQtyKolb+oE+u29bWdt1/Jzw8vPd4WVVVFWFh2sOn6OhoysrKet+uvLyc6Ohbt/tVCCGEELceV3UW3Q9sVFW1FEBV1dqel9sAL8ATcCiKYgC+Byxx0X1vf6oKdUe0gKj4XbDWgMEH4u7RAqKoOaDrm9XityJHew3WM+9iObMWR+MVFE9fzBkrMQ+/D0Nk323Y6g+W0kIa9r1L88k9qLYuvAePJnL50/hlTkPRu/9EaeulS5Rs3kzt4cPQM7Q6ftkyfOL7dm18zaki8l55n5rj5/EM8GH4t5cyZOU0jD43d8St6mQFh3+9j9IDxXiH+zDzl/MYdt8IDJ7u/1gLIW4PS5cu5Y033uDZZ5/ljTfeYNmyZb0vf/nll1mzZg3Z2dn4+/vLETQhhBBC9CtFVdWbv4ii/A7t+Fk64Av8XlXVNxVF8QfeBsKBH/e8vlVV1de/4nqPA48DhIeHj167du1N1zjQtLe34+PzBcdiVBUf2yXCOj4krONjTI4anBhp8JpIjdcsGs0TcOo8+7fggUx14NOUQ0BNFj5NOSg46fBLpSVsBq3B41D1t/DHymHHo/wMpktHMDaUoOo96IofhTV5Eg7/CHdXh6qqqKWlqCdOoJaXg4cHSkYGuhEjUL7o89tF9+0qqqX9w3N0X6lH5+OJz/QUvCYOQudxc2FO55V2qjaU0prTjMHPQPiSGELmhKPz6N9Ooi/9HiGEAMDf35/k5GR3lwGAw+FA/yVHbL/+9a9z8OBBGhoaCAsL4yc/+QmLFi3ia1/7GmVlZcTFxfH6668TFBSEqqo888wzfPDBB3h5efE///M/jBo16obqunjxIi0tLTf6bgkhvoL8vBbi9nSnfG3PnDnzpKqqYz7vda4Ki14GxgCzATNwBFikquqFT7xNILAeuAf4LRAIvKSq6pEvu/aYMWPUEydO3HSNA01WVhYzZsz49AtbLkDxWq2LqKUQFD1EzdM6iGKXgYefW2odqOwNl7CcWYf1zLs4O2rReYdhylyFefhqDEG39tY3W1MNDQc30XRoM/a2RjzCYgmetorACYvQm93/Tctpt1Nz8CAlW7bQXlyMZ1AQsYsXEzNvHgZv7z67r6qqVB7KJ+/V92nIK8YcFsDQh+YyaNkkDCaPm7p2fUEth1/cz6VdF/AMMDHmiQmM+PoYPLxv7ro36nO/RwghPqWgoIC0tDR3lwFox9B8fX3dXcZnDKSPkRC3I/l5LcTt6U752lYU5QvDoht+Cl5RlCeBf6z+WA/sVlW1A+hQFGU/MBz45LqRnwG/RJtjdBDYgDbLaP6N1nBb6CiDK+u0gKjxFKBA+DRI+x7ErwBTiLsrHFDU7k6shdux5K7FVpYNih7P5NmYht+HZ/IsFN2te0RIVVU6Lp6mYd96WnP3gerEd9gUgqffi0/KOBSd+wcp2zs7qdi7l9Jt2+hqaMA7Npah3/kOEVOnojP23XFI1emkfN8Z8l7bRVNhGd6RwYx9dg1Jiyeg97i5+zZerOfISwe4sK0ADx9PJjwzlVH/MhZPP/dukRNCCCGEEEIId7nh36xVVf0T8CcARVHSgJd7ZhJ5AOPRuofoef1gIEZV1SxFUYYDVkBF60K6c7Vegk097fPBY2HMbyBhFXjLEMtPUlUVe1WuNqz63BbUrjb0QYn4zPwJpoyV6H3C3V3iTXFYO2k+vouG/e/SVXkJvZcfIbPuI3jqCjxCBsbnQldjI6Xbt1Oxezf2zk4Chw0j7YknCB41qk/nQDkdTso+Ok3+a7tovliJT2wo43/2IIl3jUNnuLljYc3FTRz9zQEKN+VjMBkY99QkRn9zPKbAO/vbkhBCCCGEEEK4pA1DVdUCRVF2AWcAJ/BXVVXzPvEmvwT+ref/vwNsBp4Ffu6K+9+y/AbB+Jchaj74DYyZCwOJs7MRa95GbeV9XQEYTJjSFmMefh/G2PG39LBqgK7aUhr2b6Dp6HaclnZMMUOIfuCnBIyZh85jYHS1tJeVUbJ5M9X796M6nYRPnEj83Xfj18czQpx2ByV7TpD/+m5ai2vwS4xg4n88Qvyc0TcdErWWt5D9+0Pkr8tFZ9Qz6vFxjPn2BLyC++74nBBCCCGEEELcSlx2ZkdV1V8Dv/6C1636xP+vBSa56r63vNQn3V3BgKKqTrqLD2LJeYeuC7vA0Y0hcgS+C57HNHQZOtOtPbdJdTppO3eEhn3raT93BEVvwG/kLIKnr8IrMWNABGCqqtJ87hwlmzdTf+IEOg8PoufOJW7pUrwi+naotsNmp3jnMfLf2E17eT0BydFM+dVjxM4acdPH8Nqr2jj2x0OcfTsHRVEY/shoxj41CZ9w98+AEkIIIYQQQoiB5NYd8CJuK46WCixn1mE5sw5nSzmKOQCvUQ9hGn4fxrBbfzCnw9JO05FtNOzfQHddGQb/EMIWPU7Q5Lsx+g+MuVSqw0FtdjYlmzfTWlSE0c+PpDVriLnrLjz8+jakc3TbuLz1CPlv7qGzuomg1Dim/fpxoqdm3HRI1FHXzvGXj3DmrVOoDpX0NcMZ/93J+Ebf2sGjEEIIIYQQQvQVCYuE26j2LrqK9mDJeYfuK/sB8EicinnmT/AcsgDFcAuvvO9hrbpMw753ac7eibPbgldSJuGLv4nfiJnoDH03EPp6OLq6qPr4Y0q2bMFSXY05IoLUb36TyJkz0Xv27b+B3drNxc2HKHhrL5a6FkIyEhn37H1EThx6011WlsZOTvw5m5xXT+DospO2MoPx35tMQHygi6oXQgghhBBCiNuThEWi39lrC7HkvoMl7z1USxM6v2i8p3wf8/DV6P1j3F3eTVOdDtrOHqR+33o6zh9HMXgQMGYewdNXYY5LdXd5vbpbWyl//33Kdu7E1tqK3+DBJD/8MGHjxqHob24u0FexdVopeu8AhX//EGtjG2GjBjPxFw8TPjblpkMia4uVU3/J5vRfj9Pd0U3q3elM+P4UAgcFu6h6IYS4PmVlZTz88MPU1NSgKAqPP/44Tz/9NI2NjaxevZri4mISEhJYv349gYGBqKrK008/zc6dO/Hy8uL1119n1KhR7n43hBBCCHEHkbBI9AtnVxvWc1u0YdWVp0FnxHPIfMwj7scjYQqKrm/Dif7g6Gyl8fBWGva/i62hCmNAGOFLniBo8t0YfAdON0tndTWlW7dS+eGHOLu7CRkzhvi77yZg6M1383yV7nYLF9bv4/w7H9HV0kHE+FSGPXoXYSNvfmB2d3sXp185wcn/zaarxcrgRalMeGYqISmhLqhcCCFunMFg4KWXXmLUqFG0tbUxevRo5s6dy+uvv87s2bN59tlnef7553n++ed54YUXeP/99ykqKqKoqIjs7GyeeOIJsrOz3f1uCCGEEOIOImGR6DOqqmIrP66tvC/YBjYLhtBUfOY8h3nYCnReQe4u0SWsFRep37ee5mPvo9q68E4eSeTd38Vv+HQU/cD5EmspKqJk82Zqjx5F0emInD6duGXL8ImN7fN7d7V0cH7dx5xfl4WtzULUlGEMe3QBIcMSb/raNouN3NdPcvxPR7A2WUiaO5iJP5xG2LBwF1QuhBA3LzIyksjISAB8fX1JS0ujoqKCLVu2kJWVBcAjjzzCjBkzeOGFF9iyZQsPP/wwiqIwYcIEmpubqaqq6r2GEEIIIURfGzi/yYrbhqO9DuvZd7HkrsXReAnFwwdz+nLMI+7DEDliQGz8ulmqw07r2QM0ZK2no+gkitGTgLELCJ5+L+aYIe4ur5eqqjScOkXJ5s005eVh8PIi4e67iV20CM+gvg/rrE1tFL79ERc27MfeYSV25gjSH11AUMrNB1R2q50zfzvF8ZeP0FnXQfyMJCb9cBoRI6NcULkQ4nZ1/pVXaLtyxaXX9E1MJGrVqq9+Q6C4uJjTp08zfvx4ampqegOgiIgIampqAKioqCD2E0F+TEwMFRUVEhYJIYQQot9IWCRcQnU66L6yD8vpt+m6uBecdowx4/Ce9CSm1CUoHl7uLtEl7O3NNB7eQuP+DdiaajAGRRJx91METlyKwSfA3eX1ctpsVB84QMnmzXSUleEZHMzgr32N6HnzMJjNfX5/S30LBX/7gKKNB3F02YibM4phX59PQHL0TV/b0e0gb20ux35/iPbqNmInxbP4L8uJHtf3HVJCCHEz2tvbWbFiBb/73e/w+6ctk4qi3BZPpgghhBDi9iBhkbgpjpZyLLnrsJxZi7O1EsUrGK9x38A8fA2G4JufQzNQWMrO05C1nuaTe7SjZkPGEHnvM/hlTB1Q85bsHR2U79lD2Y4ddDU04BMfT/rTTxM+ZQo6Q99/uXfUNFHw5l4ubjmE6nCSMH8s6V+fj1/8zR8Jc9qdnNtwluzfHaS1rIXIMTHM//0S4qYk3HzhQog7Rspjj/XJddva2r709TabjRUrVvDAAw+wfPlyAMLDw3uPl1VVVREWFgZAdHQ0ZWVlvX+3vLyc6OibD9uFEEIIIa6VhEXiuqmObrqK9mLJeZvuy/sA8EiagXnOc3gOnoui93Bzha6hOuy05HxMw771dF7KRfEwETh+IcHTV2GKGuTu8j7FWl9P2fbtlO/Zg8NiISgzk6FPPknQiP459tdeUc+5N/dwedtRVFUlafEEhj4yD9+Ymx8u7XQ4Ob/5HEd/c4Dm4ibCh0cy+78WED8jSZ6FF0LcElRV5bHHHiMtLY0f/OAHvS9funQpb7zxBs8++yxvvPEGy5Yt6335yy+/zJo1a8jOzsbf31+OoAkhhBCiX0lYJK6ZveEilty1WM+8i7OzHp1f1G218v4f7G2NNB7cRMPBTdiba/EIiSZi+dMETVyC3svvqy/Qj9pLSijZvJnqAwdAVQmbNIn4u+/Gb1D/hFmtpbWce303V94/hqLTMejuyQx9eC7eETc/D0l1qhTtKOTIS/tpLGogJC2Mpa+tJGnuYAmJhBC3lEOHDvHWW2+RkZHBiBEjAPjVr37Fs88+y6pVq3jllVeIj49n/fr1ACxcuJCdO3eSnJyMl5cXr732mhurF0IIIcSdSMIi8aVUmwVr4Q4sOW9jK8sGnQHPwfMwj7gPj8TpA+oI1s3qLDlHQ9Y6Wk59gGq34ZM2nuA1P8Y3fdKAej9VVaUpL4+SzZtpOHUKnacnMQsWELd0KeaeIwx9reVyFXmv7aJ070l0RgND7p1O2kNz8AoNuOlrq6rK5T1FHP71fuoLagkaHMyiP9/D4EWpKDoJiYQQt54pU6agqurnvu7DDz/8zMsUReFPf/pTX5clhBBCCPGFJCwSn8tWk4cl5x2seRtRu1rRByXiM/PfMGWsRO/TP4FEf3DabbSe/pD6feuxXMlD5+lF4KS7CZ5+L6aIBHeX9ylOh4PaI0co2byZtkuX8PD3J+n++4mZPx8Pv/7peGq6UE7eq7so+zgHg8lI6gNzSL1/Fubgm7+/qqoUf3yZIy/upya3ioCEQBb8cSkpy4ai0+tcUL0QQgghhBBCiGshYZHo5exqw5q/GUvuO9irckHviSltEebh92OMm3BbHf2xtdTTeHAjjQc3YW9twCMslsiVzxA4YRF6s4+7y/sUh9VK5UcfUbp1K5aaGryiokh94gkiZ8xA79E/86EazpWQ9+r7VOw/i9HbRPrX55O6ZiaeAa75WJUeLObwr/dTdaIcvxh/5v1mEWkrMtAZJCQSQgghhBBCiP4mYdEdTlVVbBUntC6igq1gs2AIS8N33v8PU/o96MwB7i7RZVRVxVKcR33WOlpPf4TqsOObPpng6avwSRuPohtYwUR3czNlO3dS/v772Nrb8U9JYfDXv07o2LH9VmvdmcvkvfI+VUfO4eHnRcY3F5Oyajoevl4uuX7FsTIO//c+yo+U4hPhy6z/WsCwNcPRewycY39CCCGEEEIIcaeRsOgO5exsxJK3AUvOOzjqL6B4eGNOX455xP0YIoffVl1ETls3Laf20pC1HktpATqTN0HTVhI8bSWeYXHuLu8zOquqKNmyhaqPP8bZ3U3ouHHE3303AWlp/XJ/VVWpPVVE3l/fp+bkBTwDfRjx5DIGr5yG0dvkkntU51Ry+Nf7Kcm6jFeoN9P/fQ6ZD47CYJJvSUIIIYQQQgjhbvKb2R1EVZ10Fx/CkvM2XRd2gaMbY/QovBe+iOfQpeg8vN1dokvZmmtpOPAejQc342hvwjMikajV/0rAuLvQmwbe+9py4QLFmzZRl52NotcTOWMG8cuW4R3TP5vmVFWl6mgB+a/uoi73EuYQf0Z9bwXJ90zGYPZ0yT3q8ms4/OJ+Lu8pwhRoZupPZzH8kVEYvfrnOJ0QQgghhBBCiK8mYdEdwNFWjfXMeiy5a3E0l6CYA/Aa9RCm4fdhDOufbpX+oqoqnZdyadi3npacj0F14jtsKiEzVuGdMnbAdUypTif1J09SsnkzzefOYfD2JmH5cmIXLcIzMLB/alBVKg7mkf/q+zTkl+AVHsiYH61i0NJJ6D2NLrlHQ1E9R186wIVtBXj6eTLpR9MY+S9j8fBxTQglhBBCCCGEEMJ1JCy6TalOO92XPsKS8w5dFz8E1YFH/GS8p/8rppQFKAbXHCcaKJzdVppP7KFh33qs5RfQmX0JmbmG4Gkr8QiJdnd5n+G02ajat4/SLVvoKC/HFBrKkEcfJWrOHAxmc7/UoDqdlGXlkv/qLpoulOMdFcy4n9xP4qLx6I2u+dbQXNzE0d8coHBTPgazkfFPT2bU4+MwBfTP+yiEEAOJw+FgzJgxREdHs337dq5cucKaNWtoaGhg9OjRvPXWW3h4eNDV1cXDDz/MyZMnCQ4OZt26dSQkJLi7fCGEEELcQSQsus3Ym0qw5q7FcmY9zvZqdN5heE18AnPmGgxBie4uz+W6G6tp3L+BxsNbcHS04Bk1iOj7/j8Cxi5A5znwAglbRwcVu3ZRumMH3U1N+CQmMuz73yds0iR0hv75cnQ6nJR+cIr813bRcrkK37gwJvz8IRIWjEVncM1g6dbyFrJ/f4j8dbnojXpGfXM8Y789AXOQawZjCyHErej3v/89aWlptLa2AvDjH/+Y73//+6xZs4ZvfetbvPLKKzzxxBO88sorBAYGcvHiRdauXcuPf/xj1q1b5+bqhRBCCHEnkbDoNqDau+i6sAtLzjt0Fx8ARYfHoJmYR/wKz0GzUPSuOUo0UKiqSkfRKRr2rac1dx8AfpnTCJ6xGu/BowbcUTMAa309pdu2UbFnDw6rlaDhw4n/7ncJGt5/w8SddgfFu46T//pu2kpr8U+MYNJ/fp24OaPQ6V2zXa29uo1jfzzM2b+fRlEUhj8ymrFPTcIn3Mcl1xdCiFtVeXk5O3bs4N/+7d/4zW9+g6qqfPTRR7z99tsAPPLIIzz33HM88cQTbNmyheeeew6AlStX8tRTT6Gq6oD8+SaEEEKI25OERbcwe90FLLlvYzm7AdXShM4/Fu9pP8KcuQq9X5S7y3M5Z5eF5uO7aNj3LtbKi+i9/Qid8yBBU1fgERzp7vI+V3tJCcWbN1Nz4ACoKuFTphB/9934JvZfl5fDZufKjmzyX99NR2UDAYOjmfL8vxA7YziKzjUhUWd9B8f/dITcN0+h2p2kr85k/NNT8I32c8n1hRDCVU7+ZgNNF8pdes3AITEM+cb8L32b733ve/z3f/83bW1tADQ0NBAQEIChp6s0JiaGiooKACoqKoiNjQXAYDDg7+9PQ0MDISEhLq1bCCGEEOKLSFh0i1G7O7EWbMOS+za28hOgM+I5ZD7mkQ/gkTAFRXHNL/8DSXd9BQ37N9B4eCtOSxummCFEP/BTAsbMQ+cx8GYvqapKU34+JZs20XDqFHqTiZiFC4lbvBhzWFi/1eHosnFp62HOvbmXzpomgobGM/qZe4meMsxlz05bmyyc+HM2Oa8ex261k7ZiGOO/P4WA+P4Zzi2EELeC7du3ExYWxujRo8nKynJ3OUIIIYQQX0nColuAqqrYq89iyfk71vzNqN3t6IOT8Zn9M8zD7kXnHezuEl1OVVU6zh+nPms9bXna0Tr/4TMInrEar0H9d3TreqgOB7XHjlGycSOtFy/i4e/PoPvvJ+auuzD69N8xLLu1m4sbD1Lwtw+w1LcQOjyJcT+5n8gJaS77uHW1dXHq/45x6i/H6G7vImXpUCb8YCpBybff56IQ4vYy+gcr++S6/+gY+jyHDh1i69at7Ny5E6vVSmtrK08//TTNzc3Y7XYMBgPl5eVER2sLGaKjoykrKyMmJga73U5LSwvBwfL9VQghhBD9R8KiAcxpbcGatwlL7tvYa/LBYMKUtgTziAcwxowZkIHJzXJYO2k+tpOGfe/SVX0FvU8gofO/RvCU5RgDw91d3udydHVRlZVFyZYtWKqqMEdGkvqtbxE5YwZ6z/5bDW/rsFK0YT8Fb39IV1M74aOHMOk/vkbY6MEu+1yxdXaT89pJTvzPUazNFpLvGsLEZ6YRktZ/HVNCCHGr+a//+i/+67/+C4CsrCxefPFF/v73v3PvvfeyYcMG1qxZwxtvvMGyZcsAWLp0KW+88QYTJ05kw4YNzJo167b8mS+EEEKIgUvCogFGVVVsZce0LqLCHWC3YojIwHf+rzCl34POdHvOgOmur6B+33qajmzDaWnHHJdKzMO/wH/UHHTG/gtcroetvZ3y99+nbMcOulta8EtOJvlHPyJs/HgUvWu2il2L7rZOzq/fx/l3Pqa7tYPICWkMe+wuQocPctk97BYbZ946zfE/HaazvpPEWYOY+KNphGcOzFlRQghxK3jhhRdYs2YNP/3pTxk5ciSPPfYYAI899hgPPfQQycnJBAUFsXbtWjdXKoQQQog7jYRFA4Szox7L2Q1Yct7G0XgJxdMXc+YqzCPuxxiR4e7y+sTnHjUbNZvg6avwSswYsM+iWuvrKd26lYq9e3FYrQSPGkX8PfcQmJ7erzV3NbdTuPZjLqzLwtZhJXpqBumPLiAkPcFl93B0O8h7O4fsPx6io7qd2CkJLPnRNKLGxLjsHkIIcSeZMWMGM2bMACApKYljx4595m1MJhPvvvtuP1cmhBBCCHGVhEVupDoddBcfwHL673QV7QGnHWPMWLwnPYUpdTGKh5e7S+wTzi4LTcfepyFr3SeOmn2d4KkrMAaEuru8L/SZzWZTp2qbzRIS+rUOa2MbBX//kKL39mPv7CJ21giGPbqAwCGxLruH0+7k3IazZP/2IK3lLUSNi+GuPy4jdlK8y+4hhBBCCCGEEGJgkrDIDRytFYSUbaT+//0YZ0s5ijkIr7GPYR5+H4aQwe4ur890N1TSsH8DTYe34uhsxRSbQsxDP8d/9NwBe9RMVVWa8/Mp3ryZhpMn3bbZDKCzrpmCtz7g4qaDOG124uaMJv3r8wkYFOWyezgdTs5vOcfRlw7QXNxE+IhIZr9wF/HTEwdsp5cQQgghhBBCCNeSsKgf2esu0PbRf9J9OYtQ1YkhcRrmWT/Fc/A8FMPADEtulqqqdBSdoiFrHa1n9oOiaFvNZq7BKylzwAYQqsNB3bFjFG/aRGtREUY/P5Luv5/YBQsw+vr2ay0d1Y2ce3Mvl7YeRnU4SVgwlvSvzccv3nUDv1WnStHOQo68dIDGC/WEDg1j6WsrSZrruuHYQgghhBBCCCFuDRIW9SPF0xt7XSHek75DriWByQtWubukPuPsttJ8fBcNWeuxVl5E7+1P6NyHCZq2Ao8ButUMwNHdTVVWFqWbN9NZVYU5IoLUb36TyJkz+3WzGUB7RT35r+/myo5sABIXTyD9kXn4RIe47B6qqnJ570WOvLifuvwagpKDWfTnexi8KBVFJyGREEIIIYQQQtyJJCzqR3q/aEKezEZRdNiystxdTp/obqqhcf8GGg9twtHRiik6megHfkrAmHnoPEzuLu8L2drbKd+9m7Lt2+lubsZ30CAyfvhDwiZM6NfNZgCtJTXkv7ab4t3HUfQ6Bt0zmaEPz8M7PNBl91BVldL9Vzj86/1Un67EPyGQBX9YSsrdQ9HpdS67jxBCCCGEEEKIW4+ERf1MUW6/X8RVVaXzUg71Wetozd0Hqorf8OkEz1iNd/LIAX2MyVpfT+m2bVTs2aNtNhs5UttsNmxYv9fdfKmS/Nd2UbL3FHoPA0NWzWDoQ3Mwh/i79D7lR0o4/Ov9VGSX4Rvtx9wXF5K2MgO9sX9DMSGEEEIIIYQQA5OEReKGOW1dtJzYS/2+dVjLzqP38iNk9v0ET12JR3Cku8v7Uu0lJZRs3kz1PzabTZmibTZLTOz3WhrPl5H/6i7KPs7B4OXJ0IfnknrfLExBrp2NVHWygsO/3kfpgWK8w32Y9cv5pN83HIOnfBsQQoi+9tvf/pa//vWvKIpCRkYGr732GlVVVaxZs4aGhgZGjx7NW2+9hYeHB11dXTz88MOcPHmS4OBg1q1bR0I/b94UQgghxJ3NJb8lKoriD/wNiOu55ouqqr6mKEoK8DZgBL6pquoRRVEMwC5gqaqqna64v+hftuZaGg68R+PBTTjam/GMTCL6vv+PgHF3DeijZqqq0nzuHCWbNlF/8iQ6T09i7rqLuCVL+n2zGUB9fjF5r7xP5cE8jD5mhv3LXaSsnomnv7dL71Nztpojv97PlQ8vYg72Yvov5pD50EgMZqNL7yOEEOLzVVRU8Ic//IFz585hNptZtWoVa9euZefOnXz/+99nzZo1fOtb3+KVV17hiSee4JVXXiEwMJCLFy+ydu1afvzjH7Nu3Tp3vxtCCCGEuIO4qqXgSeCcqqpLFEUJBc4rivJ34JvA00Ax8HtgBfAE8DcJim4tqqrSeeUsDVnraDn9EahO/DKmakfNhowZ0EfNejebbd5M64UL2maz++4jZsECPPz8+r2e2pyL5L2yi+rsAjz8vMn81hKGrJqOh4/ZpfepL6zlyEsHuLjzPJ4BJiY/O4MRj47Bw9vDpfcRQgjx1ex2OxaLBaPRSGdnJ5GRkXz00Ue8/fbbADzyyCM899xzPPHEE2zZsoXnnnsOgJUrV/LUU0+hquqA/lkrhBBCiNuLq8IiFfBVtEcxPkAjYAdsgFfPH5uiKAHAEmCBi+4r+pjT1k3LqQ9oyFqHpbQAndmHkBmrCZ5+Lx4h0e4u70s5urupzsqiZMsWOisrMYeHu22zmaqq1Jy4QN6r71N7sghTkC8jvnM3g1dMxejl2m6spksNHPnNAc5vOYeHtwcTfjCFUd8Yh6ffwO36EkKI/pL1873Unatx6TVDh4Yz+kcTvvD10dHR/PCHPyQuLg6z2cy8efMYPXo0AQEBGAzaQ7GYmBgqKioArRMpNjYWAIPBgL+/Pw0NDYSEuG4bphBCCCHEl3FVWPQysBWoBHyB1aqqOhVF+RPwJuCJ1mX0M+BXqqo6XXRf0UdsLfU0HtxI44GN2Nsa8QxPIGr1vxIwbiF6k5e7y/tSto4OKnbtonTHDrqbmvBNSiLjhz8kdMIEdP282UxVVaqOnCPv1V3Un7mMOdSfUT9YSfLdkzGYXNvh01LazNHfHqRgw1n0ngbGPjmR0d8cjzloYP97CSHE7a6pqYktW7Zw5coVAgICuPfee9m1a5e7yxJCCCGE+EKuCovmAznALGAQsFdRlAOqqpYCMwAURUkGYoACRVHeAjyAn6mqeuGfL6YoyuPA4wDh4eFk3YZr5tvb2wfk+2VoLMVUdAiPsjMoqoPuyFSsI5djCxtMpVOBo8fcXeIXUtvacObkoJ49CzYbSlwcupkz6YyJocBmo+DAgf6rRVWxnquk/cMCbOVN6AO88L9nFF5jEqg2KlQfPeyye3U3dFG9uZyGfbUoOgiZH0H4kmjs/grZZwbuv5f4cgP1e4QQA4m/vz9tbW3X9Xe+rAPoZjgcji+sZdu2bcTExGAymbBardx1111kZWXR1NREU1MTBoOB8+fPEx4eTltbG+Hh4RQWFuLv74/dbqe5uRkPD4/rfl8BrFarfC8Rog/Jz2shbk/ytX0TYZGiKE8C3+j5zybg56qqqsBFRVGuAKnAJ39T/SXwU+C7wF/R5hj9Cnjgn6+tqupfgL8AjBkzRp0xY8aNljlgZWVlMVDeL6fdRuvpD6nPWo+lOA+dyZvAGfcSPG0lnmFx7i7vK7WXlmqbzfbvB1Ulwo2bzVSnk7KPcsh7dRfNFyvwiQ5h1L89QMLCceiNrt061lHbzrGXD1P4txxUp8rwB0cy7juT8Yl07RY14R4D6XuEEANVQUEBvr4D43teW1vbF9aSkpLCCy+8gF6vx2w2c/jwYcaMGUNLSwu7d+9mzZo1bNiwgRUrVuDr68vy5cvZsGEDc+bMYe3atcyePRu/G5yxZzKZGDly5M28a0KILyE/r4W4PcnX9k2ERaqq/gn4E4CiKP8PmA0cUBQlHEgBLv/jbRVFmQ5UqqpapCiKF+Ds+SPnY9zI1tpA46HNNB54D3tLPR5hsUTe+0MCJyxCb3LtRi5XU1WV5oICbbPZiRPoPDyIWbCAuKVL3bLZzGl3UPLBSfJf203rlWr84sOZ+NzDxM8bg87g2qNvlsZOTvy/o+S8egKHzUH6qkzGf28KfjH+Lr2PEEII1xg/fjwrV65k1KhRGAwGRo4cyeOPP86iRYtYs2YNP/3pTxk5ciSPPfYYAI899hgPPfQQycnJBAUFsXbtWje/B0IIIYS407iq1eE/gdcVRTkLKMCPVVWtB+gZev1TYHXP2/4F+HvPvZ9w0f3FdbCUFlCftY6Wk3tR7TZ8hk4k5IGf4pM2AUWnc3d5X0p1Oqk7fpySTZtoOX9e22y2Zg0xd93lls1mTruDK+8fI//13bSX1eE/KIrJv3yU2Fkj0eld+7G0tlg59ZdsTv3fcWyd3aTeM4yJP5hCQGKQS+8jhBDC9f793/+df//3f//Uy5KSkjh27LPHhU0mE++++25/lSaEEEII8RkuCYtUVa0E5n3B61Rg7if+uwAY5Yr7imunOuy05HxMQ9Z6Oi/novMwEzjpbkJmrMIzPN7d5X0lp81GVVYWJZs39242S3n8caJmzer3zWYAjm4bl7cf5dwbe+moaiAwJZapL3yDmOmZLg/cutu7OP3KCU7+bzZdLVYGL05l4jNTCR4S6tL7CCGEEEIIIYQQ4LrOIjFA2duaaDy0mYYD72FvrsUjJJrIFd8ncOIS9GYfd5f3lWwdHVTs3k3p9u29m82GPfMMYRMn9vtmMwC7tZtLWw5T8NZeOmubCR6WwJgfrSJqcjpaE53r2Cw2ct84yYk/HcHSaCFp3mAmPjONsGHhLr2PEEIIIYQQQgjxSRIW3aYsZRdoyFpH84ndqPZufFLHE7zmx/imT0LR9X/Icr2sDQ2UbdtG+Z49OCwWgoYPJ/7ppwnKzHR5KHMt7JYuijYeoOBvH2JtaCV0xCDG/+xBIsalurwee5eds38/zbE/HqaztoP4GUlM+uE0IkZGufQ+QgghhBBCCCHE55Gw6DaiOuy0ntlPQ9Y6Oi6eRvEwEThhMcEzVmGKTHJ3edekvaysd7OZ6nQSPnky8XffjV+Se+q3tVu4sGE/hW9/RFdzO+FjU5j8y0cJHzXY5fdy2BzkrztD9u8O0l7VRszEOBb/73Kix8W6/F5CCHG7UFXVLU8i3Aq0SQBCCCGEENdPwqLbgL2jhabDW2jYtwFbUzXG4Egi7nmaoElL0Hv1/9DnG9F87hzFmzdTf/w4Og8PoufNI37pUszh7jly1d3ayfl1H3N+XRbdrZ1EThrKsEfvIjTT9aGV0+6kYGMe2b87SEtJM5Gjopn/28XETkmQX4CEEOJLmEwmGhoaCA4Olu+X/0RVVRoaGjCZTO4uRQghhBC3IAmLbmHWiovU71tP87H3UW1deA8ZTeS9P8AvY+otcdSsd7PZ5s20FBZi9PV162YzAGtzO+ff/ogL7+7D1mElZlom6Y8uIHio64eAq06VC9vOceSlAzRdaiQsI4K731xFwqxB8kuPEEJcg5iYGMrLy6mrq3N3KVit1gEXzJhMJmJiYtxdhhBCCCFuQRIW3WJUp4PWswe0o2YXTqIYPQkYdxch01dhik52d3nXxGmzUbVvn7bZrKICU1gYKd/4BlGzZ7tlsxmApb6Fwrc/pOi9A9itNuJmjSD90bsIHBzt8nupqsql3Rc48uJ+6gvqCE4NZclfVzBowRAJiYQQ4joYjUYSExPdXQYAWVlZjBw50t1lCCGEEEK4hIRFtwhHZyuNh7fRsH89toYqjIHhRCx7ksBJyzD4BLi7vGti7+igfM8eSrdtu7rZ7Ac/IGzSJLdsNgPorG3m3Ft7ubT5EE6bnfh5Y0j/2nz8kyJdfi9VVSn++DKHf72P2jPVBCYFsfB/ljFkyVAUnYREQgghhBBCCCEGBgmLBjhr1WUastbTdGwnarcV7+SRRN7zNH6Z01D0t8Y/n7WhgbLt2ynfvfvqZrPvfpeg4cPd1knTUdVA/ht7uLztKKrTSeLCcQx9ZD5+cWF9cr/Sg8Uc/u99VJ2swC8ugHm/XUza8mHoDLo+uZ8QQgghhBBCCHGjbo204Q6jOp205R+iIWs97YXZKAYPAsbOJ3j6asyxQ9xd3jXrKCujZMsWqvbt0zabTZqkbTYbNMhtNbWV1ZL/+h6u7MxGURSSlkxk6CPz8IkK7pP7VRwr4/B/76P8SCk+kb7Mfn4B6auHo/cY+DOlhBBCCCGEEELcmSQsGkAclnaajmyjYd+7dNeXYwgII3zJEwRNvhuDb6C7y7tmzQUFFG/adHWz2dy5xC1dildEhNtqaimuJv+1XZTsPoHOaGDwiqkMfWguXuF983Gtzqnk8K/3U5J1Ga9Qb2b8x1wyHhiJwSRfckIIIYQQQgghBjb5zXUA6KopoWHfepqO7sDZ1YlXUibhS5/Af8TMW+aomep0Un/iBMWbNmmbzXx8SFy9mti77sLD399tdTVfrCDv1V2UfngavaeRlPtmkfbAbMwhfVNTXX4Nh1/cz+U9RZgCzUz92SyGPzIao9nYJ/cTQgghhBBCCCFc7dZIIm5HqpO2/MPUZ62j/dwRFIMR/9FzCZ6+Cq/4oe6u7pp9ZrNZaChD/uVfiJ49G70bVwg3FpSS9+ouyvflYvA2MfSRuaTeNwtToG+f3K+hqJ6jLx3gwrYCPP08mfSjaYz8l7F4+Lhnu5sQQgghhBBCCHGjJCzqZw5rB01HtxOw6w2K2+sx+AUTtvibBE2+G6Nf38zN6Qv/2GxWtn07XY2N+CQkuH2zGUD92Svkvfo+lYfyMfqayfjGQlJWz8TDz6tP7tdc3MTR3xygcFM+BrOR8U9PZtTj4zAFmPvkfkIIIYQQQgghRF+TsKifdNWW0bD/XZqObMNp7cAZFEfC1/4Dv5Gz0RlunSNKXY2NlP5js1lnJ0GZmQz9znfcutkMoPZUEXmv7qL6WCGe/t4Mf2IJQ+6djtGnb0Kb1vIWsn9/iPx1ueiNekZ9czxjvz0Bc1DfhFJCCCGEEEIIIUR/kbCoH3TXV3DhP1ai6PT4j5pD8PRVHCupJ2DsDHeXds06ysu1zWZZWQNms5mqqtQcP0/eK+9Te/oipiBfRj59D8n3TMHo1TdH4Nqr2zj2x8Oc/ftpFEVh+NdGM+6pSXiH+fTJ/YQQQgghhBBCiP4mYVE/8AiJJvq+/w/fYVMw+odoLyzJcmtN16q5sJCSTZuoO3ZM22w2Z4622Swy0m01qapK5eF88l7ZRUPeFcxhAYx+5l4GLZuEweTRJ/fsrO/g+J+OkPvmKVS7k/Q1wxn/3cn4Rvv1yf2EEEIIIYQQQgh3kbConwRNvtvdJVwz1emk/uRJSjZtormgQNtstmoVsQsXunWzmep0Ur7/LPmv7qKxsBTvyCDG/ngNSUsmoPfom6N81iYLJ/6cTc6rx7Fb7aStzGD89yYTEB/YJ/cTQgghhBBCCCHcTcIi0ctps1G9fz8lmzfTUV6ubTZ77DGiZs/GYHbfwGanw0nZR6fJf20XzRcr8YkNZfzPHiTxrnHoDH0zTLurrYtT/3eMU385Rnd7FynLhjLh+1MJSr51hpALIYQQQgghhBA3QsIigb2zk4o9eyjdtu3qZrPvf1/bbGZw36eI0+6gZM8J8l/fTWtxDX6JEUz8j0eInzO6z0IiW2c3Oa+d5MT/HMXabCF5YQoTn5lKSGpYn9xPCCGEEEIIIYQYaCQsuoP982azwIwMhj71FEEjRrh1s5nDZqd45zHy39hNe3k9AcnRTPnVY8TMHIFOr+uTe9otNs68dZrjfzpMZ30nibMGMfFH0wjPdN9sJiGEEEIIIYQQwh0kLLoDdVRUULJ5c+9ms7AJE0i45x78kpPdWpej28blrUfIf3MPndVNBKXGMe3XjxM9NQNF1zchkaPbQd7bOWT/8RAd1e3ETklgyY+mETUmpk/uJ4QQQgghhBBCDHQSFt1BmgsLKdm8WdtsZjQOiM1mAHZrNxc3H6Lgrb1Y6loIyUhk3LP3ETlxaJ91ODntTs5tOEv2bw/SWt5C1LgY7vrjMmInxffJ/YQQQgghhBBCiFuFhEW3ud7NZps303zuHAYfHxJXrtQ2mwUEuLU2W6eVovcOUPj3D7E2thE2ajATf/Ew4WNT+i4kcjg5v+UcR186QHNxE+EjIpnz33cRNy3RrUfvhBBCCCGEEEKIgULCotuU02aj+sABbbNZWZm22ezRR4maM8etm80AutstXFi/j/PvfERXSwcR41MZ9uhdhI3su2NwqlOlaGchR146QOOFekKHhrH0tXtJmpssIZEQQgghhBBCCPEJEhbdZuydnVTs3attNmtowCc+nvSnnyZ8yhS3bjYD6Grp4Py6jzm/Lgtbm4WoycMY9ugCQjIS++yeqqpyee9Fjry4n7r8GoIGB7Poz/cweFEqik5CIiGEEEIIIYQQ4p9JWHSb6Gpqomz7dsp37cLe2UngsGGkffvbBI8c6fbOGWtTG4Vvf8SFDfuxd1iJmTGcYY8uICg1rs/uqaoqpfuvcPjX+6k+XUlAQiAL/rCUlLuH9tlGNSGEEEIIIYQQ4v/f3p1HWVWdCRt/3qKYimIQkEFkcEARRKZSEUXBkYgRoyYmtiaSGJMsE2MS+/u+TvdKpzvJSmyHmMGkYxyiiZGkjRpNHEODiBTIIMqkgMgg8wzFZA37++NeScWAQqpu3Rqe31q1qHvO2efdZ1Hvubfe2mfvxsBiUQO3a/VqVv7xj6yZNIlUWUmX4cPp/bGP0b5v33x3jT2btrPoN39hyWNTqdxXTq/zh3Ly+IvocHyPnMZ9p3QF026bwuoZq2jbox0X3DGW/lcOpKDQIpEkSZIkSR/GYlEDtX3xYpY/9lhmZbPCQo467zx6jxuX95XNAHat38qih15g6R9fJlVW0fvCEgaMv4j2fbrlNO7a2auZdtuLrHxpOW26FXPu9y5iwKcGUdjSH3NJkiRJkg6Vv0U3IKmqis1z5rD88cczK5u1aUOfK66g59ixtMzzymYAZas3sfCh51n21HRSShw7djj9r7uQtkcfmdO4zSTd4QAAFQNJREFU6+eto/S2Kbw9cSmtOxVxzr+fzynXDqGwdfOcxpUkSZIkqTGyWNQAVJWXs27qVFY8/ji7Vq2iZefO9WZlM4AdKzew8FfP8fYzrxAFBRw3bgT9P30Bbbp3ymncTW9soPSOl1j69Ju07NCKM/9lFIPHl9CiTYucxpUkSZIkqTGzWFSPVezZw+rnn9+/slmbXr3qzcpmANuXrWX+A8+y8oXZFDQv5ISPn8NJ15xPUZcOOY279a3NlN75Em/+cSEtilsy/BsjGXr9qbRs1yqncSVJkiRJagryX3HQ39m3dSur/vxn3nnmmb+ubPalL9Fp6NC8r2wGsHXxO8y//1lWTZpLYavm9Lv6PPr903m07tQup3G3r9zG9B9OZdGj8yhsVcipN46g5Iun0+qI/I+ukiRJkiSpsbBYVI/sWr2alU8+ydpJk6iqqMisbHbZZbQ/4YR8dw2AzQtXMP/+Z1g9ZR7N27RiwHUXceKnRtOqQ3FO4+5cs4MZP3qZBRNeIwoLGHL9qZx64xkUdW6T07iSJEmSJDVFh1Usioh+wAPAUOBfU0q3V9s3BvgR0Ay4N6X0g+z2h4GBwJ9SSt/Mbvs3YH5K6YnauIiGbvvixSx//HE2zphBQWEh3UePzqxsdtRR+e4aABtfX8b8+55hbelCWrQrYuANYznxqlG0aFuU07i7NpTxyk+nMe83r5KqEgOvGcJpXxlBcbe2OY0rSZIkSVJTdrgji7YANwGXVd8YEc2Au4ELgHeAmRHxZPb8e1JKp0TECxHRHigCTk8pfbemnW/IUkpsmj07s7LZggWZlc0uv5yel1xSL1Y2SymxYc4S5t/3DOtnLaZlh2IG3TiOE64YSfPi3D72tWfLbmb9fDpz759FZXklA64axOlfPZN2R7fPaVxJkiRJknSYxaKU0gZgQ0SMfd+u04ClKaVlABExARgHPAG0jogCoDlQCfwn8O817HeDtu6ll6h8+GHmbt5My06d6Dt+PD0uuKBerGyWUmLdjDeYf98zbHztLVp1aseQr15O38vPorB1y5zG3rttD3PueYU5986kfPe7nHT5yQz/2ll0OKZjTuNKkiRJkqS/qq05i3oAq6q9fofM6KFFEbERmAP8GjgeKEgpzamluA3S1vnzAeh/0010O+ssCpo3z3OPMkWiNVPnM//+Z9i8YAVFXTow7JaPc9ylIyhsldul6Pft3Mer985kzj0z2LdjH30v6ccZ3xhJpxOOzGlcSZIkSZL09yKldPiNIr4NlL03Z1FEXAmMSSldn319LZli0Zff1+4p4AvAeGAQ8EJK6ZcHOP8NwA0AXbt2HTZhwoTD7mN9lsrL2bV3L8Vt8z/3TqpK7F2wmrKJiyhfs41mRxRRPPokikp6E4XNchq7cm8lm15Yy/o/raGyrIL2JR3pfkVPWvdy4mqprKyM4uLcTh4vqfaYs1LTZO5LjVNTye3Ro0fPTimVHGjfh44siogbgc9nX16cUlpzgMNWAz2rvT46u636ecYBs4Fi4LiU0ici4rmIeDiltLv6sSmle4B7AEpKStKoUaM+rJsNzuTJk8nndVVVVrFy4hwW3P8s25etpW3PLgz71rX0GXMqBTkuElXsKee1h+Yw8+5S9mzezTHnHscZ/3w2XU/pntO4UkOS73uEpMNjzkpNk7kvNU7m9iEUi1JKd5OZvPqDzAT6RsQxZIpEnwSufm9nRDQHbgbGAn2B94YzNQNaAH9TLFLuVFVUsvy5WSz81XPsWLGe9sd0Y8R3xtPr/KEUNCvIaeyKfRXM/+1cXvnJNHatL6PXyD6cccvZHFVydE7jSpIkSZKkQ3dYcxZFRDdgFtAOqIqIm4H+KaUdEfFl4DkyBaD7U0oLqjW9EXgwpbQ7Il4HiiJiHvB0SmlbLVyHPkRleQVv/3kGCx98nrLVm+jQtwdnff9z9Bw9mCjIbZGosrySBb97nVd+9DI71+ygx/CeXPyzyzh6eK+cxpUkSZIkSYfvcFdDW0fmEbMD7XsaePog++6q9n0CPnU4cfWPq9xXzltPlbLwwefZvX4rHfv35uyvX0mPs04mInIau6qiikV/mM/0u6ayY+U2ug/twQV3jKXXyD45jy1JkiRJkv4xtbUamuqZir3vsvSxqSz6zV/Ys2k7Rw46ltO+eTXdh5+U+yJRZRWLn1zE9DtfYuuyLXQ5pRvnfu8q+ow+1iKRJEmSJEn1nMWiRqZ8116WPDqFRb+dyL6tZXQZ1pcR/3kdXYb1zXmhJlUlljz9BqV3vMSWxZvofFIXLr3/So69MPexJUmSJElS7bBY1Ei8u3M3b/7+Rd58ZBLv7thF9+EnMeCzY+gy+Picx04psez5JZTePoWNCzfQsW8nxv73x+g7th9RYJFIkiRJkqSGxGJRA7dvWxlvTJjE4t+/SHnZHnqMHMiAz46h84A+OY+dUmL5pGWU3j6F9a+tpcMxHRnzk0s5cVz/nK+sJkmSJEmScsNiUQO1d8tOFj08kSV/mELF7n30PHcwJ392DEec0DPnsVNKrJq6nGm3TWHt7NW069meC+8cy0lXDKSg0CKRJEmSJEkNmcWiBmb3xm0s+vVfWPr4VKrKK+h1/jAGjL+IDscdVSfx35mxktLbpvBO6UqKu7flvB+MYcBVg2jWolmdxJckSZIkSbllsaiB2LVuCwsfeoG3npxGqqyiz5hTGXDdRbTr3bVO4q+ds5ppt01h5ZS3adO1mNHfvZCTrx5MYUt/hCRJkiRJakz8Tb+eK1u9iQW/eo63/zwDgGMuGc6Az1xIcY/OdRJ//bx1lN42hbcnLqV1pyLO/tZ5DPr0UApbN6+T+JIkSZIkqW5ZLKqndqxYz4IHnmP5czOJZgUc97Ez6X/tBbTp1rFO4m9cuIHSO6bw1rOLadWhNWf+yygGjy+hRZsWdRJfkiRJkiTlh8WiembbW2tY8MCzrHhhDs1aFHLCJ0Zx0jXnUXRkhzqJv3nJJqbf8RKLn1pEi7YtOeOWkQy5/jRatm1ZJ/ElSZIkSVJ+WSyqJ7a8uYoF9z/LqklzKSxqSf9rz6ff1efRqmPbOom/7e0tlN45lTefWEBh6+acdtMIhn3hdFp1aF0n8SVJkiRJUv1gsSjPNi1Yzvz7nmHN1Pk0L27NyZ/7CCdeNYqWHYrrJP72VduYcdfLLPyf12nWvBnDvng6JV8aTuuORXUSX5IkSZIk1S8Wi/Lo3Z27mfjFu2jWsgWnfOESTvjEObRoWzdFmp1rdvDKj19m/oTXiIJg8PgSTv3yGbQ5sm6KVJIkSZIkqX6yWJRHLdoWcc4dX6TTgD40b9OqTmKWrS9j5k+nMe83r5JSYuDVgzntK2dS3L1uHneTJEmSJEn1m8WiPOt2Wr86ibN78y5m3T2d1x6cTWV5JQOuGsTpXz2Tdke3r5P4kiRJkiSpYbBY1Mjt3bqHWf89g7n3z6RibwX9Lj+Z4V87iw59jsh31yRJkiRJUj1ksaiR2rdjL3N++QpzfjmTd8v2ceK4/gz/2ll0PL5zvrsmSZIkSZLqMYtFjcy7u95l7n0zmfWLGezbtpfjLz6RM74xks79uuS7a5IkSZIkqQGwWNRIlO8p57UHZzPr7lL2bNnDsRf05YxbRtLl5G757pokSZIkSWpALBY1cBV7K3j9N3OY+dNSdm/cRe9RxzLilrPpNuSofHdNkiRJkiQ1QBaLGqjKdyuZ/8hcXvnxNMrW7aTniN5ccs/l9DitZ767JkmSJEmSGjCLRQ1MZXklix6dx4y7XmbHO9s56tSjGfPjj9LzzD757pokSZIkSWoELBY1EFWVVbzx+AKm/3Aq25dvpevg7px360fofc4xRES+uydJkiRJkhoJi0X1XKpKLH5qEdPvfIktSzdz5ICuXPrAxzn2guMtEkmSJEmSpFpnsaieSinx1rOLKb1jCpsWbaTTiZ255JeXc/yYE4kCi0SSJEmSJCk3LBbVMykl3v7LUkpvn8KG+es54riOXPyzcZzw0f4WiSRJkiRJUs5ZLKonUkqsnPI2026bwrpX19C+dwcuuuuj9PvYAAoKC/LdPUmSJEmS1ERYLKoHVk1bQentU1g9YxVte7Tj/Nsupv/HB9KsebN8d02SJEmSJDUxFovyaM3Md5h224usenkFbboVc+73LmLApwZR2NL/FkmSJEmSlB9WJfJg3dw1LL11Ia++Po2izkWc8+3zOeWaIRS2bp7vrkmSJEmSpCbOYlEd2jB/PaV3TGHZ80toVlzIyH87l0GfGUrzohb57pokSZIkSRJgsajOVFVW8acb/sDebXsZ8X/OoeyEvZR8ZHi+uyVJkiRJkvQ3LBbVkYJmBYz9xeW079WBVu1bMXny5Hx3SZIkSZIk6e8c1prsEdEvIkojYl9E3FJte8+ImBQRCyNiQUR8tdq+WyPi9Yh4qNq2ayLi5lq5ggak68ButGrfKt/dkCRJkiRJOqjDHVm0BbgJuOx92yuAb6SU5kREW2B2RLwArAaGppROiYh7I2IgsBQYD4ypWdclSZIkSZJU2w5rZFFKaUNKaSZQ/r7ta1NKc7Lf7wQWAT2AKqB5RARQlG13C/CTlNLfnEOSJEmSJEn5d1jFokMREX2AIcCMbOHoaeBVYC2wHTg9pfREbceVJEmSJElSzUVK6fAbRXwbKEsp3f6+7cXAi8D3UkqPHaDdvcDPgKHAhcDrKaXvHuC4G4AbALp27TpswoQJh93H+q6srIzi4uJ8d0NSPeU9QmpYzFmpaTL3pcapqeT26NGjZ6eUSg6070PnLIqIG4HPZ19enFJac5DjmgN/AB4+SKFoCBDAm8D3U0oXRcQDEdE3pbSk+rEppXuAewBKSkrSqFGjPqybDc7kyZNpjNclqXZ4j5AaFnNWaprMfalxMrcPoViUUrobuPuDjsnOSXQfsCildOdBDvsOmdFCzYFm2W1VZOYykiRJkiRJUj1wWKuhRUQ3YBbQDqiKiJuB/sApwLXAvIiYmz38mymlp7PtLgNmvTcqKSLmRsQ8Mo+hvVYL1yFJkiRJkqRacFjFopTSOuDoA+yaSuYRs4O1ewJ4otrrW8isiiZJkiRJkqR6pNZXQ5MkSZIkSVLDZbFIkiRJkiRJ+0VKKd99+EARsRFYke9+5EBnYFO+OyGp3vIeITUs5qzUNJn7UuPUVHK7d0rpyAPtqPfFosYqImallEry3Q9J9ZP3CKlhMWelpsnclxonc9vH0CRJkiRJklSNxSJJkiRJkiTtZ7Eof+7Jdwck1WveI6SGxZyVmiZzX2qcmnxuO2eRJEmSJEmS9nNkkSRJkiRJkvazWFRLIqJPRFxX7XXLiPhdRCyNiBkR0ecg7b4WEQsiYn5EPBIRrbLbj8m2W5o9T4u6uRJJuVCDe8RXs/eHBRFxc7XtHSPihYhYkv33iJxfhNSEHCBnz46IORFRERFXfkC7YRExL5vbP46IyG43Z6UGoAa5/72IWBURZe/b/vWIWBgRr0fExIjoncPuS/oA/0h+R0RRRPw5It7Ifh7/QbV910XExoiYm/26vg4uo85YLKoFEfEl4BngOxExOSK6AZ8DtqaUjgd+CNx6gHY9gJuAkpTSyUAz4JPZ3bcCP8y235o9n6QGqAb3iJOBzwOnAYOASyLi+Ozu/wdMTCn1BSZmX0uqBQfJ2ZXAdcBvP6T5z8nkbd/s15jsdnNWqudqmPtPkXm/fr9XyXzWPwV4FPiv2uuxpENVw/y+PaXUDxgCnBkRH6m273cppcHZr3tz0fd8Kcx3Bxq6iGgL/AeZD4OnAJOBXcA44NvZwx4FfhoRkf5+kqhCoHVElANFwJrsXyHPBa7OHvNg9lw/z9mFSMqJGt4jTgJmpJR2Z8/1InA5mQ+a44BR2eMezJ73/+buSqSm4WA5m1Jal91f9QFtuwPtUkrTs68fAi4j8+HUnJXqsZrkPkC1vH//9knVXk4Hrqm1Tks6JDXJ7+zn8EnZ79+NiDnA0bnuc33gyKKaqwIS0BEgpbQ8pbQT6AGsym6rALYDnao3TCmtBm4nU9FcC2xPKT2fPW5bth3AO9nzSWp4/uF7BDAfGBkRnSKiCLgY6Jnd1zWltDb7/Tqga06vQmo6Dpazh6IHmffs91R//zZnpfqtJrl/qD5HpngsqW7VSn5HRAfgo2RGCL/niuxjpo9GRM8Dt2yYHFlUQymlXRHxeeD7QLfsYyPfOpS22fkKxgHHANuA/4mIa4Bnc9RdSXWsJveIlNKiiLgVeJ7MaKS5QOUBjksR4dKWUi04WM6+N8KvlmKYs1I9k+vcz37GLwHOqY3zSTp0tZHfEVEIPAL8OKW0LLv5KeCRlNK+iPgCmZHD59Zy9/PGkUW1IKX0JPBxMo+GHAl8A1hNdgRA9gerPbD5fU3PB95OKW1MKZUDjwEjssd1yLaDzDC31bm+Dkm5UYN7BCml+1JKw1JKZ5OZv2xxdtf67CMv7z36siHX1yE1FQfJ2UOxmr8dml79/ducleq5GuT+B4qI84F/BS5NKe2rjXNKOjy1kN/3AEtSSndVO+fmajl9LzCsFrpab1gsqqGIKK62qsFOYBHQFngS+Ex2+5XA/x5gvqKVwPDsDOsBnAcsyh43KduO7Hn+mMPLkJQjNbxHEBFdsv/2IjNf0XsT8FVv7z1CqiUfkLMfKvuY2Y6IGJ59X/80f81Nc1aqx2qS+x9y3iHAL8gUiiwSS3lQ0/yOiO+S+cPuze/b3r3ay0uz52004gC/m+gwZB8le4TMXCOdyRSAriYzQuDXZGZM3wJ8MqW0LCKOAu5NKV2cbf8fwFVABZnVEq7PDmM7FphA5rnKV4Fr/EuE1PDUwj3ipWzbcuDrKaWJ2e2dgN8DvYAVwCdSSlvq8tqkxugDcvYo4HHgCGAvsC6lNCDbZm5KaXD2+xLgV0BrMnOTfCX72Jk5K9VjtZD7/1Xt+DVk3su/HRF/AQaSmZ8UYGVK6dK6ui5JNcvviDiazDyjbwDv/T7+05TSvRHxfTJFogoyn+e/lFJ6o+6uLLcsFtWSiOgDjEop/SrPXZFUD3mPkBoWc1Zqmsx9qfEyvw+Pj6HVnm1kJp+VpAPZhvcIqSHZhjkrNUXbMPelxmob5vchc2SRJEmSJEmS9nNkkSRJkiRJkvazWCRJkiRJkqT9LBZJkiRJkiRpP4tFkiRJkiRJ2s9ikSRJkiRJkvazWCRJkiRJkqT9/j/sv4MIPG3+2AAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -290,7 +282,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -354,8 +346,8 @@ " ['$0.80', '$0.90', '$1.00', '$1.12', '$1.25']\n", ")\n", "plt.yticks(\n", - " [-0.025 * i for i in range(7)],\n", - " [f'-{2.5 * i}%' for i in range(7)]\n", + " [-0.02 * i for i in range(7)],\n", + " [f'-{2 * i}%' for i in range(7)]\n", ")\n", "\n", "for i, loss in enumerate(impermanent_loss):\n", From 081e0958322ed356577dae8527bbb5ebd08636ad Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 29 Sep 2023 16:18:09 -0500 Subject: [PATCH 30/32] updated amplification code and graph ranges --- .../Stableswap/ImpermanentLossAnalysis.ipynb | 199 ++++++++++++++---- 1 file changed, 162 insertions(+), 37 deletions(-) diff --git a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb index a9207d3f..33002cbf 100644 --- a/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb +++ b/hydradx/notebooks/Stableswap/ImpermanentLossAnalysis.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.614450927Z", @@ -27,6 +27,7 @@ "import glob\n", "import random\n", "import copy\n", + "import math\n", "from IPython.display import display, Markdown\n", "sys.path.append('../..')\n", "\n", @@ -74,12 +75,63 @@ " },\n", " external_market={tkn: assets[tkn]['usd price'] for tkn in assets},\n", " # archive_all=False\n", - ")\n" + ")" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.614450927Z", + "start_time": "2023-07-06T20:00:30.645499714Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# find the trade sizes necessary to get the price we want to look at\n", + "invested_state = initial_state.agents['LP'].trade_strategy.execute(\n", + " initial_state.copy(),\n", + " agent_id='LP'\n", + ")\n", + "amps = [12.5, 25, 50, 100, 200, 400, 800] # , 10000000]\n", + "trade_range = [100000] * len(amps)\n", + "adjustment_factor = 1.0001\n", + "# print(trade_range)\n", + "for i, amp in enumerate(reversed(amps)):\n", + " target_price = 0.001\n", + " invested_state.pools['stableswap'].amplification = amp\n", + " try_state = invested_state.copy()\n", + " spot_price = 1\n", + " while (\n", + " spot_price > target_price \n", + " and not try_state.pools['stableswap'].fail\n", + " ):\n", + " # find the ~ correct trade size to get the price we want\n", + " trade_range[i] *= adjustment_factor\n", + " try_state = invested_state.copy()\n", + " sell_quantity = trade_range[i]\n", + " try_state.pools['stableswap'].swap(\n", + " agent=try_state.agents['Trader'],\n", + " tkn_sell='USDA' if sell_quantity > 0 else 'USDB',\n", + " tkn_buy='USDB' if sell_quantity > 0 else 'USDA',\n", + " sell_quantity=sell_quantity,\n", + " )\n", + " spot_price = try_state.pools['stableswap'].price('USDA', 'USDB')\n", + " print(spot_price, trade_range[i])\n", + " if try_state.pools['stableswap'].fail:\n", + " print('trade failed, use a smaller initial value or a smaller adjustment factor')\n", + "\n", + " if i < len(amps) - 1:\n", + " trade_range[i+1] = copy.copy(trade_range[i])\n", + "\n", + "trade_range.reverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -97,10 +149,9 @@ } ], "source": [ - "amps = [12.5, 25, 50, 100, 200, 400, 800] # , 10000000]\n", - "trade_range = [2300000, 1900000, 1700000, 1500000, 1100000, 990000, 910000] # , 507800]\n", "steps = 5000\n", "amp_events = []\n", + "trade_sizes = []\n", "invested_state = initial_state.agents['LP'].trade_strategy.execute(\n", " initial_state.copy(),\n", " agent_id='LP'\n", @@ -108,10 +159,16 @@ "for i, amplification in enumerate(amps):\n", " invested_state.pools['stableswap'].amplification = amplification\n", " trade_size_min, trade_size_max = -trade_range[i], trade_range[i]\n", - " trade_sizes = [trade_size_min + i * (trade_size_max - trade_size_min) / steps for i in range(steps)]\n", - " events = []\n", + " # trade_sizes.append(\n", + " # [(1 / (1 + math.exp(j / (steps - 1) * 1000 - 500)) * 2 - 1) * (trade_size_max if j < steps / 2 else -trade_size_min) for j in range(steps)]\n", + " # )\n", + " trade_sizes.append([trade_size_min + j * (trade_size_max - trade_size_min) / steps for j in range(steps)][::-1])\n", "\n", - " for trade_size in trade_sizes:\n", + " # print(trade_sizes[-1][0], trade_sizes[-1][-1])\n", + " # trade to change the price of assets. \n", + " # We assume that whatever the resulting price is the new market price, and the trade is an arb trade.\n", + " events = []\n", + " for trade_size in trade_sizes[-1]:\n", " # trade to change the price of assets. \n", " # We assume that the trade is an arb trade, and whatever the resulting price is the new market price.\n", " \n", @@ -120,7 +177,7 @@ " agent=new_state.agents['Trader'],\n", " tkn_sell='USDA' if trade_size > 0 else 'USDB',\n", " tkn_buy='USDB' if trade_size > 0 else 'USDA',\n", - " sell_quantity=max(abs(trade_size), 0),\n", + " sell_quantity=abs(trade_size),\n", " )\n", " if new_state.pools['stableswap'].fail:\n", " print(f\"failed with trade size {trade_size}\")\n", @@ -142,7 +199,73 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.614450927Z", + "start_time": "2023-07-06T20:00:30.645499714Z" + }, + "tags": [] + }, + "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": [ + "colors = pu.color_gradient(len(amp_events), (255, 160, 0), (120, 0, 160))\n", + "plt.figure(figsize=(20,5))\n", + "for i in range(len(amps)):\n", + " plt.plot(trade_sizes[i], color=colors[i])\n", + " plt.title('trade size')\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "for i in range(len(amps)):\n", + " usda_prices = pu.get_datastream(amp_events[i], asset='USDA')\n", + " plt.plot(trade_sizes[i], usda_prices, color=colors[i])\n", + " plt.yscale('log')\n", + " plt.title('price')\n", + "\n", + "# print(min(usda_prices))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-06T20:00:31.857764207Z", + "start_time": "2023-07-06T20:00:31.681435289Z" + }, + "tags": [] + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 50, "metadata": { "ExecuteTime": { "end_time": "2023-07-06T20:00:31.857764207Z", @@ -155,25 +278,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "withdraw vals: 38693.31110168434 - 38679.447716633935\n", - "deposit vals: 5459063.883129939 - 5452143.269209162\n", - "withdraw vals: 32601.062262776297 - 32589.52345404563\n", - "deposit vals: 5831307.125647275 - 5823661.37706083\n", - "withdraw vals: 29531.01450978018 - 29520.62730654679\n", - "deposit vals: 7996976.881893186 - 7986199.582767676\n", - "withdraw vals: 26450.267043381886 - 26441.0252924171\n", - "deposit vals: 10358550.001000993 - 10344056.134209413\n", - "withdraw vals: 20199.75214742055 - 20192.764888551454\n", - "deposit vals: 6476085.514061861 - 6465596.809359915\n", - "withdraw vals: 18434.186038222684 - 18427.799208916826\n", - "deposit vals: 8281060.5921689 - 8266515.91506627\n", - "withdraw vals: 17131.29648621797 - 17125.338529637313\n", - "deposit vals: 11240337.315232767 - 11218904.26952222\n" + "withdraw vals: 45.9653571482188 - 46.00567259542424\n", + "deposit vals: 5005.005679025259 - 5005.011886666203\n", + "withdraw vals: 37.78433162932457 - 37.81898330800086\n", + "deposit vals: 5005.004841537628 - 5005.01122380925\n", + "withdraw vals: 31.32156929092355 - 31.35204935766751\n", + "deposit vals: 5005.006445982795 - 5005.013086964742\n", + "withdraw vals: 26.224402532823888 - 26.252049725633967\n", + "deposit vals: 5005.005309355448 - 5005.012334962913\n", + "withdraw vals: 22.249648487014614 - 22.275766066316997\n", + "deposit vals: 5005.007013222778 - 5005.01462770513\n", + "withdraw vals: 19.16348357961593 - 19.18937264094511\n", + "deposit vals: 5005.007381368562 - 5005.015881828\n", + "withdraw vals: 16.797434075097872 - 16.824529620685436\n", + "deposit vals: 5005.009092387879 - 5005.018919705244\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -185,7 +308,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -197,7 +320,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -245,11 +368,14 @@ " [f'-{round(0.2 * i * 10, 2) / 10}%' for i in range(6)]\n", ")\n", "\n", + "# remove default ticks\n", + "for t in plt.gca().xaxis.get_minor_ticks():\n", + " t.set_visible(False)\n", + " \n", + "price_min, price_max = 0.98, 1.02\n", "for i, loss in enumerate(impermanent_loss):\n", - " center = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1))[0])\n", - " range_width = abs(center - usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1.022))[0]))\n", - " start_range = center - range_width\n", - " end_range = center + range_width\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0])\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0]) \n", " plt.plot(usda_prices[i][start_range: end_range], loss[start_range: end_range], color=colors[i])\n", "plt.legend(amps, loc='center', title='amplification')\n", "\n", @@ -269,8 +395,8 @@ "\n", "price_min, price_max = 0.80, 1.25\n", "for i, loss in enumerate(impermanent_loss):\n", - " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0]) + 1\n", - " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0])\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0]) + 1\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0]) \n", " plt.plot(usda_prices[i][start_range: end_range], loss[start_range: end_range], color=colors[i])\n", "plt.legend(amps, loc='center', title='amplification')\n", "plt.show()\n", @@ -293,11 +419,10 @@ "if 1 in tick_prices:\n", " tick_prices.remove(1)\n", "\n", + "price_min, price_max = 0.001, 1000\n", "for i, loss in enumerate(impermanent_loss):\n", - " center = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1))[0])\n", - " range_width = abs(center - usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - 1010))[0]))\n", - " start_range = center - range_width\n", - " end_range = center + range_width\n", + " end_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_max))[0])\n", + " start_range = usda_prices[i].index(sorted(usda_prices[i], key = lambda price: abs(price - price_min))[0])\n", " plt.plot(usda_prices[i][start_range: end_range], [1 + loss for loss in loss[start_range: end_range]], color=colors[i])\n", "\n", "plt.legend(amps, loc='center', title='amplification')\n", From 5dccaa48faa8bd9e7098122aecfb880ba69334ce Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Fri, 29 Sep 2023 16:50:04 -0500 Subject: [PATCH 31/32] probing reasons for failed test on pull request --- hydradx/tests/test_stableswap.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 439fe0eb..166a0918 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -6,7 +6,7 @@ from hydradx.model.amm.trade_strategies import random_swaps, stableswap_arbitrage from hydradx.model.amm.global_state import GlobalState from hydradx.model import run -from hypothesis import given, strategies as st, settings +from hypothesis import given, strategies as st, settings, reproduce_failure from mpmath import mp, mpf from hydradx.tests.strategies_omnipool import stableswap_config mp.dps = 50 @@ -68,10 +68,10 @@ def test_swap_invariant(initial_pool: StableSwapPoolState): st.integers(min_value=10, max_value=1000), st.integers(min_value=1, max_value=3) ) +@reproduce_failure('6.39.6', b'AAniqAxXWAxlag3jsgDeAA==') def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: int, i: int): - tokens = {"A": token_a, "B": token_b, "C": token_c, "D": token_d} initial_pool = StableSwapPoolState( - tokens=tokens, + tokens={"A": token_a, "B": token_b, "C": token_c, "D": token_d}, amplification=amp, trade_fee=0.0, unique_id='stableswap' @@ -80,13 +80,14 @@ def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: spot_price_initial = initial_pool.price(tkns[i], "A") trade_size = 1 - agent = Agent(holdings={"A": 1.1, "B": 1.1, "C": 1.1, "D": 1.1}) - initial_pool.swap(agent, tkn_sell="A", tkn_buy=tkns[i], sell_quantity=trade_size) - delta_a = initial_pool.liquidity["A"] - tokens["A"] - delta_b = tokens[tkns[i]] - initial_pool.liquidity[tkns[i]] + initial_agent = Agent(holdings={"A": 1.1, "B": 1.1, "C": 1.1, "D": 1.1}) + swap_agent = initial_agent.copy() + swap_pool = initial_pool.copy().swap(swap_agent, tkn_sell="A", tkn_buy=tkns[i], sell_quantity=trade_size) + delta_a = swap_pool.liquidity["A"] - initial_pool.liquidity["A"] + delta_b = initial_pool.liquidity[tkns[i]] - swap_pool.liquidity[tkns[i]] exec_price = delta_a / delta_b - spot_price_final = initial_pool.price(tkns[i], "A") + spot_price_final = swap_pool.price(tkns[i], "A") if spot_price_initial > exec_price and (spot_price_initial - exec_price)/spot_price_initial > 10e-10: raise AssertionError('Initial spot price should be lower than execution price.') @@ -400,4 +401,3 @@ def test_swap_one(amplification, swap_fraction): if buy_state.d != pytest.approx(initial_state.d): raise AssertionError('D changed after buy operation.') - From b3039d3927ad532a0ef0565a360206c56a66ecf8 Mon Sep 17 00:00:00 2001 From: jepidoptera Date: Mon, 2 Oct 2023 12:35:25 -0500 Subject: [PATCH 32/32] corrected stable_swap_equation for new definition of amplification --- hydradx/tests/test_stableswap.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/hydradx/tests/test_stableswap.py b/hydradx/tests/test_stableswap.py index 166a0918..b5561776 100644 --- a/hydradx/tests/test_stableswap.py +++ b/hydradx/tests/test_stableswap.py @@ -22,12 +22,12 @@ def stable_swap_equation(pool: StableSwapPoolState): # d: float, a: float, n: i """ this is the equation that should remain true at all times within a stableswap pool """ - a = pool.amplification + a = pool.ann d = pool.d n = pool.n_coins reserves = list(pool.liquidity.values()) - side1 = a * n ** n * sum(reserves) + d - side2 = a * n ** n * d + d ** (n + 1) / (n ** n * functools.reduce(lambda i, j: i * j, reserves)) + side1 = a * sum(reserves) + d + side2 = a * d + d ** (n + 1) / (n ** n * functools.reduce(lambda i, j: i * j, reserves)) return side1 == pytest.approx(side2) @@ -68,7 +68,6 @@ def test_swap_invariant(initial_pool: StableSwapPoolState): st.integers(min_value=10, max_value=1000), st.integers(min_value=1, max_value=3) ) -@reproduce_failure('6.39.6', b'AAniqAxXWAxlag3jsgDeAA==') def test_spot_price(token_a: int, token_b: int, token_c: int, token_d: int, amp: int, i: int): initial_pool = StableSwapPoolState( tokens={"A": token_a, "B": token_b, "C": token_c, "D": token_d},