From 1b26bb9c5735c5ed5975ef7c76b773bacda7be03 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 20:22:57 +0200 Subject: [PATCH 01/18] added probabilistic erupt within the erupt class Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/erupt.py | 72 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/causaltune/erupt.py b/causaltune/erupt.py index 5bbb77df..30483748 100644 --- a/causaltune/erupt.py +++ b/causaltune/erupt.py @@ -4,6 +4,8 @@ import pandas as pd import numpy as np +from scipy import stats + # implementation of https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3111957 # we assume treatment takes integer values from 0 to n @@ -94,3 +96,73 @@ def weights( assert not np.isnan(weight.sum()), "NaNs in ERUPT weights" return pd.Series(index=df.index, data=weight) + + + #NEW: + def probabilistic_erupt_score( + self, + df: pd.DataFrame, + outcome: pd.Series, + treatment_effects: pd.Series, + treatment_std_devs: pd.Series, + iterations: int = 1000 + ) -> float: + """ + Calculate the Probabilistic ERUPT (Expected Response Under Proposed Treatments) score. + + This method uses Monte Carlo simulation to estimate the expected outcome under + a probabilistic treatment policy, accounting for uncertainty in treatment effects. + It balances potential improvements against estimation uncertainty and treatment rates. + + Args: + df (pd.DataFrame): The input dataframe containing treatment information. + outcome (pd.Series): The observed outcomes for each unit. + treatment_effects (pd.Series): Estimated treatment effects for each unit. + treatment_std_devs (pd.Series): Standard deviations of treatment effects. + iterations (int): Number of Monte Carlo iterations (default: 1000). + + Returns: + float: The Probabilistic ERUPT score, representing the relative improvement + over the baseline outcome, adjusted for uncertainty. + """ + # Calculate the baseline outcome (mean outcome for untreated units) + baseline_outcome = outcome[df[self.treatment_name] == 0].mean() + + policy_values = [] + treatment_decisions = [] + + # Perform Monte Carlo simulation + for _ in range(iterations): + # Sample treatment effects from normal distributions + sampled_effects = pd.Series( + np.random.normal(treatment_effects, treatment_std_devs), + index=treatment_effects.index + ) + + # Define policy: treat if sampled effect is positive + # Note: A more conservative policy could use: sampled_effects > 2 * treatment_std_devs + policy = (sampled_effects > 0).astype(int) + + # Calculate expected outcome under this policy + expected_outcome = ( + baseline_outcome + + (policy * sampled_effects).mean() + ) + + policy_values.append(expected_outcome) + treatment_decisions.append(policy.mean()) + + # Calculate mean and standard error of policy values + mean_value = np.mean(policy_values) + se_value = np.std(policy_values) / np.sqrt(iterations) + + # Placeholder for potential treatment rate penalty + treatment_penalty = 0 + + # Calculate score: mean value minus 2 standard errors, adjusted for treatment penalty + score = (mean_value - 2*se_value) * (1 - treatment_penalty) + + # Calculate relative improvement over baseline + improvement = (score - baseline_outcome) / baseline_outcome + + return improvement From 8c1fd39e07f897f653321b1a113a2c6c0a15b94e Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 20:28:14 +0200 Subject: [PATCH 02/18] added function to generate linear synthetic datasets Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/datasets.py | 100 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 99 insertions(+), 1 deletion(-) diff --git a/causaltune/datasets.py b/causaltune/datasets.py index 9ac0eb1f..0373a780 100644 --- a/causaltune/datasets.py +++ b/causaltune/datasets.py @@ -378,7 +378,7 @@ def generate_synthetic_data( p = 1 / (1 + np.exp(X[:, 0] * X[:, 1] + X[:, 2] * 3)) p = np.clip(p, 0.1, 0.9) C = p > np.random.rand(n_samples) - print(min(p), max(p)) + # print(min(p), max(p)) else: p = 0.5 * np.ones(n_samples) @@ -427,6 +427,104 @@ def generate_synthetic_data( return data + +def generate_linear_synthetic_data( + n_samples: int = 100, + n_covariates: int = 5, + covariance: Union[str, np.ndarray] = "isotropic", + confounding: bool = True, + linear_confounder: bool = False, + noisy_outcomes: bool = False, + effect_size: Union[int, None] = None, + add_instrument: bool = False, +) -> CausalityDataset: + """Generates synthetic dataset with linear treatment effect (CATE) and optional instrumental variable. + Supports RCT (unconfounded) and observational (confounded) data. + + Args: + n_samples (int, optional): number of independent samples. Defaults to 100. + n_covariates (int, optional): number of covariates. Defaults to 5. + covariance (Union[str, np.ndarray], optional): covariance matrix of covariates. can be "isotropic", + "anisotropic" or user-supplied. Defaults to "isotropic". + confounding (bool, optional): whether or not values of covariates affect treatment effect. Defaults to True. + linear_confounder (bool, optional): whether to use a linear confounder for treatment assignment. Defaults to False. + noisy_outcomes (bool, optional): additive noise in the outcomes. Defaults to False. + add_instrument (bool, optional): include instrumental variable (yes/no). Defaults to False + effect_size (Union[int, None]): if provided, constant effect size (ATE). if None, generate CATE. + Defaults to None. + + Returns: + CausalityDataset: columns for covariates, treatment assignment, outcome and true treatment effect + """ + + if covariance == "isotropic": + sigma = np.random.randn(1) + covmat = np.eye(n_covariates) * sigma**2 + elif covariance == "anisotropic": + covmat = generate_psdmat(n_covariates) + + X = np.random.multivariate_normal( + mean=[0] * n_covariates, cov=covmat, size=n_samples + ) + + if confounding: + if linear_confounder: + p = 1 / (1 + np.exp(X[:, 0] * X[:, 1] + 3 * X[:, 2])) + else: + p = 1 / (1 + np.exp(X[:, 0] * X[:, 1] + X[:, 2] * 3)) + + p = np.clip(p, 0.1, 0.9) + C = p > np.random.rand(n_samples) + else: + p = 0.5 * np.ones(n_samples) + C = np.random.binomial(n=1, p=0.5, size=n_samples) + + if add_instrument: + Z = np.random.binomial(n=1, p=0.5, size=n_samples) + C0 = np.random.binomial(n=1, p=0.006, size=n_samples) + T = C * Z + C0 * (1 - Z) + else: + T = C + + # fixed effect size: + if effect_size is not None: + tau = [effect_size] * n_samples + else: + # heterogeneity in effect size: + weights = np.random.uniform(low=0.4, high=0.7, size=n_covariates) + e = np.random.randn(n_samples) * 0.01 + tau = X @ weights.T + e + 0.1 + + err = np.random.randn(n_samples) * 0.05 if noisy_outcomes else 0 + + # linear dependence of Y on X: + mu = lambda X: X @ np.random.uniform(0.1, 0.3, size=n_covariates) # noqa E731 + + Y_base = mu(X) + err + Y = tau * T + Y_base + + features = [f"X{i+1}" for i in range(n_covariates)] + df = pd.DataFrame( + np.array([*X.T, T, Y, tau, p, Y_base]).T, + columns=features + + ["treatment", "outcome", "true_effect", "propensity", "base_outcome"], + ) + data = CausalityDataset( + data=df, + treatment="treatment", + outcomes=["outcome"], + effect_modifiers=features, + propensity_modifiers=["propensity"], + ) + if add_instrument: + df["instrument"] = Z + data.instruments = ["instrument"] + return data + + + + + def generate_synth_data_with_categories( n_samples=10000, n_x=10, true_effect: Union[float, int, Callable] = 0.1 ) -> CausalityDataset: From f57e75eeeeb512e48104bea54668c1bca8b92f58 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 20:30:34 +0200 Subject: [PATCH 03/18] added new metrics: frobenius norm, policy risk, codec, probabilistic erupt Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/scoring.py | 490 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 487 insertions(+), 3 deletions(-) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index 430d23b3..fe822baf 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -1,7 +1,7 @@ import copy import logging import math -from typing import Optional, Dict, Union, Any, List +from typing import Optional, Dict, Union, Any, List, Callable import numpy as np import pandas as pd @@ -18,6 +18,10 @@ import dcor +### Imports for CODEC +from scipy.spatial import distance +from sklearn.neighbors import NearestNeighbors + class DummyEstimator: def __init__( @@ -37,6 +41,7 @@ def supported_metrics(problem: str, multivalue: bool, scores_only: bool) -> List metrics.append("ate") return metrics elif problem == "backdoor": + #print("backdoor") if multivalue: # TODO: support other metrics for the multivalue case return ["energy_distance", "psw_energy_distance"] @@ -44,11 +49,15 @@ def supported_metrics(problem: str, multivalue: bool, scores_only: bool) -> List metrics = [ "erupt", "norm_erupt", + "prob_erupt",#NEW + "policy_risk",#NEW "qini", "auc", # "r_scorer", "energy_distance", "psw_energy_distance", + "frobenius_norm",#NEW + "codec"#NEW ] if not scores_only: metrics.append("ate") @@ -96,6 +105,11 @@ def __init__( }, ).estimator + if not hasattr(self.psw_estimator, 'estimator') or not hasattr(self.psw_estimator.estimator, 'propensity_model'): + raise ValueError("Propensity model fitting failed. Please check the setup.") + else: + print("Propensity Model Fitted Successfully") + treatment_name = self.psw_estimator._treatment_name if not isinstance(treatment_name, str): treatment_name = treatment_name[0] @@ -109,6 +123,7 @@ def __init__( + self.psw_estimator._observed_common_causes_names, ) + def ate(self, df: pd.DataFrame) -> tuple: """Calculate the Average Treatment Effect. Provide naive std estimates in single-treatment cases. @@ -170,6 +185,7 @@ def resolve_reported_metrics( """ metrics = supported_metrics(self.problem, self.multivalue, scores_only=False) + if metrics_to_report is None: return metrics else: @@ -206,6 +222,7 @@ def energy_distance_score( YX_0 = Y0X[Y0X[split_test_by] == 0] select_cols = estimate.estimator._effect_modifier_names + ["yhat"] + energy_distance_score = dcor.energy_distance( YX_1[select_cols], YX_0[select_cols] ) @@ -229,10 +246,95 @@ def _Y0_X_potential_outcomes(estimate: CausalEstimate, df: pd.DataFrame): if est.identifier_method == "iv" else treatment_name ) - Y0X = copy.deepcopy(df) + return Y0X, treatment_name, split_test_by + # NEW: + def frobenius_norm_score( + self, + estimate: CausalEstimate, + df: pd.DataFrame, + sd_threshold: float = 1e-2, + ) -> float: + """ + Calculate Frobenius norm-based score between treated and controls, + using propensity score weighting. + + Args: + estimate (CausalEstimate): causal estimate to evaluate + df (pandas.DataFrame): input dataframe + sd_threshold (float): threshold for standard deviation of CATE estimates + + Returns: + float: Frobenius norm-based score, or np.inf if calculation is not possible + """ + # Attempt to get CATE estimates, handling potential AttributeErrors + try: + cate_estimates = estimate.estimator.effect(df) + except AttributeError: + try: + cate_estimates = estimate.estimator.effect_tt(df) + except AttributeError: + return np.inf # Return inf if neither method is available + + # Check if CATE estimates are consistently constant (below threshold) + if np.std(cate_estimates) <= sd_threshold: + return np.inf # Return inf for consistently constant CATE estimates + + # Prepare data for treated and control groups + Y0X, treatment_name, split_test_by = self._Y0_X_potential_outcomes(estimate, df) + Y0X_1 = Y0X[Y0X[split_test_by] == 1] # Treated group + Y0X_0 = Y0X[Y0X[split_test_by] == 0] # Control group + + # Check if either group is empty + if len(Y0X_1) == 0 or len(Y0X_0) == 0: + return np.inf # Return inf if either group is empty + + # Select columns for analysis + select_cols = estimate.estimator._effect_modifier_names + ["yhat"] + + # Calculate propensity scores for treated group + YX_1_all_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + Y0X_1[ + self.causal_model.get_effect_modifiers() + + self.causal_model.get_common_causes() + ] + ) + treatment_series = Y0X_1[treatment_name] + YX_1_psw = np.zeros(YX_1_all_psw.shape[0]) + for i in treatment_series.unique(): + YX_1_psw[treatment_series == i] = YX_1_all_psw[:, i][treatment_series == i] + + # Calculate propensity scores for control group + YX_0_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + Y0X_0[ + self.causal_model.get_effect_modifiers() + + self.causal_model.get_common_causes() + ] + )[:, 0] + + # Ensure both datasets have the same number of rows + min_rows = min(len(Y0X_1), len(Y0X_0)) + Y0X_1 = Y0X_1.iloc[:min_rows] + Y0X_0 = Y0X_0.iloc[:min_rows] + YX_1_psw = YX_1_psw[:min_rows] + YX_0_psw = YX_0_psw[:min_rows] + + # Calculate the difference matrix with propensity score weights + D = (Y0X_1[select_cols].values - Y0X_0[select_cols].values) * np.sqrt(YX_1_psw * YX_0_psw).reshape(-1, 1) + + # Compute Frobenius norm of the weighted difference matrix + frobenius_norm = np.linalg.norm(D, ord='fro') + + # Normalize the Frobenius norm by sqrt(n * p) where n is number of samples and p is number of features + n, p = D.shape + normalized_score = frobenius_norm / np.sqrt(n * p) + + # Return the normalized score if it's finite, otherwise return infinity + return normalized_score if np.isfinite(normalized_score) else np.inf + + def psw_energy_distance( self, estimate: CausalEstimate, @@ -324,6 +426,78 @@ def psw_energy_distance( 2 * np.mean(distance_xy) - np.mean(distance_xx) - np.mean(distance_yy) ) return psw_energy_distance + + #NEW: + @staticmethod + def default_policy(cate: np.ndarray) -> np.ndarray: + """Default policy that assigns treatment if CATE > 0.""" + return (cate > 0).astype(int) + + #NEW: + def policy_risk_score( + self, + estimate: CausalEstimate, + df: pd.DataFrame, + cate_estimate: np.ndarray, + outcome_name: str, + policy: Optional[Callable[[np.ndarray], np.ndarray]] = None, + rct_indices: Optional[pd.Index] = None, + sd_threshold: float = 1e-2, + clip: float = 0.05 + ) -> float: + # Use default_policy if no custom policy is provided + if policy is None: + policy = self.default_policy + + # If no specific RCT indices are provided, use all indices + if rct_indices is None: + rct_indices = df.index + + # Ensure cate_estimate is a 1D array for consistent processing + cate_estimate = np.squeeze(cate_estimate) + + # Return 0 if CATE estimates are consistently constant (below threshold) + if np.std(cate_estimate) <= sd_threshold: + return 0 # This indicates no heterogeneity in treatment effects + + # Apply the policy to get treatment assignments based on CATE estimates + policy_treatment = policy(cate_estimate) + + # Validate that the propensity model is properly fitted + if not hasattr(self.psw_estimator, 'estimator') or not hasattr(self.psw_estimator.estimator, 'propensity_model'): + raise ValueError("Propensity model fitting failed. Please check the setup.") + else: + # Calculate propensity scores using the pre-fitted propensity model + propensity_scores = self.psw_estimator.estimator.propensity_model.predict_proba(df) + if propensity_scores.ndim == 2: + propensity_scores = propensity_scores[:, 1] # Use second column if 2D array + + # Clip propensity scores to avoid extreme weights + propensity_scores = np.clip(propensity_scores, clip, 1 - clip) + + treatment_name = self.psw_estimator._treatment_name + + # Calculate inverse probability weights + weights = np.where(df[treatment_name] == 1, + 1 / propensity_scores, + 1 / (1 - propensity_scores)) + + # Prepare RCT subset for analysis + rct_df = df.loc[rct_indices].copy() + rct_df['weight'] = weights[rct_indices] + rct_df['policy_treatment'] = policy_treatment[rct_indices] + + # Compute policy value using inverse probability weighting + value_policy = ( + (rct_df[outcome_name] * (rct_df[treatment_name] == 1) * (rct_df['policy_treatment'] == 1) * rct_df['weight']).sum() / rct_df['weight'].sum() * (rct_df['policy_treatment'] == 1).mean() + + (rct_df[outcome_name] * (rct_df[treatment_name] == 0) * (rct_df['policy_treatment'] == 0) * rct_df['weight']).sum() / rct_df['weight'].sum() * (rct_df['policy_treatment'] == 0).mean() + ) + + # Compute Policy Risk (1 - policy value) + policy_risk = 1 - value_policy + + return policy_risk + @staticmethod def qini_make_score( @@ -353,6 +527,294 @@ def qini_make_score( qini_score = metrics.qini_score(new_df) return qini_score["model"] + + #NEW + @staticmethod + def randomNN(ids): + """ + Generate a list of random nearest neighbors. + + Parameters: + ids (array-like): List of indices to sample from. + + Returns: + numpy.ndarray: Array of sampled indices with no position i having x[i] == i. + """ + + m = len(ids) + # Sample random integers from 0 to m-2, size m, with replacement + x = np.random.choice(m - 1, m, replace=True) + # Adjust x to ensure no position i has x[i] == i + x = x + (x >= np.arange(m)) + return np.array(ids)[x] + + #NEW + @staticmethod + def estimateConditionalQ(Y, X, Z): + """ + Estimate Q(Y, Z | X), the numerator of the measure of conditional dependence of Y on Z given X. + + Parameters: + Y (array-like): Vector of responses (length n). + X (array-like): Matrix of predictors (n by p). + Z (array-like): Matrix of predictors (n by q). + + Returns: + float: Estimation of Q(Y, Z | X). + """ + + # Ensure X and Z are numpy arrays + if not isinstance(X, np.ndarray): + X = np.array(X) + if not isinstance(Z, np.ndarray): + Z = np.array(Z) + + # To turn Z from shape (n,) to (n,1) + Z = Z.reshape(-1, 1) + + n = len(Y) + W = np.hstack((X, Z)) + + # Compute the nearest neighbor of X + nn_X = NearestNeighbors(n_neighbors=3, algorithm='auto').fit(X) + nn_dists_X, nn_indices_X = nn_X.kneighbors(X) + nn_index_X = nn_indices_X[:, 1] + + # Handle repeated data + repeat_data = np.where(nn_dists_X[:, 1] == 0)[0] + df_X = pd.DataFrame({'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) + df_X['rnn'] = df_X.groupby('group')['id'].transform(Scorer.randomNN) + nn_index_X[repeat_data] = df_X['rnn'].values + + # Nearest neighbors with ties + ties = np.where(nn_dists_X[:, 1] == nn_dists_X[:, 2])[0] + ties = np.setdiff1d(ties, repeat_data) + + if len(ties) > 0: + def helper_ties(a): + distances = distance.cdist(X[a].reshape(1, -1), np.delete(X, a, axis=0)).flatten() + ids = np.where(distances == distances.min())[0] + x = np.random.choice(ids) + return x + (x >= a) + + nn_index_X[ties] = [helper_ties(a) for a in ties] + + # Compute the nearest neighbor of W + nn_W = NearestNeighbors(n_neighbors=3, algorithm='auto').fit(W) + nn_dists_W, nn_indices_W = nn_W.kneighbors(W) + nn_index_W = nn_indices_W[:, 1] + + repeat_data = np.where(nn_dists_W[:, 1] == 0)[0] + df_W = pd.DataFrame({'id': repeat_data, 'group': nn_indices_W[repeat_data, 0]}) + df_W['rnn'] = df_W.groupby('group')['id'].transform(Scorer.randomNN) + nn_index_W[repeat_data] = df_W['rnn'].values + + # Nearest neighbors with ties + ties = np.where(nn_dists_W[:, 1] == nn_dists_W[:, 2])[0] + ties = np.setdiff1d(ties, repeat_data) + + if len(ties) > 0: + nn_index_W[ties] = [helper_ties(a) for a in ties] + + # Estimate Q + R_Y = np.argsort(np.argsort(Y)) # Rank Y with ties method 'max' + Q_n = (np.sum(np.minimum(R_Y, R_Y[nn_index_W])) - + np.sum(np.minimum(R_Y, R_Y[nn_index_X]))) / (n**2) + + return Q_n + + #NEW + @staticmethod + def estimateConditionalS(Y, X): + """ + Estimate S(Y, X), the denominator of the measure of dependence of Y on Z given X. + + Parameters: + Y (array-like): Vector of responses (length n). + X (array-like): Matrix of predictors (n by p). + + Returns: + float: Estimation of S(Y, X). + """ + + # Ensure X is a numpy array + if not isinstance(X, np.ndarray): + X = np.array(X) + + n = len(Y) + + # Compute the nearest neighbor of X + nn_X = NearestNeighbors(n_neighbors=3, algorithm='auto').fit(X) + nn_dists_X, nn_indices_X = nn_X.kneighbors(X) + nn_index_X = nn_indices_X[:, 1] + + # Handle repeated data + repeat_data = np.where(nn_dists_X[:, 1] == 0)[0] + df_X = pd.DataFrame({'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) + df_X['rnn'] = df_X.groupby('group')['id'].transform(Scorer.randomNN) + nn_index_X[repeat_data] = df_X['rnn'].values + + # Nearest neighbors with ties + ties = np.where(nn_dists_X[:, 1] == nn_dists_X[:, 2])[0] + ties = np.setdiff1d(ties, repeat_data) + + if len(ties) > 0: + def helper_ties(a): + distances = distance.cdist(X[a].reshape(1, -1), np.delete(X, a, axis=0)).flatten() + ids = np.where(distances == distances.min())[0] + x = np.random.choice(ids) + return x + (x >= a) + + nn_index_X[ties] = [helper_ties(a) for a in ties] + + # Estimate S + R_Y = np.argsort(np.argsort(Y)) # Rank Y with ties method 'max' + S_n = np.sum(R_Y - np.minimum(R_Y, R_Y[nn_index_X])) / (n**2) + + return S_n + + #NEW + @staticmethod + def estimateConditionalT(Y, Z, X): + """ + Estimate T(Y, Z | X), the measure of dependence of Y on Z given X. + + Parameters: + Y (array-like): Vector of responses (length n). + Z (array-like): Matrix of predictors (n by q). + X (array-like): Matrix of predictors (n by p). + + Returns: + float: Estimation of T(Y, Z | X). + """ + + S = Scorer.estimateConditionalS(Y, X) + + # Happens only if Y is constant + if S == 0: + return 1 + else: + return Scorer.estimateConditionalQ(Y, X, Z) / S + + #NEW + @staticmethod + def codec(Y, Z, X=None, na_rm=True): + """ + Estimate the conditional dependence coefficient (CODEC). + + The conditional dependence coefficient (CODEC) is a measure of the amount of conditional dependence between + a random variable Y and a random vector Z given a random vector X, based on an i.i.d. sample of (Y, Z, X). + The coefficient is asymptotically guaranteed to be between 0 and 1. + + Parameters: + Y (array-like): Vector of responses (length n). + Z (array-like): Matrix of predictors (n by q). + X (array-like, optional): Matrix of predictors (n by p). Default is None. + na_rm (bool): If True, remove NAs. + + Returns: + float: The conditional dependence coefficient (CODEC) of Y and Z given X. If X is None, this is just a measure of the dependence between Y and Z. + + References: + Azadkia, M. and Chatterjee, S. (2019). A simple measure of conditional dependence. + https://arxiv.org/pdf/1910.12327.pdf + """ + + if X is None: + # Ensure inputs are in proper format + if not isinstance(Y, np.ndarray): + Y = np.array(Y) + if not isinstance(Z, np.ndarray): + Z = np.array(Z) + #print(f"Shape of Z: {Z.shape}") + #print(f"Z is: {Z}") + + if len(Y) != Z.shape[0]: + raise ValueError("Number of rows of Y and Z should be equal.") + if na_rm: + # Remove NAs + mask = np.isfinite(Y) & np.all(np.isfinite(Z), axis=1) + Z = Z[mask] + Y = Y[mask] + + n = len(Y) + if n < 2: + raise ValueError("Number of rows with no NAs should be greater than 1.") + + return Scorer.estimateConditionalQ(Y, Z, np.zeros((n, 0))) + + # Ensure inputs are in proper format + if not isinstance(Y, np.ndarray): + Y = np.array(Y) + if not isinstance(X, np.ndarray): + X = np.array(X) + if not isinstance(Z, np.ndarray): + Z = np.array(Z) + if len(Y) != X.shape[0] or len(Y) != Z.shape[0] or X.shape[0] != Z.shape[0]: + raise ValueError("Number of rows of Y, X, and Z should be equal.") + + + n = len(Y) + if n < 2: + raise ValueError("Number of rows with no NAs should be greater than 1.") + + return Scorer.estimateConditionalT(Y, Z, X) + + #NEW + @staticmethod + def identify_confounders(df: pd.DataFrame, treatment_col: str, outcome_col: str) -> list: + """ + Identify confounders in a DataFrame. + + Args: + df (pd.DataFrame): Input dataframe + treatment_col (str): Name of the treatment column + outcome_col (str): Name of the outcome column + + Returns: + list: List of confounders' column names + """ + + confounders = [ + col for col in df.columns if col not in [treatment_col, outcome_col, "random", "index"] + ] + return confounders + + #NEW + @staticmethod + def codec_score(estimate: CausalEstimate, df: pd.DataFrame) -> float: + """Calculate the CODEC score for the effect of treatment on y_factual. + + Args: + estimate (CausalEstimate): causal estimate to evaluate + df (pd.DataFrame): input dataframe + + Returns: + float: CODEC score + """ + est = estimate.estimator + treatment_name = est._treatment_name if isinstance(est._treatment_name, str) else est._treatment_name[0] + outcome_name = est._outcome_name + confounders = Scorer.identify_confounders(df, treatment_name, outcome_name) + + ######## + cate_est = est.effect(df) + standard_deviations = np.std(cate_est) + + df["dy"] = est.effect_tt(df) + + df["yhat"] = df[est._outcome_name] - df["dy"] + + #### have to use corrected y, not y factual to get the estimators contribution in + Y = df["yhat"] + Z = df[treatment_name] + X = df[confounders] + + if standard_deviations < 0.01: + return np.inf + + return Scorer.codec(Y, Z, X) + @staticmethod def auc_make_score( @@ -469,6 +931,7 @@ def group_ate( return pd.DataFrame(tmp2) + def make_scores( self, estimate: CausalEstimate, @@ -551,6 +1014,24 @@ def make_scores( ) out["norm_erupt"] = norm_erupt_score + if "prob_erupt" in metrics_to_report: + treatment_effects = pd.Series(cate_estimate, index=df.index) + treatment_std_devs = pd.Series(cate_estimate.std(), index=df.index) + prob_erupt_score = self.erupt.probabilistic_erupt_score(df, df[outcome_name], treatment_effects, treatment_std_devs) + out["prob_erupt"] = prob_erupt_score + + if "frobenius_norm" in metrics_to_report: + out["frobenius_norm"] = self.frobenius_norm_score(estimate, df) + + if "policy_risk" in metrics_to_report: + out["policy_risk"] = self.policy_risk_score( + estimate=estimate, + df=df, + cate_estimate=cate_estimate, + outcome_name=outcome_name, + policy=None + ) + if "qini" in metrics_to_report: out["qini"] = Scorer.qini_make_score(estimate, df, cate_estimate) @@ -579,6 +1060,9 @@ def make_scores( estimate, df, ) + if "codec" in metrics_to_report: + temp = self.codec_score(estimate, df) + out["codec"] = temp del df return out @@ -624,7 +1108,7 @@ def best_score_by_estimator( ] best[name] = ( min(est_scores, key=lambda x: x[metric]) - if metric in ["energy_distance", "psw_energy_distance"] + if metric in ["energy_distance", "psw_energy_distance", "frobenius_norm", "codec", "policy_risk"] else max(est_scores, key=lambda x: x[metric]) ) From cd35011b04c1e4d23a940250225f581046bf4d06 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 20:42:29 +0200 Subject: [PATCH 04/18] changes to _tune_with_config() (add initial value for best_estimator for all cases) Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/optimiser.py | 53 +++++++++++++++++++++-------------------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/causaltune/optimiser.py b/causaltune/optimiser.py index 08b921ae..754b510d 100644 --- a/causaltune/optimiser.py +++ b/causaltune/optimiser.py @@ -527,44 +527,45 @@ def update_summary_scores(self): self.scores[est_name]["estimator"] = self._best_estimators[est_name][1] def _tune_with_config(self, config: dict) -> dict: - """Performs Hyperparameter Optimisation for a - causal inference estimator + """ + Performs Hyperparameter Optimisation for a causal inference estimator. Args: - config (dict): dictionary with search space for - all tunable parameters + config (dict): Dictionary with search space for all tunable parameters. Returns: (dict): values of metrics after optimisation """ - # estimate effect with current config - - # if using FLAML < 1.0.7 need to set n_jobs = 2 here - # to spawn a separate process to prevent cross-talk between tuner and automl on component models: - estimates = Parallel(n_jobs=2, backend="threading")( delayed(self._estimate_effect)(config["estimator"]) for i in range(1) )[0] - # estimates = self._estimate_effect(config["estimator"]) - # pop and cache separately the fitted model object, so we only store the best ones per estimator if "exception" not in estimates: est_name = estimates["estimator_name"] - if ( - self._best_estimators[est_name][0] > estimates[self.metric] - if self.metric in ["energy_distance", "psw_energy_distance"] - else self._best_estimators[est_name][0] < estimates[self.metric] - ): - if self._settings["store_all"]: - self._best_estimators[est_name] = ( - estimates[self.metric], - estimates["estimator"], - ) - else: - self._best_estimators[est_name] = ( - estimates[self.metric], - estimates.pop("estimator"), - ) + current_score = estimates[self.metric] + + # Initialize best_score if this is the first estimator for this name + if est_name not in self._best_estimators: + self._best_estimators[est_name] = (np.inf if self.metric in ["energy_distance", + "psw_energy_distance", + "frobenius_norm", + "codec", + "policy_risk"] else -np.inf, None) + + best_score = self._best_estimators[est_name][0] + + # Determine if the current estimator performs better, handling inf values + if self.metric in ["energy_distance", "psw_energy_distance", "frobenius_norm", "codec","policy_risk"]: + is_better = (np.isfinite(current_score) and current_score < best_score) or (np.isinf(best_score) and np.isfinite(current_score)) + else: + is_better = (np.isfinite(current_score) and current_score > best_score) or (np.isinf(best_score) and np.isfinite(current_score)) + + # Store the estimator if we're storing all, if it's better, or if it's the first valid (non-inf) estimator + if self._settings["store_all"] or is_better or (self._best_estimators[est_name][1] is None and np.isfinite(current_score)): + self._best_estimators[est_name] = ( + current_score, + estimates["estimator"] if self._settings["store_all"] else estimates.pop("estimator") + ) return estimates From 90865ca832c0c134f54cb72cb28e789e21c6a5cb Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 20:46:10 +0200 Subject: [PATCH 05/18] updated which metrics to minimise to include the new metrics in scoring.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/optimiser.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/causaltune/optimiser.py b/causaltune/optimiser.py index 754b510d..5befc865 100644 --- a/causaltune/optimiser.py +++ b/causaltune/optimiser.py @@ -497,7 +497,7 @@ def fit( ), mode=( "min" - if self.metric in ["energy_distance", "psw_energy_distance"] + if self.metric in ["energy_distance", "psw_energy_distance", "frobenius_norm","codec","policy_risk"] else "max" ), low_cost_partial_config={}, From 463fa1785597e9b01af363e4b27182c5bb7228b0 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Mon, 12 Aug 2024 21:46:31 +0200 Subject: [PATCH 06/18] added a simple testing environment Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/Testing.ipynb | 1341 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1341 insertions(+) create mode 100644 causaltune/Testing.ipynb diff --git a/causaltune/Testing.ipynb b/causaltune/Testing.ipynb new file mode 100644 index 00000000..0a2b4121 --- /dev/null +++ b/causaltune/Testing.ipynb @@ -0,0 +1,1341 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import os\n", + "import sys\n", + "import pickle\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import copy \n", + "\n", + "import textwrap\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore') # suppress sklearn deprecation warnings for now..\n", + "try:\n", + " import graphviz\n", + "except ModuleNotFoundError as e:\n", + " import pip\n", + " pip.main([\"install\",\"graphviz\"])\n", + " import graphviz\n", + "\n", + "from typing import Union\n", + "\n", + "root_path = root_path = os.path.realpath('../../../..')\n", + "# print(root_path)\n", + "try:\n", + " import causaltune\n", + "except ModuleNotFoundError:\n", + " sys.path.append(os.path.join(root_path, \"causaltune\"))\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "from causaltune import CausalTune\n", + "from causaltune.data_utils import CausalityDataset\n", + "from causaltune.datasets import generate_synthetic_data\n", + "\n", + "# Import linear synthetic data creation\n", + "from causaltune.datasets import generate_linear_synthetic_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# set a few params\n", + "metrics = [\n", + " \"frobenius_norm\",\n", + " \"prob_erupt\",\n", + " \"policy_risk\",\n", + " \"codec\",\n", + " \"energy_distance\", \n", + " \"psw_energy_distance\"\n", + " ]\n", + "\n", + "iv_metrics = [\n", + " \"frobenius_norm\", \n", + " \"energy_distance\", \n", + " \"codec\", \n", + " ]\n", + " \n", + "n_samples = 100\n", + "test_size = 0.33 # equal train,val,test\n", + "#time_budget = 21600\n", + "components_time_budget = 10\n", + "\n", + "estimator_list = [\n", + " #\"Dummy\",\n", + " \"SparseLinearDML\",\n", + " \"ForestDRLearner\",\n", + " \"TransformedOutcome\",\n", + " \"CausalForestDML\",\n", + " \".LinearDML\",\n", + " \"DomainAdaptationLearner\",\n", + " #\"SLearner\",\n", + " \"XLearner\",\n", + " #\"TLearner\",\n", + " #\"Ortho\" \n", + " ] \n", + "\n", + "iv_estimator_list = [\n", + " 'iv.econml.iv.dr.LinearDRIV', \n", + " 'iv.econml.iv.dml.OrthoIV', \n", + " 'iv.econml.iv.dml.DMLIV',\n", + " 'iv.econml.iv.dr.SparseLinearDRIV',\n", + " 'iv.econml.iv.dr.LinearIntentToTreatDRIV'\n", + " ] \n", + "\n", + "n_runs = 1\n", + "out_dir = \"\"\n", + "filename_out = \"iv\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Dataset Generation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create empty dictionary\n", + "data_sets = {}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Non-linear Data\n", + "Unkown Confounders (RCT), Known Confoudners (Observational), IV" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#cd_non_linear = generate_synthetic_data(n_samples=n_samples, confounding=False, noisy_outcomes=True)\n", + "#cd_non_linear.preprocess_dataset()\n", + "#data_sets['rct_non-linear'] = cd_non_linear" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#cd_non_linear = generate_synthetic_data(n_samples=n_samples, confounding=True, noisy_outcomes=True)\n", + "#cd_non_linear.preprocess_dataset()\n", + "#data_sets['known_confounders_non-linear'] = cd_non_linear" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "cd_non_linear = generate_synthetic_data(n_samples=n_samples, confounding=True, add_instrument=True)\n", + "cd_non_linear.preprocess_dataset()\n", + "data_sets['IV_non-linear'] = cd_non_linear" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Linear Data\n", + "Unkown Confounders (RCT), Known Confoudners (Observational), IV" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#cd_linear = generate_linear_synthetic_data(n_samples=n_samples, confounding=False, noisy_outcomes=True)\n", + "#cd_linear.preprocess_dataset()\n", + "#data_sets['rct_linear'] = cd_linear" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#cd_linear = generate_linear_synthetic_data(n_samples=n_samples, confounding=True, noisy_outcomes=True)\n", + "#cd_linear.preprocess_dataset()\n", + "#data_sets['known_confounders_linear'] = cd_linear" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
treatmentoutcometrue_effectbase_outcomeinstrumentrandomX1X2X3X4X5propensity
000.4505431.2890240.45054310.0-0.076146-0.1326210.4198291.4962460.0944850.219328
100.1566400.4836190.15664001.0-0.8249380.6183840.1110481.294570-0.6940360.544131
20-0.468900-1.123213-0.46890001.0-0.084203-0.9989360.038287-0.766497-0.2990850.450420
31-2.290974-1.580341-0.71063310.0-0.072053-0.549470-1.041654-0.865283-0.3795140.900000
400.0443350.2168950.04433500.0-0.1306181.086328-0.4310980.116885-0.3143610.807708
\n", + "
" + ], + "text/plain": [ + " treatment outcome true_effect base_outcome instrument random \\\n", + "0 0 0.450543 1.289024 0.450543 1 0.0 \n", + "1 0 0.156640 0.483619 0.156640 0 1.0 \n", + "2 0 -0.468900 -1.123213 -0.468900 0 1.0 \n", + "3 1 -2.290974 -1.580341 -0.710633 1 0.0 \n", + "4 0 0.044335 0.216895 0.044335 0 0.0 \n", + "\n", + " X1 X2 X3 X4 X5 propensity \n", + "0 -0.076146 -0.132621 0.419829 1.496246 0.094485 0.219328 \n", + "1 -0.824938 0.618384 0.111048 1.294570 -0.694036 0.544131 \n", + "2 -0.084203 -0.998936 0.038287 -0.766497 -0.299085 0.450420 \n", + "3 -0.072053 -0.549470 -1.041654 -0.865283 -0.379514 0.900000 \n", + "4 -0.130618 1.086328 -0.431098 0.116885 -0.314361 0.807708 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cd_linear = generate_linear_synthetic_data(n_samples=n_samples, confounding=True, add_instrument=True)\n", + "cd_linear.preprocess_dataset()\n", + "data_sets['IV_linear'] = cd_linear\n", + "cd_linear.data.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Model Fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:51:47] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 17:51:47] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:52:27] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'frobenius_norm': 1.7061476082509759}, 'validation': {'frobenius_norm': 1.8133158981000745}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:52:47] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'frobenius_norm': 1.5240321859227073}, 'validation': {'frobenius_norm': 1.2537755378872513}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:53:07] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'frobenius_norm': 1.4503309515531349}, 'validation': {'frobenius_norm': 2.1334819838273797}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:53:48] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'frobenius_norm': 2.0273869220789993}, 'validation': {'frobenius_norm': 1.6487019570997452}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:54:49] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 17:54:49] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'frobenius_norm': 1.469078660688006}, 'validation': {'frobenius_norm': 1.2767739128957123}}\n", + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:55:29] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'energy_distance': 1.2342694730438208}, 'validation': {'energy_distance': 3.581697941996879}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:55:49] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'energy_distance': 0.26447111116414446}, 'validation': {'energy_distance': 1.8041461329277957}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:56:10] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'energy_distance': 0.28117313378506426}, 'validation': {'energy_distance': 0.873065452526324}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:56:50] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'energy_distance': 0.20387149159602824}, 'validation': {'energy_distance': 0.7661351736217683}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:57:51] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 17:57:51] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'energy_distance': 0.20716529061236866}, 'validation': {'energy_distance': 0.8863925741834082}}\n", + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:58:31] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'codec': 0.008658008658008658}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:58:51] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'codec': 0.08900523560209424}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:59:12] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'codec': 0.07894736842105264}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 17:59:52] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'codec': 0.05365853658536586}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:00:53] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 18:00:53] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'codec': 0.008695652173913044}, 'validation': {'codec': 0.0}}\n", + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:01:33] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'frobenius_norm': 1.7238523719841985}, 'validation': {'frobenius_norm': 1.2998893813992485}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:01:54] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'frobenius_norm': 1.5951272809656039}, 'validation': {'frobenius_norm': 1.0673157380063014}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:02:14] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'frobenius_norm': 1.5749917488367353}, 'validation': {'frobenius_norm': 1.1209231659854761}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:02:54] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'frobenius_norm': 1.7497389879147947}, 'validation': {'frobenius_norm': 1.4443528602451912}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:03:55] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 18:03:55] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'frobenius_norm': 1.615607024139133}, 'validation': {'frobenius_norm': 1.1343300656833482}}\n", + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:04:36] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'energy_distance': 0.23724020051138384}, 'validation': {'energy_distance': 1.2377427037908548}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:04:56] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'energy_distance': 0.252395428844979}, 'validation': {'energy_distance': 1.2199628927910995}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:05:16] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'energy_distance': 0.2526835825297922}, 'validation': {'energy_distance': 1.2201602220588965}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:05:56] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'energy_distance': 0.2677465290200698}, 'validation': {'energy_distance': 1.260878360107383}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:06:57] {493} WARNING - Using CFO for search. To use BlendSearch, run: pip install flaml[blendsearch]\n", + "[flaml.tune.tune: 07-24 18:06:57] {636} INFO - trial 1 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'energy_distance': 0.2590631341798373}, 'validation': {'energy_distance': 1.2301493868146594}}\n", + "Initial configs: [{'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'projection': True}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}, {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:07:38] {636} INFO - trial 2 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearDRIV', 'train': {'codec': 0.05142857142857143}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:07:58] {636} INFO - trial 3 config: {'estimator': {'estimator_name': 'iv.econml.iv.dml.DMLIV', 'mc_agg': 'mean'}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.OrthoIV', 'train': {'codec': 0.18991097922848665}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:08:18] {636} INFO - trial 4 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'projection': 0, 'opt_reweighted': 0, 'cov_clip': 0.1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dml.DMLIV', 'train': {'codec': -0.0033333333333333335}, 'validation': {'codec': 0.0}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.tune.tune: 07-24 18:08:59] {636} INFO - trial 5 config: {'estimator': {'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'cov_clip': 0.1, 'opt_reweighted': 1}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.SparseLinearDRIV', 'train': {'codec': 0.01342281879194631}, 'validation': {'codec': 0.0}}\n", + "after estimate\n", + "after setting score dictionary\n", + "{'estimator_name': 'iv.econml.iv.dr.LinearIntentToTreatDRIV', 'train': {'codec': 0.05654761904761905}, 'validation': {'codec': 0.0}}\n" + ] + } + ], + "source": [ + "for dataset_name, cd in data_sets.items():\n", + " \n", + " for i_run in range(1,n_runs+1):\n", + " \n", + " cd_i = copy.deepcopy(cd)\n", + " train_df, test_df = train_test_split(cd_i.data, test_size=test_size)\n", + " test_df = test_df.reset_index(drop=True)\n", + " cd_i.data = train_df\n", + " \n", + " #for metric in metrics:\n", + " for metric in iv_metrics:\n", + " ct = CausalTune(\n", + " metric=metric,\n", + " metrics_to_report=[metric],\n", + " verbose=1,\n", + " components_verbose=1,\n", + " components_time_budget=components_time_budget,\n", + " #estimator_list=estimator_list,\n", + " estimator_list=iv_estimator_list,\n", + " store_all_estimators=True,\n", + " )\n", + "\n", + " ct.fit(\n", + " data=cd_i,\n", + " treatment=\"treatment\",\n", + " outcome=\"outcome\",\n", + " )\n", + "\n", + " # compute relevant scores (skip newdummy)\n", + " datasets = {\"train\": ct.train_df, \"validation\": ct.test_df, \"test\": test_df}\n", + " # get scores on train,val,test for each trial, \n", + " # sort trials by validation set performance\n", + " # assign trials to estimators\n", + " estimator_scores = {est: [] for est in ct.scores.keys() if \"NewDummy\" not in est}\n", + " for trial in ct.results.trials:\n", + " # estimator name:\n", + " estimator_name = trial.last_result[\"estimator_name\"]\n", + " if trial.last_result[\"estimator\"]:\n", + " estimator = trial.last_result[\"estimator\"]\n", + " scores = {}\n", + " for ds_name, df in datasets.items():\n", + " scores[ds_name] = {}\n", + " # make scores\n", + " est_scores = ct.scorer.make_scores(\n", + " estimator,\n", + " df,\n", + " metrics_to_report=ct.metrics_to_report,\n", + " )\n", + "\n", + " # add cate:\n", + " scores[ds_name][\"CATE_estimate\"] = estimator.estimator.effect(df)\n", + " # add ground truth for convenience\n", + " scores[ds_name][\"CATE_groundtruth\"] = df[\"true_effect\"]\n", + " scores[ds_name][metric] = est_scores[metric]\n", + " estimator_scores[estimator_name].append(scores)\n", + "\n", + "\n", + " # sort trials by validation performance\n", + " for k in estimator_scores.keys():\n", + " estimator_scores[k] = sorted(\n", + " estimator_scores[k],\n", + " key=lambda x: x[\"validation\"][metric],\n", + " reverse=False if metric in [\"energy_distance\", \"psw_energy_distance\", \"codec\"] else True,\n", + " )\n", + " results = {\n", + " \"best_estimator\": ct.best_estimator,\n", + " \"best_config\": ct.best_config,\n", + " \"best_score\": ct.best_score,\n", + " \"optimised_metric\": metric,\n", + " \"scores_per_estimator\": estimator_scores,\n", + " }\n", + "\n", + "\n", + " with open(f\"{out_dir}{filename_out}_{metric}_run_{i_run}_{dataset_name}.pkl\", \"wb\") as f:\n", + " pickle.dump(results, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACUYAAAbqCAYAAAAHbTiuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAC4jAAAuIwF4pT92AAEAAElEQVR4nOzdd1gU1/s28HsBQaQJiAoW7BrFghVjAUti7zVfC9ZojFGjRo29GzXGkqiJUVFjNGpiNPaOXcQGil2xIQKKgKLUnfcPX+a3A1tml4Vd8P5c117XzuyZM8/uDst5Zs6coxAEQQAREREREREREREREREREREREVE+YmHqAIiIiIiIiIiIiIiIiIiIiIiIiIyNHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiIiIiIiIiIiIiIiIiIiIiCjfYccoIiIiIiIiIiIiIiIiIiIiIiLKd9gxioiIiIiIiIiIiIiIiIiIiIiI8h12jCIiIiIiIiIiIiIiIiIiIiIionyHHaOIiPK5wMBAKBQK8fHo0SNTh2Q2BgwYIH4ufn5+pg6HiIiIiChHPXr0SJIbBAYGmjok2TZs2CCJ3dhmzpwp1l2mTBmN5fT5DP38/MRyAwYMMHrMxsbckYiIiIhIPX3yEdVyGzZsyJ0AP1Kmyrn4HRPlPewYRUQfvcwNWn0fu3btMvVbIDJY5gs7CoUCBQsWxOPHj/WqR3X78ePH51C0RERERMYnJx+wtbVF8eLFUb9+fXz11VfYv38/lEqlqUMnUmvZsmWYOXMmZs6cmac6v+lDXR5jyOPatWumfitmZ8OGDeLxw/MdRERElFOYh+Vvqjela3rY29vDw8MDTZo0wejRo3Hy5EkIgmDq0IkonzL7jlHjx4/P8kNZokQJJCUlmSSeFy9eoFChQlli+uWXX0wSDxERkbElJydj2rRppg6DiCjH6JNjaDqRo200EUN17do1y37q16/Pk0JEZiApKQlRUVEIDg7Gr7/+inbt2qFy5cr5ttMJ5W3Lli3DrFmzMGvWLB6jpLcNGzaIxw87RhFlnzlc3wgJCYGFhUWWOPbu3ZtrMRARGYJ5WP6WmJiIyMhInDlzBitWrICfnx+8vb1x5coVU4dGRPmQlakD0ObmzZtYsWJFlvVTpkxBwYIFTRARULx4cXz99df48ccfJeunT5+O3r17o0iRIiaJi4iMp2jRonBwcJBd3t7ePgejITKNP//8E+PHj0eNGjVMHQoRkVGZY46RIeMCpGpHqODgYKxbtw5DhgwxYWREHxd1+cD79+8RHR2NtLQ0cd39+/fRokULbNmyBb169crtMIlIhYODA4oWLar3djY2NjkQDRHRB+aSe9SsWRPdunXD33//LVk/ZswYfPbZZ/wtJCKzwDwsf/P09ISVlbRbQmJiIqKjoyWjgIWEhKBx48Y4ePAgmjZtmtthElE+ZtYdo8aOHYvU1FTJOg8PD5NfFJgwYQJ++eUXyV0dr1+/xvTp07Fq1SoTRkZExrBw4cJcnYuYTGfDhg2c/1kDpVKJSZMmYf/+/aYOhYjIqMw1xwCA6tWro0uXLti5c6dk/ZQpU9C7d292xibKJZrygffv3+PYsWOYNm2aOP2WUqlE//79UbduXZQvXz53AyWjypg6zJjy2p3sfn5+eXaUwq5duzK3IyKzY065x7Rp07J0jHrw4AGWL1+OCRMm5Ho8RESZ5ac8LK+2qXNSYGCg2tHXExMTcfjwYUyfPh03btwA8OE779mzJ+7fv6/zXFhey7mIyHTMdiq9U6dO4dChQ1nWf/PNN7C2tjZBRP/Hzc0N/fr1y7J+7dq1ePjwoQkiIiIiMo7ixYuLzw8cOICTJ0+aMBoiIuMy5xwjw7hx47Ksi46OxtKlS00QDRGpsrW1Rfv27XHhwgX4+fmJ61NSUjBnzhzTBUZERERmx9xyjxo1auCzzz7Lsn7hwoWIj4/P9XiIiORiHpa/2dnZoUuXLrh48SLq168vro+KisLvv/9uwsiIKL8x2xGjpk2blmWdjY0NvvzySxNEk9Xo0aOz/CCnpqZizpw5CAgIMFFURGTOXr9+jdOnT+P58+eIjY2Fq6sr+vXrh0KFCqktr1QqERwcjFu3biE6OhpWVlYoVqwYateujU8++cRocV28eBG3b99GZGQkHB0dUaFCBfj5+aFAgQLZqjc8PBzBwcGIiopCYmIi3NzcULlyZTRs2BCWlpZGi/3WrVuIjIyEvb29GLupp0LKjpcvX+LSpUt48OAB4uPjoVAoYGdnhxIlSqBixYqoVq2a0T4/db7++mssXboUsbGxAICJEyfiwoULObY/4MP/z3PnzuHBgweIjo6Gra0tihUrBh8fH7V3kRjq0qVLuHPnDiIjIyEIAho3boyGDRvKiu/kyZMIDw9HTEwMnJ2d0aBBA9SuXVvjNoIg4OLFi7h69SpiY2Ph6OiIatWqoWnTpjn6/RGRduaeYwDAp59+irp16+LSpUuS9UuWLMHo0aPh6OhoosiIKIONjQ3Wrl2LypUrIz09HQCwd+9eKJVKWFjIu/8sMTERp06dwrNnzxATEwMnJyf07NkTbm5uGrcJDQ1FSEiIONVAsWLF4OXlBW9vbygUCqO8t+vXryM0NBQRERGwtbVF2bJl0bx5c405iy4RERG4fv06wsPDERcXB0tLS7i4uKBChQrw8fExWrtdqVTizJkzuH//PqKjo+Hi4oJPPvkEjRo1kv2dmIt3797hypUruHnzJuLi4pCamopChQqhaNGiKFeuHGrVqgVbW1tTh6lWWloagoKCcP/+fbx8+RIpKSlwcnJChQoVUKdOHbi6upo6RKMw5O83N2MLDAzE06dPER8fj+LFi6Nu3bqoVq2aqUMj+uiYY+4xevRoHDlyRLIuNjYWy5Ytw4wZM0wUFRGRPIbmYe/fv8fp06fx+PFjvHz5Eg4ODihevDiaNGmCYsWK5Vb4erl58yZCQkIQExODN2/ewN7eHp6enqhZsybKli1r6vByhK2tLX788UfJ9Hn79u3Dt99+a/R95eWci4iyQTBDQUFBAoAsjy+++MLUoUk0aNAgS4zW1tbC8+fPTR0aEekhICBA8nccEBBgcF2enp5iPTNmzBAEQRAePXokdO3aVbC2ts7ymxEeHp6ljsTERGHmzJmCm5ub2t9CAEL58uWFdevWCenp6TpjOnHihNp9bt26VahYsaLa+l1cXIQffvhBSEtL0+v9p6enC+vXrxeqVKmiMXZXV1dh1qxZwvv373XWl/m7ybB161ahUqVKauu3t7cX5s2bJyt2f39/cTtfX99sl8tM3fGgydWrV4W2bdsKlpaWGj87AIKdnZ3QuXNnITQ0VHYc2oSHh0vq//nnn4Uff/xRsm7Hjh0661EtP27cOFn7fvXqlTBq1CjB0dFR4/utWbOmsGvXLln1aTpeVq9eLZQrVy5L3f7+/mKZGTNmiOs9PT0FQfhwPM+bN08oWrSo2tjq1asnhISEZInjzz//FMqWLat2m5IlSwq7d++W9X6IyLgMzTFU/weoPjJ+K3LC6tWr1e7zxx9/zLF9En3MDM0H6tatK9nu4cOHktd9fX2ztDtevnwpDBw4ULCzs8vyN37ixIks+0hNTRVWrFghlCpVSmN7ycPDQ1i8eLGQnJysM+bMbb+MfR45ckTw9vbW2L4eP3688O7dO1mfS2BgoDBixAi17S/Vh42NjTBw4EDhwYMHsurV1NZbsWKFUKJECY2fzbp162TVr649qI6mz1AddceAJlFRUcKXX34p2Nvba/3crKyshMaNGws7d+6UbJ/585HzyHysa8oddQkPDxcGDRqktV1vYWEh1KtXT1i5cqWsOuXsU1Pb3hiy8/cr91iSs0911OWnb9++Fb7++muNx0/t2rWFs2fPaqwz83cv56ErxyX6mJnr9Y20tDTBw8MjS1xubm6yztMRERlTTuVhGZ4+fSr0799fsLW1VfubrFAohMaNGwunTp0yKF5tDHlfCQkJwuzZszXmNhmPcuXKCVOnThViY2PFbePi4oRChQqJZSZMmCBrn6rbq35O+m6vTubzaXJyi/T0dMn7cHd317lNbuZcqvT9joOCgoQiRYqI2xQuXFg4efKkzu2IyHjM8ra5ZcuWqV3v7+8vuw6lUomHDx/i2LFj2LRpE5YtW4YFCxZg/vz5+Pnnn/HHH38gODgYSUlJBsepLp6UlBSsXr3a4DqJKH85evQoatasiZ07dyIlJUVn+fv376N69eqYOXMmYmJiNJZ78OABBg8ejJYtWyIhIUHvuMaNG4cvvvgC9+7dU/t6bGwsJk2ahJYtW+L9+/ey6oyKikLDhg0xaNAg3L59W2O5V69eYcaMGahTpw6eP3+ud+zffPMNvvjiC9y9e1ft62/fvsWUKVPwv//9L8/M5f3nn3+ibt262L9/v3i3iyaJiYnYtWsXgoKCciyekSNHonTp0uLylClTkJaWZtR9XLx4EZUrV8aKFSu0HsMhISHo3LkzvvjiC6Smpuq1j7S0NHTp0gVfffWV3lPdJiUloVWrVpgyZQqio6PVlgkODkajRo3EUV0EQcDIkSPRp08fhIeHq93m2bNn6NKlC7Zs2aJXPESUfcbIMXS5ePEiNm7ciB9++AGrV6/G4cOHZf3/z+yLL75QO73Gzz//DKVSaYxQicgIypcvL1nW1n4HPrRratSogYCAACQmJuqsPyYmBj4+Phg1ahSePn2qsdzz58/x3XffoW7duga1r5cvX45WrVrh6tWral9/+/YtfvzxR9SvX1/newQAPz8/rFq1Smf7Kzk5GQEBAfD29saBAwf0jlupVKJnz54YNWoUIiIi1JZ5/vw5Bg8ejD59+pj17+f169fh5eWFNWvW4O3bt1rLpqWl4cyZM/jnn39yKTrtVq1ahcqVK2P9+vVa2/UZIyJ//fXXuRid8ej795ubXrx4gQYNGmDlypUaj58rV66gSZMmWLlyZS5HR/RxMnbuoVQqERoair/++gurVq3C/PnzsWjRIqxZswZHjx7Fy5cvZdVjaWmJvn37ZlkfExPD8xRElGfIycP27t2LypUrY9OmTRqvbwiCgDNnzqBp06YYP368Sa8lnD17FhUrVsT06dM15jYZHj58iLlz5yIkJERclzGCaYZNmzbpdT7/zz//lHxOQ4YM0SN647GwsEDhwoXF5VevXhmtblPmXAcPHkTz5s3F/9ceHh44deqUZHQsIsp5ZjeVXlxcHHbu3JllfeHChdG8eXOt2z58+BArVqzA+fPncf36dVkX862srPDZZ5/hyy+/ROfOnfWKtXPnzvj666+z/LPcuHEjZs6cmeeGayci4woPD8eKFSsQHx+PQoUKoUOHDmjQoAGcnJwQFRWFffv2Saa8ePr0KZo0aYIXL16I6zw8PNCrVy9UrlwZKSkpuHr1Kv7++2+8efMGAHDixAl89tlnOH36tNoLqOoEBATgp59+AgCULFkSvXr1QqVKlfD+/XsEBwdj586d4u9nYGAgunfvjr1792qdniMyMhKNGzeWXPxwd3dHx44dUa1aNdjZ2eHJkyfYvXs3rl27BuDDcLC+vr64fPmy7GmB5s+fj19++QUAUKtWLbRv3x6enp5ITk7GhQsXsG3bNrHzzPbt2+Hn54evvvpKVt2mEhYWhgEDBogdoiwsLNCiRQs0btwYHh4esLKyQnx8PB48eIDLly8jKChIZ+ep7LKxscHs2bMxYMAAAMDdu3exdu1aDB8+3Cj1X716FS1atJAkIBUqVED37t1Rrlw5vH37FkFBQdi1axeSk5MBAH/99ReSkpLw77//yt7P+PHjsWvXLgCAl5cXOnTogDJlyiAlJQW3bt2CjY2Nxm2/+uorHD16FAqFAq1bt0azZs3g6uqKyMhI7NixQ0w83759i969eyMsLAyLFy8WLzTUqlULHTt2RKlSpfDu3TscPnwY+/btA/DhhOawYcPg6+uLEiVK6PXZEZFhspNjyLF27VrMnz9fbadIZ2dnjBkzBt9//73saWqdnJzQvHlzHDx4ULL+8ePHOH78OFq2bJntmIko+zKfaNY2Xe7r16/RpUsXPH/+HFZWVmjbti0aN24MV1dXvHz5EoGBgZLt37x5g6ZNm0puOHBxcUGPHj1QvXp1WFhYICwsDNu3bxcvBFy/fh1NmjRBcHAwXFxcZL2HY8eOYf78+VAqlXB1dUWvXr3g5eUFpVKJkJAQ7NixA3FxcQCAGzduoFWrVjh37pysKfAsLS1Rv3591K9fH2XKlIGTkxPevXuHu3fvYu/evWLukJCQgG7duuHSpUuoWrWqrLgBYNasWdixYwcAoFKlSujRowfKlCmDN2/e4NSpU9i7d6/4HW3ZsgWOjo5meSNbUlISOnXqJLmgU7NmTXz++ecoV64cbG1t8fbtW0RERODatWs4efIk3r17l6UeR0dH8SLR48ePxffu7Oys8XjI7vSsM2bMwOzZsyXrKleujLZt26JcuXIoVKgQYmNjERISgsDAQDx79ixb+zMVff9+c5NSqcT//vc/hIWFAQCaNm2KNm3awM3NDS9evMDevXvFqdGVSiW++eYbuLq6onfv3pJ6bG1txeMnIiJCvJHUwcEBRYsWVbtvub8zRB8bY+YeFy9exNKlS3HgwAHEx8drLVu1alV07twZ8+bN01qua9euWLRoUZb169evx6BBg/SKj4jIFHTlYQcOHECXLl0k5WrWrInOnTujVKlSeP36NU6cOIFDhw6J59mXLFmCtLQ0jR1bc1JGvBnnwQGgaNGiaNeuHby8vODs7Iw3b97gzp07OHPmDEJDQ9XWM2zYMGzYsAEAxHag3Ovea9euFZ/7+vqiYsWKBr+f7EhPT8fr16/FZbnXvHQxVs5liE2bNmHw4MHi8Vi5cmUcOnQInp6eRqmfiPRg0vGq1FizZo3aYet69+6tc9sdO3boPeyz6qN9+/bCq1ev9IrXx8dHbV3Hjx839CMgolyWU1PpZTw+/fRT4cmTJ1q3UyqVQsuWLSXbDRo0SEhMTMxSNiIiQmjUqJGk7MSJEzXWnXlIfAsLCwGAMHDgQLXTYdy/f1+oXr26ZJu1a9dqrD89PV1o0aKFZAjaqVOnahyCe/Xq1ZLp4gYNGqSx7szfjYWFhVCwYEFh8+bNastfvnxZcHZ2lgy1qm1KPXOYSk+17iJFigjBwcFa64yJiREWLVok/Pfff7Lj0EbdVHqC8OF7VT0OihcvrvZ4zKBah7ap9JKSkoSqVatKyk+dOlVITU3NUvbWrVtZpmVcvXq1xrrVTR9iZWUlrFmzRlAqlVo/B9XpLhQKhQBAKFq0qHDu3LksZdPT04UhQ4ZI9jNmzBjByspKsLKyEn7//XdZ8Y0dO1ZrTERkPNnJMbRNpff+/Xuhffv2snKNevXqCa9fv5Yd86+//qq2nv79+2fjkyAidQzNB7y8vCTbZW7zqw7pn/GoXLmyEBYWprPuQYMGSbZr166d2vMVr1+/Fjp37iwp26tXL431Zm77ZeQGbdq0UVv/ixcvBD8/vyxtN23c3d2FJUuWCC9evNBYJj09XVi5cqVQoEABsd6mTZtqrVddbgBAmDx5sto2/6VLl4SSJUtKtjl69KjG+k01lZ7q+1IoFML69es11icIgvD+/Xth69atwqJFizSW0WdKb1X6TKW3Z88esd0MQHB0dBS2bNmisbxSqRSOHTsmtGjRQnY82uTmVHr6/v3m5lR6GX8Htra2Gqf62Lx5s+RvzcXFRYiOjs52HESkXnZyjwwvX74UOnXqJCvPyPzQRalUCu7u7mq3lTu9LRGRMeREHhYTEyMUK1ZM0lZatWqV2nrOnz+f5ffwwIEDsuPVRu77evz4seDi4iLJB6ZOnap1GvObN28KgwcPFs6cOZPltRo1aoh1tW/fXmuMGa5cuSKJ948//pC1nS6GTKUXGBgo2aZGjRo6tzFVziXnO164cKEkZ2rQoIHw8uVLne+JiHKG2Q1p9N9//6ldb4w7uXXZu3cvunTpotdUPc2aNVO7fs+ePcYKi4jysAoVKuDQoUMoVaqU1nIHDhzA0aNHxeUuXbpg7dq1KFSoUJayHh4e2Ldvn6TX/pIlS2RPm6FUKtG2bVusXbsWtra2WV4vX748Dh48CDc3N3HdlClTNP42bt68GceOHROXFy1ahDlz5mi8i3z48OFYsmSJuBwQEID79+/Ljn3z5s3o06eP2tdr166NH374QVyOjIzEiRMnZNVtKsePHxefT506FXXr1tVavkiRIvjuu+/QoUOHHI3LwsICCxYsEJdfvHghjjSWHevWrcPNmzfF5dGjR2POnDmwsso6iGWVKlVw+PBhuLq6iuumTJmi1zS4P//8M4YOHap1xLPMBEFAgQIFcPDgQTRs2DDL6xYWFlixYgWKFy8urlu2bBnS0tKwYsUKjUMNDxgwAO3btxeX//rrL9kxEVH25ESOkZaWhp49e2Lv3r2yygcHB6NVq1aSOwC10ZRn7N+/36yngyL6WFy9ehU3btwQlz08PHS2+Z2dnXH8+HGdoyKFhYVh/fr14nKDBg3wzz//qB2dpXDhwti2bRsaNWokrtu2bRsuXrwo630olUp4e3tj586dausvVqwY/vvvP1SpUkVct2jRIq1T6j18+BBjx45FsWLFNJaxsLDAiBEjsHz5cnHdqVOnNN79rCn24cOHY968eWpH66lTpw4OHDggGSX0u+++k11/blHNBzp16oSBAwdqLV+wYEH07t3bpO8lNTUVw4cPF0dQt7W1xYkTJ/DFF19o3EahUKB58+aSvDcvkfv3m9sy2gQBAQHo0qWL2jJ9+vTBqlWrxOXY2FhJrkdExpXd3OPu3buoVasWdu/ebcywRAqFAn5+fmpfk5vbEBGZiq48bNGiRYiKihKXlyxZonFGCR8fH+zfv18yKtG4ceNyIGrNvvvuO8TGxorLq1atwpw5c9Ret8nwySefYO3atZIcMMOXX34pPj9w4ICsa0aqo0U5Ozuje/fucsM3qvfv32fJcT777DOj1J3bOZcgCPj2228xceJEMWdq27Ytjh8/LrnWQUS5y6w6RqWmpkp+nFTl1jybp06dws8//yy7vKa4Dhw4YKyQiCiXDRw4EAqFQtYjY1o4TRYtWgR7e3ud+1Q9SWlra4uff/5Za0cOJycnLF26VFxOS0vDmjVrdL85fJhC9Oeff9Y63aeHhwdmzpwpLkdFRWk8saPaycnHxwfjx4/XGcOoUaPwySefAPjQSPz1119lxf7555+jW7duWsv07dtX0qEsKChIVt2mojp1YqVKlUwYSVbt2rWT/J9bvHhxtuf1Vj3W3d3ddQ7xXqpUKcyaNUtcjo2Nld2hqFatWhg2bJhBcQ4dOhTe3t4aX7e1tc1yLHp5eemcurF///7i8+fPn+fZ6USI8pKcyjEiIiL0vhni4sWLWaYc0qRSpUpqOxW8fPkSwcHBeu2XiIzr1atX8Pf3l6zT1UYFgGnTpsHDw0NnuczTva1atUrrFMDW1tZYvXq1JH9QbXPpsnz5cq1T4zk4OEja/CkpKdi0aZPG8nKm2cswbNgwlC1bVlzW51yKi4uL5KYIdby8vDBq1Chx+erVq7h8+bLsfeQGc84HNNm6dSsiIiLE5blz56J27domjAjYuHGj7Dw+45Exdbgccv9+TaF58+bo1auX1jJDhgxB/fr1xeVNmzbJ7qxNRPJlN/d4+fIl2rZtm+PnCnhNg4jyIl15WFJSkuQGk1q1aklyAXUyl7l58yYCAwONE7AO4eHh+Oeff8Tl9u3bY/jw4dmqU/XaSHp6uji1nibv37/Hli1bxOU+ffrolc8ZQ2JiIv7991/Ur19fcr6rYMGCGDlypFH2kZs5V0pKCv73v/9JpmXs378/du/erXYgBCLKPWbVMSo0NFTtnJ12dnZ6z2darVo1jBo1CuvWrcOhQ4dw4cIFBAUFYf/+/ViwYIHWO7x++ukncV5ZXWrWrKl2/e3btyXzoBLRx8fV1VXWqD7Jyck4cuSIuNypUyeUKFFC53Zt27aVXESQe1fXZ599hnLlyuks169fP8mdCeo6Rt24cUNyV/fYsWNlxaBQKCRJjOr710ZXT34AKFSoEGrUqCEu37p1S1bdpqLaGD537pwJI1Fv0aJF4vOEhATMnTvX4LrCw8MRFhYmLvv7+8POzk7ndgMGDJCUk3us+/v76zVSlCrVDkyaZL74069fP723uX37tn6BEZHejJljqGNlZYVvvvkGhw8fxvnz5/H7779LRlbJbNGiRXjy5ImsujXlGub4/4Iov0tKSsLdu3exfPly1KxZE9evXxdfc3R0xOTJk7Vub2FhIat9AUhHoPbx8ZHV4aR69eqSi5z79u2Tta9PPvkETZo00VmuTZs2kjuxNd00oS8LCwvJCHn6dPzs1asXnJycdJZTvWsaMF7sxqKaD5w/f96Ekci3fft28bmTk1O2L+CYO33+fk1B7s0gQ4cOFZ+/evWK7QmiHJDd3GP8+PF48OCBxtc9PT0xe/ZsHDp0CBcvXsSRI0fw008/oWXLlnqd/9CUZ1y4cEEc2YKIyBzok4edP39eclPv8OHDtd4cnmHEiBGS39DcGj3vn3/+kVyLnjRpUrbrdHJyknSYX79+vdbf9b///htxcXHismp70dj8/PxQoUIFycPDwwNOTk7o2rWrZCQwhUKBVatWoUyZMkbZd27lXG/evEG7du0kN3Z/99132LBhg9oZM4god5lVxyhNd+1VqVJF1j8va2trDB48GDdv3sSNGzewfPlyDBo0CJ9//jkaNGiA+vXro02bNpg0aRJCQkLQo0cPtfVERETIHr7d3d1d47B35nYXIhHJU7RoUZQvX17WQ9ud2/Xr15fV2Lly5QpSUlLE5TZt2siKU6FQoG3btuJyaGgo3r9/r3O7Vq1ayarfwcEBn376qbis7iLF6dOnxecWFhZo3bq1rLqBD1OCZAgLC0NiYqLObXx8fGTVrdqxTLVhb45UL3QtXLgQv/32m+R4MLUGDRqga9eu4vLq1avx+PFjg+q6cOGCZFnusW5nZycZ5j1zPZqoHr/6KFCggKwLkJlHclE9pjVRnX4PMP/jkyg/yG6OoY2FhQV2796NFStW4LPPPoOPjw+GDBmCy5cvo169emq30WeUx+rVq6tdzzyDKGepG0HW1tYWlStXxpgxYyQj5RQsWBD//vtvlv/xmVWuXFnWkPmRkZGSzpNy20sAJFP2vnz5UtZ01XJzA4VCgc8//1xcvnLlitGm9XR3dxefq362usiNvUKFCihfvry4bG6j7qm2O0+fPo0RI0Zke5TWnKRUKnH27FlxuXXr1mZx57ODg4PsPD7joW26R1Vy/35NRfVvU5vM+bq5/S0Q5QfZyT3u3LmDzZs3a3y9f//+uHPnDqZNm4bPP/8c9erVQ8uWLfHtt9/iyJEjuH79uuzp+ry8vNSuj4uL09oxi4goJ2U3DzP03HPZsmUlg2nIPfecXarXVooVK6Z2ajxDqN4Y8uDBA60jYK1bt058Xq9ePckN58b2+PFjPHjwQPKIjIzMMlBJuXLlsHfvXlk3ycuVGzlXVFQU/Pz8xKnDFQoFfvrpJyxatMjgm7eJyLjMqmOUppN2pUuXlrV9x44dsXbtWnF6Jm2srKy0Tt+jT49R1bsmVck5CUlE5mfhwoW4f/++rIe235sKFSrI2t/du3cly5ru2lJHtaGampqK8PBwndtousiqq+ydO3ey3F0QEhIiPi9dujQcHBxk1616Ejo9PR2RkZE6t9F1wSmD6vSFcjpcmZLq3dWpqakYPnw43N3d4e/vj40bN5rFCan58+eLnfySk5MxdepUg+ox1rEeERGh9g7MzOT+DWbm4uKCAgUK6CyXebQrORdWMm9j7scnUX6Q3RxDm759+0o6KWcoVKgQfvvtN43b7dixQ1b9zDOIzJuvry+uXLki6yJkbucG6upSx9Dc4O3btzqn+Xn48CEWLFiATp06oWLFimIbK/PFDtVzM/p0Gjc0dnMbsXPAgAGSG25Wr16NEiVKoH379li+fDmuXLkie1Tz3BAZGSn5nurWrWu6YFR07dpVdh6f8Vi4cKGsug3NK3JDqVKlULhwYVllS5YsKSlrbn8LRPlBdnKPzZs3a/y9b9KkCQICArTeoFmtWjUcO3ZMVpwODg4afzuYaxCRudOUh6nmP4ULF9brvI9qLiUnjzKGmzdvis+N2ab28fGRvJ+1a9eqLXf//n2cPHlSXM7J0aLkql+/Ps6fP6/2XFt25HTO9eDBAzRq1AhXrlwB8OHG6z///BPffvtttmMnIuMxq3Hbnj59qna9h4dHjuxP9Y7BzPS5S9HDwwPXrl3Lsl7uFBlElD85OjrKKpd52s2iRYvK3kfmjhhypvDUp343NzfxuVKpREJCgmS6CtVe9Y8ePcpWz3c5sRsyv7W5DwHes2dPBAYGYvXq1eK62NhYbNq0CZs2bQLw4QT2Z599hi+++ELv4dGNoXLlyhg0aJA4wsmWLVvw3Xff6X0Hiep3bG1tLWvqkwzqjnVdd6bL/RvMzNB51PPj8UmUH+RkjjFgwACNr3l7e6N69eqSYd4z3Lt3D7GxsXBxcdFav6YYmWcQ5ayiRYtm6fBvY2MDJycnlCpVCrVr10b79u1RrVo12XXmt9wgo351FxtevXqFsWPH4o8//tC7rZOUlCS7rKGxy/lcclPp0qWxbt06DBgwAGlpaQA+3Iywb98+cUpEJycn+Pr6okePHujatatJR2jKfGe16ohf+ZWheUVu0OfvAPjwt5DRsc3c/haI8oPs5B5HjhzR+Nq8efOyPdptZh4eHmo7JDPXICJTyW4eptq20beNpJpL5dYI/6rtamO3qb/88kuMHDkSALBz507ExcVl6RCr2mHKzs4OvXv3NmoMmYWHh0umxktMTMTjx49x/PhxLFmyBI8ePcLFixdRp04dHD16FJUrVzbavnM655o7d6743MrKCvv27cNnn31mtPiJyDjMasSohIQEtetVR/6QIyUlBYcPH8a4cePQqlUrlC9fHq6urihYsKDkrkRLS0uNdehzciDz6A8ZNL0fIvo4yJ0z+O3bt5JlfRpcmX9/Mteljq2trdHqN2aSIGcEoPxq1apV+OuvvzSOQPbs2TMEBATg888/R+3atXNtOF9VM2fOFI9NpVKJiRMn6l2H6vGj78UcQ451zttNRIDxcozMFAoF6tevr7WMpun0BEGQ3BmoCfMMItNQN4JsWFgYzp07h23btmHixIl6dYoCPo7cAABiYmLQtGlTbNq0KUunKEtLSxQtWhSlSpWSTGfm7OwsltGnI5Whscv5XHJbnz59cP78eY03QcTHx+O///5Dv379UK5cOWzcuNEEUX7w5s0byXJ2/5/mBeacV+jzdwCY/98CUV6XndxDdVR2VS4uLmjcuHG24lKHuQYRmZvs5mHGOvecmpqK5ORk/d+AnlTb1cZuU/ft21f8DJKSkrJM1ZqWlibJKXr37q3XbCDGYGdnh6pVq2LkyJEIDQ1Fw4YNAXy4FvLZZ58ZvRN/TuZcqjdMp6WlidPpEZF5MauOUZruDLS2tpZdx/r161GuXDm0atUKP/30Ew4fPoyHDx8iNjZWr39k79+/l11W0wgR+tRBRB+vzI1efToIZZ6GS04DWp/fJl31qyYYNjY2kgsc+j4MHaUnv+jVqxdu3ryJixcvYu7cufj888/V3pl87do1NG3aFIcPH87V+Nzd3SVDvx48eFDr/OTqqB4/+naEM+RYJyICjJNjqOPi4qLxYkIGTVPhAR9GB9SFeQbRxycv5wYAMGbMGEnHz4YNG2LTpk14+PAhkpOTERUVhSdPnkgudnzzzTeyYzBG7Obajqxbty6OHDmCBw8eYOXKlejZs6faEUaioqIwYMAAzJw5M/eDRNbPj51rTEvfNkFe+FsgyssMzT3evn2rcdtPPvkkR0YOZ65BRPmNsc49FyhQQOvUpcaiGq+x29ROTk7o1auXuLxu3TrJ6/v27cOLFy/E5SFDhhh1//pycHDAP//8I45q9fTp0xyZ2i+ncq758+dLpkNctGgRxo8fb6ywichIzKpjlKZ/NCkpKbK2HzNmDAYPHqzXNHia6HOXoqakRd+7tojo46R6hzQAREdHy942c9nMdcnZRpuYmBjxuYWFRZaOOkWKFBGfly1bNssdHfo8GjRoIDuu3GboCShDRsGqV68epkyZgkOHDiE2Nhbnz5/HxIkTJcP/pqamYvDgwbly54qqCRMmSL5zfUeNUj0+U1JSEB8fL3tbQ451IiIg+zmGJnLa+trKZB5xQx3mGUQfn7ySG6ir/8WLF9i6dau43LdvX5w5cwb9+vVD2bJlNY7abegotIbGbu7tyLJly2LEiBHYtm0bIiIicOfOHSxZsiTL3fGzZ89WO11rTnN1dZUsR0ZG5noM5i4380d9/g6AvPW3QJQXGZp7aDs/klOdGJlrEFF+o9q20beNpFo+85RzOUW1XZ0Tbeovv/xSfH7t2jVcvnxZXFadRs/Lyws+Pj5G37++3N3dMXv2bHH5n3/+wfHjx3NkX8bOuZydnXH06FHJyPJLliyR3GhORKZnVh2j1I2MAcjrKfvff/9h+fLlxg5Jlsx3TWbI7WEHiShvqlSpkmRZ09DZ6oSGhorPCxQogLJly+rcRp+T5zdu3BCfV6pUKcsJ3ipVqojPnz9/DqVSKbvuvER1ZCy5J6tTUlKyPdyrpaUlfHx88MMPP+DBgwdo2rSp+NqzZ8/0HrEpuxwdHTFlyhRx+eLFi9ixY4fs7Y11rJcoUULv4ZCJ6OOVnRxDGzl3UmsrIydXYJ5B9PExVntJXV3qGJob2NnZoUSJEpLXjx8/Lt5kplAosHDhQlhY6D7t9PDhQ9kxqDI09sqVKxu0P1OpVKkSxo4di+vXr2PcuHHiekEQsGXLllyPp0SJEpKLTpcuXcr1GMydIfkj8OHOdH09ffpUdufCiIgISdm89rdAlBcYmns4OTlpfC2nRuZjrkFE+Y1q/hMXF4cnT57I3lY1l5KTRxmDl5eX+Dwn2tQ+Pj6oUaOGuJwxatTz589x4MABcb2pR4tSNWzYMJQuXVpcHjdunF4DmRjKGDmXk5MTjhw5Ik4JCADLli0zeIRkIjI+s+oYpWmqCTk9ZVesWKHxtS5duiAwMBCxsbFIT0+HIAgQBMFoF/CfP3+udr22qTOIiDLUrl1bMqS2aqNUl3379onPa9SoIeuurkOHDsmq++3btzh79qy4XK9evSxlmjVrJj5PSEjAlStXZNWd16jeJSJ3VMLLly8jLS3NaDHY29tn6QCsOk1JbhkxYgTKlCkjLk+ZMkX2+8x854ncY/3du3eSTmDmcAcLEeUd2ckxtImNjdV4MSGDtpNwLi4uOvfBPIPo4+Pu7i45EaxPbrB3717xeZEiRVChQgWd28idnlkQBEnZ2rVrZxkBSrWd7ObmpnZKgsySk5Nx5swZWTFkJjevefDgAe7fvy8uq8tr8oKMzmaqd5ZrygcKFCggPjf2zSsKhQKNGzcWlw8ePGjQSEf5mWr+GBsbq3FUFlWRkZF6XbxTJffv+ODBg5JlTX8LOXn8EOV3huYe9vb2Gqe2u3XrVo5cFGauQUT5jaHnnh89eoSwsDCN9eQU1Zugo6KiJNdijEV11KgtW7bg/fv32LBhA9LT0wF8GOmwX79+Rt+voaytrTFhwgRx+dq1a/j7779zbf/65FzqODo64tChQ5J86ZdffsGIESNypYMXEWlnVh2jNJ2003ViQKlU4uTJk2pfa968OXbu3AlfX184OztL7lY01tCET58+Vbu+fPnyRqmfiPI3GxsbfPbZZ+Ly7t27Zf0+HThwAOHh4eJy+/btZe3v6NGjePTokc5yf/zxh2Ski06dOmUpU7t2bVSsWFFcXrZsmawY8prMI2Np+t1XFRAQYPQ4Mt/Rm5qaavR96GJtbY05c+aIy/fu3cPvv/8ua9uyZctKhqPdtGmTrIsoGzdulNwhKfdYJyICDM8xdBEEARcvXtRaJjg4WO16hUKBqlWr6twH8wyij1OHDh3E5xcuXMC1a9d0bhMWFoZTp06Jy+3atZO1r5s3b8o6AX/w4EHJ76a63ED1RK/cKZ83btxo8FR627dvR0JCgs5ya9askSyriz2vsLS0lPwP0JQPqE67pM/01XL17t1bUv+vv/5q9H3kZar5Y3p6usb2gKrs5I9y8zHVcq6urmjUqJHacjl9/BDlZ9nJPWrWrKl2fWxsrMGdiDV58+aNxv+/zDWIKK/69NNPJR1afvvtN1mdUVavXi0pl1vnnrt16wYrKytxeeHChUbfR9++fcXRTOPj47Fjxw6sX79efL1r166ybtzLTYMGDULRokXF5VmzZuVqZ325OZcmDg4OOHjwIHx9fcV1q1evxrBhw9g5isjEzKpjVO3atdWu13VXxMuXLzWOVlGnTh2N223fvl2/ANWIjIzEq1ev9N43EZGqESNGiM/fv3+PUaNGaf3dS0hIkMxPbGVlJen9r01qaqrO+l+8eIGZM2eKy0WLFkXHjh2zlLOwsMCkSZPE5S1bthg0nYOcO2hNqUGDBpJlXSeeL1y4IOvE9rt37xATEyM7jsxTqaiO3JSb+vTpIzlhpzr3ty6qx/rz588xffp0reWfPXsmKePi4iK5EENEpIuhOYYcGzZs0PjalStXJFM3qapYsaKsE0+apolinkGUv3311VeS5a+//hopKSkay6empmLEiBGSk8WqbS5dRo8erbUjU2JiIsaPHy8uW1tbo3///lnKeXp6is/j4+Nx+vRprfsNDw/HxIkTZceZ2atXrzB58mStZW7evCkZYdzb29vsfkPl3LSS4f3797h79664rCkfUF2v6X9RdvTs2VMystm0adPy7ejBhvD29paMCq0rf3z48CF++OEHg/d39OhRnXfSBwQEICgoSFzu378/bGxs1JbN6eOHKD/LTu6hetNkZtOmTTPqRWFNf9uOjo6SGyCJiPISGxsbDBo0SFy+evUqVq5cqXWb0NBQySwNVatWhZ+fX06FKOHp6YkePXqIy3v27DH6DQdOTk7o1auXuDxhwgQ8ePBAXB46dKhR92cMtra2kmtfYWFh+Ouvv7JVZ07kXNrY2dlh//79aN68ubju999/x5AhQzgiK5EJmVXHqJo1a6qdBioxMVEy7HlmmYdvV3X8+HG1naYuXLiAadOmGRaoiswXqTNUqFABRYoUyXb9RPRxaNOmDVq2bCku//333xg+fLhkxKYMkZGRaN++Pe7cuSOuGz9+vKypKoAPnZn27NmDoUOHqu2Q9PDhQ7Ru3RrR0dHiuvnz50uG01fl7+8vxi4IAvr164epU6fqvHv7zZs32LZtG/z8/LJMEWduKlWqJLmAsnjxYhw5ckRt2SNHjqBt27ZIS0uDQqHQWm90dDQ8PT0xYsQInaOOPHnyRJKo2NraolWrVnq8C+NRKBSSE/cvXryQve3gwYMlo0YtWbIEs2bNEofvVXXnzh20atUKL1++FNfNnz9f4/DyRETqGJpjyLF582bs378/y/p3795h+PDhGrfr2bOnrPo15RoNGzaUFyAR5UnVqlXD4MGDxeVz586hR48eeP36dZay8fHx6N27t2S0qN69e6N+/fqy9mVhYYHLly+je/fuauuPiYlBp06dJNMHTJgwAW5ublnKNm/eXHLH86BBgzSegD579iyaNm2KuLg4ycje+rCwsMDKlSsxY8YMtW3Jq1evok2bNpKcZ/HixQbtKyc1b94cHTt2xN69e7Xejfzu3TsMGjRIMsJH586d1ZZVnf4jMDAQ27ZtM+rdyVZWVvjtt9/EfOfdu3do3ry51gsWgiAgMDBQ64X//MLe3l4y8tvmzZuxceNGtWWvXLmC5s2b482bNzrzR3Uy/n78/f2xe/dutWW2bt0qaZe4uLjg+++/11in6vHz8OFDLF261KjTxBPlZ9nJPfr06aPxOsfJkycxdOhQrR2l79+/j88//1xWnJryjPr16xv8f5mIyBxMmDABxYoVE5fHjBmjsZN6UFAQ2rRpI7lJZMmSJTkeo6rFixdLRrkaMWIEpk+frva6UIY7d+5g6NChOHfunKx9qN5QHxUVJT6vUKFCrnUC09eIESPg5OQkLs+ePVttzidXTuRcuhQqVAh79+6V5D/r16/HoEGD2DmKyESsdBfJPdbW1mjevDn27duX5bXTp09rvFvBxcUFzs7Oak/iXb58GS1btsSIESPg6emJ+Ph47N27F2vWrJE9tLs2qicfVbVu3TrbdRPRx0OhUGD9+vWoX7++2MlkzZo12LdvH3r16oXKlSsjNTUVV65cwd9//y3pdFS/fn3MmjVL9r6mTp2K2bNnY926dTh8+DB69eqFSpUqISkpCcHBwfjnn38k05u1bdtWcqdFZpaWlvjrr7/QpEkT3Lp1C0qlEvPmzcOKFSvQqlUr1KlTB0WKFIFCoUB8fDzCw8MREhKCoKAg8YROXvjNnDlzpnhyOykpCa1atULnzp3h5+cHe3t7PH/+HIcPHxbvjB88eDCOHj2Kx48fa633/fv3WL16NVavXo3SpUvj008/RfXq1VGkSBFYW1sjJiYGwcHB2LNnj+SizsyZMyXJQW5r3bo1mjVrhhMnTui1nY2NDf744w80bdpUnB5v5syZ+PPPP9GjRw+ULVsWiYmJuHDhAnbt2iV5z507d8awYcOM+j6IKP8zNMeQQ6lUolOnThgxYgQ6dOgABwcH3LhxAz/++CNu376tdhu5ozzevXtXcsIqQ+HChbOMZEhE+c/SpUtx9uxZ8bfkv//+Q8WKFdGzZ09Ur14dCoUCYWFh2LZtm2QE0nLlyum8K1rV5MmTMX/+fOzduxeVKlVCr1694OXlBUEQEBISgm3btklOCnt7e2PKlClq63Jzc8PQoUOxevVqAB8u0FarVg09e/ZEvXr1ULBgQURGRuLo0aMIDAwEAJQsWRIdOnQQt9FHRl4ze/ZsbNu2DT169ECZMmXw5s0bnD59Gnv27JGc9B4+fDhatGih935ymlKpxJ49e7Bnzx4ULlwYn376KerUqYNixYrB3t4eCQkJuHHjBnbt2iW5eaVt27YaL4D36dMHM2bMQHJyMpRKJXr37o1hw4ahZMmSks5rs2fPVjsysBytW7fGjBkzxJGG4+Pj8cUXX2DmzJlo164dypUrh0KFCiE2NhY3btzA8ePHsz2NrTY7d+40aKqpUaNGYdSoUUaPZ+rUqdi9ezfS0tIgCAIGDBiAzZs3o02bNnB2dkZMTAwCAwNx6NAhKJVKfP7553j37p3e76FRo0awsrLCiRMn0LlzZ/j6+qJNmzZwc3NDVFQU9u7dK7loplAosHLlSrWdGzN07NgRRYoUEW9QGTt2LKZOnQpPT0/JSFjDhw/X2hGc6GOUndyjSpUq6Nu3r8aOlOvXr8fx48cxePBgNGjQAM7OzoiPj8etW7dw6NAh7N+/X/aFVl7TIKL8qkiRIggICEDHjh2RlpaG9PR0fPnll1i9ejU6d+6MEiVKIC4uDoGBgThw4ICks83o0aNz/XewRIkS2LJlCzp27Ijk5GQIgoA5c+bgt99+Q/v27eHl5QVnZ2e8efMG9+7dw5kzZ3D16lUAH9r8cvj4+KBGjRoIDQ2VrB88eLBBHfNzg6OjI77++mvMnz8fwIfOYH/++afakYvlyImcSw5bW1v8999/6Nq1Kw4cOADgw3Ty6enp2LBhg9aBX4goBwhm5rfffhMAZHn07dtX63YDBgxQu522R6FChTS+5u/vLyteHx8ftdsfOnTICJ8GEeWGgIAAyd9vQECAwXV5enqK9cyYMUPv7e/duyeULVtW9u+Yn5+fEB8fr7XOEydOSLYJDw8Xxo4dK7v+xMREWbHHxcUJ7du31/u3GICwaNEitXVm/m7k8vf3F7fx9fXNdrkM3377raz307FjRyE5OVnn8RAeHm7Q5zVhwgTZn4UumWP4+eefZW978eJFQaFQZIlv3LhxOrcNCgoSihQpIvs99+7dW0hJSdFap6HHiyAIwowZM8TtPD09ZW2j7m9LDmP93hCRfIbmGIIg/V9hjMfkyZNlxfzrr7+q3f6LL77I7sdBRJkYMx9Q5evrK9Yp9xyDqujoaKF27dqyf1+8vLyEiIgIrXVmbvudOHFCWLp0qWBhYaGz/mrVqgnR0dFa609MTBQaNGggK14PDw/h8uXLstthmb+ntLQ0oUePHrLbkmlpaVpjlxuHus9QEznHgGrOIPfRokULISEhQev7CQgIEAoUKKC1nszHuiHt259//lnnfjI/jMHQXCrzQ1Pent2/X0EQhGXLlsmKwcfHR3j9+rXsfWbOYyMjI4Vq1arp3I+FhYXsfO/AgQOCvb29QZ8d0ccuO7lHTEyMUL58+Wz9rumiVCoFd3d3tdveuXPHGB8BEZEsOZWHCYIg7NmzR+s14MyPsWPHCkqlUq94tdH3fZ0+fVpwc3PT6/deWx6S2S+//CLZ1srKSoiMjJS9vSEyn0+Te+48Q3R0tOQ7rFChgpCampqlnKlyLn2+46SkJKFdu3aSbb744gudOSoRGZfZjYvao0cPtXPc79+/X+uwzdOmTUOhQoX02tfPP/+sd3yqXrx4oXbqIw8PD7O8C5GIzF+FChVw48YNzJgxQ+sdnOXLl8fatWtx7NgxODo66r2fJUuWYMuWLVpH4luwYAGOHj0q+7fVyckJe/bswaFDh9CsWTPJncjqeHh4wN/fHwcPHsTYsWP1fg+m8NNPP+HXX39F0aJF1b7u4eGBZcuWYdeuXZI7aTVxd3fH77//jk6dOsHZ2VlrWQsLC7Rs2RInT57EwoULDYrf2OrVqyeZB10f9evXx507dzBq1Citx3CNGjWwc+dObN26VeN0jkREuhiaY2hTokQJtG/fXq9t6tevj+nTp8squ2vXLrXr+/Xrp9c+iSjvcnNzQ1BQEJYvX45SpUppLOfu7o5Fixbh8uXLsqfXVjVmzBgcOnQItWrVUvu6nZ0dxo8fj+DgYK05CvBhuoDAwECMHz9eYx5hZ2eHgQMHIjQ0FLVr19Y73gyWlpbYvn07li9fjhIlSqgt4+Hhgd9//x1bt24127txV61ahUGDBqF06dI6y1avXh1r167FkSNH4ODgoLXsgAEDEBISgm+//Rb16tWDi4tLjrSnR44ciVu3bqFPnz5ac0dLS0s0atQIa9euNXoM5mr06NH4559/UKZMGbWvu7i4YNq0aTh9+jQKFy5s8H6KFy+OoKAgfP3117C3t1dbxtvbG6dOncLIkSNl1dm6dWuEhYVh6tSpaNSoEdzc3GTluESUvdyjSJEi2L9/P0qWLJlT4eHixYuIjIzMsr5+/fqoVKlSju2XiCg3tW/fHrdv30a/fv3UTnEKfBhJs1GjRjh58iSWLFli0tGTGjdujHv37mHy5Mkarz1kqFSpEmbPng1vb2/Z9fft21eSD7Vv3x7Fixc3ON7c4ObmhiFDhojL9+/fx6ZNmwyqK6dyLrlsbGywc+dOdOrUSVy3detW/O9//+OU1US5SCEIgmDqIDLr3bs3tm3blmX94cOHJXNxZrZnzx707NlTMu2OJgsWLMCkSZM0/qPz9/fHhg0btNaxevVqjBgxIsv6SZMmYcGCBTpjICLSRqlU4uLFi7h16xaio6NhZWWFYsWKoXbt2qhatarR9hMUFITbt28jMjISjo6OqFChApo1a5btk+YJCQk4e/Ysnj17hlevXgH4MASqp6cnqlatirJlyxojfJNIS0vD2bNnERYWhri4OLi5uaFChQpo2rSpwRdcBEHA3bt3cefOHTx58gQJCQlQKBRwdHRE+fLlUbduXRQpUsTI78Q8pKam4uzZs7h//z5evnyJggULolixYmjYsKHGiwhERPoyNMcYMGCA2uksPD09cfv2bXTv3l3tVBmZ1a1bF4cPH9bZERb4MB1R0aJFxSlnM5QsWRKPHj0y24v7RJSzrl27hpCQEHFofzc3N1SvXh21a9c22kn869evIyQkBM+fP0fBggVRpkwZtGzZUu8b0YAP+cDp06dx7949vHv3Dm5ubihZsiR8fX0Nqk8bpVKJ06dP4/79+4iOjoaLiwuqVKmCJk2awMLC7O4J1Oj58+e4ceMGHj16hNevXyM1NRUODg4oUaIEateujXLlypk6RK2Sk5Nx9uxZhIeHi1M8Fi5cGBUqVECdOnVk/Q/Mj5RKJYKDg3Ht2jXExsaicOHCKFu2LJo1a6a284Quqm0TX19fcWpKAHj79i0CAwPx9OlTxMfHo3jx4qhXrx6qVatmrLdDRDIYmntkePXqFQYNGoT//vtP733rutwzceJELFq0KMv6X3/9FcOGDdN7f0RE5u79+/c4deoUHj16hFevXsHe3h7u7u5o0qSJWXYOEgQBV65cQVhYGGJiYpCcnAwHBwd4enqiVq1asjr3ZHbhwgU0bNhQXN67dy/atWtnzLDzjLyecxGR4cyyY1RQUBB8fHyyrO/Tpw82b96sdduMu+FOnDih9vW6deti9uzZaNOmDQBkq2OUj48PgoKCJOsKFCiA8PBwjXcrEhERERFR7jM0x9DWMerRo0cAgN9++w3z58/HkydPspRzdnbGmDFj8P3338vudPzrr7/iq6++yrJ+4cKFmDBhgqw6iIiIKH/S1jGKiMxDdq5vZK5n6dKlOHDgABISErSW/eSTT9ClSxfMmzdPY5n09HSULl0az58/l6x3dXXF06dPNY6qQkREedvQoUPFkVt50x0RfazMsmMU8CGxP3XqlGRdwYIF8fz5c1l3mIWHh+PMmTOIjIyEpaUlPDw84O3tjSpVqhglvrCwMHh5eWVZ379/f7UXToiIiIiIyLSym2NoIwgCgoKCcOvWLURFRYkj/jVr1kzvqWfq1auHS5cuSdY5OjriyZMncHJyylacRERElLexYxRR3mDM3EOpVCI0NBS3bt1CbGws4uLiYGVlBWdnZ5QrVw61atWSNcr4vn371E4HPn36dMyaNUuvmIiIKG+Ii4tDyZIlkZiYCACYOXMmZsyYYeKoiIhyn5WpA9Bk9uzZ8PPzk6xLSkrCmjVrMHHiRJ3bly1bNkenaVq+fHmWdQUKFMD06dNzbJ9ERERERGS47OYY2igUCvj4+Ki9M1wf586dy9IpCgDGjRvHTlFERERERHmEMXMPCwsL1KpVC7Vq1cpWTOquaTg7O+Pbb7/NVr1ERGS+lixZInaKKlCgAIYOHWriiIiITMPC1AFo4uvri1atWmVZv2LFCqSkpJggov8THR2NP/74I8v6wYMHo3z58iaIiIiIiIiIdDHnHCPDkiVLsqxzc3PjxQoiIiIiojzE3HKP0NBQHDlyJMv6iRMnonDhwrkeDxER5bwtW7Zg0aJF4vKgQYPg4eFhwoiIiEzHbDtGAcBPP/0EKyvpoFbPnz/HunXrTBTRB4sXL0ZSUpJkXeHChTF79mwTRURERERERHKYa44BANevX8e///6bZf38+fPh4OBggoiIiIiIiMhQ5pR7zJkzJ8u68uXLY8yYMbkeCxER5Yz//vsPtWrVQo0aNeDs7Iw+ffqInXGdnZ0xc+ZM0wZIRGRCZt0xqmrVqhg9enSW9fPmzcvSMSm3vHjxAitXrsyyfs6cOXBzczNBREREREREJJc55hgZZsyYAUEQJOvq1auHwYMHmygiIiIiIiIylLnkHiEhIfjnn3+yrF+2bBlsbGxyLQ4iIspZsbGxCAkJwfXr1xEXFyeut7a2xp9//onixYubLjgiIhNTCJnPvBMRERERERERERGR2RkwYAA2btwI4MNUXYGBgaYNiIiIiIjMwoYNGzBw4EAAgKWlJYoVK4ZmzZph4sSJqF69uomjIyIyLXaMIiIiIiIiIiIiIiIiIiIiIiKifMesp9IjIiIiIiIiIiIiIiIiIiIiIiIyBDtGERERERERERERERERERERERFRvsOOUURERERERERERERERERERERElO+wYxQREREREREREREREREREREREeU77BhFRERERERERERERERERERERET5DjtGERHlQ8OHD4dCoYBCocCmTZtMHQ6R3gRBQO3ataFQKGBtbY3bt2+bOiQiIiLKh4zRbo6KisL+/fuxceNGLFmyBAsWLMDq1avx999/4/79+0aOmLJj5syZ4vddpkwZU4dDlGfs3r1b/Nvp16+fqcMhIiIya4bmGPfv38eOHTvwyy+/YN68eVi4cCFWrlyJXbt2ITQ0FKmpqTkYNeV1gYGB4nGnUCjw6NEjU4dEpBdeE6Kcxo5RRET5zOXLl/H7778DAGrWrIm+fftmKdOtWzdJI/m///7Tax9KpRK+vr7i9paWljh79qzasqr78fPz0/v90MdJoVDghx9+AACkpqZi1KhRJo6IiIiI8hs57WZNXr16henTp6NWrVpwd3dHu3btMGDAAIwfPx6TJ0/GiBEj0KNHD1SsWBGurq4YMmQITp06lVNvhXKAah6j76Nz586mDj/f2bBhA2bOnImZM2di165dem2r6/uysbFB4cKFUaFCBTRt2hRDhgzBqlWrEBYWZlCsjx49Uruf8ePHG1RfgwYNstSlq2NfmTJljNoJsFOnTmjYsCEAYPPmzRrzfyIioo+dvjlGfHw8Zs2ahdKlS6NixYro2bMnvvnmG0ydOhWTJk3CyJEj0aVLF9SsWRMODg7w8fHB1KlTceXKldx4O5SDeN0kf1G9CUfdw8rKCnZ2dnB3d0fNmjXRpUsXTJkyBXv37sWbN28M2ueAAQPU5javXr3Su64DBw6ojXvDhg0at9mwYYPssnLwmhDlNHaMIiLKZ8aMGQOlUgkAmD17Niwssv7U//rrr3BzcxOXv/zyS70aS8uWLZNc2Bk7diwaNWqUjaiJsvr888/RuHFjAMCRI0ewd+9eE0dERERE+YmcdnNmaWlpmDVrFsqWLYs5c+YgJCQEgiBo3SY2Nhbr1q2Dr68vmjZtiqCgIKPET/Qx2bBhA2bNmoVZs2bp3TFKl5SUFMTHx+PBgwc4ffo01q1bh6+//hpeXl6oXLkylixZYvDFClWbN29GWlqaXtuEhYXh4sWL2d63McyZM0d8PmbMGNMFQkREZMb0yTGOHz+OqlWrYubMmXj69KnOupOTkxEUFIR58+Zh8uTJRouZiHJeeno63r17hxcvXiA0NBS7du3C/Pnz0aFDBxQtWhS9evXChQsXsr2flJQU/Pnnn3pvt27dumzv2xh4TYhykpWpAyAiIuM5cOAAzpw5AwCoVq0aOnTooLacm5sbVq9eje7duwP4MP3H119/jb/++kvnPm7fvo0pU6aIy1WrVsXcuXONED1RVhMnThSP6WnTpqFdu3ZQKBQmjoqIiIjyOrntZlVxcXHo0aMHjh49KllfqFAh+Pn5oU6dOnBzc4OdnR2io6MRERGB48eP4+bNm2LZ06dPY9iwYbh27ZpR3w/lrIIFC6JEiRKyy7u7u+dgNJQd6r7L1NRUxMfH482bN+KFzAx3797F+PHj8eOPP+KXX35Bt27dDN53VFQU9u3bh06dOsnexlwuUABAixYtULduXVy6dAmXLl3Cv//+iy5dupg6LCIiIrOhT45x4sQJtGvXDklJSeI6e3t7tG7dGt7e3nBzc4OlpSViY2Nx584dBAcHIzQ0VOdNGURkHjw8PGBraytZ9/btW8TFxSE5OVmyPikpCdu3b8f27dvRq1cvrFq1Ci4uLgbvOyAgQK/Rll6+fIk9e/YYvD9j4zUhyinsGEVElI/MnDlTfD527FitjYVu3brhiy++wNatWwEA27ZtQ7du3dCjRw+N26SlpaF///5iwmZlZYWNGzfCxsbGOG+AKJN27dqhcuXKuHPnDq5du4Zdu3bx5DsRERFlmz7tZgBITExE06ZNcf36dXGdq6srpkyZgq+++goFCxbUuG14eDh+/PFHrF27FikpKdmOnXJfgwYNEBgYaOowyAi0fZdKpRJ3795FUFAQ9u3bh3///Vcc4enFixfo3r07FixYgEmTJum1z2LFiiEqKgoAsH79etkdo1JTU7F582ZxuXjx4njx4oVe+za2sWPH4n//+x+AD7+jzM2IiIj+j9wc4927d/D395d0ivrmm28wd+5cODo6aqz/+fPn2LlzJ9asWWO0mCn/8PPzY8c5M/Lnn39qnCIxPj4ewcHBOH/+PAICAhAeHi6+tm3bNly8eBFnz57V64YbOzs7AB/OXVy7dg1Xr16Ft7e3rG03b94snqswh5yD14Qop3AqPSKifOL06dPiEPtOTk7o3bu3zm1++eUXFC9eXFweMWIEoqOjNZZfsGABgoODxeXvv/8edevWzUbURNopFAoMHTpUXF6yZIkJoyEiIqL8wJB287BhwySdory8vBASEoJvv/1Wa6coAChbtixWrlyJO3fucPppIjNmYWGBKlWqwN/fH9u3b8ejR4+yjBD1/fff6z01Rd++fcULo/v37xc7SemyZ88exMTEAADKly+PTz/9VK/95oSuXbvC1dUVABAaGpplBD0iIqKPlT45xpYtWyRT540cORIrVqzQ2ikK+DACzciRIxEaGoqVK1caJ3AiynVOTk5o2bIlpk2bhvv372Pr1q1wdnYWXw8PD0e7du3w9u1b2XUWLFgQPXv2FJcDAgJkb6tatl+/frK3yym8JkQ5hSNGERHlEytWrBCf9+rVC4UKFdK5jYuLC9asWYOOHTsC+DBk5rBhw/Dvv/9mKXvt2jXMmTNHXK5VqxamTZtmhMizLzk5GWfPnsWjR48QHR0NW1tbuLu7o2nTppKOX/pISUnB9evXcfv2bURFReH9+/dwdHRE0aJF0aBBA5QpU8Zo8b9+/RqnT5/G8+fPERsbC1dXV/Tr10/WdxgREYHz58/j6dOnSE9Ph7u7O3x9fVGyZMlsxRQZGYlz587hxYsXSEhIgKurK8qVK4cmTZoYbYSwsLAwXL9+HZGRkUhOTkbt2rXx+eefZynXv39/TJw4Eenp6Th79iyuXLmC2rVrGyUGIiIi+vjo227++++/JR0hSpUqhZMnT+o9tH2ZMmVw4sQJrF+/XmfZ9PR0hIWF4datW4iMjERiYiLs7e1RpEgR1KlTB1WqVNFr37np1q1buHr1KqKiopCYmAgbGxs4OTnB09MT1atXh4eHh+y6BEHAnTt3cPPmTTx79gxv3ryBra0tXF1dUbNmTdSoUQMWFnn3nr/Q0FCEhIQgOjoaSqUSxYoVg5eXF7y9vY02VcDDhw9x+fJlREZG4u3bt6hUqZI4pbom4eHhCA4OFr9DNzc3VK5cGQ0bNoSlpaXeMaSkpODatWu4ceMGYmNjkZSUBFtbWxQpUgRly5ZFrVq1dF4INIUSJUrg77//xty5cyW57+DBg9G0aVOUKlVKVj1lypRB8+bNcezYMaSlpeGPP/7A+PHjdW6n+lsxYMAAs5iC08bGBv/73//w888/A/jwe9qyZUsTR0VERGR6+uQY+/btE58rFApMmTJF7/2VL19e720yXL9+HaGhoYiIiICtrS3Kli2L5s2byzoXrU5ERASuX7+O8PBwxMXFwdLSEi4uLqhQoQJ8fHx03kiij0uXLuHOnTuIjIyEIAho3LgxGjZsqDGuS5cu4cmTJ0hISIClpSUcHBxQsmRJVKlSBZUqVTKozZ0b581NKS9db4iJiUFoaCgePHiA169fQxAEuLi4oEyZMmjYsCEcHByyFbMqudcy9GVhYYHevXvj008/hZ+fnzh61NWrVzFhwgSsWrVKdl2DBg0SOzlt2bIFP/74I6ytrbVuc+nSJYSGhgIAHB0d0b17dyxevNjAd2M8vCZEOUIgIqI8LzY2VrC2thYACACEw4cP67X9gAEDxG0BCH/88Yfk9eTkZKF69eri69bW1kJoaKisulXr9fX11SsuXR4+fCj06dNHKFSokGQ/GQ+FQiH4+voKFy9elFVfTEyMsHLlSqFly5aCra2t2jozHlWqVBECAgIEpVIpq25PT09x2xkzZgiCIAiPHj0SunbtKvnuMh7h4eHitqrrAwICxPfevn17wdLSUm18HTt2lNQh165du4S6desKCoVCbb329vbC6NGjhdevX+us68SJE2rf099//y05nuQcH82aNRPLffPNN3q/LyIiIiJBMKzd7O3tLWmzHDt2LEdiS0hIEDZs2CB06NBBcHR01NoWLVWqlLB06VIhOTlZVt3q2pO6aGrLqaNUKoXffvtNqFixota4AQhlypQRxowZo7EdnZSUJOzYsUPo2bOnUKRIEa11ubq6CjNnzhTi4+NlvacZM2aI23p6emotm1N5TGpqqrBixQqhVKlSGt+Xh4eHsHjxYlnfb3h4uGTbEydOCIIgCIGBgYKPj0+WujW97/T0dGH9+vVClSpVtH7es2bNEt6/fy/rvSYkJAgTJkwQXF1dtX6PFhYWQu3atYU1a9ZIts98DMp5ZORaqozxXfbu3VtSz/DhwzWWzfyd/Pzzz8Kff/4pLletWlXn/iIiIsRcz8LCQnj69KnQrVs32cevav6pq6y+Tp48KdZtZWUlREVFGbV+IiKivEbfHKNWrVpi2WLFihk9Hk3twyNHjmTJbVTP+Y4fP1549+6drH0EBgYKI0aMEMqVK6e1bWZjYyMMHDhQePDggax6AwICJNtnWL16tdp9+fv7Z6njxIkTQpMmTXS2G52dnYU+ffoIT548kRWbMc+bC4Lx8w198jd1+WFeuN4gCIJw+fJl4bvvvhOqVq2q9fu1tLQUunTpIly7dk1Wvdm9lqGaa6r+3enj6tWrQsGCBcU6rK2ttR6f/v7+klxNEAShUqVK4rrt27fr3Ofw4cPF8kOHDhWuX7+u9vhQJ/Pfq9xzDXLxmhAZGztGERHlA2vWrBEbCE5OTkJqaqpe28fFxQklS5aUJAURERHi65MmTZI0cObPny+7bmM38DP8+uuvajsUqXsoFArhp59+0lln5sarnEenTp2Et2/f6qw7c8eoI0eOCE5OThrr1dYx6siRI0LhwoV1xubh4SHcvXtX1uf55s0boV27drLft4eHhxAWFqa1TnXJxMiRIzXWqe34WLFihVjOzc1NSE9Pl/W+iIiIiFTp224+evRojrVnM8t8UlHO49NPPxWio6N11m3IyUq5J9aTk5OFjh076h27ps/ekM4wVapUEe7fv6/zPZm6Y1R0dLRQp04d2e+revXqkrxMHXUXvhYuXChYWFiorVPd+37x4oVQv3592XFVrVpVZ1xPnz4VKlSooNf32KhRI0kd5tQx6vnz55L809raWoiJiVFbVl3HqPfv30tyuAsXLmjd3/z588WyrVq1EgRBMJuOUenp6ZJOiytWrDBq/URERHmNvjmGaseFwoULGz0ede3DZcuWaWwfqj68vLz0zi/kPBwdHYX9+/frrDdzTpSamip07txZY72ZO0YtWLBA79iOHDmiNaacOG+e+TM0dceovHK9QRCk7Vw5D2tra2H9+vUGfX76XMswRscoQRCy7PPbb7/VWFZdxyjVv4HWrVtr3VfmHOX8+fNm1TGK14TI2DiVHhFRPrB3717xeZMmTWBlpd/Pu5OTE9atW4dWrVoB+DC129ChQ7Fv3z6cP39eMnRmgwYNMGHCBOMEbqCFCxdi0qRJ4rJCoUCzZs3QrFkzuLu74927d7h06RL++ecfJCYmQhAEjB07FjY2NhgxYoSsfbi7u6NRo0aoVasWihQpggIFCiAqKgrnz5/HgQMHkJaWBgDYvXs3RowYgY0bN8qOPzw8HCtWrEB8fDwKFSqEDh06oEGDBnByckJUVBT27duncRjf27dvY/To0eJws126dEGNGjVQqFAh3L9/H1u2bMGTJ08AAM+fP0f//v1x9uxZrVOMJCYmolmzZrh06ZK4ztnZGR06dIC3tzccHR0RFRWFAwcO4PTp02Ldvr6+uHz5MkqXLi3rfS9btgy//PILAKBcuXLo3LkzKlSoAIVCgfv37+P58+cat23evLn4PCYmBkFBQRqHSSYiIiLSRN92s2p5ABg2bFiOxJWZi4sLGjduDG9vbxQtWhS2trZ49eoVLl26hP/++w/v378HAJw7dw69evXC0aNHTTal3IwZM/Dff/+Jy66urujQoQOqV68OFxcXpKam4tWrVwgLC8OZM2fw6NEj2XXb29ujUaNGqFOnDtzd3WFvb4/Xr18jJCQEu3fvRlxcHIAPbeQOHTrg0qVLBk8BktPevHmDpk2b4vbt2+I6FxcX9OjRA9WrV4eFhQXCwsKwfft2xMTEAPgwzUmTJk0QHBwse+rGXbt2YcWKFRAEAcWLF0fXrl1RtWpVWFtb49GjRwgKCpKUj4yMROPGjfHw4UNxnbu7Ozp27Ihq1arBzs4OT548we7du8Wp3G7evCnmAuqmwBMEAb169cL9+/fFdRUqVEC7du1QsWJF2Nvb4927d3jx4gVCQ0MRGBgofpeqbG1txWliIiIikJSUBABwcHBA0aJF1b5/fae4lMvd3R29evXCH3/8AeDD9IAnTpxAjx49ZG1fsGBBfPHFF1i9ejUAICAgAA0aNNBYPmMKDODDlBjmxMLCAn5+fvj7778BfPid/Oabb0wcFRERkenom2O4ubnh7t27AIC4uDgEBQVpbRdk17FjxzB//nwolUq4urqiV69e8PLyglKpREhICHbs2CG2xW7cuIFWrVrh3LlzsqbAs7S0RP369VG/fn2UKVMGTk5OePfuHe7evYu9e/eKbcyEhAR069YNly5dQtWqVWXHPn78eOzatQsA4OXlhQ4dOqBMmTJISUnBrVu3JFOwHTp0CN9//724bG1tjbZt26JevXooVqwYFAoF4uLicPfuXQQHB+PKlSs6959b581NKa9eb1AoFKhVqxYaNGiAihUrwtnZGUlJSQgPD8fBgwdx/fp1AB/a7UOGDEHp0qXRokUL2Z9Ldq5lZMeYMWPE/QIfjmt9+Pv7Y+rUqUhPT8fhw4cRERGBEiVKqC37zz//iH/7VatWhY+PD27cuGFw7MbGa0JkdCbumEVERNmUmpoq2Nvbiz2nFy5caHBdw4YNk/TwXrFiheQOFltbW+H27dt61QktvegNcfz4ccndLZUqVRKuXLmituzTp08ldz7b2toKd+7c0Vj3rFmzhE6dOgknTpzQ2vs8PDxcaNiwoeS9HT9+XGvc6u5k+PTTT2UN1au6TcZ779OnjxAXF5elbGJiotC6dWvJNvv27dNaf+apFIcMGaK2bkEQhH///VcydWGLFi001qvpDu9Zs2bpPaqZIAiSKTjU3QlOREREpI0h7ebMU03k5JRRAQEBgq+vr7B3714hJSVFY7no6GihQ4cOkrh03QGrWtaYI0YlJiZKpqDu0KGD8ObNG631Xr58Wejfv7+Qlpamcb/e3t7C1q1btU7l8ebNG2HIkCGSGKdPn65136YcMWrQoEGSOtu1aye8evUqS7nXr19nuSu+V69eGuvNPCJAxmPYsGFCYmKi1pjS09OFFi1aiNsoFAph6tSpGqfKW716tWRqjUGDBqktl/nYmT17ttb8KjU1Vdi7d6/w/fffayzj6+sr1qduyhRtjPVdbt68WVLXiBEj1JZTN2KUIAhCcHCwuM7JyUnj8X3q1CmxnIuLi5CUlCQIgvmMGCUI0ru3bWxsZE+vSERElN8YkmOMGzdO0lb45JNPZI1+KlfmtkjG+eQ2bdqobX++ePFC8PPzk2wzdepUrftwd3cXlixZIrx48UJjmfT0dGHlypVCgQIFxHqbNm2qtV51o+haWVkJa9as0TgVdwbV9mL58uV1fqZPnz4VpkyZIgQFBWksk1PnzQXBfEaMykvXGwThw1SU06dPFx49eqS13Pbt2wUHBwex3rJly2rNSbJ7LcNYI0YJgpBl5F1No7ipGzFKEATJSF3z5s3TuJ/mzZuL5RYvXiwIgmBWI0YJAq8JkXGxYxQRUR539epVSePj0KFDBtf15s0boWzZsmobgACEpUuX6l2nMRv46enpQvny5SUneDVNX5AhLi5OclK4b9++GsvqczI3Pj5e0kDt0qWL1vKZO0ZVqFBB50WjDJm/hw4dOmhNBGNiYgRHR0exfJ8+fTSWDQwMlNT99ddf64zn33//lWxz9OhRteXUJRMTJ07U/YY1UG2oZ0wnQURERCSXvu3mpKQkSYf8nOhcoEqftmhKSorQqFEjMTZvb2+t5Q05WSnnxPqxY8ckFyx0tc3l0LeDRc+ePcUYihUrprVTmak6Rt24cUNSX4MGDcTOLuokJydLvl8AGi/YqOsY1bt3b1lxbdy4UbJdxslwbZYtWyaWVygUwr1797KUmTZtmlimVq1asmLRxRw6Rj18+FBSl4+Pj9pymjpGCYIg1KhRQ1y/efNmtdurXkgaOXKkuN6cOkapdt4CPky7QURE9DEy5Nx8WFhYlmntrK2thV69egl//fWX8OzZs2zFpK596O3trbWdnZCQIFSpUkUSj7Yp9fRps69atUoSS0hIiMay6jpGrV69Wuc+kpOTJR34d+3aJTs+TXLyvLkgmE/HqLx0vUEQ9Dv29u/fL6l39+7dGstm91qGMTtG9e/fX1LXwYMH1ZbT1DHqn3/+EddXrFhR7bbh4eGCQqEQc/mMTo7m1jGK14TImEwzzjoRERlN5iFfq1WrZnBd9vb2CAgIUDuNm6+vL0aPHm1w3cawa9cuPHjwQFz+9ddfUaRIEa3bODk5YeHCheLyjh078OrVK7Vl5QwPnMHR0RGTJ08Wl48cOQKlUil7+0WLFsHe3l52+QxWVlZYuXKlxqn2AKBIkSLo2rWruJx5ugxVS5YsEZ+XLl0aP/30k84YOnfujNatW4vLGdNB6FKsWDHMnDlTVll1qlevLj5XHYaXiIiISA59280vX76UtO/Kli2bI3Fl0KctWqBAAcyZM0dcvnr1KqKionIiLK1evHghPndxcdHZNpdDn88BAH744QfxeVRUlKwpMfR18uRJKBQKWY8xY8Zk2T5ze3nVqlWSaT8ys7a2xurVqyVt/lWrVsmK1draGsuWLZNVVjUX8PHxwfjx43VuM2rUKHzyyScAAEEQ8Ouvv2Ypo3pcVKpUSVYseYGnp6fkO3n58qXedQwcOFB8vn79+iyvv3nzBjt27BCXzW0avQyquRnA/IyIiD5ehpybr1q1qmTKN+DDdF/btm1D7969UbJkSXh4eKBjx46YN28eTp06heTk5GzFuXz5cq3tbAcHB0nbMCUlBZs2bdJYXp82+7BhwyS51IEDB2RvW6tWLVnTmb98+RLp6enisjHaoLl53tyU8tr1Bn2OvTZt2qBp06bisj7HXnavZWRHmTJlJMv65h0dOnSAm5sbAODevXvidIWqAgICIAgCAKBt27YoVqyYYcHmMF4TImNixygiojzu/v374vMCBQrA3d09W/X5+vqiS5cuknXaOkzlpi1btojPq1atKmksa9OtWzc4ODgAAJKTk3Hq1CmjxNOyZUvx+du3b3Hz5k1Z27m6uqJDhw4G7bNFixYoVaqUznI+Pj7i8wcPHiA1NTVLmfj4eOzbt09cHjlyJKytrWXFMWDAAPH5sWPHxEa0Nr1799b7Qpcq1ff96tUrcf5rIiIiIjn0bTdn7kxfuHDhnAjLYE2aNJF0rgkODs71GAoVKiQ+j46OltzEkFvKli2LcuXKicum+Bx02bNnj/jcx8cHtWvX1rlN9erVJSfxVdvt2rRp00bWSe0bN24gNDRUXB47dqys+hUKBfz9/cXlI0eOZCmjelxcunRJbS6SF1lYWMDR0VFcjo2N1buOvn37ijnXiRMn8OjRI8nr27ZtQ2JiIoAPFwK9vb0NDzgHFS5cWHKjj+rvKxER0cfE0HPzc+bMwZw5c2BlZaX29cjISOzZswdTp06Fr68vihUrhmHDhuHevXt6x/jJJ5+gSZMmOsu1adNGcv71v//+03tf6lhYWKBZs2bisj7tdX9/f1nXJFTbnwBw7tw5+QGqkdvnzU0pL19vkEP1Go4+x152r2Vkh7Ozs2RZ37yjQIEC6Nu3r7gcEBAgeV2pVGLDhg3isrnejAHwmhAZFztGERHlcU+ePBGfFytWDBYW2ftpv3v3bpae82lpaUhJSclWvcZw5swZ8Xm7du1kb2dlZSW5+KDtjgZ9ZE50IyIiZG1Xv359jUmvLqoJiDYlSpQQnwuCgPj4+Cxlzp07JxkFQZ/PtEGDBuLzuLg43LlzR+c2n376qez61VF9T4D02CciIiLSRd9285s3byTLhoz2mZOsrKwkIzTJbYsaU+ZOG506dTJJxyTVdnlOfA4FCxZE+fLlZT0y7szNEBkZKTn22rRpI3u/7du3F5+/fPlSVucTuW1u1buGLSwsZN90AkhzgbCwMLEjTwbV3Ovhw4fo3bs3nj17Jrt+c6b6O5CQkKD39kWKFBFvkhEEQXJBApCOImXOFygAaX7G3IyIiD5Whp6bVygUmDp1Km7evInBgweLN/VqEh8fjzVr1qBatWqYPn26Xp1GWrVqJTumzz//XFy+cuWKXjMkaGNoe11u27Zw4cKSUanGjh2LHTt2GBx/bp83N6W8fL1Bjpw+9nJC5nMPhuQdqrnEjh078PbtW3H56NGj4m9XsWLF9PqechuvCZExsWMUEVEep9pDWlcCpUt6ejr8/f3x/v17yfqkpCQMHDjQaImQIV68eCGZHkTfKQNV75rWdVI+JSUFe/bswbBhw9CwYUMUL14cdnZ2WabJKFCggGQ7ub3VK1SooFfsqooXLy6rXObGc+aLFQAQEhIiPi9QoIBeQwxnvgtdzoWO7LxvIOt74t0BREREpA99282Zy6ieSMxJSqUSx48fx6hRo9C0aVOUKFECDg4OsLCwyNIeVT2xa4q2kaenp6SjT1hYGOrXr48aNWrg+++/x8GDB9WeMJcrKCgIEyZMQMuWLVG6dGk4Ojqq/RzOnj0rbpMTn0ODBg1w//59WY8pU6ZItr17965kuWbNmrL3W6NGDa11qSO3za2aC5QuXVqvXFI1F0hPT0dkZKTk9a5du0o6iO3cuRNlypRBixYtsHDhQpw/f94sbrwxhGqHSScnJ4PqUL1IsXHjRvHC5u3bt3H+/HkAgI2NDfr06ZONSHOean7G3IyIiD5W2T03X7FiRaxduxZRUVHYv38/Jk2aBD8/vywjxmRITU3FnDlzMHjwYNn7yDwFrtyyb9++1XnO9+HDh1iwYAE6deqEihUrwsXFBQUKFMjSXp83b564jT7tBn3OJw8fPlx8npCQgJ49e6JUqVIYPnw4tm3bpldH/dw+b25KefV6Q2RkJJYvX44ePXrgk08+gaurK6ytrbMce0OHDhW3yaljz9gy36RlSN7h5eWFevXqAfjwt6w6XbfqzRj9+vUz+Cb+3MBrQmRM5nukExGRLKqdmLI7tOfixYtx4cIFcblKlSq4ffs2AOD8+fP46aefMH78+Gztw1CZpzIZMGCAZHhVfbx+/Vrja//++y9Gjx6Np0+f6l1vUlKSrHKq0y/oy9DvWN1dRKqfaWpqapaOXvrQ9plmyM77BrIOifzu3bts1UdEREQfF33bza6urpLl3DgBd+rUKXz11Veyp2hWJbctamxr166Fr6+vZDSj69ev4/r16/jhhx9gYWGBOnXqoF27dujXr59k2jtNrl+/juHDhxs0BYapPgdNMreTixYtKnvbzBcHjNnmVs0FHj16lK1p0zPHZW9vj7/++gudOnUSOxSmp6fj+PHjOH78OIAPbfvGjRujS5cu6N27t9lNVamOUqmUXKRwcXExqJ5WrVqhRIkSiIiIwKNHj3D8+HG0aNFCcoGiU6dOBtefW1TzM+ZmRET0sTLWuXlbW1u0adNGctPBgwcPcPz4cWzduhUnTpyQlA8ICECLFi1kdaTWp/2ZefTT169fo3Tp0lnKvXr1CmPHjsUff/yh95Rn+rTX9TmfPG7cOJw5c0YyjfXz58/x22+/4bfffgPwobNLq1at0LdvX60jJeX2eXNTymvXG969e4epU6fi559/Rlpaml515tSxZ2yZzz0YmhcMGjRIHNF5/fr1GDhwIF6/fo1du3ZJypgzXhMiY+KIUUREeZxqb259G4Kqbty4gRkzZojLtWvXxqVLlyQjM02bNs1kQ78a80KUpsbTypUr0bVrV7WdohwcHODh4YFy5cpJpspQJTcJNJce+LnxmarK7vvOPG95dhIrIiIi+vjo224uUqSIZCqMR48e5URYol27dqFly5ZqO0UVKlQI7u7uKFu2rKQtqvqe9L0gYSweHh64dOkSxo0bp/YueaVSieDgYMycOROVKlXCkCFDtE4FcOHCBTRu3Fhtp6iCBQuiePHiKFOmjORzUD2Zb6rPQZPMI41lPrGrjZ2dnda61JHb5s7pXKB58+a4fPkyunXrBktLS7XbHD58GF999RU8PT2xePFis/vuMgsPD5fEqDqVpT4sLS3Rv39/cTkgIABpaWn4448/xHXmfoECkOZnzM2IiOhjZaxz8+qUL18eQ4cOxfHjx3Hq1CmULFlS8vqcOXNk1WNrayt7n3LanzExMWjatCk2bdqUpf1maWmJokWLolSpUpL2uuoIWPq0+fQ5n2xpaYldu3Zh5cqVajtzAcD9+/excuVKNGzYEH5+fhqvdeT2efP8Iqc/t/fv36NNmzZYunRplr83CwsLFClSJMuxp0/HQFWmvIbz8OFDybKheccXX3wh/v2fOXMG9+7dw59//onk5GQAH6ZR/OSTT7IXbA7jNSEyJvO4MktERAZTHUoy8xR4cqWlpcHf31+czsDGxgabNm2CnZ0dNmzYAB8fH6SnpyMpKQkDBgzA2bNnZc+XbiyZLyC4u7vrdVFBlYeHR5Z1N2/exLfffisu29vbY8SIEWjfvj1q1aql9iKPIAi5/jkYk+rnZ2FhIZmHXV/ZncZRjszHd+ZEnYiIiEgbfdvNNjY2qFmzJq5evQrgQ8eomJiYLHdRG0NMTAwGDhwonvSzsrLCkCFD0L17d9SuXVvjVBqenp548uSJ0ePRl5OTE3788UfMmjULhw8fxvHjx3H27FmEhIRIpuNOT0/HunXrcPHiRZw5cybLXbhJSUno27ev2HFKoVCgd+/e6NOnD+rVq6fxpLavry9OnTqVc28wGzIP/a/PhZHM01Nkris7VHMBGxubLBfa9KHpLvNKlSrh77//xosXL7B//34EBgbi7NmzWU70JyQkYMKECQgLC8OGDRsMjiOnZUxzl6Fu3boG1zVo0CAsWLAAwIepBj///HO8ePECAFCyZEl89tlnhgeaS1R/R5mbERHRx8oY5+blaNKkCQ4cOABvb2+xQ8idO3fw4MGDLDfvZqZPXHLan2PGjJHczNGwYUN89dVXaNy4MUqXLq22U/yMGTMwe/Zs2XEYysLCAiNGjMDw4cNx+vRpHD16FGfOnEFQUFCWz+HkyZOoX78+Tp8+nWUK67x23txc5PTnNnfuXEneV61aNXzzzTfw8/NDuXLl1HaaCQgIyBM3HahSzTsUCgXq1KljUD1OTk7o1q0bNm/eDODDZ3HgwAHx9bzwufCaEBkTO0YREeVxqnNAx8TEGFTHvHnzcOXKFXF55syZ4khRdevWxcSJEzF//nwAH+7gXrJkCb777rtsRK2/zL3ily5dil69ehmt/p9//lm8EGVra4szZ86gZs2aWrfJ6/MZq36m1tbWkulPzFF0dLRk2d3d3USREBERUV5kSLvZ19dX7BgFAMeOHUPv3r2NHtv69evFtqWFhQX27t2LVq1a6dwuJ9ujhtzZbGdnhy5duqBLly4APsR39OhR/PXXX9i1axfS09MBfJgqb86cOVi8eLFk+927d+PBgwfi8m+//YahQ4fq3K85t8szd2rL3KbVJnNZTR3kDKGaC5QtWxa3bt0yWt2ZFS9eHIMGDRJPvD99+hT79u3Dxo0bJVO5b9y4ET169EC7du1yLJbsOHjwoGTZz8/P4LoqVKiApk2b4tSpU3j//j1Gjhwpvubv758nbsBRPT6ZmxER0cfKGOfm5fLy8kLr1q2xd+9ecd3t27d1dozSp/2Z+T1kbn++ePECW7duFZf79u2LjRs36my75HZ73cLCAr6+vvD19QUApKSk4OzZs/jnn3/wxx9/iDdiJCQkYPDgweJ0Yxny2nlzc5GTn1tqaipWrlwpLjdv3hz79++HjY2N1u3MOVdU5969e5Kc2MvLC66urgbXN2jQILFj1C+//CJODV6oUCGjXl/LKbwmRMZk/lk2ERFppdrrPj4+Xtb0CqquXLmCefPmicsNGjTI0ulpxowZ8PLyEpenT5+O27dvGxixYTw8PCR3lD979syo9R87dkx83r9/f52dooCsQ5rmNVWqVBGfJyUlSeYAN0cRERHicysrK5QoUcKE0RAREVFeY0i7uX379pLlNWvWGD0uQNoW/eyzz2R1inr58qXWKelUqd65K7fDU1RUlKxy2hQuXBjdu3fH33//jbNnz0qm8cg4OatK9XOoXLmyrE5RSqUyx6c5zI5KlSpJlkNCQmRvGxoaqrWu7FDNBZ4/fy4Z2SunlSpVCsOHD8f58+exfPlyyWvqjgtz8Pz5c2zfvl1ctrGxyVbHKEB6h3bGBQqFQoGBAwdmq97ckJ6eLvmN8PT0NGE0REREppPdc/P6yriZWXWfuly/fl12/Tdu3BCf29nZZTn/evz4cXEqPIVCgYULF8rq0G3q8+jW1tZo1qwZfvnlF9y7dw+VK1cWX7t06VKWKfXy2nlzc5GTn1twcLDkeJ83b57OTlGA6Y89fS1btkyyLOfcgDYZo2kB/5dzAEC3bt2yjOBsjnhNiIyJHaOIiPI41Q5LwIce5XKlpKTA399fHCmpYMGC2LhxY5bhbq2trbFhwwZxXuWMKfUy7vjODZaWlmjSpIm4fOLECaPWr9rAktMpCpBeuMmL/Pz8oFAoxGVjf6bGdvfuXfF5lSpVTDrPNxEREeU9hrSbW7RoAW9vb3H5xIkTOHnypNFjM6Qtevz4cdn1Fy5cWO2+tFEdyccYGjRogC+//FJcfvHiBV6/fi0pY8jncOnSJdkdxEzB3d0dpUuXFpdVpy7QRXU0gCJFiqBChQpGi6tZs2bi84SEBMkIwrlp1KhRku9adVoWVarTYuRmJ64M48aNE/NmABgyZAhcXFyyVWePHj2yTBHStGlTnaM+mIP79+9Lvofq1aubMBoiIiLTyc65eUMkJSVJluW0Rw4fPiyrbkEQJGVr166d5TqBanvdzc0NHh4eOutNTk7GmTNnZMWQG4oWLYoffvhBsi5zGzSvnTc3Fzn5uWXOY/PjNZxr165h/fr14rKNjQ3GjBmTrToVCgUGDBiQZX1emEYP4DUhMi52jCIiyuPq1q0rWc58V7E2M2bMkNwFMn/+fMndEqrq1KmDSZMmictBQUFYsmSJntFmj+q0JQcPHsxyJ0d2ZNzpAmRNMNVJSUnB6tWrjbZ/U3Bzc0Pz5s3F5cx3I5gb1WO7Xr16JoyEiIiI8iJD282TJ0+WLPv7+xs8HH9qaqraUaf0bYsCyDLSjjaqd+7K6fCUmJiIHTt2yK5frsy5hmpHE8Cwz8Hc27AA0KFDB/H5hQsXcO3aNZ3bhIWF4dSpU+KysaeXq127NipWrCgum/JzVD0uMh8TGezt7cXnckZGMKa5c+fir7/+EpcLFiyI77//Ptv1FipUCN988w1q1qwpPlSn1DNnmX8/mZ8REdHHKjvn5g1x9uxZybKcjvM3b97Msp06Bw8exJMnT8TlTp06ZSmj2l5PTk7WWSfwYbpkc5vOTFdektfOm5uLnPzcVI89QF6+ePjw4RydMtyYnjx5gq5du0re19ChQ40yQtKAAQNQq1YtMedo2bKlOM2kueM1ITImdowiIsrjihQpIhlC9+LFi7K2CwoKwuLFi8Xlxo0bY/To0Vq3mT59OmrUqCFZzs2GZe/evcXhidPT0/G///1P7+GJNTWYVYf+V70zW5MJEyaY9ZQdcqle6Dt79iwWLFigdx1yL1plR0JCgqQjXHanrSAiIqKPj6Ht5u7du6NPnz7i8uPHj+Hr64vIyEi99v/o0SM0a9YMq1atyvKaalv0wIEDOkdmXbZsGc6dOyd73w0aNBCfnzx5Uued7BMnTswympM6z54902sUWdVp5Ozs7ODm5iZ5XfVzOHXqlM6RoHbt2oWtW7fK3r+pfPXVV5Llr7/+GikpKRrLp6amYsSIEZIReUaMGGHUmCwsLCQ3vmzZsgVbtmzRux51uYA+eZIgCJLpXcqUKaO2nOp61Zt7clJERAS6d++OadOmiesUCgXWr19vtCkc5s2bh2vXromP7t27G6XenBYcHCw+L1u2rGRUNCIioo+JITnGxIkT9Rr9NcO2bdtw6dIlcbly5cqyRxQdPXq01o5MiYmJGD9+vLhsbW2N/v37Zymn2l6Pj4/H6dOnte43PDwcEydOlBVjdsTGxkqmCdMl8/TW6tqgeeW8ubnJqc8t89TNuq7hvH79GsOHD9d737lNqVRi27ZtqFWrFsLDw8X1derUyTKymaFKlSqFq1evijnHkSNHJCN7mSteEyJjY8coIqJ8oG3btuJzOcOTvn//Hv7+/uJFDDs7O2zYsEHnfOAFChSQTKmXnJyMgQMH5tqUelZWVli7dq04hO+VK1fQoEEDWReFQkNDMWnSJI3TEqjO1Xz8+HHMnz9fbbnExER88803WL58uaz5081d8+bNJUOpTp48GV9++SWio6O1bpeUlIS9e/eiY8eOGDduXA5HCZw+fVo8zhQKRbbn1iYiIqKPk77t5gy//fabZKqo0NBQ1KxZEytWrNB5p3R4eDhGjhyJypUra7xTW7Vtc+/ePXzzzTdIS0vLUi41NRXz5s3D2LFjAUB2e/R///uf+DzjBoPY2Ngs5ZKTk/Hdd99h5cqVsk6Url27FpUrV8by5cvx4sULrWW3b9+OdevWicsdO3bMsg/VzyEuLg79+/fHu3fvstQlCALWrl2LXr16AZD/OZhKtWrVMHjwYHH53Llz6NGjh9rOZ/Hx8ejdu7dktKjevXujfv36Ro/L398fLVu2BPDhM+3Xrx+mTp2qs0PamzdvsG3bNvj5+akduWzgwIHw9fXFtm3b1H5/GdLS0jB+/HjJzTadO3dWW9bHx0d8/vDhQyxdulTt30h2KJVK3LlzB5s2bUKvXr1QpkwZ/PPPP5IyCxcuxBdffGHU/eZFqr+fbdq0MWEkREREpqdvjnH27Fm0aNECDRs2xJo1a3SOppSamoqlS5eiX79+kvVyR7C0sLDA5cuX0b17d7Xtz5iYGHTq1EkyndyECROy3MQAfDiXrDqV1aBBgzR2ij979iyaNm2KuLi4HG+vh4aGonTp0pg0aRLCwsK0lr1+/bqkE1iJEiWyjPwF5J3z5uYmpz63OnXqwNXVVVweN26cxpF4w8LC0LRpU4SHh5tlrhgfH49jx45hzpw5qFixInr37i352yxfvjz27t0LOzs7E0ZperwmRMbGiRiJiPKBbt26iaM/3bp1C0+ePNF6x+bkyZMlPa0XLlyoscNQZt7e3pg8eTJmz54N4MPIUz/++KOsOz+CgoJk38Wi6v79++Lz5s2bY9myZRg1ahQEQcDNmzfRqFEj1KpVC82aNUO5cuXg4OCAxMREvHz5Ejdu3EBQUJA4DLCNjY3afXz77bf47bffxLsRpkyZgh07dqBLly4oVaoU3r17hxs3bmDnzp1iI37u3LlZplbJi1avXo0HDx6Id/j8/vvv2LRpEz777DM0aNAARYsWRYECBRAfH4+nT58iJCQEFy5cQGJiIgBg2LBhOR7joUOHxOeNGzdGsWLFcnyfRERElP/o227OYGdnh1OnTqFHjx44evQogA8XEEaPHo3JkyejWbNmqFOnDooUKYJChQohOjoaEREROHHihM4T8wAwePBgLFiwQGxnrl69GkePHkWPHj1Qvnx5JCcn4+7du/j333/x+PFjAMCXX36JQ4cOicvaeHl5oVu3bmInj0uXLqFKlSro27cvPvnkE6SlpeHOnTv4559/8OzZM1hZWUna/No8ePAAY8aMwdixY1G3bl3Ur18f5cqVg7OzM1JTU/Ho0SMcPnxYcne7nZ0d5s6dm6Wujh07olq1auJntnv3bvFE8SeffAKlUonw8HDs3r1b7EzTunVrJCYm6rxb3dSWLl2Ks2fP4vbt2wCA//77DxUrVkTPnj1RvXp1KBQKhIWFYdu2bYiJiRG3K1euHFauXJkjMVlaWuKvv/5CkyZNcOvWLSiVSsybNw8rVqxAq1atxGNaoVAgPj4e4eHhCAkJQVBQkDjiVevWrbPUKwgCTp06hVOnTsHOzg4NGzZE3bp14eHhAUdHRyQmJuL27dv477//JMdvzZo1MXDgQLWxduzYEUWKFMHLly8BAGPHjsXUqVPh6ekJa2trsdzw4cO13hmuLidNS0tDfHw8EhISJKN0qXJ3d8fKlSvRpUsXjXWbq4iICIPy8JMnT6odGSsmJgZXr14Vl7t165at+IiIiPI6Q3OMCxcu4MKFCxg5ciRq1qyJBg0awNPTEy4uLgCAV69e4fr16zhw4ABevXol2bZHjx7w9/eXFd/kyZMxf/587N27F5UqVUKvXr3g5eUFQRAQEhKCbdu2STpneXt7Y8qUKWrrcnNzw9ChQ7F69WoAH87bV6tWDT179kS9evVQsGBBREZG4ujRowgMDAQAlCxZEh06dBC3ySlxcXFYuHAhFi5ciEqVKsHHxwfVqlWDi4sLLCws8OLFC5w7dw4HDx6U3Oj9008/aew8k1vnzY1x3cSc5MTnZmVlhQkTJojXoWJiYlC/fn107twZjRs3hoODA2JiYnDq1CnxO3Z0dMRXX32FhQsX5t6b///69OkDW1tbybrExETExcVpHUmsd+/eWLVqFZydnXM6RKObOHGi2jxfm27dumn8fnhNiIxOICKifKFSpUoCAAGAsHTpUo3lTp48KSgUCrFs8+bNBaVSqde+UlJShJo1a4p12NjYCDdv3lRbNqNMdh7q7Ny5U3B0dNS7rkKFCml8X3/99ZdgZWUlq57hw4dneX8BAQEa6/b09BTLzZgxQ/Znrc8+VJ04cUKyXXh4uNbyycnJwuDBgw36fkaMGGGUGDRRKpVCiRIlxHrWrFljUD1EREREgiC/3axOamqqMGPGDMHBwcGgdlOLFi2EK1euqK371KlTQqFChWTV07FjRyE5OVmvNuaLFy+EKlWq6Kzb2tpa2Lhxo6y23IwZM/T+DFxcXITTp09rjPPWrVuCm5ubrLoaNmwoxMbGCr6+vuI6f39/jXWrxuvp6an181Ldj6+vr9ayckVHRwu1a9eW/Vl5eXkJERERWusMDw+XbHPixAm944qLixPat29v0DG9aNGiLPWpfh9yHzVr1hSeP3+uNc4DBw4I9vb2WutR93dgyPvKeFSqVEn48ccfhTdv3sj+PDN/Jz///LPsbbXp1q2b7ONX9bfB0Iem/O23334Ty5QqVUpIT083yvsjIiLKy/TJMT777DOD/z9bWFgI33zzjZCamqqxfnXtw6VLlwoWFhY6669WrZoQHR2tNf7ExEShQYMGsuL18PAQLl++LLsdHhAQINlersy5i5yHpaWlsGLFCp1158R5c0Ew/nUTfc7Fq5bLS9cb0tLShE6dOsmqw8nJSTh48KDsYyq71zIMyY0zHgULFhR69uwpXLhwQa99+vv7i3W4urrqta0m169fl318ZP5sDXloyt95TYhygvmNH0dERAYZOnSo+Hzr1q1qyyQmJmLgwIEQBAEA4ODggPXr1+s9n3CBAgWwceNGFChQAMCHKTdUp+bLDV26dMHDhw/x/fffo3jx4lrLFihQAI0aNcLChQtx9+5djeV69eqFEydOoE6dOhrLVK9eHTt27MjxO1xym7W1NdauXYugoCB07NhR48haGVxdXdGjRw/8/fffWLp0aY7GdurUKURERAAAHB0dxSlTiIiIiAwhp92siZWVFWbOnInw8HBMnToVNWrU0NmWdnV1xZdffolz587h6NGj8Pb2VluuSZMmuHjxIpo1a6axrvLly2P16tXYvXu3ZJQcOYoVK4bTp0/D399f4x3RjRs3xvnz59G/f39Zdfbr1w/Tp09HvXr1JFNqqOPs7IyRI0fi9u3baNy4scZyVapUwZUrV9ClSxeNn627uzvmzJmDU6dO5ak7ad3c3BAUFITly5ejVKlSGsu5u7tj0aJFuHz5Mjw8PHI8LicnJ+zZsweHDh1Cs2bNdH6XHh4e8Pf3x8GDB8VpHVXNnTsXX3/9NSpVqqRz3+XKlcPixYsRHBwMd3d3rWVbt26NsLAwTJ06FY0aNYKbm5vefwfqFChQAI6OjihbtiwaN26MQYMG4ZdffsGNGzdw584djBs3Dvb29tneT36h+rs5ePBgs5yehIiIKLfpk2McOHAAgYGBGDduHOrUqQNLS0ud9Ts5OWHQoEG4dOkSVqxYobO9ltmYMWNw6NAh1KpVS+3rdnZ2GD9+PIKDg9VOoaeqUKFCCAwMxPjx41GoUCGN9Q0cOBChoaGoXbu2XrEawtvbG8uXL0erVq10ttusra3RpUsXXLlyBd98843Ous35vLk5y4nPzdLSEjt37sSCBQvEkdXU7bdr164ICQkxq6nXLCwsULBgQRQrVgzVq1dHx44d8f3332PPnj2IiYnBtm3b0KBBA1OHaTZ4TYhygkLIuDpORER5Wnx8PEqWLIm3b98CAK5du4aaNWuaOKrcc+PGDYSGhiImJgZv3ryBnZ0dihQpgkqVKsHLy0vv+ZjDwsIQFBSE6Oho2NjYwN3dHTVq1EDVqlVz6B2Yl/fv3+PcuXN4/PgxXr58ifT0dDg4OKBkyZL45JNPUKlSJb071Bmqb9+++PPPPwF8mPLwp59+ypX9EhERUf5k7HZzVFQULl++jOjoaLx8+RKpqakoXLgwihYtilq1asmeslrVgwcPcPbsWURGRsLS0hLu7u6oUqWK1g78+nj58iVOnDiBp0+fIi0tDSVLlkS9evVQsWJFg+t8//49QkJC8ODBA0RFReHdu3coWLAgXF1d4eXlhZo1a+rdiSUiIgKnT5/Gs2fPoFQqUaxYMZQvXx6ffvppvuiMce3aNYSEhIhTKLq5uaF69eqoXbt2rrW11UlISMDZs2fx7NkzcdoWR0dHeHp6omrVqihbtqzsul6+fInr16/j4cOHiI2NRXJyMuzs7FC8eHF4e3ujSpUqOfU2KAfcu3dP7PBWsGBBPH78GEWLFjVxVERERKaXnRwjY5rh+/fvIyoqCm/fvoWFhQUcHBzE9mGlSpVkdaACgEePHknaaydOnICfn5+4fP36dYSEhOD58+coWLAgypQpg5YtW2rs5KRNQkICTp8+jXv37uHdu3dwc3NDyZIl4evra1B9xpCeno6bN2/i7t27iIiIED/PwoULo1KlSqhTpw6cnJwMrt+czpvnJcb+3N6/f4+zZ8/i1q1bSEhIgKurKzw8PNC0aVMULlw4594I5QpeE6KcwI5RRET5yIQJE8T5zIcOHYo1a9aYOCKi7ImOjoanpyeSkpJgY2ODe/fuab27noiIiEgOtpuJiPQ3duxY8Q7+r776CqtWrTJxRERERObDXHIMXR2jiIjMGa8JUU7J+7fXERGRaMKECXBwcAAAbNq0CZGRkSaOiCh7li1bhqSkJADAsGHD2AAmIiIio2C7mYhIP7Gxsfj9998BfBgtaurUqSaOiIiIyLwwxyAiyj5eE6Kcwo5RRET5SJEiRTBhwgQAQHJyMn788UcTR0RkuNevX4t3IDs6OmLy5MkmjoiIiIjyC7abiYj0s3z5cnF6oNGjR8PDw8PEEREREZkX5hhERNnDa0KUk9gxiogonxk/fjzKlSsHAFi5ciUeP35s4oiIDLNgwQLEx8cDAGbNmoVixYqZOCIiIiLKT9huJiKSJzo6Gj/99BMAoESJEhwtioiISAPmGEREhuM1IcpJVqYOgIiIjKtgwYLYvHkzDh06BAAIDw+Hp6eniaMi0o8gCHB1dcWMGTNgbW2NkSNHmjokIiIiymfYbiYikufhw4cYN24cAKBZs2awt7c3cURERETmiTkGEZFheE2IcppCEATB1EEQEREREREREREREREREZHhHj16hLJly4rLJ06cgJ+fn+kCIiIiMgOcSo+IiIiIiIiIiIiIiIiIiIiIiPIdjhhFRERERERERERERERERERERET5DkeMIiIiIiIiIiIiIiIiIiIiIiKifIcdo4iIiIiIiIiIiIiIiIiIiIiIKN9hxygiIiIiIiIiIiIiIiIiIiIiIsp32DGKiIiIiIiIiIiIiIiIiIiIiIjyHXaMIiIiIiIiIiIiIiIiIiIiIiKifIcdo4iIiIiIiIiIiIiIiIiIiIiIKN9hxygiIiIiIiIiIiIiIiIiIiIiIsp32DGKiIiIiIiIiIiIiIiIiIiIiIjyHXaMIiIiIiIiIiIiIiIiIiIiIiKifIcdo4iIiIiIiIiIiIiIiIiIiIiIKN9hxygiIiIiIiIiIiIiIiIiIiIiIsp32DGKiIiIiIiIiIiIiIiIiIiIiIjyHXaMIiIiIiIiIiIiIiIiIiIiIiKifIcdo4iIiIiIiIiIiIiIiIiIiIiIKN+xMnUARNmRlJSEBw8eiMvly5dHwYIFTRgRERERERHlB8w1iIiIiIjI2JhnEBEREeU+doyiPO3Bgwfw8vISl2/cuIFq1aqZMCIiIiIiIsoPmGsQEREREZGxMc8gIiIiyn2cSo+IiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiIiIiIiIiIiIiIiIgo32HHKCIiIiIiIiIiIiIiIiIiIiIiynfYMYqIiIiIiIiIiIiIiIiIiIiIiPIddowiIiIiIiIiIiIiIiIiIiIiIqJ8hx2jiIiIiIiMRKlUYtmyZXj//r2pQyEiIiIionwkMTERy5cvh1KpNHUoRERERESUjzx//hwBAQGmDiNHsWMUEREREZERCIKAUaNG4dtvv0XHjh0hCIKpQyIiIiIionwgJSUF3bt3x5gxYzB69GhTh0NERERERPnEq1ev8Pnnn2PQoEFYuXKlqcPJMewYRURERERkBNOnT8fKlSuhUCgwaNAgKBQKU4dERERERER5XHp6Ovr164eDBw+iUKFC+N///mfqkIiIiIiIKB948+YN2rRpg7CwMHh4eKBt27amDinHsGMUEREREVE2/fTTT5g7dy4AYOXKlfjiiy9MHBEREREREeV1giBgxIgR2L59OwoUKIB///0XDRs2NHVYRERERESUx71//x4dO3ZEcHAwXF1dceTIEZQtW9bUYeUYK1MHQPQxSElJQXBwMJ49e4aXL18iLi4O9vb2cHZ2RuXKlVGzZk0ULFjQ1GF+VBITE3Hq1Ck8ffoUsbGxcHNzQ5kyZdC0aVMUKFAgV2N59+4drly5gtu3b+P169dIS0uDk5MTypQpg7p166Jo0aLZqj8+Ph6XL1/GvXv3EBcXB0EQULhwYVSoUAF16tSBs7Ozkd4JEdHHKSAgAOPGjQMAzJs3D1999ZWJIyKijwXzDPNjTnlGUlISzp07hwcPHuDly5dwcHCAh4cHfHx84OHhka26nzx5ghs3biA8PBzx8fGwsbGBs7MzqlWrBm9vb1hbWxvpXRARfdwmT56MNWvWwMLCAlu2bMHnn39u6pCI6CPBXMP8fCy5BhER5bzU1FT06tULgYGBcHBwwMGDB1G1alVTh5Wj2DGKKIcIgoDt27djw4YNOHXqFN69e6exrJWVFRo3box+/fqhZ8+esLe3z8VIPy4vX77ExIkTsW3bNiQmJmZ53cXFBQMGDMCcOXNQqFChHI3lzp07mDt3Lv7++28kJSVpLOfr64vx48ejffv2etV/8eJFzJ8/H/v27UNaWpraMpaWlmjdujW+//57NGrUSK/6iYgI+PfffzFkyBAAwLhx4/D999+bOCIiyu+YZ5gnc8oznjx5gjlz5mDz5s1q8wwLCws0adIE8+bNk50DJCcn4+DBg9i1axeOHTuGp0+faixbqFAh9OnTB9999x0qVqxo8PsgIvrYLVq0CD/88AMA4LfffkP37t1NHBER5XfMNcxTfs81AKBMmTJ4/Pix3vF8/fXX+OWXX/TejojoY6ZUKjFgwADs2bMHBQsWxJ49e1C3bl1Th5XzBKI87MaNGwIA8XHjxg1ThyQIgiAcPXpUqF69uiQ2uY+iRYsKv/zyi5Cammrqt5HvnD17VihevLis76FixYrCnTt3ciyWNWvWCDY2NnodG/3795d9XMycOVOwsLCQXbdCoRAmTZqUY++XiCg/OnLkiGBtbS0AEAYPHiwolUpTh0RERmSOuQbzDPNkTnnGrl27BAcHB1mxWFhYCFOnTpVVb4kSJfQ+5mxtbYXVq1fn2HslIsrP1qxZI/6eLl682NThEJERmWOeIQjMNczVx5BrCIIgeHp6GnTsff311zn2fomI8iOlUil89dVXAgDByspK2Lt3r6lDyjUcMYrIyFasWIGxY8ciPT1dXKdQKFCjRg00a9YMHh4ecHV1RUJCAqKionD16lUEBgYiOTkZABAdHY2RI0eiUaNGqFWrloneRf5z7949dOzYEa9evRLX1a5dG127dkWxYsXw5MkTbN26Fffv3xfLt23bFhcuXECRIkWMGsu2bdswbNgwCIIgrqtSpQo6duyI8uXLw8rKCs+ePcPRo0dx+vRpscymTZtQoEABrF27Vmv9ixYtwsyZMyXr6tatizZt2qB06dIQBAGPHz/GgQMHcOXKFQCAIAj44Ycf/h979x0eVZX+Afx765SEBJAiNkDsDdcOoq4rQYogSLOgIMq6dv2ha8OCq6uuCq4FRQVRRECQIkUg6OpiQWwri4orIKIgHVKm3Hp+f9yZSyaNSWMS8v08Dw+54d4z7wTLOXPe877IysrCqFGjau/NEhHtpz7//HP07dsXpmmif//+GD9+PCRJynRYRLQf4zqjfqpP64z33nsPl1xyCVzX9b93wgknoF+/fmjbti0ikQg+//xzvPPOOzAMA67r4pFHHkE4HN5rxcPi4uKU64MPPhjnnHMOTjrpJLRs2RKWZeHHH3/ErFmz/GpSsVgM119/PSzLws0331yr75WIaH/29ttv47rrrgMA3HPPPbjjjjsyHBER7e+41qifGstao7RmzZqhefPmad3bsmXLKo1NRNTY3XfffXjxxRchSRImT56MXr16ZTqkfSfDiVlENVLfTlc8/PDDZarwXH755WLt2rWVPldcXCwmTJggDjvsMP/Zb775Zt8E3UicfvrpKX8vTz31VJl7HMcRt9xyS8rf4cCBA2s1juLiYtGqVauUWJ5++ukKq4wsWbJE5OTkpMT08ccfVzj+hg0bRDAY9O/VdV1MnTq1wvsnT54sNE1LuX/dunU1fp9ERPuz//73v6JZs2YCgOjatauIx+OZDomI6kB9WmtwnVF/1Zd1xtatW0XTpk1TYhkzZky564w1a9aIY489NuXeTz/9tNLxc3NzRSAQENdcc02l6xHTNMWDDz6Y8l41TRM//PBDjd8jEVFjsGjRIv9zmuuuu45VaYn2Q/VpnSEE1xr1WWNZawiRWjHqwQcfrNX4iYjI8/jjj/v/rR0/fnymw9nnmBhFDVp9WkQsXrw4pXWZruvi7bffrtIYhmGIBx98UMiyzEVELZoxY0bKPyd/+ctfKr3/wgsvTJm4f/HFF7UWy9tvv50Sy80331zlZ6677roK7/3HP/6Rcu/TTz+91/FLP/PYY49V6T0RETUm69atE23atBEAxJlnnimKiooyHRIR1ZH6stbgOqP+qk/rjL/+9a8pseytbcWvv/6asrlx9tln73X8X3/9Ne147rnnnpR4rr766rSfJSJqrD755BMRDocFADF48GBh23amQyKiOlBf1hlCcK1RnzWmtYYQTIwiIqprL730kv/f2X/84x+ZDicjJCFK9HIiamC+++47nHDCCf71qlWrcPzxx+/zOKLRKNq3b4+tW7f635sxYwYGDBhQrfEWLVqEI488Eh06dNjrvZZl4dNPP8XatWuxdetWhEIhtG7dGmeddRbatWtXrdcvz5dffokff/wRv//+O4QQ6NKlCzp16rTX51zXxaeffop169bh999/h6Zp6NatW8rfW107++yz8emnnwIAQqEQNm7ciGbNmlV4/w8//IDjjjvOvx4yZAgmT55cK7HcfffdeOKJJ/zr7777LuW1yiOEQOvWrbFt2zYAwJlnnonly5eXe++ll16K6dOnAwAURcHOnTuRk5NT6fgFBQU44IAD/FLJgwcPxrRp09J+T0REjcXvv/+OLl26YN26dTjhhBPw0UcfpV3am4ganvqw1uA6o2JcZ6Q66KCD8PvvvwPwWk9s3LgRoVCo0mcefvhhPPjgg/71J598gs6dO9dKPPF4HAceeCAKCgoAeC0uSv5zTEREqVauXInzzjsPu3fvRo8ePTBnzhzoup7psIioDtSHdQbAtUZluNZItS/WGu3atcMvv/wCAHjwwQfx0EMP1TxwIiICAEydOhVXXHEFhBC499578eijj2Y6pMzIYFIWUY3Vl9MVzzzzTEocV155ZZ2/5o4dO8Qtt9xSps1ayV8dO3YUc+bMSWu81157LeXZpBdffFEcfvjhZcYeOnSof0/JVglt27YVQghhWZZ45JFH/KoaJX/ty4z/33//PeXUS7p/N126dPGfadq0qTBNs1biufbaa1N+FoZhpPXcWWed5T9z5JFHVnhf165d/fvatGmTdlwHHnig/1xeXl7azxERNRY7duwQJ554ogAgDj/8cLFp06ZMh0REdaw+rDW4zuA6Ix0//PBDys9hyJAh1Xru//7v/2ocS0k9e/ZMGb+wsLBWxyci2l/89NNPonXr1n5VjUgkkumQiKgO1Yd1hhBca3CtkZ59tdZgxSgioroxb948oaqqACBuuOGGRt2qWwYR1YjruhgzZox/LUlSnWezr1ixAkcffTSeffZZFBYWVnjft99+i759++Kyyy6DZVlVeg3bttGvXz9cf/31WLduXZWeLSwsxLnnnotRo0b5JwkqM2zYMEiS5P/68MMPq/R6lXnvvffguq5/3a1bt7Sey8vL87/evXs3Pvnkk1qJp3RlkUgkktZzJe9r1apVWuOnO3ZVxiciaowikQh69eqF//73v2jTpg3y8/PRpk2bTIdFlLbvvvsOU6dOxdNPP41nnnkGM2bMwM8//5yxeIqKirB48WK89tpreOyxx/CPf/wDEydOxLJly6o0f9nfcZ1RFtcZ5Sv97/NJJ52U1nNHH300AoGAf/3uu+/WOJaSsrOzU6757zcRUVkbN25EXl4etmzZgo4dO2L+/PkIh8OZDouI9nNca5TFtUb56utag4iI9u7DDz/EwIEDYds2hgwZgueeew6SJGU6rIxRMx0AUUP33//+Fxs2bPCv8/LycPjhh9fZ633zzTe44IILUFxc7H/viCOOwIABA3D44YejuLgYn3/+OebMmQPDMAAA06ZNQzwex+zZs9N+nTvuuANz5swBAJxwwgno3bs32rVrB9M08cMPP6RMaksbNmwYPvvsMwBe27cePXrg4IMPRiQSwX/+8x9kZWVV451Xz7fffptyfdZZZ6X1XOmyritXrsQf//jHGsdTetz3339/r+WJN2/ejO+//96/Pvfccysd/+233wbgLea+/PJLnHbaaZWO/8UXX6CoqCit8YmIGhvDMNCvXz8sX74czZo1w5IlS+r0//NEtWnmzJn429/+hpUrV5b75507d8ajjz5aK3OcdCxfvhyPPfYYlixZgng8Xu49iqLgrLPOwqOPPorzzjtvn8RVX3GdURbXGeXbtWtXynVlLTZKkiQJubm5fvuUtWvXori4uExCU3WV3ESRZRktW7aslXGJiPYXO3bsQLdu3bB+/XocccQRWLx4MZo2bZrpsIioEeBaoyyuNcpXX9caRERUuS+++AK9e/dGPB5Hnz59MHHiRMhy466ZxMQoohr66KOPUq4vuOCCOnstwzAwZMiQlAXEqFGj8OCDD0JVU/91Xr16Nfr164fVq1cDAObMmYOXXnoJf/nLX9J6rX/+859QVRXjxo3Dtddem3YG6S+//IJffvkF2dnZmDJlCvr06ZPmu6sbP/zwg/+1oiho3759Ws+V7oVeMjGpJnr16oX27dv7mwSjRo3CBRdcUOGCwnVd3HzzzXAcBwCQlZWF66+/vsLxr7zySjz44IMoKCgAAPzf//0f8vPzK1z0xeNx3Hbbbf71QQcdhCuuuKI6b42IaL/jOA6GDBmC/Px8ZGVlYeHChTjhhBMyHRbRXjmOg2uvvRaTJk2q9L5PP/0UF1xwAe677z48/PDDdRZPcr7x8ssvQwhR6b2O4+CTTz7BF1980egTo7jOSMV1RsVCoVDKdSwWS/vZkvcKIfDDDz/g9NNPr3FMGzZswFdffeVfn3HGGVAUpcbjEhHtL4qKitCzZ098//33OPjgg7F06VK0bt0602ERUSPBtUYqrjUqlom1xuLFi/HJJ59g1apV2LlzJ4LBIA444ACceOKJOO+88zBkyBB2vSAiqsR3332H7t27o7i4GOeffz6mT58OTdMyHVbGNe60MKJasGLFipTrM844o85ea8KECSmT2VtvvRV/+9vfyiwgAOCYY47BkiVLcMABB/jfu++++yo8nV+e5557DiNGjKhWWb0ZM2ZkfAEBIKVk7kEHHZT2h/GHHHJISuZsVUvvVkRVVUyePNlfUPz44484/fTT8fbbb6e0lrBtGx999BEuuOACzJw5E4B3yvrVV1/FoYceWuH4zZs3x6uvvurHvmzZMnTu3Bnvvfeef9oG8DYoFyxYgE6dOuHTTz8F4C1ypk6duk9PvxAR1VdCCFx33XWYOXMmdF3HnDlz0j6hR5Rpt99+e0pSVDgcxogRI/DCCy9g7NixuPTSS/3FsOu6+Nvf/oaxY8fWSSzxeBx9+/bF+PHj/aSoJk2aoH///vj73/+OV199FS+++CJGjRqFnj17ch5SAtcZ5eM6o6zSlZjSbZW5ffv2lMqxgHeSuzY89dRTKe0/Bg0aVCvjEhHtD5LzoxUrVuCAAw5Afn4+2rZtm+mwiKgR4VqjfFxrlJWJtcby5cuxdOlSbN68GaZporCwED///DPeffddjBw5Em3btsXIkSNT9juIiMizbt065OXlYefOnTjjjDMwd+5cBIPBTIdVL7BiFFENbdmyJeU63ez96hg3bpz/dZs2bfDoo49Wev+hhx6K0aNH46abbgIA7Ny5E9OmTcOwYcP2+lonn3wyrrvuumrF2adPH3Tv3r1az9a2kv3KmzdvnvZzmqYhKyvLn7yXnsTXxNlnn40PPvgAQ4cOxf/+9z+sXbsWgwcPhqIoaN26NRRFwdatW1Mm9kcddRReeOEFdO3ada/jDxgwAHPnzsV1112HTZs24euvv0bPnj2h67p/kmLLli0pPdpPO+00jB8/HqecckqtvU8iooZKCIG//vWvmDBhAmRZxtSpU9P67y9RfbBgwQI899xz/vVxxx2HRYsWlUms/vbbb9GzZ09s2rQJgNdyoGvXrjjxxBNrNZ6rrroKixcvBuCV0r/tttvw0EMPIScnp9z7DcPAvHnzWF4fXGeUh+uM8nXs2BGqqsK2bQDA0qVL03quvPtKvq/q+vjjj/HCCy/41wcddBBGjBhR43GJiPYHtm3jsssuwwcffIDs7GwsWrQIxx57bKbDIqJGhmuNsrjWKF+m1hqhUMh/79u3by9z6HvMmDH417/+hcWLF7NlNxFRwqZNm9C1a1f8/vvvOOGEE/Dee++hSZMmmQ6r3mDFKKIa2rFjR8p106ZN6+R1fv75Z3z33Xf+9dChQ9M6UT9s2LCU++bPn5/W6w0dOrRapyoA4Oqrr67S/ZMmTYIQwv9V077XJZUs0VvVjNiSZWJLjlMbzjrrLHz//fcYO3asv/HnOA42bdqEX3/91Z/oS5KE4cOHY8WKFVXalL/ooouwdu1a3HvvvdB1HQBgmiZ+++03/Pbbb35SlKqq+Otf/4qPP/6YSVFERAlPPPEEnnrqKQDAK6+8gksuuSTDERGlx3Vd3HPPPf51OBzGvHnzyq022bFjR8yYMcM/Teq6Lu69995ajeftt9/GjBkz/OsXX3wRY8aMqTApCgACgQAGDBhQbz6QziSuM8riOqN8TZo0QadOnfzr//73v35CYkUcx8HTTz9d5vs13Tz5/fffMXjw4JRqUS+88AKTHYmI4M23RowYgTlz5iAQCODdd9/FaaedlumwiKgR4lqjLK41yrev1hqKoqBXr1549dVXsWbNGkQiEX8vIxKJ4Msvv8SNN97o73UAwDfffIOLL76YlaOIiOD9vz0vLw8///wzDj/8cCxZsqRKybWNAROjiGqo9GSurj7wXb58ecp1jx490nouKysrZVJeepyKdO7cOe3YavPZ2layzG7JSXM6AoGA/3VVemenY/Xq1ejduzduv/32ShcoQghMnDgRhx9+OJ599lm/Bc3eLF++HBdccAH+/ve/wzTNCu+zbRv/+Mc/0KFDB0ybNq3K74OIaH8zfvx4P7HkqaeewvDhwzMcEVH63n//ffz3v//1r2+55RYcfvjhFd7fuXNnDBw40L+eP38+1qxZUyuxGIaBW2+91b++9NJLq31yt7HiOqN2n61t9W2dcfvtt6dcX3PNNZW2qrjjjjvw5Zdflvl+TeIpLi5G7969/Up0AHDTTTehb9++1R6TiGh/IYTAyJEjMWnSJCiKgunTp+P888/PdFhE1EhxrVG7z9a2xrjWWL58OebPn49rrrkGHTp0SElwUxQFp556Kp5//nl88sknflcMAPjss8/w7LPPVuXtEBHtdwoLC9G9e3d8//33OOigg7B06VK0adMm02HVO0yMIqqh0iXoaruyUNL//ve/lOuOHTum/exJJ53kf71x40ZEo9G9PnPEEUekH1wJTZo0SZmYZlrJExWVJQiVp+RJg5InLWpq0aJFOOWUU/Dee+8BAJo1a4aHH34Y//nPf1BUVIR4PI61a9fi5ZdfxtFHHw3AKxl86623Yvjw4XtNjpo4cSK6dOmCTz/9FABw8MEHY+zYsfjhhx8QjUYRjUbxww8/YOzYsTj44IMBeP9cXHbZZXjwwQdr7X0SETU006dPx/XXXw8AuPfeezFy5MgMR0RUNbNnz065vvbaa/f6TOn2VnPmzKmVWGbOnInNmzcD8CpgPvbYY7UybmPCdUYqrjMq17dvX/Ts2dO/3rhxI04//XQ88cQT+Omnn2AYBnbt2oVFixYhLy8PzzzzDICy/5xVt8R6PB7HxRdfjK+++sr/Xs+ePTF27NhqjUdEtL955JFH/P/2Tpw4ERdffHFmAyKqonbt2kGSpBr9qq2KOuvXr692DDNnzqyVGBo6rjVSca1RuX2x1ki3Hd5pp52GOXPmpCROPf74436HDCKixiYWi6FPnz748ssvccABByA/P79OW+Q2ZEyMIqqhAw44IOV69+7ddfI6u3bt8r/WdR25ublpP9u6desKx6pIZS1O6uK5ulLytEvJkxbpKHmCobZOzaxZswYDBgzwxz7iiCPw7bff4v7770fHjh2RnZ2NQCCAww8/HCNGjMA333yDPn36+M9PmjQJzz//fIXjf/zxxxgxYgQcxwHgtexbuXIlbrvtNhxzzDEIhUIIhUI45phjcNttt2HlypU488wz/ecffvhhzJs3r1beKxFRQ/Lee+9hyJAhEELg+uuvxyOPPJLpkIiqbMGCBf7XHTp0QIcOHfb6zDnnnJPyoWu6LQr25pVXXkl5jXbt2tXKuI0J1xm181xdqW/rDEmSMHnyZJx66qn+93bt2oW7774bRx11FILBIJo3b44ePXpg6dKlAIATTjgBd999d8o4zZo1q/JrW5aFgQMH4oMPPvC/d/7552PmzJlQVbWa74iIaP/x/PPP44EHHgAA/POf/8RVV12V4YiIMqOu2rVR1XGtUTvP1RWuNSrXqVOnlOrXO3fuxCeffFIrYxMRNSSWZWHQoEH46KOP0KRJEyxevBjHHXdcpsOqt5gYRVRDpSfo69evr5PXKXlqIxwOV+nZ0n270zkBUt0PsOvbB98lFzXpLJ6SLMtCJBLxr6t7crq0UaNG+eNKkoRp06bh0EMPrfD+UCiEt956CwceeKD/vYcffrjCBdEdd9wB13X9Z2fOnFlpD9nmzZvjnXfeSTk9cu+991bpPRERNXQff/wx+vfvD9u2cdlll+H5559POXlG1BDs3r0bGzZs8K/POuustJ7TdT3lw82VK1fWOJZYLJbyoSTbxFQP1xm181xdqW/rDMCb2//73//G9ddfD03TKr134MCB+PDDD8v8/65FixZVek3btnHppZemJFV26dIF8+bNq9Wqu0REDdWUKVNw8803AwAeeugh3HLLLRmOiKh62rVr5x++SPdX6bnAZZddViexHXTQQWnHVFct4xoarjVq57m6wrXG3l1yySUp15999lmtjU1E1BA4joOhQ4di/vz5CAaDmD9/fspnvFRW/fq/PVEDdMYZZ2DKlCn+9YoVK3DeeefV+uuUXLSlUza2pJKT4dJj7e/at2+PNWvWAAA2bdoEx3GgKMpen/vtt9/8BCMAOPzww2scSzweT2lP06lTp7T+J5WVlYXhw4fj73//OwBg+/btWLZsGfLy8lLuW79+PT7//HP/ul+/fn6rvMocfPDB6NevH9566y0AwKpVq/DTTz/hyCOPTOdtERE1aP/5z39w0UUXIRaLoWfPnnj99dchyzw7QA3PDz/8kHJdlRYCHTp08BOZdu3ahc2bN6ckZVfV119/Ddu2/etkC4SioiJMmTIF06ZNw08//YTt27ejWbNmaNu2Lf70pz/hyiuv5KmmErjOqN/q0zqjpHA4jHHjxuGuu+7CrFmz8O9//xsbN25EJBLBgQceiJNOOglXXHEFTjvtNADAr7/+mvL8H/7wh7Rfy3EcDBkyBLNmzfK/d+aZZ2LBggVlNrKIiBqjefPmYejQoQCAW265xa8aRdQQffjhh1W63zAMHHzwwX71mgMOOAD9+vWrg8i8BMTaatPXWHCtUb9xrbF3Rx99dMr11q1ba21sIqL6TgiBm266CVOnToWqqnjnnXdw7rnnZjqseo+7PkQ1VHrB8P7779fJ65QsM2qaJgoKCtJ+tvSksLZKljYEJTfXbNtO+/TL2rVrKxynun788ceUHt/JBUI6St/73Xfflbnn22+/rfSZmo5PRFXjugIRw8bOiIntxQa2FRnYXmxgZ8RExLDhuiLTITZ6P/30Ey688EIUFBTgnHPOwYwZM/Z66o2ovlq3bl3K9WGHHZb2s6XvLT1WVf3nP/9JuT7kkEPwr3/9C8cffzyuv/56fPTRR9i0aRNM08SWLVuwYsUKPP744zjxxBNx7bXXppT+b8y4zqjf6tM6ozxt27bF7bffjtmzZ2PFihX47rvv8P7772Ps2LEpc/+SVeIOOeQQtGnTJq3xXdfFsGHDMH36dP97p5xyChYtWlTvWpEQEWXCRx99hEGDBsFxHFx11VUYO3Ysq9JSozJnzhzs2LHDv77yyiuh63oGI6KSuNao3xr7WiMdpSvSVTXxjoioIbv33nvx0ksvQZIkvPnmm+jZs2emQ2oQmBhFVEMnnnhiymZSfn5+nZSePeqoo1KuSyfBVKbkBPTggw+uctnahqxjx44p1+mWVP30009Trk888cQax1KTUy6lT1yXt2FY1+MTUXosx0VB1ML2YgPFhg3LceG4Aq4QcFwBy3FRbNjYXmygIGrBcty9D0q17rfffkPXrl2xdetWnHzyyZg3b16j+v8j7X8KCwtTritrpVta6Q+Yi4qKahTLtm3bUq6/+OILdO/e3T8tKkkSWrZsiTZt2qScenVdFxMmTMAf//jHtNokVMXWrVvx3XffVelX8oRupnCdUb/Vp3VGdRUWFuKrr77yr7t27ZrWc0IIXHvttXjzzTf973Xs2BH5+flo2rRpbYdJRNTgfPXVV+jduzfi8Tj69OmDCRMmsCotNTqvvvpqyvU111yToUioPFxr1G+Nea2Rri1btqRc12abPiKi+uzxxx/H448/DgAYP348Bg8enOGIGg6uyIhqSJZl/N///Z9/7bouRo8eXeuvc9ZZZ6Vcv/fee2k9F41GU0odlx5nf9ejR4+UE3lLlixJ67n8/Hz/66ZNm6JLly41jqX0puPmzZvTfvb3339PuT7ggAP2+fhEtHfFiQpRcduBAGDaLgrjFnZHTeyKmNgdNVEYt2DaLgSAuO1gZ8REsWHvbWiqRdu3b0deXh42bNiAo446CosXL0Zubm6mwyKqkdKJRMFgMO1nS5+0rGlS0u7du1Oub7/9dpimiUAggIceeggbN27E1q1bsWnTJuzYsQPjxo1LSeRasWIF/vznP9cohtLGjRuHE044oUq/+vbtW6sxVBXXGfVbfVpnVNfMmTMRj8f963T+vRNC4C9/+Qtee+01/3vHH388li5dWqWETCKi/dXq1avRvXt3FBUV4fzzz8f06dOhqmqmwyLap9avX59SgejMM8/ECSeckMGIqDSuNeq3xrrWqIqPP/445bp9+/a1Oj4RUX300ksv4Z577gEAPPnkkxgxYkSGI2pYmBhFVAtGjBiBVq1a+deTJk3CnDlzqj3eokWLypQ9bd++PY4//nj/+o033kirPOjrr7+esrl10UUXVTuuhujAAw9MWTjNnDkTu3btqvSZ1atXp0yse/XqVSutlQ477LCUcd5///2Unt+VKb34KX3aBgCOOOKIlOuSC6HaGJ+IKlcQsxBJJDjFTQe7IiYKYhYMy4XlCNiugOUIGJaLgpiFXRETcdMBAEQMG4VxK5PhNxqFhYXo0aMHVq9ejUMOOQRLlixJ+X84UUNV8gNHAFVqUxEIBFKua1o5snRilWVZ0DQNCxcuxIMPPphSPj83NxfXX389Pv7445TE7KlTp2L58uU1imN/wHVG/VWf1hnVEY1G8fDDD/vXp5xyCjp16rTX52699Va8/PLL/vWxxx6LDz74gCe0iYgAbNiwAXl5edi+fTtOO+00zJ07t0rJ6kT7i4kTJ0II4V9fe+21GYyGKsK1Rv3VWNca6TJNE+PHj0/5Xl5eXq2NT0RUH7311lu44YYbAAD33Xcf7rjjjgxH1PAwMYqoFoTDYUyePDmlLPall16KWbNmVWkc0zTx0EMPoVevXuW2MEn+Bw8ANm3ahAceeKDS8X777beUe5o3b45LL720SjHtC8OGDYMkSf6vkqdBasNtt93mfx2LxXDfffdVev/tt9+ecn3rrbdWen+68WdlZeGcc87xr3/55ZcyE/jyfPXVV5g+fbp/nZ2djc6dO5e578gjj8Thhx/uXy9btiytUzhz585NKbN71FFHoV27dnt9joj2KDZsxC0vyakwbqHIsGG7ApIEBDUZTYIqckMamgRVBDUZkgTYrkBRiYSomOns08pRrisQSVS42l5sYFuRge3FBnZGTEQMG64r9j5IAxOPx3HxxRfjyy+/RIsWLZCfn4+2bdtmOiyiWlF60800zbSfNQwj5bp0BamaxgIAI0eOxJ/+9KcKnzn22GMxZsyYlO/985//rFEc+wOuM2qmsawzqspxHFx77bX45ZdfAHgVA8aNG7fX5+68804899xz/vXRRx+NDz74gAnGRETw2vbm5eXht99+w7HHHov33nsPTZo0yXRYRPuc67qYNGmSf52VlcUWL/UU1xo1w7VG+aqz1qjq4aybbroJGzZs8K//+Mc/8vM9ItqvzZs3D1dddRWEELjxxhvxt7/9LdMhNUhMjCKqJd26dcNDDz3kXxuGgYEDB+Kqq67Czz//XOmzkUgEEydOxFFHHYXRo0dXWEXommuuSTlh8fTTT2P06NFwHKfMvT/++CMuvPBCbN++3f/e3//+90Z5Um3gwIE49dRT/euXXnqpzMYb4C3cb7vtNixatMj/Xv/+/XH66afXWiwlSxQD3gLl1VdfTTlFVdJHH32EXr16pfwd33LLLRVWgSg9/mWXXYZ33323wnjeeecdDBkyJOV7zDImqhrLcf1KUYVxr0IUAIR1Bc2zdDQJaghqCnRVRlBT0CSooXmWjrCuAAAMy/WToyKGDctJr5JcTeItiFrYXmygOPF6jivgCgHHFbAcF8WGje3FBgqiVp3Hs6/Yto3Bgwfjww8/RJMmTbBo0SIcc8wxmQ6LqNZkZ2enXJeuIFWZ0h9Clh6rqkpvAkqShFtuuWWvz11++eVo3bq1f12y/UZN3XDDDVi1alWVftXktHRt4jqj/qpP6wwAePPNN7F48eJy/96Sfv75Z/Tu3RtTp071v3fHHXfgzDPPrHTs+++/H0899ZR/feSRR+KDDz7AgQceWPPAiYgauIKCAnTv3h3/+9//0LZtWyxZsoSV9KjRWrJkCX799Vf/evDgwXWeJPjMM8/gzDPPRIsWLaBpGlq0aIFjjz0WQ4cOxeTJk8scBKE9uNaovxrTWuPwww/Hk08+id9//73S+zZt2oQBAwbglVde8b+nKAqeeOKJNN8FEVHD8+GHH2LgwIFwHAdDhgzBs88+m9JuldLHBudEtej+++9HTk4ORo4cCcdx4LouJk+ejDfffBMnn3wy/vjHP+Kggw7CAQccgMLCQmzZsgVff/01Pvzww7QWaIFAAJMnT8a5557rl5J96KGHMGXKFAwcOBDt27dHJBLB8uXLMWfOnJQNsb59++K6666rs/den0mShClTpqBTp07YtWsXhBAYOXIk3nrrLVxyySVo3bo1NmzYgKlTp+Knn37yn2vfvn1aJ6erolevXrjiiiswZcoUAF5rmREjRmDMmDHo3bs3OnToAFVVsXHjRixduhT//ve/U54/6aSTcPfdd1c4/p///GfMmDEDH330EQDvw7mLL74Yp512Gnr06IHDDjsMgFetauHChfj6669Tnu/atSuGDx9em2+ZaL8XNbwPBOKm4ydF5YRUBFSlwmdkSUJWQIWqSCiM2TAsF3HFQVBTEDUc5IbrJne92LD9JC4AMG0XcduB6woIAUgSIMsSgqqXyBW3HcRtB1kBFdmBhjttdF0Xw4cPx7vvvotAIIB58+alfLhEtD/IyclJud5bmf2Sdu/enXJd042L0rEcc8wxKe3zKqKqKrp06YJ33nkHALBt2zb8+uuvOPTQQ2sUDwC0atWqQVe14TqjfqpP6wwA+PjjjzF+/Hg0b94cf/rTn9CxY0c/2XDz5s1YtmwZPvzwQ1jWnva9V199NR577LFKx/3111/xyCOPpHxv9+7dOPfcc6sU35QpU/a6KUJE1NBEo1H07t0b33zzDVq1aoX8/HwccsghmQ6LKGNeffXVlOt90UZv7ty5Kdc7duzAjh07sHr1arzxxhu488478cgjj9RJLFu3bsW2bduq9MyaNWtqPY6a4Fqjfmosa43k83/9619x99134/TTT8cf/vAHHHHEEWjatCkAYMuWLVi+fDkWL15cpjr2Cy+8gDPOOKP23igRUT3yxRdfoHfv3jAMAxdffDFee+21lEqPVDUNd4eLqJ669dZbcfzxx+P222/HqlWrAABCCHzzzTf45ptv9vp8mzZtMHr0aJx44onl/vkf/vAHvP/+++jVq5d/cuKnn37C3//+9wrHvPTSS/HGG29U493sP44++mi8++676N+/P7Zu3QrAa1H31VdflXt/hw4dMH/+/DrZQHvttdegaVpKWekffvgBP/zwQ6XPderUCe+8806lm5WapuHdd9/FpZdemtJG78svv8SXX35Z6fgXXXQR3nrrLShKxckcRJTKdQUM20uMiiVa6YV1pdKkqJICqoKwLhA1HcRMLzHKsB24rgpZrt2s/4KY5bf7i5sOYpYDu7x2eY6AYblQZQkhTUFQV7zWekIgJ6jVakz7ghACt912GyZPngxFUTBjxgycd955mQ6LqNa1b98+5bpkWfm9SZa4TyrZmrc6Sj+fTMxOR+ny99u3b6+VxKj9AdcZ9VN9Wmck7dy5EzNnzsTMmTMrvEfTNNx1110YPXr0Xj9UK+9U+LZt26q8CVjVFhlERPWdZVkYOHAgli1bhtzcXCxevBhHHnlkpsMiypht27alVK4/7rjj0KlTp33y2jk5OWjatCni8Th27NiRMn/ZsmULRowYgWXLltX6huK4ceMwevToWhsvU7jWqJ8aw1qjJNd18fnnn+Pzzz/f6725ubkYN24cLr/88rTHJyJqSL777jt0794dxcXF+NOf/oRp06ZBVZnaUxNMKSOqA127dsXKlSsxdepUXHjhhQiHw5Xer2kaLrjgArz++utYu3YtRowYUWlyyhlnnIEff/wRt9xyS5kT+SWddNJJmDVrFqZOnQpNa3ib2bWtS5cuWLVqFYYNG1bh30mzZs1w++2349tvv62zFkuapuG1117DokWL0K1bt72WPDzppJPw0ksvYdmyZWlVW8jJycHChQsxderUtD586Ny5M6ZNm4Z58+bVeWlrov1NzHIg4FVesl0BSQJCetWSC0O6AkkCbFfAtF0I7Emyqi3Fhu0nRRXGLRQZth9vUJPRJKgiN6ShSVBFUJP9eIoM22/zFzMdFJeoNtVQPPzww3juuecAAJMmTULv3r0zHBFR3TjuuONSrqtyCnnt2rX+182aNatxa6ySbRIAVKntQel7q9ISsDHgOqN+qi/rjAsuuACdO3eu9O8kOzsbl156Kb799lv87W9/40lDIqJqcl0XQ4cOxcKFCxEKhTB//nycfPLJmQ6LKKPeeOONlGox11xzTZ29VnZ2NoYPH445c+Zg8+bNKCgowC+//IItW7agsLAQixcvRq9evcrEd8cdd9RZTA0d1xr1U2NYa4wcORKnnnpqWhv+Bx10EO677z788MMPTIoiov3WunXrkJeXh507d+LMM8/EnDlzGmVb2domCSHKKRVA1DB89913OOGEE/zrVatWldmIqQ9M08SKFSvw22+/Yfv27SgoKEB2djaaNWuGo48+GieffDICgUC1xrYsC5988gnWrFmD7du3IxgMonXr1ujUqRPatWtXu29kPxKJRPDRRx9hw4YN2LVrF1q2bIl27drh3HPPha7r+zSWgoICfPHFF1i7di12794Nx3GQm5uLgw8+GKeffjoOPvjgGo2/bds2fPHFF/jll19QUFAAwDtR0bZtW5x++ulo2bJlbbwNokZpZ8SE5bgojFswLDeRZFT1D20KYxYM20VAk5ET1KApMppn1c5/iyzHxc6IV2Y6GSfgVbYK6QrkcpIzXSEQMx1ETS+ZKhkXADTP0qEpDWMT9dlnn8Wtt94KAHjuuedw0003ZTgiorrVtm1bv1JUhw4d0kqOMk0Tubm5fgLSueee67fkrS7LspCbm+tXhznnnHPKtAeuyPXXX4+XXnrJv/7xxx9x1FFH1Sie6moIaw2uM+qf+rDOKC4uxooVK7BmzRrs3LkTAHDggQfi0EMPxdlnn80P04iIakgIgZtuugnjxo2Dqqp499130aNHj0yHRZRxxx13nF8RX9d1bNy4ES1atKj11zEMA4ZhVJpckzRp0iRcc801cF3X/97nn39ea623HnrooRpXjKqP6wyAa436aH9faxiGge+++w7r1q3Dpk2b/NaLubm5aNmyJU499VR06NChVt4HEVF9tXHjRpxzzjn4+eefccIJJ+Cjjz5C8+bNMx3WfoGJUdSgNYTNCiIi2n9tLzbguAK7oyYsRyQqLlW9HWXcclAUt6EpEpqGdSiyhBbZ1ftwqbSCqIW47SBuOihKVHzKCalptfszbAeFMe+Z5HsLqgpyw/X/xN4bb7yBoUOHAvCqRt1///0Zjoio7pVOKlq7du1e2+K9//776Nq1q3/9j3/8A3feeWeNY+nXrx/mzJkDwPsQc+fOnWmdFj3rrLP8svmapmH37t17PalcV7jWICIiovKMGjUKjz76KCRJwtSpUzF48OBMh0SUcZ999hk6d+7sXw8cOBBvv/12BiPa44knnsDdd9/tX1900UWYN29erYy9devWKrcXXrNmDfr27etfc51BREREALB9+3acd955+P7779GhQ4e0OwlRetiIkIiIiKiakunlyd/Lq76UjuRjpcerKdcVMGyv6lOyPV9YV9JKigKAgKogrAtETQcx00FQU2DYDlxXhSxX773uC3PnzsXw4cMBALfddhtGjRqV4YiI9o1+/fqlJEa98soreOyxxyp95pVXXkm5LvkBfU0MGDDAT4wqKCjAkiVL0L1790qf+fnnn/HFF1/412eddVbGkqKIiIiIyvP000/j0UcfBQC8+OKLTIoiSnj11VdTrq+99toMRVLW7bffjueffx6//fYbAGDp0qWIxWIIhUI1HrtVq1Zo1apVjcchIiKixq2wsBA9evTA999/j4MPPhhLly5lUlQtaxh9UIiIiIjqoWRCU/J3t5oZTcnHSo9XUzHLgQBg2i5sV0CSgJBetYpWIV2BJAG2K2DaLgT2JFnVR//6178wePBgOI6DoUOH4umnn4ZUWz9Qonqua9euKRWOnnvuOfz8888V3v/pp59ixowZ/nWvXr1w5JFHlnvv+vXrIUmS/+uPf/xjpbEMGDAAbdu29a/vvvtumKZZ6TMjR45MaXGRrPpGREREVB9MnDgRd9xxBwDgsccew3XXXZfhiIjqh+Li4pTqUG3btk2pSptpuq7joosu8q/j8Tj+85//ZC4gIiIiohJisRj69OmDL7/8Ei1atEB+fj5by9YBJkYRERERVVOyQlSyepLluJXdXiHTdlPGqW7lqdKMxLjxRNWogCpXeWxZkqArcso4yXHrmy+//BJ9+vSBYRjo27cvXn311bRadxHtL2RZxt///nf/OhKJoHfv3vj111/L3Lty5UoMGjTIT0SSZdmvflAbAoFAynjffvstLrnkEuzatavMvYZh4MYbb8Ts2bP97x111FG46qqrai0eIiIiopqYNWsWRowYAQC48847cdddd2U4IqL6Y9q0aSguLvavr7766nq3Fj/66KNTrrdu3ZqhSIiIiIj2sCwLAwcOxEcffYScnBwsXrwYxx57bKbD2i+xlR4RERFRNQVUGZbjIqgqMCwXhu0iS4gqJR+5QsBMJFQFEy3uAmrtfICYrGDlut7vmlK9cXVVhmG7/jjVrYxVl3744Qd0794dxcXF+NOf/oSpU6dCVTnVpcand+/euOGGGzBu3DgAwHfffYdjjz0WV1xxBU4++WRYloXly5dj5syZsCzLf+6JJ55Ax44dazWWK664Av/6178wYcIEAMCCBQtwxBFHYNCgQTjppJOgqip++uknvP322/jll1/857KzszFr1ixomlar8RARERFVx9KlS3HZZZfBdV1ce+21eOKJJ1iVlqiE5Hwf8A5cJFvb1yel2+ZFo9EMRUJERETkcRwHV111FRYsWIBgMIj58+fjlFNOyXRY+y3uFhERERFVU0hTEDFs6KoMVZZguwIx00FWIP0pVsx0IASgyhJ0VYaUGLc2JPOXkr9XtxJV8rHS49UX69evR15eHnbs2IHTTz8dc+bMQTAYzHRYRBnz7LPPoqioCJMnTwbgVY56+eWXy71XkiTcfffdfluY2vbSSy/Btm28/vrrAICdO3fipZdeqvD+gw46CHPmzMHxxx9fJ/EQERERVcXy5cvRt29fmKaJgQMH4qWXXmJSFFEJ3333HZYvX+5fd+vWDYceemgGIyrfli1bUq5btGiRoUiIiIiIACEEbrzxRkybNg2qqmLWrFk455xzMh3Wfq1+1TOleuvbb7+FpmmQJMn/9cc//jHTYREREWWULEsIJKo8JZOZoqYDI9Fybm8M20HU9O4N6d7zmiIjZjnYGTGxvdjAtiID24sN7IyYiBi2X7UpHcnP65O/V7fSU/Kx0uPVB1u2bEFeXh42btyI4447Du+99x6aNGmS6bCIMkpRFLzxxhuYPn06TjjhhArvO+uss7B06dKU9nu1TVVVTJo0CXPnzsWpp55a4X05OTm48847sXLlSpx++ul1Fg8RERFRulatWoWePXsiEomgW7dumDx5MhSldg6xEO0vSlaLAoBrrrkmQ5FU7uOPP065bt++fYYiISIiIgLuuecejB8/HpIkYcqUKejRo0emQ9rvsWIU7ZXjOLj22mth23amQyEiIqp3wgEFcdtBUFdgui4My0VhzEZYFwjpSrlVmlzhVZZKJkUFNBmKLKEwZiFLV2A6pXLXBeBAwHJcRAwbAVVBOKDstTWeLElwICDLEuB4zwerUY3KtL1Wf7Is+ePWB7t378aFF16INWvWoG3btliyZAkOOOCATIdFVG8MGjQIgwYNwqpVq7By5Ups2rQJiqLgoIMOwumnn47DDz887bHatWsHUYNycX369EGfPn2wdu1afPXVV9i0aRPi8ThatGiBY445BmeddRbbXxIREVG9sW7dOnTr1g27du1Cp06dMGvWLAQCgUyHRVSvmKbpV6kFgJYtW+Liiy/OYETl+/777/H+++/71+3bt8cRRxyRwYiIiIioMXv88cfxxBNPAABefvllDBo0KMMRNQ785Jn2auzYsfjyyy8zHQYREVG9pCkysgIqIoaNnKCGQlgwLBdR00HMcqArstciT/IqL5m2C9Nx/SpMAU2GIknYHbUQ1hUoigzTdhG3HbiugBBehSZZlhBUFeiqjLjtIG57LfuyK2nbF1BlLxlKVWBYLgzbRZYQVUpscoWA6XiJUcFEdayAmvmio9FoFBdddBG+/fZbtG7dGkuXLsXBBx+c6bCI6qUTTjih0spR+1KHDh3QoUOHTIdBREREVKHff/8deXl5+P3333HiiSdiwYIFyMrKynRYRPXO3LlzsX37dv/6qquugqZp1RqrZIvKtm3bYv369eXeF4/HEQgE0m5pWVxcjCFDhsB1Xf97Q4cOrVaMRERERDX14osv4p577gEAPPXUU7j22mszHFHjkfldLarX1q1bhwcffBCAd+KDVRiIiIjKyg6ofiWmnKCGJkEVqixBCMCwXRTFbRTGbBTFbRi2lxSlyhKaBL2kpqjpIKQpUCQJuyImCmJecpXlCNiugOUIGJaLgpiFXRET8USlqYhhozBuVRhXSFMgAdBV2Y8nZqbX5i8pZjp+vLoqQ8KetoGZYpom+vfvj08++QRNmzbFkiVLMn7a03UFIoZdKy0QiYiIiIgoM3bu3Ilu3bph3bp16NChAxYvXoxmzZplOiyieql0G719sbG3fPly/OEPf8Bbb72FSCRS6b1fffUVOnXqhG+++cb/Xps2bTBy5Mi6DpOIiIiojClTpuDGG28EAIwaNYpzkn2MFaOoUn/+858RjUYBAGPGjMGoUaOwY8eODEdFRERU/+SGNCiyhIhhI6gpCGrKXis/RQwbhuUirCtwhECR4SUtSZJXlUlTZMiSBFd4bfAM24XtChQZNkzXRU5QQ8x0IEtSuZWjZFlCQPVa/YU0BUWGjajpQFW87++NYe9p9xfSk9WiFL+lXiY4joOrrroKixYtQigUwoIFC3DSSSdlLB7LcRE1HBi2gzKpT9VsgUhERERERPtecXExevXqhVWrVqFNmzbIz89HmzZtMh0WUb20YcMG5Ofn+9edO3fGMcccs09e+9tvv8UVV1yBcDiMs88+Gx07dsQhhxyCnJwcGIaBX3/9FR9++CE+/fTTlOeys7Px7rvvIjs7e5/ESURERJQ0b948DB06FEII3HTTTXj44YczHVKjw8QoqtDEiRP93ttdu3bFkCFDMGrUqAxHRUREVH9lB1QEVNlPlNFVr41eeWzHheMKNAtriFoODMsr6x7WFYR0pUy7u6CmIEsIxEwvWcmwXBTCQk5QSyTdyOUm3IQDXmJUUFdguq73XMxGWBflvg7gtc9Lvg7gtftLVsQKBzJXLUoIgRtvvBHTp0+HpmmYPXs2OnfunLF4ig0bEcP2r2urBSIREREREe1bhmHgkksuwfLly9G8eXPk5+ejffv2mQ6LqN567bXXUtrTZaINTDQaRX5+fkqCVkWOOeYYTJkyBaeccso+iIyIiIhoj3/9618YOHAgHMfBlVdeiX/+859ptwWm2sMdGSrXli1bcMcddwAAgsEgXnrppQxHRERE1DBoiozcsAzXVRGzHBi2C1eUSJSRJARUGabtQlVkxM09SVE5IbXSSk6yJCEroEJVJBTGvGpTccVBUFMQNRzkhssmRmmKjKyAiohhIyeooRBem76o6SBmOdAVL3lLkgAhvOQe0/Ha/QFeUlROUAMAZAXUjFY7uu+++zB+/HhIkoQ333wTF154YcZiKYhZiFte4lg88bO0y2uXl2iDqMoSQpqCoK54rfWE8H+uRERERESUOY7j4IorrkB+fj6ysrKwcOFCHH/88ZkOi6jeEkLgtdde86+bNGmCQYMG7ZPX7tChA4YPH45///vfWLNmzV7vP+mkk/CXv/wFw4YNQygU2gcREhEREe2xYsUK9OnTB4ZhoG/fvpg4cSJkmR0lMoGJUVSum266Cbt27QIA3H///ejQoUOGIyIiImpYZNlLYsoKlP0z1xV+paFYIrkmrCtptbcDvHZ2YV14yU2mlxhl2A5cVy23zV12QIXjCsQtBzlBDXHFe852BQzba9FXmipLCOmKXykqpCsZrXL05JNP4rHHHgMAjB8/fp996FqeYsP2k6IK45af2FZbLRCJiIiIiGjfEELguuuuwzvvvANd1zF37lyceeaZmQ6LqF6TJAnr16+v1TGFKOegUTkOPfRQTJgwAQCwe/durFq1Cr/88gu2bt2KaDQKVVXRtGlTHHLIITjjjDPQsmXLWo2TiIiIKF2rVq1C9+7dUVxcjAsuuABTp06FqnI/IFP4k6cy5s6di5kzZwIAjj/+eNx5550ZjoiIiGj/ErMcCHjVmWxXQJK8xKOqCOmKX6XItF3oqoyY5bVpK09uSIMiS4gYNoKal/C0t9ZvSZlu/fbqq6/ir3/9KwDgiSeewIgRIzIWi+W4flJbyaSo2m6BSEREREREdUsIgTvvvBMTJkyALMuYNm0aLrjggkyHRURpatq0Kbp06YIuXbpkOhQiIiKiFGvXrkVeXh527dqFM888E3PmzEEwGMx0WI0aE6MoRUFBAW644QYA3smP8ePHQ9PY5oWIiKg2JSs0xW2v6lBAlcsk1OyNLEnQFRlGIrlJV72vy6tQlZQdUBFQZUQNB0bimZIJUCVJSFSmCigZTdyZMWMG/vznPwMA7rrrLj9BKlOixp72eXXZApGIiIiIiOrW448/jqeffhqAdxijX79+GY6IiIiIiIgauo0bN6Jr167YvHkzTjzxRCxcuBDZ2dmZDqvRY2IUpfjrX/+KTZs2AQBGjBiBs88+O8MRERER7X/cRIl41/V+r27iUTIZKjmOm0bpeU2RkRuW4boqYpbjPS9KVIySJARUGSFNKbct3760ZMkSXHHFFRBCYMSIEX4rvUxxXQEjkcy2L1ogEhERERFR3XjppZdw7733AgDGjBmDq6++OsMRERERERFRQ7d9+3bk5eVh/fr16NChA5YsWYLmzZtnOiwCE6OohH//+9945ZVXAACtW7fGE088sU9ff+vWrdi2bVuVnlmzZk0dRUNERFR3kvlLyd+rWi0qKflY6fHSIcteFaPKKkxl0meffYZ+/frBsiwMGjQIL774IqRq/pxqSyZaIBIRERERUe2aNm2aXzF/1KhRuP322zMcERERERERNXSFhYXo3r07fvjhBxxyyCFYunQpDjzwwEyHRQncgSEAQDwex4gRIyASO6rPPPMMmjZtuk9jGDduHEaPHr1PX5OIiCgTJAmA2JPYlE6lp/IkH0uOk+G8oVqzcuVK9OzZE9FoFN27d8fkyZOhKFVLQKoLmWqBSEREREREtWPhwoW48sorIYTAjTfeiIcffjjTIRERERERUQMXi8XQu3dvfPXVV2jRogXy8/PRrl27TIdFJTAxigAAo0ePxv/+9z8AQPfu3XHppZdmOCIiIqL0uK6o9y3hSpMlCQ6EF5cjYDkuglrVE3/MRKJO8v1Vt/JUfbJmzRp069YNu3fvRufOnTFz5kzoup7psABktgUiERERERHVzLJly9C/f3/Yto3LL78czz77bMar0hIRERERUcNmmiYGDBiAf//738jJycHixYtxzDHHZDosKoWJUYRvv/0WTz31FAAgHA5j3LhxGY6IiIho7yzHRdRwYNhee7MUAnDgJRxFDBsBVUE4oFQ7kaW2BVTZS4ZSFRiW61UMEqJKiU2uEDAdLzEqqCr+uA3Zxo0bkZeXhy1btuCkk07C/PnzkZWVlemwfPWhBSIREREREVXdN998g4suugjxeBy9evXCpEmTIMsNe/1ERERERESZ5TgOrrrqKixcuBChUAjz58/HKaeckumwqBxMjGrkHMfBNddcA9u2AQAPPPAA2rdvn5FYbrjhBgwcOLBKz6xZswZ9+/atm4CIiKjeKjZsRAzbvzYTbclct0TFKFlCUFWgqzLitoO47SAroCI7kPnpT0hTEDFs6KoMVZZguwIx04svXTHTgRCAKkvQVRlSYtyGaseOHejWrRvWr1+PI444AosXL0azZs0yHVYKtkAkIiIiImp4/ve//+HCCy9EYWEhzj33XMyYMQOapmU6LCIiIiIiasCEELjhhhswffp0aJqGWbNm4Zxzzsl0WFSBzO8MUkaNHTsWX331FQDgxBNPxMiRIzMWS6tWrdCqVauMvT4RETUMBTELccsBAMRNBzHLge2Wk6DiCBiWC1WWENIUBHUvGckVAjnBzH4ILssSAqqCuO0gpCkoMmxETQeq4n1/bwzbQdT0fgYhPVktqv61DExXcXExevbsie+//x4HHXQQ8vPzceCBB2Y6rDLYApGIiIiIqGH59ddfkZeXh23btuGUU07Bu+++i1AolOmwiIiIiIioARNC4K677sLLL78MWZYxZcoUdO/ePdNhUSVYL7gR27x5Mx588EEAgCzLePnll6GqzJUjIqL6q9iw/aSowriFIsOG7QpIEhDUZDQJqsgNaWgSVBHUZEgSYLsCRYaNwrgFwKu0VFyi2lSmhANeQk1QVxDQvClZYcz2k7fK4wqBiGGjMObFH9BkPzEnOV5DE4/H0bdvX6xYsQLNmzdHfn4+2rVrl+mwypVsVZhsXWjYbpWrRu2PLRCJiIiIiOqjbdu2oVu3btiwYQOOPvpoLFq0CLm5uZkOi4iIiIiIGrjHH38cTz75JADg5ZdfrnJXLNr3mAXTiG3evBnRaBQAoCgKhgwZstdnNm7c6H/9+eef44gjjvCv8/Ly8OKLL9Z+oERERAAsx/Xb5xXGLRiWl1wS1hWEdKVM1Z2gpiBLeC3qoqYDw3JRCAs5QQ0Rw0ZAlaEpmUtI0RQZWQEVEcNGTlBDIbz3FE1UwdIV2WuRJ3mt10zbhem4fhu2gCb7la+yAmpG30t12baNyy67DO+//z6ys7Px3nvv4bjjjst0WBViC0QiIiIiooahsLAQPXr0wOrVq3HooYdiyZIlaNmyZabDIiIiIiKiBm7cuHG49957AQBPP/00rrnmmgxHROlgYhQBACzLwtq1a6v0TDweT3nmhBNOqO2wiIiIfFFjT/u8ZFJUTkittPWcLEnICqhQFQmFMRuG5SKuOAhqCqKGg9xwZpOJsgMqHFcgbjnICWqIKw5iptca0LBdGImWayWpsoSQrviVokK6guwqJObUF67rYsSIEZgzZw50XcfcuXNxxhlnZDqsSrEFIhERERFR/ReLxdCnTx989dVXaNGiBfLz83HYYYdlOiwiIiIiImrg3nzzTdx4440AgPvvvx//93//l+GIKF0NbxeNiIiIGh3XFTBsL6EklmilF9aVtJJRAC/5JKwLrxqT6SVGGbYD11UznpSSG9KgyBIiho2g5iU8mbaLuO3AdQWEACTJS8oJqgr0Em3XsgJqg0yKEkLgjjvuwKRJk6AoCqZPn44//elPmQ4rLeGAlxgV1BWYrutVIovZCOui3MplgNc+L1m5DNg/WiASEREREdVHlmVh8ODB+Oijj5CTk4PFixfj6KOPznRYRERERETUwL377rsYNmwYAODmm2/G6NGjMxsQVUnD20mjWnPyySdDJPvxpKldu3b45ZdfAADnnXcePvzwwzqIjIiIKFXMciDgtZOzXQFJ2lNxJ10hXUHM8qoxmbYLXZURs6rWBq2uZAdUBFQZUcOBYTvQVTklAaokCYlEr4DSINvnAcCjjz6KsWPHAgAmTJiAvn37ZjagKmALRCIiIiKi+sl1XQwfPhzz5s1DMBjEvHnzcMopp2Q6LCIiIiIiauA++OADDBo0CI7j4KqrrsIzzzwDqZxD0lR/ZX4nkIiIiGgvki3l4omqUQFVLrcyT2VkSYKuyDAS1Zh01fs6K1Dr4ZbhugIxy4Fhu3BFiSpQkoSAKiOkeUlOuWEZrqvu9d5MV7mqiRdeeAH3338/AOCZZ57B0KFDMxxR1TXmFohERERERPWREAK33XYb3nzzTaiqipkzZ+Lcc8/NdFhERERERNTAff755+jTpw8Mw0Dfvn0xYcIEyDIPPDc03I0hIiKies9NlNtxXe/36lbZSSZDJcdxq1g5saosx/WrQJV5JQE4ELAcFxHDTqkClRVQ90nC1r42ZcoU3HTTTQCABx54ALfeemuGI6q+xtgCkYiIiIiovho9ejSee+45SJKE119/Hb169cp0SERERERE1MD997//RY8ePRCJRNC1a1dMmzYNqsrP9hsi/q0RERFRvZfMX0r+XtVqUUnJx0qPVxeKDRsRw/av95Y0E7cdxG1nv02amT9/vl8d6uabb8ZDDz2U2YBqQWNrgUhEREREVB/985//xOjRowEAzz//PC6//PIMR0RERERERA3dmjVr0K1bN+zatQtnnXUWZs+ejUBgPzzR3kjsf7tuREREtN+RJABiT2JTdSs9JR9LjlNXLaALYhbiltf2L246iFlem7UyHAHDcr02a5qCoK4gYthwhUBOUKub4DLg3//+NwYOHAjHcTBkyJD9qv92Y2mBSERERERUH73++uu47bbbAACPPPIIbrjhhswGREREREREDd5vv/2Grl27YvPmzTjxxBOxcOFCZGdnZzosqgEmRhEREVG9J0sSHAgvscTx2s8FNaXK45i2642XSFCpbuWpyhQbtp8UVRi3YFjea0oSEFBlaIoMWZLgCu99GLYL2xUoMmyYroucoIaY6UCWpP2ictTXX3+N3r17Ix6Po3fv3pg4ceJ+2X9blqX9tgUiEREREVF9NGfOHFxzzTUAgP/7v//Dvffem+GIiIiIiIioodu2bRvy8vLwyy+/4IgjjsCSJUvQrFmzTIdFNdTwd9ton1q/fn2mQyAiokYooMpeMpSqwLC8ZKIsIaqU2OQKAdPxkpSCquKPW5ssx/Xb55VMigrrCkK6UibeoKYgSwjETAdR04FhuSiEhZyghohh+4lUDdXq1atx4YUXorCwEOeddx6mT58OTdt/KmEREREREVFmfPDBBxg8eDAcx8HVV1+Np556ar+pSktERERERJlRUFCA7t27Y/Xq1TjkkEOwdOlSHHjggZkOi2pBw91pIyIiokYjpCmQAOiqDFWWIAQQM50qjREzHQgBqLIEXZUhJcatTVFjT/u8ZFJUTkhFVkCtMIlLlrxKQzkhL1/dsFy/4lRyvIZow4YN6NatG7Zv345TTjkF7777LkKhUKbDIiIiIiKiBu6LL77AxRdfDNM00a9fP7z88stMiiIiIiIiohqJRqPo3bs3vv76a7Rs2RL5+flo27ZtpsOiWsLEKCIiIqr3ZFlCIFHlKZnMFDUdGHZ6iUOG7VVkAoCQnqwWpfgt9WqD6wo/nlgisSmsK37cexNQFYQTsSWTvgzbgeuKWotxX9m6dSvy8vLw66+/4phjjsGiRYuQk5OT6bCIiIiIiKiB+/7779GjRw8UFxfjggsuwFtvvQVVZVMEIiIiIiKqPtM0MWDAACxbtgw5OTlYvHgxjjnmmEyHRbWIiVFERETUIIQDXtJQUFcQ0LwpTGHMRsSw4Yryk4dcIRAxbBTGvPZ2AU1GMJFYlRyvtsQsBwKAabuwXQFJ2pOEla6QrkCSANsVMG0XAnuSrBqKZKnZ//3vfzjssMOwZMkStGzZMtNhERERERFRA7d+/Xp069YNO3bswJlnnok5c+YgGAxmOiwiIiIiImrAHMfBVVddhffeew+hUAgLFizAH/7wh0yHRbWMx2mIiIioQdAUGVkBFRHDRk5QQyEsGJaLqOkgZjnQFdlrkScBQngJSqbjIpkzFdBk5AQ1AEBWQIWm1G5+uGF7rfPiiapRAVWusH1eRWRJgq7IMGwXcduBrnpfZwVqNdQ6E4vF0Lt3b3zzzTd+qdlDDz0002EREREREVEDt3nzZuTl5WHjxo04/vjjsWDBAmRnZ2c6LCIiIiIiasCEELj++usxffp0aJqGWbNmoUuXLpkOi+oAE6OIiIiowcgOqHBcgbjlICeoIa44iJkObFfAsF0/OakkVZYQ0hW/UlRIV5AdqP0pULJqVbL1XXUTr5LJUMlxKqqGVd9YloWBAwemlJo96qijMh0WERERERE1cLt378aFF16INWvWoF27dliyZAkOOOCATIdFREREREQNmBACf/3rX/HKK69AlmVMmTIF3bt3z3RYVEeYGEVEREQNSm5IgyJLiBg2gpqX8GQmKiy5roAQgCQBsiwhqCrQ1T0JSlkBtU6SogD4lamSv1e1WlRS8rHS49Vnruti2LBhWLBgAYLBIObPn89Ss0REREREVGORSAS9evXCypUrceCBB2Lp0qU46KCDMh0WERERERE1cI899hieeuopAMArr7yCgQMHZjgiqktMjCIiIqIGJzugIqDKiBoOjETLuZIJUCVJAAKqgnBAqfX2eSmvIwEQexKbqlvpKflYcpxq5lftM0II3HLLLXjrrbegqireeecdnHPOOZkOi4iIiIiIGjjTNDFgwAB8+umnaNq0KZYsWYIOHTpkOiwiIiIiImrgXnjhBdx3330AgDFjxmD48OEZjojqGhOjiIiIqEHSFBm5YRmuqyJmOV77OVGiYpQkIaDKCGkKZLnus4tkSYID4b2WI2A5rt++ryrMRDvAZMzVrTy1rzzwwAN44YUXIEkS3njjDfTs2TPTIRERERERUQPnOA6uvPJKLFq0COFwGAsXLsSJJ56Y6bCIiIiIiKiBe/PNN3HTTTcB8PY3br/99gxHlBmuK+rF3tq+wsQoIiIiatBkWUJWQEVWILNxBFTZS4ZSFRiWC8N2kSVEWolNrhCIWw7iloOdEROuAHKDGlxXoFlYh+uKejkBHTNmDB555BEA3gmLyy67LMMRERERERFRQyeEwA033IC3334bmqZh9uzZ6NSpU6bDIiIiIiKiBm7u3LkYNmwYAOCWW27BQw89lNF4MsFyXL8bS5m+JwJw4B38jxj2PunGsq8wMYqIiIioFoQ0BRHDhq7KUGUJtisQMx1kBSqebtmOi6jpwHRcCAFETRu2I6DKEmRZgu0IOK7A9mLDn4AqklQvsvhfe+01jBw5EgDw6KOP4vrrr6/z1yQiIiIiov3fvffei5dffhmyLOOtt95Ct27dMh0SERERERE1cO+//z4GDRoEx3EwdOhQjB07FlI979hR24oNGxHD9q9N20XcduC6JfaaZAlBVYGuyojbDuK2t8+VXcleV0PQsKMnIiIiqidkWUJAVRC3HYQ0BUWGjajpQFW875cWSfy5f21a2FFswXUFwgEFhTETIU2FnagWVWxY2FoUh6rICOulxtvHWfyzZ8/GtddeCwAYOXIk7rnnnjp5HSIiIiIialz+8Y9/4PHHHwcAjB8/HgMGDMhwRERERERE1NAtX74cF198MUzTRL9+/fDqq69Clht+FaSqKIhZiFvenlTcdBCzHNhumZpRgCNgWC5UWUJIUxDUvaIArhDICWr7OOraw8QoIiIioloSDniJUUFdgem6MCwXhTEbYV0gpCt+W72iuIW45QIAYpaNgqiF4kSWvqbKUCQJliMQ1r3Jqmk7EAIIaAoM24VhOVAUKSNZ/EuXLsWll14K13VxzTXX4Mknn2x0pyqIiIiIiKj2vfLKK7jrrrsAAE8++aR/GIOIiIiIiKi6Vq5ciR49eiASiSAvLw9Tp06FqjauNJliw/aTogrjFozE/pQkAQFVhqbIkCUJrvAO4Bu2C9sVKDJsmK6LnKCGmOlAlqQGWzmqYUZNREREVA9pioysgIqIYSMnqKEQ3gQzmsi+1xUZtusiZnq9m3dHLBSblpfcBCArqKJZWIcsSQiqMjRVxo6IiXiislSRYUGTZdiul2gV1ktM5Wohi991RaVt+lZ+/SX69u0L0zTRv39/jB8/nklRRERERERUY2+//Tauu+46AMA999yDO+64I8MRERERERFRQ7dmzRp069YNu3fvRqdOnTB79mwEAoFMh7VPJTuNAKlJUWFdSTnQnxTUFGQJgZjpIGo6XgEAWMgJaomOJXKddSupS0yMIiIiIqpF2QEVjisQtxzkBDXEFQcx0ytJGjFsFMQsAEDEdGDaXsJTtq4iN0tDSPOmZkFNRpPEJDOkKZAAbC82YdoONFVGk4AGVwAhTYauKjXO4rccF1HDgWF7CVspEm36Vv73v+jXsycikQguuOACTJkyBYpStkUgERERERFRVSxevBhDhgyBEALXXXcdHn300UyHREREREREDdxvv/2Grl27YsuWLTjppJOwYMECZGVlZTqsfS5q7Gmfl0yKygmpCKgV7+/IkoSsgApVkVAYs2FYLuKKg6CmIGo4yA0zMYqIiIio0csNaVBkCRHDRlBTENQUmLaLbcVxaIqEuOVCuC40VUaLcABZwT1TsrCuICugwna8SlPJ8qW6IsG0AUWSENJlhDQVrgB01ZuAVjeLv9iw/dMCAGDaLuK2k9Kmb+Ovv+Cyvhdh9+5dOPX0M/DyG9NgQUHjOldBRERERES17dNPP8Ull1wCy7IwePBgvPDCC6xKS0RERERENbJt2zbk5eXhl19+wZFHHoklS5agWbNmmQ5rn3NdASNxQD+WaKUX1pVKk6JKCqgKwrrwuqKYXmKUYTtwXRWy3LDWbUyMIiIiIqoD2QEVAVX2KzGpioSAqkBXFAhhQpE1vx2eBC/BKaQrfvJSNNE+z7C9JCdNkdEiOwDHFTAtFyHNS2JyXeFPQKuaxV8Qs/y+0vFEuz/bTa0ZtW3LZgwd2Adbt2zGkccchwlTZiIrO7vKbfqIiIiIiIhKWrlyJXr16oVoNIoePXrgjTfeYFVaIiIiIiKqkYKCAnTv3h2rV6/GoYceiqVLl6J169aZDisjYpbXJcRMdBuRJCCkV23NFdIVf+/ItF3oqoyY5SCrki4l9VHDipaIiIgaJdcViFkODNuFK/ZUMpIlCQFVRkhT6mV2uqbIyA3LcF0V24sNqLKUeA+AqshoElQRVL2KUiXjd4WA6XglTeOJBKmQ7t23O2rCdgUs26s4FbcchEtNQNPJ4i82bD8pqmRfaUmCX12qcPcu3HBlf/z2y3oc0rYdxk+ZBSWcg8K4lXabPiIiIiIiotLWrFmDbt26Yffu3Tj77LMxc+ZM6Lqe6bCIiIiIiKgBi0aj6N27N77++mu0bNkS+fn5OOywwzIdVsYYdmKfKVE1KqDKkKtYoVeWJOiKDCPRbURXva+zGlhLEe5iERERUb1lOa5fcUmU/kMBOBCwHDfRKk5BOKCU2y4u02RZgqrIaBrWURi3IEsSgpqMJhVUW4pbDoQAbCeZxS95yVOSBE2RvXZ3jgNNlWE6LsLljFFZFn/yZwakJkWFdQUh3XudSCSCqy/rj9Xff4fWBx6IGXMXoNVBB1epTR8REREREVFpGzduRF5eHrZs2YKOHTti/vz5CIfLW9UQERERERGlxzRNDBgwAMuWLUNubi4WL16Mo48+OtNhZZQrvJ01N9EppLr7OMlkqOQ4yXEbEiZGERERUb1UbNh+8g7glfqM2w5ct0TFKFlCUFWgqzLitoO47SX+1FUFo5pUrqrKBNQslcWvl8ji11UvMUr4E9Dyx6gsiz9q7Gmfl0yKygmpfl9pwzAw/IrB+OqLFWjatBmmzZ6P9u0PB4C02/QRERERERGVtmPHDnTr1g3r16/HEUccgcWLF6Np06aZDouIiIiIiBowx3Fw5ZVX4r333kMoFMKCBQvwhz/8IdNhZVwyfyn5e1WrRSUlHys9XkPCxCgiIiLaJ6qSVFQQs/w2b3HT8SsfleEIGJYLVZYQ0hQEdQURw4YrBHIqqMZUndhUWULccmtUuaoqE9DkW92TRLXn3uRX6UxAy8vid10BI5FwFUv8jMO64idFOY6DG0dcjY/+9T7CWVmYMnM2jj3ueH/MdNr0ERERERERlVZUVISePXvi+++/x8EHH4ylS5eidevWmQ6LiIiIiIgaMCEE/vKXv+Dtt9+GpmmYPXs2zj777EyHVS9IEgCxJ7GpupWeko8lx6lmflVGMTGKiIiI6lRV2+G5EH7FpJJt3iQJfss2WZLgCu85w/bazRUZNkzXRU5QQ8x0IEvSXitHpRPb7qiJmOVAV2SEdQWuQLUqV1VlAioSf1ZeElXyqXQmoOVl8ccs772adrJNn9d2L/m6d956E+bPnQ1d1zFpyts49fQzy4xbWZs+IiIiIiKi0uLxOPr27YsVK1bggAMOQH5+Ptq2bZvpsIiIiIiIqAETQuDOO+/Eq6++ClmW8dZbb+HCCy9M69madAhpKGRJggPhvQ/H21MLakqVx0nu2SV/HtWtPJVJ3L0iIiKiOlPVdnjFhoVdUQthXYEjhJ8UFdYVhHSlzGQrqCnIEgIx00E00RauEBZygloi0UqusGVdOrFFTQcSAFWRURizsLUwDk2VEdZLTaHSqFxVlQmoJEmAEOUmUSUnoJI/Aa34519eFr9Rqk1fINGmTwiBh++/F29NngRZlvHihNdx7vl/Knfcytr0ERERERERlWTbNi677DJ88MEHyM7OxqJFi3DsscdmOiwiIiIiImrg/v73v+Ppp58GALzyyisYMGDAXp+p6mH+8jqENBQBVfb2olQFhuUVGsgSokqJTa4QMB1vXymY6DwSUBvez4OJUURERFQnqtMOz3ZcQJKwK2rCclxkBzTkhFS/zVt5ZElCVkCFqkgojNkwLBdxxWvxFjUc5IbLTtDSiS1q2oiZiXtsBxK8UwKO5SUCNQvrVapcVZUJqCwBDlAiiUogoMJ/LQAIKt7PRK9kQl5eFn8yyWpPmz7v+efHPoUXn3sGAPDUs+PQq0/fCscFym/TR0REREREVJLruhgxYgTmzJmDQCCAd999F6eddlqmwyIiIiIiogbu+eefx6hRowAAY8eOxfDhw8u9r2RlqKK4hYhhQ5KkPYfOE90+qtIhpKEIad4hfl2VvT041ys0UJXuHzHTgRCAKkvQVRlSYtyGpuH97REREVG9V2zYfuJRuu3wTMfF7qgFTZXgOgK2K5AdEJUmRZUUUBWEdYGo6SBmeolRhu3AddWUcqfpxOa4AobtIKAp2Bk1YCbu0RQNB2QFvOpPrkAw4MWWTuWqqkxAdVWG5Th+EpVpu3B1gbi1ZwKqJSagFVWdqiiLP5pI9irZpu+Nia/i0dEPAAAefOQxXH7l0L3+vMtr00dERERERJQkhMDIkSMxadIkKIqCt99+G+eff36mwyIiIiIiogbujTfewM033wwAePDBB3HbbbeVuad0ZaiS+0GG6e0T2a6AlOiQEdRkqIqcVoeQhkKWJQRUBXHbQUhTUGTYiJoOVEVKa+/NsB1/TymkJ/eZGmaLQSZGERERUa1KlhgFUieae2uHt7PYhBACUcNrz9YkoMEV3njplikN6Ypf/cm0XeiqjJi1J/ko3dgKY5Y3KRQOQqoCGRJUWYIsSYiaNrIDGqKmg4CamCgjncpVWtoT0KCmJP5sTxJVUczyq1oFExNQXZUrnIBWlMUfsxxA7ElsmjtrBu76v1sAALfdcReuv/m2tH7W5bXpIyIiIiIiSnrkkUfwzDPPAABee+019OnTJ7MBERERERFRgzdnzhy/OtStt96KBx98sMw9xYbt7wUBwO6oiV1RE26i64dlC68ylCYjrMnQFAlCAIrsddnYW4eQhiQc8PalgroC03W9g/0xG2FdlLtnB3gH75OFAAAgoMn+If1woOFViwKAhtf8j4iIiOq1qLGnRV0y8SgnpCIroFbYt1iWJKiKhCZBFYbtwrJdAF6buWQ7u3TIicx+wGt/BwBGop1curG5iaQqAIhb3kS3eZaO5lkBbzzLhZEYO1pObF7lKm9imIzdq1wl/AljUFcQ0Lw4C2O2f9qgvPeha15y17Ziw0v20mQ/kSqZoV9aZVn8yfcpyxKWfZCP26+/FkIIDL3mz7hrVNkFREXKa9NHREREREQEeG0tHnjAq0r7z3/+E1deeWWGIyIiIiIiooZu6dKlGDx4MBzHwbBhwzBmzBhIpfYmCmKWnxQVNx1sLYpjc0EchuViV8xCzHRguy5kyeui5zje3oymynBcQIK3J5Tc5zEsF4VxCwAQMWxYjouGRFNkv3hATlDz96aipoOdEROFMQtxy6usFbccFMYs7IyYKUlRyUpZWQE17UIG9U3DSmcjIiKies1NtKAD4FUmgleNKZ2SnK4AdFVBQJFh2o4/GTVtF64r0i7NqateNr+bqK6UTDhKN7a45ZVVtRInAiTJq+AkS5JXkcp0EDcdBFQFpuPCFaJMUlBllauyAioiho2coIZCeFWroqaDmOVAV2SvupMEyBJQFLdgOS4SbwWm60JJtCDMLmcCmk4Wf0CVYTkuVn75Of7vz1fBtm30HTAIjz01tswCoiIVtekjIiIiIiKaMmWK39bioYcewi233JLhiIiIiIiIqKH77LPP0LdvX5imiUsuuQSvvPIKZDl1X6LY8FrkAXu6hhTHbW/vQwjosoxAQEZWQIEkyTAT+0DFcRuW5iI7oCFmOZAkVNghpDhu79mHEgIi0aFDliQEVBkhrf61mssOqHBcgbjlICeoIa44iQQxAcN2UwoMJKmytyeW3GMK6UqDq5ZVUsONnIiIiOqdWCKpyCyRVFRRVaPSRCKBSdckSCbgCAHLdqGpMuKWg3CaE65kbk+yAFPy93RjSyb8xB1v8qyrsp/4FNQUxC3vedtxoSqJ2PTU2JIVnwzbawuYnCRnBao2AVVkCaYN5AZV2K4MQEq0yBMIaQriiQm6EN77Mh3Xf78VZfGHNAWff/EVhl8+APF4DOf8qRse/+dLZRYQlamoTR8RERERETVu8+bNw9ChQwEAt9xyi181ioiIiIiIqLpWrlyJnj17IhKJIC8vD2+99RZUNXVfxnJcv1JUMinKdQVUWUJWQEVRzIKuygjpir+n4+reXk3M7zJiITugIWo6CKhyokOIQNR0UBi3YNouLMdFsyw99cC8ABwIP4aAqiAcUOpVdaXckAZFlhAxbAQ1L+HJTOxhuW6JBC9ZQlBVoJc4DJ8VUBt0UhTAxCgiIiKqRcmknmQbu0CJpKK9SWbsK5IEVZYhhJecpKkyTMdFOM0YkolByZdN/p5ubMnqTCLxRcmJ656EJwdx20G24p0oCOtl46iochWQ/gS0WZaO7MCeilGG7UCC5I9dnSz+tWvX4NJL+qCwoABnnNUZT4+fBEt47ymdyl6VtekjIiIiIqLG66OPPsKgQYPgOA6uuuoqjB2bflVaIiIiIiKi8vz000/o1q0bdu/ejc6dO2P27NkIBAJl7osa3r5F3E9ySuwDyVKZDiFJsiQhrKtQZRlFiWQqTfH2SqKmg5yQl0i1o9hA1HSQG9KgKjIKYxZkWaowoSie2EOqbwlF2QEVAVVG1PBa5+mqnJIAVZIE1MsEr+qqP38LRERE1OCVbFsHoEqTJVkCHHiTR12VYdmun5zkisqfLclMJAslE3WSyU/pxla60pRXD2kPTZVg2IBI5CRVFFtFlauSqjIBjRo2bFegaViDlkjGqk4W/2+//YauXbti27atOOHEjnjz7VlAIOz1yI7ZCOsCIV2pIGFs7236iIiIiIiocfrqq6/Qu3dvxONx9OnTBxMmTKhSVVoiIiIiIqLSfv31V3Tt2hVbtmxBx44dsWDBAmRlZZW5z3UFjMSh+FiilV5YV2BV0iGkpGQlqZjpIG56iVGm47XKKzZsJIZBQdSEqsiAJCE3pKUO4ggYlusdXtcUBHUFEcOGK4Tf3aM+0BQZuWEZrqsiZjkNqiVgTTAxioiIiGpNmaSiKpwO1lUZluMgqCoohg3LceEkso5KJxVVxBXCb4UXVJPVjOQqxSZJAMSexCYXqS8uITXRSlQQXEWVq0pKdwLaMjsAR4gaZfFv374deXl52LBhA4466ii8u2Ahwrm5AIBCeCchoqaDmOVAV7zxq9qmj4iIiIiIGp/Vq1eje/fuKCoqwvnnn4/p06eXaWtBRERERERUFdu2bUvZ01i8eDGaNm1a7r0xy4GAt5eRrAwV0hUYUW+/qLwOIaUFNQVxy3vedlyoioydxSYEvAPzO6I24ALZQQmqAgQ1GZriJVq5wmujZyRev8iwYboucoIaYqYDWZLqVeUowDtsnxVQkVW2+NZ+qX799ImIiKhBK5NUlG5GE7xJZ9R0oCpeadPkJNYfNw0x04EQXjs5XfVqPYUSVY3SjS1ZuUqSJcDxJrMlW8yJRKJUMrGqotYQFVauckW1svBlSNXO4i8sLESPHj2wevVqHHLIIViyZAnaHnoQCmIW4paDnKCGuOL10bZdUe02fURERERE1Lhs2LABeXl52L59O0477TTMnTsXwWAw02EREREREVEDVlBQgAsvvBA//vgjDj30UOTn56N169YV3p/cz4gnqkYFEpWh9tYhpCRZkqArMoxEG7wggEiifV6xYcOyXaiyV1kqK6CiSakqUEFNQVaJzhuG5aIQFnKCGiKGjYAq85B5BnEni4iIiGqNLElwILzEnERSUcl+zXt71pt0ukhODeOOC9N2kZVGqzbD3tPmLaQnq0UpKYlJ6cSmK4nKVYoC0/Je39WFn9hk2d4MWpKTcZeNpbzKVbIEFEQtGLaDMilZAnDgxeRNkCvu21zVLP54PI6LL74YX375JVq0aIH8/Hy0bdsWAJAb0qDIEiKGjaDmJTxVt00fERERERE1Llu3bkVeXh5+++03HHvssXjvvffQpEmTTIdFREREREQNWDQaxUUXXYRvvvkGLVu2xNKlS3HYYYdV+kzyILxbqjLU3jqElKapEgwbEG6iCpUQMCwHpuXt92QHFYR1tcKOJLLk7d+oioTCmA3DchFXHK8wgOEgN8zEqEzhbhYRERHVmoAqewlHqgLD8qoOZQmRdku9sK4gZjmQZQm6qiCgyCiKWwioXinS8sZxS2TgA16bt2TCU7hEQlW6sSUrV2mqDFWWYLsCcctBWFfLTXgqr6Vd6cpVUdNJiX9vyUfxxImEmiYf2baNwYMH48MPP0STJk2waNEiHHPMMSn3ZAdUBFS5Rm36iIiIiIiocSkoKED37t3xv//9D23btsWSJUvQokWLTIdFREREREQNmGma6N+/Pz7++GPk5uZiyZIlOOqoo/b6XJnKUFLywHzlHUJKkxIVpWzX9fZuZAlxy/EP2if3nso7MF9SQFUQ1gWiptepI6gpMGwHrquW2zGE6h4To4iIiKjWhDQFEcOGXiKpKGZ6CT7pUBUZsuRNXnODKhRFgmm5cFxgZ8SErnhJO1LiHtN2YTquP9kNaDJyEuVLswJqSvJOurHJiWQmw/YmusWGjZjp+M8IIaDKElTFi6N01anSlasK4xYgAFlXEDcdxCyvXV0ZjoBhuV67Ok1BUPfidYXw31NVuK6L4cOH491330UgEMC8efNw6qmnlnuvpsjVbtNHRERERESNSzQaRe/evfHNN9+gVatWyM/PxyGHHJLpsIiIiIiIqAFzHAdDhgzBokWLEA6HsWDBApx88slpPVumMlRi02hvHUJKE4mKUpYjoMgSHNsFJC9RqomuVXpgvrRQohCA7QqYtgtdlRGz0t8vo9rFnzoRERHVGlmWEFAVxG0HIU1BkWEjajpQFanSLPwkw3YASAhoCrTkMzqgKl5SkmG7fq/oklRZQkjfk60f0pUylZaqEltIV2DYLgKaAtN1YVoudhSbcIRAQJUR1L2xdUX2J9DlVa5yXC/ZqVlYQ2HcgpEotypJ8PtJy5JXDctyvPdmuwJFhg3TdZET1BAzHciSVKXKUUII3HbbbZg8eTIURcGMGTNw3nnn7fW5qrbpIyIiIiKixsWyLAwcOBDLli1Dbm4uFi9ejCOPPDLTYRERwTRNLFu2DOvXr8e2bdvQvHlzHHrooTjvvPMQDoczHR4RERFVQgiB6667DjNmzICmaZg9ezbOPvvstJ+XJQkOhHewO1EZKlnhqaIOIeWxbC8xynG9xChTuBCOd6hfV+QKD8xXFJOueIfw44luHYbtcv8lQ5gYRURERLUqHPCSj4K6l1RkWC4KYzbCukBIV9Jqh3dAtg5FkhA1HTTN0qAp8l7bzyVV1n4u3dg0RUZY9ybMWbqKmGkgYtoAAAEgmEjOCusy4pZTbuWqkKZgd9TyxrEcPykqrCvl/hyCmoKsEj8Hw3JRCAs5QQ0Rw/YTqQCvT3ZllZ2efOwRPPfccwCASZMmoXfv3tX5qyQiIiIiIvK5rouhQ4di4cKFCIVCmD9/ftonuIlo/yBVUF1hb5588knccccdtRyNJxKJ4IEHHsCkSZOwc+fOMn+enZ2NQYMG4YknnmDLTyIionpICIE77rgDEyZMgCzLmDp1Krp161alMQKq7CVDqQoMyzuEniVEpR1C9FIH5l0hYDrePo6qeHMe4QjEbRdZARVBPVEtqsSB+b1Jvrab6CKSrGRF+x4To4iIiKhWaYqMrICKiGEjJ6ihEF6lpGiijVxV2uE1y9IhQ4KRyKavqDyphETP5oCS0j6vJrEpsgTTcVAcd6BIXiUlIbwJdtxyYNkCccuFEF5xVSkxfk7IS8wqjtsIaYqf4AUAOSG10spZcuJ1VEVCYcyGYbmIK17/6ajhIBwAooYDw3ZQZvosAAcCL77wHEaPHg0AeOafz2LIkCFp/K0RERERERFVTAiBm2++GVOnToWqqnjnnXfQpUuXTIdFRI3cjz/+iN69e+Onn36q8J7i4mJMnDgRCxcuxKxZs9CpU6d9GCERERHtzaOPPooxY8YAAF599VX079+/ymOENAURw4ZeojJUzPTa1pXXIaQobiOkCwS1PYfY45YDIUTiefiH4gEgqMr+3k5Y33u1qKRk/lRy/4t5UZnDxCgiIiKqddkBFU6iJGlOUENccRAznSq3w0smSLmumlIhyXEEDNuB5Qq/5Z7luiiKe63uQprilUytYWy6oiCoCVi2i+ygV8WqKG7BEQKq4m0OyBIgyRKCigJNleG4wPYiA0IIHJAdQFHcqzQV1pW02gkCiSQvXXgJW6aXGLUzYiBq7nlf5VXQevedaRh1l3cC86/3PYBLh41AsWFXqQ0fERERERFRaffffz/GjRsHSZLw5ptvokePHpkOiYgyrFWrVmjSpEla9zZr1qzWX3/btm3o2bMn1q1b53/vyCOPxGWXXYZDDz0UmzdvxjvvvIP//Oc/AIDNmzejd+/eWL58OY444ohaj4eIiIiq7rnnnsP9998PAHjmmWdw9dVXV2scWfb2ieK2g5CmoMiwETUdqIn9o2SHkCYBDUWwYFouYqaDuOX4h+0jhp04kC6hKO5AThygV2UZ4cQeS1hXoFZyOL+0ZCJUMkFqb4Wm9tYtpLK9L6ocd8mIiIioTuSGNCiyhIhh+72cq9sOT5a9Skq66iJqOHBdBwFNQclWzI4r4MDrHe21nqu4glRVYssNhSBJwI4iEwUxE0FdQTM9ANvZc7/rCMRcG6YjISeoQ1ElmLbA1kIDluv6pxKqIqQriFlewtaOYgOJSquQJcn/fkkfLF6Ae269AQBw1YgbcP2tdwLwJvOuEH6SGRERERERUVU8/fTTePTRRwEAL774IgYPHpzhiIioPnjiiScwbNiwjL3+DTfckJIUdeutt2LMmDGQ5T2fA40aNQpPPvkk7rrrLgghsGPHDlxxxRX4/PPPMxEyERERlfDGG2/glltuAQA89NBDuPXWW2s0XjjgJUYFda8ylGG5KIzZCOsCIV2BIwQMy0WTgAZDcRA3HZiOi6hpIW55XT90VYGuyJAgkOXvUUmwHBdNQ3qJ76UnWXEqmcxUUQs+y3H32i0knb0vqhgTo4iIiKjOZAdUA2BFaAABAABJREFUBFTZn9DVpB1esWEjYtj+9d6SrOK2g7jtlEmyqk5sRXEb4YCC5llZKDYcFMYtWIn2f162vtdGL6B6k+vCiA1VkWA6XllWXU2/53SSLEnQFRm7oiYcIdAkoGFn1PSrTkmS19ZPU2Qs//jfuPOG4XAcBxcPvAwj738ExaYDK5EQFTMdyJLEylFERERERFQlEydOxB13eFVpH3vsMVx33XUZjoiICPjiiy8wc+ZM/7pHjx545plnyr33zjvvxNq1azF+/HgAwIoVK/DOO+9Uq00PERER1Y7Zs2f71aFuu+02PPDAAzUeU1NkZAVURAwbOUENhbBgWK7XmcNyoCsyFAmIWV6ykiLLcC0XjhDQZAmaqiA7oECSJRwUCkFTFFi2i8K4BUWWEA5U7fC7KwRMJ9mKz3s2UM4eVG3vfVH5+JMiIiKiOqUpMnLDcpl2eFUpAVoQ25OxH09MYktXTAIAOF7GvypLCGkKgrpSacWkdGKzHRdZAa/PdGGijV5WQE1JTJIlCa7wMvYN24XluIhbAqbtJUU5rkDEsKt8mkCWgJjpQFMkFBsWbEf4ZV9DuhfTf77+CtcMGQTTMNDjot547sXxsFwJUdPxTkTAQk5QS5wkkHmKgIiIiIiI0jJr1iyMGDECgJdYcNddd2U4IiIiT+kkqDFjxlR6/2OPPYY33ngDsVjMf56JUURERJmRn5+PSy+9FK7r4uqrr8bTTz8NqYoHyyuSHVDhuAJxy0FOUENccRAzvf0kI1m9KZEcZdkuVEVCU01DUFf8Q+khzduD2RU1kR1UoSkSIEmImU6V9nhipgMhAFWWoKsypMTYJdXV3heVxcQoIiIi2ieS7fCyAnu/t6Riw/YnhoVxL8MfQKWJSbYrUGTYMF03rYpJFcVmOS52Rkw/KSr52iUTk0oKagqyhEDMdBAxbBiWA8v1JqZR00FAlavUfzpuJybElgtFliBLEnJCqj9B/9+Pq3F5/4sRKS5Gl3P/iBcnvAFd06ADUBUJhTEbhuUirjgIagqihoPcMBOjiIiIiIiockuXLsVll10G13Vx7bXX4oknnqi1zQoiopqwLAsLFizwr8855xwcc8wxlT7TrFkz9O/fH2+++SYA4NNPP8XWrVvRqlWrOo2ViIiIUn322Wfo27cvTNNE//798fLLL6e0wa0NuSENiiwhYtgIagqCmpJShUmVvf0dCfDb1rkCEALICihoEtQQUGXvOcdFXJFRZNiImg5URfL3Zypj2A6ipre/E9KT1aJSiwPsi70v2oM7Y0RERFRvJXsmAyiTmNQ8S0eToIag5pUPDWrehLV5lo5wYqJpWF6ZUwCIGDasRNnSdEWNPZn6ydfOCanICqgVtsaTJS/JqklQgyQBpu0gbnnvITkRToeb6HcNeJNowOuRnZx0b/jlFwzu2ws7d+7AyaeciklvvY1gMOg/n6wsBXgnE5LjuOWdNiAiIiIiIkpYvny5v1kxcOBAvPTSS0yKIqJ64+OPP0ZBQYF/3a1bt7Sey8vL8792XRcLFy6s9diIiIioYt9++y169uyJaDSKbt26YcqUKVDVuknoyQ6oaJ6lI6h6CVC6KiMnqKFpWEezLB1Nwzpyw97vzcI6DsoN4cjW2Wh7QBaaZ+lem7qgF1tQVxDQvLSawpjtV2oqjyu87iGFMW9PKKB5e1cAUlrxZXrvqzFi6hgRERHVWxUlJlWWkZ9MTKppxSTXFX5CUiyRtR8uUU61MrLkTbRDARVWzEKRYaNJSIfpeK36KkqqKimeaO1nuwIuAEmS/Envtq1bMLhvL/y+aROOOuZYvPXOXGQ3aVJmjJCu+KVXk239YlbVyr0SEREREVHjsWrVKvTs2RORSATdunXD5MmToSh7XwMREe0r3377bcr1WWedldZznTt3TrleuXJlrcVERERElfvpp5/QrVs37N69G507d8asWbMQCFSxvUgVaYqM3LAM11URS+y3uEJACK8qkyxJCKgyQlpqJaeSz2cFVEQMGzlBDYXwEpiiiZZ3uiJ7LfIkr9qUabswHRfJnKmAJvtt7rICKrQS3UQyuffVWHFXjIiIiOqlmiQmAcmKScKbpJre5NCrmKSWO8ktLWY5EPAms7YrIEl7Sp4m44tbTiLZCSUm04DtCLiuQG5QQ1HMQsxyYNoOdFVB3HIQ1vc+BYtbjl8eNagkTgaoCgp278all/TBz+vW4pDDDsP02fPQvPkB5Y4hSxJ0RYaRKBOrq97XVW1nSERERERE+79169ahW7du2LVrFzp16rRPNiuIqOGaMmUKJk6ciNWrV2P37t3Izs5GixYt8Ic//AHnn38+Lr/8cuTk5NT66/7www8p10cccURaz7Vr1w6KosBxvM+Yvv/++1qPjYiIiMr69ddf0bVrV2zduhUnn3wyFixYgKysrH32+rLsJRRVZ18kO6DCSewF5QQ1xBVvv8l2BQzb278pTZUlhHTFrxQV0pWUVneZ3vtqrJgYRURERPuc64q9ZujvLTEpHTWpmJSc0MYTE9SA6vVzthwXMdOBabsoUyxVAA68cqkFMROqIkNVJFiOQEHMQssmXi/rsL732KOm4/1cAKiKBF2R4FoGrhx8Cb7770q0bNUaM+YsRJuDDq50nGQyVLKFXkUlXomIiIiIqPH6/fffkZeXh99//x0nnnjiPt+sIKKGZ+nSpSnXu3btwq5du/DTTz/h7bffxt1334277roLd911F2S59ioYrFu3zv9almUccsghaT2nqiratGmD3377rcw4REREVDe2bt2KvLw8bNiwAUcddRQWL16Mpk2bZjqsKskNaVBkCRHDRlDzEp7MxGF01y2xvyVLCKreIfekrICakhQF7P1QfjrYLaTq+JMhIiKifcZyXEQNB4btVJBUJPzeylHTgaZIZRKTqqImFZOSCUTJhCJNkf24/Pdju4g7DkSJya8kSwgqXunVwpiF4riDoriFmOElOoUDqt8XuqL3Y9iO/zrJ3tWy6+DPw67EiuWfITe3KabPnof2HTrs9X0kXyKZD8W8KCIiIiIiKmnnzp3o1q0b1q1bhw4dOmDx4sVo1qxZpsMiogYgKysLzZs3h2VZ2LFjByzL8v+soKAA9957L/71r39h7ty5CIVCtfKahYWF/tdNmjSBqqa/zdWsWTM/MaqoqKjGsWzduhXbtm2r0jNr1qyp8esSERE1BLt378aFF16IH3/8EYcddhiWLl2KVq1aZTqsaskOqAiosr+/patySgJUSRISVZ0CSkr7vKSKDuVXBbuFVB0To4iIiKjOlKwMVRS3EDEcv90c4E0QBVBuRn3MclBsCFiOA00pfwKZjupWTCqdSFRs2P7XhuUgnsjGL822HOyyTFi2A9MRXms9V6DYtBCKK7BdgbCuIGp6PajDugI18d5cIRAzvaQoCYCuyRCuQNy0Mer2m/BB/mKEQiG8OWMWjjvhxCq9j+S8uorzayIiIiIi2o8VFxejV69eWLVqFdq0aYP8/Hy0adMm02ERUT2l6zr69u2Lfv364eyzz8ahhx7q/5lpmlixYgXGjx+PKVOmQCQ+kMjPz8eQIUMwc+ZMSLXwoURxcbH/dTAYrNKzJZOzSo5TXePGjcPo0aNrPA4REdH+JhqN4qKLLsJ//vMftGrVCvn5+SnzhoZIU2TkhmW4rrrXjiiVtbQr71B+dbBbSNUwMYqIiIhqXenKUEVxC3HLy4I3LAfxRA9mCYCWmCiqigw4AoblQpUlxE0HWiIDX1UEckNatWKpbsUkSfImpnHLwfZiA7IkQVNlREwbtu1CU2QENK/yk6bIkCEhYtqImC4s14WQJBi2g2LDhisETMvBjmITRsCBqkgIaV4CWFHcQkhXoMoyTMf14wvqCoKqgqK4iecfuQcL5s6CpmmY+OZ0nH5mp7Tfv5k4fZCciFf15AEREREREe2fDMPAJZdcguXLl6N58+bIz89H+/btMx0WEdVjv/32G1q2bFnun+m6ji5duqBLly644oor0L9/f0SjUQDArFmzMHPmTAwcOLDGMcTj8ZTXrIpAYE8ZhVgsVuNYiIiIqCzTNHHJJZfgk08+QW5uLpYsWYKjjjoq02HVGlmWkBVQq12dqfReVXX3bNgtpGpqr7EzEREREbzKSjsjJuKJpKjdERPbig0Uxkxs2h3D5t0x7I5bsB0BPZEcJAAoEhDUZEiSl8yzI2Lg990xFMYtbCmM47edUeyOmoiadpUy36tTMclyXBTHvfcRMWwUGzbitovCuOUndXnDSoCQoEgSDMeF4wpk6SqCqgLbceEIL7Gq2HCgKyoEBCxHoDBmYUexiR3FJoriNrYWGtgZMSEEoMoSmgRVHJDlfbg36Z+PY/bU1yFJEp57eSLO75qX9nt3hYDpeIlRQdXrUR2ooLwrERERERE1Ho7j4IorrkB+fj6ysrKwcOFCHH/88ZkOi4jquYqSokrr3r07Jk6cmPK9hx9+uFZiKFklyjTNKj1rGIb/dW219iMiIqI9kuuMxYsXIxwOY+HChejYsWOmw6pXSu9VVbfSE7uFVA0rRhEREVGtKYhZiFteX+S46aAobmFHxPuQKmI6MBM9k4OKDFkGHMeFJivQVBmOACRXQJUlRA0bhuXAcgVs14Uqy9gVMxHSFViOKLcNXUWqWjGp2LARMWyIRAlUM1H9anfEgqwAMiTkhFRoigwJgGE72B3z3mNIU/z3qSoyQhoQ1xVojouwriCoKcjSFQQ1FXHHgZX4eWQHFLgQ0GQJTRMJUa4QePn5f+Ll58YAAB54/Bnk9epbpb+PmOn4yVa66sUb0pQqjUFERERERPsXIQSuu+46vPPOO9B1HXPnzsWZZ56Z6bCIaD8zePBgjBkzBitWrAAArFq1CuvXr0e7du1qNG52drb/dcnqUekoWSWq5DjVdcMNN1S5CtaaNWvQt2/fGr82ERFRfSOEwJ///GfMnDkTuq5jzpw56Ny5c6bDqndkSYID4e1ZOQKW4yJYjX0bdgupGiZGERERUa0oNmw/KaowbsGwXBQbDiTJmxBrioSAoiEcUPyqULYrUGzYMF0XiiQhZjoI6QrCuoqsgIpNBXGYtgMhvMQeTZHQMjsIVfF6Jxu2l3CUFSh/SlPVikklE7sggN0RA4UxC64QiJo2VEVCTkiDK7z2gKosQ5EAI/EaEcNBMk8rmKiG5QoB2wGyAzJ0VUFWQEFuSIfpuIiZ3mvJsoTsgAbLFXAcF1kBDdPefA2Pjx4FALj7gb9hwBVDETW9NnwBde+TZMN2EE2MH9KT773y3tZERERERLR/E0LgzjvvxIQJEyDLMqZNm4YLLrgg02ER0X7qkksu8ROjAOCzzz6rcWJUTk6O/3VxcTFs24aqprfVtXv3bv/rJk2a1CgOAGjVqhVatWpV43GIiIgaOiEERo4ciYkTJ0KWZUydOhV5eel3v2hMAqrsJUOpCgzL2+fKEqJKiU3sFlJ1TIwiIiKiGrMcFxHDhusKbCsyUGxYsF0Bw3IR0GRETQeyJKFJSEV2UAMAuLrXZi5mOtgVsSAgkK2rKIhZiJq2315PkiQYpgNZBnYWe8lIuiIjqCsIqAqiiapI2cGy05qqVEwqL7HLdL1apAFNhm7LkCUgO6BBlrz3bLsuCg3vGVWRELMcBFQZB2QFIEkSig0LuipDVQQgeS3ycsM6FElCKBF/YcxrK+i4AjlBFSFdxZIFc3D9X/4CALjptpG4beQdfkyFMRthXSCkK+VOlF0hEDP3JEUFNNk/bRAOsFoUEREREVFj9vjjj+Ppp58GALz66qvo169fhiMiov3Z0UcfnXK9devWGo/Zvn17/2vHcbBx40a0bdt2r8/Zto1Nmzb514cffniNYyEiIiLPI488grFjxwIAJkyYgEsuuSTDEdVfIU1BxLC9vSNZgu16ezoVFQAoD7uFVB0To4iIiAiuKxCzHBi2CzfRQk6SvNKbAVVGSKu80lBBzEJhzEJR3EJR3AYAqIoMXQUsR8CwXUjwMtYFvAmaqsgI6yose0+LvV22AUCCpshoElTRPCuA3TELmuxN7BxXIGLYkIMaiuM2LM1FdkBDzPIqU5WcOFalYlIysQvYkxQFANkBFRKAqOXAcgSEEIiYFhRJgqJIMCwHu6MWJAAuBMIBFW6i/Z6VzNbXFAjhvUbyZ6oqEpqGvZZ5TYKqVwlKlhAOqMhfsgRDrrgCQgiMGDECf3/sMURNBzlBDYXwYouaDmKW105QV+VEVS6vCpfpuH5v6YAmIyeRiJYV8Nr/ERERERFR4/TSSy/h3nvvBQCMGTMGV199dYYjIqL9XSgUSrmORqM1HvO4445LuV6zZk1aiVHr16+H4zgVjkNERETV8+yzz+KBBx4AADzzzDMYNmxYZgOq52TZ6woStx2ENAVFhs1uIfsAE6OIiIgaMctxETUcGLYDUfoPBeBA+ElDAVVBOKCUSa4pjFnYUhiHEF6Wuu0ISDIQi5uwbYGYZcN0gZyACkmSvOQd20VIV6ArMmzXSx7aGTHhugLZQRWqLCEnqMENCBTFLRiJOFRZQkHMBAAosgRXeJO+7ICGqOlVa5JlqcoVk6KJqk9x0/GTonJCKpTERLIwZgLCq8YUt7yfVDJRS5aA4riDmG2jKG4jJ6TBcV00CWrQVRlZugrTcaHIkl/hyS3xww7pCmKWA9sV+OyzzzBsyGBYloVBgwbhxRdfhKIocAUQt7zkqLjiVdmyXeG3EyxNlb2KVMn3HdIVZFfhtAER7V++++47rFy5Eps2bYKiKDj44INx2mmnpZy0JiIiov3btGnTcMMNNwAARo0ahdtvvz3DERFRY7Bly5aU6xYtWtR4zI4dO6Zcf/bZZ2m1BP30009Trk888cQax0JERNTYvf7667j11lsBAKNHj/a/psqFA15iVFBXYLouu4XsA9whIyIiaqSKDduvkgR41YbitgPXLVExSpYQVBXoqoy47SBue+U8k0k2BTELOyMGhACK4xZ2RUw4QiAnpMGyBRwhYCR+j1mOVzVK88aLmQ6KXK81niQBtutVOgooClRFwq6oCUWWoSkyHMOGLiuADAhXwHa9Nny7ohbCuoIDsh2EdQ1bCh0EEhWagPQqJrmugJGoWBVLtNILJ9rcFce9a8NyYbkusnQVluN6rQJtgYjp/byKTduLH4AjBIrjDnKCKrJ07+cU1GS4Lvy4RInEKFmSoCsyVq5cieGDL0EsGsUFed0wefJkKIo3mc0NaVBkCRHDRlDzEp729veVVPLvi4gal5kzZ+Jvf/sbVq5cWe6fd+7cGY8++ij++Mc/7tvAEsaNG4cbb7wx5XsPPvggHnrooYzEQ0REtL9auHAhrrzySgghcOONN+Lhhx/OdEhE1Eh8/PHHKde1cTjj7LPPRk5ODgoLCwEAS5YswahRo/b6XH5+vv+1LMvo2bNnjWMhIiJqzGbNmoXhw4cDAG6//Xbcf//9GY6o4dAUGVkBFRHDZreQfYQ/ISIiokaoIGb5SVFx08GuiImCmDfxshwv8chyBAzLRUHMS3iKJ7LQI4aNwriFYsNG3HJg2i6KDAs7oxZsIaCrMkK6V12qSUBDKFFlSpEBWwhETBvFpg1XCBQb3iTPslwokoyAKiOaqLwUNWwIIaAqMizXRcS0IVwvycpMJDDJkvdeftkex7YiA8WGA8cVUGUJTYKqPzGsrGJSzPKqZZm2C9sVkKQ95UcjpuX3dpYlCYWGBdNxoasKdM2blAISJACWJWAnWgaGAwriiUlsSFcQTiRIJZP8Syf7b9rwM/4ypD8KC3bj9DPPwoTJU6Hreso92QEVzbN0BFUFEgBd9Sa+TcM6mmXpaBrWkZOoUiUBCKoKmmfpTIoiaoQcx8HVV1+NgQMHVpgUBXgnpi+44AK/1PW+9Ouvv+Luu+/e569LRETU2Cxbtgz9+/eHbdu4/PLL8eyzz0Iq5/QxEVFt27ZtG6ZNm+Zfh0IhdOnSpcbj6rqOXr16+dfLli3D6tWrK31m165deOedd/zrTp06oXXr1jWOhYiIqLFasmQJLr30Uriui+HDh+Ppp5/mOqOKsgOqX/EpJ6ihSaKbihCAYbsoitsojHn7ZYbtJUVVZe+LUjExioiIqJFJJjTh/9m773jLqvrg/59V9t6n3DIzIKDGrjFGUWPU6GNPBEXUiBEU7N3wRB9UUjQmtmAssStGFMQSG2JDUMDHXyTRJ3l80hSjIagEolKn3HvKLqv8/lj7nLl36p1hZu7cme/79eJ159w5e5+1zznAWnt9C7BQNixWbhoQ1Mk0sx3LfDdNwjrZpJpTZLENiILUPu/GhRKALWVD3QRCiHQyw5GzBTNFRmFT5afCGHq5YabIppO8xgU2jWtijAwqR+UDhVX4ECnbtnZj51ksHYOqIdMaYxQ+RoxS5JkBFBGIMQKRsnE0IbXTW9/Pp6/VL7ZOEndk0oqubKtGFVajVarO1LR/N3aBECO51tNI/bluxoaZgg2zGfO9jJmOJc804yZQNh5FCvSCFHQFoNrWfEtbPf/yFz/nWU97MjffeAP3/PX78MnPfZFer7/DsWZGM9/LOHKmYKbNApi06DNakRnNTGE5cqZgvpdJloAQh6lXvvKVnH/++dPHvV6PF7/4xXzwgx/k3e9+N894xjPIsvTfxRACb37zm3n3u999QMd4+umns7i4eEBfUwghhDjc/Mu//AtPfOITKcuSE088kfPPPx+tZY0ghNhzTdPgnNv9E1vOOZ773Ocum/M//elPp9Pp7PD5f/u3f4tSavrP8573vF2e/4wzzlj2+FWvetUun/+a17yG8Xi80+OFEEIIsXLf/e53Oemkk2iahqc97Wmcc845EhS1l+a7Gf1i0nnEsL6fM9/NKDJNZhRWKzKjKDLNfDfbo70vsZyEjwkhhBCHkcaHaaWohTJViILUOm5HfYs7maG/pG9x1QQWaKCNWI8hTs/RL9Lxtr3RnibCEa0VBPAh0i9SxPugcoxKT5FpGp9awWUmBWAZpRhVniYEfIgsjhsiik6m6ViNT3FQGA3WGGJ6eXJrsEozqh3rezmFTVWrdhccFNraoyGkn5nRND5Ve8qMZvO4grY8aWYVt5ntoIDaRRpfEYLC5SmwzPtIplM1p6jCtP1dBIxSdNrWeHk7po0bb+HpJz2J/772v7jjne/KRz/zRdatX79dRaltaa3oF5Z+sevnCSEOPxdffDHvf//7p49//dd/nW984xvc4Q53WPa8f/u3f+MJT3gCv/jFLwA488wzeexjH8uxxx6738f42c9+lq997WsA3Ote9+JHP/rRfn9NIYQQ4nBz1VVX8bjHPY6FhQUe+chHcsEFF0wDo4UQYk/9/Oc/57GPfSx/+Id/yCmnnML69et3+tz//M//5EUvehFXXHHF9He9Xo83vvGN+2w8D37wg3nqU5/KF7/4RQC+/vWv88pXvpJ3vvOd2wWA/tVf/RXnnHPO9PFv/uZv8nu/93v7bCxCCCHE4WRyT3E0GvG4xz2OT33qU5h232NHQoiMG0/VJp/HmDpqaKUorKabmbSHdBibKWzqplJ5KufJbUrO3xEFK977EstJYJQQQghxGBm11ZjKNsgJYK5rKezOJ65apSAcaxQLY8e48riQ2sltHNUoUrlO51MbvkmgUW40zgcKq6mdp/Fp4psZTSczDErXjkHReE+MaRI3rBtiUIRIiog3GqUU3TwFVc1lltwqqsZT+4A1ULnIqHas62bESBtRv/NrWmrSk3nyUyvFuG0bSEzVraxRzBYWrRW1C3QzQydTzHUyXAhorbBG4VykkxuU2trz2YdICDDftWSTNneZYTgY8MynPYWrfvwjjjrmtpzzmS9x9DHHTMcghBB7KoTAa17zmunjXq/HRRddtF1QFMD97nc/LrjgAh7xiEcQQiCEwGtf+1ouuuii/TrGW265hVe84hUAdDod3ve+93Hcccft19cUQgghDjfXXXcdxx13HDfddBMPeMAD+OpXv0q3213tYQkh1rif/OQnvOxlL+PlL385D33oQ7n//e/PXe5yF+bm5nDO8ctf/pK///u/51vf+hYhhOlx1lo+//nPc8c73nGfjudDH/oQ//zP/8w111wDwHve8x4uueQSTj31VH7lV36FG264gQsvvJB/+Zd/mR6zYcMGPv3pT0tVCyGEEGIvXHXVVRx//PFs2bKFhz3sYVx44YUUxY6ztxsfpoE+cdu/jOCJ00R+CfSZdAvRhGAlkGw/kcAoIYQQ4jARQqRq28WN21Z6vdzsMihqqcIaennklkFF7QIKxbgJaJ0CfUYxgo80PlJYKDLNuFFYDVZrXAhUbVDRpMWcj5EYI5UL078f1YFurpnNLTEqyiagSRWXlErBUlm0dHNLF8iMI4wbOsZQZIZOZimbsOLAqLaw1bRKk/Nh2vouBV6ldnVGKYZ1akNo27Z1mdFtkJhmVIOLAatTEFnjA4tlg1ap5V+IhoVxjTWauqo4/bmn8C//9P9Yt349H/6bL3L7O9yJTvtZFDvJBhBCiF353//7f/ODH/xg+vgVr3gFd73rXXf6/P/xP/4HJ598Mp/73OcA+NrXvsbVV1/N3e9+9/02xle+8pXcdNNNALzuda/br68lhBBCHI5uuukmjj/+eK699lruec978o1vfIP5+fnVHpYQ4hDSNA1XXHHFsopQO3O7292O888/f78kQxx11FFccsklPOlJT+InP/kJkDZsd1aZ6uijj+bCCy/kV3/1V/f5WIQQQohD3bXXXstjH/tYbrzxRu5///vzta99jX6/v8PnDio37VwCKYm8dJ4QlgT6aEXHGnKrKZ2ndJ5+YZkpDu/wFekWsv/IrpsQQghxmBg3KTK/dgEXUuu3br6y4KGJbm5oQsSFyKBuiDGSa41WahrUU7eR7Fqpacu4SdnPsvHULqSWeyZFItXeUXvP5qFjWHlyo1BA5TwbRxVNW5HJx4hC0fjIQtmwOG6mgUtAmjzXHqXSsZPWeLszqc40ibIflKn1XdO+T908BXLlVpO11zGoHOPGk1mFUqnPcwwpAKoJgcxqGhfYPGpYLNNzR42n8REdA2ee/gL+4e+/Ta8/w7vO+xwbbn9Xxu3YFdBdYVCXEEIs9aUvfWnZ4xe96EW7PebFL37xssdf/vKX9+WQlrnsssv45Cc/CaQWf3/0R3+0315LCCGEOBwtLCxwwgkn8OMf/5g73OEOXHbZZdzmNrdZ7WEJIQ4BGzZs4PTTT+fe9773dq3qduRud7sbb3vb2/jhD3+4XyvE3ute9+Lf/u3feOUrX7nT9n79fp/nPe95/OAHP+BhD3vYfhuLEEIIcai68cYbOe6447juuuu45z3vyaWXXsq6det2+Nwt42YaFFXWnk3Dmi3jhqpJHUdcSMn1VRPYMm7YNKwp2w4ew8qxUDYH6rLEYebwDrkTQgghDiNVWwWpbKtGFVbvccs23QYBNUBZh2mvY6XAGo3VChciZePp5ZZOpqmcp7AaFwy18wxrh48GaxSVA+ciw7atXje3bfs5CFajlaabG+Y6FqUU/dwQSdWYXIy4yuF8bLMKAouVY76XE0mBYP0VZBcUVtP4QMcaqiawWDtmCkvpt1bVmrTXm8ktAxxV49kyanBtFa4QU7BW6TzOp+pXwUMd0vtwRCdnXDuMgte/9lV869KLybKcv/jg+dzxV+9LBLSGzaOG9f1cSqEKIfbKxRdfPP3z3e52N+52t7vt9phHPOIRdDodyrIEUtWoM888c5+PbTgc8tKXvhQApRQf/vCHybJsn7+OEEIIcbgaj8c8+clP5p/+6Z848sgjufzyy/d52yohxOFrbm6OD37wg0Ca2//gBz/gmmuu4frrr2c4HGKMYX5+nmOOOYYHP/jB3P72t9+j8z/60Y8mxpUluG2r3+/zrne9i7e+9a1cccUVXHPNNdx0002sX7+eO97xjjzqUY/aaUULIYQQQuza5s2bedzjHsdVV13FHe94Ry6//HKOOuqoHT53UKWOGwALZQqGglQhqrCpA4dWihBTG72qTU5frBx1CMx1Msa1Ryt12FeOEvuefKOEEEKIw0RobzBNKintbb/mzGjGeHx7nkllqMoFOrlhUDrGtcfqFDTVzQ3j2tPPJxWlPGXjqZrAuPYMS8eWssG5SFSgFXSzjFlr6BcZ/SId18nMtJJSiLptu+cYNQ6rNTO5bStSpYl35cKKyo12M8OwcuQ2BXaFNrArLnmfCmvwMTKuPMT0HjY+4Nv3dEtbvcqHSNkEFsYls4WllxuMgkHpsSby6feexSVf/CzaGP7kHR/iLvf9LRarhl5umZnc/2uDrOY6EjAghFi5zZs3c+21104fP+QhD1nRcXme85u/+Zt85zvfAeD73//+fhnf6173Oq655hogVbJ6+MMfvl9eRwghhDgcNU3D05/+dL797W8zNzfHpZdeyj3vec/VHpYQ4hDV7/d5yEMesuI1x4GS5zmPfexjV3sYQgghxCFjOBzyxCc+kX/913/l6KOP5pvf/CZ3uMMddvjcxodppailQVG93NBtk8+X6mSGfoyMa8+oTvtFC6R9kWHlpoFUQuwr8m0SQgghDhOTxLvJzz2tFjUxOS6STuRjpNcGPRXWUGRperFYNoxqRyczFG1AUz839AuL1RqtFaPKsWmUgqKqJgVMaaU4op+xvp9Pg6IKa5a1l9NK0c0MmdbENlDJtC34JgFbYYWZhlorirYNYDczxAjjdiIOoEnXa5Si9oGmbd+XJvOpbV/VBnp1rIEYKdoqWtcvVFy/ZUwk8NXzz+aCj38YgDPf9C4ecdwTyK2myFKrvkHl8DGde1x7Bkt6cAshxO786Ec/Wvb47ne/+4qPXVpZatOmTVx//fX7bFwA//iP/8j73vc+AI4++mje9ra37dPzCyGEEIezEAIveMELuOiii+h0Olx00UU84AEPWO1hCSGEEEIIIdawqqp46lOfyne+8x3WrVvHZZddxj3ucQ9CiAwrx8Zhzc2DipsWK24eVPx80zglslduurcy17X0C7vTvSitFP3CMtdNtXyqJkwrTo0qf2AuVBw2pGKUEEIIcZhQCojtT1YeOLT9edJxto3WdyEF8/Ryw6j2zBQZ0EwrQpVNIDcaoxXlJNhIKZwPoCBqRS8z+AgROKKXc8Ts1lJPSytFLTWp2FTYdO668eSZoXGBEOIeBX71CkPpPJ3c0Mk1o8ozqh3G6PR3laduAt3MEGJkcewYN47ap1Kvs90M7yNKwahOYxo3vg1CU1x6wSf4zIfeAcAfvPbNPOH3noHVik4/JzM6VaiKYJSeVouSrAghxJ746U9/uuzxnrTO2fa5P/3pTznmmGP2ybiapuFFL3oRIaT//r/73e9m/fr1++TcQgghxOEuxsgZZ5zBpz71Kay1fOELX+CRj3zkag9LCCGEEEIIsYY553jmM5/JZZddRq/X45JLLuFe974PW0YNlfNsu7MUfAqWiqTuGkYpNvSzaUL67hTW0Msjo9ozrj2dzFA5TwgWrfcuwV+IbUlglBBCCHGY0ErhiWki6VMruM4OAo52q531dqwmRGh8JMRIv7CEmFrJzRQZmfGUtceFSNW2t1MqUjdhOnmeLTJiAGOAWKO1xmaaqkkBVt3cYLaZ+IYYqdzWzIGZjsUHqBpPTyuUUpSNZ9auPKAoM5p+YRlWjrlOhg+RQZ3O898bRxTWkBnNsHHUTcDHtMGfmxS4lGlNJzfcvFgRoyI3itpFujlc9d1L+Jt3vwGAF/zBmTzzhS+jY800sAzgyJkCaxQL45RNUZo0+R9VnvmeBEYJIXZvYWFh2eMNGzas+NhtA5UWFxf3yZgA3vrWt3LllVcC8LjHPY5TTz11n51bCCGEONy98Y1v5P3vfz9KKT7+8Y9z4oknrvaQhBBCCCGEEGtYCIGXvOQlXHjhheR5zpe//GWOfcCD2Disp8+pXaB0nhAiMUJZe0rvpwnxXkHpDLZy9IuVhaN0c8O4SftJtQvkbfL5So8XYnfkmySEEEIcJgqrUzCUNVRNoHKBftyzykohRpRKLetm26pGmU6t3/qFZbaToZVjVPvUVs8anE+T5BjAakUvs4waR24NY+uwVrFxsebI2QKUIteazGpcDIwbyG1qZhdJE24XwrQdYGY1M7llWHmcDrgYURpqH/a4VeBMYfEhkhudql5FuH6hZLFKQVybxk2qctW+l3PdjNyk1oG50YQYmSksRsPPN41ZqBr+83vf5uNv/WMAnnzaC/iDM19D1mZJKJUCq3r51iApyYoQQuytwWCw7HGn01nxsd1ud5fn2ls/+tGPOOuss6avcfbZZ++T8+6NG2+8kZtuummPjrn66qv302iEEEKIW++9730vb3zjGwH4wAc+wGmnnbbKIxJCCCGEEEKsZTFGXv3qV/Oxj30MrTWf/exnefDDH82wckAKgJoELy01ahyNjwxqRwww2zFopRjVqVPGTGf3ISlaKXKjU1K88+Q2/blf7PZQIVZEAqOEEEKIw0Q3MwwrR241VitciNOAppUa1x6lFN3cYo2mmxms1YxqjzWKwhr6haVof1f71GZvZkl1pNp5aq+ZKdLxR6iCuSIjEttiVAqrVFuNKtC0wUhLWaUockM+DShSNF5BiHSsIcQUvLSn5rsZChhtHDHTyeiOHc4HmiZAAKMUMx1DbtM12iUBS0Zpull6XzuZYdPV/8onz3olwXseecJJnPFnZ9GESM8ocqvpZGa74C3JihBC7K2yLJc9zvN8xccWxfI7DOPx+FaPJ8bIi170IqqqAuDP//zPuetd73qrz7u3zj777OnmsRBCCLHWffzjH+eMM84A4C/+4i84/fTTV3dAQgghhBBCiDXvzW9+M+95z3sAOO+88zjuCU+aBkUtlA1Vk/ZqlEr7L5nRqUpUCJRNYFA1aW/DawZVw0yRMW48SrGiPY5JMFRoA69cCAwrl34XU3UqpVIQVWHT/pIklYuVkl02IYQQ4jChdQpcKp2nmxkWK7csoGl3KucZ1al93YZ+xrgJzHYzUFA1gYWxo5dHum0FpLmublvr+bbSUwrEKhuPNZrZjsVohQ+pvd+4zTZQQJ4ZMq0pvYewdcKLVnSMwZqtk91ubmicIuJQSqXqSzEFgu2NuW7G0XMdbhlWGA3WaMrGUVjNbDdfdl7VZjF0Ms2w9ri2l/Z//PD7vP81L6OpKx70yMfyR2e9h9vMdlHAXCfb6WRdsiKEEHtr2wpRdV3v5JnbmwQvTWxbQWpvnH322Xz3u98F4Nhjj+XVr371rT6nEEIIIeDLX/4yL3zhCwF41atexWtf+9pVHpEQQgghhBBib4UQGTd+1YN/3vve9/L6179++ufTnvXsafu8pUFRvdzQzZcnfefGYLWmcRnD2qNR7fNTcFTqMKKnnTN2ZnLKxgUWxg3OR+LMNk+K4Ik0PgVNFdbQKwzZbs4thARGAb/85S9pmgaAO97xjqs8GiGEEGL/6RUpMKqTG+oQtgto2lH7uRBTQNMkKKrINDOdDKXcdDK7QJoYj9rgptzo1AKvncCn86ZKSp0stZ+b62RsHNZ0C0PtPEToZZrFylM1HpMrZvIdT1UUqY1eN0vVoba0/x/v5mY6xluzWJjvZSyWDUfNdYhbxgwqR+U9s2QoBUan9nlFpqfvmQ8N48bz4x/9mHe+6nmMh4vc70EP5cy3nU23U9C4QGY1ZePp7SI7YtusiBDjTp8rhNje4Tq3n5lZfpdg2wpSu7Jthahtz7WnrrvuOl7zmtcAKYD0nHPOIcuyW3VOIYQQQsC3vvUtnv70p+O95/nPfz5/9Vd/hdrDFuJCiL13uK41hBBCCLHvNT4wqjyV82y3A3CAg3/OP//8aUXaN73pTbziFa9gyyjNecraT4Oi5rp2h0n27fYPRiu6mSG3mtql/afMeAprGNWeue6uxx8jjOrUxWNOKYxW1G0SeViSQK+1omPT65TOU7rUdWNGOm+IXVgT344HPOABANzpTnfiS1/60i6fe8UVVwApy/lBD3rQis7/yEc+kp/+9KcopXDO3brBCiGEEAexzGj6hWVYOeY62S4DmmKE2gVqH5jE5kwCmgCOnCkY1o7No3ra9q5qPD6yXdDQhNWKbp6CoyBlF3QyQ+U8w8qTZ4YjMsO4bqtM+RRMpFBtkFW6hsIaUFA2fvrc3Bo6bWDU3rSe2zYzY6F0LJYNQUEvt+RWtdWiFEYptCZlLBBoXGTL2HH9z6/j7a98DoubN3KPXz+Wt3zok3T6MxilKL0ns5raB3q7GMfkLZu854daXNTBkgEjVo/M7fePubm5ZY83bdq04mM3b9687PHs7OytGsvv//7vs7i4CMDLXvYyHvKQh9yq8+0Lp59+OieffPIeHXP11VfzlKc8Zf8MSAghhNhD3/ve9/jd3/1d6rrmpJNO4pxzzpGgKCG2IWsNIYQQQqwFg8pNW9QBqxr8c+GFFy6rSPu6172OECKVS4ny4yb97OVml51Hxo1jUHuqOnXC0EpRO48LgdvMdqh92g/YUXL+xMZBzbj25JmmcqlDhw872CDxkaoJab8pS/tCw8oRYpzuXwmxrTURGPWv//qvKKUYDAa7fe6jH/1olFLc/e535z/+4z9W/BrxUNt1FEIIIXZiprD4kFrczXUySpOCi1yIVC5QubDdMUsDmhofIKaqTVopMqMZ1Z7MpJ7SjQuU3tNUgUwrerkhz8x0Ej8xmcQPKsdMkbEla9rqVZrap4l3jUK7VGFpJrcYpYlERrVvA7ZimkxrRS8zdIyhl5s9WhzsLDMjtxprFG4U0Ao0pEpWRhFjZLJuCTFSu8DPf/FL3vT7p3LLDb/gtne6G6957yfpz8zSKwyjyhOnFaB2PZ7JlGSyPjhU9joOpgwYsbpkbr9/3OUud1n2+Nprr13xsf/1X/+17PFd73rXvR7HV7/6VS6++GIAbnvb2/KXf/mXe32ufemoo47iqKOOWu1hCCGEEHvl3//93znhhBMYDAb8zu/8Dp/+9Kexdk3c1hXigJK1hhBCCCEOdlvGDWUbbFS2CetulYJ/Lr30Uk499VRCCLzwhS+cVqQd1Y5ICthyIaLU1m4dSzU+MK49w8oxqjwGhY+R0nlmCosLkcXSoVSVKkkZxVw33+FYFsuGxSpVqXIuUDeBTqYpa4dSCmMUKiqiingfiTGSW4MLkToE5joZ49qjlZLKUWKHDslvRYxRFihCCCHELsx3M4xWDCs3bW+3u6wEYJrF0C/sdGLs2//njmuP8x6lFV1rpv2iI2CUSpWoYFnQSwiRLaOasvH4AM4HBlVMVYOUpWoCjQ9sGTUsjBusThWFTFtRyGpFjKAzg9WKuW7GTGHbyk67t6vMjM3DmkjEx4jzgdmiwBqFDykYy2o1DSgbDhZ4x6uexy+v/RlHHHN7znz3x5nfsAGALaOG2gX6RRrT7qYodRuYNqmatKsMirXiYMqAEWuPzO1X5td//deXPb766qtXfOxPfvKT6Z/Xr1/PMcccs9fj+OlPfzr983A45Dd/8zd3+fxtM+3f97738alPfWr6+HWvex3Pe97z9no8QgghxFp3zTXXcPzxx3PLLbfwW7/1W3z5y1+m0+ms9rCEOCTIWkMIIYQQB9KgctOgqIWymbaoUwoKmxLPtVKEmJKIqzYwabFy+zz45zvf+Q4nnXQSTdNw8skn8+EPf3hakXaSPF+2VaMKu313kGHlGNXp73OjWQiRyqckfB+gcRGIKKUom4BRihsXa4zW23X8cD6wcVgTI+3xgWHtWdfLKGzaD9JuazcRm2lCjFRtUJnzae9lrpO1iddakq7Fdg7JnSYpIy2EEELs3kxhKayeVvHJrV5W0WkpRZoMF1Zjjd5hJkM3N4SQSpyO2ij+TtvermmrO91mtrOsTdqo8Qzr1FatYzVlZtgybhjVjlynln5GpRFopaYT415hWN/LCTFlHABsmMmZ6aQe1ytpxba7zAwfU5lWoxRKKcaNo8CQG8248ZQxlY+lHPMX/+v5/PTHVzK3/gj+5D2f4Mijb0fVpDaEQKpuVUa6uWN2F9kcIcbpMZ22LG2xk89krTiYMmDE2iRz+5VZt24dd7zjHaeVov7P//k/Kzqurmv+6Z/+afr42GOP3WdjWlhYYGFhYY+O2bRp07I2gNu2+RNCCCEOJ9dffz3HHXccP//5z7n3ve/NxRdfzMzMzGoPS4hDhqw1hBBCCHGgTLolwPKgqF5u6OZmu8CjTmbox8i49oxqT9UEFmj2SfDPv/7rv3LiiScyHo95/OMfz6c+9SmM2ZpsHtrA8dDex9/2dZaOv2o8ZZPu+zc+3d+vvWdYB3KjqH2kcYHMFBitGNWeGGGmszVMZfO4ZlA6tpQ1w9LjY2S+m4KifIgMa0dckmTdySxzXUs3t9QusGXcUPtAbjSdLHXwmO+t7X0Vse8dkoFRQgghhFiZzGjme5oQLOMmBSiFuKSKj1IUVuNDnLY/230mg6FyYVoZyRo1DWwZNX6ayTAJmOnmhoUy/bl0Hq3AB6h8amGXblTGVG0qT4FJIUY2jVJ2QWEN8z3Lhn4BQK/YfbWolWRmxDZIqQkpK0NrhdWKQZnKuYYImxZK3vLqF/P9//cP9GZm+fMPfpK7/eqvMigdtQ/cMqhQ7XmzNpvDagX9HZeLHbeLAqu3VthaafWrg9HBlAEjxOHgCU94An/9138NpCpQP/3pT3fbFu/v/u7vKMty+viJT3zifh2jEEIIIVZm8+bNPO5xj+Pqq6/mzne+M5dddhlHHHHEag9LCCGEEEIIsRdG1dbk4cl98rluSvTeGa0U/cJijWJh7KiaQGn8rQr+ueqqqzj++OPZsmULD3/4w7nwwgvJ8+X7FZO9ncnPpUFbw8pNx79YNdTtn7u5QTVpvHntqJvAqPbUzqNUOs6HyLpezrjx0/Z8w8rx3xvHjBvPwrgBFEYpXAj8YvMYH9LeEFpRGI01iqZKbfdmioz1vYxubhjXnpsGFXdY36NynhDsihLoxeFDQuWEEEIIgdZpwrqhn3PkTMFtZguOnCnY0M/JbaqQBNtnMmzo58x2MjpZaoHWyQyznYwN/TxVU4KUydAGEw0rR+PDsoCZcePxIeJCZLbImOlY5joZ890sTfrbdnm1DyyMGzYOaka1o3aB3CqOmM2nQVH9wu42S2JXmRlLrydV1DIc0SuYa1sPjhtPEyJKK5SCd7/+VXzv7/43edHhnR/9NA98wG8yU1jW93Myoykbz6ByjJtA8GkV4UNc1lZuIlXaSu/JpF/3SqtfHYxW+j7vyfdGCLFrJ5100rLHH/nIR3Z7zLbPecpTnnKrxnDGGWdMW5Ks5J+f/exny45//etfv+zvzzjjjFs1HiGEEGItGg6HnHjiiXz/+9/nmGOO4Zvf/Ca3u93tVntYQgghhBBCiL0QQqRyW/dDIN0n31VQ1FKFNdP75uN2DyEF/+xZS+Brr72Wxz72sdx00038xm/8Bl/72tfo9XrbPW8SBzX5Oakg1fgw3cPYNijqyJmCI2dycqNZ183pdSzd3GCtxoXIsPIMK8fGYUnlPDcslNy4UHLdplHad3GexkVGlUsVpypP7VMiv1KKXKcE+tAGSimlGFQNNyyWNCGglGJYOjaPauKS91mICQmMEkIIIcQu7SyToV/Y7cq7TkwyGea6qcpP1YRpINSWUbNdwEwvt6zrZ6zrZRwz12XDTE43SwuD2U76fa+wGK1QGpTSzLRBUL22olI3NyuqKrTS6+lkBgVkVpMbjdUK3wY3bRrUfOCs13LF17+MsZZ3nfNxHv7wRzDfzchMGtu6XkZuNT5GnEuVp0a1p7CGUe1xbaBPiClQamGc3pMiS4FCsLLqVwerff29mZxPCLFzj33sY7nPfe4zffz+979/u8Cjpb773e9ywQUXTB+feOKJ3OMe99jhc6+55hpU21pUKcWjH/3ofTZuIYQQQmxV1zVPe9rT+O53v8u6deu47LLLuNvd7rbawxJCCCGEEELspXHjiUDddkyYVEvaE93coBS4EKld2OPgnxtuuIHjjjuO6667jl/7tV/j0ksvZX5+fofPndy/nyRtT5KWp0FZjZ8GRc12LL083fPv5ZY8S+EnM7klt5pMazrGkJuUeL5x2LBxWFO7wC3Dmqr2FFazpXKMXXqfrEndJjb0cm473+U2cwX9jiWzGq0VETA67eHULrA4dlQ+jW3TqJ52pxBiKQmMEkIIIcRO7Y9Mhs2jmhDidgEzx8x1p4FNqT1ezlwnI880hdXMFpZ13YzMagqj6bTjGNU+BdO07fr21fXotp0dpAl21QR8jPgQ+NyH38mlF3wCpRSvfdv7ecRvHw+kCftkQZMbDSgKa+gWhkHlGVYNw6qhdp5NozpVwBrW0yyLItPT61hJ9auD1cGSASPE4UZrzVve8pbp4+FwyJOe9CSuu+667Z77/e9/n1NOOYUQwvTYs84664CNVQghhBDb897z7Gc/m2984xv0ej0uueQSjj322NUelhBCCCGEEOJWmATplO0988LqnSYP74xWqt1z2HqelQb/TNp0X3XVVdzpTnfi8ssv5za3uc1On19M9kXa+/mVCzgfqCfX0WztfJFvc89/tkit7UJMlZ1mOqlTSa9jWd/NsErhfMBqBRF6hWXQtt7TpECrmcJy1GyHuW5KPs+Npp+nPaBJUrnzER8jM0VG2Xi8i9Q+EEPaU5hUuRJiYvdlFYQQQghx2NpXmQzjxuNCpGw8lQ+Yxk8n7UsDZvpFyiIY157aBTKryezy4KBe7RjXnqr2zHUyermZVo3a19fTzQ1VOw404OHCj3+Yiz7+AQBe8Wd/ye+c+FQq5+lmaVrVyVJf7EHl2uAejVWaQe1QSnHLsGG2k8q/ruulBY3Vim5uppP6lVa/Oljt6+9NapuYWjr21/D7IsSB8KQnPYnTTz+ds88+G4Af/vCH3Ote9+KZz3wm97///Wmahn/4h3/gC1/4Ak3TTI9729vexv3ud7/VGrYQQghx2Isxcvrpp/P5z3+eLMv40pe+xEMf+tDVHpYQQgghhBDiVpoE6UwSf/c2ITq3msqF6XlWEvwzadP9b//2bxx99NFcfvnl/Mqv/Mouj+m2exy5TZ00XIhtizpFs+Sef2cn+zK93OJ9ZGQ8xEm1K8Vc17IwdsQYCTFitGJhVONcpF9YQox0M0Mvt2Rm+8AxrRTdzGC1YlA5GhfITerAUTYe6xW9torUpPuHEBOysySEEEKIndqXmQyVC2wZN2ilGLZVgHYUMJMZTdbVqapUM+kjDTGm5892LBrIbQoksmblATN7ej2Z0fRywy2Dmn5m+caFn+Qz70/VWH7vJa/m4U86LY2vjGilqF2g8QGtFJ3MpIyFPI1rXT9joXJEH4kxTif2823Ww0S/sGs6KAr2/femdH666OsX+3y4Qhxy3ve+97G4uMgnP/lJIN0AOeecc3b4XKUUf/Inf8KZZ555IIcohBBCiG289rWv5ZxzzkFrzac//WmOP/741R6SEEIIIYQQYh+YxC9Nfu7pvfKJyWHbnm9nqqriqU996rI23fe4xz12+zpap04YpfN0M8Ni5dgybuhkdtqyLt/mnv+ki0TjA2UTGFQORdrvUEAn0xTWUNhA1aRuIvP9jM2jNnCqSfsKETWtWLUz2ZJgqKr29DuWQekIOuJCxIfIplFNZjUhxuneklbp3N3MTNsEisPH2t51E0IIIcR+ta8zGcrG08st48bRzewuA2a0VvQKS28Hf2f13gXM7M319AvLxlHN311+CR980x8B8IRTX8QTn3M6VRMYVg6j1LLrsFpxm9kCo1LfbK0V/dxitWHcuOnzRrXHaodusyvW9bIVV786mK1mBowQAowxfOITn+CJT3wib37zm7nyyit3+LyHPOQhnHXWWfz2b//2AR6hEEIIIZZ6+9vfzlvf+lYAPvzhD/O0pz1tlUckhBBCCCGE2FeUAuLWwKa9vc89OWxynl3FVznneOYzn8lll11Gv9/n61//Ove97323e14IkXHb4WNpEJEPkVHl6GSGImjCCBbLBucDWqvpPX/nA+PG07iAj3G6DwQpud1oRQQKk6pPHTmTs3FYk5nUaaPygcJqrIaKrQFMu1NYTeU8LkZC21FwXHsWdJMCsXLD+n6+5M0DT6TxaU+nsIZeYfZ670KsPRIYJYQQQoid2teZDJMAF+cjZAc+YGZvr+f7//j3vOnVLyWEwGOf8gxO/+M3Mm48PgYyrQBFZhRKKzrGLGv/d3Q3a7MqGnwMDEuH1gprNIZIN0/ZDVopKhe4eVCt+Un5amXACCGWO+WUUzjllFO48sor+f73v88vfvELjDHc7na340EPehB3vetdV3yuO9/5zsT98C/h/jqvEEIIsVZ85CMf4Y//+I8BeMc73sGLXvSiVR6REEIIIYQQYl/SSuGJqUqRT8E5O2tDtyt126lhUu1oZ/fdQwi8+MUv5sILLyTPc7785S/zkIc8ZNlzGh8YVZ7Keba7Mxe3/tg4rMmtxijwpOAjHyNWa8a1Z9x2B2l8YFx7Sh8gpI4ZmVYM6sj6To5pu0PULrAwdnQyTek9RrVBVjECgRjTfs/u9hS0Ulit03U4R9l4FscNs4UlAjHAQtkQwpKKUVrRsYbcakrnKZ0/JDp4iJWRT1kIIYQQO7WvMxm2daADZvbmev75//1f/uD5p9HUNY88/kRe/udvR2uwRtHVGTMdi9GKue7W7ANFCt7q5im4aVg5ahfpZhbXbftnG0WMUDVpMXAoTcpXIwNGCLFz97nPfbjPfe6z2sMQQgghxDY+//nP89KXvhSA17zmNdLaVgghhBBCiDVmZxWXlrZtK2wK4OlYQ9WE1AFjBcE/IUbKxlO7gGvbwxFhvpul6ks7aKMRY+RVr3oV559/PsYYPvvZz/LYxz522Vg3DmsGlVtWHSqESGY0Si0PIgpZpGwCPoJRYIzCucgtw5K0EwKNS9fkY8S0151ZTRMihVY0IbBlVKdgMAWj2hGx9JQmt5rcaIJPxyqVWup1VxA4lrfv6+ZhTdUElFI0IbJYNtBNQVxVE6h9IMZIbEecGc1cx7KunzOsHCFG5jrZnn70Yo1ZUztt4/GYK664Yr88VwghhBDb2+eZDKbNZGgzGg50wMyeXs+P/v2HnPZ7T2E8GvKQRzyaN77rr1E2J7aLFq0VZsk/WkHe9reeXONC2VA16frLxrE4blBt6z2jFa6teoWPVE3AakU3M3Rys2Yn5Qc6A0asTTK3F0IIIcTh7NJLL+VZz3oWMUZe+tKXctZZZ632kIQ4ZMhaQwghhBD72+4qLi1t25YZjfOB3KZ2ci5ExnVKjN4R5wOj2rcBPel3o9rhfcRqhVKKUeUZWkeILOs+8aY3vYn3vve9AJx33nmcdNJJy8a6UDaU7X5F5Txl7ad7FArI2mAua/R0v8Io0AqaAEVmUoCVi3StZlA3OJfu3XdzTTe3ZEajURSZxho1DewaVI46BCJQ+wB1up7CGqrGk1tFbIPBjFLkVhNipPYB5wIhQiSiSHsxkciWccOwdORW42OgrAO50ZRNYFw7rNH0tCG0n0fdtvorG8+WsuGIfpHaAyq1JpPUxcqtqU/3F7/4BY95zGN2+7wY44qfK4QQQoid29tMhqUmE1eArjXLfh7ogJk9uZ7/uuYannHSE9m8eRP3+80H8d6Pfopgi1QOtvH0cstcJyOzmn5u6O1g0jys3DQoarFq2DxqcDFSWE2RpQXGfDcjxDQpr9oFwmK7QJjrZIxrv+Ym5fv6e9Npvy+FXZutBcWOydxeCCGEEIer7373uzz1qU+laRqe/vSn88EPfhAlSQBC7DOy1hBCCCHE/jSoHMPKTR/XLlA6v9O2bXUb6GR0qoS0WDlGtceaFBS01LD9uwnnAwtlzcI4/a5XGAZVw3wnR2m1rPvERz/0Ad7whjcA8L73vY/nPOc5y8Y6rByLY0fpPYOxo2p8qhBlFHN5RrcwKek5RnRIXS8mQVMda9AqsjCuWawc3dwSVaSwhsJCp62MZbRuk8c1tg3WCnkKdhpWjlHpKJ3nyKJDWTus1eRWobQit2b6egtlA4DWoNh2rRRpQmRh1HD9QklhNS56rDLUwaN1Rj839IsM55d/NinAKxIi0ARuHlbMuozKBYoNvWmAmTj0rJ0dtlbcTWWJpTcRdvfcHR0jhBBCiK26WapatNJMhh0Z154YSZH/mWFUeea7GYuVO+ABMyu9nhuu/yWn/O4TuOH66/m1X783H/vMF8h6Mzgf2DxqqF1gpkjZEwp2GNzVtIsdSEFRZe2ngWBHzRbk1tAv0sKI9hz9mMYzaku8LtAw18kYVi6Vn10jk/J9/b3J2/d5JeVzxdoic3shhBBCHG6+//3vc+KJJzIajTjhhBP4xCc+gTEyzxViX5O1hhBCCCH2hy3jhrJJ9/3L2jNutlZcWmabDhG93LBp1NDJUtJ01QQWxo5eHunmKSBpcZtqTqPaMaz89PUyqzFKpWRk69k0rKfdJz7y0XN51StfCcCb3/xmXv7yly8b62CcgohciAxrT+3S7zs2BTT5GClrnwKc2vvwmVFYrdsgLk0THP2OZXHcUDeBqCIda5gpLEVmyI0mM6rdG0nVrLa2FoTgI86n1nxbxjWNj2TtXo9W6ZpTcFRgWG0NDtOKdK6Q2uF5H3FEBmNHhDbpHBSR267rpCRzBVtG9Q4/G60UPgQWS0/uUiAXwA1bSn5lQ+9WfkPEwWrNBEatdHGy0ufd2mOEEEKIw4Fuy5iWzu82k2FH0uQ9TWC7eQoC8h46uZkuGA5kwMxKrmfTxo0846lP5r+u+Rl3uvNd+NyXLuI2R92GjcOaENPEPbL1hmhu9bRy1bbjBKgaTz2pmlRYupkhtwaltg+o0krRLyzWKBbGqdpUadJiZFR55ntrIzBqX39vAAprdvg+i7VJ5vZCCCGEOBxdffXVHH/88WzevJmHPexhfOELXyDP89UelhCHFFlrCCGEEGJ/GVRuGmi0UDbTbhFKMU1s1krtsENEkWl6uWFUe3q5mQZHjSbBVT49VwGLZcOg8rgQIEJuNP1O6mARYiTTelrNabFyfPUrX+TMV5wOwMvPeCV/+qd/ut1YbxmkIKGUdB7pF5a5IsNaNW0xt7Td3WyRUbuIzWGua1kYO3y7nzPXz9k0qMitYUM/Z10vx/nAuPGM67DD1oLDxnPzoGZUN9P2gOu7OT6mlnfz3RyF48aFksxoeplh7DzjyrODZoWEEBlUDZnRKKWofGC+sHQyy6hxdGIKNlNtS77MqCWfTUSp9P6NagcDuN26LlvGDXPjhrluth++PWK1rYnAqNe//vWrPQQhhBDisNUrUoBLJzfUIewwk2FbYUnlI4Ai09MgoHX9DB/iqgXM7Op6YlPyrFNO4kc/vJKjjzmGz3/5Yo4+5rZtQFRgse1VrQL4EKldYF1v+0lyaP8OoGz89M+Z0XTaceftImlHCmvo5TEtitosjcp5QrBrJjhoX39veoVk0R8qZG4vhBBCiMPRz3/+c4477jhuuOEG7ne/+/G1r32NXk+ykYXYl2StIYQQQoj9pfFh2pJuaVBULzc7vN+9ow4R6X53qsC0rpeRG824ThWhtoxT67hl1ZwyQz839Ao73T/pZJrZNkBqXHsuv+wyXvX7LySEwGnPfh6vfcNZjNu2dZOxjmtP7UMap0t7E93c0MtTqEhhzbTd3bhOid6LNMwW2XSsvdywWELZpHaAHkUkBYDdMqgISzqDOB8pvYcQ8SGyUDWpOpPR9DJL6QI3LVZkSoFS+BgIMVWoikQ2jWpu8pHcqBQA5iNWa3Kb9gu0hsVxTZEZGu8Z1gGtFMes77JpVFPY9Drd3KTnb/PZFDa198ut4oaFVJlr07Bifb/glkFFNzdrpnuHWDkJjBJCCCHELmVG0y8sw8ox18lYoFmWyZCbNCFVKpVFrV2g9mEa9V9kmrlOCh7qF5bCajYO61ULmNnZ9WxeHPEHz38G//S9/8v8uvV88gtf4ehfuSML42bZ9cx2LQqomoALKZPCaLVs3GWTchiqxrctAz1znYwi09MFTC/f9bi7S6pq1S6QW8242bPqWqtpX39vZCFy6JC5vRBCCCEON7fccgvHH38811xzDXe/+9259NJLWbdu3WoPS4hDjqw1hBBCCLG/jKqt7fMmQVFzXbvLhO8ddYiY7Vi0UqnyUjejkxluGVTkWQqSCj6QacVMN2OuyMjs1vvivdxM9we0Ulz5z//IGS9+Fq5pOP6JT+HNf/VelFLcsliTZ3o61qoJzBRm+rpKqR12s+jlFqsVi6VLXTCMp7CGce2Z6VgiCmsUw7qhm6UWdKPG07iAIt3nDyHiicQILgQWSkfTtstzPtA4TRMCVmsWKjdNgL9lUFO5FJRVNp7GB8YK+pmdXrMPkVHlUCpS1gGjIQSFVZp+x1B5D1FRWN22L9z5XopWipkio+oGNo1qFipHr7BkRq2p7h1i5dbGzpoQQgghDogQIuPGU7lAiHFJ/+dUYhRgrpNRmpQ54EKkcqkk7LasVtOIfEiBPjPtBHa1A2ZmCosPKQNirpMxpObMl72E/3PF/0e31+eDH/88t73zPVks3fSY1Ftb087h6diANXqH416sGkZVYOO4om5SUFO6/jTuXm6wuxm3VorcaCoXKJ0nt7ptx7fHl7tqtn2fb+33RgghhBBCiLVmcXGRE044gX//93/n9re/Pd/85jc5+uijV3tYQgghhBBCiBUKIVK1VZzGbXu6Xm5W1AUDtu8Qsb6f431o7/+nJOvZIiP4iOlmy6o5KZjuLxitGNWO2gWu/P6/8byTn0o5HvM/HvU7vP6vPkTpIt0QWawa1tt8OlarFZnVDKpUlSq3O+9mkVtDN0+J6mWdAqNql1r6Wa3oZoaqPa8ikhlDDLClbHB+a2tBqzUhpLZ/hdU07T5PEwNaQSfXZDZVxBo3nsZ5BqVDoRhWjsoHCq2pXcWgdvRy0wZCQdlEysbRLyzdzKBUYF03Zzj2zHZTIJVfYQvkmY5l3Hi8D5S1p5fbNde9Q6yM7DIJIYQQgsYHRpWfTsKXieBJZVBHdep13csN6/s5dRu0E8KSICqt6FhDviSToV/YZcEtB0PAzHw3w2jFoGz48z88g0u/9hXyPOfs8z/NAx/84J1ez2LZtJkexbS07LbjnvTbjm2J1/XdbBoU1c3Miqs+TYKhQkifSljhZP5gMnmfh5Wjk6XPb2+/N0IIIYQQQqwlZVnylKc8he9973scccQRXH755dzpTnda7WEJIYQQQggh9sC47RBRu4ALEaWYVjpaqR11iMitxupUxWlYp9cwOnVisDolTncyQ4gpqGqSQP6zn/wnLzntqQwWF3jAbz2Ud33kE1RRc/OgZlS7VI1p3EzHmmd6Ws0JUsu6XelkhrIda+MCmdWUjSczmjEpWMqHSOkCGwpN7QOFUaioyTNFbgyRyLCE+a6i9ml/KWsrOSmVWvKhoHaRECNz3RwXIv+9acSg8lgFKgMTFVXjGFeOEFNCeWY0Vqd/xnWgkxs0gFFoUsWoxodl7f12RgGF1Qx9mH42sf3M10r3DrEya+LTNCb9h+Xud787//Ef/7HKozm0xRj5yU9+wpVXXsl1113HwsICvV6PDRs2cL/73Y9jjz12+nkIIYQ4NAwqN+03DewyaKWXGxqfAqSsDvQKuyyQZak0oTT0ih33Y96TgJncaEJMgVSj2k+zIzYO62lZ1L2J3u/nhte/9k/4m098DK017zj7XB78sEe3E2ymCw+t1fR6NhyRU7mwy3EbnUrKxmjbsrRpyrW01O1KTObsk3ioNRgXBaRAuMLqafDdZNG3I7v73oi1T+b2QgghhDgcOOc49dRT+da3vsXMzAzf+MY3uNe97rXawxLikCZrDSGEEELsD5OE6LKtGlXsoOLSZP+idoEQ0567UirtM9i0z7CjDhEAvcLiYmRdL6eTaWbbjhkAw8oxqv308XXXXsuLn/EUNt5yM7967/vylx/6JNHkqLYLyKZRQ240i5VjfS+nsHoa7DPZX9hdsNAk+Kh2gdJ7MpuCnybHRSKotN8B4FzqrrGut7XDx6By9IqUlN/4QGYUG/oduplhWDnKpsL5CNrjXKRRnkBEK02uA0qrlHyuI1GBCyrt02jQGpROF+NjGkvQEYVGaUWM6Vor5+lmu96Pie31TvYrau+nn/la6t4hdm9NBEbF9t/SuFZ3Aw9yi4uLXHTRRXz1q1/lW9/6FjfddNNOn7t+/Xqe//znc+aZZ3Lb2972AI5SCCHEvrBtq7yFcUPlUunSENL/a7ev1QT4SNWEaanUuW7WBgFFcmu2a7u30mCl3QXMOJ9a7A0qBzEtIPptwIxve1U3PgUp7WkwTeMDZ531l7zrXe8E4B3v/SBP+t2nTBcuPkTKmCbts52MDf2coq1WlRm9y3FH0vEhRFyAzCrW97Ldts/b1mTqM1mn7Ga9clDLjGa+pwnB7rRd460JchNrh8zthRBCCHGoCyHw4he/mC9/+csURcFXv/pVHvjAB672sIQ45MlaQwghhBD7w6STw9aKS9vvYUyqOS0TIx5ofEr4jjHifJxWbFraIWJH514sm1RZiRTk84tf/JLTT30KN/zy59zxrvfg7R/5DEVvlqpJbeqqJuCiJ+8WDMoUIDXb6dD4FCk02V9YSWeKfBJQNe1mAUqlPxulqJ3HmlTZaq5NgjdaE2PEx7R3ZLXCO5jtWHp5ans3YZVi7DxFYRmHhlHlcR5uM1fgXcagcYxLj1KK2Y5NgVfdLFXPqgLDqsHHgDEK59I+QwwR51PgWT+3NC7QzXZ4eVN1G5xWZAbi1j2Ztdi9Q+zamgiMAlBreSfwILa4uMhRRx1FWZYrev6mTZt417vexfnnn89HP/pRTjrppP08QiGEEPvCjlrlLc002FI1VE2Y9que72X0cotWihBT8FHVloldrBx1CMy1WQu51beq3dnOAmYGpWPceLSCXmbQSlGHFAS1o/ZrpfNpwruC9muDyvGhD/01b3z96wB43ZvewpNOeWaa6LfVorTRy1q7bR439EOcnntXgT6Z0WgVmGnfo05m9jgoCrZOyieBQrvL5FgLtFb0CyvZFoc5mdsLIYQQ4lAVY+TVr341559/PsYYPv/5z/OYxzxmtYclxGFD1hpCCCGE2Ne27egwuU+/bTWnSVDOjrpx2LYC02LpCG11qKWxNzs69yQoalA13HzzRl75gqfz3//1U465/R340N9cyG1vd9t2/ybt4bgQGJaB3HhigLLxlHXaY/G0+ww+PX93WzqTGdWya58mcqvUbq5y5EZhtGJdL5+OfdykRHcfYtvOLyVFA9P9JlDkVjFuHCFEjFEYDY2PZFZzZFHQdCIRKDKNBjKb9mzme5HKWRqX3qfaBzYOam4zW6T3wUXIUzDXrmwdC3SMoXSeTOtl1y0OHWsmMErsH9777YKi7nrXu/KoRz2Ke97znhx55JGUZckPfvADLrzwQm6++WYANm7cyMknn8wFF1wgwVFCCHGQ21GrvEHVsGlYEyMpmyEEOsYw27V0MoMPadLaKVIEfycz9GNkXKfMhqoJLNAw18naak36Vrc9Wxows2Xc0M0N3dxQ1n7ae3tbwQU2DxtCjBRGk2eajcOaXm44cqbYYfWhLeOGz372s/zxq14BwEv/15k8/QWnUzXb1MrapkpWJ08lXkOM06Cwbcc90csNg8pRu8CWtipXfwX9rJddW4zUk0m5TZ9DsZP2c0IIIYQQQoiDw1/8xV/wnve8B4CPfexjPPnJT17dAQkhhBBCCCFuFaWAyLKKS9tWcyrrHe9hLN1nmBxfNp5B6ZjvtfsM25x7UoUKUlDU5i2L/MlLn8lPfvxDjrjNUZz72a9wxzvccfoShQWjwYWY9nucx4fADJZB7ZjrpJCQjjWpupQLhHzX+xWTK5k8JZICnFJyvaJqFFVMCfXretmyczXbtB5MieSqfa9CqigFFNayMK6pfKBfWGoXUBoypekVhsoFGh/JraKXpb2rDTMpAGtYO25erHAh4HxkWHtGlaNXZJSNY55st1VEy8YTI1itsFahHHTb9oASa3/okcAoAcDc3BwveMELeP7zn89973vfHT7nXe96F2eccQYf+chHgBRU9cIXvpBHPOIRHHnkkQdyuEIIIVZoy7ihbNLkc2mA0aB0ND5SucCoTkFTudY0LmCUosgMo9oTYpz2s9YqBQBZo1gYO6omUBpPJzOMKs98b98E7QwqNx3zQtlMA5aUYhqAFUJkWDvGtaNqqzyVjSf3mtkiY7F0+La609IWe4PKcfEll/AHL3kBMUae/pwX8j/P/NNl595dlaxx7dFK7bIq1aRPdm41VitcSEFl/T2orDWut07Kc6tR7XmFEEIIIYQQB6cPfOAD/Pmf/zkA733ve3n2s5+9yiMSQgghhBBC3FpaKTxxWnFpy7hGq7QfMqiW7mGke/mZUUv2GSJ1u88wqBxKKdb3M8aNJ681/cIuO3fjA+2WDZXzLA7H/NkfPJ8f/uv/Y25+Hed8+kvc8S533W6Mzke6mWFdL6N2AR+h9oHGh7YNHlizdb+ibDy9fOf7FZNuFqpNPK+dJzOGbm6pnKeTG2Id2+Ci5f3qJvFhcdoeUE3PWTaexkUKq2hCCpCKIQVPDUpHZjWz3YyZjk2dUGqPVYp+x2KUmgZYddsuHRpNN4+Ma8WmUYM1GhcsIUaM3vmeVe084zb4rJMbGpcqVRlz6HTvEMtJ2YHDnLWW17zmNfzsZz/j3e9+906DogB6vR7nnHMOp5122vR3mzZt4uyzzz4QQxVCCLGHtg0wWqwcLsQ2sj8y07FkJgU7zXczikxPJ+eLVQNA2YRl1aaAFGjURs1PJo5VWx721mr81tdbGhTVyw0b+jmznQwfUvQ/KPpFxkxh2wwNxy2LNb/YMmZQNSyMG+q2dO3GYc2mUc23/vbbvOjZp+Kc44TffRqv/Yt30C/s9NydLLXO62SG2U7Ghn4+vdaqCSyU6X0ZVm5aYnVHtFYUbZWnSTDTqE6tDFeicn6aETLJUCjs9tWvhBBCCCGEEAeHv/mbv+HlL385AG94wxt4xStescojEkIIIYQQQuwLk04OHWtwPrB5lLpYLA2K6uYpKGmSrJ0ZTWENM4VlXW+y/xKonce1QUfOBya3/CddI8aNn1ZaGowq/uLVv8//++636fb6nP2JC/jVe917u/EtbQm3rpv2OfrZ1upQtU8VqyAFAUHa49gyqlkY12we1Wwapp8L45ph1VC1e0sdY1Jgl0/7Pxv6GTHCTJFRZCmwalR5RnXqtgFMKzUtLdg0bjzDNuJLqdQWz4eAJiWHT9oPTp/AknZ+2/yEFLg0W6Q9rsxouoWmrAObxw1jl/bGdrSdEmJkVDsWy7ZgQJYS5msfUucQ6d5xyJJP9DA3MzPDW97yFjZs2LDiY97xjncs69X+ta99bX8MTQghxK2wqwCjXm7oF9k0ur6whiNmCtb18mkQTt2EaXDUqPbbBQF1c4NSqTRr7ULqJ92sLOhnV0bV1upWkzHPdS39wqKVYrFspgFDlfNsGdUslg6tFJ12YTGq0qR2y7jhl5tLyvb5V/yf7/GsU36P8XjMI377eM56z4dY18+n596RSZWsuW6a4FdNmAabTca6M71JG8LcUGRpyrUwdtN2fDsSYmRYORbG6bMrshSktfR8QgghhBBCiIPLRRddxHOf+1wAXvGKV0yrRgkhhBBCCCHWvm5m2hZymsanDhZbRvV0D2O2k9HLd73PoFVqB2eVIsRUsaiTGWJkem6rFWUdGNeeunG89U9fxRWXX0yW57zvvE9zv9980A7Pv7Ql3EyR0c00/U4GbcWq1AUjPdcohfORhXHDTYOKhdK1VaUiPqTnbxo1bBmnvZjU9q+hsGmfI11npPYOH9J+yeZxzU0LJddvGbMwbqZVslLFJ8fm0dbOJrk102Ryo9N7UeS6rdikyLQmxEho2+3B1gCpbd/dTmbodyxKKWY7FmXS3ljVBDaOaioXqFxqLVg5z2LZsHlUTxP+8yx1ICkbT6fdi5HuHYcuaaUn9tjtbnc77nWve/Hv//7vAPzkJz9Z5REJIYTY1s4CjApr2Dyq09+5yUR0a3/nXm6xWrFYOuomUBlPYQ3j2pN1t8ZTa6XIjaZyqSJTbtOf+8XejzmEOK2oNAmy6uVmWnlpWLlpz+4dlaed6Vi6eWrrF0NEWcW4dmwZa/7jqqt4wTNOYnFhC7/x4Ifyzg+fz3y/Mz337qQqWak/97hOC5ZUJcvutIpTZlIZ3GHlmOtkLJDGPGpbGuZGp0m2SpkTk8yNScxUkWnm2jaG/cKSGYlnF0IIIYQQ4mDz7W9/m1NOOQXvPc95znN497vfvSyhUAghhBBCCLG2TTpEjBqHaef6W8aOTqaZ62bku6kuNGnblltNNzf4EPEhnbfxYVnFoluGNY3zfOAtr+MbX/osxhjecfZ5POThj9rluSElaWutmOvkVC7QZIHKBWydAn+0UmwZN1ijyKxhVDluqWtUjFidKi85Is6lziO1T3s202uMsHFY0ysslYssVmmvRCmIqOneR9V4jE57Ro2PQKCbpapZudFsGQcKq6ma9F6mPahApjSF0cSYAqum+fpaLf2xTC831N4zLAP9PLXXI0Lt0kbLoHTbHWO1SgntNlXDCjGmgDLp3nFIk8AosVdmZmamfx4Oh6s4EiGEENvaXYDRpONd2Ka/80RuTduT2VPWfuvkMMRlk8FJMNTkPDurgrRS48YTaftMO89i6RhUirgAtfcMSo9pXz+3GqMU3dzQycw0sCszGt+WXO3nBh8j1153HS855XfZePNN3PPXj+XNH/wEedGZTnJXqpsbxo2fVsnKrWbcePrFzqdTM4XFt/265zoZpUmLFBdim62wfTs+q7de1+R1Z3bxGkIIIYQQQojV8U//9E886UlPoixLnvzkJ3PuueeitSQ0CCGEEEIIcajpFYaNo4o8M+jG4UJgWAVmOpYQ4w6rRYWY9gaWVijq55bNo4bMqOk+w+TQTm7IrOIj7/krLvzkRwH4s7e/n995/BN3f26T2tEtjGt6mWkTzT0uBoyCn292HNEvyKxmWDqCD8QYiSHiYqTygWbcULXRSB1rWNfVWG3QwOZx3VajMlijqFyNBgalRylY11N0M4OP4EJgXHlyo0BrCqvpF1v3cSbn2DisiaRApKYNZCpyQ+MD48YTQsSaFCwFpKCnHZgpDMPSkZmUbN4rLG18FEaDQqEUKK3oGENm9bSlXjo+k+4dh4E1tcs2Ho+54oor9utrPPKRj9yv5z9UXHPNNdM/H3PMMas3ECGEENtZGmDkQkQplgUBbdvfeUcT9k5m0qQ5RBoXyKymbDy9JQE6k8Mm57mVcVGp+lTt+K+NIzaPUtZCP0+vN6x82x7QM24CWimOnMmZWTKZnlxLZnSqvhQCbrjA/3reyfzy59dxhzvfjbd+5NPMzM7tdKGyK3tbJWu+m2G0Ylg5OlkKeJoEf036ZiuVskM61izLLukXVoKixCFL5vZCCCGEWMt+/OMf8/jHP57FxUUe85jH8LnPfQ5rZe4uxMFA1hpCCCGE2Ncyo7FaA57MaDKrURGqJlC7mmzSIQKm+zPNkg4Rk7ZtAPNdi9F6us8QItPuExee/2E+/sG/AuDFf/RmHn7CSSyWzU7PPUkUV6QE825usNZQZJ7FKpJpw7B2DGtHCBBioHGpbZ5SMNu1ND5Q1gFlJwFEmp5NlaBQEaUUVROw2mN1Cuiqm0Avt9RFYNg4BqWnyCJapeRvpRR121IvxMgtseaImYL5rmXcBBbLBoXCKEUEOpnGxUimFaAZlClIqxdBd7a2G1yqcqnVXwgw182xWrO+n+FDCr4yShFi2tfJrEKhCMS2ilSkk6UKU9K94/Cwplbrv/jFL3jMYx6z386vlMK57cupieX+/u//nhtvvHH6+KEPfegqjkYIIcS2JlWIJq3yiiWt8iD9/44Yp4FNO6r0tDTAqPSezKZSrr0lz5kcNjnPre0WccPCmBsXKgZlk/pZ+8hNg5LaBRbHDqWg9J6uMcx2MyoXuG7TmPW9jCNmOtPz5DaNe7BlgVc+/2n89D//g6Nvezvece7nKGY3TMe+N8FRe1sla6awFFYzqlIv69zqnZbXVbSt+wojE3BxSJO5vRBCCCHWqmuvvZbjjjuOm2++mQc+8IF85StfodPp7P5AcVAJIaZWH+1mzTRpRSkKq+lm0kJjrZK1hhBCCCH2h25uKJ1nYRyZyS2ZVcTAtMvEJAiodgHnAyGmuWU3N8QQGdeO+V5GYXMWS7dsn2GmsJz/sY/x9jf+KQAv+F9/wpNPfT4hMD33thqfWt7lRrfVkRQ+pqpRjQs0LlCGtL/TyyyDqqFsUhu72U5GjClAymrNTEdjlaLIDVYrKhcY1x7vI3UIdDPNsHKp5V57fCBSWM1i6Rg3jqpx1CHNs50PWKPRGnwMaJ1aCA4qT9k4BlVDbhVFrmnaNoJZjDQ+kls17XwSFQwqTy/TqRAAkQiUjWfTqJ52D4lK0S8KOpllQz9Dodr3KAWRuZBa8WVG02tbDkr3jsPLmvpk460tRSH2ibe//e3LHp9yyimrNBIhhNj3DoUbo5Ngna2t8pYH12gFnlShCJ8mmjua600CjOJ0cr787ycTcT3t77z378t1m0bcvFgDsFA6FsYN1ui2JGuq/uRDau83VGkyPtvN6Hcsm0YNPsJRs2kjQgFVVfInv/8cfvhv/8L6DUdwzme+zLrb3pGFUd1OnlWqgJUvv/BJ+dm0gElzD6UUWrGspO3eVMnKjGa+pwnBrvnvmBD7gszthRBCCLEW3XjjjRx33HH893//N/e61734+te/zuzs7GoPS+yBxodp0sp2M9IInthWLHaStLJGyVpDCCGEEPtDjDDXyVgcOxrf0M1SdaHGBUa1Y1R76saDUiit6FuD0ZMAnYg10LhI41wKHNJmet4LLriA//U/XwbA8176cl74P1/JYttJIxBxPs1vjE77CFYpMqOAVMEp7V1ofLuRM25SQFRVOqoqBXR3M0M/T10rCmvoZmmO24SARqF1qt6kSMnedScFZI2bADGQm7RHsqGf40Nk86ihsIZR4wk1GGPoW4XzgRIYN4FuZhm7hmHp8b4ks6ZtQ+iZ6Vhmi4xh7SiyNPaFcUPlU5BSF41RGt/u0wyrrYHpZeOJEXKtUyJ9E5jtWOa7Gbk19AuTKlpJ9w7Rkk9X7JHPfOYzXHTRRdPH97///fnd3/3dfXLuG2+8kZtuummPjrn66qv3yWsLIcShdGN026CdbQOWcqtpvKdjTVvmNRDy7asnTR7tKAgoxEi9pNc0pMpUe+OGhZItowal4KbFks3DGkckM4p+kdGxkYhl0E56nY80RDaOa0rvOaJfsDBuMAqOmOnQOMebXvkS/uUfv0N/ZpZzPn0h9/jVe05fo3JpIVG7QC+nPWdIi5YlpW2XvqEeaLyndp7aRWY76Zr3JhZMa0W/sLttwSeEEEIIIYQ4uGzZsoXHP/7xXHXVVdzpTnfisssu48gjj1ztYYk9MKjcsg2V3W2UlM5TOi8bJUIIIYQQIu0HROgXJrWMM6kuURMCLsRppwjnI6X3jGtHRJFbRS83ZDpVdqqcb9u5Jd/65mU8+5nPJITAc573Av7wz97MxmGVuoJE6OYZHbt1M2LceBaa1NLPaDX9qdoEb6MVzkeMVlilqEJgVDaMG98GD6WNkczqZcnjSkHeVlQa1Sm5e9Owonae4BVHrC9SO8G4tfLSjYslRqUqUsPSUbtA5R11E4kxEELAGM2WsmFLGdEocqvJMt3OwSNGKQalp3EBpdN7ao2mn6d9mEyrlPHfztldCPgI/dwy38vaqleK+W7O7dd3cT61+Wt8kO4dYmpNreY2bNjAy1/+8tUexmHrhz/8IS95yUumj621fOQjH0HrffMfirPPPps3vvGN++RcQgixJw61G6OTyfnOWuV1sjSptUZjtcKFuMPqSXHp+VgeBDSuUzS+1Wra27rblhvdE6PacdNiBcAtw4ph5UEr5jLDhpmcuU7OwrjBx5QRkfp0K2oXWSgbRrUHKo7oF2waNfQyzRvOfDnf+dal5HnB+z/2GY69328AkNk0eY4hBblNKmANK9eeJ3F+559/1ZasjVWkmzvWTSKrhBB7TOb2QgghhFhLRqMRT3rSk/iXf/kXjjrqKC6//HJ+5Vd+ZbWHJfbAlnFD2aS1X1l7xo3HbVsaGcBHqiak1hqZoZMbhpUjxMhcJzvAoxZ7Q9YaQgghhNgftFJ4YmrDZjSdrK1m1EBmFGUdGDee0FY4yowhtyodF2ChbKZ7MgCl8/x/376CFzzz6TRNw1OfdjJnvfO9bCk96/oFdYhsHtVsGTfkbeBOJNK4SDe3uOAZN4EIbOjk5Ca1pVsYpb2TOgRyrVERZjo5gdSyrvKeXmapXKCXRbI2eKiTGbRSyxLjUWmPxLb7QJM2dr12b2y6j8RkDymSaY22ER8VjY+oEIkhEIDaB5oQKLxmOHb0OgajFD7EVLkqwEzXMt/J8TG917127ynESOUCrolt5SuDRlGHwNGzBUfMpP2amSJjvpcdEh1ixL5z8O3m7sKGDRt4/etfv9rDOCz98pe/5MQTT2QwGEx/99a3vpUHPvCBqzgqIYS49Q7FG6NLJ+epVV6Y9kie/H1uNJULdHLDoHSMa4/VyyPnJ63y1LRVXvp95fw0kKibT6pF7d0E8pZJ+7xRTdme8/bzXQKRENNEd9tPI9OableTG83Nw4pR7elYRy83nPVnf8I3vvx5tDG84T0f4R73ezCDyqGAxXEDIeIj017fi2XqqT25rrLe+ec/rj2jKpWfnetkjGpPL/fbP1cIsSIytxdCCCHEWtE0DSeffDJ/93d/x/z8PJdeein3uMc9VntYYg8MKjdd+y+UDVW7DlQqVT/OjJ5uAjU+pA2XEFmsHHUIzHUyxrVHK3VQJkiJ5WStIYQQQoj9obAp8GjSjWPTsKbIDN3M4kKDMYoZY6eVmzKj0ShC25GkdoHaBxbGDdZqfnH1VbzkmSczHo857vjH854PfZTMWmJwbBk3OL+100dKGtcpuVx5BlVDCCmoiQiD0mG1onKBYZ0KAWjAx4iPkUwrMqUJEQql6eaGwhoKq5nrLt/jmrSpcz4QQnrtwmpKn/ZHah/I2i4cs0XGjXVJ7QKZ0cx2MoxSlN6zaVARYySqiLWGmbYy06j21C5QGIVVqYpWiJ65jsVHKJuADxW3mSmY7+bUPrUqrFzq+GGUIs80XavxEW4zWzDfz6f7YL0i/ZTuHWIpWcWJ3dq4cSOPe9zj+K//+q/p717ykpfw6le/ehVHJYQQt96hemN028l55QL9uLxVXi9P1Y8Ka2iyQNUEFsuGbm6mk8dm0irPpMdWq2XVlYpMbzfR3BPOBRarBoDN44aszUiY72UsjhtcG/2/bbjVJG6pmxvmfMZC2TAYO776sffxlU+fB8AZb3wX/+O3H0eIqcoUsW3B11bHsloTQsmRsx0ABtXSz78t5WrUks8/smVU04RAbCKV9+RWE2P6Hh1Mn78QQgghhBBi3wkh8NznPpdLLrmEbrfL1772Ne5///uv9rDEHmh8mFaJXrr27+WGbm62ayvfyQz92CbH1J6qCSzQMNfJGFZuer9ACCGEEEIcXrpZSpjPrSYSGdWeSAo+qts55mSPZds5ZmENIY9sGtZE4NqfXM1rX/g0BosLPOihD+Ps8z5JnucslA0uRFyIdDKN1VmqnERqlRcJKAXjOuBjwLYbJqPGoVVqoVf5QK6h9kCMbZu9yHw3tZ1bKBtCjBwz36X2KYl86XgnSfOlS3tBM4UlRojta4WYuooAVI3HKMVcJ8O2yfOT98QaTUSRaY017ZgV5EZhtCYzhsKmP4dg8SFgNORtcNmw9oya8TSpf1Lhyai0jxNjmtOv7+fTAgb9wspcXeyQ7OKJXVpYWODxj388P/jBD6a/e+Yzn8mHPvShff5ap59+OieffPIeHXP11VfzlKc8ZZ+PRQhx6DuUb4wunZxPyrKO69T6b8Iu6RM9U2RAeg/GtadsQurR7FNf5kBkUDpiNKj2fSkyfasnmhtHNSGmdnq1T9W4NvRzfIAiM7jaTTMTJuVNfUwLgkkDu35hWCwdX//8x/jKOe8G4FmvfAO/86SnMagdmVYsjhuUglHt8SHSzQzjxrFx1PbgNmr6+e9s0aJoA6EAo9PzCxPQbbDYwfT5CyGEEEIIIfaNGCN/8Ad/wGc+8xmstVx44YU8/OEPX+1hiT00qrZWiZ6s/ea6lsLuPMFHq5Rdbo1iYeyomkBpfGpNX3nme7L+E0IIIYQ43GitKKxJAUMx7SFsGaXk79xqZjuWfBdzTOdTYNHwll/y579/Kps33sK9jr0f7zvvM0RbTPeqrNEcMZMTYpqXThK7x42fniMSGJSOzCrGtUeRup50ckPHGjJrKJ0jMylYalw2NM6TW8O4diyWDbULzPdyFLC+n0/3RSbJ6aH9Q2YUtUut6AB8iNO/mxQfmOlYerklhMgtwwrvA4UxjOuG2jl6maFXGI7oFTQhMCgbxk2grKGTp02gI2YKlEqv50NkXKdiBURofKSwGtOOMUaY7ViOmCmmCfzd3EgSu9gp+WaInRoMBpxwwgl873vfm/7uaU97Gh//+MfRet8v/o866iiOOuqofX5eIYTYkUP5xujSyXk3Myy2VZ6sUcuur19YQoyUTWCmyMiMn7YTHLRBY/3CMihTkJVSKrUSXFJV6tZMNBfb11gst77WTJGlftlWUwdN4wK1S1kXmYEmpKC2EFM1L6s1/3j5l/jKX78FgMc/5+U8+ImnTftfdzsZLkRCjLgQGFSO+Y6lbDyZVvx885jMaNb1Mua7+bJWgkD7/vhpZbD5XkZhDItlCrYqm4Pv8xdCCCGEEELsG3/2Z3/Ghz70IZRSfOpTn+KEE05Y7SGJPRRCpGoz3cftpk2vbRuyEoU19PJUDWBcp/Vf5Twh2L1qJ7+nQoiMG0/VtoNfmjhULMmaF0IIIYQQB0avMIxqh1YpgXzS/SK3OXYnydNL9xk23nwjf/Kip3Pz9b/gTnf7Vd750c8xMzvHYtteTys13ataLJtl+zejBUeE6dwUIpWLlLXDGiiMwSjFun5GZjS2rcx045Yxo8rhg6H2EedT8NXmcYPWCkUkAnmbUB/bCKhJIFRKmI9M8snrNsCqabusKMV0z6h0bZeVTkYT6zQGpZlpr2m+n6FRbJjJuXlQUbvQJu9HOpkhM4pR7enmliNmLI0LlN4TQzsX1opOplnfzekt2ZtK+0sS+iJ2Tr4dYodGoxEnnngi3/3ud6e/e/KTn8ynP/1pjNnzdklCCHEwWes3RleiV6TAqE5uqENqlbcwdvTyuKwi1mwnQ6sUOJUZjbeR0gVymyagvbZ60vpeTr+wywKHbu1E07cZBZOWfd3cYE3qbT2uPTO5ZYAjxMhi6VAqlWXVWjGqHEVmuOKbX+fTb38tAA964rN4zDN+n0ylG8VznYy5bppkD2tHJzeEGAkw7aldN5Fx06B1mrhHImmKn8rFNj5MJ/95ppktUpWsI2ZyQB20n78QQgghhBDi1nnnO9/JWWedBcCHPvQhnv70p6/yiMTeGDd+ur6bbNp08z27t9nNTcrOD5HaBXKrGTfLqzLva40PjCpP1SYKLRPBE6eVsAubsu+lirEQQgghxP6XGY3RikgKRNJGo7wnxMjmUUNuNJlVTMKNGhepfSDGyOKWzfzRi57Bf//Xz7jdHe7I+z/xBfrz63E+VYPKY9p7mOxVLd2/KaxhtpORu8C4cvgQ6eWWUe1ApU4XG2byafB8v7AsjlOCurWGHqTXqT218zQhMldkECHTirkuVC60/6TXmwRCTYoLqHb/o2m7epQ+7a/lbUDX5PwAg9pN2wt28tSBJDN6em0ZmvVdGDcpcV6r1LFjrpexrpexZewgRopM08kNWqXXWdrxQ4HMhcWKSWCU2M54POZJT3oSV1xxxfR3J5xwAhdccAFZlq3iyIQQYt9YqzdG90RmNP3CMqwcc52MhbZV3qitCJUb3VaBShNmo2BQeWqXWtr1+tk0CKiXm+l17cuJ5qTU6uSnVbp9PTvtyT2TW3KjcS4wdgGlFOMmXcM1//gd/vrPX0EInvs86kkc/7xX0y0MmdUcNdthtm31V7uAD5F+brnNbMFNixVl4zFKE3AYlcqyjmpH7ba/JqsVnSWBc50svbcbh/VB+/kLIYQQQggh9t55553HmWeeCcBf/uVf8tKXvnSVRyT2VuXSZkzZJkcV7abNntBKkRtN5QKlS23WKxfoF/t8uAAMKsewrbAMaU1bOk8ISypGaUXHGnKrKZ2ndF6y5IUQQgghDhBrNJ1Ms1g19HNDjGmPYVjVxNT5DQVtW7i0F+PKEX/6+8/i6h//kCOPOppPXPBVbnO7X2HTqGGxbAgRVAjb7VX1C0thNaM24MhqhdaKXmHTHo2CiEvt83QKPOpYTYikNnSAijCuPIFIYU3af3GBkXHkmeamxYpOZqb7IFXbsk9rRXCBsvH0ckunLZ6StQFScdpqL+2rTAoR1C601aQC/dzQyzO0Um3lqa0yq6hcmmsXWbrGxkVmO5Y7bMin+1hSPVXsCxI61xoMBnz0ox9d7WGsuqqqeMpTnsK3vvWt6e+OO+44vvjFL5Ln+SqOTAgh9p19eWN06Xkm5z1YzBR2Wr50rpMx27FYrYgxjXWxdCyMHYulw8f0/CNnco6aK9jQyzFa0S8Mc90UyZ/+vmC+l+2T6PvJhHXy08Wt799skU0XALnRHDFb0M8tvcLStZr//o8r+eBrX4prau7zP36HJ/3BG8gzSy8zrOvlzHYyQkzBTotl6vFdZJpuZlnXzbjdui6VS9WgZrsZ852cQOpdbbUiM4o8S1kM872tGRq93LRZGgf/5y/E4Uzm9kIIIYTYW1/84hd58YtfDMAf/uEf8sd//MerPCJxa4S4PCFnb9eyk+rJ0wSfuF0dp31iy7iZBkWVtWfTsGbLOCU6NT7iQqTxkaoJbBk3bBrWlO0m2bByLLTrX7H/yFpDCCGEOLiEEBlWjo3DmpsHFTctVtw8qNg4rBlWbjp/26evGSOznQyr0hzMhRQs1cstxiiMUikwCoWPkaqq+NM/eD7f/+fvMTe/jk98/ivc5173TNFTQNnuLWRG7XCvyhrNXDdjfT9v93wUWkHTeKxWzLb7P3mekrpHtadqUkD/uPI0YevehdWK+W5OJ9dYVOokElNVq0HpGFQNmdWUjSeGtO9Ru4BWkFmNAvI2QGoyJdYoQog07XVUTaqgZZTGGk3RzqXzbebiqn0DQozk1kz3syZVpxof6GaGDf2cI2cKbjNbcORMwYZ+6nAiQVFiTxz2KSTf+c53OPfcc7ngggsYjUa86EUvWu0hrZq6rvm93/s9LrvssunvHvOYx/CVr3yFTqeziiMTQqx1IUTGjT9oorr35Y3RyoX9fmP01pjvZhitGFYuRfxnZrfZphP7O9vUtJ95ZvS0v/bckv/d9NpqUePGoxzMdCy28Wz8759y9mteRDUe8au/8RBOfMVbcNFMKzllRjMo3bQ8LaSgqJm2AlaRGea6OWUTuGVQ40PAGoVSmpk26GkpRfqsu/nyKllr4fMX4nAjc3shhBBC3Brf/OY3OfXUUwkh8KIXvYi3ve1t22U1i7Vlskybbtrs5ec5OWzb8+1Lg8pRtln2C2WztWWJSgldmUlJXSGmNnpVWwV7sXLUITDXyRjXHq2UVI7aD2StIYQQQhxcVrP1cIwpIKp2kU5myIyiCZHSBaYxSEqhtMIS+Is//H2+951v0+31+OinL+QBv3G/9jxt0rgP5EZj9a7Hl6pFpWTvca3aKqaWTqbTPDCCC6lzyFxXM24Ck+HMdiwuRrRSxBjJtMG0e3TT9oAxtc3LrUIpGNaOqgmpAlY7Ic6txoWIb7uxAAQizqXnOR9x7Xw1s+marE7Voops+fXF9pObzNEnyfLSqUPsD2vmWxT34Wrzhhtu4OMf/zgf+9jHuOqqq6bnP5xvdDjneMYznsHFF188/d0jHvEILrroIrrd7iqOTAixlq3mxHRX1tKN0X1hZlJqtf0scquXBUAtdSB7Ms8WlnHtme1YFsumzawIyyb/1mhmjSaESNd5fvyfP+GNp5/GYMsm7vJr9+WFb/wAGytLZmC+m1O5QC+PVG5rWdmlbfC6bf/pECP93FAVpg3AUtNJeyfTbeBeymDo7CRwb618/kIcjGRuL4QQQoiDzT/8wz/wlKc8hbquOfnkk/nrv/5rmU8cApQC4tb1294mtEwOm5xnX381JvdGYHlQVC83dHOz3X2LTmbox8i49m1FgMACDXOdrL3Hog/I/ZWDkaw1hBBCiEPfarceHlQNo9qjVNuuTqW9FaNTe7kQU9CPbyLvfMOr+LvLLyHLC/7yQ5/kmHscy3UbR8x2LMPaEWKcVk4yu5lj5FbTuEBhNZtHgcYHjFbT4yaBTZFJpSdPJ9OEmCpDDWtP7TyDKr1uYQyLZcNsxzKoNIXRjGoHpGvw7djyTOPbYKV1vTTf9IDSCnza55skkJfe0/iAD1DYrcFQudm+c0vj2lZ/OhUyCCHiYqBsAqPaMdvJGFSOY+Y60jZP3GprIjDqZz/7GQBZlu31OUIIXHzxxZx77rlccskleO+ni6TDfSHjvedZz3oWX/rSl6a/e9jDHsYll1xCv99fxZEJIday1Z6Y7spauTG6L2VGM9/ThGAPmupdG3o5Nw+qaWWo2ge2jBqOmCm2e67WiuGWjbzupadyy43Xc8e7/ipvOPtTDFWHWtdkWqWKUArW93Myo+lYg11yI7iXG/qFpR7WEFPFqkkPbqUVs0VGZhTreitrHbv08w8xBWNtHKpVf1+FONjJ3F4IIYQQB5srr7ySJzzhCQyHQ44//ng++clPYtr2EGJt00rhiWk91m7aTFp07Im6bQsybQm/j+ecoyol95RtkBPAXNdOk3x2RCtFv7BYo1gYp2z+0ng6mWFUeeZ7h19glKw1hBBCiEPflnEzrbJZ1p5x41Nw0rba9sNWK7qZoZOb1FovRuY6ez9XGFRuOjcctwE8uU0dK+ZzO22HVzWOt73+NXzroi+gjeHVb/0g9/iNh0xb/4UYWRg3VI0nRsismlZQ2plOZoioVDmq/V2MW4+KpLbLWqnpGCfVlsrGp2Txdp+urD0LowajFUfNdVgce2a7lmGVgvStVRil6eeW2cIQ22pUtUvvaeMjHWOomzB9rRAjZeUY1Z5ebsitmbbP62xTLSq07ft824Jvc1PTzVN7PB8i3sdpMNZkv/FAFlgQh541ERh1pzvdaa+P/c///E/OPfdcPvnJT3L99dcDW7M6VFsqLsbIQx7yEE477bR9NeQ1I8bIC17wAj73uc9Nf/eQhzyEr3/968zMzKziyIQQa9lqT0x3Z63cGN0ftE43Tvvbxx4dcNZqZouMLWXDum7GjYOKTaOawqaWdkstbNnMy575VK695qfc/g535K8+9jlUbx033DTAKMUxcx36HUMvT+0Cm3ayDCmLop+baQCTVkyzGTKjaXwgtvVk96TdeO0CzgdqH3EhYrVaftN6FauiCXEwk7m9EEIIIQ4mP/3pTzn++OPZtGkTD33oQ/niF79IUaxswXSwtY3fX/bHdR6o966wac3XsYaqSe3n+m0LkRWPtd20Aei0a75iJ1WY90YIW6sej9t7Kb0llY93p7CGXh4Z1alFfSebbHjZQ+L7tydkrSGEEEIc2la79XDjA4vjBucjv9w8ZrFqGFaebqaZKQxGpzGUjeev3/U2vvw35wLwyje9i2Mf+lg2DmoGtqGXp0pIpXMYpdEaFku32zFplYKinE+BVJVPlaF8u7FRh4hRihADMaq2Q0h6T3yMjEpHVXtGtaNxaY5rjWLTsEFFUrWoGBk1gSLXrO+mxPJxHZjrWnq5ZVSnoPFh5cmsSlWeQmRQObRKwWKQ5s39tjVeN1+exA4pUGtUO5yPzHYsSim0Sp/xoGzS/IuINZqZwh7wAgvi0HNIfmPG4zGf//znOffcc/nOd74DbF9CN8bIve99b0477TROPfVU7nznO6/CSFff3//93/OJT3xi2e+uvfZafuM3fmOPzvPtb3+b29/+9vtyaEKINWq1J6YrsRZujB4ujpjN2VI2zPVyxi6wWDZcv1Cy3gVmOxYfIouDAWc87xT+49+vZMORt+Ht534OuhtYrBp6uUGblI1RNp7ZIn2mqr2ZXmTp+xaBYZVaDHgfCBE6xjDA0fiAayOjVlpyP8TI5nHNqPLMdbJp9aiFsjkoqqIJcSiRub0QQggh9pdf/vKXHHfccfzyl7/k2GOP5eKLL15R9fSDtW38vran19nJNC7EXQY7+RgP6HvXzVICVm512kQKqf1cfw/WZOM6ZfFbrcitRrXn3VfGTXov6vb+iFJp82hPdHMzTUqrXSC3mnGzZ9d5OJK1hhBCCLF2rHbr4cYHrt9cslA2jGrHqHZpHys3KK0Y1YEYPTcvVlz48Q/z8bPfCcDL/uQsHn7CU3E+Mqwd4yailMO3iQIdY5jvZjSkxwvjhrnuzgsH9HJD2fh2fyviQ2BUB3KjyY0BlRLAlWLZfpxRipsHNZvHDVYbbB4ZDRw+KDQOImid2tpBYFxGnIvktmFDv2C2YykbRy+zhDZoaVCm+eewThWdOplJCeRa02nns53M0MuXz0lrF7hpUNG4kLp8uDANQq9doAmRrK1KFWJgy7g54AUWxKHnkFoZ/eM//iPnnXcen/vc51hcXAS2z+ro9Xq84hWv4LTTTuM+97nPKo949Xnvt/vdL37xiz0+T9M0+2I4Qog1brUnpiu1Fm6MHkgHMst5R69lNGwa1sx1LDFEtpQN/71pTIgRi+edf/QSfvDP/5f+7Dyvfd+ncDPHsHmxIhCxJrXAC0RuO9/liJkC51PbxsanftlLA5RSVoJiYVzTydMkPUaoJ72sVxgcd9NCxajyWK0IRBZGNTOdbPv3aZWqoglxKJC5vRBCCCH2p40bN3L88cfz05/+lLvd7W5ceumlrF+/frfHHcxt4/fWjtZpozolPeVG08kMLsSdXqdWqXJ07QPdzCxfWy8JdrpxocSFSDdPwU4H4r3TbWXf0nm6mWGxbe1hjVpRRabKpfsVsDVYqbArWyOvdK1dtdWoy7Zq1CSrf4+uUylyo6na9zS36c8HQ7Xog5GsNYQQQoi1ZzVbDw8qx2LZsFA1xPZx4yOKNMEbl2nO2M013/zSZzn3nW8C4GkveTUPf/JpDEqHNSoF+7jAuPIYo1AojIE6pMAghWLTqMa0nT92JLeabm4Y1o5eYRiWLrW58xHnG4zSZDbNJTOTEsabELhlWOFiYL6TMSwdt4wqImmfrptZMgPWGhofaDyUjaOvLPO9gtoHNo8b+rklRpgpMmYKyyA6rFagoHEeiGRZ2i9rfGC+my0LigoxUjaejcOaxgVya6h9oGkT5ZVKgVn9wtKxml77HijFAS+wIA49a/6bcsstt/CJT3yCc889lx/96EfA1kXMJLvDGINz6YbF7W53O97ylres2niFEOJQtpoT0z2xmjdGDyYHMst5V6+1oV9QNSnq3wMhBGIMOOd5/xvO4J/+/ltkRYeXnfVhekffhWHlMFox38kpnWPjuOK2WYeZjmXLqN5t28ZObsisZlz76Y3nygVqt7LguE3D1PIPUk/tQRnJrcYYddBURRNirZK5vRBCCCEOhMFgwIknnsiVV17JbW97Wy6//HJue9vb7va4g71t/J7a2TptsWwo2zX9oKqpao9qr2VZCwwf2dRuanQyQ5EZFsYNC+OGbm6WBTs1Lkxbly+UDYqUZLSd/fDe9Yq0/u/khjqElJQ1dvTyuMMkLkibNpMkLoAiSwFik/Ptyp6utVNCT2pDAuz1unsSDDU5T1hhReTDhaw19q0YIz/5yU+48sorue6661hYWKDX67Fhwwbud7/7ceyxx2LM2kwgFEIIcfBZzdbDkzVA2XjK2rNYNmwZN2gFKIVWCqVTa7jLL/4SH/+LPwbgd055IY845cU0PjDXy9BK4UJgWHlK7+hnhplORi+zuJg6nAzbuefmUU1h9Xbt5yDN+Xq5Za4TuH7LGB8jHauxVjOqHAEom4CPEdpWdMPKUVaerjUMakcTA51M08ksc12LIl1HZjU+aDLdBiP5yOZRTT+zLGapapNSisx4rNHMtpWt5klFBLaMG7yPVD4lWCiVEkkicdq6z/mQEjCsaX+f1hKznYzcahbGjhgjs50MazT9wtDJzAEvsCAOPWtyNy7GyDe+8Q3OO+88Lrroomm1oslCZvLnY489luc+97mcdtpp3O52t1txFYjDyaMf/egVtw0SQohdWc2J6d440DdGb619XdXpQGY5r+S1+h3LoHKMa0dm0w30j739T/nety7G2IyXvels7nnfB6JNKk0LMCgdtY/MFZbGR67fUjJTpF7UudVkRi0JUIrTtgSD0mH0pB1ixMdIYTWLZbopHXbSVjHEyOK44YaFCkgZCrZ9z4/o58x2s4OmKpoQa4nM7YUQQghxIFVVxVOf+lT+4R/+gQ0bNnD55Zdzl7vcZbfHrYW28XtiZ+u0QdkwqlLl3XETIII1ChVBqcC81cx0MkJMQVFlk6op37xYUfmAaVt3FJlJrc/bDRUfI7nROB/SmwZ0Ms0RM8V+f+8yo+kXlmHlmOtkLJA+v1Eb3JYbnSpBK9qKwoHah2nL9CLT06CsfmF3uYbbm7X2xmFDJ9PT19vTalETk8Mm55FbvrLW2NcWFxe56KKL+OpXv8q3vvUtbrrppp0+d/369Tz/+c/nzDPPXFHg6Z7627/9Wx7zmMfs1bHf+973eOADH7iPRySEEGJ/Wq3Ww0vXALcMa4aVY9QElIL5XkZhNJWP9AvLN77xdT75l39EjJHfOO73eNSzzkBHxWLtqFxI8+IQKV1AATFPQU4+Bvq5IW+DlmofWCwdRlccNdfZ4Z7DoO2IQqpZhbWaI/sFG1FYTdrD8mCUbufnkX7HsqWsGdcpKP+o2S6z3QyjFc4HZjoWH1KSQiSSuYjX6b1erB2dxrBl1GBnFY1LVatCTEkBmdEcM9cht5oQIltGDS5EbhnU23VaaXxqn0eEYe0prOao2YLcGkZ1CoqyWmHbwKpOZlalwII49Kz+KnwP/OxnP+O8887j/PPPn7Z72zar48gjj+S0007juc99Lve///1XcbRCCHF4Wa2J6d46kDdGb439UdVpT7Kcx7XH+4hWkGeGWwYV3dww381XFJC10tcajRt8iMx2DBuHNZ/8wNv41pc/g1KKP/zL9/HbTzgBTWpb1/hUalYpOGImZ9z4drHQMFNY1vW2D1AqLIQ8lWkd1x4f2u9sjBRak2eKGBQ+RjYO651+/otj1771W4Oijp7rMN/Ld/oeyKRdiB2Tub0QQgghDjTvPc985jO5/PLL6ff7XHLJJdz73vfe7XFrpW08rCypZnHJBs/SdZrzKWEI0iZF3SY/zeSW+V5GN7f4mKooa5U2K2YKyy82j9k4rImkzZ35ToYiBYyFGNk8djgfppWROrnhNjPFdJOjs2SzZH+9dzNF2ugpG89cJ6M0aW3oQqRyYdrObimrFd3cTMfXzc0uA7P2tqKYUmnzqnYpc35vKz1NDpt8HQ/n2B5Za+x7i4uLHHXUUZRluaLnb9q0iXe9612cf/75fPSjH+Wkk07azyMUQghxKFuN1sPbrgHKScK80XQzzVw3o7CGxarh/373O3zgtafjXcOxj3g8j33haxhVHuerFHgUIp1MY5QiRgikueY488wUFq00W8YNENlSOzrWpjWHgl5mt9urGFaeqvHMdTPyTGOVovGR2U7aqzKmnVsaTYyRCDQu4pq0N9bLDP2Onba8y7SmbAKNT+9zjJM9DVCk6q9KQeUi4zpgdWBOwYZt9kVs+/5mRrNxlKpHBRvpWIPSpCpSQAQWxw2dzLChn6eWei4wbt/jTru3mJvln/OBLrAgDi1rIjDqb/7mbzjvvPP49re/nf7l3WZxmGUZT3ziE3nuc5/LCSecgLVr4rKEEOKQshoT01vrQNwYvTUmfavLxlO7VNWqdL79/2B7U7sw04nxSqo6rTTLuXaehbJhUPlpGf7ceWaLjGHlibGeBpbtLCBrT15rUIFSitJFvvapj/C1T34IgJf/2ds47sSTKLL0XKNThnAkcsNCxc2LJU0bjNfLU//rECLabP/d00rRyy1WazYOK2qXFhZFbsiUYaZvsFrv9PMPMWU5z3QsZfs9Wd/PWN/feVDUUjJpFyKRub0QQgghVkOMkZe+9KVceOGF5HnOV77yFX7rt35rRceuhbbxK02quXGhxIU4TUxauk6LpPXOJDEENLlJa7dR7XExMltkbfXedNzNg7pdj1nKNhBoUiFp0yiitKIwKVN9UDqGVc1MJ8NqRS+zLIwb1vVy+u06W2u13967+TYjflg5Oll6vd1VdJrYXfXkW1NRrHKewhoqH6abZp1sz6tS1+0adrK+3NvKU2uZrDX2H+/9dkFRd73rXXnUox7FPe95T4488kjKsuQHP/gBF154ITfffDMAGzdu5OSTT+aCCy7Yr8FRd7rTnVb8eXY6nf02DiGEEPvHJHD8QLYe3nYNEIHZjp3uIU3mWtdd9UNe+/vPpq5K7vvQx/CMP3o7Y5eS/8eNp9vO7Qqr6RcZTQgsjhtuGdXULrBuJufOhUVpGJUh7YVoqJ3nhi0Vc53U9m5pW72O1XgfmJnJ09yyCWRWkWtD6RzdTOO8x/lA5T2F0dSuIaqIjtAtDEaptt1eu/cxfW8VMSqU0vRzgwuRmEdCgG6hIUZ8CCyMHFqpaQGB2Y7FaMUNCyUznYyooG7nxMakZIiq8an9IGkMWZugPqrdNCiqyPR0ndXbQfGFA1lgQRxa1sQ35NnPfvaybI6JBz3oQTz3uc/l1FNPZf369as0OiGEELA6E9N94dbeGO1lhmHl9lmLu4mbBxWbhjW1D5S1n95gXqpsPAulIzcNM0XqwdzJ03hCjNMJ6cRKs5yHlWPcBDJjmO9qBmXD5rFjsXQsjBtmC8ugUhxNh15hdxiQtScZ1WWTsiLGyvHFz3yaT7z3LAD+5x/9OS9+yUsAWN/LphP/0FZ12tDL2TxqyGxAt+/NoHJorThypthpOzwXwvS97GaG+W5G2QTmu51pZsKOPv8QIrqb4fzWQKzbzO7ZzTSZtAshc3shhBBCHHgxRv7wD/+Qc889F601n/3sZ/md3/mdFR27FtrGr7R9m1WKYT1pBVJNk0d6uaHINBsHKXFo86jG+UiRpTVw4wPOx+n6XEXFLaMKHaH2gcaFtt2FonKBURXQHUVTe4iREGHzKGXAdzJD7QMbBzV6NiVHLZapvdmoTglS3TxtkuyP926msBRWT4PIcquXrfOXSlWvdl+Z+dZWFAshMqgaOsawUDYMraNf2D0KbEqt4tPrdtrvZrGT6zqUyVpj/5ubm+MFL3gBz3/+87nvfe+7w+e8613v4owzzuAjH/kIkIKqXvjCF/KIRzyCI488cr+M62//9m+5853vvF/OLYQQYvVt2yp4f7ceDiEyrh3jxnPjYkXjA3XbAm9QORRprnfdz67mpc/8PUaDRX79Ab/F8/7sPSw6hdZp7ymSEsKt1vjAtFWdD5Ge1WSZZjBu+NktA+Y7OZXzjJuGzKSE/LJ2KXhpFOlmhnW9nG5hmO8WzHUzRnUKsO9mEaNTEP7YqdSmGRiXDucjzsOmkcP70HYDMenaY1wWINXPLS4ElFKYtkKs0REUjGtPCKAynQKt2oCsSQJD4yJHzhTkRnPLsCIzii3t3HjSacaHQDc37RwYalLF2sncrcg0M0Xa1+rlZlkw2MSBLrAgDh1rahdOKcUxxxzDc5/7XJ7znOfwa7/2a6s9JCGEEK0DPTHdl/bmxmhmFY2L/z97fx5vaVrW98Lfe3iGNeyhqnpkJjHh9QhoiCAmiiMagggCigcUBaJEUEQ0EtFmcAqKHESNQutRQYEXJaJyUETjgKiJnrwRxQlRmkF6qGnvvYZnuKf3j+tZa++qru6q6q7qrqq+v376U1W71n7Ws9baWNd1X9fv9+NY112wiLsVt+61HJ11AMw6N9xXJKVEYaQYLbSiGO6x94Hji8DSBQ5NSjbrgqaXaIODitZzUTmLQ5X8XefD2hnJGjjZeNwyMS89hVHsLB2HxvJ82+PilIWsc1VUx2FBCOA97/pVfuxV3wnA//kN38xXPveFa+Xssg9sjuT1ti6sfy7GpcF5UUOsbF5nrUcr+ZxKu2/N2nuxgk1piHRALFxLo9kaF1gtj72jz39n2cu1kjQ10/r8DqohF+2ZzEFybZ/JZDKZTOae4tWvfjWvfe1rAc470ulSj40/n/i2460nRBnouOEx00ociI/PenaWPW5w0FWs1OJgtURw7DWOeSexeEopOhfwCYyCQmsqLQMYq0UR7kJk3gQaH1g6GSBZowgJdhY9rQ9cM61QWlFaWYRaufeOS8OkshflvSuMZmusidGeNXbwXBaw7q6jWIyJnWVPYbREqvQSI3I+r7Hpw/BZqXUfPLoLrlNXCrnXuPBYa/mu7/ouvuM7voPDhw/f6WPH4zE33ngji8WCt771rYBE6/3kT/4kL3/5y++J281kMpnMFYYaDvlXx/EXM3rYhcixWceJRY8LkdZJHHRlNSHK0n/vA3/1tx/mO5/zFeycOM6nfOoj+c4f+b857gw2BialJSrYWXhSDNSlwSpN6zwhSuScj4lFK4tPSitC6IhJZiaFlSWqQiuuqiylkbqu85HCaloCk0FMoJTUt60TMUGhNZ0P+JDYaRy7jSOkRAwy+9gcWepCM+88pdFrp6jKahJpnaSxWrKvrJEoPp3oQmQUZVGqLuTvTxcwbA4LYa0LbI/L9X35oeZddoF563AxMaksKSXpHw6IT0aFudNa+J42WMhcGVxWspGUEjs7O9x000189KMfvZ3yI5PJZDL3HqcXkhezML0YFMNyzFXTimk15DAPFv5GKwqjmVaWq6YVxihmrZdYO+SAfK917Cx7Ti7kMHmvdfRe7FVbHzix6JkfUPDeEcfn3Xop6ti85fisZ9Y6tNpXJRuliAlRFgSJQBiVhqYPnJjLc4M4P62Whc5F5bzo/Hopat455q04YS16v36eulCo4WC8d4Fl77lt1vKxEwv2Grf+71wV1e0wZHjf7/4O3/sd30RKiac96+v41v/8Cvn7Qc3ch7j+mVotUrU+MCoMh6cFRuv1IpQBOieH5vNWnK7mrZfPYzgo3hwVHB7tbyNtj0qqwtzp5z8a8q7HlSgV7o4r2uozgVy0Z+675No+k8lkMpnMPcEb3vAGXvaylwHiYvKc5zznvL7/QsbGH7zOmaLbz5fT49tmnV8vb9WFZqO2bI0KNmpLaRVucM89sXTMe8+oNMw7zyd3GmadJwHLzrPoA70PLFrPvJXHKqAqDLPWcfNOx7z1nFw63CD4qAvD9qhkqy4pjCYmcXoKCYnSQ9G7yF7rRYBDYt555p30asdmPbvLXuI1EPco6YUvznsH4qI1qSyHJyVXTSuu3qi4alpxeFKKY9M5LEVdCEexaW1lwDUMlfoQmQ8Re+dC58V5CvaX9ip719yrrxRyr3HhmU6n/OAP/uBZl6IO8prXvAZ14P9f/j//z/9zMW4tk8lkMvcBVvX3qr5ZzT3Ol7NFD887z4mFzFgSIiSf957OeTonCz0+BI7eeisve/5Xc/TWm3nAQ/8FL339m/C2xoUkMxyjsVozrQzjqmBc2XXNV1lxaIqIoNugWHYiUleski40RmtaHzg+6zg6b2lcZNl7eidurUopDk1KtsclIK6khyYl125WlIU8d1VI7+JDxBqJu6sGAUM5xNiFlEiwrt9BRA8rYX5VyOOUAuLqsfJ8SrEWMCT26+GtUbFebFrd19aoEFG60SilKLSmtpqtUcHWuDwlPm9a37lA4N4wWMhc/lw2jlEpJZRStG3L29/+dt7+9rdz3XXX8axnPYtnP/vZPPzhD7+3bzGTyWTu02ilCCQpKIO4JdV3QZ14tsL0QhJjOm916PmocbuhQB0V5k4j7lasim6A47OWnUYWnKaVZVoXFEYWdWJKuJDWimXfBarh0HvWek4uekojB9PLLrA11neqco4pMW8dR2eiSJh3HjeodAujmdYGqyU+YbUkhYZCKxoXqIyhJXJ80TH1BbtLx/a4ICbOqqjuQ+TP/9ef8u3PfzbeOb7o3z+ZG37w/0JpTeedvL4QsYPiYVxaVm/3arHo8KTCaFnIAtgYFaSUKAtNOhAdobSiNmZd0ENAa3PK+7A6GD+Tg5OoQdJl6YqWyVxq5No+k8lkMpnMPcHb3vY2XvCCFwBwww038G3f9m3nfY17Ozb+jvrWEBPLXiLh550/a3xbTImtUSHDnBhRUfrb1dJR5wK9j2tFeaENPiVWkw/nI1rB7qInIPHvLiRqW7FZF+v3pbCKPshiU+8DCsXSBQIitgkpDctOCqU0Icl7I5HnolzvY2SjkshzrfwlrQi/UI5io9Kwu3QizLGKzkmsyLhMZ/w8Qd6HVRwfyNBqdQ4zru67blG517h0uN/97senfuqn8td//dcA/MM//MO9fEeZTCaTuVyphnjn2ho6J7OLyVBXnitnix4+OPtpusCi9+w2Hh8jZSlL8z4mZns7fN83P4ubP34TV1//AF75U2+BaoOTC7eu0/sgs5VxaQkprudnMSRchEJpRpUeFogTizbQhYRSspxUWMWRqaWwxbpel+tYlr1nYyT3M2vkOZVSLFY9gYLaanxIXL1Ry1xjnpi1gWUXmNSBQitQinnnafoAChTynhRar2vJutifDa1ag1WqhlYKq9UdpmOcKalloy4IMZGQGde4stjB9ao0+g7j807n3jJYyFzeXBaOUX/6p3/KN37jN7KxsUFKaf3fzTffzGtf+1o+/dM/nUc96lH82I/9GEePHr23bzeTyWTuk6wKyFVBuTq0PR/OVpheKFyI7C4dx+adLAGFuF56CVGWuuad59i8Y3fp1uqD81Hj1oVeb8vPOr92cWr6cEbnKBcis0ZcpuadY9bKYw6NS67ZrIciUqxRKyv50tvjYn3g2rlIH+LaOWo2LAmJfWk6o8o5RolCOLHoOT53uCBFd+vCoBaW/zu56Ll1t2Gn6YlRCvDGRUKCNLxvs8Yxa0TRutv03DZrz0lR/Td/9UFe8OyvpG2WPOZzv5Dv/9E3YIw5oyp4tTS3UnoeXFDaGhVyGD/E4Vmj2agKNkclW+OSzVHJRlVQDJECldVsjwvGpT3nBaXL3RUtk7lUyLV9JpPJZDKZe4Lf+I3f4NnPfjYpJV74whfyqle96i5d596KjT9b37rXOBZd4OaTDcdnPT5ENkdWnI7OcI+9l4GM1hK5HlJi0XlxJ+o9JxZOFqFgEMhYNipReq8U4j4mGh9p+siikwWrRDplWUyhCDHR9tK/LXoR3oAo1A9PKkalwSiNHaL6RoVho7br/rZ3kVknPe2yD/i46gXP7b27J7lQjmKTUl5/6wMbVYEa3tJlLw7Ue8OgrvPSs696+YNLUSsR1mRwQb4vknuNS4/pdLr+/WKxuBfvJJPJZDKXM6PCoJCFequlhmz6c3PXXHFn0cO3m/30w+xneM6NkWV7VFLi+IEXfR0f/4e/Y+vI1XzzD/88duMqlt6LO2uIhKFeHxeyGKSUOKf6EJkPtW1hFePCMikt46JAK82i9xxftEQSrUvUheXqacX1WzWT0qKS9Ag+Jm7ZbfnkyYYTi55j855F55lUlu1JQV3IQhZKMW89xijGlWZSG1l4SorOySxo2cp9W60wSjEuzHopamUeALIQ5YdIbqXVYDBw9nSM05NaSitJHXZI7ACYVJLUsTkqzmkpCu5Zg4XMlcNl0SF95md+Jm94wxu4+eab+fmf/3ke97jHrf9u1dx84AMf4Nu+7dt4wAMewJd/+Zfzjne8g77v78W7zmQymfsWF7swvVCsXJnONwbv5FKKS5DC+KAa9/CkZKMuqAuzjhDYqAuJXTuwuHSmiLsVy04ON1sfWLQBnxLTynJoUt5hUaeVYlxaNobDz87FQR0A8y6cYl96usrZhcjJpaPzca00XvSeE/OO4/OOpgu4IE5Siz7Q+MiyF7vVcWGYlJpJZbFW7FitlcL92Fxcp2ZtYG8pr/eODmQ/8g//wDc886nMdnd5xKMezate/zNU5b5VU2HldafhrYrrhSI1/Lr6ujQoRivGpWF7XDIqDYVRp8XhKSblgSJb61Ouc7ba+Z6y681krnRybZ/JZDKZTOZi84d/+Ic87WlPw3vPM5/5TH7sx37slDin8+HeEEicrW89Me85sejwIQ5uUoE+RHy443s76Lwr6m7ph04sOpyP+BQphyiLcWkotCwulUYzKS2bdYEZbnrReo4vHE0XmbWOE4uOeetofSCkSOtkaOJ9EsdhJX1kac0gIhLFfBgcfvsgj5f+VgIOehf3I+qGs4VLUVxyIR3FxuX+QtNkeC9W5yudj8xaz14jcfHdgaj4jdqul6JGpQip7qvkXuPS46abblr//rrrrrv3biSTyWQylzVaq3XU2mpmtOzDBYkediHebvajhsdtjS2jwuBDYmc+53te+HX87V/8/5hubvHSH30zm9fen52mZ3fpSCnhUyKkiEExlNvEGFk6qZF9SEPEnl0vwlujsBqcDyx7ibiblppRoZlWBZOqYGssgoWVkcDxRcdO0zPrHM5Hbp21HJu1nFzIvcw6TzU4MAG4ILOs1dxNAWY1N9GajQNRfyBOUeNyv6ZsncyL0GoQArAfr8fZBQyrpI7rNmsOT0qu3xqxPS6pC0NdnNkd9Y64pwwWMlcel9VPyWg04tnPfja///u/z4c+9CFe+tKXcv311wP77hHOOd797nfzjGc8g+uvv54XvOAF/Mmf/Mm9eduZTCZzn+BiFqYXit3GrQvctg9SJDZS6LqQ8FHsOzsn8QEnFz3tcE/HZh3z1tP2Yb0UdWdqXBhUn5VlcyQFZOfiWnWw7PbfF3F0koPstg+0IVAXkqN8LgVhafUpytrCaPoQWTp5rasDU5DCdN75tXq384Gjey17rWPZeZZO4gG1gb3GcbJxLFqPVjCtDEaJXaxVkgVdW01VaMygPrhtr+PjJ5bsNY5bdht6H874Gm7+5D/xVU95Isduu5V/+amfxg/f+BZG4wmR/cpZId+3Omhe/Vu/+pHYX1BK6+9SSr4+Li3b45LDk5IjU/l1e1wyruz6+853QelyckXLZC4Hcm2fyWQymUzmYvC///f/5su+7Mto25YnPvGJ/PzP/zxa3/Wa+54WSJxL3zrvHK2LHJ/3nFw6+iBLTccXHf90cjm4AnecGMQ/y94f6KtEPFMXGu+HAU1MTEqL0QozLOac/jplOSdASjROXKASkZhg2UdclFi3Y3sds8aR2O99RkMkhl8tZSlZ9un9aoEqrhfXSrsfd77qx+etOCFfiuKSC+0oNikt49KQUqIuDIcmJVujgqrQFEbiSgqjqApZYjs0KdfxeZNqf0Hqvk7uNS4N3v/+93Pbbbet//zZn/3ZF+25Xvayl/EZn/EZHDp0iLIsueaaa3jkIx/J85//fH7lV36FEM5PvJnJZDKZS491vFspYm2Avcaz6PwdntPHwSV1r5H6+kzRw6tZzemzn9JoOidOrSdnDS9/8fP5//3JHzIaT7jhJ36BT/20h1MYiUOeNY4Tc4dzETfE2S06z7z17C4D3ouTlNYwKjWF1WhkMan3EmUXYqLQirLQWGtwPq5fZ10YlIK9zq/dqOat49hex7GFCN1v3u04NpfeYdF6Ti57YhLxQVVolr1nZ+4IQ109rWW+NSplDqeQOLuN2p5iWBCTCOtBxA5Wi3iiLsx5p2NcLgYLmSuTy3YS9ymf8in8l//yX/j4xz/Or/3ar/HkJz8ZYwY7t0H9cfLkSd74xjfyOZ/zOSil1k1PJpPJZC4OF6swvRDcnRi83WVP70WJe3zRyb2VZr0IdjYqa6itpuk9t+y2nFj0fHKn4bZZO1iddoQh7s7HBClRWX1eSlMpjNX6NaWUaIaCPib5WoyJk/Oe47OWk03PJ042fPJkw7F5R++kmDRasVUXlGb/tVWFISZonawt9SGy6D2LLjBrZclK8qEtMYnL1LJzHJv3fPi2BR89vuDW4XXvLHv+6eZbecZXPImPf+yjPPih/4w3vuVX2Dp0CDj18H217rQ6WN4/KD91Qan3+wtnan1Qfufv111ZUMpFeyZz8ci1fSaTyWQymQvBhz70Ib70S7+Uvb09Hve4x/HLv/zLFMXdWxQptGLZeToX2Vn23LLbcWzeycJR59dOQQeJMbHsPDvLnhOLnqOzjttmHXtNT4yJGNMZ+49z7VurQlMVhi6GdZz5zbsty6FHm7WOmBii4hOLLrCz7Jm1EhXvQ0Sh1n26VtLjeh/X9+XCvhCkcWFwVk4Yo9EMsXp9YNF69pYyfPEhsuwDLkWawSm5sIrpWqku1yysIsRIiqC0uFkd7OFWgx8fE50TEVHnwyUpLrkYjmKTynJ4UlLb/R50sy7YHpccGkQ/m3Wx7ilrK87I92WnqDsj9xr3Hj/8wz98yp+/6qu+6qI919ve9jY+8IEPsLOzg3OOo0eP8pd/+ZfceOONPO1pT+Nf/st/ya/92q9dtOfPZDKZzMWnMJJiAbBZF+sZ1N2JHl6J1kFqXpC62CjNbuOGhaXIa1/+Et7/O79JUVZ8z4/+LA/9/zySRR8YV4ZxIfF0887R9IGQWD//vHf4kCgLiaqblnYtOl9FyTmfCDGilQjQex9Zdp691rHbuKGO98w7TzekjvQx0nlxqNpt+iHWOTEZZnMhJuadpIScnPdoFJPCYK1mr3VDLLfHWlnOMlqzORJXKnuaqER6lCj3X1sUsDEq0MO9wrmLzy8Hg4XMlctl3y1prXnSk57Ek570JG677TZ+/ud/np/7uZ/j7/7u79aPSSmth6k33XQTX/ZlX8Yzn/lMnvKUpzAej++tW89kMpkrjlVhuug8m3XBHqJqXfbiQlQavbbXXKlD+7DvZnSmwvRCcCYrVJACd1Te3qazLgyTJIe8yz6w2zhCSlTGMGs922PFqCzP+bmbXgrxxkXSsPRkjWbRecalZWfZ40Pi+KwjAYXWaKXQnHsxp5Vs6Xc+iMIARTcUpS5EccFa9pxse1HyLnrsUCwqLarTZedpusD2pMCHxKg0bJoCrcQdSV7LKnovYAfHqBATrRcFb9cHTix75q2nHuxgdxtRIYxKA67lP3z10/jQ3/4N11x3PT/79l/lqmuuxflI7yK9j8RSVMTOp+H+Vq9x//NZPb/Vij5EGhepraEeDjfLs/zs3JUFpVXR3vrAqDDMOj/chzqnJblctGcyZyfX9plMJpPJZO4qH//4x3n84x/P0aNHedSjHsWv//qvMxqN7vL1XIgsu0DjxFkXJHLCx7ju5VyQGv+gi2/T78ear1j2nt5LxPnxuSi5r92omNaW0hrpEbU65761MIZppZm1PXshYrSic6JEN0Yxb51EYRiN1mpYKJLBxcllT+cjWimUUigFpZZevQ8RqyVmz8e4dsldDTw6H2i6OCxrJVyMND7gUmDZw6IXcVRhFV5DJGE0FNZgfCIM19JK4WLCIEs/ibSO7QDpbwuj6X1kt3UYpYiJS1JcoodYQK0VhIQLcS32Oh9OHyqV1rA1LojRDnGJ8lmkNDglK4kxGRW5pzxXcq9xz/K2t72Nd73rXes/f8ZnfAZPfvKTL+pzHjp0iM3NTRaLBSdOnCDGffHdP/7jP/KUpzyFl73sZfzAD/zABXvO2267jaNHj57X93z4wx++YM+fyWQyVwIxpnOud6aVlXmEC2zWBa0JNH2QhXof1zORg1itGJVmXaMdjB5u3H509UqQ4KK4OymlCCFw4w+9gj94939DG8N3/NBP8n985r8BILhA2wVChKJUVN7Qh8DUWIzSuBTxAayBaW1p+4S1slxktYjcnQ80PrDXhKG+huAhWoncW4kwwtCDLHsRQkwrS2FE6CDvkyGmxM6yxw5LV+PSyPuhxJVq6QIaed7pyOBjorKGomS9pHXK5zKYGpxYSOTwxuCiVViJAryr6RjjSmYsdWlkwctF9hrPuExnnNet7mU1r4OLZ7CQubJR6QqVP/zRH/0RP/MzP8M73vEOFosFsO80sWI0GvGkJz2JZz7zmTzhCU/A2st+T+w+x1/91V/x8Ic/fP3nD37wg3zap33avXhHmUwGZBFmpXJt3X5hekecqTC9kPbvu0tH6wNtH5gNB82bI3vOyyyfOLGU/GQSoNgcWe63ffYDsVWhuuLkomevc5Rasp0Lqzk0KWm6gNaKj51Y0vtAZQzjSqL0ztWVanWv89avi+G60Fy9UdP5SF1obt2V3Olb9lqazjOtLRuVpfGRQosCYuk8pRlUp6VlWplhSSky7z3HFz0G2ByVWKOYDJEIALPWcXLZs9d4yaZWCmUUG6Xluu2a0Hd837c+h//9P/6Qre1DvOlXfpOH/ouH0fnIqDDsLnv8sEBVF4adIZd7a1RgjWZS7eda7zVuaHQCR2cdrQts1QVXb9Yo4PCkvMPD4c6HtUOZOIQZ6uHQ+Wy4ENeNwLks2cGZi/bVz/fhSXnBFgAzmSuZXNtn7g1yr5HJZDKXD0ePHuVxj3scf/u3f8vDHvYw/vAP/5Crr776jI89l8HL0oX1khLA8XnHbisK8GXrUQqmo4LNqlgv9KzjJYaexflIGwKLxnF80eMjTGrDRilK7Glth8cbJpVl1ngSCQ00fj/C40w94fF5z17bc9teS9NHXAjM2kBMkVFh5XVUhkPjct2j+BCJwLJz7DSekCKTwhISbFaWjVFB03tGpaXzkWUv/WxMEZUUSxc4MetY9J6dxlEYjRnehyOTEqPAJ8WilcUohfT2o1LuRytohv4pxsS899Rac/VWjdWaBx0Zn9JPdT5wYt7T+8C0LtgaFVy/PTrn3u2eYtGJer/3kd3GodTQj55HpF5MiROLnpRgayROUNPKrh0RMheX3GtceP7qr/6Kxz72sczncwCstfzJn/wJn/mZn3nBnuP3f//3efrTn84zn/lMnvjEJ/LoRz+aw4cPr/9+d3eX3/3d3+W1r30tf/RHf3TK977+9a/nRS960QW5j1e+8pW86lWvulvXyH1GJpO5r7ISInQ+cGfLCgoRGI8rsz5Ln3f+lHq993Et3l7X94NAoDywrDOp7CkumycWPS7E9Vn/wfjmm/cafvp1r+aXf/r1KKX4ple8jic+9SupjCEiC/G7i55P7jbsLD17TY82isOTkpE1JKXwQZasjBbHqK1RwWZtaZ0scc1bz7x3LPtApRVVadEKjkxLNqqSzZHUva3z+JCGujMxqQ3TodbuQ8THiNUittgclZRWYpi1Eierj59omLeOblhkUkBlNNZqUkjUlWFaFWsBQucDiy4MTlQwqQxXT2sArt+q2RqX6/mX1YpDkxIFXDWtzmlp/+Dnd3DOohTnbbCQXVMz58oVuxi1Yj6f87a3vY2f/dmf5X/+z/8JcIod7qrJ2d7e5ulPfzpvfOMb77V7zZw/eViRydw9zmcT/3y5UIXp3SXGxLG5ODGdXMjizerg+Vz5xMkl89az7EUVvFFbrt8e3elB58FirnPiGLXsA4veU2jNtLYYrdgel5xc9mhY36dS4r4lVvjnfuDb+8islaW0uhCFwNUbNYURR6i/uWWGD5Fbd1v6GNmsLFvjch2zcHJ4fms0DFEKRybV+vq37bUcX/QUSu4/pMR1WzXWaFwI9E7iBmetGw71GQ7xFUcmmp951Yv4n7/3W4zGE17/pv/Goz7z0VSFYdbK4XGhNfPhZ2almLBasTUub3e47EPk5NLR+8Atex29D0wqiZXYGknEwOlcqAWlXLRnMvceubbP3JPkXiOTyWQuD/b29vjCL/xC/tf/+l888IEP5P3vfz8PetCDbve4cx28zFpPStI3+iA9c+vESRhg0a9cege34dIQEmu/X4UorvsgizKr7yu0pizEBWmzLhiXhroQR6fNuiAlkeLsLnsKq7lqWt1h33rTsTnH5j07S8escVir1s5OldFsj0uUElGPVmpwhxKBSesjzkdmjZOItnHBuJBFrURCoQgxcXSv5ehCesQYQanE7lIWpVofSCnhfGKjNozLgtpqNsbFuqdbtoFpbblqWtH6wLSyg6O05+TCoY0MfLZHJePSnCI+iikxaxxH5x1WKa7arNisS45My0tOXHIhzhzuzlApc+HIvcaF4eabb+azP/uz+ehHP7r+2o/8yI/w7d/+7Rf0eWazGUVRUNf1nT4upcQP/MAPcMMNN6y/VlUVf//3f88DH/jAu30feTEqk8lk7hoXYn50dxarVhybd4QoTksSgycuSrPO8aY3/ARvfI38//hvetkP8CVPfzYgPYAs/kvd/JGjc3bbno+faEgpsTkq0CgOb1QUWmYnKNBKnFJH1tD7SCBxctHTdIGqUCgl6RyF1jzgyGg9R4opMW89fYjsLByl0RyZliRgoy5Y9J40iDAmleXazfp2s6vjc5ntzFvHoo+EGLFKE1PCp0hlDVYr6kLe25BkpmGUYjqyHBrJvOXQpOTazZrOB3aWMhsprRIXXCO9xbnOFy81g4XMlc8Vvxh1kL/+67/mZ37mZ/jFX/xFjh07Bty+uQnh3DIsM5cGeViRydw1LkTBeCk9z51xIdSbR2edZFQve0aV5fC4ZHtSrJXAZ3rO1fLNrHP0bj/Srh9s9Q+NSlDiWHTrXosPiaOzji5EjozLdVzb2RawDiJOSKIuMFpRW81VGzUxJToXOTrraJxj3om6YKMu1tGHrQ/cttex7Dw+JSaFpSoU07pgZA0xJo43HU0fBzcpQ2UM9ztUryMOlr1nt/GEIAtSCsXm2LBoPe/40Rv449/8bxRlxQ0//ib+zed+HnYYDIysYbdxjEpDSIl5I9nXdWE4Mi3XiueVOgJYR1Acn4t702qJCmBrXDAp7UVdUMpFeyZz75Nr+8zFJvcamUwmc+nTNA1PeMIT+IM/+AOuvvpq/vAP/5CHPexht3vcuQ5eYkyDW7D0ckYpxqVFKYmvcCGhUey1PYs+4EKk7SMhSZ+36oGVUrggcXqlURRGURYG5yVabuUCVVjNtLS0PmCUYlJZeh9RCq7fGp3SA63YaXo+fMsMFxPHFx2z1qOA6RCVoZDhxbiUPmclmtFKovqOL3pigkXrWHSB67crDk8rJqXEcbiQOLnsWXaBvdaxt3Tstj2dGyJFEOHNwnlIMoApjQysHnhoLEthPrJoHdpqDo9LjFbrGJGTi57dxmOU4qqNkqrQ3H97xEZdkpBlqz7EQaXumZQiTDJa8cDD40tSXHJ3XarvqqNx5uKRe427xokTJ/j8z/98/vIv/3L9tW/8xm+8JJbIvumbvok3vOEN6z9/8zd/Mz/+4z9+t6+bF6MymUzm/DnlbL0PNO4cztYLQ12e+Wz97hgAHJ11xCQLSieXvdTOMfH//YWf40de/h0AfMO3vYxnPf9bTxFIKETcXhjNbbOWE/OOj51YsvSBQ3XJ1rjg8KTiyLRk3gYg0YVI72QZPiapA3cH4bUG4nDNrVHBNZs1I6sHV1epMXeWPbuDc+v2yFIXBVrDvHOMC8t1WyOqQnPoDkTjnzi5lPjmlDi26EkhgVZrZ1czzFKq0lAPCR6TuqAcZnaHJgVXb9TMGseJhaMPkcIqNgZx//a4OGW+dy5zv0vFYCFz3+A+tRi1wjnHr/3ar/GzP/uzvPe9711nTeeG5vIjDysymfPn3ig0LqYz1dk43Qq1LjQb57mQcmLRs7t0HJ+3KK25drNiWtkzuhK5ENlZiiL44FLUqDQoBcsuUBopaI0WW9UTw2H20VnH8UXPqNSMjMGnxLUbFRuj2z/PmZi3np2mx3lZXjo0rTBaohxmrUeTOLF0uAPWqgAhJBrnuWWI2mv7yLgyHJ4UaK0olGHe+2EQENFaURrDgw5LoQ2iTr511uFDpNSKmBSFVRyZlLzxh1/Jb739Z9HG8J9fcyNf9IQnAqI2ACgLjRkO6WtrODG8htIapkPRfM1GRWH17Zac5p3ETWxUBZ2XZazyTnKsL+SC0oX439K9+b+NTOZKIdf2mYtF7jUymUzm0sY5x9Oe9jTe9a53sbm5ye/93u/xqEc96naPO9fBix8cnqxWuCgLRiCq6Ks3KrRSg0Pv4Aw8CFM+udMwaz2zVnqDupTaf1wYKmuJ7As0ppXl6s0KjaJ1Qep/LS7DLiSsUmijOTwpmFbF7ZyH9lrHsVnHXiO/Hl92LLrAqNRsjUo6F3FRotJHpai2D01LSNKrhgif3FkSU2I5CDy2xwX//OoNxqVBITXUvHX8007DvPUcm7UsXCQNESA+Rgpj2Gt6QoDpyLBZFVSF4ZrNmjSo7F2KLDtPZcXBatYFSiMx7Z2PlFpTV+Kadc3G7VXtrZPIeYmAL9ioLQ8+Mrl7PzQXiRy5fuWSe41zZ29vjy/+4i/mz/7sz9Zfe9aznsWb3/xmtL73f56PHz/OAx/4QJqmAeDBD34wN910092+7m233cbRo0fP63s+/OEP85SnPGX959xnZDKZ+xJ3lsZQWVk00krmDS5I3Xgx0xhWjlEn5j1HZy2T2vLud/43XvmS55NS4jnf9K18w7d/jywUgSzwO5mvrFh0nlv3WnaXsrxUW811h2qu3ajZGBWEwV7Wx8SiE1HDao6028iC/chqSmupS839tmpGpZVlsMKsI/Bu3Wslcs8qQDGtClJMzJ3nmo2K6zZH65SSFTElOh9wPrLXStxfAkjQh4RRiqRAJYkQDMOyVGU049Ku3aAOjSx1adlpREARhw9FK2h9ojBqPcsYWcPWqFgvsp3t87oUDBYy9w3uk6t0RVHw9Kc/nac//el84hOf4Od+7uf4uZ/7uVPsXTOZTOZK5Jw38YM4DB3cxF90npjSXVoi0VqUrwdS2e4xVgVaHF7nXSmYtILCKtCKFKUgvyMBQzMcanYurJeiNmpLaQ3z4aBc6f3rglivhghXbSR2l45lF6jH8qATS0dVGMqzKE1jSsw7+Xy1grq0omRM0khMK4PRmmUvy01bdYmLkb3G0bjAsvNoBUZD48RBysVApQ3GKJRSVFYcnZo+MJ1YqsKsY/sWrceHiEFcpnxMjAvDO/7vH+e33v6zADz3P7+aT33sFzJrPaXRbI4Myy7S+0hZaFovh8LTykKZsFrjoxy+Ny7SuHjKa7Zacf1WTYiJZR/YGhVs1MU9piqYVuJktSraS6vvcCnr9KL9Tov9BGHIKF90Phf7mcxZyLV9JpPJZDL3PWKMPPe5z+Vd73oXdV3zrne964xLUfPOr3vgsw1ejs06Ohc41nuaTpTc12zVzFuHUXB4UrFRF2jlh4GEISXp19peouVCTIQg0XO9UsTkJQ7DKI5MK7ZGBSlCWWrGpVkvU2HB6MRe4yhTonOaaVUMz6OxRrPoPM3gUrVa4lJKMbKa2lgKranH0rsnRIW+NwxRCiPPB1BazdIFfEjEJD3ozsKx2/Rs1gWVNRxf9JxY9ixaRxcSpVEYrVFATIouyPJTryI+gtLiItU4z7S0GKOIXtG6OMRrGGqrSVGcqzZHsvQ1soZRaantvquV0hJRvnL/rY1hXBqumt7+QOFSEZoURq/dmDfrgj3cEBso5y7nG7mee79Lh9xrnBvz+ZwnPOEJpyxFPf3pT+dNb3rTJbEUBXDkyBE+7/M+j/e85z0AfPSjH+Xmm2/m+uuvv1vXveaaa7jmmmsuxC1mMpnMFc/qvBvObZm8LgyTA8vknYvs4disi+HcXN/tukkrtT6LT8Dvvve3+N7/9AJSSjztWV/Ht73slSilWPZSi5dGUxqZW3Q+kqIkc+wsHZM6oVRBQhECuJhIKXFko2R36dbR2W0f2W06kpIauraGqtCMSs1mXTIqLQrWs4Y41I9EGFnLqFTrOLyl8yj0+r1bRf/6IdXDHag5jZYlp1W97JeOUaUxKKKC6eCU2zmpra0WYfmktCitOb7oWXZ+3Y8kRDRRWk1t7Xp5rO0DO8ueUWk5NJGZzZ3NFwuj2RprYrSXRG2fuXK5Ty5GHeQBD3gAN9xwAzfccAO/+7u/e2/fTiaTyVw0zudAeLWJ72Ni1nn6GNmsxbJTlmwun38+VkXf6tfzidBbURqNQlEbQxMD/VCYnU6Mab/4G97rUSlLTTFJHABAbfcPpEEK/GUfmJQFhycFt846OhcZ1xY3RABOqkRd3LHS9OSiZ955tJKYBjmkT9SFHIC3TgroutB0QQ5kQYrhQhsinr3Wr+MROhcgJcxE03WRUWlwIeCcqI+NlYP5lMDpuD7Q3xgVKBSFgd/71V/krT/5GgBe+F3fx+c95RmihPYyNJi3QyPgAp1TbIwKfIhDI2TX92eNOuuS06FJiUad94LS3eWuFO3n6zTV+kDrQ7aHzWTOgVzbZzKZTCZz5ZNS4sUvfjG/+Iu/iLWWd7zjHTzucY+73ePOdfAicXiBZe/FpbZJhCTuTa2LGKU4Nu/xITGurDgxWc0tuy3zzmO1kj7MKkxUxAjFIPwwMVJqGSZYrXEhUVlF04vAZFQammHIM60t7TAw8EEcqSorveKoRIZBXmI0Gh9RSlFrzXRS0Qfp40ySHsX7fVcbgKb3NM5TGelNl60sfxmjqEvDvHPEJP3LbbOOo7OOlMBojVGRABRaYbUmxAQqYI1B99KPzjq3dmcujbwftrCMC1ms6lyQPtgoNkbSq27UBXUhanJ7Wm+27D2gGJeaazYrCiM91cHP9lITmkwrS4iJ1gU264LW7Eeud4NL1umcydE493yXLrnXODPL5ZInPvGJ/PEf//H6a1/+5V/OW9/6Vow5e5zkPcnDHvaw9WIUiNvT3V2MymQymcy5s+z2Rfur2vxs8cN6iJu2RrHXyPyiNVJLL7vA1vju1XiV1euUjA/82Z/wPd/yXIL3PP7LvoIbfvD/WtfT49JSGk3rZMHdarCD8CCmJPMJrSiNovFRhBDDPCdGeR1KJcaFJqWE7Q1WS4297EW0UFnD5khqQWv2l536lXMWUBYiYp8UhsYHll1ka2TWs73SaJa9zB96LwtMXYj0XurjpvNUheGqaclmXVAWw/MMs4zrt0drQb9C5jcpiZh+2cs8KCRZ+gpRIsCLIZJca0ApWbRCavpl79keB67bqs86X7w3DRYy9w1yp3WAL/zCL7y3byGTyWQuCpfiJv49hRqqt9VLPNNC09mQQ8oeaxQ2KFLaX3w6SOvkUNYNS2VKsT7glJiEhNUKO6hfV3+nlaI0ms5HjmxU7LaOhQtM64LCanof0SrQukCxUprKy6L38tnOh8+3spq6kAiEqjAUViIUuiE7WimYlJbey4KXuBcFKqMprSIly/YosdvIa7FaCuDOeRZ9IkR5js4FTizkMH7kLQEpuseVYdEF/tfv/Do/9YPfDcDXvfAlfOXXfSOLzlMYhVEKY+QDmVSGEJNcpzSMy4rSKhSilhjfyaHwmZac7i1VwbkW7feWa1smc18k1/aZTCaTyVyZvOpVr+LHf/zHUUrxpje9iSc+8YlnfNy5DF4WnR9cfTwxIQssg7LbhcjJeUc/smyUBY2LGLNacBG3pY3acmzWrV2BogHnAuPCEIaouGllMUrU1L6P+GiYlOK+WxXSG8oyVKKwoj6PJNrBlaoPkdhJzzBrPM6L6+72RNynRqUh9qIKX/TiBmy1ZmItZnAoWg49SLTiaOVDwhglbsjBsHSe+2+N2Gkci8FNGOSaxmo2SoNGo5TcY+c0syYwKhRay5mD94lZ6xlZQ1nCZlWwNSo5OpO4jbqQ17M1LrhqUqG19IbWiLtVStIXuiAR6dvjYr00Vdm7LzQZFQaj1UXtFbdGBUYPMfFD9Mk95WicuWfJvYbQNA1PetKTeN/73rf+2hOe8AR++Zd/maK49M4uRqPRKX9eLpf30p1kMpnMfY8YJdINoBlq03Fp7nQp6iCVNYxLSY5YiQw6H4jR3mkNdzaH0cpoFsDffvDP+a7/+DX0XctjHvfFfN/rfup2C77WaKZGSzydWzmAJro+rJegrCo5uugYF1aik7uINp6QZClJa0UiMa0Mi95L/+HCOnpuNecYFWaIwYvrlJJymMuFmNgYWfZOOmJKGC0CcxcSjXPM2iALUV4WokKSXsiFSBcjoYPjqkcpmGLZHpVcvSGR2BuVpbT6FPGBD5GdpscoxSIElp0jRJjWlvHp88VBpKCH9zikxM6yJ6XE9dujy26+mLmyuGy6rRgjH/zgB9d/3tjY4KEPfehdvt5HPvIRZrPZ+s+PeMQj1lufmUwmc6VxKW7i31OsrFC1VhDkcLsuzk+xdrCwHhXyulsX1wreFStHqDbsF6paKfoDxesqV7k8sPEP0gR0PjIqLFdNam6dtRxf9hyZlBgjS0J+cKRauVKtCuPWBaxSbIzssOiUGJWaupCoN60UWkEYXktwERdkwebEssOHSFUYrt8aMescSpVwYsmi9+w0cqheWkWpNMsgTcTJpsMk2ZraGkWqQR3sfOSDf/K7/MQrXwLAU7/2eXzbS79n7djlml5+tkq7zru2Wpa/wrC4VRrD/Q+NMEqd95LTpawquK+6tmUyZyLX9plMJpPJZO4Kr3/963nVq14FwE/8xE/wzGc+84yPO5fBy8GafNZ4lp1nr5OI8NIYtJZFqXnjYVBJG11TGM1u4+iD9FV9TExqy0ZtSUnqfqMgGDBKcWhcAqx7t364r0lp6FxEa3F2akNAaYVOSZaoosaHiFaKpgvUwzIVSD9pB9FJSIlJaVj0sLN0LPtAYaRXNEYxKc3a/aoJkUltGNUGNfRXfYgsusDCeXwAazVt6wCFVprCSFyfNbJYlEjECBsjte43550nhETbeyaVZdl5VIJEkij5pADF1shyzUaNViIAmdb7fU0cxFkhJkalxMutevdxJb/eFaFJoUWxfmzeUVnpW9dcBHepuxO5nrkw5F7jnqHrOp7ylKec4p71+Mc/nl/5lV+hLMt78c7umFtvvfWUP1911VX30p1kMpnMfY9mEJX3B0Tlo/L85jSj0qzrv95LhFvjJGnhdM7ZYRT44F/9Nd/4zKexXMx5+L9+LC959U+CuuPzdz2IvEfIEnyI4vZkFMz7QEiJxsn5vlKJ0msKbZjWsqSv0Cz7np2FI0ZZgjJWXJeaPjCtVq9TYvAU4gprjfQHVit5DUMdvJqR7Cw6yqF+Xi2Q9SGiUsJoEWqAuE5ZrelDYK+ROr4uDVuDUL8+TVBw256454aUaJ0sd22NCqpCr5e1NIo4vKeSuDK80YPCf7eRCPLDk/Kymi9mriwum6naG97wBr7lW74FAK017373u+9WQ/OhD32IJz7xiaRhUvvTP/3TPPe5z70g95rJZDKXEvfWJv6lwsoKtbZy6Nz5yCSl84rUiymtX+vWuKTxAas0e41nXKa169bqPDYNvzF6P3sa5GB39b6Py9urDcalxCRsTwq6EFn2cuhrgmJaFhid6ILkVvc+4mIEpdioCia1YVoV7Cx7jkzL9YLU6nC1tOIMVVvD8Xkvyl8jBfC0VpSD+kEBJ5Y9dWFpXUQrMMPBt4uJRe8hiWtWYRLTyuJipEDTusBNH/x/ef3LXkAMgcd/+dN5yQ0/iNFyDxt1QUyirC6MHIxrtVI/wMhKYVyYfcXApbrkdL7cl13bMpkzkWv7TCaTyWQy58ub3vQmXvziFwPw/d///bzgBS+4w8eebfCy6Pz+UlQnLklhEGMURrM1spTGsNM4XIiEGAHNiUWPNopSa3YbGRAQE+PSsFEXzFoHIEs5Vq9j9mAYeCjFovf0PlAYcQ6Oq/i7EKhLyyIkSNKHtj5glKIPCePV+rWUVvrPcWVpfcD5SGkUKUU0ihAiDqiSJhSaqtDy+pA+9eppRduLQMaHyLL37C68nB0oWPaRcTks9ChZ3NJa3s+VIKi0Bq3Ax8ShScGyk+GNC4FDo4rCQGEMdSHHz9IDK3aW/eAEZWVQlfavuxLUVIVeO+VOKhEA3RWhyV7raPpAWWg2qoJ561l0gbrQFzXG/K5ErmcuHLnXuPj0fc/TnvY03vve966/9gVf8AX82q/9GnVd34t3due8//3vX/++KAruf//734t3k8lkMvctVrHC7TCrWi3Ynw8HkzfaYQG98/F284PzcRi95Z8+zrOe9iROnjjOpz7iM/i+//pmKEfsdQ6l5Zz+TPcZk0QoH5z9aKVoFx3GKK6uKiCxs3Q0vWcxpCr3IdB0jklpiLGQGdPIUpthGSpIza6Q+11FocQoi0khyiJWGNJJQtQYpZm3Dh+hLAx7jWPeegKJymiKYVmq64abGGrmSWkICTqXOLnoMVpxhIrGBQ5PSiaVpXOBWweB+z/tLNFKSRz2uDjje1NZQywPvDcJifxWihPzjo3aouCymS9mriwui4naYrHge7/3e9fNx/d8z/fwJV/yJXfrml/6pV/K93zP95CS2GO//OUvp+u6C3G7mUwmc0lxoTbx1XDg2Q9Zxqslq0ud0RArVw6H0imxLlbPlaYPWC3KUmvkgHZzLIekyz5wYtGzNyhXex/pnCzB7C1PXYqaVnKwOy4N9gxLLZPKUhcSkzcpDYcnFYfGxeCoFIY4PDmUrgpZhNquC7YnBRtVQWU1127Ug+2pXHNVmNaFWRf8yDk7s6Ub7scyqQyFkesqpSiswmhFCLB0kdZHXIoYpSgtGAPOJ+ywgNX2kQ/91V/wI9/xH+i7jn/zBV/CS3/gR5lU+2rchCykjQvL5qjk0KTkyLTi8LQUq9ihkL4LaYeXPHfk2jap7B02gCvXtlWueOfiehCwul4mczmSa/tMJpPJZDLny6/+6q/yvOc9D4CXvOQlvOxlL7vTx9/Z4MWFyHLo02ado3fS49aFYaM2jEtZ5imtZlLu/3klElq2nnnv6frBlUmzVkmveplwQCxzkNLuuyCt+gLnI9ZAQnowrUTA0vlIinK/KSVxlEKey6wGJCkxLeXeZq3HGE1daKpCes5Dk4JxYamMxHOPC0tpDfUQTTeuDNduVmyOC3xMtD6y7FYqdEVhxCGq6UX5rTTUpV73KVWh2awspZbrGa3pXMSYIRpueD+3xyXTSqI2NusCozWz1rPXeGatRIikBFYrNmq7XooalRJFeGdCk8OTko1a+snV+7tRF4MYR5g1nn/aWbLbOHaWPU0vTgNucJbabRwnFz3t8HOx6Dx7w5Lb3WHlaHx4UnLVtOLqjYqrptV60JSHQRee3GtcfLz3fPVXfzXvfve711/73M/9XN71rnfdLqruUuI973kPf//3f7/+87/9t/+W8Xh8L95RJpPJ3LeIw7/NcaiT76rod+XEubpOPG2YsDtEQ4OcxZ9c9Ow2Uj+6kE6pAT/0kY/x1Cc9gVtu/iQP/uf/kpe9/s1QjOh9YtbKdXaWsmTU+WH24wPz1g8LT/uzH1A0fWBzVFIazaJ3uJjYHhdcPa3ZmhRsjSxXTSpGlSUpEZLf71DNpDCyyF9LBPfuwrHXOhJQGqnJWy/Oql0fOTmXvy+Moq40887hAhgNO23PbusIiHhjWhdMh3q9Lgy1FUfYCHQhEhJsjCy9j+wt3e3mDycWvbjiDoIDBVw1LRmXdz7XGJfiqAsixndhSMdo/GU1X8xcWVwWi1G/9Eu/xG233YZSigc96EF893d/9wW57nd/93fz4Ac/GICbb76Zd7zjHRfkuplMJnMpcSE38Q9eZ3XdSx2t1dqlaXTARnTlonU2Oh/Wh+ZHpqXYgxrN9qhko7brZavOy0HtrHUse08fIhHZ2p/Wdr0UNSrMGa1dV2zUxXpxrbaaI9Oa+x8acd1WvV4eqgrNqDQcmpRctVFxeFxyeFJy/faIQ1OxK199xKvGYF9NESis5FAvBuWqD5G9xnFy2dOHyKQ0kFYWrIlEwvtI8InSyKF2bQyQ2GscJ2YdH/7Q3/ETL30uzWLG//Gox/LSH/4pJuPqlAUw5+Ve1PCl1RnwqndZ3fOV5kh/YVzb5LGrZqsbFC6ZzOVIru0zmUwmk8mcD7/7u7/LM57xDEIIPOc5z+FHfuRHzhpjdWeDl3VN7QL9sGAzre3a0eng96+/L0kvZ7WWg/zO0w0R6qx6r6F3OvClMy6+VFbEMBKXJ9/hQ6K0g7PUUPu3TtyL4iBsSTGJiMVolF4tee0/nwKs0igFxiiuGpccmlRMa8uktmzVBdYoUpQHH54UHBqX4jxVGkaVCHJcDDgfmHcSFxijDFlKq6mNYaMq2BoVjArpDQ9NS0aVYWtUSHM3iJFckPvdqAoOjS3XbNb8s2umHJlWVIUMZKxWg0BHszUqODQp14tjk2p/Qep8hSaLztP7xLi0KJXWTs5uiJG3RuI/NupBnDQIwWYHFqKaPjA/4DSQuTzIvcbFJYTA13zN1/DOd75z/bV/+2//Lb/xG7/BZDK5W9e+6aabUEqt//v8z//8O3xs0zTnde2bb76Z5z//+ad87eu//uvvwl1mMplM5q6ymgGcLug+X9RpM4WDe1GnO4zOOr82C6iHxSOpYzXHjh/jG575VD7x0Y9w/QMexA//32/n8FVXEVIiJnH7nHeOeetY9LIcNWv3l6RS2p/9aKXo3L6DVUywNSoprWZaW7YnBffbGnHd9oirNmuumtYcmVTrpmE6iN5ra0QEPxKx/KzzHJvLYpf34oiKUpSFIoRESNB04h6rtAjcl428/s1aav1xaVAofIoURq8FC6NSEyL4EIFEXRhCTOtauPMB7+PaEXevlbp4c1SsHWHPRmn30zJWfdle2w/zkstjvpi5srgsFqN+4Rd+Yf37V7ziFVh7YRIAi6LghhtuWP/5TW960wW5biaTyVxK3FOb+Jcy42pYNCrNsL0Pe43Yqd7R64gpiUq0kYKvKkR5ulkXXLUh3qx1IctJB/OUrVaUhZGir9BsjctT4vOm9dn/DbNaDoXrwamrsnKd67dHPOSqCQ+9asqDj0y4drPm0Ljk8KTiqo2K6YFDYb0+KN8vMMelwflIZTUJWdY5ueiZd36twF0d/i57TyKxUcsBtzEKaxUhRRoXaFwghETjAieO3sxbv/f5LHZP8uB/+XBe+F/egLEVvU/MW48P0kisIhfq4f1Y/Uz1QxG8uue72hRdqtzXXdsymdPJtX0mk8lkMplz5c/+7M948pOfTN/3PPWpT+XGG28861IUnGFQkmDZeU7Me27bazm56Lh1r2XWenEYHtyFTl84Yv/bBSV9YO8TzstwIab9+LbVrhRGesreReatY69x7DbiNLwcYvtikoFA7yMuxLUYoi405dC3LjsR6qQDMX8ate6pOh9Y9J6dZY8eBjMbo4LaaLanojjXSmGULCHVVjOpNKU1GK05PC6pSjMsVRkKYzBI71dozajQTEuLMQarNJPars8UKquZVuJWNS5lacxocaoqC0MaVOr3PzTigYcnjAtZPiutuDBvj8VFeHtcslkXlMPCWD1ErK+i7M5XaOIPOILNO0dKEvdRF2Z9z4rh/RjcpQ5PyvX737m4Hggthl45c/mQe42LR0qJ5z73ubz97W9ff+2xj30sv/mbv8l0Or1H7+Xtb387n/d5n8ev//qv0/f9nT72d37nd/isz/osPvaxj62/9umf/ul87dd+7cW+zUwmk8kc4HRR9PnMl2KSRfedZc+Jec/JZc9u04sTqPPEmM7ZYdSFyPGdPb7167+aj3zobzhyzbV8341vZ7R1NfO2J6XErHHEkIZYaEPnIyHIIlRp9Hqpf2tcYpQ4RY1KQ+sCnQtYpTg0KXngoTGfcvUGh4cFpXEpi/9HpiXbI/n1yKTCWhEK+JCIUQTl1ihGhWGjtozKgnFtUUkitcel1LONDzQ+4GJi0Tp6J/F542Lfral10i+A9BKr+OlxYZmUIgyJSZ6zKgzz1q/nDyeWPSGJw23vI0pxTvOtg6ySTJRS69fXunBZzRczVw4XpjO4iHRdt85+rqqKZzzjGRf0+l/91V/NC1/4Qrqu433vex/OOYqiOPs3ZjKZzGXCPbGJf6lTGLH6X3SezbpgDymMl70s+JRGlpqUktfV+0gf4vo1VoVeK1UnlV1b+S87cZ4q7bAUpRSLPjD2cpAqyt5EPTj+nCk+73RWC0TWSHFtzXCIbTQxHcjAVorKakaFOUWFXFmNC5HaGjonKoJJkgg7ayRSwQVPiokYwFrFrJX4ghDlNbc+DLnPEJJCK+QQu5LCeNkF6lIzHhn2ThznXa9+IfPjt3L4fg/hma/4r3hdM+u8WMKmdIo7l9VyH2oYKJxpYaqyl8Xe9jlzT+anZzKXOrm2z2QymUwmc6789V//Nf/u3/075vM5X/RFX8Rb3/rWc15yUGJ+Ky5AraP3gdIaml5U4z5IH6IUhCTR4D5Iv9IjApOY9vuSVfWekvSHEhM+DC20xvmEUmGIiIgQYOGC9D3x4AKPKLt9SLRe1N3WakqtmZQFLkYUct3CahSiPnchrqPh+hAlbt0FmkH44mOShaUEUSmObFQcHp/aLPTDsMiHiFUSi15YzaQwaFVycuEwCrqUmNiCUWEp7Cq6IxJI+BCHWEF9SkxgYTSlVRRWBifeBxZRokpGpaEwmo0NcWhqBufic+lv4fyFJssDLrurgdhV04pl74nDYKewmtYFxsPy1SrG3BrFXuMlxtwE6sKw7AJb4yurR71Syb3GxeX9738/b37zm0/52sc+9jH+1b/6V+d1nT/4gz/g/ve//92+n/e97328733vY2tri8/5nM/hkY98JNdffz0bGxssl0s+8pGP8Nu//dt84AMfOOX7rrvuOn71V38VrfP/rjOZTOaeRCtFIEmtF2SRaeUUekesFt4PzmoaJ0kK0SgRM/SBY/OOzkW0ljr7oMPowWX6WevYnS150fOexV/87/+Xze1DvOZn3s4DH/wQ5p3HBygsTOuCvc7TBzg0tkyH2ZAd5kwrlJJ5ztaooHGe3UaW649sVIxLS2U1dvjvYHjrqNAs+sC0KvjI8Tl9SFy7WVGZQOcTdSlpHetFJhSRxKxyzDtPkYZat0toYG/pmDWOjSG5pLBK+pshBhikXl8JAYxWuNUMyhrC4PpaW0PvA03vKW3JrPPrSO/VNex5/vupB8fbzkXaEKiTPuXzzGTuSS75xagPfOADeO/X9qkXOqd6PB7z+Z//+fzWb/0Wzjn+/M//nEc/+tEX9DkymUzm3mR1IHxXNvEPcrnHnU0rS4iJ1gU264LWBJo+4AfbzjNZd1qtGJVmXaCPSrNWrRZGszXWxLh/sDupLK0LmNLQh4hWq63+cz8oa/pASvLcpdWk4SDZnSU2LUZxb2qG3OyYEvPWERKQ4PC0XN/PXuNpfcRoiSJYdGGtppDniRRarFutVfQuEuK++9O4MoSQOHFil1/5/hdy4uaPMj1yHU/+z/8VO9pGacWxRUcfI9ujgnFZMO8cldVcs1kDUA7KhEXnT3m9iv3IwyuFC+na1vl4Wbq2ZTIrcm2fyWQymUzmXLjpppt4/OMfz4kTJ/isz/osfvVXf5WqOndVgFaKvc5JHJyPEs1EZKdx9C4w7z3Ow6jUayemxjn6AH5YVjpYe6+cpBTiwGS1wlqN85F6JMrzziWa3uNCEqfiKA5S886jhjg8NVxLD6KcWecpvLgYFVZTojEabpv1TEtLVWhOLhxaSa/mvCxeWb0fp+dDwhpxP5q3ntJoNqrb96C9j6L2jglr9peLqsKw7GVJaFJZWh/QSrExNnR9ZFRYFNK3aa0w+sznAYohZj4EdlvHkfG+0zKIk7PWsoB0PgKP8xGaHBTetMOC1Kqnd0GU7m2QePk+xFMGVHJtw7hMIqLqw+AQEIjRnjEWMXNpkXuNi0sIt3et/uQnP3ne13HOXYjbWbO7u8u73/1u3v3ud5/1sY997GN5y1vewkMe8pALeg+ZTCaTOTt3Jug+E4vOrxfeQZakGuc5sXCkBNMkrqeHxuU6Ak6W6UUQcbrD6KLzzJue//TC5/I/3/8HjMYTfujGt/LPH/Z/SGR0YVgUnkXrmYwsSkmPMO8k2nprXND7gDWKaWXXYvkTi0TTB47P5d+3zVHBRl2ICIDEzrIXAf1aECCzkJSkZ7BK0aXILXstW3VBYRRXb5QYLXF58r0JpTST0tD6SOsCWsOyayVGW2tmnSMmWTyzRrFqB4xSQ4y1CO8VijD0OKvUk73WYYwMEhMiNNgaQxiivNOBucZdmUmskkOI8nnHdPnNFzNXBpf8Wvzf/d3frX9/vuqDc+VRj3rUGZ8vk8lkrgTuLFrtfLgS4s62RsV6o//0GLzCyOF2YdTaCvXQpFwf4k4qu3aNOsjqYPfwpOSazZr7bY85PCm5brMe7FPjKY5Jd0bnw7rYL4xirxEFwHJQCIcocQthsIadd55bdhs+fnzJzbsN8yGSwWgpLguj8SFybN5x827DXuNYtI6ml+vttB4XRXk8rQ3jUmOGuDaloCwNh8cl123XbE2KtRq67QInF3N+7TXfxtGP/h3jzUM8+1Vv5Lr73Z8+RrFt9dIQ3LLb8rETC0AGAauie1yaU17v+lDe3l4hfLmTXdsymX1ybZ/JZDKZTOZs3HLLLTz+8Y/nk5/8JJ/2aZ/Gu9/97vOOaVr1GqJ6jhybtew0PW0vURPeJ0KSJaOj85Zbdlv2Gses9ex1nmOzjpOLjnm3v4wD+4f6xbCcs3JN0sDO0tF4GVLENCjcnWfZeXxKhJTwab+X2216loNABWRYIwMWQ11ITPu0Krh6WnL1RsVmZSm0DDWMUkyqgsPjgmktjsatC5RWrWO4DxJSYt45li5QGhnEEGFn2RNi5MSix4dI6+R+JrXh8LjiyLRkWluu2qiZ1AVaKTofmbd++M+xs+g5Puu4bdayu+xZukAzuAyXdr+fvqsCkfMRmrROhEY+rNyl1LqnX312aS00OfM1coz55UvuNe47/Ot//a955jOfyQMf+MCzPlYpxb/5N/+GX/zFX+T9738//+yf/bN74A4zmUwmczqjQhaZSquHxSARiZ+JWetOcQHdXfbsNo7dZog5TlLn9S7Sucgtu+3ajXXWepa9P8Vh1AeJt375t7+Q3/ut36AoK37wJ9/Moz7z0WyPC6aVZXNUMCoN41pcpq4d5jtVoQkpsejDOhGkMCKWOD7rObnombUeHyNlodkeFcxaN0RmJ1xIp811Eo2LLDpxuhpVBu8je42j6YLUzdowKQs2R+UQP11J/PSo5JqNms26oLaGupDZVFUgsXhaEcLgtBoSlZXYv5Rg2fvB5Vbek9IaJqURQURVYLWmG2aHK2FCjGkt6NBaoVG3ixw/FxQyl0wJlB6udxnOFzOXP5e8Y9TJkyfXv7/22msvynMcvO7B58tkMpkrgfPdxD8TV1Lc2bQSC9PTY/DOhGJQjFbmnA9xx5Wh9YG6NPRRCvO9xjMuxfnpTO97TLJEtCr2Q5TiGODQuBBVqxeL2LWyQCtiSKc4SRVGobUcVO8u+/VhLsCs8cwazy27SxIKozUG6FxkpX1e9pIfPSoM07qkLjR7nac2mpG1HJlUHF20KBX43Z94Gbd86H9Tjad83ffeyIMf+i/oYmDZeeZtoC4TvQ9MaksXIpXRHDo8pukDm7Wl83H9eqtCn6IivtLIrm2ZzD65ts9kMplMJnNn7Ozs8KVf+qV8+MMf5iEPeQjvfe97OXLkyHldYz4sGykFjRd3Xx+lpy2sodbgfcD34Hwa1NzSh/UuMKqGZaq59FQbIxmWKKWpC1FY22EhKiKuxLNOFOqlMbR9IKTApLT4lNaildJqUkr0PrG77NfDFR9laNG6QOsDCsW4tIwmmpigNAUuJEor/aT0eCv/KcPSeTqnMUbRuYQPYehfFYmE84lZK88XQpQe2GiUlsFUbQ1peA/6oRedN56wmRgVFmM0vQ+MS4MLimUnC18+ytIQQO8kjp4EGulLxSHYrVX1d5XzEZr0p7lLlQfcpQ7GIR789XRyjPnlS+41Li6f//mfv47juRg85CEPOefrP+IRj+Atb3kLAEePHuWDH/wgH/vYxzh27BhN01BVFdvb2zzkIQ/hMY95DFtbWxftvjOZTCZzbmitqKzMTkaFYTY4Qlmjbufs1A6zkXnn1rF4Loib66S0bIzsOmLOGMW8c7ggMc5Wq/W8ZSWSX3SeV7/8pbzrv70dbQyv+tGf5nGf/wWnzIVWkW+jQmYqWim2RwVKKY7POjoXmGtF6SVGe1rbIWpO+ohJZbFaMWs9VSER0W5wK00H5jpKK2pjKK1iseelDxn++WvDKuEknDE6OibpPUJMHJ5U9CExG8QdRzYqYkzr+t4amRMpBUbJ/MVohdWyLFUO8666kMfOW09aOUQNVb4ejASUknlgTCIciOX5zRfDIA6xWlFbs75eJnNPc8kvRs3n8/XvNzc3L8pzHLzuwefLZDKZK4FRYdbKU6vlEPVgUXgunB7vdrnHnZ0pBi+mA0tHSlFZKV5X7kWrqLqzPbYYcqYXnWezLthDivdlH2hcoBwOxNWwad/7eEqmsgtxvYRlFIPa4PYHQ/Olo3MBqxXD3o0cqBd6yJHWNL38/bwXC1iJ1wui4HUe5+NQACtaH2hDJJKIyKGx93G4V0UXAsYoDIrffsMr+eifvx9bVnzdy3+Sf/awT5PXrizOJ7yPtC6ikQP+upCGZ7fpmVYFO41nOhwqV4VeO3Gdi4r4XD+HS4m7kp9+Jq4E17ZMJtf2mUwmk8lk7ojFYsETn/hE/uIv/oLrrruO3/md3+F+97vfeV3Dhcii84OzUaB30tPYJL1a5yK7S8eJRY+LiVFp5bFO+i43uDyVRrPsvAheXOSTuy2HRyXbU1lSSiSaLpBUYloVOJ/YnpQ0ztN5IIAxYFAopWh6T4zSA/gUQUm8eDk4Q3U+sEHBiXkvTse1ZTr0SdujghOLnr3WMSkts95LpJ+GQosTcm07Fq2nd+IKvNs4xqX0Dz7In31IbI0L6ZmUkh4yRGY+4lOk6QNm6DHmLnBi0bM1tmwV5eAmJY5SvU9EIhEgQesSTeeBhNIyOKkL6SMro/EhMe/8XV6OOh+hyap13neX2u+ZVt91LkKTHGN+eZJ7jfsmV199NV/wBV9wb99GJpPJZM6Bs4nKY0xrMfVqKSoOIn8zJHeUw/wDYHtcYLSidQEXPG3vUVozrS3LPkgEs1a89r98H2/7+Z9GKcXLXv3jfNG/+/dnFMuXVg/CcY018vvtkTzHrPH4JOkbktoBhVWMi4LGeXYaB0mzNbYYpdhd9qfMdVZLRT5EYoI+Rtou4KJ8LcREoUUs4UPCak1hlcRVD2IHmSOl9Xt5/+0RJ0pD7wNoRaU1RaEZWVm80kZRaINRCqVlfmIPzE5GpWFcWvl+ZP5QFfvifqPFfVVrNfQs8vytC4zLc6/tZ40sgFkr76tW6rKeL2YuXy75xajt7e31748fP35RnuPgdbN6IJPJXGmc6yb+HXElx52tYvDuTPnpQly7S93uKDRBIK0P3wsjC08xwaL3tH1AKUWIkRgRBW+KayvSg1itVnv4APgYQevBFlY26IuhaJx3DpCv77ae3gcKq9moCkBhFFy/NWK36Zl3gXZQBixaz6xzLPsoB/MpUY4NJNisLaXWoGBUaLTRhJCwSq0XkZwP/OGbX8PfvP830cbyzO96HQ9/9GdRKClqmz4xKROpTBgULkWs1UQSSxfYWXq2RiW9j+haFqFWC0Kj0tzpQfn5fA7n6/J1scmubZnMPrm2z2QymUzm8udiiBX6vufpT386f/zHf8z29jbvfe97+ef//J+f970th+i7tg/owSNoe2yZNYFZ6zg664gp4ZNERHS+pxjq6hAk7qJzkbmS/s5HGXqklOhCYHeZhkUfee1KKVKMbI0K7KDAPjQpsUrjotTvTRdwKbIc4thiTKgEmyPLpCzY63qsUfRBhCspcYp4pCoMV21UaK3YHsOk3VfOgzhSTSuJuSus5viiH7aAEj5Kz2i0YlIXlIMa/NC4xKj9KIxxYSVObxXz4SO3zVo6L+KXSWVJLuCDuGT1Pq1FPiFAWcjQJqSEc4nSSFTK+IBKP6Z0xnj6s3E+QpPVoOhM7lIroYlaC03u+DlzjPnlSe41MplMJpO5uNzdPuBsovLOydl/7wPzLsiijtXoIbquLFYzEBiX++f/o8KiUMwahxsi9SprWPaBn/2p13Pjj/0IAC9++at5/Jc//Q5ryYMOo+PSUlsRfqdkaF3EJnF2tUbE4CnJLOjEQowFtscFfnCrgtV7I45Sqzg6lTQxyFKUT4lF59c1des9UwwxiWvUgdTtNVYr6tJQWYMPPVt1QdwesXSy0NX7yKQu2KztGecPanBHrYflL5DWIaaEi5EKs35/NipLQnqTo65DqX03LqvvOInlICt3XYCtoRfYqO0VMV/MXH5c8otRV1111fr3n/zkJy/Kcxy87sHny2QymSuFCxHvdqXHnZ2JeedZHKg+7yjSzg5xBivnp3FpxJErwbIPElunZbnHI7FyRuv196/sQ3eWUiCGFLFaispxaU75jEQ9IAffs9SvD3ONUhgjUYFhuLerN2pK09P0no26YGfhUCh8CIysRC1MSkPjIyNrKU0ikKiMprCaeedZuiCKa63472/5r/zRu96KUoqnveQHefhjv0DCG7ThqmnFvHWgEhbNuDbSACiwCgqr0UoiDSqjBztcWdKbVpZpZSWz+gwF8bl+DrU1lFaL+5UXV7S7E9lwociubZnMPrm2z2QymUzm8sWFyLz17DaOzgdi4sAwhOGA3Zy3WCGEwNd+7dfynve8h/F4zG/8xm/wiEc84rzvLw6xEwCNk5i6Ualp+og1EoHnXGTeBRa9o3ERq6W3GpUGYzSECDrBgfg7pRTjQvqyFCEmWbCZ1AWFkfp+a1zQOlGlb49LRoVhr3HsdZ6NWpaenI90Q8+ojQIULkY2a8u4tDgfOTwpKa2WmJB6v5+5oyESKFKKKCULQ0YrqkLT9nFQdEsPYY1BK4kOPDQu2BhZypX4BhlwnFw4Tqie0iiWw6BmXBiOzztu22sxQ68m5wSemGR4ZI1CJSgLiyIx3bRs1gXWiOJ9r3Vs1gVNH9Dq/GP1zkdoogZr5tPdpeIQ3wFQG+mjyjv52cwx5pcnudfIZDKZTObicCFFy9PKEqK4Dm3WBa0JNH2gD1Knp5TYbRxN7yUWLxo6FYdaPNH0nq1xccrZulLi9jQqB2MAF5jWBW9988/x6lfdAMA3/afv4cn/59efErV8hpeyvh7ITGNziNVOSVxQXYyU1hCiRF3HJMtb1mgRQgwXGZXDgtNQsxsNKUBCkja6EOl6Wf5yUVJEnJc4wEkpNb30HlL3Ks0Qkbf/vk4q6VEWztP5xLiyVEWiNFocqAq9DuBeLURVxe1ff+8HMb8SZ6hqmD8cHpecWIqj7clFD+h1fT1rHaNSlqjuaL7YDi60q0WzaV2ggCOT8ozvfyZzsbn3p4Vn4QEPeMD697/3e793UZ7j93//98/4fJlMJnOlcHfj3c437uxKYLdxtG5fbdy4cMZIu2Xj1pF1q5zm22aOYqmZDHaibnBsWr1vISVIEaskVmDmHYsuSOSAkYN3EAXx6a5eq0W1zgd6nxgVhu1RQecjvYvsxh6lYNl7plUxuEtB4xzzxrHbeXwI9Gg2tKVzEaOhi3LdQmnGpaUwihhh3jT0PvI/f/3NvO+X3gjAU7/5Bj7zC5/EtLTUlShBrJbif6MqIIFViqumBcaIBa4LgT4kll2gnhhaF9iorQwglOK2vZY+JAojNqrF0KB0w2egtbrTz4EgTYbV8v11ae6WKvlCkl3bMpl9cm2fyWQymczlycllz7FZR+/jWsW91zhaL7EPoLBGUQ+LQYfGBa03ZxUrpJR4wQtewC/90i9RFAXvfOc7+ezP/uy7dI/NWmEe8TGx6D2jwhJT4MSiY9lFjFG0XmLzQpAhhQwBQDt5DZUxFFaxPSpJyNKXuEopprVh3klPt2UsLibmnSMMsXxVoRkXBh8SmyOJOG9dYDREZyx6UbBbrdioLXVpODwpcEHELhpxEjZa3a6PuaMhEojwZlwmZq1fv69NH1EoNkZ23evXhYhaTh9glNawPSnYaQpiSCQiKsLRWSdDmhgptYhQfFjF1MlgpbbSF4JE+127MWJaWSalxRolwixkOUqGZfq8zhTOR2iiFQQ44C6VqKwo1VdLYsUw6LmzePMcY355knuNTCaTyWQuPBdDtLw1xNMtOk9dyHLNzrLHDAkZs8ahlGJSG8aFXS/ou5CwRpb99xpZzJGUDakB68ow7zytC7z7V9/Bq176YgCe+4IX8zXf+CLcMH+4I+7IYVRrxda4RGtNYRTb4xKjxcXq+LyTNI3G40JkUlk2aksXZF6zum7nRHiwojCaWCT2Wk/jAuNSMSoVzieCTSgU09Ht3z81CFLGpaH3hpNLx9haGhNwITIu7VoAMC7tWV2d4uBa1brARlVQl0YWqKzBWvk1AYcnJbfNOlnSUomUFE0faJ243p4p9q/3gdYFSms4MpVlqEPjkioLvjP3Epf8YtSjH/1oxuMxy+WSv/iLv+Cmm27iIQ95yAW7/k033cSf//mfAzAej3nMYx5zwa6dyWQylxJ3dIjqYxoiBM4c77ba+oazx51dKayKZ4C9AzEFp0fa7Tb9EJ8Aiz5wculQGqalLByFmGTJaFD8LnuPG97nmOT93KjFejVEiWHYXfaEBFsjyaI+yME4tfbAokw5qBFmjcMoxcaowMeAUXDrbsOsC+wuHW0MFFYRkZi8mKSZwItT1KQ09DoyHw6dIRFi4v997zv5nZ9/LQBf/DUv4nFPfqZERiCLWePSMqkMIUmkwUZVoLUc7O80jkUvGdIaNSjLEwpxj9ptHCGKta01Ghdk+Ws8LAAt+4BCmgelwA5xhQc/h5X6txsGILPO08d4t1TJF5rs2pbJCLm2z2QymUzm8uOTOw0nFj0A885xfNaz1zoZhjAokAdlcaMVs9Zz257mmo2aIxvlnYoVXvayl3HjjTeiteatb30rX/IlX7L+u/ON6lj1tK0XR6O0dhWSujqkiFZ6cIhKpBpcjPgYUQm0VRgjam5jNJ2PXLdVs1kX8jgfaZz0SIXWjGtxCZ5Wlj6KI5TWoMuCUSk9TG01IURmXcQHEcIcHhdsjUpcSBitUGg65yVig8T1m/VaXX1Hr7txYT1EWg2nthAl+0ZtaFxk0TlikiWr1ZDkmo2K8oA4w4fIXuPYbXp2lj1loakKEbKElNBoZp0jJXBKFsus0Vir0UkMtvY6x7LXbI8LqsrgQ2RzVDAZ+sR5F+hcpDVyz8susDU+98Wo8xGalFbjQli7S/U+0mq/jjOphz6ztPoOhSY5xvzyJfcamUwmk8lcWM5VPH5XRMvTylJZvXaiWnbDtZViUstsRClF03sSitIqic/T4oK0mmmNh/mIC4GxtRTG8Se//zv8l5f8R1JKfMUzv54Xf9cr2GtEQH5HC+9ncxg9U9RyYdRQ8xuOuY6QElUhcdyrpaj5gZnQSjxfGE1IibrQtL1j3iV8jBRaEUls1MUwt5P6VyklDr1WnyJwkF8llntS2nWUd1VoOhfPydXp5KJn3nnssIhWW3n8av6wmmscnla0XnqHlBRGQVL7rr0HY/8kCjDig0RyT2sxABgVhqs3qzO+/5nMPcElP90uioLHPe5xvOc97yGlxMtf/nLe/OY3X7Drv+IVryAlGUZ/7ud+LtZe8m9JJpPJ3GXOtIl/tg3/FZdKLNnFZmX5CqcuRZ0eaSePUetIu2UvxauK4Gzk0LhEK8VosCs9uejXh7FVoRkbQxvkwJ6kaIaD8JVrklJKtv1XsXzsq1x9kAWgVabzbuMk/1opWh+JTU8fIrtLR+8iHinEOxdRJPYWHqUVhfWMtGVjVNCHQOugj45xkWh6sFbzF3/0O7z3jd8LwGd9+bN5/LOej9WKkKAsxCVLwX5MgxKVtQKsVfuWsT7gfCJGKdhnnVsfNgPM24BPYhlbGc2JRcRHODQq6UJYfw5HpiWHJ9XtCvm6MEwOLBLdXVXyhSa7tmUyQq7tM5lMJpO5vDi4FPWJkw3HZq044CLCh0BCxUQMsOw8icS4LJhUhn/abWi9xEOcSazwwz/8w7z61a8G4MYbb+TpT386cNejOlaxDr0TEdC0tsy7fYffq6YVs6bH6AIXIlVhWPYBH6PUD3J5QlSEkNga7ldr2KoKdpYOHxJbo4Kq0KKa3uuYVpaTy55FBKv1Os4PJLJiWhdMaxGPxEGYtOwDhYG6KNAKNmpD6yLOJ27d6zDGcc2GDHqs0ae8bokzV5Bk6FBa6SWoC0allbjyelBpOxkyFUYiuVeOWi4EUad3ngji+pXEpapzkVFlaXoRDEmsX0HjIikmSq3QST6MkBJWS2ShG1y6JpVZ9zej0hKHiPmml8WozgditOflgHuuQpN6+Eyt0WgtffuyF9epstDrRaqVE++ZyDHmly+518hkMplM5sJxruLxuyNaLoxma6w5uRSBQGEUzgUWXaAuNJUyFMZQWnFnClHuZZXesarnSyvziMJqPvSBP+WH/9M3Erzn3z/lK/n2V/4QSqnbRS2fztkcRu8wallJLd36QOcTdtETwr4wPMZEYSWlozoQ41cbjVOJUVkwKsP66z4kQoocGckC0daoOCU+7yAH6+lpZWi8uLUemcjjOxfv1NVp3jnmwyxsY2SZVgWl1WyMivX84eBc437bI7SGnYUjDLHaWsl7mhAzgBASPkmc36hQlIWkjIxLwzWbdZ5rZO5VLovq/eu+7uvWDc1b3/pWnvKUp/DUpz71bl/3ne98J295y1vWf/76r//6u33NTCaTudQ5fRN/fYh6BhScNRP6SmPZ7SsgVsX+6ZF2PsS1i8+8c+tIu43K0oe4LmLlcB5QUBViObq7dMwahzZaHJpcXFuPrtQD49LIQb2Vwj4lmNZ2beXaDgftfQikpId7SnS9p/GR3TbhXGTee7SS51x0snhVFZqkJZ5NN6BGmmbWDQfFCh3s+vqf/PP/wa+89jtJKfLIL/wKvvQ534E1mq6PTGrLuJRFHR8jwUlnUA0HzD4lkgeFYtEHeifqaWMk+sBqyedues98sItNQINYqzKodOetQ6OoCsORaQXIYt/GGZQmWikmlcQ17DX+bqmSLwbZtS2TEXJtn8lkMpnM5cHJZb9eivrI0TknlvJ7A1ijMHp/sd8FEYqElFj0jmXv2R5Jza6Gw/IHH5ms+8qf/umf5qUvfSkAr3nNa3je854H3L2ojtWwYtWr9T6u/xuXFq0UrrQUhcRa7LUehqGAj9LHFUahtbjrtt4zCppjs56rNkq6oWfRGqaVDAsOT0tiFDW5rveFISnKa9ZKobQ4D/VBBhOVNWyPZXlo9dr2Gs+JRU9pFEc2anwKHFt0pFkSEUhlT3ndYVDqj4Y495Wr1kZdoIYe8KpJifeR40tHSLJQteq9VkMukM+v85HCKE4ue6wCO0SsL3tPFyOLxuES1MZSlDLQsVYxHsQ5xxc9VsPVusZ5+KedJY+4/7bcY2nW7gK9j5RW07gzR+HdEecnNJFIwdbF9escleJsDCJ6uqPzjRxjfvmTe41MJpPJZO4+5yoeX3F3RMvzzovrUmHoQsQYzaSGjdquBcIacVJyIa5js+fDAtZGVdD7RAiJv/2rD/Dd3/S19F3Hox/3xbz8NT9OVPK8p0ctH6T34awOo2eKWl66QOcCt83adbLIzsJRWnnMqq40Wur3tLLbRZIxls4BSlykrDizFkbJ7G4U1vOhzdGZ37uY0vp+tsYlpQ90fWTWekalzPV6F9fuU6s2a+Xo1LqA1ZqN2nBkWgMiTD99/nBwrnHd5ohpaTmx6GlcHBbNZDHNKDBWUbI/19ioZSlqY1TkuUbmXueymHI/4xnP4OEPf7g4Y8TIs571LN75znferWv++q//Os961rPWKo+HP/zhfNVXfdUFuuNMJpO5tJFN/IKrphXTobhcZSIbLYXYtLJcNa3YGhf3maWole0nQDMcoI5Lczt7/lVB2/n95amNumBrXO67Ow2P2Vn2NJ1s/K+U1T4lXAgoEtPaYpRhWltKLQWkUop565l3bn0vYj27f5+NC6Rhj2beexa9RylF7wNdH7BWQZJGYbVwU1pNoTUblWWjksGA1atYgMRuI5VxaQwf/es/52de8QKCdzzssV/MF33Dd9H0kWUbCIjKoTCK1oV1U1BYTTnEAq6k3fPe4UMkhERlNXWhsVoWnVofpBEpDFvjgq1RwaSyGC0NkQuRm3daji47dpY9xxYdjZPYhIPDktOprFlH8TUHPqt4Jpvfe5jVawRpGA9NyrXivDBKFClGURWarVHBoUm5XoqaVPYOrYczmcuJXNtnMplMJnPp40Lk2KwD4BMnluulqKqQCLm6tJSFZlxZticl127WXLtVszUqxFVWwfFFz8ml/Hd01vL3t844Nu/4mTe9hec///kAfMd/eikvecm3AxLVsarz2z5wctGz28ggRhavZJDRuchu4zi56Nd916KT/immhBvq/lVPt3L+WTjPsvcibCkt07pgXNrBlbZkPETzNU7cd3cWjmUf1urx0bCgtOqPtVJcs1FzaCz1vBr66WlVsDGS/lAGAIUscDkRv9SFxvm4fm0nh/jxkBILF7h5p+GWnZZZ43FBlnx2lu6Mr7sZIu8OT0qumlZcvVHx0KumHJlWjEoLRrFRW45MSkalLGf5IFGACiCJOt/HRFJQaE1I4tA0KqVna1ykjQmrYDTSXL1ZsT0u0MrQOnELK4zGGhEDhSTx7Dfvtuw1jhDTOoZkJcI5kyjkbEwru+6NNutCYum1Wi92zVrPXuPxYVjAMnqIfZfIw2XvKa0640JWTIlFJ9+/+jnPMeaXJ7nXyGQymUzm7nNH4vHJMFM4EyvR8uZIaq3uwJL66nqnc3ABa977dfxcXRg2hzq6sobCivPntCrYHpfrBfbeRWbDDOXDH/ob/uOznspyMecRj/5s/vMPv4E2yEwmprSOSO59XLtGxZRY9p5ZO8xF7sBh9ExRyz7EtYhkOSyE7bWOm3cabjq65CNH5+wsO8yQsOFCZK91NC4QkzivNkM89HQQcSzbgFGKvcZxy07LzrLn6Lxb9zmnI864mo1aXKU264LrD9UiTBgcW7VWQ68i70Pr5F5jkpnWkY1yvRR19UbF4cmZo+4OzjWmdcGDjkx48JExh4Y+o7JaYr8rw+FJyf0Ojbh+e8Tm0BfluUbmUuCymXS/7nWvQ2s5ZOi6jqc//ek85znP4aabbjqv63zsYx/jec97Hl/xFV9B27aklDDG8LrXve7i3Hgmk8lcwmgtxerBQ9SrphWHJ+VakXpfYuVatFIdKHV7i/2DRXB7QEm6ct1aDQF8TDS9LPF0Pkh0nBN17KGhEDRaCu2EHCSPS8vmqGBS7DcPq+WoZR9wa6coaSqUOjWjujDqFMvVZR9JwKQyXLM14gGHR4xHdn1oPxrsZg+NZQFnUhla5/nEP/4tv/C9L6BvGx7yyM/iS17wfYDFaFFlNC5wci7q8aYPsiRlNdNy/4DZaMnXXrZS6JelvEY1SCL6ENaNzqg0HJ5UHBqXlEazu+xFURwSZSGxEcYolp3ntpksSd2619L0d7wcNSr3P4fey/vQuDM3YPc00+F/c7WVGMLSStOyPS45NCnZHn4+VrENtZVmIisqMlcSubbPZDKZTObSZt56cXDtHMfmsiBVFZraikK8LgybdcGktJRGY424GR2ZVKIiriyJxMlFz8eOLzi58Byb9/zme97DC77hOaSUePZz/gPf/t2v4Ni84592Guat9D57rWPW+XVPVheajdqyNZJlmLrQ61p/1nn2hu/rfeTEvF//nfRMEoXRuMBs6XAhYbXCh4hK0jctWlGpa62ojIg9SLLE0ztPUSgqaziyUVEaTYqsI8+1EmX31rhke1xIRIVRg/BI+iLnI0ZptscFqETrTo1GL7WmHJaKYoQwRFH4GIHEZl1gjSKmeMbX3fRhHYGxYlRKn1doiWkfDcOW0sh7iR60LErhA4yHaMDD05KqMPJ4LctB1ihUSpTW4F3gxKKndREDa/X31tiiEuwsHbtNj9GanaZn0fkhglB6v5VY5Y4iTM7GuQhNRqVhe1KwWRfcb3skr3fAhcRe42id9OmtC+w1jhOLfi2AyjHmlz+518hkMplM5q5zruLxO+J8RMsHF7Ccl7/fHBlGhSHEQSDee/aanp1lz8lFz14jtWWhpZbuXeQfP/KPvOBrnsbOyRN86iP/FT/0U7/I1uYUEHfU3catBQW9l/pv1joRtQ/3uIp8W73egzXg6VHLs9bLzKdxnJj3zJbSv6QQSQq64NlrPUdnPZ/ca/jkySV7Syf9yqLjlr2W3keM1hilKKxi2YlTrlLSD7gognfnIyfmUq+uXvvqPV3Vr0emJVUhfcz2SEQrRyYlpTFrYUlKat3HTSvLVm3ZHkvNXFnN9ds1127Wd/rZnj7XqAvDtZs1Dz4y4aFXT3no1VMefHjCNZs1k9IyLmyea2QuKS6bn8Qv+qIv4rWvfS0vfvGLUUqRUuLNb34zv/ALv8DjH/94vuiLvojHPOYxPPShD2V7e5vpdMp8PmdnZ4ebbrqJP/3TP+W///f/zm//9m8TY1wrPABe+9rX8oVf+IX38ivMZDKZzL3NSrW6UrEezHxesVIL+7B/mH0wa1riFzS9j+y2jkJrZp3HDNfZqC3WaDkcjmkoZKU4VUq+vyo1NYbZYFNbGLFNbX1kXGr6oUnoXMRFuedpZcVlyUuGs+8DIcFmYdClQWlZhFJK4hEUokpwQZQCV00qXIh84mMf5edu+Eba+R4PfNin88zvej2NKuidZGRrFRgVhun2EBuILDytlqJKq3CeYRHJSyQFMCkLfIhMq0oGA0aBkvejtIZl79dNiFaaEAPHmharNNbqQc0QKQe1cUpw827LtZv1GRW/q0P/bojeKK38/g4ED/c4q/z0GC2NC+voi3U8iFKisChybEPmyiTX9plMJpPJXLrEmNhtelKC47OekBJmqK+BtevwHSFOsYZCK2aNI2E4sWj56z//C274j8/EOce/f/JT+a4feA0uJJRK7CxlySckWSKC84/qKK3m2LylNBIt50KUmO2lp/X7IhhOibBQKGXoXMRHqcn94Go7qgwhKiptJUIPGYRMh1iPlGSJxoVIbc26p9scFQcEK5EQEwUSw94dEIdYrZi1CWtg4TwK2BpL1MS4NGtRSRcC02FIs1lbXEhnjShJSeI5plVBaSNGKXYah9GKWeeJw4LY5qgAJNp90XtChMPjkhAjPgZG1mJGaj2oKgtLZQylVfKeKDBGA5oYoQuRziV2lj3ORypjuGqjonGRPgS2R+X6/u4q08pSWS0RI0OvtxIqHWTVTx+ZVGjF2nUsx5hf+eReI5PJZDKZu865iMfPxrlEKZ++gLUSGJRGc2LRc2LR0Q7zjHzA5VEAAQAASURBVFNIEJBF+73WcfPNN/Oq538lt916Mw/5lIfxqp/8BXQ94tC4WNfwUv+FQUzumXdeBB5W0i3qA4tfdaFPuc/To5YXnWfROVqnOdGIk6syitglljHJfMQptJZ46hgSu8Gz23rGlRnq4UShFeNKs9d4Eoq60BijOLHYd4dyPjCpC9Tw3J0X0bqMC+R9WTmd1oWI91exhHVh2PKRpfM0XRjq32GeZY0sUg1920Z97jF3ea6RuZy5rLq7F73oRezu7vKqV71q/bUYI+9973t573vfe07XWDUyq/9e+cpX8i3f8i0X65YzmUwmcxmxtlAd1AtnOuzvT1ueKs+wPFVaLQpUFykqTdMHppUdnKWGjGqj6Xyg6UWdPO8cKEXvZJFno7KiDoiJtpfFqNUiVRjub9E5yqHINVqx6LwsRXmJmqitYlwaYgIXpZEZl5bdxmGNZpXNN28DVeGYnzzKW17xjcxOHOWaB30KX/WyH2eyMcUvexZR/g0tjKgV+pAYFZrD04oQpaE4Mq1QQM+qyQi4KBEGSkmWtixORQql1+/HwQFBHyKdk2jAZR+pbKIoNCEktJKIjN5Frt6U55q3npgSG2ewYl0tQ91dVfLFZOXadqksbGUy9yS5ts9kMplM5tJgFdW9OtRedJ5b91qWXeDorAUt8Q8rhfHZHHQWvdTopTUY7Zg3no9+6G94w3c+m7ZZ8jlf8MV8/+vegI9K1Nt9QEu6N/POUxeG67frO1Wlr6I6rFHsNZ7ORWxlgISPMiZICRatRHQDtM7TelleKowsEdnB2SlWEuWxs+xhSAYPMaELMDpBSmyPCxa9DGxADv5HhQxHVkMVcQ7eH/rcUQy7KM1lGWze+n1XqZH83fa4xId0e7GMi2yOilNed2sCdWFYdoGtsV7fGweGE4nE1qigc0H6ycKsRSo7S1l+CyESYmRUGGKSSMAQEotec8JLTIjVcj0XYFSJw20xOEsdGpXsNj29TzgXCVYW7CqrKAtZHGtt2L+/u8G5DGSu3xoRhp/tFf0gnInxwGO1DIcOLldNKpuXoi5zcq+RyWQymcxd41zE42fjXETLpy9g1aXUYivxg49RROha04YAQ/0WkNmESorFbIcf+Oav5ZaPf5Rr7/8gvv+Nb2Nz6zBGKeadpzTihLRoAx/f7YlRRBA+SP149aRia1xg9b4wY1XHxwNCDJAFJKMVN+821NYw6xyLVuLqYkpsjkSskJA5yEgrrNZoLTVFiCJ0X2jPNRsVfUhUwxJR52UxrAsRkKXs3cbRWgNK0fYBnxIaqV1TErHI4Wl5itPptLK4EE8TEJRsj27/GSkGd6/q7P3dGT/jPNfIXIZcdh3eDTfcwGd91mfx7Gc/m9tuu229KZrOYdi5amJSSlxzzTVrlUgmk8lkMrCvWl39eqaCf+X4ur88dfvHKKD3iRQTYfhPIiD2D/aVSsxbRxcCKSo6Pxxm9wHVSoRCaWXZyWi9jgbYa0UJveg8jY8UhWQ3tz6w7OQgOyHRCxuVpbCaGBMuilq5NFJst32gqgwasZy9+dZj/OR3PpfjN3+c7WsfwLNe/kbGG1uDfasoFkorblfjwcHJpUjbB7Yn5XposRo67HY9e60jRtisxVp1XFpilFi81fux7P16QLAYlsQisjjWmzionO06R9wtOlyM7C4d42pQkGuFVv52zlGrj+/0zzWTyVw65No+k8lkMpl7j4OH5gf/5W1dwIXEyUbixWTJRhTV1RmceQ7SuCCxdEpJb6Dg5k/cxM+97HksZns8/FGP4cd/+hc4tDmWmO5exCIJGcJUdojJC4lz2UuRqI59ByWjFHuNo+sDO63EfxdaSb/kAgowSrFR29v1e1opxuseSsQlpdVsjsrBwXZwuB2Uz1opid+zhtaLs+6skzh1awYn4TuIYY8x4QZBy24jC1JbI7Ne2NJKUVpxMGr6sBbL9EEWgA6+7qaXXlIiSuzQHykCCa0V0cW1Qn/1Gg6KdlZ1VzdEkIco7sLWKMaVRJQvO0UfE8vWU1uJ4qutOCpVhdyvDwkXLZpIXWmUFlepvdajXaDU0re6ECnMhTmSPpeBzKg0Z3WXgrs/HMpceuReI5PJZDKZ8+dcxOPnwtlEy6cvYI0Kw14roonSapqlZ9Y4lAKFGhIqAs5HFOC7Ba/79q/nE//4d2wduYYX/tDP0hSb7LWOBx4aY7Vi6QIfO95QFZpDo5KmD4xLu55D7HWORe/ZGhdcu1FhjaId+pk+xPU8YRW1fMtOK3V2TJxcOHwI1IVipAqppVNiVFpOqJ6mCxRWrXsHkSooQkrsND2FMRRG3KpONo4wCBmsUTAkfWglzq1tCuvrlNawVYtAZJVSctDpNDs6ZTJ3zGW3GAXwJV/yJXzkIx/hxhtv5HWvex0f+9jHTvn7g7Z6BxudlBIPetCDeMlLXsI3fMM3MBqdYUUyk8lkMufE6ariK6GwOqiqhTM7DK3+Xbmz5amEDBmUksJecaqz1F7bc9tex17r0Mj7Ne8kok8ckMQ5abMuhvc1cNus5/CkYOkCI2sIKa7vQyu1VkKHmIhRYQxsjkuxizUK4yKBxKILEgtRRDmoVhBdy8+8/D9y80c+xPTQ1Xzld/8U9aGrGJcWFyPVSDOqwCo1WMtqWdYyGjcooksrtq8+Rhad57a9Fp8Sm7VlUhWkGKkLDQqM0uthwCo+b9WMAFSFoTRaFsqG7OtCy4JUSol55+lCxHqJgxiVluVwDwcbtdVntPqI7q4qOZPJXBxybZ/JZDKZzD3PvPMsOr/+80EnnROLnt3GsdM4fIooFCFGWicRZKPizE5OIe4vDy37QEywd/w2fvEV38j85HEe/C8+lR+68S2MJuN1vIMCGmeYNZ5l7wnJcGhSsuwDldXidHsWRqXEkM/byLzzLF0gJHGOIiX2ek/rokROKOhDIESDNvI6YpKIj25Y6JpWBaTE8WWP0Yo+yMLWbuuZVpZ6WChaLYmNK1mMqktDH6NE3DUSjRdSEmX6aTHsjZP7nLeekNIQ0Sdq74Pvb12IS9TKPdgacScel/ZOI0oqux/xt7Po6XzE6rCOQzlVtCPDFz8MrdogwyatFEppXAgcnlQcW/SQElWhmNYFG7U9xdUrIcObwkoPZzRMq4Kmd0QHVJatUUHTBw6Ny7N+rheKPBy6b5N7jUwmk8lkzo9zEY+fC2cTLZ++gOV8RA/xcL0L7LZu6C0Uk9KgtCzFl4Vmb9Hwk9/1TXzkbz7AaGOLr33ljVSH7i+RfFZzYtmz7Dzbo1LitmedzE1SwqdEbQ1Wi+NrVWhSglv2OkalZ1zur04cjFrunCzajyvLJ3caeh/YGBUSOW41i056KQVs1SXjMmCGOOfWR0gyfEok5k3g/ofFIdYFz7gwmNIwrixm6BlmrScSmRQS6z0qDG2IVEYi9yorIvtDk33XqINkR6dM5vZclotRAKPRiG/91m/lRS96EX/5l3/JH/zBH/Cnf/qn3HrrrRw/fpzZbMbGxgZHjhzh2muv5TGPeQyf93mfxyMe8Yjb55FmMplM5py5I1UxMOQ7J1yQ5ZjLTW15UFVLkNdRn3bovzo0vrPlqX5QByijSFEi4FbvwW2zlr3GierARXof0FrTOo8PcuDd+UgfpCnQSlQEicSkNPS9LEYVRtE6hhi7QOskI9pqiaobF4ZRYXBRVMiF1XSdo3WyoHRoUrF0nuWy4S3f/yI++jd/znhji+d9/09z+IEPJsX9haRxZbh+e8Re6+idKBdiSix6x27bs9v0nFiIklgsca3YuVrD1dNa7jtIIR5W92P0OtKgD3G9FDWtClrnJU5DKWICH9P6Z60qJFJwdWDZ9vKzWFlRUhcjfcrnAKcqujOZzKVJru0zmUwmk7nn2G3ceoGp7cN6uWaFD7LM0/WRpougEgbF5kgU1CmlUwYGK1b1vQtResK9k/z0d/0HTt76T1zzgIfwn3/0zWxubnHgqdZx340L0MkyggtxfdC/OTp7L7mKuFi5zxZasbPscT7gUqTrI4suMKkMRimWXSCEns1RIU5Hab+/KIxmPDgMbVYWozWdWw1pIroW0Ytif4GpMJpJZVl0ns26YA+Jv9tpnPQ/PhFJ1MOyUu8jJxY9LkS6EGVxZ7iXUWlOWQbbjyEJtD4wNZreR8blnUeUHIz4i0ne193WrQc3B3sjrSCwvyDifaCwhpQSsvuVqEqDWii0lp+Pwmi8P9XVy/nhPbSrKZg4LDeD647zstjlhoHOPU0eDt13yb1GJpPJZDLnzrmIx8+Fs4mWDy5M+RBxSF097z3Hlz2Fkei6EBJ7naPvo4gW+o43/+BL+IcP/A/K0Zj/83t+ksn1D8alwNVlybzxhJgYFYYTy44E62X+ujBUQOcC1uw7iSYSpdE4H+m1LDydHrXc+ci4ssxax7L3KAXXbNT4kNbOpKDWTlhaSZTe5sjgQ1rHjS86j7Gw1zgSkGLi0KRka1xihlmQ9xFrFKUtmQz9wdaooPeRWevoXYQStifFepksk8mcnct2MWqFUopHPvKRPPKRj7y3byWTyWSueO5MVbxWW2q1Lhrb4fB2lW98qXNQVdsNauhJSmc8NN5fnjr1MDgOB/kJqI2hCZ7CajRqvRQFcHzRsbcMaAOjQg6ujdFUSqF6T9tFjs96qkKjhhzqSVkQkYFDqQ1WRXqXuK1vcT4gZ8sakNeglBT9nXeklWIa8B6SjegU+JX/67v4u//1R5T1mOf/4I18yqd+Km0fWQ5xFhujgnElMQvXTA0pJmadqJrrwhKiY9FGvPeMSkPfRyoTmVSGaV1QWE1dSDZ3XRh2l/36vVrF7nWDa1RdyMJXiJqGQGEkrsGFuB5UrD6JQmuslaHAOlZisObVWuIBV7EVpyu6M5nMpUuu7TOZTCaTubjMO79eitpr3TrWWnoHcWCVOPC4Hkb0IbLoA5tOvtb5iFLhFGejmBI+DvW9izSLOT/+nc/j5o9+mK2rruVFr/l5Ng9fPURTceD75NdCizLaaHW72Lg7EzjMWhF/lFYza8V1an0/gyuQ0WpQa8vAxUdRbfchMCosdSkLUxJfLrHhWsNGWUCC1on7kx0iwUH6rIPuQtPKrh2zNuuC1gTmrcMnhsWzCMkS0zAQaR2NCyxdRCUZtGzWkUNjcckdFXZ9/cIqOg+DafApi2V3FFFyMOKvsuIy1XSe0hqm9am9eWHFFcoaBU4WnBIBrTQhSZ8WQmRUaZyLhCjvpbGnff7Dc5dDb2a19GuraPnCyrBpWltxAM79WeYeJvcamUwmk8mcnXMRj58LZxMtH1zAWjk9HZt3OC89R4qQVMJ5T9tLXzBfOn7l9d/N3/yP/z97fx5vWVbXd+PvNe29zzl3quqJWSZjFIgmTkA0aEuUOKBG8eeUgAaUYBQxKKg4gRLHKKIoEI1iHFAQZxMTfRQnMuAvIoM+MsnUQ3XVHc6whzU9f3z3OfdWdVV3dVPddtPr/Xrx6jq3zrDPObfp9V3rM/wBxlU89dt/nIc+6mPoQsD7zP5qoLGG7bF54uzSkxI469mbSKrStds1ZuqYd4FF76ms2SSHbtVyn7WZYF213DjNwUrOdY46+edO42icIeg0Grc1s9pw1In5PaZENpkma6yRhNLWRwafsFZxZt4zreXcZFo7qtE4sNc4jtqADpHGyTzWWJmTZrWhtoqY2FR3n6zTLhQKt809/5S6UCgUCvcIbs9VvCFmep8kZtQZmkqcqinni0Z63pM46aq1WhHGqrfZCeVTNW4ar8VTQ0ik6nizXhzUErO63jivrOagGzaiqFsWPQfjn7ecVCBMnSGhaIdIYzTRJkJUrIZIHxM7TebmeUvtZNN+0XtizqDGaj9EDNT7iFGy8B5CgvEAoI+SFBWVwlhxev/Sf/wO/u8f/zesc3zld76UD3/UPyZl2cwPMUs/dmV58KkpRrOpzdiaOPbbgcOVxyp5j0qBtYpd5+RQIMuhy+7E8aBTE466sNkQB2iHQM6SeBWy1EqshUuV1YSUsUaTxt1/H9fvU1gf3IQolQ8+JNy44T+tLe1w/D1c6OguFAqFQqFQKBTui6yTfeF8UdS0Mkwqs5lpGheZNZbtiQEsZxeJkBKtD2ilpDrOi5HBalnDDzFt1vdt1/HSb34m73zbm5jt7PHvvv8/c78HPgitoTL6PLf4Sad4bTUpcdHauIux7MOYnAvLXpzb6/OAnbqiMokz85aYYGdiWQ1pTKuN+JDRWaF1ZKbseWIhPdZX6LH6YuUTkwoqd5y0NK1vPVvsThxGK5Z9oHGGnYmj92ImUkGhVGY1BFZ9ZOklITenTCCzrR1Gw1EXmHeBymi2Jpbt2qFGe8ha9HSy7uu2KkrWFX+VNdQuMm+lwnw2WJw5fi/r9N1Ka9Tocl/5zO7UoTLMasvZxcDMWVolewKtj5Az01p+b9apyWasX++BnBPLIWCUYlpZrFF0MXJtVW+SrQqFQqFQKBQK9ywuxzx+e1yOaXktwFJIjV7nI8tOZpXaiaC+D9KksTtx9DHymz/xPbz5j34bbSz/6gU/wof/48eSxtdJKXOw9Fy9LSImY5SYsLWcM6wXzvsrEUmdmlZcvV1z1Hr6IGlUqyGw3bgxwVaz0zj0uL5PWWaUEKR2ej0/WKOl4nqI7E3deIaW6AcYQiBlMVEoJUm3fYws+0yIUqc9dZZZJZ/RpDKb6uut2rI7rVAKTs+qzeefslSfX6xOu1Ao3Dbl35JCoVAo3C6X4yqW2jNxEPRBVPHzPjCkxE7jNtVo9+TkqJOu2okzzPvAaoijov84blV+diyeWm/WDyHSrtOPqvX9pVbu3KLHGs3hauBgNdD7SG00GWiHhNEao0Fr0FqzaytWfWA1D4SUWHRj8lQXcLuaYRSlTazUNszbwLmlRxtFSJp5FyErJrWhtgY1bqe7RtP7yK+9/Pv537/3WpTWfMnzfpCHPeZxKK3QSeGMoa4M12zXXDWtSGS2K8epqVz/aogYpdibOnwwKBUk/SlDVopFH7hup6F2msoaluMBRQTU6DRpfaIykioGnLcxL8j7m9UWH8VlPIS0GajQUvVXjTUNXYw4qxliwgSp0gAZJuDWju5CoVAoFAqFQuG+xqo/NrqsZ7qdid3MOmsqo0dntKXzCec05Dw6uQ0+KKnq9glbywFHGB3hq27gJ7/z2bz1jX9GPZnxb7/3P/HAhz4SazS1k/+dXJafdIprpdBWbl9YG3chIabNmn/Re/qxxm1WWaxV3HzU01iFtRrfJ2pnqZ2IqQar6XyiDRHtFedWPQBbjZhQupAYQqZ2ipTAjo7x7dqRRqHQperit2pLbTWrXuZfZzXbteUoB9ohEXPGGIUajSSLPqCBfXpar6mcYeosmUS/GFj2cTNDr+elk9Vet1VRsq74O7cc2KodcxcIQ2DpAyFLXYizMinmMRlrCJFhdLjHlJlWZnzPhj5EObTJ8iJDyMw7SdNaz2muMhyuZIZ1RuOQGXpv5lh0gcbq0QBz5ypZCoVCoVAoFAp3LZdjHr89Lse0vBZgZcQYcbAaQMHKRwwQx1rmboCYM7/xyh/mz3/rF1BK8VXf9oN8wqd9Br1P3HTUEZMIqKzSLPpAJjN1hmt3J2igD3E8SzCEKGcMIWUqpzk9qxmCGEGmlWVaGRon5ynr84Q+iAmkC/K+nNFYdTwPTCtLylLRtzupWPaemDLLQYwCKeWNqTumzCrI2dDU6c3n2jiD1Zr5mEi1Pl+qzIU12Jeu0y4UCrfNPfd0ulAoFAr3CC7XVbymcYZJShwsPQetJ68y+8uB7cZxsBq4bqfZKO3viaxdtU1lGFKi94mjNjCt8ub9rheeTWVYdFIvuK4IAHESW61Y9ZGdieXmo452iBiTuOmw4+xqoDaGujGsc5BWQ4SUycCQZKE9dYbtqWM19k8PPrHVOFLKnJ44slLknEf3rQjUWh/ZX/W0PpNywipL7aSDuvORPiT+4JdfyR/88k8B8KXf8N189D/9dIyB2mi6FKksbDUVs8oSUmbbKhFf9R6URLb6KE5voxS7U/kd0RomzjKExHbjxkEhc7DyzEaXd2MMg0/S463FIQ0y5KzpQ6KyhpgS08owbzOtD7zzTE/v5SBhq7EsrGdWW4xWuCTCvEUfN+lStdObmN+LOboLhULhvsJb3vIW3vSmN/GBD3wAYwwPfOAD+biP+zge9rCH3S2vPwwDb3vb23jrW9/KjTfeyGq1Ymdnh+uuu46P+7iP4+EPf/jdch2FQqFwXyalTDsEWh+5ed5vKjGMltTaysjaWY+VdqshstNY5q1nai3LIRBiZvBiknDjQca66i5lSCnxyhc/n794/e9hq4pnvOhlPPQj/hFuPAw5Pa0389SaCw0Uo07qorVxJ1mLovoQN0m+s8qitCJGEWpNaisJt0AfAk5rjFGYqKitIjMm2AZofcAaSUuC8bBDazKZ7cYydWvji75ds48zmt2pfD7zznNumTloB0iSsrvsI/MhkMfPLqRE28uhUBsSizZIUu/oQl92QQwvs2rzma25vYqSrVoOd+ZdYGtiQUniVM5ZPjsZ9Ykpk7LU3e3UljaI+WU1KLZqw07juGWeQGWpHtSKGGWu69eiKL0+oAlyqDRWqu9NHIpxr8DJeyq6qEKhUCgUCoV7JpdjHr8t+ss0La8FWDCeQQ1S/ZzGx80qQ0yZprL8xqt+gj949csB+KJnfwf/+FM+C4WsiyfOUGvFUR/ENK0BDHtTx97EkXImdVKxXRvNxGmMkplj8Ik5nu3aEYZEiEkaPZw5r6IuZUlxSuuKaKNJnL+g3aqtzDYpM0TNaVvhjGbZj6ZyJfV3VmtqnZk6S+Ws1PU5OWtZi6Jqpzef9bS69Wd+qTrtQqFw2xRhVKFQKBRuk8t1FcOxa3cYlf4Tp5l3QURB44L6zLxnCInaGqa1uaTT9u4kJXE/90E29lsfx4Sr40XlaqwPtFoxhMgti4Gc4WBMUALFdmO5atuNTuIMKBEbhcTSB87uDxLjqmRBO4yiq9pqtBYHgjMKoxUpZW5ZDKQkm+91pemHxLSSXum1QEppOVjYmzpqqzlsZZgwrccahTEKa+QgYqdx/NfX/hde/bLvB+ALnvl8/vnnfzGrLtDUBqcVPo6JUVZTGc20NuxNa+a9Zxi//1ltx2qJtVM4MXceqxXbE8f+UhzXCsVikOvRyHtzo9Mk5WOnBXDec3Vefl8ap7hlPkgfd4bl+LtlgsJo8FETEtx02FE7w7U7NRMnv5u105vqxttydBcKhcKHMq95zWt40YtexJve9KaL/v3jH/94vud7vodP+ZRPueKv/f73v5/XvOY1/M7v/A5/8id/wmq1uuR9H/nIR/KsZz2LZz3rWdR1sbgVCoXClcbHxC3znnPLAR9lva3GFKSYMhHwUQ4wKitVEJXV7E0cZxc9MRtWQ4AsCUEZqK3CWcMQRGCVcuJn/uML+ePfeQ1aG576rT/CP/jHj6UyCmc0jRWzxlogs6YyY1X5aKAYxhqLi9XGrTlZzdENkZQz1ih8TGhlsEbc4IsuishKNFdoxLWuak3uxXlujcI5zZl5z2oIVMZSWUXjZH7YbixmdGlPK8P2HaiHn1SGo07mpGasq1tX/zXGkFRmVkmKVUgZraAfMqsoicHz3nN6VpEy+JTYm8hrV2MNyeVUlABcvVUTx/rxwaRNNccQEznJ81RGc81Ww/6qZ3fiOHPU0cVEiJGYxN2elaRVaSBGMaxopXBZBGcTa+hjYlZbTk0cp2aVHPRYg7OKKl082apQKBQKhUKhcM/icszjF5KyJEutRVG3Z1peC7BClKaIRes56gK7E4tRiiFkFr3nD3/9F/nVl/8AAE9++r/nXzzlXwNSv9f6xKQ2dL28fkwZ1zisljMRkHMHq8W00MXIlpGK58aJeWDwid6IGGrVB+yYWmu14paxBeTsoudgNbC/8qx8HEVV8VZnZNPKiglEwbz1MktomVMAyFLVLTNYBmRNPYRMHp0hziqM0hy2nsZpDttxDa5kDmicuc067UKhcGmKMKpQKBQKlyQlcZECtGOV3rQyFxVFLUfnwJpNJGkUodFqiJyaOUI0bNWWLkS6IBGsf1/1ej4mVn2kD/E8ff/EGakE9AmtRAg1+ETI4qIVd60cKOix0k02pSPnFpl2SFy7UzN1hv3VwNllz9nFwJl5jw+RnUlNG2STWWlFDuIUNhp8EGFUzqBVRhlASd2epC8NtENEKRH87FaOSWXYagyDz5yNnpAyPiUWg3z+127XnNqqeP1//Q1+7EXPB+AL/s3X8i+f9tWkBJUz5JxZ9lLtsDNxXLNTY5VmWhnZQB838LcbS3XB95/HT08r+SyumtWyQd8FwjBu1g/i0N6aqDGKFjofNw7zkBI+sqlsXA0BH7NUMFhFN0SOes8wJIwVV3tTaWb1OIiETMyZq7drHnLVdDN0TSpzj65vLBQKhbuCGCNPf/rT+Zmf+ZnbvN+f/dmf8Wmf9ml867d+Ky984Quv2Ov/3u/9Hk960pMueph9Md7+9rfzDd/wDfzUT/0Uv/zLv8xHfdRHXbFrKRQKhfsCFxo98olquhBljX/UeTLiQl4MgUor5q3cT2lFY4zU4wWpRnej8On0Vs1w2LEzceyvPEOIY+oQbDeQkrzOL778JfzmL0gq7Rc857t51OM+ldpINRzAtTsN1miq0RSyZp1OtTZQDEEMFGuhj7rIoUvnpcIijBUYQ5D3mJIIneT5FF2UhNud2o5V6OCTHETgMmcXgYPlQOM0k9pCFrPLOqmptgafZM7bqq1c+x1Q9FitOGo9fkzaOmjFJLMzcZyaWOZ9IqaE1aB0wmnNdEvTh8iyiyyHyLJfMaksp2YVrY9M60TjJDnqcipKGH+2rvgLSQ6QQsps1eeLvLYnjoxUE16z3dD5yGHrN2K6bqyDt40cLK1TtXYmkl4coojaJpUkRSklaVNXbVWshkhM6ZLJVoVCoVAoFAqFew7rSuZlH9hpHEdIk8jaPF6N63o1zgVDkLOg9TbQ5ZqWp7Xh7LInjg/sU+TcStT0tdP8+X//TX7pR74DgMf/y3/Dx3/u07jxsN0IhXxITCo7CvhlXSxiI004ET1bjWm3bBKWoLKGSSVirm6I1FM5iBlC5JZ5kipBo9ibilHBmvWZjcwbKQ9k2LR5rLFGc+12I8KrVkwSfZCzJhSEJP9srAYUZmwFWfeLhwg+BBon53ApA/l8M0vOmRAzzqxnpiv0xRcKH+KUk8JCoVAoXJJ2rX4PsnGq1HH86Unmnd84X/sgC8n1wlNriDkRAiw7TW9kgXx6VtFUEpeact4slO8uFn3YRLXCmFQUIikdHyTEJBUDIWX6UeSlNJjxkCHljI+JSSWb+znLojqmzMHS46zipsOWEDIxZrpehFAhRkKSAWK7slItoSAk8EFcxD4mcTQbTc6yoJ82BmcMzejKmFaWIUXO7Q8AbFVaHBVaFvtHK4/PiXOrgf/9Z/8PP/SNX0POmSc95V/xtK97HmQYYqIySmoPFexOKk5NHZXR5Hx+pK04x2/9/fsg3/W6VttZzbS2m9+BdR1FFyLDUg45lFb40UESU6YZzCYWdt75TWWG1Yr9+cDBJkbWYA2ECGTFucWAUrDbOGZ1DSmzvxq4/+7k71V0VygUCn+fPOc5zzlPFDWdTvmyL/syPuZjPoZhGPif//N/8trXvhbvPSklXvSiF3Hq1Cme85znXJHXX61W54mitNZ89Ed/NJ/8yZ/Mh33Yh3Hq1Cn29/d5wxvewK//+q8zDPLfsbe85S1cf/31/Mmf/AmPfOQjr8i1FAqFwocylzJ6AJBhvxvovSQE7S96YsrM+0hIiao6Xq8TpbbbjjV6tTP4kEk5c3pabWY9nzLzNnG49AwxobWs9X/71T/Nq1/+QwA8+Znfwj+5/skYpahHkc5VWxVXbzfAredJPYp6+jF56rCV555WGnDn1catGU7MFz6mjTBqVluW40FBbWV22akN51YyS2w3lpSgjwlrFO0gz6OQNKmsYNHJ7LPVSHJUzpJ45YzmYOXPqwGE2xaldV5mnT6kY9OHM1RGk1Cb2kANLIZEm8T84bQcNPmQWAwRP76fg5Xn1LRCK3XZFSXrz7i2UuN+7XbDYScHWyknnBGTzPpw6cFXTTi3NPQ+sRgCSsHB0hNzRqMwVuG0HHTtTd34/iJdSJAliaqqNHuTitppTs8qtFaXlWxVKBQKhUKhULhtbmvtWVvNxF18PXhn2KotMWU6H9lpHJ2Rlo0wrm/Xe/4nsaNI/nJNy31IYloAApkUQTtZ677xT3+fV33vN5Fz5uP+xRfxqV/67+i9CIxGrRDOaJQKdCEzcZaQZC6wWuHj8YS0/kQuTFhqnKHz8p58SISUOFwEdmonphGfOOo8887T+0jrA0PMkLOcv3SBPiSMUlijNqb69dp6UhmqpNlu5Aq6EOhD3swrRsFOY4FxvZzFhO6MIpM5aofj73hMobVGWlqGkDbnMcV0UChcHuW0sFAoFAqX5KSgBWTz8sJF1rIPm43yRe83dXvraoZ1NVzvE1lllNK0PjDvNUNK7DRurK1Td5mI5cKB4aj19CFJVV6Sxeqtl/FgtOJw5Vn0Qd63gr6LGCOipNrWtKNzlnEhXjuNU1JvN4RIH2QhrrU4JQYfWQ2Zrcay3Ti01puN/JhEfLXePNdKMTUajaQp5S7Tm4jKFQbZRN9pHAlZuC97cSP70RWelQwKb/k//4uf/vZnEmPgYz/1s/n/Pfs70EoxbwMrHyQBKyasEWHVrJJu66Y24sQeRXHNRdzHF6tvqKxmWskg0vlIbTX1uqZj3Dh3RnEYRXS2GgLtEFDUpJQkOpbMQesJQQadaW2ojWZaOzRQWUVMcHbZkzIkBQftwM6pKe0gByRFFFUoFO6L/PZv/zYvfelLN7c/6qM+iv/6X/8rD37wg8+731/+5V/ymZ/5mXzgAx8A4LnPfS5PfOITecxjHnPFruVhD3sYX/3VX82//tf/mvvf//4Xvc973vMevviLv5g///M/B+Cmm27iK7/yK3n9619/xa6jUCgUPhS5PaNHO0T6GKXCLUTOrTwpizhnWlm2J5baGJklRnFRSJlFHxhSYrt2aKXICq7eqtAKnFGQEzHLjHXYBv7v//Nr/PwPiIv7Xzz1a3niF/5rqYUb6/Cu2al56OktQNKHL+YWn1RmTKnSohKK4KOkyF61Vd3q/inLHLLsIos+yCzm9OhWl4ObnYkTN7UzxAzLPuJDonaGPsrsdvV2zf5SqtETUv+9M3FsN5adidvMepXRbNUWZ9mkb02cuU1Rms+Js4ueo86zv+wJKbE1utnnvdSp55xZdoFIRmU5DFoOEacTWYmAK8ZEVDKzLvrAfPDMWy9CJG6/omTNhXUo67m+HqsTT875VmuOWo8zmnYI+CyzYiZRaQMqs9WI0CqmjDWGq2uH0YrKabbHJKr1973sw2UlWxUKhUKhUCgULs7tGSLiuKZf9oHaGqb1xdfdd5Tdiazxlr0kGDXOXNRgvhbtVCfE77dnWl5f76QynF0OhJConZyvvPOv/g8/+8Jnk2LgHz3hs7j+ac+jSxlHAtQobMo4q+m8pD5tTS2sg5du/REBt6511kpMEEMQc3lKmRASrZami4S8N4WInhprWA0DPiR8SCilmNV2rPLWzKrx/Y4JT/LamSFmQorEmGmc5tTEEbOc7WSlxueSGUspmYWIF3zTMUvDiYbOJzFbRDF23G+3uYPfbKFw36ScGBYKhULhkqRROp9G1f6Fi+kQ08alelIUtXYFnNxczTngjGKrcZtO5d4njvDsNG5ctOsrsmBfc7GB4WTl3+F4zQoR8+xOHdPKbtKgDleemEUQtOj8mK6k8THTeUmKmlWGmdP4lOlCIsaMsQo01EpqGJa9x3vG1zFMxsFk5QPpIoqsmDKKcbO/90ydJefMkY9MnSXVsOwTRofx/gkfRGQUs/yv7yOrkHj337yFn/muZ+H7jkf8k0/mc5/9Is4uJeFrq3FoLZ3VxmqmzmD1KO4ymtoa5r24qy9VGyE1FnnT231SQLU7qWiHyMFqTKOaVpvvxfaK0GSGSm8sGj5mDsdkqFUfN79/uxOpjpg4u6nes1oEdsYoeh9F4CamCrYbx8HKc3oWmFZlqVMoFO47pJT45m/+5s3t6XTKb/7mb95KFAXw0R/90fzKr/wKn/zJn0xKiZQS3/It38Jv/uZvftDXce211/Lyl7+cr/iKr8C5206EfMhDHsJ/+2//jY//+I/nb/7mbwD44z/+Y17/+tfzz/7ZP/ugr6VQKBQ+FDls/aaCuhvrLE5WRYQozmaAs8uBnEQ4tdVYfJCNfWe0CJGQpKFUiRu8HaRGfI5nexS77E4dMWcqo3HaoHVL7yNve8Mf8os/IFXdn/5FT+ML/s2zsUaz6iNWK67babhmu+aoHXDjPNGHAa2gMiLo0VquZVoZbln0zJzFKHl8N9Z1pMR5VR0iDJL3nbLU521VlsPWSwpTlvey6gM+SjKS1SL4CWOFhlGKZUikLIm3tdVMK801O7XMG0aRBjmYcFaz6ANKy+HJLfMekMMeuHj6cB8SizEJN0QRQ23VlsoYQkrsrzwhJXkMmabWxATdkGlH53zOCWPEPX62Hais5qb9DpUUp7fqy64ogTtWh2K0IiHz5VWzmpikdp18bDhqB0n1WouqrFY0ldR9ADROXu+OJFsVCoVCoVAoFG7N5TRfnBQmdSHShXjF2hTWlczrc5bK6vMEUCdRcJvCrJMG9oPVQOcj+0v5p9UacuC9/+9becULnokfej7iEz6Fz/maFxGUQkVAK2aNnJUcLj2Lzo9JsYpV58kZmokI+J05Xm+uE2fXcbQnl6KV1Ry2nhglBWo+BEDM/taocV1rOFjJn1sfGELksItoDSsf2aktS6VY9ZFmXFOr8TtRShFTYn/psVaxZSy7k4pFF6ispu0jO1NLiIlhHOlOhg4cN5dIhbgEFUTy2ESyTqktFAq3TzktLBQKhcIluTBa9EJhzHqDsw9xI4rabtytFsYno0q1UkycZasxHLWB3ic6E2lGx+3u9I4Joy4VH9sOkRDTZrN9CIlF79lfSvzoaogMKdEYw/bE0jhDTCJKamojVXZasTd13LLo8SlLFCqwM3EoRNF/sj86pMTRynO0Xpxm2VQOMWOMbA6jFTrLwjZG+WyMAaukji+mhDfymEUXSTlhVGTaWHwfyFYe46y4EcTVLd9DZTVb1rL0AQOcef+7+dlv/2r61ZyHPfpjeeq3/jCVrSBJCpQzilMTx2Ss0VgNMmDtTaqN+zdfQhQHMlC04+9AM25yV+Z8AdXetBpTp9Im1vea7QnLPmy+l63acbjy3HTU4ZS4L1SWzfXrduvzahanlWXizKaK4tS0ks8hynDRDpF5O7A9qTg7H5heVZY6hULhvsPv//7v81d/9Veb21/3dV/Hwx/+8Eve//GPfzxPecpTePWrXw3Ab/3Wb/H2t7/9g66xe/zjH8/jH//4y77/9vY23/Ed38GXfumXbn72W7/1W0UYVSgUPmT5YCowFuOsAXDUnUzsZWM0WXRBDBpd2CSwmjHByRhNHyJHreea7ePUnnVVt9VKqhl8ojdRRCwoHnxqyi2LgT5Ertmueesb38BPf/ezSSnyaZ/zhXztN7+Ifqwev3arwicxRBwsPbtTtzE5iKMdfBTBTDUmFlmjiOPgefVWvfmcFOpWVR1DTJtZy6GxWnHYDqz6KEIdrYgp46yiCxmtNDFFloN8XjsTS2ZMum3E1OO0HDp0g9RSZNR46GPQSgwh27Xl/fsrYhJH/to0E3MeE7X0RvQz7wIHy4FlH/BZPsfOJxEOKTZz1mScQ0NOGK2pXUJ5AzpjjaXzkcOVp+08i9pKHf0QeKCbsDXOSbdXUbLmjtShVMbQuIwP8NCrZnRe0o1XPkjtYAaroXKaqbUbkR1IUtSkMueZki432apQKBQKhUKhcMztGSI2jGlCVismzsiasQ+knM/bW7+zOKPZnWpSsndqjrnQwJ6SpDyt/yxmBzjz3nfx8m95Bt1qwYd/zCfyFS/4EZJ1qFEYpJRi4jQ5K/oqjYIhSVk1RqFR5NE8vj6jWqfmAjTGbN7PmnXrhVWKg3bAh4xqFLXTVEaPa39p7PAxY9BjepRi5ROrzjPvAtPKYJWYSqQKD/aXXg6UlJgOKmu5auKY1JbTWxVhTIVqh0DO8rldLHQAoLbQ6cBqkNtKSVjBVTNpNZlcIp23UCgcU04LC4VCoXBJlEKiR8c12DrBZ/3ndYVad8IBejG3wMWiSmtrmFZZHKqDCKP6EEnJXpZ71MfEogsctsO4ED/ub14NksRUO83+aiAmcQh0XhavfUgbEVClNX7sga6dEUfyuKgHNn9nlCJkqZfwUaoHzi4GJpU+z5mxM3FsNZYz84GlF6fBkGST2RrNQes3FQNbEzu6cuX9ppRZDZkag1EJPYHFIJ9fiEliXWOkT5EtK93Te1NHZTRdSAwhsvKRWWW5Zf8Gfvz5X8ni4CwPfuRH8ozv/klMNcUZzampY28m6U3OaHxM7E4qTs0cTmvCuFleWX0sijsRQJvysZsc5HNeO4On1fmb3EqBHd3gu1PHEOR97Ewc1ihuPOxwUaPJLHpxUByuBppasds4dhonz6FlsFKK4/pC5DCjMvK/2miO+sD+yrM9qZj3UsVnL+FgKRQKhQ81Xve61513++lPf/rtPuYZz3jGRhgF8Gu/9ms897nPveLXdns88YlPPO/2O97xjrv9GgqFQuGu5oOtwFj/HZwviloLUbRSm7Tf2ho6Hdlq7Gi68JxbHDvNV32gsortpjpv072yhkklBxXdIIIeMTNYrtuR6uv//X/+D//hOV/J0Pf8syc+iR/+8ZdTOYtWklC1TiJKWQ45Fr24qhXq2D1tDM5qWh/ZH3f3t2tHdBkzzoOnpo6UuZUjvqkMBjmseN+5lnlINJWmGT+DlY8w3j/GRBezuNx9IOTEzfOOnOQAp6k0dj1j9ImVj0ycwSjNtLZMRzGPVfDuc0u6IXFq5hjbO5jVFqUkPXddH6gBrTIZxRAzbRdRGrZqtzmgmjWWymhp+0jQhcDgpQ5kp1EwVmo4rTEKhiimFWcU2418LnD7FSUXckfqUHYnk43p6GA1kIHrdpvz0qJjhJ5EJlNbQ+Pk8OjcaEgC7lCyVaFQKBQKhUJBuBxDxHGakJw/hJSZj9XYO42jHSJaqSuSHAWyRpzVlll96ftcaAJZ9GG8juNWisOVlzVlSMzH93njB97LT73g6ayODnjghz+ar/zOH+eq3S16H2FMY0pZ5pxZbaitYn/p2R+k6UNFabAYEsQoa3KQJNecwY6psOtUqzXrs61uNG7knGmcGLqNEiMEyLWfWw0YK8+zvwiEJNdkkgbEhDLEhNVi7PYxMsRECJlZYzg1rXBWvrNTs5rD1jNvA6tB1uZXb9UbM8F5n+mJ85iJk9mPLI0s66O0OxM6UCjc1yjCqEKhUChcEq0UkSxCpSgL7PXCbJ2IFKIsuJVSF120wXFUqbogqnRSmY3LYQhJokN93FQSXIr91cAt837jFPYh0cVITiK06n0ErUhx7brVGK0hw/bEklov3c9aIlEldUkGhu3ayXOExMQZOh9Z9gFnpWriqB1o+8ikNuScGaIZXQ2j+H98f1KNkFn1gUUfsAYGnyHLBr4xipQghIy1CqsUPiZqozcRW9aIQ7kdAvM2YI0iZ0WKsmG9rpW7/96UZe85s+jxIXHTmTO88N9+KTd/4H088MMezve8/BfZ2jtNO0ilRjsktPHsTByTyrA3qWicYWfqNkNW52UQ6HxAoWSjnIwPefzcxwMXp9mqZZN7WpnzErTgOG1s7RyZ1ZbToygLak7Pauat5/37LeeWnoN2kOvTUG1pjFbUVgRRnU/4dPzaJ3u7RZTnWAyBIYrwbVpZzq0Grt0pHduFQuG+wW//9m9v/vyIRzyCRzziEbf7mE/+5E+maRq6rgMkqenvQxi1tbV13u3lcnm3X0OhUCjclVyJCoxVf+wWXx+M7Ezs+Rv7XkRX7RA4bAMhJbYby1bjWAzy//XrOeKmw7WJREwI67V8M85BIYkzel3RkIH3vfsdfPNXfSmr5YLHfdI/4+d/8ZdomoacxbFcW41Riqkz7Lee1RBofZTUW3Ncnb4gkMfrWKcNVUZz/72JGFGQA4d1stNJKqtZ9pHlIO+vdlpMJqO5o8rH9zdGo2Jk3nsRHilFH2GI8lnGbOhC2gjKhiDJw0bCfjlcAmP132KQary/u8VTVZrGSFrVtDZkMhq9+QxDAmulbuOwlc9xqxZTy8oHcfOfMJXMMMQkTv+QM+TMpHGoaWbVW466gdpY4ngwo4C9iaO+xAx+W9zROpTtbcdDTk85txw46jy7k4rOyO9nzhkz1hRmoPXHqVPr97jeJ7jcZKtCoVAoFAqF+zqXY4g4SeMMsyzmhtU4Kxzh2WncaLrQd7k4/WImkJPXvhrNzjFD5wNGK7qQUMDhLWf48W/8Co7O3sw1D34ET/uun6SezrBGM3GWkNNmRspkET4pJSlR0qVNyJCyzBGr3nPYWjEpDDKL7E4cKedNwwiIiGvZj9fXy7lSZTVGaaROT2acNJrlF51nCFIxXjmF78X4YQyYsf4up7Hxw0BWUkUerBgeILPdVDROMwQ5izpq/eYzXA1SBV5ZsalnZG704zkYSGKrnGGF8XOXv7gjoQOFwn2VMo0WCoVC4ZLUVtKEGmvovbgOZuPm9Vrs1IXj5J4LF+TAxrEAx1Gl1bgI10pRGU0/HgpUVv58W46DDxy0nFuKo7j3kXnnWXnZyA5JUqS0khqGlDNGKbYbOSwIKbMcPHEUcp2aOtyYitT7xOATczxWiwOBLA4LnxI7lQimupBFDJYTVmuslmEkZ1n8z7tAF+S6+pAIIbK/GKiMYtEFfM7EKM6EyopACuQQpHKymbzq4uZz0g6WncfHhFIaZxVh3HxWSjaaQ5LErGlled/+Wb7v2U/jA+9+O1ddd39+9Gdfw4c99MEb98hR6zlqvXwuE6k9vHq7ZjHIQc26UmHdVe1TxoeITyIUE4dDAiWb/CYqjtqB7VFkdSHr3xO9EcWd/zuyrnNIZK7dafAx4RsRXE0q+bv1In+NVYq6Mpvfo8YZphuBlGXZhzG+1jLvA9de+tepUCgUPmQ4ODjgPe95z+b2Yx/72Mt6XFVVfOzHfix/+qd/CsCb3vSmu+T6bo93vetd592+3/3u9/dyHYVCoXBXcCUqMLYqSz/OXu34XNPKnCeKAjYmgTOLfrOpnjNS9wbMuzBWVUiyz1ZtyE7W7ZNK1tVaKUmrHQ0ozmoWfeDGD7yPr/qSz2f/3Fk++h//E375Na/jQVfvAiL8SjkzrSwfOGg5akUkpbWVSjwl1RZpTMU6ubk/QdzR1miWfeDqbanTvlTl4Pboft+ZOHZax37raYeAMxqjZc5yRm9er7KaW+aJSGKImQQ4Y2h9QIXErnOsglTo6aCYTSwpgU+JmCTB6nDl6ULgaBVIZLYnjmu3m7GCHGKSedJqMQwpwPskr681/Zh4bI1iWlt2Gkdlzfg5ZKk7NGIKWSdmiVAqslKRyfhzZzVbtWV74ggpcxuj821yZ+pQ7r83YbuXwzVm4+/b7Qj81tzRZKtCoVAoFAqF+zKXY4i4kLUp2RrFURvE/GykqeOuThO6mAnk3HJg2ctZzMHK0/mANXKe0gcRRmkUuZ3zkuc+jbM3vJdT1z2IL/mOn6TZ2sMazbyXsxqVFdbK/YcY2e8TMSdCSlRWMQQxvy+7yN6piiFmjtpAN7ZXOKMJ49mI05oQpd2j9XL20w6RRRcISDrsLcuelDIHVqMQ8VUfE1orQo4cth6rNNdtO0JM7K88yyFQ2eOK8NoZHGIg0EpETo01zGrLtDIcLD0hy9mbGdfeKctntz5TOYnViubE/Lc3dfiY73DoQKFwX6b821EoFAqFSzJxshFfWXHChrH7eVbbTXT/2lnrzMWV6OtkKTtu4io4L1lqLYZaP8/Jur4LOSmKumXRsegiISWUGnuhkyj++zHlKaREbYxEjYae7dqSM2gNO42TDexBHq9UJkQYfKIdBVXnlsOmUq71snkf0nrBbZlUhpgSfQRSZtnLZnpMmb5PLH3gsJNFcW0MPie00sd1Ej4zqy2TWm/q/5yVzXuFwhhYdrKAz+PmNEptSu2kYk4x72ToaNuWH/qmZ/Cuv34TO3unefErfom9ax8gfd3jJrUz4yIbCDHTkTgz77lut5HPbEwFu3Zboly1gnNxYNEFUsporWkqSdsC2ayvKoNCPq/K6E1y1Mm6xWZcsNcXcSLvTsQ53RIljrcx8rPRYbGuSFRanseccD2sD2/WzGqzeR/r6ysUCoX7Am9729vOu/3IRz7ysh/7iEc8YiOM2t/f58Ybb7zbhUm/+qu/et7txz3ucXfr6xcKhcJdxZWqwOiGuHEMS2IvFzUmSEKsVMkNIRFz3mysN5XhoPOgRMizHBLv3V9x7U7DVm03c8OslsrvISTiKLS66aab+Lov+3xuuuH9fPhH/EN+4bW/znVX7wG3drQ7ozfXdspJVV+IIqDJ6XjmG6IYPKxWDDFtNvkn47x4qaoOHxP7y4E0HoaEKIcHjTVs1e6CJGMx48RpwmjFmXnPMNbWTWpDYzV9iGJEGROF7VgHbpUiqczgE2dXvZhYhkBSjDNIJufMVmPx4zWs04i7GIHMqo8cdJ4Y5cClMoa9qaO1kVljadxtb81qBX2wTKzMzo2TQx3gdk1Fl+JSgjOtJN34pBjqQu5o2tTFKiELhUKhUCgUCpcmpXxZhohLUVvDtJJmjXYQYdRdmSZ0MRNI5yPnlgOtjxy1fnNGUGcwlSQnKaW5+ewB3/t1X8773/X/cuqa63jm9/40evdatJamktqI2V2qr+U5QoCQxVww+CSVdSmTciIhoqRuiOznHqsNW41hZ1oRoqzbY84ctp5JZcbZKXDzomUYoHaKPkBMga3xLMkaNaZbRVJW5JixY921MYrGOZpKc9CG0VzuxlnN0ljFtBJB2zpgwIyhA9UYSgCw1Ti2anteM8p6jX6yhnzNtBKB1VHr71DoQKFwX6cIowqFQqFwSfRYY9YF6S6e94HVEMdKN9mMXeuYLpYWNQRZfINswsOYLHViAb5+2Pp5LqWL2l8NG1HUTUcd804iRifOsD1xOKM4aj0pwX6SbmWJ85chYAiR1eAxSqJQtQLUSaGNuA2IMnzIwnLAGE1OGZ8SyyHSGI0fN/YXoyBpS1m6cWMZRFzVJdko7oaIUQpIVFpqBIxRIp7Kkdgl2mDQSjaOV2NyqgKGFlZ9QCnF1FmMgpQSdSXugcZqhiAf2Kob+A/f+Ez++i/eQDPd4pt+5Ge59sEPpx0CRrvxw5V/pKzwMYojA8Ut835TUdGHKMKtVioAQxanhfR3S792HyJdzjitaSoRQK1dFn2Qw5zp+H2vRXHr+NfJJaoe1ocXZ+YdgxKH8cUOeta/MxfWfazRHAu24Fi4VygUCh/qvPOd7zzv9kMe8pDLfuyF933nO995twqjFosFL3vZyza3q6ricz/3c++21y8UCoW7iitZgbG/GpjVdrOhXl8ksXfZB7pBXmM5HkrMlEVZSYCajZv7R51HjTNN78XNvegDu43bVDUYzSatSvkj/v2/+WLe/c6386CHPIRXv+43ecgD7rcRu6x6mSEOlgPnVn4jFjJKbQ51qlG0dCFDiCz6iMqKiZNrXHTh2EBzkRSjYZw3jlq/SbfaHg85xKl9sTTjda2bZtFDVpIEtQqB4KGpJEErJ6k8H3LCBxnOVj4AmWHIYw2hHIKkDEdt4H67irp2pCrTjanGyzZw1IlD3kd5H8NYFRLHlKZbjnq2GidJvBc5pEpZDsVCzkydZlqLm9yO7+22TEUX42L1JhsyxDHNS+pWLi1oujNpU4VCoVAoFAqFy6P1l2eIuC0mldmk1N6VaUKXMoGcWx2LpcRQr8lK9uqPWi9zRlzyo897Bu9821+ytXuKZ/6Hn+baBz6ELgRWXaIbEjsTSaR1VlFlmQ+2aktE1p+LLrAc4mgq14SQObvoOb1VQ1ZUTpGAw9WAdxaNXIMzmoOV58y8w4fEsos4a6idZgjSJNL5gEKhlBrX82JaGKJUee9UUtUXxkXw7sRhleK63ZraGvamFSDr48poTs0cR10gpDwa0CVGanfisEbM8M7q8wRQJ1k3kEyq4zX6HQkdKBQKRRhVKBQKhdthWoswqqkMQ5KN86M20IeIM3ojbDq56EpZNoTXoqjK6WP37wWL+PXD1s9zEX0VPiZumfcAnJ0fi6Ku2arZnji0UrQ+YLUmkgkJKmeojGLZR4YQ2G89ldGkHEc3tKGy4updV7PVVnPUebohjtURGZsTCtnQNwqM1hx2AzllZo3CKOmaNloxq6xsmo/CncYatA6Q5HbKMKs1GY2zUt/X9nFTI2GMoh8S2sjmvtUKsmJWyabyueXAVmPZqSvyGMc6xERKiR98wXP433/033FVxdd//yt56D94jCRCjQcR601qtCyyQ8oMnSex7uOWw4qQMrsTx6S2nFn0HHZ+dBQnFr1nUmm2asfuxOHMcQ3huvJjHed6sBrwcUzEqtZpUZfeGNdaYY1mq3FoHaiswo2HDevEKK1kOKjtrQ+RNr974xb/+mChbMQXCoX7CkdHR+fdPn369GU/9tSpU+fdns/nV+SaLpd//+//PTfccMPm9jOf+cwrLsy6+eabOXPmzB16zNvf/vYreg2FQuG+x5WswEgZ2iFu5q4LBSs+JlZDRCkRNPnRtFFbzVZjN+vnU9OKkDI5wWTqaIfRbR0SB61nWhlJvLWaISZi3/Gir/1X/O1b/4qrr7mWX/613+YRD/uwTS1a7yNn5h19TBwsB0LKTCqD1evaa7sRBYGYO7RWm/X9rK7YmWQ6n1h5eZ8+Jk7NqvPX/KNwp/eR/dWAM5qYpBrj9KzCh8i5lWfeibGkNgZnFQpFZkz3jYmUpJJ8q7JiHMkKayAjM0dVaZICg6ZyihAS/ZA2deZGa1Y+cMtRL8Iqa/i7s0sesDeldvKec4Z1zG+MmZgy7RAYQt5U1Rstf7d2z1dWMXEWNQq9Kqs2phONGHoqo7HmOKHpjpx7XKze5LYq8LoQ6UK8zQq8SyV6FQqFQqFQKBTuPGvz9W0ZIm4PrSQ19a5ME7qUCcSniFZyLnDLoqfzCWukKnw9FwyD5xXf9bX89V+8gXoy42nf9ZNc9aCH0/rIdu1oTOJgFZj3Iu4yXnP1dsXMGnzMEDRDCCIWMgonC3oGL6KniT02VXdR+jk6n7jJd2gt5w7GaA5bT86M50WZeRewKrE9scjXkIHMqgsE8mbGmuEYTGZSaUmV7SM+JZTV+JiZOHkNSXw9PsuoTNp8J9PK0sfErLYijtKKzsdNqu6x6UCEVc1FTAeXGzpQKBSEIowqFAqFwm2ydhYv+8BO4zhCFrmdT+OGeyaRWY2L4LXDeL0Iq5xme3QGT6tbO07XG+TrRd3FFvmLTirq+hA3tXFXb9Xsjqp7YLMoPWgHfEpU4+tI+5xiffRgUSg1um+HiE+ZDKjWU1st4qSQOLPoANnoT1mcANuNHVX9CYsWF2xlMMrgjLyXnEX8NRsdzOdWw0ZQNm0MoJk6SyZjK4uzYdNhbaImxIxOMHOSxhStxLWmnGgqw1WzCqM1mbSppHjpi7+NP/it16CN4Tn/4Sd4xGM+nnnnCVkW3d6uV8ZAEifFUetpKqlxOHPUM+8CV80cRmlWvccnETzlJDGxK++ptYHx84spM6kUjZNhZO1gOWo94DffY1PpTRrUtL70AdBayLSuEsnAzqS65P0vxXI8fFonSV3MeV0oFAofiiwWi/NuN01z2Y+dTCa3+Vx3Ja961at4xStesbn9kIc8hBe96EVX/HVe9rKX8V3f9V1X/HkLhULhUlzpCgwRL+VNrfaFc9PalDKMlW5oxVTLfHPhfaeVkblDKbYby7SyHKx6hpDJZJyWug2dM9/3/H/LX/6fN7C9s8sv/epv8JiP+ocbocyiD5w56lh5mWfOLHr6mNgaq7a1lhSsneb8ervGmfPc6iln9pcrVkMcHdNa0qC0upVwJ6VMyjIjtj7hrEIrOfgYUqbtI72PksAbj99zGOc+DUysIQO3zDuc02gUMSusVujxPjknBi+HExmpy+h8YkgJsiKkxFHruXqmOew8s3bALzM5ZWonJhcfpFZPqhIh5kzfJbTqGWLCKM3ezI0O/kxMgUllCCkx7+W79zGyUzvqSuozanNcLX6552MXqzcJF0vWjXljeJk4Q1OZTWrYTnPrtK9CoVAoFAqFwpVnbYRYpwDd2UriuzpN6GImEKsVrc8oFIetpNIqoHYivndGQ8r8xHd+PW/+sz/AVjVf8M0vYfch/5Dl4NFac9RGJpXCOUWIMgukCIfLAWcM1siaPSfYmToqp6X1Y3x/U2tBwVGfuHrLck3jxNwdI4s+cNSGTduIzBKKbkgsB0no3Z1ZJpXMKmlsEuljZAgy36mxHcMnje8StdUbg8TuRGar3anbJEZd7DvZtLFw/N1orZnWlukd+A4uJ3SgUCgcc48XRl1//fV322sppfj93//9u+31CoVC4d7CVm2JSVKgdhpHZyI+JI66BAqWXWDVy2bzetP9ZHoQQDPWIpwk5WOHbGPXqULnL/RTks7nDBy1npDFgbwzcRc8l4h12nFBHpKIlJzROK2AzKITIVToAs5oppXUAwyjE3flIyqMDuuY2Jk4fEj4JGKnGDPdMNbnTaQWT6PwSd5DHxKDj2itcUbRhYQziqXPpJhosoiplILaaYyGJjuMkkU+yJCQMlI9YWQzXSuYVg6rErPxfTsjHdSv+vEf4nX/5T8B8NUv+EE+6nGfylHrscjrVFZcvBpFQoRLXYhEZJN+MXi8T1TJEGJiWjliTpvPddEFhhilJi9lrI8EJyliYZXZbjJbtcVozbwNzHtxWVTWcGoUWoWY2J1WtznEbdeWdohsN1aqJ/pRgKYvf/ALKdGO3892YzfPWygU7jmUtf1dR9d1592uqssXl9b1+ZbBtm2vyDXdHn/0R3/EM57xjM1t5xy/9Eu/xM7Ozt3y+oVC4b6LJKLetRVgV7oCY1234EPCWn1+Ym86TmRaL+X3aofPaVPjdqE4SoQvYsyorCS3dj5ilWJWGw5XkZd8+9fzhj/6HzTNhJ979a/yzx738Zs1/WHrWXSes8ueg5X8s/NpnFPEWU2Ezif2lwMKSci1WhPHWvDtZkzPUoyPkZoLa/SmjuI8YuaoHcgZcWSjmFaWnEYjSy2zVRw/b6v0Jn22thqlpRLekzlz2JOAELLMPxmu2q5Reny8VsSYmPeBeetlHkzytlCwGAIZmXu1Vtx42LI1iocOWg9krFVYo3BZszetODPv6UPgqBUnu7WZg5WYORqrWQKtlwOjdoj0MeG0xkzF8a+VzNW3ZSq6kEvVmygls/famJKypFn14+/rvA8MKbHTONohopW6ZHJUoXBPocwahUKhUPhQ4ML0nzuaFrXmzqYJXc6sBNzKBFIZxRAlVWkxBBbjOc1WY9mbSBpszpkf+e5v5vW/+2toY/nKb38Jpz7iY+mGxKKXteesUnQhY5VG24xG4SwYo9mdOBTSGjFrLEetxyhZJ2ekYUMhZu48GiP2VzI/KCT9da/RDDniQ2bwmSElYkxUVurOt2pZ96/PSNbV3VpnhhDphsiRUmQUO41US4fx8TFnmTdCuvBjPe87WcfLrr9bH9N5RpLL5XJCBwqFwjH3+In2D//wD1F3w7/I642SQqFQKFyc3YnDaMWyDzTOcL+9Bg4l0nUIkRhls75pDI0x53UhTytz0f5qcT7LZnJlNQo2C+vNfXykD7K4XI3O3+0TVRBrcpb6BTl8EHGS1YqpMxijmHeBbkhoAymImEv+3oouP2dWPqHH6rbeJ1ZaHLrWGGa1ofMirKqNPnYNAD5G2iFx0MqG/8xqWQQjyUUzZ1gkSWnabhynaoPVhkimNopqJocHMWZQGbKijwGXNTlLxVyI4t5OMREUzGzFL//sK/mZH/sBAL78Od/JJ3z659J2MnA0tWarttRGb9KzWp/GTXfDaggsxpoJo0VU1uUogrMITWXofaZxUk9YGcWksQwxSRpVskwrOLccWA2RiRPn8tRZeh8lKnZ83Qy3u4l+elpxy6JnWlkqI7UdhyvPVVuXn+97uPKkLNGy08qilTxvoVC451DW9ncdFyZEDcNw2Y/t+/682xcmSN0VvPGNb+TJT37y5jqVUvz0T/80j3vc4+7y1y4UCvddfEysepkvbnUuMFa1rSshaismijvr0L7SFRhDSjTjDGE5f/O8G0VYPiS0lsdNG8Oyy4Sc6UPazFl+NKYoLSKlxq0FSppbFr0chPSBV3zvC/iD334dzjl+6r/8Ip/z6Z+62XBf9IGzi57VEDm7HETEM0SpyWgUMedRoLROGo4MMW7mglPTikVMY2qRHz8rOYCZWnFYWyMioAuFO4etpDUtu4DSUhNorCL1iWSUiHt8IpNprJHnsJotY+l9QiuIMTEkSeE66gOVNcycYVoZrNK4SoGCs34YZzp53kUX6WNg6iyVFoNNO0S6WsRT1+1BzmLKATGzXL1dc9QG5n1g4jRDMPgxbUqhJIHYKlql0QZuPso4p7BKM601O2N1fEyZaW2xY2X7+nfqtrhUvcm0kkOfC38fG2eY5Uw7RFaj8/8Iz07jxn8n9J3+96FQuDsos0ahUCgUPhRQ43Jy/Z+aO5v0dEfThO7IrBSSCIBSZmMCWT+mGxI+SIX1rDJsN26z7vxPP/xifv0XfwalFM/8th/iYR/7BM6tegyJoZdEplNTx1Zt6cJ6XQ/Oakl21YrGafZXAzFKmu41OzWzytCGKLXZMK6fE84YotEMMRIjoMBZiIMm68QqiEEiZ82sMuQEXZCmDsWYKmUktTakTKwzWUViSiw6jyKPbStxFF9Vm8/rtr6T9Tq+2YjMErOLmFlui8sJHSgUCudzjxdGAZtIucvh5FByscfd3t8XCoVC4dJs1bJhvl4gb9UWNwpvFmPFXT2KohQSDTq5SH0eiKNgNXYbrJ3Ttb21M1ucCeOBQhJn7cXqJzJr1zD4kKlcprZyLashYrQ4C7ohbRbuRmuq9XMphVGwHAIhZAKJBCyHiDOwNUhkqgImlcVqhVKK3ksVwbq6QgH9ID3RPiZyylizdvgq9leDiLUaxcxZea1xSOhihLEW4rCVLmtnDSpkhpTZquzmAOT3f+NX+Mnv/TYAPvNpX8dHPvEpfOBcSx8ik8rQGEXvzeYAZJ34lXJmOUgdgjOKkGDwCR8zlRFHemUU243DmojRbERtIWW2rKUPCaPk9sRqQkgop3FjTYZP4wHBEDk1raiM3jjcL4W1Url42Hn2Jo6bFz37q4F6dK/fHovOs7+Sw/VTU7n/du2wZRgoFO5xlLX9XcPW1tZ5ty9MkLotLkyIuvC5rjR/9Vd/xWd8xmdwdHS0+dnLXvYyvvzLv/wue81nPetZPOUpT7lDj3n729/O533e5901F1QoFO52Fn3YiERA3LVdiLeqamus1Dx0IdKFyKy2dyop50pXYFh1XD0N52+erzfEuyjJPrNKjCS1M4RBEoOsVhitNsKo9ab5ek6Z1ZacYdF7/tOPfC+/+yuvQinFS1/+U3zWv/jMzVrex8SNhy2dT8x7z7z1dOt5wsmsZpRU0B11InpS4+fQ9on9xcDNRx17Y2127cTQsfSRo9YzdXFTPbF9wRzQOEPnE6tBhEg+RI7agYlzLIaE04qrt2oOVp5lH2mDXINCoY0kQPkYOVh6Vn2gGyLKaKYG9maOWW2ZOKkZXPkAUT6nlBSdT3RB6vvIkb2pZd6l8X3J5z5vA4mM05qrZhWMFeRTp1n0kqpb20T2mZjFfKKU1Lf3KlJHs0ms2p4cm3HWqcO3Zyq6kIvVm+xM7G3WOa5/F6xRHLWB3ic6E2mcYdVHdqdlvircsymzRqFQKBTu7WiliIx76THfZWlCJ5OhpMEhjslQ8vdruf/FZqV558XonaUe2mm1SYBdJ0g1Tgzf69f9hVe+lJ9/xY8C8NXf/GIe9+mfww1HHY0zxKSpDLQhsOgDE2fIGWona+OcM13ILDsva/CopALcSFvFYhhfe0goEkYZtifSOuKM3rRpSEJqRClP75UY9wGtM4shsNVYfJAmkeqEsaUKkhg1qaTlow+ZEBPLLpGyJ4/PnRCxlrvEmcT6O5nUMnPURpNHcVk7xIuGC1yKywkdKBQK53OPF0Y99alPvd37rFYrXvva15LHiDqAvb09Hv3oR3PNNdcwm81YLpecOXOGN7/5zRwcHAAy3Git+YIv+IK7xRVdKBQKHwo4o9mdalKyVFZz01GH0VK1N4RE5wO1lY1se5HN/3TCgQqyEb5e2E/rWy/c1nGt6wOLyo4L2SQOAqmGgFsWA6s+sOxk418rSWLqvNzHWU2MIm6ySqoZ1uKgyhgyGaMVR10gkGUzfIhAJqTEjfOWakyKasbOaB/SZjG7dgtXVqFU3gwAs9pybuWpnSZGiCmx9LJoNUpTaY3SMM2GW871tF7StzKMtRbQBtnkF5d05g1/8N/4ie/+RgAe9+Qv57H/8ul0fSSTsUaj0HQx0y8H6cGeHEe3rvpI6wOrPjKtLCknfM6EIbO9YwkhoZVh3npWPmK1Zm9qGUImJnF+W6XoY6Z2isoZKiMu7O1aDi5slu+ncSKKy8hAdHsL+6u2Kw47z860oh0HshuPOk6FJK7xi9TqhSTJUmtR1Hbj2B4PWa7aLmlRhcI9jbK2v+u4sH5uf3//sh+7/gzXbG9vX4lLuih//dd/zROf+ETOnj27+dmP/MiP8MxnPvMue02Aa6+9lmuvvfYufY1CoXDP5bD1mzqxboiberpbESU51mo1Vs0Zlr2YCnYuQ6x/kitdgVGNqbQ+JsJ4QLLePD9sB8xY/Qaw1YiAqLKaIWmpsxhFYSmLIWJt9KjH2SZlmXt+/j/9OK9+5UsA+Pbv/Y983hc85bw57cyRVOb1PrK/FFFU44wcoChJQApJPseUIITEakj0MUCSA4lhNJBERDjkjFyj0QozVZxb9kyc4eqLpMcaLfV5W43lxqMOHxN7U6nma4dAQg42INMNURJlrdoYaG6aD6x8oPOJoy6yM1XsTiomzo4JU4YDL4KuDLRDYPAiRLNW4ZIavxOpEgkp0YdM42A1BJzV1EaqASurxKSjFKcmjoOlxxrFtrWSUtUYnNJ0XubKyii2p47GGaajKUYrec9aycHNVbNRUHYRU9FJ1vMyHB9OTU9U3d8WKUmasY+RZR+Zt569mdSfaCUz7gdbNVko3BWUWaNQKBQKHwrUVosYyhp6n654mtCFyVDzTtb0KUlt9bwPhFHk5MbqvPU6cj0rdT5ijWbZBYzW2MZuEmxTzpva5pjlWn7jl36OV/zQdwPwr7/uW7j+87+U1RCZOoNValMdftR5DlaeEKXJQivNpDZMnWFQkS5KcqxRCmMUoNCjOGjlZcaYNiJq2pnIeYLTCmNEODStLCEmams4O++5cS5nMc5o+vH8QmslddknPm9rFcFLBblPidqJyX41BHwrZpPaGPoh4bb1RdO5Tn4nU2fpiJvXmfeB1RCxRl3Wev1yQwcKhcL53OOFUf/5P//n2/z7v/7rv+YLv/ALSSmhteZpT3saX/VVX8UnfuInXvIx/+t//S9e/vKX86pXvYqUEm95y1t4zWtew0d8xEdc6csvFAqFD1m0Vhvx07IPnJ5Vm3j+DBy0nspoUauP7tYhJNkEX0eGOr05YJiN6VMXsnYkrP+ZcuaoG1Co8xJJUxLXbcyZPibyEFh0mpBkI7kbIih5zKwx1E7SlHzMaCWHBlL5Z1j1x3GrIWWszhwsA1tTcYubcfG/Ef30UqUXc8JHETqtax/S+L5jzEST8RFCiPjR2a2UCKQOu0A7SNyr0ZohRRFnjQcY2RomteKv/+INvPK7nk2KkUc94XN43Jd+PeeW4ugwCrYnlpQzCUlvCjlzdjkQYmbiDLfMO1Y+YpSW4SFIxV7O0PnM4AOTmDBKbb6nIcjBgtEiitqd1sy7gELeW2MNKeWxpk+Ebo0z9KMLf+1yn91OK960slyzXXNm3nPdjlRCzcckqMN2YFJZZrXZODyWfZTDj/E6txu3edw12zXT6h6/zCkU7nOUtf1dx8Me9rDzbr/nPe+57Mf+3d/93Xm3H/7wh1+Ra7qQv/3bv+X666/n5ptv3vzs+77v+3j2s599l7xeoVAogCRFrUVRJ+vE1pv1F1a19UFmgHkfGFJip3G0gxgv7khy1JWswAgxMcTIakishkhtNctekpC2G4uPYA0sx+SidVVaO0S2KsuCwGrcbFcKdhqZRdaHLkNI+Jj49Vf/PD/zw3Jg8eznfwdf9OVfcd6c1vu4MSScXQ4MIdJUkvjkkyZGEeMMYeywAHzKhJzICYxSVFqLo3qdKJuluq8LMl9NKsst856jLtD6yKlZNX5HIg5b91KE8fP0UQ5wamuJORFTZr5OM3aG3geOVn78MsRZPYyCLWvkA+6HCJO8OVTwo/mlHQLzLoxVGpraKKIOxJw5bD2TyrDsxUxSWYtKGXIWN3pK5KAZghhzrJF50zmZZ0IUMVdjDTvTY7f6Op144gzXbldS8T5ElFJsNXYz+1zMVHSSdqxXHMbfZ6WOD00uxVpsN4yiMKM1KUtVSD8eft2yFDPPB1s1WSjcFZRZo1AoFAofCkycmDMqq7FaXdE0oQtTdA+WA7csepZD5HDZM8SMOrHHb9RYVR0UstQVM/S8CzirxjMFMZfPakcXZd3qRoFODIn//pu/yg9/1zcB8AVf+TV8/tP+7aZ9ZGfiWPaR/VUPKCZOE2Jm2QdWg0JrmEVLZwzWyu21ASRnONv3nJo6DoOcz0wqmRtmlWV24mygtnpzVnDYemaVZeEGYgJtZCYySmOVwhnNcojUNm9So9xYb260wqAI49wRM+QI4vtX+JTHtNdbC5Qu/E6MWguvFUOS2sCjNjCt8kVrr+GOhw4UCoXzuVefGJ49e5YnPelJvPe97+Waa67hda97HY9//ONv93Gf8AmfwCd8wifwjGc8g8/93M/lrW99K0960pN44xvfyOnTp++GKy8UCoUPHbZqu6lp22kcnZFauZAyfZCDhQuxWpzE60XbpDKXPGRYx7cqBV1MxCESs2NWSdxoF6Vir/NR6hCCLDC1hoNVQGnQwJASKSm2KkdlLVOnqawsLtfXGcdUKqcVk0pzsAoMPqOqTFbimtVac9gGyGAaxbz19DGKAxpFbRWV0zitqZ2Ixu6/O2FIiYPW40JiWlsUYFD4kGmTJ+fM7rRi3geMguTlsCImzd7MsTtxfODtb+anvvNZBD/wEZ/4qfzTp34zZ456PJBiZjLWUMQkw0MmE2NCG0XvEzcetMS8PgBSLNqwWcSvu7KzghDEnUGWSglgFHhJhUJKyAFMSNROvjtnNY3VTMfvcS2GWleHXO5B0HU7DUOUFKjrdhqmTrO/8gxjf/nJwW1NZTSnpsdJUadmxwKpQqFw76Gs7T84PuqjPuq8229/+9sv+7HveMc7Nn8+deoU97vf/a7Yda155zvfyfXXX88NN9yw+dkLX/hCvumbvumKv1ahUCis8eMaEs4XRa2FQxduNjfOMDux2dz7xBGencax7MNGSHU5XKkKjFvmHTcd9aChNiK0yWSpXwuZo9YTc2JSWXKW1ztoFbsTR+U03ZhYBCJMWr/nZR/Qym4OJV7/e7/Nj3zncwH4sqf/O/7N13z9rea0s8th4ypfDQGl4LrthpTBRc2+7zeipN4n5n0gjpXg9UyuZRgTf1MGlWUt70OgGxK9SoTU4qc1p2eKM4uOkBLbjRsTlCLdEDjqAzHKQcUt857eahF7hURTaa7daaRmow+krLB2FGP5RGU0rQ/4nPEhYWuLsYouJM4tBmaNoQuSRHwwVgE6pVCIeG5SGXlfMWGNIkSp3chAU2sm2tL1ibbrSUgiFgqchkmluXq7ZlZbloPHexhiJvlMTqA0KDJ7E0ftDJU1hAQ+SSX6du0YYmLibl+QtJ7DuzE1qj5RBXIxlqNwbo0PiS5GOh8YxkSrrYn8jk0r+0FXTRYKdzdl1igUCoXCvQWtJTWoC5GJM1csTWh+wjDSDZF553nfQTueq0R8kmRaRaYdxKBROWnbqKwY3Lcnx+vAlLWkntq1kMiQxzRYrWX2+NM/+D3+4wueTc6Zz/7ip/JlX/O8UVCURUBlFBCpjGaImcYaOiK9j4QEzihMA2vRkUORU2bRDQw+sfKJ1kcqbURE1Uh6rY+JeSfistrqjShJ6sPXledr0wab66mciKOGlDjqAjEltNI4I+vqEKU1xYdEyBmVM8qKuCnkyKSqiTlzYXDTxb6TWe0wRrHsAzuN4wi/MUW0Pl6R0IFCoXA+9+rJ9dnPfjbvec97MMbw2te+9rKGmZM89rGP5bWvfS2f8imfwnve8x6+/uu/nle96lV30dUWCoXChy67E4fRsohbpwUNY1rQugLvwh7qNbe3kaqVGjevE4x9y6vOE2LcuGVBfMNqFBqFJHUNOcGssWP1QcAYceBOnUEpSRjSSm2EUSsfCGOcqUmaWWOIOUES94Idbd8pSWXdwWpg3gUSWRbRio37QlwEEaf1xs2RgUrDapBaOmc1IchC32ol7uqx1qOxip1JJXV1xnDTe97Bjz//6Qztioc95hP55K96EUdDovfiwHZakZzGaDUKvqR/+9xqkGpBLZv2doyNRUECcoJpY7FKMas1KcHEaWJWBMQxDOI6j0kcIM5qtozduMC7KD8bYmI6fh/rPfcLK0QuhwefmlKZjjPznu1JxfakYjW6tUMUIZfR0lG+3djzkqGu2a6LKKpQuJdS1vYfHHt7ezzkIQ/ZJEX9+Z//+WU9bhgG3vjGN25uP+Yxj7ni1/Z3f/d3fOqnfirve9/7Nj97wQtewLd927dd8dcqFAqFk6z6443/tShqZ2Jv80BBK8WstlijOGoDvU90RgwCqz6yO728DecrUYFxw+GK9x20Yt5AMx88rY8sOnmO1kdiyoQUOeqk8s9qLWKczDgDpE3a7ax21EbTxUhjJK1IKfg/f/56XvTcZ5JS4rOe8mV8zfO/nVlt2Z0cV1OnE0lMR52Xz7Jx7E4qzi37seI6cLgaJCU3RQYvppCdiSUkUDqhkmIY0kawM3GGLias0eSxOvzssoMsVW4pQTskppWkFBst5pQMLFpPSiLi6UcTR6XFPW6NZnfiCE7Sj0LK7C8HthvD/iqPznmFtYYYMnaqWPog/+sih30gZ3luZTSzWmakdd1FOx7W6NHFP4TEkDJOBWaNYdFFlkPEji7wTsGpaUXt5PoeuDuTtOMhEkaR1spLulRG4UMiO8OsktpDZzQhJrYaSTC+PdLmwGesQbmNg5KTosHeR7oTVZMKJYc+ITH4xGH0kuz1QVZNFgp3N2XWKBQKhcK9iWktwqimMlckTSiRGcb13nrtd8O8EzG9kiSoECIZTThR+dYGcCoxqWUWagfH7tQxhEg/BJTREBnPDUS0U1lJl3rT//4zfvB5zySGwPWf/QV81Te9iIiiH8VZVkvttE+JWe3Qw/Hc4kNm4hTOamaNI41JVt2QOOhkJsox4ZyhGxL1TNb+1Xj2IQ0YkZASIcmauvOSnrs+puiTmCoWXaSuLHlc0/dGkldDSMifIkOUdfX6s+1DJueE1opqTNWqrWZ3UuFHsdjtfSfr9NW7MnSgUCicz71WPri/v89rX/talFJ8+qd/Op/0SZ90p57nkz7pk3jSk55EzpnXvOY1m97wQqFQKNwxtmrL6VklIqYhshqkizqm48WmVbKRrJBu69Oz6nYXbdJFLdH/Ir7yzIfjGojKivBoVhl2pw5nRUgVUqYLif3FQBu8bNgmqK1UEGxVBmelTs4aETw5LYcD9eiCuN92zVXTmlNbFUYpInINe1OpcyBB7RRTa9iZWKaVoRrFSX58401lNvGp25Vjd9bwgFMNe1NHTpmVT/iUOTvvWHQBZxSnZ5artht2JpaJs5y76f38+PO+gtXRAfd/5KP4jK//fjCyIT6pFFu11AI2VqocfITGGKpx83vVR84telY+sGgD+8uBPiRJrTKw5aRC0CjNpDJMasdWY6jHqkAfxalQWRGRhfEQw47PnzepUMff21oItZ7R7sD5DyDJUQ+/ZsZu49BKavau22l44KkpD7lqxgNPTSVRqrJoBbuN4+HXzIooqlC4l1LW9leGz/zMz9z8+R3veAfvfOc7b/cxf/zHf0zXdZvbn/3Zn31Fr+l973sf119//XnVfs973vN40YtedEVfp1AoFC4kJal1AxEQgSRFXY7LGsRVPR3dvO1mAzxuhCa3x8QZFGwqMHI+fp7L4abDjhsPe3KGRRfZXw4cdaMRpVLUTnFqWrHdOBSKZZfoB6l4e++5lpvnPfNOBER7U8epqWOrMlijuHpWc93uhN1pxbve+pc8/5lPxQ8Dn/qkJ/P87/4h7rczYVZb6hOGltZLalGIiTDOEo3TLMfZbDmIo3o5BM4tO84uB/ootWw3H/XsL3s0kiQ1xIgf67pXPuCjCGt2Zw5FpveJZQgcdYFblj1DjBx1nhuPOm6e93KwExJDFFNMBoaY0Eqx6ANDWH/flmt2Gu63O+FBp6bcf2/C3qxiWlv2GsfOxJAToBVWSepv20USkuC0rvNoKqli32kss9qy01gqLe7tlDLD+NnEmGiHwLnlwOFq4Mxhx/7K0w3yeyPzssFoSQeujGZ74tiuHW50pyslCcZudOWfmtVs1SI6Ukqx3biLHpBcyIUGlUsJ8pZ92Iii5r1n0YdN9V7tNFuNZbt2TGpD7TQoNlWTa4FcO0QWF0n2LRTuKZRZo1AoFAr3NsTUIOcmO42TdRiw6ALvP7fiveeW3HDYcsNBxw2HLe89t+T951abNNiTaUKVlWQnOBZFLXpPipmdxtL7cS2PJERtN45T04rGalKW9fq5Zc+iD9y86DloB6zRLIZIO8haMkQxPmTECPL2t/z/+ZZ/+68Y+p6Pf8I/599+2w8wjEvY9VlCzpnVINcbUsJaMeDPKsOpmQiwdsazgS4mhpCJJGoja+YhZ2KMRBIxQEgwqS17UzGb+9EgMoS4Scu6+ahjf9lz2HqOlp4Qs1TsImcdIWbmrccaaQPRSCrtMCR8kCQohWJv6mgqi4+ZRRcJQVJiU86btfpR6zm3HM4TRV0s4Wl34jbfdeMMp2YVuxP5zp1Ro0lCUTsRf52aVRtRlMwmxaBQKFwu91ph1Otf/3r6vgfg0z7t0z6o57r++usB6Pue17/+9R/0tRUKhcJ9ER+TRK7GRO302L/MGPWZpYotipPXGb1RxN8ekqQkdQH9WJO37MIoAMpSpzdWMmil2J06prWhMQarNZ1PnF3IArTzEa0UISS2Jg6nzUZ5b41mZyKO51ljuWq74urthp2JLMBPbTkap7nxsOPcsqcbAj5lKqOZVJpJbXHakHPevE7tDE6L+CrmxN7MsVNJjV61ER1FDtvA/jKQYma7tmw1FVNnSUmxf8stvPJb/g3zszdz+oEP5198w0vATZhVlp1JxaSyaNSmt1prqaRofaQfxLVgDCitGYZIFwMpy0FGN0S6QRKYtBLBWj0e4BilqZ2IxNbf73qA6vx6ihn/cZFUqPV99ehmviPO+DXTyvLgq6b8g2u3uXa7ZlKZzcFSZUXEde12zT+4dpsHXzU9LzmqUCjcuyhr+yvD53/+5593+5WvfOXtPubC+3ze533eFbueG264geuvv/48gdY3fMM38L3f+71X7DUKhULhUrRe/L1DSBuhx7q24HKZVJKotE4EyhyLrG6PdQUGiEgKkHq+cPuPP1wN3Dzv6Hzk7HKgC4GYM1uN5brdCQ+7eosH7k3ZncrG+AP2ply1Zamd1GPHlDlY9aQsVRZ7k4qrthr2phVXb1XsTSXx9x1/8zae9dSn0K6WPP4J1/P9L30FV29PNtXfkxPVf30QB/i6ujzmzGqQGcEZxblFz5n5wLzzHLWeo9UgdRNJ6i1WQ+SGo45F78cxQkw0XZ/GVCWZkZrKMGssVmuM1qgsn70YcAKLQQwvh63HWS11gSGy6qQuox/d7bPKMnHHbvo4urWX/ZiylTOnJjWZTNsHWh8w4+zkjJHaDs1oQNFYpdmuHY0V1761Cq1EQFVZI1V9IXPYefaXA4shEnOWwyENjIcqIMlRldHEmFGANYpZZZk1lt2JY6txm7pyBWw1ht2JzKNweTXlFxpULvaYtQEGRBS1ThGYVIa9acVW7WT+MoqJNWzVcki2Fgz2Pm3EUcs+iDmoULgHUmaNQqFQKNwb2artcSqQM5Bh0XmW45p2fzlw01HL+86tuOGg4wOHHe/fX3G48uN5zJguNdY+rFN0pZFBRDjzzrO/9AwxsTUaI9bzRGUNs0rWpEZLO8VqCNx0KCKp2mmWvRgYYpKzF58y7/rbv+abnvGltKsl//gT/ynf8oM/iXWO1SDipPW6tB1kXktJrtUPEUXGR4hZ3vPezIn53Gog0/VijgAwQEbRD1FaP8bnWnRSebf+7M4tBs4ueo46L2Z6nwgp4aPMd0rBwcozhLEqezx/ar0YJiqrqSpNXWmmtZjV+5BQWUz9iH8ejTSq9CGx7ONmfrJasd0cC5gulvC0Dh1o7LG5Zqdx7E0rTs0q9qYVO40bU28vP3SgUCicz73235iTNQynTp36oJ5rb29v8+f3vve9H9RzFQqFwn2RRR9YnnCIhphPRO/LocDJGr0hJs4th9ut0QMR4VRGk2OiG6RHGSUbzMs+EKzeLAi7EFEoUpJ42O1GFverITB1UkGw6hN2rFeIWQRXM2dQWpFz5qj1srCcVjhreNDehPcfdsyqCkXAB0lbGkKGnKndGHe6CkBGjMWZKoPTIgDrfJTEqZhIWlFZ2aC/8UzHQTtw1EaGlNiuHAEReqlK0a2O+KlvezrnbngPO9c8gCc/76WY6RYxZqKRxbYxGp8DpEyVNEorVkPAGqmaMxlCRNwLfcBpjapg0Xsqo3FWE7Mc0lRTTWPFGVFZhR/kc3RG4WOmjwmjFCGNG+sXbLaf3HRfx+02dt1jfue12NZqrt1puPZOP0OhULinU9b2V4YnPvGJPPrRj+bNb34zAC996Uv5qq/6Kh72sIdd9P5/9md/xq/8yq9sbn/WZ30WH/7hH37R+7773e8+73me8IQn8Id/+IeXvJYzZ87waZ/2afzt3/7t5mdf93Vfxw/90A/dkbdUKBQKd5q1U3dd2VZbfYfF+uta736sCa+s/HlWX97jL6cCI43GiiEkMZOEyLvOLlm0kXaQzftpbblqVvOAvYZqs76WRKvOjxXmOeNswGkj4iHksGFvInXYV9WScLtOff27d72Lr/6yz+fo4IB/8vGfyA+/8udoJs1GPFZbszE5gKzx1wlJqxAhy8+OWs9hG1j0gX6sO+9jIgRY9YlV36E11OY4bYic8QkqrVAoYgalJRFpb1KTSaismVZSKxfGGnKl1MZVnrPMTTtTy+EqYJy4u0FEUSgR/viYWIwO8aPWozVsVZajPmCsZm9WkTMcLD0xQSBhUGgl89ZOI2lOMSUW42tbrVnGgEFja6iNIaRMbRUhRUBvkoynlRiCKitOb4DFENgaTR2V0xil6FcyMxqjMGNi1GysyPBJfm/uSE25VopIlu8wZql1dOcLAzdJaD5uRFHbjd38jgFjspd8P/Ler0zVZKFwd1JmjUKhUCjcW9mdODofOVh5ULAzrThqB25ZDHRj5ZrRYIxmqxZjQEiJGw46/HamsYZ2CBijNwaP9Ug0hMTZ5YBPib3GAWpjiFZj88e0MjTO0nlZiyoyB61n2XsUkJJiiJHGababCr9/A9/69C/i6GCfj/rof8L3/PirmG5tsRwCChEUtX1giJEhZJRSdF4M6FYprDFYq9iqHForjlpP6xOVUcy7QEbMInZQtGo0hZBxSkn7RZZUqdaLcF9qrxMhARmcEWFUzBGfxHifcpbXNzAf68krp2UNr8X8DyJ+iuN1DjGyv4pA5vSkIqTMxBqclnYPZ84/D1tzW+dhzmh2p5qUrJjeQyLlLJ+7kvV9baXS+uScVigULp97rTBqtVpt/vzBDiEnh6OTz1soFAqF2+ew9XTjorobIq2PG1HUeUSpRLBaieu2MlJvl/Ml4z7X9Rc5Z86tPLXTJCwpw7wbyElRGYXW4mJNOWO1RmtYtJ6YJYa1soZpbdidyKb37sSK+l6LcMeMC8nWR67eNmzXlt1pxbL3JCsJU50PaKVoB6lmkL5sjXWyQJajB4UfEplMsuIMHkIc+6sl5SgDzigWXeTssmfeDZv6u606EwLUtSYOHT//wq/hxnf9DbO9q3jy836M0JxivvRMK421GquhQXP/nYbVEMgJBh/plaJKCjNuYvchElMiJRhUpk6ZIWaMSuioaFMYO7hlQ98ZLaIqlYjjrrtSir6PVE5jjaR/KcBYEZUBmyGhHeLGDbEWrU3cHXPnFwqF+xZlbX9l0Frz4he/mCc/+ckALJdLPudzPoff/d3f5cEPfvB5933Tm97EF33RF5FS2jz2e77ne67Idezv7/PP//k/521ve9vmZ1/zNV/DS17ykivy/IVCoXA5rJ3I6+q7y0mrvRhrMdT6eS4nrWfNugJj2Qd2GscRUl2xGiLzzhNPzE3rdKtzy56jlacPiXkfqKymtprTW+48wQpI3cOW0Uyz1HffcNChFXgScax16GaRq7Yrthq7EYbddOMNfNHnfRY33XgjH/GRj+JH//OrmU5n1E5vxDPT+vzXylnW+6sh4kOCnHnnmQVhNER0g9TI9UEOLiqjMZrROS61H+uK7JgT3RCxTUXlJJkpRjg9FRf0vPcEL5v/1soBRz9EGA9ocs7U46HPvI00lWbj0x7r6JajGOpk7ZyCTbIvg2c1ePYm9ca5vhg8KYlYSWnNtFI4p9Ao2pg377X3IgDTWgRUMWeq8X61smityFlBzseVeNOKnUklBy8hsUDEUb1PbDeSBlBbI0KsURQ1HQ9N8hgydkdqymurRQxlDb2XlORZzpvfgTSmoAGbeV4Seo+/94sZXtYHOyLMy6yGSDuIMEqqJm05qCnc4yizRqFQKBTurRyOwv9TU8f+cuDGo55FLz+rnEaPFXM+RllfGxH2X7tTkzO8b3+FUgqnxWyQx/Vgzpll72mHSG00CUjjuq+26zYQWdMZnfFB0XpJZgoxshwytTHknFBK4VPmnX/3Xn7iG/8V587cxIMe/g/4jh97FbaZ0vnIxMn5zKKL9DFzuAr0IaKVpD7J+zH0MVJpResDyyECCaUMZ+c98z6CkrMdZzSaDBraPrGMEbUcQMk6dZ0ONbGG2ioO2kDjIluNI+XMvA2gNApJtk0R5q1nd1qTgqTC1rUYGKzWG4MDiAHnYCVm8hjl/GnWWJpKavCu2qrZm1akJAaY1RBxRs7E1oaY2xI46dGIcLlmnEKhcPnca4VRD3jAAzZ/ft3rXse3f/u33+nnet3rXnfR5y0UCoXCbbN23sJxPzXIRm1tRVW/dkH7KJuxIWXmfWBIiZ3G0Q5SO3cxpXzrJYp12Ues1ZggC8iDlcdoTciJ5ZBQOkqE6ZDGqNdEHyCMlXHT2jCrHc4q9iaO07P6PLes1P0xbt4rrFHceNTiQ8YahXOawy6jdB6r6TSLLtCvazQag0oiHjo9c2PFX+Ko9XQhUWnNpDEMIbPoBxTwd2dXtEOkj7KFXzuJr92eWLYc/Ofv/Abe+ea/YLK1w1O/6+Vw1YM5uxzQWqodJtagjWz4O61RSjr0zLhwTmR6L4v4WWU56jzTSioeameYWIUzeiNwAnnfMWXWX0VlFa3P+CjPE3PCB9htHIOPm2qQZqzbEzd93NQxXMptXigUChdS1vZXjs/5nM/hWc96Fi972csAeMtb3sJHfuRH8mVf9mV8zMd8DN573vCGN/Ca17wG7/3mcd/3fd/HR3/0R1+Ra/ixH/sx/vIv//K8n/3u7/4uj3zkIy/7OR70oAfdZiJVoVAo3B4XpuvcmWpnOBah3JG0npNs1VYSZn1kp3F0JnJ20TPvTiTupiyzUkycnfdSQR6l2q22mu3G4oNUV1ysPlorxXbjMKcV55aGWW05u+zH+jmp2VBZascPD87xRZ/32fzdu9/Fgx/6MH7iv7yW3b09aqc3hpVZbW8lJFNKHNLnlpKgu7/qGUJmNgqosoLGWYbgScCkUsycZeoMyyEQRnPJEMVIo5AEpZzAWkXjJG03JjkayeTNjIaCkDMpSlV4TDJvNkpz81FHBmLMVDZTW8MQ0viaIkzSKgMyn3Yx4axiu3Jj7Z7MfCFmFl1AKeiDIkXYnlqGmLFaDi+sEfFa55O8RytJUIPP7DQVIcg1GyMiLJ+SVOPVInayY3rwog/4kBiMpCMftH48dFGb+ryT8+qdqSmfODEiravIQ5Iqwdk47HVj1aQ/UTV5YaJU58WkZLWkEV94n0llNsaoISQqK0kEs1LpUbiHUWaNQqFQKNwbOXn2svKRxRAxWowGPkhtndJK6rTHZCFrFENM3DTv2WsS/ViRF3NGo5iOzRk+JFaDnAsoBSEmrNHMKkkGPckQpD55NUSs1tTWsOx62j7gk1Rr08159Xc+g3M3vper7v9gvvyFr+CGzmLbgHOS/NRHqbSeOs3No/GkcpYhJjF35CSCLZ8gg1GKIcAqDLRjW8lW7cbk2Yw2itbLewxdQmU1rlcV7TDW2fko9dwKaisJU7NGkrW2rOZwNQCKlCPLASobuWZWMakMKclr+JTwJxqjQ0xkBduVxRpNyJnKaE7PaqwRA/+yD4SYxCQxOTaoxDHhysfEsg9iNqjNnTbxFAqFO8a9dlL9p//0n27+/KY3vYmXvvSlfO3Xfu0dfp6XvvSl523an3zeQqFQKFya9eINzhdFTSuzqYU4SeMMsyybsauxz/oIz07jxkWgvtUC8NxykGqIsZJhvRF7aioVe2nsyo4xswpjotNYp6dNZsvYcRGNDA214aqtmphEQKQVGKPIGXqfMFqGiP2V3xxcnDnqOGq9VDtkxcRZQBbwSY3O7iEzrQyJzMpHnJZ6uhAkKSoraPuIT57aaEJKxJQwWmNzAK3H9+WY1Zqf+w/fyJv/5x/h6oanfcdPsPPAR3K4GmiMImlZbB92nlllyFnRhURWaUzIkkMXp404r3NiWhlQ1Vg1CBNrUEoxayy2z/iciDHRDpHtxsF46FFZIzV8KbEa3d/OiYCq94mtxm0273OW7vF5L3UKSoMZZAg4PauIy1yiXguFwiUpa/sry4/+6I8yn8/5uZ/7OUCSo17xildc9L5KKZ7//Ofz3Oc+94q9fozxVj975zvfeYeeI4Rw+3cqFAqF20CJuua8uuc7w/phdySt50J2Jw4FnF32nFsMo9s6s+j8KHpR1Fac1lorLIqjFgKRvWlFNRoR2kGSjbbqiyfuTiuLT4neR6bWEWLksPXklFn1kRvP9nzDVzyFv3nbW7nm2vvxil94Hfe///2ZjJVtIGKXi5pWhsjBaiCmjPeJw9aTYmbVDRhjaX0gpozTiqwtOiuZS6xmq3G4dSWhj6SUMUYTkohuthrLtDb4II7zDCjkYGMtGAKp6JtowxATtdMsOk/vM85AzOLePr1lSBlSlPlkuRzwcTS8WEWlNTs7tSSBjTOsURmnNatBDmt8zqiUCSHR1CIsikn6/jQiUNp2hqmz5JS5atcybRwqSVrXECJtH9meOHYah9YapxU+ps1n3flIP1aoL3vPzsTRrOv1rN7MTHe2plxrRW2lynHiDPM+yGGWkZ+vn7Mb/5t9MhUA5ABsXbXXVMdGmJP3+WCrJguFu4syaxQKhULh3saFZy/7y4F+FKDHlBiCrAfXLRXrRKN2kPpoHxIHnazXO5+Yjeu5jMwSXYyEnLFG40Oicmo0Apw/7CyHyNFSavvmnReTdRLxVUhSWz20C373B76WM+99B1unruFLvvMncdNTnJsPLPrA/bYbdqcOlTWrQUzj27UlK1j2HlBihAhigphVFg2s+kAbAm0r50PWium7MUYq8JJU4E2cGA9u6Xv2l/1orjBklQghY6ymUpp2EEHT6dSwN9FsTwy9l2TeM4tMjpneR5Y+osfPoQZyVnK+ZKSWz4fM1BmamSWEyFEfODVzPPi0pGM1zmC1fD9DkFrvlE5U4p2o2OtCpAvxNiv2CoXCleNeK0F86EMfyhOe8AQAcs485znP4bu/+7svewM9hMCLX/xinvOc54wx24onPOEJPPShD70Lr7pQKBQ+dFj1x/V56w3lnYllVttLOli1kjSjnYks8nqfjl0P/fmHqD7KohFg0Up93e6k4tS04tqdhgefnnLtTsPe1LHVOK6ZTbj/qYb77zVsTS3XzCY01jCpDZGMVYbdsaKgcWvxlqb3eXP9ISVyFmesVnBm3nFm2eNT4vSk5tSs4vTMcdV2zaS2kBRKZepKkpJ8SKgsm9fTymCU5tTEUVlxQjfOcHpaUVnNVu1GcZZUTOw0lllt+OWXvJC/+MPfwVjLl33rS7juHzyGeRvISM2RswarFDFnQsqbiguDpnJmdBxIutWkktqNISpyTuQkhwbOKhQQk7igp5UlAa0PGMVm4Q4iJtNK6viGkOhS4nDlxRkcM0pLLcbh2G1+sPKELJUNMWUaJyKs9fd5y6LncOXxMVEoFAprytr+ymKM4VWvehWvfvWrefSjH33J+z32sY/lf/yP/8GLX/ziu/HqCoVC4e5hPZOsBSZ3dv15Z9J6TuKjrJ87L/PCENNYq5BIWerwnJFEntpoZrVskjeVZnfiNolLi0H+myhVfJf+7+PMyTzW+UAbErUxOKuJceAF/+4recv/fSM7e6d4yc/+Ch/2YQ9ja5yRQJKiLlZzfth6hiDrf63gfQcrDpdSvbH0mS5Iii1AHyNdCPSjuSUlSdN1RjNx4tb2cW3WEGNNbWRm6GMaa8DzRoA2hMQQM/POM28D886z6AP7y4H9cfYwRotZQ8GyC9xw0HLYBg7aYWMOqZ3MopUzhJBRaCaVZrtxnJ5VXLVdURkRMKkM1mkyiggorWgqg0KRUuL0rOLarYbaaa7arvmwq2diEGoMldaQ5DGVkbRhq2FSWTIi3qqtJpNZDIGD1cBasrdO5F0n78IHV1O+nhWbylA7+X6O2iAO9rHGMV9QNZmyJJPNO0mVrJ3eXNe0uvXrrqv17kzVZKFwd1FmjUKhUCjc2zh59rLswmhotiKaD7LemlRGzkZqS22llnlvWnG/3YadicOM6+shRM4tB3neIRJiYvCSzqQ1RDIxH6/r1iz7wC2LjsPOM+8C81Wg7SOJDCRqo8mh57//6Ddx8zvfymR7jy98wU+we82DyKjxWhMfOGy54bBFKTg9c4h7JTPvB5a9zA1GKamebpzUWIco63AUVaWoncaqzLIPnFt5FJlJZajVsRF/6QNHncfnzNlVzy2LnjOLgXPzgcNeUm9XXSLmyBDhqI3EBBNnacx6Tklj/V1giJnOB5SSdN9550cRmaapLLXRGK25alqxN63ZX/UiFAtSG76/HDhsJVDARznL8VHOog5bEbt1oxFh2cu1FwqFuxaV8713Yn3LW97Cx37sx+K9J+eMUooP+7AP46lPfSqf8RmfwaMf/Wi2trY2918sFrz5zW/m937v9/jZn/1Z3v3ud7N++3Vd8xd/8Rd85Ed+5N/X2yncCd7ylrecd9jz5je/mUc96lF/j1dUKNw3SClzy6InA/vLQQQ6lblDkfnLtWNVK07NKhRw9Va9OXA4XHnef9DS+sAN+y0hZ+6/M2HWWEKU+oIhSvLSEBMhyMFCJnPUBo7agS4ktmvHygeGkDg9rbhqu0Yrxe7keMPfanElx5Q3EbUpZ/aXA0NMnJqIGEuPSUq3LAY6H1iObudZbZhYx5AiOSFJSzniQ6YPMmxopdiZVMScOFp5zix6zhz2ZCWf3d6k5k9e/WP8P69+BUopvvAbv59HfOITWfXiNu6jRNUaI44CPz7nrDbiAgf2JtVG5NVUGms0bR+pnCL6zDIEOZCoDEYrDJqrdioqpVmFCBl2p3IwYJQkai2HSB8SbR+YD9LxrY1iu7Zcs9OwVVlaH6mMiLCaymCUogsRN8bvXuiEWFOcEIVC4SRlbX/X8eY3v5k3velNfOADH8AYwwMe8AA+/uM/noc//OF/35d2j6bMGoXCPY+UMq2X9em6LkIpEStdmE667AOLXuaAw9aPG/HVHRI2pSzVcTlL6pMYHOxlzz2LPmyc3iEmbj7q6WLkaCXCE5/SZo5qrBHRT+fJCgYvKUfTytAOspluLVJ/gWJn4kRUdKK2ejXIockQEmcXPYftIK5rq3jZd3wdf/o/fofJdMpP/vyv8U8+/hMA+fz2phXXbtcXrXBYv4dF53nT+w64+ajn7Tcv5EAkJ3LWOAt2nCmGcU6TNCipu1gnRCklQp/BB2ZNRYyZq2YVe1tOZpyUWHaBzmcap5jWUsU3rQ0hQT9EnNPccjQQssw9Q4hMrGXIEYNmqzGgFF0fWfYy180qMcxUVuag5TBWs6fEzNlNCu4t834UBYmre6txaA2NtTSVphlr+kJOkiCV4drtCTsTK9UgUWoAb5r3LPrAbPx+Kmu4drui9YlMpjIidvNjZcmpqWNv4tiZVOfN1X2IHLXy+7O9NvlYw+704olht/c7eDLp+WDlsVrRDiKS2m4sIO7/zXrK6U062aXm/fU1rud6rRTXbJfIqMI9jzJrFO5JlDmjUCjcFheevRysPFqD0YpFt14bulsJmU6yngvWIvxlF7h6u97U5d1w2HLUeVJKLAbZx792PDeBtSiq3zR/HKwk/clZqePLGXIK/OoPPJf3/N8/pprM+MoX/xQP/4f/CKMVq7H2zxlDjJlmNCTElOiDpGH5kCSdCbhup5H68dF43vqI0ooQpLa5HU3pnU8YpUYDgIKxWcP7SFbQ9fJaQ0hscmjHWclaxVbluGa72qy991cDRyvPpJHqvD5kQopU2jBtDGQxLzijMFpjlMI5xdZYPd64tQklkzI8YLch5LxJepUKP2lK0UrEYj7KZ7BWZ1xYaV7OSwqFu4579b9dj3rUo/jFX/xFvuRLvgTvRUn57ne/mxe+8IW88IUvBGRQmUwmtG1L3/ebx64HIICqqviFX/iFMswUCoXCZdL6KBVyQTa8lTrf1Xo5TCojqUNJnAOV1bRjHKwsQiNKiStCKakNsHZcxBrNltGkLAr7ISZylcelLly11bDoPDfPexRymHBm2W/cq0ZL5L/Sx3UEh60n5sy89YQEB22PD0k6p2upY5jVRurjjGY1BG6ad6yGseZPw6mmYtkFYk4sOo9Bs+wjk0ozcxajYd4G9pficPY5U2k5yHn9r/4Uf/RqqTn6/K/9Tj7isZ9O20daH2l9YDUkjInURsPotsiAD5GQQStZaDunmFpLbRVtEOFY24Nfu9JR7FlLZcA5qTyMQGMUQ4JF5zdVg43T5Czfs8+ZxolDeVZbdqeOvcbRDlKZcGpSkch0g3ynk/EQYO1EZnRDWK2YOENTGZZ9IOV8UVd6oVC471HW9ncdj370o28zOapQKBTu6fiYWPWRPsRNus6GzJiamsaKbhHSTJysNysrVWghiZv4jpg5Ppi0nsPWb9JxuyFy8zg79CHR+oA1it1JvTnQUEhVWeMsh61n2YexhkFhNHQhEb1UyzmjN+m67SB1dTFJddz682q9OKCnleGnvu9b+NP/8Ts4V/Hil72Khz/qY1j2gZ3GsjeKWVofbyWMOlnh8b79lYjSYmRSKdo+E5GZap04q9bVheO80pGICQxSdTdrLM4onHaknKkqMV0owBqFj2LM6HwEZbEmU9nMaoi042c3LET45ZwhRhEonVv1kopUKREnaVj5IAcrChYelj5itGZWa1Z9oraJq7cbfEhoqza/V84YdhqpATy9VUlKlpYK9ZQz1sBe3RBypDJS1V4ZTcqW/dXAvBMzynYjLnJtFFrLPDaEJDXlSEKxQjFxcjiVMjROyzx8ooIe5LBkneq1ToG6XLZqK4dMY1V8Z+JYkSfO99UQ8CmDkt8/kN/3ZpznQH7nL/XvzZWomiwU7g7KrFEoFAqFewsnz16GKOvH3doxb+W/X5PK3KYoCqS5YtWLED+kzMpHPnDYsl1bOh8IMZJzJiuFQaqrh5BonJH6vDYw+EzXR47GxFatoDFGUlVz5Hd+7Nt5z//9Y4yr+YLnvYSPfMzHsDtx7EwcZxcDZ5cDzih2GkvMiXYIpKzQZGJMhAi1UlSV4bDzDD7RVEZSXLPCac1hiGIQURrGuUErxbwLKMbmD61EjBUiPmcImdoZGqvZbawIscaErBADvbccMND5hLUarUU45sb669WQaZOnC4GJs1Rao5ymMopqbMfofKIyWowBwA2HHduNk6SrKMKoabVuLVG3+m5mJ9b7vU8c4dlp3DjP6osaVgqFwgfP/8fen8dbltb1vfj7mdaw9z7nVFUPoA0qg4naQYgBB3IxGEEThxBvJJpoHCKo8RpMa+tl+F1+EXAizuCQG73iENQg0SviEMT8hCCXRMkPtBEiQ0Dphu6urnPOHtbwTPeP77N3VfVY1V1NV3evD/Srzjq119rPXnufOt/v8/0MD2piFMCXfdmX8Z/+03/iG77hG3jf+963a1K2Co6+7+n7/rxztpa3OWce//jH87M/+7M87WlP+5ivfcKECRMerBhKnEQfykat1RcdKaGVkJOGkOiDkGuGkJjXZ4v/mMRiVBlRgPuYdpuz22u0laHljpvDe404Fd26GiTSzRpMaRgap5k3ZyP/jjZjiXob6UKkHyI+JpzVzJy4M9267Om85agLpJSKw1XF4dpzuPF4n1hqTcyZMxsPJOa1RWVFCJloE92YufmoYzMUhTGJEBT//U3/kTf90o8B8IyvvY4nf+GXc9wNYlM7jHRDRqmM6I8zNgoZbQhiH2t1Zl45YspopVi0hrayuGKNu+7j2XuuFYvacKJ1Qk4b5V7XruK482yGhE+BxomyYr9xzAsxzMfIqVnNVfs1J1pHRrK1F7VjNUjz4krDsVVN3F4JEVJmOQTGJNfuxihrnpQQEyZMYKrtJ0yYMGHCHXGu4w3IgKAP4ty6c4w6x520D5E+CAGqtoY+RFpnWG4da406r6e4KwzhLDGlsZrNEFBKcdtmvFunqu2at6So414i5zqfCmkkM68tc2epK72LWwhJCECbEBhC4rgLhCQRdLUTUUg3JLohFncfoBBaNl7IRI0zMkTxiW6MKJV5zU99P3/wm7+C1ppX/Myr+Py/9wU7hXLMsta7qsu3ER6nVyPHnZDOQsy0lcPHkRgyldW01qG09Eiph1GJQrvrI15laicEKhcNVy8q6fdyprHSsxkjfcl6iIQkUXPkTDcGUJmcFDEnNND5hNWacZTBx+gj88px0DoO1yNKK6yCECXWe1EbYpKIv5TEFVgpxRDEufdgVuGMEtJc41A5c9j53XuwX/pKqzWzSvoiAIM45fqQ8CHjkzj6OqPolKj455WhdRatISV2hKuxiIvGIM7HY5De0RnNceeLa5M8z+0V5PdmSHLQSoz7lmzXOBGwrAbPGA25uEjVTlyx7DnPcU/O0Pc1anLChI8lpl5jwoQJEyY8GHDu7GXwCWeUxFMnIeo29yDUCEUksRnTbr5itDiqmtI7bbxce4gSiSf1cdoRqXyWaDpJkxBS/7wWF9Wc4Lf/3ffz3rf+HsoYvvB538+jrv0MQpSouPUQqa1mUYkjboiZ/ZkTEUOGlA1DzPgYqJ2hj4nNEJjXjrokZYw+oSv5/ZuByirimNHIOlPKpJQIGWzpiTSK1ilA+gGnNWQhM2UUWgsBDCU9xbIfOJhZQpldNJW4syqtGH0Ucb2T/jKpTJ8VOQeaWmL/UobNEIgx44yIaEaf0Fqx39q77TklCcRijeK4Cww+0ZtYCG2Rg9lEjJow4f7AQ2IK+bmf+7n82Z/9GT/90z/Nz/zMz3DDDTfc7eNzzlx77bU897nP5Zu+6Zuo68niecKECRMuBlvnpVR2he8tg31LhtpeZ3vdbfG//f5+5YhFdZyqfEGbrVop9puKUDa/T84cClFYp5RZ9r4Up5nNGEApblsHlv3IEERt7WPGKIVC7YYPQ4iiuB0TqLJWBashUtlcCEWRnDLHfUeKUFUGrSU64ba15HBvRiFfffQdb+LNP/f9ADzlWV/H5zzr60kpMQQIKeEjJUYPTNb4Ek9RWcXoEwEhfUUyIWb2Go2EawgBbFZZGQABpkQhNJWhcpqTs4qPP2Hphsjh4NmrbYnQyzgn6owTs4o+BPZqxcGs5eq9Bh9FEeFzZq9ybMaAUYoTs4pFYyclxIQJE+4Tptp+woQJEyZscXvXpa3j7B1wF+6k1khN2lSGMSWpQbvArMp3WrMC57n1hEJQWeZMHyIzZ3akHlWip6tCjGqd3bn53D66bPCJxolzlZCqFIvWFmKVIVXi6LPsPZteVNnOwnHniWT2SpxZQiL1Upelp/ABZzW+EJRuXY1oIGa53n957c/wul8SV9oX/8CP8bnP/OIdkcUXMta2B7t9Xb518fUxcWYtUR5KgVEaSFwxr+mLg5fRgNK0lSKlLZFAFNy9j0QlZLAUE6qQh2pjQSliyKQQOe7FjaqxEm2ntMTztdbgQ6bR4jZVO0NKifUI685DlliMTZ843ASaSqLDK6dRyPAFhai/fSCmTGUUrjIc9wFjtESJG82i0sQESknfFHNiXllOzivmtWUYI4edRJnEmNl46QW3fYxVir3GFQJZYtE4ZpXlxMyVHiiy1zrGmDjuPT7KEMdoEZMs+7MEQKtFBLQdfLWVuU9ikkVtqa3eOa/Ni+NzbQzHvURNzir5TKriHjWrzidJ3dnPyhhLlHsZ/NT34F4wYcIDjanXmDBhwoQJlzvOnb2MUfqIrUC9ugeB+jZCD8BZhVZCzKdEkmeQ9AnAWc1RF6DKaAURzfEoTkzLzksvkCIUUtSsMijg9//9j/Gnb3wtKMXf/99exqd95t8hJnGgTcBVRtONQcj+iPvtMEaOfcJYRYgZUkJpMFrTak3K8nXKGYPGWYNVhtZlFAGrNMsYSABZ6ufOC+lrjJmq0qAUJ1rLGLPMlbQ4C6sshChjxIXKKUUgs4mRdS/OsbXVzGpH6xR2VKwzKJVxypB0QmVFVkLQWtROYvW0ksj2DNoozmwCJ2c1i+buSVHnoraGWXXWIbdxhiFEUrLnCW8mTJhwafCQIEaBWN1+27d9G9/2bd/GBz7wAf7rf/2vvPvd7+bMmTOs12vm8zknT57kr//1v85nfdZn8ZjHPOaBXvKECRMmPGixVa9u/7y3qtDtabe/3rb43zLt29rsItp6H5lVF/bra1v8i4rZcGJeMSvM/4Soo482oygohsjp5UggkWIiAY0VxYABjotS3VpFzkoytbVi3liO+8Dp9UAuqo2ND8ScIctmNjmzGRM5J+a1YSjRGR/607fxln/3YnJOXPt5X8Zn/+N/yXoIDFExBsnXDlFIWjkropL4hz4k+iBKBqs0ldWkmBljROHQVmGKen1lZPPfJzjRWqyVTfFHnZgzqw0+JBatxAUu+4A2Hg0siqNW6wxKwamZ4WDmaJxhv25oa1MIYnEX2TEpISZMmHCpMNX2EyZMmDDh9q5LQ3G1UYodeeee3ElDPEui2m8cx8h1NoVkVRmppZViFyG9devZjAEfIlpr/CB193EK5HOcqpRWNMawcZHKBGaDASUb730RAwDUTqGVYTVI/MU2+qIbY3m+vIvLWA1eyCsx0A1J4rDnMowgQ0qJqBVOaXovLkujTyUKTqFUxmh422//B3793/0QAF/1bS/i8/7BP+bWZb8jdDmrySrzkcMRFJyaOWa1ZT0ETswqQompW3aBkDIhCgmothpjLDFn6spgFHSjqMu1VtS1iDaUFmHKR497YkJU10qx7EcOaktSGR+iuOnKiIO9ugLkXjiruXJeCfErZjQSZ1fnRD8UJ+EEQ0ocrT2JjLMigll10rfNKomly1lEL2MRvyiVWRiz+7uj3ktMhjFUhVg1+ogPGVMU+rXRLPYss9rSh8h6CGSfd+9nY6U/Wo8BoxWP2GvZn8nr2X5e1xp6n5gbiUjcb/Ku59JaCGPnup9tMa/tJXHYdUZzMNOkZGmdwR91GG2EvJYzMWb25pbG3Tlp8Pa4L1GTEyY8kJh6jQkTJkyYcDnj3FlJTInBw3E/4kNmlhKhiA2q4iy7rduWJdEBpK9Y9p7NVtShQRuptDdDhJyxWmMN+JBxKrMa5DmO+5GjTkj8mUzKUBsIKfOW//h/8bbf+DkA/u4/fyFP/Dt/j95nDlqpH71P3LIcilNVYvCRVZ/ZbypxYNKa0Udihv1G4qSHIRBjQltNiJnKGA6cRRmFGi2dDxwPkjgyhsQ6SeJHKlHiCai0OEXFBDGWaGhr6EKUGtUa5pXMhDSa1mi6MXHUBVqnaJxGpczMORSBkES0nlXGaRGP6zL3OV6P9M6SUqaxkiBismYMmeXgOZi5i3q/28rsBEBjSFRW0/mLi4CfMGHCheEh+VP1mMc8ZmpYJkyYMOF+hJJEtx2xaUtkulhsT9te5w5EKTIxZ1a9kHtWQ+C48+w1VqxVzyn8UxaV+LmDhc0QuHU10FrD/sySkUiD/RKzkMv/xpDYjKL8rVAo40QRYDROazLgUyIAhyuJiGgqzXE3cno1kBVYDbd2HpUVPicp4rUSNXJji+pa0diEM46/fM87eeu/fREpBj75s5/J3/n65zPGSEiKHGDVjbsBhKLYwSqFVYqoROGhUBgj3x+TZG33MTKOBlMrfJR1O6upleLKvYbGqF3MoNGKtnX4KIMMsGUMUYY1OWON4sCJy9SpeUXjDKdmFUcl07wrw6pZZSYlxIQJE+4XTLX9hAkTJjz84GO6g+sSSM15T+6kqz5wuB457jyzypIzOCOpc5XRuMrQFxLVENLOrfZcdD7uNuzHMQAZrzNDf9btFiSGoraRxmqa4iY1hMjJWbUjZc0qwxCUbNqXAQFBhhX5nD5qCJGND/iQWfWe9SBuRj5IBF9f3JvWfSTnQGUtKOkXxpAJMeKsxLv90Rt+k9/7ye8G4O/+k2/myV/81bzrw8c0lWHLt4k5U2mNc/KN0UeuPmjIGVonrlVjSNxyPIASUpJRirYxkIXklTJU1jCvHUMIHHeRmMQ5acxCXjrROsZQhjFacdh5nNEUsyVQQlaaV4b91uJTIidkoKAUx5sg/ZYS0tCitjQWIVgtHMcbcdkaYpK4DGSI4ZKmtgmLIhdX3MZpMgmjFUOQeIzBJxSK+dwwc5bKgosKjUKruCMt7bVWhkdaYUZFbQzLwe+IemNMDCHijOZEazmYiavMyVm1c106NRfC2WoI3Lwc0Cqz3zic1cwrw+yc4Yei9E21ueTOuvJ6HCmzc0Jblp83o9UFkaLOjZpst+5T1kz93IQHHaZeY8KECRMmXG5QCkIRTBx1XmKQg8xJhPyTgVwi84QglbI4ywKsxoAPInJQSgTQOUucntOKISaOOy81fs7c1nmOO8hZoXVm2Ue6MTCEjN+6rWrNO97wGt7yy68A4G//k+fxGV/wj+hD+XujWPUSR62BprL0oxCMNLDRQmzaqy17teZMF8vsR1EZI8WvAu9l3dZaKjRaUeL1AqBEEDMmeh9xxmC09CjWaNrKElJCxcyYEpshklWmstJD7rUV/RDwOaHZzjEylXVorQhRYsxnVU1MA4PPgMbHyJmVx1oR0iun0Ebei85L32SNZq92ZQYEqz6waC6MgqELyW0okfHblJX5ZFI5YcIlx0OSGDVhwoQJE+5faKWIZNn0jCWD+V4oQ7cxDtvN0+0GbEyJZR847Lwot5NEtxmj8CFx20ZUC1pLlEPKYsuqAVvUuGNILDtfVANSxDolpKAYEz5l5s5yi+9LoyCqh6qojEPItFbTVOKYpJUU8+LelNn0Er/XxwAZYsq0zhAjmAxBQ20khzqmRMqJWWM57j03fuA9/M4P/SvC2POJT3wqz3re9zCiGcdI0tL4DEEGNQlRETujyRmyhlppfNC7qJAYIm2tCTnRDZmbQmS/dkQyscTeHcwsbaU52VacmtcYpejGSK9k8752hpAk4kKjcFZhtOagFQLafiNKh3ltCemsoj2UBmu7GX6hmJQQEyZMmDBhwoQJE+4Km+FsfN6WFHVP7qSxKIZjyjvCBlDO0TijWI+iGK6spraakIWstHWA0ro4Dg2JmGWoEKPU4zH7EoWXSwQdhJi4LcqQYVFb5o1EU4++F7JLLTHTW+erzRBZjYG9xmE1O3LWZgicWY/4KPV1JOGTKMHXQ+Qvb9vgtEYXQg9Z0VTiorTXVhgtMXJHq5G/+JM/5Pd/+sWQM5/+zH/M3/jib+C2pQflqaxCaU3OmZkzOKfJZAafOdHY4rRld46wQ4xsCtkrpYw1mkVlWA0RW+IjcoIuRkKC2olq/WBmxf2qD1ROc3o1Fkdb8FnhE1RK4vLa1mGMwWTFcghYpTi5qIp4ItHWJc4tZUJxB4tJnHVThsZZFm0irBMhJWpnylBI7m00ohh3WuLxKpPY+EDnI4vash7jjkBnDFy116C14ubjAWeqMiTJOGPIOeOM2IspBTnJPQohs2gt+40rkXfSO91ZFJ010q8etI4YM7PakLPE2G1JSXWJZ7y/SUaz2tCHeK+jJkHe8+1ewDZKcsKECRMmTJgwYcK9RzdGcWxKGTL0Y2AzRtajRG9bLU6dtdNURoOCISRmlbi6+jJzUVocQ61S+JTpx0Qzc8y0JqRMNwROr0fWgxCpdHG+7cZIX4hVPiSMNvyPt/4O//lVPwDA3/zSr+fT//5Xsx4jkMnOsB4kVWIMEVCEFPBRvqeVps1y/VAiySWKTno0rxK1FjFFUNJzxFxi8JQIMfx6lDUVtb41poj3JeLOGUNtNToqosnEIER+rRWLSlMZI3MSpzFJE7PMs8aYqJ3U50ZrQkyELIKM/bYqYnyNtUW4UEmU3qqPWAObIZOR9A/vDD5EaidzDlUiCC8EWzLUVoRzb40IJkyYcPeYpo8TJkyYMOGiUVstZChrGLyorOc5X1SkXsqSkQ3Q2K3CVEu8XbFqVUWZPHrZpA0pcdh5Bh+xWmIzQpTIvMYajFasx0CIGVNiNYxVNNaRc6Z2FqXUbmP/9HpgOQSJXTCqWKxKETpGcaiqKs1+JefFlFkoxenVyBASSsvzZGDjJcKitjKwWFhRIcgaEynDeghsbv0wr3nZ/0a/XvKov/4kvuz6H8TWjugzrYOjbsRoGRIYJYqHbBRWadAZtMaQWdQWpRW1M8XByoi6PIiyXCVFXWs0ir2Z41Rb09SaK/Yqrt5rGELcxROOQVQWx53fuWrlDDNn2GvsbqNbNvktt61HgF22eX0P2eZ3hkkJMWHChAkTJkyYMOHOkFIW8g8X7k66HsKOqOGsuL6e6Uc2Y2C/cSituGJRMa9EDCDuPnLd/XOiDnxM3HjYMQZRGccoJBByJimFJhdC0DY+besUJOKNjyx7TswclZH47UceNGilONx4lr3nzGZEIXW+UpqQJNZvCOJ4NAZxvNr0qZCxEmTFmeOBWW1IMbP2Eac1+60lUeL/UmTVRz5wwx/zn3/iBeQY+aTP/AKe8I/+JWufSWqgsprVCJU2aJU5vRpQSI8UI9y67DnqA48+2ZKzqLxXfZC1hYRWmc2QqKyhG2W9/RhQSrPfGJxRjDEz+kQqJlyNtRgghsSQJYZCp0zrlLhMjYm9Qk4aUsQqg3OGECOHPpGKg62IOgJNJWQpiQRh958xipPzii4EDApdWXxIjD6LiEZrkpbhDgoqY3BaYZTGGDl/iAkQtblW0mdlMovaiWpdK0ICawyVS4whsWgspTWiMpr91u0+p60zdzoI2TotaaU4WEhUeWPNRUduXAo4I+S99RAuOmoSuIOA5lI7W02YMGHChAkTJjzccNR5ibAGyHK8GgKZ4oqqNG3ZPx9iwihFSCJgX/YBrWHmLFpLH5MyuNpCkr39nIXMfmYzsuwDRkn/ddx7fM6kMhfRSqEQIceH/+RN/Nd/992QM5/2+V/OZ3zZN7LxEWc1RiliTKV2T2il8STwCWOE9G+NEIc2o4gTZpXhaOMhV8wbS+MsToPWiZg0qYhX1l5e9zBGfMoy60FTG4k5D0D0EYPMUmLpI43VuJQJhfx0YlbRVEJ+qqw42A59wlrFQWOptKbShgwsxyD9hVYidgcWtaGphEymlTjLtkXEIUJzQwhSBys0mzGwqB2bMVJbfQehxJ3hDkkqEy9qwoT7BQ9ZYlTXddx0002cOXOGzWZD0zQ85SlPeaCXNWHChAkPCbTOsB4CldVlg1gK7Ytx++lG2cy2WslmK+BDYigOR6thpC8qCKXAx8x6CDJI0IrT64HOSxEMMsRwVjGvRWkbgTFm5sowRimKG9ew7D03HvbUVhQVM2dJKnMUPUYLwcmHXBygpAFYj5GYxSlKFBMSY2FRtJVl0wcUCkoBnlTGRkPjNIOPBDIhJM7c+hFe9X88l/XhrTzyk/4aX/OvXwnVDB/FYlbiJTRWayqdwWS0EaWwApyRwnszinVsbSTf2ipIKhOjIuckqmYSp6qKmOT9amrNJ14x52RbAaKcr63Bh0QfI5s+YJTCGMWsls357SAHZKN7Ud7frWJhq2C4txvgkxJiwoQJF4qptp8wYcKEhw86Hy/KnfTcqL3BR3ofGWMiBPGN7UPCaolkayuD1YqZk7gGidSWjWulYNlJXLXTcPOxZ+OjuNIaRW0VWsmG+MYn0hALgUu8a2PK3LoaufW4pzKGeWPZbyyL2tGVIUDKcNx5DjvPXu0QGYjCaYMikDJoo8S1FlFor0s827KLLIcg98Nl9CAqkmUXJPLug+/mD1/xXUQ/8nF/46n8zX/2ApLRWCWOWDFmYoYQAlllQpLojCGMNNbgtGbVe457h1KaRRJi0aoPHA2emTU4K1F0TiuWXWLdJyqXONoklNIoLXHklTsrmvBR+q0zq0F6rMrglEZl2G8MkUxbWzTi0LUcAkOQnrCtDEZp+hDpQmKImX6MEoFuNcooUkpUxpB1RimLDxlnEyhxMqqdRmZL4nprFWQF88rQNpbNGPEhUc/EpXeMQkpb1BanRV2/31hmtbhg9SGilESzV7U9z/04loHNorZ36I0vV6elRS0OYb2P7DeO3kjc+d1FTVqtaCtzBwHNhAkPVky9xoQJEyZMuBywGgK9jzTOcPOy56jzDCESkgjUtRJHo5SEsB9igpK2UVtDSpnOR/Zaqeu2CeC9lxnLorYYBTcedmilODWv+aszm51wOhShuipi89FnPvznf8L//2dfTE6RRz3lC3jC//ovWQ2BmKFJBqU1vZceQBuJo9uMgS1NyMdMU2kOGse8scSoOOqC9FmdB6VoXObkrCZ0QaKuh0RWiXGU3myI0pPNKlPqVtAKHBCKUKLvA8lp1kPAOYNSikpLj5NzxmlJyIhRROw5i9hbaS2R4VoIXJs+gpLjxmm00hzMLZURF+AhJLoQ0Shx71KK2lQ0trjUOs3gE85EamvYjJH99p5nJ9uxyJYgdZEa9AkTJlwgHlJd6/vf/35++qd/mje84Q3ccMMNxHjWOv3xj38873nPe857/DAM/PiP/7hkqxrDt3/7t6Omf20mTJgw4R6htaK2YrvfOsOyKLRlYHDPm7pblSycHXKEmMnIpquPiXUfztq3hkhtDPW8Ytl7ln0kJXFTWvYeyFTGMI4ZqyMn5xWV1tQ5Sza2EleqM93AGBIKxenVwGaUTffaiQOW1orlRl6HREokuiHS1obD9UhMQgZyWpGUoh8TPiQ2vQxgQspgFIvKEhP4lECLGnp9dMgv/utv5vDmD3PFx30CX/l//BRNe8CmKLBBIgQ1MqBYVJa1AqcVKCWPSZmNjyij2K8Ms8oWJbK4Ri2HiNWZIWQhg42JttEcNJaPP9FyalZx0Dqc1XRjZAypDDdgNIm9VrNobCFN6RJ3YZjV5jzy0+2VCxfrFrXFpISYMGHC3WGq7SdMmDDh8sR2w30I4uizi6G7RBFg3RjZDIHbNiPdGKmsQSuPVuLK05xz/fUQdqSo5eAZy9dGK+aNxKNVRjErpA2lRPUcRok4ODET0UBbGWZOav5M5sajjvUYSTlTOUPK4uw6jpkxR2I8G71X7gohJJbDQErgdKSPkffclIk5c9R5+jHTjZ7eB6wxxCzEr9YZ1n0gIfXwXmM5NbfctvKcCeIwJartjEZcjULKrHpPjBljNGdu+p+8+RXfQejXnHzsp/OEf/b/xVnHQeU4mDkyIvYQRXnCKnGt0qrEcXtxYQI43HjmlUUry3IYONx4ep+ILnO1qznuPGMIbEIgpMjRMuEM7LdOojxSxtWKxokiPfhEDOCcoUYxqx1XzCsWjeWKmeOW9UiI0nfZItSoraEpJDbI1FZixbdOYiKcSdgSN06W+AxnNJ2OKKU52niJEclCvHLKUDlx++29RJe3CWqjqZzexSQebjwnZxVWK07MK2JMtJXFR4n/rqz0Ra2TQcde61gOHh8yqZDNtkSjB4vT0kHrxH15COJg5cyOBHb7qMnGmt09gPMFNBMmPJgw9RoTJkyYMOFygo+J9RAAEQusyrzhykXNR48HiZnLEaWEbFQ7gzWKdV9i9gYRhzRWs+oC3Sgus5XVDGRUVigUIctzVUZz3I2MRUzSVhaF1LGdhxjg8IN/zjt+7kWk4HnEE/42n/5PvoulTwxeBCchQlVlKqNQMaKSRiEkK3IWklDIIiZfD2yGyKw2hAzr3gMwbyydTxx3hpxlbpPIjGMuAnKJ32trS07ST40xE0tP43OmUYqshJQVyZiYMMagMqAhFCcrrRRLH8TdVon4RTye5N4YLfMcZ2RWlFJmr1WorPAhoaAICOT+ZeQ6s9oUQpqjLnVyPwoxaozSM9/T/GQs86FzRRcTJky49HhIdK6r1YrrrruOn/u5nyOXXYZ8u+nq7Y8B6rrmt3/7t3nTm94EwKd/+qfzzGc+8/5f8IQJEyY8BDCrhRjVVIYxSdTdcReYVaICvrPi7a5UsiFKAW5QHPdS3DqrMaUQDJu8cxOyWmOUlqJ5iMwbUQDMnKF1hlg2xldjoHWWa0428hwpkwOs+kAfEqNP+JRYlLXuN45lD2srG/K1tQwhcdR7DrsRVaL5+hJ7gMqElEgofJJYhlhiNHLO7DeOECQz+7ajI/79S76JW//yfSxOXsXXfPe/Ze/UVWQlzk2rztPHhI9SYOeccZWlRrNXOw47jyoKZ2NEydzUjtpCbRROKXxRgZMV5KIWyZFHLVraynJyVsl5ZZDkWlGYHG5Gei9qjMpqZpVFK7hqr2a/cXc61JL87rPEpnvr9DQpISZMmHBnmGr7CRMmTLg84WNiU1yS7vCvcIZI3m3o3xm5/kKvf+tqELcaH4kpY4orawR8lF6ishqj4PR6xMckLkNeaulZLe41W+KK1Zq6xG6fmLldPzL4xDGe/caxHgJjiJxeDxx3gcON58za4wxsjJEIajKpNBvWGqyGFDJZwzhEOp8YQ2Y9ymb7FVTklOFmOGgr+hDoY2LwQnDqxkjtDMs+sOw9zmpqo1FiZgVZSEJ5hJS2zj2K1gpxZUiJRKI781He8srvYFwdsnfNJ/NpX/MSktaFyAIJcX2KKYPR9F7ccIUAo2kxLMcgcRV9oDKem414WWUyjdPcth7Z+ERtFEopujFTGU2vAikl1jHjU+ZEazloK3zp7zSKISW0VdTIC2udRAjOKxmKnGgdMcq9a6w4bVVGehWNorLiTlRZjVaOZR9Yj4HjbmSvdoSYWI+Rk7MKpSR2T2vFiVmFVuBTlh5LweAzY4xorZg1Buc0Oko8oo8JHzN+DJycVTsBz7wWctntCYF7jQMlrseP3G8ASvz7g9NpaVFbaqt3P+PnksBuDwX36md8woTLAVOvMWHChAkTLkdsBpmX9GPkzHpEKZhXFp8SWkOMqYgiZA+9LrOTGBMhaW5eDnRjxDuDswbInJpV1JUhhczBzLGoLbdtxhLzJjMSaxRXzh2nofQEkg5xfOP7eNu//S7i0HHy8X+TT/knL2KMQBRHq95HjM5YY6kqQ04iQNgUoQpKEULGKDAZkgJPphsTiYhPEkU+xsRB46iM1Mi6vLbDjaSICHdJobIITiTiT35Pi4g9sRkz3ie0URityFpRaUXlDE4pQswcdgOLbNl0Hm00rdPEqNA645wBlVmPicaImGLwWXoha3YCki0k1jDTFkddgP3Sf+YywwlJnKls6b9m1V3X/ClL1DuIuB/YEawmTJhwaXF5dN/3ATfddBNPf/rTee9733unTYtS6k6/v8U3f/M384d/+IcopfjlX/7lqaGZMGHChAuEM5p5bVkPgf3GcYxEWGzGSOcjlZGN1AtRyaIUTiv6MqAAuHq/ZtkFOmRT9sxG8rVjkkJeASvj6YMmJzDl+UShm5jX4ny0VV6DqHpvOu7ELclLjrTSjs6LAqD3EYvGabFIXfaeMxvPchOonCIlcWJaVAZrNUZLLAfyfyFfFXKPVnB6M3KqUfyHl/8rbvyLP6NZHPCs5/8EzRUfh9ZKrHHrs4ONfoxyfgZrdFEeiGJBGy1uVQqcMhgloR11ZbFWY5HBRTdE9hrH1n9r2UX2aifqZTI+JXI85/1Asd9Wd1At390GvVaKiGSXE2UAtt3cvxhMSogJEybcHlNtP2HChAmXJ1ZD2CmYgXt0k+mDxE9fqJvMuddPWSLklkOQOLycGWxEaUVjDEpJfN6Z9YjWsvndFeHFonZYreh92sV0z2vDHo5cNtLntcUaxXEnZKreyOb+X3xkyen1yOn1wK1LT+cDpxZCpMqIU5ZWItQYfGQZRIwgJKBMpTXei9tVSkCG6kTNpg+cmlUiflCaRauIKXF6M7JfuxIpnnFGeoBI4rjzRdks8WzdKK9/r7E0lUUrxTBENmdu400/fh3dmY/SXPkoPvVrX4KqZowRlp1HFeV05xPGaJb9iFElyrwMCVylqbShC561j7jBM8bAGDLKKGqjCDkSQua491y5aJnVmZATIVqM1gxjIubMso/0vqO1DiPzGFAQikuvNZraaQ7aiisWNWNIHPcjMYMqJKzaGlqncdad1x/EGPExM68NRim6ITAEISuBvN66MjtxzaySQUXcinCUSE3yKOpuV1TjvpDUtFKsBk9t9Z3G3Gktn515ffZze9Vefd5nd1bd88/GFpej05IzmoOZJiV7v7rCTZjwQGHqNe4f3HDDDbzzne/kxhtvxBjDNddcw5Of/GQe85jHfEzXkVLij/7oj3jf+97HTTfdxMHBAddccw1Pe9rTOHny5Md0LRMmTJhwMUgp75xRjwdPN0YWjZU6c0ycmDl0r1A1DKMQ8MPas9dYKMkeOWURg4fIvHG0RkQJOcv5+62INhRSJx92I6m414aYIWUqpehUZn3rTfyXV3474/qYU5/0aTz5uS9DVQ1kCEn6nxgzCpmptNYxJpkR+CDi720B2VhNVQlBCSX/Vo9RXH3HKAKOBISUeOR+SxckKcQphTKKMSSsAaXyrja1WnqkPqTiJCvRf05r5o3BaWlEjFYkJUklfYkQ7/rI3kxhlGbtAwrp7xaNhQxNpXHGYEyitZq2slsNOgpoK3BJyxqt9EqtMywaB1niymPOGKXoQ2RhNGNIFKPiO0U3RnIWEUVltTzPvZi1TJgw4Z5xeXXgF4lhGHjmM5/JX/zFX+ysaz/1Uz+Vr/3ar+WzPuuzuPrqq7n22mvv1tb2i7/4i6mqCu89b3jDGz5WS58wYcKEhwQWtd3FBOw3jt7EYid64SrZ2mpUsWzdbmrPKsO8tqw6OXZaCsKUcykwM0MZDpycyc70qg8MPjNvDBWGvdag0PiQMMhzLgdPP8ayca1otCHnTCbSjbIhvh4iChhCoKnkeTOZZR8Yoww8cmVotKZXyOv0SbK8i6rBWk3IYFLkV37gBXzwT/8rVTPj2S98BScf/TiGMVIZgzWa4BM+J0z5XSWqeAVZ1Ng+JPZbS+9l3Uormkpx0Mg9OjGvSDmTUkZhycDgI6CojaapJF7i9Kqn95Yza182tQu5rbLMG3tRquXaiqK6sYbBy/s8vxtL2JTlMzKGRMqUew5HncdpLU0ckxJiwoSHO6bafsKECRMuTxx1nt6fVTB32wjp2yNKFLXVsjncVIb1EEjFTfVCr3/ceYaQ8EHqfh8zSmWImaONJ4SEcxqfEn4UhyZbCBuDDgxRCFSZbUQ3zKogDj8FtTXMqiyijjEy+MgHTq+prOao86yGEWMUgxdhRkhCUspoloPEJ2yH5zFntIYxJZwzmDEScyIlIXdpoxlDxmhNzolT84qPHvV0fWS1CSid0UjNXlnpi457j9Wa4z7gY8QajS3OsSFlYoykbsNb/+13sf7oh6gPruJTv/b7SM1JulDEGwR8TPSjI+WMyuIY5bTERBgkOnscE5GET5mmEImSERV4GmGthNC1ifI+xRTZbx3rPhKckIHcnkSSL4eRGDM9ARMVYxJRSeU0RmtO1I4r9moWjQhs5rUlRaic5hEnWhG0JHHdHXxxnVJb1yhL5wPWaEylaJ0o3rOC0Se6LMOJvcZRWRlWzBsryvlUIttHUZqrEssXuwQJIYQZBVhmlb2omLuHotPSnZHAJkx4sGPqNS49fu3Xfo2XvvSlvPOd77zTv3/qU5/K93zP9/D0pz/9fl1HCIEf+IEf4Cd/8ie58cYb7/D3VVXxpV/6pfzgD/4gn/RJn3S/rmXChAkT7g06L0KMMSRWfUAphUKI/c5qFsaxqJ24zGp5jM+JM93IZoglug7I4uI6+MjMWXFOVZr9tqJ1mluWA0YrTq97DtcjzmhSzmx8RBuNSonx6Bb+8498G93RaU5e8zi++Pofpd07weA9R5vA8ShkLXGCUqQMmzFSVzInGIPMMIxSaKOwRgMZYw0a6HMEEjlryNIjBZ+4LWRC7NhvZL5RFcHDqvd0HqyC0Qc2IZKTZjMGfBDhtlUKq2WusV87Sf5IGafl/m3GQFfSRcYU6b2E5/UhyblKUWnDYs+y31iONh6jDAczd4ea3UfFagiMMTGvHFcuKuaNw2qNViL4iTGTlDjsAtxZ67zFEM6mq2wda2s7iRAmTLi/8KAmRr385S/nXe96F0optNb80A/9EM973vMu6hqLxYLP+qzP4s1vfjM33ngjH/zgB/nET/zE+2nFEyZMuC+4vXX9pFq8f3Gh9/ugdRitWA+hxDGYi1LJCgkpMQaJHVBKisCUMtYoaqdZdp5ZZag09EEUFH2MqMhOEexzIWFlTVtbZq4ik4lRIu46D7cuBzJQG4kBPOoH1oNn8BEfoN+qvZ1mM0ZOr0e0go2PrHsvKvO6EqtYJRvoMYpBqspQO1OIWDCzit/+P7+Xd/8/b8S6in/24lfwqGufxGoIqAzOQEqaRCaETEqSa61QzCrDXmNRGWaNYYyZ2umicoZFY2hrx0HraKzZuXIZFcQJqqg1bC3vT4iJ2hpx0NpazmohRm2bLlPiJi5Etdw6GXJVtuR8FxX7/HbnhigOYuc6hW0hzUsi68xqkK9PtHc9MJswYcJDH1NtP2HChAmXH1ZD2JGWjnu/c3fdxjc4I647KYtCeCg1/XIIjCmx37idG8+d1ZnHnefWZc+yD5xeD3SjRPElMjpLX1A7cao93PhdbPXhcS/XNbLR3RhNW9f4JGpnHxKjjyilqBpDN0aMVpyan5XqtpWh85HDTshWIcJm9Ny66jnuPAeF/OOT9ERkdvENRou7Uyp17jBkfM60VnOisUL2CpGwysQITq+FBJSkfzFa09aGM5uBMILRct0+wrIbd4KCzeClf3GKkETtbKxCxZE//Mn/ncMPvQc3P8Gnft33Yw6uYgyRlDNRKRSOMUbGIDHlY0hUTnNqVqG1LkIWcTqqrbjVdjHR+8jV1jD4uHOh3a8tZlR89Gik95ErFkJi2m+NOEaFyP7cMms06yGwGYVw1FqNyorWWhaV5bGPmFNZIV2NMWJ9Ag2bIRQiXUQpIRu15nyVtEL6F1Xca1OOhCixEz4kEpmcbRlMbAM25H22UbEZ5TOplcIaGYQkLwMThdp9Rq9c1LvzLtTRaXJamjDh8sfUa1w6xBh5znOew6te9aq7fdwf/dEf8fmf//m86EUv4iUvecn9spaPfvSjfMmXfAl//Md/fJePGceR1772tbzhDW/gF37hF3jWs551v6xlwoQJE+4ttuLyruyXV2W+AnBVqU27MZIyuOJ2u/aBYYh0pSbOCozSaCNkqJQyzigOGkfrRKgxFEepw03YxWZvxkhKiZATy8MzvPFHrmN1643sX/0o/sHzX8ns4CTOKIxypKzwKdIN0iOkFDFG4QYhCw1B3HOHkKkM7NWW2knPWGmRnxulSMbgx0jUmYqMMQpSiZRLCa00YfQs2gqtNNbInCErTcqJkCNaaZzNoKCxGmsMtRWH2lmtZf4zRlZDoPNJRPYomWWERK+kD2icoa0N+zNXhOSGEzOJ5q6L2GYr8lZAUhJhuNcIiaqpLG1l0Er6iTHJnGtVHGXnjUXfCTEq5byLeAfu1LF2woQJlx4PWmJUSokf//Ef3x3/xE/8BN/4jd94r671xCc+kTe/+c0AvOtd73pYNjQTJlzO8DHt1Jd3qCEyRGQTfj2EB4X68nLHvbnf90Ule9t6BKAvdrG1leHKZpQC3WlNyKIEpxShPsqwo7EWo8T6dOZEWeysXNfHxJV7Fccbzy1rjx1lkDH6hFKZZe8ZgzhMSWWb6QZxhVr2HlB0PgFSzCqliGXjfTMKWSpncFqxV1tGK+2EQoYab371j/Lf/+A30Nrwz174wzzuiZ9NTInWyvMpJQQoY2A9GAafi71tZuYM1ijmleFgVnHUeXxIPOKgobKGtjKSUV0cpXIJ3Asps2gszimGMVEZccyaV1Ys4cs7ui3l87aiP/vHBUEXi94+RFpnWA6BzRiFyFZysNfle1uEeJYsN4TEeohorTg1d+Qsb8Fh55mnfNlFSkyYMOH+x1TbT5gwYcLlh23ND+eTomaV2W3+novGGebnbPAOPnGMZ79xpXfQuz7Nx8Tp5cD/PL1hjInV4Heb/7XTO0fUw86zHiMnF45KG/YbcQk67iKRRAqR2hjqyjB3Fm1UIWhFunOuB4aU2LkUgZBVQkx0YyjurJ5bVwPHG+mDrFEoBRsvjq7SJwViyjhrmNVnI7uHLHESKZZ+JSWsNUVB7TmzVnRD4sTCidNtSGg0GoX3kaBBZYgkDjcjIUOMCb8VSKAYUyRbUDHw+z/5Ij7ynv+Obeb8jX/+vVRXPoqUE3G3Za8YQ8BaTechFkLQltwVQsJUmpjzzgG3djJAiSmz9rHEhWeUVhxu5P1bZs+yg0RHay2VhUVtaMvwJiRxvrVKoR3MKysCjLnjqr2GxhoWjSXlRO8Vq9FLtIXPLBqNUbJOpzWz2hbCnfSfIWdSFnfcxmkiCq3EZWyMMkAKJcJQKcVeLWvqvPQgSilap0FBrS0rH4hRiHyn5hWNM8yq0ofdy5i7yWlpwoTLE1OvcWlx3XXXnUeKms1mfNVXfRVPetKTGMeRt73tbbz2ta/Fe09KiZe+9KWcPHmS66677pKuo+s6nvWsZ51Hirrmmmv46q/+ah73uMdx+vRpfud3foc3velNABwfH/OVX/mV/MEf/AGf8zmfc0nXMmHChAn3Bak0FZuhzGNKYoZS0mNppaiMzFuOO+iIHBgHjUMpUFqhxswQEynCojKcmDv2mgprlJCiYgDE4bcbIzElei/1tdaabnXEG3/s2zm66QPMTl7FM7/jxzm44ir2a8uQJBpvr3EsO09VUkNSEcuD/K6NEXzOKA1ag1UKlUW4HozEktfW4nJikzIkSeFodMW8kVp82QcWtWZEsek9lZUZxiaIS29lFCEpmkpmLMZIT2qUIsYk4o6UOMrSZww+E3KUXmpItNayTh4bFKfmNUZLvLjWIgZpKysEtSTi+ep2c8bDjSfnMh+pDEqpXc+zGSN7tWMMifUIg5fernGS/LEVt48hnSckr52+KMfaCRMm3Hs8aCePb33rWzl9+jRKKZ70pCfd62YGOC/v+oMf/OClWN6ECRMuEVZD2BVXwD06EfUh0od4rzcyH+64r/f73qhkt4V/Kp6i28JvMwZWfeS2bgBgrzac2YTd91PKGBVZj5nGyma8L+t0RrOoDIvacfPxIKSclBiDDCtSoQZpg6gRQPKblaL3AaNlPSlGxgTrUSJAnNKsfMAoQ2XFHcvoDGiySsSYaJ3lHb/1Kt70H38egH96/ffwNz/3meScOdrk0qzIc1VOiESn5jVH3UhtNWNKHNSGyoldq0FxonWEmLFWIiNkrZJ/vc24howZFD5GtLZUOuOsKtnXht4HnHHSKGVQCYLK1EBlRE1xIVEnW8xqIUY1lWFMMkw57gKzSqJGxiCrGkKkL/GKqQxetq4DTmuJJ4kjjzhoAC5qDRMmTHjoYKrtJ0yYMOHyw2Y4G2+3JUXtt3ZHhL8zaCXEEGsUx11g8Im+qJo3Q+RgplkNgZuPez563O/UtKfXA6OP1FYiE9Y+0Fq7i9tenhaClbPiotpWGh+FfL+N7osZGnN287q2iRBls3/tAyfnFZtRRBzOaEIhxYwhcXo1crgZGXzEGHBW04+JpCSKwhlxlE1K+gYUrIdIrTVNrek9ErdntNTCEUyOWGVY+sAYMos60TpxWOr82Xi3yknswhAj/ZiLYrw4HimpmWOSpsr7xFt+/mXc+M63oF3Fk5/7vcwf/dfoYkJFjVUSO6gUxZk2oTX4pKiNqKnHkNAKdBSnrxgz2spzxSSvL/iI14qZ0ywax21rjx/kfmUSh+tM7yLzxtCFs/1jW2vmdcVxH0hJUVcKqzSLyvHI/YbaGg5acf8CWHYRrcURq3HS03U+EnMmZ4mfqAykrHd9hFZw1AX2KsuqG4kpM6aMjZkQE8f9yKKy1FYRk4hCUioCHWdpnIhH9rRhjIrBi6NWZWUNj9hvpr2ECRMeYph6jUuH17/+9bziFa/YHX/ap30av/u7v8ujH/3o8x73jne8gy/6oi/aRdtdf/31POMZz+AJT3jCJVvLi1/8Yt72trftjr/8y7+cX/qlX6Kuz7JTn//85/PqV7+ar/u6r8N7T9/3fMVXfAX/43/8D5qmuWRrmTBhwscGD9VEkZ3YIkp/MG77hCIgB3Gr3TOaeWVZD14cekPGWs28MpDP1rx7pW/yUYTTknYh11n24uykFSL4MJroO97449/JbR98N/XigC+6/hXsXfXxpAQbnzAGEZ1k6ZNmtSVmOd8oTe/PknwUCoOooHOW+YW8SJkrZaS/QpXIOAWVEfKXK+khSsPCWTadx2c4Wg8MIdFWlsZalI7ock9ilPjASis2IXK0HLBa4bT0Ol2IEusHHG8CaxNFUGM1rdNnPy+S3C6zKq3EhbjcPygOTz5y2InIf68xpVfRRVxRRCc+URshQuVyD3zMLPuzPdMWVivayuycoi7GsXbChAn3Dg/an7D3vOc9u6/vq/3pwcHB7uvj4+P7dK0JEyZcOhx1fkeg6MdI54VccQdEKTi2G+JiwT+RKy4Wl+p+X6xKdls0b//USpQGZzaemDI+RJZdAEVRM2RCioSQqazkRXdjZDl4Kqt5xJ5sZGslgxJfGoptLINV0jDtNZbjLhByRgMxnRsL6OmjxDqkKBvyPkoECElys7OS6DmlRPF+0FpWfeRPfvdX+MNffiUAX/4tL+Jv/71/hM9iAeuMotKWutIMQZTRPgYqK3EatdOcMNBYS1byZ+fFWelk63BamqGQM/OSs71F72NZi8JZ0Cozry1Ga2aVZa91nGgkWuLcqJOUueCok3PhjESarIfAfuM4RlwEbl0N9GV4NIaI36rmY0IhzdCitjirqa2ouJ0tDVRxFLjQNUyYMOGhg6m2nzBhwoTLC+LyKb1BV3qEWWXulhR1LmprmFUSzdCNQowaQuTMJnN6NbAZI+s+cNSP3LocGVOiNrpEMkj83Bk/kmKm9wlnFSmK689+69ifOXxI3LYad+6uPiVS1hKvFhKNM7hG4WOGJPVobSVWz7VCdFLALauR4042qo1VuCy1aRcCWYEmc9x7uuJoq2pLpRXBJzqd6KLCaEVtNMYoVr3E/eWsGFLCaUVMmaNuBAXz2lBpxaw2rPtMnxLKiktSMELcEofcjNWKsTj5xhh5+6/+KB942++htOGzn/NSrnj8E1mPEY0iFxIVSpGy1PlKq7IZn8hZU8dIhRHSVw5opK5vraY2Gh8iOWdCac7qytA4S1sllhu5RzlB5RRjzBxvAiFmKiuRhyFlamPYayvGGHFac/V+zSP2W9rKMqskJhzkPRp9pKkNp2Y1bRkIhCzuwKsS1b51FG6d2Q1Wlr3ELVJiDV2Sv88oep/QKjIsE1bpXTz7woijVDdGrIF55cijxylRnl9zcsa8diwq6XEeagO3CRMezph6jUuDlBIveMELdsez2YzXve51dyBFgThrveY1r+FpT3saKSVSSrzwhS/kda973SVZy1/91V/xyle+cnf86Z/+6bz61a/GuTvuA//Tf/pP+dCHPrRb+1/+5V/yEz/xE3zHd3zHJVnLhAkT7n881BNFlKTM7dIetn3Pnb0GrRV7bcVeW5GKkOCWZY/VErudyRgNVSEH+ZhYbwIJuHU1cmYzElLCoKisxuTAf/zh53Pju9+Oa+Z82QteyalPeBxWK2KW1AwbxKnVx4xPhRCli3AjpR3Bpxtl/98YTVtZcYGqHbXRtLW4Am966cFShpAi+03NyZlDa7kuGYJPzK1jlTzz2jCMlkQAFErDzFi0ylhtmM8NY8qsB08CNJFuTHQxEVKiD4nKyPp8ytQlqcNoWA+JR52qmTmJzOvGIA5PRUAfYsJoJU5YSZyGAVqn2W8rlFKcnDtseZ/2G8cSz21rIVQdtJKUYYyQvu7MeGCLyehhwoSPDR60P2W33HLL7utP+IRPuE/XyvlOBv8TJkx4QLEawo6kc25sg1LsIhi0UucRPELK94rgMeGBvd/bwn+bxHHUjWxj3o66kY+cGRhzYuYsY4wMY2YMomzuvGz4zyvDzAmJ6LaVp62kkOy8bOz7kBjLQMU6g7OGW5YD2/3sBDiVmTeWISbaZMk5QFS0paQOSaIwyBmtxYnJlU36RW0ZY+Zdb/5N/vBVLwfg73zlN/O/fNlX79TOMQsBKEU4mFUse7FdDTGTUMydZSRhlOZwPYBSHK1FSX1i4TipNfNG7m1lNUbpMuCQeL/Bi4K6Lgr2vbrGGk3jNLNG1AZKq13BfTFRJ3eFRW2JKdP7yH7jWOE52ohC5MzGM5Zh2lb9rZXkeDfnDNWqucJqfa/XMGHChIcGptp+woQJEy4vdF6GDmOp+5USBevFoK3MTmwxBhEsdEu57unVwM3LgS6Ic1JlNFft1zTGkpXUqLeuBoYc6UKg84pVH5g3lsoprHZFQS1xDVsXpOMu7AYKlTXMyxqcUfRj3BHzQ5T4gs0QWHW+1PaK9SikrtFLHF8uLq0+SOx1bcTxKaRMH6V+9WOirkQxnGIiZGgricnrQ2LROnzIbMZQRBuGISSMNjinqXOGrJi1Qi4yHRx240793DhFjpk/e93/xQfe9B9BKZ74VS/g6ms/h3XviVHy42IWZ1xSeQNyJkYFBEATyCz7yMzJQCCNqZCeNM5IxHfKmTEKUajziRMgiu3aokHy/lTGGYOPgJbYOl+iIJpK08eIQdy7Ts4dV8xrcs60TiIYJUpdIj20ln6zLfGM3RhZVJYVAV8cooYQsVqiQxQSk5FLHxNixhrDiZn0eCFl9morzro5k5WsT5fBjlJwci7kJ20UzSB9yKl5RWPFZfe2zfiQHLhNmPBwxtRrXBq88Y1v5E//9E93x8973vN47GMfe5ePf+pTn8qzn/1sfvVXfxWA3/qt3+K9730vj3/84+/zWn7qp36Kvu93xy9/+cvvlBS1xfXXX88rX/lKPvzhDwPwYz/2YxMxasKEBwkeDokiWikieecONYZE7QxS/d79eW1lODGvyMBQBCIhbcUtitUQd/HUY0iknIrLU8TEyO//1It535+8CeNqnvVdP8o1j/sbxJyJKTGvDb0XotGYMgoxU5L/Sr1dnG59TFgje/8nZw5ntIgnrBC0RPCt0Q2kLtN7j9CoEpVTDGMgZ4WzmtaJ6L2uLdZojFY7gcTMGfZai9NGeh9AhcQYDFYrVhm8EyJTzCJsUOVeLWpNbTXWyWxlMwZWQ+DErCouwdLvdiHhi5g7pEzjjER7x8ysMpyYVQDsN5a92xkzaKXYbyw+ihsXCk7NqzvE0ENxtJ36igkTPqZ4cPxWuBPM5/Pd1+v1+j5d69Zbb919fcUVV9yna02YMOG+Y7vZCOeTdGZls/T2RcSlIHg8nPFA3+9d4a8Vm86TcmZRO25dDxyXYx8Sg47kpLAuUyXNQGT0CaVg7MTKtXYaryW7WZNpnEUpVVTk8nzG6OI6lXBGivPOJ2KCbhN2xKfGGRaVYuUDMWYalTnqokTgGb3LmNZalNg3/NEf8Hs/9a8B+Jwv/So+/6u+hW5MZBKDD+QE80ZUAocbjyojm+KMKzatGZKGVBTJY4goFD4kNj6SUZyYWebVliClGEKSQj+JUtsaycWeN4a2REWovH2OO977e4o6uSecddkKpHyW9LUaA04rZpUtFriKxhjcOUqIWSW2ssB9WsOECRMe/Jhq+wkTJky4vCBxbtAXovvWtedioEvdPATpN3ofxd1Iwy3LAZ+EzHRqXrHfVuydM7iYV5a2Mtx83OFj5nA1cFT6Dx8TZ7Rnv3USSRcSpzPstw6jNIvG7EhRACdmbkfw2m5wH228XGfjiVk2vskSh2e1AQ0bH4hRXJOyymilMUrcdUOMdF7IXhlF6AO+RLfVTlNZJyIMrVAJGqfJ2XBi5thvLJtR3Ih0lgiInDMn544QLb1PHDQ1IYkT6zAm/vz3/wPv+d1XAfDX/uG3cuoJT2e5GelKfJzKCaXEUdaHjNEKo8Q9KyQwKmNUJqVMSJkKxFkqCfnK6USM0nfUtcHniEGhlKIxQkDTWjb9xU1KMa81Rsk4Y/QJrxJKWU4tHK01ZRAi70HjDIvGshkDOUPvAzEntBXhRkyJWWWJOTP6xKKyjCYxjFEcpM5xAt6KdYzRzGpDSnBiVmMMxJjZax21lQGKj5mcADJVcXuqnSFmEXcoFHuNpTaGo85zclbtCIEPtYHbhAkPZ0y9xqXBr//6r593/JznPOcez3nuc5+7I0YB/MZv/AbXX3/9JV3LJ37iJ/IFX/AFd/t4ay1f//Vfz8te9jJAXKP++I//mCc/+cn3eS0TJky4//BwSRSpS+xd40Qo4FPCZb0j/twdlILWGW7bzlBiRGVYdolZnVgO4hLb+8hQkh2sUYxd5L/8/A/w7rf8LtoY/uF3/hs+8dq/hcoyc+g959CyMjFs0zUSSmkqozBWBN+qbN8rFFYp9tuK3keJ24sZZ6CuChlpgKwUxmpUEk3HqqR6VBaM0jitWA2B1mlWvcRsb12ZQnGVckYEGSEkjFIsKs3KZ4wB7cVJa15rDFLHG62YN5bRJ/ZrR+uEuKUy3LLquWJeE7N8hlQRYoSY0CiUClgt/UxlRRDTVoar9s6PTBmC9KvWaE7ObYkxFPLT5EQ7YcLlgQdt9/6IRzxi9/UNN9xwn671J3/yJ7uvH/WoR92na02YMOG+YzOcLXa3JJ391t5tbMOlIHg8XPFA3+9t4W+VohslDu7moWdTcpezzlij0ChmlSHmxMyJtWkum/JHfWDde4xWnJzXpJQZfeZglunGIMQrI4VniLmQiDStNecoMTKdF4cmpxRJS6EdoxCKrNLUVkhTbWXZrywhJ7LP/OWfv53X/pvrySnyGX/3S/lfv+WF1JXFh8Rx5znuI0YBWjNzUghXVmNQ1AaMVihlWfUBnzKLumI9eGpjGFNiGBOHeHwTSVncoazRjDHhYxQFfkq0lWH0kRMzx6J27NWWUDbz4Wxc4e3htEaROeo8y95z0Faivk9JlN33UKQvaovTimUXROeRMosyzJpV55caCnG8aqvzlRB3FbeSkp0ahAkTHgaYavsJEyZMuLyQSuGYyuDh3gpNKnuWGCUup2cdpOaVqHopG8O3x7yyVNZSWVE7pyx1/BgSUWf6ZSLmxNHaYzYjV/qGvdpwMJvRunNcUmvLMnshu8SIs5rVGAgxSf3bBYnqTgqnDbd1A8ebwHEfSq8kgorKaGaVoXIGpRVjFFdanyJk6IPGKkXlNI1V9GOiMbKpbrTBWVGBN5XEjneFjKVjZAzQDVHqZ2dkqGA0cQi87y2/zZ//xk8A8Ni/98+5+jOfRV8isWOp9bVS5JxKVAOkFIlJ4jis0btojpASPimGMeKcxmqFVYCCoy6glMJQ4vKspjXyertNIqVMWwm5SaFwBqy2nJxVGK3oCokuJXGDiklcZQ9aR11i8sYSTzdE+VydaqoyeJDP3F7t2KhAN0YRo7RC7upLU5ZLPGBbW2JIdKjde31qVombbkqEQQhwrdU0tRWleHG22pQIDGc0+43ZuVLtzyRy/Mx6fEgO3CZMeDhj6jUuDV7/+tfvvn7c4x7H4x73uHs852lPexpN0+zcnX7rt37rPhOjPvCBD/Dnf/7nu+NnPOMZqAsgbz/zmc/cEaO2a5mIURMmXL643BNFUsp0Pl6S+OXWmZ3gfNsfDcVx956izLWS2UIfIsddwBgRMmzGSIwRXRyXUt5GWSc6n/gvv/IK3v3/+3VQimf8i5fyuCc+jajyzkXWac0QM6nMUpzVWA2jM6QcCMisIaWEyjI/mVWWutaklJk3jhgz1mrIim6I5BxYek9KYFEEJdHavYu0zjD6TGMyKYn775WLitoFspJZw2qMDD4yxky/6enHjDNyj2OJ9K5azX5t6UOi95lMQqOZ14aPP9EwhCQimsaedYWK4lSrS7ygLmLv4z4QUiJ5RW0TTeU4OXO0zrDfno3QS+eYCIAIZZrS/5yaV5Npw4QJlxEetD+NT3nKU3Zf/+Zv/ibjON6r6yyXS37v934PEOXA3/7bf/uSrG/ChAn3DillhrKh2pXCd3ZO7NY9QcgVxfKyFCJDUXpOuCMuh/vdOoNCSEhWK9Z94OZljy1FbW3E9cloOLmwzGpL4wzGaHwUq9bGSDxCiDDEyMZHhhC4bTNwy2qQoYSWzfDOB3yKzKzYroYsquLKamonTVVVifJ4jFkGOT5wPAScEXVBbRUpJ1KCv/qLd/GLL/lWwjjwqZ/5dP7xdS/joK2wSmO0KDDEGclx0FjaSvGoEy1X79XsNY5FY5nXFmc0i8ZyalGx31hOzCrqSuOKYj3lTO8TR73nxuOOjxx1bMYgjYRWzCtLbTSLxtFWloPW0ZT3Zrs/dPt9Ih+FuHXbeiRmCEmGFWOQgdWy96yGwK2rYaeqvyuElNlrRTFdWY2zmnlt0UrumTOKeWWKI4C704agrYyQ18rAK3P2czlhwoSHNqbafsKECRMuL9yeWH+xblFbKLUdGkiMXO+F1F9ZqVu3kQh3dv3OS19RW01TSZ0ec2I9eJbdyHE37BxkFZT46sx6CBz3XjbHC+FqGyedS5/iY+IjxwM3L3uOeiHCrEfPLauejx71HK49g49sxsB6TCw7z6r3HA+BZSdDmpQSISd6nxiiDBgoMeFHnZcovqzL3wXmlRXlcZD4inll0SjZ+DdaRBcZFq1DaenTPvT2P+SG1/wbAB71tH/Eo5/+lYQYySnjfSTEBFlcoVKJsxMhCLsBTcpJ3GoLgSqELOrtJEOOzZhYdoHOR5SGfkglTFyRyLuIiT5IbHdlDG0tApOYMocbudeQySkTYyKRCTlJ7EVxnAIZmPQ+YpSoyRetw2npHfpdPyq9zDY6zxrForIsGsdeK71OpTXLITDERFNZ9hvDXuN41Kk5jzo5Y7+1hJg57iNnupFbltIXdmOksppT84pHHjQAjDHR1paU5bVuoyMbp9lrZC17TXHiLb3KsnzGQPrg1TnxLhMmTLj8MPUa9x2Hh4d86EMf2h1/9md/9gWdV1UVf+tv/a3d8Tvf+c77vJZ3vOMd5x1f6Fo+8zM/E2vPkiMuxVomTJhw/+DuEi5OzSv2GkfjxMmzcVIHnppXuznF4NOuVlsP4W73tO/N2o42nltXA6ty7ZjyTsThY7rg/fQttFbUxYmoqQyNEfL+qg87wcpdwRnNzcuO9SAx4IOPjF5cekOmkMYiqfQCRive/rpX8e7f+/cAfPY/+y4+5XO+gD5GVFZU2pBLFF/vI9ZqFrXBGcWyjyKuL68pZHDOYIzZEVS9F/H1eghURnqdTKbzidUQ8X7r6Cq9pjMKrVQ5v0SJV5oTM0dlDa0Vx9fGaQ5ax8HMURtxyR1i5HAzsvaRVe9ROpeZRMWpecPBzLFXO67er7nmxJy9tuLKRcNBicKrrWbuxD3WKsXJeVUi16W+r60mK+nV5pXdORI7q7FG0fu4m62cS4raiia2M58JEyZcPnjQ/kR+0id9Ep/yKZ9CzpmbbrqJ7/3e771X13n5y1/OcrlEKcXTnvY0FovFJV7phAkTLgadjzvr+u2GZFtdGElni4lcceH4WN7vlGRIcdt65NbVwC3LgVtXA4edZyxDksYZln1gCAlTBhzWKPYqsSkNMWOVYiiRGTIYCQwxY7XGmsxqE9iMgTOdp+sDOYnKwOfMOAT6MeFDZlZbKmOYV5qUQWk4Oas4tRC2/6KtpDhuxFKVmLBKkzMsu0BMijM3fYB//5J/wbBZ8YnXPplnf9cP4lyFNZrGaZy2VMZyalbxiL2a1hlOzhtRK4dM7RSN07SVPH5WWa6cV1yxqLh6v+HjT7Z83ImaK+cVByWbm5RpjEFraK3m1KJmr7Fi5erEiWm/cew1EhkCoqoGOFeksh4ChxvPUN6zGKWZWPWem5cDx93I6fW4e0/7ELltPd7lpv82bmVMibayXL1Xc+Wi5opFxal5xYlZxay+e/enbdwKnI1t2V53woQJD21Mtf2ECRMmXF64PbH+njbk7wo5i3BijFk2r0sN3zhdXHzk2pshCPGo8xx1npuOO04vJUpOZVBoYkxshkDvE0prKJHTPma6MXHUjazGyBjTbtP/qPPF4ejsegD+5y1rPny4ofORzRD4q9s6Tq9GjjtPjIllP0rfEBPjKOSn9ZhY957V6DncjPiQiUmi5EigkWGI0rAeIyghcjlr8KGQhLQiIZF9+42hqTW1k0FDztD5RDcKKevGG/4b7/jFl0JKPPJvfSF/7Uv/BTFJf6TLdVKWeLycJBYDlck5l7+T16qVRimJtnZGgcqkEh943AXWo2c9BlJKVEYRlfRcldEcbkb+6raOVR+ojQHF7j0DdrW9NYpF7dBaFNejTyhElLIewo6YNoS4U+7PG1uciIVk1Y1x179Yo9lrnPQQldkJVIYyJMvl+eeVxTlNSOBj5JZlz+nViEKz31haZzCIAOagcbS1OCNbI5+n5eBpnMFpxeATrriCPdADtwkTJlxaTL3Gfce5Dk0Aj3/84y/43HOdpc6cOcNHPvKRB2QtTdPw8R//8bvjd73rXfdpHRMmTLj/cFcJF1sR7p1hm3Cx3woBcvBpR7zfXu++YlVmG304O1M57qU3OLMeOdyMHPf+gvfTz8WsNjTO0FjDvBGizmoInFmPd+jFUpKUjMPNwIduXfH+m9cMPuFDZNlHVn1kXhtOzUpNWxkM0ovc8MZf409e+5MAfPqXfQuP/uwv4bb1QOcDOSXObAaJLw/i9tuX+VFX3JqsFTclozU5QT8EBh+KO624aPmY6MfAagz0PlA7cZtSWdE4Q+00WmtqazhoG6xW5JQICeaV4cRcHGkzMtfYqy22RLs7o5k1ZwXhIYswwznpKWaVpa1FiG+0uPlWTosAxEcUcNA49msR4zurWbS2iOE1JxcVJ1uZxVyxqPmkK+Y8/hELTs0rFNKT5AzHXdjNsXIW4fpeY3ekqLYyU+T2hAmXIR7UP5Xf+Z3fyTd8wzcA8LKXvYyDgwOuu+66Cz7/l3/5l/m+7/u+3fHzn//8S77GBytuuOEG3vnOd3LjjTdijOGaa67hyU9+Mo95zGMe6KVNeIhjS4LYkiLqUvBcDLbkiiEk+hB38Q3z+p7PvdxxKS1a4WNzv31MbAaJJ7jDOCVDRAr5M+uRTGYssQobnwk501iDc6q4QCViFlWCNYrVkDjeeBJQG401Gk8mkzneeHoXyREWjVix+gwhRrQRtr6Pmf22kmK/qNXbylCbSB8iVoHrNcdG4jUSUpw7oxmOPsrP/x/fxOb4DNc8/lq+4gU/jnE1dXGe2m8dmz7gjAw4lFJFMWDwMXPQlpg7hABWOyE0Xbmo8VGIaiEmblmNdN6jld4NCrYb9iBKZq0kszokGbjst3ZnIwzQGHnslnR0rtJm2+CElCGBT2Id5a0m5chR5y8oLuJSx61sr3Nvh3ATJkx48GGq7SdMmDDh8oFWSuKotYIodeU2DuBcpJTFBSpKtNvZ/kRqT4l+TsQoEWc+ZhaFiLIlAm3GgNWaWS3X70vdD3DUe3woj7GaPaN3ZCCrFZ2XviClshE/SG17Zu3JOXPQVru4bhC18odOr/nIsocMHznTcdh5EhlTyDlDlMi5BCilSEQ0UqMOEWYxUzmDUVLLuxJVp41CK6i1RuVMzokhyNqkJwjMqgZrithiiKy7yJjirqda9QOnN56/fM+f8v/8ny8kR8+V1/4vPP7LrmP0iTEJeSch5KFc1p1yJsaML0OYnDK69Ikqg9YZlbXU+hl6n4RspBQxKjKKptJ0Q9xFknQhkkZRXc8qu4vzOJhbukFcv6wV4UbKory0SrEOkeSTfHYyu/PWQ2BV4tIrp2mVvJdXzGv6IEOvZe9pKxkKaaV2MeYtsBw8LiqCUYwhctwHnFa4CMvoUSgWjSWROO4jMWUZhhjN4DNKRU60MmTxMXNrN+4IYClLT3bVXk1b3fVW6aWMlJ8wYcLHFlOvcd/w/ve//7zjT/iET7jgc2//2Pe///088pGPfMDWsnW+uv11JkyYcHng0iRcSJRcN0qdJgkXdy/YvSccdX5HtOrHSLfdT7897mX8sjOavdaxGgILHEMTOdN5zmxGfEwsaodSkijhQ2KMiWUfOLP2KKXZ+IBP0i/MnGJWOYzKzJ2Vni0k3v7G1/Gffvb7AXjSl3w9f+0Z/5T1IM6xWSlA4sadNuKKm8RtKsZEyBKL57TCF0dgaxX9mIkRGgtYRYqJgYQx0gvEIpafVZa9mSqOTJnG5VLvi6Aj5Czi79ZKL2kljaOympQ0CcVBozjceI77kdFLmgdk+hA56QwxU0QgGaUkvcKXOG5npC/ZayyVVTSVozLiCBUTGKOJSG+yGSOL2uKM9A0KuHpfCFxhK0zZ9r1a0VizE4KAOEVNpKgJEy5PPKh/Mr/u676On/7pn+a//bf/Rs6Z66+/nte+9rV8+7d/O1/4hV/IfD6/0/Pe/va386M/+qO8+tWvlvxTpfiSL/kSnvGMZ3yMX8Hlh1/7tV/jpS996V1ayT71qU/le77ne3j605/+sV3YhIcNJnLFneNCyEXbzebaGma1uaB7d3/f79UQdra3ICqKvkTtnVs89j7RVIYPn+mIOUGGrDIqS7QBWYOCdScRDiGejTnQRqGzEItijsycIYbM4CMhJ6xSLEfJwz61V9ENMiTovCiXldIolGzAlwJWot80x5vA8RhwCurGMq8NVgHDMb/w4m/k8JabuPrRj+Wbv+/fsThxkhggKXFfygm6kKgrw1X7Na2zmDK0MaWx6H2iNqJADuV4jInWbSPwpFnbjNIQ+Jg47Mad1H3RSJFtGlE3LDsv90SJletWreBKDEVT8sq3pKjl4BnPzWd3GpTF6jJUKC5iF5LPfinjVu7sehMmTHjoY6rtJ0yYMOHyQW21kKGsYfBJhA8572o8H9PO4efO+xMYQuBoI25EVitIGaOk51BZyPrIfrlE0xXHpXUvDk9DSiXmOZGRGt4HMEaUxjOr2WugMgZrFeteIiKOusDoJHJv1Xsa51gNvghLEp2X59gMnnUhdRkFPichE5F3JDCnNRtkAzyHgELIRaaoko2SzXKJjBOCUeczjVU4rWU4ERONs6gsDkozZ6gbI1F2JAYvDlcpQTdmznz4A/z+j1xHGDpOffJn8Nf/yQvQJZ6i1ooQM0kJMWy7xpAlPg9S+V0ovYRCXKKUFnetHMRNt7KGVKIrrNEYLWQorRXKSJTFEOT9bZWlSYmQZNN/Zg21MeSkmDUyaNpFFZLoCxEtJcOZjadyho8c9ew3DqUUlRPByOATtRVxy8JoQMQb3RjpfaIyGmflNWyKkGY5BI47z7IX8UZtDZlM7QymEKZCIeAppfAx4VNm5jSbMZAznJy5MmDJRIAxsmgsBzN3t6So838+7p+B24QJE+4/TL3GfcPx8fF5x6dOnbrgc0+ePHne8XK5vCzW4r1nGAbq+iGgpJ0w4SGES5VwsSUubWO8Ox+Z30uyymoIO1LUuYJjpaRvckbvxAUSXZcuaD/99ljUllPzipuOeq7Ya0AhDlBDKP3M2T33wUdOr0e6MeJT5LjE9u3Xliv2appK4704wnYpc8Nb/zOv+eEXQs486Qu/gid/+TexHAIuS51827pn04uYPOdAIpOzIiohN6EUzolT7BAi88pSGcWZDMMY8AnGbsRaRYgKPYrwYK9xrLsAWQhDtRX3qMqKOCFEua8hUYT/Qh47aC3dmDAaWmdYDoGuGLSGIAIVrTJWSS+ktCLFzDhmnJWeI6aMKmnnMUNC1BCDlx5W60xKIthRQAwiQnEmFbcpw5V7VkQ8zuyi3neCIIAibndF0HGhc7kJEyY8MHhQE6OUUrzuda/jcz7nc/jABz4AwFvf+lae/exno7U+Ty3wV3/1V1x77bXceOONu+J5a739qZ/6qfzSL/3Sx/4FXEaIMfKc5zyHV73qVXf7uD/6oz/i8z//83nRi17ES17yko/N4iY8rDCRK+6ICyUXbZnpfRC3owthpt+f9/tiVBRHnZfhh4+lgZBYispoUsisg7hCHXcBRWYMmY0PKBQHrcOWmIoxyqDAp9KcoGhrUTdXTmOU5qC1rMdQXqtiNUSGMaK0qNqtUegEY8rstZYxJBorA48QM0O/4ldf8k3c+uH/yalHfDzf9WM/z/6pqzjqQomqy9x42LMZAicWlVxTSfO10JbOJ3LOdIPEiKQktr611bQzw5nNSOcMrTMlMlAaKmc0Vx/UXLlX040RqxUHs+q8e7/9uveBMci93trKWqNYDp5bliM5S2MWggxN9lvHfuuIKZNzoDJiZWu04sRMGrdNsS4+xrPfuELC07tCv8SAX5K4lXM/U/fyIzlhwoQHIabafsKECRMuH7SFUF9ZLcrYlOlG6THWQ2Azno2j8CHRx0hOQmzyUZxfQ0yEIvDYut3OG8tmDLROiD45JfohMuZESJqYRPQRQqIPiWFM+BRx2tCNibUP1Fmz3ypsiZqojGxaL6q0i28YixBh2Uf2mkDMuQgIICXYjJ4zfWAzSA2vNcSsaa1EXYcEisyyD2iV2fiMUVY214EhJlTOhCTq5kZpcrEdGkLAaBGrRK9KDJxmf+5IUVyrei8OWzNnCTGV+5ZYn76J1//AtzKsjzn1SZ/G3/y6lzIYGdjmDEkJmUclUFqITBFZq1YiilBKCFqVURilxfWqDAtIClQhmqFxVtNYibOYWcWQQefMvDbEJOp8BSzHyELBo062xCTKblNJHzB3FmsVq05iDrWW5x1TJnSeK/ZqqixkulNzR0wQirPtXuNwRjGGzKJ2OBPpR+kbhxAZggxibl72DCGxGaPEF5YIvhiEIFY7zXIYd4KX2snrtlrTOnG2qoyQl/qQuHU1EDLs1wZf+rGTd0GKuMufkUs8cJswYcL9i6nXuG9YrVbnHTdNc8Hntm17t9d6oNdyX4lRN998M7fccstFnfPe9773Pj3nhAkPZVxuiSJbMTqcT4qaVYa2MndYW+MM85wvaD/9znDFoiakzC3LgSsWDZXz3HLcs+qLM2wWB9j1GMraPIedZzUGnFHMqooxJnIPkLltnXj/O97Gq7/vOlKKfMbn/wOe8fXfyelNgCwOThoRc3c5EJImZxFWNE5qcaMAlVmPiUHlXdRfF7K42TpLTOJklZJCkVnHSIxAIYOFmDBK0dSWSisqI3X4bavIeog0VlMbjTGwGYV41fvEGCIxJ5ZDRLocxVDmJWgRzFsl5CZri4gnZMa47fOKKGcT0Bp5zTmLQEQbuhjZRnqEJIL5k7OKtrLlfsp8CBklnYN89ht3+LsJEyZcrnjQd+tXX301b3nLW/jqr/5q/uAP/kA2gHImxsgHPvCBndvGMAy8+93v3jUxWzzjGc/gV37lV9jb23sgln/Z4LrrrjuPFDWbzfiqr/oqnvSkJzGOI29729t47Wtfi/eelBIvfelLOXny5EVZDk+YcCGYyBXn4/62aL2/7vdmDKQshJwLUVFsmfrrMbAepShXGvZKtvZR7znejFilGULAF1VCYw0JYfvXZSiy6hPGAEZjDZxsK1LOGKl8CTlzMLM0lSYnhU9n4z1y3rpfiTraaoV1kNAsGkMYe37hZd/OTe//cxYnTvFdP/ILfNzHPYqYhcAmedvyWsecWfWRk3PNmBJWy0b5dvAxhEAfRE1gtJKIiZSZVUaGT0aRsijiVRSHqw+fkXxwlQE0ISasOfunUqKqWQ+ZeW0LGUyx6oNEY4zy/GPJCAdYVHaXiz2GhFJZnKNgF79xIXERFxq3ck/YxgVuldb3lqw3YcKEByem2n7ChAkTLg/o4sbTh7hT6G5KP7L9p/fcSOaYSqxDEhGAj0JiMUphtdS1/Rg56kfmtaPaM4wxsvERbUAFcV3VWshC6+RF/OAScVT0IezcczMSXxBCBgcnZhUxZ5IRV6QhJjRQOcu6CxxuIlppUk5opcvvFeiGiLOaECWGbq81mBJB7Us/0FSGlDMhBpIWl9ecZa3rGMkobPnd5IxBF0W70Yr1IBHg4ti0dXIVN9eYpS9xStM4Sz8kwuY0v/qyb2Z15hZOXPNYnv68H8S2e3Q+surFLTcnyFliI6xVkBVOA2W4knIiJtmZN1qxqDQpQZ8zNomrbKUNKUkPVZmtu63Gas1hN6LQ1M7iQ2K/tcQswpTaGo77sIu8uHpRi5o/JYJXWKtpnQUVWZQhkdESL7jfOKoSN3648ey3jiYYQspYrbGVDEBqKzEpIcoQKyf4yLonxu28Qd53q6VPsruhksJHUZznlJkXt1+FXLeRDw5kidrwxWV3iNKnVQ/wwG3ChAkfG0y9xr1H3/fnHVdVdcHn3p541HXdQ2YtAD/5kz/Jd3/3d9/n60yYMEFwuSWKbIazs5ntjGO/tXcb7Xdf45cfsd9gtOLMeqQbxYlIozgaArE4FC17icAbYsIqzam2wlklQpMxsQqepOCW9/0Zr37JtxL8yCc/5fP4gm96McY6zJjRPjKrhNS0HAIkcf7NOVNZieS2Wu+i053R1E5TKU3IkJKI0StrGGMApxkTKCUR30qJe5YmUhvDaojszRyL2vHR4x5nxO1piOLcG7M4Ce+1TowAnOa2zYhSGYPi9Hpg9Ik+SUpIDImYM05rYkp0padURdhDljlMXYnL8F4lsdrdGFHOMORAP0ZxoK0slRbBQ5fEkcpqjY8iQJnX4hwVdIaUhaJVDAusFlHGxRgWTJgw4YHBQ+In85GPfCRveMMb+MVf/EV++Id/+LwYuNs3MFt88id/Ms9//vP52q/9WrR+eNvavf71r+cVr3jF7vjTPu3T+N3f/V0e/ehHn/e4d7zjHXzRF30RN954IwDXX389z3jGM3jCE57wMV3vhIc2JnLFWXwsLFrvj/vtoyhuG2cuWEVxZjOy6sMu8iAkqcLPdCP72YlawGpqlQCDsxqDpqlFXUCWYtUnzQkjAxWAcUycWlQyOEkQUmK/FNw+ZNnoT5qQEuMoHqgqS4zFvLKseo/TBmxi4eDnvvc7+cCf/THNfMG3/9CreOQnPhZjlCiVrWbTSwTI1jlqNXjGkNhvDVcumqJwzrvGxSqxjO2HQGUMSoHVMARNP0a00aSYUGWgkHJm1YcSA2iAzF7jRAXiI52Xe6+QQYlRiqPOy31Hiv4+JI43IyFlGqcZY0apjFaZ9RjIOTNz8nk5Nxv7nuIi7ilu5UKQcpboRKApzWVtH96/oydMeDhiqu0nTJgw4fLArBZiVFMZxpTKxnykrUTdG4pDaR+kxnVW47JhOXiWvQwArJGh8xgTM2tY94kQR3xKuxjrvcYxS7AZPH1MxFFYMHWtqLJDEehWUmf7kNDacDwEameotLgeObaEKSHQjCkLYUlpfAhURtS/Gx9JObHxEaNAaQ1Z3Ju01hhkGDCvLCF76qwZvKZyhpQS1mxr4EyKEFPCVoacFYnEflNhi+hBaanHU4beJw43nmtOzGitoaksIUW6IbHqPUO35Of+P9/I4Uf+koOrPp6veNFPkmcnWPeJaMDpyHpMKDI5y0Y8qUREZPn96DSMUTbonVbMakPjrETmJVFbS7yeEKzqynDlombmLEoLb8g5I7HmGU7MnJCLlMTObYcIWkOlDcteRBt7tWUIsq62srQlPuKglZ6isWYnyNEoHrHfFOV53BHu9lvLyZljM8rQZRuvtxq8DCIawy3LsCPmzWvHrDI0TvqmIYpTlSqx5n1IxBRoK7Mj8M0qy6KxNFozm2mGKL3VXiuErW6MuPbiaohLNXCbMGHCxw5Tr3HvcHtXpnEcL/jcYRjOO769a9OlWMuFukZd6rVMmDDh0uNyShRJxcUURIwMMuO4O1LUubgv8ctXLmqpv33kBIrbGJglw3GMhCT1MSqTksZrmS3UzhCzrFlpOPOX7+NXXvatjP2GR137FJ75rd+DsxXaKj5uT8QR696zHgJ7taMPaXejDBAykDJjEpeq2iisBpSi0rDXVuSkWPWelkqcZnuJr66MiNA1iMCjRNkte49W4qo7hFgceiX1Q1x+ZQ1nNiObQRx+xxAxWhGSiNFzyiirQCFiGjLZJ4iJAfl+2pKbTMYlQ1WLE/J6FNeuXCICQ+kxIwGyEQKYVtyyGqiN4ZEHDaOXXvhSGhZMmDDhgcFDghgFYof7NV/zNXzN13wNN9xwA29+85t5xzvewenTpzk8PGQ2m3HllVfyKZ/yKXze530en/EZn7FTgTyckVLiBS94we54Npvxute97g6kKIAnPvGJvOY1r+FpT3saKUn80wtf+EJe97rXfSyXPOEhjolcIbg3Fq1tSty2HLl52ZfNZMW8Enb9I/ZrrpzXzOvzi+774353o6hlL1RFsew9Y8i0zlBbxdFxZAiJvdbQWE3KouC2SLTDmKJE4s3FEamxck9SzhxtgjD+kY37vYVlUTuUgsoqbjoaqJ2mJjMEif1wVnPQVqx1QCHZ0q0ydENgM4ri4uNO1vzMy76Dd771P+Oqmuv/zc/yhCc+CR8TrTOEEDnV1jRWHK8qrfBFNT9zhnntWA2B29YDIeQdQcq6xKKyHMwqNn3gaD0SokUpJXnWKoNWO+JZLFa5RmlWfZC4jqJOABm8VEaGQ6NPhOL+ZLTilmUv8XlRVBhbRcMYImMQJ6lUSFFjTGzGwBWL81V3dxcXcXdxKxeKbpRBh9WKymoUEuMyYcKEhx+m2n7ChAkTHng4o3fRea0znC6b5LesBkIQxbDRCgU4rVkPgXUfCFlq8f3GYoxi2XkADjcenyLrlUTrmVnFwllccSvtRnncaoykJEQXZxSusGq8T4SUsEERjIgbFs3ZWlGhWDSWzovydx0CKDBKUVdSK8cEvpCnaqcZCrlLa0UmM0bEfRaFUxplFW2dUQpC0HQhorKIFrSRdcWUiVpIWWPIJCODmJREgLJw4nIL0pO0teHEzLEZFZ0fGbo1v/o938rNH/wfzE5cwVe++N9y4qpHsBkSvRtptIYsURIhg49AhiElTC5il6TIWXpAg6K2EmcXizPSibZi2QeskvfHacPMGWa1pqn0LjpvkQwhSY931V5NP0q/NK8sKWVu60ZSzLSthpyprWZWO07OpXa/ddnjo5Cq9mpHRqLutFKcmlfUzrDXWG5bjzvC3eATx11gVhkWjfQOvY+sh8CqDyilOO5G1qMnZ7j6oOGgdaRCCKtaQ+dDub+aMUgv7aP0qU1l2JTeets7jmVYFGLCIOsbC8HpnoZU5+JSDNwmTJjwscfUa1w8FovFece3d226O9zelen217oUa7lQYtSlXsuECRMuPS6nRJHOi2PtWATpqrjDXgzuS/yyRnHFvOLMeqT1luAy1zRzeh85sxm5dTngU0Zl6EJkjNKH9SFyy199iF976TfTr454xOP+Bl983Q9hXQVkrNKYSnPKKOaV5WgzsPGJ3I2orPEpoUpUuLGKKim0EVekmMS59ZF7NcYafEjMKnGW7QbPibmjG+S+OSPx3ruYuxK3PoSAVrq4Osn+/35tIWUaK8KO486zGSMJiVNPSR7XWkvI7EhKPmeSz6BE/EH5/IjbsLhOGS0Gu9oIWW1RS0xe56WfSFHi0m3paXfpHChuXvbU1mCtvqSGBRMmTHhg8JD8ibz22mu59tprH+hlPCjwxje+kT/90z/dHT/vec/jsY997F0+/qlPfSrPfvaz+dVf/VUAfuu3fov3vve9PP7xj7/f1zrh4YGJXCG4GIvWEFOJmhN3oowolGXvV4gyHznqJZrAaE7MKg5mDmf0Jb/ftjhGLZqKo40MNu5ORbEeAr1PVEZz1I0StWEknzqlTGUt80qK0MYZjgePtRqLona62KRKU1FbTW0Vs8rRWENWsKgNzhis0RLLsRHiUm00bSWDHKsVTisGr0W1PUrERh8Ss1qGAP/hFS/lLb/3f2OM5V9930/zxKd8dlEBOIxWzBtRPywaw1GnuHUpyrlHnWilGRkjMUGIgAjXi2IahphY9YG60swbyxAT3Rg5caLCKMVeY1kNgeM+UGY0QC4RelJ8L0psnsoyDLplObAeAlctxCJ81Yedk1RWhYTmNDNndzEn67HktjtpKuKdfBbuLi7iruJWrFEXpKIZguSuw9kGs7bmogYTEyZMeGhiqu0nTJgw4YHDorbElDnuPIvakeMocW6I0KqUb2zGKBHZCIl/r7XMiqDjikXFR48GPjx0kGEzJhIjJ+c1zomDqlbQOAtExjERoURQKwafSFmUv5XRGKNoK43Wii4kjMoonVEoNl7iqkPKtNZwMBeVrjOaw41nXivOrBPzytBHRULqdG00KE1KUf7U7NyHNAqnNdoJMSkmiEmhcwatSxy3YlE5Ts2tRPOljCxZIVIGaCtxXtq65DqrCePAr738ev7nu/471WyPf/C/v5L5I66hG4UQNK8sMUqP11aB1RAlmjAprJJ1SBRUgqxIZExxyoo5YZW4N8WUmFWa4CybQQYye3NHSnLvW2d3w4szK0/MCaUUe42jLuses0RWmMowrxzWSO8xL7V77yOLRlymrlg0KKQXXI8RZxRay/DgXMLdfuM4RoRA26jGyujSx29jGDOrMWK05tTccWpeY5Si82EXK946w6w2+JBLfKOWiHZkL8Ao2ReIyL3XWnHlrCKmMszwEWckJmR2Eb3wpRi4TZgw4YHF1GtcGPb39887PnPmzAWfe3h4eN7xfY0ivLO1nDhx4qLX4py7Q7TevcG3fMu38OxnP/uiznnve9/LP/yH//A+P/eECQ9FXE6JIkO5Rl9co+qPYfzy1q3KGo01msoq9rAYrbnxcMOyLwJoLwLsyioaJ/HSmzO38n9//7fSHd7KiWsex9P/5Q9impaUkHSJmNlvHfPK4kzCx0Qi0HkhP83QRMAHMGQaZ6i0IpCZVyLy0EqTk7w3zsgcblNJxN5e5c4KCICUwRrNnjNUldTmnfeEmNhrbCG/Ka4+UXOiqUjqLFlJK/AhE1JmVsucafASuZ2c5vTGo4zZJotjtcYZxUePI8pI/+iMIUXFQeMkpq+QmnJxyl00Vvqjxu0MCyorMenHIfKIfXO3hgXzLHOUTZnlHePZbxzrIeyIVBMmTLg88JAkRk24cPz6r//6ecfPec5z7vGc5z73uTtiFMBv/MZvcP3111/ytU14eGIiV1ycRet6CNy6GujKaxZiU+C49/SDRCWcmFkpXq1s2n/kuOe491y937Co7SW9333ZUA4x36OKIhRCDoBPER8SdWXYby3aQEryGK0NqRS+KSc2IyUmQaG02m3EW6OZ1RatyvAhZ07Na1kHirYynJoLMSomaWwU0DiN1Zr9xnDLStyqnM4Yo7BG8zu/8OP8zn/4eZRSfNtLf4SnP/MLaJ1hDBmrZQik1XbTHvZbhy+vP5EIUdFYzaK1WCvq8uPOc9z7HblJG1UaBEXlxDb2qBtprThh1VaU1VuCU8rSGOw1QnBb1JaT84ozG0+MCac1VaM56gO6KBkqa5gZxWYI+JSZVRarFTErtJbHpNIMrMfIQStRFrWV5muLu4uLuH3cyln1d77TxmF7/rZxAFHub5vdWf3gIjROmDBhwoQJEyY8FLFXW27TigFIwF5jUWRWY8KlLE4+SVyjDlq7q8lBeoFZZRlDZtl5DjuP1lJvHm1GZk5isp3RQsyxmrYymAijz1DISSjZkNcKiUSrHY0xWCDkiB9FLNGHSIxJakorG9ghiEvtevBopTnuPRnZJNdZQYIxJXKJY6O4tDqjyVmcZtEQAzhrZAABoBRWiQp63ji0UfQhUxmNNQpbdtyctvgSm7euZHPcKhFI/OL3fxfv/e9vwdYNf/87foS9j3sM6yFCzixqzYlayDvxuOeakzM+ctRz3AchXuVMSolYNvathpQVMWd6H6mNWFdtS3CrtbhmBan9F5XdCTGclQjv0WcWjSElce7tfCQraJ0MCpw2ZDIhZ/acBRQhpp1SeqsiP+5G5rW7S0elLeGu95H9xtEbiRcJKTMEEYocbkaWvbhGEUXcccW8Yl4Zln2JwBDVCM5oKmOoTHE0LkOszgd8kIFNHxK1UcWtS+OsobEGHxOrMbAoEeWzi/jZuBQDtwkTJkx4MOAxj3nMeccf+tCHLvjcD37wg+cd350o+96u5fbfu5C13Nd1bHH11Vdz9dVXX5JrTZgw4fJKFNnue2/3we8tweXexC+f61bV+8gYMidmFbeuBonOtoqs5NpGKcYkjzs+PMNrXvYvOL7lw+xd/Siecd2PUs336QbZs4+AjoHjLmG0FsH0EDBa+oOwJQzFTFMpmctYg7OKGDONs+w1jpzUzr13CIqcFQczzXEXiCVGbtHIXG6IkU0fMEZJxLnJpAFmtaU2mpBljnSicfK6ssIYhdHigrvXOIwWx0dy5mBmGT2g4GgIKKNYVJZMKmS2zKJ15JwJSWYuV+7VO1IU5b6GmAgxUzuJID9oHYdrj1KqCCeE1LZozN0aCWilmNcWaxTHnUTK90aiEzdD5GA2EaMmTLhc8KAmRr3pTW8CJAv6KU95yr2+ztvf/nZWqxUAn/u5n3tJ1vZgwetf//+y9+fhtuVlfS/6+XWjmXOuZu+CokBAAUnQYBc1D14PQZGQXAGDOQk3ih67BAWNJIqKJkgAEYgGFU+IgZgEiMd4Id1j7BKbCApcu6OIgXiQCNJUt/dea81mjPFr7x/vmHOvvWtX1a5iF9Smxvd56qk115pjzt8YY6693vf3fpuf2339mMc8hsc85jF3e8wTn/hEmqbZWeb+l//yXyZi1IRrigc6ueJqLVqXfeC21YAfG4RlH+h8IpUixX/OFOBkUGxCZohrzs4rDlpRTd9y3JP362t6vY82nkVt2YS7V1Fsjx1iIkRRDreVRStxVjrxkY2Pu1gHO9ol1c5QG80wbsCHJK+/GRKz2qDG9c2cobKGWknxG2LhcFaPkQxCBOtDJmU47sThaT1EYs5sBomF+LX/8K/59//yNQA854U/wJc9/W9IjEQpNE4Biv1WUzmxlu1DZj3kkSSWUWgaq6is4czMsepFrb3RiXntcFqU7yGOQxgU6z5SUPQhc+OeSEeckQbnoHU0zvCRow0hFWaVRishYrWVxRnNhY3nIQcNt696/Eiw27qBoYQQlnKhU/I5K2Njud86iUDxQqZKpWDH+7TfXize7you4qrV3+O8yceMT3n3GrXTu+zteW0nNcWECQ8wTLX9hAkTJtw/0Z1y0Vn1mkzGKMW8UviUCdlQWVjUDmdEwFAZLQKEsZ6bVYamMhifWDSWtY9c6AJGK87Ma/Yb2VjvhoxWYIzGksmj4AAUZ2cVaFEct87w8LMznFH0UZyM+pSwaOpaodBQpK8ZYhIyU8zkIj2MxOtpfM7iPhUhpIIxYu2qVUErUM7Q5kLnYV4rSir4MAojjKwFBTllstEMMeG0Yt5YiTFXipAzFD2uvbDsIx88t+Hf/ej38/tv/UW0tfy15/8QZz/t8fQhUWXFrDZU2gAKAzRG43OhqaVWHsZBTy4FVeQ+xCzEJKtlkLCoLYtG+qvKaOa1Y9l5cgXzMc7voHV86oPmhAg+JZZ9QGvFshNn3yFmlIaZEzHGombnRDyvLSlnQpZ7AOI4ZbQiJCFunV97hpjZH3vQ063hQSvuu+sh0jhD48yO3LbuI0aL4EUruR57raMZ2WYi/NAs+zi+78W+QSu1Ewad9EJu28aLK6Q/dVqeP28MyyEwjOKTXD7+A7cJEyZ8fDD1Gh8bPvMzP/OSx+973/uu+tg/+ZM/2X195swZbrrppmu+lic96Ul3e1zf93zkIx+509eZMGHC/QP3p0SRy/e/7y0J/t7EL592q+qCOE1tfOSkC3Qh0ceELnDcR1CFkKDbnPBzr/w2zn3o/czP3MhXvPCfMX/QQ1h2gY0PbELEasWidpja0PtEnxJDSNROaupaK1AFstT1XchURlHXhugzxkhP5CpNSBKbDbDX2l0KijWKojNDVOy1FmssTglJSivZ97dKyGJaKZyBvUrE/dZoVn3Eao02ipQLVmsaJ66wZiRaKZPIsXDQOJZ9JFNIBSqn8bFw0Ngxzg4Wld25y9ZOMcTESRcYRgKeNZp5JbGAGZkLdUNiCIUbFuKOla+CnFdbw6wqMgvxQowaYiJne10ZN0yY8MmM65oY9SVf8iUopfj0T/90/uf//J/3+nW+6Zu+iXe9610opYgxXsMV3r9xdHR0ibrjCU94wlUdV1UVn//5n89v/uZvAvCud73rPlnfhAcuHujkiquxaF0PkfNrjw+ZtZdM6ThuylZWIvL2GkuIhTLGBQwxi5NUzJwZIyVuXw7cuN9c1fUupdD7xMpHhjHqbkvamlfi6rQtXvNwxw3q0zi9idyPBKnDmRvJPo55k+lCpBsSJy7IZwLD9ioYo6ilGdXdAAEAAElEQVSV5HGfbCLWygAGhNADcDCTc6yMZr8V69IhJvbbiqbKaBRNlamNfJa6IVE5g47gY+JtP/8W/v0/+0EAvupbv5tn/O2vwxnNapBN+m0zVTnNXu042nhQ0iCVMg4pUNywaGicRBi2LrEagpz7ENkMiaaS9cVUuNCN97FAsYqjzkusxTZXXSsqrWmdRakERT7vZ+aOw3HYcNJHQko4Lb9HalS7dz4wRGkkYxGSlDMaqxR1ZajGe+VMhVJyX2pr8ClfUvjfXVzE3am/t5/v07BaHL22ZMa2MlP+9oQJD0BMtf2ECRMm3D+xrd9iKSwaizWw6hMFiRnQSmq5dqwpa3fH/sUZzf7Mcdx5FJa2Mqz7xGpIFMQZaFaJIlgbhe/DGM0twgJnFItRdVwK7DeO2mlCkBi1qDOxjIrlkDjqPaoo5rVsoA9BnFdjKjvxQMagSiFl2cTOJWO1RPd1SJ9gtGKvtsTk8UlEHRlxhXKWHZFmv3UiyrBSgzdjROCiNmwG2MSEK4oB2fx/87/4Id76s/8OpTVP+7Yf5MbHfSGxCDHLaihZXJl0zhJZ11o2WtHERMoWoxMpyXMooJVmyIrWgtUGqxUP2nPU1o4x2oaUE51X7GvHQw9rDmY11ShwWdQaox03H0M3ZA5bi495F3UeciFEaQRCEsJaHnuexhWGlKm0OGit+kBb27FXF/emZR9oneFwVl3yuRAHY81mSAxjtEhlJbrPGs3KR3IxEuOhFNZKBMZyiDvFPVw5wm5LgPLjsAdGkhrQVNL7VEbcg8vYv1h99XsH12rgNmHChI8Ppl7jY8Ph4SGPfOQjd7OEd7zjHVd1nPee3/3d3909/qzP+qyPeS2f8zmfc8njd7zjHXzTN33T3R73W7/1W5fcs2uxlgkTJlx73J8SRZQCysVa82qcnq6EexO/vH2vGAshZuaN5fZlYD1ENn2kj4WVj/RJ5jcp9vziq1/Abf/rPTSLQ/7KP/gx6rMPQRURGzDOP7SWWGlrwCeIUepkpcAZme0YLbU+QKaglWavsmQnM50+ZVRSY1y1CDNKLsQkkX5GaeaVRSO9RNdnCkVivMXUlgft1VzYBFZD5LByzGrL0Say15pdzW6V9JbbXtDHTBhdak3RrHxgNs7/rFE4bUBlNkFiuPsoxgE+Z9Z9ILjEetBsQhS3Yi0JJK0T9+IuJIxWWC2CjUxmUUn/2YfErLr7eUVbGbogsxAfJcK8C/eM2DdhwoT7Dtf9b2IpokK7Fq/zQMN73vOeSx5/+qd/+lUf+5jHPGZHjLpw4QI333zzx6z2mDDhNB7I5Iq7s2iNKYsywKdLSFG1FYJN68TlyY95yFLgmR15rA+JC+uLr3e88dy435CyueL1lrg+ibo7/S+l1YpmjPhbj5vCBYg6362Kog/y/Ji2rlhS3PZjJvbMSeTGhsgQM8ebuCMHpVzYeDAaNkMkA60yomAYVQBtbQipcGHjOdM6jkqhshpn1Xh9CxnICVylech+S+cDaukpzvL7v/Ff+A+v+X4AnvG138zf+sZvI6RCSKJmbp255Py392mbTe2jkKJqp3BG7a5b7TQX1gUzNmKxZGKCaDSpFGojaoSNl8ZPIZvz24EHubAMgZAyJcsFWfWRw5nbxS7uNaLcjlki+A5njpSkafEhY62CqMQlqnG7tQC735+jTSDmQkwZa/Qlhf/VxEXclfo757K7l1orGitq7i3mtb0uf28nTJhwbTDV9hMmTJhw/8Pl/UkpiCBCK2KyY3y3u0sF7ZbMNK8dyz6w31RYHUe314xPhbiBPEbn+QgKidWb147KQmst80bioPdq+fpCDjitGII4PK36yLJPu94wjJESG58IKeNjIWQoSfoRY4AClRWXK6ULe42lC+LEG2NGym6FohCSkH+MA2sMKRcaK8Ica7T0XpXBaonx01phbcHlTEjSg7z7P7+BX/v/vh6A//3vvYRHPuEprH3EFLkWldOELGKNvdaxqA1OC/EmZUdMHmUshYJPhZREKNRqidouSA9yMKvYqyQmbzNkYpYowARYa2id5hFnW25YSPz4xicOZxWzKosoJop717n1wEkXoRSGnOl6IWu1TgYh7Poe6VtqYzBKRB7rIVJbs4vpnlXpDp8NZzQHM03Oct23kXxalZ0DVjurhHQ3xnxf/km7sz/7zip8QhyKrbj1gvSyWilx6LKaEKX/vZphG1zbgduECRM+fph6jY8NX/7lX85P/MRPAOIC9f73v/9u4+je9ra37VInAJ7+9Kd/zOt41KMexeMe9zje+973AvDLv/zLlFJ2gsk7w3/7b//tksfXYi0TJky4b3B/SRTRSpEoUuOlIhF/94IIf2/il7d/avoxXSTEzLlVz4WNJxe4fdXT+8QQMqtNz1v/2fdy8//8v3HNnC99/qs5fPijMErRx0iIiZQUeVyL8zKD0Ur25ueViFMqI6SpbTSfVYpipObvR9fc7XxJNNwZozSzxoiLbsk01nI4c0ChtVYi8ZqMUqBQOKu4YVGLQ+zWabgSZ6V1TMQiKSFGK2IUhyoUrPuIs4q2FkexPiUqJ65ih3s1fUwsakuMhVIUx51nVmlihHWX8EFmVovGYrRiZg17jUMVdtHbViuU1hRGl6pKs51C+pi5TONxRejxnIZxFrKNUZzX9/RTM2HChPsC1/3k8e4K3gl3jve///2XPH7kIx951cde/tz3v//9EzFqwjXHA5VccXcWrVsnpyEK0z2mzKwynJlVl5CoFFuHHylyZ06GCufXA6shsuqlSNt4PWYd3/F6H208q0GcicxoXRtzQS61ZC37lDnbVswby/m1pwtJHIuMuVMVxbYZWPvAceeJubDsA6UUupA42sj39ltRGqeUWftISmXc1IZ57aSYD0ISqozYv96433DQVKQsjRJKCFPnVgPn1h6jFGdm4tBklLyfD3kXgfGe33sH/+YHvoOSM0/9yq/iOS940U750DqNc4bGGNypz9usMviY6IOQnVLJKNhtrG/voFYXN+O3X3QhodQ4SMgFnxIxZwoKqx1WiyNVprDxcUdwU0qxHqNIfJSYiq3yQGuJ3StFlNXaKg5bx2bMtl4OQZqR8T9nxGVsG3VSjTEgfUwsjN4V/vckLuLO1N9XwvZazWpz3Tm8TZgw4dpiqu0nTJgw4f6Hy/uTmGT4uHW4re4iPnuL7Ub4zBm02jo0ycDCjFLsEIW8U3RBI4Sj2mlqZ9n4iNHs+gMhzihqKxFvBcVm2ZNLoa01mz4SciFlqcud1iwqR6cCsTYcdRkfI7YYlFaQEs5odBE3VWs0WisGnxiyRGXHVHAGspYNclWgNhIPsa2pD2cVZxdO3HU1DL7QWMNea1n1kd/+pbfwX/7lDwPwN5/7PTzh//03ubDxGA3rIVHQNM5iS6bWstFvtMIaTe0M8wKFwrqX6LdUMiWLy1TO4jw7b6VfaaxFG+kltIooL72hsxqtYVZbaueYVVYiSoLEAO7v1XQ+sjnxWKvZqytKXYg5E0fXKJ/SGGmo0Qoaq2kqy9wZ6soQUua4E7EFMdPFxL4VJfbJGKEo0Yan+vrxfh62jpQlHn4I4nrcOlFe+5jJ1Xb4PQ6psrhYXanXUIgwxo89ZHWq36ms5vbVQG31TiyyHgLrwX5cB24TJkz4+GHqNT42fOVXfuWOGAXw+te/nle84hV3eczrX//6Sx4/85nPvGZr2b73Bz7wAf7rf/2v/NW/+lfv9PkxRv71v/7Xu8cPf/jD+YIv+IJrspYJEyZce9xfEkVqq4UMZQ3DGDM9v4pItdO4t/HLZZwF3L4e6H3iwnrg5uWAj5nj9cD5daByGlLmN/7lS/nQH74d4yq++Hn/hPahj6XzEeMMCoVSmlQiPo41vZU5j1Ey72hqQwjSNxmF9BYFKmMwWjMEWf82qSPmTBckFq9xQNY4pzmYVWjGtA9tuGGvZu0Tbqy3N15mWudWPZuQaKxhE+FkE9ifOSDjjCaNs79CQRXE1VXDuk+kIgQphYgdaidi9cNZTW0050K/ixNfDQmtMhqgyDFaK+aVpakMMWcqI+veqy1DEsfcVR+Y1xK/V/L2Pl71Ld+RobbConvrNDZhwoRrj+uTNXCNkdKYe2ofWJfj5OTkksdnz5696mPPnDlzyePlcvkxr+fWW2/ltttuu0fH3JM88wnXJx6I5Iq7smjNRVy0Qsz40Tmrtpq9xt3hnMvoU7Td+FFKLP73WyfOWyHTj1nHXYjsZXvJ9b5tNRBSYVE7hpDoR0eibW50KlBpTWM1IRcurD1DlPiJPooauzm1UXwa3RC5fe25dTkQUh5drqTKdEZjlKYbPH2QiL2z8wofMkEVYkr4VNBessY90IeM1ZqDmeNwVrH20iDZmLml6xlSpmS5Zr1PHPeBSmtu3K9ptGYxqnz/n3f/Hq/+7r9LDJ4v+JK/xt970St5yH4j6t/LGh7FGFtYyeftttUAQMwyLHJWYcZ7cnrzrbJKHK+UwqDoU6YLifWQUEoUDc5oKidxJEaD1uzu1xYpZ1abKMV7U43DGIkU3EZP7DWWanR8MkrhR9V3FSXawyjF4ay6Y9SJVQyROxT+9zQu4krq7ysNP1o3qasnTJhw7fBAre0nTJgw4b7C5f1JygVr1CmH24t1XBzju9dhFLPkghqdXaVDKTTWctBKHHcXZYAxr60Q+rUiJIlIWPnIeogYBXuVQ2k4Wge0ljq8IKrtXBlWgwguYIz5U6LydcawaAy10QwpcbTWVC4SYqaP4oKVc0ZbQwQapwhJ+hhnxJU2bkRUEHOW/5IMM5wRp9rWVcxrw4PmFQdz6bWMESeltpaN/Fll+KO3/RI/99qXAvD0r30ez/jab+GW4w6NOHBJL2W4ab9mSJn1kFgPkVQKeozsUzCuC0qOaITsZLUCa/G5MCtqFHEI2ezcxovz1UgkyhkMinktjlc3n4iTR+sMdSvOX0Yp5g+ybHzmuPNcWA8s+0jKIgSpjaayShyLa4PRhkVl2GurcZ2KyiSKE4GND5m1ClRGc37tOWgv618LpPF+rofIaojUVnrJZR8wRmGTDHD6cRi2dU32UdzA8hWGVIWyE+XYUb2txuuNAmsUPsLZWcWQpGf6eA/cJkyYcH3hgdxrPOUpT+Hxj3887373uwH48R//cZ7znOfwqEc96orPf/vb386b3/zm3eOnPe1pPPaxj73ic//0T//0ktd50pOexH//7//9Ttfy3Oc+l1e/+tUMg+zFffd3fzdPfvKTcc5d8fk//MM/zIc//OHd4+c///kTUW7ChPs57g+JIq0Td6LKimAhZiHJ35NYtHu6nx5SZjMkLqzDrsZd+8gtJz0nvcSDX9jIz0JO/Na//Sd88Hd+BaUNT/rWV/Cwx/1FhhjpfWI9ZBF2JIlF9zGSCxxtAs4ZZqNLUmstlSkyI1Fw0gdSgkDEWYvWhcpY/FZ0MtbUeSQtaSNzEGPk3GbVGC0+9oMxFYaSSFnqcKWgNlJfG4RwFVNmUVnOzBzn19J7KRRFFbSWMA2lIXp5vcaJGMMq6fec0ZydV1ROes+cMikXUpH51ay2WA2z2u1mHvut5czcsajF/ffC2pOLpHBUgEbtZnP3xC1y++flcoHRhAkTPvF44FXwV8BHP/pRABaLxSd4JR9frFarSx43TXPVx7Zte5evdW/w2te+lpe85CUf8+tM+OTD9UquyKPq9p6u964sWvuRoBTGpiCVIqrcK5DFwqjmVXr7uvL/rRvUcfRCYApCzNlmHTujMSYzr2XD/dza7yxbrVESJWelgA05M8TCaghAwYeM1rDXOlZ95MJGXIxOb1Dftuz54IWOXAo5F3xI9CFKoTtKr/uU2WskgqIPkZI1s9pxxmlWfWAzjPnQYwTGfut2DknLPtA4gzOK4z7gYyamzC0nPZ2X85rVlqQKtywHWqspBT7wJ+/lRc/9Gvpuw1/8or/MC17x48Si0AhR6eL9E4Vxc9n9c1rRAwpRXrhidkOi6tQmudFy7KoXp6jaasnmDpK1rZAYEIU0QjkXbj7u8OlitOKsMmyGRMyiljnqPEM0xJh50F59iduY1opZbZnVcv+GmJlVltUgWdoxZarLIiO2bmOnC/+PJS5Ca8W8tpNl7IQJEz4ueKDW9hMmTJhwX+FK/Ykd6+Ptz/sQOd5E1j7cUU2bxLnpwkb6D6c1la24YVFzqBQxSwSDH51wl32ksgZjFVaL8MAaCLmwGRKN0zuXo5gL59aeD13o6GMk50LKisZp5pVlXov706wyVFFTsqKOmsEnbl/J8SqXHRGnddU4qMg4CyUrcpH48S5kfEgUFD4korXURYHKZLQ0CkXhtLjNhpFA1jrLH77z13nDK76LUgpf+te/iq97/vcQY6EyikXtxj5AifvVGDOuUGyGRO/T+Hqyg++T9Au7jXaFnEcBq6DSCqPgeCMuW21lsEYRgqyHJD3CLSeesqd2wqNtz9L5RFsZSims+kg9RuaFLGQtDVStOEW1VjPbujunwknvsVqPEecSsVgZza3LgZQLRgdqa1h2EWvVnTpBhySOAKlknNUjWc2wGuI4jDJjzJ4MY2KW4djlQ6aNl2h2ZzR1JW5llRU3sPUQaZ0dIz2EBDWvDH3MH9eB24QJE64vPJB7Da01P/iDP8hXfMVXALBer3nGM57BL/zCL/CIRzzikue+613v4lnPepa4GY7HvvzlL79ma3nEIx7Bt37rt/LqV796937PfvazedOb3kRdX7r59NM//dO8+MUv3j3+lE/5FL7t277tmq1lwoQJ9x0+0YkiWitqK7F+rTMsh8jGJ6xRVxXBfE/301eDCEMAKqPofGYIiY8cdXz0pCemwrIb6BM4Bb/3ltfyx2/9z6AUX/otL+Gmz3wCMWcy0kOVkljHMsaNamIqhPG6taUwryx9EmeqRWMZUqGySuYupeADLLQ4+ZYiggMRR1SElCEXlILBZxpnaSvNYVthxvtx1HlQsGgNQ1SocjGBpA+JPmaMggftVcxrSfgQIwBFo6Tfw8vfEaM1RmXqStynNJAyaFU4O6soSsQpRimJyEORGSQ2r3Y4rcaUDcusshw0jupU76CUCB8kYSWyHpIIS06ZDlwttn3a9pCJhzthwv0HD/jO/dd+7dc4d+4cSik+9VM/9RO9nI8rTud7A1TVVQSkjri8wei67pqsacKEu8L1Qq7YsvqHmLgDGfwyJeyVHK7uyqLVR8lYHmJmSOMG7xXcjHIpu43zrUXrNvptm3OccuHcaiBkaSZShrPzCq1kM1yPKojGGhprmI0b6kMQ56VcQCtN62TNfUi7yIQu5rE4LSybwMEYwPzRo47jLqCQXOjbTnr6lKmd3l0D70WJ25M5bBV7jWFROVYhsRwSZ+c1dRVZ9xGipm7ksxFG69P9xjGrLTGJe1VUiluWAydDxCgtG93J8+C9BkohF7jtI3/Gi77lq1mdHPOYv/B5PP8VP4F1NSjFaogczBx7zZVVZ1tUxqCIlCxqAqMVKReUFUvXLbaqEGcglUxtzS7TOxcoqhCCNB4nJYwb9w6jtCjDC6x6aZCM1vQhsu6FaLcaIkopGSBcIcqwrUSJXjvJZ/chs+wjbSWDhu3naOs2JmsqI7lv/HxOcRETJky4H+OBXNtPmDBhwn2Fy/sTnzJ1KbsN3tuXA2sfd8/vQ2LtEyllchb3UwVshoRzmpwzNy8HUHDjXsuicuyNQ4+z84r1ELl9NdB5UTBfWIvY4dzG0w0JZ5REQ4z18XKI3L4c6H1GG7hhUY/OtRpr5D9nxri/VmG9omsrhlQ46QIpK4aY6HykD5mzKVMZtdvQrowaI9syuajRQUjTGIkGbK3ZCTQ0cDBz1NZwOPZ57/2D3+E13/dcUgw84SlP5xte8DL6IEOOXISoswmRptIczB1DTMSUmTcWozU+JUIspCTOtJRCotBUFlTkZIj4kKitoanNLjruYGbRiOLCaYOtRQHetkJq63xk2YvL7Jl5jU8Zv8mcmVW7GDtrNSEU9lorzlUqYLWmqQwzJySukz6wCYnaaMJGeo3WGWqnWdSO1RBpnQYUx5tAbRMpF3GuPT0USuN76ovXPicRHKVSmM0cVdbiPjWISGjr4ht93rnkVlbiNLqQON4EABa1oTIaNzr+nh5SPXivFjV5LrS1pa35uA7cJkyYcP1g6jXgGc94Bs973vN47WtfC8Af/dEf8Rmf8Rk8+9nP5nM/93MJIfDOd76Tt7zlLYQQdse96lWv4nM+53Ou6Vpe9rKX8da3vpXf+Z3fAeDNb34zb3/72/nar/1aHv3oR3PhwgV+/ud/nl//9V/fHVPXNT/zMz9zjwTiEyZM+MTiE50oMquFGNVUsp8+hMxJF5lV5ZrGLx93YZfY0XtxxzrpAhfWnhAlTWLlA+uhYAz84S/9W/7ol34KgCf/nX/In/uip7LqA0MupCSR21vR9RALWmWkei67fiGmzEnvOdM6QJFLZj0UUoSSJJGiD4mZ06AkOi/EgiKSkzg56aSpK8WZmWNe29084vzGE8b5lY+FVRdpK03I4mSbS6H3icoqjrpISApnwAZxfFIK9mpLp8UowKpRjD8EVt14XSslopUs4hs3RpH7WEhKxDxGax6yV4vTrTPj9VcjWUzthBPN6J4Vkjgeh5RB3dF04Gqwdazd9jr3JHpxwoQJ9y2ui+79Xe96F7//+79/pz9fLpe88Y1vvOrXyzlzfHzMu9/9bn7mZ35m9/0nPOEJH8syrztc3gB476/62K1N7RaXO0hNmPBAxWlWP9z9hmofE31Ml2yo3pVFay5iUZrHL6zVVyzyh5glUkEJQUcpaQriGNu28ZGUi2ywR7EVDUmK5ZMu7IhPKUsBud9aYiqcdBfPLcRMnxLlsnPTSpj/Tiu6kPjQETSV4aQLHHeyKXJ+M3DSR8Jok+o0VM7Qh8RmEIKV1lBUxnmDPTQ8/LBl1UdUgcPGse4jfmwInNGcaSv29i2LRtTNx10g5sz50QL1oHFoLfektoYCzGrLyfnb+P7nfhUXbr+VRz32cXzPj/wrimtYDaL+AD9G/am7tMk1RtQUQ8xUVuO0nM/ssgZJjVkklZMmLsSM0oraSiHfezCV2LM7K7Efzoj17NY1qrZ6N2TysXDcR4z2zBtLFdNojXvHKMOd25RP7NWOJUEcw7w0GG6Mi1gPEZ/yqCLJGC0EvCkuYsKECdcCU20/YcKECdcXLu9PQNEHEVLcdtzjozg9rfvIso+EcpnLTpIa/KSLmAEOZ+LSc9vSkwt86g1z4OJmcy5ChAForMXpxPHGS/8REl1AlNpaYxRcWAdiyfRDpE+Z3kcefnZOYwy2UsxHdfa8tjTOkErh7KKm91EcfsfYvy5kYomE48yilrjxlGHZi2I4pgJK3JoO5hV7tR2dVgszJ+5USktkdUKINh/+k/fw8m//eoa+4/P/tyfzbf/41fQZuo0n7BTbhXUfOTOvSRkWtaMbIiEV6kphk8GPrlA+ZdrKEpLnpIv4EKm0Qlea1lkZTiip6Zsxcr2uRB1eivSEB61jE+KuR8kFOh/IRdyBY0psjZIOZ460ypwUEVlkBQ5FUxv2aruLaIeENeK4FFOhmWnmtWPjIwo4M6/58FHHEKQPcWOMyF5jd2KMrQAo5jLej8i8duDFwbYPl/YwpRSWQ8RqibsLUZx0xTVXhkcFaJzmoJXo8YPW4WO+4pBqr7GEWD4hA7cJEyZcO0y9xn2P17zmNSyXS970pjcB4hz1ute97orPVUrxwhe+kBe84AXXfB2z2Yyf/dmf5WlPexq/93u/B8CHP/xhXvnKV17x+Xt7e7zhDW/gi7/4i6/5WiZMmHDf4hOZKOKMZl5b1kNkv3GcIAkOdxe/nMY6WWmJlj63GpjXlmUf77DW1RB3pKiTPoz1NaBFhL/fivghpYJWhf/11v/E7/+HnwDgf3v23+czn/RMYiksGgcEVpkxRUNqbKWk5i9FCEkpgx7JSbWxVMZgDJA0Gx8IRQhNY5q39CyksRcEn2R9e9aNMw4hFW2GhNIXkzCc0aScOeqCzDisIWbQudCpSCJRisUqRcgJo6SX2m8c5zcDqz7QhTw6zyoiGacUbS1kK6s188ZIbV4ZameogyGVhA0GrSSer61krvGwM+1dkpQqowkpUWm9I0ZtXXXvrDe4HLmU3fXZGhZcKe1lwoQJnxhcF8So//gf/yMvfelLr/izUgq33nor3/AN33CvXnubC6qU4hu/8Rvv9RqvR1xu+Xu5g9Rd4XKHqGthH/y85z2Pv/W3/tY9OuZ973sfz3zmMz/m954w4VrgDqz+IJnXd8ApJWzrDE0lg4ZcCvuNu0uL1jIW/CC5ylqJO9FphFR266jHIYAb2f3duAFcimysb0JE9/JvoNGygbwZhCBz0nliLtywqMShaizIhzHO74rnhpCjjteBthZ722UX+JNblwyxUFvNufVA5zPdkKmdwmhxTFr1EZ8L1irqylFZuY4xFW5fDmyGxJmZo4+ZeTGcmVeEmBmiobai4vYx89GjXpj9CiH9DHIdqzEyb+twVVlNvzrhHz7nq/jwB/+Uh3/qp/GT/+4/0R7cwJ+eWzOMhLG1h9tWomi/M5vcXAp9ELKZ0opZZamcGu9HZuPjzpGpMpqYxFGrtgYfAyllYoLKyT0ISYZBi9G6NeSCs5qZsxy0QkhaDXGM5hBHp5CF2Ha0CTxoUXPShytGGc5rUXsPIbNXOwYj8Rwxix1uH0SNUoC9RuIJZ86w19gpLmLChAnXBFNtP2HChAmCexu9/YlYx+n+ZBsvsPFpJwq5fSUkIwCNCCMaazBKMaTEhY2ndopUCmufqXShrgy3LgcWlZH62Upf1I916m2+ZzUE9LiPbJTihoW4DK26QEyZpQ8cD6JYXvuI0op9LDkX+pTQgyiIGydrKchG/RAS88axn8S5SSmFUoWYEimKUMP2BmtELAJyTUoEU1lx1HWWtja0zkrdrCCPvVgphY9+4E/5ob/3bFbLYz7z876Qb3nZj3OhL6QcKapQGc2schyvA7NaSE0pZ4YgPVWl1ChSUGhdqCzEpDjpJYa8rRRaGRHNKIvREl130DoedtCitWITEn0o7NWGRV2xaKSef9BeTSqFTR/ZjMKZg9aRkuL2dWRWSQReH8ZeIWXWW5cuI/F5WmvmVlFZ6e3U6H41r0TQE8eBwLy2rIYg60RU14czt1Nmb9E4w/yUuj4XWA1hF6E3pISN+pIe5nTv6+NF1+Q4Cn3mjWGvETJU6wwhFXy8SIo6LfqYVRYqPiEDtwkTJlw7TL3GfQ9jDG984xt5+tOfzste9jLe/e53X/F5T3jCE3j5y1/Ok5/85PtsLTfddBPvfOc7eeUrX8lrX/tabr755js8p6oqnv70p/PDP/zDPOpRj7rP1jJhwoT7Hp+oRJFFbUlZ6s79xtEbmbNcKX45pkwfMqmIaHmbFrEVMG/F6ds0EWfVrqc6TYqaVYYuGPZax4VVwBmpPz/42/+N3/6//ikAn/cV38hn/JWvYu0jVktMtdUapzOt0yxThFIwY3pIKUL00apgx2i5uTMoVTBKobQ48MahEEloJYHfBZmrnJk5Gmu4sPGEBNqISD6mwnEf2G8czkisduM0G59YDZFKa27Yq3FakVNhFSMlKZwxo8OvIqbMAISNpx6vW8yyzkxhPSQWtcFWBpMKIE62s8pSSmFRO4m7tpoPXeiIRfqPhNyfJon4Qps7r+MbZ8Y4b7keKDEtqBWX9C13hc4nSpH47WoUg1we9z1hwoRPHK6bqebW1u5avt4WSile8pKX8AVf8AXX7PWvB+zv71/y+MKFC1d97NHR0SWP9/b2Pub13Hjjjdx4440f8+tMmPCJwJ2x+sWp6WJ0w+VK2OUQ8Tmz3ziJr1OKRW3v1KJV4vnGjRhG96hxe38bebZdR2X1jtGec2abbuFTZtkF1kMkjnaq2+iAk01k4yOlFFEoj5vQqyGyqB3LQdS523OrtueGFKghZQqGVa9Z9aJetlbzkaNeWP0Zzq17UsrMxyiHC+uBTUho9K4Ar6whJYk5UCjOrT1Hm0CMmaY23LaMOKtZDQmjFXPnUAYqK+5YQxRG/+CTRFAoGcLUVvOgRU3MhaOTJS957tfw/j9+Dzc8+CH8i5/6jzz4ITcB8NCDltuWPX0oqDFmYj0YPnKh44ZFfUUVSEyiXHjwopahjFLMa4PV+hJHJmvEijVmGchshgxKsrpzgTIqOvZrS4zSjDgtA4bWyecojiqJ2mjqSu7RopJGYt2PQ4NRpbHsLkYZbrHfONZKhlm1lUHX1gFs00eMUhijmNUy0LrpoNmRq6a4iAkTJlwLTLX9hAkTHsj4WKO3PxHr0Fo2q5vKsD+zHG0Gbl324jjbB9lkt0I0WYz1t0Q0ZEBxZlbzoLli4yPn1p4MrPvEXmO5fR2obYei4biPxJhZ9oHVkBhSZvCR2hkWjQwkVoM4CRmjMBvNxheOvSfmjMqakAsnQ0BriQFvK02Mls2QqK2mCyJi6fwYvaYVWhUqa8gpo6ym0pqiC1qLulirhLUWjYhOzi5qHjSv2G9l838TEhbQlcS4ndx2Kz/ygq/j6PxtfOpjP4NvfcXr6bJs2jujqYwiFShZYi6s0cQx4qKyGq00PhSc1qOqW6Kya6dYUIjJoHFkCssuMERRgh/OHLPKsmgdORecNVRG0VaGeWVF9DCqqZVSHLSOVRe4ZTnQ+SLOUYjrVNjFuJfxPA0bH2grTT1u7uci0eu1lSFPTvL3XaGojMIayxATQ8i7/rSx2974jp/JrUvvdjhy3AVco6mcRhVFzJnohehWz4RQd24zMPjEfmMZUmLlEyhFZcXdzMeMdopFY3dDirYydyr6+EQN3CZMmHDtMPUaHx8861nP4lnPehbvfve7ede73sVHPvIRjDE87GEP4wu/8At59KMffdWv9Wmf9mmXXOd7AuccL3rRi/i+7/s+3v72t/O+972PW265hb29PR7+8IfzxCc+kbNnz96r154wYcKELQ7G6O/1IALoxpk7pIV0IdJHiSB3VsTRqyFQG3FUOtr4O6SJ3LoMGK1EUDLOXfZHYXQ4Kew1jj871+GM5iN/8Bv81hteDsBjv/Rv8nl//e/Sj6T/ELfOTvJv6bxxO7F1iAWnlcwZrIjvjdZowBfoQsYnL85SQGUNhcJ6CBitcQX2xgi6Retw1jCkhCqKUjJay1zHmot/g5e9CGdqo7nxoOFMW3HzcYe1mjgU+pyIsWC0EMlEKCMR4xufqLT0fc5o0IWNT4SUuGm/JetCjIWcRSzhY2a/ldlZLnINZpWBUeSw7AJn546NT+y3d95Xb8UPnU/S7yjGJJcrRyZejtNx3W21dYuaRBUTJtyfcF1NNu+sOL6nRbO1lsViwad92qfxhCc8gW/4hm/gC7/wC6/FEq8rXK6Q+OAHP3jVx37gAx+45PE9aXQmTPhkw3ZYAHdk9V8pZ/pyJewQMicIo16GH/pOLVr7kFn2QsKKFJJPbFwkaEPIeffv4VapKyjELGtY+ygFexInpspq5q1lv3Xst3bntLT2GR8TuWRKkdfZ+F6Y8rDbSL783MS2VBTCHz3uWfaJ/ZZddMOty54hZha1Ze0Tqy7hc2LwiZwTba2ptDQVWcvGeCnSXGyixLsJ8Sgwd/I+lVVYp6iNQSmNTxln5NgLMVIXzaJxtNbs4t9S7Hnld/4d3vuu32Vv/5Af+smf4cEPe+TuPM7MKzY+EbPHGmkStoOdzqdLVCBbzCtRaVfW8OGjjjwS3oxWbEbXr5MkQ6P1ELnQBXxMrPpIKZn2sGFmNIMXRUflFH0szMZhTGUUSilR5nv5nNywqCXKwch1bytLH4RIV40F9/l1oKnMHZyu5rU0G93YPDirKYA3mb1Ws2jsSJqSxmaKi5gwYcK1xlTbT5gw4YGIaxG9/fFax5gSB0g9L8pgiXK7+ahjOUTWXeRC56mt4RFnZ8ycIafCkDIx5x3hahvpvGikHr/5pB+/r6DAbStPyLKZ7GPeuU9ZpbC1ozLifnQyRFCK1klN2jjNg+cVVsFxL8OHIWVuX3o2XRxJXBpn/M4xSo8igBgTx51niJl5beUaoGmcoqkMlZZoOKUUfZ134gFV4Oys4sH7DY2T+viMYozSMBxdOMcPvfAbuP2jH+KmRzyK577iJ8muxWkNJpMTKK1ROWO1qMDPrzxZFdZecWEd2G9GByOgUNhvLOshSRxE7VCqEAL0SZyvFkhUw5m24nBWceOiQWmFoux6l9pJjN6ZWSU9yrhp77QITjZBBDIpFoagaWvLonakUui9CHDs2KeedlGK4wAm5UxbO+aVDII2PtFUln58n5kT1ffOAfku/tzX1rDfOnzK9D5xMKtG9yhxA9sMEVA4qzg7q9nYyEkXscBBI58DpWC/qXBWcdhWzBu7+73aYhJ9TJjwyYup1/j44fGPfzyPf/zjP9HLwBjDE5/4RJ74xCd+opcyYcKET1Isaktt9U5ccjp+edkHXDY4Yxhi4mTjUWNiiDX6YvrGqTSR2soso0REJL+NhLOGjY/Sm+VCyIk/+6Pf4q2vexElJx7+hX+Vxz3zW1nFjCoSz00RR1SrFEkpQiq0VtJIUi5YLf2A9EKaSitigd5HzpXMvHJYpSTyWoP3Ga1BFSgK9toao+RxbaW3s1YIXU5rYiks+0SImcoZSob92nJ2UYspQBBHWK1g3UV8yNSVxhpNpjBvDDNnqKxi7RMpSz2/8UKOMlqTc+GWZU8fIj4IgWyIicppln2U/rOII7ICHrTXcNQFlILOZxSe2Shkvxx5nNeFbUxga2VWEjIhFtZDvOKs7/SxV4rrntWTW9SECfcnXBfd/4tf/GJe/OIX3+H7WmuUUjzmMY/hj//4jz8BK7u+8Zmf+ZmXPH7f+9531cf+yZ/8ye7rM2fOcNNNN12zdU2YcL1hM1yMzzvN6r9S5NoWp5WwJ10U0pNJYtc5JA5m+ooWrSFmVlomFDEWuhDJaozgUwqrFHVldk5RzijGmcKOFJVH1n5TaRaVZa8SVfFeLTF1zmhCHPAx0flCLJHK6B1JS2IP7vrcDkaF8lHnOb8J8p5jVJszGsZMbEUZYyCEga+1KHvnlcEYTR8yfcxoBd4XVv3AMESa2kJOPPig4cZFhdEaqyEWWA+FUkTtXBs9qqGl6C6lcLzuedX3PI8/eOfbqNsZ3/Mj/4qHPerPMYS0Y/JrpTgzqygUjrtAO0Zv7Ldud12vNLg6GdXajzzTshwiy15UFT4IoapPiZIYhwviFgaZouHccpDOArl+nZf7VBkhLG2bmK0afxtPYY2mcXrn4HV27uhDFnWH0/go8XqLutyheHdG41oZHBxtPH2II7lLbGi1ggfv1buIxwkTJky4Fphq+wkTJjxQca2it0/j3sTx3d06tvEP4oqaCalgNDtnpHUfiYjD7MkQiDljsuKWZc9xH6itRqEkilpp5o3Uq7lI7X9mXhFS5riPdF42zlGQSkZRWPYSe2CNAqV3seCrIYIq7FWObUnbR01TWw4VqDFaOyNurrdtPMdDpLEapTStU/SpCJknZEJJpAyNUxgMxyVwxlpuOmwogDGK2gjxpwkZYzWHbUUZ3bQohSGIKnlRW/Ybx2a14kde8I185E/fx5kH38Tf/+F/w+zMDWgFqSTWvZCIZKhiGGLGaj1GRCiizpSsOO4iQyzMG03vC62DppbIcaVE5T3YjOoVjRFnr8NZxV7jeMh+zaI55YCkEikXKiOR3z5mzs6rnUjipCu773cx0VaW1hmcFnetzSBRg7UTtlzKZRflocbPWW0l6juXgs+ZHERAZJM4JSulqJwmDml37+5OdN1WImw5KRKbuKgdRoMy4wAlF4YoynF5vsZE4fLtLWr2xh6mcZq9U783CibRx4QJn8SYeo0JEyZMmHBfwhnNwUxfEr+87AM+llF8IISmRSMOt3eZJrLyxJJprWHdR0pVuGEhyQ8+ZlZD5GgTuPmP/5D/9E++gxQ8j/jcv8xnffV341OhdIFZLcKUUgrFaOpGEjhOepnJ2DHOTVGwRkMBp5WIKKIIWXRRaMrYr2m0EkJPwUhvlgpHm4Gz85pmTK1onQjEJWpbsR4Cyz6KyFwViVYfI9m30d1b91+lwGgtgg2lMFpmLTEXZrWloOgHEXtvSUnGCAlrtY4YLWSkzRhnuGgMqkis36zS7LWOlAsbH3eijZjl+R896jlo3RUTQUoBazSHo5AEIFUZo0T0IUIYfafHwh3juqd+Y8KE+xeuC2LUXeHeWqxOgMPDQx75yEfunKLe8Y53XNVx3nt+93d/d/f4sz7rs+6T9U2YcD1guxkL7FTNsyu489wZxGFJijLJXhZFQc4WrdUdLFpvOmwoRYrUlAohZvIo9N66E23RVpJfDQWf8hhjAZURRyar9M7WdZtx3QWJ82ucJmFYdhGiog9pzFXmLklRWygUzsjgoPc9Xcj0MVIAawCtWLR2FyunlKJkMFoIW1pYTKgi34sx4Ys0GjFlHlpbrJEN+NoZbljUo1NV4ZbjnrWPrH2kFAgxc9R5GqNpK8tPvvJ7efsv/xzWVTz3B17Lp37G59EFIZ0Zc1HF4axiXlkU4+BhJCE5ozi8LJpOzlmcpoZRSb0JUaLshgEzErNykqIdtkoCaT6WmwhIdGFlZZNfq7KLVRx8oU9pd6xSkkt+fuUl8q6y+LxVzcv96UPmoLaAEPa0upviHcV+W92heJ8U1BMmTPh4YqrtJ0yY8MmKax29fW/j+O5uHSFlQpSIhS5kLmw8QxjFFYB1inMnns4n4hjlLcpfhfeFwUcqp1nU4p5rtKhzV0NPbSz7rcTsPfSwJV3YsOwSh0BKhePR6dQajbJKoh1S5mQ9sBkiucBh6+hjYt1FYiloLc8JaRv7JopiqxVWK/qY6ELEKsNyuHiOZVQrKxQhg08JpxVmVEgvasvZWYXVcl+qSrHcRIqSOn4IhSEWKgsXVp6TztPowo991zfxJ//jD5gfnOHv/MDrGdozhHXAJ1GUF+BB84ZFa/EhoSsLPmGtFkcko+liFueslNh4GRqsPeQsvdSicWgU89rRVoZNyJAKbWPYayxtbTBa7UQWBzPHSRd2vZGzQjSb1RbXipCi5MxtS1FIH7Ru19s6ozlorYg9khmFGRLPF0ZXsOgzMUsfsx4imz7SjLF922iPympiGnuZsWe9O92FHte/V7uxr5XvHc6qncNZ7fQdBCvWSP/qo0TuzSp7t2TBCRMmPDAw9RoTJkyYMOHucLXCk238cmWlD2mc4aQPu7nQ1aSJHHciANgMCaslajvlgjYSu3e88bz3PX/E61/0zYSh4xGP/0s85Xk/wDLpXX/kYyHkLG5OCoaYCaFQRqJQyZnt3MGOfVJlhPyUtDxHam0RSzsjMxGtNOe7AV0kTSNR6EOk94Yze4ZZVRFzZq8VgYg1M25b9qz7yEkfCXkrssnkXDBK7b5eNJb9RkjL+62jIOKcYZxTSOKJEJIqpzi3jqBg0VisVfiQMaP4vjYKpzRqPC/GSMLKCsGp9yK+sVoitYeYd/9djtOR2yd9QKNYNDX9GMMec7mqY+GOcd0TJky4f+C6/q3cqj+mjOh7jy//8i/nJ37iJwBxgXr/+99/t7F4b3vb2+j7fvf46U9/+n26xgkT7s/oggwifNwqYS/mB18t2srsVNo+StHWBYnLgDtatO61jiFlyYHWEimRspClrBJC0rZAP9p4AIbRxtNoRR8iQ8zMnNm5SzXj89XIltmSZpzRu/iCvdZJpFwud7uRvM2y3m06a9nE10GRYqaqZLPeVIohJhorSu+U5BokCn0U16OUMptQcCiUlY3vXCBT8CGxHiJ7jWMIkoPtUx4JV4njLo6KZg0V/IfXvYJf/9mfQWnN//G9P8xDH/eXuGXZU6hZ1E5IQjHTVhctVWsnUXLOKOa1kM22KoYrNUWrIfL+W1es+oQ2CqthPSRWg6g0tNbkLJ+dwUc2PkvzosFoaZq6kGmdQWlFymCtYmYMIUlT1odMTIG9RuIlXMrMK4lCdEYan5gKqyFwOKtJWRwHpuJ9woQJ92dMtf2ECRM+WXGto7fDKdEDXH0cX2X17rgrrWM9RFIGZzW3r3rWo7tPLoWTLpAouEFco4aUWHYiRqhGhygt+9D4lFj2UnMao2i2bqQjSepgJspZId0oFIxiE4luqK0IGjovsXkxa/qgSSnxwfNrNl4ci2qn0EqLkKIU+pQ52QRCFveglAs5K6xVZDIpcLHP0WCMJsQxMiEmjDY8pNGkVMgZNPIaxqqRnAMnm4BShdpK3e98YeUzKUb+wz99Ae/5vXdQtzO++eWvwz7o4Sw3kXktSuqQYK+xlFK4+agXRywgxETJ0lf0oVA5gzGwGhKrPmGNQWk5Z2scRin2WkdjDcveixiiwP7MceN+zYP3mjt8ppzRu0h1N0Z2zMafKSX33GjDopbrXxACVlsZChKl1+TCSR92PW+LGXuThI+JkQNF59Oo6BbBB7AjyAE0RvqN6irU05XVDDHTOL2LO1Tj909H4p2GAs7O6skRasKECZdg6jUmTJgwYcJd4d4KTz6WNJFFbTjaSNJE7TSLxkoPWCK3nAx8+AN/yo9919fTrU74lD/32fyN7/oRiq0wIZNGItGW1BRToQ+ZmRKn3kRBiUHUOE8pGK1ZNAaNiC/2xrhunxIhF2qFCLyNRHI7o6icHF9SISYYciJnSDlz436N0TKHSaVQW4ObS1PoU+JMW0liSh/Q6uL8xGi1m2c1ToQoIQmhKRWJBewGITSFLAkXtTUS02dk1lRbxYP3ag7binY0Kgij47FSMuuYVYZKK25fe2pjuGFRkXOhdvpOe+ctHnrQAuwMCxpn7rbv3mISm0+YcP/Fdf2beSVb3An3DF/5lV+5I0YBvP71r+cVr3jFXR7z+te//pLHz3zmM++LpU2YcF1gSzDZKmFrq6+YM3xX2Cphh7Gw2m7+zuuLzzlt0br9uRSPjoQoltdDYlZL3IBWii6IY1LKEmcwRFFGh5RxWjNr7EiK0qci5CAhBV2MojQISQpSjUQlDGO8wl0hxHED3Ch0gZwlzqKUgtaGs4uKmAqpFM7aancttZVhSIiJwWfMaPRaO42m4IraKZ2PN54b5nJsSFmu+5ghvfaR204GuiDRFNnAr/z06/iVn5Z/v/7G33spn/6XvgxfMlXWHHWB9ZCwGvbbis4nlEq7a7K9TxIvp3jQoubOcNIF1kEGXzFlVj7R+zF+whpRrge5hn1IKKSQbpzBKo1RYjdrlaI2GqtEtV6yxH5olYWQl2E9BGKCEAqN1egkDgLago2KIYpl7F7jODOvpuJ9woQJ92tMtf2ECRM+WXFnm+XbiDg/ui6VMfJajxHJbWXuEL29dTvab909juO7fTlI/LZWd9i0Xw+Rfvzebcue4y7ImmNGa8XhTJyajJZavfNC9LdaUZLET+dSmFeGvZklZSGotNagx/g1ce+RDeVVHzmcOW5f+l1t3FaGh+zXpCz9VSmGlDVdn1htBrqUWQ9JxBN53DxPHo3U4D5lhlzwPrH2hbYSd6qDqkIrOReybPQPIVORqYzGaCFDlVLISO+Vc6Eo6VdiEmLQfm3ZDJGNT2x6ccTVGlJM/OxrX8J73vmrGFfx17/rR5jd9FhWg5C9bln2Y8SDo3WaNYxRdIrVkEklUzLUxqCtDCmctbR15raTnpAKZIkN39+3tJWlsbI53wdxAHZG7cQdV+pHt6S4krfutRd/ppSiG/vamKRfaKxhr3FjhHdhCB6jJbp96xTWOrOLHF97Ed9QwFWGPmQWtd5FSvixF7Va+j3FRafbu8L2VLaindoabphX9zg+csKECROmXmPChAkTJtwZVkPcCVng6oUn7Zj+AfcuTcQZ6fmWfWTwCb1QnF97Us6cv/WjvOLbv4bl+dt58CMfy1e/6J+xf7DPSR9JJUnvMM5wdIE8Crl9KuLqOooWyNLnVMZyprEUCm3tpC9UmraChTI0lcUqTUZmEJsh0vvMkApWQSmKw5llr5FY9OUQmXvLQePYn1XMKsO5tccoEb7EbNlvHTEV8hiTNzghYB20jpizxK+fuhbOiMvsWsUxPlzOo7LiHKWwaAXOwJm546Z9IS/tt076DON2Qv9u7L2Vkjj6kAopiXvu5fH0W1wpcvu0YcHdiTOmuO4JE+7/mKaeD3A85SlP4fGPfzzvfve7AfjxH/9xnvOc5/CoRz3qis9/+9vfzpvf/Obd46c97Wk89rGP/bisdcKE+yN2sWjjzvK9LXq2ZKe826i+sr23DCUqrNHcemLY+MThzHFu7Qkxc9vJwLENzEbSTcqFo27guEtooKkMTmsO5o7FOHzYb91u3ZXVhCQb4XlUEmzL061WIqRMezfXxKdRDWwNbNXYQ8LnjCsao2AYz7EayWTWKHwo+JQYQiFlyCVLZIRSZK3Y9AmjwFmL1RpV4HhULdfGoBSc2wx0vcSMDDFxrh/4k7f9Z3793/4YAE/7O9/NFz/tf2cIMhhIKROTZFSf3wR8LjxoXrPqI1orWqd31x4ubs5fCRc2nvNrz17t+NPlmqNNwCjFDXs1jdUSvZEzJxtFYzM+iM1uSogla0g4p9lvLNoo2loGHpsxqkQpGSTkktkMkWEozGojFrEpUyvDapAc85iLqCKMxIVcjbJ6Kt4nTJgwYcKECROuLa4UvV2NxJxlH7lD2V8KoRROOokfsFpRciHkwu3LgXljaKyhlILfRpNdRRzfEBMhldHtNlFZs9u0jymzGR1mjzbDjhSVyki+V4rGGWLMHPeR5ZAwehRV5IsusTlDUUBWnJ057BhNvSXhhJTpvPRMldWEKM6pKBkI1Eacp7oQ6UMEFEdd4EPHG7pRJBCz1MHajFEJBVYh0cXMevCsBqnxrdFYNEZDTKKWDlGcbSslpByjwRpNikmUy0rJ8IPMoq6wSn6uUbLOqPEhc9uJpzaaDJysA7/xUz/Ce379Z1Ha8GXP+0EOHv253LLs6UKhixGNxJ47JQ6ulZXPRUCUzjFrXD0ONUZRBMB+Yyi5ljiMKEwzraBxstlfWc1+K0QpozU+pkui1U9j+93t5+3Sz11hPQjJy4dMlQpnZxeFE3p0JfYxU1eGOMYxWi2ErMpqUjGsh0QphVkjUY8g/Ys4nEkv0oyCnMrqqyIvbde57cG2Q6l5bS8REk2YMGHChAkTJkyYcG9w3IVd1Pg9FZ6cWw3kMsZG34s0ETX2WUpByIWjtQcFt99+O//oW76K22/+EGcf+kj+j5e+jjNnztBUBmM0szoTS+HcSS9idAVmFNhYBUUpkpJ+MRd5H5TMeWa1YzHG3/mYGYKQhbRmdG6CwUeJcUdRKZntzGuL1nrXj8RcuLDyKCDkzKKZj+Qm6QE3IaKUEKKMVvgoiRd7taWyBn/KVbmxZhSkSBLIDMOiNgxxG32eUEAqGWssN8wrDmcV+62jtoZFcynVQSIDNcs+MIwC/r1G7lnrZPZxtQKL04YFkzhjwoTrHxMx6gEOrTU/+IM/yFd8xVcAsF6vecYznsEv/MIv8IhHPOKS577rXe/iWc96Fjnn3bEvf/nLP+5rnjDh/oTLN5bvqVvUFqeVsKf/f2dY1Ja0qEnLHhBi03EX2PRxjErzrPpIKoV1n0hIdF6lNXWlyanQR3GYCimz8RctQTc+yQBAKVIRlfTpRV2pLziNPsiGuNUKaySGwRlFGQvhVApjr7Eb3gCjQqCMcRkJVMHHBKNt60mXiTnjnIECISeO+khbaVF6N1qalyFx1Ac2IbEcEv/PO/4rv/FvXgnAX/nqb+Yrv+6byTmTkgxbmkoK+u0QYdVHcilUWlNGRYJRFxXNp+/xNnO884mTPvD+25YMsXDceWketOLsrGKvlciL7fXRSo+2rorjTcC1iiEaTjYBCpyMCvoQM2YcMjXWEHPGp0LJong3aGaV4aCtxigSu1NgrL1kbx/MKoxW4/BHTcX7hAkTJkyYMGHCxxGXR293IZLLxfi8rUNPzhfJTKkUaiO1W0CEB93oLJWy4/bsqa3msHU7x9qQpHZWI3mmMvLzIQrp6bgLu9dd9pHDmaKtxH11S4oaokRRgxy/FTssaiux3znjoyhvtRmJTiGPzqqOeavQo0I4F8hJiFNnZqNCNxeMgZAKrdOc6wM5F2at1PNqjH4WgYe4Rt2+7FltEs7C8RDxqYhAQklU235rUV0gJk+IIg4IMdNQ2ITIvnPEUihRSEhdyIQkKmNrZL0bLxvttbMoreh9wR0oupjYbysaq/Gp8OGjjnXvURqWQ0Brze/855/kD3/ppwH4oq/7Ph722V8sQgUFIQihqao0s0YGELPa4LaOsMDMGVCQUmFQEqNdGXH1CimjtNTqeeyjNjFxUGBeCbFt0VgUct20Yiduubwv3bZwpwlGW6Txs2cUGCVDjll96UCnHaMjKqMJo/vUagg0zoykPCXOVwUMirJ93VJYDZHKaBanIkWudmC0jX7c9in3tt+eMGHChAkTJkyYMOFyrEbCP1waNX41whOf89jDFVY+oIr0QSddGN2AuaQ3a66w967HvfnGGvqQOLcZ0LHnhX/3q/jw/3ofhw++iee98l9xw8NuomSF0eJIpYAzjUWXmtuWAydDIG/JT8ngYyIXhQ8Sla41Mk/ImaoUGmupnQjjG2tIOcuswSri2ANWVoMG7x1KFSqnQYHVMkM66QIXvGflI3u1ODbtNY4+ZJrKYK0kldRW+kCtPCFJdF4fLu0r+phonKF1bhRVpNExCoxV9L2Qq2pjWVTy/m68lo27ssB768C8WooYadHYsc+xnB1TSO4JJnHGhAmfHPikJUaFEDg6OqLve8rdMQxO4ZGPfOR9uKr7J57xjGfwvOc9j9e+9rUA/NEf/RGf8RmfwbOf/Ww+93M/lxAC73znO3nLW95CCGF33Kte9So+53M+5xO17AkT7hdQF7k8wJ07Pd0drqSEvTsctA6jFbee9ADcuGeIs8yyD/Qx48NYANuEKlKApyJRHpUtNJXkMp/0gdoKIaoyGo3E6TWVIfR5HMAURk7kXZK2fBSbUsbjAfZq2URvrGJZ5DkSASdrSLkwhESIogiwVqO0RqtMKRIxEbM0HVJ8S5a1K5qYElZbtJLmIqSMM0L+SanwZ3/wm/zmv3oJlMLn/9Vn8dSv/XaJDslQV5qGi0OfymqUKpSiuDC6Ps1rS+8Ti8Zx0IrFam31LnN8NQQ2XoZUx51n7aVwP1oHEoWzs3qM4pAOxIyNlFZjnIg1zA4tRitRo6RCyOKSNYRCbxOV0zRO4ik2Y9RGZcTyVSlFa+1OqXI4q8mlcPtqAGTotBwCZ2cSN3F2XjGfIvImTJhwHWKq7SdMmHC94nT09mqIMEYTDFHilrdq5C6k3aY8wLoXF1BrNZUx3LbqKQViTig0yy4To7iPWqPusPnujJa4tcrQVpqTLhOS1N1wsSY97fa6GSIx5Z07FIg4YEh5V6+f33iOe4+PmU2I5Fgo1mC0OL6iFSEWZnVm3tQoRLF7OLP4mDm/HoTsUoTIn1Khqa1ECGpFHF2wulGtfWEdRO0cMiHI8EEI/QBCapJ1F5zVlEGEFTGLI9WmjyxaS4iFqjbEJOSslDOrHowWIQJKcTotvORCKuLiZCvL+U3PcedFGDFEln3ifb/+Fn773/8LAJ74td/J53zZV+yIbSUXtJWI7FobjIL1kDgzrzFjVLgd3xegkGm1oQsirrBaUzkjpCcKlRXBCWOk3LyyNM5wOKs46SKLWpy/tsSy2WXR51uCkdoRjC7/jKrRQVZjtLok1oLxHraVofOJeWWBKEOMUTUds8QB5lIYUiJnOOkys3qMqdCMx8kw52ocau/gRDyub8KECROuNaZeY8KECRMeeAinHItOk6JmlaGtzB0I+Y0zzEth3UcubDwnXWbjM0bDuZWnMoqzezX7yl08tsicJaQks5eRrHN5ese8MdyyTAxdzw9959fx/vf+IXuHZ/nOV7+BT3vMoznpImnst4yWOjlkmWfMG0sXJXo9F3HA3Tr75iyOueIYJWLqnDMxJ1Y9Qi5SkBH33G3PJ46xCm0UfYk4I/3B4DODi9AVfJSECq1ENPI/b0484kzLfuswSmr3bS8MF2dKlTUS5X0nfYVVIl6prEJrO/bIMktpaxHizypDgTF6/s77g8pqUpbYejMSrbaJLRMmTHhg4pNmOrpcLnnDG97AL/zCL/Dbv/3bnDt37h6/hlKKGOPdP/GTEK95zWtYLpe86U1vAsQ56nWve90Vn6uU4oUvfCEveMELPp5LnDDhfgmtFIkibP8kyoGts9A9wb1Vwi5qS312xnEXOFoHBuDMSFtvneF4E1gOgZTA60xlpCCsrWYIYpWqtaJx4hjUjmv3KdM6zRANWkk8xXoInJlXV4xnyEU24LekqNrpnRp4v604vwlYLS5JuRTOrz2zxpLHZiIUOf9uSIS1KOKdVWQyPmdWXWTtkzhIFWkA2lZU9KWU3fsbrUaykOF9f/zb/PfXfi8lJR7zhKfyJV/33VzYhDFmQgrgttIoAzNnRa0/SAb3xktEx4MXDRmxyN0OXTZDxKdMTKLazqPy/4MXNpx0gZONkKUWtWR2b3zCJ0Xj5J5I8a53USDzyorCpBTOzBy3rz3WgE+Jo82o+NaSXQ7QWjMqTIT4VEa73tOfO6s1i3HA5EPeEfY2Q+JgNg0TJkyYcP/HVNtPmDDhkwE5F1Z9oAuJjxx1LPvIorEsu9Gh1GqMFtK92SpsvdS9fcwynI0Zo8VRahMS59cDldPMrMTgnQwRBRLbPBKjlBbVcacTzkudv93/3XghzZRysYYvhUvi9IxS9EWiIEJKnHRJiERDFHdZpdikTGMNXmWUuegMO3OKQuGkjzgjjkarPmBGIv+2Pj23GjjeeIyRer4PiT0t9TPAeoicX3uUkujrtY90IeO0kLkGn4kpk4qQqHxOhFh2sW+VUWRgSAntFRrFZkhSW+dCLuKMpDU4q7DaEBPMKk3tNBtfaJ0iZHGDXXVybc5vxBn2A/+/X+I33/TDAHzxs76Fz//yr965azfWyABkHBbUW1W01fQ+4yzoqDhzUJGy9AtOj2r0LHEXbqzvfUyUAMpKzOAQk/RutYgjQiwctBKlN8TEqpfYC6svRmhvFe4AjRmj7MYBwhClh3Nak6xGaXHkGmKmGiMXt5hV0r8NQXoYZzKDT/QxsfZJ4gaBVZc4mFlA0ViNGt1z+3so1Oi8fDatlrg+Bbt+dcKECRM+Fky9xoQJEyZM2AwX4/O2pKj9Uw6nl0NiwUUgbbRm46U3U8AQJbau6sRJyWpFbTTOiituYwzO6jHpIzOrDPPaXkzv0IrgAz/2fc/jPb/3W7TzPV7042/kUx7753BGs4fiqPMYzegGBaBYDtKblCxzpcqIm5TMqiSRo2SRQCgUe7VlXlcs+0RlCvutZfASuV47TUmKymkWlaOtNR+50EmPpzWFQs7Sy/mQCSmLO1St2K8riiocdZ5NSNwwr3aR6kNM1NZcYixwZ31FLIWll0QUHwoJEffUYy/glGbmpJdonLmDGORy+JixWo89VhmJXJMD7YQJD2R8UhCj3vCGN/D85z+f5XIJcI+UHRMExhje+MY38vSnP52XvexlvPvd777i857whCfw8pe/nCc/+ckf5xVOmHD/xNY9qLFGiEYxM79CdMFd4WNRwuYs7HytFPszy3qAZR/wqXDrSc96iBitcFrvCr+YCsskA5RtNIOPanSS0hzORNXrU2ZeGU6MASLrkDnaeOa1pa1EvVwohCjr3/7bWzvNYlQGN06GPUqJKttZTSmFZR/xJeO9JmbRIw8loYqS6Lhx2BGSKLK7mMhZ4h1yLrTWElOhD5k+DFzY+N2162LkQ+97L2955bcT/cDDP/v/xRd//T/iZIjYbRxI43Yxf0ebSO00ucj75QwxZ4aNOFZZq9hvIkcbjx1dt5ZDYNlFQsyEJM3T+bUXEtcgg6OYCyebQGcTrRN3rlLEXjeYi2oJpWBRWRQSj1f3QgrrfSaUjE8KVxQWRV0b9muHNRKtEVKidpLbvf3Lt40ybJ00XH3IO0XGEBM52ykyb8KECfdrTLX9hAkTrnds3UWH0SXKxywOUKMoIJ36d81o6R0qo0dyiRCmnJE4spgKISUK4pp0fuWZN5bkMgXQaut+qqjHjXC0ojaJxmrqStxbu1FgkJLEzSmEqLIVaPQxEVPGGY0fCS4+XiRLdT6x6hODT+hRpVwpQzbyWilLlPbay5B4O1wYYuKwrdHaE6Klj4k+JY66QMiFfWuhgLWQSqH3mVUfOe4959YDWsEty54QJV47JSErWRSxQOcjfcz0PuFTIVMuIdJkCp2PtNbQFVBFoY3BaE3rQI8EoZBk09wYhUb6AWuEPLXqE7lIvMRmSHzg99/K237yZQB80TO+hif9f76ZlKELZUfKWoeEH4lXRmuslnu5GiKLYmnH3ThnJF5iGElUZ+cVt689MWdAXGJPiMzcKLoIEpvnU2ZWOWaV5nBWcWEjLsDBifhl2QfaMWZiS36zWslwBhFWrEeiWwH2W0PeFKLKHI5Oucs+0lZFRBljf7uoHVptyVeKZDWMnxtnJALcajgzqyTWu612hC3G970aDDHtPnvb2L3aTtHfEyZM+Ngx9RoTJkyYMCHnwjCKkLvRtXdWmTslRW3r5lzkuHUf+chxx81HkuQRs8g7Uins1Q4PbNjGwxl8EOF14wz1SIbKpbDXOCqjuX0I/IuXfSd/8I5fw9UNz3/V6/nzf+FzCFlE0XuNZUiJVR9Y9TJ70IgQI2QRvrsCMSaKAoemqELrLFoVlBZiktaKkBL7TTWmeiQqJy5MThu8jrTO0taaW4971j6i0fhcSJvIQWPxGUBitCOZbtBAoKRtra84t/YoBY2z9CGfImuVkeh0aV9RGU3VajZhK8TRzBrwURyvqqrC50yikMk07u7FFn4rADEarEQJVlbiACdMmPDAxXVPjHr5y1/O93//91NKGTNHLzYzamtJfoUGR50iLUwN0EU861nP4lnPehbvfve7ede73sVHPvIRjDE87GEP4wu/8At59KMf/Yle4oQJ9yu0zrAeIpWVKISYi9iA3oO4snujhD09bDn9L9issswqyy0nHfNGItqWfWTtPWGrHLCSwawVI2s/U7LkRMcsm/83zCtqqznqAm1tWASHVoyKBnYb26dhtaI51UCIIhzWXjby1ybRGHE+8jmxPAloFIvW4KMMHyiSFx2jDHqWfWQ5RCozOmkZTaIQSyEGGcrMnON870dr1MKtH/oAP/Pib2bYrHjon/88vvS5P0jUhmFI2CBqgzAqM44yzCsDWlTqyz6SUoYizlOpBB52WONj5sMXOqwBpzVdTDJMiqJU91GGHjNjSG1BFWhrOypGEikXUjH4XKi0EoV6kmHL9k/QvLKcnWV6H1n1MmhQGQpCzqqsZVHLUEKxdYVSO0KY4o5Rhs5ocpH77KOo1Ltwzz6fEyZMmPDxxFTbT5gw4XrHaoi7SAYQMsxt64GVj3RDQmlw1nDDrMIaqdWBXbQdiPq1tuIgFFLh5pNOyC6DuLDmBJuS8TGgjSh/cwZXqd0xGx/pg6IOSYhUadz8V6CjJiMCi62TVM5CmNIKVj6K2CIWNOLq2iVxbzVaQQZnpNZ3GDY+EGOhqSyLRlxdE0Uis2Pm9lXPJlhalzAaQsgcrwNQONNUHHeRm1w9EsEyR53nw+d7Nj5AgX6M0BMCFugsMQhxHAQorSS+bvxPIWIMazVxPAcZAohjbDvGYyzGaL1coFIGYyCExHxWUTJYLaSiPkZilDjBP/sfv8Nvvu5FlJz47C95Bn/lG15AlwppFFgoNUY2FCFoybylMKRCbQ1DkN5Ga0uImdoZqlE9viXM7dcOpcpOMKKVOOY6I85fChG37DVOYvfGOAlxrXWARIF0PnHSBXwU4lLVWIaYUMBRdzHOonaivB5CIWTFXuvwSZTgnZeIR2f0rlc1Wkk0oM8joUzRzhyV1qx9ZK9xHMwqGFXZ+41jXlkRjnSRWVWuGE+y/T3o/EVSVO0uOuPO6sktasKECR8bpl5jwoQJEyaAkKEKsl8eszjlbsn4l+OkD6z7SBeEENWHxGp0NYq5sPbi7lsofOh84aEHhbOzinntyJSLfUEWkYTPmb3a0YeMVpHWaV71j17AO/7bz2Ks4+/+4/+Tx3zWF+BTHmc5MvN40LzmZBNGsXTmqA+EBFYZilaknEiq4IxlVinAUrYuxUaTk7hH+ZIZUsQoTcgJlywHM8sw9k1Oa25f9lzYBDLQOIncc1rTNjL7sUaRUkERENqTIhYRjp+ZO3IxbLw4CFdGs+wlji+XsQetpPedVZbKaDY+suwlDnBWidg7jeksqyGQCySf0eid8629E8HE5ckmldMwuiW3lWH6Mz5hwgMb1/Vk9G1vexvf//3fD0iDYq3lq77qq3jKU57CTTfdxFOf+lSUUnzKp3wKb3rTmzg6OuL9738/v/Irv8Iv/dIvifuIMbz4xS/miU984if4bO5fePzjH8/jH//4T/QyJky430NrRW0NfRRXoOU2XsKoO1UYnEbnI+dWAyFlZpXl3MrTOI01EnfXujuqYi8ftviY6eNYgBdY9p5bV57KaM5tvCga+sS8liiLg7aSmIate1HKpJzxo/sRwLm150GLStyTktiqGq1IKVNbKUC3wxulxenqdJ7zrJIC+ebjnjTmXRcl8R8lQ4wSr6ERZ6oyhmYoRGGxGZJ8P4sLV3QGA+SYefAY59eHzIV1ZGWFRJRz5uabP8LP/sBz6U7Oc/YRj+UvP+9VFOMohZ3d6zbaY+kTtVViPzvmc6+8ZGzXRgZRQyz4XHHLiedwZmmV5ebjblSfQ6U188Ywq5Sot0OmtYbKafYbsYvtxmzuzifaCjZD5uy8wseCUnL9t8rptrKcmVXk7ElFGqeUM0O4SGirrAxPOi/XSI0DkxAyKV907dp+/g4aSyriArAduoxpixMmTJhwv8JU20+YMOF6x3EX6MPFSIYuJI77wKaPu7pQK1EK91Ei6pSS+rQLQl558KK+xFXHGYXViqMusBmEmJQptMZgrcJZxazStJWV/qGyhJQZoriabkbnIqshxMJxFzhoxYl16xa1XfuyDxLnMMSdy9AmShxgRupSqzUaxUEr6l9dIBZNInG+83RBc9A6UhLhgI8ZaxRtbTjaeE66wGqIxCykIOtEtdxUhnMrz4W1Z9MnYs6sQ2LVRVZDgAyhUuSsyENGjSKPmGSQsYvFUxLzELOiVprKCNnKGEMucv1ntcNqcWvab8X5N4xRgjFnfMosGg0UUoEUZYjx/v/xLn7jn38PKXg+/QuexJf+3Rex8okyyo5zKTit8aOzrVaKxip8FjFMsFLf1yETk6y9dozxf0Jo86Mz1pAk0k5rTWUMe63DasViVD5vhsSmjjvBw7y24xAgs6gdRkeON3KtAcp4v33MHLRuJ8xpK7N77xsWFV2UKI292jGYRO+TOFSNx57GvDJoNarPlRodpgz7rcUZxbxy7Ldup8I/6YWwtRl/N6ot2UoJScvHPDoRy+vXThyztufnzNW5TU2YMGHClTD1GhMmTJhw/SDnQhcSQ8zkUnaR4VqpO52Z3BMMp1xzgZ0o5fT79yFxtAncvh6k/g6RGCWSbT1ErNVkMiklNIqq0mgtrr8XukAshRvGTfhqfP3OJ3zILAns1Y71EHnVq/4xv/CWn0JrzT/4gdfw57/oS2icZkiF5BOzWsTPx5uAVjJ3+bPzMvOxWmYUc2fIScFYV1ujMEoE07Na+sT9xtDFwrr3LPtIQUhQpoxOvyGCUhxves5tpIdojIgUQs4sapkP5VyIBVLJWGvkNTRAIeRMN4ioovOZs3PFvDYyH0ky80Gl3XmcJqdt3aaUhpkzHG8C7RjJfdJ5bljU470yDCHRhYvx9Ap2rxVO9ROVkznWqo+7fmJK0psw4YGN65oY9dKXvnSn8HjoQx/Kz//8z/PZn/3Zd3he27Z8yZd8ye7xd3zHd/De976Xr//6r+e3fuu3eNnLXsZP/uRP8jVf8zUfx9VPmDDhkwWzWgYbTWXwWaIL7k4JO8TEhbXneBMoyKavHclG23i+kDLrIVJbc7EAvsKwJeaLNPeYMrctPSFlbl96jlZiW3rjfg0KIeOwZdQrKgO5CFlGq7QbCADctuxxWpOM4mBWsfGRbDRKKYxRzJ295NyUgspoGqcJY5TfbcsBFCwHcY1a1JYLG8+ikWHJagjctupRRVM7Kd63GdVb1bTRiq6X63A4r2icZdmHndrex4SnMKxO+IV/8u2szn2UvYc8gi/9+z+Ca+ckIGdpcA7bCqXAx0hrnVjf5jQ6MxV5TW1IRdTki8ahlcRp1NawGYSE1ceEQWErtVN8GBTrmPExUY9RgxIlqNioNDpLiSvWaojMK0M/2ujuSGaMDZ7TxFSY1aIkN0bROk0eVfJ+vE+FIs1ByjRWY7Tc35wLRxtP44Sgthkis2RZVJasJ1nEhAkT7p+YavsJEyZcz1iNZCK4SADZwlnNnoLOGxSFeW3EaTZejJsTUnthEyJDFMejrXDgwtqz7ANDSugkkQTzeiTUl4JWGjfGRFutqIyldYbBZY43ngvrgC+ZSililqi6vdbSJDNGKETWQ6LzQrQ/7gOdF8VuHmvPmTM0jWXwmVgKVinaSjbbGzQxZDYps85C/LfGEDMYLWSkzRDHCD8oSlE5w4MWFbXRPOSgwWhRQmstfchqCGz6xHHnd8OQ5NUoeIDtdKSUQsrs3Je0FkclBaSccNaIE1POUhtrGQoYreQaWEvOEm8Yxh10n4R4lUbHIzR86H+9j1/+sX9A7Dc87DM+n7/yrT9ILuIaXCmN1vJ+tdP0XtTdWiHq7BipRmGHMRCqTMiJcmpLzmotkYljqV7GmA47kof2GiGinZ1X3JoH2JKtUt4RjKqxjzwaleTOiKsUyHAhl8K8tswbSzOKLWAkdBlwxnHcyb2XvlQU4SFm+pQo+eJQSmlFY0TNffE1hJh30Doqq1nU8jktSNz3fuPojRC74ugmNlxGtoKLhK2tU5S4e13X25cTJky4H2DqNSZMmDDh/o87S8kAJBaccsWZyT1FHovuPM5Vtq8RkoibtwSbj5500i/5xGaIhFgIRRxYo5d9eaUUbWXRSkPJxFSorIgGSoEHLWqGIOIE28j3fcgMJvHGf/6jvO7//DEAnv/iH+JJf+0r2PjArLL4lFmOM4DWwUnn6UKm8xGjFHtNRaWRiLkI7axCURgi1Fbq9ZgLB001ikoKc6dZ9TJXqo1BGbmm6yESM/gUWPdJnKOszICGIFHbi9ZJXCCFmOU+KRQHM01lDRpFF2U2ppUa3Ymlpzg7dxxvAs6KO9Ttq4F5ZS8RBFWjaGWXRjImk5yzA+uQSBkevCfkqDK6CV9JvAGXJpus+kjtNPNG+okrzeomTJjwwMF1u7Nw4cIFfvVXf3VnZftTP/VTV2xm7gyPe9zjeOtb38pTn/pU3vrWt/Kc5zyHz/u8z+Mv/IW/cF8tecKECZ+kcEYzry3rIbLfOE64ayXs0cZz3MWd/bZWsrl/0gmRZTUotFa7zeo+pp16YYvTwxalhPTjjGbZByqr8SmxGQLGKKyRwYNCivvbVwOHs2qnhNBK0Y5DgtUQCCmy6gOgODuv2WsdZ2YVZ2YVKYnr01bNW43OVluHopjEjWk9RG5bDiilcFqsVTdD5My8YoiJ206GMReanfuST0mGJwhBSmmFKQpFweeMzvL1cR8wKGZOE7NE6Q2bE37p1X+fo4/+KbMzN/Lkb/9RzPwMSo151UjxnylYNG3tqEaVfZshUxi8OFeFDO1YlDeV4RFnW4ZQxFFqGVBa0VqDNopFZTBG0wex05VrDCllQio4K5+P2sq9DiljjGYzRPYaSylC/hpipnWikgip0FiD12JEO6sMxiiMlsGPT4m+F8WMUUri8nIhG0XKMpAIqdA4GSZIIycNzvm1p3WGg9ZNiusJEybcrzDV9hMmTLiesd2ch0vr9FllUMpRSmE1JKm/tcIZg9WFwcpxnU+sh8SZmSOksFPjgtSwR70n58Kql8iDea3Ybx17jWU1pNFlVAQFPmUae1GcYbRCayAWToaIUppu8Mwby6oPOGPQClLOQooJonjeBCHvUJQogJVi0ycyZRwIXHQ9XfskRH4rdWjOhUxmUAWSIqdC5RTWGBqjOGwsIcN6EIJWKULyqawidYlNSBx3EZ9ElOCTDLIpEHKh5CL1Mcj/hfcEFFICVEEpjclCOHJGnJ/2KsNo7oTVmiFk+uBJKXOyCTASszQKo2SQEFLilo/8GT/3Q38Pvzrm8JGP44uf+wo8lpkVclBVaTZ9hCK9lXMSg20U+CwCiy5EfE6YAj5I33R62LPdn9/S4WIqDBSskWjFWWWxJuFDYVFZoOzELpcTjFonIo1UCovmopNs4y4SpUAuRW0Nh60QorbEurayVEaGPD5mnNU7AtTlUIgCvoxCjyvFwx+0DqMV6yFe0qOcdj1Wikt64C3mtZ1IURMmTPiYMfUaEyZMmHD/x92lZFxeL25nJvemXrwoRpD/ayW16lYwDnDbcuBoExhC4sLGE1JhVmtULlTW4seI6lkl6REaGJK4UBkte/mrIVJZcUHtQmKvcbSVREf/1L96Ha951csA+NYXvoRnf93Xc7QOKGR/3xnNZkh0PrLqIz4WGBNArIbDtpaZBwWjRazuU2a5kZ7OFCVCaqPoxnVQ4KB2nBTpTYuCIWRWKo2OwtI/WqOhSFT4fuO4cb+RvnJ07e389j4piTb3sD+zdKtEKiLed5XFjP3EQeMAxazKnN8oeh8ZgjhHNU7v/j5vnXFntcyyzq8GfMzMKyNR6Vr6rYOFOOBejXjDaGgrRzP2RPWd9DUTJkx4YOC63V34zd/8zZ3K4wlPeAJPetKT7vFrVFXFG9/4Rh73uMcxDAPf+Z3fyS/+4i/eB6udMGHCJzsWtSWNFqt3pYRdDgE/DkpSLuPGvMIHUTBX1hBSgVQYRjeh1gkx5mgTaJ0REs+pYcvWlWobneCMFLlNZZgpO0YjZOxYUA+jKnyICqv1JXajKRd8ynRDZlYbUk7cMG9RyKb0vLa7jOZLnaogjjF8yyEQo0TuFRAS1NgQ1M4wrx3nbSB2iW6Io9NUGYcWou6ui8bZzLqLKGCvsvS5cNIFjNWcnVVU1pBDwhTPL/7Yd3Hb/3oPzd4hT/uu11A/6CZ8LhhlOKgsaCnYS4GkMkOA3keskSEDgGs0XR+JCGGrchUGTc4ICStlIoUUMqYWm9jGGWpnWfcRCkSEDLXxicYZchHy2TbCbktuUuri8CfETK8SRimGKPEdxmgOakceVepGC/nOKMVyCKQERikWY2SGNXp3HjGJ81XK4hAQksSQLCpRaw9J8r6nIcOECRPuT5hq+wkTJlzP2AwXHV23dfp+a8XmP+aRyC5K1VLYxdQ1zrDswy6KWxyVxPmztlKnrQbP8TqSxHhU6kMt6matFFYpwki0n1WGGDNYw9rHMcZORAxHm8hxFyQ6TWsubIbRPUmzHAIhicNpSJm5k9cxowhCWDuFYVRQh5ixVuOHNJ6nIiaYNw6tYNVHcWC1lpgyupK+Y1HLJvWQhMTljMTy3XLccziruH018GfHHUPKpCiEr1K2kRmKWKDOIgaQWPCMQ6GUZuY0Q4LEaCZFxml9KkphFKWgWPnEfutIGWIenXq9uEYdNBWZgtOGnOH87bfz7176XDYXbmXxkE/li7/1h6jbOa3TzGrLtpcDhXPSVzVGCFhKFVxRBCt1vo+JohVdSPi4DRMXlItfshxEdFGPQ596JBg9eFFz83EPwEFbjf2diGpOD4xqZ7lhIc6x/Shq2ZKr7iyCpA75knh4nwr7rTg19UEivHPh4lBq5xYs0RonnQxH2mo7cLg03mQxRnhsHQC2DldXwpawdW8dACZMmDDhcky9xoQJEybcv3F3KRk7XDYzaSrDehC30/1TAoC7w9je7MQJx51nq6AYQuKkD3z0uJNYvI1niCIQVyiKhpDFRdcYjTVSIx/OK9ZjRN3aR5yWPux4E0Qwk6SXa5zhP7/l3/EjL/1eAL7ued/J3/6G54pbq4sYLWkZGUmVCFkzDBFrNCEXtJbvSyktKRPzyrAeMt0QQbOro63RLJzDKkVKoHRmMbNECjGBKQqMFPmxFGoLXRBxutKaw5njpsMGqy/W5CFmlFbMaoNRioycvyRt6N2MqnXSs52dVyilZI3AQ/YbcQce5D6vx3OrRuF/4zQhFvoo7sGMPchBW9FY6cGslrnTxyLemDBhwgMT1+1E9EMf+tDu6y/7si+7y+cOw3CnP3vkIx/JM57xDN785jfzq7/6q9x6663ceOON12ydEyZMeODg7pSw6yFBlti8kGTzHKQAP5w5DtpqR3DaRsnFXFgOkTAqdY82nlQKs8ruhi1b9GPudsqFjc8Yrblh5qid4dblQEgyLHFGFMpGq11k3xZKybDAjoMKYwxDTNy413DDor5blW8fMq01BKVYDpHNIHFvlZVYhY2PHM4rVj7uCtQLm4BPeUfqKqXs1B/eyDVIFKpRLX5Qycb/SR+pdeFnf+yFfPCPfoeqnfPUf/Cj7N30aSgFrgihSVhfYm3bxUKrNbpIvIcME2ATMk5DLKJAz7FQGY21ipM+sFfLUKc2mnVKhAjzWhNLYaZh0Vp8zpAkLqMbMiHn3RBCKzUS1ETlXlnD2idu3KsJ8SKhbNUHUoGF09Qjka2pNKs+j+QyGabNGyHRFQohZua1RFzkMqrnlaj1QUhaIWXWJOzG78hQ96ZpnDBhwoT7ClNtP2HChOsVOUvkGUA3bubPqosRAKWU3earMxddZFdD2IkoKqNJOXO0CtS11MM+FoYYuW010PvIaogXxQZa0/tI5y3OKoKHMpb0uTASb+QbG5/IRUg6Somz0t7MEnNmr7F0IdINCWu3KltAywa3KuKgVBSkKDW/kPAVax9wWrPs5fzmtSXGTFajyljJRrUSM1i0hphhvYqEknFGNsc/0Ef2Zo6YM8sh0vejWrnki5F0KJTWLIwhZnFc3ZK4UoYcE9ZqrFHkkokpUxCi2WbwtJWhYHeRGSlnbl/21E5EKashEEtBFTlXChgDm9WS/+ul38LxzR9kfsNNfMnzf4SDMzdww7zmcF7ROk0XMpVW4NQ4JABrNL1POG2YVYaTPtA4w2aIVEYTS2YzBJad2bk7dSHRDQmUDFokHsNIxITRzCpZa1tZmsrQWENImf3W3WkchALOzuqrIhjdeTy8CHFm6o7bh7mI2n2rrK+d3sXfzeo7Dhyc0RzMNDlburF33cYk3hlha8KECROuBaZeY8KECRPuv7izSPLTKRl3NjPxOYsbk5f47qsVAWulSMgMYtMFchEi/1bUfn7jAXEGVgpmleaGeUsfAl3MYwR5RqnCvHaULHv0h/OKlAsnfZDUh5horOZobdhvHSd94O2//Iu88nufD8Azvvqb+Obv+B5aJ3MTrRRKwbx20uuUjA+Ffkgs+yhRgqGwaOzYa4kARWnNrIYhiitwBrIqVE4DhcOZZeUTPogIvNIaC5xZOEKCzRAICdZDAKVYzCvOzmvmIwkplyKzIB/pQ4Gtq5XTKFUwRnpQoxS1NaQsPVE3RoM7o7lpv+GWk56TPowx8CKs2ArJh5gYQmLZjYQ1rbBKU1V699nQyvEpZyuc1tdEvDFhwoQHHq5bYtSFCxd2Xz/iEY+44nPqumYYBjabzV2+1hd90Rfx5je/mZQSb3/723nmM595LZc6YcKEBxDuTAkbkmwuJ6M46gL9uHm8P3OcmTkWtaMyeleYNc4wHzeaV32UiDynCVEi+sRFSLHqI0qJjWnnEylnuiDNRKLQB0Mq4Iyi84XlJnC4qKiMkqzqnOEUsQmtsWNhGceYCqv0zl3orlS+QrKSCL7bVwMUqJwMQxqncUbIVKVkHjyrqI3mo0c9jUv4CMWAUZBHwpioBBQhF2IqOK1oK8PBrKLzCVUyv/xvfoA/+Z1fx7iKv/E9P8r+oz9DVPmIej4WcfFSaHJBlNopkUvhoHZUlaJxltpJJIjRiT4WWqsZglixxlgoNay8kNNMSCSkQSsFfMrsNY6TLuCUJqSENbDxEau1xN1Zua4hiXJCCGiM99pijOb8auC4j1ilODOrKOM1qIwBhNyktUQTWit2skPIEhWoAQVOyWtvFRYUuS+M9yDmgk/SnN2bpnHChAkT7itMtf2ECROuV3QhUZCoh5iFfLTdeAVks9ro0YknM3OWkEUU0MdE5zNDEMI6JdMnhUJhdaJ2Gl0UTWU48ZEMVEpx0keM1szqRJWlqty6D4WcSeFSgrxWSjaHk8UZg1KaxgkxKRdoKzUerUgRbvc9uYD3QtBSgLOKRW0IIbMJkRAKWHFEHYJsuje1kHfcqODtRkIXStyOnFEEAyVB7wvWFJajOvzWghCGfCblhEGNzk+FujKQ5RyN1lgl/VIcyWMeGVgoVchFocfN+5AyOYNWhb0Whphpxv5lOSS6KG5SJ32CUtirLZWWuDkVA//6Hz+Pj7z/vcwPzvKM7/5nVDc8lNppFrVlVmn264r9toiQI0t0eOcTM6cwY32ttNy/tPJoI2trxshBIR8F9CiuKSDxgCgOZ479VtTVhzOHNWq3sb/fOHEbHpXV14JgdE/j4bfR6lunq9rpneBiXtu7JGJprUY34qta2oQJEyZ8zJh6jQkTJky4f+KuIsm3KRmncXpmshndek+Qfe71EHdEqrtDPc5rrFIyZ1CK4+KJUVyOSoZFYzm3GsR1qbYsGgMUjMnk6FlFmfeEWDiYOZZdBKTHmllDHzMhJoIu3LYeUBp+6zd/nZd8+98hp8STn/G3eP4/fBl7TcXKB3RR7LcVt570bIZILAWNYt4YCo51iKQk/V4XJPkjAU4phqjxIbPx4hi1sDJvkL6s0HmIQfo6a0TkPYRMLLCoNEPSzI1iCIk4kqBiymPcugi2tyJsAKuEFBUp1FrmKJ0Xx6lZbSlldE0ej8mjEP6hhy3lCEIqPGS/FSJUH9iELJF4SM8XUkHlQimF4y5QO42zEiH+oQsbbtpvr5l4Y8KECQ8sXLeTUOcuOlxYe+XT2NvbYxgGzp8/TwjhkmNO48yZM7uvP/rRj17bhU6YMOEBh8uVsKshcn7pORkCPmaGIKSiGxb1rihbj8WaOCuZnRJiXltCFPeho+PAkLLEryVxhgKgSBF8tPHccjKw7AOdT7S1OApJlrLCjREXm0EGKVYrFldwC/JJil2npfBuKrPb8L4rla+PovzOueyIOSlnlqND0hDEsSoXzboPOCtEsMoZKqMIEboQJbrCGGLKtLUBpRg8FKVGFXhhXhl+/U3/lPe87edQ2vC057+KG//cXySngi8SHeeMYqYNXUikHEXdrqTwlmLaYIxmNVrb+hjRWlMZjTFa1PJKhl1nVUXvZTjltCIiSnOQmJHGmnHYVIgl47QihEx0hQ2JeozPG28YoEbSk2R/q5RFVYHaFegKRjJXJmc5xmnNmb0KoxTHXeCgdWSKxHeMQ7itQxUIOcuNg7i91jEEOYd72zROmDBhwn2FqbafMGHC9YptZHY/ukbVVl+yga+VxLvNG8OQhKgk0QcKg6IPEnnno5B76iJDgFIKOQuxplIGVbJUkUqNsdhC9q+dZl5Z9sa6futYetoZthpVukopGqfQGrQSAv6skjUPMRNjYT3AphfHKa0hpYxCM6sNIUqta5TCGnGPwoLSZRfloBXUTlxne59o3Rg5kQvnNoHeSwS11rDsJJIvl8JJnwk5EmOhi5mQE1BIRcn7AKrAYTv+jVCQbGGOpR+EgKW0OHSpIkrrlMXxSuLuJALQmYrNIGvIYyxfpUFricheNJYb54affMm38b53/Q7NfI+//f3/nPlNnyb1tlNYC1aLFVbJMHi5zlZrZhWksnUSE2IRo4Jcoag0HDYVTaVoncWHQlFJXLHGa2e04oaFsIb2Gnm8JUWd3thfNHYkNF2bz/LVxsOfhh3FK9s1tZWZRBcTJky432HqNSZMmDDh/om7iiS/M2xnJlvhwBAyvUmjQ2viYHb3e9ytMyy7wEkf2fjIxidSFidc2SOXXiyOIpHZKHwpiEggFRhiIeQCORNToa40WhXWIRFiYu3jONdRtNbw7v/7D3nF3/9GQvA86alP4/te8aM0o1OUVYqDWcXt64GYJdZOKWisIeVCYw1DiCKqNmoUPnuMUiwaw8kQiUmciBeVZV47mkrTGI3S0k8t+8Kyy3R9pLaWeW0lkhs402wTPsSBN8TCbUvPaohjfLgQjlIuWK3IFLo+UVeaIhoWUskMCTZ9ZL+tLiFSbWdLqyFitOLM/5+9fw+XLS3Le+HfexxjVNWcc63V3TQNoqJRIyGibiNRgx+RaIyHzxh1y+dZg6cYiUSMgpfGDWrUqIgC7mgSjVc2ogZ3tpitJooRFULiCdAgJkTk0By6e605Z53GGO/p++MZVWuu1avPq+lueH/X1VevQ82qUaNmz36e93nu+5453r3sWU9LaYvGYBTy3jN7kUucemcAozWpFG47HehD5oa5Z+btdRNvVCqV9w8esacVFy5c2P/6rOrjLLfccgu33347AG9605t44hOfeM3H3XHHHftfHx8fX7+LrFQq79doLcrrXArGKs4Zz23LHqUlqm4IiTEmUREbg5sGEkOUBaL5VHRuQiSkwnKMlCwF8UkvqnI1HaD3IfPuE7EiPd1Glv2I3xiGkMQRyYrbFIDShsZp+phpc6ax5gq7UacNuXUyONCazRg52V4uMM+qkM91TgroaYO/AJfWIwpF6zXLrQxwUirEnKccZ4vRmhgTziqaqIhagy2ErGBaDsoJrC5skQI4lYJF8rD/8BU/yet/7WUAfNrXfxcf8deeSiqFrBQqQM4Z1zj6mOhjZgwyaDqaeVyRQrixsmjV94mRzMXVQCqZhfekVCApUSeYPCntYQwyvImTIwDI8hLIIGEzJjovQyPtJHM7TcV8zpMrlVESZVJkCLScPktvNefnnvMzzxAzNx14KIqYJOYkFhk8KGRZq/OS472aGsiD1uLPNI1jzGwnZUQ7KWzOzTyN0/e7aaxUKpUHi1rbVyqVRyq7eLY8FYVXH7aKe2yitRKL1gdZNnFWE6dafBsizioMBorUnlYrnNOUTWE7ZqLsweP0rq7Xoq4dNduQ9s5AhULrRJSQS0EjwgeKxBkoZLHGanFX9VYOizdDYtMn5o3h4gZizrRGHGa1kaiKlAvWKGIspDwtfeUicXLG0DrpEU5Tpk9ZYiaiZBusRg1KMbOitC5KsRkjbTEUo5h7TcyWS2GUWIqiUUrEIGMpGA3EhMax6BwpFYIWFTPeMqZMyCKgSBRWfZTeZerJCkzXLvd2LODZLU8pDqziqDO0Bv7N930rf/i7v4lvWp75Az/JLR/2USy3kfUogoLGWpyVoYn1Cq0VfUxyD8fEGDLzVurvkBLHm0AsWcQIVqL0jroZh3PHdoxsRokGtEbjSmFmxVXKTH3XWbXzg32wf0/x8Pt+cIo+P+sgvHMZrlQqlYcbtdeoVCqVhx/3FEl+TzTWMPNFHE5HOeMeYiJne7euqSFlNkPitA+cbEeM1mzHkVQKnTdTIofU9tuQ9iLkISYubQa2Q2bZi+vtblHqOI+0zrCdRO/SdWlZMgqFi2/7M17y7K+k3274+E96Ks//kX9BMQ5jRDjdOIkMH8PUMxip+eV1MzFnFq1HTzFxF1c9x2tJEtmEgFEareGgsSxah7eKubeY6T7EJJHsWhdSlAhxaxTnZg3DGCgo1kHEPGosbFPEFY3WBq1kKUnry71uRhakYipcHEc0UxKKgtWQOOzKPv0CmMTql93BNiHhjeHcTNI2xElZetpGy/eGMwqtDGMsXNyMnKwDi9YwayybXoQuQ5uZ+Tv3H1W8UalU7opH7E+CD/uwD9v/+o1vfOM1H/PEJz6RN7zhDQD8xm/8xl02NK985Sv3vz6r+qhUKpUHwskUC9EHUUsv+8DJNqAA7cx+sYYkjj9WS8RF4wybMe2HLOshTYtNUpBr7ZmV3RKT5uJ6ZBMiq23kdDuyHhJDThKTt4UjYBsUhULKmZQKTns6Z7Ba72MTdgwxccd6pA8J00ukw6I561CF5FlPxWxjxZnqbISInt7LxfUgz5mkuXFGsx4iejpM91oRrIGUaZ0UvblAZw3FiDJiCBBiRBuIpfD6X/tZ/svLfwKAT/iSZ/P4J386SkMKMvDRBZwxDGNi3Nm1AiaLottOKoKUp0aoj8QCYyqi7lcyeAlFlPurXt57LhATNE6W0eKkwN/FljhjaKzGJE3nYNUHGmcIMbMdxIWrqEIcwSowVjbRDHDYeZyBResppXDT+Y6bD1tCyhxvAuBYDoEQC/0o+eWtsyy3AZDifrcUlaf4wO2ZAcquoZx5gzX6fjWNlUql8mBSa/tKpfJIZadG3f37WnEPmzFhjbhEeav3auTTjfQGrbNYBWMslKLEPRZFmZxfW6c5aBzrMZBKRilZjrq0GfDGsh0Vc2cmdydFSoU+ZlIpzLxhMk2idXI4v3MLPWzdFE+nMEZcoLrGcMOswSjYjBmtNcMYZTFLg59q/5hk4T9nWcQSUYWaFMOFkiQiMCRRWXde0XlF2xjIcn2dMzhn6MeEMwVjNF1jZBlLyaH7JmaMgp3e+HSKEj9oDLPGsR0zhUDnLYyZVKboauQAvjWaxmmMVhy1TmLItaJFYRQMWeIfRCyi+LV/9X38t1f+MsY6/skP/gQf+lEfz5gSpxupu62R+7neRjZ9onEi3FgOEWslNrGPiduXI95q+hA52UYKBd9Ir3fYOhKZECJjyAxjwRiJpLBaT25R4qxrtEbDXoxycT3SWnGRGmO+z5F594Z7ilA/i2IaSjWmKrArlcrDltprVCqVysOPe4okvzd0XtIiYpb4N29FNDK/iyWY1RD3yzlKIWftIU4uvgWjIE3OSCnDmNLeNVVpxbZP9CmzDpExyHJQSIWTnLihc3TKUsbJvXb62tvf8Rf8X9/591kvT/jLT/rf+N6X/BRRWTqraIzGGs0YkvRC3kw9o2E1SLSg4rJYPYRMDJmYwGrDOgS0UnQeFt7hrKFkMEoxxoS3InIIOcMkdHfWY5WeHHQzs8ZTkFnBZkjkDOMUmz4ERcow9+CnvsRPvZWIwKUfUBqshtNt4tzckoskg7RuBkxij2u4g52bOcYowvrGXnYdluwMiVZ3RnFh5rl9NXBpEwi5cNA4vBEh/RgTM2+reKNSqdwrHrE/DT7qoz4KrTWlFF7zmtdc8zGf8imfws/+7M8C8MIXvpC///f/PovF4orH/Pqv/zq/8iu/csXzViqVygNlNUT6Selwx3pkPUQ2k2vRorEcdg6N2I6GlPcNwGqIjDlz0DgurkdACt9tyOI+NC03eePICdZR3Ibs5Oy0HBKrIZATOKclBqGxtN4wxsR6zJAjjTfkAoedow8Jpdhv11/ajFzcjDgjB+AxiYvV8Wa8pkK4j4nj6fFpmgi1uwiRaTA0RFEBaKXoQ8JauTaUYuY1KWtaL+rrMeVpgKPoY+SgheNe7s+bX/OrvPZnXwDAx/7dr+EjP+XzSTkTUqGg8FZeUwPbKM2H1wYFoBUxJ3IsxJhYqkjjDGOeogaNODhthkSMGd1NgyKl2IaMKjCkTCwymUm5cH6W90tHO3V+0JKh7cz03pXCmMyYEiHICtmI4kLjsEpxYe656bChsUZiAhvD+VkjCn9lOGhl0enRhy1jypxuApsxszkd9oOKubIMMRFimexi5XNonGbRiMJktxQF971prFQqlQebWttXKpVHEjmXfaz0pc1ITKIajhmMhnPG7xektFJ4I86wrTeslpEx5cmNR9NHxQzDso9TzJ5h5jTKwEEjB8W3r0Rs4IyZln0UY5F4uJQi2RluXw7MWukzVquEYopa01KX7pbmZ97SOkMBzBStPcaEQnHQOcKqkFTGGoMxhUYrwNAoRQiJjMJqTWdBW4XThkZrukai+vogCuxtzIxT9F5jNPNWi5Ot0WRdJJJhitQbgog6chShw8xZQsoYrUGLU5VCUVJh1JNCOyWaqebOkxuWs4khisOS1ZrOw7zxlJxZdI5561CqkLMix4x1hgY5yJ85zWv+3Uv43Vf8LEopvvo7fpCP+6S/yUkfsGisNcyAkBJKaWKSr9uELJF8qbAeZZAg/ZMoysdY9gtxGVgPkQvzhpQKyzHhjeax5ztar9FKPvPWSZzizFtKEeHDTlQz87KElHK5k1jlei4n3V2E+lkH4eu9lFWpVCoPBrXXqFQqlYcf9xRJfm8422v10zn5EPM1o6Z3InaQ5ZyL60DImdWQcNaIW22BVZ9YD4n1MO57uNtXCYpizInlNjKkQs6ZVET4PXPyutvViFaSmJFy5p23voOXP+9rWV26ncd+yEfw3B/5aQ4PD9hOguVkCkfWkwsY4MZFM4meM4vG4UxiO0ZS2Qm1C2NOMoNRcg810HmNt4qiCl2j0EoTcma7HclFXIw1MjfxRuM1nGwTisj5uUIpxYXOY4ykVyRgMwRCysyco3VaZkFOej4AYxTeKJyVnuXSRmZZuUCZEk7m06Kb02rvCnbWHSwmea/AfhEMJD7eWz25RilJZNGKS+tRROhTj/jYrhPxvb1S+F/FG5VK5a54xP5EODo64mM+5mMopfDGN76RN73pTXd6zOd93ucxm8lG6l/8xV/wCZ/wCfzCL/wCb3rTm3jd617H93zP9/B3/+7f3T/+sY99LE9+8pPfW2+hUqm8j3LWFvS0D/Q7555JlX1u5mmsROc11rBo5M92iogxZC5th32BfNoHxpimx4tyAAV9nIYECtZ9QCnZoG+sxlpFyoWSC5e2gX7M6CmiTiHFf0yZ9SjXuZ1+f9qP3LGSItYq2A6ilpD3JQfyIRWGkDnZBi6tR/oxkQtsxsTp5GC0K3obraf3VMilMEwKgJjy3mlpMW34x1RQSv4spsKYpAkpKBbe8q7X/Tb/9We+F4APfeoX8LhP+SLec7rldBO4tBlYbgduX43ihBSi5H87jTaiCpeCWhbEtiHv708umdZqWqehyGKRLHQpjteBzRhY9YExZbZDYrWNpCTuURfX494NK0z3ad7IsKlzlhvmDRfmDX6yuW1bw0HrOT933HK+5dFHLY8514lTmNU87sKMD73pgAtzz42LhpsOGj7ohjmPPuqYecu5zuOtKEf6lBiT5Gavh8iqjwwxUYoMXxat3S9Fdc5c0Rzsmka43HzumtFKpVJ5KKi1faVSeSQQUuZkE7h9NbAaZJGpFHEWzUiNe7INXFyPnG7D3mF0tquNrWEyQuJkE9hOrknzxqKUuDYdzSydt1jEFUrit2UB3xuNN4ajWcNhazBG7eMUMtJHhFTQSg6jW6tZtJZUJBpvZg3n516WpiZRxDDunl96jXlreczhjMYZznWO853j/Nxxbib/7FTNjTdYJZFvs0aWY7wxOCMChT4krJb33HhLow0lwXaMKDQoCFliGebe0mjFGCSWLxcRg4whAVLHO61oGqmxtRKhwhgLmyHL4X0RdyujQSlxYCpKSVyhM8ydmcQDCqMVXWPxWtF6w80HLa//1ZfyWz8nrrRf8S3fzad+1udycSMuuk4rDluLMQZvDDGDtwpdZCEql0IsidWQWA6B9RgJOe/j++at4dzMTWIUA0WhUFzoGg4ax9HMccO84ZajGTcfddxyruPczBNz2Q89JMJCvgcvrUeON+PUJ8rr9DFxcT2ymvrQ64XWinljr+hPblw0XJh75k11nK1UKo8Maq9RqVQqDz/uKZL83rJzB9o9z+55z3JWxH7aB5ZTLzfzhnljmHnDLUcdNy48jROx9sXNyPE2cOvFDW+7uOVdy57jSRTTWDUJNApjLiy3kdMx7iO8nVWkzTH//vu+gdPb38mFWz6QZ3z3TxLsjP/1nhXvPOm5tJa+8e2XNiJ0RqL8Dlp3Rf94w6LFKIXV0leUDN4oOid9lLcapUSEoVH0obDsAyFmxlAYQqIfIttpBmC1JGcoVUTonmGIhTEVSoLOKaySBSeyovHieDwmiQXMKWOUYuYs89birfSCnTU0Tp5vjInOabK0MjDdl7PuYM5cjgw/uxTVeemdxMVWFpvkPjRcWHiOZp6Zt2gNp9sRo0WcU4q8n0VjuXHRcDRzdSmqUqnciUe0NcRnf/Zn8/u///sA/MRP/AQ/9EM/dMXfnzt3juc85zl8x3d8B0op/uRP/oSnP/3pVzxm56qhlOK7vuu7MOa+WTVWKpXK1VxtC1qAg9bK8lEu11Q+aKWYeYvVimUfWW4izmpKEVWxn4YUapBlKas1Q8iT6jjQp4xzhhudIUTH7auBIWZSzsSoWI0jRslS1KKzGKMYUmKMGWcy3mgubsTZqg9JLEidIQEHnWXmpQjdbeiHyUUq5sJyiGzGyMxb+jGRcuHmg5bVIO/BTu+3DxknO12EWPBGlOqt03u71p3COiUZggiFd7zx9/jtn/hOSk487uM/nQ/6O1/DZorOcyZjggw4UpF7HKYC+8a5J2dYB3HVEnctQykZrUSJ0jpNKmIxe9RacfYCUoEyuUmFVEg5oRWcbCMxZ6xpGFKmHxOrIe5V3LtoC9/JclWe8slLkUGGM5rDTpacWmc47CxHnRdF/10U60edw2i1/144mnlizqyRJshqUU8oLa9vzzyPNHh3/t/9TkFzd01jpVKpvDeptX2lUnk4czZ2AeRQt4+J7ZBkESZlNmEXX2cZitTLu1ps5iVSb+YsMclhtYgFIMVCLgmNLAdt+pHWKRIZpSRiofUGZxSpyCKOM4a5lwUiZ5S4K03XlUrGKctmzHRelpRkyd7htNSOnTP7JXtvNOvpIF8h9f/5wU2vBdpqDhrL6TayDVEEHPsocBFm9CmRS6YfxelWK4nN24yRMSaWvcY7RasNVkPOQMlsRomvyEikdUxFnFeVRutCY6RX6KfYCGczrZW+CaVQO2FDypRcaKwlZYVWEg2hippiGQragMuAKizmnpvmjsZb/suvvJxf/dc/CMCnf/mzeNKnfh79KC5a88bSD4nOSwyFsQqvNashMoSI0SK8SLngrSKMMGSwWrOYObpGovdiKjzmyHPLuY6c4aCxnF945l5cY8/PHIedp3WazSgOTW6KKixMg4kp0nzPJFjZfZ6tN6wHcRQ+bN175b+LSqVSeaRQe41KpVJ5eHFPkeT3lt2XXf18O64Wse8WcFonaRhGKZZDnOLvQCPLNcveMAyBkyFhFLgkzrnemr3jiObyso8uCqMSc6dZnpzyM//067h061tY3HAzX/p//ATu8MKU+BE413mCKixaeQ0RMBdW1uz7x8ZKX7AeA7kUDlon8xWvRajhFIe50Ge5PkrBaNgMEaVhGxCRh9GMSqIA3dQzxlJovfRZJ31g7sWZeEiS8FEQgcaYEn4bOZrbqU8DPaVuhF3EIDIz8tYQyxRBGDJHN7hp9qQJ0/zhrDvYzilqiJej9Q5ad5cR3uJYa1AoaVqLiDhm3ogg3RqOZrUHqlQqd88jejHq6U9/Or/5m78JwJve9CbGccR7f8VjnvOc5/CGN7yBn//5n99b/J1tYnZ84zd+I1/1VV/1XrrySqXyvkrOhSHe2RbUW7NXJdzdAoq3hsZljjfTwsr0c8pbjS+a5VYi+WaNZTkGvDGEKAODResoRYrJMWWWfZSC1WqGUFAEWbbKBudlSSrlwjAmlId3nfSEnMXmtBFHq4PW8gHnO7y98rCndYZ5KWzHxGZM0wBGXKtkASxPagVF4wy6j6z7sFezJwrGKDql2YaMUZqYJBLjdBoS2cni9fStb+JXX/Bschx5zEf9Df7K//5sxqKmglvtFQtpzPsYDaM1xhTQijHKcGreyGdgtGIMl5utmZfrbL3leB3o4zjdc8XMGhpnCEkKdK3AakXO4pBVirhj3b4aZOGpsRitpkx0yxgzWivMZP961Dmc1Tz2XIe3mpsPWw5bd6+U1oupIVr1kb7IctzcKw5bec6zKAXe6Cvi867mnprGSqVSeW9Ta/tKpfJw5erYhV0kMchhrLi4KnLKnMZEzoXzc3GJ3dWMi9ZKFBkw95ZjHXBaE3PmZIyAQk+q2VwyOWsKiq5R3HjgWYdE42XRaBMSGnER0lpRkAhlcWHNhAzKRPoIty0TVhsWreWgc4wh7YUSfZ9hcmwdp2Wmw87to5aHJHHSc204N/MctY7lJKS4YzWyCeLumkqBAusxcrINxCiOrFrLe3DaoAx4ZzBay+BAi1vUNia0UsRcyLkQYiQmOWwfpmWn1ltmThPLpFLOkc5ZOqemml6jtEJFcZmyqmCMRhlD28gBvaHglETUHbaWWeuIBf74P/8aL3vBdwDwWV/8NXz2V/4Dhl08nTOklBlTYd5abjgQV62QREhBUaxDIBURvyysxbaekDIh5cktyqKK4mBmeMzhnM5pxpj33y9OW248bLlp0XJ+7lkNEaUU80YGNyHt/h8nA4S7E6uMOXPYOraj3NNFjcmuVCqVPbXXqFQqlYcXalpu2f14vb+i3d2X7Z7n6v2qq0XsAIednOHv0jhA5jopy2JPKZKAsY6R7RhxGsakmfmCNYplL4tDqRSGIAtEnZU4u9Vm4Jf/+Tfy7j//U9rD8/y957wYe/goxqEQG5nFnDLitCHkTGtEDH00cwzxanENbIPlcOa4/XSQGYOyqCahRlgcteSUWI+ZlBQpQ0oya1lPQu6UC6015JxxXtyVFBL3VwBXJNFjGyLWaLTSdM4y94UhRJZjYJsSR03msEukJI5Wo0qMGVorsXrj1P8YLSLxuXcivFEyg9rdY5BI951b1C5tpfPmLpeidngrvZTTCmvk19sx0TrDEBM5V0fbSqVy9zyiT0k+/MM/fN/Q3BVaa172spfxtKc9jRe84AX86Z/+6f7vSik86UlP4rnPfS5f8AVf8GBfbqVSeT9gG9KdbEFn3pCyDC1IEkV3d2fUu6132aBXU5Yy5KJI0yH8pdUgMRlINIQzSpyXppiMc51jO2ZA4jRKkWtJY2ZtI1rD0cyxGiJbDf1pYhszBkXjDYet2JV+wLk7L0Xt0EoU1NYoTraBMWSYdOan28hNhxIhF61m0RqONyPbOFJKYTMkUpH7NMR0OUM8SfE+xsIQI8t3voX//IJnEocNj/qIj+WTnvFd9MWRYpIYPCMZ3t5qtlkGMjFJjEaJok7Y3RulNIWM1jBrLZqdUrshU1huZCFLKSmsnVLMGkfjFLloMoGYCkczu3efyirz7uWA1WJnq49alFZoVab3lok546wMk7zT3HzQMm8s88be52GFM5qjmWOWDCFm1mNCTdEaSsn3ibcSp3JPKpt7ahorlUrlvU2t7SuVysORq2MXdofpZxdVjFb0MUmdvrkcZ7aLNt4GqdkOWsfJNrDqI1rBvLX0MWK2Cm0NB51hM0gIApSpvtNYo3CxgIVSFMsU6KeFIgCL1MEUGSjEnOmDuD2NxnDUyeJQyoWDznHQiBtUENumfeTfLq7vXadbrNH7eL6iFQpQRpb9rVFsBxFymEmIEGLhZJSlnsO5RwObIdNN0QolF1IqOFNkmSyCNgWnQBnNNkSGBDFDIYOCHDOj0fhS8FbTqJ3DqkRigyKVzDC5u1qjiUmjldw7WT4CbaD1hnnjaKyovJ3S/PkbXsNLv//ZlJz55M/+Qj7v679V1NNKc7KJzFIhU2iMYe4l+jpO77kUhbMGvZEaXRU1CUMkOiNPQxWtJbawmxy72knR3E0xEyKekGWqIaRrqtlnXha6rq7vrxarDCFzSuCwdbLYNX1/ViqVSqX2GpVKpfJwQytFopyZmWRad9+d+MbJuWi3EHO2Zr4rEXtjDdsxkaY/70PCW8OQAps48q6TLWOWdAtnNSEmxhAZo2IzJJQW19wxFsaQUUYcXlerLa/68efwjjf+Ia6b85nf8mM86nEfIkJwCnmZOew8Smk2IUrknjZc2gbmreWo4wpxTZ4EGDMnIvYLC4+3mlQK7zru6WNi4T2KRMjyNWPKzIzGqEKfMgpNKpmQMzYpnJHI9NZJRN7h3IrYJUnfshkTGfbpFptJuNHHhAuaMY6EbGmMxTlYTr2ttRqD5mDmOGwtRRVm3pDLnYXZY8wyx0q7GZq6V5/9Pl+kSC80xkLMZS/s2YZ0zeSMSqVS2fF+8xPiq7/6q/nqr/5q3vnOd/KOd7yDUgof+IEfyM033/xQX1qlUnkfYpgK8bO2oBKBlmitYQiZMWayv3akHkDMEvu2jomiCue9AyT6TiuFtnC8Ccy8Rk8RalZPi0XTgAYs52aZ400gZVG0l1KYNY4+JEqS5Z9VH1BaEcbCrBF3oRvmEvH2qMOWo5m/5jWepbFSTN++GiiTymM1RG7MEgXxnqWoqJdDZDNEtiEwhCJLQYopLjAxhCTPAShd2Nz+Ll71Y/+YYXXChQ/6SD7p678PbIOJGW9EVW6VwhtN6yyNMQwp0Y8Ja6Cg2AZ5rEYWznYq+oOZnYZYk8NWzCyHiDGaudWoIp+lUoVxLGgjTQOI/eyFecPpJmA0bGMiZwXacLyODFHem9HyOc68ZTZFW5zrPPPG0nlzvxXcWslnPm8t1kgU4MH9iMq4u6axUqlUHu7U2r5Sqbw3OBu7cLIZOdkGQhJhQmPNPm7ZWUUqmguLBmMVy23cRy2XUjhoPZtRxACLxmKU4vZVz3KbWPeJo7lEBmjA6ExrNOsg8WyHjcU7w6ItLLdhOgx2LPsi16Yg95BKYO4sY06EUNiEREiFCzOw2jH3hjJFrDmjCSFigD7JYlTn7dRHgFEaBRy2lpMSdjtXGCXuVP2YMRqaRpMTbIaAtVJzj9Npd1LQOEUphkQhxsImiBtUigVnDY3SxCJ1uzMKhcQEjqkwcxrTiJhBTYtRILHR2ijIGWs021FcXZVRhJBkGSwUukaWjrSWQcJNBx2N0zij6Kzh7X/2Ov7VP/2HxBD4uL/5GXzFtzxf3EBSYRvEnXUzJlLOHJ13aAWHnfz73acDINF5i8bu3WmVUtPnI4KFPkRQ4vA6ayTaofOWczOJyb64Hq84yL+4HtFa3UnN3tyFUAWuFKucbiNDyPRGVNObIXE0q4tRlUqlcl+pvUalUqk8+OycWHczkyFm5uWuZybXIu9itZE+Yfe8O64lYu+8PM5bzcl2YFfBv+t0w23LcS/+aLShcyJ6jqVQMiRVWCd5zpMsseZaKxbaokrmd/7V83jHG16DcQ1P+0c/xGM/9C9TlCzx2CmAzxqJfzNTHZ+LCEjWfcAoRXCZReNYj5EhJropin23OGSUYtlHDlsLPQw5gRJXKK01Ie7cZeV9xVLYhMxR68QhuLX7pScFOKPEqReZS+UkiRkFcMZw0BpCEsGM0bIovB4SyRe6YvGTC1UHPOaGGYedJ0QRyOze39XuYJLqofczNL8Tzd8DO08xEYpLmgjILM5bLd9Dzb3+9qlUKu+HvN8sRu245ZZbuOWWWx7qy6hUKu+j7Cxfd7agzoib0WYUBbPVstDTh8TMX/tHcJkO/nMpqCLPEXNmjInGWQpSkIessDljtRzw72idbOLPGsN2jKxG8NqizTTc2AayzhLBoZQMHhrNuZnfF6q3HLXcfNje6/d9bu64uBnJWTb9+5h5yx0bzs89pcDpNk4xcIX1kOljYRsGSi5EClZpVCkorcipMK6P+a0ffRbb49s4vOWDeeozf5BsO/rJhclq6JyhaxzOqEn9La5Jl9YjfZDHbKOo4DchcTJEbpiLhWtMEhc4jJlcJA4l5YJ3irm3rIaIUbDcRrYxMfdmGnbs1N2ZWStxhKKGgKOuYUiRw06sYhur8M7QGlF07Cxw749T1FneG01jpVKpPFKotX2lUrk35CzLLkPMEmdXLh+mNlbTOXNNy/3NkAgpc2kduLSWBf6D1u2XdFIupOmxQ8xSYzqLVgqzVfvD7DFmFq3jeCs12zYktFYSHT2pjW9cNKz7hLeilp47y6wxVyhelYK0luWh3ijmzqHMFINXxKmoBE3TKpSWQ3NnNTHJ15yf+8lVqRCiLHidDpGQMjN/+doap2kajVWy5C8H4NP90pplDiijaJRhOUbGKAtgJRcMCqULnbM4rTjpA2qq+cdQGFViG6U3MkhNP+ZMShm7+wyKKK4PvcHsXY/KFMGdaLWlFFgNaVJRF0576ZeUklhBoxSt1SitedRBwy3nGhpj8E7zlj/7U/7Ft38tQ7/hIz/ub/C13/lDaGPxVhNiph+yHPCPiZQktrzzlpAKNx+2bCYHsNNtIJdC5wwzb/dOruJlpabhgrhfzb0lpMwN3uxdnLyRw/s+JqxWLPvA0czfSc1+b2isYeYLmzHVOIlKpVK5TtReo1KpVB48OmdYD1EcaaeZyXa8b44/28lZyerJvXV63h3XErHvXXe1YjP1Qrceb3nXcb+Pg9sMkT5K8oTEw2mUkbo+pkRKkJA+02RYq8jrfvFHeNvvvxJlLH/j676XR334k1j1kVljuTDzTCEhlFzwRrFoHEOUiHEo3L4cWfWRAngrLrOlZM7NHTHBzIsY4tJqYNYYxixReMsBtJL3aZSShSelcAasNjgDWsuCk0ZPIh8R84eUuWMT8UZxaTNI7HlKkxBdEityKcy8lkUoL3HpMcqSVMiFOCaOOk/njYg1+kDnLGPMHG9Gcbmd5mA7d7AxZTqtz8zQ7l2/shN6q6m/aZ30Vbvnub9xjJVK5f2H97vFqEqlUnkwudoWdOfuszv0br1h1Ue2o6iQr5WbLAfpl38ds8TvGaXRrhCSFKZeG0IoDESxVN0V19Prp5RBKRZeIhuslsK4MZdVEc5p1tvEYedAg0XxuPMdjz7q7tP7tloz94b3LAe2MaKK4nQ7SvGMDARONoFlL81GSImxgNdi2Vq0RHHMnCGlNb/+I/+Y1XvezuLGW/jUb34hpT3EKlEmKApKaazV2Mkly+lCTJDy5IKkICNLXjkzRc4pTvrIwluGmAkpi7JdK3RQzBpLYxXbEPdNREiZUgoUcdhSalKMWFmUSrnsP+t5Y7jJN9x44Omc/O9VKRl4zKfojlljHnCcxXujaaxUKpVKpVJ5XyCkzGZIDDFxpyPSAglZQlpuAxkwWk0xaVAovOPSVpb+J6Wx01ocSkPcL1cprWiNoXOGZc6cbAOdN1xYeNQKVmNk2UtE9npQHHayYGOVpjWGMoOZMxy0jnljaa3hdDuyGRPOmr1LU84FbzQ3Ljy3n450ztJYaK1mSJnDxk7LOxltFPPBUSjikmRlwans3/pllyJrFCEhMWxKHLG0Ujxq3rIe45n+oqBRJGDuDAmpcxWKxopqOQOxZGbayutqGFaZ7ZgwRg6q8xR/PYYASk0x45oxyUG5LGCBRjGkwlGjOTdzElmhpI5dDolGK8x0gJ4KhJTQChonSunWaWainNgvr7Xe8J53vJUf/ZavZLM84YOf8DF81Xf9GBhxX81ZRCYFiKFcEYfXOYOZDuBnzqJQ0psoRedkCLBD7V9Pk7Oim3o+b69cdNupmvMknNlFjV+tZr+3dN6wDanGSVQqlUqlUqlUHvbo6Yy9j0l6qSFO4nJ1r8QBQ5Q4abhcNzf2SsHLtUTsIH3ibcuBzZi5Yz2wGRKbqcdbD5lYIE9ff9R5chpZT5lw1hpKEQFFKYAuvOn/+Re89XdfAUrz1778O7j5CU+e3IBFBLNoDSkrCgVtkNjuxsjikJXeSiPzhW3MhDGyHCSi7tImsGgth63jsG2IrQjUF95SSiGWjFYarw2pwLw1WC1C+wJsxyzOVkpjraJk6RNWU7qHM0bmJFqRSmHROcYkYgtrtIhOUGxyIlPwWmGn+21KIWczOU8ZQoQbF14izYvMtHJJlOnXVisGZGGtseWKGdo9Ic83Cb2n+VZjDOHMfKbuRVUqlXuino5UKpXKdeRqW9Bd8T3zZir4DMFlhpBZ9jI0aZ25ovjbDx+mgcWyD3TOcNBZYi4cr0bOdR5rFOs+MkwH31fjrGHRSME5bx2lwEFrkaFMwCpZzBrGTOc188bQWsMNi3vvFHUWiYtIeK2JFN59OmDMSGM1OUuOtTeaZRbrWaUlMqPzjj5lhpgIoefXfvhZXHr7/2B2dIHP+bYXc/7mx3DbamDMBe/MfijUWUfrFY2RoLyUsywqZVnE0kph0WSdmTUyVBpyZkiJxsnvQdFZS7MwaNT0uSlKFsV9zHBkHYtOIk9ykYHKUWM5v2hwRpFyYdkHGms46mSo0lhpGmbeirPVXbgQ3K/7/F5oGiuVSqVSqVQe6ayGuI/BA1k46WMi58uOUUXOtsVFanrczuXzPac9p9tAzIVL64GcFRcWDpevWnJPhTHIQXLrDMarvWPPo45a1OlAnxJQpP4ssGgNOVsaZ7h9NTDETMmFmZ+iBlA0znDQuP3CzXpILBSsh4i1illxHLaaMUJbxJGqc7KolHKhsRmVM7PW7xW4/Sjq38aa/fbOzEqfMsS0d0KaOUPXOYaoWMw9t68G1kPC2czMTzVvgdN+5FEHDbct5cDeKE1jpJtZ9xIjl4rU5ikrMgU7dTu5QMmZvsigIpVCodA6yxATSkp80s4ZVQFZFvsphVgKOZV9fN1RJypsoxUqFRTiEnvYeWZeE1Lh3e98Jz/4TV/G8R3v4QM+9CN45vf/JLabMYaMM3oaGEiPMCRxntVaMelNOD/3dM5waSNLYYvW4aLU4VZpSpmuR4sray6F1SADls6bOzkG71rAUmCcBBnXUrPfW84KcmqcRKVSqVQqlUrl4c6skTPu1ouL7BAyp9vIzBc6b65ZD+ciIuFVL+68WivMqFgPiQtzR1qXvSvwtUTs60Fiz1dDwmq4tBnpUyTERJ8K2z5ijeKw8RQljqx6J6BBQ0kENJAwWvH233wpb33VLwDwsV/0bB7z0Z9CLhIl3naKUgpiIispISEVhhRJJXNxPYpLrDOEWMiU/RJRyoWD1kkvVQpOa062gcZqDltLHzKnm3Ev1Lhh0VCQPmjVZ2KWGYBRhdYbjNYYDUppxihzFFk0Uqz6iFaaXESsYbQiqUImU4rBOc2FKUYdLYtJsSQo0rS1zjJzGq2hj5mYCt5ptA4sGkfjDOtxZIiT61OROdLVM7S7ow+Xhd5uEnp7qwnj5ee5j+1TpVJ5P6QuRlUqlcp1RCtFmg7QSVJcts5gjUSpbcbEonFAYAiinu6DLAw5q1CIhenxZmQzpMltSYrX3eF66eB4O9I4g1IKMyaKKthJTa7kQmRTv/M4rWm9pjGa83NPH2VwY6bFpKLgMedacgYmh6v7ynqIsjTkDKfbgNGKmDLWmilCpLDwht6CNp7jdSLnRMqZIWdZYEojv/WS5/Ce//l6/OyAz/wnL+Smx3zQvsHxu3mI0pxvvQyOKMycpXVi83o6RIzeLQcVtFWMo8Lowpgk3iMnaULipKaXgZli0Roaq2icF6eo6d4fto5FYzFac66zhCz32mq5VxcOPOdnYhd7buYxWnHj4sGdPjyQpnG3FNU4vc8mnzXVLapSqVQqlcr7DifbQD/FkfVj2rvonGUziosryOGq1lJsnm4lHno1BlKB5SYwJFmcWY+Jw1Zx2Dk0sugTUt67/KyGiHeao85JdN/k1mOjonGaxRQDvWgsKRf0kLhh3rAaAtuYKJPb6E5skafqPpfCkOT5TjYRrRU3HToOW8fF1UAzLfJbLYv5Y0osJ+eqlGEbEss+cFvIdKuBGxeN9CBO3FJzFjGFQfoZazTbUWK3Yy7MvJlcq6SGnDtLKoVcHCFnusFww0IWk+5YDmxTRu3OyUtGTbkRMRRCkUgKrfS0jFboU6axmvUQSbnQWk3jLd4onNKs+sgYM84aOsO+Tyq5kApoozhsrcRzA6uQcErTeYkcT0lxfOki//LbvoLbbn0rj3rsB/HsH/43HJ4/L69JISaJsRhCQu58JhVZEuunz18B88ZyvnMsh4iaFrFmzl7TCTingjeGRaP3UXtn2Z3/KyXRgUqpO6nZ7ytnXaigxklUKpVKpVKpVB6+OKOZN5b1EDlsHafTzGQz9XDeiLB7J2oZY2Y99XEhZrzTdFZ6q5mXWYmkVeT9AlQzfT3AyXYEFEPIDCFx23JgCIn1EDFGU8aMMuI4u02JFDN9SvRDkvjrqSdgSpV46+/837z5V/81AE/43G/gw5/yOTRWsRoSY8popFcIOWO0nqLaCzFn1gHGWNiOA3PvmdaQaKZ6fjvFupcigo/G7lxqRfjurWHeWmIvPUnOhc5b5o3BmYDVniEk7liPhJTZhkRG4TUs+8h6CBQgZZnrWC2JGn3I3LEaSEXmIo0xbIZE12hKUdgCuWRaa7iwaDjeRIaQ6K18/el2xFtDh2EIGaMiJxtFkYaHQmETIikblJJ+V1yE7/r7ZIxp37u3/nIayq7H3wm+789cq1KpvH/xPrcYdeutt/Knf/qnHB8fs16vJQLpPvBlX/ZlD9KVVSqV9wcaK/FrrZXCb4iZ+aRynjeiAO9DnoYiiX6UIc0QEztBex+k8LdGBjTOiAogpEJrDc6ICjmkhJpeT6HomssLMbkUlimjEEX6onEctI7OG5qYMEphNOQihWfnLJsx4oy+z4fnMUmzUpgO9CkMMXN+4Wmt5ngb2JK44aDh3ScDRhU6lxmSJoQyib8T/+Wnv5t3/PFrsL7hM7/5Bdz0gX9ZNqGUonMSnTcGUU0UCucXjtZKRvUmJELSaG32GeClQOcsrZWBldISg7IdEifrwNZpznUObxTeKayRqL0YC/PG0DWGG1vHhZmfoiysRPQNaR9HMmsMB63ldBvfq5at96dpHKdGCmSgddiKu9W8sQ843q9SqVQeLGptX6lU7iurIe6Xok57qZFAlk8aq3FGYgOMFlem1TawDIlYCt6afSzcmETperwZocDNhy2HrUVPh+0idhDnzewlCm07Jsbp9Q5aR84FpQt5u4t7VqLo9ZbHnZtx23LgglbceiyLWss+4LTe121KRXCWZR9ZDuJelch4LctXY8wcdI6Ftxx0DqXg3Mxzsh3ZDJHVmMT9yWmMlli19ZhgNTKEhLOKMYqjU+cc5+cejaJPicZIH7LqI6514lga5CB/qxKNkWu4uBlQSmLnCtLLbKa4hpzLvj8JMaOVCBfkzRUkdEFByYQ4iUxUoSgFRUnvY/WkbtZApg+FBKQoUXUXGsesNZzvGi6tB5gi9goi1IipMG6X/Px3fz3vesv/4PDCTXzTD/005258FABGaWKRWlmlwjAduButoRS6RqK/u0mUAuCs5kA5oHDaR6BMEYziGKWVPCZEhTMF5/T0+V/5vbpz/dVakWLB6CvV7PeHsy5UZ/9dqVQqlTtTe41KpVJ56NmJRvqQOGwdvZG+SmYmMl/ZsRO3SEKGRaNYDoHGaKxWhDSitfQRfpqbbMZEKiIszkVe7+J2kMWpceoLjSZnOOwUY2JaShJH3T5kJDRckhjEtQhu/6Nf582/9GIAPuzTv5yP/NSnT8tGDhT7ODk1iaslbk4zxsBmTOR8+X0pU3BKc9DYvZg9l0wGQiykEpk3MjwqiEBkOURaZ7gwvXeAc51l3rrpdbJEla/HfX/rjWabI11jyWVaLoqFo5mhNZoIGBU5VjCMhdMcyJ1EiVstEeYKKEri2O9YjYyx0LpdvwZWG851joPOEVOhdYaYCzEXtjFy0Di5jpBwRhOSzJVm1xB7yyzt8lKUd3qfmNE4zbKXe9Lu/uwaYpVKpVI5y/vEYtQ73/lOfviHf5iXvexl3HrrrQ/ouWpDU6lU7o6ci6i/Yxb3pimGQyvJi26MZo0UlVaLwno7ilIcZECilUSfNdbQWENMEnVQshR71micMRw0FmcMKctgZO4tzmqWQ2DmDX0Qh6ZSCkPIpFSwTlQLKWVaq+m85ahzKCUqdbh8AD+mglHTtRotEW1O712u7i07B6LlNjDGRNtYuqJQk3mrN4bzMxlMGK1Jqchwo4BpoJTMb/7rH+R//ddfRxvLpz7zB7jlw5+E0uCtwSBLXDElvDXMnObczHPUORlQIC5dcr8zlLJfQmutxmjFGMWdq/WQcsI5eew4KUiONwXvZVlo0Rq8lSK8dUaGaM4wn+IQF62l84bOG6xWVyi9z/77wea+NI07rFb7+EaQSI/F3ckxKpVK5SGg1vaVSuX+slMGw5VLUbOpdttFJ5QiC01jChijsEWTosTdDSFz0Djec7qdYu1kyUWUrYmFtwwho1XcR6NppZh5i9XTUlXIDEbqfYXisPNYrWTxSCkuzL1cby6cbAM3zGUR/2QzEpJE6W1CpI+JlAubUd5HzmUvDJjKXhE+TKpZZzSbMXJxPWKNpnWaPiaMQv5BsYkJhSw+lQJHnWU7TpEEWha3buqa/XtzZuR4E+T1CygURilOtiNjzNyxHBlLRim4fTnIctgUzVcQoYK34twkceGQsixFNV6TC6wHccSiFKySnsVosE6jiyJn6LxGK43RGWvkIL+zsloVong8zTtLiIUxSKwFaHIK/OIPfjPv+LPX0y2O+PLn/yTm6NFsx4jRGqUKMWb6IZGmGMOuMQyh0BgZaOwcxXaLTTJkSXTOMkZZhjrs3BUH+Tu3VpCoCRA3sLN/Pyb5XFtriCnird73avfX6emh6k0qlUrlkULtNSqVSuXhx1HnMFp6tdbJ2fXVUejrMZJL4ahzciY+nYN33uCtuewQnKSnO3tuP04uSPPGcVJGxjETYsFqLbF5M09ejyRdCBmsA50yRmdimsQhIWGVIpbC7X/8at7wsh8A4AOf8vf48E//ConL04pUMnYSS3hr6GNEIT3RvNWs+oLVcDIkGmeYNZqDRhIr5o0hTSLnzSD9lPYwBukbYyos+7BPqzAazs8aWfBSijEVwmZEI1HdChhD4nQbGaIsgXXOctBpZq1BG0V2Mo9qrWY9LYI1zoDSqMkhOehEAjZ9xmjFYWcxKGaNw+iy/4y0kpSSg06ENYetZtHaKcUCTMosh8CFecM7jjdT/HnhJI7kXDiauSl4Xe5BOCP09k7uE0h/H1PZR+v5KVqvuw8zrUql8v7JI34a+rKXvYyv/dqvZbVaXaHqUPfx9Gen7KtUKpVrEZIUo7sD/isokKYicQ0yKNFSiC0HWYKyRu232eeNpbGazSiWqtZoFma3tCQF/VErS1AAGmkGOmcIudAaw6jylBgNRzO/HwDNvKWUQioFY2RQAnIIryeVwi7uQysFBm6YBjOHrSMXrnC5OstuQ3+Moq4Q5yaJKjFK7Tf059aiNMSYubQNHG9HFLAcpgLcKGatZbkZWfWJ3/35F/HfX/mLoBR/+xuez+Of9IlYBZuQZFhRCrooQoTOSxHsnaakwtGBYxszzkrchzEKjSyktc6gUayGSNKiSpBKWh6TSibELMMnpUhDwms9LWtJdOEYJdbjyMpS1OlWhkJWK6LNzBt3hdIb3ruWrfemaVSKK5QyO+aNrUtRlUrlYUet7SuVygNhM1yOz9stRR12dl+H7xTDAMshMIa8X1TSSrHsA6fbgLNSRCkUNxx4cpaloBAzKyILL4e73ojAYIe3hs7LQkw/CSGGmLBao4z8TDr7o+nRRy1hWo5ZtLJYdXE1oLTCaXFyzaXgDLTaYJQmZFngiTnTeXGTzRmWIaIprMbL9fqs0VDATYMC7zSxiDjCOU0/Zlovy0WpyGDg5sOGDNPCksQqOCNig5m3bELk0jpw+3Kkj5FVHwlZnJa2QRa5YinkDN5JZEIBrDOoAtbAZsjEksXRKUM/RLkurfC2oNEYJf1EURJJ3jmFQnM0EyX1JiTGURaw3FTr9gOsYyCkQokJqwq/9KPP5S9e/19wbccXPPdFnHvMh9CHSOsUKhdCzCz7SEqFrjE0TnNh1nBpM8j1GHm9PiQOWqmdW2emHu+yGKYPab9MBuKctTuod9NB/VnxyXZMVxzk61Ht1dRnI9nvKw9lb1KpVCoPd2qvUalUKg9fFruZyTSD8Vbvz7LXQyRmEZkvh0CIBW80i1bv0xDOzj6GKepcRO7S04SUeffJBqU0Q0zEaTaw7KWfmDvDKiSMgRILqzFedl2aEjuUhtM/+0Pe8G+/m5Izj3vyp/OEv/sNaKXRGnISMYoxGo30CEpZSklYq9kOmaIUuUhv4K3mqPU007xDKc1s6qHETangNfQ5048S5e2tZhMijz7s9r3ljfMGa9R+WSzBJLCJbEJCKRG4DCHTucLMman/UwSkj045048iJO+8w9vMapuIORGNnsTrat9n7OL+Om/ITE7LynN+7vf9906cNG/sFAMoDs8hZc53DUNIzLzhtM+c9oGUy50iyq1WtN7sn7N1ssx2uo371wARPu2urVKpVO6KR/RE9BWveAVf8iVfQs75Ts3IfbW+rVQqlbtiNcT94hFwj4snSsOljbg6NU4zhMzpNjLzZV8MWqM57PR+2UgiJ+QfpaBrDSWBNWKduhpk6FAoHHROCsIpb7qxmlIKqz5yx3IgI1aindVkZ8ha7ExB7GY3YyJOsRut09x80HK8DRx1jmUf7+RytYvKOxvFtmMbIiFmLvWBi5sRP11vymCUmtThmpQzY5CFrFQyq6Uo8t/wa/+WN/y/PwPAU7/yOXz4X/80rFGoUohM6u2YmXk9RVCIkh0gA30s+88k5EwphXlrCJHpOgreSURIyBmlwcksTJbNGkM7NUaqiBqcSV3hU6Z10ozlPKA0lCxflwuc9pFZYwhJruGhsmy9u6bxahTSJMwaU+PzKpXKw45a21cqlQdCnuKpAbZTlN7szAEqsHfwGcLZyDuLnx6zGSMFWPeBVCTCuXOelItEKk/LUaPJe/v/g6tqqtZJ5Fyclm76MRNzZN6Ky5E9s7DSWM2Ni4ZlH2is5g4GWm8JKeONxDiUyRmqAP0YScCsk7i4mDNKGUKSXiWmzHaKGrBGUYaCN4ZzM8O8kQX6O1aBXDLOGKIpEqlnFHNnSZPA4vxcrmm3eN/5xKX1KH3R1K9oBcMofU4shZgSaorGS1PGgkaRKcQCxETM4JKSA/ys9stDWitxk1US8+0NhKJYaM3MSXR1IeOsiBeMUWzXCaWUOOnGxMXNyLqPDClTciblwm/9m+/lzf/tN9DW8WnP/OdcePwT0FoGEas+Tp+VOAE7qzhs3d5tVxy3DIetwxl53O5/TVrJwtQQZbFs1e8iPfTk+nQ57qHdCVWsPjNESPsFvd1B/sEU03itSPZ7/d/AVS5UUOMkKpVKZUftNSqVSuXhjzMihMjZ7lM7xiizE6MV6zFilWY+0ywau5+1nKV1hvnk3rqZBDPvWfYU4LblSOuNRL8VTUb6wmwgTa63ukDOEr0Xc6YUiem2urD8izfyx//mOykpcMuTPpmPevq3ELJcl0LE4hqJJI9JhCON1ShjSCkTKeRJINJMfY5VkkLSOcOYMkZb5o0l5sLpGOi0JabLgoeZs+hpjmG04tzM7/+usUZ60CQ9Xh8kdvCgs8y9YdlH2mmRKZWCKUqccynkUZanjlon8etA1ypyEoeuMezi6MWlF6T/PN4mQoKDRvqPXb8781fOHxprmPndLCfROumbbpw3OKM4HSJjTCIo8RpjNK0xe/MA+WxlAW63FNU4vReTzJrqFlWpVO6ZR+xiVM6Zb/iGb9g3M6UUPuuzPosv+7Iv42M/9mN59KMfzWw2e6gvs1KpPMI52Qb6cFl5vp2GHHfijEVr5wwzLyrizl1ejtpMX++NHJgrJUOOmAp5GgQ4rUEVFo1jM152gVoNEgWyGiKXNiN2UhasxjgNSgrrkPaK85wlhuJ0G+icNAixZFZbGfbMGytq6HmDtZrzM48x6k4uVzGV/aE9sI/9i5Py4tJ6pA95iipJtN6wGRJHM8myvrQZWfcBUKz6kVjAaU3jC6//T7/I7/7sjwLwtC/9Jj76b38+Q8zoooixUDJAISWJhmu1xlpNTHLAb63mtA/T0Eg+E6Uk2sN7iQE53gyUrIgFrNYYDYu5nVTnsmgVYoYpTqXoQme12MgC6zEz84rj7bi3gtUKxqg5aB3Hm0AuhXOdf0gtW6/VNF4r6rFzVTlRqVQentTavlKpPFC2Ie0t92MuIjbwl+uynMveTWdX3+9iF3ZoJTXkekhTbJpGK0hI3b6LOhvGhO80IWZyLlfUV1rJQfh2TNy+GqbINolaS1kECymXveOsQhauOm/4oHbOwlvefmlDUIpQJE5vPURxh3IKh9q/pjMikCilcLwNbAep1VGFGZbOKW468DijGWPBKMUNC48zikXr2I6RfloQi9Py17tPB/qQ0FoOnXd9iDMabxRBK0qGMYvrE0qhciYE+XVBHKl2S1U5T9F5WgbPfUzELBEMO2W3NZdfK8WMM4pzrRykWythClpprIbGK2KUzzOTWcUMRbFQch8sCu8tv/EzP8x//8+/hFKaz3zmP+NxT3wyfciU7cDCO0oSR1+rNcYpZq1h0VqgYIzihpnHGM3hJErxRrPq0xTrJ/2eiFQMwcng5GTqGfK00OSdvkItnc8MaODKg/wb5p6TbbjLSPZ79d/AVS5UNU6iUqlUhNprVCqVyiMLrcVlaN7AySZww0LckNI0lznrCnzNr59cisaYWfaB9ShJESCR6yGKe24ohSFFQlZoYAiF5RBIeXK3LQWjNAet5eJb/yd/9K+eQxp7bvyIj+OJX/xcEpqYEynDagg4Y6AkvN1JRti7IG2GiDWKbUhoreis4bCz5ATaKKzW+0WimArOao6UxxqFd2ZyviqkkklFxCjnZ56Dxu7TNMYpWcNNfWvnIzcetKz6wDAll9yw8MycmcQtBW8VQ5SUjfkUeweSQHLQeqBw23IQgXpWcm+KJFl4q1kOkZJF/DLz5rLw5hp9TOeNzMesYe4NSknk3/l5g7N67/qci8IWEdmEmHFWnKqGeFm43zjNYSvRejvXsEqlUrknHrGLUa961at4+9vfvld4/NRP/RRf/uVf/hBfVaVSeV9iNcT90EQWf6QwU0oWc+7KonU5RBqnaZyoyGdetv+3k5XpEOWxZ9mM4rwktqCWmESFnnLhZDNO6uRCazXLIXM6Ro43QZTrOxW5Kmjk1zkXTvrAorEYo3jnyXbvLnV+7rkwWZp2fvrHGS6uRTExToqIW4979DTUCClLJEnM03KYqLCPt4FtEAV5QR57OkQ2MZIToKQBOF4H1mOmDxGrNW/9/d/kP/7L7wHgb/y9r+JpX/jVpJLZjmJtS9EUpRhi4qgzjFkcogCMKXRWlA2ZwibItYGSIlmBc4btmNBKsQmRlDIzZzBGIgO9U3hr6UNgnBoNo8EYsx9ghChDnTw1XKVMkYSTOkUbsEoK7tLJtT3Ulq1nm8ZKpVJ5JFFr+0qlchaJPLhvy967+rqfXKMaq69QD/fT4lQ4szh1raiyXYQdQGMkis5qTcyXe4HdIbI1Uq92/sqjlZSmKIAkSzYU2MZECWlass9XOM56q/cOtTcdtsway+k20MfEso/csRpFLJATMSSUNzhg3UcSskAzpjy9N+i8xAsYLQOE4mSp67SXpanzU3TguZmnFHj3aT8peyV++u2XerxVEqkw3QunFZuQySWzmWIlSlHcsLDcsUx0jWEMhcYbGqsw2jCmQucUxsjh/qAzWhn6KNF9KRWaVtMqTYwyMGidRRs5yLdaFpeUEkHDEAsMSe5HnoLFCww5wlBovKYfMr/3ip/idb/yfwHw2f/wu/joT/5U+jGzCRGdZSDunJ6W3cAZw6JxeKNopwgLq2QwsFNh71xxz4pdjJZlJGc06z6xGoN8rwKz1rIwMozpnN5/Rnd1kN84QxNkse2uItnvjmu5UD3UvUmlUqk8XKi9RqVSqdw37k8/9mBdxz25At8Vp30g5kLrDEYp3r3aYqblKJSijyL06MfMkKRPC5O4fbcUBSL8CHe8i9f++LMJ2xU3fuhf5Slf971sitvPDWLKRBSohEmKxOQcpZnEEZEhFBqnKVnRehFdW63pGul5hpSZe4NRoLxBR7CNYjtmZq3c736QCHDbaCKy6DSmzKyxuE6Tp/i80z5M76Nww6LBG83pEDg6tJhpgaidetzWG24/HQglM06OvjcsPN4Y0uRu5Z3BjQlrlTj+IjHrrTcopRhTnqL/Mhfm7V263p513o2l8OijTswBiqR/bEdx3k1FnLVy1pNjlMTHg4hAOm/2vXznDYv7ICapVCrv3zxif1r8yZ/8yf7Xn/mZn1mbmUqlcl0JKe+HE2eXombTItG9sWhtnN47R52fOc7P/TVj+DZjwmnNbGYZYuJkM+KsZuYt1sjQYDst/lgjW/lDzBw0jpPtQJyiKgrQGIO1ohjQWgZAmyHSOIM3ms5pGqvPKMPlsD4mGSykUjhsHe8atwxTs3HHehRFds4MUWImcpZ7NITEuo/0MWKV4bblgNZwNPOc9CMaidnocxQ1uFa87Y9fy3/4sedScuZjP/Xz+ZQv/SZO+7AfIBilSU1h00dSzigt0Xq5FBqjab1lG2XhrNGak23YqwUKGqM1Rk/Wt2iUUjhrcEYsuuaNnQrnwhA0SiWGMbNV0GXNUsH8nAMkgzykwry1eK25+bClj6K+WG4jzmpumEu8ihT+/r3x7VmpVCrvc9TavlKpgNSXu3jgO3m0FvYuS+sh3ikeeLfMtDucvloxuosY69OkgL1qcWp6CZyVP1NF4a24tDZOE8e8d5zaPc/CSOxdd+Y5lkOgj3Kdyz7ijRbxQRB3oVwgp3Inx9l5I+KIkDKLRmLtbNAsGkfnDcerkeNtYZ0jYSj75Sql5CC+NRLBYCZnJ+kllCxxjZEhyWJPKYUy3SNvNLPGMqTE8ToAsmB2sg1YDf30fmfOsAyZ9RBYD5GQ5ED6wtyJc6sKOANaZ9KQMVbcacu03NN6g9GaTmuKLcww9GNBmwK5kAooDYvGE5MowQuwaI28DyvNTj8WtoPEK6S0c8dSdFYz5oKOmT955S/yqpe+CIC/+WXfzF9+ymdhjcFbiNmIclsprFV0XlOyOPTOGys92hQIeNBZbli0hCifx7yx9FNM4U7sIt9XEkdop3seJpW215pVL4IZbzVpevzdHeTPGokFPCtWuTqS/WruzoWqxklUKpWKUHuNSqVSuXc8kH7sweCeXIHvivUQ9/OcMWdCzgyjyKwPZw5nwGhIaZrPTHOglKW2V0oWdUqBeHo7//mF/4j+9CLnPuAv8f/5hn9ON5+T+8QQIzGD0ZI+YRW4ybm1cZqC9Fe7WcQYM7PGMG9l7tN5ie7ejElshIE+SD8x95aDztGHhLeac6lw22pgjNIzHq9HzrUNrdd0URaaxpinJSWJU2+cpnOWO6xm0VpumHtWQ2QzRGIRYY21Cq2hRYOSHqKZxDvbobCNBasVzom4vmR5zFHnSEUWz6SntfhJVDJew1l5h7eyGLXr2w9aR+sM6yFybjJvvNYM7aywaMe8sXUpqlKp3CcesT8xTk9P97/+tE/7tIfwSiqVysOZ+6tu2AyX4/N2RfS9tWi1RnKOh5A5aC3nZo6cQRn2ivAd6yHiTJl+Hchlsv60eu9KddQ5+hC5fTly6/GWbZCFpJM4YrXGWvBGDtdTEdco12pyYcrBBooClQHDyTZy00KWfJy5HOUh15AIKVEyLFrLHauR7Rg52QaJ5zOauM2EBHkqnr1VHBXPaR8pJaOKZrWViLlxisFTqtBYxVv/9I/5f1/wbHKKfMRf/1Se+ve/jTJFh6yHSBjBNWCMRs8c25DIOdNquH2dyGUgkVn3YiF76C2rkIgx46ahQ2cNIee9+mDMCa2hmwYeVkFMiVxAFUhZXLBaZ1Ao1kPm9tWAM0rsZ41GT0tpx9uRmZeCezVE1JQZDpfzwyuVSqVy36m1faVSWQ1xL0yAez4M7WOij2l/GLpz4tn9++olkl0adrmLxSlgijuQrysUvDWElGisJmbDGCW6OmVxFj37vCAusBK/Hbl9NUKGdmZorbjJ3rTweGuu6Tg75rx3EGqnRamL65HVEDnXOVIqhJzJODmsRxytlIaFb1EK1mOilMKisXijiUUO38fJsVZriWwLqUwOtY7NIMtbyz5wx3qgTNHXqyFRKDhtGGPm4nogiWgao6FPhW0vdb5VYhObk8Zq6S+Gqd52ViLwUhaHqJTlYJ1SCEGWu2beyHOGBMpggMMpmkGh0EWTSmLM8r418v1ABqULRYHXije95j/yyp/6ZwA85Qu+hk/+3K+gT6L49laTciZPCufNmFFIzMN5pydHXJgZy0FruGHRAvBBN87wVnqVXTzg2e/Nc51ja0Vxftg6nNX7+PHWyuPv7UG+M5p5Y1kPkcPWcUq420j23eCjxklUKpXK3VN7jUqlUrlnHmg/9mBwT67A1yKkvBcNXNoOnGwCQ5SeDi3Ccm80NxxoTjYjh63ljuVAyIVEnmrtQuMMJ3dc5Hd+9Fms73gXhzc/jqc96wW42QE5y9zFGoNN0ud0zjBvHXMrwm1vDQX2zsPGSGS2URBiIRqJOl/20kM2TuOCYpjSLZppAeywcygFy22Uvkkhs5nJTSukjNVX1v07McYu7WTRWDpvsEZz00HL0gfGkFnrxGoIeCfRgv0YyblglGNMUeY2jaHx4qScMrhGxO8Zed+t0xweNjJH0VoE+1bRh8TsGt8Xu4/vbP++aCyN1fulvKtnaFd8PbxXlvIqlcr7Jo/YxagLFy7sf10zwCuVytU8ILX5A7Bohakw80UOsMfE+blHGbgw8wzTACQXyUceYsYZxRAynbP7wcCucI1TIT8mUQmfmztMr9iEJMORkDiaORqnuXHhmbUGg6YPomQuiKp6PSZyViQKj5p7tFYcbwJ2UpnvmpqD1vLOE1mEKkUGJv0guddeazbTElKRpA1WY6QPYjdbkqjODYWL60Eek8UCFVU4fsf/4pf/+T8ijj2P/+hP5LP/0feQ0KzGiB7BGoVzillrSSlDFPVBSEryw5WooQvQGsmrTjkTY8ZazcxJAQ0yCBtK4rQXe1mj5V4qoChZYDrtA0WB0ZpMYghpUkSIIj1naCa19WqMZAwLJcoIqxWt1aQiy3PnOsn7vislRKVSqVTunlrbVyrv35xswz7Cup+WQGK+UxV/J5eldlquz0XUw5TLB607B6kdd1qc4s41m1ISlaCVqINLKXROjk3m08F0nOp5qTElgllUuxLxFlLmtvVAzJmZt1xYeBaN4VEHLfMzB8PXcpw9JXDYijjgwtzzuAuzfV8TpqGAN5rb1yMAFxaN1MO5sOojMWUaJ3EGYecKZWVRaRPi/usVsqjkjKiYV0NEK43ThtNtYJkDm6GwaDVtJ45SaAWpcLKOjDmx8BbrFWMq2EkAcnEdUcAQEjlMn0MCVTTWaQwK66b3bzKbURFiYdQZZ8ApRZiiIM7PHLlIDT+mxHbM9DHC5EJbEKGEMxKH/dbX/Q6/9uLvhFL4a5/xdP7Olz8T7wxqCygRvlijaac49J3Aw2gRQzTGcOPCczhzHDRykTcdNFyYMqrv7qD+PH7ft4WUmTeWGw+au1y+u7uD/EVjSbnQh8Rh6+hNuttIdqhxEpVKpXJP1F6jUqlU7p7r0Y/tFvSvJ/fkCnwtttNS1PF65I71SEyFw8YTYk9M0uMNUd5DzOCdZt5aln1g02dUETvbuFnzX/7PZ7N691uZX7iZz/gnP4ZZXCCWTCwyw5HrEzdccYRKzJ3GKLlWrRXbUe4ZqpCzYu4bGieCCKUUOUukX9gmtiHjjeJ8J0IXQGYRRhNTYT1GvNM0ThasGiePuXrGs+tVNmNi5iRJIyS5RoCDxjGYBKVwcS2euX2U1w+RKYFD47QIfEqB7ZBwTtNNaSRaKeatwVvDzBlyFrfcPiWcnSL+rvH57PrxXd+++7czmqOZJmf7sIhxrFQq75s8Yk9KPuZjPmb/67e97W0P4ZVUKpWHGw9U3XB/LVrP0nmzbyDGmLFGcXEzYo3eF3TbINnVu3xkrdUVrlTrKXpix7IPDLGQc8FpReMMndccNBZnDbkoSlY4rzma+f296FziIGdWvdyTbcj4DKUEDnYNy9TUaCBnKcDferEnZLn2udac9NIg9VPO825xyyiNVZmBgjEKbzW3LROZQsiJGCGfvIt//8++gWGz5DEf8SQ+99k/xLzrGFNmGyJ9zHhEhd+Peh+f4a0hxMIyBBbOsI6ZkmBLggwohSoQUsLrkZwtWsFpn0h5undTI7KYBhxWKzTSOAxDIuRCMzl05Un5cNBK3nbOmZhEjX++8zRebGJ3n+PxFHvorQyVtiFdMfCqVCqVyr2j1vaVyvsvqyHuD+HPRlgrxd5Bdad0vSuXpe0oUcfeyuEzSR67WxTZPd8Vi1N3lk/gjeYkFryVhZ+QMoedxU5L+XNvKCXvY6nHyT3KGsVqiPuo6TBmWmt4zLmWzhmOZv6aNeK1HGd7I06mmyFxNJP3f9Aqblo0xCzii9ZKXHRMmZjkkL0g7q5+coSVeAKJYxtjppSCVZp+WrIZk8Q45ASX+pExJm5f9sRc0AqsRvoMo7i0kai4PiSMFpFCM8VBFDJaaYYoB+0hS5+glbjRMoklDgpkZAEpZ8ha0zkYTdk/t1IKYzRGqb0rV57U0UwR5FYrMAZj4LD1WAtvfv3v8f/80LeQU+SJn/wZ/H+/7rnEXDBJ4vhign6MbMdC9qJsnnkZRBx1HqsUjzpsOT+XGAdvNBcWnhumpSi454N6ZyznZp7G6CvEMPfnIP+ocxit7tKlqsZJVCqVyn2j9hqVSqVy11yvfkwrdd3r0HtyBb6aPM1iVkPkeDPKNefMZojcsQ6UXMilMG/sFKetOd7Ite/uAWjGccvvvORbOH7bn+EX53jKN76AMruBUMBr6TH7GCXaHMWsdRil6ZxEziml2IbEYWcZU0GRmXnpXWIp6JRYjZGQM8ebkX5MsmDkC9ErTraRVAo3H3ZYs1t+EnfY1RBEJOJl3uGMxNedZSfGuDCXPz/tAySJvdNKsRkTjTU0B4b1mLi0DbLclArWKlIBm0EbEZBvx4RRMlNZjxJ9HlJh3pi9gOioczLTmZbYrrVXB+zj6Xc90dWfqdbSI59pxSqVSuW68Yg9Lfn4j/94Hv/4x/OWt7yFX/qlX+Kf/tN/+lBfUqVSeRhwPdQNMU15zvfBovVqtFJ4o1kPkdtWPY0Vl6FdkZqLRPyVAiebkZQLRzO3f51lH/YDlyEmNkPk4nqkIAOBXYEI0AcZ3uScMFPUhUIK85xl4BGTIiZRHg8hcdA6vFEcNBYU+6ZGrncgpULjNJttpGTYFDjdRFZ9RBtwShOyKAhWowxSUi6MIeKm97oeM+shc3rxPbz6hf+Qzckd3PRBH8b/79tfTDubEacFrJAUSUmR3Y+ZMQ4cdk5U0SmzjRGLwllDVxJZwcJbtiESYyGVAgrSOnJ+rpk3RhwAtGIbZLGr8fIZNkbTeYmnsEYTLXQ2YZQMwqyRaIrVEDlsPZ2zNDOJ5zvo5PPZPaazBrdoxDVqUo4PMdeivVKpVO4HtbavVN4/2Tm4wpWH8GcdVM9ydy5LMWW0gtYahiC17Xxa5ofJ8AhQZxanrnaEdVZNkQgaa0RPmydrf6126mPFopXfWyNRBnpauvLW0A+JWWuZe8PMWWaN4cbF3ReIVzvOts4wxCRL/1oO1Z0zHLaOzZiYNx3OKPqQeevFtTgZhUTM4LS8WQWgRO0LUr+vQ2LZJ2469KQMf3H7mlTkfi/7OLnlarxVNE6xaB1awfmZl2vQimbu0CiKgpNNYDtIf5CTQmsYQiblTCqgSkE+0ohq9LSYlelay0xrxpiZawgxk0omxEKnxcVpNcQpwtoQogwDBqvQSqNUYe4tF+ae97zljbz8+/4RcRz4yI9/Kl/8Ld9LREQPRkHMhVym6Aor6ugxZQ47w8KJKOXczPK4Cx3ealpnOGjdXQ517s1BvbX6AfcENU6iUqlUrh+116hUKpVrcz37MUnm0Ne1Hr0nV+Cr6UNiPUZONiOnQ2DZR5giqHeus8aAt2paNPK8Ja1xRjNzhmWJmJR49b/6Du74X6/Hdgs+/mv/Oe7CY9iEjKagrZ7cn6TXmHnDzIuQJheIITOfeYwCazTnZg5npPdZDwldxJ14MwxYA0MQgbjRhVQyXjtiKWzGzPEmUJD51Jgk5m/ROhTSozkjsy2t1DXFGHaQvupsj3xh7vFW78VFB60FpShZ4gOd0eQMqWSJGy+yFDftg+GMxuqCN5pucqxqJ1eqZR/vtMx2llxEoAPStzO9t0qlUnlv8YhdjAJ4/vOfz5d8yZfwR3/0R/zUT/0UX/mVX/lQX1KlUnkIuV7qhj7IMOK+WLRei5gzJ9uAMwpvDEPMnPaBnAubIbENsvnfB1Fw6x4pHpHDba2kaN+5VwEYJY5MRsO8cVzajFN0R57i4go3HjRT5ETmsPOshsAYxRVJTQtAjdE4K65HM2/3Tc3JOkiRPia2QyTlgvaGEBJKwYWFn1QFkeOVOD1twy7LWtGHwjoEYkhEYFyf8poX/2OWt93K0c2P43O+9UUcHB1QiiZm+Qz6yRUrl8RqFOvWnZpDFY03hlmn0Vqz7iUmQpoNQ1GKlDJ9nLK0lUQUKgumaNSYyUUcn+aNofVWYvCcZHznHFBaM7OGg0b+zBjFQeNwWu5zzhLFZ7QsRc0bs1dX9CGx7OP+e+WemrNKpVKp3DW1tq9U3v/YDJcFDbva/ayD6rW4O5el9RA56NwUiyAH9jsxgTeakBKtMYyTi1L25YrD/t2Bec7gnZF6fVIdz6Y6cjNKXNzcO6yRCAWQBarNkBiyHFjfcNBw1Dnmjb1XIourHWe91Xs30l18mjbiGhtzQqFZ9QP9mImlcDpE+Tqn8dpMtauidZq5N6QCqzFhDJz00kNYpfDeTE5Qis5bOi+9T4iFmDN9LPRjJCY5tJ+1mlljWfeRMRSUVtiERH1nWRwKSRxdrdH4Iu5c6yHTWUMGSso0jUVrOTDvrKFNhtPtiFWG1llxprIGp8UNN09iiBDFPXfWOC6+88/58ec8g2Gz4vFP/Di++LkvwDiPTjD3slQWU2IMmV4pWi+DicYZWquZe8ujjloWjeP8zD/slotqnESlUqlcP2qvUalUKnfmevdjO9fb64VWikS5S1fgPEVQj0lmALevet513HPcB7ajCDusUfseIpTMEApbLbHVRisOWkdIIkgvOfNf/83zuO2N/xXtGv76134/N37whxNSwSo599+mDAXaRtMohdOKIWUyCpQsCXXeYJSa5goy55l7O4m5EUGLUWgU3orzrtGKfiwslbjlzg86Ee5vL98Pq5UsJhnNzUctRiluXDR32Qt0U4/srb5Tj+w6Tc6FIUov2IfIekg0TuLHd/Qhs2VaZNLSVzutyLBftJp5yzCZDFwdkXeW7ShGAVbLjEtN11ipVCrvLR7Ri1Ff9EVfxKtf/Wpe8pKX8HVf93WEEPiar/mah/qyKpXKQ8D1VjcYre61Reu1WE7FNzAtPo3kcvm5NkFe8+J6ZBMSrVEoGrSW5ShRAyvGmFCI0nveWIaU8UXUwp0z5NbTx8uxgesh0voARTHEJJnZ07046jxDFCXAtbKeUy5kRH19+3LgdBsmt6kirk1Go4HVGIkp46blKm8Uq0EajW1IUGAZM2O/5nde/M2cvvMtdOdu5O88+0ex8/OcbCIHnSUnWQrLRVTiWRU00jBohThPGZg5w8x7lC5cmDXccq7FGnl/q22kT5lNLzEdnVMsh0QKYotrjMIYReMsh52TeJUpmiMX+aexMixqnWFM4jA1hIxrNLnIsOFw7jhqRYUx85f/17n71rg7JUSlUqlU7h21tn/w+JM/+RNe//rXc+utt2KM4bGPfSwf93Efx+Mf//j36nXknHn1q1/Nm9/8Zt75zndydHTEYx/7WJ7ylKdw/vz59+q1VB56doewwORUJLX73R3Cn+VOLktzA9OCfecMyymW2hpFY6XW24xSA+8OhfuQ9rXdGDPbUQ6Cc5EDX6PEMXTZBzpv9qKCRQOts4QkC1Mn25ExZU6HQGs1Nywablq0+/d0b9g5zg5TZNpZN9Ld8v2uTqbAJkRSgdZp1uvIOGY5sNcF7+WguZuWuWKWJaebjxqJahgyRiWSVlxo/H4gMveGrrHkDJ3L4gxV5HqGIK9dSmE7BFByKH86RKzSWJPZhMLMXY4O91bhtJ7iwQuZjLeGufe0zkzLT3KI3qckdfm0MGW15vxCFstigourEac1WYso4t1//hZ+8Xlfzer4Io/9S0/gq77rxSzmDWNUFMRRtxQwznLYaQ5nWYp1BTOx1eL8wnPUOTpv7nag8FBT4yQqlUrlgVN7jUqlUrmS696PXeV6ez1orJZlqKtcgdO04LMTle94z2nP8XbkjtXIySagjcT7DeGyu3Ca5iUX1yMxFYxS+7SP1//cD/G2P/hNtLF88j/4ZzzmCR9NTECRPhIKKYGx4LRGodBa4bXEgKeixD24Naz7yFHrJAK9ZEpRHM3tPnawZEUfI9ZKrW+UwihN6zWpwO3LgUVr2QyRxhlKEYfjc53nqLOTSOLuBRJay2P6mK7ZI+/6DG8NSiu2Q6JQcEZTJqetkAsLY5k3dkoqAW/FAcsZcd6Cy8J+tY/Iu/JahpimvlBEQfL5VoFHpVJ57/KIXowCeNGLXsSjH/1onve85/H1X//1vPjFL+ZLv/RLefKTn8zNN99M27b36fk+8AM/8EG60kql8mByPdUNSim2Y7rXFq1Xsx6iLEMhmcslZ4x2WKNpnThXrfvApshwAAoJxW2rQRZzlCKmTFZw2DiOOkcfEqshElPBGrVXMTurGJMMHLzV9EEakZSlgD3ehL1KwVtNQRTo18p63m3sT+KGKVJQcdKPHK8DjVXELAtU3ipab5h5TT9avJFFsFljSSmxKoFX/Ytv59Jb3oibHfJJ/+CHcEc3s42JmOVdKyCVQinibpVzoXUaFOSiWDiDtqDRFFU48LLcdOOiQSlRFqxnEjEIA/2QGbO4QxUPY8g4bfBOoxX7pSim1w4xM0a5Ad5qUY57S8qyZLcNsiCnsKgiX+evUo/vvjXuTglRqVQqlXtPre2vL//u3/07nv/85/P617/+mn//iZ/4iXzP93wPT33qUx/U64gx8v3f//285CUv4dZbb73T33vv+ezP/mx+8Ad/kA/+4A9+UK+l8vBhG9LeGTXmIlHF93KJaMfVLkut1/tlpzFnET9sIzNf9vXwEEVlvBridCgtNfFO1LBzeNqOiRsWfloKypxuA+sh4ozm3NztHZakxpalpoU3KK05P5f47Jk32PvgPrS7vqvdSHc157KXaz5sHUMYGIPEMQwx0zaaFrV3iirAMCaKMyjAaEUIGTU5J1kth91DyITJyXXmDM10DUZL7zD3hosrWayyk3jkZEgSuaCl71Ba7ltBeojNmNBGYbQsOjmtyYjCW6XMkEbO6TljkGjCVAqN0TRa4Z2e4gINRmk0Cmug84rVKL3QyaVL/Pvv+4ec3v5OLjzmg/l7z/kxVsWzPhmZN1bUzEX6lnkjn/vCW/qQODfznJ87coFHHbYcthJtUQ/kK5VK5X2f2mtUKpXKZR6Mfuys6+09kXO5R1fUazke3bEakNN9IcTMZozcthp483s2lAK3LQdizhxZL4Jssgg3vCOkjHeK022QOVDIxJz4o5e/iD//3V9GKc1nPPN7uOWjP4ntkHCmQJEeqjFmL6QZQiJR6JzmQufZxkRBMbMGheLCvOHC3BFyIaRCihljRLB90geGUQTaJhs6ZzloDec6Typwug2ElDjZZlIpWKU5N/NYI4td52dTv9mYe7yfKRc2Q6R1hibrO/fIZ52VtfSLi9ay6iNjTBilcNPn0RiFM4Z5a9mMMk9b9oHGaYaYUChaI9e0m6PkM+YEgDhSTS5RZ6+/UqlU3hs84hejAL71W7+Vixcv8iM/8iP88R//Md/6rd96v55HKUU847xSqVTe+9ybgvjqQ+vrrW7YRdg5I69ztUXr3RFT3hd5x+vAGEVN0HnDQWs5aB3LPjBmyWE2WqPIpCTb9+JWpSm5kJABwRBkOGGNRLfpJFFvAGpqAkopVyw+hZhRjaKPSRZ+puvf3bmrHY7y1LwoJQMUa8Sm9tJmZBgTY0zEDFppGicDjjEUtqO8lvdGivyQ2ITAa/71/8Ftf/b72KbjyV/3/ZgbP5CQC04hEXtBFtCsVjhn8VkyyBsrUR5aw1gKjNC6wg1zh7OGxmtZVlJwNPMctI7OWS7MGy6uR063IzEX8gBDiWhjmE2xeX3IzCal/xAz2yjqDFmWkjsz94aQxDFqPURaZ/FGCngFd/o+2Ckh9F4JUQcqlUql8kCptf0DJ6XEM57xDH76p3/6bh/36le/mqc97Wl8+7d/O8973vMelGt597vfzWd91mfxe7/3e3f5mHEcefnLX85/+k//iZ/5mZ/hcz7ncx6Ua6k8vNjFw/VTHd+cWWK/t1ztsnTYun19e9g6ThEn2c2Y2E7R0EOUOhQF6z5yvBlppoWgzhsWU53dTurVmVbEOLKchA9linMLMXDUOUAWmaxWdJPSV6PonLlXA4Gz3JUbqZqudZzu1cl2ZDVGvNPMWyOiCCux2jGLC6tRMjzQWoYFrTMcD6KKPt85WZwKmVUf9lHenZNau3ESa7AZEq1XaAXbIeGdYj0kQkyklIlJXKSMVjgjcdVboohPpt6iDwlrNTlJZHYqhZhgPQb6MdHHhCoalGIxkyWqxhrOzzzeae5YjjTeMEZxAzs+XfJ/f983cnzrW5hduJm//awXMtoDtqthGmwkjlrHYWe5Ye45v2jwRhTNXSM9mQx+lCxQTd97lUqlUnn/oPYalUqlIlzPfmwbEpc2I43VLPvIUefucqYTUpYI8piucHsCRNwwCSrWQ9w7CqUsrsC3nm4ZQ+agdZQiDsDLIbIeIhdXA6UUlv3Isg+kDFbLNXnr8FYRY+GgccgrZ1DQh8hv/9xP8ke/8lIAnvKVz+UD/7dPwSoRo7fWsPOlGmPev6d5K3MHYzQ5w5ALChGNDDHRGMMQdwKdwhaZOaBlJmJbQ2csTSMznTSlazgrvdwmxWnZCIwpHCLzn8UkSJk3Fmf0Pd7P3b8urscrFsx2PbLVauoz1X42t3MAW7SOxul9j7xzQ96Mafoz6bePN4EhpCnhxBJiBm843QbGlPd9beM0h6081+76K5VK5b3JI34x6g/+4A94+tOfzpvf/GY53EQWBCqVyiOL+1oQzxqzL5yut7rBTQrr3XXsLFrvTWOwW4rahshqDADcOGuYeVEu79ykFLAeI9shkQvMvKUpmZQKuWSSEjvWUiBORb5KsgYVUmYzBg47T5mucvfzr3WGZR+JRZQA8uPw8rXv3tPVDkf9dA9TLqzGyDZmjIbNkFlHiebIpTBvLU0xxAS5ZFCKWCCNiZwzOSZ+6ye/h7f+wW+hreep3/D9HH3oX5HPNiQUmlIUrnPMvKVQWPURM2VqDymjkIgSSiYkWTY72QY6V1i0Yv16MCn5tVH7WJN5Y7i4FpV6ypnVmJh7sbONKXNpPRCTFN45X45azBRCzhwaNy1diS3uNmSMyTRO7eNMzi7l5VIYkzxPHapUKpXK9aHW9teHZz3rWVcsRc1mM774i7+Yj/7oj2YcR1772tfy8pe/nBACOWee//znc/78eZ71rGdd1+vYbrd8zud8zhVLUY997GP5ki/5Ej70Qz+UO+64g1/5lV/hVa96FQCnp6c8/elP55WvfCWf8AmfcF2vpfLw42w8HHC/D0WvdlnqvPQJfZBFqd7IwW7MIrqQ2AUZZBbF3uXIGvn7IaZJ1OA43oycbAOlwEErEW/OaEqGZnJl1VpxNJPIvdPtSEiF1msW7X0/brkrN9I0HVwrrVhvI0OIqCnKbt5YSpHD9SEl+lF6jcZp7LQoNGZZYhrGQioZY3ZxB4VtTOQMi9bSWE1RinZSDW+GyDaA3qt9ZfESBaebQOMNWkHKmT5qZt6y6gN+EmZYrfZ9RlYaaxIUWVK6YymLTAbFvDNYo1g4qccXC0Oe4iOWfeCc8jLwWK/5pe//Jm778zfSHJzjad/0Auy5G1n2gZjAOfl+KEVU2bPG7ZXKnTf4rBmjLLF5I3GDshBWlcqVSqXy/kDtNSqVSuUy16MfiykzxMTxJmA16M6Ti8wRrjXTyZOoe8c4CVxyPiOQ1yJg8FbTxzS9xhTTNn3dO0+3GKUIOZPz5T4q5MxmlMcaDWOUfq+UROMcmyDiks5qRqNIKfP6//jzvPbl/ycAn/DF/5gP+oTPkCh1K+5Q2sCFmSfGgpqWtEqG1hsKMo8KMRFzYuElpjtGSdxAyeyqc4bWazZDIMXConFYrTjsxMFK7hWcDgEG+X/TMC1hLRqDQkOBRWOnuYn8ejUthd2b+5mdLF7JvZE5U5zcrIaY97O1MWVI0lcddm5vPnBW+JOLPNeicZQysuxlSqW0YtWLw9d6vPz9ZLXMcHaicxEkPeLXEyqVyiOQR/RPnje84Q089alPZbVaAbIYUJuZSuWRx30p4HYFcR/FknXR2OuuNkddHkLsNui34z1bwJ5dlDnZyABl4S3z1qKm5zrp5X1uQtwrDKxRzJymIPnRx5tAKYWj1tE5PR3my3JPnNToyyExbwphioJT+vL1Wi1KgW2MeGM4u2l2V1nPu+te9ZEhZhbecul04HgTCCkQskIjr200xJwJSSI1tFIMMbPuI6/52R/hf/zuf0Bpw9/4mufx2Cd8HCHJYzNFim6t2AyJMYkjVskZbwytF7X7GArH28AwJLSBzjvWQ6J1GqM02zHhjEb1gc4ZZt6SiwyLrNIUU0hFFtwUiiGWaXEukZGovcZJzIkzinUvkXkSoyLNWZzua0GawhDynZbtdtGDVtehSqVSqVwPam1/ffgP/+E/8GM/9mP73z/hCU/gV3/1V3nc4x53xeNe97rX8Rmf8Rn7aLtnP/vZ/K2/9bf4q3/1r163a/nO7/xOXvva1+5///mf//n823/7b2maZv9n3/Zt38ZLX/pSvuIrvoIQAn3f84Vf+IX82Z/92X2OM6lcX+6Pk+t94WpXpPvrvHktl6WjThZs1lNkQOvMvsdwxk0uD5kbpsi7NDktjTFjtCJnia0zWhStIcmf++lQuHWag0npCnKvYi4SNY2630ted+VGmnb510Vq2s2YOTezXNqMLKcIiDQt/g8hUxTEkmmtiD9CLFLn5kRrpTcpFJQSB1g19UJGa5TSEnUd5T2lXEhJ4r/XfZTlqCwH/NqI++7JNtDHkYX3+wU07zVu5wgbE9sw7mP8wtRzzZzBWyNxd85MMXeW0z5ycTXu3/O7T3tO1z3/6ceewzvf9Af4bs5nPvtHmT/mg0lRnHcLoJXbu1JJPHZg5g0X5p4+ZPoQGFPBerOv7Xcq9EqlUqm8b1N7jUqlUrmSe9uP5Um0PcZMLrK0o5Sin8QnShVKKYyxsBpkJqK480znPaueYUp0MJOAI+Zr/BxOhSFIjLcsFInY/OJmZNE41kNPiJllkOi2zmsReodETIlUikSaaw1KZkXOGIaQOZjcjMaQabzmtb/27/m1f/l9AHz8534NT/xbX0jKmU3MzJzi3LxBAxZD1yq0kZnA/nX7Qoh5itCzmMn99saFpXWG9ZiYT+83F/AuoY3MXqyR5aRznUcrWbjqYxT1zpQkUlAsGnms1QqjFLMpIv54PTJMM51+cn+6p/tpFKRJLNROqSB9TCjlOF6P+MZe0YumLH3korFXzMakFw5cXI+MsdxJRLRoLc6oKz7/HbuZXqVSqTwUPKJ/+jzjGc9gtVrtG5mbb76Zz/u8z+NjP/Zjufnmm5nP5w/1JVYqlXvgZBvop/i7e1vAnS2IcynXXW1OkQzkmAszZ1gOUZZujLrbeL4+yKLMegyshogCjuZu/9z9NOgYYqJMwojzc88QL7/nXRyeJFLLQY3RinMzwx1r+aKQZHixHgJ50knsHIucnZTYAUoCzuxF5SIKDeAaWc+wGgLbMYrTFIVLfWA9BIaY8VaiMebeolBsxsB2yNIUFWkmXveKn95bzv71L/s2PuLj/ybWaGLOlCzLV6mALWCspp0KYm3EGasfMzFLbvbOWUsnhVKJzRhpes2tl3o+4EKLUYpxUjLsIk9iyrxNFWxRdNaSG2iNxihonSXkiFOXo/ig7BX9ucCldcA7WSwzRmG0ppvuU+PMFd9XQ7yci12HKpVKpXJ9qLX9AyfnzHOe85z972ezGa94xSvutBQF8KQnPYlf+IVf4ClPeYq4PubMc5/7XF7xildcl2t5+9vfzote9KL97z/qoz6Kl770pTjn7vTYL/qiL+Ktb33r/trf9ra38eIXv5hv/uZvvi7XUrlvPBAn1/uCkvPe/WJTvp/DybtyWVo04oC0ey/e6v2B7LmZZz3V+Luv2R/eK3WFOOOoc3ir9wMBqyVy7+yi2PmZnyLiCifbcJ8cZ3fclRtpzgWRSUz9Timsh8BmiCKcoOCUIhXYDlO/kSI5Q+tEPp0KnGwHAGYHlk2IxEmkAOC0OM/mAp2D1VD2i/+bXhy3UpYhQGMtiUzKmUubgjeJkESwcSmNGKWYN5bGQU6AKvvPwyqF1hpNZNF4FjOJj3BWcW7m9i67twe5VmcNYx7ox8hv/+vv5q1/9NtY1/B53/ZCPuiv/FX6UFgNI9tBejVvpU7XxYKSBa6CiDlOtiPbkDhoHd6J+hlg1lRhQ6VSqbw/UHuNSqVSuZJ76sdikkjys1FoO1b9KLFwyExhPSRaq/ezjP18Z5rpjDFTKDTW8O5lj0Z6BrVfXBKh+25+MUzuRcshMuY8ufwpLq1HrBahTi4i+r59PbIeIqtB3GmdVjTOYNBYp2iMOFUZJZHhY8isxsAf/vYr+fkXfDsAf+0zv5hP+t+/ljFmhiBuxH1MbPtI4xXWWtDSb+2E6yFeXrJVBY7mDQeNmRyMpbc6P9PMvd33ijNviFmxaC2dN1il8M7I/KTAwZmRfYiZTUg0VnN+4UhZ7ePndrOnWWM57cP+s7in+wnipGW13jtS7aLtOmfYjImDzrEcgohrsizCpTwlmijpv8eYGVPGG022gCpXxO1dbTCg4AGdHVQqlcr14hG7GPWHf/iH/Lf/9t/2trfPeMYz+NEf/dGqKq5UHkGshrhfirovBdyuID5sHdtRDup3wwm4PmrzWWM42UZabxizFMSn28jMSy70tV6jD7LAc8dKIvTmraVz8mO2cZKvDbIAthvKtE5ckmKWBsFbjVGKiAxGOgwxZeaNuCb1MbMdMs4ULm0Ci9bi9eVln8YaFFM0yHRdu4Wx3eKW1Qo3DTpaZwhTzNxtq5E+iv0tU4a2mjKvY8osC/jVuI+U804zpsI4JP77K/8df/jv/wUAH/m5/5APePLfmexRNUNQMFOUaenJak1rFAbYxkQfRIHfh4TWahqsJGLOODQpZbGPTZlxPZBKZtEMHHaexkpMSsoSvzdrDcOQUFosYeet5Id7a9DKTtcjrgetNQwpYbRmHBKxZOIIM8s08JJARW81nb9sE7sdLy9FNU7vLWDrUKVSqVTuP7W2vz78xm/8Bm94wxv2v3/mM5/Jh3zIh9zl4z/xEz+RL/iCL+Dnfu7nAPjlX/5l/uf//J/8pb/0lx7wtfz4j/84fd/vf/8DP/AD11yK2vHsZz+bF73oRbzjHe8A4IUvfGFdjHoIeKBOrvcFrRSJIovlSer99n64b96VyxKIYOJopsnZ3sn96rBzzBtLnqK41d30EAqYOcuNi+aaB7k5F25fDWir7pPj7Fnuyo10GyRCTyvFcoicbIMMFhRsBnF7dUZPsdQS022NTDkkCi9hlGI9iHvqoo14L89vreb/z96bh0ual/Xdn9/2LFV1lu5Z2RkwiSiIyhIhIaBB5BJQUEEJkogCrwJBIriBUVEY8I0SNYDiAm6JEUUIUXZEjSwSohEReb1GBlBgmOntnFNVz/Lb3j/up6pP9/Q63UPPMM/nuubqru6q5/xO1bl67vu57+/3Ox16Gz+4QmklKuqjS08XIn2MkDNKZzKKrDImy7tilDhr9UEcYp1TqCSDgRQ1ZWFQWhTJeRh+WKs5oGXZbKOyFEZunF+1VZESHFm0MMSKH1v2kOCDv/2z/N1734o2lm/5wZ/hi+73IJRWOJ3RFMxKcaYNMaOyAq1o+8SO7jFa3Hz14Kw7KQ2blRPRxzBYGBkZGRn5wmbsNUZGRkZuzpn6sf0iEpAlqVVfuOzlfr7Wihgju63cxw85s5HhQG3Zqt16pjPvAnutzEuOJY8d+rZpaTg4LW82Z6mcYbrvHrz8GpiVjhuaBj0sPk0Ky6ILxJCxiFutVRpUwhpNYQwxS4qFM4qUFIs2UljF3/3l+/md//f7ySlxv6/+Rv71v/0+mjDMd3zCmEE8rTVOa0LMpJikZwNwYLIkfYTCUGrDrLIcmBRMSsNW5Vj6SByE4npw9C2toVKaA5OCzdqhFNTO0g19tfeJBCgyhZFZxqS0XLFR0fYRazTzzhMTOKMI+2Zqk8EV92zvZ0xgDYOrrnzGRitxgVKykHX1pvz/sfMyj+vC8TjDk699YFrIvQEf0YNI5mK7TY+MjIxcLG63i1H7Ixnuf//780u/9EuX8DQjIyPny0plDicuRZ1rAdf5xC5elqN8lNi0i6g2t0YzHRZdNivHLnLG5eBqVRhRnO/fkj+y6KVIThlnpcBdfU9xGCat4vCM1mxUspRUWE3oZSFJIcroLibysNAk6gexTe1ijzFiVdunhFGKjS0ZMq4WyfbHAAJDLIg0ESD51yDuVI2X93O3DeScaXyg85mYI9bIEMinxKIJOKeorcEPSnWQAc7fvfetfPC/vQKAez/q33LNv/oW/LAkZrTDGo32iaQ1hcqURqxUU4aExH6EBD6I7W5E1Aa1EyWGGyIOnU/MKkvnIyjoQ8dG7ZgUhtZL1F6pNKZQOKM4NM+EnNguZIDlY6Z2ls1KoxX0KdEMzlQblaWNEbJCqczReU/XRy7bKFh2EaN6/uEI4iY2OEOVTq8VFeNQZWRkZOTCGGv7i8Mb3/jGEx4//elPP+trnvGMZ6wXowDe9KY38YIXvOCinuUe97gHj3rUo874fGstT3va03jJS14CiGvUhz70IR74wAde8FlGzo2L4eS6WZ1++e1kSivxz5WVWIOL6bJ0MlrLDdppebO/kutcYGyg1modGVefh+Ps6nvYaXoOzyVOuy4Myz6glRKVci/LTp/dabhxt8EaUWIfnnfsNQFjpBatrWWjtPQh00dZsjJGoaI42q4GHSvRwWXTEmc1ISbmbWC3hWlhKWzGD5EJ2iimhSUXsLOUaLuulwUrN8Q5zFPAJxE65AjGGBYhkLTBJk1I4LRiNsTmzSrNXQ9OSUlROc3VWyU5Kw5MC442HdcfCszbBFk+iw+96Vf4P2/9bZRSPPkFL+NLH/LV5DxEH6ZMXUrTUmhDQpTWrY8cXfbkISZiVlkOTgoumzo2Skdh9BjhMDIyMnIHYuw1RkZGRm7O6fqxVZIDiBvrKjIPpLaeDzOdZRvXfz+rHFdMS7QChbqZKLwvEjtLz6IPFNZw9WYJKHHHNTfvs1YLNtYoPrfTDbMjL2JvDU5p6VmSpEE4ozENdDFRupLlIMB2WuFDPi7kMIrr/+bD/O7LnkcMnns/6F/z8Kf9ME0CaxVFMqAVisy0MEwqQzXMQxSKPDgNWyVnVxpKbShLxZWzgo3aURUGozS5D8Qs/Z7VCqcUqlzNb+R7VkpR74v53k8XIvM2UAwzn9V7KnHxlmZYlALYrO0Z+8797+duE+h8ojBp7di7NZE+/oqN8gSx1KQ4u1hqxRUb1dhfjYyM3Oa53f4rdfTo0fXvn/jEJ17Ck4yMjNwSlt3xoctqKeqWFHCtiWgFyz5edLX5RuXWTkablaM1Mpg43ZZ8GhTek1Jyo7VS66zmY8MgoQ3yfRdDlNxOkyitJiSDUoHlkIWdswwk4LjzU11Y9FIGJk2IGK1ofJCsZ52ph+9ZDfF6pZMGYd4GcXlS4vK0eo/j8H2klFn0gaZL7LWBhLg6tVlsan3K+JzwnSKmlsrJtaxWfOL//hnvf91LIGfu/i+fwN3/9VPJZFJWomb3iQOTAmfF4rVyUuyvhjA5ZZqsyIjCPKdMpS0blSUBISSqIb5PhnMJpWA7lSwJdCFyYFqwUTkOzT19ipChdJbCegojjcVl0xJxfzJD7jcUaGaFZdFH+hCpkmHeBY7ORR1vjUYrzaIPlFZU9qufk826WL/fEuV3u/3f6cjIyMhtgrG2vzj84R/+4fr39773vbn3ve991tc87GEPo6qqtbvTH/zBH1zwYtT111/P3/7t364fP/KRjzyjG8+Kr/3ar10vRq3OMi5GfX64WE6uq2X+c6F2slBVWH3RXZbOl7MtTp0Lk1IWo052nK2c1K8hZkRfkFFKkVLCD89rfZKanrxezNqqHbtNGKL5IseWPa1PtL3naCNRej5FAgrdealvkwgAslL0PkhMdcg4Y8iAVhqr5eZ+5Qy7rSemLO6oGRofSCrTNKKEroxmkSIaRV04ji48XYJCQz8MAranjmm0pCTq4o3SkDWQFdYoclIoA3VpuWpWsjUp2KgsMWU2Ksv2pBTHWiDGTJ9kcWvRR9735t/iT3/nFwD41uf+KA/+2sex1wYRSsB6QLBZW5RSWBR9ihzeg9avBjqZA1PHZu3YqEW4cvlGeV5LfCMjIyMjt2/GXmNkZGTk5pyqHzs872CYLcy7/X2h1N2djyLeDgmI+MG9VsTVmRLRUy+6sHbnlQg5y2JI09Dq+Lxj2Uc269OLjUtr1uLv3SZQWk1OmenE4mOi6eXsdSFOuyFmJpXBGOldjdaEGGXGESIf/9jf8js/8f/gu4a73vef8/Cn/zjLADoGpoXFKKisZqNy63SOAxNHGxO9T7ReDaJ8xbQ2eJ+4bFJwcFasF5js4MabYIhjT1RO0/hE6yVJpDSrOc7p8UHeJTW8PVrL9bqQqZz0whu1ZlKYs4px9r+fkyKvnbgqZ+hCJCW7nomdKZL+ZMaIvJGRkdsbt9tJ7hVXXLH+/Z3udKdLeJKRkZHzJaW8vvndDDe1L6SAK61muSrKL7LafFpajFbDJr4MEE63Jb9VObRW7DY9PuZ1ES3XP/69w6CwNlqK9j4yLQytt+y1npQziy4SY2azslgjMSWLNrLoPMcaj0GhC01Mot7enIhzlk2JPkZ8zGirWHZx7bi0NRGF9IqV0uPwoiMEeZ1RCmc0ldP0MeIGlXyjNd5HGi/q7Lo0fO5jf8mf/uKLyCly9wc/ii/9pueQ0YA8B59xJrPTippDA4WyOK0wSnFwo2SvlUFPGzNOQxczTimMUZRKgzVYA33M+JgJWV672/bUpaWZyzBnlXVutMYoWfqyWvK5UxJVyPbUUTu7/vnzMZEybJSWYzGx6ANGwebESdOmMjllYsiypDUMbyZDrN6xpeeKcagyMjIyclEYa/sL59ixY3zqU59aP/6qr/qqc3pdURQ84AEP4L3vfS8AH/7why/4LH/1V391wuNzPcuDH/xgrLWEEC7aWUbOzsV0cl10Yb1IdTYuxGUJREG7indYKWxLe+ks+t3gQrToApuV40js2FkGjixkOcetHGeRAcBO4wlJghL6XmKdndWEkNFGanSnFXttpPWyGNX5RCLR9CJmmDlDHzNdBO0jXg1Cj2HUEGIWUYACDcx7T10qSlez9EEU14Pa+abdDq0Ve40nJkVpFdkaNIpjTU/TByKZutA0naifQxQ32AO1JpFp+sTEGarS0PYiYLFOD7F5DqUVZSEDlc3aMRmW4GalHQYxPQ6FtZq/fOub+ONf/2kAvumZz+ern/DtdDGxWTtaY0gpUzjpDVIEa8E5jUmKwkbaoAgpoHRJyhKtXVrN5Rvl2tl3ZGRkZOSOwdhrjIyMjNyck/uxo8uencazUVn6mNZ9YV2YtQi9DzJraPtIYRSzyqKVwmhFHyLeaLRWLIeZTT8IlH2Q6L26MBTD60tr6KO4xJ5pjlM4jepErGyUwmjpBUPOVM5wcFZSDX3LUe2prKa0lkOLhuXSo7Si6QP/+Inr+d1rn0W32OPqf/JlPPK5P4V2BTFLr2YMWGXwUcQqV80qDs4KZoVht4sUWkTe805EJBNnMKUIRGLKaKfYqh0hJha9xOLNhx43RkNKSfq/CPM+ULjjs6OTCSmx23r6EMnZ4mPGalj2CQX0ThOzRMKfym3qTKyXyIaZySpVZL9A6UyR9GNE3sjIyO2Z2+1i1DXXXLP+/eHDhy/hSUZGRs6Xxkvx2A9K8wst4GolMoOVLenFVpuf65b8SgFRO8ukALfvOXmInlvF9a2K/UlhSRk6HzkwcbLkM+Qx+wRHlj1O6bVFrTUyaLJasVUXhCiNQ+8TR1MvjcYQj5GyxL2VVmO0WisRrFHryL/Di44bdlt8SCw7jzGKEBNNJ43PtDJ0KVIZhVIGlaRR2P3k3/GeV/4A0ffc7cv/JY985o/SZcnpbkKktqJWJ0vj0wVxjjq4UbBRijNYSImYYGtaYBsPSlE5BSpTWYM1mqaPLLokhT4Kq46/16VR6AzHloE+iBqkMpmNWcHReY8zCpQmpMzSBzaSlUZLK+rCUg+fzV7npYnTikPzjt2lJyqYOcekMmxUjs3KoZWi6WXpbKuyHJjKQGW39eNy1MjIyMgFMtb2F85+hyaAL/qiLzrn19773vdeL0YdPXqUG264gauvvvrzfpaqqrjzne+8XvD66Ec/eovPMHLuXEwn18oZll1ka3JuatHTuSxNinzKpSyQmn+1lAXikrq6UT8pz98t6mIyK8UJ6fC8IyZwVhETtCEz7zwpZZa91K56eIsWjadNETX4vkqvYQD5LI4uOpo+ceNuK+ILJzehOw/ZSHR0zjBvk9T5IUudrRSVVVinh4WqjFEKkmKvDZAVl28ULIM40PqcyCETIlROY40h5iz/pcyiS/Q+sGglBjsDqrQcmMhCmCJTW1iGMMRtJGpn2KxlmJByZlKKorkPiRAzlZE/DzGTUWjEZeqjf/ou3voLPwHA133bd/GEf/dsUArtAz7BwaklZ7mRH8lMnF470saYKYwILTIwLQwbpWVr4rhqqxrr9pGRkZE7IGOvMTIyMnJq9vdjaSmDi0PznpQzpdVs1cV6DtL4QM4ye5j3gT4kZpWldIZCS+qCUrK0VFrDso+DuxK0UXq3jcoSogiQQ0wiCPdxLUQ+FQowWtH5yKIPVFZmBgzi6LU7lNFYpehDGiL+El1M9F1i7/ANvPFl302zc4TL7/FP+eYf/C+0upQoO6vZmrj14o/WsFUXOCeLY9Yari4dfUxcNis4suhFpJ0yXcpoZCFqFekdUsaHuLaDijGx6MV5+ejSyxLWpuamvZZ+6L8LoymdJiVxmNppehHBD7F7OWdylgUvpRXdniyJXTbjvMwBYHDdHYT07TDr6kI6pXvyxXBWHhkZGbktcbtdjHr4wx/OlVdeyU033cR73vMenv/851/qI42MjJwjqwi6VaxcOcS8nQ/7C7g+yWZ7H9KtpjY/ly35A5OCmMQtSSIvjjtXKaVg2OIH1k0BMMSNZHaWgRClwPcx0PSZI/PEgbpge1qwEt5XzhCyKPtnleXgrIQMe71nMVjKHpg6+pi5bCoxdp1P7LWey2YFMcFe61l0gXkXiFFi+Fov711MsOgD3eDW4JShLC06SOzf3g2f5I9+/vvwzYKr/tlX8C+f8ZN4DOTEtDRMC0Ma8ra1VqKYQBayrFGgFKVT+C4zKQwxizK+C4nKKUJUdDHR9BlUIuSMImO0orBqWBrLLNrERm1JeBovZ603DIs2YLQm5cy0EtUGZDqf6IOnMBpnZfS07AO7jR8aOrH/LZ1mahQTZ9ielmxPHNPCEofPu7AalGLpI5vD8tb5xMaMjIyMjNycsba/cD7+8Y+f8Pjud7/7Ob/25Od+/OMfv6DFqAs9y2ox6uTrjFx8LraT66ms+M/EyS5Lu4hj1bKPND5SrFyWpJSmD2ntFAqyFLVadJmW9jZh379a3NppPJ0Xt6fOS88SYyQkMEMtuVh62iALVJossRJ2iNvLkMjMuzAs5ye6GNlpIxulY1bLUKH14pAasyibNaLYRsGilQ0mBaAkqvvQXgtKFoYiCasU8y4yqySOYncR2G0Dyy5JbIUSB9U+JmKWr5cZerg8fC4+UxiNtZmJsoCidgalFJvDsIScscpwdO5xRpF0pvGR2GW2aofWMKsNH/7fH+I3r/0+coo85NHfzHc9/0fXn+ussvJ+hoRCxA5WQ8yQEzhtUA6KQmOGzbOt2uGsZlrYcSlqZGRk5A7K2GuMjIyMnJpVP7bXekpr6Fxir5VI7tWSk0gYYK+VvkScjBJOa0pnmA1LTYUVEfF+N6gVeUiuKK1BIz1oGyIzIzOd0xm6hpjW/VDjE4qMH2YxCoa5gWI3BDQQcmS3CUNPpMkpcfTwIf77j/8/7B66ge073YPH/+CrmG5tkttAAqxSNF2kjyLsvmyjwBpNaQ2btaR55AwmK7QyTApL1/TstoHN2rE1cey1nsIaCit9yLS0MkcwmpgSRxtP00lv2PtEWwamtSPkNLz3ms/ueFofUWjaEAgxUziZf1WFBhSLPg6uVOIyLM5c4bwMAuSzkuuu0k32z6pGRkZGvpC53U5xrbU897nP5Ud+5Ed429vexgc/+EEe/OAHX+pjjYyMnAOrQut4rNwtG2DsL+CkgA+3utr8TFvyKWUOzSWC4mTnKq0gDq9niIUrrRT37TD86UJk3sogoukzKSdiyhxtenb7IPasWor67dqyPXFkJLovprxeBCqsZrMqUEqKb2c0pZFmZt4FbtxtsVosa7soyoC2jxxbeuZtYFIalJZ88N1GLFu3Sosq4dDnPsPbf+Z7afeOctk9vphHP++nCaYg5yTKjsE9IKXEvPHsdRGlwBhRdew2PTEmNI5jTZCfhZyJKWGdonKWneDJCfoUKbRiVhgU0EWxii21ZpkiPkV2lzKkqQuDHoYrLZnLpxXWikrcOU1hND4mUZfkTBdEUbLbekDel3ZwMjswLdioLJfPKqal5cDEYYef0f0/M7c0NmZkZGRk5OaMtf2Fs7u7e8LjgwcPnvNrDxw4cMLjvb2928RZvPd0XUdZjvLEW4uL7eR6Oiv+M7FyWWp9ZLNytCay6AKLLnIselHHIss9ahBHTEvDtLTr2r0uzCVfUvcxceNex7GluLiSpTYNMaGNYmINrYdSKfoYCV2iGd6vEBJoRV1oyFBYw6SQOAujNUvf0/rIwkesAh8jvdcopdmuHUcWHT7K55dVxvtIRmLmlIYQ5GuVRrMXE3td4MC0YLr0XL1d4zSoDPMm0seI0oo+Bva6RB8SjZcb8yAiF2sMRilCzszbwOUbBmc1MSdQEuVXOHGs1UrOMaksxxY9Cx+ZOMNmLQOEzdpRWIkY//M//wg/9fynE73nyx/2KL7zB6+V/kep9c/ARmnZKIGsCOS1M+9+dA+7xg+iBsVGaZhVt9vbXyMjIyMjF8jYa4yMjIycntmwGJUz1NZQOg2D8KEP0g8ALNogbrJRhB5bE7teiiqdZlJYji39CW5QnRcR8jpFA4Wz0AURNgCk0+zkLAbxexgWrDKZpg90QVPajDGQEmxOFKTMXh+ZN+JSJVHximM7R3nDtc/m6Gc+wcZlV/O4H3glxcY2izbg42CDW0iyhdGKwomgIpGZlYacoCplNmFLRxcjkDm29HRRUi58yPQ5sVUX69jBlCw7jSfmjNUaciZL5AmJzOFlh8+ZnB1HF7243Q7JG/MuDCIQEe7PY6ALInyJMdNaTdtFDkwLtFJrZ67TxfKditWobPW5jHtRIyMjdxRu13eGfviHf5j3vOc9vPvd7+Ybv/Ebefvb386XfdmXXepjjYyMnIWTC67zdYtasb+Ac0avhzgXU22eUj7nHOWTc7n3O1cVVuNjpLJmcC5KzIczNl6GPztLz04T6Hxk2Yn1bBvikJ2tabqI1bK4U5gCrTSVk4UfH+WcRcgcmBQc2mu5bKOkHGL/Dk4LDi96FouOlOHY0nNs2SN6b4bhzSruI6OVZhkCWYGxCp+B5THe+tPPZXHkc2zd6R486nk/Q1HPsCmvM8KVUqQgwx+tGVy7JNrCaWkinDbstYHeB8rSkpMiK4UZmorCaRQKHRTWiJKkHRwMQsx4nciIw1STE1pD7BKVq8XCt7TUpWW7drQhYQ1YJZ9nHKI6tB7iE8k0XaL3ko8+LQyT0nL5rGRSWCaFWS9FrX5WL0ZszMjIyMjIzRlr+wtjPp+f8LiqqnN+bV3XJzw++VqX+iwXYzHqxhtv5Kabbjqv11x33XUX/HVv61xsJ9ezWfGfjq3aYbRiZ9nTB6lQrVaEwQloVYMrLX++WuayWrE1KS75UtS8Cxxb9hxbytL94UXLkbmnC1Fcl2Bdz4Km8dInXDYrSBGOhB6ShMnNKoczCqcVDLEMN+y09FniqW1hcNYQEhQm4wNMS0ddQBcDTSfOThrQBhRKXHZ9ou8DeojIW3SRmKBa9MScMRpihJhgFeSntUK0yeCsofUBZyXGXCmFteJOVTrDRmWJZBZtRCEDDp8SV00rlBKBQUZh0RijmDiL0nD1ZsWktPx/H/tbvu+7vpVmueB+D/oXPO1HXkHhHJUzTE8TrZFypg95HSW+Wp6KOaGVYlIYppWjcPYW95wjIyMjI18YjL3GyMjIyOkpB2HGjXuStrBROUqjaWMkJ5mJGC1JDpNSEjIqJzV6XZh1FJ70hcfdoHxKlOjjKRrkIUD8uHj+VEKHvdbTDjFzKWd2Wk8fJY47pIi1CrImJBHHhyjxec5qju317HUBHTve8PLncuMnPsZ06yBP/rFfpL7izuIQ5SNaa7TKRDKVNSgFpdF0MUmvomDpI9ZoEVuryLKXeZKzCus1XS+9z9bEsT05Hjuoh3i/ZR8wRuGj9NxKKznzMpBzpu2lj/FJovE6H0mIyFyRcUaxWVqUlsWplKQnVAaaIO5dl01LWp/Q6tydo1Zv+epzGVulkZGROwq368UopRR/8Ad/wPd8z/fwa7/2azz4wQ/mmc98Jk996lP5yq/8Sow5P6XryMjI5welGG6my+NbatV5cgE3Gxaa9qvNm17U611I68HPfuyw0HOy2tzHxLKLg13syV8YInIDXpyCDJPS4Iw+IZd7v3NV5TSZjDUaqxU7jZeYuZw5tNtyZNkzbwNdn2gHxfiyDxilCUkUBVolUtbsdYGb5j19Sly1WWGMpogZW8n3r7TismnJtLRs1o4uJP7x6JKQMlYrtIJlH/CDGlwp0GiqSlNGzbFGYvZiSsSYSRnico//+fLncOyzn2Tjsqv5uuf/PGmyzbyNOAcuK9peFpeMVcyMpXKOPnaDujxhnJYhzTB08TmjfGQ+uEoVGLJOBJ+ZVYaNyhCjRH4oDQSJyejCvgU15L+UwKfI9qSQCLwhjmO7dhycynuw04T1pCflLJbAHM8gnxaWKzZLtipxiKqdOW0zcaGxMSMjIyMjN2es7S+Mtm1PeFwUp/GiPwUnLx41TfMFc5YVr371q3nxi198Ua71hcSt4eS6/7rnS973GzVEM++/rBcdjwABAABJREFUkrhGHf/D24KwdaeRyIOmjyw6z027HUcacbqaDkv2KWcS0r/M247WJ4m7DuLuVFmNNWoQaCic0Sx9xGlFMJraKeadpnKy5N/4xKSQOjZEKJyh856UpL8xWpNSJiSwDD2AUaSoSSlhlF73Rseafu1KmySDGmsMpdaYQpFLy2a0LPqEIeOshiTDgANlAVpJHISVJTCrFYWTKD1QLLsISnqKaWmoCsN25ZhVllllmZSWf/jkJ/m2xz+W3WNHue+XP4Af+dlfZS86ll76sdqd2gFYBjKKyh3/uU05s9cGjFZUhaUyhspqSjsKGEZGRkbuyIy9xsXlyJEj/PVf/zV/93d/x5EjRwDY3t7mXve6Fw9+8IPZ2tq6xCccGRnZz9nE3yElpqVl1jty9hRGidB5Xw2dkQQGUh7mDCJw2S8qdlad4Aalho5NrVM00rrnXNX36qQ6f9GF9VLUvPP4mOl6EcWY0mCNwirFVl1wtOnpQiAmaIOkb8SYyd7z3172H/jHj/1fyukGT33xazh4l2toukjhNFmD9+J2a5VGa8WBiURwV1qzPXG0PtGniE/S1zkt71XvIxuVJScRyJRZZiv7YweXQ+JE6xO7jaewikkSsUYXEp0PLPtEH3riIOJfDbvqQjMrStAiNFkGWZqa1oa6KOhjxCpDIrNoA4XVbJSOZS8ipXPp6VcuYGvB/7gZNTIycgfhdr0Yda973Wv9e6UUfd/zqle9ile96lU45zh48OB5qZOVUvz93//9rXHUkZGRfWiliOR9sXJpvZh0PpyqgFupzRddoHKy8NQP6vWU9hX9WlENuc8rpqVlVlrmXRjsVo9/nTO9vh1UENPSMnHiinR02ZOyLCD1IaGUGgp/Resjy16i2w7Pe5rBNaoLYRhsKFxSlNqRsjQOKWWxUdWZbaNY+IDuwMx7rtoouXyzoukjh5c9ISUqJ/nVfYwcqAvckGf9mWMNTUj4kKgLy1btQMGiizR9Zi8EVIbaaua9DDBc7nnrz76Amz7x/1FvHOCbXvhqNq++C/POk7I0D/PWE3OgdgaTDfMuYnSmcoYYFdZqjIbOJ+ZtoI+JGCEZiU1xWtFnKJzGWiXqkaw5uFGwbAOHF0lcv5xGo0hK4j6skdyPpg9MC8OVmzW9F/vY7apko5Iltys2Ki6bZXYbz14XmDd+eE8yhTXMKsOdt2uxtgVRl59FYXGhsTEjIyMjIycy1vYXxsnvTd/35/zarutOeHyya9PFOMu5fnYX+ywjZ+bWcHJd/Xo+zqur5SJnNNFkfEj4KItWKQ+OUUCKmV3v126xPsoSzKQwXD4rT7jmrc0qRvvosifEzHU37rLXihOsVorN2kqtmjNdiHQ+E2IU59SQcSFKFEWGK2Yl25MCH0VYYbT0DCmDDxmjDVNnsEpJPEWIRKvxXhaVuj7RhYzTiu2pgwTzPtD2iTYllBYHKmUgJU0aPjOlwKdM6xPTQg2xdfLZXL5RDSKTxE6TpPeZKazSa7danzObTiINKys358tC4ZQ4wPZRauTK6sEFVx2vt0sjkdRHD/Hkb3osn/3sZ7jPl3wJr/6N1+PtlP5YQzcsnNUuDYtWZ0fceD0axayUiL/N2p7z60dGRkZGvjAZe40LI+fM+9//ft7whjfwzne+k4985COndHkB0Frz6Ec/mhe84AV89Vd/9a12pnve85588pOfPO/XPfvZz+aVr3zlrXCikZHbHucq/j4y77FGojY2KsdGacWdNaZ1P2aNCK4n5So+78SkBeBmblCr2r8yRhxsQyKtlqaGl+5v30KUBBCQpahuWJCqCkOFprQiTg5R+qDN0nIsZTSJFlmqajrPm3/uh/nEX70PV1Y86YU/z+wuX0TMCedk7uD7RFaZ2hgKZ1BkppVlWlq264LtScG888wbcdOVGHHYWM2avESQaw3OSOrFKnYwpMReG9bvsTMigtmuHQnpaXc6z84isNf2oBQGUEbep7q0pAy10ZAl3cM6jcoKnxKTwlIYPQjfE20vaSmlNTR9xNVnXoxafa4AlZUeaRSRjIyM3FG4XU9vP/GJT5ywTbz6fc6Zvu+54YYbzuk6SilyzjfbTB4ZGbl1KK3Ev61i5bqQmOZ8XoOYMxVws9JSWr0u+oshTu5UKDjB8Wk1lAFohxi+cKqg65jpvCgVaidKhc8ea9BaMSvFNch7KVSNjrS9LFbdMO/oQsSHzD8ea2j6QMoZjVxHOYU1CoWidOIu1YXMsWVHwkAWV6Z548lJhh+f7AObtZOhg1EoJcpsoxShjbR9K9asPq4tZ7VWOGPoQ2TRRw7t9SiliDnRxECMmZgyXdvxrlf9IP/4sb+gnMx40n98NVfe/Z5Di2NpvCgxMlBYg1ayrKSQxqeLiURkWsjAJKZMXVqqnNhtA10nS2ONl/d6Ei1bE0s1xOl5n7BWszlxpJgprCYPn3UXEgaNtfIZVs4SYmZSyusrp5mWlpzFDrcL4ii1PSk4VvYySOs8/ZB17oymMPpm8Xmn42LExoyMjIyMHGes7S+M2Wx2wuOTXZvOxMmuTCdf62Kc5VwHTRf7LCNn5tZwcvVRbgivos1OfOLNnVcTeS142G2P3/yeDDX9apl92QcWXaTLEondN4nSRWalY68NxJSHPuB4bX9LOdNSlx6iuZs+cGSIzvvkoQXHmiCxzymhMjRBERJUTpMiFFbhfV6LLlov16kKgw8ioAhJHGXbXgYQnQ9EMgZFUZjBWVYcVGk9MQE9WCWDidKKiKCNEa3FUQqFuKMaTdsnZrUsa1krvUBGorNjzlit2agNhTEoJSIHoyyQSVkRUxJnqZgxBvogLqwhK8pCrm+0YlJo9LBghRYHrMumJT7K3x+YFNxpu2a+u8MTvuExXHfddVxzzTW84+3voHWb3DTvqAtN6zXzNsgwYbjOmeiDDHXamJgVjlklPdKBSTm6uo6MjIzcwRl7jQvjqU99Kv/1v/7Xc3puSom3vOUtvOUtb+GZz3wmr3zlK3HO3conHBkZOZnzEX+jJGZ9t/VYo9moLJPCMtl3vdppFn3ED8/rQyIVJ850Vh3g6s9WYnhnpZ7vY6Lp/VpYAZwwt1ktRYmwRPpCZzTbtWPZBZm7KBFbzzuPAkmFUNKk9SHyB7/wYv72/e/CWMfXP+8/cfm97k+K4uAbUybnTCKTkwjSNyrHrLRslHbt4KsVTAuZNcQoPaFS4n9ltKIwBqsTzkqkoFaKPiVKo4gxDyJwEYlMSkPtDCFllr1n2ScusyUhZBadkvhypXBGMassCk1hZXZTO+ltJ4Wl9ZHCHj8Dg2i8C7IcVVozLJ7lM/Y+TR9l0U0rCitznFFEMjIyckfhdr0YBafOn70U1xgZGTl3amdYdGLzabUipEzTn5/TztkKOGc0WxNNSvaclerzLqyXovYPZZRiPZTRSgYMPspCV0iZz+21xJzZKKXJDzHJYlRILPuAUpILPbNWnKL6KEtBfZBpSM4wFMCF0VSFIeVMjKCMoioUV7lqiOXzHFv25KzQOnJ06cXpKmdKZ0Vd3keiSlgtsXXzLuBj5si8ow2ZqTPstD1tK8tTWUHpxPmq6QOHFz1tL/nhf/arP8E//NV7MUXJN37/z3G3L7oPvU+EQd1eG000Q751TPioWPSBQmnKiaVEY5UU+HVhsFqh0HRJXJ3mfcAaWVxb9hKz0YZEHzMHJqXEjkTkerVGD/naKWW0lSbBB4UiopFluWlpOdYEKmvZrCS+cGviTvhZUEqhVUYjDcRWLTng5+uScLFiY0ZGRkZGhLG2v+Vsbm6e8Pjo0aPn/Npjx46d8HhjY+Oin2V7e/u8z+Kcu1m03i3lWc96Fk984hPP6zXXXXcdj3/84y/K17+tcrGdXFuf8NHjjNywPZvz6rzzHF16JoUh5nx8Kaow1IXEpy26MNwgl6g5qyM7rafpAnsN7LnArLb4kCiHJfqVm+vsPJ08z6ao3u08y6FO3m0DXYgcXrT8w5GGECEk6SU2a4se9NIpZZRWTLReRx34lCW6OiaqUq/j3ypr8DlLPW0lIjwjn1FOQJaeIQ3RdOIolWgVoBWFNfQxyecaBqcooNTi4KqAaeHQSlTNndHrm+p9zFglkdfaKNo+sVHLc+k0KosQIqaM1oP622QKI7F9TRdBiUhko7IopdioLHttIOe8FlNUTjOtLIvFgn/zxCfw4Q9/mKuvvpp3vvOd3PWud+HQXse8C2zWBZ3P7LSenaUnpsxm7U4Zq5eyLLIdmfccbXqc1hyYipJ6a4jsGxkZGRkZGXuNW858Pj/h8ebmJg996EN58IMfzFVXXUVRFHzqU5/iLW95C//n//yf9fN+6Zd+iSNHjvD617/+Vl0mO3DgAAcPHjyn515xxRW32jlGRm4rnK/4e9EFEWtrRdNHji577rR1ontz5QzLPq6XnEISIfakOF5r+7CKzpM+KKVMGATbnU8cWXR0IXNw5jgwLVDq+PJUynkQkEQO7XUi7jaKFGUpaTUz2Z4UpJS5ad7R+kgbEos2sOg873ztz/DX7/kfKKV51LNewp3u+1UYI4kXzoqY3CeYOI3RMhOonPRthdPrMxkzCLl7mZ+s+o+c8/r/A0qBUeJ4VTlDoUXQk5ViVol4Rxlxvl31McvecdNex5Flh0KJQNtqUOCU5qqtihgyXZI+SxalZDY1Ky1xSBXpY6IsDN0w6zBKMSkkrr31ce3qdTJdiOvls7pYmQ18/lyXR0ZGRi41t+u7Qz/2Yz92qY8wMjJyC9BaUVpDGyK1M+wNww5r5M/PxvkUcFrLAOVsLj4r1TqcpFTfN5TZT+UM05y5abejGc5yyLc4rQkps1VLJvVUyTJO7xMxZyl4S83ndiN1ael8JCbJnk45E3Pm2NKLssAotLKUTqOURhVKBkoZupho+0SMntJo9lrPwUlBbS0a6GNip43MCkMmk5N8/UXnaXqPj9AMKotpYVkkz+7SD5avonT/0H97BZ/44DtQxvDw776Wy+79ZTQ+oVFUhaYwipv2ehZ9lEUjZAFKZZjWmjhEbCilqIGUoMsJpyEG8CHS9oGqkEzuNERp5+Hz2Gs7tJaYlMsmJXVphs9Es9cF+j6L25bNHLAFZSHuUFqxtrQ9suipC8P2xOGMXv8sxDS8VkkTNyvdLYqOOVVszMjIyMjILWOs7S+Ma6655oTHn/rUp875tSdHUOyPGrlYZzn5z87lLBd6jv1ceeWVXHnllRftel8oXEwn173OU1sDSAz00UV/VufVEBMoxdFlj4+JWenYrO26J9hfl3debpKHlDFKloAWfSD0ART0RmILrtyoqAoRYqSc2azOzaHgbIrqxSCiyBkWfeDQvKcLkZ2mx4cs8co+icOTVjgd2KgLuTndBhSi7J2URly1jCJGaLrEViUR3JUTtXQe3rc+gE+RcrjBjQI9LDGFmFEa6TGSGj7LPIhAoC4tdSEijJQUzmqcFfcqq8X9yWpF5YwMGlJiUlqs1jgn7laNjzgtg48EOCuDkpizDAGGPy+URFLUg7OTUUrED0ZTO03OUFpFzPJ7nSJPf+qT+eAH3s/29jbveMc7uPe97w3A1sSx2zr6KHGKADutZ3cY7pROU1npkWShKw3Lc4E2JJzWXL5RcmBSUheGq7frC3IPGxkZGRn5wmDsNS4Oj370o3n605/O4x73OIqiuNnf/8RP/ARveMMbeNrTnsbe3h4Av/d7v8drX/tavuu7vutWO9dzn/tcfvzHf/xWu/7IyO2J04m/83DjPatMziL+DknEMSEkln3GDvOV3cYPgofjvZQeBOpdEDHNvAs0fRyE62bdF8Yk0ejHfE9diAPT6l58nzIxyyLTZ481XDYrSLUjkTk87znW9Mdju0PG2eNuSm6Ij7NGsVE6MvCPR5ZoYBkC7/7tX+T9b/4NAL766T/CPR74NRgNxeAK5XNm20jChVEiTmn7xHbtmA6C9zZI8kU3iPJnlSUrWcxSyK/LoR+SxA+zjhiMOZOSOAsv2kwXpTcpKj0sNHmWXWRz+H7bTlx4QRy1SqPZqou1aAYQIc2QxLFROZZ9GNyUIxuVJaREjtKfmkZx+aykj+kEpy8YhCT98Zla6fR6IW1Sjm5RIyMjdxzGxaiRkZFLwqSUxaiqMPQpDW5IgUmRT7mIBKcv4FLOZDJHFv1ZXaFOx7I7rqBYNQv7hzKnouklomKjstyw29EPyvTSGnKGjcquHaY6H/ncbgcEln2iD+KY1PqAM4Yrt8QRKkboc0AhwwRtFM0QpVE6JdnbSuNToI2RkGTwlFHsdZGQJac65ozTmqPLnjZENqoCpTI+SBNSO03DkLs9xNhpLcoLp+Ed//WXuO5Pfh+U4iu//UVcdd+vYt55AplKK27Y9SgNtbVsVJKDXThNnzIhZJZdYqfzkGBzYul8IiVPaQxHQk8KicYPLlOdRyFNThcifRrehyAqDR+Px7CUVrPsE4tOlPpKy/evnWbRRkqn2G16Yobt5NZLVkcW/QmuAbdGbMz+X0dGRkZGzp+xtr8wvuRLvuSEx9ddd905v/bv//7v178/cOAAV1999UU/y8Mf/vCzvq5tWz7zmc+c9jojF5+L5eS66AIpZmwpLlCTQiIOzuS82sfEsaXHWVEBy7J6Xtffiy6s6/JV/DHINQsr6tlpb1n4METaQOMTO62nT4nNykm9PrgYnYmzKaqXfeDIoqf1kWUXaXygD5mlDyw7cY6aOENWmdoaKmfoU+bwoqMLFqc1fUx0UUQDsrAvEXp9THR9wtSaRSfxzClnlm2gCwEfMm2M7HWReesJMaF0JkTIPoHSaJ3RSpTGhRXlsM4ShedTQiMuTyprkslYC6FXGA0oiDkxLR1GS6x3SiJWmHeBSmusgaQUZnC5bYO4VSmtSCHTqUxVZKYzx2ZlmVWOrdphjYgc5m2g9Qk7uEt937Oeznve/U4mkwlvectbuN/97rd+r53RXLlZrUUj8meKeR9YdpG2TyxMXD8/xEzIIt6YOcuBmePApKRyhrsdnHBgcvOh7cjIyMjIHY+x17gwHvGIR/CiF72IBz3oQWd97jd/8zezsbHB133d163/7KUvfemtuhg1MjIinEr8HWJaz0qUVuJrq8CgcGa4364CN+62GC09xaywIjh2BrtPZFAXhi4kSicznd4n9tpAXcjMYdlLvPjKQVYrWPjAXhs4tuxFLDKco/GRY03PjXvd+uw+Zo4tOva6QGHEacnZYYkriJCj6SPHFp66MDgrPcpf/OFv86f//dUAfPW/ez73e8TjmRaiGMmIg9XMGGpnCVnek9aL0xJKYYxECYaYhsQJ6TeWQ3+mTGLiDFrJ+aeFxJinLL3Kyll3Fe/XhoRWIrrXWhbDWi/Xjt3QG1nFViE9q0FROOmZjVJMnFy7cjLPWLWmlTNDXyVJJhNnaQk0KdN0gWNaUw0zsyFdUITwMa3nGKXTa/GQRAeOIpKRkZE7DrfrxaiRkZHbLyv3nkUX2Kwcu0ihvhwGEcUQr3amAm7iDLuN5F7fbJEqQySvm4HSSh7zqQq9lPK62G2GgcikMGdcigoxrRe0JK5C/lxl2J44UbEbvV7IqpzEg5ROc3TpcdbgvaeyDqXBaU1LkoNzfNum65PkRitF20W64WsppbBqUHgPSu+YZCAUySx9JIkERIZOi462T0wLjU+w9IGQE/M2Yg1MnGNSGjqf+bM/+C3++g9eC8CXfct/4Mov/2p2m4DTihAycy0qdacVFrHPDTlDkkaq0JIHnrNkfO81EjlSakNVyHNrY5gUhoxl7iNGASjaQZUehmW3jSiDuaYP1IWo63cG5UgMshBWOBnKxBix2rIcmpo+ZnaWPQenMgzZ7xpwsWNjVp/zLXGdGhkZGRkZuRhsb29z97vffe0U9f73v/+cXtf3/QlxF/sXFG4p97///U94/P73v/+cBiEf/OAHCeG4Y8/FOMvImbkYTq67jafpI7PKstd51BD3djbn1SPznpxlob4NkY3SSTTc4BK0qrX3L0XVhSwdra7pzFA35systIQkblRaKXbxbFZu6AX0aW/4ni1OWwFHFhGzXhwLHF16UKJktkYW930CZyxaixrboIlI1IECUSl7WUpKKeOMYVKK2ne39UxqS+sDWll22zAskclN9bZPlAZ2cwINNiuSAZ8yBjBaHFFVhl4NzlIKtM6kIMrl2oiza0IWs4IRNywGYYkzIioJKVM4TUwRMiz6iLEKpzWrXqWLgX5wZ7JG1M2rG/8py+e0GqAopGbufGRWKf7zi3+QN7/xDTjneOMb38hDHvKQm30ms9JyxUa1Hgw4I2KXtowyUAiRHKVnWvUyK0V7MSxj3e3g5GbxHyMjIyMjIyO3jOc973nn9fxHPepRPOpRj+Id73gHANdffz0f/ehHR+HDyMitzMni72UfsFqcXGGI4Y4iOF6Jy5VWVMawVRdrJ9801NrHmp7LZ9X6+s5oJoVE6m2Ujj2kV9tZem6ad5Bha2KZD3Ha81bhYxqWk4akidLQeBE87CyDDFSARRchZ/aGe/gpZvoQyVlhraKymlnpqJymdIbWR/bawJ+95Q286ReuBeDR//Y5fP23P4PDC49GXG2dgctmBQcmJWZYUpp3AaMU8y7gk5zDGNhrYFpJ/xKiLHvZoU+aVRYfM6UzDJoU+pA4MHXkLL3kvA1oJd/z0kesElG3UrDbe1KUPrePid1FTzUsThWFYaO0bNWysFQ5cUdesYrv08PMKQ+zIFglqWh8SOQhnn7lOLUfq9W6nwbp2c43en5kZGTk9s74r97IyMglY5WL3PrIZuVojeQ2h5TpgijJT2ZVwMWUObr0VE6K8ZOjLtQQ7VBZQ2G15FMPjk4nF3yNj2SGgncoVFcRfadjNajpgjQZ5aCyd0Yi5LRVp8hzVkwKSxuk+I0eUInKWrowNCTD8zKZEORcpdXEnOmSxElYLY2AWv9dEhW+VmwO+dXLXuxml95TO8OxpcenxIFJweFFR9NJcS8RGqIyV2j+5o/fxB/9+s8A8NBvfTb3efSTOLbw7HWerDUxJtDSDBit6IbHlTXMSkMEfJYYE7IsHoWkRMXvEjrIkCZbxVZtUUq+Zx8y1siik9UanTMR2G0iVgfMxHJ02dF7WZgKWSxvrVZs1QU5Zw7Uxdped2WxG7MMjHZbf4JrwMWMjQGo7CrScVRYjIyMjIxcOr7+67+eX/zFXwTEBerjH//4WePo/tf/+l+0bbt+/NjHPvaCz3HNNdfwxV/8xXzsYx8D4F3vetfg6HPm/8++853vPOHxxTjLyNm5UCfXZog3I0PvE1u1O6vzqlbiTLRyXvUhQSm12CqmGiQ+b7UUtVFZipOuubox3A319ax0pLyK3ku0JlI5w7KLbE1uXqedS5z2DTuNxD1nURFro5hWcjM/Z4gpMXEatGLiFD5mfABjjjtO9T6xwOOcouslGztnmDjD0kd8SjKkCIHdJrAYBhi7jcdHcVqtjHyvbZD6WeeMRhTQzmjMILaIeYji03Bk7tFGavXKWJSWYcikMISY6BL0HrSRG/uVs8T1wpHColiGOOg2Mq3P9CGJS28CT0aTmUwMpZW+p7CaSWHXPyfLPrLoRWTx2p+7lt//7V9Ha81v/NZv8ahHPeq0PyNbtThYrYYQu0sRW7QhkhPrf1OUllp8Fd23VVuu3q5Hp6iRkZGRkZFLzCMf+cj1YhRIfzIuRo2M3HqcLP7e6/wQQa5PiCW/GVEiwckSWY7RND5gjELNRTAzLe26L5yWVmYVPjEtLDF6doa+xWnNsSYQYmJWWiwS6V05w9WbFSEmbpz367SMLkRSSnQhcnThMVYRh9hwUxiMkdgHmSGJyzBLiZ6bOMv73vWH/Pr/+8MAfNU3PJVH/ZtnMascPklvOS2MCLyNWfcPlZPlIB8T1iiOLT1djOisWA7C9HkbAEXptCwbWU1Mw2JYaTBKFqy0Usw7ERlNC8vheScuXSmhtGLpI0pLSsbO0hNypu/FwSsr1lHgWkeaXouoxx3vW/NJv4LEm3dB3J+NUczbQGE008IwKSw+JZxRp5yRrTjVjGxkZGTkjsD4L9/IyMglZXXDe9GFdVF6tiWnvdbTermhb5Ti6KI/bVHfeVkkqp2hKswJrkErVgtY7dA4lPYUDlT72L8Q0w6Dm+mw5NUPqgtn9c3ynHOWGI4UM4XVHFt2xATTymGMYtPJe9H5RB8jnY+ALB/1QaxkZ5Wh72WBq7QapRRxmB3lNAyZtBT98y7gQ0Ih1rQpy1ISWRFyRGlx3ur6hDOJj77vj/j9n/9RAB7xLd/Jv3zSM5n7II1OCPiYaFMWp6ckCnYzDFHselAT5XwxoZSmMqxVEj5KxMXWxJKSvH8HpiVGG441PSEkjNEYo7FK4vK6APM2EHPCaI1VGuvAKbHKvWxWilojJMxgBWyN4oppwcZEFqa0kvd0v2vAdu1QcMGxMTkz5KjLolp9C1ynRkZGRkZGLhZPeMIT1otRAL/8y7/My172sjO+5pd/+ZdPePz4xz/+op1l9bU/+clP8o53vOOEOI2TCSHwute9bv34rne9Kw984AMvyllGzsyFOLmmlNEKpqVjZ9lTFxJ3cC5uUylL7FtpNH2I64Wc1ssijtJq7eRUF+ZmS1Hr8w83hod9KJwxQ/yyiC4qZ4Yb7lLnSTSCLPfsLr3U2j7SR3F33Z4cP38XIjuNLE4dXXaEmNY3veedCBGaXt4j5yS2wFmJll7deE85Y61i3iXqUmLyjNJ0w+CgGGL2bthtSAms1hil2G08MSYS4DT0w811kKX+mOUz0ECM0pfYSrPo5IZ7bY04z2bFwclxAYGzimlhaftISJF5F5hos47U2Kit1O4+4ZymLpGBRAZFoukztbMYlUBBaQw+Z3yMgzhBBhw+SM+013oA/sdv/iK/+Ys/D8DPv+oX+LYnPemsPyOz0spiVOk4OAksusBeE+hiZGjHhj5Rs1k7DkwKZtUYBzEyMjIyMnJbYDabnfB4sVhcopOMjNwx2C/+3m09PmSmE3vKWHJn9NpRyQ+zh4zCGMVeE5g4Q4yJeef5zLGMNcdF4VoplBqcf31cuyodnBR0Q0z4tLBsTwomhaZ2du0mO+88d9qs8CnyqcNLOh9ZDP1fMcTHhRTXsXa6G2L/lJbFLaMojaFwir/8wJ/w2pc8n5wSD3zUN/FvnvsiDkwKCiMuTF0v4h8VRGAdE0wGJ1qt1HpONCkMvkl4H9hpA7uNJ2WYlJaq0CSQ82eJJ9dKXHW3KkPKEiWvlZIY8HWKSWY6xOvFlAchi6IPiUUfZK5ApnKWYIbecVLQR+m1zTCbWk2o9k+q1PAo5cxG4eR9UhpUXkeZb59CJCIi+9OnqoyMjIzcERgXo0ZGRi45qxvey07ymwurT9hg38+yC+Qhrq7xce3ctIq6WBXnEj0hQ4OQxIK1T+kE16DVVnwarEjTsFx1tsKwHdThIa4cptRaZdCHJApt4ORdrZiSKOCVIsRMCIqsMlaLk5TMG6S0jTmBUtRO49tV45IJkaFhyRRDRvb+ynj1fVujqazY2nadNEVKwdJLDEhhZECkUSij+cRff5Df++nvJ6fEg77um3nsM14gAx0yjdEYY2h6sbZdLZI5lXHWEqLYzw7mURSFpsZSZVFyJyBmiCEStETWbZSOujRMhkWirBK7y0BEFtQumxXkLMqLkBO7TeaKDYPRiokzOKvFjaBy68+v84lZJe4EG3WBVooD04KYM7tNOME1oPXpgmNjVj97K3cxsa0do/RGRkZGRi4dj3zkI7nvfe/LRz7yEQD+y3/5Lzzzmc/kmmuuOeXz3/e+9/G7v/u768ePecxj+Cf/5J+c8rmf+MQnTrjOwx/+cP74j//4tGf5nu/5Hl7xilfQdR0AP/ADP8DXfM3X4Jw75fN/+qd/mk9/+tPrx9/7vd97VoepkYvHLXVyRSu0dvgg9ee0tGd1Xl2xigMonEL1EHPGh0TICbIsCK3cXM8Uebz/xvDqunUhjk5hEC5oBTfstthV/YzU/qvhwbwLg9DC0HkRX1ijObbw5JxZdIF2GCYcnBYiZAiJ0ioWXSbnhDMSnb1SOIcMOSUyeX0278FZCEGTYqLLAUgsek/OiomTpaLKGZa9RIYbFEVhWbae0hmM1hyat4QIdljy1yrTR1lOUlphhtiHWWWpjMVZeY+2JwVaQRcTk9LKgtWgEPdiwyQLVNpIRHfKYLU4tsaMs5qN2ko0n8v0KVFq6b+mpRmcxAJG7/tMMvzJm/87v/wzLwHgR3/yWp793c88p58RkN5sa6LZSJamihyYDo5VKwHN4AZbu7EWHxkZGRkZuS1x/fXXn/D46quvvkQnGRm5Y7Dq2RadLN6UQxzb6WLJV5TWkIq8FqUsu8i8DVROQ0iklNioCjzQEE947cpJuHQiaI45M505rtqsThC2KCWzlJXT6w27gUlpCUF6LaNFxLHsEt2QGLEImdWUxurEpJTrhZT5+F/9Ja/90ecQg+dLHvq1fN0z/iOLNlK5yKITobfKmkUrzleRSAoamiDzJyMC/JTzenaw9EH+LImo3SpgmP1oBdpIzLdCUTlNF6T3ATi86Cm0uGOVOWOVlkQND5NiNXuSMU7K0o9pIJqENYZFFzmy7DFa5kx7bZAltokZ3r/jn9kqc2Q1A8vArLJsVJaUM07LEtbYL42MjIzcnHExamRk5DbB6oZ3SvYEFff+Ak4rSEkKuNNFXeyncobpvpiPk12DVotUw5xi/evZ4tT6kxymisFhavWqk6+3YtWc5CTfm9bitBTy8DXFGRZr9NotSxyvNNpB4yX6rhvk0X2SAYzV0iJoLV8jD9+D1uLUNO88CUVOmbaLKJ3IUWJSfMgc+sTf8Psv/15i8HzpQ7+Wb3z2j9GHIUJDyzJSXRixgEXcokprCINlrgdKp5iWmcraQTWihmjAvB5qLb00OSGJ3W3O4hgmbgGarVqaiUUXSCkzLSwhIwtjWV4TQybEIaKlLIgxMh8WlCaDk8D2xKG1YlJIo2WRBuRk14Ct2l1QbAyI49ZqULdqzkZGRkZGRi4VWmuuvfZavuEbvgEQVfbjHvc43vrWt3K3u93thOd++MMf5klPetLaxVFrzUtf+tKLdpa73e1uPPvZz+YVr3jF+us95SlP4Td/8zcpy/KE5/72b/82P/ZjP7Z+fJe73IXnPOc5F+0sI+fGLXFyPbbsAYlim1p7VufV/ajBgsooiVLOGdoY1yKDsFqcOss1998YXl33eMRe4siywyiNM4rtSbH+nhZDZJ2PiaVPVE5TOrNeBKusZj7E7M0H16ONYQm/H2ru0hoUgS4lbD+IEQblNel41F2Iom7ebTyTwqEVlIXic7ueFDMxZHyKLDqonR6cnQxOK7TSNEGcZEVGAaWzFDahEKV3VpnaaZRWbAznQyGOqxa0ymxW1TAM0ewuPanQ7DRy814hDqttiNTBDqpvjVZSz/e9LE6pCJtVQYiReRe5bOKYliJUuHxWYpSmKiTSTmlZPvuTt72Zn3vxDwDwPd/7fH7shT907j+U+9BaMS0t0/Lszx0ZGRkZGRm59LzxjW9c/74oCr7yK7/yVvtab3/723nve9/LRz7yEY4cOUJVVVx22WXc73734+EPfzjf/u3fzpVXXnmrff2RkdsCKzHGqodJSRIo4NSx5PvRSoTbVit2Gs+RRUdIcp8dFFpD2yfi6n6/0VRWszFxWCPi5kUXmZWOA1NH5cx6oWiV2LBy4t1texZtEOF6bSkKw7zt2WsD1iqKpJj3EEIcBCsS8Y1SVM7ymes/xm+8+HvwXcO9v+KhPPrZL2Gvj+z1DTctOllQcoYrZ6XMSJDcOj8kdFivKU2idLJA1PqITxLXbRQ0g0swQFYKHxI39WEdB18YQ+Ek9k4p6Ic+sLeajdKiNew2kcYnagc7S09ZiIgkBBHJb1YG0FgNVoMpFW2X2DWeGGVZK+/7TIt9Qn4/zG2UHtyWkQSRyhkUcPmsHBegRkZGRk7DbX4x6ju/8zvXv1dK8au/+qun/LuLwcnXHxkZ+fxzphveO0uP1op2WHIC2KztGR1+RL1ssUbdzDVo2UW2JhILwjDogeMF5+lYOUEdd5iSF65etbrO/vmNPHdYNjIG8EwLjU+ZdlgCs0Nx7WNeK9+XXcJYqKwlZSl2+z5hjKIPsnRUD7nTClGEdD5JdnhI1M6ys/CEFOljou0TgbR2vLrpU9fxlp96Lr5t+KKveAhP/P6fIqExyL+Jk8pQ9ZayjXgryvGUFFulZhETOUFhFVVhKIzhwEQU9InMso04J4Ouwsri0m4b8F4+v3r4/jdKS9NFlElgjUS0+ETSqwgQOa8PCTUMzrYmjjaE9bJZ5TTbk4JisMOtnTkhFu9k14DCyrLWLY2NAVmKWkUyTssxsmNkZGTkXBhr+1ufxz3ucTzrWc/i1a9+NQB/8zd/w33ucx+e8pSn8OVf/uV47/nABz7A7/3e7+G9X7/up37qp7j//e9/Uc/ykz/5k/zpn/4pH/rQhwD43d/9Xd73vvfx1Kc+lXvd614cPXqUt7zlLfzJn/zJ+jVlWfI7v/M7VFV1Uc8ycm6cj5OrQsQNs1IWiHzM51UPaQURqf8Lq/GD8+qq1tbn6Oa6/8bw6rogN+APL3pCjJTWcqQPHF30+CTLRfPOo1D0KQ0xfpm9xlMVhtIaji575p3HKE0fxblqWtj1mVaxzDEnll2k0AZjFDlnIgnfy9AgpERWigqJLAg5YtDklIkJjjVeBgxRcq9DAj+oqVMW8YNFkbQIJXJKVEbhbAFkfMjUhUUhERMpiUsTCiqr2K4LQBaWrNFDfALiEIVER8hbLEtqfUj4JDF/ZFk8m1QGFxSF00wLSx81m3VBYRWtT0ydYasuUGrlSqXoQ+Tdf/ROXvoDzybnzFOf9nSufem14036kZGRkZFbjbHXuO3w+7//+1x33XXrx49+9KPZ3Ny81b7eBz7wgRMe933P7u4u119/PW9+85t50YtexLOe9Syuvfbam4k0Rka+UFhFnfeD81M/3Es/Uyz5yXQxSTKHM8QkkePz4R76yX1hynB0cNitnKEuMrPScOft+mbClt1G7j10IbLXhLXIBKDxnjaunJs8TRdZhrhevCoHwUsIiU9/9u/51Rc+nWa+y12/+Mv52uf8FHsBcooYIyIfWdqSPqw2Iqi3RpaqVo5QbY7kIXnDh0RtDRBJGVRWRDITqymMIRNBiVNVGyJGJQqvWPQBrTS9l3SSKYpWJ/a6wKKNRBKLNtOoyEaWFBBrFTNt8NFgFPiYKa3Mr/a6SBsiIWa0VsxKicmLWSLf5T2XuHKQ2VPTRyaFHRMtRkZGRs4RlfNZNgAuMVprcR7JYlkYY7zZ310MTnX9kds+f/M3f8N973vf9eOPfOQjfOmXfuklPNHIrUVKmUPzjgwcXfSEJDfx9y+/nI3FKi5NS8TaaoP+WOPxMa1dqCqn2ahOHfMCcHjekTLsLOUcm7XDGc1e62Xpxmk2SrdWpYNEAO51gZv2Om7cbfmHIw2QOLroKZzmTls109IyKSzzLrBoAwsf2Vt6Elli/3LmWONZ9AESoCUO8F5XTIFhQKMUTmsmpeHY0pPJfPTTO+y1Yb3w1UcZBh373D/w9p/6bpqdw9z5n34ZT/7RX2Q225D4jEFlrzXctNexs/Rypj5QWMPls4I2SKRgafVa0X75Rsmyi1grjVHKUBiJItFaVPI+JDYqy/a0YFponJbIv5Vj1rzz7DaRmBKz0tIPv1bOUBiNNUoGLyiUglklgxiQBajLZ+Upfy52G08X0nqhyRnNwWnBTuPXVsGtPx4bczrs4KC1coqqC7NekBoZGRkZOTNjbf/5IcbI0572NH7zN3/zrM9VSvFDP/RDXHvttWd83vlG6a244YYbeMxjHsNf/MVfnPW5Gxsb/Pqv/zpPeMITzvrczwd39F5jFTV3KifXlRX/4UVPynldn2/V7rSLVCez7AOLLhJi4tC8Y9EFDk6L4W9FXRxSlrrtNNdMOUvNm+VrS5yfYVJYbtpt+NSRZnBqlSjrrdpJJIHVLHupZfcaOfuscmtlcOn00H/0+JRouojWiis3SpyRyIXPHGvYbQM3HFuy10Uqp5g4Sx8ydWnoeokF7H2ii6Lk3SytXHtwht1tPTfOO2JKGCVResXg1mW0liUvJcplcTf167NqJH6wDwFtND5knFEoxB3LqMz2pKIuDZXVXLlVMx2Uyl2IHJr369pca0VKmcsmJZiMRTMpDEpDyLBZitPqsgt0MbFZWbZqUY+nnLl8WmCMwRm5qd/6yP/+8w/wH77jibTNksd/8xN51S+/jis261FMMDIyMjJyqzH2GrcNDh8+zP3udz8++9nPAvLe//mf/zkPfOADL+rXuec978knP/nJ9eO6rjl48CAAhw4dWkd67+crvuIrePvb384VV1xxUc9yvtzR+4yRW4dD8469xvPZnYamlx6uHMTE5+Lqu+wlgq/1kesPL8gpc8VmRWEUV2/WlE6cZmOWpSMfJVlBK1mSslpROsOVGyfem085c2TRk4d5ytFlL4kZGXabnkUX6X3k0zsNe20gxITVilnlqApNbSX2/YbPfJrX/fC/ZefQZ7nqmi/mW37kNZh6ypFFRx8yxkAfJNp8WhoqazgwddTOkciDqMdSO7Oefyx9xAcRSoeQqQqNBqaVZVZYScEIgZgGAU7ONH0a4v80RtIGcRbuvD3Bac0NO0sWfSLnREhyz+Uu2xWlMzRdpHCa3mdCFmdmY0R80oWE95HFINi+arNiVllmpePqrWr9GS26QEx5PQu6aqscxDAS+z72WyMjIyOn5zbvGHUu3MZ3u0ZGRi4CjR8sSUMiJFFsrzbhz5VTuQY1PlJavVZld16iM6Y5n7ZhWMV+7HeYSoPCAKAycq79Fqd9TGilyEhDslUbFl4U8iFlFr0o2Y2WQdMccUFqjKKP0mz0XgrvGMVlyhrNzEl8XoiJrUlBoWVxaN7KYpEs/YTBNjfThyjqg2OH+F8/9700O4fZvsu9ePwP/hxlPaHzER9FFRJSIomQnMpprJJ4laKQmD4yxCwDK5MSWevBVUCRUews/QlxgppMZTUxJGKEtpMov2nBeslo7iOzShqBlETRQZ/JWex4g8tsO8esslilKAtZllJKsVEZrtyosKcp/lcuWiunr9Wi2C2JjVkxLa0srY2MjIyMXDTG2v7CMcbwG7/xGzz2sY/lJ3/yJ/nIRz5yyud91Vd9FS996Uv5mq/5mlvtLFdffTUf+MAHePnLX86rX/1qbrjhhps9pygKHvvYx/LTP/3TJyxfjVxaziW67HydV/dTOVmOXy3Qr2r9cqgL19fk9NdsvSh9rZZFfKXkujvLns/udvSDAlgpiENUc+FkCagfFoms1qDELWlF00f2WrnpvNf0+MhaeOCMLOcv+sBO08tifxtYtJnygMZajdWaaqoJAZYmEJbSf7QxopSijaIEjkki+3JWOKswSq0XvGKSeOcQMl1IFMZw9ZYdVMJZ/t4qjHIcW3qME4dVqzMpQdKKeR+YVYZJaSm0Yt4GicdWitJorpyVGKPZbTw5QZ8Tvs3MKk1VmnUE4aKTiEOjNROtSAl224BRmss3CmaVIwMTZ0jAJ/7uo/zAM55M2yz5mq/9On7+F3+FzUk53qQfGRkZGbnkjL3GrUsIgSc/+cnrpSiA5z73uRd9KQqk53nMYx7DE57wBB7xiEdwr3vda738FmPk//7f/8vrXvc6fvmXf5m+l/jnv/zLv+Qbv/Ebec973nPRnKNuvPFGbrrppvN6zX43rZGRi4VWSmYQWvoNlWGjtue0FBVioull2XO39SLKRvqLaWFJHBdllwoKK4KYG3Za6YW6gNIwqyzLXpyHV7W/9GzyNUSMLPOP3cbLzCdnlkHcklRWlNYwLQ0bpSOS8SnR7h7ht178THYOfZbL7nwPvuVFryIWExatp/OZZS+zkJWgRiHfQoiZ7CR1I8TM0WXPwiqcMbLkiqKPUSLItQjAY5LXHm56vIdEwsdEGJyKnZXowHkvLlilVYDl6Lzn4EbBpHTMu24QjEtvCBLB52pDzLI0ZbMhJvn/UutFzN+QxdUqwl7rUUpROb2e7xxZ9ISUmAxOxrPKrJeixkSLkZGRkbNzm5/m/qt/9a9Oq+Y409+NjIx8YbGKTGuDFOil1edU1O9n5YLUDUsvq0WZ7dqx6MI67zokUTvUhZHoupBI+bgiTIrS48MaHzMxSYFvtcJZidZYLfvA8fi9Qosa4bKNkuZIs1YKzNuA1VAXeh1Z0oZIaQ1ZZWkcciKkRBMSMaR1xnbnE5PCMCssflD2F0avF8CmpaMJLU2bSArico/3/8ILWB76DJPL7swjn/ezRDtlpwlUhUZFRR+DWOQaRYiKaeHYS+JAFSOUlcYYUao7ayitKEbaPpM5vrxmlKjzUYmMkmxxbehjJHUynGq0vG/KKAyZLmScNuhCBnKrRSdnFIXW689xs3ao4fcHpu6MLl9w/PNa3QPbfy/sfGNjJILEjM3GyMjIyHky1vafX570pCfxpCc9iY985CN8+MMf5jOf+QzGGO585zvzoAc9iHvd617nfK173vOet3iQ5JzjP/7H/8gLX/hC3ve+93Hdddfxuc99jo2NDe5617vysIc9bK3uHrn0nItT1MqeXyuJGdBaQRShwP4a+Ezsr81XFVUbkyziW43ad81TRWf34fjN+6o4LkxYdIHDi54+JOZtZOk9pTVsVhKvnZIsW/kQaX1m2QVSFuWz6URl3MfEvA1oBX3KdD6RlfQkdWFISVyXUsoEACU18s4ycvmGYVpoImANOCsRCM4qCq3wUb7fiTOEEIelJZgWBYHEgdrR+IRWGaMVVWWoc0ajqAqNM4Z564clKFkqMxoan4hOo7KiC4k41OMKaPvI4dyjh1gMoxRXbYmgYK/xHJg4CqP55OElMQRSShza65kUhu3aYYy4PZRWRBEpi1tVVWgqa9hrA3VhiBk+df3H+e6nfDN7u7s8+Ksewq/8xn9ja1aPYoKRkZGRkVudO0Kv8bGPfexWu/aVV155wTX5c57zHN75zneuHz/gAQ/g5S9/+YUe7ZR84AMfOK3zkzGGBzzgATzgAQ/gO77jO3jMYx7DjTfeCMD73/9+fv7nf57v//7vvyjnePWrX82LX/zii3KtkZELobTiwlRZAynjk/QTZ2LV1xxdejofaXzkc3sNTRepC3Fq0koTosxHyJkI+BjFZSlmaqfZa2WJatW7NX3E1dLl9SfNdayR+UjrIz5mckws20hK4AqYOotWUFeGtkvs7R3jV170DA794/VsXn41T/6x12DqLfaanr0uEEKkDzKTmGlDYS0oScxofMaoiLVyLpmXQEyBnBRVKXF5XUjUbhC5ZGi6RMqRylk6L/HmhVPH48tLmVXsNIE+wEalCBkOzXtSStTO0ASJIJxVkoQRkvTXMWU2hpSMZReYd7IcVhWayhgmlcyLQhax+LKP/OPRZv2ZFdYwcYaqMFy1IU5SdWHGfmtkZGTkHLjN/0t5pniGc4luGBkZ+cJgpT5fuf3c0oWUU7kGaS1KhDZEamc4uuy5cTdQONnkP4FBSbDsAjHnwV5WsqtDzDirObbscYPyXSsZ0MSYJQZDaypnyEniKXzMlEacrHaaALRMCisK8ihOWW1IqAyg0MgQyTrN1sShtajLr9ysxG41Jom2GyLnjNZ0KaOzQetM6Jb8+S/9ELuf+TjV5mV81bNegZ4dpPGBImlyNmgNzkgDoytZ/ln2gczgopVF6aGUQmkl9rZKUzqIOZKAeRsJEazJ6CTLW2RF6UCRaHxmQqKPEZsUaGmeameZVYpQyfeSAaMhJfk+68Jy5RCVVzoZ1NTFuS0orWa5q/tgJ98Pc0azNdGkZM95GDgyMjIycn6Mtf2l4b73ve8JUQ2XCmMMD3vYw3jYwx52qY8ycgp8TOsl8ZutwGVErRslNmC1JH6+zqsnMxkcXbVWFNZQGk03OK1OraEniUihOH7NNChqV0tRpdPrxamcM41PdCGy23h2G0/pZHnnwKRgVoliOuU8uEEFdtuAT4m9VjFZ3UzOmT5Fmi6x10q8Q+00VWmHmAO5+b7Xeva6nhDBAF2IHN7r6bzEftfO0IcoLk1ZUQ31v1ayzNR5i82J7dpyYKNCAU4r9lrpMSpjmdXiaKqVHpadMgenjs4nWp9IJApX0fo0qLCTCBMQccaii+Ss2ZrKTf9VHPnK3fbgxNF6cZq984GaEJPEYwSJ87ZGUejjw5UCsFoiC6vCkFOmtIZZZbnxc5/lu5/yBA7ddCNfer8v4zd/5/e54sDmeJN+ZGRkZOTzwh2h17jPfe5zq137ZS97GT/0Qz90i1//ohe9iNe85jXrx/e85z1585vffNGcmU7mXOPwHvjAB/KmN72Jf/Ev/sVa6PHyl7+c5z3veTh3ZpHlyMjtidoZyAxOupJc4X2mPsWPeYiJZoiRiznT+EDOcGivZd6KexEKjjX9ME+JKE5MVbBGesGYjnePTReZlU56uCRzl9Vfr+YxxRBNHuIgBh/+c0Zh0SLkGK6nUstv/cSz+ezHP8Zk6yDf9MJfIEwukwWnmGl7WSqS2YDGWE3WGatEVO1jHGYmanDcNWTAolmkQL+UfmpaOEprqIxGm8y8S6AUSklM+kRZnJb+yaeEaiMUenAFzmgFlVOEkETkomXBCwVblaVwEmmulaIPaW0CEJL0bxpxNc5GhOQaJYtUyPzJKMVGZakKy8FJgbMyW5Io+THRYmRkZORcGf+1HBkZuV1wssvP+bpFrTida9CklMWomDNNiEOBCs5EhuS89YIMQxSHUjBvPEeWnmmhuXyzolJSZM9KGVysFBQ7Tb+OzaudofFhcDySaL7dJgCJtk8sfUdKWf4j0YdIjOImNa0s2ke2KstGXa4HUcs+oJQ4H00Ky5FFj1aKReeJPoFKaAJ/9gs/zE1//9eU002+7vk/z+xOd2PY2SJnsaat1GAlq0RBb5Bs7ZUiXeL2PJtVgXEKrcQhy2hxuYohk7I0NMOV6YJEGC68NF4kRa81JmlIEEJmUlpZchoi+fY6jwUWPtL5RGFl8NLHtB7EnetSFBxXp+x3ODgV5xIbMzIyMjIyMjLyhcS8k/iDFWeLFW6HqIPaGRTczHl1eo43Zq3R6KHW3qosxijaXpafFn2kG5bxdxtPXRj84Oa0GmqVTjMr5U5/MURQdyFyZNGz9BHIzCrLFbOCg9NyXQcu+yBuTE6W4j99tKHxkc06YozC94m91tP4xLwPZGDhA7VPzK0nRsjDTepjy0BpFGXlCEl6CBsUIUXaYAlRanlrM1Ybcpbo6N1WhBhXbU6pC4uzmoN1QSJz2YYsbilYL3MpJfX4Kt5hp+lxRqIyuhDYWQZmsxKlMjfteUqrMFoisCeFpTQSSVEXduiJZPGpKiy1S+QsjlgHJsXwfmqUhpxY38RPOeGM1OFmqMFXi1ZHjhzm6d/2BP7hU5/kXvf+It74P/6Qe97lytFhdWRkZGRk5A7Ay172Mq699tr147vc5S68+93v5s53vvMlPNVxHvKQh/DEJz6R17/+9QAcOXKE9773vTziEY+4tAcbGbmIaK0onWbZR6rC0DeJhQ9UwZyQjLDsw1pkAqxdi47utdy416MU1JVmrxE3KBEQRworwg+iOOpaLdF9ZlggaocUCx8k0q714o676t1Wcxij1Vp0HWKmizKTsIMTLogDko6eX/3xf8/1f/MXVNMN/u2P/xLlVXdn2Uvf6geBjRpSKnwQUY0sDElMeVkWlIWm6aIscGnpQXc6j8mw6KQvvHyqmQ39aNeLUEdlRUhQWEVtzTqmz0UlDleAdZpCJdqQmFaKmOT6MWYObBYSC1g5Noeki5gybYgsukDnM7PKsRLDTytHzhL5rgeBvUEEKYXRXLVVrQVBE2e4bFqOiRYjIyMj58m4GDUyMnK7QMl+zXqxaeUgda6kJMX5XufZbaTgzYhL0ErNHZNYk26UjkNe1BEhpfUQohgi8jJwbNmz24jFbASWXiIqMlBZifBQCpRWVMaglAyYFn0gDja225OCurA0fWBSGBSKeRfoggyBll3EKs1G4UDJwCln2KgspbNs1paUMlu1owtDVB2Kpg+0fWCvCyy7QBsTVsF7fuXFfOaj/xtb1nzdf3gFl9/tXvQJfIikrNDWUCiF0pnWZ7qYqI2mnlhAsTvv0Free58y2sKksEyHZabVm9OrSCuZIoQIKPA+DUtisnBlGBoFrTB2tYgkcXZun/NAYTSFM4QEB6eOm+b9upHTSp1gy3vGzz/LEA0GO2HEXnhkZGRkZGRk5I7OTuNpvdwYb3uJTwjpFLX2vhvg9WDd3/iIjwlnxFVzp/EcnncsOnFUPe68KYs21UnOm91QLJbO4Iy4uM4KR+PjsPivWPSBRR+YlXZ909dqcV9a3RiuBwUuZI7MO/bagA+J7SFuuS7s+uvudZ7eJ1nEb1cL/KLUPTzvKAtDTnCs9aQERomLa4gJMhxbRIzREl0d5cZ7HNy2jFFYLdELzim60NN6idE7WFZMK1EyT0tHH+Q9uXKjIiYRCWxPLXttxKhMpzQZEUtMa3F4Wi32OwNaFSz6IKICV7Jde6alJWeYFD3OKIl+CJHSaDIiyMgJppVdK4xzlgjwe185QwFHl17U1IU57eeXUyYhQw2jFXu7ezzlWx7P333sb7nzXe7Cu975Tq655q63zg/syMjIyMjIyG2K//yf/zMvfOEL14+vuuoq3v3ud59XbPfng2/6pm9aL0aBROpdjMWoZz3rWTzxiU88r9dcd911PP7xj7/grz1yx+Fc486npWXZR+rC0HpJZNhrRWRSOcOiD/Re7pH3IdH5yJGlZ6fpObzwJDIqZ9oeQswUxqGAaeGwWsQahTX0IRGSOAq3CWpnObYM7LWeraljyxYibkZ6EHJez3WMUYQ2UVhZrPIhDkkVet8CV+TXrn0BH/vQn1FUNf/ux1/NFff4p9y0aGlDJmfpWRWKPkSJabcaoxTWaIxROKcggcrSv4YsonStEztzSfzoh5hzH6WXyzETcmJaGhatLFrVw7xihTWaclgYU1nmRmmYsSx7EcF0WeY7VwzJF86IiMhoxbQQF+LGRw7PezYqOXNl5dwHa4cPmWOtF8ep2kl8XiERgwcmBZfPyjHRYmRkZOQWMC5GjYx8gXKuxfLtBa0UEbFfJUrRXTlz1tf5mGh6cYDKwLITe1dr1JCRnZh3gRt323VxutP0KERhgRd1tDPDUlSWa7YhsfQRg0IPtqaf3mm4fFoy2aqOD5NipvcSZxGSKLGPLHoKo7nn5RNqZzmy7Akp4UNmUppB3ZBZ9DLQCSnSJyiNpio0U+eoC7HErZ0h5oyf98QsDlNH5z2LPnLTXkcTIpVT/Mmv/BTXffDdGOv4uu/9T1x17/uJeqGXxkEWqyKdpNpRWE1KGaukCWq9p+kjs9ISh8g8sjQWs9JSFxZrNEcXPa1XxAhai/NATqCMwqFQRDSawlrsEI03cWb9WbaDlayo0qHNMpQpkCWsrVrew52Fp962J9jynommj+QsQ7TVglt9Dj8/IyMjIyMjIyNfyMy7sF6K2m29xB8jfcMqnnkVPeej1GkhZfa6QJ8Sm5XcKD/W9GgUjQ+0Pq1vxksEnFq7qC77SGHlRnKIIkoAuGxWYJRi2Ue2p45tHIf2OtoQQSExfT5htFrfGF4xKQx1YTg072j6yOG5lz8v5eaxM2pd9y33DQKWPspZfWRSWLqQ6FOi95GJk+X/eRvpoggstJY62ShxWt3r/OBqOrhWqYzJsoAUcqLvsixrZZg4R1bQ+czBWSHxCJsSz92nNJxTU1jDwakMGqrCrF28jNKndTvNyFDDaImdSClz1WbJpLTDMKNko3aEIabamZWq+kQXsBX3vrJk4sw595Jt2/KtT/1W/vL/fIjLLrtsWIq654X/cI6MjIyMjIzcjHyeQtFbm1e+8pV83/d93/rx5Zdfzrvf/W7+2T/7Z5fwVKfm5DPdeOONF+W6V155JVdeeeVFudbIyMmcb9x5OUSs+ZCYFtLrpCxOt0cXPTFJ7NzCS18UUmK362h9xlmFjuJQ2/jErDRsTRwZyEpel7OIJrYnjna49q6X/qsqNPM2MG8CW1WxjtDTCiKs5zpaKXFbMhqDCKkzoFHDklHit3/mx/nQH78N6wq+68dfyV2/5CvYXYqjL1l6w5AzOcn1tBIxuSxIGcyQ6qFRKCT+rvUJo6EP4FMmIr1OoTW7beRgF/FJeqZpaWl8IkcIWcQ0bp9QRRbPIkorQi/uV3ttJJGpnAho5m1g2Qfph52ldHImiTtUTApDW2r6IAttk8Ks5yxdiFgrYpyNWpbS7rRVjw5RIyMjIxfI7XoxaqU6uOaaa3j3u999i6/z2Mc+lo9+9KMopfj7v//7i3W8kZFLwvkWy7eXYqrc5yLUeRnKTIdIh9Ox6MJ62AKIAqLpyDGTs7gtzSrHsgsshufNu+MDoa3aUW1WxJhpYyQPUSJdUByYOCbOcONeR0QRQ2JaSUZ1FyLTwmGMLBX1IdEO6gujxcY1ZxlgbFSae142xRnF0WXPXhvWi1yzyrDXRonLGAr+lDPTwnC3yyYcXUg8X+MTs8pitaILkTZGml7iTYzW/OXvvYoP/9EbUVrz+O97Ofd+0EPpPSQSShmSz6SY0AzxHkgEXkqZZRdp+oZZZdmqHfVgmbvXBlmmUuIeZUOmcrIklXLCGkXfZqyWWJVpaVh0EaUMGkDDxGm2alFIoCDmjDOiOt9t5PzTwlJaw9ZE/nd15UbJjXsd8z6waAPTyq5teU9HN6g1QJoW+Xm6fS0GjoyMjNwRGGv7kZHPL6ueAE5cilotGp1cZ1fOMB1uqi97iTrexWOUYmfpKczKCaljtwvMW0+GYRHKUBmDtYq9NtDHROW0RLw5vY4WODAt0EhNu1k7bC9LRyuXJ5BlriJI/TspDEYrbtrtONb0+JilprSamTMkJGbADu5Oq8iI+SBAgEF8YKGPlm4hyuOQ8nohLCO1o48JjKbQSL/VR/rheaiM1YrNypDzsCAWIKaENQYz3NTenjiu2CjFoXbR0YeIU5oDdSFLWyGxUcryf2E03mr6kJh3nsrJoOPkz2UVh+1jZhos1igOTEuu2qoIMa2Xpc40RlXD97i/NzyXaOkQAk9+8pP5oz/6I2azGW9729u4z33uc+YXjYyMjIyMXALGXuPi85rXvIZ//+///frxwYMHede73sWXfumXXsJTnZ66rk94vFwuL9FJRkbOjVsSd55yRinFRm1Z9oGJMxglyz3NIIg52nhxw0VmLlYZpkVG+YxXsvl0+axgY+JQGbmnD8OylWXe+kHs4bBaovv6EDFDm7Kz7Llio1oLoQur8TGu5zohZllcQlyk/ODMq4cR1Vt/9T/x/re9AaU1/+5HXsE9vuwh+CSOwu2waLTXeqSLkSWj0gxuuCnjtKJyhsIYcs4sfcAPM5qc8yD8EDG7RuFNIg5Lp32QBbBlH6icJiqJ6euGmD6rNdbIIlZOsnDV9JHCaWJUGKPxg0A+Jc2yT9RFHqIILWbfPCKkzGZVUFpZfuqHmRKDUN1oReE008KwUTm2Ju5W/GkbGRkZuWNwu16M+sQnPgGAtRf2bXz605/mE5/4hFg6jozcjrklxXIbItPSMjvDYsltgdqJYrqwsmgTkgxlpqc59/7hTufjEKMnSgirxW1pmIXwud2OmNKgHpAieHsi/kbzNqwHIgpx4vJRmgClxEFp0QYOblg2h9fEJNFtafgojBY7VKtk2aiwolw4uvRsTwumpUwcrtqsuWJDFOl9SKQh57odojuOLD2QmVSWeSdKhElhWPZBFOBZ04aEQaN1wmnFX/3Br/Onb3gtAN/8vS/mQY/4eqpC0XSRY60nJlFXNCFjLBRO4j1IGR8iKCVxKYXmTpsV8y7Sx9VYJaMQBX/lEo0XVYRSms3a4n2mCX5tsZsTopQPiRgSpStIw2fQhYRVit5nFr3Hh0xVyM+qs2r99TaqkmWX2Os8h5YdSoPRnHIxKu0b3AGUTq8bskk5ukWNjIyM3NYYa/uRkc8vy+54fN6qbt6s7Tqe7lRoJWpWaxS7TeDQvKMwsuA0bz2xC6QssWvdEE8X9tVjVklsXmE1PiRUyXopqi7M+vcpSczyTYML1Fbl6K2II7QanF1RLPsEJPa6QM5IJN0Qk51zXkfuAetBQB8SfnBCqpzBGsWReU/lRB0dU+bIvCeT6UOkcpZJ7TjS9ESfaEJYR3KXTurVGDOVNYQIk1IRkkbrTKEtk9JRFprtScE1l09Z9lHO6TRpWsDgZqsH8YQfYuyaXkQCENZCiy4knNY4K+5aPibmg3iiMHKTvnKaKzakv9iaFCJcuBXchFNKPOMZz+BNb3oTZVnyP//n/+SBD3zgeV1jZGRkZGTk88XYa1xcXvva1/I93/M968fb29u84x3v4P73v/8lPNWZ+dznPnfC48svv/wSnWRk5OxcSNx5iAml4OC0EFF3Fjemjcoxbz0kMEoxqwzOyLISShIXQorUxmC09GvOaKblSgyeMFqck44s5P69s5rNynJ40ROz9EghZXaanowjZUflDMs+ynxkmOugEMcl1BBNp+h85h2/9Sr+7E2/AcCTvu+l3O+hj+TQvGVvGTm67Ol9RilJBDFanHBDTJRDvJ8d5giV02hAKemRFJ6uz/QxYQzUTnOsCRgNFkXwiWONCHu2J47dxhNz5sDgmOVDEsOBlBhaZ9BZelqtMEqTcsYAvc/rSMOdtqcwCqM1Clk6q4y8n/NOnLYun5VopdiqCzZrJ3OloWcTt2S9FnuPjIyMjFwYt+1NiHPgjt6EjIysuJBiedHJ8s9qEHFbRGtFaQ1tiOJYNLhBWaNuNrxZdGE93Fmpy/uQhs18zYHaUTmLsxKrttN4UsrstYFEZlZadhpRBcxKsS71URaVVgMIWUBTXL1VojYr5n1AZdioLTHL8hNZDZFwehj0GG7c64dTZipnWXaRRRfWqnytFJPCMinkWdsTx027HUeXPZdNC0BcmETFDq1P5KzQWuL+tJdFJq3gI+/+fd79mz8HwLc+54V8y7/5d7Q+Mu88qlKAYtEF9ERhlcIHWXSKg2pCDQtd08IACqU12xNRsG/Xlj5CSAlnZRks54w1DA2OYntmSQu5VuUMhTZoo1g0gWKiqAv5eWsHhUoHxChDG4kvNKQsy2ibVYFS8tluTx1dTORBkeGjvCeF1QyR5fQh0UeJ3QNOcCKQXO/bvkvayMjIyB2RsbYfGbllnO/iS0qiWoXjC0OTwpxxKWo/8jyps1OUG8w+Sg0cc2ajsmxPpNY8vNcy79Pa8clozfbUcpftCT4mDu11bNZOnJ/2uhPOffcDE5Y+nlX84axi4hyND/gh5sAYcWr1UZaJVg5R3fD9GgXaKECjtKLvM1sTx+HdnpQzISfUoAiOOVE7yzIH+rASOihqZ9cxEAqJgfABtiaO3mcKp9koLFlB4SS+Tr5XmJQlXWjxw43vVdxf00c2KnHS6rwIMpxJdH0k5EwfI22Q3mWl9LZGszlxzCrLZuXQWlEPUQwgvdS5OECdKzlnnv/85/Nrv/ZrGGN4/etfzyMe8YiLc/GRkZGRkZFbibHXuDj81m/9Fs94xjPWsX6bm5u87W1v4wEPeMAlPtmZ+bM/+7MTHl9zzTWX6CQjI2fmQuPOJ4UIsieF4crNkqNzz6F5S+EMSsG0ksjz2smsxWpFE6TXCCET9dBjGb2O3vNB0izaPrJRO0orgpQ89J+KTNsnSqvIKHYbL8kWPuK0uOD6JM9t+8ixJpBywjnNLFmshff9j1/jPb/9agAe/fQf5J8+9Ov53LGWeedZ9kGi7chrNyVrFNLSatKQkmKU9L0hZrKReL3OJyyGuoTcSy9cF4bGZ6ZOE5Cov1Wf2IRI5QxNEPH6tLIUVhyIfZRZR85QDb3z1FnKQtP6OJwvURbyPRulaUKkdgqfJLVjr/GEmCmtZlpZYsrMO8/2ZCJfv4/kLDOWwkqfueoVR0ZGRkYujNv9YtTFYFXEj83RyO2VCy2WNytH08syym3ZOWpSSrFeFYY+STG+2wQmRV4vFvmY1or0vc6LAn4YgmxWbhgQDFEdE0cfE1u1qCXmnacPSTKpSycxHzau1dsMzlGT0tJ0gZAzMcH2xKKNoh3U3yuHqNrd/L0MCeZtYFoaSmfoveRNNz5SmFMv96wGGzFnNoazO6PYaT0hJIxWlGhmtWVaSATGn//+H/KW17wEgK9/6rN4/FOfiTWKmRGFf+MjlRG1+bwTJytvxWXJZfA50iJLdoUxkGCzstzt4JTdVor3o0tPFwIqS4FujQyxnFX4XgY0ldHEJFEgbYp0PrIxsVit0VoaCD0MvzIQSFTO4azGaYkQLKwjk5kWTn7W+8C0MMQsKhMZ7KX157wfO7x3K6eo/QOikZGRkZEvTMbafuSOxC2N0W68PL8f+gKlOC8V6ko0oJTiWOuprMFqxUZZMNnQ3LTXcXje0/mIMYat2pCqPIgVEkeXPUeXnq3KcfmsYFoaYtKnPfdGZfEhr4UOhT1xyT2mTMrQ9FKrz0qpN3dbqe8V4vIUYiZk+X41ipihG2L9fNLEKO+HcxoVNEYnNmpL5zMTPRwui0NqyhJALc5RhpxEWBBzpjSW0iQ2qoLN2jItHc4oCiMxCTuNR6UhdtpJLbtZWVnQ8om9VoQTq+WowmiKWgYTbYgsh6WoGDOz2rFRGe56YIJWUvve2o7AL3nJS/jZn/1ZAF73utfxDd/wDbfa1xoZGRkZGbktcUfvNV7/+tfzHd/xHaTBAn42m/HWt76Vf/7P//klPtmZ6fue17zmNSf82dd+7ddeotOMjJyeixF3vnr+so9sT5z0UdGx7CJ7bcAaNfRfmd5HtF7F2Uk/Y4zCaFi0AWsVRiu0hkQiJgahcjrB0chozbLvaL04H8UMThvpv2IkJOlxQF7fx4hWsDUImd/31jfwtl/5KQD+1bc9i/s96ls5vOiHWU8gp4xBgZG5Se2sxNVlmd30XlEXCmcUGplx1NqIcCglNFAX0kOmJKKUrsgolSmQVA4UkBU+JDwSAagHAXrKMuvYryPKrcwr+hBxQ39qtSxQ7bZpHWsYIygnLlmdT+v3zu+LO9dKDQkieT3bWvXnpT1/d9+RkZGRkVMzToeBvb09ACbDRu7IyO2JsxXLILakrY+kfLyB98MQJK3UPZUbBg/6NuumI9atlkUX2Kwcu8j3uxwcsgqj6UKkD5nWB44tvcTeDQ5BpdPrpahJIbnT805yqRsv6oikNcsuiDWsUrRGr4cKEl8R1/F2pVNs1U7e8zw4EVmF0xLdYbQS5yUlBXRhNQemM/7xaEPbR0pj1soLrdUZl3uu2qywWiIztD6+wObj8FovlrFBJf73u97Dr137AnLOPPSx38bjvvN5JwyPKidft/UJYzU+ZLxNTEqJDyFnll0gzDM9MnzanMpA58CkYFpajix6pqXFp8SyDbRDzrZRGWM0tZMG5OrtkqOLQEgJHzJloXEaGh/YrCybtQMUiTz8bMrZpoXBDEtNVuvh59ozKx3HlomYZIC1WReknCmdPm1k5IrbQ2TkyMjIyMiFM9b2I3cULiRGux9qznZwjSqtvtlN9jOxElXkPMQHoDiwWdLHyGIual6JpUvsLgPLEElxiEwIgRBgVhkymcOLnkUbufPBitrZ05xbarnLq/KUzliFNRgFRpX4mAZX0+NRDfMuYLWmjfL9OqOJMQMZUiaExMQZegClSDHjLGg0U2epHagMMSfIlqKQa3f9sGSlwRgDZKmdJ1aiHbJE+W1PHItOHH1TyhilmA8x4UYpfEpkYLN07A1OXE0fUUqcrWLOcuN8EE8sg0RRbFaGSWW5bFJitGJ7UnDlRnmr9nOvfOUr+dEf/VEAfu7nfo6nPvWpt9rXGhkZGRkZua1xR+413vSmN/GUpzyFONRT0+mUt7zlLTz0oQ+9KNd/xCMewZ/8yZ+sH19//fXc8573POVzm6ahrutzvvZznvMcPvWpT53wte5xj3vc4rOOjNxaXIy4884nNipL5TRNHyVJoRaB+LQU96PCrK4nUefdbgtKsVFaUobdJjCrLJWzWC0LR2YQcaBEKNL5yMIo+qRZ9pE2JEotUeVkmBRa5h3DIpAI9xObE8ckGHYajzGKv/5f7+C//cyLAHjENz+Nh3zLM9htI60P+CDLQ1kpSiexecqANYquScRBrCNx4xqtNH3MWCPCGZ0zdWmpncGnhFGRxnt8TlgLPoBVMi9RSlEOyRgAanAe1kozLcU1S3oyEfE0vfS81iimhaHTkuQRopL3urAURhFyYrfJEhloZe4hqR1DRJ+TtI1VTL0d5lgrofekHN2iRkZGRi4Wd/gJ8Y033sgnP/lJlFJcccUVl/o4IyPnzemKZaMU8zacECe2H2c1OUSOLT3LLqKBWSXKga3JbXMxCmBWir1o6yOblaM1cci/FmXEsWVPBrEkHSLcVpGBqwaidqKiBoZ4vEA75FzHFGl8wgSJANEcX6LKORNTZuklY9pHRePT4F6U6X2iMOJKZbTi4LQ45fdwcFJwlJ42RjYG9fiksGccZK2403bBxBkaL8qMvTaIQiJ6Us78f3/1v/npH3gmKQYe8DWP5Rue9SMo9sWmDMOrEDNNiCz7gE9JYvxAvgeriYDTGlUoZqVhWljI/P/s/XmYZGlZ541/nu2cE0tm1trNJqsMg8swgDKKjuICtAu+ICIjiiyiKCCyiQyCAsoiIwKKgAi44AYKLryC2IOX/PypMA6Kig6DLIosvVZVLhFxznm294/7RGRWdVV3VVNr9/O5rr4qMysy4kREdtZ9P/f3/n7ZagMbI8udDo7pfGLhIzNraIdoj73Mu8jchyHbXLYyUlaDVaxiVDtQkHNCAU4r6kpcryqrGVd2NbjbHkR/zkTMYCPbVGL/Wxt9yhhIBce5IxQKhULhlk2p7Qu3Fj7fGO15HxhXljR8z5nUSSnllbBq+f21lQPozXlP4wx9TGwtehZ9IuaMFYtQFn0E5ED8mu2OIzueA9NKxPkKDq3VUqffRPz3iZFwS+fYkD0xK1SS+rdxhp0uMO8io2pY9R2ebxiGehlZNlApc6z1hBjJCeJQj3cp01iD0TAdORqbUVpisTsdMVaR0tIJdRmlraiMQatMYy1aySE5LMVo8hruHzuMkQ1npaQvkQN0iakIKSNXqVBkZl1kp41oFI3THJjWNE5zcOo4vNawb3zy/uNs8Zu/+Zv88A//MAAveMELeOpTn3pOH69QKBQKhYuJW3Ov8e53v5tHPvKRhCCi/PF4zB//8R/zX//rf70g13PXu96VZzzjGXzP93wPt73tbU95u89+9rM89alP5e1vf/vqa8YYfuZnfuZ8XGahcEacjbjzcSWOQ4s+sn9SMe8C82Ghem1w1bUaKiMOuEZLtHhjDcZkYkr0vcwHJpVlXB/vUpUzWKUYDY5TANdvd2wuvBzEI/eh0NJjKbWKnBu5oaeLmXFtAcUH/uLPeONPPZ2cEl/5zd/Bgx//DK7ZEufhPsr9y7WC0RCTiI5QrJyPrZZodQ1oI8YACsW8D9ROM6kdWkMIGWPAeIXPmZExxBiH182QEkM8X8JZRe/BmoSPkRHiEuxyXrkuN5UmBMXaSCLdSWCd5rK1iu3W06fE/qai9TJ3SsNejtViTBCSRPO1feSarVaWd2zm0BCPDqwW/guFQqFwdrjVCqM2Nzf58Ic/zE/+5E+SUkIpxX/6T//pQl9WoXBGnKpYDjGz1e9uj4d46u3x5ebAVZstt1UioUnJXtT2nBsjh9GKWRdonMSk9SFxdNaLE1KIg8Jfc9laTbWneRhXu6IoAB/iKrd53kWclaGEHcRKS1GSG9T6k1oRU2IGsiUxvP6V0bQ+MHIacCtnrpOxFP2oYaM8pnzSSJAlJxP3TIZNh+tMR0aGUR/+x7/n6d/3XXRty32+6ut47I/9DPMoblWLLoKSa8/Ic130gVkv4qicM5WRgZRWijzkh6somxAhSO71vrGTuDyjqa0ZXhMrTlptoI1J3ACAZmoYe0MXIiFK1N51Oz1rtUYP2ygbjcQQyrBp92duVBnGlV29XqPKDJbAYRD6KQ5O6tWWvR2audXP9/D+j1yxmi0UCoVbA6W2L9yaOFsx2llS4QDOyC2qHWL4/J4YvpgSx+Y9fYjEnDk28/jh/8XKGsaVODRVWtHHzNHY0faRpezn0HpNzokYE0ZL7X0m8d+11fiYaKyh8wmlGVxFJYI7L2CnkxhqbRR6WB2IKbPwQ6SEhp2FOKFOG4NGM6oNOkPtJBJh7AymVqQISoxWVxvD2Yo7akqIuMnqIcZPWNb6rY8opFZdLm94Iw5X815cbysjfxdCpo0SR92HhNWwf+pYry37B3XYuDJctt6cc2fUd77znTzmMY8B4KlPferKNapQKBQKhVs6pdcQx6W+71efa635vu/7vjO6j6c+9alnTVR91VVX8exnP5vnPOc5fPmXfzn3vve9+cIv/EL27dsHwNVXX8373/9+3vOe9xx33QC/+Iu/yP3ud7+zch2Fwtnk8407B7n9cmmmD4lxbSUCPENGljXWG7eKfsvI0s24tlw/68WVtpbFlDiIgKrBXXjZ12Skf9RGEUJis5XeL4aMbRStz9x+v+M2Gw0pifOt3Je4JrV9IKTMZz7yIV75nCcSgucrvuFb+O6n/zTXznomlaWLkZjFOak2hmPzfphtZTIZHzOVVWRkNqQ0GKNRCYKSpXpjNTplFLIIw9C7Ka0IXWZUaZzJTEaSWFFVCq00m4ueeZ/IScRYBkn00FrJ/SC9sFEKPThGGQ8HJhXOyefj2rHPKBpnWB9XEt0esoihhvnMyBmUSpL0kjKjiaG2mukwExlVpqRfFAqFwlnmkvit+sIXvpAXvehFJ/27nDMf//jHB9v6z4+HPexhn/d9FArnk5MVyyEl+iAFWhfiatP4Bgxb2FojKns0m3NPHiLhJhd50TWtLbXVzDuJt6usFMpaO+gGYYzTVFZchSqjV85Pe2mHbfc+RXxKOMxKkd+nRIUMWUbsDo4UUtQ21tCGSB8iOQ/3M7z26kaGS8u/MloPUXLyfE6MBNkr7gFWQ5u9t5n3kZwzn/23T/DE734421tbfOl9v4LnvuKXuW6ecQR2ukgbE+MhmuTYrGerC3gf2ekCMWWclY32cWXF7jUkKqNYb2qUVkxHlgTM+sBa7Wh9YjzEgiz6iFGKkbvhz8xOG7h+1rLoI26IJdw3ciLAA+ye56eUDMFG7obvU+MMrZfYSGc0jZVhn1GKQ9O6iJ8KhULhEqLU9oXCzeemYrRPFDg1zjDJeRCYi8PsFh6lJKJ5SboRUf+J9FFq1mNtz3YbaENgex5AQTcIm3KWg971kWPkDDnL9Y5qS+4jG+MKMiy8bPv6IE6kPkmPIq5Q9gbXfar47+X2cTXE54FGjuxhrXZsOc+ilwi+6CWKetFGZj6sIgY7L5HZITDU2pkUM8lKnepDpkuRRlsmjSGRV05ZWkeM1lilSUYeN6RERg7elyx8JERxpt0YOzZGUlcfXq+JSZy1KiMOYLM2snxXaisCKqvVSkylkIWRyzeac75F/L73vY/v/M7vJMbI937v9/LKV77yRvudQqFQKBQuFKXXODcs4/OW7OzssLOzc0b3ceTIkbN5SQCklPjABz7ABz7wgZu87cbGBq997Wt51KMeddavo1A4G3SfZ9w5MDjXypJJO8xMMrA+coSUxH1WS3/T+sisD2y3XsROWQRHBycVRssydxfSsKChB6fdRFaKeSezFJA0h1kXUFmhlKRPHJ7W0vOdQBp607/54N/xY098FO1iwb3v/wCe8ZKfp02aY21ga9HjBxFVrTU5JyojMexhEDplYFI7+hDxIVPVirEzxJSkb/NxNT/qQkApETXFJHM0Y2Tpfa1xHJzUdEF6UKNl3rM1D0Bmu4srYdf6SJ5PzuKEZbUalmUyKI1zmgOTij4knIH944oQ5ZonlUXXu3Mhssw26uH9kdmVxVlN6yOHz8PiS6FQKNwauWR+s96Y+8qN/d1NsTzMu+9971uK4sIlx4nFckyJnOVQfKfbuz0u0WPOqD3b46L4X0Zh+JipnMZ5zZFZf9ELo0BENBtjTUp2EA15UgaVpbCVyDzZGjhZE5FyXonGwqD2N1ockGZdWEVtLHVlaqi6l38ao2iUkSaijVROE7IMityNNC157/0h1ypitBvedhmX14XdwcjuHYEziv/zsX/jMY/4No5cdy33+KIv5QW/8KvUzQjXL/AdxBRplOa6tqP1kS4EYobtNuBjQqEwJtGGYfij8mprBDLNYJ2bh7jAbTxrtWPeS3O1PnKkId5QBmXD9jyZRGZkLbfdGNH5uBpWGaXZ6QM+SBb3tJGs9FM1e3p40VsfSRn2jR19SBwYF0eoQqFQuBQptX2hIO6vCx9vVBx/Yp1zqhjtG4tX0EpqTWsUW4tA5xMxJYzW+CBORT4mGnfTQ8IQ0xDjl5i34lzlUybETMqJRRdRRg6ll4sEWil2BjdbHxM+Sozz4fURCx9YtBLtvN1H9kURSM37yPrI3eC6WxNpnLlB/LfWinpYWhg5w3YXAHGCzRnWaomz60Kk7xOfO9LSp0jby4buNdstnY8i2q8VRosjqdIK7zOzRSQhm7wdgTpJr9HHJBvCUeOMLKZkBYs+oLUaRFGZnU4cWkPKOK2pnGatccN/8hycYeWE24ZIjDI0EOctqIwZtrXl4PzgtF4tWZxLPvjBD/KQhzyEtm35tm/7Nt70pjehdYlzKBQKhcLFS+k1bvk885nP5M///M/5+7//+1W836m43e1ux+Me9zie/OQn32jsXqFwoVkuq9ycuPO9VFaEUWm1LC+/u6zROJNWj1Nbw9gZFk6WLrTVeJ+GecnwvVmRVcanxLyLhCwiKaUVPkQaZ2mcXGcic2Ds2Deu2PWXOh6tFFf9+yd5yvc+nJ3tLb70vv+F5/3cLzNPmqs3F2QlCyryPBTWKmJSZOXl8ZPMKnzKqJwZOY0GRrUjxMzCJ0JMhEEElRJ0fWRcGZaR7hnFWm3JWXFw6jg4rel8IAG1gcvWGnJu2ek8KosQq/UJpwPoTIqKDHQxMrKaecriLKwUIUqs+uFpxcZYhj1rtaGPmT4mTvZPkNaypN7FyLSxjGtbRFGFQqFwjrjV/3adTqc8+tGP5iUveQnW3upfjsIlxt5iOcREzJnaHi+KGlUnFwbVFlK1K2aZdYGdhWKtdux0Ipi5VPKL9SAs2hhVpKFYDSmzMXKnjKcD2YpwRrHoM0ZrIA3DE3ldl4XqbsQIEvahFSSJzBg5w6KXCDmtYb1xdD6x1pz690k/CNqWg65TiYF2urByBFh+34mRiMeOHuEHv/vb+eyn/5073/ULecWv/A7RTTg27zm28GzOOoxWXLc9bHGkTDcU4SlltDZMG8m0bvvEQsm1TWpDY7S4OhmziiYE6H2iM5K/vegjbqQlmrEy4OU6EzK4SynjcyImee0uX2+G6D/DqPP0w8/pjZ1LpSw/p8ufaWdk8JUyjOvPf8uvUCgUCrccSm1fuBTwMa1cT08mfI/klTPU3jjlU8Vo35goai+1NYyrzLyPpCEWQKllPHdikvONbiTPurByb8pZrmVr0YvQXivaXgRX67ZaLVlstZ7KSq0JrOq5ehDLh6RRtSWS6bpE5xO1lZp3mu0gEtu97kUvwqguxBvEf49rEUY1lcTnyXXKi2q0wijF2FmObPfM+khTadoY6GIixowxWuLtBoerg+OKCGzNPV2UunbRR8a1XfULVit8ykwrQ+U023OPNYr54Mxb6d04PaMVVimmjWGtdughGmO9ccf9TOyN2N4/Of49OFnE9rnkIx/5CFdccQXb29t83dd9HW9961vL79ZCoVAo3Gq5Nfca//qv/3rOH+PP//zPT/u2P/uzPwtA13X80z/9E5/4xCf47Gc/u3Kx2tjY4PDhw9z3vvflbne727m43ELhrHPDWcTNWwZeftvyfpyRL6SY2Vx4lIJ9Y+kv5z4y6yLz3tP1svRxXJOqpJcagsgxKMaVwWiNq5RE8G33aDTjRmOdZrsLVFaBEkGpViLWapzhs5/+d77z//lmrrv2Wu7xxV/KT/7Cr+G1w2bIWTGpDKGxQzx8JmdZNKm0wbuMiTL7GWtDbcW1KWVJA9FKoZQs7ez0ARs0Ec84aOpK3Kd8Wi7TOyqn2D+p2D+pqExDGyKbi35wcJL+MStJHPE+rpJHjFaMncT2LUKi9wnvZdE8psyBya4oalwZmsrSsDvj6MNysVycp8aVRPlNG3FcNmUJvFAoFM4Zl0QF/9CHPpQ73/nOx30t58zjH/94lFJcdtllvOxlLzvt+3POMZ1OufOd78wXfdEX3eoamcIth73FcuvTYA26KyBZa25cGKSVYlxZUsrMukDn5TB+5OwNtrAvBY5zdOKmI0H6kKitoY+9OExZjYI9Tlsc96czGh8jjTH4kFbCqGUhm5I0Cj6deuM+5TxEF0IzDLHqk7xHsom/6wiwzAbfy872Fk/4rm/n4//yf7nsNrfjZ375d1jbd4jNuSfEhNYKZw3XbrfE4frmfcRoICusUzROnlxlNCOniTGTlFjgbveBfaOKtUayyUfBMG0UMWXaXoRRfUj0Q2Owd+uhD3El6rJKM+/l58sqzXQQM63Vjm1EHLXo4yBUk0HQ0hK3H17nVSNnNePhtR1V52cgVCgUCoWzS6ntC7dmTkf4rrWiseIOtIx5m9T2uPpoGaM9qs5MJD6qpK4zRq0WIXyQunHRx1O6xm634hIFEqW36CNH556Zj+KWmhVdjCjAp0gfDEYrnNHi6prkMDwOh7/VcGgMUDtNSJlFlF7ER3FkbX1kXNnjrjsMbreV1Sz88dfrzK7z63rj2GK5LKIICY7MekISp1zIHNnpxfEqZEa19EQjp7GDCF8bETKtjSS+L+ZMyJnWB7R2zPvAtHFoJYIyoxXjxkKWGD2NYr1xOK1wTmOQ+94YXJ72j6tVhPeJTrhn4iJ2rvjUpz7FAx/4QK677jq+7Mu+jD/8wz+kaZrz8tiFQqFQKNxcSq9x66Kua+5zn/twn/vc50JfSqHweXOms41TcWJaxcgZtluPH6K7Z33kmq0WZzS9lyWOEDJaSwLE3EfGgNUGpSGmTM6JcS2uSNPG0vaRnBXXzzqun/WElAkRrtvqOLRW46OVFI6ciYCPkU995nM87uHfwmc+/WnufLe784o3v5VNGrxPw0xArl0rEUU5Y2kqPSyPKGyniBlyEteq2knUYIgZG5W4+WqNMQmjIKtMpWWesFFXZKWokqSmrI8s05Hj8rUaqzUbI0fMGafF7Viriq2FZ9ZFnNUSxRckKr2xms5L/1xXmtpIjB6oVU+6fN339qvLWdyJCYOycBRWLlufh7FhoVAoFG6CS6KSv9e97sW97nWvG3z98Y9/PABra2s85jGPOd+XVShccJbFckbENs4q2l7ENKPK3Kgoai9uUOzHmGh7GUCcbAv7YkcrRSTLNcd8k5EgKcv3mKFLmAzb2lttoDIKN7g+LV+CpUOSHYYkIWd22rAa6rjBNtZqdcqNjkUfyVlusxQAjYZrXMapHJn1Q9wGzHovESdG3qOlGKjvOr7/Cd/NP/3937HvwEH+x5vfxvplt2O7C4wqQ8ygkUYhDc9Vqcyo0uQEPoNBUxmNM4baDRvylSZnGRyN7SCsy7IpknJm4QMpi5DKhyQ2un1gNAyt+hDZHJoGgMrJ/ZGgcdLIOKskckRp1mpHZyJtvzvoWjpq7cVqhWsMVZCGp3G6WMoWCoXCJUqp7Qu3Vk5H+A5AzHQ+YYdo6KYyzDqJrWucWcVo11af8RaxVorKaLqckLAAhrg3mA917okOVPLYctudztP28nk/iLNqrTBaDrKdUdTOkof7cyaT0yAoCrLFu6yVF2H5+JpKQdDiXNWFhB9qwuWh8eq6ByHZMh7ixCjqaW1FxO8j642jNZFrtjtCTIwqw1VbPTu95/pZT9cnjJG6duoMPkUxho0KbRU7rccqQ8iyBTz3gbaPKKc5NveMnCWEzPrYUVvNsUU/LEvAtHFURnObjQatFM4ofJSD9kltGVeGQ9Mb5mgvnXBPFrF9Prnmmmt44AMfyKc//Wnuec978u53v5u1tbULe1GFQqFQKJwGpdcoFAqXKmc62zgVJ6ZVdINDEUg0+nyIOZ/WFmcUByYVfYi44Ry/C5G5j9QmSwSdUmy1QWYHI0s3RJ9bg8xGcqZ2GmM0nY/M2kjXLwa3X03tDH62wxMf9e188uMf4/Lb3YGXv/GtVJP9sN2x6COqzlTGApl9I8WxnHFWesA+Jpw27BuJs28bAiFBStBUmvWRzGwWfZT0ixAxRuYek8oxrq3EuWvFqDJsjBz7pxW3XRuxb1Ih60cKC9xu/5jthedj125zcNKwb7LsTTOTxpJyIkaAjLNW0kQGR+XJcN/L5z1tTq+pO1HIdjONwgqFQqFwGlzSU+U73vGOKKW4wx3ucKEvpVC4ICyLZR8zOWcWfSAmsSg9k6JZnJM0CzIhZdkCgBtsYV/s1FZLw2ANnU83GQmyjMCorWKny2QkEmRzLpap+1MmxSQRfSkPDkwSh+GsZmvWM2sDKCme523EKo/RMO/DDSIMuyBNA+xu99fWEHNmex6GDfnE5sIDx0ciLudTOUNOkR/+/sfw/r/8CybTNV73lt/jrv/xP3JsLreftx0+RZRWKCWb5Tln+qjIOZM1NEphjWGtcYwbaYLEFldEVIcmNVllQpAovLE21Ebjg/xstL1nq/OMncVpcRzYbgNtiMe5O9VGs9N6stGEBApFHRO1daThvamtRMD4kGhjJO9xTFBa0RiDs5qdNgASX7LWuJttJ1woFAqFi5NS2xduyewMwiaQeLm9DqW11UNUgCJlOQDvBleo7S7Qp8R645j3kZjEBRS42c6ZS1FRbfQQcSxORp1PbC0C4yozqsywfZtW9etO51n0kZASISUOjiuOKUVIiZwyjdOMrGE6LBd0g/Pn0uGp7SJVpRlXhpQzMQ+xekaTcxaBfoKcMinDiZqx5XUvn/+pNqg3hviBWScLDCNnUGSu3VlwdOYxWhYCKq1ZHzlxgEWcVeddwKfIdbMAGSa1RWuYD85YicyRNrDdR263f0RtFFoNjlIxUzuD05raKtZGFVbLa5uzDBUOT2tGtaWx58/56UzZ3NzkwQ9+MB/96Ee5053uxJ/+6Z9y6NChC31ZhUKhUCh8XpReo1AoXOyc6WzjZJyYVhFiWi2JXD/rQMl8wwyOtxmJOJ82llkfGVeGLhjmvfSvO21Aa5jUjogsgWTEXWqnjWy2HpUk8nt7ERg5zaRJKCUOvwsfwe/w/B/8Lv7vP3+YA4cu4+VvfCtu4zDH5p047SowGNYaicWLVWIWIiOrsUZTuQpnFDnBsYXHGMWiD5Bl2UZrxcG1ipRgPOu5OkHKgZgSs85TO4NWcGDi2DeuOLze0Ax9a+M0a41b9b19TKjh+RotyRk+ZhQKY8BpzajSjJxlpw/S6/aDc3LM9ClxeFKjlWbWhdOarZ0oZCszj0KhUDh3XDqKh5NwPrKtC4WLmWWxvCyVtrtIs4xYOM0Cajl80UqxVolYZTlsONkW9sXMyMk2fWWloA8p32gkiFKKECJdkNcgxDzYte4OpY7NExrZTKiMxmrYWni2u8DWwuNTgiQRIBkRA4EasrkjldE0TuNjXg2VaqdXwrVE5sisX13T5sKz1fZszjzHBoHUtLGknIcC3fPiH3sq73nX/0tV1/zCr/w2X3Kve7PTebSSxiRnxcFpzdY80DaRyinmfSAsMpU1aA1GIcMapbAKaq3RBqwWa1ilpChXFfK6ANZoybhWEqcSYyY30PlIPTwfBYydYTqyjJxcd2Xl+fuQ2O48MWfGlR02/xVKqZXYzJ3C5UxEbJmNkePARKwDThZBWCgUCoVLl1LbF26p+JhW8Xl7RVHjyqwESHtpnGGSpY6d9xKTvYUnZ3FhWirIb+6B6fLbxOVJ0/p0XPTcfHCzEoemKHF/XqLzQkqMnAUkUiDExNG59CMGqSGtVlijsVoz6wN9iCgxIMX7jBpJ7ZczGCVOoiFknN0V4eecV0sMJ1733jjxUzGtLVpJ3b7oA9fsdMQI642ljxGFbEVrJe9PJGONOJwqYNEH+hjZ7Hqs1nJYrxSVMcQYQMO8k8P4PibWGkdTGRqnOTCpqYxmrbFYs+vqVTvNaOhLxvWZb36fD+bzOQ95yEP40Ic+xGWXXcaVV15ZBsiFQqFQuEVQeo1CoXCxc6azjZNxYlrF9sIzqS19SKu+5LbrI7oY6X0S96cs8eNKsXIpjsnQdpEuJojgU0/jDCl5JrWRPssnDApPpmsD1mq01kOknbg95ej5iad9Hx/+u79hur7BT7/+txgf/gJCzBxbBHxIjGrDuNJYY9lceEJW6KzpfCamNCRdmNXMZnPhCUbcrSaVIcbMrA00lWVSOya1uFmFlLDacGhacWit4fBERFEgS+vrI7d6ba3RrI+k/71+p6Myipg040oTY+bAtGLSGDQSA6/ITBu7Wlw6tvDknLFKsQiRNaNlNjQsQZ2KE4VsUGYehUKhcC65pIVRhcKtnWWxLIMHRYyZjsT66PSHJK3fLZabyjBrwyqC7+bmWF8otBb3oTZEyc7uwikjQUAiTLZaT0iZ2hp2Os9OG0kZ2ZrvxXZ1ESJ+2GhvfaQLEVBMa0cXA9uLwNFZwAcRAYU4xMVpLeKpwfZ2XFlqp1lvHCD53MuNgLaPbC56PnOspY+J7YUIiGqriUkKfgO8+RUv4J2/9zsYY3jRq9/Il3/lV6+cpZzR7B9XbC16FIq+Toy85fKRYd4lJlVLyorNuScrMbpqaiMDLKePiwB0WlMZQx8jzsogp/WBfeMaVB6GPJkQEiHCtFaMastG41YiKRgGfs5w3U4nWyJ9oPPSYBxea+hjZv/YMq0trZetjJRX8z60kniTmDJqiF45MYKwUCgUCoVC4WJm3u3G5y1FUesje9L6dIlWEqlmjWJrEei8bPpao2lDpBkE6DeHvVb9k9qilIi2ltFziyHieOEjx+ZywLvdBkKSmnZSD9euYNFFKhvxIRFzIme9cnqSGlwzQ9H7jAJCTrR9IA63qZdR1FaTggisFAxCfXXK697756nwIa9uY5WiDeLotOgTmcx4+TxyZuYTCy9b0T6As4q5z4QMRklhapTCGY0dVaSY6UIm54BPsoE9qSv2jWoymZjlv2qPKGrZA0xqe7Pdvs4l3nse8YhH8Bd/8RdsbGzwnve8h7vf/e4X+rIKhUKhUCgUCoVbBWc62ziRE9MqpF9UaK1Y+LiaTRglCzKdiYSY2e7E8ilnWYAOSVyqNiYVjQ/stDI/MihSGhZYhl5yu/XonBnXEiO31jhQitooFl3Pzz33yfztX7+PZjzmpa//TQ7d8e5cs7VgHiLzNhFTZv/EolAicsoJlcFZ2GoDVdbHpXJMGyczFS9uvlZraq1oaln27rzHGkVlHUpJygWAVeBTZmvRS4JGZSU5Y0gJWbK9COQsKR+1M1RGc2it4tC0ucHrnbIsvOcsbs4LH+kGAVpnIrWViD83OnXvd6KQrcw8CoVC4dxyqxNGzedz/uVf/gXvPXe60504fPjwhb6kQuFmsyyWc86DA5Gn9ZEQ02kVy32QwQdAUxkU6jjHnktMFwXI9nUbIk1l6FM6aSQIiONRGKY2OSeuH4Q7TiuUVitxT2NlyyFEhig4cMYMrlrSJEgEiWRaL3wk50w41mKHLfzaanxIqJrVQCTlLO5LiHPA0VnP0VlPHyMaeW9zyhij6EPER3jHm17FH/zmmwB42oteyT3u9wA+e2yx2iJYaxzWqNXgKsW8ikUZVYaUKpbbH/M+Dva3GWs1MWSqWmx068G5SZzEDFaDs0asa63myE6H1YqkMlppaqe47b7xSlCnkKiTUWVWQ5/GGZQSJ6urt1s2F36wqq2Y95H1keR9j0/ynnYhMjtJBOHFGj9SKBQKhfNHqe0LFzsp5UFULzHVIMLx06nVQWqecSXOo10QYVRIeeVueibx2UtOtOrfGFVUVqz+G2donKEPiaPzHquhD7IRWznN4WlN7SSSYXPh2Rg7Qs4c3emZ+UwmMKrMqi6srEYpEURpMp3PHEk9G+MKa3a3Z80QyaeGWlwPAvkbu+4bc8xKKXNk1tF6ifKLGUaVHhxgNX2wVNaI+L+P5EWPVpacYOE9OcHGuCKnRO0Mk8rSpzREJCT64frGtWFau+E1ycw6z6SxHBien9WKUWVW79OoMkwvwqjylBKPecxjeNe73sVoNOKP//iP+c//+T9f6MsqFAqFQuGCUnqNQqFwvjnd2cZe0h63YdhNq5j3gabS9ENMu1Jw2bRZ3ba2hsPrGrahDbLsIssgCm0UKivGlaGP7ZCUoaisIabMpLKr2HKj5HYbo4ppY8k547TilT/xDP7qf74L6yqe98o3cbv/8J+4bqdlswvMF7JgYq1eORRDpveRPmaxG84KHzNdjDgvcyutFGsjx6KPbHdBFr8b6Smdkue9b5zxERQZp+VrIYr71KHphLWRzGdmw+tQWU3tNL2XGRHIw9dG5hv7RtVJ3ytJw5C496YyhJQJaXBcHl7ffoiCP9kc40QhG5SZR6FQKJxrLr4TuTNgZ2eHa665BoC6rrn97W9/ytt+9rOf5elPfzp/8Ad/QAhh9fX73//+vOIVr+B+97vfOb/eQuFcMK5FcFI7Q+U0oZNiWSl1nJp+LylnWr8riqoGO9Ju2Ea4qS3sNGyQdyGRct7j7iOimpG7cAWcM5pJbZl14ZSRICElee4qc912x8yH1fb+pLEcnNT4mEWgZGSzYNFHYhZXpgzELFvvKsPhac2oNkycpYsSZyjZ01k2yJWWwUqGWRfYP6lWg52t1nP9Tk/nI0bLe7Y56/FRHstpDRre87Y38Y43vgqA73n6C/iSB3wLANdstewfOw6vN6sBlNGKkKAL0pyE4bHGtUUpRUIEYTHJf80QnTd2GrdnSDdyhmAyaVjpV4hzweaixxrDdu9xg5uBNGYM0YE3fP9HlaELSRqXENlaeK7f8RityRim2d7gZ/VUTZ08l7I5USgUCrc0Sm1fuCWy8JEMxx1GLw89T5dRZVh4iX0LMVEbQ+cTRismOZ9RpN6prPrFBUoz78QddSnu16OKnc6v+o3aGdlircQx6vqdHjPcbwiJnUUkhMShtYZRJbe1WrE9l+WBRCYmxQEtG8Eg4qkuJHzMTGuzEulXexY2zjRiYKv1zHo53N9sAz7G3TpVKVIWsZIPiVkOrDUOrQKKISI7J1KSreKcM+ujSqLwnKb1kSOznrj8ulWsNxVGwWUbDQfGFVorGmuOew6T2l6UoqicM095ylP47d/+bZxzvOMd7+CrvuqrLvRlFQqFQqFwVim9RqFQuBS4sdnGrA/kBHk4209ZljZCEgFQ7UTIs1zMtloWUbZaD0j/tHQmrqxm0YuIZ1yZVfTdMgJ+WjuMhmNzieILUaLQFUPsXOPYXIhbUsyZrEQ4tXwOv/pzL+TP3vm7aGP4oRe+mjt+6X9huwtsLSIpZTbnnjZGRpXEqVutAYvRir6P+JhJJEKAScp0MdFHiaqzVmYoCy9pIG1IKAX7ho3rceUg51W8O8hiOMD1s47tzlM7Q2MM1sqSeR8TZHlltZLXSik4MJGFF3m9ZabWh2XihSydb7aBymicVaQsr3ccjAxqZ2h9ZLynDywzj0KhULhwXHyncmfAs571LH75l38ZgB/+4R/mVa961Ulvd9VVV/EVX/EVfOYznxGbxz385V/+JV/91V/N2972Nh760Iee4ysuFM4+zmimteQvrzcWH9NKyNP6iBtcfhSshjJ+KGRBRFFr9bJYVhitT7mF7WNaDUtuYCaVISKb67MuyHZ7bS5ITMS0lo2F1scbRILMusDmQpqBWR/potiVbowqrBVVvtWa/RPLuLJ0IbLThlUO907nUWjWG0NTmSHqToplZzT7rGxG7BWfpQyzznNgUlMN0XggcSpHZyKKWmss1+500pBEiY0bV5ZJbXjvO3+PN//sCwB45BOfwX996Pew3QZiTFhj2GwDB9d235HaSR52HuxyrZWfkZQT8z4xruxQgCeck/c4pczWIlC5RGVE3JazuBHo4S3MSNHuY2ZcKfY3Fc5qbr+vYTo0XKfCGc24Msz7yKFpTRskx3xz7jk26zk2FxvbZcZfiAkyVMOWxKUQP1IoFAqFz49S2xduiXTL2OTBNWp5GH0mLDdRozUsfGBSO/pOLP4XfWRyCrHNyQ5uFz7S+sTYGaxRx1n1O6PZGGtSsix8ZLsNpCx9g9GKcaWpjSIBIcnhdVNpjFFMGkvIiS5EtvsIOx1jZ3drzZzRKKxSVE7ikUFEUVopWRJQ4obrjFo5Vy0504iBY3Op9zfbnn4QejXWyAJBlBrXKEXUirXGMh8GAE1lWNMOnxI5Z2IErTPjynJwWklUg9UcXvO0PhFTQmvF5esVG6OKSW1ZH+3WxQouaF90Ojz/+c/nda97HUop3vKWt3DFFVdc6EsqFAqFQuGsU3qNQqFwqXDibGMHz5FZz8KnG/xeWpJ1xmggi7vv2shhtCKmPCRfcFw/4ozGjTQpZZxVXLfdYbS4QfmQ6HxgUls2xo5pbbl6q0WhmI4MGkXlNNdsRXxKNEajtV7Nm37vl1/F239dft8+8Xkv54vu/40cmfU4rTk661AaFiEy84GYLCl6riHTtIa1kaPzgYySHlIp2j5itUQCehRdlznWerbbgNMaZyFGWdxPyJxjY+RYdJ4+J9aHPi3ELK5Oe0RJdmk4YDXzPjCpDNYaep9YH6IBQxRhWr9nprZicNia92JUIMv0itZHrt5pOTCqSTlhjCJnmc3tvZ8y8ygUCoXzyyUtjPqjP/ojchYBwZOf/ORT3u5JT3oSn/70p1FKoZQ6rnhQShFC4Hu+53v453/+Z+54xzuej0svFM4qByYVbYiEaJhWdohAk62BPqSVO9FerFaDsGe5qa3wUQrYk21h73RhtTEAcr9tiEOu9OAYtWczug2RNsQLthm9MRT/eyNB2j7ymaMLFj6y8IF5lwanJMP6yBGiODzFPZv3IydF82VrDTtt4LqZDFLsUMzGBAenFWMnIqpxJUIenRVrjQiMWi/WqZXVGK04NvOsjSSDe9FHRpWhj2nlWtU4EadNa8P/et+f8j9+/GkAfMdjfoAf+JEf5bObLV2IbC4C4wqqkWx4NEPc3epdG2ZuIYqjwLSqsCbQ+0TrAyEmtheRkRPHJ7QU4FrJwGvWRmLOOAOVMYycYrv1IoJLmXpwEhhXp/f+TmpLzJnOJ9Yrx3V9x7FZh3Py/NMNf0zpgzQvy8HXxRo/UigUCoXPn1LbF26JpOHn82SH0WfC0lXJDor1erifeR+xRh0XzXeqg9t+EPwDJKc5MutZr53UvuyKtbSWLeKNkSMNLqmyhazoYj7ucYxSGKXpfYasVnEBbUg4FUlZ6t+mUmglQvnOJ7qQmFaWyhiOzju6YVO5drJs0Nhd59szjRhIwxABWDnkrjdOfj9EETKR5PUIaVn3q5VrVjPU711IK5dYAKOk54lJFgnWG4czCp8yjbOriMHlFvWFdtI9HV7xilfw4he/GIDXve51PPKRj7zAV1QoFAqFwrmh9BqFQuFSYjnbuGarZeETo8pidWKn97S9uERBxhjNaHAAtkOsm9GKDaVWveDyz5Mt6GitZGFca+Z9ZN+4Yrvzw/wg0QaZIbRBxEk+KnzI0MlcxBpZllFZ0YXE//zdX+XXfvFnAXjCs1/EV3/Tt/OZY630YUr6QKWRRIsM1kg0nlLicNXHxMLLwnSIWRaosyIOblWLVlI9Oh8kXj4nOq+xRkRgGtg/rQYDgIoQ5THXR4pD05pJbVn0gT5m+mEW41Om0bDWOGLKzNvI2siyf1wx68KqFwVWr8WJMzGjZV7itMaoSB8yTme6EAkpodXx5wCXSuR6oVAo3NK4ZH/T/uu//itXXXUVSinuec97cve73/2kt/unf/on/uAP/gA1/KN/6NAhnvvc53KPe9yDD33oQ7z0pS9lZ2eHxWLBC17wAt785jefz6dRKJwVRs6w0TiMUoN4SVM7g9OaNkbynkJNaUVjDG6P6Gk8DBj6ocA9cQt7c+FXw4V2iKQL6STbCVFEL1YrRk4clWadFKnrN+EodC6YDsONzYXn2Myz8IGQh3i5mJnUalV8tiHitGbkLM6owXErYZUo/jPQ+UhM4ma06BPTRgRM40rERAeH4nrJcks/xCxxHl2gdobOB2Kqh8hDeV+6XoYo09rJ96TE333gL3nB036AFCNXPOy/8aQfeyFaa9ZqS+cj13XiCrY+svQhsfCRNaNxw/ClsYY4uD6lnIlJBE6dTzhjGNVpeL+kMQohM++iDH8UdMOwywfog1jCghwEWSOPManPbNiz3jiu9R0LCfpmXDvM6vWW19dohTWatcauRFfH5p7Da/UF+TkqFAqFwrmn1PaFWyqncxh9Oiy/rXJ69aezms5LjPa4yhK5t2f7FeTgdrkQsPC74iIzHJQrDUdm/UmXGdRgOauULEm4QYDVhUjb7/YDk8awESxhR6Kguxhpu4QG9lVa4pa1QSHOV0ZJjN5W57l+1pEQodOkdivn0nFlbnbEwMKLY2uIiRjzqq9Zfq22mj5EZl3EWkVKQ0y2YhV9V1lNH9IqqkKWHCyNUyilyVm2kLVW9CHRODnIroahxKlcvC4m3vzmN/OsZz0LgJe+9KU88YlPvMBXVCgUCoXCuaH0GoVC4VIkprxKn1guWKckvUq153Ypw9bCM6os+yduFcW3XMhe9pIpn2SeM7B3oXmtdnQmMu87coadTuZBjTW0fSIjrkijWg8pEZZ5H3nf//s23jSkXnzXDz2LK77zsVyz3UGSZRcAbSAlmDiLjxmyzAI0IhSKMdNYzU4fUUpJ8okB7zMhSDQ7QB8yfUjUTq+cpazRTCpL6xMqy1VOG8PhaU1cuSDvzhuOS/xI0PrAxqgCwipWcDkCO7EHPv6Nkq/5KE7NtTP4JP2lxLSLEOpEY4G9r30RRRUKhcL54ZL9bfvP//zPq4+/8iu/8pS3e8tb3gJIbMBoNOKv//qvuetd7wrAFVdcwVd8xVfw9V//9QD87u/+Lq997WtpmuYcXnmhcPbRWoYUGbh8o+Ha7U4sRpvdmLwTUUgRPRqGDlsL2R4/cQt7pwsrUdRW61euRkrtxsdpJdamflDgh5TZ7gJ9Sqw3jkUf0UpdkAKvC4mYMpPG0MdISolZH1aipMruDl+WvUEfEylmnNFs90GEYDEz6wNay2BHXiPN2Mlw6MB4VxR14pa+MWoQJknBjoLPHJuz00oUSspBmolKokP6qPjYh/+en3zKY/B9x1d/4zfxrJ96BVpLoS9xKCLQan3EaLXaZBtZg9ISizJpDLM2Ug2b+0YnFPIeVVajO1h04p610ciArRlehK6PdDFhkdxusjQHMcPl6w2V0YSUT9stasky03xj5Jh1nq3Wy3BOq+PiUoBVbN9GY9k/qVbfX8RRhUKhcMuj1PaFWyp7xUVw44fRN8YqBttI/d0FqbO3kPp83keu3elIw+F5HyILn4Y46V3nKGc1Vis2F142YqO4g55smUErRSTThkjnI6Cl3l/1A7JQMTV25UC6NQ8cmYtDqkRwJ6xROK2YNhatDMYqNtvAYlg+qIwI/51RWC2Hxyc6Xp1JxEAXxBW2DRGlwGkNQ++y8PIYVmtmMZBQy3NsrN6NOdRKDRvLgRAyjVWDK6+mshk7CPmVgrVGDvXbIbKvC4lJfbPe5vPG29/+dr7/+78fgGc/+9k85znPucBXVCgUCoXCuaP0GoVC4VJjOZNxRrNQEaulD1FJZhZWK7RSKJVRWYGS/qz1iYycn3chimhIK4gyuznx/H0v641jpsQhqbaGtcZSec2xhceiGDtx9dVGUw290DKu75//6kre+BLpKb75u76fB3/3D3HtVieL6inSD8srTmtmPhIRUVTOMouZ1JbKaaJOhF6hgaSkUQspY4zE3mWt2Jp5vJeebFJZDkwrDk7qwZ1YBEniUKVQSDLGWuNYH1mUkkj4lEFn+Xrj9Or7nFWkLO7KG2NHbQ07nb9BD+yM2jMTk3mNMyJikz5UFpG0Ekes5WxjyaUQuV4oFAq3RC5ZYdSnPvWp1cf3vOc9T3m7d7/73YD8g/XIRz5y1cwsecADHsADHvAA/vzP/5z5fM7f/u3fcv/73//cXHShcA4Z14Y2RNYaR0YEL10QYUllZUNbKWRj2wzb1oob3cL2Ma3i8/aKosaVYVSZG2y8N84w2bPZ3fnE1lCIz7qwElKdL/Y6XfU+sd2GQUCkGdeGatgiABk2+SA7B0vFvhmclJzWdMFjlaauFLURJ6blWMsOgx7glPaqrU+r+MFxZVh0EWMUXYz0XWLkDPvGFa2PXPVvH+NFT3k0i/mMe3/FV/P8V7wepQ073a51rVJK7GuDxP+1PjLvA1dtSySdVtIYxJCJGXzMbC/6VazHsbknwSo6JGVW3xdTGgRliT5D30pzctgaUpRNk5TyStB0usy6sPoZWgQJ/p7WEjtitWJj5FY25XFojCqrQSnmPrJu9AUV2RUKhULh3FFq+8ItlaW46HQPo0/FMhp7GXOn9W5EXGsi1+/IYgTA0bmnHzZyFRLfN3KGupID4EUngiTdiTPqqDIcGFekIVZuWWfVVrPoA2kobY/OPY0V8dDS9n/ZDyyXKozqGNWa/ePIkVnHvI+0QQ6l+5DZWnic1VTWMK6tbO0OcdAhZmxjiEni6uDmRQzIxvAQX6illvcxieuT0XSDgCkjIqqcMkornDm+rnVGERZ55azVh4hChGfNsExSGU1lNT6GVVzizRW/nS+uvPJKHvWoR5FS4glPeAIve9nLLvQlFQqFQqFwTim9RqFQuJQ42UxGa0mrONlMBjjObXc5k6mMZtZHJpWhQ3qfSc436mI8GVxwF32EnNEanFKoxnJwrcYPiy/zLtKGyHrj+If3v4+fefaTSCnxjQ/9bzzyyf+diCRoxJzZbiNtyNRGk5Gz/8YafCWReU4pppVlZA1BaVKS/rf1CadlQeXYvGe9cYydCKjWJpa1ynFw6hg5S2XVEDcYqZLCR+kJjRKH395GrK7IWVJG7AkzqlkX+Nxmou0jWYlD18gdvxh0Yg+8pLaQql33qaVD1LjajVoXEZv8eSlErhcKhcItlUtWirq1tbX6eP/+/Se9zXXXXceHP/zh1eff+Z3fedLbPeABD1h9/H/+z/85OxdYKJxnnNErx6L1xjGqDaPK4owZ/l7tCpoGJ6gjs/44UdSJW9jzbjc+b1kAro8kGuJUBbRWMqxZH8m1dD6txEnL+zsfnOh0td0FfJTtcWfkGg9MKqaNpXZ62AjQaA19SiiliEnyrq0R4ZBIoRR9TMy7QIyZtdrSOHmu261fvZ5diGzOezYX0rwoBSElvI/0IXFk1rPTBuZDkxNTJubE1Z/9ND/2hEeyfewoX/jF9+J5r3ozSTu2Wi/WsYiAaTHcTxcis0Vgu/WEmNlpA31MhCzOXePGMW0MRsHRhWdr4cW6Nstjro0sB6aOSWWxGhZ9YLsLMBTqS/WXxCpm9o9qOi82tePK4mM6rffDDy5aANudZ9bK8542lttsNNx+/4jb7htxm42G2+4bcYf9Y26/f7QafHU+rdymZsN7WSgUCoVbDqW2L9xSqQfBfWOlJu8G588zIeVMP9Q+y/s5vCfCWaKwDeuNI6RMThIHvVZbDq3XHF6raSqJko4xszGuuM3GiNrJRutOG7h6u+XIrOdzxxbM+8FJ1kk0nxviGzovDlBrjVtFSe9lWlsOrdWMK8u0sdxu31j6kiEqYFxZRpXlsvWGA+OKOx2YcOcDEw5MatZHjtts1GyMnET2Oc3GsFm7FEVNantazqE5i2ApZ2iMREcsHVebIYqwHpyzABkehMiJb0vOmZAzKSdyzsz6iLWa2mnq4X0Y74mmODE28WLk/e9/Pw972MPo+55HPOIRvP71r1/FBRUKhUKhcEul9BqFQuFS4mzNZGQdWhyXrBYHo0V/0/MZZzTrI8f+SY1RCm1k2UQBXUyElNBahEL/9x/+Ny95xvcTguf+D/xWHv/sF5MVdL3EkqcEWSUMCqtgVGnWRjKPWWscG43DVQYfMyln6kqzMcQBGtmXXsWeH533XLO5IMTMWuXYGLmVc/HBNUm4aINEyDdOsz6q2D9Y+Sp24/zmJ3kNRpWhtpKQ0QeZAl2/061er1P1wHtf/3El71FICR9lEX59VLE+chxeqzk0rTkwqYZFp9KDFQqFwoXgkrXc8N6vPj7VQd5f/uVfkodTSeccX/u1X3vS293hDndYfXz06NGzeJWFwvllWlux6/RxtT2+GLKPuyAuQCdyqi3slPKqWFwMAqNxZVZDgJuitoZxlZn3cg3NEDmX0rkv/E7ldNU4GcpsLzwhZWonVqW1NXtU/XIfCnEtOrLTM3KGnDIZaSLMoPBXSgRmIWWMgn7I4TiZvWplJd5OZXBW3LqWGxOVy0ymlquvuppnPPY7uO7qz3HHu/0Hnv8Lb2FBRWw9zmj88B52MRFCQhmF1oouJro+cWzRE0Lm4LRi36QipoxVUFeOhY84pQdBXKKxGqs1ikxt9cotKiUwWZFUxmpDZeE2tWXSLJ0D5Odl7Jzkjp/GpgnsNl2dlzxuHxPT2rJ/XKGH1+hElg2dNYqthbhNtUZ+luZdZGN8yWp7C4VCoXACpbYv3FIZOcOsC1SDECck2eSdnIH75d6t08rKgfRyw7S2mquOtSgGQb9WTBvHWuOorGbei5upYjdGL+TMTuvJWcQ/Mx8JUeriDHzm6ILb7hsxdgY5Qj6RUyt/xpWlMlJzXr/TYY1i3BhZShhXVMZwh/0jUs60PqHIrK871ht3g61duHkRA0oxbPIiCw5JxEqtj4M4y6zeg9SG4ZA8yVZwZaRGVrDTS+S0yWqo9xXrjWU6RJWPq8HpauiVlr+6Llad0Yc//GG++Zu/mdlsxoMe9CDe8pa3YMyZu5cVCoVCoXCpUXqNQqFwqXA2ZzJtSBKzHhNjZwiDo5Q16rTuLw2JGesjR4oyKzk4rdAoWh/54N/+HS9+8qPp2gX3+aqv45kv/nnaKDOQmQ8klYkxUWuLrhJGyzyiqg0xJ4koN4oQMspkupjoY8YqRVMZxt5yrO3pvSyAO6WIMdOsWTbGEo231jgUIiI71nr8EGnXOMtkcPndP5YYu3aICOxjGlyGd/890Eqx1lhZtg8RO8x9rDUcmFQnnV2c6jWrrSGERExZ3KKG97WIoQqFQuHCc8kKo9bW1lYfX3/99Se9zfve9z5AGp773ve+jEajk95ub0PU9/1ZvMpC4fyzMXIYrZh1gcaJ4GkZ4ZbSEAWhJIajGba3l0xqu3LoWfhIRrarQxJV/qg6s4PzUWVY+Dgo7aUQX/gzGwTdHE61VbHMvF7+L793W3+p6rdacc12Rztc57S2IoiymuyTvIZkFkMkSAbmPrDYHCLmcj6pvWoXIn2QrQfZFnDknNleeLSGa45cz0/+wH/jM5/6JLe5/Rfwije/DT3dx3YbCBFiCiu71coq5loxqQwG8CnTDXF6CoVP4iowrWSzwkfJHj+4VtEeleiUhU8w5ICbkIkpMakNZIWzajWYmtSGw9OG1kcqY9g/dhijpXkAiWO5ieFeGt5/kIFUFxK1M4ycDJOWw6tTcSFFdoVCoVA4P5TavnBLRcRLEnk9cobtIXb5dA+ju7Abe72sxZexdSDRALXTHDAVV222g9uS1KCz3hNiYlwZyIjr6QmLEkqJ6H+7E1fRy9cblBIn1J3W01Sanc5jtKJyEsm83QZGVT5pjMDyOVdWtoytURyZ91il0cC0MSjg0LQeNnyNiPwHR6dVr/J5RAxoJcsDjbP0Ua49IzWrRBpYUgbdesa1oU+WeRvwMWNjxsdIiJkjs46QMqPGYJRi39ix1sih+siZVf27N+Zw+fgXG5/4xCd40IMexNGjR/nKr/xK3vGOd1DX9YW+rEKhUCgUzgul1ygUCpcKZ3smU1tNFwAliSGdT2wtAuMq32Qs3zKNwyiFz4kUMxvGcmwW+NdPfoyX/cj3Mt/Z5h73+nKe/fJfQltHCgHIqJzRQw8aoizwNE4zrS2j2jDvIz4kYgKrMtYqYkhoo/AoQpSPVYKQMyZkqsqQhig8QWY9OWeUUuQoyywbIxFFLcVPRiuOzT0pS7S9s9KT7p9Uxz3/xknfnGNGG1mO6XzkdNvRPsjsot6zFKWVQml1XmZihUKhULhpLtnfxLe//e1XH//t3/7tSW/zzne+c/XxV3/1V5/yvo4cObL6eDqdnoWrKxQuLNPaUluJwutCHByLTq5qP9UW9tJdqh02FGqrz/iQXytFZTTdIMyqrHw8OYdn8De2VbHoI5FhaBEzPmZOrEe7PRFtWwvZMuiHDfEwbLajMiFm5h1YJVtnayPHsbknpMSksqst/SXLgUk9CIDGThMztD6xWMx51TMfy8c/8k/sP3SYl7/xbRw4fBu2Wo/Tms1W7lchW/jjymB1xMeIM4Z539MMdq+1M4wrI42FyxwcNxzZ6dAotFLsn9S4uWcRpZlprJYtjNowdnbY/5dmYt9YHJ2c1dxmo5FolszgSLCM2ss3Odxrh4bOh7SKKllvHM3Q1FXmpn+2LpTIrlAoFArnh1LbF27JjGsRRjWVoU/pjA6j98ZeL4Xk43q35loenIeUcVZTuYoDk4pFH0nZMnISY9yv3EyhshpnNBpFIuOsovWB7TbQxzlNZcThM2Vqo+ljJOXMgXFNJtP7tDood0avXKyWB/g+JnKWWvHAtObgpKELkX3jittsNDijOTCpVs/BWn1W+4PaanxM7BtLHDVKYQ2EkFeirnFl6BvHkXnPtLIoIKaEUeLGuvCyTDByhsPTmtoZDk7lmsfVrijqZDGH9WluE58vPve5z/HABz6Qz33uc3zpl34pf/zHf8xkMrnQl1UoFAqFwnmj9BqFQuFS4WzPZEIeep+Q2Deu2EKSLuZ9ZOEj1bKfk2N++pDoh36utuJ+XFvNbOGZDWkWV3/m07zwB/8b28eu507/4Yt5zivfxNp0CojDVM4QE0TAaU3MEWcUk8aunk9tZAkmJZktGCPPMacsYicgJ+ld1bBovT521MYwqQwHJjW1MdRO04dhYFHLlo3VmlkXMFrROEMcBEohJeY+MlGKY/OejMwllk7AsqDDMP9QWKNwRjPrIilzysUgcUOOq8SMpjKoLIvyy5uf65lYoVAoFE6PS3aifJ/73AcQ6/93vvOdXH/99Rw8eHD19+9973v5+Mc/vvr8G77hG055Xx/96EdXH9/2trc9B1dbKJx/nNFsjDUpWRZD8XgmW9hLN6WU8ur+bg5LMdTyfva6NJ0LbmyrorIaHyONNXQ+0YdEqnZtU+d9oPeJ2mqOzHv84ArVhUillbgjxYBCEXPG1dDGSIqgjCInBmEUx4miltsIAOu1Y9ZLjMeij+gUeN3znsz//fv/zWRtg59901u5013uuhJ3OaMkAzyJG4DRiq2FCKV6P2w9GMXIGpRSTAZhVEyyzdEFES3tmziO7Xj6EDFWc3jsJCNcy3VPG3HL0loxrQ1re+JMlsOfrYWnC0kK+gxag9U3vWmytKc9uuiZ9RIlM9pjATw+ja2XCyGyKxQKhcL5o9T2hVsyzmgmtWXWBdYbd0aH0SCiqPVG4tsmtb3JZYY4HC7D8aKovW6mS0JMKOTAt/Vh5bx6neqYOEvnIyAHvVopNkaOymjaflewvlwA2IvVahDui9MnStM4ue5z3Q8s4wvHtSwrbLcepw3aHS/qskYOyjsSOWV6n4kxUDlDZTS20UxrJ4sHTg7fp7U9LvLvVDGHFwtHjhzhQQ96EJ/4xCe4293uxnve8x72799/oS+rUCgUCoXzSuk1CoXCpULKmZQys0Vg7gMhWfqQV6KdysjCzE256u6dyayPHbM+ALDeOFojIp6QMt0gdjoRqxVKS1LFvAtDf5q56qqreNlTv4frr/4ct7/zF/KcV/86qp5ybNGxMaqYNjJ3UcCs9fQpoZQi6kwImaCgshL/TgafEvvHjrlPzNpA1GAQ1yalZY41rSwLJSKj/WPHoWnDxkgi9OR5emJMLIZeb1IbDk5rnNGr59gG6XWdUYBi5DQ5s3r+48pghtnIqDYsell+nzQWhsSMG1sMiinL+6QloaPzgQRstZ7a6rLcXSgUChcJl+xv47vc5S7c+9735kMf+hCz2YyHPOQhvOENb+Dud787f/VXf8VjH/tYsU/MmUOHDt1oQ/OBD3xg9fHd737383H5hcJ5Q2vFpLZnLCBZziuWf97cSIjlt514f+eKG9uqaJwZ3I127UxbLyKlENNK1T/3kRhkS7+yMiiyy9i8Xuxgx5WjcZqdNqA15EUmZJgONq0hptXQpPW7A5PaGXGqMiLS+qWfeib/8P73UdUNz331r3CnL/wi4pDf3TjDTitCorVBuLTwUmhXWlNPNLNF5NC0Zt+oIuZMGMRvsi2R2Jp7MhLDgs7sH1WyJWEkSnG5CT8ZHMOW0SxKHb8xAbsNlVaKupKP953GcG9z4cUZq5MGbFIZprUM9/be/01xvkV2hUKhUDh/lNq+cEtnWlviUHueyWH0UswEImyannCgerJlhmVN2/m4EkWtNZbqBHfPeR9Wt62MwZlEmyI7rVzbvJIYgJWI3ig2F55RZdgYV/iQaGMk74nrVlrRGIPbG9dd2ZXzKJz7fmBvfOHBSUUX5fmsNceLunxcbiOLuL9PssygY1ptB49rw/7B6WrfuDrucW4q5vBCs7Ozw7d8y7fw4Q9/mNve9rZceeWVZYBbKBQKhVslpdcoFAqXAj7KWf7CR2Z9WPVQKWfI4sDko/Qgy8XjUy2znziTWasdo0oWSJoher0fFpDTnn5Oa5kZ+Ji4equVxWqlcFZzzbXX8YqnP5bPfeqTHLrN7Xn2q36dQ4cO0Ufpo67b6YgxSd+pYOYjMWa0ApWh9YGNsZM+a7UoLX9uWMNaI4vkiz6wkzJGabRWjCtNXWluuz7i8JoMuVLK1M4Q8+DypGSRXWmIGY7OO1ICa2TRPCWIWV7EPkRClBnGcpln3kdCTGRgXFti8viQWW+cOEKdYjFIenxZCq+dpjKyqOSsCK98SMwGUdXJUlsKhUKhcH65ZIVRAM997nN5xCMegVKKD3zgA9zrXvda/V0e/sVXSvG0pz0NY06+tflv//Zv/MM//AMATdPwJV/yJef+wguFS4ClK9CyiL65IpTlty3v52bqq06bG3O62us61FQiOlr0UVyPBiFVHxLbC08XZIOgNpaUswiilOLoXKLztFY0zg1b93Dddo82MK1lC3/hI2tGr7KlgVV03MbI0sfE6378ufzVle/EWMcPvOi13P4/3ItFCDitCTHROCtDmijNTj+4fo0HpwCtQOEZOc3aSIRG641FKyXX7INY1+YhCjBmmspyaFoxri1diBilGFV2lcWth3iVk1nD7m2oZMvh9DZNOp9W9z+pDeuNDJVEkHX6/wydb5FdoVAoFM4vpbYv3NLZGDmMVqd9GL3XgXRS2xuIouAkdVHejXBu/a5o50RR1E4nwnYQd8+d1rPTBcwQO+djou0yCiubuylxaK1mY+RWB/WTyh4ngNrLcnt3VEl0wXYbzls/AMfHFx6a1hyd9Wy3IupaGzlizLQxsqYsW3OPqx1KK/ogSwi11aw1jsNrNePq+Nf+dGMOLyRd1/Ht3/7tvP/97+fAgQNceeWV3OUud7nQl1UoFAqFwgWj9BqFQuFiZqcLzLpAN4hzfEzMfCTnjBti3vYuoex1OjrZ+frJZjLTWqLs5l2UhAyrj+s5l2y3nkUXUcCkNhxbeI5sbvOLP/b9/PvH/g/rBw7xrFf9OvW+w1y71aGVzB8isNMGfMhkEj7Ic8mI85TVmkm9myJR22XyhYiLfEpMalkOqrpATJlmISkecVhiSSmzMbIcXhutFnVqYzjSdoQosfWLPu6mWoTEWmOHRRYRW1VGy4J5ynK9LjGuLFut9MiHpjW5zgSbRfBk5ZpPXAxqQ6QNicYarFHElJn1gdrIvGjeixvxOCRMZYbbx1P29oVCoVA491zSv30f/vCH84M/+IO8/vWvX211LFl+fr/73Y9nPvOZp7yP3/zN31zd/n73ux/WXtIvSaFw1tBKEcmy8Tyo/pubEQuxHMwsN6dvrvPU6XJTTlfjytCFJMWsk2J5c9HTh0RlNUdnnQinnGHhIzutx1rFdhdwS/epLJF9y82EkdM4q5j7yM4isG9U0XlpHpYCocrpVdG/NnK85IU/wR+99ddRSvH0l7yae3zF17DVBdlKqAxGa3z2pLRsfhQKsWJ1RmGVZu4DhyY1G2MncSVOIvBClAFbiCJSijFQWYvTiWljV8/j4KQ+I2HSiQ3V+kiEYTc13GsqjdMaZxQ+ZhL5lE3bmTz++RiqFQqFQuH8UWr7wq2B0z2MBhEX3dRW6YnLDIte6km/J1b6xBp+3oeVKGrWB7H/TyJir51mfeSYd4Gc1Sp6eeEjx+YepRVrw9asAqyRg+rduO4bxjss+t3FAjj3/QDcML4QoDKBhY9szv0qAkEOrSWqWhxd5TWzelfUZbQc9Acfzyjm8EIRQuC7v/u7ufLKK5lMJrz73e/mi7/4iy/0ZRUKhUKhcEEpvUahULhYkbSFYWnbR3a6wNyLsGieYVIP/VMU56KUpPeSWUamqQzrgzvusg871UzGGc3GWJOSZeGjpDPk3XP8RS+L1OPaMPOBnTYSfcdrnvtD/Ms//i3T9Q1e8obf5tAd78b2IjLzPV2Ux7JG01hN5wOV0YycGQRcUcRJtYG8m+yxjCA3WpapU9b0IbPd9mhEaFRZM/yZIGsmjSUnxea8JwyL8ZHE3EeUUtLrhkQfIgenMvtYLrHboQecVBajobKGRR8HMVWHVmrVQxutmNYOZxVWy8K6s3q1GLTTeWzSTCsti0aLAFoxcma1DOVTRsXMVuvpY2LsDM3g2pVyXvWRhUKhUDh/XPLV+2tf+1ruda978TM/8zP867/+6+rrTdPw2Mc+lpe//OVUVXXS7+37nte85jWAbIZ88zd/8/m45IuWI0eO8I//+I989KMf5ciRIwDs27ePu971rtzvfvdjY2PjAl9h4XxSWy1iKCu50F1ITHI+o0FGypl+KIyb1SbAuR0W3JTTlR2sWud9HOLcPJuDRe112x3bnccaTc+w2Q5UWa9clDYaR0aEUQCzNrLoIjEn4rBtf/VWSz0U/o0zVE6ztic67g2veRWve/UrAHjmC/8H3/ptD+fa7QW9z8w7sZi1VqFRLEKiMgqjZTBVW41CEVLiwKTm4LRiWosYqnaalOU5To3GGYn6s16K8kVg5Qq1f+xOO8JuyckaqtMd7vkoIrtaaSY3QxR1qscvFAqFwi2LUtsXbg3c1GG0Hmq+kbvpWLYTlxlmfaR2hjYOEXl7YqWB4+Kjl6IoWB78GhpnV3U7GULOHFqr2Vz04iI1fO9aLTXxTYmBLkQ/sOTE+MLKaJpexE1diHQ+rkRd2ihsVtxmvaaxGpBDca0UMcHWIhx336cTc3ghyDnzxCc+kbe//e1UVcUf/uEfcr/73e9CX1ahUCgUChcFpdcoFAoXGztdWImiREAjTkaN00CmMpppbQkpDa5ScTXvcFYzrSzzLpIzjCvLvI9YMwiBtD5lD6a1YlJbJvXu13xMgwhJ8+mjczqfmHUdr37eU/nH//UXjMYTfuYNv8Vd7/HFtD5iJ5qm0my1PcdmnkUXhpg8i1Kwb+TY6j0qZ3zIbC08+8cVh5sac5I+VyuF0RlrNDWyhDJOMOsimQQotrpAymCMW4nDUOLOvN3tpm5kZJZgdKJxmnkXqOzuUossu1us1hyZdex0gUltWWsMrU9sjCpizqQssfJkcWTuo7wPPmTMsECUUmbcWIxWVFai+0KUOL3RMK/RShbv+5RYbxyLPq5mK4VCoVA4f9wifus+8YlP5IlPfCKf/OQnueqqqxiPx9zznvc8ZSOz5OjRo7z0pS9dfX7FFVec60u9qMg589d//de8/e1v58orr+TDH/7wcdsye9Fac8UVV/CsZz2Lr/u6rzvPV1q4EIwGJ6DKaqyWwcCij2ckaFn0UpTboShUw/2eS07H6WpSSzxe6xPTWgrR1ie2Osnubr0UtyGLjeq4lgHRuNLIbjzsGztUhmu3O+YhMm+lMM4NpFnPZWs1yWimjV05RTVO8we/8xZ+6id+HIDnvfCneeTjv4/rd3o2xjV9AJ8i8y6x3QdI0qTYxtBoQ8rDa4o0M1oDWRFiYn3k9jyvOMSAyIZ/bTTWaPYNjgNGq5scsp3IjQ21bmq4N6ksPolt7XYbiEM2+sUusisUCoXChaHU9oVbCyc7jD5TTlxmaIdN1nySWGnYFff3Ma1EUePKrpymlvXVpLbiOtUvt31FDN+FhFaKzkTqYcPWjU5dk12IfmAvpx9f2JBSxsfdfthphTbqZsccnm9yzvzoj/4ob37zm9Fa8zu/8zt8wzd8w4W+rEKhUCgULipKr1EoFC4WfEzMOlnAWMa41U4DhtoZthde4t6G21itWWsU8y6w2QZSG9mxnmllmfWBw1MYVZaj857Nuae2MgegzatkixtbwJl30iu2fWTRR1JKvO6nns1f/s934aqKn3/zb/Ef7/PlbC48SkFKGTJMKkdlDPM+EEJGa+h8whkRZulGE3Kij7KIfnCaqNXxCzwpS/LFfFjeiRkmlQGTmfcZo6WX9CERTUYhs4XWR67d7ul84JrtbkivMJBhc+7xMdN6hdGaIE8PpcSZOeVMSGnlPJVyZn1UsbnwTBrDvIvHzcTGtcXFhI8Sr7fdeaqkwbBamtGDa5U14jS1Ma7IZEZOBFedT2zhWW8csy5QW31RuA4XCoXCrYULf3p3FrnLXe7CXe5yl9O+/eWXX85jHvOYc3hFFzePfvSjVxbAN0VKiXe96128613v4gd+4Ad4zWteg3PF6vGWjNaK2kr28cgZtruw2jhYCn1ujC5E5sNGuWQ4S8F5poKcM+V0na7WGodW8pyckZi3SaU5Nk8oPWwDOMv+SUVTGdYaEUcth0nLgU4Gji08MSRCBh9grVZURrO2RxQ1rgx/9u4/4kef9hQAnvy0Z/L4J/0IfUjUVnHdjichGyE+JCqtUFbRpcR8EG4pWGVxr48cY2fpQjwuUk4rJWKuSrYYjBZhW0wiFlNwzkRupxrupZS5bqcTp60+XjIiu0KhUChcWEptXyjcNCcuM6TBIWkVK83xh81+EJp3Q53eODkQzkidabVCKUVjNTFmnJZD2toanFGEJAL8thdhVB8SaagzT+RC9QMncibxhSEmUgKjwdzIAfXpxByeb172spfxileIK+0b3/hGHvawh13gKyoUCoVC4eKl9BqFQuFCs1eItIw63zd2dH5IoqgMV2+19CExqSwo6eNCzlRGMYuR6EErmW98brNFAwufcFYWozcXPQcntcStx7QSY53Yy6SUWfQSPX7NdsexWcebfvYF/MnvvxVtDC965Rv4ki+/P51PTGvLTudpM4DCKGhqy8gZfExURouwqwvM2p5rtj0qAGSu225X6RqVUVijV9flB9GRNZI4UVlDTpnaJvIghNpceMbOsPAiaJp1Xj4e4s67mBhXmi5k+hC5ftYRUmbfyHFoWnPdDhxeayTqbvie2moSmcYaUsqsNY6Y8klnYkv35c5H+uE9W2ss1TAD6sOuQ3Mz9MCNNaw1jspGthYSa9+aSONEfLUxvjj6yUKhULg1cIsSRhXOjJ2dneM+X19f5/73vz/3u9/9uPzyy6mqik996lO8613v4oMf/ODqdm94wxs4cuQIb3vb21AlyuoWzbgWYVRTGfo0KNoXgXGVGVXmpI4/KYvoZTkEqZ1eOTaN63MvZDkTp6vJMCTZbv0QlTEMg7CMpjB2lmkj1q/OKFLOjIfh0byPxJQIERqrObBWw05HF7IU0zmTknw8qgx/+ed/xpOe8FhSSjzy0Y/jB5/1PGZD8zOuHdMm0PaRxhhiJUOruQ/ECKrWjGtLPeSEmyEnPKXAxsgyqcUmNy+tXQdW0ShDFF/KUuCfb5HbpSqyKxQKhUKhULjYObHOUmopKM8opZAQAaELUi/GlAnD32tg7nfrdoDK6FWf11SanMX51A718FbriTnTONlkbn1kvKfWvtD9wMk40/jClPLnHXN4Pnn961/Pc5/7XAB+7ud+jsc97nEX+IoKhUKhUCgUCoXCqUgp0w0WRstF7HFlxOVJKbogsXYMiy7X7nToITrOaM24dtTW0AWJZAspc3TWYY1CK0WTNZU1XLfdS1+YZZml0jK3ODrvSVlmKY3THJn1zPuIVrJs/Zuv+zn+4DffBMD3P/fl3OXLHsDHrp5RWVm+0UZRO83G2EiyxfAYWwtPRpbSG6dRZOY+Me+kn1JKsdN6yNwgTs8oxbiSiLvaaSqjODb3rI0sW4tAH0WUFXPm00cXKAW9j/QpMW8jbRSBVNtJDKFPmd4nErC58FTW0MU8LJbL9dVW01SWUbCr9+PQtGLWBfaNq+NmYo1NtD6iBqcqkFlFNbhPtT6uRFG108ctzMOwWFPJXGnRizCqC5GU7EXVWxYKhcItmSKMKnDFFVfwhCc8gYc85CEntQ1+0YtexNvf/nYe97jHsb29DcDv/d7v8eY3v5nv+77vO9+XWziPOKOZ1JZZF1hvHFuIpeu8jyx8pDKyba0U5CxCnH5Q2oMUgMvc5kltz8s29ZmKcKyRInWtsbS9ROllEvtsxagyqGHrQSvZt89IAT+uDClrjIkc2YmQwadMjBL51lSGcW1ZHzn+9/96P4/7nkfivefBD3kY//2nfxaQCLw2RGZtZHvhyeShIFY4a2mcZe4Da7XlthsjjFbkDCHJiKuxEq+303mJBPTiHrWM1NsbPaeUbIVcKJHbpSiyKxQKhUKhULgU2FtnjSrDThuY+YhRCmd3a2A/iObbEElZYg+WoqjKGqqhVm+cXh3Ou+FgPkSJoAYGN9PI1TstB0Y1KSeMURdNP3BjnG584dmIOTxf/PZv/zZPetKTAHj+85/P05/+9At8RYVCoVAoFAqFQuHGWPhIRvqnkDJK7S4EWyOioOv7yKQyzHu/cv5VKKpaYr+t0rQhcnTeo1BYo4gxEQYxVZj37B85js16Zq0Ii3yIaC2L3GuNZXMh3xtSJsTE0XnH7/7KL/E7b3glAN/1Iz/Bf/76b2Nz4amdYatNLHykMZrL1hsqsxuJp5XCGU0fJcVjWjvaIIvllZbHNxqcMSgytZGZBUO0XWWXIisGgVaidgalFEYHYlbUVsRSbUz4IPMFVGbWB3q/jJWP+Civb86SoOGMRN85Iw7JWcnyi7NLAVNEa+mnndmdQeydiR2d9yyGVI92mMOMlfTf0gNLE1w7veqdx5XB7umBR5UkkoSU6UOistJ7n0myRqFQKBRuPuW3LfA3f/M3LBYLAL7ma77mAl/N+eMBD3gAP/7jP86Xf/mX3+RtH/7wh7O2tsaDH/zg1dde/OIXF2HUrYBpbYlDJMd642hNXMWhdUGK3BOxWq1ylUEKvul5LO7OVIQTkjyHPmaUholzHF6rVznV48qtIui6IS5kidaKtcaQsmHWeY7FQBsjCsn7/sD//lse/R0PZTGf81/+69fz31/2C2x3gUwgJRErbS48sz4yrgx9zDir2WmDNEFaMe8T1+50HJrWTCrD2mj32hYrq10RR837SG01XUg3iJ5bb0Q8dSFEbpeiyK5QKBQKlya31tq+cOtlb511YFzhYyJEOfjtQ4Qs27ytl63jWeuZ+8S4Mmgjm8STardu11qtDt4bY4bDZSnKprUjp8z1M0+OsuUcUkKr42uzC90P3Fp417vexfd+7/eSc+bJT34yL3zhCy/0JRUKhUKhcIum9BqFQuFs0O1ZWgFWrktLlFISR9d6rNaMnUR9ayUzitAHALYXgbmPEoueJZpurbZst4GkljOPxKJPVFaRssTxHVt4Pn0koZWisoqYE2TNH7/9t/itX3gxAA95/NO5/7d9N5vznnmfWKsNMcs5fTayMJORePbR0PcthVE5ZVIW8dNtNgyzxjPrIiEmqsHpuK4MtTE4q1DDSnrOmawUtbUoFYhJRGSNM/jgmftM5QxdlMVxa6DzGZJEw+eciQligpShspCSzBrWRxVKK7bbwPrIYY2i7SOV1uwbOxb97ixiXFkqq4+bic26QM6Z7T7gB1HTMg4RpAduBtcvEDeuEwVPWikqI7Obdoh570K6JBZyCoVC4ZbAJXEyeeDAAQDudre78Td/8zc3ettf//VfByQW7qEPfehp3f+jHvUoPvGJT6CUIoTweV3rpcTTnva0M7r9gx70IB70oAfxp3/6pwB88pOf5J//+Z/5oi/6onNwdYWLiY2Rw2jFrAs0TgYc/VC8pbQnWkIrGmuo7O5gZFLb8z4EOVMRTtsHttow2NOCs4qcMm1KNM4QklicLgVUx5EkjmTWB0Ch0SwWiX+9bge1dRXPfcJ3sLW5yZfc+8t5wavfyCxq+q4nI69bZTRGaTbGDpVhc95jNKs4EoUmM0SexETKhq2FxxmJ8LCNRAF2PuFMpLaGY4uenKWR2hs9tz5yZLhgIrdLUWRXKBQKhbNPqe0LhbPPss5KKbNWO5zRdCHSx8RW6xlFw07n5SA8SM1rh5p51ynKMK4s8z6sBPZuENgfXKtZeHHyrJ1hrZFD69rp1W0vpn7g1sBf/MVf8PCHP5wQAo961KP4+Z//+RJ1XygUCoVbPaXXKBQKFzspZXY6z6KPHJv39DGzNvRzlZW5xTI2bmfhAVgbOUbDnKILIjwKKaMNuCCRddXg9muNzBq0Umx3IqzqYyIkRetliXzmPSllGmehg6u2Wj72gf/Jb73ieQA88Du/j69/5PcjUX4inNruMzFlFl7jjMyKlu1HyplJtdvzZVjFkh8cV+yfVFyz1YoATCt2Wuk5M5kQZFG8sRLVLjF6mp0OZl0kp0zvpQ9NOa8cltYaxeZM0eqE1ZqFD5L6YSFnjbMaDfQh42NCk9EoFr2InOzIcXBSo7Wi94Mj1/B8lLrhTGx95Kitpg8JtPTPldEoLYkde52hxtUNRVFLlmKo5fJ9yvmktysUCoXC2eeSOJ08duwYAJubmzd528c+9rEopbjb3e522g0NsLI5LNw43/iN37gSRgF8/OMfL8KoWwnT2lIPKvhuULPvHXjsRTFkJtfmgjn7nIkIJyMKqWoYDmlguwtsjCpShtaH1fNyRuPMrqjKx4RHrFK3Fl5sYhvLtVd/jlc//bu57pqrueMX3pNn/dybuL5VhLwYNjH0aoMCBWNruW67Z9pIke1D4nObLTllfE5YZVj0C263kVkbOXJO9CExGiJTJHIuDM85sW/sjhMULaPnlgX9dutJWWx6U8q0IQ6/BxW11Yxqw9jZsz7UutREdoVCoVA4+5TavlA4NyzrrJ0ukIHL1xuODfVpJmO0xmSorUIpzXSPKGpUiSiqD1IzAzSDwL4aDq8nQz9wdJ5RSuGMYlrLY+6fHB/JfjH0A7dk/u7v/o5v/dZvpW1bvvVbv5Vf/dVfRevyOhcKhUKhUHqNQqFwseJjWs1WdlqJNw8xr87Efcz4GLl+p8fHhDOyqLJuHI0VUZTVYIc+bdYFppXFB48P0qNZq1hvHErBZ44u2Fp4aqfpY8YqxK3JgPaKSGZz3pNy5iN/8xf87st/lJwS9/7Gb+cbHvN0tDEYBaPaUFnFVuuJw6+/eZdIgJ9nLlsTsZBWEucO0MfIrBNh1LS2OCtip5gyTWW4++VraCXOxqeaCWwNojCUIiRxf1omSXQhYpRmZjUjo+hTwiaNNYq1xqGBNiSsVuybaFnwMZpDa9VqxqOVYuYDa7VjcxFonKZ2MntYunftnYmRZbloXMn1rTcOt2d2oZQswZ8Yn3ciS/HV8p+S8k9KoVAonD8umQnzmWw+lubk3DGdTo/7fDabXaArKVwInNFsjDUpWRY+rlT/q8JVDaIaJxEcF5rTFeGMaoNRNUZ7VCuiqDWj8TGyTM1rnLmBpS0sFf6RIzNIgNKweewob3j247n2s//O5Xe4E8985a/S6zFbix4QG1WFxmr5/u02MG87tFZYpQiDFeykNhwbGoB5ENGTNDyOUa2ZNo6qVRId6BM+Sna3HV77k0XP+ZiIQ8MVovyntWJcHf/PQYiZlohRMKndWR1qXWoiu0KhUCicfUptXyicG6a15fb7R3zm6AKlYJzSqjZsrEFrqVf7kAgps1YbGifCp3kfVqKoyundCIDh4B3kILi2hn1j+dwZhdFSI1+M/cAtkY9+9KM8+MEPZmtri6/5mq/hbW97G865C31ZhUKhUChcNJReo1AoXGzsdIFZt+syF1Ji3ge2u0CImZgz48rQWEMXEiEmjs4jWsG+ccW0tqSc6Xyij4mYEjGLGCqlTFNpJpW4+S76wLGF5+qtlhAzWy2Ma01dOQ5OJHq90pqrthZstp5PfPiDvP3lzyCFwD2/8kF8wxOeS0zS28Wch9g4xchatI44rVEqE0ICC0cXPYcmNa2PxJjY7ALeJ5pKIvaMlms8OK2YdREfEpsLT201+8ejk4qIcsor16adLhByZmotOYHRigOTmhATXTAcm3uMUmgkpq4Z0kJGFfiUyFEW4kOE3if2jSsaK+5TvU8sdJD4PzIHp5JpV++ZVSxnYl0Up6l5r8lBlt2NVmglM57GmRvMjk7G8p+dve5UhUKhUDg/XDLCqDOh2MefOz75yU8e9/ltbnObC3QlhQvJcmP8Usg+vikRTsqZRR9Z5MC898z7iFKZRZ/YXgQmjeXQpKJ25gb3nbK4Tx2b92it2D92fO66Y7zpeU/kqn/7GPsPXc7zfuE3ucMdbsfOwmO1wmow1lBpjdGKY/OelOW+cgKMwVopiPeNpVHZagOVUejl80iBvlXM+8ioMlw/A60k+zqmzL6xWxXve6Pn9jZg1mgaJwdA8y4OudwZrZSIwIweIlEUxqizLkq61ER2hUKhULhwlNq+UDgzxpXltvtGbLeecWW4ftbT9pE+JBadHK4brTAKjIGFj/iYVge0ldOs1W64r+PF6Sln+pjQSrExclRWnKdOFRNQOLv8+7//Ow984AO59tpruc997sMf/dEfMRqNLvRlFQqFQqFwyVJ6jUKhcK7ZXHhaLwsobR9Z+MhO6/GDICqkROvBKCUxd13AWXFS6lPChwS1nJePKsMISY/IGTYXPc5qYkxstwGrDX0MbC0CWgMRFCKg0kqhgHkvoqraGq76xEf4/Zf9CKFvudO9vopv/uEXY4wsYY9jxBk9uFpJ7J3VGqU0ISVxj1KJnUWiMYY+RI7MPHWlGTtxm7JGlsIbp0k504bE2Gk2Rg4fEzvDQvu4ssfNBFLKrI8c8076WAnny4TMyr2485lp45h1kelI0VQaayRCrxqET6FLtFGWhbKG1kdCSlijUGQysDnzOKvJaYiIRxbbT8Rqzbiy7J+IQK1xmrXmzBdU+iHJZDnzOB0xVaFQKBTODuX0snBG/P7v//7q46qquM997nMBr6ZQOD1OJsLpQ5QNhSiF6Liy3Gaj4ZN+jsUwHwZEdHIfa7WhqSwKKcNlyz4RooijjFYE3/PbL34qn/mXf2Syvo8Xvu63+II735lxZSCL+9H6SIrlLkiTs+gj48rQxyQNx0ScrVLO9EE2GGKEmQ8YJZF4OSG54EhTsFY7fM6EmLBKUVtDysdHz52sAQuDHZa1GnuCY1POUpTrwXEr5bxyoDqbXEoiu0KhUCgUCoVLhWWstFbiDNp62W69bqcn5yyOpX0k5X516Gu1oqnMyimqcfoGgqflAbzVEg19qkPjwtnn2muv5UEPehCf+tSnuMc97sGf/MmfsLGxcaEvq1AoFAqFQqFQKJyCnS6szuS3Wk/nZRZRGY3W4ky0MywyOysipJAyfRfoQ6Syhi5E5n04LvGhj7JkfGTWM+sDtdUopfAp0raR7TZitSzBKA3raIxRXDPr2GkDFsVnPvlx3vpTP0S/2OF297g33/jDL0NbQ+U0ISY2F4GJs6Ag5oRCxES1g7aXpRnvIZL5zNE51opgqsqgtB1i9zJGy9J1H2Umk1PCGek1940lkr12+rjZw5FZT2U1R+Y9SokoadZHaqslVjCKqCklEX2RM5PK0sVEF2SRxxmNRhFSJqOYVrvfBzKXaH1ipw+sKce0kb75wKQ+6aJ2bTU+JnH18vI4k5zPSNi0XDQCcXRe3m+hUCgUzg9FGFU4bd7xjnfwsY99bPX5FVdcwfr6+gW8okLhzFiKcDJBYuca+RXY+sjnNherxmPeeTJQWbMqeI/ME3UfaU4Y/ISYGFeG+aLnl1/0dP7lQ++nGU/4yV/8db74i78IHzNtL/nazughv1qGVY2VfOvWi1BJcsCloF8WyCGK+EkhMXjWiNPUvrpi7gN+2Bxx2hCSWOWGmDg4bY5zijpZA6aUFN7LTO2UM35oHkLKbHeBPiXWG8eij2ilVvdZKBQKhUKhULi4OVmsNMBm6xlnw7zNxJigMqzXDrfnQHZcmRuIouRAXmrKZbxebYu75/lga2uLb/qmb+IjH/kIX/AFX8Cf/umfcvjw4Qt9WYVCoVAoFAqFQuEU+JhW6Q17z+THlWH/2HFsLjOImGQmYbWcvXdBllr6kAkpMqksiz5SGb2Kncs5c2TeM+8jGkgxMwuBDHQ+YjREJLLPovA5cnQm8W9Kwcf+7ZP88nMex3zrKJff9Z487Nmvop6MqZ1mWrtV5N1CB6xSpEEUtXR1Wmss8z5hNPR9Yh4S00E6ZZXGKEVlFPvHFesjh1aKrYXHGw0amcH0ga3Wn3T2kHKmcYacxUmrdpq2i/Qk1hpFN8w6+pAlHSRA7WRZ3KfEwschnUJkUAZxRu59wmmZg/T97gwGJb1tHxPj+uSLPyNnmHWBykrSRkiSRHIm7sll0ahQKBQuLGXCXTgtrr/+ep7ylKesPtda8/znP/+sPsY111zDtddee0bfs1eoVSicDqd0TsoSTbdWW2atZzYU47qysnWgIMaMVyKEQktmtVLQdoHXv/jH+If//5W4quYnXvVmvug/3RefhgIeKXCnjV1t4KehcG6cZnvh8SGz1hjaPqGVPPa8i/iUJM5OKxrrmDYGBqtb1ykRPfUJVYmN7PrIYY1eWbLeWAM2qm6Ye904w2SIF5z3kc4ntpAGZdaFlZCqUCgUCoVCoXDxc2Ks9MbIkTKs1Y6daqgNh8NjmyVSeXSS+LxlbQiyzbsUWZ3q0Lhw9lgsFnzbt30bH/zgBzl8+DBXXnkld7zjHS/0ZRUKhUKhUCgUCoUbYd7tziCWZ/Lro935QGU1XUg0zrAzJEtYLY6/imE2EBNzH6hsxcJH1oY+bWvh2WkDZEmmUBoqbchklFZMnOHITNyCs9LsdJF+uIbto9fxKz/+/WxffzWH7nAXvvsnXsd4Yx8qS7hcZRSqsXQ+EBN0OVFZETtprVl0kY1RRVOBBFokVIY+RxprUUri1r9g/4jxENGesoiqlgkXMcsi+KlmD8s0C6eVzFaMYYEkgcSUVzHwKYsj1bgaZjCVgV7621kbmPcBHzNVo4hRhFKLPpKGSL5RZeRPJ69r48wpZx9aS1JHGyIjZ9juxIXZGrV6T2+MsmhUKBQKF54ijCrcJCEEvuu7vovPfe5zq6899alP5cu+7MvO6uO89rWv5YUvfOFZvc9CYS835py0b2yZ95aRs/QhYrUnDg5M1urVRkYXMiixbT3aBrYXPW/9xZfw/ve8A20MP/Fzv8SX3f9rMFoywbGy9QHH50V3IZKRjYfEroXrThuHXHAp4EFcnYxROC2b/lopNkaOfZOKY4uezid8zKSc2WoD+6c17RAFeFMN2MnQSpy1rFFsLQKdT7RG3LLmXWRjXIRRhUKhUCgUCpcKJ8ZKpyx18XpTMdMeHxJ7j2JjyqQsm6x9SPQxrQ6e90YcTGpbBPPnGO89j3zkI3nf+97H+vo6f/Inf8I97nGPC31ZhUKhUCgUCoVC4UZIKdMFOZdfDPOI8Z7YchBxTBcStTP0KdH7xHYbUAqMho2R5bpZz84isN44fEyElFh0getnHSAxdj6Ac1A7hUKTcqCLkdbLwvVaZYgJGqu5+rrr+Y2f/AGOfu5TrB+6LY/6iV9ivL4PrSRWPcSEj9BUmpwMUe+KiZxWTEaywD0PHrJi0UtUX8yJBsu+xrF/4viCA+Pjov9av+uUVDuDAia1YaeLJ509KAVkec0U4Jymtoq5z2y3Xu7L7Hax48rQR0nDqJ0mdok+ZhJAVsQIcx8wRolQyjE4dBn6IEKrkTPHXfPJGNcijGoqec86n9haBMZVPukSOpRFo0KhULiYKMKoi4CPfOQj5+y+L7vsMg4cOPB53cdTnvIUrrzyytXn973vfXnZy172+V7aJUFKmYUXJbpYb7KyC62tZuSKovtS4XSck3Y6sandN67RWmO1DIOOzHtizEPRaukDeGfofOSPf+N1XPm2XwHgh573cu7/9VdQWS2bCyu5k5ByPu56ANBglWbkWG0YzNqAGYZM48pAhrmPq4HV8k+tFJURS9kuynPzKdGFyKSq2GnD6nFO1YDdGLU1jKvMvI+Du5Vkmqdky899oVAoFAqFwiXGMlZ6UtuVi+pBKol17sVFtQsSq3wiVss27fIAd1SZErF8jkkp8fjHP553vvOdNE3DO9/5Tu5zn/tc6MsqFAqFQqFQKBQKN8HCy1J0HxIhiVvS0iVoiTOacWWGFAvHNp7eiyPSduvRSpFzpo2Jo/Ne3Ip8wkcRPJESTmsgslZX4jLlAylBzJmQREjVRxFd6dDytpc8hes+9S+MNw7y0Oe+DrN+kHmXWBtrrNZorVgmrDdWE8nECLmCro+0PqKVJubEyFoqY6grhUYWuddGlrXGHScw6oP0mwBNteuWNaosKXPy2YNSRDKVM4wqSx8jk8bho8fHTEyJ1ovjlFLQa4Uzmq7PzLxECo5rg/WK5MAocMZQG0VdadYax8hpKmvoQ2BcS9rHSXRNN3jPJrVl1olYbQuZM82HZJLKaInIU5RFo0KhULgIKSeZFwH3vOc9z9l9v/SlL+U5z3nOzf7+H//xH+eXfumXVp/f+c535o/+6I+o6/psXN5Fy9JpZ+nqcxx5UOIPQpvaGsb1qS02CxcHp+OcNKktISW2WxEQxZgAzaSyzH2kj5mYPRYRPv3Z7/8Gv//LPwfAo37k+Xztt34HXRBrWQAziIeW2d8+Zpbzo8FECqcU1mgM0PWBbCQeb2Ncraxjl9euhh8xtadCr6xmu/VYJGvbKEXXR5oNw+bCUztNiPmUDdhNMarMKm6wH57bwp9ZdnahUCgUCoVC4eJiY+QwWjHrAo0TwVMfEm2IpLRnIUQrGmtW9S3sxh8Uzh05Z572tKfxG7/xG1hr+b3f+z2+5mu+5kJfVqFQKBQKhUKhUDgNlssm7eAaVVt9UjehyRAr1/nEWu3oTKTtI1Zr+phWYie/1XFwWtFYg0b6uc25x5nMuDGEnEk+gYLex8GJKWKtou0jKXl+58VP5bMf/QfqyTr/z3New+jQ7WSpOkEIBqosjk7WYK1iEQPWaBqjWTeGq7Y6nDFoFMFndjrP+sjhtEarhFawPnKruUHKebWEA1A5vZrFLGcUp5o91FbjY6Kxho2R47qdKEKy2hBipkdmeDHLnC7kLCYGRjFWlhgBJc7IGdhoHChFbRT7RzVWKyqjUcNrOWnkmk/2Hp3ItLbEJM9tvXG0piwaFQqFwqVC+c1bOCUvfelLeclLXrL6/Pa3vz3vfe97ud3tbndOHu9JT3oSj3jEI87oez72sY/x0Ic+9Kxex04XVs5CwE0OCNoQaUMsA4KLmNOxrgXQCqa1Y9FHPrfpAZg2Bt2L3evCJzQKWyvef+Uf8tafl+jHb3r0U/iqb3s0Rkme9dbCgxrcnoDGSkHdh0Sq8rDtIY+pUDijmPdghti9ro9M60zVaNKw3QGsBlJ7RXh+KLY1UFnFdhdwVnPNdsfCB2mWhoJ+XJ/czvXGEFcqyTtvQ1xln09u2drIQqFQKBQKhVs809pSW71aCKmsPk4AtRcFZSHkPPLCF76QX/iFX0Apxa/92q/xLd/yLRf6kgqFQqFQKBQKhcJpskyOSMN29I31UOuNY6YC8z5SW5lZVEZzzaxjfWTph7lGHzNWJ/aNK0LMHMk908aCEtclHzNzH1l0HqXU0N8ZYvD84Sufw8c/9H5cM+I7nvsLHLzzf2Bz1uG1ZlzJsvjCB/aNK5SS3i9GmYWhoHaWgxNIZIxSZAXzNqOAI7MeZxSTkaMyBh8T263H73FKqpxmrRanpHG121Oeavawb+SYdYHKaia1YeEdOWesUmDAGkNIIjbbWQRyAo3CGMWk1litmPeBTKTWEhPY+cikcjSVoTaayzdqttpAztAMc6L6FP3wiZRFo0KhULg0Kb99Cyflla98Jc997nNXn19++eW8973v5a53ves5e8zLLruMyy677Jzd/+mwjJQAcRZaqtVvQBQVv9WKkTM0lWHWBVLOKyvMwsXD6VjXggiPfJSNhNpq+pCZ9YEQM+OhWDVK87EP/v/41Zc9m5wzD/7Ox/KwJ/wIRouL1FbnSVFC9NYbS8qyDdB7eezWR8aVXeVkKyWPu9n2VNrSyTqD5IqHRMqy1WCUFPTS1ChSlg2EzYVn3kUqo0gojILKaBZernuWIopMiBmtKxp35sOsZUOybOT2RgIWCoVCoVAoFC5dnNFsjDUp2RIhfpHw6le/mhe+UBYwfvEXf5FHPepRF/iKCoVCoVAoFAqFwpmwPD5f/nlTy8qT2opbUh/pQ2JUWw4r2FoElFL0PlI5w7yLGO3JwLSyoDIxyCzryLyHLMvf48owqgzzLvCHP/9CPvyX/xPrKh79/Ndwpy+9D7MucDQrYkg0Dplb9InUZJRRw/l/ZlRZRpUhp0w1rdheBNo+ykK4gmnj6EKiqQxWKXY6L73j8HztIEpaLqg3Tt8gieJkswc9OFe1ITKpLFsm0IXIxsSyvZDFHjKsNRaFRAc6q1aOTCEmyIoDE8fIWXxMTCrLbTaaQXym8VH6XqtFRKaAkTv9tI2yaFQoFAqXHkUYdRGQLzKRwWte8xqe8YxnrD4/dOgQ733ve7nHPe5xAa/q3LPThZUoaqv1q7g1UchLpJlWUhT6KC49IWW2u0CfEuuNOA1ppYri+yLjdK1rGyduTxJ5Z+iCRyF52mYoxv/pg+/n55/3JFKMfO23fDs/+pMvoQ2J7TZIvnUbiFnsWWMCo6Xo1Uqx0wYWgxWuVhABtLhHaaVQGiqlZftBq+FnMmGVYm2kCDFjLSz6hE+JRR/YnMs1jmpLiBmjNYs+DKKqjDaKevjZ9TFzbO4ZV+aMovCWL9WJDV2hUCgUCoVC4ZaB1opJbYsr6AXm137t13ja054GwE//9E/zQz/0Qxf2ggqFQqFQKBQKhcIZs3cpGk5v0dgZjRtp0rBc7Yyij4l5r5iOHCNnUArWGse8CwSV2ekCSkGMGXLGx8y+UcVkEAz9yRt/hg/92R+iteG7fuwV3O1e/4UQxelprbHMWk8ii/DKaGZ9ZK1x+JAwRmOUlsg5KwYBViu2FFirGTvNqLL4kLFG/t4NszFtFI0xuD1CoVPNJE41exjXIoxqKsPG2HLNViQlWUKvnWZz7gkxUTtF6yHETDIZY5Q4NVWKjETuAewb/X/s3XeYXWW5/vHvu+ouM5MChKpIU2nCAT2AigeVJIRQg3QQEJAOIihVBBFBEAtVQOlFeiAEQqKohyNF5XcUEThIF0JPmbL3Xv33x9p7ZyZ1JpnJTrk/18WVWTN7rf3MiGStee/3edxmQMuy8i5bMGcDve8MfDOQNhqJiCxflqv0RldXFzfffPOQvFZy11xzDSeccELzeOTIkfz2t79l0003bWFVQy9K0ub4vN6hqEayfu4QTcG1KWcZ1TChEiYEUUonUd72NIibQSpZNvS3da1lDEn9NYasedM8ot2n5Nn88x9/4+enHUkUBHz+y2M4/YJf4Ng2RZPvMKiGcT5uzxiMya/j2QbLGFwrDzz1BHFz1F6aZiT1zwGUfZuuakzJd3CMoRIm5L2nDHGaEYcxZWNDBj1h3pbVdfLrhnFSf6BxidKUjIwsy/Lz4vzByLUNbtGjEiakWUZ7P7ubNcf+mb5/ioiILAnd24uIzDFx4kQOP/xwAL797W/36eAsIiIiA6NnDRFpJcsYEvLORyT5OkOhn92ILMtQ8h1KzBk1l2QZ7b5LwbUpujZRkpFmeZjHNhmeazHceERpmo94qyX892+u5H8euBWAPU86n/W2/hKVMGmujZQLNpYFcQphkpJkGUGUd6xKsoyy7+C7+UKAbQxBnK+FFVyHjqJDdy0iTDJKvt0MPbUVnD5rDoa8I1TRW3CnpAWtPbh23l2qJ4gZWfYJk5RZPRGWMdTiFMe2COIEg8G28jW+mZUwD3IZg2UbSvWfeUfRZVjJyzeSm3zjOYDvWs3/XUp+/7tFze9/M200EhFZ9i1Xwaj333+fww47bJGvy7Ks36+VOa6//vo+O1KHDx/O1KlT2WKLLVpY1dJRCeaMz2uEojqKTjNBPj+WyW92HNvQWY0JopSanVCotzQdVlIwalnR39a1aZZh15P7WQauZWFZEMQJb7/+MmcedQCV7i4223pbvv+za/EL+cxtYyCOU8IkmxOCSue8V5QkdNXb3hrLIqnPmu4O8nF3lTCmGsZ4tkWcpcQx2JahXHCwTb7DIUvBdwxFJx+35zsWcZLSHaRkKbQVHEqeQ3vBJkys5gNTlOTj+IIoZVYlwliGdt+lFqVYJu5X56iw3nGrsathUa1/RURE+kP39iIiuccee4x9992XJEk47LDD+MlPfoLRPbeIiMhi07OGiLRSPqotpeDYBFE+faScZQP6vXqaZYRJSslzKHs2cZoRuhaObdHm22RZRsHzqYUJ3bWY2EmxMVTihP++90YevfUqAMYfdSaf3n48lSjFMuDYhraCQy1K8YoWnbWIhLzeJM14a0aFkW0ebb5LlkEljCk4NrWoESYC17EwlsWqRSdfc8ky0nqYyrYMlgHPzkNHi+qUtLC1hzbfIal30Fqjo4htDLMrESXXJrQMYZzSE+abzqthQpgkdCcZxrYoOjZRlNJRdLCAD7prFBy7GdzyXYuO+sdl31GjAxGRlcByFYyCRY+d6/3Lw/6OqNMvHOHWW2/lyCOPbP7MOjo6mDJlCltvvXWLKxt6aZrlM4mBan2UXqnX3ONF8R2bkpdRCROqYR6MCuKENHXUHnMZ0d/WtbUowbasekApo1xwcCzD9Lf+zZnf3I/ZMz5ivU9vzumX/hrj+CT1jk+VICarX9sxBs8xxFlGnKT0hPluA8+16anFzU5OQZjSU4vpCvJ52GkGH/WEuI5F2clncpd9G8fKb8jzf89skjQjquUzt2dVIwwZw9s8hpc8OgoOlrGABN/Nx/+FcUbRtXi/KyCIEmr1FrHtvkslzGdfL+ymv/EABlBwGm1l9ZAgIiKDQ/f2IrKy+8tf/sLuu+9OGIZMmDCBa6+9Vv8dExERGQR61hCRVim6Nj1BjOdYOFY+DaIaJv3apNxQDROyDJx6BykDDCvlE0tqsU1ajchScF2L4WWXapQwrOgy5d47ePDaHwOw82Hf4isTDqanlk+biNOMNM1IMTTmvRVch0oSk2EwxhDEKVEM3UFENUxoLzjEaUqYJEC+8bsWJQwvugwruxQdm9nViJJns1q7v1jhL1jw2sOwopt3wQpiVmsvUPIcZlciaklC2bOZ2RPSWYvBAzuCzIYUsG2D7+bdo2ZVIwqujY2hGiaMLLu01UNRRc+mbQD/u4iIyPJrufmvfX8fTvr7uiU9Z0Vy1113ceihh5Km+Q1IW1sbjzzyCNtss02LK1s6qlFCRp5Mj9MMY+bMFe6vomdTjZI8tR+neI5FNRrYja4Mnf62rm3sTjBWvqMBYwi7ZvCD4w7kw3ens9a6G3DyT66HQpmeMMa1DEXPIQOKroPnWGQZ9AQJtTjGsQ3ttkVXNR+vGKUpUZzmw/GsfHeGMeBYYEy+K8Oz8wcHz7UYUfKI0wzHMvhOvgukEifESUotSvEdC9+xWa3Nx63vwOiudz8r1GdiG1I8x6bdz0NeQZyP+gvsBN+xqYYJbnHBQafeD2CeY2HIH+xERESWhO7tRUTg+eefZ6eddqK7u5uvfvWr3H777TiOniFFRESWhJ41RKTVrPrv82txQtG16QpiKmGCY5t+bchvjK2DOWtVvmPj2Kb+u3qLWpiQZmCZjKJTJCPj0UkT+fVFZwAw7oBvssvBxxKlKUXPxs8suqoRYZxSSRM828KxDVYKBd+m7Lj4nsGzLDqKLnGa4ToGy+Sbr40x2MbCNoY232W91UrUopQsg3LBoVBfa1jc8NfC1h7afAffsagEecDLdywqYUKY5CP1bDukFiVQdEnSjLg+DtBkeRisrd51q73g4tgW1SjFmJhRHQWFokREViLLxX/xb7jhhlaXsMKaOHEiBx54IEmS32SVy2UefvhhPv/5z7e4sqUnqIdhavWuUb5jDXhUWGPWcxCn1OK8C08Qp5opvIzob+vatP67jTTN275We7r47pH789brrzBqzbU558pbaV9lNUpe3smp6NmUfJuCaxEl+ck9YUwUJ1SijM5KTDVMsDB0FF0cy1DwbIIwwbUshpc8Sp5DkmUkaUZXLca1LbI0Y2ZPhGdZfGyVUv45IIgSoiTDsS2IUnzHZmTZw7XzWuI070blWAbHtjAG2gsOUZJRqH89TvM54bUwD0aFcd59an7dzRb0AKZOaCIisiR0by8iAq+//jqjR49mxowZbLPNNkycOBHf1wOkiIjIktCzhogsK0p+HowqeDZhmhJEKZ3VmJKXUfTs+a5BpVneWarxO3nftZobvEu+jW1MsxOVbQxJmm+gdh2L5576b35y5gmkacq4vQ7k8G+fTRindAcxYRSRGWgrOHQHESl5GKnDd8F3sU3eZamt4FDyHNoLDq6xwIYwSugJElzLMLzksFpbgeHlfNRemkbYlqHdd/oV/krrY/HC+sbvzmpUX8NwqQQxw0veAtceXNtiWMkiTR2qUULRS5lZCahFhuEll57AUAkTLKBQcHBsC6/XWl+aQU8QU3Rt2osuvmMtcLKIiIismJaLYNQhhxzS6hJWSI888gj77rsvcZzP4C2VSkyePJntt9++xZUtXY2bn7SeilncWcKNMFTjOrqpWnb0t3VtY9dXlkFQq3LWsV/nX8//gxEjV+VH1/6GVdZaB8cY2osuBvrcqPcEEVlmKHs272UQxCE9YYSX5g855YKDb1u4Jp9vbRkwlsFg6KqFBFFKybWpRClJmubtYaOEWZWo+fBTixLS+rxu381v7H0nfzhyLIuuWgRAoR5i8myLkmczsxLhOzaRm5JmWT43PMsouDa+a1OLEkq9fhaLegATERFZErq3F5GV3bvvvsvo0aOZPn06m266KZMnT6atra3VZYmIiCz39KwhIssK17Yo+w49QUxHwaWTiCBKqYQJ1Sjv2OQ5+ebmLMunWYRJ3oEJ8t/Jd9THvZV9p7lu1exE5dmE1ZQgTvjH/3uaM44+hDiK2HGXPTj1B5dg2/nv8eM0o6sa8kF3SDVMCJIM205p81w6ig6ua2FhKLk2Zd8hSlOGF1ywDGGckqUZq7U7tBcdOgpeXo9nU3Bs2kc4dNXy9cWFhb+iJKUa5hu2kywPR1XDOY0KbMvQEyb4ToxlDCXfXuA6nWUZyr5DRkyb79Lmu3TWItr8/GeVkUGWr3EYDEmWEacpUZLhWhaOY4Eh7xwVJljGqGuUiMhKQv+1X4kdf/zxhGHYPLYsi8MPP3xA1zjxxBM58cQTB7u0papxo9n4c6Ddohoap819PWm9/rauNfWnkCSO+P5JR/D/nn6CtvYOrrj5btbcYKPmmETbyjuEuY6FZfJQ3CptHtUw4b3OWjOwlKZ5YKmtkI+ys4zBWPmYO6fXjf2awwoAfNhVY/rsGkA+tzvO6KxG2MZQ8Cwsy9BRcKnGCVGcNjtFGUMzFOW7VvN7Knn5+5Q8m0qYNB8OKmFCLUp4r7vGyKJPmqXY9Ta8/X0AExERERGRgZs1axZjx47l5ZdfZr311mPq1KmsssoqrS5LREREREQGWZvvkNS7JHUUXGp2HgiK04wgTpvTTHpzLEPRs5sblYue3Se40+hEVfTyP//2t+c4+9iDCWpVtv/KaC6+7FqM7VCL8t/zOxYMK3lgDDMrIUXXopbkUy7iNMVJDK5r01F0WKXNx7XzTdJd1QjXMhRdG8+xaC+4WAZGlDxWbfObG8YbnZgWFP6Kk5RqlJKREcUZPUFMLUkgzXAdG9c2dAURI4setm1RixNqcb6pfUGBpShJ6QnyQFZnLX9PyNdD+tONK4hSOonoKLj0BDG+Y2ndQ0RkJaBg1EqsMT6vobu7m+7u7gFdY8aMGYNZUksYA2Rzgk2L2+mpcVrjOouZr5Ih0p/WtZaBKE254PQTeeqPv8UvFLn0V7ez9oabANBRcmmvh4uGl9x5bpaLrk3JtekJ8t0PjmMxsuzRUXDoKHp9XmvMnI5OTnO3R4kkg/e7Agq2TcmziOIE2zakmcm7kRmI4hQyg+9YhHFGluU3/r5rNcNPva9b9h3SLKMWpbT5Llma8VFPRJZkBHFCnKZYpu/3sqgHMBERERERGZienh7Gjx/Ps88+yxprrMG0adNYa621Wl2WiIiIiIgMkWFFN++IFMQU3Pz37WGcUosT0jQjq69NWZah4OQhpIb5hYManagqQcz7/36N7x9zIJXuLjbdahvOvPRagtTCtbJ8g7cNPbU8DGQbQ8G1sTyHNT2bDHBtQxClZIBj5+saJc9gWxkFz6FtPmsEjU3UDQsLf33YExDWQ0thnBJECXGW4VgWvmvj2RZRklGwLKI0Y2ZPSNG1KXj5BJA0y+Z5P4BKkK9t1uohJ4COorPAEX6QN0Qo+w6ObeisxgRRSs1OKLg2lSBhWEnBKBGRFZ1WuWWlZxlDQpYn3JOMKEmbN3oDEdbT/Y2k/OJ2npKh0Z/WtUmacsHZ32Hqg/diOw7fvfiXbPSZzwLguVYzFFXy5t/KtRYl9fF4UPTzB4Y238kfOEzekarRYSr/XN9/Rxzb4hOrlsFAZyXGdwypa5EBlsnb3jp2/nFKBpkhyzIcy1Dw7OaNf7He9ra3fEdH3inLd23aCxlZfSRfluVBqIE8gImIiIiISP+FYchee+3FE088wfDhw5k6dSobbLBBq8sSEREREZEh1uY7+I5FJUgI4gTPsfr8/r03Qz4ub2Hj5Np8h1c/mM4399uD2TM/4pObfoZzLrsJHJ8gTqg3U8qvZ/LXO5ZhrRFFkjTvnFRw65MoqjFxllJ0LTIMbYV8w/VA1gjmF/6aVQkx5JvDO4OIOM6wbIsO12qur1jkkzJc2yKI03zsXxATpmk+OWM+o+7SNN/sDVCN8j9LvdZGFsV3bEpelq8L1X8OQZyQpk5zbU9ERFZMWuleib3++uutLmGZ4DtWHoZybIIob19azrIBBZvSLCNM8mBUoX4D5i/gxlZaZ1Gtay+/5EfcdfOvMcZw8vm/YKsvfoUkyehoc5s31gXXmid01BAmKbUooZYkeLbNyLJHe8FlZNnr979PljGsWvaxTT7/ut13cW1DyXN4t7NKHGfMSjPSFBw7f+joPZav5M0bimoo1x/AZlYyjDG4tqHNzx9aRpTn6mjFoh/ARERERERk0ZIk4eCDD+bRRx+lVCrx8MMPs/nmm7e6LBERERERWUpc22JYySJNHapRQhCnpFmvjlEmnxBRrG/ar0YJXbV4vq+Z/dEH7LX7eN57dzrrb/Qprrr5HpzyMOI0w5gM17JJ62tcxsrXrHqvIQwvukRJxkfdAY5tGF7w8R0b37HoKM7p0DSQNYLe4a/uICJKMtp8l64gytfMHJrdp2zLzDNNo9zPUXfVKCEjb1SQf7/5dQei6NlUo3xdKIxTPMeiGiULXFcREZEVg/4rLyu9opu35fQcC8cyxPXE/EBugqph0uy64zlW3jFoMbpOydBbUOvaq6/4Bdf+4hIATvn+RYzfcy+SBBzbkPeAWnjoCKAWpVTDfD627+YPC55tDbh7mOdYlDwHQ97yNknzPzsK+QMLFoRRiu9aOLY137F8C+LYFr5jM7yUH7u2wbbyGud+ANMOCRERERGRJZNlGcceeyx33XUXruty//33s91227W6LBERERERaQHLyke6lf15vxYlKV21mCDOwz99ZJCQ8cGHH7Hn+DG8/PLLrLvuJ7jz/ocYturqfNQTQJSSZWDbhrLr9FmXaKwhFNx8fF2YJAwv5ZulfdcizfJwk22ZxV4jaIa/6o0EOisRSZJPa+ko5JM1FjRNo7+j7oL65JZavWuU7wx8/cUyeTArqI809Jz84/n9byIiIisOBaNkpWdZBt+xqcUJRdemK8jHjTm26Vf7zSDOU+wwJ5nuOwqVLMvmbl17729u5cLvnwnAaWefy0FHHAVAdxARRilBnNDm2wvceZDWdzN0ViMAXCefj21hKA1wtwLkDykAtjVnh0ab7xDFKV1BTMl1SJKINIOil4eo+nvz33gosYxhWNHFcyzafEe7IUREREREhsCZZ57Jtddei2VZ3H777YwZM6bVJYmIiIiIyDKmO4jp6TUDL6yHdtJ0TseoarWHw/fZgxf++RyjVl+D39z/EB/72DoAtBUcPugK6KrFhHFKmKR4toXvWPhuvlk6TjI6azFZPXVV9G06Cvn6w8JG5Q1EmmZESUrJcwiiFLu+obu/6w+LGnWX1otP0/zPxZ120QhDNa7TuK6IiKy4tBIuApT8PBhV8GzCNM1bdVZjSl5G0Zs3vQ5zwjCNUJTv5kn3xvVk2dbYvXDvvZM45YRjADjuxJP59ndOoxol1KKE1dsLRElKmGSEScaMnhDPzud/GwNZRvMho/Fwkrd1NURJRsGzFtnBaX4a9+BzAlL5bomia/Nhd0BG/j5xmmEwA9oRoe5mIiIiIiJLx8UXX8xFF10EwLXXXsvXvva1FlckIiIiIiLLmtnViFqUrzPVwqQ55q23oFbjuEP35//99c8MGz6cm++ayHobbADknaZc22L1jgLDinmgqPf5cQJxkjSPHcs0x9pBvuF/MEJRMPSj7hprJ40/B9otqqFx2tzXExGRFZeCUSLkIZmy79ATxHQUXDqJCKI0T6VHyULDMJCHonon6xc3pS5L1+9+9zsOOGB/0jTl8MMP5/KfX4qp3xH3eRiJ5jxMBHHabNfam2MZ2gv5mL6uIKJgWYv970FYv36j61jj5l7dzURERERElg/XXXcdp512GgCXXHIJhx9+eIsrEhERERGRVknTjGqU5F2Ksl5doMKEOE0puDbdQT5CDnpvwrZIk4RTvnkET//PHymV27j6lntZe4NP01mL6Ci4fdYhCm4eeJpfxynLMhScfJxdw2B1imoY6lF3xgDZnGDT4nZ6mntz+mLmq0REZDmiYJRIXZvvkKQZtSiho+BSs/sXhhmqZL0Mraeffprdd9+dMAzZa6+9uOaaa5qhKIBhxTzk1BPE/X6YqAQxPWHCyKJHVP/3ppxlA7rxb4y6Ayg4jfDSnAcVdTcTEREREVm23XXXXRx1VD6e+4wzzuDUU09tcUUiIiIiIrIwCwouWcbgOxZFd/E2GEdJSiVICOK8k1Kfr8Ups6sRAO911iAzFFyLjqLb/F1/mqacdMKxTH34IXzf56Y77marbf6TSpjkawNEzU377QWHKM4I6mGi3gGo3gz1kXW+Peib/Id61J1lDAlZ/r9Fko/tKyzGRIwFbU4XEZEVlxIcIr0sThimYbCT9TJ0nnvuOXbeeWd6enoYPXo0t912G7Y9781zm+/gO1bzwWVRDxPDSx6+E2PbFjN7QuI0DyT1d342LHrUnbqbiYiIiIgsux599FEOOuggsizj6KOP5oILLmh1SSIiIiIisgALCy6RQUIevukJ4gGHibqDmJ4gbh7PvdbUHcTEaQrZnE5LnjMnqJNlGd87/VTuviNfv7j2xlvZ/r92AMCxDZ3VvMNUzU4ouDZRnDGs5JKmzpCEvPpjqEfd+Y6Vh6EcmyBKh2RzuoiIrJiU4hCZy0DDMEOVrJeh8dprrzFmzBhmzJjBtttuy3333Yfv+wt8vWtbDCtZ/X6YsIwZ8lF36m4mIiIiIrLseeKJJ5gwYQJRFLHffvtxxRVX9OlKKyIiIiIiy45FBZfm3iRfixNqcdKvTfKzqxG1KP9df62+qTlO50Sv0jSjEsRkQFc1AmMYVnTwHJtKffP0lZf+iF9fczXGGC775XWM3XmX5vm+Y1PysnzDdJgHo4I4IU0dLMtQ9h3KC172GDJDPequ6Nr0BDGeY+FYZkg2p4uIyIpJq+Ii8zHQMIwsH9555x123HFH3nnnHTbbbDMmT55MW1tbv87t78PE0hp1p+5mIiIiIiLLjr///e/svPPOVCoVxo0bx0033TTfrrQiIiIiMjT++c9/8uyzzzJ9+nRs22bttdfms5/9LOutt16rS5Nl0KKCS01JRhCl+cZj16bg5cGcNMuakxnm1h3EzWt31vKJD5D/vt53LFzbohYmlAsO1SAhyTIgI04zuoOINt/ll1f8nJ9dfCEAP7rkZ+y1z/7zvE/Rs5t1h3GK51hUo4GFhAbbUI+6s6x8E/pQb04XEZEVj1bGRRailcl6GVwzZ85k7NixvPrqq6y//vpMnTqVkSNHDvr7LM1Rd+puJiIiIiLSei+//DJjx45l9uzZfOELX+Cee+7B87xWlyUiIiIyaA499FBuuummAZ+36aab8txzzw1BRXPcc889nH/++Tz77LPz/frnP/95LrjgAnbYYYchrUOWH/0JLlnGkGZ5sCeIU+I0oyuICdOUjoJLNUywjJlnA3Jj7N7c1y55dp+N07UowXdswiSlo5ivB1jGEEQpD955PT85/3sAnP69cznsyKPm+31YxuBYhs5qRBAnlDyHzmrEiLLXss39S2PU3dLanC4iIisWBaNEZIXX09PD+PHj+cc//sGaa67JtGnTWHPNNYfs/ZbmqDt1NxMRERERaZ23336b0aNH895777HFFlvw0EMPUSqVWl2WiIiIyAovSRKOOOIIbrzxxoW+7oknnuCrX/0qZ511Fj/4wQ+WTnGyzOpvcKmh4NqUe4Vqgiilk4iOgktPEDeDVA2VYE4Xqsa1O4rOPN2MGs2psjQPDbUVHAyGB++/h4vOOgWAw445icOOPXmB30c1TOipd0zybAvfyS+apBkJWfN7XZobppfGqLuluTldRERWHApGicgKLQgCJkyYwJNPPsmIESOYOnUq66+//pC/79IedafuZiIiIiIiS9dHH33EmDFjeP3119loo4149NFHGT58eKvLEhERERlShUKBtddeu1+v/fjHPz5kdZx88sl9QlGlUokDDzyQLbfckjAMefrpp7n33nuJoog0TTn//PMZMWIEJ588/6CJrBz6G1zqzTL5794d29BZjQmilJqdUHBtKkHCsFL+u/00zQji/PrVekeqkmfP99qNkE7jTwvDU//9Oy747nFkWcZu+x7MyWeeS5RmpHN1XGqEoXKGOMmoxREZGQaDNde6Qy1OqMXJYq07DNTSGnW3NDeni4jIikH/xReRQZGm2TLXsShJEg466CCmTp1KuVzm4YcfZrPNNltq769RdyIiIiIiK6auri7GjRvH888/z9prr820adNYffXVW12WiIiIyJDbZptt+MMf/tDSGiZPnszll1/ePN5kk02YMmUKH/vYx/q87u9//zs777wz06dPB+DUU09lxx13ZPPNN1+q9cqyYSDBpfnxHZuSl+WdicI8GBXECWnqYFmGapSQkXcoitMMY+aEe+ZmDFBfQwF45s9P8O1vfp04ivjK+D056Zwfk6QZxhhqUT4mD/p2uQqihM5qRFcQ4VoWkZNhWxAlGSQZQZTmYSDXpuDlnZzSLGt2SxoqS2vU3dLenC4iIss3/VdfRJZIlKTN4E829xczWtayNcsyjj76aO655x48z2PixIlsu+22Q/6+c9OoOxERERGRFUutVmOPPfbgL3/5C6ussgrTpk1j3XXXbXVZIiIiIiuFNE0544wzmselUolJkybNE4oC2GKLLbj77rvZfvvtSdOUNE0588wzmTRp0tIsWZYRAwkuLUjRs6lGeWeiME7xHItqlHdjanQpqtXDV75jzTcEBGAZSABjGV569u+c/I39qdWqfOmrYznvJ1eRmLzTU5ttEcYpJS/vFNUIRXUFEWGUUo2S5vfRVnDwbIv2gkOU5F2T4jSjK4gJ05SOgks1TPLRfUMYClqao+60OV1ERPpLwSgRWWzdQdycxw0sMo2/NFu2nn766fzqV7/CsizuuOMOdtxxxyF9v0XRqDsRERERkeVfHMfsv//+PPbYY7S1tTFlyhQ23njjVpclIiIistL43e9+xz/+8Y/m8Yknnsj666+/wNd//vOfZ++99+bOO+8E4KGHHuLll19mww03HPJaZckN5qSKgQSXFsQyBs+2COprIZ6Tf1z2865HjZqBhYZvPNsiShKmv/Yy3zliP3q6u9h6m89z6S9vxLge3bWYrD4NLs3qG9Tr3ZQaoag0y7AtQ9FzGVHycGyLsm83uyeVe3VhCqKUTiI6Cm59E7s1pOGgpTnqTpvTRUSkPxSJFZHFMrsaNUNRtTBhZk/I7Gqe/I+SjDjNiOrtWmdXI2b2hNTqN+49QUxnLRqy2i666CIuvvhiAK677jomTJgwZO8lIiIiIiIrhzRNOfLII5k4cSK+7zNp0iQ++9nPtrosERERkZXK/fff3+f4iCOOWOQ5Rx55ZJ/jiRMnDmZJMgSiJGV2JeLD7oDuICZKUpI0I80ykjSfUtEdxHzYHTC7EhEl8wZt5jaQ4NLCNDoSNa7TuG6j41Hjz4WFrgquzfR/v8GxB+3F7Jkf8clNt+Dia2+jUCxiMHNdNw84QT4+L6x3jfLsfNycZ1s4dt6BqREqarx/2XfoKDr1c1Nq9RGClSBZrO99IIYVXcr1YFPBtRlR9hhWdPFdC9c2OJbBtQ2+azGs6DKi7DXrL/vOgEf+NTanjyx7rNrms1q7z6ptPiPLHmXfUShKRGQlp45RIjJg3UHcvIHuPdPaGJo7DSxjSLNsqbdsveaaa5qtlC+99FK+8Y1vDOr15zaYO1ZERERERGTZlGUZp5xyCjfeeCO2bXPXXXexww47tLosERERkZXO5MmTmx9vsMEGbLDBBos8Z/vtt6dQKFCr1YC8a9Spp546ZDXKkhmqSRUDCS4tTOO0ua9nDJDN+Xoj2DQ/H7z/Lkfuvwfvvzud9Tb8JBf/6g5sv0QY5+P+etfXGDcHNNdlbMsQ14NZhfo4QM+efwcs37EpeVk+yi5MKLg2QZyQpkMfFtKoOxERWVYoGCUiAxIlafOhpHcoquTZFD17nhvvpdmy9c477+SYY44B4KyzzuLb3/72oFx3fqIkbd7Mz/N4k0FC1vxZ6WZeRERERGT59sMf/pCf//znANxwww3sttturS1IREREZCU0a9Ys3nzzzebxtttu26/zPM9j66235k9/+hMAzz777JDUJ0tudjVqhn9qYUI1SpoBoD7q0yocy1B0bQqeTU8Qk2bZAjsNDSS4tDB9glC9/rSMISHLw0ZJvj7Qu4NTw8wZM9h3z1158/XXWPtjH+e6OyZSGrkaYZTSVYtJsgwDmPpyQhSnOI5FFKeESf5PIwTluxa+k79HyZv3vRqKnt38WYZxiudYVKOk2dFpKGnUnYiILAsUjBKRAWm0WK3VQ04AHUWnefM9P42WrY5t6KzGectWO9+ZUAkShpWWPDA0ZcoUDjroILIs45hjjuH8889f4msuyFDtWBERERERkWXPFVdcwTnnnAPAL37xCw4++OAWVyQiIiLSOq+99hpf+9rXeOaZZ3jvvfcwxjBy5Eg22GADvvSlL7HPPvuw2WabDcl7v/DCC32ON9xww36fu8EGGzSDUTNnzuTdd99ljTXWGNT6ZMkM9aSK/gaXFqXRvakR4mlsFvcdK7+mYxNEeX3lLOuzmbynu5sD996DF5//J6uvsQa33DOJ1dZcC4AuImphQlc1AgOOZQjshCTJSMiYUQmp1GJcx8Jy8lBUm5+HwEqejbOQjdmWMXi2RVBfy/Cc/OOyP+Bvf7E1Rt0tzfcUERFp0Aq9iPRbmmYEcf5gUq0/oJQ8e6GhqN6GqmXrn/70JyZMmEAcx+y///5cccUVmMVsg7soQ7ljRUREREREli233XYbJ5xwAgDnnnsuJ554YosrEhEREWmtN998s0/XJoBKpcJbb73FH//4R374wx+yyy67cPXVV7P22msP6nu/+uqrfY4//vGP9/vcuV/76quvKhi1DFkakyr6E1xalDTLCJO8tkJ9XcSvj4YruvkagOdYOPVRd9VwTlemWq3GoQfsw//7618YMWIkv7n/ITb+9Ceb32+775IkGbYxYAxpBj1BAmRkEYRhPr2i4Nq0FeZsVi+6dr86PzXCUGl9PWNxO2aJiIgsjxSMEpF+q0b5jXdY34lhTN6CdUHSNKMWJYRJSprlLWYzMjprEW6vwNCStGz929/+xvjx46lWq+y8887cdNNNWNbQjKwb6h0rIiIiIoNt5syZPP7447z99tvMnj2bNddckw033JDttttuyO6Z5ufNN9/kueee47XXXmP27Nn4vs+IESPYdNNN+Y//+A88z1tqtYj016RJkzjkkEMAOPHEE5tdo0RERERWdo7jsMoqq+D7PjNmzKC7u7v5tSzLmDRpEk8++SQPPvgg22233aC9b2dnZ5/jkSNH9vvcESNG9Dnu6uoalJpkcCyNSRWLCi71RzVMyLK8m5PnWJj6dSHviOQ7NrU4oejadAUxlTDBsQ02GUd/42Ae/+PvKbe1cdu9E9l4k03z77Pg0mNiZlUikjSjvejiOxaZAdcyRHEeYHIdm4JlGFH0cOthrJLXv1AUzBn518hDKRclIiIrE63Mi0i/BfUWsbV61yjfsea7myJKUqphQhinzO/e2sJQCRPe7awyst43dXGCUf/6178YO3Yss2fPZvvtt+fuu+/GdYemG9PS2LEiIiIiMlhef/11Tj31VCZNmkQYhvN8fa211uLYY4/ltNNOw3EG/7EwCAKmTJnCxIkT+d3vfse///3vBb62VCpx4IEH8p3vfIeNNtpo0GsRWRx//OMf2WeffUiShK9//ev87Gc/G7KutCIiIiLLg6222op9992XMWPGsMkmm/TZ3PDyyy9z77338tOf/pT3338fgA8//JDddtuNp556ig022GBQaugdwAIoFAr9PrdYLC70Wovj/fff54MPPhjQOS+//PISv++KZmlNqugdXPJti65aQGc1pOy7uLaFMWAZ8GyLgmvPM+UiiPPf9adpBpZhViWsn2fq5xosk38/Bc8mTFOCKGVWT8j3TzmOKZMfwvd9brrjHrba+nNzvv96QskyeVcny0C5PiJvRMmlsxaTpBkZGVGS/+k71iLH582tEYRqPNbo8UZERFYmCkaJSL81btAbrVbnF+zpqe+CaIjilFqSkKUZWZbfbEdpRpxkpHYetprRE1L2nQF1UXrrrbcYPXo077//PltuuSWTJk2iVCot4Xe4YEtjx4qIiIjIYJg4cSKHHHLIPLupe5s+fTpnn302DzzwAA899BCjRo0a1Bo22GAD3n777X69tlKpcN1113Hrrbfy05/+lKOPPnpQaxEZqGeeeYZdd92VWq3Gbrvtxq9//eul2mFNREREZH5efPHFIbv2qFGjFtp96ZJLLmG11VZb4Nc33HBDTjvtNA477DD22GMPnnzySSAPR5144olMnjx5UOqs1Wp9jgfSedb3/T7H1Wp1ieu56qqrOO+885b4Oiu7gU6qmJ9ifTJFnGaEcYrnWPOdVOE6hve7IsI4JcnyoNGsSkjRs/MwlDFESR6A8hyLomdjW4ZqmNBZjahGCZYBy8qDS22+la+bZJDUt4nX6nUUPZssyzj39NOYePcd2LbNL667mc9u90WCOO88FcYpYZLmXahsi1ULDm2eQy1KcGwL37Vx6ustnmvj2tBWcOgoDnyDeFjf+N4IfA1khKCIiMjyTsEoEem3uVuszn3j3LuTUhAlzQeAuYVxSk8YE8RzHi56gpg0y+goLPqG/sMPP2TMmDG88cYbfPKTn+TRRx9l2LBhS/bNLcTS2rEiIiIisqSeeOIJ9ttvP4IgaH5uhx12YKeddmLEiBG88sor3HLLLbzzzjsA/OUvf2H33Xfn97///YB2Wy/K3Luv1157bbbffns+85nPsNpqqxFFEf/3f//Hfffd1+wmVa1WOeaYY4iiiBNOOGHQahEZiBdffJGddtqJrq4uvvzlL3PnnXcOSVc1ERERkYHaeOONh+zaF154IaeffvoCv76wUFRvo0aNYtKkSWyxxRbNjRIPP/wwzzzzDFtvvfUS1zn3M8v8uuMuSO9nJJi3g5S0Tn8nVSyMZQyebRHEKbX6ukMQp5R75eG6g5ieIMa2DBng2zY9QUItjOmqRhgrDx+1ew5evbPUR90htgUZ+Rg937Uo+y5RnGLZ+TUbG8Ity1BwbEq+Q1ctYlYl4pc//RF33Hgdxhgu+Pkv+cJXxtJVi+ep37FMM5wFsEq731wrKbo23UFMm+8wuxoRJRlplg3oZ5RmGWGS/5wL9XUN39HmDxERWXnot3si0m/GANmcFqtpryHUPUHcDEV1BRFh/WNTb//q2hYWhpQs7yoV5QGr7iAmIWMVfKphgmXMQjtHdXZ2Mm7cOF544QXWWWcdpk2bNugdDua2NHesiIiIiCyuWq3WJxTleR433ngj+++/f5/XnXfeeRx00EHce++9ADz11FOcc845XHzxxYNaj+/7HHTQQRx22GF84QtfmO9rLrnkEi644II+u6xPOeUURo8ezac//elBrUdkUd58801Gjx7Nhx9+yGc/+1keeOCBQQ0MioiIiKwMVlllFc466yyOPfbY5ucmTZo0KMGotra2Psdzd5BamLk7RM19LWmd/kyq6I9GGKpxnd7rF7OrEbX6pmfbGGpRQk8Q41gGz7UJopQoSYmSmJ5ajGMMvmvjORY9Yf66Vdp8yGB2JcSxLcqOQ5T02hieZARRmoecXJtfX3cZV/40f86+8Cc/54ADDqAW56P45g5Teb1CSnNP1yi6+cZyz7FwLEOcZlTDga0tVMO8Q5VjGTzHwtSvKyIisrLQiryI9JtlDAlZ3uUoyYiSlIJrEyVpc3xe71BU7/azvUVx385QUZzRWYvoKLj0BDF+PUg1t1qtxp+GUxsAAQAASURBVO67785f//pXVl11VaZNm8bHP/7xIfyOc0trx4qIiIjIkrjiiiua3ZcAfvCDH8wTioJ8l/Xtt9/OZz/7Wf7xj38AcPnll3PSSSex9tprD0otRx11FCeccALrrLPOQl/nui7nnnsuYRhy4YUXAhBFERdffDHXX3/9oNQi0h/vv/8+o0eP5q233mLjjTfmkUceob29vdVliYiIiCyX9txzzz7BqMZovSXV0dHR53jmzJn9PnfWrFl9jgfjXu/YY49l7733HtA5L7/8MnvssccSv/eKZFGTKvqrcdrc1+sO4mYoqjH1ouDaZGQkaUZbwcHCECQJlSDJN0rXx9wFSULRdXAsw+xqhG3yzk5l32muY1jGkGb5eklQ31x9w/W/5qLzzgbglLPOZZ+vH47nWH0CUA1pllENY8BQcC2qYT6NwzIG37Eouvn0ilqcUHRtuoKYSpjg2KZfUy2COGmu3zQ2fPuOrWkWIiKyUlEwSkT6zXesPAzl5DsogjilnOW7EyAfn9cIRbUX8nazc2u0bLWMYVjRJc0ykhSCKKVm52PmKkHCsFLfB4Q4jtl33335wx/+QHt7O1OmTFlqXQSWxo4VERERkSWRZRk///nPm8frrLMOp5xyygJf73keF198MePGjQPyAPovf/lLzj///EGp58c//vGAXn/OOedw1VVXMXv2bAAeeuihQalDpD9mz57N2LFjeemll1h33XWZOnUqq666aqvLEhEREekjW45+l7jGGmswbNiw5v39+++/PyjXXW+99focv/nmm/0+94033uhzvP766y9xPaNGjRryaQYrg4VNqhiIxmmN6xgDUZLSE+Sj6xqhKICSZ7NKm0eaZlTChDBJcR2LNj9fs6hFCd21mM5aRM0kWAayFEa1+4xs8yl6824IL7g25Szj7rvu4genfwuAI48/me989zTSLMN3LOIkoxLGBHHeoaoWJWCg6DoUHIssq3//GSRkzfotyxAnKQXPJkxTgiilsxpT8rL51tL4OVbDOaEo37Wao/pKvrpFiYjIykUDZEWk34qujYFmy9Ysg55aTNjoqBTN2XUwv1BU4zVZluFYBse28F2bEeW8e1QzYFVvJ9uQpimHH344Dz74IL7vD1rr5f4a6h0rIiIiIkvqL3/5C2+//Xbz+LDDDsNxFr4PZsyYMX26b95///1DVt+iFAqFPuP2PvjgA7q6ulpWj6w8KpUKu+66K3/7298YNWoU06ZNW2SnMxERERFZtGKx2Py4UqkMyjU32WSTPscvv/xyv8995ZVXmh+PGDGCNdZYY1BqkiXX+H17o4NRlKSLdZ3GOkXjOpYxVIJ8zaEWJs1QVEfRoew7WCZfo+gouowse5R9G9c2uLZFm+/guwbHMiRJhmUMZd+h6M05d34em/Yopxx7BFmWsfdBh3HCaedQixKSNKOrGucBKdfGtgxpBp5j49k2QZTwXleN1z/s5s2PKnzQFdBZiwjjlAxI0owgzkNSHQUX382XdythwoyekM76qMAgzrtNdVYjZvSEfUJRjSkeZd9Z7M3fIiIiyyv9zSci/WZZc1qzNuZPz6yE+e6GeotYY2juOphbGKfN8FOh3rLVsy3KvoMxEKdZ80a/Wg9ZZVnGySefzM0334xt29x9993813/91xB/p3313mECg7tjRURERGQwTJ48uc/xmDFjFnmOZVl89atfbR7/85//5PXXXx/s0vqtra2tz3FPT0+LKpGVRRRF7L333jz++OMMGzaMRx99lI022qjVZYmIiIgs95Ik4aOPPmoeD1Y3zuHDh/fZ3NHfEX1hGPLMM880jzfffPNBqUcGh18fL1eorz0EcTrg38E3JlX0vo5rGYI4X2dorDeUPHu+4+csYyh5DsNLHiPLHiPKHsNLPqM6CljGEEVpcwxd703dvT35p//hiIP3J45j9vzaPlxwyc8wxvBRd8isSkRnEJFkGR91B7zXVWNWJeDND3t48Z3ZvPheJ2/PqvJhd8j7nVXenlXho+6A2dWImT0htTCh7DskWUZ3LQ9HtRec5gb2IE7pqsV0VmO6anlHqiwDxzK0F5xmKKro2bT5GiYkIiIrHwWjRFYgaZrRE8TM6An5sDvgg66AD7sDZvSE9ATxAm/YB6LRYrXg2fhuPlqvqxYxsxqSZhmeY82zWyLN8vawXbUIyHcnNB4+SvU2r159h0ItbnSNyh9ifvCDH3DZZZcBcOONN7Lrrrsu8fcwUEO5Y0VERERkMPz9739vfuw4Dp/97Gf7dd7nP//5PsfPPvvsoNY1EK+99lrzY8uyWG211VpWi6z40jTlkEMO4eGHH6ZYLDJ58mS23HLLVpclIiIiskJ4+umniaKoeTz3CLwlsfPOOzc/fuWVV3j11VcXec7jjz9OrVZrHu+yyy6DVo8suflNqmhssO6vapg0g0CeY9H4zXtG/nv5xqbuRrhpUfLJF/n1kiwlyTJsY8iYMzmjt7//7//j4H0nUKvV2HHsOC775a9oK3p0BxFdtYg4SamFCa+938O7s2vM7I7494wqH/QE9NS7WQVRvgHdGIOFYWZPyPudNWpRQleQj/XrKLgYAz1BTMG1GVH2GFbMO0i5dt7hyrUNvmsxrOgyouw1N7KX/TkBKRERkZWNglEiK4AoSZldifiwO6A7iImSlCTNSLOMJM3nUHcHMR92B8yuRIsd7AFw6x2eADoKLm59N0c1iOmsRgRxShAnhPU/u2sxsypR80HGd/M53ZCHopx6IMqrX6cR3kqzjMsuu4xzzz0XgMsvv5yDDjposeteEkO1Y6VxXREREZEl9cILLzQ/XnvttSkUCv06b4MNNuhz/Pzzzw9qXf315ptv9tnB/Z//+Z/Ydv9+YS0yUFmWcfzxx3PHHXfgui733Xdfn1GOIiIiIrJkGhtdG0aPHj1o195zzz37HF933XWLPGfu1+yxxx6DVo8suflNqqiESbPb06IEcdIcGdcIPvmOTVRfa2hsxvbns6l7QRqbnMMkxbEsXNsiTOd8rrf/e/EF9p+wG91dXWz3xe257qbbcF03XxPJ8vf7qCdkVjVk+uwKXUFEJYpwbIPvWPiOoeBaZClUopRZ1YhqFFPy8kkbs6sRlTAmiFI6axFl38FzLGxjmoGyjoLL8FKj05VHR8FtBsQKjs3IsqdOUSIislLTqrzIcq673iGqFifN3Q+dtYhZlZCZPSGzKmGfWdS1OJ853R3Ei/2ebb4zZ5eB59JWcDD13RJxnLdy7apFdNdigjghyzIcy9BWcJqhqKJrNwNWMGesXCNvdOftt3HSSScBedeo448/frHrXVJDtWOluICRgyIiIiID1XuXdO/REosy92v7s9t6KPzkJz8hTef8cnmfffZpSR2ycvje977H1VdfjTGGW265hZ122qnVJYmIiIgss6rV6oBef9ttt3HnnXc2j4cPH87uu+++0HM+8YlPYIxp/rMwO+64I5tttlnz+PLLL+/TfXZuTzzxBHfffXfzePz48RqfvAyae1IFQGc1zidhLGCTcprlEzQ6q/lah+9azXWLkm83z2tsxnbt/i+JNoZvpGk+JcO1LbLmpu45r3vj9dfZd4/xzJjxEVv8x1bcfMc9FItFoiSlEia4jqE7jKmFCTN7IjLyoFKWQRCl2Jah4Dr4jk3Rt3DsfCP8zErEu51V4sabZdAdRARRSi1KcO28plXbfNp8B9e2sC2DZQy2ZXBtizbfYdU2n2Eld0Dfu4iIyIpI8WCR5djsatRs21oLE6pRMudGubckI4hSHMtQdG0Knt18oFjc1qnDii62ZZjRE+I7NsNLLtUoxbHAsy3SLMMyBmPlN/pOrxvvktc3FAVzAlHGwKMPP8RJx34TgG9961ucffbZi1XjYGnsWKnFCUXXpiuIqYRJfUfHosNNC9qx0hipJyIiIrIkqtUqcTwn9D5y5Mh+nztixIg+x11dXYNWV3/9z//8D1deeWXzeK211uLII48c1Pd4//33+eCDDwZ0zssvvzyoNciy4dJLL+WCCy4A4Oqrr2bfffdtcUUiIiIiy7YJEyaw0UYb8c1vfrNPIGlulUqFSy65hPPPP7/P588++2yGDx8+aPVYlsWPfvQjdtttNwB6enrYddddeeSRR/jYxz7W57XPPvss++yzT3MThmVZzXtBWbY0JlX0BDEdBZdO8hBQpb7u4dlWvuHY5GsJYZwSJmlzXcF3reZaR7keFGp8rfFnf7tF5edkzXMNgGGe67337jvsu8d43n3nHT756Y25/d4HaO/oAOZsrA7r4/HCOMEyFr5jM7saUo1SfMfCc+x6yCkPNaVZRjXMp3DUopRZlXBOhyjLUAljHMtQcG2COKEdh7LvUPYX+0cvIiKyUlAwSmQ51R3EzVBUZy1/SIA8WOTXdzA0bqSjJCWoz9HuCmLCNKWjkLdytYxZ7Baqbb7DyLJHZzXCsvL51b1H5fVmTB6Y6j0+r7dGa9o/P/E43zz0IJIk4dBDD+XSSy9d5C6hpaHk58GogmcTpvm8785qTMnLKHr2fB+q8oeYOaGouXesiIiIiAyG7u7uPsf9HaMHUCwWF3qtofbOO++w77779ukWdeWVV9LW1jao73PVVVdx3nnnDeo1Zflz/fXXc+qppwJw4YUXctRRR7W4IhEREZFlX7Va5fLLL+fyyy/nk5/8JNtssw0bb7wxI0eOxPd9ZsyYwd/+9jcefvhhPvrooz7n7r///nz7298e9Jp23XVXjj32WK666ioA/vnPf7Lxxhtz4IEHsuWWWxJFEU899RT33HMPURQ1z/vxj3/MFltsMej1yOBo8x2SNKMWJXQUXGp2QjXMN4MHcb7GMTfHMhQ9u/l796JnN9c7jAGyOdMqFtR5an5MPYFlDGT0vY4xMHPGDPbdc1def+1VPr7uJ7jz/kmsssqq+fukWXO9oxYlJGlGlKaUPZuuWtTc3N5RdCm6c68tGLyih2NbdFbzdR/XzgNSaw4r0lmL8eyEME7xHItqlMyzCV1ERETmpb8tRZZDUZLSUx+F1zsUVfLs+YZ0Cq5NuVdIJ4hSOonoKLj0BHEzSLU4Gg8ZnmPxfmdAlKYYk++iMMZgmfxrhXlu8OdIs4wwSfnn3/+XY76+H0EQsMtuu3PddddhWctGi9eh2LEiIiIiK54XX3xxyK49atSo+XaDqtVqfY49z+v3NX2/77bSgY7JWBLd3d3suuuuTJ8+vfm5448/nj322GOp1SArj3vvvbfZiey73/0up59+eosrEhEREVn+vPTSS7z00kuLfJ1lWXznO9/h/PPPH7JNr5dddhldXV3ccsstQN456tprr53va40xnH766c2QvCy7GpMqeoKYgpsHnsI4pRYnpGmWd3Ay+ZSHgmPjOXN+z172nT6bwC1jSMjyyQ1JvoG8EaBaFMtAQv4+YZzm6x1Wfu1KTxdH7rcHLz7/T1ZfYw3ufuBh1lxr7ea5tSghA6I4pRolBHGKY+z6eL0Yz7EZUfIoewteoi26+evDKCVOMiBfE/LsPAxVixM8xyKIU3WLEhER6QcFo0SWQ5Vgzvi8Riiqo+gsdKybZQxl38GxDZ3VOJ9FbScUXJtKkDCstHhBnaJrNx9S2gsOcZpRdOcdlbcw1TDhlZf+j6MP2ouenm6++KUduPOOO3CcZes/UYO9Y0VERERWPBtvvPGQXfvCCy+cb5hj7g5RYRj2+5pBEPQ5nruD1FCp1WrsvvvuPPPMM83P7bzzzvzsZz9bKu8vK5dp06ZxwAEHkKYpRxxxBBdddFGrSxIRERFZbhx88MHYts3TTz9NT0/PQl9bLpfZe++9Oemkk9hyyy2HtC7btrn55pvZZZddOP/883nuuefm+7ptt92WCy64gK985StDWo8MnjbfwXcsKkFCUA8A9Q5A9WYA37Ep+fY8m5F9x8rDUI5NEOW/vy9nWb9G6nmORZTkG6LjNIUMPMsiqNU44RsH8r/P/JURI0Zy58TJrLveen3ODZN8naASxwRxgqlfryeIsY2F71gUFxHQsozBsSwyB5L67uvOWsyoDp+eWkKS5J8bSBcsERGRlZlW50WWM2maEcR5MKpaH6VX8uyFhqJ68x2bkpflnY7CpDmLOk2dfOfEAFmWwXfyMXNF16YriKmECY5t+lVTECe8/OprHLn/nsyaOYMtt9qaO+66l1Jp6SzKDdRg7lgRERERGQxzj52bu4PUwszdIWqwR9jNTxRF7L333jz22GPNz335y1/mnnvuGbJg/LHHHsvee+89oHNefvllda9aATz11FPsueeehGHI3nvvzS9/+ctlYlS3iIiIyPLi8MMP5/DDDydNU/71r3/x0ksv8dZbb9HZ2UkURbS3tzNy5Eg222wzPvOZz2Db/fs9dW+vv/76Yte3zz77sM8++/Dcc8/x7LPPMn36dGzbZq211uJzn/sc66+//mJfW1rHtS2GlSzS1Gl2XUqzXr9/N6YZMFrQukZjU7fnWDiWIU7zqRr92dRdcG0q9U3RtrGAjCAM+d6Jh/Pk43+k3NbG7fc+wKc33mSec+uT8qgFCWGc4blW/fMZrjNn8sSiePVgl2cZUgxxkhLHGRn5ZvMRZVAuSkREpH+0Qi+ynKnW27CGcUqc5jOui97AHjaLnk01ym/qB2MWdcnPg1EFzyZM03xUXzWm5GXzHe0H+UNANUx48+13+Ob+e/L+u9P55Kc35vZ7H2D1VYcvVh1Ly2DtWBEREREZDMViEcdxiON81PLMmTP7fe6sWbP6HLe3tw9mafOI45j99tuPhx56qPm5L37xi0yaNGlIu1WNGjWKUaNGDdn1Zdn03HPPsfPOO9PT08OYMWO45ZZbFmuhTkRERETy8Xif+tSn+NSnPtXqUuZrs802Y7PNNmt1GTLILCufhLE44+KWZFN3vqaRr2F4jkWWpZz7nRN47NGH8X2fm39zL/+x9Wfne26W5es31TAhSjLaCw5dQYRjWTiOwTKmX4Em0/zT4Fp556pakm+Wj9K8K5X2fIiIiPSPglEiy5nGuLZavWuU71j9av3am2UMnp3Pnx6MWdSubVH2HXqCmI6CSycRQZTmXamivN1sYxdE46EgTFJmz5rF0QdO4I3XXuFjH1+XO++fxMfWXH25CBANxo4VERERWfFkLdquud566/Gvf/0LgDfffLPf573xxht9jodyN3WSJBx00EHcd999zc9ts802TJ48mXK5PGTvKyunV199lTFjxjBz5ky222477rvvPnx/MR94RERERERkubQkm7qjOH++byvY/PS8s5j2YN7l+Ipf38J2X9x+vu+XZhnVKKa7FmMMuDa4jgU18FyDa1tkGXknqAVstm5o/HbBGHAdQxJCECX4jt0MRA10bUhERGRlpWCUyHKmMTM6rfdjXdwQUSMM1bjOks6ibvMdkjSjFiV0FFxqdj6qL04zgjhtBroaqtUKJxy6H//3/HOsNmp17po4mfU/8fHlbtTckuxYERERERksm2yySTMY9dZbb1Gr1SgUCos875VXXpnnOkMhTVMOPfRQ7rzzzubnttpqK6ZMmUJHR8eQvKesvKZPn86OO+7IO++8w+abb67wnYiIiIjISmpxN3VnGTi2xfCyy5WX/Ih7b7keYwwX/PyXbLvDGGb0hAs8N4jyTe0FzyGph6DKnkOcZXkHqyghSvKN1gsLNoWNNRXLYMg7WIVxiu/YePVOuP4iwlUiIiKS09+YIsuZRn6p8efi7ghonDb39ZbEsKLbHMdXcG1GlD2GFV1818K1DY5lcG2DyWJOO+ZQ/t9fnmLYsOHcef8kNtvkU3QU3CUvQkRERGQltMUWWzQ/juOYv/71r/0674knnuhzvPnmmw9qXZB30TriiCO49dZbm5/bYostmDZtGsOHDx/095OV24wZMxg7diyvvfYaG2ywAY8++igjRoxodVkiIiIiItIibb5Dwc2DRB0Fl/aCg2Pl4+yCOKWrFtNZjemqxQRxPRRlGdoLDvfecDXXXfYTAC669Bfsu99+izy36Dq0FRxGljwMYBnoKDkYwLYMjmWRwTybyXtLs4y4Pi6vYNtkZKRZPl7PsUweyAKKrkaFi4iI9IeCUSLLmUagqfHn4nZ6apw29/WWVJvvMLLsUXBsDHlnqo6Cy/CSx4iyR7tvc9ZJR/P7306lWCxy130P8MVttl7uOkWJiIiILEt23nnnPsdTp05d5DlpmvK73/2uebzJJpuw3nrrDWpdWZZx9NFHc8MNNzQ/t+mmm/Lb3/6WkSNHDup7iXR3dzN+/Hiee+451lxzTaZNm8aaa67Z6rJERERERKTF+rup23cthhVdRpQ97rntJs4/5ywAzvvhjzjk8CP7de4awwoUHBvXsWgvuBRdhyTNu1dFSdYcoVeLkjldoebSDGgZg2MbKkFCkmVgGQqejWXAd2wsS6P0RERE+kPBKJHlTKNDVOOGN0oWvKtgYRo33I3rDOYsate2GFZyWbXNp813cG0L28qbvZ556rd44L57cF2Xe++9jzFf+dJijwMUERERkdx//ud/stZaazWPb7jhBuI4Xug5U6dO5c0332we77nnnoNe10knncS1117bPN5444157LHHWHXVVQf9vWTlFgQBEyZM4KmnnmLkyJFMmzZt0IN+IiIiIiKy/FrUpu7hJY+OgovnWDxw791851vHA3D66adzzlln9Ptc2zJ0FFxGlFxW7/ABSLN8LSZKUlzb4Dl5p6eeMKYaJX02wEdJSq0+js91LXrCmJ4gxjKGDt+pj9KzKPnqFiUiItJfSiOILGcaM6ML9RvnIE4H3DUqzTLCeqCqcZ2hmEVtWYZy/WFj1Tafn1/0A266/lcYY7jtttsYN26nQX9PERERkZWRMYaTTjqpefzWW2/x05/+dIGvj6KI7373u83jQqHA0UcfvdD32GGHHTDGNP95/fXXF/r673znO1x++eXN40996lM89thjjBo1ahHfjcjAxHHMgQceyLRp0yiXyzzyyCNsuummrS5LRERERESWMQva1G0Zg20ZXNviT7+fxnHf/EazA/KPfvSjfp/b5jus2uazxvACjm0xvOzhuxaOZYiTjCzLqEYJZc9uhqNqUUJnNaKrFjG7GjGzEhLGaR6QCvOv+a5FyXMYUfYxwCptvjaci4iIDID+1hRZzhTdOTsSGrOsq2EyoGtUw6Q5J3tpzaK+5JJLuPDCCwG45ppr2HvvvYf0/URERERWNieccAJrr7128/h73/sev/nNb+Z5Xa1W44ADDuAf//hH83PHHXcc66yzzqDV8r3vfY+f/OQnzeONNtqIxx57jDXWWGPQ3kME8nGNRx11FPfeey+e5/HAAw/wn//5n60uS0RERERElmFzb+perd1n1Taf5555igP324c4jjnggAO48sorMXNN21jQuSPLHmXfwaqHpMq+g2UMq5R9PNdqjtBrhJ9cOx/Bl2QZ3UHCjErIzEpIJUyI0qw5es+xDB1Fl1XaPCAfC9hRdJf6z0xERGR55rS6ABEZGMsy+I5NLU4oujZdQUwlTHDs/POLEsQJlXqQqug1ukUN7SzqX/3qV82OBD/+8Y858sgjh+y9RERERFZWxWKR3/zmN+y4444EQUAYhuy///5ce+21jBs3juHDh/PKK69wyy23MH369OZ5n/vc5zj//PMHrY5///vf/PCHP+zzuVmzZvGlL31pQNe57bbb2GabbQatLlnxZFnGd77zHa6//nosy+I3v/kNX/3qV1tdloiIiIiILIf++te/sssuu1Cr1dhll1248cYbsazF7y/R5jskaUacpLTHLp5tQXf+tVqUUIuSfPSeMfiOIYwtLCsfn+dZFlGa4juGjmIerPIdm5Jns/qwwiB9xyIiIisPBaNElkMlPw9GFTybME0JopTOakzJyyh6NpaZN+SUZhnVcE4oynctCvUuUUM5i/qee+7hqKOOAuC0007rM7JFRERERAbXF7/4RW6//XYOOeQQurvz37j+/ve/5/e///18X7/11lszadIkisXioNWQJPN2M/3ggw/44IMPBnSdarU6WCXJCuqiiy7i0ksvBfLNGHvuuWeLKxIRERERkeXR888/z0477URXVxc77LADd911F6675F2ZhhVdbMsQxCkAaw0vMrMnoDOISeKUWpwABs+1KHs2jmOI4owoTSl5DkXXxnctVin7lDybYSVPI/REREQWg4JRIsuhRhvWniCmo+DSSUQQpVTChGqU4Nl5W1ZjIMsgjFPCJCXL8vN916KjkN/Ul+uzsIfC1KlTOeCAA0jTlG9+85vNUXoiIiIiMnQmTJjAf/zHf3DKKacwefJkwjCc5zVrrrkmxxxzDKeffvqg/LJXZGm7+uqrOfPMMwH46U9/ymGHHdbiikREREREZFmWphnVKCGIU9IsI8vAGPj3G68zfsxoPvroIz73uc/x4IMPDurmoTbfwR9Z4t3ZNTqrESPKPiXfoRYmxGlGmmWEcUqUpCQh2LbFsIJD0XPoKDoML3lYxlD0bNp8LeuKiIgsDv0NKrKcarRhrUUJHQWXmp1Qrd9IB3Ha3IHQm2PlN8+NTlFDeSP95JNPsueeexJFEfvssw9XXXXVPLO4RURERGRorLfeetx3333MmDGDxx9/nLfeeouuri5WX311NtxwQ77whS8MeCTAH/7wh3697hOf+ARZI5EvMgTuuOMOjjvuOAC+973vcfLJJ7e4IhERERERWVZFSUolSAjihLmfVN975x323GUc70yfzqc+vTF33vsghVJ50GtwbYuPjSzRWY34qDvAtQ0lz6lvak/IMnAti6JnY9uGgmPjOXOe2cu+o1CUiIjIEtDfoiLLsUYb1p4gpuDmgaew3n41TefseLCspXsj/eyzz7LzzjtTqVTYaaeduOWWW7DtoRvXJyIiIiLzN3LkSHbfffdWlyEyaB5++GG+/vWvk2UZxx13HOedd16rSxIRERERkWVUdxDTE8TN497rJzM+msEhe43njddf4+OfWI87Jz5EadhwZvSEQ7Z+0lF0KXr2AoNavRnAd2xKvq3xeSIiIktIwSiR5cCCWrxaxuA7FsOLLrUoJYgTPMfqE4DqbWncSL/yyiuMHTuWWbNm8fnPf5577rkHz/OG5L1ERERERGTl8fjjj7PXXnsRxzEHHHAAl112mbrSioiIiIgIMO86Smc1IohTLJN/LQPSehKpp7uLow76Gv/6vxcYtfqaXHP7/fgdq1ILEwqeTU8Qk2YZHYXBHz3v2hbDShZp6ix03afo2liWnndEREQGg4JRIsuwhbV4JYOEjChJm4GnYUW3OUqvFTfS06dPZ/To0bz77rt85jOf4aGHHqJcHvy2syIiIiIisnL53//9X3bZZRdqtRq77LILN95444DHQYqIiIiIyIpnfusoPUFMJUwAmBVEhFGKMQbPsSiamJOPOJB//O0ZRowcyY13P8DH1v0EcZrRFcSEaUpHwaUaJljGDNnkDcsylH2Hsj8klxcREZFeFIwSWUYtrMXr/Ebk1eKEWpxQ9h1Glpd+h6aPPvqI0aNH89prr7HhhhsydepURowYsdTrEBERERGRFctLL73E2LFj6ezs5Etf+hJ33XUXrjv4O7dFRERERGT5Mr91lJ4gZkZPQJZBT5QQJxm+Y9FesLFJ+dbRh/Hk//w3be3t3HHvg2y5xeakWUY1TKiECUGU0klER8GlJ4jxHUuj7ERERJZzCkaJLINmVyNqUb6boRYmVKOEOJ3PtOkkI4hSHMtQdO0hb/G6IN3d3ey88848//zzrLXWWkybNo3VV199qb2/iIiIiIismP79738zevRoPvjgA7baaisefPBBisViq8sSEREREZEWW9A6SlctIkoywjilEuahKc82BGHMhacfzx+mPoLvF7jm5rvYcqutgXzqRtl3cGxDZzUmiFJqdkLBtakECcNKCkaJiIgszxSMElnGdAdx82a+sxYRRCmQd4hq7EywjCHN8jF6QZwu9RavvQVBwB577MGf//xnRo4cybRp0/jEJz4x5O8rIiIiIiIrtg8++IAxY8bw5ptv8qlPfYopU6YwbNiwVpclIiIiIiIttqB1lCzL8rWRgkNXNaLs5WEnyxh++oPTeWTiPdiOw0+vvYnPfG47eoKYcq91FN+xKXkZlTChGubBqCBOiGOboL4ek2a9pnoYg+9YFF0byzIt+VmIiIjIoikYJbIMiZK02fa19818ybMpejaW6XtjXXBtyi1s8RrHMQcccAC/+93vaGtrY8qUKWyyySZD9n4iIiIiIrJy6OzsZNy4cbz44ot87GMfY+rUqay22mqtLktERERERFpsYesoWZZhjCGKU4wx+K5heMnj8h+fz8Tbb8AYw5kXXc5WX/wKAJUwwXcsnF7rKEXPbnafqgRx/mcYU/TmWlLNICFr1uM7NiXf1tg9ERGRZZCCUSLLkEowp+1r42a+o+jgO/YCz2lVi9c0TfnmN7/Jfffdh+/7PPjgg3zuc58bkvcSEREREZGVR7VaZbfdduOZZ55htdVWY9q0aXz84x9vdVkiIiIiIrIMWNg6yqxKmH8tyV/jORY3Xn0Zv7ripwCc8cNL+eouEwiiFNdO8B2bSpjQUZyzjmIZg2dbzKyEdAcRbb5LmhlsK6UWJ6Rpr45RlqHg2HiORS1OqMUJZd9ZKtM8REREpP/0N7PIMiJNM4I4v1mv1lvAljx7oaGo3hbU4jVNnSVu4ZqmGdUoabaJTdOM7595GjfccAO2bXPHHb/hy1/+8hK9h4iIiIiISBRF7Lvvvvzxj3+ko6ODKVOm8KlPfarVZYmIiIiIyDJgUesoaZa/Lqt/MOnOW/jZj74PwMlnnsf+h3yDShhTDRNqYR6MCpN83aP3xI4gztdZPNsiiBK6aylRks1bUJIRRCmOZSi6NgXPpieISbOMjoI7VD8GERERGSAFo0SWEdUoIQPCOCVOM4zJW7YORO8Wr2Gc4jkW1SjpMyN7IKIkpRIkBHFeW8PPL/kxv7zyMgB+esUv+cJXd2J2JVKbWBERERERWWxpmvKNb3yDSZMmUSgUmDRpEltttVWryxIRERERkWXEotZRsmzOn7+bfD8XnnUKAEcc/22+cexJABRcm1qUnx8nKY5tUYsSSvVReT1BTBjnF+oMIgqJjWUZjAHfsXBtC8sY0iwfoxfUa+kKYsI0paPgUg0TLGPUOUpERGQZob+RRZYRQZy3fK3Vdzv4jtVnh0J/NFq8BnHe0tVz8o/L/sDr6Q7i5pxuyB80anHCrddfy0U/PBeAs86/iD33OYCsXrfaxIqIiIiIyOLIsoxvfetb3HrrrTiOwz333MOXvvSlVpclIiIiIiLLkEWtoxgDZPDkH6bxo9OOJ8sy9v364Zx42vear5mzjpKvabTZFmGcUvLqm8XDhIyM7jCGFHDyrlQjy948azYF16acZVTDhEp9tF8nER0Fl54gbgapREREpLX0t7HIMiKtb2VI6y1eF/dm2XOsPtdpXHcgZlejZiiqFibM7AmZXY247647Of/M7wBw9Le+y36HHc3sasTMnpBamD+I9AQxnbVosWoXEREREZGV03nnncfll1+OMYabbrqJ8ePHt7okERERERFZxixqHcUy8Jcn/4ezTjicJI4Zs9tenPnDSzBzBZpcJz/O0sZ18z+r9XWO7lpMFKcYy9BeyDeDL2gju2UMZd+ho5hvGA+ilFp9zF8lSJbwOxYREZHBoGCUyDKid4tXYMDdohoap819vf7qDuLmTXtnLaIriInTjD/+dgpnfetosizj0COP4bSzvkfBtTCGZpvYRiCqGiZ09+o2JSIiIiIisiC/+MUvOO+88wC48sorOeCAA1pckYiIiIiILIsWtY7ywrP/y/GH7kcY1Pj8l8dw2o9+MWfRpBdD/rlG0CrLMtI0I4xT0iyjq77WMbzo4Dl2c0P6wviOTak+1q8RsAripBniEhERkdZRMEpkGdG4N2/8uTidnmDOA8Hc1+uPKEmbnaI6axFBlG+XeO6ZJzn16ENJkoSv7bs/P7r4JxQ9h/aCy8iy17zZD6K0GY7qCWKiJF2s70FERERERFYON910E9/61rcA+OEPf8gxxxzT2oJERERERGSZtbB1lBdfeJ5v7DeBSk83//n57Tn/sl9hO25zI3hvGfl5jWCVMYZKGFMJE6bPrDKzElINEuI0o7MWkWZZv9Zsip7d3EwexikZUJ3P+4uIiMjSpWCUyDKicQNuWfmfixsqCuszthvXGUjnqUZb11p9FjbAGy89xzcP3pdarcaYceP52ZXXYFlz/tOhNrEiIiIiIrI4Jk6cyOGHHw7At7/9bc4888wWVyQiIiIiIsuyBa2jvPHaa+y7x3hmzpzB5ltuxWXX386wtjKQd28K475rFVGch5yMBXGS0hNEvNcVMLsa8VElJM2g5FtkGRigGqbM6AnprEbEC1m7sYzBq4/3q8WNrlHaQC4iItJqCkaJLCP8eivWglPvvlRv2ToQaZYR1m/KG9fx+9HiFfKZ3EH9Rr2xg+HdN1/hkH32pKuzk+2+uD3X3HALrusuoH61iRURERERkf557LHH2HfffUmShMMOO4yf/OQnmMUcJy4iIiIiIiuH+a2jTJ/+NvvsMZ733n2XT2+yKbfdM5FyWzu+a+O5+eu7ajGVMG52fmqso2QpzK5GJFlGTxAzqxJQDSLCOCPO8vPSNCVOUrIsf7+Zlag5eWN+GmP3GmsjizsdRERERAaPglEiy4iia2PIb5ody5BlcwJG/VUNE7IMHMvgORamft1+nRslZOQdp+I0493p/+aQfXbnow8/4DNbbsXNd9xDsVhc+PegNrEiIiIiIrIIf/7zn9l9990Jw5AJEyZw7bXXKhQlIiIiIiKLNPc6yswZM9h3z1154/XXWPcT63Hn/ZMYtdpqzU3c7b7bDEdVw4RZlZAPuwKCOKG7FtEdxvVAVMT7swN6woQMg+cYshQc2xDXw1OzK2Fzc3klTOiuzT8c1Xi0aeShlIsSERFpPafVBYhIzrIMvmNTixOKrk1XkM+zduz884sSxAmVepCq6DW6RdnNlrKLPj/fIVGLEz768AO+uf+eTH/rLTb65Ke4/d6JtHd0LPp7qLeJDeKUWpzgOfnHZb9fJYiIiIiIyAru+eefZ9y4cXR3d/PVr36V22+/HcfRryZERERERGSONM2oRklzskaW5YEjyxjiNMMASVDhmIO+xr9efIHV11iTux54mNXXWBOAsu+QZBlBlNLuuwR2Qi3M11B6wphalGBbhijNiJMMxzZgoOQ6lNyUDMOIssvwkkeUZM0N5d21mMhNafNdqlGCMfl79dYIQjUCUtoDIiIi0nr67aPIMqTk58GogmcTpilBlNJZjSl5GUXPbs7P7i3NMqrhnFCU71oU6l2iSn7/ukU1rgMwe9YsjjloL1575WXW/tjH+M39k1h11dX6fZ1GGEptYkVEREREpLfXX3+d0aNHM2PGDLbZZhsmTpyI72sXhYiIiIjIYFpYqMh3LIpu/zdUL21RklIJEoI4n3DRRwYJGVmW8c5HnRx3yD489/f/x/ARI7nm9vtZdc11SLOsuY7SUXDpMfkGdNe2SJwMK0qxLINtDEXHphrFFFybkufS7jtYlqESJdjGUPYdfMfGdyD1MmpRQjVMCKIUiGjzXSphgu9YOPacAT1hfRN642c8v3UdERERWboUjBJZhri2Rdl36AliOgounUQEUUolTKhGCZ5t5SPyTL7rIIxTwvpsa8hDUR0FF8h3Kbh2/6dlZhlUq1WOOWR/XnjuWVZZdVXumjiZtdf52IC+B7WJFRERERGRub377ruMHj2a6dOns+mmmzJ58mTa2tpaXZaIiIiIyAqjP6GiKEnpCWJ8x6bk2wNaQ1iYwQhjdQf5WLuGsD6ZIk17Xc8y2FnKacd/g6efeJxyWztX3nwPG3zy0/NdR7Etg2VBdyUmjFMc21AyNsMKLkGc4tRray+4pFn+82nzHSphQhinpF4etLKMoeQ5OJZFVy1ft3HtBN+xqYQJHcX855hmGWGSB6MKTmOyx+D8jEVERGTxKRglsoxp8x2SNN990FFwqdn5LoQ4zQjitDnyrjfHMhQ9u9kpqujZtPkD+793HEcceciB/PWpP9HW3sFNdz3ABhtuNOD61SZWRERERER6mzVrFmPHjuXll19mvfXWY+rUqayyyiqtLktEREREZIXR31BRwbHxHItanFCLE8q+M+C1hN4GK4w1uxpRi/KpGLV6wClO5911HYcxp59wFL979BE8v8CFv7yFj39qMzprEUXHxrYNQTbvOkpbwcUCMDCrGpGmGbYxlDybsm8zvOji2RazqhFZ/ecX19dpSt6cn4/nWBQ9m2qYj+bzHZswSZudqqphQpblazaeY2GAotv/yR4iIiIyNBSMElkGDSu62JahJ8jbuBZce5EPMg2L8yCTpiknHn0kv330EQrFIlfedCef2nTzxapdbWJFRERERKShp6eH8ePH8+yzz7LGGmswbdo01lprrVaXJSIiIiKywuhvqIgkI4jSfKO1a1PwbHqCmDTLmpMoBmKwwljdQdysv7PejQny833HwrUt0jSjO4g4/8xTefTBe7Adh/N+8Ss23XpbkjQjSTMcy4CxiEnxbQvbsuapoRLGpBm4tiFKMoyBkWWvuY7hORZBnFJwbbqDmGqY1ENOc8JNBdemFuXBqThJcWyLWpRgW4ZKmH8fRa/RLWrZHVsoIiKyMlEwSmQZ1eY7+I7V3G3hOVafAFRvBha79W2WZZx44oncc9dvcByHX95wK1v953YEcUq51zzu/lCbWBERERERaQjDkL322osnnniC4cOHM3XqVDbYYINWlyUiIiIissLoT6jIMqY5Ji6od0LqCmLCNKWj4FINEyxjBrTherDCWI1uUnPXX/Jsip6NZfIN5JUw4bIf/5D7brsBYwxnXHQFm237ZSpBgmWBb+dBppElD9e2ychDTuVe35MBDIbhJZdqlECS4TtWnzWQomcTxCm+axOmKWGU0lWLKXoZBddujtXzbIugHvQqWYZZPRFufS3Ed63mdI+Sr25RIiIiywIFo0SWYa5tMaxkkabOEs/nXpDvf//7XHnllRhjuPyaX7HTuJ2Z2RMSpxnVMOnz4LAoahMrIiIiIiIASZJw8MEH8+ijj1IqlXj44YfZfPPF60orIiIiIiLz6k+oqLeCa1PO8t/7V8KEIErpJKKj4NZH3Vn92ng9mGGsJMnDVLV6PQAdRQe/vvG6qxZRi1J+feXP+dUVPwXg2+dezI677EmUpHQHMaT5WoqDoasW0V708B2LWpRimYSOottcR5lRCUnSrPlzm/v7dW2LkmdTCRPafZcuIsIozUfnRQmunW9gz0gJk5Qwzv+xjGG44+G7VrP7Vtl3BryRXURERIaGglEiywHLMpR9h7I/uNf92c9+xvnnnw/AVVddxf77HUAtTii6Nl31XRiObZoPIQsTxInaxIqIiIiICFmWceyxx3LXXXfhui4TJ05ku+22a3VZIiIiIiIrlEowp2PT/EJF82OZfK3BsQ2d1ZggSqnZCQXXphIkDCstPMgzmGGsrlpEmmY4tpV3cKpfp1F/TxBTi1LuuvUGfn7huQAc/Z1z2G2/Q/Aci7aCQ9HL687SDNuxybIMC3Bs0wwo9e4cldWbWjX+nN/EjLLvkGR5p6t23yWwE2ph3hGrEYQK45SeMMax8qCUbRnaC06zU1TRswfUgUtERESGlv5WFllJ3XDDDXz7298G4Ec/+hFHH300UZLPAC94eZvYIErprMaUvGy+DzWQj89rPNSA2sSKiIiIiKzszjjjDK699losy+L2229n9OjRrS5JRERERGSFkqYZQZz/Tn5+oaJF8R2bkpdRCROqYR6MCuKENHUWutl5MMNYaZYRJxkFF+I0w5g5m67jJKUSJjw88R5+eEa+jnHQUSdx2DEnNkfaQd7hKUnzKRtlz84DTXGCZZn5dsMyBqhP5IB8fWN+OgouPSbfPO47+c81ilNqSR7CSlODaxm8eoeogmc310XKvqNQlIiIyDJGfzOLrITuv/9+jjjiCABOPfVUTj/9dCB/iCj7Dj1BTEfBpZN8x0elPiPcq7eJNSbfURHGebvYxrOD2sSKiIiIiKzcfvzjH/PjH/8YgGuvvZavfe1rLa5IRERERGTFU40SMvLf0c8dKuqvomdTjeZ0QvKcvHNTeQGhnsEOYxkDcZKR1RcYfMdqBp4qYcIffzuFM791NFmWsccBh/Gt08/Bd/u+l2UMrm3laxVp3uGpcb35dcOyjCEhy8NfST7qr+DOv/6y7+Q/kzAhjFNcx8J18jWPbhNjWQbfzT9nGyg4NiXf1rqIiIjIMkjBKJGVzO9+9zv2228/0jTl8MMP5+KLL8b06gTV5jskaUYtSugouNTs/CElTjOCOJ8HPjfHMhR77YhQm1gRERERkZXPdddd19x0cckll3D44Ye3uCIRERERkRVT4/f0tXpQqXeoqL8sY/BsiyDOJ0l4Tv5x2Z//6wc7jJWmeUCpEiQ49Y5OkHdx+p/H/8gpRx1KEseM3u1rnPaDH88TimrwnDwYlaV5IMqxLXzHmm83LN+x8jCUYxNE+XpHOcsW+LNzbQu3aJHW10zCJP/e4zTDtgxtvkvZs1m1zae96A7oZyEiIiJLj5ILIiuRp59+mt13350wDNlrr7245ppr+oSiGoYVXWzL0BPEFNw88BTWH47SeltaY8CyDAXHxnPm7IBQm1gRERERkZXPXXfdxVFHHQXko/ROPfXUFlckIiIiIrLiaoyAS+thoMXtUtQIQzWus6DRcjA0YayS5xAkKU6vaz395z9z/KH7EwQ1vvCVsZz+o19Q8hccOmpU0Cg9yxbcDavo2vQEMZ5j4ViGOM2ohgvuktWs2zKUfIcS0BPEZKV8w/iIsoeBRZ4vIiIiraW/qUVWEs899xw777wzPT09jB49mttuuw3bXvBujjY/3z1RCRKC+m6R3gGo3gz1NrhqEysiIiIistJ59NFHOeigg8iyjKOPPpoLLrig1SWJiIiIiKzQeoeAgAEHlBoap819vfkZ7DBWY+RdxpxQ1osvPM+h++5Jpaebrbf9Iuf87FpKRX+h31+j5MZLjFlYNywH37GpxXlIqiuIqYQJjm36NRIwiBMqYR4Ma3TL8h07H80nIiIiyywFo0RWAq+99hpjxoxhxowZbLvtttx33334/gL64fbi2hbDShZp6lCNknznSNarY5Qx+I5F0dWNv4iIiIjIyuiJJ55gwoQJRFHEfvvtxxVXXDHfrrQiIiIiIjJ4jAGyOWGghXV6WpjGab1DRYt67WCFsRq9nhrXeeWVVzhgj/HMnjmTzbfcmguvvhnPL+DaC3+fsN7JyliN6+WfX1A3rJKfB6MKnk2YpgRRSmc1puRlFD17vt9XmuWdpRqhKN+1KNRH+5X8gY0TFBERkaVPwSiRFdw777zDjjvuyDvvvMNmm23G5MmTaWtrG9A1LMtQ9p0FzhYXEREREZGVz9///nd23nlnKpUK48aN46abblpoV1oRERERERkcljEkZPmG5SQjStJmUGcgGqEiy+obUpqfwQ5j+fUJFQXX5v133+GQvXfjvXffZaNPb8LVt9wDfpk4zRZaU5rl3ztAof4s4tU7WS2oG5ZrW5R9h54gpqPg0klEEKVUwoRqlODZ+fQMY/JzwjglTNI5dbsWHYV8tF/ZdzRFQ0REZDmgv61FVmAzZ85k7NixvPrqq6y//vpMnTqVkSNHtrosERERERFZzr388suMHTuW2bNn84UvfIF77rkHz/NaXZaIiIiIyEqhGSqqj39rTHsYiDTLCBuhIqcxFm7By4aNgFIjRNUIJA1UI4xV9G2MgUrnLL55wJ689eYbfPwT6/OrO+5n2IgR/Qpg1aKELAPHMriOhYFmQGxh3bDafKf5uo6CS3vBwbEMWZb/LLtqMZ3VmK5aXB/7l79He8FphqKKnk2br/4TIiIiywMFo0RWUD09PYwfP55//OMfrLnmmkybNo0111yz1WWJiIiIiMhy7u2332b06NG89957bLnlljz00EOUSqVWlyUiIiIistIoujaGfFxcI9BTrY95669qOCdU5NVDRcWFdJ0a7DBWyXUIK91888C9eOWlFxm1xlpce8f9DF91NaB3AGv+7xHGSfN7Lnj1blGO1TxvUd2whhVdyvVgU8G1GVH2GFZ08V0L1zZ52Mo2+K7FsKLLiLLXDFOV/TkBKREREVn2KcossgIKgoAJEybw5JNPMmLECKZOncr666/f6rJERERERGQ599FHHzFmzBhef/11NtpoI6ZMmcLw4cNbXZaIiIiIyErFsgy+Y1OLE4quTVcQUwkTHDv//KIEcUKlHioqeo1uUXYzRDQ/RdemJ4ibYaw4zaiGSTNc1B+9w1hJFHDcofvzj7/9P0aOXIUb736AtT+2bv4aYjzbIohSwjgl9eaM1EuzjFo0JxTluVbze258L/3thtXmO/iORSVICOIEz8nH6M2Pqf+MSr6t8XkiIiLLGQWjRFYwSZJw0EEHMXXqVMrlMg8//DCbbbZZq8sSEREREZHlXFdXF+PGjeP5559n7bXXZtq0aay++uqtLktEREREZKVU8vNgVMGzCdOUIErprMaUvIyiZ8/TIQnywFA1nBOK8l2r2QWp5C88UDWYYSzHpHzz0IN48k+P097ezh33PcgWn9mMzlpEmmXMqkRAHoCyLENXNe8KFcYpUZI2x+R5rkW7n3duKnlzAksD6Ybl2hbDShZp6lCNkmYnrCzLx+9ZxuA7FkV34cExERERWXYpGCWyAsmyjKOPPpp77rkHz/OYOHEi2267bavLEhERERGR5VytVmOPPfbgL3/5C6ussgrTpk1j3XXXbXVZIiIiIiIrLde2KPsOPUFMR8Glk4ggSqmECdUowbPz7kfGQJblo+XCXqEi37Wa4+DKvtOvLkiDEcZyrIzvnnAU06Y8TKFQ4KGHHmKLz32OWpTQUXDrnaLy1xtj6AlieoKYsuc0uzk5lqHg2c1AVsG1mp2rFqcbFuTBr7LvUPYX+WMQERGR5YyCUSIrkNNPP51f/epXWJbFHXfcwY477tjqkkREREREZDkXxzH7778/jz32GG1tbUyZMoWNN9641WWJiIiIiKz02nyHJM2aoaKanY+Yi9OMIE4J4nSecxzLUPTsZqeoomfT1s9xeEsaxvIcwwVnfof777kLx3G49957+dKXvgSAbeUhqIJrs9bwIu93BtSSBAMEUUIYJ9i2YVjBxe/V/ank2ZR9Z4m6YYmIiMiKTcEokRXERRddxMUXXwzAddddx4QJE1pckYiIiIiILO/SNOXII49k4sSJ+L7PpEmT+OxnP9vqskREREREpG5Y0e0TKiq4+ci5WpyQpr1GwlmGgmM3uy5B3imqv6GohiUJY116wbncfP11GGO49dZb2Xnnnftc13csKkFCAAwrubhhPiqvO8gDWAA9YUKUZLQVbIqejW0ZOqvREnfDEhERkRWXglEiK4BrrrmGM844A4BLL72Ub3zjGy2uSERERERElndZlnHKKadw4403Yts2d911FzvssEOryxIRERERkbn0CRXFCZ5j9QlA9WbIR8uVfHuxA0OLE8a6/KeXcPnPfgLkaxr77rvvPNd1bYthJYs0dSj7Dh92B1TChI6CR+gkBHGKZaiP0DNUwxSYE8Rakm5YIiIisuLS3YDIcu7OO+/kmGOOAeCss87i29/+dosrEhERERGRFcEPf/hDfv7znwNwww03sNtuu7W2IBERERERWaDeoaJqlIeI0qxXSMkYfMei6NpYllni9xtIGOvmX1/HBeedA8All1zCkUceudBrW5ah7OfhqO4gpieIm18bym5YIiIismLSHYHIcmzKlCkcdNBBZFnGMcccw/nnn9/qkkREREREZAVwxRVXcM45+cLFL37xCw4++OAWVyQiIiIiIv0xJ1Q09O/VnzDWA/fcyWmnnATkm7tPPfXUAb3H0u6GJSIiIiseBaNEllN/+tOfmDBhAnEcs//++3PFFVdgzJLv8hARERERkZXbbbfdxgknnADAueeey4knntjiikREREREZFm2oDDWpEmTOPLww8iyjOOOO26xN3cv7W5YIiIismJRMEpkOfS3v/2N8ePHU61WGT9+PDfddBOWpd0PIiIiIiKyZCZNmsQhhxwCwEknndTsGiUiIiIiIjIQv//979l7771JkoSDDjqIyy67bIk3dy/NblgiIiKy4lCSQmQ5869//YuxY8cye/Zstt9+e+666y5c1211WSIiIiIispz7wx/+0Fy4+PrXv85Pf/pTdaUVEREREZEB+/Of/8xuu+1GEATsvvvu3HDDDdrcLSIiIi2juxCR5chbb73F6NGjef/999lyyy2ZNGkSpVKp1WWJiIiIiMhy7plnnmkuXOy22278+te/1sKFiIiIiIgM2HPPPce4cePo7u7mK1/5Cr/5zW9wHA2wERERkdbRbzlFlhMffvghY8aM4Y033uCTn/wkjz76KMOGDWt1WSIiIiIispx78cUX2Wmnnejq6uLLX/4yd955pxYuRERERERkwF555RXGjBnDjBkz2GabbXjggQcoFAqtLktERERWcgpGySKlacp2222HMabPP6+//nqrS1tpdHV1MW7cOF544QXWWWcdpk2bxqhRo1pdloiIiIiILOfefPNNRo8ezYcffshnP/tZLVyIiIiISB/nnnvuPGsDi/PPYK4n7LDDDotVwy677DJoNci83n77bUaPHs0777zD5ptvzsMPP0xbW1uryxIRERFRMEoW7fLLL+epp55qdRkrrVqtxu67785f//pXVl11VaZNm8bHP/7xVpclIiIiIiLLuffff5/Ro0fz1ltvsfHGG/PII4/Q3t7e6rJEREREZAVjWZbuM1dwjYkXr732GhtssAFTp05l5MiRrS5LREREBAD1xpeFeuONNzjrrLNaXcZKK45j9t13X37/+9/T3t7OlClT+PSnP93qskREREREZDk3e/Zsxo4dy0svvcS6667L1KlTWXXVVVtdloiIiIgsY0aOHMkGG2wwoHO6u7t57733msdjxoxhlVVWGezSAGhvb+/3dIW11lprSGpY2XV2djJu3Dief/551l57bX7729+yxhprtLosERERkSYFo2ShjjrqKHp6egDYeOONeeGFF1pc0cojTVMOP/xwHnzwQXzfZ9KkSWy99datLktERERERJZzlUqFXXfdlb/97W+MGjWKadOmsc4667S6LBERERFZBp144omceOKJAzrn+OOP58orr2weH3HEEYNdVtOECRO48cYbh+z6snDVapXddtutz8SLT3ziE60uS0RERKQPjdKTBbrlllt49NFHAdhxxx3ZZ599WlzRyiPLMk4++WRuvvlmbNvm7rvv5r/+679aXZaIiIiIiCznoihi77335vHHH2fYsGFMnTqVjTbaqNVliYiIiMgKolarcdtttzWPV1ttNXbbbbcWViRDpfFs8cc//pGOjg4effRRNt5441aXJSIiIjIPBaNkvj744ANOPvlkAAqFAldffXWLK1q5/OAHP+Cyyy4D4KabbmLXXXdtcUUiIiIiIrK8S5KEQw45hIcffphiscjkyZPZYostWl2WiIiIiKxA7r33XmbNmtU8/vrXv47ruq0rSIZEkiR8/etfZ/LkyRQKBR566CG22mqrVpclIiIiMl8KRsl8nXTSSXz00UcAnH322Wy44YYtrmjlcdlll3HuuecCcPnll3PggQe2tiAREREREVnuZVnGCSecwB133IHrutx333184QtfaHVZIiIiIrKC+fWvf93neCjH6ElrZFnGcccdx29+8xscx+G+++5j++23b3VZIiIiIgukYJTMY/Lkydxxxx0AbLrppnz3u99tcUUrj1tuuYWTTjoJyLtGHX/88S2uSEREREREVgTf+973uPrqqzHGcMstt7DTTju1uiQRERERWcG88sor/OEPf2gef+ELX+DTn/506wqSIXHGGWdwzTXXYIzhtttuY9y4ca0uSURERGShFIySPrq6ujjmmGMAMMZwzTXXqM3tUvLggw9y2GGHAfCtb32Ls88+u8UViYiIiIjIiuDSSy/lggsuAODqq69m3333bXFFIiIiIrIiuv7668myrHl8+OGHt7AaGQoXXXQRP/7xjwG49tpr2WeffVpckYiIiMiiKRglfZxxxhn8+9//BvIWtxqtsHT84Q9/YJ999iFJEg499FAuvfRSjDGtLktERERERJZz119/PaeeeioAF154IUcddVSLKxIRERGRFVGSJNx4443N4/b29qUSmvnrX//KLrvswjrrrEOhUKC9vZ11112XsWPH8qMf/YjXX399yGtYWVx99dWcccYZAPzkJz/RmEQRERFZbjitLkCWHU888QRXXXUVAKuvvnoz9S9D669//Su77rorQRCwxx57cN1112FZyiyKiIiIiMiSuffeeznyyCMB+O53v8vpp5/e4opEREREZEX1yCOPMH369Obx/vvvT7lcHvL3/ec//8k///nP5nEQBHR3d/Pmm28ydepUzjnnHA466CB+/vOfM3z48EF97/fff58PPvhgQOe8/PLLg1rD0nLrrbdy3HHHAXD22WdzyimnDPgaaZpRjRKCOCXNMrIMjAHLGHzHoujaWJY2jIuIiMjgUzBKAAjDkCOOOKLZ5vZnP/sZI0aMWKo1rEwPEQ0vvPACO+20E93d3XzlK1/hjjvuwHH0f0sREREREVky06ZN44ADDiBNU4444gguuuiiVpckIiIiIiuwX//6132Ol2Y3Ic/zWGWVVXAchw8//JBqtdr8WpIk3HTTTfz3f/83jz76KBtttNGgve9VV13FeeedN2jXW1Y9+OCDHHrooWRZxvHHH88PfvCDAZ0fJSmVICGIE7K5v5hBQkaUpPQEMb5jU/JtXFubx0VERGTwKIEhAPzwhz/khRdeAGDs2LHsv//+S72GleUhouGNN95g9OjRfPTRR3zuc59j4sSJFAqFVpclIiIiIiLLuaeeeoo999yTMAzZe++9+eUvf6lR3SIiIiIyZN577z0eeuih5vHmm2/O5z73uSF7P2MM//Vf/8XXvvY1vvrVr/LJT34S27YByLKM559/nttvv53LL7+crq4uAF577TV23nlnnnrqKVZZZZUhq21F89hjj7HPPvuQJAkHH3wwv/jFLwb0bNEdxPQEcfM4jFNqcUKa9uoYZRkKjo3nWNTihFqcUPYd2nwtYYqIiMjg0F3FMuLFF18csmuPGjWKkSNHLvDrzz33XHP3cLFY5Oqrrx6yWiT33nvvMXr0aN5++2022WQTHnnkEdrb21tdloiIiIiILOeee+45dt55Z3p6ehgzZgy33HJLc5FIRERERJZfrVxDWJSbbrqJOJ4TfhnqblF33XUXq6222ny/Zoxh00035YILLuCwww5j/PjxvPTSS0A+geKcc87hyiuvHNL6VhRPP/00u+22G0EQsMcee3D99ddjWf3v5DS7GlGLEgBqYUI1SojTeXpGQZIRRCmOZSi6NgXPpieISbOMjoI7WN+OiIiIrMQUjFpGbLzxxkN27QsvvJDTTz99vl9rjFWIogiA73//+6y33npDVovArFmzGDt2LP/617/4xCc+wdSpU7VDRUREREREltirr77KmDFjmDlzJttttx333Xcfvu+3uiwRERERGQStWkPoj+uvv775se/7HHTQQYNR1gItKBQ1tw033JBHHnmEz3zmM/T09ABw3XXX8b3vfY811lhjies49thj2XvvvQd0zssvv8wee+yxxO891J577jnGjRtHT08PX/3qV7njjjtwnP4vKXYHcTMU1VmLCKIUyDtE+Y6Fa1tYxpBm+Ri9IE6J04yuICZMUzoKLtUwwTJGnaNERERkieluYiV32WWX8fTTTwN5e9tTTjmlZbWsyA8RDZVKhV122YW///3vrL766kybNo2111671WWJiIiIiMhybvr06ey444688847bL755kyePJlyudzqskRERERkBff444/zf//3f83jCRMmLFH3qcG2/vrrc9xxx3HxxRcDEEURU6ZM4dBDD13ia48aNYpRo0Yt8XWWNa+88gqjR49m5syZbLvttkycOJFCodDv86MkbY7P6x2KKnk2Rc/GmmsUX8G1KWcZ1TChEiYEUUonER0Fl54gbgapRERERBaXglErsTfeeIOzzz4bAMuyuPbaaweU+B9sK+pDREMYhnzta1/jT3/6E8OHD2fq1KlsuOGGrS5LRERERESWczNmzGDs2LG89tprbLDBBjz66KOMGDGi1WWJiIiIyErg17/+dZ/jww8/vEWVLNiECROawSiAJ598clCCUSuit99+mx133JF3332XzTffnIcffpi2trYBXaMSzBmf1whFdRQdfGfBI74tYyj7Do5t6KzGBFFKzU4ouDaVIGFYScEoERERWXwKRi0jsmw+c5WH2Mknn9xsH3vUUUex7bbbLvUaVhZJkvD1r3+dRx55hGKxyOTJk/nMZz7T6rJERERERGQ5193dzfjx43nuuedYc801mTZtGmuuuWaryxIRERGRQdaKNYRF6ezs5O67724er7/++nzlK19pYUXz96lPfarP8fvvv9+iSpZtH374IaNHj+b1119nww03ZOrUqQPecJGmGUGcB6Oq9VF6Jc9eaCiqN9+xKXkZlTChGubBqCBOSFMHyzKLvoCIiIjIfCgYtRJ79dVXmx8/+OCDTJ06daGvnzFjRp/jHXbYoU+Hqf/93/+lvb19cItcAWRZxvHHH8+dd96J67rcf//9fP7zn291WSIiIiIispwLgoAJEybw1FNPMXLkSKZNm8Z6663X6rJEREREZCVxxx13UKlUmsff+MY3MGbZC68Ui8U+x71rllxnZyc77bQTL7zwAuussw6//e1vWWONNQZ8nWqUkAFhnBKnGcZA0etfKKqh6NlUo4Q4zQjjFM+xqEYJZV9LmiIiIrJ4dBchQN4edaDeeOONPsdJkgxWOSuUs846i1/+8pcYY7jtttsYO3Zsq0sSEREREZHlXBzHHHjggUybNo1yucwjjzzCpptu2uqyRERERGQl8qtf/ar5sW3bHHbYYS2sZsHee++9PserrrpqiypZNlWrVXbddVeeeeYZVl11VaZNm8a66667WNcK4nx0Xq3eNcp3LKwBhuUsY/BsiyBOqcUJnpN/XPYXqyQR+f/s3Xd4FNX+x/HPpmwKJYQOoReRJkqTXhSRIgICgqiAClhQUVC5dtB7FcSC3mtDEbwCFqqKiCC9SFVaQCnSew8EUnd+f3CZ306STXaTTXazeb+eh4c9kzNnvrs7OzNn9zvnAADEpLxALho/frzefPNNSdKnn36qPn36+DgiAAAAAPmdYRh6+OGHNWvWLNntdn3//fdq2rSpr8MCAABAAbJ161Zt3LjRLHfq1Enly5f3YUSurVq1ylJmlNX/l5SUpN69e2vFihUqWrSofvnlF11//fXZbs/xvykfHY6r/4cGZ+9nSHtIkKUdhx9OJQkAAPIPEqMKsM2bN8swDLf/vfrqq5b19+3bZ/l7sWLFfPNE/NTnn3+u5557TpI0btw4DRkyxMcRAQAAAMjvDMPQs88+qy+++EJBQUH65ptvdOutt/o6LAAAABQwkyZNspQHDx7so0iy9u9//9tSvu2223wUiX9JTU3VgAEDNH/+fEVERGjevHlq2LBhjtq8lr907X9PR4u65tpqadsDAADIDhKjgFwwc+ZMPfzww5KkUaNGmQlSAAAAAJATY8eO1TvvvCPp6o9RPXv29HFEAAAAKGgSExM1depUs1y2bFndcccd2W5v0KBBstls5r9ly5a5rHvlyhWP2v7Xv/6ltWvXmuUaNWqoZcuW2Q01YBiGoccee0zffvutQkNDNXv2bLVu3TrH7V5LaLr2f3ZHerq2Wtr2AAAAsoPEKMDLFi5cqP79+8vhcGjo0KHmVHoAAAAAkBMff/yxXnjhBUnSe++9p0GDBvk2IAAAABRIc+bM0dmzZ83ywIEDFRISkifbbt68uV5++WXt27cv03rnzp3TsGHD9NJLL1mWjx07Ns9i9VeGYWjUqFGaOHGigoKCNG3aNHXq1MkrbV8bISoo6Or/yamObLWTlOKwtJPdkacAAAAkqWBf/QFe9ttvv6lnz55KTk7W3XffrY8++kg2LtgBAAAA5NDXX3+tYcOGSZJefvllPfXUU74NCAAAAAXW559/bik/9NBDebbt8+fP65///Kf++c9/qkGDBmrcuLGuu+46RUdHKyQkRKdPn9aGDRv0888/69KlS5Z1//GPf6hXr155Fqu/Gjt2rMaPHy9Jmjhxovr06eO1tkODbLpwOUWJyQ6dv5wkyabEFIdCgmyyBwcpPDTYTHZyxWEYSvpfQlV4SLAkKSyEcR4AAED2kRgFeMnWrVvVpUsXXb58WZ06ddJXX32l4OBgX4cFAAAAIJ+bP3++BgwYIMMwNGzYMI0ZM8bXIQEAAKCA2rdvn5YsWWKW27Rpo5o1a/okli1btmjLli1Z1gsLC9Obb77JzQWSPvroI3MU2nfeecdrSW3JqQ5dTkzVleQUXU5OlSTZJKU4HIpPTFGkPUTJqam6nJQqe0iQIuzBCg3OONnpSlKqDENXk6lCgmSTFBHKby0AACD7SLEGvGDv3r26/fbbdf78ebVo0UIzZ86U3W73dVgAAAAA8rmVK1eqV69eSklJUf/+/fXBBx8wKi0AAAB8ZvLkyTIMwywPHjw4T7f/6KOPqmXLlgoLC8uybvHixfXkk08qNjZWTz/9dIG/jp46daplFNoRI0Z4pd1LiSk6G5+khJRU2Ww22SRdTExWYqpDF68k61Rcgs7EJyo5xSFDUmKKQ+cvJys+MSVdW4kpV5OnJCnCfm20qKxHmQIAAMiMzXC+ggXymdjYWNWrV88sb9++XXXr1s3TGI4ePapWrVpp3759uuGGG7Rs2TJFR0fnaQwAAAAAvMsf+hp//PGH2rVrp7i4ON1xxx2aPXu2QkND8zQGAAAAwB+lpKRo586d2rt3r44cOaK4uDg5HA4VLVpUJUqU0I033qjatWv7XTKUr/oZ33//vXr16qXU1FQ98cQTev/9973y2ly4kqyE/40QlZCUqivJqUpITtWFK8mSpPikVCWlXP17eGiwCtmDFWkPUdj/RoAKDw1SkfBQOQxDV5L+PykqLDRIRcOv9n2KF7K7HF0KAADAHUylB+TAmTNn1LFjR+3bt081atTQwoULSYoCAAAAkGO7du3S7bffrri4OLVp00bfffcdSVEAAADA/4SEhKh+/fqqX7++r0Pxe4sXL9bdd9+t1NRUDRgwQBMmTPBKUtSlxBQzKSouIVmJyQ5JUmhIkKILhSo51VDR8FDFJSQpPilViSmpSkxO1cWEFBUKD1GRsFAlpqQqPjFFIcFBujaMg3NSVKGwEJKiAABAjpEYBWTTpUuX1KVLF8XGxqp8+fJatGiRypQp4+uwAAAAAORzhw4d0m233aZTp06pYcOG+uGHHxQREeHrsAAAAADkM+vWrVP37t2VlJSkHj16aNKkSQoKynmiUXKqw5wKzzkpKtIerAh7sIJsNl1MSFZCskMlCoercEqqLielKD7x6ohSSfFJupSYosL2qz9TRkWEKjz06rrh/xtNKsIerMJh/IwJAAByjisKIBsSExPVo0cPrV+/XsWLF9eiRYtUpUoVX4cFAAAAIJ87deqUOnbsqIMHD6pWrVpasGCBoqKifB0WAAAAgHxm27Zt6ty5s+Lj49WhQwd98803Cgnxzs+ClxP/f/q8a0lRRSNCFBYSbNYpEh6qIFuKLielKiwkWGEhwSoS5lBcQpIuXkmV4ZAchqEI+9W/RReym+sWCgshKQoAAHgNVxWAh1JSUtS/f38tXrxYhQsX1oIFC1SnTh1fhwUAAAAgn4uLi1Pnzp31559/qmLFilq4cKFKlSrl67AAAAAA5EOrVq3SuXPn1Lx5c82dO1dhYWFeadfhMJSYcjUx6sr/ptKL/F9yU1qFwkIUFhKky0mpSkp1KCQ4SMULhSs8NEVXklIVEmRT4bBQOQxDhsNQhD1EkWHBTJ8HAAC8isQowAMOh0NDhw7V7NmzFRYWph9++EFNmjTxdVgAAAAA8rkrV67ozjvv1KZNm1SqVCktWrRIlSpV8nVYAAAAAPKpRx99VCVKlNBtt92mQoUKea3dK8mpMiQlpTiU4jBks12d9s6VkOAgFY0IksMwrk6jl+JQobAQJaU6ZBiSYRgqFB6iQmEhKhIR6rU4AQAAriExCnCTYRh65plnNHnyZAUHB+vbb79V+/btfR0WAAAAgHwuOTlZffv21fLly1W0aFEtWLBAtWrV8nVYAAAAAPK5u+++2+ttJqZcnTov4X+jRoWFBCnIZstyvSCbTZH2EEX+b8Y8e3CQElMcCgsNUqQ9RMkOw+uxAgAASBJjUQJueuONN/Tee+9JkiZNmqTu3bv7OCIAAAAA+Z3D4dCDDz6oH3/8UeHh4frxxx/VsGFDX4cFAAAAABlyGFcTmBz/S2TK7rR39pAgSzvX2gUAAPA2RowC3LBp0ya99NJLkqQJEyZo4MCBPo4IAAAAcM+5c+e0cuVKHTlyRBcuXFC5cuVUo0YNNW/eXEFB3Cvja19//bWmTp2qkJAQzZw5U23atPF1SAAAAADg0rX8pWv/uzNaVEaurZa2PQAAAG8jMQpwQ6NGjfThhx/q5MmTGj58uK/DAQAAALK0f/9+PfPMM/rxxx+VlJSU7u/ly5fXY489plGjRikkxDddw6NHj6pOnTq6cOGCuaxy5crav3+/T+LxhXvuuUcbN25UkyZN1LVrV1+HAwAAAACZstkkGf+f2JTdkZ6urXatnWzmVwEAAGSJxCjATY899pivQwAAAADcMnfuXA0cOFBxcXEu6xw9elQvvfSSvv/+e82bN0+lS5fOwwivGjZsmCUpqiAKCgoyp+wGAAAAAH8XZLMpVYaCgmxSqqHkVIfCQ4M9bicpxXG1vSCb2S4AAEBuIDEKAAAAAALImjVr1K9fPyUmJprL2rVrp06dOik6Olp79+7VV199pWPHjkmSNmzYoO7du2vp0qUKDw/PszhnzpypuXPn5tn2AAAAAAA5FxYSdDUZKiRYickOJaY4VMgwPEpschiGklKvJkaFhwSb7QIAAOQGrjIAAAAAIEAkJCRYkqLsdrumT5+upUuXatSoURo6dKjGjRunv//+W7169TLXW7t2rV555ZU8i/P8+fN64oknJEnh4eGqWrVqnm0bAAAAAJB9EaHBskmyhwQpJMgmw5CuJKV61MaVpFQZhhQSZJM9JEi2/7ULAACQG0iMAgAAAIAA8Z///EeHDh0yy6+99pruueeedPXCw8M1ffp01a9f31z273//W0eOHMmTOEeOHKnjx49Lkl588UVVqlQpT7YLAAAAAMiZoCCbwv43ytO1ZKbLSalKTHEvOSoxJVWX/5dIFWG/NlpUsDmlHgAAgLeRGAUAAAAAAcAwDE2YMMEsV6hQQSNHjnRZ326366233jLLCQkJ+uSTT3IzREnSkiVL9MUXX0iS6tSpo+eeey7XtwkAAAAA8J7IsKsJTeH2YIWFXv2pMe5KiuITU+QwjAzXcRiG4hNTFHclRZIUFhqk8P8lVl1rDwAAIDeQGAUAAAAAAWDDhg2WEZ8eeOABhYSEZLpOx44dLaM1zZkzJ9fik6QrV65o6NChkiSbzaZPP/1Udrs9V7cJAAAAAPCu0OAgFQq72t8sGh5qJkddTkrV2fgkxV1JVkLy1VGkEpJTFXclWWfjk8yRosJCg1Q0PFSSVCgsRKHB/FwJAAByD1caAAAAABAAfvrpJ0u5Y8eOWa4TFBSkW2+91SzHxsZq//793g7N9Morr2jv3r2SpMGDB6tVq1a5ti0AAAAAQO4pHBZijvhUNDxURcJDFBJkk2FIiSkOXUy4OjrUxYQUJaY4ZBhSSJBNRcJDzKSoCHuwCodlfkMPAABATpEYBQAAAAABYMuWLebjkJAQNW7c2K31WrRoYSlv3brVq3Fds2nTJr333nuSpDJlymjcuHG5sh0AAAAAQN6Iigg1R44KDw1WdCG7oiKujiAVGmxTSJBNocE2hYUGKSoiVNGF7GYyVaGw/0+QAgAAyE0kRgEAAABAANi5c6f5OCYmRuHh4W6tV716dUt5x44dXo1LklJSUjR48GClpl6dNuHdd99VdHS017cDAAAAAMhbhcNCVLyQXeEhwbJJsodcnSavWKRd0YXsKhZpV9HwUNlDgmSTFB4SrOKF7IwUBQAA8gxXHQAAAAAQAP7++2/zcaVKldxeL21d53a8Zfz48dq8ebOkq1P89e/f3+vbAAAAAAD4RmhwkKIig+RwhOhKcqoSUxxyGIYMQ7LZpCCbTWEhQYoIDVZQkM3X4QIAgAKGxCgAAAAAyOeuXLmilJQUs1y8eHG31007ctPFixe9Fpck7d69W6+99pokKSIiQh9//LFX23fHyZMnderUKY/W2bNnTy5FAwAAAACBKSjIpkJhISoU5utIAAAA/h+JUQAAAACQz126dMlSdncaPelqslJmbeWEYRgaPHiwEhISJEmvvPKKqlWr5rX23fXRRx9pzJgxeb5dAAAAAAAAAIBvkRgFAAAAAF70559/5lrbpUuXznA0qGuJR9fY7Xa32wwLs97Ke+XKlewFl4GJEydqxYoVkqR69epp5MiRXmsbAAAAAAAAAICskBgFAAAAAF5Uu3btXGv7zTff1D/+8Y90y9OOEJWUlOR2m4mJiZZy2hGksuvo0aMaNWqUJMlms2nixIkKDQ31StsAAAAAAAAAALiDxCgAAAAAyOcKFy5sKacdQSozaUeISttWdg0bNkwXLlyQJD388MNq3ry5V9rNjscee0x9+vTxaJ09e/aoR48euRMQAAAAAAAAACBPkBgFAAAAAPlcRESEQkJClJKSIkk6d+6c2+ueP3/eUi5SpEiO45k5c6bmzp0rSSpXrpzGjh2b4zZzonTp0ipdurRPYwAAAAAAAAAA5D0SowAAAADAiwzD8Ml2q1atqt27d0uSDh486PZ6Bw4csJSrVauWoziSkpL0xBNPmOUJEyYoKioqR20CAAAAAAAAAJAdJEYBAAAAQACoU6eOmRh1+PBhJSQkKDw8PMv19u7dm66dnLh8+bKOHz9ull944QW98MILma5z5MgRy+MaNWpY4vnhhx9yFBMAAAAAAAAAoGAiMQoAAAAAAkCDBg30/fffS5JSUlK0ceNGtWrVKsv11qxZYynXr1/fq3GlTbzKSkpKimWdwoULezUeAAAAAAAAAEDBEeTrAAAAAAAAOdelSxdLeeHChVmu43A4tHjxYrNcp04dVa1a1euxAQAAAAAAAADgCyRGAQAAAEAAaNq0qcqXL2+WJ0+erJSUlEzXWbhwoQ4ePGiWe/bsmeM4ihUrJsMwPPrXtm1bc/3KlStb/rZ58+YcxwQAAAAAAAAAKJhIjAIAAACAAGCz2TR8+HCzfPjwYb377rsu6ycnJ+u5554zy+Hh4XrkkUcy3Ua7du1ks9nMf/v3789x3AAAAAAAAAAA5BYSowAAAAAgQDzxxBOKiYkxyy+//LK++eabdPUSEhLUv39/bdu2zVw2bNgwVahQIU/iBAAAAAAAAAAgL4T4OgAAAAAAgHdERETom2++UYcOHZSYmKikpCTdc889mjhxojp37qxixYpp7969+uqrr3T06FFzvSZNmuj111/3YeQAAAAAAAAAAHgfiVEAAAAAEEBatWql6dOna+DAgbp06ZIkaenSpVq6dGmG9Rs1aqQff/xREREReRkmAAAAAAAAAAC5jsQo5GuJiYmW8p49e3wUCQAAgO9Ur15d4eHhvg4DfuSuu+7STTfdpJEjR+qnn35SUlJSujrlypXTo48+qn/84x8KDQ31QZT+jb4GAAAAfQ3A2+hnAAAA5H0/w2YYhpFnWwO87Pvvv1ePHj18HQYAAIBPbd++XXXr1vV1GPBTZ8+e1cqVK3X48GFdvHhRZcqUUY0aNdSyZUsFBQX5Ojy/RV8DAACAvgbgbfQzAAAA8r6fwYhRAAAAABDAihcvru7du/s6DAAAAAAAAAAA8hy3BwMAAAAAAAAAAAAAAAAIOEylh3zt/PnzWr58uVmuWLGiwsLCfBgRfG3Pnj2WoYjnzp2rGjVq+C4g5BvsO8gO9htkl7f3nbyejxsoCOhr5A3OpWAfAPtAwcb77//oawDeRT+jYOE8B19i/4Mvsf8hK3ndz2AqPeRrxYoVY1oQZKpGjRp5Oj8pAgf7DrKD/QbZxb4D+B/6Gr7B8RDsA2AfKNh4/wEEOvoZBRvnOfgS+x98if0PvsZUegAAAAAAAAAAAAAAAAACDolRAAAAAAAAAAAAAAAAAAIOiVEAAAAAAAAAAAAAAAAAAg6JUQAAAAAAAAAAAAAAAAACDolRAAAAAAAAAAAAAAAAAAIOiVEAAAAAAAAAAAAAAAAAAg6JUQAAAAAAAAAAAAAAAAACDolRAAAAAAAAAAAAAAAAAAIOiVEAAAAAAAAAAAAAAAAAAg6JUQAAAAAAAAAAAAAAAAACDolRAAAAAAAAAAAAAAAAAAJOiK8DAABvKlWqlF599VVLGXAH+w6yg/0G2cW+AwBXcTwE+wDYBwo23n8AQCDjPAdfYv+DL7H/wd/YDMMwfB0EAAAAAAAAAAAAAAAAAHgTU+kBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCG+DgAAsuPs2bPatm2bdu3apbNnz0qSihUrpmrVqqlp06aKiorycYTIC7Gxsdq6dauOHj2q4OBgxcTEqHHjxqpatWqexuFwOLRmzRrt3btXx44dU1RUlGJiYtS6dWtFR0fnaSxwzTAM7d27V9u3b9ehQ4cUFxenyMhIFS9eXA0aNFD9+vUVHBzs6zABtyQlJWnlypXav3+/Tp06peLFi6tixYpq27atIiMjfR0egALm3LlzWrlypY4cOaILFy6oXLlyqlGjhpo3b66goLy7H+vgwYPavn279u3bpwsXLigsLEzR0dGqW7eubrrpJtnt9jyLJT8qKNfWnEMz5uv3PykpSTt37tSOHTt0/PhxXb58WUWLFlWZMmXUuHFjVatWLU/iKMh8vQ/klfj4eK1YsUKHDh3S2bNnVapUKVWpUkVt2rRRaGior8MDAADwmoJyfQcAbjEAIB9wOBzG6tWrjREjRhj169c3bDabISnDf0FBQUaXLl2MJUuW5GpMlStXdhlDZv+GDRuWq3EVBDNmzDBuuOEGl69xixYtjKVLl+Z6HMnJycY///lPo3z58hnGYbfbjV69ehn79u3L9ViQsbi4OGPatGlG3759jVKlSmX62YyOjjZGjBhhHD16NFdiWbp0abaOGZKMDRs25EpMyFx236/x48fnWkyXLl0yRowYYRQvXjzDbRcuXNh48MEHjVOnTuVaDABwzb59+4xevXoZdrs9w2NS+fLljX/+859GcnJyrmw/ISHBmDt3rjFo0CCjYsWKmR6bIyMjjSFDhhi7du3yaBv+eC7wtoJybc05NGO+fP8PHz5sTJgwwejYsaMRGRmZ6WeqRo0axrvvvmskJCS43f7kyZOz/RkuSPuBL/eBvOwjnTp1ynjwwQeNQoUKZdhe8eLFjREjRhjx8fG58lwBAADyir/08QDAn5AYBSBfuPfee7P1RdnQoUONpKSkXImJxKi8l5KSYgwaNMit1zkoKMh4+eWXcy2W48ePG40bN3YrlqJFixpz587NtViQsbi4OCM8PNzjz2jx4sWN2bNnez0eEqPyn+y+X7n1Y/iff/5p1KxZ060YypYta6xZsyZX4gAAwzCMOXPmGEWLFnXrmNSkSRPjxIkTXo8hJibG42N0RESE8fHHH7u9DX87F3hTQbq25hyanq/f/19++SXTG55c/atbt64RGxvr1jZIjMqcr/cBw8i7PtLq1auNsmXLutVuzZo1jb/++svrzxUAgMwMHDgwW+fDunXr+jp0+BF/uL5DwZTda/r88N0JAgdT6QHIFy5dumQpFy1aVC1atFDTpk1VpkwZ2e12HTx4UPPnz9emTZvMehMnTtTZs2f13XffyWaz5Vp80dHRKl68uFt1S5UqlWtxBLqnn35aU6ZMMcuRkZG69957deONNyopKUnr1q3TrFmzlJycLIfDoddff13R0dF6+umnvRrHlStX1L17d23cuNFcFhMTo/vuu0/Vq1fXmTNn9PPPP2vFihWSpLi4OPXr109LlixR8+bNvRoLXEtNTVVCQoJlWbVq1dS2bVvVqlVLJUuWVEJCgrZt26ZZs2bp9OnTkq5O1dmnTx/NmDFDPXv2zLX4KleurJAQ9y7FwsPDcy0OuKd06dIqUqSIW3VzYwrNU6dOqUuXLvr777/NZTVr1tQ999yjihUr6vjx45o1a5Y2b94sSTp+/Li6deumtWvXqkaNGl6PB0DBtmbNGvXr10+JiYnmsnbt2qlTp06Kjo7W3r179dVXX+nYsWOSpA0bNqh79+5aunSpV89pafsI16Zbu+GGG1SqVCklJyfrr7/+0uzZs3Xo0CFJV6/jHn30USUnJ+uJJ57waHu+Phd4W0G5tuYcmjFfv/+XL1+WYRhmOSgoSA0aNFDr1q1VuXJlRUdH69y5c1q7dq2+//57JSUlSbo6Hcgtt9yiVatWefz+VK9e3e26BWGKbV/vAxnJjT7S7t27deedd+rMmTPmsoYNG+quu+5SmTJldPDgQX399dfas2ePWb9Lly5au3atSpYs6fmTAAAA8BF/vL4DAL/h68wsAHBH9+7dDUlGp06djJkzZxqJiYku686cOdMoUqSIJev4888/93pMziNGvfrqq15vH1bz5s2zvKd16tQxDh48mK7e5s2bLdNvBAUFGVu3bvVqLM8884wllt69e2c4pcO0adOM0NBQs17FihWNK1eueDUWuHbu3DlDujqqwFNPPWVs2bLFZd34+HhjyJAhlvc1Ojraq3eKp70bmikW/Z/z+zV58mSfxtK7d29LPMOHDzdSU1PT1Xvrrbcsoy80bdrUB9ECCGRXrlyxTFtnt9uN6dOnZ1ivV69elmPXs88+69VYoqKijLCwMOOhhx4yVq1a5bJeUlKS8eqrr1piCQ0NNXbu3JnlNvzpXOBNBenamnNoev7w/s+ZM8eQZFStWtUYO3ZsptNZHzhwwGjevLkl5tatW2e5jbQjRuH/+cM+YBh500dq0qSJ2b7NZjPefvvtdHVSU1ONJ5980hJLnz59vB4LAACuOI8YFR4eblSvXt2tf507d/Z16PAT/nJ9h4LJed8rXbq028ew3PjtFnCFbwUA5AvvvfeesX79erfr//LLL5YTcdWqVb0eE4lReSc1NdWoX7+++XpHRkYae/fudVl/9erVRlBQkFn/jjvu8Foshw4dskzPdsMNN2Q6XeObb75p2Rcz+hIWuePixYvG888/b5w5c8btdfr37295v8aMGeO1eEiMyn/85cfw9evXW2LJ6kuvhx9+2FJ/5syZeRQpgIJg/PjxlmPM2LFjXdZNTEy0XMOFh4cbhw8f9loszz33nHHo0CG36z///POW2B944IEs1/GXc4E3FaRra86h6fnL+7969Wrj008/zfT9dhYXF2fUqlXL8v4sX74803VIjMqYv+wDhpH7faQZM2ZY2n/kkUcyrX/77bdbkqiY0hwAkFecE6Patm3r63CQz/jT9R0KpkD87gSBJ0gAkA889dRTatKkidv1O3bsqI4dO5rlffv2aceOHbkRGvLA4sWLtW3bNrP85JNPqlq1ai7rt2jRQn369DHL8+bNM4fFz6mPP/7YMj3bW2+9pdDQUJf1n3nmGcXExJjl999/3ytxIGuFCxfWG2+84fY0l5I0fvx4y7Sb8+bNy43QAI9MmDDBUn733Xczrf/mm28qIiLC5foAkF2GYViOKRUqVNDIkSNd1rfb7XrrrbfMckJCgj755BOvxTNu3DhVqFDB7fqvvPKKoqKizHJBPc8XpGtrzqHp+cv736JFCw0dOjTT99tZkSJF9Oqrr1qWFdTPcE75yz6QF9577z3zcUREhN544w236xuGQf8dAADkCwXp+g4AsovEKAABq0OHDpby3r17fRQJcmrOnDmW8uDBg7NcZ8iQIZby3LlzvR5L5cqVLQl4GQkJCdEDDzxglg8dOqSNGzd6JRZ4X/ny5VW7dm2zzHEDvpacnKyffvrJLLdu3VrXX399putER0erV69eZnnNmjU6efJkrsUIoODYsGGDjhw5YpYfeOABhYSEZLpOx44dValSJbOc9rouL4WHh6tly5Zm+dSpU7p48aLP4vGVgnJtzTk0Y/70/nuKPr535Od9wBPHjx/X2rVrzXLv3r0VHR2d6Tq1a9dWq1atzPK8efOUnJycazECAAB4Q0G5vgOAnCAxCkDAKly4sKUcHx/vo0iQU84/aFSvXl3Vq1fPcp3WrVsrPDzcLHvjbuJ9+/Zp586dZrlDhw6W0YVcue222yxl7mz2b87HDo4b8LVVq1bpwoULZjmrH4yvcT7uOBwOzZ8/3+uxASh4nK/JJPeOSUFBQbr11lvNcmxsrPbv3+/t0NxGH6HgXFtzDs2Yv7z/2cHn1zvy8z7giZ9//lkOh8MsZ+cYcP78ea1evdrrsQEAAHhTQbm+A4CcIDEKQMDat2+fpVy2bFkfRYKcOH/+vA4ePGiWmzVr5tZ6drtdjRo1Mstbt27NcSxbtmyxlN2NpWnTppbRFLwRC3KP84+1HDfga9k97rRo0cJS5rgDwBucj0khISFq3LixW+v50zHJuY8QFBSkUqVK+SwWXyhI19acQ9Pzp/c/O+jj51x+3wc8wTEAAAAUBAXp+g4AcoLEKAABy3n4ULvdroYNG+batn755RfddtttKleunMLCwhQVFaVq1aqpe/fuevfddwNu+oW85HwXuSTVqFHD7XWd74w4d+6cjh8/7pNYwsPDVb58ebO8Y8eOHMWB3LNq1SrL57V58+a5tq0XXnhBN954o6Kjo2W321W6dGndcMMNevjhhzV79mylpqbm2rbhuWnTpqlNmzYqXbq07Ha7ihcvruuuu059+/bVJ598ori4uFzZbnaPO1WqVFFwcLBZ5rgDwBucj0kxMTGWu0szk/ZuVV8dkw4ePKhNmzaZ5aZNm1qOlVnx1bnAmwrStTXn0PT86f3PjtmzZ1vKnl6rP/TQQ6pTp46ioqIUFhamsmXLqlGjRnryySe1cOFCb4bqt/x9H/BmH8n5uQYHB6tq1apurecv5ywAAAB3+Pv1HQD4CxKjAASk2bNna8+ePWa5U6dOKlq0aK5tb+3atfr11191/PhxJSUlKS4uTvv27dMPP/ygkSNHqnLlyho5cqQSExNzLYZA9ffff1vKlSpVcnvdtHXTtuWrWHIaB3LPW2+9ZSnffffdubatr7/+Wlu2bNH58+eVnJysU6dOadu2bZo4caJ69eql6667Tt9//32ubR+e+fXXX7Vy5UqdOnVKycnJOnfunHbv3q3vvvtOjz76qCpVqqQ333zTMl2HNzgfL4KCglShQgW31gsJCVG5cuUybAcAssv5WOLLa7Lsevvtty3HaU/P8746F3hTQbq25hyanj+9/566dOmSPvroI7Nst9vVvXt3j9r44osvtHPnTsXFxSkpKUknTpzQ77//rn//+9+6/fbb1aBBg4CfNs3f9wFv9pGc4ytfvrzbibAVKlRQUND/f2UeSMcAAED+sG/fPvXu3VtVq1ZVZGSkChUqpIoVK6pdu3Z65ZVXtH37dl+HCD/i79d3KHgC4aYyBCYSowAEnDNnzujxxx83y0FBQXr55ZdzfbsRERGKiYlRTEyMwsLCLH9LSEjQu+++q+bNm+vUqVO5HksgSXuRVLx4cbfXjY6OtpQvXrzoF7EkJyeTJOeHvv76a/34449m+cYbb/T4xxZPRUdHq3LlyipZsqTly3fpake0R48eevHFF3M1Brjv2hdRZcuWVWhoqOVvFy5c0AsvvKBOnTrpypUrXtum83GnSJEilqmDsuJ83Mnp8Q8Arly5opSUFLPsy2uy7Fi1apU+/PBDs1y+fHkNGTLE43Z8cS7wpoJ0bc05ND1/ev89NXLkSB07dswsP/LIIx5PpWez2VSiRAlVrlw53fORrk4f0q5dO33yySc5jtdf5Yd9wFt9JOfn6snzDA0NVaFChcxyIB0DAAD5w8GDBzVr1izt379fV65c0eXLl3X48GEtX75cr7/+um644QbdeeedOnLkiK9DhR/ID9d3KFgC4aYyBCYSowAElJSUFN1zzz2WL0yffPJJNW7c2OvbCg4OVteuXfX5559rz549io+P1+HDh3X48GHFx8dr48aNGjZsmOx2u7nOH3/8oe7du5MU44FLly5Zyu5O2SJdTVbLrK38HAu8KzY2VkOHDjXLISEh+uyzz9J9EZ9TJUqU0BNPPKEFCxbozJkzOnv2rPbv369Tp07p7Nmzmj17tlq2bGlZ54033tAHH3zg1TjgHrvdrrvvvltff/21Dh48qEuXLungwYM6duyYLl26pJUrV+q+++6TzWYz11m0aJHuu+8+GYbhlRicjxWeHHMk63GHYw6AnMrP10HHjh1T3759LV+6ffjhhypcuHCW6/rDucCb/Ol9zO1YOIem50/vvyf++9//auLEiWa5UqVKev31191at0KFCho1apSWLVumCxcu6PTp09q/f7/Onj2rU6dO6b///a/q169v1k9JSdGwYcM0d+5cbz8Nv+CP+0Bu9ZE4BgAA8rOQkBCVKVNGlSpVStdvMQxDP/74o2688Ub99ttvPooQ/sIfr++A/H5TGQKT+7fLAYCkP//8M9faLl26tEfZ7Bl5/PHHtWjRIrPcqFEjjR07NqehZWjt2rUqVapUhn8LDg5Wo0aN1KhRIw0aNEhdu3bVyZMnJUm//fabPvjgAz377LO5ElegSUhIsJSdE82yknbkrpxeZPlTLPCeY8eOqWvXrpaO39ixY72eUNmoUSMdPnzYZec0KipKPXv2VI8ePfSvf/3LMtLdc889p549e6pixYpejQmZO3z4sMvjvN1uV6tWrdSqVSvde++96tWrly5fvizp6nSuM2fOVJ8+fXIcg/Nxx5NjjmQ97nDMAQKLL67J8+t10KVLl9StWzcdPXrUXPb444+rR48ebq3vD+cCb/Kn9zG3Y+Ecmp4/vf/uWr58uWV0t9DQUH3zzTcqWrRoluveeeeduv/++11OoVayZEndf//96tevn5544gl9+umnkiSHw6GHH35YHTp0cCuBMj/xt30gN/tIHAMAAPlNw4YN1bdvX3Xs2FF16tSxnL/27NmjWbNm6d133zV/Zzh9+rTuvPNOrV27VtWrV/dV2PAxf7u+Q8Fkt9vVo0cP9ezZUy1btrRcoyclJWn9+vX69NNPNW3aNPMmsms3lc2cOdNysxmQW0iMAuCR2rVr51rbb775pv7xj39ke/0XX3zR/CJTkqpUqaIffvgh3cWdt7j6gSStxo0ba+7cuWrZsqV5wh87dqyeeuqpdJnSSC/tF6RJSUlur5t2ZK60d0B4IxZ378DwdizwjrNnz+r222/XgQMHzGVDhw7VyJEjvb6tIkWKuFXPZrPppZde0pEjR8xpPBITE/XWW2/p3//+t9fjgmvuHuc7deqkL774Qv369TOXvfbaa175Mdz5GOPJ8U+yHnc45gCBxRfX5P50TeauhIQEde/eXZs2bTKXdenSRe+9957bbfjDucCb/Ol9zO1ra86h6fnT+++OTZs26c477zTjtNls+uKLL9S8eXO31nf3xqvQ0FB9/PHHOnTokObPny9JOnnypD799NNc6Rf4kr/tA7nZRwoPDzeTVTkGAADc4cubwsePH59p36NGjRoaNWqUHnjgAfXo0cMcKer06dN68skn9dNPP3k9ZuQP/nZ9h4Ip0G4qQ2BiKj0AAeHNN9/UG2+8YZZjYmK0ePFilS9f3odR/b/mzZtbTuxnz57V6tWrfRhR/pH2Dt20d0BkJu0dDjm929efYkHOxcXFqVOnTtq2bZu57N5779XHH3/sw6j+3z//+U9LZ/THH3/0YTTISt++fdW0aVOzvH37du3fvz/H7TofKzw55kjW4w7HHAA5ld+ug5KTk9WnTx8tWbLEXNa+fXvNnDlTISG5c49Ybp0LvMmf3sfcjoVzaHr+9P5nZdu2bbr99tsVFxdnLvvoo49033335cr2bDabxo8fb1kWiNff+WkfyIgnfSSOAQAAT9WuXTvX/jlPC5wRd2/IKF26tH788UfFxMSYy+bPn2+5GQQFS36/vkNg8PSmMmevvfZaboQEpENiFIB877333tMLL7xglsuUKaPFixerWrVqPowqvbvuustSZv5v96SdIuHcuXNur3v+/HlL2d27UXM7ltDQ0FwbyQzuuXTpkjp37qwNGzaYy3r37q0vv/xSQUH+cXlUokQJtW3b1iwfOHBAx44d82FEyEpuHOedjzuXLl1SSkqK2+s6H3dyevwDgIiICEtCkS+vybKSkpKifv36ad68eeayVq1a6ccff8z1O2D9/Zq/IF1bcw5Nz5/e/8z8+eef6tChg86cOWMumzBhgh555JFc26Yk1alTR9dff71ZXrt2ba5uzxfyyz7giid9JOfn6snzTE5OVnx8vFkOpGMAACAwlChRQi+++KJlWSAmdMM9+f36DgVPfripDIHJP375A5BvGIaRa/+yM43ef/7zH40YMcIslyxZUosXL1atWrW8+bS9Im1M1+YCR+aqVq1qKR88eNDtdZ2nR5OU42Q5b8Xib0l7Bc3ly5fVtWtXrVmzxlx25513avr06QoODvZhZOlx3MhfcuP9cj7upKam6siRI26tl5KSoqNHj5pljjtAYPHVNbnzMcmX12SZSU1N1X333afZs2eby26++Wb99NNPKlSoUK5t9xp/P3cXpGtrzqHp+dP778ru3bt1yy23WD4748aN0/Dhw3Nle2k5f4YTExN14cKFPNluXskP+0BW3D3OOj/Xo0ePKjU11a32Dx8+LIfDYZYD6RgAAAgcPXv2tJT97YYM5J1AuL5DwePvN5UhMJEYBSDf+vTTT/XEE0+Y5eLFi+vXX39V3bp1fRiVa2nvTr82hy4yV6dOHUt5z549bq+7d+9e83F0dLTKli3rk1gSEhIsP66kbQd558qVK+rWrZtWrFhhLuvcubNmzJih0NBQH0aWMY4b+UtuvF/ZPe7s37/f8uMPxx0A3uB8LDl8+LDbQ/Q7X5OlbcebHA6HBg0apG+//dZc1rBhQy1YsCDdXbS5xd/P3QXp2ppzaHr+9P5n5O+//9Ytt9xiGQHotdde03PPPef1bbni75/hnPL3fcAd7r5Hzs81JSXF7bvQ8+qcBQDwP/52U3hmypYtq6ioKLPsbzdkIO8EwvUdCh5/v6kMgYnEKAD50hdffKFHH33ULBcrVkwLFy5UgwYNfBhV5k6cOGEplyxZ0keR5C/FihVTpUqVzLK7meNJSUmWudXr16+f41jS7l/uxrJ+/XrL1B3eiAWeS0xMVI8ePbRkyRJz2W233abZs2fLbrf7MDLXOG7kL7nxfmX3uOM8IprEcQeAdzgfk1JSUrRx40a31suLY5JhGBo8eLCmTp1qLmvQoIEWLVqkYsWKeX17rvj7ubsgXVtzDk3Pn97/tA4cOKD27dvr8OHD5rKXXnpJL7/8ste3lRl//wznlD/vA+5y9z3iGAAACHTOycKBlswN9wXC9R0KnkC/IQX+icQoAPnO1KlTNWTIEBmGIenqHMoLFixQo0aNfBxZ5latWmUppx3iFK516dLFfLx37179/fffWa6zcuVKyygGd9xxR47jqFq1qq6//nqz/Ouvv5r7YWYWLVpkKXsjFngmKSlJvXr10sKFC81l7du31/fff6/w8HAfRpY55+NGaGioYmJifBgNspIbx/mWLVtaRjlx3ocz43zcCQoKshxHASC70h5L3DkmORwOLV682CzXqVPH69fBhmHokUce0eTJk81ldevW1a+//qrixYt7dVtZyQ/X/AXl2ppzaMb85f13dvjwYd1yyy2WaT9GjRql119/3avbyUpSUpI2bNhglmNiYvxyVNmc8sd9wBPu9pE6d+4sm81mlrNzDChWrJhatWqVzUgBAMg9qampOnPmjFkOtGRueCa/X9+h4An0G1Lgn0iMApCvfPfddxo0aJAcDockqXDhwvr555918803+ziyzCUlJenTTz+1LLvtttt8FE3+k3bO9M8++yzLddLW6dGjh9djOXDgQJZfrqakpFh+pKtQoYIaN27slVjgnpSUFPXr108//fSTuax169b68ccf092Z4E8WLFig3bt3m+WWLVsqMjLShxEhM6dOndI333xjliMiIrzyI4rdblfXrl3N8sqVK/Xnn39mus65c+c0a9Yss9y8eXOVKVMmx7EAQNOmTVW+fHmzPHnyZMvIPRlZuHChJdkh7XWdNwwfPlwTJ040y7Vr19aSJUvy/Iu13DoXeFtBubbmHJoxf3r/JenYsWO65ZZbLD/ejBgxQmPHjvXaNtz1xRdf6NKlS2Y5UPvs/rYPeMKTPlLZsmXVrFkzszxz5kydO3cu0/b//PNPS+JV165dAzI5DgCQ/61bt07Jyclm2R9vyEDeyc/XdyiY8sNNZQhABgDkE3PmzDFCQkIMSYYko1ChQsaKFSu81n7btm3NtiUZ+/btc1n38uXLHrU9ZMgQS9vt2rXLYbQFS2pqqlGvXj3Le//333+7rL969WojKCjIrN+1a1eXdfft22d5b9q2bZtpLAcPHjTCwsLM+jfccIORlJTksv6bb75paX/8+PFZPl94T0pKitG3b1/Le9CyZUvj4sWLOW7bk33H02PG0aNHjUqVKlnanzJlSg4jhruSkpKM5ORkt+snJycbnTt3trxfgwYNcll/6dKllroDBw7MtP1169ZZ6nfu3DnT+g8//LCl/owZM9x+LgCQlXHjxlmOMePGjXNZNykpyahfv75ZNzw83Dh06FCm7XtyTW4YhvHMM89Y6teqVcs4duxYdp5authz81zgSwXp2ppzaHr+9P6fPHnSqF27tmWdJ598MrtPzcLT6+/t27cbUVFRlliWLVvmlVj8jb/sA3nRR/r2228t9R999NFM63fq1MlSf/369R7FCABAXkn7fSffGxZsuXl9B3jbyZMnjSJFipj7X0REhHHlyhVfh4UCgMQoAPnC/PnzDbvdbp4oIyMjvf4lpSc/wpQtW9Z46623jKNHj2ba5pEjR4xevXpZ2g0ODjbWrVvn1dgLgh9++MHyOtatW9c4ePBgunpbtmwxYmJizHpBQUHG5s2bXbbr6Zf3hmEYI0aMsKzTp08fIyEhIV296dOnW/bbmJgYLvDykMPhMAYMGGB5r5o1a2bExcV5pX1P9p3Jkycbbdq0Mb7//nsjMTEx03YXLVpkVKxY0dJ2gwYNjNTUVK/Ejazt27fPqF69uvHJJ58YZ8+ezbTurl27jDZt2ljer8jISOPAgQMu1/E0McowDOOuu+6yrPPUU09luE+MHz/esNlsZr1GjRoZDocjy/YBwF2XL1+2XGvZ7Xbj66+/TlfvypUrRu/evS3HrpEjR2bZvifX5C+99JKlbs2aNY0jR47k5OmZcvtc4GsF6dqac2h6/vD+nz171mjQoIGl/rBhw7zx9AzDMIzRo0cbd955p7F48WIjJSXFZT2Hw2F8++23RnR0tCWWO+64w2ux+CN/2Afyoo/kcDiMRo0amevYbDbjnXfeSVcvNTXVGD58uKX9Xr16Zdo2AADe4mmy8NSpUy3nrGLFihnnzp3LneCQb+TW9R2QmUC+qQyBx2YYhiEA8HPVq1e3DK1fuHBhj6c0ePLJJ/Xkk0+6/Hu7du20fPlys7xv3z5VqVIlw7o2m02SFBQUpCZNmuimm25SjRo1VKxYMUlX58ddu3atfvnlFyUlJVnW/eSTT/Twww97FDuuGjZsmD766COzXKhQId1777268cYblZycrLVr12rmzJmWYYTHjx+vZ555xmWb+/fvtwzT2bZtWy1btizTOC5fvqy2bdtq48aN5rKYmBjdf//9qlatms6dO6f58+db9qewsDAtXrxYLVu29OQpIwdWrlypNm3aWJaVL1/e4+nzli9frpiYmHTLPdl3pkyZogceeECSFBUVpVatWumGG25QuXLlVKRIEV2+fFn79u3TokWLtGXLFsu6ZcuW1W+//ebyeATvc35vQ0ND1bx5c914442qWrWqihYtqpSUFB07dkyrVq3SkiVLzOldJSkkJERz5861TN2T1rJly9S+fXuzPHDgQE2ZMiXTmE6ePKmbb75Z+/fvN5ddd911uueee1ShQgWdOHFCs2bN0h9//GH+vXjx4vrtt9903XXXefgKAEDmVq1apQ4dOigxMdFc1r59e3Xu3FnFihXT3r179dVXX+no0aPm35s0aaLly5dneR5295r80KFDqlSpkmVZqVKlVLRoUY+ey7Rp0zKclju3zwX+oKBcW3MOzZiv3//XX39dr7zyimVZtWrVzL62OypUqOCy/dGjR2vMmDGSpNKlS6tly5aqX7++SpcurcKFC+vixYvatWtXuqnZJKlOnTpatWqVoqOj3Y4lP/L1PpBXfaS//vpLzZs3t0yj16hRI911110qU6aMDh48qK+//tqyH1StWlVr165V6dKls2wfAICc6ty5s2rWrKmhQ4eqXr16LutdvnxZ48eP1+uvv67U1FRz+dtvv62RI0fmRajwc7lxfQdkZv/+/erQoYOeffZZ3X333Zn2oXbv3q3BgwdrxYoV5rLIyEjt3Lkz3fc7QK7wdWYWALijcuXKlgzi7Px79dVXM92GJ3enZ2f7UVFRxrRp07z7whQwKSkpxv333+/W622z2Yznn38+yzazc1e7YRjGsWPHjIYNG7oVS5EiRYzZs2fn8NnDU2lH5cnuP1fHAk/vhs7Otps1a2bs3bs3d14guJT2vXX3X/ny5Y2FCxdm2X52RowyDMPYsWOHUb16dbdiKVOmjLFq1aocvhIA4NqsWbOMwoULu3VMatSokXH8+HG32nX3mjy7x+q0/5YuXerV9t09F/iDgnRtzTk0PV+//6+++mqOP7+VK1f2evtdu3Y1Tpw4kY1XNP/x9T6Ql32klStXGqVLl3ar/erVqxs7d+70qH0AAHLCuQ903XXXGffff7/xxhtvGJ988okxefJk45133jHuv/9+o0SJEunOW/fcc0/AjnIKz+XG9R2QGefr/9DQUKNNmzbGk08+abz33nvGpEmTjE8//dQYPXq00aFDB8v0jZKMkJAQY968eb5+CihAggQA8NjIkSPVqFEjhYSEZFm3fPnyevHFF7Vz5071798/D6ILXMHBwfrvf/+rb7/9NtO7Z5o1a6Zff/1Vb7zxRq7FUrZsWa1du1avvfaaypYtm2Edu92uu+66S1u2bFHPnj1zLRb4v0aNGql///6qWLFilnVtNptatGihqVOnatWqVapWrVoeRAhnxYsX12OPPaa6desqKCjry+Xq1atr3Lhxio2N1W233ZZrcdWuXVtbtmzR008/7fLum0KFCmnQoEHatm0bI9QByFV33XWXtm7dqp49e8put2dYp1y5cnrttdf022+/eTzaq6/567nAmwrStTXn0PT86f3PDbfccovuuusut0b8CQkJUceOHfXDDz9o3rx5BWaUIF/vA3nZR2rVqpW2b9+uQYMGKTIyMsM60dHRevrpp7VlyxZdf/31HrUPAIC37Nq1S1999ZVeeOEFPfLII3rggQc0cuRIffXVVzpz5oxZLygoSKNGjdKXX37p0YibCGy+vr5DwZacnKwVK1bogw8+0NNPP62HHnpIDz/8sEaPHq1ff/3VMtJ2+fLlNX/+fL8faRuBhan0ACAHEhMTFRsbq7///ltHjx7VpUuXJF0dBr5UqVJq1KiRqlev7uMoA9f27du1detWHT16VMHBwSpfvryaNGmS54kkqampWrNmjfbs2aMTJ06oSJEiqlChglq3bq3ixYvnaSzwf6dOndL27dt18OBBnT59WleuXFFYWJiKFSumKlWqqGnTpoqKivJ1mPif+Ph4bdu2Tfv379fx48cVHx+v4OBgRUVFqWzZsmratGmGUy3mtqSkJK1YsUL79+/XqVOnFB0drUqVKqlt27YqVKhQnscDoGA7e/asVq5cqcOHD+vixYsqU6aMatSooZYtW7qVVOTv/PVc4G0F5dqac2jG/OX9zw2HDx/Wzp07dejQIZ05c0YJCQmKjIxUsWLFVKNGDTVp0sRlskxB4st9IC/7SPHx8Vq+fLkOHjyoc+fOqVSpUqpSpYratGnjMtEXAIDcNGnSJE2fPl3r1q1TfHx8pnULFSqkPn36aPjw4brxxhvzJkDkW4F8jQ//EBcXp+eff17Lly/Xzp07LclPGalevbqGDh2qoUOHqlixYnkTJPA/JEYBAAAAAAAAAAAAgI84HA7t3r1bu3bt0uHDhxUXF6fk5GQVKVJExYsXV7169XTDDTcoODjY16ECQDoF5aYy5F8kRgEAAAAAAAAAAAAAAAAIOPl/THsAAAAAAAAAAAAAAAAASIPEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAAYfEKAAAAAAAAAAAAAAAAAABh8QoAAAAAAAAAAAAAAAAAAGHxCgAAAAAAAAAAAAAAAAAASfE1wEAAFAQHDx4UFu2bNHp06d1+vRpORwOFStWTGXLllXDhg1VsWJFX4cIAAAAIB+irwEAAADA2+hnAAgkJEYBQADZv3+/qlatmmvtG4aRa20HokOHDundd9/V/PnztWvXrkzrlitXTnfffbcGDBighg0bZmt7Xbt21fz5881yjRo1tHv3bpf1Bw0apC+//DJb28rKq6++qtGjR5tlm82W4zbnzJmjHj165LgdAAAAeI6+hn+hrzHaLNPXAAAAyL/oZ/gX+hmjzTL9DCCwMJUeAABeFh8fryeffFI1a9bUhAkTsuxASNKxY8f0/vvvq1GjRurevbt27tzp0TaPHDmiX375xbJsz549Wr58uUftAAAAAPBf9DUAAAAAeBv9DACBjhGjACCAhIaGqnr16lnWO3v2rM6dO2eWy5cvr4iIiNwMrcA4fPiwunXrps2bN1uWFytWTLfeeqvq16+vUqVKyW6368SJEzp48KAWLVqkffv2mXV/+OEH2Ww2zZ071+3tTpkyRampqemWT5o0SW3bts1wnTJlyri1v+zdu9d8HB4erpiYmCzXKV68uMu/udtGWoULF/Z4HQAAAHgHfQ3fo69xFX0NAACAwEE/w/foZ1xFPwMIbDaDMQQBoMAZPXq0xowZY5aXLl2qdu3a+S6gAHH8+HE1btxYR44cMZdVrFhRr732mu6//34FBwe7XHfbtm0aO3asvvnmGzkcDnXv3t3tToRhGKpRo4b+/vtvSVLVqlXNTklERISOHTumqKiobD8v5yFj27Ztq2XLlvmkDQAAAPg/+hq5g75G7rYBAAAA/0Y/I3fQz8jdNgD4D6bSAwDAC1JTU9WvXz9LB6Jt27batm2bBg0alGkHQpLq16+vadOm6ffff1ft2rU92vayZcvMDoQkTZ8+XWFhYZKkK1eu6Ouvv/aoPQAAAAD+g74GAAAAAG+jnwGgIGEqPQBAtsXGxmrbtm06duyYEhMT1bBhQ3Xs2NGnMV26dEkrV67U4cOHdfr0aRUpUkQxMTFq166doqOjc2277733nmXu60aNGumXX34xL+bd1aBBA61fv16zZs1ye51JkyaZj5s0aaJmzZqpe/fu+u6778y/P/LIIx7FAQAAAPgSfY3/R18DAAAA8A76Gf+PfgaAgoTEKACAS8uWLVP79u3N8r59+1SlShXNmjVLY8aM0bZt2yz127Zta+lEOA81OnnyZA0aNCjb28zKli1b9PLLL+uXX35RUlJSur+HhISoS5cuGj9+vK677ros2/NEYmKi3nnnHbMcFhamr776yuMOxDWFCxfWwIED3ap7/vx5S4fj2noDBw40OxEbN27Utm3bVL9+/WzFAwAAAHgbfQ330NcAAAAA3Ec/wz30MwAUNEylBwDwyBNPPKHevXun60D40iuvvKKGDRvqxx9/zLADIUkpKSn64YcfVL9+ffPi2lumTp2q48ePm+V+/fp5PHRsdk2fPl0JCQmSJLvdrn79+kmSbr/9dpUtW9as53wHBgAAAOCP6GukR18DAAAAyBn6GenRzwBQ0DBiFADAbRMmTNB//vMfSVK1atXUo0cP1ahRQzabTXv27NHRo0fzPKZHH31Un3zyiVkOCQlR586d1bJlS5UqVUpxcXFavXq1vv/+eyUnJyspKUn9+/dXRESEunXr5pUY5s2bZyk//PDDXmnXHc6dg65du6pEiRKSpODgYN17773mXR9Tp07VW2+9JbvdnmexAQAAAO6ir5Ex+hoAAABA9tHPyBj9DAAFDYlRAAC3vf/++5KkMWPG6IUXXlBIiG9PI19++aWlA9GsWTNNnTpV1atXt9R76qmntHPnTnXr1k179+5VamqqBg8erNjYWJUsWTJHMRiGoZUrV5rlwoUL6+abb85Rm+7avHmzfv/9d7M8YMAAy98HDhxodiLOnDmjuXPn6u67786T2AAAAABP0NdIj74GAAAAkDP0M9KjnwGgIGIqPQCAR0aNGqVXXnnF5x2IuLg4DR8+3Cw3atRIS5cuTdeBuKZ27dpavHixoqKiJEknT540O0U5sXfvXp05c8YSR1BQ3pxene+sKFmypLp27Wr5e/369XXTTTdlWB8AAADwN/Q1rOhrAAAAADlHP8OKfgaAgojEKACA28qUKaPRo0f7OgxJ0ueff64LFy5IkoKCgvTf//5X4eHhma5TuXJlPf/882b5s88+U2pqao7iOHHihKVctWrVHLXnroSEBE2bNs0s9+vXT6GhoenqDRw40Hz866+/6tChQ3kSX2aWL18um83m0b927dr5OmwAAADkIvoa6dHX8Bx9DQAAADijn5Ee/QzP0c8A8j8SowAAbuvXr1+WF+p5Zfr06ebjTp06qU6dOm6tN2jQIPPxiRMntHXr1hzF4XxnhSQVK1YsR+25a86cOTp37pxZdu4sOOvfv7/ZuXA4HJo8eXKexAcAAAB4gr5GevQ1AAAAgJyhn5Ee/QwABZFvxwwEAOQrLVq08HUIkqRLly5p8+bNZjntcKuZKVOmjCpXrqwDBw5IktatW2cZmtVTFy9etJQLFy6c7bY84TyEbJ06ddS4ceMM65UqVUqdO3fWDz/8IEmaPHmyXn75ZdlstjyJMyPh4eGKiYnxaB1P6wMAACB/oa+RHn0Nz9HXAAAAgDP6GenRz/Ac/Qwg/yMxCgDgtho1avg6BEnS9u3bLcPF1q1b16P1y5QpY3YiDh8+nKNYihQpYilfunQpR+25Y9++fVqyZIlZHjBgQKb1Bw4caHYi9u/fr8WLF6tDhw65GmNmbr75Zi1btsxn2wcAAID/oa+RHn0Nz9HXAAAAgDP6GenRz/Ac/Qwg/2MqPQCA24oWLerrECSlH+q1Xbt2Hs3tvH79enNd56Fbs6NEiRKW8vnz53PUnjsmT54swzAkXZ2L/L777su0/h133KHixYubZec7MwAAAAB/QF8jPfoaAAAAQM7Qz0iPfgaAgojEKACA20JC/GOgQW9eqF++fDlH65cpU8ZS3r9/f47ay4rD4dCUKVPM8i233JLlkKx2u1333HOPWU47lzcAAADga/Q10qOvAQAAAOQM/Yz06GcAKIj842wAAIAHIiMjLeWKFSvKbrdnq63SpUvnKJbq1aurRIkS5h0fmzZtksPhUFBQ7uQeL1y4UIcOHTLLv/76q8dzaycmJmratGl6/PHHvR0eAAAAkK/R16CvAQAAAHgb/Qz6GQB8i8QoAIBfceduh5IlS1rKM2bM0M0335xbIWXKZrOpdevWmjt3riTp4sWLWr9+vZo1a5Yr2/PWkLGTJk2iEwEAAIAChb5G5uhrAAAAAJ6jn5E5+hkA/AGJUQCAXBMZGWl2Ctwd3vXEiRNZ1qlVq5alfPjwYZ91IqSr811f60RI0sSJE3OlE3H69Gn98MMPZrlUqVIezZGekJCgI0eOSJI2b96s33//XQ0bNvR6nAAAAEBuo6/hXfQ1AAAAAPoZ3kY/A4C/yJ0x8QAAkFSsWDHz8bWL16ysXbs2yzqlS5dW3bp1zfLSpUs9js2b7rvvPpUtW9Ysf/311/rrr7+8vp2vvvpKSUlJZnnevHnas2eP2/9iY2MVHh5uru+tOzUAAACAvEZfw7voawAAAAD0M7yNfgYAf0FiFAAg11x//fXmY3c6B/Hx8ZoxY4Zbbffr1898/NVXX+ns2bOeB+glYWFhGjlypFlOSEjQ/fffb7ng98SlS5f05ZdfplvufNFfvXp1NW3a1KN2o6Ki1KVLF7M8ffp0JSQkZCtGAAAAwJfoa9DXAAAAALyNfgb9DACBicQoAECucR4Kdvny5dq9e3em9UeNGqVz58651fbjjz9uDrkaFxen+++/XykpKR7F580L6Kefflpt27Y1yxs2bFCXLl108eJFj9rZunWrbr75Zs2ZM8eyfN26dYqNjTXL99xzT7bidF7v/Pnzmj17drbaAQAAAHyJvgZ9DQAAAMDb6GfQzwAQmEiMAgDkmv79+5uPU1NT1b9//wzvgkhMTNSzzz6rDz/8UDabza22ixUrpg8++MAsz58/X+3atbNcaGfEMAytXbtWjz32mFq1auXmM8lacHCwvv76a8XExJjLFi9erPr16+urr75Sampqputv375d9913n2666Sbt2LEj3d/TDhHr/Np64o477rDM4c3QswAAAMiP6GvQ1wAAAAC8jX4G/QwAgSnE1wEAAAJXvXr11KtXL82aNUuStHHjRl1//fW67777VLt2baWkpOivv/7SrFmzdPjwYYWEhOiFF17Qa6+95lb7AwcOVGxsrMaPHy9JWr16terVq6cWLVqoTZs2qlixogoVKqSLFy/qxIkT2rZtm9auXasTJ05IkmrVquXV51uuXDmtXbtW3bp10+bNmyVJBw4c0IABAzR8+HB16NBB9erVU6lSpRQaGqqTJ0/q4MGDWrRokf7++2+X7cbHx+ubb74xyzfeeKNq166drRjDw8PVs2dPc1jbpUuXat++fapatWq22suOdevWqUaNGh6v16tXL40bNy4XIgIAAEB+Q1+DvkZG6GsAAAAgJ+hn0M/ICP0MIP8jMQoAkKs+/PBDxcbG6s8//5QknTp1Su+99166ena7XZ999pkqVarkdidCkt566y1VqVJFTz/9tDn/9Zo1a7RmzZos1w0ODnZ7O+6qUKGCVq1apeeff14TJ05UYmKiJOncuXOaMWOGW/ON9+7dW2+++aZZnjFjhmX42uwOOeu8/rVOhGEY+uKLL/T666/nqE1PJCQkaO/evR6vd63zBwAAAEj0NehrpEdfAwAAADlFP4N+Rlr0M4D8j6n0AAC5qkyZMlq5cqUGDhyooKCMTzutWrXSb7/9pgEDBmRrG4899pj27t2rxx57TNHR0ZnWjYiIUIcOHfThhx9q5cqV2dpeVgoVKqQPPvhAu3fv1lNPPaWaNWtmuU5MTIxGjBihbdu2acaMGZa7D5yHhrXZbDnuRHTo0EGlS5c2y1OmTJHD4chRmwAAAEBeo69BXwMAAADwNvoZ9DMABB6bYRiGr4MAABQMp0+f1tKlS3Xo0CGlpKSoQoUKatKkiVsX2e5yOBz6/ffftXPnTp0+fVrx8fEqXLiwypQpo1q1aqlu3boKCwvz2vbcdeDAAW3dulWnTp3S6dOn5XA4FB0drXLlyummm25SxYoV8zwmAAAAIFDQ16CvAQAAAHgb/Qz6GQACA4lRAAAAAAAAAAAAAAAAAAIOU+kBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4JEYBAAAAAAAAAAAAAAAACDgkRgEAAAAAAAAAAAAAAAAIOCRGAQAAAAAAAAAAAAAAAAg4Ib4OAAAQ2JKSkrRhwwYdPnxYp0+f1vnz51W4cGFFR0erVq1aatCggcLDw3O0jYsXL2rt2rU6duyYTp48KUkqXbq0ypYtq2bNmqlo0aLeeCoBzzAMbdu2TXv27NHp06d15swZ2e12RUdHq1KlSmrUqJGio6N9HSYAAAgwNpvNfDx58mQNGjTId8HAK6pUqaIDBw5Ikl599VWNHj3aJ3G0a9dOy5cvlyQNHDhQU6ZM8Ukc+cGgQYP05ZdfSpLatm2rZcuW+TYgwAemTJmiBx54wCwbhuHDaAAAAAAA3kJiFADA6wzD0HfffacpU6ZoxYoVunz5ssu6ISEhatWqle6//37dfffdKly4sNvb+PrrrzVp0iStXLlSycnJGdYLDQ1Vq1at9OCDD+ree++1/PCWFecfB1zFHhYWpmLFiql06dKqXr266tWrpxYtWqhNmzYKCwtze1vXOP94k13Dhw/XhAkT3K6/bt06/fvf/9aiRYvMxDJX6tatq3vvvVf333+/KlSokKM4AQD5T9ofDDMSHh6uqKgoM6m2W7du6tSpk4KCGLAYOTN37lxt3rxZ0tXEm/ySQJWQkKBixYopMTFRknTrrbfq119/dWvdS5cuKTo6WikpKeYyT5LHPvnkEz366KNmeerUqbr33nvdDx6Zck746tGjh2688UafxeKv3DlvZCUqKkrnz5/3TkDIN/bv36+qVau6/LvNZpPdbldkZKRKliypChUqqFatWmrcuLHat2+vatWq5WG0ObNs2TIzGbFYsWJ66qmnfBoPAAAAAAQav/1m+plnnpHNZrP8i4mJUUJCgte20a5du3TbsNlsqlKlist17rrrrnT1mzZtyh1EAPA/ixcvVoMGDdSvXz8tWLAg06QoSUpJSdGyZcv00EMPqXr16vrwww8tP/xkZP369WrcuLHuvfdeLVmyxGVSlCQlJydr6dKluv/++9W4cWOtX78+W8/LVezx8fE6cuSI/vjjD82cOVOjR49Wx44dVbp0aQ0ePFixsbFe25637d27V926dVOzZs00bdq0LJOiJCk2NlYvvPCCqlevrhEjRujs2bN5ECkAeF9e9Dc8kZCQoJiYmHQxPfPMMz6JJycSEhJ04sQJbdiwQZ988om6du2qWrVqMfoIcmzu3LkaM2aMxowZk69G/gkPD1fz5s3N8m+//aakpCS31l25cmW6a2NPPktLly61lG+55Ra310XWru2PY8aMMZP2AOQNwzCUmJioc+fOaffu3Vq6dKk++eQTDR48WNWrV1ejRo30+eefu3289aVly5aZxxJPbnICAAAAALjHL0eM2rFjhz744IN0y1988cUcT7eUU2PGjNHcuXMtiVAbNmzQpEmTNHjwYB9GBgC+98EHH2jEiBFKTU01l9lsNt1www1q3769ypcvrxIlSiguLk4nTpzQH3/8oWXLlpl3z588eVKPP/64WrZs6fJu67lz56p///66cuWKuSw4OFitW7dW69atVa5cOdlsNh07dkyrVq3S8uXLzXh+//13tWvXTl9//bW6d+/u8fOrXLmyQkL+/9RpGIYuXryoCxcupPuyNS4uTpMmTdLkyZP16KOPavz48YqIiPB4m9WrV/d4nVKlSmVZZ/ny5erVq5fOnDljWV6pUiXddtttqlatmkqVKqXk5GSdOHFCu3bt0sKFC81EqKSkJL333nuqVKkSd7MCyHf8sb8RHh6uF154QY8//rhl+QcffKCHHnpItWvX9klcWSldurSKFCliWXblyhWdPHnSksyxZ88e3XrrrZo+fbr69u2b12ECPte+fXszoeny5ctav369WrVqleV6GSVBeZIY5TwSaa1atVSuXDm31wVyQ0bnjawwNTokqUiRIipdurRlWVJSks6fP69Lly6lu2n1999/15AhQzRu3Dh9/vnnatu2bV6GCwAAAADwI36ZGDVixIh0o3+UL1/eLxKP6tevr549e2r27NmW5S+++KL69evn9hRQABBoXn/9db3yyitm2Waz6Z577tHrr7+e6RD28fHx+vbbbzVmzBgdPHgw023MmTNHvXv3lsPhMJf16tVLEyZMcDmt29GjR/XUU09pxowZkq7+WNurVy/NnDlTPXr08OAZXv0RytWogqdPn9b69eu1cuVKTZ48WSdOnJAkORwOffjhh1q3bp2WLl3q8Xliz549HtV3x+LFi9W5c2fLubZZs2YaN26c2rRp43K91NRULV68WKNHj9Zvv/3m9bgAIK/4a39jyJAh+te//qVjx46Zy5KTkzVy5EjNnz/fh5G5Nm7cuAyn9Lpy5YoWL16sl19+2RxFxeFwaMCAAWrcuHG2En8RuArCCMzt27fXq6++apaXLl3qcWJU4cKFdenSJR04cED79u3LdIopSdq5c6d5TXothryyf//+PNsW8hdX5w0gK3fddZfL0QJTUlIUGxur9evXa9asWVq4cKF5brmWnP3ll19mOZXooEGD2D8BAAAAIAD53VR6K1as0C+//JJu+RNPPCG73e6DiNIbOXJkumUnT57Ue++954NoAMD3Fi5cqNGjR5tlu92ub7/9VtOmTcs0KUqSChUqpAcffFC7d+/Wq6++qqCgjE9NBw8e1IMPPmhJiho/frxmzpzpMilKuvpD93fffad33nnHXJaamqoHH3wwy0QsT5QsWVJdunTRm2++qYMHD+o///mPZdSRjRs36u67785ymsDcdvToUfXv39+SEDBixAitWbMm06Qo6erIXB07dtSaNWs0Y8YMRUVF5Xa4AOB1/tzfsNvt6UaMkqSff/5ZK1eu9EFE2RcREaE77rhDa9euVbt27czlSUlJev31130XGOAjN998s2X0UHdGfbp48aI2bdokSYqKirL8oO/O+mnr5GViFADkpZCQEDVo0EBDhgzRggUL9Oeff1r6t9e+A0g7vSgAAAAAoGDwuxGjXn755XTLwsLCNHToUB9Ek7EWLVqocePG2rhxo2X5O++8o+HDhzPEN4AC5fLly7r//vstCUvTpk1T7969PWrHbrdr9OjRatasWYZTKwwePFjnz583y88++6yeeeYZt9sfMWKEjh07prfffluSdO7cOQ0ePFgLFy70KE532O12DRs2TK1bt1a7du107tw5SVd/2H733Xf13HPPeX2b7ho6dKhOnjxplocNG2ZJGnNX7969deONN2rv3r3eDA8Acp2/9zceeeQRvfbaa+Y0s9e88sor+fLHvLCwMH3++eeqVauWObXtvHnz5HA4XCZDpxUfH68VK1bo8OHDOnXqlKKionT33XdnOnXs1q1btWXLFp08eVIOh0NlypRRvXr1dNNNN8lms3nluW3btk1bt27VkSNHFBERoapVq+qWW25RZGRkjto9duyY1qxZo+PHjysuLk4lSpRQtWrV1Lp1a4WFhXkt9i1btujIkSMKDw9XlSpV1L59+2z1ZS9cuKBNmzbpr7/+0oULF+RwOBQZGaly5cqpRo0aql+/vs+TDv2B3W5Xy5Yt9euvv0qSfvvtNyUmJmb6nq5cudL83LRq1Uq33HKLPv30U0lXR5x64IEHMt2mc2KUzWazJCm6cunSJa1cuVKHDx/W6dOnVaRIEcXExKhdu3aKjo7Ocv2cMgxDa9euVWxsrE6fPq2SJUuqSpUqatu2rUJDQ726rfj4eC1dulQHDx5UXFycSpUqpaZNm6p+/fpe3Y4n9u3bpw0bNujEiROKj49XqVKlVKtWLTVv3lzBwcE5anf16tU6evSoIiMjVaFCBbVp00bFixf3YvT+58iRI/rtt9906NAhpaamqly5cmrbtm2mN9a4Iy+O07Gxsdq2bZuOHTumxMRENWzYUB07dnRZf9euXVq3bp2OHj2qwoULm+9xXnxu/dF1112nJUuW6LHHHtPEiRMlXU3O7tu3r/bt26dChQp5dXs7d+7UH3/8YX52w8LCFBUVpcqVK6t+/foqX768V7fnSnx8vLZu3apdu3bp9OnTSkhIULFixVSuXDk1b97cq9Op5tbn6+zZs1q9erWOHTumM2fOKDQ0VKVKlVKdOnV00003KSTE858zYmNjzevCxMRE87qwUaNGXrsuBAAAAODnDD+ybt06Q1K6f/fcc0+ubK9t27YZbq9y5cpZrvvxxx9nuO7bb7+dK7ECgL+aMGGC5Th4//33e30bGzdutGyjZs2axpUrVzxu58qVK0aNGjUsbW3atMll/YEDB1rq7tu3z+Ntzp8/37DZbGYbJUuWNC5evOiyftpzkzdt3rzZ0natWrWMy5cve3UbAODP8rq/kV19+/bNMM6NGzf6OjRj8uTJlpgmT57s1nqNGze2rPf3339b/u58/hs4cKBhGIZx+vRp44EHHjAKFSqU7rVYunRpum0kJycbH3zwgVGxYsUMXz9JRvny5Y3x48cbiYmJWca8b9++DLe5aNEi46abbsqw/cKFCxvPPPNMts6vc+fONRo3bmy5bkjb9vDhw41z585l2dbSpUszvIb59ddfjYYNG2bYvt1uN0aMGGHEx8e7Fe/evXuNfv36GWFhYS5fb0lGWFiY0bFjR2P58uUu28psn0r7Prjz79o+tGvXLsvyjz76yK3nds1ff/2Vo/XT+te//mVpL7PXxDAM49lnnzXrvvXWW8axY8fMcsWKFbPcXpkyZcz69erVy7Tu5s2bjW7duhl2uz3D1zQkJMS48847jb/++sut51q5cmVz3VdffdWtdb766iuXn99SpUoZY8aMMVJSUjxqP6Njy6VLl4wnnnjCKFy4cIbbql+/fqbvzauvvurxPpnRMeua1NRU44svvjCuv/56l+uXKFHCGDNmjMd9oO3btxvt2rVz+dns37+/cerUKcMwrH2ftm3berSdzGT3vOGujNr++++/jTvuuMMIDg7O8Lnfeeed2erb5cVxeubMmUb9+vXTte3qPVm3bp3RtGnTDOMJDw83BgwYYJw5c8YwjKzf4xdeeMGy7tmzZz16fZ5//vkcrZ9W2uP/tc+wJ5KTk41WrVpZ2hk7dqzL+mn318w4HA7j008/NWrWrJnlMaBKlSrGU089ZTgcDksbnh5LMnrfDh48aLz11ltGy5YtjdDQ0EzXb9KkiTF37ly3X7+8/HzNmzfPaNGihREUFOQy/iJFihh9+/Y11q1bl2V7CQkJxttvv21UqlTJZXsxMTHGf/7zH/PcAgAAACBw+VVi1D333JNhJ2XBggUeteNwOIzffvvN+Pzzz40333zT+Oyzz4wlS5YYycnJlno5SYw6f/58hl8YVq5c2UhNTfUoXgDIr1JTUy1fMtlsNmPv3r1e3869995rOdZOmTIl22198cUXlrbuvfdel3W9kRhlGIZxxx13WNp5//33XdbNzcSo++67L1d/lAAAf+et/sY1ly9fNpYuXWpMmTLFePfdd40333zT+Pzzz40FCxZkmgSblfnz52cYZ24kH3squz9wp032SvuDVtrkhc2bNxvly5d3+UNW2iSDkydPGo0aNXL7h8X69esbR44cyTTmjBKjJkyYkOkPdtf+1atXzzh58qRbr83FixeNrl27uh17+fLljdjY2EzbzOgH93HjxrkVe5s2bbJM7Fq8eLERGRnpdsySjBdffNFle5ntUzlJjDIMw5IU0qhRoyzfD2fOiUmRkZHG+fPnPVo/rTVr1ljiHD16dKb1nRMK169fbxiGYdSqVctctmfPHpfr7tixw7KtJ554wmXdl19+2a19Q7qaQPftt99m+Vw9SYxKTU1Nd93t6l+7du2MS5cuZTsx6sCBA0bt2rWz3E5oaKgxZ86cDNv0ZmLU8ePHXSa1ZPSvTp06WR67rpk9e7bLRDfnfxUrVjR27NgRMIlRixYtMooVK5bl8y5fvryxa9cut7aRV8fpxx9/3GWbGb0nEydOdOuzW6lSJbfe43379lmSvv7973+79foYhmGkpKRYztv9+/d3e11XvJEYZRjpb7QqWbKky0QYdxOjEhMTjTvvvNPjY0Ha76Y9XT+j983d46fzv0ceecStZKC8+HxduHDB6NKli0fxZ7Uv7Nq1y62EtWv/2rRpY8TFxbkVLwAAAID8yW+m0jt//rxmz56dbnmxYsV0yy23uN3OtGnT9OKLL+rAgQPp/la6dGk98cQT+sc//pGtYXedRUVF6ZZbbtGCBQssyw8cOKAlS5aoQ4cOOWofAPKDbdu26eDBg2b5tttuU7Vq1by6DYfDoZ9++sksFylSRH369Ml2e3fffbeGDx+uixcvSpLmz58vwzBydfj0p59+WvPmzTPLv/zyi5588slc215GDMPQ/PnzzXJUVJT69u2bpzEAgC95q78hXT13vPvuu1q5cqWSkpIyrGO323XLLbfo1VdfVbNmzTxq/9Zbb1VUVJQuXLhgWT5r1iz95z//yZdTd6ekpFjKmU0Jde7cOfXs2VNHjx5VSEiIunTpolatWqlEiRI6ffq0li1bZln/4sWLatOmjf78809zWfHixdWnTx/Vr19fQUFBio2N1XfffadTp05JunoN07p1a23YsMHtqaQWL16sN954Qw6HQyVKlFDfvn1Vr149ORwObdmyRTNmzDCn/d2+fbtuv/12rVmzRuHh4S7bjI+PV/v27S3TtEdHR6tbt2666aabVLRoUZ04cUI///yzVq5cKUk6evSo2rZtq02bNqlSpUpuxT59+nS9+OKLkqSaNWuqR48eql69ugzD0ObNmzV16lTFx8dLklasWKHRo0dr3LhxGbZ18uRJ3XXXXbp8+bK5rEWLFmrfvr0qVaoku92uixcv6sCBA/rjjz+0atUql58Td4SGhqp69ermtq9dw4WHhysmJibDdcqUKWM+fvjhh80p5TZt2qQtW7aoQYMGWW43OTlZ//3vf81ynz59FBUVld2nIUlq0qSJChcurEuXLkm6OtXdq6++mmHduLg4/fHHH5KuXv82bNhQktS2bVv99ddf5vrXXpu00k692b59+wzrPfroo/rkk0/MckhIiDp37qyWLVuqVKlSiouL0+rVq/X9998rOTlZSUlJ6t+/vyIiItStWzcPnr1rI0eO1JdffmmWg4OD1alTJ3P6vqNHj+qnn37SunXrtGzZMg0bNixb27l8+bK6d++unTt3ym6364477lCLFi1UvHhxHT9+XHPmzNGGDRskXX3/H3jgAd18883ppp4qXry4+bo7TytdunTpDKcEl6SIiIh0y44dO6ZWrVrp77//NpeVK1dOd955p+rWratChQrp4MGD+v7777V582ZJ0o4dO8zPf2bnghUrVqhfv36Wz94NN9ygnj17qmLFijp37pwWL16shQsX6tChQ+rdu7fq1q2bxSvo//78808NHz7cnN6uZ8+euuGGGxQZGak9e/Zo+vTpZv/16NGjGjBggFavXp3p1K55dZyeMGGC/vOf/0iSqlWrph49eqhGjRqy2Wzas2ePjh49aqk/Z84cPfLII5Yp7Rs3bqxu3bopJiZG58+f14oVKzR//nwdPHjQrfe4SpUq6tixo3755RdJ0qRJk/T444+7Ff9PP/1kiXHIkCFurZcXGjVqpNatW5vvz+nTp/X777+rSZMm2W7z1Vdf1Q8//GCWS5QooW7duql+/foqXry4kpOTdebMGcXGxmrVqlXav39/hu1cO5acPXtW586dk3T1OFy5cuUM67s6711TtWpVtWjRQvXq1VOJEiVks9l09OhRrVixQkuWLJFhGJKkTz75RKVLl9aYMWPcfs658fmKi4tTq1attG3bNnNZSEiI2rdvrzZt2qhs2bJKSUnR0aNHtWHDBi1dujTddNNpxcbGql27djp9+rS5rFq1aurWrZuuu+462e127d27V7NmzdLu3bslXT1mdurUScuXL8/xbwYAAAAA/JRv87L+38SJEzO8Y6Nfv35urZ+ammrcf//9bt0F0rhxY+P06dM5GjHKMAzjk08+yXD9AQMG5OCVAID84/3337cc/8aNG+f1bWzZssWyjc6dO+e4zdtvv93S5tatWzOs560Ro5KTk42IiAiznaJFi7q8OzO3RozKjdcRAPKTnPY3DMMwDh8+bLRs2dLju/IffPBBt6Zuc9avX78M2/riiy88fepeld2RP+rVq2dZ7+DBg5a/Z9Q3q1WrVpYjbhiGYTz44IOW9bp27WpOG+Ts3LlzRo8ePSx1+/bt67LdtCNVXBuVo3Pnzhm2f/z48XRTVr300kuZxj5o0CBL/cGDB7sclWjOnDmWUZpuvfVWl+2mHYkkKCjICAoKMt5+++0Mr0H27dtnGYEnLCzM5RRIzqPlhIeHGz///HOmz/HChQvGp59+akyaNMllHXf3qeyMaJOYmGiULFnSXO/xxx93a73Zs2db4lq5cqVb62XF+To0LCzM5dRo8+bNy/C6bdq0aebyzEY+7dOnj1nPZrNluM9OmTLF8hybNWvmchSqHTt2GNWrVzfrli5d2pyCLSPujui0cuVKywg15cqVczlF0rRp08wRkJxHyXF3xKhr69x4443G7t27M6yfdjSoZ5991mXbhuH+vptWamqqceutt1reo5deesnl/vDxxx9bpq168MEHXbaddvpwm81mvPfee+mm8DIMw1i+fLn5+XB+TfPriFHXnsO9996b4bE0Pj7e6NSpk2Wdn376KdP28+o4fe3fmDFj0o0qlNbZs2eN0qVLm+uEhIS4vD7YtGmTOUWlO+/xrFmzLPG4O42v8+hJNWrUcGudrHhrxCjDMIx//vOflrbeeuutDOu5M2JUfHy8pX/frVu3LEcK3bRpkzFgwACX3wM4H3vc/V76msGDBxuDBg0yRxZ0ZfPmzZZRB4ODg10eC6/J7c9X7969LfVbtmxp/Pnnny7rnz9/3vj3v//tchTKy5cvG3Xq1DHbCw0NNT744IMMX/fk5GTjlVdesWz/tddeyzReAAAAAPmX3yRGpZ1m6Nq/iRMnurX+0KFDM1zf1b8mTZq4nGrB3Q7oX3/9leH6JUuWZDo9AAVC2inuXE0RkRNpf8h++eWXc9zmiy++aGnzs88+y7CetxKjDMMw2rRpY2nL1Zd9uZUY9dlnn1nazWpKEwAINDntb/zxxx+WHyE9/de+ffsspydz9umnn2bYTs+ePbP7EnhFdn7g/v333y3rlC9fPl2dtOe/6Ohot6aL2r59u2W9m2++2UhISHBZPzExMV1ym6skjIymcLvppptcJi4YhmHExcUZ119/vVnfbre7nFJv2bJllraHDRuW5fOdM2eOZZ1ff/01w3oZ/eD+9ttvZ9r2L7/84tb1UevWrc06Tz31VJYxu8PdfSq7U30988wzln0rs/fwGudpfa6//nq3t5WVsWPHunX9PHLkSLPO2LFjzeWHDx82l8fExLjcjvPx6sYbb0z39wsXLhhRUVFmnUaNGmX5uuzfv9+yTmaJf+4mRjlfI4eGhhp//PFHpjF8/vnn6fZtdxOjpKvTxrlK+rumRYsWbr3GhpH9xKgvv/zSsu748eOzXGfChAlmfZvN5jKhwbmelPWUjatWrUo3HVt+TYySriapZJQEds2pU6eMokWLmvUzSzDM6+P0qFGjsn7ChpEumePDDz/MtH5sbKwRFhbm1nucnJxslCtXzqz3yCOPZBnP0aNHjZCQkAyPWTnhzcSoJUuWWNpylRjvTmLU4sWLzb+HhIRkmiTqrpwkRrlzTrvm8OHDRnR0tLmtp59+OtP6ufn5Sjt1dLt27Tx6LhkZM2aMpc3vvvsuy3Weeuops36hQoVyPG0uAAAAAP/keizbPJScnKwlS5Zk+Lc2bdpkuf68efM0ceJEj7a5YcMGbdq0yaN10rruuussQ/Rfc/r0aXP4dQAIZCdOnLCUq1atmuvbqFGjRo7brFmzZqbbyA1VqlSxlJ2Hdc+MzWbz+F9G8uK9AgB/ldP+xokTJ3TnnXfq5MmT2Y5h6dKleuKJJ9yu7yquRYsWpZuWzp+dOXNGAwcOtCzr1atXluu9/PLLKl++fJb1Pv74Y0v5o48+UlhYmMv6drtdH3/8seV8+dFHH2W5nWvef//9TKfGK1KkiN555x2znJSUZJmOzZlzvUqVKundd9/Ncvs9evRQp06dzHLa5+/K9ddfrxEjRmRap2PHjpbrlXXr1mVY7/jx4+bj6667zq3t+9rQoUPNx+fOnctwWk1nhw8fNqeSkqTBgwd7LZa0U9qlnfLummvT/0lSu3btzMcxMTHm1EtHjhwxpwFytmPHDsvxKqPpQj///HNzus6goCD997//zXTflqTKlSvr+eefN8ufffaZUlNTM10nM7t27dKKFSvM8tChQ3XjjTdmus5DDz2Uo+mvxo0bp+jo6EzrOO8vR44c0ZEjR7K9PVecP//NmjXTM888k+U6Tz75pGrXri1JMgzDMgWis88++8x8nPY9y0jLli3THadz0wMPPOBx/2bKlClutR0SEqIPP/ww02nSS5YsqbvuusssuzrWSXl7nC5TpoxGjx6dZT2Hw6EvvvjCLNevX1+PPPJIpuvUqVPH7WuQkJAQPfDAA2b566+/1pUrVzJdZ8qUKea1SUhIiAYNGuTWtvJSdvvjGXE+DxYvXlwlS5bMdlvekNWx21lMTIxlX/j555/dXtfbn6/x48ebjyMjI906D2UmISFBH374oVnu27ev+vTpk+V6//rXv8xplePj4/XVV19lOwYAAAAA/ssvEqO2bt2qy5cvp1teqFChdD9ep+VwODR8+HCXfy9evLjGjh2rlStXavny5Xr99ddVtGjRHMd8TYMGDTJcvmbNGq9tAwD81ZkzZyzlYsWKeX0bZ8+e9fo2oqKiMt1Gbkj7A0xebNNZXrxXAOCvctLfkKSnnnpKhw4dyvBvRYoU0QsvvKAlS5ZozZo1mjBhQoY3T0jSpEmTNG/ePLdivu666xQREZFu+aVLl7Rt2za32vCVhIQE7dq1S++//74aNGhgibdo0aJ64YUXMl0/KChIAwYMcGtbP/74o/m4WbNmatiwYZbr1K9f35J49tNPP7m1rdq1a6t169ZZ1uvcubMqVqxoln/44Yd0dS5cuGDZ7uOPPy673e5WHM4/OC9evFiGYWS5zsCBAzP9IfOaZs2amY937tyZYZ3IyEjzcX7p99asWdOSkPT5559nWn/y5Mlmwo/dbvdq0kijRo0s30k4J0Bdc+HCBW3evFmSVLhwYTVq1Mjy97Zt22a6ftplaZOxJGn69Onm406dOqlOnTpuRG/d/06cOKGtW7e6tV5GFixYYCk/9NBDbq3nbr20ChcurN69e2dZz/lzILn+LGTX9u3bLa9bVkmL19hsNsu+uGjRonR1/v77b8XGxprlgQMHunVscU4Gy89uvfVWy/HXFef3eO/evUpOTk5XJ6+P0/369XMrKWT79u06fPiwWX7ggQcUFJT117ueJHgOGTLEbPPChQuaMWOGy7qGYVgStbp16+byOsiXvNkfdz4Pnjx5Unv37s12W77QoUMH8/Fff/2lixcvurWeNz9fp0+ftiQG9+/f3622M/Prr79akoJHjhzp1nqRkZG6++67zXJGx1YAAAAA+Z9fJEa5Grnp+uuvz7Jzv3DhQv39998Z/q1EiRJat26dRo0apVatWqlNmzZ66aWX9Ntvv3ktOap+/foZLs/paFQAkB+k/QKtcOHCub6NQoUK5bjNtHHGxcXluM3c2mb16tU9/peRvHivAMBf5aS/sWPHDn333XcZ/i06Olpr167Vv/71L7Vv317NmzfX8OHDtX79epUtWzbDdf71r3+5FXNQUJDLRAV/6mtkNPJHRESEatWqpaeeesoy0kp4eLjmzJnj8rW5platWipRokSW2z527JgOHjxoljt37ux23HfccYf5+PTp09qzZ0+W69x+++1utW2z2dSxY0ez/Pvvv8vhcFjqrFmzxrKsa9eubrUtSTfffLP5+Pz58/rrr7+yXCdtoocrMTExlrYz4px8NnXqVL3++uuKj493q31fck78WLZsmcvvEQzD0OTJk81y9+7dvToaSHBwsCXBbt26delGY1m5cqWZmNWyZUuFhIRY/u6cGJXRiFPOiVHBwcHpRqC7dOmSmXglebb/lSlTRpUrV7bEn13OI21HRUXppptucms95xG0PNGoUSOFhoZmWc/5cyC5/ixk18qVK83HQUFBltGFsuL8+Y+NjU332Vu/fr2l7O5xq1mzZnl240Tp0qU97t+4+x1edo51hmGYo6c5y+vjdIsWLdxqO+0I9e5+HmrVqpXl+feaKlWq6LbbbjPLkyZNcll3+fLllnOoN0fY8yZvfgeQ9ljVvXv3fDVzQLly5czHhmHo6NGjbq3nzc+X83FQcm800aw4t1m6dGk1btzY7XWdP7M5Oa8BAAAA8F9+kRjl6kvoSpUqZbnurFmzXP7tlVdeyXDKpTp16ui5555zP8BMuLqbxZ0v1gEgvytSpIilfOnSpVzfhjd+eEsbpzdHEnQlbWJS2lGrXNmzZ4/H/zKSF+8VAPirnPQ3pk6dmi6p5Zp33303w+SlSpUquUyAWrt2rSUhITOB1Ndo27atfv/99wyn9ErL3Wlzd+3aZSm7Gs03IzfccEOmbWXE1U0xWdW9dOmSZXQPSdqyZYv5ODQ01KMp6dKOxJG27Yy4+2O48w/Hrq65hg4dahl96pVXXlHZsmV1991369NPP9WOHTvcGh0lr911111mgpNhGC5/6F+8eLH27dtnlocMGeL1WJxHcEpMTNRvv/1m+btzspNzElRGyzIaMWr58uXm44YNG6a71t2+fbtlCry6deu6H7ys+6A7+58rzq/ztSni3FGzZk23EpzSys7nQPJO/8OZ8+e/UqVK6a7TM+P82qempurYsWOWv//555+Wcr169dxu25O6OTFu3DiP+zfOU3NlxpvvcV4fp9099zl/biS5Pdqb5Nln3TmZdMWKFRlO2ylZR+CrWLGiR4l+eSm7/fGMVK5c2ZKMHRsbq6ZNm+qGG27Q888/rwULFmSYDJTb4uPj9c0332jQoEFq1KiRypQpo4iIiHQJ7GlHS3U3+dObn68dO3ZYyp4kMbni/JmtU6eOWyNlXuP8mT1x4kS+mrYaAAAAgHv8IjHK1bQU5cuXz3LdtF8gXhMUFKR7773X5XruTs2QFVcxOt+5DACBKu1oDt6+m1q6OiWqt7eR9kvKtNvIDWnjzottOsuL9woA/FVO+huLFy/OcHlUVJT69+/vcr3evXu7HI0qoxFePInPn/oaGY38UadOHTVv3lx33323xo4dq+3bt2vZsmVuJz64m7B87ty5dLG4K+2P1mnbyogn7ZcqVSrT9p2nuE1OTlZoaGi6Hy5d/XOewsfd2N2ZniktV8lNzZo105tvvmlZdunSJc2YMUOPPPKI6tatqzJlyuiee+7R3LlzM5xCxxfsdrtleqspU6ZYkoOucf6Rv0qVKpYph7wl7dR2aY8JzslOGY0GU7lyZXPUpmPHjllGo9mxY4dlKqGMptFLO8Vyu3bt3N7/bDabZVQid/Y/V5yvR9NOc5WZoKCgbCU1ZOdzILn+LGSX8+u/f/9+j177tEkwaV9/53JYWJhHN4CkPW7lR958j/P6OO3ue+X8uYmIiFBYWJhb60mefc7uvPNOy8hCGSWTnj9/3nLDqrvT+vmCt/vjn3/+ebpktm3btmns2LHq3LmzihcvrqZNm2rMmDEuRyj0pokTJ6pSpUq655579OWXX+r333/XyZMnlZCQkOW67tSRcu/zFRoa6pWRGZ3bXLZsmUfH1i5duljaysm5DQAAAIB/8oveqqvhi7Oa5scwjHR3w11TrVq1TKdfqFixolfmvHc1pVNeTMsEAL6W9ji6f//+XN+GN0bJSHu3qzfOB1lJ+2WoN6dkcUdevFcA4K+y29+QrHefO2vevLnsdrvL9YoWLeryWL9mzZostyvlj75GRiN/xMbGas2aNfr22281atQoj0ejSTttmCtpRz9M+0N0ZtK+tu6MpBgREeG19r2ZoHz58mWvteWuUaNGaeHChWratGmGfz916pS++eYb9ezZU9dff73mz5+fxxFmzHkElKNHj+rnn3+2/P3MmTOaO3euWX7ooYc8GnHCXTfeeKNl2jLnRKjz58+bo8oVKlTI5SgarkaNSptklVFilL/sf4mJieZjT5I7slPfn+Tm6+88MosnxyzJO1OWB5K8/py4e+7Lq89NSEiIHnjgAbP85ZdfphtFZ+rUqWZSTVBQkB588EGP4slL3u6Ply9fXhs3btTIkSMzHPXN4XBow4YNGj16tK677joNHjw4167fnnvuOT388MM6e/Zsur8VK1ZMMTExqlatmpnA7jwdquT95E93OI/g5a1jj7+c2wAAAAD4J/d63bnM1Z0pmf3QIF0d8SOjOzwlqUKFCllut0KFCjpx4kTWAWbC1d0yV65cyVG7AJAfNG3aVNOmTTPL69evz3C6j5xuw9nGjRtz3GbaNm6++eYct5mZ5ORkyzaLFSvm9lQJ3pL2dXS+0x8AAl12+xsXL160/ADpbMGCBdlOmDh+/Lhb9ehrZC5tYpsnP2KlndbFnSQ5T173rNp3TuIKCgpS1apV3W47LU+m4fKm2267TbfddptiY2O1YMECrVixQmvWrNHp06ct9f7++2/dcccd+vzzz33+o3nNmjXVvn17M3lo0qRJuuOOO8y/T5061fzMBwcHW5ICvCkoKEht27bV999/L+nqddnly5cVGRmpFStWmNN3tmjRwuWUcW3bttV///tfSVeToR5++GFJ1iSp0NBQtW7dOt26aZMIK1asmOXx0BVPRlJLy3mEnLTTXGXFnxJEPeX8+oeFhbn1/ZUrac8TzgkGnp4rvD1lYH7nr8dp58+Np9Oje/q5GTJkiMaOHSuHw6Hjx4/rp59+Uvfu3c2/O48iddttt6VLuPEnaWcc8MbUbVFRUXr77bc1ZswYLVy4UEuWLNHq1au1ZcsWyzTMqampmjRpktavX69Vq1Z5NJJbVhYtWqTx48eb5ZIlS+rJJ59Up06dVK9evQwTJPft26dq1ap5LYbscGfqXk85f2YLFSrk9tR/GXE3UREAAABA/uEXV/mu7lhKSkrKdL3MvgBw5844T++ey4irH1m80TYA+Lu0SVCLFy/Ws88+69Vt1K9fX1FRUeb0d6tWrVJ8fHy27yqMj4+3jNQRHR2tevXqeSVWV5YvX245X7Ru3TrPpxioX7++ihcvbt5FumbNGiUkJGR7OHwAyE+y29/IrR/e005j5Qp9jcylnRLIefqwrKSt6870Qp60f+rUqUzbdx6pwm63e2VETF+pW7eu6tatq5EjR8owDG3btk3ff/+9vvjiC3OESsMw9OSTT+qOO+7IUSKNNwwdOtRMjJo3b55OnDhhjqzp/CN/586dFRMTk2txtGvXzkyMSkpK0po1a9ShQwdLYlNmNxw4/2358uUZPm7SpEmG18xpR0qZMWNGrt8okBHnqdtcTXmakQsXLnicSOVPnF//qlWraufOnV5r2/lYk5iYqLi4OLeTMNIetwo6fz1OO39uUlJSdOzYMcuUd5k5fPiwR9uqUqWKbrvtNv3yyy+Srk4fdy0xatOmTebodtLVJCp/tmDBAks5o2lKs6tQoULq2bOnevbsKenqyEW//vqrvvnmG82dO9e8qXfbtm16/fXXLYlMOfXuu++aj8uUKaONGzdmmWzpzZGVsst5lofk5GSdPn06x6N4Oa/funXrdKNCAgAAACjY/GIqPVdf0mR151Nmd/W6c2ecN+60dnVXi6/u2gWAvFS/fn1VqlTJLC9atMjrU7QFBQWpS5cuZvnixYuaMWNGttv79ttvLT+kdOnSJVemSHH23nvvWcq33357rm4vIzabzfI6nj9/Xt99912exwEAvpDd/oY37+h35u7IRvQ1MnfddddZyq6mPczI1q1bM20rI9u2bXO7/e3bt5uPCxUqlC7B5vrrrzcfJyQkuJ0s5+9sNptuuOEGvfzyy/rrr7/Ut29f82/x8fGaM2eOD6O76q677jITC1JSUvTll19KktatW2d5jwcPHpyrcaSd4u5aspZzYlRmP9xXr17d3K+OHz+unTt3KjY21pLcktE0epJUq1YtS9nTZAlvadCggfl4z549bic7/fHHH7kVUp5w/vwfPXrUMrJMTqV9b52PRVnxpG5B4K/HaefPjST9/vvvbq2XkJCgHTt2eLy9a6PRSdLPP/+so0ePSrqaJHVN6dKldeedd3rcdl7ZsGGDVq9ebZbLlCmjG2+8Mde2V6xYMfXu3VszZ87U6tWrLQntU6dO9dp2HA6HZfrUp556yq0R6NJOK+gLaW9O88bI4M6fWV+d1wAAAAD4L79IjKpYsWKGy48dO5bpelFRUQoODs7wb+7cbejJHYmuXPtCIC1XzwkAAklQUJBGjBhhlh0Oh8aMGeP17Tz99NOW8htvvOFyFI3MJCQk6M0338y0bW/7+eefLXcqli5dOtemZcnKM888YymPHTs2W68jAOQ32e1vFClSxOVoU3mBvkbmypUrZ0nQ9mRkgHnz5pmPS5Ys6dYUtwsXLnSrbcMwLHUbNmyYrt/arl07S2K28w+bgcJut+vjjz+2PM/s/CjvzHlauewmk9jtdg0cONAsXxslynm0qHLlyqlr167ZjNI9N9xwg2XEjGXLluncuXNmgl9kZKSaNGmSaRvOo0YtW7bMklQluU6MKl26tOrWrWuWfbX/NW/e3HzscDjMEbSyMmvWrNwKyWPO0y25u086vy9xcXFuJ7a4I+3IX+4et9atW+cXo8j4E389Tjdt2tQy+rC7Cac//fSTy+mBM9OtWzdzRKrU1FRNmTJFV65c0ddff23WGThwoMtpP30tJSXF8p2FdLVfnFcjON98880aOnSoWT5+/LjOnTuXrl52zm9nzpyxvKdpk+ZcWbx4sVv1clPr1q0tny9vHNedj62xsbEejfQJAAAAIPD5RWKUqy+hDx48mOl6NpvNcjeIs3379mV6N9fBgwe90kFylVxVvXr1HLcNAPnBkCFDLFOiTJkyRXPnzs12ewsWLNDevXsty5o0aaJbbrnFLO/evVuvvPKKx22//PLLlikQOnTooEaNGmU71qxs3bpV9957rwzDMJc999xzioyMzLVtZqZBgwaWH/l27typf/zjH9lub8+ePea0CgDgz7Lb35Cujo6YkX79+skwjGz9c3d0RfoaWevWrZv5eO3atZZpfVyJjY3VihUrzLK7CTA7duywjDjhyoIFCyz71rVph5yVKlXKcm0zYcIEt2LIb6Kjoy3TPiUnJ+eoPedRo69Ns5wdQ4cONX+Q3bVrlxYsWKBvvvnG/PugQYMsCS+5wWazWRKbNmzYoJ9//tn8Qbx58+ay2+2ZtuG8/tKlSy2JUWFhYWrRooXLdfv162c+/uqrr8zplvNS586dVbx4cbP81ltvmVNOuXL06FFNnjw5t0NzW3b2yYYNG6pmzZpm2Zuf/2rVqlmS3r788sssp42VpIkTJ3othkDhr8fpEiVKqFOnTmZ52rRpOnDgQKbrOByOdDcIuSskJEQPPvigWf7iiy/03XffWfb33B5hL7tSU1M1bNgwrVq1ylxWpkwZPfbYY3kaR9qR3DI6F2bnWOL8PYPkegpmZ2fOnNFXX33lVvu5qUSJEurQoYNZ/vrrr3N8A/Ptt9+uYsWKSbr62nzwwQc5ag8AAABAYPGLxKiGDRtmuHznzp3pOnlpOd9h6MzhcGjatGku1/NWJ9DVdAq5+UM7APiTyMhIffXVV5Y7Lvv166fZs2d71E5SUpJGjx6trl27ZjiNxqRJkxQVFWWWx48fr3feecft9t999129/fbbZjkqKkqfffaZRzG6KykpSR9++KGaNWtmuRu0a9eueuqpp3Jlm+6aOHGiJZHt/fff16hRo7I836Y1c+ZMNW7cWDt37vR2iADgdTnpbzj/aOPsp59+ylYiQUajBGTE4XC4HF2Hvsb/e/TRRy3lYcOGZZoEkJycrMcee8wyGoMnP5AOHz480xE34uPjLSM02u12DRgwIMO6L7zwgvl49erV2frR2hcjP3oybfKRI0d0+vRps1ylSpUcbdt5/d27d2dr9BNJqlmzpmWaukGDBpnXnzabLc9+5Hce3SI5OdmyDzgnPbniXGf58uVavny5WW7WrJll+qa0Hn/8cXO60Li4ON1///1KSUnxKP6c7n9hYWGWkVS2bduWboRTZ4mJibr33ntdTjPqC877pLtT0QUFBVluTpg+fbqmT5/u8bZdvf5DhgwxH+/fv19vvfVWpu2sXbvWnFISVv56nH7yySct7ffv3z/TaXpffPFFbdq0KdvbGzx4sNnf37t3r0aNGmX+rU2bNm5NR5vXdu3apVtuucWS9Ge32/Xdd9/l+Ealw4cPZ5nE6cx5qt9ChQpZEoavcT6WxMXFuZUkVKJECRUqVMgsO4+GmRGHw6EhQ4ZkOZV0XnE+3sfHx2vAgAE5+rwUKVJETzzxhFkeP358upEU3cGo2gAAAEBg8ovEqAYNGmT4hV18fLxlZI+M9O7d2+XfXnvttXSjjkhX7/TN6oshdzl3bp25StgCgEDUsWNHjR492iwnJiaqT58+GjBggPbt25fpuvHx8friiy903XXXacyYMS6Hja9SpYo+//xzSwLWM888oz59+ujw4cMu2z969Kj69u2rkSNHmsuCgoI0adKkHP845+z06dP6+eef9fzzz6ty5cp6/PHHdeXKFfPvN998s7799luXU8DmlfLly2v69OmWofrfeusttW7d2nInbUZSU1O1aNEitWzZUn369MnRSA0AkJdy0t/o37+/ZaqPay5evKg+ffq4NfXQlStX9OOPP+quu+5S06ZN3Yp5165dlvPINZGRkW5PlVIQ1K1bVw899JBZXrNmjfr06ZNhAtqFCxfUr18/y2hR/fr1c/s9CQoK0qZNm9S7d+8M2z916pS6d+9uSWh77rnnMvwBVJJuueUWDRo0yCy/8MILGjp0aJYjGyckJGjevHm68847Ldc3eaVmzZq67777tHTp0kyn+zl79qzuu+8+s47NZstw9CxPNGvWzHx85coVvfDCCxl+TtzhnJBz4sQJ83H79v/H3n2HRXG1bQC/t9BBFFQEC/aKir3Egl009tiiRmOJJSbWV1OsMSYxJrHEbuwaYzdq7C323lGjYo3YUJqUZct8fxDm24FlmYWFXfD+XZeXe5ZzzjyzuyxzZp45pwlKliyZ8SAtkHKpO+PEGuPErbSUK1cOPj4+AICXL1/i1atXafadUt68eSWzaezevRtBQUEICQkx204QBJw5cwbDhg1DgwYN0o0xPRMmTIC/v79Ynj17Njp06CBZXk6v12P//v2oU6cOjh49ikKFCklmmrIl48/khg0bcPjwYVnt+vbtKybeCoKAPn36YMKECYiOjjbbLiYmBhs2bEBQUBDmzJljss7gwYMlMyVOmjQpzZlTTpw4gfbt20Ov12fb0mI5ib1+T7dq1QpdunQRy6dOnULt2rWxe/duSYLj1atX0bVrV/zwww9QKpVpzrqfnuLFi6NFixZi2fg7015mi9LpdLh27RqWLl2K4OBglC9fXvL3Xq1WY9WqVWjUqFGmt/Xbb7+hXLlymDNnDp4/f2627saNGyVLtbZv397kcWWtWrUkv4Pjxo1Ld7ytUqkkCfwrV67E6tWrTdZ9/fo1unfvjm3bttnN73rLli0lsxcePXoULVq0wD///JNmm5iYGMyfPx8TJkww+fPx48cjICAAQNINa8HBwZg9e3a6idTh4eFYtmwZatSokakZ0ImIiIiIyH5l7dzwMjk6OqJp06b466+/Uv3s+PHjkinGU2rZsiVKlSplMgHq9evXqF27NsaNG4cGDRrAYDDg2LFjmDlzZronm+S4c+eO5GRAsrx586JOnTqZ7p+IKCeZOHEi8uTJgzFjxkCv18NgMGDNmjVYu3YtAgMDERQUBD8/P3h7eyM6OhovXrzApUuXcPToUdl3+3/wwQfYuHEjevXqJbbZvHkztm3bhkaNGqFBgwbw8/ODQqFAWFgYTp48iaNHj0ru5nRycsK6deskJ5LlCgoKkiyrIggC3r59i8jIyDRnp1CpVBg2bBh+/PFHODs7W7zNtJZ/MqdIkSJm74xs1qwZDhw4gM6dO4uznZw8eRINGzaEv78/WrRogZIlS6JAgQLQarV48eIF7ty5g3379tlkmRUioszKzHijcuXK6Nq1KzZu3JjqZ4cPH0bp0qXRp08fNGjQAIULF4ZarUZUVBRevHiBGzdu4NKlS/j777/Fu8+NEwDMMb6YZ6xp06aS5FYCZs2ahZMnT+L27dsAgB07dqBMmTLo1q0bKleuDIVCgZCQEGzYsEGSOFKyZEnMnz9f9na++uorfPfdd9i1axfKli2L7t27IyAgAIIg4OrVq9iwYYMkUa5atWr4+uuvzfa5cOFChIaG4vjx4wCApUuXYvXq1WjRogXq1KmDggULwsHBAVFRUXjy5AmuXr2KM2fOiDPmDB48WHb81qLT6bBu3TqsW7cOPj4+qF+/PgIDA1GwYEG4uLjgzZs3uHLlCrZv3y4Zdw8ZMiTVckKWqlOnDipVqiQm7/zyyy+YP38+ihcvLjnOat++Pb755huzfXXu3BkFChSQfCYA6Ww7Wa1SpUooWLBgqiQLFxcX2Ql7jRs3Nvn9lF5iFJCUnBMSEoKZM2cCSDoeDAgIQP369dGoUSMULVoUbm5uiImJwYsXL3D9+nWcOXNGPA+S2fcTSJo9ZcuWLWjWrJmYBLBjxw7s2LED7u7uyJcvH169eiV+hyqVSqxduxYDBgwQj0tteePBxx9/jMWLF0MQBMTGxqJZs2bw9vaGr6+vJK7ffvsNNWvWFMsqlQp//PEHGjZsiFu3bsFgMGD69OmYO3cuWrVqhRo1aiB//vxQKBSIiorCgwcPcPXqVZw9e1Ycdxgvp2bM2dkZy5YtQ4sWLZCYmAhBEDBixAgsX74cnTp1QpEiRRAZGYnDhw9j7969MBgMqFixIipVqoRNmzZl7QuGpMSFb7/91uJ269ats8m5Nnv9nl6yZAnu3r2La9euAUhaJrZt27ZwcnJCwYIFERkZKZmJecKECXj06JH4t9LS35vBgwenWkY9b968Zm9YtbatW7emupknMTERUVFRiImJSXMW0DJlymDZsmVo2LCh1WIJDQ3FyJEjMXr0aNSsWRO1a9dGyZIlkS9fPmi1Wjx8+BD79+/HhQsXxDZubm5pfvb9/PzQunVr7N69GwDwxx9/YPPmzShevLhkVqiaNWvit99+E8tffPEFduzYAUEQYDAY0LdvXyxbtgzBwcEoVKgQoqOjcfHiRfz555/id+y0adPSPT7JLosXL8atW7fEG49PnDiBgIAANG3aFI0aNUKhQoWg1+sRFhaGCxcu4PDhw4iPj0ffvn1N9ufm5iaeH3r27BkSEhIwatQoTJ8+Ha1atUJgYCC8vLxgMBgQGRmJu3fv4sqVK7h48aJFs4AREREREVEOJNiJxYsXCwBS/evdu3e6bXfu3GmybUb/+fv7y4p50aJFJtv37Nkzk68GEVHOdeDAASEgICBD37++vr7CkiVLBJ1OZ3Ybp0+fFgIDAy3uPzAwUDh16pTsfenbt2+G/5Z4eHgIAwYMEEJCQix6/Ro3bpxtf8fu3bsntG3bNkPbcHZ2FsaPHy9ERkZatH9ERLaSmfFGWFiYUKRIkWwda/To0cNk+8WLF2fylcicFStWSOJZsWKFVfo1/vvXt29fi9u/fPlSqF69uuz3ISAgQHj69KnZPh88eCBpc+TIEWHWrFmCUqlMt/9KlSoJL1++lBW7RqMRBgwYkKHP07Bhw0z2eeTIEUm9Bw8eyIpl8uTJ6X5WMxJnr169hMTExDS3a8ln6tKlS0KBAgXMbk/uZ2js2LGSdt7e3kJCQoKsttbSrVu3VPE3adJEdvv58+enau/i4iJoNBqL+nB0dLT4fa1YsWKaffr7+4v1Jk+enG4MFy5cEMqVK2d2e97e3sLevXsFQRCEQoUKic/Pnj07zX4z+t1iyWdy2rRpgkKhMBv7kSNHTLaNjIwU3n///Qz9Xv34449m49qyZYus97Vo0aLCzZs3JWOfxo0by36t0pPy70ZG/6X1GlryXiWz9DvSnr6njb18+VJo06aN2e2rVCrh+++/FwwGg+TYomPHjhZtS6vVCr6+vpK+P/30U4tjtkTKv8OW/qtWrZqwZMkSi74PU35eTTH+Wyn3n5eXl3D8+HGz23706JFQsmRJs/2Y+t386aefZMWgVCqF6dOnmzy+SUt2/H5FRUUJrVq1suj1TO/7/OnTp0KdOnUy9LnZuHGjrP0kIiIiIqKcxT7mzgXQtWtXODk5pXo+5TTQprz//vuSafDlqFGjBmrUqGFRm5TSmlq3T58+meqXiCgna968Oa5du4b169ejVatWcHV1NVvfwcEBzZo1w6pVqxAaGopBgwale/dq3bp1cfHiRaxZswZBQUFmZ85Qq9Vo3LgxVq1ahYsXL1p1qVOlUgkXFxf4+voiMDAQXbp0weTJk3HgwAG8evUKv/32GypWrGi17VlbqVKlsGvXLpw5cwYffvghChYsaLa+QqFAlSpV8OOPP+LBgwf44Ycf4OnpmU3REhFlTmbGG76+vti5c2eaS6JZW2JiIvbs2ZPqeScnJ3Tr1i1bYshpChQogLNnz2LOnDkoWrRomvV8fX3x448/4uLFi/Dz87N4OyNHjsS+ffsQGBho8udubm4YO3Yszp8/L/vz4ujoiN9++w1nz55F+/btTX5OjXl7e6Nr167YvHkzZs2aZekuZNq6devQs2dPcQk3c+rWrYutW7di7dq1VpvprFq1aggJCcH333+PJk2aoFChQhmalROAZIksIGksn97rb22mZnZq3Lix7Pam6tavXx+Ojo6y+xg2bBhCQ0MxbNgw5MuXz2xdFxcXNG/eHPPnzxdn0LGGGjVq4OrVq1iyZAmaN28OX19fODo6wtfXF/Xr18dPP/2EW7duoVWrVhAEQbKcZd68ea0WR0ZMmDABZ86cweDBg1G1alXkzZtXMsusOZ6enti5cyf27duHJk2apNvOz88Pffv2xd69ezF69GizdTt37oxLly6l+XlycnLChx9+iEuXLqFChQqy4n1X2ev3dIECBfDXX3/hr7/+Qo8ePcTZ87y8vFC1alWMGTMGN27cwBdffAGFQiGZ/dfS3xu1Wo1evXpJnsvOGfbS4ujoiLx586J06dIICgrC4MGD8dtvv+H+/fu4dOkSBg0aZNH3oRx9+vTBpEmTUKtWrXR/Z/Ply4fhw4fj9u3b6S4/WqxYMVy9ehW//vorWrdujcKFC5tcCjqlMWPGYPv27ShbtmyaderWrYtDhw7hq6++Sre/7JYnTx7s3bsXW7ZsQY0aNUwuNZjM09MTvXv3xueff262Tz8/P5w+fRobNmxArVq1zPYJJM0iOnToUBw/fhxdu3bN0H4QEREREZF9UwhCGvMM20CPHj2wYcOGVM/v379fspa9KcnTBa9duzbd7VSrVg379u1D165d8ffff6f6ub+/Px4+fGi2j6ioKBQsWDDV0klFihTBw4cPbTqVOxGRPUlMTMS5c+fw77//Ijw8HFFRUeKyGOXKlUNgYGCmL0BFR0fjzJkzePbsmbgUSYECBeDr64u6desyeUcmQRBw7do13Lt3D+Hh4Xj9+jUcHR2RL18+FC9eHDVq1LD5hScioszIzHgDAMLCwtCrVy+zy5Wao1Qq0bVrV/zxxx9m6+3Zswdt2rRJ9XyPHj2wfv36DG37XXPlyhVcvXpVclxQuXJlVK9ePd2LY8kePnyIEiVKiOUjR44gKChILF+/fh1Xr15FWFgYnJ2dUbx4cTRv3jzdpPD0xMfH49SpU3j06BHCw8Oh1+vh4eGBIkWKoEKFCihbtqzsfchqDx48wK1bt/Do0SNERUXBYDDAw8MD/v7+qFmzZoaSz7LTH3/8gZ49e4rlGzduoFKlSjaMyPYMBgMuXbqEW7duITw8HLGxsXB3d4ePjw/KlSuHSpUqZXvyWEp37tyRLON34sQJvPfeezaMyHqio6Nx8uRJ/Pvvv3j9+jWApKQBf39/VKxYUfKdZIn79+/j5MmTCAsLg6urK4oWLYpGjRrBy8vLmuG/M3LS97QxPz8/PHv2DADw7bffWrycWuvWrcXl9GrWrInz589bPcacJj4+HlevXkVoaChevHiBuLg4ODs7w9vbGwEBAahatarVE7PSkvz9ffHiRbx+/Rru7u7w9fVFzZo1M/zdYQvPnj3DqVOn8Pz5c0RERMDFxQU+Pj6oUKECAgMDM3TOPTw8HCdPnsTz58/x5s0bqFQqeHp6okSJEqhUqRIKFy6cBXtCRERERET2xK4So86ePYu6deumer5Xr16yEp4AYO3atZgwYQIePXqU6mdeXl749NNPMXHiRDg4OCAoKCjDiVGLFi3C0KFDUz0/Y8YMjBs3TlasRERERESUfawx3gCAw4cPY/bs2Th06BDi4uLM1s2TJw8aNmyIli1bomvXrvD19U23/7QSuM6ePYvatWvLjpMyJ73EKMr5WrRogYMHDwIA6tWrh1OnTtk4IpJj9uzZGDVqFICkhNPo6Gi4ubnZOCoi+3blyhVUq1ZNLO/ZswetW7eW3f7x48coUaIEDAYDAGDx4sUWz95PREREREREZCt2lRgFJE0Df+zYMclzzs7OCAsLS3dK92SCIODMmTO4ceMGwsPD4e3tjZIlS6Jx48ZWm76/Vq1auHDhguS5PHny4PHjx5yZhIiIiIjITlljvJFMq9Xi8uXLuHPnDiIiIhAVFQVnZ2dx1ohy5cqhRIkSFt3Z/vr1axQuXBgajUbyfKNGjUze1EFZh4lRududO3dQvnx5JJ8SWblyJfr27WvjqCg9sbGxCAgIEG9ma9y4cYZn8SN6lyQv7QcA7u7uePbsGdzd3WW3//rrr/Hdd98BADw8PBAWFmZReyIiIiIiIiJbMr8Qug188803qU42JyQkYMmSJRg/frysPhQKBerVq4d69eplQYTAqVOnUiVFAUlrujMpioiIiIjIflljvJHMwcEBtWvXtuosTosXL06VFAUA06ZNs9o2iCjpdyo5KSp//vzo3r27jSN6dz148ACurq7w8fExWy8hIQF9+vSRzPA9ePDgLI6OyD7FxcXh3r17qFKlSrp1f/zxRzEpCgA+/PBDi5KaXr9+jQULFojljz76iElRRERERERElKMobR1ASo0bN0arVq1SPT937lwkJibaIKLUfv7551TPFShQQJzKnYiIiIiI7JM9jzcSExMxb968VM+3bt0ajRo1skFERLmPTqfDL7/8Ilk+c8yYMXB2drZhVO+2s2fPokSJEhgwYAD27t2LyMhIyc/Dw8OxZs0a1KhRA9u2bROfr1+/PhPa6J0VHR2NwMBAtGnTBuvWrcO///4r+Xl8fDz279+P4OBgSeK3l5cXJk+eLHs7YWFh6Nmzp/h76ejoiHHjxlllH4iIiIiIiIiyi93NGAUAv/zyC6pWrQqdTic+FxYWhmXLlmHo0KE2jAy4fv265ERcsu+++w4eHh42iIiIiIiIiCxhr+ONpUuX4tmzZ5LnHBwc8Msvv9goIqLcYdGiRVi0aBF0Oh0eP36MmJgY8WelSpXCiBEjbBgdAUlJHMuXL8fy5csBAN7e3nB3d0dMTAwiIiLE2b2SFStWDGvXroVSaXf3+xFlG0EQsGfPHuzZswdA0hJ3+fLlQ0JCAl6/fg29Xi+p7+zsjNWrV8PPz89sv23atEFYWBhiYmLw6NEjST9jxoxBsWLFrL8zRERERERERFnILs8gVaxY0eSJyenTpyMhIcEGEf2/yZMnpzohV6tWLQwYMMBGERERERERkSXscbyRkJCA7777LtXzn3/+OSpUqGCDiIhyj+fPn+Pq1asICQmRJEV5enpi48aNcHFxsWF05ODgkOq5169f49GjR3jz5k2qczDBwcE4c+YMSpQokV0hEtkdlUqVKjEwJiYGjx8/xsuXL1MlRVWqVAmHDx9G27Zt0+375s2buHr1Ku7fvy/pp1mzZhbNNkVERERERERkLxRCyjNMRERERERERO+4hw8fShIvjhw5gqCgINsFRBk2ZcoUTJ06FUBSEk7hwoXRsmVLfPXVV/D397dxdAQAISEh+Ouvv3D69GncuXMHYWFhePv2LVQqFby8vFCsWDE0btwYH3zwAWrVqmXrcInswvPnz7Fz506cOHECN27cwJMnTxAdHQ29Xo+8efOiUKFCqF+/PoKDg9G+fXvZM6wVL14cjx49AgC4ubmhQoUK6N27Nz799FOo1Xa5+AARERERERGRWUyMIiIiIiIiIiIiIiIiIiIiIiKiXMcul9IjIiIiIiIiIiIiIiIiIiIiIiLKDCZGERERERERERERERERERERERFRrsPEKCIiIiIiIiIiIiIiIiIiIiIiynWYGEVERERERERERERERERERERERLkOE6OIiIiIiIiIiIiIiIiIiIiIiCjXYWIUkZUNGTIECoUCCoUCq1evtnU4ZGX9+vUT39+goCBbh2OXkl8fhUKBlStX2jockiEoKEh8z/r162frcIjsypw5c8Tfj4kTJ9o6HCIispKMjtvu3buHTZs2Yd68eZg+fTpmzJiB+fPnY/v27bh27Rq0Wm0WRk053dGjRyXjpYcPH9o6JCKLCIKA6tWrQ6FQwNHREbdv37Z1SERERERERETpYmIUkRVdvHgRS5cuBQBUrVoVvXv3NlnPOAnB1D9HR0d4eHigWLFiqF27Nj788EP88MMPOHHiBPR6fXbuEuVAn376qeTzlCdPHsTFxdk6rFxlypQp4r8rV67YOhwAwJUrVyRxkZRxUiMvQpElhg4diuLFiwMAZs6cifv379s2ICIiyjS547ZkUVFRmDp1KooVK4YyZcqgW7du+OyzzzBhwgR88cUXGD58ODp16oSqVavCw8MDdevWxYQJE3Dp0qXs2B3KQsbHj7wxJuebMmWK2XMxarUabm5u8PX1RdWqVdGpUyd8/fXX2LVrF2JiYjK0zZTjEIVCAScnJ7x+/drivvbs2WMybnM3JK1cudKqNy8pFAr88MMPAACtVovPP/88U/0RERERERERZQe1rQMgyk1GjhwJg8EAAPjmm2+gVGYs91Cr1UKr1eLt27d48uQJzp8/j/Xr1wMA8ufPj969e2PkyJHw9/e3WuyUOyQkJOD333+XPBcTE4NNmzahb9++Nooq95k6dar4uHjx4ggMDLRdMP+5cuWKJC4mRxFZh6OjIyZMmICBAwdCo9Fg3Lhx2Lx5s63DIiKiTLBk3Hb48GH06dMHYWFhsvrWaDQ4e/Yszp49iwsXLmDv3r1WiZmIsp5er0dcXBzi4uLw/PlzXLt2Ddu3bwcAODs7o3379hg1ahTq1q2bqe0kJiZi3bp1FicVLVu2LFPbtZaWLVuiQYMGOHHiBA4cOIBdu3bh/ffft3VYRERERERERGnijFFEVrJnzx6cOHECAFCpUiW0a9dOdttSpUpJ/pUoUQLe3t5Qq1PnLoaHh2P27NkoV64cpk6dyhmkSGLLli2IjIxM9by9nEAlIsqJ+vTpAz8/PwDA1q1bOQMIEVEOZsm47ciRI2jbtq0kKcrd3R0ffPABpk+fjiVLlmDZsmWYOXMmBg4ciKpVq0KhUGT5PhCRdfj5+aU6H+Pj4wMnJ6dUdRMSErBx40bUq1cPPXr0wJs3bzK17RUrVlhUPzw8HDt37szUNq1p/Pjx4uOJEydCEAQbRkNERERERERkHmeMIrIS49lZRo8ebdEJ8Xv37qX5s7CwMJw9exZHjhzB6tWrERUVBSDpTuQpU6bgwoUL2LZtm8kkKrK+lStXZnrq+axknABVokQJPHjwAABw/Phx3LlzB2XLlrVVaGTHjh49ausQiOyao6Mjhg8fjq+++gqCIGDq1Kn4888/bR0WERFlgNxxW1xcHPr27YuEhATxuc8++wzffvst8uTJk2b/YWFh2Lp1K5YsWWK1mCn3CAoKYgKJHVm3bl2aSyRGRUXh/PnzOH36NFasWCGOrQFgw4YNOHfuHE6ePAlfX1/Z23NzcwMAxMbG4sqVK7h8+TKqVasmq+3atWuRmJgIAChUqBCeP38ue7tZoW3btihXrhz++ecfXLlyBdu3b0enTp1sGhMRERERERFRWjhjFJEVHD9+HOfOnQMAeHp6okePHlbr28/PD506dcLcuXPx9OlTTJ48GSqVSvz5rl27MGzYMKttj3Ku+/fvSxJcfv31V3GGEwBYvny5DaIiIsodPv74YzEJeefOnbh7966NIyIiIktZMm77/fff8eTJE7E8fPhwzJ0712xSFJA0fhs+fDiuXbuG+fPnWydwIsp2np6eaN68OSZOnIh79+5h/fr1yJcvn/jzBw8eoG3btnj79q3sPp2dndGtWzexbMmsUcZ1+/TpI7tdVlEoFBg0aJBY/vnnn20YDREREREREZF5nGKGyArmzp0rPu7evTtcXV2zZDtubm6YMmUKGjZsiDZt2oh3Cy5duhTNmzeXnGCT49q1a7h69SpevnwJg8EAHx8fBAQEoFq1alZbAuLmzZu4fPkynj59CpVKhfLly6Np06ZwcXFJs82TJ09w4sQJPHnyBAqFAsWKFUPz5s3h7e1t8fb1ej1CQkJw69YtPHv2DLGxsXB3d0f+/PlRo0YNlC9fPjO7l2Hnzp0TY3J3d0fp0qURFBQEZ2fnDPe5fPly8e5jX19ftG7dGr1798aPP/4IAFi9ejWmT58uSayzhMFgwIkTJ3D79m28efMGPj4+KFWqFBo0aAClMnN5tomJibh+/Tpu376NFy9eID4+Hnny5EHBggVRp04dFC9ePFP9G3v69ClOnz6Np0+fQqfToUiRIggKCoKPj4/VtiHX/fv3ERISgkePHiE6OhqOjo7w8vJCxYoVUaNGDTg4OGR7TJaKj4/H8ePH8ejRI4SHh8PDwwOFChVCw4YNrfaaJn/27t69i5cvXyJv3ryoUKECGjRoYHez5YWEhIjfqxqNRvxerVGjRoa/V7Prc2IwGHDq1Cncv38fz549g4ODA1q2bImAgIB02yYmJuLo0aN4+PAhXr9+DS8vLwQGBqJWrVqZ+n7QaDQ4efIkHj58iJcvX8LFxQW+vr5o1KgRChUqlOF+jUVEROD48eMICwvDmzdv4O3tjT59+qT6W16oUCEEBwdj586dEAQBv/76q+TvPxER2T9Lxm1//fWX+FihUODrr7+2eHulSpWyuE2y69ev49q1a3j69ClcXFxQokQJNG3aNMNjzadPn+L69et48OABIiMjoVKp4OXlhdKlS6Nu3bqZGoekdOHCBfzzzz949uwZBEFAgwYNUK9evTTjunDhAh4/fozo6GioVCp4eHigSJEiKF++PMqWLZuhY6hnz57h1KlTeP78OaKjo+Ht7Y2SJUuiYcOGJpdJy2mSxzRPnjyBXq+Hr68vGjdujCJFimSq36x43V69eoVr164hNDQUEREREAQBXl5eKF68OOrVqwcPD49MxWwsJCQE169fx7Nnz6DRaFC9enW0bNky0/0qlUr06NED9evXR1BQkDh71OXLlzFu3DgsWLBAdl/9+/cXk5x+//13/PTTT3B0dDTb5sKFC7h27RoAIE+ePPjggw8wc+bMDO6N9Xz00UcYP3489Ho9Tp48iUuXLqF69eq2DouIiIiIiIgoNYGIMuXNmzeCo6OjAEAAIOzfvz/dNo0bNxbrZ/TXcNGiRZI+KlasKOj1+nTbabVaYe7cuULRokUl7Y3/+fn5CTNnzhQ0Gk26/T148EDS9siRI4IgCMLx48eFWrVqmew/X758wvz581P19c8//wht27YVFApFqjZqtVoYNWqUEB8fn25M0dHRwsqVK4V27doJefLkSXM/AQhFixYVZs2aJWtfBUEQ+vbtK7Zt3LhxmvVWrFhh8j1ev369ULZsWZOxuLu7C9OnTxd0Op2sWIzpdDqhcOHCYl9jx44VBEEQQkJCJNvYsWOHxX0LgiD89ttvgp+fn8m4ixQpIsydO1esa/yzFStWpNnnq1evhPnz5wvNmzcXXFxczL5P5cuXF1asWCEYDAZZ8fr7+4ttJ0+eLAiCINy/f19o27atoFKpUvWvUqmETp06CU+ePEmzz8mTJ5uN0dS/5N+HZDqdTti9e7fQr1+/NF9P48/DyJEjhefPn8veVzn//P39U/Vh/J3Ut29fWa/xkydPhI8++ijN906hUAgNGjQQjh07Jqs/49fXOMZff/1VKFKkiMltFChQQFi8eLGs/o1/dwEIDx48kNVOjoSEBOGnn34SihUrlubrXrhwYWHevHmyfr+z4nOSzNTrrNVqhW+//Vbw9fVN1X/y748gmP7+02q1wuTJkwVvb2+T8RUvXlzYunWrpS+pcP/+faFXr16Cq6trmp+vxo0bC+fOnZPVn6nvhIcPHwqdO3eW/A1P7/OxatUqsY63t7eQmJho8b4REZFtWDpuCwwMFOv6+PhYPZ60xlEHDhwQqlWrlubf/bFjxwpxcXGytnH06FFh2LBhQsmSJc0eTzg5OQkff/yxEBoaKqvftMY6CxcuNLktU8eXR44cERo2bJjusWu+fPmEXr16CY8fP5YV2/bt24WaNWuaHFMmv4YjRowQIiIiZPVn3Nbc+E+uI0eOyD4mNa6XPK66f/++8P7775sc0wAQ2rdvn6HjXGu/bhcvXhT+97//CRUrVjT7/iaPw65cuSKr37Rev82bNwuVK1dO1X/K9yzlmC7leE2Oy5cvC87OzmIfjo6OZj+fxsfQ3t7egiAIknMCGzduTHebQ4YMEesPGjRIuH79usnPhykpf1/N1c2IJk2aiH1/9tlnVu2biIiIiIiIyFqYGEWUSUuWLBFPAnl6egparTbdNtZIjBIEIdWJvz///NNs/ZcvXwo1atRI9+Rz8r/KlSsLT58+NdunqRP6ixYtEtRqdbr9jx8/Xuzn0KFDgru7e7pt2rRpk25iQcoTf3L+1a9fX3j58mW6r3lmEqOGDx8uK5Zu3brJTgBK9tdff0n6uHbtmvizmjVris936NDBon51Op3Qo0cP2XHr9XrZJ10zkmjUoUMH4e3bt+nGnTIJ4u+//xby5cuXbv+enp7C6dOnrRZvyhPtKX9f5Pzz9fUVzp8/L2tf5fyzRmLUzp0700xYMfVvzJgx6X6mUybsJCYmCp06dZLVf3IioDlZlRh1584doUyZMrJfi0aNGgnR0dFm+8yKz0mylK9zVFSUUK9evTT7NZcYFRkZKdSvX19WfPPmzZP9mi5atMhkspKpfwqFQvjll1/S7TPld8KBAwcET0/PNPtN6/MREREhuRCZ0WRTIiLKfpaO24wTF/LmzWv1eEyNo2bPni0olcp0//4FBATIGrtYejyRJ08eYffu3en2m3Kso9VqhY4dO6bZb8rjy++//97i2A4cOGA2ppiYGKFt27ay+/Pz8xNCQkIseg1tnRh14MABIW/evLL27c6dO7LiyarXzdIxiqOjo7B8+fIMvX7mxtlZkRglCKnH9qNGjUqzrqnEKOPfgdatW5vdVnx8vOR9P336tF0lRs2dO1fsu0CBArJu2CMiIiIiIiLKbva1/gxRDrRr1y7xccOGDbN1WaeRI0diwIABYnnfvn1o3769yboxMTFo1KgRbt++LT7n5eWFrl27onLlylAqlQgJCcHGjRvx6tUrAEnLNzRs2BDnz5+Hl5eXrJgOHz6M7777Dnq9HmXKlEGXLl1QsmRJJCYm4vjx49i0aRMMBgMAYMaMGWhgqy6ZAAEAAElEQVTRogX8/PzQoUMHvH37Fl5eXvjggw9QpUoVODo64saNG1i1ahWioqIAALt378a8efMwYsQIWfF4eXmhQYMGqFatGgoWLAgXFxe8fv0aFy5cwI4dOxAfHw8AOHXqFLp3746DBw9melk4U7777jvMmzcPABAYGIj3338f/v7+0Gg0OHPmDDZs2ACtVgsA2LhxI4KCgjB06FDZ/S9btkx8XK1aNVSuXFks9+3bFxcuXACQtCTIixcvZC9xNnz4cPzxxx9i2cHBAe3atUODBg3g4eGBBw8eYNOmTbh79y42btyIChUqyI7ZmK+vL9577z0EBgYif/78cHBwwIsXL3D69Gns2bMHOp0OAPDnn39i2LBhWLVqley+nz9/jm7duiEiIgKOjo7o0KED6tevDzc3N4SGhmLjxo3iUghRUVEIDg7GmTNnUK5cOUk/Xl5e4nIooaGh4vMFCxZMc/kHc0tGOjk5oX79+qhZsyaKFCmCPHnyICYmBiEhIdixYweePXsGIGk5i7Zt2+LatWsm37fixYtDrVYjJiYGL1++FJ9Pa+mWzC6vsWfPHnTq1El8TwCgatWq6NixI4oWLYqIiAgcOXIE+/btg16vBwD8/PPP0Ol0mD17tuztDB8+HNu2bQMANGjQAC1btoSfnx/evn2Lo0eP4s8//xSXjvzpp5/QtGlTBAcHZ2rfLBUSEoKgoCCEh4eLz5UsWRLt2rVD2bJl4ejoiNDQUGzZsgV3794FABw7dgytW7fG33//LevvhbU+J2np168fTp8+DQCoU6cOgoODUbhwYcTGxuLKlStwc3Mz2c5gMKBnz544deoUFAoFWrZsiSZNmqBAgQKIiIjAnj17cOjQIbH+yJEj0bBhQ1SpUsVsPDNmzMAXX3whlhUKBZo0aYImTZrA19cXcXFxuHDhArZs2YLY2FgIgoDRo0fDyckJw4YNk7XPDx48wNy5cxEVFQVXV1e0a9cOderUgaenJ168eIG//vorzSV78ubNi2rVqonfqbt27UK7du1kbZeIiGzL0nFbgQIFcOfOHQBAZGQkzp49izp16mRZfIcOHcJ3330Hg8EAb29vdO/eHQEBATAYDLh69So2bdqEyMhIAMCNGzfQqlUrnDp1StYSeCqVCrVr10bt2rVRvHhxeHp6Ii4uDnfu3MGuXbtw//59AEB0dDS6dOmCCxcuoGLFirJjHzt2LLZv3w4ACAgIQLt27VC8eHEkJibi1q1bkiXY9u3bhy+//FIsOzo6ok2bNqhVqxZ8fHygUCgQGRmJO3fu4Pz587h06VK624+NjUWTJk3Ev88AkC9fPrRr1w7VqlVDnjx58OLFC+zZswfHjx8HAISFhaFx48a4ePEiihUrJntfbeX27dsYMWKEuLxdp06dUKVKFbi6uuLevXv4/fff8fjxYwBJ+/bRRx/h5MmTZse22fG6KRQKBAYGok6dOihTpgzy5cuHhIQEPHjwAHv37sX169cBJC3LPHDgQBQrVgzNmjWT/brMnj1bHGeXLFkSHTt2ROnSpaFQKHDv3j2EhYXJ7ssSI0eOFLcLJH2uLdG3b19MmDABer0e+/fvx9OnT1G4cGGTdbds2SL+7lesWBF169bFjRs3Mhy7tTVt2lR8/OrVK5w9ezbNpTOJiIiIiIiIbMbWmVlEOZlWq5XMcjRjxgxZ7aw1Y9S///4r6adixYpp1u3fv7+kbtu2bYXXr1+nqhcREZHqbt/u3bun2W/KO52Tp96fMmWKyZmdDhw4IJkJpGHDhkKdOnUEAEKnTp2EN2/epGrz6NEjydJ/BQsWNDtr1IoVK4TGjRsLu3btMrvM0cuXL4V27dpJ4k/vLtWMzhilVCoFZ2dnYe3atSbrX7x4UTKjka+vr+wl9V6+fCk4ODiIbWfNmiX5eXh4uOQ1l/s5PXDggGQf/P39hcuXL6eqp9VqhS+//FLcT+M25u5GnTp1qtChQwfhyJEjZu8qffDgQaoZbQ4fPmw2duM7lJNjKlWqlHD9+vVUdRMTE4URI0ZI+m/UqJHZGY7k7qOpfSldurSwZMkSITIyMs16Go1GmDhxomQ7H330kdm+01rSRA65M0a9evVK8PHxkby2CxYsMFn39OnTqZZm27NnT5p9G9+9nfye5cuXL81lbvbs2SP5XNeqVcvsPlp7xqi4uDjJ0iAODg7C3LlzTf7earVaYdKkSZLtf/PNN2n2nZWfE1Mzn7m7u6c746AgSF/D5PfI399fuHDhgsn6y5Ytk2yna9euZvs/fPiw5DukbNmywqVLl0zWffLkiVC7dm2xrouLi/DPP/+k2bepWQvq168ve1keY6NHj5Z8LxIRkf3LyLhtzJgxkr8bFSpUEO7du2e1mFKOo5L/BgYHB5scpz1//lwICgqStJkwYYLZbfj6+go///yz2SV39Xq9MH/+fMl4olGjRmb7NTVDr1qtFpYsWZLuLKHGx52lSpVK9zV98uSJ8PXXXwtnz55Ns06/fv0ksQwcODDNY6ht27ZJZj5t1qyZ2e0b92vLGaOSPx+9evUyuW+xsbFC69atJW3++usvs7Fk5esWGBgoTJo0SXj48KHZehs3bhQ8PDzEfkuUKGF2bJjy9Uv+N3XqVFmzd1trxihBEITSpUtL+kprFjdTM0YJgiCZqWv69Olpbqdp06ZivZkzZwqCINjVjFGCIEiW1TaecZaIiIiIiIjIXjAxiigTLl++LDnBtG/fPlntrJUYJQiCUKxYMUlf8fHxqercuHFDUqdOnTpCQkJCmn1qNBrhvffek7RJ60S0qSWfxowZYzbmzz//3OQFanOJQJs3b5bUTytZQhAEk69BWhITEyX7Wq1aNbP1M5oYBUDYvHmz2b4XL14sqZ/echHJfvrpJ8kFiRcvXqSqY7wkWbly5WT1GxgYKEk6uHnzptn6gwcPTrXP5k66WvI+RUVFSU48d+rUyWz9lEkQ7u7uwt27d8226dWrl6SNuUSRjJ5YTkxMlJ3wJgiCMG7cOHE7Tk5OZpdMyY7EqP/973+SbaRMwkvp8uXLkuQlc8mbKS9SqNXqNJc1TJackJf8z9x7bO3EqKlTp0r627hxY7ptRo4cKdZ3c3NL88JTVn5OTCVGmUtYM5byNcyTJ49w//59s2169uwpiS0mJsZkPb1eL5QqVUqs6+/vL7x69cps35GRkZLf9d69e6dZN+V3QunSpdOMJT2rV6+W9PXs2bMM9UNERNknI+O2kJCQVEn/jo6OQvfu3YU//vhD+PfffzMVk6lxVLVq1cweI0dHRwvly5eXxGPu774lx9sLFiyQxHL16tU065oa6yxcuDDdbWg0GsmStNu3b5cdX1qOHj0qiePTTz9Nt822bdskbQ4ePJhmXeN6tkyMAiC0a9fObOLZq1evhDx58oj1e/XqlWbdrH7dLPns7d69W/Y4zFRi1Pjx42Vvy5qJUR999JGkr71795qsl1Zi1JYtW8Tny5QpY7LtgwcPxJvP1Gq1mORob4lRxslbrVq1snr/RERERERERJll/fWiiN4hKaf1r1SpUrbHULx4cUn59evXqeosXLhQUl6wYIFkOYOUHB0dsXDhQslSQgsWLJAVj7e3N6ZNm2a2Tp8+fVI9N2fOHKhUqjTbtG/fHp6enmL57NmzadaVs5xEMgcHB0m8ly9fxosXL2S3l6tly5bo0qWL2Tq9e/eGq6urWDa3j8aMl9Fr3bo1ChYsmKpO3759xcf//PMPTp48abbP8+fP48qVK2J55MiR6S6T98MPPyBfvnyyYgYse5/y5MmDr776SiwfOHBAXJJRjnHjxqF06dJm6/zyyy+SZcOWLl0qu3+5HBwczH7OU5o4caL4mdBoNDh8+LDVY5IrISEBy5cvF8uBgYH4/PPPzbZJWefmzZs4evSorO31798fdevWNVtn8ODBkrLc35nMSkhIwPz588Vy9+7d0bVr13TbTZ8+XVyWNDY2FmvWrDFZLzs/J+3bt0fr1q1l1zf2xRdfoESJEmbrGL9HGo0GV69eNVlv+/btkiUqFy1ahPz585vt29PTEzNmzBDLmzZtMvk30JQff/wR7u7usuqmZLxUKQDJ8jNERGSfMjJuq1ixomTJNyBpua8NGzagR48eKFKkCPz8/NC+fXtMnz4dx44dg0ajyVScc+bMMXuM7OHhgZ9//lkSz+rVq9Osb8nx9uDBgyV/1/fs2SO7bWBgYKrjMlPCw8PFpZYBoGzZsrK3kRbj16NYsWL45Zdf0m3TsWNHyfFPyvGyPVKr1Zg/f36ay/0CQP78+dG5c2exbO7YOKtfN0s+e8HBwWjUqJFYtuSz5+PjgylTpsiub00pz8UYL68tR7t27VCgQAEAwN27d8XlCo2tWLFCXD68TZs2Fi2ZnZ2Mj495bExERERERET2iIlRRJlw79498bGDgwN8fX2zPYaUiShv3rxJVWfnzp3i47p166J69erp9lu5cmXJycm//vpLVjxdu3aFi4uL2TpVqlSRXPSvUKECatasabaNg4OD5GTb7du3ZcUjR8OGDSWJYufPn7da38k+/vjjdOu4urqiSpUqYvnWrVvptjl9+rSknnEClLE2bdpIkgyMk6lMMf7MAMCgQYPSjSVv3rzo1q1buvUyqnnz5uLjt2/f4ubNm7LaKZVKWfEXLFgQHTt2FMv79u3L9MWtzHJ3d5ckB2XFZ1Ou06dPS5JOhgwZAqUy/cOIYcOGSS7g7Nq1S9b25PzO+Pv7o1ChQmJZzu+MNRw8eBAvX74Uy2PGjJHVztXVVfI7cuDAAavEk5nPiZzXOS39+vVLt06tWrUkn5O03qPff/9dfFyxYkXZyVpdunSBh4cHgKTEq2PHjqXbxtvbG+3atZPVvylFixaVlI2PBYiIyD5ldNw2bdo0TJs2DWq12uTPnz17hp07d2LChAlo3LgxfHx8MHjwYNy9e9fiGCtUqICGDRumWy84OFjyt2jHjh0Wb8sUpVKJJk2aiGVLjif69u1rNmEnmfFNIABw6tQp+QGaEBUVJRmnDh8+HI6OjrLaGh/HHDp0SEw+sVfNmjVLdQxiivExYWhoKLRabao69vi6GY/1LPns9ejRw6IkLGuScy7GHAcHB/Tu3Vssr1ixQvJzg8GAlStXiuX+/ftbHmQ2Mf5svn79GpGRkbYLhoiIiIiIiMgEJkYRZcLjx4/Fxz4+PrKSBKwt5YwX0dHRkvKzZ88kcQYHB8vu+/333xcfh4eHy7r4W6dOnXTrODo6Sk4iymkDQJIAYc0TbWq1WpI09PTpU6v1nSy9mW+SFS5cWHwsZx+NE5zy5cuX5sV+BwcHfPjhh2J548aNiImJSbPfc+fOiY/LlCmT7qwwyTI684wcKS9gyX2fqlSpIvnsmGMcv1arTXN2m+xkvN9Z8dmU68yZM5Ky3O+SEiVKoGLFimn2Y4qDgwNq1Kghq39Lf2eswfhu7oIFC6ab2GnM+PvOmjNcZfRzUr9+/Qxtz9/fX9ZFZVdXV8n3fVrv0YkTJ8THbdu2lR2HWq2WJPvKeU1r166d5gVuOby9vSXJtMZ/Y4mIyD5ldNymUCgwYcIE3Lx5EwMGDBCTcdMSFRWFJUuWoFKlSpg0aZJFSSOtWrWSHVPLli3F8qVLlyyaSdWcrD6eyJs3r2RcMXr0aGzatCnD8Z86dUrS1pJjCONjssjISPzzzz8ZiiG7ZGQ8KQgCoqKiUtWxx9ctu49lrSG9czFyGCc7bdq0CW/fvhXLBw8eFL+7fHx8LHqfspvx5w7g8TERERERERHZHyZGEWWC8QXe9E6SZ5WUyS3Gy80BwJ07dyTlqlWryu7bePYiU32ZIjcBxXjJMrnTwRu3iY2NTbe+wWDA4cOH8fnnn6NRo0YoXLgwPDw8oFQqoVAoJP+MT75mRXKF3NfF+ORqevv49u1bbNiwQSx3797d7BKJxrNJxcbGStqmZDwjV0BAgNk4jKVcYkqOxMRE7Ny5E4MHD0a9evVQqFAhuLm5pXqPHBwcJO3kvk+WxJSyrjVnJkvpxo0bmDRpEtq0aYMSJUogb968UKlUqfZ73bp1Yhtb3nlr/PufN29eFCtWTHZb4+8SOd8jXl5eqd7vtFjyO2MtxglzFStWlDVDQjLj77sXL15Ap9OZrZ+VnxMPDw+TS2/KIfc7DUj/PXr+/LlkCVNLl6U1fk3//fffdOunt6ymHMb7xDviiYjsX2bHbWXKlMFvv/2GFy9eYPfu3fjiiy8QFBSU5jLSWq0W06ZNw4ABA2RvI6PHrG/fvk3379/9+/fx/fffo0OHDihTpox4rJXyeGL69OliG0v+vlnyt3XIkCHi4+joaHTr1g1FixbFkCFDsGHDBll/y5MZH5M5ODhYtDRfyjGoJdu1hYyMJwHTx17Z+bo9e/YMc+bMQdeuXVGhQgV4e3vD0dEx1WfPeIbfrPrsWVt652LkCAgIQK1atQAk/S5v2rRJ/JnxMuZ9+vTJVGJ/Vkv5uePxMREREREREdkb+x1VE+UA8fHx4mNbTd+e8oSTl5eXpBwRESEpW3IRPOVJz5R9mZKR1yEjbdK7+/rYsWMYOnSo7OXWjCUkJFjcJj1ZsY8bN26U3FH60Ucfma1fvXp1BAQE4MaNGwCSZpsaOHCgybrG77Uln5kCBQrIrgsA27Ztw4gRI/DkyROL2gHy36fMxC/nM2+pR48e4dNPP5W9PKWxrPhsypXRzwQg/S6Rc5I8o9+n2bUEivGSgkePHrUoMSqliIgIk7832fE5yZMnj8V9J7Pme2T8egJJS7TIWabPFDm/s5nZ72Surq5i3HFxcZnuj4iIspa1xm0uLi4IDg6WzJwZGhqKw4cPY/369Thy5Iik/ooVK9CsWTP06tUr3b4ze8xqKmn99evXGD16NNasWWPxcZIlx52W/G0dM2YMTpw4IVm6OywsDIsXL8bixYsBJCW7tGrVCr179zY7U5LxMYRWq5WdWG9KVhz3W1NWHXtl1esWFxeHCRMm4Ndff033RoCUsuqzZ23pnYuRq3///uLygcuXL8fHH3+MiIgIbN++XVLHnqVcJpPHx0RERERERGRvmBhFlAnGd+xZerLPWu7fvy8+VigU8Pb2lvzcOHEGSH3CyhzjGZpM9WWvtm/fjm7dukGr1ab6maurKzw9PeHs7CxZQuPRo0fie5hdyRWZZbyMXpkyZVCvXr102/Tt2xf/+9//ACQtaXbz5k3JMmfJjO8sdnFxkR1Tys+MOfPnz8fw4cNN/szDwwMeHh5wdnaWJJ2EhoaKj+W+T5mJ39qf+bt37yIoKAhhYWGpfubg4AAvLy84OTlJLk68fPlSvBvZlp9N49fCku8RQPq6arVaaDQas7Ob2Ttr3gFt6qJBdn1O7OWu86x+PVOyxn4b/33JzMVEIiLKHlk5bitVqhRKlSqFQYMG4fjx4/jwww8ls+hMmzZNVmKUtY9ZX716haCgIJM3iqhUKnFpWEdHR/H5N2/eiIkulhx3WvK3VaVSYfv27Vi0aBFmzJhhcsmte/fu4d69e5g/fz4aN26MxYsXo1y5cqnqZfcxRG6R1a9bfHw8goODcezYsVQ/UyqV8PLygouLi+SzFxMTg5cvX1q8fVsezxqfiwGA/PnzZ6ifnj17YvTo0YiPj8eJEydw9+5d7Nu3DxqNBkDSMooVKlTIdLxZKeW5Fx4fExERERERkb2xjytiRDmU8XThxnchZ5d///1XctI9ICAgVbJByinNLTnhm3La/ZR92aNXr17h448/Fk/MqdVqDBw4EB988AGqV6+e5nIX/v7+Jk/K26vbt2/j1KlTYvnu3bsZmrVm+fLl+Omnn1I97+bmhujoaACWfbblLmV28+ZNjBo1Siy7u7tj2LBheP/99xEYGGhyiRNBECTJbHJlJn5rf+b79+8vSXYJDg5G//79Ua9ePfj5+Zl8D/v27YvVq1dbNY6MMH4tLL1wZPy6Ojg45OikKECaGObm5mbRsnIpmbqYk5M/JxmRMtHO19fX4uS7ZH5+ftYIKV3G3yuWJIQSEZFtZNe4rWHDhtizZw+qVasmJmD9888/CA0NRalSpcy2tfYx68iRIyVJUfXq1cPQoUPRoEEDFCtWDCqVKlWbyZMn45tvvpEdR0YplUoMGzYMQ4YMwfHjx3Hw4EGcOHECZ8+eTfU6/P3336hduzaOHz+eaql34+MFpVKJEiVKZDimjCyxmFNl9ev27bffSpKiKlWqhM8++wxBQUEoWbKkyaSZFStW2P2sSCmdPn1afKxQKFCjRo0M9ePp6YkuXbpg7dq1AJJeiz179og/zwmvS8rfWx4fExERERERkb1hYhRRJhhfDH/16lW2b3/v3r2SclBQUKo6KROBLLkLM2XdtJKK7Mny5cvFO2CVSiV27dqFVq1apdvOmnfNZgfj2aIyY82aNfj+++9TnZzOly+fmBhlyWdG7u/Br7/+Kiavubi44MSJE6hatarZNhl9jzITvzU/82fPnsWJEyfE8ldffYXp06en285ePpvGr4Wld3Mb18+bN6+1QrIZ47vBky+AWktO/5xkRMq762fNmoXu3bvbKJr0aTQaREVFiWVfX18bRkNERHJk57gtICAArVu3xq5du8Tnbt++nW5ilDWPWZ8/f47169eL5d69e2PVqlXp3mSQ3ccTSqUSjRs3RuPGjQEAiYmJOHnyJLZs2YI1a9aI45Ho6GgMGDBAXG4smfExhKOjI+7du5d9wedgWfm6abVazJ8/Xyw3bdoUu3fvTvfGiJx2LHv37l3JbMYBAQGpZu+2RP/+/cXEqHnz5okzwbq6utr1cXGylN9fPD4mIiIiIiIie2P51BtEJDK+szIqKirbl5qbPXu2pGwqAahs2bKS8tWrV2X3f+3aNbN92aNDhw6Jj1u0aCErKSo8PFw86Z4TaLVaycwwefPmFZfwkPOvePHiYtuXL19i586dqbZhvFTFjRs3ZMcmt67x+/TRRx+lmxQFpF6qQK7r16/LrpsyflNLdmSU8T7nyZMHkyZNktUuo/ttbca//5GRkRbNsGb8XZITvkfSU758efGx8ax91pDTPycZ4efnhzx58ohla7+m1pZyiUN/f38bRUJERHJl97itUqVKkrJxQm1aMnrM6ubmhsKFC0t+fvjwYXEpPIVCgRkzZsiaedXWxxOOjo5o0qQJ5s2bh7t370qOxS9cuIB//vlHUt/4mCwhIQGvX7/Otlhzsqx83c6fPy/5vE+fPl3WbLG2/uxZSs65GEskz6YFQEyKAoAuXbpIjpPt1dOnT8XHarU61XcSERERERERka0xMYooEwICAiTlu3fvZtu2Fy1ahJCQELFcuXJltGnTJlU9X19fFCtWTCxbMrOJ8V3O+fPnR+nSpTMYbfYxPiEnJ9kGSLpwkJPs2rVLckfm4sWLce/ePdn/QkNDJScqTc0+VadOHfHx3bt38eDBA1mxpZzFLC0ZeZ+ME0Ysce3aNTx//lxWXeP4HRwcEBgYaLKe8fJnBoNBVt/G+1y+fHlZFwieP38u+T03J+WsX3Ljkqtu3bqSstzvkocPH0r2IWU/OVGTJk3ExyEhIRbPoGVOVn9O7JFKpULDhg3F8pEjR2wYTfru3LkjKVeuXNlGkRARkVzZPW5LSEiQlL28vNJts3//fll9C4IgqVu9evVUy+IZH08UKFBA1lKzGo1GMmulrRUsWBA//PCD5DnjpQGBpGQS4yWG7f0Ywl5k5etm/NkDsn6sZwtXrlzB8uXLxbKTkxNGjhyZqT4VCgX69euX6vmcsIweID0+Ll++vMnlwomIiIiIiIhsiYlRRJlQs2ZNSTnlDEtZ5dChQxgxYoTkucmTJ0tObhpr166d+PjMmTO4cuVKutsICQnBsWPHxHLbtm0zFmw2S74zGkh9QSItc+bMyapwsoRxIpO7u7vk/ZVDqVRKpuPft29fqhPYKfv87bff0u03KioKGzdulBWDpe9TYmIiFi5cKKvvlAwGg6ylB1+9eoXt27eL5VatWqWZlOLu7i4+ljMDAJCxz+bcuXMl7cwxjsmSuOSqX7++ZHmIxYsXy4pt4cKFknrvv/++VeOyhVatWolLAgqCgLlz51qt76z+nNirHj16iI/37t2bakYIe2L8t97JyQlVqlSxYTRERCRHdo/bTp48KSnLucHk5s2bqdqZsnfvXsnMnR06dEhVx/i4QKPRpNsnAKxatcruljNLOXtr8lLcyQoUKICmTZuK5ZSz+JBpWfm6pTwmlXM8u3//fty6dctqMWSlx48fo3PnzpL9GjRokFVmSOrXrx8CAwNRtWpVVK1aFc2bNxeXmbR3xt+ptWrVsmEkRERERERERKYxMYooE/Lnzy9ZJuHcuXNZur3Y2FhMnToVrVq1QmJiovj8kCFD0KVLlzTbDR06VFL+9NNPJe1T0mq1GDZsmGTGmWHDhmUi8uxjvKTRnj17oNfrzdafPXs2Tp06ldVhWU1YWJhkVqOOHTvCxcXF4n569uwpPtbr9Vi1apXk57Vq1ZLMljR79ux0ExW++uorvHnzRtb2jd8n45nJ0jJu3Dg8fPhQVt+mzJgxI93lGcaOHStZVmXQoEFp1jVejlDu8oHG+3zjxo109+fcuXP46aefZPWdMiZL4pLLyclJcsfy5cuXMX/+fLNtrl27Jkk8rFixIoKCgqwaly14eHjgs88+E8szZ87E0aNHLe7H1IWirP6c2KsePXqIyxzp9Xp8+OGHFi9zJDeRLLPOnz8vPq5fv36q2dqIiMj+ZGTcNn78+AzNLLthwwZcuHBBLJcrV072zLsjRowwm8gUGxuLsWPHimVHR0d89NFHqeoZH09ERUXh+PHjZrf74MEDjB8/XlaMmfHmzRvJMmHpSbkMfMrjXSBpDJLs5MmT+P777y2OK7uOIexJVr1uKZcYTm+sFxERgSFDhli87exmMBiwYcMGBAYGSmZTrlGjRqqZzTKqaNGiuHz5Mq5cuYIrV67gwIEDad78Zk+io6Ml5wpyw3iPiIiIiIiIch8mRhFlkvHydVkxdX9YWBi2b9+Ozz//HIULF8aUKVMkyT4dOnTAvHnzzPZRqVIlDBgwQCyfOnUKXbt2RURERKq6UVFR6NGjh2S2qB49eqB27dpW2Jus16pVK/Hx3bt38dlnn0Gn06Wqp9VqMX36dIwePRpA0ixKOcHKlSsl7/+HH36YoX5q1qyJsmXLiuXly5enurt35syZ4uO4uDgEBwebvLter9dj0qRJWLBggezX0fh9Onz4ML777juT9WJjY/HZZ59hzpw5GX6PlEolYmJi0Lp161TLbwBJn4UxY8Zg9erV4nMNGzY0OxOX8XJwGzZskHXRzHifDQYDevbsifDwcJN1d+zYgZYtW0Kr1cre74oVK8LDw0MsT548GS9evJDVVq5x48bBx8dHLI8cORJLly41Wffs2bMIDg6WXNz7+eefrRqPLY0fP15clicxMRHBwcGYPXt2urMyhIeHY9myZahRo4ZkhrJkWf05sVdqtRq//fabuBTQpUuXUKdOHVmJq9euXcMXX3yBUqVKZXWYACBJggsODs6WbRIRUeZZOm47efIkmjVrhnr16mHJkiXpzqak1Woxa9Ys9OnTR/L8l19+KSs+pVKJixcv4oMPPjA5Tnv16hU6dOggOZ4dN24cChQokKpu06ZNJUtZ9e/fP81k65MnT6JRo0aIjIzM8uOJa9euoVixYvjiiy/SXQb4+vXrkiSwwoULp5r5C0jaV+MlyL766it88skn6S51nJCQgF27dqF9+/YYM2aMZTuSC2TV61ajRg3JLLNjxoxJc8bqkJAQNGrUCA8ePLDLY9moqCgcOnQI06ZNQ5kyZdCjRw/J72apUqWwa9cuuLm52TBK2zt+/Lh4jkKhUEjGM0RERERERET2gou+E2VSly5dxASSW7du4fHjxyhWrJhFfaS8g9hgMCAmJgZRUVGplgtI5uzsjK+++gpff/21rJOIs2bNwsmTJ3H79m0ASRfUy5Qpg27duqFy5cpQKBQICQnBhg0b8OrVK7FdyZIl050Vxp4MGDAA33//vXhCd+HChTh48CC6du2KUqVKQaPR4M6dO9i2bRsePXoEAPjkk0+wb98+sWyvBEHA8uXLxXL+/PnRokWLDPfXs2dPTJ06FQAQGhqKv//+W3J3Z/PmzTFkyBAsWrQIQNKd5DVr1kT79u3RoEEDeHh44MGDB9i0aRPu3LkDAJg4caLYpzmjRo3C4sWLxbuMv/76a2zatAmdOnVC0aJFERcXhxs3bmDr1q3ie/ntt99K7myWa9CgQdi+fTvu3r2L6tWro2PHjqhfvz5cXV0RGhqKjRs3SmaTyps3L5YuXWr27tyPP/5YXEouNjYWzZo1g7e3N3x9fcXEDiBpCcLkCziBgYEIDg7Gnj17ACQta1m2bFn06NEDVatWhVqtxpMnT/DXX3+JswwEBgaiTJky2LRpU7r76eDggD59+mDBggUAki74+fn5wd/fHx4eHuL++Pn5Yffu3Ra+ikny58+PFStWoH379tDpdNDr9fjkk0+wcOFCdOzYEYULF0ZkZCSOHj2aasa2ESNGoHXr1hnablYICgqSXDCU48cff0Tnzp0BAG5ubti2bRsaNWqEZ8+eISEhAaNGjcL06dPRqlUrBAYGwsvLCwaDAZGRkbh79y6uXLmCixcvmp3JLqs/J/asadOmmD17Nj7//HMIgoCbN2/ivffeQ2BgIJo0aYKSJUvCw8MDsbGxCA8Px40bN3D27FlxOaG0lr60pkuXLkn+RiZ/HoiIyP5ldNx25swZnDlzBsOHD0fVqlVRp04d+Pv7w8vLCwDw+vVrXL9+HXv27MHr168lbbt27Yq+ffvKiu+rr77Cd999h127dqFs2bLo3r07AgICIAgCrl69ig0bNkiSs6pVq4avv/7aZF8FChTAoEGDxKWo7927h0qVKqFbt26oVasWnJ2d8ezZMxw8eFBM+C1SpAjatWuX4eWr5YqMjMSMGTMwY8YMlC1bFnXr1kWlSpXg5eUFpVKJ58+f49SpU9i7d6/kmOmXX35Jc9y7cOFChIaGijNjLV26FKtXr0aLFi1Qp04dFCxYEA4ODoiKisKTJ09w9epVnDlzBrGxsQCAwYMHy4r97Nmzsmf/Mnbv3j2L22SHrHjd1Go1xo0bJ85A9urVK9SuXRsdO3YUx5CvXr3CsWPHxPc4T548GDp0KGbMmJF9O/+fXr16pZqBOTY2FpGRkWZnEuvRowcWLFiAfPnyZXWIVjd+/Hh8++23FrXp0qVLmu/Pvn37xMcNGjSQ3EhDREREREREZC+YGEWUSXXq1EHZsmXFxJCtW7di5MiRFvURGhoqu27+/PnRu3dvjBo1yqIELA8PDxw7dgytW7fGpUuXACSdxDd34jsgIAD79u0TT/rnBB4eHti8eTNat26NuLg4AEkzR6U1I1H79u3x66+/SmZPsld///235LPStWtXixM7jBknRgHAsmXLUk17P2/ePERERGDDhg0Aku6E37JlC7Zs2ZKqv27dumHSpEmyEqP8/f2xcuVK9O7dW5zRK3nJAFOGDBmCL7/8MkOJUYUKFcLGjRvRoUMHREZGYsOGDeL+pJQnTx7s3r0b5cqVM9tn7dq18c0332DSpEniTFuvX79OdTEs5VJgK1aswHvvvSe+jxEREWn+DpYvXx7btm3DlClT5OwmAOC7777D2bNncfHiRQBJSZbGSz0ASHe2g/QEBwdj27Zt6N69u/g7dvnyZVy+fDnNNqNHj7a75d4ykggZHR0tKZcuXRoXLlxA586dcfbsWQBJM0KtW7cO69atS7c/4yQ6Y1n9ObFnw4cPR+HChdGvXz/x9Tb33WAsrdfTmjZv3iw+rl+/frbNUkVERJln6bjN1dVVUtZqtbhw4YJkmby0KJVKfPrpp/jll19kx5ecaD9mzBiEh4ebvTmlUqVK2LdvH5ydndOs89NPP+HSpUviMUpcXBxWrlyJlStXpqrr5+eHP//8Ezt27JAdrzXcuXNHfD/SolKpMGvWLHTr1i3NOs7Ozjh48CCGDRuGZcuWAQA0Gg127dola9luuccQCQkJFo3d7V1WvW5jxozBqVOn8OeffwJI+t3ZtGmTySR+T09PbNiwAc+ePcvEnmRcWFiY7LrOzs5o3749Ro8ejTp16mRhVFnr5cuX6c4MllJaMxELgoCtW7eK5ZQz5hERERERERHZC/ubq5ooBxo0aJD4eP369ZnuT6VSwc3NTVwuoEePHvjuu+9w/PhxPH/+HLNmzbJ4Viog6c7hs2fPYs6cOShatGia9Xx9ffHjjz/i4sWL8PPzy8yu2ETDhg1x7tw5NGnSJM06pUqVwsKFC/Hnn3/C0dExG6PLuOST1ckyuoxesnLlyqF69epiecuWLYiKipLUUalU+OOPP7B06VL4+vqa7Kdw4cKYM2cONmzYYNESCN27d8eRI0dQo0aNNOtUrlwZmzZtyvSd640aNcKlS5fQpk0bkyfwVSoVOnbsiBs3bqBevXqy+pwwYQLOnDmDwYMHo2rVqsibN2+6iWo+Pj44f/48+vfvDwcHB5N18uXLh1GjRuHixYsoXry4rFiSeXp64tSpU+KsTsWLF4ebm5vZ2a8y4v3338ft27fRp0+fVHdYJ1MoFHjvvffw999/4+eff7Z6DPbCz88Pp0+fxoYNG1CrVq1097NkyZIYOnQojh8/jq5du5qsk9WfE3vXqVMn3L9/H19++SUKFSpktq6DgwPee+89zJgxI90Lq5klCIIkqfKTTz7J0u0REZH1WTJu27NnD44ePYoxY8agRo0aspJnPD090b9/f1y4cAFz5861+CaGkSNHYt++fQgMDDT5czc3N4wdOxbnz583uYSeMVdXVxw9ehRjx45NleRl3N/HH3+Ma9euScYFWaVatWqYM2cOWrVqBXd3d7N1HR0d0alTJ1y6dAmfffZZun07Ojrit99+w9mzZ9G+fft0Z5L09vZG165dsXnzZsyaNcui/chNsuJ1U6lU2Lp1K77//vs0b7JydHRE586dcfXqVbtaek2pVMLZ2Rk+Pj6oXLky2rdvjy+//BI7d+7Eq1evsGHDhhydFGVtx44dw9OnTwEk3WTUvXt3G0dEREREREREZJpCSJ7qgogyLCoqCkWKFBFnh7ly5QqqVq1q46jSd+XKFVy9elW8W7BAgQKoXLkyqlevnmuSGEJDQ3Hy5Ek8e/YMKpUKvr6+KF++vNlkHDLNYDDg+PHjuHXrFiIiIuDj44PSpUujQYMGFiVEmRISEoKzZ8/i5cuXcHJygq+vL6pUqYKKFStmqL/ixYuLMwJNnjxZMpvO06dPcerUKTx9+hQ6nQ6FCxdGkyZN0k3AsLbw8HAcO3YMDx8+RGJiIgoWLAh/f380atQozWQYexQfHy/ux+vXr+Hu7g5fX180bNgw219TexAeHo6TJ0/i+fPnePPmDVQqFTw9PVGiRAlUqlQJhQsXtri/3PA5yYwbN27g2rVrePXqFWJiYuDm5ob8+fOjbNmyCAgIgJubW7bEcfDgQXH50kKFCuHRo0c5JrGWiIiSZGbcFhsbi9u3b+PevXt48eIF3r59C6VSCQ8PD3EcVbZsWdmzDz18+BAlSpQQy0eOHJHM3nr9+nVcvXoVYWFhcHZ2RvHixdG8efM0k5zMiY6OxvHjx3H37l3ExcWhQIECKFKkCBo3bpyh/qxBr9fj5s2buHPnDp4+fSq+nnnz5kXZsmVRo0YNeHp6Zrj/+Ph4nDp1Co8ePUJ4eDj0ej08PDxQpEgRVKhQAWXLls01Y15rsvbrFh8fj5MnT+LWrVuIjo6Gt7c3/Pz80KhRI+TNmzfrdoSyRe/evcWZckeNGmXRLHlERERERERE2YmJUURWMm7cOMycORNA0p3IS5YssXFERO8uc4lRREQZ0blzZ2zbtg0AMGPGDIwbN87GERERUUbYy7gtvcQoIiJ79vLlS/j7+yMhIQFOTk64e/eu2ZnJiYiIiIiIiGyJS+kRWcm4cePg4eEBAFi9ejWePXtm44iIiIjIGm7fvo0///wTQNJsUcOHD7dxRERElFEctxERZd7s2bORkJAAABg8eDCTooiIiIiIiMiuMTGKyEry588vzh6h0Wjw008/2TgiIiIisobvv/8eBoMBQNIsdLZadoiIiDKP4zYiosyJiIjAggULAAB58uTBV199ZeOIiIiIiIiIiMxjYhSRFY0dOxYlS5YEAMyfP19cyouIiIhyphs3bmDt2rUAgOrVq+OTTz6xcURERJRZHLcREWXc999/j6ioKADA1KlT4ePjY+OIiIiIiIiIiMxT2zoAotzE2dkZa9euxb59+wAADx48gL+/v42jIiIiooz6999/MXHiRABAp06doFTyvgIiopyO4zYioowRBAHe3t6YPHkyHB0ducQ0ERERERER5QhMjCKysnr16qFevXq2DoOIiIisoHXr1mjdurWtwyAiIivjuI2IyHIKhQLjx4+3dRhEREREREREFuEt70RERERERERERERERERERERElOsoBEEQbB0EERERERERERERERERERERERGRNXHGKCIiIiIiIiIiIiIiIiIiIiIiynWYGEVERERERERERERERERERERERLkOE6OIiIiIiIiIiIiIiIiIiIiIiCjXYWIUERERERERERERERERERERERHlOkyMIiIiIiIiIiIiIiIiIiIiIiKiXIeJUURERERERERERERERERERERElOswMYqIiIiIiIiIiIiIiIiIiIiIiHIdJkYREREREREREREREREREREREVGuw8QoIiIiIiIiIiIiIiIiIiIiIiLKdZgYRUREREREREREREREREREREREuQ4To4iIiIiIiIiIiIiIiIiIiIiIKNdhYhQREREREREREREREREREREREeU6TIwiIiIiIiIiIiIiIiIiIiIiIqJch4lRRERERERERERERERERERERESU66htHQBRZiQkJCA0NFQslypVCs7OzjaMiIiIiIiIcgOONYiIiIiIiIiIiIhyPiZGUY4WGhqKgIAAsXzjxg1UqlTJhhEREREREVFuwLEGERERERERERERUc7HpfSIiIiIiIiIiIiIiIiIiIiIiCjXYWIUERERERERERERERERERERERHlOkyMIiIiIiIiIiIiIiIiIiIiIiKiXIeJUURERERERERERERERERERERElOswMYqIiIiIiIiIiIiIiIiIiIiIiHIdJkYREREREREREREREREREREREVGuw8QoIiIiIiIiIiIiIiIiIiIiIiLKdZgYRUREREREREREREREREREREREuQ4To4iIiIiIiIiIiIiIiIiIiIiIKNdhYhQREREREREREREREREREREREeU6TIwiIiIiIiIiIiIiIiIiIiIiIqJch4lRRERERERERERERERERERERESU6zAxioiIiIiIiIiIiIiIiIiIiIiIch0mRhERERERERERERERERERERERUa7DxCgiIiIiIiIiIiIiIiIiIiIiIsp1mBhFRERERERERERERERERERERES5DhOjiIiIiIiIiIiIiIiIiIiIiIgo11HbOgAiIiIiopzOYBAQr9VDozPAIAgQBEChAJQKBZzUSrg4qKBUKmwdJhERERER5SAcZxAREREREWUeE6OIiIiIiDJIqzcgTqOHRqeHkPKHAqCHAK3egFiNDk5qFVydVHBQcdJWIiIiIiJKG8cZRERERERE1sPEKCIiIiKiDHir0SFWoxPLiToDEnR6GAxGd3IrFXBWq+CoViJBp0eCTg83JzXcnXgYTkREREREqXGcQUREREREZF0cKRERERERWSgqXosErR4AkJCoR7xWD50h1b3cgF6ARmuAWqmAi4MKzo4qxGp0MAgC8jg7ZHPURERERERkzzjOICIiIiIisj4mRhERERERWeCtRiderIhO0EKjNQBIunPbSa2Eg0oJpUIBg5C0vIVGZ4DOICBGo0OiwYA8zg6IT9RDqVDwjm4iIiIiIgLAcQYREREREVFW4QiJiIiIiEgmrd4gLmthfLHC1VEFF0cVlAqFpL6zgwpugoD4RD3iEvXQaA2IhhZ5nB0Qq9GJFziIiIiIiOjdxXEGERERERFR1uHoiIiIiIhIpjjN/y9rkXyxIo+LGm5O6lQXK5IpFQq4OamRxyXpngSN1iDeCZ7cHxERERERvbs4ziAiIiIiIso6TIwiIiIiIpLBYBCg0SVdYIj/74KDq6MKTmqVrPZOahVcHZPqxicmtdfo9DAYhCyIloiIiIiIcgKOM4iIiIiIiLIWE6OIiIiIiGSI1+ohAEjUGaAzCFAoABdHeRcrkrk4qqBQADqDgESdAQL+/+IHERERERG9ezjOICIiIiIiylpMjCIiIiIikkGjS1rSIuG/u7md1Mo0l7VIi1KhgKNKKeknuV8iIiIiInr3cJxBRERERESUtZgYRUREREQkg0FIWooieUkKB1XGDqUd1UpJP8n9EhERERHRu4fjDCIiIiIioqzFxCgiIiIiIhmSrysk/2/pXdzJkpul7I+IiIiIiN49cscZ8fHxWL38NwhpDCA4ziAiIiIiIjJNbesAiIiIiIhyAoUCgPD/Fxwyegd2crPkfjKYX0VERERERLmAnHGGVqvF4I/7YP+ev3Dv7j/45vuZqepwnEFERERERGQaZ4wiIiIiIpIh+c5tpTLpf63ekKF+EnUGST8ZnXmKiIiIiIhyvvTGGQaDAaM+HYz9e/6Cs7MzWrdtb7IfjjOIiIiIiIhM44xRRNkgMTER58+fx7///ovw8HBERkbC3d0d+fLlQ7ly5VC1alU4OzvbOsx3SmxsLI4dO4YnT57gzZs3KFCgAIoXL45GjRrBwcHB1uFZVUJCAk6dOoXQ0FCEh4fDw8MDfn5+qFu3Lvz8/GwdHhFRjuGkVkKrN8BZrYJGa4BGZ4CbIFh0wcEgCEj870KHs1ol9ktElBEcZ9gfexpnZPU4ICYmBidOnMCjR48QERGBvHnzonDhwmjQoAG8vLyssAdERO8Gc+MMQRDw9bjR2LxhPdRqNZasWof6DRqm6oPjDCIiIiIiorQxMYooiwiCgI0bN2LlypU4duwY4uLi0qyrVqvRoEED9OnTB926dYO7u3s2RvpuCQ8Px/jx47FhwwbExsam+rmXlxf69euHadOmwdXV1erb79evH1atWpXpfgQZyzc9fvwY06ZNw9q1a5GQkJDq50qlEg0bNsT06dPx3nvvZTomIqLczsVBhViNDo5qJdRKBXQGAfGJerg5yT+kjk/UQxAAtVIBR7USiv/6JSKSi+MM+2TrcYaxrB4HhISEYMqUKdi+fTt0Ol2qnzs4OKBVq1aYMWMGKlasmKF9ICJ6l5gbZ/w4/RusWLoYCoUCcxctRcvWbUz2wXEGERERERFR2njbCFEWOHToEKpWrYoePXpg7969Zi9WAIBOp8PRo0cxYMAAlCpVCvPnzzd5gpky59SpU6hcuTKWL19u8mIFALx58wa//PILAgMDcefOnWyOUB5PT8906/z5558ICAjAb7/9ZvJiCJA0Ffvff/+NRo0aYeLEidYOk4go11EqFXD67+7r5IsMcYl6aHR6We01Oj3iEpPqujgm38WtEpe6ICJKD8cZ9smexhlZPQ5YvHgxqlWrhs2bN6f5WdJqtdi1axeqV6+ORYsWWbwPRETvmrTGGfPmzsasmT8AAL7/aTY6d+1hsj3HGUREREREROZxxigiK5s7dy5Gjx4Nvf7/L5IqFApUqVIFTZo0gZ+fH7y9vREdHY0XL17g8uXLOHr0KDQaDQDg5cuXGD58ON577z0EBgbaaC9yn7t376J9+/Z4/fq1+Fz16tXRuXNn+Pj44PHjx1i/fj3u3bsn1m/Tpg3OnDmD/PnzWy0OHx8flCpVyqI2ERERePPmjVju2bOn2fp79uxB586dYTAYxOcCAgLQqVMn+Pv7IzY2FmfPnsWWLVug0WhgMBjw7bffwtXVFV9++aVlO0RE9I5xdVIhQaeHs6MKiQYDNFoDouN1cHUU4OKoMrmsnkFIuuM7+WKFk4MSzv9d8HB14l3cRCQPxxn2yV7GGUDWjwMWL16MIUOGSJ6rV68e2rRpAz8/P0RGRuLYsWPYuXMnDAYDNBoNhg0bBk9Pz3THMERE77qU44w/1qzCtxOTvpu/mDgF/QZ+kqoNxxlERERERETyKAQ56zER2amQkBAEBASI5Rs3bqBSpUo2i2fatGmYNGmSWFYoFOjZsyemTZuGkiVLptkuNjYWGzZswNSpU/H48WMAwOXLl3nBwopq166N8+fPA0h6X2bOnIkxY8ZI6hgMBowaNQpz584Vn+vatSs2btyYrbGm9P777+Ovv/4SyxcuXECNGjVM1n316hXKli2LyMhIAEn7+vPPP2PkyJFQpLhYHxoainbt2uHWrVti3ZMnT6JevXpZsyNERLnEW40OsZqkWTKiE7TQaJMuQCsUgKNKmbR0hQIQBCBRZ0Ci3oDkI24nByXyODsAANyc1HC3YBk+Ispe9jTW4DjDftnLOCOrxwEhISGoXr06EhMTAQBOTk5YsWKFyYSnixcvon379ggLCxPr3r59G8WLF7fCnhIR5V7J44xdf27DJ/16w2AwoN/gzzBm4jdwUqs4ziAiIiIiIsogLqVHZCX79+/HlClTxLKjoyM2bNiAdevWmb1YAQBubm7o378/7t69i8mTJ0Op5K+mNW3evFm8WAEAgwcPTnWxAgCUSiXmzJmDVq1aSdpeuHAhW+I0JSwsDHv37hXLgYGBaSZFAcBPP/0kXgwBgK+//hqjRo1KdTEEAEqVKoX9+/cjb968AABBEPC///3ParETEeVW7k5q8U7sPM4O8HBWQ61UQBAAjc6AmAQdouN1iEnQQaNLulihVirg4awWL1a4OKp4sYKIZOE4w37Z0zgjq8cB33zzjZgUBQDz589PcxaoGjVqYNeuXXBwSPqbp9Fo8PXXX1u4R0RE7x53JzVOHzuCYQP7wWAwoEfvfhg3aRoABccZREREREREmcAZoyhHs5e7uOPi4lCiRAm8fPlSfG7Tpk344IMPMtTf3r17UaZMGVlLrmm1Wpw6dQqhoaF4+fIlXFxc4OPjg7p161r1jtwLFy7gn3/+wbNnzyAIAho0aCBrZiGDwYBTp07h/v37ePbsGRwcHNCyZUvJ+5bV3nvvPZw6dQoA4OLigqdPnyJfvnxp1r916xYqVqwolnv37o01a9ZkeZymTJ8+HRMmTBDLv/76K4YPH55mfT8/Pzx79gwAkC9fPjx9+hQuLi5mt/HNN99g8uTJYvnkyZOoX79+JiMnIsr9jGeOApLu2k7Q6WEwCBCEpBmklEoFnP+7uzsZ7+AmyhnsYazBcUbaOM6QyspxwNu3b+Hl5QWtVgsAqFChAm7evJluTP3798eKFSsAJM1K9eTJExQuXFj2PhERvWtOnz6N5s2bIy4uDu06dsai5auhUqk4ziAiIiIiIsokjpSIrGDp0qWSixV9+vTJ8MUKAGjdunW6dd68eYOpU6di5cqViI6ONlmnatWqmDp1Kjp06JBufytXrsTHH38slpNzJhctWoSZM2fi/v37kvp9+/YVL1hMmTIFU6dOBQD4+/vj4cOH0Ol0mDFjBubPny+eoE82efLkbLtg8fz5c5w5c0Ysf/DBB2YvVgBJJ/obNGiAEydOAAB27doFrVYr3vGcXQRBwPLly8Wys7MzevfunWb927dvS17rtm3bpnsxBAC6desmuSCyZcsWJkYREcng7qSGk1qJOI0eGp0ejmql5MKEMQUAJ7UKrk4qOKg4YwsRycNxBscZcmT1OODEiRNiUhQAdOnSRVZc3bp1ExOjBEHA1q1b8dlnn8lqS0T0rrl27RratGmDuLg4tGzZEr+vWws91BxnEBERERERWQFHS0SZZDAY8Msvv4hlhUIhWeoiK5w7dw7lypXD3Llz07xYAQBXr15Fx44d0bNnT8mJbDl0Oh06deqEoUOHprpYkZ7o6Gg0atQIEyZMSHWxwpR+/fpBoVCI/44ePWrR9szZs2cPDAaDWG7ZsqWsdi1atBAfR0ZG4uTJk1aLSa4jR45IXvsuXbqIy12Y8uDBA0m5SpUqsrZTrlw5ODk5ieUdO3ZYFigR0TvMQaWEp6sD8rs7wd1JDQeVEiqlAkqFAiqlAg4qJdyd1Mjv7gRPVwderCAi2TjOSI3jDNOyehyQ0f5T1uM4g4jItHv37qFly5aIjIxE/fr1sXXrVri7unCcQUREREREZCWcMYook65fv47Hjx+L5RYtWqBkyZJZtr3Lly+jWbNmePv2rfhc6dKl8cEHH6BkyZJ4+/Ytzp49i+3bt0Oj0QAA/vjjDyQkJGDbtm2ytzN27Fhs374dABAQEIB27dqhePHiSExMxK1btyQn0FPq168fTp8+DQCoU6cOgoODUbhwYcTGxuLKlStwc3PLwJ5nzNWrVyXlunXrymqX8k7pa9euISgoyFphybJs2TJJecCAAWbrR0RESMrp3bGeTKFQwNPTU5yNIDQ0FG/fvoW7u7sF0RIRvduUSgXcnNRwS/vPIxGRRTjOSI3jDNOyehyQ0f5T1rty5YqsdkRE75KnT5+iefPmePHiBapUqYJdu3ZJ/p5xnEFERERERJR5TIwiyqS///5bUm7WrFmWbUuj0aB3796SixUTJkzA5MmToVZLf51v376NTp064fbt2wCA7du3Y9GiRRgyZIisbc2ZMwdqtRoLFizAwIEDoVAoZLV79OgRHj16BHd3d6xbtw7t27eXuXdZ49atW+JjlUqFEiVKyGpXqlQpSfnmzZtWjSs9kZGR2Lp1q1guXbp0uhdMUi6XER8fL3t7xnUFQcCtW7dQq1Yt2e2JiIiIyLo4zpDiOCNtWT0OyGj/KeuFh4fj1atXKFCggOz4iIhys/DwcLRo0QKPHj1C6dKlsX//ftnJp0RERERERCQf59glyqRz585JyrVr186ybS1btkxy4nzEiBGYNm1aqosVAFC+fHns378f3t7e4nNff/01EhISZG/v119/xaBBg2RfrDC2adMmm1+sACBZnsPPzw8qlUpWuyJFikCp/P+vSEuX+cistWvXSt6r/v37p/s+pLzAkHLJi7SEh4cjJiZG8lxoaKjMSImIiIgoK3CcYRrHGall9Tggo/2b2jeOM4iIksTExCA4OBi3bt1C4cKFcfDgQfj4+Ng6LCIiIiIiolyJiVFEmfTixQtJWe6dwhmxYMEC8bGvry+mT59utn7RokUxdepUsfzmzRv88ccfsrYVGBiIwYMHZyjO9u3bo3Xr1hlqa23R0dHiYy8vL9ntHBwcJFOXp7xgkNWMl9FTqVTo169fum2qVq0quXh18OBBWdsyVc/4dSMiIiKi7MdxRmocZ5iW1eOAGjVqpNsuM/0TEb1rEhIS0KFDB1y4cAH58+fHgQMH4O/vb+uwiIiIiIiIci0mRhFl0uvXryXlvHnzZsl2Hjx4gJCQELHct29fyQn1tPTr109Sb9euXbK217dv3wzdwQ0AH3/8sUX1V65cCUEQxH/pLRlnCePlQJydnS1qa7xkhHE/We3ixYu4cuWKWG7Tpg18fX3Tbefh4YF69eqJ5evXr2Pfvn1m2+j1evz888+pns/uRDAiIiIikuI4IzWOM0zL6nFAhQoVUKxYMbG8e/fudJcAfPv2rSThzlz/RETvEq1Wi+7du+PIkSPw8PDA3r17UaFCBVuHRURERERElKsxMYook1Ke2HV3d8+S7Zw5c0ZSDg4OltXOzc1NcgEgZT9pqV+/vuzYrNnW2oyX9HB0dLSorZOTk/g4Pj7eajGlx3i2KAAYOHCg7LajRo2SlAcMGGB2uYqxY8fiwoULqZ7Pzv0lIiIiotQ4zrBuW2uzt3FGVo8DRo4cKT7W6/Xo0aMHXr16ZbKuTqfDxx9/jCdPnsjun4joXWAwGNC/f3/s2LEDTk5O2LlzZ6pZ+YiIiIiIiMj6mBhFlEkeHh6SclbNLHTnzh1JuWrVqrLbVqlSRXz89OlTxMXFpdumdOnS8oMz4uHhgYIFC2aobVYwvns7MTHRorYajUZ8bHxXd1aKj4/H77//LpZ9fX3Rtm1b2e07duyINm3aiOWnT5+iVq1amDFjBu7evQuNRoOIiAjs3bsXLVq0wOzZswGk/hynLBMRERFR9uI4Q4rjDPOyehwwdOhQBAYGiuXr16+jWrVqWLhwIR4/fgytVotXr15h69atqFu3LjZv3mxR/0REuZ0gCBgxYgTWrl0LlUqFTZs2oXHjxrYOi4iIiIiI6J3AxCiiTPL29paUIyMjs2Q7ERER4mNHR0d4enrKbuvj45NmX2nJkyeP/OCs0C6rGN9Zb3xXtxzGdzNn1R36KW3evBlRUVFiuV+/flCpVLLbKxQKrFmzRnLHYUREBL744guULVsWzs7O8PLyQnBwMA4ePAgACAgIwBdffCHpJ1++fJncEyIiIiLKDI4zrNMuq9jbOCOrxwHOzs7YunUrSpYsKT739OlTDBs2DP7+/nB0dETBggXRpUsXXLx4EQDQrFmzVMsfcpxBRO+qyZMnY968eVAoFFi1ahXatWtn65CIiIiIiIjeGUyMIsqklBcDHj58mCXbMb5D3NXV1aK2bm5uafaVFrVabdE2MtsuqxhfQJFzoSaZVqtFbGysWM6uO5uNl9FTKBTo37+/xX14eXnh2LFjGDp0KBwcHMzW7dq1K44ePQqFQiF5Pn/+/BZvl4iIiIish+MM67TLKvY4zsjqcUCJEiVw9uxZdOvWLVU7YwqFAsOGDcOOHTtSJY1xnEFE76JZs2Zh2rRpAIB58+ahV69eNo6IiIiIiIjo3WJfZxaJcqDatWtj3bp1YvncuXNZMhW28Z3EcpaoMGZ84j1lX7ldiRIlcO/ePQBAWFgY9Hq9rBmY/v33XxgMBrFsfGd0Vrl37x7+/vtvsdy4ceMMLzXi6uqKBQsWYPz48di6dSuOHTuGp0+fIjY2FoUKFUKVKlXQq1cv1KxZEwDw5MkTSftq1aplfEeIiIiIKNM4zrBv9jrOyOpxQP78+bFhwwZMnjwZ27dvx8mTJ/H8+XNoNBr4+fmhVq1a6NOnD8qXL5+qf1dXV5QrV86q+0tEZO+WL1+O0aNHAwC+/fZbDBs2zMYRERERERERvXuYGEWUSSkvThw6dAj/+9//rL4d4yUHEhMTERUVJXuZi5cvX6bZV25XsWJFHDhwAACg0+nw8OFDlCpVKt12oaGhqfrJasazRQHAwIEDM92nv78/Ro0ahVGjRpmtd+3aNfFxkSJF4Ovrm+ltExEREVHGcZxh3+x9nJHV44CKFSvKit24/+rVq1u0TDgRUU63detWDBo0CAAwZswYfPXVVzaOiIiIiIiI6N3EpfSIMqly5cooVqyYWD5w4ECWLHNRtmxZSfnq1auy2xqfjC5cuLDFS2TkZFWrVpWUT58+LavdqVOnJOXKlStbLSZTdDodVq1aJZbz5s2LLl26ZOk2k0VHR+PixYtiuXnz5tmyXSIiIiJKG8cZ9i2njDPMyepxwJ07d/D06dMs65+IyJ4dPHgQPXv2hMFgwIABAzBz5kyzy5ASERERERFR1mFiFFEmKZVKcUpsADAYDJg6darVt1O3bl1Jec+ePbLaxcXF4ejRo2n2k9sFBwdLTjzt379fVrvku7+BpCSlBg0aWD02Y7t378azZ8/Ecq9eveDs7Jyl20y2efNmJCQkiOVPPvkkW7ZLRERERGnjOMO+5ZRxhjlZPQ5Yu3at+FilUmHAgAFW7Z+IyF6dOXMGHTt2RGJiIj744AMsXryYSVFEREREREQ2xMQoIisYNGgQChYsKJZXrlyJ7du3Z7i/vXv3plpioUSJEqhUqZJYXr16NeLi4tLta9WqVXj79q1Yfv/99zMcV05UqFAhyUWazZs3IyIiwmyb27dv48SJE2K5bdu2cHBwyLIYgaxZRk+OuLg4fPPNN2K5evXqqFevXrZsm4iIiIjM4zjDfuWUcUZasnoc8OzZM8yZM0csd+jQAUWKFLFa/0RE9ur69esIDg5GbGwsWrZsibVr13IZUSIiIiIiIhtjYhSl8urVK+zZswcLFy7E999/jx9//BFLly7FsWPHJCe+6f+5urpizZo1UCr//1eqR48e2Lp1q0X9JCYmYsqUKWjbti1iYmJS/XzYsGHi47CwMEyaNMlsf//++6+kjpeXF3r06GFRTNmhX79+UCgU4j/jO8+tYeTIkeLj+Ph4fP3112brjxo1SlIeMWKE2fqZjf/Zs2fYvXu3WK5RowYCAwMt6iMj9Ho9Bg4ciEePHgFImpVgwYIFWb5dIiIiIpKH44zMedfHGWnJ6nFAXFwcPvzwQ0RHRwMA3Nzc8Msvv1itfyIie3Xv3j20bNkSkZGRqFevHrZu3QonJydbh0VERERERPTOY2IUifbt24fmzZvDx8cHbdq0wbBhw/DVV19h/Pjx+OSTT9C4cWPkz58fPXv2REhIiK3DtTstW7bElClTxLJGo0HXrl3x0Ucf4cGDB2bbxsbGYvny5ShbtiymTp0Kg8Fgst6AAQMkd3P//PPPmDp1KvR6faq6//zzD1q1aoXw8HDxue+++y7blmezJ127dkWNGjXE8qJFi0yemDcYDBg5ciT27t0rPtelSxfUqlUrS+NbtWoVdDqdWM7sbFFr167Fvn37TH4ukj148ADt2rXD+vXrxefGjh2LOnXqZGrbRERERGRdHGfYL3sbZ2T1OGD+/Pk4efIkBEFIs861a9fQtGlTSRLXzJkz4e/vL28niIhyqKdPn6JFixZ4/vw5qlSpgr/++gtubm62DouIiIiIiIgAqG0dANmeXq/H0KFDsXTp0nTrajQa/PHHH9iyZQt++eUXDB8+PBsizDkmTpyIPHnyYMyYMdDr9TAYDFizZg3Wrl2LwMBABAUFwc/PD97e3oiOjsaLFy9w6dIlHD16FBqNJt3+nZycsGbNGjRq1EicvWvKlClYt24dunbtihIlSiA2NhZnzpzB9u3bkZCQILbt2LEjBg8enGX7bs8UCgXWrVuHevXqISIiAoIgYMyYMfj999/RuXNn+Pj44PHjx1i/fj3u3r0rtitRokS2zKC0fPly8bGrqyt69uyZqf5OnDiBxYsXw8vLC02bNkXVqlXh4+MDAHj+/DmOHz+Oo0ePQqvVim0+/vhjfP/995naLhERERFlDY4z7JO9jTOyehywc+dODB8+HH5+fmjSpAkqV66M/PnzQ6vVIiwsDIcPH8bp06clCXiTJ0/G0KFDrbujRER25vXr12jZsiUePnyI0qVLY9++fciXL5+twyIiIiIiIqL/MDGK8Nlnn6VKigoKCkKzZs3g5+cHrVaL0NBQ/Pnnn7hz5w4AQKvV4rPPPoOnpyf69Olji7Dt1ogRI1CpUiWMGjUKN27cAAAIgoDLly/j8uXL6bb39fXF1KlTUblyZZM/r1atGg4dOoS2bduKd2nfvXsX3333XZp99ujRA6tXr87A3uQe5cqVw44dO9ClSxe8fPkSAHDx4kVcvHjRZP1SpUph165dKFiwYJbG9ffff0suknzwwQfw9PS0St9v3rzB5s2bsXnz5jTrODg4YPz48Zg6dapkiRYiIiIisi8cZ9gnexxnZPU4ICwsDOvWrTNbx93dHd9//z1vpiKiXC8mJgbBwcG4efMmChcujAMHDqBQoUK2DouIiIiIiIiM8Cr4O+7cuXNYtGiRWM6bNy8OHTqEI0eOYMKECejfvz8GDx6MH3/8Ebdv38aMGTMk7UeOHImYmJjsDtvuNW/eHNeuXcP69evRqlUruLq6mq3v4OCAZs2aYdWqVQgNDcWgQYOgUqnSrF+7dm38888/+Pzzz5EnT54061WpUgVbt27F+vXr4eDgkOH9yS0aNGiAGzduoF+/fmm+J/ny5cOoUaNw9epVlC9fPstjWrZsmaSc2WX0AKBZs2aoX7++2ffc3d0dPXr0wNWrVzFt2jQmRRERERHlABxn2Cd7GWdk9Tigffv2qF69utk2Xl5eGDhwIG7dusWkKCLK9RISEtChQwecP38e3t7eOHDgAIoXL27rsIiIiIiIiCgFhSAIgq2DINv59NNPJVP4b9myBZ07d7aozfr169GjR48si9GckJAQBAQEiOUbN26gUqVKNonFnMTERJw7dw7//vsvwsPDERUVBXd3d+TLlw/lypVDYGAgnJycMtS3VqvFyZMnce/ePYSHh8PZ2Rk+Pj6oV68eT8aYERsbi7///huPHz9GREQEChQogOLFi6NRo0ZwdHS0dXhW8fbtW5w7dw737t3DmzdvAACFChVC0aJF8d5778HZ2dnGERIRERHZr5ww1uA4w/7Ywzgjq8cBEREROHv2LB48eICIiAg4ODigUKFCKF68OOrVqwe1mpOTE1Hup9Pp8MEHH+DPP/+Eh4cHDh8+jJo1a9o6LCIiIiIiIjKBiVHvuLp16+Ls2bMAgIIFC+L58+dQKBRm29y4cUOy/ML48ePxww8/ZGmcackJFyuIiIiIiCjn4ViDiIiITDEYDOjXrx/WrFkDJycn7N27F0FBQbYOi4iIiIiIiNLAtZPeca9fvxYflypVKt2kKAAoU6aMpJx8ByoRERERERERERFRbiUIAkaOHIk1a9ZApVJh06ZNTIoiIiIiIiKyc0yMesd5eXmJj2NjY2W1SVmvYMGCVo2JiIiIiIiIiIiIyN5MmTIFv/76KwBg5cqVaNeunY0jIiIiIiIiovQwMeodV79+ffFxSEgIXrx4kW6bQ4cOScqNGjWyelxERERERERERERE9mL27Nn45ptvAADz5s1D7969bRwRERERERERycHEqHfckCFD4ODgAADQ6/UYMWIEBEFIs/7r16/x9ddfi+WqVauiRYsWWR4nERERERERERERkS2sWLECo0aNAgBMmzYNn376qY0jIiIiIiIiIrmYGPWOK1euHH744QexvGHDBrRo0QLHjx+HTqcTn3/79i3Wr1+PWrVq4e7duwCA/PnzY/369VAoFNkeNxEREREREREREVEyg0FArEaHN7GJCH+rwasYDcLfavAmNhGxGh0MhrRvBjVn69atGDhwIABg9OjRkptGiYiIiIiIyP6pbR0A2d7o0aORN29ejBkzBpGRkTh06BAOHToEZ2dnFCxYEDqdDs+fP4fBYBDbNG/eHIsXL0bJkiWtFsfLly/x6tUri9rcu3fPatsnIiIiIiIiIiKinEWrNyBOo4dGp0eq1CcB0EOAVm9ArEYHJ7UKrk4qOKjk3S988OBB9OzZEwaDAf3798dPP/3Em0SJiIiIiIhyGCZGEQCgf//+6NKlC8aPH48lS5ZAEAQkJCTg8ePHknpubm6YOnUqRo0aBaXSuhOOLViwAFOnTrVqn0REREREZN+uXr2KmjVrSmasbdy4MY4ePWq7oIiIiChHeKvRIVbz/8cQiToDEnR6GAwCBAFQKAClUgFntQqOaiUSdHok6PRwc1LD3cn8qfEzZ86gY8eOSExMRJcuXbBkyRImRREREREREeVAXEqPAAC7d+9GgwYNsHjxYghC2tNKx8bGYuzYsahQoQIOHTqUjRESEREREVFuo9frMXDgQElSFBEREZEcUfFaMSkqIVGPiNhERMVrodEaoNUL0BkEaPUCNFoDouK1iIhNREKiHgAQq9EhOkGbZt/Xr19HmzZtEBsbixYtWmDdunVQqVTZsl9ERERERERkXUyMIkydOhVt27bFjRs3AADlypXDkiVLEBoaioSEBMTExODKlSv45ptvkC9fPgDAnTt30KJFCyxfvtyWoRMRERERUQ42a9YsXLhwwdZhEBERUQ7zVqNDgjYpySk6QYsYjQ46gwCFAnB2UMLDWQ1PFwd4OKvh7KCEQgHoDAJijBKi4hP1eKtJnZwdGhqKli1bIiIiAnXr1sXWrVvh5OSUrftHRERERERE1qMQzE0PRLne+vXr8eGHH4rlDh06YP369XBxcTFZ//Hjx2jatClCQ0MBAGq1GufOnUO1atUyHcvLly/x6tUri9rcu3cPHTt2FMs3btxApUqVMh0LERERERFlrfv376Ny5cqIi4tDgQIFYDAY8Pr1awD2sZReSEgIAgICxDLHGkRERPZBqzfgTWwigKSkKI3WAABwdVTBxVEFpYnl7gyCgPhEPeL+mzHKyUGJPM4OAAAvN0c4qJLuHw4LC0ODBg3w4MEDVK5cGX///bd4oygRERERERHlTOYXUqdcTafTYdy4cWLZ19cX69atSzMpCgCKFSuGDRs2oFatWhAEATqdDpMmTcLOnTszHU/BggVRsGDBTPdDRERERET275NPPkFcXBwA4JdffsGECRPExCgiIiKitMRpkpKbEhL1YlJUHhc1nNRpL3WnVCjg5qSGWqVAdLwOGq0BCSo9nB1UiNPo4emqxOvXr9GiRQs8ePAApUqVwv79+5kURURERERElAtwKb132IkTJ/Dvv/+K5Y8//hhubm7ptqtRowbq1asnlvft2yde0CAiIiIiIkrP8uXLcejQIQBA8+bN0bt3bxtHRERERDmBwSBAo0tKjIr/byk9V0eV2aQoY05qFVwdk+rG/zd7lEanR1RUNIKDg3Hz5k34+fnh4MGDKFSoUBbsAREREREREWU3Jka9w65evSop16xZU3Zb47parRZ37tyxWlxERERERJR7vXjxAmPHjgUAODs7Y9GiRTaOiIiIiHKKeK0eAoBEnQE6gwCFAnBxlJcUlczFUQWFAtAZBCTqDIhPSECHjh1x/vx5eHt748CBAyhevHiWxE9ERERERETZj4lR77DY2FhJ2d3dXXbblDNLxcfHWyUmIiIiIiLK3YYPH46IiAgAwMSJE1GqVCkbR0REREQ5hUaXtHRewn+zRjmplVAqFBb1oVQo4KhKOi3+NkGDoQM+wt9Hj8Dd3R179uxBxYoVrRs0ERERERER2RQTo95h+fLlk5SfP38uu+2zZ88kZW9vb6vEREREREREudeff/6JzZs3AwAqVaqE//3vfzaOiIiIiHISgyAk/W9I+t9BlbHT245qJQwGA74c+Sn27NoJJycn7Ny5E7Vq1bJarERERERERGQfmBj1DitdurSkfODAAVnt9Ho9Dh8+LJadnZ1RtGhRq8ZGRERERES5S1RUFIYNGwYAUCgUWLx4MRwcHGwcFREREeUk/+VFif9bOluUUU/4ccqX+HPTeqhUKixdtQ5BQUHWCJGIiIiIiIjsDBOj3mENGzaEq6urWP7jjz9w7dq1dNvNmzcPjx8/FsuNGjWCi4tLlsRIRERERES5w7hx4xAWFgYAGDRoEN577z0bR0REREQ5TXIeVPL/yTNIWWrWjO+wbvliAMCchUsR3PZ9a4RHREREREREdkht6wDIdpydnTFs2DD89NNPAACtVos2bdpg48aNqF+/fqr6giBg4cKFGDt2rOT5lGUiIiIiIiJjx44dw9KlSwEAPj4+mDFjRrZu/+XLl3j16pVFbe7du5dF0RAREVFGKRUK6CFAqVQAegFavQHODiqL+li6cB7mzPweADDxu5n4oHvPTMw8RURERERERPaOiVHvuAkTJmD37t24efMmAODp06d47733EBQUhKZNm6Jw4cLQarUIDQ3Fjh078M8//0ja9+vXDy1atLBF6ERERERElAMkJCRg0KBBEP6b0WH27NnImzdvtsawYMECTJ06NVu3SURERNbnpFYmJUOpVdBoDdDoDHATBNmJTX+sW4OJX/wPAPDp2K8waPAwsV8iIiIiIiLKnZgY9Y7z9PTE/v370blzZ5w7d058/ujRozh69KjZtgMGDMCiRYuyOEIiIiIiIsrJpk6dijt37gAAWrdujR49etg4IiIiIsqpXBxUiNXo4KhWQq1UQGcQEJ+oh5tT+qe5d+/8E6OHDwEA9Bk0DJ+OGgdHtRKK//olIiIiIiKi3Im3whAKFy6MU6dOYeHChahcubLZukqlEq1atcK+ffvw22+/Qa1mbh0REREREZl29epVceluV1dXLFiwwMYRERERUU6mVCrgpE5KYkpOZopL1EOj05ttd/zoEQzp/xEMBgM6du+F/02aDtf/kqmc1KqkpfmIiIiIiIgoV2JWCwEAVCoVhgwZgiFDhuDff//FhQsX8PTpU0RFRUGlUiFv3rwoVaoUatWqBU9PT1uHS0REREREdk6v12PAgAHQ6XQAgEmTJqFEiRI2iWXYsGHo2rWrRW3u3buHjh07Zk1ARERElGGuTiok6PRwdlQh0WCARmtAdLwOro4CXBxVqZbVu3ThHPp+2BWJiYloHtwOk2fMgbOjCs7/JVa5OnG2KCIiIiIiotyMiVGUSpEiRVCkSBFbh0FERERERDnYrFmzcPHiRQBA5cqVMWbMGJvFUrBgQRQsWNBm2yciIiLrcVAp4eakRqxGhzzODoiGFhqtAXGJesRr9XBUKZOWyFMAt2+GoGeXDoiLjUW9Rk0wY95vcHNxRB5nBwCAm5MaDiouqkBERERERJSbMTGKiIiIiIiIrOr58+eYPHkygKTluJcsWcJluImIiMhq3J3U0BsEJGj1yOPsgASVHvGJeugMAjQ6AzQ6A548eoi+H3RAVGQkqlSvhV+XrYW3p5s4U5SLowruTjw+ISIiIiIiyu048iMiIiLKYgaDgHitHhqdAQZBgCAACgWgVCjgpFbCxUEFpVKRfkdERDnE8+fPERcXByBp2e7evXun2+bp06fi47Nnz6J06dJiuUWLFli4cKH1AyUiIqIcy9PFASqlArEaHZwdkpbGS9QZkKDT41lYGD7p2QGvXjxH2fIVsXbjVhQs4CW2dXNSMymKiIiIiIjoHcHRHxEREVEW0eoNiNPoodHpIaT8oQDoIUCrNyBWo4OTWgVXJxWXcSCiXEer1SI0NNSiNgkJCZI2AQEB1g6LiIiIcgF3JzWc1Epx3OWoVuJtdAQ++bAz/n38CMVLlMSmP3ehYIH8UAAcdxEREREREb2DmBhFRERElAXeanSI1ejEcvKdywaD0YxRSgWc1So4qpVI0OmRoNPzzmUiIiIiIiILOKiU8HRVwmBQ4+WbSPTu2gn/3LqJQr5+2LzjLxQpXJgz9RIREREREb3DeNWNiIiIyMqi4rVI0OoBAAmJesRr9dAZkuaMMhgEaHR6aPUGGARAEAC1SgEXRzU8ndUwGAQYBAF5nB1suQtERJkSGBgIQUg1V55ZxYsXx6NHjwAAjRs3xtGjR7MgMiIiIsqtEhM16NX9A1y6cB5eXl44eGA/KlUqb+uwiIiIiIiIyMaYGEVERERkRW81OjEpKjpBC43WAADQGQwQDIAAAWqVEkqlAlq9gESd4b9/iUjQ6uDh5IC3Gh30BgH5XB1tuStEREREREQ5gk6nQ8+ePXH48GG4u7tj7969qFSpkq3DIiIiIiIiIjvAxCgiIiIiK9HqDeLyecZJUYAApUIBpTpp2QatzoBEvQGCQYACArR6AxL0Buj0KgCAOxzwNCIeAJgcRUREREREZIbBYMDAgQOxfft2ODk5YceOHahVq5atwyIiIiIiIiI7wcQoIiIiIiuJ0/z/8nnJSVEKBSAICigVgEarR4LRsnrJ1ColHAUgRqNFfKIOgpsAD1dHhMdooFIquKweERERERGRCYIgYPTo0Vi1ahVUKhU2btyIJk2a2DosIiIiIiIisiNMjCIiIiKyAoNBgEaXlBgV/99SeoAAQUiaJSpGo0WiUbKUo1oJB5USSihg+G/WKAMExCfq8TpOC6gUUCgcEKvRQalQwN2Jh21ERERERETGvvnmG8yZMwcAsGLFCrRv397GEREREREREZG94RU2IiIiIiuI1+ohAEjUGaAzCNAZDEnL5ymkSVEujio4O6igVCgk7Z3USc+/iEpAvFYvzj7l6phU1+m/RCoiIiIiIiIC5syZgylTpgAA5s6diz59+tg2ICIiIiIiIrJLTIwiIiIisgKNLinxKeG/WaMEA6BUK6DR6sWkKA9nNRzVqjT7UCuV8HRxhEqphUZngFqpQHS8Fq6OasRp9PB0ZWIUEeVeDx8+tHUIRERElEOsWrUKI0eOBABMnToVn332mW0DIiIiIiIiIrvFxCgiIiIiKzAIQtL/BgEGgwABSeWE/5bVc3FUmU2KSuagVsBBp4RCkdQ+PjGpvUanh8GghlKpMNeciIiIiIgoV9u+fTsGDBgAABg5ciQmTpxo44iIiIiIiIjInnHaASIiIiIr+C8vCoKQlMSk+D/27jxKsruu///zs9x7q6qXWbJAAAUjCBI2+QqiyKaCCAKRRSAsERAQRBBBEJQloAiCICg7hBAgShBQMKAg/gBBRVEQ2YWwCISQzNbdVXWXz/L741bXzGQmyUwySU/PvB7n5HRXdd3bn+45J13ve1+f99sYutlYPWNgUFx5KArA0AefSm8wBrqUaUMi04/rExEREREROV595CMf4cEPfjAxRn7t136NP/3TP8UYbR4RERERERGRy6dglIiIiMgRsH4t3hjoYiLlTB37IFPpLfYQL9avd5ryxlI4i2HveL71cX0iIiIiIiLHm0996lPc7373o21b7n//+/PGN74Ra3V5W0RERERERK6YKkcRERGRI2A9+GStIWXoYianPuRUuEN/y9WF/hhj+0CVMYY0O8/6uD4REREREZHjyec//3nuda97MR6P+YVf+AXOO+88vPcbvSwRERERERHZBBSMEhERETkCKt+/rRp4R87QhkScBZosh9YtKuVMG9P8PAYond1vTJ+IiIiIiMjx5MILL+Qe97gHO3fu5A53uAPvfe97qapqo5clIiIiIiIim4SCUSIiIiJHwLCYBZm8xTtDzpl2NvoucWiJprqL5Jzx1uBnXaaqwu43pk9EREREROR4cdFFF3H3u9+diy66iFvc4hZccMEFLC4ubvSyREREREREZBNRMEpERETkCLDWUHkHwLDsRzrUMdGGRDfrAnVF2pCYthGAQen2ntcYrDXzz0VERERERI4HO3fu5B73uAcXXnghp556Kh/60IfYvn37Ri9LRERERERENhkNYhcRERE5QkaVow6RLQNP3QVCdKw2HYnMoHB4e2AmPeVM3cV5KKoqLJV3pJxxs0DUYBa4Wh/XJyIiIiIicixbW1vjXve6F5///Oc55ZRT+Md//EdOOeWUjV6WiIiIiIiIbEIKRomIiIgcIYWzLFSelDJLVQHAtA1M28jFe2q2DEsKbzAYMpkuZNqYyLkftVcVlsXZcdYAxuKtofQWQz+uT0RERERE5FhW1zWnn346n/rUp9i+fTsf/vCH+ZEf+ZGNXpaIiIiIiIhsUgpGiYiIiBxBi5UnpsxaE1ikIC9kdkw6pl3E2Y4iHNj1yVvDoHTzUXzWQkp9t6hhud4tys1H6omIiIiIiByLQgg89KEP5SMf+QiLi4t88IMf5LTTTtvoZYmIiIiIiMgmpmCUiIiIyBG2ZViQcua7u6YsjUpwhkkTaULCmEzpDd5YjO3H5HnXh6VSzlizNxRVFZbBrEvUqFK3KBEREREROXallHjsYx/L3/zN31BVFX/7t3/L7W9/+41eloiIiIiIiGxyCkaJiIiIXAO2jUoALl1tMKYfj+dnHZ9yBmw/ei/lTBsiAM4aMH1Iqiosy4P+uIXKU7gDO01tRillpl0fEks5kzMYA9YYKm8ZFuqMJSIiIiJyvMk587SnPY1zzjkH5xzvfOc7+bmf+7mNXpaIiIiIiIgcAxSMEhEREbmGbBuVWGOYtIFR6ViZdkzbSJcyMWXqLlE6S1VYrOnDQN4ahqWbd4oalo7FavO/ZetimnXNiuTLfjFDJNPFxLgJVN4xqtwxEwYTEREREZEr9sIXvpA/+7M/A+Dss8/mfve738YuSERERERERI4Zm/8um4iIiMhRbMuwwFmDNYZR2b/1akOiDpGU9umYZA0D7yj93jDQQuWPiVDUWhMYN2H++Mp+/jpE6hCPmZ9fREREREQu36te9Sqe97znAfDKV76SRz7ykRu8IhERERERETmW6E6TiIiIyDVssfJU3s47JpXe7heA2peBY6pj0p5pR931owLrNjLtIiEd0DMKYqbpUt8xq3AMSse4CaSc5yMFRURERETk6Hc447PPPfdcnvKUpwDw/Oc/nyc/+ckbuXQRERERERE5BikYJSIiInItKJxly8iSkj/kmwSb3VoT5qGolbqj6RLQ/7yVtxSuHyGYcj9GrwmJkDKrTaBNieVBwbSNWGPUOUpERERE5Ch3ReOzU8zUXaSNiZz7+uif//ED/PqjHw3Ak5/8ZJ773Ode+4sWERERERGRY57uMImIiIhci6w1LFSehWqjV3LN6mKaj8/bNxQ1Kh3D0mHN/uGvQeFYyJlpG5m0kaZLrNCxPCgYN2EepBIRERERkaPP5Y3PbrrEtI2EGDGz8dneWT75z//EEx71CGKMPPhhj+BZZ/0xK9NwzHTOFRERERERkaOHglEiIiIicsRNmr3j89ZDUctDT+Xd5R5jTR8a886wMg00XaJ2kUHhmDSRLSPdIBEREREROdpc3vjsSRuYtnH+utAmdsSW//2fz/CsX38oXdtyl3vcm9//4z/DWEsdInWILFReHWNFRERERETkiFGFKSIiIiJHVEqZJvQ3QKazGySj0l1hKGpflXeMysykjUzbPhjVhEhK/pgZMygiIiIicrRJKR/22O/LG5+91nSAYXHg6ULfNaoJkQu/+iWe88SHU08n3PqnfpZnv/Q17JwEujThhIWKQekYN4GUM8uD4tr+FYiIiIiIiMgxSMEoERERETmipl0k04/PCCljDAzLQwtFrRuWbr7TvA2J0lumXb97XEREREREjpwuJiZNH1zKl/1ihkiej8quvJuPu7u88dmQGZUeawyrTUcbEtYaVi/5Li940sNZ27Obm93qtrzgz8/BFxXGwGod+g6yybM8KJi2EWuMOkeJiIiIiIjI1abKUkRERESOqCb0N0TqWdeoylusObxOT9YYSmdpQqIOkdL3ny9UR3y5IiIiIiLHrbUmzMNN0G9uqEMkpX06RlnDwDtKv/+4uxj7GNW+47OHpWXaJqyhD0XNnh/vvoSnP/pXufTi73Pjm96c15z7LuxgcXaMI2eou4R3iRU6lgfFLIhlKZxGaouIiIiIiMhVp2CUiIiIiBxRKfc3SFLqP17VGxnrYaj186yfV0RERERErr49024+Bq9u47xj6wFipukS3hqGhWNQOlbrjkkbWaz8fuOz4+z4povzUFSqV3nKmb/Kd779TW5wwxvx+ne8m5NOPIFJG5i2/eu2jEraGEm5/16160dqT5rIlpGCUSIiIiIiInLVKRglIiIiIkfUen5p/ePhdotat37YZc8nIiIiIiJXz1oT5qGofcfgGcO8S5M1hpT7MXrNbEz2ahNoUx+SmraREPeOz668ZfekA5ifO3dTfvtRD+FrX/kiJ13nurzhvL/h5OueAsCgcNRdf3yIidI5DJCBadsHo5oQSclj7VWrKUREREREREQUjBIRERGRI8rM7masB5uuaqen9cPWz3MV81UiIiIiIrKPLqb5+Lx9Q1Gj0jEs3QEbGwaFYyFnpm1kMhubtydEBt6xa9Iy8I7FgacNiQx0sxBV1zX8wRPO5HOf+TTLW7by+ne8hx+64Y3m5907Prsfz7foLNZCyhBSpg2J0lumXT+6T0REREREROSqUEUpIiIiR52UMtMu9mPUcibPQjbWGCpvGRZOO4aPYtYYIrn/N4r9DvNB4Q77PG3ob9Cs/1tf1c5TIiIiIiKy16TZOz5vPRS1PPRU/vLfs1tjWKg83hlWpoG6jRj21m7bFsq9Y/liJITAHz7tCXzqEx9jOFrgtW/7a25ys5sfcN7CG5oAOa0/YyidoQmJOsT5eO2F6kj+BkREREREROR4omCUiIiIHDW6mJg0kSZEDugxlCGS57ubK+8YVY7C2Y1YqlyByts+DOUdTdeP3VjI+bCCTSln2tjfHRnMbtBUXv/WIiIiIiJXR0qZJvQBpuksyDQq3RWGovZVeceozOya9MEqgBAT5L7TE0AMkZc952l87EMXUJQlrzr7PG5125886PkMfY2w3mU250zpXb9JZnbCq9qBVkRERERERAQUjBIREZGjxFoT5uMcoO8WVIdISvt0jLKGgXeU3lLPxi0sVJ5FjVU4qgwLx7gJlN7irSGkfuzG4Yy/mLaRnMFbQ+ktZnZeERERERG56qZdvwmlnY27MwaG5eG9z+7H7UGImZwzxhimbSBjyDnzF3/8PP7+vX+Fc46XvuZs7vCzd7ncc+XZlpj1TRTGmPkI7fU8lHJRIiIiIiIicnXoLqKIiIhsuD3Tbu/YhTYy7SIhHeTqd8w0XcJbw7BwDMo+gJNyZnlQXMurlstjraHyjjpEhoVjtQlM2oh35pB2ojchMpntPl+/SVN5jU8UEREREbm6mtm46nrWNarydh5KSjlTd5E2JFJmHnqyBkpvGRQOa8xsxLkjxEDM4A2M28io8rz+lS/lnee8HoDn/Mmr+Pl7/vIVrqcLfd1nZs1hrdkbhFoPSGmitoiIiIiIiFwdCkaJiIjIhlprwjwUtVJ3NF1/od6Y/iJ94foL9Sn3Y/Sa2c7m1SbQpsTyoGDaRqwx6hx1FBlVfTBqUDralGi6xMo0MCrzbIf5gXc3Uu47S62Hoqqiv/myfj4REREREbl61sfSrY+pK5wlxMSkjbQxHdidKWci0MX+fXrpLKPSsVD1m1TWp13XIfGet7+OV7/sRQA86dkv5BdP/9UrXctlx2eX3tLOwlvrGyMOZyS3iIiIiIiIyGXp7qGIiIhsmC6m+fi8fUNRo9IdNDwzKBwL+4Rnmi6xQsfyoGDchHmQSjZe4SwLlWfcBJYHBSv0/76TWUew0tl+RN5sR3gb0n43YqrCzruALVRe/64iIiIiIgeRUmbaRZqQSHmfMeTGUHnLsNi/8+plx9PVbaTbp1tviJc/0tw7SxP6zSrW9t2k3Kxm++B73smLnvNMAB73lGfwwEc+ru88VebLDTbVXSTnjLcG7/raoPSWSdsBe8NSlVctICIiIiIiIledglEiIiKyYSbN3vF566Go5aG/wnFr1hgWKo93hpVpoOkStYsMCsekiWwZ6aL50WKx8sTUj+NYHhTULjJt+zGJ6zdULstbw7B0805Rw9KpE5iIiIiIyGV0MTFpIk2IHDCEPEMkzzeiVN4xqhzFLHzELPC01gSK2bjrJkTq9spHmg9KR+Ud0zYRYsIXln/9//6BFz/7KQA89Ncex5Oe/ixWph1hVguMygPfz7chMZ11ih3MxmeXztJ0/WYJb02/kQIYFuoeKyIiIiIiIled7jKJiIjIhkgp04T+Qvh0NkpvNLvIfigq7xiVue9A1PbBqCZEUvL77YiWjbVlWOCsYdwEBkUfeGrD5e9CL/fZDb5QeYWiREREREQuY60J8867wJW+v65DpA6RhcpjjSGSqUOk6SJg+5Hl85HmfSCpcGafkeaZdjbSfK0OdMXeTq//+smP8+zf+nVijNz3QQ/lN5/9wr5DrLeEWa3Wh5z6Oi/lPiw13Wd89noN6CzzsdrDcr1blFN9JyIiIiIiIleL7jSJiIjIhph2/c7m9Qvsxuy9+H2ohqVj2vW7mtuQKL1l2vUX/OXosVh5Km/nO9pLb/cLQO3LwH472kVEREREZK89046629t5d70eOsA+XZ6GhWNQOsZNIOdMTJnUn4Jdk46Bt1izt3PrZUffVR5SuTfQNG0jdUh860v/zXN+80zapuEev/TLvPjPXk0T+jUaY2hTggQ71tr5qPSQMnmWqqoKy2JVkHLGGpi0af78egfZUaVuUSIiIiIiInL16K6hiIiIbIj1MWr1rGtUNbsYfzisMf24hdkO6dL3ny9UR3y5cjUVzrJlZEnJM+0iTUikvM+OdmOovGVYaEe4iIiIiMjBrDVhHopaqbt9ujz19VTh7D5dnvrR1SFlVptAmxLLg4IM7Bi3FN4SU6bpIgY4eWlwuZsXoH+/Pio93lp+sFrzta98id9/7BlMx2Nu/zN34nVnn8toNKTuIinDat1RWstaCHQhMW4DxoC3lmHpGBb9elfrDmfNfNxeVViWBwXQd5DVZgkRERERERG5uhSMEhERkQ2RZruE02x381W94L0ehlo/z/p55ehkrWGh8gqviYiIiIgchi6m+fi8fUNRo9LNuzGl1Hd1amMiZcgZmtnIvKK15JRZGhZMZmOu93eodVTm+9/5Ns9/whms7tnFLW/z/3j9ue/khC2LTLt+xPn1tw3ZOXbsmbaUrmQaIm2XSPQBLmcMbci0ITAs3SxwtbdjFfTdgTVWW0RERERERI4EVZciIiKyIdbzS+sfD7db1Lr1wy57PhERERERkWPFpNk7Pm89FLU89FTe0cXEWhtoQzog3lR5h8GwWneMm4BdqQkxs2OtIeZ+tLkzcMlqw5ZhwajyB63NUu5DV9/5zvf4/cc/hJ2XXMyNbnJT/vyt53Pi9i04a9i+UM7HZ29fKPtx2m1kib4DVBcSdYzkDIU1jEpHWTgG3u3XrWqh8gpFiYiIiIiIyBGjClNEREQ2hDFA3htsuqqdntYPWz/PVcxXiYiIiIiIHJVSyjSzEeTT2Si9UemovGPcBCZtnL92Hj5Ke8dW51kAatIGpl1iUFimTaQqbR9AMv156y5SOMvS0DMqPbOSjTYkupjYs2sXv/vrD+Z73/4m1/uhG/KyN53P1m3bKdz6SHO/3/jswllGZWTS9F2sisqx1RcMCndA+MrQh7hGldP4PBERERERETmiFIwSERGRDWGNIZKx1kDMdDEdZJzDlWtDv1vaWjM/r4iIiIiIyLFi2sV5QCmkjDH9qLmVumM669C0Wgd2T1umbZofV3lDzv0mFOcMTZtYayNdtNRtZK2BExcrytJROktKmTYmdqy1jIvIcJ/6bDIe86zfeBgXfvVLnHjydXjN29/NdW5wPQZFH2Lad6PLwcZnp5SZdrEfg573hrasMVTeMizcvKYTEREREREROZIUjBIREZENUXnbh6G8o+lSv8M458MKNqXcX7gHGHg3P6+IiIiIiMixopltBqlnXaMqb1mpO3autUzbyM5xy6QLfdgI8NZSOMOkS7RdBNMHk+ousdZ0TCtPafu6KeZMNzu/N4bSWTAQY6axicXS0XUtL/jtR/OFz/4ny1u28obz3stNb3ITwqwrFVz5SPODhaVERERERERErg0KRomIiMiGGBb92IfSW7w1hJSZtpGF6tDfnkzbSM7graH0FjM7r4iIiIiIyLFivRtTSv3HSRfYtdYx7fpQ1LTtR9U5k+mjUf3jlDOlc6SUCTkRUqLpMs5EyqFhWHiGpWexdIy7flxeiInCWxYHs7osJ/7waU/g3/75owxHC7z5L9/N7W57a2LKrNZBI81FRERERETkqKdglIiIiGwIaw2Vd9ShH9Gw2gQmbcS7/vkr04TIpO13TA/L9W5RGr8gIiIiIiLHln27Mq02HV1IjNvArrWWPdOOOkS8tQQLkEkpz2ul3aHDGCidY1hYRoMMydCGTFVkDFAWjm2LFZM2sGcS6GJiGiJDZ/ijZ/0O//jB91OWJeecdz53uuPPADBtO0AjzUVEREREROTop2CUiIiIbJhR1QejBqWjTYmmS6xMA6MyMyzdQS+up9x3llq/0F8VlsGsS9SoUrcoERERERE5thgD5L5jbt1G1urAShPYM+0YtxFnofT9+LzKO6Yh4K1h3CSalIg54ZwlkAkBCgcYGNeBbiHRhL5z72JVUDrLah3IOfOGl53FB979l1hred3Z53KXu/0coJHmIiIiIiIisrkoGCUiIiIbpnCWhcozbgLLg4IVOpouMWkj0y5SOtuPyDP97ug2JNqY5jumq8KyPCgAWKg8hdPFeBERERER2XxSyky7SBP6EXg594Eoawx1G0k508TIpA1cvNpgyIzbiDWwZVSwUHrKWTgpAaXLQMDZPshkjWGtjngLTUgMCksbM3WIVJ2jCZFh4Sm9Y1hmXv/Kl3Lem18LwAv/9C+4573vO1+rRpqLiIiIiIjIZqJglFyuEAL/9m//xre+9S0uuugiuq5j69atnHrqqfzET/wEJ5988kYvUUREjgGLlSemTN1FlgcFtYtM20hImSYkmpAOOMZbw7B0805Rw9KxWOltjYiIiIiIbC5dTEyaSBMi+bJfzBDJdClx8Z6GLiZ2rDbUXSDlTOFgUHi2DEq867vtNl0i50xImUSmKiyVt0y7iG0zMUPhLU2XGFWOtTpS+ci4DgyLvqZ67zvezNmvfAkAT3/ui7jvg86g7iKjymukuYiIiIiIiGw6uoMoB/jud7/LC17wAt797nezY8eOy33dzW52M5785CfzhCc84VpcnYiIHIu2DAucNYybwKDoA09tSNQhktI+u6WtYeDdfCc0MBv5oLc0IiIiIiKyuaw1gXET5o8vrwbyxtDFREiZS8ctOUOm76C7UPl5KAqgi328qpttMPHGUnpH3fXj9HLKDArHtAkMypKcMilnVuvAqAr84/v/mhc/55kAnPmbT+f+Zz4WgHoW3NJIcxEREREREdlsdBdR9vPqV7+a3/u932Ntbe1KX/vlL3+ZCy64QMEoERE5IhYrT+XtfLd06e1+Aah9GfpdyaPKaXyeiIiIiIhsOnumHXXXh4zq2SjxkA7oGQUxs7sNTNvAahuwBsZdJMSMtwWVv2ynpv4cadZ417s+VJXJGKAsHWQoC0fbJpaGJQbIZP7x7y/gub/zmwA88JG/zhm/8Ts0bcRkQ8yZLcP+nBppLiIiIiIiIpuJglEy9/znP5+zzjpr/th7z8/+7M9yl7vchete97p477nkkkv43Oc+x0c/+lG+//3vb+BqRUTkWFQ4y5aRJSXPtIs0IZHyPruljaHylmGhUQ0iIiIiIrI5rTVhHopaqTuark8xGQOVtxTOYo0h5UwXEyt1xjnDznFLTOCtpekCkzbSdAk/ez0wH8eXc6YJkaaLxJTJQEwZkzKBxJZBQUizsJSzfPmz/8ZZv/04Yoz84v1+lcf+7llMukgbEsYYrDEaaS4iIiIiIiKbkipXAfpOUfuGon7xF3+RV7/61fzoj/7oQV+fc+Zf/uVf+PznP39tLVFERI4j1hoWKs9Cde18v5SyglgiIiIiInKN62Kaj8/bNxQ1Kh3Dsg8c1V2k7iIp99fg8qxGSbEPShkMpbfEnFitAwkonJkFpiLTENk97mhSpHIW7yzeWqoK6i5ROMNaHfHOUBaWr3z+szznN8+kbRvueo978Qd/8kq6ZPCxP29VWEalZ9tCOf85NNJcRERERERENgtVr8I3vvENnvnMZ84fP+xhD+Otb30rzrnLPcYYwx3veEfueMc7XhtLFBERuUZ0Mc1H9x0wtCJDJM9vXGh0n4iIiIiIXF2TZu/4vPVQ1PLQ44xhrQ60MZEvU5yk1HfXHRSOBDRtx6j0WOeoQ2KYM12EtaZl11ogkYg5E2OmjpHRoO8+VbeJBFgsbUqkZPnON77K83/zEUzHY37qjnfmZa85m2owYLXusKYPTi1WBYUzGmkuIiIiIiIim5KCUcLv/M7vMB6PATj11FN54xvfeIWhKBERkWPBWhPmO7UB2pCoQySlfTpGWcPAO0pvqUOkDlE7o0VERERE5CpJqR9vBzCdjdIblY4QMyvt3tokxP1rk9VZ3eIsbB8VfD9Exk1keWQovcNbQ9tlYoCqMEzaDGSYdcE1QMp5Pm5vpelIOdPsupg3PeMRrO7Zxa1+4v/xtr96F34wmnWryn0n38JTOMO2UcmJi5U66YqIiIiIiMimo7t6x7lvf/vbvO9975s/ft7znsdwONzAFYmIiFzz9kw76m7vTu1pFwnpgJ5REDNNl/DWMCwcg9IxbgIpZ5YHxbW8ahERERER2cymXd+ptg2JkDLGQEiJNvS1SBMidXtgbZJTokuZ6ey4wlqygxihIbAnZwaFYzRw0GTqzlIVhpQMzmUqb1kaFNRdYtJ2NDEy3bWTt//Br7Pzkou54Y1vyqvPfReuGjEqPTnDlmGJt4ZtCyUGFIoSERERERGRTUvBqOPc2WefTUp92+7RaMT973//DV6RiIjINWutCfNQ1ErdzcdXGAOVtxTOYk0/aqKLiWZ282G1CbQpsTwomLYRa4w6R4mIiIiIyCFrQl971LOuUTElcu5H0q01+9YmhtJbCmewxuCsYWXasVC4vpYxmUkTGPqCDKzUgcXKkwBvDYUF6xxLVT96zxgDORNSImUw9Zi/euET2HHRtznxlBvwkjf8FVu3bWfSRiAzaft1DMu+o3zlnUJRIiIiIiIismnpbt5x7sMf/vD889vd7nYsLi5u4GpERESuWV1M8/F5+4aiRqVjWLr5aIl1g8KxkDPTNjJpI02XWKFjeVAwbsI8SCUiIiIiInJlUu47QaWUCTERc6by+4eihqVjUOxfmywPClLKOGfYOe5ICdqQSSmw5DzOGAyGNOssNSodGEPhLW1M1G1iVxvIQFdPOO+FT+Lib36VrSecxB/8xTs4+ZRTmHaBnGGthsWBpyosg6IPRo0qd63/rkRERERERESOFN3JO46FEPjMZz4zf3yrW90KgJQSf/M3f8P9739/Tj31VAaDAdu3b+e0007jN37jN/YLU4mIiGwmk2bv+Lz1Gw/LQ89C5Q8IRa2zxrBQeZaHfZ686dK849T6+URERERERK7MLBdFzlB3CYuhCXtrk6VBwag8sDax1hBSv2FjadAHp4yBaRvYsdbQxsRaE+hCxlqDsYYuJHaOW9qQSCnRxsR4MuUvX/TbfOtLn2W0tIWzXnseN/2xGzNpIz/Y0zBtI21MFN7MR4cvVF6bQURERERERGRTU8eo49hXvvIVptPp/PENbnADvvnNb/LIRz6Sf/7nf97vtU3TsGvXLr74xS/y+te/np/92Z/l7W9/Oze84Q2v7WWLiIhcJSllmtnIiuks2DQqHZU/tN3PlXeMysykjUzbyKBwNCGSktdYCRERERERuVLGABkyeR5Aqtu+NhmWjtIfPIC0Nut6C1B6R0iZmGDcRWj6GqVyjuWhp0qWpkuUtj/XtIvkBJXLvOfPf58L//tfKQcjnvHyt/DDN74Z3lqaru8mlXNmceApZ0GoYek0PlxEREREREQ2PVW2x7FLLrlkv8erq6vc5S534dvf/vb8uS1btrC8vMwPfvADmqaZP/+JT3yC29/+9nzkIx/hFre4xbW2ZhERkatq2kUy0IZESBlj+gv9h2NYOqZdJKRMGxKlt0y7yIJuFoiIiIiIyJWwxhDJdDGTc2baBmICY8x8bN2+Us7sHnes1B05Z3auNeyedEybQEqZwhiMtyQyMe8dG+5mGzcqb7HApAt88HUv4Ev/8mF8UfCMl72Bn7zdT1EVjlFpyQZsNgxmG0fakDhpySsUJSIiIiIiIscEVbfHsd27d+/3+CUveQld1wFwxhln8OxnP5vTTjsNgK7r+NCHPsQzn/lMvvCFLwDwgx/8gAc84AH853/+J4uLi1d7PT/4wQ8OCGtdma997WtX+/uKiMjxoQn9eIp61jWq8vZyx+ddHmsMpbM0IVGHSOn7zxeqI75cERERERE5xlTe0sXEehWy2kQG3jIs3H61SYiJuktMusDKtL9Wt2vSMp5t0vDOsVhlQsx0KYHJGCxYgyHThEwXEmvAqDB84rxX8l8ffg/GWp7xktfwC79wd6rCslj14/KqIrJWh76zlLcsDRSKEhERERERkWOHKtzj2Nra2n6P10NRL3jBC3jOc56z39eKouDe9743d77znbn73e/Opz71KQC++tWv8ud//uc861nPutrrec1rXsNZZ511tc8jIiJyMCnn/mPqPxbu4GMqrsx6GGr9POvnFRERERERuSLDwjFuAt5ZvDXEmGlILA/3hqImbWA6G69Xt5E2Jr6/u2bnuCVnSDn1o8EzFA5iBmMszlmGzuK9ozRgqn7k98fe+QY+9u5zAHjaC1/O6b/yK3hjGZSOnPvxfqWzjErHQulZHhaHvYFERERERERE5Gh21e4IyjFhMBgc8NzP/MzP8Ad/8AeXe8zS0hLveMc78H5vpu7P//zPybopLCIiR7n1P1XrH6/qxf71wy57PhERERERkStiraHyjpzzfHRe3UVC7LvbrjV7Q1FrTeB7u2u+s2PCpWsNISWaEBi3kZTBOUPCUDhD5Qylg6qwbF8o2TIqWR4V/OcH38k/nPtKAB779OfzgAc/jOssD7jetiHbF0pOWCzZvlCyPCwYlh7n+mJHuSgRERERERE5ligYdRxbWlo64LknP/nJmCu5+vGjP/qj3Pe+950/vuiii/jiF794xNcnIiJyJK3/eVv/eFU7Pa0fdtnziYiIiIiIXJlR5TDGUBWOsugvza5MAzvWGqZtAGDHuOV7uyaM245JiKSUGbeROkYiGe8Mg6IfwbdQearCMfAeY2bPlZ7/+sj7efdfvACABzzmyTzo1x7PoHDEdGAd1M7GjlvbFzfqGCUiIiIiIiLHEo3SO44tLy8f8Nzd7na3Qzr2bne7G+95z3vmj//rv/6L00477Wqt54lPfCIPetCDDuuYr33ta5x++ulX6/uKiMjxwRpDJPcX+2Omi2m+S/tw6KaBiIiIiIhcVYWzLFaePdOO5YGni4m6i4zbgDGwMuloYqIOsX++DkzaQMqZwrl+5F3lyTkTYqAJmcKaWTcqy6BwfOO//plzX/JMAO7xoDP51cf/Dl3KTLvIMDhG5d71pJxpZx2rBr6vjyqvvbQiIiIiIiJy7FAw6jh26qmn7ve4qipOPvnkQzr2hje84X6PL7300qu9npNPPvmQv7+IiMjhqrztw1De0XSJJiQWcj6sYJNuGoiIiIiIyNW1faGkDpEQHYulZ/ekxRrYPWnZU/ddoyZNZK0JdDERYmboHdtGJaOhI2cwGbCQJh1gqLvIsHD81799kj9/5mNJMfLz93kgj3ra82lDJqdMF/pz7WvaRnIGbw2ltxhgeBU2kIiIiIiIiIgcrRSMOo5d5zrX4YQTTmDHjh0ADAaDQz72sq+t6/qIrk1ERORIGxaOcRMovcVbQ0iZaRtZqA797ZBuGoiIiIiIyKFKsy5NTUiknPtA02xfRmEtiwPPat0B4KwlZYO3lpwSMScsfRcobw2LQ8/SwPdj+Fy/OcMFg02GJiambeDrX/pvzn3O4+jahp++2z145h+9gj1tomkibUxkoO7ifH1NiEza/vGwXN/44ebdcUVERERERESOBWpxcJy7zW1uM/98ZWWFEMIhHbdz5879Hp9wwglHclkiIiJHXD9aor/Yvx5mmrSRJsQrOmxONw1ERERERORQdDGxZ9Jx6Voz7/oUUyblTEz9f11MNF3CW4s1hp1rDTH1Y/GGlad0nq2LBVXh8M7isRTWsVB6nO3DUMYYti2ULA0cq9//Fm8/6wk00wk3uc1P8fizXoUvCpzpL/92qa9lQupDWuMmsDLtrwNWhZ2PGR9V2vghIiIiIiIixxYFo45z97nPfeaf55z53Oc+d0jHfeYzn9nv8WXH8omIiByN1i/yD0pHVfRvg1amgXETSDkf9BjdNBARERERkUO11gR2jlvqEMlAGxIrdcfuScuuccvuSctK3eGtIQMJMBa6lEgpEVLCzJ4LEdoQ++cM5JyYtB3jtq9NvLUMSke982Lecdbjma7u5vo3uQWPfeFrmATL7mnHNAS6kOi6fiz4at2vb33TR1VYlgcFAAuVp3C6XCwiIiIiIiLHFlW6x7kHPOABGLO308X5559/pceklPjrv/7r+eOqqrjjHe94jaxPRETkSCqcnY/OWx4U83DUpI3sHLesTDvqru8iVXeRlWmnmwYiIiIiIsewlPqNEDvHLZeuNVyy2nDpWsPOcdtvoEgH30BxMHumHeOmDy3VbWTXuGXPtKPpEl3MhJTpYqbpEuM20oZI00UKa4k5Mw2RNmYmbaSw4B1URV+/rLWRPdPAah2ZNJEYM5W37N5xCX/+u49iz6UXc/IP/yiPecEbWF5awmCo20DdRKYhEmJi3ARyZj4efGng5/XNsHQsHsaYcREREREREZHNQnfzjnM3uMEN+NVf/dX541e/+tVceOGFV3jMX/zFX/D1r399/vhBD3oQw+HwGlujiIjIkbRY+XnHp+VBwdLA97u1MzSh30G9Mg2s1oEmJN00EBERERE5Bl3ZuLsuJtaawKVrDXsmHV1MV3i+tSZQd/2GipW6Y7UJhJQxBgaFZWng2TLs649BYTEGSu9oY2L3tMNimDSRrotYa8jZsGcSGNcd42lkre5YqQM5Z6rC4pzhkh07eNlTz+T73/kmJ13vh3jiS85mtLyNnA0LA481djb6OxNypu4SKfddcY3pQ2EpZRaqvbWOiIiIiIiIyLFGwSjhRS96EWVZArC2tsY97nEPvvSlLx30tW95y1t42tOeNn88GAx4znOec62sU0RE5EjZMizmnaMGhWPbQsmWYd9BqnAGbw2FM1SFZcuwYNtCOQ9T6aaBiIiIiMjmdqjj7tqQyEAd+g6za7NuUJfVzboxQR+Karo+RDUqHdsXSpYGBYPCUfp+LPfSoGD7QslotuGi7iJ7ph3GGPojMzGDm3V5d9aSMmAyMWfaLjNeW+MNv/94vvP1L7P1hJN4zqvfwfWvf30WBxZnDXUI7J521G1i4D3D0rM88CwNHNYYQuo7WOWciTFfafBLREREREREZLNSqwPh1FNP5Y1vfCNnnnkmAF//+te59a1vzemnn84d73hHlpaW+N73vsf73vc+/uM//mO/Y1/3utfxYz/2YxuxbBERkatlsfJU3jJp+tF5pbeU/uCZcQNU3jGqnMbniYiIiIhsYntm47OhH3c37SLhYOPyZiPvvDUMC8egdP1ovZwP2Cgxafaebz0UtTz0VL7fXJFypu4ibeg7NuWcyUAXErvHDWt1IMbM7nFDNmCtYalyVL5k0Dqa0J/XGOi6TKLhL//oyVz4hc8wWlrmaS8/h4WTrk9KGWMMXejX4J3BeYM3lpT7blhdyISYGFaOQeFwzlKHSB0iC5VXZ1wRERERERE55qjSBS666CK6rgPgh3/4hzd4NRvjkY98JKurq/zO7/wObdvSdR3vete7eNe73nXQ15dlyete97p5mEpERGQzKpxly8iSkmfaRZqQSDmTMxgD1hgqbxkWbjaCQkTk8KjWEBEROXpcdtzdeojJGKi8pXAWa0wfIIqJJiRCyqw2gTYllgcF0zZijZkHiFLKNKE/53R27lHpqLwjxMSkjbSxH9ENEGKi7hJtTISYGLeRLkQms4BW6S2YTOUdxmS8hT1TKK3FOoMziXNe+Lt85T8/SVENedwfvYHr3OjHWJm0AH2Ayhq2DUusYRbOMpy4WDIqPVtHBdYYupDZE7pDCn6JiIiIiIiIbGabIhh129veFoAb3vCGvPe9773C13784x8HYDgccrvb3e6Qzn/nO9+ZCy+8EGMMIRy8Jfbx4Dd/8ze5613vyjOf+Uw+9KEPzW/g7KsoCk4//XSe//znc/Ob33wDVikiInLkWWtYqDwL1UavRESubao1REREjg9XNO5uWPbj5fY1KBwLOTNtI5NZJ6gVOpYHBeMmzINU027vOL6QMsbAcBYymrRxfr4QE7smLZMmzDdirNWBJvUBrLWmY6UJLFNgkmFQOLyDkBLWGuqQyDnzzpc/n8994h9wRcHDn/MqTv7RW7JzrSORabtEWVgq24ermpjx3rJtoWDrqGCx8mwZlocV/BIRERERERHZ7DZFhfvZz34WYwxra2tX+tq73vWuGGO48Y1vzFe+8pVD/h45H6Rl9nHotNNO4+/+7u/YsWMHn/jEJ/jud7/L7t272bp1Kze60Y24053uxNLS0kYvU0REjnMpZXV4EpEjQrWGiIjI8eHKxt0djDX9BgrvDCvTQNMlahcZFI5JE9kysjSzsXX1rGtU5S3jJlDPvkcTInUb2TPtaGP/XBsidUisTDsyMG0jIcLQOyZt4Du7poSU2TYqaGPCYGi7yPvf+FL+5QPvwljL4577Cm52hzuxVgemIVF5Q0yJynm8gzokKu84aaniBttGWGPYNirws9Hghxr8EhEREREREdnsNkUw6nDlnHXz4Wo64YQTuN/97rfRyxAREdlPFxOTJtKEflf2fjJE8nwneOUdo8rpYr6IHFGqNURERDafKxp3dygq7xiVmUkbmbZ9MKoJkZQ8afa+IKX+YxcTs/wTa03fmWraRbqUKb2jixFrLZaMt5acM4sDx9qsu1QXYRoiF69McdbgHDhr+ej5b+Rj734LAA94ygu5yU/9PDlByhlnIcSMNZaVumP7QknhDaeeNOS6ywvzn9dfpjY6lOCXiIiIiIiIyGZ3TAajjFGHCBERkWPNWhPmoy+gH1VRh0hK+3SMsoaBd5TeUodIHSILldcYCBE5YlRriIiIbD6XN+7ucAxLx7SLhJRpQ6L0szF6s7x0zv24vC5A4e08FBXSrDvVwDPtEjmDt4ZhYRlVFZM2ElJiUBgmbWZYOHKGSRfZsVZTWMen/+GdfODsVwBw/yc8izvc4/6s1gFrIMR+3F4X+w5RI+/YtlBx8mI5D0UNC8fCFdREVxT8UideERERERER2ex0l1BERESOenumHXW3d/TF+g2JA8RM06XZjQbHoHSMm0DKmeVBcS2vWkREREREjgYHG3dnDzPsbI2hdP3ovDpESt9/bgww26hRd4nCG5qwd1xf4RzeZpqQaGfff6H01F0k5kzdBjCGExYrJjsmtDHjvGXgLV3I/M+//B0feMOLAPjZBz2OW9/zDKyDZV8QYyIXhrqLlM6ybVSyNPQsDz0nLQ+AvlPUFYWi1l1e8OtQjhURERERERE5mqkfsoiIiBzV1powD0Wt1B2rTZjv8h4UlqWBZ8uwYGngGRQWYyCkzGoTWKk7AKZtZG2fblMiIiIiInL8uOy4u6s6brv0dr/zpJz3BqwMtLHv3FTPxuJVxd7v087CWYOi73CbydRdpA39uWKEUeUx1uKBxdLx/S/8Cx/4i+dAztzuXg/h7g9/EiFn6iYSY6IqHLMlccJCyQlLFc5atgwKlgYF20bFIQeb1oNfsDdAth4oExEREREREdnMtOVHREREjlpdTPPxeSt1N991PSodw9IdsMt7UDgWcmbaRiZtv0t7hY7lQcG4CVTeXuWbICIiIiIisjntO+4OOOxuUevWD9v3fFVh6WKCDDlnJm3CAM5aDIac+/F9IfXPV7MkU0x9FykDTOtImyKj0lF5Bybz/S//F+98ydNIKXKbu92H+z3h9xmVnjT7PgZDGxMj31/e3TIqsAYWhwU3PHGBUXn4l33Xu2DtG/wSERERERER2ewUjBIREZGj1qTZOz5vPRS1PPT9zYLLYY1hofJ4Z1iZBpouUbvIoHBMmsiWkYJRIiIiIiLHk33H3cFVD/ysHzZvEmVgWLj5Zg5vDeM6Yg1sHfn5+O/1zkuF2zvCr4v9c4HENERSzCwPHcYbvvr5/+ac5z6Rrm24xU/fjUc840Uk6zEGFgqPNVAWloXSUXjLau2pSsu2Qcmocnh71WqegwW/RERERERERDY7BaNERETkqJRSppmNcJjORunNd1Afgso7RmVm0kambR+MakIkJY+1V22HuIiIiIiIbD7WGCK5rwNipouJQXFodcW+1sfhrdcT1hisNVTekXLfwXbXpKNNiZzTPFh02RF++waz2i4xbjssBmMLfvB/X+dtL/gNmumYH7vNT/HY572K4XBIExIDb9m2UFI6S+EtkzYwaRKlMyxXBYOy75B7JINfIiIiIiIiIpudWiaIiIjIUWnaRTL9zYeQcr8buzy8mxfD0mEMhJRpQyKzN2QlIiIiIiLHh/XxdYPZJosmpMMOD6WcaWddntbPs37eUeXIOVMVjsL3aaJxE5m0Yb/vsx40amPCOcvuccOuSUdOhtI7Lv7ud3jtMx/DZGU3N7jJLXj8C19HVQ0ovMHO6ppJG2hCZLHyOGMYlJaF0jMoHDFlKu/m3agO18GCXyIiIiIiIiKbnTpGiYiIyFFpfdxEPesaVXl72BfmrTGUztKERB0ipe8/X6iO+HJFREREROQotT7urvQWbw0hZaZtZFg46i7SxkTKfcckY+hH1TnLoHDzkNC0jeTcj8srvcXMzgt9J6iFyrNaB5aqfoReztB0iWkXqbuINWa+WWPPpGPXuGV1Njq89Ia1XTs45/cfw8qOizn5h3+UR7/g9RSjESElXDSQDVXpWBoUOGPIOVM4S46JougDWpXvu+M2IbGQ82HVT1cU/BIRERERERHZzBSMEhERkaPS+s7qy46dOFzrYaj181zVsRIiIiIiIrI5rY+7q0Mfhto1abl4pWPgHcVlwz8ZItDFyKTtN1dYC9O2Dw2td7GtvNtvRPfSoKCNCdsYFkuPMRBTog6ZGKFOkS5mRqVjZdqP2yuspSGSmjHnveA32HXRt9l68vV5zAvfxIknn8DQO3KGGDORRNPBuLFU3rJj3OKMofCWxdITc2ahcvsFvxaqQ7/0e0XBLxEREREREZHNTMEoEREROSqt55fWP17VMQ7rh132fCIiIiIicvwYVX0wKuZMHSJtSLShDydlmzH7dIwy1jBwDucMuyZt312qdGxbKBnMwkKjav/QUOUty4OClDLf31MDhm0LFWt1wBpYnWZyyuTcj/EbFZ6uS6Su5h0v/E0u/uZXWNp2Io/5ozeydOLJpJTpYh92akPEJUOXErsmDQulZ9tCSSQzmnV3Wh6WOGsYFo7VJjBpI971gbAr04Q+BAaXH/wSERERERER2aw2VTBqOp3y8Y9//Bp5rYiIiBxdjAHy3mDTVe30tH7Y+nmuYr5KRI5xqjVERESObYWzxJSZtJHFqqBpa1brQMgZM/v6vl1qd8WWlDOVd5TekmavA1io/AEdbdfH9W0dlbQxsVYHIFN4yxZXYo0lpERMmVHp+xF7dcNf/8nT+PaXPstoaZnfftlb2PZDP0IMYK0l5MSk6wNSDjMf/eesoXCG0juaLrFtVHLiYslqHRiUjjYlmi6xMg2MysywdAfdaJJy31lqPRRVFfZyg18iIiIiIiIim9WmCkZ973vf4253u9uVvi7nfMivFRERkaOTNYZI7ncpx0wX0/wi/eFoQz/yYn2381XtPCUixzbVGiIiIse2tSbgrGFQWC5Za8AYqtJhuoSxfTDKYkj0tUeXUr/JIiRKb1isCuousVBlFg8yom7fcX3LVYHBkFLGmUgbE8PSsVonpm0kkSFF3v2KZ/HV//wE1WDI01/2Fk680Y8BsFQ5jDF0MZIjOAyj0lEUjuVBQektORu6kHHWsDDog1rr61oeFKzQ0XSJSRuZdpHS2X5Enuk3j7Qh0cY030hSFX3HKzh48EtERERERERks9pUwSjob0RcEbPPzc4re+3BjhEREZGjQ+VtH4aa7YJuQmIh58MKNqWcaWMfjBr49ZEQusAvIgenWkNEROTY1MXEuAkAZMDN/j5vGRYMlh0p9eP1cuprCFt6MJmcoYv93/zVpuM6SwOsMXQxHTQ4tD6ub9+uTd5ZEnDSoMDN3hasTTve+rI/4L8+9kGcL3jCH76GG512G3Lu32M4a2hjovAWby2FtfMOTguVY9pEDBnnTF/nzN6WbF8oCSlTd5HlQUHtItM2ElKmCX1NdVneGoalm29CGZbuoMEvERERERERkc1q01S5h3rj4VBfd3WPERERkWvW+iiK0lu8NYTUj3lYOIyL9NM2knN/sb/0FjM7r4jIvlRriIiIHNsmTT8qrm4jTZcYlZ4TF0u6mFmddrQxkXLfSckYyGQKa6m8I+RE22UG3uJmXWgnTWTL6MBgVOEsC5Vn3IR516aUM/U0cclqw7QLTJvAW1/5R3zygndhrOVhv/dSfuhWd2DaBBYGBYWztKHfIOKMwTvDsPQYYFQ6locFC0VmpemIqa91gHmtY63BWcO4CQyKPvDUhkQdIinl+c9obR+qKvfZOLJQeYWiRERERERE5JizKSrd5z3veRu9BBEREbmW7TuKYlg4VpvApI141z9/ZZoQmbT9DZBhud4tys1H6omIgGoNERGRY11KmSb0dcG06z+WzhAThJgpC0fGzDrNZjKQMrQxY0gsDT2LZf942kYGhaMJkZT8QWuLxcoTU2at7iBDiAln++BS3Sb+9q2v4SPnnw3A/Z70fG5y+59nbRrIpacqEtAHspYGBVVhKWedqQaFm28SCaml7iKFtQxKR8r71zqLlafylkkTaUKk9Ha/ANS+DP2xo8ppfJ6IiIiIiIgckxSMEhERkaPWwUZRrEwDozIzLN1Bx+ql3N+wWA9FVYWdj4VYHz8hIrJOtYaIiMixbdpFMtCGNOtCG0jF3loixkzICTObR2cNGGsYOEfhLV3MpJxpusiw9LQhUXrLtLv8brbOmvnoutL33yvExHnnvJV3v+FPAfjFRz+d/3f3X2FQOGLKdCmxWnecvDTkxKVqHoiCfqPHqPR996kuslb3tY73/aaRnPMBtU7hLFtGlpQ80y7ShETK+3SMMobK23mXKREREREREZFj1aYIRomIiMjx6WCjKJouMWkj0y5Sun7nszH92Is2JNqYWJ9cVRWW5UEB9GMhtANaREREROT40oQEQB0iq02HwWCNoekidRcJ6SBjb2Om7RLeGgaFoyocMcFa0/VdnLylCYmF6sBD90w76lloKuXMJasNu8YdH7ng3Zz3Z2cBcPeH/gZ3eeCjsNkQI/OapnCOlDOTNtDNaqHhbITfat3R7VPrFN6yXF15rWOtYaHyB12riIiIiIiIyPFAwSgRERE5qq2Poqi7yPKgoHaRadvfwFjfhX1Z3hqGpZt3ihqWjsXL2c0tIiIiIiLHrjRLEq1NA22XWBx4VuqW1Wmkm43PK5ylcBZrwDuDs4YuZkLKrDWBNvVdotbqyLjuN22sn3dfa02gno3rW6k7do1b2pD473/9J1753KeSc+YXHvAI7v/Y36FuAyGDMX1Qa1B4Sm8YN4HCGZaXC8gw7RJ0e2sebw0UljJbjIVBYVmabQYRERERERERkQNtijuEzvU3NW984xvzla98ZYNXIyIiIte2LcMCZ/ubBIOiDzy1IVGHSEr7jIOwhoF3lH7vbumFyisUJSKXS7WGiIjIsSmlzLSL7Bq31F3ke7untDHyg7WaHPsxdKPSU/n9R3TH1IeprIW2y0zaSJ5mMECGSRsYVY4tg3K/79fFxLgJQB+KunStoe0SX/rMv3HWU36dGAJ3u/f9ecKz/pBEX9vknGeBq0CICWc919ky6EfrxcRi5ee1zvp4P+cMuycdmcy2UcnSoKDy6owrIiIiIiIicnk2xV3CPNuBlQ+yE0tERESOD4uVp/KWSRNpQqT0dr8A1L4MUHnHqHIanyciV0i1hoiIyLGli2leM2SYd32adoHdkw5MP7K7xJJSoHHgjJ2Hj/y8W1Q/ts4bQ8z9aD1jYGQ8O9ZaUoJBsbfmmDR9p6i67cNYbZf4zv9+gac99mE0Tc3P3O0ePPvFr6TLFj/rThVTxllD6S0r08Ck6de8ZVgQYsY7y6jc//LttO07Si0OCraOSgwwnHXKFREREREREZEDbYpgFPRtpUVEROT4VjjLlpElJc+0izQhkfI+HaOMofKWYeGwVu8dROTQqNa45uWc+frXv87nP/95/u///o+VlRVGoxHbt2/n1re+Nbe85S3n3btERESuqrUmzLs2AbQhsVZ3fHfnmF2Tjj3TQDawZdZRtqUfUVd5y6Bw1E2gCQlnLKXvR+pNZl1qp20i5YRZgmnr2DrM1CFSh8iwcDRhNkKv6Zi2kYv/70KedOaDmKytcevb/Qx//Oo3s3VpkXETaENiaVDM17pYFXhr2TPtMKbvWJXpx4kPCjcf80eG5B1Da1ga+NnaVfuIiIiIiIiIXJFNE4wSERERWWetYaHyLFQbvRIREbk8q6urvP/97+d973sf//RP/8Qll1xyua/dtm0bj3rUo3j605/OKaecci2uUkREjgUpZS5erVmZdqTcd21qQiRm2LFas6cJ1DFy6VpNSJluoaSsHQsDx1JVYE1/TJpNzKtDYGWasMYwrBwxJVabjsJbYsis1F3fLar0DErHjnFDTJnKO9bqwMXf+w6/9cgHsHvnDm56i9vwqrPfwfblJaDv7tSGROksnbe0ITFpA+Vsg8e064NYpXcMC8+wcCwOPNM2Mmkj1hqqog9yAYwqBYtFREREREREroiCUSIiIiIiInJEra6ucvLJJ1PX9SG9fteuXbz85S/nnHPO4U1vehO/8iu/cg2vUEREjgXrY/N2Ttp596XVpqPt+k5QbYjsGLesTgNrbf/1whusMZSFmY/Zc60h5sTSoMRaQ+oykUzK/Si+0vVjvCvvcLPjU06sNoE2JVLKdDH3oajvf5+nP/pB/OCi73HDH/0xXnXOO9m+bdt8zd5ZhqVj2kYWSg/0HaTakIg5E3PuA1Cmw1tDTH3nqPUOl1VhWR4UACxUXqPDRURERERERK6EglEiIsexlLLGkYmIiMgRF2M8IBR16qmncpe73IWb3vSmnHjiidR1zf/8z//w7ne/m0svvRSAnTt38qAHPYh3vetdCkeJiMgVWh+b18XEuAmEmNgxbpm2cfaKzLQNGPqOs3UTaGNmYTa6te0SGUNrIykZBqXle7unLFaOUeUZlZ4uJWLKNCFTeUvOEGJmoTQ0XWL3pMWa/rmto5Jvf+8Snv6Yh/B/37yQ61zvh3jZ2e/kutc5+YC1j0pPypmmSyyUnsIlmjbijMEAkzaQAYPBLhqchaVBwbB0805Rw9KxWOnSroiIiIiIiMiVUfUsInIcWt9V24RIvuwXM0Ty/OJy5R2jymkXqoiIiBy25eVlHv3oR/OoRz2KW93qVgd9zctf/nJ++7d/mze+8Y1AH6p6zGMew53udCdOPPHEa3O5IiKySeyZdtRdH4DaNe5YmbZM2sh41hXKmExMMA2J3dOWPZOO1ToyKPu6tg6JylucgZVxIBvogsVYw2oNi4OCQWmZrAV2jltCTJTekoGUEksDj3eWUelZrTv2TDtW1tZ4xm88jK9/5QtsP/Ek/vQt7+IGN7gB1hx8s9FiVWBNYNrGviPV0FJ4S0gZMjhjSWSqwjIsPdsWyvmxC5VXKEpERERERETkEKmCFhE5zqzvql3XhkQdIint0zHKGgbeUXpLHSJ1iLrwKiIiIofMe8+znvUsnv70p7N9+/YrfO1oNOINb3gD4/GY8847D+hH673mNa/huc997rWxXBER2UCH28l4rQnzUNSeScuucUMGmtAHjApnMMYw7SJdyEy6SJcy1maMgeVh0de/s/M1MRIzrNWB0cCzUGQuWa37TUO5/37eWQbGUsdI3UV2jzv2TAMnLkYwUNcNL3naY/jKf3+a0dIyZ732Hdzghj9ypRuMRqWndLZfa0xYYxiVjmFpMfQ//2JV4GzfSUobl0REREREREQOn6poEZHjyJ5pNw9F1W1k17hlz7Sj6RJdzISU6WLfzn/PtGPXuKWejSEYN4GVutvI5YuIiMgmsbi4yIte9KIrDUXt66UvfSlmn64af/d3f3dNLE1ERI4SXUzsmXRcutawNhuJF1Mm5UxMfRfjtSZw6VrDnklHF9O8szHAyqxTUwYKa1moPIPS4Z2lcJa6jXhnGLj+a9sWKwaFowmJ0cBTFRZnDUtDjyEzDZHd44ad45a1JrBSB5oY8Q66ELloz5S1acek6zcX5ZSZtJE944aXPvtJ/Ne/fJRyMOSpL30zW653YyZtxHLlo+m9sywNCraOSrw3FNZQWIs1BmcNhevDUicuVmwZFQpFiYiIiIiIiBymTdX6Yzqd8vGPf/wa/R53vvOdr9Hzi4hslH131a7UfRgK+p24le8vHFtjSLm/AN2EREiZ1SbQpsTyoGDaRqwx6hwlIiLHHNUaG+9617seP/7jP84Xv/hFAL7+9a9v8IpEROSaclU7GYeU8dZQt3G2wSexNChoYsQmQ0gJZy3trKaFfmRdkRI2wZ6mY9pGVqf9qLouJZyxYCCnTGdhaGDcdHjnIBhCgknbj6EfOUdhDRlwxuANvO7Fv8+n/78P4nzB4876c25w09sw7SLTLjBuO7b66pB/L85YFgcFVWFpusSWYR+Yctbs1zVLRERERERERA7dprqz/b3vfY+73e1u19j5jTGEEK78hSIim8xld9Wuh6L6Fv0Oa/a/wDooHAs5M20jk9kF5xU6lgcF4ybMg1QiIiLHCtUaR4fFxcX55+PxeANXIiIi15Q9026+aaduI9OuDzwdYNbN2FvDsHCUhWX3pKXylhD711fFLDjVhfkYPoCmjWQylbdYA9NxxFhLjJCBLiSKgaVrE8YbupD7kFQ27JkEUkpsXSyZRlgcOkalo/CWrcOCUVX0I/sKw5tf8Uf8w3vOw1rLr//By7np/7sTKWXanGlDYqUOLFYF/hDq57qL5NwHv/pwmGFYOYADanYREREREREROXSbKhiV80EukoiIyJWaNHsvOq+HopaHnsq7yz3GGsNC5fHOsDINNF2idpFB4Zg0kS0jBaNEROTYoVrj6PDNb35z/vl1r3vdjVuIiIhcI65OJ+NUZ6wxrNWBNiYWqr01bc7Qhj5UFFMm5IzBUHrLuIk0Xca7yEJlmY47xg1goOkSa01iXEdiSmAsXUhkEjElhoUjxowBBs6xOCgYeMeWUcF73vJq/ubc1wHwxD94CT/9i/dhddqRDRAya03AO8OkDSwPyyv8vbQhMZ2NsS8Ly7SNlM4xKvpLt5VX/S0iIiIiIiJyVW2qYJSIiBy+lDJN6C+wTmcXoEelu8JQ1L4q7xiVmUkbmbZ9MKoJkZS8WvmLiIjIEfOJT3yCH/zgB/PHP/3TP72BqxERkSPt6nYyXq0Dtp96R9MllgYeTB+EMqY/v7V9sAmg8oZ6Nm6vKgyTJmKNJWXDNASmawFLPxYPk2lDxplIAirrmLSZFCPeWYaloyORZp2t/uk97+CcV/4xAL/21D/gzvf5VULMLAw8XUw4AyFkxk3kktWGUeXx9sBwU8qZuovzUFRVWHLug16LVd8NywDD4tDqdxERERERERE50KYKRm3fvp3f+q3f2uhliIhsKtMukul3oIbZBeNheXgXVYelm483aEOi9JZpF1moNtWfERERkculWmPj/cmf/Ml+j3/1V391g1YiIiLXhEPtZLweFmpDIuW+q2NMiZVpizUG5wyFtcSUKZwhAsYa8qzLVJ6FlwyGLkYKb1mddZkqXKawZhawsqQQWe0iIfbf01qDt4ZxCpQp0jhL6R2DwrFUepqY+J9/fB+vfuHvAfDw3/htHvzoJ7JzrSXlzKhy1C14Z/v1pMzuaYfbNebEhSGFNxgMmUwXMm1M866VVWEpXb/WYelYGhb9895pU5KIiIiIiIjI1bCp7mhv376d5z3veRu9DBGRTaWZ7ZatZ12jKm8P2Il7ZawxlM7ShEQdIqXvP1+ojvhyRURENoRqjY31l3/5l7z//e+fP77NbW7D/e53vyN2/h/84Adccsklh3XM1772tSP2/UVEjneH0sk4xMSkjbOw0P7HO2tx1jJpA9NxZMuwYKF0DBccXcwMnCPTd40yQEyZRMYYQxciKWVK34epvIOBd0y6QB0SbUjE3B8TEhibiUA0MACMMcSUaEPm2//5MV531tPIOXP6GY/mMU/5PWLuR/flnFkoPYW1jJvAoPRM20hMmd3jiLftQetxbw3lrFPUah0YFI5tCyWDWZeoUaVuUSIiIiIiIiJXx6YKRomIyOFLsyvK6y3/C3dg+/5DsR6GWj9PuuyVahERAWDnzp1s3759o5chsml84Qtf4HGPe9z8sfeeN77xjdiDjBy6ql7zmtdw1llnHbHziYjI4bmyTsbjJjCZjZODPiRVzwJNOYMxEGedo2KCSRvZNe2oCos1lsJbvDW0MdPFTBMSpTNkEl1KFN4QIjQx0sXMpA3kDIV3+JDJOWGNwRjAWkxKGGuonMM5QxMyX/7sp3j783+LGAN3/qXT+c1n/+EseJXwFlIyxAxbRgWj0rLaRJYHBVhou0jK/bq9NZTe4iyU3pEzTNtIzv3vZNtC2R8HLFT+KtfwIiIiIiIiItJTZS0icoxbzy+tfzzcblHr1g+77PlERGSv97///dzkJjfh7W9/+0YvRWRTuOiii7j3ve/N2tra/LkXv/jF/ORP/uQGrkpERI60K+pkvFp381BUEyJ7Ji17ph1Nl+hiJqQ+7JRiou4y0y6w1ga6mFmtA13sz73eYanvdNx/fb1wLZyljX0oa9JFYuw7RDVdmj9feoczlpT6EXjTNjLuAqWzjL/zVc77w9+iaxtu9dN347F/8FLaCN1sBJ+3lqqw5JQpnOXEpQEnLJUUzrBUFSwPS7YMPIuVZ1A4rDHkbOY/Y+kcJyyUXGd5MA9FDUvHosbXi4iIiIiIiFxtqq5FRI5xxgB5b7DpqnZ6Wj9s/TxXMV8lInJMatuW3/u93+MVr3gFAG9+85t52MMehtH/LEUu186dO/nFX/xFvvWtb82fe9zjHsfTnva0DVyViIhcEy6vk/G4CdRdH2xaa/owFPTj60pvKZzBGkPKmUxm0iXqYJjWgT2uZXE2Zm7SBpaGnmmIUEcmbaTrEkVhIUPKCW8NKWVWpy116ENTXcgYa2i6SM6GLgYAMobC9sfuuehbvOeFT6CZrPEjt7wdD3nmy9lVJ/bUKywNyn70fGFw1pKBYeFIGbYNK5bKhLWGEDMLlaPp+k5YOWfAUHnLsHKMCk/p9+5fXai8QlEiIiIiIiIiR4gqbBGRY5w1hkjGWgMx08U030l7ONrZDl9rzfy8IiICF154IQ9+8IP59Kc/DcBTn/pUXvziFysUJXIFVlZWuOc978n//M//zJ972MMexmtf+9pr5Ps98YlP5EEPetBhHfO1r32N008//RpZj4jI8eZgnYxDTPNOUfuGooalm3dV2lex0Hd9iinRzTo97Ry3bF+oaGPCGcNS5Rk3ATc1rDaROO0YFJYErE5b9kwDky7ThsjAW4w1FBaSd7QxUeBIs4UW3jDddTF/97InMlnZxXV/9Me53+++gpVgSNOuD2zRccJCBdmw1kS2Dvs1dzFROMvCwDMsHCFmRqXjirYpGaDyjlHlND5PRERERERE5AhSMEpE5BhXeduHoXy/O7UJiYWcDyvYlHKmXR9P4N38vCIix7vzzz+fxz72saysrLBt2zbOOecc7nvf+270skSOamtra/zSL/0S//Ef/zF/7oEPfCBvfetbsfaaeX9x8sknc/LJJ18j5xYRkSt3sE7G652imhDnoailQbFf56R9WWOonGVQOLYuQtMl1urAat2yNChpY6RwlqF3bBkWrNaBtSbgTMFK3bF7GlipWwwwKiylc0xCwpBxFipjsWSs6ztF7d55KR9/xVMY7/wB2653Ix70rL/AVqM+xNUmlkcFhsi2YaZOicJavHPsmrSknBmVnoHvQ07bRn1AatpFmpD6Dliz34c1s85RhZtvRBIRERERERGRI0d3tWfW1tZ405vetNHLEBE54oaFwwClt3hryBmms125h2raRnIGb/txBmZ2XhGR49V0OuUJT3gCD37wg1lZWeGOd7wjn/3sZxWKkoNSrbHXZDLh3ve+N//yL/8yf+6+970v5513Hs7pvYWIyLFqfWPOevCnCXG++aae1afD0l1uKGqdm51naVCwNPAYYMdax6QNFM6ydaEgk/tOTWUfotpdt+yetLPv4XG2D0WlDCZBHRIJQ86ZJmXaLhHbNf7l1U9n7ZLvsHjCdbn/s16LHW2lsAaywVhwru/ytDrtqNtITBnINCERYqbp4n71s7WGhcqzfaHkxMWKk5YqTlys2L5QslB5haJEREREREREriHHfTDqk5/8JI9+9KM55ZRTePzjH7/RyxEROeKsNVSzLk/rYaZJG2nCoYWjmhDn4w2G5Xq3KO1kFZHj15e//GXucIc78LrXvQ5jDM9+9rP56Ec/yg//8A9v9NLkKKNaY3/T6ZT73Oc+fPzjH58/90u/9Eu8613voiiKDVyZiIhc09Y7Dq93IF6ZBmLKhJgIKWOMudKR7ylnEjAoHAPn2DYqGVWOkBKrdWDXuKXrMttGJSlnDNB2iXGTiLk/fr1rVZcSbQxgMpV3DL3tA1PWYlLLR175u+z+zv9SLW/nTk9+OdXWE/HWMKo8ywNP5SzeWBYGfZirXK+1m8CuSdcHvAyMm6D6WURERERERGSDbZpRejnnI3auiy++mLe+9a285S1v4atf/er8/OYwxkqJiGwmo8pRh8igdLQp0XSJlWlgVGaGpTvoWL2UM9N2byiqKuz8QvWoUkcHETk+nXvuuTzhCU9gMplw8skn87a3vY173OMeG70suZpUa1zzmqbh9NNP55/+6Z/mz9397nfnPe95D2VZbuDKRETk2jAsHOMmzDsZr4+TS7O/waW3Vzruve76TsZLlcc5Q9slTlocsGvSsHvSUjrLWhMw9IGkLvZj8goDLf04+XHX0cXMqHBUVUGMmZQTMWUqZ+m6ho+/7ve59GufoxguctvHvgSWT+HS1YaTlwZYMktDT8qwMHBU3uK9xTtDaS3jNlI4Q8r9hqJJG7nuluP7PYCIiIiIiIjIRtsUwahvfOMbAFdrF3FKiQsuuIA3v/nNfOADHyDGOL8BcrzfpBCRY1/hLAuVZ9wElgcFK3Q0XWLSRqZdpHS2b/FvIGdoQ6KNifX7xFVhWR70/w9eqDyFO+4bDorIcWZtbY0nPelJvPWtbwXg537u53jHO97Bda973Q1emVxdqjWueW3b8oAHPIAPfehD8+fudre78bd/+7cMBoMNXJmIiFxb1jsZ1yEyLBw5Z6ZtH46yxlC4K/572YY4Hwk/KB3OGGLMTLtIzH0nqkHh6HKitJbCWry1tCnjnWGLK+hipouequjP17URjJl3dwox8M9vfgEXfeHfcEXFT/z6H7N0vVNx1pCBZDJrTWLgDc5l1urItIksD0sKb1hY9IyAqnSz8Fdk26ikCxmUARYRERERERHZMJsiGHXDG97wKh/7v//7v7z5zW/mbW97G9///veBvTu2jTHknMk5c4c73IEzzjjjSC1ZROSos1h5YsrUXWR5UFC7/sJySJkmJJqQDjjGW8OwdPNOUcPSsVhtij8dIiJHzOc+9zke/OAH8+UvfxlrLWeddRbPetazcE7d844FqjWuWSEEHvKQh3DBBRfMn7vTne7E+9//fobD4QauTERErm37djIuvWXaRsZNxDvD4uDgdWbKfQ27HooqC0tMmbU2sGVYUDg763TcAf3f4LIwZAOLw4KtXeTi1Yami4xKz/KgYE/dEVOmcJZB6RkVjroL/NNbX8r//ec/YZ3n9r/+R1Q/9ONM24TBULjMyrQlxUwcFpgOQgosDRxbRiUD7/DGcOLW4fxny/Qbi5oQSclrnJ6IiIiIiIjIBjkm725Pp1POP/983vzmN/PJT34SOHA8Rs6Z0047jTPOOIOHPvSh3OhGN9qAlYqIXLu2DAucNYybwKDoA09tSNQhklImZzCm38078P3F6nULlVcoSkSOKzln3vCGN/CUpzyFpmm43vWux1/+5V9y5zvfeaOXJhtItcahizHy8Ic/nPe+973z5+54xzvygQ98gIWFhQ1cmYiIXJtS6js7NSFRd5FxE4gp08T+sY2wa2xYqHzfyRjI9J2Mu306GZdF/7VpGxmWjphyf66cKb0jpEwd+0DS7rWW1SayVgdCSIwqhyWz1kaYdZEalJ5to75j5L/81Wv48sf+FmMsP/vY53PCabdnXHfUqV+Hd/2IvLXcUXrLsHQU1jCc1c3DynHS8oCFypNyxtB3sWpD6oNSXWRB9bSIiIiIiIjIhjimKvJPfepTnH322bzzne9kdXUVOHDH9mg04slPfjJnnHEGt7jFLTZ4xSIi177FylN5y6SJNCFSertfAGpfBqi8Y1Q5jc8TkePKnj17eNzjHsf5558PwL3udS/e+ta3cuKJJ27wymSjqNY4PDlnHv3oR/POd75z/twd7nAHPvjBD7K4uLiBKxMRkWtLF9O87lyPEA8KRxsTKUPlLIU3rE4jKXVYY2gvp5PxoHR0IbFn2mGtoZ5Emi6xWrdM28So9JywWLJ1VLI48KzVgUjNnkkflgp1xtp+TaOqwFqDmSWw/u1vzubf/uYcAH7mzGdy/dvejRgyWxcqmi5Qd/0OopQhZqhKy6BwOGfZMqxw1lA6y+Is2DUsHdN2FgSb1dxNSCxU19qvXkRERERERET2semDUTt27ODcc8/lzW9+M1/60peAvTco1nduO+cIIQBwvetdjxe96EUbtl4RkaNB4SxbRpaU/Hznbsr7dIwyhspbhoVTu38ROe78x3/8Bw95yEO48MIL8d7z4he/mKc+9alYq4Do8Ua1xlX3iU98gnPPPXe/57797W/zEz/xE4d1no997GNc//rXP5JLExGRa8FaExg3Yf74gE7FwLgNDLwjDyDGzLgLjArHwDuMAWMNA9d/vlZ37Bi3VIWji4k2JCZtYNxECm8pvWGtCYTY/302JlN5Szf7ux1SIsVMGxPeWSpj6WLmP//+fD7+9lcB8NMPeTI3vfP9MAai64tjZwyGiLWGpYFnVDqWqpKYEs4ass1sGxYslJ6lgaeajaGPvh9Zn1K/nnSZ7pIiIiIiIiIicu3ZlMGonDN///d/z9lnn8373/9+uq6bP2+MmX9+y1vekjPPPJMzzjiD613vevOviYhIz9p+XIF2roqI9O8fX/nKV/KMZzyDruu40Y1uxF/91V/xUz/1Uxu9NLkWqdY4MmKMBzz3ve9977DPs/77FxGRzWPPtKPu+r8DdRuZdpGQ9g8GLQ48ddd/rW4izhsKa/HW4p2dj52btIG6i7QhsTQomHaR3dOOaROIKZESdLEPYFnTd4HqJokmJMj04aWUaLqEt5ahd6ScSSnxxU/8Ax9/60sAuNW9z+Tmv/gwrIHKW5qUiSFgrcEVBpPBmtmI+YFj4EsGpWNpUDCsPEtDTxPSPBi1/rZgPQ+lXJSIiIiIiIjIxtlUwahvfOMbnH322Zxzzjnzi+qX3bF94okncsYZZ3DmmWdym9vcZgNXKyIiIiKbxY4dO3j0ox/N+973PgDuf//78+Y3v5mtW7du7MLkWqNaQ0RE5Opba8I8FLVSdzRdPxrPzAJHhbNYYwgxMZ4Gpl3EuT5MtVoHTlgsGUWPtczG1cLysODSlYa1tuOS1ZbVuiWERMyGJkacNTRdYnHg2TosGFWemDLjJrBYefZMHNOQSTkzKEsKC1/+j4/z0Tc+D3LmZnd7ALd7wBMYeEsGQoYYEzkbKm+wtg9tDQvH0HtKZ1kaFAwKi59978o72lmHKGvNPAi1HpBSflpERERERERk42yKYNQ73vEOzj77bD72sY+Rc57fmFhXFAW//Mu/zJlnnskv/dIv4f2m+LFERERE5CjwyU9+koc85CF85zvfoSxLXvGKV/CEJzxBHYCOE6o1rhl3vetdD/hdiojIsa2LaT4+b99Q1Kh0DEuHNYYuJqZt3wFqWDlG0eGsoYvQpcS4iVTecelay1LpWBwUXLra8IPVhjpEVpuWcZsYFpYYEqWzOGvB9N2hxk3E2D6E5Waj8LYOPTkl6phIKfK9r32Ov3/VM0kxctOfuSd3+bVnUHpLVTjaLpEB4y1dyGAyW0pPyBmLwTmDoX+PuDQsqLuINYYYM9Yb6i4yqjxt6H/29dH0Vu8rRURERERERDbMpriq/4hHPGK/ndrrbne723HmmWfy0Ic+lG3btm3Q6kRERERkM0op8ZKXvITnPOc5xBi5yU1uwvnnn69OQMcZ1RoiIiJHxqTZOz5vPRS1PPRUvh8vN24Ck3bvqNWcIdN3ZxoUlsm4Y9JGUkrEDOPSE3ZP2TPpcM7QhsS0i+QMdRcJMVN5x6h0LA89hbM0IbFrnCicofCWlMFYQ+kdhXNc8s0v854/fgqxazj1J36WX3jc88nWYoxh4B3DwtGERB0MKUdiylhjKI2hdH0kKpPxrn99iJlBYaljpPCWNiYGOdPG/ucfzH72yttr7x9CRERERERERPazKYJR64wxXPe61+XMM8/kkY98JDe72c02ekkiIiIisgldfPHFPOIRj+DDH/4wAA972MN47Wtfy9LS0gavTDaKag0REZGrJs3G1n1/pSblzO5xS8yZhcoRoyPZzFob5mGppot9sCllnDEY04+rWxwUrNaBS9caSufYudrgvGHaRKqy7+A0qSOD0pEzFN7incE7Q8oQInhjCDn34aY2MiosqzUUzrLjom/wt3/yW7TTNa7/47fl9Ke9lMFg0IejZ92sQsy0IeMs2JxxzoEB7yxkQ+H6kNVC2V9S3TL0xAQ59QHrlGHa9uEtbw2ltxhgWLiN+ucREREREREROe5tqu1KOWd2797NN7/5Tb71rW9pNIOIiIiIHLaPfOQj3OY2t+HDH/4ww+GQs88+m7e97W0KRR3nVGuIiIgcni4m9kw6Ll1ruHTc0MVE00XamEgZnLWM28h3dk24dLUhxMRq07FSd6w1gbWmow6RqrBUzlE4i7fgrSXkxGoTmLYRDLQhU3eBQelYqjzDsu8UddJiyVJVYICYEyFnUu67PDUhgTFU3rJ66UW8+w9/k+nKLq7zIz/Or/zun+GKAU1IJKB0jtJ5BqVjVFm8NxTekYAU+85WZWlYGHhGhes7TBWO0Swgtf62oenSvCvWsFzvFuXmI/VERERERERE5Nq3aYJROWeMMdR1zTvf+U7uda97cYMb3IBnPOMZfP7zn9/o5YmIiIjIUS6EwHOf+1zufve78/3vf5/TTjuNT3/60zzqUY/CGN2sOp6p1hARETk8a01g57ilDpEMrNWB1abjktWG1WlH0wXGbWDa9uPz2pD4v10Tvrdrysq0IwOj0jPwDm8to8qxbVRSOEdMmfE0YK2hjQlnLcOyf91C2YeMRqVn+0LF8qhkVDkWB36/cXV1Gxl4RxsSplnhr1/0RFZ3fJ9t17sRD33ua1heXqbwlmHhSDlTFoaloWfrqGChLCAZCudYHjiGpSXGzFJVMPB9aGp54FmoPOsx6kxm0vZhL4CqsAxmXaJGlbpFiYiIiIiIiGykTRGM+vd//3ce97jHsbS0RM55/t9FF13En/7pn3LrW9+a2972trzqVa/ikksu2ejlioiIiMhR5rvf/S4///M/zwtf+EJyzjz2sY/l3//937n5zW++0UuTDaZaQ0RE5PDsmXaMmwD0AaRd45Y90462SzSh79oEhrZLXLLasjrtuHSlZue4Za0JGNOPtpt2idU6zP+rQ2LgDYWzWGf7sXZdIudM5fsOURZL5fqg1KDYe1nTrndwKhzWmFnHKgj1Gm941mPZ+b1vsXzidfmVZ72aanErbej/3g8rz9KgoPQGY6BLGe8NWxcLTlquOHlpSOFt3yUKS8j9WLxh1Yeu1urAuAmszLpbWdOHopYHBQALladwm+Lyq4iIiIiIiMgxa1NU5j/5kz/J6173Oi666CLOOecc7nznO8+/tn7j4r//+7956lOfyg1ucAPue9/78td//de0bbuBqxYRERGRo8EFF1zArW99az7+8Y+zuLjIeeedxxve8AZGo9FGL02OAqo1REREDt1aE6i7flTcSt2x2gRCyjALBI0qx1JVsDT0lN4QUmKlCVy82jJpI9YYVqaBS1Zr2hAJKc3/a0NkTx1YayOkzLBwLA9Klof9+LrlYYF1hi4l0qzb42UV3lJ5S+EN4/GEtzzviXzvwi+xuPUEfu0P38RJ170epbd414epAEKEmGBQWJaqgq3DklOWhyxVniZEKu85ZeuAE5cLlqoCZy2TJrJn2rJ72tLGRGUd3pq+i9UsFDUsHYuVv/b+cURERERERETkoDZFMGrdcDjkkY98JB/96Ef56le/yjOf+UxOOeUUoL9pAdB1HRdccAEPfvCDOeWUU3jiE5/Iv/7rv27kskVERERkA7Rty+/+7u/yy7/8y+zYsYPb3va2fOYzn+GhD33oRi9NjkKqNURERK5YF9O8U9RK3dF0CYBR2Y/BG5UecmbaBSZNZK3pR+mN645pCKzWHat1R8yZJiS8NSyUnsXKs1B6SmdpQyamxKQNTEOYhZwcky6AMdjZOrqY5n+fL6v0lth1vPGs3+Jr//NphotLPP5Fb+L6N/xRhmXfwalwjsXKsWXoWR56lgcFC5XnussV19lSMSgd3hmWhgUnL1ecuDTghIWKExdLtg77tcaU8cYyKj0nLJZsHZVsGe7tFLUekBIRERERERGRjWXy5V1F2CRSSlxwwQWcffbZXHDBBYQQ9vv6vrvHcs7c+MY35qtf/eq1vUy5hnzhC1/gFre4xfzx5z//eU477bQNXJGIiIgcDb75zW/ykIc8hE996lMAPPnJT+ZP/uRPqKpqg1cmm4lqjeObag0Rkf3tmXTUIVK3kdVZQGp56HHGcNGeKZM2sdZ0tCFRekcIkV3Tjmkb2TNpmXaJhcpx0lLF8rCg8gd2VPrq91fYsdZy6aSBBFsXSq6zVLFWB7yzVIVlrQ0Urh9Xtx5E2leMkT/5vSfx7x/5O8pqwDNeeS4n3fhWLFYFTUjsXKv7kXnWUPm+s1U1G3fnfR94yrkPWA0Kx9KgwBlw1rBtoQ+AtSGyWve/g8WBp/KOge9/tlHlND5PRERERERE5Ciy6at0ay33uc99eO9738t3vvMdXvziF3PTm950v9fsm/365je/yS//8i9z3nnnMZlMru3lblr//d//TVEUGGPm/931rnfd6GWJiIiIHODd7343t7nNbfjUpz7F1q1bee9738srX/lKhaLksKnWEBER6aWUaUI/Qm86G6U3Kh0hZnZNOjL930RnDJMmsmvccvFKw7gOrExbupQYFn0XpkkTaUMixH4kHkBMmdW6Y6UOZAMD70lAzJmYMtYZJl2gjQlyv57VOjBpw/wczNbwhj/+ff79I3+H8wWPOevPufEtf5LFqmB5WHCd5YrrLA84eWHAlmFByomUMmttZE8T2DPtIGcWKseWUdGHuAaeExYrTj1pkRMWS7qQ+rGA1jCs+nDXQuX4oe1DtowKhaJEREREREREjjLHVKV+8skn84xnPIMvfelL/PM//zNnnnkmo9EI6C+MGGOIMfLBD36QRzziEZx88sk89KEP5f3vf/8Bu79lrxgjv/7rv67fkYiIiBzV6rrmSU96Eg984APZs2cPd7jDHfjsZz/L6aefvtFLk2OAag0RETmeTbtIhj7QlDLGQEh9QGjdWh2YdpGUM22MrNYddRfZOe7YPe5mI/YSa3Vg11rLWhNoQ2LaRVbqjrUmYEw/Zq+LkWkd2L3WcNGeKbunHSH1QanKO2KCpous1WEekGpD4q2v/GM+9J53YIzhQU9/MTf7yTsDcMJCyQ9vH2GNYXFQ8MMnjLj5KVs59cRFrr91yA22Djl5qWJ5WLJQFYzKvgMUgLd9ZyyAuksU3rJ1VHLdLQNuuH2BraOSk5YGVIW71v9dREREREREROTKHVPBqH3d8Y535C1veQsXXXQRr3/96/mpn/opcs7zHd05ZyaTCeeffz6nn34617nOdXj84x+/was+Or3iFa/g05/+9EYvQ0RERORyffWrX+Wnf/qnefWrXw3AM5/5TD7+8Y9zwxvecINXJsci1RoiInK8aUICoJ51jYop0Yb+795a0zFpIhgwwKC0tCFTh9h3eAKSAWvouy2FyFob2TVp+eala4ybwLSNXLLasGcSaEIkxIyxMO0Sl45bdq91rExavr97yq5xw6iwWAurTSDETBczf/2WV/O3574WgAc++fnc5k6/xMBZFgrHtlGJt4aTFiuuv23I8qig8JYbbB/xQycucMrWIaeeuMiNThixdVjgncMaw9A7FqqiD2KFRM7grWFp4Fke9GP8huWBIwFFRERERERE5Ohh8r6zH45xX/ziF3nTm97E29/+di699FIAjDHzGxjru7xlrwsvvJBb3vKWTCYTTjrpJFJK7NixA4C73OUufPSjH93Q9X3hC1/gFre4xfzx5z//eU477bQNXJGIiIhc297xjnfw+Mc/nvF4zEknncS5557LPe95z41elhxnVGsce1RriIjsdelaQ0yZ3ZOWaRvnnZvWmo6m68NPpbPsmrbUXeSi3TWXrjWsNX3XKJsNVWH7v4c5szgoWKo8XUwMC8taG7HG0HSJaRdYawJ5Nr6vTYnCGkZFyaC0xJQZlp4tA8+gdBTO8KkPnM+5L3sOAL/yuGdw5wc+imHpWBqU/esKz9LQMyo9VWFZLD2TNmCtmY3x68NZzkLlHVVhsdZAhpzBGLDWMPCO0u/dZ7pQeYWiRERERERERI5yx2zHqIO5+c1vzstf/nK++93vcv7553PPe94TY8xGL+uo9rjHPY7JZALAy1/+chYXFzd4RSIiIiK98XjMYx7zGB7+8IczHo+5613vymc/+1mFomRDqNYQEZFj2fq2ypz7cXIWQxPiPBS1NCiIOVG3ibUmEmIihtR3g2oie+rA7knHrnE/Gu/rF6/y1Yv28H87x3xjx5TVacfatCPljCHjjCECdejPOW4STexH5hXOQM7smnZcutrwyX/4O972p88F4BfP+A1+6YzH4pzFWUtKmQSMSjcPRS0PCqw1XGfLkB85cZEbn7zET/zwNm73I9u52XW3cL2tQ7YvVGwdlmwdlWxb6D8uDwpKb/uuWN6xfaFUKEpERERERERkEziuglHriqLggQ98IB/4wAf45je/yVlnncWNbnSjjV7WUefss8/mIx/5CAC/8Au/wMMf/vANXpGIiIhI7/Of/zy3v/3tOfvsszHG8PznP59//Md/5HrXu95GL02Oc6o1RETkWLSe9c1k2phIZOq274Q4LB2rdculay3WQhsjq3VHmxJtF2liokuRSReoQyQnWGsCPxh3s/F5Lat1x7jrg09NoA8/Ac4YcoYQM9M2stYEJm1kZdoRQubr//UJ/uplzyTnzJ3uewa//OinUoeEMwYDbF8s2TIs2TIqrnT8XeEsW0YFJy5WLFaewlmcNVhjcNZQuP+fvTuPl/yq6/z/Ost3qaq7dHdWIGAiDKiEXYKAAhMmiOKMMCjC4LBJQAEJmyBCCKCiIAwYQQJEGGBQRBB3BYYRA/4QlD1E2QmEkKW7b997a/l+v2f7/XGqqm863UnvfW/yeT4eeXR1961vfau+Velz6rzP56NZqCwnL1Qs9wsKc6v8WlUIIYQQQgghhNhybvUz+DPOOIMLL7yQb37zm3zkIx850aezaVx77bW84AUvAKCuay655JITfEZCCCGEEJBS4tJLL+W+970vV1xxBbe5zW346Ec/ykUXXYQx5kSfnhA3IHMNIYQQtxgJxq1n16hjddxxzZ6G3aOOYevYM+7YNeoA2NN0ufpTF0hAYQ1KK0gK52G9zeEnFyMuBBoXWR13rI4dE5doXUAz7V2nciDKaMVSzzIoLaUxhARdiFzx+U/xZ695HjF47vagn+Ixv3ohC7WhNAaNYlAZjFEMSsP2QUld5LHioNobkNofrRWDyrJjUHLyQsUpixUnL1TsGJQMKptb7AkhhBBCCCGEEGLLkHrPG5x77rkn+hQ2jWc961msrKwAcOGFF3LHO97xBJ+REEIIIW7t1tbWePrTn8573/teAB7+8Ifzzne+k1NPPfUEn5kQN0/mGkIIIbYiFyLjNjBsHaMuEEMipMSw9VSFhgh7xp4QI6MmsNY4IolttWXcBawyqOQxOre0Cx5iTPgYUSiCSrQhEVNCG9BlSSISPBQo+pXB+URdGgaVZaE0pAT/fvmX+L+//3x813L7ezyQhz79Iq4fOXxULA8KlnslJw0qAIxWrIw6FquCkxZL+qV8HSqEEEIIIYQQQtyabJlvAmKMXH755fPfLy4uctZZZx328b71rW+xvr4+//3d7nY3lJIdXwB/+Zd/yfvf/34A7nrXu/Jrv/ZrJ/iMhBBCCHFr99nPfpbHPOYxfOMb38AYw6te9Spe8IIXoPWtvgCqOApkriGEEELc2LD1jFoPQFUYVsaOsQ9MusD6xLE2AXSi8wnnIruGDW1ILPcLNIqQEgs9g4uGxiUGBVgFk87TeE0bIjolrNF0IdK6RBs6Kq1Y7uWKTgtlge0pYgKFoguwds2V/O3v/SpuMuKUO92DHz//t2iCpnSeFaAuDLFMrE0c2/oFvdKwVBdorVhvPDFxozZ6QgghhBBCCCGEuOXaMitJl1xyCfe61724173uxX3ucx++9rWvHdHxvvrVr3Lve997fsx3vOMdR+lMt7bV1VWe8YxnAKCU4i1veQtFceDy4kIIIYQQx1JKiYsvvpj73//+fOMb3+AOd7gDH//4x3nhC18ooShx1MhcQwghhLih1Ymbh6KaLrA6drQu0rlIAtY7z/dXG3atOa5fbbhqZczOkSMEWB07rl2bMGw8nQ/UlWVQGUqrOXmx5uTlPtsHJb3CgFIoIEUYdYEUEj4ltMot77RRVKVhW7+gtprJ7mt490VPY7y2wkk/cBd+/BmvpsOy3jgaH1moChZ6Bms11miqwuBCYnXiaLoAwKj1rDXuxL24QgghhBBCCCGEOK62xGrSaDTila98JSklAF760pfysIc97IiO+ZM/+ZO89KUvJaVESomXvexltG17NE53S3vhC1/I1VdfDcD555/PAx/4wBN8RkIIIYS4tdq9ezf//b//dy644AK6ruORj3wkn/vc57j//e9/ok9N3ILIXEMIIYS4oWHraVwOEa01jvXW42OiV2pSShRGUVpFiIFd45Zdo47do46m84w6l0NKIeF8ZOQCw2mVJms0WikKpeiVhspqCq3QSmOMhpgwWtGzhhABBYVRpBQprEZ3a7zn5U9nbec17Ljtmfy3F/4BC4uLGKPQRhNzWSlGbWCxMpy6VBETjFqHj4n1DYGoSRcYToNfQgghhBBCCCGEuGXbEnWj3/e+93HdddehlOIOd7gDL3nJS47KcV/ykpfwzne+kyuvvJLvf//7vP/97+fxj3/8UTn2VnTZZZfxtre9DYDTTjuNV7/61cf18a+77jquv/76Q7rP17/+9WN0NkIIIYQ4kT75yU/y2Mc+lu985zuUZclrX/tanvWsZ0k7MnHUyVxDCCGE2MuFOK8UtdbkKlEA/dLgo2JQWSbDls5HXEg0XcSFyLgLQGLiAorcei+khAYKoxn5QGU0pi6YdJ6Q8nGVUlijUUCICUWiNIqJCwwqy0JlUUbRjYZc+pKncf33vs3Sybfh8S9/C3b5ZIaNo7KJsjAUVtEvNGWhGbaRQEe/MISYz1UrKDpNionlfsmo9TmcZbbEvlEhhBBCCCGEEEIcpi0RjHr3u989v33RRRdh7dE57aIouPDCC3nqU58KwDvf+c5b7WJF0zScf/75853yb3jDG9i2bdtxPYc//MM/5BWveMVxfUwhhBBCbC4xRl772tfyG7/xG4QQuOMd78if/umfcp/73OdEn5q4hZK5hhBCCLHXuM2VopouzENRSz2LD4nOJ6xRjLpA53J1ptZ7QkyUVgGKcReICULy+AgpJhZ6lkFliREmLqKNIgRFCImQIsFDrTUBcoBJK0qtUEqhjCK0De985TO4+hv/zmDbDp78W2/jpNNvy56xo9CaujLUhabQhsoaYkist45EwoXIQmnzORaGcRcYtZ7ViaNXWkatZ7EuUAq0UlRW0ysMWksYXwghhBBCCCGEuKXY9Fui2rblE5/4BABVVfELv/ALR/X4j33sY6mqipQSl112Gc65o3r8reIVr3gFX/3qVwF4+MMfzmMf+9gTfEZCCCHE1hZjYtR6do86dg5brl9v2Tls2T3qGLU+t/oQN3Ddddfx0z/907zoRS8ihMBjH/tYPvvZz0ooShwzMtcQQggh9oox0focjJpMW+n1S4NROfA07jzDNmC1QilQ5LZ3pVH0S4NWitJojFY4H4kJtFGkaRWqRML7QOc93ucAlFaGGBMuJayCwmqsMgysBRJt0/Env/NcvnX5Z+gNFvmV3/kj7vif/hOF0ZRGs1BbdgwKtFK4GHAhUlpNYfM5rwwdO0ctw8axMu7ofGR14rh2rWXXMP/nYyTEHKIatp6dw5bVscOFeAKvhhBCCCGEEEIIIY6WTR+M+sIXvoD3HqUUD3nIQ+j1ekf1+P1+n4c85CEAOOf4/Oc/f1SPvxV84Qtf4LWvfS2QX48//MM/PMFnJIQQQmxdLkRWx46dw5Zh63EhL7TElGTB5SZ87GMf4573vCcf+tCHqOuat73tbfzxH/8xS0tLJ/rUxC2YzDWEEEKIvSYukIDOR3xMKAW9MldZ8iGyZ+zwIeJDoldqtvULtFa4CErNWtIprFEUhaW2CgM0PtG5hPMBbTQhKFBgtIKYSNOxsiJhFJRWU1pF5zx/efFL+Mq/fZyiqnn6q97CHe78I4QQaX0kpkhpNC7mNnyFMXQhMmwCnYtoBSFFJm1gvfVcu9aw2nQMm1wxanXScd1awzeuG7Jn3LHWODofSUDjA7tHHcNpW0EhhBBCCCGEEEJsXZu+ld5XvvKV+e173etex+Qx7n3ve/OhD31o/nj3ve99j8njbEYhBH7pl34J7/MXPS972cs466yzTsi5POMZz+Dnf/7nD+k+X//613nkIx95bE5ICCGEOETD1jPasHjS+UjjAzEmUiK36NCK2hpKq2l8oPGBQWVZqDb9sOyYCCHwW7/1W7zyla8kxsgP//AP8773vY+zzz77RJ+auBWQuYYQQgixV+tzYL+ZVo2qbN5P2YXIxAU6H3EhUheatQlU1rDcL+hiIoTEqPM0LlBaTTdtw7dY50pSAC4mdBfQClLKIagQ8zG7GFClpQwwbB3LfcPH3vFqvnTZ32Os5Rdf8gbudPZ9iEDrEp0PJKVQKKJPKKVIJFofKbVGKcViXWA7z9hFUgSrNU0XmXSBJgQabzlpULJn3FFaTb+0tC5itaJXGOrS5EqvKbFUF8f/ggghhBBCCCGEEOKo2PQrcCsrK/Pbp5122jF5jI3H3fh4twavf/3r+cxnPgPA3e52N57//OefsHM59dRTOfXUU0/Y4wshhBBHYnXiaKYtR5ouMHEBv792eSHJgsvU1VdfzeMf/3g+9rGPAfCUpzyFiy++mMFgcGJPTNxqyFxDCCHErVmMiYkL0+pLiV3DlphgvXEoFIPK0LhAmP6cjzEHnhRUhSGkRG0NMSR8zOGjpMCHSCShgZhAaXA+EVICIv3SoFJChURhNV2IuAijNqCVp19q/u+7/5DPfeT9oBSPvOBV/PB9H5SrWbnIqPP4mCh0DkOhIEyrWCmlGPQsS3XeeND4QEqJqBUKICXqUtNOAjElIDEoC4xWWA0hgY+J9dbTxchSXTDpAlqpW+1GBiGEEEIIIYQQYqvb9DP64XA4v32sWqlsPO7Gx7ulu+aaa7jooosA0Frz1re+FWs3/VtCCCGE2HSGrZ+HotYaRzvdIa9U3mlfGI1WiphyK7122p5ksy247Ls4Nq9ypRSV1fQKg9bqqDzWP/zDP/CEJzyB66+/nsFgwCWXXMIv/uIvHpVjC3GwZK4hhBDi1siFyLgNtD63zpsJkTxenY5V94zVtBV0oHG5PXQXIsZotvdLrl1riCTqQuPaXCmqDYFp4SmU0nQ+omMeP8YAgUTrAqDoW4O2GlpFShGXctWpb/3Vn3D5X/1vAB7ylBdzu3ufy+5xR+0MVit8iKQEmhx2SgkgYbRmuTYsVJbKmtzOerpRYdJ6CqsxSrGtX1BZQ+cjoIgkKmum97dMusC4C7QusoZjqS4YtX4+rhdCCCGEEEIIIcTWsulTMNu2bZvf3rVr1zF5jI3HXV5ePiaPsRldc801jMdjAIwxB7UY+b3vfW9++1Of+hR3utOd5r8/77zzePOb33z0T1QIIYTYxFyI8/Z5G0NR/dLQK/e2DpmpC8MgpU214HKgxTEAUl7Amj3Pyhr6lTnsc3TOceGFF/LqV78agHve85786Z/+KXe+852P7EkIcRhkriGEEOLWYhaA3z3qGLaelHL7OR8iCSiMYnXiSCkx7gJa51B/4wKr446JC0xcDkxVhSLGhDWKXmlZqAJtiPSLHKQath6jFSrlgH2hFaBonKeLCbBYA2uNx/kAJEqtGbvI9z/1V3zzLy8B4G6P/GXOvP9/ZRIiZYiMQz7nSKIwChcTdWFoXaAuLXWhGVQlRilKqxl3AUVub+18pLCaXmmop6EpPR3OzsbvXci/DiqLNYq1iad1kcYE6sIwbgPLfQlGCSGEEEIIIYQQW82mD0adfPLJ89tXX331MXmMjcfd+Hi3Js45vvGNbxzSfZqmucF9zj777KN9WkIIIcSmN273ts+bLaos9fIu9QPRSm2aBZdh6+fBLsgLR40PxLihYpRW1NZQWk3jA40PDCp7yNWtrrzySh73uMfxyU9+EoBnPvOZvPa1r6Wu66P6nIQ4WDLXEEIIcUs3C8BPnOe69Zb1Joei2g1VQgujqQpD5wNGK7oYcV0kxIjRipigcZHVSUuvsMQEISWs0tQ9g9EwcYFRF7BGYY1GqRzGSgoCQEx0IUCCCR7lFSlBqS2qymPQlc99jG/+5cUAnPmfH8cPnvs/GLtAGRO1AqU1dWlIMTHuIv3agEooraitZjANR80C/D7m0JfzCUWu5FoajZsGoHqFxcdETAkfItZoGhfol3ks3y9zSGzS5XF66wMx2qNWQVUIIYQQQgghhBDHx6YPRp1xxhnz2//4j/94TB7jYx/72H4fTwghhDiejmcbM3F0xJhofQ5GTaat9PqluclQ1EYnesFldeLmLQCbLjBxAR9vVDMKQqJ1EasVvcJQl4ZR64kpsVQXB/VYf/EXf8GTn/xk9uzZw/LyMn/0R3/Eox/96KP5dIQ4ZDLXEEIIcUs2bD2r445xF9gz7lhvPI0PDFtP5/KYzxhYKA1GK0jQhVy9yRPz+DblcW5MiXEbUQTsNHi00DOECKUx7Fio8KsNzmis9viQsEbjfKJNuSppoRWdTzRdorCJXmHpV4oQS77+uX/ma+97NaTE7e7/X7nTT/8SSkGIEa8UE58obWKtcSxWFjQ0LqAVLNYFtTUs9QqMVlSFppu222tcIBApjKa0Gki4kJ97rjYVMRoaH1gwufVfv8yvX6808/Fx5yOl1Uxc3iAghBBCCCGEEEKIrWPTz+Tve9/70u/3GY/HfPGLX+Tb3/42Z5555lE7/re//W0+//nPA9Dv9znnnHOO2rE3u3ve856ktJ/Fz5tw5plncuWVVwLw4Ac/+AYLPUIIIQ7P8WxjJo7MvuG1UesZd4EQE5POUxe5fd6hOFELLsPWz0NRG1sAKsW8nZ9WuYWKC5HW59Yp662ni5GlumDSBbRSN1k5qm1bXvjCF3LxxXn3/znnnMN73/tezjrrrGP6/IQ4GDLXEEIIcUu1OnHsGraMu8Cwdexca2l8YE/j6FyEBFVhqNG0PgeeCqvpXEAVhrrQJBTDJoecRl0OSQ3bgJ1WbqqLHJYftR6jya3pcr4qt7wLCZ8iMUJKuWJU62Le+FEUKA0kxfVf/wKf/aMLSTFw+x99KPd4zHMx1lIYhdZqet9IrzAYpQghj8u10ZAUzieWa4MLEaMUTRdofAQF4y6PdxdKOx3b5vOzWmO1IlmF0YqUh8Js3COglaI0+fVpfKC0+fagOs4XUwghhBBCCCGEEEdk06+qFkXBgx70ICB/ifKyl73sqB7/oosuIqWEUoqf+ImfwNpNnxUTQghxCzJsPbtHHc00FNX5yFrj2DPuWBl17Bl3rDWOzuc2EI0P7B51DDe0PjteYsxBoN2jjp3DluvXW3YOW3aPulw9aH+Vhm4hXIisjh07hy3D1uNCJMSUd6DHxLB1jLuQF54aP2/PcTBmCy6Qry9A6w/+/ofDhch64xh3nu+ujLl2tWFl3NH6vOveaEVp8676ujAs1gU7BiX9aeirdfl9CjBqD/x8v/71r/OABzxgHop6wQtewMc//nEJRYlNQ+YaQgghbomGref69YZxF1hvHd9fnbBn4lgdO7xLlEazfVCy1LMorRi7mP9+0uFCHuM204pSldW4GPEhEElMnGetdTks1QZAoVHzarfeRxSKiQusjDsmrad1ns4HOp+ISRGAznnGref73/wKl73xhQTXcvu7P4AHPOVlbF+oOX2pZrkuuc1ynx2DkoUqn6tSikSiKnKIf+IClVVUhcJqTWE1LiYmXWD3eptbRqf88z5EwnSDYFXk8XdpzXwzAHCjDYS5yhTzuU48xA2GQgghhBBCCCGEOPE2fTAK4IlPfCKQv5z44z/+Y/78z//8qBz3gx/8IO95z3vmv3/Sk550VI4rhBBCHIzVictf1JPbmK2MOlYnuXKPCwkfc5uH1kVWJ46VUUcz3fE8av08mHKsHSgUFFMixFxNaNh6dg5bVsfukEJBW8HNhdfWJh1rzaxdiKL1kT3jvdf2YBzPBRcXItfsadg96tg97Bg1nhATg2kLwBBh1OYA3trE4afXUyvFoLIs9XKwo3VxXnFq3IYbPc573/te7n3ve/PZz36Wk046ib/5m7/h937v9yjL8pg9NyEOh8w1hBBC3JK4ELluraFxkfXWsXu9Y33isUZRFpqlfsGpSzWnLFZs65Vs6xUsVgZrFJPp+G7cBRKJUeepS41RGj9tP9f6yK71lhDzGLHzgdZ7VkYdKyPH2EV8nLaXLgwxJVofmTg/bW8XKTUorWh2fY9PvPF5dJMht/uhe/Ezz3sNpy33OXWhpjCafmXYsVBw8qCitoZ+qdneL7BWoZVmqVdQFZpxF+Zh/VGTK7pOnKcJEefzfGVt7Gh9ypsSrJlvTKhsbl+tVf5VqRu2s579djY8l1yUEEIIIYQQQgix9WyJYNQv/MIvcPbZZ+cy3DHy+Mc/ng9+8INHdMy/+qu/4vGPf/x8B/fZZ5/NYx7zmKN0xkIIIcRN27eN2Xrr8TGhFNSFZrG2LPcKFmtLXei8+3raxmwWiJp04ZhXjtpKFa2OhZsLr7lpeK2bLjytTxztLCzUBdYPMrx2vBZchq1n53rLWuNICdYbx6gL+JB31a9NOoZtDkOllBe+VvYJeVXWzCtHTbpZhaswD3WNx2POP/98Hve4x7G+vs5P/MRP8PnPf55HPOIRx+ZJCXGEZK4hhBDilmR1nCuZti6wMnIMW0e/tCxUBYPKMqgMi7WlMLk66KCybOuXbOuXDEpLSInWh3lbOp9gW9/ShcSw84zGnokLXLc+4fq1hqt2N6xMHI3Lresg4UJgvQn4GFHoaZtmQ22nt63Bre3kU296Pu1wD6ee9UP8/It/n22LCyz2ShYHBWds63HSQkXPWk7f1uOUpZJeYUEpFqoCY8Aa0FqhgNYn1hrHauNYGbVct9awNsrVqtqQ/46UKK1hMB3L9kpDStNA1PQbUn3DXNR8XD4br++TmxJCCCGEEEIIIcQWsCWCUQCvf/3r0VqjlKJtW37u536OJz/5yXz7298+pON85zvf4Zd+6Zd41KMeRdM0pJQwxvD617/+2Jy4EEIIsQ8X4jxostbkkA3kXdU7BiWLdUFdmCNuY3aktkpFq2PloMJrdcFCbamm4TUXEsPWs97m5964eFCVo47HgsvsejYu0PjA9esNeyYOFwJac6PruTptrQfMWwTO9EozD+vNQnETF7jiiis455xzuPTSS1FKceGFF/L//t//44wzzjj6T0iIo0jmGkIIIW4JYkzsGXdAHvt1PmCMYrlXoHSuilQYPa+ONKOVolcYlnsFlc1/P5ujEOGUxYpCK0i50tOoDXzr+jHXrDWEFAghEUKiXxo0Cq01RiVSgghoo7BGU2hNv7LoZpV/veTXGK9cy7bb3IEnvOwSduzYTmk01igWSstSr+C0pYrt/YKlXsH2QUW/sixUhkJrYsiVoLZNq0ZpDZFE5wPjNtL5RBcjMSnaLlJM20TPgk91YagLQzedS9U2z7VmlVxnummLa61vWFlKCCGEEEIIIYQQW4c90SdwsB760Ifyute9juc85zkopUgp8a53vYt3v/vdnHfeeTz0oQ/lnHPO4ayzzmLbtm0sLCwwHA7Zs2cP3/72t/n0pz/NRz/6UT7ykY8QY5zv3gZ43etex7nnnnuCn6EQQohbi1nbsaYL8wWHpZ6lmn4Zvz+zNmbWKNYmPrcxM4G6MIzbwHL/6Gad9w0Fzc5TKaY7vvOCSUx5QaL1cV7RqouRpbpg0gW0UixUW2a4MXdT4bVeaeYLIk0R0EGxWFvshu3lnYus41isCsZdoJy+ZgdyrBdcNl7P3eOOYeMZu4ACFqq88LT3euawk4+JYeNxRWShKpi4gFIwqGxuQWI0rY80PlAYxdvf8Q5e9LwLmEwmnHbaabznPe/hoQ996FF9HkIcKzLXEEIIcUswaj1tiDgfGXd57LZYF3kO0QQmXaRXJnyIKBRagbWacjq2t0ZRWc3KqEOhUFoxbDxKJZb7BSPn6YJi4qANCe8jo5RIKVEUis4nIFEbjVWWnlK5Eim5VXSKoPyYT17yQobXfofBjtN4zIVvZuGkkyimYarKGMpC41JksSgotGGxlwNMpyxWjBqHNwlUgdGawmpiVJRWYxTowtAvYKE2tH4238rBLGMUjQss17l61rjzpJSwOv993gCxd04WU7pRcKqyW2aPqRBCCCGEEEIIIaa21Erls5/9bFZXV3nFK14x/7MYIx/+8If58Ic/fFDHmC1SzP57+ctfzq/+6q8eq1O+xTnUXfNCCCFuKMY0r8IzmQZV+qW5yVDURrmNWWLcBSZdDkblNmZ2Hqo5UgcbCpqpC8Mg5VZs42nYaw3HUl0wav08SLWVHGx4rbQaFwK1NbQuopSiX2pGbaBzkdYEKmuYdIGit//X4FgvuOx7PWft72qj0YVhqVfc4HlVFmKZaFx+j+Xn71iYhrwqq7HT1iutj6ytrfHil7yAD7zvvQCcd955vPvd7+a00047as9BiONB5hpCCCG2utVpu+Rh5/AxYjT4kGhcHgOGlEhJkzsgJ0IC1wWGyZNi/jcskYPyky6QiPRKy3d3T0jTeYz3iX5lGZRQFIpJG/EpEWMipkRpdW7B3SoMsFAaolK4EPFtwz+/5cXs+e7X6C1t57Evewu3ue3t0QpcjFitKaxCoUBBTKBIhJioCz0Neyn6laFXWKxVGBRjHUgkUIptvYK6NMSUGLYBDaxNPH4aGDt5sQKVNybMx8XTyrzlPtW0Jl0gJbA6B68U0CsObt4mhBBCCCGEEEKIzWNrrVICF154IX/3d3/HKaeccoOd2Gm6Q+2m/gPmO8BPOeUU/v7v/56XvvSlJ/LpCCGEuJWZuJAXCqYVeZTKbckOxYHamB0tBwoFzSoF7c+sotVSL2euWxfnFYpmx9sqDiW8Vhf5WlijsTqPMWLae01nrQU7H4kx7ffxjvWCy77XMyXm7Rq1UuRHvCGtFP3SslgXQL6eG9vqQa4e9h9f/iKP/skH84H3vRdjDK961av4h3/4BwlFiS1L5hpCCCG2stn4u+nyWDymPLZNCULKQaC11jFsPKPGM+4Co8YzbDxrjef6tZbrVjuaEBi3jpVRbsU86hz9ylAbQ0iKzkWsVtTWUBea5dqyUFsgUUwD/saANoCGQisskX+59EJ2fv0LFPWAn3rB77N8+h2IKeZW3S5htUbrHHZSKNy0quqkjfkYRlFYTW0NvcpwUr9iqV9wu+09bn/SgB39Aj+taFtbw45BwbZ+wSmLuUKUC4kQYW3iWJ3kloNVoefj/P6GeVnrw3zcOxvbV9Yctc0oQgghhBBCCCGEOH62XDAK4GEPexjf+ta3eP3rX8/tb3/7+ULEzMZd2hullLj97W/PG97wBr71rW9x3nnnHc/TFkIIIWinX+4305BJZfUht02btTHbeJzZcY/U0alolX92tgM7V7TafyhoMzqU8NrGa1FveN5aqXl4zU3Da81+wmvHesFlv9ezMjmANX2IfHb7V1p945BXiIQYeeelb+Hx/+08rvzmN7jt7W7HX/79R3jxi1+M1ltyeCnEnMw1hBBCbFXTIqSsNo7WR0pj6GLMbZS7iIuRzkVCSviUWJ04dk86dg9brl5puGat4Zq1MbvWGlbGHdevd1y32rJn6Ll2raXzkaVKc+pSybAL7Jk4+qVlobIUWtOzlsXSMigsPasxWk1DWZ5PvuM3ufbL/4IpKn78Wa+hPu2ODDvPsAm0LoCCwigSYC1Abr0HOdTlQkKh2N4vWO4VLFaWXmkYlBatNdt6BTsGFacsVJy8ULFQF2yrSyprWO6VGK0Ytp6rdo9ZGXc0LlAVmoUqbwTolwZrNDElRq1nbZIrrlaFnrfX61dSLUoIIYQQQgghhNiKtlQrvY16vR4XXHABz372s/nSl77EP/3TP/HpT3+aa6+9ll27drG+vs7i4iInnXQSp512Gueccw4PfvCDudvd7najRQwhhBDieInTBfZZUOhwW8zN2pjNjhPT0QkeHa2KVhMX5hWtSquZuMCg2hrDjkMNr/VLQ+sjlTW4Iu94H7WeMH39mhAorKYLkf70PnFD60E4dgsu+7ue/dIQIiitIOQd9TcVfKsLQ+Py/X2IjIdrPP9pz+ZDf/tXAJz7sJ/ijW95G6edcspRO28hTjSZawghhNiaEuPO46fj2VHnCCERUqI0GpVy+Khf5jbQMSZWJ57VcUeICVJCK5UrK6VEqcGnSAjQrHvGrScCi7VluWeZdIGJ88RkKXQex0Zg3HVUhaEHOB/4xLv/F9/51/+L0ob7POWVLJ95NybO50q4lUXrPD4edZ6TBxUpQYJ5kN/5iCkNRinqIo9ll3oF2/sl1uh5lcdt/bzxoOnyXCQAIeUW0UZpINCGSBk0jc+VVFsf6JUGoxVrE0cX8p9DHqMvTSuoDiq75dqDCyGEEEIIIYQQItsaK5Q3QSnF3e9+d+5+97uf6FMRQgghbtbsS/bZr4daLWpmdrd9j3ekjmZFq9ZHGh/mIa5BdXTO8Vg71PCaNZp+aRh3Ybrj3NFOd+KPG48LkdJoQtQ0LtD5eNwWXPZ3PY1SjLpAbQydi7nNX5lusk1ivp6Bz/zbp7noOU/je9/9DrYoeN5LXsEzn/VsqsJQWVkoErc8MtcQQgixlcQ0rV5qYDwJkGBx2uq6qDXjNhBSonORcefz2NQFtIJRFwhAZRQxJlxILNQ5iNT6XLHJTQNWqxNPVRoKqwkRWu/RSlFog1K5nV7TeTDw2b94K1+/7C9AKe7zhJdyyo/8GM4ntEq0LjLpPAvTDRQpMg/ja6Ooyry5IEyTUpXVxDhtQW001uQqqCctVPNNB5XN1W59mM5FjEYrSCQUBYWBXmHnmweMVsQI642fv45WK3qlmW9c6JVmfo5CCCGEEEIIIYTYemRWL4QQQhxHSgFpb7DpcCs9ze42O87RKlCyWSpaxZiYuJCPkRJp+ppppaisplccvXZz+zqc8NqgssSUaFxkoSooTGBt4vKCi8vtS7RSmA3nfDwWXPZ3PUujGXe5ipXVCh/zLvp+eeDHNjrxp29/M2/9X79F8J7b3eFMXvfmd3CPe92bqjAooFdIaxEhhBBCiBNqOvbTKHyMNB5uU9U4O6sSqhm7wHXrLTEmxs7ThUDTRozOd48x0YY8jm9az9q4w8WEUXnc6Fxk2AZKqxhUlkFpaV2kXxu6GAgxURlNqxWf/Zt388W/fScA9/kfL+AuD3gYXYjo6bF8TIy7QASWgEIr1hoHCZb7BSQYd4HF2lCYPI5ufWT7oJi3sc7Bp3wulc3j3C5ErNEsTOcyi72C1XHL9XRYpVjqlxil2LFQoJXaO9fQitrmttMzg8pKKEoIIYQQQgghhNjiZGYvhBBiSziRQZmjSStFIOVznbYxqw8jUNJNKwHNnvPhVp7a1/GqaHWg6xliIsSEZtrq7QYnB4H8mo1aT2UN/coc9ZYWhxteW6wLtPLznepLvbxrP8a8sx6VW5cczwWX/V1PrdU8uFYXhmHrmXQh77zfT0u9ld27ePEFv8w//+NHADjvEY/kua98Lbc/7eR5m8XKbo3PnxBCCCHELVWMiarIFZSsVhg0ilyBqVcYXIi5wlPjpu3mIutNDj2hchVUkxSd83Q+onWuorTe+dwWerrpobKGBDQ+t462JlckTSGRlEKR29f9+z9+kM994E0A/NgvPIsfeuijGbceq2Zj4JQrOcVplVUXGVvPtoWSRG7LVxeGqtAMakuKuarVjkE5DUFN21BvaPttjWapp6cbFnKl1twhMDGoimk7adjWL7Bas2NQ7ve1VHDM5hpCCCGEEEIIIYQ4/iQYJYQQYlNzITJuA60P3CiecpyCMkdTZXUOQ1lD62JuMZcO3MZsf2JKdCEHo2o7C6Ycned8rCta3dT1HDU5VAR5MUIrhVL5vvvbxd34QOPDUQ8VHUl4beNO9WHjctioMixWBYVRbOvvXXw5HgsuB7qevTK3RKkKQxcjnYusN55emagLM38//tu//DMvetb5XHfN1RRlxTNf/Jv87GOfgDWaqtDz16VfSbUoIYQQQogTaeICvdLmcZxSVKXC+8T3VyZsG5SEGJl0ecwXUg5FjX3EuUBdGAqtMRr2dJ5RF0gpEaPCx0CIuZVe6yKhTFSlxnWQbGDUegqj8UGxvV/iga996h/4l//zGgDu9TNP4D7/9YnEBGYanIopkVwed0egdYE2RFzQJKUYVIa2C5w0qACFVppxyG3xBqWdtq/OoSi7n3G0Vop+adkw9GZt4uZj2IXKEmKiMHpLb7oRQgghhBBCCCHEwZFglBBCiE1r2HpGrZ//vvORxgdiTMc1KHM09QrDqPWUG9qYTbp8zgdr0gVSYlrhRx/VNmbHsqLVTV3P9cbT+ZCrRE2rLPm4N8Qzb/M2XZCxWtErDHWZX8+YEkt1cYTPPjvS8Jo1moVa0fiA6SJ1oTFaURcGo9VxXXA50PUsjKZfmtyapCpYx9G5yKQLNC6gSbznrb/PW1//amKM3P4H78Tzf+cP+U8/fDZKKerSzF/vQWU3dRhRCCGEEOLWoPW5RZ1RMG4DhdE4Hxj7QBp3LFSWLoY8vu0SYx/wLpIS+JRQIbBn6Bk2gdZ7Utq7UcGHvMHBxYhyiRANCUXbJJTybKsNq23CaMVVX/wkH/nDl0FK/NBDHsWPPvqZaACdW9cZpRi1Hms0WgFJ5V/J4+QuRspgMFrTr3J1KgVs7xcURmONIqbEoLQHPYfad2OJVoqlfnFIczAhhBBCCCGEEEJsXfINgBBCiE1pdeJoXK4e1HSBiQvzoMwNHIegzNGktaKyhsYHeoVhvc1VkqxR83YQN6X1YV5V6Vi0MTtWFa1aF3DTP9v3eo673MoNYDTJASmrcpBooVdMw0Q5gONCPicfE+utp4uRpbpg0gW0UkclEHe0wmsKxWJt2T4oUcDJC9Vx33l+U9dzUFlCyp+fxaqgNYGmC1x77bX89gufwWc/+XEAfvKRj+FJL3gldX9Av9As1HbedqRXmk0bQhRCCCGEuDWJKTFqPS7mNng9nZvp7Rw17FoPrE0cLuR21muNhwghRjwKgmfSQeMiMUUiCaMURivStM7roCwoTKT1IT8GeaODHwViKKhLw9cv/wwffv0LiMFzl/s/jHOf8uugNMZoTILSavqFRaPY3lekpGi8py41MUaaEDFKc/piRa80hJC4w44BRkNdWlbHHT7mFnwL9ebYWCKEEEIIIYQQQojNT1ayhBBCbDrD1s9DUWuNo3U5UKNUDnoURue2Cykdl6DM0davcjCqLnMbs9ZF1iaefpnolWa/IaSYcjhnFoo6Vm3MjkVFq3Hr5+e67/U0CoxWLNUFa00HJJQCazXG5IWYylpighATi3XBYMNr0brIGo6lupi2U9RHXL1os4fXDsXNXc+lumCk8vOrrOEz/99lvPjZT2P3zuupe32ef9Hv8p//68/ThEi/MJy8WKMU1IXZ1JXZhBBCCCFuLWLMYafv7hoz6jzrk4CPkfXJdN5gDKnILe+aaYXQ9UnHeudxPmCMJsZEjLnKaEwJo3K43mgotaYscvWmEBN7RrnCFClhp63oRl1g55Vf5f974/PxXcsP3OMBPOwZr0RbQ4rkNnrTsXAXItYo6sJSGEUYJaxOaGUofaK0msV+yUmDglOXas48ZcDaxNGFyHKvmG6uULQ+bLmxuRBCCCGEEEIIIU4MWc0SQgixqbgQ5+3WNoZo+qXZb2ioLswxD8ocbYXRDCrLqPU5EER+nuNpJaXS6LyTWUFKeSd2F3KbC8ihqGPVxuxoh4J8yKE1rdV+r+ew8VQ23w/UvCXGLAjWucg6jsWqYNwFyun1HFQWaxRrE0/rIo0J1IVh3AaW+0f+emzm8NqhOJjrOagsmsirf/s3ecvFryOlxJ1/+K783pvfwRln3on1xrFgcqUoBSxVBScvVJvucyWEEEIIcWviQmTcBlofcsvqzhNiYtw5QoSqyBVDtYKFsiCPXj2row4XIjFGXEw0zqNU3rSQwnT+ESO9wlBohTEqj39RGKMpi0DsIm2MpJhIJIbXfZdPv/nXcJMhJ93x7tz/qb8J2hACFFaDygErEviQqG3e6OJiYrlfstizLFSGYevxMVIYxbZBSWlzS+pTFismLm98mc0ptuLYXAghhBBCCCGEECeGBKOEEEJsKuN2b/u8WYhmqWdvMpQzawt2LIMyR9tCZQkx0bjAUl3QmMCky+3lWp+rYO3L6rwoMftC/1i1MTuaoaC1iaNXmv1ez40t95oNYarZ87Nasd54OhdpTd4RPukCRS9fz8oa+mXKgbIuX+/WB2K0R7wDfDOH1w7VzV3P73/vKn7ll57Ip//lkwD8jyf+Ei942W8RTcmo9Zjp+25Hv6QuDCcvSihKCCGEEOJEGrZ+vpnEh8jq2DF2gdVRy56Jx/vIYt9y+nJNFyKrjaMdJ0pjGNSGiQustwnvIz6AsVBqQxc8qFyFqnEBisSgLFFK5Sq9KWG0QikgJVxMjPdcxxcueQHdcIWF296R+z71txlHy+rEsVAVtC7SLzWl0bQ+UhUQp0NJg2b7oGDHoJxXkd0zcQxKy2mLNaU19KaVSu30OW/1sbkQQgghhBBCCCGOPwlGCSGE2DRiTNPKQTCZttLrl+agKhXBsQ3KHAvLvQKjFaNpq7m6MHQ+0vhAjImU8s5trRW1NZR27xf4x7KN2dEKBcVpe43CaIZNB9zwejYut9ybVZVSSs1DUUBeCClz4KqZtnrrfJy3+YAcpJq4HCjrfKS0mok7tNZ/B7KZw2uH4qau59//7d/w0uc9gz0rKywuLvG7b3gj5z3ikfPrWVkjC0lCCCGEEJvI6sTN2443XeC69SZXzu0CYxfRWlEUmhjBxTxmNUoxqDR7Ro5xGxl1Ibe2U4rGO/AwVoGUEhHQKJSBlkgILSFY+kWuHupCQiuFNZpmbTeXX/oi2j3X0Tv5DH7oSa9iomoIkVEbqApDpTVdiITkKYxmoS7pgDPXLQABAABJREFUlRqDYqlXsFDnsXJVGPpFriSlFTQ+37/1kUF1yxmbCyGEEEIIIYQQ4viTbwOEEEJsGhMXSOSgTQ7K5C+vD8WxDMocCwuVpbJ63gajtPoGAaiNFNPwV2WOeTjlaCw8KHIQ6kDXs5seo5mG4cppS42N6sLQTK+n85HCahoX6E+vp1Zqvvu8mb5+s8WTo2GzhtcO1b7Xcy1M+O2XX8g73/omAO56j3vxe3/4Dm7/A2fOr60sJAkhhBBCbC7D1s9DUWuNY9IFJi6iFBRWMSgNdWFpQ67WOmw8aXbfxjPuIl2MuBhR5AASKGJKKJVIKEIIhJgojCVG6BKoNpCSop7OVXwIhMmQz//RrzO+/rvU207lR3/5NcTBDkKELkQGgHMRXcI2WzGoLYPSsNi3FFrTKwz90qIVLNYF2/olo85TF4kuRlIErXJl2plbythcCCGEEEIIIYQQx5d8IyCEEGLTaPcJylT7CcrcnGMdlDkWCqNZ7mtitExcoPWRmDZ8sa8Ulc2LB8ez8tWRLjx0PuJCPOD1jNM1jji9UZj9P7cQE6M2MPGBQWEYtobtIVKa3K5vdo1nx9m4eHI0bNbw2qGaXc8v//tXefpT/idf+NxnAXjS05/J837j5RRFKQtJQgghhBCblAtx3j5vrckVQFsXqQuN1YqU8vi6VxiqqFlLjtYHCq25enXCzmFHimCnc4vRtIW51qCTJsSQW+QpSErRhoQmUReaBNNKvAlFomtaPv22l7B21dcoF7bxoAvewODU29O5wKj1xJhwIYICqzQnLVaculRhtGKhstSFoV8YiukcxxpNTNP7ALXJbbdLo9l3aH9LGZsLIYQQQgghhBDi+JEVLiGEEJvGLNCyNyhzeF9eH+ugzLGitWJQ2U0V4jqShYedrgUOfD3T9LrMLs/G0JQPkYkLuGmbPR8jyiuiNfgQcSHhQmDchfnPW21ucLyjabOG1w7V3/3ln3P++eeztrbG9u07+P03v5WH/dQj9vuzspAkhBBCCLF5jNu97fNalwNEVaHQyjBsHQBLdUGIidLkoJRWip2jhmHjUCTWmoALgfXG03QeqxWFgomPdD6ilEIbhbVAgkii8YmUYp4TeE/nHJe/8yJWvvlFbD3g3Oe8ntue+YNMuoBBEWKeh1ly9dd+ZSgLhQuJ5V7B9n45b6+9cdw8a7NttUJrhZ622d7fPplbythcCCGEEEIIIYQQx4cEo4QQQmwas0DL/oIyh2J2t32PJw7P4S483Nz1VEpBSvPrNQuwjTvPZBp4AvAxMu4CanospRXGKGqTd5m3PjBs/IbjHv5zjTHd7HPcbOG1gzGZTHjuc5/LW97yFgAe+MAH8p73/DEnn35bWUgSQgghhNjkYky00yqsk2krvX5paL0ixDTfiNArDS5EVoaO1gXWGsc1KxPGLrHetKw1AQ0kcotq5yNojdKBCKQYKbSGCMZqdFJ0IdGkmDcqpMQVf/pqdv77v6CLkgf/6mu4413uSq+y+F5iOHYUJrHeRiKKkMBazY5+yUJlucOOPqW9cav0zof5+F8bBSmHqmYBqQPZjBtLhBBCCCGEEEIIsflIMEoIIcSmoRSQuFFQ5lDN7jY7zpEEZcReh7rwcHPXUysI0+MS0rQKlJvvgO9CpO1yCz0XIlYpfEqYCJ2LdC5itcJPF4IaH1hvHDsOY2XEhTivinWjd12CQJq3L9lqVZT+4z/+g8c85jF86UtfQinFi1/8Yl7xildgbR4GykKSEEIIIcTmNnF5jNr5XE1VqRyCaqYhqZRm7afzZoHGe9oQGTeBiY80Lt+v8ZE0bVfnppWdXEgYraisofMB5xNBKWoVCSpvZvAx0vrIVX/zJq7//P9DacOPnf9b3O4u90ZrTWk0RsG4CPRVSUwuB+9jpFSKLkQqa2h9vEEwKqZE4/aGoqxVhACJxLZ+AeR23EIIIYQQQgghhBBHQoJRQgghNg2tFIG0ISgTqYsb7yi+OZ3PX/bPqt0cbuUpcWRu7nqWVuNCoLaG1kVWxx2l1WilGHV+fh1dSBRa068Ni1WBVlAVms5HuhBZmzis1Sz3ennRZ7rYc7CGrZ8vIkF+/zQ+EOOGKkpaUVtDaTWNDzQ+MKgsC9XmHkq9613v4ld+5VcYj8eceuqp/J//838477zzTvRpCSGEEEKIQ9BOx8XNtGpUNR0zJ2DiPNcPG4ZNoC40lTWM28D1aw3XrTc0PtIFTxsSpUo4rehCIMSEVorC5A0JVkPQGqtyYClvPlAoFQkx8b3/+06u/fTfgFLc4xd/gzPu/kCMViilqEtD2wUs4FOiMAqlNMZotNasDB2nLvQYtX76d4rOR1yI800tZaExSuF9YLEu6FcWBfQOYz4ohBBCCCGEEEIIsdHmXs0TQghxq1JZncMz06BM6yODlA4p2BRTopsGY+rpbmTZZXxi3Nz1rAvDuAtYkxt6zHbCx5TmoajSahIJhWKxLLBa0S8NvdISy8TKqCMBKcLEB5asJqQcwjqYik6rEzffad90gYkL8wpUNxAS7bRCVa8w1KVhvXEMG0dpzSG1ojuYdn1H2sJuOBzyzGc+k3e9610AnHvuubznPe/h9NNPP6LjCiGEEEKI429WeXXWMk8BaxPH6sSxZ+wYt5GQEqM20LjEdWsNw9bTuLyJwPtIiJGYFJ0PeB8xRqOMRgNtSPgYSURAw3TMHlUiJsW1n3g/11z2XgB+5NHP4fR7nQspojBolau5NtOQk9ZQWUNd5CqrRoPRitYHQsohq42bJazOwSqFYr1xVIXmpIUSyMeR1s5CCCGEEEIIIYQ4Ups+GHXuuecet8dSSvHRj370uD2eEEKIG+oVhlHrKa2et0ibdLkyz8GadIGU8hfspdWyy/gEurnrqZWiNJrW790pvt44AAqjWagKfIwoFFYprFEo8gIJgA/5TguVza1FXCRVeRFn3AaW+zcdjMqLRTkUtdbsbeGnVA51FSbvxI/ToFU7bV2yMu6I40RlDSlBvzR736M30XbveLXr++IXv8hjHvMYvvKVr6C15hWveAUvfvGLMUY+B0LsS+YaQgghtoLZWDklGHce5zWF1fgQGbWOsfNct9rQhURdwHXrLTEmRq3LYapZa2sSMUVCghQSpYqgFKVRaDQduVpriomkFDrBdZ/5O6768KUA3Omnn8odf+KRxJRQShPJVayUUoQQsEZhtGWxMngSC2XBoCzoVZpIotCGmMhVo7SiNgZj1LSdnqdXGrYPynlwql/J+FUIIYQQQgghhBBHbtMHoz72sY+hjkMLpJTScXkcIYQQB6a1orKGxgd6hWG99dOKQmoehrkprQ+Muxx06ZWzalGyy/hEOZjr2S8NExfQWlFaw7DxhJRY7mliivPgUjW9noXVoPKC0GR6rRdqi1Yq/366aNT6QIz2gNd+FkCCG4aicjUqc6MqZXVhGKTErmHL6iSHt9oi0rOG69YdC12uZnWgtnv7Ohbt+lJKvOUtb+E5z3kObdtyu9vdjj/+4z/mQQ960EHdX4hbI5lrCCGE2AqUAhKM2jwGNrViddJy9cqYnaOOcRNYbxwuJFYbGE08TYjsGXd0PmK0JoVIUhAiuJQoFPg4DSkpKI2isJZR5/FOEUJi15c/zpV/eTEAt3vQY7jDQx6L0aCSRqmEAoKPOBVQaAZ1rhSVK/cmti1YrDK0LuF9RJV5A0JdWBKJ1kdcG7FGsdwrGNSWpboAYFDZw9okIIQQQgghhBBCCLGvTR+MgryQcLA2Ljjs73439/dCCCFOrH6VgzR1aehipHWRtYmnX6b9BlYgt5aYdHtDUVWhZZfxJnFz19MajcndOqhtrtDkU2LcBVYnjsKo3DYvJtY6h9WKXcMu71IHqlLTLy2FzQs6KEXnI6XVTNyBq42N273t82ahqKWevckAXg5SKRZry85hx3rjqQpNaTQpORanizj7tt1zMdK4SF1oCq0PqV3fqPXElOYLRAeyurrK+eefz5/92Z8B8IhHPIL//b//NyeffPJN3k8IIXMNIYQQm59WirXW0cU8br1mtWF17Jj4QNNFhp0nAZ5E03omLleSWp/ksaTRERcSSuWqqymBV0CMgMJaDQl8iJRGoxLs+fdPceWfvwZInHyfn+KM856Cj3s3F2hdUuhIVNCvSxaqHIg6eami8ZEdvZIztvcYd549Y49SEGJiPK0oq1WuEtsvC0qr6ZVmPofrleagNwcIIYQQQgghhBBC3JxN/y3DE5/4xJv9mfF4zAc+8AFSSvMFiG3btnH22WdzyimnMBgMGI1GXH/99Vx++eXs2bMHyAsXWmse/ehH0+v1juXTEEIIcZAKoxlUllHrWaoL1sjVfMZdYOICpdG5RZ7KYZrOR7qwtxVbVWjZZbyJHMz19CGhFaw0HQnQkFt+kHexTzrP2sRNd5fnxRKrFFVpKI1m3Hl6yWCNwodciam0uUXfoLrxOcWYaKdVnCbTilT90txsKKqZBqi6EIkp4WMEl1isC0qjWKwsKG7Qdu/a9YaQEotVwc5hi1aKfmlvtl3feuvpYmSpLph0Aa3UAReH/vVf/5XHPvaxfPOb38Ray+/+7u/y3Oc+F63lvS/EzZG5hhBCiK1AKxh3gdoYvrcyYdjmMbULER/z2FQD3kXGLrLaOCadx03nSS6k3D4vRhK5SpRVitIYksrjY6s1aFAhMfruFXzzfb9Nip6lH/kJTv3JX6bzCaUjKSm0htJ7RiqxUFn61rBUF5yyVFFZzWmFYbEqMFpRF4bbbbdoBdV0LL+tV96oYurMoVRMFUIIIYQQQgghhDgYm/6bhne84x03+ff/8R//wc/93M8RY0RrzZOe9CSe9rSncb/73e+A9/n0pz/NW97yFt71rncRY+TLX/4y73//+7nLXe5ytE9fCCHEYVioLCEmGhdYqgsaE5h0ucpO63N4ZF9WK9llvEnd3PVcbzwxgQ/gY6RfGHpFrjDVuEiK0CvyokkXI4XWoNR0MSixrWfpV5bW5ypTiVxhKR6gWsvEBRI5VOdj3jk/a724Pz7EeTWy2SJUNQ3nlUZTGU1hNTEl+qWdt91bnzh2Te93bdtgp239tvUKFnvFAdv1zaqftS6yhmOpLhi1fh6kmkkp8YY3vIEXvehFOOc488wzee9733uTYyAhxA3JXEMIIcRmE2Ni4gKtz4GnlGBt4libOEadZ9LmTQOzzQXdNBwVphsLYkwwDd2DwoVATIkYc1tXrRQpgVGKBCgUpVG4kKiNYff3v8kV73wpybUs3ulHuf0jn4cxBhSkCCkXl8JqRb+wnLZUc/JSyY5BycI0DLVjULJQW4xSrDUOUBRWsVAVFEaxrV/e4Dkrcgv0fmVkY4sQQgghhBBCCCGOui29Yrxr1y4e/vCH893vfpdTTjmFD37wgzzgAQ+42fudc845nHPOOZx//vn87M/+LFdccQUPf/jD+cxnPsOOHTuOw5kLIYS4Ocu9/KX6qPXURQ48dT5XA4oxLxDILuOt46aup9UKBQwqQ1loFkpL6yM6JfqlQSvQSuNjxGpNAkLKt2urcSGxOu6YFUgat4Fh41nq7b/93CxY10yrRlXTFn4HMgtFtX5v273lXknrQ34OIVBYTRci/el9tFIotbft3rjzDCrLSYNqviC1P1opBpXFGsXaxNO6SGMCdWEYt4Hlfn6Su3bt4slPfjJ//dd/DcCjH/1oLr30UrZt23aQV0QIcXNkriGEEOJ4ciEybgOtzyH+mTjdYBBS5NrVhrXGs3vUYY0i5GEq/cLSEhgT6FeGYWOoiogm0AUIIY+fSblKlI8JFxP1dG9AG8EoGF5/FZ99y4sIzYjFHzibOz/upZiqR/CRsjRUWqNNDjGV1rLUKyhMbqEXAVRix6CiKjSVNcSUWO4VKKWopvO1XmGmY+U89q2szn+mDzweF0IIIYQQQgghhDgSW3ob1gUXXMB3vvMdtNZ84AMfOKiFio1+7Md+jA984AMopfjOd77Dc57znGNzokIIIQ7LQmXZMSiprUEBpc1t8rb1S7YPSrb1S5bqIrfWA2prpjuVJRS1GR3oei73y/xfr2B5ej17hWa5N7u2ipgiRisGpeHkxYoztvc5fbmmX1mUUviYGLaBURdQKleFGnd+v+cxqyQ1a9d3U7vSY0p0YRqkmgakemUO4s3CeGm2Oz/d+H6lzcEuAJXyc+58nD/2gVTW0J9WsZpsCGbFmPjEJz7BPe95T/76r/+asix505vexJ/92Z9JKEqIo0zmGkIIIY6XYZvDTo3fW9l0rXHsGXdcvWfCtasNV69M2LnesGfcMukC1692rE4cMSSMTgxqS2k0MSSsSVTWUE3bRZdWoVUu9RRjpDB5Y0KKuc2ed57xyrV8+s3PpxuusHi7O3Hvp76KwWBAbTV1aaiNprSKhdKyrV/SLy3VtM15GwKD0mC1xhhYqPIGBa3AaE1pdJ7D9UvO2N7nlMWKkxcqdgxKBpWVUJQQQgghhBBCCCGOqS0bjFpZWZkvNDzsYQ/jx3/8xw/rOD/+4z/Owx/+cFJKvP/972fPnj1H90SFEEIckcJolvsFJy9ULFSWwmiMzhV3jFYURrNQWU5eqFjuF9J6YZPb3/UsTL6ehdUolfAhsmNQ0SsNgzLvRD99uccPnDTgNtv6bOuVeaHH5naJ2/oFvTJXoOp8YDKt6tS4MG0hckOzDnuzX2+qWlTjAinldnp+2n5k1q5xdq99j7fv/fL7FYxROB9J07+/Ob3SoBT4mOh8JMTIb/72q3jIQx7CVVddxZ3vfGc+9alP8YxnPAN1E89BCHHoZK4hhBDieFmdOEZtDvQ3XWBllANPo2llqGtWJ+xpOlYmjpELDJtAigmloXWBPZOW9SYwaj0+JFofAEWKiRgVpITWCkOuaBpSovV5zB1jIqbE+uoe/u0tL6RZuY7+yWdwztN+l7K3gNWafmHZPsgbGRbrkh2Dim39km39goWeZaE0WKNxPuXKpyqPlXM11zxGnbWtrqxUhhJCCCGEEEIIIcTxt2VXjy+77DLatgXgoQ996BEd69xzzwWgbVsuu+yyIz43IYQQR5/WucXYjkHJyQuV7DLe4jZez9ss9zhpoeT0pR6lydeyDXvb1i3WBf3S3mT7ubow8/YcpFxdqTSacXvjANLsMLNfYzpw9aZun7Z75Ya2e7N77Xu8fe+nlZqffzPtd9LtJ7C1v+dVToN+V139fR733/8bL3/ZSwkh8PjHP55/+7d/4573vOfNHkcIcehkriGEEOJ4GLZ+HphfaxzrrcfHxKTzND5SWp0rpCZF5wNNF3Ib6YkjpkhdGGKE9cazOvGsTFpaH1EKQkyEmEP6Vmus3bvBBBITF1hrPcO1Vb7yzpfQXP9diqWTucdTX03qbyfMxqtasa1XsK1n80YUO93osFiyvVdRTTczgMJqlVufp0ic3r0q9HxjQb8yx/9FFkIIIYQQQgghxK3elg1GXXXVVfPb27dvP6JjbWw9893vfveIjiWEEEKIQ9Mrcms9a/IO9pRgdezy303b1t2cxoVcPay0WKNou0BdmHn7uY1mwaZZmG5/VaVmZnfd23Zvb/ppFn5S0+NszObte7/ZItD+2u7dlNJq/uUT/8TPPvSB/NM/fpRer8fb3/523v3ud7O4uHhwBxFCHDKZawghhDjWXIjzSlFrjZtvCggpUhW5MioJxm1g5Dwx5ipMVaEwRuNCrk7aBWi8Z9R2DBvPuIs4nwjT8WavzC2aC6MoDVijKZTCaI1rW776npczuvpr2P4Sd37C76CXTsFPx8fLvYKT+gUJhbWW3rSa61JdYI2iLDSV1bgQab1nddIRU6J1+cGrIrfOBhhMq8UKIYQQQgghhBBCHG/2RJ/A4RqPx/PbR7rAsHHhY+NxhRBCCHHkYsw70lsfidPgk1I5oFRZTa/IbfF2j1tqq9njAsPWs1BZthflzR6/84FJl3faLw8KJl1EaYWPuW3IxAUG1d4hz2zxpraG1kVaHxmktN+KVGlaTWrftnsxpXmgqjY59FRuWOjZ935GKRxpv233ZsdrXKDzkZjy/UMIvPF1v8PbLn4dKSV+6Efuytv+9//hx+97z5t9TYQQR0bmGkIIIY61HGLyrI1zpagEFFoRUh5XdjHgfZpWN005FGUNhUlU1rDe5jDVsOsICZrWY4zGR0/asA8yxEhZWBaUYb0B3wWCUhA93/6z32Z05eXoqs8P/uJv0zv1DGJMlCa3uS6swSc4aVBQaMVSXTDoFeikqApFaRTOT8f2VtH5hFGKmBKLtZ1XiuqV06CXEEIIIYQQQgghxAmwZbdq3fa2t53f/uAHP3hEx9p4/43HFUKIW5IYE6PWs3vUsXPYcv16y85hy+5Rx6j1N6qqI8SRciGyOnbsHLYMW48LkRDz4k6IOVg0bD07hy0uRsatpyr2ttfofKRx4YCt7mJKjDvPepN32peFpldYSpPDVrP2d62/YUWoWYWq0mqsVqTEPFi1LzUNQu3bdq9xgZTA6rxopGC+8LO/+4Xp/fZtu+dDZG3ipp/D3BolxMTV3/seT/r5n+Gtv/9aUkr8t1/4n/zp33yUO935LjfzqgshjgaZawghhDhWXIisjDq+vzph1OYNASEmrMrjVh8i1w0bdq61jFpPaTULVUGvMBitiSlvLqitpi40isSkDay3nrWJY+LTtBJVpLKGqiiwSqGVprSKfmWJMfKtP38ta1/7V5QtucsvvpLFM/4TRims1RTWYq0BFVmsLCcvVCz3S3qVZbEynLGjxx1PWeSU5ZrlnmWhMpRaow0s1QVLvWI+Nh5Udl41SgghhBBCCCGEEOJE2LLbtR74wAfOb3/xi1/kD/7gD/jVX/3VQz7OH/zBH/CFL3xhv8cVQohbAhci4zbQ+sCN4iUJAmnexqGyhn5lpMWBOGLD1s9bg8A05DRtazevGKUVtc2t8kJMND4Hp3qFpvGaQmsmXZi3ySunAaQ0PZ4LcV55qSw0i1VecFnuWULa28Zu32CV1orK5uBUrzCst55xF7Am//kNflZBmN6HkHAhodhboaoup9WirJ635tvf/cZtfg4b2+6Npo8740N+jT7x0Q/zWy/8VVb37KY/WOC5r3gtj3jUo9FlwerEsVAXsuNeiGNM5hpCCCGOhdkYedx6YoJx51ltPCmlPH6MucKTCxE7Hf+GlOhCpDAGcKw3Ha3RKAWty+PnECMk6ELAGo0xCk3+GU3CJwgxoZTCqMTVH3ozu7/0MZQ2/PDjX8apd747LgJK0y81i7WlV2iW+yXLdYlWCqVgobbUhaWymn5lCNFAyu2ilVYUWlNYDSlRy9xSCCGEEEIIIYQQm8SWXVU788wzefCDH8xll11GSonnPve5rK6u8uu//utYe/NPy3vPa17zGl72spfNqzo8+MEP5swzzzzGZy6EEMfPoYZTGh9ofG47JsELcbhWJ47G5cBP0wUmLuD3V5EsJFoXsVrRKwy9wrDaOEZtYKG0VIUmhISPic5Hun0qP0Gu2FSXZh5oqou8gLQ28QdsWwfQr3Iwqi4NXYy0LrI28fTLRK8085Z5pdW4EKitYdIFVsddDkEpRVno+eP2yhsGqva937jzLNbFvO1e5yIu5BNrfcivU9Ny6Rt+hz99+x8C8J9+5O4873feyOm3P4umC5RGMyjLXOEtJdl5L8QxJHMNIYQQR9vGMfJq4xk1jj2Nw/lIoRVdSCRyi72QEoMyh5kiiT0jx6RzrIxb9owchdUMakPrI42LtD7gYr5dpkRdmPm/Pz5FnI8kIIbEN/7h7VzzL38NSvEjj/t1Tjv7/pASVieMVlRlrvBUW83JCzW10Qw7T680LPdKlmpLf9oab9h6jFJ4lVtHl4VhUBoGlWW5L2NVIYQQQgghhBBCbA5betX7jW98I/e5z31wzhFj5KKLLuLtb387T3ziE/nJn/xJzj77bBYWFuY/PxwOufzyy/nwhz/MO9/5Tr797W+TpqulVVXxpje96UQ9FSGEOOoON5xSl0aCF+KwDVs/f9+tNY7W5TCTUlBZTWFyqCimXKms9REfU67a5DyLVcG4ye/XhTq35XA+0oRA2hDoU1pRG5N3pE/1p4sws8fft23dRoXRDCrLqPUs1QVr5HMdTz8r5axClYLOB1qfK6+5mBeVlvvFvEJVv7zxTvi6MNMqVHraPhBCSBRWM+lydTYFDNv8uN+/6kpe+bxf5t+/+FkAHvfkp/HU519IEzQxJbRSjBrP4jSwOOkCWikJMApxDMlcQwghxNGy7xh52Lg8RgyJlBI+MK8MNXEBFwIhJoadp9SGwiiunjiaLoJKrIw6hpNc/bfxEas1QUUUoJLCeYXRcTqOBB8SMUa+8/H3c9XH/gSAuzzq2Zxxn/9CSglFLndaGkXf6hxysnsrQC2bkkFlmI14rVFUhcHHPE7tYqTUmoXa0q8sVqpECSGEEEIIIYQQYhNRKe2vjsLW8cEPfpDHPe5xOOcA8hc6G1ZAq6qi1+sxmUxo23b+57OfSylRliV/8id/wqMe9ajjfv7iyHz5y1/m7LPPnv/+8ssv5653vesJPCMhNoeNlaIONpwy+9egKvQ8ECWVo8ShcCGye9QBN3zf9UtzgypMG8WUphWVAqsTh9aggHEbWKwL+qW5cQvIDRS5OlNvQzhpbeJofZy/lwuj2TEo93v/GwQIXW6Rt2+AcNh42mk4qnOBqjScNKgoraYuNIsHCBCuTRzrjWPnsGPc+bxzvi4IKbFYF/NQ1D996G/4vZc+l+H6GovLy/zm697ET/yXn2K9yZ/hfmVI0/Yni3Vxg8/ojkEp7UmEOIZkrnHrJnMNIcTRsL8x8vXrDSnBqHHkkWgCFKMu5D+LCWMUnU9ooIueq3Y1TFxkZTRhdRIwRrHcs6xOApPOEWKkdQmtwWhNaRQhJULIR7/603/L1//89QDc6aeeyp0f9osUJs8JY8rjcqt1rghVW07uV5yyVGGtpraaqrCklDh5oWKhstSlnrfyizGHpU5frtnWL1moLAOZRwohhBBCCCGEEGKT2PIraY961KP48Ic/zA/+4A/eYKEipbzrrmkaVlZWaJpm/mfAfKHiTne6Ex/5yEdkoUIIcYvhQtxvKKpfGnYMytzOqzDTUIdhsS7YMSjpT1uBtS6y1uQF4FHrceHG7cuE2J9xu7dC2ex9t9TLiyL7C0UBaKUYVJalnqU0mm56P6MVIUa29QsGZd4lb7RCq/xrYRSD6Xt6qVfMw0FxutMeoJ62uavsgYc7y71ivmhTF4btg5LlXg4fFUZhtWKxNpSF5pSFipOXKkqjWW8ckA644BOnY471xlPZHJ4qjWbnsIWUmDjP2nDMG17561x0wS8xXF/jHvc5h/f9w2Xc/9yHz0NRZaHpFZZ+aTl1qQLyZ3QW5pq95kKIY0PmGkIIIY7UvmPkcZdbPhut0FrhQ2LYBEaNZ+d6w8rIEVIOG8UQ2T3uuH6tI6TIqHV0AZROhJhYGztiCGgFIYIxKm+CmY6JZ1O5nV+6jK9/8PcB+IGHPIa7/8wTqKfVVsvCgFb4GAkx4mIOSJU2t42ubR4jW6UojZ5XYx1OQg7vh4Q1ikIrluoCBfQKs59XQgghhBBCCCGEEOLEuEVs33rQgx7E5ZdfziWXXMKll17Kl7/85Zv8+ZQSd73rXTn//PN5+tOfTlVVx+lMhRDi2DtQOKWyB/5yehZOsUaxNvE5eGFCbgfWBpb7Wz5HuyXEmJi4XJkoB2tylS+tFJXV9AqD1vsPGJ1oMSZan997k2lop1+am3zfbVRZw/ZBwcSFvLiiFZ2PTLrAYq+gf5DnMenyAo3VKrfC4+YXZhYqS2U14zbQ+kBp80LQRr3SM+7y31UmTheEFLtH3Q3a7qUEnY90IVdh65WGkBInVQVrTYdxii4kvnTFFfzuC3+Zb33lCgCe+MvP5pcu+HWSNky6/PqVhb5Bu75BZVHk85h0+fPZ+kCMdtO+L4S4JZC5hhBCiMO17xh5vXW5TZ1RrIwd1w9bmi7Q+IBSsDr2aAVxEkEpNIoY85wuxRy+N1rRtwYXE2OX202j8sYBFyIpKVAKRf43aedX/41/f++rIEVOu+9Pc8dHPJ0YobIKq/N4uXNxGnrSGKOorWbHQsmgzuNkqzVVTxFiIsW8GWc2HmU6DF3qlWitqOzmnbMIIYQQQgghhBDi1ukWEYyC3Mbiggsu4IILLuBb3/oWn/70p/mP//gPVlZWGI1GDAYDtm/fzl3uchfud7/7cdZZZ53oUxZCiKPuaIRT+mWS4MVx5kKch3Ju1DYuQSDNK4FV1tCvzKZrnzZx+dybLrDeOFxMKAWNi9NwF5QmVyk70HtpUFlKq2ldDiD5mFgZd5SFPqj3cOtzSz7IgSTgoBdmCqNZ7mtitPsNp23rl/SKfGyt1Q3a7rU+t6Pcl9WK05ZqXIg0LrJYFVTW8Ofvey//66Jfo5mM2bbjJF786jdyv584lwgwDXXVGz63daHnlal6pWHi8uN2PlJazcQFaVUixDEmcw0hhBCHYzZG7nyuyjucODqf+N7KmNXG40PezNL5SK/UFAYmXcIHUFrTtwZjFL6NdDGidG6PV1mDTtNxaIqkmIgxUZgcyp9tENj5jcv593e/ghQ8O85+MHd+5AWQEoXJASgX83hyUFlaF9BGsVDkNnkxJQqTq0BVhSYlxVrTMXGeNuRKV9ooFkpLVWi2DaaB/kqqRQkhhBBCCCGEEGJzuUWuop111lmyGCGEuFXa+MW7nwZTZgGRgyXBi+Nr2Pp560PI167xgRg3VIzSitrm9oeNzzvKB5VlYRNdk2HrWZs4do9aGhepCkNKkEjTcBe4EOZVl3rljcNdWimWa8t1LoCCqtC4EFmbePplolea/bbkiykx6faGoqoiB7Dg0BdmtM7V0wYHKPAyu151YagLc7PXC5i2rISrd67wW7/xa/zFn74HgHuc8wBe8b8u4eRTT0cpUFpRG0OxoVrVrFLUxteoNJp2+rilzbcPdL5CiKNP5hpCCCEO1iw8v3PY8NVrhoydI0boQqDzYV5taeQDoy4QSZAUS7XlpL6l9ZHOJdYmnuF0zlBohdYwKAo6n1vqdT4SE/gQ0UrhfWRy7bf4wh+9mOgatt35R7nLY16ENQZrNSFFthUVGNCASnkjQ1UY+pXFB9BojM7j8QSMO89a40hBURSKqtDzUNSpizWFyQGrzbaBQwghhBBCCCGEEGLzrKgKIYQ4YrMv3ptp1ajK6v0GSW6KBC+On9WJo3F7Wx/OAmk3EhKti1it6BWGujSMWk9MiaW6OM5nfWPD1rN71BFiXpjxIYEKxBjnYaGNoZ9ZhaV9Qz8A/crSaz0+RBZ7JROXF4DG09fnptrWQQ5FzV6TY7EwczBt92YUzCt8feXfr+AXfu7n+dpX/gOtNU94xvP5lef+Gv2q3O/9DhQeY/p3rY/E6Xslpv28Z4QQQgghxAkXU+L69ZYvXLXKepPb6K1NHMPG04U8dwshMZ54UAk1DSK13lOVeS43q4oaSAQXKQuDSonGBayGxcqyHjualFvpaQ1+91V89q0vxDcjtp15Nmf/4kVEa+lSokjgXAIFPWNY6hX4EBl2AY3i9KWaqjBsGxQ0LsznK5M24FKktoZ+mTdpLNSW5V7BoLL0SrOpNm4IIYQQQgghhBBCzMg3FkIIcQsyC0jMAhOHGwqR4MWxN2z9fJFhrXG0Li+MKJUDbYXJCyExpeniSK4Ctt56uhhZqgsmXUArdUIXIGbhrpQSrQvsGTu6EFnAwsb3X0h003BXXRiqwjDuAjElFjeEu5SCfmnnr82gLBhU5qDa1vVKM68UdSwXZm6u7Z5WispqeoVBKbj00kt59rOfTdM0nHb66fzuxW/jrj96f+rCYLTacL+bbzc4e42AeRhMPp5CCCGEEJvT9/ZM+N7KmEkbGLeRlVFDF3KLusIoXMhVfotCsz5xuBjymLC2XL1ngp22qvMhMmw9IQaqmDBGUxdMdyBAWVpCF1Bo/Pr1fP7SX6dbX2HbGXfigb/yu7iiR9NFQkr4kDcoKBT9ylAVmlEbGJSG07f1MFqxXBWctFjhfW71FxJ0NtDXJdsHBf3KstSzbO+X02qrm6uarRBCCCGEEEIIIcRGt9hvLSaTCd///vdZWVlhPB5T1zX3ve99T/RpCSHEMbVvUOJQq0XNSPDi2HIhztvnbQxF9Uuz33ZxdWEYbGgX17rIGo6lumDU+nmQ6njbGO4adp5JG4jTkE9pcysNjSKSw12zFo/DabhrsSpoXEQrP68cNXuvLda52lPr4yG1rQOO28LMxrZ7MaYbhKTGXeC6XSu84IJn8efvfx8A5573MH7/zW+jGGzDhcRibedBrkMxe41mb5PD/JgLIY6AzDWEEELcnGvXGlaGLesTz55Jy871Dh8ThVbsGJQs1hYfYWXcUrSa1gWCz63R1yYOqzUpJXbTMXGBUefRCqxJaBK9oqBX5o0KyitSjIRmjc9f+us0K9cyOOUMHvis17G4vI0uRAodcT63vO6Xlp7VpKQgwUmLJYXVLFYWrRXb+iVWaxb6eUw9cYFeabBKsdQrKK3h9KWapbqkX+2/yqkQQgghhBBCCCHEZnGLCkZ985vf5JJLLuEjH/kIX/7ylwkhzP/uTne6E1/5yldu8PNt23LxxReTUsIYw/Oe9zyUrC4KIbYwpYC0NyhxuJWeJHhxbI3bve3zZqGopZ6lsgcOyWiVQzjWKNYmntZFGhOoC8O4DSz3j+9ihAuR9SZXi9o16ti13uJCIpHQ5PferOoV5JZysUyMO8/q2LPeeFYnjkFh2DPOiy+D0sxbimwMHdXWHFLbuuO5MONCnLfV2/hp+8LnPsvTn/w/+fa3vokxht942St40i8/O1fKcgFCDosdTjCq83tfIzj8AKQQ4tDIXEMIIcTBGnee69db2hC5bjhh3Hg6H+kVhjNOqlnu7e1T7n2kNBGlIjtHjkkXaGPC+cDEB3yIGAWzid6sqm8XA1ZpSq0oe5bYjfnXS1/M6NorqbedwgOf+b/oLe0ApaiM2VCNdlqFNSaWjCIm2FZZ+pXFGs2Ofsnpy3UefxtD4yIhJiqj2T4oWe4VbOuXnLZU32SVUyGEEEIIIYQQQojN4hYRjBoOhzz3uc/lHe94B2m6mp/2CQPs+3uAqqr4u7/7Oy677DIA7n73u3Peeecd+xMWQohjRCtFIOUvqDcEL2JMNC7QhUhM3GzrLgleHDsxJlqfF9Mn02pL/dLcZChqo8oa+mWuSDTpcjCq9YEY7XFbmHAhcs2ehrXW0XSBUevRStEvNUop1hvH6tgB+f2lFDgfGbu8S72LkUkbKYxCDXLwab1xxJRYHTusUQzKGoCFaWuOg2lbd6TPf9+qTzf3GMPWzyt/Qf7cTJznnW+7hN975UtxznHbM27Pmy59J/e///0Zt56VsaOYHqP1kUFKh/T5iilNP8eJGBN7xh29whBiOuqvhxAik7mGEEKIQ7VrvSPGxHDiGDeRmBSDalap6YZfxVWFJgFWW7b3FaUJ7E4toyaSUsL7SJfy3E3lAk8ADJtIZRMK8F3Lv77txaxf9VWKwTL3+5XXsnzqbahLS11oNIqVcUdpNTEBCoZNx3LPYq1mobYsVgU+plz1VSuWeiUpJfqVZcdCSVVolqYtsHcMShlrCiGEEEIIIYQQYsvY8sGo73//+zzkIQ/h61//+n4XJJRS+/3zmV/+5V/mn/7pn1BK8Sd/8ieyWCGE2NIqq3MYyhpaFxm2nhATPiRu9H/CBAFwIbdnK62mVxqMVvOqPfU0rFMdoEqPOHQTlysLzdrKKQW98tCqBvVKw8QFfEx0PlJazcSFeTu6Y2nYetYnjrXGkYD1xjF2kUIrGhdQQOcDJNg9BGMUky6Hh2bVkVICFwNrk8Ceccf2Qcmg0IRQTQM/MOoCKMUpC3k3/cYKUkfbgao+5ZOFMG0FmNsW5qpU4y7M2wg2XWDiArt27eZlL3gW/+9DfwvAuT/5CF752jeyvH07K6OOymgU4GKidYGqMEy6Q7tu6xPH+sQTUkL3ChRQ1DpXhzvAuUprEyEOn8w1hBBCHKquC1y33rA6dly/3rB73JAi0+qqgd3jjsW6wBqdNwqgKAtNvzQoB40LVNbgbCQkhTUanyJKKSI5jGvVrDqwwqbEx956Idd99fPYus8Dn/laFm9zJjEmaqsx0ypThVFEFEZpQh464kIiJlifBLb3S7b3C0JK7Fxvp3MUxbZ+Qa8081DUoLIyvhRCCCGEEEIIIcSWsqWDUW3bct555/G1r31t3pbih3/4h3niE5/I/e53P0499VTuete73mTLikc84hGUZYlzjo985CPH69SFEOKY6BWGUesprabzudVZV0b6pcX5SBMCKe6thKO0ojaGwurcTsFH8lfkCqsVpc1Bjt5htPsS+9dOq3E106pRldWHXJFLK0Vp8jVrpi3mWh+PSWhoo9VJbp3XuEDjA2sTx+rE5XBXUeBCDtW1PrFn0mFQVKUGFM5HUnLzNnsocCkSomK98aw1iV1jx45+yUmDEgAfIsPOzxdhjoX9VX1qfCBu+JxoraitobSaxgd2jVogLwqtNY7WRT7/mU/zwmc8he9/7yrKsuQlr3gVT3jq0/ExtyrxMeFjwPlIMQ0ajqeBMWvUQVUMWxm1XLuWH3uhtvgQSYkcUjvAuTY+B68WjkNoTohbGplrCCGEOBSzsP339ozZM+n43p4xK42nC4leoYnTn1kZd8QI/crQaYVzEWUUxmjwgcJolirD6qhDpVwNuDYWYq48VReGXmUZtwGjEp94+2/yvS/+M7ooud/TfpdTz/phQkyklP9rXR6LajS9UlFpg9GQlEIZqIzGGAgJjNGsTfIGCGs0tVUURs3H473SyLhSCCGEEEIIIYQQW86W/jbjNa95DVdccQVKKbTWvO51r+PZz372IR1jYWGB+93vfnz84x/n6quv5sorr+QHfuAHjtEZCyHEsaV1DlhcN2yY1YhaHTtGjd9/q4OQ6FzE6vwF+6wNWlVobrPcA3LrNmmTcPTEaWWRGPOvh7vbehaGmh0n3kTFkqNh2Pp5haTd445h4xlPK0QtVJalXsFCZbl6dYLRObi1MmoZr0aqwlAYRUiJ0mjKQlMojUIRQ2KCxyqN8z4vEMXEeuvY3u8z6QJaqWOyADMLesHeqk8+7ud1DHlByWpFoRWTabhtbeLQCt7x5ov5g9f8JiEEzvrBO/KWd7ybu9/zXjlc5QJawdgFxm0gxIgLiW2DAh8jPkTWJp5+meiVZr8huZgS16+1rIw7ABKJpsvnutwrcCHt91x7haEuc1gypnRMA2ZC3BLJXEMIIW6dDrW9MuRx4a5RS+cj37h+yM71ju/sHuXxn4sMHSidiCkRgiamlsZbFqdt65ouYLWi8XH6eIq61PgWSpPQ5D56LkKYttdLKfHpP34D3/iXD6G04QFP/U1O/6F70U17p+eKrh6FAaUoS03PGKpC0SssRaHz8yktC3VBrzB5DFkaXEyURrHcL+fjUwnbCyGEEEIIIYQQYqvast9oxBi5+OKL579/05vexNOe9rTDOtY97nEPPv7xjwNwxRVXyGKFEGJLi+RgRGUNe6JjNK1K0ysNi7XNQScUcdpyq/ORLkTW29yea6HM/zSEaUCkX0m1qKNpll+a/Xqo1aJmZnfb93jHwqw1G+TqRJMuh4lqo9GFYalXUFnDuMvt21LK759dw5ZIYrXpsAYWywKrYbGyKKXwTWTdB4xTLPU123olC1XBxAV6pWHsAktGT9vC6aPasmNj0GtW9Qny6zp7LK0UMeXPyazq0+5hRxtyy73vXX0Nv/+y5/CZf/4YAD/zqJ/jdW94I/3FRdYmjs7HeWu+yhoUOXgYUmTP2FFZzVpwLNUF4y63WSyNzpXaVL6mnY/smXSM23yuPiasVviY6JeGhdoe8FzXW08XI0t1cUwDZkLcEslcQwghbn0Op70ywDWrzbyC5+5hyzV7Jkx8YGXYMeoCMYGPfl5hUKtASgYfYNR5BoVFWxi3kZVRS4w5aNU5T0JRWIg+4VJCK/BBsTrxfO3v/4iv/OMHQCnu9+QLOf1uDyBFSDESYsIUhjYkFkpFr7RsHxRoFKct1xRG4UOi8YGFyrJc500OdWnoV5Zh47E6Vw8ujGbHoJT2eUIIIYQQQgghhNiytuzq2Cc/+Ul27dqFUop73vOeh71QAXDWWWfNb1955ZVH4/SEEOKEmAWd+qXh2vVm2g7PoBWURuMDaBKFBYWiMJoYYdLtrZzjbeKkqmDcBbbLF+BHnVJA2htsOtxKT7O7zY5zmPmquZvaGd+6AAo6F2ld3sW+WBdMOj9ty6HwITLpAr3CTNvTORangak9k46UcjsObTSTLtKvDJXVtE6TEhitpi35zN5WgS7SmEBdGMZtYLl/dN6L+wa9ZqGofmn2W7WpLgylD+watuwcNkTgc5/6BH9w4QWs7LyOqqp58W++hv/+uP/Jqgvs2j3OO+6NvlELSx8iISWCz9WzlFK4mF/z0poNLS0zP12gy2GoXAkKYPug4JTFer/nOkiJSRcYd4HWRdbI4atjETAT4pZK5hpCCHHrcrjtlXNr5Dweu3rPmGvXWq5Zb1kdt+wad5AS5bQSk1KK1kW0gcZHTEgUhabtOnxKKBKr447WBRqXiCQUENF4Fwkp0i8LtEp85aPv5av/8C4A7vGY53LGvR9KSqA1BJ/nGIlEqQ1lodHkceXpy3229QqMyW3T3XTcGVPC6ByW6pe52mtdGHYMSqyR8aMQQgghhBBCCCG2ti0bjPrKV74yv/2zP/uzR3Ss5eXl+e21tbUjOpYQQpxIs6oyRinU9Av605cqEsxbb7U+sOE7f2Aa/LB6Xo2m9YFtvTK3bBBHlVaKQMrtN0LedV4Xh16Vq5suYszaeBxu5amb2xnvYmT3qAMF49ZTGE2/mi4IufxjkYRz+d6tj+jpwlFPawwKKAnTxRY7TYYZpagKwzalpqGovBBjtGJbvyTE3CZw97CjX+UqVI0PGK1uso3JwZh9TpppcAhgqZerqe3PqPWMu4APuZrUpRf/Hh94+8WkGLn9D96Zl77uEu5297uxZ9wx68Q3bP00fHjD89Na4dtcSWrcBazJLe/KwuTXx6gbLMB1IbfAiySGTT74aUs12wflAZ+fVopBZbFGsTbxxyxgJsQtmcw1hBDi1uNw2iu7mAghsjpxKJXHflfuGjGcBNbGHSECJHwC5XPVKIUClVhvI4XJLdAb71GAUppRF+hcYuwCPkRcAJUSqVNorUgxUerAdz/193z1ry4B4Acf/hROO+dncDFSFZbKKmKEkKbzQa2ICfo9w2mLNacvV9SFwajc5rou8zi7LjTb+iVGK/plHpcWJj/ukW7AEEIIIYQQQgghhDjRtmww6vrrr5/fvsMd7nBEx0rHsv+QEEIcJ3EaeoLckmuhsixUhtkO5soafMg7n1PMu4K1UigNtc3VbcadZ9IFFLBQW1ofiNEeVvjk1u5AFZiaLuBinFdEan1kML0WB33slOjyagv1NMxT2UMPuxzMzvjW7T3/cRdQKjCYtg1R03BX63NoaHYM53P7NgWsjB2lVSSVY3bVNABUWIUPimSgsJrKaAqd43w+RMadx/kEKp/H7P3ZL+1+25gc7C72fT8nkCtFHSgUtbGi1Le/811+8wW/wpf+7ZMAPPCnf55nveS36PUHrIw6Oh+xKld2mq0gVVbPK6/NWliGlBi1nkQOMY5bT780hJiorGapX+RzTQk/vRZr447Sak4alCz3DxyK2qiyhn6ZGHeBSZeDUfKZFuLgyFxDCCFuefY3Ph93ub1yaXSuvhvy/7Nvqr3yrLW0D4k2BNbHjitXRoyaQFlonIdJ8IQAjQu0KLTJY9x+ZalsDkGtTTx1aSi0JiSfN7KEhPOJSZfb4SUFBjDGUBnFVZ/7GJf/2esAuMODfp47/OfHQUrElNvAEi39yjDxAZUUVuf/eqVhx2KV5x6lmVetLY2m9ZFC57H0rJUzHPkGDCGEEEIIIYQQQojNYssGowaDwfz2aDQ6omPt3Llzfvukk046omMJIcSJMnG54k/nIz4mlIIdg4oYczCiCxFrNAsHCJAoBcu9gspqjNZ0PlJazcQFBtWW/efiuLu5CkxGK1YnuTXdpMsVmCbdob3Gky7k1nQ6t8BQ5BZ0h+Jgd8YPW4cLicYHFIqlniXGXEWpNobORYZNfh4xgY/5/dcrDU0X6ZWGBW1xPs4fozCKEHJ4qLaaHYMKaxTOR9ZbT+NirpxEIgbYNeroFZpRq9nWjzdqY9L4/PotHMRruL/PSa88cKWoWSjqIx/+B17+vGewtmc3dX/A4577Cv7Lf3002wYVKSUaF9BasdZ63PSzdtKgpLJ6WuFq72Ns75cYlXfvKwUuJsadx2jFsHEs9QoKowlpb/WthTq3PFnsFYd0nXulmb/u8pkW4uDJXEMIIW45DjQ+9yGy3uRNAivjhm46Bs0tnw0uJDofpu2lc4hoUBpGrSemxPdXxzQ+snO1YU/j2N4vGXUeH0MOzBtF8kCMxJSro+4ZObTK5+RjpPVhOjaGLkR0yn+nNPNWzEnniqsrX/8Ml//JqyBFbne/n+aOj3g6IUFIuUWzVnn8vFgX+Elud72jn8eVS1WBC5F+aemmVVqt1liT531VMQ1GkebhsCPZgCGEEEIIIYQQQgixmWzZVbHTTjttfvvLX/7yER3rM5/5zPz2GWeccUTHEkKIE6Wd7uxtptVwZoEMbRRLPU2chjc6H4kpV7BQSuUv+a2mLgxaKdYmjnZaOai0eQfxoDqRz2zruKkKTCHkYEog0bpAiHnRY9J51iYFdzipT6+8+X+WWx8Yd/kazwI9lT20lnLD1s9DURsrIu1vZ3wO1QS8j7iYqKxie79iz7gjkfAht9rTOrftcCHgfG4x4mM+bml0fj9qhVWaQW1wIVIYjVV7w11eKZrOE2yiRDNuA4lEoTVWK2KKuLz6M29j0isM9YYFqqX6poNDB/qc7MuFyLgLOOd43e+8kve89Q8A+MEfuisv+N03s3zaHShNfo1IitJorM0hN4BS5/YkWikmXa5CYKehRIUipbwYZ4xi3OUFsYXaslBPF696BXvGHSElJs6jUfStOeQd+1qpeSUA+UwLcfBkriGEELcMw9azPt0Q0E0rPjUuEFNi1AZUAqX3huYrq3Eh0SsT/dnYPEEgj3OHjSMBw8axMnEMx4H11qOU4tpRS9fmVs1pOm62TtHFhA4JrfJY3vu8QSBMq1ARc2vtmB8KbSDFXGFVkcdyw6v+ncvf9XJS8Nz+3v+ZH338rxGSpou5kuy485w8HeB13lNbQ201y4MKoxTW5sqshVGMOs9CZamKHIoqjMZMx6mdDxTGHNEGDCGEEEIIIYQQQojNZssGo+573/vOb//VX/0Vb3jDGyjLg2sts9H6+jof+tCHALDW8sAHPvConaMQQhxPs3YIcVr1Z9/WYlop+qXl5rpwzYITs+NEaQF0UA5UgcmHXCnJ+TjfoR6mVbxKq1FasXvcMe48t9nWY/ug3G9bt5gSk25vKKoqcpgNoF8d/GLFrAUd3DAU1S8NvfLGwZtBmdt9dC7gOo8PsNZ2tCGyMu4ojcaHRPBxHrYDReMj4+kiUW01Wu3dhe5DpHF5Eaaahrt8SrOuj4wbj7OaGBPG5EWhhdpitWaxtvM2Jj4m1ltPF3PrvkkX0ErdZOWom/uczEy6wNVXfYcX/MpT+NLn/o3/n703j7fsqsu8v2vae5/h3ltVCSFhHmWKDCptkEYREAcG8VVoBO1m9m0nFHBgEARkaLoBwVcU0FeZBERBjQp2C3waBLr1BTGEBpQxQEKGqjudc/awpvePtc+ue6vuTaqSSiqVrK8Wdc+5Z++z9nBSa53f83segB99wpP52V/7Tbqoqa1LkSU+4olIwNpU1JoWGhcj1gU6lWITa+tZ6d9r0Tm2GouR6RoaFZj313a10kiRhIutC0ghUvyij0Mn/8mSP9OZzMmT1xqZTCZz5nN41nKkjztunE9RdTvmQ0uR0+FZS+ciByaasycVPkSumrUYZRkbhRApQrpQks4nh9PLNhq8i2x3HfPW4UOg9QEiVJXBeDG4UVnnCZFBfOQiECPe93F5wKJvppBCDm5RUsrkmvqtL3PRHz4P3zWce89/x/f/zIsRylDbgHIOEETAhuTW2tnA6qigMhLnAtOxYVJofIxsN8mlVIjkPrsIgWmpkxOsS+Mx6to3YGQymUwmk8lkMplMJpPJ3Bg5Y4VRd7jDHbj73e/O5z//eS677DJe/vKX85u/+ZsnvZ9XvepVbG9vI4TgQQ96ENPp9NQP9gwixsiXvvQlLr74Yr7+9a+ztbXFeDzm0KFD3Oc+9+Hbv/3bUSp3C2YyN0aWWofl3yfrLLNkudmx+8vsz34OTHXn8PGoI1drPbPO0VpPYz2bi0BZSAolaVzgss2GzdqxNtIcGBcIkc5/5wKdD8O1KI0cnJEmpd5X3LMXi/aoeGs5ztWR3lOMBfTRISlSJAIL69huUzd9hBTRFgJN51m0Hq2S2KhCJVekGNhqHJVJrmUuRHyMKCEwOh277wtUAlh0qShktKTQikmpqHSKM1FSUBlFZRSTHUKx1ga2sKxWhnnrBtervTiRz0kIkff/9V/xgmf/HNubm0xWVnnBK1/Hgx7+SJwPuC7FCtqQimxaSbr+mIQQTCo9uBG0nacYSWwvTFpYx1ZtgXRutmtLIBXEYoTGSrQSvdAu9M4CASUFTReYKce4VCfk/rbzGu517JlMZn/yWiOTyWTObC7farhyuwVSNPS88TTeQ0xupKEX5bdtEqAHItu1ZdF6qkIzKY4KhUZGgY9sLRzbjaXzSaC/2XTMG0fjksspEUqjWDGSef8YGGKchQ1JPO89zoOPgeADSkpiSA5SLji0BKUUhRTY9cv49Jt/DVvPOPvO9+Z7fubldEEhZaDUgpWypLae9UXHVu36xoxIoRxr1QgpU5T3vPUgIoWC1cpQyCScL7WiUDLNazvPgXFxrRswMplMJpPJZDKZTCaTyWRurJyxwiiAX/mVX+GpT30qAL/1W7/F2toav/zLv3zC27/zne/kFa94xfD413/910/5GM8Etre3ufDCC/mrv/orPvShD3HllVfu+9qDBw/y5Cc/mec85zmcd955N+AoM5nMNSEEEI+KIK6tK8xys+V+rqW+6mbDfg5MPgbKXqDSWs+iS4UKIyWqECgp6XzHvPV0MlIWknnrMEqwsUgRdtNydyycloJRoYZCxahQV+uOdCwhRNo+Qq7uhVzjQu0rigKQIkWHCCmwPmB9cjFadI4YYauPtBNC4EPE9m5Y8zaAiCT/qFSQCiEyKQ26UBRGMl3GkwhQQlA3DusDWgimpcGH9F692RQ7m9WlEExKjVaCrdrR2kCjPJVRLFrP2nhvYdQ1fU7atuWFz/t13vIHvw/APe59P170mjdyj7vdldYGnA+UWjJvU/SJQKB71yylxRBDWGqZolJiKk5pJdhYtPh4NKavUIKoJONi6RIFxggmhYYIUorkONY5hJRURnLldkDNOT52McYh4mXRR/eNC4VWMn+mM5lrSV5rZDKZzJnJVbN2EEUd3m7YbhwuRiqjhvn5dmOpO89GneaoUgIIFr3ra6kFa6MCKQSVSQ0BG3XHvHPUredI3faNCwJrA2WhCCLN+2atTzF5wdNZT6E11lta67EhEgK4kOaRAM1S7B5SrJ8AtI742WE+/cbn0G6vs3abu/CQX3gVphrR+QBeIlWa08t+Lt06T2NhXGgiaV/OR6yPaBXobKSoJEYJZq2jMhqjRHIW7Zs5RqW61g0YmUwmk8lkMplMJpPJZDI3Vs7obzie9KQncf/7358YIyEEnvOc5/Dv//2/573vfS/z+Xzf7T71qU/xH//jf+Snf/qnCSEghOCRj3wkD3vYw27A0d842N7e5pxzzuGJT3wi7373u69WFAWwvr7Oa17zGs4//3ze97733UCjzGQyJ8LSIWYZdWB9uFb76VzYtZ9r6zx1c2EvByYtBUokgcx2a5m1SRQlRO/2NDLccqXijmdPWKk0LgaCj6hefFQaSQzpWhglKI1kbWQ4OCkGUdSk1EPR4kSprR861pfjWcZk7EfRF0Oih84HhIB565m1HiEEWgkEgrMmBbdYLRgbhVYCT6Bzns3acuV2Q9N5Oh8RIjIuFGujNPZCC3R/r816gVlVKpRMBaPlGOrOU3eeI/NuiEXZWHT4EKn6iLm6jxls+yiSvbi6z8lXvvQlHvUD3z+Iop7wtJ/j9W//K25/xzsmsZOR6ZilIPabLbePcRnNd/Rzo1OFjcZ7fEjRJa1LsXkhRLSSjIzinNWSg5OCQku0EJRaMS41hyYmXR8p2Ko7vrFe07okfGqsY9ZatuqOzUXHVt0xay2udxZrXWB9YZm3Ln+mM5lrSV5rXH989rOf5Z3vfCevfvWr+e3f/m3e85738JWvfOV0DyuTydwEmLWO9XkHwFWzhvXa4mJkWmoOjA2rI5Mck7RMYiQi8zbFYPsIB0clhU6id0jz+hBhWhoKJVPEtA/MG0fbBoyGejm/Iw6Rz+vzjs5BEBLrPEqA9xHnYnJLjZHkUwWBJJCP0IvjFbqb8y9v/lXqI5czPec2fO/Pv5pOTZIQPkQWnWPRehofsCE1WSzXEgLwREKEs6clo14sPy4VPkbWFx3bjSMSiSK5vWopOGelHNYXJ9uAkclkMplMJpPJZDKZTCZzY+aM/pZDCMGFF17IAx7wgOGL9E984hM89rGPRUrJ7W53u+G13/jGN7jXve7FpZdeytbWFnC0iHmPe9yDt7/97Tf8AdwI8N7TNM2u5+50pzvxfd/3fdztbnfj7LPPpmkaPvOZz/Dnf/7nXHXVVQAcOXKExz72sbznPe/hx37sx07H0DOZzDGUWmJ9oNKK1qYv5CcxnpQIIsSYOpCBqncRKvUZraE9aUJIbk2pczoS49E4uVInIctSYLKXA1OhBF1fSNluLV0vllo6Pe28HkanAsZ2bZl1DhC0NuBjZG1UALs7tQX0ohl1rbq3214g0/RjLrW8xvujMoqt2mJDcnLaajyt931sHJy3WrFoPTYEVmWBkik2rvUeayPOWVrnCFFwi5WCymiUFBRKMioUQkDnfCoi9YWc1dLQutRF39okwIJIaYohdm+nQ9KyoFVpSecChZbU1jPZo5iz3+fkL//8T/mVX/oFZtvbHDh4iJf99u9z3+95MNbH4VxLkcZdWze4WIXeAUqr40VHRf9ehEjTv5e36VjHRjEtDdNSo6UkBL88rOHvkVH4AkbKcZVLrgRFLRBCMmvd8cUqH2l7B6+qdwJbxjyOC32z/UxnMteWvNY49fzZn/0ZL33pS7nooov2/P33fM/38LKXvYwHP/jBN+zAMpnMTQLrwxB1t91aZk2aXx0cFxycFLvmaSEk59S6k0jpESIJ3IWEkVK0LjBrLYfGJdYFnAs4n1ynpAQfwBNobcRHiN4jo2TW+T7y2KOlApHG5UMECUYIWhuJCGRM/9ZoEQgyCaNEBNfMufjtz2NxxSVUa2fzwJ97DWZ6cNhX7KOptYhUWmEEFFWJc8m1FgmV1qlZQwlGJsUC1tZjtEy/U8l9daVKc8TVkRnmzpNSZ1FUJpPJZDKZTCaTyWQymZsUZ/w3Heeccw4f+9jH+Kmf+ik+9KEPIYQgxoj3nq985St9MTVF43z+858fChRLHvawh/Gud72LlZWV0zH8Gw2rq6s85SlP4clPfjL3vve993zNa17zGn7pl36JN7/5zUASVT31qU/lQQ96EGefffYNOdxMJrMHI6OYty65zkiBC5G621scsh9154kxdUYXWiL6/d4csD6waD2tS65Ku4ip63oZm7cUJ3UuHOfAtNy2tX4QRa1UmmKfuLrKKBobOKAkhRFsLTxNF5iYJPDpXGBc6ONEWdeGZWzc0k3pRMRVUgp8v50AbEjuVqNSUqok9FoZ6eF+a7sAOm03LQVKCi7fDsSYzo8AtJAcHBdoJdmqU0f/VmOTGKgX7WwuOoyWrFSGGCNSwKJzhLBDrCYFlV7GxUU2a4uQcO7qKAmeyuOP59jPyfZ8zkt+7Zn86dvfAsAF3/NAXva6N3POebdic5HGJjl6zisj2agDSgqUgHkXWLQdpZYYneYg40IPnx/6c9Y6T+eS8MtIycrIYJQY3K6W983OuLvKKK6atSglmBjFVfMO6wJnTUukSMK6pbgtxBSTsrwXZ43DmhRFWHe+/0yXN6vPdCZzKshrjVOD956nPe1p/PEf//HVvu7jH/84D33oQ3n+85/PS17ykhtmcJlM5ibDok2ipKbzLFqPC4FpqY8XRcWI6+fDPjBEPC9jjHXvErpoA6tlikTeaiyQoukkAikhukjoXQW3a0dtBJ2Drksi+tY7QtLIpyjnKAgxALEXYiVnqiBBRvARpG+55N0vYfbNf6WYrvHAn3st5cFbYn3EhzQHNSq5lyoEI6PpepH+SqWIUXNwajBSUvZzvkXnICan1wOjgoMjw7jSnLNSAWl+Oy31dWrAyGQymUwmk8lkMplMJpO5MXOT+Lbj3HPP5X/8j//BH//xH/Pt3/7tu34XY9z1Z8ld73pX/vAP/5APfOADHDp06IYe8o0GrTXPfe5z+cpXvsJrX/vafUVRAOPxmDe96U084QlPGJ5bX1/nDW94ww0x1Ewmcw1ImSK44KjwYdH5wdHomlhGdMHReLVSXzchzpnCrHUcmXc07mjU3FZj2Vh0rPeRbVuNHYRQjUuRbkf6mI6lA5ORYojdaOzRc7mfKAqOuhABCAQHJ4bKJHeps6Zliv3oO7iv67XY6Ua0fO9rIsQ4vG8UAj1EiERq6wgxDmKbaak5e6Wg0hIlktBOSsG00JRG4n0cYjwG1624FKUlhy6lBFfOWlxIwqAYYbtx2N4NyfpUyFo+3qwtm4tu+Dd+3jhmjRtEYMey83PyjS//K0945EP507e/BSEEv/yrz+XPLvwA59361sBRkVLYIZXrXBLHzRpH2TsGSJHET1uN5cjMslnbPu6vZbuxrM87GpuKc1IIJlUvdOtjTZb7BRBD3N3uop1SAhcCC5scslaqJKwqdSpelVoNETHLz++scVw1S/doBJwPN5vPdCZzKslrjevOL//yL+8SRY3HY57+9Kfzu7/7u7z2ta/l8Y9/PMak+KYQAi996Ut57Wtfe5pGm8lkzkSWTq6dCzS9+2tlFNPKHDfnTfHXaZ61nMsWveAcwLqIFgIfAo1NUc/z3sW09QEXA6WSRATz1rLoLNZ5vI9Y5+h8aqhwftmYENEakoFUP6+OaV4qAEkSuqvg+Mb7XsX2Vy9ClWMu+L9fxcqtbo9AIAXQzw9jPze1IeJ8oNISLVP09qFpycFRyW0Ojbn92WPOGpccGBdMqnQuVivNgUnB2sigpGBtZDhvbcTZ05K1scmiqEwmk8lkMplMJpPJZDI3SUQ8tq35JsBnP/tZPvrRj/Iv//IvHD58mI2NDcbjMWeffTZ3v/vd+f7v/36+4zu+Y+jwzpwcl156Kbe5zW2G4s/9739//vEf//G0jOWzn/0s559//vD44osv5l73utdpGUsmc2PA+jCIdbYa23/pn2IiRoXaUwgTYnL6WYqiSiNZrVJx8tCkuEl8OX518XhL4ZgUgqbz1NYPYpS90DLFUVSF4si8wyiB74U6WoCLYHthlRBwYFxcowCpdZ5Z4yiUZFJpthvL2igVLAqdOrhPxvlrP66atfgQ2Vh0WB9TdMY1uActOse89WzVHVdstwiSe9Z27dBCMh2lyLaDY8N244jA5sKysI6mv6eqQrHoUoTcwVHBysiwVhkmleKKrZZ569hcOByBlVLjQ+TQ2KCUonOeyqjBhckocZxDUoyp+NT5yFqlWRsXTEvNHc6e7HlMnfP87hv/gOf/yi9T1zVnn3NLXvH6N/GQhzyEUdFHB/o4RCGWRjIuNOvzjvXeRcqFCBG2WksIgc4GZo1HKMHBkcFoSd16bEwuUQdGBQLBpEpCubMmxXBNQ0zXJEZYrdK2k0LhQmTeOq7Ybll0jqvmLUQYF5pDk4JpqTgwPt4WK8TIVm25atYCcHBsOGtaUWrJHc6e3CQ+05nM6SSvNU6Ov/mbv+GRj3zk8Pie97wnH/jAB7jtbW+763X/8i//wo/8yI9w6aWXAiCl5NOf/vRxYrQbkrzWyGTOHOatY9Y6Lt9sWF90zFrHuEgRceUxTQqbtWXWWA7PO+rOYV1kVComZZqzxpgcPm3vOHX2tGTWOrSUXL614Mi8Y955vnbFjMtnzRCZHEKK1fMhuZ0aJTBaIkki9XnrcD7S9c0YWkqEFDjviSFwyV+8ho3PfBipC+7ztFdwq3t8Z3KnUoLgkxyq0P3eIhRGsVIpVooCrQSBiBKwMio4b7XiFisVRks2Fh3ORw6MDKvjgkMTw60PjJlWOs8LM5lMJpPJZDKZTCaTydwsOOOj9PbiXve6V/7C+nrkVre6Ffe4xz34P//n/wDwpS996TSPKJPJLDFKMik189axWhm2SOKoRS/4KZRMEV8idSl3LtD5MDgI7RRFTcoz/4vya4rH22oti84jRBInSZIjkhCkaDS1M6YsFTxciGy3ji4kQU5jkzin0BIbIkIIGp8EQUUfc3ZNLDvHQ4xIITAynffGeQotj4uFuzqh19VF7kkh8PQOUH0n+zUJo5ZORlKmwo6IYBD4Ir1vjClSpLHp3DTWo5VAe8m4EL3bksAIiTEpSq9znsu3PFUj2a5diuqTkVJIOh+4xaRASMl23SGFZFIKIqkj3vnk4LT02Iox0LnIVmtxLqIkrI0LapuEWMfew9vb2/zn//yfecc73gHA933/Q3nF69/IysGzh8+J9wEbIjIKOhdYdI7D8xbrjkYKVkoy6xyVVjgvMErhYqR1kVlrKb3C+YDRCiNFcqrqx7Ja7Ra6NfZohKXpI/gKLVnUFq0ky0t5y5WKrcYRQ9rG+YCScojtW7qd2f4zXRmFjxHd309aSVQWamQy15m81jhxQgg897nPHR6Px2MuvPDC40RRAPe5z314z3vew4Me9CBCCIQQeN7znseFF154Qw45k8mcobT9nHVwcu3F9HvNxWOMFFqm+ZeSSJHmeM5HlJC4GLAx7W85F44hUhSC1qb5/nZtWThP61O8Hb3TZyQODk/L+biUgkgSfIbeWSoIiNEjPEQEl37gjWx85sMgFXd+/PM5eOf74ENE9Dqo1nmUFMQgCBGUgkIKlFS9yygoKThntWKkFQcnBUan+Dzre1csoxiZFGl9cFJcvxckk8lkMplMJpPJZDKZTOZGxE1SGJW5/plOp8PP8/n8NI4kk8kcy7R33GmsZ7UyNMpTd8kFqXVhKBrsREvBqFCDSGZUpFiuM5lZ65i3bnjcuUDjPCEkQY8LScBSaUXtPF3vrnXWtODQpDyuiFIZxWSHu1ZrAwvrGBtNYx1SaBCghSD2jlMnKixbxmEs37PoYzxCv59lLNw1Cb08Sew0bx2lVoxLtWsMpZZJDKUVbd/ZPunFWEtCf+90PhAirM87QoypS14IqkKyUTuMSiK6FAOSik9aapQQdCFwy9IQiLSdZ9Y5BIIQFSCSi4qIaJEiS7ROrluLNrlDuQBbi5ZSy1TUUQLvIzPrcCGJfkR/fkuThEGqE8yc4/AsUmnJWdOKRetZGx89/k9/+tM87nGP49/+7d9QSvGCF72Yn/mFX0ZKSWOPfk5AMG8sEWhtGj/AtDS4mN7fxciBsWFaabZqR916tBBst2mMIUaQAiVTEcqFwMhIVo4RRXUuvS8kZ63l9V8KFl0v7iqMRAvJpIhJ7CRSUaxzYSjY7URLwVnTgrpLgjUtBeNCUVt/StzHMplM5kT44Ac/yGc+85nh8S/+4i9ypzvdad/Xf8/3fA+Pfexjefe73w3AX//1X/PFL36Ru9zlLtf7WDOZzJnNcr68dLZexhXvjFcOMUUxbzUW7yONdTQupKaEPlZvGafnfcCFPmK7tszaJObfqDtmXVpn+BghpnmsJ4mPWEbepTckADZGfIAQAz4EgoAQ+tdFOPLRt3H4n/4ahOD2j3k2a9/274i9I60SMClNimRG0jiPj1AJhZAC7wNRKUoj0FJitGQ60qyOUixejHDWpCAKWB1pRoUezk0mk8lkMplMJpPJZDKZzM2FM7oy9pGPfASA0WjE/e9//2u9n0996lPMZjMAvvd7v/eUjO2mzle/+tXh53PPPff0DSSTyezJ2sigpGDeOiqTBE/HCoNE38VcaTUIcSA5RZ3poqjN2tLYJDbZLx5vu7F0LrBdO9re8ensaQEIFq1nWh1/DqQQTEqNVoKtOsVutMIjpaC2HiUlumBw4JKcmDvP4ETUX4be4GfYT4zXLPQ69no2ztM4v+t6joxi3joKLdFS4EISek1KjfWBuvMpmm7H2HyMhJBcsWrrYB5xUSBJIjAhBWevFIyMRgrB2jjF79WdRyCYrmhuKSu2G9tH+cFIS6SSnLtS4WISe1kfWDQ1rQv4EJmWmqoXCG0sLE0vXJNCoGWKLIwhRfeVWuBi6pIvlGS78YwLx5FFx0qlEQLe8IY38KxnPYuu67jtbW/LO9/5Th74wAcO5/XYz4n1msZ6ykKx1TgKLXAxsDw5y057KQTTwrC+6OhccoiaNZaNukMIUIUiEDg0LhH9/4WYCm9LMRZAYeQQ8zIq1HCtl64Hh8YlznkWHVRKMa00IUYKI4k77gEhBZVSmKGo55ASlEr34rHuY5lMZn/yWuO68773vW/X46c97WnXuM3Tn/70QRgF8Bd/8Rc85znPOeVjy2QyNy2O6p/SnMfIJCJP4qJAY5dOuRHvk9DcKMXCeqRIblFz59mq0+/wEVMoSiXTYwHrdYf3kY15x1ZjqbuAFND1LlGVEdgA1vleHCWIgSH2Oe6cZEvwHo78019w5UffBcDtH/lznH3v78cHQWMDpp871jZgpCZ5qEpEH9UXItSdp1QKHxSllsQYMSqtA1cqk9YvlU7peyFFrKs9nGUzmUwmk8lkMplMJpPJZG7KnNGV7wc/+MEIIbjLXe7CF77whWu9n6c+9alcdNFFCCFwzl3zBjdz/uEf/oErrrhiePyABzzgNI4mk8nsx7TUlFoODkOFlrsEUDsRsKfD0JnIrHWDKGqrSVGCwK54PGJy6hFCsN3Y5KgTBZ0PFDq56gjBvs46pVaMiyQqanph0VZtcSJSmRTFBxCO93U6jhAjnU9jrHphjFESHxj2s93aodt9P6EXAD51wWspGBlF1QtsQoysVibFuWlF4zwjo9huHYteDLVzf9YFGu+JIbIxa6mdZ7N2xBCRSmCUZFwopErv431k26XYt3GhWBsZDozNELOXokNEEo5JQWEkIUSqQhGihCiYt5ZxqYmkWD7fBYSApnHY/vxYH+hswBNRpNi5QkvWF0kgNTKK1nogomTFvHX829e/xfOe9fO8973vBeBRj3oUf/RHf8RZZ50F7P85GRnFxsJC3VEVkq2FZW49k0Jx3lqFVpLWBkoj0X2EJThWRxrnA2epEiEiMQo664kxnYetJjlwLeNbIImiVsoUYTku0mdweTnC4D4miPGoS1f6zB7d7liWcXyjlYLahuPcxzKZzDWT1xrXnb/5m78Zfr7zne/Mne9852vc5kEPehBVVdE0DZBco7IwKpPJXBOizxUudXICNTrN1TZrS62ORuq5PpK6c4HWpQjlmYusjDRdk+KZm164vhoKYhFZn1ta6zkyb1l0nu1etC9IwvwSjZHJDSrGiBNJwhRCmnst4/VC7yol+1zzIxf9d678+z8A4HYPfzK3+u5H4UPflODB41FC0XWu31LggksxyTHSdA4hBCGmoGkXUhSgUQotJYWSVIVCkNY8xqQ5a54OZjKZTCaTyWQymUwmk7m5cUYLoyB13sVT8K3OqdjHzYVXvepVux4/7nGPO00jyWRufoT+i/zWpaiuwSlICMpezCF3dAAbJVkbS0LQJ7XdmcoyRg52i6LGhWJUqKEgsmgdhVYIApNSJ0FUL3QBy7Q0LDqfYt72EYqNCkVVSGrrib1bUWsDjfUIKcCnzvClC9B+NL1oRkuBVnK4Lp6I7F2/rA9Q7C/0kiK5EFmf4vFciGy3ji4EVitD3fnkbFRqxmUSRlWFoguBq2YtnQ2MCoWAXSKp2no2+/evO8dW61DA2qhIkXm2Q6+UHBgVg0MRpPtuKSpbRvM11qFkEjNNS0OhJeeuVoyM4lubDV897FkbGS5ZX7DoHAdGBuvS9RoZNYjdpEqd91IIhAAfAlIInE+d80JC6yLrC8vlX/xnfvXnnsI3v34Jxhhe9apX8cxnPjNF+e1gr89JjJEQAuvzjkIplPKMRYpUbFzEzTsCyXFAyVRsm3cuuUYpwajUGKmYtRaIbNWOykgWXbpfDoyLoVi1vEcqc/S8LeclO6cn1geUFKxWyRFOSYFWyQ3h6GeatN/+M906T23DLvexTCZz4uS1xrVnY2ODSy65ZHh8wQUXnNB2RVHwnd/5nXzsYx8D4KKLLrpexpfJZG4aLNdHm7UdnD+3GkvlFY11WB+JRXI2TfPcNC/yMc21lZK0XeDwrCOSXJg6H2htxPsOoqF1Dd6n+eWstSxsoOnn15WWFCbFVPsY2a4tUgpCSO/lQ5orep9i9RACJSKbn/sY3/rb/weAWz7wx7nV9/6H9DuZXhN6h6fWRaTs96MESiTnVBFgZNL6IQIjZRiXknNXS6pCcYtJyaifV7bOMyoUK/1jceYv+zKZTCaTyWQymUwmk8lkToozXhh1bHEzc/3yzne+kwsvvHB4fN/73pcf/dEfPSX7vuKKK7jyyitPapsvfvGLp+S9M5kbO9aHwdHmuNJqBE8cREF7OT9JmSLgbuoRWov2aHzeUkC0OtLHiZOWDk2NTwWNtZGhUIrtXnhklKfUikXnWR3tLYxKhRBFoTyNT0Kj1qU4uqXzU+cCoYiDIOtYuv71AFWRtllG3EGKqpt3nkmprlbotaQyiklMTlaL/hxsYVmtTH9vyEG0NG8dSogh7O/KWYtzAaOSY5IPER8ipZTMakvrAm2X4gJdDGy3joNjw8J6Lt9uWCk1lVGUJp23EGOK75CCqlCMrKYyKeax0JJpqYcIv0BMUSchDo5GwUe8DEmIZJP3llGSaSnRKhW2Zo2j9gEjJStjw8hIBALnPX/y5t/lLb/zCrxz3P4Od+Rd73oXF3z3v7va+2f5OYkkMdhKZTh7pWRjblFC4IWg857tzeTCpZXYJZwrtaTSkihAiiRYu+VqxcJ6NuepSFb2xatSKVbHR92exoXa5VAmeieB5SWue0GV7sVlAjg0Ka5R0LjUYiz3k6dNmczJkdca157Pfe5zux7f5S53OeFt73znOw/CqPX1db71rW/l+O5MJrOLY9dHEtLcVSmUEByZtxCh9YEj845poXv3JJiWSUAuiIgIbdcys47oI+vzjs4HKiPpAnRBMjaGSisWnaPpJFUhab0khECMglGhKZTH+YjzSSDVRdk3pPTOUSFiiSghWHz103zjff8VYuAW3/lD3PYHn4aQEtULoiohsOGosL1zvTuVEFSlRpDmeDGm+b+RigNTzW0OjDl7pWJUKEaFHhxEpYQQGOaN+61NMplMJpPJZDKZTCaTyWRuqpzxwqhTgfepKK11Ph1Xx2c/+1me8YxnDI+11rz5zW9GylMTu/WGN7yBF7/4xadkX5nMTYlZ6wYXJGDohA5hh/OT7EU6WtI4T+NSvNt0nyi4myIhRFqX/nte9+5C4x1uPLteu3TPGWLK+vi0Qg3xeKVWdD45bO1XPCi07F2AHGWpmFSBtkvXx7qAUoLGesbF7usQYnJRWoqiSiOHcS4LHUuB1DIW5OqEXjuRIol7tBJs1S65WClPZRSL1rM2TqKk1ibx1LQ0tLYhBobIu84HOpferw0BFyOTQlPo5GilevepqlAUKgnCCpWcproQWClNKlTZgFaCWetYtB6tBEYJfFCcNS6AJGYzvVNW5zwjnUR9AoH1kUXXYV3EaMHY6N6ZKw5d/vg07qJ3bepmG7z6Bb/EP37kgwD8wCMfw+++4fc556xDV3P3HGWztoM71Wbj8D4yt64vTqUgFKXAu3QNXZMiBIterGRKw0qleiepdD1GRiHGEAVMS4N1HhsC1gWmlWZU7BYyhhBpO8/COrZbz6yxOB+YlpoD44IQYhLGnYDL2/I65kJYJnP6uLmuNb785S/veny7293uhLc99rVf/vKXszAqk8kM7LU+sj6wXXdJbO9T/N1KqbE+OUrV1nMLUXKLlRItJSE6ttuOLgRsiJRKsNk6WhewPs1PVyqFlLKPhBbpuw8BpRZIkoNTZRSd9RRKEnpRf+eTG2zTeQSSzschRq/55uf40jtfQvSOA/f899z6ET9PiMkJqjIK78MgoheRXnAv0BKQKbZaSdGLnlKzxFmTgkOTkgPjgkmpWan04CCKgCPzDjga213uE6+eyWQymUwmk8lkMplMJnNT5eb17fw+XHbZZQBMp9PTPJIbL5dddhmPeMQjmM1mw3OvfOUr+a7v+q7TOKpM5qbPTpFG06Uv9JduQrvwMYlQZBJhVIVi3iZXm9XKHP/6myC1Td3iyyg4IVLc3V4cGysme9+kpTuRC6nbWyu5p7BpiRCgl0UHYKUsKGSK74jAVm2pO8/BSaDUmkjEukjnwxCrVJoULQcgRWSz9nQ+MDaSeecptGTWOKQQHJyYa4zmW1JqxbiILLokwKqMonWeEDRSCnRfWFmfd4BgpdJUhcS5wMbCoaWkthZJim4r+gJK6wJKCEojIZJi44wenMzq1rNoPEaJFOth1CBUK7TC+ogUgSOLDqOSqEz3cYBGy+T6JAVNFwgR5jbiCaggk5ioO3qMlVYYJWhd5Mi847IvfIrf+Y1f5MiVl1OUJT/zqy/hP/z0k1hdW9117Psxa93wedtqLLPG4kOk0hK3FIVJQWMDPoALAakkAfC9sGzepei8s6cF41JDFClOTwhEjIwLRSfFUNRa/gH6yEKfinshplhE55n1hb9JBS5ENhYdRlVYH3YJqo4lxDi4o+VCWCZz+ri5rjW2trZ2PT506MQEqgAHDx7c9Xh7e/s6jye702YyNw2udn0kBK6fZ0sBl283aJXE82kuHLhyu+2F/Z66C3TOM28cV80bNusUi1woQRTp53HlMDNJaSS1TU0TSqR5tAskuZMQCBGTw6lMzRNbC4+PaU0RYmp+qC//Kl982wsJtmXlzt/BXR/7awilQAoEgkILnEjzdCUko1L2Ivde4C4FkyK5rso+cu+sccltDo05ODLc/qwxa33zwZJ564ami6WQf2RObD2RyWQymUwmk8lkMplMJnNT4WYvjPrwhz/M4cOHEUJw+9vf/nQP50bJkSNH+MEf/EG+9rWvDc894xnP4NnPfvZpHFUmc9PnWJHG0jFICIZINCkEIaYYvbYXBG23ji4EVitD3aWouJuDc1TbO+M0vWtUqeW+7jhLF6blr0Mv65FCUChJ27tuTVUqRhxTXxhYCqsmZXIysj5yi9WSQKTpPF1IzkuXb7VUxu0ak+4j5kqt6JwfBFkxRgojcX2UnSCJvoSAykpiTE5Y+moEMUtGhRqKRZ0LFFpSW8+oF0lNSs2idVivUBJGhWY7WKaVpvMBFxRGQWUKWpci63xI8SCN9fjgkcDauED053W9scN7Wxe5ctYkFyitMDaJviZFRQQ26o5524uoYmSlNJRacnjWDvtoXcCGdMzQR/9JgRYCHwPOQd12fOhdb+LCP349MQRudYc789z/+nvc9i73YL12HJ61rI0MtfW74up2soyihKOftxiXY/CURrFSGhrncCEyNpJSG2KIeEBJqHqRmwsRFyKL1lMaydrIIIVDS8HauOhFYILWhiRcsx7ne0Efgkhk0Tm+tdUQfKRpPUoJWhcY6cjKSONjZGNhj4vg28nO+L1cCMtkTg8357XGzoYKgKqqTnjb0Wh0tfu6NmR32kzmzOea1kcjU7JRW6wPuFj0zlKeaakxSqCEZKO2SCxKCQ7POy7bbFh0jo25o/Npzu0jbMw7Sq1orBsE/J1NEdCFVsytRwsBSJz3ECRGK5p+flwagZIKLdN6YnHVN/nS25+Pb2ZMbnsP7vi4FyBN0QutBEIk0X1pNJWWjErN2Eha63FeoBWURjMtFasjg48QfGBSKbQUHJqUxwnmW5ccYuFow0ipT8x1NJPJZDKZTCaTyWQymUzmpsQZUSm/6KKL+PSnP73v77e3t3nrW996wvsLIbC5ucnFF1/Mu9/97uH5Cy644LoM8ybJ1tYWP/RDP8RnPvOZ4bknPvGJ/N7v/d4pf6+f/dmf5bGPfexJbfPFL36RxzzmMad8LJnM6WYvkQYkccioUMcJfiqjmMRI3aUvv1sb2MKyWhnmrRuEVDdlQq9SCjvi8fajT2BDyFT5sD4MTkxGC1oHMSz3u/977owpW6kMnUsOPgfHBQudRDiH5x1N53E+4oOn0opJpSiUJAJXbDXYEAZHnz6hg8PzDi0F63XA+chqpRAkcUzrwtUKYo4e51LoleL9Ci0HAdnSXQshWBlpDowNjfVsNckVybbJGWpUKNZGBT6G/j5UzDtPiJFZHzcCAk/E9B356/OOb202jAqFEMlRqtQS6yMjlZywWhdorUcpyfqio3OBqtCslJpZ41gET2NT/N6oML0wKtHYJFwTwGz9MG980TP53Kc+AcAFP/hj/OQzX8TtzzubSMRIyWZjCTFdy/3O2aI96jxwNLbQEGPE9udsu03uWqVWrI3UIHTrXGDepc9roSVjKQYHrdam4wwRWheZt2ksa6MC1wsaF/22y3211uNiHKL7JiODD4FZ4zAyxTe2Iom1Fv21WDnGGS4XwjKZEyevNa4fmqbZ9bgo9lEZ70FZlrse13V9SsaUyWTOXE50fdTY5Xy8pLGBjUVHiJHtxiFFahqZdQ7rAuuLjnlr6WxAEIgBhIR54/AxxXTHkJygJEkcJYRgWqY5Zus8lRB0vdhdY9FaIwEtJFKDEI524zD/+tbn4WbrjG55R+76Uy+BYoT1AUl6T60EMQggxWIfGhcgRD9njBQ6RTdbF7EeCg1VZTgwLpIDbd/YMCati5brQkgOtUuH23GZRfKZTCaTyWQymUwmk8lkbn6cEcKo973vfbzkJS/Z83cxRq644gqe/OQnX6t9L6OMhBA85SlPudZjvCkym8344R/+Yf7pn/5peO4nfuIneMtb3oKUp15gcc4553DOOeec8v1mMmcie4s09NXGqEmRvkTXSrBVO1obaFSKUFu0nrXx6RVGhRCpbRLEhBiJvWOTFKLv8L5uoo3j4vH2cYsCKJTEek+lFJ1Nrk6hiEghlp5Eg9Bq+e/EccezR0zZoUlBoSWVVoTY0gC3XK2SA1V3NOajtYHOJcGNEGl7v8zYCII2hNSZriSzxmJDpLYCsegGl6lF7wY0ra7+n/KlGGopGAsx7umupaVEiuQ05nxIblVCcGBs+nOpAEdrPZMiRdhZF2hc4KpFixLJxSkK2G5TlOBIKNZGmrWRZlIYCiMp+/Es3c2UEkPBybqAEtA5T+hdriIRJcB5iVaC1nq8T/F2//K/P8rvvuiX2Fo/TFGN+Ylf/A0u+MH/CyPkEF0CnroTrJSGWevYauxx8ZIhpMIXMMT+jQuF9YEj8w6koOuv37hQTEuDUUfvr0JLfFQ0Nn1ei0ojRIrL26otR+YtRBhXmnGhqUxyetNK0vXxKp0LwxiMTOfpwFhjfSrEzboU6xfpXeF8oAohuVjZgBSOSalzISyTuRbktcb1w7EOUV3X7fPK42nbdtfjYx2kMpnMzY8TXR9pJSiMZD63TEvNSqXprOeK7ZbN2iJIc+C2S40DI63obIrV8zFCPDpfbl0Sty/nuEVIc+bWebQUuBipW48QMUVAx4B2gUmpqAqZxjrb5rN//Fza9W9RnXUr7vHkVyLHq8QYCTEiemfPNBdPAnwlJbPWc9a0wBiJdoFCaUwhKHRasyglWSk0rfUcHBWEmOaxsrZ9bHc6H6WRw9x3UuqbfLNMJpPJZDKZTCaTyWQymcxenBHCKEhFBXE1Re5rs78lQghe/OIX813f9V2nbP9nOovFgkc84hF8/OMfH5579KMfzZ/8yZ+gVC6sZjLXJ/uJNK5OFLWTUivGRUwRXV0SRrXOE4I+LW4x1gcWrU8d18f+MoInDh3gpVaMS3WtvrA/Lh5vH0ETJIetRecxWqaiRkjRcONCE3fE6qX97n3O9ospk1KwNpasVJqrZi3riw4lNSOjcD7ShYAWAhcCnUyuVc6FZGPVv9+BkUmFGY4KyiRpnLPGYU1gWpohYu/qnKOWw98pHFtGBx7rrtUdI5gqjokjnJYaKdKxF0pyaFqyPmvZahylUdTeMVLpWEutODgxTMskrFobm2GcS3ez9QV0NjDru/9dcKyUGikkPqaolMJIKqORErbqjtYFZAz82Ztfy9/9yRuJMXLrO92dJ73gNdziNndibNI9VCiJFKngtGgcs8KyWhV7xkvW1g8OWi5EhEguS7FN92alFOvOEggUercoakmp+6iTkPahJSw6R+M8C5vcAKZCcKRuOVdX0DtuHak7SqmG+w5gWikOTkqkENTW4XzkrGlB49JnunWBrdpSd57OJXHUMv4xRnIhLJO5FuS1xqlnOp3uenysg9TVcaxD1LH7ujZkd9pM5szlZNZHIcJKaVg0ns55xkZzYFRAFHRhweaio+48W7UjhDRf22w6bIgoCd5HfAARoVCKzgesj7gQsASUSo0UWoHz4Pr/3vsY0EiqIonaSyMRruHi//e5zC//GsXq2dzrKa9kvHYQhMDFAL1DlCA1SqxUGq0kLgSMSdHJJgBCEETECEVRCQop+zGkmGspYLuxSCHQfROblsn5dSmQHxXqZhGvnslkMplMJpPJZDKZTCazF2fUtyL7uXbs9/x+aK2ZTqfc4Q534IILLuDJT34y97///U/FEG8S1HXNox71KD7ykY8Mz/3wD/8w73nPezDGXM2WmUzmVLCfSONkGBWK2iaHm84FCi2prb/G6LVTzax1Q+QFpGNqejegwTFKCiqtKLSk6cUdk1Kf9Bf3UqQ4N7kjHm9ZCDjutb2YqXXpNbPWUXep89u63t1DLvd7/PYnElMmpeCc1YqDk+I4YZjzgfWFpTIw66PVBLA2NhycFJRacWTe4UOkNBIpBeNSEWMSJaUuecu0NCw6nxyf9hG9LP+JXNb7hdjfXWsZG3hUMHX8wY8LTaEkjQ1YH7AhCc0KLQikmMADSmN9RPSxc5Nyd+zf0t1stdJcttmwPu8ojWSlTNGPPgZsf443a8e8tYyMofWe9Ssu449e+iy++n8+BcCDHv2TPOZnfo2OJCYrtWRaJBFWoQ2btcP7FAM4l5azKI6Ll9zLQWsQhA1iu+QgsB9Lh6+uj8driMSQ7kdrPdZHKiMxWmF9pNCpEDbSiu3GsWhdin2ZFCgpsT5waFJw1jSNt7GBqUpjbvp7ddY6unmKISyUTCKpyuRCWCZzLclrjVPL6urqrsfr6+snvO3GxsauxysrK9d5PNmdNpM5czmZ9dHyv9mVkQhh0EoQQiQQ8R5aG2m6MDhHeSJaSmIMw9rJ0xu59opzpQQhijR3TlM4rAfnHC6CjxEfIlJ4lDQIPF3bcNEfPZ/Nr38BM17lvk97JSvn3BrrAjYEpJBoneL5SiUZlZpxZRhpxagQGJ3iAZN7qmC10pw1KZi3Pr22UCiZjq00Ci0FSiVB1nJtteTarK0ymUwmk8lkMplMJpPJZG5KnBHfjLzoRS/iRS960XHPSykRQnDnO9+Zf/3Xfz0NI7vp0bYtj3nMY/jQhz40PPcDP/ADvPe976UoitM4skzm5sPVijROECkEhUrCn8b5QQQ0KU/5cPdls7Y09mjkxVKodRw+0tqQxBxGURWKeesIMR4XeXZ1lDqJSSqtaG0Sp0xi3PfcjQpF6wKlUXQh0NnAZm0HIdkyHm9nUeHaxJQZJVkbS0LQQ5TgvHVIIYbIuHGhuMVKyajYKR4iFWV6oZcPkWlp0FKy3VhaGzDKD7F6q6O9hVFLF6ilaEsKkRyj9nDXisPfDK/dCykFSgpijDTWEQPUnSMiODg2jIxGy5Bi5yq9p7gMGO4HKQTbjTsaqecjRis8HfPO0TrJOpYv/OOH+cvfeSH19ibleMqP/sJvcv8HP4IuJA8sKcHHJFwbFRU+REZGQaEgpqi+xh4fL7k8/mMdtFyIGC2ZLbr+/uqFhirs6b60FEYtOouWkhCgdg4bIloLrI8cnCgqkxzFOudBpLFUvZBpVCpWSjNcBykEK5VBCteL4JI7wsQHlBQsWo91gWmRzvNKqal2FApzISyTuWbyWuP64Y53vOOux5dccskJb/u1r31t1+M73elOp2RMmUzmzORk1kei7wIQApRMYvzt2rKwntY5NuuOWePQUtB0DhcirU3z+9Arn5aNBCk1W6CEwBSCGJODqyTShkAX0/zR900fUUHjPTF4/vWdL+XIv/0zqhxzn6e+gvEt74ASUI0M89YihWRcSLRWFEqxOlIcHBkmlaZSCqUErfP4kNxEK6UIwMFJwahUrFaGpgtURg7zR6PEsH4ScJ3ceDOZTCaTyWQymUwmk8lkbkqc8ZWyk+3gzuxP13X8+I//OP/9v//34bnv//7v5y//8i+pquo0jiyTuXmxn0jjZFmKoZb7ubpouVPNrHWDKGqrF/FAEuIsnXqkEISYnJ3avvt7s7Zs1pbSSI7M4YjpemGNoNRyiKrbi5FJgqpiRzxe3e3vkmWUZFwkUdFKadjGsrlIYi7nI5XxlDEyrRSNTZFlnQ/XOqZM9oWZkYk4n0Rq6/MO3Y9jpygKoFAS6z2VUnQ20LlAKCKFlskRrPM0vVCm84GwhwgsxEiXKjqD0Kvs74u93LV2FpKW2+/E+UBjl+chst06tJJIndymtJRMSo3vC0RL9oqnmrcpvqTUkhAj885BhIPTAq3S44NVgQiSjdmMv3vLb/Opv30HAOfc8Z485tn/hVvc6nbMWkuMpMg9lc5hihVJxwWwWhpsSM4Ae8VLXp2D1sgojvQCKWOAmO7vyqg9i3I+pBjLQkU2a5eKVUV67aTQnDUpKbQixEjROwGMS0XnkotZZwPb2BQB0yVRo1HpvJZasug8nQ9oJTlrWqJkR4zJtcv05zIXwjKZU0dea1x77nnPe+56/MUvfvGEt/3Sl740/Hzw4EHOPffcUzauTCZz5nEy66Nlc8Fynrux6Ji3js4GnI80bRJAuSBobEBKQes9NizdPkHEiAsQYkCJFJ3ngiCGSOdBiIjzERGP/jshJSgBzke+9hev5sjnPoHQhns/6SWMbn03Qkyxe0bA2dMKYyRGJbFV0btGGaUYa4VUgnGRIvU6F+hcmvNrIbjNWSMOjkpcCGxJi5KSiUkC+ZFJc79rWjdlMplMJpPJZDKZTCaTydzcOKOFUcvO7kOHDp3mkZz5OOd4/OMfz9/8zd8Mzz3oQQ/iwgsvZDQancaRZTI3P/YTaZwsQxLYMfu7vrE+DPF5O0VRSfyjjjueyigK51mfd2wuLJEkOpqWhlnrMEqglRz2u5/gQ8oU29Y4z8gottvksKNVen4vJqXGx+RYVSqFkg4tBIVJsWQCwazxu7a5rjFlJxoFUpkk2jI7hF6N9YwLTWUUjU3bu14ks/zdrvfqPDGmMRdaIkgFE2Afd63dhSTrI8tDW3QpbnBJ5wNH+hg3QUqZW6sMIULnkiBru3WURrE22u385XxI7kdGctXcI4RAIUAeFc45H4gFbHzly7zl5c/i0i9+FoD7/vATedBP/gIHVyqqQuN8RElQQmJjoIpJsHbFVo31kVGh+3suInu3raUz2TJesv/1Hg5aSWRVGo1tk1ipcX5wnmqdR0s5nNvOBzYWXXKWkgEXAkZpDo4NrQuMCoVWkhjj4OTVOI8UgrVxQaGSc1ZnA23vBlZ3HtO7gWklWR0l8dNSrJdEXgEbA2OVxFFnT8tcCMtkTgF5rXHdOHDgALe73e0Gp6hPfOITJ7Rd13V88pOfHB5/+7d/+/Uyvkwmc+ZwMuujQvfNBVqxsbC01rPZWLYax2ZtmVmHQKJUQPZNG41VRO1xPr2Hi2m+KqUgCoHr37jr596QXF0FASVBRFBSQgxc+oE3cuSiD4GU3P0JL+Tsu34HQkSiEMg+Rnl1VKCkwHnH2tQwNQYbIlUhKUuFJK1/pEjz5XGhWa0MB8aGg6OyPwdwaFKipeDgpEBAngNmMplMJpPJZDKZTCaTyezDTUIYlblueO/5qZ/6Kd73vvcNzz3wgQ/kb//2b5lMJqdxZJnMzZP9RBony3Kz5X6upb7qpFm0R+PzlqKo1ZHeV5w07wVMSkqmlWF93jHrOurOUyhJYx1r44JKKwotaZyncX7PiLBxmYRRVZHi8Vob2Kod4yLuKcoCmJaa1rZsN5ZCSVZWNaVSNN6zUiqUTHEaUophDEuuTUzZiUaByF7M1Pbil1mbhElJ5KT6qMR0LqYqCbnGxc73ORr5NyqSQxERNmqL84EjsxaEGGL9Su12FZLaHS5Vi87T9g5grUvPz1pL119fgABoLdisOxZtoNCwWhnqzh8n/FqOy/pADFBoweqoQJBcvho808rwD3/1Xv7glc+lmc8YrazxE7/0Mr7t3z0YF0Lqml/GA/YRfkKm+LtLN2p8/wGYlLp3Z5IIBIvO862tmkN9ruSkTMKpvR20gAjjQtL6JEiaFppOBdrO43rHs6Uz1ay11DaJpZyPTArFoUmBEgK0YNIL14QQLA21jjofpOs6KuJuN7De9W1nkUsKwbjQjIskoNtukoDwwDgV2XJBLJM5NeS1xnXnR37kR/j93/99ILlAffnLX77GWLyPfvSjNE0zPH7kIx95vY4xk8nc+DmZ9dGyuQCSe5MLkW9t1PgIG4sOgcDIFDW3UmmESHOwpPT3tD4SYoppDgEgpr+jx4fkeBtixCBACIxSOJ/mppd9+E+48h//CoTg237iV7jFPS/A+cDBacnYpHi8zicx1dmTgoDpxVeglUAK0ELQ+YiwgVJLdITVkWFaaaZV744qBS6kNclynl3q7BCVyWQymUwmk8lkMplMJrMfZ7QwKnPdiTHylKc8hXe/+93DcxdccAHvf//7mU6np3FkmczNl/1EGifL0pFm+QX5tXWeOhlCiLS94KfuhTTjQu0ritrpKNVaT2M9NgSsC8wDyEpgW48PHS5ElEhf+leFYmPRsTYynLNSDce4jBybt47VyrBF2v+i89Q2Ca0KLekT44Z4PBCsjUyKZNMyuR+NzZ4xfNc1puxkokBGRXIDKk0SenU2sN04RkVEKcBBDMv9Ht1/3R0VRSlJL2RyrI3MIOLRKomutBRJdGU9ByeaENLvli5V6/NuGM+883TO4/r4Q60l0zJF/QkhGBvNrHPUnWXRpnM87h2ZnA8cGBcpLq4fQ9O7RoWgMCrS2SSmq5uaP/1/fov//ucpOu9O538HT/i1/4ZauQWRSKVkcmWygZVKJ9eukWHeWKwP6VoLiTbJIcr7yOpIp45/HwkqCbyOzLshou7qHLSEFEwLPVy7QkmKURI/Nd4T+vfcXFg6F9CFwMdIQBBjRCjBWCtEf6mlYIgaPNb5ILmBeVyIWBcwuncD20eAd7qc4TKZTOZE+LEf+7FBGAXw5je/mVe84hVXu82b3/zmXY8f85jHXB9Dy2QyZxAnsz6SQlAoyVZtKbTk8KJl3gZi9PgQUUqglCT4mBoNQnJzVVLgAngfCD4SSU5Rond4lUICnqVVqosQQqCIaW532cfey9c/9HYA7vLon+dW3/EDSCkwWqJEEjeFEBhpRdErs7SUQGoUCETmXaTSispIJpUeXFmVSNF4lVYUKgmnILnsLs/DuDz59WImk8lkMplMJpPJZDKZzM2FLIy6mfMP//APvPWtb9313CWXXML97ne/k9rP//yf/5Nb3/rWp3JomczNlv1FGicubAoxDuKTSi+7iE9exHOynGhMHCSnqKUoanuH+1BlJJEI9OKSEKljKoS4mAQtyc3JcNWso7aBQ+NiECpNS43vY+dWK0OjPHWXhCatC4Nj0060FKxUBZVRhH7chU4uS7HvTk+uSqkosbMbO4RIbT2tCyf0+pOJAjFKMi5S1/tKadgmnae689henDQqFKWTCCHYqi2dD8O+fQwQJD4ExoUixiRGC6GPuqstUgqkTMdxZGbxMTIujorPNmtLoVQvLnNDdF5hJJURVEYRAxgtaFxyloq9w1bjAkp6YmXYqh0CgQsB50H37k5GKcxYcmTeMSoUX/jCF3j983+Or3/pCwgh+JGf/s88+km/SBMF27XFuohQER9AKVAaXAxcNWsZGUWIgUXjsTpwVlnS2MC0EkQEnQ3MO0frPIWWjArVxzOmKLxiR2zh0rHMek+lkvhLSZEcxlwS7wkBIgoCyQFKklzFIgJEciMzSrJoPVoGJkVyqSq0pLEBYjzO+UAKgekdwBqfohQ7Hxjvc4+cLme4TCaTOREe9rCHcf7553PxxRcD8Du/8zs84xnP4I53vOOer//4xz/Oe97znuHxIx7xCO5617veIGPNZDI3Xk52fVSZ9HqjBJ31CBGZtUkYJYEkR4KykLR1isxzXQRicgQNEUFECJGcqkhCKdmLpYjQ/w+RyOF//nu+/oE3AnD7hz+J2zzwRwkhomRaC5RGMS0Vo6LCKFifO1yMmCBofcRIQaEUohfxOx0RCAotaKxnUkhWqhQBvlMUtVqluOpJP+fMZDKZTCaTyWQymUwmk8nszU1WGGWtZWNjg6ZpiCdhn3C7293uehzVjQ/v/XHPXXrppSe9H2vtqRhOJpMBRiaJNY4VaezlXrQfdeeJkT52LYk+RtfCdepkOdGYOOvD4Gi0UxQ1KhSVURze7thsOmKMffxYxCjBok3OPDQpsu+sScG8TTFiO+P11kYGJVNMXGXSPjsXaJwnhB3ipT3i8VZG5oTi8awPLFpP6zzH/SsTwZO62ZPw5qjD1MlGJU7KVARpbWClNLQqxax1Lo2BFpQQKCmGgki6bwJKHD2uzh095wACgVaSun+ucT49JwWXbzUpoq3u2KodjYtY7xESxiYVXpSUECLbTRJLuSa5Ro0KxdgofIR544GImreURqFEEmFZHznSpQi/A+OCGFPH/vv/4l28+RUvoG1qVg6exZOe+9+417/792wsLDGSnJR8RIokBIP0HkIIKi1xShIRlCYdmxLpeh4YGcr+c7WwSUw0ax2eyFmUtL2QT0vByCi2+3jHaakQgNnxWXQhslIZZo2lri0xBrwPLKyn9R6jJD5ESiUptaK1PkWuhOS4FQWcNS3oXMDDDueDyPK2K3QSRsXeVSpczS1yOpzhMplMXmucKFJKXv7yl/PoRz8agPl8zqMe9Sje//73c9vb3nbXay+66CIe97jHEUIYtn3Zy152g485k8nc+DjZ9ZELkcoorthq+seezdoybwM2eAqZ5uRlIbEhEn1yRQXAL1s0wPcOoqlhI/Tzz0gguUQpBBuf/zhfv/B1ANzye/4vbvPgJ1AphZORidEoIRBRIITEaIEWkmkVcT6gtaDr4/pWxya5oBrFdGyQQrBoPZVRlKXG+ji4ui7XTJDWTycb7Z3JZDKZTCaTyWQymUwmc3PjJvPtyfb2Nm95y1t4//vfzz/90z9x+PDhk96HEALn3PUwukwmkzlxpBSUWtE4v0ukoZXYN5JuJ607GqO2dGsq9W7XouuLE42JW4pxWusHUdRKpSm0YtY6XDwarxdCiv1cHRm0ElRIZq1ju0kOTWOTnJDOWS2Zt44QI6tVEjeVWg7ipULLXQKonZxsPN6sdczbo/9eXJPoqnF+EG5dm6jE1cowF+k+KHWKJgyxowuBQqYCidEyxWlohfWh73pPkW2qLyAJkcRqRiXB2kqlOTLv2G4clVZ0PgmEYoRLN2qci/gY2Vx0vehHEH1kXPTH0Qvcuj5KTgpQoqDoj2dSSkAwb5N46bBrh/s7hkgTAo11NIsFr3/xr/N3f/mnANzzu76HZ7zwtRw8dDYhNepTW4/3kRhTJ3+lFYGAdZEDI41QYiiW+aAQIsX4HRgV0F9f6+LQWQ9gXWSrsem5mMRJVZFiC1sbemeBVASrTLo3687TWEeMYogFXHQeJQTjQicBVuPQSrJoPF0IKCE4OE7v63xk0ab70Xo/OB90LhCK5Hyw/KReUzze6XKGy2RujuS1xrXnUY96FD/7sz/LG97wBgA++9nPco973IMnPvGJ3Pe+98Vay//6X/+LP/uzP9vVbPFf/st/4T73uc/pGnYmk7kRcbLro0Xr8CFy5XbHRp1ilZ2PaAU+9lF0ErZry8IGfAAXkqBKKJBOEHpRlEjeUSAghNSQEESaV8+//M9c8uf/BWLgrPs9nNv+0DMI9K6tkBYZApQWg4jWBo+WghAkMaYY5XGpWBsbRlpxYFJQaYUnIEVyJJ0UksJIDo0LDoyL4TiXTSGZTCaTyWQymUwmk8lkMpmr5ybxDcpb3vIWnvnMZ7K9vQ1wUl3bN3ce/OAH5/OVydwIGZfpi/+dIo2t2jEuIqNC7ekKE2LqnF6KokojB8HNuLz+3aLgxGLiQoiDy01jjwq4Cq1YdI7WJueiRZucdqaVQAkojcIogexFKlu1pbUp7mx93lJqwdq4oO48UoghxmxtLAlBn1Tc3dWxWdth3E3nqW2K6TsOn1yeli5EVR/bFmPsHY5OLipxUmoKLXthTnKpmhbJHUsryaRUjAuN8ylqr9TJuWjJuFB73ju3OjBiu7EcmXfQpYhDKaBQiu1FAzISSeMbGY1UksYHmjo5ejVdQCuBDwFHEjCVRqVCTaWZNUmspoQgAE2XClWd9RRG8ZmLLuJVv/qf+cZXv4SUkv/wM8/mR574DLa6wGbr0AhKJYkmIGSKoAsBXEiOXdORpjIKF5Pj06RUaLl0bUr3fYhHRURSCNZGhhBTHF9rA41K3fi+jyZZrQxbWFqbYglTnKAEAVu1pe48Sgpa57H9NoWSVL1DmpHgI9hw1M3Jhsi886yNDLX1VCY5FSw7/10f/zgu9OBAdk3xeKfLGS6TubmR1xrXnde//vVsb2/ztre9DUjOUW9605v2fK0Qgl//9V/nOc95zg05xEwmcyPnRNdH89axvrBJ0G4t88axUTuazieBvQt0Ps1fm5ii9Rq/0wE2rT0giaCijBAiIgpiL1ZSUlB/8wt89U9/i+gda/d4ILd/9C8iEQgEnQsYLRFEnE9CrfW+aULI2DdiRBqbGiQOjgrOnpRICYcmBZNS01hPrZKIam1cIASsjsxJN3RkMplMJpPJZDKZTCaTyWRuAsKol73sZbzwhS8cCs07CxXLmJ29ihdiR5UxFzcymcyNDaMkk1Izb90ukcaiF+IUKrkfCZFESF3/Bf/yP2elkYMzzqQXCN0QnEhM3FLUY/v4MiFSp/RS0AMw7yw2BLRI4q7xMRERq4OwJWKkxIbAZm0RUiR3pdYNzkiQhCmTUjMpr9vxzVo3iKK2mnRNlse904kpxOQEtYxo224dXQisVia5H3WecaFOOirRKIkZJQFMYzwhJsEYMV3npSDo0CRFtW33ziSrIz1004eYBDidC4TIDqGWZGNhOTJvATFEzTVtoNKa1VESOlkXUFLgY0yiJ53ERVpIokgxeZURnD1NJ9ubJEhSSjI1kvVeSNS5wPv/7G2843W/he1azjrnPJ798t/hDud/F1sLi+uvrYsRFwJNl0JNYkgxhUKm+D3nIlcuWlbLFJm3OjL4ALPWDv++x/6YYy+e0n2kYamT0KrukjBKK0GhJK1P16pRnnrpiNV5fIhsNW64V10IFEpy1rRkpdLMWkcMAmQkuIBRktVRui5N76jVOM9UpfdVAjxQFYpZk9yotJSDcFAM8XjH3wun0xkuk7k5kdcapwalFG9961t55CMfyUtf+lIuvvjiPV93wQUX8LKXvYyHPOQhN/AIM5nMjY0Q4nGNDY1NDQKFlgQtsC7uWh+1Ls1xr9xu+NZGwyVHFmkOFyNBgkIiZMCQBPu1DRAjPgR8XDZ3CLQGHCAiIkJAgEgiKgE03/oqX3nHCwldw8qdv4M7/fivIqRGSBCppQAiaQ4sJaGPnx4VHSCQQCA5mZ41Kbj1gTFrI8OtDo6YFJqt2jJrLEomR1LVN1qsVuakGjoymUwmk8lkMplMJpPJZDKJM1oY9dGPfpQXvvCFQCo+aK35yZ/8SR72sIdx7rnn8vCHPxwhBLe+9a1529vexsbGBl/+8pf54Ac/yN/93d8RQkApxYte9CIe9KAHneajyWQymd1MS43vXWR2ijRciLQuiW6ORUvBqFCDU9ToGEHR9c2JxMQto78an0QdRe+ys+gFR60LzJv083SkGJkkIDr2fYySxBgQClYKQ2PdLvefRetZG586QZj1YYjP2ymK2s+JqTKKSe/itVUnwdE3woLKqFQYMTJ1pkdwlTmpqMTGBUaFZqVKbkmVTvEbIUSu8mGInluOr9RJeLaMvdtZo3d9DF7dORadQ0nJxrxj1jkmhYYoqIxE92K8W0xLtEpxhpNSs7mwfMs2KbquUKxUhtpGZq1jXKRO9s4HYuhdpwpJM9vmdS94Fv/fh/8WgPs+8CH86steR6PHKTKPJHrTMjIyirHRlIWj6QLKJSHWkdqhJRwYG2QvVtC9MM2xFKyJ/tpFQkzno+pFREUvPmxdh+tdzAotMVqitWTeunRue/erq2YtV223rFWGeWvprMf0BSolxRCnFxUUSIKAQgsmfezgpNCEmFzEjEqRiPRCwlIrrEnOB5t1R+eT4KpSR8e65MbgDJfJ3FzIa41Tz+Me9zge97jHcfHFF3PRRRdx6aWXopTiVre6Ffe///25053udLqHmMlkTjPWhyEK+1hZaWVS9HOKaQaI/f8LDs9bNheWK7dbvnzljIV1XLHd0HQeIUGRhKqFFDihCN7jRKRxsXcATfNPJUApSYixj/RO7xMjEAX1kUv5yjtegG9mTG57D+78ky+kGlU4n9xIKy1QGoxcyqjS+qaxAQSUKrnVRgTBRCaFTm5QlWFSaurOY0NkdVTsanY5NCmyQ1Qmk8lkMplMJpPJZDKZzLXkjBZGveQlLxm6t8877zz+9m//lnvf+97HvW40GvHgBz94ePysZz2Lz3/+8zzpSU/iH//xH3npS1/KH/7hH/JTP/VTN+DoM5lM5ppZGyXRxU6RRucCjfOEsCMSro9mKPTRL8snpb7Ooqi9OrWvLoKu1DKJoa4mJm6Z7hb7H0xfeBgEU9bjYqTUkpUyFQKMPr4IUOjkrBNDpCglkSQKWbr/tM4Tgj5lHdWL9mh83lIUtdOJaS9a69lYdKzPLdutBcCFiJKw1TimpWbeeTbqjsPzjvMOlByclNc6KrHu3bi6HW5coz7Cb7kdJDFU4zzzxg8Cqsb64fnt1rFoHZNCMq2SMOmc1Wpwm9IxEnpHp8oozlkpsT7FmCwLWJt1hwuaGFOBK8RI4SUX/8unePVzf47Lv3EJUml+5KnP4j89/WeZten9C60QpIgSKSWFVkNE3rxL1/TIvGNzYWlcxMfISmGGyBEhknBq3jqUgnkf3bda6V3uaeNezJbcBdJxFzr9fGhSUGo5FOUKLTl3tcKFyKJ1EGOKdhQSoUH3nwctJVuNZbVSLFqHi3HY37jQLLrkCtV0SRgVIlQmuUdNSwNYNhYpqtHKwMhoIpFpqQaXrxuDM1wmc3MhrzWuP84//3zOP//80z2MTCZzI2PWuqERAdh33WOU6MVMIjmLWseRumN9u+OSI3O2W8vmwtK6QOzn1WmaJKm0YqO2oCTRekIMxH7O5mNEIKgI+JDWQogUrSeEoNm4ki+//fm42TrVLe/InZ7wm0wmY7QQOB+IMdAFQeEETqcGkeRSqvAh0lpP3TraQnFgXKCUIPSCrKKQHJl3eZ6XyWQymUwmk8lkMplMJnM9cMYKo9bX1/nQhz40uEG84x3v2LNQsR93v/vd+chHPsLDH/5wPvKRj/CMZzyD+93vftzrXve6voacyWQy14ppqY8TaRR7CIUg9SSXWjEu1XX68vzqOrWJKcps6aC08/1GJolwCi33jYlbftm//FsiaG0qSLgQWXSOGCNjk2IjlsWEvY51535KnQoPO91/antiEXXXRAiR1iUB0bFOTPtx5XbD4VkHgFYCEeHKRXIdmhSaLngWnWalMmil2G4t25dbDk0s561V1yoqceki1vRjLXvno6YXcrUuiXJciMw6h+1fX7eOy7dbOpuKT0nIBIfnlkIFbJVETyuVYVqZJI5SkkJJfIyMy+RINWt9EgkZSWcDPkScT+I6heCv3/EHvO31r8A5yzm3ui3/6fmv4bZ3vzcbC4sLMC4kiEihJc6muJJxkQRHS1onODgumLWWrdrR2ogPllEluWJboKXoIwLT8UsZqYxESIkQgo1Fx9rIDPtbiqFCL9Rbxj8aJVkbS0LQ1NazPu+YlhrZ3wMyRM6alse5hUkp6FzoHQ1S3N/S8awyisYm0ZrzAa0kSopBHFX0j7WUlEb2nz/JrD0qaoPT7wyXydwcyGuNTCaTuWHZrO0QWd308XguHLcSAZ8E+o1LrqxN55m1ju02uUVt1L2A3qbYaef6OZdKc2QvBEIKvO1j7mKKR04OUctGDYnsY7uR4CPQzvnS255Pt/4tykO34q4//TLK6RoxBlxUCJFEVSFEoowE0pxOyzSnH1eSzkaa4PGBFO8nQAmB0ZJZ4xgXOs/zMplMJpPJZDKZTCaTyWSuB87Yb1c+9rGPDR3cF1xwAd/3fd930vsoioK3vvWt3P3ud6dtW5797GfzgQ984HoYbSaTyVw3jhVpnKiD07XhRDu1lw5VjfM0zg8OVaVWNM4zMio5D3V+V0yc6OPDllqSwFG3qHnraF1IIqu+AGD6eLRjWZZJlr9KghJxnPvPpLxOpwPY34lpPy7dqNmqk0PUrLZsNY7GJ1FSBEQ/1nmTHKCMlIyMxGjFkXmLC4FzVqrj9ntNhZKlqGcp8rE+dbsDzNqj8X+N9YhI6phfdGzUFhsiLkZCBCmSoEgpgY0hCaT66L+qUBAiNkQW1qVijkpCLedbGucRwKTSGCnxwVFvbfAHL/9VPvnRvwfg+37wkTz7Ja/miDNsNZaNxnFgZJBS4EMSkq30RSTnI0sdYGUUnQ20PjAtDKXWrM87auvZrB3OR0qt8SGJjELQaAnTUrGMR5mUGiUl6wvLuFBolW6gYwV7S6QUfeReSDF7SlAaRaHEEBO4FGIJQR8l6CgnBfPO0dmQohOLSGVU71CVPjNTlVzPVkeGxrZsN45CSaaVZtR/jlYqgxLienWGy2Qyx5PXGplMJnPDMWvdIIraGVmdGiTksB7onGerdimmetGyaNO887Kthiu2atZ7QZTzac5eKIlXEtu74IaQYveW80IfUnMGURBjes9IarQQpHlx9CDdgi+//QXUV16CWTmLuz3p5RRrh1BA60CLgJIizYulYKVK881RqRAROh8JHowUlGNDpSQrpWZqNEIIDo4KQoxMCsV4x7wuz/MymUwmk8lkMplMJpPJZE4NZ+w3LN/4xjeGnx/60Ide7Wvbtt33d7e73e141KMexXve8x4+9KEPccUVV3DOOeecsnFmMpnMqWQp0jgVYp+9OJlO7brzeB+RAgqjODxrGRVqiAyrjKIMktYGtmrHuIi9uw54kjgIH3vxTqC2fhATjYskIAEYmb0FSF3vdiR6IZgU+7v/XFf2cmLaS6wFySlqeRxXzhrmvduPkmKIRiy1pDIaF0KK1LAB2wYmwMFxQWMD27Xl4KQ4KUHMTnGP8wHrUgzhTlFU0UcXti5wZN5hfSACU6OZC0cMgS4ErAt4Hzg0LmlFwLnIVmOxPgwuXk3rqQo1FKtWKo22IokJAB8DX7zo/+PVz/t5Dl9+GaYo+eXnv5TH/6encuWsZbX1+BBpbEdjPRIoTOqslwLqPo5RSYHqnZhiXyCzSjIqBbPGJZFcgHnrqTuPUZJxqSiNoDKpMNW5kASEPtC6FGW36PwgrDv272M5VnRW9tGW4z1eO2/TvldKwzaWzoYUoWd9cgDzgUjEKMmii/1nLN0fgUipFTHCOSOzp+PZqXKGy2Qy+5PXGplMJnPDsHShhd2iqHGhdjlzzlvHduNonGdhU/PFduu4cqtlfd7SOs/GwiL6pYMQAq1AIGk7j5aSIJKzbIhxmANLIZAygI9EkoNTJDWEICF0HZe8+7eoL/031GiVu/70y6gOnIdSgtgL+JUUaT/AxCgqrZBaUklNlJFRIY42s5g0R10pDWvjgkOTksJISq16QVae52UymUwmk8lkMplMJpPJnGrOWGHU+vr68PNtb3vbPV9TliVt27JYLK52Xw94wAN4z3veg/eej3/84zzmMY85lUPNZDKZM4KT6tRuLLPWDyKRwiURyLz1gzjnyLzro8HAB1j0QivvAzZEZExCl0Xn6HxM3dokh6il4GdUKPQeBYFlMQOgUqn6USg5iFr2c/+5thwritmvSFF3bojP2ymKWhsZVipNiKmoY2Q6RiUF00pzeNZy+VbDrD/vB0aaq2YtlZFUhYY+es1IwajQexZKQojUnaO2no26Y6N3eQKwfbTg2qigdZ6F9Sxah/VJABVCJIqYhG5KUgqB85HWRebOEQPYEJhKQ+sCnfMcGAsi0NqAHInhvHQ+YKSiMoK3/t7refvv/VeC99z2DnfmJa97M999/++g0ooQQdCxUXdI6CPqAkJKiJFSSwRJAHe49SgFur8Hp6WhUor1Jt1jUkbmjUUpxbiQTCrD6sgwMZq1kaEsFEoKQkgOALPGYU1gWhq2aouSgoOTAmBfwdtxEZD7KahIojUfI60NrJSGVh2NMOxcYN65FKuCQErBuEhuYCtVQWUUoReWFVpdb85wmUzm6slrjUwmk7lhWLRHmzKW64/Vkd4VWb3V2OQS2nkW/Xy7dYGNuuWKrYa5dcxai3UBayOVVkxKleZSIRKUwEfBvHV0zhP7uebStVYpifIRQkSRYvcC4JzjG3/xKuZfvQhZjPi2//hS1m59J2KMKAFFoSj6Jo7WOjxpfhxIX7YpIxAIJoVGqTRXVkBVGs6aGA6MDVoJrAtMS41RgkPjAr1PbHomk8lkMplMJpPJZDKZTObaccYKo4wxw89a730YKysrtG3LkSNHsNbu2mYnBw8eHH6+7LLLTu1AM5lM5gzgZDq1axswSrE2ksway0adure3astKqZm1gluuVMm9qd+PkiAQgzPOvLG9qMbjYorSG/ed0VIIYkyxaeNi7/++L513tBSYXkBTGTUUN67J/edkOVFRzJF5EkXNajuIos5ZKYfjsD72+zn6t5aSsyYlMUa+sdH0ohkYF5r1Rcd5y3Mg+j/HYH1g0Xpal4Rn1sfeEcoTSIIpF5YReo71RXJ9am1g0XmUSB31ENGq73YXAqWSG1OKp5PMW4eUgrXKYF1kq7ZUWuFixMWA5mjx6sjhK/nt33gmn/r4/wTghx/zE7zola/l0IE1Vkfp3+KmFwhZFxgXCqMELizduGDRi/RciNiY3K+0h3Gp0FJgRUQJwcGJ4ZL1jkUXKDVUSjIuJNZFxlPF2sQwMhopBCFGGptcpVobiLHD+kjn4BbTdHLLfQpRx0VAXoPqbrUyzEVyMyi1otQK6wJbraVzyQHLKIHWkrWR2eUGtlKZHJuSyZxm8lojk8lkrn9CSHNWSNHVkNYfO0VR89Zx1ayls2nueOVW28dve6wFrQXCgg+RLkS899CL8Dvn6ULs4/GS66kPER+PRnlHIiIItJQQA4hAiApJ5LK/fh1bX/hfCG24x0+/hAN3uCdSgBISIwVVoSm0ZNE5hJCMlaA0GilFahABVkaaSmtGRYrW01IiEZw1LrnFWoWUMK0M435frQ9ZGJXJZDKZTCaTyWQymUwmc4o5Y6tuhw4dGn7e2dG9k/POO4+rrroKgC984Qucf/75e77u8OHDw88bGxunbpCZTCZzhnAindrbjaXpf9e6ow44hRLMnMd1STBUKMm3thoOjotBjOIDjIxkUkoa57Fe01jPpNLU/T6rQiG9pHMercSeEWKQChx154dtIEXoSSno2rQvOcTrnRpl1ImIYpwPgxhqq0kis7WR2SXuSmWZpRAp/b3oXB//pjgwMhyed8w7z7TU1F1y5dJ9vJwQgsZ5GueH87MUtC3Zbi3btWW7cYTYIaVkpBXFSLI+a7l0syFG2GodTedSJz2BQip8iLgYEQIqIzGqSNepVHQ2CdIEYL3HxRRxJ4Rg0Tqq/l759P/+KL/9gmeyefhKymrEc178Sv7DE/4jQgjGxdH7KUYoVHK+CjGglaQqJAfGhqV4rnWRlVLiYkwXoKe2HufBx8isc6koppLA6MC4ZFoaRkYyLQ1NF2hth1HJaWlcaLSUbDeWzdqhpGBsjkaX7BfdKIXAE9O91UdAVvu8dsmkTAWuuvN0LmC0pHQKKij78RklKHpxX45NyWRuPOS1RiaTyVy/hBC5atayvuhobWCzsUl0JIt+LprmpjtFUUfmHVutpVSSEAWjQrEWNa1zxDrN13ShISa30y4IBBEfwfk01xuXms6laGXr0zolxhTt7UJESShM5Ot/+0au/Oe/R0jJ/Z/yYqZ3+U6sd8kOSqV5oQsB4SJGCopKUxSSsVaUhWKtLFgZGapCMSkkB0YlRsNm7QkxUJo0/1tOcRvnh1jw6ys2PZPJZDKZTCaTyWQymUzm5soZK4y6613vOvz8uc99bs/XnH/++XzmM58B4IMf/OC+xYoPfehDw887O7ozmUzm5sCJdmovRVGzdmfMnmBaGSqjaKxHCUFpkjNO5wJSCrRM7jiN9QiRnHRGRrGxsEAS8mwtYN55RkZSlholJSHGXcKmnW4/AIWRwxhHRYocW3Z+L0U6+7n/hBCprad14YSiyk5EFLO5sIQYkwim70hfqXb/M2tdL4zqh1Vbj+/j+dLYI411hAizJhVVDs9bDk1KWhvQUjAyiqpQXLZZI0lRfE0fU9j5gHWxd6YSLLqAFAEiXLHVcmTe0nrPxsxRO8eo0Ey1pPXQ+lQg6mxAa0EMGoTE+oh1UBrYqj2ujxkJROgLUluNo1Tw/77+v/HeP/odYozc7i534wWvfiMP+M77DvfUzljESLpepVaMC4X1kUIKSp0coSaForZ+iHeE1OEfIygF67MO71PE4LhUhJCKW7PWccgZvJTMuyTYUjLFNnYuMCqW4qh0T2opOTgybC46lEzRdnvdD6WW6bprRWtDKlodc4/uhVESM5KEEFl0jq0moqRgZFKU4qTUTEud4/EymRsZea2RyWQy1w873U7XF8m9c24dIUSMkf18rk3Pt45Z4wgxcnjeYa2n0pJxoZOeSATmNsXVhZCimU3vfKqANoRkuipIgn5ACtm72IICghCEEPFRDE0Q3/zwO7j0438BwH2f8Ovc7j7fi/MBGwStCwgEIy3RRgICGSOFUaxUmlFpmBjJwWnJyCgmpWal0ighUkNASI0OXe/oupz9LSO7r8mVNJPJZDKZTCaTyWQymUwmc/KcscKoe9/73kgpiTHyiU98Ys/XPOQhD+Gd73wnAK973et46lOfynQ63fWav//7v+f973//rv1mMpnMzYnaeiLQudQlLUQSGi1xPkWuwW5R1KhQVEYNrlBLgVGpJONCoQR9bEVEKcGhSTGIXCqjmFZJRHRoXAxCKQHMGkfjAlIkMc1ybNaHIcquMJKVMkUWpRi2FPW2jNdbOvAc6/6zsxCzs+SwFF11LhAiECNlX8iYlhojBdZztaKYWef6v+0wLi3lrvew4ahwq7YegQAF887RuQAIKq2xLuBJkWqyd29q++uz3To2aovqRTSzzqJ6pZWSgpVK4bxGCIENge2mI5BEYodnLV0f5+ZcRBDZFtCFQPBJeLTdWKKAOE7nOYb0vJCKcQUiQhMCi961CSJXXHYFr3jls/nCp/8JgB/4sZ/kF57/W5x76EC6V/pzuZPOeWKMFCZFl0gZOTQxffe8IMbIpNRURtK5CBGMTjF/h+ctSklWKs3heZsKYTLZeiVXgHSul2IoLQRloSj6+2TpshVCpPGerSY5R62FMAjViOCJQ8ykURLnA4WWaJliIevO7+tsdiyyd9darQxaCg5OCgRw9rTMgqhM5kZIXmtkMpnMqWe2Yx4G0LrAonNsLmwvWBcI2UFIc+dvbTZ03tPYkFxNY5oXN/3aQAuJtYGQptGEfr9GCZQQWOH7NQ5pEgtIBG3fiFAUCuEiCx8QRKKIXPm//pJvfvDtANznsb/EHS74IZSAIGIvoE/ifh8jB7REKTBSMS41k0pzi2nJgXHBgVGa1xqV/ixjk+f9umrpEGp0mgceG92dyWQymUwmk8lkMplMJpM5dZyxwqi1tTXud7/78clPfpLPfe5zfOELX+Bud7vbrtf8+I//OM985jOp65qvfe1rPOABD+CFL3wh9773vWmahr/+67/mFa94xfD6W9/61nz3d3/3DX0omUwmc1ppXSohNL1rVKnlLsHPUhTVuqMxeyuVGb7ch+SsY5Skc4HGe1a0QaveTah2tDZQqMC41FRasTY2nD0t2axTEeQASdC0ubAYLVl0jqtmLZNC73ofLQVVL4SqrUOK5Ea1VTfM2hS/cWhSEkJkXOhdgpNjCzGdC8xay7x1tL1ISEhBpVQ/Bs+i88xbx7hQzBpPVewvilkKapxPf4/M7n9iWxeIMaJFKqhsLSxVodioWzqXoj0qI1kdaWatQwl6ty3JSmWY9G5UW7Vls7aURibRmA2sjQyrI5Ocs0Jk1nqUFFw1axFCoARszDs2F5YuBGZ91F9ySPIQ0zZLcZjRkq3aUXpBqSTbTUhuYiKJwQQQA9jo+ed/+Cjvee1zmW9tUI2n/OxvvJJH/9hjEUJQmiSSO1Y81Do/nKfVyrDo/ODQpKVkuofYKMSYYlbqFLcihaDuXBJXFZLVosARGOvkxBRiEvUBOKB2SYhmtBgKTiFGtErFtQOVZrNJRbLBMUoKKq0otKTrBYJKBkZGsd06Fl2KfdzprrYfrfPDZ2kpPCx1donKZG6s5LVGJpPJnFqW835gcDtdn3c0zvOtzZqtxqJFmiO5GFg0jnlrEUKwWVuUhAOTko2FoPWepg1MR5raeWobECE1QZRa4X3ExogPab7vPUiVRPSqt5ASRDoX8D72c1DBFZ/6e775d28C4PY/8CRu88DH0PmICx4fUpNGmgkHnE8NCEoqDowLJoVirTIcmBTc+RYTCnX8/DC580aUECghEQJM/7rl8usUJYFnMplMJpPJZDKZTCaTyWR2cMYKowAe9ahH8clPfhKAN73pTbz61a/e9fsDBw7w3Oc+l9/4jd9ACMFnP/tZHv/4x+96Teyro0IIfvM3fxO1x5dXmUwmc1NmGdewjG8warfL0TKertkh6ij2iKgrdBJGxSEGgj4mLbLoUgReZRSt84SQREtrI4OSgnnrODguAEFVeOxmYLuxLFpPZSRVqRj3IpLWJrFSZRRKCa7cbtiuLSGC0ZIQYX3ecpuDYyojKY3asxCz1dghlg+Ss1XrAiF0vUuTYlwqnO/j9oCNhR1EY8eKYgajob5VXe2oalifHKl8iCAjl28lYVLr/BBROCk0WiWxz7x1xBDxIeJCZNZYtmtH4wOHZy0bc4uPgUJJ1saGQxMziI+kEowLxZXbbYrskJKtxrI5d7gY2W6SO1XVOx+FENFakuRDoFSKF9lqLbKNGK1YKTWIdG8IAfPGYW3Hx975u/zvC98KwG3vei9+/rd+h3t827cRiayUmrMmxa74vGXU4KLzlDrFH45LRWcbRpWidQElA6E4PqIuie+SAG9aarbbJGJaqQpKk45FCs3BUUEkOQVolSIZOxcGAaDxMgnCBKyUJjlkxYgtFKHzQwwjAD7uijAcF4r1he3vK0lrA1u1Y1xERoXaM1Zv5zEDlEYOMYzjMs85MpkbM3mtkclkMqeGWeuGufhWY5k3jtp6thtL45I438eID5amTe6mh2cdjfW9G1SKIl60ntJoEMmpNhJpuxTxLGQSK20sfIpelhIfPHUXcTGig6CQAg/4mCLsIqCVQEq44jOf4JK/+m0Aznvgj3P7hz4BGwJGCgICo1SK5FMS7QXWR4yWKJnmx5VWHJyWSJFiyIvxsc61aT0QI71DappbL5srlmL5a4ppzmQymUwmk8lkMplMJpPJnDxntDDq8Y9/PB/+8IcB+MIXvkDXdRRFses1z33uc/nMZz7Dn/7pnyLE0qL8aIFiyS/8wi/wlKc85QYaeSaTydx4ODa2YeeX8csv751fxuyJQdRxLMutjt3fqEixcS4kgUqhJbU96rY0LTWllmwuLCG0zFvHtExRcF3vYmVt4HDrCSFSaMnIKLZqm8QxPomWSi2QytDawMoouf9stTOKPtpPqyQQam1g1jo65ymNJCwFUTECER9T3EbnA7XzTAvNvHUp1k6m2EDnQ9rfLlFMfx4kEMD38YKtCzQ2FXxCH//hYqDUko15h/WR0kgaG5A+FU1SfKDn0o1FOpchPRdixIWAUrA5S0ImIeAbpIi5tXGBUZKyF4hJIfAh0NmAlClSRKtUyBEkEZVREiUEK6WhUIHWe7Zrm4o0AnyASgsqo3EuMCkVG5d/k7987a/zrS9dDMADH/3TPPrpz+Hg6piiFxaNjMKFiI/pHupcoNsRhzgq1XBvHBwXO0RbnsZKxsXxU5S6L6h1PlB3yemr0pKDo4LOBwQwqdK9MzaKLgQIkUJKSh1Y2CTcWx73kbpFIhgpjRDJLW2l0kM8pPVhV4Th0gFr0XnGhRrEUYtebFf0MSlCsOcxl0ayWqUIyEmpd4kQM5nMjY+81shkMpnrzjKWOITIldstV263LDpHaRSN8xzeatlqHFtNx6JNscYherreYbS2DhsilVY0NlB6D0HgY3KqndeOeds7vXaOEJLYyQefnKP6nL3WBlqZhPlKCoSISCRaCTa+9En+7d2vgBg4+zsezt0e9TMURlGqFMWsjED0sc7zxqOlRgmPVpJSpwjxWWtZtJbVasxm7XrnW7VrPQAgBWglk1OtltTuaNQ2pPloJpPJZDKZTCaTyWQymUzm1HJGC6O+7du+bShW7IeUkne961089KEP5bWvfS2f//znh9/FGLnPfe7D8573PB772Mde38PNZDKZGyWib5de1m+XDlKQhB1wNGavOCZmbyfLrY6NgZBCUCiZCgLOU+j086Q8um3rAj5GbrFSIRAcWXQsNSOt9cytR5JEVNuN5ZvrNZ5IqZIjFAhaB+3MUurUcR5CpDKKq7ZbSiMZFQolUkyfFHBgXLDoHLaPz0iiGIOS6bgXrU+FHOuYGM3heUvROyYtY9qSOAoKJZPLE+l31gWOzFtcKIgxDm5BKZLPYl3EeU/jAwKBlKm44z0cmXXMuuRMZSOUveNTiJGt2rFoHdZ71hcWoyQHxwWt83xjvWbeec6eloQAk0LRdpJvtgGkYFKk6D3rU3FISlIHPqnbfjoy0FrquafQqSO+danzfrP2SGmZlJpP/8Pf8RevfxHtYkY1WeFHfvbFPPChP8y5ayOMTscxLkp8hO3maHThEi1TxGJlFNanSLyRUVw1bymcZNY6XEjXZKcIbylUSufBsrCeUovkcBUjpVGcPTYgJQJBoSUFuwtLReO4at6CjQgRkP3rRkWKQDFK7nrPyqghwnDRpSjJ5PiUohYPjA2FktSdHxzHls5U+x0zJLHgXnGBmUzmxkVea2Qymcx1Z7O2qaGhsXxrq6FzgUmhcSFwxWbLZmPZXHRcvtXgfKA0ChGh7tL6YNE5fAAFeCmxLhARhOD7hofkAmtdSA0BLtLaiA0xRSQDRFASpEhNBiGmhYqSgfWvfY4vve3FRG85eM8Hcqcf/SUQEq0U566WdP1cMIQ0dy61xPlIWRYYCaXRSAlzG9hcOEZFx7jQXLndcWBcYEMYBLNaCQRpTn5gpLEhYmRyPi10cpEa7dOEkslkMplMJpPJZDKZTCaTufbcbKpyT3/603n605/OZZddxje/+U1ijNzudrfjlre85ekeWiaTyZxWpBB4Yopv8El8shRwLOPhjsbs7R/tsBRRiSEG4ujvlmKo5X52iq92xtx1LmB6oQqkzunaelRj6Vzksq2GtgsUOhWjQwwIoRkbRSR1fyspWHSORecIRKaFofOBjYVlpdKMjKLQilmb3KOAQbSyFH2NDIyMZ7txWB+oO0/rUld4ZSRaSoQQFL370rwXzmw3DmKkdp7W+3QckSECbimu0VrSWI+RklGhk2gpJoeurcYybx2TUjOrHcFoLjm8QGuBc+AJNDZF7DkfuGyr5sDYcGBUUhnP5ZsNQiSnEqUEo1Lig2DWJCHRuNCUOtL6gJL9tQ+yL9r05wLFvPUQA1pKpIC2bviHt7yef3r/uwG49d3uzeN/7b8xPXQuxkhsDIyVodKKtVHvrhVSzIkQKR6k0rtjGA+Mk/PK5qJjxSUnJRdSzMg3NxaslIaVkUaJdE23G0fjkjtTjBGjJKHf5tBEMx2l/a1WGheWQiqGMSglGBnZOzgJQgwUSjAp07WXe9zeUggmZYo53KpdciTrXaXqzrM6MlRG0fXCv2s65kmpsygqk7kJktcamUwmczxbteXyrYYY4ci8Y9F6hISNRcdV2y3bvSjqyKLD+uTaGq2nUAJEiqiOCCKxb3xIczslBI0NzFpPFL043frenamP2TvGxTYJm9KaQ4n0ZH35V/nyO15IsA3TO92PO/3Er2GMJpLeQ0iBDoJx0cdkx9TQ0FgPMRKJSBE5NCnZbiy19Vy51XLOWnKoKovkzKqFoCxUisn2nkmhqYxi1iah/XLtU/bR4ZlMJpPJZDKZTCaTyWQymVPLza4yd95553Heeeed7mFkMpnMjYZSyySG0ipFTLjAJCbHnmV3814xeztZuvkAVCp9sV/siAlbbnZsgWLWukEUtYy5gyQeWa00TR/BtzYuuHyzSeMtJDFGFIJRH7dWGcUtVgoKrXAhMGscG4uOWeupu4ARUJgUc2GUJDo/vNdKZXYJV5akSDjLrHVokQRFm40FkttQ8JHWSVZGhpGWaAmzxhEQKEAKifeB0qQxLjqPFFAahVYClXRojAuJ7s/Vet0SY0TLJN5ZX3TIKSitiSEJeIw2zJVFK2ht6qSfdx7nW8pCooUgAhKoOz+I3OouIARMR5p5a/FREEOkc2AKCD7S2SQ2mlnHrOkAODgq2Lj8a1z4O8/jyq/9KwAP+LGn8Oin/RJnTUdHz1VMXfCmF8EdmhR7RsUJUtFnXKrh9753W1reN4dnHYvOsdUkdwGjUtSgjym2LgYGR6mF9ZS9cxYkYZfRCgOMdt6jIfZ/Co7MW2xIwjSBGKJL9roPlpRaMS6S+1fdeQ5OCrwPFCp9fgot991+r2POZDI3TfJaI5PJZBKbteXIvCVG2Jy3fGuzwfcxdtYH5p1HSMFmk+bb3keiABuWa46IEGAkOA8+BCalwfuIJwmMWp8aBToXcES8i4RwdO1BH28cARlTRDRAkGA3LuOSt/8GvpkxuvXduP1jn0eQBT5CpSSTUhEDOJ/isYX8/9n793jZ8rOuE39/b+tSVftyLt2dCyQkRAIJyEUICBOJBuEn6PBDzIxyFwOCOnHgh8ZwmUACo6Iit+CIgxFFBxAECYz5CQijAkLklhAShEggSae706fP2XtX1Vrre50/nlV1zuk+fQtJOuec7/v1Or1r965atWqttWs/33o+z+ejiCmhjaw9jJb6XiK9DXYp348xMYyRVecIMXPuoMNoJSL6kOZYcM3ZGGmtuc5VdNFWt6hKpVKpVCqVSqVSqVQqlfcGt50wqlKpVCrX0zvDZoo0VmIcYpa4iGVrUUq6CTeK2buWMSRKkcgwN8dAXBtJtnvYtTF7IWU2k0StXSuKWjTSINBKcToEtNZcXk+g4LBzhJRkEhxojOLOww6rtTQkjMYZTe+sCIfiyMYnhlLoc8EZcfmR9ojEmz2cmOVsCuQizktDSIQssXLrVFi2lr41c1RHRiGv/ah3hJyBls0UuLyJHC2gby2NVVitiVoi+NapIA0fOShnY+BdZ56YC32rmbzEzFktEX8HncVHETrlLM2Zg06imkqR43myCTgr7lQFicJbNJZhnrxPRXHUa3IuaCUOXjEVTreBokCVQi6KmAqNMWijePPP/zv+n3/6twnTwOLwHJ/5km/iQ5/3fO44WGCN4sLSkbK4NvXOzo5aso3OqavuSXNcYe8eOgl/1DuMVtxzMgDwlOOe9Rg4GQNxdhqbYiIjr3fRyTForaW3hkVnmWLm3KJh0dy4tJlimuMexXEgxcJiaUAp7ByR2D1KdEnfiINZzAUfr4qhjnrHEJK4opXymF5zpVKpVCqVyq3KbvjBx8zZFHjn6UQqBYXUR0bDQWclejoUUpF1RgxgDJKbVxRaFawxlBCYAiyagrWa4COpyFBCzFKLF0T45ESvLw5RRVxsd+KoXXy4v3KJd/yrryVtLtPe+UE84y98A65bUYrEXDdGkTJsQqSxhlYZOqcZvDyTM+IE1TsFGk6myLnOspprVF8KGRHUh5zZBllHGKVQSpHmtdHRwnLYiWvqsrVVQF+pVCqVSqVSqVQqlUql8l6iCqMqlUrlNkdrRWsNY0z0znA2RbY+YY1Ei6X5PhKzV3hwCpiPaRYbQddcdd65VggyhsTgI5NW5FlAdToEiTrLIurRWnHYW9rZvSfP4hOtFGPMrFqLVpCLIyRpWlij9nF/Y8isrmkmGKU5XjQijhoTRosoqjEGnzIHnXtYIczWR3yQ5/YpsQ0JlzV9o4kJWidiJaMVVkuc3hQzrVOcrRNHvSWUyGZMjDGTcqCbp8GDUvvGEEBIic2Yue/UE0LB7HZJwZOPOladRMlppYgJsr36WICFczRWsZ4iIWfGoXDQ230HyBlFziI2G2OmALEUNlMkl4IxmimlvftULqBQqDTy8//sH/Bb/+k1ADz1w/4If+p/+UbuetJTWDorx6C1fMC5JWPIXBk8U8z4kDnsFIvGcH7RPGZB0Kq1PP3CknedTlzeeladY9U5YpKIOr2Wc70e5aWtlpZlK5F5Wy8Cu0dqJu0czXzOhJQpsyta5+QxjdEP64i2QytFY8QRa4xpHxG5bO387zG91EqlUqlUKpVblmuHH07GwOhFPN7OQxjWaDYTFDJXhoB1GhNFuNQ4tY/udlax9WVfb8ckwxuZvI98Bonfc3qOTtaIVefsDLUTTKlrvonbU+7+wa8jXLkXd/xkPuhzX4npVxQKjdbkAqlIbDURegt9o2m0IbqCQmOtoiRZixitac0uOs9gDHNknrjYnmwi1s6CMGNYOIPVivOrhvNz8dg3pkYtVyqVSqVSqVQqlUqlUqm8F6mfvFQqlUqFRSvCqK4x+JyZQuZ0iNJXKGUfs+djJjciKMmlzIInEUU1Tu9FTf0skNo1Ru47ncilcNQ7Ui40VlyYSoGTrSflwtHCXSdMGUOaXY9EXHStZuVgnqwegwh6GqPxSdx6dtvIhbkBI82LGAujLhgd0FrNwq+HCmFiyvvXtPZx31hxRqLbNiky+kTKhVVraazmwqqhFBiDwxnDxkeecrjkbXlDjJl1ypgxkFciPCqlMMTI2ZDIueCcIpSMtQqnGzZT4Nyy4Y7DlpDE4SgmmYYPMc9RHqIIUw6c1RwoR8yZy1OgmV2sihaR2hQSi9biTMHHhCqKOJ9nZ2A7JWLOFKVQpXDyzt/lP//jr+XK3W9FKc3Hf/aX8rH/4xdzsGjELasxXFi2HC+cuHSVQms1Wy9uSlMQAdYQxHnsseKM5innei6sGi5tPGdjxGhFY43ovEph4QxKi7PYFDN9Y1g2mpjFdWsXR/Lgc5tnJ4JhigwhzefO7K/ZRfPYokt2Yqg8K/IezkWtUqlUKpVK5XZkO0kdPfo0rx8KfaP3tZxSipwz60Fqah+SxA47cX3VWhFiJuSM1hCjODTFlDjzCaMk3k6ioxWaQsxgtGilSpnLdw1q/h4FqkCcttz9r78ef//vY1bn+cDP+Ubag3PkDFYpsipopN5ORpxXjVEoFCFnGmPonaGxipMhsHSWUkT0dNg5ppiwVtNqw0HXkEtm2WqUEqfarjF0xnDYO1ad1MjL1lZRVKVSqVQqlUqlUqlUKpXKe5lb7tOXu+++mze/+c1cuXKFzWZDeZwNyy/4gi94L+1ZpVKpvP/ijGbZWjZT5LBznBL2DkInQ8BqcTnKKXM6gNFqdt2RxzdOc9CKWGnRGJzRbGbnqa0XZ6JcCkNMlJCYgmaKiVQKPhSJ31OKK9vAojEsW4ufHX5Oh0ApBSOmVag5ngxgCiLoiblgNUwh70VZO0cgq+X1DSHRlMxmyqw697CCliFIM8fHTJij0ZSS/ZxMhrkx4keJxFBKMcWMVhLN0VjNlBTrMXBx2XIyBHJmFgqJo9KYRFg1RmkEuWJYNZqMYjNF2kbEVuJolQip4GPBWnGnaoxiO0VihsbKuWmNiKV8TAxB9iMkae50TrPxmVVruJIzzmpWjSPGwBgiBfZiojf/7I/y8//yW0hhoj++yJ/4slfytOf+EaZcWJaC0RIfp5TEMII4TMmxFjHSGOUYipvS478eW2d4ynFPzmUfUddYjY+JtY2EWFg0lgsrwzhHMK4nuWYHnxhnsZyz0sgqFNZjZIqJ9SgOBr01LBuDVnLN2scYXbLTW+0un6qLqlRuL+pao1KpVB6eXfwxSE29i5tujOF0lDWF27lvpkiY768RYdGyldouxozTht4WzmLBzi5SKRV8kpi6XEQcZbTE5oHUZSmLc9Q+yhtQBlTyvONHv5Hpnf8N3R3wtM/5Rppzd83R2ZAolFjQ1pKybDsXcVqVyGiJmW6NQRs46hzWKHwqEqm9cAxeXpuz0FlD6yxPPbe4rs5czO5QrTUsWlPj8yqVSqVSqVQqlUqlUqlU3gfcEsKod77znXzLt3wL3//938/dd9/9B9pWbVZUKpXblVUrTYAxJA47x2jEDcppETHFJJFl6ymybMQpyWpF11x13emcCKxOx7B3mDrZBqaQaBuDD3mO7cvEVNj4hI+JRTaExtA6w9anWUgl+zVF6XSkedzbXRN55manqClmbCMReT2zWEcpKAVrNTpmdn5AUyqsgDQLr64l50KYn28KiTGIKKkUBUrEUieDJ6aCRknMnVH0zmBmUdAQxGkr5UJRYLXmjiOL04opiWAnDwVtQCtpmhit8CGz9hLPdtA4GmNmsZEmJHHXMkpx4iMDEFKBeWLe6II2mhASax84HQONtRglIrbjhWPRGEopxCwirr4xZGAKmjEENusNP/e9f4ff/aWfBODpf/gT+ZQv+3q6w3OEXMhJmkJmFn/tj1kpbENkPQZikUjBKSaOekffGI5796hxetcKoHIpEoWiZPq+tZrj3tFazXqKHETHyRBQitmNKkqMYutwJjHuXKtiYk5xAcS9LM0NtM4aDhci5Dvo3eNytdo32dT1XyuVyq1LXWtUKpXKY2OYHV99lMEFrRXOKqakKLkQESFTTIWY5GtIhc5pWmdorEFrJTV4nt2ligiUGquZfCaWQsllH02tFGQFJc5RetcKojRzFHfiHT/yzWzf+np00/P0z/kGlnc9jVIgZrlPSRmtNDEnQoKUswiyMvS9prMGFKSSUVmzbBtap9j4OLthiYtr4zR3rToOF05i9pyBIo5YO3eo3pnHHDddqVQqlUqlUqlUKpVKpVL5g3PTC6O+//u/n7/8l/8y6/X6uolt9Tg7lTtL90qlUrmdOeodRotrUeckkqy1mnvORtw8qR1iwufMUltWvd2LlHZOT5spzq49iXetJ0LMc2SZOA3dsWrYTElcl1ImJHnPXk8RnzMHrWMMWaL9rNlHlu3EMrv9gKvCqLK/z9W/A1pBAuyDhrBzEjHPZko44+doO9m2D5lQMlopTqcoIiLEHevMB4qCkgtKi+jqbBIRVJwnxfvWsGisuGTlwqI14mqVCkd9w+HcADnsHSGJgOh0G7iyCRijaK3Ch4JPiVwMuei98GaIkVg0PmYK0miKKfPAxtMYzXYys2ALfC7YIsf3ZAOrxjDEzHZKdFYzGU0pEmvSWcW9//1N/N/f/rc4ve/tKG34hBf9FZ7zqZ8DSpNyxijF8UHDQefwKeNDIqXM/euJxmrWo0z8S+OpiMAsFdKYuH89PexEfEiyT1NMPMRzpcjk/i6OUSJU8l6QF3Nh8ImDzqGVuJO1czReTHL9lMw+XrFzBh1h2TnKrIlbtIaLq8dnaeVn4dyumXWjOMZKpXLrUNcalUql8tjZDTTs3EMPWsuVrae1moJEVvuYRNyfrw4paH21ZrdaREglRMZU0BpSlJowlkxMiVIKqYBGHGWZ3VmZRU5mFkhprdAl8/bXfDtnv/VfUNbxIZ/79fQf+KH42dLVaHE/hYJSoMhQ7H5Io3OG42XDOMnARGsNrdN0jcJoxUFn6Zwm5UKYMm1jaBsRQd150PLUc4sqhKpUKpVKpVKpVCqVSqVSeYK5qYVRr3nNa/i8z/s8cs4PaTQ83liLSqVSqQgS7aD3gpVFa7mLjq1PHPZXI8tCFjeoZWs46iVKYj0G3nXm8SlzNoW9KOriHAu3ai3L1kr0nDYsnJF4DaslBi5kzggijvIJe817ewYMNxailAd9BZnYDinhjAEiMRdpxqTEelR4m693Ciri9hRy4fLWM/nMstVsQuJ0DDitsMZQVKGUglUaaxRzL4YpZYZN4vLWk3JhM0Y2vROhUsocBEuYGyIxZtY+YJS4Tlmj2fpEiIlYCrYUplBIWSbQN1MERHDkg0yxawOZzNk2Yo2m9SJ2OhkCmylx3Dt6pznNkeU2gILLW09jNa3THHSWk63nF378X/Jj3/3NpBhZXXgSn/pXvoknPfsPo4q4TTVWy5S+kWl3DRQF929kW3cetIwhMcaM1eAj0Ml1smgsBWmOjTHtp+QB1lOcX5fgo4iZcr7GMUorOmskRi9ltj5hdKZ3hrM5qtEaxXJ3zfqETxlrNKsHibBKKWx8pDMa0yg6pzns3OMSNuVS9hGP3eyS1j5YeVepVG4Z6lqjUqlUHh+7qOrdYMOqs5yOEVuyRHMniTd2RksUtlFoBTEWchbhVMziUjtEcZaNSZxmd5HaVmtxGM2FlAspI2J4ZK1gDbTaoLUI9d/x//8nPPDrPw1a8yF/4Ws5/4c+Gh8ybnaa0krcYePsQIWy+yjt1hgKcLYJFCWRgP0cG946ia1eNJbeWS5vRrrGcK5vuLhqOV40PPPiCltrxUqlUqlUKpVKpVKpVCqVJ5ybVhiVc+av/tW/um9UlFL403/6T/MFX/AFfMzHfAxPetKTWCwWT/RuViqVyk2JM5qjhSZnyxASzmiU8gw+c9Q3eJfJuWC0QmvFEDJDyJyNAR8lQq9kiTq7sGxorKF3Zi9E2sXc7eLSOmdQDs7GiA+ZySS0kjgObcT6KeeCMWpuuFzfoFYP+grQWsPgdxF0mgxc2QYWjUysjz5xOgX0NY5Rax9RBcYpESm8ax2ZgjhILTpLzBLxp5RECHbOcNA6rIGTIXAyBIlsy5mTbeRkCFxYNoBi6BMXV600gWQcnc0UKRROh8CVITDOwp5VazBG0xfDyRA4GwPOGonho9BYxSYkYoS+sZQi7kljTAwhE1LmZIhMUWOMYgqJpjFoBToqtMqcnVzmh7716/iV/yjRec/6uD/OC77ka3H9AVYZ+lbhtCaUjEWxaB29Ezexy9vIxZVmPQaGMWGswihFKIpUMsZYppDJOdAYTe8MXWPYTHEflTcGcRIYfWIIEn/3EFJhCtJI651h0Rgub8Mct6KZQuZ0iCyaQt8YDntHLhIH6WOeo1fk+1xg4QyrQ0vJEHPh8c7t766nnZhPAb0zj/q4SqVy81HXGpVKpfL42WlGd1+t1rRWERN0rWbaZtZj3MfLudkJdEqJ08Gz6hviHH/sU2HtozgxpSLvx8zxeFkBmf2yQIEq8jNjwFgRMd37//xz7v+lHwPgQ1/0N7nruZ80O0SBiplQFFprSi7oIq5Rdi4QY5KhicY2+FxwVrFotbjgahFFNVpz1Dm2ITHEzMppDhfiNnXQuiqKqlQqlUqlUqlUKpVKpVJ5P+GmFUb9x//4H3n729++n95+9atfzRd+4Rc+wXtVqVQqtxZaixvPsoXzy+YRXX5SKlCgdeJc1FhL3xgaa/Yxe/vtzjF3WitI0uxYtZa+mQU+PtE4zTAlGq0ZEeGMmSe/m1mLEmb3HjU7MV3r6KGVmiPXMpGEKuBzpi+acUqkUuhGiQwEoICP4vS0npLEdcxxfxdXLblIZJ7SioW1HC8cRmuMkdiQzhms1tx7suV0G1n7CBlSyTTakCmcDQEfC7kUccnKmTFmppAppVAoTLOwzOfMwhk2PslkvE8kUzjoDNZqXIKuK6QE69ETs9wuOWG1IpdMTBK3N5Ao28BBb7A68c7Xv4Ef+Za/yZV3vRPrGj7jxX+D577wRQxzhKFSBaM1SmkWVnNh1bBoLesxYLUh5cy7TicapwihcPGw5XDpSCmzMo47li0ohVUiQDqbYxIPO8f9ZxMgornTUdzH5NyJ+5IzGq1EACdxg3m/jdZpFo1h6xOLxuzFUdtZXNUYiWs0WsR2Pmb8LvLEyjXorGYKad9wm6JE8D0aU0xsvYi5+mbnFlVjUSqVW5W61qhUKpWHknNhCIkp5r3YfTfoIHF5oojaleS5FI56x2ZKHLYN2zGzSQFtFFoXcsooDTnC2iesjYQk64GTjZ/rcXFNdVaT1BxzPUdfayWDFlmJa5TRYLXBKHjHz/0Ib/sP3wfAM//MX+XiR70QoyV6LwMUqeOtUaQEzlpQsLAapWVNM8ZMGyJ909AZGVIoSNxzb2SNsw2Jy5sJZzSLzrJqHaXAhYPmCTlHlUqlUqlUKpVKpVKpVCqVh3LTCqPe+MY37m9/xmd8Rm1UVCqVyvuAB8fsNVaEKADbKZKBEDOTymitOOodq1ai4q6lmWPuOmuYggiBclPonGGc3YO62VXJaYVVCmc0PmaMzuQi29sJo3ZxZs2DnkchLj+6KKzVxG1hNJnGyn1zkX1pjQiXhpAIJTPFxJWtR2k4t2jIpXCy9XSNYeEsh71FK0WImVKk8+Nj5mQIjHGXNwdjjKTB0JnCNiTuUYXzi5aURWijlcIZmFJhComSFY2BIWTWY2GzTWBg4SSKJKaCmTtNy1azHiPrKYJSLBotUSRZnKFyhlgyR72jsZqTbWD0kf/6mu/jF37wVZScOP/kp/F5L/sW7nzGhxJTRmtIOUuUiFJ0jUT9rTpHyiIwslpzz+lICIW+06way6oVR7AROF44Vp1DzbenKMKlKWQuJ793hppiYj59LBqJJXlwrF3nDMvZDWu3jdZpOiexeccLR2M0g5drZooipHowViv6xmC04so2cLxoyJSHOE7dKFYvX/P8wPz8IoxatNUtqlK5ValrjUqlUrlKSHlf/z/E47OIUCikzJVtkDp0towKKbPqHIs2sJ0Sh51lMwVSKjilWftEoy2bPLEOAR8SRiu2QSL0cpG4PKVkW0aB0hpKwUfQWgYzlBaRlNYaZzUP/NpP8daf+EcAPONPfhEf8D98FqmU2U0U+Y9WOFVQRYEuaBTGiBvuwll6Z1Ba4VPhZBMpvWKMifOLhq53hFS4Moj7q7OazlkuLkUMdfGgYdHctB+3VSqVSqVSqVQqlUqlUqnccty0n9Scnp7ub3/qp37qE7gnlUqlcnvx4Ji93cR4nKP1RgqLxnK0sBz1N56U7py4/lijZ1cniTtbNHYvgPIp44wmZXFjiqUweggxMUURQBUkosNqhVKK1l0VRvk5Vg5kar0UERdZo2iNCHEoEmeXHTirSKlQSiFTSKVQEhil2PhIStA6SykwBWn8OKuwyojzU4iEOWYjbAtaw7KxFBSRjE4KpRUnm4mIkon6WZjVG0M0hnWKpAxWaRSFSKYkxZDF8Wq1cKQCZhY9FaBvNK215CyCrsZpWm1kP+YpexMLcbjCj3/b1/H7b/gFAD70kz6NF/6lr0H3S9ZjoBREqCTqKs4miaxrjJF4wCRRhpspMYZESrBS4sKklWbrI4tGRFQgr8ua3T/F6RC5vPUipCuIS1gnIrNHcmzSSlzLdtuYQuagE2Ha4BOHvdu7Q+3cy/buBVrRWbMX7wHccdDub58Sbug4tbtedtfhLg6mdZrD+fUtW7lWK5XKrUlda1QqlYrwSI6xD6m5jGLjEyFmQs4oJc6zx31DSBPzPAFXtoEMKAobnwBxOR3nCO80x1eb2ZkzpIyaRVG6gNYao7Jk5xVwGnE7RfHAG3+O3/43/wCAJ3/Sn+UDX/g5WA0NUuORCsoaHIWSoZSCUhqnFc4ojNF0reV40UCRNUGmMKTESht8zviU9oMfK2dZdQZnDWjF8aLhrsP+fXiGKpVKpVKpVCqVSqVSqVQqj8ZNK4w6f/78/vZisXgC96RSqVRuT66N2duRckEriZZLuXBl68ll13BQaCWCmc5JFMUUM11jWI+RYY6Ma6wIo0oWgdV6Kiw7y5Qzjc1sZhFLOwtedmKo5poItjEkhvl+fWPwW4nFe/JhtxdANc6wncQJaOcGtB4jMRec1jijmHLhge1EQdEaTS6JxrpZLFNQaM4Gz9pH1mOkdxoU+JSICc4tnbyWoukbw+XBS0yI0fROsWgaUs7yr2QKhWFKjCkxxERnNecWLSEXTqfInccdKReZoE9yLFeNwxjNfWcjpUDvDK3WaA0L13A6BX73N17Ha77tq1lffhe2afmkz/sqnvuCz8QYTS6K1olbUsqFpbL4ECkoppC5tJ44WogYyGcYQsRqiSlsnSEX2PjIUec4Wri9yGkXNwcSOdfZzP0hsfURHwsxZ7TuMFoETrvr4kauTbttLJoiIiafOLdsSCnTGE1I+Tr3sgejdo9vDc5ocfYKicPOMZr0mB2ndk5RfWNYtTdtCVWpVB4Dda1RqVQq7GsmgHGurXfun9eRxIlTA6OPFODS2nNl6zkbRIB/eTuRZ/enVApdY+idZfCj1P9J72OsSy4oCikrMmUegtAyuEBBq0LRUBJYPTtFacOVt/wyv/ODfxty5o6P+TSe/qf+MilDyQUnSXkUmU3AKIVxYLQhxIwCrDF80PklB72ldZpl6wg5M0wypHC8bFBKsXQGYzUXly2HveN0HjJ4ymHHk466vZttpVKpVCqVSqVSqVQqlUrl/YObtqv30R/90fvbb3vb257APalUKpUKSJMhpszpENj4RGNE4PJgYZSbBTBWyWR4aw3BZaaQORsDVou4qRSFNfN9tWLVWHIpbKbIqY8oAsd9Q9+YWRijeNfZyNbLBHvImfUY0Ep+fr5vOF429E4i1XwUMY0PmcEnchEBTEyglYaiIGW2IdO3lsUcxbadEjFnUHB54xlCJuVE4ww+y/7FVGitxmrNJkdSLtik0EjUiC2FXBSDD8RU8KngjCLngrYKpzRTykyhcHnjcVZz0FourwPayDR77zTWajLwwNnIdkp0jTgrGSU/b4ziZ3/gu/jJf/WPKDlzxwd+MJ/6176R9s5nEHPBOkVnFY3VGGUIOZFL4Wgxq90KoCUmxACd0/O+Glorx1CpyPHCsewsB60IqBaNuc5NKaTM2RQ5HQM+FpgjR8SlqpCAkESg1hjNojEPiV8EESTtGnK789dYzVHvrnMv27sXKEVrNb0zaH1VcHXUO4xWbKZI58zjcpxatraKoiqV24C61qhUKrc76ynuRVGno7hsgtRIrdW4a4YSQsqsJxl0uLzxoBRGwz1XBt6WB44XjpQlju9sTJyNgZwKKHF/1UoiuK/kwMbLoELOswCqyJMWCqoUwvyzGBNKKZTWKKU4fdub+K1/+Q2UFDj+sE/imZ/5v1JgjuLWxDjXeJT9vlttMBq63kKB86uOo5XjKUc95xYNPolQK3QZpRULJzXqQWs5Wjis1kwhsWwcF5eOJ59boJBBhUqlUqlUKpVKpVKpVCqVyvsPN21n73nPex7PeMYzeOtb38qP/diP8fKXv/yJ3qVKpVK5rdn6yOWN5/JWxELOKEDEPju0FqHK4CUmgwLGZFatg12sWUhspygOPbPAxmiZLM9z/FrMRQQ1pXD35QFnNK0zwNw8KYWQirgezU2Tg96xbER00zWWzRQxXrFs4NwSYi6861T2MeYwR8DBlArMUYFbn1FtJETwSQRVKWd8zAw+swmRGGQSPjaGXGTCfUqFK4OHIgKvxmiuDJ6UwWnFNkSU1kieh0IV6J0mxMIQEkOMhJTZTpHDRUPrFClbtJdYkWEXS2gUFMgUNpfv4x//nb/Jm3/1FwH4mD/5Wfx/Xvy3SMYxTJntFNgOAdVZtkZzYWVYGodSipRE+DVnnEAQwdF6inOkHjhjKapw3DdcWLX7BlDnNMtrhEObKc4uTxGrNSdhwqfCYWe5vJlIOe8FSHZ2EZtiZtGY/XbyHLXoU2YzSZzeECKHnSPETH/cP8S97NFYtZbWarZTkgjCx+E4ValUbn3qWqNSqdzOhLnmgutFUYtG4qgf7PAprrEKoxXWKO45GVlP8jgfC2eDx1hNKeLQ2WjDlWmCXFi2jiFmhkHi9TRS55eSUUqTFVJTIw6xmcwUJUZb6lYY738rb/7nX0P2IwfP/Gie/mf/JhkZSijIc5ZScBqsM3TO0jnD4byuyDmz7BwfcLxAKbjrsOXiQYczmlwK952OnI2RzmkOOkfrDAedwxmFmgVSB53Ura29XpBfqVQqlUqlUqlUKpVKpVJ54rlphVEAr3zlK/m8z/s8fu3Xfo1Xv/rV/MW/+Bef6F2qVCqV25KTIfDA2nM6BjYhshkSILEWJRcKIi5RszBqH4NnNXme3l61DmcS959NFCDkwnqMOKM47BtWrWUMCaM1xxcbQszcv5FIDgz4kMiICEujWM/NnGZuYFijaKyldSKIWTQt2ymy8WmeJFccLhoOenE9CjmTCwynE9uY5u1YYpRJ+cYoNjnzwHZiDIkYC0PMErvmDMUXBh9pGsMwJUROo+haTXGGKWRCyiSjsUpRioiNjJZIOx8TChEJ5Qw+Ji5vPZfHQG8NjdMcdbNDU2voZgFWAd71m/+Ff/F3X8rZlQdo+wX/37/6cp7xCZ+GzxmdFVprtNZzPJ1h2VjuPOhoncFqcfnauTvFlNEpY4sI2jKZ823L+YOGlOHiqqEx4v50rZgJrm+kjSEz+sR6iHIxdJaQRMC2i1+xWtE1htYatl6EUEaJM9VOXmdmR7EY5bFnU+T+9fRuCZec0RwtNDnbx+U4ValUbg/qWqNSqdyubKer8Xm7Wu6wt/vI5GvZ1XtaKXzIrMfIyRBYTxGnFespcHmbaYwhl0QqCmegsWZ2EC2YoBh9xESF1oreKXwSoRW5MKZMVpC05OBZDdZaCrC+7x389j//atKwZvWBH8aHfM7LKbYhlEwOO5coqeuUMSycZtlI3djN++Cs4kmHPcZozvWOJx0t9jHKWikOOsd6jDRGc9A7lBJXqF0cd+v0PnJ50Va3qEqlUqlUKpVKpVKpVCqV9zduamHU53zO5/DzP//zfNd3fRdf9mVfRgiBL/3SL32id6tSqVRuK9ZT5L6zkZgzG5/YjpnTIVJU5rhvcFYz9zSIuexjNlqnWbaOZWMYfEIp6JxMoVsjMXBWS5PBGcW5ZcMdq5bTIXIyeELK3DlPcq+nwDAlSgaFRPYtW0vfGEaf2MwOVHaO9xtDpneGiwcdF5Ep9DEkmrOJ7RRprEIrRcmZzsmsuVWGlMXBqXOW+05GrowBHyQmMBeR7igkUnA7iUjJeYl+AxFTnflCYw0xZzRgjcR4AJg5Jq9TGlShc4ZpjqEbh4jPhZJF+FUo0FlQipAK79iMWJ349R/9bn7mX38PAE991ofx+S/7B6zuehpnQ0QVxZkPaKUYQsIaRd+26Nl1atlaFHBu4TjoLKdDZD1FyuxCtSwSZ3jxoKVrDCEWjBanpVVrH+IUtWuknU3SHEvMx0Qrlo2cn9UskPIxy/UxRoKT5trgE31jWDSWEDNjSkw+sR4jxijQsHDSFBtjYozp3Yq601o9bsepSqVy61PXGpVK5XYk58IURfAzzFF6i1m4/mCurffuOR1Yj5ECmNlR6nQKtM5glKJ1hiGIsGk7JaaUcMbQO0OM4uxkjYIIIYGZxfogNbJsU9E1ihgVPmWms0u85V98NeHsARZ3fRAf+vmvQLUdOTMPHiRSlsc1RtPNbk5tozjuWw56cY9yRnHQW477lruOG3ntPjGGtBfdh5RJpcAoTrall/u1TnM4DyssW1vdRSuVSqVSqVQqlUqlUqlU3g+5qYVRAN/5nd/Jk570JF7xilfw5V/+5bzqVa/i8z//8/n4j/947rrrLrque1zbe9rTnvZe2tNKpVK59Qgpc9/pyBQyMWVOtp6YM61VGCPCl4POoWfhUEjSaJlCYuuTuAXRsGwMMWWCAlB0VnG0aFDA+WVznVvPsrUc9hLDNqbC2RhQiLBFa8Vydi06GyO5lDlCAzpj9qKbVesYgoixlq1FK8WisdxxAPdm+MBzS9ZT4nTr6ZyZYz8Sacisx8QYR7Y+StpcKZAVMYFR4jQ1BDAo2kZzZRvkPkphtUJrEYg5rfG5kEsEx+zWpHBas+quxrz5kMipELJECWYjt1UsnI0JZRSWxPrSvfzUd3017/ztNwDw/M/8XD7ry16K0g1bn8RxKyaYFMYoOmdRKDZjhM6yDZH1KEIlHzOdM1xcGZatYT0FtmOCUmiMhjnS5GjhOLd0+yiRa6+L3QT92RTwIe/j6A57i0LLdL4R16rWQm5EnDb4xKWNl3PaGE62gcFHRHIGIRViKagsrgQphb2rU9cYNpOc912DqlKpVP4g1LVGpVK53RhCosBetK4U9M1DRVHX1nv3nA5cOpsIqbDxkYg4noYo8XV3HrYc9i1bH7gyBGLK5GKgiCg+A72z5BQICXLOFK3QFHIBZ8RlSimN04qkC+HklN969cuYLt9Dd+EpPOcv/m2WR8eElIlKavGCxpoizrVK0VjF+WXLUddwbuFY9Y7eac4tWxatYdU67jroCEmcTmMW8b6PmY2POK0xu8hArfauUiDH6PGK8yuVSqVSqVQqlUqlUqlUKu8bbolPbV760pfywAMP8K3f+q38xm/8Bi996Uvfre0opYgxvof3rlKpVG5dTobA1iemmHhgCOQ5Tq1bNIQsrj8KsHo3qQ2900zOcDbKY69sPc60cxMEjhcistFK4YzGGn1drJnVigIsWsuVwYvAKImz0y7uQiswWmONYtEYpphxRpNymafaA6vWsfVJtjlPdjdWE3KmUDBFnJgoBWs0KWdKhk2I5JgJIZNyoaDoHDQWfNaoklEUfE4UL4IqozWjDwD01jCqRGMUi9bhrEyqF1WwWrHsLM6IIGhKmUVjGGMmxExIhVwKRkFUGmsii87yW7/0M/znV38TfntGu1jxp/7K1/NJL/x0jlYN6ymiNTRa42PmqLeg5LX6OY5umBJOa1KeJLKkFLRShCRxf5015BbIhcNFg1GKw86xaCy9lVKiuWY6fpibZFNI+NlF4KCzbH1CaY0q0kxbNFfLkJ04zc+vFcCnBAVCErFYY0WUpZXDGpnQ3zmRnU0RnzOHnWPwCa1UbU5VKpX3CHWtUalUbiemuQ4bZ9eo1mq0emik8OATMWUubSbuvjxQgFwymzESU8HHiFUKhWKMGYaJtjHcddhBKVzaeFKCrGDykSlGpiTi/KGAVoW+MWQUTkNMInAyWpH8wJu+92sZ7vs92sMLfPSX/l0OLt6FTxkHFCWxyLIO0XROY7TmaNFwftFwYdmwbB2tU6w6x8VVw/llS+f0vOYQh6y9Y2lMWKVorKZxmlVjObds9sfi3XEsrVQqlUqlUqlUKpVKpVKpvO+46T+5+ZVf+RX+/J//87zlLW9BzR/WlTnOqFKpVCrvPXIuXNmI2OdkGwgxc7xwtFai79Y+EmJmPUU6Z/ZNFa0UvTNYrUl5ZAiJd52MLOZItTuOWo7naIrzy+YhcRQnW3nO0SdClIbJXX17g3gPT0gFpeU5RSRlORsDU8g4k2itYesTh708x06Uc3kbMBacE0HUdpD4Nq0U3ieKKhQtjZlSJIqtFGi1omTFtkRKFnejgkTrGaWYcmEbIn3ryFlcl3LKJAqt0fgkwi2tFFlJ82cKIk4qiNuUNdLUMUbhcuK/fN8/4Dd+8gcBuPCM5/DCL/9GnvoBT+f+tWcbRCCUUiFbRSqZg4VjigWXM4edZuMjSoHPGR0UJ0MgZYno23Gt+1JMZf931mqFsxoF+2n5PE/WA4xz/ErfiOvWyRBojXh4hZRnwRzXbFvEZp0zXNp4Si6sOovRisNenMd8DFgDR73DGk3faBRKBHohc0rgsHNspkg7u1JVKpXKu0tda1QqlduNXTx0nnPsblRL5Vy4svVsfeLS2UTMhdFHrmzjHD+niHknhC84q8nA2RBlsKAoemu57CdOx0CiEKPUzZqCM4jbk5Yo7JQKOz39dhj51f/za7nye2/CLQ75uC//+6zueCoxF1IuxCKxeQedoW8suYiY3qDQWuK6tdYkMod9T2cltnnZWs4tHAURffmYcVZjjCLEQmvLvv5ctmbvhrpoTa03K5VKpVKpVCqVSqVSqVTez7mphVFveMMbeMELXsB6vQZkCrs2KiqVSuV9w2aKTFEmxbeTxMpdWDVopRh8YtVY1og4agzzpLXWNLOQpiDCoq2PbIu4QEWXpWGSYNkazsa4j0nTWpGzODCBxHyAOFQ9VBQlDkYhJTpj8EEiMBaNxPsNPjF6EUb5lCVyTykeWHuAWdijMKqw9eIOBTDFSIiJPIuNrIbWWZaNYT1FQspAwWpDIBNVprN6dqxSRF9IReEU9K2dw+EUQ0j4JG5HZ1PkZBtxFkIuiGmVPJdSis5qWmMID9zNa1711bzrrW8G4Nmf8jk8+3/8EnTTsA6JnsLWR5aNo2s0lzceHwuZQqMMpSiMA6c11ipUKVgzH+OQpMGjpBnWWHFmKoBSGasM2yly56FESDVW7+MOxzl+JVwTv9I5ub9EChZCLIwh0lpPSBmtwFm9d4pSiEgKxKWgc4YQC4U8Hwu1dxJbNHYvfDsdIlPIjCbNz5k4WtRGVaVSefeoa41KpXI7snub2329kVvU/WcT21k8dP/GczZEfEqcDQlU5mSEwQdCymymyGoMLBu7r/e0VgwxkorUiiUWUiniUqo1WotYPudEVpYxRLTWWJV5w/e9kku//SuYtud5X/Z3OffUZ5KS1NqlgCLTNwZjDN1cRy5ax2FnGIO4yFqrUEqRY+Gu8y0AjVF7F1nXa3KWmOcrg9+70bazO+3FZbuP8a5UKpVKpVKpVCqVSqVSqbz/c1MLo1784hezXq/3TYq77rqLz/7sz+ZjPuZjuOuuu1gul0/0LlYqlcoty8kQKMDZGIil0Fq9F6mkUvAhs2os3mQmn4il7KPZdiggxIIPia7RLDvLyTZwbtGIGGa+v7j/GAoySe6vEd30zUNFUTCLcXzCzfF7cW5udE6aIjEXYspYo0XMU0RsZWYB1hgTnXVsdUFrhdN6jqWTvzmrVqOUJqfC2Ti7WIWEKgproKBojaFtIWwCxii0zuQMqcgEukaEPVNKhJAZjMYAU0z0xTLNIqPeWbKVKXjQ/NYvvJbXfd83E8Yt3eqIT37xy7njuZ9AKvKaLm8mRmswVjGGxFFxbHzCaEhJEUymd4Zl61AlceYDk5fzYq2iVZrWXSMoUoq+MZwNkZgSyYIzEo0C158DP5/fMYlwrbGa0ScubTyDl6aVxCHK+bBaIhOnGDkbI1ZrfIr7OMUyP8dminsTq25+vsZcjXZprWHRFLY+MXg5z1NM5FybVpVK5d2jrjUqlcrtiJonGHZ1V36QIHQzRc4mqX3/+/1r7juZyIhj6BgjRkmtnkpBoZhipoyRzZhoLDRWhhROxjCvG6R+dEbLEIBTdBhKgRQzuYCzBh8jv/Z/fTP3vuE/o23D8178v3PHM5+LLpCUhpJZtgatHMvGoLSImRonrk4hg9IaYzWdUxy2Dd3sKNU5s3cF3KG1EodWYzheGA46S+cMnTUc9I5KpVKpVCqVSqVSqVQqlcrNw00rjPrVX/1VXve61+0/vHrxi1/Mt3/7t9N13RO8Z5XKrU/OhSEkpihOO2X+4FwrdZ27T+XWZpzdfYb567K1e5HKQevYqsjgE43RNL0mpiJimSzXzJQyPkkkxdpEUiwi3lESu3Fl69Fa0Vkj4pqYuLL1OKNJc4NmF893I7RWNLNbU+fE0WnwIsRpjGaKiTEmVkaznSIFaXxvvAh6FAVjFHcdNShgTJFTrShFzY5Xcv9QMj7kuXEOISUS4rLUO01nDadDIpeCUYpIwSeIMdNaQ+ckWm4siWEKEi+CYusnUGAUZA1OaTabLb/+b76Dt/+XnwDgzg/5KF74Za/ArC7iU0ZTyFmaSyEVDpQlpYSbYOvFbUmj0EpDgfXs+uQvJ9Y5cmkbUciE/M6FS2uFns/JlBKN1jirSBnuOxv5gHM95prf97xzGciFXApnQ9gf04PO4lNminK81mNiPSYWrabRilxg6yMbHzFamlQpZYYgDlSHvaN1er9viweJ4vrGMIREnOP8GqsZQmLZ3rTlTqVSeYKoa41KpXK7opUiIYMBJBls2EUmx5TZ+kQu8I7LW+65MhKL1JghJnzI4kBaRNBvldpHJ5/5gAuKRKQgYn4fM0pBztA1GpDI7Wl2lRqLDFKYlPhv//Yfcc8v/3uU1nzkF3wdFz7koyW6uhQ6q8hYVMm0jZnj7ixOK46XLc6o/bCE1opWG1pnyCWjiqxjfMzkLK87l8LgE9u5hm2d3h+DRXvjoYxKpVKpVCqVSqVSqVQqlcr7Lzdtp/AXf/EX97c/8iM/ku/+7u9+AvemUrk9CCmznSQS7SFBMgUS5Tp3n0VrJI6rckuSsgii0uwQ1Njrz/WisTRGhCkhSpNkZeTPztpHTFEsGom5246Z0hQu2BatNXGnrkmFKWSsliaJCGfkGmzto19ffSONldYZfBYB09kYxRWqFMpsXrXxiUVj8Uki3kRMZWmtIeTMqkvETeags2x8ROcCWqOVJmVPVtIoKqUQcgGVWLgGpWCKGasUYRZzaSWioSGIMGrwCZTElQwxkbJEeYw+kYHGabTWnLzjd/nF73k5Z/f8LijFR3zGF/GcT/8ijHNsp8iUCq2RSLkc5bmM1ow+cnkroiylFT5nesDO8Xj3no5MIaOVwgCnkyckQ2Ok6eOMwlotblUFMoWD1lKQY7iZEkp5EcBZzRQyqWTWY+T+rfx/q0VMpmAfndc5w6ZIFOPZKO8tVivQBVUUUYOPgcYYVp3ElrROs2rdfH2ZfdzJDq12orfMGNNeGLdsH+fFXalUbnvqWqNSqdyutFaLGMoapiCC9uUcO70TCr1rPXBp68kFYpY6LuSCNuIwNUyJ7Ryj3TbgksLN9eDJEMip0Dqp+WMuNFZjjUFlMEbTayXOrrPL6K+99nv5vf/0wwA8+0VfxYUP+0RCKhSVKWSMMjirUMpgFHROc24pDrRHC0eKmUVrMVrjQwJVxEl1HihYj4HGGk62HmM0PuV9lGDrNIed1J/L1tb1baVSqVQqlUqlUqlUKpXKTchNK4y6fPny/vaLXvSiJ3BPKpXbg/UU2Uxx/72fhQc5X+MY9SB3nzGKU8uqurXcosw5G3PU2UPVcmCN5sCIA9EUkwjnfCKljFGKYRbZ9a2it5a+MfTOcNQ78hy9N82xeWdTZOsji8Yy+kTK4jb1SDijWTQSqXfQOs4I+JBlAjxEvM1Yq1hPIpa6vPVsfUQr0FrTN5pDbYlRGj5N0GAdbaP2Lxtl8TGyCRNaaVorjkyFQs4Ko6FvDX6b8ElclLRW5JwZQmaMmcPOYo1mGiI+ZYaS2IaCNQqK4e7XvZZf/YF/SAoTzcF5Pv6Lvo4nP+fjsEajKOJoUiRasLFaHKlS5srGo5SibxXLztIYhdWGvtE4ozEK3nkyMITMFBK9s7MLl6YoWDiDRqE0kOGwtxRgCJnzi4a7DjtGn9hMkdJYpphZz65Xp2MkxExr9V74FUvheOFwxpBL4aBzjCGyGeXfmDLDJqG0YtUZYi6UBo6VZdHavShKYgBv/L6yE0PlWVz34PiXSqVSeSzUtUalUrld6Z1hM0URK81x1INP9I3Bp8zWRy6tJUovRHGQGkLEakMqmVLU7HoqblGtUeQkwiqfCipLjDaIYN5pRYxzLWoMToszqZ4HFH7zp36I//bvXg3Ah37WX+MpH/dp5FywKIoClMYajbUag+LcsqG3hgurltZqCtC0jlVn8DGz7Ayr1tFYw3oK+JS5tPWsGssYFId9AyCDGY3ZO0X1janr2kqlUqlUKpVKpVKpVCqVm5Sb9lOdO+64Y3/7yU9+8hO4J5XKrc/JEBjnD69Hn/ZRVQ/hQe4+XSMfqudS9lO2lVsHoyEkaRpMyLT1w6G1om8sbo54a/qGtY80RTOoRGcNR71l2VhaZ/buU50zLK+JsvAxk0pAKRh8ws+uQI/EsrWkItfmQeuYTOJ0G0SokwoPrD0+ylR4SiL0O+wtuYAzBkrh3LIh5oLScLqNe8ejnCE4mNqCT5YpZCgQc8IDfasZfBa3JSBnua0AHxXOFBonTaGYC1sfiCkzxkLOBVcm3vxvv4N3/PJPAnDhQ/4IH/35X0N/dAEfM/tRdlU46CyKwhQKhsKYJa5u2Ts6q3nqcb93r1q0do65izij8aGAVgwp0uWGvtGoIsKyrjFoBWsiuSjOL5w0uoy4CRwtGkLMGC2OTc5ocpFJ/GVjKKUgXSs4t2g4t2xmxwGJNly1jlXr0EZxNka8z8QMk890jaE1mkUr1wWIU9QjRePtkhV3h6bqoiqVyrtDXWtUKpXbFa0VrTWMMdE7Mw8nJHwSF9iTbSCEzOQzsWSGkFAojAKlNGGO2bZGhFFGQVFqjp2WiDxtFFPMlJwx2qCLuKwqFH3OpCw13dt/6d/zX/+vfwjAh33GF/PBL3gROWeyBmOURF/P2+6toXeKZWs5aCznlw1GibjJaEVjDaNPbH2kawzLxtJYRcwSXb2P2ZujsK9dY9Rhn0qlUqlUKpVKpVKpVCqVm5ub9pOdZzzjGfvbly5degL3pFK5tVlPcS+KOh2DCD+QD6pbK64zWqkbuvv4nDnsHINPaKXqh8m3GJ0zjCHTNZqNh42PHC9E9PJwDPO15GMmxEwuIjZqnaFvRPjS2YfGoy1bizWKk0Ecn3ZOVadDZPUYRHeHnWOjpKnTWkPfFPJsdhVSws6uVqvOsCiGw85xNgRiKWglj7905jnoHAYNqnDYO06HyBAiS2cYrWb0IvwS1yUFaGKOUAqpSIdHKUUCxpjpmoTCEkshlUKImd3L297zFt7yA9/EcP87UFrz7E//Szz9BX+B1u2m1QulKBIFQiEDWZX98TdK4azm/KJBaxEyWa1ZtBKLcmXr8bGAKtL4shptFL2ze/Ov7ewSF3PBasXxwnLUN6giza7TQY6p05qQNUe9Y9VaUs6cX7RcWk8MPnF+abjzoGXRXj1XD45abI3BLjQaOBkDKctzdE4zxszFVcu5hXtIfN6D2WvF1PVfK5VK5fFQ1xqVSuV2ZtGKMKprJI56CplL68AUE6ejp1CI8/9XGrTSjCmRktS0xmhIBTW7PxmjyTnPYigR35eSGFLBWdCaOea6MKWCQvF7v/If+Zl/8koAnvsn/zwf92e/RAYJpsTgI63RKKBvNH1jWXXiONs1sq6wWrNqDYtGorBTyhgja9LD1pGBZWuI86DH0byO2Q30KKjx8JVKpVKpVCqVSqVSqVQqtwg37ac7n/zJn8ydd94JwM/8zM88wXtTqdyahJT38XnXiqIWjeH8suGgc3Szu0/nDAed4/yyYTELXKaQOR0lZmEzRcIjOApVbj6OOodSsGocVmt8lGiNhyPnsp8gn2aBlKAwSrFsHUopDvobC+haazieo/N24pf1FImP8bpatnaOcVOElLFGcWHZsGodFw8alq3Eahx2DgWsut1thVJg5ilyYwCl2PrMqrcc9k6myxtxSWutmZsoloPOcmHRsOodjdY0VmMsqDl+MmUYvIgJU5YpeU3hnb/wb3nj//HXGe5/B/25O/lj/+t38OxP/Tyc02itCDnL8egsF5Yt5w4aWifT/a3Ts+hLYbRM6jutOOgMR4uGszFxZZjYhsiUIuMUUbNw6kkHHYcLy3HfcMdBy0HnaK28/lQKIRXWU2TtIyGXWRyp6BpNzIWYC5nC5W0g5CzXR2c56Nx1oqgd1mgOOsfxomHZWtx8HLVSlFIopXDQO5at4cJB86iiKBDRHYjbAfCIQr1KpVJ5OOpao1Kp3M44o/cOnYedo3WaEBP3n468/YEtlzaed52NTDFCLqy3ntOtxCk7rWmN5rCzOHM1vtnMdVxC1plGa6xRxCQuUk5rqWNT5u43/Vd++lUvo+TEhz7/T/MnvvArOexlrXm8cFxYNRwtHO0cD50LGCMDFnZ2icolz+tZEXQNIVJKobGa42XDuaXj3KKV4QGj0EpE+c5oVq3l4qrlaOGqKKpSqVQqlUqlUqlUKpVK5Rbgpv2Ex1rLS17yEkopvPa1r+WXfumXnuhdqlRuObbT1fi8nSjqsLcsW/uwYoOdu8/hLG6ZQt47Tu22V7k1WLaW1mic1SwaQylwZRv2wpQHM8VEQeLrYpEp8zFkSiks9hEXmkXz8M5ix0sRIanZpSyXwpWtf8z7vGvOHPUieuobIxEbzqKUwhnFhVXD8aLh4kFL3xqUgq1PKA2lFJwx5FI4HTw+ZEIUUZMPGZ8yaj42y8awcIbzq4bzy5bDZUNrDQYtk+3zlHtWUFImJgjjGW/6l6/g937iVZQUuPBhn8ALX/ZPedKzPxJrNL0zNFaiQLRS5Fn8c2HVSkMHWM4CLacVi1aEUgedpaAIKRFTJs9RdSEVQi40sxvUnUcdrdM0TsoDpSFmcYdLRURRJ0OgcwYfM6ejNME24+yKlQuN0VxYtjitxUludgZ7uOsCRMR00Mmk/3EnIqnWag47NzfXzCM+fkcuZR/p2FkRaLaPErVYqVQqN6KuNSqVyu3OqrV0zsgQQmGO0ysMITP4xGaS2n7wiTHl2YkUlk4GBBpnWFhD6wwZoGQUhZgyk08MPuGU1JilFErOoBXv+t038u+/9f9HioFnf/yf4LP+2jdw0Df0zsyiJUdrJe56t35YNhqrNH0rYqx2XptorfBJ4qMf2Hg2U8IZqZ87a/brgvOrlgurlourlvNLqUV3IvtKpVKpVCqVSqVSqVQqlcrNz03dLXzZy17GC1/4QnLOfOZnfiavf/3rn+hdqlRuGXIuTFGETLv4s8XshvNYaK3ZO0cNXh4/xUTO5ZEeVrmJ0FpxvGgAOOodjTWMIfHAZmLrI7lcf653jmHbKPGMW58IKeO05mB2gjrqHl50B2C1ZjlfV7u7nQxhf60+HLkUtj5y7+nA3VcGTsawf/xh77iwbDi/bDjsxQlt1Yk466B1LOfbq8YyTLLP6zHwwNbzO/eteefpltMhohU0RmGswmqZincGihLh1EHnOGwNy8agtcYYEYMdNuK6dvb7b+KXv/3LufTG/4wylmd8xpfzUX/pm1isjohRIvI6Z1g0jt4Zlq2ldwarFLnA0skxXI+RmAp9Y7jzoKNvHEe9Y2ENORUWrcVpET/5kJlSwVlN3zhyBqM0k89c2nqmmMm5iLPTLFjLOXN58Gx8ZAoirNoGEVmdjZH7154pRk4HT2MNZo7LOxvDDa+LHc5oxpAYo0Tzdc5QQGJcnH5MwqjBJ0qROJTGzvEq7rG9Z1UqlcqDqWuNSqVyu2O0YooSgacUdE5TSmEMmVxEDFUAjWLVGihwZQpspkBImUThZDtxZeM5HWQNEJIME/iUyGRSLoyxoI3m9O3/nX//D7+SMA087cOfx2d/5d/BOitOT0ZjFTijaJ2hKEWOha3PDKlQSsYoEfaPU2IKie0UuX89sfERZhfYaXa57ZyugvpKpVKpVCqVSqVSqVQqlduEm/pTH6UUP/7jP84XfdEXce+99/K85z2Pl7zkJbzuda8jpepMU6n8QRiCTAD7KDFfSkHfPD6BQd+I207M4hZTuCqyqtwaHC2cCOac4dxSxFHrSSayH9h41mNkigkfxR1qM0VONp7TQZylnNYcLx2N0fSN4bB/aNzaQ55zvk9j9D427nSIbKaHim5iypwOgfvXE+86m7i8kYgPayQ6LqRCofDAxrOdxE0ppCyORbNr0oVly6q1tI3GaM3964mTbcCHzNnoGX3Cp8wQisQFpsLaJzSFxjpaO0+uG82ydRyvGo47S2MVxhgaXXjjT/4rfuYf/BXGB+6hO/9k/uhLvoM/9MdfRGMUKcv0PUDrDL0zc6Sfmo+bRgOrXqLyQIRgTis6Z+md5q6jnnOrhkVr5f5KGlhKQddoOqdJqbANEaUglExJBTOrx6xWOKuxRpMKDJM0x5yRqJJlY1jNrwkKoIgZNj7N50sxBHEGuLIN110XU0ysx8jpGImzcPKgsxx2bt+Es3NEyiMxRRHbwdX3qtaaOu1fqVTebepao1Kp3M6cDIHNFFm2ls5pxpBZT5HBJ/w8lFBKIUSpgVMRZ9icC+sxcv/ZwH1nI5uQ8TFzMnhOx8h2ikwhM/k818wiwBovvYPXfstLmDanPPUPfQT/09/6VrDNHGstgwAZRQaMkkjtYVdLDoHNlBm9uLcOUerzB7aekzFIjVgybo7KA7i8DVVQX6lUKpVKpVKpVCqVSqVym/DweUU3Ac985jP3t5VSeO951atexate9Sqcc5w/f56u6x7z9pRSvOUtb3lv7GqlctMxze4s4/yhd2v1Izr53AitRLgxxcwYE42V28v2Pb67lScIZzR3HnbcczIAO8cixRQyJ9Gz0XrfaLgyiJjodIgAnGsdR0vHspGYjourFmseXa8r7kaGySec0WxC4srWc3kjLlatVawaS0aiPnwUsVNIhSlmEUVpxengWbaOzolASilpAO2EUYedY6MiW58kvg/FUW+597RQUKSc8LGQSsGoQk6FohQlZ7YeTnRAKU3rFAoYQ8YYRa/F5cnkjJ3O+A/f+Y287fU/B8BTP+aP85w/95UcHB2RUibkwpQyK+dYOIOd4/eWzjCFTNKFxpo5Hq+Im9WUMEax7BwpJ7QWR6rRz7+DQ8LnTOs0x7rBGli1DqMVC2swVlGKOAL0jWHr5XylUuidZp0y1sCysZQCmYLVSkRIChYNbKYocXtJJvKP+wafMoUCRURMU3zouV22hpA0jdFcHjxNLqQEWy9NuRuRS2HwV0VRrRO3KYBFW5tblUrl3aeuNSqVyu3Keor7OPTTUWKTd1W6MwprNaFkjAZUwViwGnwqrIdIKiKaKkDKmZwKMcvtIWRyzmitUamAg7K5zM9821eyvXI/Fz7gg/lzX/0qFssV6ykBgSkUfE4YFL4k1kMixkxrlUR1F5hSRGtHKUrqwcYyhkhrRNzft46tT5xbOqxWXN54+sZw16G8j1dBfaVSqVQqlUqlUqlUKpXKrctNLYx661vfirpGqLG7XUrBe88999zzmLajlKKUct22KpXbnZ3zzi76zj0GwcqN2Imhdtt5uBitys3LqrXccdBxaT0B4uQ0+sQ4x274IG5hYRbbrVqD1obD3rJsLH1juLBsbyh8yaUwBnEWynODZesjl7eeGDOxFNpZwDN6cXyKCe47nQgpY424KaUClELbGBqjiVket4sHORsjndVYrdj6xLvORu467Fm2linKdPkUEkorFq3lbIqEnDFa0ShxXvIp4ZRCN4ZYClNKXBkmGq9orcUaBXuxYOLSG3+Nn/3HL2d75V0Y1/ARn/0SnvX8z0TpQskK21hsLBRV0AWMUqj5b1XKZY7+0DSAprAOaXbNApPBOQ1oLq5acpYGV0wSfWe1wceENdBaccc6bB0XDlpCyigSVonAbed2Nc1RI0cLRyng5xjEGDO6lb+fSokIbNFYlm0k5oxG4VOmMSKS651hjImS5fxqpVBaIkys0Wy9OBFcXLacmABZIvLCNdtQCtmHKFEsu7eV1mkOOxHoLVv7br9vVSqVCtS1RqVSuT0JSVxeQURRlzeezRRRWqG1RhtNyRJX53PBGUNn4XSU+j8X8DFJvRoLikxB7d0/rVEkZSiloBXk7Rn/6R99Jet3vYOjuz6AF33dd9GvDmQNWRJDyEwhsZnSXpDvo8TmWSMDB4vOsGwsVhsWjeaob0il0DnLqlV0VlMQd6iY4J7TiWVjSEW2B1VQX6lUKpVKpVKpVCqVSqVyK3NTC6NAGhPvD9uoVG41dr8Wu6+P1y1qx+5hD95e5dbiqBfHoZOtZ+vFsceHzJgSJReJqTCKXAoxGUqBtjEc9Y7D3j1EFBVTZjtH1F17zWx95P4zj0/ifrSZElP2HDhLKpBS4nSK5CyRHClLNNxx7zhYNDRW44zaC7JCEvGWUYr1FBEvKMXlTaAx4rSUcuGgdVgzUnLBWUXXWBH7OYnyyMwiwCRCn8lHaRiFzBQgt4qLBw0+Fgbv+fXXfC+/+MPfTSmZoyc9nT/64ldw4WnPwlrNqrH42cGqpMIYIgXFlBJDEIcokxUhZUYvjlYxJVIRhzdrxDHLIs5YZR9rIr+PSin6RtM4RUwFVRQ5w7KzaAUpF4zSdHPkXmPkGAB0zmC0YjPJ6wtFml9q1h/thuwTEme3E0U2RhylQsroRrFqbxyZqBScWzQcdJmTbWTVWGDXsBIR287N7lqslki/nVNU3xhWD+MwValUKo+HutaoVCq3GjkXhpBm4ZHU6UrJeq+1Gr9zDvaJe09GToZAa7XUzT4SQiHkxDZkQsxk4HJOKBQoWE+BUiRe2WhQymAVpAw+Z3IWUb/WiuJH/us/fRmnd/93FscX+Qtf9485d/EuicMLGas1CvnaNYWSIJbMQWs56C0hFbSGJx8uaBuDUWCMYgiRmMBZJa+rMWigsWbvhLVsNAezi9STj5sqqK9UKpVKpVKpVCqVSqVSuYW5qbuGL3/5y5/oXahUblmUfJa9Fza9u05Pu4fttlPNEm5dVq2ltZrtlBhCZAgJH83e6alvDEPIKMRtqHOGC6uGxl4/nb2Z4j4WDUQkNcbE6RgZfeJsjKScaYwiF3Eout9PGKWxRhGSXHTDGFFK0TjNGDOHqnBh2dA3Zt/46JxhWQpOK955Ig2dmEWI847LW5QSwdN9ZxNbL9F2GviAo55p4Vj7tG94pyJNprMhseqcOC8pxaI1hFhYD4nNybv46f/j5bz9ja8D4Nn/w5/mk7/ob5BMRyqFw87SWsN5q4lFGkepOE62gSnJsdv6KE0oBSlB6zKqKLRRLK3BWE2KEqt3tHBYoylI0ygmaYZNIcBsgo0AAQAASURBVFEKLBpD25i9+5JSch8oxJRBiegoze8FrdXMxlGkLE5gSonbE8ixAggp0VlDaxNnYyAXQ2s1i3aOETRqf10opUSAZUVQp5UI6NajOBUc9Q3WiKBNa0XO1zTwtKKzZv+8IE5RVRRVqVTeE9S1RqVSuZUIKbOdElNMPGRlVyBRmGLi8sbjjObuK1subwOdM0wpM3qJwdv4yDaIqCpRiFHipRsrovuSi0TpKei0orEaOw8bmKywIYuba/S88ftezunvv4lmccif/Mpvp7/wJKxWaBRJy14e9Y4YC2gHpbANEgltiuKwVxx0js4ZnBWn2LMh0VlxhrVaywBGgcYZeie1aFFgtdSPWisWrrpFVSqVSqVSqVQqlUqlUqncytzUncParKhU3ntopUjzJC9JRBbdu/GB8W7iWM9WMu+u81Tl0Xm06e/emf15eG/hjOZooTnI9iH7klPmnaej3NHLNXXf2cSqtXtRzGaKjEGumSkmicebX9c4/zsdA1NIGKOwSvOk44bWOnzciaYkbm8KGWc1XatZtY6YClPMHPbXuxVppThaNORSuPd0QgGbKXFl6ymAM4rLW4/RCjc3WKaUCKngtIixjFY4q0VgdJDwMREzFAoUOB0jb/uNX+Sn/tH/xnD6AK7t+dQveRnP/IRPp2/FSamxhnN9g9GKVS9/nq9sPGdj5NxSpuxPx8A0zs2mXHBWYu6UUnSNZvSFnAtaaxbWMEyJbSPxeiHK8Ugly3UwN6xOh4AzEm83zoKpZWuJqZCAmCIKxWEnoqWInJ+QipwDrbFG4u127xFbn7BG0xiN0RKnOabEgXUYozheNI94HQ0+0TeWrjF0s9PUYe8e9v1DAa01LFpTp/0rlcp7jLrWqFQqtwrrKe7j8UDWaGNMDxGc51zIBd5xecvvPbCls4ZUMsNUWE+emOb62mmGSbGdMlPKlAxnYyaXjFaKogoWiUvOClpjsK0mhMSgI6OP/OYP/m2u/M6vYpqOP/rlf4+jpzyD0zEwxsRx33B+2UgtrjXbGImxEHKmcZaD1lIKHC4sFw9aTuchgsYaVp3DasWyszgl7qldo1l2js4YjFFc2QZiLjijWLWybrlRrHelUqlUKpVKpVKpVCqVSuXWoH7yU6lUbsguLqGzhilIfNWylMclbMql4Gd7mZ2jTGuraOE9zWOZ/g4ps5ni+0w8orVi2VqW7TX7VwrL1jLFTGsN6ymyHiMKCMlw/3oipkLvRKQzzQKplMscx2Y4GQIxZaxRNEamzzdjZlCBrtHk2QXJGsVokihmsmYbAp1rubSecEZx2DnGIFF94lwkEXM+ZB7YTrROS1SfjzywDQxjQmvIGcacWVhDTpCzNIfOLRrMToQ2C7we2HimkHAm87of+m7+ww/8EwDufPqH8Odf+vc4evIHEUvhqHXELOdo0WkMmpLheOFYNWZ2q4qcjpHWGFaukI2iKIXTGq3FcakoaEyibxyL1pApnE4BaxSHi4bWaXpnKVnEWmMQhyylFTFl7r4y0miF0eIwZbSidzJhH0pmiAobEjnLOQ2psDCGRTO7RRm9f39ojIihusbQhMRminRe4kryo5jPTTHtHcMOZweAxsj5eCJFf5VKpVKpVCrvrzzSgMQ0R8dprRh9YggyePAQUuFkCAw+ce/JAMDl7YRCzcMCmoNecTYlFtZwAkDBKEXUhclnCgWrZR2YlNTqTmtSKfQadGvQGt78g3+fe9/wn9HG8fFf8k3c9aznkHJh4SyKOZ5ZK3qnWTSWO21HzAVVCgcLxzA7Vi2ciOgtim1MlCwutlZLva+VxC0vmqsffSlg1Yrgf1c/TjGzbN+LJ6hSqVQqlUqlUqlUKpVKpfKEUoVRlUrlhvSzuKOxGqslXmzwj2+SdvDiPmPnCAU1b7fyB+PaxsfZGNhMaW58yM/nFMQbxo2NMTHG9Jjjxv6gLlQPnk63WnFpCuRcGGMixMLGJ1atRLRppbi8DWgl10rfGHxM+KQ4G8IsNNJcXDWMUaLlYi5kYAiJRWPIWZycXG8wqjCEzOkg9z3sGt7+wMBhH+ib61//egxYK6/lnVcGKBprwIdMKgUf53i5AtucsEbhjDhGpZzpO8e5RYNCRE1PPdfz27/7Vl71NX+dt7zhlwF43p/6n/jUv/g3uHi8YvAJpRSHC4szmpjgsHfkXEilzMdZc7xo9o5MZo6dC/N9Wq3pWoPKhW1IFK3xOcOkKEVi/+4vBZ/EwWlyGWc0SmuOloaUMqA5mwJDFMHZUdeIoDEptE6EIM5Qy8ayngKbMYJSs9OXYdXJcdwJpHa3dwK41io2E6zHyKKN1zWmrrvWirzH7ERRrdN7B6pVJ8eoNqwqlUqlUqlUrvJoAxKnU2Drk0RZz7HJu7qytRo3C9tzEZH+/evE6ejFpTQlVFHEUjhoLeeWDZfXHqUKbWM46B2bkNApY1TB24yPsn6AQioZHxXOKEKWgQerFb/5I9/J7/7C/43Shk/60lfw9I/8BGKGxmn6xtBYcXs6t3AsnKOxmicfdaw6y5WtZzOvMc08iNEYiWt2Q6AAy8ZSSsEaxXHfYLTer5UaI/WlT5mzMc77+u7HxlcqlUqlUqlUKpVKpVKpVG4OqjCqUqncEK0VrRXnnt4ZzqY4x2PJ/380rnV96ZudW1R1dfmD8ODGx9kYrsbOhauxcwpws2jJGg2pMIWM1YreGbpGRG+5FA4795ie6zqucaE6GwIZaUwYra6fTo/zdLq6fjpdK8U0u5HFHPEx8fbtRMkKa+TaU0jjxCXFA5uwF83kIqIjnwpWKzpnMFrJ/s7X22xSxnFv6RtxmToZApfWga3PLOdJdYBYCiUXtj7JNL1WFAoxQ4iBYZsJsXDxsKEUiDljtNrvy9YnXIajrtlHAu7Efz/3H17L33nZ/8rZyWX65QFf9NL/nWd/wqeQi8JoWHQOpySKZBdTEnOmMZoURZCWZ2GhVZqDzmEQV6wOOOgMMYI1iilFzqaEMZpYMlNM4s6mNdtJBGir1nD/mefiqqFvDINPEodiNH1ryAWMgdaISE2pAihCjGxjIeW8P3cLZ+gby6o14kLWzNfajDWaRWPY+sSydaynTMmZwUsEYWvFAUopEfD5mPEps+tJtU7vr81la2s8XqVSqVQqlcqDeLR4vJQzp1OkM4YpXXVjvbBqOL9sH+IE3M3uS0aJkGk9JjSKRatxVmrKXR3oY+J46YgxczpGrgwepzXYTMrisgoyYGC0whpFyYX/9pPfy2/+1A8C8Ee/8GV89PP/JEZLbHWjIZXCqnM4rVm1lvNLqVuPlw1KQd9YjhcNZ6PU9W5eg+gi+y+1reL8qqO1+mHjm9W8f7vas+qiKpVKpVKpVCqVSqVSqVRubaowqnJD3vjGN/L617+eu+++G2MMT33qU/nYj/1YnvGMZzzRu1Z5H7JoRRjVNQafM1PInA6RRVPoG3PDWL1Hcn1ZtI8uqPqDOhTdqjy48XFl43lg8JRcWE+JEEXU0xnDsrM4I5EXRolIaoqZmAtnU8TnzGHnGHxCz84/N3quXApjSKzHyBATOUnHQGuJcGvmWMRdH2HRGJatJafCAxvPyeApKIYQifNjnZHnM1oETEe9w0eJWoslc7KOaK04Xrj9fhTkuipKriGFuGJ1zrBqHc4ohjmubQoyob4Ta2mlOOodp2NgG6IIcXIhxMIwi6RSLqznY7sdRQB4NnhaaznsLadDRFGIuZBiwTWazmpCLpjOknLh8hBQWgRlqtX8n//wG/mh7/1uAJ71nD/MV/ztV3HnU57GehIx0hgzR53lsLOcjZFSwCnNNiUw4LRmM0XGlET4lUVQNMaEM4qD1qG0orfiiLUZ5f8f9m6OvkyzAwBskmKMmcYpjIGTIUjzyphZdKQ46BrOLcCnTEqwcGaenC9kDdOUZ3GdZtkYOmfpZpeBZWNv6CS3bC25FM7GwLIxgLjPKQpTlHjOB2O1xJ3s3jP6xjwmZ7NKpVKpVCqV24mTITDOEXkPF4+3HhM+Zs6GiA+J1hkurFpAsZkiBw8akMi5kLIMHxilCKmgVcYaS0xZovJK4Xgh7qLj1rNsLbEUhqAJKaJ2qvfZwjbmjA+giuG3f+6H+M0f+x4AnvcXvoLnfvKf2a8n7zzogYxBop+XraW18tVozbKV+lArRcoS+dw5zaqz+6GdRSvrlmbvgvXwx28nhNotZx9HWnylUqlUKpVKpVKpVCqVSuUmpHYbK9fxQz/0Q7zyla/k9a9//Q1//omf+Il80zd9Ey94wQvetztWeUKQ6CrLZoocdo5TAlMQZ54hJBrznnN9eawORZspikNNa24bF5kHNz7OxsCljQdg4xN+dmbqjEZrSCnjtMFZTSrggPPLZi9Ym0LmlMBh5+bjqffH8mQIrMcwi4PCDZssQ0iMIe2jEftW3IIurSdKAa0Ka58xCs4mmeYupXDUO1rrmGKhMQatMiEVYoLjvmEMIkoq8wXktGIbEkedw+c8u0hpjFa0cwyGM9LFaGeRVipXxTYhFToHU8xYpWmN5nQMNFpziKKxmcZafCwctI4xiDhqComMRPTFIIIynwsKRdtqWmsw2rLxkZQypz4TVORshHvf/lZe/cqv5C1vkvfQz/7Cv8z//Ff+Jm3TMAYRRaVcaKxCKTi/bEm5oJQiZ7nGp5BYdY5tkJjEzRRFRFRETLZoDDFnYsjSdEKx6i05F3IWQdyFg1am+VPGmsgYM9Mk97dG0Tfy+9hYzblFg1HinpU9LBvNUe/2jlWHrSOEzNpHul6z6i3L1jCExAec6/dRejdi2Voubz0+SoyhsxpnFFqrvZvBg+Mer31sFUVVKpVKpVKpXM96ivu1wekY9k5Q18bjAbJGUFL/bn1ijJlEYekMSinOhsjxwongSCvGIBF1p1PEx0xMiZALzRiZtEbpeU1nNQet43QIRKvRSp7TaoUphWIUKoPSikQGpbjnV36SN//IdwDwYZ/xxTzrBX+OKUQao0CJEEspMFZJlF5rWbSG40WD0WofxawVJGTbJKmdd8Io8Zy9GotXHsEGys8C/d3AzY0GfiqVSqVSqVQqlUqlUqlUKrcO7/cdxy/+4i/e31ZK8T3f8z03/Nl7ggdv/3YipcSLX/xi/tk/+2ePeL+f//mf54UvfCFf8zVfwyte8Yr3zc5VnlBWrTjijCFx2DlGkySCK7/nXF8eLQbiwcKJMSbGmG4L4cSNGh/rKc1itIIzitY4cVJScuzi7IDkc54FPxmt5HhZozgdIlPIjCbROcN2ShwtNOspcmk9iShqCvidKChJDN8uQi7mjFGKKSTOxkg6lf3YNSxSLow+cXnwjF7iLJad4dImM/rIqnWy/woaozkbI4OPbKaMQmHMHKVnNV2BmGdxk9YctoZY5P26vUZEo5WiMZoxZnwU4ZGPeX/tOqsIQ8GHgmkLWsNBZyW2T0mEX/HSbFl1Dh8z6ykSQsHHzGGxQKHRht4ZWqdRiDBt2YoA7Bd+6sf5se/8eqbthtXRMX/jm76Nj/1jn8J6lOO9HqXJtOgMjTY4I4LApx73rGfB2hQT9595rmwHfBaRWIiFEDMhy3H2UbENEaNFbNQ6wxTBOc0YIovOctQ5Fq0j5cyqtVxaT5zmwqI1xFywSnO8dLRaIkdsY2jQ6EaRS8GnIhGaQ6RxmkVjUUquAYMc63NLx0F/4yjGHYNP9M7SW0PrDCGJW9nDub4puO2Ej5VK5YmlrjUqlcrNxG5QBK4XRS0ac52j79ZHtFKEKFHNAFrLkEXKhVVjOR0DSkk0tNaKk61n6yNnQ0RphQZSKkwhEXWmFBFPtVbqR6PULNxPxFJE+F4UOmciGZXBWsUDv/nz/NYP/T0AnvnJf44P+bQvZEqZhKaJUp9OKUGRWO6TIXDYNfMAgNTnOxqjCSnRGYMPGR8zuZGo7jKP1+yOgXoYsZPUunJMOruLfK91Z6VSqVQqlUqlUqlUKpXKrYwqjzRG936A1hqlFKWIo0ZK6SE/e09wo+3fTrzkJS/hO77jO/bfLxYLPvdzP5eP+qiPwnvPL/7iL/LDP/zDhBD29/mWb/kWvuIrvuKJ2N09b3zjG/nwD//w/fe/8Ru/wXOf+9wncI9uXR6veGnHo4mXHksMxLVYreidoWuuiq4Ou0cWZ9yshJR5YHaG2jU+cpHmROsMZ0MgZok13ImSdvF3wxxl2DiZ6AY4XjickYi2rU9YrTi3bFBIpN3bLm8ZQ+ZsChK5ETPWiABJK7V3igIRBKUsQqbddXG8cBw0lrdd3pBQbMbIGBNaQessnZProtWaxl19/04ps2ytiLlCxrmdK5MSUVUrbkgxF7SCXKCxZo5nY/+67zkZubz1hJixRuLuVp0DCj4WroyeEApHC4nlePJRv4/iSLnwwHZi6zNaFe47nQgxS4RgLtxx0LJoxF1q2RpWnUUree2XTtb8y297Jb/0734QgGd++B/hS/+3f8iznvlBTCETsgjLppQJIfOB5xegwCi1FwHlUriyFbeuK2NgPYhILaS8F6OVonBWQyqgZ8Fh73B6Nx0PvdMcLRqWjd3/HoaYeWDrubzxjDEzTIFl17BsDHcddoBEFGolYrKNj5Qs187oE63TpAw5Z1KBo97y1OOFPE979dp7MFNMnA5ybRx0ls6ZvctcjcqsVCrvL9S1RuWRqGuNyvsbJ9sgQyI+cTbX4If91Ti5HXdfHjgdw95d1mpFKpmzQQRBfSt112HraJxm8InTIWCM4vfu37CeEpfWo9T8KdM4w2Fn0VrTzrXc6COnQ+D+9cQUM+spEJIMSfiQQcP2rb/Om773aygx8KSP/TT+yOe+lNbJsEbK0DWG3hhCKTQGVl1DawxPO9/ztItLnn5hybIxLOb1ZM4S2V2Ak62/bi20HiNTlNp1F7d9vGgecgxvtBa6uGprDVqpVCqVSqVSqVQqlUqlcgtzS1itvJ9ru97v+Ymf+InrRFHPec5zeO1rX8sHfuAHXne/X//1X+fTP/3TufvuuwH4qq/6Kj7lUz6Fj/iIj3if7m/liWHVWlqr93F3jdXXCaCu5bG6vjyWGAitxMEmJHGnirlwNrshHXaOwSe0Urekc9R2uioY2x2bxiq0ssQkx0IptXfmAhGYLBqL1YqzUYRGk5HJ7sEnXK/pG7MXoPmYaazmbQ9sJW4tJC5vAj4mVq2lmYVuao4yXDaWK6MnzlPWhUzvNCjF5W3g0noiAxok5k5p7NxY1ihQsI1JhEFGXJcuD2E/se6MxONpJZPvucg+Dj7SN5aQC0apfYRezFnER3NEXZqn1VPJXBnFWQylON16fC4sG0sq0rABEe90znBl8FxeBxLidrXxETtfVyUXRp9ZdYpSMmnep84ZLt/9Vv7+S7+ct/3Om1FK8cf/5y/ls1/812mcI6RMLmCVpjHQWku3Mixbi0KaWNbIxP39m0maWwUWzpJT4VRL0ylSCKlgjJImEmCMYtVZGqVJFHIqPPXcYm56FR7c18mpcNg5bEg4ozjXN1ijgMKqE8Fc7wxnUyBEgzZw2DtYFDon19PaR042gVzAp7w/Nw/uN+VS9rGNIJGau2t01dk5ovM99VtSqVQq733qWqNSqbw/kHNhmiO0h3kNtWjMQ0RRZ2Ng40U0NYbIdrq6drNGnFiHSWrq399uWbWGvrFMMTEOmbPJk7LUlNM8cNGmQsmFXDLOWlSBK4PHR3GyTbmQEsSYJPbaKU5//828+V+8nBIDF5/7SXzYZ38lBXGdsllL7HcurHOchx8UcRM4vwRnNTkXtlPkwvJqsam12ovsO2dYT3FeD/IQF6gbrVWneLVG7ZudW1QV5lcqlUqlUqlUKpVKpVKp3Oq83ysJ/tgf+2MPO6n9SD+rPDZyzrzsZS/bf79YLHjNa17zEFEUwEd+5Efyr//1v+b5z38+OWdyznz1V381r3nNa96Xu1x5AnFGc7TQ5GwZQvoDub481hiIHZ0zLK8RXEwhc0rgsHNsprgXUt0qPFzjI6QMFBH8IB/4P/hYyf839I0cr9GLMMrHTM4iHGrMPOkdE5TCu85GDvqGSxtpcHTOcNg7Oifn4mwMOKPxMeO05qBTKIU4AimZvA4pc2UTuPOwZZjdpvpGXIV20YsGcNowxoRNIuxSCob5/FstERmbGNhOkYJi0Rge2I70s0Bn0Yjj07UOViCCvM2USLOALqTEopUJ+ikUUskEkzgbpcl9OgTOxoDVistbz5UhzNvIKArWaZxRjLngY2I9RjqniTEzKcV/+okf5nu++WuZxoHDcxf53Jf+XZ7xh/8oKEvnRPy0aOWa1Eoi+5501GFmZ7Xzq5YxJC6tPU5rLi4b3nkycGUbKMCis+KIFi1DTDilKCiJ1NMKZw05F5aNwWgt+5akeX+t6VpIEiyilQjOrNZYq+YmmqIxhpgzSokoqxRwWrPqLGZuPo0hc2HR0jnN2SANNqM9nZPITIl2FCc5nzI7DUHr9N7RbdnaW+p3tFKp3BrUtUalUrlZGEKicDU6W6mr4p4dmykyhkwBNl5qtlTKXNPJOutsDJQMISZiygwBzqbEdooinlJG1lezKN/PUdUxJQwKdEYhEXxbH9mGSAwJnwpFKUCxvfetvOl7v4bsB44/+KP58M/9OtrWYY3eu8AaFE7D6RgxiCvwJnucLgxTAmToYQgSCb6jbwxTzLTO4HPGh8z9a3HZXbYGazRKcd3wyCMJ9xft9cewUqlUKpVKpVKpVCqVSqVy6/F+L4z62Z/92XfrZ5XHxk//9E/zhje8Yf/9S17yEp75zGc+7P0/8RM/kRe96EX8wA/8AAA//uM/zu/8zu/wrGc9672+r5X3H7SWeLM/iOvLjdyQbhQDcd3zKnleaxSnQ2QKmdGIiGc7JY4Wt47o4uEaH9NWjlWelS8756Qb0TnDODtDhZhxVjMGEQvt48xy4fLkSUWmy7c+opTESeyaBXl+PMC0F2lZUi4smsLJNhBzZjMlrFVMKRFDoVjFhaVj2RpOtl4clFDi6JQAk9EoemdZOFhPAUVh4wO5KDZToXHiGKaVZoxZHqcU08mA1SLuSVmaNZfWntFHQKE1jFPGZ0/O4GPCGY3Vio2Xxs96jKyHwNHSMfrEeoqkUgi50BqNzoohsBee3b/23HnYUKaB7/07r+DnXvtvAPiI530S/8s3fCv24DzbMWKtZkqJVDQ+JRaNwxrFuVXDU88t0ErERj7mvfDoqHdc2niOuoZFY9HqqqCJItF+mUJvpZkUcyGWwuQLVomIaYoZo3ZOWoUGaQLFnCkUcZuadu5riTDf/6ATZzCtoCDuAcao/b7dcdDiUybEQmM1OUs8XyniOHA2Xo3Y3GG1om/M/hrqG3NLurpVKpWbn7rWqFQqNwvTXI/vBiTaBw1IxJT3wp+tl1js3f1Wrd3XZdFJ9PYUC6vOspnS3qHXGsVR77i89UwyP0FKMmBgtSFqUEnqUIlWjwyTiKIoBaMKZ5fv5Tf/6d8iDmccfMCzee4XfAPaObSWQZbGgpqdZKcoQzaRQqRgrUZrxckUuPd04tyi5XQINNcMwTijWTSGrU8ctI5LcdoPS1gjAx0HnSXMYv0q3K9UKpVKpVKpVCqVSqVSqdQu5W3Oj/zIj1z3/Ytf/OJHfcyXfMmX7IVRAD/6oz/KV33VV73H961y6/JYYyAejtYaFk1h6yXaoXOGKSZytrdMDMLDNT52cT67D/Yf7Ba1O7a7GLfNJJPgPmWOe4dRikUrDl8gsRdrn8RBaRa4HHbuugnrKYpIK85NEKXE1eksiIvUbg80oJQ4CjmtaWYHsZQLeb7PJiScBmv13uWrZImGm3xkExIpaY6XhpMU8b4w+UwsmdYYhphIObFsHX1jONmMEvMRE6dDACVioJQQoU+Bk9ETY6FxmphkOt5azXEvU+j3nU5c2kzEOaavNQbXSYMkZhFvTSFjNPzWG3+DH/zmr+Let/0uSms+68VfwZ/5vC9DGXHkUkrcpXIpHC9aOqu5uGppnOZpsyhq2VpWrTRr7rky7uNHrJZ4vJ1QKabMfacjIRe6JqJUgaxQSs5lLJlTFdFanKDmfhTAfP5FfBVSZjMmNipxNgVKKdhBRE9Kw9kUWc2v1cyix/PLBms0y9awaCwLxIFgionGaFaNNNdCyTijrrrGzW5Y10aX7F5vpVKpVCqVSuXdJ8+F3tUBiesFPTtR1E4ADxKNnEvZx0iDOM5e2QaYRU8KWDiDUTLgsPYBrTRn48hmTCQKZS74tVKgMttBhFdjECF/zhmtFNsr9/PmV7+UcHaJxV0fxMd92TdjuyVFgVKKMYrblDMajbhB7Zz5Jp84WjgOe8cUZbjj8uAJOYNSPPmo27+GZWsJOXMyv45le9X11MdMTEWcba+hCvcrlUqlUqlUKpVKpVKpVG5f6qdAtzk/8RM/sb/9wR/8wXzwB3/woz7m+c9/Pl3XMY4jIK5RVRhVeTw8lhiIR6NvDMPshuRjprH6ITELNzMP1/hQc2bZTti0u5/EYEgT5JoUNaxRTLHgQ2ZrEn6OuNvpx3bxejEX4tyoWHXXH0OJ74Mxpf2+hJT3YiltFHEoOKslSiMXtCpYoynI+dmJumLKkDWrztBaLVPourAZI8ooSpDneWAjTZbGKFJW5AypFHIp3HM6cdQl3Pz4KWVKhtYZYgKtCjEVGmsYfCIHeVxJhXs3W0KGw9ZwaT3J63GGECUaJBqNVjJFb7Uiz+dAqcIv/7sf4qde/feIwXN8x118+dd/G3/oDz+PWDLbbRCnrFygiHDMKsWidSzneMj1FGmtRBOOIUkzqmSOF477QsYaicOTaDqFM4YnHXeAonMSe7IZIyRonIaAOFtpRc4K5qaVQgRS6yFweQwMswuAQq4dnwpnk2eJw8eCLiPloMMa6J0lZ1h14jB2rUBu2VrGmObzCc5qFsZwvGgecv3+v+z9ebxtWVnei3/f0cw5V7P3aaoVECkQY3ERVISgMYbYEKJiUK9EUSIam4QYYxQTVLwKhkaNubk2xGBiEvmZ2KASTfT+RPLRJCA2EMWiifQoZVFVp9t7NXPOMcY77h9j7lXnVN9S51SNL9TnrLX3mnONNZtzxljv8z6PMAkYW1u78CuVSqVSqVTuB44E8LfXIKE5Mx7N2cfJKdWCNcLp1ch6KI0TIsKYEgfbkdYaNBsQYW/mWeTMez96SD9mkir9qEQtInjNEHNmZkCso0tKP0YMoFOUc9oe8qevfQnjmRtoTlzNp37DqzDtgoTQmDJXVc27GL+QFOcMjRGcNVhg0XhaV+aPKSk3HQ6olrm5NZljs2bnAnUUIQ2w1zmWrSdExVjonK3C/UqlUqlUKpVKpVKpVCqVyo76TdDDmLNnz/LhD3949/zpT3/63dquaRqe8pSn8KY3vQmAt7/97Q/I+CoPXe4qBuLuYERobImD62PaRcPdl3i/i4k7KnwYgUT5gp+UCSmTNLKdOsShFAoOx8AYlDEo2zFineHy1LJoHduQ2AwJY8p+ci4Cp5yL6MnJhUKWXYP5eSKtcXL6GlIRPXlniKqMISFiMKZEZAxRdx3qR5/FWzM5TZW4tn4I5VrIsO4TY0pEhUVj2J+3HJ87+lBEYZqLgOvGwx5nLYvGIFnok3LYK523WDF4K2xDKu9thBSVgyGyCaW4c7iNjDljBXwqgjA1wswYGlecrpwr+7np5tP8l1e/jPf+/m8BcO3T/hrPf/GruOqKKzEGUirHPKvQTYWjE/OGy/cakpbDlhG8NcwaW8RsGTZDZD0mwiYwRGXZWq7c724TiXJmE5h5wxAta5PYbMuxt0Z24rBMEcvlSQB10I+cOhyxFjrn0BRL5GEqnfnOGISIIPQxc/OqJwR4xImOq451bMfiDHXrglvOsNd59lqH5iKGs+Y8x6jJJWzm7UPGva1SqVQqlUrlYkCKtug2DRIAfUjTnL40nlhbHE+HyT005cw2TFHbYyLmTIwJYqJzBmc6NMOYMn1MbMaETEKm5cyTkzIq2Cnqbr/x9E2CkEhqiJst737t99Lf+EHc8iSf9HdeCfOTbINSUusMZEFEyCYXpyoRvCkNAM4Ke63j5LKhaSwfd6xjGJV+TBzYwF7nuf5sz3ZU5s0tX2Ptd57LFk0Ze1T2Z/42TR6740cV7lcqlUqlUqlUKpVKpVKpPFy5pIVRj33sYwG45ppreOMb33iv9/PFX/zFvPOd70REeN/73nd/De+i513vetcFzz/xEz/xbm/7uMc9bieMOnPmDDfccANXX331/Tq+ykOXu4qBuLsciaGO9nN+ceBS544KH40zhJTonGUIyunNwGxyIdoMkcM+0J/nGhWSMuaMC5lzfWAzxebFnOmcZd5YRIrIRqSciws9p25HpIUQp/i6dV/ENqMmhlEZguIsOHEgTCIcQbW4NiFwZEKUKaKhc9uAKmxjAslInn5JiefzVkhqdwWfWWs4t01styOnVoqhdMTnDKFTGutogYPtSB9KXB4C2zEVAVRWkhr81J3eNYKRci2dGwJIZq/zxJj5sz+9jl/65y/i7Ec/grGOz33+P+ILnvt1POrEohSdTHHPWrR2isLzhKTMG8tmTCxbz4lFgzPlmJ3djDsR0WqIWJGdCxOS2Y4Xup45a5g3lu1oWDSWlBzn1iPrMWKlRBc6K2jKGBHGWOIli5ta6aQfg5JUy3kVcMbQekMGhMw2RMYkNLa4Ws36kcsXJapkPcTdeLZjOf7OCF1jEeDyZVsFUJVK5SFLXWtUKpWLCSNCIp/XIKE7d8/xvMaTbUhoPnIRLa9fbSOrPuKNcHozMkRFDLTWknPm1GoganFr/chm5HAb2cbSmJA0M3OOuck4YxgVVARrLRIUkwPv+7kfYP3n78bOllz7glewd9WjyJpxViBDzgJGEDJeDI0xOFuaKZwVlo3jqv2Oy/da5o3lxLzh0MZpTSBEVciWEBVpy5ro1i5QM2+xpjRmHAn6q3C/UqlUKpVKpVKpVCqVSqUCl7gw6oMf/CAAzt23j/GRj3yED37wgyWi6mHE+9///gueP/rRj77b2976te9///urMKpyt7mzGIh7wtFmt97fQ4E7Knx0vghu3BRnNwbFIKzHUuyAclwsoBw5QWWSKP0INHB6M5IyHOsgqmInl6RtLOKokJTW3RKhdr5IK00xbKs+kXKJrEtkUBjjFOuXlaBKjEWEla0prkmTqMZMjlR9TKVjXTOqJYZjDCX+Imtxw9qMkbYX5t5xNozcvBpppg74zRAZUsYZpVFh1jrI0FnhsFeilvi+EhcSsQizxk4uV7CcOVpn6cfIRhUn5TNuo3LzauD9v/0L/LfX/ks0RvaveAR/6x//II/+S59CSNAH5bJlQ+sN5zYQXGbWlGKNaokXvGqvo20sSfPOJe18tmNxtNqMEWsMy85NwrUL4wwXrStRiWOauuA9qz4QVBFRwhSj5zDEnNnGhBWDM8rmvAiUxhmEIiwTMpttxHmDnZy7vCvHZ9UnZj5y2bJlMyZaZ0g5s5lcyY5iL1tXi0uVSuWhTV1rVCqVi4nWlfn/UYPEEJVFLuL4I4fXw22gn+LFQ4JVn+hj5GAbWQ8RzcqqjxgBMYK3kcZ1HAyRPzu1ZrUN3Lwa2EYtDqrG4EWK65QKUZRNLG5ShoxBedd/eiVn3vNWbNPxqd/wKpaPfBzWCEmhayzemDInnlyiGmtovCHGTAL2O8fly5bWWTpn2e88x2cN3pryOYOWcVjDsXlDYw37xYbqdl2gHioOwpVKpVKpVCqVSqVSqVQqlfuPS1oYBdQCw33g4ODggucnT56829ueOHHigueHh4f3y5gqDw/uLAbinnC02dF+Hkp/HdxZ4aOxZipslNd+5OxmF4NXdCpCysWhKeZSgJg3DpESr7HuE94Ji9aSg2AnF6HOlpi3MSra5NvE9/VJWQ1xV3Qogp/EGGGIkfVQRE4zZ8lkvLUcDoHBGLwtER8obIlsQkQ1E7UIfsaku67xmKAxpatbFfqQiTmwHiIpZ64/NyAZZo3HayJoJioMo9I5Q6+KMzBzlsO+xNRZMSWy0ZYP0zaGZeOKqEsMjVHM9P7bw3P81594OR95e3HF+6Snfz5f+Pf+L+Z7+ySFRWcZYuTcFubRMWscx3zZ36n1yOV7LZctWoaUSEmJ1iBSzqmf4ul0Ehr1IZFSZoiR2WBonWUbEiJc4Bx1bN6wDYmzm8CJuSNTjn2IxQlKKNe/N4bOGVISjJEiAOssy8YTpmPdOiFEMNZgRWit0HjLXucwIjgjjFFZD4FZ47h5NWBNOeetNztngnl7i3iuUqlUHqrUtUalUrlYmHnLeog0zhQ3Ur3FbTTnIrYfwuQcNc2vV/3I2W3EGqHzhtWQGJKiKZMpzqpnNiOSi/hp1ScOw0hKQOvwrQNTGhiKaywMIaHAZhv545//59z4J/8D4zxP+8aXc/knPpH1WCK7Z97irWXWWTpnyDnjxOKdoWuKYD+msiiUydWpayzWFtH+onEs2+JgCsUVy0hZg1gpgv7qAlWpVCqVSqVSqVQqlUqlUrk7XPLCqPuDPKkrHm6Fj9VqdcHzruvu9raz2exO93VvuPHGG7npppvu0Tbvfe977/P7Vj723FkMxD3hKDLi6Mvwe+s8dTFyZ4WPeWO5eTXQOsOZVdo5+ZAzdhJHHR2J1pXIuFlj2Y4Jaw0tWtyYhkTnLbNOWPWJZecYgpJzETHNm/JPhLeGM9thF2+3HSJjypMzFCjKeigOUnk6B5shccWyxO4dbCNDLAWNResIqlO8h3DQBzajkpLivaGzpVBirGG/cwiwbB3n+pH1kNCU6ZxhOyYaJyys59wmEozSeoOIcLAJWGvYTlF1i9YRY0ZMJmkR9+w1Dc4ZWmNoTCIL9EPipg+9kzf8xPewOXMj1jV8zt/5dj7tC76C4wvHNmQSyrlNZN4U0ZY1huXcs2gch30o8R6NZRsjMWaOzxvmjWXW2Ntcn3udo/OGEBOHQ6SPymoILFvPaogl/i4zuW0VoZoAi9ZzMETAEiMYiuuXM4K1whANkCEIly1busm1SlIpMpX/Kc4I3lqWM1tEajGDz7TOEpLykTNbLt9rAeH43DNr7K47f9G6ex2BWalUKg83Hq5rjUqlcv9ijBS305iYecvhECcn2RJ3tx2LuH7TJzRnVmPEGOHY3LHqU4nBHhJjSGQR+jHSB8W5Enu9HRIhKX1MGEozRm8T+67BOCGEREaL06tk3vVrr+b6P/h/QQxP+drv46pP/gwa72hsmZO7aV2yaCzH5s0u2m7RltdsxsjhNuKmn82mRo7W3rIuNCKcmDekaS6813kaZ5g19oImgkqlUqlUKpVKpVKpVCqVSuXOqN8kcYvb0Xw+f5BH8rGl7/sLnjdNc7e3bdsL/em32+19Hs+rX/1qXvrSl97n/VQufu7MDenuojkzpiKM6txRtNdDR6hxZ4UPP4lgtpoJmvHGMKbENioSlXnjaJ1hDIpMMRl9VLyzzJpyjMZYjrs3grdFaBSS7tyMtmPCGaFxdorMU6wRxpjoozKZftFYODcUcZYRWLSWMSmdNZzdxJ370TYoMSmjKo0xZV+pCKpizLS+iHYUaBvLlct25840bx2rMeKMkFLGGmFv5vHW0DmBeYnMa10RADlbouKcKZ3n1hqiyxxMwqXWCyElxgQzY5i1Difw1v/873jL6/41WRP7Vz2av/JNL+NRn3gtxhoUgzGJHOH0ehJAzYX9XByyhqCsx4izhj4kVkNk3jqW3R0XbYyUYs+8c2guEYbrITJERRDWthR/jhARukngdmzmObMZaZxwbquEFIrIqXWoZmbekrOQUXIux6x1lnkzuWgFofEGR1HRNY2jawxRSxGNXM7v3swz9xZvZSeKmjXlfSqVSqVy93i4rjUqlcr9z7wt64OusYxaYuYOtpGzm4DmTMjKwTYwJC3usBk2Q+TcdmQzlkYG78ucWTNYCzEk1kHpx8g4RVx3vkRsmylmG5MpadgGZ5V3/MZ/4IO/8zoAnvxV38ljn/oMYgQnYF2Z61tn8RTR097ME0PGWilrtwyZ4nA6a0qzQCZjpczdAaKWOay1gsklLrCPicaZsn6skXmVSqVSqVQqlUqlUqlUKpW7ycO+snnjjTfyoQ99CBHhiiuueLCH8zHl1g5R4zje7W2HYbjg+a0dpCqVO+PO3JDuLtsxkTOTeKdEMczuhevUxcwdFT6ETOstp1YjKWecBSOWmDLeSonLG4tDk59i7KCIlo46tIeonF4PWCtsxsiidRwOkeMzT5qcLQ77SGOLEMoZw9ltAEpHeVZIWQEpneZWShf3rClOTVY46EeCAqmIovqgZDJ4Iauy7iMhlRg4ny0pZfYXHieWlOHYwnPVsuPMdgQF74XVqKhmlq3h+NKz8I5hVDYxMfeWXpU9LdF+1hQxV86ZqJnOG4aQyFkYooIUMdX67Gn+64+9hA++/S0APO4zn8XTv/pF+PkSMngDWWFmHaOM5JwRgcYJmyHx0cNtMWhKgFfIAiIsG8tmVCDe7rXdWENIic5aRqdstpE+JBpj2Jt5tkGBTM7sOuyNEYyBuXfENtPY0v2PgBVYDZGcYT0kGi801jNvLMYU56kxKN5aOmfJwH7n8M6waByjKoebgGYwhuL+lTPH5s1OtLhoXRVFVSqVyj3g4bzWqFQq9z/eGhatYz1E9jvPAYHtmMp/MXJ6NbIaQ3ELNZlz68gYi7vs3FtMZ4lRdwL7bSgR3Ezz5ZgyWTPRgGoGhMYWl1FjiuPru3/rF7juV/8NANc+51t41NOeRc6w11nCtGaxVjjWul2jRWsMvoXOF9HUuk8kLa87+pmR8rh15oKo9W5q1FA9GtO9j2KvVCqVSqVSqVQqlUqlUqk8PHnYVjfPnTvHddddx/d93/ehqogIT3rSkx7sYX1MWS6XFzy/tYPUnXFrh6hb76tSuTPuzA2pdXctbhriLfFxs+bILcruIvUeKtxe4WMIyrltYEyZwzFigDFkGm+YWUsmM0bFieCsMPceETg2cyzPcx86Pvc4U6LstlNsnjfFLcrKlMWX4fQmEDUTYmIzlMKKToWT1ZBISRliQjVjrLDuI94I1hpE4PBw5GCItFaYNwYjwswLSYWtEWbGYCiuVkaEpNB0pTu9cQZri7uT9wZvHMu2vPexmWfReFpnsSYRtxnVjOgk3MpC5wzHOs8mKmMaWafinrQZI95YEMMH//gtvOFf/V9szp3CtR1f8HdfzKP+8t9EoBSGMqwHZYyBeeswBsiZzZg4tRrZn3mWncMZA5IRhHN9ZNFY3ORgtplEfMvuwn9yO2/ZjAnvimAraSZEJYoSp2JPSHbniAZAyjtHr/WQ2IQigAsxgbMc9iOtL7F9Io65d8waQ4gZJbPsHJ23eGeYOcs2FGewzls6LJbi5DVpoqbIw3Itnlw0NT6vUqlU7iZ1rVGpVB4olq0jaaYPif3OE5Myawxnt4n1mNgMSlJl1UcyZR439wbnyvz89GrAYvEWtkNCEZwxNN4gkomqZISQFCsAGe+Ks+ifvunXect//BcAfPLf/Do++fOfCwhjVBaNBYSQMgqICokiZtqGVAT+CEFLhJ+mInpqvSNn6FpL6yzOSGkWmJponDVoSrTecKSHqrqoSqVSqVQqlUqlUqlUKpXKPeGSEEa99KUv5WUve9nt/i7nzPve9z6sve9OMV/6pV96n/dxKbG/v3/B8zNnztztbc+ePXvB8729vfs8nhe+8IV8xVd8xT3a5r3vfS/Pec5z7vN7Vz723JEb0rzJzBp7u7F6R4KQI1FU6w3dZIc0bx9ablFH3Lrw0ds0RaFFxjExptJpHVPG+RJHuGwdrTc7EctRhJqI0FhD502JmxM47ANOhKSZ/ZnHCoyp5KgZQJOSgT4o27E4PDXesBkC/RhZDSXizk6Fi/UYWXjLNiY2oxI0YUVwzuCtJU+RiWLLOOe2nP/NmPBW8FZoraH1dnJhUtZ9GQOitM7QieCdIUTFWyFl8M6QNTPzxQ1KrIEsGGvRscT5qZZ4uKAZJ5F3/dp/4I//63+AnLnsUY/j2d/2g1z1mMfRj+X9kimRdpARKU5cZzeRYXI3WzauCKNaT9cYDMK5fqRxhnnr2AxF7LRsPesh0ocStafnOUBtQ2IzlqKVEWE1FKHTrIFFYzEUQZWREmN42Ec2Y9y5Oo2hjHXeOKwVxmARBMmQtBx/xow1hkVjy7FtLM10bVy2bJh7xxBLlGLnLXHqxHemuFqdXDQ4a6ooqlKpPGSpa41KpXKpcWzmi/PSEDEinFi03Hg4YEWwFkLMrIfIbGbpvCkCpagcbsu8E6MYha4xdFLE+qMqQRKGopBPk/hoVGCMfPBt/503/ORLAfjkz/sKnvDFX4eRWxpexpQQiptvTMqYEl4MqrDuY4ntc1rmsRRh/qy1GMlTA0RZw4SUSVrWDN3UBFPmriXeD+B2loqVSqVSqVQqlUqlUqlUKpXKHXJJCKOgFCXuze/uCpm+UXvKU57C8573vHu9n0uRa6655oLnH/7wh+/2th/60IcueP7Yxz72Po/nyiuv5Morr7zP+6lcGtyRG9JmTGxDorGmRORNzjVjVMaku+7g1hv2JwekRese0qKN8wsfnbccmzVFFOQM21Achxprdo5PGYrzUFT2Zo69ztE6S+vNBYIzK4K3pjgtTcf55F5LH5Szm5FNSJQkvMwmlEJH54WDbSCkzKxxk0tXZtaWTm9vE2PMDEHpp9gOJ2DFMIZUREFA60zpQJ/Gc2zm2Zt7Zt6SKLFw1gin1gN9LAKjxhrGnNnrHKpMDkt5F6URcqalfI4QMlmKcMo7wQxFWJczHJ66kd/7jy/n9PveDsATP+/L+Ktf8+34tiNn2O88h31gzJl5Y7CmiMn6MSEizKc4ucYV0dBlywam43Ri1mJMub6TZjZDYt0X0VeePqc7ulZzGezp9bgTqaWUGVRpvWV5dN6cZTOWzvqj++bseuTcJiAI1gijRsaQmbcOpLhdpQQWw8l5g1ihsxZnbzn/s8Yyb9z02DEDOl/iB9PkHNY6gzFSi0+VSuUhT11rVCqVS41l62idYT1ExhjxVhARvDEMonhvkMn5yYgUN1Ay/ZgYUyakIj4KKRMm99KUMikrVgyqyqpPiIkcvP+P+e2f+B6yJh7z9L/Jp/+f30rGEHLGCOy1ju2Y6EMk5Uzni5OtIaM5oWLY9pmuhf2Zx01/N8ZYHE2XszIvLQ0hsaxfvNm5CVspzRBHDsG310RTqVQqlUqlUqlUKpVKpVKp3BGXjDDqgWK5XPL85z+fV7ziFTj38DocT3jCEy54/t73vvdub/u+971v9/jEiRNcffXV99u4Kg8fbs8NaTsmomaGqAxRb7ONM8KssTunqFljWbYP/Xv3qPCxGRJGjuIIhZyFrJmmKUIyYFcQ6bzBTmKpqIpXwZwnjDmK1hhzonMl+k0zXH2sY9laPnRqQx+Lo9EQiwALoHEWROm8YdnOyDkTEzRO2ITIqg+c2wS8d6AwhMR6iHhncBZSUsQZFm2DNbBvLdYWFytvBEHQDH1InFkFMkVN1RgLVpl5R9DEOFKi/QAnxbEqRohJSZQC0BCVNEXiJc38xXVv4o9/9lWEzQG+m/OMr/8eHvO0L0BNOWZjLDFySinA9FExWQnJTJF4mb25Z945lp1DBDZD5Pi8oWlLYSpqZtE41mPkzGYEinjPINy0Hlh4u3OMWoeEn5y2NMOgigXIxT0qxFycn1IRvK36wGZQYlacFQLFYa24AwirPuDEsJwbnDF4Y7DWMJ+67YXirjXz9haB1nmUd4GUMtbdcr3U4lOlUqncOx7Oa41KpfLA461hr/M7V9YhRKIqzgmIRWNiE8u8rg+JPiohlPnedowMqYiXyvpBGI2QVbCmzJ37mDj34Xfz+//qn5LiyCOe/Ff5tK/+J2RTxPpDSDgR2sYyxFRcabVMdJNmrLVoFlwGa0vk9TAmtrk0QZycN8wm8dPR/L/ztriztqUJpvNmty48iphu3UO3KaZSqVQqlUqlUqlUKpVKpXL/c0l8O/+c5zyHxzzmMRf8LOfM13/91yMiXHnllbzqVa+62/vz3rNcLnnMYx7DE57whIdtkeL48eM8+tGP3jlF/e7v/u7d2m4cR9761rfunn/Kp3zKAzK+ysODW7shdd4yxuI2pJp3AhJjhM7ZnfgHmL4wf/jcv94ajs0NQZWbVwN9UpKWKDUhM6a0c4HKWeljpnO2OApFZYx6gUvQeCQ8m8RT+5NDEcCy83zc8RnHR897hkNaaxHy7nV7raNpLCJMcXNFAOWdYdF4nAxsQqJxQj9mZjEwJOVY69mOidY6rIHGFmekISRiUlpXnKcO+sDMu6nTvEQAjilzrPUgGWcN2SvbURhCoplZbIbVEBmTEhL0MSICrYXN0PP2X/oJ3vPffg6A4x//SXzu3/9nXPnxxTmvMaWbnkno1Adl5i1tY3AiDLGIokTkPDGUZ9E6Om+xVnbxhAAH/QhTRMjhNnDzMDBrLUKJKIwpM8TEwTaQgTObAGTm02eOmsjZcjgE+liu+c1Y4u6giLaO77U78Vdrlf2550aKWCwmRTVjvTCmRJMM+7Nyfo867W+PIweumDMN7ApVtfhUqVQeytS1RqVSudRQzWxDYojKmc3In51ac9hHEDDGIKrMGkP2ZS4eVFn1kX5ylS3z5UzWjArMWgsibIPijYEMETj1Z+/jj17zT0nDlhOf+Gk86fkvwTtH44RMpmscqiX6zonFN1oaHsTQNZbOGrBlvWAzhJTZBmXmi3C/OEvBonHknFk0lpPLdrcmmXm7c7Z1psT0yfTzSqVSqVQqlUqlUqlUKpVK5e5ySXxL/+QnP5knP/nJt/n513/91wOwt7fH137t136sh/WQ4Au/8Av5yZ/8SaC4QL3//e+/y1i8//E//gd93++ef/EXf/EDOsbKQ5/z3ZCGmGicuUAAdT4CtM4yb+1DOj7vzgiToOnyece6V4YxkfItHdSaS2wcmhmj7rq4G2vYjomci9PWkcimsxYjRXy07BzHZp7NkCCDs4ZF52kbi06d6J23U5FCcEYQKQK2U6sRzZExBpYzx+VLT+MdB8PIuY1h1UdmrcNaw4m5Z944YipuVmLBqFzgEpZyiZQTgX5UFo0tHeOhOCZ5MQSTGQCRzMEqFpelnElJiapYEQ4++he84Sdewo3vfwcAj33GV/DJz/4musWsdLkbYR2VqLBofBE3SSk4pQibVER6rbNcvt/gxEyRJMUham/qlrciiBG2fXF/WjSWoMomlEhBG4vz0iYk5s4ximKMoQ9FwDWGzGEKeGcwYtCkKHlylEpkLYKw461n3pVzpjnTWIUOnDE84uSMG85uyRTnLTFC60qEnrfmTkVRmjNjKk5tjS0OXMvO1eJTpVJ5yFPXGpVK5VIhJN2tmY5CPtdDKM6mwHobKVPPTFKhc8KyNRyOkHJGchH8b4OSyew1DpkaBFSLIywixKSc/ehHuO7f/lPC5oC9j/9knvR1P4BvOpLCNih7xmAMiIHGGNSBGMEiLDrPsbnn5KJBc+ZgE4lJyU2Zpe7PPJcvWowxdI1h1lhOzBr2Zn73WedNmcMebCNQ1i/AXQr9K5VKpVKpVCqVSqVSqVQqlVtzSQij7ohHP/rRiAiPetSjHuyhXLJ86Zd+6U4YBfBTP/VTvPKVr7zTbX7qp37qgufPec5zHoihVR5mHLkhqbpd97Pm8xyjRGinCLCH8xfhq6EUBowIQ0qklIgo/ZjYnzV4KzvBTEiZkJSYM3GIBGdYNK7EaIQICDlnnCtFjc4Xsc3RuRhS4ubDAWchpKlT25pJyGZpvbkgYk0z7M88B1vLZiwRHo0xNE4YQwYyi9bS2hK9sd85Wm843CZAWI2BfhfpITgBJZOlXAOzxpJTJkTlYAhopozBwKpPBC2fZduPnNtEkmZuevvv8JbXvoqwXeHnezzpK/8JVz3prxJVWY9KloSV0r1uRMh5RDUjRkgm0ydFFRpvaHyJputH5djcMfOWwz6ybCMn5g19UJwpMSUiwuFQYvy8FUIsLlaL1iBZQGA7FsFVTEXIdXRZx5SRBm48HLliv6XxlqCZxhmWrcdbuSASrw/KNhQHgLm3LBpPJrMZEzFlDvuAM4ZtSOzdiZiwD2lym8rM/C2RlbX4VKlUHq7UtUalUrmYWA2R9bQWgOL+uhoCZ1aBg21kNYTye1OERyhsQizxyTnjjWHWwWos8/KcKS5TZGaNIwt4JxgMsj7Du/7dixkPTrG46jF82je8gm42J5e8aYQyZzUGrIF553C2zGe9M1yx1xJTJueMFeHYorjCNkfx2bY0wuzPPCfnLZ03O/fVxpZI8JDyThTVerOLUp+3VbBfqVQqlUqlUqlUKpVKpVK5Z1zSwqgPfvCDD/YQLnk+//M/nyc+8Ylcd911APzYj/0Y3/RN38Q111xzu69/85vfzC/+4i/unn/RF30Rj3/84z8mY608PDBGWLSORftgj+SecX6cxQMl6ApJWQ9xt58xKsvWk4cAAs6UQkJBaCxoNgxRJ9GLApHGGlZDZNm63b72uwZj5ILINGcM1gjH5g2aS9TbyUV7h/GFOR+9s9B6w17rcVawxnDlfmZMnsZYvCtd5kEzLkPMmbPrgVGLQCioshkT57ayi9iImrnh3BbNFCcoU+I3Ysrsd56YMmOMjKOSE6TQ88e//BO873d+BYDjj/k/+JSv+V7mJ64sA80wxERIxW3LChgxRC0irdYX4VfnLMc6x7y1HJ+3jFFLV7t3mKJvog9K0iJESxmcCNuQSDnT+eLUFVJ5zzEmNikRtUQbppyJCaw15JRZh4Q3Bm8ENeWcn9sEGmemGMRSSDpfrORzZoiCm0RqezPHZkw0LjNEZQilaJa0xAO62xFH9SFxej3Sh8SidTTesNd5jEgtPlUqlYctda1RqVQuFs5tA5sx0ofEwSawDaUpYDPEIpDajgxZUSBG5dxmZNY4rClio9UQWI+xrFnGslYxZLIIGSFpxhrBiiVtD3nzv3oR21PXM7/s4/jLf/+f45bHsZRptGZFMUTNtJqx1iAIe3PPwjtOzB3LWUPjiiNtiApisFOjQx8T27HMOZedK65TAs4WN6iYMgd93K0tWm/Y74qT1KJ1D1vX4EqlUqlUKpVKpVKpVCqVyr3nkhZGVe47xhhe8YpX8CVf8iUArNdrnv3sZ/Mbv/EbfPzHf/wFr33729/Oc5/7XFR1t+3LX/7yj/mYK5WLiduLs9iRIZF3gqb7GgG4GUokWz8mOm8Q4Ir9DrMu4pzT65Hj84bW3eLkZESKGMYYDvqRg23AmuIK1cdUxEtG2JvdNjKtdQbNJWpPdSRl5c6GLlI+89GfSkYzBFWcKWM6HCLHrEeApHDz4UBImahHwiY47EfGVKI8kmbOrEdaZ1mHRExKTIqf9meN7CLgvLU4k1mf+nN++8e+i9N/9h4APukLvprHPPNryWKJOZMSxcUpKUPMWKGcuxwJmpl5w17nMCLstY5l22AtxKwsO8uy9UWUJKVTXnNmPSa8gXWvtI3l7DaQpg753fkLkSaXcQvgrNCIISv0ERJKqwYxcGo9std5/NQ533rDVfvdBQ5du+NO+Vnjyp+zphSMjo5LSDqJ4uDGg569madx5fpJOXO4jRwOoXTxO8uyc+y1nnlja/GpUqlUKpVK5UHmzGbk5sOBMSkHfWAMZV6XySiZrrGIFdJQXHj7UERFKUXGpDROWA0J1bKNN8IQM4qgWuaykhWMZehX/P5PfieH17+fdv8kz/hH/5ITV38cQmZIsB2VMWZyitjOk4Er91qOLzxocRydd54T84ZjM4cRwxATrTdkirDqscslZnJsjXrLCiomiCntnjtzi4MpFFHVHTVoVCqVSqVSqVQqlUqlUqlUKnfGw+5bpc1mw3ve8x5CCHzCJ3wCV1xxxYM9pAedZz/72bzwhS/k1a9+NQDveMc7uPbaa/nqr/5qPvVTP5UQAm95y1t43eteRwhht90P/uAP8uQnP/nBGnal8qBze3EWfSzxaDvHKCN0ztK4IkTq49QdfQ+/1FfNDLEUCrYh0TjLVfsdQ1ROzFtuWg0MUTnsA4MzOGN24pc8ja0IgRQrBu8gTYWQk8vuNi5EMImkcsY7gxGIWvYz87c/RiOQjh5oEYQlLXF9SZVxck2KmtmMynaMDCHTeNiEwOEmEjWTckYpYq8hKINmOqusx0RSZdk5xApnNiN7ncM7IU0uXf/7f/46v/lTLycMW9q94zztBS/hssc/laCKFUFEGFKJD9GcyWS2o2IA5wyNNYgYxqjMp5gPsZmkIFnwzuKcYa9xbELCOHbHVS2MSZmZ4sQVorIaI84YNkOELDQOuik2xIgQVEm5uGR1zrI/88W9aRVZeOXsdmTZOJLPqGaMva0wKk+SvMZarBXGqFyx15FzKV5lU6L2yJasGZnEVWESTR2Vo+aN47JlUwR8jWVv5mvxqVKpVO4hda1RqVTuT85sRj5yZgvA4RCmhgyltQZF0ZTpY6T1htObkc4bzm0y67GI3oegtI2ZnEW1RD9boY9lDplJjBHGCN6MvO3fvoTTH3gHzXyPZ3zrv2R5xSPJgLeWxgmtSwyhzB5PzBoaZ7h82XF83uA9WDEc7xq6pkTfiQhRFSPCFcsWpMw5j7ir9dMR92b9VKlUKpVKpVKpVCqVSqVSqRxxSX+ztFqtuPHGGwFo25ZHPvKRd/ja66+/nn/8j/8xr3/964nxFiHDZ33WZ/EjP/IjPO1pT3vAx3sx86M/+qMcHh7y2te+FijOUa95zWtu97Uiwotf/GJe9KIXfSyHWKlcVJzbBvpwi4PTNqQLOp53pMwQtHQ8e0vXWNZDRHPeRULcHbYh7QROUTMi8MgTM/78bCmUnJg3rIfAMMW6Na4Ik87HW8MQlIySUonJ67zh5KIBuE1kmjElUm4zJjpvGSd3rJkvwqxb460hpERnLSEqmyn2rw+3jCOrcnYdGFJkCGV/1x9EsirWFBenIuKRnVORE9iGyGZMjKqMSTkxL4UYKwIKod/wGz/1St72W68H4BHXPoW/8Q/+GQdmyWaIOGvwtpyD4yIc9KHE9kERbgm7iD2bFc0GAxz2Ee8MjbEYkRIvKELUzLGZZ5yi6uY+M2bwztCnxLyxJFU0w5nNwGYoDljHrMPZEj2yDYk+KiHm6XgzxdcZ0iwTAUZlS+LksqUPyvJ23JuOthdTCk3WlOvyyv0OJHP9mR5BaLwtLlKqMBWfnBGcMxzrPMvpepx5y5X7XS0+VSqVhz11rVGpVB5Mzm0DNx8OABxsRk5vAlGVZetwVjjsizj/zGZk1ZeoPG8M1goEIcSEklkPCXJxZ+qj0jmDMZBSiZJ2NjOOkT/+2Zdz+k/fimk6nvbNP8TJRz8OS1n/OyNoFpwYehKNNbTest85ji8aOmfovGPRGC7b6xDg5KIhqOKtwRlh3hZH1uNzv3PcbZy5QAB1PgL32XG3UqlUKpVKpVKpVCqVSqVSAbikv1160YtexOMf/3ge//jH88M//MN3+LobbriBpz/96TvHo5zz7r83velNfPZnfzavf/3rP3YDvwix1vIzP/Mz/PzP/zxPfOIT7/B1T3/60/mt3/otXvGKV3wMR1epXFyshrgTRR30gcMh7sRK3RTDdmzm2etcibyT4pJ0OEQO+uK6th0Tq/Pcpu6KYYpC6yfXqNaZ4hq11zFrLDNfXKJA2I6Jmw4HTq9GDreBPhQhlhODtxbNZX/HZp6TixbgDiPTFpM4Zt5avDOEpBz2kc1Y9nk+rbMIReATY3F4OuxvcZk7tx2JCiKZVZ+wxhBVETJuiowzCJ1zNK5E5KkmVn2Yot4UciZp4tSqLx3mIfHBP303r3nRV/G233o9Ygx/+cu/mee8+CfIs+M0zrDoPPud48S8ZdY5Gl9ETt5bvIGuKR3pnS+uWRkhC9hJTGVESvEoK3n6zBlonMGY4lYVVIujE0JjSoxd58v5D6H04zdOCCkzxsR6iLt/h2aNYeYtftpu2VkWnac1QqY4ZxmEMeltjvlRXB5AN4nVTi4a5k15fHzW8IjjM47PPa23dM5xvCvn/fL9lkeemPPI43OWXYk3PDlvePRl8yqKqlQqFepao1KpPHishshmiIxRWQ2B0+uRqMrMW5adZ9kVh1LVTFYICTpjWG0j/dRIkSlf+MRUBPlDUGIsjlNOBGOExllab3jPr/zf3PQn/wOxnid97UuZf/wnE6NO8XcZocyLrRGMQNcaFo3hxMJjJLM3cyxay3Kylj2aJx9NXY/SoEVKM8WxuefyZctyWoOU/cou8nvZOi5fthyb+yqKqlQqlUqlUqlUKpVKpVKp3Gcu6crnr/7qr5Yv6UT4B//gH9zh6174whfy53/+58gUo5TPKyyLCDFGvuZrvoZ3vvOdPPrRj/5YDP2i5bnPfS7Pfe5zue6663j729/O9ddfj7WWRzziETz1qU/lsY997IM9xErlQSUk3cXnHfTFoQlg3lhmTRHcnE/nLYuc2Y6JzVgKEgcE9jvPeoi0ztytL/uPBDE6uVIdbdM6gzdmJ9RJSQGzi8RTYIiZMSWcaClkOMNley1X7HVohllj71AIs2wd6yESk7JsHOtJZLUdE31IeHuryL5UBFGZEtU3BmW2tJxajYSYWcwNQ0zsd46gmdZbWm+JmokpkbPiMPShxO9N5lFohoV3HPOWs5sRzZkz64G3/uav8Yc/9y9JYWB54gqe/Y9ewcnHfip9TBz2ERE41jmOLZoS45dLJN2icYR+RMXgrLJsW+aNIcTMGLV8ppxBoHHCXueKy9OY6BrLscYyRkXy0XWRMK58pmOdYz1GlEyImaYxtBj2Zw0GYdbYEmfYCS4Up6xVn0i5xIwsGsfhNuKcQZKScmZICWeFISiz5ha3rj4kcs7F+WkSl3WT8Kt1hjObIjo7sWhYdp6YlEXr0MwtcSVSPt9li4bW39YJrFKpVB6u1LVGpVJ5MDhab/QhcTgE1n0i5sysKVHazhgOh0BMt0ReqyrGFpG9N0JPEfmnlKb/FBGLsYb1EOm8pXOGMSau+5VXc8Mf/r8ghic+77u54tqnlrjpUIT/McN6SMxbizXCfueYt57OW+beYcXQWEszNRkAu/nqODV3HK1Nzl8rGSMsWsfUp1GpVCqVSqVSqVQqlUqlUqk8YFyywqgPfvCD3HDDDYgI1157LY9//ONv93XveMc7eP3rX49MX8BdfvnlfPd3fzd/6S/9Jf7oj/6IV77ylaxWK7bbLd///d/PT//0T38sP8ZFyxOf+MQ7dY6qVB6ubIZb4vOORFH7M7crAtweRsqX/s4KB9sSIdfbEk+3GRLH5nctjDqqsaZJnJNz5ubVwGZMCEUwJUDrDSLCNkSGlAHBW2it7KIqrDHMjooW3t5ppN/MF9FUypn1EFl4hzWCUFywxqi7gsfRZ805M/OWcYrHu/FwYD0kFm0RQW1DYn/uObcJJTojAyhRhWXrGGJCAwTNhJwRBSuGPiaCKiIwbta8+Wd/mI+87Y0APPKJT+fz/t5LsfN9NjExJMU6Q2egbTzrPnFy4dmzjj5G1kOi8Y65xnKMnOCdxdmMsUJMytGnSpqJSdmbeZJmNJWYQm8NQyrXg+RyTITiHOambvqz23J+9jvPsnU01rI4L7JQSARNLFqD5nIdFHcwwQo0zjKExGaMLBrHmJQZtxSatmN5/24qPjXW7ApOzpbi1PF5ea/WGeZNcTM7EkS1rrhVHRWrKpVKpVKoa41KpfJgcbTeONdP64aUWDSOvZnDGcNmjIxBEWA9JlZDQAFvhP25K9HXjWEzJM5tFectiBBTiadDM5shEgK897f+f3z4d34RgE/68m/niif9VZrJ6SkmRVXQrCAGa4u7azs3mCysQ8S6Er3deMNeW9YU86ZE392es2l7B7F5lUqlUqlUKpVKpVKpVCqVygPJJSuMeuc737l7/Jmf+Zl3+LrXvva1QLF/n81m/O7v/u7O9ehZz3oWT3/60/ncz/1cAH7xF3+RV7/61XRd9wCOvFKpXKqoZoYpym47RenNG3unoqjzaZ1l3mQ2YyrOQ94WEZC6uxSmJC0Rdme3gRCVzVhET1BcmoYx0adEiBnIzBrH8rx9OhHaSTyzGSLzxnJiile7M4wRWmfZ7yDEzE2HPUkze1P0Wp8SmjJ90J1oyTtDTApZGGNkiErOFKHQZiBTLKAyxUljjJGgmc5bUirOHN4K5Ew/Fielo7gPa4QzH3w3//PffB+bmz+CGMu1X/yNXPvMr2JjDG3KoIkxlq567wxMHfbGCIdDQMqusSJ0jcUi7M0snTUELf9eWDEEzaSUp1gPw6wp49vGhGzg2MLTDwmxgrNFCOWsIQtsQiKmTOdsEZ/NPAaYN6WrX6S8/sTC0YciZlqPJS7l7CagOWMMLFrLECKHfaK1I8YYYiqfb4wJ5wz73S3CvPl5blJHxSgjwrGZp3EllmRRY/IqlUrlLqlrjUql8mBwwXpjLC61nTU4W1xmY7pFGF/mm4rmIo4XgROLFiORPkSOzSyNtZztR5KNnN5GQlAGVbLCh9/yn/nA///fA/BJX/JCPuHpX1icYYMys4aUFc0CAq0Bkw1tYxhTxsXE/rxlMTVRHImiOm92c83SzFEaBo4cZmfVnbRSqVQqlUqlUqlUKpVKpfIgcMlWRz/84Q/vHl977bV3+Lrf+I3fAEoR+m//7b99myi4ZzzjGTzjGc/gt3/7t9lsNrztbW/jsz7rsx6YQVcqlUuabSgRcWNUohZnoPNjze4Os6Y4Jh25LTXOsA3pTsUqqyFybhsIqbznqg9sY6Jzjs0YGGMR77TecGzusQbi9FprDGNUcs4MISEI+zOPd4YhKrPmrv8ZmLeWPiYuWzYYgTObkVUfSic4maQZZwVnbzkWN68Hxkk8FmOGrFjjONwkOm846AN9UISMd5YWsEY40BIbcrAJxSEqKc4V4VJKmff8t1/iD3/xR9EU6U5cxZO/5ns4+dgnMqpgVMt7GRhjLvGDxkNQlp1lO2oRY2XYay3eSon7i4oVQxZh2TlaZ4iaWfUR70q3e86gqQisxq0WV6oDJSk0CfLck3Mmpkw/KMN0rbTW0PpbxFHz2zne1kS2Y3ECyDmQ8hSfN5TPsBmVmEecEbwpblZHIU2iEFLmsA9ctmhw58Uy1mJUpVKp3HvqWqNSqTwYXLDemBoGGmfQXNyajpozxqg7S9ll59iGxOEkfLKSdwIqQVg2ltEZmkFRAzPvuP4Pf5P3/9pPAHDNFzyfj/+rX0bSjJjSzGGN4FNxL22skDJEMh3l94vOcqzzIKY0IlAE+kdrmiGWGHG4Zb3UuupSWqlUKpVKpVKpVCqVSqVSeXC4ZH3MDw4Odo9PnDhxu6+5+eabue6663bPn/vc597u657xjGfsHr/rXe+6fwZYqVQecgxTZFw/dXG37pbYsruLEaGZxCtH+xnOi6K7Nee2gfUQaawpBYY+cvN6ZDMmzm1HtqGIaIwBkaNIvRJJt2gcx2eeT7hszlXHOhatI2ZlG5TOWjZj4u7UJry9pfP7xKLh8r2WxhsOhsDZzcg2JLYhcTAEzm0D5zahiLFMcZlqnHB80RJTEVAtGlscmxCsFWbestd5jjywtiFhrMFgmDeGuTP0h4f8zk98F7//c/8CTZFHfdrn8Dn/5N9w/JonolnQlEg5E7KSUi7iMM3EqBgH/aishwCAZhAjNNZOnluZ7Rg53EY2QwQRMqUIBSVKD4SgxUlqr3PkBKsh0YfIkJTtqCCCquJsOcczX4pK5VqxtyuKApg3jtaX97LG7MRLUTObEDHAekjccK7n5vXAYR/px4QIdM5MblzCmErcYbmmajGqUqlU7gt1rVGpVB4Mzl9viDDFYJf5W1QlTL8fQsI7gzdC1jLXLbF7RUB/FLO8iYltyISoHJs5rBVuesebeOcv/BAAj/ys5/DYZ34txggzX1ypZlY4MWu4Yq+l9QZry5z82MxxctnQOQNZmDWGMSZSUo7PPYvWoVP89sG2zElbb+imue28rQL9SqVSqVQqlUqlUqlUKpXKg8Ml6xgVQtg9ljsQJrzpTW8iT12U3nv+2l/7a7f7ukc96lG7x2fOnLkfR1mpPHioZrYhMUTdOd6IFAFF64r4oook7hk6/X2iOv29Yu+dtrSZ3JqO9nO031uzGop7EsAYlFOrgbObwHZMu47uubPszxpaJ0UIpEoclaiWRWPpQymqzBs3OUeBJkVLoB138Na3Ydk6YlROrQc+em7L6fXIZkiT+5VijGHuLa0vYrGUMo0xqMuMKUEusXIKZJj+zMSQWcWBISrbITFocYsaQgZRGmu48b1/wlt++vtZn/4oxnme+JwX8ujP/lJGVawxNMbgnQBCHxOqGYNgBfqgdD4RpLhAaQJnhZBKcWnUVDrgNeNs+Rkhs5nctVYai4AtgzENURVnhG1KWMk4Y2icZeYN+zOHM5Z5Y1HNnOsDmyHROXad9Hd8fD0pDfQhEVJm2TrmPnP9mUimRDTlXNytABpfBFEHfWDZOJad210zqyHuBHu1GFWpVCr3jrrWqFQqDwbnrzeMgLfCiMAkgBcRYsrEXMROSp7msULKynbIeCOMsThGhZyxSBFVpcyp9/4Rf/Lal4EqVz/lC3jCl34Ljbc4Y4sQaxLeM0U/LxoLCHszh7MGJ8J6KFHXfVAuWxR31SGUqPAx6W590XrDflci9hatu9drp0qlUqlUKpVKpVKpVCqVSuW+cskKo/b29naPT506dbuv+Z3f+R2gfKH3lKc8hdlsdruvO7/YMY7j/TjKSuVjT0jKZkgMMXEbzUuGRCYkZT3E4mLT2vol9d3k6Ev+oz/vqVvUEUeb3Xp/53N0jkJSbjoYOOwDISqZzIm559QqkFRx1mAMxFzchkTKtuPkRrVoLNuxCJOSZrrJxagfE/udJ6Qi0LozkVxIyrlt4Ow6cP25ntPr8vdkohRvkkLSxCormj3HZ44Tc48Y4cwqMESl84aQYBgTmjOH28iQEmNQjBGGEBk0c7CNrIc4uUdl3v2bP8v//q//lqyJ5ZWP4qlf9/2c+PhPYkgZJwYvgnWCd4IRQx8TOWdSBjUZoxCzpR9j+RmJzZgJKTHGTBZBKZF1KWYGYJUhTl363lhihHMmgAh7s4yQOTJc7GYGJ4ar9juOzRv2OsfBNrI38yQyM1+iE89tRjpvcOa295rmTB8SUcGb8lkaaznsA11riZo50TRkMq01dN6gCtZC6y0InF6PGMq2OReXqBOLphajKpVK5V5S1xqVSuXB4Pz1gbel4aCzljEo6zExbyx9SqzHSbgvwmEf2I7KelRCTAwh4YzQp0QftMxaRTj88Lv5vX/9XWgMXP0pn83Tvua7wFhSznhX4vJc6aRBc2lymHmHdULnDPPWTfNjQZHS2BCV9ZC46XDcCfWdEWaN3YnzZ41leSex4ZVKpVKpVCqVSqVSqVQqlcoDzSX77dQjH/nI3eO3ve1tt/uaX/u1X9s9/uzP/uw73Nfp06d3j5fL5f0wukrlwWE1xF2UFsAYdeegs3OMMkLnLI0rIpI+JhatuyS+rH6wXbBEgHyLsOmOnJ7uiqPNjvZze/qqzZBYD5Ezm5FVX85p5y3n+khMyjZGUso4AgLMWkuedmSNkDQzxoQ15f3WQ2TROvZmjpQmhyRTJD7bkHZRebdmNURuPOjZjImYlJAUMtxw0LPuIwglCm9mmTcea0rkXIjK/sxz+Z4naHFBiqmIoEJInNmOWBGSKuOYObcdCaocbhNjjIT1Gd798z/ETe/+AwAe9ZTP41O/8kV0iyXOCCJKUiFT3stgaD00RtimInZKMeNsJqaMdQYjsB21uHAZGFXxYkCLaMx7QwZiyPRBSRkal0vHvIWUFehovcVJwliLRZh3hqTF1WnZejpnCarMGstBHwiH5br96EHPfudpnGG6lBhjOaY5T5F9Rrhy2bEaAt4Ke20DKMuZx4owb+zkXiUYKUWrIerOWaxJlmOdwxphXotRlUqlcq+pa41KpfJgcP56o3WWqErjLM4IqmXed9gHDjaBxpUo5ZwhZmXeGNYps86JrJnDIRGiYkUYbv4Qv/2j304cNlz9yZ/OU7/++7De422JtnZGymuNYeYMYoVhTDirNDhUM2c3gav3O07sN2yC0sdI0ow1Ze7tnTD3bhdHDVwy68xKpVKpVCqVSqVSqVQqlcpDm0v2G6pP//RPB0oh+td+7dc4deoUl1122e73b3zjG3nf+963e/55n/d5d7ivP/3TP909/riP+7gHYLSVygPPuW3YiSP68Sji7HaEOykzhBIHNvOWrrGsh4jmvHOXudi4WFywjAiJyV0plfc86oS+JxzFoR2JuG7tPKWauWlVYtX6MTFGRYAhJozAZkw0zpCMEsmc3o7YrTDvLIvGEROknIkJVn1k2TkEcE7Yaz2nVyNRlZvWA8uQOOwjJxfNbcRl57aBGw97hqAMMXH9mZ5z27HEvaniveBNERMd9Il1r3SNYX/WIGTWYyzbBiVp5nAIXH9mCxT3jMMh7GI3gmb6qcP91Hv/F+/++VcxHpzC+JZrv/Qf8gmf+UUoQoyKOMMYS7wIk0PWzsXLCNYIOZfrXARyzPhWQLXE0imEqCCAzcxbhy/KJmJSUs4YAzllYgaThRAzg4E+ls8+85aYlZNOuPrYjBOLhuNzj7PCyUXHuW2J0dtrPVkzp1cj2zFhkAuKRUc4U6pgy8YxJiVqpnWWyxaOE4uGpBlVdp34ISp9KkWvxho6Z1iHVBylGkvrLJsx8XHHm1qMqlQqlXtBXWtUKpUHg/PXG8YIomVe3nlLBk6tBk6tRsRADEVYbybXWIdBTKKxUhxYtbiibk5dz1t+9NsZVue44pon8DkvfBXJzfBW8FYYRqVpBO8MKWWCZhxgrLAdE2KEZetYOou3k7OUYSfGz5R1ZGPNrgGgOhNXKpVKpVKpVCqVSqVSqVQuJi7Zauk111zDp33ap/FHf/RHrNdrnv3sZ/Oa17yGxz/+8bz5zW/mBS94ASKlOH755ZffabHi937v93aPH//4x38shl+p3K+shrgTRR30gSEU4U3pNDa7GAbNRcwzxCK8OBwioyr7nS+iDZGLTkRxMblgtc4UMZSzk1hIWeR8jyL1NGfGVM5P5+xuv+dz8ySKikk52wfi5L6Uo7A/a4gKQ4h0viVlZb2NRDKHfaQflFlry7mOWqLWcqZpHGPInE0BI6Wze7WNjKMyJuWmwx4oWqG9maNztrgmaWYTIqcOB85sxiIsAvZbz17nmDWOMSU2Y3E+ikk5vR7w1jBsAjFnNCnbmFn3kSEpIWasgc0YaZyACM6CicqH3vgzvP8Nr4WcWVz1CVz7vJcwv/oahqQ4MaxTokkGa00Z7TSgTKaPxc0q5UxO4E0pFq1DYqklSk4VssmklCFDY0sxZ9ZYhjExTu5RmqH1BhGD9xYnJTxPNdOP5Rq4fOlpneVwO3LZosVbs7uPjs08mjMfObNlf9ZgjLDuE31KmASNM1gjiCnxKNYKZzcjSYugK+dSAFt2jna6TpatJaTMGBXvDP5W1818jGzHxDDFJM4bu3ONqlQqlco9o641KpXKx4JbO+Kuh8hmTCTNbMdY3JhypvXFPepgG9mOSkhptw6aecMeDZsxkKfJ8XqIZR6+Os3vv/pFbM/exPFHXMMXf+f/A82SXnVyphKWncGZMvc3AmGaD8+8RR3sd5ZF6zg+88waR0iK0SKSsiJsx9JEceRS+kC7+FYqlUqlUqlUKpVKpVKpVCr3lItLAXEP+e7v/m6+4iu+AhHh937v93jyk5+8+12e7ENEhG/7tm/D2tsvDn/oQx/i7W9/OwBd1/HEJz7xgR94pXI/cuSUBBeKouaNZdbY24h2Om9Z5Mx2TGzGxBCUAwL7nZ8cl8xF09l7sblgzXzZb+MMzghRy3G8oxi689Gc6UPi7DqwHiNWirORHWHuLaqlMzwk5cxmBODUeiREpbGGWWMZYxG2GUBzOffOCMcXDVEzq6kzfAyJeeNIBjprUIQhJFLKnFx6+hGuP7tljErjDMYIx+fFMcoZYXNu4Mx2hAytNWxCYjUEkmacmOKqpBnrSqRH4y37rePstufMdqQPJX5uO0SsFcaYGJIyjGXsKSlaLlNCzIjJ9Gdu5i3/5vs5/b4/BuBRf/kL+T++7B+SbEMflG1UxEQ6Z9nGRAcYMaRcCjgliq7sdEyJGMGYjKdEe5zZBvZbzxBjiRxRpfGWxltaZ4iaSTkjCJYS+WesobWW4zPHNipzX7rgGwv7nefEosUbwVlDzpmD/sL76MS8AeDmwwGhXIculPsxIxgxeFviDA/7wBCVrJmoxenq2MyxbMt25X52zJjEWSExJkUzO4HgXucwQOMsnbc4a+40JrFSqVQqd05da1QqlQeKO3LEbZxhNa3txljm3N4asmS8EQwQcuTsJmCscHzmsdYwtxCSYeEtmzGWRorNAb//6hexvvkjLC//OL7su36CYycv49xmxKiQRYkx0c08jbEYa7ACQ1DsFIvnLMy8Y7/zHJsXV9jGlbllYwwqcNmioXWWRWPrvLNSqVQqlUqlUqlUKpVKpXJRckl/a/XlX/7l/L2/9/f4yZ/8yV3H9hFHz5/2tKfxHd/xHXe4j5/92Z/dvf5pT3sazl3Sh6TyMGQz3CIcOhJF7c9ucZm5PYwIi9bhrHCwLXFnvU103rIZEsfmD74w6mJ0wTJGaJ2lj4mZtxxOHd3Oyh0e75iUzVhELMMUWwcw62wRGrkiPNqGROssQYvY5ShiLmmmaYUxKmNMxQ0p50mgY3YCKSgCq5SLG1Tji6PQ4TbSKRxfeKImTq/g7GbkzHZEgDEZkirrITClyZGzEnOmHzLbFJEsWJM5PmuIFmLOeBFSyhyEyLAeGUICKZFwGeXsOjDGhLXldYdDwIklpsRqjCTNnFh4VOH6P34zv/fv/xlhfQ7bznjC//mPufxJf51RBC+CEaFPEZcN20k0BLBoDTYbOl/i/MaQ6IMSY3GQIhc3qiGU42ZEMAKNNWANeRJvkR3rIRAVMIJrLMYYHHD5smHWODpN5bgaw7x1tL6I2K5YzLhiv2MbEs6a29xHJ+YNRoTNEJk3loM+lmJVKgIoDZRil5ZxrVLEGcN+Z9nrirBq5i8sMhkjzFvH/HauN2cMw+Sq1rjyeNHeL5d/pVKpPOyoa41KpfJAcFeOuNsxEqamiTg5Sh0OkWFUsoAXA+X/zNuyBik+UZksQmcdS3PIW/7Nd3Nw/ftp90/yBd/+Yywvu4IxFCGWZFCKeykK2UDnDFaK6N+I0PoSs51ixtkSoS0mM/MOzcWBdRMSR9Kuo3VppVKpVCqVSqVSqVQqlUqlcrFxyX8z/+pXv5onP/nJ/OAP/iAf/OAHdz/vuo4XvOAF/NAP/RBN09zutuM48uM//uNA6fr+wi/8wo/FkCuV+w3VzBDLF9DbSUQ0b+ydiqLOp3WWeZPZjEWE03nLEBOq7kGNP7iYXbDmbRFGdY1lVC3vtY3Mm3ybsR32gTPrwBCL8Omwj8XlyRbXpdYbLl92O+emTYicXo8lDi0k+hAnhywpjkhZ2YzKJkZCyIxeWDS+xFzkTEyZMMXfOWOwktGsLDrPNpTYDWOUs9siZCrFFykORUAfEznDkBIxTS5XY6J1hmXnCTqSUsJKcbA6tynOVZmM5jLOMSXCqBwOEQNsIyy8o3WGlDPn1omoSmsN6+3I//qVf817fus/ArD4uMdx7Ve/hPllj2JMGUQncZwgGaJmsmacNzQKToR5a3FWSuyfCN4KYg2SiwDQGEOIkZxyie6z5VgaY3BWGENmSCMGKS5gSREjWIET84ZlV+JC5t6TsoII88ZybNbSGKFtiotUUi1RKLdzHx2beayRnaAJblsAS3nEIYAFhEXndtf8Pem8PxJD6eSspjnfxRaVSqVSuTPqWqNSqdyfnNsGNmNpADnYBLYhETQjFAFlY0vc8jit7YaobIYAIhwOgVUfEGM4OYnvjQgOg2bFFm9WJEfe/JqXcOr919Es9vmbL/pRrn7UJwBC0NK0kXNmiIqzQmPK+4aYsY1lZg0JaI3FGaHtLMc6j3dlzo2Hvc7Tj4mgSoxlvjkm3bngViqVSqVSqVQqlUqlUqlUKhcTl7wwCuCbv/mb+eZv/mY+8IEPcMMNNzCfz7n22mvvsEhxxJkzZ3jlK1+5e/6sZz3rgR5qpXK/sp06fsfJLUkEZs3dE0UdMWvsLqLuSKDzYMdvXcwuWN4aFq1jPUT2O88BRbi1maL+GmswAjetBlZ9LMWMMTKETMpFFNU6OBwiUS3OlLjAzltyLiKZVR+4eT0wRGXW2OIANB2LEqVnSEQ0ZJxJBBGsFIHOrLWshlLsQITGW24+HPHOEJKSc2YzFAGZtwAGZwzLznIcz7lN4NSq57BPbEMESjzheowsWkdMxZFqHktUm+YirENBsxZHK4qIKWmJpjs9jjhTPpsYyBHO3PgR/vDf/wBnPvgOAB71V/4Wj/j8bwTvS+e5KkYMmYwcic0mkY8zgrOlEOTLh6D1lLFlmPmpy90KY1AGccSskGEbFG8NkvMkhir7d0bIIhgMQmYxxdH1oxJVsVaZufKZL1u2LFqHKghCiErrLWNIGCO3ex8t2yIOO4pMaVw5X0doZtd5n3JxiTo287h7KOi71aGi6qIqlUrlvlPXGvcPp0+f5k/+5E/40z/9U06fPg3A8ePHeexjH8vTnvY0jh079iCPsFJ5YDmzGbn5cGBMykEfGM9zxPVHjrgImYy3Qh8Vb4VtUBQYY4l+Tqp4IyBlzi2mOKoaIywbw3/+kZfwZ9f9Hr6b8VUv+XGueOwTSEqZZ06xzQbBSmlsKOsCw7GZY+YdYgShuPQuZw7JJf5aSVgRGmdprGEUpfMWBUJUfGsf9HVkpVKpVCqVSqVSqVQqlUqlcns8pL6xuuaaa7jmmmvu9uuvuuoqvvZrv/YBHFGl8sAyxPJlej+5RrXO3MZN6a4wU2fyxRK/dSm4YC1bR9JMHxL7nae35b2iZs5sRk6vx10M4GFfojIMlHg7K4iULutjM084KowkJaSMMcUlaz0knJSu7D4o88bSOIsqzH1xNAqTK5BQ3KS2AbwanAgHfSid42JYj5Hj84ZVX+Ly1mPC2XLuM5lF50haBHaboDjrgFg6woGUIaQS67dsLUIplngrrEYlpMRmKL9vJ/HQzBs2Y0QVhhQZk6AZNiHxF3/033n7f/pBwnaF6xY88Sv/CSef8Fd24jxEUBGSKpCxpojNNEPbWForeGdwRjCAtcWNyjlDY4WutRiE44uG06sBCYkYpVxbmjnWOtrGFgGTd5gMxpQudyfCorPMGz9FFBr2Zp554zg2s2UsSCkaTZdTnxJ7zpcTAXd4H3lrODY3qDq2IRVnp0kM5yYnq0VbrtMi8rvnYr4jIdTR2O7hXweVSqVSuRPqWuOekXPmd3/3d/mlX/ol3vCGN3DdddddEEd4PsYYnvWsZ/GiF72Iv/7X//rHeKSVygODTjF4Q1TOrAeuP7tFRNiERAiKUoT6SHGLMlNkeOtKJLYC6z6WRpYx0cfIzJfHzhWH1CFmQo54ZzCS+S//6mW863d/C+s8L/i/foxP+rSncrgNnNoMpAyL1mKl5aAPIA5VJR4F8WVDFkUQhpgRyWwHgBKvN8PSOmHRFLda5wxMY+5T4rjzNca5UqlUKpVKpVKpVCqVSqVyUfKQEkZVKg83jmKyjmKz7m1c3MUUv3WpuGAdxaOth0jni7vQqdXAGBMpKUlLxF4flcYaFq2lmYRrrbNYEfqxRPLNG0cfEushYg2c6wNQIu1IgjVC40pk3mZyflrg2Eziq84bNBehXEhKJjOmRD9mRBKtNxxsinvVeogMSZEwOSWJZTVsyZoRAwebyJiUIeYiRgKcZLIWVyVVAQMYKZ3nsUTreVuiOIQiaFr1mZgzKSWMlIC4U4dr/uRXXs2H/uevAHD5NU/gM7/xZSwuu5rDvhy3xiaMGNZjcaxSPYq+E6w1dM7gnWXWlG72eVvEYttUnKqsE+aN51jnuWyvYd5YPnR6g7eGMSkL45l5w7Jr6GPAYMhAaw1YMLkIBSOKJkPjhM5b9maODDTO0nrDvLFTzCHk6c8jIdNd3UdHwqfzi0bWSHEDM2HnDNb5e3bdQ7lvjt4DuMdCyUqlUqlU7i+e//zn87M/+7N367Wqyq//+q/z67/+63zTN30TP/7jP473/gEeYaXywBCS7lxCMyVe+6bDAc2w2ozcvBnYDor3QuccrRNSzsRY5rMCtI1h5h2bIWJMnuarlq4pzQFDVI4tGqJCSooz8HM//ire8huvQ4zh73zXP+dTnvpXQTJns2LyJJjXEg2+6gOLziLZEjTTWIuS2QwlIttbQ9LS5NE6w6zpmHvL/rzclwJ0zpCsYKXM17sp3rtSqVQqlUqlUqlUKpVKpVK52KjCqErlEubWcVn3VgRxMcVvXUouWOfHo51el2KHNQYxBs0lVm3eWE7MG+be0vjSAZ6RnfBr1Udab1i2nlUfOLMJZBU2Y6RxhpSU/a7FSImOm3lLSFockzQTk7INWgoWzrCNynZQtkMqBZZUHIkOtyMqMAyKKqhkjIVsynEWgZSKQGccFM3KkDLeCK0vQi6hCG+sE86tQxEbaS5d42rpQ0JMpk8JshBjIilkgfHUn/Hff/J7Ofjz9wBw7TOfx2d86d9nPm9AhL02sx0D2+gYY8I6A5tMH4rILIthZqVEjAhkivBo0xch1zboJJTyGIG9zk4OVoZl40qM4Sg03tB5x7J1dL48z7mIz/qQShyfE+a+ITWlCOWNQRBaJ+y3jtkkWLr1fUOWC57fk/uonQRvnbMMQcv1mvM9uvY1Z8ZU7p9uclhr3f0TIVmpVCqVyj1ltVpd8Hx/f5/P+qzP4mlPexpXXXUVTdPw4Q9/mF//9V/nrW996+51r3nNazh9+jS/8Au/cEucbqVyibAailvsEWfXI6fXA6fXI+shcsPhwBCUZWtpbZn3nt1ErBGsscRUYvH6ZBhDESkFzQxDabhQMo0z9FEZo7JsHNkZ/vO//3He+Iv/FoDnf+cr+NS/9jemposSFb2ceVSVxpZ58bFFw7K1DEMiAMuZo7OlYWAbEppL5F7jDLOmrHkab2hsieGOWuacM28YY1kzmEkgValUKpVKpVKpVCqVSqVSqVxsVGEU8Ad/8Adst1sAPudzPudBHk2lcvcRAfItAo1726F7McVvXWouWN4a5i1sxtIh/Rdni/PRGDJzbzm+8ByfNbTOXhDlp02J4tuOiSEoEHDWEFOJshjGhLfCvHEYA31IWBEaZ+h8ESEtGst6hJiKkEYEkmYOtmOJx1AIqpxeDTTeoFNc3pATnS1xc+UYwawpUXcpZ7YxkTPYo2i4IXF82TCmjHeCJmUTFSvC3syzHhQEnLWIAUeeoj1KRN2Hfv8N/MHP/hBx2OIX+zz1+d/D457yOSw6x7ItBaCYSuRO4yCqYTsmkpZIv+2YUYWQMxKVWVuOU1ItAqnJWaxzQlZwjTBqJobAGDNRi8Bpf+Y5sfB4W4o7KdsSHKJFgKSpjL21Bm8svoEQM84I+53HmdLNz3Qej87m7n6R0uN/b+6jmbeshyKGc0aImtmO98zlbDuW8+ZMuU5k2m+lUqlUHlwe7muNZz3rWXzDN3wDz372s2ma5ja/f9nLXsYv/dIv8XVf93UcHh4C8LrXvY6f/umf5u/+3b/7sR5upXKvObcNuzjtfkwc9oFTU8T2uW3k7KaIo1pnCKrccLbHuuI6GqIiKF6EPmUONgHnBCiNEQd9ZIwRM/PMnKX1lpSUmDP/7Zdfy+te8yMAPO9bX8Iz/9ZXshoCoy3iqb2Z43AbWSXFmMR+17BoHPPWsRmUMQacM1hj0JwRI2U8IpCF/c4Vh6rO7cT8AK03pVEiRubNhY0DlUqlUqlUKpVKpVKpVCqVysXEJSGMOnnyJACPe9zj+IM/+IM7fe3P/MzPAKUj+TnPec7d2v/znvc83v/+9yMixBjveoNK5SLBiJDIRXCT8kMifutSdMHaDMUdaowZZ8FEYdZYGic0zjJEZUyZxhpab3buT/PG4YzhsC/xaZsx4p1wbhsJSTm9Grn6WMdqiBiEdR9Zdo5l50i5FFAWjSUkKfFrqowpcXoTCEkJMUI2KIrTEk+XyRgpnd5DKMUUb4TtWAREfUio5l1MXNJMduUaUZ1iNXKJyRuT0qojRMU7YdEaNAsG2IyRzWbLda/7f/jgm/8LACcf92Se9DXfw95lV2Eks/CW1llm1tGniLcNY1JytrQ+M6SePImaUoaUMiErMghdkxAjxTVLFYMQDdCUY7vaBjTDOhThmUjm+Kxl5h3WGB5xYkbSXKIFY8IbQ+OUmDLz1rDs/O7cWlMEXjFncoLOXniPyXTfxKQ4Y+7VfWRMiVjsY2LmLYdDZDMmnC0/vyuGmNiMpRB3FD15azFepVKpVG6futZ4YHjGM57B93zP9/DUpz71Ll/75V/+5ezt7fE3/sbf2P3s5S9/eRVGVS4ZVkPciaIOprn9akiIQIyK5oySOTHzbEJiM5T4602veCN00/wtm7KOQDIH28jhNrBoLa13pFxir50RnLEYa3jrG3+Vn/mR7wPgK77xH/FFX/UNGAMnFg1RlZAyWSGTsUZw1uCd2UXqxZRZztoyz07KdkyEWJoOcs5YC84JdpoLh1TWCEeOt4d9KOueaQ1aY5wrlUqlUqlUKpVKpVKpVCoXI5eEMOrs2bMAnDt37i5f+4IXvAAR4XGPe9zdLlZA+dKvUrnUeCjGbz2QLliqmW1IxSUpl4g5kfIFfusMM3/PhSSqmSEmYlKuP7dl1QdiLoUHM2W+pVxcoErsXYn567zBWTPFU1i2Y2IzRPqYWQ2JoIqbREiNGESEoMrZbeDcthQgnBHGpISo9KOyiZEhZIaUiFHJOWPIGGNKUYSMkXKerQWTocEw80Uk5ayQhggIVgxBtHSiq0E1lyi+mDACFmEIiYPNSCYzE8csF/enIUT+4kPv4c2v+T4Ob/gAiPCJz/w7fMoXv4CohpQyfUxsQyznJWcyRdDUOcM6RDQpTpgi7MwkiioRemKKWKo1BkRwUsRI3goxJTYDpWgz7duZIh5sjSHnzH7nivtWU7riS5FIaL1hE1JxkcqZxlqOL0xx2QoJNymknBVyzjvHqM4WtzCma+7e3kfztgijusYyqjIE5WAbmTeZWWNv977WXJyljkRRrTc7ceS8rW5RlUqlcneoa40Hhm/7tm+7R69/5jOfyTOf+Ux+8zd/E4APfOADvPOd7+QJT3jCAzC6SuX+IyTdxecdiaLKHBOOtw3nNoGUM3NnWU3z33lb3G1zFhAhKSwbh7PCXudooyHFzOG2uE5lHQFwVogJ9ubK//793+bfvew7APiir/w6vuaFL0IzHPYBZwyNc8x8EWh1vqwdjiK9nS3z+1lTxhGiEnNxgW28pfNl3rxoHdshM1saNJdmgXnjaJ3dzaPnjbso1pGVSqVSqVQqlUqlUqlUKpXKHXFJCKOAYuN+N3k4Fh4qD08eivFbD4QLVul+zujkPnQBGRJ5V9BonWXe2rsd4bcNidUQObcJbIYIIpisbIapM1zZjaN1BmeKuGiIiVlj6bwlk7l5NfDRw4EYE6tt5Mx2ZN5YNGW8Myw7h1Ci+4wRDvtYIvgmdVfKJe7C2cyx1rMmsgmZoCCayCK01uIdk+tTOa6dN3TesRkiY1LWk0iInGmyIZki6Oqj4p1ByfRBabwlZQiasQJjUNYSiaq887d/lT/8T/+CFAbavZN86vO/h2OP/TS8d0gAQYkKZ7eB7VQ48iIEzTRTMSWoFrGTMxAzSQFV7BQBOCbFGsPSg3N26qwXGis4sURNCKXbvQ+ZRSNYJxhTRGmNE7y1u+jCEDOdL8+NlCjGeVOEXuuouwLSUbFHASuCm8a4Hcu1c1/uI28Ni9axHiL7neeAIyexxDYkmklIVzr4yzVeHLbK9q037E9OV4vW3esYykqlUnk4UtcaFwef//mfvxNGAbzvfe+rwqjKRc9muCU+r0RkQ+MEI46YlNUkmopZWQ/FHVRE6LzFG0PSElftnOCtYR0SZJh3DrsRxl53f+9kEbJJfOgdb+M//LNvQ1PiMz7vS/iib3wxZzYjnbfMvGMzBhatofMdQ9xyZj3gjNC1ZS4994Y+JLw1bHqd3FsNy7ah8wYj0HpLDIr3Zhe9102Or1DSpYsD7sWxjqxUKpVKpVKpVCqVSqVSqVTuiEtGGHVPuCeFjUrlUuahGL91f7tgqWbObkoERaaISfpY4uJ2jlFG6JylcYY+JvpYxGXLuxCYqWY+fGrNmc3I4RC5+XBAyTtxjbcNUSZllMIY09S9XYRsNx0OWAOapUTPDYnVMHLYp11BxIihicXNyUwOUTFnRIt4JwNOwLsSrTckGFIpvuRcjufhkNhrDa0TlBKl4U1xobKTeEYohRjnLC4mkpS/S1trGSZhVFCldUUs1DiLPbpOcmYTIpv1irf+xx/mw3/wBgBOftJT+JSvfjGL/csRY8gqaE7ErGw3ReizNy+iqtYbvDEEzRzJeVpnEIR1zuRxxFuDNZCAReN2Ll/LrsTjzbylm5y0QlI0w02HW5CMsYZMZtk6VCCmjIgybwyN86UwZMrjbSixI0MsUSLbmHDT8SnXZzm/CMXdKSpRM7Oj6BPu/X20bB1pijTc7zy9TWzHRNTMEMv9cGvc9L5HAsJZY+/y2q1UKpXKvaeuNR44lsvlBc/X6/WDNJJK5e5x5B4LpWECYN5YQiqz7m2IJC0C+LOb8nvJGSbv0WXr0JwZkjIGxYhwdhNwtoj7O2dopqaGIWWImfe980/45X/2QmIYedJnfR7P+86XswnKNo7MvGPeGrZjYhsCVkoctbMGg6GxjnljdvNsQdibW5pRMBb2uiJ+8rY0CaScsSJYK9McO3N8Vubkm7HMSy+WdWSlUqlUKpVKpVKpVCqVSqVyR9TKaaVyifNQi9+6P12wSnHC7uL5zqxHot6Oy0PKJUrOyE5csx4imvPOged8QlI2Q+L0euDUeiRp5mAzFlcfV+LZsghRFY+hm6ImQlKiKqt1QLUc68M+sekj65A4tR6IMbMeAmNS5sagWQkq9FGZWWFQpkILJC0uR31KiJbz3Hhhv23QDsZzipFSdjHmlriOI1HTUUxhiMoQS9FGVRGEpJmoRQClOdOHiClHk4wQk5Jyxkk5Tzd+6F38wU9/P6sb/xwxhk981tfzmM/9SpZdU65BzYyxOE0RYJ0CQ0yMKRXBVzTszxxeDBFBRPAGsgVrDa23JcLPWQyGk3PPsvXMWsuiscwaX4RdFqyUYlBS5cS8ZeYTVkpU35ASV3cdISWSChhhCEpKsBkDnXNkMv2gHPaxiNxMpmkdnTcMMeEnQZZz5Thtx8ixmb/f7qNjM481wnqIk6uXvUtB3xF3R9BXqVQqlcrFygc+8IELnl999dUP0kgqlbvHdophPhLKixSh0LAp8/XtqMjkWTumMi+POdMArTXFkTVnxpRJZM6sB8aUCVEYNDGmjPcGiZBUueFD7+U3f/hbGLZrHvPEp/F3vudHwDhI0MfEakjMRosr02/ObiMpK8c6zxV7DSkLOcP+3NFaYTUqrW1LPHcqTq4zb9ifeTpXhFGbocyl542jawzWyEW5jqxUKpVKpVKpVCqVSqVSqVTuiFo9rVQucR5q8Vv3lwvWZow7R6Mhpt3nFSlORN4ajMhOsDRMxYzDITKqst95tmPCiFwgNFkNkfUQS8TamBiTcno9cHodpnEW9yaZBERQihSdt+w3njObcef6c3odObsJDFFJKdOPkZhAtXRvY4rwJpvJ+WpMWJNpneOgjxxooDFmF/13ctEw85a9LnHTQc+8MWxj6fJeDZG5t6ScSEkwGIaYSUmx1pByiYcDMFbI0/WSVBHJkIvT1MFY3pOcccZAVt75336ZP37dj6Mx0B2/kk99/vdy9Sc9GTI4J3TWEBM0ZEYtbl4CDKkI+Ywp154ZBG9LZ7xCKRAlRTUzbz0WGHKmsYJ3Fu8MJ+ctx2aeRXfhP2fzxrLq0xT1Z+gaAyLFcUoznXM0zpBSERBuhoTGzJntAEBKSlIYotJYobOZM+uRvc5hRRhVkWSJUyTionP36320bIsj1mYosYuNMxcIoM5H4B5HQFYqlUqlcjHyK7/yK7vHTdPw6Z/+6Q/iaCqVu+ZoXt9PrlGtK2uMo+i7IZZ1zGEf8UbQBCFlvCtx2VCixJ0IqzGy6hOtNxxsRsQKXgTTWNY5s77xL3jj//1tDKtzXPW4J/BlL/4XHAZLS4l8njeO9RgZhsRaM60vjRrLzjFvLa13zBrL5XsNrbOEqMzH4k7aOUPUMqZ5U5oojuaVOZc1WlTl3DaVdQoX3zqyUqlUKpVKpVKpVCqVSqVSuSOqMKpSeQjwUIvfuq8uWHHqdp47x+EQmE2Cqnljb3f7zlsW520/BOWAwH7nWQ9xJ6Q6tw30U0TGmfXIuW3g9HpgPSSSwqKxiJSIus0YGULCSkPrLX0oYi0jwryxnFqNnFoPpJyRDOsQMUZYeGGBYTUkGl9Eb9ZAyiXebUyZ9ThiRIoLkhEWreX4rGPZGawUd6lFV4Q/Hz3XQ2M5s46A0lphG5Q+ZKydyhqaiZqJ03USQkJTKdLEVIo6IoIRiArGCduQkPGQt//cD3H9H/93AK564l/hSV/1Tzl54gTeWSDTOIsAnRcOx0gcEkEVZ8EkYaQIl5i61zVnELACVqHxpkQKWohRacWw8JbZFO+xP/ccRZFYI3hToj42Q2I9BqwRFq1n1hZnqGXbkFIuTlTGcGzu6MciPJo3ltOrIlzz3jDGRFQpAilNdFLcvxBojCHnzKJzXLFsH5D7yFvDsblB1bENiSGW63rnGCWyixOssSWVSqVSudT55V/+Zd773vfunj/rWc9if3//QRxRpXLXHDmw6uRKeyQOkqkrJSN4V1xHrRUIcORfe/6aRAxshkRW2AyRISkza5m1jpwzZ26+kf/yg/+QzdmbOPnIx/Il3/mjnDx2DNUyE5bJrerEzHNmG4hR8RSBkzXCFcsW5wwnFg2XLboyn2zhsiUMoawBjBGGmOindeQYlTEq6zHiTVlnWCMX9TqyUqlUKpVKpVKpVCqVSqVSuT3qt1eVykOEh1L81n11wcoZlq2fhEmCsyWm7c4cp4wIi9bhrHCwjQxB6W1xetoMCWt1J4o6ux05vQnknIkpF7empWCNoQ8JawzjqESUc9vAIkPnDKtJZKUZNCvbMdG6ya0pwbJziBgaKyzaEpOXNBeh2JixbYm4OOwDrbXMWkNjHTkLs2YSZIWyTycNB9vA8XlD6yOrMdKHgKrBGMEZi1VhCNC44m2Vci4OWpoRI2hSVCEpGClxfF6U1hnOvP8d/K/X/gDb0zdgrOPJX/ZCHv/Xv6JcZFI6yJedwyD0QdmGiGrGWKHJhiGV/bSuCMqMtew3Du8NjTeoCicXQlRo+sCqD7S+uES13iJHDko50/hSqGmdKaK2PtBHxYih8bBsPNuYOD7z5JzRXERymUxjDa4T7CgsGjixaDgcImfWA1nBtZZlWyJC9rqG/ZnDiCAGTswbjs+b3TX0QN1HRfzmWLT3+64rlUqlUrkoOHXqFN/yLd+ye26M4Xu/93vv1/e48cYbuemmm+7RNucLtSqV2+P89QfcInYyAmn683wBlLdlHhxTJqbi9ATFRSpNTRAxKwp4L4SYOX36FL/wA/+Ag4/+GcvLP47nvPjHOX7iMhaNw7kyT92MkRgzorlE4KWMt4IXR2vLOuERx2csW89+53bve8R6cultnd25SfWpOJc6keJe6g3LxnFi8cDPfyuVSqVSqVQqlUqlUqlUKpX7k/oNVqXyEOKhFL91b12wOmdYc0sn9rxxzBt7t2L4YDomTS4irLEIo9ZDKI5JRjjoAwebSM6l2HBs7hmDsmgdqyESUqbzBrvnObcJDEkxQ2QbwBvDYV8i/saoJbIiQR8jURURA5rpU6ZrDKrgjMEJJE0gpUN7v/MYI+x1jqSAwHaM7HUNqqVrW20mZSXmTNtYzm4iHw0JiRkks8mKNRlvLBlDYy2IYEwprugQGXOJFxQRMqWoYzC8940/x5+8/l+TNbG4/BF89jf9AMc//i+hGRpbOsmtNcSYyZQxbMdEUmXVB4yUc+WNpXHCvHUIwv7M03rLrDG01rAJie2QpmtUWI1F6NZ5i8ZMSnDYR8aobEwRzMWsZMAiXL7X7OIUZ01x3rrxYGAzJsTAXusYkzL3FtNAzJmQMq0z7HcNiybTNsKyKREhx2YeP4nyZk25by72+6hSqVQqlYudGCNf9VVfxV/8xV/sfvat3/qtfMZnfMb9+j6vfvWreelLX3q/7rNSEQGmBhS4xUGqcYaQSsNCH0o8d9IihIq5CKY2IdFqxlkhpDKHTaqMUyxfVjh3cMDPv+JbOPVn72F27CRf/OIfozl+Bc4JrXc0rsxzTRZ6STgjHJsb5q1j2VicM5xZjWjOu3nxZkzszy6cty7a4ja7HRNjVLwzWFuEWa3LHJt5nDUsWlvnv5VKpVKpVCqVSqVSqVQqlUuOKoyqVB5iPJTit+6NC9ZmiGTAGwFvESlCoXvCrLFswy0REn0oRQYjJY5tTMpeV0Q1nbOQy3F307Edo9J5y7IDO0bWUwf33swRIkQUQWgby8FBz6pPWDsVKbqGmDLLzjHEIr7qQwaEEJWYlUXrcUYQESxKawxjKkIogMZZsiqIhyz0MbHfOVa9ZUwZciZEZSQzWghJmTWCNaBT57oxhiwWSCCQNePCIX/4H17B9df9LgCPesrn8pTnfSfNbEHOmWbqWDciqCpJLInMdoiEyalJjBBjxgrMnXDFskFzEVPNvGHeGKw1eGNZNMJe61j3iXVIhJRxpvyu9YJ3wqiKiUKSVGL0jKHzhmXr8Nbszt2scdy8GohaIgnPrkuOybxxdM4gRiBmnBGWjaPzxVHKShGxOVNEUM6Uc9y5Est4KdxHlUqlUnl48+53v/sB2/eVV17JyZMn79M+vuVbvoU3vOENu+dPecpTeNWrXnVfh1apfEwwIiRymQ+mTEi6W7dsJndYZ0wRRGlxZp01ZtfEMSRlNSirIXJmM9KHRMplDjqcOuC//Mh3cMN7/oRmvsezvuPHuOzqT2DZlui6lDNDgEULx5eew77MSVtrUA+jZk52HitlfXBuE5gdK2sYzfk28eLeGvzMoFNzytntiJESP91Oc/zLFy2L1tX5b6VSqVQqlUqlUqlUKpVK5ZKiCqMqlYcoD5X4rXvqgiUinJh7NiH9f+zdeZxkWV3m/8/Z7hIRmVlVvSCLiLggojA/EBFGxmUUcNSRURBBVHZtbFtlpxFwYxMQFBRbBEFRGRRBHBps6NFRxnEZGUdcEGHYlKWXWjIzIu69Z/v9cW5E7d1VTVd3Vdf3zYtXV1Zl3rwZEV19b5znfB9IZfrPsW/63xitFJXR9CGx8IEQMymrdUVG4zSVNevd35Oq/FVaV4bQZ3wEHxKTMZC18JE+RvqdHqtL4MYaxbIP7N8d6ENi79ShAFSpv1j2mdqV79nHSAZ2hgAZNqrMZuPwMRO0ZhkSVVL4uuzunlaG+ZCZmDKJqQrlfBtnQUVyTqBK/VzOZVLSYvBURqPHekJrFFVQWGfwMXL9R/6OP/vtF9Afug7jKu73yB/ny//jd9KH8jiDQo8LPlplrLYkMiorFiExDLEEnpRGu4zRYxhJGaaVZrOxtHWZyJRyYlJbUs4suoC1GpcSbW1xGtpKsdlYklI02tBUBqMUGxNHbTVGqxJiMprNptTo+ZBoXQnPLX1g3ocyCSt3dCGNi1aKkBIxZqaNZaut18/3RuOOeo2ksUYx2kyJTAkhhBBnp7vf/e5n7NgvetGLeNaznnWTv/45z3kOV1xxxfrju9zlLrzjHe+grs/xC1hx3qitLmEoa+h9mWo7HUNHldG48d6lsoouQM6JnDWVNlirWA6R7S6wf6fn0HIABTFmco78z9c+n3/7h7/EVg3f+KMvZ+MOX4jKZSOAUVBbhVZlAq1WmdoqQoSQMhNnMVqt76XmfWC3D8wHz7RydD6u72GOpbXCGIUzhj0Tw0ZTNg001rDRuhN+jRBCCCGEEEIIIYQQZzMJRgkhznqnMwVr/2Igpkzqw/prb4rKlmDUso/YMSSllUIpyjShMngJgElVdoRXRuPH0NZiiEQfaZxmUhmWXWIRAtFEcs5sLyOHukgXIhl1xCKHpqk0KoM2JXCTevAxk1OZurTdBZTSaF1+/hChaaAymlk91r41jpAyKZVJUrfbqln6wPJQxGjFtHJoA5UxdD7Q+TJtSgGNLtOjcsoM3vMvV7+JD175BsiJzc/7Ar7hyS/gws//YoYYUZmxDkThxilWldbsDpGUSs9fZTRU5T84Rmt8zGjK14QQWZJZDonaeTbaCkXGh0zlNFppUKWqcLNx7F/0OKvZbCt8zEwqQ1uVANhGbdEKnDXM6vIchZSZVZZD0XNo4RlCKpOtrEHrsoiUYqJLpfLP6jJtKsTMocXArHHElDkwH46bTtaF8vxNa8uslv+cCiGEEKfjRS96ES984QvXH9/xjnfk6quv5g53uMMZ+X5PfvKTefjDH35aX/PhD3+Yhz70oWfkfMRtQ+sM8z5QrUP2pUJ6Wpc676U3NC6y2TrmXcKaMrlVWSBqMpnFeE/gY8aHyBATf/fml/KJv/ljtHU8+MdeysVfck8aq9FWE3O53u1CYqPRzJqyGUMrQ8qZYdxM4sZ7iUllyArmXeD6XY+alWv9EwWj0liBvRhKnV/tykRYgEl9elN4hRBCCCGEEEIIIYQ4W8hKrhDinHEqU7BWYaXVP091WlTKpTJiCImUoQ+R3S6w9JE9bUXMiVntxl3hmZgzq0NrrUr93hCZVhYooazOl2OkmGlqTZ8oVW4hsduFEnQCamNoG4PTmomzXDCtaCrDcgjM+4jVGq0znVcsh4xRmpjLpCKrNVbDrHZYramdHiveLIcWA21l2O09lTVcsFHT9ZFliFRWsRhimQ6lNdMKQKG1Kj+fz3Q71/MXr/9pPvPBvwHgC+//n/j6xzyTdjLFqExMBqM0XQzElHG67CxHlUldOSmGlKmVYuocPiU6n2itoq1LLeIyJlqlUDrTB4UdApPaYIwqATcyrdMYNFqXWrtpVcJftTNsThyts1ij2NOWiVO1NXQhshwXdHaHQEgJaxRalZ39G63lgmm9DlYdmA/kEPExcXDZ09hSxedCCZKtxUzvU6nnc2Va1bwPpFymeAkhhBDixr3iFa/g8ssvX398u9vdjquvvpq73vWuZ+x7XnzxxVx88cVn7Pji/KS1Wl97ts6w0wcWQ8Sa8vuz2jLvA1ttxXXbPbtdYj5EQuqJSZFy5prdnpxLDV8fM//8jl/h4//rnSileeCTfop9X3ofrC5hqNaWa1BryszSnMuGjEll6ENEAUPIVBYmztJWBgXsGyvJ8xjc8rFURVdWo8aJsUMoleGr+6ja6fX17XSsqRZCCCGEEEIIIYQQ4lx0TgWjdnZ2+I3f+I0z8rlCiNsGpYBxkhSUwNMNCTGxGOJRiwAAMWViyuOfBxY+QFa0rkIriJSFEGLGx8xsrH7rfWJaWZxJWKXoTaIbpyd5nylRqEztDDvLME660liluGBWcce97TqIs9E4JpVFjTu8rVIYk8lkJrUhpXFiFgptFM4oLphWVNbQh0RTGUKXUePj0A8BtGJaWfZMK/ZMy1SohQ/EqMmUBREyHPyX/80fveonWG4fwNYt93/00/nKr/82amfHyVSG5VglGOeJLgRMyhiTqY1GUxZ6qgRdDBitMNlywcwQQwYFikhlQZPxKaO1JgQItgTPNhtLaw3LENlZBCbj4lLOmS5kLpgZLpw2WKPWAafVc3pkKMqHxBAStTNcYBqmtaGxms3WMqkcKWemtaGyiu2lJ431gq3RpAztWJ2YVgtWIRFSZqcPDCmVur6hPBYyOUoIIc5dt9V7jXwj10K3tFe/+tU85SlPWX984YUXcvXVV3O3u93tVjwrIU4upXzSqbVOK2JOHFwMpAyLITCExKGlZ0/rmDUGqxU7nWdaO7qQOLgc2L/wKBRDiCx7z5DKNeyH/ug3+Zer3wzA1z7m2XzBfb6RyqhyDkPAGseFdbk/qK1BK4WPCR9LRfbOEKi1wSo1VmxbnFHs9pFZZYk5Y7UaN4KU69pj2XHTx2pSVFsZucYVQgghhBBCCCGEEOe0c+rdrWuuuYbHPvaxN/p5OedT/lwhxG2LVopIPiK0lNZv6h9rPu7oXgkx0YVISpmdLuBjZoiRyhrIij5EtpelKgOgsYbel9BNqjKz2qFVYDnW6lWtZpIyIWWcVyyGxGLIWGPQKrG0ikZZNhvDnmnFRRv1UdOJUi7BLJWhchrjFEMXORAjxpRFi5xgs61oLFijaSpTziskamvwLhEz7PaBkBRagzUKH3Kp0KjLoscQYglG+cD/ePMv8ae/+2sAXPwFX8pDLnsRF9zhLkxrS0iZ2ipqVxZWjFZcOK2orWYIkZhKOEypUmO49J7eJ7Yah7EGp6BtLU2lObjrWXrP7lB2rNdW46yidZbNxqKUYhkiZMXeqWW3j3QhkVIiDxFFLkGwpNlqD09rWvrynA6hTOcqO+JLtYmzmkpr9k0bNtryfQ4tA40rk7Xy+FgZpWgrTessKXP4OXeG6REVI71PbOPZbBzzvgTdZDe9EEKcm+Re48y74oor+JEf+ZH1x/v27eO9730v97jHPW7FsxLixHxMLPpIP14nH/VnoQTxh5BAlfuInEs9XcyewSc+eWDBEBKTylAZzU72LPpI5yMxJA71YQzXl4mmH3/fH/ChK8s1+H0fcRl3vv9/wvuIU5qYYIjlWHnMMhmtsEoRxs0ZKWcWfaRuNXVlSsW11Wy2jph6djporWGjdaSUqZ0mpSOCXkdURq9IZbQQQgghhBBCCCGEuC04597hurEdz+qI2qxT3R2tTrFqSwhx9itVd2kdWupDYprzcZV6O52n82VVoQ+RboiEVP7OSDnThbieILXTechl8SFRphl1Q2RS23XgpvORSWWZVGWi0tKXigqjFbPKoBXsnWSs1jgDu12krRKVKaGexpn1gktMmT5EfCy/o1T5PY3GqHIOPmQ8JZhkjEIpTRfK9KuUoDKKIa56BcEZVRZhEhiV6XKkzoqlh5wVCth/7af4vZc+k09+8G8BuPeDv5tv+IEfZzaZ4ozB6Iw1pe5v1lisbgkxcmAxUFeW7eVATJnKaGIqKyzT2tD5SCIzc5qQEo1WaKXZnFjSIjOEEmSzRtM6Q2UUhhL08j6xjBGfFEPIhBhJgAYWPnJwEdgzsWx3oYTRjMKPO9+XQ6AbQ1JWl4Wfpi4LRY3TVEYf9RrofcIZzYWzmpgyg0+0rgSsUhrDdpTw3bQu9X3by0DvE52JNM6w6CNbEwlGCSHEuUruNc6c17/+9VxyySXrj/fs2cNVV13Fve51r1vxrIQ4sd0+MO/D+uMhHN5AMe8jnQ/rIFHO0MXIThfQuWw8mPeePiSUUuyf9wwhc6gLzAcPSpW/F3Ieq54V/+8vruL//NdXAHD3b/kB7v5NjyBpTc6JRUhooHVlYuyBZc/tq9WUWUUmM+89y1DuPSqrxuviUrEN5bp6q3UlBMXRNXnHUpRpVJPaSOBfCCGEEEIIIYQQQtwmnDPBqFNdeLgpVRFnW72EEOKma51h3pepTqvQ0nKITI/Y6TzvwzoQs9uXiUbAeld1iKUOzyhFSGU3uDGKxRCwC8XFm826KqOpDLtd2e1ttS7f12g2jC71deMUpZ0+oAFtyu5zVGZP66hdCU2VGozMTleq3FZCTMyHyP55z3Ioxwo5c/28x2mFM4aJGzjgDHfaN0Gh1pUYq59tWlu2x+NqYNpUGMDZElRKGf7+z/+Yt//iT9DtbtNMZjzsx36GB3zTt5bQkzXElElklFI0TjNrLE5rfNKEDDl5FkZjdakVHFIeA0Waxhl8KF9vdKn8632pLyTDrLFkyiSrtrJstCVcFnJiu/dkyu72pY8shsS0MmNlYubT20tyrlAoKqfph7KjP2c4sPRkMpUxZbd+XXbAb7WuTNdymu2uLHh14+SwVW3IwcVASBkfEs7qEnw7Zrd8bQ2TKrMYIsuhBKP6EEnJrkNUQgghzg1yr3FmvelNb+KJT3zi+rHY3Nzk3e9+N/e5z31u5TMT4niHln4dru+GyNIf3kCx05dpUABDH7nO9zDeQ9S2bI747HaPUuXeYt4FfC7BJpUzeyeOymo0YK0mp8QH//pPef+bXgg5c7dveBj3eegTyShao1mO01hru6q/y9ghcnA5YJRCa0XOmYUvmyMmEzNWcSv2Th1uvCcZYlqHo6xWZdrU+GdHVgOWmm8j17JCCCGEEEIIIYQQ4jblnAhG/fqv//qtfQpCiHOE1oraGroQaZ1hZ6zLs6b8fohpXZ93ZChqFYgJMdH7jDMl/JNyZlInVFZcs9ux03varlSsHVp6tlpH7TS9T+x0fn0crcru79ZZnNHs9oEhlGTSoYXHGc0FsxofEpFMZQ9PmarHndkhZnaHSEyJEMuCRkiZLgaWQ2KjMuyZGLLSzIfAYggcWgw0lcEoRe9Lpcd25+ljYt+0Qqky+WijtrTO0XdL3vyal/De330DAHf5snvyfZe/nL0X3wkfEzHC9V3PtDEoFMqANnr8+cCoMkmrrg2b0eFTRhlFrTNLHxhiKgs2MWMUqKzWi0taKZraMAwJnzK7XSABKSfmqkzBCinT9YGDcSAB9VgZOK0sTaWIKXOwC+z2c9rKksmkBCEncgRjYepsqdCzmgum9TjZyxDG6pAwPq4l9FWeO2d0mQwQI87qUl1ygtdbW5n1zzOEtH4ep1I5IoQQ5wy51ziz3vKWt/CYxzyGlMo112w2413vehf3u9/9buUzE+J4u/3hiaPb3ZEbKCDGMhm1sYbtzpdr5ZyBTEhQo7hgWnFd7okJdjtPyBlFuS/YO62YDxFrQ7nuHAKf+uD7ed+v/gQ5Rb74/g/h/o96KiXmXzZ4XDCt6AMMIdCHiHLQhczOIqCAxloqowgh09aavW1FyrDRGDbGiVDLoUzCtboEuBRw4ayW8JMQQgghhBBCCCGEOG+cEyu3P/ADP3Brn4IQ4hwyqUswqqkMQ0r0PrG9DEyqXKY1cbg6DWCjcdixam45hqYqp6mtIeWM02UKVB8ihzrPoWWgsmYdiimLDmXhZDlEOl8q8pxVKMqkqSEkFkMolRe5VP5Na0tymYUPpJyJ47kd6gIhpnEHd4ZcQlJDyFirUFFBVqAUtdPknNkzqQHFTh/KpKOUMEqx03mGUH6G2cygtSZl2DdxfPqTH+Nlz3oyH/mnDwDwLY98Ao988jOwruL6ec9uH0q9Ryg/hwKGkJl3HqcV+6YVOpfd8Ysu0DaGCaWK0MeMQqNVpnYQdebg0lONjyWqBKMUirY2aJ8YAhAzO12gDwmrFTGDVYo+lo/vuDWlrsoEqDvubdFacWA+0PnEso/0IY7BuEDtNBe0Da011JVhq3VMKkvrDNPacnAxANCF8Tm3el25WNkSjMrresUTv9a0KlUl/VivUtny62l9876mhRBCnDlyr3HmvP3tb+d7v/d7ibH8t3Y6nXLllVfygAc84FY+MyGO52Na1+cdGYqaVGZdoVxrw05farantaV2ZUPD6nPLPYdliInKViyHQEywGMrkUx8yIWRuv9XwkX/6AL/9Mz9CGHru8v89kK97wvNAK0jQOEvjynX2tII+aBY+lkB/yCwIpbKaREyKSWNojMbZUht98UZTzivE9aaQVa1ebWUilBBCCCGEEEIIIYQ4v5wTwSghhDgdzpTQ0bwPbDaO7TG0tNsHDi09VpepRSnldf3Zbl+mK0EJRW3UZYf1rLbElOlDYrN19DHR+cj20nPRRsN8KKGmWe1wJtINZXpQHyJ9KAssu31AqVJdVxsN0wpjyjnsm1RoA9fvlpDOEBJxDEX5sRJvPkRiLlOljFaYRrNRjSEppRhSwmponMb7xDxnDi78emc7KnPBzHHhrGH/Tk9Wir/+4yt5xfOeymK+y2xrDz/8/J/na77+mzFKkXJm/wJUgiGWx+nAYuDztloUkIDr5z0+JkIEo2Hee/qQqJwh51JlN6k0867seQ+pLOJEAxWZSmuMVVirMQq2JpasIPjIwidSzAwxE3Mmac1Wa5nVjroy7JvVbDSGyhiMVmw2jnlfQmvbC7AaptqSgGll2TetaVwJZE0qs57mtAo7pfEXzhxeIFr9avWauKEWpFUYKq1DVFKZJIQQQrzrXe/iEY94BCGUoMlkMuGd73wnD3zgA2/lMxPixBb94fq8VdBps7XU1rC99AClDnq9ucJS2RI2qkzi0HJgd/BMKks/RLRW3H7PhBAS1+z2+LnHWUXMmk9+5F/4hac/jn455y5fcV++62kvRbuKlDMpQ4xlKqtS0NYWaxLGKpZ9mSbbxcT++cDtthpCzhgMeyYVm41ja+LQWjEfJ+cC1K7UW0PZRCKEEEIIIYQQQgghxPlEglFCiNukVaCp85HNxtGZyP7dgZQyi1Bq7xRlwSGmEoOxWtFUhnpc4GhcCVj5mOhDonaGjdbS+8ihpae2mlnjMLoEZ2pr1nV9Sx9YDInOJ5zWbDRlwtQQErPGshgiTpdaDlUa9tjtI8M4USHlTEplStTgS/1F4zQJhTGgnaG2msYq6srQh8T2wuOspl+GMbSUUFqxUTu2WotWio0q8+oXPZc//K+/AcC9vup+POelr+Hi29+RISb6oQSZaqPZUSXYFSk723e6wGZrx2lWsNMHfEg4q0lZETKkELFaY5RiWlv6NnJgEamdxenE7hBx2hApP5tSCW0MMcMwxPWkKGcUEYVVZbrWrK7YM7XEBNPacMc9U6CEmXa68lxMKgMJ8vi/ymjaujxn1RiKsmNNIVCmcXE49LSaFgWwijatfkvdwKb61Z+dSohKCCGEOF9ceumlDMOw/lhrzeMf//jTOsZll13GZZdddnOfmhDHSePGBoDlWKU3Ge8L0liZDKxr9trKrENRwHoDQ86sp07pVH4/xETjDEPsWfaBaz/7r/zS0x7L/NAB7vQlX8F/eeYrwVW0lUOrzHyI1E5RG1VqphPUrtRA10azTGWq6dJHlj4ycZaJczinsUaRc2b/fFhfk9ZOsznW6k3rUvMthBBCCCGEEEIIIcT5RIJRQojbrK3WYcbd0o0z693R+xcDTiucKfUUSisaY3D28CLBkZOF3BiqWQyRraZiMUTmXeDgstTWTSrL3omjG+v5+pDwMWO1KjvJxwlU28uBIWR8Tmw0FqcVcx85uEhUVuOXnkUXiZT6vxDL1CilobGGBEycRhsga1pn2DNxKAU+ZgaVaJ2hp+wE74eS2JmOgaBPf/zDPO9Hn8i/fPAfUUrxiCdcxqOf/FQmTcVu79ntAyFkMqtpSooQoRsSs9oQx1pCgK3GYa1ivizTuGJOMNbeTWuDVpreR5wzOB2prWZQijZDZTRNpdFKlwlUObNcRnyM+JRpnQGt2HQWoxVtZdk7tbTOorXCqvI8Ga3WO+M7HxliQinFTjcwxERjLRrFnonD6uMXgJRSkPM62HTkpKfV4pcaa0ZuqG1k9WWnEqISQgghzher+ryV3d1ddnd3T+sY+/fvvzlPSQjSGCjqw6q2uly7dT7iQ0IrRUjl+nBVPdf5snHAh7T+s9X0pfVxcwlPLfrAfIhYDZPKsn+3J2VFZTXdELjm2s/y2mc9jkPXfYaLPv+uPOI5v0w1mRJT2RRRVxqnE0ufSKlsNHBaY62mQWFMKJstYiRlmFUWUOz6wAWqWk9uzbls+mgrsz7XtjLMankLSAghhBBCCCGEEEKcf+RdMSHEbdqsttRWs+jL1CVnNa3TWO2YNXY9HQpKfVplNW1ljttJPa0tMWd6n9g3qSCXmrqcy2LJ0htAYY0mphIsMqrs7m6cQSv4vK2GtrJsLzyf2e4Iuez6dsaw2wesUkwqQ8qKIaSyQzwr9DgFyepy/kNMGJWpncaZEhzyMRFyBq2YVBZrFIP3xJRorOF9V76VF//E01kuF+y78CJ+4qW/xBfe6/50MfOZ6+Z4n7BW0ViDs4rcl9I8n8rUKZ8yE1PCWDFldvsAg6Kyhj4mJtbS67SuoAup/LpSCmUgpEzOmYkzbE0qjC6/Rx4/V4PJZWKXxWCtYu/UcdFGjVaKPqQxJGUYxhrE1YQnrRWT2jKhLAD920FVagjV4YWuWX18MEoriOPXEzM+ZmpbFrZ8LMGoxqzqUU6+s34VotLrEJUko4QQQgghziY+JhZ9pA+R44Z7jlOefMzMe0/KsGfi1td0w3hd2I1hv8rq9Z+VSbERHxPLIYICHzJRw6xWLIYSYFr6yIEDB/j15z6J6z71CbYuugPf+/xfod3awmiF1YqswCjFrHZkPCmO15kGZq3FaVhSrvubyhBiRulynbq3dUwqQ2U0W62jrSzVEZs+prWVUJQQQgghhBBCCCGEOG/JO2NCiNs8ZzRbE03nI4shMO81KSesKpUXWo1TjJxZh1tOZLNxzFVgCInKaKwrISSfEs6occf5uDPbmuMWIybOcN1uz55pxaGl57rdnuUQmdaG3U7jYwki7XYBH2AIkZgy1igUhphg6QNOW2qnMEbhY2ZDs64D3O1KwMpZw0Zj2Nld8pLLn8lVf/C7ANz/gV/PC3/hCtzGXj59YMFndjrmfVkgqoxmG49GM4SIjyW8ZFBURhMpgahZZbBOERI0Y22INZrKaPpYpmU5o/AZEjCrHEOMaA0axaTRWKUZxl33OUBlIOQSDMs501rDtLJMK1uq9WwixUyIGec0fYhHTfhamVSlNi/nvK7l214EZrU77nMrq/Ex0lhD71MJo1WlfnG1y97ZMtXq2KkAKynn9WJZM4bs6hOclxBCCHG++djHPnZrn4IQAOz2YV1vByVs1IUStF9NjDrUeZzSxFTC8oshUtvAtLbjJFXI4y9WGygWQyhhqFFI5Tp4OQRQ0DpNooT5D23v8IafejKf+eg/M9m6gEf95BXM9t2OqbMYrbEWOl82Rjijx1pwMLpU6XmfMKZ0cNe2XOtnm3FWs9FUXLzV0DrDhRs1m2257lWUqu9JffymDyGEEEIIIYQQQgghzicSjBJCnDeMKZOF9ozhnY3GnjTwcjLT2o6hmwjjBKpGG/ZMquM+90SLEbU1XLPbYUypxpgPgf3bHdftDvhYJhV1IRF8KjvaMyht6GMGlQhJYerM1Dmc0aQMIUHtND5kNmpLyhmjNJ/92Af5qR9/Ev/2sY+gtebSp1/OU5/2DK5feP75Mzv0IaExKDI5x3WNniLSxYhCUWnFwkdc1DhKfd0ylCDYxFnayjDVihBTCZX1gZQzKZaFo5Ayu/2AUbpUAtaWrbqmcZqYE8shcWDRk7NGuVJNUhlTnptK46xmWlnoA4cGT1aZSW3wMZ2w3k5rxawx9LsRZ8onzIdAH+JR08GghJ0WQ8QajdWlNmVn6cskK6AZ61Mqq08amFsOh0NU1Riiak/zNSWEEEIIIc6MQ0tP50t4qRsiSx/X13pH6n1imSLzPuBMmQhVpj3ldW3y6p8axW7v1xXTQ0z0Q2Tel8lRIWVQMMSMDon5vOMXL7+Ej//j/6GebvDQZ7+ai+9wZzIaYxRWU65HYwlXLUMgpRK6r5xi8GVjQM5QWYNSZcOGBkKGzcaO15+lxntVF97eyKYPIYQQQgghhBBCCCHOFxKMEkKcN7RSRPIR1WnptINRUGryNhpHZVQJJ1ECQ6sd51qpky5GJEodX20NB5Pnmu2O7S6QyRgNORsmLtON5xrH6UnOAFmhjKIPkbmPVM5w4awipnLMmEv9x6Qy/P5vv4HXvewn8UPPhRffnpe95nXc4973Y7tP7CzLgs9yCBxY9KUKzxnQitoo2kqzkS0HFx6lFUYpEhl0CXdNKwuqTFaKZBqj6WIap0dpckpkMq1TXLsTyLlMt6qtYaOyOKtoKk2IipThwmlNVrAYIv2QgMwyRjaxdL5MdLJGEVLCqFL3l/LJ6+3a6nD9nTaKEDPby8CkyrSVOVzBp8okrD4kKqfZ2R3ofGRaWWbt4ZrF1fGO1YfIYpwSsPqc2soClBBCCCHE2WC3D+tQ1HZ3OMikVJnwuQpApZxZ+jL9KeUSqq86zQXTmm7crFCPgSSA+eAZB4YyH8K6Vlmpcm8wbQyZsnFBk/m1FzyVf/rrP8PVLd/x9F/k4i+4G8ooBh8JSVOP17RNpemGEtIKKZEBrSzalJro3d6TosJZxayyNJVlw2k+b7Nha1Ixayyft9Xekg+xEEIIIYQQQgghhBDnBAlGCSFu01LKLH2kHxcTdrtISIndztMNJbxkT6Na4sjqtLayVLZUXUzrG//rtPeRg/MBHyPX7PRct9NzYD6QFRxaeHaWAWsUiUQaF1us1mXHeQJNosIwbSzzPtA6jY+OSWVYpMAQM4cObfOLL72c//me/wbAfb72P/KUn30Fd7nT7el8xGrFdfOO5ZA41AWUKnV4TaWxWqNQxAiKjAa22oqtNrG9iOMu9TLFqbKaneRRAKpU2OWUuXij4uByYEGp9Uu51OppxVh9l5l3gYX3qKQJOWG0ZuIMPmaqRrPTB3qf2O4CMZf6EGMo06yUwmgF+eT1dlZr2soQY2ajdix8qU5ZjFMCKlPOv4TYYKfz+JjWNSnDGMBKOTOr7XHVIylnlsPhUFTt9PpcJrVMixJCCCGEuLX5mNb1eUeGoiaVOSoov7LZOGpriClzaJmYd4HKajZqR+8jRimUVkSfmA8lSH9kKKpxhtoaDix62sriQyKnzOtf+hz+5k/ehbGORzzrlVx0t3uRci4bHjLEnIhodFIolamdog+QUpkkFXLCJTjQBeZDpHWaqauxSrGndbR1+VkaV+5JhBBCCCGEEEIIIYQQx5N3zoQQt0k+JhZ9LHV04+85o8kEtCrTneZD5FMHl+yZVLSVOS4AcyI3pTptdS7X7nR0oQRw5l3g4MLjnOHgvOfQfGAR0jhlqhTaaa1QQIyrcJEiZgghMastQ4DdzuNMmbz0oX/4P7zup36c6z79SYyxPPzJz+Abv/Mx7CrFJ66bszVxXLfbc2DuSSmXWg6ruWhWM6vtWMtXJmn1PpbvFRNtZbG2TJVyShFTImfFrLH4kJk4y7SxdCGuq/ByBYsu0jqDAvqU6X2ksppDnQdg6gyTxqKUYjlEYkpYpSGXnfI7nWdSWQ4tB1IqNX8bG+U/W5U7eb3dEBKTyuLHANtW42icYTmU6pQ+JPpxEQvKtK8hwFZjCUkDanyeM60zdL78XDmXYw8xratUaqfZbFz5eU4QohJCCCGEELe8RX+4Pm8Vito8YiLosSqr8TGzd1Kmsc77QDeUQL0zmuU4xfSA9/iU6EJch6JmtcON001DKvcJxmr+6y+/hP/+B29Ga80Tn/fz3PHe/55uKHV7yyEwqS0kRYjQVOB92dCR8yp4r1n6RNIZHzMGRVsZLphWTGvDtHZoDZPastG448JeQgghhBBCCCGEEEKIQoJRQtzGHTkxKeV8SnVv57rdPqx3iEMJs3QhklJm0Qd8TPiUiLFMETI60IfEpDI3OPnpplSnrc4l5UwfEz4kPrvdsX/RM+898z4w7xNal+dD5cQQMqCZVZpMqcuYVIZuyISYCFFhtMZoWIw71f/7W9/AO177MmLwXHD7O/Gk57+SO3zJPVmGUsMxhFQWWoDOR3zImHHS06xx2PFnqIDel59VoVCq/LpxGmcMzmqUBnLGGsOQAxkwSrFRO4wux9dRMWnKY2MM7Mw9GUgxwbioE3JmZxkxJtNYQ+MsfYhUTrHbJ7aX5bF2RmO0otJmHUiaVCd+no6c6HXhrMbHVKZiOUPjzFGvhdW/C3unFbP68MSo1c9eWX1ciGrF6vIzrCZFtZWRXfpCCCGEEGeBlDJ9KNeRy7FKb1KZk4aioFwrLoaINeX+aBWm74bIRuPolgOqMuv7qZ2lx5oyNdSZch3tY8YqRQLe+Tu/wrt++1cBeNLlL+be/+EhXDcf2NNYhpzZWZTgfUoZVQbElqo+BSGAs+X7KwUazUarUCj2thVGK6aVpa3K9983rYBSDyiEEEIIIYQQQgghhDierOIKcRt1oolJaxkieV0xUVvDpD61iUlnu0NLT+cP7xBf+jIlaMUZzWIowZc+RpZDYgiJrYkj5UzKmY1xAtDKkdVpaTxW58vHe1qHT+mEQbMjz+XgfODgfKALiU8f7Di0DBityalU7A2x1LfFDE5rUAqlNDlnfIBBlVq3IZZJTkOMmKQ4uH8/b//Fn+Cf//p/APCVX/sgHnbZT7O5tcXOcmCIiWnlmMfAgcWAUYpJpTHWMPS57HgfIrPGllDRGASqrWFPm1h4xaFFYHNiaZwmUyZYBTItmspprFE0riwUhVS+djkkKq2ZbVhizDRWs9sHUoKNxhJi+V5aUcJTWlM7Rc4ZpxVaw26fSDkwqw1aabb2VOMzkplWJ17YOnaiV201W62j86mErsYawBNZ9IGQMnsmDmf0CUNUWisaa446xrS2EooSQgghhDhLrDYDDCERUkapw5saTkYrRWVKKL6pDENMbHd+vHa2WKPZWXpqq+m6ONbpQd2W+4YhJDofqZ3m3W/5Dd78yz8HwCMvvZyvetB3st15rFZMa0OVyj1HpTW7PjHvPMlZtFZYpahajc6KLiZqq6msKlV+KIyGz9ts2DepaGt7WlNshRBCCCGEEEIIIYQ4X8lKrhC3QTc0MelEAY8uRLoQz/mAx24f1kGk7c6vazOUKjuondElwOQ0h5YepWBnmdk/7zm4HMqOb63ZnFg2aofTigxlqtMYslKUBQ3dw9a4EBJTPi5olsjreo3tzrN/4Qkpc3DZ41OZTrWzDKAyG61jiAqVYaePpFxq5lCgx6lNMWcyicZaliFwYD5w3Yf/jrf9/DPZvv6zGFfxLU94Bvd7yCNIKA4tA3k8p8qWaVExZWpr+Mx2j1GajcYSk+bA0jOEhDXqqNrBWVthbCDETEylVo4MISWGlNkeBqwuAaHy2JVKv9oa9k0hA1aVykIbFMs+YU2pNtk7cUyqcaKUHmsCU6mr8ykzrR0hZiCTc1nQGkJkstGgVPmaY51solftyv9Tsjc4Pe2iWU3MeR0ovKEQlRqPfVsJFAohhBBC3Faspn1249So2upTqpmbVGa9QaCtEoshMh8CZqnY0zoOLf1R4aMh5PVEqtV1/1++9w953UufC8Ajn/SjPPiRT2C78wwhl80TqlRlb9aWBDQRtnuPjyV01diyGQFgw1gmlaV2GrLCp8jeac1FGzWLIdJy6lNshRBCCCGEEEIIIYQ4n527CQghxAnd2MSktZjpfSqVYM7QVGZd+bZ5zMSkc8EqlARHh6ImlaGtzFGLIftsDcCB+YA1JZTT+4SPuVTWbUfmVWCImZgSPmWMUkxrSzVOEkJlWMKhhadypUZtWlsqq9npPQcXnklliLk8zjlnKqPIsezmPrQYiDmjtebCmWFIlpwA1TPEXKrjnMaoEhbqY2Y+JJzJxBB53++/nr966xXkFNlz+zvz7T/2Er7sK76SxRg+qqymdpoYE8ZoalOx0wechl6takUyXTA0NpNzorGGSeWoncIZzW4XmFaW2JbKvhATTWWptUYPkd2uhKkqq3FaM60NiVKrt7PMhJy5cNawlRP/un/JBbOakBM7y4DSpQrEGkWIpT4wZ2gd5B6mFeTkiDmTcllsqq3BmnJufUjU48LUkRO9AGqn1xV3k/rw4pXW5Tmc1id/HWkUWxN9oyGq22IFpRBCCCHEbUEau5dXk15PNcRujWZSlUq9We3ofeTAIrHsA1ZrfCgTXq0qGwB8TFy706MUGKX54F//CT//Ez9KzplvfcQP8N0/9FR2+0hrzRj0VyilaCvNvM8MQ2ZjYjFj9TQZaqtwWlFXmj11jbPl2tfHxFQbGqvZ6QLW6JNe8wohhBBCCCGEEEIIIY4mwSghbkNOdWJSymWSUD/WS+z0gSElNhvHcohopc65yVGL/nAYbPVzb7aW2h6/SDDvAzGVxY/GGVKCIQ2EENkdqy0OLAf2thUhZVJM9BkWXQRVFiya2pKTwhqFHyd0tZVhs3H4WCYcHZgPhJTLJK7GshwiIZdFlNXzNKscTa0xQyAk2KgthzpPolTWeaAymsrA0if2X/tZrnrN8/j0P/41AF98/4fwdY97Nns3Nxh8xozP9WZj2RwnWmkU8yGQYQxbKVQuz3OKCa8UoDFG01TqqClQ1ig6nwi5vHacLgszeZwMtdE4NlvHRmPZM6nY7jwpl+/Tjos6oU/EnKicxndxHSxSCnLOWKM5/DQZaqfZ6TzWaIYh0Ljyexk4sNuz2Vh2u4DVipAyw3g+UEJRq2DftLY3eZrTqYSohBBCCCHE2Wd1Xbj656lMi1qZ1qVeuvOJjcYxxIwPZZODAoaU2O0jCnBWr8NXH/6/f8nPPf0HiSHwwIc8lCc+42fow1gdbRQXuJqljxit2JyUa9SFjmgFs61yz+JjuYdpnCnTa61Co9A6l/OIZfqrVqWa+ua45hVCCCGEEEIIIYQQ4nxwbiUfhBAndToTk6C84T49YtJO7xPbeDYbN9bB6XPmDfaUMv1YlbGqs5hU5oShqCMfG6MUkMlkrFIEpVj6UqFmUBxaepZ9LFONxkWPaW2xxqAy60lCldVorel8IqYeHzKV08SYx2BUqVvbjp6cM4MvU4gqY3CmPC+1MxAy1momlcXHhNYl1ORjonGaT/3DX/HOVz2H5fZ+TNVw30c9hS/92m9jOqnGaVMZqzR7JxWbjSPlPFaBlIlgzmjmQwBlmLUKq8uxlVKlti6DD5lJa2icxsfM0gcmtWHhAzFlmkqDz/RRYXWp7zBa0VQlvDTLFq0V80Ex+EQfIp2PVEajgMoZKsf6NZlzHheUyq+h1NR1PoGCfbOaWe1wGkLOJGC3i1iTCCnRVuU/Y1ar8nOOu+bbypxz4T4hhBBCCPG5Gy/xWd3+rCZInaqNxqFVKNXKRjOtzHh9nplWhsEnFn1kWhtmteOfPvC3vOSpj2foe+7zwG/iqT/zSpwzbLSGvVPHdTvDeM0NlTVlQmnruHBaAeX+pa1sqT0no1DknEhJY62iD7ls6tCaxmraynDRRknvyzWvEEIIIYQQQgghhBA3Tt5BE+I24nQmJq3osR7OGsX2MtD7RGcijTMs+sjW5NwIRi19JFPq1kIq05ra6sSTolaPzU7vGXwCFLPGsjmxfObgEjI0TrOz9OyfD2hd6ujqSrPVVDijaZ1m1jpCLMEoHzOVzuyZOA7OBxY+4mOmj4lZbUoVnA/kMUwVycQME6swSjHO9aJxipwtPiRCLLUZlTV0fc+f/PZr+PPf/zXImb13/CK+/pKfZe/tv5CkMpU2GAN7WgeUgFBlFSmX14Afq/n2Thy1M6Tc0/Xl95w2xAQpQUoJlKGpxqlSCrpQAlQGXWrwukA3JJpKM60tF85qnFHcYU9bztcE5kOkMWXRaKcLDL7UkXQhoAJcMKuprKb3Jdx0OLNXfqG0Zmvi8L4Enya1oR0DTzFDImN1mSBVO01jDZU9/Fqd1lYWiIQQQgghzlNaKSK51B7HPG4yOL2quWlt6X3Eh1w2HxjNRmuZVhY0LPtIzvDRD3+I5/zgo1jOd7nnfe/PT7/ytWTnyCmz6Et99KQ2VKbcOxxaBq7bGZjUmgs2GjZry15g1rj1RhYfEl2M5FQquWNMOKu5YFIxaxy11ev7OLnmFUIIIYQQQgghhBDixsm7aELcBpzOxKQTqa1hUmUWQ2Q5lGBUHyIplek/Z7s+lGhRNz4Gq8WCI/mYWAzlzw+HolhPGUopM6kCSkXmQyDkUoFXWc3SR5RSaKNonGbhE9asFlhKrUU5XsAahQmKxeCJGajKuayeF0XZsb6qqzNakVJGUUJWbWWI0RGTJ+TM4trP8PZXPIuP/cPfAHCPb/wvfPUjfxzraiDTWsdsYrEauqEEuHxMGG0ZfGYIkT6mUoNnNHUGpxRLMr2PaDSBXOpBukwfI/POM2sczmiWQ3k8drpAyCXIpJViwzTsbcsu9622Wk8Xa5xhMcR1tchyiPiY2DOxlHiVorJ6rAfUhJTpQyKnTJkbBX2MTJyhaSvaugSs9rQOazW7XcAZxaxxhJhIKbPbB+hKSGpaWxTl34lz4bUrhBBCCCFuXrUt18ONNfS+1IdPcz6tSr00TiqdNZaNxo7TXlXZ3OAsMWY++vGP8ZwnfQ/bB/dzt6+4F8995a8TtEPFjFIKZ/W4WUGz0wWsUkxrTcIQUsZSrmk3aouz5bp7CCUEZYyiGzdbzBpXJrPWDgXsnVRsTdw5M91XCCGEEEIIIYQQQohbmwSjhLgNONWJSTekrQxLHwkpM4S0DgRNz4FdyKt6jDTW3Z1okWA5hqJ6H9ehqI3GUo3hsflYFXdgMdD7RCLTWA0oFBBiYt4FFDBx5bEyY/DG6lK1N/hETHl87Mr3DevmDkUmY3Sp6ZtUulTuGYUBoqKEkxgDPtnw9//rj/nDVz2P5c5B6nbKd1z6fO56v29mZ1kqEzOZidNEn4kaWpfZmlRsVBalStVdzDD4TBcDBvAp0Y8hMaUUlc2kmNFGsdNFtpcBrRV7ppFKmzJNrPOkMTy125XQk1YZraF1hn1jDQiA1gprSg3hqn4wpvJz5QxbE8dm44gJhpiwGuwRr1UfEz6lEkKrDNPKcYcty55pxaHlwLwLLIZIotQMTusy4atxh+sid/sw1kEaJmONoRBCCCGEOD+0zjDvA5XV6+v05XB69zXLoUyEslrROIMC9u2p2L8YyMA1n/0slz/he7jmM5/iC77oS3jJa3+HPXv3jnV5pZJco0iUiVWrc+hDYohluuruEEiHOuoLJmitqF05353OszvEEvRXiqbSbDaOymgumNVstu6MPXZCCCGEEEIIIYQQQtwWnf2JByHEjTqViUk3RitFZTR9SHQhlqqzkJjWN/vp3uxiyiyGwMGFx8dVOCmix4WJymiG1WM0Tm4qdXMlkJNy5uBioBtDU4uhTH5a5rLbWylF6ww+JXaXpRKv8wmrSngnpHHiklIsh8issYAi50ROJVRFLhOhrFI4q7AYuuDphsCkLrvOc6ZUy+XAVa9/Ge972xsBuNOX3IPve/bL2brdnfEpoYDOZ2LKGKPQpgSS2sqQcwm29SFRGcViiIQYmfcB7xMhZkJKhJzxQ6DziiEcDnRNa0fOiZ1FwJiAVZpliGgNm62j9yUQtdtH2uXAVusYYkKVH5EhJJa+TB6rrEZrh1GK3T5gdXldrs415VIPMsRETInOlxpIqxXTxnLBtC7TqdpSLZIzZMo0tM22IuUyFWoIid6XSj6t1bparwuRLkSpGRFCCCGEOI9oraitoQuR1hl2+hKst0ad0kTdPsT1pNnVZpPaGqzV1Nbwr9dcy6Xf/zD+9eP/j4vvcCdeeMWb2bP3gvUk2mPvw8p0XsunDy45tPQ4ramtwuoy2apMWF3vpkBrzWZTQlKrY67OZbORUJQQQgghhBBCCCGEEKdLVoqFuA04lYlJp2IVhlodZ3Xcs5WPiUUfOTAfCCkTUwn4hJQwSREBHyPXDz0hgVGsJ2qtFhgADi4G+jEcNPdlIWTv1BFCZtIYWmtoK81OH/AxE2MGAweXAxtUTCtDpiyipDwGlhSEXHaJd2Gs4tOZymkqb1AK+iGxOwSMiaVaT8OnP/kJfvOFT+FfP/T3ANznWx7J13/fjxFsxU7vqQwshsTOMlA7Tc4aHyMmlUUYqzUhZ2qrsVZz/U5PiIlDC8/gM8ZkdpeBIWYgl13sIWO1YneI9CGi1bgYAyRV/synxLyPGKXZO3Hsm9ZkStBspwtHPS9WazYaRyZTW8OnDi2JMZEp06diyuydVihAa9AJImXRqLaGymk26rLoM6nKxKedznNwUcZwDTFxaDGUINSxAcCY1+Gq1hmaqkwMSDnLQpIQQgghxHliUpdgVFMZhlRC9NvLwKTKtNXx4SUo9z7L4XAoqh6nkq6OB0Ds+f5HfBcf+qe/Z++FF/H8X/5tJvsuXk+WOtlxO1/qyi+YVmx3AWcNtSvX1TmDM2UTwLFB/xUJ+gshhBBCCCGEEEIIcdPJO2tC3Aas8kurf57utKiV1Zcde7yz0aouDcp5h5hY+jRWVERmtV0vKgwx4WMuISSl2DNx68coxMTO2Ht3/byEiJwpiyDZZBpnmDiDs5omgtUJrRVOK0LMDOOUrmllCLFMjupCBK1grM7IafwQxaxx7PQBUGxOKoaU2O0jlUm8/0/eze+/6vl08x3q6Sbf9KTn8UX3/XqCVqhQfobrQ2R7PmCMZmNcqElJsTkxTGqHM3q9cLLoA5XSLH3ZJd/5SIwZrcoCjTWK1hoGU85TpYRCE2NmiIGsNIsQqF3Z5e6MYrMpoajKava0Dq0VIaZSMXLMQs525+l94o57GjpfHueDoUyvMlod9zq1ukzgWu3kb1z5WebjLn8fE/MhUhuNIjOtDI0bq0qUIuXyc/RjpeROHxhSYrNxLIeIVkoWlIQQQgghzgOra+J5H9hsHNuU69LFEFn6SGU0ldUodXjq6RDT+v6ndnodqp/WFmc0wzDwiIc/nPf/1V+wsbXFz7/uv3LxF34xetx8cXDhqYzGWYUaa7R9yONxy4Ev3KjZN604uPAooHEWBWw25br6SAqkGloIIYQQQgghhBBCiJuBrBCLtf379/OBD3yAD33oQ+zfvx+APXv2cNe73pWv/uqvZmtr61Y+Q3EyqmRw1sGmmzrpafVlq+PcxHzVGXdo6deVeN0QWfSR7c7DWEUXPeuwTO8Tu30oiwkp06XEEAyMFYGdT6RcJh8t+nLMPa2ltiXoBOVxSLmEnuZ9wCqgdsSU2e0iziSMLhO3dnzEpDKRqqeEeUIuwaHOJ/ZOKna7wIGlZ6MxKFXz8c8c4veueBHv/6O3AHDHL70n3/BDP0u152L6mHFJUTvwMdP7ErraaAxQAlxbrWNaW1qr2TetaJ0hpkzMmY3Wct28p3aaeRfJZFJWVLY8uRutY2fp0WiU09TGAAmUpvOJ2mqc1txuq6Z1hos3apZDqa1TWjEbJzvNGnvUgo0CLp41ZWKWj+yfD9S2TNZa+EhKZXrW6jiNKeGzlUllmNaWENM61LXbR1JM2MowqQy339Nij1kkapxhesRu/94ntvFsNo55H8rPIwtLQgghhBDnvJQySx/LxNuxtno1UbS2msl4Tdz5yGbj6Eypew4p04/V08c6UX3drLbEGHn0ox/NH/3Ru2knE17zxrdwp7vdA6XK5ww+jceN9OG4wx61AaBsUCjX8c6Ua3IfE62xR51/68xxYSkhhBBCCCGEEEIIIcTpk2DUeSznzP/6X/+Lt771rbznPe/h7//+79c7WY+lteYhD3kIT3va0/iGb/iGW/hMxY3RShHJ5Y3zWKbmHFkVd6qGcXFg9Qb8TZ08dSbt9mEdilpNJFpNH5o2hvIQZJzRWKMZxoo8HwODj1TO4ENmMQQaV6ZJZTK7fSBlaGyZvKSUoraKIZYKOaXKgkXMGXKZTmS0whroQuTa7cxGa4g5k1LCGlt2imcYQmarNQwhYU0JL8WxUuOaT36UX738h/nXj3wQgPs99HF8zcN+kKwsKUecLROcyJqUy+72rcZRV5pln2id4fZ7JqScaKyhHsNFy/ExWvqINQoVYO/UMh9KjV4GDJoDuwMocFYzqw0pKxKaGKAyYA1stGUn+1Zb0TjL7bcqhlgqSWJKVLYsBq3qQ45dyPExEUJmu/NstoendbWVPaoiRFHCZW11eFf8YogMIXJw4RlCZFpbNhrHRmOPC0WtaKWY1hZrFNvLQO8TnSn1JYs+sjWRYJQQQgghxLlqVafdh8hxd68Z4ji1tYTiyyTTIZRr1caVa/IulKD+qdTX5Zy55JJL+N3f/V2cc7z+N9/Mfe5/fw7MB1LOtM7SujKJtguRnMqmCq0USpf7iyOvW2e1pXWGPpRJtJtNmfq6b1rdMg+gEEIIIYQQQgghhBDnGQlGnce+7/u+j9/6rd86pc9NKXHllVdy5ZVX8qQnPYlXv/rVOOfO8BmKU1VbXcJQ1tD7svt5Or4Zf6pSLjUPUN68Xx33bLJa4IDDoSgo04pqp/Ex47Ritw/ElJlUiknl6H1kPgR8zIRUwjXLIRLTWH03VmpoBbO6TDWyStHHxHwIOKVp6zJBqhsS48ZujFZMG0tMGXRi0cMQE2r8V0OrMolqCBnFaurUUHaEO8N73vEWXveS59IvF8z27ONhP/4i7vSVX8PcR6xStJXFGYPOgM4sB828DzSVxYfIRRsVe2c1m60lpTItqw9lylOIZef8vAtUVuODIhuN0opl71kOmUmr2Vn6EkJSGa01mrIIFNM4LSuXhaIQYLMpizhbrRsfr4jVir3TCgXsm1Qn3NXujObz9jTYHbUOtS2HUqmXKdOfGlsWqo78+pASBxfDGI5KOKvZat06PHVjamuYVLlUpgwlGNWHSEpWdt8LIYQQQpyDjqzTBm405NSNtdeV1WgUfYhUVh8VgDrSierrnvWsZ/Ha174WrTW/8vo38g3f9M0cXAxMKkvrNCmXewBrNLOTBPeVgspoJlUJSXWrSVfjNfdNnfgrhBBCCCGEEEIIIYS4cRKMOo/t7u4e9fHm5iYPeMAD+Oqv/mpud7vbUVUVn/jEJ7jyyiv5m7/5m/Xn/eqv/ir79+/nLW95C+osnCh0PmqdYd6XAIzVipBKldi0PvV/xZdDJOdS81BZjRqPezZZVd11Y0UawOZYe+dj4uDCUzvDkBKDT+x0gbYytJUGLPOhVNsthkDVVhxaeqCErAAmjaFyhpTL4sRqgWLpAyEnFn0i5kTWmkhGJYgpM4RESrDUgbaydDFyzXaHT4mMojble2w2Dh8T/XLBy37yWVz9jlKdd7f/72v4gWe/jHbPBYSY2WwsWWucGsNXtUUpRT8EDi0DkcygdKmmS7B/t2ffpOww73wkxEQGln0iUiZYTWpLNyS0Ap8yWpdpTH1IGKOYVQ5nFJVRbNYObRS7y0AGWqfZMy1pr9VCTlsZlr5UkQwhUVnN0p/8NeeMZqN1aK2Y1PaoYFvKlOPEhEqMU7YSh5aexVh3ojRs1I7GlSDVqdbhne55CiGEEEKIs9Oxddqra7zjxEzvU6nFc4amKlOi2spw4ay+wfq9Y+vrXvziF/NzP/dzQLkP/vbv+M711wFUYwArjdNgh1BqunPOKKXQqoSyVpNVV1a/XB1HclFCCCGEEEIIIYQQQpw5sjIseMhDHsITnvAEvv3bv52qOn58/0//9E/z1re+lcc+9rHs7OwA8Hu/93u8/vWv5/GPf/wtfbriBLRW1NbQhUjrDDt9YDGUCrXa3ni4qQ+RxVAWGVaTeGprzqqpOill+nC4Hg5gUpn1z+fGHdiLIbJRO3bwDD6xHCK9j4QErdXs7wMH5gNWaQ4uB9rKoLXGadgzcfQhoRSEnLFa4UOZwhQSZMpO8M2xpq22ZYEjmMQ8Bvo+McTERl0RU0SR2WwcIWfmfUIrxb/88z/wimf/MP/20Q+jtOZbv/9S7v+dTyRrhdOlzs45zWSs/FsJKRGt4Y77HAfmA96O1YlkDiw9PmVm488y7wLGKOZ+KI9dBj+Uc9NKoXIJdHUhMqkME2fZHINVs7pMqWrduDCkFIkyfWw+RDbbsiN+oiyV0fTjLv3Kll9P65M/h7NxElXnI5uNozNlklNImX58nI/Uh7KgBZnZWLs3qcxphZq0Uqd9nkIIIYQQ4uxyojptKAGj2mqc0eW6NZcavXL9ntnpA0NKbDaO5RDRSjGr7SldC/7Kr/wKz372swF42ctexuMf/3iu2+0hHw42rTZSaKWYVJbJKbbhrYJQq+PIfiMhhBBCCCGEEEIIIc4cCUadx77+67+e5zznOdz3vve90c/9ru/6LjY2Nnjwgx+8/r0XvOAFEow6i0zqEoxqqjIxqfeJ7WVgUuUS/jnBu+0pl8lSq1BU7cpu5tXxziZLH8mUSUIhZZTiuDq1aW2JuewQ36gdvYl0QyRZzXLpQZU6vmXIWD2QyaSU2WxtCZLpUjc3xETMmWE4HNQJMZXHx5Zd54ryGGmlMAYWPrLsIymC0xFnSiCpsonGGUyVeM/v/xa/+nPPY+h7Ni+4iMde/vPc6R5fRYxgbanXWD3+vS/nYJTCaMXeicPHTDdW5aUU0cCQEkYr5n0oga4Y8CFTWc2BuWfwmSGW8FFlFVYbjNUkH9A5o8bvMfjErLE4o7EaUNAYTcyUKj/KYwfl5wLWIaPTqQDZat36fBtX6vNOVoGyMVbebS8HfMxsNZaN5vQrPG/KeQohhBBCiLPDyeq0J5U54X1O4wzTI+5zep/YpkxvnfdhHaS6Ib/zO7/Dk5/8ZAAuv/xynvrUpwIlABUZNyjEEsJqbsKU3WHcELDaiHI6FehCCCGEEEIIIYQQQojTI8Go89iP/diPndbnP+hBD+JBD3oQV111FQAf/ehH+cd//Ee+/Mu//AycnThdzmimtWXeBzYbxzZl0WAx1kxURpeKPHW4qmyIab1buXaazTF0Mq3tKVeV3VJW04S6cWpUbfUJFxA2G8dclYlZtS0TpfxYddf5yKyx7C4jfUzMGkPjyl+Dvc9U1mBtZliUKr4uRJzVGA2Loew8b6wh5UxlDi/CpJQZfKmkA7hmu2PvrOKCWU1lNGE551df9Gze89/eBsB9vvYb+L5nvAQ12aTrE3WluXijBhS10dRWkwFtFI0xJDL9EJkPfnyeHTFDHyMWhUExhMS8Kz/fvB9Y+sCyjyx8xMeMUWCUJqdMPySMLq+HSW2pKs2ssWVRJ5cFGq0UfUj4mKlXr5sxJ3bsDvfTrQCZ1ZbaahZ9pB+nOFX2+NebD+X16YxhUilmNyEU9bmcpxBCCCGEuPXdUJ32yWhV6qitUWwvA71PdCbSOMOij2xNTn6v8853vpPv//7vJ+fMk5/8ZH72Z392/We11SUMZQ29L/cH05xPK9iUcqmQBmjsalrv2XXvJYQQQgghhBBCCCHEbYkEo8Rp+aZv+qZ1MArgIx/5iASjziKnW1UGYLWircx6p3NbGWanUVV2S1lN+VlN/bmh4Na0LrVryyEyhISzmgtmFYeWnspqrtE9JPAh0xHYaisu3qgYQiJnhTOaeQr4mIk544xCowg5sdMHdjrPZlPRhUAImUOdZ3cZqCpNSJlIptaaC6YVH//nv+cFT/tBPvmxj2Kt5bJnPo+Hfv8PElLm+p2ea3cHtAFQTCtTqvoaQ8plcWU+BHwoFX4bjaOyms6XRZ1uCOyO0772zqqxMjBTW0NKmR3lMUphK0VKkBVok9msDdqMAS+n2WwdG40r554ziyHiTPm5V4s2bWVQ40N+bNDoplSAOKPZmmhSsix9LBOd8hETo8aaE2c01nh8zDd50pNUlQghhBBCnJturE77xtTWMKnK9e1yKNfQfYikcTLpsf70T/+Uhz3sYYQQeNSjHsWrXvUq1BEXj60zzPtAZTVWK0Iqk6lOp+p5OURyLvdhldWo8bhCCCGEEEIIIYQQQogz4+xLP4iz2mw2O+rj+Xx+K52JOJnTqSprrDlqUs+0tmdlKAqOn/ZzY7uyndG4VpPGoNgQFTFnDs4HNmtLnxJOabLKGKNYDomlT6RxLNIQy6+jh51lKlV32hBSmb600wdSV8I8BxeerMBlhVZwwaRi36ziv/3267niZT9F8J473fnOvObXfoN7/Lv7cM1Oh4qZtnZcbBQksEaxUTu0ht0+sdGUwJBRirZ1TGvLEBIxZUAxhMjGxNHWljCGl4wqIbfdLpByRmnFrLX0QyQbqKzhwmnNwgeGlFAJmtrQWMOkKkGpYQzQ+ZhYDhlrFPOhLP6swmirNaSbowJE67Kbf1qf+M99TFJVIoQQQghxnjqVOu0b01aG5biBYAipbKDwx4eZ3v/+9/Pt3/7tdF3Ht33bt/GGN7wBrY/ejKG1oralwrx1hp2+TKq1Rp1SWKsPh2vMVz9Hbc0JQ1pCCCGEEEIIIYQQQoibx9mZgBBnrY9+9KNHffx5n/d5t9KZiBtyqlVlAIpxJ3Vtzrr6vCMpBeTD035OdXqQ1opJbZkAeyYVtdVcvztQGY21iut2eoxS5AydT/hYKjqMUbisiUDrFInMECMoUGh8CJDH4I6CSW2xWuO0pk4LXvaMy/irPynT1b75W76NV73mV9mzdy8AG96RcnnsQzJYowgxY7Va19jVRpcQlIGNxlJZgyKyGAK11Qwh4kNGa5hWlmljWfaRmBPWwPYyUmnNgeWAQlE5TesMTa1IWeNQNFbTx0weH0+tFI0zWK3Z6T1LH6izxihN5xO33yqLN5XRt0gFiFSVCCGEEEKc3061TvuGaKWojKYfN4tUtvz6yGD+Bz/4QR784Aezvb3N133d1/GWt7wF505c4zypSzCqqQxDSvQ+sb0MTKpMW5kTnl/KZbLUKhRVO70O/E9qmRYlhBBCCCGEEEIIIcSZJMEocVre9ra3rX9dVRX3vve9b8WzEcdKKR9XS4YCHxJkSlWDUuuqstqWsMy5sENZK0Ukf87Tg2praMfpSK2zXLQBRmkymZ3OA5qYE12fmFaWpjJ0fWS792gMoFBkjLNoMosBMoACjeLaj3yAl/zMj3HdZz+FcxVPe97P8ujHPYk9s8MrL0opyHkd8qqsJqZYplSFUqux3QWsKROgqlWgx2mWXmE1WK3xMTCETF2Xn8cYhcHQ2Mx2jtxuT0MXE5VRGKWpK828C2it0RFqZ4kplMq8cPjxtKaEszKw7CNbUwMZJs6igMaZW6QCRKpKhBBCCCHOb6dTp31DVmGo1XGO3GTxiU98ggc96EFcd9113Oc+9+Ed73gHbdue9FjOaKa1Zd4HNhvHNp7ep1LX5yOV0eN9V5l2O4TEENN68m3tNJtNCV1Nx+poIYQQQgghhBBCCCHEmSPBKHHKfv/3f58Pf/jD648f8pCHsLm5eSuekVjxMa2nQ51ojtKRb7ZXRp/106FO5OacHjSpLNOq1OI11tGFzIWzhs4nOh/pdyO1NVRO0/tIAi6Y1VijMUoRU6ILgeWQ0CEyNRat4M/e+mu8642/QIqR23/+XXjuz1/BA+9/v/X37nxkCIlDS48PkYVPhBDJZCqjWQ6JkBOtNXQ+sGHdUeGvw7vdy0737WXGp4RSHp8MbpyO1ftIFyJDDKSU2PWZWWNZdJkENDZjx+O0lUEpRR8SRiuc0YRYgnUxJjIQU2ZrqvEpMbUWn9ItUgEiVSVCCCGEEOe3063TPpnVlx17vGuuuYZv/uZv5pOf/CRf9mVfxrve9a5Tused1ZY4VnZvNo7ORJZDqevrx2rqY1ldNj2sru/bypy1NeZCCCGEEEIIIYQQQtyWyLtw4pRcf/31XHrppeuPtdY897nPvVm/xzXXXMO11157Wl9zZFDrfLXbB+Z9WH88jBURKZWJUUqVgEljDZXVdKGEZqa1PafeiL+5pwdN6jL9aN+kYv9i4MBiYKt1xJjxMUOCEBKtMygFxiisLvV2OSumzrHVKC6eNXS7+3n5c36Uf/irPwPggQ/5Di55zovZ3Nik94GYy1Sp1QKMUYp+PI9lyhxaeNrKcGjpqZ2iA9I44evYxZ/GlUCTM2Xy19LH8ZxAVZp5H5n7gNaw0wcqp4kp4FPm4NJjtCK3lr3O0vnIpLJoFD4ldvuABmLOhJjJqkymymQ2m6oE73Jme1leb7dEBYhUlQghhBBCnL9uap32sVZftjqOUnDw4EEe/OAH86EPfYg73/nOXHXVVVx00UWnfMyt1mG0Yt4HGlcCTzd2L7Zyrt2LCSGEEEIIIYQQQghxLpN34sSNCiHwyEc+kk9/+tPr37vsssv4qq/6qpv1+/zyL/8yP/VTP3WzHvO27tDS0/kS/ujG6oaQTrBYEDO9T2WXsjM0VQkZpZzXNQ5nuzM1PchazcWbDfURk5lCTuzfHeh9IuSMU4oUoY+JTEahMGO46v1/8T5e+Zwf4eD111LVDY/6sefzNd/yXfTKsN0NZGDvtCJnCLEslISY2Ok8ChhCxGhdKjZCYgjQuExlTzzVyxpNWxn2z4cS2AKMVuW1EAyVLjUdRitqo4lJMa1LoKtymhhLaCimnlltOLgYmDjLEBNLHwgxE3KmsWVxJ4bMtCohqpQ1Qyyvr1uqAkSqSoQQQgghzj4nqvA+E3XdN1ed9jBOcFqdU7dc8sjv/Hb+9m//losvvpj3vve9fP7nf/5pH3dWW2qr19N7K6uPCkAdSVHuP87F6b1CCCGEEEIIIYQQQpzLJBh1FvjgBz94xo598cUXs2/fvs/pGJdeeinvec971h/f5z734cUvfvHnemric7Tbh3UoarsrYREoCxK11ThTpg2lXBYQ+pAIKbPTB4aU2GwcyyGilTpndiufyelBW61j2Qc+e6hjo3YcnA/EnMk5ozDrQJRWisoqUkr8+qt+jre//lXknLnDF34JP/zTr+JOd/1SDnWeeV8mUPk0YAyEGCnLIYVWiiGW52y3DxzqMj5EZpWj82WBSXPixSSrNX6s6NgzrVj6iB6PrnUJReUIZI3WMHGa1tn11+z2HsiEDMEndrpuHRZTKBqrqI2BDNYqQswoVQJot0YFiFSVCCGEEEKcHW6wwjtDpNx7zPtws4SAbs46bYDGGoZh4PGP/h7e9773sbW1xVVXXcWXfMmX3OSwlzOarYkmJXuLhMWEEEIIIYQQQgghhBCnR1aJzwJ3v/vdz9ixX/SiF/GsZz3rJn/9c57zHK644or1x3e5y114xzveQV3XN8fpiZtotdgAR4eiJpU5YUCocYbpEQGh3ie28Ww2bly00OfEruUzPT1oWlu2Jo7PHupYDJFMpnFlF3gfEjllUoaPf/xfueJnnsK//N+/AuBrv/XhfNsPXk7dNBzqBrYXnphg1ljCEDg4V/RVoq0sW63DGcWkMhxceipriGng4MKzvQzEnNmoHD7AfPDssYf/XUu5hIOWQ8RoxUZjCePPt29WlwDRuPBjfKJyJeA0rTUbbUU3LtTsmVR0IRJTxKCIVpGArUmNMxqjIKYStIo5M2sNe6eOSWXZO62OerxuqbCRVJUIIYQQQty6bo0K75u7TtuozCVPehzvueqPaNuWd77znXz5V3wlhxb+cw57aa2Y1pap3CoLIYQQQgghhBBCCHFWkZVicVIvetGLeOELX7j++I53vCNXX301d7jDHc7I93vyk5/Mwx/+8NP6mg9/+MM89KEPPSPnczZb9Ifr81ahqM3W3mClnFbljXprFNvLQO8TnYk0zrDoI1uTsz8YBWd2epBPuUzYypm9U8d2F9heDgCorMgK/s///GN+66XPZH7oAHU74bt/7Kf4d1//bWil2Ok9PuT1pKVrdjpaZ6mMZu+0ojJqXaEBkCkLNY1r6GNke6kYfOb6MLDVOK7bHaiMwRiFD3kMeZVzVBoumNYcWAwYo5nVlmY87q715MYSUsZqRVMZNlvHrLbklPEJdvpSw2iUYtaUx7S2mpQyZqzrS6nsxm9rw6wuga5bswJEqkqEEEIIIW4dt1aF981Zp904zbOe8qO8421vxTnH2972Nu71Vfdj/3xYf/4tEfYSQgghhBBCCCGEEELcsuSdPHFCr3jFK7j88svXH9/udrfj6quv5q53vesZ+54XX3wxF1988Rk7/m1FSpk+lDf3l+PixKQyp7QwAGNYpMplytJQglF9iKRkz5lqhzM1PWin8ygUpEyI5bFeLfjUKvH2176cK3/7tQDc8Yvuzvc88+Xsu8OdOTT3tJVGZ0VOmcoqnFEs+8xGrchAyiWc1vmIUjCpLJPKkjIcXAzsaSsMmp3O41MixMR253FaMTtiEclqRVal0i+kTG0N09qy2dpSmehLPaJWis2mVI7U1rBvWmG1Xr9+Zo3mmu2BPiS0gsoZtiaOPa1DKUUmc3DhSRmmzuKMYu+k4sJZfau+TqSqRAghhBDilnVrV3jfXHXaL3/BT/Kbb3gdWmt+67d+i6/5D9+4noB1S4a9hBBCCCGEEEIIIYQQtywJRp0Fcj7Bm6+3ole/+tU85SlPWX984YUXcvXVV3O3u93tVjwrsbL0peJhGBcclCoTkE5HW5n1G/9DSFRWs/SnV0lxa7u5pweVeoyINZr5EDmwHGidQanMv33y47zxBU/lEx/8vwB89bc+kgc99qnMJi1aKXqV2B0iVmmMU6DK9Kk9E8Oe1qG1ZhjDbNPKsBwiVitigm4I4wJTWezxSeOSRpExlOdlz6TCmBLyskZzaOmBjFYlFFeqRcr/c4YLZjWLLjBrHTtdYFqX4JitNFor2srSVpbKWPoQqZ1eT4TaMylVefM+kFuF1Yq90woFt3oo6khSVSKEEEIIceadDRXeN0ed9htf8wu8+pUvB+CKK67gW/7zfznhz3VLhb2EEEIIIYQQQgghhBC3HHkHTxzliiuu4Ed+5EfWH+/bt4/3vve93OMe97gVz0ocaVUV141Bm9rqE+6SviFaKSqj6ccpS5Utvz7XQiY35/SgRV8mOV2309H5QAiZZYp84M/fw5teejnL3W2a6QYPueT5fOFXfSPzAHERaJymcYqlLzvTTVbEXGo7NhvHrHWocVFmCOV75JTZ7QNGlwlSldE0TmOVoQ+JISRygkhCKQsqM6tLYEkpcEYxrRyLIeBjxhm1Pv56gWbcvb5RG1BqHcaqjpgs5qyiD5DH9sHVBvkjK0dWobvaygQmIYQQQojzzdlS4f251Gm/5Td/nRf85HMBeOlLX8oPPPZx6/q8WyvsJYQQQgghhBBCCCGEuOVIMEqsvf71r+eSSy5Zf7xnzx6uuuoq7nWve92KZyWOlcatz2lMsdzUN+FXYajVcdJZNrnsdHyu04NW9XLdELlup2cxJEIYeNuv/hx/9gdvAuBOd7snD3v6z1Ft3Y6UM5XROKtIQERRO0U/ZGIswSyjFSnl9WLJxFoOLQb2LwZqY0g50ViNj2AsTLUj5cxFGzU7C0837kpfDJHPbg9MnGNzUur3FCXEdORTthgCyzHMVDlNaw2Hlp6tScUyRAaf2OkCbZVpXFnwUZRFn/VrKpfzPbJypHFl0WtSn95UMiGEEEIIcW472yq8b0qd9tt/7y088ymXAfDsZz+bpz3taRxaeODWD3sJIYQQQgghhBBCCCFuGRKMEgC86U1v4olPfOK61m9zc5N3v/vd3Oc+97mVz0wcaxWGWf3zdKdFray+7NjjnY+WPjLExPXznvkQ+cwn/x+/9lM/xr995J8A+IaHP57/+OgfIRtLNxxeFDLjg5golZhDDEwbyzBkrNLUVpXHNcP20nNgWRZhBhVJGQan2WwdzmhCKpWGjTUMLtKFxFZrqZwhxcwQE51PpBQYxslYfUwsh4iPaR2Qq5xmoy7Toi6YlaTYhtHs4Bl8+fzOR5zRZEo1SMqKnc6XaVttmUxVO83mOHVqWlvZBS+EEEIIcZ45Gyu8T6dO++qr3s2lP/h4cs5ccsklvOAFLzjrwl5CCCGEEEIIIYQQQogzT4JRgre85S085jGPIaWyW3Y2m/Gud72L+93vfrfymYkTUQrIh4NNN3XS0+rLVse5ifmqc0ZK+aR1e4s+cN1OTx8S//Ndb+c3Xv4T9MsF0629PO7yl/GVX/N1QKm/Wy27GG2A8iDWVmG1wseM9xGfwFrDtKmYVqUKL8RMYzS7fSBq2KirUstRldDRpC673n3MtNGy3UfmfaR2lkltCDEx7wO5ssyHSBiDUj4mFNA6Q3PEok7jNBuNW9eDbNSO3pSpWKuFqXkfGGKismWClDV6XTmymhTVVobZTVy4EkIIIYQQ566ztcL7VOq0//df/DmP/75HEkLgkY98JK9+9atRSrEYwlkX9hJCCCGEEEIIIYQQQpxZ8s7dee7tb3873/u930uM5c3u6XTKlVdeyQMe8IBb+czEyWiliOSyIzmWiT+rEMvpGMaFjtXO5ps6eeps52Na7yg/LkKWIZLZv9vzL5+6jte8+Ln88Tv+KwBffM/78oTn/jwX3/4OkEAbTR0z1mhaZzBa4UOij+VxzONoqMWQaCtNZTQhJmpriDlhG03MmS4mLJppbZg4w95pResMdpzIVFtQKjPvI4eWA/t3e2qruf2elkUfSnDJaZY5M63K1KfaGDZat34OJ5VZL8xsNo65KvV4tS3BKR8SixDIfcYqxbTSVE6zb1KxZ1KtH55pbSUUJYQQQghxnjrbK7xPVqf9/ve/n4d/53fQdR3f+q3fyhvf+Ea0Lud+toa9hBBCCCGEEEIIIYQQZ46seJ/H3vWud/GIRzyCEAIAk8mEd77znTzwgQ+8lc9M3JDa6hKGsobep/ImfM6n9YZ+yqWaDaAZJwzVJ6mgOJft9oF5H9YfD+PiRUpH7CjXir/62//LTz/lB/nkRz6EUopvfOQP8fhLn0bWBh8Tuz7gklov4ijKgkjtDEZr5kOZyrT0kQSQYdZajNY0TjEExTJEfMwYFNPGsHdSAlEbY10dQIjlGAfmA5nM5sQRYyamvK6/G0Jm2hiGkJjWFVYHQsr0PrJnUtFW5rhFq2lty072ITKEhLMalzSz2mG1YmtSoRRstg7FWBFSH38cIYQQQghx/ri1KrxvaNJrbcsmhZPV1v3zP/8zD3nIQ9je3uY//If/wO/+7u/i3OHr7bM97CWEEEIIIYQQQgghhLj5STDqPHbppZcyDMP6Y601j3/840/rGJdddhmXXXbZzX1q4ga0zjDvA5UttWchZZbD6VU3LIdIzmC1orJ6XcV2W3Jo6el82QneDXFdd3GknDO//+Y38cKfeDpD37Gx90K+++kv4V5f/e9BGyaVYTEACvqYWPYRhcIqtV7QCTETQiakjM4Kq8FaTc6ZlDPOGipryJ0itxBrw0btaI5Z0FkMgeUQSTnjU6n2qIwijqG33ieMVgwxsaEsSil2+4DRionVZRqU0ydd3HFG41pNSpntpSfEcrxJZTFa0TrDZuNucKFJCCGEEEKcP27pCu8bmvSaxo0CQ0jkDNVYRV1Zsw5L/eu/fpJv/uZv5tprr+Xe9743f/iHf0jbtic8l1s67CWEEEIIIYQQQgghhLj1SDDqPLaqz1vZ3d1ld3f3tI6xf//+m/OUzjqfy27lM0VrRW0NXYi0zrDTl5o0a8rv35g+RBZDee7bajUt6rYVhtntwzoUtd2VaU5QnrvalvDQYneXZz/1Mv7grW8B4B73/Vq+9dKfod1zIRuNI2fofGRSGYZgWPQJpRMhJnaHfFR9obUKHzVNVZ4XrRRWabRiPekppESIUDuNGrNLq4d8tz98jjudZ2cZgYxt7Pp58SmRskHnzOATF04rlmMVSIgJrRXby8CkyrSVOeEiT8rl9exTZrOtqJ1mc5xYtW9ayYQoIYQQQgixdktWeJ9s0uvgy72LTxmloDEGZzUhRRbjtfq0tnzsXz/FQ7/lm/jkJz/Jl33Zl/Hud7+bzc3N477PLR32EkIIIYQQQgghhBBC3PokGCXECdzQbmUyRMrCwLwPt0rt2KQuAZymMgwp0ft0aqGY4XAoqnZ6vbAxqW8706JWzwscHYqaVGb92Hzg//4tP/jY7+P/feTDGGP4/kufwb//rsdxzfZAHxOLIbC55RhCIqZM6wxKKayFQ4sACXRWaKVQGpzVWBXxizKJa+IMbW1gDFcNoUyCQmW00uv6Qmc1iyGsz/Hgsufgopz7tCo74KeVRitNFyKKsuiy8BFnNTEnjNJYo4kpY7RiMU7Hqowu08BUWbgZQmKIab2Ic2QoalpbCUUJIYQQQoij3FIV3ieb9LqaqLoSUuZA8GP1s6Zxmt1eYfYvefx3fwcf/pd/4Y6f//m87Q+v5KKLLjrh+dySYS8hhBBCCCGEEEIIIcTZQYJR57GPfexjt/YpnJVOtls5pSMmRmlFYw2VLYGVLpQqu9lp1Nl9LpzRTGvLvA9sNo5tSgBIQjGw6A8vqqwCR5utpbaGnDOvf+2v8JOXP5NhGLjjne7ES179Oj7/7v+OT+5fMm0iqcv0oYSrNhqHVlBbRx8HamuYVplIxtmjJ3T1lGDSVuuYVBanNc6VBZLtZSDmTG01VimMVigFVim2+0DKmQOLgZ2uvO5mjWXfpEKrcrw41vJVRjNtLH5cXDKqLFY5o8c6PI2PpdavD2Xx6lhWK9rKrBeA2srcYq9bIYQQQghx7rglKrx3+8BinPa6fzGsP3/py6aAidMopehiog8RP97T9CGyDBobB57+hO/hA3/3t1x40UW85e3vZO/Ft2e78+v7nSPdUmEvIYQQQgghhBBCCCHE2UNWw4U4wsl2Kx8nZnqfSsjEGZqqLBqknE/4BvyZMKstMWU6H9lsHJ2JLId4XodiUsr0oTx/y/F5nFSG2hoOHjjAUy79Ia78b+8A4MH/6dt45S9dQaqmHFwMOKNwxjCrMkOEnWWgcSX8Nq0N4Jj3kVTBcgj4kHE648xq+pPBqETjNHVtsEaxWTmSKlOsdofAtDI0TjPERG0V251nt48shrCe5LU1cextK6A8P9Zo0vhcpnHRpnWGWWPZXoYxFAUxQcqwd1rdaJhv5ZYM8wkhhBBCiHPLma7wXgyBTx9cMoTEzhHV0gDOlOmsh/qIDxFrSo35nklFGu+BhmHguZc9ng/8zV8y3djk1W/8PS66012AEsjSSh13rXtLhL2EEEIIIYQQQgghhBBnF1kRF2K0O+5UhqMr2JQqO4Cd0WilSLlULvQhEVJmpw8MKbHZuJO+AX+mbLUOoxXzvoR4GmfO61DM0pfqw2F8bpQqizB/89d/yQ8+7vv51098Auccz/uZF/KEH/phlFLsnw84o6mtoTIaoyyhD4Sc2OkCk6o8bm1lCClTO112mqdEypmYIuWVktEanNZs1o620hijUBlQCoPCaA2U50thmQ+RnDO9z5hxOtRmW4J1tdNMKjseuYTzVjvZlSqLUZMqsxgiCsXeiS2LNClTWX3Uc32kUj1yy9c/CiGEEEKIc8+ZqvDe7UsoqmzoiMy7SBcjtVF0Q0IpWIYIWWHNERNXtWLSOJb9wDOffhl//Wf/nbppecXrfoc7f+mXl/OjTIsqtef6qGveMx32EkIIIYQQQgghhBBCnH1uW6kIIW4iH9O6Pu/IUNSkMid8w79xhukRb/jf2BvwZ9KsttRWs+gjfYjndShmNSWrG6dGOQ2/8qpX8sKfeh4hBL7gLl/IFb/+m/y7e99n/TWlKu/wZKidZWLqLEOMDCFhtOLA7sCeSYVRis5HnFEsfVoHsRQw+ETJPZVgktOKISQOLTwhlMUWqxVDLMfPGayCCDRO46xm1pS/ktvKrENRAD6UYJTSh8959XmrqWYpw0brmLiyMNOHEtxah+OUorZlp70s3AghhBBCiFNxJiq8Dy09iyEwxETvI5/d7hhiGjd5ZELODD6yXNVi1xajygSp5RCJKfHzz38Gf3zlH2Cd4wWv/nXu/4B/jw+pTJD1ic5EGmdY9JGtydH3PWcq7CWEEEIIIYQQQgghhDg7STBKCGDRH67PW4WiNlt7g7uGtVJMa4s1iu1luNE34M8kZzRbE01KlqWP520oJo0rMCll9l9/Hc9/6pP5k/deBcB//i/fxct+4ZfY3No66msqq/ExM6sNfTAMPtOHgMoKo8EoRcowxPK68KlMDLNGU+fyvWLKZQEowkZj2e0CsSoTnyaNoXaKxVCmWO2pyqSu3T6glEZRQlOVKYsrrSv1eUf+TKvv3Yyvx1XwTavydf04JayyGp8y+1rHtD6zj7UQQgghhDg/3JwV3qspvZ2PbHeeRR8ZYkIrmDWGbkilBjtnXAKjQWnFfAgMSTOrLK9+yc/we7/1BpRSPOfnfomv+tpvwIeEsxo1zlpdDuW+rA+RlOxR90BnIuwlhBBCCCGEEEIIIYQ4e0kwSpz3Usr044Sh5VilN6nMKVUpAEdVmt3QG/C3BK1LWOt8DcWsFiv+8s/fx9Of/ASu+eynaZqGn3nxy3j0Yx6HOsHu78YZFkNko3EcWgY2J5ZDy0QXEz7ARqNwRlFZQ06ZzUbT+0gfE5PKEFNm/7zHGE1loLWWDFwwraicIS4yWWt674FSxZhyhgwxJ3aHyMQZLpxVtNXxfyV3vtTtWa2wpizQrBaYoISk+nF3PBwOhwkhhBBCCHFzuTkqvI+c0nv9fGDwJVTVOMNm63BaE00gpFIzPa0Ms8biYwll+ZB4w+t/kd9+7asA+IkX/TwP/vb/Us4jRpzVaF02NYSUGUKispqlj0yPqRC/OcNeQgghhBBCCCGEEEKIs5u8iyfOe6s6tCGUiT5KlTe5T8eRlWY39Aa8OLNSirz8517My1/8AlJKfNGXfCm/9sbf4u73+IqTfs1q6lLOsNVarp8PTCpLSJBjqecLUdG4TOV0qSN0muUQmQ+eRZfQSrHVWvZOKpzR1M5gtKb3CZUVKMW+aUUfEzFlQizhpaYyKCDksgDTVkef2xASy7Guoxlfk5XRR9V7rH65ykNJLkoIIYQQQpwJn2uF95FTervxGrd1ej3dthsn965CSc5orNZYXUJJv//bb+QNr3wBAD/09OfxLQ97NJXVDCGRU15/58qooyaq9iGdcOPIzRH2EkIIIYQQQgghhBBCnP3knTxx3lu98d6NU6Nqe3Tw5FScqNLsZG/AizPj05/+NN/9PY/ifX/6JwB8x3c/ip9+8cu53QV7bvRrJ5WhD4m905ohZj57qMNqRV2VRZCYIOdMN5QQXXl1ZFpnaW0mJEvKpeoupExrNSjFtDZctFGx9AmNYrsbmA+RhQ9lh3xUxJhxY5CuGgKTypJy2b2+CkXVTq8nmE2OCe2tglCrl+xpvnSFEEIIIYQ4ZTe1wvvYKb2ZsrnEj5tTtFLkI2qxV99r5c/+6B38ygufDcDDH3cp3/P4Hy71eWa8Mj9ik8DpTFT9XMNeQgghhBBCCCGEEEKIs58Eo8R5L93AG/CnQyrNbj1XXXUVj370o7n22muZTKe84KWv5Jv+88NRqjwPNxZ0s0YzqUql3kUbNdvLAd8lnDEopdhoDbUrVXo5g0+JkDO1NqDKtKfpGGia1pZJZZlUhrYyaFV2oS+GyAWzhrr3LIfI9bFnpwv4mHFGlUBThsEnEqwXhmqnmdUOKKEoe8zrcxiDfauFp9MN9QkhhBBCCHG6TrfC+9gpvXqshw6xXMumnDn27ml1WfuXf3o1L3jGD5Nz5iEPezSP/OFnEGLGGkU/biQ4cpPA6U5UvalhLyGEEEIIIYQQQgghxLlBglHivHfsG+Y3NVgilWa3PO89z3ve83jxi18MwD3veU9e8/rf5Iu+5Es5MB8IKbMcTq3ScFqXYNP++cC+ac20seQEfYglLJdBqRJgqrWhplR6xJyZVHb9/E8qy2Zr1xOejjx25xOz2uGMLgG67Dm09Gx3npASeyeZISZmtcVqRVOZ9XFaZ477OVIunw9lWhWUiWdCCCGEEEKcTY6d0tu4soFAawUx42Pm2LuwnOHv/vdf8LzLHk8MgW/8Tw/lkstfSELRxcjMWOY+UluDWm8SuOkTVU837CWEEEIIIYQQQgghhDg3SDBKnPdWk3pWb5jf1ElPUml2y/rEJz7BIx/5SP78z/8cgEsuuYSXv/zlDNnShUjrDDvjpCZr1FFBpZM5sjbjgmldFlmAmDJdiMRxGpg1qtToOc1iiCilGEKismXy1Im+10bj0KqcT20NF200KKXQGuJ2IoRcpltpxUZjqY44xqQ6PhQFsBwiOZeAVmU1ihKgEkIIIYQQ4mxy7JTeSVXqqhtr6H1iCInVMCatFST44N//Hc/+oUfTd0u+5uu+ictf8mqSNsz7AKlcOw8hU1toTLkGroyWiapCCCGEEEIIIYQQQoijSDBKnPe0UkTyEbuVE81NCJfIG/C3nHe84x085jGP4cCBA2xubvK6172Ohz3sYQDYmOhCpKkMQ0r0PrG9DEyqvK62O1bKZbLUYohMKstGY7FaM8TEVutOWq+4HAKNM9jxOVcK2urkr51pbaltCVMNMdFWBqUqUszMfQQUbpxCpVRZ2DlRfR6USVaLsTpk9T1rK/UeQgghhBDi7HPsVN1JZdntA9ZorFaElEnj59ZW89EPf4jnXvIo5rs73POrvoaffOVrsc7hx2mpObOuvLNa4cZNApXVLJYekImqQgghhBBCCCGEEEKIQoJR4rxXW13CUONu5T4kpjmfVrBJKs1uGX3f88xnPpNf+IVfAOC+970vb37zm7nrXe+6/hxnNNPaMu8Dm41jG0/vE4shsvSRyugyXWms2RhCYohpvUhTO81m44AyfclotV50yeNkMa0UtdUYVUJM211ZfKmtvtHXjTWazVaTcsYZxbU7Axtthc99mUzlI5Ng2bPHYfXxr6EjQ1yr810F+Sa1TIsSQgghhBBnn2On9ELZBNCHRFMZdrtATJmY4MA1n+Inn/woDh24ni+++1fywtf8Jk07gXIIAHxKBJ8xqtRPQwlF9SHJRFUhhBBCCCGEEEIIIcRRJBglznv/f3v3HSZFlf1//FOhw0SCJBlRkgERE4oourBfcQ3ooqJEFdifyooJzGkNuAZ0TagomGBBMGFAxFUx4iJmgqwJJIsIAg4TOlXV74+eaacJw+Rmet6v55mHuT1V1Wd2ess+fc+9J8MXb8fgt/9YrVwccXbYumxnaGlW+5YtW6YBAwboyy+/lCRdccUVuuuuu+T3+7c7NjtgJ4qMcoM+hSxHxRFHMddTOBYvftuWbRrK8FuJIqMMv5UokMoK7Dim4qgjeX+0BNnZzlI7YhqGGmX4ZZumNvsiCvriO1T5rXjR1JaiaKWKuLICdqWeHwAAAKgrO9qlN9NvKRxzFbAtRX3xnV7Xrf9F1/7tbG385Wflte2gmx6ZIn9GduI64aijUNSR40lZfkvBMm2sTVPsqAoAAAAAAABgOxRGocEzTUMB21Io5ijDZ2lrOKaiiCPbMhIfspeHlma17/nnn9cFF1ygrVu3qmnTppo8ebJOPfXUcs9plOGTZRoqDMfb3QV9liKxeJs91y2z+5NpKGhb8pfZ4SsrYCu7AoVx27YEqUr7xKyAreKoo4JQTJm++OROJOom2oNUtIirIvECAAAAqbDDXXoDtjL9looijrIDPhVs/U23XDxEa1YsU7NWrXXTw88qM7eJfi+OKuAzJU/aUhyR60lZflt+21TjDJ9cz5NpSMWR+PtmdlQFAAAAAAAAUBYz6YDiH5iHYk68KMWNr1bOL44p0+8pw2/tsOCFlma1r7i4WKNGjdLEiRMlSccee6ymTZumNm3aVOj87ICtgG2qKOwoHHPkt82kAqiyDMUL2jIDVoV3Xtq2JYhbWiFVSdklrf8cx4vH4I8XZtVkERcAAACQKuXt0ut6njbnF+jaEedo6bffqHHTPXTrY9PVKi9PRWFHUddRYSS+W5Trxa+VGbDkN01FY55cL6asQHwXVXZUBQAAAAAAALAtZtMBxVugZZUUp+QGfcpXVOGoq6KIo+KoQ0uzFPj22281YMAALV68WIZh6IYbbtCtt94q267cbctnmWqUacp14zszhWOuXK9MsZFhKGCbyvBVfpevHbUECVahhWIk5irTb8s2DVmmIc/zaryICwAAAEiVcnfpNT1dc9EwffXpJ8rOydXEaS9rz/adlB+KymeaCsccFUZicj3JZ5vKDMR3gvUsKdc2Eu+j2VEVAAAAAAAAwI7wSSFQIjtgy3E9haKOcoM+hSxHxRFHMdejpVkdmzx5skaOHKmioiK1bNlSU6dOVe/evat1TdM0lBWwlRWooSC1k5Ygnleplnqu5ynixF9bWYF4S5DMkiKtmiziAgAAAFJpR7v0bi4I66ZRI/TBnLcVzMjQxKkv6sAuh8jzJL9tqjAck2UZMk1DGT5LMqQMX7wQqlWjoDIDNjuqAgAAAAAAACgXnxYCZTTK8MkyDRWGYwr64gVPkZhLS7M6UlBQoJEjR2rKlCmSpOOPP15Tp05Vq1atUhzZjpXXEqSiiiOOPC9eZOe3TRmKv5bihVy1FzsAAABQl7bdpfd3L6KbrrtKs155SbZt6+Enp+iYHj3kKf6e2jQMmSXplmUaygz41STTp4AdX4xS9j03O6oCAAAAAAAA2BmqOIBtZAdsBWxTRWFH4ZhDS7M6snDhQg0YMEDff/+9TNPUmDFjdN1118myKt+arq6U2xLE3nXc4ZijoogjKb7bmBR/PbEbFAAAANJR2V16Hxl7u16c+owMw9Bd4yaqe8/e2hqKJY4tXahi5xgK+OK5ViTmym+byg742FEVAAAAAAAAQIVQGAXsgM8y1SjTlOvaKo46tDSrRZ7nacKECRo1apTC4bDy8vI0ffp0HXfccakOrUJ21BIkvzimTL+nDL+1w7Z6rhdfBV9aFBXwmYl2jJmB3bcQDAAAAKiuRhk+jXvgPj38wL8kSfc++Ij6DxhQoV16m+ewSy8AAAAAAACAyuETRaAc8XZmNi3NasmWLVt0wQUX6KWXXpIk9enTR5MmTVKzZs1SHFnFbdsSJF9RhaOuiiKOiqOO/FZ8xzHDkDwvvso94rjyvPj5AZ+p3KBPUryFHjuPAQAAIJ098cQTuvnG6yVJt91+p84d9jd5Erv0AgAAAAAAAKgVFEYBSInPP/9cAwYM0PLly+Xz+XT33Xdr9OjRMnaww9LurmxLkNygTyHLUXHEUcz1FI65Csfc7c6xTUMZfiuxU1SG32L1OwAAAOoV1/UqtcPuCy+8oBEjRkiSrrvuOt180/WVvgYAAAAAAAAAVAaz8ADqlOd5evDBB3XttdcqGo2qXbt2eu6559StW7dUh1YtjTJ8skxDheGYgr54wVMk5laoJUhWgJYgAAAAqD+ijquisKNwzJG37Q89yZGnqOOqMBxL7Pb07jtv65xzzpHneRoxYoTuvPNOSezSCwAAAAAAAKB2MRMPoM789ttvGjZsmGbNmiVJOuuss/TEE0+ocePGqQ2shmQHbAVsMzFJ5LdNWoIAAAAgrRSEYyoMxxLjXS0GCMUcfTj3Iw0880xFo1ENGDBAjz76aL3cKRYAAAAAAABA/UNhFIA68fHHH2vQoEFas2aNAoGAHnjgAf39739PuwkRn2WqUaYp17VpCQIAAIC08ntxVKGoI0kKRRwVR+Pto7fjeApHXdmmoZ++W6JzB/RTcXGxTjjxJP373/+WZVl1HDkAAAAAAACAhorCKAA1wnW9HRYCea6rRx74l+64/TY5jqP99ttPL7zwgg455JBUh1yraAkCAACAdFIQjiWKovJDUYWjrqT4e/6AbcpnmTINQ64Xb6MXjrlauvRHDT37r8r//Xd1P6aHJkx6VhHPlD+VvwgAAAAAAACABoXCKADVEnXcROu4bdeK//rLL7rkwv+njz54T5I0YNAQPfbYeDVplFv3gQIAAACokqjjJtrnlS2KyvRbyvBbMrcJ1JPuAABVVUlEQVTZBTbos7Rl9WqNGHyGNv22UZ0OOliPTn5OmZmZKgzHEoVUAAAAAAAAAFDbKIwCUGUF4VhigkSSIjFXoZgj1/X03w/f17WXXqiNG35VRmam7r7vIQ0YfI4iJedlB7j9AAAAAPVBUfiP9nmlRVG5GbYC9o5b4m3cuEGDzjhVP69ZrfYd9tVjU2fIn5GjUNRR0GepKOyoUSaFUQAAAAAAAABqH5UJAKrk9+JoopVGKOKoOOoo5nqKxWIaf//devLh++R5njruf6Due/wZ7bf/AQpFHAX9lgrDMbmep9ygL8W/BQAAAIDyuK6ncCz+vr+45P1/pt/aaVFU/u+/a/CZfbX0xx+Ut9deeuG1WWrSopWKIo6KI/HCqHDMkevaMk1jh9cAAAAAAAAAgJpCYRSASisIxxJFUWVbaaxft1bXXXK+vvj0E0nSoPOG64Yxd8vwBRRzPW0NxxRxXeUGfSqOODINg52jAAAAgN1YcTTeMjsScxVzPRmGlOHfcVFUcXGxzht0lhYt/Fp7NGuu5199Q3u12Vuu5yUWUkRirvy2qeKooyxyAQAAAAAAAAC1jE8hAVRK1HET7fPKFkXN/+BtXXPZRdq86Tdl5+ToXw89qr+ecZZCUUehmKOiqKOisCPDkPKLo2qa6ZfregrYpnwWbTQAAACA3VE4Fn+/HyrZNSpgmzKN7Xd6ikajumDoEM3/78fKyc3Vcy/PVMd995MkmYYhv2UqXNJ622/Hv88K1N3vAQAAAAAAAKBhojAKQKUUhf9onxeOuopGIhr/r9v15PiHJUkHH3q4Hnlyklrt1VabCiPySs4L2JYMGdoaiqogFC+sCtqWYo6nVo2DFEcBAAAAuyHXi7+jj8U8FUdicj1TUceT50mGIZmGZMnT1ZdcqDlvvalgMKgpz89Ql0MOTbpOaTGU63pJ1wUAAAAAAACA2kRhFIAKc11P4ZKV4sVRR2tWrdC1F/8/Lfr6S0nShSMv0ajrb5Vj2ImV5dGYq5DjyHPjkycxx1XIceV6ngI5lvLDUdkFhnKCPtrqAQAAALuZqOOqIBTT5sKwoq4n2zJlGiVFTZ4U8zz984Yr9eqMF2TbtiZMflbdjzl2u+uUbjJVWg9FXRQAAAAAAACAukAVAoAKK4468iRFYq5mz3xVt15zqbbm56tx4yZ6cPwEHXP8SYnWeuGoo1DUUcxNnvEwTUOxsKvfY64MSTlBn0J+R6ZhyPU85QZ9df+LAQAAANhOQTimLUVROa4nGVLM8ZQfispnGokdoybcf4demPK0DMPQXeMm6vAex6swHFPWNoseSguhSgukdtCNDwAAAAAAAABqHIVRACosHHMVCoV0w7VXadqkpyRJRx7VXY89NVlNWrRWUSS+m9TWcFSRkgIpw4i3zfBZpkwZcuXJ8TwVhmMqiroyjJg8Q8r02yqOxAuk2DkKAAAASK3fi6MKRR2ZhlQUdVQQdlQUickfMxNFT8899aj+/dhDkqSrbrtXfz65rySpKOLI9TzllFn0ECnZUdY04xVRJpVRAAAAAAAAAOoA1QcAKuyH77/X+cPO0ZLFiyRJF11+pW74xy2SaWlLUVRSclFUht9S0GdtN+nRJNMvyzBUuplUKOIoPxRVbtCnwnBMgZJCKgAAAAB1ryAcUygaX/QQjrkqCMdkmYYMQzJMKTNg6fXnp+rxe8dIkkZceZP69D9XBeGYIq6rnIBPoagr04jvHOV6niJOPEcI2pYkKWDzfh8AAAAAAABA7aMwCkCFTJkyRX+/6CIVFRaq6R7NdOdDE3TKySfJZ5vKL44XRYWjTqIoKidoy18y6bEtQ4ZMw5DfMpTht1QYcRSOugpZjoI+S0VhR40ymSgBAAAA6lrUcVUYjkmS8kPx9/mGYSgnaMlvG3Jdac4br+mf14+WJP1t5CiNHHWlQlFHxZF4PrBVUeUEfCqKOPLbpiIxV54n2aYhv23KkJTh23GuAAAAAAAAAAA1icoDAOUqLCzU8OHDdd5556mosFA9juupV9/9r3r0Ol6u58l1vURbjNJV5Rl+a6dFUZLkKb5VlGkY8tuWMv3xY4sjpavSHbml20kBAAAAqDNF4fh78lDJ4gXTMLRHtk+ZfluZflufzn1PN4/+uzzP01lDhmnU9bfINAxl+m3lBONrryJRV+FY/Dq/F0UTLbcz/KW7RVmJlnoAAAAAAAAAUJsojAKwU4sXL9YRRxyhSZMmyTRNXXfjzXrhtTfUas89JcVXk4eijjxJ0ZirmOvJMKTgLlZ/R2Pxoiej5A6U6bdkGFKspMjKk1RcUmQFAAAAoG64rpcoaCp9P57pt9Q4wy9J+t/Xn+vmS/+mWDSqP5/SV1fcOlZllzP4bStR/FQUjqkoEtNvBWG5rqeAz0zkCZkBdosCAAAAAAAAUDdopQdgO57n6cknn9Rll12mUCik1q1ba9q0aTqiew8VhGMKeobCUVfhmKvShd4hJz5x4rdNmcbOV3+7nqeIE99hKliyq1TQZynmeArHXIVi8XYb4ZirrEDt/p4AAAAA/lBcsughUmbRQ4bfkmkYWvH9El08tL/CoWId3fN43XD3I4o4UrQoKr9lymcbMmTIMKSiSEyRmKvsgE+2Fc8NcoM+SVJWwJbPYo0WAAAAAAAAgLpBYRSAJPn5+brwwgv1/PPPS5JOPvlkTZ48Wc2bN5freioMx+S3TdmmoZjrqSjqKGBb8kpa3+1qkiMUdeR5nmzTkG2ZiR2mIka80Kq0hZ7r0UoPAAAAqEvh0hbZJbtGBUoWPSxb+qOGDzxDW/PzdXi3o/XQk1Nk+gIKRRzFSnaZCsf+uI7rSZ6kmOeqcTCggC+eI2T4LWUH+BgCAAAAAAAAQN3hE0kACV9++aUGDBigZcuWybZt3XnnnbryyislGSoMxxSOuSoIxxSKuorEHBVFYiqMOGqS6VdpHZOpne8WFYm5Ko7EJ1mCJS02/FZ8sqV0k6nS61AXBQAAANSt0sUJbplFD2vXrFb/0/to44ZfdVCXQ/TUsy/IzsiUJAVsSzEnvuur58bPNw1D2QFLMddShs9UwLbkevGdoiiKAgAAAAAAAFDX+FQSgDzP07hx43T11VcrGo1qn3320XPPPaeuR3bT1pCjcCzeUkOKrxovijiyLVOmaSgUcbQ2UiRDUqbflqvtK5pcz1Mo6iSKogIlEySSlFlSIFVaCFVaIFVONz4AAAAANcR1PRVHHYVjrn4rCMtxpd+LI/I8T1s3/6bz+p2mtatXq0PHfTX9lZlq3ryZYo6rooijiOPKtkxlb7NrbCRmamsoJk+GArapbIqiAAAAAAAAAKQIn0wCDdymTZs0fPhwzZw5U5J0xhln6KmnnpIvM0ebCiOJ4yKx+Epw1/UUiTkKRR0ZpiHLMuXEHBVEHG0uiioUdbRn4wwZMuTJUzTmKeK48koqnwI+U9kBn6R4UZRdMokSKWnbYZrxiiiTyigAAACg1kQdV0Xh5EUQrhdf1OB5nrb8nq+rhvfT0h++1555e+nZl19X8+YtJEm2ZSo3w0wsgIjE3Hj7PM+TYRiyTEOZflvZQUu5GT5ZJu/tAQAAAAAAAKQGhVFAAzZv3jwNHDhQq1evlt/v13333aeLL75Y+aGYCsMxSVIo4qg46ijm/rETlN+2FHE8haOOLCO+ytw2pJikTUURGYax3Ypw2zQU9FuJnaIyfJaySo5xvXjxlCQFS34esJNXnQMAAACoGQXhP97vS38sgtgaiioac7U5v0DXjzhH3y5eqKZ7NNOEaa8oq2krFYZjiffwUnwxQ6bfVqY/+fr5xVFZpptYBMGiBwAAAAAAAACpQmEU0AC5rqt77rlHN910kxzHUceOHfXCCy/osMMOU0E4plA03vIuPxRVOBovWDKMeLGSzzJlGoZygrZ+L45oU4GnUNSQaVoqqW1ScTSmgG0qy2/LMOPFTnaZ9hqZfitpQqU44sjz4sVTftuUoXjhFAAAAICa9XtxNPF+f9tFEIYMhcIR/fPKC/XNl/OVmZ2jsU9MV+u920uSiiKOXM9TTtC30+uz6AEAAAAAAADA7oTCKKCB+fXXX3Xuuefq7bffliQNHjxYjz/+uHJychR13MTK8bJFUZl+Sxl+a7uV3kFfhppk+rXqtyJtLAjLZxmKup5sMz7xkVGmVZ5hSH7LTGqfJ0nhmKOiiJM4XpICtpVoqQcAAACgZuxqEUSGz9Ato0fp0w/nyB8I6sYHn9Ze+3ZWQTimiOsqJ+BTKOrKNJJ3jiqLRQ8AAAAAAAAAdicURgENyHvvvachQ4bol19+UUZGhh555BENHz5cRknBU1H4j5XjpZMkuRl2ov3djvhtS/s0y1LAZ+m3grC2FEfluJ6KIo5+L46oRW5QQZ+loC+5sMr1PBVH/iiKCvhMBUsmTDIDTJwAAAAANWlXiyAMSdddOUpvvvaSbNvWPY9P0sHdj1M45ioSix+7VVHlBHwqijjyl+wmWxaLHgAAAAAAAADsbiiMAhoAx3E0ZswY3X777fI8TwceeKBeeOEFde7cOXGM63oKx+KTGMUlq8gz/Va5RVGlfJappll+uZ6noM9SKOYoaFsyDEMx11PM8RQxXBmG5HlSJOYq4rjy4h07FPCZyi1px5EVsLebYAEAAABQPbtaBHHXmFs0+amJMgxDdz40QcefcJIKwlGZhqGo46o4Gm+j57dMBWxLxRFHvoz4+3YWPQAAAAAAAADYXVF9AKS5tWvX6vjjj9eYMWPkeZ7+3//7f/r888+TiqKkeDGUp3jRUsz1ZBh/rPKuiKyArUaZPhmGoaBtKeAzZRlSKOIqHHO1NRRTfnFMW0MxhWNuor1GTtBOFEVl+C1l76QlBwAAANKL67o6+uijZRhG0teKFStSHVra2dUiiPHjHtBD990jSRp7/zj1O7u/JCk74FPA98fOUPnFUf22NaxwzFFBKKaicEz5xVFtKowkFUWx6AEAAAAAAADA7oIKBCCNvfnmmzrvvPO0ceNGZWdna8KECRo8ePAOjw2XtMcIlUyYBGwzqfVdRTTO8CsUcbSlKCpJapTpl+d5CvhMua4nz5MMQzLNePGU3/5jkiQrYFMUBQAA0IA8/PDDmj9/fqrDaBDKWwTx7ORnNOYfN0iSbrxljM772/mS4rtAhaKusgM++SxHplnSKi/qyCqMyrYMxVxXGf74e3jbNJThtxI7RbHoAQAAAAAAAMDugE8pgTQUjUZ144036t5775UkHXbYYXr++ee177777vQct6SvnevG/63qyu7GmX55nuS4ngxJlvXHivFtGZICtqXMgMVKcgAAgAZk5cqVuvHGG1MdRoOxs0UQr7/6sq4edYkk6eLLr9ClV1ydOCcn6JNpxFQUcRSwS3aX8qStYUeuPNmmKU8lbfNY9AAAAAAAAABgN8UnlUCaWbFihQYNGpRYfX/ppZfq3nvvVSAQKPe8krqoxL+V3S2qlGFItmUq6DPUKMOniOPKZ5lyvTI7RhmGArapDJ8l06za8wAAAKD+GjFihAoLCyVJnTp10rfffpviiNLbjhZBvD/nHY08f5hc19U5Q/+mm27753bnZQVsBWxTRRFHEcdVZsCW60k+y1Buhl+WaSQWQbDoAQAAAAAAAMDuiE8rgTTy8ssv67DDDtP8+fPVuHFjzZgxQ+PGjdtlUZQUL1gq+2/p5ElllZ5W2jIvK2CraZZfzbIDap4TULPsgJpm+ZUVsCmKAgAAaICmTJmit956S5LUu3dv9e/fP8URpb9tF0F89fmn+tu5AxWNRvXXM/pp7APjZOxkYYRtmcrN8JW8h7dkW/HdpsySBQ8+y1R2wFaz7IAaZfooigIAAAAAAACwW+ETSyANhEIhXXrpperXr5+2bNmio446Sl9//bXOPPPMCl+jdIeo0mKlqONWKZZISZuO0utUdecpAAAApJ8NGzZo9OjRkqRgMKjHHnssxRE1DGUXQXz/v8UaOuBMFRcV6c+9/6JHJj4ty7J2eQ3TMJThs9Uow6cmWX7tkR3QHtl+Fj0AAAAAAAAA2K1RGAXUcz/++KOOOeYYPfLII5Kkq6++WnPnzlXbtm0rdZ2AHb8dBO34pEg45lZ61yjX8xQpKagqvU7pdQEAAIDLL79cv/32myTppptuUseOHVMcUcNQulhh1YplunDwmdqa/7u6dT9aT02ZLr/fX+HrsAgCAAAAAAAAQH1DxQJ2yXVdHX300TIMI+lrxYoVqQ6twZs2bZoOP/xwff3112rWrJlmz56te+65Rz6fr9LXyvBZMiT5bVO2acjzpOKIU6lrFEcceZ5km4b8timj5LoAAADAG2+8oenTp0uSOnfurGuuuSbFETUcAdvUz2vXaPjZfbVp4wYd0LmLJj83Q5mZmRW+BosgAAAAAAAAANRHfIqJXXr44Yc1f/78VIeBMoqKinT++edryJAhKigo0J/+9CctWLBAJ598cpWvaZqGAiUTHKXFTEURR+FYxYqjwjFHRSWFVBn+0okSi5YaAAAA0NatW3XRRRdJkgzD0IQJE6pUzI+qKfx9swacfqrWrlmtfdp30GNTZ8ifmVOpa7AIAgAAAAAAAEB9RGEUyrVy5UrdeOONqQ4DZSxZskRHHnmknnrqKRmGoZtvvlnvvvuu8vLyqn3tzEB8YiPotxTwxW8P+cUxFYZjO22r53qeCsMx5RfHJEkBn6lgyQRJ6fUAAADQsF1//fVavXq1JOn8889Xjx49UhxRw5Gfn69TTjlZP/7wvVrn5WnajFlq1rwFiyAAAAAAAAAANAgURqFcI0aMUGFhoSSpU6dOKY6mYfM8T08//bSOPPJI/e9//1OrVq00Z84c3XbbbbJtu0aew2eZygrEr5Ub9CWKo4oijjYVRpRfHFUoGp9ACUUd5RdHtakwkpgkCfhM5QbjK/+zArZ8FrcYAACAhm7evHkaP368JKlly5YaO3ZsiiNqOIqLi/XXv/5VX375pZo1a6bnX31DHdq3ZREEAAAAAAAAgAajZqopkJamTJmit956S5LUu3dv9ejRQ7fddluKo2qYtm7dqr///e+aNm2aJOkvf/mLpkyZohYtWtT4c2UHbDmup1DUUW7Qp5DlqDjiKOZ6CsdchWPudufYpqEMv5WYJMnwW8oOcHsBAABo6CKRiM4//3x5JYU3DzzwgJo0aVLncfz666/asGFDpc5ZunRpLUVTN6LRqPr3768PP/xQOTk5euutt7Rf584qDMeUG/QpX1GFo66KIo6Ko478lhlvkWdInidFYq4ijqvSmikWQQAAAAAAAACoj6hcwA5t2LBBo0ePliQFg0E99thjmjp1aoqjapi+/vpr9e/fX0uXLpVlWbr+H7fqklFXyrRMbSqMKGCbyvDVbBuLRhk+WaahwnBMQV+84CkScxWKOXJdT54nGYZkmoaCtiW//cekSFbApigKAAAAkqR//vOf+vbbbyVJJ554ogYNGpSSOMaPH9+gFnm4rqthw4Zp1qxZCgaDmjVrlg4//HBJYhEEAAAAAAAAgAaFTzOxQ5dffrl+++03SdJNN92kjh07pjiihsfzPI17+BFdc/VVikQiyttrLz3+9L915FFHS4pPaDjyFHVcFYZjCtiWMgNWja3czg7YCtimisLx1nl+20wqgCrLkGr8+QEAAFB93333Xa1du0WLFmratOlOf/7NN9/o7rvvliRlZGToscceq7VY8AfP83TppZdq2rRpsm1bL730kv70pz8lfs4iCAAAAAAAAAANCZ9oYjtvvPGGpk+fLknq3LmzrrnmmhRH1PBs3rxZQ4f/Ta+/9qok6cRTTtW94x5TMKeRthRFdjhZEYo5CsWcGp2s8FmmGmWacl1bxVFH4Zgr1yszWWIYtbJjFQAAAGpGp06dau3ad911l6677rod/sx1XZ1//vmKRqOSpFtuuUXt2rWrtVjwh3/84x8aP368DMPQv//9b/Xp02e7Y1gEAQAAAAAAAKChoDAKSbZu3aqLLrpIkmQYhiZMmCCfz5fiqBqW+fPnq/+AgVq9aqV8Pp9uuPUODRh2oRxPCke3aW3heApH3Xh7C5+loN9SYTgm1/OUG6y5v5tpGsoK2MoK1NglAQAAkMbGjRunTz/9VJLUpUsXXXnllSmNZ+TIkTr77LMrdc7SpUt1+umn105AteS+++7THXfcISnePrC81oUsggAAAAAAAADQEFAYhSTXX3+9Vq9eLUk6//zz1aNHjxRH1HC4rqv77rtPN9xwg2KxmPZp2073T3hG+3U+VE7J5ETANuWzTJmGIdeLt9ELx1zFXE9bwzFFXFe5QZ+KI45Mw6DNBQAAAOrcypUrddNNN0mSTNPUxIkTZdupfV/aokULtWjRIqUxbMt1vRotSHrqqad01VVXSZLuvPNO/f3vf6/QeSyCAAAAAAAAAJDOqJpAwrx58zR+/HhJUsuWLTV27NgUR9RwbNiwQUOHDtWbb74pSep75lm6eewD8mfkSJIy/ZYy/JZMI3liJOizlOV5Ko44Koo4Ckdd5Suq3KBPheFYopAKAAAADZPneXX+nKNHj1ZhYaEkacSIEerevXudx7A7izpuooXddn8dT3IUXwARfz9fsRZ2L730ki688EJJ0tVXX73TFocAAAAAAAAA0NBQGAVJUiQS0fnnn5+YOHnggQfUpEmTOo3h119/1YYNGyp1ztKlS2spmrrz4YcfavDgwfr5558VDAb1z7H3qd+g81QQcSRJuRm2Ara10/NNI77C27YM5RfHFI66ClmOgj5LRWFHjTIpjAIAAEDd+emnnxLfz5w5U2+//Xa5x2/atClp3KtXr6Qdpr7++mvl5OTUbJApUhCOqTAcS4wjMVehmCPXLbNjlGkoaFvy26ZCMUehmKOsgL3T3WDffvttDR48WK7r6oILLtDYsWNlGLS+AwAAAAAAAACJwiiU+Oc//6lvv/1WknTiiSdq0KBBdR7D+PHjddttt9X586aK4zi64447dNttt8l1XR1wwAF67Okp6tT5IG0ujEiK7xRVXlFUWQHbUqbfU1HEUXEkXhgVjjlyXbtSLTgAAACAmrJ27dpKn7Ny5cqkseM4NRVOSv1eHFUoGv9dQhFHxVFHMXcHO3o5nsJRV7ZpKMNnKei3VBiOyfU85QZ9SYfOmzdPZ5xxhqLRqM4++2w99thjFEUBAAAAAAAAQBkURu0mvvvuu1q7dosWLdS0adOd/vybb77R3XffLUnKyMjQY489VmuxIG7dunUaMmSI3n//fUnS8OHDdfe/HpBnBxSJuYq5ngxDyvBXrCiqVIbfSkywRGKu/Lap4mh8hTkAAACA1CgIxxJFUfmhqMJRV1J8h6jS9temYcj14m30wiU5wdZwTBHXVW7Qp+KII9MwEjtHLVq0SH369FFRUZFOPPFETZ06VZZVufwBAAAAAAAAANId1RK7iU6dOtXate+66y5dd911O/yZ67o6//zzFY1GJUm33HKL2rVrV2uxQHrrrbd07rnnasOGDcrKytJjjz2mc889V5sKI4o68VYaUnyCxKzkam/TMOS3TIVLWnL47fj3WYHa+E0AAACA7S1YsKBSx996661JO8cuX75cbdu2rdmgUijquIn2eWWLojL9ljL81nbv+YM+S1mep+KIo6KIo3DUVb6iyg36VBiOKWCbWvHTMv3lL3/Rli1b1KNHD82YMUN+v7/OfzcAAAAAAAAA2N1RGNXAjRs3Tp9++qkkqUuXLrryyitTFsvIkSN19tlnV+qcpUuX6vTTT6+dgGpYNBrVzTffnNid6+CDD9YLL7yg/fffX5LkevE2Gm5JOw2fZVbpeUqLoUqvU3pdAAAAAHWvKPxH+7zSoqjcDLvcltmmYSgrYMu2DOUXxxSOugpZ8XbZP/60UqeccILWr1+vQw45RLNmzVJWVlad/C4AAAAAAAAAUN9QGNWArVy5UjfddJMkyTRNTZw4UbadupdEixYt1KJFi5Q9f21atWqVBg0apHnz5kmKF4Hdd999CgaDiWNK65dK/63sblGlSk/b9noAAAAA6pbregqX7AhbXNJKL9NvlVsUVVbAtpTp91QUcVQccVSYv1lnnHaKVq5cqX333VdvvfWWGjduXFvhAwAAAAAAAEC9R2HUbsJLQfXK6NGjVVhYKEkaMWKEunfvXucxNASvvfaahg8frs2bNys3N1dPPfWUzjrrrO2OMwxJ3h+FTVXd6an0tNLrVLG+CgAAAEA1FUcdeZIiMVcx15NhSBn+ihVFlcrwWyqOOtry++8aMeh0/fD9d8rL20vvvPOOWrZsWTuBAwAAAAAAAECaoDCqAfvpp58S38+cOVNvv/12ucdv2rQpadyrV6+kHaa+/vpr5eTk1GyQ9Vg4HNa1116rhx56SJJ05JFH6rnnnlP79u13eLxpGHLkyTQNyfEUdVwFfZWbNJHiky6S4tdR1XeeAgAAAFA94ZL35qGSXaMCtlnp9+emYciNhHXZ3wZr0YKv1HSPZnpp5hvaZ599ajxeAAAAAAAAAEg3FEZBkrR27dpKn7Ny5cqkseM4NRVOvbds2TINGDBAX375pSTpiiuu0F133SW/37/TcwK2GS+Gsi2Fo67CMVdZnlepiRPX8xRx4pMvwZL2HAHbrMZvAgAAAKCqSneBdd34vz6r8u/No9Gorvj7cH3+ycfKys7R9BmvqeN++9donAAAAAAAAACQrqiYAGrY888/r8MOO0xffvmlmjZtqtdff1333XdfuUVRkpThs2RI8tumbNOQ50nFkcoVmxVHHHmeZJuG/LYpo+S6AAAAwO7q1ltvled5ia+2bdumOqQaU9rmuvTfyu4W5bquRl88QnPemq1AIKjxk5/TIYcdrhR0YgcAAAAAAACAeonCqAZswYIFSRMQu/q65ZZbks5fvnx50s8bN26cml9kN1FcXKwRI0Zo4MCB2rp1q4499lgtXLhQp556aoXON01DgZJdnkqLmYoijsKxihVHhWOOikoKqTL8pbtFWYmWegAAAADqVmkdVOm/biUqmjzP043XXKGXnp8u27Z134RJOuqYY5OuBwAAAAAAAAAoH4VRQA349ttv1a1bN02cOFGGYeimm27S+++/r7322qtS18kMxAuagn5LAV/8/575xTEVhmM7nURxPU+F4Zjyi2OSpIDPVLCksKr0egAAAADqXukOUaWLFaIlba8r4p47xuiZJybIMAyNHfe4evY+KXGdyu48BQAAAAAAAAANlZ3qAID6bvLkyRo5cqSKiorUsmVLTZ06Vb17967StXyWqayArcJwTLlBn/IVVTjqqijiqDjqyG+Z8RZ5RrwdRyTmKuK4iVYaAZ+p3KBPkpQVsOWzqH0EAAAAUiVgm4o6roK2pXDUVTjmKsvzdlnY9PgjD+mBe++WJN35rwd0Yt+z5HlS0C7dGZb3+QAAAAAAAABQERRGAVVUUFCgkSNHasqUKZKk448/XlOnTlWrVq2qdd3sgC3H9RSKOsoN+hSyHBVHHMVcT+FYfDJlW7ZpKMNvJXaKyvBbyg7wf28AAAAglTJ8lgrDMfltU7ZpKOZ6Ko44yirnvfq0KZN1643XSZKu/8dt6n/u/1NRxJFtGvFFEvqj9TYAAAAAAAAAoHxUTgBVsHDhQvXv318//PCDTNPUmDFjdN1118myamaColGGT5ZpqDAcU9AXL3iKxFyFYo5c15PnSYYRb8kRtC35y6wYzwrYFEUBAAAAuwHTNBSwLYVijjJ8lraGY/EiJyv++LZmvfaKrrpspCTpoktHacTlV2hryJEUX/wgSQHbSrTUAwAAAAAAAACUj+oJoBI8z9Pjjz+u0aNHKxwOKy8vT9OnT9dxxx1X48+VHbAVsE0VhR2FY478tplUAFWWofgESWbAon0eAAAAsBvJDMQLo4J+SxHXVTjqKr84pky/pwy/lWir9+F772rk+cPkuq4GnzdMV940JlEUFfCZid1hMwPsFgUAAAAAAAAAFUUFBSrs1ltvled5ia+2bdumOqQ6tWXLFvXv318jR45UOBzWqaeeqgULFtRKUVQpn2WqUaZPzbIDyg7Y8lmmLNOQaRiyTEM+y1R2wFaz7IAaZfooigIAAAB2Mz7LTLTOyw36FPDF37MXRRxtKowovziq/86bp2FD+isSiejk087Qtf+8T8XReAvtgM9UbtAnKb47LO/5AQAAAAAAAKDi2DEKqIDvv/9eJ598spYvXy6fz6exY8dq1KhRMoy6aWFhmoayArayAnXydAAAAABqUHbAluN6CkUd5QZ9ClmOiiOOYq6nRYsWafjAM1VcVKRjev6f7nhogkzTkm0ayvBbiZ2iMvwWLbMBAAAAAAAAoJL4VBWogLy8PPn9frVr107PPfecunXrluqQAAAAANQjjTJ8skxDheGYgr54wVMk5so2Pflsnw474ig98vRUZWcFFbStpDbaWQGboigAAAAAAAAAqAI+WQUqIDs7W7NmzVKzZs3UuHHjVIcDAAAAoB7KDtgK2KaKwo7CMUd+21T3I4/QrHfeV9Ome6hxkyaJYw1JAdtSZsCifR4AAAAAAAAAVBGFUUAFdezYMdUhAAAAAKjnfJapRpmmXNdWcdRROOZq3333ledJhiGZhqGAbSrDZ8k066Z1NwAAAAAAAACkKwqjAAAAAACoY6ZpKCtgKyuQ6kgAAAAAAAAAIH2xHz8AAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtENhFAAAAAAAAAAAAAAAAIC0Q2EUAAAAAAAAAAAAAAAAgLRDYRQAAAAAAAAAAAAAAACAtGOnOgCgOsLhcNJ46dKlKYoEAAAgdTp06KBgMJjqMIC0Qq4BAABArgEAAACg/qMwCvXa6tWrk8ann356agIBAABIoW+++UadO3dOdRhAWiHXAAAAINcAAAAAUP/RSg8AAAAAAAAAAAAAAABA2qEwCgAAAAAAAAAAAAAAAEDaMTzP81IdBFBVW7Zs0YcffpgYt2nTRoFAIIURIdWWLl2a1Obk1VdfVceOHVMXEOoNXjuoCl43qKqafu106NBBwWCwBiIDUIpcA9viv/uoKl47qApeN6gqcg0AAAAASGanOgCgOho3bqy+ffumOgzsxjp27KjOnTunOgzUQ7x2UBW8blBVvHaA3Q+5BnaFezeqitcOqoLXDaqK1w4AAACAho5WegAAAAAAAAAAAAAAAADSDoVRAAAAAAAAAAAAAAAAANIOhVEAAAAAAAAAAAAAAAAA0g6FUQAAAAAAAAAAAAAAAADSDoVRAAAAAAAAAAAAAAAAANIOhVEAAAAAAAAAAAAAAAAA0g6FUQAAAAAAAAAAAAAAAADSDoVRAAAAAAAAAAAAAAAAANIOhVEAAAAAAAAAAAAAAAAA0g6FUQAAAAAAAAAAAAAAAADSDoVRAAAAAAAAAAAAAAAAANKOneoAAKAmNW/eXLfcckvSGKgIXjuoCl43qCpeOwBQ/3DvRlXx2kFV8LpBVfHaAQAAAIBkhud5XqqDAAAAAAAAAAAAAAAAAICaRCs9AAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABpx051AABQFZs2bdLixYv1ww8/aNOmTZKkxo0bq3379urWrZsaNWqU4ghRF5YsWaJFixbp559/lmVZysvL0xFHHKF27drVaRyu62revHlatmyZ1q1bp0aNGikvL0/HHXecmjRpUqexYOc8z9OyZcv0zTffaPXq1crPz1dmZqaaNm2qQw45RF26dJFlWakOE6iQSCSiuXPnasWKFdqwYYOaNm2qNm3aqGfPnsrMzEx1eABQr5FrQCLXQOWQayCdkGsAAAAASDcURgGoFzzP0yeffKIZM2bonXfe0TfffCPP83Z4rGmaOumkk3TVVVfpz3/+c63F1LZtW61cubLS51188cV65JFHaiGihuOll17S7bffrkWLFu3w58ccc4zuuOMO9erVq1bjiMViGjt2rMaPH6+ff/55u5/7/X6ddtpp+te//qW2bdvWaizYsa1bt+r111/XzJkz9d5772nDhg07PbZJkyYaPny4rrrqKu255541HssHH3xQ5XvS559/riOOOKKGI8KuGIZRpfPuvfdeXXXVVTUcTVxhYaFuvvlmTZo0KTFZX1Z2drb69++vsWPHqlmzZrUSAwCkG3INlEWugYoi10B1kGsAAAAAQN2hlR6AeuHcc89Vjx49dP/992vx4sU7naiQ4itqZ8+erf/7v//TiBEjFI1G6zBS1CbHcTR8+HCdffbZO52okKR58+bp+OOP180331xrsaxfv15HH320brrpph1OVEjxVZYzZszQIYccotdee63WYsGObd26VS1atNCQIUP0/PPPlztRIUmbN2/W/fffr4MOOkivvPJKHUUJVNz333+vww47TPfff/8OJyokqaCgQE8//bS6dOmiTz75pI4jBID6iVwDErkGKodcA+mGXAMAAABAOmPHKAD1QkFBQdI4NzdXxxxzjLp166aWLVvK7/dr1apVmj17tr788svEcRMnTtSmTZv0wgsvVHk1XkU0adJETZs2rdCxzZs3r7U40t3o0aM1adKkxDgzM1NDhgzRoYceqkgkok8//VQzZsxQNBqV67q6/fbb1aRJE40ePbpG4yguLlbfvn31xRdfJB7Ly8vTOeecow4dOui3337Tm2++qY8++kiSlJ+fr4EDB+q9997T0UcfXaOxYOccx1EoFEp6rH379urZs6f2339/NWvWTKFQSIsXL9aMGTO0ceNGSfH2OWeffbZefPFFnXHGGbUW3z777CPbrthbsWAwWGtxoGJatGihnJycCh1bG21tNmzYoFNOOUU//fRT4rF9991XgwYNUps2bfTLL79oxowZWrBggSTpl19+0Wmnnab58+erY8eONR4PAKQTcg1I5BqoHHIN1CRyDQAAAACoZR4A1AN9+/b1JHknnXSS99JLL3nhcHinx7700kteTk6OJynx9eSTT9Z4TPvss0/i+rfcckuNXx/JZs2alfQ3PfDAA71Vq1Ztd9yCBQu81q1bJ44zTdNbtGhRjcZy1VVXJcVy1llneaFQaLvjnn32Wc/n8yWOa9OmjVdcXFyjsWDnNm/e7EnycnNzvVGjRnkLFy7c6bGFhYXeBRdckPR3bdKkibdhw4Yai+f9999Puv7y5ctr7NqoHWX/Xs8880xKYznrrLOS4rn88ss9x3G2O+6ee+7xDMNIHNetW7cURAsA9Qu5Bsg1UFnkGqgucg0AAAAAqDu00gNQL/Tq1UufffaZ3nzzTfXr109+v3+nx/br108vvfRS0mN33HFHbYeIWuS6rq6//vrEODMzU6+//rratGmz3bGHHHKIXnzxRZmmmTj3hhtuqLFY1qxZo0ceeSQxPvjggzVt2jQFAoHtjh08eLDGjBmTGK9evVqPPvpojcWC8tm2reuvv17Lly/XAw88oIMPPninx2ZmZmrixIkaPHhw4rHNmzdr/PjxdREqUK7PP/886b9rJ598sh588MHEfa6sq6++WhdeeGFi/Nlnn2nGjBl1EicA1FfkGg0buQaqglwD6YJcAwAAAEBDQGEUgHph1KhROvLIIyt8/F/+8hf95S9/SYyXL1+u//3vf7URGurAu+++q8WLFyfGl112mdq3b7/T44855hidffbZifGsWbO0dOnSGonlscceS2qZcM8998jn8+30+Kuuukp5eXmJ8UMPPVQjcWDXsrOzdeedd1a49Ywk3XvvvUmtcGbNmlUboQGV8uCDDyaN77///nKPv+uuu5SRkbHT8wEAycg1GjZyDVQFuQbSBbkGAAAAgIaAwigAaat3795J42XLlqUoElTXK6+8kjQ+//zzd3nOBRdckDR+9dVXazyWffbZJ2lSbEds29bw4cMT49WrV+uLL76okVhQ81q3bq1OnTolxtw3kGrRaFRvvPFGYnzcccfpgAMOKPecJk2aqF+/fonxvHnz9Ouvv9ZajADQEJFrpA9yDdQVcg3sbsg1AAAAADQUFEYBSFvZ2dlJ48LCwhRFguoq+0Fdhw4d1KFDh12ec9xxxykYDCbGNbEad/ny5fr2228T4969eyet+N2ZE044IWnMyuDdW9l7B/cNpNrHH3+s33//PTHe1QRpqbL3Hdd1NXv27BqPDQAaMnKN9EGugbpEroHdCbkGAAAAgIaCwigAaWv58uVJ41atWqUoElTHli1btGrVqsS4e/fuFTrP7/era9euifGiRYuqHcvChQuTxhWNpVu3brJtu0ZjQe1ZsWJF4nvuG0i1qt53jjnmmKQx9x0AqFnkGumBXAN1jVwDuxNyDQAAAAANBYVRANJW2TYEfr9fhx9+eK0911tvvaUTTjhBe+65pwKBgBo1aqT27durb9++uv/++9lWvBrKrpqWpI4dO1b43LKrvTdv3qxffvklJbEEg0G1bt06Mf7f//5XrThQez7++OOk/78effTRtfZcN9xwgw499FA1adJEfr9fLVq00MEHH6wRI0bo5ZdfluM4tfbcqLxnn31Wf/rTn9SiRQv5/X41bdpU++23nwYMGKDHH39c+fn5tfK8Vb3vtG3bVpZlJcbcdwCgZpFrpAdyDdQlcg3sDLkGAAAAANQuCqMApKWXX35ZS5cuTYxPOukk5ebm1trzzZ8/X3PmzNEvv/yiSCSi/Px8LV++XDNnztSVV16pffbZR1deeaXC4XCtxZCufvrpp6Tx3nvvXeFztz1222ulKpbqxoHac8899ySN+/fvX2vPNX36dC1cuFBbtmxRNBrVhg0btHjxYk2cOFH9+vXTfvvtp9dee63Wnh+VM2fOHM2dO1cbNmxQNBrV5s2b9eOPP+qFF17QRRddpL333lt33XWXXNet0ecte78wTVN77bVXhc6zbVt77rnnDq8DAKgeco30Qa6BukSugZ0h1wAAAACA2kVhFIC089tvv+mSSy5JjE3T1D/+8Y9af96MjAzl5eUpLy9PgUAg6WehUEj333+/jj76aG3YsKHWY0kn266MbNq0aYXPbdKkSdJ469atu0Us0WiUiavd0PTp0/X6668nxoceeqj69u1bq8/ZpEkT7bPPPmrWrJlMM/lt2U8//aTTTz9dN954Y63GgIrLyspSmzZt1KpVK/l8vqSf/f7777rhhht00kknqbi4uMaes+x9JycnJ6lVzq6Uve9U9/4HAIgj10gv5BqoK+Qa2BVyDQAAAACoPRRGAUgrsVhMgwYN0rp16xKPXXbZZTriiCNq/Lksy1KfPn305JNPaunSpSosLNSaNWu0Zs0aFRYW6osvvtDFF18sv9+fOOfrr79W3759+aC6EgoKCpLGwWCwwudmZGSUe636HAtq1pIlS3ThhRcmxrZt64knnthuAqG69thjD1166aX6z3/+o99++02bNm3SihUrtGHDBm3atEkvv/yyevTokXTOnXfeqXHjxtVoHKgYv9+v/v37a/r06Vq1apUKCgq0atUqrVu3TgUFBZo7d67OOeccGYaROOedd97ROeecI8/zaiSGsveKytxzpOT7DvccAKg+co30szu9v9+dYkHNItfAjpBrAAAAAEDdqfgyEACQ9N1339XatVu0aFGpVbE7cskll+idd95JjLt27aq77767uqHt0Pz589W8efMd/syyLHXt2lVdu3bVsGHD1KdPH/3666+SpE8++UTjxo3T1VdfXStxpZtQKJQ0Ljv5syvbrqav7srK3SkW1Jx169apT58+SR/m3n333TU+ydm1a1etWbNmpx84N2rUSGeccYZOP/103XHHHUm7T1xzzTU644wz1KZNmxqNCeVbs2bNTu/zfr9fxx57rI499lgNGTJE/fr1U1FRkaR4i6WXXnpJZ599drVjKHvfqcw9R0q+73DPAVAfkGv8gVyjbuxO7+93p1hQc8g1sDPkGgAAAABQdyiMAlApnTp1qrVr33XXXbruuuuqfP6NN96oCRMmJMZt27bVzJkzt/uQuKbs7AOsbR1xxBF69dVX1aNHj8SqvrvvvlujRo3abnt0bG/bD3YjkUiFz912tfy2K6lrIpaKrqqs6VhQMzZt2qQTTzxRK1euTDx24YUX6sorr6zx58rJyanQcYZh6KabbtLatWv1+OOPS4q/fu655x49/PDDNR4Xdq6i9/mTTjpJTz/9tAYOHJh4bMyYMTUyWVH2HlOZ+5+UfN/hngOgPiDX+AO5Rt0g10BtItdAecg1AAAAAKDu0EoPQFq46667dOeddybGeXl5evfdd9W6desURvWHo48+OulDq02bNum///1vCiOqP7Kzs5PG266kLs+2qxa3vVZ9jgXVl5+fr5NOOkmLFy9OPDZkyBA99thjKYzqD//85z+TPmB+/fXXUxgNdmXAgAHq1q1bYvzNN99oxYoV1b5u2XtFZe45UvJ9h3sOAFQduUb62p3e3+9OsaD6yDVQk8g1AAAAAKB6KIwCUO898MADuuGGGxLjli1b6t1331X79u1TGNX2zjzzzKTxJ598kqJI6pfc3Nyk8ebNmyt87pYtW5LGFV1FW9ux+Hy+WttdABVTUFCgk08+WZ9//nnisbPOOkuTJ0+Wae4eb4/22GMP9ezZMzFeuXKl1q1bl8KIsCu1cZ8ve98pKChQLBar8Lll7zvVvf8BQENFrpHeyDVQG8g1UBvINQAAAACg6naPbBxAveF5Xq19VaW1xSOPPKIrrrgiMW7WrJneffdd7b///jX5a9eIbWP69ddfUxRJ/dKuXbuk8apVqyp8btmWBZKqPYFVU7HsbhNpDU1RUZH69OmjefPmJR7761//qmnTpsmyrBRGtj3uG/VLbfy9yt53HMfR2rVrK3ReLBbTzz//nBhz3wFQH5BrVB3vGaqGXAM1jVwDtYVcAwAAAACqjsIoAPXWhAkTdOmllybGTZs21Zw5c9S5c+cURrVzZbepl+IfmGLXDjzwwKTx0qVLK3zusmXLEt83adJErVq1SkksoVAo6UPDba+DulNcXKzTTjtNH330UeKxk08+WS+++KJ8Pl8KI9sx7hv1S238vap631mxYoUcx9npdQAA5SPXaBjINVCTyDVQm8g1AAAAAKDqKIwCUC89/fTTuuiiixLjxo0b6+2339YhhxySwqjKt379+qRxs2bNUhRJ/dK4cWPtvffeiXFFt4uPRCL68ssvE+MuXbpUO5ZtX18VjeWzzz5L2pK+JmJB5YXDYZ1++ul67733Eo+dcMIJevnll+X3+1MY2c5x36hfauPvVdX7TtldCiTuOwBQGeQaDQe5BmoKuQZqG7kGAAAAAFQdhVEA6p2pU6fqggsukOd5kqTc3Fz95z//UdeuXVMcWfk+/vjjpPG2rRKwc6ecckri+2XLlumnn37a5Tlz585VKBRKjE899dRqx9GuXTsdcMABifGcOXMSr8PyvPPOO0njmogFlROJRNSvXz+9/fbbicf+/Oc/67XXXlMwGExhZOUre9/w+XzKy8tLYTTYldq4z/fo0UO5ubmJcdnXcHnK3ndM00y6jwIAdo5co+Eh10B1kWugLpBrAAAAAEDVURgFoF554YUXNGzYMLmuK0nKzs7Wm2++qaOOOirFkZUvEolowoQJSY+dcMIJKYqm/jnjjDOSxk888cQuz9n2mNNPP73GY1m5cuUuPziMxWJ65plnEuO99tpLRxxxRI3EgoqJxWIaOHCg3njjjcRjxx13nF5//fXt2hHsTv7zn//oxx9/TIx79OihzMzMFEaE8mzYsEHPPfdcYpyRkaFjjz222tf1+/3q06dPYjx37lx999135Z6zefNmzZgxIzE++uij1bJly2rHAgDpjlyjYSLXQHWQa6AukGsAAAAAQPVQGAWg3nj11Vc1ZMgQOY4jScrKytLs2bN1zDHH1Mj1e/XqJcMwEl8rVqzY6bHFxcWVuvYll1yiVatWJT3XPvvsU9VQG5zevXvroIMOSowffvhhLV++fKfHz5s3Ty+++GJi3KdPH+277747PHbFihVJf/devXqVG8tFF12kQCCQGF9zzTWKRqM7Pf5f//qX1q5dmxhffvnlMgyj3OdAzXEcR+ecc45eeeWVxGM9evTQ7NmzlZWVVa1rV+a1U9l7xrp16zRixIikx4YNG1aFKFEV0Wg0qSXNrsRiMQ0dOlRbt25NPDZgwICd7hDwwQcfJL12dvW3HTVqVNL4iiuuKPf466+/Puk1t+35AIDtkWs0XOQaqCpyDVQFuQYAAAAA1D0KowDUC2+++aYGDBiQ+PAoMzNTb7zxho477riUxNO+fXvde++9WrduXbnH/fzzzzrrrLOSVhRblqWxY8fWdohpxTRN3XnnnYlxYWGhTjvtNK1evXq7YxctWqT+/fsnVvqbpqk77rijxmJp06aNLr744qTnGzJkiMLh8HbHTp8+XbfccktinJeXp0suuaTGYkH5PM/T3/72Nz3//POJx7p3764333xT2dnZdRrL888/r549e2rmzJmKRCLlHjtnzhwdddRRSROchxxyiM4999zaDhMl1q5dqwMOOEATJkzQ5s2byz32xx9/1PHHH68333wz8VhmZqZuu+22GounW7duOvPMMxPjN998U6NHj07c58r617/+pYkTJybGXbt2Vb9+/WosFgBIR+QaDRu5BqqCXANVRa4BAAAAAHXP8DzPS3UQALArHTp00E8//ZQYZ2dnV3qr7ssuu0yXXXbZTn/eq1cvffjhh4nx8uXL1bZt2x0eW7oK1zRNHXnkkTrssMPUsWNHNW7cWJK0fv16zZ8/X2+99dZ2H0w+/vjj263ORMVcfPHFGj9+fGKclZWlIUOG6NBDD1U0GtX8+fP10ksvJa2qvvfee3XVVVft9JorVqxQu3btEuOePXvqgw8+KDeOoqIi9ezZU1988UXisby8PJ177rlq3769Nm/erNmzZye9ngKBgN5991316NGjMr8yqmHu3Ln605/+lPRY69atK93S4sMPP1ReXt52j1fmtTNp0iQNHz5cktSoUSMde+yxOvjgg7XnnnsqJydHRUVFWr58ud555x0tXLgw6dxWrVrpk08+2en9CDWv7N/W5/Pp6KOP1qGHHqp27dopNzdXsVhM69at08cff6z33nsvadLAtm29+uqrSS0ptvXBBx/oz3/+c2I8dOhQTZo0qdyYfv31Vx111FFJO4zst99+GjRokPbaay+tX79eM2bM0Ndff534edOmTfXJJ59ov/32q+T/AgDQsJBrQCLXQOWQa6CqyDUAAAAAoO7ZqQ4AACqitKVFqYKCAhUUFFTqGps2barJkCRJruvq008/1aeffrrLYxs1aqTx48dr8ODBNR5HQzFu3Dht3bpVU6ZMkRRfzV12tWJZhmHouuuuK3eioqoyMzP1+uuvq0+fPvrqq68kxVd93n333Ts8PicnR5MnT2aioo5te9+Q4jsrVFZ57Uuq4vfff9cbb7yhN954Y5fHdu/eXc8++ywTFSkUjUb10Ucf6aOPPtrlsa1bt9akSZN0wgkn1HgcLVq00OzZs3Xaaadp2bJlkqQffvhhp6vFW7ZsqRkzZjBRAQAVQK4BiVwDlUOugZpArgEAAAAAdYNWegBQBVdeeaW6du0q2951fWnr1q1144036ttvv2Wioposy9K///1vPf/88zrooIN2elz37t01Z86cpJYYNa1Vq1aaP3++xowZo1atWu3wGL/frzPPPFMLFy7UGWecUWuxYPfXtWtXDR48WG3atNnlsYZh6JhjjtHUqVP18ccfq3379nUQIcpq2rSpRo4cqc6dO8s0d/12uUOHDho7dqyWLFlSKxMVpTp16qSFCxdq9OjRatKkyQ6PycrK0rBhw7R48WImSAGgniLXSA1yDdRX5Br1C7kGAAAAANQ9WukBQDWEw2EtWbJEP/30k37++efEyvJGjRqpefPm6tq1qzp06JDiKNPXN998o0WLFunnn3+WZVlq3bq1jjzyyDr/cNdxHM2bN09Lly7V+vXrlZOTo7322kvHHXecmjZtWqexYPe3YcMGffPNN1q1apU2btyo4uJiBQIBNW7cWG3btlW3bt3UqFGjVIeJEoWFhVq8eLFWrFihX375RYWFhbIsS40aNVKrVq3UrVu3HbY/qW2RSEQfffSRVqxYoQ0bNqhJkybae++91bNnT2VlZdV5PACAmkeukVrkGqiPyDXqF3INAAAAAKgbFEYBAAAAAAAAAAAAAAAASDu00gMAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQdiiMAgAAAAAAAAAAAAAAAJB2KIwCAAAAAAAAAAAAAAAAkHYojAIAAAAAAAAAAAAAAACQduxUBwAAQEOwatUqLVy4UBs3btTGjRvluq4aN26sVq1a6fDDD1ebNm1SHSIAAACAeohcAwAAAAAAYOcojAKANLJixQq1a9eu1q7veV6tXTsdrV69Wvfff79mz56tH374odxj99xzT/Xv31/nnXeeDj/88Co9X58+fTR79uzEuGPHjvrxxx93evywYcM0efLkKj3Xrtxyyy269dZbE2PDMKp9zVdeeUWnn356ta8DAACAyiPX2L2Qa9yaGJNrAAAAAACA8tBKDwCAGlZYWKjLLrtM++67rx588MFdTlRI0rp16/TQQw+pa9eu6tu3r7799ttKPefatWv11ltvJT22dOlSffjhh5W6DgAAAIDdF7kGAAAAAABA5bBjFACkEZ/Ppw4dOuzyuE2bNmnz5s2JcevWrZWRkVGboTUYa9as0WmnnaYFCxYkPd64cWMdf/zx6tKli5o3by6/36/169dr1apVeuedd7R8+fLEsTNnzpRhGHr11Vcr/LyTJk2S4zjbPf7UU0+pZ8+eOzynZcuWFXq9LFu2LPF9MBhUXl7eLs9p2rTpTn9W0WtsKzs7u9LnAAAAoGaQa6QeuUYcuQYAAAAAAKgMw2OvcgBocG699VbddtttifH777+vXr16pS6gNPHLL7/oiCOO0Nq1axOPtWnTRmPGjNG5554ry7J2eu7ixYt1991367nnnpPruurbt2+FJys8z1PHjh31008/SZLatWuXmPzIyMjQunXr1KhRoyr/XmVbU/Ts2VMffPBBSq4BAACA3R+5Ru0g16jdawAAAAAAgPRFKz0AAGqA4zgaOHBg0kRFz549tXjxYg0bNqzciQpJ6tKli5599ll99dVX6tSpU6We+4MPPkhMVEjStGnTFAgEJEnFxcWaPn16pa4HAAAAYPdBrgEAAAAAAFB1tNIDAFTZkiVLtHjxYq1bt07hcFiHH364/vKXv6Q0poKCAs2dO1dr1qzRxo0blZOTo7y8PPXq1UtNmjSpted94IEH9OGHHybGXbt21VtvvZWYNKioQw45RJ999plmzJhR4XOeeuqpxPdHHnmkunfvrr59++qFF15I/Pzvf/97peIAAAAAUolc4w/kGgAAAAAAAFVHYRQAYKc++OAD/fnPf06Mly9frrZt22rGjBm67bbbtHjx4qTje/bsmTRZUbalwTPPPKNhw4ZV+Tl3ZeHChfrHP/6ht956S5FIZLuf27atU045Rffee6/222+/XV6vMsLhsO67777EOBAIaMqUKZWeqCiVnZ2toUOHVujYLVu2JE1slJ43dOjQxGTFF198ocWLF6tLly5VigcAAACoaeQaFUOuAQAAAAAAUD200gMAVMqll16qs846a7uJilS6+eabdfjhh+v111/f4USFJMViMc2cOVNdunRJfIhfU6ZOnapffvklMR44cGClW1RU1bRp0xQKhSRJfr9fAwcOlCSdeOKJatWqVeK4siu9AQAAgN0Rucb2yDUAAAAAAACqhx2jAAAV9uCDD+qRRx6RJLVv316nn366OnbsKMMwtHTpUv388891HtNFF12kxx9/PDG2bVsnn3yyevTooebNmys/P1///e9/9dprrykajSoSiWjw4MHKyMjQaaedViMxzJo1K2k8YsSIGrluRZSdhOjTp4/22GMPSZJlWRoyZEhidfnUqVN1zz33yO/311lsAAAAQEWRa+wYuQYAAAAAAED1UBgFAKiwhx56SJJ022236YYbbpBtp/Y/I5MnT06aqOjevbumTp2qDh06JB03atQoffvttzrttNO0bNkyOY6j888/X0uWLFGzZs2qFYPneZo7d25inJ2draOOOqpa16yoBQsW6KuvvkqMzzvvvKSfDx06NDFZ8dtvv+nVV19V//796yQ2AAAAoDLINbZHrgEAAAAAAFB9tNIDAFTKtddeq5tvvjnlExX5+fm6/PLLE+OuXbvq/fff326iolSnTp307rvvqlGjRpKkX3/9NTH5Uh3Lli3Tb7/9lhSHadbNf17LruBu1qyZ+vTpk/TzLl266LDDDtvh8QAAAMDuhlwjGbkGAAAAAABA9VEYBQCosJYtW+rWW29NdRiSpCeffFK///67JMk0Tf373/9WMBgs95x99tlH119/fWL8xBNPyHGcasWxfv36pHG7du2qdb2KCoVCevbZZxPjgQMHyufzbXfc0KFDE9/PmTNHq1evrpP4yvPhhx/KMIxKffXq1SvVYQMAAKAWkWtsj1yj8sg1AAAAAADAtiiMAgBU2MCBA3c5IVBXpk2blvj+pJNO0oEHHlih84YNG5b4fv369Vq0aFG14ii7gluSGjduXK3rVdQrr7yizZs3J8ZlJyXKGjx4cGISw3VdPfPMM3USHwAAAFAZ5BrbI9cAAAAAAACovtTuTQ4AqFeOOeaYVIcgSSooKNCCBQsS423bOpSnZcuW2meffbRy5UpJ0qeffprUAqKytm7dmjTOzs6u8rUqo2yrigMPPFBHHHHEDo9r3ry5Tj75ZM2cOVOS9Mwzz+gf//iHDMOokzh3JBgMKi8vr1LnVPZ4AAAA1C/kGtsj16g8cg0AAAAAALAtCqMAABXWsWPHVIcgSfrmm2+S2lJ07ty5Uue3bNkyMVmxZs2aasWSk5OTNC4oKKjW9Spi+fLleu+99xLj8847r9zjhw4dmpisWLFihd5991317t27VmMsz1FHHaUPPvggZc8PAACA3Q+5xvbINSqPXAMAAAAAAGyLVnoAgArLzc1NdQiStm8p0atXLxmGUeGvzz77LHFu2RYRVbHHHnskjbds2VKt61XEM888I8/zJEmmaeqcc84p9/hTTz1VTZs2TYzLrgAHAAAAdgfkGtsj1wAAAAAAAKg+CqMAABVm27vHRoM1OSFQVFRUrfNbtmyZNF6xYkW1rrcrrutq0qRJifH//d//7bL1g9/v16BBgxLjV155pdqTNAAAAEBNItfYHrkGAAAAAABA9e0enzoBAFAJmZmZSeM2bdrI7/dX6VotWrSoViwdOnTQHnvskVhZ/uWXX8p1XZlm7dQev/3221q9enViPGfOHBmGUalrhMNhPfvss7rkkktqOjwAAACgXiPXINcAAAAAAADphcIoAMBupSKrqps1a5Y0fvHFF3XUUUfVVkjlMgxDxx13nF599VVJ0tatW/XZZ5+pe/futfJ8NdWa4qmnnmKyAgAAAA0KuUb5yDUAAAAAAEA6ojAKAFBrMjMzE5MPFW0jsX79+l0es//++yeN16xZk7LJCkk69dRTE5MVkjRx4sRamazYuHGjZs6cmRg3b95cubm5FT4/FApp7dq1kqQFCxboq6++0uGHH17jcQIAAAC1jVyjZpFrAAAAAACAdFU7e28DACCpcePGie9LPyTflfnz5+/ymBYtWqhz586J8fvvv1/p2GrSOeeco1atWiXG06dP1/fff1/jzzNlyhRFIpHEeNasWVq6dGmFv5YsWaJgMJg4v6ZWhAMAAAB1jVyjZpFrAAAAAACAdEVhFACg1hxwwAGJ7ysyCVFYWKgXX3yxQtceOHBg4vspU6Zo06ZNlQ+whgQCAV155ZWJcSgU0rnnnps0sVAZBQUFmjx58naPl51c6NChg7p161ap6zZq1EinnHJKYjxt2jSFQqEqxQgAAACkErkGuQYAAAAAAEBFUBgFAKg1ZVtOfPjhh/rxxx/LPf7aa6/V5s2bK3TtSy65JNHaIT8/X+eee65isVil4qvJD+pHjx6tnj17Jsaff/65TjnlFG3durVS11m0aJGOOuoovfLKK0mPf/rpp1qyZEliPGjQoCrFWfa8LVu26OWXX67SdQAAAIBUItcg1wAAAAAAAKgICqMAALVm8ODBie8dx9HgwYN3uNo6HA7r6quv1qOPPirDMCp07caNG2vcuHGJ8ezZs9WrV6+kD/R3xPM8zZ8/XyNHjtSxxx5bwd9k1yzL0vTp05WXl5d47N1331WXLl00ZcoUOY5T7vnffPONzjnnHB122GH63//+t93Pt21FUfZ/28o49dRTE5M8O7ouAAAAUB+Qa5BrAAAAAAAAVISd6gAAAOnroIMOUr9+/TRjxgxJ0hdffKEDDjhA55xzjjp16qRYLKbvv/9eM2bM0Jo1a2Tbtm644QaNGTOmQtcfOnSolixZonvvvVeS9N///lcHHXSQjjnmGP3pT39SmzZtlJWVpa1bt2r9+vVavHix5s+fr/Xr10uS9t9//xr9fffcc0/Nnz9fp512mhYsWCBJWrlypc477zxdfvnl6t27tw466CA1b95cPp9Pv/76q1atWqV33nlHP/30006vW1hYqOeeey4xPvTQQ9WpU6cqxRgMBnXGGWck2me8//77Wr58udq1a1el61XFp59+qo4dO1b6vH79+mns2LG1EBEAAADqG3INco0dIdcAAAAAAADbojAKAFCrHn30US1ZskTfffedJGnDhg164IEHtjvO7/friSee0N57713hyQpJuueee9S2bVuNHj1akUhEkjRv3jzNmzdvl+dallXh56movfbaSx9//LGuv/56TZw4UeFwWJK0efNmvfjii3rxxRd3eY2zzjpLd911V2L84osvJrXJqGpri7Lnl05WeJ6np59+Wrfffnu1rlkZoVBIy5Ytq/R5pZNMAAAAgESuQa6xPXINAAAAAACwLVrpAQBqVcuWLTV37lwNHTpUprnj/+wce+yx+uSTT3TeeedV6TlGjhypZcuWaeTIkWrSpEm5x2ZkZKh379569NFHNXfu3Co9365kZWVp3Lhx+vHHHzVq1Cjtu+++uzwnLy9PV1xxhRYvXqwXX3wxaZVz2RYUhmFUe7Kid+/eatGiRWI8adIkua5brWsCAAAAdY1cg1wDAAAAAABgVwzP87xUBwEAaBg2btyo999/X6tXr1YsFtNee+2lI488skIf5leU67r66quv9O2332rjxo0qLCxUdna2WrZsqf3331+dO3dWIBCoseerqJUrV2rRokXasGGDNm7cKNd11aRJE+2555467LDD1KZNmzqPCQAAAEgX5BrkGgAAAAAAADtCYRQAAAAAAAAAAAAAAACAtEMrPQAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABph8IoAAAAAAAAAAAAAAAAAGmHwigAAAAAAAAAAAAAAAAAaYfCKAAAAAAAAAAAAAAAAABp5/8D8m1GRXK5GiUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pickle\n", + "import textwrap\n", + "import numpy as np\n", + "\n", + "### Define list of experiments and metrics\n", + "\n", + "# IV\n", + "# trials = ['IV_non-linear']\n", + "# metrics = ['frobenius_norm', 'energy_distance', 'codec']\n", + "# no_rows = 1\n", + "\n", + "# RCT\n", + "trials = ['rct_non-linear']\n", + "metrics = [\"frobenius_norm\", \"prob_erupt\", \"policy_risk\", \"codec\", \"psw_energy_distance\"]\n", + "no_rows = 2\n", + "\n", + "# Known Confounders\n", + "# trials = ['known_confounders_linear']\n", + "# metrics = [\"frobenius_norm\", \"prob_erupt\", \"policy_risk\", \"codec\", \"psw_energy_distance\"]\n", + "# no_rows = 2\n", + "\n", + "\n", + "### Plot formatting and creation\n", + "no_col = 3\n", + "fontsize = 9\n", + "fig, axs = plt.subplots(no_rows, no_col, figsize=(8, 3*no_rows), dpi=300)\n", + "axs = axs.flatten()\n", + "\n", + "\n", + "### Define names for metrics and subplots to be displayed\n", + "\n", + "# IV\n", + "# metric_names = ['Frobenius Norm', 'Energy Distance', 'CODEC']\n", + "# subplot_labels = ['(a)', '(b)', '(c)']\n", + "\n", + "# RCT / KC\n", + "metric_names = ['Frobenius Norm', 'Probabilistic Erupt', 'Policy Risk', 'CODEC', 'Propensity Weighted Energy Distance']\n", + "subplot_labels = ['(a)', '(b)', '(c)', '(d)', '(e)']\n", + "\n", + "\n", + "\n", + "# Plot true against estimated for best estimator\n", + "for i, (trial, metric) in enumerate([(t, m) for t in trials for m in metrics]):\n", + " ax = axs[i]\n", + " \n", + " # IV\n", + " #filename = f\"iv_600_{metric}_run_1_{trial}.pkl\"\n", + " #with open(f\"iv/{filename}\", \"rb\") as f:\n", + " # results = pickle.load(f)\n", + " \n", + " # RCT\n", + " #filename = f\"linear_600_{metric}_run_1_{trial}.pkl\"\n", + " filename = f\"non_linear_600_{metric}_run_1_{trial}.pkl\"\n", + " with open(f\"rct/{filename}\", \"rb\") as f:\n", + " results = pickle.load(f)\n", + "\n", + " # KC\n", + " #filename = f\"linear_600_{metric}_run_1_{trial}.pkl\"\n", + " #filename = f\"non_linear_600_{metric}_run_1_{trial}.pkl\"\n", + " #with open(f\"known_confounders/{filename}\", \"rb\") as f:\n", + " # results = pickle.load(f)\n", + " \n", + " best_estimator = results[\"best_estimator\"]\n", + " CATE_gt = results[\"scores_per_estimator\"][best_estimator][0][\"test\"][\"CATE_groundtruth\"]\n", + " CATE_est = results[\"scores_per_estimator\"][best_estimator][0][\"test\"][\"CATE_estimate\"]\n", + " \n", + " # Plot\n", + " ax.scatter(CATE_gt, CATE_est, s=20, alpha=0.1)\n", + " ax.plot([min(CATE_gt), max(CATE_gt)], [min(CATE_gt), max(CATE_gt)], \"k-\", linewidth=0.5)\n", + " \n", + " ax.set_xlabel(\"True CATE\", fontsize = fontsize)\n", + " ax.set_ylabel(\"Estimated CATE\", fontsize = fontsize)\n", + " \n", + " ax.set_title(f\"{metric_names[i]}\\n({best_estimator.split('.')[-1]})\", fontsize = fontsize)\n", + "\n", + " # Change the fontsize of the x and y ticks\n", + " ax.tick_params(axis='both', which='major', labelsize=fontsize)\n", + "\n", + "\n", + " # Remove top and right spines\n", + " ax.spines[\"top\"].set_visible(False)\n", + " ax.spines[\"right\"].set_visible(False)\n", + " \n", + " # Add correlation coefficient\n", + " cate_gt_for_cor = list(CATE_gt)\n", + " try:\n", + " cate_est_for_cor = CATE_est[:,0]\n", + " except:\n", + " cate_est_for_cor = CATE_est\n", + "\n", + " corr = np.corrcoef(cate_gt_for_cor, cate_est_for_cor)[0, 1]\n", + "\n", + " ax.text(0.05, 0.95, f'Corr: {corr:.2f}', transform=ax.transAxes, \n", + " verticalalignment='top', fontsize=fontsize)\n", + "\n", + " # IV\n", + " #ax.text(-0.15, 1.15, subplot_labels[i], transform=ax.transAxes,\n", + " # fontsize=fontsize, fontweight='bold', va='top', ha='right')\n", + "\n", + " # RCT and Knwon Confoudners subplot label\n", + " ax.text(-0.15, 1.15, subplot_labels[i], transform=ax.transAxes,\n", + " fontsize=fontsize, fontweight='bold', va='top', ha='right')\n", + "\n", + "# RCT and Knwon Confoudners\n", + "# Hide the last subplot (bottom right)\n", + "fig.delaxes(axs[-1]) \n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"all_metrics_comparison.pdf\", format=\"pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pickle\n", + "import colorsys\n", + "\n", + "# Define list of trials and metrics\n", + "\n", + "# RCT\n", + "# trials = ['rct_linear']\n", + "# metrics = [\"frobenius_norm\", \"prob_erupt\", \"policy_risk\", \"codec\", \"psw_energy_distance\"]\n", + "# no_rows = 2\n", + "\n", + "# KC\n", + "trials = ['known_confounders_linear']\n", + "metrics = [\"frobenius_norm\", \"prob_erupt\", \"policy_risk\", \"codec\", \"psw_energy_distance\"]\n", + "no_rows = 2\n", + "\n", + "# IV\n", + "# trials = ['IV_linear']\n", + "# metrics = [\"frobenius_norm\", \"codec\", \"energy_distance\"]\n", + "# no_rows = 1\n", + "\n", + "\n", + "### Plot formatting and creation\n", + "no_col = 3\n", + "fontsize = 9\n", + "fig, axs = plt.subplots(no_rows, no_col, figsize=(12, 8), dpi=300)\n", + "\n", + "axs = axs.flatten()\n", + "\n", + "\n", + "### Define names for metrics and subplots to be displayed\n", + "\n", + "# IV\n", + "# metric_names = ['Frobenius Norm', 'Energy Distance', 'CODEC']\n", + "# subplot_labels = ['(a)', '(b)', '(c)']\n", + "\n", + "# RCT / KC\n", + "metric_names = ['Frobenius Norm', 'Probabilistic Erupt', 'Policy Risk', 'CODEC', 'Propensity Weighted Energy Distance']\n", + "subplot_labels = ['(a)', '(b)', '(c)', '(d)', '(e)']\n", + "\n", + "\n", + "colors = ([matplotlib.colors.CSS4_COLORS['black']] +\n", + " list(matplotlib.colors.TABLEAU_COLORS) + [\n", + " matplotlib.colors.CSS4_COLORS['lime'],\n", + " matplotlib.colors.CSS4_COLORS['yellow'],\n", + " matplotlib.colors.CSS4_COLORS['pink']\n", + " ])\n", + "\n", + "def scale_lightness(rgb, scale_l):\n", + " # Convert RGB to HLS and adjust lightness\n", + " h, l, s = colorsys.rgb_to_hls(*rgb)\n", + " return colorsys.hls_to_rgb(h, min(1, l * scale_l), s)\n", + "\n", + "all_handles = []\n", + "all_labels = []\n", + "\n", + "for row, trial in enumerate(trials):\n", + " for col, metric in enumerate(metrics):\n", + " ax = axs[col] \n", + " \n", + " filename = f\"known_confounders/linear_600_{metric}_run_1_{trial}.pkl\" # to be changed for different plots\n", + " with open(filename, \"rb\") as f:\n", + " results = pickle.load(f)\n", + " \n", + " for idx, (est_name, scr) in enumerate(results[\"scores_per_estimator\"].items()):\n", + " if \"Dummy\" not in est_name:\n", + " if len(scr):\n", + " # Plot intermediate runs\n", + " if len(scr) > 1:\n", + " lightness = np.linspace(1, 2.8, len(scr))\n", + " col_rgb = matplotlib.colors.ColorConverter.to_rgb(colors[idx])\n", + " for i_run in range(1, len(scr)):\n", + " CATE_gt = scr[i_run][\"test\"][\"CATE_groundtruth\"]\n", + " CATE_est = scr[i_run][\"test\"][\"CATE_estimate\"]\n", + " CATE_gt = np.array(CATE_gt).flatten()\n", + " CATE_est = np.array(CATE_est).flatten()\n", + " mse = np.mean((CATE_gt - CATE_est)**2)\n", + " score = scr[i_run][\"test\"][metric]\n", + " ax.scatter(mse, score, color=scale_lightness(col_rgb, lightness[i_run-1]), s=30, linewidths=0.5, label=\"nolegend\")\n", + " \n", + " # Plot best estimator\n", + " CATE_gt = scr[0][\"test\"][\"CATE_groundtruth\"]\n", + " CATE_est = scr[0][\"test\"][\"CATE_estimate\"]\n", + " CATE_gt = np.array(CATE_gt).flatten()\n", + " CATE_est = np.array(CATE_est).flatten()\n", + " mse = np.mean((CATE_gt - CATE_est)**2)\n", + " score = scr[0][\"test\"][metric]\n", + " scatter = ax.scatter(mse, score, color=colors[idx], s=30, linewidths=0.5)\n", + " \n", + " # Collect handles and labels for the overarching legend\n", + " handle = scatter\n", + " label = est_name.split(\".\")[-1]\n", + " if label not in all_labels:\n", + " all_handles.append(handle)\n", + " all_labels.append(label)\n", + "\n", + " # Add bold subplot labels\n", + " ax.text(-0.1, 1.1, subplot_labels[col], transform=ax.transAxes,\n", + " fontsize=12, fontweight='bold', va='top', ha='right')\n", + " \n", + " if col == 0:\n", + " ax.set_ylabel(\"Test score\")\n", + " ax.set_xlabel(\"MSE\")\n", + " best_estimator = results[\"best_estimator\"]\n", + " ax.set_title(f\"{metric_names[col]}\\n({best_estimator.split('.')[-1]})\")\n", + " ax.set_xscale(\"log\")\n", + " ax.grid(True)\n", + "\n", + "# Add legend in the last (empty) subplot\n", + "axs[-1].legend(all_handles, all_labels, loc='center', frameon=False)\n", + "axs[-1].axis('off') # Hide the axis of the legend subplot\n", + "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.95])\n", + "plt.savefig(\"all_metrics_mse_comparison.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pickle\n", + "import colorsys\n", + "\n", + "# Define list of experiments and metrics\n", + "trials = ['IV_non-linear']\n", + "metrics = [\"frobenius_norm\", \"codec\", \"energy_distance\"]\n", + "\n", + "# Set up the plot\n", + "# IV\n", + "no_rows = 1 if len(metrics) <= 3 else 2\n", + "no_col = 3\n", + "fontsize = 9\n", + "\n", + "# Create subplots\n", + "fig, axs = plt.subplots(no_rows, no_col, figsize=(no_col * 4, no_rows * 4), dpi=300)\n", + "\n", + "# Flatten axs for easier indexing, and ensure axs is an array\n", + "axs = axs.flatten()\n", + "\n", + "# Metric names for titles and subplot labels\n", + "metric_names = ['Frobenius Norm', 'CODEC', 'Energy Distance']\n", + "subplot_labels = ['(a)', '(b)', '(c)']\n", + "\n", + "colors = ([matplotlib.colors.CSS4_COLORS['black']] +\n", + " list(matplotlib.colors.TABLEAU_COLORS) + [\n", + " matplotlib.colors.CSS4_COLORS['lime'],\n", + " matplotlib.colors.CSS4_COLORS['yellow'],\n", + " matplotlib.colors.CSS4_COLORS['pink']\n", + " ])\n", + "\n", + "def scale_lightness(rgb, scale_l):\n", + " # Convert RGB to HLS and adjust lightness\n", + " h, l, s = colorsys.rgb_to_hls(*rgb)\n", + " return colorsys.hls_to_rgb(h, min(1, l * scale_l), s)\n", + "\n", + "all_handles = []\n", + "all_labels = []\n", + "\n", + "for row, trial in enumerate(trials):\n", + " for col, metric in enumerate(metrics):\n", + " ax = axs[col]\n", + " \n", + " filename = f\"iv/iv_600_{metric}_run_1_{trial}.pkl\"\n", + " with open(filename, \"rb\") as f:\n", + " results = pickle.load(f)\n", + " \n", + " for idx, (est_name, scr) in enumerate(results[\"scores_per_estimator\"].items()):\n", + " if \"Dummy\" not in est_name:\n", + " if len(scr):\n", + " # Plot intermediate runs\n", + " if len(scr) > 1:\n", + " lightness = np.linspace(1, 2.8, len(scr))\n", + " col_rgb = matplotlib.colors.ColorConverter.to_rgb(colors[idx])\n", + " for i_run in range(1, len(scr)):\n", + " CATE_gt = scr[i_run][\"test\"][\"CATE_groundtruth\"]\n", + " CATE_est = scr[i_run][\"test\"][\"CATE_estimate\"]\n", + " CATE_gt = np.array(CATE_gt).flatten()\n", + " CATE_est = np.array(CATE_est).flatten()\n", + " mse = np.mean((CATE_gt - CATE_est)**2)\n", + " score = scr[i_run][\"test\"][metric]\n", + " ax.scatter(mse, score, color=scale_lightness(col_rgb, lightness[i_run-1]), s=30, linewidths=0.5, label=\"nolegend\")\n", + " \n", + " # Plot best estimator\n", + " CATE_gt = scr[0][\"test\"][\"CATE_groundtruth\"]\n", + " CATE_est = scr[0][\"test\"][\"CATE_estimate\"]\n", + " CATE_gt = np.array(CATE_gt).flatten()\n", + " CATE_est = np.array(CATE_est).flatten()\n", + " mse = np.mean((CATE_gt - CATE_est)**2)\n", + " score = scr[0][\"test\"][metric]\n", + " scatter = ax.scatter(mse, score, color=colors[idx], s=30, linewidths=0.5)\n", + " \n", + " # Collect handles and labels for the overarching legend\n", + " handle = scatter\n", + " label = est_name.split(\".\")[-1]\n", + " if label not in all_labels:\n", + " all_handles.append(handle)\n", + " all_labels.append(label)\n", + "\n", + " # Add bold subplot labels\n", + " ax.text(-0.1, 1.1, subplot_labels[col], transform=ax.transAxes,\n", + " fontsize=12, fontweight='bold', va='top', ha='right')\n", + " \n", + " if col == 0:\n", + " ax.set_ylabel(\"Test score\")\n", + " ax.set_xlabel(\"MSE\")\n", + " ax.set_title(f\"{metric_names[col]}\")\n", + " ax.set_xscale(\"log\")\n", + " ax.grid(True)\n", + "\n", + "# Place the legend\n", + "if no_rows == 1:\n", + " # For a single row layout, place the legend above the plots\n", + " fig.legend(all_handles, all_labels, loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=len(all_labels), frameon=False)\n", + "else:\n", + " # Add legend in the last (empty) subplot for multiple rows layout\n", + " axs[-1].legend(all_handles, all_labels, loc='center', frameon=False)\n", + " axs[-1].axis('off') # Hide the axis of the legend subplot\n", + "\n", + "plt.tight_layout(rect=[0, 0, 1, 0.95]) # Adjust the rect parameter to make room for the legend\n", + "plt.savefig(\"all_metrics_mse_comparison.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "causal-env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From fa6c4fe50fcc8702446bac88f18da0c9cc151960 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 13:35:57 +0200 Subject: [PATCH 07/18] move new testing file to notebooks folder and rename to Run metric tests across different scenarios.ipynb Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- .../Run metric tests across different scenarios.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename causaltune/Testing.ipynb => notebooks/Run metric tests across different scenarios.ipynb (100%) diff --git a/causaltune/Testing.ipynb b/notebooks/Run metric tests across different scenarios.ipynb similarity index 100% rename from causaltune/Testing.ipynb rename to notebooks/Run metric tests across different scenarios.ipynb From 00e600b555edab990dca17ee632789cc12ee2f21 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 13:50:00 +0200 Subject: [PATCH 08/18] Fix first set of linter issues Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/scoring.py | 319 +++++++++++++++++++++++++----------------- 1 file changed, 191 insertions(+), 128 deletions(-) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index fe822baf..01c62301 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -18,15 +18,14 @@ import dcor -### Imports for CODEC +# Imports for CODEC from scipy.spatial import distance from sklearn.neighbors import NearestNeighbors class DummyEstimator: - def __init__( - self, cate_estimate: np.ndarray, effect_intervals: Optional[np.ndarray] = None - ): + def __init__(self, cate_estimate: np.ndarray, + effect_intervals: Optional[np.ndarray] = None): self.cate_estimate = cate_estimate self.effect_intervals = effect_intervals @@ -34,14 +33,17 @@ def const_marginal_effect(self, X): return self.cate_estimate -def supported_metrics(problem: str, multivalue: bool, scores_only: bool) -> List[str]: +def supported_metrics( + problem: str, + multivalue: bool, + scores_only: bool) -> List[str]: if problem == "iv": metrics = ["energy_distance"] if not scores_only: metrics.append("ate") return metrics elif problem == "backdoor": - #print("backdoor") + # print("backdoor") if multivalue: # TODO: support other metrics for the multivalue case return ["energy_distance", "psw_energy_distance"] @@ -49,15 +51,15 @@ def supported_metrics(problem: str, multivalue: bool, scores_only: bool) -> List metrics = [ "erupt", "norm_erupt", - "prob_erupt",#NEW - "policy_risk",#NEW + "prob_erupt", # NEW + "policy_risk", # NEW "qini", "auc", # "r_scorer", "energy_distance", "psw_energy_distance", - "frobenius_norm",#NEW - "codec"#NEW + "frobenius_norm", # NEW + "codec" # NEW ] if not scores_only: metrics.append("ate") @@ -92,7 +94,8 @@ def __init__( "Fitting a Propensity-Weighted scoring estimator to be used in scoring tasks" ) treatment_series = causal_model._data[causal_model._treatment[0]] - # this will also fit self.propensity_model, which we'll also use in self.erupt + # this will also fit self.propensity_model, which we'll also use in + # self.erupt self.psw_estimator = self.causal_model.estimate_effect( self.identified_estimand, method_name="backdoor.causaltune.models.MultivaluePSW", @@ -105,8 +108,13 @@ def __init__( }, ).estimator - if not hasattr(self.psw_estimator, 'estimator') or not hasattr(self.psw_estimator.estimator, 'propensity_model'): - raise ValueError("Propensity model fitting failed. Please check the setup.") + if not hasattr( + self.psw_estimator, + 'estimator') or not hasattr( + self.psw_estimator.estimator, + 'propensity_model'): + raise ValueError( + "Propensity model fitting failed. Please check the setup.") else: print("Propensity Model Fitted Successfully") @@ -123,7 +131,6 @@ def __init__( + self.psw_estimator._observed_common_causes_names, ) - def ate(self, df: pd.DataFrame) -> tuple: """Calculate the Average Treatment Effect. Provide naive std estimates in single-treatment cases. @@ -139,7 +146,8 @@ def ate(self, df: pd.DataFrame) -> tuple: estimate = self.psw_estimator.estimator.effect(df).mean(axis=0) if len(estimate) == 1: - # for now, let's cheat on the std estimation, take that from the naive ate + # for now, let's cheat on the std estimation, take that from the + # naive ate treatment_name = self.causal_model._treatment[0] outcome_name = self.causal_model._outcome[0] naive_est = Scorer.naive_ate(df[treatment_name], df[outcome_name]) @@ -158,7 +166,8 @@ def resolve_metric(self, metric: str) -> str: """ - metrics = supported_metrics(self.problem, self.multivalue, scores_only=True) + metrics = supported_metrics( + self.problem, self.multivalue, scores_only=True) if metric not in metrics: logging.warning( @@ -184,12 +193,16 @@ def resolve_reported_metrics( List[str]: list of valid metrics """ - metrics = supported_metrics(self.problem, self.multivalue, scores_only=False) + metrics = supported_metrics( + self.problem, + self.multivalue, + scores_only=False) if metrics_to_report is None: return metrics else: - metrics_to_report = sorted(list(set(metrics_to_report + [scoring_metric]))) + metrics_to_report = sorted( + list(set(metrics_to_report + [scoring_metric]))) for m in metrics_to_report.copy(): if m not in metrics: logging.warning( @@ -222,7 +235,6 @@ def energy_distance_score( YX_0 = Y0X[Y0X[split_test_by] == 0] select_cols = estimate.estimator._effect_modifier_names + ["yhat"] - energy_distance_score = dcor.energy_distance( YX_1[select_cols], YX_0[select_cols] ) @@ -283,7 +295,8 @@ def frobenius_norm_score( return np.inf # Return inf for consistently constant CATE estimates # Prepare data for treated and control groups - Y0X, treatment_name, split_test_by = self._Y0_X_potential_outcomes(estimate, df) + Y0X, treatment_name, split_test_by = self._Y0_X_potential_outcomes( + estimate, df) Y0X_1 = Y0X[Y0X[split_test_by] == 1] # Treated group Y0X_0 = Y0X[Y0X[split_test_by] == 0] # Control group @@ -304,7 +317,8 @@ def frobenius_norm_score( treatment_series = Y0X_1[treatment_name] YX_1_psw = np.zeros(YX_1_all_psw.shape[0]) for i in treatment_series.unique(): - YX_1_psw[treatment_series == i] = YX_1_all_psw[:, i][treatment_series == i] + YX_1_psw[treatment_series == i] = YX_1_all_psw[:, + i][treatment_series == i] # Calculate propensity scores for control group YX_0_psw = self.psw_estimator.estimator.propensity_model.predict_proba( @@ -322,19 +336,20 @@ def frobenius_norm_score( YX_0_psw = YX_0_psw[:min_rows] # Calculate the difference matrix with propensity score weights - D = (Y0X_1[select_cols].values - Y0X_0[select_cols].values) * np.sqrt(YX_1_psw * YX_0_psw).reshape(-1, 1) + D = (Y0X_1[select_cols].values - Y0X_0[select_cols].values) * \ + np.sqrt(YX_1_psw * YX_0_psw).reshape(-1, 1) # Compute Frobenius norm of the weighted difference matrix frobenius_norm = np.linalg.norm(D, ord='fro') - # Normalize the Frobenius norm by sqrt(n * p) where n is number of samples and p is number of features + # Normalize the Frobenius norm by sqrt(n * p) where n is number of + # samples and p is number of features n, p = D.shape normalized_score = frobenius_norm / np.sqrt(n * p) # Return the normalized score if it's finite, otherwise return infinity return normalized_score if np.isfinite(normalized_score) else np.inf - def psw_energy_distance( self, estimate: CausalEstimate, @@ -373,7 +388,8 @@ def psw_energy_distance( YX_1_psw = np.zeros(YX_1_all_psw.shape[0]) for i in treatment_series.unique(): - YX_1_psw[treatment_series == i] = YX_1_all_psw[:, i][treatment_series == i] + YX_1_psw[treatment_series == i] = YX_1_all_psw[:, + i][treatment_series == i] YX_0_psw = self.psw_estimator.estimator.propensity_model.predict_proba( Y0X_0[ @@ -415,25 +431,25 @@ def psw_energy_distance( ), ) distance_yy = np.reciprocal(yy_mean_weights) * np.multiply( - yy_psw, - dcor.distances.pairwise_distances(Y0X_1[select_cols], exponent=exponent), - ) + yy_psw, dcor.distances.pairwise_distances( + Y0X_1[select_cols], exponent=exponent), ) distance_xx = np.reciprocal(xx_mean_weights) * np.multiply( - xx_psw, - dcor.distances.pairwise_distances(Y0X_0[select_cols], exponent=exponent), - ) + xx_psw, dcor.distances.pairwise_distances( + Y0X_0[select_cols], exponent=exponent), ) psw_energy_distance = ( - 2 * np.mean(distance_xy) - np.mean(distance_xx) - np.mean(distance_yy) - ) + 2 + * np.mean(distance_xy) + - np.mean(distance_xx) + - np.mean(distance_yy)) return psw_energy_distance - - #NEW: + + # NEW: @staticmethod def default_policy(cate: np.ndarray) -> np.ndarray: """Default policy that assigns treatment if CATE > 0.""" return (cate > 0).astype(int) - #NEW: + # NEW: def policy_risk_score( self, estimate: CausalEstimate, @@ -456,7 +472,8 @@ def policy_risk_score( # Ensure cate_estimate is a 1D array for consistent processing cate_estimate = np.squeeze(cate_estimate) - # Return 0 if CATE estimates are consistently constant (below threshold) + # Return 0 if CATE estimates are consistently constant (below + # threshold) if np.std(cate_estimate) <= sd_threshold: return 0 # This indicates no heterogeneity in treatment effects @@ -464,23 +481,30 @@ def policy_risk_score( policy_treatment = policy(cate_estimate) # Validate that the propensity model is properly fitted - if not hasattr(self.psw_estimator, 'estimator') or not hasattr(self.psw_estimator.estimator, 'propensity_model'): - raise ValueError("Propensity model fitting failed. Please check the setup.") + if not hasattr( + self.psw_estimator, + 'estimator') or not hasattr( + self.psw_estimator.estimator, + 'propensity_model'): + raise ValueError( + "Propensity model fitting failed. Please check the setup.") else: # Calculate propensity scores using the pre-fitted propensity model - propensity_scores = self.psw_estimator.estimator.propensity_model.predict_proba(df) + propensity_scores = self.psw_estimator.estimator.propensity_model.predict_proba( + df) if propensity_scores.ndim == 2: - propensity_scores = propensity_scores[:, 1] # Use second column if 2D array - + # Use second column if 2D array + propensity_scores = propensity_scores[:, 1] + # Clip propensity scores to avoid extreme weights propensity_scores = np.clip(propensity_scores, clip, 1 - clip) treatment_name = self.psw_estimator._treatment_name # Calculate inverse probability weights - weights = np.where(df[treatment_name] == 1, - 1 / propensity_scores, - 1 / (1 - propensity_scores)) + weights = np.where(df[treatment_name] == 1, + 1 / propensity_scores, + 1 / (1 - propensity_scores)) # Prepare RCT subset for analysis rct_df = df.loc[rct_indices].copy() @@ -488,17 +512,24 @@ def policy_risk_score( rct_df['policy_treatment'] = policy_treatment[rct_indices] # Compute policy value using inverse probability weighting - value_policy = ( - (rct_df[outcome_name] * (rct_df[treatment_name] == 1) * (rct_df['policy_treatment'] == 1) * rct_df['weight']).sum() / rct_df['weight'].sum() * (rct_df['policy_treatment'] == 1).mean() + - (rct_df[outcome_name] * (rct_df[treatment_name] == 0) * (rct_df['policy_treatment'] == 0) * rct_df['weight']).sum() / rct_df['weight'].sum() * (rct_df['policy_treatment'] == 0).mean() - ) + value_policy = ((rct_df[outcome_name] * + (rct_df[treatment_name] == 1) + * (rct_df['policy_treatment'] == 1) + * rct_df['weight']).sum() + / rct_df['weight'].sum() + * (rct_df['policy_treatment'] == 1).mean() + + (rct_df[outcome_name] + * (rct_df[treatment_name] == 0) + * (rct_df['policy_treatment'] == 0) + * rct_df['weight']).sum() / + rct_df['weight'].sum() + * (rct_df['policy_treatment'] == 0).mean()) # Compute Policy Risk (1 - policy value) policy_risk = 1 - value_policy return policy_risk - @staticmethod def qini_make_score( estimate: CausalEstimate, df: pd.DataFrame, cate_estimate: np.ndarray @@ -527,8 +558,8 @@ def qini_make_score( qini_score = metrics.qini_score(new_df) return qini_score["model"] - - #NEW + + # NEW @staticmethod def randomNN(ids): """ @@ -547,13 +578,13 @@ def randomNN(ids): # Adjust x to ensure no position i has x[i] == i x = x + (x >= np.arange(m)) return np.array(ids)[x] - - #NEW + + # NEW @staticmethod def estimateConditionalQ(Y, X, Z): """ Estimate Q(Y, Z | X), the numerator of the measure of conditional dependence of Y on Z given X. - + Parameters: Y (array-like): Vector of responses (length n). X (array-like): Matrix of predictors (n by p). @@ -562,7 +593,7 @@ def estimateConditionalQ(Y, X, Z): Returns: float: Estimation of Q(Y, Z | X). """ - + # Ensure X and Z are numpy arrays if not isinstance(X, np.ndarray): X = np.array(X) @@ -571,7 +602,7 @@ def estimateConditionalQ(Y, X, Z): # To turn Z from shape (n,) to (n,1) Z = Z.reshape(-1, 1) - + n = len(Y) W = np.hstack((X, Z)) @@ -582,7 +613,8 @@ def estimateConditionalQ(Y, X, Z): # Handle repeated data repeat_data = np.where(nn_dists_X[:, 1] == 0)[0] - df_X = pd.DataFrame({'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) + df_X = pd.DataFrame( + {'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) df_X['rnn'] = df_X.groupby('group')['id'].transform(Scorer.randomNN) nn_index_X[repeat_data] = df_X['rnn'].values @@ -592,11 +624,12 @@ def estimateConditionalQ(Y, X, Z): if len(ties) > 0: def helper_ties(a): - distances = distance.cdist(X[a].reshape(1, -1), np.delete(X, a, axis=0)).flatten() + distances = distance.cdist(X[a].reshape( + 1, -1), np.delete(X, a, axis=0)).flatten() ids = np.where(distances == distances.min())[0] x = np.random.choice(ids) return x + (x >= a) - + nn_index_X[ties] = [helper_ties(a) for a in ties] # Compute the nearest neighbor of W @@ -605,7 +638,8 @@ def helper_ties(a): nn_index_W = nn_indices_W[:, 1] repeat_data = np.where(nn_dists_W[:, 1] == 0)[0] - df_W = pd.DataFrame({'id': repeat_data, 'group': nn_indices_W[repeat_data, 0]}) + df_W = pd.DataFrame( + {'id': repeat_data, 'group': nn_indices_W[repeat_data, 0]}) df_W['rnn'] = df_W.groupby('group')['id'].transform(Scorer.randomNN) nn_index_W[repeat_data] = df_W['rnn'].values @@ -618,17 +652,17 @@ def helper_ties(a): # Estimate Q R_Y = np.argsort(np.argsort(Y)) # Rank Y with ties method 'max' - Q_n = (np.sum(np.minimum(R_Y, R_Y[nn_index_W])) - - np.sum(np.minimum(R_Y, R_Y[nn_index_X]))) / (n**2) - + Q_n = (np.sum(np.minimum(R_Y, R_Y[nn_index_W])) + - np.sum(np.minimum(R_Y, R_Y[nn_index_X]))) / (n**2) + return Q_n - - #NEW + + # NEW @staticmethod def estimateConditionalS(Y, X): """ Estimate S(Y, X), the denominator of the measure of dependence of Y on Z given X. - + Parameters: Y (array-like): Vector of responses (length n). X (array-like): Matrix of predictors (n by p). @@ -636,44 +670,46 @@ def estimateConditionalS(Y, X): Returns: float: Estimation of S(Y, X). """ - + # Ensure X is a numpy array if not isinstance(X, np.ndarray): X = np.array(X) - + n = len(Y) - + # Compute the nearest neighbor of X nn_X = NearestNeighbors(n_neighbors=3, algorithm='auto').fit(X) nn_dists_X, nn_indices_X = nn_X.kneighbors(X) nn_index_X = nn_indices_X[:, 1] - + # Handle repeated data repeat_data = np.where(nn_dists_X[:, 1] == 0)[0] - df_X = pd.DataFrame({'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) + df_X = pd.DataFrame( + {'id': repeat_data, 'group': nn_indices_X[repeat_data, 0]}) df_X['rnn'] = df_X.groupby('group')['id'].transform(Scorer.randomNN) nn_index_X[repeat_data] = df_X['rnn'].values - + # Nearest neighbors with ties ties = np.where(nn_dists_X[:, 1] == nn_dists_X[:, 2])[0] ties = np.setdiff1d(ties, repeat_data) - + if len(ties) > 0: def helper_ties(a): - distances = distance.cdist(X[a].reshape(1, -1), np.delete(X, a, axis=0)).flatten() + distances = distance.cdist(X[a].reshape( + 1, -1), np.delete(X, a, axis=0)).flatten() ids = np.where(distances == distances.min())[0] x = np.random.choice(ids) return x + (x >= a) - + nn_index_X[ties] = [helper_ties(a) for a in ties] - + # Estimate S R_Y = np.argsort(np.argsort(Y)) # Rank Y with ties method 'max' S_n = np.sum(R_Y - np.minimum(R_Y, R_Y[nn_index_X])) / (n**2) - + return S_n - - #NEW + + # NEW @staticmethod def estimateConditionalT(Y, Z, X): """ @@ -687,7 +723,7 @@ def estimateConditionalT(Y, Z, X): Returns: float: Estimation of T(Y, Z | X). """ - + S = Scorer.estimateConditionalS(Y, X) # Happens only if Y is constant @@ -695,8 +731,8 @@ def estimateConditionalT(Y, Z, X): return 1 else: return Scorer.estimateConditionalQ(Y, X, Z) / S - - #NEW + + # NEW @staticmethod def codec(Y, Z, X=None, na_rm=True): """ @@ -719,15 +755,15 @@ def codec(Y, Z, X=None, na_rm=True): Azadkia, M. and Chatterjee, S. (2019). A simple measure of conditional dependence. https://arxiv.org/pdf/1910.12327.pdf """ - + if X is None: # Ensure inputs are in proper format if not isinstance(Y, np.ndarray): Y = np.array(Y) if not isinstance(Z, np.ndarray): Z = np.array(Z) - #print(f"Shape of Z: {Z.shape}") - #print(f"Z is: {Z}") + # print(f"Shape of Z: {Z.shape}") + # print(f"Z is: {Z}") if len(Y) != Z.shape[0]: raise ValueError("Number of rows of Y and Z should be equal.") @@ -739,7 +775,8 @@ def codec(Y, Z, X=None, na_rm=True): n = len(Y) if n < 2: - raise ValueError("Number of rows with no NAs should be greater than 1.") + raise ValueError( + "Number of rows with no NAs should be greater than 1.") return Scorer.estimateConditionalQ(Y, Z, np.zeros((n, 0))) @@ -750,19 +787,23 @@ def codec(Y, Z, X=None, na_rm=True): X = np.array(X) if not isinstance(Z, np.ndarray): Z = np.array(Z) - if len(Y) != X.shape[0] or len(Y) != Z.shape[0] or X.shape[0] != Z.shape[0]: + if len(Y) != X.shape[0] or len( + Y) != Z.shape[0] or X.shape[0] != Z.shape[0]: raise ValueError("Number of rows of Y, X, and Z should be equal.") - n = len(Y) if n < 2: - raise ValueError("Number of rows with no NAs should be greater than 1.") + raise ValueError( + "Number of rows with no NAs should be greater than 1.") return Scorer.estimateConditionalT(Y, Z, X) - - #NEW + + # NEW @staticmethod - def identify_confounders(df: pd.DataFrame, treatment_col: str, outcome_col: str) -> list: + def identify_confounders( + df: pd.DataFrame, + treatment_col: str, + outcome_col: str) -> list: """ Identify confounders in a DataFrame. @@ -776,11 +817,14 @@ def identify_confounders(df: pd.DataFrame, treatment_col: str, outcome_col: str) """ confounders = [ - col for col in df.columns if col not in [treatment_col, outcome_col, "random", "index"] - ] + col for col in df.columns if col not in [ + treatment_col, + outcome_col, + "random", + "index"]] return confounders - #NEW + # NEW @staticmethod def codec_score(estimate: CausalEstimate, df: pd.DataFrame) -> float: """Calculate the CODEC score for the effect of treatment on y_factual. @@ -793,28 +837,30 @@ def codec_score(estimate: CausalEstimate, df: pd.DataFrame) -> float: float: CODEC score """ est = estimate.estimator - treatment_name = est._treatment_name if isinstance(est._treatment_name, str) else est._treatment_name[0] + treatment_name = est._treatment_name if isinstance( + est._treatment_name, str) else est._treatment_name[0] outcome_name = est._outcome_name - confounders = Scorer.identify_confounders(df, treatment_name, outcome_name) + confounders = Scorer.identify_confounders( + df, treatment_name, outcome_name) ######## cate_est = est.effect(df) - standard_deviations = np.std(cate_est) - + standard_deviations = np.std(cate_est) + df["dy"] = est.effect_tt(df) df["yhat"] = df[est._outcome_name] - df["dy"] - #### have to use corrected y, not y factual to get the estimators contribution in + # have to use corrected y, not y factual to get the estimators + # contribution in Y = df["yhat"] Z = df[treatment_name] X = df[confounders] if standard_deviations < 0.01: return np.inf - - return Scorer.codec(Y, Z, X) + return Scorer.codec(Y, Z, X) @staticmethod def auc_make_score( @@ -849,7 +895,8 @@ def auc_make_score( def real_qini_make_score( estimate: CausalEstimate, df: pd.DataFrame, cate_estimate: np.ndarray ) -> float: - # TODO To calculate the 'real' qini score for synthetic datasets, to be done + # TODO To calculate the 'real' qini score for synthetic datasets, to + # be done # est = estimate.estimator new_df = pd.DataFrame() @@ -863,8 +910,10 @@ def real_qini_make_score( @staticmethod def r_make_score( - estimate: CausalEstimate, df: pd.DataFrame, cate_estimate: np.ndarray, r_scorer - ) -> float: + estimate: CausalEstimate, + df: pd.DataFrame, + cate_estimate: np.ndarray, + r_scorer) -> float: """Calculate r_score. For details refer to Nie and Wager (2017) and Schuler et al. (2018). Adaption from EconML implementation. @@ -931,7 +980,6 @@ def group_ate( return pd.DataFrame(tmp2) - def make_scores( self, estimate: CausalEstimate, @@ -998,42 +1046,50 @@ def make_scores( ] values["policy"] = cate_estimate > 0 values["norm_policy"] = cate_estimate > simple_ate - values["weights"] = self.erupt.weights(df, lambda x: cate_estimate > 0) + values["weights"] = self.erupt.weights( + df, lambda x: cate_estimate > 0) else: pass # TODO: what do we do here if multiple treatments? if "erupt" in metrics_to_report: - erupt_score = self.erupt.score(df, df[outcome_name], cate_estimate > 0) + erupt_score = self.erupt.score( + df, df[outcome_name], cate_estimate > 0) out["erupt"] = erupt_score if "norm_erupt" in metrics_to_report: norm_erupt_score = ( - self.erupt.score(df, df[outcome_name], cate_estimate > simple_ate) - - simple_ate * values["norm_policy"].mean() - ) + self.erupt.score( + df, + df[outcome_name], + cate_estimate > simple_ate) - + simple_ate + * values["norm_policy"].mean()) out["norm_erupt"] = norm_erupt_score if "prob_erupt" in metrics_to_report: treatment_effects = pd.Series(cate_estimate, index=df.index) - treatment_std_devs = pd.Series(cate_estimate.std(), index=df.index) - prob_erupt_score = self.erupt.probabilistic_erupt_score(df, df[outcome_name], treatment_effects, treatment_std_devs) + treatment_std_devs = pd.Series( + cate_estimate.std(), index=df.index) + prob_erupt_score = self.erupt.probabilistic_erupt_score( + df, df[outcome_name], treatment_effects, treatment_std_devs) out["prob_erupt"] = prob_erupt_score - + if "frobenius_norm" in metrics_to_report: out["frobenius_norm"] = self.frobenius_norm_score(estimate, df) if "policy_risk" in metrics_to_report: - out["policy_risk"] = self.policy_risk_score( - estimate=estimate, - df=df, - cate_estimate=cate_estimate, - outcome_name=outcome_name, - policy=None - ) + out["policy_risk"] = self.policy_risk_score( + estimate=estimate, + df=df, + cate_estimate=cate_estimate, + outcome_name=outcome_name, + policy=None + ) if "qini" in metrics_to_report: - out["qini"] = Scorer.qini_make_score(estimate, df, cate_estimate) + out["qini"] = Scorer.qini_make_score( + estimate, df, cate_estimate) if "auc" in metrics_to_report: out["auc"] = Scorer.auc_make_score(estimate, df, cate_estimate) @@ -1044,7 +1100,8 @@ def make_scores( ) # values = values.rename(columns={treatment_name: "treated"}) - assert len(values) == len(df), "Index weirdness when adding columns!" + assert len(values) == len( + df), "Index weirdness when adding columns!" values = values.copy() out["values"] = values @@ -1107,9 +1164,15 @@ def best_score_by_estimator( if "estimator_name" in v and v["estimator_name"] == name ] best[name] = ( - min(est_scores, key=lambda x: x[metric]) - if metric in ["energy_distance", "psw_energy_distance", "frobenius_norm", "codec", "policy_risk"] - else max(est_scores, key=lambda x: x[metric]) - ) + min( + est_scores, + key=lambda x: x[metric]) if metric in [ + "energy_distance", + "psw_energy_distance", + "frobenius_norm", + "codec", + "policy_risk"] else max( + est_scores, + key=lambda x: x[metric])) return best From 0ac800c64f41d1fb6ff7876483b2e2081bf90965 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 15:56:38 +0200 Subject: [PATCH 09/18] Fix all linter issues in scoring.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/scoring.py | 260 +++++++++++++++++++++++++----------------- 1 file changed, 156 insertions(+), 104 deletions(-) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index 01c62301..ddbf72c6 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -91,7 +91,8 @@ def __init__( if problem == "backdoor": print( - "Fitting a Propensity-Weighted scoring estimator to be used in scoring tasks" + "Fitting a Propensity-Weighted scoring estimator " + "to be used in scoring tasks" ) treatment_series = causal_model._data[causal_model._treatment[0]] # this will also fit self.propensity_model, which we'll also use in @@ -122,7 +123,8 @@ def __init__( if not isinstance(treatment_name, str): treatment_name = treatment_name[0] - # No need to call self.erupt.fit() as propensity model is already fitted + # No need to call self.erupt.fit() + # as propensity model is already fitted # self.propensity_model = est.propensity_model self.erupt = ERUPT( treatment_name=treatment_name, @@ -132,15 +134,17 @@ def __init__( ) def ate(self, df: pd.DataFrame) -> tuple: - """Calculate the Average Treatment Effect. Provide naive std estimates in single-treatment cases. + """ + Calculate the Average Treatment Effect. Provide naive std estimates in + single-treatment cases. Args: df (pandas.DataFrame): input dataframe Returns: - tuple: tuple containing the ATE, standard deviation of the estimate (or None if multi-treatment), - and sample size (or None if estimate has more than one dimension) - + tuple: tuple containing the ATE, standard deviation of the estimate + (or None if multi-treatment), and sample size (or None if estimate + has more than one dimension) """ estimate = self.psw_estimator.estimator.effect(df).mean(axis=0) @@ -156,7 +160,8 @@ def ate(self, df: pd.DataFrame) -> tuple: return estimate, None, None def resolve_metric(self, metric: str) -> str: - """Check if supplied metric is supported. If not, default to 'energy_distance'. + """Check if supplied metric is supported. + If not, default to 'energy_distance'. Args: metric (str): evaluation metric @@ -181,16 +186,18 @@ def resolve_metric(self, metric: str) -> str: def resolve_reported_metrics( self, metrics_to_report: Union[List[str], None], scoring_metric: str ) -> List[str]: - """Check if supplied reporting metrics are valid. + """ + Check if supplied reporting metrics are valid. Args: - metrics_to_report (Union[List[str], None]): list of strings specifying the evaluation metrics to compute. - Possible options include 'ate', 'erupt', 'norm_erupt', 'qini', 'auc', - 'energy_distance' and 'psw_energy_distance'. - scoring_metric (str): specified metric + metrics_to_report (Union[List[str], None]): list of strings + specifying the evaluation metrics to compute. Possible options + include 'ate', 'erupt', 'norm_erupt', 'qini', 'auc', + 'energy_distance', and 'psw_energy_distance'. + scoring_metric (str): specified metric. Returns: - List[str]: list of valid metrics + List[str]: list of valid metrics. """ metrics = supported_metrics( @@ -217,16 +224,17 @@ def energy_distance_score( estimate: CausalEstimate, df: pd.DataFrame, ) -> float: - """Calculate energy distance score between treated and controls. - For theoretical details, see Ramos-Carreño and Torrecilla (2023). + """ + Calculate energy distance score between treated and controls. For + theoretical details, see Ramos-Carreño and Torrecilla (2023). Args: - estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate df (pandas.DataFrame): input dataframe Returns: float: energy distance score - """ Y0X, _, split_test_by = Scorer._Y0_X_potential_outcomes(estimate, df) @@ -276,10 +284,12 @@ def frobenius_norm_score( Args: estimate (CausalEstimate): causal estimate to evaluate df (pandas.DataFrame): input dataframe - sd_threshold (float): threshold for standard deviation of CATE estimates + sd_threshold (float): threshold for standard deviation of CATE + estimates Returns: - float: Frobenius norm-based score, or np.inf if calculation is not possible + float: Frobenius norm-based score, or np.inf if calculation is + not possible """ # Attempt to get CATE estimates, handling potential AttributeErrors try: @@ -292,7 +302,7 @@ def frobenius_norm_score( # Check if CATE estimates are consistently constant (below threshold) if np.std(cate_estimates) <= sd_threshold: - return np.inf # Return inf for consistently constant CATE estimates + return np.inf # Return inf for constant CATE estimates # Prepare data for treated and control groups Y0X, treatment_name, split_test_by = self._Y0_X_potential_outcomes( @@ -308,7 +318,8 @@ def frobenius_norm_score( select_cols = estimate.estimator._effect_modifier_names + ["yhat"] # Calculate propensity scores for treated group - YX_1_all_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + propensitymodel = self.psw_estimator.estimator.propensity_model + YX_1_all_psw = propensitymodel.predict_proba( Y0X_1[ self.causal_model.get_effect_modifiers() + self.causal_model.get_common_causes() @@ -317,11 +328,13 @@ def frobenius_norm_score( treatment_series = Y0X_1[treatment_name] YX_1_psw = np.zeros(YX_1_all_psw.shape[0]) for i in treatment_series.unique(): - YX_1_psw[treatment_series == i] = YX_1_all_psw[:, - i][treatment_series == i] + YX_1_psw[treatment_series == i] = ( + YX_1_all_psw[:, i][treatment_series == i] + ) # Calculate propensity scores for control group - YX_0_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + propensitymodel = self.psw_estimator.estimator.propensity_model + YX_0_psw = propensitymodel.predict_proba( Y0X_0[ self.causal_model.get_effect_modifiers() + self.causal_model.get_common_causes() @@ -357,18 +370,23 @@ def psw_energy_distance( normalise_features=False, ) -> float: """ - Calculate propensity score adjusted energy distance score between treated and controls. + Calculate propensity score adjusted energy distance score between + treated and controls. - Features are normalised using the sklearn.preprocessing.QuantileTransformer + Features are normalized using the + `sklearn.preprocessing.QuantileTransformer`. For theoretical details, see Ramos-Carreño and Torrecilla (2023). - @param estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate - @param df (pandas.DataFrame): input dataframe - @param normalise_features (bool): whether to normalise features with QuantileTransformer - - @return float: propensity-score weighted energy distance score + Args: + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate. + df (pandas.DataFrame): input dataframe. + normalise_features (bool): whether to normalize features with + `QuantileTransformer`. + Returns: + float: propensity-score weighted energy distance score. """ Y0X, treatment_name, split_test_by = Scorer._Y0_X_potential_outcomes( @@ -378,7 +396,8 @@ def psw_energy_distance( Y0X_1 = Y0X[Y0X[split_test_by] == 1] Y0X_0 = Y0X[Y0X[split_test_by] == 0] - YX_1_all_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + propensitymodel = self.psw_estimator.estimator.propensity_model + YX_1_all_psw = propensitymodel.predict_proba( Y0X_1[ self.causal_model.get_effect_modifiers() + self.causal_model.get_common_causes() @@ -388,10 +407,12 @@ def psw_energy_distance( YX_1_psw = np.zeros(YX_1_all_psw.shape[0]) for i in treatment_series.unique(): - YX_1_psw[treatment_series == i] = YX_1_all_psw[:, - i][treatment_series == i] + YX_1_psw[treatment_series == i] = ( + YX_1_all_psw[:, i][treatment_series == i] + ) - YX_0_psw = self.psw_estimator.estimator.propensity_model.predict_proba( + propensitymodel = self.psw_estimator.estimator.propensity_model + YX_0_psw = propensitymodel.predict_proba( Y0X_0[ self.causal_model.get_effect_modifiers() + self.causal_model.get_common_causes() @@ -490,8 +511,9 @@ def policy_risk_score( "Propensity model fitting failed. Please check the setup.") else: # Calculate propensity scores using the pre-fitted propensity model - propensity_scores = self.psw_estimator.estimator.propensity_model.predict_proba( - df) + propensity_scores = ( + self.psw_estimator.estimator.propensity_model.predict_proba(df) + ) if propensity_scores.ndim == 2: # Use second column if 2D array propensity_scores = propensity_scores[:, 1] @@ -512,18 +534,21 @@ def policy_risk_score( rct_df['policy_treatment'] = policy_treatment[rct_indices] # Compute policy value using inverse probability weighting - value_policy = ((rct_df[outcome_name] * - (rct_df[treatment_name] == 1) - * (rct_df['policy_treatment'] == 1) - * rct_df['weight']).sum() - / rct_df['weight'].sum() - * (rct_df['policy_treatment'] == 1).mean() - + (rct_df[outcome_name] - * (rct_df[treatment_name] == 0) - * (rct_df['policy_treatment'] == 0) - * rct_df['weight']).sum() / - rct_df['weight'].sum() - * (rct_df['policy_treatment'] == 0).mean()) + value_policy = ( + ( + (rct_df[outcome_name] * (rct_df[treatment_name] == 1) + * (rct_df['policy_treatment'] == 1) + * rct_df['weight']).sum() + / rct_df['weight'].sum() + * (rct_df['policy_treatment'] == 1).mean() + ) + ( + (rct_df[outcome_name] * (rct_df[treatment_name] == 0) + * (rct_df['policy_treatment'] == 0) + * rct_df['weight']).sum() + / rct_df['weight'].sum() + * (rct_df['policy_treatment'] == 0).mean() + ) + ) # Compute Policy Risk (1 - policy value) policy_risk = 1 - value_policy @@ -534,16 +559,18 @@ def policy_risk_score( def qini_make_score( estimate: CausalEstimate, df: pd.DataFrame, cate_estimate: np.ndarray ) -> float: - """Calculate the Qini score, defined as the area between the Qini curves of a model and random. + """ + Calculate the Qini score, defined as the area between the Qini curves + of a model and random. Args: - estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate df (pandas.DataFrame): input dataframe - cate_estimate (np.ndarray): array with cate estimates + cate_estimate (np.ndarray): array with CATE estimates Returns: float: Qini score - """ est = estimate.estimator @@ -569,7 +596,8 @@ def randomNN(ids): ids (array-like): List of indices to sample from. Returns: - numpy.ndarray: Array of sampled indices with no position i having x[i] == i. + numpy.ndarray: Array of sampled indices with + no position i having x[i] == i. """ m = len(ids) @@ -583,7 +611,8 @@ def randomNN(ids): @staticmethod def estimateConditionalQ(Y, X, Z): """ - Estimate Q(Y, Z | X), the numerator of the measure of conditional dependence of Y on Z given X. + Estimate Q(Y, Z | X), the numerator of the measure of + conditional dependence of Y on Z given X. Parameters: Y (array-like): Vector of responses (length n). @@ -661,7 +690,8 @@ def helper_ties(a): @staticmethod def estimateConditionalS(Y, X): """ - Estimate S(Y, X), the denominator of the measure of dependence of Y on Z given X. + Estimate S(Y, X), the denominator of the + measure of dependence of Y on Z given X. Parameters: Y (array-like): Vector of responses (length n). @@ -738,22 +768,27 @@ def codec(Y, Z, X=None, na_rm=True): """ Estimate the conditional dependence coefficient (CODEC). - The conditional dependence coefficient (CODEC) is a measure of the amount of conditional dependence between - a random variable Y and a random vector Z given a random vector X, based on an i.i.d. sample of (Y, Z, X). - The coefficient is asymptotically guaranteed to be between 0 and 1. + The conditional dependence coefficient (CODEC) is a measure of the + amount of conditional dependence between a random variable Y and a + random vector Z given a random vector X, based on an i.i.d. sample of + (Y, Z, X). The coefficient is asymptotically guaranteed to be between + 0 and 1. Parameters: - Y (array-like): Vector of responses (length n). - Z (array-like): Matrix of predictors (n by q). - X (array-like, optional): Matrix of predictors (n by p). Default is None. - na_rm (bool): If True, remove NAs. + Y (array-like): Vector of responses (length n). + Z (array-like): Matrix of predictors (n by q). + X (array-like, optional): Matrix of predictors (n by p). Default + is None. + na_rm (bool): If True, remove NAs. Returns: - float: The conditional dependence coefficient (CODEC) of Y and Z given X. If X is None, this is just a measure of the dependence between Y and Z. + float: The conditional dependence coefficient (CODEC) of Y and Z + given X. If X is None, this is just a measure of the dependence + between Y and Z. References: - Azadkia, M. and Chatterjee, S. (2019). A simple measure of conditional dependence. - https://arxiv.org/pdf/1910.12327.pdf + Azadkia, M. and Chatterjee, S. (2019). A simple measure of + conditional dependence. https://arxiv.org/pdf/1910.12327.pdf """ if X is None: @@ -869,7 +904,8 @@ def auc_make_score( """Calculate the area under the uplift curve. Args: - estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate df (pandas.DataFrame): input dataframe cate_estimate (np.ndarray): array with cate estimates @@ -914,18 +950,21 @@ def r_make_score( df: pd.DataFrame, cate_estimate: np.ndarray, r_scorer) -> float: - """Calculate r_score. - For details refer to Nie and Wager (2017) and Schuler et al. (2018). Adaption from EconML implementation. + """ + Calculate r_score. + + For details, refer to Nie and Wager (2017) and Schuler et al. (2018). + Adapted from the EconML implementation. Args: - estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate df (pandas.DataFrame): input dataframe - cate_estimate (np.ndarray): array with cate estimates + cate_estimate (np.ndarray): array with CATE estimates r_scorer: callable object used to compute the R-score Returns: float: r_score - """ # TODO @@ -957,16 +996,18 @@ def naive_ate(treatment: pd.Series, outcome: pd.Series): def group_ate( self, df: pd.DataFrame, policy: Union[pd.DataFrame, np.ndarray] ) -> pd.DataFrame: - """Compute the average treatment effect (ATE) for different groups specified by a policy. + """ + Compute the average treatment effect (ATE) for different groups + specified by a policy. Args: - df (pandas.DataFrame): input dataframe, should contain columns for the treatment, outcome, and policy - policy (Union[pd.DataFrame, np.ndarray]): policy column in df or an array of the policy values, - used to group the data + df (pandas.DataFrame): input dataframe, should contain columns + for the treatment, outcome, and policy. + policy (Union[pd.DataFrame, np.ndarray]): policy column in df or + an array of the policy values, used to group the data. Returns: - pandas.DataFrame: ATE, std, and size per policy - + pandas.DataFrame: ATE, std, and size per policy. """ tmp = {"all": self.ate(df)} @@ -987,20 +1028,26 @@ def make_scores( metrics_to_report: List[str], r_scorer=None, ) -> dict: - """Calculate various performance metrics for a given causal estimate using a given DataFrame. + """ + Calculate various performance metrics for a given causal estimate using + a given DataFrame. Args: - estimate (dowhy.causal_estimator.CausalEstimate): causal estimate to evaluate - df (pandas.DataFrame): input dataframe - metrics_to_report (List[str]): list of strings specifying the evaluation metrics to compute. - Possible options include 'ate', 'erupt', 'norm_erupt', 'qini', 'auc', - 'energy_distance' and 'psw_energy_distance'. - r_scorer (Optional): callable object used to compute the R-score, default is None + estimate (dowhy.causal_estimator.CausalEstimate): causal estimate + to evaluate. + df (pandas.DataFrame): input dataframe. + metrics_to_report (List[str]): list of strings specifying the + evaluation metrics to compute. Possible options include 'ate', + 'erupt', 'norm_erupt', 'qini', 'auc', 'energy_distance' and + 'psw_energy_distance'. + r_scorer (Optional): callable object used to compute the R-score, + default is None. Returns: - dict: dictionary containing the evaluation metrics specified in metrics_to_report. - The values key in the dictionary contains the input DataFrame with additional columns for - the propensity scores, the policy, the normalized policy, and the weights, if applicable. + dict: dictionary containing the evaluation metrics specified in + metrics_to_report. The values key in the dictionary contains the + input DataFrame with additional columns for the propensity scores, + the policy, the normalized policy, and the weights, if applicable. """ out = dict() @@ -1031,23 +1078,24 @@ def make_scores( if self.problem == "backdoor": values = df[[treatment_name, outcome_name]] simple_ate = self.ate(df)[0] + if isinstance(simple_ate, float): # simple_ate = simple_ate[0] # .reset_index(drop=True) - values[ - "p" - ] = self.psw_estimator.estimator.propensity_model.predict_proba( - df[ - self.causal_model.get_effect_modifiers() - + self.causal_model.get_common_causes() - ] - )[ - :, 1 - ] + propensitymodel = self.psw_estimator.estimator.propensity_model + values["p"] = ( + propensitymodel.predict_proba( + df[ + self.causal_model.get_effect_modifiers() + + self.causal_model.get_common_causes() + ] + )[:, 1] + ) values["policy"] = cate_estimate > 0 values["norm_policy"] = cate_estimate > simple_ate values["weights"] = self.erupt.weights( - df, lambda x: cate_estimate > 0) + df, lambda x: cate_estimate > 0 + ) else: pass # TODO: what do we do here if multiple treatments? @@ -1062,9 +1110,9 @@ def make_scores( self.erupt.score( df, df[outcome_name], - cate_estimate > simple_ate) - - simple_ate - * values["norm_policy"].mean()) + cate_estimate > simple_ate + ) - simple_ate * values["norm_policy"].mean() + ) out["norm_erupt"] = norm_erupt_score if "prob_erupt" in metrics_to_report: @@ -1072,7 +1120,10 @@ def make_scores( treatment_std_devs = pd.Series( cate_estimate.std(), index=df.index) prob_erupt_score = self.erupt.probabilistic_erupt_score( - df, df[outcome_name], treatment_effects, treatment_std_devs) + df, df[outcome_name], + treatment_effects, + treatment_std_devs + ) out["prob_erupt"] = prob_erupt_score if "frobenius_norm" in metrics_to_report: @@ -1142,7 +1193,8 @@ def best_score_by_estimator( for k, v in scores.items(): if "estimator_name" not in v: raise ValueError( - f"Malformed scores dict, 'estimator_name' field missing in {k}, {v}" + f"Malformed scores dict, 'estimator_name' field missing " + f"in{k}, {v}" ) estimator_names = sorted( From 67eeda5a7ea7fc7af7dc3af39e6107d9d38c8b67 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 16:13:17 +0200 Subject: [PATCH 10/18] Fix all linter issues in erupt.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/erupt.py | 44 +++++++++++++++++++++++++------------------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/causaltune/erupt.py b/causaltune/erupt.py index 30483748..d7b8fd30 100644 --- a/causaltune/erupt.py +++ b/causaltune/erupt.py @@ -4,8 +4,6 @@ import pandas as pd import numpy as np -from scipy import stats - # implementation of https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3111957 # we assume treatment takes integer values from 0 to n @@ -90,15 +88,16 @@ def weights( else: weight[weight > 1 / self.clip] = 1 / self.clip - # and just for paranoia's sake let's normalize, though it shouldn't matter for big samples + # and just for paranoia's sake let's normalize, though it shouldn't + # matter for big samples weight *= len(df) / sum(weight) assert not np.isnan(weight.sum()), "NaNs in ERUPT weights" return pd.Series(index=df.index, data=weight) - - #NEW: + # NEW: + def probabilistic_erupt_score( self, df: pd.DataFrame, @@ -108,22 +107,27 @@ def probabilistic_erupt_score( iterations: int = 1000 ) -> float: """ - Calculate the Probabilistic ERUPT (Expected Response Under Proposed Treatments) score. + Calculate the Probabilistic ERUPT (Expected Response Under Proposed + Treatments) score. - This method uses Monte Carlo simulation to estimate the expected outcome under - a probabilistic treatment policy, accounting for uncertainty in treatment effects. - It balances potential improvements against estimation uncertainty and treatment rates. + This method uses Monte Carlo simulation to estimate the expected + outcome under a probabilistic treatment policy, accounting for + uncertainty in treatment effects. It balances potential improvements + against estimation uncertainty and treatment rates. Args: - df (pd.DataFrame): The input dataframe containing treatment information. + df (pd.DataFrame): The input dataframe containing treatment + information. outcome (pd.Series): The observed outcomes for each unit. - treatment_effects (pd.Series): Estimated treatment effects for each unit. - treatment_std_devs (pd.Series): Standard deviations of treatment effects. + treatment_effects (pd.Series): Estimated treatment effects for + each unit. + treatment_std_devs (pd.Series): Standard deviations of treatment + effects. iterations (int): Number of Monte Carlo iterations (default: 1000). Returns: - float: The Probabilistic ERUPT score, representing the relative improvement - over the baseline outcome, adjusted for uncertainty. + float: The Probabilistic ERUPT score, representing the relative + improvement over the baseline outcome, adjusted for uncertainty. """ # Calculate the baseline outcome (mean outcome for untreated units) baseline_outcome = outcome[df[self.treatment_name] == 0].mean() @@ -140,13 +144,14 @@ def probabilistic_erupt_score( ) # Define policy: treat if sampled effect is positive - # Note: A more conservative policy could use: sampled_effects > 2 * treatment_std_devs + # Note: A more conservative policy could use: sampled_effects > 2 * + # treatment_std_devs policy = (sampled_effects > 0).astype(int) # Calculate expected outcome under this policy expected_outcome = ( - baseline_outcome + - (policy * sampled_effects).mean() + baseline_outcome + + (policy * sampled_effects).mean() ) policy_values.append(expected_outcome) @@ -159,8 +164,9 @@ def probabilistic_erupt_score( # Placeholder for potential treatment rate penalty treatment_penalty = 0 - # Calculate score: mean value minus 2 standard errors, adjusted for treatment penalty - score = (mean_value - 2*se_value) * (1 - treatment_penalty) + # Calculate score: mean value minus 2 standard errors, adjusted for + # treatment penalty + score = (mean_value - 2 * se_value) * (1 - treatment_penalty) # Calculate relative improvement over baseline improvement = (score - baseline_outcome) / baseline_outcome From b1670c70a2b9ae9454817d1d78cffe4fcb38a561 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 16:17:05 +0200 Subject: [PATCH 11/18] Fix all linter issues except linewidth in optimiser.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/optimiser.py | 62 +++++++++++++++++++++++++++++++---------- 1 file changed, 48 insertions(+), 14 deletions(-) diff --git a/causaltune/optimiser.py b/causaltune/optimiser.py index 5befc865..5f1d723a 100644 --- a/causaltune/optimiser.py +++ b/causaltune/optimiser.py @@ -181,9 +181,9 @@ def __init__( resources_per_trial if resources_per_trial is not None else {"cpu": 0.5} ) self._settings["try_init_configs"] = try_init_configs - self._settings["include_experimental_estimators"] = ( - include_experimental_estimators - ) + self._settings[ + "include_experimental_estimators" + ] = include_experimental_estimators # params for FLAML on component models: self._settings["component_models"] = {} @@ -497,7 +497,14 @@ def fit( ), mode=( "min" - if self.metric in ["energy_distance", "psw_energy_distance", "frobenius_norm","codec","policy_risk"] + if self.metric + in [ + "energy_distance", + "psw_energy_distance", + "frobenius_norm", + "codec", + "policy_risk", + ] else "max" ), low_cost_partial_config={}, @@ -546,25 +553,52 @@ def _tune_with_config(self, config: dict) -> dict: # Initialize best_score if this is the first estimator for this name if est_name not in self._best_estimators: - self._best_estimators[est_name] = (np.inf if self.metric in ["energy_distance", - "psw_energy_distance", - "frobenius_norm", - "codec", - "policy_risk"] else -np.inf, None) + self._best_estimators[est_name] = ( + np.inf + if self.metric + in [ + "energy_distance", + "psw_energy_distance", + "frobenius_norm", + "codec", + "policy_risk", + ] + else -np.inf, + None, + ) best_score = self._best_estimators[est_name][0] # Determine if the current estimator performs better, handling inf values - if self.metric in ["energy_distance", "psw_energy_distance", "frobenius_norm", "codec","policy_risk"]: - is_better = (np.isfinite(current_score) and current_score < best_score) or (np.isinf(best_score) and np.isfinite(current_score)) + if self.metric in [ + "energy_distance", + "psw_energy_distance", + "frobenius_norm", + "codec", + "policy_risk", + ]: + is_better = ( + np.isfinite(current_score) and current_score < best_score + ) or (np.isinf(best_score) and np.isfinite(current_score)) else: - is_better = (np.isfinite(current_score) and current_score > best_score) or (np.isinf(best_score) and np.isfinite(current_score)) + is_better = ( + np.isfinite(current_score) and current_score > best_score + ) or (np.isinf(best_score) and np.isfinite(current_score)) # Store the estimator if we're storing all, if it's better, or if it's the first valid (non-inf) estimator - if self._settings["store_all"] or is_better or (self._best_estimators[est_name][1] is None and np.isfinite(current_score)): + if ( + self._settings["store_all"] + or is_better + or ( + self._best_estimators[est_name][1] is None + and np.isfinite(current_score) + ) + ): self._best_estimators[est_name] = ( current_score, - estimates["estimator"] if self._settings["store_all"] else estimates.pop("estimator") + estimates["estimator"] + if self._settings["store_all"] + else estimates.pop("estimator"), ) return estimates From d716e9104c0dc4e4ad9bbd9cdae565fc33cfa933 Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Tue, 13 Aug 2024 16:18:02 +0200 Subject: [PATCH 12/18] Fix all linter issues except linewidth in datasets.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/datasets.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/causaltune/datasets.py b/causaltune/datasets.py index 0373a780..fb2aad86 100644 --- a/causaltune/datasets.py +++ b/causaltune/datasets.py @@ -403,7 +403,8 @@ def generate_synthetic_data( err = np.random.randn(n_samples) * 0.05 if noisy_outcomes else 0 # nonlinear dependence of Y on X: - mu = lambda X: X[:, 0] * X[:, 1] + X[:, 2] + X[:, 3] * X[:, 4] # noqa E731 + def mu(X): + return X[:, 0] * X[:, 1] + X[:, 2] + X[:, 3] * X[:, 4] # noqa E731 Y_base = mu(X) + err Y = tau * T + Y_base @@ -427,7 +428,6 @@ def generate_synthetic_data( return data - def generate_linear_synthetic_data( n_samples: int = 100, n_covariates: int = 5, @@ -498,7 +498,8 @@ def generate_linear_synthetic_data( err = np.random.randn(n_samples) * 0.05 if noisy_outcomes else 0 # linear dependence of Y on X: - mu = lambda X: X @ np.random.uniform(0.1, 0.3, size=n_covariates) # noqa E731 + def mu(X): + return X @ np.random.uniform(0.1, 0.3, size=n_covariates) # noqa E731 Y_base = mu(X) + err Y = tau * T + Y_base @@ -522,9 +523,6 @@ def generate_linear_synthetic_data( return data - - - def generate_synth_data_with_categories( n_samples=10000, n_x=10, true_effect: Union[float, int, Callable] = 0.1 ) -> CausalityDataset: From 365d671257cc1b0aa927d04fe0e4b34a3c0acf7d Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Thu, 15 Aug 2024 14:55:21 +0200 Subject: [PATCH 13/18] Fix linewidth >120 in datasets.py Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/datasets.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/causaltune/datasets.py b/causaltune/datasets.py index fb2aad86..a8b17f8d 100644 --- a/causaltune/datasets.py +++ b/causaltune/datasets.py @@ -445,9 +445,11 @@ def generate_linear_synthetic_data( n_samples (int, optional): number of independent samples. Defaults to 100. n_covariates (int, optional): number of covariates. Defaults to 5. covariance (Union[str, np.ndarray], optional): covariance matrix of covariates. can be "isotropic", - "anisotropic" or user-supplied. Defaults to "isotropic". - confounding (bool, optional): whether or not values of covariates affect treatment effect. Defaults to True. - linear_confounder (bool, optional): whether to use a linear confounder for treatment assignment. Defaults to False. + "anisotropic" or user-supplied. Defaults to "isotropic". + confounding (bool, optional): whether or not values of covariates affect treatment effect. + Defaults to True. + linear_confounder (bool, optional): whether to use a linear confounder for treatment assignment. + Defaults to False. noisy_outcomes (bool, optional): additive noise in the outcomes. Defaults to False. add_instrument (bool, optional): include instrumental variable (yes/no). Defaults to False effect_size (Union[int, None]): if provided, constant effect size (ATE). if None, generate CATE. From 037af9610b1505110b63c13d9a0ea6e013baa1aa Mon Sep 17 00:00:00 2001 From: 1andrin <115493865+1andrin@users.noreply.github.com> Date: Thu, 15 Aug 2024 15:08:43 +0200 Subject: [PATCH 14/18] Fix whitespaces Signed-off-by: 1andrin <115493865+1andrin@users.noreply.github.com> --- causaltune/datasets.py | 70 +++++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 21 deletions(-) diff --git a/causaltune/datasets.py b/causaltune/datasets.py index a8b17f8d..f4f1406d 100644 --- a/causaltune/datasets.py +++ b/causaltune/datasets.py @@ -12,8 +12,10 @@ def linear_multi_dataset( - n_points=10000, impact=None, include_propensity=False, include_control=False -) -> CausalityDataset: + n_points=10000, + impact=None, + include_propensity=False, + include_control=False) -> CausalityDataset: if impact is None: impact = {0: 0.0, 1: 2.0, 2: 1.0} df = pd.DataFrame( @@ -78,9 +80,8 @@ def nhefs() -> CausalityDataset: df = df.loc[~missing] df = df[covariates + ["qsmk"] + ["wt82_71"]] - df.rename( - columns={c: "x" + str(i + 1) for i, c in enumerate(covariates)}, inplace=True - ) + df.rename(columns={c: "x" + str(i + 1) + for i, c in enumerate(covariates)}, inplace=True) return CausalityDataset(df, treatment="qsmk", outcomes=["wt82_71"]) @@ -171,7 +172,8 @@ def amazon_reviews(rating="pos") -> CausalityDataset: gdown.download(url, "amazon_" + rating + ".csv", fuzzy=True) df = pd.read_csv("amazon_" + rating + ".csv") df.drop(df.columns[[2, 3, 4]], axis=1, inplace=True) - df.columns = ["treatment", "y_factual"] + ["x" + str(i) for i in range(1, 301)] + df.columns = ["treatment", "y_factual"] + \ + ["x" + str(i) for i in range(1, 301)] return CausalityDataset(df, "treatment", ["y_factual"]) else: print( @@ -224,10 +226,14 @@ def synth_ihdp(return_df=False) -> CausalityDataset: data.columns = col # drop the columns we don't care about ignore_patterns = ["y_cfactual", "mu"] - ignore_cols = [c for c in data.columns if any([s in c for s in ignore_patterns])] + ignore_cols = [c for c in data.columns if any( + [s in c for s in ignore_patterns])] data = data.drop(columns=ignore_cols) - return CausalityDataset(data, "treatment", ["y_factual"]) if not return_df else data + return CausalityDataset( + data, + "treatment", + ["y_factual"]) if not return_df else data def synth_acic(condition=1) -> CausalityDataset: @@ -410,11 +416,18 @@ def mu(X): Y = tau * T + Y_base features = [f"X{i+1}" for i in range(n_covariates)] - df = pd.DataFrame( - np.array([*X.T, T, Y, tau, p, Y_base]).T, - columns=features - + ["treatment", "outcome", "true_effect", "propensity", "base_outcome"], - ) + df = pd.DataFrame(np.array([*X.T, + T, + Y, + tau, + p, + Y_base]).T, + columns=features + ["treatment", + "outcome", + "true_effect", + "propensity", + "base_outcome"], + ) data = CausalityDataset( data=df, treatment="treatment", @@ -448,7 +461,7 @@ def generate_linear_synthetic_data( "anisotropic" or user-supplied. Defaults to "isotropic". confounding (bool, optional): whether or not values of covariates affect treatment effect. Defaults to True. - linear_confounder (bool, optional): whether to use a linear confounder for treatment assignment. + linear_confounder (bool, optional): whether to use a linear confounder for treatment assignment. Defaults to False. noisy_outcomes (bool, optional): additive noise in the outcomes. Defaults to False. add_instrument (bool, optional): include instrumental variable (yes/no). Defaults to False @@ -507,11 +520,18 @@ def mu(X): Y = tau * T + Y_base features = [f"X{i+1}" for i in range(n_covariates)] - df = pd.DataFrame( - np.array([*X.T, T, Y, tau, p, Y_base]).T, - columns=features - + ["treatment", "outcome", "true_effect", "propensity", "base_outcome"], - ) + df = pd.DataFrame(np.array([*X.T, + T, + Y, + tau, + p, + Y_base]).T, + columns=features + ["treatment", + "outcome", + "true_effect", + "propensity", + "base_outcome"], + ) data = CausalityDataset( data=df, treatment="treatment", @@ -621,8 +641,16 @@ def generate_non_random_dataset(num_samples=1000): ) treatment = np.random.binomial(1, propensity) outcome = ( - 0.2 * treatment + 0.5 * x1 - 0.2 * x2 + np.random.normal(0, 1, num_samples) - ) + 0.2 + * treatment + + 0.5 + * x1 + - 0.2 + * x2 + + np.random.normal( + 0, + 1, + num_samples)) dataset = { "T": treatment, From f421807a0d057640c4f00c39b78a9788dae0c614 Mon Sep 17 00:00:00 2001 From: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> Date: Thu, 29 Aug 2024 20:26:01 +0100 Subject: [PATCH 15/18] Update test_sklearn_propensity_model.py Signed-off-by: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> --- tests/causaltune/test_sklearn_propensity_model.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/tests/causaltune/test_sklearn_propensity_model.py b/tests/causaltune/test_sklearn_propensity_model.py index 7a1ce204..dc0f5cf6 100644 --- a/tests/causaltune/test_sklearn_propensity_model.py +++ b/tests/causaltune/test_sklearn_propensity_model.py @@ -47,16 +47,6 @@ def test_sklearn_propensity_model(self): ct.effect(data.data) ct.score_dataset(data.data, "test") - # now let's test Shapley values calculation - for est_name, scores in ct.scores.items(): - # Dummy model doesn't support Shapley values - # Orthoforest shapley calc is VERY slow - if "Dummy" not in est_name and "Ortho" not in est_name: - print("Calculating Shapley values for", est_name) - shap_values(scores["estimator"], data.data[:10]) - - print(f"Best estimator: {ct.best_estimator}") - def test_sklearn_propensity_model_multivalue(self): data = linear_multi_dataset(5000) cfg = SimpleParamService( From 7270d9474937838b7b87c17220d2447fff9bc6ee Mon Sep 17 00:00:00 2001 From: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> Date: Thu, 29 Aug 2024 20:45:48 +0100 Subject: [PATCH 16/18] Update scoring.py Signed-off-by: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> --- causaltune/scoring.py | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index ddbf72c6..d71b13c3 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -512,7 +512,18 @@ def policy_risk_score( else: # Calculate propensity scores using the pre-fitted propensity model propensity_scores = ( - self.psw_estimator.estimator.propensity_model.predict_proba(df) + self.psw_estimator.estimator.propensity_model.predict_proba( + df.drop( + [ + 'index', + 'variant', + 'Y', + 'dy', + 'yhat' + ], + axis=1 + ) + ) ) if propensity_scores.ndim == 2: # Use second column if 2D array @@ -1130,13 +1141,16 @@ def make_scores( out["frobenius_norm"] = self.frobenius_norm_score(estimate, df) if "policy_risk" in metrics_to_report: - out["policy_risk"] = self.policy_risk_score( - estimate=estimate, - df=df, - cate_estimate=cate_estimate, - outcome_name=outcome_name, - policy=None - ) + try: + out["policy_risk"] = self.policy_risk_score( + estimate=estimate, + df=df, + cate_estimate=cate_estimate, + outcome_name=outcome_name, + policy=None + ) + except: + pass if "qini" in metrics_to_report: out["qini"] = Scorer.qini_make_score( From 8f2ed0e0e7d5e47abae6d9dd2844a89efeeda630 Mon Sep 17 00:00:00 2001 From: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> Date: Thu, 29 Aug 2024 20:48:21 +0100 Subject: [PATCH 17/18] Update scoring.py Signed-off-by: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> --- causaltune/scoring.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index d71b13c3..76d1f769 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -1149,7 +1149,7 @@ def make_scores( outcome_name=outcome_name, policy=None ) - except: + except Exception as e: pass if "qini" in metrics_to_report: From ff7f5f7a857ec2de2cbe85cddce27b3820e992ee Mon Sep 17 00:00:00 2001 From: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> Date: Thu, 29 Aug 2024 20:50:30 +0100 Subject: [PATCH 18/18] Update scoring.py Signed-off-by: AlxdrPolyakov <122611538+AlxdrPolyakov@users.noreply.github.com> --- causaltune/scoring.py | 1 + 1 file changed, 1 insertion(+) diff --git a/causaltune/scoring.py b/causaltune/scoring.py index 76d1f769..70ec07f8 100644 --- a/causaltune/scoring.py +++ b/causaltune/scoring.py @@ -1150,6 +1150,7 @@ def make_scores( policy=None ) except Exception as e: + print(e) pass if "qini" in metrics_to_report: