diff --git a/causalml/dataset/__init__.py b/causalml/dataset/__init__.py index f4678b11..e664d0b4 100644 --- a/causalml/dataset/__init__.py +++ b/causalml/dataset/__init__.py @@ -14,3 +14,5 @@ from .synthetic import distr_plot_single_sim from .synthetic import scatter_plot_single_sim from .synthetic import get_synthetic_auuc + +from .mab_simulation import make_mab_data diff --git a/causalml/dataset/mab_simulation.py b/causalml/dataset/mab_simulation.py new file mode 100644 index 00000000..32b3750f --- /dev/null +++ b/causalml/dataset/mab_simulation.py @@ -0,0 +1,561 @@ +import numpy as np +import pandas as pd +from typing import List, Dict, Tuple, Optional, Union +from scipy.special import expit +from scipy.interpolate import UnivariateSpline +import random +from scipy.optimize import fsolve +from scipy.special import logit + +# ------ Define a list of functions for feature transformation +def _f_linear(x): + """Linear transformation (identical transformation).""" + return np.array(x) + +def _f_quadratic(x): + """Quadratic transformation.""" + return np.array(x) * np.array(x) + +def _f_cubic(x): + """Cubic transformation.""" + return np.array(x) * np.array(x) * np.array(x) + +def _f_relu(x): + """ReLU transformation.""" + x = np.array(x) + return np.maximum(x, 0) + +def _f_sin(x): + """Sine transformation.""" + return np.sin(np.array(x) * np.pi) + +def _f_cos(x): + """Cosine transformation.""" + return np.cos(np.array(x) * np.pi) + +def _standardize(x): + """Standardize a vector to be mean 0 and std 1.""" + return (np.array(x) - np.mean(x)) / np.std(x) + +def _fixed_transformation(fs, x, f_index=0): + """Transform and standardize a vector by a transformation function. + + If the given index is within the function list f_index < len(fs), then use fs[f_index] as the transformation + function. Otherwise, randomly choose a function from the function list. + + Parameters + ---------- + fs : list + A collection of functions for transformation. + x : list + Feature values to be transformed. + f_index : int, optional + The function index to be used to select a transformation function. + """ + try: + y = fs[f_index](x) + except IndexError: + y = fs[np.random.choice(len(fs), 1)[0]](x) + y = _standardize(y) + return y + +def _random_transformation(fs, x): + """Transform and standardize a vector by a function randomly chosen from the function collection. + + Parameters + ---------- + fs : list + A collection of functions for transformation. + x : list + Feature values to be transformed. + """ + fi = np.random.choice(range(len(fs)), 1) + y = fs[fi[0]](x) + y = _standardize(y) + return y + +def _softmax(z, p, xb): + sm_arr = expit(z + np.array(xb)) + res = p - np.mean(sm_arr) + return res + +def make_mab_data( + n_samples: int = 10000, + n_arms: int = 4, + n_features: int = 10, + n_informative: int = 5, + n_redundant: int = 0, + n_repeated: int = 0, + arm_effects: Dict[str, float] = None, + positive_class_proportion: float = 0.1, + random_seed: int = 20200101, + feature_association_list: List[str] = ["linear", "quadratic", "cubic", "relu", "sin", "cos"], + random_select_association: bool = True, + error_std: float = 0.05, + n_arm_features: Dict[str, int] = None, + n_mixed_features: Dict[str, int] = None, + custom_coef_arm: bool = False, + coef_arm_dict: Dict[str, List[float]] = None, + custom_coef_informative: bool = False, + coef_informative_list: List[float] = None +) -> Tuple[pd.DataFrame, List[str]]: + """Generate synthetic data for multi-armed bandit experiments. + + This function generates data that can be used directly with both classical and contextual MAB algorithms. + For classical MAB, only the 'arm' and 'reward' columns are needed. + For contextual MAB, the feature columns are also used. + + Parameters + ---------- + n_samples : int, optional (default=10000) + Number of samples to generate. + n_arms : int, optional (default=4) + Number of arms/treatments. + n_features : int, optional (default=10) + Total number of features. + n_informative : int, optional (default=5) + Number of informative features. + n_redundant : int, optional (default=0) + Number of redundant features. + n_repeated : int, optional (default=0) + Number of repeated features. + arm_effects : dict, optional (default=None) + Dictionary of arm effects. If None, random effects will be generated. + positive_class_proportion : float, optional (default=0.1) + Proportion of positive outcomes in the control group. + random_seed : int, optional (default=20200101) + Random seed for reproducibility. + feature_association_list : list, optional (default=["linear", "quadratic", "cubic", "relu", "sin", "cos"]) + List of feature transformation functions to use. + random_select_association : bool, optional (default=True) + Whether to randomly select feature associations. + error_std : float, optional (default=0.05) + Standard deviation of the error term. + n_arm_features : dict, optional (default=None) + Dictionary specifying number of arm-specific features for each arm. If None, defaults to 2 features per arm. + n_mixed_features : dict, optional (default=None) + Dictionary specifying number of mixed features for each arm. If None, defaults to 1 feature per arm. + custom_coef_arm : bool, optional (default=False) + Whether to use custom coefficients for arm-specific features. + coef_arm_dict : dict, optional (default=None) + Dictionary of custom coefficients for arm-specific features. + custom_coef_informative : bool, optional (default=False) + Whether to use custom coefficients for informative features. + coef_informative_list : list, optional (default=None) + List of custom coefficients for informative features. + + Returns + ------- + df : pd.DataFrame + Generated dataset with the following columns: + - arm: The arm/treatment assigned to each sample + - reward: The binary reward (0 or 1) for each sample + - reward_prob: The probability of reward for each sample + - feature_*: Generated features (informative, redundant, repeated, and irrelevant) + - feature_*_transformed: Transformed versions of informative features + x_name : list + List of feature names + """ + # Create arm names + arm_names = [f"arm_{i}" for i in range(n_arms)] + + # Set default arm effects if not provided + if arm_effects is None: + arm_effects = {arm: np.random.uniform(-0.1, 0.1) for arm in arm_names} + + # Set default arm-specific features if not provided + if n_arm_features is None: + n_arm_features = {arm: 2 for arm in arm_names[1:]} + + # Set default mixed features if not provided + if n_mixed_features is None: + n_mixed_features = {arm: 1 for arm in arm_names[1:]} + + # Set means for each experiment group + mean_dict = {} + mean_dict[arm_names[0]] = positive_class_proportion + for arm in arm_names[1:]: + mean_dict[arm] = positive_class_proportion + arm_effects[arm] + + df = pd.DataFrame() + np.random.seed(seed=random_seed) + + feature_association_pattern_dict = { + "linear": _f_linear, + "quadratic": _f_quadratic, + "cubic": _f_cubic, + "relu": _f_relu, + "sin": _f_sin, + "cos": _f_cos, + } + f_list = [feature_association_pattern_dict[fi] for fi in feature_association_list] + + # generate treatment assignments + treatment_list = [] + for arm in arm_names: + treatment_list += [arm] * n_samples + treatment_list = np.random.permutation(treatment_list) + df["arm"] = treatment_list + + x_name = [] + x_informative_name = [] + x_informative_transformed = [] + + # informative features + for xi in range(n_informative): + x = np.random.normal(0, 1, df.shape[0]) + x_name_i = f"feature_{len(x_name)+1}_informative" + x_name.append(x_name_i) + x_informative_name.append(x_name_i) + df[x_name_i] = x + x_name_i = x_name_i + "_transformed" + df[x_name_i] = _fixed_transformation(f_list, x, xi) + x_informative_transformed.append(x_name_i) + + # redundant features + for xi in range(n_redundant): + nx = np.random.choice(n_informative, size=1, replace=False)[0] + 1 + bx = np.random.normal(0, 1, size=nx) + fx = np.random.choice(n_informative, size=nx, replace=False, p=None) + x_name_i = f"feature_{len(x_name)+1}_redundant_linear" + for xxi in range(nx): + x_name_i += f"_x{fx[xxi]+1}" + x_name.append(x_name_i) + x = np.zeros(df.shape[0]) + for xxi in range(nx): + x += bx[xxi] * df[x_name[fx[xxi]]] + x = _standardize(x) + df[x_name_i] = x + + # repeated features + for xi in range(n_repeated): + fx = np.random.choice(n_informative, size=1, replace=False, p=None) + x_name_i = f"feature_{len(x_name)+1}_repeated_x{fx[0]+1}" + x_name.append(x_name_i) + df[x_name_i] = df[x_name[fx[0]]] + + # irrelevant features + for xi in range(n_features - n_informative - n_redundant - n_repeated): + x_name_i = f"feature_{len(x_name)+1}_irrelevant" + x_name.append(x_name_i) + df[x_name_i] = np.random.normal(0, 1, df.shape[0]) + + # arm-specific features + x_arm_transformed_dict = {arm: [] for arm in arm_names} + for arm in arm_names: + if arm in n_arm_features and n_arm_features[arm] > 0: + for ci in range(n_arm_features[arm]): + x_name_i = f"feature_{arm}_{ci}" + x_name.append(x_name_i) + df[x_name_i] = np.random.normal(0, 1, df.shape[0]) + x_arm_transformed_dict[arm].append(x_name_i) + + # mixed informative and arm-specific features + for arm in arm_names: + if arm in n_mixed_features and n_mixed_features[arm] > 0: + for xi in range(n_mixed_features[arm]): + x_name_i = f"feature_{len(x_name)+1}_mix" + x_name.append(x_name_i) + p_weight = np.random.uniform(0, 1) + df[x_name_i] = ( + p_weight * df[np.random.choice(x_informative_name)] + + (1 - p_weight) * df[np.random.choice(x_arm_transformed_dict[arm])] + ) + + # baseline reward probability + coef_classify = [] + for ci in range(n_informative): + rcoef = [0] + while np.abs(rcoef) < 0.1: + if custom_coef_informative and coef_informative_list is not None: + rcoef = coef_informative_list[ci] * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_informative) + else: + rcoef = 0.5 * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_informative) + coef_classify.append(rcoef[0]) + x_classify = df[x_informative_transformed].values + p1 = positive_class_proportion + a10 = logit(p1) + err = np.random.normal(0, error_std, df.shape[0]) + xb_array = (x_classify * coef_classify).sum(axis=1) + err + a1 = fsolve(_softmax, a10, args=(p1, xb_array))[0] + df["reward_prob_linear"] = a1 + xb_array + df["control_reward_prob_linear"] = df["reward_prob_linear"].values + + # arm-specific reward probability + for arm in arm_names: + if arm != arm_names[0]: # Skip control arm + treatment_index = df.index[df["arm"] == arm].tolist() + coef_arm = [] + for ci in range(n_arm_features[arm]): + if custom_coef_arm and coef_arm_dict is not None and arm in coef_arm_dict: + coef_arm.append(coef_arm_dict[arm][ci]) + else: + coef_arm.append(0.5) + x_arm = df.loc[:, x_arm_transformed_dict[arm]].values + p2 = mean_dict[arm] + a20 = np.log(p2 / (1.0 - p2)) - a1 + xb_array = df["reward_prob_linear"].values + (x_arm * coef_arm).sum(axis=1) + xb_array_treatment = xb_array[treatment_index] + a2 = fsolve(_softmax, a20, args=(p2, xb_array_treatment))[0] + df[f"{arm}_reward_prob_linear"] = a2 + xb_array + df.loc[treatment_index, "reward_prob_linear"] = df.loc[treatment_index, f"{arm}_reward_prob_linear"].values + else: + df[f"{arm}_reward_prob_linear"] = df["reward_prob_linear"].values + + # generate reward probability and true treatment effect + df["reward_prob"] = 1 / (1 + np.exp(-df["reward_prob_linear"].values)) + df["control_reward_prob"] = 1 / (1 + np.exp(-df["control_reward_prob_linear"].values)) + for arm in arm_names: + df[f"{arm}_reward_prob"] = 1 / (1 + np.exp(-df[f"{arm}_reward_prob_linear"].values)) + df[f"{arm}_true_effect"] = df[f"{arm}_reward_prob"].values - df["control_reward_prob"].values + + # generate reward + df["reward_prob"] = np.clip(df["reward_prob"].values, 0, 1) + df["reward"] = np.random.binomial(1, df["reward_prob"].values) + + return df, x_name + +def make_classical_mab_data( + n_samples: int = 10000, + n_arms: int = 4, + arm_effects: Dict[str, float] = None, + positive_class_proportion: float = 0.1, + random_seed: int = 20200101, + error_std: float = 0.05 +) -> pd.DataFrame: + """Generate synthetic data for classical multi-armed bandit experiments. + + This is a simplified version of make_mab_data that only generates data + needed for classical MAB algorithms (arm and reward). + + Parameters + ---------- + n_samples : int, optional (default=10000) + Number of samples to generate. + n_arms : int, optional (default=4) + Number of arms/treatments. + arm_effects : dict, optional (default=None) + Dictionary of arm effects. If None, random effects will be generated. + positive_class_proportion : float, optional (default=0.1) + Proportion of positive outcomes in the control group. + random_seed : int, optional (default=20200101) + Random seed for reproducibility. + error_std : float, optional (default=0.05) + Standard deviation of the error term. + + Returns + ------- + df : pd.DataFrame + Generated dataset with the following columns: + - arm: The arm/treatment assigned to each sample + - reward: The binary reward (0 or 1) for each sample + - reward_prob: The probability of reward for each sample + """ + return make_mab_data( + n_samples=n_samples, + n_arms=n_arms, + n_features=0, # No features needed for classical MAB + n_informative=0, + n_redundant=0, + n_repeated=0, + arm_effects=arm_effects, + positive_class_proportion=positive_class_proportion, + random_seed=random_seed, + error_std=error_std + ) + +# ------ Spline generator + +def _generate_splines( + n_functions=10, + n_initial_points=10, + s=0.01, + x_min=-3, + x_max=3, + y_min=0, + y_max=1, + random_seed=2019, +): + np.random.seed(random_seed) + spls = [] + for i in range(n_functions): + x = np.linspace(x_min, x_max, n_initial_points) + y = np.random.uniform(y_min, y_max, n_initial_points) + spl = UnivariateSpline(x, y, s=s) + spls.append(spl) + return spls + +# ------ New MAB data generation function (logistic model) +def make_mab_logistic( + n_samples=10000, + treatment_name=["control", "treatment1", "treatment2", "treatment3"], + y_name="conversion", + n_classification_features=10, + n_classification_informative=5, + n_classification_redundant=0, + n_classification_repeated=0, + n_uplift_dict={"treatment1": 2, "treatment2": 2, "treatment3": 3}, + n_mix_informative_uplift_dict={"treatment1": 1, "treatment2": 1, "treatment3": 0}, + delta_uplift_dict={"treatment1": 0.02, "treatment2": 0.05, "treatment3": -0.05}, + positive_class_proportion=0.1, + random_seed=20200101, + feature_association_list=["linear", "quadratic", "cubic", "relu", "sin", "cos"], + random_select_association=True, + error_std=0.05, +): + # Set means for each experiment group + mean_dict = {} + mean_dict[treatment_name[0]] = positive_class_proportion + for treatment_key_i in treatment_name[1:]: + mean_dict[treatment_key_i] = positive_class_proportion + if treatment_key_i in delta_uplift_dict: + mean_dict[treatment_key_i] += delta_uplift_dict[treatment_key_i] + + df1 = pd.DataFrame() + n = n_samples + np.random.seed(seed=random_seed) + + feature_association_pattern_dict = { + "linear": _f_linear, + "quadratic": _f_quadratic, + "cubic": _f_cubic, + "relu": _f_relu, + "sin": _f_sin, + "cos": _f_cos, + } + f_list = [feature_association_pattern_dict[fi] for fi in feature_association_list] + + # generate treatment key + treatment_list = [] + for ti in treatment_name: + treatment_list += [ti] * n + treatment_list = np.random.permutation(treatment_list) + df1["treatment_group_key"] = treatment_list + + x_name = [] + x_informative_name = [] + x_informative_transformed = [] + + # informative features + for xi in range(n_classification_informative): + x = np.random.normal(0, 1, df1.shape[0]) + x_name_i = f"x{len(x_name)+1}_informative" + x_name.append(x_name_i) + x_informative_name.append(x_name_i) + df1[x_name_i] = x + x_name_i = x_name_i + "_transformed" + df1[x_name_i] = _fixed_transformation(f_list, x, xi) + x_informative_transformed.append(x_name_i) + + # redundant features + for xi in range(n_classification_redundant): + nx = np.random.choice(n_classification_informative, size=1, replace=False)[0] + 1 + bx = np.random.normal(0, 1, size=nx) + fx = np.random.choice(n_classification_informative, size=nx, replace=False, p=None) + x_name_i = f"x{len(x_name)+1}_redundant_linear" + for xxi in range(nx): + x_name_i += f"_x{fx[xxi]+1}" + x_name.append(x_name_i) + x = np.zeros(df1.shape[0]) + for xxi in range(nx): + x += bx[xxi] * df1[x_name[fx[xxi]]] + x = _standardize(x) + df1[x_name_i] = x + + # repeated features + for xi in range(n_classification_repeated): + fx = np.random.choice(n_classification_informative, size=1, replace=False, p=None) + x_name_i = f"x{len(x_name)+1}_repeated_x{fx[0]+1}" + x_name.append(x_name_i) + df1[x_name_i] = df1[x_name[fx[0]]] + + # irrelevant features + for xi in range( + n_classification_features + - n_classification_informative + - n_classification_redundant + - n_classification_repeated + ): + x_name_i = f"x{len(x_name)+1}_irrelevant" + x_name.append(x_name_i) + df1[x_name_i] = np.random.normal(0, 1, df1.shape[0]) + + # uplift features + x_name_uplift_transformed_dict = dict() + for treatment_key_i in treatment_name: + treatment_index = df1.index[df1["treatment_group_key"] == treatment_key_i].tolist() + if treatment_key_i in n_uplift_dict and n_uplift_dict[treatment_key_i] > 0: + x_name_uplift_transformed = [] + x_name_uplift = [] + for xi in range(n_uplift_dict[treatment_key_i]): + x = np.random.normal(0, 1, df1.shape[0]) + x_name_i = f"x{len(x_name)+1}_uplift" + x_name.append(x_name_i) + x_name_uplift.append(x_name_i) + df1[x_name_i] = x + x_name_i = x_name_i + "_transformed" + if random_select_association: + df1[x_name_i] = _fixed_transformation(f_list, x, random.randint(0, len(f_list) - 1)) + else: + df1[x_name_i] = _fixed_transformation(f_list, x, xi % len(f_list)) + x_name_uplift_transformed.append(x_name_i) + x_name_uplift_transformed_dict[treatment_key_i] = x_name_uplift_transformed + + # mixed informative and uplift features + for treatment_key_i in treatment_name: + if treatment_key_i in n_mix_informative_uplift_dict and n_mix_informative_uplift_dict[treatment_key_i] > 0: + for xi in range(n_mix_informative_uplift_dict[treatment_key_i]): + x_name_i = f"x{len(x_name)+1}_mix" + x_name.append(x_name_i) + p_weight = np.random.uniform(0, 1) + df1[x_name_i] = ( + p_weight * df1[np.random.choice(x_informative_name)] + + (1 - p_weight) * df1[np.random.choice(x_name_uplift)] + ) + + # baseline conversion probability + coef_classify = [] + for ci in range(n_classification_informative): + rcoef = [0] + while np.abs(rcoef) < 0.1: + rcoef = 1.0 * (1 + 0.1 * np.random.randn(1)) * np.sqrt(1.0 / n_classification_informative) + coef_classify.append(rcoef[0]) + x_classify = df1[x_informative_transformed].values + p1 = positive_class_proportion + a10 = logit(p1) + err = np.random.normal(0, error_std, df1.shape[0]) + xb_array = (x_classify * coef_classify).sum(axis=1) + err + a1 = fsolve(_softmax, a10, args=(p1, xb_array))[0] + df1["conversion_prob_linear"] = a1 + xb_array + df1["control_conversion_prob_linear"] = df1["conversion_prob_linear"].values + + # uplift conversion + for treatment_key_i in treatment_name: + if treatment_key_i in delta_uplift_dict and np.abs(delta_uplift_dict[treatment_key_i]) > 0.0: + treatment_index = df1.index[df1["treatment_group_key"] == treatment_key_i].tolist() + coef_uplift = [] + for ci in range(n_uplift_dict[treatment_key_i]): + coef_uplift.append(0.5) + x_uplift = df1.loc[:, x_name_uplift_transformed_dict[treatment_key_i]].values + p2 = mean_dict[treatment_key_i] + a20 = np.log(p2 / (1.0 - p2)) - a1 + xb_array = df1["conversion_prob_linear"].values + (x_uplift * coef_uplift).sum(axis=1) + xb_array_treatment = xb_array[treatment_index] + a2 = fsolve(_softmax, a20, args=(p2, xb_array_treatment))[0] + df1[f"{treatment_key_i}_conversion_prob_linear"] = a2 + xb_array + df1.loc[treatment_index, "conversion_prob_linear"] = df1.loc[treatment_index, f"{treatment_key_i}_conversion_prob_linear"].values + else: + df1[f"{treatment_key_i}_conversion_prob_linear"] = df1["conversion_prob_linear"].values + + # generate conversion probability and true treatment effect + df1["conversion_prob"] = 1 / (1 + np.exp(-df1["conversion_prob_linear"].values)) + df1["control_conversion_prob"] = 1 / (1 + np.exp(-df1["control_conversion_prob_linear"].values)) + for treatment_key_i in treatment_name: + df1[f"{treatment_key_i}_conversion_prob"] = 1 / (1 + np.exp(-df1[f"{treatment_key_i}_conversion_prob_linear"].values)) + df1[f"{treatment_key_i}_true_effect"] = df1[f"{treatment_key_i}_conversion_prob"].values - df1["control_conversion_prob"].values + + # generate Y + df1["conversion_prob"] = np.clip(df1["conversion_prob"].values, 0, 1) + df1[y_name] = np.random.binomial(1, df1["conversion_prob"].values) + + return df1, x_name \ No newline at end of file diff --git a/causalml/metrics/__init__.py b/causalml/metrics/__init__.py index 0bc9d187..dd1d3718 100644 --- a/causalml/metrics/__init__.py +++ b/causalml/metrics/__init__.py @@ -32,3 +32,15 @@ SensitivitySubsetData, SensitivitySelectionBias, ) # noqa +from .mab_evaluation import ( + MABMetrics, + evaluate_mab, + compare_mab_algorithms, + plot_mab_comparison, + plot_learning_curve, + cumulative_reward, + cumulative_regret, + plot_cumulative_reward, + plot_cumulative_regret, + plot_arm_selection_frequency +) diff --git a/causalml/metrics/mab_evaluation.py b/causalml/metrics/mab_evaluation.py new file mode 100644 index 00000000..a211bd42 --- /dev/null +++ b/causalml/metrics/mab_evaluation.py @@ -0,0 +1,396 @@ +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from typing import List, Dict, Tuple, Optional, Union +from scipy import stats +import seaborn as sns +from dataclasses import dataclass +from datetime import datetime + +@dataclass +class MABMetrics: + """Class for storing MAB algorithm evaluation metrics.""" + cumulative_reward: float + average_reward: float + regret: float + arm_pulls: Dict[str, int] + arm_rewards: Dict[str, float] + arm_means: Dict[str, float] + timestamp: str + +def evaluate_mab( + bandit, + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + true_means: Optional[Dict[str, float]] = None +) -> MABMetrics: + """Evaluate a MAB algorithm on a dataset. + + Parameters + ---------- + bandit : BaseBandit or BaseContextualBandit + The bandit algorithm to evaluate. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + If provided, regret will be calculated. + + Returns + ------- + metrics : MABMetrics + Evaluation metrics including cumulative reward, average reward, + regret (if true_means provided), and arm statistics. + """ + # Initialize metrics + cumulative_reward = 0 + arm_pulls = {arm: 0 for arm in df[arm_col].unique()} + arm_rewards = {arm: 0.0 for arm in df[arm_col].unique()} + + # Run bandit algorithm + for _, row in df.iterrows(): + # Select arm + if hasattr(bandit, 'select_arm'): + arm = bandit.select_arm() + else: + arm = bandit.select_arm(row) + + # Get reward + reward = row[reward_col] + + # Update bandit + if hasattr(bandit, 'update'): + bandit.update(arm, reward) + else: + bandit.update(row, reward) + + # Update metrics + cumulative_reward += reward + arm_pulls[arm] += 1 + arm_rewards[arm] += reward + + # Calculate final metrics + n_samples = len(df) + average_reward = cumulative_reward / n_samples + + # Calculate arm means + arm_means = { + arm: arm_rewards[arm] / arm_pulls[arm] if arm_pulls[arm] > 0 else 0 + for arm in arm_pulls + } + + # Calculate regret if true means provided + regret = 0 + if true_means is not None: + best_arm = max(true_means.items(), key=lambda x: x[1])[0] + best_mean = true_means[best_arm] + regret = best_mean * n_samples - cumulative_reward + + return MABMetrics( + cumulative_reward=cumulative_reward, + average_reward=average_reward, + regret=regret, + arm_pulls=arm_pulls, + arm_rewards=arm_rewards, + arm_means=arm_means, + timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S") + ) + +def compare_mab_algorithms( + algorithms: Dict[str, Union['BaseBandit', 'BaseContextualBandit']], + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + true_means: Optional[Dict[str, float]] = None, + n_runs: int = 1, + plot: bool = True +) -> Dict[str, MABMetrics]: + """Compare multiple MAB algorithms on the same dataset. + + Parameters + ---------- + algorithms : dict + Dictionary of algorithm names to bandit instances. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + n_runs : int, optional (default=1) + Number of times to run each algorithm. + plot : bool, optional (default=True) + Whether to plot the comparison results. + + Returns + ------- + results : dict + Dictionary of algorithm names to MABMetrics. + """ + results = {} + + # Run each algorithm + for name, algorithm in algorithms.items(): + run_metrics = [] + for _ in range(n_runs): + # Create a copy of the algorithm for this run + alg_copy = algorithm.__class__(**algorithm.__dict__) + metrics = evaluate_mab( + alg_copy, + df, + reward_col=reward_col, + arm_col=arm_col, + true_means=true_means + ) + run_metrics.append(metrics) + + # Average metrics across runs + avg_metrics = MABMetrics( + cumulative_reward=np.mean([m.cumulative_reward for m in run_metrics]), + average_reward=np.mean([m.average_reward for m in run_metrics]), + regret=np.mean([m.regret for m in run_metrics]), + arm_pulls=run_metrics[0].arm_pulls, # Same for all runs + arm_rewards={arm: np.mean([m.arm_rewards[arm] for m in run_metrics]) + for arm in run_metrics[0].arm_rewards}, + arm_means={arm: np.mean([m.arm_means[arm] for m in run_metrics]) + for arm in run_metrics[0].arm_means}, + timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S") + ) + results[name] = avg_metrics + + if plot: + plot_mab_comparison(results, true_means) + + return results + +def plot_mab_comparison( + results: Dict[str, MABMetrics], + true_means: Optional[Dict[str, float]] = None +): + """Plot comparison of MAB algorithms. + + Parameters + ---------- + results : dict + Dictionary of algorithm names to MABMetrics. + true_means : dict, optional (default=None) + Dictionary of true mean rewards for each arm. + """ + # Create figure with subplots + fig, axes = plt.subplots(2, 2, figsize=(15, 12)) + fig.suptitle('MAB Algorithm Comparison', fontsize=16) + + # Plot 1: Average Reward + rewards = [metrics.average_reward for metrics in results.values()] + sns.barplot(x=list(results.keys()), y=rewards, ax=axes[0, 0]) + axes[0, 0].set_title('Average Reward') + axes[0, 0].set_ylabel('Reward') + axes[0, 0].tick_params(axis='x', rotation=45) + + # Plot 2: Regret + regrets = [metrics.regret for metrics in results.values()] + sns.barplot(x=list(results.keys()), y=regrets, ax=axes[0, 1]) + axes[0, 1].set_title('Cumulative Regret') + axes[0, 1].set_ylabel('Regret') + axes[0, 1].tick_params(axis='x', rotation=45) + + # Plot 3: Arm Pulls + arm_pulls = pd.DataFrame({ + name: metrics.arm_pulls + for name, metrics in results.items() + }).T + arm_pulls.plot(kind='bar', stacked=True, ax=axes[1, 0]) + axes[1, 0].set_title('Arm Pulls Distribution') + axes[1, 0].set_ylabel('Number of Pulls') + axes[1, 0].tick_params(axis='x', rotation=45) + + # Plot 4: Arm Means vs True Means + if true_means is not None: + arm_means = pd.DataFrame({ + name: metrics.arm_means + for name, metrics in results.items() + }).T + true_means_df = pd.DataFrame([true_means] * len(results), index=results.keys()) + + # Plot estimated means + arm_means.plot(kind='bar', ax=axes[1, 1], alpha=0.7) + # Plot true means + for arm in true_means: + axes[1, 1].axhline( + y=true_means[arm], + color='k', + linestyle='--', + alpha=0.3, + label=f'True {arm}' + ) + axes[1, 1].set_title('Arm Mean Estimates vs True Means') + axes[1, 1].set_ylabel('Mean Reward') + axes[1, 1].tick_params(axis='x', rotation=45) + axes[1, 1].legend(bbox_to_anchor=(1.05, 1), loc='upper left') + + plt.tight_layout() + plt.show() + +def plot_learning_curve( + bandit, + df: pd.DataFrame, + reward_col: str = 'reward', + arm_col: str = 'arm', + window_size: int = 100, + plot: bool = True +) -> Tuple[np.ndarray, np.ndarray]: + """Plot the learning curve of a MAB algorithm. + + Parameters + ---------- + bandit : BaseBandit or BaseContextualBandit + The bandit algorithm to evaluate. + df : pd.DataFrame + The dataset to evaluate on. + reward_col : str, optional (default='reward') + Name of the reward column. + arm_col : str, optional (default='arm') + Name of the arm column. + window_size : int, optional (default=100) + Size of the moving average window. + plot : bool, optional (default=True) + Whether to plot the learning curve. + + Returns + ------- + rewards : np.ndarray + Array of rewards over time. + avg_rewards : np.ndarray + Array of moving average rewards. + """ + # Initialize arrays + n_samples = len(df) + rewards = np.zeros(n_samples) + + # Run bandit algorithm + for i, row in df.iterrows(): + # Select arm + if hasattr(bandit, 'select_arm'): + arm = bandit.select_arm() + else: + arm = bandit.select_arm(row) + + # Get reward + reward = row[reward_col] + + # Update bandit + if hasattr(bandit, 'update'): + bandit.update(arm, reward) + else: + bandit.update(row, reward) + + # Store reward + rewards[i] = reward + + # Calculate moving average + avg_rewards = np.convolve(rewards, np.ones(window_size)/window_size, mode='valid') + + if plot: + plt.figure(figsize=(10, 6)) + plt.plot(rewards, alpha=0.3, label='Rewards') + plt.plot(range(window_size-1, n_samples), avg_rewards, label=f'{window_size}-step Moving Average') + plt.title('Learning Curve') + plt.xlabel('Step') + plt.ylabel('Reward') + plt.legend() + plt.grid(True, alpha=0.3) + plt.show() + + return rewards, avg_rewards + +def cumulative_reward(rewards: np.ndarray) -> np.ndarray: + """Calculate cumulative reward over time. + + Parameters + ---------- + rewards : np.ndarray + Array of rewards over time. + + Returns + ------- + cum_reward : np.ndarray + Array of cumulative rewards. + """ + return np.cumsum(rewards) + +def cumulative_regret(rewards: np.ndarray, optimal_reward: float) -> np.ndarray: + """Calculate cumulative regret over time. + + Parameters + ---------- + rewards : np.ndarray + Array of rewards over time. + optimal_reward : float + The optimal reward that could have been achieved. + + Returns + ------- + cum_regret : np.ndarray + Array of cumulative regrets. + """ + return np.cumsum(optimal_reward - rewards) + +def plot_cumulative_reward(results: dict, filename: str = None): + """Plot cumulative reward for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + plt.plot(cumulative_reward(result['rewards']), label=name) + plt.title('Cumulative Reward Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Reward') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + +def plot_cumulative_regret(results: dict, optimal_reward: float, filename: str = None): + """Plot cumulative regret for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + plt.plot(cumulative_regret(result['rewards'], optimal_reward), label=name) + plt.title('Cumulative Regret Over Time') + plt.xlabel('Time Step') + plt.ylabel('Cumulative Regret') + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + +def plot_arm_selection_frequency(results: dict, n_arms: int, filename: str = None): + """Plot arm selection frequency for each algorithm.""" + plt.figure(figsize=(12, 6)) + for name, result in results.items(): + arm_freq = pd.Series(result['selected_arms']).value_counts(normalize=True) + plt.bar(np.arange(len(arm_freq)) + 0.1 * list(results.keys()).index(name), + arm_freq.values, + width=0.1, + label=name) + plt.title('Arm Selection Frequency') + plt.xlabel('Arm') + plt.ylabel('Selection Frequency') + plt.xticks(np.arange(n_arms) + 0.5, [f'Arm {i}' for i in range(n_arms)]) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + plt.tight_layout() + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() \ No newline at end of file diff --git a/causalml/optimize/__init__.py b/causalml/optimize/__init__.py index 6379fc0c..6589f40b 100644 --- a/causalml/optimize/__init__.py +++ b/causalml/optimize/__init__.py @@ -3,3 +3,15 @@ from .utils import get_treatment_costs, get_actual_value, get_uplift_best from .value_optimization import CounterfactualValueEstimator from .pns import get_pns_bounds +from .bandit import ( + BaseBandit, + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + BaseContextualBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) diff --git a/causalml/optimize/bandit.py b/causalml/optimize/bandit.py new file mode 100644 index 00000000..57fae137 --- /dev/null +++ b/causalml/optimize/bandit.py @@ -0,0 +1,538 @@ +import numpy as np +import pandas as pd +from typing import List, Dict, Optional, Union +from abc import ABC, abstractmethod + +# ============= Classical Multi-Armed Bandit Algorithms ============= + +class BaseBandit(ABC): + """Base class for all bandit algorithms.""" + def __init__(self, batch_size: int = 1): + # Number of samples to process in each batch + self.batch_size = batch_size + # List of unique arm identifiers + self.arms = None + # Total number of unique arms + self.n_arms = None + # Dictionary tracking number of times each arm has been pulled + self.n_pulls = None + # Dictionary tracking cumulative rewards for each arm + self.rewards = None + # Dictionary tracking average reward (value) for each arm + self.arm_values = None + + def fit(self, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + arm: arm assignment (array-like) + reward: observed reward (array-like) + + Returns: + self: returns an instance of self. + """ + # Reset stats + self.arms = np.unique(arm) + self.n_arms = len(self.arms) + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + for a, r in zip(arm, reward): + self.update(a, r) + return self + + def predict(self, n_samples: int = 1): + """ + Predict the best arm for n_samples. + + Args: + n_samples: number of predictions to make + + Returns: + list: list of predicted arms + """ + return [self.select_arm() for _ in range(n_samples)] + + @abstractmethod + def select_arm(self, context=None) -> int: + """Select an arm based on the current state or context.""" + pass + + def update(self, chosen_arm: int, reward: float, context=None) -> None: + """Update the model with the observed reward.""" + self.n_pulls[chosen_arm] += 1 + self.rewards[chosen_arm] += reward + self.arm_values[chosen_arm] = self.rewards[chosen_arm] / self.n_pulls[chosen_arm] + + def batch_update(self, chosen_arms: List[int], rewards: List[float], contexts=None) -> None: + """Update the model with a batch of observations.""" + for i, (arm, reward) in enumerate(zip(chosen_arms, rewards)): + context = contexts[i] if contexts is not None else None + self.update(arm, reward, context) + + def get_arm_values(self) -> Dict[int, float]: + """Get the current value estimates for all arms.""" + return self.arm_values + + def run(self) -> pd.DataFrame: + """Run the bandit algorithm on the entire dataset.""" + selected_arms = [] + rewards = [] + for i in range(0, len(self.df), self.batch_size): + batch = self.df.iloc[i:i+self.batch_size] + chosen_arms = [self.select_arm() for _ in range(len(batch))] + reward_batch = np.where(batch[self.arm].values == chosen_arms, batch[self.reward].values, 0) + self.batch_update(chosen_arms, reward_batch) + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + self.df['chosen_arm'] = selected_arms + self.df['observed_reward'] = rewards + return self.df + +class EpsilonGreedy(BaseBandit): + """Epsilon Greedy bandit algorithm.""" + def __init__(self, epsilon: float = 0.1, batch_size: int = 1): + super().__init__(batch_size) + # Probability of exploration (random arm selection) + self.epsilon = epsilon + + def select_arm(self, context=None) -> int: + if np.random.random() < self.epsilon: + return np.random.choice(self.arms) + else: + return max(self.arm_values.items(), key=lambda x: x[1])[0] + +class UCB(BaseBandit): + """Upper Confidence Bound (UCB) bandit algorithm.""" + def __init__(self, alpha: float = 1.0, batch_size: int = 1): + super().__init__(batch_size) + # Exploration parameter controlling the width of the confidence bound + self.alpha = alpha + + def select_arm(self, context=None) -> int: + unexplored_arms = [arm for arm in self.arms if self.n_pulls[arm] == 0] + if unexplored_arms: + return unexplored_arms[0] + total_pulls = sum(self.n_pulls.values()) + ucb_values = { + arm: self.arm_values[arm] + self.alpha * np.sqrt( + np.log(total_pulls) / self.n_pulls[arm] + ) + for arm in self.arms + } + return max(ucb_values.items(), key=lambda x: x[1])[0] + +class ThompsonSampling(BaseBandit): + """Thompson Sampling bandit algorithm.""" + def __init__(self, batch_size: int = 1): + super().__init__(batch_size) + # Dictionary of alpha parameters for Beta distribution of each arm + self.alpha = None + # Dictionary of beta parameters for Beta distribution of each arm + self.beta = None + + def fit(self, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + arm: arm assignment (array-like) + reward: observed reward (array-like) + + Returns: + self: returns an instance of self. + """ + self.arms = np.unique(arm) + self.n_arms = len(self.arms) + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + self.alpha = {a: 1.0 for a in self.arms} + self.beta = {a: 1.0 for a in self.arms} + for a, r in zip(arm, reward): + self.update(a, r) + self.alpha[a] += r + self.beta[a] += (1 - r) + return self + + def select_arm(self, context=None) -> int: + samples = { + arm: np.random.beta(self.alpha[arm], self.beta[arm]) + for arm in self.arms + } + return max(samples.items(), key=lambda x: x[1])[0] + + def update(self, chosen_arm: int, reward: float, context=None) -> None: + super().update(chosen_arm, reward) + self.alpha[chosen_arm] += reward + self.beta[chosen_arm] += (1 - reward) + +class BatchBandit: + """Wrapper class for batch processing with any bandit algorithm.""" + def __init__(self, bandit: BaseBandit, batch_size: int): + # The underlying bandit algorithm to be used + self.bandit = bandit + # Number of samples to process in each batch + self.batch_size = batch_size + + def select_batch(self) -> List[int]: + return [self.bandit.select_arm() for _ in range(self.batch_size)] + + def update_batch(self, arms: List[int], rewards: List[float]) -> None: + self.bandit.batch_update(arms, rewards) + + def get_arm_values(self) -> Dict[int, float]: + return self.bandit.get_arm_values() + + def fit(self, arm, reward): + self.bandit.fit(arm, reward) + return self + + def predict(self, n_samples: int = 1): + """Predict the best arm for n_samples using the underlying bandit.""" + return self.bandit.predict(n_samples) + +# ============= Contextual Multi-Armed Bandit Algorithms ============= + +class BaseContextualBandit(ABC): + """Base class for all contextual bandit algorithms.""" + def __init__(self, batch_size: int = 1): + # Number of samples to process in each batch + self.batch_size = batch_size + # List of unique arm identifiers + self.arms = None + # List of feature names used for context + self.features = None + # Total number of unique arms + self.n_arms = None + # Dictionary tracking number of times each arm has been pulled + self.n_pulls = None + # Dictionary tracking cumulative rewards for each arm + self.rewards = None + # Dictionary tracking average reward (value) for each arm + self.arm_values = None + + @abstractmethod + def fit(self, X, arm, reward, features): + pass + + @abstractmethod + def select_arm(self, context: np.ndarray) -> int: + pass + + @abstractmethod + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + pass + + def batch_select(self, context_batch: np.ndarray) -> List[int]: + return [self.select_arm(context) for context in context_batch] + + def batch_update(self, chosen_arms: List[int], context_batch: np.ndarray, rewards: np.ndarray) -> None: + for arm, context, reward in zip(chosen_arms, context_batch, rewards): + self.update(arm, context, reward) + +class LinUCB(BaseContextualBandit): + """Linear Upper Confidence Bound (LinUCB) bandit algorithm.""" + def __init__(self, alpha: float = 1.0, batch_size: int = 1): + super().__init__(batch_size) + # Exploration parameter controlling the width of the confidence bound + self.alpha = alpha + # Dimension of the feature space + self.d = None + # Dictionary of A matrices (feature covariance matrices) for each arm + self.A = None + # Dictionary of b vectors (feature-reward correlation) for each arm + self.b = None + + def fit(self, X, arm, reward, features): + self.features = features + self.arms = np.unique(arm) + self.n_arms = len(self.arms) + self.d = len(features) + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + self.A = {a: np.identity(self.d, dtype=np.float64) for a in self.arms} + self.b = {a: np.zeros(self.d, dtype=np.float64) for a in self.arms} + for x, a, r in zip(X[features].values, arm, reward): + self.update(a, x, r) + return self + + def select_arm(self, context: np.ndarray) -> int: + ucb_values = {} + for arm in self.arms: + theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) + ucb = np.dot(context, theta) + self.alpha * np.sqrt( + np.dot(np.dot(context, np.linalg.inv(self.A[arm])), context) + ) + ucb_values[arm] = ucb + return max(ucb_values.items(), key=lambda x: x[1])[0] + + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + context = context.astype(np.float64) + self.A[chosen_arm] += np.outer(context, context) + self.b[chosen_arm] += reward * context + +class BatchLinUCB(LinUCB): + """Batch Linear Upper Confidence Bound (BatchLinUCB) bandit algorithm.""" + def __init__(self, alpha: float = 1.0, batch_size: int = 32): + super().__init__(alpha, batch_size) + # Store data as numpy arrays + self.X = None # Context features + self.arms = None # Available arms + self.d = None # Feature dimension + + def fit(self, X, arm, reward): + """ + Fit the bandit model to offline data. + + Args: + X: Context features (numpy array) + arm: Arm assignments (numpy array) + reward: Observed rewards (numpy array) + + Returns: + self: returns an instance of self. + """ + # Convert inputs to numpy arrays if they aren't already + self.X = np.asarray(X, dtype=np.float64) + arm = np.asarray(arm) + reward = np.asarray(reward) + + self.arms = np.unique(arm) + self.d = self.X.shape[1] + self.n_pulls = {a: 0 for a in self.arms} + self.rewards = {a: 0.0 for a in self.arms} + self.arm_values = {a: 0.0 for a in self.arms} + + # Initialize A and b for each arm + self.A = {a: np.identity(self.d, dtype=np.float64) for a in self.arms} + self.b = {a: np.zeros(self.d, dtype=np.float64) for a in self.arms} + + return self + + def select_arm(self, context_batch): + """ + Select arms for a batch of contexts using vectorized operations. + + Args: + context_batch: Array of context features for the batch + + Returns: + list: List of selected arms + """ + ucb_values = {} + + for arm in self.arms: + theta = np.dot(np.linalg.inv(self.A[arm]), self.b[arm]) + # Compute UCB values for the entire batch using einsum + ucb = np.dot(context_batch, theta) + self.alpha * np.sqrt( + np.einsum('ij,jk,ik->i', context_batch, np.linalg.inv(self.A[arm]), context_batch) + ) + ucb_values[arm] = ucb + + # Select the arm with the highest UCB value for each context in the batch + chosen_arms = np.argmax(np.array(list(ucb_values.values())).T, axis=1) + + return [self.arms[i] for i in chosen_arms] + + def update_batch(self, chosen_arms, context_batch, rewards): + """ + Update the model with a batch of observations using vectorized operations. + + Args: + chosen_arms: Array of chosen arms + context_batch: Array of context features + rewards: Array of observed rewards + """ + for arm in self.arms: + indices = np.where(chosen_arms == arm)[0] + if len(indices) == 0: + continue + + X = context_batch[indices] + R = rewards[indices] + + self.A[arm] += np.dot(X.T, X) + self.b[arm] += np.dot(X.T, R) + + def run(self): + """ + Run the bandit algorithm on the entire dataset. + + Returns: + tuple: (selected_arms, observed_rewards) + """ + selected_arms = [] + rewards = [] + + # Process the data in batches + for i in range(0, len(self.X), self.batch_size): + batch_end = min(i + self.batch_size, len(self.X)) + context_batch = self.X[i:batch_end] + chosen_arms = self.select_arm(context_batch) + + # Calculate rewards for the batch + reward_batch = np.zeros(len(chosen_arms)) + for j, (chosen_arm, true_arm) in enumerate(zip(chosen_arms, self.arms[i:batch_end])): + if chosen_arm == true_arm: + reward_batch[j] = self.rewards[true_arm] + + self.update_batch(chosen_arms, context_batch, reward_batch) + + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + + return np.array(selected_arms), np.array(rewards) + +class CohortThompsonSampling(BaseContextualBandit): + """Cohort Thompson Sampling bandit algorithm.""" + def __init__(self, batch_size: int = 1): + super().__init__(batch_size) + # Name of the feature used for cohorting + self.cohort_feature = None + # List of unique cohort values + self.cohorts = None + # Nested dictionary tracking successful pulls for each arm in each cohort + self.successes = None + # Nested dictionary tracking failed pulls for each arm in each cohort + self.failures = None + + def fit(self, X, arm, reward, cohort_feature): + self.cohort_feature = cohort_feature + self.arms = np.unique(arm) + self.cohorts = np.unique(X[cohort_feature]) + self.successes = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.failures = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + for i in range(len(X)): + context = np.array([X.iloc[i][cohort_feature]]) + a = arm.iloc[i] if hasattr(arm, 'iloc') else arm[i] + r = reward.iloc[i] if hasattr(reward, 'iloc') else reward[i] + self.update(a, context, r) + return self + + def select_arm(self, context: np.ndarray) -> int: + cohort = context[0] + sampled_theta = {} + for arm in self.arms: + a = self.successes[cohort][arm] + 1 + b = self.failures[cohort][arm] + 1 + sampled_theta[arm] = np.random.beta(a, b) + return max(sampled_theta, key=sampled_theta.get) + + def update(self, chosen_arm: int, context: np.ndarray, reward: float) -> None: + cohort = context[0] + if reward > 0: + self.successes[cohort][chosen_arm] += 1 + else: + self.failures[cohort][chosen_arm] += 1 + +class BatchCohortThompsonSampling(CohortThompsonSampling): + """Batch Cohort Thompson Sampling bandit algorithm.""" + def __init__(self, batch_size: int = 32): + super().__init__(batch_size) + # Store data as numpy arrays + self.X = None # Context features + self.arm_assignments = None # Actual arm assignments for each sample + self.rewards_array = None # Actual observed rewards for each sample + self.cohorts = None # Available cohort values + + def fit(self, X, arm, reward, cohort_feature): + """ + Fit the bandit model to offline data. + + Args: + X: Context features (numpy array) + arm: Arm assignments (numpy array) + reward: Observed rewards (numpy array) + cohort_feature: Index of the feature to use for cohorting, or an array of cohort assignments + + Returns: + self: returns an instance of self. + """ + # Convert inputs to numpy arrays if they aren't already + self.X = np.asarray(X, dtype=np.float64) + self.arm_assignments = np.asarray(arm) + self.rewards_array = np.asarray(reward) + + # If cohort_feature is an array, use it directly; if int, use as column index + if isinstance(cohort_feature, (np.ndarray, list)): + cohort_feature = np.asarray(cohort_feature) + self.cohort_assignments = cohort_feature + else: + self.cohort_assignments = self.X[:, cohort_feature] + self.cohorts = np.unique(self.cohort_assignments) + self.arms = np.unique(self.arm_assignments) + + # Initialize success and failure counts for each arm in each cohort + self.successes = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.failures = {cohort: {a: 0 for a in self.arms} for cohort in self.cohorts} + self.cohort_feature = cohort_feature + return self + + def select_arm_batch(self, cohort_batch): + """ + Select arms for a batch of cohorts. + + Args: + cohort_batch: Array of cohort values for the batch + + Returns: + list: List of selected arms + """ + chosen_arms = [] + for cohort in cohort_batch: + sampled_theta = {} + for arm in self.arms: + # Draw samples from the Beta distribution for each arm + a = self.successes[cohort][arm] + 1 + b = self.failures[cohort][arm] + 1 + sampled_theta[arm] = np.random.beta(a, b) + # Select the arm with the highest sample + chosen_arm = max(sampled_theta, key=sampled_theta.get) + chosen_arms.append(chosen_arm) + return chosen_arms + + def update_batch(self, cohort_batch, chosen_arms, reward_batch): + """ + Update the model with a batch of observations. + + Args: + cohort_batch: Array of cohort values + chosen_arms: Array of chosen arms + reward_batch: Array of observed rewards + """ + for cohort, arm, reward in zip(cohort_batch, chosen_arms, reward_batch): + if reward > 0: + self.successes[cohort][arm] += 1 + else: + self.failures[cohort][arm] += 1 + + def run(self): + """ + Run the bandit algorithm on the entire dataset. + + Returns: + tuple: (selected_arms, observed_rewards) + """ + selected_arms = [] + rewards = [] + # Process the data in batches + for i in range(0, len(self.X), self.batch_size): + batch_end = min(i + self.batch_size, len(self.X)) + cohort_batch = self.cohort_assignments[i:batch_end] + arm_batch = self.arm_assignments[i:batch_end] + reward_batch_true = self.rewards_array[i:batch_end] + # Select arms for the entire batch + chosen_arms = self.select_arm_batch(cohort_batch) + # Calculate rewards for the batch + reward_batch = np.zeros(len(chosen_arms)) + for j, (chosen_arm, true_arm, true_reward) in enumerate(zip(chosen_arms, arm_batch, reward_batch_true)): + if chosen_arm == true_arm: + reward_batch[j] = true_reward + # Update the arms with the observed rewards + self.update_batch(cohort_batch, chosen_arms, reward_batch) + selected_arms.extend(chosen_arms) + rewards.extend(reward_batch) + return np.array(selected_arms), np.array(rewards) \ No newline at end of file diff --git a/docs/examples/bandit/mab_bandit_model_comparison.ipynb b/docs/examples/bandit/mab_bandit_model_comparison.ipynb new file mode 100644 index 00000000..1ffbecad --- /dev/null +++ b/docs/examples/bandit/mab_bandit_model_comparison.ipynb @@ -0,0 +1,719 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "642f1ef4", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Multi-Armed Bandit (MAB) Demonstration\n", + "\n", + "This notebook demonstrates how to use the MAB (Multi-Armed Bandit) algorithms in `causalml` for:\n", + "- Simulating bandit data\n", + "- Running classical and contextual bandit algorithms\n", + "- Evaluating and visualizing results\n", + "\n", + "We will walk through each step with explanations and code." + ] + }, + { + "cell_type": "markdown", + "id": "1237d79c", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 1. Setup and Imports\n", + "\n", + "First, let's import all the necessary libraries and define helper functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "85d7b0a5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from causalml.dataset import make_mab_data\n", + "from causalml.optimize.bandit import (\n", + " EpsilonGreedy, UCB, ThompsonSampling, BatchBandit,\n", + " LinUCB, CohortThompsonSampling, BatchLinUCB, BatchCohortThompsonSampling\n", + ")\n", + "from causalml.metrics import (\n", + " cumulative_reward, cumulative_regret,\n", + " plot_cumulative_reward, plot_cumulative_regret, plot_arm_selection_frequency\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2307f61b", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "### Helper Functions\n", + "\n", + "We define a helper function `run_online_bandit` that handles the online evaluation of different bandit algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f295a2e9", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def run_online_bandit(algo, X, arms, rewards, context_cols=None, cohort_col=None):\n", + " \"\"\"\n", + " Run online evaluation of a bandit algorithm.\n", + " \n", + " Args:\n", + " algo: Bandit algorithm instance\n", + " X: Feature matrix\n", + " arms: True arm assignments\n", + " rewards: True rewards\n", + " context_cols: Context columns (optional)\n", + " cohort_col: Cohort column (optional)\n", + " \n", + " Returns:\n", + " Tuple of (rewards_list, selected_arms)\n", + " \"\"\"\n", + " rewards_list = []\n", + " selected_arms = []\n", + " for i in range(0, len(X), algo.batch_size):\n", + " batch_X = X[i:i + algo.batch_size]\n", + " batch_arms = arms[i:i + algo.batch_size]\n", + " batch_rewards = rewards[i:i + algo.batch_size]\n", + " if isinstance(algo, BatchLinUCB):\n", + " chosen_arms = algo.select_arm(batch_X)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(np.array(chosen_arms), batch_X, np.array(rewards_batch))\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " elif isinstance(algo, BatchCohortThompsonSampling):\n", + " if cohort_col is not None and isinstance(cohort_col, (np.ndarray, list, pd.Series)):\n", + " cohort_batch = cohort_col[i:i + algo.batch_size]\n", + " else:\n", + " cohort_batch = batch_X[:, 0]\n", + " chosen_arms = algo.select_arm_batch(cohort_batch)\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(cohort_batch, chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " else:\n", + " chosen_arms = algo.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " algo.update_batch(chosen_arms, rewards_batch)\n", + " rewards_list.extend(rewards_batch)\n", + " selected_arms.extend(chosen_arms)\n", + " return np.array(rewards_list), np.array(selected_arms)" + ] + }, + { + "cell_type": "markdown", + "id": "ac9de137", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 2. Data Generation\n", + "\n", + "We'll generate synthetic data for our bandit experiments. The data will include:\n", + "- One arm-specific feature for arm_1\n", + "- Different base reward rates for each arm\n", + "- Feature effects for arm_1" + ] + }, + { + "cell_type": "markdown", + "id": "acc2f013", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Generate Feature Matrix and Rewards" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "df9619a6", + "metadata": {}, + "outputs": [], + "source": [ + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Data generation configuration\n", + "n_samples = 20000\n", + "coef_arm_dict = {'arm_1': [0.1]} # One coefficient for arm_1's feature\n", + "\n", + "# Create feature matrix\n", + "X = np.zeros((n_samples, 1)) # Only one feature for arm_1\n", + "X[:, 0] = np.random.normal(0, 1, n_samples) # Random feature values\n", + "\n", + "# Generate arm assignments and rewards\n", + "arms = np.random.choice(['arm_0', 'arm_1', 'arm_2', 'arm_3'], n_samples)\n", + "rewards = np.zeros(n_samples)\n", + "\n", + "# Set base reward rates for each arm\n", + "base_rates = {\n", + " 'arm_0': 0.1,\n", + " 'arm_1': 0.08,\n", + " 'arm_2': 0.08,\n", + " 'arm_3': 0.06\n", + "}\n", + "\n", + "# Generate rewards\n", + "for i in range(n_samples):\n", + " arm = arms[i]\n", + " if arm == 'arm_1':\n", + " # Add feature effect for arm_1\n", + " feature_effect = np.dot(X[i], coef_arm_dict['arm_1'])\n", + " reward_prob = base_rates[arm] + feature_effect\n", + " else:\n", + " reward_prob = base_rates[arm]\n", + " reward_prob = np.clip(reward_prob, 0, 1) # Ensure valid probability\n", + " rewards[i] = np.random.binomial(1, reward_prob)" + ] + }, + { + "cell_type": "markdown", + "id": "3e5fe036", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Data Statistics and Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "badeeb06", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot reward by arm\n", + "plt.figure(figsize=(8, 4))\n", + "arm_rewards = pd.DataFrame({'arm': arms, 'reward': rewards})\n", + "grouped = arm_rewards.groupby('arm')['reward'].mean()\n", + "grouped.plot(kind='bar', width=0.8, color=['#3498DB', '#E74C3C', '#F1C40F', '#1E8449'])\n", + "\n", + "plt.title('Reward Rate by Arm', fontsize=12)\n", + "plt.xlabel('Arm', fontsize=12)\n", + "plt.ylabel('Reward Rate', fontsize=12)\n", + "plt.ylim([0,0.3])\n", + "plt.tick_params(axis='x', rotation=0)\n", + "\n", + "# Apply a box to the plot\n", + "for spine in plt.gca().spines.values():\n", + " spine.set_edgecolor('black')\n", + " spine.set_linewidth(1.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7fdab0f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data Generation Statistics:\n", + "Total samples: 20000\n", + "Number of features: 1\n", + "\n", + "Arm reward rates:\n", + "arm_0: 9.80%\n", + "arm_1: 9.26%\n", + "arm_2: 8.59%\n", + "arm_3: 5.77%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Print data generation statistics\n", + "print(\"\\nData Generation Statistics:\")\n", + "print(f\"Total samples: {n_samples}\")\n", + "print(f\"Number of features: {X.shape[1]}\")\n", + "print(\"\\nArm reward rates:\")\n", + "for arm in np.unique(arms):\n", + " rate = np.mean(rewards[arms == arm])\n", + " print(f\"{arm}: {rate:.2%}\")\n", + "\n", + "# Create feature name mapping for plots\n", + "feature_map = {f\"feature_{i}\": f\"Feature {i}\" for i in range(X.shape[1])}\n", + "\n", + "# Plot reward by feature value and arm (bar chart grid)\n", + "n_bins = 10\n", + "n_cols = 3\n", + "n_rows = int(np.ceil(X.shape[1] / n_cols))\n", + "fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 2.5 * n_rows), sharey=True)\n", + "axes = axes.flatten()\n", + "\n", + "for i in range(X.shape[1]):\n", + " feature = f\"feature_{i}\"\n", + " df = pd.DataFrame({feature: X[:, i]})\n", + " df['arm'] = arms\n", + " df['reward'] = rewards\n", + " df[f'{feature}_binned'] = pd.qcut(df[feature], q=n_bins, duplicates='drop').cat.codes + 1\n", + " grouped = df.groupby([f'{feature}_binned', 'arm'])['reward'].mean().unstack()\n", + " grouped.plot(kind='bar', ax=axes[i], width=0.8)\n", + " axes[i].set_xlabel('Feature Value Bin', fontsize=10)\n", + " axes[i].set_ylabel('Reward', fontsize=10)\n", + " axes[i].set_title(f'{feature_map[feature]}', fontsize=12)\n", + " axes[i].set_ylim([0, 1.])\n", + " if i == X.shape[1] - 1:\n", + " axes[i].legend(title='Arms', loc='center left', bbox_to_anchor=(1.0, 0.5), fontsize=10, title_fontsize=10)\n", + " else:\n", + " axes[i].legend().set_visible(False)\n", + " axes[i].tick_params(axis='x', rotation=0)\n", + " for spine in axes[i].spines.values():\n", + " spine.set_edgecolor('black')\n", + " spine.set_linewidth(1.5)\n", + " df.drop(columns=[f'{feature}_binned'], inplace=True)\n", + "\n", + "# Remove any empty subplots\n", + "for j in range(i+1, len(axes)):\n", + " fig.delaxes(axes[j])\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "bee8fa6b", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Prepare Cohort Information" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f530e321", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First few rows of the dataset:\n", + " arm reward feature_0 cohort\n", + "0 arm_3 0.0 0.496714 1\n", + "1 arm_0 1.0 -0.138264 1\n", + "2 arm_1 0.0 0.647689 2\n", + "3 arm_0 0.0 1.523030 0\n", + "4 arm_3 1.0 -0.234153 1\n" + ] + } + ], + "source": [ + "# Add cohort information for cohort-based algorithms\n", + "df = pd.DataFrame({\n", + " 'arm': arms,\n", + " 'reward': rewards,\n", + " 'feature_0': X[:, 0]\n", + "})\n", + "df['cohort'] = np.random.choice([0, 1, 2], size=len(df))\n", + "\n", + "# Show the first few rows\n", + "print(\"\\nFirst few rows of the dataset:\")\n", + "print(df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "8587bca3", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 3. Initialize and Run Bandit Algorithms\n", + "\n", + "We'll demonstrate both classical and contextual bandits. All bandits are fit using the consistent API." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "16892600", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get feature columns for contextual bandits\n", + "feature_cols = [f'feature_{i}' for i in range(X.shape[1])]\n", + "\n", + "# Initialize and fit bandits to set up their internal state\n", + "# Classical bandits\n", + "eg = BatchBandit(EpsilonGreedy(epsilon=0.3), batch_size=100)\n", + "eg.fit(arms, rewards)\n", + "\n", + "ucb = BatchBandit(UCB(alpha=1.0), batch_size=100)\n", + "ucb.fit(arms, rewards)\n", + "\n", + "ts = BatchBandit(ThompsonSampling(), batch_size=100)\n", + "ts.fit(arms, rewards)\n", + "\n", + "# Contextual bandits\n", + "linucb = BatchLinUCB(alpha=1.0, batch_size=100)\n", + "linucb.fit(X, arms, rewards)\n", + "\n", + "# Bin the feature into 10 bins using pd.qcut\n", + "n_bins_mab = 10\n", + "feature_for_cohort = 0 # Only one feature, index 0\n", + "cohort_bins = pd.qcut(X[:, feature_for_cohort], n_bins_mab, labels=False, duplicates=\"drop\")\n", + "\n", + "# Use the binned cohort in the bandit\n", + "cohort_ts = BatchCohortThompsonSampling(batch_size=100)\n", + "cohort_ts.fit(X, arms, rewards, cohort_feature=cohort_bins)" + ] + }, + { + "cell_type": "markdown", + "id": "0c67deaf", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "06e9bf35", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "2586e996", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "### Run Online Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "32568bdb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "BatchEpsilonGreedy:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_1' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchUCB:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_1' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchLinUCB:\n", + "First 10 rewards: [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0' 'arm_0'\n", + " 'arm_0']\n", + "\n", + "BatchCohortThompsonSampling:\n", + "First 10 rewards: [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + "First 10 selected arms: ['arm_0' 'arm_1' 'arm_0' 'arm_3' 'arm_3' 'arm_3' 'arm_0' 'arm_3' 'arm_1'\n", + " 'arm_1']\n" + ] + } + ], + "source": [ + "results = {}\n", + "results['BatchEpsilonGreedy'] = run_online_bandit(eg, X, arms, rewards)\n", + "results['BatchUCB'] = run_online_bandit(ucb, X, arms, rewards)\n", + "results['BatchThompsonSampling'] = run_online_bandit(ts, X, arms, rewards)\n", + "results['BatchLinUCB'] = run_online_bandit(linucb, X, arms, rewards)\n", + "results['BatchCohortThompsonSampling'] = run_online_bandit(cohort_ts, X, arms, rewards, cohort_col=cohort_bins)\n", + "\n", + "# Print first 10 rewards and selected arms for each algorithm\n", + "for name, (rewards, selected_arms) in results.items():\n", + " print(f\"\\n{name}:\")\n", + " print(f\"First 10 rewards: {rewards[:10]}\")\n", + " print(f\"First 10 selected arms: {selected_arms[:10]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "09c3fee6", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 4. Evaluate and Visualize Results\n", + "\n", + "We'll create visualizations for:\n", + "1. Cumulative reward over time\n", + "2. Cumulative regret over time\n", + "3. Arm selection frequency" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "15484711", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHoAAAJMCAYAAACFPMH/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd0FOXbxZ/0hJDQe+/SpEvvXYo0FaTZFRVELNgVGzZUxK4oTbAhqIAivffee+8tpGfrd+7rN/lPNrvJ1mSzub9zcpLszszOzjtb3jv3uU9QXFycVQghhBBCCCGEEEJInic4t3eAEEIIIYQQQgghhHgHCj2EEEIIIYQQQgghAQKFHkIIIYQQQgghhJAAgUIPIYQQQgghhBBCSIBAoYcQQgghhBBCCCEkQKDQQwghhBBCCCGEEBIgUOghhBBCCCGEEEIICRAo9BBCCCGEEEIIIYQECBR6CCGEEEIIIYQQQgIECj2EEEJIHuDUqVNSuHBh9fPjjz/m9u7IxIkT0/eHEJJ38bf3FkIIIZ4T6oVtEEIIIU5jtVpl6dKlsnjxYtmwYYNcvnxZ4uLipECBAlKqVClp2LChdOvWTXr16iVRUVG5vbskH+BIrAoLC5PY2FipUaOGtGnTRu69914pX758ju9fficxMVF+/fVX9Z6xf/9+uXr1qgQHB0uJEiWkQYMG0r17dxk4cKCEh4dLfsIbIutff/0lFStW9Mr+EEII8R/o6CGEEJJjbNq0Sdq3by933nmnfPfdd7Jv3z65cuWKGI1GuXnzphw+fFh++eUXefDBB6VOnTry2WeficViye3dzjfgar52ZR9X+fM7OC+vXbsmGzdulA8//FCaN2+uBAeSkTVr1qSfN/jbm8yZM0caN24sTz31lPzzzz9y+vRpSU5OVuLPiRMnZP78+TJq1Ci57bbbZMmSJV59bEIIISSvQkcPIYSQHOGnn36SMWPGiMFgUP83atRI+vbtq67IFy1aVE3cMIlbtmyZ/P3333Ljxg15+eWXZdiwYSwP8kNeeOEF9RNI4Jz8/PPP0/+HoAAxYfbs2bJixQpJSkpSokKVKlWkadOmubqv+YG33npLCWwADp477rhDevfuLZUqVRKz2SzHjx9XQg+cPidPnpS7775bJk2aJPfdd5/kB9avX+/wvscff1x27NiR7XI4ltHR0cpVSQghJHCg0EMIIcTn4Co/Jh6YnKFE69NPP5VBgwbZXfaee+5R5VzvvvuufP/99zm+ryT/gnMTTjI9EHTgQNNEB5PJJB988IH8/PPPubaf+YEZM2akizwo6YTY1qRJkwzLwGE1ZMgQJQ6jrC4hIUHGjRunhLgOHTpIoGN7rtqey84sRwghJDBh6RYhhBCfkpKSIg899JASeXBVHqUYjkQejZIlS8pHH30k06dPVzkphOQ2zzzzjHI+aMIlSwp9x7lz5+T5559XfyOnC64dW5FHT+fOnVXZYVBQkMoAe/TRR5UbixBCCMmvUOghhBDiU2bNmiUXL15Ufz/wwAMqo8dZUKqhTa41tCwQdH3KCpTYYLn69es71WXmzz//lP79+0v16tWlbNmy0rp1a/n6669VTosGJpHIaEFQNJYrU6aMtGvXTjmPcJ+nHW2wXSyH3+6AoFq4TQYMGKCu4kMwK1eunMo4weR3y5YtWWaswHWlgZI6bb/t5a846roFIU+7HSV42YFSG235vXv3OjyGr7zyigpERnAsHB716tVT59PatWslJ4iMjJSaNWuqvyEiXL9+3eGyCAvG8YEAAXcJQoNvueUW5VZbsGCBU4+HY4eA4WrVqqnzDEIHjsGlS5fU/TivccxwnmeXtYRyya+++kqFnGN7RYoUSRdS9CAcHecAStjwGsC5g+ybZ599VpWwOTq3+/Tpk34b/rY9b1zt5IR91YSap59+WmrXrp3tOngdjhgxQv2N9xs4gDSwLYRoY1+GDx/ulNCEclIs/+KLL9pdBscUr3u81mrVqqXGuGrVqnL77ber/U9NTXX6dY4StOeee065x3DMcd/u3bslp8juPcr2tR4fH69ua9WqldpfvBfC9YYMNj3IX4MTrkWLFup8wmsBDqxdu3Y5tV/IcIPACudWhQoV1OsA5+YTTzyRo8eHEELyIizdIoQQ4lO0iQOuttublPoDmExOnTo10yRj/PjxSkiYNm2aKtl5+OGH5Y8//siwHCYcKBfB5GXy5MmSW0CE0U+49RNSTCTxg5wkhNq+9tprPtsP7AOOJybXEMV69uyZ5fJauDGEKYg3tnz55Zdqf7VsJ42zZ8+qn7lz56pMFpT5hISEiC/Rbz801P5XqHnz5qksKpQR6YH4sGjRIvWDY4IwclsRUwOTW9yv59ixYzJlyhQVVo4fZ0HWFQSQrCbXaWlp8uSTT6rzwxYEpOMHrwG47JwRSjwBgqkm0kBcQzC7s+D9BS5ATWDW1kUZE0QVlNv9+++/Kvi9UKFCDreDc0pzbN111112BdWhQ4dmEr8g/iEPBz94P8HjQfzJTtCD4xEZZXkBvOb69esnR48eTb8N2VUIwl6+fLl63rgfoi2O3fnz59OXw3sCni+Ww+se4pyjc2DChAmqxNfWOYdjjh98riAjDAIZIYSQzFDoIYQQ4jNw5XfPnj3qb1z1zW7Skxv88MMPsnXrVuV2wCQWV45xRf/jjz9Wt6P9MCYVmLhA5MGVa5SewVUC8QRZQpgIY4IJkaNLly658jxQGgfhAM8DEyi0BI+JiVHukgMHDih30pkzZ9TzgqsDIdcacPxgcgoRAlfgwe+//y6lS5fOFNyaHQULFlSuht9++01N6iB4YD/sAfHh4MGD6m8E6dqCrmsI5AZwTcDBg/MIbgu4EJDjgnwWjCEe98033xRfHt8jR46ov9Fy3V5AOM6P+++/X01U4SCBMAgnD5xVFy5cUMcEIgKOC5wzEE9sgVioiTxwMECYg5sHYgwmyAiLHjlypCqJdAY8DoQJTLrhPsGYYl/wfDSQb6O5rzp16qTO78qVKyuhBWMEsQ3nOAQsOFd69OihloVLA+fN9u3blctCGzOcT3qwnLPgfECnM9CyZUuXgthxrHFuQxTD+47+3MP5BeEFxxHjpLl/7KHlL+Gca9iwYYb7EPoMoQ5iEV5vEBnhesL7Bt7vMEbffPONOldwHBHi7UhUgmgCkQdt4V999VX1fPE3xGO4rvwRnCsQbyBuw7EGEQ1OMLwP4vmPHj1aHbPBgwercxQuNLgjUYK7dOlS5eDDGDz22GPqvMHztQUCO44hgMsJ78twA+F1h/MDrw+8N7/zzjvqOOEYEkIIyQiFHkIIIT4DE0xtQmk7YfIXMGGAE0BfCoZ97dixoyoZgDjy+uuvK2cEltG7krAcJjGYjGBSiavZuSX0oJQHLiR7E2NMyCA6YLKLied7772nSig0hwomrHDUaF16ACbMzgg79oCoAFEDEz2UKuGxsnLzwO1lm9t06NAhdVUfQGDAGCDjSX/sUdoHtw/EEU0AgRDkC2bOnKkm9wAlfrbAzYFJLkQePJcvvvgiwyQW+wuBAOUucDwhd2bVqlUZShlRlqWdhxAOMDGGoKiBdbt27aoERVuHkyNwTkDc03ei0r8WIZZB5MG5ALESXa30QLTBpB3Pad26dcpBgXMcjiZM3nHeaMIMwDnjSfivvnzPnfcMlBxC6MH7DgROiDAAxxkiF5xVOO8cCT14z8Ixc+Tmwesf5wHKyTCG+vHRHgeOFjiIIATDhaWJlbZArMT6cBnpX2tZ5RHlNhDQFi5cmKHrHMqp8H6B9xe8D+L8wOsAohcEGv3zKlasmHKsQeRCtzRbF+LKlSvTRR68Tz3yyCMZ7sc5AbEdt+M95o033lD/szMjIYRkhBk9hBBCfIY+xwROAH8EzgtMFmzBlWpNoMDzwMTGXukZJmpa1gaubOcWmEBlNdmB6KA9T4hXmtPKF8AVoo23JubYgpIMuFsAxDJkfeiBMwT5SBANbEUePZhEw/mC7SEfyJug1ATCA/JsMDnVxhtuBlsg8sHRULx4cVVyYs+pAOBK0hwvKC/Sg/3Xsl3grLIVEQDER1fKmZBr5KjdOCbjn3zyifoby9iKPBoIRIYTA5w+fTpDVpO30YtGcEK5in4d/bYgZMHRBCBY6UuK9GhlcfbER7y+tdc4hEV746MJH9oYZZdPBKHSXUE1N8B7oF7k0ejevbsSJwFchC+99FIGkUcDJW9wijl6v4QoCeBMtBV59GOJUs2IiAglLNmW0xJCCKHQQwghxIfocyf07X79CUxuHXX20mfG2HNx2C4XFxenfvwBlEdA0EGpA1wK+NEHRvtS6IHbQztecK1oAcJ6IBaghMiRc0IrJcIVf0ciD8DYNWvWTP29efNmj/YbAoA+RBglRxBKEK6LjCa4NeBQsjcxR9kbgOMmu3Mdzhx7+ws3A0CJCsrfHAGHjbPYO7YaODfgOgFwR2VXFoWSOXv77av3DEcZRlmBEj4N25wk7VhAFIQbxBa8PrTbESBsO87aGEPQsC1PczTGOMfxOrQHxMCs3lf8EU0ss0fdunXTRTJHy0E01Ep4UQanB0KpFq6e3fmI16cW0u3L85EQQvIqLN0ihBDiM/STLn9td5xVqY8+W8PZ5TBRza0yAoSiIosHThlM4vU5LLZk1TXKG6CMAyUY2AfsDzI57OWg4Oq+7aQOrhG4ArTyDfw4w+XLl8VXIAsELg1kH9mC56gJZ3DlOOssst1flBppE2ZH4qN2P0QCZ8q37HWd09CX6tkL8s6N46x/z8D57IlQZJsNhbIf5O6gLBDOHZQE2gp9KClyJJBpxwvCjSuvcRwvze2iB+VOED7yEs68D2bnLtSWsw2gRjaR9p6FbCl9F8DcOh8JISSvQkcPIYQQn6E5ALRWu/5IVhMtvZPE2eWyEld8CfI+4CJAeRYyRrLbD2fDfN0FeRzapNC2fAvlSVqbcZR82IbVaiKPq3gqJqLkRuuahEk/SkJQgoKJKzKakAGEkGpbcB8cP65iOwaaGwyPlxUoXXE2rDerCXduHees0D93dybw+nXsHUdNwEFJniasaWjnqSOnjbePV17MlcnKraa9D2YnXmnL2b5H+eP5SAgheRU6egghhPgM5KtgUoov9Dt37szt3QloHn30USX2oGwCORgDBw6UmjVrqswYTFxxO0pWNPFNX8blKxCSinBhOCHQjlkTflCWhTINbRlb9BNAdJ2yt4w9HOXiuDKJtQ0SRrkWxAEEzEKsHDt2rCoV0zs09PsLJxNalfsLWZW96fcboczOBln7UqDQl0u6856htZHH+45W2qMH5xLyj3D+Q9hBtyugdeMCGGt7z1E7Xnhd2euY5ghHGTxZjU1+RH8+wsXXtm1bp9bz17JgQgjJTSj0EEII8RnIGkHpCCZsmOijGw7KFTwBggUmaRAt8sJVXv1kzlf7jNbXWrApOjo56vID50lOAtFD6yKFUpkXX3wx/W8AVwpCV23ROzEwYfeki5M3wET9gw8+UK2lIVChjbvWGQhAPNPOS/y4u78QF5BnpA8RdjQh9kYWlP4447Wa28dZnwWE0kKc03iezgpLKMnCewy49dZbM5VugYoVK6r8HWwbQg/af2Ps0PlKO6Y4bx0dL7RNR8mRPxyrQEN/PsIVxGNMCCHuw0sJhBBCfArcJQATYITaeoo2ectuoosJmT+gn2xmtc8QgbRJqqvoS1CyCnfVZ7LYAxNeb1K5cuX09tZaWQzEJrQNB2hDbc+FA2EFwkNudzLTg33VAngR2IsMJA3k6WjukY0bN7rtloLIAVB6h45jjsD9cKB4CsQQDU+OszfPG2zrnnvuSS/x+/77751eV//+or3v2EMTcpC1oz1vTXzEedejR48s847QsQvuOeJ9N5d2LvnL654QQvIqFHoIIYT4lGHDhknp0qXTW1CjC5OzoJTCNpBVK4PISrRA/ga6TPkDWgen7Pb5n3/+SS9n8qTkIStXUHaTZq3tMXAm6NcZtEyUEydOyJYtW2TevHnpIoajjlBw8WiTbeTl+EvZ37PPPpsuymntxjW0LlkIktbyh1wFZWIA54HW4ckeP/30k3gDCD3ly5dXf8+cOTNTOK6zePu8QRmilvOCNtpw6mQHMpWmT5+u/sb7jSYWORLt0JpbEyBv3rypHD0AweDafbb06tUr/e8vvvjCxWdFsgNlps2bN09/74egRgghxD0o9BBCCPEpmLChzAWTd0yQhwwZYjfQ1jaU85lnnlHht7bOhtatW6vfW7duVZM7W+CacbZbS06htVrG5B0lbLacO3dOnnvuObe3r7UrBrNnz7a7DES2rMQDUKpUqfS/Icx4A7RZ1jpIwTWhOSe0EhpHIJsHbdrhjrnvvvsytWLWg2WQ+wOBz5f07Nkz3dWBc1jvwII4obmQkOOTnTgFAUtrJa2B14YmMqCkyF4YMVpJf/fdd14rK0SpH8Ck+oEHHshSKITDBq9l/PbleQPx6Z133lF/Y38gvmQlkqItPY4d3l/gCPnyyy+zzG2B8Nq1a1f19/z585VDS3NIZZUH1aFDB5XPBHAcfvzxxyyfB85Z2yBy4pyYinEfPnx4lmWMELjRvQ/vn4QQQjLCjB5CCCE+p127dvLZZ5+pkFp8gb///vvV/5jAwVWArBY4d1BKsXz5ciVIOHIXYNIP0QICECZ3mBhA/MGX/m3btqkr7QjNbdCgQXowa27z8MMPq+eECTLaWI8fP161ekbXJZQoYJ8hViAM154QlB14rsizgIvphx9+UGIXylPgbMAkCOIKrpBDWEFpkSMwFnBnYD/ffvttJdAgdFjLGSpTpozL7aCRt9K5c2flWMKkLCEhIX1CnVXJD0qhMNmHAAbxoE2bNsod1qlTJyUswDkCcQIuoT///FM5aeB00Yf5+gJNgMT5BleP5uyAGwECgzY5RfYQHEvoKoZjiOUvXryoBIuFCxeqcrv3339fPS8NHF+cG+ichucDYQGCFzqYQYhYtmyZfP7552pc8TqCIOpp2RRyhyCU4PxYvHixKrXDawyCBgQRvC4haOE8hVMJ7hdbtwyeX7ly5dS5NmXKFClbtqxqQw9xF5QoUcJuXk5WYB9QHvXJJ5+o44ZzCGWJcNXA1Yfjefz4cSXU4NwCOE8xJh07dsx2+xgbPB+UEuJ4AzyH7AKAv/32W7UvGGMIynPnzpVBgwapgGYIk8gWguC4ZMkSJUT37t3b6TBxIurYPvHEE+rzAe/n2vmI93hk+OA9E+cFBM+//vpLZVpBNMXYEUII+R8UegghhOQIEGWqVKmiJu67d++W7du3qx9H4Es9Jr2aS0KjVq1aqmsO7kOJC5wPenAlH1fbIaz4i9CDCbs2eblw4YJyfNg+VzhxMOF0R+jBZB/5JH379lUiD8qj8KMHQhA6BWk5MPbAZPyRRx6RyZMnq2Nnm/eDiZWznXD0QHSyLU1zVLZlK5BFR0ercwbCH56jo5wnTPJzovsOjjGOITJ6IKBh35BFBCBC4DYcQwgBs2bNUj+OsCd+QNiB4AnBDkKW5nDQnysoUYKgZFs25Q44dyCcQjyCiHH27FkVNu0IjIcm4OgZN26ccgdhEm4rBEGcyiozxxGvv/66Ej/xG6IWRBX8ZBWYbS/c2x4Q4AoVKqSEK/wACDbZCWcYa4g4I0aMUIIOhGn8OMJVgYuIen+HQPzuu++q1xHK9/BjD2R8efoaIISQQIRCDyGEkBwDjhJk9GCiBPcA3CW4IgtxApN0OBrgdMEkDJNmR1kZmEhjso0JJEq4IAKULFlSXckfPXq0urqeXZlSbkxemjZtqspuIHTBoQHnA54r9tnTK9Jw46xZs0Y+/vhjdXzhgihYsKAq60ImyUMPPeTUhAiTanRGmzNnjhIzIM7oM4DcLXmCYKcJPXAgQbBzBggEyOuB8IEJNTqM4XzBBA9jjvMAjjEIMFrejC+BEABBA8fTZDIpxwl+NNCaGyIZMm+Q+wLnDlweEKLg+sHzhjsBzi64XuxtH2OI0iKcK3AAwcWAcwW3jRkzRp0r2rG0FULdAU4UtLOGcwIiEkrKIDbBfQVhB4+HkjW4qfC6tOfqQtkXnDsQE/fs2aOcMjg+ngIXF5x/ENBwPOFag+iD44nHw3mP82PgwIEO3y/sgWXxutByfZwVHwFeU6tXr1ZOMjih4DyBixDPFy4ovH7giMJ5r5VtEteAcAgnFM4nOM7g6sM5j/cwiJJ169ZVAjpe9/puXYQQQv4jKC4uzr3WEIQQQgghJMdBiRQmuuDTTz9V7hJCCCGEEA2GMRNCCCGE5CH05UtwiRFCCCGE6KHQQwghhBDiJ6BMCzlOjkBZGLJoAMqWkL1ECCGEEKKHGT2EEEIIIX4C8nwaN26ssnCQ94McH+QRIXNp6dKlKtwZYhCyfJD7RAghhBBiCzN6CCGEEEL8MH/HEWh7j8BmBBUTQgghhNhCoYcQQgghxE9A56aFCxeqzmnbt29XHabQwQqdripUqCDt27dXbee1lu6EEEIIIXlS6Pn5559lw4YNsnPnTtVW02AwqJa6aLnqiJMnT8pHH32kWrFevnxZChUqpFqaPvjgg6qdpi1o2/nVV1+pVrK4UoYWwC+88IJq82sPfPmaOHGibNq0SX0pQ438448/Lv379/fqcyeEEEIIIYQQQggJqIwe1KCfOXNGihUrJqVKlVJ/Z8WKFSvSRaAePXqoq15xcXGyb98+WblyZSah58MPP1SPgStl9913nyQmJsrvv/8u3bt3lz/++EOJPnpWr14tAwcOlMjISBkwYIAULFhQ/vzzT7Xu2bNnZfTo0T44CoQQQgghhBBCCCEB4OiBOFO1alWpWLGiqkmfMGGCQ0cPRKDWrVtLiRIlZP78+Uq80QP3TWjo//StY8eOSfPmzZUYtGzZMuX8Abt375auXbuq2+EmCg4OTl+/WbNmcv78eWWrRscLcPPmTencubOcPn1atm7dqvaVEEIIIYQQQgghJCfJE+3VO3To4LRwgnKt+Ph49dtW5AF6kQf8+OOPSrx5+umn00UeAAEHrp1Dhw4poUfv5jlx4oQMGjQoXeQBWHfcuHGqrGzOnDluPlNCCCGEEEIIIYSQABd6nMVqtSoXT9GiRVVYITJ9PvvsM5kyZYpyBVkslkzrrF27Vv3u1KlTpvvg0AHr1q1ze/lAIjU1VY4fP65+k8CCYxuYcFwDF45t4MKxDUw4roELxzZw4dgGJqn5ZFzzREaPs5w6dUp1pmjUqJGMHTtWpk2bluF+OHDgtilXrlyG0i1k7CD7x5Zq1aqlL6NfXn+fHmwD28KJ4wx57eSCW8lsNqvfJLDg2AYmHNfAhWMbuHBsAxOOa+DCsQ1cOLaBiSEPjysygvOl0HPlypX0fJ0jR46oHJ9evXqp/ByUck2fPl1GjhwpS5cuTV8HZV7I87FHTExM+jL65UFsbKzDdfTLZwVyfnCS5TUuXbqU27tAfATHNjDhuAYuHNvAhWMbmHBcAxeObeDCsQ1MLuWxcQ0JCVG5xflS6NFKsyCevPjii+lhzYULF5bJkyerrlsISkbmTsuWLXN5b0XKli0reQmonnhBwLkUHh6e27tDvAjHNjDhuAYuHNvAhWMbmHBcAxeObeDCsQ1MDPlkXANK6NG7bG6//fZM96PVOoSeHTt2pAs9WMeRAychISHTdrW/s1oHwpK3rVf+BF4QeXXfSdZwbAMTjmvgwrENXDi2gQnHNXDh2AYuHNvAJDzAxzWgwpirVKmiLE1A30FLQ7tNn42DrJ3ExES71i17eTz2cns0sA1syxVLFSGEEEIIIYQQQoi3CCihB4rcbbfdpv4+ePBgpvvRKh3oW7W3bt1a/V6+fHmm5ZctW5ZhGXeWJ4QQQgghhBBCCMkpAqp0CzzwwAMqg+fdd9+VX375RSIiItTthw8fltmzZ6uw5C5duqQvjxwftF+fNGmSKvfSXD8IdJ47d67UqlUrQ54P2rZXrlxZfvvtN3nkkUdUJy+gBT7DAjZ48GCvZQ4lJSX5TXcu7A+eH56rVtZGAgOObWDCcc2bFyyio6MlODigrsMQQgghhJAcJE8IPTNmzFDiDdi/f7/6PXPmTFm7dq36G0LMiBEj1N8DBw6Uv/76S/744w9p06aNdOrUSeXp4DYIJl999VWGDJ3q1avL888/L2+99ZZavm/fvqr86vfff1f3I8RZ/4U7NDRUPv30U/U46Og1YMAA1VL9zz//lDNnzsibb74plSpV8soE7dq1a2rbxYsXl6CgII+36Y19QngVJo6chAQWHNvAhOOat7BarepzCu/9xYoV45gRQgghhJDAFXog8syZMyfDbRs3blQ/GprQA0Fk6tSpqoRr1qxZMm3aNOXqwf/jxo1TYo4tzzzzjCrn+vLLL+X777+XsLAwJR6hc1fDhg0zLd+uXTv5559/ZOLEiTJv3jwxGo1Sp04dmTBhghJ+vAGcPBB5oqKivLI9Qggh/g0+v7T3fHwGwIFKCCGEEEKIqwTFxcVZXV6L+JwrV674jZNHg+6AwIVjG5hwXPOus+fq1atSokQJh8vA+QMXaYUKFQK6Y0R+hGMbmHBcAxeObeDCsQ1MUvPJuPKbvx/jTyIPIYSQnIHv/YQQQgghxBMo9BBCCCGEEEIIIYQECBR6CCGEEEIIIYQQQgIECj2EEEIIIYQQQgghAQKFHkIIIYQQQgghhJAAgUIPIR4yatQoKVy4sJw6dUryGhMnTlT7vnbt2gy347ZevXrl2n4FEj/++KM6nvhNCCGEEEIIyT2s5lS0OJVAJzS3d4AQe0A0adCgQabbCxQoIJUrV5a+ffvKE088IQULFnT7MTD5bt26tSxcuFBykjVr1kifPn2yXCY39sufgPA0c+ZM2bx5s1y+fFmMRqMUL15c6tevL927d5c777xTYmJicns3CSGEEEIIIXkA8839krr7dRFjvJQOLiCWyAdFKt4ugQqFHuLXVKlSRe666y71t9VqlWvXrsmSJUvk3XfflWXLlsk///wjISEhkhdp2LChEi3sUbFixRzZh4cfflgGDhwoZcuWFX8gJSVFnnzySfnll18kMjJS2rZtKz179pSIiAi5ePGibNy4URYvXixvvfWWHD16VIKDaUokhBBCCCGEZMZqTBDDydliOjMv/bagUt0kKdkqMSd/EEvROhJcsLIEIhR6iF9TtWpVeeGFFzLclpaWJl27dpUtW7Yo50f79u0lL9KoUaNMzy2nKVasmPqxWCxiMBgkt4FLa+7cudKpUyf58ssvpVSpUnYdUS+//LLaZwo9hBBCCCGEED2W1CuSuvN5sSafy3zf5eWSXPpFKVTnfpGgFAlUKPTkUbouuJzjj4lKRqvFKkHBQRKUxXJLepf06X7A3QGnx+7du+X69evpt69evVp+/vln2bRpk1y4cEHdVqNGDbn33nvVj73SqXXr1qkSLo3PP/9chg4dmv4/yqe+++472blzpyQnJ0vJkiWlZcuWMnbsWKlTp06G/YLj6KuvvpKpU6eq0jMsO2zYMHnuuec8EiS0MrYhQ4bImDFj5LXXXlPOFrPZLLfddpv6H+4gPXC/fPzxx8r9dP78eQkPD5fSpUurkrDXX39dChUqlJ7R895778mff/6ptpUdcFR98MEHsmjRIvUYsbGx0qZNG/UcbY8HsovmzJmjjh2cV9kdl1WrVimRp2bNmirPJioqyu4+YOzh5goNDc00puPHj1ciERxf27Ztk/j4eImLi0sfn1mzZqmf/fv3i8lkklq1askDDzwgw4cPz/Q4ri5/48YNeeONN2TBggWSmJgot9xyi4wbNy7TcseOHZOmTZtKly5d5Ndff810f0JCgloXLiuImYQQQgghhBAny7O2P4NJq8NlgqwmKXTjN5HKb0twVBEJVCj05FG2XDFKfgXOEzh5goKCVGaLxuTJk+X48ePSrFkzNUm+efOmLF26VIkyR44ckbfffju9LAqCAASOChUqyD333JO+Df32XnrpJSX8FClSRAUTlyhRQs6dO6cECQgrtsLGq6++qoQjlGNBbIBIBMEB+TKvvPKKx8/75MmTatsQfSA2nDlzRubPny+33367EmogHgAIUlju9OnTaj969+6tjhlEFghho0ePThd6XOHq1avKSXXixAkl7qDkC9v8448/5N9//1UiDUQwW5w9LhBUNFePI5FHQy/y6EGmz0cffaTEIIh7Z8+eTRdtHnroIfntt9+kWrVqMmjQIAkLC5OVK1eq43Ho0CFVDqbh6vI45jhHIAhBMIOghnPl/vvvV89ZD7aniVXYv/Lly2e4H4+ZlJQkI0aMyGZECCGEEEIIyd9Yks9KypYxIuZkp9eJTN0vcmmNSOVuEqhQ6CF+DYQbuE60yTccPJggw7ED90T16tXTl500aZIKatYDFwaCe+G0efTRR5WwU6lSJVUyBaEHoo+98ik4UCDyQMyBQ6No0aIZtql3Emns2rVLCRpwzgA4Vho3bizffPONEpbgqtGzY8eO9OdmC9weEKz0bNiwQZ566inl4NGAyweCC5w+69evV7dBiIIAA0eN7fbhNIFg4Q54XIg8cKlAvNGAyIMcpccff1y2bt2ayb3k7HGBSAPatWvn1v6BFStWyGeffaYcQ3pmzJihBBS4tT755JP0YwABDIIK1oGYozmjXF0eIiNEnpEjR6q/Ne6++241Prbcd999yoEGcev555/PtK84JhhbQgghhBBCSGZM17ZI2i43L6ZbrVLwp9lifq6LSIBGQVDoIX4NhAUIMrbAHWKbzWMr8mjOD0yqIQCgvEfv3skKlBkBOE/0Io+2TZQf2fLss8+mixkA2Tdw26B8CY6iunXrZlgeJU34sQccN7ZCD257+umnM9zWuXNndRwg7mBb+hIue64Yd7uUQeCAYwfH4plnnslwX7du3aRjx47qGKOkrFWrVm4dF3TXAvplNSC27dmzJ8NtcNDceuutGW6D28lW5AEQlaKjo+XDDz/MIHRBUIGrCMIehB3t+Lm6/E8//aTue/HFFx2Ojx64rHAOoURNX8K2d+9eJQD269dPdRkjhBBCCCGE/IfVECcp254Wa0rm7B1niDhplpgtRjlqLSOn23WVuudPiqV8VQlEKPQQvwYTZQgMGnDSQEyAC6JHjx4ZSpaQbTJlyhRVGoQyJ5S/6EGmjLMg3wVZQChRchbbnBxQrlw59RtlZLZAgEKOjrNA1LAn1KBcCkICMouwDxBaIJZg2xAOIIqhlAj5Mih3c4fDhw9LamqqKjlCi3tbcDuEHogxtkKPq8fFHhhTCEN64MayFXrgFLIFZVVw25QpU0a5c2yBQwtAdHJneeQAwUGFXB174dHa+OiBeAS3EMZo+fLlysEFpk+frn7DGUQIIYQQQgiBAccspnOLxHB8uogp0eX1C+wxSYGDJgn5/+quAxVrSokOvcRS9n9ZrYEGhZ48SrMS7pXf5EQYsy+BowRuEIgNcD0gJwU5NXCcwCWBMiFM/lEyg2XReh1ZNRAJ0K3LWTB5x0TflRDlmJiYTLdprd8RnOwp9lxE+ts10QTOH4Qwv/POO8p5gtIqgCwY5BU9+OCDLj82RDSAnCJ7aAKHtpw7xwXbxlhBkLN1Z6EDF34AxJEJEybY3Q97+4cwZpT9IZTanjtMQxMGXV1ee86OHDiOxg1iDoQklGpB6IGQhnBmlBZ26NDB4eMSQgghhBCSH7BazGI887sYj/1XbeEqRf5Ok/DLmMVmpO/ZtXLTgCoACj3Ez/B1Zyt7aC24UaKS222tmzRpon5v375d/UYXKIg86IYEV48eOIJs3SDZAbEEpUT+1MJbK21ydLs+YBlZRBBGsP9w9cBt8/XXX6uyK3QZQ76MK2hizZUrV7LcB3uijrM0b95cCT3IrrFXhucM9hxL2j7BWYQw5exwd3mEVbsybniOCGr++++/1XHFGEFkQhi1u84rQgghhBBCAgHTta1iOPiJWNPsf8fOiqJ/pknYjcwCj0awxSwh50+JVK4hgYp/zGAJcRF9y2wtywfA7WMLQoztAQEHQogjIQkOIHT38hdQmoUwZUfPz7aMSXuOuP3JJ59UbeIBhAVXQcvzyMhIJayhtMkW7Tjpu5a5ipatgxBsuFu8BYQYlK2h/Ew7b7y5PFrMw4WD4PBLly45ff4BdAZD9zEIkXD2wOmEki5CCCGEEELyI5bUK5K65y1J2/WySyJPoRUGKTk9VUpNT81S5Ekc9JDseOlrMTR2PqIjL0Khh+RJIAYALQ8GDhaA/B5bAULLPbEFbdPRAtseWnkTsoBu3LiRKaPFkUvDl6A0C53F9KADGfJf0B1My8I5cOCA3f3T3DjIHnIVuLjQPeratWuqfbketLDHflStWlVatGgh7oLQYjwGWpdD9LEnmmhlda7yyCOPKIEKgpdtdhNAphNydtxdHqWCcLuhXE4P8nds83n09OzZU5UIfvHFF6ozGYKt8T8hhBBCCCH5CUvSKUla3kNS1g8X8xXnLrZHnDZLsd/TlLgTedriMF7EUryUpDz1jiROXympXQeKBAW+DMLSLZJn2qsDiC6bNm1SZVooQXr99dfV7QhmRjgvWltD6Khdu7YKy128eLHK7vnjjz8ybRttvOfNm6c6ccH1AjcFJt716tVTE+7Ro0erMjAE/GIbyH9BbgtKi1Be89hjj3n03LJqrw73DFqp24b6ohsYWpijIxfKnJBPhO5an376afpyKAFC+3OUQqH9PLKKIEzAyYPtPvTQQ27tL3JxIEagExVaoSMEW9sHZCZBfPO0zA1ty7ENZNWggxZCnuEmgtAE8QqOIowvOnfhdmdB8PWWLVuUcwbnD0QlCCrYJs4THFM4nuDMcWd5CELoDAZR8eDBg0qAhIiI8wth2DgP7YEObhC1PvjgA/U/Q5gJIYQQQkh+wpxwRFK3PSNicS5PNeSmRQpuN0nEOYsEORGDauh5txgG3C8S7vrF7rwMhR6Sp9qrw41StmxZeeCBB1SwsObkQTcqdOCCwLF+/Xrl5EEXpG+//VYJNPaEHrROBxBuEFqMMi5sG0IPePPNN5Wggm1gfZRyIXQY4gPaiXtKVu3VUQ5kK/Qg0wVumtdee02JDAgyRlcwiF36zlboVAYBBsfhr7/+Uo4UiBT9+/dXggSOizsgbBjOnffff19lIqEkCfuJNufjx49XriJPgWiF4z1ixAiZNWuWElkwlniuEHcwNnBb3XnnneqxnQWZN8gsgoAHMQbCC44Lzg04kTDW+gBkV5dHK3Z0BoMYBsEHQiSO8/fff68cSI6EHgChEUIPzr2uXbt6cPQIIYQQQgjJO63SDce+F9OF/xrHOEP0dqNE7zNLkCWbbUdFK3HH2PkOkZD8KXkExcXFOS5gI7kGymwcdTjKLfwpjDk/gRIhuFuGDBmS3nnK23Bscw+IiHDyPPvss/LSSy95ddsc18D9DECO1ZkzZ5TYDaceCRw4toEJxzVw4dgGLhxbH7ZKP/+PGI794HSr9PDzZim02ijBTph+jC27iGHwKLEWLpavxzV/yluEEOIHIEwc5Woo4WLZFiGEEEIICWTM8YfFcGiKWBKOOLV85BGTxGwzOSXwgJRn3hdz/ds828kAgUIPIYTkMPv27VPlXChNQxYQMoHKly+f27tFCCGEEEKI17EaE8RwfLqYzi3Ef06tU2RRmoRfyX5Zc7U6knbvOLFUrO6FPQ0cKPQQQkgOg2ymN954Q+UMoWMXMn8IIYQQQggJJCxp18R4co6YLq8WMWbfOTfskkViNholzMl0mZSx74i5YUsEbHphbwMLCj2E+Dno7BQXF5fbu0G8yNChQ9UPIYQQQgghgYY54agYjn4nlhv2G8/YEpxslUJrjBJ+MeuUZWtklKQ+MF7MzdpT3MkGCj2EEEIIIYQQQgjxCPPNA5K6/RkRq9m5VunxFonZZJKI8xbn2qQPfEAkLNwLexr4UOghhBBCCCGEEEKIW1iSTknagU/EEn/AuRVMVoneY5LovVm3Slf5OyOfEkulGl7b1/wChR5CCCGEEEIIIYQ4jdWUJIbDX4np4hKX1gs/Y5bYzSYJScw6hyf1/mfF1LanSHCwh3uaP6HQQwghhBBCCCGEkGyxmlPFcGyamM7Od2m94ASLEngiztq38FgKFxPDkMfE1LwT83e8AIUeQgghhBBCCCGEOMR8c7+kbhvn1roFtxilwCGzBNmJ7rEGB4ux60Ax9L9XJCra8x0lCgo9hBBCCCGEEEIIyYTVGC+GYz+I6fw/Lq9b9M80CbvhuETLXKOepI14SiwVq3m4l8QWCj2EEEIIIYQQQghJx2q1iOnCYiXyiDHe6fUiTpklZotRQpKyXi5l9JtibtKGZVo+gkIPIYQQQgghhBBCxGoxivHELDGe+tnldQsvNUjEOcdttCwlykjasDFibtjSw70k2UGhhxBCCCGEEEIIyeeYr++UtMNfiDX5tNPrBCdZpci/BgmNz7qLlqHvcDH0GSYSHuGFPSXZQaGHEA8ZNWqUzJkzR3bt2iWVKlXK7d0hhBBCCCGEEKexpF0Tw5FvxHx5ldPrRO82SfROkwRloe+k3fmQGLsOEAmL8Js26VZr1oJUoOAfR5sQG06dOiWFCxfO9FO2bFlp1aqVvPvuu5KYmOjRY2B7vXr1kpzmxx9/VI89ceJEt5c5f/68TJgwQdq1aycVK1aUEiVKSK1ateSuu+5S6xoMhvRl16xZY/dYli9fXjp16iSff/65GI1GnzxXQgghhBBCiH9itZjFePp3Sdn4kFMiT8RpsxT7PU1KTU+VgjvsizymBi0k+c2pkjhthRh7DxWJiMp1kcdkMsmqVavk22+/lVmzZsm6devk2rVrEsjQ0UP8mipVqijxQlNf8YJcsmSJEnqWLVsm//zzj4SEhEh+4rfffpPRo0dLSkqKNGzYUO6++26JjY2VS5cuyerVq+Xff/+Vn3/+Wf78888M62HZ7t27q7/NZrNcvnxZHb+XXnpJNm3aJN98800uPSNCCCGEEEJITmKO2ytphz4Ta9LJbJcNSbBIzCZT1vk7xUv/l7/TqJX4C2lpabJ06VJ1kVwPLnKvXLlSBgwYIFFRURKIUOghfk3VqlXlhRdeyPSC7dq1q2zZskXWrl0r7du3l/wC3qgefvhhKVSokMyePVs6duyY4X6IYQsWLJCZM2dmWrdRo0aZjmVcXJxySEEUguBTo0YNnz8HQgghhBBCSO5gurxa0va+4/TyKM+K3muSILP9+62hYWK8fbAYlHsnUnIbzIdOnz6tLn7bo0CBAlKtWjUpVaqUhIWFSaBCoSePEvXGYzn+mHDmRVksEhQcLFk1wUt59Quf7kdERIS0bdtWdu/eLdevX0+/HW4WOFngTrlw4YK6DcLFvffeq370pUx9+vRRf8O2hzImDZQxDR06NP3/hQsXynfffSc7d+6U5ORkKVmypLRs2VLGjh0rderUyfSm8tVXX8nUqVNV6RmWHTZsmDz33HMS7AW7Ilw4zzzzjFgsFpk2bZpdgSsoKEg9t27dujm1TTz3Jk2aKJUbbikKPYQQQgghhAQOmKOYr6xxSdwRk1WijpolZqtjgUdtOzpGkl/9Uqyly4s/gIvY69evl3PnzjlcBnM6LIdqh9DQwJVDAveZBTghx/ZLfgX5M3DyQNSoX79++u2TJ0+W48ePS7NmzVSWz82bN5UDBqLMkSNH5O2331bLIdNm/Pjx8t5770mFChXknnvuSd+GfntwuED4KVKkiMryQQ4O3jRQ34k3Bluh59VXX1XCEcqjkH0DkQglZrAGvvLKKx4/bwhUJ0+elObNm2frYoIY5gx4k9u+fbtER0dL9erVPd5HQgghhBBCiH8IPKaLy8Rw4EOX1os8ZpaCW40Skmr/flOj1mLsPkjMtW4VCfaPCA3Mt3BhHkYAXBTPjjNnzqi5YmRk7juQfAWFHuLXQLjRAonxZgUHD7J54Nh54403MogTkyZNksqVK2cK3rrzzjuV0+bRRx9Vwg46Y6GECUIPRB/bciaA7BqIPBBzUApVtGjRDNvUO4k00HULQk/p0qXV/3DyNG7cWGXfQFgKDw/36Fhs3LhR/YabyR127NiRfizxBoiMnsWLFytV++OPP1Y5P4QQQgghhJC8jenKBjEcmyrW5LNOrxNywyKxm4wSfsl+VypLybKSNvxJMd/aXPyF1NRUdWFfq+Zwhfj4eFW+FahQ6CF+zYkTJ5QgYwtcM7auFluRB8COd99998mKFSuUI0bv3skKlF8BOHL0Io+2TZRl2fLss8+mizygWLFicvvtt6vW63AU1a1bVzwBwgwoV66cW+tD5caPHriiEHbdtGlTj/aNEEIIIYQQkruYrm6StN2vubROkNEq0btMUmC/2W4XLWtYmBh6D1M5PBLuXNWAr0lKSlIX5u1dfM+Ktm3bqov+Z8+eVQaAQCZPtFdH7grKbzp06KAm2MgVQQtpZ0CpCybGWOepp55yuNwvv/yiym1Q8oPBRycj20mxHpS7wCkCRwjW6dKli8ybN8+t50cc07lzZ1VepP3A4YMQ4gMHDkiPHj1k69at6csmJCTIO++8I61bt04fc/yMGDFC3X/x4kWnH3fbtm2q/KlNmzZOr4NyLls0UQbWwNwGgpd2HG/cuCGHDx9WTid0MUO4NXKFCCGEEEIIIXkLS8pFSd39ussiT9glixSbnybR+xyIPJEFJPntaWLsN9IvRB5klmKOjvmgKyJPp06d5MEHH5RbbrlFXejOD+QJR89bb72l6ujgkIC9Cn87A8pTRo0ale1yH374oXoMqHqYDCcmJsrvv/+uXCN//PGHtGjRIsPyCP0dOHCgqulDS7aCBQuqrkVYF+ogWl/7GnO1jPkwOQFe+1Ynwph9Cdw1cMkgLb1fv35q3ObPn69ye3r37q3Kp2699VYl1GFZtF5H6jpcNejW5YqVr0yZMi6FKMfExGS6TWv9jjclDW2bWdWPavfpH19zEdm2B3QHvMFhezhOOC5jxoyRTz/9VKZMmeLxtgkhhBBCCCG+x2oxiPH0XDGe/EnE4vxcJ+qgSQruMEmwwf79xjbdxXD3o2KNLSL+ArJSEbSMi9bOEBsbqxrUIG81P5InhB5MPtFmG+4ZZIlMmDDBqfWQsYIW3MhyefHFF+0uc+zYMVWeg6wXZL+gbTV44IEHlMvhySeflA0bNqRPuJHPgtvwP8J2ISpoeSxwn7z55ptyxx13qH31Jb7ubOVIfICggqwZb3SR8gR0itKcVWDRokVK5Bk+fHgmsWLu3LlK6HEFnAcolcJz9vZz1bJw4KpxhKZQ63NzNMERQiOCor19LLNysBFCCCGEEEL8A6spSdL2vSfma5udXif8rFnCL1gk8rjZYdCypURZSX3oebEgaNkPSElJkb/++sul6ggYQ1q3bq1MIvmZPFG6hZItV4UTlKWgyxLKtfSdlGxBCRjEm6effjpd5AEQcODaOXTokBJ6NDDJRm7MoEGD0kUegHXHjRunhBBXRQXiOpqSi4BmgDEBcPvYoh8/PRBwHLlqIH7A6YLuXt5Gy+rZvNnxG7N2nz7XBzWlyCFC+3ich1nhintJO5bOJNQTQgghhBBCcger4YakbHlCklcPdFrkCblpkeJz06TIMqNE73cs8kDgSf7gR78QeTAv2b9/v/z6668uiTzt2rWTPn365HuRJ88IPa6CMhmUbMEFhIDcrNAm8qjbswUOHYBOSu4uT3wD3FqgVatW6rcWpqV1ptKP1/Tp0+1uAzY+WADtgRpO8Pzzz2dy3kAY1IKR3QFiTcuWLVX7P3tZUytXrlThYhA3teenlYGhzBACFcoE0ebdHn///Xd6LpEzrxXk9ADbEkVCCCGEEEJI7mNJPi/JGx+U5LVDxJJw1Kl1QuItUvy3VCk+3yAhifY7aaU+OF4Sf1guidNXiqlND+Q7SG6CeRYuaqMxDubUzl68RuTKQw89JLVq1co3GTzZkSdKt1zlo48+UmU8aLWWXUtrlG4hY8dea7Vq1aqlL6NfXn+fHmwD20JgsLPt4LJSMf3NYaG5Z/Db1/umPRaOJQKW9e4TvPgxvghafvXVV9W+oP4SwsjkyZOV+lu7dm05evSoah/eq1cvlaFku99wyCDfB5244PqCkNKzZ0/lokG49hNPPCGfffaZapGObZQoUUK17oPAgvts85/sHRdHx+yTTz5RmUKPP/64ChPDY+Dx9+3bp0oIkUEEAcbWdQSBEbejfBAlgo0aNZJmzZqp8w7iE94Q4W5CRzJtPW0f0F5dfyyvXr2qOpGhI1j58uWV+y0nxpYE5muWeBeMV1afEXCP6n+TwIFjG5hwXAMXjm3g4g9jazWnifXc72I597sEWY1OrGCVqMPm//J3HGgk5iIlJOmuR8TQqPV/wo4fnLtw7eBiN3JSnQXzJTTDgbkD4k5W35v8bVzdBRnB+Vbo2bNnj7z//vsqXNZeFyRbcDJhAp9VuK7+hNP+1men2K7j7AmKUF19SK8eCFT+evIZjU68yXiI9twhWmA8NdAJCyHJI0eOVKHXECi03CBY+5DHBFcPnDxQdOH8wfhC6MGx1h9TLIvJFJaFgwZ/I6C4Ro0a6v6XX35ZCSnff/+9Wh+KMu5HzSd+tG1pY4j/bcdMuw/HTH8fOrtBiPziiy9k+fLl8t1336nHR3v2oUOHymOPPSZVqlSxew707dtXiTtQuiE6oVQQ9atwKNWrV0+JQCg71NbVxsu2vTreKOCEwmNBuEJ4dU6MLcl5OK55D3xZceaz5NKlSzmyPyTn4dgGJhzXwIVjG7jk1tiGJ++T8Gu/SaxcdaoRTug1i8RuNErYVfvuHXCqz70SV7upWNBB6+xZyW0wv8KFfVeOMS6OY56Ezte4KI5mSPnhNRsSEqJELWcJiouLc3wm+CFaGDMm8JgQ68HEFo4HTGqQYQJRAMC1gFo9lLtgfT0QAfADF4gtcO8gqwUuDy13p3///rJixQoVAmzvQMNJkpSUpDo9ZUdWqiNUTUcCVG4BVwCObVhYGC1xAQbHNjDhuOZdrly5kiE3zhZ83uELCpyk2TlXSd6CYxuYcFwDF45t4JLTY6uc2FaTiOGGJB79TgrEOx+0HLPRqJw89lqkG6vVkcQhT4i5gvMiga/BBW5k6uIitCsXJHGRunnz5hIVFZUvX7OR+dXRg5ItCDb//vtvusiTHXDmOLpqmpCQkL6MfnmQ1TooKfJ0oLCd3O5sZYtW+oEJo7/tG/EMjm1gwnHNu2C8nPkwxxcUVz70Sd6BYxuYcFwDF45t4OLrsbVazWI697cYDn+WflsBJ9eNXWOQyOMWh44fZPCYWneXsOBgCRP/ACIL4iauXbvm1PKYfzdt2lRVRISGek++CA/w12xACT0It8XEBvkq9vjhhx/UDzozIRdFy9pBhyNN1dNjL49Hn9tjWxqGbSQmJqq8FUIIIYQQQgghxB5Ws0GMJ2eJ8dQvLq8bu9ogUScc5y+m3fWwGHsOxpUj8RdQzYKsVTh5nAXVNQ0aNFBlSyQfCz0dO3a020oNAgxcPjVr1lRWL31bdGStQOhBTsqQIUMyrIdQXG0Z/fJwDmF55KBktzwhhBBCCCGEEKJhurpVbh74XCKNF5xeJ+yKRZVohV23n7xiDQsTw92jxNi5n18JPChJO3jwoGzZssXpLlrIDoU5w5MSrfxOQAk9aKlmD2T0QOiBAGOb0YOcnylTpsikSZPUyaRlIsAdNHfuXBXoi1bYGuhmhPbYv/32mzzyyCPpohEydSAAwQI2ePBgnz5PQgghhBBCCCF5C1PKZTm64wupkLpRnC0aCkq1SsHtJok6YnZYopU2bIwYO/UVCfGf6f2NGzdkw4YNcu7cOafX0TopM1vSc/znTMiCGTNmqJMEaKHJM2fOVN2SAISYESNGuLXt6tWry/PPPy9vvfWWtGnTRnU0QvnV77//ru5Hu259tgXqAj/99FPl5kHL7QEDBqjW1ujKdObMGXnzzTdV/SAhhBBCCCGEEGK1GOXMod+kwPmfpEKQc64WEHXYpEQee63STU3bSdo9j4u1WMb4kdwEwcpok37y5Emn10G+batWraRcuXI+3bf8Rp4QeiDyaF2vNNBCGz8a7go94JlnnlHK4ZdffqlaaaNDDcSjF1980W6L9nbt2ql23BMnTpR58+apE7pOnTqqGxiEH0IIIYQQQggh+RdT8mU5sXOKlE3dov5XASNOGlWCk6xSeKXBbqt0S8mykjb8STHf2lz8qTwL4g7m5zBNOAMMFI0aNZL69eszg8cH5Ln26vmpta6/tVdH0DXa0aE8jR18AguObWDCcQ3czwAEGsJFijajgdwxIj/CsQ1MOK6BC8c2cHF3bC1JZ+TSrg8lNvWQS49XYL9JCuw3KzEoJDHzFN0aFi6G3kPFePtgkXDnOkznBOhGvX79enWsnAVRKDBWoDImp0nNJ6/ZPOHoIYQQQgghhBBC/A24WSzxB8V4/h9JvLpTooyXJNbJdYPSdPk7WdgvTA1aqBwea8my4g+YzWbV0Gjv3r0urYdW6SjTgshCfAuFHkIIIYQQQgghxAWsVouYLiwWw8HJ6be50iMq8ohJYrbZz9/Rk/LEBDE3bSeSywHFEHe2bt2qmha5A1qlo5ERSraI7+FRJoQQQgghhBBCnMBqMUnKqXliPTHVrfVDr//XJj38imMLj6lZe0m9d5xIwf86Quc2p06dUo2QkpOTXV63WbNmUrt2bYmI8I9yM4MxVbmwAh0KPYQQQgghhBBCSBZYTSliODZVTOcWuL2NmE1GiTqUuUzLXKmGpN3zhFhuaSD+BPJ30Bjp9OnTTq8TFRUlTZs2lapVq6qcSH/AYEyTvzZOl53H1qXf1ts0UprX6SSBCoUeQgghhBBCCCHEDnB/mC6vluRDX0uI8Zpb24g8ZpaYLUa7ZVppQx4TY9cBIiH+MzU3mUyqRGvnzp2qZMsZgoKClHMHIo8/uHesVqtsO7JK/lj/g937F2yeLpXL1JRSRcpLIOI/ZxMheZRRo0bJnDlzZNeuXVKpUiWvb//HH3+Uxx9/XD7//HMZOnSo17dP8gdoXQn27NmTfhvPLUIIIYQQ+1itZimQsFosG34V6DOuNgAvtNwgEWcsDjuqJ7/yuViq1xV/Ax2p0EULbh5X6NevnxQvXlxyW9w5fHaXzFr2cZbLtareR8qVqSChIWESqFDoIX4J6kAbNMhsXSxQoIBqx9e3b1954oknPGrJV7hwYWndurUsXLhQcvM5OQJp9PpJOcmZD7ZPPvlEVqxYIefOnVNhccWKFZNbbrlFdQh46KGHJDo6Ord3kxBCCCGE+BBz/CGxHJgihZOOurReSJxFYtc7zt8xduwraYMeFCnobF+unHPwYN6xfft2sVgsTq+HFul16tSR4OBgyU2wzwfPbJc1exbJ2avHsl3+1LX90qFJL1VmFqhQ6CF+TZUqVeSuu+5KV2ivXbsmS5YskXfffVeWLVsm//zzj4SEuKqv5w6FChWS8ePHZ7r9vffeU60G4QyyXZ7kHPhw6927t9y8eVNatGghXbp0UULi2bNn1VWNf//9VwmMqDcOFPB8EZBXqlSp3N4VQgghhJBcx2pMEMOxH8R4/m8JEucCe6N3miR6r0mCsqhwMte8VVLve1qsZb3v/vcElGUdOHBA5fC4Mj9r3LixFClSRJVr5SaXbpyVHxa/K0mpCS6td+7GMTl0bqc0rN5SAhUKPcSvwaT6hRdeyHBbWlqadO3aVbZs2aLS39u3by95ATiIbJ+LJvRA1LF3H8k5XnrpJSXyfPXVVzJ48OBM92/evFmKFi0qgQTOOwqKhBBCCMnv/NcqfYmkHJ0qIaZ4h+VWekKvWKTIUoMEG2y2FRIqpts6SNqw0X7TNUsPLpz//vvvLq+n5e9ERkZKbpNmTJHlO+fLxv3/isXqvANJT7GYwL7QmbseK0LcAOFebdu2VX9fv349/fbVq1ervBG8AZUrV079dOjQQaZNm5Zh/TVr1ijRBaxbt079rf0gs0QPyrr69++vlGu4HpBz8vDDD8v+/fsz7RccRxAJ4JAoWbKk1KtXTzmPXLE/Zsfy5culW7duUqZMGbVPjz76aIZjoOfvv/9Wjo2KFStK6dKlVZnaZ599pqyZtiVlEDDGjBkjhw4dkrvvvlutg7yhBx54QH0YaEIHHC0oKcN9o0ePlqSkJLvHduLEierKQK9evaR8+fJqe8OHD5fjx49n2s9jx47JY489Jrfeeqs6bijNw74+//zzmVofIvEfJXv4oClRooSyiuJ/lFzZgsfGvhiNRrU/GDtsv0mTJvLdd99lWh7CIUQPeyIPuO2229LPG42ZM2fKkCFD1LZxfmDfBwwYoM5FW/THZtOmTWpscGyqVasmTz/9tKSkpKjlFi9erITMsmXLSo0aNeTVV1/NNGY4T7XzFedop06d1DmBbeE1cPnyZXEG/Xb04DYcP2wH5xgEV5xDcDnhedhj7969cuedd6aPN/7G6wRONWwP5xkhhBBCiL9hTjgmydueFsPBj5XIkxXByVaJXW2QktNTpdgiOyJPRKQkT5wuaY++7Fcij1aa9e2337os8iB3B/k7bdq0yXWRB3ODPSc2yeR5z8v6ff+4LPL0b/2gvHj3lzKi9ctSolBZCWTo6MmjpGwdm+OPiSm31WKV1OCgLFXuqKaf+HQ/DAaDcvLAKqgFzILJkycrIQFCCybJcGcsXbpUxo4dK0eOHJG3335bLYdJKEqo4KSBaHHPPfekb0O/PTg8EFILWyImvRAWkNuyatUqadiwoRIZ9GBCDuGoe/fuauKNCTiEHggNr7zyisfPG8INyod69OihRAeUE/30009y8uRJVcKmB4LOyy+/rPZ90KBBKtsI6+M2CDCzZs3KZLWEiIJtN2rUSEaMGCE7duyQuXPnquf82muvKQEDwtnIkSPV8YfIARELx8iWrVu3yscffyydO3dWwhgsoQsWLFCPjTGBIAIuXLigjlVycrISsPAYEI8wjlOnTpW33npL5eSAo0ePqv27evWq+g2xB0ICngueP36qV6+eaV8gVqHeGCIFyvzmzZsnzzzzjISFhannogGx69KlS2qfIJo4w7PPPqsEPRwXfAieP39eFi1apD4McXxw3tiybds2da7ied97771KOMFzTUhIUM8Lotftt9+uzmOM96effqpygeyV/f35559K/LvjjjvUPkCsgmiD44zbURLoLnj9YH+wDYh/OO74YjBw4EBZuXJlhvMfXxywzxi7Pn36KMEJ5w/Wx/EhhBBCCPE3rKYkiT88TYIvLJBg237ndiiw36TKtIKNme9LGzZGjJ37ieRyVo0ezEFOnDih5i7uXlzH99FatWrlegYPuHLzgizcOFOOXdjn0noVS9aQezqNkejI/74Xp6amSn6AQk8exRJ/MNceWwk+OfRYmPDDAaEe12pV7hVk82Ay/sYbb2SY2E+aNCldQNCr13AWwGkDZ4LmRkGZFIQeiD72SqYgGkDAwGQWAoW+ZAfbtOeiQdctCD1wPoDnnntO1a9+8803apIeHh7u0bHAPmFfkB+j1dRigg/RBRN8vBEDvKG//vrrSphCqDAcFgBiEwQICFA///xzJufKxo0b5Z133lFCg3a8McGH2IBl4YLRhAt8cEBYwHYgAsEpowdjBKHnvvvuS7/thx9+kKeeekodC6ynCRUQFDDGthlFN27cSBd5ANaF2ICwZAgkGtgvCDfjxo1T27MF4gtEMU30wHmA4DiIYXqhB8cGYw5x4v7771fLQKSASOYIHDPbc+7ixYvSsWNHJfzZE3ogdEGMsT2Wv/76qzpuEIpw3gCcm/gb5y+eH8QpPXD/QIyDoKYxYcIEdewhbOIcdxc4dB588EF5//330z/c4aSD8wtXg/AYGjjXIVThdrzeNLAPH3zwgdv7QAghhBDik+Dew0sk6sxUKRkSL9nVaYWfNUuhtZlbo1tKlBVD3+FiatsDvcXFX8AcAd9R7VUgOEvNmjXVheXcDis2W8zKufPvtl9cWq9k4fJyZ/tHpXSRCpJfyX1pjpAsgGiBySp+MOHEpB63IZfHNpvHdsINIBRAbMAbnqOSE3vAYQHgyLHNZcE2bYUNzd2hiTwA3ZrgcsAEGI4iT4EzRxN5ANwpKBsCcKxoQDCAGIWSJk3k0VR5CEBg9uzZmbaP4/fII4+k/w/HDxw2AGVVetECggNEJjzOwYOZRUcIcHoRBeB/OD0gHEGw0WPvQwRuJA2UZmH80P3KdrsQZfBhhHIpBCfbAsFF72xBOVTz5s3VmGBsNCCEwd2Fx4J4BYcRhEGcZxAr4uLi7B4zW3AOwNWCkjS4pGyBWGLvWEJYg8ikiTwgJiZGOcQgesFZZQsEIr3IA1AGhhI0iGmelA3CRYTzRX8FB8cH57/+fMNzhIMIophe5AFw09mWuxFCCCGE5BZHzx+VrcvHSaXzH/8n8mRBxGmzFP8tTYosyyjyWMMjVOes5InTxNSuZ66LPPi+h6gFfFeFq/7777/3SOTB91J8/81tkefI2d3y0W9PuyzyjOozQUb3eztfizyAjh7i12ASC8eCBpw0UKiR34JJMRwcyOQBmLRPmTJFOVZQzmSbHwOnhbOgvAbCCGpRnQXlXLYgJwjAteIpzm5/9+7d6re9fYcyj9pae23b4V6yLefShCt9SZvtffaOK4QUW4sn/sftEEDgFoFIgTGEMwuOHNhKMd7Yb1sBRdtfZPfY7iO2i9bnhw8fVsvpxS1njhvEFIDj8sUXX6iSPXR2wzmAHzi18IOsJ5xb+n3DefbRRx8pkQkuMwSF68GxgWtMT1bHMrvjbHtc4DqyBZ3CsB04vbB/tsfDWSDKYVv2RE79+YaxBHoRUi8WYV9cEVkJIYQQQrzNunNxsn7zNHkodomUCc6iPRa+WyZYJHazSSLOZr5gZmrcRtLueVysJZwr8/e1wIPvYch+9BR8R69bt26udzPGhc+DZ3bI7OWTnV6napk60rv5cClROLAzd1yFQg/JU8BdA5cMymlQaoMMl/nz56vcHoTbYkIO9wlKjrAs3qzgOJgzZ06mSXhWxMfHq5wWV+pRNcFAj/ZmCUeRpzi7fc2lgtItWyCS4HaIErbYTur128/qsVF6ZIs9x5P+dk0oQBkdRBU4p/Ab+TkADp0XX3xRjXF2zwlo7cH1Dh0Nezk1WY0LRCCUhmnlYXCQIeAY5V8opcK5pJUVImcHjwmXDkQrHCecMxBZUMZn75zL6lh6+zjjPHYXe/ui7Y+98w0ZRVntCyGEEEJITmKyWGXi1otS49Ln0id6qzTMLhvZbJXovWaJ3mO/VXrKUxPF3DD323GrQOI9e1SjFNvGJc6C7864AKyvRshNDMY0+WfrHNlyaIXT68QUKCw9m90j9Srflutt3v0RCj15lODYW3ItjDkomzDmnACdk4BWQoJcE4g86OwEV48eOIK0ybmzoPQFHYeglPtD+Jg7E/QrV65kcpPgwwC3O5rEewtHXZ+02/UtveEkmjFjhhIydu7cqQSfr7/+WpXc4cMHThH9c8pqu754XuhuBqcPnEF6Zwpug0UW+wphUQ/yhCD0+JrsjrMnYczOoh1z23I8230hhBBCCMkJziUa5dsVv8qz0TNkHG6Izn6d8HNmidlkktCEjMJJcqkKkjp6goRXqCq5DeYlyOXU3Pvu0rNnT3Vh0x/EEYMpTVbvXiCrdmfO2XREcFCwtKjTTTo17CcRYblbXubPUOjJo/i6s5WjNxc4ZxAqnNvih5aXoqnYcF0AuH1sQX6IPfAcHGWYQEhClgycGe3atZO8BBxNCG3GvmuCmAbqdpE0DwXfl8BCaiuS4X9cecCHir1OTMiqQaA0ftDOG6HJCBuG0KOVNMFVgzHXfzDhf9zuqPTJG9hzOzk657A/3rDQOoO9czsxMVFd5YHIg1Iv29bs3kYbS3vPGd3UtNIuQgghhBBfYrRY5edde6Xixa/l2eijTq0TnGSVmM1GiThtyXAh21ogWuKe+1hOmoKkQoncLQlC/g6+22Me5q57BxcskT3pD+KOxoHT22XR5h8lLtH+xUJ7lC1WSfq3eSjf5+84Q96yKhDy/2gtvZHNAvDGBZDfowdix/Tp0+1uA2G/9gJuAboNAWQBIQhXDybO/uxSQCAuslRwjPQlWvhwQMgw0LeU9wVohW573PE/bkfIsVbmAwePvfIizbmDnCRtfFEehTbtaFuuB9k5hw4dUoKcu3k0AIHf9sKcIdxoHab0OTSOzjks60kAniugzTk6delB9zmUxsFllBOCLFxjOC4Ql9B+XQ9aw9u+fgghhBBCvEl8cqKsWjlRDCt7Sv8bz0qTCCdEHotVCuwxSbH5aRKpE3nM5atK0se/StKXC8VcJqMzPqfFHTje0dEU36/cEXngmodDvm/fvur7mr+IPDcSrsispR+rHB5nRZ7ihcrIY33flFF93qDI4yR09BC/Rt9eHWDSCOcAyrTQzUfrIoV8FLyBTZ48WYkBtWvXVl2V4AhBds8ff/yRadsQBpAJA9EDLhhkj8DKCIcCxIjRo0erMjB0QcI2kA+DVt0I3kVHK60Nub+BUiMcl5dfflmFF/fv319lGqE9O44JHCi2pUbeBqHKaKMOVxTGAmOCx0cnMn3L759++kkJNRDssN8oA0IXL5RvQYgbOnRo+rIIPcY4P/nkk2pb6MCF7f79999KOML9ngBhDFlBjRo1Ulc98PgI/0a5FgQqZD4hE0oDH5xokz5ixAiVJYT74ZjCuYlOWTj3fA0eZ/Dgwao7As5/2HmxvziWCJXOKTCm6CT20EMPqYB0OLJwHLA/GFs4rnLbBUgIIYSQwGLD3uVy6+X3BWmG/7VmcY6wC2aJRZnWzf+VaRk79lWdtKSg78vebS8oouEGvjfay2N0B8xl4N7P7WBlW0xmo6zZu0hW7/5L/e0MTWq0l65N7pToSN/GTgQiFHpInmivrgGHR9myZeWBBx5QrZs1VwVKazDBRCttTCrh5IEQABUcAo09oQeTegDhBsIBSouwba0U5c0331RlRNgG1kewLqyPcJZ07NhR/BkIUZhsQ7z45Zdf1FUAdFGCUIGSKF8r+uiEhk5aeDxk2OCDBkIAOmzpO0ehZTyOK8Q7dLjCfmIM0DJ9zJgx6eOrtUVfsWKFOh/gYoGIBIEHYhBEJds8IleB6ASBCdk6EI+QOYPzDYHREP0QyKwPrGvQoIG6wvL2228rO63WVQznEtbPCaEHV2ggNMHFg45gaIMJ4RLOLQihnrRXdwUcC+RkTZgwQZYuXarOL7h8cCxwG/B1LhQhhBBCAh+T2SKLNv0inVOnya1urB+72iCRJ/7n4LGUqahClq2l/uvImlPgYqK+s7An4DsXOmb560U1FR59YqMs2zFPridccnq9J+54W0oVcd+tn98JiouLcy+qm/gUlK446jCUW/hTRg/xz7GFm6RPnz5KeEGHKuIb4CSC8AQhT+968rfXLLpzwR2FXCi4yYj3PgNwTM+cOaPE0MjIyBzdN+JbOLaBCcc1cOHY+h6rIU4Sj/wgwZcWi8UaJMFBrk9fC+wzScHtJgn6/2tgpnrNJG34GLGWrpCjY4vvZWgmgwxDdztmaaBDMFz0uNDnb+C57Tu1RX5e+V/chrO0v7WvdGhwh4SG+M6PkppPXrN09BBCCPEI5FYhFwilebZ5Rfgg1VrVE0IIIYQ4i9VskOSTv4icmpUeLOu0yGOxqoDl2E1GCU7V3VykuKQNfULMTduL5GBmTUpKinI6O+pS6grVq1dX8Qy4kOdv3Ey6Jl8tmCCJKTedXqdARIx0b3qXNKzeRnXUIt6BQg8hhBCPQKcvZDGhpBElgqgxRykerlih3A2h5oQQQgghzmA1JUnq3nfFcn2LexswW6XYnwYJjc8oCqkcnsGPikQWkJy6EIaIiGPHjnlle4hBQMSBP4LMnXX7/pGl239zep0gCZKmtTpIl8aDpEBE5g63xDMo9BBCCPEIhH0PHz5cfZlBRhYsscizQmD1s88+myHbiBBCCCHEUbmP+dIKST7yrYQYXe/aGXXAJDFbTGJr+oGDx9i5n4gPy4FsBR5c7EJjCk+Bcwe5o/4Ym2GxWuT4+X3yz9af5dKNMy6tW65YFendcoSUL17VZ/uX36HQQwjxGgiqjouLy+3dCHiQy5NVNk9OA+swAqEJIYQQQlzFajGL4cRMMZ36Sf3vSq+oiBPooGWU4LSMt5satJC0YWPEWjLnHDBwNEPg2b17t1vro7EIGpqgyQy+W/lLO3R7gtzBMztUe3RXiQqPVg6epjU7+KV4FUhQ6CGEEEIIIYQQkqNigSX+gKRuG+fW+gV2myR6j0mCTZnvS37hE7HUapBjGTx4LocOHVIiT1JSktProQyrVatWUqRIEfF3zBaTLN85X7VGd5dyxavI8C7jJDoyZ1vY51co9BBCCCGEEEIIyZH8HePJ2WI87V5r8eBEqxRZkjl/J/XRV8TUsrPkFBB0FixYIPHx8W6t36lTJ6latarfunY0zBazbD64TBZt/tGt9Zvf0lk5eCLDcyYXifwPCj2EEEIIIYQQQnyG1XBDUne+KJbEEy6vG7PRKFGHzRmyd6yhYWJq00PS7npYJDpGcgqLxaJao8O9g1ItV+nSpYtUqVJF8gKnLh2WBRtnysUbp11ar1B0MWlTr6cqzwoNCfPZ/pGsodBDCCGEEEIIIcTrWFIuSuqO8WJNveTSesFJVonZbFQt0m09L+aat0rqA8+JtXR5yUkuXLgg69atkxs3XAuKRphy/fr1pXDhwpIXSEyJl3+3/Sw7jq51ed3ezYdLs1qdmL/jB1DoIYQQQgghhBDiNazmNDGe+kWMJ390q3tWwe2Z83eMLbuIYfAosRYuJjlJSkqKbNiwQY4ePerSeo0aNZLGjRvnGdHDaDLIjqNrZMn23yTVkOzSunUqNZX+rR9giZYfQaGHEEIIIYQQQohHWE0pknboU9Ui3R0KbjVKgQNmCbJkvN3QdYAYBtwvUqCg5BQIWD558qSsWbPGpfWioqKkRYsWUq1aNb/P3wFxiddk+pIP5OrNCy6vW6Ncfbmz3SiJioj2yb4Rz6DQQwghhBBCCCHEKSypl5VbJyiylISV7ytiTpHUXa+IJeGIy9sKvWaRAvtMEnnSkjGDJyxcjBB4+o4QiSqQo+6ds2fPqhyeq1evurRuhQoVVMgyWqP7O1duXpBZSz+W6wmuldRVL1tfOjXqL+WL+3+QdH6HQg8hhBBCCCGEELtYks+K6cISMZ7/W8SYscuU8dhUt7ZZaKVBIk5lzt8B1ugYSZ7wjVhLlJGcEneWLFkily65JnqgLXrTpk2lcuXKkldISk2QJdt+kW1HVju9TnhohHRs2E9a1O4moSGUD/IKHClCCCGEEEIIIelYzQYxnv3DbSHHHkFGqxRabZSIsza1Wf+PsW1PSbvrEZHYnAktTk1NlS1btsjBgwddWi8sLEyaNGkidevWzTP5O3GJV+XbRW9JfLJrQdJ1KzWTnrcNUZ20SN6CQg8hHjJq1CiZM2eO7Nq1SypVquTVbf/444/y+OOPy+effy5Dhw716rYJIYQQQgixzaYxX1opaQc+ErG63j7cHsEJFonZbpIIlGfZud9SvLSkPPuBWEtXkJx6jgcOHJBt27YpsccVkL3TvHlziY6OzjMBy2v3/S1rdi8Qo9ng9HrFYktJr+bDVQ4PyZtQ6CF+yalTp6RBgwaZbi9QoICyR/bt21eeeOIJKVjQ/VA2tDhs3bq1LFy4UHIShLr16dNH7rvvPvn4449z5DF79eql2kFmJUb1799fdRRwtMyqVatk5syZsmnTJrly5Yq6glG+fHlp1aqVDBs2TFlXbcUvPSEhIVKsWDF1BWT06NFqPUIIIYQQkvtYrWYxnf9HDIemeHW7MeuNEnXEnEngsYZHiqHfCDF2v1MkNExyArPZLHv27FEuHlfBnKNdu3ZSrlw5yQukGVNk6fa5svHAEpfXbVazo9zefKiEhuTMuBDfQKGH+DVVqlSRu+66K119v3btmqqhfffdd2XZsmXyzz//KAEhUOndu7c0a9ZMSpUqlWv7gLpliGpz585VQlv79u2levXq6j60mfz1119l2rRp8tVXX8ngwYMzrDt8+HApW7as+htXTA4dOqTGb/HixTJr1iy5/fbbc+U5EUIIIYTkd6zGBLFaDGI89r0YL62UIKvZK9uNPGySqGNmCbtizRCwnP640bGS/Oa3Yi2WM99vjUajbN26VQUsu0Pbtm2lZs2aeaJMC/OlPSc2yT9b50hCcpzT6zWu3laJOxFhUT7dP5JzUOghfk3VqlXlhRdeyHBbWlqadO3aVanxa9euVcJDoFKoUCH1k5vAfQORp2PHjvL1119LyZIlM9wfFxennEk3b97MtO6IESOUUKVn/vz5cu+998qUKVMo9BBCCCGE5CBWc6qkHZycqQW6N/onFV5qkIhz9vN3QOojL4mpZReRHOrWpLVIh2M9KSnJ5fXvuOMO9f0W3bT8WeRJM6bKjqNrZN/JLXL15kVJTM38ndwRQzqOltoVm7CDVgBCoSeP8s3CN3L8Ma1W/FgkKCg4y/fnh3u96tP9iIiIUMr67t275fr16+m3r169Wn7++WdVWnThwgV1W40aNZSogB/b0imAciaUcGnYZuGgrOu7776TnTt3SnJyshI5WrZsKWPHjpU6depk+jCBq2Xq1Kmq9AzLoqTpueeec/vDwVFGj1Z29sMPP8irr74q//77r9q/evXqyWuvvaaOjzfAMf3tt9+Ugwf7AkePLdiXCRMmKAHOGTp37qx+68eOEEIIIYT4OHvn6kYxHPlSrKmXPdpWkX8MEnbJIqlVg8UcEyxRh00SkmJ/WXP5KpI24imx1LpVcvK5Hj58WH2PdQV8t65du3a66AE3ur0Lmf6A2WKWNXsWyLIdv7u1/vAu46Rm+cwxGSRwoNCTRzlz5ZjkVwwGg3Ly4E24fv3/BYRNnjxZjh8/rhwkKBfCG/PSpUuVKHPkyBF5++231XIVK1aU8ePHy3vvvacU+nvuuSd9G/rtvfTSS0pgQetEZNyUKFFCzp07p7JqGjZsmEnogeAC4ah79+7SqVMnJRKhxAx20VdeecXrxwHPr0ePHhIbGyt33323XL16VX7//XcZOHCgrFy5MtP+uQPKqzRXjz2Rx1aAc4bly5er3/YymAghhBBCiHexpFwQw+EvxXxts1vrF/knTcIvZa7BijoO945jB0/a0CfE2KmfSGjOTTmRI4nv4/jtbPYOciO93VDFVxw5t0dmLPnQrXXLFK0k3ZrcKdUZsJwvoNBD/BoINxMnTkxX5+ECQTYPHDtvvPFGelYMmDRpkgpq1mMymeTOO+9UTptHH31UCTt4I0c5GIQeiD62pWEA2T8QeSCWLFiwQIoWLZphm/bcKAgxxgdL6dKl1f9w8jRu3Fi++eYbJSyFh4d79digzvjBBx+U999/P90xBCfPmDFj5Ntvv/VK0PPGjRvVb4TPucOMGTOU2KZdFYHghoweiDy+EL8IIYQQQsh/mBOOSNr+D8SadNrldQvsNUn0LpMEm1xbz9S4jaTd87hYS5QRX5GYmKi+c58+7frz0oN5BL47h+agEOUOqYYUmb9uquw75XqItEaHBndIxwb9/LoEjXgX/z6rSb7nxIkTSpCxBa4Z22weW5EH4I0b3a1WrFihSrb07p2sQPkVgCNHL/Jo27TNqQHPPvtsusgD0GEKGTToPgWBo27duuJN0Nbx9ddfz/CGjec3btw42b59u1ce4/Ll/6y9WqCyq6BLly04LoMGDZIyZXz3BYAQQgghJD9iNcZL2uGvxHzpPwe1q6Akq9BKg4S41nVckfLk22Ju3Fp8BS62Ik5hx44dHm0HFxzRLdafRQ+T2SiLt/7sVtcsjZiowtLztnukXuXbmMGTD6HQQ/wa5LkgCFgDThq4TJ5//nlVtvTnn3+mt/VOSEhQAb8omULwmm3o2sWLF51+3G3btqlSpDZt2ji9Dsq5bNFaMPqivrdatWqZ2strIpS/1BPDvaOFMaPkDlde4K6Cm2fz5s12hSBCCCGEEOIaVkOcpB35xm2BJ/S6RQovM0hIsnPLW0qVF2O3gWKNKSTmmreKtUhx8RVnzpxRbntPiIqKkhYtWqjvz/4oelyPvyQ/Lv9ULsed9cr2WtXpLh0b9pfIcHbRyq/kCaEHAbtIS4eCu3//fjVhtA2nBchCWbRokfz999/K0YA8FbyQa9WqpZwOCOR11Ir7l19+URPQgwcPSlhYmHojQEmPvck7wPZRUoTgX6jLKPFBaG7//v0lJ6hQopr4axizL4G7Bi4Z5MX069dP3nrrLdXFCecEWpGjfOrWW29VmTVYFuMNcQGuGmfDgkF8fLxynLii9MfExGS6TTvfzGbvtKvM7vG0x7R9PO15oPzNEdp9+ucM0QjHD6Vy9hxTroDSNVhkP/zwQ1V29tdffynRDq81QgghhBDiOlarWUzn/xHDsR9ETIlOrZNsCJdS25Ik6rDZqW5blhJlJW3YaDE3bCk5CUq0MNdClIMnwFWPC8PejlHwFLPFpFw7G/b/67VthgSHymN935SShd1z45PAIU8IPZjMQ8lFyUepUqXU347KfEaOHKlcDsgU6dmzp5qwQwF++umnVWein376KZOKi4knHgP5LSjzwZsKQm1RHvTHH39kmogiwR2Bt5GRkTJgwAD1eHCWYN2zZ8+q4Fpf4+vOVvawWCxKUMGbZG5bHZs0aaJ+ayVKEPgg8gwfPly5evTAEQShxxXQ0hxlS3jOuf1cvQECmzVHlCPB5tq1axmWBTj3IfQggNpTocd2/CDyYPwo9BBCCCGEuIbVYhDj8ZliPP2r8+tYRUIPi1TaHi/BBufWMfQbKYZe94iEO9d0wxvg+zcuCsJhjwvq7oILlqgOsHXA5zaX487LNwsnqLbonoLW6APbPiQRYXTukDwo9GDiXrVqVRWci4BZtHK2B17EEG2GDBmi8ks0IOLA7bF48WIl3MAJonHs2DGVwwKnAUJ+McEHDzzwgHTt2lWefPJJ5SbSJvt4s8Ft+B8lQnCPaMG7eCN588035Y477lD7SnxHXFxcBhcKRD4At48tGD97YAzxQeJIiIAwiO5e7gYR+xNwnOF8RbkUAqJtgQCEY1i+fPn01wBAe3i43T777DO56667lO3VEXBMOdt5Sxs/R8efEEIIIYRkxhx/SFK3PunyeqFXLRK70Shh1xy7u/WYGrSQ1IdfFCn4vwuAOQFc5AhavnHjhtvbwHd8NGPRX7z0B24mXZO5a76RExcPerytEV2fkRrsnkWyIE9YFTp06OCUcILAWHQh0os8AP+jrArgjUPPjz/+qMQbOH70E1wIOHDtHDp0KINQADcPJsQIk9VEHoB1EYILx4ur7hHiOijdA2iHCODG0neJ0oBQM336dLvbQNt0lPfZA+cRQBaQ7QcNzhctpDivAJEGH3oQTW2fM8QWtIbH80LJmx6IXDjXESYNt5S9VpVwzaED2rRp05zal1OnTqmyLdC6te8C+wghhBBCAgFEJxhO/iRJy3u4JfLErjFI0YUGp0Qec/mqkjR5rqSOezfHRB5cuMV3TXSNRbdbV0QeRDUgD7Jbt26quuKhhx5SF+z9SeS5cvOCTFv8vnz46ziPRB50zpow8gd5897pFHlIYDh6vAFyd4BtRg+EANCpU6dM68ChM3v2bCUOaRPS7Ja3JyY5Au2mHYHJt7+5HTT3DH77et+0x0JN7jvvvJPBCYJaXZRpFS5cWAkU2Be8uUMMnDx5sspxql27thw9elS5uHr16qVK62z3G+0Uke+D/Kb69eurcwPlfqjj7dKlizzxxBPKyQIHDLZRokQJdZUBZUy4b9SoUZn22fa42Dtm2m3oAma7DY3mzZvLiBEjsj3mWY2D/j4Ez0GMQQgytg3nE8QxBFijIxk+XFG7/NRTT2XaJo4pbkM5I7oUdOzYUW0P+4TxwfFAuSMyrmzXhciGQGYAIQllYCizS05OVmWW2J6/neeBRE6+Zol3wXhl9RmBiwr63yRw4NgGJhzXwMWXY2s1XBfLgbdEklzPqIk8YpLYjSYJcvLjP7VFF0kaPEqsUf9/wTyLzyBvcunSJdm6datylztLy5Yt7YYq47umJ6Ve3hxbfPfafmy1/LN1tkf7UKt8I+nTfGR6aZYhje8h+fn9ODIy0ull843QM2vWLLsCDUq3UPKF7B9b8AaiLaNfXn+fHmwD23I2MOz8+fMOQ3qRg+OvJx9Cr32N9tzhnnr//ffTb0dpEEKSIRIgCwmlRlpu0K+//qrEDLh6IMghhBvOHwg0EHpwrPXHFMtiMoVlkeOEv1HLW6NGDXX/yy+/LI0aNZLvv/9erY/SJNwP0Q8/2ra0McT/tmOm3Ydjpt2nHT8IUfixB9YbPHhw+ocVfttuW8tMcjS5t70PLqVbbrlFtY5fuXKl+kBFKRbKFtGmHVdB0LXLdj0IYF988YXaH7jVtmzZosocNRcdShURjA5BzPaYaK87gA9jON8QcA5xDU4hfz3HA42ceM0S7wKRB245Z74gk8CEYxuYcFwDF2+ObZA5SQrfmCNRKbtcWi8pKULKrU+QiPPOX9w512mAXG7eVSQkVOQqxBbnBRd3wPdXZJq6GrAM506VKlXSm5FgG/42tvgOfuLKXll75A+3H6ts4apSqlAlqVGqkUSGFVC3Xb541e3tkcB5P8acDHE2zhIUFxfnXKGmn6Bl9NjruuUIlJSMHTtWlaFgwq4HIgB+4AKxBaIOslrg8tDKsdBVCw4IhMjaO9BwkqCtN5wL2ZHV1Vq0x8Z++RN488KEEe4of2xLSNyHYxuYcFzzLiiT1JcT2wKRFF9QcIHB37qIEM/g2AYmHNfAxZtjazWniPXMT2I977pQEL3DKNF7zU45eKzhEZI06GFJbdtDJNh+R2JvgguAcO0cPnzY5XXh4IcbHRdb/WVsE1Juys+rpsilOPsNglylUbW20rXRXRIWyveGnMCQh9+P6ejRAafGs88+q8pUvvnmG8krA4WSGn/r9qSVfmDC6G/7RjyDYxuYcFzzLhgvZz7M8QXFlQ99knfg2AYmHNfAxZOxtSSfldSdL4s19aLL60YdNEnMVpME2S8SyISp/m2S+uhLIgULSWQOTKi1fFNXwUUqXHBHpEJuf4fRxtZsMcumA0tk2Y7fxWBK82ib5YpXkS6NB0n1svW8tp/ENcID/P04oIUedE1CiQ8UYIS/li5dOtMyCOpyZI+H2KIto18eZLUOlGdCCCGEEEIIcYQl5aKkHfxELDd2urxu7DqjRB4zS5ATtRnWkBAxdr9LDHcMF4n8rxzIl6Bq4cCBA7Jv3z5JSUlxeX1coEeWpm2Dndzk1KXD8tfG6XLphuclYwPbPiwNqrai25r4lIAVehDCizDbYsWKKZGncuXKdpdD1g5aTmv2LT328nj0uT3IGtGDbSCU1l77akIIIYQQQgixmg1iPP2rGE79LEEW5/MKjWdCpeyaRAl2IXrPXK2OpD7wnFjL2Z8LectBfObMGdWgA5mW7lKnTh3l4vEnl0WKIUn+2jhNdp/8XxdmdxnaeazcUqGRV/aLkHwp9GgiD9pnQ+TJKrQIoboQepYvXy5DhgzJcJ8WOKtvAY2/P/roI7U82q9ntzwhhBBCCCGEANO1rZJy6AsJTj0vzvg5zMYgKbzFIFFHzE4tr2EpU1FSnnxLrGUqijdBgxA05ti7d6/XtglnS79+/aR48eLiL0C82npkpazYOU8MZvc7kLWt30s63HqHhIdFeHX/CMl3Qg9aOUPkQfkURB573bH0INB5ypQpMmnSJNVyWgu/3L17t8ydO1d1bkILP4327dsrd9Bvv/0mjzzyiNx6663p4ckQgFDrh+5EhBBCCCGEEALM8Yck7fDXYo3fL84mzhTcYpQCB5wrz9JIffRlMbXsIt4Gcx3MjRx1DHYVzJk6duwo5cqVU92E/AGzxSRbD62UBZtmerSd4rFlpE/LEVKxZE0JRTczQnKBPHHmzZgxQzZs+M8up3XHmjlzpmqLDSDEQNxBkvuwYcOUZbBNmzZKjLGlYsWKGbp1obX0888/L2+99ZZap2/fvqr86vfff1f3T548OUMAGNpPf/rpp8rN06tXLxkwYIBqqY5uXrAsvvnmm1KpUiWfHxNCCCGEEEKI/2K1mMV4YoYYT/3s0nqFVhkk4qTFJQdP8kufiqXmfxegve3g2bVrl/rxVORB1cMtt9yS6+HKeowmg6za/aes2v2XS+sViy0tnRr2k/pVWkiaMUVtJ6YAc1qJ/5AnhB6IPFp7c42NGzeqHw0IPcjI0epCoTg7eoOxbcv+zDPPKAHoyy+/lO+//16lvEM8evHFFzPl8AC0aUc3r4kTJ8q8efNU+2LUlKLtO4QfQgghhBBCSP7DakoSw/EZYjrreov0wksNEnHO4pz7pHwVMXXoI8Z2t4tERPpE4MEc7ODBgx5tB3k79erVU3Mqfwofjk+6LnPXfivHL/xnInCW8NBIJfC0qNNVQoL/m0pHhhdQP4T4E0FxcXEumAFJTnHlyhUpUaKE+BOoVUWbRFgt/UmJJ57DsQ1MOK6B+xmAjiZwkaIziT+FVhLP4dgGJhzXwB/b8rE3xLLvVZfXT7gRJZXWxknYdeemZNboWEm78yExte8l4oPPdqvVKkeOHFFt0fG3J6DKAeVZuIjuD+D57D25WX5Z9YVb69erfJv0bDZEYqOLen3fSM6Rmk/ej/OEo4cQQgghhBBC/AkIB5brW6XsmbfEOR/O/0g1hknsNoNUO3TD6RItuHfS7npYJKawTy4O7dixQ7Zv3+7Rdvr06SOlS5cWfwLPbeOBJfL3ltlurV80ppTK3Kletp7X940QX0GhhxBCCCGEEEKcZOdVg7y57qCMDJ0pnaP2uLx+6vEIqbD5pgQ72Ync2LKLpA0bI1IwVnwB3A2bNm2SGzduuLV+s2bNVIMaf3QPn7l8VP7aOEMuXD/l1vqNKnaQbs0HScHoGK/vGyG+hEIPIYQQQgghhGTD/uspsmbzjzIs/DeZ4ea8v8iiNAm/4ly77rS7HxVjt0HoBiO+cCOdPHlSli5d6vQ6JUuWlFatWvldvIQ99p3aKj+tmOL2+r2bD5d6FVvI+fMXJDTEP0rPCHEFCj2EEEIIIYQQ4oCEuGMSvP1xQV/dSuGurx+93SjR+8wS5GR9l7lGPUl5aqKIj1wkaJWOoGU4eZwFzWhq1qzpV4HK9ohLvCqLNv8oB067VoJWLLaU3N3hCSlTtGKGLBdC8ioUegghhBBCCCHEhrjzayTs4NvibkFSwW1GiTpqlmAn9QKIO+aGLcVXuNMqHe3Q0Y041AeuIm+C9ubr9y+WVbv+FKPZ4PR69So3lzta3cuuWSTg8O9XLCF5gFGjRsmcOXPUhya6C/gLvXr1knXr1klcXJwEAoH2fEjOs2bNGhUSOX78eHnhhRfSb+e5RQghRMNqtYjh3GIxHZ4srhbshJ8xS8w2k4TedL5blblCNUkbMVYsNeuLr0hLS5MVK1a45OCpU6eONG/e3C8FHrPFJIfO7JL566ZKiiHJ5fXrVm4m/Vs/IBFhUT7ZP0L8Af975RIiIqdOnZIGDRpkur1AgQJSuXJl6du3rzzxxBNSsGBBtx+jcOHC0rp1a1m4cKHkFqtWrZKZM2eqADy0U0aIXfny5VX987Bhw6Rp06aSV/nxxx/l8ccfl88//1yGDh2afvvEiRPlvffec3o7tpNy4nsWL14sU6dOVZ03IH7ExsZKqVKlpHHjxnL77bcrYYQQQggJNMwJx+T6vilSIPmgS+uF3LRI4ZVGCY1zXuCxRhYQw8D7xdi5n0iId6dkKDnaunWrHDhwwKX10Aa9SZMmUrduXb8MVgYnLh6UvzZOlytx511aLywkXNo36Cut6/aUUC8fb0L8EbfPckzgqlevLk899VS2y37yySdy5MgRNeEjxBWqVKkid911V3po3LVr12TJkiXy7rvvyrJly+Sff/6RkJAQyWukpKQooWru3LlKvGrfvr16PYGjR4/Kr7/+KtOmTZOvvvpKBg8eLIFEmzZtMt22Z88eWbRokRLebO+3tzzxHXht4QfnZffu3aVixYrK6n3w4EGZN2+eHDt2LOCEHrzO8JokhBCS/7CaUiTtwCQxX1mr/nelgCc42SqFlxkk7LrzAo/WRcsweJRYCxcTb4LvyocPH5bNmze7nC+Dizq9e/eW6Oho8TeS0xJl3trv5OCZHW6tX7Fkdbmz3SgpXLC41/eNkIATembPni0tWrRwSuhBmvv69esp9BCXqVq1aiY3B+ynXbt2lS1btsjatWuVSJLXGD16tBJ5OnbsKF9//bXqYqAHLoqPP/5YheUFGm3btlU/tu4fCD0QdejeyV0n3fvvv69cZRBUy5Qpk+F+iCG4QhhoVKhQIbd3gRBCSA4DUcR0ea3cPPiVRJmvubRu+FmzxG40SoiLVUMIWU597DWxFvV+1ypcDEUZ8qVLl5xeB8HKtWvXVg7yiIgI8TcsVotsO7xK/t36i6Qak11ev0mN9tKl8UApGFXIJ/tHiD+TI741i8Xi9wnteY0//vgjVz4Q8YOxzGo877jjDp/uBz6IIBTs3r1brl+/nn776tWr5eeff1ZlUBcuXFC31ahRQ+699171Y5vTAfCBiBIuDdsyI5R1fffdd7Jz505JTk5WggwC6caOHatql/Xg2MAZgJIXTJixLMqvnnvuuQz2V+znb7/9phw8EDjgnLAF+zRhwgQlauk5ffq0mojDzXT16lXV3rJTp06qvMnRZNVoNMqHH36oxFl8+GM55Ao9+OCDmZZNSkqSKVOmKOcGHisqKkpuu+02GTdunBJ29WglWH/99ZdaFoIVnHso74ELBLlFmvsPPxqe5qC4+nwmT57s8vPB+H3xxRdy/PhxNY6PPfaYPProo2qMP/vsM5k+fbqqcy9Xrpw8++yzMmTIELu5TThv8FrF8ufOnVPlTzi/8PiwR+vBcjiGuBKXkJAgRYoUkVq1asn999+f6TX1999/q3MVrwGDwSDVqlVT+4B91NfS4zk3bNhQ3Yf9fOWVV5Q4imPYrFkzeeutt6R+/f9lAqBUC+/XuKJnK/IAHD9bkQ6vtR9++EGWL1+u2rTGx8er59mtWzd5/vnnM7Vg1R8bHGs413BskG+F18rAgQPVc8JY/PLLL3L58mX1/PB6gMCrR8vWuXjxonIh4XWFEkhs64EHHpCHH37Yqc8eexk9+tJDHAtsH86zyMhI5XR65513pGjRopm2hWOBcTxx4oQUL15cPZ8XX3xRSpcuneulooQQQv7DdHWzJB2YLKHGa+JKSkvMeqNEHTGLK7Maa3CwpEz4RiwV/3Nuewt8XgN8Brrz2YLvN/hcwmeVv2EyG+XvLXNk88Flbq1fpmgl6dNihFQo6d1jTkheIkeEHkwE/NEGmJfB5Ce/gkkgJquYwOknqZjQY2KOCWzZsmWVGwZuMogyECDefvtttRxECAgjmEhCJLjnnnvSt6Hf3ksvvaQmeZhwYyKICSsmpMjVweTZVuh59dVX1WQRk0CIL/jQxeQQk2pMsDVmzZqV7uqxJ/Lo0V9dQUlXjx49lMCD37gCs3//frU9lLDhRyv/0oMJLybwXbp0UWVuED2eeeYZJTSMHDkyfTlYfAcMGKCWRT4SJuQ4z7A8hCUIWP369cu0fQhDEM+Q3YLnjcdo1KiROv5w6eB2/XH1FFeeD7Kctm3b5tLz+fLLL9X5hf2GqAExAoIFxgrCyp9//qnGGE4yuLKwXZxT+LJkC9aD8Ni/f3/1HogxgqC0b98+mTFjRvpy2Jenn35aiQEQWSAgQMTC88R5pBd6IDS9/PLL6rwcNGiQ2i8IP7gNrVJxPtiKGxB8cLzQOQPiI0QIjA0ET9i7NUeZJlzgdeQsmlsTbVdR149xwHHCc8JxxuulUKHMV9IgfmBscC5jHHEsIdZB5Pzmm29UqRiOM8YRAg5ep9hXlHPaAiEXIowm4GLM8BrH89Ze9+6CY/vvv/+q/YRIiOf7008/KVEL46kHj/XBBx+o4zlixAh1LHC+QbwjhBCS+5jjD0vcng8lMu2005Og8PNmKbTKKMHON3ISS9lKkvr4a2IpX1W8DS5K4OIKHDzugu8s+B7pbxfiIV4dv7BPFmyaJdfiL7q1jQ4N7pCODfr5bcYQIX4n9ODqNb4068GVW0xsHQGbP77k4wsxJt+EuAomnJgYA7gp4ODB5BHi4RtvvJFB2Jg0aZIKataDbJE777xTOW3gdoCwg6v9KA+C0IMJur1SIUzgMHmFmLNgwYIMV+6xTb2TSANdt/B6wGQdwJ0AdwsmrZh0hoeHq9s3btyofmNi7Aook4TIg8wrvUMJjiMIHXCJQISw5fz582pyitprgOMAVxIEA70wgucLYQGZSHAkaB/+jzzyiHJSPPnkk9K5c2eJiYnJsH08ZwhqCO7Towk9EMn0LilPcfb5QPiDkODq84FYAteVdi5BkMM4QkjBBB6PrV39glMGAgrELntCD8qcIBrB+QMg+EFcwjjBwaMJOBB9cH5AMLN1wOjPNQg0r7/+uloG3TNQYqXfLkQhuNpsc50wRlgPoqcG3DxwRsG5opXgQqjBNiFs3H333Ur4w21w1Dj6Mojz+NChQ5mC0eHagQj27bffqvPTFogf2C/tWOIcwXjAwYTXHY6zdoEAt993331KhIOjzRbkBmF5TVDCaxrjAlcWxDAIj+6C9wK8B2gOMLSjxbhhXFE+qn22QYj96KOPlMiMzz1tHLEvtk4kQgghOYvVmCDxh3+Q4Et/S6Q4kadjtkr0XrNE7zFJkHNdyBWp9z0jpna3i/hAZIBzB5/9iYmJbm8Dn434fuNvAk9iyk35Y/00OXhmu0vroWvW7bcNldgChaVssSpSINL9Ji2E5FuhB5MB2y/YSHLXrqA6ApNzoJ+YEuIsmNja69CkOSr02Io8AGUsmCDigxGTaL17JyvgRgBw5NiWZ2Cbtpk6AKUxmsgDihUrplwhmPDCUaQJIZobCxNCV4RW7D8cGXoxA2BiDDEJ4sTZs2fTJ/96p5EmimjlbGiXiUk2SoQ0oQNlMnAgvPbaaxm+AMANA0ED5UcQEmxFBOyPrcjjS5x9Pjju7jwfCEf6cwnHE5N8HF+ci3qLM2rasezevXvt7iu2pYk8AGIORJmePXuq0jO9Uwf7alvOBfTnH0K6ITQiyFs/znB+QcjB6wLbtX1OEDfHjBmT4bbhw4croQfingbEGrzXY7/ReQs/AMcbYhrcQLbv+bbClAb2AQLnypUr7Qo9cDDpjyUEJRxLXBiAqKZ3gcKZhWPj6Djjtad3DeFvPCZEPRwPT4QeCEX6Mj+4j3D+QOjBsdOEHriOIAKh3Et/THA+Yl/slRYSQgjxLebrOyR15wsuTXoQsFxksUFC450LWE5t3kmOtLxdytSup8p7ve1w2bFjR4bPamfB5ygc1bhYg/3yJ4cL5oeXbpyRX1Z9KVduutY9C9Sv0kJ6NBsssQWK+GT/CMlXQg++OOsnFphQYtJib8ILMLFCSQFs9vjCjy/qhLgKruSjpEPvboAjBiUxKKWAM0JrQY5JPpwVmLxjsoh8FtsrIc4CJwgmz650fEI5ly3aJN/TUGWUpQC4RmyvwuCDG+3Y4ZDAcrZCT3b7hYko3HnIpalZs2YGYUIDJUwQRrB9WxEBE/ScxNnng3MAGTeuPh97ZWaagOfoPkcBxRBHbEH5D8RCbUwBclwgYGF5CAvYP4gLekELoCQK2DsvsV18kdNvV/+cbL/gOTo3IYTBHYMyKYiLyNLBa04TfmwdUgCvQ2TtwNUGSzkEj+xed46OJcbN9j6IKxBPHG3L3nHWbrN3PFzB2de1JkLZ2xcIkYQQQnJORDBfWilp+zNfKHREUIpVYrabJPKoa/k7yS98IsmVbxHTmTPiLWEHn1v4DHYXfN7jsxyfX/rcPn8gPum6rNqzwO3snWpl60r/1g9IoWjvdisjJBBx+tUPCz5+NJAPgaukyC8gOY8jgc0fwph9CdwNcMlARESpCspP5s+fr3J7kG2Cieatt96qyk6wLCaIKDmEu8M22DgrIBQggNWVqx+2JUBAa/2un/hi7LBPKD+z50KyB0SsrNwTCL/VL6fHViywt1/aeo7Oq6y272iffIUrz8ed45XVODq6Dy4be9g7nlge5ybOMQ2Uh+E99fvvv1claBAs8eUMgcYI/dXOk6yeF16TuF0LIs/uOWlf/vTnpn5bECc0gQKvewio+AyA8wuuHs3Zg32FSwnuHGQ0wammXdFEqZWj111Wx9nRGCPvytnjrN2mP87u4OzrWhsbe6GWufF+TQgh+ZEDp3ZLyoFPpFa48y6RqP0mKbjTJMH2P2IyYSlVTlIfflEs1f/fzexiG3Nb8BmLCxm44AYHtydNK/C9FReM7GXj5RYGU5os3/G7rNuXMdfOFZC507Z+LwkL/S8GgRCSPW7LvMjz4JfX3MPXna0cXWWAoAInV27bPzUXiWZlRRYMRB6Uo2DiqQeOIK0DlLPgAxIlVnjO3n6ucGpA6EGOh7NCjzbZREche2jlYPYmpa5s31HId1bb97c675w4Xs6Cx0FpmR6IA3Cm6d8/cQxx7uIH98FRg/MWQb7IqUJZGsQF/fNCvpTtF0Xc7ovnhP2DkApHEUp4UcYGoQcCF8KH4cSxzRfC/nz66aeSE+A423ad08bYnmjkC7Tjjhwt27HJz+H5hBDia6ymJEnY+6GEXN8g6t3XSS0gKNUqRVGiFedciZY1IlJSXpgsliq1xFugQgLxAmg84Am4gISy8OyafOQkqYYUWbFznqzf/18ZuKtEhhWQTo36y223dJaQ4P8usBBCckDocTbrhBBfoF3t0DKgkOUD4PaxBeG69oCAo7WmtCckIZAWORyuhiZnB3JO4IqAcwNlMGhZ7Qi4IVBCppWyQADQXFUa+B+3A3e7W2EyjBwXHEeEHdvmB+E4uLp9e66HnALPByIaRBJvPR93wLlnG9IMOzYEEkePjS9rEFXwg44aEFXwPCAYwa2GYGDsv23JHMrH8EURJVy+wjZwGfsHxwzysmxdRsgUQCB/ToDjbCv0aK97X4+xRr169dTYoMwN4d16PLHgE0IIsQ++/ySeWypJh7+VGHHevRl+xiwxm00SmuicwGOq20TSHn1ZrLHey4OB+xYZdp4EK8P1iwsLuXHBzWwxS1LKTYkpUCTTd9LDZ3fJTys+E5PFSYuUHQpHF5dHer8qBaP8x5lESF7DY6sCJsroHoOOPyiXsc3iQb4DrkY7mlAT4q6jDCCbBmiTPK2jlQYmxMhisQdKZdAu3R5acCqygG7cuJHhPkzSPblCD+EItloENMPBYc91gskzuooh90R7fshtQQD6zJkzMyyLZdD1CNu1zedxBYhOKI2ZMGFCuoCmZY8g0BbiCTpoOQuOL3B0jH0NAnO9+XzcAd3e9M8fjrg333wzk1gON4x+HwH2XTv3IPYBdJBDyRXOf32JFraL0Gnb7boKsqngfrN3ZRFOFa0lvJZDA3EHQiXcdMnJyRmEWHSdyyngKtLn5eBvBE3jy2dOXZRAzhLEY4yNvuUtssLQEZAQQoj3iLt+XHaveEqCD09ySeQptNwgRZYbsxV5Usa9J4nTV6qf1OcmeUXkwWc13DvoRokLA+6KPHD1P/TQQ+oCXU6LPOeunpBXpo2U12fcLx/8+pS8Ov1e9f/bP45Sv/H/rGUfuy3y3NvtOXnz3uny9J2TKPIQ4iEeJXQdPHhQddzBhFWbpNi+4aDVL4I7UYJg2yWJEFfaqwNMfDdt2qQmloULF1adhgCCmXFVAy21IYbUrl1bnZcIj4UzAmKkLRBGcF5iIginBBwosL3iyjyukiA3BWVguDqPbWBSC3cIHBboevTYY4+5/bywXbxmUJ6DwLyOHTuqVvG4Da2i8RjI/MBrRwOtm/E80RYcLZ/RgQvPFTlZyAXB/Z6AbkFoXY/XLIKd8XqFCIVjBHEL++JKWRCcJRABkNOCib+WXYIOSTkBjhNcWd56Pu6AoHAEJ6NNOezUGDeclyh70pdforU4hCcsD1EPIg+u9OE9FstppUAIt8c5j65UcAr1798/w3bhaIPg7i4Qj5DDA5EGIipcRBCWkBmA1xK+lKKzF/KxAISNBx54QLnT8DxxfuK8Xbp0qXoeyLnKCdBRBPur5Qb99ddfSmDDOe1Jxy1XwLFCm3qIOtgXHCMcO+wL2sXv378/10teCSEkL2Mym2Td9rnSNOEHQY/K6k6uF2T4r4tW2PWsxR1LmQpi6H+/mJp3FG+Ciw+4yITPAXfA3AouXjhUcytc+dj5fTLt34zdl/WkGv93scdVWtXpLl0aD2L+DiFexu13C1zdxSQD4WGYJGOCgXIUrYRGA1egcVUbGSoUeoin7dXhbEAZDiaXY8eOTXfyoKQEnX/QuQhlTHDyQAjBVRMINPaEHrROBxBVMFGG6wzbhtAD4LxA62RsA+ujjAohvnDWQJjxBAggaOEOR8+sWbOUeAWRRevog9cWRFR9eQ4mkrgShOOBZSFiQDyBSIA21ra5IK6CAF08T+SqQAz54osv1H5CUIBjz143oewcPXBT4TjDCaKV8eSU0IPng3Pik08+8crzcQc8d4SF4/mjDh/nD1xieHw9cONAHIGjBuei1rEQ4h3OET0QGatWraqcI3jPxRVCCB0IJkdbdE+u7uE9+ptvvlHnF/J44JCDIwWiKs5FONEgjOoFC+w7xhouKZzTeL3B3YLnmRPHWHO1QRCGcAq3Ha5y4nXy8MMPS06CUGq8h+AY/vDDD+pYQOTDuGBcfS0sEkJIIILvZ5sPrpaaFz6UpkH2mx/YIyTeIoWXZO/eAWnDxoix8x0iXsqC8aQtuh58J8SFSdvS6ZwiITlO/t4yR/acyOiY95RSRcor9w5dO4T4jqC4OCcTyOx8ocVVXJRHYMKByQXcEJiwIkxUD8pJMGlBeQJxDjgPcrqbUV4KYybehWPrXeCKQQkUnGcQHXKLQB9XlN6hNNiTDiU5AdxZcPjAZYZSQm98BqC8Dk4riN1alzMSGHBsAxOOq+ufX9sOrZE6F/7n6naW4BSrFF2YJiFJ2TxG4eJiGDJKTM07wTbjlbHFBUm40XFhzrYk2xkwX0LTjtwSdjK4p/b9LWv2LJA0o2dB0RolCpWV+7qPl5gChSWvwNdtYJKaT8bVbUcPrk7izQxXTbO7goyJDloGEkIIIYEKnK5wN2lB5AAilCbu+DoTihBC8jrJJou8uXqvdEqdKq0iDzm9HjpoRe8zSYG9ZnFGsjH0uEsM/e4VifJOlyqIOvv27XPLwQPHdvPmzbNszpFTnL1yTL5e+IZXt3lX+8ekXuXb/LJLKyGBjNtCD1QwlAs4Y0VHGUJOdV8hhBBCcgOtmx7KO5FPhNJmlMHBnYOSN192RCOEkLxKXJpF1l9Kkz0nd8sTptfkZdzo7EV2s1UK7DdLwd0mcbaqK+ndGWIt41m5u955hLxEdL50FQgfaGJTsmRJyW2S0xJl6fbfZMuhFV7bZtfGd0rrej3ZGp2QvCb0oBTAXmcWR1c5ETRKCCGEBCq4IosS5VWrVqngeDh7atasqXKptE5+hBBC/uNCslle3XJTlp28LC8W+U2eKLjWpfXDLlokdoNRQuOzLpEy1b9N0oaPEWsp9zuTZtieyaQy9ZBl5w7I6+vSpYu6EJ5bwIG0+8RG+W31Vy6vW7hgcbmn4xg5cfGg/L1ltroNQcp3t39cqpapw1BlQvK60IMwUKTHI4+naNGiDpc7efKk+kEAKiGE5AfQaQw/xLcsXLhQ/AkEViObiRBCiGO2XjHIg8svyYiIX+WT2H9F/uur4TSqi9a/Bgm7ln0GTsroN8TcpK1HGTwaWmdUNP1Agw5X6dChg+qwmpslTClpSTJ37Tdy6MxOl9dtULWVdG96d3rGTplilaRV3e4+2EtCSK4KPQheRtAoOr04auuMN8SXXnpJvaGhPTUhhBBCCCEk/3Ei3iQvbroqFeMXyroSv7q8fuQxs8RsNkqwIftlUx9+UUytunpF4Llw4YIsWLDArXXRERUCD3JNc5Lr8ZckLum6lC1WWSLCIsVsMatwZZRnuUqJwmWlT4uRUqX0LT7ZV0KInwk9aBeL1sloa4v8gfvuuy9d3UZ+z969e1U3LnREqVy5smoVTQghhBBCCMk/pJqs8tnuKxJ5ZoZ8F7NUpIi41iJ9mVFC4q3Zhiybq9WRtHvHiaVi9VxvjY6A5VatWqmoi5zCYrXI9iOr5Y/1P3htm63q9pBuTe6UkGC3p4yEkFzC7VdtoUKF5Oeff5bBgwcrlVtvoW/QoEG6oweBlLNnz/aLJHlCCCGEEEJIzrD01E25uu9zGRW5WiT7/i0ZKDY/TUJvOteiPOXJt8XcqJVbDp6bN2+qMH1v0LRpU7n11lszdF/MiVboK3f9Iat2/+mV7VUuVUu6NblLKpT0TDAjhOQuHsmz9evXV44ddBmZN2+eHD9+PP2+cuXKSf/+/WXs2LFSrFgxb+xrvgNCGVsREkJI/nvvJ4SQvMzpBIMs3PyHjAia6nwHLRGJOGmWmC1GCUnOflljmx5iuPsRsca6YBGyCVXeuXOniqLwFHQh7t69uxQp4t6+uEpSaoL8uWGa7D/lerevrBjaeazcUqGRV7dJCMkdPPbhFS5cWF5++WX1k5ycrFTx6OhodtnykMjISNXVjE4oQgjJX+C9H58BhBCS1zh60yhPL9kqz0TPlBER/7sA7AyFlxgk4rzFqWVTnv9YzLUbuV2ahbIslGd5QrVq1aRt27ZiNptVbEVOfGc/cm6PzFjyoVe3WaFEdRnQ5iEpXqi0V7dLCMmjQg8Ua5RvHTp0KD1gDG0Cc7NVYCABsezatWvqb3zhp7OHEEIC38kDkScxMZFOWEJIniLBaJFPtl+UIhdmycwiKyQkyOp0Bk+hlUYJu5H18mnDnxRjp74iwe6XRCUlJam4ifj4ePEEVC107tw5ff4DoceXpBlT5Y/138ueE5u8ts3OjQZIm3q9JDSE2TuEBCqhnggRULJzOkU+vxAcHKy+6OND6erVq+IP4AqIdqUZ+0cCB45tYMJxzXtgrPDez/EihOQFkA8zZ9tmuXBhpwwvsFJKxDonohTYbZKCO02SlR5kqtNYCTzWspU82keDwaCiJo4ePerRdtq3b69Cln198RWi/8Xrp+VG4lU5f+2k17J3QK/mw+S2Wp35GUNIPsBtoadSpUoSFxfn3b0hGcCbMGp+8eMPYMKIqyClSpViWUGAwbENTDiuhBBCfMHpq2clYcerUjnkvAzADc58VbVYJXadUSKPW7LtoJUy+g0xN2nrUXv0y5cvyx9//OH2+rfccovUrVtXxVT4WhiJS7wmSanxsnT7XDl6fo9H27rtls7So+lgCQsNl1RDspgtJkH0W8EoxmoQkp9wW+gZMGCAvP322yrATOuyRQghhBBCCAk8DGarTN51TZJO/ipPxC6SYiFGp9eNOmiSmK0mCcqmyill7Dv/dc/ygOvXr8uqVatccsQXL15cxU8gY7Rs2bJSoUKFHHG9nL58RP5YP00ux531iVsnMpyRGoTkV9wWekaPHi2LFy+W4cOHy/fff6/aCRJCCCGEEEICi7+PX5W0w5/LY+EbRAo7uZLZKtF7TBK9xyxBWWQsG24fLIb+94mEexYHkZCQIBs2bJBTp045vU5oaKi0bNlSatWqlSN5mClpSZKcliDr9/8rmw8u83h7URHR0qPpELm1akvm7RBCMuD2O8JTTz0lFStWVKn13bp1U2+QsDg6CmPGmyfasBNCCCGEEEL8mzSzVd7bfFL63HxD2oVfEAl3ft3ws2aJ2WyS0ATHITxpQ0eLsfMdIh4KFHDwzJ071+X1KleurHJ3wsNdeGJukGZMkWXbf5cNB/71yvYqlqwh93QaI9GRLMUihDjG7XfW2bNnK/EGgWHg4MGD6scRFHoIIYQQQgjxb9ZeTJPHlh6TL4pNkacjTrgk8AQnWiVms1EizjjO4TE1bSepD44XiYr2OGQZF5z37t3r9DpFixaVZs2aqYvVvuZGwhX5e8tsOXB6u1e216puD+nSaKDK3iGEEJ8JPePHj3d3VUIIIYQQQogfse+6UZ5ae0namf6QDWX/cnn96N0o0zJJkMn+/cZ2t0vakMdEChT0aD9xkfn48eOyceNGSU5Odno9xEwgV9TX2TvXEy7Lb6u/ljNXPOvypdG50UBpU+92lmYRQlzC7XeM559/3t1VCSGEEEIIIbmI2WKVH48my7Mb4yTNLNI1aqdMLjpHKoY6F2IcetUisRuNEnYtix7pEHja95a0YaM9zuAB6Pi7fv16OXfunNNdgpHBkxMdbE1moyzf+bes2b1QTBbng6ptqVupmfRrfT+DlAkhHkFpmBBCCCGEkHxCsski0w4ly4c7b0gVOS53R52RYTGrpG74Gae3UXCLUQocMEuQA43HWqCgpA16SEwde4sEh3gs7uzZsyfLiAh79OjRQ3XP8jVGk0H2nl0vv2/bJompN11ePzw0Qkb1eUOKFyrtk/0jhORPKPQQQgghhBASwKDcaf7JFLl/5TUZUnCNfFBshows4/p2Cq0wSMRpx/k7wNimhxjufkSssUU82WU5f/68LF26VNLS0lxar2/fvlKqVCnxNfHJN2TBxhluZ/A0rdlBbr9tKDN3CCH+JfSsW7fO6WVDQkKUZRLBZzlhnSSEEEIIISS/g/KsL/Ylyitb46Ve+Cn5s/QsaRxx3KVthCRYJHadScIvWbJ+rPJVJW3kWLHUvNWjfUbuDvJ3jh075vQ6ZcuWlVatWkmRIp6JS86WaK3du0j9pBlTnV6vZvkGclf7URIcFEJxhxDiv0JP7969VSctV8Dy9erVk4cffliGDh3q9Ho///yzbNiwQXbu3Cn79+9XKfuff/65w23Ex8fLu+++K3/++adcvnxZqfr9+vVTAdIFC2YOgLNYLPLtt9/K9OnTVbhbdHS0dOjQQV555RXVetEey5Ytk0mTJsnu3bvV80K427PPPqvaNBJCCCGEEJJbXEw2y/Dl12TLFaPEBiXLW0XmyYiYFRLiqNbKATEbjRJ12HGJljdbpd+8eVO1STebzU6vU6BAAWnRooVUrVrV5XmJqxhMabJq91+yerdrQdVDO4+VWyo08tl+EUKIPdx+Ny5fvrx6Q7148aIYjf8FjsGtg5+EhAT1A8LDw5XQkpSUJNevX1fCyOjRo2X16tXy9ddfO/VYb731lpw5c0aKFSumtoW/HYHH6dWrl6rl7dSpkwwaNEg95pQpU5QLadGiRRIZGZlhnbFjx8qMGTOkdu3a8sgjj8iFCxdk/vz5snz5cmUZrVatWibhCcsVL15chgwZom6bN2+eEpOmTZsmd9xxh8vHkxBCCCGEEE/Ydc0g/Rdfk+tpFikRfFMWlZ4sDSJOubSNoFSrxGwzSeRRc5YlWiD14RfF1Korrua6vc8mk0ldzN21a5e6+OrUPgYFSd26daVJkyZqruFrUJ61aNOPEpfkXFB1+eJVpU/LkVK2mP0LxoQQ4rdCD4QUOF6++uorJZSMHDkyg/vl1KlTyiHz2WefKeHjzTfflGvXrqnb3n//ffn111+lZ8+eShzJDog0UOpR+vXxxx/LhAkTHC47efJktW/Yp9dffz39dvz9ySefyBdffCHjxo1Lvx2CE0Qe2D0h7mgfFnfeeaf6gUvn999/zxAI99xzzynRadWqVVKuXDl1Ox6vXbt2atsQmFiiRgghhBBCciJ/59O9ifLa1nj1f7XQi7KpwgQpEGxweVtRh0xScLtJHK1qKVZK0oY+IeZGrTwKWcZFYlyAPXLkiFvr9+/fX30X9yU3k67Jos2zZf+prU6vg05Z3ZveLY1rtJPgIN+2cSeEEJ8IPXPmzFHlUxBOBg8ebLed4auvvio1a9aUxx57TLll7rnnHiWEFC1aVJ566imZNWuWU0IPyqic/aCbOXOmKs+CQKMH/3/33XdK1NELPfgfvPTSSxmuCHTt2lXatGmjXD1wEGmp/RCDYC194YUX0kUegL8feughVTK2YMGCdKcPIYQQQggh3sZitcqMw8kydn2c+j8yKE3GFlogj8QulvAg58ufQMhNixRabZSw645rtIwd+0jakMdEIqLc3md8V0f2DjJ4UlJSXFoXcwpcmA0LC3P78bPaL2TvhISEyvYjq+WP9T+4vI1yxarKiK5PS4HIzDERhBCSZ4SeqVOnSpkyZeyKPHpwP9w8WB5CDxgxYoQSgWDR9Cb44EDZVefOnVXOjh7837x5c5Wtc/bsWVV6BtauXavuQ32vLdgO7scVB+154n8A14695SH0YHkKPYQQQgghxBfsvGqQpzfEybarRikSnChTS3wmzSOddMeYrRK9xyzRe03ijB6UOuIpMXXsIxLsvkMFJVlw3G/evNml9apXr66+vyOLxxeYLSbZdGCp/L1ljlvrlyxcTro1HizBaVHqorBtPAQhhOQ5oefQoUNSq1Ytp5YtXbq0HD58OP3/4OBg9ca9d+9e8SZaOj/KvOyB2yH0YDkIPcjzQcZQnTp1VGcwe8vrt6v/2za3R3+bs10CUlOdT+r3BxCCrf9NAgeObWDCcQ1cOLaBC8c2MPHWuB66aZKH1yXKoZvIz7HI4ILr5KXCv0nRkESn1g8/a5aYzSYJTcg6XdlYo77EP/ySWGMLa0/A7X2+cuWKbNq0SW7cuOHSenDXYw7hq+/Mpy8fkcXb5sjlm+fcWr95ra7SsUF/MZvMcunSJb5mAxC+Hwcmhjw8rq6IyW4LPQhBg6CBALXQUMebwf3oZGWbhI9EfVvXjaeg2xYoVKiQ3ftjY2MzLKf91m7Pbvns1tFyefTLZ8X58+dd6izgL+DDjAQmHNvAhOMauHBsAxeObWDizrimmkXeOhoui6/89307TEwyvvCfMqbQQpe2U2iFQSJOW7IMWI6vUltO9n9IzAViRG4m/PfjJphEYQ6Ai6rOgu/XNWrUUN+pkeOTVQMWd0u0Tl07IKsP/S9/0xUiwwpI40qdpVrJW9Xc5vy58+n38TUbuHBsA5NLeWxcYUxxZGjxqtDTuHFjFWT89ttvy2uvveZwuXfeeUcFGOtzdmDfxBt/2bJlJT+T154/PrDxgkDns5zocEByDo5tYMJxDVw4toELxzYwcWdcL6dY5L41CbLtmin9tlYRB+XtorOkZvgFpx87dp0x2w5aKe16SdKdD4uER4in304TExNl8eLFkpyc7NJ6LVu2VO54X7VJv5F4RRZv+0mOXXCvoqBamXpyR8v7JSo844VqvmYDF45tYGLIJ+PqttCDLlPoOoUuV8jaGT58uNSvX18FIeMNHmVZCEZesWKFesPG8hoIOMYy9nJxPEFz2SAs2R62bhx7jp2slrddB6HSerSW8o4cQrbk1TpevCDy6r6TrOHYBiYc18CFYxu4cGzz77jeSLPI+E1x8sux/4UVlw25Ji8WmSv9ozc59ThhlywSs8koYTcyl2hZg4LF3LStpA1/UqyF/vdd1tOzDS515PBs377dacc6cm0wf8DFT18JPEaTQdbuXSSrdy8Qk8Xo8votaneVbk3ukrDQrCeEfM0GLhzbwCQ8wMfVbaEHDp0PPvhAdZ+CmLNy5Uq79kiUdU2cOFHat2+ffjscPk888YQMGDBAvImWkQO3kD2027XlUDqG2l+0gscHkm1Oj+3y2t87duxQZWu2Qk9W+T2EEEIIIYQ44qbBIm9vj5dvDiSp/4sFx8v0kp9Ko4gTLm0ndq1BIo/ZL9GyhkdK8oSvxVq2kniTc+fOqWYkji622oKsztatW/v8avqRs7tlwaaZcj3hskvrlStWRYZ0GiOFojN+1yeEkIAXesCDDz6obJZTpkxRLh2ErWmUKFFCdaGCoFO3bt0M6w0aNEj9eBsILOgEhsA3BC3rM4DwP25H23et4xbAh8zcuXNVm0f8rQfBzQCtHPXL//bbb+r5NmvWzO7yttshhBBCCCHEHrgw+svxFHlly025nmKQu6I3ysfFXWvvHZJgkYLbTBJ5ymL3fmPzTmIY8phYixQXbwKHPr5fO7rIqgcXfxs1aqQcPPaaoHiTuMRr8veW2bL/1NZslw0PjZROjfpLueJVVIv1iiVqSHhYhE/3jxBC/FroARBxvvrqK/U3VHxNYHEUiOxLYPlECdn777+v3Eavv/56+n34Hx9G48aNy7DOyJEjldCDrKH58+enX1lYsmSJaqWONuoVK1ZMX75///4qk+ibb76RYcOGSbly5dKvZHz77bdSrFgx6d27d449Z0IIIYQQkjc5cMMoz2yMk3UXDdIi4pD8VGaW1Ar/X8CvMxTYb5KC2x23Sk95aqKYG7b0zg7/f9bm/v37ZcOGDU6vU7lyZXVxGBEPviI++YZ8s/ANuZl03el1aldsIr2bD5NYOncIIQGGx0KPHog7vhB4ZsyYkf5hgg8WgPwfCDEAHxwjRoxQfz/55JOyaNEi+eSTT2T37t3SoEEDlSEEBw4CpEeNGpVh2+3atVPr4jFQXtatWzfVHWDevHlSpEgRJRrpKVy4sBKNHnnkEbU8hB+A5a9fvy4//PBDevctQgghhBBCbB08PxxKlnEb4vCfyt05V+lbl7YRZLBKwR0miTpkliCbGB5zpRqSNmKsWKpndNR7CjrpIn8H36tdoUePHiqLx1ecvXpcvl4wwaULw3UqNpXuTe+WIjElfLZfhBCS54UevPHv3LlTuVqQsD9kyBDxJhB55syZk+E2lFrhR0MTeuAmWrhwobz77rvy119/yZo1a1SiNkrIxo8fL1FRUZm2D1GoTp06Mn36dOVOwjbgynnllVekSpUqmZa/++67lXNn0qRJMnv2bPWBAUHp2WefzdBdjBBCCCGEEI3FZw0ycs01JfB0i9opU4p/KwWD01zaRuQxsxTcapSQ1Mz3pQ18QIy97xEJDvFqhxrEE5w9e9bpdfA9GVEG+A7uK5LTEmXptt9k6+HMOaGOKF+8qvRpOVLKFqvss/0ihBB/ICguLi5zHL8LVyQgdnz++ecZwtfgbNEYM2aM6s6Fsih7ognJO6SmpsqZM2fUVZlATijPj3BsAxOOa+DCsQ1cOLaByb7LSTJ+/TVZeyNE6oeflA+KTpf6Eadd3k7hJQaJOJ8xh8dSuJgYBj8mphadYFfx2j7je/7Ro0dVBk9Kyv86gGUFIhCaNm0qtWvXluDgYPEFKM36dtGbLpVoRUVEq85ZjWu0k+Ag7+4XX7OBC8c2MEnNJ+Ma6smbP1w0cM8AHKgbN26oHBw9CGRGmdWCBQtk9OjRnu8xIYQQQgghfs6hOKPct+K67I8zqf8LBafK20XnyYiCKyXYtt4qCyIPmyRmq0mCbTqDW4ODxdhlgBgG3CcS9b8GJN7I4EF51tat2QcZ66lRo4bcdtttUqBAAa/ti9ofq0U27P9X/tmS0d3vLE1qtJeuTe6U6EhGKxBC8g9uCz0opYJ4U7VqVfn+++9V6VLPnj2V6q+nS5cuStFHuDGFHkIIIYQQEsj8cTJFRq74n9skSCwyKHqDvFzkVykekuD0dgotN0jEWUumDB5grlFP0kY8JZaK1cSbIKcSbdL17nxn6NWrl5QtW9ar+5KSliS/rPpCjp7f6/Y2Hr79FalQsrpX94sQQgJa6Jk1a5bKppk6daoSeRyBvBu0ND98+LC7D0UIIYQQQohfM+94kvy+ZYl8VeIrOVfJvW1EnDJLzCajhDiolLLEFBbD3Y+IqXV3ES+URsGhf+nSJfWzefNml9atV6+ecvB4u1X6pRtnZebSSS6VZunp02KENKreVsJC/+ukSwgh+RG3hZ59+/Yp5b5hw4ZOBbK5EuBGCCGEEEKIv3Mh2Sx3/H1RusoiebHIXOnmZhOnyKNmKbjDKCHJjpcxdO4nhoEPiETHeEXgOXLkiMrRdJU2bdrILbfcoi74epPElHj5d+vPsuPYf111XaFWhYbS67Zh7KJFCCGeCj1paWnKqeNs4FFERIS7D0UIIYQQQojfYLRY5dt9N+Ta0d9kRZHf3d5OcLJVivxrkNCbjjN7rOERkvLyZ2KpVEM8JT4+XuVr2mZqZgcc+ghZRg6PtwWeGwlXZOo/E+VmErqRuc7QzmPllgqNvLpPhBCSb4WekiVLysmTJ50SeZDYX7ky2xgSQgghhJC8i8lilcl7EmXl/g3ydtEfpVqhS25tJ/ysWWI2myQ0wbHAY6rfTNKGPSnW0uXFU5KTk2XNmjVy+rTrnb4Q0dCoUSMJCwsTb5JqSJblO+bJxgNLxCquNwG+v/vzUqVMba/uEyGESH4Xelq1aiW//PKL+rnrrrscLvfDDz8osadt27buPhQhhBBCCCG5Asqc9t0wyZvbbkit+Hkyvsg8ebSUe9sKTrRKzGajRJyxiCNfjKVoSUkb+oSYm7T1uF06HPjonrV//36X1oNrp3r16ur7PlqmeztkedmOubLp4DKX1mtbr5d0aHiHhIaEeb1FOiGEBBpuCz2jRo1SIs/48eOlYMGCcvvtt2daZsaMGTJhwgR1BeDhhx/2dF8JIYQQQgjJMYHnp6NJsnTH3/Jp8anyPTKHi7i/vQJ7TFJwt0mC/uu2bhdDryFiuGOESESUVzJ40A0XF1xdAS78li1bqu/33gT7tOv4elm85WdJTL3p9Hrdm94trer0UF18CSGE+FjogY3z9ddfl9dee02GDRsmpUqVkpSU/1oE9O7dWw4ePKhaM+JN/d1331VXBQghhBBCCPH38qxvDiTJjzt2y8Ris+TT4sddWj/IaJWog2YJjbeqLlrBRlGFSVl5cwxdB4jhzoc8FngsFovs3r1btmzZ4vK6pUuXlnbt2kmhQoXE26CT1oKNM+XkpYNOrzO8yzipUe5Wr2cCEUJIfsBtoQeMGTNGypcvr8QefVetdevWqd9lypSRN954QwYNGuT5nhJCCCGEEOJDNl5Kk5+2rJK3C3wkI8u6tm7UIZPK3QmyZL7PnlRhLltZUse+LdZS5cQbXLhwQX0Hv3HjhtProLFKhw4dvF6epZFmTJEVO+fLhv1LxGI1Z7s8RJ2RXZ+VamXr+mR/CCEkv+CR0AMGDBggd9xxh6r/3bt3r8TFxalk/jp16ijbp7eD2wghhBBCCPEmV5JNMm/LPzLU/JnUL+D8ekFpVim4wyRRh80S5GSesLFNDzHc/YhYYz2oA/t/4Jw/deqULFmyxOl1YmNjpVmzZlK1alXxFcmpifLL6i/k2Pl9Ti1fonBZ6dJooNSp1NRn+0QIIfkJj4UeEBISIs2bN1c/jli9erWygxJCCCGEEJKb3EizyOCl12TTZYNUDb0obxX9UYZGuRZYHHrNIkWWGiTYyQictCIlJOXB5yW0XhPxFC2DZ9WqVS6t17p1a6ldu7bPyqESkuNk9vJP5ezVY06v07XJXdKmXk8GLBNCiL8JPVmBVo7I6Nm4caNcu3bN1w9HCCGEEEKIXU7Em2TQkqtSKm2f/F76A5FKrm8j8rhZYjYYJTiLUGVgDQsTQ//7JSghTpLrNpMTEbFSoWJFj758G41G2blzp+zatUuJPc6AUGW47FGm5SuBx2Q2ypq9i2T5jt+dWr5QdFHpedtQqVOxCTN4CCHEB7j1WQPBBjbRAgUKSJUqVSQiIiLTMqgRnjhxoqxfv159EPFNnBBCCCGE5AYpJqt8vCdBNh7eIiuLfyjBztZZ/T/BKVaJXWeU8HOO26IDS/FSkjLuPbGWqSASjDZd/2FC56szZ9ze/4sXL8pff/3l8no1atRQLh5fRSlcuH5avln4hhJ6nCE4KERa1+0hHRrcIeFhmecPhBBCckHoOXnypIwdO1a5dLSrCDExMfLkk0/KuHHj1P/nzp2Tp59+Wv7999/0Zbp16yYvvPCCl3aZEEIIIYSQ7Nlx1SAd/7oiJYJvyitFfpE5JTa6XJ5VaJVRQhPsC0PWyAJiGHi/GDv3EwnxrlHebDbL9u3blYPHFSDqNG7cWOrVq+eTluT4fr/35Gb5ZdUXLq1XtUwd6dV8uJQs7GLKNSGEEJdx+hMJIcu33367uqKgt4rGx8fLW2+9pdL627Rpo8KZsSyW6d69uzz//PPSsGFD1/eMEEIIIYQQNzifZJZXttyU7WdOyrZy70np0JsurR922SKFVhskJMnxMpaylSRl/EdiLVxMvC3wbN68WTU5cRVcgO3Tp49qjOILTl06LP9u+0VOXz7i0np3thsl9as0p8OfEEL8Tej5+uuvVdvGwoULy8svvyy33XabpKSkKBvpl19+KZMnT5Zp06aplo4IZUbZVqNGjXy794QQQgghhEAgsVhl9tFkGb0uTuqFn5JFpd+UkHIulGhZrFLgoFmid5okOItKJGPzTpI28imR6Biv7Hf6w1sssmfPHiXyuAq63TZt2tRunIKnXL15Ub7861UxmNJcXrd707ulVd0eDFomhBB/FXpQigUVHmJO+/bt02+H4IMPlUmTJqnsnuHDhyvRh4o9IYQQQgjJCbZdMcjTG+LEnHBE9pb/SIpkZcWxh8UqRRcYJOyGfWHIXKmmpI0cK5ZqdcQXnD9/XuVbwhXvCiVKlJAuXbqowGVvc+7qCZmx5ENJTkt0ed1ezYfJbbd0psBDCCH+LvQcPXpUSpUqlUHk0Rg2bJgSeqKiolQZF0UeQgghhBCSEyVa7+yIl2XHz8mrRX6WvmW2uLR+4cUGCb/oOGDZWqCgpA16UEwd+2QIV/YWycnJsmnTJvU92xVQmtW3b1+vCzyIXjh4ZofMXj7ZrfX7trxXmtRo75NsIEIIIT4QehITE6VmzZp276tQoYL6jQ5csbGxLjw8IYQQQgghrnE20aRKtNacT5IHYpbJyrJ/SMHgNKfboxfcapSQlKyXM7bpLoa7HxVrbBHxNijT2r9/v2zdulW1THcGfM9u0aKFT9w74Fr8RVm0ebYcPrvL5XVb1+0pnRr1l/BQdtIihJA8JfTgAyk01P7iISEh6QFwhBBCCCGE+II0s1W+2Jcon+2+KmMK/iazKi1z2cETcdGS7XLJr37hkzKt1NRUWbp0qcq9dBY45nv16iVFinhXcLoWf0lmL/9ULseddWv9FrW7SudGAyQyvIBX94sQQojneLcPJCGEEEIIIV4m0WiRN7fFy9cHEqVH1A5ZVHKOlA+97tS6ITcsUmitUcKuZx3MbOjSXwyDR4mEhYu3SUtLk8OHD8vKlStdClhGgxNHF1rdwWK1yK5j6+X3td96tJ1RfSZI2WKVvbZfhBBCvItLnxxnz56V9957z+37x48f79reEUIIIYSQfAsyY/48lSovbropYYbzMqPkHOkctcepdUOvWyRms0nCL9l38Bg73SGG2weLtUQZr+7v9evXJTw8XI4cOSLbtm1zaf2wsDBp0qSJ1K1b16s5NwhWnvrPO2I0GdxaPywkXDo0uEN10AoN4XViQgjxd1x6pz537hyFHkIIIYQQ4vNW6dMOJ8nzG67JE4UWyuYSf7qwslWKLDVKmJ2QZVODFpI2/Emvizu7du2SLVtcC4K2pVq1asrBg6Blb5CSliRz134jh87s9Gg7I7s9K9XK1GWzFUIICUShp1WrVnyDJ4QQQgghPmU7WqVvjJPoxF2ytOyPUj3solPrhd6wSMxGo4RfzlyiZSlTQVIffUUsle03FnEVk8mkxJ3t27d7vK3ChQur79nlypXzeFsJyXEy7d8P3M7dAfi+f1utTtK50UCJivCO6EQIIcRPhZ6FCxf6dk8IIYQQQki+ZNX5NBm55KQUC06QETErZEHsMhEXNIYCu01ScKdJguzE8KQ8/7GYazfyyn7Gx8erMOVr1655ZXso02rQoEF6YxN3Mnd2HF0r89dNFW/xSK/XpFzxKl7bHiGEkJyHRbaEEEIIISRXuJRslkmbj0uzxB9kXwXX3DHBKVbVJj3yeOYSLXOtBpI2YqxYynsuWKD9Odqg7927V7xFy5YtVQ6PJ275C9dPy4KN0+X05aNub6NARIzEFCgsNcrVlzb1bpfoSHbQJYSQQIBCDyGEEEIIyVFMFqv8cCBOzh/5XZ4p+KdEF0hzfmWLVaIOmaXgDpMEG23uKlREDHePElOrrqhB8ljgQWnW7t27xVu0bdtWatWq5ZHAk5SaICt2zpfNh5apfCB3Gd5lnNQodyujGQghJACh0EMIIYQQQnKEVJNVPth+WUpe+F6GxawSiXVxAyarFP3bYLdVuqHrADH0v08kOsbjVuirVq2SU6dOiaeULFlSGjduLEWKFJELFy5IhQoV3BJWIOjsP71NfloxxaP9GdxxtNSp2ITiDiGEBDgUegghhBBCiM9IMFrk8TU35M9TKXJ7gW0yochPUjbmhkvbiDhhltgNxkwOHmANDZOUV78QS6Uabu0fRBSz2SwHDx6UDRs2iLsULVpUunbtKrGxmdWr1NRUt7d7Lf6iLNg4S46ed66tvC2dGw2QdvX7eLVdOyGEEP+GQg8hhBBCCPE6EFDmnUiRT7cdl68KTZQvK7keYBxywyJF/jVIiB2dxFyllqQ+9ppYS5Z1ebvJycmycuVKOXfunHhKt27dpGLFil53yZy7ekK+WvC622VZJQuXk0LRxejeIYSQfAiFHkIIIYQQ4jXOJJrk52Mpsnr/eplT6mPpXsz1bUQeNknMFpMEmzLfZ2zZRQx3PizWYiVd3i6cNWvWrJGTJ0+KJ/Tr109KlCgh3sRgSpN/tsyRLYdWuLxu5VK1pFXdHlK9bD0JCw336n4RQgjJe1DoIYQQQgghHnE11Sx3LrkmO64apXnEIZle8lMZVcr5cqXQ6xaJ2WiU8Cv2w4WtwcFiatJODEOfEGuR4i7vn8FgUMHKe/a4V/4EoqOjpXfv3nZLszx1Pm08sETW7l0k8cmulbRVK1tXejcfIcULlfbqPhFCCMnbUOghhBBCCCFukWi0yPs7E+TTvYlSPPimTC72qwwq6FrOTfQOo0TvMUuQgwZS5pq3/tcqvUJVt0SU48ePy8aNG1W5ljt07NhRqlWr5vUSqJtJ12TqPxPlRsIVt9bv1/oBaVy9LUuzCCGEZIJCDyGEEEIIcVlA+fNUqry46aZcSDbKvTEr5LnC86RQcIpT6wenWKXgFqNEnrCII5nCGh0jafc8IabW3dxqlX7+/HnZtGmTXL16VdyhUaNGqmOWt0OMr968KFP/fkcSU2+6vG6lUjWlf+sHpVhsKa/uEyGEkMDCK0KPyWSSnTt3qkA7XC0ZMmSINzZLCCGEEEL8iJMJJumx8IpcTLGo/xuHH5OppWdJ/YjTTm8j/IxZCq2x30FLw9imu6QNGyMSFe3yPl65ckWWLl0qiYmJLq9bunRpadWqlRQr5kawUDbC2LXEC7Jr0wrZdWKdW9sY1ecNKVusklf3ixBCSGAS6umH1qRJk+Tzzz+Xmzf/d1VCL/SMGTNGVq1aJfPnz5cqVap4treEEEIIISTH2XvdKG3+uJz+f/XQ8/J+sRnSPPKI0w6emE1GiTz1n0Bki7lsZUkbOVYstzR0ex8RtLxlyxbVJt1ZwsLCVGmWN7tmJaXGS3zSDfn277fEaDJ4tK2a5RtIr+bDpGiM68HThBBC8i+hnog8I0aMkIULF6r/K1SoIDdu3Mh09aRz584yc+ZMWbBggYwePdrzPSaEEEIIIT4nyWiRUWtuqBItjXIhV+XNonOke4GdTm+n8BKDRJy3L/AAQ9/hYrhjpEhoqNvfSQ8dOiSbN2+WtLQ0p9Zp3ry51KtXz+OyLJPZKIs2/ShbDrveKcse4aGRUrhgcalYsrq0qtNdShR2vXU8IYQQ4rbQM2fOHCXeVK1aVb7//ntp0KCB9OzZU9VC6/m/9u4COqpr6wP4PzNxIwkeCMHd3d0KtFCgpd7X1/ZVaEvL+/qoURfqTpW+QoUaUqxQ3N2CW4AkBELcJ6Pf2qdv0nhmJkJy8/+tlTWZO9cmJ/fOnX3P2XvkyJHqQ3Tt2rUM9BARERFVcRI4WRFlwNO7UxGTaVHTBnkfx0/133V4HV7nLQjYZ4K+mPzHtoBayLn5QZgHjgHKEGxJTEzEtm3bcPXq372NiuPr66sCPOWRWNleKWtzxDJkGtJRHqT3ztRBD8DHy/nhakREROUS6Pn+++/Vh+S8efNUkKekUpTh4eE4ffq0q5siIiIiokoQmWbGrF0pWHspB95uOXgrZCFuD9jq8PL6VCmTbobXleJ78JjbdYPhkZcAf9fLlEu59H379uH48eMq6FIa6b3To0cPeHp6urxN2c7WIyux9sCvKC9BfnVw05AH0aReq3JbJxERkcuBnmPHjiE0NBRdu5Y+lloS2sXExLi6KSIiIiKqQNlmG94/ko4Pj6Qjx2LDaJ9DeDlkIcLcEx1bgckG/wgzfI9b4FZMjMc0eNxfCZa9vF3ez6SkJPz5559IT3esF430Kp80aZLLyZUNxiwV3NlyZAXKU6BvMMb3uRPtw3uU63qJiIjKFOiRMdDSU8fR5HheXl78ixMRERFVMWuiDZi1OwUX0i1o4h6PV+r+iJG+EQ4v73XRgoC9Jugzi37dOPEu9QO96zl4zp07h40bHc+DI9eo/fr1Q0BAgEvbtFgt2H1iHf7Y+yPK281DHkbHpr3LLfkzERFRuQV66tWrhwsXLjgU5Dl79iyaNm3q6qaIiIiIqJxdTDfj6T2pWBVlQAePKFwKf8npdQStM8LrUv4uPJJY2TjpLkCnL/M+Sql0ycGTkJDg0PwS2JEAj6M3I4tyMe40lu9agLjkaJTVmJ7TcP7KSTSq3Rz1vVuiRbOW8PZ2vUcTERFRhQZ6+vfvj19++UX93HzzzcXO99///lcFewYNGoTKInd+li9fji+//BJnzpxBWloaGjVqhIEDB+Lxxx8vFHSS1+fMmYNly5apZH7169dX3XxnzZoFf3//Quu3Wq346quvMH/+fERGRqo8REOHDsXs2bMZ0CIiIqIqTYZmfXw0A+8eTkdn95M4FfYh/HWOVauyC1mZA4+Ev3PjWNp2geHeWbDVK58qURLYkUIeBau5ljRES9IJSN5Idxeqd2XlZGDhho9xIc7x0ux2nu5eGNFtCto26YZA3xDodfp8vXUGdhynroWjo8seOCIiIqrQQM9DDz2kgjz2YMi4ceMKzbNgwQK89NJL8PDwwL/+9S9Ulueeew6ffvopGjRogPHjx6u7O0ePHlWBmUWLFmHNmjVo3769mjczM1PNc+TIEQwfPhxTp05FREQEPv74Y2zfvh2rVq0qdOdFgkXy3tq1a4cHHngAly9fxtKlS7FhwwasW7dOVXMgIiIiqmo2XjLg1d0xeMb7Q5xtfMa5ha021F5mhHvq3wEec4eeMDz8fJkSK9tTAsh1lwzRclbjxo3VDchatWo5NL/ZYsbBs1uxas8Pqjx6WUgZ9NuGPw4/b9eGiBEREVWpQI/cMXnxxRfxwgsv4I477lC9YLKzs9VrEyZMwMmTJ1XCPOldI71lWrZsicoQFxeHzz77DGFhYaqrb94PfQn+PPvss+pRfsSHH36ogjwSvJH3Yye/f/DBB5g7dy5mzpyZO33Lli0qyCMXFBLcsVdvuOmmm9TPk08+icWLF1fKeyUiIiJyxKVMC97bfQYzLM9hWZBjvWSEW7YNAftN8D5nhVvBvDsTbgc8y5aDUa4TT506hV27dsFkcj7oMnLkSNWburR8N7Kdoxf24JfNc1EeZdAnD7yfwR0iItJeoEc89thj6i6KBHvyVtWSOzKiYcOGePnll1UvmcoSFRWlhlb17du30J2dsWPHqkCPfZy3fOh/9913qkeSBGjykudff/21CurkDfTIcyHryVuic9SoUWpomPTqka65EmgiIiIiulYsVhvei0jH2weT8FCt1Xg6cCV89A4GU2w2+JyywP+gGTrj35PN3QbAcP9TgF9AueTfkWtGeXRW79690alTJzVkqyRyTbjlyHKsP1j2m3BDOl+PIZ1vgIe76yXaiYiIqnygR0yePBkTJ07Evn371PColJQUlbNGhkZJMjwZtlWZZNiUBGDkzpDk3gkM/Lsr8erVq9XjkCFD1KN0D5ZhVyNGjFD7nJc879OnD9avX6+CWBLQEtJLSF6TQFJBsh55XS5abrnlllL3VcZrVydGozHfI2kH21ab2K7axbbVrvJoW8nB88GxbLx/LBuDvY9ifeiPaO4R59Q6QlYY4ZH09xAtY7tuSL/vadjsQ7TKcA0jw7QOHTqE06dPO7Wc3MAbNmxYbiWtkv5GcjPv8PkdWH/wNxhMWS7tp4e7FwZ3nIBerUeovDvCYrbCYnb+vfOY1S62rXaxbbXJWI3b1Zlk/mUO9Ai9Xq+CIvJzrYWEhKgeRpKnR+72SO4ge44eGXZ133335eYLso8Db968eZHrkukS6JH5JNAj+XyuXLmigljynouaP+96SxMbGwuLxYLqRobHkTaxbbWJ7apdbFvtcqVtM83Ae+c9sSzOHQ31Sfiizk+Y4Lff4eU9L1kQsNsM9/S/Ajw2NzfE9xqOy4NvgNXbF0hO/evHRRJ8kfcl10nODNOqXbu2SgHg4+OjbijKT0lik89h08nfYLa6nn8n2K8+hrebBj+vQMReikV54TGrXWxb7WLbalNcNWtXiT8UF7co10CPVKi67rrrKr3HjiOmT5+O0NBQNbTsm2++yZ0uPYxkGJm9GoP0+BHFJe+z9wayz2d/zNtLqKT5SyP7WJ1I1FMOCMnHlHfYGlV/bFttYrtqF9tWu5xtWwme/Hw+B4/vzlTPG+iTsbLBJ+jqdcGp7QavNsIz7u8y6aYW7ZFx6yPQhTVHI5RNamoqVqxYoYZRuZKDR1IBOCItMwlrD/6KkzEH4KqpAx9Cm8ZdUd54zGoX21a72LbaZKwh7epyoOfuu+9WvWdk6Na0adPQs2dPVBVvvvkm3nnnHTzzzDOq9LsEciThsjyXRNGSZ6eoKmFVuetVVSIHRHXddyoZ21ab2K7axbatuW0r+Xc+P5GJl/Yk4MmgpbgU/tfwdGcE7DDB54wlX5JlW0At5Nz8IMwDx8BDp4Ozt/MkmHP8+HHs3LkTrpCkynJN2bZtW4f/t6WK1s7ja7Dp8O8wmp0rEy+kNPqADmMrJfcOj1ntYttqF9tWmzw13q4uB3rk7orkt5k3b576kS61kpdGAiv2fDbXwqZNm/DGG2/g4YcfxhNPPJGvN89PP/2Erl27qmFdEuix98CRO01FKdiDp7QeO6X1+CEiIiIqiz+isnHr+iT4uWXjmeBFOB++0anl3ROsCNxtgkfC3/l37MO0zEOvR87U+5wulS5DqVatWqWGuLvaHV2qucqPvde1owGeDYcWY+uRlQ4v07fdKBXY8fb0cWlfiYiINB3oOXbsGDZv3oyFCxdi5cqVOHPmDF599VW89tprqvrUrbfeihtuuAG+vr6oTGvXrlWPgwYNKvSadM9q1aoVIiIikJGRoRI3i8jIyCLXZZ9un0+SMDdo0AAXL15UuXUK5ukpOD8RERFRedh2JQfT1iaisVs09jd6Dw3cncuV45ZjUxW0fE5b4JY/xqNkP/8ZrM3bOrw+KSgh1z32Squukiql/fv3d+ommQxXO3ZxH5Zs+xpGBxMjD+o4HkO63AAvD+3evSUiIipzoEe61g4dOlT9ZGVlqZw90mNm69atKumxPP7f//0frr/+etXTx17pqqLZs2fbS6gXlJiYqEpxSm4hCchIz6Tdu3eru1B5K2/Jc5keHh6er4fSgAEDsGjRIlXVS37PSxI3C7lgISIiIiqruCwLZu9Nxa6oKHwW/ANG+B5xeh3eZ80I2G+GrkBMxNyxF3LufAy2BmElLi+Jk+UG14ULF9T1XXnw9/dXva3lOkuuKR2RkpGIr1a9irSsJIe3Uz+4Me4c+W/U8gspw94SERFVL+VSdUt67UgwR35kONcvv/yCn3/+GSdOnFDBH/ldEg9L5auKJmXPv/rqK8ydO1f1KMqbaFkSM1+6dEnN4+XlpabdeeedeOutt/D222/jxRdfzJ1Xnkuvn5kzZxbKTSSBHum5tHTp0twETtKTSEqrDx8+HE2aNKnw90lERETaZLUBn5/Mxorju/F7gzfwvkx0ISOyPsWKwB0meMYX7sKT/e83YenUW+7cFbu8XDPJkKzyJsP9pfe3IwU94lNi8dHSp53eRvdWgzG6x03w8+ZweiIiqnncUlJSiujAWz5kiNTrr7+ONWvWqLs1SUmO34Fxldxxkl5EO3bsQN26dVVlMAn2HD58WPU0ktKcUvmhR48euT13xowZo4JQEqSR8eEy74YNG9C9e3c1LE2WyUuqeUlC53bt2mH06NGq5PqSJUtUjyAJ+MgFjBZJN+3o6GjVzVrLiatqIratNrFdtYttq12HIo+h1YV/l3k9KtHy2cLDtLJnvglLlz4lLivXRtJzubih7a6QazEJ7jhScdRkNmLdgd+w4/gap7fTILgJru93F5rUa4WqhMesdrFttYttq02GGtKu5dKjp6ikfIsXL1Y9efbu3YvKJHlzJOgiPXrk8bffflPDuerVq6cSRf/73/9GmzZtcueX4IwEc+bMmYPly5erLsmSy+eRRx7BrFmzCgV5xAcffID27dtj/vz5+Pzzz9U6pJrX7Nmz0axZs0p9v0RERFT9ZJisOJtqRkPbBXiffBHupr9uhrkanvCMtqgky7pM5KuiJSwt2iPn7idgDS957XLjSoahy5D8spJrIwnqSO6d1q1bq6FapTEYs7Dj2BocPLsNKZlFD8Evybjet6N32xHQ6/LnUCQiIqppyq1Hj/SkkZ47MlTrzz//VMEVSZYn3XJHjBiRm5yZqq+aEv2sidi22sR21S62bfVkstrwQUQ6PjoUh7drz8f1fvvKvM5am43wumAtFNyxy7l1OkyjpwA6XbHXbwcPHlQ/ZSFD4qUQRtOmTR3OuSPkWvHA2a1Yun2ey9tuH94TNw64r0pX0uIxq11sW+1i22qToYa0a5l79MiFgVTekh48MjRLPrCFlDGXnD1Tp05F7dq1y2NfiYiIiKqdlBwrHt6WjFVR2bjRbzc2h/6C+k5WzSrI/4AJvkeLrqAlDA/NhrnP8GJz8Fy9ehW///47ysPYsWNV4QpnAjziXOwxrN77E64kR7m03U7N+uCGfv+At2flVnglIiLSbKDn/fffV0OzTp8+rZ5LgEe66MrwKAnw5B0eRURERFTTyLXRwrNZmL03DSHWGPxa/3v09z7l+gqtNoSsMsIjsfjO2NlPvQ9Lu27F7k9UVJTqeV0WUi2rQ4cOTgd27GISIvHLprlIzoh3afmbBj+ITs36urx9IiIirXM50PPyyy/njsEeP368GpolJdT5oUtEREQ13dEkE57clYLDV9PwRK3luD9wLTzcLC6tK2C3CT5nLChucWutEGQ//QFsDZuUmD9RClVIJS1ntGrVCn369CkyZ6GzsnIysG7/b9h3ehNscC5zwK3DHkPLRh3h6f5X1VQiIiKqgEDP4MGDVc8dybsjwR4iIiKimi4204KndqdgRVQ2rvPZj82hPyHUPdmpdeiybPA7ZC6yalZe1sBgZL/wGWx1GhQ7T3x8PJYuXQpXqmRJzp2GDRuirNIykzB/7bu4mhLj8DLueg/0bD0Uo3vcDA93zzLvAxERUU3icqCnvMZ1ExEREVX3Clr/tzMFP53LVs+bu1/Bd3V/xFCfY06vK2i9EZ4xxSdXFuaeg2H455OAX0CJySal8unJkyed3gcJ8MgQfFd6acvwsONR+7Fy13dIz06BK8LqtsTtIx6Hn3fx74+IiIgqubw6ERERkdZZbTZ8fyYLj23/K6DR1TMSKxu+5tjCJhu8Yq0I2GuGPtOxYUzG8bfBOPFOwMunxECL5E/cs2ePCvY4qlmzZqq3tqena71nDMZsrNz9HQ6d2+7S8n3ajsSwrhPh5x3o0vJERETkZKBHyo8JKZXeoEGDfNOcISXMiIiIiKqzk8lG3LbiCHSw4oK5HoZ4n8SP9d93bGGrDb7HLPCPMMPN7OAiDcKQPetd2ELqFTuPlEmXHjxHjhxx8F1ABXVGjhyJRo0awVVGcw42RyzHlojlLi0vQ7QeGP88GoQUn1+IiIiIKiDQ06VLF/XYunVr7Nq1K980R0n338TERCd3j4iIiOjau5xlwcObLmGs6QfcEbAZW12IjXhctiBwtxnuqY714DHc/zTM/UcBOl2RPXfOnDmDzZs3O70fQUFBKsATHBzs9LJ5t38i6gBW7fkBqZnOX9+1DeuGcb1vR3BAXZf3gYiIiMoQ6JEPc2G1WgtNc5Sz8xMRERFVheTKbxxIRUrsFrwd/BMaejufd0aSK/vvM8H7fMm5d4S5SUucmPIwGrZtD29v7yLnkcpZ69atg9FodHpfJk+ejNq1a6MswZ2FGz9CWdwx4gm0CetapnUQERFRGQM9ycnJDk0jIiIi0oJLGSb8tHMVHtR/hjkywZWOJzJM66RFVdDSmYqfzdRnGIzTHoKtdj2VV8dcxPD4rKwsbNy4EbGxsU7vRpMmTdCvXz8EBrqW/yY+9TKW7fgWF+KcT+xsJ5Wzbuj3D3Rp3t+lJM9ERETkOCZjJiIiIvofk9WGnw8fQZMrX+JBr7Mur0efYkWtLSZ4JBffo9ncvjtyHngWtqCie9hkZGRgxYoVSE9Pd2kf/P390b9/f4SHh7u0/KWE8/hxw0dIy0pyaflg/7poWDscQzpfj9DaTV1aBxEREVVioGf79u3qzlCnTp1Knffo0aNITU3FgAEDXN0cERERUYWRYUkLjl9FzvnvcIvPeui9XBty7nHFioD9JngkFL+8zS8QWS/Mha1+4yJflyFZknsnKioKrurWrRu6du0Kd3fnL/XOxERgwbp3XdpuvaBGuGvUv1HLz7XhYURERHQNAz0TJkxQ3YBXrVpV6rxPPfUUdu7cyWTMREREVOV68MzZexkd4z/EVN/DgK/r6wpZmVNsgMcaVAem62+HacQkqVCRb0hWTEwMfHx8YDKZsH79etd3AED79u3Rt29f6PV6p5bLMWXj4NltWH9wMQzGLKeW9fMOwJiet6BriwEclkVERFTdh245k2CZyZiJiIioqrDabPjuVDoiji7GyyE/ORzgybD4o/5xd/gduFJqYmVh0+lgGj0Vxkn/AHz+2khKSgqWLl2qAjtl5evriz59+qB58+bQFVGdqyRWmxXbjv6Btft/cXn7LUI7YNqQ6fDx8nN5HURERFQNc/TI2HJPT8/K2BQRERFRsXIsNryyPw27zh7E6yE/YGpI4cTHxfE9bkbdQwklJlbOy9K6M3LuehzWsOa5Q7L27duHY8eOoaxCQkJw3XXXqUCPs8wWM7YdXYX1Bxe5vP1HJ72uhmkRERFRDQz0HD9+HCdPnkSjRrwYICIiomtn4yUDluzfhDf8PwAalD6/1eoG7ytmeF6ywueMxeEAjzDc9TjMwyeqYVo5OTmIiIjAiRMn1O+u8vLywogRI8p0TRV5+TiW71yAhLTLTi87qsfNGNBhDPQ61vIgIiKqyhz+pP7ss8/w+eef55t26NAhdOnSpdhlsrOzkZCQoH4fNWpUWfaTiIiIyCkybPyXyGw8sCUJY30OYl69T9Hb37FlPS9ZELDHDPc0x4eemwaPQ87N/wICgmC1WnH40CHVg6esPXdkaFaDBg1cSqxsl5aVjNV7F+LI+d1OLVcnsCHuHDUTIQH1XN42ERERVS6Hrxikalbe6g+SbM9gMJRaEULmGz16NJ555pmy7SkRERGRgwGexeez8cDmeDxeawUuhS93fGGLDbW2muB10epQDh61SMsOMDw0G7Y6f3UTio+Px7Zt23Jvdrmqd+/eqrqps7l38kpIvYKPlz6t8vE4o1vLgRjdYxr8fQJd3jYRERFV8UDPbbfdhoEDB+ZeQN1www2qssObb75ZbIBHxo03a9YMQUFB5bfHREREREWwWG1YdykH8yIu4FHdh7gYft6p5f0Om9WPm4OdeCytO8Ew/UXYgmqrm1+7Nm3CmTNnUBYBAQHo0KEDWrVqBW9vb5fXYzTnYHPEcmw/usqpIE+D4CaYNOCfaFSnmcvbJiIiomoS6GnSpIn6sevfvz86duyYG/whIiIiuhZ2x+Vg6h9ReLf2fzHe7wAG+ji+rJvJpoI7vicscHMwHiKl0rNfmAtrcF3Va+fAmjWl9nAuSo8ePdQQeCmFbjab1dAsCRhFRzueIDovuRFnshhVomX5MZmNDi03tMtE9Gk7Av4+tVzaLhEREVUtLg/2XrlyZfnuCREREZETDiUY8X+bz2GWz+c42eSU08vrMm0IWZUDfVbp81padkT2E68B/rVUQEUKTWxb9LvT2/Tz80O/fv3QtGlT1fvZztX8O9Hx5/DlypddWrZdk+64ccB9LI1ORESkMSybQERERNWGBFn+jMnBY5sv4enAH7A4aCf0jo61+h+fU2b4HzBDV0qHF2vdhsj555OwtO+unlssFhzYu1cVo3BFixYtMGjQIHh4eKAsjKYc/LJlLk5Fu7YfXVr0x9iet7AHDxERkUaVS6DnwIEDqmxoUlISTKbia4/OmjWrPDZHRERENdCRJBNm7biCgaalOBDqfM9itxzpwWN0qJJW/M0PY0WWG1K27wfkxwUyJEvy7XTr1g2enp4oq5SMBCxY9y7iU2JdXse9Y59G0wZty7wvREREpNFAz8GDB/Hwww/j1KlTpd59k+7JDPQQERGRs1KNVrxxIBUXLm7He8ELEeab6NTyfofM8IsoPcmyzd0D6Q+/gL1mD3UDqywkkfLEiRMRGFj2qlXSg2dzxDJsObLCpeWb1GuF6/vehQYhf+daJCIiIu1yOdBz8eJFTJo0CWlpaejbty/OnTunEhLefPPNSE5OVkEgKS/q4+OD66+/Xt3VIiIiInLUnqs5GLPyKv4VsBbPh/wC1HVu+cBtJnifs5RaJt3UexiyJ9+DXedjcOzAsbLsMgYPHozWrVvny7/jCrPFhM0Ra7HuwG8ur8PH0w9je92Kri0HQOfmeol2IiIiqiGBno8//lgFef7zn//g6aefxnXXXacCPZ9//nnuOPYff/wRTz31lBrS9fPPP5fnfhMREZFGnUs14+ndCeiUsQgx4cudWtbrggUBe0zQZ5c+r6VxM6Td9ig2xMQjasUa13cYwJgxY/JVJ3WF9IA+HrUXS3Z8jbLqEN4LE/vfw0TLRERENZDLgZ6NGzfC19cXjz32WJGvSw+eO++8U3VZvueee/DZZ59h+vTpZdlXIiIi0rBssw3vRaTj6JmteLrWb2gddNmh5fTJVgTuNsEzzvGkzFm3PIT99Vpi3w7X8u8Iyb/Tu3dvlytmGc05iIo7jQxDGtzcdDh0dhvOxh51aV33jJmlcu+w5w4RERG5HOiJjY1FeHi4KhMq7F2UJRlz3moSMj69YcOGqkcPAz1ERERUlPXnr6DWmZfwuPt5p4Zo+R00we+IpdT8O3aZA6/DmrAuuBgdDcQccGlf+/Tpg44dO0Kncz6okpKRiO/Xv4e45BiU1YAO12F4txvh6e5V5nURERGRdrgc6JFgjvTosQsICFCPV69eRaNGjfLNW69ePZw9e7Ys+0lEREQaFJWcgqgDb6Gv2wGHr0rcsm0I2G92KP+OkBjQ+XufxRm9r7oeMUqQx5HtuLmhXbt2MJvNaNu2rbqecTX3jtlixo5jq7Ep4neYzKXUdS9pn+CGSQPuRbeWA8ucB4iIiIi0yeVAj/TSkaCOnfTuEXv37s0X6MnJyUFkZCSsVmtZ95WIiIg0wmDKwY59C9En+yfUdiJe4XPaDP/9ZugciJWYeg7G4aFTsXXXbuDUBYe3IaXQBwwYgBYtWpQ5mHI4cid+2/JX/sKymjzwfnRtMYABHiIiIqqYQI90WV6+fDmysrJUz56hQ4fiq6++wssvv4z27durihMGgwFPPvmkStos3ZyJiIioZrNZchB5+Es0SFkJZ64MvM+aEbDHDJ2p9HkvT74fP13N+uuJBHmcINcv/fv3zzcM3RUnow/ih/UfoDxIafSerYe5NFSMiIiIah6XAz2jR4/G4sWLsX79elU+fezYsejUqROOHDmiyq0HBwcjPT1ddXeWO0/FJW0mIiIi7bMZk5G+/ynosy+igYPLuBlt8D9ohs8px3LwXG7VFb+GdobFHuRxQo8ePdClSxdVTKJsVbP2Y/HWL1WiZVc1DGqOyQPvRYM6jV1eBxEREdVcLgd6JkyYgJ9++kl1axZyl+nXX3/Fww8/jA0bNqiS6qJ27dp48cUXMW7cuPLbayIiIqoWbFYLcmKWI/vcfHjaHKh5/j/6FCuC/zQ6VCY9vW13bOk1DqfPnwcsFqf2T3rvSB4eV3vLpGQkYPXen3Ds4l6UlbeHL+4YPhPGDCDIv06Z10dEREQ1k8uBHqm2NWbMmHzT6tevj0WLFqncPRcvXoSPj4+6eCrL3TEiIiKqXmxWMwxxO2A98XruNE8HltOl2xC4ywSv2NLz+tn0ehhufgAHG7bBwUOHYJQgj4NkyHm3bt3UNYor+W4k7+Duk+uwas8PcEXDkHA1HCusXst8vYFkX2TYe3SGY8miiYiIiMo10FMSqUohP0RERFQz2CwGGE/Phfnyny4tr8qkH7XArZQYj1Hnjo1Dp+G4JGOOTgWi9zi1na5du6ohWpJw2RkZ2anYe2ojzlw6guh41yuJju9zB3q3GVGoBxETLBMREVGVDvQQERFRzWAzpSPn1CewXN3s0vIBu0zwOV1yDh556US9ZljTuv9fE5ysTt6hQwf07t0b7u7OXfaciz2Gb/98C2UV6BuCm4Y8iPB6rRnQISIiogrn0BVPdHT5dCEOCwsrl/UQERHRtWU1xMNw4EnYDFdcWl6qaAXuMsOthJQ6mR7e2NCiF87WaeL0+hs2bKhKpEtxCGelZ6Vg9b6fEBG5E2XRq80wjOw+Fb5e/mVaDxEREVG5B3qki3NZyR2sxMTEMq+HiIiIrh2bKQ05x9+GJdH55MOSYDlwtxmeV0oen5Xh6YONzXu6FOCR/IDDhw9HaGio08tarBbsObke6w8uRo7J8cTRRXlk4muoH8yqWURERFRFAz2SILCsymMdREREdG3YzNkwXfgBpqjfXFre95gZ/gfMJebgSff0wdLu45Dg7u30+gMDA1UPnsaNnQ+umMxG/LH3R5WDx1XNG7bHtCHT4evN3jtERERUDQI9ycnJFb8nREREVOXYjCkwHJ4Na/oZp5d1T7AiYJ8ZnnEl9+Ax6fTYHdYRe8M6urSPbdu2VWXSXanyeSr6EFbu/h7JGfFOL1s3KBT/HPMU/H1qOb0sERERUUVhMmYiIiIqxJp9BYb9T8BmdO5mj+/R//XccaAjr8xytkVXbArvigyjyantBAUFYcSIEQgJCYErQ7T+3PczdhxfA1dM7H8PerQawsTKREREVCUx0ENERES5bOZMGM98AXPcRsDqePAlaL0RXjGl1EbPI8XbH+uH3oKojGzAwSBPrVq1MGrUKJcSLAuL1Yxdx9eqRMuOat24C3q2HopmDdrB29PHpe0SERERVSZNB3qWL1+OefPm4fDhw8jKykL9+vXRq1cvvPTSS/nG8KelpWHOnDlYtmwZrl69quabNGkSZs2aBX//wmPtrVYrvvrqK8yfPx+RkZHw8/PD0KFDMXv2bDRt2rSS3yUREVE5BXjOfw9z9BKHl3FPsqreO16XHAvwWBuGIequJ7Fk++6/JkiQxwEtW7bEoEGDnC6Pbmc056gePLtPrnd4mbq1QjGh711o3rCdS9skIiIiqnaBnunTpzs1v3Rv/uSTT1AZJPHzE088gW+//RbNmjXDlClTVMDm8uXL2L59uyoXbw/0ZGZmYvz48Thy5Iiq0jF16lRERETg448/VvOuWrUK3t75k0I+/vjjWLBgAdq1a4cHHnhArXfp0qXYsGED1q1bhxYtWlTK+yQiIiorS8pRGA78n9PL+e8xwfekxaEhWsY6DbF5wn04ejYSsAd5HEiuPHjwYFUm3VVGUw62HFmBncfXqGCPo0b3uBn92o+Bu17T98OIiIhIo1y+gvnxxx9V8Ka4alp5x63LPJUZ6Pn8889VkOe+++7Dm2++WSg5o9lszv39ww8/VEEeCd68+OKLudPl9w8++ABz587FzJkzc6dv2bJFBXkk6aMEdzw9PdX0m266Sf08+eSTWLx4caW8TyIiIldYDVdh2DfD6fw7InCLEd7nrSgqO41Zp0e2uxf8jVnqedJjr2FzYiYuXrwISJDHQdJ7p02bNi7lwEnPSsE3a+YgIfWyU8t5e/qiT9sRGNZ1EvQ6BniIiIio+nL5SkaGNRVHhkmdPXtW9XCRIM+//vUvNbypMmRnZ6vgjgyhkuFYRVXgsHf9ln377rvvVG8fCdDkJc+//vprFdTJG+iR5+LZZ5/NDfIIyRkwcOBA9Z6lx1BYWFgFvksiIiLnyGeeLfMisvc86NLyQWuN8IotPEQrNqAOfu4ypuiFDhx3eP0+Pj7o3bs3WrVq5VKAJyH1Cv67Zg7SspwPXnVu3g/je9/B0uhERERUswM9Tz31VKnzXLhwAffcc4/qBbNmjWuVLZwlgZaUlBTcfvvtsFgsaujVuXPnVAJHyaPTvHnz3Hllugy7kqodBQNR8rxPnz5Yv349YmJicod6bdu2Tb3Wt2/fQtuW9cjrMuTrlltuqYR3S0REVHxgx5pyFKZLy2BJ3AdYHMuHk5d7ohWBu0zwSMjfezcyuBE2tOiFdO+y38SRoI4Mhe7Zsye8vLycXl6GZG2JWI5tR/9QyZad0a3lQIzvcwe8PJhkmYiIiLSjQvsmS6+ab775Bj169MC7776resFUtEOHDqlH6ckzYMAA1bPITqfT4eGHH8arr76aG+gReYM/ecl0CfTIfBLokXw+V65cQfv27YvsKWRfj329pTEYDKhOjEZjvkfSDratNrFda27b2lKPwnrmQ8AY7/I2/Peb4Hvs7xw88nCqTjj+aDsQ5cXX11fdhKldu7YKTDn6uZienYI/9/+MkzEHXNruyG43oWerYdDr9LBZAIOl6nwe87jVJrardrFttYttq03GatyuBXMHl6TCB6FLMmQZZ79kyZJKCfQkJCSox08//RRdunRRPXxat26tEixLHh7JEyT7dO+996pqW0J6+xSXCFLY57M/2qeXNn9pYmNjVa+j6iYuLu5a7wJVELatNrFda0jb2mzwzj6MkMR5ZVpnrU1GeF38OwePBHji/YKxpVl3RAc1QHmQz0uppCWPMtxbfkpjNBuw8+xKXEw84fJ22zbshR5NR6gcPLGXYlGV8bjVJrardrFttYttq01x1axdpaNJcR1UilIp2QalW7YMf6oMUvpcSP6cH374IbdahyRPlgTNkkdHgj0S6LnWQkNDUZ1I1FMOCCk/nzc/EVV/bFttYrvWnLa1ZV+C9fw8IMW1Hi4iaI0RXlf+zsGT4eGNVW0H4lKt+uW011D7269fPwQEBDi8TEzCOfy69TNk5aS7vN0WDTtiUr/74O1Z9Ydo8bjVJrardrFttYttq03GGtKuFR7oiYqKUsOnius1U97svWq6du1aqCSrDLmS4WSRkZEqj4993tTU1CLXVbAHT2k9dkrr8VOWrldViRwQ1XXfqWRsW21iu2qXhzEalgPPAFbHS4fnFbwqB57x+fPvGPQe2BneBYdC25TTXgIdO3ZUee9kCLUjN2x2HF+NNft+LtM2bx/xONqGdUN1xeNWm9iu2sW21S62rTZ5arxdKyzQEx8fjz179qh8OFLOXMbgVwap1iGKCyzZp0segBYtWqjfJfBTFPt0+3yShLlBgwaqTKwMuSqYp6fg/ERERBXBlnEWDS49D2t06UOeilJ7aQ7cU/MHeOTZiXrNsLVpN2S50POle/fuKqmy5N1xxeXEi5i7/HmURZN6rTCh711oGNKkTOshIiIiqpGBnpCQEIfmk+SKkmTxmWeeQWUYNGiQejx9+nSh10wmkwrGSMCmTp06qruW9PrZvXu3SrSct/KWPJfp4eHhuRW3hCR4XrRoEXbt2qV+z0sSN9uHiREREZU3a04CjGe+hPXqFpTeNya/wK1GeEf+nXvHHtxJ9/LFqTpNsa2Z871fhgwZosaLu7u7ft/IYMzC+oOLsfvkOpTFjQPuQ9eWA6Bzc/YvQ0RERKQtLl+ZSQCnNEFBQRg7diyefvppNGlSOXfXJNHy8OHDVRLmBQsW4K677sp97f3331fDtG6++ebci9I777wTb731Ft5++228+OKLufPK84yMDMycOTPf+u+++24V6HnttdewdOnS3HF9a9euVaXVZduV9V6JiKhmsFmMMF1cCFP0UofLpOvTrAhebYS+iNnj/YLwfbfxLuXck2FY0nunrOPa5ToiInInVu/7CRnZRQ+hdsTUwQ+iU7M+DPAQERERlTXQc/jw4RIvBKV3jKO9fsqblHIfPXo0HnvsMaxcuVIN55KqW1u2bEFYWBheeeWV3HlnzJiBVatW4YMPPlDzSKUueW8SKJIL2YceeijfugcPHqyCRxJEkjuZsh0puS5VxYKDg1XQiIiIqDxYUk/AsP8Jxxew2uBzygL/g2boTIVfztF7YEd4Zxxu2Nql/bnxxhtVL92ysFgt2H1iHf7Y+6NLyw/ocB1G9ZiqKmcRERERUWEuXyVV5V4r0qtn48aNeP3119VwKgnayDCt+++/H//5z39Qt27d3HklICXBoDlz5mD58uXYunWrmveRRx7BrFmz4ONTOE+BBIUksfP8+fPx+eefq3VMmDABs2fPVtsmIiIqC2tOEkyRC2C+vNqp5UJWGuGRVLjHbZa7F1a2HYgYF8qjy5DoNm3aqJs4rpIEyzuPr1G9d1z1r3GzEVavpcvLExEREdUUmr0dJnl15s6d69C8kqD5jTfeUD+OkKohDz74oPohIiIqL1bDVeQcfxvWlCMOL+MZbUHAHjPcM/IHeDI9vHG4YSvsbtLZ6f2QGxhSBl0qVZYlwJOelYLF277G2VjH349dswZtMbL7VDSu24LDsoiIiIicoNlADxERUXVhs5pgiloM04UfHS+VbrYheJ0JHnH5EyynePtjUcfhSPMOcGlfZAhzt27d4OHh4dRyOSYDdp1Yi3UHfoOrWoZ2xIS+d6J2oPM9j4iIiIioHAI9UjZ94cKF+PPPP1U1K6lUVVySZrkjeOjQobJsjoiISFNs5kxYkiNgPPcNbFnRDi2jT7YicJcJnlfzf97m6N2xs0lnHGzUzqV9kSqUo0aNgpeXl1PLnb9yEt+sdqxHbHECfUMwrvdtaB/es0w9iIiIiIioDIGe5ORkTJo0CUeOHHGoAhcv3IiIiP5ijt+JnCMvOb2c7xGzSrTs9r+P3YtBDXAwtC3OhzRyel2NGjXCgAED1PBlZ/PtrDv4G7YeWYnyMLDjOAztMhFeHt7lsj4iIiKims7lQI+UIpcqVYGBgarkuHTzrlOnDgM6RERERbDZrDDH/A7jmS+cWi4z1gfhO1Kgz/z7pkqaly82N+uBs3VcK4wwYsQIVTzAmc9sqZa199QGrNz9PcpDm8ZdMXng/fD19i+X9RERERFRGQM9f/zxB/R6PX7//Xd07drV1dUQERFpms2cBaNU0Ir9w/H8O/8TsMmE+hcN+RIsr2w7CJdq1XNpX/r06YNOnTqVGuBJTo/H8l0LcOZSBMpT0/ptcH2/u1GnVkMmWCYiIiKqaoGejIwMtGzZkkEeIiKiIlhST8Kw/3Gnl7uUGYLQbelocCVdPZdUy+dqN8am5j2R4eXr9Pp8fX1VgKdFixalBnjMFhO2HV2FzRHL1e/lpWPTPpg04J8cnkVERERUlQM94eHh5bsnREREGmBO2IWciBedXs7NaFP5d7qdilU5eAx6T6xqOwAXg0OdX5ebG4YNG4bmzZs7PDzr7KUjWLH7OySmxaGsvD19MajjeHRvNQj+Ps7lACIiIiKiaxTomTZtGl555RWcPXtW9ewhIiKqyazZV1T+HUvCTqeX9bpggc8eKy571UN2HS8cbtgalwPrOr0eHx8f9OvXz6EAjxRSOBF1AAs3foTy8MCEF9C4TvNyWRcRERERXYNAz/Tp01VZ9dtvvx1ffPEFh3AREVGNZLMaYYpaBNOFn5zKweN1zgLvfTYYbZ5Y1HEUUnoEurwPEuBp164dOnfuDA8PjxLnNZpzsGr399h/ZgvKolOzvrih392q9w4RERERaSDQIxeSS5cuxb333quqd3Ts2FHdQZRcAEWRO4uffPJJWfaViIioSrEkHUDO6U9hy7rk0Pw5Fg8knqyHC9lhuBDcCOjp+rb9/PwwaNAghIWFlTqv9N45dG47Fm/7CmXVp+0IjO11K9z1JQeUiIiIiKiaBXrE888/r6pvWa1WVWpdforDQA8REWmF1RAP49kvYbm61bH5bW44Fd8SB9M7A5KPuIw5iSW5sre3N+rWrVticEfKoUv1LFfUD26MAR2uQ/vwHqq0uvTcYaUsIiIiIg0HeiRoI0O2RPfu3dXQrTp16jic9JGIiKi6sVnNMMcshfH894Dl77LnxUmKD8LqtBHltv3hw4er3rM5OTmIjo4uvH82GyIid+K3rX99PrvCx9MPI7tPRc/WQ6HTMbBDREREVGMCPQsWLFBBnY8//ljl6SEiItIqm8WAnJMfwRK3waHeOzExoTiQ2QVZHj5l2q67uzt69+6N9u3bF3sjJSsnA9k5GbicFIWfN31apu11bzkIo3veDD9v1/MFEREREVE1DfTIncTQ0FAGeYiISLOsGZHIPvAfwJxR4nw2GxCV2Rjb4/r8PbGMKWx69OihessW16smKycNS3Z8heNR+8q2IQDh9VrjxoH3onZggzKvi4iIiIiqaaAnJCSkxNwARERE1ZU1Ow7Gs1/AEr+j1HnTjP7Yd7UrruTUd3l7UsjAXha9NBarGbtPrsWmiGUwW40ub3Ngx3EY3vVGeLh7urwOIiIiItJQoGfkyJH45ZdfkJqailq1apXvXhEREVUym9UCS8J25Bx9vdR5s81eOJLcHmfTSg/MlJRQuUOHDup3vV5f6vxGUw6W7vgGR87vcnmbklD5vuueVYmWiYiIiEibXA70PPPMM1izZg0effRRfP7558WWVSciIqrqLClHkXPqE9gyL5Q4X6bJB/sTuiImK9Sl7fTt21cFd5xJcnwi6gB+3PAhXNUguAluHzEDQf51XF4HEREREdWAQM+GDRtwzz334N1331VVt6ZMmaK6nJcU8Ln11ltd3RwREVG5sxlTYDz7NcxX1pU4X7bZGwcSO+NiRpjT25CKlBLgadCggcOVKVMyElTlrItxp+Gq4d0mY0CHsfB093J5HURERERUgwI9Dz/8sLpglVKucXFx+Oyzz0pdhoEeIiKqCmw2C8yXVsEYOb/YRMt/JVhuhO1xfV3ezrhx49CoUaMS58nITsXZ2KNISruKc5ePIerqGZe317FpH9zQ7274ePm5vA4iIiIiqqGBnv79+zt8Z5KIiKgqsFmMMJ75HObYVcXOY7HpsD+hi9P5d+QzsWPHjqqXq6dnyQmOUzIS8eWql5GelYKyqFsrFDf0/wea1m9TpvUQERERkXa4HOhZuXJl+e4JERFRBZHep+aY32G6+DNsxuQi5zFZ3bHrag9EZzqfqFiGZQ0YMEBVpCxKdk4m1h34DXtObUB56dl0JEb2ngw/X/beISIiIqJyCPQQERFVdTabFeboJTCe/arYecxWPfYldEVkelOXtjFkyBC0atUqXy9XKYG+7sAibDtafM8hV03sfw86hPVGTMwl6HWlV+siIiIiopqFgR4iItJkqXTzpeVqmFZxMk2+WH95EDJM/k6vf9iwYWjRokWhIcwyFGvRti9xLvYYylNIQD1M6HsXWoR2gM5NB4PBUK7rJyIiIiLtYKCHiIg0w2bJgfHcPJhjlhU7T0pOINbGDoHJWnIenYICAwMxaNAghIaGFjk0a/3Bxdh9suTqXc4a0W0yBne+XgV3iIiIiIgqNNBTXB6C4shdz8TERFc3R0REVCJT/E6knvgMPuarRb5utHggIqk9Tqe1dHrdw4cPR7NmzaDT/R1wSctMwq9bvsCFuJMoT+3De2JEtymoF1Q4oEREREREVGGBHklsWZHzExERlcZiNuDyoXcRnLZVPfcpYh75+Dmf0QSHEjvBYPF2eN19+/ZFhw4d8gV3rDYrDp7ZiqU7vimX/b/vumcRXr91uayLiIiIiKhMgZ7Dhw8X+1pWVhbOnj2LefPmYceOHXj77bcxdOhQ/sWJiKhcGNMvInXv/8EX6QguZh6rzQ0nUlrjcFJHh9fr5eWFgQMHqt47BZMrbzq8DJsO/16m/fbx9MOkAfeiTVgX6HUcPU1ERERE5c/lq8wmTZqU+Hrbtm0xYcIEvPzyy3jqqaewfv16VzdFRESk2CwGnD+6ACEJv8PXzVLsEK19CV1wISPcqXVL753evXvD3f3vj8YsQwb+3P8zjl/cj2xjptP727P1UAzrMhGBfs4NdyYiIiIiclWF306cNWsWvv76a7z55pv49ttvK3pzRESkQTL8N/HSVhhOf4H6SATyF7tSciyeOJTYEefSmzm8Xk9PTwwYMKBQBa1MQzrW7v8V+89sdml/b+j3D/RoPYRJlImIiIhIe4Ee6QbfsmVLbN++vaI3RUREGmTKuITzhz5GI+OhYnPwRKY3VUGeHKuXQ+v08fHB4MGD8/VOlWDSxbhTWLJ9HpLSi07oXBIvDx/cOPA+tG/So1DZdSIiIiKiylIpCQLi4uKQnp5eGZsiIiINOJZkwohlMZgeuAoP1/oDjdzMRc6XnFMLe+O7ISGntkPr9ffzQ7/+/REeHp4vGBN5+TjW7v8NMQnnnN7X3m2Go1Pzvgir2xJ6nd7p5YmIiIiIqlWgZ/HixYiNjUWrVq0qelNERFSNxWZa8FFEMr45mYG7AzZiZ6M/UE+fVsy89bHpykCn1t+1a1f14+HhoZ5brBZsO7oK6w785vS+tmjYAZMH3Y9A3+JSQRMRERERVbNAz8KFC4t9Tbq/x8fHY8+ePVi9erW6azpt2jRXN0VERBq2/pIB/9lwDK+G/IDZPscxu4QcytlmbxxI7ISLGSUXBMhLhg9LHh7JxyMyDWlYvfcnHDrn3JBiybfTvdVgjO11K7w8HC/TTkRERERULQI9Dz/8cKk5CCTgI66//nrMmDHD1U0REZEGxWSY8e6eMxib/QW2NDpZ4rxGizv2xPdAVGZjh9cvPUkHDRoEvf6v4VSpmYlYvnMBTsUccnpfG9VuhttHPI4A3yCnlyUiIiIiqhaBnv79+xcb6JHpvr6+qorJddddpy60iYiIhNFiwxdHk5B+/hc8F7AS3j6F8+/IfYILGWHYebW3U+sOCAhQn09hYWHqs8hoysGSHV/j8LkdTu9nSEA9jO9zB1o37uL0skRERERE1S7Qs3LlyvLdEyIi0rwtl3Pw697NeMDrezQLzF/ZymjxwJHkdjiV6nxON51Op/LvdOnSBe7u7jCac7AlYgU2Ryxzel3+3rUwacA/0SK0A9z1f+XzISIiIiKqLiql6hYREdVsV7IseHfPOfRK/xZz/A8UCvBEJLXH6bSWLq27du3aGDFiBGrVqoXIyyewcMNHMJiynF6Pp7s3HpjwAuoFhbq0H0REREREVQEDPUREVO4kR9vhRBOe3pOKpKRIrGr4Cl6UEul+eecBzmc0waHETjBYnE9uLEmWe/XqBT8/P8TEn8MfG7/DsYt7nV9PaEfcNPgh+Hr7O70sEREREVG1DvSMHz8eO3fuxLPPPot///vfpc7/7rvv4rXXXsOQIUOwZMmSsuwnERFVk/w7i89nY9PpCDyo/wK/eV8Giuggk5ITiL0JXRFvqOv0NoKCglQVLZtnDr5a8zKS0uNc2tcOTXvhxgH3wsvDx6XliYiIiIiqdaBnx44d6qdbt24OBXmEzCe5fDZv3qxKrffu7VxSTSIiqh4iEo0Y/0cCQhGNz+t8juslwFOA2arHoaSOOJ3q2hAt0bNnT9RtHITFOz5FXHKMS+u477pnEV6/tcv7QERERESkiUDPokWLVAWTJ554wqkNSLDnjjvuwK+//spADxGRhqQZrXhkWzKWXczGNL9tOBn6bZHzyRCtM2nNcTy5DbIsvk5vp0ePHmjXrh2gs2L9wcVYsmq9GhrmjLZh3TFl0P3w9nR++0REREREmgz07N69G97e3hg1apRTGxg5cqRaTpYnIqLqT4IsP53Lxkf7zuO7kFfwWXhKEfMAl7IaYsuV/i5tY9TIkQhtHAqdTg+9To9D57Zjzb6fkWlIc2o9kwbci24tB0LnpnNpP4iIiIiINBvoiYqKQpMmTVTQxhleXl4IDw/HxYsXcS198MEHePHFF9Xva9euVQk880pLS8OcOXOwbNkyXL16FfXr18ekSZMwa9Ys+PsXTtBptVrx1VdfYf78+YiMjFTJQIcOHYrZs2ejadOmlfa+iIgq0/FkE57ZeRU9DEuxrt7yIudJNQZgb3xXXDXUc3i9fj7eCGzshd3nVwJuwLzN21zexxYNO6Bf+9Fo2aiTChIREREREdUkDgd6srOziwx4OEKWk+WvlePHj+ONN95QwZjMzMxCr8s0STR95MgRDB8+HFOnTkVERAQ+/vhjbN++HatWrSoU4Hr88cexYMECNZzggQcewOXLl7F06VJs2LAB69atQ4sWLSrxHRIRVazLWRbM2pWC7Ku78XrwjwgPSijUg+dsWjPsTeju1Hp1bm6oFxaC/ZdXwXLBpII8rgryr4Opgx5g/h0iIiIiqtHcnalykpiY6NJGZLlatWrhWjCZTHjooYfQqVMnNG/eHL/88kuheT788EMV5JHgjb3Xj5DfpSfQ3LlzMXPmzNzpW7ZsUUGe/v37q+COp6enmn7TTTepnyeffBKLFy+upHdIRFT+9scb8cXxDPwSKUF6G27y24HP6nwD1MufXDkqozF2xfeAKxEaNzcgRr8PFy6X7UbAmJ7TVA8evc6pQpJERERERJrk8FWxDL86cOAA4uPjUbeu4+VwZRiUDNvq3t25u7zl5Z133sHJkydV5S8J6BSVa+K7775TvY4kQJOXPP/6669VUCdvoEeeCykzbw/yCMlfNHDgQNWrJzo6GmFhYRX63oiIytuVLAtm703Fr5HZaKBPxi3+RzGz1jI0ck/KnSfb7IX9CV0Qlen8Oc7NZoNPkA0nM3fKE5f3s1Wjzhjf5w7UDqzv8jqIiIiIiLTI4eyUgwYNUo/z5s1zagMyvwRTBg8ejMp26NAhvPvuuyrPTtu2bYuc59y5c2rYVZ8+fdTQrrzkuUy/cOECYmL+LuO7bds29Vrfvn0LrW/EiBHqUYZ8ERFVF5FpZtRfcAlTFu/BQ9n/h0vh92J/4//Du7W/zQ3yWG3A6dTmWBE92qUgT3CAJ1JrncHJrB0uB3lq+YXg1mGP4s6RMxnkISIiIiIqS4+eu+++G5988okayiS9VuSnNFu3blXzu7u746677kJlysnJyR2yNWPGjGLnk0CPkGFdRZHp69evV/M1btxY5fO5cuUK2rdvD72+cJJP+3rs6y2JwWBAdWI0GvM9knawbWtuu+5LMGHC2jQEuGXh2aCl+EfABugLBGEMZi8cTOyECxlhsDl+fyBXqsd5pNpiEWVwvQeP6NduDAZ2GA9Pdy91jq/JeMxqF9tWm9iu2sW21S62rTYZq3G7OlMYy+FAj1SSevDBB1WwZ8qUKSp4IkmIa9euXWROns8//xwfffRRbo6cyq5E9frrr6tgy6ZNm4oMyOSttiWKyyEUGBiYbz77o316afOXJDY2FhaLBdVNXFzctd4FqiBs25rTrrtTdHjkqDfq6VPwe/256OmdPzidZfbG3vhuuJQV6tI2bbDisvtBmN3+l3/HiRQ+3ZoMRduGveCu/2tobGZOKnw9A1Sp9bjLV13aH63iMatdbFttYrtqF9tWu9i22hRXzdpVYhrFdU4pilOZK1966SWcP38eK1euVLlv3nvvPTUkSoI49opWMsxJcuJI+XEZsjVu3Di88sorqEx79uxRFbOeeuop1fOmqgoNde0L1LUiUU85IKT0fN7cRFT9sW1rRrvKOXnxRSOm78xAM/c4HG38JIL1WfmWiclsiC1X+ru+TWTgqvsxWN1MTi3Xv91YDOgwTvXWEbKvbpKtmYrEY1a72LbaxHbVLratdrFttclYQ9rVqUCPTqfD999/r4Io77//PpKTk3Hs2DH1IxfkcmFuFxwcrKpYPfbYY6hMZrNZ9SDq0KEDnnjiiVLnt/fASU1NLfL1gj14SuuxU1qPH1e7XlUlckBU132nkrFttduuUQY9/m9XKiLiEvFmyCLc5L8DXm7m3HkyTL4qwbKrPXji9SeQ7ZbodPGtTs364IZ+/4C3p69L263peMxqF9tWm9iu2sW21S62rTZ5arxdXapF++ijj+Lee+/F2rVrsXPnTjUEKT09HQEBAaqXSr9+/TBy5MhCyY0rQ0ZGRm5+nOKqg0l1LCFBK3uS5sjIyCLntU9v0aKFepT31KBBA1VJTIZdFRwWVnB+IqJr6WymG6YsuYR/+izFwsC1QIEcyhabDidSWuNYcltYbMUPcy3IhCwk6c8hR1d0kLwkHnpP9GozDKN63Ax3PUuiExERERGVJ5evsH19fTFx4kT1U5V4eXnhzjvvLPK1HTt2qCDQddddhzp16qBJkyYqINOwYUPs3r1bDT3LG5yS5zJdSstLIma7AQMGYNGiRdi1a5f6PS9J3Cz693d96AMRUVntisvBpDUJGOMVgSW1f0YD98IBmdis+tiX0BUZJn+ncu+k6qKQprvkUuWs3m2GY2T3qfDxqvwbAURERERENYHmbqX6+PiooWVFkSFdEuiZOXMmevXqlTtdAkNvvfUW3n77bbz44ou50+W59BCS+QtWIJNAz2uvvYalS5fmju2THk5Sen348OEqiEREVJm2XcnBhD8S4AkT/hO0BOcarylyvgRDiEq0nGwMcmr9RmQi3v04LG6OVbzy96mFjOy/AkxhdVvgtuEz1DQiIiIiIqo4mgv0uEIqiK1atUqVgo+IiECXLl1w+PBhbNiwAd27d1cBorwGDx6sysUvWLAAQ4YMwejRo1XJ9SVLlqjcRBI0IiKqDBkmKz4+moH5pzKRYjBgZq0/8O+gZUXOm2oMwO6rPZCQU7haYnFy3NKRqD8Fs5uh1HmD/evihv7/QMvQjk69ByIiIiIiKj8M9Pwv745UEpszZw6WL1+OrVu3qizcjzzyCGbNmqV6CRUkQSGp6DV//nxVSl7WMWHCBMyePRvNmjW7Ju+DiGqG2EwLpq1LxJGkvypbDfeOwP76HxY7f7whBGsvDXNo3TbYkKG7glTdRVjzJGsuSaM6zTCi2xS0aNhBJe0nIiIiIqJrxy0lJcX5JAtUIxkMBkRHRyMsLEzTGcprIrZt9bD3qhGjVsar371gwoO1VuM/QUuLnd9g8cShxI6ITG/mcO+dZN05GHUZDs0vwZ2BHccxofI1wGNWu9i22sR21S62rXaxbbXJUEPalVfnRERVXFRaNpYf2IR/WD/EpfDi57PZgLjsethweZBT67fApHrwSE8eR8qjt2rUCVMHPwhfL8eTOBMRERERUeVgoIeIqIqKSYxF1MEP0EUXgX+UMq/k35EKWhLocUaG2xWk6C+UOkzLzc0NI7vfhD5tR8DLQ7t3P4iIiIiIqjsGeoiIqpBzqWaMWRGLW7xX4/FaK9BFZyx2XotVh9NpLXAwsbNL27qiPwyjLr3Y1931Hri+793o0qI/9Dq9S9sgIiIiIqLKxUAPEVEVkGW24p3D6dh7eg8W1fkBLT2uFDlfuskPSTnB2BHXGzZHxlkVkWz5ivtBmNyyiny9QUgT3DjgXoTWbur0uomIiIiI6NpjoIeI6BoyWW14eW8yjNFL8XzIL0D9/K+brXok5oQgwRCCw0muly3PcktAsv48LG45Rb7u7eGLyYPuR9uwbmqYFhERERERVU8M9BARXQNWmw3rIrZiQOLreEomhPw1PTknUA3FupJdIOJTBlf1R2HQpRT5Wi2/EFzX+3a0b9KDAR4iIiIiIg1goIeIqJIdjToBy6mPMEB/PrcM+sbYgUg2BpfbNv7qwRMJi1vxOX4GdRqPoZ0nwtPDq9y2S0RERERE1xYDPURElWRbdCIO7p+HuwM2Qq+3IcPki61X+iHZGFQu6ze4pSJZf67Y/Dt2ft6BuHfs06gbFFou2yUiIiIioqqDgR4iogp2OT0Tf+5bhsHmJegWmAaLTYejyW1wLLktLDZ9ufTeSdVHlRjgaRPWFeN734HggLpl3h4REREREVVdDPQQEVUAm82Cy2eXo1b05wgEMFUm6oHYrPrYl9AVGSb/Mm/jqv4YDG7JKK341k2DHkbnFn3KvD0iIiIiIqr6GOghIipH5vRI5Ox9WP1eK8/0TLMPDiR0RnRmY5fXnaa7hDRdNKxu5lLnlSTLUwY8CHOmDmGNwlzeJhERERERVS8M9BARlYO0uH3QH3uu0HQZpnUqpSWOJreD2eb4KdcGG1J1F1VwB262Uue/ccC96Ny8P9z1f2/DYDAgOjPaiXdBRERERETVHQM9REQulkePSDAiPGcnPE/PkVFZuWw2IDK9KXbH93BqnYn608jUXXV4/pHdp2JAh7Fw13s4tR0iIiIiItIuBnqIiJxgs9mw8sRJhEfPQSuPuNzpVpsbjiS3w7Hkdk6tL8ctHcm6czDqMkqdt1/70egQ3gvp2alo07gLPNw9XXoPRERERESkXQz0EBE56EzsWeD4qximuwJ4QJVH33h5INJNAU6vywozUnQXkCHrKiGZsqe7N6bf8DJCAuuXbeeJiIiIiKhGYKCHiKgUl9LSsXvvNxiBNXDXWXE1uw62x/VCtsXXpfVluMUhRX8BVjdTsfP0aTsSo3vcDE8PrzLsORERERER1TQM9BARFWP/1Rz8uGs1HvJeiDHuKUg1BmBPfHfEG+q4tD4jMpGkPwujLr3I13u0GoIxPafBx8uvjHtOREREREQ1FQM9RER5ZJtteHp3CnadP40Xgn/Gy/7HkWX2xpYrfRGTGYoSx1mVIFUXrapoFbV45+b9cH3fu+Ht6VP2N0BERERERDUaAz1EVOOZrTbMPZaB1/Yl4pWQH/BawFYgFDBYPLHrag9VQcul9cKAOPcIWNyMhV7z9vDF9f3uQqdmfeHm5lrwiIiIiIiIqCAGeoioRtsdl4N/70pF3cz9WFF3CUJgwOHEDjiW0tal9ZmQjXj34zC7ZRf5+hNT3kZIQL0y7jUREREREVHRGOghohopwWDBC/vSsPFcFJ7xXonszLo4lNnLpXUl6s/A4JYMC4z5hmYN7DgOfduNQi2/kPLbcSIiIiIiohIw0ENENYrFasOCU+lIPrkA47MS0dUYimxjXafXY4MNcfrDMOoycqc1a9AOk/rfw1LoRERERER0zTDQQ0Q1xoF4I77ZtQsjMjbCnBGKS5KIx0kGtxQk6c/lDs1qWr8tbhk2HX7egRWwx0RERERERM5hoIeINF9F60iSES9uv4gpxiXomeGDBKvzAR6RqD8NL89s3DLkATRt0A5eHt7lvr9ERERERERlwUAPEWluaNai89l4ancq3M1J+KbuJ2jhFo9707shKacerC5UzkrSn4VBl4LB7cdiaPcp8HD3rKC9JyIiIiIiKhsGeoio2jucaMT1fySgPi7hq7pzMUZ/Gck5SgYAADOVSURBVN7u9XElcwBOxHTHCRfWaYVZ9eDJdkvG+HbXoVfvqdDr9BWw90REREREROWHgR4iqpYuZVowcXU8zqZZ0MYjBl8EfIXDicHYG9Ufe/83T54CWKVK1UUhTRcDm9tffX6GXDViVPfr0HTY7dDpGeAhIiIiIqLqgYEeIqpWTFYbPjuWgTcPpaGd7gzWBM/DxqSGiLnaB7VdWJ8RGYh3P45pJ2LRMy5TBYfM3QbA8OgzgI9fBbwDIiIiIiKiisNADxFVG9suG/D93p14zfsDNLT2R4ohBBFZg50O8JiRgxT9eehNcXjoUBwaZplgadYG2S88AWvzthW090RERERERBWPgR4iqtJsNhsWR2bhi+37cDsOokeOHxZjgmvrgg2ZbrHoHHsUY88nwstqU9MN986CeeAYQKcr570nIiIiIiKqXAz0EFGVdTbZiB82bERoUhRuUsOsXB9KJdWz0nEU0/efQ/0sM0z9RiLzlodgC3JlwBcREREREVHVxEAPEVU5++My8efahaiTbUNoGdeVpruE2unncM+xWAQZLbA2bILsRx+HpX33ctpbIiIiIiKiqoOBHiKqEiwWC46fPoFd23aq53VcXI+nKR3jT2xE07T0Qq8ZR0+FcdoDgLtHGfeWiIiIiIioamKgh4iueQ6es2fPYsuWzbD+L2eOK0Iyk3HzkXXwMRvVc0vzdjBOvQ+68ydh6dAT1qatATdnCq4TERERERFVPwz0ENE1Ex8fjy2b/kBSSo5Ly5tNx3HjyeNomZp/+eyn3oelXTf1u6VDj3LZVyIiIiIiouqAgR4iqlSZmZnYuHYZLsdnuLR8uu4yUnTnMTwqGdedT4H+f52ALK07IXvGa4B/YPnuMBERERERUTXCQA8RVYocQyb2bPgRJy+5sKxbGuL1J2B1M+HG00kYdCkdMgjLOGoysif/E/D1r4hdJiIiIiIiqnYY6CGiCpWVlYUVK35DaoHhVY4wuKUiQX8C005eQa8rmSq4Y3PTwTx8InJuup8BHiIiIiIiogIY6CGicme1WrH7YASOHtjr9LIWmJCgP4kcXSqmH7yClnny91jrNFD5d2x1G5bzHhMREREREWkDAz1EVOagzunTp3HkyBGkpKS4tA4bbEjXXUKqLhp6mxmP77uMRpmm3NdNA8eqsui2wOBy3HMiIiIiIiLtYaCHiFwK7pw4cQI7duwol/VdcT+ElinxeORkMmobzLnTLWEtkHPXDFhbdy6X7RAREREREWkdAz1E5JQrV65g27ZtSE5OLtN6JP9Oov4ULG5G3BtxFR0Ts/O9nnPbdJhG3gjoeZoiIiIiIiJyFL9BEZFDzp8/j3Xr1pV5PVI9K8eWgEGx6Rh1IRV+Zmu+182desPw4HMsk05EREREROQCzQV6YmNjsXTpUqxduxZnzpxBXFwcgoOD0adPH8yYMQM9e/YstExaWhrmzJmDZcuW4erVq6hfvz4mTZqEWbNmwd/fv8hhK1999RXmz5+PyMhI+Pn5YejQoZg9ezaaNm1aSe+UqHLI8bFz505ERUWVaT3JuvMqD0+LVAOmnEpCw6y/c/AI44hJME65F/ALKOMeExERERER1VyaC/R8+eWX+OCDD9CsWTMMGzYMderUwblz57By5Ur18/XXX2Py5Mm582dmZmL8+PEqkezw4cMxdepURERE4OOPP8b27duxatUqeHt759vG448/jgULFqBdu3Z44IEHcPnyZRVc2rBhg+rx0KJFi2vwzonKl9lsxsFDB3Do0CGpae7SOjLd4pGmj4HJLVM9n3w6CQMvpasy6XbGUVP+CvD4+JbTnhMREREREdVcmgv0dO/eHStWrMDAgQPzTZeksRMnTsTMmTNVYMfLy0tN//DDD1WQR4I3L774Yu788rsEjObOnauWsduyZYsK8vTv318Fdzw9PdX0m266Sf08+eSTWLx4caW9X6KKIL13Nm3ZgJxs6XXjeJAnxy0dJmQiR5eGLLcE2Nys6BifhWmnEuFvyj9Ey3DX4zAPux7Q6SvgHRAREREREdVMmgv03HDDDUVOl8DMoEGDVK+b48ePo1u3brDZbPjuu+/U8CwJ0OQlz6X3jwR18gZ65Ll49tlnc4M8YtSoUSq4JOuPjo5GWFhYhb1HooqSkZGOZSt/QWpSjsMJlRP0J2F1yz8MS0w/eAUtU/Kvx9y2K3IeeBa2kLrlts9ERERERESk4UBPSTw8PNSjXv9XDwIZ0iXDrkaMGKHy7OQlzyWvz/r16xETE4PGjRur6VJtSF7r27dvofXLeuR1GfJ1yy23VMp7IioP2elXcWj3MqRkO5YAWXrrJOsjVcUs0T49GwMj09AkzVgoubIwDZ+oqmjB4+/gKBEREREREZW/GhPokV42mzZtQoMGDdChQ4fcQI9o3rx5kcvIdAn0yHwS6JF8PlJaun379rnBooLz511vaQwGA6oTo9GY75Gqv4yMBKz48weYMkMAlBzkscEGg1sykvTnYHUzoIOfAdfFJKNhhAluhWM7yBo9FVnjbwe8ff6aYLEClur1P1/d8ZjVLratdrFttYntql1sW+1i22qTsRq3a8HcwajpgR6TyaSSJufk5KjcO/YgjVQTErVq1SpyucDAwHzz2R/t00ub35EKYRaLBdWNVDKj6s1qseDQ0fVISXaDDhLkKT33TrLuHIy6DPjrLfjXpatofMJYKHuPxcMLCT2H4vLg62Hz8ALiEyrsPZDjeMxqF9tWu9i22sR21S62rXaxbbUprpq1q8QwiuugUiMDPVIK/eGHH1bJmO++++4qNaQqNDQU1YlEPeWAkPLzefMTUfVgs1lx7OI+bNq+FrWsTQB4QlfKMhaYkO1+AT2Cz6BLQDbqrDXC87K1yPTMluC6SP3Pe9CH1MVfAx3pWuMxq11sW+1i22oT21W72LbaxbbVJmMNaVd3rQd5pk+fjl9//RU333wz3n///SJ74KSmpha5fMEePKX12Cmtx09Zul5VJXJAVNd9r6lORR7FlvU71e+1IEGe0mW4XYG/72k8kHgFdbaZoDMXnifn1odhGjUZ0P91KtHuqbJ64zGrXWxb7WLbahPbVbvYttrFttUmT423q7vWe/L89NNPmDp1Kj777DPodPn7L7Ro0UI9RkZGFrkO+3T7fJKEWXL8XLx4UQ25Kpinp+D8RNdKdvJJrP3jW8RlOv+/aEQGGgcexT9iL6LWTnORAZ6sZz+CtXXn8tlZIiIiIiIiKjfuWg/yTJ48GV988UWRyZMlINOwYUPs3r1bJVrOW3lLnsv08PDw3IpbYsCAAVi0aBF27dqlfs9LEjfbS7kTVTZDdjIW/fEaMhJbQKcObeeDPKm6c3hw3340yCpcLt0S3gqGx19naXQiIiIiIqIqrLQUHdV2uJYEeSZNmoQvv/yyyCCPcHNzw5133omMjAy8/fbb+V6T5zJd8vrkZX/+2muv5cvUvXbtWlVaffjw4WjSxLGhMUTlITPjCv77yxP4+odvkJXY5n9BHsdZYER9w0E8sv0HvLhlV6EgT84djyHjv+uR/fJXDPIQERERERFVcZrr0fPmm29i4cKF8Pf3R8uWLQsFcMT48ePRufNfw05mzJiBVatW4YMPPkBERAS6dOmCw4cPY8OGDejevTseeuihfMsOHjwYd911FxYsWIAhQ4Zg9OjRquT6kiVLEBwcjLfeeqvS3ivVbBaLCZu2zsWJsyZ42drDy4V1eOIybjuwFcEFgjvWOvVhePQVWMNbSUS03PaZiIiIiIiIKpbmAj1RUVHqUXrjvPPOO0XOIz1u7IEeGa61cuVKzJkzB8uXL8fWrVtVBu5HHnkEs2bNgo+PT6HlJSjUvn17zJ8/H59//rlax4QJEzB79mw0a9asgt8h1XQmsxHLt3yKyPPJCLQ2ghd8nV5HqHskJkbsgXeSJd/09Nsfg9vIiYCu6F5wREREREREVLW5paSk2K71TlD1YDAYEB0djbCwME1nKK+qLsadxterXoOPLQTBluZwh3NtYNUlY3D9/egQkQCfU5bcEunGcbcgbcw0RMcnsG01hsesdrFttYttq01sV+1i22oX21abDDWkXTXXo4dIS2w2G05GH8KPGz6A3uaFupb2KtDjqEy3q/DxPYnrAhLRcpsBnlus+V9/Yz5soeFyxquAvSciIiIiIqLKxkAPURUVl3IZC/6ch6DU+miCgU4tOyJyMzrFxuT22snLcNfjMA+7AdBpLhc7ERERERFRjcdAD1EVzMGzcNuviD93BrWsDZ1advKRtQhPvVrka4aHZsPcZziTKxMREREREWkYAz1EVURMfCTmL/8Q9Swd1fNANHJoOW9rEiYd2YmG6Sn5ptt0OphGT4Vx0j8AH+cTNhMREREREVH1w0AP0TViMGYhInIXVu1ciLrmDvCEH+rhryCPI/TIwdCLB9ApOrLIIVrZL38Na1jzct1nIiIiIiIiqtoY6CGqZCkZifhq1StIy0xBgDUUDa09oIMz5cxtaJ9+BkOOHoa3xZjvFXP3gci5bTpsdZ0b8kVERERERETawEAPUSUxW8zYfnQVNkf8Dr0pAA0sXVUvHmfdemg1GmQkFZqe/cQbsHTtV057S0RERERERNURAz1ElZBced3BRdhxdDV8bLXR0NLXqeWDdfEYd3I36l1NLfSapXEzGB57Bbb6jctxj4mIiIiIiKi6YqCHqILYbDYcOb8LK7Z9h5CcDk6XSBdDk3aiy/FIFCyEbm7XDTl3PQ5baHi57S8RERERERFVfwz0EJUzq9WKPUeX4o/9q1DH0gZ1bd2cXsdo/Ua02xELnanwa9mPvQJL94Esk05ERERERESFMNBDVI5DtFZs+xwHzx9CLWsYGlv7OLysuy4TfaxH0fXYOXgm2wq9bq3fGDl3zoClU69y3msiIiIiIiLSEgZ6iMo4POts7FH8suZr1LNIaXQfhMHxhMgeMKHP5Qj0OHcKOhQO8Nj07jBOuhum66YBHp7lvPdERERERESkNQz0ELnAmpOCfTtfx6rzyQi2NEc9mwR5nBNkSsXUg+sRYMwu8nWbXyCyXvqCpdKJiIiIiIjIYQz0EDnBZrMi7swvWHlgBRIzm6ChtQd00Du1jjaJ5zH89F54W/5KwGPu1BumcbfA0rYroCuYdpmIiIiIiIjIcQz0EDnIkHwcm3Z8gANxXgiy9EIwfB1eNhBpGHj6MNpcjVLPTV37I/OOR9lbh4iIiIiIiMoVAz1EpbCZ0nF034dYfyoOfqZeqOvk8sPP7kGnK2dVDh5znQYw3fkYLF37V9DeEhERERERUU3GQA9RCcO0Es4vxcrdfyAtsxX8bJ2dWn7sqe1oG38BUgTd5u4B4/hbYZxwO+DpVWH7TERERERERDUbAz1ERTAkn8TKtT8iKTUMQG/4OLBMmN8FjDh1ALUuGPJV0LK0aAfDv56FrUHjCt1nIiIiIiIiIgZ6iPKwGtOxbdPXOBGlh84mQZ7S1c5MxsizexCanpA7LbnvGHjedA9sgcHswUNERERERESVhoEeIul1Y0jErvWf4HhsKAB/OFL7yt1ixMALEehy+bTqwfNki9vQ8647MC7cBx5ubnn69BARERERERFVDgZ6qEbn4DFfXoOIPb9gf2JnuFklyOOYNlfPY+D5g9jbaih+vusVhNYNwvN1PODmJhl5iIiIiIiIiK4NBnqoRspJPon1axfjUqrU0OqvEiY7wseYjcnHNqJeZjIOPv4J+nTrWMF7SkREREREROQ4BnqoRsgxGXDp4npEH52Hk8kdoDM3AZwolB6UlYTxp3bhYmA4kv79AXxbhKNVhe4xERERERERkfMY6CFNS8tMwvoDP+PA2V3ws9VDbct1DuXfsdNZTZhyZCM8c4w4NflRdB0zHG46Z9ZAREREREREVHkY6CFNik04j9+3fIjYtGR42HxRz9IJ3rZaDi/vbk3BzQc3oH52Nv7sMgldH3wA3XwdKbJOREREREREdO0w0EOaYbFasPnwUmw8vAywuSHAGoom1g5OrSNNF4PbIvbig7rT8O0D3+NfXULQX8cEy0RERERERFQ9MNBDmnAu9hhW7/4vkpKzEWYZADeH0yv/xQoz4pJN2NP+IQx85hnMqefJClpERERERERU7TDQQ9U6uPPtn2+p3/U2TwRbmqOBrY5T69AbLyA2qS7eazQFP9xSB8834fAsIiIiIiIiqr4Y6KFqxWaz4eiFPfhl81z13M2mR5C1Kfys9aCD3uH15NjioIvPxqJW9+KFqY3wXH2vCtxrIiIiIiIiosrBQA9VmwDP1ZRLWLX7R1y9lIQm1oFOr0Nns6BHzAmcMIXglea34b6x9bCiWyDcmYOHiIiIiIiINIKBHqqyzBYzdh5fgz/3/6Kee1uDEGxpgRC0cHpdYSlX8FWtYfC4407c0coXtzL/DhEREREREWkQAz1UJUVePoEVuxYgJSUVjc39nBqWlZfVBsx174fWXRrgq8HBCPF2bT1ERERERERE1QEDPVSlpGel4I+9C3Ei8pBKrtzQ1tyl9Rw31YZvt0F4qmdtPOChK/f9JCIiIiIiIqqKGOihKsFitWD3iXXYcHAJvHLqoKG1O9zgXIAmwJiONbZ2qNOzH17qHohATwZ4iIiIiIiIqGZhoIeuKaM5B2v2/Yw9J9bD11YHIZb28IDzJc5TMoAtHW7Da/3roIk//62JiIiIiIioZuI3Yrpmjl/cj7Xbf4dvZhiawPkqWh2yTmJxdlf82XgQ3hnbAE+GeVfIfhIRERERERFVFwz0UKVLSr+K5Zt+RHqcBb62MKeWDfW9jO5ZEXgu83ZE9HwOD3XwxzvBHhW2r0RERERERETVCQM9VGlMZiPW7lyMqJMJ0MMPXk4s2z7oJHqkHMO8yJH4qttHeHNgXbQJYoCHiIiIiIiIKC8GeqjCGYxZWLTmc2RdCVDP9Q6GeGp7JaJX3UOol56Ef1+8B7fUn4nv762N6aEcokVERERERERUFAZ6qMLYbDbsiViFvfuOwMta2+HlPHU5aOV+Ds/n3IB9V+7E+CbeeO26WvgkgP+uRERERERERCXhN2eqECfOrMeGHRvgbgyDFxwP8tT1SMAxYyDOdX4RS7sGwN+DJdKJiIiIiIiIHMVAD5ULm9UMU+TPOHJsFQ5cHaqmeaKpQ8v6uWegt+d+PGe8GZeCb8DPI+sg1E9fwXtMREREREREpD0M9JTBgQMH8MYbb2D37t0wm81o3749pk+fjhtvvBE1SVbUZizdtBaZOeEA/gryOMINVoyosxmPxd0D84B/4cdWvtC5uVXovhIRERERERFpGQM9LtqyZQumTJkCb29vTJ48Gf7+/li2bBnuuecexMTE4NFHH4XWJUcfwHdrf4SPpQ0ACfI4Ru+WgzEJW/CS20240v0zLJ4YCA8dAzxEREREREREZcVAjwuk986MGTOg0+mwcuVKdO7cWU3/z3/+gxEjRuCVV17BxIkT0aRJE2hNZnoavvvuu9znPpAgj2Nqe0dhwtl9OJLdFjEPf44vm4ZU0F4SERERERER1UzMdOtib57z589j6tSpuUEeUatWLcycORNGoxELFy6Elly9dFoFePbuP+D0sh5uaehy9SA+SR6Djyb/gs5z3kMfBnmIiIiIiIiIyh179Lhg27Zt6nH48OGFXpMePWL79u3QksDgUJeW65R1GH8aesLr5gewvqUf3JiDh4iIiIiIiKjCMNDjgnPnzqnHFi1aFHqtfv36Kl9PZGRkqesxGAyoNnTu6Nc1DDsPRTs0+zGDF771HYZpXW7Ey919UctTh5ycnArfTXKN9ELL+0jawHbVLratdrFttYntql1sW+1i22qTsRq3q+QHdhQDPS5IS0tTj4GBgUW+HhAQkDtPSWJjY2GxWFDV7d+1EumWw8jIssLfY2Cx82UgHQlNRmFkqA+GeNkw3U0CWQakxSWj9L8GVQVxcXHXeheoArBdtYttq11sW21iu2oX21a72LbaFFfN2lWv16N58+YOz89AzzUUGuracKjKdvJoCFIT+gCe8UhyO4sQa8t8r1stGYjqMA1Pdg+Gt55Ds6ojiWjLyU56pHl6el7r3aFywnbVLratdrFttYntql1sW+1i22qTsYa0KwM9LrD35Cmu1056ejqCgoLKtevVtTT+htvx5edPwcuzMXxtdZHllohAXQz+sAxHt54j8Z8uAdCzPLomyMmuuvxfkuPYrtrFttUutq02sV21i22rXWxbbfLUeLsy0OMCe24eydXTtWvXfK9JdDAjIwPdu3eHVuj0ejw4/W2kpKVh+Zbt6NfjFnRqUAv3MLEyERERERERUZXC8uouGDBggHrcsGFDodfWr1+fbx4t8fb0RN82LdE62JvVs4iIiIiIiIiqIAZ6XDBkyBA0bdoUv/32GyIiInKnp6am4r333lPdwG655ZZruo9EREREREREVPNw6JYL3N3d8dFHH2HKlCkYP348Jk+erEqqL1u2DNHR0XjllVcQHh5+rXeTiIiIiIiIiGoYBnpcNHjwYKxevRpvvPEGlixZApPJhPbt2+Oll15SgR8iIiIiIiIiosrGQE8Z9OjRQw3fIiIiIiIiIiKqCpijh4iIiIiIiIhIIxjoISIiIiIiIiLSCAZ6iIiIiIiIiIg0goEeIiIiIiIiIiKNYKCHiIiIiIiIiEgjGOghIiIiIiIiItIIBnqIiIiIiIiIiDSCgR4iIiIiIiIiIo1goIeIiIiIiIiISCMY6CEiIiIiIiIi0ggGeoiIiIiIiIiINIKBHnKKXq+/1rtAFYRtq01sV+1i22oX21ab2K7axbbVLratNulrQLu6paSk2K71ThARERERERERUdmxRw8RERERERERkUYw0ENEREREREREpBEM9BARERERERERaQQDPUREREREREREGsFADxERERERERGRRjDQQ0RERERERESkEQz0EBERERERERFpBAM9VKoDBw7gpptuQpMmTRAaGoqRI0diyZIl13q3apzY2FjMnTsXN954Izp27Ii6deuidevWuPPOO7Fv375C87/xxhsICgoq9ufixYtFbmf9+vUYN24cGjdujLCwMEyYMAGbN28udr/Onj2Lf/zjH2jevDkaNGiAAQMGYN68ebDZbOX6/rWuU6dOxbbV+PHjC82fk5ODN998E927d0f9+vXRtm1bzJgxA/Hx8cVu45dffsHw4cPVcRweHo5p06bh0KFDxc7PY7/sfvjhhxKPQ/m54YYbcufncVv1/Pzzz3j88ccxdOhQ1KtXT7WDtGtx0tLS8Mwzz6jztMwvx/bs2bORkZFR5PxWqxVffPEF+vfvr9qiRYsWuPfee3HhwoVit8H2rty2NZlM+P333/Hggw+id+/eaNSokfrbjxgxQv0dLRZLoWXkWC3pWJZjvShXrlzBI488gjZt2qhze8+ePfHOO++ofSiKK58FWufMMVtVz7nOnkdqCmfatrTPXvmJiYnJnZ/HbPX5jiP4WVs6dwfmoRpsy5YtmDJlCry9vTF58mT4+/tj2bJluOeee9TJ8dFHH73Wu1hjfPnll/jggw/QrFkzDBs2DHXq1MG5c+ewcuVK9fP111+rNiro1ltvVV/UC6pVq1aRH6APPPCAWrcsJ+SL/aRJk/Dtt99i4sSJ+eY/efIkRo8eDYPBoOZp2LAh/vzzT/z73/9Wr7399tvl+jfQusDAQDz00EOFphdsP/mwuu2229QHUK9evVSgQP4XFixYoD6A1q1bp9owL7noePXVV9UHlRy/8kG4ePFijBkzRn2B6du3b775eeyXD7nwmDVrVpGvyd/zxIkT6stiQTxuqw45bqKjo1G7dm11US6/FyczM1MFZo8cOaKCqlOnTkVERAQ+/vhjbN++HatWrVLHVF7ypUWO3Xbt2ql2vHz5MpYuXYoNGzaoY1kuRvNie1d+254/fx533323Og8OHjwY1113nfqSsXr1avV3lL/nTz/9BDc3t0LLypeQooL1AwcOLDQtLi5OBdQvXbqkvlBI28v/jezn/v378eOPP+bbhiufBTWBM8dsVTznunIeqSmcadviPnvleJYbXxJgkS/wBfGYrfrfcfhZ6xi3lJSUmn07h4plNpvVSUiirGvXrkXnzp3V9NTUVPXFJCoqSkVZi/pgpPInXwpDQkIKfdDs2LFDnWz8/Pxw6tQpeHl5qely50HuGCxfvhyDBg0qdf0pKSno0qUL3N3d1Zd8uWMp5MNLLmyF9P4ICAjIXUai3LL9X3/9FaNGjVLTjEaj2p+dO3eqE5zc/STHAgJCPrRK8/3336u7R/LB9tVXX+VeRHzzzTeYOXOmupsgH5h28mHZp08fNG3aVF1c2C9c5UNR2k2mS3vpdH918uSxX/HkOJGLTPmyePz4cXU3SvC4rXo2bdqk7s7J//v777+Pl156CZ9++iluv/32QvO+/vrreOutt9QF5Ysvvpg7XX6XY/L5559Xx6idtJlc6MsdRrng9PT0VNPluJPedHIBKwFZO7b3tWlbORfKFwe52JfP2rxfNuTL3cGDB9WFv1zc5+0dIG0ly3z22WcO7Y/0GJKA0XvvvYd//vOfaprcCb7vvvuwaNEi9WVHzvuufhbUFM4cs1XxnOvseaQmcaZti/Pkk0+q40WCMXL82PGYrT7fcfhZ6xgO3aJiyT+2RL3lZGT/oifkS6IcPPLPu3Dhwmu6jzWJnKCKupsgJy25OJGTknxhdJWc+OSL/L/+9a/cE5qQ3++//34kJiZixYoV+bonyglNtm0/oQk5eT777LPq9/nz57u8P1Q8uSMh5IMs750i6W0jQRv5kMnOzs6dLt2aJXgjdxXy3p2U41p67ciHp3wI2fHYr3hyhyopKUn1qLIHeVzB47biyRABR4KacnH/3XffqV4f8kUiL3ku0+3Hrp39ufzt7ReeQtpGzvdypzHvHWu297VpWxm6Kl/c8gZ5hDyfPn26+l3uIpdFenq6ulss53A5l9vJOf6FF14osq2c/SyoKRxtV1dU9DHoynmkJilr20pvCzku5O9/yy23lGlfeMxem+84/Kx1HAM9VKxt27apR4lyFmQfalDWCxsqHx4eHupRr9cXek1OPBLd/uijj9RJqbixq862d0nz9+vXT10A8//DORJAkaDMu+++q7qxFjUuWS5SZHqrVq0KXezIRYN0eZW7zHKHuSLalsd++bBfdNx1111Fvs7jtvqRnnPSFVx6zxUVEJDpkgsgb04IaQ95reDQyfI6Ntne1/bz156/Q+7cy3ldjnsJohdl7969KneHnMMLDgGTc72c83fv3p2bD8iVzwIqXlU557pyHiHHSc8tCRrI8MvihkjxmK3a51h+1jqOOXqoWHIgiYJjFoWMi5WIaWRk5DXYM8pLItDSlVWSfnXo0KHQ6wWTx0mvjDlz5uSON3Wkve3T7PPk/V260BYkJ2NJ9itjUqUniXR9pNLJWG/73WE7SdYnidxk3LKQCw4Z413U313Yp0v7yJ0Q++9yvMpx60zb8tivGDL0Tcbiy50hGdtfFB631U9Jf1v7dBk6KfNJXgi5oJcvFO3bty8ySJD3WC64DbZ31SFDMYq7wBcbN25UP3m/0MlQARl2kvdLiiP/P2fOnFGf+XLn35XPAipeVTnnOnseIedIT5CSbrIIHrNV+zsOP2sdxx49VCzJHWFPEFsUGZdon4euDcnoL4nC5I6CjEvNewKTZHKffPKJGkMqJ7jDhw+r8azygfXwww+rfAOOtrd9DGre9rb/XlSiQvsy8oFW0ytEOErGl0tSZLkokHwQMnxKqmJJ5Svp0ipdhB35u9vbr2BblXQcFzV/3nUVtQyPfddJry05NuQLRMGLDh631Zezx2Zpx1lxx3Jxy7C9K5/k5ZEcD5KzQZJw5uXr66uGEciXFMn9IXeY5Rzfo0cPlQhWcnu48v8jwwmcmZ/n6pJVtXMu27XiyDG4detW9eVfes8UxGO2enzH4Wet43j7hqiakhOGXIRId2OpBlJwrPH111+f77lEk2WsqZR/lISRkoROEodR1fDUU0/ley65caQMpD3zv4ztzZs0kKrvcSuBHvkScccddxR6ncctUfUgFbfkS6FUMpShtgVJeWB7bga7IUOGqET38ihDSCS40LVr10rcayqI59ya1ftO8rvIjTV78Ym8eMxWn+845Bj26KFilRZZlh4GxUVHqeJPgDLER5K23Xzzzao7qaPkw0qGAUlSs7xtW1J723uT5G3vgncqilpGvszKMB9ynT3Bn4zzduTvXtRdCPm9pOO4qPnzrquoZXjsu0buFMq4cekBIF25HcXjtupz9tgs7Tgr7lgubhm2d+WR6iny5UMSqcuXPxlW4CjpNSC9NfOe1535/7HfMXbls4BQ5c+5bNeKu26WIhIS4CnqJktJeMxWre84/Kx1HAM9VKyixiDmzSUi3c+KGx9JFR/llg8sqYokJSCLujNRktq1a6vHvJn9S2rvosaq2n8vKleLJJ6Tbq9yZ4x5H8rG3lZZWVnqUYID0t7F5cixTy/YVnK8ynHrTNvy2K/8JMwl4XFbtZX0t8073T6f5HqQAIH8ze3JOkuaP+/vbO9rZ82aNbjzzjvV8ShBHmcCtsWd1x39/5EKLva8LK58FlDVP+c6ex4hx6xbt06VxpYhW9ILz1k8ZqvOdxx+1jqOgR4q1oABA9SjlJwrSJJc5Z2HKvcE+NNPP2Hy5MlqaE9xlT6KI0nJJCGYnPjsH1yutHdJ80upbtkO/z/Kzl55y16hwcfHR40Xl1w+ktQ3L+mSLAkEpW27detWIW3LY991Uk5d8j0EBwdjwoQJTi3L47bqkwu9hg0bqju+8nfMS57LdLnQy5tAVf7W8tquXbuKbb+8STnZ3tc+yCNBWjmGJcjjasC74Hld9OzZU30plHO4nMvzknO9nPOlmoz9i4IrnwVU9c+5rpxHqHySMJeEx2zV+Y7Dz1rHMdBDJXZblejzb7/9hoiIiNzp0i3tvffeUyc3jpms/K6McgKUceOSE6C4II90ETx79myh6XJXasaMGep1WUfeyPKNN96ouh7KeuWuh538LmUm5UIn75dTKQ8pJ0VJbCfJKPOWCH/ttdfK9IFa05w+fTrfXaK80yUBnZA7G3YyZEC8/PLL+S4u/vvf/6rkgVIdQi4o7GQ8urS1lArN261UjutFixapXARS/tGOx37FkGNXjg/piuzl5VXodR631Zt0y5aeHtLj7e233873mjyX6fZj187+XP720gZ20jZSrlUqOeX9YsH2vnbk7yd/q6CgIBXkKe2uuyT1LfjlTyxbtkzdrZb15K26J+0qX27kHC7ncjtZh5zrRXH/P45+FlDVP+e6ch6hkiUkJKicWlJOXcqqF4fHbPX4jsPPWse5paSkFP6PJvofqfwzZcoUeHt7q5OZjC2UE56Uu3vllVfw6KOPXutdrFGlP998803VBpL5v6gT4Pjx41USX+kiKMnipDR369atVUnsq1evqpLOcpKSEoMrVqxASEhIvuUl6a9kuJcPQznJiSVLliAxMVF9CMnJN68TJ05gzJgxMBgMan7pGim5C2T6/fffX+gETMW37dy5c9WHhHQplvHgcvEpHxZSdWDmzJl4/vnn830gysWA3FWQJIFyl0C6i8qXD/mgkunShnm98847KqmkrF+qeMkH4eLFi9WHkFSV6Nu3b775eeyXP2lfyfewffv23DKhefG4rbrD7eSOnJD2ky8DcrxI/g4hQVL7BZzctZO/7dGjR9WFY5cuXdT8cpdP2nXlypWFLuIfe+wxtY127dqpyk1S+UfaT+7syjmgZcuW+eZne1d+20rQfdCgQar6i5wXC7aJkHOvBNXzfh7LFzc5R4eGhqru+xI4l+1JoFfaqmCSX2l7+SIpx7skCZYeQ3K+2Lt3L8aOHau+bMqXnLJ8FtQEjrZrVT3nunIeqSmcOR/bffzxx5g9e7YKJNi/dBeFx2z1+I4j+FnrGAZ6qFT79+9XB+CePXvUl0754JOTpXz5o8rz0EMPqQ+Mknz66afqQlOSh8mXcWk76R6akpKiTnhyITNx4kR1winuIkHGMUvPD/lwkw8nOXlKZZGhQ4cWOb90QZUAggQGpFeK3OX85z//iXvvvTffhxsVT+4mzJs3T/3N4+Pj1d9R7hZIF9/77rtPfYgVJF84JEGdfBDJBYYMJZAPmOeee04lCC2KlAeV8c7SHd3Dw0NdHD3zzDPFVpDgsV9+5G85YsQI1ab2br8F8bitnufeW2+9VR1XeXu+zZkzR124S04r+fIoF4SzZs3KLcual1z4y11DqawnF/xy0SntJl9M7F9eCmJ7V27byl3agtWZCpIvbPLlwk6+UEhwXM638sVA2lmGG0gidqmgKMd1UeTLh7SVfEGQc4AE56UHpfQwkd6U5fFZoHWOtmtVPuc6ex6pKZw9HwsZPnXq1Ck1pEd6MBeHx2z1+I5jx8/a0jHQQ0RERERERESkEczRQ0RERERERESkEQz0EBERERERERFpBAM9REREREREREQawUAPEREREREREZFGMNBDRERERERERKQRDPQQEREREREREWkEAz1ERERERERERBrBQA8RERERERERkUYw0ENEREREREREpBEM9BAREZGmXbx4EUFBQeqHiIiISOvcr/UOEBEREZXG1SDNp59+ioEDB0JrTpw4ga+//hrbtm1DTEwMTCYT6tSpg7p166Jbt27o168fxo8fD39//9xlIiIisHLlSjRp0gS33377Nd1/IiIiqjgM9BAREVGV17dv3yKn79q1Sz22aNFCBTkKqlevHjw8PNCqVStoxbx58zBr1iyYzWbo9XqEhoaq956RkYFjx47h8OHD+Pbbb/HHH3+ogI/dkSNH8Oabb2LAgAEM9BAREWkYAz1ERERU5a1evbrEnj4zZ84sMXixd+9eaMHBgwfx5JNPwmq14tZbb8Wzzz6Lxo0b575uMBiwZcsWLFy4UAW4iIiIqOZhoIeIiIiomvj+++9VkKd9+/aYO3cu3Nzc8r3u7e2N0aNHqx8iIiKqmZiMmYiIiGpsMuaHHnpITX/jjTeQlpaG5557Dl26dEGDBg3QuXNnvPrqq8jJyVHz2mw2/Pe//8WQIUPQqFEjNG3aFPfccw+ioqJK3P6yZcswbdo0NXxMhljJ42233Ybt27c7/V7Onz+vHtu2bVsoyFOSTp06Yfr06ep32a7972H/kb9RXikpKWqYl7xXyelTv3599OzZU/194uPji92GrGvr1q04fvw4/vGPf6B169Zq2V69euGtt95SPY6IiIioYrFHDxEREdV4EuQZNWoUzp49i3bt2qkgigQ/3nnnHRw9elQNhbrvvvuwaNEiNG/eHOHh4Thz5gyWLFmCPXv2qKTIwcHB+dYpAaL7779fBXqEJEuWdUdHR2PVqlUqh87LL7+MRx991OH9DAgIUI8HDhxQ6/fy8nJoue7du8PT0xPnzp1DYGCg6hFUsCdQ3lw+EpiKjY2Fu7s7wsLC4OPjo/42n3zyCX777TcsXry40Drs9u/fr4I6FotFBaQkIbT8rV5//XWsW7dO/c38/Pwcfs9ERETkHPboISIiohpPKlhJbxSpTCVBm0OHDqmAhgQ6JD/Q3XffraavWbNGBVl27NihAjySH+fSpUuquldBzzzzjArySHBH1iGBEsmfI71yvvzySxU8ef7559V6HTVmzBj1eOHCBUyaNAnLly9XvW9KM3/+fJXHyN7zRvYn74/0uhHJycm45ZZbVJBH3vPJkydVXiB5vxKskdeuXLmiXpNk0EV57bXXMGjQILXs5s2b1d9Lglq1a9dWf7MXXnjB4fdLREREzmOgh4iIiGo8qV4l1axkSJbdiBEjMGHCBPW7BGxkKFOfPn1yX2/WrBlmzJihfpcAUF4SFJFhXtJ75ueffy5UNezmm29WgSAZDvbhhx86vJ8SaJk8ebL6fefOnbjzzjvVfkhJ9X/+859qm0lJSS7+Ff4qRy+Bq3Hjxqn9kl5IdrVq1VKvy5A2eX8SZCqK9OCRv2XeHk5S/WvOnDm5QaerV6+6vI9ERERUMgZ6iIiIqMaToE7e6lV2Xbt2VY/S20d60BQkAZa8uXPsfv/9d5U0eeTIkSrHTVFuuOEG9Sg9emSYkyN0Oh2++eYbFSyR/DlSWUuCRbJ9GU71xBNPqB47H3/8MVwh6xASNCouICZBICG9dYoiwScJ9hQkASrpOWQymbBhwwaX9o+IiIhKxxw9REREVONJ3p2i2Hu0SK+Zkl7PyMjIN13y+ggZqjR27Ngil5UAjcjOzla9cCRRs6MmTpyofrKysnD48GE11GzTpk3YuHEjMjMzMXv2bDWfM/l/ZLnIyMjc4VeSn6go9t440vOnKDJUrbggkSSijouLw+nTpx3eLyIiInIOAz1ERERU4/n6+hY53V7ZqrTXC7LnzYmJiVE/pZGAjStkv2RYlPxIBTFJtizDu2Ro1dtvv40HHnhAJWF2RGpqau7vkpfH1X2uV69escvYX0tPT3don4iIiMh5DPQQERERlTN7Van//Oc/KhdPZWnRooWq5HXrrbeqSmKSEFly6jgibyUs6SEk5eNdUVL+Hftr9uphREREVP6Yo4eIiIionNlLjx87dqzSty3BHjvJh1Na76O8yZbteYrKst8SXCqK5CGSymOidevWLq+fiIiISsZADxEREVE5k8TNElj5888/iw18uMKRalVSjcueEydvbiH78DPJCVQce8Jpqa7laILoghYsWKDy/RS0ZMkSVZpdEkgPGzbMpXUTERFR6RjoISIiIipnHTp0wF133aV61Ei1qdWrV+cmX7a7fPkyvv76a7z//vsOr/fJJ59UwZhFixbly6kjDAaDqsb13HPP5Vb1CgkJyX3dHvSRwJMkRC7K448/joYNG2LHjh2qetaFCxfyvS7v4cCBA3jqqafUY1EkMfV9992Xm6dI7N69G08//bT6XdYr1beIiIioYjBHDxEREVEFkGTI0nvml19+UQmSpUS7PdgiPVsk0CMkn44zpLqW/EiPofDwcNSuXVvl45Gkz/beOn369MF7772XbznJ1SNDyo4fP67Kwrdp0ya3l4+UbJfgi1QR++2333Dbbbdh1apV6kdy9ch0Sb588eLF3N4648ePL3L/nn32Wbz11lto27at+pHEy5IkWvTs2RMvvfSS039LIiIichwDPUREREQVQKpdffnllypoIsOZpNS6BFns1ackUCKl18eNG+fwOj/55BNMmzZNlVHfu3evCrxER0erbUl5dgnm3HjjjepHp8vfcVsCQ7/++iteffVVbN26VZWAt+fwkd5AeXsjSY8e6R20YsUKnDhxQm1DgkIS9Onfv7/ad6n0VZQePXpg3bp1ePPNN9V6pOdRy5YtMXXqVMyYMQM+Pj4u/kWJiIjIEW4pKSn5+xETERERETmpU6dOKiC0fPlyDBo06FrvDhERUY3FHD1ERERERERERBrBQA8RERERERERkUYw0ENEREREREREpBEM9BARERERERERaQSTMRMRERERERERaQR79BARERERERERaQQDPUREREREREREGsFADxERERERERGRRjDQQ0RERERERESkEQz0EBERERERERFpBAM9REREREREREQawUAPEREREREREZFGMNBDRERERERERARt+H+qa+ZL7nEFNgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABGgAAAJMCAYAAACmZ5AqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkx5JREFUeJzt3Qd0FOX7/v879A6CgNIFlSKCgNgQkKZYUAERbBQRPwIiWMGCDRXBjqIiFlSKBUVRehMEpSgKInYQ6QISOlLkf67n+5/8NptN291kNpv365ychN3J7OzszJK59n7uJyExMfGYAQAAAAAAwDd5/HtoAAAAAAAACAENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAADIkHHjxlmpUqXc17p16ywn+/LLL5Oei34GAADwWz6/NwAAgIxavXq1nXfeeUn/fvvtt+2KK66w3ODw4cM2efJk++STT2zFihW2fft2O3TokBUtWtQqVqxop556qjVq1MguuOACO/300/3eXGSzSy+91BYtWpTh5RMTE7N0ewAAQOYR0AAAcowJEyYk+/d7772XKwKaP/74w7p27Wo//vhjivt27drlvhReKbyRpUuXusAmt1FVT/369d3PI0eOtOuuu87vTQIAAMgwAhoAQI5w9OhR+/DDD93PxYoVs71799rs2bNdJcnxxx9v8Wrnzp3Wrl0727Rpk/v3ueeea507d7ZatWpZkSJFbPfu3fbLL7/YV199ZbNmzXL/RvqaNm0at1UkOhYAAEDOQ0ADAMgR5s6da1u2bHE/Dx061G677TY37EehTe/evS1ePffcc0nhzN133233339/imXOP/9869mzpx08eNAmTpxoJUqU8GFLESvq1Knj9yYAAIAw0CQYAJCjhjdVqFDBDV3xetEED3uKN1OmTHHfy5UrZ4MGDUpz2UKFCtn1119vJ5xwQjZtHQAAAKKFgAYAEPPUY2Xq1Knu56uuusry5MnjhvnIypUrQ/ZmSWv2ITXXffXVV+3CCy+0GjVq2HHHHZcUfoRa9qWXXnLNd6tUqWLVqlVzDVlnzJiR7DH27NljL7zwghs6U7lyZbfslVdeafPnz4/ouW/YsMF91/ry5s1r0aBtV8WNmgkrzNG6VYXz8MMP29atWyNe/3///ecqm6699lpXzaFwqWrVqtaqVSt7+umn3euZEV988YXdcsst1rBhQ6tUqZJbz2mnneZe+9dffz3ZECW9Xl7/Genbt2/S6+h9qfIqs7M47d+/31588UVr27atVa9e3W1DzZo13TboOR47dizV31Vll9bvNW3W837yySfdMDU1dtZ+b9OmjY0ZM8YN4fODtk3b6FWhqQH1rbfe6valjg3dFzwUTMf6iBEj7OKLL7aTTz7ZypYta6eccop17NjRxo8fn6HnsmzZMuvWrZvrlVS+fHmrV6+e9e/f33777Td3v84xPba+RzKbWKjXPpSvv/7aHTMNGjRwIbBen7POOstVra1duzbV3wveFh3777zzjjteTjrpJDvxxBPt7LPPtiFDhmTJca9AVo+t80sVdOnRsaflA5utAwBiB0OcAAAxb9KkSUkXH1dffbX7rubA99xzj7tdVTSPPfZYhnu6qOGuLkTTowtRBRnffPNNsts1W46+Hn/8cXdRt379erddP/30U4oLLQU0o0aNStruzCpYsKD9+++/tmbNGjekK3/+/BYuXSDeeOONNmfOnGS3ax+uWrXKfb3xxhvuS+FVODZu3OgqnL7//vtktyvo+vbbb93X6NGj3WumC9BQdAF6880328yZM0OuX18KmbZt22b33nuvZRUFf7oo9kIyj0IsPb6+3nzzTfdcdNGbFgUPCheDAwUFFfrSsfLWW29ZQkKC+UVBkQIJHWep0XHfvXt3t+8D6d86rvSl9SioSa03lBo4Dx482IUZnr/++svNyqYhetoP2UXnloIhNRwP9uuvv7ovPZ9nn33WbrjhhjTXdeDAARdSzZs3L9nt6hGlr88//9xVxKW2X8I57hVyab06tzXLW1rvM3of896j0nsuAAB/ENAAAGKeN4xJnyLXrVvX/VyyZEn3KbVmLlIlwyOPPJKhChMFKprxSBcyHTp0cFUCmzdvDvmp/4ABA1zQcNNNN9lll13mLsJVsaNP4/U7ushs0aKF9enTx/7880+7/fbbXZWIpr5evHixW05Ne++88063nCoNMkuVBQsXLrR//vnHVflonQUKFMj0ehSQqKLnu+++cyGAflYFhCqCRCHByy+/7C4CdfGmC8EzzjgjU4+h8Evr1MW2giRV0HiVR7oQ1vN45ZVXXMChsELhlaqNgsMihW9egKYKHIVKet01hEt9iDRLlUK74Ma4uk+vqTzwwAN2ySWXJFsmM/tfr6+aM2u/S6dOndwxo3UoLHvttdfca6zKC90+bdq0VI8/Xbh36dLFNbTWMaJjQX2CdNH+1FNP2e+//+6O45YtW7rw0A86Lj744ANX8aEKGk3Zruog7WvveNMx0r59e3cslS5d2nr16uUqbVRxsmPHDhc+KGTR7yikU3AQHCh+9tlnSX2UtA/US0pVZzomdXw8//zzbr3Z1fhbYZNeO9H+13Gpc0LHmo5BHa8KabSdeu31npMaBT167joetJ+0X3RM6lhRcKXX+7777nP/Dhbuca/3G1XZKEQcO3ZsmgGN7he9nl4FIgAgthDQAABiforpJUuWuJ91kRtIFxm6sNUFv5oIa7hIRqoi1Hi3R48eSbelFkSo2uPdd9914Uzgsqr8aNasmasAuPzyy12ljS5OzzzzzKTlNFRCw6d0waT7dfGrcCiz/ve//7kLV1Fliz4lVwiiYRPaDg230ZCv9AwfPtxdhGsGrI8++sj9fiAN51CgogtQXUjqE3rvwjWjBg4c6MIZXeRrOzXsJZCGVWh/qDrn77//dsM+gi9Wn3jiiaSLVIUVeq2Cgw9towIYr2m0d0GrYMyjbYikWa4upL1wRsOSNOQk8BhQwKXg7uOPP3YXzqoKClwmkIIZhRoKvbyA0VtP69at3WuhZbSOaAQ0CiDTotclODj5+eef3cxges015C/wuBBV1ej56nloOJxC0+LFi6cICy666CK75ppr3DmrZQKfj35XVW+i41CPpdA18LF0bGsdOu+zmoYiecGagqXA81x0fuk9R6GNKoe07Xq98uUL/eeznnPw9O4KsPS+pMBGgaQCFoWsZcqUicpxr3Nfw5x0jGqoniq0NNwpVEioY1UUXCpgAwDEHnrQAAByRPWMLkR0oRRIF0vehU5GmwXr4jIwnEmLLqqCL9pEF9nnnHOO+1kX1urfERjOeBREeBUiqrQIh6o4VHHgDX3R8AZdWCrsUT8Jfdqv6g4FSboIC0VTkntBiC4yg8MZjy7MFZp425uZi2QFMwp+RBegweGMR9vrXaTrYlU9XjwapqEQShSuPPPMM6lWpeh4UIVCVtAFsCo9vFApVPCix9dFtBdmhKqKCKTAKzCc8ej41QW2aIhZRvuUpEXbnNaXNytYMPUHCgxnAuniXhf/Cnb0XIPDGY/CFYWWXn+WQOojpcokrzotMJzx1K5d21WcZTVVB6laR/R+EOo8l8KFC7vj0DvG0+pXpH45geFM4LHSr1+/pKDLC5yjddzr+NHtek7B+9zz6aefumo+YXgTAMQuAhoAQMzSBcf777/vflbFiqoiAuli0RvSoou/jFzcZqYXjLfuUAIvttNazrsI1RCocKkviPpaqL9FkSJFkt2ni65Zs2a5C0CFRMH9L0Sf/nsXZxpGkZbA5qGqDMkoVYdomJhek+ChRak9hi5WVdXj0cXvvn373M/qxRFJv51IaDuOHDnifk6rokXD7BTiiYY9pdawVuFaWsedqq284z29prdZRcNkFF6mxmvSrSqX9IIx7/Vdvnx50n4U9dnxhAoyAu/L6l48qhjSa5aRc0KVRV7FSVrnREZe41DvBZEe93rtVL0k6v0T2NsneHiTltUQOwBAbGKIEwAgZunCRQ14JbWeCbpdQ0PUw0EVGeopkRZvRp2M0Aw1aV2cZ2Y5VbFEQsNh9Cm7nqeGXuniV/1x1HvFq0pQ/xhV06iSpXnz5km/GxiCBM50lB4NQ8oo7zEUumjWmXAeI7Bxs6qD/BLY7Llx48ZpLqtQTI2CvaFFoYaXqEomeEhLoMAGw5EeJxI861JGhKpmCfX6KuxLryGyR8eC+hJ5vX+8oVcKWoPD1kDqP6O+RVkZVgWeE6pSi8Y5oeGGqQmsTAp+jaNx3CtIVFCrXjQKwtRPJzAQ0usmGsaYkSGRAAB/8A4NAIhZ3rAlVY2kdhGlC2T1eglcPi0Zvbj0hjekJvAiJ7iqJdRy0ZpGWQ1DmzRp4ipmFNjoold9eDQ0RFSxoCEigdM/axhWOAKHH6UnGo+hRrMeTb3sF4UKnvSa1QZuZ+DvZfQ4Cj6W/JpuOzBwzKrX19s/GWkAnJmQLxxZcU5k9P0i+DWOxnGv3j3e73rVMh79W+8HqkpKq3IJAOA/KmgAADFJJf9eHxBdFKk0Pz3q7aC+KV5gE0q8fXqsiy7NlKTqIX36rotgzQr0ww8/uBmggi8I9Sl7YDPdtGRm1iPvMTQzz/Tp0zP8e1nVRyZa/Jz2OjulNwOa9/qqMks9hiJ5fWNhnwaeE+rplFYVXLgBb3ZS42I1Z1ZfHTUs1/uAqnY03MmbQlzDRENVeAEAYgcBDQAgJmkWoHCGe6iKRjOd5DaaLlxNib2ePeqv4QU0gcNr9HP16tWj/vjeY+g1U0BWsGDBTK8jcGYZzczl18Vw4HAUNWVW6JQabWeo34s3en3VXFjTpYc7O5b3emqfRjKUKDBkDawUC+b1dQkl8JzQ6xvJjF+RitZxr2FOL7zwgnuNNGucZoBTTyoNexKaAwNA7IuvjxEBAHHDG66kCykN5UnvywsjdGGS1kVbPAvs6xFYpRDYdyfc2aTS4z2GPrHPTHPhQIHTnau3TmZFqzLDGy4m33zzTZrLqh+Qx8+L/Kzmvb7ql5KZoW+BvP2jnkle36TUhh9pxqTUaIrujPTb+e2331K9z3u/yMpzIruOe4+CV6/RszfMyfuu0Ce1maoAALGDgAYAEHPUGNibzlYXFZq9KL0vlfeLLuwWLlxo8SIzYVNg49PAoQwaluINa9IUyVnR50Q9MLyA5OWXXw5rHU2bNk3aTjV+DpwBKKP9eTyHDh0Kaxu87dCQkVD9PAJpZiwNLfMujuN5+IimkBZN5f7WW2+FtQ4NxfOk1S9KMxGlddxrqnaPmmWnRmFtWgGNN2xSU9RHozlzuCI97gN169bNfdcQx/nz5yfNvqXm4YHnBwAgNhHQAABijobpeBdo6U2B67n88suTAoKMNAvOKTRltXpIaNhCWtRHQxdkohlwAmdr0qfnmr7Xq4C444470rwI1HTlo0aNytR2qoeHN934tGnTbPjw4Wkur6Ec2ubgRrU33nij+1nNj7WdoaYMFt0eXIWhoSIFChRwP69du9YiGS7mNaVWUOjN0hRIx6eaMf/zzz/u397+jVddunSxypUru5+HDBlic+bMSXN5BQQ6DoJDHu1bee6555LNluX55Zdf7Omnn063wskboqTAUTObBdO5oLAjrWFSev1EQ7d69uyZZmWQHiO1x4pUpMd9IB233pApHZPe+8b1118f9e0GAEQfPWgAADHHa2qpnh5qbJkRFStWdDM6LVu2zPWveeqppzLcDDeW6YL1lltusUGDBrmw5uyzz3Y9XnRRp2oG3a9ZnLwLZoVUauIaPNzn3nvvdVPtavjR22+/7Roqq2eFhldoyIiqQX799VdXfaQmv/q0XT0sMuOZZ55xVTzqf/PEE0/YzJkz3awxGtqi9Wk4ii7K1Rdj7ty5bmpnbUOg++67z92/atUqF+BoCJEuXjXERn1tFOzoNdZU4qoK0PPyqOqlYcOGtnjxYlf5oioJ/V7+/PmTjqeM9onR9usiXwGMLuS13/R4CgY0bbECLG9ozFlnnWW9evWyeKbgS8eNjkGFFNoXCkX1pYoWHW/qLaMAUMePXrdbb73VVVYFrmPYsGGuymPPnj120UUXWf/+/V0FiX5fx6eCG68iScdRKHqde/To4YKcn3/+2VXZ3Xbbba6CSa+Xqka0rY0aNXLHQmq6d+/upqT+9NNPbcaMGe511Ho1tbpCTfWwUdNxvc6ff/65Cy41TXVWiOS4D6Rlr776anv11VeT+iPpPAgMbAEAsYuABgAQU3QhrFmIRBeD3lCTjNDFoi5iNFxBM0DpU/+cTsGTLjoVbmjoh75So/BBF63ecJRAujj++OOP3YWsvuvCVheF0ZjByaOLWl3oqhphwYIFrn9LWj1cihcvHnKqYr12unhWQPLjjz8mVTpkxO233+5ed+2zm266Kdl9AwcOTPXCNlQ/HwV9nTt3to0bN7rQ0AsOA2nmLFVspTcLUjxQ+KWqGAUsGkqoYFBfmXl9VRGnCpwHH3zQhYL6OZCmrNcQqhEjRqQa0IiOCQU6Ck90jAUHfQo2FHSceuqpqa5DoZD6V6mqR9U2aqYbvD2BFPhm1esc6XEfSK+PAhoP1TMAkHMQ0AAAYkrg8KSMDm8KXH7w4MFJ64mHgEZDbFauXOk+6VfVixqfaoiDhmPook7DGVSh0qpVK/fJelozwKhSRsN1evfu7YIeNSTVulQpoPs0NEoVNa1bt7a2bduGtb0KdhRsqKLnww8/dIGbZuRR1YVmy1G1hSobNONUy5YtUw2aVNWgSgxvHarO0LAirV8X39o+b0hVIFVl6Hd1gapqHjWcPXz4cFjPpW7duu6xtc80dbGqlRT+aZ+rIkH7+6qrroqJaaOzS4MGDVwgomGIqlTRsal9LNovGup2zjnnuJAwsPltoH79+rlqlZdeeslVuCioKVeunOuVpPtq1qzpApq06NhX/x9VMk2cONFVuig80fGl10TVXxnpuaIAWFU9qpxR1Y0qyNQDSxU+CmQUkOp407Gq56THzSqRHPfBQ8BUNaPXRvtAFTUAgJwhITExMXdOdQEAAICYpDBEFTJNmjRx4RgyTkMfFXIp+FJY9frrr/u9SQCADKJJMAAAABAnNOxM4YzccMMNfm8OACATCGgAAACAOKBZnl588UX3s4abZbTJOgAgNtCDBgAAAMihdu7cmfSl3kuaqttrmJ2b+iMBQDwgoAEAAAByKIUyanQc6Pzzz8+yKcEBAFmHgAYAAADI4TQjVaVKlezKK690U3RTPQMAOQ+zOAEAAAAAAPiMJsEAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhogGx28OBBW7NmjfsOIP5wjgPxj/MciH+c5/ADAQ3gg6NHj/q9CQCyEOc4EP84z4H4x3mO7EZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+y+f3BgAAAAA53X///Wf79u1jSl4gjs7pAgUK2K5du2zPnj1+bw5iUKFChaxo0aKWJ0/06l4IaAAAAIAIL+R27NhhxYoVs+OPP94SEhL83iQAUTivDx065EKaaF6AIz4cO3bMBfJ67y9TpkzUjhGONAAAACACqpxROFO4cGHCGQDIBRISEtx7vt779X9AtBDQAAAAABHQp6gqdQcA5C6FChWK6tBWAhoAAAAgQlTOAEDukxDl934CGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+y+f3BgAAAADxrNRbGy1WJfaoaLlJ7969bcKECbZixQqrWrWq5SRDhw61YcOG2WeffWZNmzZNur1UqVLWpEkTmzJliq/bFw/GjRtnffv2tZEjR9o111zj9+YgF6KCBgAAAEDY1q1b50KC4K8KFSrYeeedZ08++aTt3bs3osfQ+i699FLLbl9++WXI5xb45cd2xZKFCxfa//73P2vQoIFVrFjRypUrZ3Xq1LHOnTvbm2++aXv27PF7E4EcgwoaAAAAABE76aST7Oqrr3Y/Hzt2zHbs2GGzZs1yAc2cOXNs+vTpljdvXsuJzjjjDLvoootC3lelSpVs2Yabb77ZOnbsaJUqVbJYcODAAevfv7998MEHVqhQIVfVc/HFF1vBggVty5YttnjxYpsxY4Y99thj9vvvv1uePNQGAOkhoAEAAAAQserVq9u9996b7LZ///3X2rRpY8uWLXOVFs2bN7ecSNUhwc8tu5UpU8Z9xYpbb73VPvroI2vZsqW98sorVr58+ZAVSA888ID9999/BDRABnCWAAAAAMgSqqbw+qX8888/SbcvWLDA9fo488wz3bAYfV1wwQU2ZsyYkEOMZNGiRcmGFqlfSCD1YGnfvr2r5FFYcPrpp7uqk9WrV6fYLlX4vPrqq9a4cWM3JKdu3bqu0kdBQjSGe6nXzU8//eQqilRho+enbfv+++9T/I6qTQYOHGgNGza0E044wS1/1lln2e233267du1K1oNG69Y+yQhVMA0aNMjq1avnnuPJJ59s3bt3D7k/tL1a959//pmh/TJ//nwXzpx66qnudQgVzohee1VP5cuXL8VrquezZMkSt1/0nL3X2Xt93n33XVe1VLlyZTvxxBPd8aHbQsns8jt37nT795RTTnHLtmjRwvX2CbZmzRoXinXq1CnkejR8S6+t9hcQDVTQAAAQ4waP6WaxbEj3t/3eBAAx6tChQ65yJiEhwQUmnhdeeMFd/OrCVr1qFETMnj3bBgwYYL/99ps9/vjjbjlduCu8UHNcXXhfe+21SesIXN/999/vGrsed9xxridM2bJlbePGjS5I0PAk9UQJ9OCDD7rARxf0qgBRuKMg4vDhwzZ48OCIn7eCDq27fv361rNnT1u/fr198skndskll9jkyZNdMCX79+93y/31119uOy677DK3zxT0vP/++9avXz8rWbJkph9/+/btrnJp7dq1dv7557uhUVrnp59+ajNnznThyrnnnpvi9zK6X8aOHZtURVO4cOE0tyUwnAm0dOlSe/bZZ12Io+Bow4YNSWFLr169bOLEiVajRg276qqrLH/+/PbFF1+4/fHLL7+4YVOezC6vfa5jREGVgjA1WNaxcuONN7rnHFwV5oVM2r7g4WV6zH379lnXrl3TeUWAjCGgAQAAABAxBS6qivAumlUxowvbzZs326OPPuoqODzPPPOMVatWLdnvHzlyxFUqqILjlltucYGMZlrS0CIFNAprQg0zUm8bhTMKYT7//HMrXbp0snUGVu54NIuTgghVrMg999zjKlhee+01FwgVKFAg2fLfffdd0nML1rp16xQVFF9//bWr0HjooYeSbtOsQApKbrvtNvvqq6/cbQqQFJyogiV4/WqsrKAhHHpchTN33HGHC108CmdU1aPqpW+++SbFsKOM7heFK9KsWTML17x58+yll16y66+/Ptnt77zzjgs+rrvuOnv++eeT9oGCKwUh+h2FMArewlle4aDCmW7durmfPWpqrNcnmJZTxZdCKVUkBW+r9gkzPiFaCGgAAAAAREyBgIKUYKrGCO49ExzOeJUWPXr0cBfuGgYTWC2TljfeeMN9V6VHYDjjrVNDdYLdfffdSSGEaBiLqls0BbcqeE477bRky2toUqjhSaIKl+CARrfdeeedyW5r1aqV2w8KZbQuLzCQUFUoxYoVs3AomFCFjPbFXXfdley+Cy+80A3n0T5WE1/NshXOfvn777/d98BlPQrJfvjhh2S3qWJFQ60CqbooOJwRhUFFixa1p59+OllApSBEVTwK5BTIePsvs8u/99577r777rsv1dcnkKqadAxpKJcCKy/UWrVqlQvurrzySjv++ONTPA8gHAQ0AAAAACKmC1wFAx5VrigEUNVB27Ztkw3tUe+OF1980Q2h0XAgDRMJ7suSUd9++63rdaOhPBkVGI541EtEAvu+eBQcPffccxlev8KIUAGLhhUpAFi5cqXbBgUkCjm0bl3wK8zSkJuaNWu6YWHh+PXXX+3gwYNuaE6RIkVS3K/bFdAoRAkOaDK7X0LRa6pAJ5Cqn4IDGlXmBNPwI1W3qC+MqmGCqSJKFBaFs/zu3btdxVKtWrVC9s3xXp9ACn1UnaPXaO7cua5iSt5+++2kChsgWghoAAAAAESdKjhUfaGQQFUG6gOiPiyq8FBVgobT6KJdQ0u0rKbgVi8WXdxr9qeM0kW3LtAzM0tQ8eLFU9zmTQF+9OhRi1Soqp3A272wQ5U2mor8iSeecJUeGoIk6nWifjw33XRTph9b4ZeoD08oXjDhLRfOftG69VopSAuuhtKMTvoShRqPPPJIyO0ItX2JiYlueNymTZtCVmN5vEAvs8t7zzm1ipfUXjeFMAqANKRJAY0CsA8//NANwVMzYiBaCGgAAAAAZJlGjRq578uXL3ffp06d6sKZG264wVXRBFIFTnD1RXoUcmjITSxN5ewNAUrt9sDGv+q1o0BD268qGlW3jBo1yg1P0sxG6p+SGV7Ism3btjS3IVQYk1Fnn322C2jUmyXUcLWMCFUh5G2TKnnU5Dc94S6vJsqZed30HNVAeNq0aW6/6jVSOKQmyeFWOgGhxMY7GAAAAIC4pAtZUaWD16tGVF0TTM11Q1HwktoU2AqAVHGj2aJihYYwqclvas8veLiP9xx1e//+/e311193tykQyCxNfV2oUCEXiGkIUDBvPwXOgpVZXu8YNWdWNUm0KEDR8C4N0/KOm2guX6JECVf1oobWW7duzfDxJ5ppSrNZKUBUJY0qizT0CYgmAhoAAAAAWUYX8eL1O1HFiKg/TXBw4PX1CKbpszUVcijeMCD1utm5c2eKHiSpVUVkJQ1h0kxVgTSjlfqbaLYpr9fLTz/9FHL7vOoX9dbJLDXA1WxEO3bscNNYB9JU5toOTR99zjnnWLjUTFePoSmsFdaECju84WeZ9b///c8FSwqqgnsTiXoWqY9MuMtrSJ2G2WlYWSD1lwnuPxPo4osvdkPpXn75ZTfTlRou699ANDHECQAAAEBUp9kWhSVLlixxw5k0VOfhhx92t6thsJrGaopjBRS1a9d2TVxnzJjhetN8+umnKdat6ZwnTZrkZnZSlYmqF3TBXLduXXeh3K9fPzdcSo1ntQ71N1FfEg3B0TCUPn36RPTc0ppmW9UqmlI7uNmsZpfSVNaa4UnDgdR/R7M1jRgxImk5DZXRNNgaMqRpyNWLR4GCKme03l69eoW1ver7ohBBMxtpSmw1Z/a2QT2BFJpFOhxM01drHerFohmZ1HxY1TsKiBQ6qYJHr69mgtLtGaWGzMuWLXOVKjp+FAYpCNE6dZxon6rCSJUw4SyvIEczTSkM/Pnnn11wqPBPx5eaNOs4DEUzgimMeuqpp9y/aQ6MrEBAAwAAAGShxB7/NwtObptmW9UfFSpUsJ49e7qGt17ljGY30oxOCia++uorVzmjWXVGjx7tgpVQAY2m0BYFLmqmq+FOWrcCGhkyZIgLQrQO/b6GPKkZrkIDTSsdqbSm2dawmeCARj1LVL3y0EMPuXBADXY1y5RCqsCZkjTzlYIT7YfPPvvMVYAoXGjfvr0LErRfwqEmuKqUGT58uOv5o6E72k5Ndz1w4EBXxRMphU3a3127drWxY8e6cESvpZ6rQhm9Nqpu6tSpk3vsjFJPF/XkUfCmEEWBifaLjg1V/ui1DmzMm9nlNSW3ZppSiKWgRgGi9vObb77pKn5SC2hEAaECGh17bdq0iWDvAaElJCYm/t9gUADZQuN0169f7/5I0ScjAOJLVpzjg8fE9qd0Q7qHHpIA5JbzXMNRUpsxB7mLhtKomuSaa65JmskIOZNCQA2FUkWQV22k8E+VM3fffbfdf//9fm8iYkQ0/w+gBw0AAAAAAGlQk2sN69JQJ4Y3IaswxAkAAAAAgBBWr15tM2fOdEO41OtGPW8qVark92YhThHQAAAAAAAQgnoPPfroo66PjmaAUk8bIKsQ0AAAAABAFGimoMTERL83A1GkxsCavQnIDvSgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8Fk+vzcAAAAAiGfFul1gsWrv219YbtK7d2+bMGGCrVixwqpWrer35gBAMlTQAAAAAAjbunXrrFSpUim+KlSoYOedd549+eSTtnfv3ogeQ+u79NJLLbuNGzfOPfbQoUPDXmbTpk32yCOPWLNmzaxKlSpWtmxZq1mzpl199dXudw8dOpS07JdffhlyX1aqVMlatmxpI0eOtMOHD2fJcwXgPypoAAAAAETspJNOcqGDHDt2zHbs2GGzZs1yAc2cOXNs+vTpljdvXstNJk6caP369bMDBw7YGWecYZ07d7YSJUrY1q1bbcGCBTZz5kx7//33bfLkycl+T8tedNFF7uejR4/a33//7fbf/fffb0uXLrW3337bp2cEICsR0AAAAACIWPXq1e3ee+9Ndtu///5rbdq0sWXLltnChQutefPmllvMnj3bbr75ZitZsqSNHz/eWrRokex+hViff/65vfvuuyl+t0GDBin2ZWJioqtI+vTTT+3PP/+0atWqZflzAJC9GOIEAAAAIEsULFjQmjZt6n7+559/km5X9Ujfvn3tzDPPtIoVK7qvCy64wMaMGZPs970hP7Jo0aJkw340PCjQlClTrH379q6Sp3z58nb66ae7gGT16tUptkvhyKuvvmqNGze2cuXKWd26dV2lz3///ReV562ql7vuusutT88pOJyRhIQEa9euXciAJhQ950aNGrmfVZ0EIP5QQQMAAAAgS6i/iipnFEYoMPG88MILtmbNGheQqFfNrl27XMXJgAED7LfffrPHH3/cLaeeLQMHDrRhw4ZZ5cqV7dprr01aR+D6NPRH/VmOO+4416tGfV42btxo8+fPd8OF6tSpk2y7HnzwQRf4aBiRerso3FFAo/4ugwcPjvh5K1hSlcvZZ5+dbtWQQqyMUAXN8uXLrWjRonbyySdHvI0AYg8BDQAAAICIKXDxGuWqQkUVM+o9s3nzZnv00UeThQrPPPNMiiE6R44csU6dOrnKlltuucUFMpppSUN9FNAorAke9iPqzaJwRiGMhgyVLl062ToDK3c8msVJAc0JJ5zg/n3PPfdYw4YN7bXXXnOBUIECBSLaF4sXL3bfveqhzPruu++S9qWqcNSDZsaMGbZ//357/vnn3bApAPGHgAYAAABAxNauXeuClGCqUgmuIgnVPyVfvnzWo0cPmzdvnqtACayWScsbb7zhvqsCJjCc8dapIUzB7r777qRwRsqUKWOXXHKJm4JbFTynnXaaRUKBimjoVji+//579xVIVUhqwqyqIwDxiR40AAAAACLWqlUrNwzH+1JFjZrj/vTTT9a2bVv75ptvkpbds2ePPfHEE9akSRMXYnh9Zbp27eru37JlS4Yf99tvv3XDhM4///wM/46GPQXzwhQNt/KbgipvP+7cudN+/fVXV1mkWbG0nzV8CkD8oYIGAAAAQNSpmkVVKUWKFLErr7zSHnvsMfvkk09cX5rLLrvMDTOqV6+em3pay2oK7r/++stVsWj2p4zavXu3nXjiiZYnT8Y/ey5evHiK27wpwNXg1+OtM63mwd59gY/vVe1s2rTJIqXKGa1P+0n75bbbbrNnn33WRowYEfG6AcQWAhoAAAAAWcabeUgNbmXq1KkunLnhhhvsxRdfTLbsRx995AKazFA/Fg0pUlCSmZAmI0qUKOG+q4olNV6PG29ZOeecc5Jmq1ID46zalwDiC0OcAAAAAGQZDdPxGgd7vWpE1TXBvv7665DrUPCSWhWLQgtVlmi2qGjzetEsXbo01WW8+wL71qg5sPrsLFmyxIU0aclMtZC3L6M1HTiA2EJAAwAAACDLaIYlOe+889x3zc4UONORRwHL22+/HXIdmj5b02aHctNNN7nvgwYNSlHpolmcvIa94VDIcu6559rKlStt3LhxKe7/4osv3CxSmmHKe37ecKmnn37aBUvqJ6PpvkOZNm1aUt+d9GjolfrQiHr3AIg/DHECAAAAENVptkVhiSpINJxJDYAffvhhd7saBivQeOGFF1wD4dq1a7uZkzSNtHrTfPrppynW3axZM5s0aZKb2Ul9axSAXHzxxVa3bl278MILrV+/fm64lKbK1jrKli3r+r+oeuXWW2+1Pn36hP281OtF1T59+/Z1TY9VsaPH//HHH2327Nmux86oUaPcjFGBWrdu7W5Xz5grrrjCGjRo4GZgUv8bhUYKpFRNdMEFF6Q5zbZs377dPRftp0qVKtldd90V9vMBELsIaAAAAIAstPftLyw3TrOtmZUqVKhgPXv2tAEDBiRVzhQrVswmT55sDz74oH311VcuqKhVq5aNHj3aBSuhAhpNoS0KKVSxoiE+WrcCGhkyZIgLP7QO/b6GDZUvX94NNWrRokVEz+uUU05x034rANIsSnoMPb4aE6v6RQFM9erVQ/5up06dXLXLa6+9ZnPnzrX33nvP9u/f75oiK2hS0KKps9ObZrtQoUJWtWpV91jal8HTiQOIDwmJiYn/NxgUQLY4ePCgrV+/3v2Rov9sAcSXrDjHB4/pZrFsSPfQQxKA3HKeb9u2zQULAOKHQjjNOFagQIGoN59GfNkWxf8DONIAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAECu0Lt3bytVqpStW7cuS9Y/btw4t359B8J1+umnu69AHFu5Qz6/NwAAAACIZ/vmtrVYVbTl9IjXobCjfv36KW4vUqSIVatWzS6//HK79dZbrVixYmE/hi5MmzRpYlOmTLHskNpzSk3lypXthx9+yNJtQnLr16+3559/3ubNm2cbN260fPnyWZkyZaxWrVp23nnnWa9evaxo0aJ+byaQKQQ0AAAAACJ20kkn2dVXX+1+PnbsmO3YscNmzZplTz75pM2ZM8emT59uefPmtZygZMmSNnDgwBS3Dxs2zEqUKOEqcYKXR/ZRGHbZZZfZrl277JxzzrHWrVu7AHDDhg321Vdf2cyZM10wWL16dYsXer6NGze28uXL+70pyEIENAAAAAAipovhe++9N9lt//77r7Vp08aWLVtmCxcutObNm1tOoIqd4OfiBTQKY0Ldh+xz//33u3Dm1VdftS5duqS4f+nSpVa6dGmLJzruCALjX47pQbN8+XLr1KmTValSxSpUqOBS0kmTJoW9vsTERKtdu7Z78+3YsWNUtxUAAACAWcGCBa1p06bu53/++Sfp9gULFljfvn3tzDPPtIoVK7qvCy64wMaMGZPs97/88kv397osWrTI/ex9Bffi0PCn9u3bu0oeVRmoh8fNN99sq1evTrFdqvDRxb0qEsqVK2d169Z1lT7//fdf1J773Llz7cILL7QTTzzRbdMtt9ySbB8EmjZtmquQ0LXOCSec4IZzvfTSS3bkyJEUQ6/03FXB88svv1jnzp3d71StWtV69uzpqpa8gEIVJBp6pfv69etn+/btC7lvhw4dal9//bVdeumlVqlSJbe+G264wdasWZNiO//44w/r06eP1atXz+03DWHTtg4aNMjt00B//fWXG9qma66yZctanTp13L81NCmYHlvbcvjwYbc9eu20/kaNGtnrr7+eYnkFfgorQoUzctZZZyUdN553333XrrnmGrduHR/a9g4dOrhjMZj2jQKep556ypYsWeJeG+2bGjVq2J133mkHDhxwy82YMcMFkLo+PeWUU+zBBx9M8ZoF9o7RMdqyZUt3TGhdOgf+/vtvy4jUetDoNu0/rUfHmIJSHUO6XtbzCGXVqlXu2tp7vfWzzpOs7tGEOKmg0UmjEKVQoULuJFL52uTJk61Hjx6ujE1vOJl199132+7du7NkewEAAACYHTp0yFXOJCQkJGt6+sILL7gAQAGJLm5VDTF79mwbMGCA/fbbb/b444+75XTxqKFGqlxR2HDttdcmrSNwfaqoGDlypB133HHuYlWBgPqSzJ8/38444wwXDgTShbQCn4suushdMOvCWQGNAoLBgwdH/LwVuGiYTdu2bV1YoGE37733nv35559uqFcgBTEPPPCA2/arrrrK9e7R7+s2BSdjx451+y+QLqAV/jRo0MC6du1q3333nX300UfuOT/00EPumkmBV7du3dz+Vzih8En7KNg333xjzz33nLVq1coFWj/99JN9/vnn7rH1mijIkM2bN7t9tX//fvfYegyFPnod33jjDXvsscdcHxj5/fff3XPfvn27+66QRgGAnouev75OPvnkFNuikEkfzCtc0HA4fSB/1113Wf78+d1z8Sg82bp1q9smhR0Zvf5TEKf9cvzxx9umTZts6tSpduWVV7r9o+MmmLZF+0zPu3v37i7w0HPds2ePe14Kqy655BJ3HOv1HjFihOt7E2p4nK5fFdpdccUVbhsUMils0X7W7cGBUmbo/NH2aPidQjvt948//thdQ3/xxRfJjn8ND9M267Vr166dC4p0/Oj3tX/gr5gPaJRA9u/f3/LkyePeOJXWyj333OPeRIYMGeIOcr15Z9Snn35qH374oUtEdaICAAAAiIwu1FX9IKqmULWIes/oIvrRRx9NdkH+zDPPJF34B/7dr0/yVdmiSgCv+kPDiRTQ6O/9UEOLdLGvi2hdhCpYCBzaonWGqlpZsWKFC2hUaeBdWzRs2NBee+01d3FdoECBiPaFtknbov4ocvToUXfNorBEF+a6oJe1a9faww8/7AIlNbtVRYMoJFJwoOuf999/P0WliAIf7WuvF472ty7MFRJoWVWdeIGDQicFAlqPwhtVpgTSa6SARh9+e9566y27/fbb3b7Q73kBg4KAwMf17Ny5MymcEf2uQgI18VWw4dF2KXC544473PqCKTTRc1PQIDoOzj33XBdiBQY02jd6zRUq3HjjjW4ZhQsKt1KzePHiFMfcli1brEWLFi6wCxXQ6DVRqKQKmsB9qWtJ7TcFPDpuRMemftbxq+enUCmQqm0Uouka1vPII4+4fa9AUtem4VJFzE033WTDhw93182iyrXbbrvNRo8e7R7Do2NdAZNu1/nmiXQbkEuGOKl6Rm9cSpO9cEZU0qYDX6n8hAkTMrw+vVGoLE1vYEp+AQAAAEROf7MrSNGXLhR1Ma7b1HcmuPdM8IWy6AJfIYHCjNSGZoSiigZRBUxw3xGtMziQEH1I64Uzotl/VFWgC1dV8ERK1y5eOCOqBtHwGq8qw6MLfYVIGvrjhTPe0DAFNzJ+/PgU6/eGTHlUYaOKFtE1U2DYoKBA4ZAe5+eff06xLgVngeGH6N+qrFDgo+unQIULF06xDlX/eDSESa+fZlMKXq/ClFNPPdVd42kkRDAFJV44Ixo2dPbZZ7vXRK+NRwGWqqn0WAqddF2nQE/HmUIGtbMIFuqY0zGgKhIN3dKQrGAavqXjInhfKhBTOOSFM1K8eHFXkaWwSpVMwRTsBIYzoutSXdcqBItkeJ2qdnS8eOGMaP/o+A883vQcVbGjMCswnBFVr0VSxYNcEtAoZRaVlQXzDnCl3xmlNFdvkPqPAwAAAEB06G9zXRh7X6qoUbigITO6mNVQGo8utp944gl3Aaz+M15fGQ3X8SobMurbb791gcb555+f4d/RsKdg2g5RlUikMrr+lStXuu+htl1Do9TiIdT03aeddlqKYU9e4BQ49Cv4vlD7VQFI4IW96N+6XUGEqjNEr6GCAFXAKEhTZYmGbAXztlevbfA2ar2aAjtwuXD2m/bLyy+/7NahKh31zKlZs6arjFIliB47eNv0b1WU6DHUg8Y75lQ1ldq+CTXkJ9z9rCqfYGrdofWo9UaofZlRCtOCp7H3wsnA/ea9loHhoUevbajnhOwV80OclGZ6B10wnVg6EEM1sApFyeRnn32W1GApnDffgwcPZvp3kPMd/erKqK6vgta53ix5q7bw5T3vkyitCUCkVNkZ+D034P9G5PbzXJ98R7O5bHaKxnZ7zWH1PXB9+ntbF/VeH0m1JlBPEe03DRnRxbSqPTQ1typf9CGqKiJUHa/3lVDbFuo2Xdx6fUgy+nx0DRG8rBdSqNIkvfWkdr+3LzK6fq8qRD1RQq1TQ580RMy7z1u/qjVSW39aj619H7wuPUZqjy0K23S/KlQ0TEcfdGv6dG/CFlW5aHiPhh2J1+cztefkVTRpueD7Q227NzV7qNdFr7tCPS/YU8WW+pNqmJS2yWuoq+tF9bXR/lYYpkoX7UPtF33Yr6/AYy7wdQw+rrN6PwcK/Hdq51lqx4O371SR5t3nvTaqGEtrW0I9BlKnfZXa30J6/4urgMY7iAJL3YIPxow0+9Ubm8ZQqtww1PjCjNK4SB3kyF0UqMSyUN3wAfhLzQtzC96DkNvPc/UryamhbDS221uHLupCrc9rU6BGpLpfvUcUzmgIxrPPPpts2U8++cQFNPp7O3hduggKtX5dJ2gGG10gBVeCBPP+jtd6gtfl3ac+I2ntl9Sep3gz+Oh78DJar/c43n2qWhANidGHz8GPs23bNne9ExwKhto/odaf1nZ5y6vaI9Tz8apA1NfFu1/DodS7RL+r6h/1YdEQMzX3VSCjqh9vCFR669VygSFn4PPL6GsWqtpG/VZU/aNhVN7y6mGjAETfdT0YvD0KaAJfd2/fBP+c2r4M3tbAdXnL63o01PZ77yOB+8MLYwKXT+txUzs3gtfjvTZ6zLS2JSP7Gv+P3ntCZRIKyDSrVlwFNNGicjaNGYx0aJO6zCP3UbVLLNMnGgBig/6g0R84+kM70iaTOQXvQcjt57mqstM63/9vQt7YFI33KW8dGs4San2a9ce7iNT9Xu8RVdEEL68Gut6FTeB9Cl50sRlq/ZqKWRUd+l1vSu/UeNUYWk/wurz7dM2Q1n5J7XmK1yhX34OX8ZrGBj63+vXru0azmhY7eNiJno8u/BR6eMt734P3T2rrT2u7vOU19Ey3B4Zbeq00dEzPVUOCgtenf2vIjr5UQaOmwZqJSNUpmllKND21HiNwmJNeQzXrlcD1eo8dar+m9ZqF4vXDCXydvP4y6jcTuA5tj3fMBb7ugQ1+g59DWq9xqGPIW16vcfDye/futR9//NGFcNqP3n7wHi9w+bQeV78Xat8Er8cbQqbXNnh5nafelPQZ3df4f1UywQFruGI+oPEqZ1KrklGZWnrNjDT2VW/ab7/9tivnikRmS5QQH6I1FCmrcFwCsUd/2OSWczO3PE8gtfNcf4+mV7kRq6Kx3d5FoL6HWp96hYj6guh+b/ZVXcAHNmBV78l33nkn5Lp00a1K9lDr79Wrl/tbX0NaNOtRYMNabxan4EbBobY1vecRKLX701pHqPs0vEtNbbWPNImJN1RLIaBm+BFVGgVfuIfahsw+tnebpsTWNNOBszjpukm3ayiQt+++//57Vw0QPLLBayKsc8F7fRWUqVGwhhh5w4+82aF+/fVXa9asWchZeNPa74Hbrg/dr7vuumSNlb3ARVO4iwIvb3nvsRSStGnTJml5VXCpR1Jq+ybU/gx3P2vKd80KFdgoWNU+Cnh1DAfOghVqf6R3fKa177z7NCua9otCMlWreY2lRdVFanCc1mMgNO2raP0tFPMBjdd7Rr1ogptG6ZMLpY6B3bND8ZpvBXcR96g0TyGPmkB5TYkBAAAAhDfNtuhiTyGMhjPpb21vViL1pdEFsy6kdXFcu3ZtN0uP+puoqubTTz9NsW5d0KvnicIKDZlSpcLFF1/s/n7XDD7qO/Liiy+66wKtQ700FOhomItmSOrTp4/FIs3GpP3ywAMPuACrffv2bkiRpunWPlGApeAmKykwUCsIzdik10KviR5fH2wHjj547733bMyYMa7Jr7ZbVR+aFUrhmEIxBSaBwYde5/79+7t1aUYnrXfatGluKFTw0LbM0hTbmrVL1Tq6RtTjK4hTKKRgST2NHnvssaTlFT55YZF65eh+VQ7p2FQIpWMvq+lxNAW6ZoHS8a/KHW2v9uX9999v2UWvqVp+KBTScEOFbtoP2h69turfQzjjn5gPaPRGpRNYJXMdO3ZMEax4y6RFZYH79qWsgdBtH3/8sRurqFmighNYAAAAAJmbZtujmZXUHkD9STSFrzccUs1VdWGoKZV1MagPSHUBr94mClZCBTS6GBcFLrrg1xAcrdubZUcNiBs3buzWod//999/3ZADVXK0aNHCYpkCJF0kK3T44IMPXPWMPqRWwKCptINnQoq2M888083MpMcbNWqUC790Af/oo48mm5pavVu0XxW6aYiMtlOvgabOVjuJwOGuGq6jahEdD7pmU/ijYEYhjsKgUNUzmaGwSMGQesco9FEVj443VYgorOvbt2+yadQ1lEzXfZrh6fPPP0+apUrHkn4/OwKayy+/3AVEzzzzjKv0Uj8YBY6aJjw7p7f2htWpQmv27Nnu+FJVjfaFV7Wl8A3+SEhMTPy/zkExSmWJetNQUyWdhF6TMZWCKe3VeEKlfToZvSZPGg6lN2TNKZ+WdevWuQNU6/noo48snpV6a6PFssQe/zd9XqzaN7etxbKiLaf7vQkA/n/qF6CmufpDNVrlroPHhK4AjRVDur/t9yYA2Sr4PFcjV2/2EyCnUPWGerIoMNHwMFjIxrsayhhJRYkqdxQYKYALrDKKNWpwrGokvb+pegsZF83/A2K+dklj8UaMGOFOECW5KpNTCZgaUKl8bfDgwUnhjCj1U8WMklEAAAAAAPD/CiB27NiR4nb1w1HwHMmMx8gFQ5y8MacqudKYVo091bRlderUcWFMYGMjAAAAAAAQmnq4qteQhv5pKJ2urTVkbfny5W5Y2KBBg/zexFwtRwQ03vR5EydOTHe5V155xX1lhCpvEhMTo7B1AAAAAADENjWhvuGGG1w/J/WA0pAmtQdRI+W77747We8eZL8cE9AAAAAAAKJDDZT5sDrrqe9MLPWeUU8dNSpGbIr5HjQAAAAAAADxjoAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAQK7Qu3dvK1WqlK1bty7q6x43bpxbt74DQDjyhfVbAAAAADJk8JhuFquGdH874nUo7Khfv36K24sUKWLVqlWzyy+/3G699VYrVqxY2I+h4KNJkyY2ZcoUy05ffvmltWvXznr06GHPPfdctjzmpZdeaosWLbIVK1ZY1apVw1pm/vz59u6779qSJUts27ZtlidPHqtUqZKdd955dv3119uZZ56ZLLSaMGFCst/PmzevlSlTxho1amT9+vVzvwcg6xHQAAAAAIjYSSedZFdffbX7+dixY7Zjxw6bNWuWPfnkkzZnzhybPn26u/CPV5dddpk1btzYypcv79s2HDhwwIVhH330kQvImjdvbieffLK77/fff7cPP/zQxowZY6+++qp16dIl2e/ecMMNVqFCBffzwYMH7ZdffnGv34wZM2zs2LF2ySWX+PKcgNyEgAYAAABAxKpXr2733ntvstv+/fdfa9OmjS1btswWLlzoAoN4VbJkSfflJ1W7KJxp0aKFjRo1ysqVK5fs/sTERFcJtGvXrhS/27VrVxcwBfrkk0+se/fu9uKLLxLQANmAHjQAAAAAskTBggWtadOm7ud//vkn6fYFCxZY37593VCbihUruq8LLrjAVXcEDzHS8CbRkB797H0F93rR8Kf27du7Sh5VsZx++ul288032+rVq1Nslyp8VEWiQEIhRt26dV2lz3///Rf1HjS6TUOS/v77b7vllltckHXCCSdY69at3fOLFu3TiRMnuooZbUNwOONtyyOPPOJCl4xo1apVitcOQNahggYAAABAljh06JCrnElISHCBieeFF16wNWvWuIBEw2pU0TF79mwbMGCA/fbbb/b444+75apUqWIDBw60YcOGWeXKle3aa69NWkfg+u6//34bOXKkHXfccS4MKVu2rG3cuNH1YjnjjDOsTp06ybbrwQcfdIHPRRddZC1btnThjgKaw4cP2+DBg6O+H/T82rZtayVKlLDOnTvb9u3b7eOPP7aOHTvaF198kWL7wqFhSF4VjYY3pRecZcTcuXPd91A9hgBEHwENAAAAgIgpcBk6dGhShYqqLtR7ZvPmzfboo48m9UKRZ555xjUQDnTkyBHr1KmTq2xRpYkCGTXA1bApBTQKa4KHUIl62yicUcjx+eefW+nSpZOtM1T1h5rrKqBRJYvcc8891rBhQ3vttddcIFSgQIGo7ptVq1bZTTfdZMOHD3cNe0WVRbfddpuNHj06Kg2IFy9e7L43a9YsrN9/5513XEjm9aBRUKYeNApnsiK0ApASAQ0AAACAiK1du9YFKcFUpRLceyY4nJF8+fK52ZLmzZvnhv4EVsuk5Y033nDfVQETGM546ww11Ofuu+9OCmdEMxapx4pmM1Iwcdppp1k0FS1a1B5++OGkcEb0/O644w5bvnx5VB5DQ6jEa/SbWZr1KZj2y1VXXWUnnnhixNsHIH30oAEAAAAQMfUrURNa70sVNePHj7effvrJDe/55ptvkpbds2ePPfHEE27qbPWf8frKqFGtbNmyJcOP++2337ohO+eff36Gf0fDnoJpOyRUA91I1ahRI8U04154lBWPFw5Vy3ivncIevV7q6aPqGQVnALIeFTQAAAAAok7VLKpKUT+UK6+80h577DE3K5D60mhKag0zqlevnuvJomU1Bfdff/3lqlg0+1NG7d6921V4BFanpKd48eIpbvOmAD969GiG1xPJ43mPGfx43vPQMLHUeM2MA5+zwh7tPw0pC1WhlBka4qUhaU8//bQbnvXZZ5+5IVTnnHNOROsFkDYqaAAAAABkmUaNGrnv3lCeqVOnunDmhhtucDMPPfvss/bAAw+4/jKa2SizNLW1Kj4imYEplqiRcHozJ3n3ecuKF56oMXJWvn4Asg4BDQAAAIAsoyEzgRUh6lUjqq4J9vXXX4dchypFUgtgFCCo4kazRcUDb0anpUuXphrO/PHHH1apUiUXTnmuv/569/2ll16yAwcOpPkYmalQ8l6/eAnAgFhGQAMAAAAgy2iGJTnvvPPcd83OFDjrkEcBy9tvvx1yHZo+W9Nmh6LZkWTQoEG2c+fOZPdpFieveW5OcfXVV7tA6sUXX0zxnBWSqCeMnleXLl2S3afZm9TQV02OVZ20bdu2kMPBNKPWmDFjMrQt69atc8ObRP2CAGQtetAAAAAAiOo026KwZMmSJW44kxoAaxYjUcNgTZn9wgsvuAbCtWvXdqHCjBkzXG+aTz/9NMW6FT5MmjTJzXykvjXq3XLxxRdb3bp17cILL7R+/fq5QENTZWsdZcuWtU2bNrkhVLfeeqv16dMnouemWaV69+4d8r5zzz03qblxNJxyyik2ZMgQN+xLw5b0PLW/FK588cUX9uuvv9pZZ51ld955Z4rf1T5QpdJHH33kpsdu0aKF6yWj21R1o/2hBs2jRo1Kc5ptBUDqZzNlyhTbv3+/de/e3Ro0aBC15wggNAIaAAAAIAsN6R66KiTep9nWzEqa8rlnz542YMCApMoZzWY0efJke/DBB+2rr75ylTO1atWy0aNHu2AlVECjKbRFAcP06dNdJYnWrYBGFGg0btzYrUO/ryE85cuXt6ZNm7qQIlK///67+0pNNAMa6du3r51++ukuSFFPmR07drhmywpv1Gy5V69ebv8GK1y4sJt2XBU0Y8eOdQHZnDlzkmap0qxM3bp1S+ork9o02wkJCW74lAIvrUuNnAFkvYTExMTU24MjbpR6K3RJaKxI7PF/0xrGqn1z21osK9pyut+bAOD/d/DgQVu/fr27EClUqFBU1jl4TDeLZbnl4hNI7TzXUBIFCwDih0JAzTimGa0yM0MYcp9tUfw/gCMNAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAJBTA5rvv/8+ulsCAAAAAACQS4Ud0LRs2dKaN29ub775pu3evTu6WwUAAAAAAJCLhB3QFC5c2FauXGl33XWX1a5d2/r06WOLFy+O7tYBAAAAAADkAmEHNL/88os9++yzVr9+fdu/f79NmDDBLrnkEjvnnHPs5Zdftn/++Se6WwoAAAAAABCnwg5oihUrZj169LB58+bZwoUL7aabbrISJUq44OaBBx6wOnXqWM+ePW3+/PnR3WIAAAAAAIA4E5VZnE477TR76qmnXDjz6quv2rnnnmv//vuvffzxx9a+fXtr0KCBPffcc7Z169ZoPBwAAAAAAEBcieo02wULFrTOnTvblClTbPny5davXz/LmzevrVu3zoYMGWJ169a166+/3hYtWhTNhwUAAAAAAMjR8mXFSv/66y8bP368q6A5cuSIu61IkSJ28OBBF95MnTrVLrroInvttdesePHiWbEJAAAAQEwYPXq0xapevXpZbtK7d2/XO3PFihVWtWpVixWXXnqp+xA7MTHR4kG8PR9kvy+//NLatWtnAwcOtHvvvTfXHFtRq6A5fPiwTZo0KWlI0zPPPGMbN260008/3TUT1vAnzfp09913u141M2bMsEceeSRaDw8AAADAB6qWL1WqVIqvChUq2HnnnWdPPvmk7d27N6LH0Pp0YeYn9dZU301d35xwwgnu+Z111lk2YMAA++abbywnGzdunNvH+h5o6NChIV/b1L60PLKXrquvvvpqO/nkk+3444+36tWru5Yjffv2dcURyGUVND/99JO988479sEHH9jOnTvt2LFjrlqmQ4cOrolww4YNkzUWvu++++zaa691b9Y6YJ5++ulINwEAAACAz0466SR3oSi6JtixY4fNmjXLBTRz5syx6dOnu/YHOc2BAwfs1ltvtY8++shd5zRv3txdDMvvv/9uH374oY0ZM8b14uzSpYvFk/PPPz/FbT/88IMbEdGkSZMU94daHllH55a+dFxqhEqVKlXcCJaff/7ZFU/88ccfvgeb0fbqq6+6czJehR3QKJR599137dtvv016E9bMTQpl9MasKpnUVKtWzfWjyelJMwAgPuyb2zaq66tgZkfXm+2L2hrLR21NAJBV9Ml94FAE0cQhbdq0sWXLlrmZXxVu5DTqq6lwpkWLFjZq1CgrV65csvs11EITouzatcviTdOmTd1XIFXZKKBRGBP8eiN7K9eGDx9ulSpVckHoiSeemOx+hRjxeL1duXJli2dhD3Hq37+/e8ELFSrkkuKZM2e6sWDedNvp0YGkLwAAAADxSZOIeBf4//zzT9LtCxYscEMwzjzzTKtYsaL7uuCCC1wlSnAfCg2dEV1rBA6nCR6Oo+p8tVtQJU/58uXdUKSbb77ZVq9enWK79OGyPolv3LixC1z04bEqEf77779ky2k7J06c6Cpm9HjB4YxoW9S6oXv37in6cqrypnbt2la2bFn3Ybb+vX79+jTbRmiYkLZdj9WoUSN7/fXXQy67b98+e+KJJ9xz0PPVh+D6oHzx4sUplvWGKml/6nk0a9bMXdCrukJ9efRaiL4H7uNIZcfzGTt2rBudoWFn9erVc6+r9xq/+OKL7hjT+jSyQ/2Hgun5a11//vmnvfDCC245LX/GGWe4th16DsE+/fRTu+SSS9xxoWVr1aplV1xxhbs92LRp0+yyyy5z1S3aRlUevfTSS0m9WoOHCmp71qxZY9ddd53rk6ShdFq3KpcCaVIeHa9ad3A4I4ULF04Rrm3evNnt49atW7tt12ui1+bOO++0bdu2pblvtC/1+uk5nH322S60lEOHDrkJgbQe7Qu9FgqMgulY07rUl/bhhx9255yW1zBBBZ96vTLCW09qQ/Tmzp1rF154odsnei+45ZZbkr33BHrrrbfsnHPOcduhmakffPBBt31+DqkMu4JGB6HehBTOlCxZMtO//+abb4b70AAAAAByAF28qXImISHBXcB5dCGsi1BdjOsCVNUns2fPdv1cfvvtN3v88cfdcrqoVZPQYcOGuU/O1SrBE7i++++/30aOHGnHHXecu7BSIKJ+mOobowtthSOBdCGmwEfDQlq2bOnCHQU0uhgfPHhw0nK6+PeqaDSMJL0wyqOhT23btrXt27e77wppFBRpfRrqpS9vmFSgnj17ugtvXUBrOJiGqdx1112WP39+69atW9Jyuoi8/PLL3WiG+vXruwvpv//+2y2v4WRvvPGGXXnllSnWr4tshRoKF/S89RjqH6r9r6oY3R64XyOV1c/nlVdecceXtlthxGeffWaDBg1yr5X6n06ePNm9xqrcUqCg9eqYUkgSTL+3ZMkSF/IVLVrUvUZPPfWUGy6kkSMebYsCDQUVCkdKly5tW7dudc9Tx5HCFI+CmAceeMAdl1dddZXbLgU2uu3rr792x4POjeBgT/tL19uaAXnt2rXutVHD3KVLlyaFhHpc0XmUUV999ZU7TxTQKWzR66D9pOek/azzJdS1vdqU6LXRsazXUftShRkKMjTxj/aR9rNeRwWaOk+1rQpIgilDUNik5yN6zXSO63k//v+f9+HSvlXhiLZTwY+e73vvvecCJr2egfRYen21P7t27er2hY63X3/91fwUdkCjAwoAAAAAvAtFr0msPg3Xp9a66NOn9o8++miyQEKVCaqQCKSKgk6dOrkKCH3qrUBGFQQaRqOARhfWoYbU6MJLF50KYT7//POkC1dvnaE+PdcsTgpodJEt99xzj6uc0MWmLhYLFCjgbveqN3RBmxm33367C2eef/75ZJU1qh5RQHHHHXe48CDYpk2b3EWlNyJB+0ENX3WhHxhoKODSBbMqTFR94F3k/+9//3NDyjTaoVWrVilmzNVzVhCmaoFAXkCjcEuVG9GS1c9H16SqcvKOJQVpeh0VgOjCW4+txrlyzTXXuOBDIVWogEajQxT2qJrLC/0UCilAUGWMF7yo1YeODwVdCgIDBR5rClZUKaJl5s2blzR6RAGg1qsw5/3330/Rt0ivkX5PYaXnsccec71bVSGiY0sUsGidCiQ6d+7sesDqtho1aqQIfTw6jjV5j3rDBlJlkcIrzTin4zOYQgttl7cvdYzo9bjxxhvdeaf9rFBLdLvanig80xCsYOqLo+W9IEjntF6Xl19+2YVYCgzDpfcCvQeoKkaOHj3qXje9rhpmqUDYC1A1kZHCYYVS3uuobdHxFhezOAEAAADIvXRBqiBFX7owUxih21S9ENx7JjickXz58rkLO11U6eI3o/Tpv6gCJjCc8dYZaliSZpb1whkpU6aMq8LYs2ePq+DxqIpDdCGXURrCpO1XBURgCCG6oD311FNdqLBhw4YUv6vKnsB2EaeccoobTqJt0rYFXlDrE/+HHnoo2cW4qk8URChwCTWDj7YnOJzJSln9fBT4BB5LCix0cb57925X5eIFCqKhTlp21apVIbdV6/LCGVEI4wWC48ePT7astlVfwQKPPzWPVkCoYW2BrT1UaaUAJtR6RaHkbbfdluy2G264wX1XlY5HIYsCG1VnaSYnhVl6jvp9BTYKloIpiAgOZ0QhkV6nL774IuS+Cd6XCoK0L/W6KAzzwhlRJZT2TWr7WedeYJWOflYopFB3fIj9kRkKeLxwRlTto+MneN+pykfvMxrSFxiyKQAMFVDliIBGqZfKktIbqqQ3TC2ncjEAAAAA8UmfnKthrvelihpdcGnWVw05CGxYqotz9cJQJYMuir2eJxpqIFu2bMnw46ryQhe9mZlBSMOegnkX55E2+/V6hei5BVcy5MmTx/XoCFwus9ul8EFDNtSUOTBQ8Hh9R0KtXxfW2Smrn0+o4Vhe8JbafakdW6rsCabAQyFf4GN37NjR9cvR8qqGUQWLnkMwDR2SUMelht+ol2tqz0nHSUaOTQVYui5XQKOgREOuFCzp3wp11IMpuLeLKrdUbaNKGwWTOu80BEvPIbV9k5n9rFBEoUdm9rN32w8h9kdmZPS89sKjUNuiADFHDnFSyqkyJzXESm8nKYXS2C+/nywAAACA7KFqAlWlqO+GhnRomMYnn3zi+tLoQlLDjNTUVZ/2a1ld2KkPha4zNPtTRunCUg1Bgy9q0xI8VEa8KcD1ybpH1TfaJg3TClX1E4pXGRI8/MWjhqSBywUKNdlK8HZFsv7UfierZPXzSet1TO2+4Oa8nlCVVlpex2ZgAKNhVAo0VKigoVoaMqUQR41pFTp6x0laz0vBnW7XcZWR56T1Bx+bgevSdbZ3ra1ARtVGGrL0wQcfuGIJr9+LtlWhkqph1INIlWEKikRDklI779Laz6m9xqGaK6e2n73bdocIujIjo+e199oEVgWltX05IqBRRYx2gMb4pUUprV60UN23AQAAAMQ3r2rDG2KgXicKZ/QJvy4YA6n5aKiZdtKiIRIaiqQZbTIT0mSEhksooFGfiowGNN5FYqhZcQKHTYW6mMzq9afWm8RPWb2/MkqPoyFYgXRRr74ygRft2oc6dvWl+1TBouNWDWZVNaYiBoUCgc9L/ZMCKUTR7VnxnLR9CkBVwaOhhhpOp4BGwZSa4qryJbh/jrZnxIgRlh20n4OnyvZe4xIZmA06Grz9rj5Rwa+Nty1+CfsdTGmfxrdlhJ60GkQBAAAAyF003Em8oRbqSyOqrsnoRCQKXoKnwA4MgPTJvxqBRptm0RFVShw4cCDNZb3qA2/Ihy7cg4eX6N+6PXC5zNJFrMIihQGhrrG8/ZCZ9YeqMsguWfF8whHq2NOwPAUbqT22qmsUhmi6ZjXg1WxG3qxKqg4L3P7g9WrGo6x8TsG9Znbs2OEqVNQoN7iq57vvvkv3+M7K/ezddnoWv8YeTfEtoYpINPtUjqyg0ZtLam+SoZZNrcQJkGLdLrBYtq/b/5X+AQAAIHM0w5J4vVe8T891cXTxxRcnLacL2bfffjvkOjSkRNNmh6LpftUHRNMka2iHlg2exSncYQu66FbjUTUVVcWEhoEEX9zqolezNWkojhq16vmpb4qqFDQ9s9dXR8aMGeNm0dF6AxvHZpYan2rGLLWb0KxXXmWMemuo749CD83IlFHePkttH2e1aD+fcOhxtR1ezxINxfNmJQuc3l2vq/rKBFYj6Vp3586dyaZb14xkqmDR8a/ZqTQMz1uvmiEHrzez1HtJsytpWnBvmJJHlSGabSqwz4qO28KFC7vqtf379ydNG68AVbOYZRdV8WhKbq9RsHrDaIYq7c9rI9gfmaE+Qt5royGW6sUj6i2kGeZyZECjA1cHhHZoqLnSPbpfywWXMQEAAACIz2m2RResaougC0I1IvVmrlHDYFXYa2plNRDWLDSa1UeNTVWNoCmNgynQ0BASXcCpMkEVHwp39Em4en+oL4iGS6n9gtahi1FVY2h4h2bR6dOnT9jPS+vVB84axqKmrC1atHBThus2TRmsx1BPC00P7dEUvnqemh5aU/9qRic912nTprm+F7o/ElqvQilN06xrLc2SpSEz2kcKpbQtmRk+o6a1unhXAKULdq83h2bcyQ7Rfj7hUENgBS9qoKvwQq+bjksdT94U294U0wqMtLyucRXOaPYjVc9oOW/IzEknneSOeTXvVcNoBSmB61UFmcKBSEa0qM+MwhWFnxqepV41mkVM59LevXtdEKL+T14VWs+ePV01mJ6njk8dt5p2Xc/DC5CympoTa3u9vjiabUrBoGZUahDBFNuZoX2l6coVxmhbtI+077QtmjZ89erVUR8umeUBjd4kdWCpEZKm0kuN3qR1Ul1wQWxXSAAAAABZoVevXpabptn2qJJATUh1UThgwICkD2w19EIzyWgKZg33UeWMAozRo0e7YCVUQKMptEVhiC5wVcmvdXtDFYYMGeKGbmgd+n0NN1JFiypZFKhEQsGFZqZVBc3YsWNd6DRnzpykD6114a3pqwNnSNIF4Lx589z+0LIKHxR66OJ+4MCBKfpeZJYqJrQPVbmjEOPll19226kg4I477gg5O016FTSqXtJ+VuWFN9wluwKaaD+fcOi5q4m1nr+mQNfxo8lugqddVvWLQg1VsOhYVOiiMEahmzcdtkfhoGanUqWGGvaqekYBhRpma1rvSHoCKcR67bXX3PGlfjOqSFMFiMJQHYuq/FKgGRg0aNv1WqsqSce0zjdVk6j6LDv2sVdFpoxAgaf6vahtis4TzTiVndQsWe8h2ocaoqZ9oXBOr4te16wOBFOTkJiYmHxgZCbegNU0S4mhSsE0N7oOvsAEXQep5mbXVF9689XBCH+UesufcsWMOvLFdRbLtsb4EKeiLaf7vQlAjrZvbluLZU/+9X8zWMSqId1DD0kA4pV6R+hTagUOurDUJ/3ZPTsOgOhQFYoaU6vSK7DHqkJABSq6lvWrmiKeaIiaGih7Pali1RdffOEqalTVld6M1Z5o/h8QdgWNlxLedttt7oDWl5okabiThjVprKfoYH7uuecIZwAAAAAAgO+2b9/uqom8Btmi8MgLZbK651HUAxpRiZ6aW6k8UWVV6gytL4/GkOkJqrQQAAAAAADAbx988IHrx6OsQv13tmzZ4oaLqRpGQ8PUlynHBTTe2Lf58+fbX3/95ZrpqNGQxmuddtppNAYGAAAAAAAx5eyzz3YzcinLUENzVdKceuqpru+SZobzS8QBjUeNriJtdgUAAAAAQHbRzFX6QtaaMmWKxZJGjRq5Ni2xhm5HAAAAAAAAPotKBY2GNmnWJs21fuxY6pNCabYnAAAAAAAARDGgmTZtmt17772u/0xGENAAAAAAAABEMaDR/ODXX3+9mx8+f/78bs54zf3NHPEAAADIbVRFnpCQ4PdmAACyUVojiLI1oHnmmWdcONOuXTt7+umnrVy5clHdMAAAACAnKFSokB08eNAKFy7s96YAALKR3vv1f0C0hF3usmLFCitWrJiNGjWKcAYAAAC5VtGiRV0vxgMHDkT901QAQOzRe73e8/Xer/8DfK+gUfXMKaecwicFAAAAyNU0xL9MmTK2b98+2759u9+bAyAKdL3rVUfQxgOh6NjQe380j4+wA5patWrZ1q1bo7YhAAAAQE6lP9CLFy/uvgDkfApndu/ebeXLl4/qEBYgLWFHPT169LANGzbY/Pnzw10FAAAAAAAAIglorrvuOjeLU8+ePW3ixInR3SoAAAAAAIBcJOwhTpq9SVT2dfPNN9tdd91lNWrUsCJFioRcXtMOTp48OfwtBQAAAAAAiFNhBzQLFy5M9u9du3bZ8uXLU11eAQ0AAAAAAACiGNCMHDky3F8FAAAAAABANAKaa6+9NtxfBQAAAAAAQAAmdAcAAAAAAMipFTTB/v77b9u4caPt37/fmjRpEq3VAgAAAAAAxL2IK2g++OADO/fcc61WrVrWqlUru/zyy5Pd/+CDD7oZnzZv3hzpQwEAAAAAAMSliAKagQMH2i233GI///yz5cuXz/Lnz2/Hjh1Ltkzt2rXdjE9Tp06NdFsBAAAAAADiUtgBjQKX1157zY4//nh79913bdOmTdawYcMUy1188cVuiu0ZM2ZEuq0AAAAAAABxKeweNG+88YYLXkaNGmUtWrRIdblSpUpZpUqV7Mcffwz3oQAAAAAAAOJa2BU03333nZUrVy7NcMaj5bZv3x7uQwEAAAAAAMS1sAOavXv32gknnJChZY8cOWJ58+YN96EAAAAAAADiWtgBjXrP/PXXX+kud/ToUfvjjz/sxBNPDPehAAAAAAAA4lrYAU3jxo0tMTHRZs2aleZyH374oau2Oe+888J9KAAAAAAAgLgWdkDTs2dPN6X27bffbitWrAi5zPz5891U3GomrOUBAAAAAAAQxVmcmjVrZr169bLRo0db69atrUGDBvbnn3+6+/r06eNmbfrhhx9ciNO/f38744wzwn0oAAAAAACAuBZ2BY0MHz7cHn74YStUqJAtW7bMtm3b5gKZCRMm2MqVK93tgwcPdstEavny5dapUyerUqWKVahQwYVCkyZNyvDvayjWjTfe6IZmaR3qiaOfb731Vvv9998j3j4AAAAAAIBsr6DxqDqmW7duLgBZtWqV60tTtGhRq1OnjrVt29Y1E47UggULrGPHji7w6dChgxUrVswmT55sPXr0sA0bNli/fv3SXcfMmTNdiHTmmWe6cCd//vz2yy+/uDBJfXI++OADa968ecTbCgBIqVi3CyyW7etWyO9NAAAAQC6XkJiYeMximKboVqXLpk2bXAhUr149d/uuXbusVatWbiapb775xlXFpOXgwYMu4AnVJ+eKK65wQ7TmzZtn8arUWxstlh354jqLZVtj/OKtaMvpfm8CkKMDmlg/x5/8q7zFsiHd3/Z7E4Bspb8r169fb5UrVw759yWAnI/zHDluiFN2UPXM2rVr7aqrrkoKZ6RkyZJ2xx132KFDh1wVTHpSO6lUNVOqVClbs2ZNVLcbAAAAAAAgbgKahQsXuu8tW7ZMcZ8qaGTRokVhr3/p0qVuWJaGZAEAAAAAAOSoHjSlS5fO1PKaanvHjh2Zfpw//vjDfa9Ro0aK+8qXL+/60WSm+mXu3Lm2ZMkSV3mjdc+YMcPKlCljTzzxRIZL3YBYw3GJWFfM7w1AluI9CLmN/o4M/A4g/nCeIxoyOzwu7IBGszVl5fKe3bt3u+8lSpQIeX/x4sWTlsloQPPSSy8l/bt69er25ptvZngacPXCOXr0qOU8RfzeAGQhjY8FYlnk7eIRy3gPQm61detWvzcBQBbjPEe48ubN6/KGbAloVqxYkep9+/fvd1NXv/HGG/bVV1/ZU089ZRdcEBsNIh977DH3tXfvXjeLk6YKv+iii1xoo2m806MpvnOmzFcvIedQ8zIA8AvvQcht9Im6LtpUzV2gQAG/NwdAFuA8hx/CDmjSmzWpVq1adtlll9mjjz5qgwYNsjlz5oT1OF7lTGpVMnv27HFNfjNLQ6MaNWpk48aNc+HRgAEDrEWLFulOC04Hb8QijksAfuI9CLmVLto4/oH4xnmOHBHQZNTAgQPt9ddft2HDhtmYMWMy/fte7xn1iwkehqREU5UwDRs2DHv78uXLZ02bNrVVq1bZd999Z23atAl7XQDgp1JvbbRYdcTvDUCWGj16tMWyXr16+b0JAAAA/s/iVLBgQTv55JPDnmmpSZMmSb1jgnlVOd4y4dqyZYv7nj9//ojWAwAAAAAAELPTbKvSRUORwtG8eXOrVq2aTZw40VauXJl0+65du+zZZ591JWddunRJFrb8+uuv7v5Aqo4JRSHP559/biVLlrTGjRuHtY0AAAAAAAAxPcTp448/djMfnXLKKWEPQRoxYoR17NjRLr30UuvQoYPrHzN58mQ3a8SQIUOsatWqScs/8sgjNmHCBBs5cqRdd911Sberv0ydOnXstNNOc41+1chYw5q+/vprVzmjJsFFixaNynMGAAAAAADIloBGIUhaU2pv27bNli5datOnT7eEhATr3LlzuA9lzZo1c+sZOnSoTZo0yQ4fPuzCFoUxCmwy4sEHH7Qvv/zSDbXavn275cmTxypVqmTdu3e33r17W82aNcPePgAAAAAAAF8Cmj59+rjgJS0KaqRdu3bWv39/i4RmXNIwp/S88sor7ivYHXfc4b4AAAAAAADiJqA577zzUg1odHuRIkXcDEwXX3yxmyUJAAAAAAAAUQ5opkyZEu6vAgAAAAAAILtncQIAAAAAAEDqCGgAAAAAAABy6hAnTXEdDZUrV47KegAAAAAAAHJdQFO/fv2IH1zNhHfs2BHxegAAAAAAAHJlQONNoR2JaKwDAAAAAAAg1/ag2blzpw0dOtTy589vLVq0sA8++MBWrlxpW7Zscd/1b92u+5988km3fKgvAAAAAACA3C7sCpqpU6fafffdZwMHDnRfwX1l9NWmTRsbPny43XvvvVa1alVr27ZtNLYZAAAAQDYaPXq0xbJevXr5vQkA4F8FzUsvvWSlS5e2u+++O83l7rrrLreclgcAAAAAAEAUA5off/zRVcXkyZP2KnS/lvvhhx/CfSgAAAAAAIC4FnZAc/To0QxNta1GwFpOywMAAAAAACCKAU3dunVt+/bt9uKLL6a53MiRI23btm12+umnh/tQAAAAAAAAcS3sgKZ3796uOuahhx6yrl272sKFC23Hjh3uPn1ftGiRdevWzR588EFLSEiwW265JZrbDQAAAAAAEDfCnsXpiiuucA2An376afv888/dl9dz5r///nM/K8CRO++80y0PAAAAAACAKFbQyP3332+TJk2y888/3wUzCmTUa0bf9e+mTZvaxx9/bA888EAkDwMAAAAAABDXwq6g8VxwwQXua//+/bZmzRrbu3evFStWzKpXr25FihSJzlYCAAAAAADEsYgDGo/CGDUOBoBgo0ePtljWq1cvvzcBAAAAQC4XtYDm77//to0bN7pKmiZNmkRrtQAAAAAAAHEvoh408sEHH9i5555rtWrVslatWtnll1+e7H7N4tSuXTvbvHlzpA8FAAAAAAAQlyIKaAYOHOimz/75558tX758lj9//qSZmzy1a9d2U3BPnTo10m0FAAAAAACIS2EHNApcXnvtNTv++OPt3XfftU2bNlnDhg1TLHfxxRdbQkKCzZgxI9JtBQAAAAAAiEth96B54403XPAyatQoa9GiRarLlSpVyipVqmQ//vhjuA8FAAAAAAAQ18KuoPnuu++sXLlyaYYzHi23ffv2cB8KAAAAAAAgroUd0Ozdu9dOOOGEDC175MgRy5s3b7gPBQAAAAAAENfCHuKk3jN//fVXussdPXrU/vjjDzvxxBPDfSgAAAAgrg0e081iWRU73+9NAIC4F3ZA07hxY/vss89s1qxZ1qZNm1SX+/DDD121zZVXXhnuQwEAACDGFet2gcWyvW9/4fcmAACQNUOcevbs6abUvv32223FihUhl5k/f76bilvNhLU8AAAAAAAAolhB06xZM+vVq5eNHj3aWrdubQ0aNLA///zT3denTx83a9MPP/zgQpz+/fvbGWecEe5DAQAAAAAAxLWwAxoZPny4VaxY0Z5++mlbtmxZ0u0TJkxw3wsXLmx33XWX3XHHHZFvKQAAAAAAQJyKKKARVcd069bN9aJZtWqVJSYmWtGiRa1OnTrWtm1b10wYAAAAAAAAWRDQDBs2zPWWUUBTqlQp69Spk/sCAAAAAABANjUJ1vCmiRMnWsGCBcNdBQAAAAAAACIJaDR0qVixYtHdGgAAAAAAgFwo7IDm7LPPtt9//90OHToU3S0CAAAAAADIZcIOaNR75sCBA/b4449Hd4sAAAAAAABymbCbBJcrV84eeughe+SRR2z16tV2/fXXW61ataxIkSKp/k7lypXDfTgAAAAAAIC4FXZAU79+/aSf58yZ477SohmfduzYEe7DAQAAAAAAxK2wA5pjx45l6fIAAAAAAAC5RdgBzc6dO6O7JQAAAAAAALlUhpsET5061RYvXpy1WwMAAAAAAJALZbiC5rrrrrNzzz3XBTXB7rvvPqtWrZrdfPPN0d4+AAAAIGL75raN6voqmNnR9Wb7orbG8lFbEwAgF0yznVofmVdeecUmTZoUrW0CAAAAAADIVTIV0AAAAAAAACD6CGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA5JRptmX16tXWrl27TN8nCQkJNnny5MxvIQAAAAAAQJzLVECze/duW7hwYabv8wIaAAAAAAAARBDQDBw4MKOLAgAAAAAAICsCmkGDBmVmvQAAAAAAAMiKIU4AYtPgMd0sllWx8/3eBAAAAACIacziBAAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+YxYnAACAHKDUWxstlh3xewMAAMjhqKABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAcnIPmv/++8/ee+89mz59uq1Zs8b27t1rx44dC7lsQkKCff/995E8HAAAAAAAQFwKO6DZs2ePXXXVVbZs2bJUQ5nggAYAAAAAAABRDGiGDRtmS5cutSJFitj1119vZ511lpUtW9by5GHUFAAAAAAAQLYENJMnT3ZhzIQJE6xZs2bhrgYAAAAAACDXC7vcZevWrVa5cmXCGQAAAAAAAL8CmjJlythxxx0X6eMDAAAAAADkemEHNC1btrSff/7ZNQsGAAAAAACADwHNoEGDrGDBgjZw4EA7evRoBJsAAAAAAACQu4XdJHjdunV277332uDBg+27776zrl272sknn+xmdUpNkyZNwn04AAAAAACAuBV2QHPZZZdZQkKC+1lDne6///40l9eyO3bsCPfhAAAAAAAA4lbYAU2lSpWSAhoAAAAAAAD4END88MMPETwsAAAAAAAAIm4SDAAAAAAAgOggoAEAAAAAAMipQ5wCrVixwmbOnGm//fab7dmzx4oXL26nnnqqtWnTxurXrx+NhwAAAAAAAIhbEQU0//zzj/Xp08eFM3Ls2LGk+9RA+IknnrC2bdvaSy+9ZKVLl458awEAAAAAAOJQ2AHNv//+a+3bt3fNghXM1KtXz+rUqWMnnHCCbdmyxVavXm0rV6606dOnW4cOHWzGjBlWsGDB6G49AAAAAABAbg5oRo8e7QKYihUr2siRI6158+YpllmwYIH17dvXLff666+7nwEAAAAAABClJsGTJk1yw5jGjx8fMpyRZs2a2bhx41yFzccffxzuQwEAAAAAAMS1sAMaNQQ+5ZRT3NCmtOh+NQzW8gAAAAAAAIhiQHP48GErXLhwhpbVcloeAAAAAAAAUQxo1Hvm559/tsTExDSX27lzp1uuQoUK4T4UAAAAAABAXAs7oGnRooWbyUnTbB88eDDkMrpd9x86dMhat24dyXYCAAAAAADErbBncRowYIC9//77bhpt9Znp3r27m2a7XLly9vfff7tptseMGWPbt2+34sWL22233RbdLQcAAAAAAMjtAY2GOGkGJwUz27Zts6effjrFMpq96fjjj3dBjZaPxPLly23o0KG2ZMkSO3LkiAuDNG13+/bt0/1dbcfs2bNt2rRptnjxYtuwYYPriVO9enXr0KGDW0+hQoUi2j4AAAAAAIBsD2jk/PPPt6VLl9rrr79us2bNcjM17d2714oVK+ZmbrrwwgvtxhtvtNKlS0fyMLZgwQLr2LGjC1EUqGj9kydPth49eriwpV+/fmn+voZiderUyQoWLOi2uVWrVm741dy5c23IkCE2ZcoU+/zzz61IkSIRbScAAAAAAEC2BzSi8OWee+5xX1lB1TL9+/e3PHnyuCDFm9Zbj6egRQHLFVdcYVWqVEl1HXnz5rUHHnjAbrrpJitVqlTS7aqiueGGG9wwLYVMDMMCAAAAAAA5qklwdlH1zNq1a+2qq65KCmekZMmSdscdd7gGxBMmTEhzHfnz57e77rorWTjj3a51yKJFi7LoGQAAAAAAAGRxBU1WW7hwofvesmXLFPepgibScEUhjVdlkxGpzVgFIOfivAbiG+c4EP84zxFtKgQI/A6EI7O9bjMU0AwbNsx9L1OmjBsmFHhbZgwcODDTv/PHH3+47zVq1EhxX/ny5V0/mjVr1li4xo4dm2oAFMqmTZvs6NGjlvPQXwdIzfr16y0+cJ4DoXCOA/Evfs5zxJqtW7f6vQnIoVQEoomJoh7QPPnkk5aQkGCnnHJKUkDj3ZYRmkVJy4YT0Ozevdt9L1GiRMj7NYW3t0xmqbHxW2+9ZTVr1nS9aDKiQoUKljPt8HsDgJhVuXJliw+c50AonONA/Iuf8xyxQpUzCmdUFFCgQAG/Nwe5RIYCmi5duriA5YQTTkhxW06labs1w5SCH00DrhmeMoLpuIH4w3kNxDfOcSD+cZ4jqyic4fhCTAU0r7zySoZuywpe5UxqVTJ79uxJ0fw3Pd999521b9/eBUwff/yx1a5dOyrbCgAAAAAAEJezOHm9Z7xeNIFUcrZ3795MjetSOHPllVe6YVcKZxo2bBjV7QUAAAAAAMi2gKZv37723HPPZWjZ559/3i0fjiZNmrjvc+fOTXHfnDlzki2T0XDmv//+s4kTJ9qZZ54Z1jYBAAAAAADEREAzfvx4mzlzZoaWnT17tk2YMCGsx2nevLlVq1bNBSorV65Mun3Xrl327LPPujGB6ofj2bJli/3666/u/kDff/+9C2c0A9OHH35oZ511VljbAwAAAAAA4EsPmkipYiXchsL58uWzESNGWMeOHe3SSy+1Dh06uKm1J0+e7KbTGzJkiFWtWjVp+UceecSFQSNHjrTrrrvO3bZz504Xzii0ad26tc2bN899BSpZsqT16dMnwmcKAAAAAAAQowHN5s2brWjRomH/frNmzWz69Ok2dOhQmzRpkh0+fNjq1KnjwhgFNulRg+HExMSkah59hZqaj4AGAAAAAADEdECjapW//vorRfCxaNGiVH/nwIEDNn/+fPvzzz+tcePGEW1oo0aN3DCn9Gh2qeAZplRh4wU0AAAAAAAAOTagGTdunA0fPjzZbT/99JO1a9cuzd/TbEnSvXv3cLcRAAAAAAAgrmU4oFGPlkqVKiX9e8OGDa5Bb7ly5UIur54zRYoUsZNOOsk18b388sujs8UAAAAAAAC5NaDp3bu3+/Icd9xx1qBBA5s2bVpWbRsAAAAAAECuEHaTYM2SlFr1DAAAAAAAALIhoLn22mvD/VUAAAAAAAAEyGNhWrt2rQ0bNsxmzJiR5nKaHlvLrVu3LtyHAgAAAAAAiGthBzTvvPOOC16OHj2a5nL//fefW27s2LHhPhQAAAAAAEBcCzugmTt3rhUqVMjatm2b5nIXXXSRFSxY0GbPnh3uQwEAAAAAAMS1sAMaTbNduXJly5Mn7VXkzZvXqlSp4pYHAAAAAABAFAOaffv2WdGiRTO0rJbbvXt3uA8FAAAAAAAQ18IOaI4//nj7/fff0+1Bo/u1XJkyZcJ9KAAAAAAAgLgWdkBz1lln2d69e9Nt/jtu3Djbs2ePNW7cONyHAgAAAAAAiGthBzQ9evSwY8eO2aBBg2zChAkhl3nvvfds4MCBlpCQYDfeeGMk2wkAAAAAABC38oX7i02bNnUhzVtvvWV9+/a1xx9/3M4880wrWbKk7dq1y7755hvbtGmTC3G0XPPmzaO75QAAAAAAALk9oJFnnnnGypYtayNGjLCNGze6r0CFCxe2AQMG2N133x3pdgIAAAAAAMStiAIaDV269957rVevXjZz5kxbvXq16zdTvHhxO+200+zCCy+kOTAAAAAAAEBWBjSBMzpde+210VgVAAAAAABArhN2k2AAAAAAAADESAVNYmKivfvuuzZ//nzXg+bAgQP2/fffJ90/Y8YM++eff6xjx45WoECBSB8OAAAAAAAg7kQU0CxatMi6d+9uO3bscLM1eX1pAmk2JzUTLl26tF100UWRbS0AAAAAAEAcCnuI07p16+yaa66x7du3u+Dl5Zdfttq1a6dYrkOHDi68mTp1aqTbCgAAAAAAEJfCDmief/55N2PT7bffbhMmTHBhTcmSJVMsp9BGty9ZsiTSbQUAAAAAAIhLYQc0c+fOtaJFi7ppttNTpUoV158GAAAAAAAAUQxotmzZYtWrV7f8+fOnu2zBggXt33//DfehAAAAAAAA4lrYAU3hwoXdDE4ZsXnzZitVqlS4DwUAAAAAABDXwg5oatasaZs2bbINGzakudyPP/7ohjfVq1cv3IcCAAAAAACIa2EHNFdccYUdPXrU9aDR91AOHjxod911l5t6u3379pFsJwAAAAAAQNwKO6C58cYbXRXNlClT3DTbY8aMsd27d7v7Fi1aZKNGjbKmTZva4sWLXfVM586do7ndAAAAAAAAcSNfuL9YqFAhmzhxonXp0sW+/fZbW758edJ97dq1c9+PHTtmderUsfHjx1u+fGE/FAAAAAAAQFyLKDWpVKmSzZs3zyZMmGCTJk2yVatWucbBmn5bwYyGNXXr1s0KFCgQvS0GAAAAAACIMxGXtWia7a5du7ovAAAAAAAAZGMPGgAAAAAAAEQHAQ0AAAAAAEBOGOI0bNiwqDzYwIEDo7IeAAAAAACAXBfQPPnkk5aQkBD2g2g2J/0+AQ0AAAAAAECYAY2m0o4koAEAAAAAAECEAc0rr7ySkcUAAAAAAAAQBpoEAwAAAAAA+IyABgAAAAAAICcMcUpLYmKivfvuuzZ//nzbuHGjHThwwL7//vuk+2fMmGH//POPdezY0QoUKBDpwwEAAAAAAMSdiAKaRYsWWffu3W3Hjh1upiYJbib8zTff2DPPPGOlS5e2iy66KLKtBQAAAAAAiENhD3Fat26dXXPNNbZ9+3YXvLz88stWu3btFMt16NDBhTdTp06NdFsBAAAAAADiUtgBzfPPP2979uyx22+/3SZMmODCmpIlS6ZYTqGNbl+yZEmk2woAAAAAABCXwg5o5s6da0WLFrV777033WWrVKni+tMAAAAAAAAgigHNli1brHr16pY/f/50ly1YsKD9+++/4T4UAAAAAABAXAu7SXDhwoXdDE4ZsXnzZitVqlS4DwUAAAAAALLQ6NGjLZb16tXL4l3YFTQ1a9a0TZs22YYNG9Jc7scff3TDm+rVqxfuQwEAAAAAAMS1sAOaK664wo4ePep60Oh7KAcPHrS77rrLTb3dvn37SLYTAAAAAAAgboUd0Nx4442uimbKlClumu0xY8bY7t273X2LFi2yUaNGWdOmTW3x4sWueqZz587R3G4AAAAAAIC4EXYPmkKFCtnEiROtS5cu9u2339ry5cuT7mvXrp37fuzYMatTp46NHz/e8uUL+6EAAAAAAADiWkSpSaVKlWzevHk2YcIEmzRpkq1atco1Dtb02wpmNKypW7duVqBAgehtMQAAAAAAQJyJuKxF02x37drVfQEAAAAAACAbe9AAAAAAAAAgOqLeGEb9aJYtW2aHDx+2GjVqWKtWraxgwYLRfhgAAAAAAIDcF9Bs2LDB3n//fStVqpT17Nkzxf379+93MzvNnDkz2e1VqlSxsWPHWt26daOzxQAAAAAAALl1iNP06dPt8ccft7Vr14a8/+6777YZM2a4mZsSEhKsbNmy7vZ169a5Kbb37dsXva0GAAAAAADIjQHNV1995b537NgxxX1r1qxxMzkpmNEU2wpxfvnlF1uyZImdcsoptnnzZnvnnXeiu+UAAAAAAAC5LaD5+eef3fTZDRo0SHHfp59+6ipnjjvuOBs5cqSVKFHC3a5wZujQoe4+VdcAAAAAAAAggoBm27ZtdtJJJ4W87+uvv3bVMxdeeKEVL1482X1qEqy+NQp4AAAAAAAAEEFAk5iYaHnz5g1534oVK9z3pk2bhry/YsWK7vcBAAAAAAAQQUBTpEgR27JlS4rbN27caH///bf7uX79+iF/N3/+/G6YEwAAAAAAACIIaNRPZuvWrfb9998nu33WrFnue7FixaxOnTohf1dNgkuXLp3RhwIAAAAAAMhVMhzQqJeMqmAGDhzo+tGIZmt67rnnXP+Ztm3buu/BNm3a5IKdGjVqRHfLAQAAAAAAcltA87///c9VwSxbtsxVytSqVcsaNWpkf/31l+XJk8f69u0b8vcmT57svjdp0iR6Ww0AAAAAAJAbAxqFM++9956VK1fOjhw54qpiVFGjxsFPPPFEyP4zuv+tt95ylTUtWrSI9rYDAAAAAADEhXyZWbhx48b27bffur4zGt6kKbVbt25t1apVC7n8zp077aabbnIBzVlnnRWtbQYAAAAAAMi9AY0ULVrUrrzyygxX3fTq1Suc7QIAAAAAAMg1MjzECQAAAAAAAFmDgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnOSagWb58uXXq1MmqVKliFSpUsNatW9ukSZMy/Ptr1661oUOHWpcuXax27dpWqlQpO/3007N0mwEAAAAAADIin+UACxYssI4dO1qhQoWsQ4cOVqxYMZs8ebL16NHDNmzYYP369Ut3HV999ZUNGzbM8ubNazVr1rStW7dmy7YDAAAAAADk+IDmyJEj1r9/f8uTJ49NmTLF6tWr526/5557rFWrVjZkyBC74oorXGVNWpo0aWKzZs2yunXrWuHCha18+fLZ9AwAAAAAAABy+BAnVc9oeNJVV12VFM5IyZIl7Y477rBDhw7ZhAkT0l1PtWrVrHHjxi6cAQAAAAAAiCUxX0GzcOFC971ly5Yp7lMFjSxatCjbtufgwYPZ9lgAsgfnNRDfOMeB+Md5jmhTIUDgd/jvYA48z9WmJa4Cmj/++MN9r1GjRor7NExJ/WjWrFmTbduzadMmO3r0qOU8RfzeACBmrV+/3uID5zkQCuc4EP/i5zxHrKF3aexYn8POc/W/rV69enwFNLt373bfS5QoEfL+4sWLJy2THTSDVM60w+8NAGJW5cqVLT5wngOhcI4D8S9+znPEClXOKJxRUUCBAgX83hxY7jjPYz6gyeklSgBiH+c1EN84x4H4x3mOrKJwhuMrNhTKBa9DzDcJ9ipnUquS2bNnT6rVNQAAAAAAADlBzAc0Xu8ZrxdNIJWc7d27N9PjugAAAAAAAGJJzAc0TZo0cd/nzp2b4r45c+YkWwYAAAAAACAnivmApnnz5latWjWbOHGirVy5Mun2Xbt22bPPPuvGBHbp0iXp9i1bttivv/7q7gcAAAAAAMgJYr5JcL58+WzEiBHWsWNHu/TSS61Dhw5uau3Jkye7abaGDBliVatWTVr+kUcesQkTJtjIkSPtuuuuS7p9x44d9sADDyT9+/Dhw/bPP/9Y7969k2577LHHrEyZMtn47AAAAAAAAHJAQCPNmjWz6dOn29ChQ23SpEkuXKlTp44LYxTYZIR61Si4CbRv375ktw0aNIiABgAAAAAAZLscEdBIo0aN3DCn9LzyyivuK5iqbBITE7No6wAAAAAAAHJBQAMAAAAA8E+xbhdYLNv79hd+bwIQ302CAQAAAAAA4h0BDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZ/n83gAAAAAAgFmptzZaLDvi9wYAcY4KGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ8R0AAAAAAAAPiMgAYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAAAAAAJ/l83sDAAAAAACId4PHdLNYVsXO93sTcj0qaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOAzAhoAAAAAAACfEdAAAAAAAAD4jIAGAAAAAADAZwQ0AAAAAAAAPiOgAQAAAAAA8BkBDQAAAAAAgM8IaAAAAAAAAHxGQAMAAAAAAOCzHBPQLF++3Dp16mRVqlSxChUqWOvWrW3SpEmZWse///5rw4YNs4YNG1r58uWtVq1a1r9/f9u2bVuWbTcAAAAAAEB68lkOsGDBAuvYsaMVKlTIOnToYMWKFbPJkydbjx49bMOGDdavX7901/Hff//Ztddea3PmzLHGjRvb5Zdfbn/88Ye98847Nn/+fJs9e7Ydf/zx2fJ8AAAAAAAAclRAc+TIEVflkidPHpsyZYrVq1fP3X7PPfdYq1atbMiQIXbFFVe4ypq0jB8/3oUzV111lY0ePdoSEhLc7W+++abdcccd9thjj9nzzz+fLc8JAAAAAAAgRwU0qp5Zu3atXXfddUnhjJQsWdIFK3369LEJEybYwIED01yPKmXkwQcfTApnRFU4I0aMsA8//NCGDh1qhQsXtnhUpmBsj2Y7VrykxbT8hSyWFSlY3GJZobyxvf/iRSyf55zjkeEcR6yf48J5HhnOcwjneWzJmzdvVNfHeY70JCQmJh6zGPboo4/as88+a2+88YYb5hRo69atVrNmTWvWrJkb8pSagwcPur41NWrUsGXLlqW4//bbb7e33nrLpk6dauedd16WPA8AAAAAAIDUxHZEa+b6xIjClWBq9Kt+NGvWrElzHarAUQ+a6tWrh7zfu917LAAAAAAAgOwU8wHN7t273fcSJUqEvL948eJJy6S3Dg2LCsVbd3rrAQAAAAAAyJUBDQAAAAAAQLyL+YAmveqWPXv2pFpdE7yOXbt2hVWlAwAAAAAAkKsDGq/3TKj+MGoSvHfv3lR7y3iqVavmpulOrVeNd3uoPjcAAAAAAABZLeYDmiZNmrjvc+fOTXHfnDlzki2TGk2d3ahRI/vtt9/sr7/+SnbfsWPHbN68eVa0aFFr0KBBVLcdAAAAAAAgLgKa5s2buwqYiRMn2sqVK5Nu13AlTb9doEAB69KlS9LtW7ZssV9//TXFcKZu3bolTdutUMaj6bX//PNP69SpkwtyEPv69u1rpUqVspNOOsn+/fdfvzcn7mkGtFGjRrkp6E844QRXadazZ0933gBZhfM8+2zbts39f9q1a1erV6+e2+/6ArIa53n2+frrr+3+++93f1drf2sm1MaNG9tDDz1kiYmJfm8e4hTnePb55ptv7JZbbrFzzz3XXTvrHFfxQY8ePey7777ze/OQCQmJiYn/L62IUQsWLLCOHTtaoUKFrEOHDm5q7cmTJ9v69ettyJAh1q9fv6Rle/fubRMmTLCRI0faddddl+wiUyGMqm70H5KqbjS06bPPPrMqVaq4248//nifniEySj2HatWqZfv373dB25tvvumOCWSd2267zd555x2rXbu2XXjhhbZ582b75JNPXNXZ7NmzGRqIqOM8z15ffvmltWvXzhISEtz5vGnTJrfvuWhDVuI8z16nnnqq7dixw8455xwXxOp8X7hwofvwUxdzM2fOtHLlyvm9mYgjnOPZ68UXX3TXv2eeeaZVqFDBihQp4j5MnT59ugvHXnnllWRFDYhdMV9BI82aNXMH19lnn22TJk1yJ7j+E9H3wHAmLepBM378eBs0aJBt377dXn75ZVuyZIndcMMNNmvWLMKZHEKv/759+6xPnz7uNX333Xf93qS4pnBU4YyqZ+bPn2+PPPKIvfbaazZu3DjbuXOn3X333X5vIuIQ53n2qlmzpk2ZMsUNAdYncBUrVvR7k5ALcJ5nL+3nVatWuXN96NCh9sQTT7j/172K2OHDh/u9iYgznOPZq1evXvbzzz/b2LFj3fn88MMP25gxY1ybkIIFC9rgwYOTjSJB7MoRAY2oh4yGOekPSH2Cr4qXUCms0kF96hdYPePRwamARmVef//9t/3yyy82YsQIPjHIQfTmni9fPuvfv781bdrU/XER3FfIc/rpp7svHQ8KEk477TQrU6aMCxfWrVvnSi5VcaXjoHPnzq6SqmrVqu6PFX3KJEuXLrXLL7/cKleu7O5TIKj/bDJKFVpan0oMTzzxRPcYF198sX366acplg3eJh3DKgnVbbpP262f9X3atGnWqlUrt05Vtjz22GOuSkwURKpCTMOR6tat647xcCmcEZVFazihp02bNnb++ee7N31VsgHRxHmevee5/g/UuooXLx72OoDM4jzP3vN8wIAB7jECqYrG+6Bl0aJFYa8bCIVzPHvPcY00CaVOnTqugk7DmVObFRmxJccENIBS4WXLllnLli3dBYXK9PQGpze/1Bw6dMi9WStI0JvsTTfdlCyQ05uohu2o9E/9F/Tm+NFHH7k3Wo3XvuKKK9xQHvUw0huv/rO55557MrzN6nn0008/uZJijQvV+tSsWutTX5dQ1q5d6wIQ/Ydz7bXX2jXXXJMsHPn888/deFKVJOu7tu/pp592n4bpjV0hpJ6HHkP758EHH3TD/sKh8metX9sfTP/ZCH/UIZo4z7P/PAeyG+d57Jzn+fPnd9/z5s0b1fUid+Mcj51zXNv4+++/W6VKlaxkyZJRXTdycQ8awKvi0NjKN954w/Uk0hTrKs0/7rjj3BhqlU8GUhKv6g4FCSr3C2wCrTf5+vXru59V6qsEXFT6p2ReY7H1JqahcJdeeqm77/Dhw3bBBRe4pHz16tUZqrxS2bDelANpu/UfzIYNG9x/YBojGrxN+g/lvvvuS/Z7+k9Nzdb0x9SMGTOsYcOGSWN89bM+JdAn4LrPe0w9hu47+eST7auvvsrU/tb6NNRByXuo39UnCvoPRZ906LUBooHzPHvP81DUp01/lNKDBlmF89z/89zzwgsvuEbB6jenC1QgGjjH/TvHv/32W7dPjhw54vapKniOHj3qhjvpuSD2UUGDHEFvtO+//76VKFEi6c1XzaL1s97Qvvjii1R/V31TUpuhSwm7UvLAcl9v6Jya6HmPJXqTVZquNzy9SWdE8Bu9t91K2VVmuHz58hT3q+v6XXfdleo6r7766qQ3etEb/EUXXeSasN14443JHlNpuT4J0H9Q2u7M8Mogtc9D8W6nXBLRwnme/ec5kN04z2PnPNeF8rBhw6xs2bJuGAoQDZzj/p7jCmh0Xj/zzDP2wQcfuP2p0ItwJucgoEGOMHXqVNfcWW+2gWMsVUooqTUe07Iax5oa3ac3+EAaB+ql+cG8+zSde0ZovKdS9bPOOsuNPfWmr33ggQdSXY9KHQPLI4OltV2p3afkXH2XgFjGef7/cJ4jXnGex8Z5rmoBVR9ofapyUL8PIBo4x/09x2+++WZXAauerWpVoKqkq666ys3yhJwhn98bAGSE92YePD1c8+bN3VRy+s9AswqpdDKQZucKfjMPFKoppjcOO6379OlAerQ9LVq0cJ8WKBHXtqoEU+v44Ycf3DZrHG0wfZKVlqzc5sxUyKRXYQNkFud59mwz4CfO8+zZ5vTCmcsuu8z1zdBkAJotFYgWzvHs2eb0qHJGAZIm0NG5rqGMCmvUugCxjYAGMU9vlmoYJoHli8FUThlY+ihpvdFnx39Q2naNww2ejvq5555zb/ah+LnNgdTITEm+xtkqzQ9uILhmzRr3vUaNGj5tIeIJ5zkQ/zjP/eeFM1u3bnU9Kdq2bev3JiGOcI7HJoVP6kujZsoENLGPgAYxT1PQqbP5ueee6xpnBdM4TXU815tr8Ju9n9Q1XS655JIU9+kNMifQ1H/qkL948WL3cyBNdS/nnXeeT1uHeMJ5DsQ/zvPYCWfefPPNNC+ggXBwjscmb3iWN2sbYhsBDWKaOrSrE7oSapXohWrgJX/88YctXbrUvvvuO2vQoIHFgsqVK7vvCjcCx9R++OGHLsXOCTRLkwKaxx9/3D755JOkcbazZs1y41o1fWKVKlX83kzkcJznQPzjPI+NcEYXagpn2rVr5/cmIc5wjvsrtf2pZuBvvfWWC2c0dAuxj4AGMW3BggVuiI2qN1J7o5frrrvOvdkrkY+VN3s133v++efd9Htffvmle/NftWqVzZ8/3/1h9Nlnn1ms07j0rl27ujHqelNXB3j9cTdp0iQ3dnj48OF+byLiAOe5/7xpS0Wfrgffdvvtt9upp57qy7YhPnCe+0vbqSEcjRs3th9//NF9Bbv33nt92TbEB85xf+nv9Xz58tkZZ5zhZoQ6dOiQ/f777zZv3jwXnj355JNWtWpVvzcTGcAsTsgRjcY0xV1a2rdv75phTZw40Q4cOGCxoGLFijZlyhQXbGhKQY311pulwo2cNOZb/2HpTV1effVVVz2jT+E0xjhU+SqQWZzn/lPJufflNQAPvM0LbYBwcZ77a/369e77smXL3BS8ob6ASHCO++vOO++0mjVrunP89ddfd8/ht99+czM46W/3//3vf35vIjIoITEx8VhGFwYAAAAAAED0UUEDAAAAAADgMwIaAAAAAAAAn9EkGMhF1MldY2zTo5mZ1MQNQM7DeQ7EP85zIL5xjudeBDRALvLDDz9kqBGgOvDzZg/kTJznQPzjPAfiG+d47kWTYAAAAAAAAJ/RgwYAAAAAAMBnBDQAAAAAAAA+I6ABAAAAAADwGQENAAAAAACAzwhoAAAAAAAAfEZAAwAAAAAA4DMCGgAAkGs98cQTVqpUKff11FNP+b05AAAgF0tITEw85vdGAAAAZLf//vvP6tevb+vXr3f/Pumkk2z58uWWkJDg96YBAIBciAoaAACQK82fP9+FM0WKFLECBQrY2rVrbeHChX5vFgAAyKUIaAAAQK40duxY9/2yyy6ztm3bJrsNAAAguxHQAACAXCcxMdGmTJnifr722mvtmmuucT9/9tlntnv37pC/c/rpp7teNV9++aX99ttvdsstt1idOnXs+OOPt969e7tlhg4d6pbRvw8dOmTDhw+3xo0b2wknnOCWvfvuu91jez755BMXDlWpUsUqV65snTp1slWrVmXLPgAAALGFgAYAAOQ6H374oR08eNAqVqxozZo1szZt2ljZsmVt//799vHHH6f5u8uWLbPmzZvbpEmTXDhz6qmnWp48yf+kOnLkiLVv394FNnnz5nUBzJYtW2z06NF25ZVXuvDm4Ycftu7du9uGDRusatWqdvjwYZs1a5ZdcskltmbNmizeAwAAINYQ0AAAgFzHG8rUuXNnF67ky5fPVa8E3peaxx9/3C699FL75ZdfbMGCBfbVV1/Z008/nWwZVcb8/ffftnjxYve1dOlSmzt3rpUsWdK+//57u+mmm+z111+3CRMmuIoZVeXoe7169VwFz5NPPpmFzx4AAMQiAhoAAJCrKAhZsWKF+9kb2uQNdZJvvvnGfv7551R//5RTTrFXXnnFDWXyFC5cOEUFzauvvmo1a9ZMuu2MM86wbt26uZ8nT55s99xzj1188cVJ96sa5/7773c/z5gxIwrPFAAA5CQENAAAIFfxKmTOPPNMF7Z46tat6/rMyLhx41L9fYU6qrhJi9bVqFGjFLcrpPF4YU2gBg0auO+7du2yf/75J0PPBwAAxAcCGgAAkGuo94v6zwRXzwRX0bz//vuuCiaUWrVqpfs41atXD3m7qmSkTJkybrhTMPXB8ezduzfdxwEAAPGDgAYAAOQa06ZNsx07dliBAgWsY8eOKe5XH5r8+fO7/jGpDTMqUqRIuo+T2jIJCQkZul+OHTuW7uMAAID4kXZ9LgAAQBwOb1IlTbVq1dJdVs2AAQAAsgMBDQAAyBU2bdrkZlLyhhhp+utQjh496qpsNOW1KmnKlSuXzVsKAAByIwIaAACQK2hKa4UvCmc0S5OGMoWi3jO1a9e2bdu22XvvvWe33XZbtm8rAADIfehBAwAAcoXx48cn6zOTGs3QdPXVV6c7mxMAAEA0EdAAAIC4t2jRIvvjjz/cz9dff326y3vL/PLLL7Z06dIs3z4AAAACGgAAEPe8SpgzzjjD6tatm+7yGuLUqFGjZI2FAQAAslJCYmIiczgCAAAAAAD4iAoaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAAPAZAQ0AAAAAAIDPCGgAAAAAAAB8RkADAAAAAADgMwIaAAAAAAAAnxHQAAAAAAAA+IyABgAAAAAAwGcENAAAAAAAAD4joAEAAAAAADB//X9wgpdcPR3bkgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot cumulative reward\n", + "plt.figure(figsize=(12, 6))\n", + "for name, (rewards, _) in results.items():\n", + " cum_reward = cumulative_reward(rewards)\n", + " plt.plot(cum_reward, label=name)\n", + "plt.title('Cumulative Reward Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot cumulative regret\n", + "plt.figure(figsize=(12, 6))\n", + "# Calculate optimal reward based on our data generation configuration\n", + "# arm_0 has the highest base rate of 0.1\n", + "optimal_reward = 0.1 # This is the base rate of arm_0\n", + "for name, (rewards, _) in results.items():\n", + " cum_regret = cumulative_regret(rewards, optimal_reward=optimal_reward)\n", + " plt.plot(cum_regret, label=name)\n", + "plt.title('Cumulative Regret Over Time')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Regret')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot arm selection frequency\n", + "plt.figure(figsize=(12, 6))\n", + "n_methods = len(results)\n", + "bar_width = 0.8 / n_methods # Adjust bar width based on number of methods\n", + "\n", + "# Get all unique arms across all methods\n", + "all_arms = set()\n", + "for _, (_, selected_arms) in results.items():\n", + " all_arms.update(selected_arms)\n", + "all_arms = sorted(list(all_arms))\n", + "x = np.arange(len(all_arms))\n", + "\n", + "for i, (name, (_, selected_arms)) in enumerate(results.items()):\n", + " arm_freq = pd.Series(selected_arms).value_counts(normalize=True)\n", + " # Ensure we have frequencies for all arms, even if they weren't selected\n", + " freq_values = [arm_freq.get(arm, 0) for arm in all_arms]\n", + " plt.bar(x + i * bar_width, freq_values, width=bar_width, label=name)\n", + "\n", + "plt.title('Arm Selection Frequency')\n", + "plt.xlabel('Arm')\n", + "plt.ylabel('Selection Frequency')\n", + "plt.xticks(x + bar_width * (n_methods - 1) / 2, [f'Arm {arm}' for arm in all_arms])\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "41fb6922", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8eae6a77", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d93ba08c", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "In this notebook, we demonstrated:\n", + "1. How to generate synthetic bandit data with arm-specific features\n", + "2. How to initialize and run different bandit algorithms\n", + "3. How to evaluate and visualize the performance of each algorithm\n", + "\n", + "The results show how different algorithms perform in terms of:\n", + "- Cumulative reward\n", + "- Cumulative regret\n", + "- Arm selection frequency\n", + "\n", + "As results show, the Contextual MAB (LinUCB and Cohort Thompson Sampling) methods outperform classic MAB when there is context influencing arm performance. \n", + "\n", + "You can modify the parameters and configurations to experiment with different scenarios." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "venv", + "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.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/bandit/mab_bandit_model_demo.ipynb b/docs/examples/bandit/mab_bandit_model_demo.ipynb new file mode 100644 index 00000000..07aacfeb --- /dev/null +++ b/docs/examples/bandit/mab_bandit_model_demo.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "34d5f599", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Multi-Armed Bandit (MAB) Model Demonstration\n", + "\n", + "This notebook demonstrates how to use different types of Multi-Armed Bandit (MAB) models in `causalml`:\n", + "1. Classic MAB models (EpsilonGreedy, UCB, ThompsonSampling)\n", + "2. Contextual MAB models (LinUCB)\n", + "3. Batch-mode Classic MAB models (using BatchBandit wrapper)\n", + "4. Batch-mode Contextual MAB models (BatchLinUCB)\n", + "\n", + "Each section will show a simple, streamlined example of how to use these models without additional function wrappers." + ] + }, + { + "cell_type": "markdown", + "id": "9584d3d5", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 1. Setup and Imports\n", + "\n", + "First, let's import all the necessary libraries and set up our environment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "061954e0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from causalml.dataset import make_mab_data\n", + "from causalml.optimize.bandit import (\n", + " # Classic MAB models\n", + " EpsilonGreedy, UCB, ThompsonSampling,\n", + " # Contextual MAB models\n", + " LinUCB,\n", + " # Batch processing wrapper\n", + " BatchBandit\n", + ")\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "id": "c97b854d", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 2. Data Generation\n", + "\n", + "We'll generate synthetic data for our bandit experiments using `make_mab_data`. This function creates a dataset with:\n", + "- Multiple arms\n", + "- Features that influence rewards\n", + "- Different reward rates for each arm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a05b0631", + "metadata": {}, + "outputs": [], + "source": [ + "# Data generation configuration\n", + "n_samples = 10000\n", + "n_arms = 4\n", + "n_features = 3\n", + "n_informative = 2\n", + "n_redundant = 1\n", + "n_repeated = 0\n", + "arm_effects = {\n", + " 'arm_0': 0.0, # Control arm\n", + " 'arm_1': -0.01, # Small negative effect\n", + " 'arm_2': -0.02, # Medium negative effect\n", + " 'arm_3': -0.04 # Large negative effect\n", + "}\n", + "positive_class_proportion = 0.1\n", + "random_seed = 42\n", + "feature_association_list = [\"linear\", \"quadratic\"]\n", + "random_select_association = False\n", + "error_std = 0.05\n", + "n_arm_features = {'arm_0': 0, 'arm_1': 1, 'arm_2': 0, 'arm_3': 0} # Updated to include all arms\n", + "n_mixed_features = {'arm_1': 0, 'arm_2': 0, 'arm_3': 0}\n", + "\n", + "# Generate data\n", + "df, feature_names = make_mab_data(\n", + " n_samples=n_samples,\n", + " n_arms=n_arms,\n", + " n_features=n_features,\n", + " n_informative=n_informative,\n", + " n_redundant=n_redundant,\n", + " n_repeated=n_repeated,\n", + " arm_effects=arm_effects,\n", + " positive_class_proportion=positive_class_proportion,\n", + " random_seed=random_seed,\n", + " feature_association_list=feature_association_list,\n", + " random_select_association=random_select_association,\n", + " error_std=error_std,\n", + " n_arm_features=n_arm_features,\n", + " n_mixed_features=n_mixed_features\n", + ")\n", + "\n", + "# Extract features, arms, and rewards\n", + "X = df[feature_names].values\n", + "arms = df['arm'].values\n", + "rewards = df['reward'].values" + ] + }, + { + "cell_type": "markdown", + "id": "19ee61f8", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 3. Classic MAB Models\n", + "\n", + "Let's demonstrate how to use classic MAB models (EpsilonGreedy, UCB, ThompsonSampling).\n", + "These models don't use contextual information and make decisions based on historical rewards only." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d6e5367c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize classic MAB models\n", + "eg = EpsilonGreedy(epsilon=0.1)\n", + "ucb = UCB()\n", + "ts = ThompsonSampling()\n", + "\n", + "# Fit the models with initial data\n", + "eg.fit(arms, rewards)\n", + "ucb.fit(arms, rewards)\n", + "ts.fit(arms, rewards)\n", + "\n", + "# Run online evaluation\n", + "eg_rewards = []\n", + "ucb_rewards = []\n", + "ts_rewards = []\n", + "\n", + "eg_arms = []\n", + "ucb_arms = []\n", + "ts_arms = []\n", + "\n", + "for i in range(len(X)):\n", + " # EpsilonGreedy\n", + " chosen_arm = eg.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " eg.update(chosen_arm, reward)\n", + " eg_rewards.append(reward)\n", + " eg_arms.append(chosen_arm)\n", + " \n", + " # UCB\n", + " chosen_arm = ucb.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " ucb.update(chosen_arm, reward)\n", + " ucb_rewards.append(reward)\n", + " ucb_arms.append(chosen_arm)\n", + " \n", + " # ThompsonSampling\n", + " chosen_arm = ts.select_arm()\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " ts.update(chosen_arm, reward)\n", + " ts_rewards.append(reward)\n", + " ts_arms.append(chosen_arm)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(eg_rewards), label='EpsilonGreedy')\n", + "plt.plot(np.cumsum(ucb_rewards), label='UCB')\n", + "plt.plot(np.cumsum(ts_rewards), label='ThompsonSampling')\n", + "plt.title('Cumulative Rewards - Classic MAB Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0693d2f8", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 4. Contextual MAB Models\n", + "\n", + "Now let's demonstrate how to use contextual MAB models (LinUCB).\n", + "These models use feature information to make decisions." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "915e3129", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize contextual MAB model\n", + "linucb = LinUCB(alpha=1.0)\n", + "linucb.fit(X=pd.DataFrame(X, columns=feature_names), arm=arms, reward=rewards, features=feature_names)\n", + "\n", + "# Run online evaluation\n", + "linucb_rewards = []\n", + "linucb_arms = []\n", + "\n", + "for i in range(len(X)):\n", + " # LinUCB\n", + " chosen_arm = linucb.select_arm(X[i])\n", + " reward = rewards[i] if chosen_arm == arms[i] else 0\n", + " linucb.update(chosen_arm, X[i], reward)\n", + " linucb_rewards.append(reward)\n", + " linucb_arms.append(chosen_arm)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(linucb_rewards), label='LinUCB')\n", + "plt.title('Cumulative Rewards - Contextual MAB Model')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1bceb82f", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 5. Batch-mode Classic MAB Models\n", + "\n", + "Let's demonstrate how to use batch-mode classic MAB models using the BatchBandit wrapper.\n", + "These models process data in batches rather than one sample at a time." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ba49b7cf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize batch-mode classic MAB models\n", + "batch_size = 100\n", + "beg = BatchBandit(EpsilonGreedy(epsilon=0.1), batch_size=batch_size)\n", + "beg.bandit.fit(arms, rewards)\n", + "bucb = BatchBandit(UCB(), batch_size=batch_size)\n", + "bucb.bandit.fit(arms, rewards)\n", + "bts = BatchBandit(ThompsonSampling(), batch_size=batch_size)\n", + "bts.bandit.fit(arms, rewards)\n", + "\n", + "# Run batch evaluation\n", + "beg_rewards = []\n", + "bucb_rewards = []\n", + "bts_rewards = []\n", + "\n", + "beg_arms = []\n", + "bucb_arms = []\n", + "bts_arms = []\n", + "\n", + "for i in range(0, len(X), batch_size):\n", + " batch_X = X[i:i + batch_size]\n", + " batch_arms = arms[i:i + batch_size]\n", + " batch_rewards = rewards[i:i + batch_size]\n", + " \n", + " # BatchEpsilonGreedy\n", + " chosen_arms = beg.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " beg.update_batch(chosen_arms, rewards_batch)\n", + " beg_rewards.extend(rewards_batch)\n", + " beg_arms.extend(chosen_arms)\n", + " \n", + " # BatchUCB\n", + " chosen_arms = bucb.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " bucb.update_batch(chosen_arms, rewards_batch)\n", + " bucb_rewards.extend(rewards_batch)\n", + " bucb_arms.extend(chosen_arms)\n", + " \n", + " # BatchThompsonSampling\n", + " chosen_arms = bts.select_batch()\n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " bts.update_batch(chosen_arms, rewards_batch)\n", + " bts_rewards.extend(rewards_batch)\n", + " bts_arms.extend(chosen_arms)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(beg_rewards), label='BatchEpsilonGreedy')\n", + "plt.plot(np.cumsum(bucb_rewards), label='BatchUCB')\n", + "plt.plot(np.cumsum(bts_rewards), label='BatchThompsonSampling')\n", + "plt.title('Cumulative Rewards - Batch-mode Classic MAB Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "40395e20", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 6. Batch-mode Contextual MAB Models\n", + "\n", + "Finally, let's demonstrate how to use batch-mode contextual MAB models.\n", + "These models combine batch processing with contextual information." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bb766e32", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize batch-mode contextual MAB model\n", + "blinucb = BatchBandit(LinUCB(alpha=1.0), batch_size=batch_size)\n", + "blinucb.bandit.fit(X=pd.DataFrame(X, columns=feature_names), arm=arms, reward=rewards, features=feature_names)\n", + "\n", + "# Run batch evaluation\n", + "blinucb_rewards = []\n", + "blinucb_arms = []\n", + "\n", + "for i in range(0, len(X), batch_size):\n", + " batch_X = X[i:i + batch_size]\n", + " batch_arms = arms[i:i + batch_size]\n", + " batch_rewards = rewards[i:i + batch_size]\n", + " \n", + " # BatchLinUCB - process each sample in the batch individually since we need context\n", + " chosen_arms = []\n", + " rewards_batch = []\n", + " for context in batch_X:\n", + " chosen_arm = blinucb.bandit.select_arm(context)\n", + " chosen_arms.append(chosen_arm)\n", + " \n", + " rewards_batch = [r if a == b else 0 for a, b, r in zip(chosen_arms, batch_arms, batch_rewards)]\n", + " for chosen_arm, context, reward in zip(chosen_arms, batch_X, rewards_batch):\n", + " blinucb.bandit.update(chosen_arm, context, reward)\n", + " \n", + " blinucb_rewards.extend(rewards_batch)\n", + " blinucb_arms.extend(chosen_arms)\n", + "\n", + "# Plot cumulative rewards\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(blinucb_rewards), label='BatchLinUCB')\n", + "plt.title('Cumulative Rewards - Batch-mode Contextual MAB Model')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2be0a0c3", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## 7. Compare All Models\n", + "\n", + "Let's compare the performance of all models by plotting their cumulative rewards together." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3601364e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 6))\n", + "plt.plot(np.cumsum(eg_rewards), label='EpsilonGreedy', alpha=0.7)\n", + "plt.plot(np.cumsum(ucb_rewards), label='UCB', alpha=0.7)\n", + "plt.plot(np.cumsum(ts_rewards), label='ThompsonSampling', alpha=0.7)\n", + "plt.plot(np.cumsum(linucb_rewards), label='LinUCB', alpha=0.7)\n", + "plt.plot(np.cumsum(beg_rewards), label='BatchEpsilonGreedy', alpha=0.7)\n", + "plt.plot(np.cumsum(bucb_rewards), label='BatchUCB', alpha=0.7)\n", + "plt.plot(np.cumsum(bts_rewards), label='BatchThompsonSampling', alpha=0.7)\n", + "plt.plot(np.cumsum(blinucb_rewards), label='BatchLinUCB', alpha=0.7)\n", + "plt.title('Cumulative Rewards - All Models')\n", + "plt.xlabel('Time Step')\n", + "plt.ylabel('Cumulative Reward')\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "391b9005", + "metadata": { + "cell_marker": "\"\"\"", + "lines_to_next_cell": 1 + }, + "source": [ + "## 8. Arm Selection Analysis\n", + "\n", + "Let's analyze how each model distributes its arm selections." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e44a440d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate arm selection frequencies\n", + "def get_arm_frequencies(selected_arms):\n", + " return pd.Series(selected_arms).value_counts(normalize=True)\n", + "\n", + "# Plot arm selection frequencies\n", + "plt.figure(figsize=(12, 6))\n", + "n_methods = 8\n", + "bar_width = 0.8 / n_methods\n", + "x = np.arange(n_arms)\n", + "\n", + "methods = [\n", + " ('EpsilonGreedy', eg_arms),\n", + " ('UCB', ucb_arms),\n", + " ('ThompsonSampling', ts_arms),\n", + " ('LinUCB', linucb_arms),\n", + " ('BatchEpsilonGreedy', beg_arms),\n", + " ('BatchUCB', bucb_arms),\n", + " ('BatchThompsonSampling', bts_arms),\n", + " ('BatchLinUCB', blinucb_arms)\n", + "]\n", + "\n", + "for i, (name, arms) in enumerate(methods):\n", + " arm_freq = get_arm_frequencies(arms)\n", + " plt.bar(x + i * bar_width, arm_freq.values, width=bar_width, label=name)\n", + "\n", + "plt.title('Arm Selection Frequency')\n", + "plt.xlabel('Arm')\n", + "plt.ylabel('Selection Frequency')\n", + "plt.xticks(x + bar_width * (n_methods - 1) / 2, [f'Arm {i}' for i in range(n_arms)])\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show() " + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test_bandit.py b/tests/test_bandit.py new file mode 100644 index 00000000..09bdfa1a --- /dev/null +++ b/tests/test_bandit.py @@ -0,0 +1,275 @@ +""" +Tests for Multi-Armed Bandit algorithms. +""" + +import numpy as np +import pandas as pd +import pytest +from causalml.optimize import ( + EpsilonGreedy, + UCB, + ThompsonSampling, + BatchBandit, + LinUCB, + BatchLinUCB, + CohortThompsonSampling, + BatchCohortThompsonSampling +) +from causalml.dataset import make_mab_data + + +def test_make_mab_data(): + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + assert not df.empty + assert 'reward' in df.columns + assert 'arm' in df.columns + assert any(col.startswith('feature_') for col in df.columns) + assert isinstance(x_name, list) + assert len(x_name) > 0 + + +def test_epsilon_greedy_basic(): + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy(epsilon=0.1) + algo.fit(df['arm'], df['reward']) + arm = algo.select_arm() + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, 1) + + +def test_linucb_basic(): + df, x_name = make_mab_data(n_samples=10, n_arms=2, n_features=2, random_seed=123) + feature_cols = [col for col in df.columns if col.startswith('feature_')] + algo = LinUCB(alpha=1.0) + algo.fit(df, df['arm'], df['reward'], feature_cols) + context = df[feature_cols].values[0] + arm = algo.select_arm(context) + assert arm in ['arm_0', 'arm_1'] + algo.update(arm, context, 1) + + +def test_epsilon_greedy(): + """Test Epsilon Greedy algorithm.""" + # Create test data + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + + # Initialize bandit + bandit = EpsilonGreedy(epsilon=0.1) + bandit.fit(arms, rewards) + + # Test initialization + assert bandit.epsilon == 0.1 + assert len(bandit.arms) == 3 + assert all(arm in bandit.n_pulls for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.n_pulls[arm] >= 1 + assert bandit.rewards[arm] >= 0 + assert bandit.arm_values[arm] >= 0 + + +def test_ucb(): + """Test UCB algorithm.""" + # Create test data + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + + # Initialize bandit + bandit = UCB(alpha=1.0) + bandit.fit(arms, rewards) + + # Test initialization + assert bandit.alpha == 1.0 + assert len(bandit.arms) == 3 + + # Test initial arm selection (should select unexplored arms first) + for _ in range(len(bandit.arms)): + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + bandit.update(arm, 1.0) + + # Test UCB value calculation + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + +def test_thompson_sampling(): + """Test Thompson Sampling algorithm.""" + # Create test data + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + + # Initialize bandit + bandit = ThompsonSampling() + bandit.fit(arms, rewards) + + # Test initialization + assert len(bandit.arms) == 3 + assert all(arm in bandit.alpha for arm in bandit.arms) + assert all(arm in bandit.beta for arm in bandit.arms) + + # Test arm selection + arm = bandit.select_arm() + assert isinstance(arm, str) + assert arm in bandit.arms + + # Test update + reward = 1.0 + bandit.update(arm, reward) + assert bandit.alpha[arm] >= 1.0 + assert bandit.beta[arm] >= 1.0 + + +def test_batch_bandit(): + """Test Batch Bandit wrapper.""" + # Create test data + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + + # Initialize bandits + base_bandit = EpsilonGreedy(epsilon=0.1) + base_bandit.fit(arms, rewards) + batch_bandit = BatchBandit(base_bandit, batch_size=2) + + # Test batch selection + arms = batch_bandit.select_batch() + assert len(arms) == 2 + assert all(isinstance(arm, str) for arm in arms) + assert all(arm in base_bandit.arms for arm in arms) + + # Test batch update + rewards = [1.0, 0.5] + total_pulls_before = sum(base_bandit.n_pulls.values()) + batch_bandit.update_batch(arms, rewards) + total_pulls_after = sum(base_bandit.n_pulls.values()) + assert total_pulls_after - total_pulls_before == 2 + + +def test_cohort_thompson_sampling(): + """Test Cohort Thompson Sampling algorithm.""" + n_samples = 30 + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * 10) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * 10) + cohorts = np.random.choice([0, 1, 2], n_samples) + X = pd.DataFrame({'cohort': cohorts}) + bandit = CohortThompsonSampling() + bandit.fit(X, arms, rewards, 'cohort') + context = np.array([cohorts[0]]) + arm = bandit.select_arm(context) + assert isinstance(arm, str) + assert arm in bandit.arms + reward = 1.0 + bandit.update(arm, context, reward) + + +def test_batch_linucb(): + """Test Batch LinUCB algorithm.""" + # Create test data + n_samples = 100 + n_features = 2 + X = np.random.normal(0, 1, (n_samples, n_features)) + arms = np.array(['arm_0', 'arm_1'] * (n_samples // 2)) + rewards = np.random.binomial(1, 0.5, n_samples) + + # Initialize bandit + bandit = BatchLinUCB(alpha=1.0, batch_size=10) + bandit.fit(X, arms, rewards) + + # Test batch selection + selected_arms = bandit.select_arm(X[:10]) + assert len(selected_arms) == 10 + assert all(isinstance(arm, str) for arm in selected_arms) + assert all(arm in ['arm_0', 'arm_1'] for arm in selected_arms) + + # Test batch update + batch_rewards = np.random.binomial(1, 0.5, 10) + bandit.update_batch(np.array(selected_arms), X[:10], batch_rewards) + + +def test_batch_cohort_thompson_sampling(): + """Test Batch Cohort Thompson Sampling algorithm.""" + # Create test data + n_samples = 100 + X = np.random.normal(0, 1, (n_samples, 1)) # One feature for cohorts + arms = np.array(['arm_0', 'arm_1'] * (n_samples // 2)) + rewards = np.random.binomial(1, 0.5, n_samples) + cohorts = np.random.choice([0, 1, 2], n_samples) + + # Initialize bandit + bandit = BatchCohortThompsonSampling(batch_size=10) + bandit.fit(X, arms, rewards, cohort_feature=cohorts) + + # Test batch selection + selected_arms = bandit.select_arm_batch(cohorts[:10]) + assert len(selected_arms) == 10 + assert all(isinstance(arm, str) for arm in selected_arms) + assert all(arm in ['arm_0', 'arm_1'] for arm in selected_arms) + + # Test batch update + batch_rewards = np.random.binomial(1, 0.5, 10) + bandit.update_batch(cohorts[:10], selected_arms, batch_rewards) + + +def test_bandit_convergence(): + """Test that bandits converge to the best arm.""" + # Create test data + n_samples = 5000 + arms = np.array(['arm_0', 'arm_1', 'arm_2'] * (n_samples // 3)) + rewards = np.random.binomial(1, [0.1, 0.5, 0.9] * (n_samples // 3)) + + # Test each algorithm + algorithms = [ + EpsilonGreedy(epsilon=0.1), + UCB(alpha=1.0), + ThompsonSampling() + ] + + for bandit in algorithms: + bandit.fit(arms, rewards) + for _ in range(100): + arm = bandit.select_arm() + reward = np.random.binomial(1, 0.9 if arm == 'arm_2' else 0.1) + bandit.update(arm, reward) + + # Print average rewards for debugging + print('Average rewards:', bandit.arm_values) + # Check if best arm is in the set of arms + best_arm = max(bandit.arm_values.items(), key=lambda x: x[1])[0] + assert best_arm in bandit.arms + + +def test_epsilon_greedy_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = EpsilonGreedy() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) + + +def test_ucb_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = UCB() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) + + +def test_thompson_sampling_fit_predict(): + df, x_name = make_mab_data(n_samples=100, n_arms=2, n_features=2, random_seed=123) + algo = ThompsonSampling() + algo.fit(df['arm'], df['reward']) + preds = algo.predict(n_samples=100) + assert len(preds) == 100 + assert all([p in ['arm_0', 'arm_1'] for p in preds]) \ No newline at end of file