diff --git a/configuration/equity_single.cfg b/configuration/equity_single.cfg new file mode 100644 index 0000000..d096b7b --- /dev/null +++ b/configuration/equity_single.cfg @@ -0,0 +1,26 @@ +{ + "security_type": "EQUITY", + "data_directory": "./data/equity", + "datafiles": [ + "20250605.mktdata.ohlcv.db", + ], + "db_table_name": "md_1min_bars", + "exchange_id": "ALPACA", + "instrument_id_pfx": "STOCK-", + "trading_hours": { + "begin_session": "9:30:00", + "end_session": "16:00:00", + "timezone": "America/New_York" + }, + "price_column": "close", + "min_required_points": 30, + "zero_threshold": 1e-10, + "dis-equilibrium_open_trshld": 2.0, + "dis-equilibrium_close_trshld": 1.0, + "training_minutes": 120, + "funding_per_pair": 2000.0, + "fit_method_class": "pt_trading.fit_methods.SlidingFit", + # "fit_method_class": "pt_trading.fit_methods.StaticFit", + "exclude_instruments": ["CAN"] + +} \ No newline at end of file diff --git a/lib/pt_trading/fit_methods.py b/lib/pt_trading/fit_methods.py index 0789bd0..8cd7051 100644 --- a/lib/pt_trading/fit_methods.py +++ b/lib/pt_trading/fit_methods.py @@ -9,6 +9,7 @@ from pt_trading.trading_pair import TradingPair NanoPerMin = 1e9 + class PairsTradingFitMethod(ABC): TRADES_COLUMNS = [ "time", @@ -19,17 +20,21 @@ class PairsTradingFitMethod(ABC): "scaled_disequilibrium", "pair", ] + @abstractmethod - def run_pair(self, config: Dict, pair: TradingPair, bt_result: BacktestResult) -> Optional[pd.DataFrame]: - ... - + def run_pair( + self, config: Dict, pair: TradingPair, bt_result: BacktestResult + ) -> Optional[pd.DataFrame]: ... + @abstractmethod - def reset(self): - ... + def reset(self) -> None: ... + class StaticFit(PairsTradingFitMethod): - def run_pair(self, config: Dict, pair: TradingPair, bt_result: BacktestResult) -> Optional[pd.DataFrame]: # abstractmethod + def run_pair( + self, config: Dict, pair: TradingPair, bt_result: BacktestResult + ) -> Optional[pd.DataFrame]: # abstractmethod pair.get_datasets(training_minutes=config["training_minutes"]) try: is_cointegrated = pair.train_pair() @@ -46,11 +51,15 @@ class StaticFit(PairsTradingFitMethod): print(f"{pair}: Prediction failed: {str(e)}") return None - pair_trades = self.create_trading_signals(pair=pair, config=config, result=bt_result) + pair_trades = self.create_trading_signals( + pair=pair, config=config, result=bt_result + ) return pair_trades - def create_trading_signals(self, pair: TradingPair, config: Dict, result: BacktestResult) -> pd.DataFrame: + def create_trading_signals( + self, pair: TradingPair, config: Dict, result: BacktestResult + ) -> pd.DataFrame: beta = pair.vecm_fit_.beta # type: ignore colname_a, colname_b = pair.colnames() @@ -201,43 +210,49 @@ class StaticFit(PairsTradingFitMethod): trd_signal_tuples, columns=self.TRADES_COLUMNS, # type: ignore ) - + def reset(self) -> None: pass + class PairState(Enum): INITIAL = 1 OPEN = 2 CLOSED = 3 + class SlidingFit(PairsTradingFitMethod): def __init__(self) -> None: super().__init__() self.curr_training_start_idx_ = 0 - def run_pair(self, config: Dict, pair: TradingPair, bt_result: BacktestResult) -> Optional[pd.DataFrame]: + def run_pair( + self, config: Dict, pair: TradingPair, bt_result: BacktestResult + ) -> Optional[pd.DataFrame]: print(f"***{pair}*** STARTING....") - pair.user_data_['state'] = PairState.INITIAL - pair.user_data_["trades"] = pd.DataFrame(columns=self.TRADES_COLUMNS) # type: ignore + pair.user_data_["state"] = PairState.INITIAL + pair.user_data_["trades"] = pd.DataFrame(columns=self.TRADES_COLUMNS) pair.user_data_["is_cointegrated"] = False - open_threshold = config["dis-equilibrium_open_trshld"] - close_threshold = config["dis-equilibrium_open_trshld"] - training_minutes = config["training_minutes"] + curr_predicted_row_idx = 0 while True: - print(self.curr_training_start_idx_, end='\r') + print(self.curr_training_start_idx_, end="\r") pair.get_datasets( training_minutes=training_minutes, training_start_index=self.curr_training_start_idx_, - testing_size=1 + testing_size=1, ) if len(pair.training_df_) < training_minutes: - print(f"{pair}: {self.curr_training_start_idx_} Not enough training data. Completing the job.") + print( + f"{pair}: {self.curr_training_start_idx_} Not enough training data. Completing the job." + ) if pair.user_data_["state"] == PairState.OPEN: - print(f"{pair}: {self.curr_training_start_idx_} Position is not closed.") + print( + f"{pair}: {self.curr_training_start_idx_} Position is not closed." + ) # outstanding positions # last_row_index = self.curr_training_start_idx_ + training_minutes @@ -259,16 +274,22 @@ class SlidingFit(PairsTradingFitMethod): raise RuntimeError(f"{pair}: Training failed: {str(e)}") from e if pair.user_data_["is_cointegrated"] != is_cointegrated: - pair.user_data_["is_cointegrated"] = is_cointegrated - if not is_cointegrated: - if pair.user_data_["state"] == PairState.OPEN: - print(f"{pair} {self.curr_training_start_idx_} LOST COINTEGRATION. Consider closing positions...") - else: - print(f"{pair} {self.curr_training_start_idx_} IS NOT COINTEGRATED. Moving on") + pair.user_data_["is_cointegrated"] = is_cointegrated + if not is_cointegrated: + if pair.user_data_["state"] == PairState.OPEN: + print( + f"{pair} {self.curr_training_start_idx_} LOST COINTEGRATION. Consider closing positions..." + ) else: - print('*' * 80) - print(f"Pair {pair} ({self.curr_training_start_idx_}) IS COINTEGRATED") - print('*' * 80) + print( + f"{pair} {self.curr_training_start_idx_} IS NOT COINTEGRATED. Moving on" + ) + else: + print("*" * 80) + print( + f"Pair {pair} ({self.curr_training_start_idx_}) IS COINTEGRATED" + ) + print("*" * 80) if not is_cointegrated: self.curr_training_start_idx_ += 1 continue @@ -278,34 +299,55 @@ class SlidingFit(PairsTradingFitMethod): except Exception as e: raise RuntimeError(f"{pair}: Prediction failed: {str(e)}") from e - if pair.user_data_["state"] == PairState.INITIAL: - - open_trades = self._get_open_trades(pair, open_threshold=open_threshold) - if open_trades is not None: - pair.user_data_["trades"] = open_trades - pair.user_data_["state"] = PairState.OPEN - elif pair.user_data_["state"] == PairState.OPEN: - close_trades = self._get_close_trades(pair, close_threshold=close_threshold) - if close_trades is not None: - pair.user_data_["trades"] = pd.concat([pair.user_data_["trades"], close_trades], ignore_index=True) - pair.user_data_["state"] = PairState.CLOSED - break + # break self.curr_training_start_idx_ += 1 + curr_predicted_row_idx += 1 + self._create_trading_signals(pair, config, bt_result) print(f"***{pair}*** FINISHED ... {len(pair.user_data_['trades'])}") - return pair.user_data_["trades"] + return pair.get_trades() - def _get_open_trades(self, pair: TradingPair, open_threshold: float) -> Optional[pd.DataFrame]: + def _create_trading_signals( + self, pair: TradingPair, config: Dict, bt_result: BacktestResult + ) -> None: + assert pair.predicted_df_ is not None + open_threshold = config["dis-equilibrium_open_trshld"] + close_threshold = config["dis-equilibrium_close_trshld"] + for curr_predicted_row_idx in range(len(pair.predicted_df_)): + pred_row = pair.predicted_df_.iloc[curr_predicted_row_idx] + if pair.user_data_["state"] in [PairState.INITIAL, PairState.CLOSED]: + open_trades = self._get_open_trades( + pair, row=pred_row, open_threshold=open_threshold + ) + if open_trades is not None: + open_trades["status"] = "OPEN" + print(f"OPEN TRADES:\n{open_trades}") + pair.add_trades(open_trades) + pair.user_data_["state"] = PairState.OPEN + elif pair.user_data_["state"] == PairState.OPEN: + close_trades = self._get_close_trades( + pair, row=pred_row, close_threshold=close_threshold + ) + if close_trades is not None: + close_trades["status"] = "CLOSE" + print(f"CLOSE TRADES:\n{close_trades}") + pair.add_trades(close_trades) + pair.user_data_["state"] = PairState.CLOSED + + def _get_open_trades( + self, pair: TradingPair, row: pd.Series, open_threshold: float + ) -> Optional[pd.DataFrame]: colname_a, colname_b = pair.colnames() + assert pair.predicted_df_ is not None predicted_df = pair.predicted_df_ - + # Check if we have any data to work with if len(predicted_df) == 0: return None - open_row = predicted_df.iloc[0] + open_row = row open_tstamp = open_row["tstamp"] open_disequilibrium = open_row["disequilibrium"] open_scaled_disequilibrium = open_row["scaled_disequilibrium"] @@ -316,6 +358,7 @@ class SlidingFit(PairsTradingFitMethod): return None # creating the trades + print(f"OPEN_TRADES: {row["tstamp"]} {open_scaled_disequilibrium=}") if open_disequilibrium > 0: open_side_a = "SELL" open_side_b = "BUY" @@ -338,7 +381,6 @@ class SlidingFit(PairsTradingFitMethod): pair.user_data_["close_side_a"] = close_side_a pair.user_data_["close_side_b"] = close_side_b - # create opening trades trd_signal_tuples = [ ( @@ -365,14 +407,16 @@ class SlidingFit(PairsTradingFitMethod): columns=self.TRADES_COLUMNS, # type: ignore ) - def _get_close_trades(self, pair: TradingPair, close_threshold: float) -> Optional[pd.DataFrame]: + def _get_close_trades( + self, pair: TradingPair, row: pd.Series, close_threshold: float + ) -> Optional[pd.DataFrame]: colname_a, colname_b = pair.colnames() - # Check if we have any data to work with + assert pair.predicted_df_ is not None if len(pair.predicted_df_) == 0: return None - close_row = pair.predicted_df_.iloc[0] + close_row = row close_tstamp = close_row["tstamp"] close_disequilibrium = close_row["disequilibrium"] close_scaled_disequilibrium = close_row["scaled_disequilibrium"] @@ -384,7 +428,6 @@ class SlidingFit(PairsTradingFitMethod): if close_scaled_disequilibrium > close_threshold: return None - trd_signal_tuples = [ ( close_tstamp, @@ -412,8 +455,5 @@ class SlidingFit(PairsTradingFitMethod): columns=self.TRADES_COLUMNS, # type: ignore ) - def reset(self): + def reset(self) -> None: self.curr_training_start_idx_ = 0 - - - diff --git a/lib/pt_trading/results.py b/lib/pt_trading/results.py index db3def4..c799e0d 100644 --- a/lib/pt_trading/results.py +++ b/lib/pt_trading/results.py @@ -1,28 +1,30 @@ -from typing import Any, Dict, List -import pandas as pd -import sqlite3 import os -from datetime import datetime, date +import sqlite3 +from datetime import date, datetime +from typing import Any, Dict, List, Optional, Tuple + +import pandas as pd +from pt_trading.trading_pair import TradingPair # Recommended replacement adapters and converters for Python 3.12+ # From: https://docs.python.org/3/library/sqlite3.html#sqlite3-adapter-converter-recipes -def adapt_date_iso(val): +def adapt_date_iso(val: date) -> str: """Adapt datetime.date to ISO 8601 date.""" return val.isoformat() -def adapt_datetime_iso(val): +def adapt_datetime_iso(val: datetime) -> str: """Adapt datetime.datetime to timezone-naive ISO 8601 date.""" return val.isoformat() -def convert_date(val): +def convert_date(val: bytes) -> date: """Convert ISO 8601 date to datetime.date object.""" return datetime.fromisoformat(val.decode()).date() -def convert_datetime(val): +def convert_datetime(val: bytes) -> datetime: """Convert ISO 8601 datetime to datetime.datetime object.""" return datetime.fromisoformat(val.decode()) @@ -172,7 +174,7 @@ def store_results_in_database( if db_path.upper() == "NONE": return - def convert_timestamp(timestamp): + def convert_timestamp(timestamp: Any) -> Optional[datetime]: """Convert pandas Timestamp to Python datetime object for SQLite compatibility.""" if timestamp is None: return None @@ -423,14 +425,14 @@ class BacktestResult: def add_trade( self, - pair_nm, - symbol, - action, - price, - disequilibrium=None, - scaled_disequilibrium=None, - timestamp=None, - ): + pair_nm: str, + symbol: str, + action: str, + price: Any, + disequilibrium: Optional[float] = None, + scaled_disequilibrium: Optional[float] = None, + timestamp: Optional[datetime] = None, + ) -> None: """Add a trade to the results tracking.""" pair_nm = str(pair_nm) @@ -442,11 +444,11 @@ class BacktestResult: (action, price, disequilibrium, scaled_disequilibrium, timestamp) ) - def add_outstanding_position(self, position: Dict[str, Any]): + def add_outstanding_position(self, position: Dict[str, Any]) -> None: """Add an outstanding position to tracking.""" self.outstanding_positions.append(position) - def add_realized_pnl(self, realized_pnl: float): + def add_realized_pnl(self, realized_pnl: float) -> None: """Add realized PnL to the total.""" self.total_realized_pnl += realized_pnl @@ -462,14 +464,12 @@ class BacktestResult: """Get all trades.""" return self.trades - def clear_trades(self): + def clear_trades(self) -> None: """Clear all trades (used when processing new files).""" self.trades.clear() - def collect_single_day_results(self, result): + def collect_single_day_results(self, result: pd.DataFrame) -> None: """Collect and process single day trading results.""" - if result is None: - return print("\n -------------- Suggested Trades ") print(result) @@ -482,16 +482,16 @@ class BacktestResult: scaled_disequilibrium = getattr(row, "scaled_disequilibrium", None) timestamp = getattr(row, "time", None) self.add_trade( - pair_nm=row.pair, - action=action, - symbol=symbol, - price=price, + pair_nm=str(row.pair), + action=str(action), + symbol=str(symbol), + price=float(str(price)), disequilibrium=disequilibrium, scaled_disequilibrium=scaled_disequilibrium, timestamp=timestamp, ) - def print_single_day_results(self): + def print_single_day_results(self) -> None: """Print single day results summary.""" for pair, symbols in self.trades.items(): print(f"\n--- {pair} ---") @@ -501,7 +501,7 @@ class BacktestResult: side, price = trade_data[:2] print(f"{symbol} {side} at ${price}") - def print_results_summary(self, all_results): + def print_results_summary(self, all_results: Dict[str, Dict[str, Any]]) -> None: """Print summary of all processed files.""" print("\n====== Summary of All Processed Files ======") for filename, data in all_results.items(): @@ -512,7 +512,7 @@ class BacktestResult: ) print(f"{filename}: {trade_count} trades") - def calculate_returns(self, all_results: Dict): + def calculate_returns(self, all_results: Dict[str, Dict[str, Any]]) -> None: """Calculate and print returns by day and pair.""" print("\n====== Returns By Day and Pair ======") @@ -527,80 +527,87 @@ class BacktestResult: # Calculate individual symbol returns in the pair for symbol, trades in symbols.items(): - if len(trades) >= 2: # Need at least entry and exit - # Get entry and exit trades - handle both old and new tuple formats - if len(trades[0]) == 2: # Old format: (action, price) - entry_action, entry_price = trades[0] - exit_action, exit_price = trades[1] - open_disequilibrium = None - open_scaled_disequilibrium = None - close_disequilibrium = None - close_scaled_disequilibrium = None + if len(trades) == 0: + continue + + symbol_return = 0 + symbol_trades = [] + + # Process all trades sequentially for this symbol + for i, trade in enumerate(trades): + # Handle both old and new tuple formats + if len(trade) == 2: # Old format: (action, price) + action, price = trade + disequilibrium = None + scaled_disequilibrium = None + timestamp = None else: # New format: (action, price, disequilibrium, scaled_disequilibrium, timestamp) - entry_action, entry_price = trades[0][:2] - exit_action, exit_price = trades[1][:2] - open_disequilibrium = ( - trades[0][2] if len(trades[0]) > 2 else None - ) - open_scaled_disequilibrium = ( - trades[0][3] if len(trades[0]) > 3 else None - ) - close_disequilibrium = ( - trades[1][2] if len(trades[1]) > 2 else None - ) - close_scaled_disequilibrium = ( - trades[1][3] if len(trades[1]) > 3 else None - ) - - # Calculate return based on action - symbol_return = 0 - if entry_action == "BUY" and exit_action == "SELL": + action, price = trade[:2] + disequilibrium = trade[2] if len(trade) > 2 else None + scaled_disequilibrium = trade[3] if len(trade) > 3 else None + timestamp = trade[4] if len(trade) > 4 else None + + symbol_trades.append((action, price, disequilibrium, scaled_disequilibrium, timestamp)) + + # Calculate returns for all trade combinations + for i in range(len(symbol_trades) - 1): + trade1 = symbol_trades[i] + trade2 = symbol_trades[i + 1] + + action1, price1, diseq1, scaled_diseq1, ts1 = trade1 + action2, price2, diseq2, scaled_diseq2, ts2 = trade2 + + # Calculate return based on action combination + trade_return = 0 + if action1 == "BUY" and action2 == "SELL": # Long position - symbol_return = ( - (exit_price - entry_price) / entry_price * 100 - ) - elif entry_action == "SELL" and exit_action == "BUY": + trade_return = (price2 - price1) / price1 * 100 + elif action1 == "SELL" and action2 == "BUY": # Short position - symbol_return = ( - (entry_price - exit_price) / entry_price * 100 - ) - + trade_return = (price1 - price2) / price1 * 100 + + symbol_return += trade_return + + # Store trade details for reporting pair_trades.append( ( symbol, - entry_action, - entry_price, - exit_action, - exit_price, - symbol_return, - open_scaled_disequilibrium, - close_scaled_disequilibrium, + action1, + price1, + action2, + price2, + trade_return, + scaled_diseq1, + scaled_diseq2, + i + 1, # Trade sequence number ) ) - pair_return += symbol_return + + pair_return += symbol_return # Print pair returns with disequilibrium information if pair_trades: print(f" {pair}:") for ( symbol, - entry_action, - entry_price, - exit_action, - exit_price, - symbol_return, - open_scaled_disequilibrium, - close_scaled_disequilibrium, + action1, + price1, + action2, + price2, + trade_return, + scaled_diseq1, + scaled_diseq2, + trade_num, ) in pair_trades: disequil_info = "" if ( - open_scaled_disequilibrium is not None - and close_scaled_disequilibrium is not None + scaled_diseq1 is not None + and scaled_diseq2 is not None ): - disequil_info = f" | Open Dis-eq: {open_scaled_disequilibrium:.2f}, Close Dis-eq: {close_scaled_disequilibrium:.2f}" + disequil_info = f" | Open Dis-eq: {scaled_diseq1:.2f}, Close Dis-eq: {scaled_diseq2:.2f}" print( - f" {symbol}: {entry_action} @ ${entry_price:.2f}, {exit_action} @ ${exit_price:.2f}, Return: {symbol_return:.2f}%{disequil_info}" + f" {symbol} (Trade #{trade_num}): {action1} @ ${price1:.2f}, {action2} @ ${price2:.2f}, Return: {trade_return:.2f}%{disequil_info}" ) print(f" Pair Total Return: {pair_return:.2f}%") day_return += pair_return @@ -610,7 +617,7 @@ class BacktestResult: print(f" Day Total Return: {day_return:.2f}%") self.add_realized_pnl(day_return) - def print_outstanding_positions(self): + def print_outstanding_positions(self) -> None: """Print all outstanding positions with share quantities and current values.""" if not self.get_outstanding_positions(): print("\n====== NO OUTSTANDING POSITIONS ======") @@ -684,22 +691,22 @@ class BacktestResult: print(f"{'TOTAL OUTSTANDING VALUE':<80} ${total_value:<12.2f}") - def print_grand_totals(self): + def print_grand_totals(self) -> None: """Print grand totals across all pairs.""" print(f"\n====== GRAND TOTALS ACROSS ALL PAIRS ======") print(f"Total Realized PnL: {self.get_total_realized_pnl():.2f}%") def handle_outstanding_position( self, - pair, - pair_result_df, - last_row_index, - open_side_a, - open_side_b, - open_px_a, - open_px_b, - open_tstamp, - ): + pair: TradingPair, + pair_result_df: pd.DataFrame, + last_row_index: int, + open_side_a: str, + open_side_b: str, + open_px_a: float, + open_px_b: float, + open_tstamp: datetime, + ) -> Tuple[float, float, float]: """ Handle calculation and tracking of outstanding positions when no close signal is found. diff --git a/lib/pt_trading/trading_pair.py b/lib/pt_trading/trading_pair.py index 427deb0..6bce348 100644 --- a/lib/pt_trading/trading_pair.py +++ b/lib/pt_trading/trading_pair.py @@ -1,4 +1,5 @@ from typing import Any, Dict, List, Optional + import pandas as pd # type:ignore from statsmodels.tsa.vector_ar.vecm import VECM, VECMResults # type:ignore @@ -19,6 +20,8 @@ class TradingPair: user_data_: Dict[str, Any] + predicted_df_: Optional[pd.DataFrame] + def __init__( self, market_data: pd.DataFrame, symbol_a: str, symbol_b: str, price_column: str ): @@ -31,7 +34,7 @@ class TradingPair: self.user_data_ = {} - self.predicted_df_ = pd.DataFrame() + self.predicted_df_ = None def _transform_dataframe(self, df: pd.DataFrame) -> pd.DataFrame: # Select only the columns we need @@ -127,9 +130,9 @@ class TradingPair: df = self.training_df_[self.colnames()].reset_index(drop=True) result = coint_johansen(df, det_order=0, k_ar_diff=1) - print( - f"{self}: lr1={result.lr1[0]} > cvt={result.cvt[0, 1]}? {result.lr1[0] > result.cvt[0, 1]}" - ) + # print( + # f"{self}: lr1={result.lr1[0]} > cvt={result.cvt[0, 1]}? {result.lr1[0] > result.cvt[0, 1]}" + # ) is_cointegrated: bool = bool(result.lr1[0] > result.cvt[0, 1]) return is_cointegrated @@ -146,21 +149,22 @@ class TradingPair: pvalue = coint(series1, series2)[1] # Define cointegration if p-value < 0.05 (i.e., reject null of no cointegration) is_cointegrated: bool = bool(pvalue < 0.05) - print(f"{self}: is_cointegrated={is_cointegrated} pvalue={pvalue}") + # print(f"{self}: is_cointegrated={is_cointegrated} pvalue={pvalue}") return is_cointegrated - def train_pair(self) -> bool: + def check_cointegration(self) -> bool: is_cointegrated_johansen = self.check_cointegration_johansen() is_cointegrated_engle_granger = self.check_cointegration_engle_granger() - if not is_cointegrated_johansen and not is_cointegrated_engle_granger: - return False - pass + result = is_cointegrated_johansen or is_cointegrated_engle_granger + return result or True # TODO: remove this + def train_pair(self) -> bool: + result = self.check_cointegration() # print('*' * 80 + '\n' + f"**************** {self} IS COINTEGRATED ****************\n" + '*' * 80) self.fit_VECM() assert self.training_df_ is not None and self.vecm_fit_ is not None diseq_series = self.training_df_[self.colnames()] @ self.vecm_fit_.beta - print(diseq_series.shape) + # print(diseq_series.shape) self.training_mu_ = float(diseq_series[0].mean()) self.training_std_ = float(diseq_series[0].std()) @@ -172,7 +176,16 @@ class TradingPair: diseq_series - self.training_mu_ ) / self.training_std_ - return True + return result + + def add_trades(self, trades: pd.DataFrame) -> None: + if self.user_data_["trades"] is None: + self.user_data_["trades"] = pd.DataFrame(trades) + else: + self.user_data_["trades"] = pd.concat([self.user_data_["trades"], pd.DataFrame(trades)], ignore_index=True) + + def get_trades(self) -> pd.DataFrame: + return self.user_data_["trades"] if "trades" in self.user_data_ else pd.DataFrame() def predict(self) -> pd.DataFrame: assert self.testing_df_ is not None @@ -184,24 +197,6 @@ class TradingPair: predicted_prices, columns=pd.Index(self.colnames()), dtype=float ) - # self.predicted_df_ = pd.merge( - # self.testing_df_.reset_index(drop=True), - # pd.DataFrame( - # predicted_prices, columns=pd.Index(self.colnames()), dtype=float - # ), - # left_index=True, - # right_index=True, - # suffixes=("", "_pred"), - # ).dropna() - - # self.predicted_df_["disequilibrium"] = ( - # self.predicted_df_[self.colnames()] @ self.vecm_fit_.beta - # ) - - # self.predicted_df_["scaled_disequilibrium"] = ( - # abs(self.predicted_df_["disequilibrium"] - self.training_mu_) - # / self.training_std_ - # ) predicted_df = pd.merge( self.testing_df_.reset_index(drop=True), @@ -222,17 +217,20 @@ class TradingPair: / self.training_std_ ) - print("*** PREDICTED DF") - print(predicted_df) - print("*" * 80) - print("*** SELF.PREDICTED_DF") - print(self.predicted_df_) - print("*" * 80) + # print("*** PREDICTED DF") + # print(predicted_df) + # print("*" * 80) + # print("*** SELF.PREDICTED_DF") + # print(self.predicted_df_) + # print("*" * 80) predicted_df = predicted_df.reset_index(drop=True) - self.predicted_df_ = pd.concat([self.predicted_df_, predicted_df], ignore_index=True) + if self.predicted_df_ is None: + self.predicted_df_ = predicted_df + else: + self.predicted_df_ = pd.concat([self.predicted_df_, predicted_df], ignore_index=True) # Reset index to ensure proper indexing - self.predicted_df_ = self.predicted_df_.reset_index() + self.predicted_df_ = self.predicted_df_.reset_index(drop=True) return self.predicted_df_ def __repr__(self) -> str: diff --git a/research/notebooks/pt_pair_backtest.ipynb b/research/notebooks/pt_pair_backtest.ipynb index e91f7c1..610820a 100644 --- a/research/notebooks/pt_pair_backtest.ipynb +++ b/research/notebooks/pt_pair_backtest.ipynb @@ -37,7 +37,8 @@ } }, "source": [ - "## Setup and Configuration\n" + "\n", + "# Settings" ] }, { @@ -60,6 +61,20 @@ "TRADING_DATE = \"20250605\" # Change this to your desired date\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup and Configuration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code Setup" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -171,8 +186,14 @@ " \n", " except Exception as e:\n", " print(f\"Error instantiating strategy {fit_method_class_name}: {e}\")\n", - " print(\"Falling back to StaticFi\")\n", - " return StaticFit()\n" + " raise Exception(f\"Error instantiating strategy {fit_method_class_name}: {e}\") from e\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Print Configuration" ] }, { @@ -403,6 +424,55 @@ "display(pair.market_data_.head())\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit Method Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def run_static_fit(config: Dict, pair: TradingPair, bt_result: BacktestResult) -> bool:\n", + " is_cointegrated = False\n", + " print(\"\\n=== STATIC FIT ANALYSIS ===\")\n", + " \n", + " # For StaticFit, we do traditional training/testing split\n", + " training_minutes = pt_bt_config[\"training_minutes\"]\n", + " pair.get_datasets(training_minutes=training_minutes)\n", + " \n", + " print(f\"Training data: {len(pair.training_df_)} rows\")\n", + " print(f\"Testing data: {len(pair.testing_df_)} rows\")\n", + " print(f\"Training period: {pair.training_df_['tstamp'].iloc[0]} to {pair.training_df_['tstamp'].iloc[-1]}\")\n", + " print(f\"Testing period: {pair.testing_df_['tstamp'].iloc[0]} to {pair.testing_df_['tstamp'].iloc[-1]}\")\n", + " \n", + " # Train and test cointegration\n", + " is_cointegrated = pair.train_pair()\n", + " print(f\"Pair cointegration status: {is_cointegrated}\")\n", + " \n", + " if is_cointegrated:\n", + " print(f\"VECM Beta coefficients: {pair.vecm_fit_.beta.flatten()}\")\n", + " print(f\"Training dis-equilibrium mean: {pair.training_mu_:.6f}\")\n", + " print(f\"Training dis-equilibrium std: {pair.training_std_:.6f}\")\n", + " \n", + " # Generate predictions and run strategy\n", + " pair.predict()\n", + " pair_trades = FIT_MODEL.run_pair(config=pt_bt_config, pair=pair, bt_result=bt_result)\n", + " \n", + " if pair_trades is not None and len(pair_trades) > 0:\n", + " print(f\"Generated {len(pair_trades)} trading signals\")\n", + " else:\n", + " print(\"No trading signals generated\")\n", + " else:\n", + " print(\"Pair is not cointegrated - cannot proceed with strategy\")\n", + "\n", + " return is_cointegrated\n" + ] + }, { "cell_type": "markdown", "metadata": { @@ -411,12 +481,12 @@ } }, "source": [ - "## Strategy Specifics\n" + "## Print Strategy Specifics\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -491,7 +561,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -604,12 +674,13 @@ } }, "source": [ - "## Run Strategy-Specific Analysis\n" + "# Run\n", + "## Analysis\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -621,79 +692,133 @@ "=== SLIDING FIT ANALYSIS ===\n", "Processing first 200 iterations for demonstration...\n", "***COIN & MSTR*** STARTING....\n", - "COIN & MSTR: lr1=30.445006392026055 > cvt=15.4943? True\n", - "COIN & MSTR: is_cointegrated=False pvalue=0.29476776822663775\n", - "(120, 1)\n", "********************************************************************************\n", "Pair COIN & MSTR (0) IS COINTEGRATED\n", "********************************************************************************\n", - "*** PREDICTED DF\n", - " tstamp close_COIN close_MSTR close_COIN_pred \\\n", - "0 2025-06-05 15:30:00 260.73 381.485 260.065349 \n", + "COIN & MSTR: 272 Not enough training data. Completing the job.\n", + "OPEN_TRADES: 2025-06-05 15:40:00 open_scaled_disequilibrium=np.float64(2.1021479687626523)\n", + "OPEN TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 15:40:00 SELL COIN 260.465 1.991597 \n", + "1 2025-06-05 15:40:00 BUY MSTR 380.530 1.991597 \n", "\n", - " close_MSTR_pred disequilibrium scaled_disequilibrium \n", - "0 381.189719 1.750999 1.008934 \n", - "********************************************************************************\n", - "*** SELF.PREDICTED_DF\n", - "Empty DataFrame\n", - "Columns: []\n", - "Index: []\n", - "********************************************************************************\n", - "COIN & MSTR: lr1=30.346329918396787 > cvt=15.4943? True\n", - "COIN & MSTR: is_cointegrated=True pvalue=0.03322921089121464\n", - "(120, 1)\n", - "*** PREDICTED DF\n", - " tstamp close_COIN close_MSTR close_COIN_pred \\\n", - "0 2025-06-05 15:31:00 260.41 381.41 260.422353 \n", + " scaled_disequilibrium pair status \n", + "0 2.102148 COIN & MSTR OPEN \n", + "1 2.102148 COIN & MSTR OPEN \n", + "CLOSE TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 16:02:00 BUY COIN 259.3853 0.208324 \n", + "1 2025-06-05 16:02:00 SELL MSTR 379.9023 0.208324 \n", "\n", - " close_MSTR_pred disequilibrium scaled_disequilibrium \n", - "0 381.411833 1.483524 0.825227 \n", - "********************************************************************************\n", - "*** SELF.PREDICTED_DF\n", - " index tstamp close_COIN close_MSTR close_COIN_pred \\\n", - "0 0 2025-06-05 15:30:00 260.73 381.485 260.065349 \n", + " scaled_disequilibrium pair status \n", + "0 0.744767 COIN & MSTR CLOSE \n", + "1 0.744767 COIN & MSTR CLOSE \n", + "OPEN_TRADES: 2025-06-05 16:31:00 open_scaled_disequilibrium=np.float64(2.0704276873028338)\n", + "OPEN TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 16:31:00 SELL COIN 259.62 1.917107 \n", + "1 2025-06-05 16:31:00 BUY MSTR 377.25 1.917107 \n", "\n", - " close_MSTR_pred disequilibrium scaled_disequilibrium \n", - "0 381.189719 1.750999 1.008934 \n", - "********************************************************************************\n", - "COIN & MSTR: lr1=39.13391186424609 > cvt=15.4943? True\n", - "COIN & MSTR: is_cointegrated=True pvalue=0.0009997257779409195\n", - "(120, 1)\n", - "*** PREDICTED DF\n", - " tstamp close_COIN close_MSTR close_COIN_pred \\\n", - "0 2025-06-05 15:32:00 260.1999 380.78 260.158717 \n", + " scaled_disequilibrium pair status \n", + "0 2.070428 COIN & MSTR OPEN \n", + "1 2.070428 COIN & MSTR OPEN \n", + "CLOSE TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 16:42:00 BUY COIN 257.28 0.471149 \n", + "1 2025-06-05 16:42:00 SELL MSTR 375.58 0.471149 \n", "\n", - " close_MSTR_pred disequilibrium scaled_disequilibrium \n", - "0 381.366385 1.722156 1.060651 \n", - "********************************************************************************\n", - "*** SELF.PREDICTED_DF\n", - " level_0 index tstamp close_COIN close_MSTR \\\n", - "0 0 0.0 2025-06-05 15:30:00 260.73 381.485 \n", - "1 1 NaN 2025-06-05 15:31:00 260.41 381.410 \n", + " scaled_disequilibrium pair status \n", + "0 0.762836 COIN & MSTR CLOSE \n", + "1 0.762836 COIN & MSTR CLOSE \n", + "OPEN_TRADES: 2025-06-05 16:46:00 open_scaled_disequilibrium=np.float64(2.199766239888042)\n", + "OPEN TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 16:46:00 BUY COIN 254.6100 -2.275201 \n", + "1 2025-06-05 16:46:00 SELL MSTR 376.1044 -2.275201 \n", "\n", - " close_COIN_pred close_MSTR_pred disequilibrium scaled_disequilibrium \n", - "0 260.065349 381.189719 1.750999 1.008934 \n", - "1 260.422353 381.411833 1.483524 0.825227 \n", - "********************************************************************************\n" + " scaled_disequilibrium pair status \n", + "0 2.199766 COIN & MSTR OPEN \n", + "1 2.199766 COIN & MSTR OPEN \n", + "CLOSE TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 17:34:00 SELL COIN 252.83 0.248202 \n", + "1 2025-06-05 17:34:00 BUY MSTR 375.00 0.248202 \n", + "\n", + " scaled_disequilibrium pair status \n", + "0 0.957174 COIN & MSTR CLOSE \n", + "1 0.957174 COIN & MSTR CLOSE \n", + "OPEN_TRADES: 2025-06-05 18:51:00 open_scaled_disequilibrium=np.float64(2.1149913107636116)\n", + "OPEN TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 18:51:00 SELL COIN 245.77 61.682717 \n", + "1 2025-06-05 18:51:00 BUY MSTR 372.40 61.682717 \n", + "\n", + " scaled_disequilibrium pair status \n", + "0 2.114991 COIN & MSTR OPEN \n", + "1 2.114991 COIN & MSTR OPEN \n", + "CLOSE TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 19:10:00 BUY COIN 245.59 9.682403 \n", + "1 2025-06-05 19:10:00 SELL MSTR 370.66 9.682403 \n", + "\n", + " scaled_disequilibrium pair status \n", + "0 0.979289 COIN & MSTR CLOSE \n", + "1 0.979289 COIN & MSTR CLOSE \n", + "OPEN_TRADES: 2025-06-05 19:15:00 open_scaled_disequilibrium=np.float64(2.006393273424948)\n", + "OPEN TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 19:15:00 SELL COIN 244.020 325.962059 \n", + "1 2025-06-05 19:15:00 BUY MSTR 368.225 325.962059 \n", + "\n", + " scaled_disequilibrium pair status \n", + "0 2.006393 COIN & MSTR OPEN \n", + "1 2.006393 COIN & MSTR OPEN \n", + "CLOSE TRADES:\n", + " time action symbol price disequilibrium \\\n", + "0 2025-06-05 19:16:00 BUY COIN 243.27 -22.525948 \n", + "1 2025-06-05 19:16:00 SELL MSTR 367.22 -22.525948 \n", + "\n", + " scaled_disequilibrium pair status \n", + "0 0.701777 COIN & MSTR CLOSE \n", + "1 0.701777 COIN & MSTR CLOSE \n", + "***COIN & MSTR*** FINISHED ... 20\n", + "Generated 20 trading signals\n", + "\n", + "Strategy execution completed!\n", + "\n", + "================================================================================\n", + "BACKTEST RESULTS\n", + "================================================================================\n", + "\n", + "Detailed Trading Signals:\n", + "Time Action Symbol Price Scaled Dis-eq \n", + "--------------------------------------------------------------------------------\n", + "2025-06-05 15:40:00 SELL COIN $260.46 2.102 \n", + "2025-06-05 15:40:00 BUY MSTR $380.53 2.102 \n", + "2025-06-05 16:02:00 BUY COIN $259.39 0.745 \n", + "2025-06-05 16:02:00 SELL MSTR $379.90 0.745 \n", + "2025-06-05 16:31:00 SELL COIN $259.62 2.070 \n", + "2025-06-05 16:31:00 BUY MSTR $377.25 2.070 \n", + "2025-06-05 16:42:00 BUY COIN $257.28 0.763 \n", + "2025-06-05 16:42:00 SELL MSTR $375.58 0.763 \n", + "2025-06-05 16:46:00 BUY COIN $254.61 2.200 \n", + "2025-06-05 16:46:00 SELL MSTR $376.10 2.200 \n", + "... and 10 more trading signals\n", + "\n", + "====== NO OUTSTANDING POSITIONS ======\n", + "\n", + "====== GRAND TOTALS ACROSS ALL PAIRS ======\n", + "Total Realized PnL: 0.00%\n", + "\n", + "================================================================================\n" ] }, { - "ename": "RuntimeError", - "evalue": "COIN & MSTR: Prediction failed: cannot insert level_0, already exists", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[32m~/develop/pairs_trading/lib/pt_trading/fit_methods.py\u001b[39m in \u001b[36m?\u001b[39m\u001b[34m(self, config, pair, bt_result)\u001b[39m\n\u001b[32m 277\u001b[39m pair.predict()\n\u001b[32m 278\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m Exception \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m--> \u001b[39m\u001b[32m279\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m RuntimeError(f\"{pair}: Prediction failed: {str(e)}\") \u001b[38;5;28;01mfrom\u001b[39;00m e\n\u001b[32m 280\u001b[39m \n", - "\u001b[32m~/develop/pairs_trading/lib/pt_trading/trading_pair.py\u001b[39m in \u001b[36m?\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 233\u001b[39m self.predicted_df_ = pd.concat([self.predicted_df_, predicted_df], ignore_index=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 234\u001b[39m \u001b[38;5;66;03m# Reset index to ensure proper indexing\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m235\u001b[39m self.predicted_df_ = self.predicted_df_.reset_index()\n\u001b[32m 236\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m self.predicted_df_\n", - "\u001b[32m~/.pyenv/python3.12-venv/lib/python3.12/site-packages/pandas/core/frame.py\u001b[39m in \u001b[36m?\u001b[39m\u001b[34m(self, level, drop, inplace, col_level, col_fill, allow_duplicates, names)\u001b[39m\n\u001b[32m 6477\u001b[39m )\n\u001b[32m 6478\u001b[39m \n\u001b[32m-> \u001b[39m\u001b[32m6479\u001b[39m new_obj.insert(\n\u001b[32m 6480\u001b[39m \u001b[32m0\u001b[39m,\n", - "\u001b[32m~/.pyenv/python3.12-venv/lib/python3.12/site-packages/pandas/core/frame.py\u001b[39m in \u001b[36m?\u001b[39m\u001b[34m(self, loc, column, value, allow_duplicates)\u001b[39m\n\u001b[32m 5163\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;01mnot\u001b[39;00m allow_duplicates \u001b[38;5;28;01mand\u001b[39;00m column \u001b[38;5;28;01min\u001b[39;00m self.columns:\n\u001b[32m 5164\u001b[39m \u001b[38;5;66;03m# Should this be a different kind of error??\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m5165\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ValueError(f\"cannot insert {column}, already exists\")\n\u001b[32m 5166\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;01mnot\u001b[39;00m is_integer(loc):\n", - "\u001b[31mValueError\u001b[39m: cannot insert level_0, already exists", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[31mRuntimeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 59\u001b[39m\n\u001b[32m 55\u001b[39m pair.user_data_[\u001b[33m\"\u001b[39m\u001b[33mis_cointegrated\u001b[39m\u001b[33m\"\u001b[39m] = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m 57\u001b[39m \u001b[38;5;66;03m# Run the sliding fit method\u001b[39;00m\n\u001b[32m 58\u001b[39m \u001b[38;5;66;03m# ==========================================================================\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m59\u001b[39m pair_trades = \u001b[43mFIT_MODEL\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_pair\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpt_bt_config\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpair\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpair\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbt_result\u001b[49m\u001b[43m=\u001b[49m\u001b[43mbt_result\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 60\u001b[39m \u001b[38;5;66;03m# ==========================================================================\u001b[39;00m\n\u001b[32m 62\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m pair_trades \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(pair_trades) > \u001b[32m0\u001b[39m:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/develop/pairs_trading/lib/pt_trading/fit_methods.py:279\u001b[39m, in \u001b[36mSlidingFit.run_pair\u001b[39m\u001b[34m(self, config, pair, bt_result)\u001b[39m\n\u001b[32m 277\u001b[39m pair.predict()\n\u001b[32m 278\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m--> \u001b[39m\u001b[32m279\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpair\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m: Prediction failed: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mstr\u001b[39m(e)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01me\u001b[39;00m\n\u001b[32m 281\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m pair.user_data_[\u001b[33m\"\u001b[39m\u001b[33mstate\u001b[39m\u001b[33m\"\u001b[39m] == PairState.INITIAL:\n\u001b[32m 283\u001b[39m open_trades = \u001b[38;5;28mself\u001b[39m._get_open_trades(pair, open_threshold=open_threshold)\n", - "\u001b[31mRuntimeError\u001b[39m: COIN & MSTR: Prediction failed: cannot insert level_0, already exists" + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/oleg/develop/pairs_trading/lib/pt_trading/trading_pair.py:185: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n", + " self.user_data_[\"trades\"] = pd.concat([self.user_data_[\"trades\"], pd.DataFrame(trades)], ignore_index=True)\n" ] } ], @@ -707,37 +832,7 @@ "\n", "# Run strategy-specific analysis\n", "if FIT_METHOD_TYPE == \"StaticFit\":\n", - " print(\"\\n=== STATIC FIT ANALYSIS ===\")\n", - " \n", - " # For StaticFit, we do traditional training/testing split\n", - " training_minutes = pt_bt_config[\"training_minutes\"]\n", - " pair.get_datasets(training_minutes=training_minutes)\n", - " \n", - " print(f\"Training data: {len(pair.training_df_)} rows\")\n", - " print(f\"Testing data: {len(pair.testing_df_)} rows\")\n", - " print(f\"Training period: {pair.training_df_['tstamp'].iloc[0]} to {pair.training_df_['tstamp'].iloc[-1]}\")\n", - " print(f\"Testing period: {pair.testing_df_['tstamp'].iloc[0]} to {pair.testing_df_['tstamp'].iloc[-1]}\")\n", - " \n", - " # Train and test cointegration\n", - " is_cointegrated = pair.train_pair()\n", - " print(f\"Pair cointegration status: {is_cointegrated}\")\n", - " \n", - " if is_cointegrated:\n", - " print(f\"VECM Beta coefficients: {pair.vecm_fit_.beta.flatten()}\")\n", - " print(f\"Training dis-equilibrium mean: {pair.training_mu_:.6f}\")\n", - " print(f\"Training dis-equilibrium std: {pair.training_std_:.6f}\")\n", - " \n", - " # Generate predictions and run strategy\n", - " pair.predict()\n", - " pair_trades = FIT_MODEL.run_pair(config=pt_bt_config, pair=pair, bt_result=bt_result)\n", - " \n", - " if pair_trades is not None and len(pair_trades) > 0:\n", - " print(f\"Generated {len(pair_trades)} trading signals\")\n", - " else:\n", - " print(\"No trading signals generated\")\n", - " else:\n", - " print(\"Pair is not cointegrated - cannot proceed with strategy\")\n", - "\n", + " is_cointegrated = run_static_fit(config=pt_bt_config, pair=pair, bt_result=bt_result)\n", "elif FIT_METHOD_TYPE == \"SlidingFit\":\n", " print(\"\\n=== SLIDING FIT ANALYSIS ===\")\n", " \n", @@ -771,6 +866,8 @@ "print(\"BACKTEST RESULTS\")\n", "print(\"=\"*80)\n", "\n", + "assert pair.predicted_df_ is not None\n", + "\n", "if pair_trades is not None and len(pair_trades) > 0:\n", " # Print detailed results using BacktestResult methods\n", " bt_result.print_single_day_results()\n", @@ -810,8 +907,8 @@ " print(f\" Close threshold: {pt_bt_config['dis-equilibrium_close_trshld']}\")\n", " print(f\" Training window: {pt_bt_config['training_minutes']} minutes\")\n", " \n", - " if FIT_METHOD_TYPE == \"StaticFit\" and 'is_cointegrated' in locals():\n", - " if is_cointegrated:\n", + " if FIT_METHOD_TYPE == \"StaticFit\":\n", + " if 'is_cointegrated' in locals() and is_cointegrated:\n", " print(f\" Cointegration: ✓ Confirmed\")\n", " if hasattr(pair, 'predicted_df_') and len(pair.predicted_df_) > 0:\n", " scaled_diseq = pair.predicted_df_['scaled_disequilibrium']\n", @@ -821,7 +918,8 @@ " print(f\" Note: Max dis-equilibrium ({max_abs_diseq:.3f}) never reached open threshold ({pt_bt_config['dis-equilibrium_open_trshld']})\")\n", " else:\n", " print(f\" Cointegration: ✗ Not detected\")\n", - " \n", + " elif FIT_METHOD_TYPE == \"SlidingFit\":\n", + " pass # TODO: Implement sliding fit cointegration check\n", "print(\"\\n\" + \"=\"*80)\n" ] }, @@ -833,17 +931,41 @@ } }, "source": [ - "## Strategy-Specific Visualization\n" + "## Visualization\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== SLIDING FIT FIT_MODEL VISUALIZATION ===\n", + "Note: Sliding strategy visualization requires detailed tracking data\n", + "For full sliding window visualization, run the complete sliding analysis\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABv4AAAY1CAYAAADq3KlfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8U/X+x/H3yeoulLbsKVMFZDhYLlygFwcq7vFTxHFxojJUwAWoqLhx4BYB9XoVRa5er3uj4sDFEJANBWmBjiTn/P44JG1om4Y0HUlfz8eDR3qSk+SbwzdNmnc+n69hWZYlAAAAAAAAAAAAAHHNUdcDAAAAAAAAAAAAAFB9BH8AAAAAAAAAAABAAiD4AwAAAAAAAAAAABIAwR8AAAAAAAAAAACQAAj+AAAAAAAAAAAAgARA8AcAAAAAAAAAAAAkAII/AAAAAAAAAAAAIAEQ/AEAAAAAAAAAAAAJgOAPAAAAAAAAAAAASAAEfwAAAADiykMPPaSuXbvW9TBqXNeuXfXQQw/F7Pb+9a9/qWvXrlqzZk3MbjPejRs3ToMHD67rYVTbmjVr1LVrV/3rX/8KnlfR82Tw4MEaN25ccDswJ3766adq3f+etwsAAACg7rjqegAAAAAA4kOkYdvzzz+vQw45pFr3VVhYqKeeekoHH3xwtW8rlsaNG6fXX389uJ2WlqbWrVvr5JNP1rnnniuPx1OHo6tZ5513nr7++uvgdlJSktq1a6dTTz1V559/vhyOuv1e6UMPPaSHH344uJ2cnKysrCx169ZNxxxzjIYNG5bQ/z8AAAAAIBH8AQAAAIjQ3XffHbL9xhtv6LPPPit3fseOHat9X4WFhXr44Yc1evTocsHf5ZdfrlGjRlX7PqLl8Xh0xx13SJIKCgr0n//8R3fddZd++ukn3X///TG7nx9//FFOpzNmtxcLzZs313XXXSdJ2rZtm9566y1NnTpV27Zt07XXXlvHo7NNnjxZqampKikp0caNG/Xpp59qwoQJeu655/T444+rRYsWwX1vv/12WZZVh6ONjVatWunHH3+UyxX+T/yFCxfKMIyY339N3S4AAACAvUfwBwAAACAiJ510Usj2Dz/8oM8++6zc+TXN5XJVGXDU9P2Xfcxnn322Tj/9dC1YsEDjxo1Ts2bNor5t0zTl9XqVlJSkpKSkWAw3pjIyMkIe+1lnnaWhQ4fqhRde0FVXXVUvgsrjjjtOTZo0CW6PHj1ab775psaOHaurr75a8+bNC17mdrvrYogxZxhGRPMllhWPlmWpuLhYycnJVFICAAAA9Qhr/AEAAACIGdM09eyzz+qEE05Qjx49NGDAAE2cOFHbt28P2e+nn37SxRdfrEMOOUQ9e/bU4MGDNX78eEn2emX9+/eXJD388MPq2rVryHp3Fa1d1rVrV912223673//q3/84x/q3r27TjjhBH388cflxvjVV19p+PDh6tGjh44++mjNmTOnWusGOhwOHXzwwZKktWvXSpJKSkr04IMP6phjjlH37t11+OGH6+6771ZJSUmF437zzTeDx+yTTz4JXrbnGn+//PKLRo4cqT59+qh379664IILtHjx4nJjWrp0qc4//3z17NlThx12mB599FGZplluv4KCAi1fvlwFBQVRPfakpCR1795dO3fuVF5eXvD83377TePGjdNRRx2lHj16aODAgRo/fry2bdsWsk/Xrl31/vvvB8/7+eef1bVrV51yyikh9zNy5EidfvrpUY1Rkk488USdfvrpwbA6oKI1/t5++20NHz5cvXv3Vp8+fTRs2DA999xzEd3Pxo0bNX78eA0YMCA4B1999dVy+23YsEFXXHGFevXqpf79+2vKlCn65JNP1LVrV3311VfB/SpbO++8887TeeedF9yuaI2/ilR2e0VFRZo4caIOOeQQ9enTRzfeeGO55+zgwYN16aWX6pNPPtHw4cPVs2dPzZkzp8Lbrez5VNE6k4HbDTwve/bsqWHDhgWPw7vvvqthw4apR48eGj58uH755ZewjxEAAABo6Kj4AwAAABAzEydO1Ouvv67hw4frvPPO05o1a/TSSy/pl19+0csvvyy32628vDxdfPHFysrK0qhRo5SZmak1a9bovffekyQ1adJEkydP1uTJk3XMMcfomGOOkVT1GoPffvut3n33XZ199tlKS0sLVqF98MEHysrKklQanOXm5urKK6+UaZp65JFHQirEovHXX39Jkho3bizTNHX55Zfr22+/1YgRI9SxY0f98ccfeu6557Ry5Uo9+uijIdf98ssv9c477+icc85RVlaWWrVqVeF9LF26VOecc47S0tI0cuRIuVwuzZ07V+edd55efPFFHXDAAZKkzZs36/zzz5ff79eoUaOUkpKiefPmVVgR9t5772n8+PGaOnWqhg8fHtVjX7t2rQzDUGZmZvC8zz//XH/99ZeGDx+u3NxcLV26VPPmzdOyZcs0b948GYahLl26KDMzU4sWLdJRRx0lSVq0aJEcDod+++037dixQ+np6TJNU99//71GjBgR1fgCTjzxRM2dO1effvqpBg4cWOE+n332ma677jr1799f119/vSRpxYoV+u6773TBBReEvf0tW7ZoxIgRMgxD55xzjpo0aaKPP/5YN910k3bs2KELL7xQkh2yXXDBBVq/fr3OO+88NW3aVG+88Ya+/PLLaj2+6rjtttuUmZmp0aNH688//9TLL7+sdevW6YUXXghp4fnnn39qzJgxOuOMMzRixAh16NAhJve/atUqjRkzRmeeeaZOPPFEPf3007rssst066236v7779dZZ50lSXriiSd0zTXXaOHChXW+piQAAABQXxH8AQAAAIiJRYsW6ZVXXtH06dM1bNiw4PmHHHKIRo4cqYULF2rYsGH6/vvvtX37ds2aNUs9evQI7hdYIy41NVXHHXecJk+erK5du0bcSnT58uVasGCB2rZtG7zfk046SW+//bbOPfdcSdKDDz4op9Opl19+OdiSc+jQoTr++OP36rFu3bpVkrRjxw698847+u9//6uuXbtqn3320RtvvKHPP/9cL7zwgg488MDgdTp37qxJkybpu+++U58+fYLn//nnn5o/f746deoU9j5nzJghr9erl19+WW3atJEknXzyyRoyZIjuuecevfjii5KkJ598Ulu3btUrr7yinj17SpJOOeUUHXvssXv1GCvi9/uDj/3vv//Wq6++qp9//llHHHGEkpOTg/udffbZuuiii0Ku26tXL1133XX69ttvdeCBB8rhcKhPnz5atGhRcJ9vv/1WRx99tN5//3199913Ouyww4IhYNljGY0uXbpIKg1pK/Lhhx8qPT1ds2bN2uu2pffff7/8fr/mz58fDJrPOussXXfddXr44Yd15plnKjk5WXPnztXKlSs1Y8YMDR06VJI0YsSIWm+ZW5bb7dazzz4bbH3asmVL3XPPPfrf//4XDGUlO6B76qmndOihh8b0/v/880/NmTNHvXv3liR16tRJF198sW655Ra98847atmypSSpUaNGmjhxor755ptya38CAAAAsPEVOQAAAAAxsXDhQmVkZGjgwIHaunVr8N/++++v1NTUYOu+jIwMSXbI4vV6Y3b/AwYMCIZ+ktStWzelp6cHgx6/368vvvhCRx11VMg6fO3atdurIGPXrl3q37+/+vfvr2OOOUb33XefevXqpUceeUSSfRw6duyoffbZJ+Q49OvXT5JCWjlK0kEHHVRl6Of3+/XZZ5/p6KOPDoZ+ktS0aVP94x//0LfffqsdO3ZIkj766CP16tUrGPpJdhVl2TA2YPjw4fr9998jrvZbsWJF8LEPHTpUs2bN0uDBgzV16tSQ/cqGgMXFxdq6dWuwInHJkiXBy/r27atffvlFu3btkmQHf4cddpi6deumb7/9VpIdKBuGob59+0Y0xsqkpqZKknbu3FnpPpmZmSosLAxpBxoJy7L07rvvavDgwbIsK+T/fdCgQSooKAg+7o8//li5ubkaMmRI8PopKSnVrmisjjPOOCNkvcOzzjpLLpdLH330Uch+rVu3jnnoJ9lBXyD0kxScK/369QuGfmXPDxfeAgAAAA0dFX8AAAAAYmLVqlUqKCgIrs+3p8AacAcffLCOO+44Pfzww3r22Wd18MEH6+ijj9awYcPk8Xiivv8WLVqUO69Ro0bKz88P3n9RUZHatWtXbr+KzqtMUlKSZs6cKUnyeDxq3bq1mjdvHrx81apVWr58eZXHIaB169ZV3ufWrVtVWFhYYWvFjh07yjRNrV+/Xp07d9a6deuCAUlZsWjL2KpVK91xxx0yTVOrV6/WzJkztW3btnJtRP/++289/PDDWrBgQbnHW3Y9wQMPPFA+n0+LFy9W8+bNlZeXpwMPPFDLli0LVgIuWrRInTp1UuPGjas19kC4mJaWVuk+Z599tt555x1dcsklatasmQYOHKihQ4fqsMMOkxRa8RjQqFEjFRQUKD8/X3PnztXcuXMrvO3A9dauXat27dqFtNCUYvP/E609539aWppyc3ODa1YGRDJXo7Hnczfw5YCyzytJSk9Pl6TgcxoAAABAeQR/AAAAAGLCNE1lZ2dr+vTpFV4eWEfPMAw9+OCDWrx4sT744AN98sknmjBhgp555hnNnTs3bDATTmWtGS3Liur2wt3PgAEDKr3cNE116dJF48ePr/DyPcOMstVx9V1qamrIY+/Tp4+GDx+u+++/XzfffHPw/GuuuUbff/+9Lr74Yu27775KTU2VaZoaOXJkyP9H9+7dlZSUpG+++UYtW7ZUdna2OnTooAMPPFCzZ89WSUlJsP1ndf3xxx+SFFIVuqfs7Gz9+9//1qeffqqPP/5YH3/8sf71r3/p5JNP1l133aX169eHtL6UpOeff1777LOPJHsdwVNOOaXC265qjcq94ff797oVaSxEOlf3DDUD/H5/hedX9lhq6zkNAAAAJBKCPwAAAAAx0bZtW33xxRfq06dPRAFBr1691KtXL1177bWaP3++rr/+ei1YsECnn356pcFBdWRnZyspKUmrVq0qd1lF50Wrbdu2+u2339S/f/+YPY4mTZooJSVFf/75Z7nLVqxYIYfDEayaatmyZYWPp6LrVle3bt104oknas6cObrooovUsmVLbd++XV988YWuvPJKjR49OrjvypUry13f4/GoZ8+eWrRokVq2bBlcx69v374qKSnRm2++qS1btuiggw6q9ljffPNNSaqyVaXH49HgwYM1ePBgmaapyZMna+7cubriiivUvHlzPfPMMyH7B1rKpqWlyTTNsKGwZFdN/vHHH7IsK2R+VPT/U7Zitax169aFtHytrlWrVgVb0Up2O9TNmzcHKx33VmZmpiS7Mi/ws2SPGwAAAEDNYo0/AAAAADExdOhQ+f1+Pfroo+Uu8/l8wQBj+/bt5Sp29t13X0lSSUmJJHvNMym2Lf0ClXrvv/++Nm7cGDx/1apV+uSTT2J2P0OHDtXGjRs1b968cpcVFRUFW07uDafTqYEDB+r999/XmjVrgudv2bJFb731lvr27Rtsg3j44Ydr8eLF+vHHH4P7bd26VfPnzy93uwUFBVq+fHlI+829NXLkSPl8vmAgVlmV1nPPPVfh+X379tWPP/6or776KriOX5MmTdSxY0c9+eSTkhQMBKM1f/58vfLKK+rdu3elLVgladu2bSHbDocjWKlXUlKipKQkDRgwIORfo0aN5HQ6ddxxx+k///lPsLKwrLLtQQ877DBt2rRJCxcuDJ5XWFhY4Xxp06aNfvjhh+DzQpI++OADrV+/PvIHH4G5c+eGrLf58ssvy+fzRR38Baoqv/nmm+B5u3bt0r///e9qjRMAAABA1aj4AwAAABATBx98sM444ww9/vjj+vXXXzVw4EC53W6tXLlSCxcu1E033aQhQ4bo9ddf18svv6yjjz5abdu21c6dOzVv3jylp6cHg4bk5GR16tRJ77zzjtq3b6/GjRurc+fO6tKlS7XGOHr0aH366ac666yzdNZZZ8k0Tb344ovq3Lmzfv3111gcBp100kl65513NGnSJH311Vfq06eP/H6/VqxYoYULF+qpp55Sjx499vp2r7nmGn3++ec6++yzdfbZZ8vpdGru3LkqKSnRDTfcENxv5MiReuONNzRy5Eidf/75SklJ0bx589SyZUv9/vvvIbf53nvvafz48Zo6daqGDx8e1ePt1KmTDj/8cL366qu64oorlJWVpYMOOkhPPfWUvF6vmjVrps8++ywksCzrwAMP1MyZM7V+/fqQgO/AAw/U3Llz1apVq3LtUcP5z3/+o9TUVHm9Xm3cuFGffvqpvvvuO3Xr1k0PPPBA2OvefPPN2r59u/r166dmzZpp3bp1evHFF7XvvvuqY8eOYa87ZswYffXVVxoxYoROP/10derUSdu3b9eSJUv0xRdf6Ouvv5YkjRgxQi+99JLGjh2rJUuWKDc3V2+88UaFVbKnn366/vOf/2jkyJEaOnSoVq9erfnz54dtVxoNr9erCy+8UEOHDtWff/6p2bNnq2/fvuXamkZq4MCBatmypW666SatWLFCTqdTr732mrKysqj6AwAAAGoYwR8AAACAmLntttvUvXt3zZkzR/fff7+cTqdatWqlE088UX369JFkB4Q//fSTFixYoC1btigjI0M9e/bU9OnTQ9oX3nHHHbr99ts1depUeb1ejR49utrBX/fu3fXkk0/q7rvv1gMPPKAWLVroqquu0ooVK7RixYpq3XaAw+HQI488omeffVZvvPGG3nvvPaWkpKh169Y677zz1KFDh6hut3PnznrppZd077336vHHH5dlWerZs6fuueceHXDAAcH9mjZtqueff1533HGHnnjiCTVu3FhnnnmmmjZtqptuuikmj3FPF198sT788EO9+OKLuvLKK3Xvvffq9ttv1+zZs2VZlgYOHKgnn3yywjabvXv3ltPpVHJysrp16xY8PxD87W213+TJkyVJSUlJysrK0r777qspU6Zo2LBh8ng8Ya974oknat68eZo9e7by8/OVm5uroUOH6sorr5TDEb5hTk5Ojl555RU98sgjeu+99/Tyyy+rcePG6tSpk66//vrgfikpKXr22Wd1++2368UXX1RycrKGDRumww47TCNHjgy5zUMPPVTjxo3TM888oylTpqh79+6aOXOm7rrrrr06JlWZOHGi5s+frwcffFBer1cnnHCCbr755qhb1brdbj388MO69dZb9cADDyg3N1cXXHCBMjMzK137EgAAAEBsGBarYgMAAABo4K644gotW7ZM7777bl0PBQ3UV199pfPPP1/PP/+8DjnkkLoeDgAAAIA4xRp/AAAAABqUoqKikO2VK1fq448/1sEHH1xHIwIAAAAAIDZo9QkAAACgQTn66KN1yimnqE2bNlq7dq3mzJkjt9tdrs0iAAAAAADxhuAPAAAAQINy6KGH6u2339bmzZvl8XjUq1cvXXfddWrfvn1dDw0AAAAAgGphjT8AAAAAAAAAAAAgAbDGHwAAAAAAAAAAAJAACP4AAAAAAAAAAACABMAaf1HavLmgrocQdxwOQ02apGnr1p0yTTrMon5jviJeMFcRT5iviCfMV8QT5iviCfMV8YT5injCfEU8Yb5GJzc3I6L9qPhDrXE4DBmGIYfDqOuhAFViviJeMFcRT5iviCfMV8QT5iviCfMV8YT5injCfEU8Yb7WLII/AAAAAAAAAAAAIAEQ/AEAAAAAAAAAAAAJgOAPAAAAAAAAAAAASAAEfwAAAAAAAAAAAEACIPgDAAAAAAAAAAAAEgDBHwAAAAAAAAAAAJAACP4AAAAAAAAAAACABEDwBwAAAAAAAAAAACQAgj8AAAAAAAAAAAAgARD8AQAAAAAAAAAAAAmA4A8AAAAAAAAAAABIAAR/AAAAAAAAAAAAQAIg+AMAAAAAAAAAAGigBg06UB9//GFdD6NKZce5fv06DRp0oJYu/V2S9N13izRo0IEqKCiQJC1YMF9DhhwR1f2MHj1KDzxwbyyGXCdcdT0AAAAAAAAAAAAAxNadd07WO++8JUlyOp3KzGykjh076eijj9Pxxw+Tw2HXhr3xxkJlZGTW5VAjEm6cPXocoDfeWKj09PRq38+UKffI5Yrf+Cx+Rw4AAAAAAAAAAIBKHXLIAE2YMFGmaWrr1q366qvP9cAD9+rDD9/XtGn3yeVyKTs7p66HGZFw43S73dV+HF6vV263W5mZjap1O3WNVp8AAAAAAAAAAAAJyOOxA7Hc3Kbq2rWbzj//Ik2bdq++/PLzYDVg2RaaXq9X9913l0466TgNHjxAp576D73wwjNh72Pjxg265ZZxGjLkCA0dOljjxl2n9evXBS/3+/166KH7NGTIETr++KP00EMzNHbsWN1443XBfU47bZjmzZsdcrsXXni2Zs16PLgdriXpnq0+Az7++EOdeeYpGjx4gK67brQ2btwQvGzWrMd14YVna/78f+v000/U4MEDJJVv9VnR/Q4ZcoQWLJgvqbTt6Pvvv6crrhipwYMHauTI87V69Sr9+usSXXzxeTrmmEM1ZsxV2rZtW9hjGQtU/AEAAAAAAAAAAOyF9esN7dhh1Nr9padbatHCislt9e17kDp16qKPPvqfhg07OeSyV16Zo08//Vi33TZNzZo118aNG7Vp04aKb0iSz+fTmDFXav/9e+iRR56S0+nUc8/N0pgxV+q55+bI7XZrzpwXtWDBWxo/fqLateuguXNf0v/+95769j0oJo+nMkVFRXr++ad18823yuVy6957p2ny5Al67LGng/usXfuXPvzwf7rzzrvlcDirdX9PP/24rrpqjJo1a66pU2/TrbferNTUVF199RglJydr4sTxmjVrpq6/fnx1H1pYBH8AAAAAAAAAAAAR2r5duvDCFJlm7d2nwyHNm7dLjWLUhbJdu3ZavnxZufM3bdqgNm3aqmfPXjIMQ82btwh7O++//65M09S4cbfIMOwgdMKESRoy5Ah9//23Ovjgfpo372Wdd96FOvzwwZKksWMn6JtvvozNAwnD5/Pp2mtv1P77d5ck3XzzrTrnnNP0yy8/a7/97PO8Xq9uvvlWZWVlVfv+zjrrXB1ySH9J0umnn6nJk2/SAw88pp49e0mSTjjhJL3zzvxq309VCP4AAAAAAAAAoBoKC6Vff3WoT59aTAEA1JlGjaRnny2s9Yq/WIV+kmRZklR+/EOHDtO11/5TZ511qvr1668BAw7VwQf3kyTdc88UvfvuO8F933vvEy1btlRr167RscceFnI7JSUlWrt2jXbs2KG8vC3BoE2SXC6XunfvrpISX+weUAWcTqf23Xe/4Ha7du2Vnp6hVatWBsfTvHmLmIR+ktSxY+fgz02aZEuS9tmnU5nzmtDqEwAAAAAAAADqu88/d+ruu5P09tu75OITV6BBsNtuxqb1Zl1YtepPtWzZstz5Xbt20yuvvKEvv/xcixZ9rYkTx+nAAw/WHXfcrZEjL9NZZ50Xsn9h4S516dJNkybdUe62GjeOPFAzDIcsK/R4+nw1GwxKUnJySpX7GIYR0dhcFbwAlD3Pvp2a/4IIL0MAAAAAAAAAUA3FxYZMU/L5RPAHoN779ttvtHz5Mo0YcXaFl6elpeuoo47VUUcdqyOOOEpjxlyp/PztyspqoqysJiH7dunSTe+//56ysrKUlpZe4e1lZ+fol19+Vq9efSTZodmSJUvUuXPX4D6NGzdWXt6W4PbOnTu0fv3aaj1Ov9+v3377JVjdt3r1Su3YUaB27drv1e00bpwVMra//lqtoqKiao2tJvEyBAAAAAAAAADV4Pfbp7VQnAIAe6WkxKu8vC0yTVNbt27VV199rhdeeFYDBhyqIUNOKLf/nDkvKjs7R126dJNhGPrgg/8qOztb6ekZFd7+sccO1ezZL2jcuDEaOfIy5eY21YYN6/Xxxx/o7LPPV9OmzXT66WfqxRefU+vWbdWuXXvNm/eS8vPzQ26nb9+D9M478zVw4GFKT8/QU0/NlMPhrNZjd7lcuv/+e3TNNTfI6XTq/vvv1v779whpOxqJPn0O1L/+NU/du/eQaZp67LGHKqzuqy/q78gAAAAAAAAAIA6Yuzu3BQJAAKgvvvrqc5100hA5nU5lZGSqU6fOuuaa6zV06D/kcDjK7Z+amqbZs5/XmjV/yeFwqFu3/XXPPQ9UuK8kJScn65FHntBjjz2km266Qbt27VJOTq769j1YaWlpkqQzzzxXeXl5uvPOSTIMh4YNO0nHHHOMtm79O3g75513odavX6sbb7xGaWnpuuSSy7V+/bpqPfbk5GSde+4FuvXWm7Rly2b17NlL48ZN3OvbufLKazVlyq365z8vUXZ2rq6+eox+//3Xao2tJhnWno1J48gTTzyhe++9V+eff75uuukmSVJxcbGmTZumBQsWqKSkRIMGDdKkSZOUk5MTvN66des0efJkffXVV0pNTdXJJ5+sMWPG7FVCu3lzQcwfT6JzuRzKykrTtm075fOx0DHqN+Yr4gVzFfGE+Yp4wnxFPGG+Ip4wXxFP9ma+vvaaSzNnejR37i41aRJ2V6BG8PsV8cTlcuiuu25XXt42TZkyva6HEzdycyuuutxTxRFtHPjxxx81Z84cde3aNeT8KVOm6IMPPtCMGTP0wgsvaNOmTRo9enTwcr/fr0svvVRer1dz5szRtGnT9Prrr+vBBx+s7YcAAAAAAAAAIAGUtvo06nYgAIAGLy6Dv507d+qGG27QHXfcoUaNGgXPLygo0GuvvaZx48apf//+6t69u6ZMmaLvv/9eixcvliR9+umnWrZsme655x7tu+++Ovzww3X11VfrpZdeUklJSR09IgAAAAAAAADxKhD8mRRaAQDqWFyu8Xfbbbfp8MMP14ABA/TYY48Fz//555/l9Xo1YMCA4HkdO3ZUy5YttXjxYvXq1UuLFy9Wly5dQlp/Dho0SJMnT9ayZcu03377RTQGh8OQw8E3ePaG0+kIOQXqM+Yr4gVzFfGE+Yp4wnxFPGG+Ip4wXxFP9ma+WpZDhiFJDrlccbuyEuIYv18RT5xOh6ZNm6b8/EL5/XxjItbiLvh7++239csvv+jVV18td9mWLVvkdruVmZkZcn52drY2b94c3Kds6CcpuB3YJxJNmqTJMAj+opGZmVLXQwAixnxFvGCuIp4wXxFPmK+IJ8xXxBPmK+JJJPM1OVlyOqW0tFRlZdXCoIBK8PsV8YT5WjPiKvhbv3697rzzTj399NNKSkqq07Fs3bqTir+95HQ6lJmZQoqPuMB8RbxgriKeMF8RT5iviCfMV8QT5iviyd7M14ICl/x+l/LyipWVRcUfah+/XxFPmK/RycpKi2i/uAr+lixZory8PA0fPjx4nt/v1zfffKOXXnpJs2bNktfrVX5+fkjVX15ennJzcyXZ1X0//vhjyO1u2bJFkoL7RMI0LZkmL+LR8PtN+Xw8mREfmK+IF8xVxBPmK+IJ8xXxhPmKeMJ8RTyJZL6WlFiyLPuUuY26xO9XxBPma82Iq+CvX79+mj9/fsh548eP1z777KNLLrlELVq0kNvt1hdffKHjjjtOkrRixQqtW7dOvXr1kiT16tVLM2fOVF5enrKzsyVJn3/+udLT09WpU6dafTwAAAAAAAAA4p/fb5/6fHU7DgAA4ir4S09PV5cuXULOS01NVePGjYPnn3rqqZo2bZoaNWqk9PR03XHHHerdu3cw+Bs0aJA6deqkG2+8UTfccIM2b96sGTNm6JxzzpHH46nthwQAAAAAAAAgzgWCv8ApAAB1Ja6Cv0hMmDBBDodDV111lUpKSjRo0CBNmjQpeLnT6dTMmTM1efJknXHGGUpJSdEpp5yiq666qg5HDQAAAAAAACBe+f3G7tM6HggAoMGL++DvhRdeCNlOSkrSpEmTQsK+PbVq1UpPPvlkTQ8NAAAAAAAAQANAxR+AhuC004ZpxIizNGLE2RHt/913i3TVVZfpnXc+UEZGRg2PDgFxH/wBAAAAAAAAQF0qXePPqNuBAICkQYMODHv5//3fJbr44kv3+naffPJ5paSkRLx/jx4H6I03Fio9PX2v72tvBALG9PQMvfHGQiUlJQUv+/XXJbrkkgskSZ9+uqhGx1FfEPwBAAAAAAAAQDX4fPYpFX8A6oM33lgY/Pn999/TrFkzNXv2a8HzUlJSgz9bliW/3y+Xq+q4KCsra6/G4Xa7lZ2ds1fXqY7U1FR9/PEHOuaYIcHz3nrrDTVr1lwbN26otXHUNUddDwAAAAAAAAAA4plp2qcEf0DD4Vy2tMp/IbzeKvd3rPwz9DqFhRXfVhWys3OC/9LT02UYRnB71aqVOvbYw/TFF5/poovO1ZFH9tePPy7W2rVrNG7cdRo27Fgdc8yhGjnyfH3zzVcht3vaacM0b97s4PagQQdq/vx/a/z463XUUQN15pmn6NNPPwpe/t13izRo0IEqKCiQJC1YMF9DhhyhL7/8XEOHDtWRRw7UddddqS1btgSv4/P5NGPGPRoy5Agdf/xRevTRB3XHHZM0fvyYKh/30KH/0NtvvxncLi4u0vvvv6uhQ/9Rbt8fflisK64YqcGDB2r48BM0Y8Y9KiwsDF6+cOHbuvji83TMMYfpxBOP0+TJN2nbtq3lHtuiRV/r4ovP01FHDdRll12k1atXVjnOmkbFHwAAAAAAAABUQ2mrz7odB4Dakzb5pvA7GIbyX5hburl9e5XXMXNytWPGI8Ft5+pVSrt9oiQp/8V50Q+2AjNnPqzRo69Wy5atlZGRoY0bN6pfv4EaNeoKud0eLVz4tsaOvU6zZ7+m5s2bV3o7zzzzpC6//Er9859X69VX5+rWW2/Ra6/NV2Zmowr3Lyoq0ksvvaC7775bO3YUa/Lkm/XIIzM0adIdkqSXXnpO7767UOPHT1L79h30yisv65NPPlSfPuHbl0rScccdr5dffkEbNmxQ8+bN9eGH/1Pz5i3VpUu3kP3Wrl2j66+/UpdccrnGj5+ov//epvvvv1v333+3JkyYJMkOIEeOvExt27bTtm3b9PDD9+vOOydr+vQHQ27riSce1ejR16hx4yxNnz5VU6fepscee7rKsdYkKv4AAAAAAAAAoBoCa/tR8QcgXowceakOOqifWrVqrczMRurcuYtOPvlU7bNPJ7Vp01aXXHK5WrVqpc8++yjs7Qwd+g8dc8wQtW7dRpde+k8VFu7SL78sqXR/n8+nsWMnqEePHurWbV8NHz5C3377TfDy116bp3PPvVCHH36k2rVrr2uvvVHp6RkRPaasrCY65JABeued+ZKkt99+UyeccGK5/V544Rkdc8wQjRhxttq0aasePQ7Q1VffoIUL31ZxcbEk6R//OEn9+w9Uq1at1b17D11zzfX68svPtWvXrpDbGjXqCvXu3VcdOuyjc8+9QD/99GPwNuoKFX8AAAAAAAAAUA2BVp9U/AENx87Jd+7V/lajRlVex9pjnT1/23Z7fT+R6tZtv5DtXbt26emnn9AXX3yqvLwt8vv9Ki4urnJtvI4dOwd/TklJUVpaWkhLzD0lJyerdes2we3s7Jzg/jt27NDWrXnab7/9g5c7nU517bqvLMuM6HGdcMKJeuCBe3XssUP1888/6fbbp+mHHxaH7LNs2VItX75U771XuhaiZVkyTVPr169T+/Yd9Ntvv+rpp5/QsmV/qKCgIHj/GzduUIcO+1T4+APrGW7bti1slWRNI/gDAAAAAAAAgGoIVPr5/UbdDgRArfF36lz1TmW53Xt/nZSUvb9OhJKTU0K2H3lkhr755iv985/XqHXrNkpKStLNN4+V1xv+Gw2uPcJKwzBkWVbM9t9b/foN0D333Klp027XwIGHqlGjxuX2KSzcpZNOGq7TTjuz3GXNmjVXYWGhxowZrYMP7q9Jk+5Q48ZZ2rhxg667brR8Pm+lj8cw7NeASEPKmkLwBwAAAAAAAADVEKj0o9UngHj1008/6Pjjh+nww4+UZFcAbtiwTlLfWhtDenq6mjTJ1q+//qJevfpIkvx+v/744zd17twlottwuVw67rgTNHv28+XW4wvo0qWb/vzzz5DKw7KWL1+m7du367LLRqtZM7ty77fffoniEdUN1vgDAAAAAAAAgGoorfir23EAQLRat26rjz76n5Yu/V1Ll/6hW2+9SaYZu0q8SJ166gi9+OIz+uSTD7V69Uo98MB0FRTkS4q8ovqSSy7XW2/9V4cc0r/Cy8855wL9/PMPuu++u7R06e/666/V+uSTD3XffXdJsqv+3G63XnttrtauXaNPP/1Izz77VHUfWq2h4g8AAAAAAAAAqoE1/gDEuyuvvFZTp96myy67SI0aNdY551ygnTt31vo4zjnnAm3dmqc77pgkh8OpE088RQcf3F8OR+R1bG63W40bN6708k6dOuvhh5/QE088qiuuuESSpZYtW+uoo46RJGVlZWnChEl64olH9eqrc9WlSzf985/XaNy466r56GqHYcWyeWoDsnlzQV0PIe64XA5lZaVp27ad8vnqtsctUBXmK+IFcxXxhPmKeMJ8RTxhviKeMF8RT/Zmvl51VbJ+/dWhiy8u0Zlnkv6h9vH7FfFkb+araZo655zTNHjwMbrkkstraYT1U25uRkT7UfEHAAAAAAAAANVQusZf5K3oAADlbdiwXl9//aV69eojr9er116bq/Xr1+mYY4bU9dDiBsEfAAAAAAAAAFQDrT4BIDYMw9A778zXI4/MkGVJ++zTUTNmPKr27TvU9dDiBsEfAAAAAAAAAFRDacVf3Y4DAOJds2bN9dhjT9f1MOJa5KshAgAAAAAAAADKCQR+BH8AgLpG8AcAAAAAAAAA1RAI/Gj1CQCoawR/AAAAAAAAAFANpmlIknw+o45HAgBo6Aj+AAAAAAAAAKAaApV+plm34wAAgOAPAAAAAAAAAKqBVp8AgPqC4A8AAAAAAAAAqiEQ/AVOAQCoKwR/AAAAAAAAAFANBH8AgPqC4A8AAAAAAAAAqoHgDwBQXxD8AQAAAAAAAEA1+P2GJMnnM+p4JACAho7gDwAAAAAAAACqwTTtUyr+AAB1jeAPAAAAAAAAAKJkmgR/AID6g+APAAAAAAAAAKJUNuzz+epuHAAASAR/AAAAAAAAABC1QPBnGFT8AQDqHsEfAAAAAAAAAEQpEPZ5PJZ8PqNuBwMAaPAI/gAAAAAAAAAgSoH1/ZKSqPgDANQ9gj8AAAAAAAAAiFJgXT+PhzX+AAB1j+APAAAAAAAAAKIUaO/p8VjB6j8AAOoKwR8AAAAAAAAARKlsq08q/gAAdY3gDwAAAAAAAACiFFjXz+NhjT8AQN0j+AMAAAAAAACAKAXCvqQkS36/UbeDAQA0eAR/AAAAAAAAABAlKv4AAPUJwR8AAAAAAAAARKls8McafwCAukbwBwAAAAAAAABRCrT39HgsKv4AAHWO4A8AAAAAAAAAohSo8ktKouIPAFD3CP4AAAAAAAAAIEqhrT6Nuh0MAKDBI/gDAAAAAAAAgCiZpn2alGQFfwYAoK4Q/AEAAAAAAABAlAIVf263/bNl1e14AAANG8EfAAAAAAAAAEQpsK5fcrKd+FH1BwCoSwR/AAAAAAAAABAl07TX9XO77e1AEAgAQF0g+AMAAAAAAACAKAWCvqQk+zTQ+hMAgLpA8AcAAAAAAAAAUQoEfR6PFbINAEBdIPgDAAAAAAAAgCgFgr5AxR+tPgEAdYngDwAAAAAAAACiZJr2aWnwZ9TdYAAADR7BHwAAAAAAAABEKVDh53bbrT4DQSAAAHWB4A8AAAAAAAAAouT3GzIMyeOxt2n1CQCoSwR/AAAAAAAAABAl05ScTsmx+5NWgj8AQF0i+AMAAAAAAACAKPl8dujnctnbfn/djgcA0LAR/AEAAAAAAABAlPx+yeWy5HQGto26HVA9d+edHn38sbOuhwEACYvgDwAAAAAAAACi5PfbrT5dLiu4jcr98INTS5fysTQA1BR+wwIAAAAAAABAlALBH2v8RcbnIxwFgJpE8AcAAAAAAAAAUfL7jd0Vf/a2adbteOo7r5dwFABqEsEfAAAAAAAAAESptNWnvU2oFZ7PZ8jnYx1EAKgpBH8AAAAAAAAAECU7+LPkdNrbBH+Vsyz7+HCMAKDmEPwBAAAAAAAAQJRKK/6s3dtUs1UmEPgR/AFAzSH4AwAAAAAAAIAoBYK/QMWf31+346nPvF77lOAPAGoOwR8AAAAAAAAARMnnM+RyiVafEaDiDwBqHsEfAAAAAAAAAETJNCWHg4q/SHi9dhtUn492qABQUwj+AAAAAAAAACBKpWv8lW6jYoFKP44RANQcgj8AAAAAAAAAiJId/FllWn1SzVaZwBp/gVMAQOwR/AEAAAAAAABAlAIVf4Zht/ykmq1yVPwBQM0j+AMAAAAAAACAKAWCP8k+JdSqHGv8AUDNI/gDAAAAAAAAgCj5fEZwfT+XyyL4CyPQ4jNQ+QcAiD2CPwAAAAAAAACI0p4Vf4RalaPVJwDUPII/AAAAAAAAAIiSadpr+0m0+qxKIPgjHAWAmkPwBwAAAAAAAABRsiv+LEmSy8X6deGUrvFXxwMBgAQWV8Hf7NmzNWzYMPXp00d9+vTRGWecoY8++ih4eXFxsW699VYdcsgh6t27t6688kpt2bIl5DbWrVunUaNG6YADDlD//v111113yccrDQAAAAAAAIAo+HyhrT6p+Ktc6Rp/hKMAUFPiKvhr3ry5rr/+ev3rX//Sa6+9pn79+umf//ynli5dKkmaMmWKPvjgA82YMUMvvPCCNm3apNGjRwev7/f7demll8rr9WrOnDmaNm2aXn/9dT344IN19ZAAAAAAAAAAxDHTLBv8WQR/YZQGf3U7DgBIZK66HsDeGDx4cMj2tddeq5dfflmLFy9W8+bN9dprr2n69Onq37+/JDsIPP7447V48WL16tVLn376qZYtW6ZnnnlGOTk52nfffXX11Vdr+vTpGj16tDweT8RjcTgMORx8M2VvOJ2OkFOgPmO+Il4wVxFPmK+IJ8xXxBPmK+IJ8xXxJNL56vcb8ngkl8shl8uQZRlyuZjjFXPIMOxjxjGKLX6/Ip4wX2tWXAV/Zfn9fi1cuFC7du1S79699fPPP8vr9WrAgAHBfTp27KiWLVsGg7/FixerS5cuysnJCe4zaNAgTZ48WcuWLdN+++0X8f03aZImwyD4i0ZmZkpdDwGIGPMV8YK5injCfEU8Yb4injBfEU+Yr4gnVc1Xl0tKT5eysjxKTZU8HpeyspJqaXTxJSnJro40DCkrK62uh5OQ+P2KeMJ8rRlxF/z9/vvvOvPMM1VcXKzU1FQ98sgj6tSpk3799Ve53W5lZmaG7J+dna3NmzdLkrZs2RIS+kkKbgf2idTWrTup+NtLTqdDmZkpys8vlN9v1vVwgLCYr4gXzFXEE+Yr4gnzFfGE+Yp4wnxFPIl0vhYWJqmkxNS2bV75/UkqKLB/Rnnbtjnl97tVWCht21ZU18NJKPx+RTxhvkYn0i9MxF3w16FDB/373/9WQUGB/vOf/2js2LF68cUXa30cpmnJNK1av99E4Peb8vl4MiM+MF8RL5iriCfMV8QT5iviCfMV8YT5inhS1Xz1+SxJ9j4OhyWv12J+V6KoyCHLstf44xjVDH6/Ip4wX2tG3AV/Ho9H7dq1kyR1795dP/30k55//nkNHTpUXq9X+fn5IVV/eXl5ys3NlWRX9/34448ht7dlyxZJCu4DAAAAAAAAAJHy++32lZLd9tPnq9vx1GeBY+PzSZZlt/wEAMRW3K+caJqmSkpK1L17d7ndbn3xxRfBy1asWKF169apV69ekqRevXrpjz/+UF5eXnCfzz//XOnp6erUqVNtDx0AAAAAAABAnPP57MBPklwuS35/3Y6nPvP5SpM+kyIfAKgRcVXxd++99+qwww5TixYttHPnTr311lv6+uuvNWvWLGVkZOjUU0/VtGnT1KhRI6Wnp+uOO+5Q7969g8HfoEGD1KlTJ91444264YYbtHnzZs2YMUPnnHOOPB5P3T44AAAAAAAAAHHH7zeCFX8Ohwj+wvB6Q38OHDcAQOzEVfCXl5ensWPHatOmTcrIyFDXrl01a9YsDRw4UJI0YcIEORwOXXXVVSopKdGgQYM0adKk4PWdTqdmzpypyZMn64wzzlBKSopOOeUUXXXVVXX1kAAAAAAAAADEsfKtPulfWZmybVBpiQoANSOugr8pU6aEvTwpKUmTJk0KCfv21KpVKz355JOxHhoAAAAAAACABqhs8Od0EmiFU7bij8pIAKgZcb/GHwAAAAAAAADUFTv4syTZwR9r11XO6zUq/BkAEDsEfwAAAAAAAAAQJdO01/aTJJfLouIvjLLHhoo/AKgZBH8AAAAAAAAAECWfz17bT7Ir/gi0Kle21ScBKQDUDII/AAAAAAAAAIiSz2cQ/EXI55Pc7tKfAQCxR/AHAAAAAAAAAFEq2+rT6bSDQFTM5zOUnGzt/rmOBwMACYrgDwAAAAAAAACiYFl2hZ/TaW+7XFT8heP1Sikp9s8EpABQMwj+AAAAAAAAACAKll28JqfT2n1K8BeOHfxR8QcANYngDwAAAAAAAACiEAivSiv+LIK/MHw+KSnJ/pnjBAA1g+APAAAAAAAAAKKwZ/Bnr/FXd+Op71jjDwBqHsEfAAAAAAAAAETBNO3TssGf38/adZXxeqXUVPtngj8AqBkEfwAAAAAAAAAQhUC7SpfLPqXiLzyvV8GKPwJSAKgZBH8AAAAAAAAAEIVA8OfY/Smry8XadeHYwV/pzwCA2CP4AwAAAAAAAIAoBKrWnE67is3lsgj+wvD7WeMPAGoawR8AAAAAAAAARCEQ8gXW+HM4qPgLx+uVUlLsnzlOAFAzCP4AAAAAAAAAIAp7rvHnclHJFk7ZNf58Ptb4A4CaQPAHAAAAAAAAAFEIhHyBNf6cztL2nyjP65Xcbvt4EZACQM0g+AMAAAAAAACAKOzZ6tMO/upuPPWdz2fI7aYyEgBqEsEfAAAAAAAAAETBNO3T0lafliyr9HyUsiw77HO57ONE8AcANYPgDwAAAAAAAACiEGjr6XTa69YFAkBCrfJM0w7/3G6Lij8AqEEEfwAAAAAAAAAQhT3X+AucEmqV5/Xap2633RLV52MtRACoCQR/AAAAAAAAABCF8q0+Q89HqUDw53LZ4R/hKADUDII/AAAAAAAAAIhCILxyOkNPCbXKCxwTu+LPkt9ft+MBgERF8AcAAAAAAAAAUQiEV4EWn4HgL7D2H0p5vfYxcbnsNf4CFYAAgNgi+AMAAAAAAACAKAQCvtJWn5YkKv4qUrbiz271STgKADWB4A8AAAAAAAAAohBYy8/ptHafhp6PUmXX+HM6RatPAKghBH8AAAAAAAAAEIU91/gLVP5R8Vde2Yo/l4tjBAA1heAPAAAAAAAAAKIQqFoLBH+Btf6oZisvdI0/i+APAGoIwR8AAAAAAAAARKG01ad9Gqj4I/grL9DqM1DxxzECgJpB8AcAAAAAAAAAUSjf6tPafb5RRyOqv8q3+uQYAUBNIPgDAAAAAAAAgCj4/XZ4FQj+Aqe0sSwvUPHnctnHiWMEADWD4A8AAAAAAAAAouD32+v6GbuL1wLBH20sywuEpPYafwR/AFBTCP4AAAAAAAAAIAp+f2nYJ7HGXzglJfap3erTIvgDgBpC8AcAAAAAAAAAUbCDPyu47dj9aSuhVnll1/hzOglHAaCmEPwBAAAAAAAAQBQqr/gz6mZA9VhgjT+74k/yejlGAFATCP4AAAAAAAAAIAp7Bn+B6j+q2crz+Qw5HHZVpNtNVSQA1BSCPwAAAAAAAACIgt9vBNt7SqzxF47PVxqSOp0WxwgAagjBHwAAAAAAAABEwe8vDfuk0mCLarbySkokt9uuiHS5OEYAUFMI/gAAAAAAAAAgCj5fxcGfadbNeOozn89u8SkR/AFATSL4AwAAAAAAAIAomKbkcFjB7UAISKhVns9n7BH8GXU7IABIUAR/AAAAAAAAABAFv7+0yk+SHA7JMAi1KuL1lgajVPwBQM0h+AMAAAAAAACAKOwZ/En2tt9fN+Opz+y2qIE1/iyCPwCoIQR/AAAAAAAAABAFn8+oIPgj1KpISUlpq0+nk4o/AKgpBH8AAAAAAAAAEAXTLF/x53JR8VcRv7+01afbTTtUAKgpBH8AAAAAAAAAEAW7fWXoebT6rJjXq5CKP44RANQMgj8AAAAAAAAAiIK9xp8Vcp4dalHNtqfQNf7saknTrONBAUACIvgDAAAAAAAAgCiYpuTY4xNW1q+rWNmKP7fbDgA5TgAQewR/AAAAAAAAABAFu+Iv9DzW+KuY12uEtPqUCP4AoCYQ/AEAAAAAAABAFHw+o1zw53RaBH8VKLseYuCU4wQAsUfwBwAAAAAAAABRoOIvcnarz9I1/iQq/gCgJhD8AQAAAAAAAEAU/P7SECvA5bIrARGqbMWf0xlY44/jBACxRvAHAAAAAAAAAFGwK/6skPMcDir+KlJ2jT9afQJAzSH4AwAAAAAAAIAoVNbqkxaW5ZWtjgycer11Nx4ASFQEfwAAAAAAAAAQBdO0K/zKcjotgr8KlJRILhdr/AFATSP4AwAAAAAAAIAo+P1GuYo/p9MOBBHK55M8HvtnWn0CQM0h+AMAAAAAAACAKPh8pSFWgNNJJVtFvF6jTKtPu/LP5zPqcEQAkJgI/gAAAAAAAAAgCn5/+VafLpddCYhQPp/kdtuBX6BKkjX+ACD2CP4AAAAAAAAAIAp+f2n1WoDDQQvLivh8pYGf222fcpwAIPYI/gAAAAAAAAAgCn6/yq3xZ1f81c146rOSEiMY+AWOGS1RASD2CP4AAAAAAAAAIAoVB38WgVYF7Faf9s+Btf5Y4w8AYo/gDwAAAAAAAACiYJpGuTX+nE7JNOtmPPWVadr/Amv8BdqjEpACQOwR/AEAAAAAAABAFHy+0uq1AJeLSrY9BQK+wLEqrfirm/EAQCIj+AMAAAAAAACAKPh85Vt9Op0EWnvyeu3TPYM/1kIEgNhzVb1LxRYvXqyFCxdq/fr1Ki4uDrnMMAw99thj1R4cAAAAAAAAANRXpik5nVbIeU4ngdaeAsHfnmv8Bc4HAMROVMHfc889p6lTpyo7O1tt2rSRO/AbGwAAAAAAAAAaCL+/ooo/i+BvD16v3fo0sMafwyEZBi1RAaAmRBX8Pf300zr33HM1YcIEOfZcvRYAAAAAAAAAGoCKgj97jb+6GU99FQhCA5V+hkFlJADUlKhSu8LCQh111FGEfgAAAAAAAAAaLL/fqHCNPwKtUHu2+pQkl8siIAWAGhBVcjd06FB9/PHHsR4LAAAAAAAAAMSNilt92oEgSgWCP1eZ/nNURgJAzYiq1edNN92km266SWPGjFH//v2VmZlZbp9jjz222oMDAAAAAAAAgPrIsiTTrDj4I9AKtecaf5Id/FEZCQCxF1Xwt2LFCn333Xdau3at3n777XKXG4ahX3/9tdqDAwAAAAAAAID6KBBaOZ1WyPkul0WgtYdAEFq+4o/KSACItaiCvwkTJig1NVUzZ85U+/bt5S7bnLkGPf7443r33Xe1YsUKJScnq3fv3rr++uu1zz77BPcpLi7WtGnTtGDBApWUlGjQoEGaNGmScnJygvusW7dOkydP1ldffaXU1FSdfPLJGjNmjFyuqA4HAAAAAAAAgAYmEO7t+ZEia/yVFwj+Qtf4K20BCgCInaiSruXLl+uhhx7SYYcdFuvxhPX111/rnHPOUY8ePeT3+3Xffffp4osv1ttvv63U1FRJ0pQpU/TRRx9pxowZysjI0O23367Ro0drzpw5kiS/369LL71UOTk5mjNnjjZt2qSxY8fK7Xbruuuuq9XHAwAAAAAAACA+BcI9hyP0fFpYllfRGn9OJ5WRAFATogr+9t13X+Xl5cV6LFWaNWtWyPa0adPUv39/LVmyRAcddJAKCgr02muvafr06erfv78kOwg8/vjjtXjxYvXq1Uuffvqpli1bpmeeeUY5OTnad999dfXVV2v69OkaPXq0PB5PRGNxOAw5HJSi7w2n0xFyCtRnzFfEC+Yq4gnzFfGE+Yp4wnxFPGG+Ip5EMl8NQ/J4DLlcpft4PIb8/tDzGjrLcsgwpJQUQy5XYL0/Q6bJcYoVfr8injBfa1ZUwd+kSZM0btw45ebmql+/fnXWIrOgoECS1KhRI0nSzz//LK/XqwEDBgT36dixo1q2bBkM/hYvXqwuXbqEtP4cNGiQJk+erGXLlmm//faL6L6bNEmTYRD8RSMzM6WuhwBEjPmKeMFcRTxhviKeMF8RT5iviCfMV8STcPPV6ZSyslKUlVV63u6PKpWVlVbDI4sfycn2scrNTVNmpn1eaqrk8biUlZVUt4NLMPx+RTxhvtaMqBK7s88+Wz6fT5dccokcDoeSkkJ/ORuGoW+//TYmA6yMaZqaMmWK+vTpoy5dukiStmzZIrfbrczAq8du2dnZ2rx5c3CfsqGfpOB2YJ9IbN26k4q/veR0OpSZmaL8/EL5/WZdDwcIi/mKeMFcRTxhviKeMF8RT5iviCfMV8STqubrli2S35+snTtLtG1b6eVFRU55vW5t3Vok6gZsW7c65fe7VVBQFGzvaZoe5edb2raNhf5igd+viCfM1+hE+oWSqIK/iy66qM6r3W699VYtXbpUs2fPrpP7N01LpmnVyX3HO7/flM/HkxnxgfmKeMFcRTxhviKeMF8RT5iviCfMV8STyuZrcbEhy5KkPS+3zy8uNlVHjdLqncCxcjhM+Xz2eU6npZISi98FMcbvV8QT5mvNiOql58orr4z1OPbKbbfdpg8//FAvvviimjdvHjw/JydHXq9X+fn5IVV/eXl5ys3NDe7z448/htzeli1bJCm4DwAAAAAAAACEY+7+rHrPcC+w7fOVv6yh8nrtIhKns/Q8p1PB6j8AQOzE1cqJlmXptttu03vvvafnnntObdq0Cbm8e/fucrvd+uKLL4LnrVixQuvWrVOvXr0kSb169dIff/yhvLy84D6ff/650tPT1alTp1p5HAAAAAAAAADiWyC0KhtmSZLDEXo5SkPQsk3kXC4Fq/8AALET1XdOzj///Cr3ef7556O56bBuvfVWvfXWW3r00UeVlpYWXJMvIyNDycnJysjI0Kmnnqpp06apUaNGSk9P1x133KHevXsHg79BgwapU6dOuvHGG3XDDTdo8+bNmjFjhs455xx5PJ6YjxkAAAAAAABA4gmEVo49SisCVX4Ef6V8PsntDl02yeUqrQQEAMROVMFfenp6uTX+8vPztWTJEmVmZqp79+4xGdyeXn75ZUnSeeedF3L+1KlTNXz4cEnShAkT5HA4dNVVV6mkpESDBg3SpEmTgvs6nU7NnDlTkydP1hlnnKGUlBSdcsopuuqqq2pkzAAAAAAAAAAST2WtPgMVgFSzlfJ6K26JyjECgNiLKvh79NFHKzx/69atuuKKK3T88cdXa1CV+f3336vcJykpSZMmTQoJ+/bUqlUrPfnkk7EcGgAAAAAAAIAGxO8PrFsXWskW2LYvt/a8WoPk9Rpyu0PPc7ksFRVR8QcAsRbTNf6aNGmikSNH6oEHHojlzQIAAAAAAABAvUKrz8h5vaog+KPiDwBqQkyDP0ny+/3BtfcAAAAAAAAAIBEFgr1Aa8+AQPBHqFXK77cr/Mqygz8q/gAg1qJq9blkyZJy53m9Xi1fvlyPPPKIevbsWe2BAQAAAAAAAEB9xRp/kWONPwCoPVEFf6eeeqoMI/TbGJZlf2PjgAMO0O233179kQEAAAAAAABAPRUIrfas+AtsB4JB2Gv8VRSQ0g4VAGIvquDv+eefL3deUlKSmjdvrmbNmlV7UAAAAAAAAABQn1Xe6tMukLDbWIa2t2yovF7J4wk9z+WyqPgDgBoQVfB38MEHx3ocAAAAAAAAABA3/H67I5rTGRruORyBy2t7RPWXzye53aHHye2m1ScA1ISIg7+///5bmZmZcjgc+vvvv6vcv3HjxtUYFgAAAAAAAADUX5VX/NmnhFqlfL6KW6IGwlMAQOxEHPz1799fc+fOVc+ePdWvX79ya/zt6ddff6324AAAAAAAAACgPqos+GONv/K8XkNud+h5LpfdAhQAEFsRB39TpkxRmzZtJElTp06tsQEBAAAAAAAAQH1HxV/kvF5VEPyxxh8A1ISIg79TTjlFkuTz+dSlSxe1aNFCTZo0qbGBAQAAAAAAAEB9VVnwF1jjz+ejjWWAzyelpYWu8We3+qyjAQFAAnPs9RUcDp1xxhn67bffamI8AAAAAAAAAFDvBUIr1x6lFS6XHXDR6rNURWv8uVxURQJATYgq+GvdurW2b99eE+MBAAAAAAAAgHrP77cr+ow9Cvto9VleZWv8URUJALG318GfJF122WV69NFHtXHjxliPBwAAAAAAAADqPb/frmLbM/gLVLYR/JWqeI0/+xhZVsXXAQBEJ+I1/spauHChtm3bpqOPPlpdu3ZVTk5OyOWGYeixxx6LyQABAAAAAAAAoL7x+0vX8ysrUPHH+nWlfL7SFqgBZVui7tkGFAAQvaiCv507d6pDhw4h2wAAAAAAAADQUPj95cMsqTTEIvgrVVnFn1Tx+n8AgOhFFfy98MILsR4HAAAAAAAAAMQNu4qt/PmBKkDWryvl8xnljlUg7PN6paSk2h8TACSqqNb4AwAAAAAAAICGzDQrbvVpGHaoZZq1P6b6qqKKv8A2lZEAEFtRVfxJ0tKlSzVz5kz9+OOP2rx5s3Jzc3XAAQdo1KhR6tKlSyzHCAAAAAAAAAD1it9vVNqi0um0KwJhq2iNv8Cxsysjy7dMBQBEJ6rg78MPP9To0aPVvHlzHX300crOzlZeXp7++9//avjw4Xr44Yd1xBFHxHioAAAAAAAAAFA/+P2Vr03ndFpUspXh81W0xp8VvAwAEDtRBX933323Dj30UD3yyCNylKlnv/HGG3XFFVfo7rvvJvgDAAAAAAAAkLB8vsqDP5eLQKssr7f8Gn+BbY4TAMRWVGv8rVmzRmeddVZI6CdJDodDZ599ttasWROTwQEAAAAAAABAfWSadmVfRVjjr5RlVVbxZ58S/AFAbEUV/HXt2rXScG/NmjXq3LlztQYFAAAAAAAAAPVZ1RV/Ru0OqJ4KBHtud2hIGgj+aIkKALEVVavPiRMn6rrrrlNKSoqOPvpoZWRkqKCgQO+9956eeeYZ3XvvvbEeJwAAAAAAAADUG36/yrWvDHA6qWQL8Hrt0/KtPq3dlxuSKq6cBADsvYiDv969e8swSr+l4vV6NWHCBE2YMEEul0u+3a9kLpdLF154ob777rvYjxYAAAAAAAAA6gHTNOSopJ+a02lRybZb4Diwxh8A1I6Ig7+LLrooJPgDAAAAAAAAgIbK76+q1Wftjqe+KimxP1OubI0/AlIAiK2Ig78rr7yyJscBAAAAAAAAAHEjXPDndBJoBVS1xh8BKQDEViXF6AAAAAAAAACAyvh8pevU7ckO/uieJpWu8bdnxV8gNCX4A4DYirji77LLLtO4cePUvn17XXbZZWH3NQxDjz32WLUHBwAAAAAAAAD1kd+vMGv8UfEXEAj29qyODISmBKQAEFsRB387d+6Uf/er1c6dO2tsQAAAAAAAAABQ3/n9pe0q9+RyWVSy7Vba6jP0fFp9AkDNiDj4e+GFFyr8GQAAAAAAAAAaGr/fCLvGn2nW7njqq5ISu6Jvz7aogWMXaAUKAIgN1vgDAAAAAAAAgL1kmuFbfVLJZgscB48n9PxABSAtUQEgtiKu+HvmmWcivlHDMHThhRdGMx4AAAAAAAAAqPf8fikpqeLLXC7WrgsIBH97tkUtbfXJcQKAWIo4+LvrrrsivlGCPwAAAAAAAACJzOeT0tKsCi+j4q+U1xto9Rl6vmHYFZMcJwCIrYiDv99++60mxwEAAAAAAAAAccPvV9g1/kpKanc89VUg2HO7y4ekBKQAEHus8QcAAAAAAAAAe8nvr3yNP5fLItDaLRCA7lnxJ9lhIMcJAGIr4oq/JUuWqGPHjkpOTtaSJUuq3H///fev1sAAAAAAAAAAoL7y+w25XJW3+vT7a3lA9VTgOLjd5S+z10Ks3fEAQKKLOPg79dRTNW/ePPXs2VOnnnqqDKPiRVcty5JhGPr1119jNkgAAAAAAAAAqE+qavVJoGWrbI0/KdDqs+LPmQEA0Yk4+Hv++efVsWPH4M8AAAAAAAAA0FCZZrhWnwRaAT6fHfBVdKxcLsnrrf0xAUAiizj4O/jggyv8GQAAAAAAAAAaGp9PtPqMgNdb+XFyuSyOEwDEWCXfSQEAAAAAAAAAVCZQyVYRp5NAK8DrrXh9PylQGVm74wGARBdxxV9Z3bp1q3SNvwDW+AMAAAAAAACQqEyTNf4i4fMZFa7vJwVafdISFQBiKargb9y4ceWCv/z8fH322WfatGmTzj///JgMDgAAAAAAAADqI7/fqDT4o5KtVFUVfwSkABBbUQV/F154YYXnX3nllbrxxhu1ffv26owJAAAAAAAAAOo1vz98xZ9pUskmhV8LkYAUAGIv5mv8nXjiiZo7d26sbxYAAAAAAAAA6g07+CPQqkr4ij+L4wQAMRbz4O/PP/+UaZqxvlkAAAAAAAAAqDeqqvgj0LL5fEalwR9rIQJA7EXV6vOZZ54pd57X69Xy5cu1cOFC/eMf/6j2wAAAAAAAAACgvvL5wgV/FoHWbl5v5cfJ7baDQQBA7EQV/N11113lzvN4PGrevLnOP/98XXHFFdUeGAAAAAAAAADUV36/QcVfBLxeyeOpuCUqxwkAYi+q4O+3336L9TgAAAAAAAAAIG6YZuWVbC6XHQzCDvZclXwK7XJJRUW1Ox4ASHQxX+MPAAAAAAAAABJduDX+7OCvdsdTX4Vb48/lsqj4A4AYi6ri79///vde7X/yySdHczcAAAAAAAAAUO+YpmRZ9lp+FXE47ODPsiSjgRf+hV8LkYAUAGItquBv3LhxMna/YllW6YtbZecR/AEAAAAAAABIFIGwqvIWlvbno+HagTYUJSVSWlrFAanLZVcEAgBiJ6rg79VXX9XVV1+tk046Sccdd5xycnK0ZcsWLVy4UG+++aZmzJih9u3bx3ioAAAAAAAAAFD3AsGfo5KFlAJhX7h2oA2Fzyd5PBVf5nJJXm/tjgcAEl1Uwd+9996rM844Q6NGjQqel52dra5duyo5OVnTp0/Xc889F7NBAgAAAAAAAEB9EViXLlwLy8B+lYVeDYXPZwQrIPfkclm0+gSAGKvkOynhff/999p///0rvGz//ffXDz/8UK1BAQAAAAAAAEB9ZZr2aWXBX6AFKKGWXdFXeUvU0hAVABAbUQV/TZo00YIFCyq87O2331aTJk2qNSgAAAAAAAAAqK+qXuPPPiXUso9B5RV/HCMAiLWoWn1edtllmjhxolavXq2jjz5a2dnZysvL03//+1998803uu2222I9TgAAAAAAAACoF3w+Q5LkcFQcaAXW/vP7DUkV79NQlJRIbnfFlzmdpccSABAbUQV/I0aMUG5urmbOnKl77rlHPp9PLpdL++23nx599FENHjw41uMEAAAAAAAAgHoh0Oqz8oo/O+yj1acdflYW/LndVPwBQKxFFfxJ0pFHHqkjjzxSpmlq69atatKkiRyOqDqHAgAAAAAAAEDcCAR6la3xFzifUKuqNf4swlEAiLFqJ3WGYcjv98sMfM0FAAAAAAAAABJYINCrrA4iEPwRatnBn9tdcbtTp9O+HAAQO1EHf5988olGjBihHj166Mgjj9Tvv/8uSbrlllv05ptvxmyAAAAAAAAAAFCfVFXxF6hwo+LPPgaVV/yxxh8AxFpUwd9bb72lUaNGqXXr1po0aVJItV+bNm30r3/9K2YDBAAAAAAAAID6JPBxaFWtPmmSJnm9la/x53JRFQkAsRZV8Pfoo4/qggsu0H333afhw4eHXNa5c2ctXbo0JoMDAAAAAAAAgPomUKXmclXcwjJwfkOvZrOsqiv+TJOAFABiKarg76+//tLhhx9e4WUpKSkqKCio1qAAAAAAAAAAoL6qqtVnYO2/hl7NZpp2+FfZGn+lAWltjgoAEltUwV9ubq5WrFhR4WW///67WrZsWa1BAQAAAAAAAEB9Fekafw09+PN67dNwrT4lgj8AiKWogr9//OMfeuihh/TFF18EzzMMQ3/88YeeeuopnXjiiTEbIAAAAAAAAADUJ1Wt8UegZQs8/nCtPiUCUgCIpUp+5YY3evRoLV26VP/3f/+nxo0bS5IuueQSbd26VUcccYRGjRoVyzECAAAAAAAAQL0RCLQqC/4C5zf04I+KPwCofVEFfx6PR4899pi+/PJLff7559q2bZsaNWqkAQMGaMCAAbEeIwAAAAAAAADUG4EKNUcl/dScTnvtOtM0amlE9ZPXaz/+wFp+ewocJ5/PkFTxPgCAvRNV8BfQr18/9evXL1ZjAQAAAGIqL8+Q220pM7OuRwIAAIBE4veHD7SoZLMFHn9VFX+0+gSA2Ilqjb+yTNPU+eefr5UrV8ZgOAAAAEDs3HOPR08+6anrYQAAACDBBIKqytauC1QCNvRAK9Dqs6o1/hp6QAoAsVTt4M+yLH399dfauXNnLMZTpW+++UaXXXaZBg0apK5du+q///1vufE88MADGjRokHr27KkLL7ywXCj5999/a8yYMerTp48OPPBATZgwodbGDwAAgNqzZYuhgoKG3V4JAAAAsVdVq08q2WxVVfwF1kIMBIQAgOqrdvBX23bt2qWuXbtq0qRJFV7+5JNP6oUXXtDkyZM1b948paSk6OKLL1ZxcXFwn+uvv17Lli3TM888o5kzZ2rRokWaOHFibT0EAAAA1JL8fEMlJXU9CgAAACSaQKAXCK72FDi/oVey2Wv3Vd4SNRAINvSAFABiqVpr/NWFww8/XIcffniFl1mWpeeff16XX365jj76aEnS3XffrQEDBui///2vTjjhBC1fvlyffPKJXn31VfXo0UOSdPPNN2vUqFG68cYb1axZs4jG4XAYcjj49vjecDodIadAfcZ8RbxgriKe1PZ8tSypoMCQ12vI5eI5gr3D71fEE+Yr4gnzFfEk/Hx1yDCkpCRHhW0snU7JMOz9Kgu9GgLTtI9TcnLFxyEpyZBhSJbVsI9TLPD7FfGE+Vqzqh38OZ1OPf/882rfvn0MhlM9a9as0ebNmzVgwIDgeRkZGTrggAP0/fff64QTTtD333+vzMzMYOgnSQMGDJDD4dCPP/6oY445JqL7atIkTYZB8BeNzMyUuh4CEDHmK+IFcxXxpLbm665d9qlhOJWVVUlvIaAK/H5FPGG+Ip4wXxFPKpqvKSl2uJeTk1Zpu0+3W0pOdiorq4YHWI8FjlNubmqFxyE72748La3iy7H3+P2KeMJ8rRkxqfg7+OCDVVhYqFWrVqlt27Z1Foht3rxZkpSdnR1yfnZ2trZs2SJJ2rJli5o0aRJyucvlUqNGjYLXj8TWrTup+NtLTqdDmZkpys8vlN9v1vVwgLCYr4gXzFXEk9qerxs2GPL7k1RQYGnbtuKqrwCUwe9XxBPmK+IJ8xXxJNx8/ftvp0zTre3bi8LcQrK2b/dq27aG28cyL88hv9+jnTuLtG1b+ct37LDfs+fllWjbNn4nVAe/XxFPmK/RycpKi2i/qIK/WbNmqbCwUKNHj5YkLVq0SJdffrl27Nih1q1ba9asWWrbtm00Nx03TNOSaVJ+Hg2/35TPx5MZ8YH5injBXEU8qa35um2bQ5YlFRVZPD8QNX6/Ip4wXxFPmK+IJxXNV6/XIYdDYeex02mppKRhvxctKTFkWZJkVrjeoWHYlxcX8zshVvj9injCfK0ZUTVQfeWVV0LWwps6dao6deqkRx99VFlZWbrvvvtiNsC9kZubK0nKy8sLOT8vL085OTmSpJycHG3dujXkcp/Pp+3btwevDwAAgPiXn2+fer10aQAAAEBs+f12sBeO06kKw66GxOu1T92VdN4PrI/o8/GeHQBiJargb8OGDWrXrp0kaePGjVqyZInGjBmjI488UqNGjdKiRYtiOshItW7dWrm5ufriiy+C5+3YsUM//PCDevfuLUnq3bu38vPz9fPPPwf3+fLLL2Wapnr27FnrYwYAAEDNyM+3PzwopssnAAAAYswO/sLv43Ta+zVkgeDPVUnfOZfLDk8b+nECgFiKqtVnUlKSduzYIUn64osvlJqaGgzWMjIyVFBQELsR7mHnzp1avXp1cHvNmjX69ddf1ahRI7Vs2VLnn3++HnvsMbVr106tW7fWAw88oKZNm+roo4+WJHXs2FGHHnqobrnlFt16663yer26/fbbdcIJJ4RUMQIAACC+FRTYwV9JSR0PBAAAAAkn8uCvYVeyBYI/j6fiywPHMLAfAKD6ogr+evbsqSeeeEIOh0OzZs3SYYcdJufu39KrV6+u0QDt559/1vnnnx/cnjp1qiTplFNO0bRp03TJJZeosLBQEydOVH5+vvr27aunnnpKSUlJwetMnz5dt99+uy644AI5HA4de+yxuvnmm2tszAAAAKh9gYq/kpKG/WELAAAAYi+S4M/lotWnz2fI4ZAclfSdC7QApeIPAGInquBv7NixuvTSS3XZZZepZcuWuvbaa4OXvfPOO8Hqv5pwyCGH6Pfff6/0csMwdPXVV+vqq6+udJ/GjRvr3nvvrYnhAQAAoJ4IrPHn80mmWfmHDQAAAMDe8vmMCCr+LJlm7YynvvL5wgekpWv81c54AKAhiCr469Spk95//31t27ZNWVlZIZeNHTtWubm5MRkcAAAAEK1AxZ9kt/tMTq7DwQAAACCh+P2Vr1sX4HQSaHm9ktttVXp54Mt5Xi9dOgAgVqIK/gL2DP0kqWvXrtW5SQAAACAmCgoMGYZkWfYHDgR/AAAAiBW7o0TlgZZE8CfZ78PDBaSGYV9Oq08AiJ2Ig7877rhDF110kVq2bKk77rijyv1ZMw8AAAB1KT/fUFaWpa1bDRUVGcrICP/BDAAAABCpSNf48/sbdiWbz2fI4wm/j8tlNfiAFABiKeLg73//+59OO+00tWzZUv/73//C7msYBsEfAAAA6lR+vpSTYwd/Xm9djwYAAACJJJLgz+mkkq2qij/JvpzgDwBiZ6+Cv4p+BgAAAOqjggJDbduakqTi4joeDAAAABKKz2dEFGg19ODP57Mr+sIhIAWA2NrrNf7WrFmjV155RYsXL9aWLVtkGIZycnLUp08fnX766WrRokVNjBMAAACImGlKO3YYys21P2QoKTEk0eoTAAAAseH3Sw5H+H1oYWlX/Lnd4fdxu+0gFQAQG1W8PIWaP3++jj/+eD3++ONauXKlMjIylJaWpj///FOPPvqohgwZogULFtTUWAEAAICI7NghWZaUk2NX/JWU1PGAAAAAkFAiafXpcFDJFmllZEMPSAEgliKu+Fu+fLkmTJigvn376pZbblHHjh1DLl+6dKluv/12jRs3Tvvuu686dOgQ88ECAAAAkcjPt78xnJMTqPiry9EAAAAg0fj9VbewtAOthl3JFknFn9NJZSQAxFLEFX+zZ89WmzZt9MQTT5QL/SSpc+fOeuqpp9S6dWu99NJLMR0kAAAAsDfKB38N+wMXAAAAxJZpVt3qk7XrIlvjj4o/AIitiIO/r7/+WiNGjJDH46l0H4/HoxEjRujrr7+OyeAAAACAaASCv+xsKv4AAAAQe5G0+iT4i6zij8pIAIitiIO/9evXq2vXrlXu17VrV61du7ZagwIAAACqo6DAPqXVJwAAAGpCJGvXOZ0WwZ/XiKDVJwEpAMRSxMHfzp07lZaWVuV+qamp2rVrV7UGBQAAAFRHfr6h5GRLqamSYUjFxXyDGAAAALHj81Vd8UcLy8BaiOH3cbnsykAAQGxEHPxZVvhezAAAAEB9kZ9vKCPDDv3cbj5IAAAAQGxFssafw2Hv15CVlEhud1Vr/FEZCQCxVMX3LUJdcMEFMozw35YmIAQAAEBdKygwlJlpvy9NSrJUXFzHAwIAAEBC8ful5OSqAi3WrvP5Iqv4a+iVkQAQSxEHf6NHj67JcQAAAAAxk5+vYPDn8UglJQ37AxcAAADElt9Pq89I2Gv8EZACQG0i+AMAAEDCsVt9BoI/SyUldTwgAAAAJJRIWn06nbT6jGSNP6eTgBQAYiniNf4AAACAeJGfbygz0/7Zrvir2/EAAAAgsfh8RgQtLK0GH2h5vfZxCMft5jgBQCwR/AEAACDhFBSUrfij1ScAAABiy+erutUnlWx28OfxhN+HlqgAEFsEfwAAAEg4+flSo0alrT6Li+t4QAAAAEgokazx53RKfn/D/gKa11t1ZaQdkDbs4wQAsUTwBwAAgIRSUiIVFYVW/Hm9dTwoAAAAJBR7jb/wLSzt4K+WBlRP+Xx2K89w3G4q/gAglgj+AAAAkFAKCuxvCwfW+EtKkoqL+QYxAAAAYsfvVwRr/BFoRdoStaEHpAAQSwR/AAAASCj5+fZpoOLP7bZUUlKHAwIAAGggLEsNpsV6ZK0+rQYfaHm9dkVfOC6X1eADUgCIJYI/AAAAJJTSij9afQIAANSmjz926uyzUxpE2OX3G1SyRcDrNSII/qiMBIBYIvgDAABAQsnPDw3+aPUJAABQO1ascCg/39D69Yn/3iuyir+GHfyZpv2vqjX+XC47SAUAxAbBHwAAABJKfr4hw5AyMuxtWn0CAADUjo0b7fDmr78S/yPHSNausyvZGm6gFajiYy1EAKhdif8qDAAAgAYlP19KT7fk2P1ONylJBH8AAAC1YPNmO+RatSrxwy674i98JVtDr/gLtNuvOvhjjT8AiCWCPwAAACSUggJD6emlH8J4PFJJSeJ/+AQAAFDXNm2yP2psCBV/pqngF80q43JZsix734YoEOZVtcaf00nFHwDEUuK/CgMAAKBByc83lJlZuu3x0OoTAACgppmmtGWLIYdDWr068T9y9Psja2EpNdxQK/DlO1p9AkDtSvxXYQAAADQodvC3Z8VfHQ4IAACgAcjLM+TzSfvu69dffxmywnfBjHs+n1FloBWoCGyo7T4Dj9vtDj8ZGvpaiAAQawR/AAAASCgFBaog+Ev8D58AAADq0qZNdnBz4IGmdu40tG1bHQ+ohkXW6tM+bajBX2CNv0hbffJ+HQBig+APAAAACSU/31BGRumnBklJlkyz4X7gAgAAUBtKgz/7TVcit/u0LPu9pdMZfr/A5Q31fWgg+KuqMjJQEdhQ10IEgFhL3FdgAAAANEh7rvEX+IYx7T4BAABqzqZNhlJTLXXqZMrplP76K3E/dgwEVE5n+BK1QPDXUNtYBh53JK0+7f1rekQA0DAk7iswAAAAGhzLkgoKQtf4S0qyT4uL62hQAAAADcCmTQ41bWrJ5ZJatTK1alXihl2BCr6qK/6skP0bmkgr/koD0podDwA0FAR/AAAASBiFhfYHBmVbfXo89s8lJYn74RMAAEBd27TJULNm9vuuNm2shK74CwRUVQV/DX2Nv8BxqmqNPyr+ACC2EvcVGAAAAA1OQYEd7pWt+PN47NPAN44BAAAQe5s3G2raNBD8mQkd/AVafUZaydZQg79IK/5Kgz++qAcAsZC4r8AAAABocPLzA8Ff6XmB4I9WnwAAADVn0yZDTZvaiVi7dqY2bza0a1cdD6qGRN7q0z5tqJVska/xZ+3ev8aHBAANAsEfAAAAEkZ+vn0aWvFHq08AAICatGuX3XmhtOLPPl2zJjE/egwEf44qHl5Db/UZqPiLtNVnQz1OABBrifnqCwAAgAYpUPEXusaffVpSUhcjAgAASHybNtnvwcq2+pSk1asT84tXgUo2pzPSSrbEPA5ViXQtxMDltOYHgNgg+AMAAEDCKCgw5HRKqaml5yUl2ae0+gQAAKgZewZ/qalSTo6l1asT86PHwBp/tPoMLxDkBb6IV5lARSAVfwAQG4n56gsAAIAGKT/fUEaGJaPMl6oDrT693ob5TWsAAICatmmTQw6HlJ1dWgHXpo2pv/5KzI8eA0FeoEVlZQLBXyAoTFS//ebQjBmecl+0C7z/riogbeiVkQAQa1W8PAEAAADxIz8/dH0/qfQbxFT8AQAA1IyNGw3l5FghAU+bNpZ++CExg79AZVrVgZZ9msgVf3/84dC4cUnaudNQWpqlSy4p7dfp89nHwKgiz6PVJwDEVmK++gIAAKBBys83ygV/gVafrPEHAABQMzZvNtSsWWhZW9u2ptaudSRk+8ZIgz+HI3T/RLN8uaFx45LUtq2ls87y6tVX3fr119KPm30+ye0Ovw6iRKtPAIg1gj8AAAAkjIICQxkZoec5nfY/Wn0CAADUjE2bjOD6fgFt25ry+aT16xPvPVika/yVVvwl3jFYudLQ2LHJatbM0pQpRbrgAq86dTJ1772e4BfuvN6q26FKDaMyEgBqE8EfAAAAEkZFFX+Svc4frT4BAABqxqZNDuXmhr4Ha9PG3k7Edf4CQZ7TGb6aLXB5oq3xt2aNoRtvTFaTJpbuuqtI6el2CHr99cVau9ahF1+0S/i8XiNYzRdOIEAl+AOA2Ei8V14AAAA0WAUF5df4kySPh1afAAAANcHvt1t97lnxl51tKSXF0qpViVftFmhJ6ajik9VErGTbsMHQDTckKz3dDv0yM0sv69DB0rnnejV3rlt//OGQ16uIgj+Xy547fn/izRUAqAsEfwAAAEgYlVf8ScXFfJAAAAAQa3l5hkxT5db4MwypbVsrISv+AsFfVW0sE22Nv+Ji6YYbkuXxWLr77mJlZZXf54wzvOrQwdT06R4VFZWGeuEkYkAKAHUp8V55AQAA0CCZprRjR/k1/iS71afXW/tjAgAASHSbNtlfrtqz4k+S2rQxG3TwF7g8UYK/xYud2rDB0KRJxcrJqTjQc7mkG24o1urVDi1c6IpojT9afQJAbCXeKy8AAAAapB07JMuquNVnUhIVfwAAADUhEPztucafJLVrZ2r1akNW1UVfcaWhtvr88kunWrQw1aFD+P/Qjh0tnX22V4WFRkTBX6IdJwCoawR/AAAASAj5+faHThUFf243a/wBAADUhE2bDKWnW0pLK39ZmzaWdu40tG1b7Y+rJgXWogtUqlXG4bBbnvp88f8FNMuyg79+/fwyIng4Z53l1T77mEpL25tWn/F/nACgPojgOxcAAABA/RcI/jIyKqr4o9UnAABATdi0yaFmzSoOd9q0sdf9W73aoSZNzAr3iUeBij+ns+pQy+lMjFafK1YY2rLFUL9+kT0Yt1uaNq1IhYVVh3kOh/2Pij8AiA0q/gAAAJAQSiv+yl/m8dDqEwAAoCZs2mRU2OZTklq2tOR0KuHW+SsN/qre1+m0EiL4+/JLl1JSLPXoEXmAm5Vlz4FIJEpACgD1QWK96gIAAKDBKiiwT2n1CQAAUHs2bTLUtGnF4Y7LJbVsaWrVqsT6AlagMi2S4M/lSoxKti+/dOrAA/1yu2vm9l0uOnQAQKwQ/AEAACAh5OcbSkqy5PGUvywpySL4AwAAqAEbNxpq2rTyKrC2ba2Eq/gzdz/cyCr+SvePV9u2Sb//7oi4zWc03G4q/gAgVhLrVRcAAAANVn6+UWGbT8lu9VlSkljfNAcAAKhrO3ZIu3ZVXvEn2ev8JVrwFwioXK6q93U6JZ8vvt+Hfv21nXAedFDNJXOJcJwAoL5IrFddAAAANFgFBUaFbT6lwBp/tTwgAACABLdpkx3UhAv+2rUztXmzoV27amtUNc/vtx+3I4JPVhNh7bovv3SpWzdTWVk1dx+J0hIVAOoDgj8AAAAkhIICKSOjsuCPNUMAAABibdMm+6PF8BV/9mVr1iTOx5B+vx36GREUqMV7oFVSIn37rUP9+tXsg3C5rLg+TgBQnyTOKy4AAAAatO3bw1f80eoTAAAgtjZtMuR0StnZlQd/rVvbC9ytXp0478X8/sjW95Mkp9Oq1TX+TFOaNcutX3+Nzce+P/3kUGGhUaPr+0nxH5ACQH1C8AcAAICEUNUaf7T6BAAAiK1Nmwzl5lphW16mpUk5OZZWr06cjyF9PjvQi0RtB1pvveXSnDlujRuXpN9/r/4x//JLp3JzLXXoENnjjRbBHwDETuK84gIAAKBBKygwaPUJAABQizZtMtS0adXlbG3amFqyxCGrZrOjWrN3FX+Sz1c71Y5bt9rVfkcd5VP79pbGj0/S8uXR37dl2ev79evnj6itaXXU5nECgERH8AcAAICEUFCgSlt9JiVJxcV8kAAAABBLgYq/qgwb5tOPPzr1zDPuWhhVzTPNvQv+/DXbJTPo8cc9crmkf/6zRHfeWaQWLSzdeGOyVq6M7n3wqlWGNmwwanx9P0lyu6n4A4BYIfgDAABA3PN6pcLC8Gv8eb1KmG+ZAwAA1AcbNzrUtGnVb7AOPdSvSy4p0csvuzV/vqsWRlaz/H6j3gV/333n0P/+59KoUSXKyJDS06Vp04qUk2PphhuStWbN3od/X33lVFKSpV69an6RQpfLIvgDgBgh+AMAAEDcy8+3P8iofI0/+wMp2n0CAADEhs8nbd1qqFmzyL5ZdfrpPp18slcPP+zR559HmJrVU3vT6nNvAq38fGnGDI8++8wpcy+ytpIS6cEHPerZ069jjy1NGTMypLvuKlJmph3+rV+/d+HfV1851bu3KY9nr64WldqsjASAREfwBwAAgLiXn2+fVr7Gn31aXFxLAwIAAEhweXmGTFMRrfEnSYYhXX65VwMG+HXnnUn65Zf4/VjS55NcERYuRhpoWZY0fXqSFi50afLkJF14YbJef92lXbuqvu68eW5t2ODQlVeWlFuLr3Fj6e67i+XxWLr22mQ9+KBHCxa49McfDpWUVH6b+fnSkiVO9etXO2mcy8UafwAQK/FfWw8AAIAGr6AgUPEXPvgrKTEk0e8TAACgujZtst9/RdLqM8DhkMaPL9bYsUm65ZYkPfBAkVq3jr/3Zn6/5HBENu5Ig7+333bpiy+cmjy5WNnZll57zaWZMz167jm3hg716aSTfGrevPx9rl1raPZst047zav27SseU3a2pXvuKdbTT7v1ww8Ovf22K7hOYdu2pjp2NNWpk6nOnU3ts4+p9HTpm2/sqsNDDqnN4K9W7goAEh7BHwAAAOJeaavPyoI/Wn0CAADE0saNex/8SfYXsm67rVjXXJOs8eOT9eCDhcrKqokR1py9a/VZdSXb6tWGHnvMoxNO8GngQDtou+mmEl1yiVdvvOHSggUuvfqqW126mBo40KcBA/xq184+7g8/7FGTJpbOOSf8G92mTS2NG2eX+BUVSStWOLR8uf1v6VKHPvrIFXyv3Ly5JdOUOnc2lZNTO8Gsy9Wwu3N8951DaWl2EJuSUv5yr1f67TeHFi92avFih7KzLV16qVfZ2fEXnAOoeQR/AAAAiHuB4C8jo+LLAxV/RUW1NCAAAIAEt2mTocxMq8KQoioZGdKUKcW67LJkvf66WxddFF/fztqb4M/hUNj1+kpKpClTktS0qalLLw3tvdm0qaVLLvHqnHO8+vJLpz77zKk5c9x65hmPWrY01aWLqUWLnLrttuK9+n9ITpb228/UfvuVDszvl/76y9CyZaWB4JAhtVeC53JZ2rmzYbb6/OsvQ2PHJkuyW+I2a2apfXtT7dubSk219NNPTv30k0NFRYbS0y11727q+++duuQSp664okRHHeUv1+IVQMNG8AcAAIC4t3GjoYwMS45KlopJSrJPvd7KW33u2GGvj3LKKd64+9Y5AABAbdu0yaHc3OirjZo1s9S3r18//OCUFG/Bn7FXFX/hvnz27LNurVrl0IMPFlUa3qWmSoMH+zV4sF8lJdL33zv1+ef2v8MP96l//+q343Q6pfbtLbVv79fRR9dOe88977+htvpcudL+I2bq1CLl5RlatcqhlSsdev99l/Lzpe7dTZ17rle9etntWB0Oew3GRx7x6K67kvTRR35dc02JmjWr4wcCoN4g+AMAAEBc27VLeustlw47rPIPKNxu+0OpcO2DfvjBqZdfduu991yaNKlY3bqF+Wo2AABl7NhhfwmlQ4fKv4QCJJpNm4y9bvO5p169TD30kEu7dtnhVrwIrI8XCZfL0q5djgqrBL/7zqFXXnFr5MgSde4c2XtPj8ded++QQ/y69tq9HHg9FklL1ES1erVDGRmW+vY1d1fuVR28ZmZK48eX6LDD/Joxw6ORI5N11VU+nX56jQ8XQBxo0MHfSy+9pFmzZmnz5s3q1q2bbrnlFvXs2bOuhwUAAIC98O9/u7Rrl6Gzz678m+LJducclZRUuot27LBPs7MtXXttsq6+ulhDhtT+t50BAPVbcbG0bJlDv//u0B9/OPTbbw6tXWunfbm5loYO9WnIEF+1KqGAeLBpk6Fevar3XqlXL79MU/r5Z4cOPjh+vnTl89lBVSRycy19+KFDp52WogMPtAO7gw6yj9tddyWpd2+/Tj+9gZa6lWEHf3U9irqxapWhtm3NqNp1DhzoV48ehXr0UY+mTnXr2Wel/fd3q0cPvw44wK8WLSzagAINUIMN/hYsWKCpU6fq1ltv1QEHHKDnnntOF198sRYuXKjs7Owqr+9ctrTKffydOpdueL1yrloZdn/L5ZLZvkPpGYWFcq5dE/46KSkyW7UObhsF+XJs3Bj+OhkZMps1L73Otq1y5OWFvY6Z1URWmeNibNokR/728NfJzZXVqHFwe/nH66Udfnm9RXI6TXk8ljwe+4Xd67X/FTRqrWJXmoqL7W/5JK1fJau4WJZpf5vKsiS3W0pNtZSaKqWkWPJ0aaukzCQVFUkFBYZ8vy7Xrh2Wdu2SSkqM4P14PJaSkuxvRhW27qRir0OFhVLxLlOe1ctVXGzI7bb3SUqylJwsJSfb15XDoZJ2nUoff0mxHKtXaedOQ7t2Gdq1S8GfHQ57fEmZHql9O6WnW0pNteTYtUOO9evl89mP1ecz5PdLXp/k99nbRa40/Z3WSg6HlJFhqbH+VlbJRqWlWUpLs++7pMT+Q9PrNVRSIu30NJajedPgPhlFm5VWvE0Oh/2GadcuqbBQKiy0xylJrhY5cjfLUmqqPda0/A1y7iyoeL5Y9rEvzm4ub3KG/H57273+LzmKi+RwKPgGwu22/z8D2/5WrVW2T4Vj5Z8yqngX52/fQZbTJcuSLNOSsXSZJPtbcZV9c7baz7Vdu+RctzZkH4fTkBqlyrF9l5x+KzbPta15cmzdGvY6UT3XmjaVldmodOzr1soI/GdXwt+ipYKTSpJj9SoZ4T4Nl+Rv2650kSxJzhXLJDP8hxn+fTqW/sf5/XL+uSLs/pbDIXOfjqVnFBXJueav8NfxeGS2bVd6xo4dcm5YH/46aWkyW7QMbht/b5Njy5aw1zEbNZaVm1t6nS1b5Ph7W/jrZGfLymoS3HZsWC8jkCxUwOuVNrlaaOOuTBUX2/M+dctfcvsK5XCUPg+cTiu47XY7tGvfblq31VB+vkM7dxoyVqxQ0Q6/fD77vyw52f6dFvg96HJJhS33Kf1L1bKU8tdSORyWnE77dl2u0vszTclvGipq21l+v732g1lUIvealTJNI/h7wbKktDRLOTl2yBLJc21P5Z5r+dvl2LQp/HVi8VzbuFGOgvzw14nFc23VShne8G2MonqudexU+svX55Nz5Z9h94/quZaUJLNN2+C2saNAjg0bwl+ngueaNq0J/m6tSLnn2ubNcmz/u9L72LVLWji7tY4/vlHwG+cVPdfS/pbaFSXLvaJEzkxTZvPmstJLFwR0/LVaruU+dfK79eA/i/TSS269eqdTW7/w68wzvXK7JX/rNqUJoiTHnytk+MN/2OVv3yHkueZcvizs/jIkf8cyr2slJXKuXhX2KuWeazt3yrl+XfjrRPFcMzMyZZXpH2Tk5cmxrRaea2vXyCgsDHudmDzXli8N6QK753sBqR4/19LTZTZvUXqdSN7f7+VzTdr71zVJFT7XjHClt6rgubZiuYxwiyOplp5rbrfMdu1Lz6hHzzUjN1vKKn0O1NpzLZL391U81yq8zt4+15xOmR32KT2jBp5rf/8tffNbI/3vtzb67junvF4p29iqni026tj2lvY50q/GjS19/bVLXz7n0CdPGerZ068BJ2So17HZwbfEET3XcnJkNS7tOe1Yv07Gzp3hr1Nfn2sOQ/59Sv+WVkmJHH+uLvf7tayonmupqTJbtgpu19jrWpMmspqUvq45Nm6QUVDx39LB60TzXGvZKqT8LZLn2oaU9tqw1f5spKjIkGvFUhUX2X9j5ORYatfOVE6OQgKA6jzXLEv6e0Oxumq5nMsqfz9kJSfLbN0muL3nc62tJfVKSdLq9/zq38R+jFG9rjXOkpWTU3qdGD3X9nw/4G/eQkpPl8+3+++yCP6WHnluGx12WKq++sqpL790avl/Vmqe4VdGhqXmPumm04rl3uNPZX+HfUrLA01TzhXLw95HRc+1Kl/X9vxbuqaea5mNZDVtWnqdSp5rTbe59fc2Q85lJdE915o1k5WRWXqdGnqu+du1tz8A2y2iz4ireK75lnjUt4Ml5zL7/evefkacJWnCuckaNqyDfvghRV98YeiLd4uVXbxOTZpY6trVVLt2ptq0MdW2raX0dPt6UX1GHM1zbY/PiCN5XQs814LXieRzqzZtS9d4UIR/S1f3uVZcLOdfq8NeJarn2p5/S2//W47Nm8NeJ9LnWsh19nx/X1PPtQo+I3ZY/rDvB6J6rtVGHrPn61pN5TF7PtcCnxHn9gl7veD+lmU1yK+gnX766erRo4cmTpwoSTJNU4cffrjOO+88jRo1qsrrFx83NPwOhqH8F+aWbm7Zooxrrgh7FTMnVztmPBLcdv7+m9Junxj2Ov6u+2rnLbcGt92ffaKUxx4Kex3vgENVeMWVwW3Pm68red7LYa9TfOIpKh5xVnA7+ekn5fnfe2GvU3jRJfIOPia4/dbB09Vx23cKN+VmNpuoX1P7BrfHr7lSzb3hf3lObfWQNnhK/2C7e+WZSrLC/7K5od1clTjsP3CS/Tt11+qzw+6/y5Gu8e1eCm63LFmpsWuvDtnHYUhOlyRL8vmlNe4OurvVjODl++/6RqM23hH2fn5JO0jPtrlJpmnI65UOzX9bp+U9EfY6n2Qcr1dzLg1un7j1OR21/V+qfAUj6Y2sC/W/xqcEty/YNF19d34SutPuGwjcxrO51+v79EODF1+zbqw6FP9W7rYN7Q4LnNJz+0/Vlpxusiw7rLzq+4uVXrQ1GCYqMEar9OeJbZ7WdtfuN3eWpQdWnhy8bYdRetuBgMJwOvTE8a8pOdleULyJb6NOeevyYDDicErO3aeBY1KU2VTfXPqo/H47HE1f+Yv6vDLRDht3/5MMuVwOmZYpQ5b+br2/fjr7Vrlc9nuIFr99qI5vPGzfh2P3fZX5ZxiSd9Bh2jFqtPLzpb//NpT85r+U884c+f0qDXEC43NYMhzS5iOGa+3gs1VcLBUXG2r9xuNqtvg9GbsPbvBvtMDPhrTyhEu1pe8xMgz7W1xdZt+pzGWLg5fvPpQy/ZLftEObL4bcrDW5fRT4vPqY169WxvbwL2zvnTxDf2e0kc9nH7fT550jp7coeMzMMsfPsuxj8MzQl2WkJMnjkdLMAp355gXB4xN4zA6H/X9rOCQzNV2Lb3xWHo8lt1vK2PKnOj14Q+lxLbOvw7Afn79de+288+7gOJ2LvlHyvfeUBlR+Q77gz/bp2tYHadGQccGAv/3P76jzB7PkMBQM5H0+yec15PPZ5/3c4QR9dcDFwWDskCXPav+lb8qQ/XjK/jN3H+8v97tA37Q+WUVF9nPgH0umq+uWz+zHsPufZUnFJVJJsSGvT3om9wYtTh8UfDzXrrtB7Yv/CPt/82Cbe7XC3UmBX6+3r/4/NTK32o+nks9ubmnzjPJd9ps7h+XX/SuHh70PU05d2+Ffwe1s7wZNXHNppfu7XdKuRs01f9gjysmxZFlSk7VLdNT7E+25UuYLHWVP/8zooRe63R58jvTY/IGGLXvAnvO7572x+/8+8POf+xypxUeMVkaGlJlpab+fXlHHL+fI47bk9thjKX3y2IpPPlXFp50R3E5+aqY8H/4v7DEovPhSeY88KridOu0OuX7+Mex1do69Wf4epd0E0m+4Vo714cPPHffMCHmDn3nReVJJ+A/u8p9+UctWJ+nFFz1a++sO3brsPKWmBb4oYykl2X7eBFjpGSqYOSu47fhzhdJvGRf2Pvwd9tHO26cFt12LvlbqjOlhr+M78GDtuub64HbKfxcqffbzKvH6K30/UHLc8So678LgdvLsF+RZML/S+1jzl0OPlVyskW8dq+xs+zZTHrxP7q+/DB2LT1q0yKkunU01yba068rr5DukX/DytIkTtP7jFdq40VDfvvYvx40bDa1c6VB6mqXOXUx5p00J+SMv45+jZFTxR27BI0+U/pHr8ynzwvDvOeR0Kf+52cFNx8YNSh9zVdirmM2aa8e9D5bexJKflTb1trDX8e3fXbvGl77PdH/8oVKeeDTsdbyHHaHCUaXvZ5Nef1VJr80Le53iU05T8akjgtspTz4m90cfhL1O4cjL5D1icHA7ddrtcv38U9jrlHuuXX+NHBvC/zG9Y/oDIR8qZv7fuZK39MMEwzDkcTvt+Wpa8vulvx54SUV+j4qKJO+WfHW5faRM0/6db5r28yzwOuF0WlKjRtp071PB10bXn8vU/O7xoe9/rND3Q4WtO2nF6Gn27ZpSxk9fqt3se0vfc5R5bxN4LfQedIgKrx4THLvnnbeV/NJzYR9/yZATVHjOBTJN+zU25aXn5Fn4dtjrFJ59gf4+/ARt3WooL89Qs6enK+Pnr+TzGjIMu5WZ0yW5ynyBZOVZY7S1W7/gF9+6PTFWqeuW7/6S156vA4YsS3p3yF3a1KiTvLtfh89860Ill+SXvgao/GvB/DOflj+tkRwOya0S/eOZM0Neo2Uo+PorQ7JcHn09dnbwPUby1vU64NErg/uVO94OyWzRUlunzAj+f7qX/Kis++4IvkepiK97D+Vff4u2bzf0999S6mcfqN0bj9rHp8wX5sryHn6kCi+5PLjtmjdP7tde3f3exv7Cjcq895IlrTn8TBWedL5crl1q1MhUq9ceUfKnH4b//xx1hbyHHRHcTp16m1xLfg57nZ3jJ8q/f/fgdvqYq+TYGD6Y3n73g8rztNCOHfZ7qs43niX5/MG573TY7Zhd7tLvi+U/OzsYLhnb/1bGP8P/jW41aqyCR0r/bnKuWKa0iRPCXse/Tyf9dc0U/fCDUz/84FTyt1/o5N/vkdtlf8bkdltyuez3cNu2GSrYYeiHtAFadPT16t/frwMOMNXttzeVNvf58rftk7bkGdq00dB81yl6p8X/KSnJ/pvhxI1PaWDeWzIMS54kKSNdSk+3lJ5uv2+RpKLz/k/5hw/VH3849OuvDrV9cbparPxSKalSepqltHT7y1ZlWwZuvex6/dmsn9asMbR2rUNHL7hBrXYtV2qqVen83HH7tJDANOOyi2XsCP9hX8FjT5V+2FdSosyLzg27vzxJyn/6heCmY/06Zdx4benv1wreD5gtWmnHPfcHt50//ai0u8L/Le3r3lO7xt0c3HZ/8L5SZj0e9jolRwxW0cjLgttJr85V0r9fC3ud4tPOUPHJpwa3Ux5/RO5PPgp7ncJL/ynvoYcHt1On3CbXL1U81yZMkn+//YPbFT7XLGnnLmnbVoe2bZPGNnlCee7SDxXv/3O4nIY/5G8Cp1NKC3yROtXSj//P3n1HR1H9bQB/Zmt6DwRSKAmEToDQIsWXIl06Il1AQAUrKlgoShMpUhTpINJFmlLVn4JUqSK9hISElt6TbfP+MdlJNj0hEJI8n3NyNjt7Z+bO7J2Zu/Ode+/0rXCrKMDFRYSTKRqO70j7QxSlh451aUL6bxXp/JNs5Yyfe66CwSA9iHx9z20ss5so18FyYvStgaTpM+X3qpMnYLN0oUWaW7ekB7Pr15cyqm/WEilvZ/Rhqfl1L6w2b0BedF17IHXQUPm91Q9roTm0P895Uoe9Bt1LGff3bBbMhercGYs0FvUBUUTyex/C0KQpZs3SIDpawDLtO/neWE6c8ZXFjWXNa6MQH56IuDgBFdxFODpl338J36/OCOanpsJh9LA81wGtFeJXZ5yPFOFhsPv4/TxnMVX2ROLcjO9C9e8F2Mydlec8hgYBSP4o4/yq/uM3WK/J+76V7v86IHVUxnlcu20ztHt2ZksXcleB2FigYYAJaf0HIq1nxm9U62VLoT52JM/1pIwbD32rNvJ72xnToLx2Jc95kj6dBmPtOvJ7u/fGQxGRdyAzYeG3Fg9POQwbmHGTKxfxG7bKF30hOgr2b2dc5yECp08r4e1jQqVKUlkQnV2QsOR7OYny5g3YTv8MeTHW8EfalzPh7GyLmJgkpBz6G4r5ixAfLyAhHkhOFuQYmEYj/Va879cKhxu+j8REAYmJAurf3IkXg3+Q6mbpectcVxUUwNEKvfGH93BotdKDxd3urUDTiH3StVOV6ZouZNxbOdnwdZz16Iq4OAEaDdD3ykxUj/wHao2UF036sAzSvQKpPnjz1UmI8WsiNzLw/3YirB/ezajbARa/8wUAjz+fB6WvD7Ra6VpuP/Y1iwCj+d6YKdP9iFsz1sGgtZXqWEmpqDttKATzfT4ho84titK51KC2xo0vf0BqqnQe1Dy8h1pL37e4h5p1vyW5eePMiIVyvdfp9nk03Dkz198EIoDH3o1xpf+nsLWV6ghe/x2Gzy/LoUyvd5r3gyLT/kh5sSPiBr8u37ez/XkLHA/+LO8gISN78m+YBx0HITyoD1JTpXvRvrsWwe3yUXkbTGKm9aTXie/2mYDEwDZQqaTvr9ryz2ETfFWubxgNgN4gyPkwGoDjPWfAULM2HBxEODiIqL/oDdgmRcLWJvf6QMI331kEvhyGvgLkch/BLP7HjN+nQlQU7N95I4/UgOjiioTFy+T3yhvXYfvF53nOY6zhj6SpX8rv1SeOwfrbRXnOo2/ZCilvZfyu1+zdBautm/KYA0jr3hNpAwfL763WroLm90PQHsz72mZWLlv86XQ6XL58GWPHZtywVCgUCAoKwvnz5wu0DOmGeh7tpAUpaCC/VQkQ8mlXrcgyj0JZgHkUlvMoizKPIv95lEpFodejVCggZppnQH8j1BeBNJ1JDkCYjOkBgvQTx5RxehgapkGrlX5kuU8zQHXfJP8AB9JbnqQHbAxG4MPX9Yiy1cPGRnpipcFMEzRGE1SZWqqY/4zpr0tnpsHKSYBWK8LalIqK75ggKCyDI+YAgdEEGK1N+ObzjBtBVg/1qLFEWodSJV2AsrZGM3gZ0HxyKhITBSQlAXZX9fBZZ5KDHlkDGIIANGtiwMAPpZu7aWmAaa8ethtMMKRvr4D0G0qZAkz+7fTo0SsNSUlSq0PXvQZU+FuEySTddFEq01vwpN98EQB4dtWjVwsdkpOllhJVtxvhfi3zFSqDOa/Dehrwcn2dvK211phge8+U6QIlXZjlYIsJCAgQEW4vfZdqtYjKD0XYpooWQRuYX9IvQG+N0cPgKD3hpBBE+M0TISAjkGJetvzdmKSKeFycgEePgPuxKrSOEmBKvymS04M90SolZs3KeALIN0UNlwcK+cKZ+aJpNAkQTQJuPlRgyf2MeQITNBgSkfvgHQKA89fVWLcz48mxjjEadIvJe8CPwyEa/Lo346nbAREqBCXkPc/WKDVO7MrI29gHKtROyTtvB/arEeqmkh/WrR0mwD0172P62DEVYuxUcmuwzokCtCZY3EjLXBkQRallalKqAno9oEhSIi5OkI7H9MqcXNlKX0eyQokpUzK2xTNNiw/Dcx84QSEADy+p8d1NGyiVIlJSBPhGWmHUw9znEQTgRpwS2xPSb9zqgdZxKvSNynTOhrSNKrV0E1OllCot8fEK+fwTGalAUqJgcdPNXCkyH6MxMQL0FQXY2opwdgbsQgBVTEZw1GiStsHOFtA4S5Xmt4YZoG2XBisrESaTALc5RmiCTRZBVXNl0CQCEAVMfR9I8dHDxsYEW1sRlSYZoYzP+OFhcV5Lr9wunJIGo2N6MMloRI0PTRABixuxmYO4UAqY/6VOvqGtjUlDjbkmixuqAqT9mZYmIDUNiFSJiItT4M4d6YawX4oCLVMybqiaz2dqtTkYDFSqJKJZM1N6JVyAzy0Rtg+yVIKz7IOEBAHnz0uDnickCGgXoUbXGMvvU62WKqQKpRQgP6tX4+wlK6hUUpC5800V6kQopNaR1hYPlcmUSsvrmqIA10+VSgFBJZWb0FABDvcVEEMV0OkBrQbQWgFWWnNrc3PQQAFF5jpE5jvdOUhMBL74wgp/n7ZC5coi/q+VEcIdICpSwH2dNJ9CyNQVkQAkq5SYM8gaajXwySc61LdRFLqeolQWYJ4sdQ5F+sVcyPxkQgHmyW09BgPw4KGA5l2MqFgx48KS0zyq9NOCKErlUakUgCzrMRnNLdeleT08ADtbE65fV+D8OSV+mmYF1xZa1KljQt26JjgIOeTNfNykL1qlylxu8t9nUMCyDlmQ/SxYzqNUFf67KUodMqf9LJosAyCKLHXIghw32Y61TPtZFAGDPqO3CHNg6MRhNcIvaNIftBDQ5aICdvEKix/2xvTrjgDpfLPmcy2SnazkltAjLyug0CukdJlaMhuMCvlezsQhNjAI0gnCzqjDjJC8r9GJSiU+ezXjyVafNCu8n8d1DQDu3VBi/vWMukDDJA1ee5TzegRINyOu3lJj13lr+YGWpvfVaHNDIQfSLIJr6e//vK7Bjh8y6il9YjT4vzilxY0E+XoA6f+dt7T4n0PGPCMfqdAoVQGNWlq+wRyUymTtYg0u2mZszwfhSninZf5+LevDCgVw4YISEU6q9Bs9IpKSBJj0AMSM7QEsX48eUSFRqYLRCAgGoPF9hcX1Wb52pDMICnz5ZUadw12vwaf38v4+I9QqzLycsf01k63wZnqdw/wQoCr9OikoRBgMAq5eVeObPzLmaZ6gxqsRGWVAqZRukpkfBhIBnL2rxo7frGEyST12tH+sReeYvMvN/ggVfvsTMBqtAIgYFKHBCylKqDVS3kyZru2m9P1yaJEWDw5bwd1dhJubiPZ3lHCLSa9Hmyzr3ub62h9bNXjsoZWX1+M/BezT66qZr9Pm41OnB6YNsUaEKuM4mB+shDKXmzYqJaDWAMs+soLGRqp32hu1GHZLIdcz5eC6SqpHKJUiDDoFjh5WIykJSEwUoA3VoN0dRfr53vJPEICERODqLRWmn5S+G29vER0cpe1MSpLybdALcr3O0UmEn5+IBh0MGDopozWx+k7O5zSVWrqGeHiIcGqih1dVPQzpN8BqHTXB/T/poaiUVCAiQkD4fWkZWq0U0Nv3vQbbFtrAZJIa5H2gB+wdpN9u92IU8rnMyhpQq0SkpgpY9rEVLqUfaw4OQMVrCkSnKqAQpGXa2kkNJwRkfKdH9qsR4aCB0Qg4OYnoFKGAjUGQbt5qpH1l0CN9f0jf6f5dGuisNFCrRWggon2EIv34FXP8rSsYBEREKGFtLQWbVApFRgAf0rnZ/BvSaJTKgMJormekHyeZr2uidB9Ar4P8QKVCAehSFEhMVECjkfZjQeopymzXwqLUbQqwHqWQpQ4Ji3nE9N+1oinjfBsZqUDKfallaWoqUDVSgCpakIP/KalAdLR001mlBJycRbz3nh5egWmwtpZ6+/AYZ4IgpgfSdJDuGSQLSE5C+u9nAVOnamESpPOLkykVs+4rIUAK+mU+SlXp57dErYCLFzPOz/XqmeAQjTz3QbY6Rw73x5wcpbqr0ShI9xyUT6eeklXWe105zWPxwAkEKJUKQKWAKApQqwWLekpuVCoFTJnWY20FWFcEKlY07+Xs85vXIy2gAHVIofB1SKEYjoECHWvZvs+c51EoABHS/iza92l5rAkFnEfIpd6ZG5Uqy3osIlG5zaPICPxl+T7T0qRrs411pmMp6/YX8BhQKhXp26WAvb0ArQvg4pJRYUpJBZKTBCQlA8lJQGSEAtHRCtjZSddCP1FExeT0sWrN93kA+fe+SQSa1TfBqrERaWlST2vOiSLwWLpG6XUC9PqMAKP53sotOyUilAo4OorQ6QQ8fqyA1SNFnl27rvhWgys2GXXIj8JUqKzLuz701dtWeKC1Sd8fwJxQFWxFZcZ5Nofqx6Tx1khVSvUUjQmYezfv+mCaQomPx2XUazx0WkwKy3ueh6FKzH2cUe+snayG/UOF5UP+mYqRAOBqnBLfPdTIeQ6KV2NAZN7bf+yqBtu3Z9Q7u0Vr0DE273l+Cdfgt10Z+3noYxWaJFreT8m62zas0uDs1ox53r6vQvXUnNdjLgMHDqjx376MHiCmhqrgYlCgUWNz5wM51KdyOtbyUdh4TNYYzvMcjylI3jIrly3+Hj16hDZt2mDLli1o1KiRPH3u3Ln4559/sH379nyXIV67lv+O9vfP+F+vB+7k3cUd1GqgesbTdkhJAUJD857Hxgbwzmhaivh44EHeXdzBwQGolPF0M6KjgXyaCsPVFcgUYcejR1JfJ3mpWBFwcsp4Hx6eMXhObry8LLqOwd270hUwL1WrWjTjxs2b+T5pgxo1MiJ1RiNwK7/uSRTSPGZpaVLe8qLVSnkzS0yU9kFe7OwAz4wuExAbK+3rvDg7A5macSMiQvpO8+LuDri4ZLx/8EAqO3mpXBmwz+g6BqGhUhnNi4+PRTNu3LkjHQt58fW16DoGN/Ju6QQgz2PNZJK+rtRUyANpK63VUPpVl368qABFajKE/LoCsraBsbI3dDppWbrIeBjuPYBOZw50IL3Sk/GXpHSA0qsSnJ2lQ8FFjIKTMRI21tLN6pQUyC3BUlLS81fBFepKbrCykoqQVdwjKOJj5W0xn7Ez37wxunvAZO8o39QTwsOkX3WZ0ikU0oXUxiY9yOJdhGOtWjWLbpqK81gzmaT9qDMqkerlJ+9TQ2IqTMEhMBgg7+usf6miFjGOVWE0SsXNQZEI19RwWFtD/pO6BkZ6d5ewONaMRiDtYQzS7j2GTiftFhub7MH8YjnW7t8H8ukyoUjHWpUqFt004fbt/AdHKOyxJghAzZoZ73U6IDg473myXteSk4F7eR9r2a5rcXFAPl3cZb6uiSKQGh6F+DuRiI2F/BcTI72mpkq7JkHjiniNGwyG9GMw+CFSHsbJx5iNjXTDrkIF6fLn7g44+nugQg1HqNXA48dA/JUwxIYnISpKKgrG9KCR+YlEtRqIs/fC9TBb3Lol7bLKacHwdNfB1RWIipKKkXmdgiCdKwze1eBUQQNXV+nyW0V3E3Y2JlhZZZRja2vptL1zJ3D+PCDWqInRrwvo1AlQigapDEC69ISESH/mS7AoAqJCiTh3P/z6K1CvHjBrSqqUKC9WVlJZM0tIkMp0XrJe12JipJ2Xl6zH2uPH0nw5+PFHYN8+4Ntt7nD2zftYE0WgXz/gjTeADh2Q/VgLCcF3C1IRGgrMmWMxK+LigFOngNOPquDcFSu5elbP+jYc7QzQpV9nUlMzxhBUq6VN0fv4wqWCSqpKuYqoqrsBJyfI1wZHx4yeZQDkeayJItK7Ms84J+p0gE5Uw+BTHRUqSGVGmZoEhOXdiju/Yy0xCXj4QKoiREVJp6FY0RERSg8kJUn5EKIioYiJQmqq9Hlycvp1SMg47xqdXGFyka5rqamAOuohFAlx8v4CpPOu1HpFehBCrOiBZLVj+kNNgPbxPRgTkpGcnHNVUq2WuouHrW164Avw0gfDRqWTg+rm7t41moxWDI9sqiHFqEnvQh3wTLohB+LN12Hz/+YbyWKNmrC2EaTjUG2A3aPbFuvQ6cxdrKd3t65TItbNT74ZrtSnwvpxiBzgMv8Bmf63soLRq4r8XpmcAOWj+/K1MSUlo95hrkckwB5R2sryd6FJjIajLkI+H0ldQ0Ou+6hUgMnRGSa3ClAq0+sgUY8hxMbID7gYjZaBLJUKMDi7Q1vJBW5u6edG/X1YGyyPNaMR6d3gp1++KleG0skeGk36QxgPQqA2psr5yvEnVdbr2q1byBZRzKoA1zXLBwIF6KvVlB9cE9N0EO4Gyw+YZd7H5vqfQaFBaqVqcp5VaUmwigyTv5fkFOkmmvk4tbcHbN1tYFXDG87OUpVAmxqHtJCHSEhAepBKejUYMnqEMNg6Is3ZQ2qZYws4GSLhaIhK76Yf8lPsCkXGA4gKd1ek2rkhKko6ZhNuPkTi/TjExmTUgdXqjO9SEIBwowfCEhzx6JF0PVI/vAcrk9SFtSBklH8rKymQJQCItfOCTm0rl9kKiXegEvUZD4Cll1tHx4zznLpmNbh4aODgIOXBKvQGlOm9dygU0r41X6/j4qTXO6qaSNOl97yQZoBT1G3oDVLwIvM5x1x9NQgqhGt9YWUlXXqcrVPhbQqRgmspGcMfmM/RHh5ArQAr1OxYBU2apP/UzXJdE0WpNZVGnakKbG8vXT/MCvJbOp/rmihK39mNG1L1OjgYsK5SATWaOaN+faloKx5k/JY2GqVT/K1b0uU+KUmqBrnUqwzPWvbw9paqRrqbIQi+mopbt6Tl3rxpWaXSaIAYhypQ2lpBEKRNqRB/C0rkfazFuvpCVKqkurhOhGdS3nVIExS4Z5XxW1oDHXwVwfLvtJzuSOkFDSLtq8HVVTpuXK2SoHwQJpeTnH6CpChs8ViT0a2ugxiHSsJD+dyvVmdcC8wPhJnsHZHq5CFfV9VxkdAmRklBLzF7vU6tBpKs3ZCgcZXPk7bxD6BNi7d4ANb8kKr5YZg4Kw+kWTnKx4hD3D2YEpPl34M5VdsfaryRpsi4eeuZJh1rgJQPFxcgMBBo2hSoXTv99Jf199qNG3m2jNDrgWi3moiMEhAZCUQ+NEB39TZMpoz6r7u79L/8s16lkgqlWWoB6pDW1tK9AbMc6pCPHgFvvgl8/DHQrBmKdqy5uEgZNsujDimrUEE6Rs0Kct/K0xOws8OHH0rlZtF7d/P/LV2U65qfn0X3g7iZTxd3We9bFeT3Wtb7VkkFqEPa2kr37swK8nvNyUm6R2gWGSmd+LLYvBn4809g+XJIBS/zUEwFuW9VqZJ0AjS7dw/IZ2gGeHtbdPVZoPtW1atbPil6/Xre6QGpfm+uQBgyfq8BwNmzwKxZwLJlmS4XRblHXIBjLZui3CPO51gTRcgPWdvZpddvc7lHrNNl/FYHLOuqCm9PCPZ28pBJYvBdmFLS5PNv5ofBzOtNdKuKFJNWPr+q796EPs0knfe1gFWmeru5XmSs5gelRindLxRMUAXfzPZ7S6+H3AOY1loBoWYN+TeC0pAGdfhd+RyfuT4k/2+thVCtqvxAkpCcJN27y4udHUyVPJGSkl5fDI9FWugj+f6h3Cgm/U8QANHRCSb3ivJ1S5sQCVVcxrGW+R6h/KCMhzs0Hi7y9qgjH0CZFC/X08yNaszfg14P6FwrIU3rIO8fMVT6vWY+dOzt0+vBdlJAW6EA4OMDk9Ya8fHSoZx8+Q4MyXrUqZPD/TezohxrzyIek/VYe1rxmKzHmjkek3kb88DAXxEDf1FRifJT61QwSqUCDg7WiI9PgTG3vueInhMsr1RasKwWn7Q04P59AffuCQgLUyA8XHoS+vFj6TWn339OTkCFCiJcXUWo1aLc+sj840AUAS8vETVqmFCjhojq1U0WsSaDAXj8WMCDB9JfZKQgd6EXEyM9yR0dLeQax61SRcSQIQb83/8Zc68s52H7diVWrlTjp59SLX4jPy3FWV5jYoBBg6zQp48Br7+eT6A7XadOVhg7Vo8+fXK+0TJtmhrJyQLmzs177IjYWODKFan7tZQUqd6v1UJ+wl6jker+Gd+l9BodLSAuzvIHqiBIvwHs7aUuTxwdpS5r7e2lFhxSGci/LJgpFNJTve7u0p+NTb4PIMv0eukYCA9XIC4uY7qtbcb4yjY20pjC5pYb5unmadbW0rGUnCzIgbvkZAFpaRkBBBsbMT2ALe2IhAQBiYnmV+l/lQoW67O1ldbj5CTCyUmEs7MIJyfpfeb7aMWJ51cqTYqjvOrSWwSZz2mFeKC4xJhMGQ8d2NpmeZAiB+agbuZ7vOVJSkrGzb5sDdZF6cai+XoTFSW1ks4450rXqMxxJSD7zcDMrbHNN05TUgR53HnpZqwCNjYaKBRSLxfmc72VlYjk5IzrXmyslJfERCmY7OIi5cXZWap7WVll9DZhfojD/L953WlpQvqr1DLF/FlamiDnVwoEinKQ0Lx/zDc0jUZpXnNdUAqgixY3Rc0PM2Qek1tuyStKXRmb95dSKcoPyJivp9bWonwT2nK87exp5V4cyphBg7Ro2dKICRMKVq97VnI7v376qXQwzJyZd72RCm79ehX27FFix458AqllzNatKqxfr8Ivv6QW6TddZqy/UmnC8lo0zpnG9c5LGa0u5M3Z2RlKpRJRWZ4uiYqKglvmVm15MJlEmPIZHJRyZjSaYDDwYKbSgeWVSguW1SenVEoPfGZuBGVmMknBnsePpa5r3d3Nwb7Crydr4KZCBemvYcOc05u7TDPfMJNaLUg3j2rXNll0a11YL75owvLlahw+rEDPns/uJktxlNeNG9UQBBF9++ryDYaZaTQiUlLEXNedkADY2eWfNzs7oFkzk/REeiEZDFI3wDExGTdW4+KA+HhBGn8jQUBoqPS/lZV0k9PHR0RAgFTmHB3NwcXMNyil8eciIxWIiBAQESEFkSMipKB1QSmVIjw8TGjSxAhPTxO8vERUrmyCnV3ht/NZKuj3X1Q8v1Jp8iTlVaHIaAidX0OU54k5+C+KBTsfaDRP/7zxvDLXW3L7fq2tpcZMmRvrZ5XTvlMoMlpQFIRKpYCzswYxMQaeX4ugrJbfhg2NOH9e8dyWiaznV71e6iXgec1vaaRUmmAwKMvdPg0OBry8TDCZTEX6TZcT1l+pNGF5fTrKZeBPo9Ggbt26OHHiBDp06AAAMJlMOHHiBIYMyWdgaiIiIip3pFZUgIvLs6+MCkLG0+eOjuaHjorn4SNnZ6BFCyP271c908Dfk4qMFLBnjxqvvKIvVEtFtVpqhZCbxEQh01grT4dKBbk1XnHz9S1Fd+qJiIiIMgkIMOLAARViYy17BHxeGQxSzwRUfJTKshvYzsu9ewr4+DDoQUTFq1wG/gDgtddew8cff4x69eqhQYMGWL9+PVJSUtCnT5+SzhoRERHRM9O5swGff67FrVsC/Pyezs2LtDTg338VOH9ehbAwIDlZA4NBhCgKFq0VpbGqRHmcK5UKcHMT4eNjgo+PCVWqSAGzzZvV0GpF9O2bz/gbWWi1eQ/BkpQkdSlJRERERM9Ww4ZShfDiRSXatn3+H2Yyj59KxUelAgyGUtDPdDESRSAkRECLFgz8EVHxKreBv65duyI6OhqLFy9GREQEateujVWrVhW4q08iIiKisqBpUyOcnUUcOKDC+PGFC6RlZTRKXZImJwuIixNw8aICZ84o8e+/SrmL1CZNADs7EYAoB/kUCulHr3mQcvP/er2AGzcU+P13FXTpw6dotdJYisOH6wrdBaVGI8rLyUlSkvDcd2tJREREVBa5uYnw8jLhwoWnF/hLSQHOnlXi/n0BPXoYYG1d9GWZTHji8djIkhT4K+lcPFvR0QKSkgT4+PDhQyIqXuU28AcAQ4YMYdeeREREVK4plUDHjgbs36/CmDF6aDQFn/fRIwHz52tw544CyckC9Fnihmo10KCBESNH6hAYaISvrwAXFxViYvSF6sPfZAIePxYQEqJAaKiA2FgBvXoV/q6AWg3odLk/RZyUJLDFHxEREVEJadTIhPPnizeaFhcHnDypxLFjKpw9q4ROJwXsjh1TYcaMVHls08IyGgUolaw3FieVSqr3i6I03EF5EBoqbSi7+iSi4lauA39EREREBHTqZMC2bWocP67Eiy8W7AnrU6eU+OorDWxsgD599LCxAaysRPnV1hbw8zNBq82YRyjiL3iFAvDwEOHhYUTz5kVaBACpq8/cWvzp9dIfA39EREREJaNhQyP27lUhIkJ44vGQHz4U8M03Gpw/r4QoAnXqGDF8uA5BQUYkJQn45BMt3nvPCrNnp+W6rvPnFVi2TIu+fYFu3Sw/MxqlQBUVH5VK+h4MBumBvfIgNFQBlQqoXJm/QYioePESRURERFTO+fiIqFPHhIMHVfkG/oxGYN06NbZsUaNFCyM++iityE9KP2t5dfWZlCS92to+u/wQERERUYaGDaV66MWLCnToUPTuPk+eVGLuXA1sbYEJE3QICjLAxSVzChELF6Zi8mQrvPuuFebMSYW3d0bgJSEBWL5cg4MHVbCyAnbvzjnwxzH+ipd5f+r1+Qf+jEapR5DISKk3kLg4AfHxQFyc1HVmp04G1K///LeiCwlRwNPTxLJERMWOgT8iIiIiQufOBixcqMHjxwIqVMj5idOoKAGzZmnw339KjB6tQ//+hlI1tolGA6Sl5dzqMDFRms4Wf0REREQlw8kJqFZNGucvp8Dfpk0q/PGHCt27G/DSSwbY2Fh+bjJJD6ht3pz/A2o+PiK++SYVkydr8e67Vpg1Kw01a5rw119KfPutBno98M47Ori4AF9+aY2wMAEeHhnzS4E/1huLkznYZ8zy1ScmAn/8oUJYmIDwcAXCwwU8eqSwGA9QoQDs7UU4OoowGIDffrPC+PE6dO/+9AcNFEUgNRVFGjMyNFRgN59E9FQw8EdEREREaNvWgG+/VePwYRUGD9Zn+/yffxSYO1cLpRKYNy+1VDxBm5VGI/0oz0lSEgN/RERERCUtIMCIEyey367culWFtWs1qF/fiGXLNFi/Xo2uXQ3o1csAd3cRMTHArFla/PuvEqNG6TBgQP4PqLm7Sy3/PvvMChMnalG7tgnnzyvRqpURb72lg5ubCL1eAY0GOHFCgd69MyJSBgNb/BU3c9epmQN6JhMwfboWly4pUamSCV5eIpo3N8LT0wBPTxPc3UU4OYmws4P8fRsMwLJlGixapMHduwLeeENf7N9VSgpw4YISp05Jf9HRArp0MWDYMF2W1qV5Cw1VoGvXpx+cJKLyh4E/IiIiIoKNDdC2rREHDyrx6qt6+YdzTIzU1dHvv6vQpIkRH3+cBmfnks1rUWm1IuLjc27xx64+iYiIiEpeQIAJO3cKePhQgIeH9EDWrl0qrFqlweDBeowYocejRwJ271bhl19U2LFDjdatDbh0SQmjEZg7NxUNGxb8ATV7e+Crr1Ixc6YWN28qMGVKGlq3zgjwWVsDzZoBx44p0bt3xsNx7Oqz+JlbUBoMAgDp/3Xr1Pj3X2WhvleVSuritWpVE779VoPQUAU+/zx768+HDwWcOqXE3bsKiCIs/qT8SEMFqNXSA4QajfTBpUtKXLighF4PVK5sQuvWBjg5ifjpJzV+/90aAwYY0K+fPt8WgAkJQEwMW/wR0dPBwB8RERERAZC6+zx0yAqXLinQoIEJhw4psXy5BoIAfPRRGjp0MELIOW5WKqjVuXf1aW7xZ2fHFn9EREREJaVBAyMUCuDCBQU6dzbi119V+PZbDfr102P4cCnwVrGiiDFj9BgyRI8DB1TYs0cFHx8TPv5YB1fXwtflrKyAL75Igygix1aCbdoAM2cqEB8PODhI00wmoVR1eV8amFv8mbv6PHFCic2b1Rg9WleoYK5Zjx4GeHub8MUXWkyYYIUpU9IQHy8F+06fViI0VAGlEqha1QSFAvLvHEGQ/oxGQKeT/vR6ATqdNK1mTRNGjdKheXMjvLxEi/Vt3qzGpk1q/PKLCsOH69G5c+4tT0NDpQ+qVGHgj4iKHwN/RERERAQAqFfPhMqVTdi6VY0NG4CLF5Vo396AceN0cHIq6dw9OY0G0GfvxRRARou/rGPFEBEREdGzY2cH+PpK4/ypVMCiRRq8/LIBY8bosz2AZmMD9OljQJ8+T95VojnYk5PWraUuJ0+fzhh70GjMCFRR8cjc1eeDBwK++kqDoCAjBgwo+vcbEGDC0qWpmDJFi7FjpSZ4zs4imjUzYsQIPRo3NhZbjx/29sCYMXq8/LIBa9aosXChBidOKPHll2k5pg8NVUAQYBE8JCIqLrxEEREREREA6WZH584GrFmjQaVKJsyZk4omTcrOE6harYi0nH93IylJgJWVyC6biIiIiEpYo0ZG7N2rwv/+p0KnTga89ZauRHudcHcHatUy4fjxjMCfwQCoVAzYFCdzPTwpScDChRo4Oor48MO0J/7uK1cWsWhRKo4eVaJ6dRF+fqan2lrTw0PEJ5/o0KiRCQsWaBAeLsDTM3tZCQ0V4OFhglb79PJCROUXG6UTERERkaxXLwMmTkzDihVlK+gHSC3+dLrcu/rk+H5EREREJS8gwIiUFAEvvmjAe+/pnosuNYOCTDhzRgmdTnpvMuXcLSgVnbnFn3lcvilT0mBnVzzLtrUFOnc2ombNpxv0y6xdOwNsbUUcPJhzu5uQEAV8fBg8JqKng5coIiIiIpJZWwOdOhlhZVXSOSl+Go0o36zJKikJsLXlD28iIiKikhYYaMJXX6Xio4+ej6AfAAQFScHIixelDBkMYE8RxUytluriV68q8O67afD1Ld11c60WePFFIw4fVsGUw/OU9+4pOL4fET01z8nlk4iIiIjo6ZJa/OX8GVv8ERERET0fBAFo3Nj0XAXWqlUT4eEh4sQJqfWW0cjAX3HTaKTXbt0MeOklY8lmpph06mRAZKSA8+ctb8GnpgKPHgnw9mbgj4ieDgb+iIiIiKhc0Grz7urTzq50P1VMRERERE+HIAAtWhhw4oQSoggYjQIDf8XM01PElClpePPNXJ7UK4Vq1TLBx8eUrbvPsDABogh29UlETw0Df0RERERULqjVIoxG6QntrNjVJxERERHlJSjIiMhIAbdvCzCZ2OKvuAkC0Lq1UW75VxYIAvDSSwb8/bcKiYkZ00NCpFvyPj5s8UdETwcDf0RERERULphvIqSlZf+MXX0SERERUV7q1zfB1lbEsWPSmG0qFR8ao/x16GCE0Qj8738Zrf5CQhRwdRVhZ1eCGSOiMo2BPyIiIiIqF7Ra6VWvz/4ZW/wRERERUV5UKqBZMyP+/ltq6scWf1QQrq4imjY14tChjMDfvXsKtvYjoqeKgT8iIiIiKhfUaimwl9M4f4mJAgN/RERERJSnli2NuHtXup3KwB8VVKdOBly7pkBIiPQ7JDRUgLc3f3sQ0dPDwB8RERERlQvmFn/s6pOIiIiIiqJpU6Mc8FPwrioVUIsWRjg4iDh0SAWDAQgPV6BqVbb4I6Knh5coIiIiIioXzGP86XSW03U6wGBgV59ERERElDc7O6BBAyMAtvijglOrgXbtDDh8WIXQUAFGI9jVJxE9VQz8EREREVG5oNFIgT293rKrz6Qk6ZUt/oiIiIgoP0FBUuBPpconIVEmnToZEBMj4Oef1QAY+COip4uBPyIiIiIqF3Lr6jMpSQoEssUfEREREeWnZUsj1GrA0ZF1Ryo4Pz8Rvr4mHD6sgr29CCenks4REZVlDPwRERERUbmglh6uzdbVJwN/RERERFRQFSuK2LYtGbVrs8UWFc5LLxlgMkmt/QQh//REREXFwB8RERERlQvmrj51Ostf2YmJ0iu7+iQiIiKigrCzAwM3VGjt2xugUgE+PnzgkIieLvZGTURERETlArv6JCIiIiKikuLoCHzwQRqqVWNrUSJ6uhj4IyIiIqJyQaORXvV6y+kZgb9nnCEiIiIiIipXOnQwlnQWiKgcYFefRERERFQuKJWAQgGkpVn2y5SUBFhbi1CwZkxEREREREREpRxvbxARERFRuSAI0jh/Op3l9KQkga39iIiIiIiIiKhMYOCPiIiIiMoNjSanrj45vh8RERERERERlQ0M/BERERFRuaHR5NTVJ1v8EREREREREVHZwMAfEREREZUbOXX1mZgosMUfEREREREREZUJDPwRERERUbmh0SCHMf7Y1ScRERERERERlQ0M/BERERFRuSEF/tjVJxERERERERGVTQz8EREREVG5odWKSEuznJaUBNjZscUfEREREREREZV+DPwRERERUbmhVufU1SfH+CMiIiIiIiKisoGBPyIiIiIqNzQaQK/P6OpTFIHkZHb1SURERERERERlAwN/RERERFRuZO3qMy0NMBjAFn9EREREREREVCYw8EdERERE5UbWrj6TkqTWf2zxR0RERERERERlAQN/RERERFRuaLWATpfR1WdSkvTKFn9EREREREREVBYw8EdERERE5YZGI+bS4o+BPyIiIiIiIiIq/Rj4IyIiIqJyQ2rxl/E+o8VfyeSHiIiIiIiIiKg4MfBHREREROWGNMZf5q4+2eKPiIiIiIiIiMoOBv6IiIiIqNzIqatPQQBsbEouT0RERERERERExYWBPyIiIiIqN7RaIC0to8VfYiJgbS1CwVoxEREREREREZUBvMVBREREROWGWg3o9YCY3rNnUpLA8f2IiIiIiIiIqMxg4I+IiIiIyg2tVoQoSsE/AEhK4vh+RERERERERFR2MPBHREREROWGRiO9msf5k1r8MfBHRERERERERGUDA39EREREVG6YA38ZLf4E2NmVXH6IiIiIiIiIiIoTA39EREREVG5oNFLrvrQ0AQC7+iQiIiIiIiKisoWBPyIiIiIqN3Lu6rPk8kNEREREREREVJwY+CMiIiKiciOnrj7Z4o+IiIiIiIiIygoG/oiIiIio3NBqpSBfaiq7+iQiIiIiIiKisoeBPyIiIiIqNzK3+BNFdvVJRERERERERGULA39EREREVG6o1dKrTgekpgImE1v8EREREREREVHZwcAfEREREZUbVlZSkC8tTUBSktTdJ1v8EREREREREVFZwcAfEREREZUb5hZ/er00vh/AFn9EREREREREVHYw8EdERERE5YZ5jL+0NAGJieYWfwz8EREREREREVHZwMAfEREREZUbCgWgUklj/GW0+CvZPBERERERERERFRcG/oiIiIioXNFoxPTAH1v8EREREREREVHZoirpDBARERERPUsaDaDTCUhKAgQBsLYu6RwRERERERERERUPtvgjIiIionJFqwXS0qSuPm1tRShYIyYiIiIiIiKiMoK3OYiIiIioXFGrRej1UlefHN+PiIiIiIiIiMoSdvVJREREROWK1OJPgE7H8f2IiIiIiIiIqGxh4I+IiIiIyhVpjD/AYGDgj4iIiIiIiIjKFgb+iIiIiKhcMXf1mZzMrj6JiIiIiIiIqGzhGH9EREREVK6Yu/pMTmaLPyIiIiIiIiIqWxj4IyIiIqJyxdzVZ1KSABubks4NEREREREREVHxYeCPiIiIiMoVjUZEWpoU+LOzY4s/IiIiIiIiIio7GPgjIiIionJFowH0egFJSezqk4iIiIiIiIjKFgb+iIiIiKhcydzVp61tSeeGiIiIiIiIiKj4MPBHREREROWKVisiLk6AycQWf0RERERERERUtpSqwN+yZcswcOBANGzYEIGBgTmmuX//PsaMGYOGDRuiZcuW+Oqrr2AwGCzSnDp1Cr1790a9evXQsWNH/Pzzz88i+0RERET0HFCrgZgYAQADf0RERERERERUtpSqwJ9er0fnzp3x6quv5vi50WjE2LFjodfrsWXLFsyZMwc7d+7E4sWL5TT37t3D2LFj0bx5c+zevRvDhw/HZ599hqNHjz6rzSAiIiKiEqTVAkaj9D+7+iQiIiIiIiKiskRV0hkojLfffhsAcm2h9/fff+PWrVtYu3Yt3NzcULt2bbzzzjuYN28exo8fD41Ggy1btsDLywuTJk0CAPj6+uLs2bNYt24dWrdu/cy2hYiIiIhKhkaT0cqPLf6IiIiIiIiIqCwpVYG//Fy4cAE1a9aEm5ubPK1Vq1aYNm0abt26hTp16uDChQto2bKlxXytWrXCrFmzCrUuhUKAQiEUS77LC6VSYfFK9DxjeaXSgmWVSpPnpbxaWQkQ0qtxjo4CVCrW6Si756W8EhUEyyuVJiyvVJqwvFJpwvJKpQnL69NVpgJ/kZGRFkE/APL7iIiIPNMkJiYiNTUVVlZWBVqXi4stBIE3iYrCwcG6pLNAVGAsr1RasKxSaVLS5dXVFVAqpf+9vGxhY1Oi2aHnXEmXV6LCYHml0oTllUoTllcqTVheqTRheX06SjzwN2/ePKxcuTLPNPv27YOvr+8zylHBREcnscVfISmVCjg4WCM+PgVGo6mks0OUJ5ZXKi1YVqk0eV7Kq06nhNGohkIBpKamIi2txLJCz7HnpbwSFQTLK5UmLK9UmrC8UmnC8kqlCctr0Tg72xYoXYkH/kaOHInevXvnmcbb27tAy3Jzc8O///5rMS0yMhIA4O7uLqcxT8ucxs7OrsCt/QDAZBJhMnFMmKIwGk0wGHgwU+nA8kqlBcsqlSYlXV6VSgGiCNjYiPyBQfkq6fJKVBgsr1SasLxSacLySqUJyyuVJiyvT0eJB/5cXFzg4uJSLMsKCAjA999/j6ioKLi6ugIAjh8/Djs7O/j5+clpjhw5YjHf8ePHERAQUCx5ICIiIqLnm0YjvdoW7EE5IiIiIiIiIqJSo1SNnHj//n1cvXoV9+/fh9FoxNWrV3H16lUkJSUBAFq1agU/Pz989NFHuHbtGo4ePYpvvvkGgwcPhib9Ds/AgQNx7949zJ07F7dv38bGjRuxf/9+jBgxogS3jIiIiIieFa1W6rXB1pa9NxARERERERFR2VLiLf4KY/Hixdi5c6f8vlevXgCAH374Ac2bN4dSqcT333+PadOm4ZVXXoG1tTV69+6Nt99+W57H29sby5cvx+zZs/HDDz/Aw8MDM2bMQOvWrZ/15hARERFRCVCrpVcG/oiIiIiIiIiorClVgb85c+Zgzpw5eabx9PTEypUr80zTvHlz7Nq1qxhzRkRERESlhZWVFPCzsSnhjBARERERERERFbNS1dUnEREREdGTYos/IiIiIiIiIiqrGPgjIiIionIlfehn2NqWbD6IiIiIiIiIiIobA39EREREVK5otVJLP7b4IyIiIiIiIqKyhoE/IiIiIipX2NUnEREREREREZVVDPwRERERUbmi1UqvdnYlmw8iIiIiIiIiouKmKukMEBERERE9S2o1MHlyGpo2NZZ0VoiIiIiIiIiIihUDf0RERERU7rRrx6AfEREREREREZU97OqTiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAwQRFEUSzoTRERERERERERERERERPRk2OKPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4I+IiIiIiIiIiIiIiIioDGDgj4iIiIiIiIiIiIiIiKgMYOCPiIiIiIiIiIiIiIiIqAxg4K8c27hxI9q1a4f69eujf//++Pfffy0+Hzp0KPz9/S3+pkyZkucyDx06hJEjR6J58+bw9/fH1atXs6Up6nL79OmDwMBABAQEoGfPnti1a5dFGlEUsWjRIrRq1QoNGjTAiBEjcPfu3QLtC3r+lVR5BYDz589j2LBhCAgIQOPGjTF48GCkpqbmuexTp06hd+/eqFevHjp27Iiff/650NtEpVdpKq9nzpzBwIED0bx5czRo0ACdO3fGunXrCr1NVDqVRFkNCwvLtkzz3/79+/Nc9v79+9G5c2fUr18fPXr0wF9//WXxOesCZVtpKq+su1JJ1QUiIiLw4Ycf4oUXXkBAQAB69+6NgwcP5ptf1l3Lt9JUXll3pZIqr6GhoXjrrbfQokULNG7cGO+88w4iIyPzzS/Pr+VbaSqvPL9ScZdXvV6Pr7/+Gj169EBAQABatWqFjz76CI8ePbJIFxsbiw8++ACNGzdGYGAgPvnkEyQlJT1xftPS0jB9+nQ0b94cjRo1woQJEwp03i4zRCqXfv31V7Fu3briTz/9JN68eVP87LPPxMDAQDEyMlJOM2TIEPGzzz4THz9+LP8lJCTkudydO3eKS5YsEbdt2ybWrFlTvHLlSrY0RVnuyZMnxUOHDom3bt0SQ0JCxHXr1om1a9cWjxw5IqdZvny52KRJE/Hw4cPi1atXxXHjxont2rUTU1NTC7l36HlTkuX13LlzYuPGjcXly5eLN27cEG/fvi3++uuvYlpaWq7LDQ0NFRs2bCjOnj1bvHXrlrhhw4Zs5bUg20SlU2krr5cvXxb37t0r3rhxQ7x37564a9cusWHDhuKWLVsKtU1U+pRUWTUYDBbLe/z4sbhkyRIxICBATExMzHW5Z8+eFWvXri2uXLlSvHXrlrhw4UKxbt264vXr1+U0rAuUXaWtvLLuWr6VZF3gtddeE/v27StevHhRDA0NFb/99luxVq1a4uXLl3NdLuuu5VtpK6+su5ZvJVVek5KSxPbt24tvvfWWeO3aNfHatWviG2+8Ifbt21c0Go25Lpfn1/KttJVXnl/Lt6dRXuPj48URI0aIv/76q3j79m3x/PnzYr9+/cTevXtbpBs1apT48ssvixcuXBD/+ecfsWPHjuL777//xPmdMmWK2LZtW/H48ePipUuXxAEDBoivvPJKEfdQ6cPAXznVr18/cfr06fJ7o9EotmrVSly+fLk8bciQIeKMGTOKtPx79+7lGfgr6nIz69Wrl7hw4UJRFEXRZDKJL7zwgrhq1Sr58/j4eLFevXriL7/88sTropJVkuW1f//+cjkrqLlz54rdunWzmPbuu++KI0eOlN8XZJuodCpt5TUnb731ljhx4kT5Pctr2VSSZTWrnj17ipMnT84zzTvvvCOOGTPGYlr//v3Fzz//XBRF1gXKutJWXnPCumv5UZLlNSAgQNy5c6fFtGbNmonbtm3LdXmsu5Zvpa285oR11/KjpMrr0aNHxVq1alnc4I6Pjxf9/f3FY8eO5bo8nl/Lt9JWXnPC82v58bTLq9nFixfFmjVriuHh4aIoiuKtW7fEmjVriv/++6+c5q+//hL9/f3Fhw8fFjm/8fHxYt26dcX9+/fLaczrOn/+/BNtQ2nBrj7LIZ1Oh8uXLyMoKEieplAoEBQUhPPnz1uk3bt3L5o3b47u3btj/vz5SElJKZY85Lfcdu3aYcmSJTnOK4oiTpw4geDgYDRt2hSA1A1TRESExTbZ29ujYcOG2baJSpeSLK9RUVG4ePEiXF1dMXDgQAQFBWHIkCE4c+aMRbqhQ4di0qRJ8vsLFy6gZcuWFmlatWqFCxcuFHqbqHQpjeU1qytXruD8+fNo1qxZobeJSo/noS5g9t9//+Hq1avo16+fxfSsdYH8zq2sC5RdpbG8Zsa6a/lS0uW1UaNG2L9/P2JjY2EymfDrr78iLS1Nvq4DrLtShtJYXrNi3bX8KMnyqtPpIAgCNBqNPE2r1UKhUODs2bPyNJ5fyaw0lteseH4tP55leU1MTIQgCHBwcAAgDVfj4OCA+vXry2mCgoKgUCgsuu709/eXu0ouSH7/++8/6PV6izS+vr6oXLmyfA4u61QlnQF69mJiYmA0GuHq6mox3dXVFXfu3JHfd+/eHZUrV0aFChVw/fp1zJs3D8HBwVi6dOkTrb8gy/X29oazs7PFfAkJCWjTpg10Oh0UCgWmTp2KF154AYA0NoB5G7JuU7nqu7cMKsnyeu/ePQDA0qVL8dFHH6F27drYtWsXRowYgV9++QVVq1YFAFSqVAnu7u7yfJGRkXBzc7NYlpubGxITE5Gamoq4uLgCbROVPqWxvJq1adMG0dHRMBqNGD9+PPr371+obaLSpaTrApn99NNP8PX1RePGjS2mZ60L5HRuzXydZ12g7CqN5RVg3bW8Kuny+s033+C9995D8+bNoVKpYGVlhaVLl6JKlSpyGtZdyaw0llcz1l3Ln5IsrwEBAbC2tsbXX3+N999/H6IoYv78+TAajfI1HeD5lTKUxvJqxvNr+fOsymtaWhrmzZuHbt26wc7ODoB0nnRxcbFIp1Kp4OjoaFFeq1WrBnt7+wLnNzIyEmq1Wg4wZk6TebllGQN/lKtXXnlF/t/f3x/u7u4YMWIEQkND4ePj81SXu379+mzz2draYteuXUhOTsaJEycwZ84ceHt7o3nz5kXOC5UdT6O8mkwmedl9+/YFANSpUwcnTpzAjh078MEHHwAA5s6d+4S5p/LmeSyvGzduRHJyMi5evIj58+ejSpUq6N69e5HyQmXH06oLmKWmpuKXX37Bm2++me2znOoCRHl53sor666Ul6dVXhctWoT4+HisW7cOzs7O+O233/Duu+9i48aN8Pf3B8C6KxXe81heWXel3DyN8uri4oJFixZh2rRp2LBhAxQKBbp164a6detCEAQ5Hc+vVFjPY3nl+ZVy8yTlVa/X45133oEoipg+fXqh133gwIFCz1PeMfBXDjk7O0OpVCIqKspielRUVLYnkTJr2LAhACAkJKRYbp4UdrkKhUJ+8q927dq4ffs2VqxYgebNm8tPqERFRaFChQryPFFRUahVq1ax5ZWevZIsr+Zy5evrazHd19cX9+/fz3U+Nze3bE/rR0ZGws7ODlZWVlAoFEXaJnr+lcbyaubt7Q1AqrxFRkZiyZIl6N69e5G3iZ5vz0td4MCBA0hNTUWvXr3yTZvTuTVzflkXKLtKY3kFWHctr0qyvIaGhuLHH3/EL7/8gho1agAAatWqhTNnzmDjxo344osvcpyPddfyqzSWVzPWXcufkq4PtGrVCr/99huio6OhUqng4OCAF154AV27ds11Hp5fy6/SWF7NeH4tf552edXr9Xj33Xdx//59rF+/Xm7tB0jnyejoaIv0BoMBcXFxObZILWh+3dzcoNfrER8fb9HqLyoqKtflljUc468c0mg0qFu3Lk6cOCFPM5lMOHHiBBo1apTrfFevXgWAYj84irpck8kEnU4HAPDy8oK7u7vFNiUmJuLixYt5bhM9/0qyvHp5eaFChQoIDg62mH737l14enrmOl9AQABOnjxpMe348eMICAgAUPRtoudfaSyvOTGZTNDr9QBYXsuq56UusGPHDrRr1y5b1x45ye/cyrpA2VUay2tOWHctH0qyvJrHWFEoLH/mK5VKiKKY63ysu5ZfpbG85oR11/LheakPuLi4wMHBASdOnEBUVBTatWuXa1qeX8uv0lhec8Lza/nwNMurOegXEhIit/DPrFGjRoiPj8d///0nTzt58iRMJhMaNGhQ5PzWq1cParXaIs2dO3dw//59+Rxc1rHFXzn12muv4eOPP0a9evXQoEEDrF+/HikpKejTpw8A6em7vXv3om3btnBycsL169cxe/ZsNG3aNM+nkGNjY/HgwQM8fvwYAOQb0G5ubnB3dy/wcocPH46OHTtiyJAhAIDly5ejXr168PHxgU6nw19//YU9e/Zg2rRpAABBEDBs2DAsW7YMVapUgZeXFxYtWoQKFSqgQ4cOT2MX0jNUUuVVEASMGjUKS5YsQa1atVC7dm3s3LkTd+7cweLFi+XlfPTRR6hYsaLcleLAgQOxceNGzJ07F3379sXJkyexf/9+LF++vMDbRKVXaSuvGzduRKVKlVC9enUAwD///IM1a9Zg6NChBd4mKp1KqqyahYSE4J9//sGKFStyXE7WusCwYcMwdOhQrFmzBm3btsW+ffvw33//yS0CWBco20pbeWXdtXwrqfJavXp1VKlSBVOmTMHHH38MJycn/Pbbbzh27JhFPZR1V8qstJVX1l3Lt5KsD+zYsQO+vr5wcXHB+fPnMWvWLIwYMUIuiwDPr2SptJVXnl/Lt6dRXvV6Pd5++21cuXIFy5cvtxhn0tHRERqNBr6+vmjdujU+//xzTJ8+HXq9Hl9++SW6deuGihUrysvq3LkzPvjgA3Ts2LFA+bW3t0ffvn0xZ84cODo6ws7ODjNmzECjRo0Y+KOyrWvXroiOjsbixYsRERGB2rVrY9WqVXJzWHNE/IcffkBycjIqVaqEl156KccxTTL7448/MHnyZPn9e++9BwAYP348JkyYUODl3rt3DzExMfL75ORkTJ8+HQ8fPoSVlRWqV6+Or7/+2qKJ+uuvv46UlBRMmTIF8fHxaNKkCVatWgWtVvvE+4tKVkmVVwAYMWIEdDodZs+ejbi4ONSqVQtr1qyxaML+4MEDiydVvb29sXz5csyePRs//PADPDw8MGPGDLRu3brA20SlV2krryaTCQsWLEBYWBiUSiV8fHwwceJEDBw4sMDbRKVTSZZVQPox6uHhgVatWuW4nKx1gcaNG2PevHn45ptvsGDBAlStWhXffvstatasKadhXaDsKm3llXXX8q0kf2utWLEC8+fPx7hx45CcnAwfHx/MmTMHbdu2ledj3ZUyK23llXXX8q0k6wPBwcFYsGAB4uLi4OnpiXHjxmHEiBEWy+H5lTIrbeWV59fy7WmU10ePHuGPP/4AAPTs2dPisx9++EEe+3zevHn48ssvMXz4cCgUCrz00kv47LPPLNIHBwcjISGhwPkFgE8++QQKhQJvv/02dDodWrVqhalTpz7ZjipFBLGwfSgQERERERERERERERER0XOHY/wRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAQz8EREREVG5s2TJEvj7+5d0Np46f39/LFmypNiW9/PPP8Pf3x9hYWHFtsxnobj3w6lTp+Dv749Tp04V2zLNylLZzLrfcyo/Q4cOxdChQ+X35n174MCBJ1p31uWWVoUpD+a00dHRTzlXxa8gZeV5Y87jpUuXSjorAJ5OfiZNmoR27drlmy4sLAz+/v74+eefi23dRERERFR0qpLOABERERGVHwW9gf3DDz+gefPmT7SulJQUrFq1Cs2aNXviZRWnSZMmYefOnfJ7W1tbeHl5oVevXhgyZAg0Gk0J5u7pMplM2LNnDzZu3IiQkBDo9XpUqFABDRs2xKBBgxAQEFDSWSxWP//8MyZPniy/12g0cHR0hL+/P9q2bYs+ffrAzs6uBHNIpdH3338PPz8/dOjQoViWd+rUKQwbNqxAaa9fv14s63wehYWFoX379gVK+/vvvz/l3BARERERFR0Df0RERET0zMydO9fi/e7du3Hs2LFs0319fZ94XSkpKVi6dCnGjx+fLfD3xhtvYMyYMU+8jqLSaDSYMWMGACAhIQEHDx7EV199hUuXLmHhwoXFtp5///0XSqWy2Jb3pGbMmIGNGzeiffv26NGjB5RKJYKDg3H06FF4e3uXucCf2dtvvw0vLy8YDAZERkbi9OnTmDVrFtatW4fvvvsOtWrVktOWdNksTgUpf6tXr34q635ay33WcioPy5cvR6dOnYot8Ofr65vtHLxgwQLY2Nhg3LhxxbKOwurZsye6dev2TB+EcHFxybYf1q5di4cPH1oE8M1piYiIiIieVwz8EREREdEz07NnT4v3Fy9exLFjx7JNf9pUKhVUqpKrCqtUKottHjRoEPr37499+/Zh0qRJqFixYpGXbTKZoNfrodVqodVqiyO7xSIyMhKbNm3CgAED8OWXX1p8JopiqeyesKDatGmD+vXry+/Hjh2LEydOYNy4cXjzzTexb98+WFlZASj5slmcClL+ijuwk5KSAmtr6zLTcvZZlAc3N7ds5+CVK1fC2dk5z3Nz5nNNcVMqlc/8oQUbG5ts27tv3z7Ex8cX+zVKFEWkpaXJxz0RERERUXHiGH9ERERE9FwxmUxYt24dunXrhvr16yMoKAhTpkxBXFycRbpLly5h1KhRaN68ORo0aIB27drJrTLCwsLQsmVLAMDSpUvh7+9vMYZUTuNm+fv744svvsBvv/2G7t27o169eujWrRuOHDmSLY+nTp1Cnz59UL9+fXTo0AFbtmx5orHZFAoFmjVrBgAIDw8HAOh0OixevBgdO3ZEvXr10LZtW8ydOxc6nS7HfO/Zs0feZ0ePHpU/yzq23ZUrVzB69Gg0btwYjRo1wvDhw3HhwoVsebp58yaGDRuGBg0aoE2bNvjuu+9gMpmypUtISMDt27eRkJCQ5zaGhYVBFEU0btw422eCIMDV1dViWnx8PGbNmoV27dqhXr16aNOmDT766CM5QKjT6bBo0SL06dMHTZo0QUBAAAYNGoSTJ0/mmQ+zR48eYfLkyQgKCpK/659++ilbuocPH+LNN99EQEAAWrZsiVmzZmX7DoqiZcuWePPNNxEeHo49e/bI03MqR8eOHcOrr76KwMBANGrUCJ06dcKCBQsKtJ74+HjMnDkTbdu2Rb169dCxY0esWLEi23cZHx+PSZMmoUmTJggMDMTHH3+Mq1evZhu3K7ex83IaC6wgYyvmtjyTyYQFCxbghRdeQEBAAMaNG4cHDx5km7d79+7477//MHjwYDRs2FDeL1mXm9uYcTmN12he7rVr1zBkyBA0bNgQHTt2lMcdPH36NPr3748GDRqgU6dOOH78eJ7bKIoimjdvjtmzZ1tsX2BgIGrXro34+Hh5+ooVK1CnTh0kJSUByF4e/P39kZycjJ07d8rntUmTJlmsLyEhAZMmTUJgYCCaNGmCyZMnIyUlJc88FkRe55rVq1dj4MCB8vm4T58+OY7TqNPpMGvWLLRo0QKNGjXCuHHj8PDhw2zpcvq+2rVrh7Fjx+LMmTPo168f6tevj/bt22PXrl3Z5jd/d5nPXzt27Hgq4wbqdDrMnj0bLVq0QEBAAN56661sDzKY83706FH06dMHDRo0wJYtWwAU/Bj99ddf0adPHzRq1AiNGzdGjx49sH79+iLlBwA2btyIbt26oV69emjVqhWmT59uURZzk9O5Iqfzf0REBCZPnow2bdrI63jjjTee63EbiYiIiMqKsvEoKRERERGVGVOmTMHOnTvRp08fDB06FGFhYdi4cSOuXLmCzZs3Q61WIyoqCqNGjYKzszPGjBkDBwcHhIWF4fDhwwCkbtimTZuGadOmoWPHjujYsSOA/McYPHv2LA4dOoRBgwbB1tYWGzZswNtvv43//e9/cHZ2BpAROHN3d8eECRNgMpnw7bffPnHXb/fu3QMAODk5wWQy4Y033sDZs2cxYMAA+Pr64saNG1i/fj3u3r2L7777zmLekydPYv/+/Rg8eDCcnZ3h6emZ4zpu3ryJwYMHw9bWFqNHj4ZKpcLWrVsxdOhQ/Pjjj2jYsCEA6YbtsGHDYDQaMWbMGFhbW2Pbtm05tuw5fPgwJk+ejNmzZ6NPnz65bl/lypUBAAcOHEDnzp1hbW2da9qkpCQMHjwYt2/fRt++fVGnTh3ExMTgjz/+wKNHj+Di4oLExERs374d3bt3R//+/ZGUlISffvoJo0ePxvbt21G7du1clx8ZGYkBAwZAEAQMHjwYLi4uOHLkCD799FMkJiZixIgRAIDU1FQMHz4cDx48wNChQ1GhQgXs3r27wMHF/PTs2RMLFizA33//jQEDBuSY5ubNmxg7diz8/f3x9ttvQ6PRICQkBOfOnct3+SkpKRgyZAgePXqEgQMHolKlSjh//jwWLFiAiIgIfPrppwCkwNSbb76Js2fPYuDAgfD19cXhw4fx8ccfF8t2FsWyZcsgCAJef/11REVFYf369RgxYgR2795t0UoqNjYWr7/+Orp164aXX345WwC5qOLi4jBu3Dh07doVnTt3xubNm/H+++/DZDJh1qxZGDhwILp3747Vq1fj7bffxp9//pnreI2CIKBx48b4559/5GnXr19HQkICFAoFzp07hxdffBGAdA6qXbs2bG1tc1zW3Llz8dlnn6FBgwZymfHx8bFI8+6778LLywvvv/8+rly5gu3bt8PFxQUffvjhE++X3M41P/zwA9q1a4cePXpAr9fj119/xTvvvIPly5fL2wYAn376Kfbs2YPu3bujcePGOHnyZKG6tg0JCcE777yDfv36oXfv3tixYwcmTZqEunXrokaNGgCkoP7w4cMBAGPGjIGNjQ22b9/+1FqBzpgxAw4ODhg/fjzCw8Oxfv16fPHFF/jmm28s0gUHB+ODDz7AK6+8ggEDBqBatWoFPkaPHTuG999/Hy1btsTEiRMBAHfu3MG5c+fkbS1MfpYsWYKlS5ciKCgIr776KoKDg7F582ZcunRJvs7mpDDnigkTJuDWrVsYMmQIPD09ER0djWPHjuHBgwfw8vJ6gj1ORERERPlh4I+IiIiInhtnzpzB9u3bMW/ePPTo0UOe3rx5c4wePRoHDhxAjx49cP78ecTFxWH16tUWXSi+9957AKQu2zp16oRp06bB39+/wN203b59G/v27ZNvpDdv3hw9e/bEr7/+iiFDhgAAFi9eDKVSic2bN8tdcnbp0gVdu3Yt1LaaW2AkJiZi//79+O233+Dv74/q1atj9+7dOH78ODZs2IDAwEB5nho1amDq1Kk4d+6cRcu54OBg7N27F35+fnmu85tvvoFer8fmzZvh7e0NAOjVqxc6d+6Mr7/+Gj/++CMAqZu/6OhobN++HQ0aNAAA9O7dGy+99FKhtjGzChUqoFevXti1axfatm2LZs2aoXHjxmjbtm22MR1Xr16NGzduYOnSpXLQFgDefPNNiKIIAHB0dMQff/xhcTN/wIAB6NKlCzZs2IBZs2blmpeFCxfCaDRi7969ckD31Vdfxfvvv4+lS5di4MCBsLKywtatW3H37l1888036NKli7yO4ur2z8PDA/b29nLQNyfHjh2DXq/HypUrCx1cXrt2Le7du4edO3eiatWqAICBAweiQoUKWL16NUaOHIlKlSrh999/xz///IMPP/wQo0ePBiDtj2HDhhV5255UXFwc9u3bJwfT6tSpg3fffRfbtm2zyFdERASmT5+OgQMHFuv6Hz9+jPnz56N79+4AgKCgIHTp0gUffPABtmzZIgfJfX19MWrUKBw6dCjPwHdgYCDmz5+PxMRE2NnZ4cyZM/D09ISrqyvOnDmDF198ESaTCefOnctzOT179sS0adPg7e2dazmsXbu2RfmPjY3FTz/9VCyBv9zONQcPHrQIyA4ePBh9+vTB2rVr5cDftWvXsGfPHgwaNAhTp06V033wwQe4fv16gde/ceNG+bzYpUsXtG3bFj///LMcfFq5ciXi4uKwc+dO+QGAPn36oFOnTk+07blxcnLCmjVrIAgCAKk154YNG5CQkAB7e3s5XUhICFatWoXWrVvL07777rsCHaPmwPLq1avz7QI1v/xER0dj+fLlaNWqFVauXAmFQuoIqnr16nKLzr59++a47IKeK+Lj43H+/Hl89NFHGDVqlDx97NixBdmlRERERPSE2NUnERERET03Dhw4AHt7e7zwwguIjo6W/+rWrQsbGxu5Oz7zzdQ///wTer2+2NYfFBRk0XqmVq1asLOzkwMzRqMRJ06cQPv27S3G4atSpYrFzdz8JCcno2XLlmjZsiU6duyIBQsWICAgAN9++y0AaT/4+vqievXqFvuhRYsWAGDRLSEANG3aNN+gn9FoxLFjx9ChQwc56AdIAbnu3bvj7NmzSExMBAD89ddfCAgIkIN+gNSKMnMw1qxPnz64fv16nsEKs9mzZ2PKlCnw8vLC4cOH8dVXX6Fr164YPnw4Hj16JKc7dOgQatWqZRH0MzPfzFYqlXLQz2QyITY2FgaDAfXq1cOVK1dyzYMoijh06BDatWsnjy1o/mvVqhUSEhJw+fJlAMCRI0fg7u6Ozp07y/NbW1vn2jqvKGxsbORuHXPi4OAAQLrhnlNXq3k5cOAAmjRpAgcHB4vtDAoKgtFolFugHTlyBCqVCq+++qo8r1KplIPdJaFXr14WLeg6d+4Md3d3/PXXXxbpNBpNgcpeYdnY2KBbt27y++rVq8PBwQG+vr5y0A+A/H9ewVtACvwZjUacP38egPSQg7mrxDNnzgAAbty4gfj4eItgf1FkDYIGBgYiNjZWPr6fRG7nmsxBv7i4OCQkJKBJkyYWx6L5u8vatWvWFmt58fPzs9g/Li4uqFatmsX+P3r0KAICAixa/To5OeV4/ioO5tbDZubv2txts5mXl1e260RBj1EHBwekpKTg2LFjT5yf48ePQ6/XY9iwYXLQDwD69+8POzu7bMdYZgU9V1hZWUGtVuP06dPZuukmIiIioqePLf6IiIiI6LkREhKChIQEeXy+rKKiogAAzZo1Q6dOnbB06VKsW7cOzZo1Q4cOHdCjR48n6s6tUqVK2aY5OjrK4x5FRUUhNTUVVapUyZYup2m50Wq1+P777wFIgQsvLy94eHjIn4eEhOD27dv57gezgnSbFh0djZSUFFSrVi3bZ76+vjCZTHjw4AFq1KiB+/fvWwQ3zHKatzAUCgUGDx6MwYMHIyYmBufOncOWLVtw5MgRvPfee9i0aRMAIDQ0tECtC3fu3Ik1a9YgODjYIgCc1/6Ijo5GfHw8tm7diq1bt+aaBpDGW6xSpYrFTXTgyfdDZsnJyXl2T9m1a1ds374dn332GebPny8Hizt37izftI+IiLCYx97eHlZWVggJCcH169dzLUeZt9Pd3T1b95LFuZ2FlfV4EgQBVapUyRZMqVix4lPpwtHDwyPb925vb29xnJqnAch3bLQ6derA2toaZ86cQevWrXH27FlMmDABbm5u2LBhA9LS0nD27FkAQJMmTZ4o7+Zudc3MweO4uLhcuyMtqNyOrf/9739YtmwZrl69ajEGZuZ9GB4eDoVCka1r0urVqxd4/bmdozMHl8LDwxEQEJAtXdb1Fpfc9nfWMpHTvivoMTpo0CDs378fr7/+OipWrIgXXngBXbp0QZs2bQqdn/v37wPIvt81Gg28vb2zHWOZFfRcodFoMHHiRHz11Vd44YUX0LBhQ7z44ovo1asX3N3dc10+ERERERUPBv6IiIiI6LlhMpng6uqKefPm5fi5uatDQRCwePFiXLhwAf/73/9w9OhRfPLJJ1i7di22bt2a6/hY+cmtCzVz95LFRalUIigoKNfPTSYTatasicmTJ+f4edbgQ+bWNqWFs7Mz2rdvj/bt22Po0KE4ffo0wsPDcx2fMKvdu3dj0qRJ6NChA0aNGgVXV1colUosX748z9ZX5lZzL7/8Mnr37p1jmvzGgiwuDx8+REJCQp4BCSsrK2zcuBGnTp3Cn3/+iaNHj2Lfvn3YunUr1qxZA6VSiVatWlnMYx5v0WQy4YUXXpC75MvK3LVgcTAajcW2rMIoaNnPGsQzy60VZW7ngqKeI9RqNRo0aIAzZ84gJCQEERERCAwMhKurKwwGAy5evIgzZ86gevXqTzxeaOZWXIXJY0HktL/PnDmDN954A02bNsXUqVPh7u4OtVqNHTt24JdffnnidWaWXzeXJaGg+zunfVfQY9TV1RW7du3C33//jSNHjuDIkSP4+eef0atXL3z11VdFys/TNmLECLRr1w6//fYb/v77byxatAgrVqzA+vXrUadOnWeaFyIiIqLyhoE/IiIiInpu+Pj44MSJE2jcuHGBbugHBAQgICAA7733Hvbu3YuJEydi37596N+/f643+p+Eq6srtFotQkJCsn2W07Si8vHxwbVr19CyZcti2w4XFxdYW1sjODg422d37tyBQqGQW9NUrlw5x+3Jad7iUK9ePZw+fRoRERHw9PSEj48Pbt68mec8Bw8ehLe3N5YuXWqxjxYvXpznfC4uLrC1tYXJZMoz+AoAnp6euHHjBkRRtFhHce2H3bt3A0C2wF1WCoVC7hp28uTJ+P7777Fw4UKcOnUKQUFBWLt2rUV6c1eMPj4+SE5OLtB2njx5EklJSRZB85y209HRMcfAqrkVUXHJWv5EUURISEiRg7LmVk8JCQkW0/Nq3VTcAgMDsXLlShw/fhzOzs6oXr06BEFAjRo1cObMGZw5cwb/93//98zyU1wOHjwIrVaL1atXW7S+3LFjh0U6T09PmEwmhIaGWrQ2u3PnTrHmx9PTM8fzV2hoaLGupzgU9BgFpFZ07dq1Q7t27WAymTBt2jRs3boVb775ZqFanJtbBN65c8ei22edToewsLA881KYcwUgbd/IkSMxcuRI3L17F7169cKaNWtyfbiHiIiIiIoHx/gjIiIioudGly5dYDQa8d1332X7zGAwyF2VxcXFZWu9YB7PydzNnLW1NYD8u+ArDHNLvd9//91iTLqQkBAcPXq02NbTpUsXPHr0CNu2bcv2WWpqKpKTkwu9TKVSiRdeeAG///47wsLC5OmRkZH45Zdf0KRJE7kbwLZt2+LChQv4999/5XTR0dHYu3dvtuUmJCTg9u3b2QIqWUVERODWrVvZput0Opw4ccKiC8CXXnoJ165dw+HDh7OlN3/v5pY/mcvBxYsXceHChTzzoVQq0alTJxw8eBA3btzI9rm5az0AaNOmDR4/fowDBw7I01JSUnL8XgrrxIkT+O677+Dl5YWXX34513SxsbHZpmUt60FBQRZ/FSpUACCVo/Pnz+dYNuPj42EwGABI22kwGLB582b5c6PRiB9//DHbfN7e3rhz547Ffrp27RrOnTtXgK0uuF27dlmMSXfgwAFERETk2LVhQZjLlnnMNEDaxuL4LgsqMDAQOp0O69evR5MmTeRgcpMmTbB79248fvy4QN182tjYFOt57UkplUoIgmDR6jMsLAy///67RTrzd7dhwwaL6evXry/W/LRq1QoXLlzA1atX5WmxsbE5nr9KWkGP0ZiYGIvPFAqFHATP3LVqQQQFBUGtVmPDhg0W58+ffvoJCQkJaNu2ba7zFvRckZKSgrS0NItpPj4+sLW1LXR+iYiIiKjw2OKPiIiIiJ4bzZo1wyuvvILly5fj6tWreOGFF6BWq3H37l0cOHAAn376KTp37oydO3di8+bN6NChA3x8fJCUlIRt27bBzs5OvrlsZWUFPz8/7N+/H1WrVoWTkxNq1KiBmjVrPlEex48fj7///huvvvoqXn31VZhMJvz444+oUaOGxY3mJ9GzZ0/s378fU6dOxalTp9C4cWMYjUbcuXMHBw4cwKpVq1C/fv1CL/fdd9/F8ePHMWjQIAwaNAhKpRJbt26FTqfDhx9+KKcbPXo0du/ejdGjR2PYsGGwtrbGtm3bULlyZVy/ft1imYcPH8bkyZPl7iVz8/DhQ/Tv3x8tWrRAy5Yt4ebmhqioKPz666+4du0ahg8fLndxOGrUKBw8eBDvvPMO+vbti7p16yIuLg5//PEHpk+fjlq1auHFF1/EoUOH8NZbb+HFF19EWFgYtmzZAj8/v3wDox988AFOnTqFAQMGoH///vDz80NcXBwuX76MEydO4PTp0wCAAQMGYOPGjfj4449x+fJluLu7Y/fu3YXuWvXIkSO4c+cOjEYjIiMjcerUKRw7dgyVK1fGsmXLoNVqc53322+/xZkzZ9C2bVt4enoiKioKmzZtgoeHR75BolGjRuGPP/7AuHHj0Lt3b9StWxcpKSm4ceMGDh48iN9//x0uLi5o164dGjdujPnz5yM8PBx+fn44dOhQjsHcfv36Yd26dRg1ahT69euHqKgoeb8nJSUVar/kxdHREYMGDUKfPn0QFRWF9evXo0qVKhgwYECRllejRg0EBARgwYIFiIuLg6OjI/bt2ycHVp6FgIAAqFQqBAcH45VXXpGnN23aVA6kBAYG5rucunXr4sSJE1i7di0qVKgALy+vHMfkfFbatm2LtWvXYvTo0ejevbtcRn18fCzOF7Vr10b37t2xadMmJCQkoFGjRjh58mSxtpYGpPPXnj178Nprr2HIkCGwsbHB9u3bUalSJcTGxj6V1uBFVdBj9LPPPkNcXBxatGiBihUr4v79+/jxxx9Ru3Zt+Pr6FmqdLi4uGDt2LJYuXYrRo0ejXbt2CA4OxqZNm1C/fv08H0Qo6Lni7t27GDFiBDp37gw/Pz8olUr89ttviIyMRLdu3Yq0r4iIiIio4Bj4IyIiIqLnyhdffIF69ephy5YtWLhwIZRKJTw9PfHyyy+jcePGAKQA4aVLl7Bv3z5ERkbC3t4eDRo0wLx58yy6LpsxYwa+/PJLzJ49G3q9HuPHj3/iwF+9evWwcuVKzJ07F4sWLUKlSpXw9ttv486dO8XWZZ1CocC3336LdevWYffu3Th8+DCsra3h5eWFoUOHolq1akVabo0aNbBx40bMnz8fy5cvhyiKaNCgAb7++muLwEGFChXwww8/YMaMGVixYgWcnJwwcOBAVKhQAZ9++mmR1l2tWjV88skn+Ouvv7Bp0yZERUVBo9GgZs2amDFjBvr16yentbW1xcaNG7FkyRIcPnwYO3fuhKurK1q2bImKFSsCAPr06YPIyEhs3boVf//9N/z8/PD111/jwIEDcuAuN25ubti+fTu+/fZbHD58GJs3b4aTkxP8/PwwceJEOZ21tTXWrVuHL7/8Ej/++COsrKzQo0cPtGnTJtcxuXJi7n5UrVbDyckJNWvWxCeffII+ffrIrSxz065dO4SHh2PHjh2IiYmBs7MzmjVrhgkTJsDe3j7Pea2trbFhwwYsX74cBw4cwK5du2BnZ4eqVatazK9QKLBs2TLMmjULe/bsgSAIaNeuHSZNmoRevXpZLNPX1xdfffUVFi9ejNmzZ8PPzw9z587FL7/8ku9+L4xx48bh+vXrWLFiBZKSktCyZUtMnTpVbslbFPPmzcOUKVOwYsUKODg4oF+/fmjevDlee+21Yst3XmxsbFC7dm1cunTJImhrDvZVqlSpQGNcTpo0CVOmTME333yD1NRU9O7du0QDfy1btsTMmTOxcuVKzJo1C15eXpg4cSLCw8OzPSgwa9YsODs7Y+/evfj999/RvHlzrFixIs9WZoVVqVIl+fy1fPlyuLi4YPDgwbC2tsaMGTPyDLQ/awU9Rl9++WVs27YNmzZtQnx8PNzd3dGlSxdMmDAh1zH98jJhwgS4uLjgxx9/xOzZs+Ho6IgBAwbg/fffh1qtznW+gp4rPDw80K1bN5w4cQJ79uyBUqlE9erV8c0336BTp06Fzi8RERERFY4gPusRnomIiIiIyqA333wTt27dwqFDh0o6K0TFIiwsDO3bt8+3NSdRaTBz5kxs3boV58+fl7sKJiIiIiIqizjGHxERERFRIaWmplq8v3v3Lo4cOYJmzZqVUI6IiMgs6zk6JiYGe/bsQZMmTRj0IyIiIqIyj119EhEREREVUocOHdC7d294e3sjPDwcW7ZsgVqtLlT3j0RE9HS88soraNasGXx9fREZGYkdO3YgMTERb775ZklnjYiIiIjoqWPgj4iIiIiokFq3bo1ff/0VERER0Gg0CAgIwPvvv4+qVauWdNaIiMq9tm3b4uDBg9i2bRsEQUCdOnUwc+ZMNG3atKSzRkRERET01HGMPyIiIiIiIiIiIiIiIqIygGP8EREREREREREREREREZUBDPwRERERERERERERERERlQEM/BERERERERERERERERGVAaqSzkBpFRGRUNJZKHUUCgEuLraIjk6CycShJen5xvJKpQXLKpUmLK9UmrC8UmnC8kqlCcsrlSYsr1SasLxSacLyWjTu7vYFSscWf/TMKBQCBEGAQiGUdFaI8sXySqUFyyqVJiyvVJqwvFJpwvJKpQnLK5UmLK9UmrC8UmnC8vp0MfBHREREREREREREREREVAYw8EdERERERERERERERERUBjDwR0RERERERERERERERFQGMPBHREREREREREREREREVAYw8EdERERERERERERERERUBjDwR0RERERERERERERERFQGMPBHREREREREREREREREVAYw8EdERERERERERERERERUBjDwR0RERERERERERERERFQGMPBHREREREREREREREREVAYw8EdERERERERERERERERUBjDwR0RERERERERERERE9IyMHz8GixbNf6Jl7Nu3F507v1gs+SnOZT1NWfO5evVyjBgxSH4/c+Y0TJ78gfy+qPv5wYP7aNUqEDdvXn+i/JYUVUlngIiIiIiIiIiIiIiI6HkQExOD1au/x/HjfyMmJhr29g7w86uBESNGo0GDgJLOXqG0ahUo/29lZQU3N3fUr98Qffu+glq1asuftW/fES1bvlASWSyU/PL5zjsTIYriE6+nQoWK2L37ABwdnZ54WSWBgT8iIiIiIiIiIiIiIiIAn332EfR6PT77bDoqV/ZEdHQUzp79B/HxcSWdtSL55JOpaN68JXQ6He7dC8WePT9j7NgRmDTpc3Tp0h0AoNVaQau1KuGc5i+/fNrZ2T3xOvR6PdRqNVxd3Z54WSWFXX0SEREREREREREREVG5l5CQgIsXz+ONNyagceNAeHhUQp069TB06Gto1aqtRbq5c2eiR4+X0K5dEIYOHYBjx44CAOLiYjF16ifo1asL2rd/AcOGvYLDhw/kuV6dToelS79Br15d0KFDK7z++nCcO3fGIs2+fXvRp083tG//AiZPnoi4uIIFIu3s7OHq6oZKlSqjWbMWmDFjLjp27IyFC79GfHy8vOzMXWjevHkDEyaMRceObfDSS20xcuQQXLt2Jc/1HD36J0aOHIx27YLQv39PrFmzAgaDQf783r1QvPXW62jXLggDB/bFsWPH0KJFYxw58icA4Ny5M2jVKhAJCQmZ8nEdrVoF4sGD+znmM6usXX0CgNFowIIFX6FTp7bo1q09Vq5cZtEqsF+/Hli3bhW+/HIKXnqpLebOnZmtq8+c1nvkyJ8WLSrN3Y7+8stu9OnTDR07tsa8eXNgNBqxceN6vPxyJ3Tv3hHr16/Ocz8WB7b4IyIiIiIiIiIiIiKiZ+JB4n0k6hOf2frs1HaoZFe5QGmtra1hbW2Do0f/RN269aHRaLKlMZlMmDjxbSQnJ2HKlC9QubIX7t4NhkIhtbPS6XTw96+NIUOGw8bGFidO/I0ZM6bC09MLderUy3G9CxfOxd27dzB9+iy4ubnjr7/+h4kT38b69Vvg7e2Dy5f/w5w5X2Ls2LfQuvWLOHXqBFavXl7UXYJXXhmEAwd+xT//nEL79h2zff7FF5+hZk1/TJw4GQqFAjdv3oBSmXs46eLF85gxYyreffdDNGgQgPv3wzB37iwAwMiRY2AymfDppx/C2dkVy5evQ2pqEubNm1fk/BfG/v2/onv3nli5cj2uXbuKuXNnomJFD7z8cm85zebNGzBixOsYOXLME60rPDwMJ08ex/z5SxAeHobPP/8Y9++Hw8fHB0uXLselS/9i9uwvEBjYHHXr5lwWigMDf0RERERERERERERE9NTFpcVixIFBMBXDOGwFpRAEbOuxC45ap3zTqlQqfPrpVHz11Uzs2vUz/P39ERDQBO3bvwQ/vxoAgDNnTuPq1cv48cft8PGpAgDw9PSSl+HuXgGDBg2V3/frNxCnT5/EH3/8lmPg7+HDh9i3by927PgFbm7uAIBBg4bi1KkT2LdvL8aOfQvbt29G8+YtMXjwcACAj08V/PffRZw6daJI+8THp2r6uu/n+PmjR48waNAwVKkipfP29slzeWvWrMSQISPkrkM9Pb0wevQ4fPfdYowcOQZnzpxGSMhdLFiwFG5u7lCpFHjvvffw+uuvFyn/hVGxYkW8/fb7EAQBPj5Vcfv2LWzbtski8Ne4cVO8+uoQ+b25hWFhiaIJn3wyBTY2tqhWrToaNQrEvXshmDdvERQKBXx8qmLjxvU4d+4MA39ERERERERERERERFS6OWqdsK7zpmfe4q8gQT+zF19sj5YtW+Hff8/j8uX/cPLkcWza9AM+/vgzdO3aAzdvXoe7ewU56JeV0WjEhg1r8ccfhxEREQGDQQ+dTpfr2HR37tyC0WjEq6/2sZiu0+ng6OgIAAgJCUabNv9n8Xndug2KHPgDpMCrIAg5fvrKK4MwZ86XOHBgHwIDm6Fduw5ycLNjx9Zyupde6oIPP/wEt2/fwKVLF/HDD2vkz4xGE3S6NKSmpuLu3WBUqOAhBzYBoFGjRkXMe+HUqVPPYjvr1auPLVt+hNFohFKpBADUqlW7WNbl4VEZNja28nsXFxcolQq5Nag0zRWxsdHFsr7cMPBHREREREU27fhnaF6pJbpU61bSWSEiIiIiIqJSoKDdbpYkrVaLpk1boGnTFhgxYjTmzPkSq1cvR9euPaDVavOcd9OmDdi+fTPefvsDVK/uB2trayxePB8Ggz7H9CkpyVAqlVi9egMUCqXFZ9bW1sW2TZndvXsXAFCpUs7fxahRY9GxY2ecOPE3Tp48jjVrlmPatFlo2/b/sHbtJjmdra0U5EpOTsGoUWPQtm27bMvKqbvUnJiDY5nH38s8RuDTlN9+FgTBIl9AznlTqSxDboIgZJsGACbT023xysAfERERERXJ4+THOBZ+FEbRyMAfERERERERlVlVq1bD0aN/AgB8fWsgIuIxQkNDcmz1d+nSRbRq1RadOnUFII0JGBoaimrVquW47Bo1/GE0GhETE4OGDXNuBVelSjVcufKfxbTLly8VeXu2bdsEW1tbBAY2zzWNj08V+PhUwSuvDMbUqZ9g3749aNv2/+Dl5Z0trb+/P0JDQ3L8DJD23+PHDxEZGQk3NzcAwIULFyzSODk5AwCioiLh4OAAALh580ZRNs/ClSuXLd5fvvwfvL195NZ+BeHk5Izk5GSkpKTIQcKbN68/cd6eFkX+SYiIiIiIsjv1QOpS5E7srRLOCREREREREdGTi4uLxdtvj8PBg/tw69ZN3L8fjj/++A2bNm1Aq1ZtAQCNGjVBw4aN8NlnH+Gff07i/v1wnDhxDCdPHgcAeHt7459/TuHSpYu4ezcYX389CzExUbmu08enCl56qQtmzJiKv/76A/fvh+PKlf+wYcNaHD/+NwBpnMBTp05g06YNuHcvFDt2bC1wN5+JiQmIiorEw4cP8M8/J/HZZx/ht98O4oMPJsPe3j5b+rS0VCxY8BXOnTuDhw8f4N9/L+DatSuoUiXnwCUAjBjxOg4c+BVr1qzAnTu3cfduMH777SBWrPgOABAY2Aze3lUwc+ZU3Lx5AxcunMPChQstluHl5Y0KFSpizZoVuHcvFMeP/40tW34s0Dbm5dGjh1iyZAFCQ+/i8OED2LFjK/r1G1ioZdStWw9WVlZYvvxbhIeH4dChA9i//5cnztvTwhZ/RERERFQkJ+8fg0qhxOPkx4hPi4OD1rGks0RERERERERUZNbWNqhTpx62bt2E+/fDYDAYUKFCRfTo0QvDhr0mp5s5cy6WLv0G06Z9ipSUVHh5eWHcuAkAgOHDR+H+/XC8//4EWFlZ4eWXe6N16xeRlJT7uIaffDIV69evxtKl3yAi4jEcHZ1Qt259BAVJ4+nVq1cfH330KdasWYHVq79HYGAzDB8+CuvXr8p3m2bNmg4A0Gi0cHd3R4MGAVixYj38/WvlmF6hUCIuLg4zZkxFTEw0HB2d0Lbt/2HUqLG5rqN585aYO/cbrFu3Ehs3rodKpYKPT1X06NErfZkKzJr1NebM+RJjxgxHpUqVMWXK5xg9erS8DJVKhWnTZmL+/DkYPvxV1K5dB6+//gY+/3xSvtuYl86duyEtLQ2vvz4cCoUS/foNRM+effKfMRMHB0d8/vmX+O67Rdi7dyeaNGmGkSPHYO7cmU+Ut6dFELN2TEoFEhGRUNJZKHVUKgWcnW0RE5MEg8FU0tkhyhPLK5UWLKtUUlIMKei7uwc6VumEfcG/4Ks289G4YmCe87C8UmnC8kqlCcsrlSYsr1SasLxSacLySqWJubz6+/tj1qx5aNPmxZLOUqng7p69hWZO2NUnERERERXahcfnoDfp0admf2iVWtxmd59ERERERERERCWOgT8iIiIiKrRTD07A084LVRyqorqTL27H3izpLBERERERERERlXsc44+IiIiICkUURZx8cBxtvdoBAPycauDfiIslnCsiIiIiIiIiKk1OnjzHrmmfArb4IyIiIqJCuRV7E1EpUWhZOQgAUN3RD/cSQpBmTCvhnBERERERERERlW8M/BERERFRoZx8cBw2ahvUc2sAAKjhXBMmUcTduOASzhkRERERERERUfnGwB8RERERFcrJ+8fRtGJzqBRSr/FVHatBIQi4GXOjhHNGRERERERERFS+MfBHRERERAUWnRqFGzHX0aJyS3maVqmFt30V3Im7VYI5IyIiIiIiIiIiBv6IiIiIqMBOPzgFhSCgqUdzi+l+Tn64FXuzhHJFREREREREREQAA39EREREVAgnHxxHbZe6cNQ6WUz3daqBO7G3YRJNJZMxIiIiIiIiIiJi4I+IiIiICkZn1OHso3/QonJQts98nfyQZkxDWMK9EsgZEREREREREWXWr18PbNu26Zmvt1WrQBw58ucTLWP8+DFYtGh+nmkKsn16vR6vvNILly5dLPC6T548jhEjBsFkKr0PNqtKOgNEREREVDpcjDiPVEMqmldqme2zGs41AQC3Ym/Cx6HKs84aERERERERUbF59OghVq9ejlOnTiAuLhaurm5o3fpFvPbaaDg6OpVo3mbOnIb9+3/J9XMPj0r46ae9zzBHz69du3agUqXKqF+/IQDgwYP7WLduFc6dO4OoqCi4ubmhU6euGDZsJNRqNQCgRYsgrFr1PQ4d2o/OnbuVZPaLjIE/IiIiIiqQkw9OoKJNRVR1qJbtM3uNAyrYVMDt2Jto59OhBHJHRERERERE9OTCw8MwbtxIeHv7YNq0mahUyRPBwbfx3XeLcPLkcaxYsRYODo4llr933pmIcePGy+979uyMTz6ZiubNpYd0FQplkZdtMBigUpWNsJEoitixYxtGjx4rTwsJuQtRFPHhh5/A09MLwcG38dVXM5GSkoLx49+V03Xp0h0//bSVgT8iIiIiKrtEUcTpByfQvHIQBEHIMU11Jz/cir35jHNGREREREREpUnMrWgAgLWbDaycrOTpyRHJSItLhUKlgGNVJ3m6UW9EfEgcAMDWww4aO438WeKDBOiT9FBZq2HvaS9PN6TokRCeAABw9nMpVP4WLJgLtVqNhQuXQquV8ufh4YGaNf3xyiu9sGLFd5g4cTIAqbvJ7t17Ijj4Do4dOwI7O3sMHfoa+vYdIC8vISEB3377Df7++y/odHrUqlUbEya8jxo1pJ5zVq9ejqNH/8LAgYOxatX3SEiIR4sWQfj4489gY2ObLX92dnaws7PLMs0erq5u2dKmpqZi1qzp+N//foe9vT2GDx+Fnj37AJBav/Xv/zKmT5+FnTt/wpUr/2HixMno2rUH9u7dhS1bfsSDB/fh4VEJ/foNRJ8+/QFI3WcuWbIAf/31BxISEuDs7IJevfpi6NDX5PXGxcVi8uSJOH36BNzdK2D8+HfRqlVb+fNz585i2bLFuHbtGhwcHNC5c3e8/vobuQYdY2KiMXv2lzhz5jRcXV3x+utv5Ps9Xr9+FffvhyEoqJU8rUWLILRokTF8iaenF0JDQ7Bz5w6LwN8LL7TBwoVzER4eBk9Pr3zX9bzhGH9ERERElK+Q+Lt4mPQQLXLo5tOshlNN3I69DVEUn2HOiIiIiIiIqDQ5Pu0Ijk87goenwi2m3z14G8enHcHZb05ZTNfFpcnzRF+LtPjs+rarOD7tCP5be8FienxovDxPYcTHx+H06RPo3bufHPQzc3V1Q8eOXfD774ctfvdu2rQBfn41sWbNRgwZMhyLF8/HP/+clD///POPERMTjXnzFmP16g2oWbMW3n33DcTHx8lpwsPDcPTon5g7dyHmzv0GFy6cw4YN6wqV95xs2bIRtWrVwdq1G9G7d3/Mnz8HoaF3LdJ8//1S9O8/ED/+uB3NmrXEoUP7sWrV9xgz5k38+ON2jB37Flat+l7uXnT79i34++8j+OKLOdi0aQemTJkBD49KFstcu3Yl2rXrgPXrt6BFixcwffrn8vZGRDzG++9PQP369bFhwxZ88MFk/PrrbqxfvzrX7Zg5cxoeP36ExYu/x5dffoWdO7cjJiY6z22/ePE8vL19cgyeZpaYmAgHBweLaR4eHnBxccXFi+fznPd5xRZ/RERERJSvkw+Ow0plhYbujXJN4+vkh7i0WESmRMLdxv0Z5o6IiIiIiIjoyd27dw+iKKJKlexDXABA1apVkZAQj9jYGDg7Sy0J69dviKFDRwAAfHyq4NKli9i6dROaNm2Bixcv4OrVy9i79zA0Gqml4vjx7+Lo0T/xv//9Lre+E0UTPv10mhyk6tSpK86e/eeJt6dlyyC5pd6QIcOxbdsmnDt3Bj4+VeU0/fu/irZt28nvV69ejvHj35WnVa7sieDgO9i9+2d06dIdjx8/hLe3Dxo0CIAgCNmCfoDUVWbHjp0BAGPHvoWfftqCK1cuo0WLIPz883ZUrOiBKVOmIDY2GV5eVRAZGYFly5bgtddeh0Jh2V4tNDQEJ08ex8qV61G7dl0AwKRJUzB4cL88t/3hw4dwc8v73kRY2D3s2LEVb731brbP3Nzc8PDhgzznf14x8EdERERE+bobdwd+TjWgUWpyTePnVAMAcDvuFgN/RERERERElKOgaW0ASF19Zla1ky8qtfCEQmUZ+NE4auV5bD0su7j0H1Ab1bv5QWWttpju4OMgz1MUhenJpl69+hbv69ZtgO3bNwMAbt26gZSUFHTr1t4iTVpaGsLDw+T3Hh6VLVqmubq6ISYmpihZt+DrW0P+XxAEuLi4ZlturVq15f9TUlIQHh6GOXO+xNy5M+XpRqMRtrbSvu/SpQfee+8tvPpqX7Ro0RJBQa3RrFmLXNdrbW0NW1tbuYVeSMhd1KtX32IYkfr1GyIlJRmPHz+Gh4eHxbJCQoKhVCrh75+RzypVqsLOzh55SUtLlYOtOYmIeIwPPpiA//u/Dnj55d7ZPtdqtUhNTc1zHc8rBv6IiIiIKF8RKZFws847mFfBpiLsNfa4HXMzzy5BiYiIiIiIqPzKbcw9G3cb2LjbZJuuVCtznceuUs7BH5W1utBj+wGAl5cXBEFASEgwgP/L9vndu3dhb+8AJyfnAi0vJSUZrq5uWLJkebbPMgeuso5tJwgCRNFUuMznIKflmkyWy7W2trbILwB8/PFnqFOnnkU6c0s8f/9a2L59N06ePI4zZ05jypRJCAxshhkz5uazPc92WBBHRyfcuXM7x88iIyMwYcI41KvXAB999GmOaeLj4wv8PT9vGPgjIiIionxFpUSipnPNPNMIgoDqjn64FXvzGeWKiIiIiIiIqPg4OjqhadPm2LnzJ7zyyiCLcf6ioiJx+PB+dO7czaK12uXLlyyWcfnyJVSpUhWAFCSLjo6CUqlEpUqVn8k2PAkXF1e4ubnj/v1wvPRSl1zT2draoX37l9C+/Ut48cX2+OCDCYiPj4ODg2O+66hSpSqOHPmfRSDw0qWLsLGxRYUKFXJMbzQacf36Vbmrz9DQu0hMTMhzPTVr+mPXrh0QRdHi+4qIeIwJE8bB378WPvlkarauRYGMFpk1a/rnuz3Po+xbRERERESUiSiKiEqNhKu1W75pfZ38cJuBPyIiIiIiIiql3nvvI+j1Orz//gRcuHAOjx49xMmTx/Hee2/Bza0Cxox50yL9pUsXsXHjeoSGhmDHjm3488/f0b//qwCAwMDmqFu3PiZPnojTp0/iwYP7uHTpIpYv/xbXrl0pic3L16hRY7Fhw1ps374FoaEhuH37Fn79dQ+2bPkRALBly484fPgAQkLuIjQ0BP/7329wdXXNt+tNsz59+uPRo4f48ssvcfduMI4e/RNr1izHK68MyjEI5+NTFc2bB+Hrr2fh8uX/cO3aVcyZMwNarTbP9TRuHIiUlGQEB2e0+pOCfmNRsaIHxo9/F7GxMYiKikRUVKTFvJcvX4JarUG9eg0KtE3PG7b4IyIiIqI8JRmSkGpIhatV/oG/Gs418PPN7UjUJ8JObZdveiIiIiIiIqLnibe3D1at2oDVq5djypTJiI+Pg4uLK9q0eRGvvfZ6tlZtAwcOwbVrV7F27UrY2tpi/Pj30Ly5NPyFIAiYN28RVqz4DrNmTUdsbAxcXFwRENAYzs6F74r0WejRoxe0Wits3vwDvvtuEaysrOHr6ycHM21sbLFp0w8IC7sHhUKBWrXq4uuvF+UYtMuJu3sFLFiwBMuWLca2bdvg4OCAbt16YvjwUbnO88knU/DVVzMwYcIYODu74PXX38CqVY/yXI+joxPatPk/HDp0AOPGjQcA/PPPKYSF3UNY2D307t3VIv3ff5+R///tt4N46aXOsLKyQmkkiM+6Y9UyIiIi72aklJ1KpYCzsy1iYpJgMDx5/8RETxPLK5UWLKv0LNyNC8brh0Zgwf8tQX23vJ92uxN3G2MPjcT8FxehgXuAxWcsr1SasLxSacLySqUJyyuVJiyvVJqwvJaMfv16YMCAVzFgwKCSzkqp8qzK661bN/Hee29h69ZdsLHJPn5kTmJjYzFoUF+sWvUDKlf2fGp5Kwp394K1qmRXn0RERESUp6hUqcsLtwK0+POxrwK1Qs1x/oiIiIiIiIioRPn51cAbb0zAgwf3CzzPw4f38cEHHz93Qb/CYFefRERERJSnqBQp8FeQMf5UChWqOVbH7dhbTztbRERERERERER56tq1R6HS16pVB7Vq1XlKuXk2GPgjIiIiojxFpkTCQeMAjVJToPS+Tn64EXPtKeeKiIiIiIiIqGT99NPeks4CUTbs6pOIiIiI8hSZEglXa9cCp/dzqoG7ccHQGXVPMVdERERERERERJQVA39ERERElKeolEi4WbsXOL2vUw0YRRNC4u8+vUwREREREREREVE2DPwRERERUZ4iUyIKNL6fWVXHagCAUAb+iIiIiIiIiIieKQb+iIiIiChPUamFa/Fnq7aFs5UzwhLDnmKuiIiIiIiIiIgoKwb+iIiIiChXRpMRManRcLUqeFZPxcUAAQAASURBVIs/APC290FYwr2nlCsiIiIiIiIiIsoJA39ERERElKuYtBiYRBFuhejqEwC87LxxLyH0KeWKiIiIiIiIiIhywsAfEREREeUqKiUSAArV1ScAeNp7ITwxDKIoPo1sERERERERERFRDhj4IyIiIqJcRaZEAABcrV0LNZ+3vQ9SDamITA8cEhEREREREZUlrVoF4siRP0s6G7l68OA+WrUKxM2b15/pes+dO4NWrQKRkJDwRMvJb/8WdPtCQ+/i5Zc7ITk5qcDr3rXrJ3z00XsFTv+8UZV0BoiIiIjo+RWVEgmVQglHrVOh5vOy9wYAhCfeg7tN4VoLEhEREREREZWkqKhI/PDDGhw/fgyRkY/h7OwCP7+aGDDgVQQGNivp7KFfvx54+PBBrp936dIdI0eOeYY5en59//236Nt3AGxsbAEAaWlpmDdvNq5fv4qQkLsICmqF2bPnW8zTrVtPrFu3GhcvnkfDho1KIttPhIE/IiIiIspVZGokXKxcoRAK11GEh00lKAQB9xLuIaBC46eUOyIiIiIiIiptkkJDAAAaZ2eo7R3k6bqYaOgTEiCoVLCp7ClPNxkMSLkfDgDQurlBlR7AAYDUiMcwpqRAaWUFqwoV5enGtFSkPnoEALD1qVKo/D14cB9vvDEKdnb2eOutt1G9uh8MBgNOnz6BBQu+wqZNOwq/0cVs5cofYDIZAQD//fcvPv30I2zatAO2ttK+0WqtkJAQX+jlGo1GCIIAhaJsdBb58OFDHD9+FO+996E8zWQyQavVol+/gfjzzz9ynE+tVqNjx87Yvn0LA39EREREVLZEJkfA1dqt0POplWpUsvVEWMK9Iq9bFEUIglDk+YmIiIiIiOj5c2PZYgCAV49ecA9qLU9/fOwoIo4dgcbZBXU/+lSebkhMkOepNuQ1ONWtJ3/24NB+xP73L+yq+aLGmDfl6SkPHuDm8qUAgEZZWnPlZ/78ORAEAStXroe1tbU8vXp1X3Tr1jPX+W7fvoVFi+bhv/8uwcrKCm3btsOECe/BxsYGgNQF5rJlixEcfAcqlQrVqlXH1Kkz4eFRCQBw9OifWLt2Je7eDYarqzu6dOmGYcNGQqXKHsZxdnaW/7dPD546O7vA3t5enm4O/N2/H47FixfgypX/4OXlgw8/nIx69RoAAPbt24vFi+fjs8+m4/vvl+LevVBs2bITrq5uWLHiO/z220EkJiagWjVfvPHGBDRuHAgAePjwARYsmIt//70Ag0EPD4/KeOutt9GyZSt5/devX8WyZUtw9+4d1Kjhj08+mQIfn6ry55s2bcKqVavx6NFDVKpUGcOHj0Lnzt1y3b9XrvyHr7+ehZCQu6hWzRfDho3MNa3ZH38chp9fTbi7V5CnWVtbY+L/s3fX8U1dbQDHf0mTurtSxVvc3adsjPnGfHvn7u7uzsac+cbGHDaY4BSvYKUGdU89aeT9ozTV1GibyvP9fPi8764+t7knuec895xz1/0AxMfvo7y85SFJp0+fye2334hWW42dnX2b5+pN+kfaVgghhBBCdIvC6gK87Due+AMIdgkms7xzib/KmkquWLOMv4+u69T+QgghhBBCCCFER5WWati+fStLl57bKOlXp2FiraGqqiruuOMmXFxc+OCDT3nyyefYuTOWV199AQC9Xs8DD9zFmDHj+fTTr1m+/GPOOGMpUPuy6759e3jqqUc599wLWbnyW+65537++ONXPvvsoxO+pvfff4cLL7yEjz/+kpCQQTz22IPo9Xrz+urqar744lPuvfchVq78Bg8PT1599QUSE+N4/PFn+PTTr5k7dwF33XULx44dBeCVV56npkbH22+v4NNPv+b662/GwcGx2Xlvuuk2PvhgJTY2Njz77BPmdf/++zfPPPMMF164jM8++4Yzz1zKs88+we7dO1u8hsrKSu6553bCwiL44IOVXHnl/3j77dfavPa4uD0MGza8E381GDZsBAaDgcTEhE7tb03S408IIYQQQlhUWFXIIN+wTu0b7BLC1qwtndr3iwOfklmeQUrJEeYNWtCpYwghhBBCCCGE6H2GXH8LUDvUZ0O+02fiMWoMiiY93FTOLuZ97Lwbv5gasOgUfGfOwca+cY8sh4AA8z4dkZFxDJPJ1KhnWnv89dcadDodDz30hDlheMcdd3PvvXdw/fU3o1KpKC8vZ9q0GQQFBQMQFhZu3v+jj1awbNnlnHLK6QAEBQVz9dXX8c47b5zwXH0XXriMadNqe+JdddW1XHLJeWRmZhAaWnuNer2eO+64j8GDhwC1w2P+/vsvrFr1K97ePgBcdNElbN++ld9//4Vrr72R3NwcZs+eR2RklDnepv73vxsYO3Y8AMuWXcbdd9+GVqvFzs6OL75YyVlnncU555yHXm9k0KBQEhMT+OqrleZehU3/viaTkfvuexg7OzsiIiLJz8/lpZeea/Xac3JyGDZsRKf+bvb29jg5OZObm9Op/a1JEn9CCCGEEMKigqp8vBy8OrVvsPMgciq+p8ZQg9pG3e79jpams+rwtwAUa4s7dW4hhBBCCCGEEL2TpTn3bD08sfXwbLZcqVJZ3Me+wRCODdnY2Xd4bj8Ak6nDuwCQnp5KVNTgRr0EY2LGYDQaOXo0nTFjxnHqqYu5886bmTBhMhMmTGLevIV4H09kJicfJj5+X6MefgaDEZ1OS3V1Nfb2nR9qMjJysPn/e3nVnq+4uMic+FOr1URF1W+TknIEg8HAhRcubXQcnU6Hm5sbAOeccwEvvfQsO3ZsY8KEycyePa/RMSyftxh/f3/S01O5+OILG20fEzOa7777usVrSE9PJTJyMHZ2duZlI0eOavPatdpqbG1t29zOEjs7O6qrqzu9v7UMyMTfl19+yVdffUVmZu2EoIMHD+aGG25g9uzZVo5MCCGEEKL3qNJXUVFTgXcn5vgDCHEJwWgykV2RxSDX9lW4TCYTb+99HV9HP4JdQiiplsSfEEIIIYQQQoieERISgkKh4OjRtC4/9gMPPMo555zP9u1b+fvvv1ix4l1effVtoqNjqKys4qqr/sfs2fOa7XciiSug0RyBCkXt0KJGo9G8zM7OzrwcoKqqEhsbGz78cCVKpU2jY9UlNhcvXsKkSVPYunUTsbHbWbnyY2666TbOOeeCVs9rMhnpSe7u7pSVtTyHX3uUlpbi7u7edQH1kAE5x5+/vz933XUXP/zwA6tWrWLKlCnceOONJCUlWTs0IYQQQoheo7CqAABvB59O7R/kEgJAZnlGu/fZnLWR3bm7uH7Mzfg6+kmPPyGEEEIIIYQQPcbV1Y1Jk6byww/fUVVV1Wy9pSRSaGg4R44kNdonPn4vSqWSQQ16Hg4ZMoxLLrmC5cs/IiIiknXr1gAwdOhQjh5NJzg4pNk/pbJn0ziDBw/FYDBQXFzcLJa6nnsAfn7+LFlyDs888yIXXLCMX35Z3e5zhIaGs3v37kbL4uP3ER4ebnH75OQktFqteVliYny7riUtLaXdcTWUmZmBTqdlyJBhndrfmgZk4m/evHnMnj2bsLAwwsPDuf3223F0dGTv3r3WDk0IIYQQotc40cSfl70XDioHjpUdbdf21fpqlu99i0n+k5kSMA13Ow+Kq4s6dW4hhBBCCCGEEKIz7rjjHoxGA9dccxn//rueY8eOkpaWynfffc11113R4j6LFp2Cra0tTz/9KCkpR9i9eyevvvoiJ510Kp6eXmRlZbJ8+VskJMSRk5NNbOw2MjKOEhpam+i6/PJrWLPmNz766H1SUpJJS0tl3bq1vP/+Oz156QAMGhTKokWn8NRTj/Lff3+TlZXJ/v0JrFz5MVu2bALg9ddfZvv2rWRlZXLo0EF2795pvpb2WLbsUn788UdWrfqOY8eO8vXXn7Nhwz9ccMGyFrdfuPBkFAoFL7zwFKmpKWzduomvv/68zfNMmjSVhIR4DAZDo+WpqSkkJR2itFRDeXk5SUmHSEo61Gibffv2EBgY1OL8hb3dgBzqsyGDwcCaNWuorKxk7Nix7d5PqVSgVCra3lCY2dgoG/2vEL2Z3K+ir5B7dWAq1ZbyQdx73DD2ZuxVnR/nvy1FukIUCvB19kGl6tw9FuIaQlZFBiqVss379fsDX1GkLeKlCa+iVtvg5eiJRqfBxkbRaNgRIXqCfL+KvkTuV9GXyP0q+hK5X0VfIvdr1wkNHcSnn37JJ598yFtvvUZhYQHu7h4MGzace+55oFH92MZGgUqlxNnZkddff5tXX32Ra665DDs7e+bOncett96JSqXEycmRY8fSeeihe9BoNHh5eXPOOedx9tnnoFQqmT59Oi+//DoffriCL774DJVKRWhoGGecsaTN+njdZ65SKZvEVn9P1C2v+9+6ZXU5jqbneOSRx/j44w94663XyM/Pw93dnZEjY5g5cxYqlRKTycirrz5PXl4eTk5OTJkyjdtuu7NR3b9hPE1jmTdvPg888AAffPAhr776IoGBQTz00KNMmjSpybXV/n1dXZ156aXXeP75Z7jyyosJD4/gxhtv4f777250fU3NmDGDl1+2Yc+eHUyZMs28/O67byUnJ9v831dccTEA27bV90Jcv34tS5Ys7XR7iDUpTKbOTlfZtx06dIgLLrgArVaLo6MjL7/8cofm+DOZTNIAJYQQQgir2JC+gTvW3sG7p73LxKCJ3Xaez/Z9xod7PuS/y//r9DEeWP8ABZUFvL/4/Va3yyzN5NzvzuXimIu5cdKNAKxLWcd96+7jn8v+wcXOpdMxCCGEEEIIIYQQYmD64osv+Pvvv/nwww/bvU9SUhKXXXYZa9euxcWl77VHDNgef+Hh4axevZqysjLWrl3Lvffey+eff05UVFS79i8qqpAefx1kY6PE1dWB0tIqDIaencRTiI6S+1X0FXKvDkyHs5MxGIzsy0gkynFEt50nvSATd7UnxcUVnT6Gj20A247GUlxc0er9+szG53GyceGs8PPN51PVOGAwGEnNySDEddAJXYsQHSXfr6IvkftV9CVyv4q+RO5X0ZfI/Sr6kp68XxctOp3c3AIyMmp7J7ZHSsoxHn74cfR65Qm1iXQ1D4/2xT9gE3+2traEhtZOqhkdHU18fDyfffYZTzzxRLv2NxpNGI0DsrPkCTMYjOj18uMj+ga5X0VfIffqwJJZlo3JBKnFqd36uedV5OFp53VC5wh0DKKoqghNVRluDrVvyTW9X2Ozt7M5YxMPTnkUNXbmdS4qN0wmKKgoJMCx742pL/oH+X4VfYncr6IvkftV9CVyv4q+RO5X0Zf0zP2q5JJLrgRo97nGjZvYoe17m743OGk3MRqN6HQ6a4chhBBCCNGm7IosAFI1Kd16nsKqArwcvE/oGMHOtT31MsqOWdzmm0NfMtIrmtnBcxst97D3AKBYW3xCMQghhBBCCCGEEEIMFAMy8ffyyy+zY8cOMjIyOHToEC+//DKxsbEsXrzY2qEJIYQQQrQptyIbpUJBWmkq3Tldc2FVAd4OPid0jCCX2p56GWVHW1xfpisloWAfC0JPajZ/srPaBZXShuLqohOKQQghhBBCCCGEEGKgGJBDfRYWFnLvvfeSl5eHi4sLQ4cO5cMPP2T69OnWDk0IIYQQolUmk4mcihyivUcRl7+P/Kp8fB19u/w8RpORwuoCvE+wx5+T2gkPew8yyjNaXB+bvQ2jycTkgKnN1ikUCtztPCjRlpxQDEIIIYQQQgghhBADxYBM/D3zzDPWDkEIIYQQolNKdRqq9FVMCZhGXP4+0jSp3ZL402hL0BsNJzzUJ0CIyyCLQ31uzdrCEI+h+Di23LPQ3c5DevwJIYQQQgghhBBCtNOAHOpTCCGEEKKvyqnIAWCUzxgcVA6kapK75TxF1YUAJzzUJ0CwcwjHWhjqs8ZQQ2zONqYGWh51wcPeg+JqmeNPCCGEEEIIIYQQoj0k8SeEEEII0YfkVGQDEOgcSKhrGOmlad1ynvyqAgC87E+8x1+wSwiZ5RnN5iOMK9hLlb6KqYHTLO5bO9SnJP6EEEIIIYQQQggh2kMSf0IIIYQQfUhORTaOakec1S6EuYWTVpraLecpqMxHqVDgae95wscKdgmhWl9NQVV+o+Vbsjbj6+hLhFuUxX097D0olsSfEEIIIYQQQgghRLtI4k8IIYQQog/JqcgmwCkAhUJBmGs46aVpGE3GDh9Hb9TzyOYHSC5JanF9UXUh7nYe2ChtTjRkQlwGAZBRlmFeZjKZ2Ja1mSmB01EoFBb39bD3pESG+hRCCCGEEEIIIYRoF0n8CSGEEEL0ITmV2fg5BgAQ5haOzqAjuzyrw8c5XHyIrVmb+SX5pxbXF1Tld8n8fgD+TgEoFQoyyo6Zl6VojpBXmce0Vub3A3C3c6dKX0W1vrpLYhFCCCGEEEIIIYTozyTxJ4QQQgjRh2SXZ+PvdDzx5xoB0KnhPuPz9wGwMeM/DEZDs/UFVfl4OnidQKT1VEoVAU5BHC09al62NWsLDioHRnmPaXVfj+NDjco8f0IIIYQQQgghhBBtk8SfEEIIIUQfYTQZya3MIeB44s/T3hMXWxfSNB1P/CUUxuPt4E2prpS9+bubrS+qLsSni3r8AYS4hJBRXt/jb2vWZib5T0Fto251Pw87DwCKZbhPIYQQQgghhBBCiDZJ4k8IIYQQoo8orCpEb9Sbe/wpFArC3SI63OPPaDKSWBDPKeGnE+AcyH/H/mm2TX5VQZcN9QkQ5BJMxvEef/mVeRwuPsTUwGlt7uduX5v4kx5/QgghhBBCCCGEEG2TxJ8QQgghRB+RU5kNYE78AYS6hne4x19aaSplujJivEcxO3gumzI3oDfqzet1Bh2lWg2e9l0z1CdAsPMgsiuyqTHUsC1rK0qFgkkBU9rcz83WHQXS408IIYQQQgghhBCiPSTxJ4QQQgjRR+RW1Cb+/Jz8zcvCXMM4VpZOjaGm3ceJz9+HjULJcK+RzAmZS5mujD15u8zri6oLAfB28O6iyGuH+jSajGSVZbE5cxPR3qNxsXVtcz8bpQ2udu7S408IIYQQQgghhBCiHSTxJ4QQQgjRR+RU5OBu546DysG8LMwtHIPJSGZ5RruPk1AQzxDPYdir7IlwiyLIObjRcJ8FVQUAXTrUZ7DLIAAOFhxkT+5upgVOb/e+7nbu0uNPCCGEEEIIIYQQoh0k8SeEEEII0UfkVGQ36u0HEOYaDkCqJqVdxzCZTMQX7CPGexRQO0/grJA5bMnaZO41WFCVD3Rtjz9Pe08cVA58k/gNNUYdUzuQ+POw95Qef0IIIYQQQgghhBDtIIk/IYQQQog+IrsimwCnwEbLXO3c8LT3JL00rZ3HyKKwqpAY79HmZXOC64b73A1AYVUBtja2OKmduyx2hUJBsEsIcblxhLqGEegc1O59Pew8KKou6rJYhBBCCCGEEEIIIforSfwJIYQQQvQRuRXZ+Dfp8Qe1w32mlaa26xjxBXEogJHe0eZl4W6RBLuE8F/G30Bt4s/bwQeFQtElcdcJcQkBYFpQ+3v7Abjbe6DRlnRpLEIIIYQQQgghhBD9kST+hBBCCCH6AL1RT35VHn6OAc3WhblGkKZpZ+Ivfx/hbhG42LqalykUCmYHz2Vz5kZqDDUUVBV06TCfdYJda+f5mxY0o0P7edh5UCw9/oQQQgghhBBCCCHaJIk/IYQQQog+IL8yD6PJRIBzC4k/t3CyyjPQGrRtHie+II5on9HNls8OmUtFTQW78nZSWF2Al33XJ/4mB0xhbthchnuN6NB+HvaelOpK0Rv1XR6TEEIIIYQQQgghRH8iiT8hhBBCiD4guyILAP8We/yFYwKOlqa3eoyi6kKyyjOJ8R7V4jEGuYay4dg/3dbjb7jXCF5c9CJKRcceQd3t3AHQaDVdHpMQQgghhBBCCCFEfyKJPyGEEEKIPiCnIgcF4Ovo12xdqGsYAGmalFaPEZ8fB0CMd/Mef3XDfW7J2kR+ZR5e3ZD46ywPe08ASrQy3KcQQgghhBBCCCFEayTxJ4QQQgjRB+RUZuPt4IPaRt1snaPaEX8nf9JKW5/nL65gH4HOQXg5eLW4flbwHCpqKqgx1vSqxJ+7vQcARTLPnxBCCCGEEEIIIUSrJPEnhBBCCNEH5JRnE+AcaHF9mGs4aZrWE3+JBXEtDvNpPoZbuLn3oLeDT6fi7A4edrWJP422xLqBCCGEEEIIIYQQQvRykvgTQgghhOgDcitz8HP0t7g+zC281R5/5boyUkqSifFpPsxnQ7ND5gJ0yxx/nWVrY4uj2lF6/AkhhBBCCCGEEEK0QWXtAIQQQgghRNuyK7IY7zfR4vpQ1zDyKvOoqKnASe3UbH1CYQImaLXHH8DpEWegQNHiXILW5GHnSUl1sbXDEEIIIYQQQgghhOjVpMefEEIIIUQvpzVoKa4uxt/Jco+/cLcIAIvDfSbk78PT3pMAJ8vDhQJ42HuybMRlKBW96zHR3c6dYq0k/oQQQgghhBBCCCFa07tadIQQQgghRDM5FdkA+DsFWNwmxCUUpUJhcbjP+II4RvmMQaFQdEuM3c3D3pMSSfwJIYQQQgghhBBCtEoSf0IIIYQQvVxORQ4A/q301rO1sSXQOZj00rRm67QGLYeLDxLtHdNdIXY7D3sPimWOPyGEEEIIIYQQQohWSeJPCCGEEKKXy6nIQqW0wdvBu9XtwlzDOVJ8GIPR0Gj5wcL96I0GYnxGd2eY3crdzoMSbYm1wxBCCCGEEEIIIYTo1VTWDkAIIYQQQrQupyIbX0f/NufdG+o5jA/j32fJT6cyzHMEI7xGMtIrhn35u3GxdSHMNbyHIu56HvYelFQXYzQZe938g13NZDLxz7H1jPSKxq+VeR2FEEIIIYQQQgghmpLEnxBCCCFEL5dTkYN/OxJA5w29kGjvUSQWxLO/MJHfUn7hywMrAZgSMLVPJ8zc7TwwmIyU68pwtXOzdjjdauX+T1i5/xOmBk7nienPWDscIYQQQgghhBBC9CGS+BNCCCGE6OWyK7IY5jm8ze2UCiXR3jHmufxMJhNZ5ZkcKEpkmOeI7g6zW3nYewJQrC3u14m/rw9+wcr9nzDKZzTbsjaTU5GNv1OAtcMSQgghhBBCCCFEH9F3X/sWQgghhBggcityOpX8USgUBLkEsyD0JIJdQrohsp7jbucOQEl1sXUD6UY/JH3Hh/Hvs2zEZTw94wWcbV1YfWSVtcMSQgghhBBCCCFEHyKJPyGEEEKIXqxcV0Z5TTl+jgN7rre6Hn9F1UVWjqR7/Jr8M+/ufYvzhl7ApSOuwF5lzynhp7Em9XcqayqtHZ4QQgghhBBCCCH6CEn8CSGEEEL0YrmVOQADfrhHR5UjaqUajbbE2qF0ub/S1vDG7pc5M2opV8dch0KhAOCMqKVU6StZl77WyhEKIYQQQgghhBCir5DEnxBCCCFEL5ZdkQ2Av9PA7vGnUCjwsPegSNu/evxtztzISzuf4+Tw07hhzM3mpB+An6Mf04Nm8eORVRhNRitGKYQQQgghhBBCiL5CEn9CCCGEEL1YTkU2djZ2uNt5WDsUq3O38+hXc/yZTCZWxC1nvN9Ebht/F0pF80fzs6LOJqPsGDtzdnTJOePy93Lxb+fyV9qaLjmeEEIIIYQQQgghehdJ/AkhhBBC9GLZFdn4OwU06gk2UHnae1Ks7T+Jv335e8gsz+CCYRe3mPQDiPYeRaR7FKuPfH/C5/s1+Wfu+e92ymvKWb7vbcp0pSd8TCGEEEIIIYQQQvQukvgTQgghhOjFciuyCRjg8/vVcbNz71c9/n5L+YUQl0HEeI+2uI1CoeCsweewIyeWY2VHO3UevVHPm3te4/XdL3Na5JmsWPQpNcYaPkv8pJORCyGEEEIIIYQQoreSxJ8QQgghRC+WU5GDnyT+APCw96Skn/T4K64uYlPmf5wWsbjN3pxzQ+bjZufO6iM/dPg8ZbpS7t94N78l/8St4+7k5rG34evoy8XDL+Xn5B9I06R29hKEEEIIIYQQQgjRC0niTwghhBCilzIYDWRXZEmPv+M87D0oqi7CZDJZO5QT9mfaGhQoWRh6Upvb2trYcnrEGfyZ9gflNeXtPkd6aRo3rr+WlJIjPD/rFU6PPMO87qzB5+DvFMi7+97sF39PIYQQQgghhBBC1JLEnxBCCCFEL5VccgSdQccwzxHWDqVXcLfzQGfQUaWvsnYoJ8RoMvJb6i/MCp6Nq51bu/Y5PfJMagw61qb+3q7tTSYTT219DLVSzVvz32O079hG621tbLlu9I3szt3F1qzNHb4GIYQQQgghhBBC9E6S+BNCCCGE6KUSCuNQK9UM9hhi7VB6BQ87D4A+P9zn3rzdZJdncVrEGW1vfJy3gzezQ+ay+sgqjCZjm9vvyIklrTSVW8fdQYBzYIvbTAmYxgT/iSzf9xY6g67dsQghhBBCCCGEEKL3ksSfEEIIIUQvlVAQzzDP4dja2Fo7lF7Bw94TgOLq3pH4Sy9No6i6sMP7/ZryM4NcQ4n2HtWh/ZYOPo+cihz+PfZ3m9t+f/hrhngMJcZ7tMVtFAoF14++mbzKXFYd/rZDsQghhBBCCCGEEKJ3ksSfEEIIIUQvZDKZSCiIY6R3jLVD6TXc7dyB3tHjz2gycs9/t3PL+uspqCpo935F1YVsydzIaRGLUSgUHTrnUM9hTAmYyicJH1BjqLG4XXJJEnvydnPOkPPbPMcg11DOjDqbLw+uJL8yv0PxCCGEEEIIIYQQoveRxJ8QQgghRC+UXZFFcXVxh3uF9Weudm4oFYpe0eMvVZNMUXURJdoSHtp0D+U15e3ab23qHygVNiwMPalT570i5hpyKrL5PfUXi9t8d/gbfB19mRU8p13HvGTEZdjZ2PNhwnudikkIIYQQQgghhBC9hyT+hBBCCCF6oYSCOBTASK+R1g6l11AqlLjZuVOsLbJ2KOzIicXOxo5X5rxJTkUOj295uM158owmI7+n/sLskLm42Lp26rwRbpHMD13E5/s/pbKmstn6/Mp8/j26nqWDz8VGadOuYzrbunBl9DWsT/+LFE1yp+ISQgghhBBCCCFE7yCJPyGEEEKIXii+II5wtwicbV2sHUqv4mHnQYm2xNphsDNnB2N8xzLEcyhPTH+GxIJ4XtzxLEaT0eI+u3N3klORw+kRZ57QuS8feRXlNeX8kPRds3U/HVmFncqek8NP69AxF4WdjLeDNz8l/XBCsQkhhBBCdER2eVaLLzMJIYQQovMk8SfEALIi7l2e2faEtcMQQgjRDgkF8YyUYT6bcbf3oLjauj3+KmsqSSyMY4LfJABG+Yzh/skP89+xv1m+721MJlOL+/2W8gthruGMOMFenH5O/pwReRbfHvqKkgbDnlbWVPJrys+cFr4YJ7VTh46pUqpYHLmEdUf/pExXekLxCSGEEEK0R42hhuvWXcU1f17Gntxd1g5HCCGE6Dck8SfEALIzJ5Z/jq0nVZNi7VCEEEK0oqS6mIyyY0R7x1g7lF7Hw96zUbLLGvbl70FvNDDBf5J52czg2dw87nZ+TPqebw99RXlNObmVuaRokokviGNjxn9sydrI6ZFnoFAoTjiGi4YvQ6FQ8NXBL8zL1qT9RrW+iiWDz+nUMU8NPx2TycTvKb+ecHxCCCGEEG05XHyIyppKHFVO3LPhDt7a8zrV+mprhyWEEEL0eSprByCE6Bl6o56jZekArDr8LXdNvM/KEQkhhLAksTABgGjp8deMu507h4oOWjWGnbk78HfyJ8g5uNHyxZFLKKwq5IP49/gg/r1m+7nYujB/0MIuicHNzp3zhlzI5wc+5azBZ+Pj4MuPSd8zJ2Qevo6+nTqmu70Hc0Lm8XPyj5wz5Px2zxEohBBCCNEZ8QX7sFfZ886CFfyW8jMr4pezMyeWuyfez0jvaGuHJ4QQQvRZkvgTYoDIKDuG3mhgSuA01h/9k8ujr8bbwdvaYQkhhGhBQkEcvo6+nU7g9Gcedtbv8bcjZzsT/Se32HPvspFXMsxzONWGapzUTjiqnHBSO+GkdsbNzg1bG9sui2PpkHNZfWQVnyR+yJSAaeRU5PDo1KdO6JhLos7mr/S1bM3ezIygWV0UqRBCCCFEc/H5+xjpFY3aRs2SwWczwX8SL+x4hjv+vYnzhl7IldH/65KREoQQQoiBRob6FGKASNEkA3DTmFuxtbHjpyOrrByREEIISxIK4mWYTws87D0orylHZ9BZ5fyZZRlkl2eZ5/drSqFQMCVwGnNC5jHRfzIjvaMJcwvHx9GnS5N+AA4qBy4deQV/p//FR/HvM9pnLFEeg0/omEM8hzLCaySrk37ooiiFEEIIIZozmowkFMYzymeMeVmwSwivzX2bS0dcydcHvyS+YJ/1AhRCCCH6MEn8CTFApGpS8Hbwxs/Jn9PCF/Nr8s9U1lRaOywhhBBNVOurSSo+JMN8WuBu5wmARquxyvl35sZio1Ay2nesVc7f1CnhpxPgHER2RTbnDr2gS465JOps9uXvMb80JIQQQgjR1VJKkqmsqWz2sptSoeTC4ctwVDuSUBBvpeiEEEKIvk0Sf0IMEGmaFMLdIgBYMvgcqvSV/JH6q5WjEkKIviWj7Bj7CxO79RyHig5gMBkl8WdBoHMgALvzdrZr+xVx7/LTka7rvbYzdwcjvWNwUjt12TFPhEqp4rZxd3Jy+KlM9G+5F2JHzQyejZeDFz9Jrz8hhBBCdJO4gr2olCqGeY5otk6pUDLCaySJkvgTQgghOkUSf0IMEKkNEn++jr7MGTSfH5K+w2A0WDkyIYToO748sJIntz6CyWRq1/ZGk7HD50goiMdZ7Uyoa1iH9x0Igl1CmBU8h48TVrTZc31v3m6+PfQ1Pya1b3hrk8lETkW2xfU1hhr25u22OMyntYz1G8+dE+5FqeiaR3uVUsXiiCWsO/onZbrSLjmmEEIIIURD8flxDPccYXEo9JFeMewvTOzU87QQQggx0EniT4gBoKKmgtzKXHPiD+DcIeeTV5nHfxn/WDEyIYToW0q0xRRUFZDajiEQs8uzOHP1KSQVH+7QOeIL9jHSO7rLkjj90TWjrqNUW8q3h76yuI3eqOetPa/jrHYmszyj1YRena1Zm7nk9wvYkbO9xfWJhfFU66uZ6D+507H3FadGnI7RZOT3FBkdQAghhBBdy2QyEV8QR7SP5REuor1jKK8p52hpeg9GJoQQQvQP0qIkxACQpkkFaJT4i3QfzDi/8Xx36Ot291wRQoiBrm5eue3Z29rcdkPGv1Trq9mY+V+7j28wGthfmCjDfLbB3ymAs4ecx7eHviK3MrfFbVYfWcWxsnQem/YUSoWCnTk72jzu5qyNALyy84UWe7rtzInF3c6dCPfIE7uAPsDD3pM5IfP4JXm1vGkvhBBCiC51rOwoGm0Jo7xHW9xmqOdwlAqFzPMnhBBCdIIk/oQYAFI1KSgVCkJcQhstP2/ohRwpSWJf/h4rRSaEEH1LXTIoNqftxN+WrE2127YjSVgnVZNClb6Kkd4xnQtwALlw2DKc1E58FP9es3UFVQV8lvgxp0cuYbTvWIZ5jmBXbuuJP6PJyPbsbcwPXUiVvoq3977RbJudubGM9584YHpjnhV1DrmVuWzN2mztUIQQQgjRj8Tl70OpUDDCK9riNg4qB6Lch5BQGNeDkQkhhBD9w8BotRBigEvRJBPiEtps7PxxvhOIcItodai0hjTaErZnb2N37s7uCFMIIXo9jU5DkHMw+wsTWp37rLCqkAOFiYz1HUdyyRGKqgvbdfyEgjhUShVDPYZ1Vcj9lqPakStj/sffR9ezvzCx0boVce9ga2PH5SOvBGC830T25u1udV7bg0UH0GhLOD3iTG4aeyvr0/9iY0Z9b82i6kKSS5KZ2Mvm9+tOQzyHMsJrJN8c+hK9UW/tcIQQQgjRTyQU7CPKfQiOasdWtxvpHcP+goQeikoIIYToPyTxJ0QfZjQZ+fbQV1TUVLS6XZompdEwn3UUCgXnDr2AHTmxrE5axT9H17M1azO7cncQXxBHfP4+fkj6jme2PcGlf1zIOT+fyUOb7uXeDXfyzcEvu+uyhBCiV6ox1FBZU8nC0JMwmkytDh25NWszCoWCm8behgLYkRPbrnMkFMQz1GNYsxc1RMtOCjuFSPdI3t37pnnY6rj8vfx9dD1Xx1yLi60rUJv4K68p51DxQYvH2pa9BRdbF0Z4jWT+oEVMC5zB67tfobi6CIBdxz/vcX4TuvmqeperYv5HUvEhXtr5nAz5KYQQQoh2qdZXW1xnMpnYl7+XUT6Wh/msM9IrmuyK7Ha/RCeEEEKIWpL4E6ILVdRUoDVoe+x8CQVxrIhbzj9H11vcxmQykWoh8QcwJ2Q+gz2G8PbeN3hm+xM8svkB7ttwF3f8czN3/HsLH8S9R05lNlMCpnH/5If57JSvuGj4JXwQ/x4r938i8wMKIQaM0uM9/CLdo4hwi2B7zlaL227J2ki092gGuYYy2GMoO9uR+DOZTCQUxhEtw3y2m1Kh5PrRN3Ow6AD/HFuH3qjnzd2vMdxrBIvCTjZvN8xzOM5q51Y/h9jsrUwKmIJSoUShUHDb+DsBeG3Xy5hMJnbmxhLlPhgPe89uv67eZJTPGO6d9BB/p//Fe/vekd99IYQQQrTq+8PfcMGvS8mvzG9xfW5lDgVVBYzyGdPmseqGv0+UXn9CCCFEh6isHYAQ/cmjmx8kwDmAOyfc2yPn25tXOzff9pytnB55RovbFFQVUF5TbjHxp1KqeGfBCvRGPVqDFp1Bi86gQ2vQYjQZCXIORm2jbrTPFdFXY6u05ZPED6kx1nDFyKtRKBRde3FCCNHLlOo0ALjauTEpYCq/p/6K0WRsNt9bRU0Fe/J2cc2o6wGYFDCFn478gMFowEZpY/H4uZU5FFYVEt2Ot59FvdG+Y5kRNKv2RZWKHNJLU3l7wYpGn4uN0oYxvuPYlbuDS0de0ewYuZW5JJckc/7Qi83LPOw9uXXcHTyx9RH+Sl/DztydnBaxuEeuqbeZEzKPMl0pb+x+FXc7dy4cvszaIQkhhBCiF9JoS1i5/xMqaypZuf9j7phwT7Nt4vP3AbTrZTdvB2/8nfxJKIhnZvDsLo9XCCGE6K+kx58QXcRoMnKwaD87c2J77G34ffl7UCoU7M3bjc6ga3GbVE0KgMXEXx2VUoWT2gkPe0/8nPwZ5BpKmFt4s6RfnYtHXMo1o67jqwOf817c29IDQAjR75VqaxN/brZuTA6YSqlWw8GiA822i83eht5oYHrgTAAm+k+mTFfW4rYNJRTEATDSa2QXR97/XTPqOoq1xXyc8AGnR57JYI8hzbYZ7zeRg0X7KdeVNVsXm70VG4WSif6N5++bGTyb+aELeXXXS5RqNUzwm9ht19DbLY5cwiUjLuejhBX8nvKrtcMRQgghRC/05YHPMZlMXDh8GWvTfidNk9psm7iCfYS7hZuHZG/LSK9oEgvjuzpUIYQQol+TxJ8QXSSrPBOtQUtBVQHZFVndfr5qfTX7CxNYFHYK1fpqc4NxU6maZBxUDvg5+nd5DOcNvZCbxt7KqsPf8eae12TuHyF6kY0Z/7F831vWDqNf0Zh7/Lky3HMELrYuxGZva7bdlqxNRLpH4edU+707zHM4rrauxOY037ahffl7CXNtfyOIqBfoHMT5Qy/Cy8GLK6KvbnGbCf4TMZpM7Mnb3WzdtqwtRHuPxtnWpdm6G8fcgrudOw4qB0Z4RXd57H3JJSMuZ3HkEl7f/RIbM/6zdjhCCCGE6EWyy7P4OfkHLhh2McuGX4avox8fJrzfbLv4/Diivds/wsVI7xiOFB9udd5AIYQQQjQmiT8hukiKJtn8/+OOD13RnfYXJqA3Glg6+Fw87T3ZkbO9xe1SNcmEu0V021CcZ0Yt5dZxd/Jr8mpW7v+kW84hhOi4v4+u48ek7ymuLrJ2KP1GqbYUpUKBk9oZG6UNE/wmsT278Tx/OoOO7dlbmR4007xMqVAy3m+ixe9pqB0W6d9jfzMtaEa3xd/fXR59FZ+d8rXFxKm/UwBBzsHsyt3RaHmVvoo9ebuZEji1xf1cbF15fNoz3DnhXlTKgT1KvkKh4KaxtzIreC7PbH+CuPy91g5JCCGEEL3Exwkf4GbnztLB52JrY8sV0VezLWsL8Q1eUi6qLiSzPIMY71HtPu5Ir2gMJiOH2hg9QwghhBD1JPEnRBdJLjmCh70Hke5R7M1v3pugq+3J2427nTthruFM9J/MjpzYFrdL1aS0OczniTo98gwWR53Fr8k/Sa8/IXqJ9NI0jCYTW7O2WDuUfqNUp8HV1s08d9ykgMkcKUmisKrQvM3evD1U6auYHtg4gTfRfxJJxYctJmJXJX0HwNLB53RT9AODrY1tq+vH+09kV+6ORsNT783bTY2xhikB0yzuN8RzKLND5nZZnH2ZUqHknokPMMRjKO/sfUOG+hZCCCEEh4oO8s+x9Vw28irsVfYAzAmZT5T7YFbEvWt+XojPr00CxnRgTuswtwic1E4kFiZ0feBCCCFEPzUgE3/vvfceZ599NmPHjmXq1KnccMMNpKSkWDss0celaJKJdI9itM9Y4vP3dboh7Mek73ku9qk2t9uXv4cxvuNQKBRM9J9MemkauRU5jbbRG/UcLUvv9sQfwIJBiyjRlrAvb0+XH/tY2VHKdKVdflwh+iudQUdm+TEUwObMDdYOp9/QaDW42rmZ/3ui/2QU0Kgn35asjfg7+RPuFtlo3wnH547b2cJLGuW6Mn468gOLI87Ezc69W2IXtSb6TSKnIofM8gzzsm1ZWwhyDibYJcSKkfUtahs1V0ZfQ3JJMrGt9GQVQgghRP9nMplYEbecUNcwFoWebF6uVCi5ZtR1HCjcz6bjdZK4gn0EOgfh7eDd7uMrFUpGeI20OL2JEEIIIZobkOMVxcbGcvHFFxMTE4PBYOCVV17hqquu4rfffsPR0bFdxyg+UvvGvoO3I/bu9ubllfmVaDXVKFVK3MLczcsNNQZK02vnBnLyd8bWuf6N9PLsMmoqalA5qHEJqp9bRl9VQ1lmGQAuwa6o7Os/rrJjpei1emxdbHHyczYv15VpqcitAMAtzB2lqj63q0kpxmg0Ye/hgIOXg3l5dXEVVYVVKJQK3CM8zMtNJhMlycUAOPo6YedqV3+deRVoS7XYqG1wDa1vBDXoDJQerb1O5wAX1E7q+uvMKsOQV0VljR4HPyfz8pqKGsqza6/TNcQVG7v66yw9qsGgM2DnYodjg320pVoq82qv0z3CA4WyfhjLkpRiTEYTDp4O2HvWX2dVYRXVxVUolQrcGlyn0WBEk1rS4nVW5JajK9NhY2uD66AG16nVU3qsNhHlHOiC2lFNakkys0PmMrhmCH+m/kFaSgrhkfUNvzXlOspzymuvc5AbNrY29Z9NWglGvRE7N3t+Sf6JY2VHuXzkVXjoPajMr6y9zkgP83CdFTUVZBw4ytzh86kurmK83wSUCgWxOdtZ4LaQ6pJqlDZKij2L0RsNhLtFYNQb0aTVXmfTe7DuOlX2KlyC64dI01frKcuovU6XIBdUDvWfZ1lGKfpqPbbOtjj5OzPMczj+Tv78d/gfwsrCgRbuwePXae9uj4N3fVmruwcBPKI8zctNJhP/bl3P23teZ+qIGdw5917zuvaUNWd/Z9TtKGs1lTWUZ7Vc1kqPatBW1rRe1sLdUdq0o6wVVVFV1EJZM5ooSWmjrDW9B9soazWVNagd1TgHNrjOhmWtyT1oLmuudjj6dn9Zc/Jzwtal7bLW8B6sK2t1yjLL0FfVoHZS4xzQ4DoblrVQN2zULZc1R58G92BJNVUFzcsaNPi+93LA3qPBdRZU1pa1Jvdgq2UtpxxdeQtlrbXv+7qy1vQeLNdRkVOOykaJ27j6uAAOJx7EMceJ8VET2Zy3kfKacpzVzvXf9woF7pEWvu99HLFza8fvWsN7sBNlzdL3fdPrbHgPdmtZy61AW9ZCWWvwfa8pLcHNtn6dTaENo7Sj2ZGwjZPDT8VoMrIlaxNzfeab/551Zc3D3pPBHkPYuTeWCfpJjcra6iM/YCo3sUh1MsVHiprdg+ay1vQetFTWGt6DFsqayk6FS0g7v+8tlLW6exA6VtYK8qoo1VThEu5OQ5bKWmeerSyVtRHO0bjlubItdgtLpp+NjZ0N27K3MHfQfMvPVg2us9nvWmoJRoPl37XOlLVWn63aW9ZO8NmqaVmruwcblrVRPmOIVkez6u9vGDp1aJeWtaa/axa/71v7XUvXYKhp4XdNU93isxVASXIxJlNLZa2S8vxKlDZK3Brct91V1uqerep0qqxZeLaCrq3HmMtab67HNC1rnanHHC9rrT5b9UA9pul1Nny2cg10AY/687SrrHXm2aqVekzDe7BTZa3u2aq1stYN9Zg6rX7fd7CsNbwHO1PWuqIe06VlzdKzVXvaDFqox5SllmBwq8LoZIOiQbk5oXpMD7UZ9Fg9pp1lrbV6TJtlrSvqMdV6tuzZSHJCEnefdj82yvqYyzJKCa+OYJJ6Eh/Gv8/UwOkk5O8jxnGU+beovW0Gw9UjWbP3N4oCCvGM8jIv71RZ62Q9pjipCL3B2GKbQUv1mB5rM7D0fW+NNgNL9Zj2lrUTfLbqbW0Glu7B7mwzcAuq36en6zE91WZwovUY6L42A4tlrbvrMb2kzaCj9RilCWzDgPpDNSprFusxXdlm0N31mLqyZqke05GydvzZysenPt7WDMjE34cfftjov5977jmmTp1KYmIiEydObNcxtj62ARQQfdloIk6uT+4c/SuFlD+O4OjtyII369900pVUs/Xx2jecJt4xhYCJgeZ1Sd8fJDs2E6/h3kx/ZJZ5uSazzLzPrGfm4d6g8hO/Yg8lqcUEzxjEuBsnmJfnJOaz++2dAJz03mmNbs6dL29DW6pl8JKhDD9/pHl59uYMDnyTiI2tDad9eqZ5uUFnMJ9/1FVjCVsQbl6X9scR0tal4hLowtyXF5qXV+dVmPeZcu80fMf4m9ft/yKBovh8PEZ4Mfm+6eblxUc1bH1mEwBzX1zQ6Idt37u7KMsoJXRuGKP/N868PGtfLnvfrx1O89SPz0DV4Asy9tnN6Kv1DDt3BEOWDjMvz9yQzuEfDmLrbMvJK043L6/R6s0xj71+AiGzBpnXpfycxLEN6biFujP7uXnm5ZVZVeZ9pj08E7soe/KqconyHIzqEwUxf48kNm8Lg58ZbN6nMKWY7S/WzgU1/7WTsGvwI7X3rZ1U5JbjPtuDDPejKBTwT8Y6ZmTOIP7j2vkCT/98ifnH60BePCNWj8C0SU/uZVlEnj6YaJ9R7MzdztBdgznyy2HsPexR3WuHQgFRnlEYq+qvc8KtkwicEmw+/5FVB8ncmoFHlCczn5xjXl6WU27eZ+YTc/AYXP+Fm/jxPooOFxI4JYgJt04GYM6guWxZu4kte/5DoVCw6J1TsG3wRbz71e1UFVURedpgRi6LMS/P3Z5F4hfxKJQKFn9xlnn5hqP/8s/DfxGtiOZYaRqqhfVfnEfXJpOyNhknXyfmv36SebmuuP6zmXTnVPwnBJjXJX17gOydWXiP8GHaw/Xzb2kyStn65EYAZj87D/swd2yO/633vbeb4pRiQmYOYuwN9WUtOyGfPe/UlrWT3z8dlUt9Wdvx4lZ05TqGnDWMYeeNMC/P2nyMg9/uR2Wn4tRPzjAv1ze4B0dfM47QeWHmdam/HyF9fSouQS7Mfam+rFXlNihr90/Hd5Sfed3BLxPI25eL72g/pjQoa0XpJWx7djMAc19a2OiHbd87OynLLCN0fjijrx5rXp65N5d9K46XtU/OQKVqUNae2Yxeq2fYeSMYclaDsvZfOod/bF7WdA3uwbE3TCBkZoOy9tNhjm08inuYO7OerS9rFQWV5n2mPzwTrxE+5nUHPoujYH8+ARMCmXjnFPPygiPFxL5cW9YWvHESdj4NytqbO6jIqyDipEiiL68fXiZ/Vzbxn9SWtcVfntXoAWrbkxsxGU2MvDiGyNPry/TRdakk/5aEg6cDC98+xby8ukzboKxNJnBKkHld0qoDZG3LxHOIFzMen21eXpZT/3nOfHJOo4ebhA/3UnykiKCpwYy/ZZJ5ed7BAna+HotCoSDgy7PN9yxA3Gu7iUkbyZxLZ7PB+R925cUyP3SBuawpVUpOX7nEvL3RYDSfP+aK0YQvqv9dS1+bTOraZJz8nJn/2iLzcm1hfVmbfPdU/MbVl7XD3+wnZ1c23iN9mPZQfVkraVDW5jw/v9HDcvz7e9CklxAyK5Sx1483L89OyGfPu7Vl7ZQPTkdl10JZWzqMYec2KGubjnHwu/2o7FWc+nGDslZdfw+O+d84Bs0NM69L/S2J9H/ScAl2Ze6LC8zLq3Lqf7+rT6rEPcod1fGHuIOfxzN0yxAOeO3HdIaBIyWHKNEWM043zrzPvJcXYne8Mj0lcAoHH01kq/0GwhaEM+qqsVTWVPLjke84ufpk9j9X+xbzaZ+eiY26/vPc/vQmDDoDw88fyeAlQ83LM/5NI2n1Iexc7TjpvdPqP5vKGvP5x904geAZ9WUtefVhMjYdxT3cg1nP1A9dWZ7foKw9OguvYfVvYe//dB+FBwoImBTExNsnm5fnJxWx45VtACx482TsvOuf1ve8HktlQSURp0QRfWn9HC4ZsVkc/DyBGr2BxV/Wf98DbHtiIyaTiZGXjCLy1Cjz8mPrWy5rNZoGz1a3TSZgcoOy9v0BsrY3L2vkG5j862SO/ZZKdVQFeR55FGuLmB48g4Q391CcXEzwtBDG3Vz/PJi7P59db9bOC9j02WrXK9uoLqlm8BlDGH5htHl5ztZM9n+VgI3ahtM+q3+2Murry9qoK8cQtrC+R376miOk/pmCs78z815tUNYafA82LWuHvkokd08OPtG+TH2wfnjZkoxStj51vKy9MB/XkPqyFvfebkqPahg0J4wx19Y/W2XH57Fn+S4ATvlwMSq7+ntwx/NbqKmsYeg5wxl69nDz8pNKTmLLZ5tY99cfXPD5MvNyfVX9PTjm2vEMmhNqXpfyaxJH/03DdZAbc56fb15emV3/nTL1wRn4RPua1x38PJ78hDz8xvoz+Z76IVkLU4rZ/kLtcMbzX12EXYNK5t63d1KeXUbYwghGXTnGvDxjdw5xH+0F4PSVSxpVyrY/vQlDjYHhF4xk8JlDzd+rR9encejHg9i52XPS8lPN2zcsa+NvnkjQtPpeo8k/HiJj8zHcIzyY9XSDstbg93vGY7PxHFrfeLn/470UHipsXtYOFbLjtdqelQvfOhk7rwZl7bVYKgsriTx1MCMvafBstSObxJVxKBSKZmWt7vzRl44i4pT6smapHtOorN0+hYBJ9fWYw98dqK3HDPNm+qMW6jFPz23UoBL/wR5KUooJnh7CuJvqy1rO/gJ2v9VyWbNYj9mSwYGvE5uVNUNNK/WYNcmk/ZWCc4AL815pUI9p8D3YtB5jqay1Vo+JW76L0mOlzcpaa/WYHc9toaaqhmHnjGDI2fXPVlkbj3Jo1QFsnWw5+YOW6zHjb5iIf6in+b5N+eUwR/9Lxy3UjdnPNShrDesxD83Ee2T9s1VdWfMfF8Cku+vnPW1Uj2la1o7XY8IXRRBzxRjz8kZlrUE9BmDbUxsx6o2MuCiaqMVD6vf5J42kn2vrMYveaVDWKnT113nLJIKmtl2PaVTWHp+N55D6stZSPQYg72AhO18/XtbePgVbz3bUY2KzSPy8eT3GZDLVl7WmbQZ/ppCy5giOPk4seKOd9ZjvDpC9I6vlNoMnavepq8fUsdRm0Kwe07CsvbQNbVnzsmapHtOwzWD01WMJnV9f1izVY6rzKtj06H+oVTZMuHsK3jENvu/r6jGj/JhyfwfbDOaFMfqa+rLWqB7TtM2grh7TzjYDXXUr9RgLbQYVha3UY1bGUZCYj//4ACbdVV/WCpKLiX3peD3m9ZOw823eZtBqPeaLsxolOLc9uRGjwdisHnNsfSpHfm2rHtOkzeCH2rLmOdiTGU/MMS/XZJWy+bH/mKacSvSpI83PyQCJH+2lKKmIeaPn80LYc6w68g1ppamcbruYrR/UnsdSm0HU6YMZcXF9WQtOCyLy23D+2fgn539zsXm5yVhf1mIuH034SQ3KWl2bQZN6jK6oQVm7ayr+41uvx9jYKClOKWbTo/9hMpmY/dw87EPdzfu0Wo+pK2srOliPadpmUN1am0ES6X+3VI+pb8+Z+sAMfBqWtS8SyItroc0grYRtz9W2GTSsx0ArbQZ7ctj3Qe3IT03rMZbaDDL+TWP1ilX4+fhx5VfX1n82rbQZWKrHNGozeGQWXsNbqMdMDGTiHe1rM9jzxg4q8yuIODmK6Mvq6zF5O7NJ+LSNNoNlMUSe1ristVSPqSrteJtBaXb95znrqbmNEgUN2wwm3V57nTY2SooPFLDrjdoRZ05afioq+/oEwq5Xt1Fd3EI9Zlsm+79MaLXNwFI9plmbQSv1mMNf7ydnd3bzesyxBvWYZm0Gu9Gkaxg0O5Qx1zUoaw3rMU3aDHa+sBVdhY6hZw9n6Dn19Zisjcc4+P1+1A5qTvlosXl5a20G5npMiCtzXmi5zaBpWTuwsuV6TFFqMduer63HzHtlEXYB7ajH7Mkl7sPjZe2zM7FpWI95qnE9xrxPe9oMbppI8PR21GMatPk3azP4ZB+FB1toMzhcxI5Xa9sMmtVjXo+lqrCK6LNHEHVe/WeTtyOLhM9q20bO+GopDVlsM1iXSvLvSTh6ObLgLQv1mCZtBuZ6zFAvpj/WoKxlWS5rluoxuQcKLLYZ7Hx5G1pNNYPPHMrwC9qux7TWZlBXjxmy5hLaY0Am/poqK6vN4rq5ubWxZT21rQ0KFDg72+HR4M1KJyc7bNUqbO1UjZbb6sFWXfvndnV1aLTOwUGNrVqFvb260XK9W6V5Hze3xvvY2auwVatwdLRttFzj4mDex8Oj8ZsJtrYqTGoDTk5NYnaujdnG1qbRcoPOYD6Wi4t9o3WOji1fp01lg32aXKfd8S9eO7vG16l1rY/Zzd0Rtyb7aNUqHJpcZ5GLfaPrbFigbG1VKA2119XiZ2PbOGadrbqV67TFVq3Czr7xPgpNTaPPM9OYiY2NkvGho0hzTsPZzpkCXV6jfSobXKe7uyPOTa6zRq0iozIdB197Zgyawb+Z6zjJaX6j66yrMB86lIi9yg4XByfzdc6NnMVHez/CzuGy2pht1WTVZBDg6k+ofwBVxVUNrrPJPXj8Opveg0a36vrrbHIP2tvX/t0cHOo/m7NizmD9H39SYSjD08ETd3cnHBo8xNvaqjCoVRbvQYVSYV6+PmU9T29/nJOdTsbLwYu1urUY7arxcqyttDtaKms1NLgHG3+e9hbKWo1bRYOy5tj4eLa1Za3pPVjS4B5093DEzqVxWUNtbHadzs61+6ia3IN6rb7te7BJubGpMLTynWLb7LMBqG5yD7o2ugfVaFv4TmlW1uyalDVj7XW1p6xpVSqL1+lgLmuNr5NiXYN70LHFe9DeofE+Fa4NPht3J5wafp7Hy5pjk88m37nxdTZ8iLdVqzAZTe3+TqkyKS3eg3WfTdN70OBWZfEeNJe1Jp9NWYPve6i9D+pUGyuxVdkS7jOIGLdoduRv4ZwxZ5rLmlKlbFzWDUbzsZp+nvX3YOPrVGtNFr/vLV2nzrW80XW6t+N3rXFZc8LWqf4NLUtlre46m5W16vqy5mzpHmxyncry+n20pirC3cLN6+0dbPFx9ibBZOCo7gi7irbj5eTJ2NAYNqhrH9TcGpS1hcPmkWDaR7WxEkfH2ph/2bcKnUnLacNPIWlLElB7DzZ848/WVoXBpGj3Pai1aVjWHFr+PJv8rpmKtG3fg83KWuPvlKZlTd/C932eY+3np1Y1fuYAUKttwITFZ6um34N2BkWH70G9WyVejp4cKz2Go7OafSU7cXVwYdaQqay3X99iWSt1aXyd9g3euLO1VWFs4TvFXNbUTcqavrWy1vLvmqra2LVlza7lslbc5Pu+4dvStrYqFDWmZp/n6OAY9tnu4Vh5euPfVfuaBvdg+75TFKWNn61a+v1u+rtW1eQZ0qXJdepauM6CJtfZMPFna6vCgKLZZ1P3d7ZrUtaqlTZd+mxlZ6GslTcqa044etS/lV1X1hydGl+n8/F7EAXNypqle9BSPaZxWWv6t2lPPaZ9v2uaJp9Ne+oxdc9WzeoxNa3VY1q+B1VV7ShrDq3UY9ya1mPULZa1tuoxCn37nzka1mMcj/8+1j0POFh4hmxaj2nPs1VlG2WtRq0y/67VKWjybNUw8WerVmFUGJt/D9Z939s2Pn+1wsbi59mesmb5d63Js1WjZ0jHRmXNzk6NQV1j8R5sWI+B2sRffVmza3KdLd+DrdVjLH3ft1aPad+zVfN6TGtlremzVcM2g6bPVhbrMZUG1MdfJrT0fdtqWbPQZtD0HmyzzcDYgTYDdcfbDChpux7T9B5sWtZaajNosx7TIPGnVttgUiqbXadje+oxTX/XHFqur/1V9BtV+krG+o/Fzb3pPVh7nSFegZw+7DQ+2/8RShsFY0JiOKQ+BGCxzaDpdQ71j+Rf5TqqDBWNy5qxYVmz8J3StB6jq9/HUl26aVmrpsx833amrHl4ODXqaXIi9RhL7XOt1WPa+2xV3eQebE+bQWGT62xaj7HUZlBpqKDaVNW4rLfSZmCxrDVqM2i73QpabzOwa+vZCsttBpaerZrVY4ytPVu13WZg8Todbc3PAa6uDri4NL7Ohj1i7WzVGNX6ZmWt7vu+Y20GLd+DrdVjLLXPtV6PafkZsritNgOd5bKm7kCbgaXfNWVZx8taVZO6dHvqMc3KmrpJm0EL9Zj2tRm079nK5NbxNoPyJmWtWT3m+Pdqw/Ys5ya/aw1ZajOoe7ZqvR7Tcj6m6e9aw3pMa2Wt4fLW2gzsbFWY1M3bRizVYxq1GVi4B9tLYersRGT9hNFo5Prrr6e0tJSvvvqq3fsd2XYUpVKBg0/ToQQq0JZoUapb6Fqa1qBrqUuD7s1Zdd2bW+jGnXG8a2lIk6EEjmkwVB8fSsC/yZBoDYcSaNCYUZJSjMlgwt7THgevJt24C453b27atfTI8a6lfi0M26HRorRV4tbgTSeDrsHwJIHOqBt82VblVmCrUKI1GnH0b1BZqdBRnlVee52DXBslFkqPajBoDdi62uHUtBt3boOhBBoO25F8vBu3lwMOjYYSqKS6qBqFTQtD5KSUtHidFTnHh+2wazJsh1ZP2dHj3biDXPg142fe3fs2v5/zJ1VZlXy86yN2lezg08u+MO+jK9dRkV17na6hLQzbUWPkyfjHcPB2ZOmQc7j739t5dfKbDNLXvuHkHlXfjft/a68koiySa0dfj4N3bffmI8VJ/G/tlTwz6nmGqoehUCl54dizGE0Gnpv9Um037rrhSZrcg3XX2ewerNZTdry7uktwC0PkVOlRO9vifPzNFJPJxBWrljFCMZJrRl3X7B6su047D3scmw4lUHB8iJzBnvydvp5ntj3BnOC5XOd9I6U6Ddfv+B/3L3iYOYNq3zZpV1kLaDKsroWyVlNZQ3lm47JmY6PE1dWBY/E51FTVtF7WIloYSqCFslZVVEV1YQtlzdigG7eFstb0HmytrJVllqGvrEHl2HTot/qy1vQerCtrdm4tDNthzbLW4B50DmoybEfdPejUeHiSRmUtrIVhO2qM2Lnb4djgrb7qkmqq6oZMiGoybEdS3ZBoTYYSKKhEW1zd7B5srayVZ5dTU95CWWvl+77uOpveg7qy2iETlDYKBo0OpLxSi8FgBOCx7x6mWlvFIyc/weq8H1iZ+Cmrz/oVU5mxtqwpWhiOqu773rfpsB0WylqDe7BTZc3S972VylpFbgW60uZlreH3/c37bmD24DlcM/q62s8ms4yaCh03bb6emWNmszVrE9Heo7g9+s4Wy5rRZOTC989hUfDJXDjxYpSeNlz0y3nMCJ7JjUNvqS9rUS0M02Q0NbsHLZa1BvegxbJmb9OoF1i7vu+blrWyBsN2tLOs1ZTqUFYbKC+vbjTUCLRS1jrzbNVKWYtL3Mdjmx/m8aVP8f6B5QQ4BfLI9MctPls1vM5mz1apJZj0rfyudaastfJs1e6ydoLPVs3KWt33fdOyVljJ+vh1vBf3Dq9d+haR7lG113mCZa3Z75qFe7C13zVNeglGnbH575qmmso8C9/3R4rAVH8P1j0L5KYWUpFfiUKlbDQCR7eVtQbPVtC5stb02aohc1nrinpMJ37Xerwe07SsdaIeYy5rrTxb9Ug9psl1Nny2cglwwSfEndLSKgwGY/vKWmeerSzUY5regx0pa+bP5vizVWtlrbvqMdD6931Hy1rDe7BTZe0E6jF1urKsWXy2akebQUv1mPKMUpyd7VG4qlE2fO49gXpMr2szONF6TDvLWqv1mDbK2onWY3QGHZf8eCExhhhuHHeLxXqM2tmWMpcyLvv9Ytzt3Fk59yuL92BrbQb3/nQn/s6B3H/OQ+blnSprHXy2srFR4qBSkXkgF6PB1Lys9dJ6jFXaDCzUY5qWtZLcYi79+iJmDprF3Wfdb15+os9Wva7NwMI92J1tBq5Brri6OlBaWkVVSXXP1mN6qs2gK+ox3dRmYKmsdXc9pte0GXSwHoPRhE+IBwZ7pbk9q2FZs1iP6eY2gy6txxwva5bqMR0qa8efrSIm1ffQbM2AT/w9+uijbNy4kS+//BJ/f/+2dzguP7+sG6Pqn1TH3xYpLq5ArzdaO5wu9crOFzhcfJDlCz8CYFPmBh7f8jCfn/oNfk7tu6802hLO+2UJt467i5PDT+Wi385hetAsbh57W6PtynSlnP3TYu6aeB+LwuqHCjCZTFzw61LmDVrAtaNvBGDZb+cxO2Qu14y6vmsutB0+TviAn478wLeLV2NrY9v2Dk38ffQvno99mrmDFnDPxAdQKmq/LC/9/QImB0zjxrG3dHXILerP96voX1q6Vy//42ImBUzhhjE3k1F2jCvWLOPxaU8zLWhGG0cTrTnjx5O5ZMTlnDv0gkbLX9rxHFuyNlGmK+OJ6c8wNXC6xWM8ve1xssozeXvB+6w6/C3vx73Dp6d8hb9TgMV9+pPe8N1qNBk595clTA2Yxtq0P7h30gMsCD2p7R1Fi/RGPZf/cREjvKJ5YMoj1g6nS/WG+1WI9pL7VfQlcr/2D3H5e7nz31t5Z8EKBnsMaXP7H5O+x2gycvaQ8zp1vnf2vsm2rM18durXndq/s+R+7Xq5FTks+/18ZgTN4tFpT1o7nH5F7lfRl8j92jntneNP2fYm/dcTTzzBv//+y6efftqhpJ8QTSWXHCHCLcr83zHeteOAx+XvbfcxYrO3YTKZmBI4FaVCyfxBC/nn6DpqDDWNttuXvxcTMNp3XKPlCoWCif6T2ZFTO353RU0FuZW5hLtF0JPmhsynoqaCXbk7Orzvbym/8Hzs0ywIPalR0g8g2nsU8QX7ujJUIfolnUFHdkUmoa5hAAS7hBDqGsbGzP+sG1gfV2OooUpfhZtd82HBJwdMpUxXhr3KnnF+E1o9zkT/SSQVHyK/Mp/vDn/N/EGLBkzSr7dQKpSM953An2l/oDz+2yk6T6VUce7QC/gv42+yyjOtHY4QQgghekhCQTyOakdzj/+2nDX4nE4n/QBGekWTXZFNYVVhp48heocSbQkAFTXl1g1ECCH6sQGZ+DOZTDzxxBP89ddffPrpp4SEtK97pBAtMZqMpJWmNnrYdbNzJ9wtnH0dSPxtydrMMK8ReNrXzmG3IPQkynRl7MjZ3mi7PXm7CXAOxM/Rr9kxJgVMIb00jdyKHNI0qQA9nvgLcwsn1DWMf4+tb/c+BqOBt/a8zmu7XuK0iDO4c8K9jZJ+ADE+o0nVJFNRU9HVIQvRrxwrS8doMhHmGm5eNj1oJtuzt6I36q0YWd9Wqqsd0sLVzr3ZunF+E1ApbZjgNwk7G7tm6xua6D8ZE/Bc7JMUVxdx0fD2TcosutZ4/4mYgOGeI3Fr4TMVHXNy+Gm42rrx7aH2D5svhBBCiL4tsSCe4Z4jmtXdu8tI75ja8xbG98j5RPfRaGuH3pP2HSGE6D4DMvH3+OOP8/PPP/Pyyy/j5OREfn4++fn5VFdXWzs00QdllmegM+iaJdhifMa0u8efzqBjZ24sUwPqh4cLd4sg0j2Sv9LXNtp2X94exviMbfE443zHo1QoiM3ZTqomBaVCQYhLaMcuqAvMCZnH1qwtVOvbLlOlWg33b7yLX5NXc/PY27h57O0tVhyivWMwmkzsL0zojpCF6DfSS9MACHWtL/szg2ZTpivrUC9k0ZhGVwKAq61rs3VOaiduHXcXy0Zc2uZxPOw9iXIfTFz+PmYHzyPYRV4+sobxfhMBmBI4zcqR9A92NnYsHXwua9P+kLfwhRBCiAHAaDJyoGi/ORnXE7wdvPF38iexQNoE+jqNtnb+Kkn8CSFE91G1vUn32Lt3L2vWrCE7OxutVttonUKh4N133+22c3/1Ve3byJdc0vgt+2effZalS5d223lF/5RccgSg2fAWY3zG8vORH8mrzMPX0bfVY+zN20O1vrrZvFALQk/iw/j3KdOV4mLrSnF1EemlaRZ7iDjbujDSK4bYnG34OvoR4hLaqXn2TtSckHl8mvgRsTnbmBU8x+J2aZpUHtl8PxU1FTw/6xVG+7ac0AQIdg7Bzc6d+II4GZZNiFaklabh5eCFs239mN+R7lH4O/mzKXNDm0NRipaVHn8r1c22+VCfACeHn9ruY00MmMyRkiQuHL6sS2ITHeft4M3zs15muNdIa4fSbyyOWsLXh77gh6Rve3RuYSGEEEL0vKOl6ZTpyhjpFd2j5x3pHUNCQVyPnlN0PRnqUwghup9Vevx9+umnXHDBBfzyyy/k5uZSUVHR6F95efd+8R86dKjFf5L0E52RoknGy8Gr2VBh9fP87WnzGFuzNhHgFGCek6vOvEELMJoM/HfsX6A2QQgwppUE2UT/yezN283hooM9PsxnnWCXECLdo/j32N8Wt9mSuYlb/r4ee5U9by94v9WkH9S+EBDtHUNigQzrIURr0jSpzb5LFAoF04NmsilzA0aTTJjcGXVDfbY0x19HnTvkfJ6e8YLVvqNFrXF+E3BQOVg7jH7DWe3MGZFL+CX5J8qOlxchhBBC9E/7CxNRKhQM8xzRo+ed4DeRw8WHOFqa3qPnFV1LY078SY8/IYToLlZJ/H300UcsW7aMjRs38vXXX7Ny5cpm/4ToK1JLkolwi2y23N3eg1DXMOLy97W6v9FkZGv2ZqYGzkChUDRa52nvxXi/ifyVvgaAffl7GOQaap4HsCWTAiZTra/mYNEBqzYqzwmZx/bsrVTWVDZarjPoeH/fOzy65UHG+03ktbnv4O8U0K5jxniP4kDhfnQGXXeELES/kF6aRphr87I/I2g2xdXFHCjcb4Wo+j6NVoNSocBJ7XzCx3KxdWVSgPRcFv3P0sHnojfq+TX5Z2uHIoQQQohulFgYT7hbJI5qxx4976zguXjYe/BD0nc9el7Rtep6/NUYa6R9RwghuolVEn9VVVXMnz8fpXJATjEo+pnkkiMtJv4ARvmMaTPxl1R8mMKqQqY1GeazzoLQRewvTCSrPJM9ebsZ4zuu1eNFuEXhae8JYPXEn86gY1v2FvOyI8VJ3LDuGn48soqrY67l4amPd6iiEO09ihpjDUnFh7sjZCH6PK1BS3Z5ZrMefwAjvEbiYe/Bpsz/ej6wfqBUq8HV1q3ZCxpCiHoe9p4sCF3ET8k/UGOosXY4QgghhOgmiQUJPTq/Xx1bG1uWRJ3Nn2lrKKku7vHzi66h0ZagPF6vkuE+hRCie1gl83bKKaewYcMGa5xaiC5VpislvyqfiCbz+9UZ5TOazPIMCqoKLB5ja9ZmXGxdiD4+NGhT0wJn4qBy4KuDn5NVnskYn7aHxKybA8+aiT9/pwCGeQ7nn2PrMRgNfHlgJTf/fS0qpQ1vL3if84ddhFLRsa+gKPfB2KvsZUx/ISw4VnoUE7SY+FMqlEwLnMGmzA2YTKYej62v0+g0zYZ0FkI0t3TwuRRWFfJfhuXhvoUQQgjRd5VUF5NZntHj8/vVOT3iDBQKBb+k/NTpY2gN2i6MSHRUibYEv+MjP8lwn0II0T2skvh78MEHKSgo4M477+T777/nzz//bPZPiL4gVZMCYLHH32ifMQDE5e+1eIxt2ZuZFDAFG6VNi+vtVfbMDJ7NmtTfGx2zNaeEn87kgCn4Ovq1uW13mhMyj505sdz+7018mvgh5wy5gDfmLbf492qLjdKG4Z4jJPEnhAVppbXfSaFuYS2unxE0i5yKHFI0R7rl/MXVRf12qJZSnaZL5vcTor8Lcwtnov8kvj/8jbxkIIQQQvRD+wsTAazS4w/A1c6Nk8JO4ecjP3aq7rE1azNLfzqd/Mr8bohOtIdGW0KQcxAgiT8hhOguVkn8paSksHv3bn777Tceeughbrnllkb/br31VmuEJUSHJZccQa1UE+IyqMX1HvaehLgMspj4y6nIJrkkmakBLQ/zWWfBoEUARLpH4tqOhueR3tE8NeP5Dveo62qzgudiNBko0Zbwypy3uCrmf9ja2J7QMaO9R5FYmIDRZOyiKIXoP9JL0/B28MbZwjx0o33G4qx25pOEDynVarr03DqDjqv/vJwfk77v0uP2FnVDfQoh2nbOkPNJLklmb95ua4cihBBC9DvxBXG8veeNVkcW6k6JhfF4O3jj6+BrlfND7QgDGm0Jfx9d16H9TCYTn+//FJ1BR2zOtm6KTrSlRFtCoHMwIEN9CiFEd1FZ46QPPPAAjo6OLF++nLCwMNRqtTXCEOKEJZccIdQ1zGJvPajtobc3f0+L67ZlbUGltGGC/6RWzzPadywBzoFM9J9yQvH2NB9HH5Yv/Ag/R/8um/Q7xnsUK/d/QnppmlWHMhWiN0orTSPMLdzierWNmtsn3M2rO1/kqrWXctPY25gVPKdL5q3bnLmRUq2GtNLUEz5Wb6TRaohyt17jhhB9yVjf8US4RbAq6VvG+o23djhCCCFEv/JB3HL2FyayNu13Lh5+KWcNPueEX7DtiMSCBEZ6xVh17utglxAmB07j+8PfcFLYKe2OZV/+Hg4XH8LF1oXY7G2cFrG4myMVTekMOqr0VQQ6BQLS408IIbqLVboDJScnc/fddzNnzhzCwsIICgpq9k+IntaZ4ahSNSlEuLc+bOUonzFklB2jsKqw2botWZsY7TMWJ7VTq8dQKpS8u+ADLh1xRYdjtLZwt4guS/oBDPMagY1CSUJBfJcdU4j+Il2T2uL8fg3NCp7DByd9RrT3KJ7a9hiPbnmwS94WXptWOxxxdnnWCR+rNyrVadrV41oIUTvf8NlDzmN79jbSS9OsHY4QQgjRbxwpTmJ/YSJ3TriXk8NP46OE9/nfn1ewPbtreq+ZTKZWR9fRGXQcLj7ECO+RXXK+E3HukPNJL01jZ25su/f59tBXRLhFcM6Q89mTt6vfTlPQm2mOjzwTKEN9CiFEt7JK4m/48OEUFjZPgghhLQajgWW/n8dvKb90aJ9UTUqb89WN8hmDArhizcVc/9fVPLPtCT5L/Jh16WuJy9/LtMAZ7Tqfk9oJtY30jnVQORDlMYSEgn3WDkWIXqVaX01ORTZhrm33hPVy8OLRaU/yyNQnOFCYyNVrL+W3lF86PR9XXmUeu3N34u/kT1ZFZqeO0dtptDLHnxAdMTdkAZ72nq0O/xuXv5cNGf/2XFBCCNGPGE1GPkv8mLf3vGHtUEQP+jn5R7wdvFkYehI3jLmZ9xZ+jI+jLw9tupeHNt1LXmXeCR3//bh3uHn9dRaTf0nFh6kx1jDSyzrz+zUU4z2awR5D+P7wN+3aPrkkiR05sZw39EKmBEylSl9FQkFcN0cpmtJoSwDwtPfCXmUvQ30KIUQ3sUri79FHH+WTTz5h06ZN6PV6a4QgRCP7ixLJq8zj20NftXvuuIzyY9QYa4h0j2p1Oy8HL16a8zoXD7+UwR5DKKjK55fk1Twf+wwAUwJbn99PNBfjPYr4fHlAF6Kh9NI0TNBmj7+GZgbP5qOTVzIjaBav7XqJVUnfdurc69LXYmtjx7lDLqC4upgqfVWnjtNb1Q1H42rrau1QhOgz1DZqzoxayp9payipLm62/tfkn7n7v9t4cuujfJb4cadfPBBCiIGoXFfGQ5vuZeX+T1h9ZBVpmv451HpvY+3fqnJdGeuP/sXpEWeapxsJcwvnhVmv8MjUJzhcfIg397za6ePrDDrWpv3B4eJDbM7c2OI2iYXx2NnYtdkO0hMUCgXnDDmP3bm7SNEkt7n9t4e+ws/Rjzkh8wl3i8TbwVvm+bOCEm3tc6GbnRtOaifp8SeEEN3EKnP8XXTRRej1eq655hqUSiV2dnaN1isUCnbt2mWN0MQAtSNnOyqliqzyTHbkxDI5oO259FJKah8s2+rxB7W9/kb5jGm0rFxXRpW+Gh9Hn07FPJBFe4/i+8PfkluZi5+jn7XDEaJXSNekAR1L/AG42Lpy18T7cFI781H8Cib4TWp1nsCmTCYTa9P+YEbwLCLdBwOQXZHVru/GvqJUVwqAq527dQMRoo9ZHHkmXx5YyS8pP3HJiMuB2h4qHyes4OuDX7I4cgneDt58nPABJdoSbhp7K0qFVd5LFEKIPiO9NI1HNz9IqU7Dk9Of5eWdz/Nz8mpuGXe7tUPr17QGLbf+fT1DPYZz6/g7rfJ7tTbtD4wmA6dEnNZouUKhYGbwbHIqsvk44QOq9FU4qBw6fPzt2Vsp05UR6hrG5/s/YXrQzGbXmViQwFDP4aiUVmlObGZW8FxWxC1n1eFvuXvi/Ra3y6nI5t9jf3P96JvNSdNJ/lPYnr2N60bf1FPhCup7/LnZueOkdpbEnxBCdBOr/FJfeeWVVp0EWIimYrO3MSt4NkdLj/LTkVXtS/xpkvF28O70nE/Oti4427p0at+BLtq7dliRhPx9+IUusnI0QvQOqZoUfB19Oz2n5pUx17AzN5bnYp/izXnL2z20cEJhPFnlmdw+/i4CnWsnaM8u72+Jv9p5KNxsZahPITrCxdaVRWGn8PORHzl/6EUAvLjjWf479jfXjr6Bswefh0KhwN3Og9d3v0SpVsM9kx7A1sbWypELIUTvtCVzE8/FPoWvox9vzX+PQOcgTos4gx+SvuOqmP+1OXd8X1RZU8mWrI3MG7TQqi+HfHvoK9I0qaRqUtCb9Nw54d4ejcdoMvJL8k/MCJqNp71Xi9tMC5zB+3Hvsit3BzOCZnX4HH+mr2GIx1CuG3MTd/xzM5szNzIzeLZ5vclkYn9hAqdEnN7p6+hqKqWKJVFn80niB1wZ/T+8HFr+23x3+Buc1S6cFH6qedmkgCn8nvorWeWZ5vnmRPcr0ZZga2OLg8rheI8/GepTCCG6g1USfzfffLM1TitEi4qqC0kuOcI5Q85jvN9EXtzxHBllxwh2CWl1v5SSI4S7tT2Xluh6bnbuDHINJb4gjvmS+BMCgLTStA739mvIzsaOeyc+yC1/X8fKA59wZfQ17dpvberv+Dv5H5/PVIG9yp6s8v41z1/p8QnoZY4/ITpu6eBz+DV5NT8mfc+27C0cKjrIw1OfaNSQeGrE6bjZufH0tsd5aNO9PDbt6U6/xCCEEP1RjaGGrw5+zsr9nzAjaBZ3T7zf/D15WsQZfHVwJevS13Jm1FIrR9r1Pkx4n5+P/IiDypHpQTOtEkNORTZfHficc4acT7hbBC/sqJ22oyeTf3vzdpNZnsGdE+6xuE2QSzChrmFsztzY4cRfSXUxO7K3cf2Ym4nxHsVY33HNev1llWdSoi0h2mvUCV1LVzstYjGfH/iUD+KXc8f4e5q9wFhSXcya1N84f+hFjXpCjvUdj0ppw46c7f2y7PRWGp0G9+MjqThLjz8hhOg2MpaOGPB25sSiACb4TWJOyHxc7dxYfeSHNvdL0ST3inHtB6porxgSCuKtHYYQvUa6Jo0w1/YP0dmSIZ5DWTbicr45+AX7CxPb3L5KX8WGjH9ZGHoySoUShUJBoFMg2RVZJxRHb6M5nviTOf6E6LhglxCmBE7ng/j3OFp2lBdnv9Yo6VdnetBMnpv1EoeKD3L3f7e1OC+gEEIMJAajgd25O3l55/Oc/+tZfL7/Ey4feRUPT3280csRPo4+zAiazU9HfrT6HHRd7UhxEr8mr0atVPNbys9Wi+O9fe/gaufKRcMvZX7oIu6d9CDr0tfy0o7nMJqMPRLDT0d+JMw1nGjv1pNu04JmsD17KwajoUPH/+fYehQKBXNC5gFwycgrSNGkNJrrL7Gwtv493Gt4B6PvXs62Llw3+ib+Pbaem/++ttmclz8nrwbgzKizGi13VDsS4z2a7dlbeypUAWiqS3A7nvirHepTevwJIUR3sEqPv0svvbTNbT777LMeiEQI2JETy2CPobjbewC1b4utTlrFldHXWHzbvExXSkFVARFukvizlhifUfye+iulWk2nh1sVorcr05WSUpJMiiaZ5JIj5FbmcvHwSxjjO67RdpU1leRUZBPagbn5LLlw2DK2ZW/h+dinWb7ww1bnB9mU8R9V+ioWhZ1sXhbgHNT/evzpNCgVCpzUztYORYg+6bKRV2AyGblu9E0EuQRb3G6UzxhemfMG9264i1d3vcTj05/uwSiFEKJ3OFx0iLXpf7Dh2D+UaEsIcArg9MgzmReywOI8zGdGncWd/97KnrxdjPOb0MMRd9yWzE14lLsw3Hm0xW2MJiNv7nmVEJdQlkSdzRu7XyanIht/p4AejLT2ReFNmRu4f/LD5vaBeYMWAvB8bO3v1F0T7+vWnn95lXlsy97MTWNvb3PanOmBM/nqwOckFMQx2ndsu8/xV/paJvlPNSdkWur1t78wkVDXMFx64ctwp0UsZqjHMJ6LfYob1l3DVTH/46zB56A1aFl9ZBWnhJ9uvraGJgVM4aP4FVTrq7FX2fd84ANQibbE3OPPSe3U7+qOQgjRW1ilx5+zszMuLi6N/plMJhISEjh69Ciurr3vIUL0TwajgV25O5jUYE6/xRFL0Bqq+St9jcX9kkuOAMhQn1ZU96bjvvy91g1EiG7wzcEvufDXs1n602Lu+u82VsQtJ7nkCBptMY9veZjMsoxG26eVpAGccI8/ABulDfdNeoiCqnxWxL3b6rZr0v5gtM/YRg0wgU6BZPWzHn+l2lJcbd1kfmIhOinSfTBPzniu1aRfw21vGHMzW7I2sTt3Zw9EJ4QQvUd2eRa3/H0dWzI3siB0EW/Nf49PT/mKK6OvsZj0A4jxHk2Yazg/HfmxB6PtnINFB3h008PcvvZ2duVY/p7/M20N+wsTuWXc7cwPXYiD2pHfU3/twUhrh1h9e+8bjPIZzdyQ+Y3WzRu0kHsnPcj6o3/y4o5nu7Xn328pP2NnY8/84wnH1gzxGIq3gzebsza1+/hpmlSSig+zMOykRsub9vpLKIhnpFd0x4LvQVEeg3l7wfssjlzC8n1vc9+GO/nywEoqaso5Z8h5Le4zyX8KNcYaaVfoQRptifnl7do5/mSoTyGE6A5WSfy98847vP32243+rVy5knXr1uHv78+pp57a9kGE6AIHiw5Qpitjov9k87K6oVJ+TFpl8eF9d94u1Eo1IS6DeipU0YS/UwARbhFsyPjX2qEI0eX+ObYOX0c/Hpj8CB+c9Cm/nLWWdxd+wCtz3sTNzp1HtzxIZU2lefvkomSALvtOCnYJ4X+jrueX5J/YkbO9xW2yy7OIy9/LSQ16+0Ftj7+8ipwODy/Um2l0mhbfEBZCdI+5IfMZ6RXNu3vf6lffJUII0ZbvDn+Dk60LH5/8BdeOvpGhnsPa9eKRQqHgzKilbMveTG5lbg9E2jnlujKe3vYYgz0GMylwEo9uepBUTUqz7cp0payIX878QQsY5TMGB5UD8wctYm3q7+iN+i6Lp7CqkK8PfkFxdVGL639I+o6s8gxuHHNLi59DbfLvIf4++hfPbn+yXbGZTKYOJQlrDDX8nvILC8NObtf8twqFgqmBM9iSubHdQ7+uS1+Li60Lk/ynNFresNdfma6U9NI0Rnr33sQf1M5bfv2Ym3h+1sscKzvK1we/YE7IPIs9RUNcBuHv5E9szrYejnTgatzjz5lyGepTCCG6Ra+a48/T05Orr76a119/3dqhiAEiNmcbLrYuDPNsPEb9kqilZJZnsCt3R6PlJpOJL/Z/xlcHPueMqCXYKG16MlzRxOyQeWzL3kK1vtraoQjRpfIr85kcMJW5g+YT6hpm/q5xtnXh8elPk1eZyws7njE3GqQUp+DvFNCuxoD2OiPyLMb5jee52Kf5LeUXagw1jdb/lb4WB5UDM5rM1RXoHIjBZCSvFzc6dVSptgQ3GVJYiB6jUCi4YcwtpJemWnVOJyGE6Ekl1cWsSf2Ns6LO7tSQg/MGLcBe5cCvyT91Q3QnzmQy8cquFynTlfHwtMd5bsFz+DsH8NCmeymsKmy07ccJH1Jj0HHNqBvMy06LOJ2i6iK2ZW/psnhe2/UiH8a/z2V/XMTXB79Aa9Ca1xdUFfDFgc84I3IpEe6Wp/iYN2gBD015nE2Z//H4locaHaOppOLDXLFmGef/chZfH/yiXT2dNmVuoERbwuKIM9t9bdODZpBbmUuK5kib2xpNRtYd/ZO5gxZga2PbbH1dr78VccsBGOkV0+44rGmc3wTeX/QxFw+/lCuj/2dxO4VCwaSAqcRmb+13c2T2VqU6De52tVPt1Pb4k8SfEEJ0h16V+AMwGAzk5+dbOwwxQOzI2c54v4nNxuOP9h5FpHskPx35wbzMaDLyxu5X+CTxQy4beSXXjrqxp8MVTcwKnkO1vtpijyQh+iKtQUuprhQfB58W14e6hnHfpIfYnLmRrw58DkBycTKhbmFdGodCoeC+SQ8x1mccr+96icvXXMQvyT+hM+gwmoz8mfYHs0PmNpsDMNApCICsiv4zV4NGp8HVVhJ/QvSkIZ5DWRR2Cp8kfkiZrtTa4QghRLf7KflHlAolZ0Qu6dT+jmpHTgo7ld9Tf0Vn0HVtcF3g15Sf2ZjxH3dMuIcA5wCcbJ14dtYLGEwGHtp0r3k0i6Tiw/yavJrLRl6Jl4OXef9I98EM8xzeZS+EbMrcwLbsrdwx4R5OCjuVTxI+4Mo1y1if/idGk5EP4t7F1saOy0Ze0eaxZgbP5onpz7I7bxcPbry30cgcUJtk/CHpO275+zocVA5MCZzGp4kfcvFv5/JRwgpKqostHvuX5NWM8hnT6lCvTY3yHoOT2onNmW0P97knbxeFVYUsDD2pxfV1vf7+SP0NNzt3Ap2D2h2HtbnYunJ59FX4Ofm3ut0k/ynkVORwrOxoD0U2cOmNesp0ZebRVJzUTuiN+l75nSWEEH2dVRJ/iYmJzf7t3buXVatW8fzzzzNq1ChrhCX6mf2FiTy97XGLDxDF1UUkFR9mUoNhPusoFAqWRJ1DbPY2Mssy0Bq0PL7lYX5P/YU7JtzDshGXyVxPvUCwSwiR7pH8d+wfa4ciRJcpqKx9+cXbQuIPYFrQDC4deQWfJn7IlsxNpBSnEOYa1uWxeNh78tDUx3h/0SeM8Irmzd2vcNkfF/L23jfIrcxlUdgpzfbxdfTDRqEkq7z/zPNXqi2VHn9CWMGVMdegN+r5NPFja4cihBigciqyySg71u3nqdJX8dORHzg1YrF57qvOOCNyCaVaDf8d+/uEY4rL38u3h74ipyL7hI+VXJLEu3vfZHHkEmYFzzEv93H05ekZz5NZnsGz259Ab9Tz5p5XCXUNZ0nU2c2Oc1rEGezK2XHCMVXUVPD23teZEjiNk8NO5caxt/DBSZ8x2GMoz8U+zbV/Xsn6o+u4OuZanG1d2nXMif6TeW7mSySVHOLeDXeYX1rRaEt4ZPP9vLv3Lc6IXMrr897hzgn38tkp33By+Kn8mPQ9F/9+Hm/ueY1vDn7Je/ve5rntT3LPf7dzzdrLiS+I63AyWG2jZpL/FLZkbWxz27/S1xLsEsJQj2EWt7nkePJzpFd0v2wHGe0zBrVSzfbsrR3aT6Mt6Z6A+rFSnQag0VCfgPT6E0KIbqCyxknPPvvsZg8LdV3qR48ezZNPPmmNsEQ/syNnO/8e+5sQl0Fc2sJbenXDeE7wn9Ti/nMHzWdF3Lt8eXAlmWUZHClJ4vHpzzIlYGq3xi06ZnbwPL448BlV+qpmPY+E6IsKqmoTfz6Ovq1ud/HwSzlSnMTTW59AZ9IS7hbRbTGFuYXz4JRHuWTE5Xx54DN+TV5NkHMw0S0M9WOjtMHXyZ/s8v7T469UpzmhRjghROd42ntx8fBL+SjhfU6POKNDvR2EEKIrPL3tcdJL03hx9msM9bScGDlRa1J/o6KmnLMHn3tCxwl2CWG83wR+Sv6RhU3mYe4Ig9HAizueJacihxVxyxnhNZJ5gxYwK3gOHvaeHTpWZU0lT259jEGug7hudPNRcyLdB/PQlMd5ePO93PL39SQVH+blOa+3OK3G7JC5vLvvTX5P/ZUro6/p9PV9nPABFTUV3DT2NnPbVLBLCI9Ne4q4/L28H/cuo33GsqiDf8MYn9G8OOs17t94F3f+ewuXjLiCd/a+gc6g48npzzIlcJp5Wx9HH64bfRMXDbuE1Ud+4KcjP6A36fGw88TLwQt3Ow8GuYZxRtQSZjYZWr89pgXN4J9t68mpyLY4v11lTSWbMjZw8fBLW03oxXiP4ryhFzDKZ2yH4+gL7FX2jPUdR2zOds4dekG79vn76Dqe2/4kV0Rfw4XDl3VzhP1HyfFkad1oKk5qJ6A2Gd/R7xYhhBCts0ri77PPPmu2zM7ODn9/f/z8/KwQkeiPsitqe5t8dXAls4LnNGssis3ezmCPIRYfLuxs7Dgl/DS+OfQVrnZuvDTn9WZzAQrrmxU8h48SVhCbvY3ZIXOtHY4QJyy/Kg8ALwfvVrdTKpTcO+lBbv3nejIqjnb5UJ8tGeQayn2TH+bSkVeiVCgtNhAEOgWSVdF/evxptBpcbV2tHYYQA9JZg8/h99RfeWfvGzw/65V+2dNACNE7ZZQd42DRAdzt3Hlg4928MvdNQjs4wkJiQQJfH/yc/Ko8np7xYqOhK+vojXq+P/wNc0PmtzkkYXucGbWURzY/QGz2dsb4jm1x3ra2bMrcQE5FDq/MeYO8ylz+Obaed/e+yTt732Cc3wQuH3l1uxOhb+x5hcLqAt5d8IHFWCYFTObmsXfw+u6XmR+6kFE+Y1rczkHlwILQk1iT+huXjrgClbLjTVqHig7y85Ef+N/oG/BzbN7+NMpnDG/Nf6/Dx60zxHMoL895g3s33METWx9hlM9o7pv0MD6OLY/m4WrnxqUjr+CSEZd36W/cRP/JqJQqtmZt5qzB57S4zcbM/9AZtMwLXdjm8a4ZdX2XxdYbTQqYwvJ9b1FRU2FORlmyMyeWF3c8Q6BzMB8nrGCwxxCLL5SLxjTVJUDDHn/1iT8hhBBdyyqJv0mT5AdRdL/cihxmBs8mTZPKyzuf5/V575jn8jOajOzMjeX0yNYnyF465FwKqgtYNvwygl1CeiJs0UFBLsFEuQ/mv4x/JPEn+oWCqgJcbF3a1YPVUe3IUzOf4/djq4l0jwJjDwQIbc7tEegcRGJBfM8E0810Bh1V+ircZI4/IazC1saW60ffxMOb72dr1mamBc2wdkhCiAHi76PrcFA58O7CD3lg413ct+FOXpv7dpvJOZPJxJ68XXx54HP25e9hkGsolTUV3LvhDl6Z80azUQQ2ZPxDXmUe5w29sEvinhwwlWCXEB7cdA9Q28Du5+SPr6MfwS4hnDfkglaHrzSZTHx76CvG+I4jxmc0APNDF6HRlrAxYwO/pqzmzn9v4eGpTzA5YEqrx/nywErWp//FfZMebLM+fXrkGYS4hDDYY2ir250Wfjo/H/mRrVmbO9wTzmA08OquF4lwj+SsqJaTYV0hzC2c1+e9w968PSwKO9ncDtGarn6xxUntxFjfcWzO3GQx8fdX2lpG+45rMQE60Ezyn8Jbe15nT94uZgTNsrjdoaKDPL71Ycb5TuDRaU/x2JYHeWb7E7yzYIXFnpWiXl2PPzd7d0CG+hRCiO7UY3P8lZSUYDQazf+/rX9CnKicimxCXAZxx4R7OFR0gNVHVpnXHSw6QJmujEn+lisqUDvE1H2THpKkXy83O2Qu27O3NptEXYi+KL8qH59W5vdrKsgliHum39OpN567S8DxHn91w3j3ZaXH52dxPf5WqhCi500OmMoE/4ks3/eWxbmbhRADV2VNJcXVRV16TJPJxLqjfzIreA7eDt48O/Nl1Eo192640+K5DEYDWzI3cfPf13HvhjupqCnnkalPsGLRJzw/6xWKtcU8sOmeRnWWuiTbRP9JRLhHdUnsSoWSN+cv58XZr3L3xPs4I+oswlzDKdeV8cPh73g/7t1W908oiONw8SHOHdJ4yEM3O3dOjzyD1+e9yzi/CTyy+T7+TPujxWOU15Tz6JYH+STxQy4ZcTnzQxe1K/bRvmNxVDu2uk2EexTDvUbwW8rP7TpmQ6uPrCKl5Ai3jb+7xaFEu5K/UwAnh5/arqRfd5kWOJP4gr2UajXN1qVpUtmXv4dFoSdZIbLeJ8A5kBCXQWzO3GixDpNRdowHNt1DuFsED019HFsbW+6f/DDOamce2/Ig1frqHo667ynVaVApbXBS1fb0kx5/QgjRfXrsCWTq1KkkJCQAMGXKFKZOndrqPyFOhM6go7CqgACnQKK9Y1gcdRYfxa8wTwK+I2c7zmpnhnuOsHKkoivMDp6LzqDr8GTcQvRG+ZV5eHcg8dcbBToHUa2vpkRbbO1QTlipeR4KGepTCGtRKBRcO+pGsiuy2Zjxr7XDEUL0Msv3vcVN669t14sBVfoqPox/j6Lqwla3O1C0n+zyLOYPqh0C0cvBi+dnvUKlvoL7N95F+fHeKSaTiYNFB3h7zxtc8OtSHt3yIGqlmqdnvMA7C1YwM3g2SoWSQa6hPDfzJY6VHeWRzQ+YY92ZG0tySXKX9far46x2ZozvOBaFncIlIy7nron38cLsV7lm1HWsSf2Ng0UHLO777eGvCXUNY6KFoQvtbOx4dOqTnBx2Gi/ueI5vDn7ZKFGSoknmxnX/Iy5/L09Mf4ZLR17RpdcGcFrEGezK3Wmu37dHbmUunyR+yOKoswbMFB5TA6djNJka1ZNrDDV8deBzblh3DQHOgUxvpXfbQDMnZB7r0v/k+nVXsyb190bfKfkV+dz9zx242brx1PTnzKOzuNi68ui0JzlWdozXdr/UL1587E4l2hLc7NzNPVwdVZL4E0KI7tJj3QOeeeYZQkJqe009++yzPXVaMUDlVeZiAvyPD8NyVfT/2Jq5idd3v8wzM14kNnsb4/0mdvtbfqJnBDgHMsRjKBsy/mXuoPnWDkeIE1JQlc+QNoY46u0CnAMByCrP6vOTtGuOvyHtZidDfQphTWFu4YzwGsn6o3+1u+eIEKL/Mx1PahRVF/FH6q+cGbW01e1/TPqerw9+SZmujNvG32Vxu/VH/8LbwZvRvmPNywKcA3lu1svc+c8tPLLpfkb5jOHvY+vILs/Cw96DeYMWMm/QAotz3w32GMJT05/jvo138eS2R3l06pN8e+hrhngMZbTP2Bb36WqLI5fwR+qvvLn7Vd6cv7xZb7RjZUfZlrWFOyfc2+rQkzZKG24bfxce9p58EP8eRdVFXDv6Bv45uo5Xd71EkHMQz8x/nyCX4G65jtnBc3l375v8lvIzV8Vc2+b2OoOON3e/gpPaiSuir+6WmHojLwcvhnuNYEvWZhaGnUx8QRyv73qZY2XpnD34PJaNuLzNHpYDybIRlzHcawSrk1bx8s7nWRG/nNMiFrMofBEv7Hoag8nAS7NeajZcb6T7YO4YfzfPxT7NcM8RbX4PDWQabYl5fj+o/S5xUDnIUJ9CCNENeizxd9ZZZwGg1+sZMmQIAQEBeHr27cZA0XtlV2QBmMdYd1Q7csv4O3l4032sSvqWpOJDnBF1ljVDFF1sVvAcPk38iMqaSqm8iD4tvzKPaYF9ew6rAKfaxF92RSYjvaOtHM2JqR/qUxJ/Qljb/EELeXvv6xRXF/X5lwqEEF0jrTSVouoigpyD+fLASk4OPw07G7sWt9VoS/j64Bf4OvqyJvU3Lhh2cYtzcumNev49ur7FYRoj3CJ5asbz3LvhDlI0ycwImsVt4+5kjO+4dg3pGOMzmkenPsWjW+7nvg13sS9/Dw9PfbzL53ezRKlQctPY27n9n5v4I/U3TotY3Gj9qsPfHk9iLmjzWAqFgsujr8LT3pO39rzGnrydpGpSmR+6kNvG3YW9yr67LgN7lT0nh5/K1we/JKUkmaVDzmWc74Rmf8dyXRm/pvzMqsPfotGW8Oi0p3A+PqfYQDEtcAaf7/+UV3a+wB+pvzHMczjvLFhBpPtga4fW6ygVSib6T2ai/2Qyyo7xc/JqViet4uuDn+Pu6MYrc960OB/i/NBFHCw6yLt73yTKfUifrwN1lxJtCa5N5k53UjtJjz8hhOgGPT7YuFKp5Pzzz+fgwYM9fWoxgORU5KBUKPBx8DUvmxIwlbkh83lv3zuYgAl+LQ9dIvqm2SFzqTHWsC17i7VDEaLTdAYdJdqSPj/Up4PKAQ97D7LKs6wdygkr1WmwUSjN81AIIaxndshcFCjYIMN9CiGO25W7A7VSzaPTnqREW8yvyT9Z3PbLA58D8MqcN3GxdeXz/Z+2uN3OnFhKdaXmYT6bGukdzcpTv+bbxau5a+J9jPOb0KF53CYFTOa+SQ8TX7CXQOcgZvTwUIvR3jEsCF3ER/HvU3b8BSeA4uoi/kxbw5Kos7G1sW338c6IOouHpj5OibaEW8bdzr0TH+zWpF+dq2Ou4+6J91FYXcB9G+7imj8v57eUX9AatBRUFbAi7l0u+u1cPk38iGmBM/jo5M+ZHjSz2+PqbaYFzkBr0PJfxj/cPPY2Xp/3jiT92iHYJYQbxtzM16f/wB0T72b5acsJcwtvdZ9rR9/ACK9ontz2CHqjvoci7Vtqe/x5NFrmpHaWxJ8QQnSDHuvxV0epVBIcHIxG03xyYSG6Sk5FFr6Ofs2G8rxhzM3syt2Bj6MPXg5eVopOdAd/pwCGeg7jv2P/tOsNVSF6o7r5Znwc+3biDyDQKYisikxrh3HCNFoNLrauPfYmvhDCMjc7dyb4T2L90b9kGC0hBFCb+BvtO4ZwtwgWhp7M1we/4NSIxeb5t+rkVuTwc/KPXDz8Uvyc/Llw+DLe2/c2Fwy7mGCXkEbbrj/6F+Fu4US4R1k874n2Op4dMhcntRMutq4dShp2lWtGXceWrE18nPABt4y7A4Cfk1ejVChZHHlmh483K3gOs4LndHGUrVMpVSwKO4WFoScTX7CPVYe/4/VdL/Fh/HtU6auwtbHljMglnDX43AFd9x/kGsqTM55jsPuQAf136CxHtSOnR56Bh4cTxcWtJ6dUShVXxVzLbf/cyJGSpAEzl2RHaLQaItwaf7c6qZ0orymzUkRCCNF/9fwTJnDdddfxzjvvkJuba43TiwEgpyIH/+NDzTXkbu/BMzNf5I7x91ohKtHdZgfPZUfOdnlbTPRZ+ZV5AH2+xx/UzoOT3Q96/Gm0GtwazEMhhLCu+YMWcaBwP1nlff/FAiHEidEatOzL28t4v4lA7fxcZbpSfj7yY7NtP038CGe1M0sHnwvA6RFn4mHvyef7P2m0XUVNBZszNzJ/UPfPJTrBf5LF+QC7m6e9F5eOuIJfk38iqfgw1fpqfj7yIyeHn4aLratVYuoshULBKJ8xPD79aT455UtODT+dK6Kv5ovTvuPqUddJsova0Y/k79AzhngMRa1Uk1AQZ+1QeqWSJnP8gQz1KYQQ3aXHe/wBrFmzhuLiYhYsWMDQoUPx9vZutF6hUPDuu+9aIzTRT+RUZBPhHtniOmtVrkT3mxUyl/fj3mVb1mbmh3Z/ZV2IrpZflQ/QaJjivirQOYidObHWDuOElek0uMn8fkL0GlMDp+OgcuDvo+tYNuIya4cjhLCihII4aow15sSfv1MAJ4efxreHvmJx5BLzvN8pmmTWpa/lxrG3mpfZ2thy0bBLeGvPa1w4/BJCXcMA2JS5Ab2xhrkDYASRJVFnsyb1d97a8xrzBy2kvKaMs48nRvuqQOcgrh51nbXDEAOY2kbNcK8RxOfHcc6Q860dTq9iNBmP163cGy13UjtToi2xSkxCCNGfWaXHX0VFBeHh4YwZMwYHBwcqKioa/SsvL7dGWKIfyanIJqCFHn+if/Nz9GOE10j+zfjH2qEI0Sn5lXk4qh3NjVJ9WaBTICXaEiprKq0dygnR6DTNJqAXQliPvcqeaUEzWH/0L0wmk7XDEUJY0a6cHXg5eBHmWj/v1kXDL6VSX8nqI6vMyz6OX4G/UwCnhi9utP/J4afh4+jLysRPzMvWp//JKJ+x+Dr2/Zew2mKjtOHmcbexvzCR9+LeYXrQLAKcpQ4txIka6R1DQmG8PKc0UaYrxWgy4W7v3mh5bY8/aQcWQoiuZpUefytXrrTGacUAUVlTSamuFH8nf2uHIqxgVvAcPoh/j4qaCpzUTtYOR4gOKagq6Be9/QACnIMAyK7IJNJ9sJWj6TyNVoOfh/yeCNGbzB+0kPXpf5FUfJghnkOtHY4Qwkp25e5gvN/ERvPw+jr6cmrEYr4//A1nRJ1FqiaFbdlbeWDyI6ht1I32t7Wx5eLhl/Hqrhe5qGQZLrZu7M3bzR0TBs60EKN8xjA3ZD7/HFvPuUMusHY4QvQLMd6j+OrA52SUHyPEZZC1w+k16nr1Ne/xJ0N99ke/Jv9MemkaN469xdqhCDFgWaXHnxDdKaeidk4pP8cAK0cirGF60Ez0Rj27cndYOxQhOqygKh9vB++2N+wDAo/3us7q4/P8lWo1uMpQn0L0KuN8J+Bu5876o39ZOxQhhJUUVhWSokkxD/PZ0IXDllGtr+aHw9/xQdxyIt2jmB0yt8XjLAo7mQCnAD5N/Jh/jq1DpVQzI3hWd4ffq9wy7naenP4sw71GWDsUIfqFEV7RKBUKEgrirR1Kr6I5nvhrPsefsyT++pmUkiO8vfc1fjqyioKqAmuHI8SAZbXEX1JSEnfeeScLFy5kzJgxLFy4kLvuuovDhw9bKyTRT+RU5AAQ4CyJv4HI3ymAMNdwtmZttnYoQnRYflUe3g4+1g6jS7jZueOgciCrPNPaoZyQUl0pbjLUpxC9io3Shjkh8/nn2DqMJqO1wxGi3yipLmZd+lpqDDXWDqVNu4+/5DfOd3yzdd4O3iyOXMKXBz5jf2EiV8dci1LRctOHSqli2YjL2JK1iVWHv2Vq4HSc1c7dGntv42zrwpTAadYOQ4h+w0ntRLhbBPH5+6wdSq+i0WqAlhJ/MtRnf6I36nlhx7MEOAWhVCjZnLnB2iEJMWBZJfH377//ctZZZ7Fv3z7mz5/PjTfeyPz589m7dy9Lly7l33//tUZYop/IrshCrVTjYedp7VCElUwJnEZs9jZpDBR9TkFVPj79ZE4ZhUJBoHMg2RV9t8efzqCjSl+Fm/T4E6LXmR+6kOLqYvbk7bJ2KEL0G6uSvuX52Ge4Yd01JBYkWDucVu3K3UGU+2Dc7T1aXH/BsItQKdWM8R3XYq/AhuYPWkSQczBF1UUsCF3UHeEKIQaYkd6jSCiUHn8NlWhLUCoUODV5ucJJ7YTeqEdn0FkpMtGVvjr4OamaZO6b9BDj/CawIeNfa4ckxIBllcTfCy+8wMyZM/nzzz+57777uOaaa7jvvvv4888/mTFjBi+88II1whL9RE5FDv5OAY3mehADy5SAaZTqSkks7N0NFkI0pDfqKaoq7Dc9/gACnIL6dI+/urdSXaTHnxC9zlCPYQQ6B7E+XYb7FKKr7M7dxSif0dja2HL7Pzfyxu5XKO+FvTCMJiO7cncywX+SxW087D15fd7bPDzlsTbrhTZKG64dfQNDPIYywc/yMYUQor1ivEeRXZ5FYVWhtUPpNUq0xbjaujXrgV2XCJRef31fckkSX+z/lAuGLWOI51BmBc8lPn+flAMhrMQqib+MjAwuvPBClMrGp1cqlVx00UVkZGRYIyzRT+RUZuPv5G/tMIQVDfcagbudO9tkuE/RhxRVF2ECfBz6R48/oM/3+CvVlQBIjz8heiGFQsH8QQvZlLkBrUFr7XCE6PNKtRqSig+xMPRk3py/nOvH3My69D+5as0lbMz4D5PJZO0QzVI1yZRoS5jQRk++SPfB7Z6nd2rgdN5e8D5qG3VXhCiEGOBGesUAkCi9/sxKtCW42zXvpe2kdgLol/P81RhqqKyptHYYnVZeU86R4iQ2ZvzHd4e+5t29bxFfENfitjWGGl7c8SyDXENZNvwyAKYHzUCpULIp87+eDFsIcZzKGicdOnSoxeReRkYGgwcP7uGIRH+SU55NjM9oa4chrEipUDI5YCrbsrdyzajrrR2OEO2SX5kHgLejt5Uj6ToBTkHkVeaiN+pRKa3yyHFCSrWlADLHnxC91LxBC1i5/xO2Zm1mTsg8a4cjRJ+2N38PJmCs33iUCiVnDT6H6UGzeHPPqzyx9RFmBs/mrgn34ah2tHao7MzZgb3KnuFeI60dihBCtMjH0Qd/J3/i8+OYFTzH2uH0CqVaDW5N5veD/p34WxG/nN25O3l/0ccW55q1Jo22hI0ZG9BoSyjRllCiLUajLUGjLSG/Kp8yXZl5WweVA05qJ35I+o7ZwXO5ZtR1+DXodFE7xGcKb82vf4nGxdaVsX7j2ZDxH2dGLe3x6xNioLPKt84jjzzCxx9/zI8//khZWe2XSFlZGT/88AMff/wxjz76qDXCEv2AyWSSHn8CqJ3n72hpOpll0oNY9A0FVfkA+PSjoT4DnQMxmkzkVuSc0HFqDDXcv/Eu4vL3dk1g7aTR1Q712d7eAkKInhXsEsIQj6GsPyrDfQpxonbn7iTIORg/Rz/zMl9HX56Y9gwPTXmMnTmx3LT+Wo6Wprd6HJPJRE5FdrfGujN3B6N9xmBrY9ut5xFCiBMx0juGBAu9owai2h5/7s2W1w31WV5T1mxdX7cndxfppWnsyIm1digt+mz/J7yx+2VWH1nFnrxdFFUX4WLrykjvUZwz5HwemPwIb8x7l+8Wr+anJX/wxWnfcffE+4gv2McVa5bxccIHVNZUcqQ4iS8PfMZFwy9lsMeQRueYGTSHhIJ9FFcXWYyjSl/FKztfIO/4y9BCiK7RY6/fjx07ttHY+jU1NTzwwAM88MADqFQq9Hp9bUAqFZdffjm7d+/uqdBEP6LRllCtrybAKdDaoQgrG+c7AbVSzbbsLZztcp61wxGiTQVV+djZ2OGsdrF2KF0m0DkIgKyKTIJcgjt9nH+PrWdnzg7c7NwZ5TOmi6JrW6lWg41CiaPK+r0bhBAtOyX8dF7f/TJPbX2Ma0ffiI9j/3l5QgxsFTUVPLTpXs4fehFTAqd1+/l25+1iov/kZssVCgWzQ+YS4R7JY1se4qb113LPpAeYETSr0XZGk5EtWZv4fP8nJJckc2bUUq4bfWOX9/iv0leRUBDH/2RUDyFELxfjPZp/jq6jsqayV/SWtjaNtphBrqHNlvfXHn/lNeWkl6Zio1Cy6vA3TA6YYu2QGjGajGzO3MCSwedww5ib27WPAgWLwk5hRtBsvj70Bd8d+pq1ab9jZ2NPmFs4Fw27pNk+04Nm8Prul9iUuYHFkUtaPO53h77mj9TfcLf34Mroa07ksoQQDfRY4u/KK69sc1JtIU5UTmVtrxJ/pwArRyKszVHtyBjfsWzJ2szZQyTxJ3q//Ko8vB18+tVvpa+jHyqlDdnlnZ/nz2Qy8e2hr1EqFOzIicVoMvbYMCmlulJc7dz61WciRH9zWsRiHFT2LN/3NletvYRLR17Bkqiz++TwwkI09N+xf0goiCe55AnemPcuYW7h3XaunIpsssuzGOc73uI2IS6DeHPecl7a+RyPb3mYC4cv4/KRVwGwOXMjn+//hBRNCqN9xnLJiMv58sBnpGqSeWjKY3jYe3ZZrPH5ceiNeib4T+qyYwohRHeI9o7BaDJxoCiR8W3MSToQlGhLWpxCoa7HX39L/B0qOoAJuGDYMr448BmpmhTC3SKsHZbZgcL9FFYVMiNoZof3dVQ7cmX0NZwafjor4pazPXsrr897u8V5ct3s3BnjO47/jv3bYuIvvzKf/7N31/FNXf0fwD832qTu7i01KO4u2xhjG3PfmDBlyjbmG3PmzzaYC3NlAgMGDHeKUwPq7m2qSZrk+aOQNm1So03a8nm/Xr/Xb8/V76X33Nxzvvec83PqD1BIFNicvRG3xt3B+jdRD7Fajfj++zv39QDR2TjTuMyhPgkAxvtNxIeH3kO1RgVHmZOtwyFqV2ldKTyVXrYOo0eJBBG8lb7Ir83r9jH2F+5DpioDtw6+A18d/xwp5cmItdKcPlXqKjjLXKxyLiLqHkEQMDP4fIz1HY+vEr/AZ0c/wvrMtXhgxCIM9hhi6/CIum195lrEew5FtUaF53Y9hWUzP+m199kDRQkQCQKGdtCrXilV4tlxS/BL6o/48vinSCpNhEpTiYyqDAz3GoF3pr1vnGt9uNcIvLj7Ody38U68MOEVDHKL6nQ8RXVF+DbxK4Q4h+KCkAtNrvtA0X54Kb0Q4BDYrWslIrKWIMdgOMmccKzk6Dmf+DMYDFCpq8wO9SkSRFBIFKjV1lg/sF6UVJYIR5kjro+5Cesy/8EfJ3/DI6Me7/JxduZtxw/J3yLYKQSx7oMR6x6LEOews/4YdmfeNrjIXTDYI77bx/Cx98Wz45egUd/Y7kd3UwKm4/2Db6OiobzNx0BfHv8UCokSj4x8DM/vehpJZYmI8xjc7ZiIqFnfm1mU6CwU1RXCXmrPJA8BAMb5ToTeYOiz46kPZDWaaugNeluH0a809fjzsHUYPc7PwQ/5Z9Hj75fUHxHlFo1ro2+Ao8wRewt292B07VNpKuEk5+8JUX/gIHPE/cMfwoczP4VMLMfDmxfii2Of2Dosom7Jrc5BYtlxzA27FC9OfA01mmq8vOcF6PS6XjnfoaIDiHKLgYOs4+HGBUHANdHX47XJbyFLlQEXuSvemf4B3pj6rjHpBwBDPIdi+azP4Wrnhoc234eNWf92KpZ9BXtxz4bbsadgN7449gmuXX0F3k5YipMVJwAACUX7MNJ7NHsDEFGfJwgCYj0G43jpMVuHYnM12mroDHo4m0n8AU3DfQ60Hn9JZccR7RYDmViGS8Mvx8as9ahsqOjSMdIqT+LVvS9CJIiQUZWODw69g7s23I55f87BY1sfxubs/7oVm8FgwPa8rZjoP7lHRtPpaKSNM70Kd+btMFmeWp6CjVnrMT/udozzmwAPhQc25Ww863iIqInVevzdfffdeOKJJxASEoK777673W0FQcBHH31kpchoICmsLWBvPzLyVHoi3CUCu/N3YkbQLFuHc86oaCjHretuxI2xt+DKQdfYOpx+o7S+BEO9hts6jB7n6+CPo8WHu7VvankKjpQcwrPjl0AkiDDaZwz2FuzCrYPv6NkgLahSV8HJzHA0RNR3RboOwvszPsLPKT/gy+OfIdAxCOeHXNjl4xTWFuCvtJUQyfS4O+6BXoiUyLL1WetgL7XHBP9JkIvleHbcEjyxfRE+O/YR7h66sEfPpTfocaj4AOaGX9ql/UZ4j8IvF//ZbgLOU+mJd6d/iP8dfBtL972KYyVHcVXUtQhwbNtbT2/Q49ukr/F90gqM9hmLxWOehs6gw9qMf7Aq7U+sy1iDQa5RyFZl4ebYW7t8nUREtjDEIx4rEr/ssEfUQFelrgIAsz3+gKbhPgdS4k9v0CO5LMnYHnJR2MX4Nulr/JO+CjfE3typY6jUVXhh1zMIdAzCm1Pfg53EDvWN9ThZkYqkskQcKErAa3tfhAGGLrd3pVWeQmFtYZv5enuLs9wFQz2HY1vuZswNvwRAU/Lx4yMfIsQpFBeGXgSRIML0wJlYn/Uv7hm68JwuL0Q9xWo9/mpra6HT6Yz/3d7/1dQMrO7dZD1NiT8/W4dBfcgEv0nYX7gXjfpGW4dyzliR+CVqtbX4+9Qf7PXXSXqDHmX1pfBUeNo6lB7nZ++Hgtp8GAyGLu/7a+pP8HXwM1ZIxvqOR1plGkrqSno6TLNUGhWc5Uz8EfU3IkGEa6NvwAUhF+K9A28bewp1RnJZEl7a/TxuWXsd1qSvwsrkldiTv6sXoyUypTfosSFzHaYHzoRcLAcADPceiXuG3o/fT/yKDZnrevR8aZWnoNKoMNJ7VJf37UyvO5lYhkdHPYGFwx/E9rytuHXdjVi05QH8l7UeGp0GAFDZUIEnti3CD8nfYP7gO/DSpNfhJHeGq50bro+5Cd/N+QUvTHgZDjIHOMtdMMLb8lyERER9yWCPeGh0GpyqPGnrUGyqUl0JAB30+Bs4bcHZqizUamuNU1Q4yZ1xfshs/JW2ElqdtsP9dXodXt7zAuoa67Fkwiuwk9gBABQSBeI9h+Ha6BuwdMrbmBV8Ad7Y9wr2F+7tUnzb87bCUeaIYV4jun5x3TQlYDqOlBwy9nrckbcNx0uP4a6h90IsEgMAZgSdhyp1JQ4WHbBaXEQDmdXS599++63Z/ybqSYW1hRjnN97WYVAfMs53Ar5N+hrHS4+afanR6XUoqS9GUW0hCusKUVRbiOK6ItTparFk1nMQILdB1P1XZlUG1masxpSAadiWuwWHiw9iRDcaks41FQ0V0Bn08BiIiT8Hf6h1apQ3lMNd4d7p/Qpq8rE9bwvuG/agcfiR0T5jIRIE7Cvcg4vCLu6tkI1U6io4MfFH1C8JgoD7RzyM9Ko0LNn1DJbP+sxieTYYDNiRtw2/nfgZSWWJ8HPwx33DHsSFEXPwwp6n8NnRTzBy1tgeGQqJqCOHig+gtL60TU/VSyMuR1rVKbx74C0EOgUj2i2mR853sCgBcrEcMW69N3+uIAi4NOJyXBg6FzvytmFN+mq8vu8VLDv8PqYFzsDu/J3Q6hvx2uS3zL43ikViTPSfjImnhwojIuovIl0GQSqS4ljJkR57bvdHVcbEn/l3sYE21GdyeRJEgoBot1jjsnkRV+Cf9FXYmrsJs4IvaHf/z499jCMlh7B0yjvwtjCqmUgQ4ZFRj6Nao8KLu5/DG1PeRYx7rNltW9uRtw3jfCdYtVfdRP9J+ODQO9iRtx3nh8zGZ0c/whifsRjlM8a4TbhLBIKcgrEpZwPG+I61WmxEAxVrr9SvHCjaj6LaQrPr9AY9iuoK4csef9RCpOsguCvcsdvM1/q783fiun+uwE1rrsWjWx/CW/tfx6q0P5GlysS+gr34JfEXG0Tcv31+7GN4K32weMzTCHYKwer0v20dUr9QWt/Ug81T4WXjSHpemHM4RIKApfte7tKcBr+d/AUOMieThk9HmRNi3QdbbZ6/Kk0VnDnUJ1G/JRfL8fz4l1DfWI9X9i4x2ws9rzoXj259CC/ufg4SkQRLJryCr2Z/h0siLoNCosDCMQuRWZWBTdkbbHAFdC5an7kWgY5BbRqIBUHA/cMfRqTrILyw62lUa1Q9cr4DRfsR7zkUUrG0R47XHplYhhlBs/DWtPfw1ezvcGHoRdiRtw1+DgH4aNbn/FiMiAYcqViKGPfYc36ev0p1JQS01+NvYA31mVR2HCFOoVBKlcZlIc6hGOUzGr+f+LXd0XA2ZW/Abyd+wV1D7+uwR55EJMHT415AuHMEntmxGFmqzA5jy1JlIluVhckBUzt9PT3B1c4N8Z7DsT1vC/44+RuK6gpx59B7TbYRBAEzAmdhZ9521DfWWzU+ooHIaqn9r776qtPbCoKA+fPn914w1C9Va1R4dseTmOg/GU+Pe77N+rL6MjTqG+Ft72uD6KivEgQB43wnYHfBTtw99D4IgoAabQ0+OvwB1meuw1jfcbg04nL42PvCS+ltHFJp2eH3sDJ5JS4LuQYi6z0q+7WDRQnYW7AHz4x7ATKxDBeFXYxPjixDRUM5XO3cbB1en1ZcVwSgaS6cgcbb3gevTX4Lr+59CfduXIDnJrzU4deuVepKrMv4B9dEXW8c1uSMsb7j8X3yN9DoNJCJZb0Wt0anQUNjA4f6JOrnvO198PS45/Hk9kfxdeIXuG3wAgBNPf5/O/EzViR+CXeFO5ZOedts0iHeOx4T/CdhReKXmBowwyrJETp31WhrsD13G26Ou9XsMJoysQzPjn8RC/69BR8fWYbHRj95VudT69Q4XnoMtw1ZcFbH6Y4Ax0AsiL8HC+Lvsfq5iYisabBHPFan/w2DwdCpIZIHoip1JRxlThZHT7CX2iOvJtfKUfWepLJEDPGIb7P8soir8PSOx3G87JjZ9acqTuKt/UsxK/h8XBZxZafOZSexw0uTXsMjmx/Ak9sexYfnfwRX1zCL2+/M2w47iR1Geo/u/AX1kCkB0/DhoXeRUp6MueHzEOwU0mabGUGz8HXiF9idv7PLcxcSkSmrtWYvXbq009sy8UfmbMreCK1ei135O1CnrTP5cgYACmvzAQA+SvPd4OncNc5vIv5JX4Xs6iyU1Zfirf2vo0Zbg0WjFuOCkAvNvnzPi7wcqzP+wtacLZgewJeNjugNenx6dDli3eMwJWAaAGBW8Pn47OjH+DdzLa6NvsG2AfZxpfUlkIqkcBqgvctGeI/CR7M+x0t7nsPDm+/DvcMewNywSy1WfP9O+xMAcGnEZW3WjfEdhy+OfYojJYcw2qf3hv84MwG9k8yl185BRNYxwnsUbht8Jz4/9gkGuUbB194Xb+1fivSqU7gs8krcEnc7FBKFxf3viL8Tt625GWsyVuHSiMutGDmda7bmbIbO0IiZQedb3MZD4YE7h96LdxLewIygWWfVcJdYegxavZY97YiIetFgjyH4Iflb5NbkINAxyNbh2ESVuspibz9gYA31Wa1RIVuVhWuirmuzbpTPaAQ6BmHliV+NiT+DwYBMVQb2FezBn6d+R4hzKB4a+WiXksSOMie8NuUtPLTpXjy+ZRG+ueJrWGry35a7BWN9xvfqR7SWTPKfjA8PvQsBAm6OnW92G18HP8S6x2Fz9kYm/ojOktUSfykpKdY6FQ1Q6zLWYJBrFE5UpGJX/vY2Y2IX1hYAAHzY449aGe41AjKxDK/seQEZVRkY6jkcj41+wuJY6QAQ7ByCMf5j8OfJ35n464SNWf8irTIN701fZnxBdZQ5YWrgdKxJX4Wro67j3EjtKK0vgYfSc0B/Aeqp9MTbU9/HJ0eX4/2D7yKx7DgeGvFomx59DY0N+PPUSswOvchs5TDUKQxeSi/sLdjTq4k/laYSgOV5KIiof7k66jqklCfj9b0vQ6vXIMgxBP+b8VGn5tsJcQ7FrOAL8F3SCpwXPLvNx2dEPWV95lqM9B7d4QgAs0Pm4L+sDXjvwFv49Pyv201ct+dgUQJc5C4IdbLcM4CIiM5OrPtgiAQBx0qOnsOJvwq4tJv4c0CNtsZ6AfWi5LJkAE1/99ZEggiXR16FDw69g3UZa5Bcloh9hXtQWl8KmViGEd6jcP/wh40jUXWFh8IDr095Gw9vWYhF6xfhlQlvthm9qqAmH2mVp2z2YbarnRsuj7wK4S4R7SaCZwTNwkeHP0CVurLd7YiofRy/jvqFtMqTOFV5Ei9OfBW/pP6ITdkb2yT+CmoL4CJ3adOITCQXyzHGZxz2Fe7BfcMewCURl3UqCXXt4Gvx4JqHkFqegii3aCtE2j81NDbgq+OfY0rANMR5mL7cXhR2CTZmrceh4gM2GUqivyipK4GnYuAN89maVCzFwuEPItY9Fu8kvIlDRQfg5+APF7krXO1c4SJ3RUl9MWo0KlwZebXZYwiCgLG+47GvYDcMwx7otWRpc48/p145PhFZlyAIeGz0k3hlzwuIcY/DNVHXd2nYzpvjbsXmnP/w56nfcX3MTb0YKZ2rcqtzkFSWiKfGPtfhtoIg4OGRj2LB+vn4+vgXuGfYwm6d82DxAYz0HjWgPzwiIrI1e6k9Qp3D8duJn7G7YCeq1SqoNE3/V6NRwVPphWi3WES7xSDaLRYRrpHdSvz0ZZUdJHDspfao09YMiOFQk8sT4SR3hr9DgNn1s4LPx1fHP8PbCUsR4BiIKQHTMdpnDOI9h511L7wAx0C8Mvk1PLbtYby57zU8PuoZk3/PHXnbIBVJMcZn3Fmd52zcNfS+DreZEjANyw+/j225W3Fx+KVWiIpoYLJa4i8xMRHh4eGws7NDYmJih9vHxcVZISrqL9ZmrIGrnSvG+IxDaX0pPjz0bpt5wwprC+Dr4GfDKKkvWzTqcWj0GrjZuXd6n0lBk+Bj74s/Tv2GJ8Y804vR9W8rT/6KSnUFbh9yZ5t1ce6DEewUgtVpfzPx147S+hJ4Kb1sHYbVzAg6D2HOEVifuRbl6nJUqSuRVJaHSnUlKhsqMCv4gnaf52N8x2NV2l/Iqc5GkFNwr8RoTPyxxx/RgKGUKvHK5De6ta+PvS8uDp+Hn1N/wNywS/hsoB63Pmsd7KX2mOg/uVPb+zsG4Ja42/Dl8U8xPWgmBnt1rf6sUlfhVMUJDl9LRGQFF4fPw7+Za6DX6+Dj4IsoWQycZE5wkDkgvyYfKeVJ2Jm3HVq9FmJBhGCnEEhEUugMOhgMeugMeugMOoQ4heLpcc9DIupf/Tgq1ZXtjs5lL7VHo14HjV7T75OeSWXHEesWazGBaSexw/szPoJIEPVKG2asx2AsmbYEj69fDF9lAG6Ou9W4bkfeNoz0Gd3nR69wtXPDSO/R2JS9gYk/orNgtV+KK664Ar/88gvi4+NxxRVXWHwAnvm6Izk52VqhUR+n0WmwKXsDLgy9CGKRGFMDpmHZofewNWcz5kVeYdyuqK4QPkoO80nmOcgcu7yPSBDh0ojL8PnRT3FX/L0miWZqUtFQjp9Svscl4ZfDz8G/zXpBEHBR2MX45MgylDeUdSnxei4pqS9GrPu59cFLiHMo7hx6b5vlnfnK88zwvXsLdvda4k+lqYJUJIVS0rcrRURkPddF34B1Gf/g59QfsCD+HluHQwOI3qDHhsx1mB44s0tf+1856Bpszd2Mt/cvxaezv+jSOQ+XHIIBwAgvzu9HRNTbLgq7GBeFXdzuNo36RqRXpiG1IhnplWnQG/QQCSKIRGKIBTH0Bj1Wpf2Bv9P+wOWRV1kp8p7R0ZCN9lIHAECttqZfJ/70Bj2Sy5I6HErT39F8b8Cecl74ebhtyCl8cfQz+Dv4Y2bw+SipK0FSWSIeH/1kr567p8wImoWl+15FUW1hu9P0EJFlVkv8ffPNNwgPDzf+N1Fn7czbjmpNNS4ImQOgqffFaN9x2JSz0STxV1CTjziPIbYKkwaoC8MuwpfHPsea9NW4IfZmW4fT56xI/BJiQYwb2/m3mRV8Pj47+jH+zViL62JutGJ0/YPeoEdpfSk8z6Eef+3pzNAucrEcw71GYE/BblwVdW2vxFHR0DQPRX8faoaIeo6rnRuuGHQ1fk75AfMiruxwHjaizjpUfACl9aU4P+TCLu0nFomxaNTjuHfjAvyY/D0enNzx8FlnHCxKQKBjEO9jIqI+QiKSYJBbFAa5RVncRqdvxDeJX2F64Mx+82GywWBAlbqqgzn+7AEAtdrafv2xcKYqA/WN9X3io94bYm9CjioHbyUshZfSG+lVaRALIozzm2Dr0Dplgt9kyMQybM75z5hI1Rv0KKkrRl5NLtQ6Neyl9nCQOcJB6ggHqQMUEgXr70QtWC3xN2bMGLP/TdSRfzPXIM59sEmvjhmBs/Dq3heRX5MHPwd/aHValNaXwFvJr0CoZznJnTAr6HysSv8T10Rf3++G1OhNJ8pTsSZ9Fe4ethCO7cyD5ihzwtTA6ViTsQrXRF/fqfkVzyVV6ko06hvhcQ7M8deTxvqOx7JD/0ONtgYOp78Q7UmV6gq42Ln2+HGJqH+7ctA1+PvUH/gm6UssGrXY1uFQH1XRUI7V6X/jqkHXdmr+8bXp/yDQMQjRbjFdPle4SySujroe3yV9g0sGz4ELOvch0cGiBIz2td0cP0RE1HW3Dr4DW3M348vjn1n9PUSr0+JA0X5syd2E/YX7EOAQgBHeozDCexRi3GIttpXUN9ZDq9d2OMcf0JT468+SShMhEgQMco22dSgQBAEPjXgURbVFeGHXM/BQeGCY14h22276EqVUiQl+k/DXqZVILD2GvJo8FNTmo1HfaHEfsSBClFsMJgdMxST/Ke0OL0t0LmALNvVpRXVFOFiUgEdavdCM95sIhUSBTdkbcWPsLSiuK4IBgC8f6tQLLo28HGsyVmNH3jZMC5xh63D6BL1Bjw8Pv4dgp1BcGt7x3DBzwy7Fxqz1OFiUgFE+/PijpdL6UgBg4q+LxviOx/sH38WBwv2YGji9x49fqa5s96tUIjo32UvtcWPsLfj4yIe4LPJKhDmH2zok6mP0Bj1e3/cyDhYdgEqtwn3DH2h3+4NFCdiauxkPjljU7a/Ub4y9BTvzt+LO1XdihMdojPAahRFeo0w+YNEb9EirPIX9hXuxv3AvCmoLMIrzLxMR9StOcmfMj7sdHx56D3PDLkWUW+8mmHR6HQ6XHMSWnE3G0biCnIJxYcgc5NXk4a9TK/Fd0gooJAoM9RqO8b4TMTt0jsnHvlXqSgDooMdf81Cf/VlyeSJCncP7zBx6UrEUz094EQ9suhfpVel4MPwyW4fUJZdGXI4sVQb0Bj1Geo+Gv4M//BwC4O/gD6VUiRptDWo0NajWVKNWW4MqdSUOFCfgy2Of4ZMjyxHhEonJAVMxJWAaAhwDbX05RFZnk8RfdHR0h5UazvFHALAhcx3kEjtMCZhmstxOYocJ/pPwX/YG3BBzMwrrCgCAX3NQrwhzDke851D8dWolE3+nrc9ch+SyJLw97X8Qi8Qdbh/rHocQp1D8k76Kib9WSutLAIBDbXWRt9Iboc6h2Fuwu3cSfw0VvTLZOhH1f3PDLsVfp/7Ap0eW4/Upb9s6HOpjfjvxMw4WHcC0wBn489TvmOg/CcO8RpjdtkZbg7f2v46hnsMxJ2xut88pF8vx2pS38F/+WmzL2IF/M9YBACJcIjHCeyTKGspwoHA/KtWVUEgUGO41EotGLcY43/4x3BcRETW7KOwS/JP+Nz489B7+N2O52RF1MqrS8eb+1zDCayRujJ3fqd7nrRkMBjy+7WEcLTkCXwc/zA2/FNMCZyDUKczYpqs36HGy4gQOFO3HgaIEvHfgTRwtOYRFo56AVCwF0PRBJQA4y50tnmvA9PgrS8Rwr5G2DsOEo8wJr0xaih+Sv8XUwGm2DqdLBnsMwafnf21xvbnhbudFXoE6bR32Fe7Bjtxt+DHlO3x1/HM8OGIR5oZf0ovREvU9Nkn8PfHEE20SfyqVCjt37kRxcTFuvpnzaFHTC8S/mWswNWC62a9lZgadh/+yNuBkxQkU1BRAJAjwUnrbIFI6F8yLuAIv7n4OaZUnEe4SaetwbKpao8Lnxz7BjKCZiPcc1ql9BEHARWEX4+MjH6K8oaxfj9vf00rqiiEWRHCRc1jJrhrrOx5rM9YYJ77vSZXqyj4xNwMR9T1SsRQL4u/GC7uewb6CvRjjO9bWIVEv0xv0eDthKQwGAx4a+ShkYpnZ7U6Up+Kr45/hqkHX4I74u1HeUIa39r+OT8//2mx95uPDH6JGW4NHRy8+698xf0d/PDjuQdwcdQeKqktwsGg/DhTtx8as9XC1c8Xs0DkY7TMWMW5xxsZYIiLqf8QiMe4b/iAWbXkQG7L+xQWt5ofdU7Abr+5ZAlc7N6w8+Ru25W7BgyMXYWQXe3nvLdyDoyVH8Oz4JZjsP9VsBw6RIEKUWzSi3KJxfcxN2JKzCUv3vYJKdSWeG/8SlFKlscefczv13eYef/038adSVyG3Ogc3xNxk61Da8HPwx6Ojn7B1GFajlCoxLXAGpgXOgFqnxqdHP8L7B9+GnUSOWcEX2Do8IquxSeJv/vz5Zpfff//9ePzxx1FVVWXdgKhPOlJ8CIW1hVg85iKz60d4jYKL3AWbcjZAKpLCQ+HJ+deo10zwmwRPhSf+OPn7OfXCZM6KxK+g0amxIP7eLu03K/h8fHr0I6zLWIPr++DLcG9SqavwwaH3cNfQ++Ch8DBZV1JfAg+FJ+c+7IbRPmPxU8oPyKhK6/GEfKW6ot15KIjo3DbBbxLiPYfi06PLMdJ7VKd6v1P/tSLxS2zIXAeJSIqS+hK8MOFlY++EM+q0dXh174sIcQrDrYMXQCSI8NjoJ7Fg/Xx8cmQZHh71mMn2ewp249/MtXh45GM9PmqJu8Id54XMxnkhs3v0uERE1DfEew7D9MCZ+Pzox5joPxkOUgcYDAasPPkrPj26HGN8x+PJMc+ivKEM7x14G09sexQzg8/D3fH3dWoec4PBgG8Tv8JgjyEWk37mTAucARe5C57b+RQe2/oQXp70enOPP5nlHn8iQQSFRNGvh/pMKk8CAMS6D7ZxJNSSXCzHfcMegLqxAW/ufw12EgUm+U+xdVhEVtHnWhkvueQS/Pzzz7YOg/qAfzPXIMAxEHEWfjTFIjGmBc7E5uz/kF+Tz2E+qVeJRWJcFHYJtuRsancy4YEurfIkVqX9gRtjb2mTwOqIg8wR0wJnYG3GaugN+l6KsG/alb8TW3I24a39r8FgMJisK6kv5vx+3RTlFgOxIEJSWVKPHlej06BWWwvXTlSKiejcJAgC7oy/F1mqTKzN+MfW4VAv2pqzGT8kf4vbhtyJpVPexsmKVDy65UFUNJSbbLf88PsoayjF0+OeN/ao87H3xV3x92FNxmrsK9hr3LZao8I7CUsx2mcMLgw1/5EjERFRexbE34P6xnp8l/Q1tDot3jvwFj4+sgxXDroGSya8AqVUiQDHQLw59V0sGrUY+wr24PZ/b8bGrH87PPb+wn04UZGKm2Lnd3n+2WFeI/Du9A9QUl+MhzYvREp5Euyl9h32NreX2vfrHn9JZcfhIneBrz2ni+hrRIIIj4x6HJP9p+GVPUuwv3BvxzsRDQB9LvGXkZEBvf7cahCmtmo01diWuxWzQ+a0+5IxI2gWyhvKsadgFxN/1OuGeY2AWqdGRlW6rUOxCYPBgA8P/Q8BjkG4PPKqbh3jorBLUFhbiANF+3s4ur7tQNF+OMtdcKAoAX+n/WGyrrSuFJ5KLxtF1r/JxXKEu0Qiqex4jx63St008oCLvO2cAUREZ0S5RWNm8HlYkfgF6rR1tg6nDb1Bj8LaAuwr2IvfT/yCDw69h/TKU7YOq19JqzyJN/e/humBM3FN1PUY4jkUb0/7H8oaSvHw5vtRWNs0z/iWnE34N3Mt7hv2IAIcA02OcVHYxRjlMxpvJ7yOao0KAPDhofeg1Wnx8MjHu9ygSkREBDTNEX9DzM348+TveHTrg1iftRaLRi3Ggvh7TEaTEQQBs0Pn4IsLvsFI79FYuu/VdpN/BoMB3yR9iVj3uG7PVxfuEon3Z3wEAQL+SV/VqZFU7KUO/SLxZ+kj5uSyJMS4x/F3vY8SCSIsHvM0RnqPwgu7nsHRksO2Domo19lkXMSvvvqqzTKtVou0tDSsW7cOc+d2f2JzGhg25/wHnaGxw7GXo91i4OvghwL2+CMriHCNhEQkRnJZIiJdB9k6HKv7L3s9jpcew9Ipb3d7WN1Y9ziEOIViTfpqjPY5N+ZE0hv0OFiUgLnhl6Jao8KnRz/CCO9RCHQMAgCU1pcg0vXcnjfybES7x+JAYc8mkivVFQAAFw71SUQduG3wndiWswU/pX6P2wYvsHU4KK0vxW8nfsKhogPIqc6BVq8FAMjEMkhEEqRXnsI70z5go1QnVDSU47mdTyHQMQiPjGpO0IW7ROJ/05dj8fZFeHDTvXh41ON478BbmBowvc08S0BTg+sjIxfjzvXzsezQ/zDRfwo2Zf+HxWOegqeSPf6JiKj7rhh0NdZlrkFudQ6WTnkH8Z7DLG7raueGp8Y9B5FIhPcPvotot9g2H6sATb39UstT8NrkN8/qfcHH3hfvTf8Qz+58Em527h1uby+1R42mutvn622ZVRn4/eQv+C9rA7yU3hjhPRLDvUZimNdwKCX2SC1PPuemNOlvpGIpnh3/Ip7Z8QSe2fEE3pz6HqLcom0dFlGvsUnib+nSpW2WyWQy+Pj44Oabb8a993Zt3igaeDZlb8Qo7zFwV7T/ciAIAmYGnYfvklbAl4k/6mVysRxhzhFIKk/EJbjM1uGY0Ol1yKhKR11jbbsv+y19dfxziAUxLo24rMMv8Go01fj06EeYEjANI7xHdTtOQRAwN/ySpuGw6ss6LOMDwamKk1BpVBjpPQqRrlE4WHQAS/e9gv9NXw6RIOJQn2cp1i0Wf5/6Ayp1FZzklueN6IqKhtOJPw71SUQd8FJ64cqoa/Bb6s+YG3YpvM6yB3ejvhFiQdzlhraSuhL8lPo91qavhkwsw7TAGbggdA4CHYMQ5BgMT6UX9hfuwzM7FuNA0X6M8hlzVnEOdFqdFi/tfh4anQZLJr4KO4mdyXpfBz/8b/oyPLn9UTy74wl4Kb3w0MhFFv9unkpP3Df8ASzd9yp25u/ABL9JmBl0vjUuhYiIBjCZWIZ3p38AAQJc7To3WskDwx9BSlkyXtmzBP+bsRwyscy4zmAw4LvkrxHrHoeR3qPPOj4XO1e8P+OjTk310ZNDff5+4heU1pdAKbWHUqKEvdQBSqkSrnZuGOw+pNPvWQaDAYeKD+C3Ez9jf+E+uCvccW30DahUV+Bg0QGsSvsLIkFAsFMI6hvrEese1yPxU++Ri+VYMuEVPLn9UTy9YzG+mv0tHGVOtg6LqFfYJPGXkpJii9Ma7d+/H1988QWOHz+OkpISLFu2DLNmzbJpTNSsrL4MiaXHsGj0E53aflbQ+fj9xC8Id2GPGep9Me5xSCjcZ7XzPb/zaSSVHUegYxACHAPh7xCAIKdgeCm9kFudi5TyJKSUJ+NERSo0Og0A4KvZ35n9cq+l4rpi/JD8LQQAv6T+iDlhF+OKQVfDW+lt3MZgMCCpLBHrM9diS+4mGAwG3DX0vrO+pplB5+HTox/h38w158QXcQeK9kMhUSDGLQ5SsRSLxzyNhzbfix9SvsW8iMuh0Wk41OdZODN5enJ5Msb6juuRY1axxx8RdcG1UTdgbfpqfHn8Uzwx5pluH6eorgiPbF4ID4UnFo95Gn4O/p3a56fk77Aucw0UEgVuiLkZl0ZeDgepQ5ttx/iMRYx7LL5O/AIjvUez1187lh3+H5LLE/Hm1P9ZTOa62rnhrWnv48tjn+KCkDlwkDm2e8yZQedjZ94OHCs92m6SkIiIqCs605uuJaVUiWfGvYD7N92NL459inuGLTSuO1C0H8llSXh18hs99jslCALEgrjD7eylDsYPMM9GeUMZPj6yDB4KD+gNetQ11qGhscG4frTPGDwyajE8FB4Wj6E36LE1ZzN+Tv0eaZVpCHMOw+Ojn8S0wJkmcxUW1RbiYPEBHCxKgKPMGVFuMWcdP/U+pVSJ58a/hFvX3YDvkr4xKQNEA4lNEn+2VldXh6ioKFxxxRVYuJCFu6/ZmbcNIkGECX4TO7W9v2MA/py3xmQMc6LeEuMWg79OrezR3kWWVDSUY3f+DkwKmAqJIMGpypPYkrMJ9Y31xm28ld6IdovFrYMnY5BrFJ7d+SQ2ZW/EzXG3tnvsrTmbIBVJ8cUF32B91jr8dWol/j61EtODZmFO6FwcKz2K9ZnrkFeTC2+lNy6PvAoXhFx41j0ZAMBB5ohpgTOwNmM1ro2+YcCX3YSi/RjqNdxYQYhxj8V10Tfhu6SvjT392OOv+3zsfeEsd0FyWWKPJf4q1BVQSpUmX78SEVmilCpxS9zt+N/Bt+EodUK851DEeQzuUkNcZUMFnti2CCJBhPKGMty94XbcM+x+i/NdF9YW4Mfk77A+ay2UEnvcEncbLg6fB3upvcVzCIKA+XG3Y/G2RdhbsBvj/CZ063oHupUnf8U/6avwyKjHMdhjSLvbOkgd8MCIRzp1XEEQ8Oz4JajV1vDLciIisqkI10jcFX8vlh1+H8O8hmO830QYDAZ8m/Q1ot1iMMrb+iMD2EvtkVudc9bHOVJ8GADw4cxPjSMM6fQ61DfW4VjpUbx34C3cuX4+Fg5/ENMDZ7V5zzpYlIDPjn6MU5UnMcpnNJZOuRfDvUaafR/ztvfBhaEX4cLQi846brIud4U7ro+5CV8f/xxzwuYi2CnE1iER9TibJP7+/PPPLm0/b968Hj3/1KlTMXXq1LM6Rm12FgBA5uoKqWNzxU1TUQ5tdTUEiQRKv+avdPWNjajPzwMAyD08IFE2V8obSoqhq6+H2M4Odl7NvW106gY0FBUBAOy8fSCWy43r6gsLoNdoILG3h9y9+SuVxtpaqMtKAQAKP3+IJM1/4rrcHBj0ekidnCFzcTEu16qqoKmsBEQC7AOCjMsNBgPqcrKbrtPNHVKH5i+H1eVlaKypgUgqhcLXr/k6tVrUF+Q3xezpBbFCYVz3+ZY3cfmgi6CQuEPq1tzIrauvR0NJcVPMPr7YnrcNw7xGwFHmhPqCfOi1WkjsHSB3b2480dbUQFNeBgBQBgRCJGpOHNTmZgN6A6TOLpA5NydmNJWV0KqqIIhEUAY094Yy6HSoy8s1f51lpWisrW17nRoN6gsLmq7Tyxtiu+bhfxqKi6BraIBYoYCdZ3OSpLGuDurSkqbr9PWDSNr8lVBdfh4MjY2QOjpC5to8PIO2uhqaivKm6wwMMnnRqM3JBgwGyFxcIHVqeZ0V0KpUEMRiKP0DmmNu5x40XqdcDoW3T/PfRq1GQ1Fh03V6e0Msb77O+qJC6NVqiJVK2Hk0/z0b62qhLrVwD565TicnyFyah9Az3oMA7IOCjctN7sFulTVPSJRK4zqLZa2hAQ3F5staXUE+tPVqY1mLOT10Q3LuYQyWhgAAlP4BEMTNX7BZKmuaqipoqyrbljW9HnW5TS+4Le/BPQW7YV8PLPC4Ci4O7lD4+sFgMKC8oRwFlTlwrxHBSe5sUtYm+U/B7uPrcLnDdEgUSth5Nd+DLcva1syNGOs7Hr4Ofk2NhU7TsDVjPf7OWIeNWeshE8swOWAq7o++B4NE/hAJIigVzf9mwNmVtQt9zsP6zHU4ULQfo33GWixrJvdgd8qapXuwTVlTQVPR9HVhm7J25nnfqqw1VJRBq1JBLJVZvAf1Lg5IKjuGu+Kbeko2lJZAV1eHK90vwD6XPfjg4LsAAHeRs/E8bZ73p8tam+f96bImlojg7Gg652RdXi4MOp3lsiYIsA+08Lx3dYPUsbnXgsWy1uJ5352ypvDxhUjWnFhrft6bXqfJ895CWRtiF4Hk8sTmmLtY1gBAXVaGxtqm37UqdSVc5E3/bibP+1a/aw3FxdA11Le5B01+11o9743X6eAAuZuF37XW9+Dpstb2eW++rJk8B909ILE387yXyaDwaR4iu73nveWy1onnfeuyplJBVVmMGlU97PxMeyZbKmvderc6Xdba/q51492qvevshbLW3rtVp8taq3cr82WtnXerVmXN+Lxv/bt2+h7sblmz+G7VpqyZvwe7Vda69W5Vifryinbfrc7zmoaMiHTsKdiJP0/9DvtaAwLEngj3ikZc1CTMCDoPEpHEbFmr09bh6R2LYSirxJIRz8LVxQdf5P6IdxLewO78nXgg5l4oanQAgApHA3469RM2ZK2Do8wZt3ldhen+0+Hk6gVZi6SfpXer4V4jMV4YhN+2LceIOXGQ9VBZ69P1mFZlrb16zIaEn/DzsU9xzfCrTBrxmsuawuK7VWfKmkgQwU4jQm1h0/NOGRAIoQv1mDbX2eLdSunlCbi2fN53oqyxHtP1ekyb37W+W4/pybJm8d2qm20GNfmFEFcq0Ch3BKTNMRvfrdora5ae9x20GXSlrLVXj7H4btXT9ZhOl7V26jEdlbUeebdqWdbM12N6tM2g3XerTpa1brxbNdbXoyY7C7pGfdvrtFCPaVnWeqvNAGjned9O+1xDcTFmyUbimP0IvLX/dXx83pfIrs7EycLjeDbqUdTlZPdoPaYzZc1eao86TY2xTtCteoyXN46UHEKAYyDcFe4mZc3B0wvj/SZisMcQLNv9Fj5Z9yL2e6/FgplPws3BEycrTuDzYx8j7UQCBjlF4M2Rr2BY+KTm6+xGm4HV6jEt2gwk3p2sr/XrNoMeqMdUVWG23VhsV/+Bj498iFcnNc1p2fP1mB5sM2jv3aqvtBl08Xkvgh4KvTcgaj5Wy7LW8t0K6J2y1uv1GGNZs1CP6UJZO/Nu5ek5GJ1hk8TfE088Ybw5DQaDcbmlZT2d+OsJJz/+AAAQeMll8J402bi8YM8OFG3fBrmrK4Y8+axxubq61rhP+M23wnVw89ejRRvXoeLYUTiGhSPq7uZh9OpzCnHy4w8BADEPPgJ5i8pP7sqfUZubC/cRIxF67Q3G5VVpJ5Dx0/cAgKHPvwiJXfMDMuObL6CtqYHvjFnwnz3HuLzk8AHkrVsDkUyGES+/blyu12qNMQdffhU8x403rsvbsRUle3bBzssLgx9tHpKzoaLKuE/kbQvgHN3Uzd1gMKBozTps/nkXho66EBG332ncp64wDyc/+7jp33PhXThWehgPjVoEiUSE7F9+QH1RITzGjEXIldcY96k8mYzMX38GAAx/6TWIWxSo9C8+gU6thv8FF8J35nnN/84H96Fg43pIlEoMe+Fl4/JGrdoYc+g118F9ZPM45jlb/0NZwn4o/fwR+9Ci5phLyo37RN11LxzDI4zr8lf9AVXaKbjExiFi/u3G5TV52Tj11ecAgCGLn4KkxQMi+8dv0VBWCq8JkxA073Lj8vLkY8j+cyUAYORrb0IQN1dW0j5dBr1Oh4CLLobP1OnG5YX7dqNwyybInJwQ/8wLxuXaugZjzGE33Ay3ocOaz//fvyg/fAgOQcGIXvigcbk6v9i4T/TCByFv8cDN++s31GRmwjV+KMJvvMW4vDozHWnfrQAAxD/zPCR2zQ/izG+/hKaqCt5TpiFw7iXG5aXHDiP3n1UQRCKMfP0t43KDwWA8f9Cll8FrYnNZy9+1HcU7t0Pu7o4hi59ujrm6xrhPxC23wSWu+WFYuH4NKhOPwzE8AlF3Nc8lWl9cgJMfLwMAxD64CHJ/f4hP/1tn//ozanJz4D5yFEKvuR6BzgFwsXNG5rHtkO9bBQAY9sJLkMibfzzSv/4MjXV18J15HvwvuNC4vORwAvL+XQuxTIbhLcqaTtPYXNauvBqeY5p6Le0p2Imphd4o+moFVF7eiHt0MQDAW+oJp3o9Ej9YiiIAkXfcBedBUQCA80LPx5+/rMaRhNfhN3gUIluUtdqCXJz8/BM0NDYgP/YErhlyIySSpuss+f13hBYXYcmY61E9JRoRrpGwl9qjZN8epP3W9G8z/OXXTcva5x9Dp9G0LWsH9qLgvw1ty5qm3nidIddchzCXMKzNXI3xAeORs2Ujyg4kQOkfgNgHm7+c1xS1KGt33wfHsHDjurxVf6A67RRc4gYj4pbbjMtrcjJxasWXAIAhTz4DSYuKcdaP30BdVgaviZMRdGnzPI3lSceQ/dcfAICRS982eYE69ekyGPR6BFx0MbynTMOJilSsz/wXeav/xuAsKeLDxiP+6eebY65rvs6G2SOhM+gw1n8sJBJR0/P+6BE4hITg6RuexZ3/3g6xSATH2kacOPO8b13W/vgVNdlZcBs2HGHXNw+NqspIQ/r330AQBHi/uRTiFr3TMr/9EhqVCj7TZiBgzlzj8jNlTSQWY8RrbxqXG3S65rI273J4TWiu4OTv3IbiXTtg5+6BwYufMi5XV1U3l7Vb74BLTKxxXeG//6AyKRFO4REY1LKsFeXj5CfLAQCxDz8KZYuX5Zzff0Zdfh7cR41G6NXXGZdXpaUi4+cfAQDDlrwCibz5hfhMWYuPsccKx/0QiZsaVY1lTS7H8JdeM26vUzf/roVcdQ08Ro81rsvdvgml+/ZC4e2DqolauCpcIZGIUF/W/Ls2aMHdcIpsTrLmr/kLqhOpcI6OQeRtC4zLa/OycfLLzwAAgx97ArIWL/hZP3+HhuJieI6bgODLrzQur0hJRNbKXwEAI15ZCpGk+TrTPv8Yeo0G/rPnwHdG89DkRQl7ULBpI6QODhj63IvG5Vq1pvl37dob4D5iZPO/8+YNKDt4APYBAYh5oLmsqYvKmsvaPQvhGBpmXJf390pUp6fBdUg8wm+ab1xenZ2JtG++AgAMefJZSFybK4xZ338NdUUFvCdPQeDF84zLS48fRdI/f6GxUY+RS99GS6c++RAGgwGBF18K78nNH2gV7N2Fom1bIHNxQfxTzxmXa2rqmt+tbpoP1yHxzf82G9ah4lhTWYu+9wHj8obcIuM+Mfc/BHmLF+zcP35FbU423IaNQNj1NxqXq9JPIv2H7wAAQ58z825VXQ2f6TMQcGGLsnb0EHLXrIZIIsGIV98wLtc3Nj/vgy67Al7jm0c3yN+5FcW7dsLOwxODH3+yOeZKy2WtYN1qVCUnwSkiEoPuvMe4vK4oHyc//QgAEPfIY5C1qLDl/PYj6goK4DF6LEKuavFudSoFmb/8BAAY/uKrELe4BzO++gyN9fXwO+8C+J13gXF58eEE5K9fB4lCgWFLXjEu17W4B0OuuhYeo5u/Gs/dtgml+/dC6euL2IcfMy6vL62wXNb++QuqkyfgHBOLyFvvMC6vzcvCyS+b3q0GP/4UZB7N71ZZP32LhpISeI6fgODLWpW1P34DAIx49Q2IJM0NA2mffwS9Vgv/Cy+C7/SZxneBsr27kPffRkgdHTH02SXG7bUNzdcZdv2NeHh0U5kqrSvBoRXLUbX/MAocjuDt6p1YeepXPDLqUQTXOzW/W917P4RAf7y45xnk1eTg6fKJUH37K8RD4vHETU9hUuAkvL3/Dbzwy524NMUDVeoqfD+xCjIXV9wzfCHmhl+CE2+8idzKz+E9ZSoC515qjK0s8ShyVv0FQRDalLVZewQklqZjj/0PmHFZc93DUj3GpKzdPB+ug1uWtbVN9ZjQMETd0zySikk95oGHIW/R0JD7xy+ozcmB+/CRCL2uRT0m/SQyfjxd1jpbjzlyEHlr/4FIKsWIV5rnkW9Z1trUY3ZuRcnuXbDz9MTgx5rL2pbEdcj45CNco/TG+TPON74jAS3KWuQgDFpwt3F5y3pM3COPQ+bT3ECX/euPqC80U9baq8d8+Sl0DQ3wO382/GY1zwFYfHAf8jeuh0ShxLAl5usx4ddeD69Ab+N9m7v1P5Qm7IPSzw+xDz3aHHOLesygO++BU0TzdAn5q/+E6tTJdusxrctacz1mIoLmXWFcXp5yHNl//A6gC/WY/btRuNlMPaZe3aIecxPchg5vPr+lekxBSXNZu+8ByINDjOs6VY95+jlI7FyM6zK/+wqayso29Ziy40eQs/rvdusxbdoMdu9A0Y5tkLu5YcgTzcMDt1ePKdqwFhXHj7VtMzBTjznDcptBKjJ++gHA6XqMpLmspa/4HI21tWbaDMzXY0zaDK64Cp5jW5S17VtQsnc3FC3qMUBTm0HqsvchkYgQfusCOEQ0P+8L1v6NqtQUOEdFm9RjTMraosWQeTc30J1pM/AcOw7BV1xtXF5xIglZv/0CwExZs1SPsdRmoGlo8W51PdxHNM95bqnNQFNsuR5jsc0gNwunvv4CADDkiachaTEfurGstVePef0tkwTnqU8/hEGnb1vW9u5C4dbNkDk7W6zHtG4zKP7vX5QfOQyH4BBE39fi3aq9NoM/f0NNVibchg5D2A03G5efqccAltsMfKZOR8BFFxuXG9sMxCKMfK1FWdPrO2wzaFOPUbUoa/Nvh0ts87xs5uoxYrEINbm5SF32PgwGA2IfWgR5i4bldusxxrL2stl6jO+s8+F//mzjcottBi3qMS3bDAAgb8dmlOzdA4W3D+IWPW5cXl9WafHd6kxZuyoiAsneOVi6/yU0GnQYYQiG4vdtOIltbeox2T9/j/riIniOHY/gK64yLq9ITUTW7+brMRbL2ul6jMTeHsOefwkA4Ch3hLahxnJZs1CPad1mcLT0EEZ4j4REImquxwwegvCbm0ZFcpW4YKHPtdj7Zw4y9iTgwYbbMCh4OLbnbkWgYxAW5g2DS7oM3g7lkEQ1l6eyxGPI+bv9NoPAuZfAe8q05n9nS/WY2hbvVjfeAtf4oc3/Ni3aDEzqMXnFFusxLdsMIm9q+l0Ti0WoyziF9O+/BQAMfXaJybuVsc2gdT2mM20Gluoxrcpae/UYY1lrXY8pzDPWY9q2GfyEuvx8eIwag5CrrzUub1mPad1mkPHV52isr4PfrPPh16KsFR/aj/z163Cl3h2vyffjQMlejPOb0H6bwel6jMLHF3GPtKzHWC5r+f/8aaEe06LN4PEnIWuRLLNYj0lNam4zaF2P+cy0HnNGp9oMrrsR7sNHNP87b9qAskMHYB8YiJj7HzYuVxeWWm4z+Ot3VGekm2kzyEDaN18DAOKfeg6SFomvrO+/hqayEurzZ8Hr/OYP7soSjyLn7z8BAKPeeActWW4z2ImibVshc3FF/FMW6jFt2gya6jEOIaGIvvd+4/L22wzM12NUGR23GfhOnwn/C5uvs1P1mMuuhOf45lFaztRjQj77BJ1hk8Tfb7/9hgcffBCXXnopLrjgAnh4eKC0tBTr1q3D33//jffeew8hISG2CK3TpNKmwuXgIIdriy8ry5RySKViyORSk+UNBrVxHycnhck6hUKGGqkYdnam+4jKFMZ9nJ0UcGyxTi6XQiMVQ6GQmeyjcbQz7uPqYg+pQ/M6mUwCSMWwtzeNudqhaR+xVGyyXKfRWLzOEqUMUqkY8lbXWadRWrzOOO9YFBQehCDRmyxHi5gTVUcgFoswN242XBX2kMslaJSKoVSanr/BocV1utqbZN9lMgka9Y1trrPSvulvI5VJTJY3yoUW12lnsq5IIYNKKoa81d9GWmd6nS4t1tkpZKg387fRt7hOZ2clFC3WyeQS6KRiKFvFXNfiOl1c7SFq8dWKVCaBvrFtzBWn/zayVtepETUaj+XoaNfmHpSauU5xldLkHnRqeZ1yKdRSMZStrrOxxXW6OCshdzG9Bw1m7sGa09cpiEQmyw0Gg8W/TdmZe7DVdTboG5qv00xZqzVT1gSnFmXNWQGHln8bmRjSVtc53G8Y8k/kYrC0qYLi4mIPqb3pdQrattepOlPWWsWs00ibYz59nfXaehwuPYB7vcZAWquBXG66j1xtvqzNcJ6MDTIlKqrLENbqb2M4fZ2F9eWwlytxYewsKKRNXyKdKWuO9gqMjGp+gWtT1lp8bSWVSSAy6GDf6m9jqaxpZc3PTidHBa71vRpv7XoLjbI6KE+XNbtW1ymtUVgua3ZSNJgpa7oWf08XZyXsWv67ySTQS8WwV8osljVXV3uTl3ipVAy1Vov9Jbux+r9vkF6RDnelO6a4BqHyZDLUhnqTY6kFrfFYybWn4O/shyFB0RAEAcozz3u5FMNC4vDMtKewJXMLXF0cmq/TWWlS1uR2TWWt9XVqW5S1M/8+ZxjLWqvrPFPWRBLTf2e9TmexrJXan/ldM92nvrGuxd+z7TOlViqGXauYTcua0qSsye2k0Jp5pqhb/m1clCZfCZ4paxGeoVDXb0eVUIIw1zCoTscsaV3W1BKL11l8+vdbLpegAZXwdfaCq6s9ZA0Ky9dpJzX7vDe0uk5lq99vnVQMZau/Tb2DvPm+dVGalDWZVAydQdwm5jNlrfXzXittfna2ft4XKsz/fkuqTd85nLta1lxMy5pMLoXezO93rbLpuiQS0+c90FTWDAZDm+ssP32dbZ730Fi8ToVCaixrJu9W5QqLZc3OrundqvXfRutoep0yR9PrRIMY9q2us/p0zCJpq7LW2Gi5rLW4Bztd1uykqDPzu4ZW96B9q3tQa+Y61a2uU9LiS1WpTAKhse3vWpWFstbYILb4tym28A4pq7f8Dml3pqy1uk59q5gVZspa679NvaPp877l15gyqRg66OHQ6jrtFBberST6FtfZHLOrqz0a/WJRlFuDEcHBuPqqS/HK9lfw0JaFuMbtPAwXGyAWSeDgaIelh5ciuSIRH1z0AUQ/bkFVabWxrF3seiEmRozFO18/grSqA5CLZVg4diEuG3M95JKmd98s+ZnnfauydubdShDalDV3e1e41bpga94mXObyqHHIbYv1GJOy1oP1GGUP1GNO34Ot6zF6rbZFWZO3KWuVre7BPbl78OHh93CVvSeiPAbB2UnZubJm8n6vaFXWztRjTK+zw3qMznJZk8pMr7NlPUZp33ScM+8DRRbKWut6jLmy1vo6W9ZjWpc1Yz1G2Y16TKvrrFCa/13TiHXt3oNm6zEq0+s0+V3rTD3Gxd6kHiM/q3pM6zYD83+bjuox5sqa4Kw0uQcdzJW11m0GDqbX2aYeo+lKPaZlm4Hp8765zcB0nzqN0phYb30eO4Ws22Wt9XW2V9aM9ZhOthm0rMc4drbNoLbrbQa6TrQZdFiPaZH4k0kl0It0Ft+tWpe1lvUYS20Grf824krT533rd6uO6jGW2gxat40Y6zFi0+egQa+3eA+eKWtt6jG6+nav01w9prIIxvu2s/UY07Km7FybwZnftXbqMa3vwWKF+bLWXj3G7vTvmrODI9644HXctfou6A16vBH/CEQndhivU2mmrLWtx5heZ3fbDLxd3U2fgw6dq8e0bDPQSRtQUJePB8Lvh6urfbv1GB8nL7g7uKLaT4mk2gw8N+1ZXBJ1CRJOLEF9aWmb66xtUV8z12Zg0AttrtNSPaa9stayzcDk3arCcj2mZZvBmfcAJycFGlrXY5zalrXW75A1Z+oxXWkzUHa9zcDOTmr2mdK6HtP6d01r5h2yZT2mbZuBuN16jJ+dD8YHueCz4x9hVvQ0iBrbazOwUNbq2y9r5uoxnWkzaFOPaXkPuihNeglaqsd0q83AwnuKRNX1NoPGFn8bZ3NtBqefqy3bs2rtTctaSxbbDCzUpdtvM7BQj2mnzcBSPabdNoPT9ZjWv2sW6zEt2wwc25a1SmnzO3VHBEPL7nVWcuutt2L8+PG4884726z75JNPsGvXLqxYscIqsURFRWHZsmWYNWtWxxu3kH0oEYJIgNzFFVKn5qEE1GeGaRJLoGzxtZ2+sRF1p7uW2pkZ6rOxvh5iuR0U3qZdS+tPdy1VmOlaqtNoIFHaw67FF5fa2hqoy053b27VtbT29FACstbdm093LRXMdC2tPd21VG5m2A5tTQ1EZrpx17UYSqBlo1FRbioeXHsXrhl6Cy4b0zz/WGOL7s0vn3gPGpEO78x4H0DTMIt6rRZSM0O/qU9347ZvPWxHTjYMBgNkzs6QObe4zspKaE53b7ZvNWxH7ZlhO1pdZ0NpKRrrmobtaPmVia5FN25Fq2E76ouKoFM3QGJm2I6G08N2KFsP25GXB72uadgOeashctSnu3HbmxlKwICm7s0th2lSV1RAW900RI59qyFyLN6Dp69TLJND4WM6bEf96W7citZD5BQWQqdRQ2KmG3fD6W7cre/B5ut0grxFzxBNiyFyHFoNkWO8B7tV1toOJWC2rDU0oL7YtKyJxSI4OSlQmJoGbYPapKx9l/gNVh75HismfgxBEMG+zVACFspaVSU0VVVty5pej9rTQwmcuQe352zF8zufwRcTlsMTTm3uwfbK2vL/XsWB7F34YM7nULYYGuJMWXt622J4BQ3C01Oav/YxljUzw3b0Sllzd0eD1ICr/roMN8bejCu955gvay3vwe6UNYv3YKuyplJBXXl6KIFWZW3vgX/w1v7XoVZKMSZiCs4LnY1R3qPRUFGGB/66DcN8R+L+C5t7gLS8Bx8+8BQG+Q/BY2OaekY3lJagsa7OTFlr73l/pqyZPu/PlDWxSIBPTCRq6rTQ6fRNf5szQwlYKGsC2g5HZSxrrYcSsFTWWt6D3SlrPr4mlcIz92Cb37WW96CFsqZTSnHFf9fh4VGP4qLwi7tU1ozXWVYK7elhmhYdex6RroPwyOjHTJ73rcta/enhLNrcgy1+19o87/Pzml7k2itrZoZpMpwepknWatgOc2Wt5T0od3eH1L7t75rYzLAdFp/3FstaZ573pmVNV1sDmbYONTUNULQYvggAaloM22H6u9aNd6tulTXz71btXWevlLX23q06WdYaWw0/aK6stftu1bqsnbkHzQz1qVF1v6xZerdqU9Ys3YPdKWtdeLc68y5Qml2A+oqKdt+tOipreoMef55cia8PfgKPOhmuj7kJx/WZWJ27Fi9MfAmTAqY0X2erdyttbQ1Oph+Ar4M/nANDOlXWLL1bAU1lLa3iBJ44tASPTn8BM4Ob6kFnVdb6cj3GzBA5Lesxx0uO4bEtj2C4+1AsDrsHYpGkzT1oLGt2dlB49WBZ6+q7VevrbPFupfT0hLufJ1Sqeuh0+k6VNdZjulOP6VxZs2U9pvk6e7CsWXq36kybgZl6jLqoAA4OdmhUOkOQtYj5zFBh7ZS1NvegtdsMLDzve7we09my1k49pqOy1jPvVi3LmqV6TM+1GbT7btXZstbFdyuxWASlFCg+lQmd3tDmOi3WY1qUtd5oMzBep4XnfXttBq3L2soTvyGx9DieGPa4cbhZi2WtO/WYTpS1DZn/4vVdL+HXcV9BJpF1qx6zq/4YXj+0FL/P+wuudm5WazOwfT2muc3A3tsLTk4KqFT1UFdXW7ceY6U2gx6px7Qoa8WOjVjw761YEH83ro66pk1Z0xv02F+4D1GiAEjUuq7VY3qyzaC9d6u+0mbQxee9YNDBzc8LGqnS2J7VsqyZq8cAPVzWersec7qsWazHoAtl7fS7VeDQ5t6z7bFJ4m/YsGFYtmwZJk6c2Gbdjh07sHDhQhw+fNgqsXQ38VdSUt1LEQ1cEokISw+8hMTCZHxx/rdtJsat1qhw1d+X4p5h9+PSiMstHIXIOs70RqmoqEVjo95k3cGiBCzetgifX7CiyxMAZ6uy8NzOp/DG1HfhpfSyuN0b+17FiYpUfH5B1z+CSCpLxIOb7sVbU9/DUK/hJusyqzKwYP18LJnwCib4T7JwBOt5a//rOFx8EN/M+cnY46CvWXbofewp2ImPzvsCDlIHk3XfJa3Ajynf4ae5v8NR5mSyrqSuBNf/cyWeHvc8pgXO6LX42rtXzyV3b7gNka5RWDRqcccbd+CGf67CzODzcdvgBR1vTF3C+5X6k964X0vqSrD88PvYkbcNAPDIqMdN5pKzpqe3P468mjx8ccE3EIs6/+XoQJJWeRKLtjyIcJcIvDr5TcjF8o536qP4fKX+hPcr9Se8X61jd/5OPLfzKfx88Uq42bl3vIMZbycsRXJZUrfaUQYK3q/d88Gh97Ahcx1WXPgDXO2aE74HixLwyZFlSK9Kx/y423FD7M3tHIW6ivdr93h6Ona8EQCbtLK6ublhzZo1Ztf9888/cHNzM7uO+r+r465GbnUODhUfaLNuV/5O6A16TPSfYoPIiDovyi0GAoCU8uQu73u05AjyanLx+4lfLG6j0+uwt2A3xvu1/TiiM2LcYuFj74NN2RvbrNuauxn2UnuM8hljZk/rmxN2MYrqipBQuN/WoVh0siIV0W6xbZJ+AHBR2MXQG/RYm/FPm3UHixMgABjhNdIKUVK0WyySy5LO+jgGgwEVDRVwlbt2vDERURd5Kj3x/ISX8MqkN/DU2OdslvQDgFvibkdeTS7+y15vsxhsqbiuGE9sexT+DgF4ceJr/TrpR0RE1N/ZS5t64tRqa7t9jCMlh9t8/EzUGfPjboNEJMGXxz8D0PTR/NPbH8fibYtgJ1Eg1j0Oewt32zhKoq6xSeLv7rvvxu+//46bbroJK1aswOrVq7FixQrcdNNN+OOPP3D33Xd3fJCzUFtbi+TkZCQnNzXa5+bmIjk5Gfn5+b16XgKG+wxHsFMI/jr1R5t1O3K3ItZ9MDwUHmb2JOo77KX2CHIKQXJZYpf3zVClAwDWZKxCtUZldpvEsmNQaVSY4Ne9HnmCIGB60Cxsz9sKrU5rXG4wGLA5+z9M8JsEmVjWzhGsJ8YtFmHOYfgn/W9bh2KW3qDHqcqTiHQdZHa9q50bpgZOx6q0P6E3mH6ddKBwPyJdo+Akdza7L/WsGPc4ZKsyUaOtOavj1DfWQ6vXwoWJPyLqRWN8x2J60EybxjDILQoT/Sfj26SvUaM5t0YzMRgMeDvhdUhEErw6+Q1jYyMRERHZxtkm/orrilFQk49hnkz8Udc5ypxwS9xt+DdjDV7b+yLu2nArsquz8Oz4JXhv+jJcGDoXKWVJqGyosHWoRJ1mk8Tf1VdfjY8++ggajQZvvvkmHn30Ubz55ptQq9VYvnw5rr766l49//HjxzFv3jzMmzcPAPDaa69h3rx5eP/993v1vNSUkJgXeTn2FOxEUV2RcXmtthYJRfsxOWCqDaMj6rwY91iklHe9d1FmVQbiPYdCp9dhdZr5ZNeu/B1ws3NDlFt0t+ObETgL1ZpqJBTtMy5LrzqFvJpcTAu0bUNjS4IgYEbQedhfuBeN+kZbh9NGtioLap0ag1yjLG5zWcSVKKwtxJ78XcZleoMeB4oTMNJntDXCJACx7nEwAEjtRk/clirVTS/yLnKXsw+KiKiPmx93O6rUVbhl7fVYefJXkw+GBrJ/0lfhYNEBPDzycTjzeU9ERGRz9qdH2Onux0hHig8CAOI9h/ZYTHRumRt2KUKdw7C3YA/uGHI3vrjgW0wJmAZBEDDGdywMgEkbG1FfJ+l4k94xffp0TJ8+HXq9HuXl5XBzc4NIZJ085NixY5GammqVc1Fb54VcgE+PfIx/0v82zp+0t2AXGvWNmMTEH/UTMW5xWJ+5FnXaOiilyo53QNPX5ZlV6ZgXeQUCHYPwx6nfcMWgq0163xkMBuzK24HxfhPPas67EOdQhDmHYVP2RuOQoZuz/4OTzAkjvPvW0JNxHkOg1WuRWZWBCNdIW4dj4mRF029FhIUefwAQ5RaNWPc4/HHqd+O8iemVaVCpqzDKm4k/a/F3CICjzBFJZYkYeRb/7hWnv+BzsWOPPyIa+EKcQ/HV7O/xTeKX+OTIMvx58nfcOngBpgXOMJmP22AwoLS+FOlVaQhxDoW30tuGUZ+dwtoCfHJ0GeaEzsUY37G2DoeIiIhw9j3+DpccQphzGD/ooW4Ti8R4e/oHANBmqhc3O3dEug7C3oI9mBV8gS3CI+oym/T4a0kQBOh0Ouj1nMDxXKGUKnFe8GysSV8NjU4DANiWuxVRbtH9uhGBzi0x7rHQGwzGxFBnVKoroNKoEOIUiisHXYPKhgpszDKdVydTlYGC2gJM8Jt81jFOD5qFXfk7UKetg8FgwJacTZgcMBUSkc2++TArwiUSIkHo1pyJve1ExQn4OwSYnd+vpUsjLsfh4oPIqGoayjWhaB/sJHaIcYuzRpgEQCSIEO0W060heFuqUlcCYI8/Ijp3uCvc8fCox/DJeV8h2CkEr+59EQv/uwur0v7Cx0c+xGNbH8aVf1+C6/+5Es/sWIx3E96wdcjdpjfo8eb+1+Ekc8KdQ++1dThERER02pkef91N/B0pPoShXiN6MiQ6BzlIHSy2/4z1HY+Ewn3Q6XVWjoqoe2yW+Nu+fTuuvvpqDBkyBNOnTzf2wHv22Wfx9999c64n6jmXhM9DlboS23O3oE5bh30FezDZn739qP8IdgqBQqJAcheG+zyTFAp1DkOAYyDG+03Cryd+Mpkbbnf+TigkCgzrgQmppwXOgEanwZ6CnUguT0JRXRGmBc446+P2NDuJHUKdw7o1dGpvO1mRanF+v5Ym+0+Fm50b/jq1EgBwoCgBQz2HQSqW9naI1EKMexxSypNhMBi6fYwKdQUEgF+KEtE5J8Q5FC9Neh1vTX0PAPD+wXewK28HHKQOmBd5BV6c+Cpuip2PIyWHut0oZ2t/n/oDR0sO49FRT3BePyIioj5EJIigkChQ24052wtrC1BUV4ShnsN6PjCi08b6jkeNtgaJZcdsHQpRp9gk8bd69WrceeedCAgIwPPPP2/S2y8wMBArV660RVhkRUFOwRjuNQJ/p/2J/YV7odVrMSVgmq3DIuo0kSBClFsMksu6lviTiqTwc/AHAFwddR1yq3Owt2C3cZudedsxymeMyfCf3eVj74s498HYlL0RW3M2w9XOFfF99EU42i22z/X40xv0OFV5slOJP6lYiovD52FD1r8oqSvB8dKjZzXcJHVPjFssqjXVyK3J6fYxqtSVcJK7nNVQu0RE/dlQr+H4cOYnWHXZv/hmzk94fsJLuCl2Psb7TcT5IbPRqNfhQNF+W4fZZbnVOfjs2Me4JOIyDO9jw54TERFR03Cf3fm46HDxIQjg/H7Uuwa5RsFF7oJ9BXtsHQpRp9ikVWv58uW45ZZb8M477+Dyyy83WRcZGYmTJ0/aIiyysksiLkNSWSK+T16BcJcI+Dr42Tokoi6JcY9Fcnlip3sXZaoyEOwUYkwoxHkMRpz7YPyc8gMAoLS+FCcqUjHh9Jx8PWF60EwkFO7Df9kbMCVgep9NZkS7xSJblYk6bZ2tQzHKVmVBrVNjkGtUp7a/KOzi00OIvYpGfSNGeI/q5QiptWi3GAA4q+E+KxoqOMwnEZ3zBEGAncSuzXIfe1+EOodid/5OG0TVfXqDHm/tfx3udu64ffCdtg6HiIiIzLCXOnQv8VdyEGEuEXCUOfVCVERNRIIIo33GYi8Tf9RP2KQFOCcnB1Onmh/WUaFQoLq62soRkS2M950IT4UnMqoy2NuP+qUYt1hUNFSguK6oU9tnVmUgxDnUZNnVUdchsew4EkuPY3f+TogEAWN9x/dYjFMCpsEAA6rUlX1ymM8zotyiYQC6NGfi2SipK0F9Y32725yJJaITPf4AwNXODVMDp+NQ8UF4KDwQ5Bh81nFS1zjIHBHsFIKks0j8Vaor4CJ37cGoiIgGlnF+E7GvYI/JUOV93e8nfkFS2XE8NvpJKKVKW4dDREREZjT1+OvaUJ8GgwFHig/1yHQpRB0Z6zsemaoMFHWyHZDIlmyS+PP09ER6errZdampqfDzY8+vc4FYJMbc8EsBAJP8p9g4GqKuM/Yu6sTcdHqDHlmqTIQ4mSb+xvlNQIBjIH498RN25+/AEI9hPfqVmqudG0Z6j4anwhOx7nE9dtyedmbORGsM92kwGPDQ5nvx+bFP2t3uRMUJ+DsEWJzY2ZzLIq4EAIz0Hg1BEM4qTuqeaLeYs5ovslJdCVc7Jv6IiCwZ5zsBKo0KiWXHbR1Kp5woT8WXxz/DZZFXYQiHACMiIuqzujPUZ35NHkrrSzHMc0QvRUXUbKTPaIgEAftaTNlD1FfZJPE3d+5cfPDBB9i9u7mQCIKAEydO4PPPP8cll1xii7DIBq4cdA2WTnkbQU7sGUP9j6udG3zsfTo1z19xXRHqG+sR6hxuslwkiHDVoGuxK287DhYlYKL/pB6P86GRj+HVyW/22WE+gaZ/h0jXKKsk/rJUmSiuK8a2nM3t9lY4UZHSqfn9Wopyi8bNcbdiXsQVZxsmdVOMexwyqtK7PWxsZUMFnDnUJxGRRdFuMXCRu2BPPxjus1qjwkt7nkOYczhuH8IhPomIiPqy7gz1ebjkEESCgMGe8b0UFVEzB6kDBnvEYy8Tf9QP2KQVeOHChRg+fDhuvfVWTJzYNJfVggULcOmll2Lw4MG4805Wys4VMrGM82BRvxbjFtep3kWZVRkA0GaoTwCYFXw+nOUu0Bn0mODX84k/L6WX2fP2NdFu0WfVU6uzDhTtB9DUs8vSkJB6gx5plae6nPgDgJti5yPCNfKsYqTui3WPg95gwImKlG7tX6mugCuH+iQiskgkiDDWdzx25++ydSjt0hv0eGP/a6jV1uLZ8UsgE8tsHRIRERG1oztDfR4tOYQIl0FdGqmH6GyM8RmHQ8UHodapbR0KUbtskviTyWT46KOP8PXXX+Pqq6/GVVddhcsuuwxffPEFPvroI0gkEluERUTUZTHusThZcQIanabd7TKq0mEvtYenwrPNOplYhlvibsck/ynwtvfprVD7vGi3WJTWl6K0vrRXz3OwKAFDPYfD1c4VO/K2mt0mW5UFtU6NKNfoXo2Fet6ZYWM70xO3Nb1BD5Wmij3+iIg6MN5vInKqs5FXndvlffUGPRoaG3ohKlO/pv6EPfm78Pjop+Bj79vr5yMiIqKzYy+1R21j53v8GQwGHOb8fmRlY33HQ6PT4HDxIVuHQtQum2bYxo0bh3HjxtkyBCKisxLjHgetXov0qjTjnH/mZKrSEeIUanHet7nhl2Bu+Lk9zHHU6X+/E+Up8OiFIU8BQKvT4mjpEdwQczMCHQOxM2877oq/r83f5WRFKgAgnD33+h2RIEK0WwySys335mxPtUYFvcEAFzuXng+MiGgAGeE9ClKRFHsKduEKx6s7vZ/eoMeLu5/DvoI9mBwwBReEzMEwrxFdHo48oyodiaXHMTVwmtm5kY+WHMaXxz/FtdHXY5zfhC4dm4iIiGyjvaE+9QZ9m/eF3JoclDeUYyjn9yMrCnYKgY+9D/YV7sFYX+Y1qO+y+YRPer0eN998MzIzM20dChFRl4U7R0AqkiKlg95FmVUZ/WK4TVvyVHjCzc4Nyb043GdyeSIaGhsw0ns0JgVMQWFtIdIqT7XZ7kTFCfg7BHC4kH4qyi0aaRUnu7xfRUMFAMCFQ30SEbVLIVFguNcI7OriPH/fJa3ArrztmBN2MU5UnMDibYtw85pr8U3iVyisLehw/7zqXLy+9yXctf5W/O/g27j+n6vw8ZEPUVJXYtymvKEML+95AYM94jE/7o4uXxsRERHZhr3UHrWaahgMBuOyWm0tXt3zIub8PhN3/HsLXt/7En5N/QmHig5gV96Opvn9PIbYMGo61wiCgDG+47GvYLfJvUrU19h8TE2DwYB9+/ahtrZrk7cSEfUFUrEUka6DcLz0GOZFXmF2m0Z9I7KrszEn7GIrR9e/CIKAKLcYpJYn99o5Eor2w0nujHCXCOgNejhIHbA9b2ubOflOVKR0a34/6hu8lb4oayiFTq+DWCTu9H5V6koAgAuH+iQi6tA4v4n48NC7qNaozPa6a21n3nZ8m/Q15sfdjhtib4bBYEBSWSL+zVyD3078jG+TvsYg1yjEew5FvOcwDPGIh4PMEQBQXFeM75NWYF3mP3C1c8P9Ix7BON8JWJX+J/4+9Qf+OrUSs4IvwJWDrsEHB98DADw97vku/QYQERGRbdlL7aEz6KHWqWEnscPJihN4ac/zqGyowE2xt6KsoRRplaewI2+7cX61GPdYKKVKG0dO55qxPuPx96k/kKXK5Ef+1GfZPPFHRNTfjfYZi19Sf4RGp4FMLGuzPq8mF436RoQ48WWgI9FuMfg59Qezw3j0hAOF+zHCayREgggiQYRxfhOwM287bh3c3CNAb9AjrfIUJvlP6fHzk3V4Kr2gNxhQ1lAGL6VXp/erUJ/u8WfHHn9ERB0Z5zsB7x98B/sL92FG0Kx2t82sysDSfa9gkv8UXB9zE4CmD37iPAYjzmMw7hl2P3bkbsWBov3YkrMJv534BQKAMJdwBDoGY2fedigkCtwx5G5cEnEZ5GI5AOC2wQtwTdT1WJ32F34/+QvWZayBSBDw5tT34Gbn3tv/BERERNSD7E+PuFOrrcW6jH/wydHlCHUOw2uT3oS/Y4BxO71Bj9zqHKRVnmLShWxiqNcwyMQy7C3YzXuQ+iwm/oiIztKUgGlYkfglEgr3YYKZuekyqzIANI0DTu2LdotBnbYOudU5CHIK7tFjV2tUOFmRirnhlxqXTfafio1Z65GtyjKeL1uVBbVOjUGuUT16frIeT6UnAKC4rqhLib8qdSUkIgnsJfa9FRoR0YDhqfREhEskdufvbDfxV6OpxvO7noa30gePjX7S7HzHCokC54XMxnkhs2EwGFBYW4AjJYdxtOQw0qtO4bqYG3F55FWwl7Z9PttL7XFN9PW4LPJKbMxaD6VUiXjPYT15qURERGQFZ37nX9z9LJLKEjEv4gosiL+7zQfWIkGEIKfgHm8zIOosuViOEV4jsa9wD66Jvt7W4RCZZfPEn1gsxjfffIOQkBBbh0JE1C1BTsEIcQrFttzN5hN/qgy4yF3Yi6gTBrlFAwBSypN6/CX+UPFBGACM8B5lXDbSZzTkYjl25m03nu9kRSoAILzV8J/Uf3gpvQEAJXXFXdqvoqECLnIXs43SRETU1ni/iVh58lc06hshEbWtWuoNery690VUa1T4cOYnnRqKSxAE+Dr4wdfBD7ND53Q6FplYhjlhc7sUPxEREfUdDqd7/GWrsvDChJcx0X+yjSMismyM7zh8eOg9VDSUw9XOzdbhELXR8+OodcOYMWMgEomQlZXFSTGJqF+aEjgNu/J3QqPTtFmXUZWOUOcwG0TV/zhIHRDoGISU8pQeP/bBogQEOAbC+3RSCGj6SmuM7zjsyNtmXJZakQp/hwBjpYP6HwepAxQSBYrrirq0X6W6Ai5yJuiJiDprvN9E1Gprcbz0qNn1Xx3/DAeK9uPpcc/Dz8HfytERERFRfxLiHIY7htyFj8/7gkk/6vOmBEyDQqLEisQvbR0KkVk2Sfx98cUX+PDDD43/OyEhAVOmTMHs2bNx/vnnIzs72xZhERF125SAaahvrMeBov1t1mVWZSDUOdwGUfVPUW7RSC1P7vHjHijab9Lb74xJ/lNwoiIVRaeTRCcrUhHpOqjHz0/W5aX0RnF913r8Vaor4cqeuUREnRbhEgkPhQd25+8yWZ5anoKXdj+Pn1J+wB1D7sZI79E2ipCIiIj6C5EgwjXR18Pb3sfWoRB1yFnugpvjbsWa9FU4VXHS1uEQtWGTxN+vv/4Kb+/mHhevvfYaIiIisHz5cri6uuKdd96xRVhERN0W7BSCYKcQbM3ZZLJcrVMjvyaXk/12QYxbLNKrTpntPdld+TV5KKwtxCgzDY9jfcdDIpJgV9526A16pFWe4vx+A4CX0qvLQ31WNlTAWe7SOwEREQ1AgiBgrO947C7YCb1Bjz35u7BoywNY+N9dOFl5Ag+NfBRXDrrG1mESEREREfW4S8IvQ5BTCJYd/p9NRzGs09ZxFEVqwyaJv8LCQgQHN82lVFRUhMTERCxatAjTp0/HnXfeiYSEBFuERUR0VqYEtB3uM1uVBQOAECcm/joryi0GjXodTlX23BdTB4oSIBIExHsOa7POXmqP4V4jsCNvG7JVWVDr1Ez8DQCeim4k/tSVcOVQn0REXTLebxIKavIxf90NeHbnk9DoNHhu/Iv4evb3uCjsYs6bSkREREQDkkQkwT3DFuJ46TFsadURwFqqNSrcuu4GvLH/VZucn/oumyT+5HI5ampqAAC7d++GUqnE8OHDAQCOjo6orq62RVhERGfF3HCfmVXpAJp6BFLnhDmHQyKS9OhwnweLEhDjFgd7qb3Z9ZP8p+J46VHsK9wDAAh3jeyxc5NteCq9ujHUJ3v8ERF11XCvEfB3CECwUwjemf4B3p/xESYHTIVI6BPTyRMRERER9ZqR3qMxwW8SPj26HPWN9VY//1fHv4BKU4WNWeuxMetfq5+f+i6b1Mbi4+Px6aefYsuWLfjiiy8wZcoUiMViAEB2drbJMKBERP1FiHNo03CfuZuNyzJVGfCx94FSqrRhZP2LVCxFhEtkjyX+9AY9DhcfNDu/3xnj/SYAAH5J/Qn+DgFwkDr0yLnJdryUXlCpq6DWqTu1vUanQa22lnP8ERF1kUwsw9cXfo+XJr6GIR7x7OFHREREROeUu4fehyp1FX5K+d6q5z1ZcQL/pP+FO4bcjZnB5+H9g++ioCbfqjFQ32WTxN/ixYtRUlKCu+++G7W1tXj44YeN69auXWvs/UdE1N9MCZiG3S2G+8yoSucwn90Q7RaLlPKUHjlWankKarQ1GGlmfr8zXO3cMNgjHlXqSg7zOUB4KrwAoNPDfVapqwAAzhzqk4iIiIiIiIg6ydfBD1dGXYNfU3+yWuJNb9Djg0PvItAxGJdGXI77hz8MZ7kzXtv3EnR6nVVioL7NJom/iIgI/Pfff9i9ezc2bdpknO8PaEoKLl682BZhERGdtSkB01CnrTMO95lRlY4QZyb+uiraLRp5Nbmo1qjO+lgHixKglCoR7RbT7naT/KcAACJdB531Ocn2PJVNib/iuqJObV+prgAAuHCoTyIiIiIiIiLqguuib4Sz3BmfHF1ulfOtz1yH5LIkPDDiYUhEEthL7fHEmGeRWp6Mb5O+tkoM1LfZdOIFV9e2X9VHRUXBzc3NBtEQEZ29EOdQBDkFY2vuZtRoqlFaX4pQ5zBbh9XvRJ1O0qX0wHCfB4sTMNRzOMQicbvbTfKfCie5M4Z7jTzrc5LtnUn8ldSXdGr7iobTiT8O9UlEREREREREXaCQKLAg/h7szNuOg0UJvXquao0Knx37GDOCZiLec5hxeZzHYNwUeyt+TPkWx0qOWNzfYDD0anzUN0isdaKXX34Zt912G/z8/PDyyy93uP0zzzxjhaiIiHrelIBpWHnyV1wQfCEAcKjPbvB3CICjzBEp5ckY7TO228ep09YhsfQY7hl2f4fbeio98fslf3f7XNS3yMVyOMtdOj3Up0pTCYA9/oiIiIiIiIio66YHzsSqtD/x/sF38cHMj+Aoc+qV83yd+CW0Og0WxN/bZt31MTfhYFECXt/3Mj4570s4yBxhMBiQoUrHtpwt2J63FQ2N9Vhx4Y+QiKyWGiIbsNpfd9OmTbjyyivh5+eHTZs2tbutIAhM/BFRvzUlYBq+S1qBlSd/hUgQEOAYZOuQ+h1BEDDMawT+y9qA66Nv6rC3niVHSw5DZ9C3O78fDVyeCs9OJ/4qGiqgkCggF8t7OSoiIiIiIiIiGmgEQcCiUYvxwKZ78OLu5/Ha5Dd7PLl2quIkVqf9iQXx98BD4dFmvUgQYfHYZ3DX+luxdP+rCHUOw7acLciryYW91B5DPIdiT/4uJJUdN+ktSAOPVRN/5v6biGigCXEKRaBjEPYU7EaQUzBkYpmtQ+qXboi5CXdvuAMbsv7F7NA53TrGoeKD8FJ6wd8hoIejo/7AS+mN4vrOz/HHYT6JiIiIiIiIqLsCHAPxwoSXsXjbI/jfwbfxyMjHIQhCjxxbb9Djg0PvItAxGPMirrC4nbfSGw+NfBSv7FmCxNJjmOA3CfcOewDDvUZALBLjmlWXYW/Bbib+BjibzvFHRDQQCYKAKQHTAHCYz7MR7hKJSf5T8H3yCmh12m4dI7k8EYM9hvTYSxb1L55KL5TUdW6Ov0p1JVzlTPwRERERERERUffFew7DwyMfw7qMNfgl9cceO+7GrH+RVJaI+4c/1GFPwmmBM/DV7O/wy8V/4tHRT2CM71hIxVKIBBHG+I7D3oI9PRYX9U1WH8g1NzcXv/76Kw4fPozS0lIIggAPDw+MGDHCOBQoEVF/NyVwGr5P/gYhzkz8nY1b4m7Dnevn49/MtZgbfkmX9tXqtDhVcRLTA2f2UnTU13kqPFFcVwSDwdBh8reyoQLOnN+PiIiIiIiIiM7S+SEXIrcmF18c+wR+Dv6YHDD1rI+5PvNfjPIZjaFewzu1fYBjoNnlY33HY33mOhTWFsDH3ves46K+yao9/latWoU5c+bgk08+QWZmJhwdHWFvb4+MjAwsX74cF154IdasWWPNkIiIekWoUxhuG7wAM4POs3Uo/VqIcyimBc7E98kroNFpurRvelUatHototxieik66uu8lN6ob6xHrbamw23Z44+IiIiIiIiIesr8uNsxJWA6Xt/3MlLLU87qWGqdGkllxzHaZ+xZxzXCexTEggh7C3af9bGo77Ja4i8tLQ1PPfUURowYgX/++Qdbt27FTz/9hJ9//hlbt27FqlWrMHToUDzxxBPIyMiwVlhERL1CEARcF3Mj/Bz8bR1Kv3dT3HyUN5RhTfqqLu2XUp4EiUiMCJfIXoqM+jovpTcAoLi+uMNtK9UVcLZz6eWIiIiIiIiIiOhcIBJEeGzMkwhzDsezO59AUV1Rt4+VVHocWr0Ww7xGnHVcDlIHDPEcxsTfAGe1xN8PP/yAwMBAfPrppwgPD2+zPjIyEp9//jkCAgLw/fffWyssIiLq4wIdgzAz6Hz8kPItGhobOr1fcnkSwpwjIBPLejE66ss8lV4A0OE8fwaDARUNFezxR0REREREREQ9Ri6W48WJr0IsiPHlsU+6fZxDJQfhLHdBiFPPTCk01nccDhcf6lI7G/UvVkv87du3D1dffTVkMssNsDKZDFdffTX27dtnrbCIiKgfuCl2PlTqKqxK+7PT+6SUJSPaPbb3gqI+z93OHSJBQHEHX9XVN9ZDq9fChYk/IiIiIiIiIupBrnZuuDB0Lnbn7+ryNDZnHCk+hGGewyESeiadM9Z3PLR6LQ4XH+yR41HfY7XEX0FBAaKiojrcLioqCnl5eVaIiIiI+gtfBz9cEDIHP6X+gDptXYfbV2tUyKvJRQzn9zuniUViuNt5oKSDoT4r1RUAAGe5szXCIiIiIiIiIqJzyOSAqahvrMfB4gNd3rdOW4eU8qQeGebzjACHQPg6+PXocJ+/pP6IBzfd22PHo7NjtcRfbW0t7O3tO9xOqVSirq7jRl0iIjq3XB97M+q0tfjr1MoOt00pTwYARLuxx9+5zlPp1WGPv4qGpsSfix17/BERERERERFRzwpxCoW/QwB25G7t8r7HSo9CbzBgmNfwHotHEASM9RmPvQW7YTAYzvp4ddo6/Jj8HZLKEjv1wT71Pqsl/nriBiIionOXt9Ibc8Iuxq8nfkKNtqbdbVPKk+Eoc4S/Q4CVoqO+ykvpjZK69nv8VakrAYBz/BERERERERFRjxMEAZMDpmJX/g406hu7tO+h4gR4KDx6vI1rrO84lNSXIKMq7ayPtSrtT2NbXZYq86yPR2dPYs2T3XLLLRAEod1tmCAkIiJLrou+EWvS/8bGzH8xL/IKi9ullicjyi26w98cGvi8lF5IPd0D1JIKdQUEAE4yDvVJRERERERERD1vsv9U/JTyPY6WHMYI71Gd3u9w8UEM8xrR421c8Z7DYCexw96CPQhziej2cdQ6NX478TNmBp+HTVkbkKnKQIw7R+CyNasl/hYuXGitUxER0QDlofDASO/R2Jq72WLiz2AwILk8GReHXWrl6Kgv8lR4oaS+BHqD3uIk2FXqSjjKnSEWia0cHRERERERERGdCyJdB8Fb6Y0deds6nfhTqauQVpmGyyOv6vF4ZGIZhnuNxN6C3bgu5sZuH2ddxj9QaapwU8x8pJQlI6MqvQejpO5i4o+IiPqVqQHT8cb+11BSVwJPpWeb9YW1BVCpqxDNr4sITXP8NeobUamugJudu9ltKhoqOMwnEREREREREfUaQRAw0X8KNudsxMLhD1n8OLmlIyWHAQDDvEb2Skxjfcfj/YNvQ6WugpO866MgaXVa/JzyA6YFzoC/YwBCncM6lfgzGAz4PfUXXDF0HgBZ1wOnDlltjj8iIqKeMN5vIiQiMXbkmZ8QObk8CQAQ7RptzbCoj/JSegMASupKLG5Tqa6As9zFShERERERERER0blocsBUVDRUILHseKe2P1R8EP4OAfBSevVKPGN8xkFvMCChaF+39v8vewNK6ktwbXRTj8FQ5zBkdiLxl1eTi2WHPsCp8lPdOi91jIk/IiLqVxxkjhjlPQZbczabXZ9angJfe1+42LEHFwGeiqZeocV1RRa3qVJXsscfEREREREREfWqWPc4uNm5YUfutk5t3zS/3/Bei8dT6YlwlwjsLdjd5X31Bj1+Svke4/0mItQ5DAAQ4hyKSnUlKhrK29035fRH+1EeUV0PmjqFiT8iIup3pgZOR2LZcbO9uFLKkxDlFmODqKgvcpa7QCqStpv4q1RXwNnOxXpBEREREREREdE5RySIMNF/CnbkbYXBYGh329L6UuRUZ2OY14hejWms73jsL9wHvUHfpf225W5BXk0uboi52bjsTAKwo+E+U8tT4e/gDye5U9cDpk5h4o+IiPqdcX4TIRFJsC3XtNefVqfFyYoTiGbij04TBAFeSm+U1Bdb3IZz/BERERERERGRNUz2n4LiumKcqEhtd7sjxQcBAEM9h/VqPGN9x6NaU42kssRO72MwGPBTyncY4T0SUW7NU+34OwRAKpIiU5XR7v6pFcmIdmfbXW9i4o+IiPodB6kDRvmMwbbcLSbL06vSoNVrEe0Wa5vAqE/yVHpZnONPb9BDpamCCxN/RERERERERNTL4j2HwUnmhB15W9vd7lDxQYQ6h8LVzq1X44l2i4GT3LlLw33uLdiNtMo0k95+QFOPxiCn4HZ7/DXqG3Gq4iRH6+plTPwREVG/NC1gOpLKElHUYgjH1PJkSERiRLoOsmFk1Nd4KjwtDvWZX5MHvcEAD4WHlaMiIiIiIiIionONWCTGBP9J2J67rd3hPo+UHMIwr5G9Ho9IEGGi3yRszPoXWp22w+0NBgN+SPkWse5xGOIxtM36UOewdhN/GVXp0Oq1iHHnR/u9SWKtE918880db9TCN99800uREBHRQDDObyKkIim2527BlYOuAQAklychzDkCMrHMxtFRX+Kl9MbB4gSz6zZlb4RCouj1MfOJiIiIiIiIiABgsv80rMtYgwxVOsKcw9usL6wtQGFtIYZbqa3i8sirsDbjH2zK2YgLQi5sd9tDxQeQXJaElycthSAIbdaHOodhR9426A16iIS2/c5Sy1MgEgSEu0T0WPzUltV6/Dk4OMDR0dH4f5mZmUhISEBNTQ3kcjlqamqQkJCArKwsODlxUkciImqfvdQeo33GYmtO8zx/KeXJHCqA2vBUeqG8vgyN+kaT5QaDAf9lb8DkgKmwk9jZKDoiIiIiIiIiOpcM8xoOpVSJHbnbzK4/VHwQIkHAEI94q8QT4hyKcX4T8Evqj9Ab9Ba3MxgM+PL4Z4h2i8EYn7Hmj+UUhobGBhTVFppdn1KehFDnMLbD9DKrJf6WL1+OZcuWYdmyZTjvvPPg4OCAdevWYeXKlfjss8+wcuVKrF27Fvb29pg5c6a1wiIion5sauB0pJQno7C2ANUaFXKrcxDDxB+14qnwggFAWX2pyfKU8mTk1+RhZtB5tgmMiIiIiIiIiM45MrEM430nYHuu+Xn+DhcfQITLIDjIHK0W0zVR1yNbldXuXH+78ncgtTwFtw1eYLa3H9DU4w+AxeE+T1SkIMqVbXe9zSZz/C1fvhwPPvgggoKCTJYHBwfj/vvvx/Lly20RFhER9TPjfCdAKpJiW+4WnKhIBQBEc4xwasVL6QUAbeb525i9Hu4Kdw7zSURERERERERWNSlgKjJVGfj9xC84UZ5qnF/PYDDgUPFBqw3zecZgjyGIcx+Mn1K+N7teb9Djq+OfY7jXCAz3tjz3oIfCA44yR2SqMtqsq29VI1gRAADBbElEQVSsR5Yqk6N1WYHV5vhrqbCw0GJGWBAEFBUVmV1HRETUklKqxFjf8diWuwVanRYOUgf4OwTYOizqY7yU3gCAkvpi47JGfSO25GzCBcGzzY45T0RERERERETUW0b7jMVwrxH49Ohy6A0GSEQShDmHI9ApCBUNFTb5SPma6Ovx3M6ncLz0GAZ7DDFZtyl7A7JUmXh09BPtHkMQBIQ4hZrt8Xeq4gT0BgOi3KJ6NG5qyyaJv/j4eLz33nuIiYlBYGCgcXlOTg7+97//YejQobYIi4iI+qEpAdPw6t4XodVpMMgtikkcakMpVcJeao/iuubEX0LRfqjUVZgZzGE+iYiIiIiIiMi65GI53pj6LtQ6NdIqT+FkRSpSy1NwoiIVPvY+GGyl+f1aGus7HsFOIfg59QcM9njNuFyr02JF4peY4DcJ0Z3orRfiHIajJYfbLE+tSIFMLEOIU1hPhk1m2CTxt2TJEtx2222YPXs2IiMj4e7ujrKyMpw8eRLu7u748MMPbREWERH1Q2N9x0MmliG9Kh3X+91k63Coj/JSepkk/v7LWo8Qp1CEOUfYMCoiIiIiIiIiOpfJxXLEusch1j3O1qFAJIhwVdS1eGv/68isykCIcygAYG3GahTVFuKlia936jihzqFYk/43tDotpGKpcXlqeQoiXQZBLBL3SvzUzCbdIsLDw7FhwwY888wziImJgSAIiImJwTPPPIMNGzYgPDzcFmEREVE/pJQqMcZnHAAgxo3z+5F5ngov41Cftdpa7MzbjlnB51scepyIiIiIiIiI6FwzI3AWPBQe+CX1RwBAQ2MDvktegRnB5xkTgR0JcQ6DzqBHTnWWyfLU8mTO72clNunxBwAymQzXXXcdrrvuOluFQEREA8T5IbOxr3APYtyZ+CPzPJVeSClPAgDsyNuGRr0W04Nm2TgqIiIiIiIiIqK+QyqW4opBV+Pzox/j1sELsCl7A6o1KsyPu73Txwh1akoQZqoyEObSNNJSlboSBbUFiHKL7pW4yZRNJ0JKS0vDn3/+iY8//hglJSUAgKysLNTU1NgyLCIi6mfG+03Ezxf/AWe5i61DoT7KS+ltHOrzv6z1iPccDi+ll42jIiIiIiIiIiLqW+aEXgyFRIlvkr7Ez6k/4MLQi+Fj79vp/R1kjvBQeCCjKt24LLU8FQA6NUcgnT2b9Pirr6/HM888gzVr1kAkEkGv12Py5Mnw9PTE22+/jYCAADz++OO2CI2IiPopB6mDrUOgPsxL6YVqTTVyq3NwuPggHhm12NYhERERERERERH1OUqpEhdHzMOPyd9BJpbhhpibu3yMUOcw08RfRTIcZY7wtffryVDJApv0+Fu6dCn27NmDzz77DAcOHIDBYDCumzp1KrZv326LsIiIiGiA8lQ09e77JfVHSERSTAqYYuOIiIiIiIiIiIj6pssiroBCosDlkVfBXeHe5f1DncOQWZVh/N8nylMQ5RYNQRB6MkyywCaJv3///RePPvooJk2aBKlUarLO398feXl5tgiLiIiIBigvpTcAYEPWOoz3m8geokREREREREREFrjaueGbC3/EbYMXdGv/UOcwFNUVoVZbC4PBgJTyZAxy5fx+1mKToT7r6urg6elpdl19fb2VoyEiIqKBzl3hAQBo1OswK/h8G0dDRERERERERNS3udi5dnvfUOcwAEBmVQY8lJ6oVFdyfj8rskmPv6ioKKxfv97sui1btmDw4MFWjoiIiIgGMplYBhe5CxxljhjlPcbW4RARERERERERDViBjsEQCQIyqtKRWp4MAIhyY48/a7FJj797770X9957L+rr6zF79mwIgoCjR49i9erV+P333/HZZ5/ZIiwiIiIawKLcohHsFAKpWNrxxkRERERERERE1C0ysQz+DoHIUKXDTiyHp8ITbnZdnyuQuscmib9p06bhnXfewRtvvIFVq1YBAJYsWQIfHx+89dZbGD9+vC3CIiIiogHspYmv2zoEIiIiIiIiIqJzQqhzGDKr0gEIiOIwn1Zlk8QfAMyePRuzZ89GRkYGKioq4OzsjPDwcFuFQ0RERAOcIAi2DoGIiIiIiIiI6JwQ6hyGlSd/RaO+EdfH3GTrcM4pNkv8nREaGorQ0FBbh0FEREREREREREREREQ9IMQ5FNWaagBAlCvn97MmqyX+vvrqq05vKwgC5s+f33vBnPb999/jiy++QElJCaKjo/Hss88iPj6+189LREREREREREREREQ0UIU6hQEABACRblG2DeYcY7XE39KlSzu9rTUSf2vWrMFrr72GJUuWYOjQoVixYgVuv/12rFu3Du7unGSSiIiIiIiIiIiIiIioO3wd/CATy+Ct9IGD1MHW4ZxTrJb4S0lJsdapOuWrr77C1VdfjSuuuAIAsGTJEmzZsgW///477rzzzg73F4kEiEScK6grxGKRyf8n6st4v1J/wXuV+hPer9Sf8H6l/oT3K/UnvF+pP+H9Sv0J71fqe0SIcY9BkFMwJBLT+5L3a++y+Rx/tqDRaJCYmIi77rrLuEwkEmHChAk4dOhQp45x5Mg+FBUV9VaIRERERERERERERERE/dZU7WSI68VYt+5vW4cyIFx33XWd2s6miT+1Wo2cnByo1eo26+Li4nrtvBUVFdDpdG2G9HR3d0d6enqnjjF06Bj2+OsisVgEJycFVKp66HR6W4dD1C7er9Rf8F6l/oT3K/UnvF+pP+H9Sv0J71fqT3i/Un/C+5X6E96vvcsmiT+NRoMXXngBf//9N3Q6ndltkpOTrRxV1+j1Buj1BluH0S/pdHo0NrIwU//A+5X6C96r1J/wfqX+hPcr9Se8X6k/4f1K/QnvV+pPeL9Sf8L7tXfYZADVZcuWYefOnXj99ddhMBjw7LPP4rXXXsP48ePh7++Pjz/+uFfP7+rqCrFYjLKyMpPlZWVl8PDw6NVzExEREREREREREREREfUGmyT+1q1bh4ULF+LCCy8EAMTHx2PevHn48ssvMXLkSGzatKlXzy+TyRAXF4fdu3cbl+n1euzevRvDhw/v1XMTERERERERERERERER9QabJP4KCwsRGhoKsVgMuVwOlUplXHfJJZdg3bp1vR7Drbfeil9++QV//PEH0tLS8MILL6C+vh6XX355r5+biIiIiIiIiIiIiIiIqKfZZI4/T09PY7IvICAAe/fuxYQJEwAAmZmZVolhzpw5KC8vx/vvv4+SkhLExMTg888/51CfRERERERERERERERE1C/ZJPE3ZswYJCQkYMaMGbjqqqvwxhtvID09HVKpFBs3bsTcuXOtEseNN96IG2+80SrnIiIiIiIiIiIiIiIiIupNNkn8Pfzww6ioqAAAzJ8/H0DTvH9qtRo33XQT7rvvPluERURERERERERERERERNRv2WyoT09PT+P/nj9/vjEBSERERERERERERERERERdJ7LFSQsKCpCYmGh2XWJiIgoLC60cEREREREREREREREREVH/ZpPE3wsvvIC//vrL7LrVq1djyZIlVo6IiIiIiIiIiIiIiIiIqH+zSeLvyJEjGDdunNl1Y8eOxeHDh60bEBEREREREREREREREVE/Z5PEX11dHSQS89MLCoKA2tpaK0dERERERERERERERERE1L/ZJPEXHh6OjRs3ml3333//ITQ01MoREREREREREREREREREfVv5rvd9bJbbrkFTzzxBEQiEa644gp4eXmhuLgYK1euxK+//opXX33VFmERERERERERERERERER9Vs2SfzNmzcPpaWlWLZsGX7++Wfjcjs7OyxatAiXXXaZLcIiIiIiIiIiIiIiIiIi6rdskvgDgDvuuAPXXnstDh06hMrKSri4uGD48OFwcHCwVUhERERERERERERERERE/ZbNEn8A4ODggMmTJ9syBCIiIiIiIiIiIiIiIqIBwWqJv/LychQXFyM6OtpkeUpKCpYvX460tDR4eHjglltuwYwZM6wVFhEREREREREREREREdGAILLWid555x08+eSTJsvy8vJwww034L///oNcLsfJkyexcOFC7N+/31phEREREREREREREREREQ0IVkv8HTx4EBdffLHJsq+//hp1dXX45JNPsHLlSmzatAlDhw7FZ599Zq2wiIiIiIiIiIiIiIiIiAYEqyX+ioqKEBkZabJs8+bNiImJwaRJkwAAdnZ2uPHGG5GammqtsIiIiIiIiIiIiIiIiIgGBKsl/gRBgCAIxv9dWlqK3NxcjB492mQ7b29vVFRUWCssIiIiIiIiIiIiIiIiogHBaom/0NBQ7Nq1y/i/N2/eDEEQMHHiRJPtSkpK4ObmZq2wiIiIiIiIiIiIiIiIiAYEibVOdNNNN2Hx4sVQqVTw8PDAjz/+iKCgIEyYMMFkux07dmDQoEHWCouIiIiIiIiIiIiIiIhoQLBa4u+SSy5BUVERvvvuO6hUKsTFxeH555+HRNIcQllZGTZv3oz777/fWmERERERERERERERERERDQhWS/wBwIIFC7BgwQKL693d3U2GAyUiIiIiIiIiIiIiIiKizrHaHH9ERERERERERERERERE1HuY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgCY+CMiIiIiIiIiIiIiIiIaAJj4IyIiIiIiIiIiIiIiIhoAmPgjIiIiIiIiIiIiIiIiGgAktg7AFj766CNs3boVycnJkEqlSEhIsHVIRERERERERERERERERGflnOzxp9VqMXv2bFx33XW2DoWIiIiIiIiIiIiIiIioR5yTPf4eeOABAMDKlSu7fYza7CwAgMzVFVJHJ+NyTUU5tNXVECQSKP38jcv1jY2oz88DAMg9PCBR2hvXNZQUQ1dfD7GdHey8vI3LdeoGNBQVAQDsvH0glsuN6+oLC6DXaCCxt4fc3cO4vLG2FuqyUgCAws8fIknzn7guNwcGvR5SJ2fIXFyMy7WqKmgqKwGRAPuAIONyg8GAupzsput0c4fUwcG4Tl1ehsaaGoikUih8/ZqvU6tFfUF+U8yeXhArFCbXqaoE6jUGSN08m6+zvh4NJcVNMfv4QiSTNV9nQT70Wi0k9g6Qu7s3x1xTA015GQBAGRAIQdScw67NzQb0BkidXSBzdjYu11RWQquqgiASQRkQ2HydOh3q8nLNX2dZKRpra9tep0aD+sKCpuv08obYzq75OouLoGtogFihgJ2nl3F5Y10d1KUlTdfp6weRVGpcV5efB0NjI6SOjpC5ujVfZ3U1NBXlTdcZGARBEJqvMycbMBggc3GB1KnldVZAq1JBEIuh9A9ojrmde9B4nXI5FN4+xuU6tRoNRYVN1+ntDbG8+TrriwqhV6shViph59H892ysq4W61MI9eOY6nZwgc3Ftvs4z9yAA+6Bg43KTe7BbZc0TEqXSuM5iWWtoQEOx+bJWV5APbb263bKm9A+AIBY372OhrGmqqqCtqmxb1vR61OXmNF1nT5S14mLoGuohtlPAzqv5HjQpa63uQWNZc3CA3K33y5rc3QMSezP3YKvrNLkHu1PWLN2DbcqaCpqKiqbrbF3WzjzvLZW1rjzvS0ugq6szU9baed6fLmtt7sHTZU0sEcHZcRBaqsvLhUGns1zWBAH2gRae965ukDo6Nl+npbLW4h7sTlmz/Lw3vU6Te7A3y1pZGRprzZS1ls97S2Wt1T141mWt9T14uqy1vQfNlzWTe9BSWZPJoPDxbY65nee95bLWied967KmUkFVWYwaVT3s/JpjBtopa915t+pOWbP0btXedfZCWWvved/psna271atyprxed+6rJ2+B3u/rJm/B7tV1rr1blWJ+vKK9t+terKsdefdqk1Z+z97dx4eVXX/cfwzM5nJnpBA2JewGRBkRwRRKoI7KiCKVXCrLRa3uhTbKkjV4oJWXNpad9BWRcW6a6m/ugYFiyiCyhoIO1nJnszc3x9J7iyZGSYwk2Xyfj2PD+bcO/eekznfO+ecb+4d/2MrKczzmLpYa9HzGJ9YO9J5TG2sBRlbNcE8pkE7PcZWCR0zpDTPPhhCrDGPiVistYR5TDhjLeDY6gjXDEp275WtMF41scmS3V3no5rHNNGaQZPNY0KOtSDzmMPFWljGVp6x5n8eE9Y1g6BjqxBj7QjGVjXl5SrZkSNnjathOwPMY5pszSDQ9b451gwCzGNCjbWjHlu1tDWDpprHeKwZxHQKcb7WqtcMwjCPaY1rBsHGVi1lzaCR13urXIp3dZKs7mN5xlrAeUwYYy3i8xgz1gLMYxoRa/Vjq4yMwQpFm0z8hcOmvz0qSepx7lR1Gn+SWb5n1Wfa9+knik1L03G/u8MsrzxUar6m7+wrlDb4OHPbvpXvq+C7b5Xcp6+y5sw1y8t37tWmvz0mSRp4w02K9Zj85L7+skpzc9V+xEj1nnmJWV605Sdte+lFSdLQBX9UTJz7Arlt6dOqLilRl4mT1O2Ms8zyA998rV3vvyurw6ERd99rlruqq80695o2QxknjDW37frsYx1Y9YXiOnbU4FtuM8srCorM1/S/8mqlDhhobst5502VbPpRiX36q99VvzTLy/bu0qYn/yZJGnTzPDk6uYNtxyv/UPm+vepw/BhlXnCRWV64aaO2L39ZkjT8rkWyeQTU1qefkLOyUt1OP1NdTp3s/j3/7yvtWfmhYhISNOzOu83ymupKs869L7pY7UeONrft/Pg/yluzWgldu+nYG2921/lAvvmarF/9Wsl9+5nbdr+1QsVbNqvdsYPU7/KrzPKSXTu0+dmnJEnHzfu9YjwuEDv+uUwVeQfVcdx49Tx/mlmev/E77XijNkE9ctEDstjck5Utf39cLqdT3c+eos4TTjHL936Vrb3//UiOlBQNuf1Os7y6rMKsc59LZit96DD3+f/zgfK/Wauknr004NobzPLK3fvN1wy49gbFelxwd/3rVZVs3660IUPV99LLzPJD27dqywvPS5KG3L5AMXHuC/H2Zc+oqqhInU7+mXqcc65ZfvC7b5T7zluyWK0aee9is9wwDPP8Pc+bqo4numNt9xefav/nnyq2fXsdN+8P7jofKjFf0++yK9VukPtiuPfDd1X4/Xol9+2nrF/92iwv379Hm/72uCTp2BtuVmy3brLV/a53LH9ZJbk71X7kKPW+6Ofma4q2/KhtL/1DkjTszrsUE+v+8Nj63JOqKStTl1Mnq9vpZ5rlB75Zo10fvCebw6HhHrHmrKpxx9oFFyrj+BPcv+dP/6sDX2YrvmMnDbplnrvO+YXuWPvFr5R6TJa5bc97b6roxx+UmjVA/T1irXRPrjY99YQkadAt8+Tw+GDb8fKLKt+/TxljxqrX9BlmecFPG5Tz6iuSpOF33+sda0/9Tc6qqoax9vWX2vOffzeMtapyd6zN/Lnajxhlbtv535XK+3qNErp117E33GSWV+3ziLU5c5Xcp6/7d/PWCh3aslntBg1Wv8uuNMtLdm7X5uefkSQd97vbFeMxWM/551JV5uWp44knqed5U83y/A3face/VkiSRt73oNcAavPfH5fhcjWItT2rPte+T/4rR2qqhvxhgbvOZe529r30MqUNGer+3ax8XwXfrlNSZqYG/Pp6s7xi9wHzNQN9Y23FcpXsyFH6sOHq8/NZZnnxti3a+uJSWSwWdXrgPtls7uv99mXPqKq4WJ1/NlHdzzrHLK+PNavNphGLHjDLDafTHWvnT1PHcePNbbs//0T7v/hMce07aPC835vllUWH3LF2xS/UbuCx5ra9H7yjwg3fK6VvPx3jGWv7dmvTE3+RJB37m1uU4DFY3vnayyrbvUvtR41W7wvdd+QXbflR217+pyRp2MJ7FBPrHhCbsTbpNHU77Qyz3Iy12FgNv2uRWe6sdH+uZc64SB1GjzG35X76kQ5+9aXiO3XWoJt/665znvtz7Zir5yilvzvJuvvdf6n4px+VOmCg+l95tVleumuHNj3zpCRp8K23yeExwM95+QVV7N+vjBPGqde0C8zygh++V87ryyVJI+65T9YYdzu3PPU3uaqq1O2Ms9Rl4iSzfN+aVdrz0UrZk5I0dP4fzfLqyiqPWLtE7UeMdP+e/+/fyvvf10rs3l0Dr3fHWuW+PHesXXOtknv3MbftevN1Hdq6RWnHDVHfWZeb5Yd2bNeWpc9Kko773R2KSXNPGHNefE6VBQXqdNLJ6jHlfLP84PpvteGdf6mmxqWR9z0oT5ufeEyGYajHlPPU6aQJZvmeL7+ojbV27TTk9/PN8qqSMneszbpcaccNcf9u/v2+Cr7zE2u5+9yxdt2NivUYYOeuWK7SnTuUPmyE+vz8UrO8eOsmbf3HC5KkofP9jK0OHVLnUyaq+5kesfbtWuW++7asMTEa8af7zXJXjft633PqdHUce6K5bffnH2v/F58rrkOGBv/2d+46FwaOtT3vv62ijRuU0q+/jvnlNWZ52b7d2vT3v0qSBt10qxweE7adr/5TZXv2qMPoMcqc4TG22vyDtr/ykiRp+B//JJtHH9z27JOqKS9X18mnq+vk083y/d+s0e4P31dMfLyGLbzHLHd69MHMGTPVYfTx7t/zJx/p4OovldCli479za1mefnBgsCx9s6/VLzpJ6UOPFb9r/iFWV66K0ebnqkdWw3+7e/l6OAeW+W8tEwVBw4oY+w49ZrqE2srXpUkjfjT/bLGuBcGtjz1V7mqq9XtzLPV5ZRTzbFA3pdfaNd/VsqenKyhdyw096+ucLezz88vVfqwEe7f80f/Vt7ar5XYo4cGXvcbs7xyj/t6P+DX1yk2s7f7d/PGqyrZvq1hrOVs05Zlz0mShvx+vmI8JozbX3hOVYUF6nTyBPU45zyzPO/7b7XzrX/JYrE0iDX3POZ8dRp/slkeaB7jFWuzL1faYM9Ye692HtO7j7KuudYs95rHXP8bxXosNOSueEWlO3eq/fCR6n2xxzxm6yZt+2ddrIU6j1n3P+167x1Z7XaNuOc+s9wz1hrMYz7/WAeyv1BcRoYG3+oZa8UB5zFmrPU/RsdcPccs95rH3PRbOTq7F+h2LP+nyvf6ibVg85hn/i5nRYW6nnaGuk46zSzf/7+vtHvlh4qJT9Cwhf7nMX1n/lwde3Qy+23ux//RwTVfKaFrVx174y3uOnvMY4755TVK6dff3Lb77TdUvHlT0HmMb6y55zEnquf5083y/B/Wa8eK1yQ1Yh6zOlt7/8/PPKa80mMeM0vpQ4e7zx9oHuMZa3OvV2yvTHNbSPOYP8xXTFw7c9v2F55VVWFhg3lM3vp12vn2m0HnMQ3WDLI/077PPlFserqOu+12d52DzGP2/fs9Faz/ruGagZ95TL3AawY+85gYd6xtff4p1ZSW+lkz8D+P8VozmD5DGWM8Yu1T//OYioIi/fj4I4qJsarvFVcrqZ/7eh9oHhPKmkHGmBPUa/qFZrnXPMY31gLNYwKtGVRVBJ7HBFgzqNofeB4TcM0gN0ebn3taknTcbX9QTLx7wdeMtWDzmHsXeyU4N//9MRnOhvOYvV9+ob0f/1/QeYzvmsH+/3yg/HXfKKlXpgbM9ZzHBFkzeONVleRsV/rQYepzyWyzvH4eIwVeM+g84RR1P3uKWW6uGdisGrnII9ZcrsOuGTSYxxR7xNrlV6ndsYPcvxs/8xibzaqS3Fz9+PgjMgxDx954s2I9FpaDzmPMWLu7cfMY3zUDj3lMgzWDz/5PB75c5WceUxhwbBVwzWD3Tm16+u+SGs5jAq4Z/Pi9cl7zP48JGGt185iYxEQNW3CXWV5TVR041gLMY4KuGdTPYwYfp76zrzDLg64Z/ON5Vebnq9P4k9Xj3PPN8rzvv9PON4OvGfQ451x1Ovln7t9zoHlMqcfYKtQ1g137A85jPNcM+s+q/Vyz2awq27ZZW19cJkkaesdCr7GVuWbgO48JZc0g0DzGJ9aCzWPMWPOdx+zdZc5jGq4ZvKSy3bvVYdTxyrxwplnuOY/xXTPY9uxTqikvU9dJp6mrR6ztX7tauz98X7a4OA3/45/M8qBrBnXzmPjOXTToJs95TOBY2/3OGwHmMR5rBr/9nRweybKA85gfN7jXDHznMU96z2PqhbRmcPGlaj88hHnM3oOB1wz+9ZoObdvqZ81gm7YsfU5Sw3lMzovPqaqwUJWnTVLH0842y/O+/1Y733xDkjTq/ofkKfCawefa98nHcrRL05DfB5jHNFgzqJ3HJGX21oBfX2eWB18z8D+PKd52+DWDLqecqm5nutsZ0jxm6gXKGDvO/Xuum8dkPvmEQkHi7wjZ7bXBlZQUqzSPv6zMS4iV3W6TI9buVV5hVJqvSUmJ99oWH+9Qid2muDjv11jz4s3XpKbEK9ljW2ysXVV2m+LjHV6vqUqOM1+T1i5R9iT3NocjRrLblJjoXedDSbWvsdltXuXOqqqA7TyQ4JDdblOsTzvLqhICtjM21q4SSbGxMV7l8qhzamq8Er1eE6Mau00JCd7nr0jyaGdaolf23eGIUY2rpkE7CxNr3xu7w/v8NbEWj3bGeW3bF+9Qsd2mWJ/3xl7m3c52Htvi4h0q9/PeuLzamaB4j22O2Bg57TYl+NS5zKOd7dISZfX4qxW7I0aumoZ1Lqh7bxw+7ayy1pjHSk6Oa9AH7X7aaStK8OqDKZ7tjLWr0m5Tgk87azza2S41QbHtvPug4acPltS102K1epUbhhHwvcmr74M+7axwVbjb6SfWSv3EmiUl3qsPJnm+Nw6b7H7aWeX53rRLlD3Ru52W6obtLK6PNZ86O6vs7jr7tNMda96via0MHGtx8Q6V2W2K86mz4dHOdqkJSvAba47gsebx11Z2R4yshlOJPnUOFGvVDgVsZ32sxfm0014SHzjW4uyq8BNrTp92xnm20xEjl92mRJ92lvm003MQb7fbZLgsDfpgfl07fWOt0lIdMNYS6q/3PtdOW6FHO1MTvGItNq421nzbWe0Ra/W/n3pmrPm0sz7WrDHedXY5nQFj7WB9O33em/KaMned/VxTSv30Qe9YS/CKtdg4u6r9xFql53vTLsHrrwQDxlpdnWN8Y60yJmA799d9fvvGmqMiPnA74+x+r/eGTzu9Y81ee733eW/Kk2I9rikJXrHmsNvkNGwN6lwYoA9W242AfXBvvP/P75hD3mOO1MbGWjvvWHPE2uXy8/ldmlDbrpgY7+u9VBdrhhEw1hpc71UVsJ3x8Xa/sWbNDxxrcXG1Yyvf96Y62budjmTvdqrCpkSfdh6qq7PV7hNrNTWBYy1AHwwaa3H22uu9z+eafPpgok8frPbTzkqfdsZ4/KWq3REjS03DWCsKEGs1FbaA783+AGNIR3mQz7X6WPNpp8unzvF+Ys33vSlP9r7ee/41psNuk1MuJfm0My4+wNgqxuXRTu867w3QTluxdzt9Y83f9d5zbJXqE2uxsfXXe59Yqx9bWSx+Y01Sg3YGnMd4xVoY5zEJYZjH1PVB33mMq7raI9ZiG8Raob95THVp4PlaoFgLaR5zmLGV7zzGGTjW7A7vdnrOYxISY826S9K+AH3Qdx7jL9Z82+k5j/GNNXMek3AE8xifdhYk+P9cq7I5g/ZBv/OYYLEWyjymXaLXPCb2qOYxvrHm/7053DzGX6xZUhO8+mCSv1hr7DymqjHzGM81g9DmMWVVCYqJqU1O+Z7HnMccQaz5tjNYrJnzmBDXDEKZxzRYMyht/JqBM4Q1g8POYzwSfw57jFxWZ1jmMfWx5vveeM5jGqwZhDCPCbRm4Ls2Ys5jbN7XQcPlCtgH62OtwTzGWR60nf7mMYX7ZPbbUOcx3rGWENqaQf3nWpB5jG8f3B/vP9aCzWPi6j/XGjWP8f+5Vu7TzkitGQSax3itGaQmHP2agTmP8X5Nqcd8LdCagW87A81jjmTNwFoQ2ppB/TggJSVeFb7zmJSGseY7hiypn8c0Zs0gofFrBnFxdr/XFN95jO/nWrWfMaTnPKbhmoGtUfOY4GsGAWKtPHis+ZvHhLJm0GAe49kH2yV43SUYaB5zRGsGAcYpMcWNXzOo8XhvfOcxjli7XHXXVc/1rNJE71jzFHDNIMBcOviaQYB5TJA1g0DzmKBrBnXzGN/PtYDzGM81g+SGsVZod4+pD8diGIYR8t4t2OLFi/Xkk08G3efdd99V3759zZ9ff/11/elPf9KaNWsafb4da7+XxWpRbLs02VPcjxKorH9Mky1GCR5/beeqqVFZ3a2lcX4e9VlTXi5bbJziO3nfWlped2tpvJ9bS51VVYpJSFScx19cVpeWqDKv7vZmn1tLS+seJeDwvb257tZSi59bS0vrbi2N9fPYjuqSEln93MZd5vEoAc9Fo6q8g4q3uVTutMjR3uO2X59H5HgOEsrqbm+2+3n0W2XdbdyJvo/t2LlDhmHIkZoqR6pHOwsLVVV3e3Oiz2M7Susf2+HTzoqDB1VTVvvYDs+/MnF63MYd7/MogfJ9++SsrFCMn0cJVNQ9SiDB97Edu3bJ5ax9lECszyNyKutu40708ygBQ7W3Nzs8bm+uLChQ9aHaR+Qk+jwiJ2AfrGunzRGr+M7ej+0or7uNO973ETl798pZVakYP7dxV9Tdxu3bB93tTFGsx50hVR6PyEnyeUSO2QePKNYaPkrAb6xVVKh8v3es2WxWpaTEa++PW1RdURk01hIbPEogQKwVFaqqqKhhrLlcKq17lEDAWPPpg8Firbz+Fvu4OMX7PJ6kPtYa9MH6WPPz2I6IxFr79rInhhBrnn3wSGItYB/0ibXiYlUW1j1KwCfWSjweJeAv1hp1vT94QDVlZX5iLdj1vj7WvPtgfazZrBZ1HthfJWXVcjpdkqTS+kcJBIg1ixo+jsqMNd9HCQSKNc8+eCSxFuB63yDWPPtgJGMt76CqS4Nf7wPFWoM+GCzWdu+qHcgFizU/j2ky6h7T5PB5bIe/WPPsg4FizebnsR0Br/cBYy2U6713rDlLS+SoLlNJSYXiPR6pIgWLtSMYWx1RrPkfWwVrZ0RiLdjYKsRYO+qxlW+s1fdBP4/6rCpuglgL1AePJNYaMbaqHwsc3LFH5QUFQcdWYY21IxpbecdaoLGV5I61sMxj6mOtJc9j/Dwip7HzGDPWgoytmmQe49tOj7FVQkaG2nfNUHFxuZxOV0ixxjwmcrHWnPMYdzvDGGuBxlahrBn4mcdU7tujpKQ41SSkyuLwqPPRzGOaas2gqeYxocZakHnM4WItPGMrz1gLNI8J35pB0LFVqLHWyLGVzWZVgl3av3m7nC6jQTsDzmOaas0gwPW+WdYMAs1jQoy1ox5btbg1g6aax7jXDBI7dVRKSryKi8tVeehQ085jmmjNICzzmNa4ZhBsbNVS1gwaeb23GE6ld+2oKnuCuZ7lGWuB5jFhjbVIz2PqYi3gPEaNiLW6sVWPoe67Z4OJmsRffn6+Cuqe/xpIjx495PC4YBxN4u/AgUONfk1bV//X/QUFpaqpcTV3dYCg6K9oLeiraE3or2hN6K9oTeivaE3or2hN6K9oTeivaE3or0cmIyP58Dspih71mZ6ervT09MPvCAAAAAAAAAAAAEShqEn8Ncbu3btVVFSk3bt3y+l0auPGjZKknj17KtHjmdsAAAAAAAAAAABAa9EmE3+PPPKIVqxYYf58/vnnS5KWLl2qMWPGNFOtAAAAAAAAAAAAgCPXJhN/9957r+69997mrgYAAAAAAAAAAAAQNtbmrgAAAAAAAAAAAACAo0fiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCMc1dgaaWm5urv/zlL1q1apUOHjyojh076txzz9WcOXPkcDiau3oAAAAAAAAAAADAEWlzib+tW7fKMAz98Y9/VK9evfTTTz/pjjvuUHl5uebNmxfycQo250uS4jskKK5dnFledqBMlUUVssZYlZrZzix3VjtVnFMkSUrsnCRHkjvJWLLnkKpLqxUTb1dyt2SzvKa8Wod2HZIkJXdPUUyc++06tLNYNZU1ciQ7lNgpySyvOlSp0n2lkqTUzHayxrhv6izaWiCXy1BcWrzi28eb5RUF5SrPK5fFalG7PmlmuWEYKtxSIElK6Jio2JRYdzv3l6qyuFI2u00pvVLd7axyqnhHbTuTuiTLnmh3t3P3ITn3l6usukbxnRLN8urSapXsqW1nSo8U2WLd7SzeUSRnlVOxybFK8HhNZXGlyvbXtrNdnzRZrBZzW+HWAhkuQ/Hp8YpLd7ezPK9cFQXlslotSvVop8vpUtG2Qr/tLN1XoqpDVbI5bErp6dHOyhoV7yyubWfXZNkT3O08tOuQasqrZU+0K6mL+/2sLqlSyd6S2nb2TJXNYTO3FW0vlKvGpdjUOCVkJLjbWVShsgNlte3smyaLxaOdWwpkGIbi28crLs2jnQfLVFFYIavNqtTe7dztrHGpaHttO337YH07Y+JilNw9xSyvqajRodzadiZ3S1ZMvEc7c4tVU1EjR5JDiZ09+mBJlUrr2tmgD9a1M65dnOI7uNtZ3wclKa1fulnu2QePJNaSOifJHkKsVZdVq2S3/1gr3lGkyrLq4LHWu52sthBiLb9c5fl+Ys1lqHDrYWLNtw8eJtaqy6plT7ArqatHOz1jzacPmrGWEquEjpGPtcROiXIkHz7WPPvgEcVar1TZ7IePtYrCCpUf9B9r5vU+UKz59MGgsba3RFUlfmIt2PW+PtZ8+2BdrMXYrEod4a6XJBVtK5TLGTjWLBaL2vUNcL3PSFBsagix5tkHjyDWAl3vfdvp2QcjGmv7SlV5yE+seV7vA8Wabx8MFms5RXJWHybWfK/39bHm2wcDxZpnHwwQazGxMUruEeL1PkCseV7vGxNrB/eXq7ioXMken1FS4Fg7krHVEcVaoLFVsM+1CMRa0LFVqLF2lGMr31ir74O+sVbfByMdawGv90cSa0cytsorU8mBsuBjqzDGWrCxVcixFmBsJYV3HmPGWkuex/jG2pHMY+piLejYqgnmMb7t9BxbpXRNltLc5wkp1pjHNHoeE2qstYR5TFhjLdDYKpQ1Az/zmEPbCuVMLZcr0SaLR9wc1TymidYMmmweE2KsBZvHHDbWwjGP8Yy1QPOYMK4ZBBtbhRxrRziPKdiUrxqny++agb95TJOtGQS63jfHmkGgeUyosXaUY6uWtmYQqA9Gcs0gtZv7NU09j2mqNYNwzGNa5ZpBsLFVC1kzaOw8xmpIjkxJ7kN5xVrAeUw41wwiPY+pj7VA85jGxFrd2Cojw13fYNpc4u/kk0/WySefbP7co0cPbdu2Tf/85z8blfjLvvMTySINvmyo+pzR1yzf8e+t2vreZiV0SNCkR88wy6sKK5S98BNJ0uibTlCX0V3NbZte/UF7vtql9gM76MT57roV7TpkvubkP01UO4/Jz3dPrlXhtgJ1H99TI+aOMsv3fn9A/3t8jSTp9CfO9uqcax5cpcriSvU/P0sDLxpklu/5PFcbX/5eNodNZz9/nlnurHKa5x9y1XBlTuptbtv+3mZtX7lNyV2TdcqDk83yiv2l5mtOmDdOHYd1NrdteHG98r87oLRj22vMbSea5QU7ipT9p88kSac8MMnrg23dX7/Wodxi9TolU0N/OcIs371un775+/8kSWc9e65iPC6QXy36XDUVNRow41gdM22AWb7rkxz99PoPciQ5dMaT55jl1ZU1Zp2HXzNKPU7uaW7b+uYm7fwkR6m92mnCvRPN8rLd5eZrxt1xkjocm2Fu27jsWx38/oA6j+yi428Za5bnbS3Qlw9kS5JOffh0xXp8SH3z2BqV7itR79P76rjLh5rlO7/eo++eXSdJOueF870+vFbd/alcNS4NuuQ49T2nv/s1H23X5rd+UlxanE77y1lmeUVJlVnnUTccr64ndDe3bX7tB+3KzlVav3SddNfPzPJDe0vM15z0x58prb/7gvv9s+uU/1Oeup7QTaNuGGOW7/8hT2uWfClJOu0vZ8rhcSH+35+/VHl+ufqe3V+DLj3OLN/35W59/+J3slgtmvLiVLPcMAzz/MddPlS9T/eItQ+2aOsHW5TYMVGnLjndLK8qcL83x988Vp1HdTG3bXplo/as2a0Ox2Zo3B0nmeVFucXKvutTSdKERRMVl9lOtrrf9bon/qeCrQXqcVJPDf+1O9b2rD+gtX+pjbUz/n6OYpLdsbb6gWxVlVTpmKkDNODCY83y3Z/v1A+vbFBMbIzOeu5cs7zGow8OvXqEek3MNLdte3ezcv6zTcndknXKYnesle/ziLXfnaiOQzqZ2374x3rtX7dPHYd20gkesZafU6hViz6XJJ2yeLLXB9u6v6zRoV2H1OvU3hr6i+Fm+a5v9mndk3Wx9ty5ionxiLU/fa6ayhoNuPBYHTPVI9Y+ztFPKxrGWlW5R6z9epR6nOQRa//6STs/3aF2me108iJ3rJUeLDNfc+IdJ6m9Z6wt/VYHNxxQl1FdNfrmE8zyg5sL9NWDtbE26ZHTFZvhEWuPrlbp/lL1Ob2vBnvE2oGv9+i752pjbco/pnoNoFbd9akMl9Eg1nas3KYt72xSfHq8Jj9+pllecajSI9bGqOsJ3cxtm17bqN2rdin9mPYav3CCWX5or/v9POmun3kNbtY//Y0KNuer29juGnn98Wb5/h8Oas2Sr2SxWNTlH9PNPitJX/95lSoKKtRvyjE69ueDzfL6WLPGWHXOsvPNcpfT5Y61K4aq92nuWMv5YIu2fbBFiZ2SdOrDp5nllXnuWBtz61h1GuGOtZ9e3qC9X+9Rh0EZGne7O9YKPWLtZ/ed6jVY/u7va1WUU6geJ/fS8GtGmuV71h/Q2r/WxtqZT52jmFg/sTZtgAbM8Ii1z3bqh+UbFBMXo7Oe9Yi1CncfHPbLEep5Sqa5bds7m5Tzf9uV3D1FpzwwySwv3+v+/B77+/HKOK6jue2HF77T/u/2q9Owzhozb5xZnr+tQKvu+0KSNPHByYrt6hNruw8pc1JvDbnKHWu5/9urb59eK0k6+/nzZLO7388v7/lMziqnBl40SP3Pz3K/5r/btemNHxWbEqvTnzjbLK8sqzbrPGLuKHUf7461LW/8pNzPdqhd7zSd/KdTzPKSAx6xtuBktR/Qwdy24fl1ytt4UF2O76bRv3Ff7w9sytfqh1ZJkiY9eoZiO7hH62uXfKWyg2Xqc2Y/DZ49xF3nr3brhxfWq7rGqSn/cF/vJWnVHz+VYRgaNGuI+p7Vzyzf+R//sVZd5DG2unGMuozxiLVXN2r3lw1jrXi3+3Pt5LtP8Rpgr396rQq2FKj7uB4acd1os3zfhgP6+tHVkhqOrb5+aJUqCivU/9xjNPBid6ztzd6lDf9cL5vdprOXusdWrhp3rA25cpgyJ/cxt+W8v1nbPtyqpM5Jmvhnj1jzuA76xtqP//xe+9buVcbgjhr7h/FmeWFusbLvrou1+09VSg93rH37xP9UvKNIPX+WqWG/co+t9ny3X2v/9rUk6cynpygm1t0HV9/3harLqpV1wUBlTR/ofs1nO/XDqxtkT7DrzKenmOU15e4+OOxXI9XzZ73MbVvf3qQd/92ulJ6p+tl9p5rlZXvc15SxfxivjMHesXZg/X51Gt5ZY37rjrW8rQX68v7aWDv1z6cp1mOS+c3ja1Sy55AyJ/fRkCuHmeW5/9urb5/5RpJ0zrLzvSZlX97zmZzVTg2cOUj9z8syr6s7/rNdP674QbGpcTr9b+6xlWesjbxutLqN62Fu27LiR+V+vlPt+qTp5Hs8Ys3j83v8nROUntXe3Lbh2W+U92New1j7MU+rH64dW01+7AzFtveItYe/Ullemfqe1V+DZnmMrVbv0ffLvpXFYmkQa/XnHzx7iPqc6Y61QPMYr1j7zQnqcrx7HvPT8o2185gBHXTiggDzmHtO8VpQ+e6ptSrcWqDuJ/bQiGvdsbZ3w0H97zH/sRZwHvNFrja+9H2DWHNWB5nHvL9F2/+9VUldkjXxIY95jMd10HceEyjWgs1jvv3b1yreWdwg1oLNY1bf+4Wqy6s14IJjdcx099hq96c79ONrG+VIdOiMp/zPY0b+erQ690o3++3Wt37Sjo9zlNorVRPu9Yg1z3nM7SepwyD32Ko+1jqP6KLjbw0wj/GNtfp5zGl9dNwVw8xyr1gLMI859ueD1W/KMe7X/N92bXqz4TymstQ9jxl5/fHqNvbw8xivWFs4QenHuGMtlHnM5MfPlCM9hHnMV7v1/QvB5zEN1gw+3Kqt729WQkaiJj0S4jxm+UbtWb3b/5rBH2tfUz+PqRdozaDBPMYz1havUuWhhrEWaB7juWYw9BfD1etUd6wFmsdU7C/VZws+lj3GplG3nqAOnmOr+nnMkE464XeNXDOYmKmhV7tjzWse47tmUD+PCXHNoKoiyDwmwJpBaV6QeUyANYODWwr01eK6ecyS0xXbseGaQdB5zItTvRKcq+76VC6nnzWD/2zT5rcPN4/xWTN4vTbW0vuna/wff2aWH9oTZM3gmW+UvynwPEYKvGbQ75z+OvaShmsGVptV57xwvlluuEJYM/CZx1Tle8TaLWPVeWTweYzNZlXB1gJ9tuBjGYahCfdOVFyvduZrgs5j6mPtyUbOY3zXDCqCrRlsUs5H/uYxJYHnMS+u1/5v/awZbC/Uqntr1wz8zmP8rRms3at1T/mfxwRaMzDnMcmxOv3v7nlMsDWDQPMYrzWD+Ser/UA/85jRXTX6ptDWDNY+slplB0rV54x+GnyZex6zf80erX/+MGsGlx6nvmd7x5q/eUx5cePXDIr3BJvHuNcMjv9NbTttNqsKNh7U14/UxtrpfztLMXHuBEL9mkGDecyqXdrwj/VB1wwCzWMarBkEmcf89NIG7f3fnobzmJ0e85gGawb/U1FOkXpO6KVhczxizXMe47NmsOb+bFWVVilr+kBlXeCex+z+tG4eE2/Xmc94zGOCrBmY85geKfrZ/aGtGWxc5n8e47Vm8NBpiu0Swjxm7T73msHS82TznMfc7T2PMV8TyprBtaPV/cQQ5jEea/4N1gyeW6e8H/ysGfyUr9V/rl0zaDCPWfKVyvPKNXj6sep3ofu92b96t9Yv/VaSdO4/p8lTwDWDldu05d1NSmifoEmPBZjH+KwZmPOYrPY68c7Q1gwCzWP2bTwYcM1gzYOrVFlUof7nZWngzMPPY4KtGdTPY455f5ZC0eYSf/4cOnRIqamph9/Rg91hk0UWJSXFKs3jLysTE2PlsMfIERvjVe6okRz22l93Skq817b4eLsc9hjFxdm9ymtSy8zXpKZ6vyY2LkYOe4wSEhxe5UXJ8eZr0tK8/zLB4YiRYXcqMdGnzkm1dbY5bF7lziqneazk5DivbQkJ/ttpK/N4jU87Y+suvLGx3u2sTHHXObVdglJ9XlNpj1G8Tzvzk+O82ukZUA5HjKzO2nb5fW8c3nWuctiDtNMhhz1GsXHer7EUVQd8P+Piao8XH+9d5zKPdrZrl6Akn3ZW+3k/DyR5t9Nzwuywx8hlcQVsZ6zD+/dcLqtHO336YF07ffugK7XC3c7U0Np5KCXOo52JivcYxDscMXLaYwL2QYvV4lVuGIZ5rKQkn/cmUKxVy6MPer8mLkCsVaeWesRagvfxHLWx5tsHCz36YLu0BMUme8ea7K4G7Uyqez9jfPpgTWXN4fugT9zYSp0B+2B8vMPve1Ph0wdTvPqgXZV++mCDWIv1iTVXw/cmUKxVxsQEbGe8GWve7VRBlUcfTPDbB+PivV9T6tMHEz3fz/pY83lvfGPNcxDvsMfIcBkhX1PKDWvAPlj/3vj2QWdqecA+aMaaz3tzyON6L9X2g3qxDrtc9pqAsWaNsXrHutMVONbMPujdTnul4dFO/33Qt51VKSVe7WwXwuead6wlypHo/gutQLFW384GsVbhjrWkQH3Qp53WkpqAsRZX306fPlju87mW4tMHa9vpXec8n1jz/Is/hyNGTsMSch+stHnGWrz/99Pnc83Irzx8H2wQa97XFN9Yq/Fzvd+fUPv+2WO8xxySZLfbJEMBx1a+18FYp6XRfdBzbOX7uRYbINaKk73bGefxF3cOR4xcfq4pZqzZfWKtJlis+f9ci6lwhTfWYv3HWoFPH/T8a2mHI0aWaiNgrNl9+mB1XLVHHwztmmIpDjK2ivc/5vCNtWSfdlb5aedBn3Z6Jv4cjhg5ZWnw3tT/nmN92llhtYV1bBUbINZKvGItUQlp7r/Kro+1hETvdibVvTeyqEGsBeqDgeYx3rHm+7sJZR4T2udakc97E8o8pn5s1WAeUx1sHuO/D8aUhxBr8UHmMam+8xi731g73DzGUhP6mMNzHpNQ9/lYPx6IDzCGDGUe49vOssPEWrWfz7WDIcxjAo3vfecxFRZbwPczlFgL/LkWbB6T4BVrsbF2Oe3VAftg8HlMrE87/ffBYPOYQNf7YPOY0MZWDecxwWLNd2zluWbgO7YKOI8pc8pe98eEga63QWMtwJqBbx887JqBqxFrBvbGrxmo8PDzmGBrBqmB1gwON4/xSPzZ7TYZVmuDdiaEMo/x/VyL9z9f85zHBP5cCzyPCbRmEGhsZbH5xJrr8GsGDeYxVe7XBJpL+8ZahQ6Z/fZIYi0tLdHrTpOjmccEWp9r3DzG/3tTEWQeE2jN4HDzmHCtGQSMNa81g9DWrYKtGcQebmylwGsGgdrZYB7jCja2OvyaQcB2JjjMcUBKSrySk73b6XlHbP2agW+s1V/vG7dm4L8PBpvHBFqfCz6P8T+GLDjcmkFV4FjznccEWzMI9LlmPdT4WCv3mUuHMo9pEGt2nzUDP/OY0NYMQhtbGamNXzMo8Ym1BvOYuuuq53pWks/nmqdAawb1Y6vg8xj/+Rjfz7VgawaB5jHB1gxiHTEy7A3XRgLNY7zWDAL0wVBZDMMwQt47CuXk5GjatGmaN2+eLrzwwpBft3nVDlmtFsVn+D5KoFSVhZWy2v3cWrrd49bSZI/bm3fX397s5zbu3LpbS3v4PEpgZ5GcFXWPEujs80g0z0cJeCxmFG4tkOE0FJcep/j2PrdxH6y7vdn31tLNdbeWdvLz2I6iSlkdVqV6/KWTs8rj8SRdk2T3uNiW7yuVw2JVpculhM4ek5XSKpXsLqltZ88Ur8RC8Y4iOSudcqTEKtH3Nu59Ho8S8Hxsx5a627jbxyve61ECZarIr5DF5ucROVsL/bazdG/dYztifR7bUVmjQzvqbuPu5vMogdxi1ZTX1N7G7fHXUVUlVSrdU9vOlF5+HttR7VJsu1glePylUWVRhcr2193G3c/PowQMKb6Dz+3NB8tUWVAhS4zV6y5RV43H40l8+mB9Oxv0wYoaHdpZ/9gOP4/IKa+RPcmhpC6etzd7PEqgt5/HdlS7FJsWpwTfRwkcrHtEjsdfCHr2wSOKtS4+j9UNEGvVZdUq2eUdazabVSkp8dr53V5Vl1cHj7U+fh4l4CfWyvPLVZHnJ9ZcHrdxB4g13z4YLNYO7TqkmrJqxST4PvrNHWu+fbA+1mJT/Ty2ozljzaMPHlGsZfp5bIefWKsorFD5gQCxtqn+kWj+Y823DwaLtZI9Jaou8RNrQa739e307YP1sWa1WdRzaFeVlFXK6XRJkgq3FcqoCRJrFj+Po6q/3nf0fWxHgFjz6INHFGuBrvfNFGul+0pVVdww1ryu9wFizbcPBou1opxCuapcwWOtn5/HNLmMBn0wYKx59MGAsRZn87oLLKTrvW+seVzvQ4216uIqWSucKimp8HrUiBQk1o5kbHUEsRZobBXscy0isRZkbBVyrB3l2KpBrNVf731jrb4PRjrWAvTBI4q1Royt6scC+7blqfRAWdCxVVhjLcjYKuTPtQBjK8kj1sIxjwljrEVsHuMba0cwjzFjLcjYqknmMT7t9BxbJXdJVkaPdiouLpfT6Qot1pjHNH4eE2KsNec8pl44Yy3g2CqENQN/85iS3GIlJcXJkmKX1XPcexTzmBa3ZnC085gQYy3oPOYwsRaWeYxnrAWYx4R1zSDI2CrkWGvk2Mpmsyo+Jka7Nu6Ty2k0jLUWOo9pljWDAPOYkGPtKMdWLW7NIEAfjOSaQUq3FKWkxKu4uFzlhRVNO49pqjWDcMxjWuOaQZCxVYtZM2jkPEYuQxk90uSMs5rrWZ6xFnAe08LWDIKOrepiLdA8plGxVje26nO8+w7NYKIm8bd48WI9+eSTQfd599131bev+7b/ffv26dJLL9Xxxx+ve+65p1HnO3Dg0BHVsy2LqftrkYKCUtXUuJq7OkBQ9Fe0FvRVtCb0V7Qm9Fe0JvRXtCb0V7Qm9Fe0JvRXtCb01yPT5r7j78orr9TUqVOD7tOjhzsbum/fPs2ePVvDhw/XXXfdFenqAQAAAAAAAAAAABEVNYm/9PR0paenH35HuZN+gwYN0qJFi2S1Wg//IgAAAAAAAAAAAKAFi5rEX6j27dunWbNmqWvXrpo3b57y8/PNbRkZGc1YMwAAAAAAAAAAAODItbnE3+eff66cnBzl5OTo5JNP9tr2448/NlOtAAAAAAAAAAAAgKPT5hJ/06ZN07Rp05q7GgAAAAAAAAAAAEBY8eV2AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBSwGIZhNHclAAAAAAAAAAAAABwd7vgDAAAAAAAAAAAAogCJPwAAAAAAAAAAACAKkPgDAAAAAAAAAAAAogCJPwAAAAAAAAAAACAKkPgDAAAAAAAAAAAAogCJPwAAAAAAAAAAACAKkPgDAAAAAAAAAAAAogCJPwAAAAAAAAAAACAKkPgDAAAAAAAAAAAAogCJPwAAAAAAAAAAACAKkPgDAAAAAAAAAAAAogCJvzbsxRdf1MSJE3XcccdpxowZ+vbbb722z5o1S1lZWV7/zZ8/P+gxP/zwQ1155ZUaM2aMsrKytHHjxgb7HOlxp02bplGjRmnYsGE677zz9MYbb3jtYxiGlixZovHjx2vIkCG6/PLLtX379pB+F2j5mqu/StLatWs1e/ZsDRs2TCNGjNAll1yiioqKoMf+8ssvNXXqVA0ePFiTJ0/W66+/3ug2ofVqTf11zZo1mjlzpsaMGaMhQ4bojDPO0HPPPdfoNqF1ao6+mpub2+CY9f+99957QY/93nvv6YwzztBxxx2nKVOm6OOPP/bazlggurWm/srYFc01Fjhw4IBuvfVWnXjiiRo2bJimTp2qDz744LD1ZezatrWm/srYFc3VX3fs2KG5c+fqhBNO0IgRI3TDDTfo4MGDh60v19e2rTX1V66vCHd/ra6u1gMPPKApU6Zo2LBhGj9+vH77299q3759XvsVFhbq5ptv1ogRIzRq1Cj9/ve/V2lp6VHXt7KyUgsXLtSYMWM0fPhwXXfddSFdt6OGgTbpnXfeMQYNGmS8+uqrxqZNm4zbb7/dGDVqlHHw4EFzn0svvdS4/fbbjf3795v/HTp0KOhxV6xYYTz66KPGK6+8YhxzzDHGhg0bGuxzJMddtWqV8eGHHxqbN282cnJyjOeee84YOHCg8cknn5j7PPHEE8bIkSONf//738bGjRuNOXPmGBMnTjQqKioa+dtBS9Oc/fV///ufMWLECOOJJ54wfvrpJ2PLli3GO++8Y1RWVgY87o4dO4yhQ4caixYtMjZv3mwsW7asQX8NpU1onVpbf/3++++Nt956y/jpp5+MnTt3Gm+88YYxdOhQ46WXXmpUm9D6NFdframp8Tre/v37jUcffdQYNmyYUVJSEvC4X3/9tTFw4EDjySefNDZv3mz8+c9/NgYNGmT8+OOP5j6MBaJXa+uvjF3btuYcC1xxxRXG9OnTjXXr1hk7duwwHn/8cWPAgAHG999/H/C4jF3bttbWXxm7tm3N1V9LS0uNU0891Zg7d67xww8/GD/88INxzTXXGNOnTzecTmfA43J9bdtaW3/l+tq2RaK/FhcXG5dffrnxzjvvGFu2bDHWrl1rXHDBBcbUqVO99rvqqquMc8891/jmm2+M1atXG5MnTzZuuummo67v/PnzjQkTJhhffPGF8d133xkXXnihcdFFFx3hb6j1IfHXRl1wwQXGwoULzZ+dTqcxfvx444knnjDLLr30UuPuu+8+ouPv3LkzaOLvSI/r6fzzzzf+/Oc/G4ZhGC6XyzjxxBONp556ytxeXFxsDB482Hj77beP+lxoXs3ZX2fMmGH2s1Ddf//9xtlnn+1VduONNxpXXnml+XMobULr1Nr6qz9z5841brnlFvNn+mt0as6+6uu8884zfve73wXd54YbbjB++ctfepXNmDHDuOOOOwzDYCwQ7Vpbf/WHsWvb0Zz9ddiwYcaKFSu8yo4//njjlVdeCXg8xq5tW2vrr/4wdm07mqu/fvrpp8aAAQO8FriLi4uNrKws4/PPPw94PK6vbVtr66/+cH1tOyLdX+utW7fOOOaYY4xdu3YZhmEYmzdvNo455hjj22+/Nff5+OOPjaysLGPv3r1HXN/i4mJj0KBBxnvvvWfuU3+utWvXHlUbWgse9dkGVVVV6fvvv9e4cePMMqvVqnHjxmnt2rVe+7711lsaM2aMzjnnHD344IMqLy8PSx0Od9yJEyfq0Ucf9ftawzCUnZ2tbdu2afTo0ZJqH8N04MABrzYlJydr6NChDdqE1qU5+2teXp7WrVun9u3ba+bMmRo3bpwuvfRSrVmzxmu/WbNm6bbbbjN//uabbzR27FivfcaPH69vvvmm0W1C69Ia+6uvDRs2aO3atTr++OMb3Sa0Hi1hLFBv/fr12rhxoy644AKvct+xwOGurYwFoldr7K+eGLu2Lc3dX4cPH6733ntPhYWFcrlceuedd1RZWWl+rkuMXeHWGvurL8aubUdz9teqqipZLBY5HA6zLDY2VlarVV9//bVZxvUV9Vpjf/XF9bXtaMr+WlJSIovFopSUFEm1X1eTkpKi4447ztxn3LhxslqtXo/uzMrKMh+VHEp9169fr+rqaq99+vbtq65du5rX4GgX09wVQNMrKCiQ0+lU+/btvcrbt2+vrVu3mj+fc8456tq1qzp27Kgff/xRixcv1rZt2/TYY48d1flDOW6PHj2Ulpbm9bpDhw7p5JNPVlVVlaxWqxYsWKATTzxRUu13A9S3wbdNberZvVGoOfvrzp07JUmPPfaYfvvb32rgwIF64403dPnll+vtt99WZmamJKlLly7KyMgwX3fw4EF16NDB61gdOnRQSUmJKioqVFRUFFKb0Pq0xv5a7+STT1Z+fr6cTqeuvfZazZgxo1FtQuvS3GMBT6+++qr69u2rESNGeJX7jgX8XVs9P+cZC0Sv1thfJcaubVVz99eHH35Yv/nNbzRmzBjFxMQoLi5Ojz32mHr16mXuw9gV9Vpjf63H2LXtac7+OmzYMMXHx+uBBx7QTTfdJMMw9OCDD8rpdJqf6RLXV7i1xv5aj+tr29NU/bWyslKLFy/W2WefraSkJEm118n09HSv/WJiYpSamurVX3v37q3k5OSQ63vw4EHZ7XYzwei5j+dxoxmJPwR00UUXmf+flZWljIwMXX755dqxY4d69uwZ0eM+//zzDV6XmJioN954Q2VlZcrOzta9996rHj16aMyYMUdcF0SPSPRXl8tlHnv69OmSpGOPPVbZ2dl67bXXdPPNN0uS7r///qOsPdqalthfX3zxRZWVlWndunV68MEH1atXL51zzjlHVBdEj0iNBepVVFTo7bff1q9//esG2/yNBYBgWlp/ZeyKYCLVX5csWaLi4mI999xzSktL08qVK3XjjTfqxRdfVFZWliTGrmi8lthfGbsikEj01/T0dC1ZskR33nmnli1bJqvVqrPPPluDBg2SxWIx9+P6isZqif2V6ysCOZr+Wl1drRtuuEGGYWjhwoWNPvf777/f6Ne0dST+2qC0tDTZbDbl5eV5lefl5TX4SyRPQ4cOlSTl5OSEZfGksce1Wq3mX/4NHDhQW7Zs0d///neNGTPG/AuVvLw8dezY0XxNXl6eBgwYELa6ouk1Z3+t71d9+/b1Ku/bt692794d8HUdOnRo8Nf6Bw8eVFJSkuLi4mS1Wo+oTWj5WmN/rdejRw9JtYO3gwcP6tFHH9U555xzxG1Cy9ZSxgLvv/++KioqdP755x92X3/XVs/6MhaIXq2xv0qMXduq5uyvO3bs0AsvvKC3335b/fv3lyQNGDBAa9as0Ysvvqg//vGPfl/H2LXtao39tR5j17anuccD48eP18qVK5Wfn6+YmBilpKToxBNP1FlnnRXwNVxf267W2F/rcX1teyLdX6urq3XjjTdq9+7dev755827/aTa62R+fr7X/jU1NSoqKvJ7R2qo9e3QoYOqq6tVXFzsdddfXl5ewONGG77jrw1yOBwaNGiQsrOzzTKXy6Xs7GwNHz484Os2btwoSWEPjiM9rsvlUlVVlSSpe/fuysjI8GpTSUmJ1q1bF7RNaPmas792795dHTt21LZt27zKt2/frm7dugV83bBhw7Rq1Sqvsi+++ELDhg2TdORtQsvXGvurPy6XS9XV1ZLor9GqpYwFXnvtNU2cOLHBoz38Ody1lbFA9GqN/dUfxq5tQ3P21/rvWLFavaf5NptNhmEEfB1j17arNfZXfxi7tg0tZTyQnp6ulJQUZWdnKy8vTxMnTgy4L9fXtqs19ld/uL62DZHsr/VJv5ycHPMOf0/Dhw9XcXGx1q9fb5atWrVKLpdLQ4YMOeL6Dh48WHa73WufrVu3avfu3eY1ONpxx18bdcUVV2jevHkaPHiwhgwZoueff17l5eWaNm2apNq/vnvrrbc0YcIEtWvXTj/++KMWLVqk0aNHB/0r5MLCQu3Zs0f79++XJHMBukOHDsrIyAj5uJdddpkmT56sSy+9VJL0xBNPaPDgwerZs6eqqqr08ccf680339Sdd94pSbJYLJo9e7b++te/qlevXurevbuWLFmijh07atKkSZH4FaIJNVd/tVgsuuqqq/Too49qwIABGjhwoFasWKGtW7fqkUceMY/z29/+Vp06dTIfpThz5ky9+OKLuv/++zV9+nStWrVK7733np544omQ24TWq7X11xdffFFdunRRnz59JEmrV6/WM888o1mzZoXcJrROzdVX6+Xk5Gj16tX6+9//7vc4vmOB2bNna9asWXrmmWc0YcIEvfvuu1q/fr15RwBjgejW2vorY9e2rbn6a58+fdSrVy/Nnz9f8+bNU7t27bRy5Up9/vnnXuNQxq7w1Nr6K2PXtq05xwOvvfaa+vbtq/T0dK1du1Z/+tOfdPnll5t9UeL6Cm+trb9yfW3bItFfq6urdf3112vDhg164oknvL5nMjU1VQ6HQ3379tVJJ52kO+64QwsXLlR1dbXuuusunX322erUqZN5rDPOOEM333yzJk+eHFJ9k5OTNX36dN17771KTU1VUlKS7r77bg0fPpzEH6LbWWedpfz8fD3yyCM6cOCABg4cqKeeesq8HbY+I7506VKVlZWpS5cuOu200/x+p4mnjz76SL/73e/Mn3/zm99Ikq699lpdd911IR93586dKigoMH8uKyvTwoULtXfvXsXFxalPnz564IEHvG5Rv/rqq1VeXq758+eruLhYI0eO1FNPPaXY2Nij/n2heTVXf5Wkyy+/XFVVVVq0aJGKioo0YMAAPfPMM163sO/Zs8frL1V79OihJ554QosWLdLSpUvVuXNn3X333TrppJNCbhNar9bWX10ulx566CHl5ubKZrOpZ8+euuWWWzRz5syQ24TWqTn7qlQ7Ge3cubPGjx/v9zi+Y4ERI0Zo8eLFevjhh/XQQw8pMzNTjz/+uI455hhzH8YC0au19VfGrm1bc861/v73v+vBBx/UnDlzVFZWpp49e+ree+/VhAkTzNcxdoWn1tZfGbu2bc05Hti2bZseeughFRUVqVu3bpozZ44uv/xyr+NwfYWn1tZfub62bZHor/v27dNHH30kSTrvvPO8ti1dutT87vPFixfrrrvu0mWXXSar1arTTjtNt99+u9f+27Zt06FDh0KuryT9/ve/l9Vq1fXXX6+qqiqNHz9eCxYsOLpfVCtiMRr7DAUAAAAAAAAAAAAALQ7f8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAANCEZs2apVmzZpk/5+bmKisrS6+//noz1urwfOvd3LKysvToo4+G5Vivv/66srKylJubG5bjNcaXX36prKwsffnll2bZbbfdpokTJzZ5XQAAAAC0fjHNXQEAAAAAaEpZWVkh7bd06VKNGTMmwrVpfrm5uXr88ce1evVq7du3TykpKcrMzNSYMWN0/fXXN3f1jtisWbP01VdfHXa/a6+9Vt26dWuCGgEAAABA5JH4AwAAANCm3H///V4//+tf/9Lnn3/eoLxv375NUp9u3brp22+/VUxM00/PcnJydMEFFyg2NlbTp09X9+7dtX//fm3YsEFPPvmkV+Lv6aefbvL6HY05c+boggsuMH/+7rvvtGzZMs2ZM0d9+vQxy7OystS/f3+dffbZcjgczVHVBu666y4ZhtHc1QAAAADQCpH4AwAAANCmnHfeeV4/r1u3Tp9//nmDcl/l5eWKj48Pe30sFotiY2PDftxQPPfccyorK9Mbb7zR4K63vLw8r59bSlIsVCeeeKLXz7GxsVq2bJnGjRvn905Om83WVFU7LLvd3txVAAAAANBK8R1/AAAAAOBj1qxZOuecc7R+/XpdcsklGjp0qB566CFJ0sqVK/XLX/5S48eP1+DBgzVp0iQ9/vjjcjqdDY7z8ssva9KkSRoyZIguuOACrVmzpsE+/r7j77bbbtPw4cO1b98+/frXv9bw4cN1wgkn6L777mtwnoKCAt16660aMWKERo0apXnz5umHH34I6XsDd+zYoU6dOvl91GX79u0b/E58v+Nv165dmjNnjoYNG6axY8fqT3/6kz799NMG31lX//vcvHmzZs2apaFDh+qkk07Sk08+6XW8qqoqLVmyRNOmTdPIkSM1bNgw/fznP9eqVauCtuNo+fuOv4kTJ+pXv/qVvvzyS02bNk1DhgzRlClTzHZ9+OGHmjJlio477jhNmzZNGzZsaHDcLVu26Prrr9fxxx9v7vef//znsPXx/Y6/+j7y9NNPm31q8ODBmj59ur799tuwnRcAAABA60fiDwAAAAD8KCws1NVXX62BAwfq97//vXmX2IoVK5SQkKArrrhCf/jDHzRo0CA98sgjWrx4sdfrly9frvnz56tDhw5mYu6aa67Rnj17Qjq/0+nUVVddpXbt2um3v/2tjj/+eD3zzDN6+eWXzX1cLpeuueYavfPOO5o6dap+85vf6MCBA5o3b15I5+jWrZv27t2r7OzsEH8rbmVlZbrsssuUnZ2tWbNmac6cOVq7dm2D30O9oqIi/eIXv9CAAQM0b9489enTR4sXL9bHH39s7lNSUqLly5fr+OOP1y233KJrr71W+fn5+sUvfqGNGzc2uo5HKycnRzfffLMmTpyom266SUVFRZozZ47efPNNLVq0SFOmTNF1112nHTt26MYbb5TL5TJfu2nTJl100UXasmWLrr76at12221KSEjQ3Llz9e9///uI6vP222/r6aef1kUXXaQbb7xRu3bt0nXXXafq6uqInhcAAABA68GjPgEAAADAjwMHDmjhwoWaOXOmV/mDDz6ouLg48+eLL75Y8+fP1z//+U/95je/kcPhUHV1tf785z9r4MCBWrp0qfmYzH79+umOO+5Qly5dDnv+yspKnXnmmZo7d655nqlTp+rVV1/Vz3/+c0m1dx+uXbtWv//973XZZZeZ+11xxRUhtXHWrFn617/+pcsvv1wDBw7U6NGjNWbMGJ144omHfazpyy+/rJ07d+rxxx/XpEmTJEkzZ87U+eef73f//fv367777jO3X3DBBZo4caJee+01TZgwQZKUmpqqjz76yOuxohdeeKHOPPNMLVu2TH/6059Cale4bNu2TS+99JKGDx8uqfb9u+qqq3THHXfovffeU9euXc16z58/X6tXrzYTxPfcc4+6dOmi1157zWzPz3/+c1188cVavHixJk+e3Oj67N69Wx9++KFSU1MlSb1799avf/1rffbZZzrllFMidl4AAAAArQd3/AEAAACAHw6HQ9OmTWtQ7pn0KykpUX5+vkaNGqXy8nJt3bpVkrR+/Xrl5eVp5syZXkmsqVOnKjk5OeQ6XHzxxV4/jxw50utxlJ9++qnsdrsuvPBCs8xqteqSSy4J6fj9+/fXG2+8oXPPPVe7du3S0qVLNXfuXI0bN06vvPJK0Nd++umn6tSpk0499VSzLDY21qsunhISEry+R9HhcOi4447Tzp07zTKbzWb+vlwulwoLC1VTU6PBgwf7fZRmpPXr189M+knS0KFDJUknnHCCmfTzLK9vS2FhoVatWqUzzzzT7CP5+fkqKCjQ+PHjtX37du3bt6/R9TnrrLPMpJ8kjRo1qknOCwAAAKD14I4/AAAAAPCjU6dOXkm7eps2bdLDDz+sVatWqaSkxGvboUOHJNXemSVJvXr18tput9vVo0ePkM4fGxur9PR0r7LU1FQVFRWZP+/evVsZGRkN7s7r2bNnSOeQau8ae+CBB+R0OrV582b997//1VNPPaU77rhD3bt317hx4/y+bteuXerZs6csFktI5+7cuXODfVNTU/Xjjz96la1YsULPPPOMtm3b5vUIy+7du4fcpnDxvTOzPmnbuXNnr/KkpCRJUnFxsaTa7040DENLlizRkiVL/B47Ly9PnTp1Oqr61CcBI31eAAAAAK0HiT8AAAAA8MPzzr56xcXFuvTSS5WUlKTrr79ePXv2VGxsrL7//nstXrzY6zvejpbNZgvbsUI9X1ZWlrKysjRs2DDNnj1bb731VsDE35Ec/3D+9a9/6bbbbtOkSZN01VVXqX379rLZbHriiSe87gxsKoHqHKjcMAxJMvvBlVdeqZNOOsnvvo1Jzjb3eQEAAAC0HiT+AAAAACBEX331lQoLC/XYY49p9OjRZrnn4zclmY+BzMnJ0dixY83y6upq5ebmasCAAWGpT9euXfXll1+qvLzc666/HTt2HNVxBw8eLKn2e/kC6datmzZv3izDMLzu5Duac3/wwQfq0aOHHnvsMa9jPvLII0d8zOZQf1en3W4PW+K0JZ8XAAAAQMvBd/wBAAAAQIis1topVP0dVpJUVVWlf/zjH177DR48WOnp6XrppZdUVVVllq9YscJ8LGM4jB8/XtXV1V7fx+dyufTiiy+G9Po1a9Z4PU6z3scffyyp9jGgwc69b98+/ec//zHLKisrD/vdgMHU39Hm+ftdt26dvvnmmyM+ZnNo3769jj/+eL388st+k6f5+flRdV4AAAAALQd3/AEAAABAiIYPH67U1FTddtttmjVrliwWi/71r395Jaqk2juubrzxRs2fP1+XXXaZzjrrLOXm5ur1118P+Tv+QjFp0iQNGTJE9913n3bs2KE+ffroo48+Mr8H0Pc79Xw9+eST+v777zV58mRlZWVJkjZs2KA33nhD7dq102WXXRbwtRdddJFeeOEF3XzzzZo9e7YyMjL01ltvKTY2NqRz+/Ozn/1MH374oebOnauf/exnys3N1UsvvaR+/fqprKys0cdrTgsWLNDPf/5zTZkyRRdeeKF69OihgwcP6ptvvtHevXv15ptvRtV5AQAAALQMJP4AAAAAIERpaWn629/+pvvuu08PP/ywUlJSdO6552rs2LG66qqrvPa96KKL5HQ69fTTT+v+++/XMccco7/+9a9asmRJ2OpT//1399xzj1asWCGr1arJkydr7ty5uvjii80kXCC/+tWv9Pbbb2v16tV66623VFFRoYyMDJ199tn69a9/HTRJmZiYqOeff1533323li5dqoSEBJ1//vkaPny4rrvuusOe259p06bp4MGDevnll/XZZ5+pX79+euCBB/T+++/rq6++avTxmlO/fv302muv6bHHHtOKFStUWFio9PR0HXvssZo7d27UnRcAAABAy2AxfP80FQAAAADQqq1cuVJz587VP/7xD40cObJJz/3cc89p0aJF+uSTT9SpU6cmPTcAAAAAtHV8xx8AAAAAtGIVFRVePzudTi1btkxJSUkaNGhQk567srJSL7/8sjIzM0n6AQAAAEAz4FGfAAAAANCK3XXXXaqoqNDw4cNVVVWlDz/8UGvXrtVNN92kuLi4iJ772muvVdeuXTVgwACVlJTozTff1NatW7V48eKInhcAAAAA4B+P+gQAAACAVuytt97Ss88+q5ycHFVWVqpXr166+OKLdemll0b83M8995xeffVV7dq1S06nU/369dMvfvELnXXWWRE/NwAAAACgIRJ/AAAAAAAAAAAAQBTgO/4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCMc1dgdbqwIFDDcqsVovS0xOVn18ql4snqALhQmwBkUFsAZFBbAHhR1wBkUFsAZFBbAGRQWyhrcvISA5pP+74CyOr1SKLxSKr1dLcVQGiCrEFRAaxBUQGsQWEH3EFRAaxBUQGsQVEBrEFhIbEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUSCmuSsAAAAAAAAAAACA6Fe0vVA/Lt+g6pJq2ZPsyppxrFIz2zV3taIKiT8AAAAAAAAAAABEjLPKqeyFn2jPmt0ynIYsFosMw1DOym3qMqqrxi44WTaHrbmrGRV41CcAAAAAAAAAAAAiJnvhJ9qVnSu5JIvFIqnuX5e0KztX2Qs/aeYaRg8SfwAAAAAAAAAAAIiIwm0F2rNmt6w2/ykpq82qPWt2q2h7YdNWLEqR+AMAAAAAAAAAAEBE/PTqRhlOI+g+htPQT8s3NlGNohuJPwAAAAAAAAAAAEREdUm1+XjPQCwWi6pKq5qoRtGNxB8AAAAAAAAAAAAiwp5kl2Ec5o4/w5Aj0dFENYpuJP4AAAAAAAAAAAAQEVkzjpXFdpg7/mwWHTNjYBPVKLqR+AMAAAAAAAAAAEBEpGa2U+dRXeRyuvxudzld6jK6q1Iz2zVtxaIUiT8AAAAAAAAAAABEzLgFE9RtbHfJKvOxn4ZhSFap27juGjv/5GauYfSIae4KAAAAAAAAAAAAIHrZHDaNv+cUFW0v1E/LN6qqtEqORIeOmTGQO/3CjMQfAAAAAAAAAAAAIi41s51G3zq2uasR1XjUJwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUYDEHwAAAAAAAAAAABAFSPwBAAAAAAAAAAAAUSCmuSsAAAAAAAAAAACA6GetqlJcYbEsLpcMq1UV7VLkcjiau1pRhcQfAAAAAAAAAAAAIscwlLhvv+xl5ZJhSBaLZBhylJSoOiFepZ061pbhqPGoTwAAAAAAAAAAAERM4r79speW1f5Qn+Cr+9deWqbEffubqWbRh8QfAAAAAAAAAAAAIsJaWVV7p1+gO/osFtnLymWtqmraikUpEn8AAAAAAAAAAACIiLii4trHewZjGIotKm6aCkU5En8AAAAAAAAAAACICIvLdfjv77NYZHW6mqZCUY7EHwAAAAAAAAAAACLCsFpDuuPPZSNlFQ78FgEAAAAAAAAAABARFe1SQrrjrzI1pWkqFOVI/AEAAAAAAAAAACAiXA6HquPjA9/1ZxiqToiXy+Fo2opFKRJ/AAAAAAAAAAAAiJjSzh1VnZhQ+0N9ArDu3+rEBJV26thMNYs+Mc1dAQAAAAAAAAAAAEQxi0WlnTvJWlWl2KJiWZ0uuWxWVaamcKdfmJH4AwAAAAAAAAAAQMS5HA6VZ3Ro7mpENR71CQAAAAAAAAAAAESBFn3H3+rVq/X0009r/fr1OnDggB5//HFNmjTJ3J6VleX3dbfeeqt+8Ytf+N326KOP6rHHHvMq6927t95///3wVRwAAAAAAAAAAABoYi068VdWVqasrCxNnz5d1157bYPtn332mdfPn3zyif7whz/o9NNPD3rc/v3769lnnzV/ttls4akwAAAAAAAAAAAA0ExadOJvwoQJmjBhQsDtGRkZXj//5z//0ZgxY9SjR4+gx7XZbA1e21hWq0VWq8XnuFavfwGEB7EFRAaxBUQGsQWEH3EFRAaxBUQGsQVEBrEFhKZFJ/4a4+DBg/r444917733HnbfnJwcjR8/XrGxsRo2bJhuvvlmde3atVHnS09PlMVi8bstJSW+UccCEBpiC4gMYguIDGILCD/iCogMYguIDGILiAxiCwguahJ/K1asUGJiok477bSg+w0ZMkSLFi1S7969ze8NvOSSS/TWW28pKSkp5PPl55f6veMvJSVexcXlcjpdR9QOAA0RW0BkEFtAZBBbQPgRV0BkEFtAZBBbQGQQW2jr0tISQ9ovahJ/r732mqZMmaLY2Nig+3k+OnTAgAEaOnSoTjnlFL333nuaMWNGyOdzuQy5XIbfbU6nSzU1XHiAcCO2gMggtoDIILaA8COugMggtoDIILaAyCC2gOCi4mG4a9as0bZt2xqVuKuXkpKizMxM7dixIwI1AwAAAAAAAAAAAJpGVCT+Xn31VQ0aNEgDBgxo9GtLS0u1c+dOZWRkRKBmAAAAAAAAAAAAQNNo0Ym/0tJSbdy4URs3bpQk5ebmauPGjdq9e7e5T0lJid5///2Ad/tddtlleuGFF8yf77vvPn311VfKzc3V//73P1177bWyWq0655xzItsYAAAAAAAAAAAAIIJa9Hf8rV+/XrNnzzZ/XrRokSRp6tSpuvfeeyVJ77zzjgzDCJi427lzpwoKCsyf9+7dq5tuukmFhYVKT0/XyJEj9corryg9PT2CLQEAAAAAAAAAAIhu1u3bFLf8JVlKSmQkJalixky5Mns3d7XaFIthGEZzV6I1OnDgUIOymBir0tISVVBQypeLAmFEbAGRQWwBkUFsAeFHXAGRQWwBkUFsAZFBbLVwVVVKXHiH7Gu+lJwuyWKRDEOyWVU9aoxKF9wlORzNXctWLSMjOaT9WvSjPgEAAAAAAAAAANCyJS68Q/bszyWXUZv0k2r/dRmyZ3+uxIV3NG8F2xASfwAAAAAAAAAAADgi1m1ba+/0s9n872Czyb7mS1m3b2vairVRJP4AAAAAAAAAAABwROJefbn28Z7BOF2KXf5S01SojSPxBwAAAAAAAAAAgCNiKSlxP94z4E4WWUtLm6ZCbRyJPwAAAAAAAAAAABwRIylJMozD7GTIlZjYNBVq40j8AQAAAAAAAAAA4IhUzJgp2Q6TbrJZVTljZtNUqI0j8QcAAAAAAAAAAIAj4srsrepRx0tOp/8dnE5Vjx4jV2bvpq1YG0XiDwAAAAAAAAAAAEesdMHdqh57omS1uB/7aRiS1aLqcSeqdP5dzVvBNiSmuSsAAAAAAAAAAACAVszhUOk998m6fZtil78ka2mpXImJqpwxkzv9mhiJPwAAAAAAAAAAABw1V2Zvld/6u+auRpvGoz4BAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCJP4AAAAAAAAAAACAKEDiDwAAAAAAAAAAAIgCMc1dAQAAAAAAAAAAALR+27dbtHy5XSUlFiUlGZoxo1qZmUZzV6tNIfEHAAAAAAAAAACAI1ZVJS1c6NCaNTY5nRZZLJJhSCtX2jRqlFMLFlTJ4WjuWrYNPOoTAAAAAAAAAAAAR2zhQoeys2PkctUm/STJYpFcLouys2O0cCFZv6ZC4g8AAAAAAAAAAABHZNs2i9assclm87/dZpPWrLFp+3ZL01asjSLxBwAAAAAAAAAAgCPy6qt2OZ3Bk3pOZ+13/yHySPwBAAAAAAAAAADgiJSUuB/vGYjFIpWWcsdfUyDxBwAAAAAAAAAAgCOSlGTIMILvYxhSYuJhdkJYkPgDAAAAAAAAAADAEZkxo1o2W/Ckns1maMaM6iaqUdtG4g8AAAAAAAAAAABHJDPT0KhRTjmd/rc7ndLo0U5lZnLHX1Mg8QcAAAAAAAAAAIAjtmBBlcaOrZHV6n7sp2FIVquhceNqNH9+VfNWsA2Jae4KAAAAAAAAAAAAoPVyOKR77qnS9u0WLV9uV2mpRYmJtY/35E6/pkXiDwAAAAAAAAAAAEctM9PQrbdyd19z4lGfAAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEARJ/AAAAAAAAAAAAQBQg8QcAAAAAAAAAAABEgZjmrgAAAAAAAAAAAACOTNH2Qv24fIOqS6plT7Ira8axSs1s19zVQjMh8QcAAAAAAAAAANDKOKucyl74ifas2S3DachiscgwDOWs3KYuo7pq7IKTZXPYmruaaGIt+lGfq1ev1pw5czR+/HhlZWVp5cqVXttvu+02ZWVlef131VVXHfa4L774oiZOnKjjjjtOM2bM0LfffhupJgAAAAAAAAAAAIRd9sJPtCs7V3JJFotFUt2/LmlXdq6yF37SzDVEc2jRib+ysjJlZWVpwYIFAfc56aST9Nlnn5n/PfTQQ0GP+e6772rRokWaO3euVqxYoQEDBuiqq65SXl5euKsPAAAAAAAAAAAQdoXbCrRnzW5Zbf7TPFabVXvW7FbR9sKmrRiaXYt+1OeECRM0YcKEoPs4HA5lZGSEfMxnn31WF154oaZPny5JWrhwof773//qtdde0y9/+cuQj2O1WmS1WrzKbHUBZgsQaACODLEFRAaxBUQGsQWEH3EFRAaxBUQGsQVEBrHlbfPrP0ouw7zTzx/DZWjzaz9ozLxxTVgzNLcWnfgLxVdffaWxY8cqJSVFJ5xwgm688UalpaX53beqqkrff/+9fvWrX5llVqtV48aN09q1axt13vT0xIABlZIS36hjAQgNsQVEBrEFRAaxBYQfcQVEBrEFRAaxBUQGsVXLVmMoJubw399ndRpKS0tsghqhpWjVib+TTjpJkydPVvfu3bVz50499NBDuvrqq/Xyyy/LZmvY4QsKCuR0OtW+fXuv8vbt22vr1q2NOnd+fqnfO/5SUuJVXFwup9PV+AYB8IvYAiKD2AIig9gCwo+4AiKD2AIig9gCIoPY8uaMsaimxhn8jj/DkMtmUUFBaRPWDJESagK3VSf+zj77bPP/s7KylJWVpUmTJpl3AUaSy2XI5TL8bnM6Xaqp4cIDhBuxBUQGsQVEBrEFhB9xBUQGsQVEBrEFRAaxVav/9AHa9uEWGcF+FVaL+k0fwO+rjYmqh+H26NFDaWlpysnJ8bs9LS1NNptNeXl5XuV5eXnq0KFDU1QRAAAAAAAAAADgqKRmtlPnUV3kCnD3o8vpUpfRXZWa2a5pK4ZmF1WJv71796qwsFAZGRl+tzscDg0aNEjZ2dlmmcvlUnZ2toYPH95U1QQAAAAAAAAAADgq4xZMULex3SVr7WM9pbp/rVK3cd01dv7JzVxDNIcW/ajP0tJS7dixw/w5NzdXGzduVGpqqlJTU/XYY4/p9NNPV4cOHbRz50498MAD6tWrl0466STzNZdddpkmT56sSy+9VJJ0xRVXaN68eRo8eLCGDBmi559/XuXl5Zo2bVqTtw8AAAAAAAAAAOBI2Bw2jb/nFBVtL9RPyzeqqrRKjkSHjpkxkDv92rAWnfhbv369Zs+ebf68aNEiSdLUqVN155136qefftIbb7yhQ4cOqWPHjjrxxBN1ww03yOFwmK/ZuXOnCgoKzJ/POuss5efn65FHHtGBAwc0cOBAPfXUUzzqEwAAAAAAAAAAtDqpme00+taxzV0NtBAWo/7+TzTKgQOHGpTFxFiVlpaogoJSviwTCCNiC4gMYguIDGILCD/iCogMYguIDGILiAxiC21dRkZySPtF1Xf8AQAAAAAAAAAAAG0ViT8AAAAAAAAAAAAgCpD4AwAAAAAAAAAAAKIAiT8AAAAAAAAAAAAgCpD4AwAAAAAAAAAAAKIAiT8AAAAAAAAAAAAgCpD4AwAAAAAAAAAAAKIAiT8AAAAAAAAAAAAgCpD4AwAAAAAAAAAAAKJATHNXAAAAAAAAAAAAAEfGWlWluMJiWVwuGVarKtqlyOVwNHe10ExI/AEAAAAAAAAAALQ2hqHEfftlLyuXDEOyWCTDkKOkRNUJ8Srt1LG2DG0Kj/oEAAAAAAAAAABoZRL37Ze9tKz2h/oEX92/9tIyJe7b30w1Q3Mi8QcAAAAAAAAAANCKWCurau/0C3RHn8Uie1m5rFVVTVsxNDsSfwAAAAAAAAAAAK1IXFFx7eM9gzEMxRYVN02F0GKQ+AMAAAAAAAAAAGhFLC7X4b+/z2KR1elqmgqhxSDxBwAAAAAAAAAA0IoYVmtId/y5bKSB2hrecQAAAAAAAAAAgFakol1KSHf8VaamNE2F0GKQ+AMAAAAAAAAAAGhFXA6HquPjA9/1ZxiqToiXy+Fo2oqh2ZH4AwAAAAAAAAAAaGVKO3dUdWJC7Q/1CcC6f6sTE1TaqWMz1QzNKaa5KwAAAAAAAAAAAIBGslhU2rmTrFVVii0qltXpkstmVWVqCnf6tWEk/gAAAAAAAAAAAFopl8Oh8owOzV0NtBA86hMAAAAAAAAAAACIAiT+AAAAAAAAAAAAgChA4g8AAAAAAAAAAACIAiT+AAAAAAAAAAAAgChA4g8AAAAAAAAAAACIAiT+AAAAAAAAAAAAgChA4g8AAAAAAAAAAACIAiT+AAAAAAAAAAAAgChA4g8AAAAAAAAAAACIAiT+AAAAAAAAAAAAgCgQ09wVAAAAAAAAAAAAgVm3b1Pc8pdkKSmRkZSkihkz5crs3dzVAtACkfgDAAAAAAAAAKAlqqpS4sI7ZF/zpeR0SRaLZBhyrPxA1aPGqHTBXZLD0dy1BNCC8KhPAAAAAAAAAABaoMSFd8ie/bnkMmqTflLtvy5D9uzPlbjwjuatIIAWh8QfAAAAAAAAAAAtjHXb1to7/Ww2/zvYbLKv+VLW7duatmIAWjQSfwAAAAAAAAAAtDBxr75c+3jPYJwuxS5/qWkqBKBVIPEHAAAAAAAAAEALYykpcT/eM+BOFllLS5umQgBaBRJ/AAAAAAAAAAC0MEZSkmQYh9nJkCsxsWkqBKBVIPEHAAAAAAAAAEALUzFjpmQ7zBK+zarKGTObpkIAWgUSfwAAAAAAAAAAtDCuzN6qHnW85HT638HpVPXoMXJl9m7aigFo0Uj8AQAAAAAAAADQApUuuFvVY0+UrBb3Yz8NQ7JaVD3uRJXOv6t5KwigxYlp7goAAAAAAAAAAAA/HA6V3nOfrNu3KXb5S7KWlsqVmKjKGTO50w+AXyT+AAAAAAAAAABowVyZvVV+6++auxoAWgEe9QkAAAAAAAAAAABEgRad+Fu9erXmzJmj8ePHKysrSytXrjS3VVdX64EHHtCUKVM0bNgwjR8/Xr/97W+1b9++oMd89NFHlZWV5fXfGWecEemmAAAAAAAAAAAAABHVoh/1WVZWpqysLE2fPl3XXnut17aKigpt2LBB11xzjQYMGKDi4mLdc889uuaaa/T6668HPW7//v317LPPmj/bbLaI1B8AAAAAAAAAAABoKi068TdhwgRNmDDB77bk5GSv5J0k3XHHHZoxY4Z2796trl27BjyuzWZTRkbGUdXNarXIarX4HNfq9S+A8CC2gMggtoDIILaA8COugMggtoDIILaAyCC2gNC06MRfY5WUlMhisSglJSXofjk5ORo/frxiY2M1bNgw3XzzzUEThf6kpyfKYrH43ZaSEt+oYwEIDbEFRAaxBUQGsQWEH3EFRAaxBUQGsQVEBrEFBBc1ib/KykotXrxYZ599tpKSkgLuN2TIEC1atEi9e/fWgQMH9Pjjj+uSSy7RW2+9FfR1vvLzS/3e8ZeSEq/i4nI5na4jbgsAb8QWEBnEFhAZxBYQfsQVEBnEFhAZxBYQGcQW2rq0tMSQ9ouKxF91dbVuuOEGGYahhQsXBt3X89GhAwYM0NChQ3XKKafovffe04wZM0I+p8tlyOUy/G5zOl2qqeHCA4QbsQVEBrEFRAaxBYQfcQVEBrEFRAaxBUQGsQUE1+oTf9XV1brxxhu1e/duPf/88426a0+SUlJSlJmZqR07dkSohgAAAAAAAAAAAEDkterEX33SLycnR0uXLlVaWlqjj1FaWqqdO3cqIyMjAjUEAAAAAAAAAAAAmkaLTvyVlpZ63YmXm5urjRs3KjU1VRkZGbr++uu1YcMGPfHEE3I6nTpw4IAkKTU1VQ6HQ5J02WWXafLkybr00kslSffdd59OOeUUde3aVfv379ejjz4qq9Wqc845p+kbCAAAAAAAAAAAAIRJi078rV+/XrNnzzZ/XrRokSRp6tSpuvbaa/XRRx9Jks477zyv1y1dulRjxoyRJO3cuVMFBQXmtr179+qmm25SYWGh0tPTNXLkSL3yyitKT0+PdHMAAAAAAAAAAGi07dstWr7crpISi5KSDM2YUa3MTKO5qwWgBbIYhsHV4QgcOHCoQVlMjFVpaYkqKCjly0WBMCK2gMggtoDIILaA8COugMggtoDIILYQTlVV0sKFDq1ZY5PTaZHFIhmGZLMZGjXKqQULqlT38LuoR2yhrcvISA5pP2uE6wEAAAAAAAAAAI7AwoUOZWfHyOWqTfpJksUiuVwWZWfHaOHCNpL1AxAyEn8AAAAAAAAAALQw27ZZtGaNTTab/+02m7RmjU3bt1uatmIAWjQSfwAAAAAAAAAAtDCvvmqX0xk8qed01n73HwDUI/EHAAAAAAAAAEALU1LifrxnIBaLVFrKHX8A3Ej8AQAAAAAAAADQwiQlGTKM4PsYhpSYeJidALQpJP4AAAAAAAAAAGhhZsyols0WPKlnsxmaMaO6iWoEoDUg8QcAAAAAAAAAQAuTmWlo1CinnE7/251OafRopzIzueMPgBuJPwAAAAAAAAAAWqAFC6o0dmyNrFb3Yz8NQ7JaDY0bV6P586uat4IAWpyY5q4AAAAAAAAAAABoyOGQ7rmnStu3W7R8uV2lpRYlJtY+3pM7/QD4Q+IPAAAAAAAAAIAWLDPT0K23cncfgMPjUZ8AAAAAAAAAAABAFCDxBwAAAAAAAAAAAEQBEn8AAAAAAAAAAABAFCDxBwAAAAAAAAAAAESBsCb+Dhw4EHT7999/H87TAQAAAAAAAAAAAKgT1sTflClT9P777zcod7lceuyxx3TRRReF83QAAAAAAAAAAAAA6oQ18Xfaaafpxhtv1K233qpDhw5JkrZu3aqLLrpITz75pG699dZwng4AAAAAAAAAAABAnZhwHuyPf/yjTj31VN1+++2aMmWKzjnnHL3wwgvq16+fXn/9dfXt2zecpwMAAAAAAAAAAABQJ6x3/EnShAkT9OSTTyo/P19PP/20+vTpo5deeomkHwAAAAAAAAAAABBBYU/8vfnmm5o9e7a6d++uq6++Wps2bdIVV1yh3NzccJ8KAAAAAAAAAAAAQJ2wJv6uv/56zZs3T+edd55WrFihm266ScuXL1dRUZHOPfdcLV++PJynAwAAAAAg7KxVVUrYf1CJe/crYf9BWauqmrtKAAAAABCSsH7H3/r16/Xss8/qhBNOMMsGDBig1157TUuWLNGdd96pGTNmhPOUAAAAAACEh2Eocd9+2cvKJcOQLBbJMOQoKVF1QrxKO3WsLQMAAACAFiqsib8333xTSUlJDcrtdrtuueUWnXrqqeE8HQAAAAAAYZO4b7/spWW1yb36BF/dv/bSMiXu26/Szp2asYYAAAAAEFxYE3/1Sb+ioiJt2rRJe/bs0cknn6zU1FRVVlZq6NCh4TwdAAAAAABhYa2sqr3TL9AdfRaL7GXlslZVyeVwNG3lAAAAACBEYU38uVwuPfzww1q2bJnKy8tlsVj06quvKjU1Vddee62GDh2qa6+9NpynBAAAAADgqMUVFbsf7xmIYSi2qFjlGR2armIAAAAA0AjWcB5syZIleuGFFzRv3jx98MEHMgzD3DZx4kR99NFH4TwdAAAAAABhYXG5Dv/9fRaLrE5X01QIAAAAAI5AWO/4W7FihW666SbNnDlTTqfTa1vPnj21c+fOcJ4OAAAAAICwMKzWkO74c9nC+vezAAAAABBWYZ2xFBYWqm/fvn63OZ1O1dTUhPN0AAAAAACERUW7lJDu+KtMTWmaCgEAAADAEQhr4i8zM1Off/65321fffWV+vfvH87TAQAAAAAQFi6HQ9Xx8bV3/fljGKpOiJfL4WjaigEAAABAI4T1UZ+XX3657rjjDsXExOiMM86QJO3du1fffPONli1bpkWLFoXzdAAAAAAAhE1p545K3Ldf9rJy92M/6/6tTkxQaaeOzV1FAAAAAAgqrIm/adOmqaioSI8++qieeOIJSdLcuXMVHx+vG2+8UWeddVY4TwcAAAAAQPhYLCrt3EnWqirFFhXL6nTJZbOqMjWFO/0AAAAAtAphTfxJ0hVXXKELL7xQa9euVUFBgVJTUzV8+HAlJyeH+1QAAAAAAISdy+FQeUaH5q4GAAAAADRa2BN/kpSYmKjx48dH4tAAAAAAAAAAAAAA/DjqxN8bb7zRqP3PP//8oz0lAAAAAAAAAAAAAB9Hnfi77bbbvH62WCySJMMwGpRJJP4AAAAAAAAAAACASDjqxN/q1avN/8/JydENN9yg8847T6effro6dOiggwcP6v3339ebb76phx9++GhPBwAAAAAAAAAAAMCPo078JScnm///4IMP6qKLLtIvf/lLs6x9+/bKyspSXFycFi9erOeff/5oTwkAAAAAAAAAAADAhzWcB1u7dq0GDRrkd9ugQYO0bt26cJ4OAAAAAAAAAAAAQJ2wJv7S09P17rvv+t32zjvvKD09PZynAwAAAAAAAAAAAFDnqB/16WnOnDmaP3++duzYoUmTJql9+/bKy8vTypUrtXr1av3xj38M5+kAAAAAAAAAAAAA1Alr4u/CCy9URkaG/va3v+mBBx5QTU2NYmJidOyxx+ovf/mLJk6cGM7TAQAAAAAAAAAAAKgT1sSfJJ1yyik65ZRT5HK5lJ+fr/T0dFmtYX2iKAAAAAAAAAAAAAAfYU/81bNarerQoUOkDg8AAAAAQEQUbS/Uj8s3qLqkWvYku7JmHKvUzHbNXS0AAAAAOKywJ/4+++wzffDBB9q7d68qKyu9tlksFj3//PPhPiUAAAAAAEfNWeVU9sJPtGfNbhlOQxaLRYZhKGflNnUZ1VVjF5wsm8PW3NUEAAAAgIDC+gzOp556Sr/4xS/0xRdfyGKxKDk52eu/pKSkRh1v9erVmjNnjsaPH6+srCytXLnSa7thGFqyZInGjx+vIUOG6PLLL9f27dsPe9wXX3xREydO1HHHHacZM2bo22+/bVS9AAAAAADRJ3vhJ9qVnSu5av9wVar71yXtys5V9sJPmrmGAAAAABBcWO/4+8c//qFLL71Ut99+e1iOV1ZWpqysLE2fPl3XXnttg+1PPvmkli1bpnvvvVfdu3fXkiVLdNVVV+ndd99VbGys32O+++67WrRokRYuXKihQ4fq+eef11VXXaX3339f7du3D0u9AQAAAACtS+G2Au1Zs1tWm/+/j7XarNqzZreKthfy2E8AAAAALVZYE3+FhYU69dRTw3a8CRMmaMKECX63GYahpUuX6pprrtGkSZMkSffff7/GjRunlStX6uyzz/b7umeffVYXXnihpk+fLklauHCh/vvf/+q1117TL3/5y5DrZrVaZLVavMpsdRNEW4CJIoAjQ2wBkUFsAZFBbAHh1xRxtfn1HyWXYd7p54/hMrT5tR80Zt64iNUDaEp8ZgGRQWwBkUFsAaEJa+LvlFNO0ddff62xY8eG87B+5ebm6sCBAxo3zj3hSk5O1tChQ7V27Vq/ib+qqip9//33+tWvfmWWWa1WjRs3TmvXrm3U+dPTEwNOCFNS4ht1LAChIbaAyCC2gMggtoDwi2Rc2WoMxcQc/vv7rE5DaWmJEasH0Bz4zAIig9gCIoPYAoILa+Jv+vTpuvPOO1VZWalx48YpJSWlwT6DBg0Ky7kOHDggSQ0ez9m+fXsdPHjQ72sKCgrkdDr9vmbr1q2NOn9+fqnfO/5SUuJVXFwup9PVqOMBCIzYAiKD2AIig9gCwq8p4soZY1FNjTP4HX+GIZfNooKC0ojUAWhqfGYBkUFsAZFBbKGtC/UPEMOa+Lvyyisl1X733pNPPuk1YTKM2kembNy4MZynbDYulyGXy/C7zel0qaaGCw8QbsQWEBnEFhAZxBYQfpGMq/7TB2jbh1tkBDu81aJ+0wcQ24g6fGYBkUFsAZFBbAHBhTXxt3Tp0nAeLqiMjAxJUl5enjp27GiW5+XlacCAAX5fk5aWJpvNpry8PK/yvLw8dejQIXKVBQAAAAC0aKmZ7dR5VBftzt4lq5/vjXE5Xeo2prtSM9s1feUAAAAAIERhTfwdf/zx4TxcUN27d1dGRoays7M1cOBASVJJSYnWrVuniy++2O9rHA6HBg0apOzsbE2aNEmS5HK5lJ2drUsvvbTJ6g4AAAAAaHnGLZig7IWfaM+a3TKctU+tMQxDFptF3cZ019j5Jzd3FQEAAAAgqLAm/sKttLRUO3bsMH/Ozc3Vxo0blZqaqq5du2r27Nn661//ql69eql79+5asmSJOnbsaCb1JOmyyy7T5MmTzcTeFVdcoXnz5mnw4MEaMmSInn/+eZWXl2vatGlN3j4AAAAAQMthc9g0/p5TVLS9UD8t36iq0io5Eh06ZsZA7vQDAAAA0CocdeJvypQpIe9rsVj05ptvhrz/+vXrNXv2bPPnRYsWSZKmTp2qe++9V1dffbXKy8s1f/58FRcXa+TIkXrqqacUGxtrvmbnzp0qKCgwfz7rrLOUn5+vRx55RAcOHNDAgQP11FNP8ahPAAAAAICk2sd+jr51bHNXAwAAAAAazWIYhnE0B7jttttksVhC3r8+edfaHThwqEFZTIxVaWmJKigo5ctFgTAitoDIILaAyCC2gPAjroDIILaAyCC2gMggttDWZWQkh7TfUd/xd++99x7tIQAAAAAAAAAAAAAcJWtzVwAAAAAAAAAAAADA0SPxBwAAAAAAAAAAAEQBEn8AAAAAAAAAAABAFCDxBwAAAAAAAAAAAEQBEn8AAAAAAAAAAABAFCDxBwAAAAAAAAAAAESBmKM9wN13392o/W+//fajPSUAAAAAAAAAAAAAH0ed+Pvoo49C3tdisZD4AwAAAAAAAAAAACKgSRN/AAAAAAAAAAAAACLjqBN/AAAAaB7bt1u0fLldJSUWJSUZmjGjWpmZRnNXCwAAAAAAAM0kIom/nJwcbd++XZWVlQ22nXbaaZE4JQAAQJtRVSUtXOjQmjU2OZ0WWSySYUgrV9o0apRTCxZUyeFo7loCAAAAAACgqYU18VdSUqK5c+fqq6++kiQZRu1fnFssFnOfjRs3hvOUAAAAbc7ChQ5lZ8fIZpPqh1kWi+RyWZSdHaOFC6V77qlq3koCAAAAAACgyVnDebAHHnhABw8e1IsvvijDMPTYY49p2bJluuCCC9S9e3e9/PLL4TwdAABAm7Ntm0Vr1thks/nfbrNJa9bYtH27xf8OAAAAAAAAiFphTfx9+umnmjNnjoYOHSpJ6tixo0aPHq277rpLp556qp599tlwng4AAKDNefVVu5zO4Ek9p7P2u/8AAAAAAADQtoQ18Zefn68uXbrIZrMpPj5ehYWF5rYJEybo008/DefpAAAA2pySEossh7mZz2KRSku54w8AAAAAAKCtCWvir3PnziooKJAkZWZm6qOPPjK3rV27VrGxseE8HQAAQJuTlGSo7muUAzIMKTHxMDsBAAAAAAAg6sSE82AnnniivvjiC02ePFmXXXaZbrvtNn377bey2+369ttvdcUVV4TzdAAAAG3OjBnVWrnSJpcr8B19NpuhGTOqm7BWAAAAAAAAaAnCmvi75ZZbVF5eLkk6//zzlZiYqPfff1+VlZW64447NHPmzHCeDgAAoM3JzDQ0apRT2dkxstkabnc6pTFjnMrM5I4/AAAAAACAtiasib/4+HjFx8ebP0+ePFmTJ08O5ykAAADavAULqrRwobRmjU1OZ+13/hlG7Z1+Y8Y4NX9+VXNXEQAAAAAAAM0grIk/T3l5eaqsrGxQ3rVr10idEgAAoE1wOKR77qnS9u0WLV9uV2mpRYmJtY/35E4/AAAAAACAtiusib+CggLdfffd+vDDD1VTU+O1zTAMWSwWbdy4MZynBAAAaLMyMw3deit39wEAAAAAAKBWWBN/t99+u1avXq1f/epX6tu3r+x2ezgPDwAAAAAAAAAAACCAsCb+vvzyS91+++06//zzw3lYAAAAAAAAAAAAAIdhDefBUlJSlJaWFs5DAgAAAAAAAAAAAAhBWBN/V111lZYtW9bg+/0AAAAAAAAAAAAARFZYH/W5detWbdmyRZMnT9bo0aOVkpLSYJ/bb789nKcEAAAAAAAAAAAAoDAn/v7v//5PFotFkrRmzZoG2y0WC4k/AAAAAAAAAAAAIALCmvj76KOPwnk4AAAAAAAAAAAAACEK63f8AQAAAAAAAAAAAGgeYb3j74033gi4zWKxKDk5WQMGDFDXrl3DeVoAAAAAAAAAAACgzQtr4u+2224zv+PPMAyz3LPMYrFo0qRJuv/++xUfHx/O0wMAAAAAAAAAAOD/27v3KLnKMl/836pON4EOgdy4yaUBJQnXJoKREGEIzlksZM4o0GPWkSB4GZyBWcMIwuGnEKM4UQcQDHgGLxxwQBm5nhEGUI4edUxwjFxGAUUh4RolNwjpJHSnav/+iLS26VwgXV3d1Z/PWllF7Xr3rmdn8aT27m+/bzFs9Wvwd8cdd+Tcc8/Nu9/97hx//PEZN25cli9fnu9+97v5P//n/2TOnDl57rnn8tnPfjaXX355PvGJT/Tn2wMADCvlxYsy8pabU1q9OsWoUVnXMTPVtn3rXRYAAAAAddKvwd9ll12Wjo6OfOhDH+rZNm7cuBxwwAFpaWnJP//zP+eGG27IypUrc+ONNwr+AADeiK6utM65OM0Lf5JUqkmplBRFWu6/L91HTE3n7E8nLS31rhIAAACAAVbuz4P97Gc/y+TJk/t87cADD8wjjzySJDn00EOzYsWK/nxrAIBho3XOxWle8OOkWmwI/ZINj9UizQt+nNY5F9e3QAAAAADqol+Dv7Fjx+a+++7r87V77703Y8eOTZJ0dnZm9OjR/fnWAADDQnnRUxtm+jU19T2gqSnNC3+S8uJFA1sYAAAAAHXXr0t9/vVf/3U++clP5rnnnstxxx2XsWPHZsWKFfm///f/5oEHHsicOXOSJA888EAOPfTQ/nxrAIBhYeSt//qH5T03pVLNdrfcnLUfu2jgCgMAAACg7vo1+Js5c2YmTJiQf/7nf87nPve5rF+/PiNGjMjkyZPzpS99KTNmzEiSnHPOORkxol/fGgBgWCitXr350C9JSqWUOzsHpiAAAAAABo1+T9+OP/74HH/88alWq1mxYkXGjh2bcrn3iqI77bRTf78tAMCwUIwalRTF5sO/oki1tXXgigIAAABgUOjX7/jrdeByOePHj98o9AMA4I1b1zEzadrC9VVTOa92zByYggAAAAAYNLZ5xt+ll16aD3zgA9ljjz1y6aWXbnH8Jz7xiW19SwCAYavatm+6j3hbmhfMT5qaNh5QqaR76tGptu078MUBAAAAUFfbHPx973vfy6mnnpo99tgj3/ve9zY7tlQqCf4AALZR5+xL0zrn4jQv/ElSqW5Y9rMokqZyuqcenc5LPl3vEgEAAACog34J/vr6bwAAaqSlJZ2f+VzKixdlu1tuTrmzM9XW1rzaMdNMPwAAAIBhbJuDPwAA6qPatm/WfuyiepcBAAAAwCCxzcHfihUr8uKLL2bSpEm9tv/yl7/Ml770pTz55JMZP3583v/+92fGjBnb+nYbmTFjRp5//vmNtv+P//E/Mnv27I2233777bnoot4/IGtpacnPf/7zfq8NAAAAAAAABso2B39XXHFFHn300dxxxx09255//vm8733vy7p16zJx4sT8+te/zjnnnJMbbrghRx555La+ZS+33nprKpVKz/Nf//rXOfPMM3PCCSdscp9Ro0bl3nvv7XleKpX6tSYAAAAAAAAYaNsc/D344IM59dRTe227/vrrs2bNmnzlK1/J9OnTs27dupx55pn5yle+0u/B39ixY3s9//KXv5y99947b3vb2za5T6lUyoQJE/q1DgAAAAAAAKinbQ7+fve73+Utb3lLr23f//73M3ny5EyfPj1JMnLkyJx22mn5/Oc/v61vt1ldXV35t3/7t5x55pmbncW3Zs2aHHfccalWqznwwAPz0Y9+dKNz2JJyuZRyufd7NDWVez0C/UNvQW3oLagNvQX9T19BbegtqA29BbWht2DrbHPwVyqVeoVsy5Yty3PPPZf3v//9vcbtuuuuWbly5ba+3Wbdf//9eeWVV/Ke97xnk2P23Xff/OM//mMmTpyYV155Jdddd11mzpyZu+++O7vttttWv9fYsa2bDBdHj97+ddcObJnegtrQW1Abegv6n76C2tBbUBt6C2pDb8HmbXPwt++++2b+/Pk9s/u+//3vp1Qq5eijj+41bunSpRsty9nfbrvtthxzzDHZddddNznm8MMPz+GHH97r+Yknnpibb74555577la/14oVnX3O+Bs9evusWrU2lUr1ddcP9E1vQW3oLagNvQX9T19BbegtqA29BbWhtxjuxoxp3apx2xz8zZo1KxdeeGFWrVqV8ePH55vf/Gb23nvvTJs2rde4//iP/8gBBxywrW+3Sc8//3zmz5+fefPmva79mpubM3ny5DzzzDOva79qtUi1WvT5WqVSzfr1/uGB/qa3oDb0FtSG3oL+p6+gNvQW1IbegtrQW7B52xz8/ff//t/zu9/9LjfeeGNWrVqVgw46KLNnz86IEX849PLly/P9738/f/d3f7etb7dJt99+e8aNG5c/+7M/e137VSqVPPHEEzn22GNrUxgAAAAAAAAMgG0O/pLkwx/+cD784Q9v8vVx48Zl/vz5/fFWfapWq7n99tvz7ne/u1fgmCQXXHBBdt1115x33nlJkquvvjrt7e3ZZ599smrVqnzta1/LCy+8kI6OjprVBwAAAAAAALXWL8Ffvc2fPz8vvPBCTjnllI1eW7JkScrlcs/zVatW5eKLL87SpUuz00475aCDDsrNN9+cN7/5zQNZMgAAAAAAAPSrUlEUfX9RHZu1dOkrG20bMaKcMWNas3JlpzWGoR/pLagNvdX/Xl78Un51y2PpXt2d5lHNmdhxYHZq27neZTHA9Bb0P30FtaG3oDb0FtSG3mK4mzBhx60a1xAz/gAA6qnSVcmCOT/MkoUvpKgUKZVKKYoiT9+/KLsfsUeOmn1Mmlqa6l0mAAAAAA2uvOUhAABszoI5P8zzC55LqkmpVEry+8dq8vyC57Jgzg/rXCEAAAAAw4HgDwBgG7y0aGWWLHwh5aa+L6vKTeUsWfhCXl780sAWBgAAAMCwI/gDANgGT9z6eIrK5r8yuagUeeKWxweoIgAAAACGK8EfAMA26F7d3bO856aUSqV0dXYNUEUAAAAADFeCPwCAbdA8qjlFsYUZf0WRltaWAaoIAAAAgOFK8AcAsA0mdhyYUtMWZvw1lXJAx+QBqggAAACA4UrwBwCwDXZq2zm7HbF7qpVqn69XK9XsfuQe2alt54EtDAAAAIBhR/AHALCNps0+Nm86as+knJ5lP4uiSMrJm6btmaMuOabOFQIAAAAwHIyodwEAAENdU0tTpn/muLy8+KU8ccvj6ersSktrSw7omGymHwAAAAADRvAHANBPdmrbOUd+7Kh6lwEAAADAMGWpTwAAAAAAAGgAgj8AAAAAAABoAII/AAAAAAAAaACCPwAAAAAAAGgAgj8AAAAAAABoAII/AAAAAAAAaACCPwAAAAAAAGgAgj8AAAAAAABoAII/AAAAAAAAaACCPwAAAAAAAGgAI+pdAABAoyh3dWXkS6tSqlZTlMtZt/PoVFta6l0WAAAAAMOE4A8AYFsVRVp/92Ka16xNiiIplZKiSMvq1eneYft07rrLhm0AAAAAUEOW+gQA2Eatv3sxzZ1rNjx5LeD7/WNz55q0/u7FOlUGAAAAwHAi+AMA2AblV7s2zPTb1Iy+UinNa9am3NU1sIUBAAAAMOwI/gAAtsHIl1dtWN5zc4oi2728amAKAgAAAGDYEvwBAGyDUrW65e/vK5VSrlQHpiAAAAAAhi3BHwDANijK5a2a8VdtctkFAAAAQG35CRQAwDZYt/PorZrx9+pOowemIAAAAACGLcEfAMA2qLa0pHv77Tc9668o0r3D9qm2tAxsYQAAAAAMO4I/AIBt1LnbLulu3WHDk9cCwN8/drfukM5dd6lTZQAAAAAMJyPqXQAAwJBXKqVzt11T7urKdi+vSrlSTbWpnFd3Gm2mHwAAAAADRvAHANBPqi0tWTthfL3LAAAAAGCYstQnAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANIAR9S4AABhcyosXZeQtN6e0enWKUaOyrmNmqm371rssAAAAAGALhnzwN2/evFx99dW9tu2777659957N7nPPffck6uuuirPP/982tracv755+fYY4+tdakAMLh1daV1zsVpXviTpFJNSqWkKNJy/33pPmJqOmd/OmlpqXeVAAAAAMAmNMRSn295y1vyH//xHz1/vvGNb2xy7IMPPpjzzjsvp556au68884cf/zxOfvss/PEE08MYMUAMPi0zrk4zQt+nFSLDaFfsuGxWqR5wY/TOufi+hYIAAAAAGxWQwR/TU1NmTBhQs+fsWPHbnLs17/+9bzjHe/Ihz70oey///4599xzc+CBB+bGG28cwIoBYHApL3pqw0y/pqa+BzQ1pXnhT1JevGhgCwMAAAAAttqQX+ozSZ5++ulMnz492223Xdrb23Peeedljz326HPsww8/nDPOOKPXtunTp+f+++9/Xe9ZLpdSLpd6bWtqKvd6BPqH3oLa+OPeGnn7v6ZUrf5hpl9fqtVsf9u/5tUL/78BqhCGJp9b0P/0FdSG3oLa0FtQG3oLts6QD/4OPfTQzJ07N/vuu2+WLl2aa665Ju973/vy7W9/O6NGjdpo/LJlyzJ+/Phe28aNG5dly5a9rvcdO7Y1pU38cHT06O1f17GAraO3oDZGj94+Wd+VjNjEbL8/MqLSlR3GtA5AVTD0+dyC/qevoDb0FtSG3oLa0FuweUM++Dv22GN7/nvSpEk57LDDctxxx+Wee+5JR0dHzd53xYrOPmf8jR69fVatWptKpVqz94bhRm9BbfxxbzWPaEnz+srmZ/wVRbqaWvLqys6BKxKGIJ9b0P/0FdSG3oLa0FtQG3qL4W7MVv4y/pAP/v7U6NGj09bWlmeeeabP18ePH7/R7L7ly5dvNAtwS6rVItVq0edrlUo169f7hwf6m96C2qhUquk+ZWZGf+e+ZBOfbUmScjlrT3lvqvoQtorPLeh/+gpqQ29BbegtqA29BZvXcIvhdnZ25tlnn82ECRP6fL29vT0PPPBAr23z589Pe3v7AFQHAINTtW3fdB/xtqRS6XtApZLuI6em2rbvwBYGAAAAAGy1IR/8fe5zn8t//ud/5rnnnsuDDz6Yc845J+VyOSeddFKS5IILLsjll1/eM/7000/Pj370o1x33XV58sknM2/evPziF7/IaaedVq9TAIBBoXP2pek+6uikXEqK38/8K4qkXEr3tKPTecmn61sgAAAAALBZQ36pz9/+9rf56Ec/mpdeeiljx47NW9/61nzrW9/K2LFjkyRLlixJufyHfHPKlCm57LLLcuWVV+aKK65IW1tbrrnmmhxwwAH1OgUAGBxaWtL5mc+lvHhRtrvl5pQ7O1Ntbc2rHTPN9AMAAACAIaBUFMVmvsyHTVm69JWNto0YUc6YMa1ZubLTGsPQj/QW1IbegtrQW9D/9BXUht6C2tBbUBt6i+FuwoQdt2rckF/qEwAAAAAAABD8AQAAAAAAQEMQ/AEAAAAAAEADEPwBAAAAAABAAxD8AQAAAAAAQAMQ/AEAAAAAAEADEPwBAAAAAABAAxD8AQAAAAAAQAMQ/AEAAAAAAEADEPwBAAAAAABAAxhR7wIAgMFl8eJSbrmlOatXlzJqVJGOju60tRX1LgsAAAAA2ALBHwCQJOnqSubMacnChU2pVEoplZKiSO6/vylHHFHJ7NldaWmpd5UAAAAAwKZY6hMASLIh9FuwYESq1Q2hX5KUSkm1WsqCBSMyZ47UDwAAAAAGM8EfAJBFi0pZuLApTU19v97UlCxc2JTFi0sDWxgAAAAAsNUEfwBAbr21OZXK5kO9SmXDd/8BAAAAAIOT4A8AyOrVf1jec1NKpaSz04w/AAAAABisBH8AQEaNKlIUmx9TFElr6xYGAQAAAAB1I/gDANLR0Z2mps2Hek1NRTo6ugeoIgAAAADg9RL8AQBpaytyxBGVVCp9v16pJEceWUlbmxl/AAAAADBYCf4AgCTJ7NldOeqo9SmX/7DsZ1Ek5XKRadPW55JLuupbIAAAAACwWSPqXQAAMDi0tCSf+UxXFi8u5ZZbmtPZWUpr64blPc30AwAAAIDBT/AHAPTS1lbkYx8zuw8AAAAAhhpLfQIAAAAAAEADEPwBAAAAAABAAxD8AQAAAAAAQAMQ/AEAAAAAAEADEPwBAAAAAABAAxD8AQAAAAAAQAMQ/AEAAAAAAEADEPwBAAAAAABAAxD8AQAAAAAAQAMQ/AEAAAAAAEADGFHvAgBq4eXFL+VXtzyW7tXdaR7VnIkdB2antp3rXRYAAAAAANSM4A9oKJWuShbM+WGWLHwhRaVIqVRKURR5+v5F2f2IPXLU7GPS1NJU7zIBAAAAAKDfWeoTaCgL5vwwzy94LqkmpVIpye8fq8nzC57Lgjk/rHOFAAAAAABQG4I/oGG8tGhllix8IeWmvv9pKzeVs2ThC3l58UsDWxgAAAAAAAwAwR/QMJ649fEUlWKzY4pKkSdueXyAKgIAAAAAgIEj+AMaRvfq7p7lPTelVCqlq7NrgCoCAAAAAICBI/gDGkbzqOYUxRZm/BVFWlpbBqgiAAAAAAAYOII/oGFM7DgwpaYtzPhrKuWAjskDVBEAAAAAAAwcwR/QMHZq2zm7HbF7qpVqn69XK9XsfuQe2alt54EtDAAAAAAABoDgD2go02YfmzcdtWdSTs+yn0VRJOXkTdP2zFGXHFPnCgEAAAAAoDZG1LsAgP7U1NKU6Z85Li8vfilP3PJ4ujq70tLakgM6JpvpBwAAAABAQxP8AQ1pp7adc+THjqp3GQAAAAAAMGCGfPB37bXX5jvf+U6eeuqpjBw5MocffnjOP//87Lfffpvc5/bbb89FF13Ua1tLS0t+/vOf17pcAAAAAAAAqIkhH/z953/+Z973vvflkEMOSaVSyRVXXJEPfvCDufvuu7PDDjtscr9Ro0bl3nvv7XleKpUGolwAAAAAAACoiSEf/H3ta1/r9fyzn/1sjjrqqDz66KM58sgjN7lfqVTKhAkTal0eAAAAAAAADIghH/z9qVdeeSVJstNOO2123Jo1a3LcccelWq3mwAMPzEc/+tG85S1v2er3KZdLKZd7zxJsair3egT6h96C2tBbUBt6C/qfvoLa0FtQG3oLakNvwdYpFUVR1LuI/lKtVvM3f/M3WbVqVb75zW9uctxDDz2Up59+OhMnTswrr7yS6667Lj/96U9z9913Z7fddtuq9yqKwvKgAAAAAAAADBoNFfzNnj07P/rRj/KNb3xjqwO8JOnu7s6JJ56Yd73rXTn33HO3ap/ly1f3OeNv9Ojts2rV2lQq1ddTOrAZegtqQ29Bbegt6H/6CmpDb0Ft6C2oDb3FcDdmTOtWjWuYpT4/9alP5f/9v/+XG2+88XWFfknS3NycyZMn55lnntnqfarVItVq35lppVLN+vX+4YH+pregNvQW1Ibegv6nr6A29BbUht6C2tBbsHlDfjHcoijyqU99Kt/97ndzww03ZK+99nrdx6hUKnniiScyYcKEGlQIAAAAAAAAtTfkZ/zNmTMnd911V770pS+ltbU1S5cuTZLsuOOOGTlyZJLkggsuyK677przzjsvSXL11Venvb09++yzT1atWpWvfe1reeGFF9LR0VG38wAAAAAAAIBtMeSDv29+85tJklmzZvXaPnfu3Jx88slJkiVLlqRc/sPkxlWrVuXiiy/O0qVLs9NOO+Wggw7KzTffnDe/+c0DVzgAAAAAAAD0o1JRFH1/UR2btXTpKxttGzGinDFjWrNyZac1hqEfvZHeKnd1ZeRLq1KqVlOUy1m38+hUW1pqXCkMLT63oDb0FvQ/fQW1obegNvQW1IbeYribMGHHrRo35Gf8AfRSFGn93YtpXrM2KYqkVEqKIi2rV6d7h+3TuesuG7YBAAAAAECDKW95CMDQ0fq7F9PcuWbDk9cCvt8/NneuSevvXqxTZQAAAAAAUFuCP6BhlF/t2jDTb1Mz+kqlNK9Zm3JX18AWBgAAAAAAA0DwBzSMkS+v2rC85+YURbZ7edXAFAQAAAAAAANI8Ac0jFK1uuXv7yuVUq748l8AAAAAABqP4A9oGEW5vFUz/qpN/ukDAAAAAKDx+Ok30DDW7Tx6q2b8vbrT6IEpCAAAAAAABpDgD2gY1ZaWdG+//aZn/RVFunfYPtWWloEtDAAAAAAABoDgD2gonbvtku7WHTY8eS0A/P1jd+sO6dx1lzpVBgAAAAAAtTWi3gUA9KtSKZ277ZpyV1e2e3lVypVqqk3lvLrTaDP9AAAAAABoaII/oCFVW1qydsL4epcBAAAAAAADxlKfAAAAAAAA0AAEfwAAAAAAANAABH8AAAAAAADQAAR/AAAAAAAA0AAEfwAAAAAAANAABH8AAAAAAADQAAR/AAAAAAAA0AAEfwAAAAAAANAABH8AAAAAAADQAAR/AAAAAAAA0ABG1LsAhofy4kUZecvNKa1enWLUqKzrmJlq2771LgsAAAAAAKBhCP6ora6utM65OM0Lf5JUqkmplBRFWu6/L91HTE3n7E8nLS31rhIAAAAAAGDIs9QnNdU65+I0L/hxUi02hH7JhsdqkeYFP07rnIvrWyAAAAAAAECDEPxRM+VFT22Y6dfU1PeApqY0L/xJyosXDWxhAAAAAAAADUjwR82MvPVfNyzvuTmVara75eaBKQgAAAAAAKCBCf6omdLq1X9Y3nOTg0opd3YOTEEAAAAAAAANTPBHzRSjRiVFsYVBRaqtrQNTEAAAAAAAQAMT/FEz6zpmJk1b+F+sqZxXO2YOTEEAAAAAAAANTPBHzVTb9k33EW9LKpW+B1Qq6T5yaqpt+w5sYQAAAAAAAA1I8EdNdc6+NN1HHZ2US39Y9rMoknIp3dOOTucln65vgQAAAAAAAA1iRL0LoMG1tKTzM59LefGibHfLzSl3dqba2ppXO2aa6QcAAAAAANCPBH8MiGrbvln7sYvqXQYAAAAAAEDDstQnAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANIAR9S6A4WHx4lJuuaU5q1eXMmpUkY6O7rS1FfUuCwAAAAAAoGE0zIy/m266KTNmzMghhxySjo6O/Nd//ddmx99zzz054YQTcsghh+Qv/uIv8oMf/GCAKh1eurqSj3+8JWedNTL33Tci8+c35b77RuSss0bm4x9vSVdXvSsEAAAAAABoDA0R/P37v/975s6dm7PPPjt33HFHJk2alA9+8INZvnx5n+MffPDBnHfeeTn11FNz55135vjjj8/ZZ5+dJ554YoArb3xz5rRkwYIRqVZLKZU2bCuVkmq1lAULRmTOnJb6FggAAAAAANAgGiL4+9//+3/nr/7qr3LKKafkzW9+c+bMmZORI0fmtttu63P817/+9bzjHe/Ihz70oey///4599xzc+CBB+bGG28c4Mob26JFpSxc2JSmpr5fb2pKFi5syuLFpYEtDAAAAAAAoAEN+e/46+rqyqOPPpqzzjqrZ1u5XM60adPy0EMP9bnPww8/nDPOOKPXtunTp+f+++/f6vctl0spl3sHVk1N5V6Pw93ttzf3munXl2q1lNtua8mFF3YPXGEMOXoLakNvQW3oLeh/+gpqQ29BbegtqA29BVtnyAd/K1euTKVSybhx43ptHzduXJ566qk+91m2bFnGjx+/0fhly5Zt9fuOHdua0iYSrdGjt9/q4zSy9euTEVvxf1il0pQxYyz5yZbpLagNvQW1obeg/+krqA29BbWht6A29BZs3pAP/uplxYrOPmf8jR69fVatWptKpVqnygaPESOas35902Zn/BVF0tRUycqVZvyxaXoLakNvQW3oLeh/+gpqQ29BbegtqA29xXA3ZkzrVo0b8sHfmDFj0tTUlOXLl/favnz58o1m9b1m/PjxG83u29z4vlSrRarVos/XKpVq1q/3D88pp3TlO98ZmWp108lfuVzklFO6sn5933+X8Mf0FtSG3oLa0FvQ//QV1IbegtrQW1Abegs2b8gvhtvS0pKDDjooCxYs6NlWrVazYMGCHH744X3u097engceeKDXtvnz56e9vb2WpQ47bW1Fjjiikkql79crleTIIytpaxP6AQAAAAAAbKshH/wlyZlnnplvfetbueOOO/Lkk0/mk5/8ZNauXZuTTz45SXLBBRfk8ssv7xl/+umn50c/+lGuu+66PPnkk5k3b15+8Ytf5LTTTqvXKTSs2bO7ctRR61MuFyl+n+8VxYaZftOmrc8ll3TVt0AAAAAAAIAGMeSX+kySE088MStWrMgXv/jFLF26NJMnT85Xv/rVnqU7lyxZknL5DxnnlClTctlll+XKK6/MFVdckba2tlxzzTU54IAD6nUKDaulJfnMZ7qyeHEpt9zSnM7OUlpbi3R0dJvpBwAAAAAA0I9KRVFIX96ApUtf2WjbiBHljBnTmpUrO60xDP1Ib0Ft6C2oDb0F/U9fQW3oLagNvQW1obcY7iZM2HGrxjXEUp8AAAAAAAAw3An+AAAAAAAAoAEI/gAAAAAAAKABCP4AAAAAAACgAQj+AAAAAAAAoAEI/gAAAAAAAKABCP4AAAAAAACgAQj+AAAAAAAAoAEI/gAAAAAAAKABCP4AAAAAAACgAQj+AAAAAAAAoAEI/gAAAAAAAKABCP4AAAAAAACgAQj+AAAAAAAAoAGUiqIo6l0EAAAAAAAAsG3M+AMAAAAAAIAGIPgDAAAAAACABiD4AwAAAAAAgAYg+AMAAAAAAIAGIPgDAAAAAACABiD4AwAAAAAAgAYg+AMAAAAAAIAGIPgDAAAAAACABiD4AwAAAAAAgAYg+AMAAAAAAIAG0NDB30033ZQZM2bkkEMOSUdHR/7rv/6r1+uzZs3KxIkTe/255JJLNnvM73znO/nABz6QqVOnZuLEiXn88cc3GvNGj3vyySfniCOOSHt7e/7yL/8yd955Z68xRVHkqquuyvTp03PooYfmjDPOyOLFi7fq7wL6U716K0keeuihnH766Wlvb8+UKVPyvve9L+vWrdvssX/yk5/kPe95Tw4++OD8+Z//eW6//fbXfU4wEIZSby1cuDAzZ87M1KlTc+ihh+aEE07I9ddf/7rPCQZCPXrrueee2+iYr/255557Nnvse+65JyeccEIOOeSQ/MVf/EV+8IMf9HrdNSGDxVDqLfdbDBX1uh5cunRpPvaxj+Xoo49Oe3t73vOe9+S+++7bYr3utRgqhlJvuddiKKlXbz3zzDM5++yz8/a3vz1TpkzJ3//932fZsmVbrNfnFsNG0aDuvvvu4qCDDipuvfXW4te//nXxiU98ojjiiCOKZcuW9Yw57bTTik984hPFiy++2PPnlVde2exx77jjjmLevHnFt771reKAAw4oHnvssY3GvJHjPvDAA8V3vvOd4je/+U3x9NNPF9dff30xefLk4oc//GHPmGuvvbZ461vfWnz3u98tHn/88eIjH/lIMWPGjGLdunWv828H3rh69taDDz5YTJkypbj22muLJ554onjyySeLu+++u3j11Vc3edxnnnmmOOyww4q5c+cWv/nNb4p/+Zd/2ai3tuacoNaGWm89+uijxbe//e3iiSeeKJ599tnizjvvLA477LDi5ptvfl3nBLVWr95av359r+O9+OKLxbx584r29vZi9erVmzzuz372s2Ly5MnFV77yleI3v/lN8YUvfKE46KCDil/96lc9Y1wTMhgMtd5yv8VQUM/rwTPPPLM45ZRTikceeaR45plnimuuuaaYNGlS8eijj27yuO61GCqGWm+512KoqFdvdXZ2Fscff3xx9tlnF7/85S+LX/7yl8Xf/M3fFKecckpRqVQ2eVyfWwwnDRv8nXrqqcWcOXN6nlcqlWL69OnFtdde27PttNNOKy699NI3dPxnn312s8HfGz3uH3v3u99dfOELXyiKoiiq1Wpx9NFHF1/96ld7Xl+1alVx8MEHF3fdddc2vxdsrXr2VkdHR09PbK3Pf/7zxbve9a5e284999ziAx/4QM/zrTknqLWh1lt9Ofvss4vzzz+/57neYjCoZ2/9qb/8y78sLrroos2O+fu///vir//6r3tt6+joKC6++OKiKFwTMngMtd7qi/stBpt69lV7e3txxx139Nr2tre9rfjWt761yeO512KoGGq91Rf3WgxG9eqtH/3oR8WkSZN6BYirVq0qJk6cWPz4xz/e5PF8bjGcNORSn11dXXn00Uczbdq0nm3lcjnTpk3LQw891Gvst7/97UydOjUnnXRSLr/88qxdu7ZfatjScWfMmJF58+b1uW9RFFmwYEEWLVqUI488MsmGJW2WLl3a65x23HHHHHbYYRudE9RKPXtr+fLleeSRRzJu3LjMnDkz06ZNy2mnnZaFCxf2Gjdr1qz8z//5P3ueP/zwwznqqKN6jZk+fXoefvjh131OUCtDsbf+1GOPPZaHHnoob3vb2173OUGtDIZrwtf84he/yOOPP55TTz211/Y/vSbc0ueWa0IGg6HYW3/M/RaDUb376vDDD88999yTl156KdVqNXfffXdeffXVnmu7xL0WQ9NQ7K0/5V6LwaievdXV1ZVSqZSWlpaebdttt13K5XJ+9rOf9WzzucVwNqLeBdTCypUrU6lUMm7cuF7bx40bl6eeeqrn+UknnZQ99tgju+yyS371q1/lsssuy6JFi3L11Vdv0/tvzXH32muvjBkzptd+r7zySo455ph0dXWlXC5n9uzZOfroo5NsWBP8tXP403PamvWLoT/Us7eeffbZJMnVV1+dCy64IJMnT86dd96ZM844I3fddVfa2tqSJLvvvnsmTJjQs9+yZcsyfvz4XscaP358Vq9enXXr1uXll1/eqnOCWhqKvfWaY445JitWrEilUsk555yTjo6O13VOUEv1vib8Y7feemv233//TJkypdf2P70m7Otz64+v91wTMhgMxd5K3G8xuNW7r6688sr8wz/8Q6ZOnZoRI0Zk5MiRufrqq7PPPvv0jHGvxVA0FHvrNe61GMzq2Vvt7e3Zfvvt80//9E/56Ec/mqIocvnll6dSqfRc0yU+txjeGjL421rvfe97e/574sSJmTBhQs4444w888wz2XvvvWt63BtuuGGj/VpbW3PnnXdmzZo1WbBgQT772c9mr732ytSpU99wLVAPteitarXac+xTTjklSXLggQdmwYIFue2223LeeeclST7/+c9vY/UweA3G3rrpppuyZs2aPPLII7n88suzzz775KSTTnpDtUC91Oqa8DXr1q3LXXfdlb/927/d6LW+rgmhUQy23nK/RSOoVV9dddVVWbVqVa6//vqMGTMm999/f84999zcdNNNmThxYhL3WjS2wdhb7rVoBLXorbFjx+aqq67KJz/5yfzLv/xLyuVy3vWud+Wggw5KqVTqGedzi+GsIYO/MWPGpKmpKcuXL++1ffny5Rul+n/ssMMOS5I8/fTT/XIj+nqPWy6Xe37jZ/LkyXnyySfz5S9/OVOnTu357YTly5dnl1126dln+fLlmTRpUr/VCptTz956rQf233//Xtv333//vPDCC5vcb/z48Rv9lvayZcsyatSojBw5MuVy+Q2dE/Snodhbr9lrr72SbLiAX7ZsWebNm5eTTjrpDZ8T9KfBck147733Zt26dXn3u9+9xbF9fW79cb2uCRkMhmJvJe63GNzq2VfPPPNMbrzxxtx11115y1vekiSZNGlSFi5cmJtuuimf+tSn+tzPvRZDwVDsrde412Iwq/f14PTp03P//fdnxYoVGTFiREaPHp2jjz46J5544ib38bnFcNKQ3/HX0tKSgw46KAsWLOjZVq1Ws2DBghx++OGb3O/xxx9Pkj6n12+LN3rcarWarq6uJMmee+6ZCRMm9Dqn1atX55FHHtnsOUF/qmdv7bnnntlll12yaNGiXtsXL16cN73pTZvcr729PQ888ECvbfPnz097e3uSN35O0J+GYm/1pVqtpru7O4neYnAYLNeEt912W2bMmJGxY8duceyWPrdcEzIYDMXe6ov7LQaTevbVa9+1VC73/hFRU1NTiqLY5H7utRgKhmJv9cW9FoPNYLkeHDt2bEaPHp0FCxZk+fLlmTFjxibH+txiOGnIGX9JcuaZZ+bCCy/MwQcfnEMPPTQ33HBD1q5dm5NPPjnJht+6+fa3v51jjz02O++8c371q19l7ty5OfLIIzf7G50vvfRSlixZkhdffDFJen5QOn78+EyYMGGrj/v+978/f/7nf57TTjstSXLttdfm4IMPzt57752urq784Ac/yL/927/lk5/8ZJKkVCrl9NNPz//6X/8r++yzT/bcc89cddVV2WWXXfLOd76zFn+F0Kd69VapVMoHP/jBzJs3L5MmTcrkyZNzxx135KmnnsoXv/jFnuNccMEF2XXXXXuWJ5w5c2ZuuummfP7zn88pp5ySBx54IPfcc0+uvfbarT4nGAhDrbduuumm7L777tlvv/2SJD/96U9z3XXXZdasWVt9TjAQ6tVbr3n66afz05/+NF/+8pf7PM6fXhOefvrpmTVrVq677roce+yx+fd///f84he/6PmNcNeEDBZDrbfcbzEU1Kuv9ttvv+yzzz655JJLcuGFF2bnnXfO/fffnx//+Me97pvcazFUDbXecq/FUFHP68Hbbrst+++/f8aOHZuHHnoo//iP/5gzzjijp28Sn1sMbw0b/J144olZsWJFvvjFL2bp0qWZPHlyvvrVr/ZMy21ubs6CBQvy9a9/PWvWrMnuu++e//bf/luf3w/xx773ve/loosu6nn+D//wD0mSc845J3/3d3+31cd99tlns3Llyp7na9asyZw5c/Lb3/42I0eOzH777Zd/+qd/6jU9+cMf/nDWrl2bSy65JKtWrcpb3/rWfPWrX8122223zX9fsLXq1VtJcsYZZ6Srqytz587Nyy+/nEmTJuW6667rtTTAkiVLev023V577ZVrr702c+fOzde//vXstttuufTSS/OOd7xjq88JBsJQ661qtZorrrgizz33XJqamrL33nvn/PPPz8yZM7f6nGAg1LO3kg03pLvttlumT5/e53H+9JpwypQpueyyy3LllVfmiiuuSFtbW6655poccMABPWNcEzIYDLXecr/FUFDPn2N8+ctfzuWXX56PfOQjWbNmTfbee+989rOfzbHHHtuzn3sthqqh1lvutRgq6nk9uGjRolxxxRV5+eWX86Y3vSkf+chHcsYZZ/Q6js8thrNS8XrnlgMAAAAAAACDTkN+xx8AAAAAAAAMN4I/AAAAAAAAaACCPwAAAAAAAGgAgj8AAAAAAABoAII/AAAAAAAAaACCPwAAAAAAAGgAgj8AAAAAAABoAII/AAAAAAAAaAAj6l0AAAAAg9vEiRO3OGbu3Lm54447ssMOO+Taa68dgKoAAAD4U6WiKIp6FwEAAMDg9fDDD/d6/t73vjezZs3KSSed1LNt7733zooVK1Iul7PffvsNcIUAAAAkZvwBAACwBe3t7Rtt23333TfaPnbs2IEpCAAAgD75jj8AAAD6xaxZs3LWWWf1PJ83b14OP/zwPPbYY3nve9+bQw89NO95z3vy2GOP5dVXX83s2bNz5JFH5phjjsn111+/0fEeeuihnH766Wlvb89b3/rWnHfeeVm+fPkAnhEAAMDQIvgDAACgZrq7u3PhhRfmr/7qrzJv3rysX78+55xzTj7+8Y9n5MiRufLKK/POd74zc+fOzYMPPtiz30MPPZRZs2Zlxx13zBe+8IV8+tOfzs9//vP87d/+bR3PBgAAYHCz1CcAAAA1093dnfPPPz/HHntskqRareYjH/lIDjvssFx00UVJkre//e259957c++992bKlClJkssvvzwHH3xwrr766pRKpSTJAQcckJNOOik/+MEPeo4HAADAH5jxBwAAQM2Uy+UcddRRPc/b2tqSJNOmTevZ1tTUlL333ju//e1vkyRr167Ngw8+mBNOOCGVSiXr16/P+vXr09bWlt133z0///nPB/QcAAAAhgoz/gAAAKiZkSNHpqWlped5c3NzkmTHHXfsNa65uTmvvvpqkmTVqlWpVCqZO3du5s6du9ExlyxZUsOKAQAAhi7BHwAAAIPKjjvumFKplLPOOivvfOc7N3p9zJgxdagKAABg8BP8AQAAMKjssMMOaW9vz1NPPZVDDjmk3uUAAAAMGYI/AAAABp0LLrgg73//+3PuuefmXe96V0aPHp3f/va3mT9/fk4++eRMnTq13iUCAAAMOoI/AAAABp0pU6bkG9/4RubNm5eLLroo3d3d2W233fL2t789++yzT73LAwAAGJRKRVEU9S4CAAAAAAAA2DblehcAAAAAAAAAbDvBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADQAwR8AAAAAAAA0AMEfAAAAAAAANADBHwAAAAAAADSA/x/QHv7UVj2SOgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Strategy-specific visualization\n", + "from matplotlib.pyplot import pink\n", + "\n", + "\n", "assert pt_bt_config is not None\n", + "assert pair.predicted_df_ is not None\n", "\n", "if FIT_METHOD_TYPE == \"StaticFit\" and hasattr(pair, 'predicted_df_'):\n", " print(\"=== STATIC FIT FIT_MODEL VISUALIZATION ===\")\n", @@ -952,6 +1074,17 @@ " axes[1].axhline(y=-pt_bt_config['dis-equilibrium_close_trshld'], color='brown',\n", " linestyle=':', alpha=0.7)\n", " axes[1].axhline(y=0, color='black', linestyle='-', alpha=0.5, linewidth=0.5)\n", + "\n", + " # if pair_trades is not None and len(pair_trades) > 0:\n", + " # # Show trading signals over time\n", + " # trade_times = pair_trades['time'].values\n", + " # trade_actions = pair_trades['action'].values\n", + " \n", + " # for i, (time, action) in enumerate(zip(trade_times, trade_actions)):\n", + " # color = 'red' if 'BUY' in action else 'blue'\n", + " # axes[1].scatter(time, i, color=color, alpha=0.8, s=50)\n", + " \n", + "\n", " axes[1].set_title('Testing Period: Scaled Dis-equilibrium with Trading Thresholds')\n", " axes[1].set_ylabel('Scaled Dis-equilibrium')\n", " axes[1].legend()\n", @@ -962,9 +1095,19 @@ " # Show trading signals over time\n", " trade_times = pair_trades['time'].values\n", " trade_actions = pair_trades['action'].values\n", + " position_statuses = pair_trades['status'].values\n", " \n", - " for i, (time, action) in enumerate(zip(trade_times, trade_actions)):\n", - " color = 'red' if 'BUY' in action else 'blue'\n", + " for i, (time, action, status) in enumerate(zip(trade_times, trade_actions, position_statuses)):\n", + " if action == \"BUY\":\n", + " if status == \"OPEN\":\n", + " color='red'\n", + " else:\n", + " color='pink'\n", + " else:\n", + " if status == \"OPEN\":\n", + " color='blue'\n", + " else:\n", + " color='purple'\n", " axes[2].scatter(time, i, color=color, alpha=0.8, s=50)\n", " \n", " axes[2].set_title('Trading Signal Timeline')\n", @@ -997,9 +1140,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "PAIRS TRADING BACKTEST SUMMARY\n", + "================================================================================\n", + "\n", + "Pair: COIN & MSTR\n", + "Strategy: SlidingFit\n", + "Configuration: equity\n", + "Data file: 20250605.mktdata.ohlcv.db\n", + "Trading date: 20250605\n", + "\n", + "Strategy Parameters:\n", + " Training window: 120 minutes\n", + " Open threshold: 2\n", + " Close threshold: 1\n", + " Funding per pair: $2000\n", + "\n", + "Sliding Window Analysis:\n", + " Total data points: 391\n", + " Maximum iterations: 271\n", + " Analysis type: Dynamic sliding window\n", + "\n", + "Trading Signals: 20 generated\n", + " Unique trade times: 10\n", + " BUY signals: 10\n", + " SELL signals: 10\n", + "\n", + "First few trading signals:\n", + " 1. SELL COIN @ $260.46 at 2025-06-05 15:40:00\n", + " 2. BUY MSTR @ $380.53 at 2025-06-05 15:40:00\n", + " 3. BUY COIN @ $259.39 at 2025-06-05 16:02:00\n", + " 4. SELL MSTR @ $379.90 at 2025-06-05 16:02:00\n", + " 5. SELL COIN @ $259.62 at 2025-06-05 16:31:00\n", + " ... and 15 more signals\n", + "\n", + "================================================================================\n" + ] + } + ], "source": [ "print(\"=\" * 80)\n", "print(\"PAIRS TRADING BACKTEST SUMMARY\")\n", diff --git a/research/pt_backtest.py b/research/pt_backtest.py index ea33f15..5ce1e94 100644 --- a/research/pt_backtest.py +++ b/research/pt_backtest.py @@ -99,7 +99,7 @@ def run_backtest( ) if single_pair_trades is not None and len(single_pair_trades) > 0: pairs_trades.append(single_pair_trades) - + print(f"pairs_trades: {pairs_trades}") # Check if result_list has any data before concatenating if len(pairs_trades) == 0: print("No trading signals found for any pairs")