diff --git a/pybalance/lp/matcher.py b/pybalance/lp/matcher.py index b62d72e..22c6eab 100644 --- a/pybalance/lp/matcher.py +++ b/pybalance/lp/matcher.py @@ -29,7 +29,7 @@ def compute_truncation_error(x: np.ndarray) -> float: def _rescale_for_discretization( - target: np.array, pool: np.array, tolerance: float = 0.01 + target: np.array, pool: np.array, tolerance: float = 0.01, min_factor=100 ): """ Find a scale factor that allows one to convert datasets to integer datatypes @@ -49,7 +49,7 @@ def _rescale_for_discretization( # Ideally, no scaling is required at all, e.g., if everything is already # an integer. Start with an initial scaling of 1 and increase as needed # to find the right scale. - scalefac = 1 + scalefac = min_factor # Keep increasing the scale factor until the (worst) truncation error is # less than the specified tolerance. @@ -69,15 +69,16 @@ def _rescale_for_discretization( target = (scalefac * target).astype(int).tolist() pool = (scalefac * pool).astype(int).tolist() - return target, pool + return target, pool, scalefac class SolutionPrinter(cp_model.CpSolverSolutionCallback): """Print intermediate solutions.""" - def __init__(self, ind, deltas, matcher): + def __init__(self, pool, target, deltas, matcher): cp_model.CpSolverSolutionCallback.__init__(self) - self.__ind = ind + self.__pool = pool + self.__target = target self.__deltas = deltas self.__solution_count = 0 self.__start_time = time.time() @@ -99,21 +100,32 @@ def on_solution_callback(self): ) logger.info(f"Objective:\t{self.ObjectiveValue()}") - indices = [] - for i in range(len(self.__ind)): - if self.Value(self.__ind[i]): - indices.append(i) - self.solutions.append(indices) + indices_pool = [] + for i in range(len(self.__pool)): + if self.Value(self.__pool[i]): + indices_pool.append(i) + + indices_target = [] + for i in range(len(self.__target)): + if self.Value(self.__target[i]): + indices_target.append(i) + + self.solutions.append({"pool": indices_pool, "target": indices_target}) if self.balance_calculator is not None: # ---- Get indices of patients ----# - balance = self.balance_calculator.distance(indices) + balance = self.balance_calculator.distance(indices_pool, indices_target) self.balance_scores.append(balance) - logger.info(f"Balance:\t{balance:.4f}") + logger.info( + f"Balance ({self.matcher.balance_calculator.name}):\t{balance:.4f}" + ) # ---- Print Deltas per feature ----# - logger.info(f"Patients:\t{sum([self.Value(x) for x in self.__ind])}") + logger.info(f"Patients (pool):\t{sum([self.Value(x) for x in self.__pool])}") + logger.info( + f"Patients (target):\t{sum([self.Value(x) for x in self.__target])}" + ) # ---- Print Deltas per feature ----# # Don't touch this code. You may think it is written by a crazy person, @@ -135,7 +147,33 @@ def solution_count(self): class ConstraintSatisfactionMatcher(object): """ - Constructs the class patient selection class. + Population matching based on constraint satisfication formulation. This solver + can only handle linear objective functions; see "objective" parameter below. + + The constraints and optimization target are specified to the solver via the + options pool_size, target_size, and max_mismatch. The behavior of the solver is + as given in the table below: + + ------------------------------------------------------------------------------ + pool_size target_size max_mismatch optimize + ------------------------------------------------------------------------------ + N N Y pool_size subject to target_size = n_target + and balance constraints + Y Y Y balance subject to size and balance + constraints + Y Y N balance subject to size constraints + N N N balance subject to size constraints; default + to pool_size = target_size = n_target + ------------------------------------------------------------------------------ + Y N Y not suported + N Y Y not suported + Y N N not suported + N Y N not suported + ------------------------------------------------------------------------------ + + Optimizing pool_size subject to balance constraint is known as "cardinality + matching". See https://kosukeimai.github.io/MatchIt/reference/method_cardinality.html + and references therein. :param matching_data: A MatchingData object describing the pool and target populations. See utils.matching_data. @@ -149,8 +187,27 @@ class ConstraintSatisfactionMatcher(object): function). The solver will optimize the absolute mean difference on the output features of the balance calculator's preprocessing. - :param match_size: How large the match population should be. If passed as a - float, interpreted to be a fraction of the target population. + :param match_size: Number of samples to include in the matched population. + If match_size < size of target population, then the target is subsetted + to be the same size, that is, pool_size = target_size = match_size. If + match_size >= size of target population, then the full target is used + and only the pool is subsetted, that is, pool_size = match_size and + target_size = n_target. This option cannot be used in combination + with pool_size or target_size. This option is deprecated and will be + removed in a later release. + + :param pool_size: Number of samples to include from the pool in the matched + population. Must be less than the size of the pool. If pool_size is not set, + then max_mismatch and target_size must be set and pool_size will be optimized + subject to the target_size and max_mismatch constraints. + + :param target_size: Number of samples to include from the target in the matched + population. Must be less than or equal to the size of the target. + If target_size is not set,then max_mismatch and pool_size must be set and + target_size will be optimized subject to the pool_size and max_mismatch + constraints. + + :param max_mismatch: Maximum allowable absolute mean difference for any feature. :param time_limit: Time limit to stop solving in seconds (def: 180 sec). @@ -168,7 +225,10 @@ def __init__( self, matching_data: MatchingData, objective: Union[str, BaseBalanceCalculator] = "beta", - match_size: int = None, + match_size: Optional[int] = None, + pool_size: Optional[int] = None, + target_size: Optional[int] = None, + max_mismatch: Optional[float] = None, time_limit: float = 180, num_workers: int = 4, ps_hinting: bool = False, @@ -197,7 +257,7 @@ def __init__( self.n_target, self.n_pool = len(target), len(pool) self.n_features = len(target[0]) self.weights = self.get_weights() - self.target, self.pool = _rescale_for_discretization( + self.target, self.pool, self.scalefac = _rescale_for_discretization( target * self.weights, pool * self.weights, tolerance=0.01 ) @@ -209,35 +269,79 @@ def __init__( self.n_target < self.n_pool ), "Number of patients in treatment arm should be equal or less then control." - self.match_size = match_size + self.pool_size, self.target_size = self._get_pool_size_target_size( + pool_size, target_size, match_size, max_mismatch + ) + self.max_mismatch = max_mismatch self.time_limit = time_limit self.num_workers = num_workers self.ps_hinting = ps_hinting self.verbose = verbose - self._check_params() - self.ref_features = [ + self.target_features = [ sum([t[f] for t in self.target]) for f in range(self.n_features) ] self._reset_best_match() - def _check_params(self): - # set match size - if self.match_size is not None: - if not self.match_size <= self.n_target: + def _get_pool_size_target_size( + self, pool_size, target_size, match_size, max_mismatch + ): + if match_size is not None: + logger.warning( + "Option match_size is deprecated and will be removed in a later release. Use pool_size and target_size instead." + ) + if pool_size is not None or target_size is not None: + raise ValueError( + "Cannot use match_size in combination with pool_size or target_size." + ) + if match_size < self.n_target: + target_size = pool_size = match_size + else: + target_size = self.n_target + pool_size = match_size + + if max_mismatch is not None: + if target_size is not None and pool_size is not None: + # solving for balance with size and balance constaints + target_size = target_size + pool_size = pool_size + elif target_size is None and pool_size is None: + # solving for size with balance constaints + target_size = self.n_target + pool_size = pool_size + else: raise ValueError( - "Match size must not be greater than target population size." + "If max_mismatch is passed, then either both or none of target_size and pool_size must be passed." ) - if self.match_size <= 1: - # Assume it represents a fraction of the target size - self.match_size = int(self.match_size * self.n_target) else: - self.match_size = self.n_target + if target_size is not None and pool_size is not None: + # solving for balance with size constaints + target_size = target_size + pool_size = pool_size + elif target_size is None and pool_size is None: + # solving for balance with size constaints + target_size = self.n_target + pool_size = self.n_target + else: + raise ValueError( + "If max_mismatch is passed, then either both or none of target_size and pool_size must be passed." + ) + + if pool_size is not None and pool_size >= self.n_pool: + raise ValueError("pool_size must be less than the size of pool population") + if target_size > self.n_target: + raise ValueError( + "target_size must be less than or equal to the size of target population" + ) + + return pool_size, target_size def get_params(self): params = [ "objective", - "match_size", + "pool_size", + "target_size", + "max_mismatch", "time_limit", "num_workers", "ps_hinting", @@ -264,18 +368,18 @@ def get_weights(self): return weights - def _get_limits(self, f, match_size=None): + def _get_limits(self, i, match_size=None): if match_size is None: match_size = self.n_target - weight = self.weights[f] + weight = self.weights[i] # sort feature values ascending - pool_features = sorted([p[f] for p in self.pool]) + pool_features = sorted([p[i] for p in self.pool]) min_pool_feature = sum(pool_features[:match_size]) max_pool_feature = sum(pool_features[-match_size:]) - target_feature_values = sorted([p[f] for p in self.target]) + target_feature_values = sorted([p[i] for p in self.target]) min_target_feature = sum(target_feature_values[:match_size]) max_target_feature = sum(target_feature_values[-match_size:]) @@ -293,9 +397,6 @@ def _get_limits(self, f, match_size=None): min_feature = min(min_target_feature, min_pool_feature) max_feature = max(max_target_feature, max_pool_feature) - feat = self.balance_calculator.preprocessor.output_headers["all"][f] - logger.debug(f"Feature limits: [{min_feature}, {max_feature}] {feat}") - return min_feature, max_feature, max_delta def match(self, hint: Optional[List[int]] = None) -> MatchingData: @@ -314,17 +415,17 @@ def match(self, hint: Optional[List[int]] = None) -> MatchingData: I admit the interface here is a bit confusing. We will clean this up in a later release. """ - time_limit = self.time_limit - logger.info( - f"Solving for match population with size = {self.match_size}. Will match on {self.n_features} dimensions ..." + f"Solving for match population with pool size = {self.pool_size} and target size = {self.target_size} subject to {self.max_mismatch} balance constraint." ) + logger.info(f"Matching on {self.n_features} dimensions ...") # ========= Create Model===========# model = cp_model.CpModel() # ========= Variables===========# - # --- Binary flag for inclusion of patients ---------# + # Binary flag for inclusion of patients + logger.info("Building model variables and constraints ...") x = [] # pool y = [] # target for i in range(self.n_pool): @@ -332,43 +433,104 @@ def match(self, hint: Optional[List[int]] = None) -> MatchingData: for i in range(self.n_target): y.append(model.NewBoolVar(f"y[{i}]")) + # Calculate some loose bounds for variables to make solver more efficient logger.info("Calculating bounds on feature variables ...") + bounds_abs_deltas = [] + bounds_features_min = [] + bounds_features_max = [] + for i in range(self.n_features): + min_feature, max_feature, max_delta = self._get_limits(i, self.n_pool) + bounds_features_min.append(-10 * abs(min_feature)) + bounds_features_max.append(10 * abs(max_feature)) + # I'm less confident in the bounds here, bad bounds can lead to bad + # results and even infeasibility. We add a little padding factor + bounds_abs_deltas.append(10 * self.n_pool * self.n_target * max_delta) + + feat = self.balance_calculator.preprocessor.output_headers["all"][i] + logger.debug( + f"Feature limits: [{bounds_features_min[-1]}, {bounds_features_max[-1]}] {feat} (max delta: {bounds_abs_deltas[-1]})" + ) + # Variables for calculating mean absolute difference per feature abs_deltas = [] - features = [] - ref_features = [] deltas = [] + pool_features = [] + target_features = [] for i in range(self.n_features): - min_feature, max_feature, max_delta = self._get_limits(i, self.match_size) - abs_deltas.append(model.NewIntVar(0, max_delta, f"abs_deltas[{i}]")) - features.append(model.NewIntVar(min_feature, max_feature, f"features[{i}]")) - deltas.append(model.NewIntVar(-max_delta, max_delta, f"deltas[{i}]")) - ref_features.append( - model.NewIntVar(min_feature, max_feature, f"ref_features[{i}]") + + abs_deltas.append( + model.NewIntVar(0, bounds_abs_deltas[i], f"abs_deltas[{i}]") + ) + pool_features.append( + model.NewIntVar( + bounds_features_min[i], + bounds_features_max[i], + f"pool_features[{i}]", + ) + ) + deltas.append( + model.NewIntVar( + -bounds_abs_deltas[i], bounds_abs_deltas[i], f"deltas[{i}]" + ) ) + # If pool_size is not set, then we are solving for it. In this case, the target + # must be fixed to maintain linearity in the constraints. + if self.pool_size is not None: + target_features.append( + model.NewIntVar( + bounds_features_min[i], + bounds_features_max[i], + f"target_features[{i}]", + ) + ) + else: + target_features.append(self.target_features[i]) - logger.info("Applying constraints ...") + target_size = self.target_size # always a literal + # If pool_size is not set, then we are solving for it. + # Add size variables for pool + if self.pool_size is None: + pool_size = model.NewIntVar(1, self.n_pool, "n_pool") + else: + pool_size = self.pool_size # ========= Constraints===========# for j in range(self.n_features): # --- aggregate for feature j ---------# model.Add( - sum(self.pool[i][j] * x[i] for i in range(self.n_pool)) == features[j] + sum(self.pool[i][j] * x[i] for i in range(self.n_pool)) + == pool_features[j] ) model.Add( sum(self.target[i][j] * y[i] for i in range(self.n_target)) - == ref_features[j] + == target_features[j] + ) + model.Add( + self.weights[j] + * (target_size * pool_features[j] - pool_size * target_features[j]) + == deltas[j] ) # --- Taxicab distance ---------# - model.Add(self.weights[j] * (features[j] - ref_features[j]) == deltas[j]) model.AddAbsEquality(abs_deltas[j], deltas[j]) + if self.max_mismatch is not None: + logger.debug( + f"Applying mismatch <= {self.max_mismatch} constraint on feature {i} ..." + ) + model.Add( + abs_deltas[j] + <= self.target_size + * pool_size + * int(self.scalefac * self.max_mismatch) + ) # --- Cardinality ---------# - model.Add(sum(x[i] for i in range(self.n_pool)) == self.match_size) - model.Add(sum(y[i] for i in range(self.n_target)) == self.match_size) + logger.info(f"Applying size constraints on pool and target ...") + model.Add(sum(x) == pool_size) + model.Add(sum(y) == target_size) # ========= Hint! ==============# if self.ps_hinting or hint is not None: + logger.info(f"Applying hint ...") matching_data = self.matching_data.copy() target, pool = split_target_pool(matching_data) target_name = target[matching_data.population_col].unique()[0] @@ -428,12 +590,15 @@ def match(self, hint: Optional[List[int]] = None) -> MatchingData: model.AddHint(var, 0) # ========= Objective===========# - model.Minimize(sum(abs_deltas)) + if self.pool_size is not None: + model.Minimize(sum(abs_deltas)) + else: + model.Minimize(self.n_pool - sum(x)) # ===== Creates a solver =======# solver = cp_model.CpSolver() - if time_limit is not None: - solver.parameters.max_time_in_seconds = time_limit + if self.time_limit is not None: + solver.parameters.max_time_in_seconds = self.time_limit solver.parameters.num_workers = min( self.num_workers, multiprocessing.cpu_count() @@ -448,7 +613,7 @@ def match(self, hint: Optional[List[int]] = None) -> MatchingData: # ----- Append the important stuff for printing -----# if self.verbose: - solution_printer = SolutionPrinter(x, abs_deltas, self) + solution_printer = SolutionPrinter(x, y, abs_deltas, self) status = solver.Solve(model, solution_printer) logger.info("Status = %s" % solver.StatusName(status)) logger.info( @@ -477,350 +642,3 @@ def match(self, hint: Optional[List[int]] = None) -> MatchingData: def get_best_match(self): _check_fitted(self) return self.best_match - - -class CardinalityMatcher(object): - """ - CardinalityMatcher implements a matcher that, rather than optimizing balance - subject to size constraints like ConstraintSatisfactionMatcher, optimizes - matching size subject to balance constraints. - - See https://kosukeimai.github.io/MatchIt/reference/method_cardinality.html - and references therein. - - :param matching_data: A MatchingData object describing the pool and target - populations. See utils.matching_data. - - :param objective: Matching objective to optimize. Technically, you can pass - any balance calculator, but this solver cannot handle non-linear - objective functions. The solver uses the preprocessing from the balance - calculator for setting up the problem; the balance calculator itself is - used to report the balance of generated matches but not in actually - finding solutions (since the CS solver needs a discretized objective - function). The solver will optimize the absolute mean difference on the - output features of the balance calculator's preprocessing. - - :param match_size: How large the match population should be. If passed as a - float, interpreted to be a fraction of the target population. - - :param time_limit: Time limit to stop solving in seconds (def: 180 sec). - - :param num_workers: Number of workers to use to optimize objective. See - https://github.com/google/or-tools/blob/stable/ortools/sat/sat_parameters.proto#L556 - for more detail. - - :param ps_hinting: Compute a propensity score match and use the result as a - hint for the solver - - :param verbose: Verbose solving. - """ - - def __init__( - self, - matching_data: MatchingData, - objective: Union[str, BaseBalanceCalculator] = "beta", - match_size: int = None, - time_limit: float = 180, - num_workers: int = 4, - ps_hinting: bool = False, - verbose: bool = True, - ): - self.matching_data = matching_data.copy() - self.orig_target, self.orig_pool = split_target_pool(self.matching_data) - - if isinstance(objective, str): - self.balance_calculator = BalanceCalculator(self.matching_data, objective) - self.objective = objective - else: - self.balance_calculator = objective - self.objective = self.balance_calculator.name - - target, pool = ( - self.balance_calculator.target.cpu().numpy(), - self.balance_calculator.pool.cpu().numpy(), - ) - # We will have to rescale everything to use an integer solver. If - # features are not normalized, then features with larger overall scale - # end up being emphasized more in the objective function. - scaler = MinMaxScaler() - target = scaler.fit_transform(target) - pool = scaler.transform(pool) - self.n_target, self.n_pool = len(target), len(pool) - self.n_features = len(target[0]) - self.weights = self.get_weights() - self.scalefac = _get_scaling_factor(target * self.weights, pool * self.weights, tolerance=0.01) - self.target = (self.scalefac * target).astype(int).tolist() - self.pool = (self.scalefac * pool).astype(int).tolist() - # self.mut = self.target.mean(axis=0) - # self.sigmat = self.target.std(axis=0) - - # ===== Sanity Check ======# - assert len(self.target[0]) == len( - self.pool[0] - ), "The number of features should be the same in both reference population and input!" - assert ( - self.n_target < self.n_pool - ), "Number of patients in treatment arm should be equal or less then control." - - self.match_size = match_size - self.time_limit = time_limit - self.num_workers = num_workers - self.ps_hinting = ps_hinting - self.verbose = verbose - self._check_params() - - self.ref_features = [ - sum([t[f] for t in self.target]) for f in range(self.n_features) - ] - self._reset_best_match() - - def _check_params(self): - # set match size - if self.match_size is not None: - if not self.match_size <= self.n_target: - raise ValueError( - "Match size must not be greater than target population size." - ) - if self.match_size <= 1: - # Assume it represents a fraction of the target size - self.match_size = int(self.match_size * self.n_target) - else: - self.match_size = self.n_target - - def get_params(self): - params = [ - "objective", - "match_size", - "time_limit", - "num_workers", - "ps_hinting", - "verbose", - ] - return dict((p, getattr(self, p)) for p in params) - - def _reset_best_match(self): - self.best_match = None - self.best_match_idx = None - self.best_score = np.inf - - def get_weights(self): - if hasattr(self.balance_calculator.preprocessor, "feature_weights"): - weights = self.balance_calculator.preprocessor.feature_weights.cpu().numpy() - min_nonzero_weight = min([w for w in weights if w > 0]) - weights = [int(10 * w / min_nonzero_weight) for w in weights] - else: - weights = [1] * self.n_features - - headers = self.balance_calculator.preprocessor.output_headers["all"] - for feat, weight in zip(headers, weights): - logger.debug(f"Feature weights: {weight:6d} {feat}") - - return weights - - def _get_limits(self, f, match_size=None): - if match_size is None: - match_size = self.n_target - - weight = self.weights[f] - - # sort feature values ascending - pool_features = sorted([p[f] for p in self.pool]) - min_pool_feature = sum(pool_features[:match_size]) - max_pool_feature = sum(pool_features[-match_size:]) - - target_feature_values = sorted([p[f] for p in self.target]) - min_target_feature = sum(target_feature_values[:match_size]) - max_target_feature = sum(target_feature_values[-match_size:]) - - max_delta = weight * max( - abs(max_pool_feature - min_target_feature), - abs(max_target_feature - min_pool_feature), - ) - - if max_delta >= 2**50: - logger.warning(f"Inferred max_delta = {max_delta}.") - logger.warning( - "Feature dynamic range may exceed integer dynamic range and lead to suboptimal solutions." - ) - - min_feature = min(min_target_feature, min_pool_feature) - max_feature = max(max_target_feature, max_pool_feature) - - feat = self.balance_calculator.preprocessor.output_headers["all"][f] - logger.debug(f"Feature limits: [{min_feature}, {max_feature}] {feat}") - - return min_feature, max_feature, max_delta - - def match(self, threshold=0.1, hint: Optional[List[int]] = None) -> MatchingData: - """ - Match populations passed during __init__(). Returns MatchingData - instance containing the matched pool and target populations. - - :param hint: You can supply a "hint" as either (1) A list of indices to - the pool. It will be assumed that the entire target is used, or (2) - A list of two lists, the first list being the indices to the target, - and the second being the indices to the pool, or (3) by omitting the - hint altoghether and passing ps_hinting=True in __init__(). In case - (3), a propensity score model will be estimated on the fly and used - to create a match population as a hint to the solver. - - I admit the interface here is a bit confusing. We will clean this - up in a later release. - """ - time_limit = self.time_limit - - logger.info( - f"Solving for match population with size = {self.match_size}. Will match on {self.n_features} dimensions ..." - ) - - # ========= Create Model===========# - model = cp_model.CpModel() - - # ========= Variables===========# - # --- Binary flag for inclusion of patients ---------# - x = [] # pool - for i in range(self.n_pool): - x.append(model.NewBoolVar(f"x[{i}]")) - - logger.info(f"Calculating bounds on feature variables ...") - - abs_deltas = [] - features = [] - deltas = [] - max_n = int(self.n_pool / self.n_target) - n = model.NewIntVar(1, max_n, f"n") - - for i in range(self.n_features): - min_feature, max_feature, max_delta = self._get_limits(i, max_n * self.n_target) - abs_deltas.append(model.NewIntVar(0, max_delta, f"abs_deltas[{i}]")) - features.append(model.NewIntVar(min_feature, max_feature, f"features[{i}]")) - deltas.append(model.NewIntVar(-max_delta, max_delta, f"deltas[{i}]")) - - logger.info(f"Applying constraints ...") - - # ========= Constraints===========# - for j in range(self.n_features): - # --- aggregate for feature j ---------# - model.Add( - sum(self.pool[i][j] * x[i] for i in range(self.n_pool)) == features[j] - ) - # --- Taxicab distance ---------# - model.Add(self.weights[j] * (features[j] - n * self.ref_features[j]) == deltas[j]) - model.AddAbsEquality(abs_deltas[j], deltas[j]) - model.Add(abs_deltas[j] <= n * int(self.n_target * self.scalefac * threshold) ) - - print(int(self.n_target * self.scalefac * threshold)) - - # --- Cardinality ---------# - model.Add( sum(x[i] for i in range(self.n_pool)) == n * self.n_target ) - - # ========= Hint! ==============# - if self.ps_hinting or hint is not None: - matching_data = self.matching_data.copy() - target, pool = split_target_pool(matching_data) - target_name = target[matching_data.population_col].unique()[0] - pool_name = pool[matching_data.population_col].unique()[0] - - if hint is None: - logger.info("Training PS model as guide for solver ...") - - target.loc[:, "ix"] = list(range(len(target))) - pool.loc[:, "ix"] = list(range(len(pool))) - matching_data = MatchingData( - pd.concat([target, pool]), headers=self.matching_data.headers - ) - ps_matcher = PropensityScoreMatcher( - matching_data, objective=self.objective - ) - ps_match = ps_matcher.match() - - target_hint = ( - ps_match.data[ps_match.data.population == target_name] - .ix.astype(int) - .tolist() - ) - pool_hint = ( - ps_match.data[ps_match.data.population == pool_name] - .ix.astype(int) - .tolist() - ) - else: - if len(hint) == 2: - target_hint, pool_hint = hint - else: - target_hint = [1] * len(target) - pool_hint = hint - - # Kind of sanity check that the indices are aligned between what - # comes out of the PS solver and what we will apply as hints - obj = 0 - for j in range(self.n_features): - feat = sum(self.pool[i][j] for i in pool_hint) - ref = sum(self.target[i][j] for i in target_hint) - delta = self.weights[j] * abs(feat - ref) - obj += delta - logger.info(f"Hint achieves objective value = {obj}.") - - logger.info("Applying hints ...") - for i, var in enumerate(x): - if i in pool_hint: - model.AddHint(var, 1) - else: - model.AddHint(var, 0) - - for i, var in enumerate(y): - if i in target_hint: - model.AddHint(var, 1) - else: - model.AddHint(var, 0) - - # ========= Objective===========# - model.Minimize(- sum(x) ) #+ sum(deltas) ) - - # ===== Creates a solver =======# - solver = cp_model.CpSolver() - if not time_limit is None: - solver.parameters.max_time_in_seconds = time_limit - - solver.parameters.num_workers = min( - self.num_workers, multiprocessing.cpu_count() - ) - if solver.parameters.num_workers != 1: - solver.parameters.log_search_progress = False - solver.parameters.share_objective_bounds = True - solver.parameters.share_level_zero_bounds = True - - logger.info("Solving with %d workers ..." % solver.parameters.num_workers) - # ========= Solve===========# - # ----- Append the important stuff for printing -----# - - if self.verbose: - solution_printer = SolutionPrinter(x, abs_deltas, self) - status = solver.SolveWithSolutionCallback(model, solution_printer) - logger.info("Status = %s" % solver.StatusName(status)) - logger.info( - "Number of solutions found: %i" % solution_printer.solution_count() - ) - else: - status = solver.Solve(model) - - if solver.StatusName(status) in ["FEASIBLE", "OPTIMAL"]: - pool_indices = [j for j, i in enumerate(x) if solver.Value(i)] - pool = self.orig_pool.iloc[pool_indices] - # target_indices = [j for j, i in enumerate(y) if solver.Value(i)] - target = self.orig_target#.iloc[target_indices] - match = MatchingData( - data=pd.concat([target, pool]), - headers=self.matching_data.headers, - population_col=self.matching_data.population_col, - ) - else: - match = self.matching_data - - self.best_match = match - - return match - - def get_best_match(self): - _check_fitted(self) - return self.best_match \ No newline at end of file diff --git a/pybalance/visualization/distributions.py b/pybalance/visualization/distributions.py index abbf2c1..3c6bf69 100644 --- a/pybalance/visualization/distributions.py +++ b/pybalance/visualization/distributions.py @@ -200,7 +200,9 @@ def plot_binary_features( """ # FIXME this should be renamed to something like plot_difference_binary_features if len(matching_data.populations) < 2: - raise ValueError('plot_binary_features() only implemented for MatchingData with >= 2 populations.') + raise ValueError( + "plot_binary_features() only implemented for MatchingData with >= 2 populations." + ) if reference_population is None: reference_population = _get_reference_population(matching_data) diff --git a/sphinx/02_demos.rst b/sphinx/02_demos.rst index 3f9966a..2b3213a 100644 --- a/sphinx/02_demos.rst +++ b/sphinx/02_demos.rst @@ -8,4 +8,5 @@ Demos demos/balance_calculators.ipynb demos/ps_matcher.ipynb demos/ea_matcher.ipynb - demos/lp_matcher.ipynb \ No newline at end of file + demos/lp_matcher.ipynb + demos/card_matcher.ipynb \ No newline at end of file diff --git a/sphinx/demos/cardinality_matcher.ipynb b/sphinx/demos/cardinality_matcher.ipynb new file mode 100644 index 0000000..6cec374 --- /dev/null +++ b/sphinx/demos/cardinality_matcher.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "47d6b3c6-2bc8-4091-8108-ae6f8f2167a9", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "logging.basicConfig(level='INFO')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b83085cf-5a4d-4db3-85ff-317d6e376735", + "metadata": {}, + "outputs": [], + "source": [ + "from pybalance.utils.balance_calculators import *\n", + "from pybalance.utils import MatchingData\n", + "from pybalance.sim import generate_toy_dataset, load_paper_dataset\n", + "from pybalance.lp import ConstraintSatisfactionMatcher\n", + "from pybalance.visualization import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2e8252d9-3a36-44c4-9bbd-c01349be440e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " Headers Numeric:
\n", + " ['age', 'height', 'weight']

\n", + " Headers Categoric:
\n", + " ['gender', 'haircolor', 'country', 'binary_0', 'binary_1', 'binary_2', 'binary_3']

\n", + " Populations
\n", + " ['pool', 'target']
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageheightweightgenderhaircolorcountrypopulationbinary_0binary_1binary_2binary_3patient_id
062.731988130.81697276.1004010.004pool00010
126.403338130.78418880.1344231.012pool00011
258.155044175.70496190.8067450.014pool00002
368.334248167.48598490.0817770.004pool00013
454.114518130.78207353.6121741.011pool01014
.......................................
99521.474205168.60254670.3421280.025target000115995
99640.643320188.18872461.6117440.024target100115996
99729.472765161.40816257.2140950.001target011115997
99841.291949150.96883391.2707980.003target000015998
99967.530294155.12474156.1965051.001target100015999
\n", + "

16000 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = generate_toy_dataset(n_pool=15000, n_target=1000)\n", + "m" + ] + }, + { + "cell_type": "markdown", + "id": "4e699cd6-9f4c-4493-a261-0a704f288c64", + "metadata": {}, + "source": [ + "# Solve for largest subset of pool subject to balance constraint" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6c359b7f-c658-47fd-847f-834b221b7b0a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", + "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", + "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", + "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", + "INFO:pybalance.lp.matcher:Solving for match population with pool size = None and target size = 1000 subject to 0.05 balance constraint.\n", + "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", + "INFO:pybalance.lp.matcher:Building model variables and constraints ...\n", + "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", + "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", + "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.34 m\n", + "INFO:pybalance.lp.matcher:Objective:\t13153.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0117\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t1847\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.45 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12981.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0280\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2019\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12979.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0382\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2021\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 0.49 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12909.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0380\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2091\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 0.51 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12879.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0383\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2121\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 0.85 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12827.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0387\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2173\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 7, time = 1.94 m\n", + "INFO:pybalance.lp.matcher:Objective:\t11000.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0648\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4000\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 8, time = 2.10 m\n", + "INFO:pybalance.lp.matcher:Objective:\t10818.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0704\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:Status = FEASIBLE\n", + "INFO:pybalance.lp.matcher:Number of solutions found: 8\n" + ] + } + ], + "source": [ + "matcher = ConstraintSatisfactionMatcher(\n", + " matching_data=m, \n", + " objective='gamma', \n", + " max_mismatch=0.05, \n", + " time_limit=600\n", + ")\n", + "match_card = matcher.match()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a76e9375-d27f-4f9d-aea4-27d1f7e7a483", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", + "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", + "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" + ] + }, + { + "data": { + "text/plain": [ + "tensor(0.0500)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gamma = GammaBalance(m, standardize_difference=False)\n", + "gamma.per_feature_loss(match_card.get_population('pool')).max()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d6a1bdf3-37ec-4e9a-9e62-16e459ab7361", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "fig = plot_numeric_features(match_card)\n", + "fig = plot_categoric_features(match_card)" + ] + }, + { + "cell_type": "markdown", + "id": "ce715a25-d006-419d-ab1b-c6dfe3e77c29", + "metadata": {}, + "source": [ + "# Optimize match among all subsets of a fixed size with balance constraint" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "77b744e0-ae57-4e7e-9f85-6dffdec574ae", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", + "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", + "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", + "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", + "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to 0.05 balance constraint.\n", + "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", + "INFO:pybalance.lp.matcher:Building model variables and constraints ...\n", + "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", + "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", + "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.25 m\n", + "INFO:pybalance.lp.matcher:Objective:\t825443200.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.31 m\n", + "INFO:pybalance.lp.matcher:Objective:\t825304800.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", + "INFO:pybalance.lp.matcher:Objective:\t733533600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 3.09 m\n", + "INFO:pybalance.lp.matcher:Objective:\t733527200.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 3.59 m\n", + "INFO:pybalance.lp.matcher:Objective:\t733465600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 3.73 m\n", + "INFO:pybalance.lp.matcher:Objective:\t733395200.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:Status = OPTIMAL\n", + "INFO:pybalance.lp.matcher:Number of solutions found: 6\n" + ] + } + ], + "source": [ + "matcher = ConstraintSatisfactionMatcher(\n", + " matching_data=m, \n", + " objective='gamma', \n", + " max_mismatch=0.05, \n", + " pool_size=len(match_card.get_population('pool')),\n", + " target_size=len(match_card.get_population('target')),\n", + " time_limit=600\n", + ")\n", + "match_dist = matcher.match()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e8fef8b3-1823-4cdb-98e8-6c86803c8c23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "fig = plot_numeric_features(match_dist)\n", + "fig = plot_categoric_features(match_dist)" + ] + }, + { + "cell_type": "markdown", + "id": "f6461053-c41c-472a-ad31-57245b690d42", + "metadata": {}, + "source": [ + "# Optimize match among all subsets of a fixed size without balance constraint" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9b9002d6-3419-408d-9f97-a9a6a65eb4de", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", + "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", + "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", + "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", + "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to None balance constraint.\n", + "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", + "INFO:pybalance.lp.matcher:Building model variables and constraints ...\n", + "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", + "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", + "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.07 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2127925600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1582\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.11 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2020125600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.13 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2019725600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 0.20 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2016325600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1487\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 0.26 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2015325600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1486\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 0.32 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2012125600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1483\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 7, time = 0.32 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2011725600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 8, time = 0.34 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2011525600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 9, time = 0.36 m\n", + "INFO:pybalance.lp.matcher:Objective:\t2011325600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 10, time = 0.66 m\n", + "INFO:pybalance.lp.matcher:Objective:\t478921600.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 11, time = 1.19 m\n", + "INFO:pybalance.lp.matcher:Objective:\t478920000.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:Status = FEASIBLE\n", + "INFO:pybalance.lp.matcher:Number of solutions found: 11\n" + ] + } + ], + "source": [ + "matcher = ConstraintSatisfactionMatcher(\n", + " matching_data=m, \n", + " objective='gamma', \n", + " pool_size=len(match_card.get_population('pool')),\n", + " target_size=len(match_card.get_population('target')),\n", + " time_limit=600\n", + ")\n", + "match_dist2 = matcher.match()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6e7662f9-0cc3-4217-b6d4-4868ac2bd1dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "fig = plot_numeric_features(match_dist2)\n", + "fig = plot_categoric_features(match_dist2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "014a2b7e-d2a5-46be-bd25-299ff3bf52df", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", + "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", + "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" + ] + }, + { + "data": { + "text/plain": [ + "tensor(0.0500)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "beta = GammaBalance(m, standardize_difference=False)\n", + "beta.per_feature_loss(match_dist.get_population('pool')).max()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pybalance", + "language": "python", + "name": "pybalance" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/sphinx/demos/lp_matcher.ipynb b/sphinx/demos/lp_matcher.ipynb index d120d5e..81937a7 100644 --- a/sphinx/demos/lp_matcher.ipynb +++ b/sphinx/demos/lp_matcher.ipynb @@ -269,7 +269,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -300,14 +300,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO [matcher.py:65] Scaling features by factor 110.41 in order to use integer solver with <= 0.6431% loss.\n" + "INFO [matcher.py:65] Scaling features by factor 240.00 in order to use integer solver with <= 0.2841% loss.\n" ] }, { "data": { "text/plain": [ "{'objective': 'beta',\n", - " 'match_size': 1000,\n", + " 'pool_size': 1000,\n", + " 'target_size': 1000,\n", + " 'max_mismatch': None,\n", " 'time_limit': 360,\n", " 'num_workers': 4,\n", " 'ps_hinting': False,\n", @@ -340,145 +342,183 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO [matcher.py:319] Solving for match population with size = 1000. Will match on 15 dimensions ...\n", - "INFO [matcher.py:335] Calculating bounds on feature variables ...\n", - "INFO [matcher.py:350] Applying constraints ...\n", - "INFO [matcher.py:446] Solving with 4 workers ...\n", - "INFO [matcher.py:89] Initial balance score: 0.2328\n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 1, time = 0.02 m\n", - "INFO [matcher.py:100] Objective:\t207734.0\n", - "INFO [matcher.py:113] Balance:\t0.2298\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 2, time = 0.03 m\n", - "INFO [matcher.py:100] Objective:\t207713.0\n", - "INFO [matcher.py:113] Balance:\t0.2297\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 3, time = 0.04 m\n", - "INFO [matcher.py:100] Objective:\t207689.0\n", - "INFO [matcher.py:113] Balance:\t0.2296\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 4, time = 0.04 m\n", - "INFO [matcher.py:100] Objective:\t207630.0\n", - "INFO [matcher.py:113] Balance:\t0.2296\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 5, time = 0.04 m\n", - "INFO [matcher.py:100] Objective:\t207593.0\n", - "INFO [matcher.py:113] Balance:\t0.2295\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 6, time = 0.05 m\n", - "INFO [matcher.py:100] Objective:\t207488.0\n", - "INFO [matcher.py:113] Balance:\t0.2294\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 7, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t207381.0\n", - "INFO [matcher.py:113] Balance:\t0.2293\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 8, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t10433.0\n", - "INFO [matcher.py:113] Balance:\t0.0105\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 9, time = 0.08 m\n", - "INFO [matcher.py:100] Objective:\t10229.0\n", - "INFO [matcher.py:113] Balance:\t0.0124\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 10, time = 0.10 m\n", - "INFO [matcher.py:100] Objective:\t10173.0\n", - "INFO [matcher.py:113] Balance:\t0.0123\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 11, time = 0.11 m\n", - "INFO [matcher.py:100] Objective:\t10168.0\n", - "INFO [matcher.py:113] Balance:\t0.0123\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 12, time = 0.13 m\n", - "INFO [matcher.py:100] Objective:\t10165.0\n", - "INFO [matcher.py:113] Balance:\t0.0122\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 13, time = 0.14 m\n", - "INFO [matcher.py:100] Objective:\t10137.0\n", - "INFO [matcher.py:113] Balance:\t0.0102\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 14, time = 0.17 m\n", - "INFO [matcher.py:100] Objective:\t10132.0\n", - "INFO [matcher.py:113] Balance:\t0.0123\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 15, time = 0.19 m\n", - "INFO [matcher.py:100] Objective:\t10129.0\n", - "INFO [matcher.py:113] Balance:\t0.0122\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 16, time = 0.29 m\n", - "INFO [matcher.py:100] Objective:\t10128.0\n", - "INFO [matcher.py:113] Balance:\t0.0122\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 17, time = 0.39 m\n", - "INFO [matcher.py:100] Objective:\t10127.0\n", - "INFO [matcher.py:113] Balance:\t0.0102\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 18, time = 0.51 m\n", - "INFO [matcher.py:100] Objective:\t10125.0\n", - "INFO [matcher.py:113] Balance:\t0.0122\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 19, time = 0.70 m\n", - "INFO [matcher.py:100] Objective:\t10124.0\n", - "INFO [matcher.py:113] Balance:\t0.0122\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 20, time = 0.93 m\n", - "INFO [matcher.py:100] Objective:\t10123.0\n", - "INFO [matcher.py:113] Balance:\t0.0104\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 21, time = 1.85 m\n", - "INFO [matcher.py:100] Objective:\t10121.0\n", - "INFO [matcher.py:113] Balance:\t0.0104\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 22, time = 3.52 m\n", - "INFO [matcher.py:100] Objective:\t10120.0\n", - "INFO [matcher.py:113] Balance:\t0.0102\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:453] Status = OPTIMAL\n", - "INFO [matcher.py:454] Number of solutions found: 22\n" + "INFO [matcher.py:418] Solving for match population with pool size = 1000 and target size = 1000 subject to None balance constraint.\n", + "INFO [matcher.py:421] Matching on 15 dimensions ...\n", + "INFO [matcher.py:428] Building model variables and constraints ...\n", + "INFO [matcher.py:437] Calculating bounds on feature variables ...\n", + "INFO [matcher.py:527] Applying size constraints on pool and target ...\n", + "INFO [matcher.py:611] Solving with 4 workers ...\n", + "INFO [matcher.py:90] Initial balance score: 0.2328\n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 1, time = 0.02 m\n", + "INFO [matcher.py:101] Objective:\t452948000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2298\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 2, time = 0.03 m\n", + "INFO [matcher.py:101] Objective:\t452876000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2297\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 3, time = 0.04 m\n", + "INFO [matcher.py:101] Objective:\t452777000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2297\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 4, time = 0.04 m\n", + "INFO [matcher.py:101] Objective:\t452736000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2296\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 5, time = 0.04 m\n", + "INFO [matcher.py:101] Objective:\t452730000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2296\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 6, time = 0.05 m\n", + "INFO [matcher.py:101] Objective:\t452596000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2295\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 7, time = 0.05 m\n", + "INFO [matcher.py:101] Objective:\t452537000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2294\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 8, time = 0.06 m\n", + "INFO [matcher.py:101] Objective:\t452040000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2291\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 9, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t451825000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2289\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 10, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t451808000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2289\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 11, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t451755000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.2289\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 12, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t22699000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0104\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 13, time = 0.10 m\n", + "INFO [matcher.py:101] Objective:\t22422000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0124\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 14, time = 0.12 m\n", + "INFO [matcher.py:101] Objective:\t22306000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0124\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 15, time = 0.13 m\n", + "INFO [matcher.py:101] Objective:\t22291000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0124\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 16, time = 0.14 m\n", + "INFO [matcher.py:101] Objective:\t22121000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0122\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 17, time = 0.16 m\n", + "INFO [matcher.py:101] Objective:\t22119000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0102\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 18, time = 0.21 m\n", + "INFO [matcher.py:101] Objective:\t22103000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0121\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 19, time = 0.23 m\n", + "INFO [matcher.py:101] Objective:\t22101000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0122\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 20, time = 0.25 m\n", + "INFO [matcher.py:101] Objective:\t22099000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0122\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 21, time = 0.27 m\n", + "INFO [matcher.py:101] Objective:\t22088000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0122\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 22, time = 0.55 m\n", + "INFO [matcher.py:101] Objective:\t22084000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0122\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 23, time = 3.16 m\n", + "INFO [matcher.py:101] Objective:\t22083000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0101\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 24, time = 5.78 m\n", + "INFO [matcher.py:101] Objective:\t22082000.0\n", + "INFO [matcher.py:120] Balance (beta):\t0.0102\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:618] Status = FEASIBLE\n", + "INFO [matcher.py:619] Number of solutions found: 24\n" ] }, { @@ -615,34 +655,49 @@ " ...\n", " \n", " \n", - " 9975\n", - " 51.242281\n", - " 130.812647\n", - " 87.967028\n", - " 1.0\n", - " 0\n", - " 4\n", + " 9933\n", + " 68.194783\n", + " 127.495418\n", + " 69.177329\n", + " 0.0\n", + " 1\n", + " 5\n", " pool\n", " 1\n", - " 0\n", " 1\n", " 0\n", - " 9975\n", + " 0\n", + " 9933\n", " \n", " \n", - " 9977\n", - " 56.698850\n", - " 169.861617\n", - " 99.292786\n", - " 0.0\n", + " 9946\n", + " 22.630370\n", + " 185.351623\n", + " 117.381552\n", + " 1.0\n", + " 1\n", " 2\n", - " 4\n", " pool\n", + " 1\n", + " 0\n", " 0\n", " 1\n", + " 9946\n", + " \n", + " \n", + " 9955\n", + " 56.736759\n", + " 161.612045\n", + " 72.288182\n", + " 1.0\n", + " 2\n", + " 2\n", + " pool\n", + " 1\n", " 0\n", " 1\n", - " 9977\n", + " 1\n", + " 9955\n", " \n", " \n", " 9981\n", @@ -674,28 +729,13 @@ " 1\n", " 9982\n", " \n", - " \n", - " 9995\n", - " 45.215942\n", - " 186.043723\n", - " 115.100146\n", - " 1.0\n", - " 0\n", - " 2\n", - " pool\n", - " 0\n", - " 1\n", - " 1\n", - " 0\n", - " 9995\n", - " \n", " \n", "\n", "

2000 rows × 12 columns

\n", "" ], "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -855,34 +895,49 @@ " ...\n", " \n", " \n", - " 9975\n", - " 51.242281\n", - " 130.812647\n", - " 87.967028\n", - " 1.0\n", - " 0\n", - " 4\n", + " 9933\n", + " 68.194783\n", + " 127.495418\n", + " 69.177329\n", + " 0.0\n", + " 1\n", + " 5\n", " pool\n", " 1\n", - " 0\n", " 1\n", " 0\n", - " 9975\n", + " 0\n", + " 9933\n", " \n", " \n", - " 9977\n", - " 56.698850\n", - " 169.861617\n", - " 99.292786\n", - " 0.0\n", + " 9946\n", + " 22.630370\n", + " 185.351623\n", + " 117.381552\n", + " 1.0\n", + " 1\n", " 2\n", - " 4\n", " pool\n", + " 1\n", + " 0\n", " 0\n", " 1\n", + " 9946\n", + " \n", + " \n", + " 9955\n", + " 56.736759\n", + " 161.612045\n", + " 72.288182\n", + " 1.0\n", + " 2\n", + " 2\n", + " pool\n", + " 1\n", " 0\n", " 1\n", - " 9977\n", + " 1\n", + " 9955\n", " \n", " \n", " 9981\n", @@ -914,28 +969,13 @@ " 1\n", " 9982\n", " \n", - " \n", - " 9995\n", - " 45.215942\n", - " 186.043723\n", - " 115.100146\n", - " 1.0\n", - " 0\n", - " 2\n", - " pool\n", - " 0\n", - " 1\n", - " 1\n", - " 0\n", - " 9995\n", - " \n", " \n", "\n", "

2000 rows × 12 columns

\n", "" ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -955,7 +995,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -965,7 +1005,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1022,14 +1062,16 @@ "INFO [preprocess.py:442] Added cross term binary_2 * binary_3 to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_2 * height to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_0 * binary_2 to matching features.\n", - "INFO [matcher.py:65] Scaling features by factor 158.99 in order to use integer solver with <= 0.8895% loss.\n" + "INFO [matcher.py:65] Scaling features by factor 240.00 in order to use integer solver with <= 0.3751% loss.\n" ] }, { "data": { "text/plain": [ "{'objective': 'beta_x',\n", - " 'match_size': 1000,\n", + " 'pool_size': 1000,\n", + " 'target_size': 1000,\n", + " 'max_mismatch': None,\n", " 'time_limit': 360,\n", " 'num_workers': 4,\n", " 'ps_hinting': True,\n", @@ -1062,17 +1104,20 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO [matcher.py:319] Solving for match population with size = 1000. Will match on 25 dimensions ...\n", - "INFO [matcher.py:335] Calculating bounds on feature variables ...\n", - "INFO [matcher.py:350] Applying constraints ...\n", - "INFO [matcher.py:378] Training PS model as guide for solver ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/pybalance/lp/matcher.py:380: SettingWithCopyWarning: \n", + "INFO [matcher.py:418] Solving for match population with pool size = 1000 and target size = 1000 subject to None balance constraint.\n", + "INFO [matcher.py:421] Matching on 25 dimensions ...\n", + "INFO [matcher.py:428] Building model variables and constraints ...\n", + "INFO [matcher.py:437] Calculating bounds on feature variables ...\n", + "INFO [matcher.py:527] Applying size constraints on pool and target ...\n", + "INFO [matcher.py:533] Applying hint ...\n", + "INFO [matcher.py:540] Training PS model as guide for solver ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/pybalance/lp/matcher.py:542: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " target.loc[:, \"ix\"] = list(range(len(target)))\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/pybalance/lp/matcher.py:381: SettingWithCopyWarning: \n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/pybalance/lp/matcher.py:543: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -1088,10 +1133,10 @@ "INFO [preprocess.py:442] Added cross term binary_2 * binary_3 to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_2 * height to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_0 * binary_2 to matching features.\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.001 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.000 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", - "INFO [matcher.py:139] \t* alpha: 0.10453554731869287\n", + "INFO [matcher.py:139] \t* alpha: 0.1045355473186929\n", "INFO [matcher.py:139] \t* class_weight: None\n", "INFO [matcher.py:139] \t* early_stopping: False\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", @@ -1115,7 +1160,7 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.003 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.7627616953429357\n", + "INFO [matcher.py:139] \t* C: 0.7627616953429366\n", "INFO [matcher.py:139] \t* fit_intercept: True\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l2\n", @@ -1125,7 +1170,7 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 4/50, 0.006 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.015804928600429948\n", + "INFO [matcher.py:139] \t* C: 0.015804928600429955\n", "INFO [matcher.py:139] \t* fit_intercept: True\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l2\n", @@ -1133,56 +1178,56 @@ "INFO [matcher.py:140] \tScore (beta_x): 0.0615\n", "INFO [matcher.py:141] \tSolution time: 0.007 min\n", "INFO [matcher.py:180] Training model LogisticRegression (iter 5/50, 0.007 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.022 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.024 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.040 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.044 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.058 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.059 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.065 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.066 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.074 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.090 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.091 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.102 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.083 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.102 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.103 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.115 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.120 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.121 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.123 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.137 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.138 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.139 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.141 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.142 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.143 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.144 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.145 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.161 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.162 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.163 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.164 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.165 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.163 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.164 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.165 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.166 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.167 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.172 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.173 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.186 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.187 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.188 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.189 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.190 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.195 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.196 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.187 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.188 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.201 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.216 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.217 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.232 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.220 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.221 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.222 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.254 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.255 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.258 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", - "INFO [matcher.py:139] \t* alpha: 0.026061113485170782\n", + "INFO [matcher.py:139] \t* alpha: 0.02606111348517078\n", "INFO [matcher.py:139] \t* class_weight: balanced\n", "INFO [matcher.py:139] \t* early_stopping: True\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", @@ -1190,30 +1235,30 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.223 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.223 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.224 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:141] \tSolution time: 0.259 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.259 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.260 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.243 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.245 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.246 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.282 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.284 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.285 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.264 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.278 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.286 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.288 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.289 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.300 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.305 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.306 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 48/50, 0.307 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.308 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.309 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.306 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.322 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.331 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.333 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.334 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.346 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.352 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.353 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 48/50, 0.354 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.355 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.356 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", - "INFO [matcher.py:139] \t* alpha: 0.026061113485170782\n", + "INFO [matcher.py:139] \t* alpha: 0.02606111348517078\n", "INFO [matcher.py:139] \t* class_weight: balanced\n", "INFO [matcher.py:139] \t* early_stopping: True\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", @@ -1221,715 +1266,1308 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.223 min\n", - "INFO [matcher.py:415] Hint achieves objective value = 97213.\n", - "INFO [matcher.py:417] Applying hints ...\n", - "INFO [matcher.py:446] Solving with 4 workers ...\n", - "INFO [matcher.py:89] Initial balance score: 0.2324\n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 1, time = 0.05 m\n", - "INFO [matcher.py:100] Objective:\t97213.0\n", - "INFO [matcher.py:113] Balance:\t0.0603\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 2, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t97192.0\n", - "INFO [matcher.py:113] Balance:\t0.0604\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 3, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t97172.0\n", - "INFO [matcher.py:113] Balance:\t0.0604\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 4, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t97154.0\n", - "INFO [matcher.py:113] Balance:\t0.0604\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 5, time = 0.06 m\n", - "INFO [matcher.py:100] Objective:\t97118.0\n", - "INFO [matcher.py:113] Balance:\t0.0603\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 6, time = 0.07 m\n", - "INFO [matcher.py:100] Objective:\t96362.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 7, time = 0.07 m\n", - "INFO [matcher.py:100] Objective:\t96278.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 8, time = 0.07 m\n", - "INFO [matcher.py:100] Objective:\t96248.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 9, time = 0.07 m\n", - "INFO [matcher.py:100] Objective:\t96125.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 10, time = 0.08 m\n", - "INFO [matcher.py:100] Objective:\t96108.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 11, time = 0.08 m\n", - "INFO [matcher.py:100] Objective:\t96090.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 12, time = 0.08 m\n", - "INFO [matcher.py:100] Objective:\t96054.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 13, time = 0.09 m\n", - "INFO [matcher.py:100] Objective:\t95990.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 14, time = 0.09 m\n", - "INFO [matcher.py:100] Objective:\t95973.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 15, time = 0.09 m\n", - "INFO [matcher.py:100] Objective:\t95955.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 16, time = 0.11 m\n", - "INFO [matcher.py:100] Objective:\t95835.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 17, time = 0.12 m\n", - "INFO [matcher.py:100] Objective:\t95820.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 18, time = 0.12 m\n", - "INFO [matcher.py:100] Objective:\t95818.0\n", - "INFO [matcher.py:113] Balance:\t0.0599\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 19, time = 0.14 m\n", - "INFO [matcher.py:100] Objective:\t95782.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 20, time = 0.15 m\n", - "INFO [matcher.py:100] Objective:\t95767.0\n", - "INFO [matcher.py:113] Balance:\t0.0600\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 21, time = 0.18 m\n", - "INFO [matcher.py:100] Objective:\t95616.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 22, time = 0.19 m\n", - "INFO [matcher.py:100] Objective:\t95540.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 23, time = 0.20 m\n", - "INFO [matcher.py:100] Objective:\t95525.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 24, time = 0.20 m\n", - "INFO [matcher.py:100] Objective:\t95420.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 25, time = 0.23 m\n", - "INFO [matcher.py:100] Objective:\t95367.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 26, time = 0.23 m\n", - "INFO [matcher.py:100] Objective:\t95302.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 27, time = 0.23 m\n", - "INFO [matcher.py:100] Objective:\t95272.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 28, time = 0.24 m\n", - "INFO [matcher.py:100] Objective:\t95200.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 29, time = 0.25 m\n", - "INFO [matcher.py:100] Objective:\t95185.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 30, time = 0.27 m\n", - "INFO [matcher.py:100] Objective:\t95167.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 31, time = 0.27 m\n", - "INFO [matcher.py:100] Objective:\t95166.0\n", - "INFO [matcher.py:113] Balance:\t0.0598\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 32, time = 0.27 m\n", - "INFO [matcher.py:100] Objective:\t95098.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 33, time = 0.27 m\n", - "INFO [matcher.py:100] Objective:\t95073.0\n", - "INFO [matcher.py:113] Balance:\t0.0597\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 34, time = 0.28 m\n", - "INFO [matcher.py:100] Objective:\t94920.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 35, time = 0.28 m\n", - "INFO [matcher.py:100] Objective:\t94896.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 36, time = 0.33 m\n", - "INFO [matcher.py:100] Objective:\t94746.0\n", - "INFO [matcher.py:113] Balance:\t0.0595\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 37, time = 0.34 m\n", - "INFO [matcher.py:100] Objective:\t94722.0\n", - "INFO [matcher.py:113] Balance:\t0.0596\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 38, time = 0.34 m\n", - "INFO [matcher.py:100] Objective:\t94697.0\n", - "INFO [matcher.py:113] Balance:\t0.0595\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 39, time = 0.34 m\n", - "INFO [matcher.py:100] Objective:\t94652.0\n", - "INFO [matcher.py:113] Balance:\t0.0595\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 40, time = 0.35 m\n", - "INFO [matcher.py:100] Objective:\t94544.0\n", - "INFO [matcher.py:113] Balance:\t0.0594\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 41, time = 0.35 m\n", - "INFO [matcher.py:100] Objective:\t94515.0\n", - "INFO [matcher.py:113] Balance:\t0.0595\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 42, time = 0.37 m\n", - "INFO [matcher.py:100] Objective:\t93901.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 43, time = 0.46 m\n", - "INFO [matcher.py:100] Objective:\t93721.0\n", - "INFO [matcher.py:113] Balance:\t0.0592\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 44, time = 0.63 m\n", - "INFO [matcher.py:100] Objective:\t93717.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 45, time = 0.77 m\n", - "INFO [matcher.py:100] Objective:\t93699.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 46, time = 0.78 m\n", - "INFO [matcher.py:100] Objective:\t93583.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 47, time = 0.78 m\n", - "INFO [matcher.py:100] Objective:\t93568.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 48, time = 0.79 m\n", - "INFO [matcher.py:100] Objective:\t93532.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 49, time = 0.79 m\n", - "INFO [matcher.py:100] Objective:\t93530.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 50, time = 0.79 m\n", - "INFO [matcher.py:100] Objective:\t93521.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 51, time = 0.81 m\n", - "INFO [matcher.py:100] Objective:\t93413.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 52, time = 0.82 m\n", - "INFO [matcher.py:100] Objective:\t93382.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 53, time = 0.82 m\n", - "INFO [matcher.py:100] Objective:\t93348.0\n", - "INFO [matcher.py:113] Balance:\t0.0591\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 54, time = 0.82 m\n", - "INFO [matcher.py:100] Objective:\t93296.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 55, time = 0.83 m\n", - "INFO [matcher.py:100] Objective:\t93180.0\n", - "INFO [matcher.py:113] Balance:\t0.0590\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 56, time = 0.83 m\n", - "INFO [matcher.py:100] Objective:\t93159.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 57, time = 0.84 m\n", - "INFO [matcher.py:100] Objective:\t93107.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 58, time = 0.84 m\n", - "INFO [matcher.py:100] Objective:\t93031.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 59, time = 0.85 m\n", - "INFO [matcher.py:100] Objective:\t93006.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 60, time = 0.86 m\n", - "INFO [matcher.py:100] Objective:\t92967.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 61, time = 0.86 m\n", - "INFO [matcher.py:100] Objective:\t92961.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 62, time = 0.86 m\n", - "INFO [matcher.py:100] Objective:\t92924.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 63, time = 0.87 m\n", - "INFO [matcher.py:100] Objective:\t92875.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 64, time = 0.87 m\n", - "INFO [matcher.py:100] Objective:\t92809.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 65, time = 0.87 m\n", - "INFO [matcher.py:100] Objective:\t92788.0\n", - "INFO [matcher.py:113] Balance:\t0.0589\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 66, time = 0.91 m\n", - "INFO [matcher.py:100] Objective:\t92715.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 67, time = 0.91 m\n", - "INFO [matcher.py:100] Objective:\t92675.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 68, time = 0.91 m\n", - "INFO [matcher.py:100] Objective:\t92650.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 69, time = 0.92 m\n", - "INFO [matcher.py:100] Objective:\t92605.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 70, time = 0.92 m\n", - "INFO [matcher.py:100] Objective:\t92577.0\n", - "INFO [matcher.py:113] Balance:\t0.0588\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 71, time = 0.92 m\n", - "INFO [matcher.py:100] Objective:\t92557.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 72, time = 0.93 m\n", - "INFO [matcher.py:100] Objective:\t92519.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 73, time = 0.93 m\n", - "INFO [matcher.py:100] Objective:\t92447.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 74, time = 0.94 m\n", - "INFO [matcher.py:100] Objective:\t92432.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 75, time = 0.96 m\n", - "INFO [matcher.py:100] Objective:\t92347.0\n", - "INFO [matcher.py:113] Balance:\t0.0587\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 76, time = 0.96 m\n", - "INFO [matcher.py:100] Objective:\t92035.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 77, time = 0.99 m\n", - "INFO [matcher.py:100] Objective:\t91762.0\n", - "INFO [matcher.py:113] Balance:\t0.0585\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 78, time = 1.00 m\n", - "INFO [matcher.py:100] Objective:\t91550.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 79, time = 1.01 m\n", - "INFO [matcher.py:100] Objective:\t91417.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 80, time = 1.01 m\n", - "INFO [matcher.py:100] Objective:\t91286.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 81, time = 1.01 m\n", - "INFO [matcher.py:100] Objective:\t91280.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 82, time = 1.02 m\n", - "INFO [matcher.py:100] Objective:\t91277.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 83, time = 1.02 m\n", - "INFO [matcher.py:100] Objective:\t91233.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 84, time = 1.02 m\n", - "INFO [matcher.py:100] Objective:\t91230.0\n", - "INFO [matcher.py:113] Balance:\t0.0583\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 85, time = 1.02 m\n", - "INFO [matcher.py:100] Objective:\t91222.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 86, time = 1.03 m\n", - "INFO [matcher.py:100] Objective:\t91220.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 87, time = 1.04 m\n", - "INFO [matcher.py:100] Objective:\t91214.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 88, time = 1.04 m\n", - "INFO [matcher.py:100] Objective:\t91213.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 89, time = 1.05 m\n", - "INFO [matcher.py:100] Objective:\t91195.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 90, time = 1.06 m\n", - "INFO [matcher.py:100] Objective:\t91124.0\n", - "INFO [matcher.py:113] Balance:\t0.0582\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 91, time = 1.06 m\n", - "INFO [matcher.py:100] Objective:\t90978.0\n", - "INFO [matcher.py:113] Balance:\t0.0581\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 92, time = 1.08 m\n", - "INFO [matcher.py:100] Objective:\t90961.0\n", - "INFO [matcher.py:113] Balance:\t0.0580\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 93, time = 1.08 m\n", - "INFO [matcher.py:100] Objective:\t90916.0\n", - "INFO [matcher.py:113] Balance:\t0.0580\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 94, time = 1.08 m\n", - "INFO [matcher.py:100] Objective:\t90868.0\n", - "INFO [matcher.py:113] Balance:\t0.0580\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 95, time = 1.10 m\n", - "INFO [matcher.py:100] Objective:\t90846.0\n", - "INFO [matcher.py:113] Balance:\t0.0579\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 96, time = 1.11 m\n", - "INFO [matcher.py:100] Objective:\t90808.0\n", - "INFO [matcher.py:113] Balance:\t0.0579\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 97, time = 1.15 m\n", - "INFO [matcher.py:100] Objective:\t90612.0\n", - "INFO [matcher.py:113] Balance:\t0.0578\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 98, time = 1.15 m\n", - "INFO [matcher.py:100] Objective:\t90547.0\n", - "INFO [matcher.py:113] Balance:\t0.0577\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 99, time = 1.16 m\n", - "INFO [matcher.py:100] Objective:\t90514.0\n", - "INFO [matcher.py:113] Balance:\t0.0578\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 100, time = 1.16 m\n", - "INFO [matcher.py:100] Objective:\t90502.0\n", - "INFO [matcher.py:113] Balance:\t0.0577\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 101, time = 1.17 m\n", - "INFO [matcher.py:100] Objective:\t90454.0\n", - "INFO [matcher.py:113] Balance:\t0.0577\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 102, time = 1.22 m\n", - "INFO [matcher.py:100] Objective:\t90048.0\n", - "INFO [matcher.py:113] Balance:\t0.0575\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 103, time = 1.22 m\n", - "INFO [matcher.py:100] Objective:\t89983.0\n", - "INFO [matcher.py:113] Balance:\t0.0574\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 104, time = 1.24 m\n", - "INFO [matcher.py:100] Objective:\t89952.0\n", - "INFO [matcher.py:113] Balance:\t0.0575\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 105, time = 1.24 m\n", - "INFO [matcher.py:100] Objective:\t89938.0\n", - "INFO [matcher.py:113] Balance:\t0.0574\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 106, time = 1.24 m\n", - "INFO [matcher.py:100] Objective:\t89827.0\n", - "INFO [matcher.py:113] Balance:\t0.0574\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 107, time = 1.25 m\n", - "INFO [matcher.py:100] Objective:\t89556.0\n", - "INFO [matcher.py:113] Balance:\t0.0573\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 108, time = 1.26 m\n", - "INFO [matcher.py:100] Objective:\t88638.0\n", - "INFO [matcher.py:113] Balance:\t0.0568\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 109, time = 1.41 m\n", - "INFO [matcher.py:100] Objective:\t88144.0\n", - "INFO [matcher.py:113] Balance:\t0.0567\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 110, time = 1.49 m\n", - "INFO [matcher.py:100] Objective:\t87463.0\n", - "INFO [matcher.py:113] Balance:\t0.0561\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 111, time = 1.57 m\n", - "INFO [matcher.py:100] Objective:\t86971.0\n", - "INFO [matcher.py:113] Balance:\t0.0559\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 112, time = 1.74 m\n", - "INFO [matcher.py:100] Objective:\t86313.0\n", - "INFO [matcher.py:113] Balance:\t0.0556\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 113, time = 1.89 m\n", - "INFO [matcher.py:100] Objective:\t86304.0\n", - "INFO [matcher.py:113] Balance:\t0.0556\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 114, time = 2.01 m\n", - "INFO [matcher.py:100] Objective:\t35917.0\n", - "INFO [matcher.py:113] Balance:\t0.0310\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 115, time = 2.52 m\n", - "INFO [matcher.py:100] Objective:\t35907.0\n", - "INFO [matcher.py:113] Balance:\t0.0310\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 116, time = 2.53 m\n", - "INFO [matcher.py:100] Objective:\t35896.0\n", - "INFO [matcher.py:113] Balance:\t0.0310\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 117, time = 4.39 m\n", - "INFO [matcher.py:100] Objective:\t35895.0\n", - "INFO [matcher.py:113] Balance:\t0.0310\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:453] Status = FEASIBLE\n", - "INFO [matcher.py:454] Number of solutions found: 117\n" + "INFO [matcher.py:141] \tSolution time: 0.259 min\n", + "INFO [matcher.py:577] Hint achieves objective value = 147332.\n", + "INFO [matcher.py:579] Applying hints ...\n", + "INFO [matcher.py:611] Solving with 4 workers ...\n", + "INFO [matcher.py:90] Initial balance score: 0.2324\n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 1, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t147332000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0603\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 2, time = 0.08 m\n", + "INFO [matcher.py:101] Objective:\t147176000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0601\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 3, time = 0.09 m\n", + "INFO [matcher.py:101] Objective:\t147050000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0601\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 4, time = 0.09 m\n", + "INFO [matcher.py:101] Objective:\t147002000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0601\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 5, time = 0.09 m\n", + "INFO [matcher.py:101] Objective:\t146721000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0601\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 6, time = 0.10 m\n", + "INFO [matcher.py:101] Objective:\t145561000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 7, time = 0.10 m\n", + "INFO [matcher.py:101] Objective:\t145369000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 8, time = 0.12 m\n", + "INFO [matcher.py:101] Objective:\t145229000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 9, time = 0.13 m\n", + "INFO [matcher.py:101] Objective:\t145192000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0595\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 10, time = 0.13 m\n", + "INFO [matcher.py:101] Objective:\t145144000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 11, time = 0.14 m\n", + "INFO [matcher.py:101] Objective:\t145129000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0595\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 12, time = 0.14 m\n", + "INFO [matcher.py:101] Objective:\t144996000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0595\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 13, time = 0.16 m\n", + "INFO [matcher.py:101] Objective:\t144843000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0594\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 14, time = 0.16 m\n", + "INFO [matcher.py:101] Objective:\t144588000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0594\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 15, time = 0.20 m\n", + "INFO [matcher.py:101] Objective:\t144406000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0594\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 16, time = 0.21 m\n", + "INFO [matcher.py:101] Objective:\t144195000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0593\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 17, time = 0.23 m\n", + "INFO [matcher.py:101] Objective:\t143827000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0593\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 18, time = 0.23 m\n", + "INFO [matcher.py:101] Objective:\t143679000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0592\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 19, time = 0.25 m\n", + "INFO [matcher.py:101] Objective:\t143649000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 20, time = 0.27 m\n", + "INFO [matcher.py:101] Objective:\t143574000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 21, time = 0.27 m\n", + "INFO [matcher.py:101] Objective:\t143526000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0592\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 22, time = 0.27 m\n", + "INFO [matcher.py:101] Objective:\t143245000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 23, time = 0.30 m\n", + "INFO [matcher.py:101] Objective:\t142588000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0589\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 24, time = 0.31 m\n", + "INFO [matcher.py:101] Objective:\t142455000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0589\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 25, time = 0.34 m\n", + "INFO [matcher.py:101] Objective:\t141967000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0588\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 26, time = 0.35 m\n", + "INFO [matcher.py:101] Objective:\t141924000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0588\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 27, time = 0.35 m\n", + "INFO [matcher.py:101] Objective:\t141829000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 28, time = 0.36 m\n", + "INFO [matcher.py:101] Objective:\t141681000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 29, time = 0.38 m\n", + "INFO [matcher.py:101] Objective:\t141606000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 30, time = 0.38 m\n", + "INFO [matcher.py:101] Objective:\t141322000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0585\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 31, time = 0.39 m\n", + "INFO [matcher.py:101] Objective:\t141285000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0585\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 32, time = 0.40 m\n", + "INFO [matcher.py:101] Objective:\t141229000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0586\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 33, time = 0.43 m\n", + "INFO [matcher.py:101] Objective:\t141161000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0586\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 34, time = 0.44 m\n", + "INFO [matcher.py:101] Objective:\t140938000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 35, time = 0.44 m\n", + "INFO [matcher.py:101] Objective:\t140793000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 36, time = 0.44 m\n", + "INFO [matcher.py:101] Objective:\t140697000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 37, time = 0.45 m\n", + "INFO [matcher.py:101] Objective:\t140642000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 38, time = 0.45 m\n", + "INFO [matcher.py:101] Objective:\t140592000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 39, time = 0.47 m\n", + "INFO [matcher.py:101] Objective:\t140562000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 40, time = 0.47 m\n", + "INFO [matcher.py:101] Objective:\t140520000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 41, time = 0.62 m\n", + "INFO [matcher.py:101] Objective:\t140167000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0582\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 42, time = 0.65 m\n", + "INFO [matcher.py:101] Objective:\t140140000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 43, time = 0.66 m\n", + "INFO [matcher.py:101] Objective:\t140132000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 44, time = 0.68 m\n", + "INFO [matcher.py:101] Objective:\t139980000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 45, time = 0.68 m\n", + "INFO [matcher.py:101] Objective:\t139917000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 46, time = 0.68 m\n", + "INFO [matcher.py:101] Objective:\t139651000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0582\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 47, time = 0.70 m\n", + "INFO [matcher.py:101] Objective:\t139638000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 48, time = 0.72 m\n", + "INFO [matcher.py:101] Objective:\t139610000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 49, time = 0.74 m\n", + "INFO [matcher.py:101] Objective:\t139189000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0581\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 50, time = 0.76 m\n", + "INFO [matcher.py:101] Objective:\t139131000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 51, time = 0.76 m\n", + "INFO [matcher.py:101] Objective:\t138919000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 52, time = 0.76 m\n", + "INFO [matcher.py:101] Objective:\t138885000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 53, time = 0.77 m\n", + "INFO [matcher.py:101] Objective:\t138879000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 54, time = 0.80 m\n", + "INFO [matcher.py:101] Objective:\t138853000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0579\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 55, time = 0.83 m\n", + "INFO [matcher.py:101] Objective:\t138782000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0579\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 56, time = 0.83 m\n", + "INFO [matcher.py:101] Objective:\t138716000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0579\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 57, time = 0.85 m\n", + "INFO [matcher.py:101] Objective:\t138683000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0579\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 58, time = 0.85 m\n", + "INFO [matcher.py:101] Objective:\t138483000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0579\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 59, time = 0.88 m\n", + "INFO [matcher.py:101] Objective:\t137815000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0576\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 60, time = 0.88 m\n", + "INFO [matcher.py:101] Objective:\t137752000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0576\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 61, time = 0.88 m\n", + "INFO [matcher.py:101] Objective:\t137486000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0575\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 62, time = 0.89 m\n", + "INFO [matcher.py:101] Objective:\t137401000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0575\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 63, time = 0.90 m\n", + "INFO [matcher.py:101] Objective:\t137333000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0575\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 64, time = 0.93 m\n", + "INFO [matcher.py:101] Objective:\t137132000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 65, time = 0.93 m\n", + "INFO [matcher.py:101] Objective:\t137105000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 66, time = 0.93 m\n", + "INFO [matcher.py:101] Objective:\t137099000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 67, time = 0.98 m\n", + "INFO [matcher.py:101] Objective:\t137080000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0575\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 68, time = 0.98 m\n", + "INFO [matcher.py:101] Objective:\t137005000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 69, time = 0.99 m\n", + "INFO [matcher.py:101] Objective:\t136985000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 70, time = 1.04 m\n", + "INFO [matcher.py:101] Objective:\t136974000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 71, time = 1.04 m\n", + "INFO [matcher.py:101] Objective:\t136947000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 72, time = 1.11 m\n", + "INFO [matcher.py:101] Objective:\t136838000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 73, time = 1.21 m\n", + "INFO [matcher.py:101] Objective:\t136729000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 74, time = 1.25 m\n", + "INFO [matcher.py:101] Objective:\t136654000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 75, time = 1.25 m\n", + "INFO [matcher.py:101] Objective:\t136559000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 76, time = 1.26 m\n", + "INFO [matcher.py:101] Objective:\t136503000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 77, time = 1.26 m\n", + "INFO [matcher.py:101] Objective:\t136457000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 78, time = 1.26 m\n", + "INFO [matcher.py:101] Objective:\t136435000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 79, time = 1.37 m\n", + "INFO [matcher.py:101] Objective:\t136386000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 80, time = 1.38 m\n", + "INFO [matcher.py:101] Objective:\t136349000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 81, time = 1.38 m\n", + "INFO [matcher.py:101] Objective:\t136313000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 82, time = 1.39 m\n", + "INFO [matcher.py:101] Objective:\t136286000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 83, time = 1.39 m\n", + "INFO [matcher.py:101] Objective:\t136020000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 84, time = 1.43 m\n", + "INFO [matcher.py:101] Objective:\t135535000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 85, time = 1.48 m\n", + "INFO [matcher.py:101] Objective:\t135513000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 86, time = 1.49 m\n", + "INFO [matcher.py:101] Objective:\t135473000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 87, time = 1.49 m\n", + "INFO [matcher.py:101] Objective:\t135452000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 88, time = 1.53 m\n", + "INFO [matcher.py:101] Objective:\t135375000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 89, time = 1.54 m\n", + "INFO [matcher.py:101] Objective:\t135312000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0569\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 90, time = 1.55 m\n", + "INFO [matcher.py:101] Objective:\t134988000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 91, time = 1.59 m\n", + "INFO [matcher.py:101] Objective:\t134977000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 92, time = 1.60 m\n", + "INFO [matcher.py:101] Objective:\t134937000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 93, time = 1.60 m\n", + "INFO [matcher.py:101] Objective:\t134931000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 94, time = 1.62 m\n", + "INFO [matcher.py:101] Objective:\t134909000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0567\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 95, time = 1.68 m\n", + "INFO [matcher.py:101] Objective:\t134887000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 96, time = 1.69 m\n", + "INFO [matcher.py:101] Objective:\t134614000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 97, time = 1.69 m\n", + "INFO [matcher.py:101] Objective:\t134579000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 98, time = 1.69 m\n", + "INFO [matcher.py:101] Objective:\t134522000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 99, time = 1.70 m\n", + "INFO [matcher.py:101] Objective:\t134400000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 100, time = 1.70 m\n", + "INFO [matcher.py:101] Objective:\t134234000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 101, time = 1.71 m\n", + "INFO [matcher.py:101] Objective:\t134107000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 102, time = 1.75 m\n", + "INFO [matcher.py:101] Objective:\t133877000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 103, time = 1.75 m\n", + "INFO [matcher.py:101] Objective:\t133872000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 104, time = 1.79 m\n", + "INFO [matcher.py:101] Objective:\t133834000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0562\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 105, time = 1.81 m\n", + "INFO [matcher.py:101] Objective:\t133706000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0561\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 106, time = 1.86 m\n", + "INFO [matcher.py:101] Objective:\t133469000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0560\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 107, time = 1.89 m\n", + "INFO [matcher.py:101] Objective:\t133214000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 108, time = 1.89 m\n", + "INFO [matcher.py:101] Objective:\t133090000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 109, time = 1.89 m\n", + "INFO [matcher.py:101] Objective:\t133063000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 110, time = 1.90 m\n", + "INFO [matcher.py:101] Objective:\t133033000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 111, time = 1.92 m\n", + "INFO [matcher.py:101] Objective:\t133028000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 112, time = 1.92 m\n", + "INFO [matcher.py:101] Objective:\t133008000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 113, time = 1.93 m\n", + "INFO [matcher.py:101] Objective:\t132983000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 114, time = 1.93 m\n", + "INFO [matcher.py:101] Objective:\t132978000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 115, time = 1.98 m\n", + "INFO [matcher.py:101] Objective:\t132841000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 116, time = 1.98 m\n", + "INFO [matcher.py:101] Objective:\t132785000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 117, time = 1.98 m\n", + "INFO [matcher.py:101] Objective:\t132779000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 118, time = 2.04 m\n", + "INFO [matcher.py:101] Objective:\t132600000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 119, time = 2.05 m\n", + "INFO [matcher.py:101] Objective:\t132480000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 120, time = 2.05 m\n", + "INFO [matcher.py:101] Objective:\t132453000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 121, time = 2.06 m\n", + "INFO [matcher.py:101] Objective:\t132264000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 122, time = 2.17 m\n", + "INFO [matcher.py:101] Objective:\t132136000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 123, time = 2.21 m\n", + "INFO [matcher.py:101] Objective:\t132122000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 124, time = 2.22 m\n", + "INFO [matcher.py:101] Objective:\t132117000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 125, time = 2.23 m\n", + "INFO [matcher.py:101] Objective:\t132079000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 126, time = 2.33 m\n", + "INFO [matcher.py:101] Objective:\t132025000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 127, time = 2.35 m\n", + "INFO [matcher.py:101] Objective:\t132007000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 128, time = 2.35 m\n", + "INFO [matcher.py:101] Objective:\t131985000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 129, time = 2.35 m\n", + "INFO [matcher.py:101] Objective:\t131979000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 130, time = 2.37 m\n", + "INFO [matcher.py:101] Objective:\t131957000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 131, time = 2.42 m\n", + "INFO [matcher.py:101] Objective:\t131715000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 132, time = 2.49 m\n", + "INFO [matcher.py:101] Objective:\t131695000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 133, time = 2.51 m\n", + "INFO [matcher.py:101] Objective:\t131689000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 134, time = 2.53 m\n", + "INFO [matcher.py:101] Objective:\t131687000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 135, time = 2.53 m\n", + "INFO [matcher.py:101] Objective:\t131585000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 136, time = 2.54 m\n", + "INFO [matcher.py:101] Objective:\t131572000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 137, time = 2.54 m\n", + "INFO [matcher.py:101] Objective:\t131526000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 138, time = 2.54 m\n", + "INFO [matcher.py:101] Objective:\t131488000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 139, time = 2.60 m\n", + "INFO [matcher.py:101] Objective:\t131421000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 140, time = 2.61 m\n", + "INFO [matcher.py:101] Objective:\t131418000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 141, time = 2.63 m\n", + "INFO [matcher.py:101] Objective:\t131344000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 142, time = 2.63 m\n", + "INFO [matcher.py:101] Objective:\t131338000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 143, time = 2.64 m\n", + "INFO [matcher.py:101] Objective:\t131174000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 144, time = 2.64 m\n", + "INFO [matcher.py:101] Objective:\t131116000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 145, time = 2.76 m\n", + "INFO [matcher.py:101] Objective:\t131101000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 146, time = 2.76 m\n", + "INFO [matcher.py:101] Objective:\t131083000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 147, time = 2.76 m\n", + "INFO [matcher.py:101] Objective:\t131069000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 148, time = 2.77 m\n", + "INFO [matcher.py:101] Objective:\t131061000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 149, time = 2.77 m\n", + "INFO [matcher.py:101] Objective:\t131055000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 150, time = 2.77 m\n", + "INFO [matcher.py:101] Objective:\t131053000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 151, time = 2.78 m\n", + "INFO [matcher.py:101] Objective:\t131017000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 152, time = 2.80 m\n", + "INFO [matcher.py:101] Objective:\t130827000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 153, time = 2.81 m\n", + "INFO [matcher.py:101] Objective:\t130822000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 154, time = 2.83 m\n", + "INFO [matcher.py:101] Objective:\t130586000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 155, time = 2.84 m\n", + "INFO [matcher.py:101] Objective:\t130560000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 156, time = 2.86 m\n", + "INFO [matcher.py:101] Objective:\t130554000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 157, time = 2.86 m\n", + "INFO [matcher.py:101] Objective:\t130462000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 158, time = 2.87 m\n", + "INFO [matcher.py:101] Objective:\t130390000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 159, time = 2.91 m\n", + "INFO [matcher.py:101] Objective:\t130376000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 160, time = 2.96 m\n", + "INFO [matcher.py:101] Objective:\t130053000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 161, time = 2.96 m\n", + "INFO [matcher.py:101] Objective:\t130016000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 162, time = 2.96 m\n", + "INFO [matcher.py:101] Objective:\t129852000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 163, time = 2.97 m\n", + "INFO [matcher.py:101] Objective:\t129796000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 164, time = 2.97 m\n", + "INFO [matcher.py:101] Objective:\t129752000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 165, time = 2.98 m\n", + "INFO [matcher.py:101] Objective:\t129638000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 166, time = 3.02 m\n", + "INFO [matcher.py:101] Objective:\t129415000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 167, time = 3.08 m\n", + "INFO [matcher.py:101] Objective:\t129413000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 168, time = 3.08 m\n", + "INFO [matcher.py:101] Objective:\t129338000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 169, time = 3.11 m\n", + "INFO [matcher.py:101] Objective:\t129216000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 170, time = 3.20 m\n", + "INFO [matcher.py:101] Objective:\t129055000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 171, time = 3.26 m\n", + "INFO [matcher.py:101] Objective:\t129023000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 172, time = 3.27 m\n", + "INFO [matcher.py:101] Objective:\t128812000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 173, time = 3.27 m\n", + "INFO [matcher.py:101] Objective:\t128809000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 174, time = 3.28 m\n", + "INFO [matcher.py:101] Objective:\t128793000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 175, time = 3.38 m\n", + "INFO [matcher.py:101] Objective:\t128688000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 176, time = 3.39 m\n", + "INFO [matcher.py:101] Objective:\t128255000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 177, time = 3.55 m\n", + "INFO [matcher.py:101] Objective:\t128243000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 178, time = 3.56 m\n", + "INFO [matcher.py:101] Objective:\t127543000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 179, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t127017000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 180, time = 4.49 m\n", + "INFO [matcher.py:101] Objective:\t127008000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 181, time = 4.72 m\n", + "INFO [matcher.py:101] Objective:\t126858000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 182, time = 4.93 m\n", + "INFO [matcher.py:101] Objective:\t125797000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 183, time = 5.12 m\n", + "INFO [matcher.py:101] Objective:\t125342000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 184, time = 5.18 m\n", + "INFO [matcher.py:101] Objective:\t54272000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 185, time = 5.36 m\n", + "INFO [matcher.py:101] Objective:\t54271000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:618] Status = FEASIBLE\n", + "INFO [matcher.py:619] Number of solutions found: 185\n" ] }, { @@ -2146,7 +2784,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -2166,7 +2804,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2206,14 +2844,16 @@ "INFO [preprocess.py:335] Discretized age with bins [18.05, 27.54, 37.04, 46.53, 56.02, 65.51, 75.0].\n", "INFO [preprocess.py:335] Discretized height with bins [125.01, 136.68, 148.34, 160.01, 171.67, 183.34, 195.0].\n", "INFO [preprocess.py:335] Discretized weight with bins [50.0, 61.67, 73.33, 85.0, 96.66, 108.33, 120.0].\n", - "INFO [matcher.py:65] Scaling features by factor 2.00 in order to use integer solver with <= 0.0000% loss.\n" + "INFO [matcher.py:65] Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n" ] }, { "data": { "text/plain": [ "{'objective': 'gamma',\n", - " 'match_size': 1000,\n", + " 'pool_size': 1000,\n", + " 'target_size': 1000,\n", + " 'max_mismatch': None,\n", " 'time_limit': 360,\n", " 'num_workers': 4,\n", " 'ps_hinting': True,\n", @@ -2248,17 +2888,20 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO [matcher.py:319] Solving for match population with size = 1000. Will match on 27 dimensions ...\n", - "INFO [matcher.py:335] Calculating bounds on feature variables ...\n", - "INFO [matcher.py:350] Applying constraints ...\n", - "INFO [matcher.py:378] Training PS model as guide for solver ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/pybalance/lp/matcher.py:380: SettingWithCopyWarning: \n", + "INFO [matcher.py:418] Solving for match population with pool size = 1000 and target size = 1000 subject to None balance constraint.\n", + "INFO [matcher.py:421] Matching on 27 dimensions ...\n", + "INFO [matcher.py:428] Building model variables and constraints ...\n", + "INFO [matcher.py:437] Calculating bounds on feature variables ...\n", + "INFO [matcher.py:527] Applying size constraints on pool and target ...\n", + "INFO [matcher.py:533] Applying hint ...\n", + "INFO [matcher.py:540] Training PS model as guide for solver ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/pybalance/lp/matcher.py:542: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " target.loc[:, \"ix\"] = list(range(len(target)))\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/pybalance/lp/matcher.py:381: SettingWithCopyWarning: \n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/pybalance/lp/matcher.py:543: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -2267,10 +2910,10 @@ "INFO [preprocess.py:335] Discretized age with bins [18.05, 27.54, 37.04, 46.53, 56.02, 65.51, 75.0].\n", "INFO [preprocess.py:335] Discretized height with bins [125.01, 136.68, 148.34, 160.01, 171.67, 183.34, 195.0].\n", "INFO [preprocess.py:335] Discretized weight with bins [50.0, 61.67, 73.33, 85.0, 96.66, 108.33, 120.0].\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.000 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.001 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", - "INFO [matcher.py:139] \t* alpha: 4.774501445415407\n", + "INFO [matcher.py:139] \t* alpha: 4.774501445415405\n", "INFO [matcher.py:139] \t* class_weight: None\n", "INFO [matcher.py:139] \t* early_stopping: True\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", @@ -2282,7 +2925,7 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 2/50, 0.002 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.05854199518952411\n", + "INFO [matcher.py:139] \t* C: 0.058541995189524146\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l2\n", @@ -2292,7 +2935,7 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.003 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.09099552707413873\n", + "INFO [matcher.py:139] \t* C: 0.0909955270741388\n", "INFO [matcher.py:139] \t* fit_intercept: True\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l1\n", @@ -2302,246 +2945,262 @@ "INFO [matcher.py:180] Training model SGDClassifier (iter 4/50, 0.005 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.006 min) ...\n", "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.007 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.15085738749804517\n", + "INFO [matcher.py:139] \t* C: 0.15085738749804528\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0347\n", - "INFO [matcher.py:141] \tSolution time: 0.028 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.028 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.029 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.030 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.033 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:141] \tSolution time: 0.030 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.030 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.031 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.033 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.036 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 22.703034120730198\n", + "INFO [matcher.py:139] \t* C: 22.70303412073022\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0331\n", - "INFO [matcher.py:141] \tSolution time: 0.053 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.053 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.062 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.063 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:141] \tSolution time: 0.057 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.057 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.066 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.067 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.082 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.085 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.086 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.087 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.089 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.090 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.086 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.089 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.090 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.091 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.094 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.095 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.796468661160752\n", + "INFO [matcher.py:139] \t* C: 0.7964686611607528\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.110 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.110 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:141] \tSolution time: 0.115 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.116 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.129 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.130 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.131 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.135 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.136 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.137 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.152 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.153 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.154 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.165 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.166 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.167 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.172 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.173 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.174 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.177 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.158 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.159 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.160 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.172 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.173 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.174 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.179 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.180 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.181 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.184 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.197 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.206 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.207 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.208 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.209 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.219 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.220 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.221 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.227 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.228 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.229 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.230 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.231 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.232 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.234 min) ...\n", - "/opt/miniconda3/envs/pybalance/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.205 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.214 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.215 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.216 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.217 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.227 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.228 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.229 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.235 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.236 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.237 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.238 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.239 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.240 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.242 min) ...\n", + "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.254 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.255 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.264 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.265 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", - "INFO [matcher.py:139] \t* C: 0.796468661160752\n", + "INFO [matcher.py:139] \t* C: 0.7964686611607528\n", "INFO [matcher.py:139] \t* fit_intercept: False\n", "INFO [matcher.py:139] \t* max_iter: 500\n", "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.110 min\n", - "INFO [matcher.py:415] Hint achieves objective value = 1004.\n", - "INFO [matcher.py:417] Applying hints ...\n", - "INFO [matcher.py:446] Solving with 4 workers ...\n", - "INFO [matcher.py:89] Initial balance score: 0.2110\n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 1, time = 0.04 m\n", - "INFO [matcher.py:100] Objective:\t1156.0\n", - "INFO [matcher.py:113] Balance:\t0.0349\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 2, time = 0.08 m\n", - "INFO [matcher.py:100] Objective:\t1152.0\n", - "INFO [matcher.py:113] Balance:\t0.0348\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 3, time = 0.09 m\n", - "INFO [matcher.py:100] Objective:\t1102.0\n", - "INFO [matcher.py:113] Balance:\t0.0334\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 4, time = 0.10 m\n", - "INFO [matcher.py:100] Objective:\t1100.0\n", - "INFO [matcher.py:113] Balance:\t0.0334\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 5, time = 0.11 m\n", - "INFO [matcher.py:100] Objective:\t1064.0\n", - "INFO [matcher.py:113] Balance:\t0.0322\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 6, time = 0.11 m\n", - "INFO [matcher.py:100] Objective:\t1058.0\n", - "INFO [matcher.py:113] Balance:\t0.0321\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 7, time = 0.11 m\n", - "INFO [matcher.py:100] Objective:\t1056.0\n", - "INFO [matcher.py:113] Balance:\t0.0321\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 8, time = 0.12 m\n", - "INFO [matcher.py:100] Objective:\t1054.0\n", - "INFO [matcher.py:113] Balance:\t0.0320\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 9, time = 0.15 m\n", - "INFO [matcher.py:100] Objective:\t1052.0\n", - "INFO [matcher.py:113] Balance:\t0.0319\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 10, time = 0.15 m\n", - "INFO [matcher.py:100] Objective:\t1050.0\n", - "INFO [matcher.py:113] Balance:\t0.0319\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 11, time = 0.16 m\n", - "INFO [matcher.py:100] Objective:\t1048.0\n", - "INFO [matcher.py:113] Balance:\t0.0318\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 12, time = 0.18 m\n", - "INFO [matcher.py:100] Objective:\t1046.0\n", - "INFO [matcher.py:113] Balance:\t0.0318\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 13, time = 0.19 m\n", - "INFO [matcher.py:100] Objective:\t1044.0\n", - "INFO [matcher.py:113] Balance:\t0.0317\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 14, time = 0.23 m\n", - "INFO [matcher.py:100] Objective:\t1002.0\n", - "INFO [matcher.py:113] Balance:\t0.0301\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 15, time = 0.23 m\n", - "INFO [matcher.py:100] Objective:\t1000.0\n", - "INFO [matcher.py:113] Balance:\t0.0300\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 16, time = 0.24 m\n", - "INFO [matcher.py:100] Objective:\t994.0\n", - "INFO [matcher.py:113] Balance:\t0.0299\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 17, time = 0.25 m\n", - "INFO [matcher.py:100] Objective:\t928.0\n", - "INFO [matcher.py:113] Balance:\t0.0278\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 18, time = 0.25 m\n", - "INFO [matcher.py:100] Objective:\t926.0\n", - "INFO [matcher.py:113] Balance:\t0.0277\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 19, time = 0.26 m\n", - "INFO [matcher.py:100] Objective:\t920.0\n", - "INFO [matcher.py:113] Balance:\t0.0275\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 20, time = 0.28 m\n", - "INFO [matcher.py:100] Objective:\t190.0\n", - "INFO [matcher.py:113] Balance:\t0.0070\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 21, time = 0.28 m\n", - "INFO [matcher.py:100] Objective:\t188.0\n", - "INFO [matcher.py:113] Balance:\t0.0069\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 22, time = 0.29 m\n", - "INFO [matcher.py:100] Objective:\t186.0\n", - "INFO [matcher.py:113] Balance:\t0.0068\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:95] =========================================\n", - "INFO [matcher.py:96] Solution 23, time = 0.30 m\n", - "INFO [matcher.py:100] Objective:\t184.0\n", - "INFO [matcher.py:113] Balance:\t0.0067\n", - "INFO [matcher.py:116] Patients:\t1000\n", - "INFO [matcher.py:128] \n", - "INFO [matcher.py:453] Status = OPTIMAL\n", - "INFO [matcher.py:454] Number of solutions found: 23\n" + "INFO [matcher.py:141] \tSolution time: 0.115 min\n", + "INFO [matcher.py:577] Hint achieves objective value = 100400.\n", + "INFO [matcher.py:579] Applying hints ...\n", + "INFO [matcher.py:611] Solving with 4 workers ...\n", + "INFO [matcher.py:90] Initial balance score: 0.2110\n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 1, time = 0.05 m\n", + "INFO [matcher.py:101] Objective:\t115600000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0349\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 2, time = 0.14 m\n", + "INFO [matcher.py:101] Objective:\t115400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0349\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 3, time = 0.14 m\n", + "INFO [matcher.py:101] Objective:\t114600000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0346\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 4, time = 0.15 m\n", + "INFO [matcher.py:101] Objective:\t114400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0346\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 5, time = 0.16 m\n", + "INFO [matcher.py:101] Objective:\t113800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0344\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 6, time = 0.17 m\n", + "INFO [matcher.py:101] Objective:\t102000000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0310\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 7, time = 0.18 m\n", + "INFO [matcher.py:101] Objective:\t101400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0308\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 8, time = 0.20 m\n", + "INFO [matcher.py:101] Objective:\t100800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0306\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 9, time = 0.21 m\n", + "INFO [matcher.py:101] Objective:\t100400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0305\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 10, time = 0.26 m\n", + "INFO [matcher.py:101] Objective:\t97800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0300\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 11, time = 0.27 m\n", + "INFO [matcher.py:101] Objective:\t97200000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 12, time = 0.32 m\n", + "INFO [matcher.py:101] Objective:\t97000000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 13, time = 0.32 m\n", + "INFO [matcher.py:101] Objective:\t96600000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0297\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 14, time = 0.37 m\n", + "INFO [matcher.py:101] Objective:\t91000000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0282\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 15, time = 0.38 m\n", + "INFO [matcher.py:101] Objective:\t90800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0282\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 16, time = 0.38 m\n", + "INFO [matcher.py:101] Objective:\t90600000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0281\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 17, time = 0.43 m\n", + "INFO [matcher.py:101] Objective:\t80800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0249\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 18, time = 0.43 m\n", + "INFO [matcher.py:101] Objective:\t80600000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0248\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 19, time = 0.45 m\n", + "INFO [matcher.py:101] Objective:\t80400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0247\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 20, time = 0.49 m\n", + "INFO [matcher.py:101] Objective:\t19000000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0070\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 21, time = 0.65 m\n", + "INFO [matcher.py:101] Objective:\t18800000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0069\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 22, time = 0.67 m\n", + "INFO [matcher.py:101] Objective:\t18400000.0\n", + "INFO [matcher.py:120] Balance (gamma):\t0.0068\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:618] Status = OPTIMAL\n", + "INFO [matcher.py:619] Number of solutions found: 22\n" ] }, { @@ -2678,34 +3337,49 @@ " ...\n", " \n", " \n", - " 9948\n", - " 32.893818\n", - " 161.118343\n", - " 105.629306\n", - " 1.0\n", - " 0\n", - " 2\n", + " 9932\n", + " 72.514956\n", + " 159.248205\n", + " 118.505187\n", + " 0.0\n", + " 1\n", + " 5\n", " pool\n", + " 1\n", + " 1\n", " 0\n", - " 0\n", - " 0\n", - " 0\n", - " 9948\n", + " 1\n", + " 9932\n", " \n", " \n", - " 9957\n", - " 63.949429\n", - " 170.485188\n", - " 99.498013\n", - " 1.0\n", - " 2\n", + " 9933\n", + " 68.194783\n", + " 127.495418\n", + " 69.177329\n", + " 0.0\n", + " 1\n", " 5\n", " pool\n", + " 1\n", + " 1\n", " 0\n", " 0\n", + " 9933\n", + " \n", + " \n", + " 9965\n", + " 41.035792\n", + " 130.021437\n", + " 80.495109\n", + " 0.0\n", + " 0\n", " 1\n", + " pool\n", " 0\n", - " 9957\n", + " 1\n", + " 1\n", + " 1\n", + " 9965\n", " \n", " \n", " 9966\n", @@ -2723,34 +3397,19 @@ " 9966\n", " \n", " \n", - " 9981\n", - " 39.006118\n", - " 133.419182\n", - " 71.135407\n", - " 0.0\n", - " 1\n", - " 4\n", - " pool\n", - " 0\n", - " 0\n", - " 0\n", - " 0\n", - " 9981\n", - " \n", - " \n", - " 9983\n", - " 68.616093\n", - " 167.546870\n", - " 58.683367\n", + " 9984\n", + " 57.366166\n", + " 151.483411\n", + " 82.271539\n", " 1.0\n", - " 0\n", + " 2\n", " 2\n", " pool\n", " 0\n", + " 1\n", " 0\n", - " 0\n", - " 0\n", - " 9983\n", + " 1\n", + " 9984\n", " \n", " \n", "\n", @@ -2758,7 +3417,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -2778,7 +3437,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABF0AAAJjCAYAAADeR261AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2s0lEQVR4nOzdd3gUVd/G8XsTUgmhBRJ66BIJBGkGVFCR0Isi9kBEsPEIIoL6SFdRpAvSBMVHVKyI0kQERYggHWnSQ0sAKQECCSTz/sGblWU3ZZdMdonfz3Xl0j1z5uy9s8sk+eXMGYthGIYAAAAAAACQp7zcHQAAAAAAAKAgougCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYAKKLgAAAAAAACag6AIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgCAhwoPD1f37t2tjz/66CNZLBatW7cuX56/efPmat68eb48F9zDYrGod+/epj/P7t271bJlSxUtWlQWi0Xz5s0z/TkBAPAEFF0AAP8ae/fu1dNPP60qVarI399fwcHBatq0qSZMmKCLFy+a9rzbt2/X0KFDdeDAAdOew1WemM0TM+HGdOvWTVu3btWbb76p//3vf2rQoEGeP0dKSoqGDh2qFStW5PnYAAC4qpC7AwAAkB8WLFigBx98UH5+foqNjVXt2rWVlpam3377TS+//LK2bdum6dOnm/Lc27dv17Bhw9S8eXOFh4fner9du3bJy8vcv49kl+3HH3809bldyYSbz8WLFxUfH6///ve/ps6qSUlJ0bBhwySJGVoAAI9B0QUAUODt379fDz/8sCpVqqSff/5ZZcqUsW57/vnntWfPHi1YsMCNCf9hGIYuXbqkgIAA+fn5uTWLr6+vW58fBcOJEyckScWKFXNvEBdduXJFGRkZ/HsAALiEy4sAAAXeqFGjdP78ec2cOdOm4JKpWrVq6tOnj/XxlStXNGLECFWtWlV+fn4KDw/Xa6+9ptTUVJv9wsPD1a5dO/32229q1KiR/P39VaVKFX388cfWPh999JEefPBBSdLdd98ti8Uii8VivQQic4wlS5aoQYMGCggI0LRp06zbrl3TJVNKSoqefvpplSxZUsHBwYqNjdXp06dt+lgsFg0dOtRu32vHzCmbozVdjh8/rh49eig0NFT+/v6qW7euZs+ebdPnwIEDslgsGj16tKZPn249jg0bNtQff/xhl+laOWWSpPfff1+33nqr/Pz8VLZsWT3//PM6c+ZMtuNmWrFihRo0aCB/f39VrVpV06ZN09ChQ2WxWGz6ffjhh7rnnntUunRp+fn5KSIiQlOmTLEbL/P9yxw3ICBAkZGR1rzffPONIiMj5e/vr/r162vjxo02+3fv3l1BQUFKSEhQu3btFBQUpHLlymny5MmSpK1bt+qee+5R4cKFValSJX366ac2+586dUr9+/dXZGSkgoKCFBwcrNatW2vz5s25Oh6Z5syZo5o1a1pz/vrrr9Zty5cvl8Vi0bfffmu336effiqLxaL4+HiH4w4dOlSVKlWSJL388suyWCw2s5eOHDmiJ598UqGhofLz89Ott96qWbNm2YyRlpamwYMHq379+ipatKgKFy6sO++8U8uXL7f2OXDggEqVKiVJGjZsmPVzk/lvIKv1ibp3726T59rP7vjx462f3e3bt0uSdu7cqS5duqhEiRLy9/dXgwYNNH/+/KwPLADgX4+ZLgCAAu/7779XlSpV1KRJk1z1f+qppzR79mx16dJFL730ktasWaORI0dqx44ddr947tmzR126dFGPHj3UrVs3zZo1S927d1f9+vV166236q677tILL7ygiRMn6rXXXlOtWrUkyfpf6eplRI888oiefvpp9ezZUzVr1sw2X+/evVWsWDENHTpUu3bt0pQpU3Tw4EGtWLHCrniQndxku9bFixfVvHlz7dmzR71791blypX15Zdfqnv37jpz5oxN4Uq6+gv5uXPn9PTTT8tisWjUqFG6//77tW/fPvn4+LiUaejQoRo2bJhatGihZ5991vr6//jjD61atSrLcSVp48aNatWqlcqUKaNhw4YpPT1dw4cPt/6yfq0pU6bo1ltvVYcOHVSoUCF9//33eu6555SRkaHnn3/epu+ePXv06KOP6umnn9bjjz+u0aNHq3379po6dapee+01Pffcc5KkkSNHqmvXrnaXjaWnp6t169a66667NGrUKM2ZM0e9e/dW4cKF9d///lePPfaY7r//fk2dOlWxsbGKjo5W5cqVJUn79u3TvHnz9OCDD6py5cpKSkrStGnT1KxZM23fvl1ly5bN8nhk+uWXXzR37ly98MIL8vPz0/vvv69WrVpp7dq1ql27tpo3b64KFSpozpw56ty5s82+c+bMUdWqVRUdHe1w7Pvvv1/FihXTiy++qEceeURt2rRRUFCQJCkpKUm33367dTHfUqVKadGiRerRo4eSk5PVt29fSVJycrI++OADPfLII+rZs6fOnTunmTNnKiYmRmvXrlVUVJRKlSqlKVOm6Nlnn1Xnzp11//33S5Lq1KmT4+t35MMPP9SlS5fUq1cv+fn5qUSJEtq2bZuaNm2qcuXK6ZVXXlHhwoX1xRdfqFOnTvr666/tjg0AAJIkAwCAAuzs2bOGJKNjx4656r9p0yZDkvHUU0/ZtPfv39+QZPz888/WtkqVKhmSjF9//dXadvz4ccPPz8946aWXrG1ffvmlIclYvny53fNljrF48WKH27p162Z9/OGHHxqSjPr16xtpaWnW9lGjRhmSjO+++87aJskYMmRIjmNml61Zs2ZGs2bNrI/Hjx9vSDI++eQTa1taWpoRHR1tBAUFGcnJyYZhGMb+/fsNSUbJkiWNU6dOWft+9913hiTj+++/t3uua2WV6fjx44avr6/RsmVLIz093do+adIkQ5Ixa9asbMdt3769ERgYaBw5csTatnv3bqNQoULG9T8SpaSk2O0fExNjVKlSxaYt8/1bvXq1tW3JkiWGJCMgIMA4ePCgtX3atGl2r6tbt26GJOOtt96ytp0+fdoICAgwLBaL8fnnn1vbd+7cafe+Xrp0yeZYGMbV4+/n52cMHz482+NhGFc/J5KMdevWWdsOHjxo+Pv7G507d7a2vfrqq4afn59x5swZa9vx48eNQoUKOfycXZ9HkvHuu+/atPfo0cMoU6aMcfLkSZv2hx9+2ChatKj1Pbhy5YqRmppq0+f06dNGaGio8eSTT1rbTpw4keXn/vrPcqZu3boZlSpVsssaHBxsHD9+3Kbvvffea0RGRhqXLl2ytmVkZBhNmjQxqlevnu0xAAD8e3F5EQCgQEtOTpYkFSlSJFf9Fy5cKEnq16+fTftLL70kSXZrv0REROjOO++0Pi5VqpRq1qypffv25Tpj5cqVFRMTk+v+vXr1spnR8eyzz6pQoULW7GZZuHChwsLC9Mgjj1jbfHx89MILL+j8+fP65ZdfbPo/9NBDKl68uPVx5nFy5thc66efflJaWpr69u1rM1OkZ8+eCg4OznZdnvT0dP3000/q1KmTzeyPatWqqXXr1nb9AwICrP9/9uxZnTx5Us2aNdO+fft09uxZm74RERE2Mz0aN24sSbrnnntUsWJFu3ZHr/+pp56y/n+xYsVUs2ZNFS5cWF27drW216xZU8WKFbPZ38/Pz3os0tPT9ffffysoKEg1a9bUhg0bsjwe14qOjlb9+vWtjytWrKiOHTtqyZIlSk9PlyTFxsYqNTVVX331lbXf3LlzdeXKFT3++OO5ep5rGYahr7/+Wu3bt5dhGDp58qT1KyYmRmfPnrXm9/b2tq6nkpGRoVOnTunKlStq0KBBrl+jsx544AGbGVCnTp3Szz//rK5du+rcuXPWrH///bdiYmK0e/duHTlyxJQsAICbG5cXAQAKtODgYEnSuXPnctX/4MGD8vLyUrVq1Wzaw8LCVKxYMR08eNCm/dpfqjMVL17cbo2V7GReKpJb1atXt3kcFBSkMmXKmH6L5YMHD6p69ep2d1TKvPQnp2OTWYBx5thc//yS7C6/8vX1VZUqVeye/1rHjx/XxYsX7d5XSQ7bVq1apSFDhig+Pl4pKSk2286ePauiRYtaH1//OjO3VahQwWH79a/f39/f7hKnokWLqnz58naXixUtWtRm/4yMDE2YMEHvv/++9u/fby2SSFLJkiXtXpcj13+eJKlGjRpKSUnRiRMnFBYWpltuuUUNGzbUnDlz1KNHD0lXLy26/fbbHR6/nJw4cUJnzpzR9OnTs7xr2PHjx63/P3v2bI0ZM0Y7d+7U5cuXre3O/tvJrevH3bNnjwzD0KBBgzRo0KAs85YrV86UPACAmxdFFwBAgRYcHKyyZcvqzz//dGq/3K6N4u3t7bDdMIxcP9e1syrMdu0v5WbLi2PjDnv37tW9996rW265RWPHjlWFChXk6+urhQsXaty4ccrIyLDpn9XrzO3rv5H933rrLQ0aNEhPPvmkRowYoRIlSsjLy0t9+/a1y3mjYmNj1adPHx0+fFipqan6/fffNWnSJJfGysz2+OOPq1u3bg77ZK7H8sknn6h79+7q1KmTXn75ZZUuXVre3t4aOXKk9u7dm6vns1gsDj93Wf17uP7fZGbe/v37ZzkrzZXiEwCg4KPoAgAo8Nq1a6fp06crPj4+ywU/M1WqVEkZGRnavXu3zYKySUlJOnPmjPVOLM5wZnHb3Ni9e7fuvvtu6+Pz58/r2LFjatOmjbWtePHidnf0SUtL07Fjx1zOVqlSJW3ZskUZGRk2s1127txp3Z4XssqUOf6uXbtUpUoVa3taWpr279+vFi1aZDlm6dKl5e/vrz179thtu77t+++/V2pqqubPn28zi+Xau+V4iq+++kp33323Zs6cadN+5swZhYSE5GqM3bt327X99ddfCgwMtJmB8/DDD6tfv3767LPPdPHiRfn4+Oihhx5yKXepUqVUpEgRpaenZ/u+SVdfY5UqVfTNN9/YfDaGDBli0y+7z3Lx4sUdXtaV3eyoa2V+3nx8fHLMCwDAtVjTBQBQ4A0YMECFCxfWU089paSkJLvte/fu1YQJEyTJWrgYP368TZ+xY8dKktq2bev08xcuXFiScn1b45xMnz7d5hKLKVOm6MqVKzZrk1StWtXmtr+Z+13/l31nsrVp00aJiYmaO3eute3KlSt67733FBQUpGbNmrnycuxklalFixby9fXVxIkTbWYtzJw5U2fPns32vfH29laLFi00b948HT161Nq+Z88eLVq0yK6vZDuj5OzZs/rwww9dfk1m8fb2tpvB8eWXXzq1vkh8fLzN2iiHDh3Sd999p5YtW9rMtgkJCVHr1q31ySefaM6cOWrVqlWuCzuOcj/wwAP6+uuvHc5CO3HihE1fyfb9WLNmjd1tqgMDAyU5/ixXrVpVO3futBl38+bNWrVqVa7yli5dWs2bN9e0adPsCpfX5wUA4FrMdAEAFHhVq1bVp59+qoceeki1atVSbGysateurbS0NK1evdp622NJqlu3rrp166bp06frzJkzatasmdauXavZs2erU6dONjNMcisqKkre3t565513dPbsWfn5+emee+5R6dKlXXo9aWlpuvfee623H37//fd1xx13qEOHDtY+Tz31lJ555hk98MADuu+++7R582YtWbLE7pdkZ7L16tVL06ZNU/fu3bV+/XqFh4frq6++0qpVqzR+/PhcL1ack+wyvfrqqxo2bJhatWqlDh06WF9/w4YNc1zQdejQofrxxx/VtGlTPfvss0pPT9ekSZNUu3Ztbdq0ydqvZcuW8vX1Vfv27fX000/r/PnzmjFjhkqXLu3wF253ateunYYPH664uDg1adJEW7du1Zw5c2xmAuWkdu3aiomJsblltCQNGzbMrm9sbKy6dOkiSRoxYsQNZX/77be1fPlyNW7cWD179lRERIROnTqlDRs26KefftKpU6esr/Gbb75R586d1bZtW+3fv19Tp05VRESEzp8/bx0vICBAERERmjt3rmrUqKESJUqodu3aql27tp588kmNHTtWMTEx6tGjh44fP66pU6fq1ltvtS62nZPJkyfrjjvuUGRkpHr27KkqVaooKSlJ8fHxOnz4sDZv3nxDxwMAUEC556ZJAADkv7/++svo2bOnER4ebvj6+hpFihQxmjZtarz33ns2t4G9fPmyMWzYMKNy5cqGj4+PUaFCBePVV1+16WMYV28X3LZtW7vncXR72hkzZhhVqlQxvL29bW4bnNUYmdsc3TL6l19+MXr16mUUL17cCAoKMh577DHj77//ttk3PT3dGDhwoBESEmIEBgYaMTExxp49e+zGzC6bo9eRlJRkxMXFGSEhIYavr68RGRlpfPjhhzZ9srpFsGFkfSvr62WVyTCu3iL6lltuMXx8fIzQ0FDj2WefNU6fPp3jmIZhGMuWLTPq1atn+Pr6GlWrVjU++OAD46WXXjL8/f1t+s2fP9+oU6eO4e/vb4SHhxvvvPOOMWvWLEOSsX//fmu/rN4/Scbzzz9v0+bouHTr1s0oXLiw3f7NmjUzbr31Vrv265/v0qVLxksvvWSUKVPGCAgIMJo2bWrEx8dneYvkrHJ+8sknRvXq1Q0/Pz+jXr16Dm8hbhiGkZqaahQvXtwoWrSocfHixRzHN4zsPw9JSUnG888/b1SoUMHw8fExwsLCjHvvvdeYPn26tU9GRobx1ltvGZUqVbLm++GHH+xu92wYhrF69Wqjfv36hq+vr91n7ZNPPjGqVKli+Pr6GlFRUcaSJUuyvGW0o6yGYRh79+41YmNjjbCwMMPHx8coV66c0a5dO+Orr77K1bEAAPz7WAzDw1ezAwAAMFGnTp20bds2h2ubwNaVK1dUtmxZtW/f3m4dGQAAYI81XQAAwL/GxYsXbR7v3r1bCxcuVPPmzd0T6CYzb948nThxQrGxse6OAgDATYGZLgAA4F+jTJky6t69u6pUqaKDBw9qypQpSk1N1caNG1W9enV3x/NYa9as0ZYtWzRixAiFhITYLLwLAACyxkK6AADgX6NVq1b67LPPlJiYKD8/P0VHR+utt96i4JKDKVOm6JNPPlFUVJQ++ugjd8cBAOCmwUwXAAAAAAAAE7CmCwAAAAAAgAn+dZcXZWRk6OjRoypSpIgsFou74wAAAAAAgJuMYRg6d+6cypYtKy+vrOez/OuKLkePHlWFChXcHQMAAAAAANzkDh06pPLly2e5/V9XdClSpIikqwcmODjYzWnsVatWTXv27HF3DIfI5jxPzSWRzVWems1Tc0lkc5WnZvPUXBLZXOWp2Tw1l0Q2V3lqNk/NJZHNVZ6azVNzSWRzRXJysipUqGCtMWTlX1d0ybykKDg42COLLl5eXh6ZSyKbKzw1l0Q2V3lqNk/NJZHNVZ6azVNzSWRzladm89RcEtlc5anZPDWXRDZXeWo2T80lke1G5LRsCQvpAgAAAAAAmICiCwAAAAAAgAkougAAAAAAAJjgX7emCwAAAICbR3p6ui5fvmza+OXLl9elS5dMG/9GkM01nprNU3NJZHPEx8dH3t7eNzwORRcAAAAAHscwDCUmJurMmTOmPs9bb72l/fv3m/ocriKbazw1m6fmksiWlWLFiiksLCzHxXKzQ9EFAAAAgMfJLLiULl1agYGBN/RLT3ZSU1NVuXJlU8a+UWRzjadm89RcEtmuZxiGUlJSdPz4cUlSmTJlXB6LogsAAAAAj5Kenm4tuJQsWdLU57JYLPL39zf1OVxFNtd4ajZPzSWRzZGAgABJ0vHjx1W6dGmXLzViIV0AAAAAHiVzDZfAwEA3JwHwb5Z5DrqRdaUougAAAADwSGZdUgQAuZEX5yCKLgAAAAAAACag6AIAAAAAAGACFtIFAAAAcNOo//LHeT/oJ5uz3LT+3di8f748EB4err59+6pv375Z9klLS1NERIQ+/vhjNWnSJP/CwTTbt29Xy5YttWvXLhUuXNjdcZALzHQBAAAAgAJo6tSpqly5MgUXF3z55Ze65ZZb5O/vr8jISC1cuDDHfVasWKHbbrtNfn5+qlatmj766CO7PpMnT1Z4eLj8/f3VuHFjrV271rrtwIEDslgsDr++/PJLSVJERIRuv/12jR07Ns9eK8xF0QUAAAAAChjDMDRp0iT16NHD3VFuOqtXr9YjjzyiHj16aOPGjerUqZM6deqkP//8M8t99u/fr7Zt2+ruu+/Wpk2b1LdvXz311FNasmSJtc+SJUvUr18/DRkyRBs2bFDdunUVExOj48ePS5IqVKigY8eO2XwNGzZMQUFBat26tXWcuLg4TZkyRVeuXDHvICDPUHQBAAAAgDzSvHlz9e7dW71791bRokUVEhKiQYMGyTAMa5/Tp08rNjZWxYsXV2BgoFq3bq3du3fbjPP111/r/vvvl5+fn8LDwzVmzBincqxfv1579+5V27ZtbdpXr16tqKgo+fv7q0GDBpo3b54sFos2bdokSUpPT1ePHj1UuXJlBQQEqGbNmpowYYLNGN27d1ffvn311ltvKTQ0VMWKFdPw4cN15coVvfzyyypRooTKly+vDz/80LpP5iyOL774QnfeeacCAgLUsGFD/fXXX/rjjz/UoEEDa3HhxIkT1v3++OMP3XfffQoJCVHRokXVrFkzbdiwwalj4awJEyaoVatWevnll1WrVi2NGDFCt912myZNmpTlPpmzisaMGaNatWqpd+/e6tKli8aNG2ft87///U89e/ZUXFycIiIiNHXqVAUGBmrWrFmSJG9vb4WFhdl8ffvtt+ratauCgoKs49x33306deqUfvnlF/MOAvIMRRcAAAAAyEOzZ89WoUKFtHbtWk2YMEFjx47VBx98YN3evXt3rVu3TvPnz1d8fLwMw1CbNm10+fJlSVcLJl27dlWrVq20detWDR06VIMGDXJ4uUpWVq5cqRo1aqhIkSLWtuTkZLVv316RkZHasGGDRowYoYEDB9rsl5GRofLly+vLL7/U9u3bNXjwYL322mv64osvbPr98ccfOnr0qH799VeNHTtWQ4YMUbt27VS8eHGtWbNGzzzzjJ5++mkdPnzYZr8hQ4bo9ddf14YNG1SoUCE9+uijGjBggCZMmKCVK1dqz549Gjx4sLX/uXPn1K1bN/3222/6/fffVb16dbVp00bnzp3L8rUvWLBAQUFB2X6tXLkyy/3j4+PVokULm7aYmBjFx8e7vE9aWpp27Nhh08fLy0stWrTIctz169dr06ZNdrOVfH19FRUVle1rgOdgIV0AAAAAyEMVKlTQuHHjZLFYVLNmTW3dulXjxo1Tz549tXv3bs2fP1+rVq2yrrUyZ84cVahQQfPmzdODDz6osWPH6t5771WvXr1Uo0YN1ahRQ9u3b9e7776r7t275yrDwYMHVbZsWZu2Tz/9VBaLRTNmzJC/v78iIiJ05MgR9ezZ09rHx8dHw4YNsz6uXLmy4uPj9cUXX6hr167W9uDgYE2cOFFeXl6qWbOmRo0apZSUFL322muSpFdffVVvv/22fvvtNz388MPW/fr376+YmBhJUp8+ffTII49o2bJlatq0qSSpR48eNsWle+65x+Y1TJ8+XcWKFdMvv/yidu3aOXztzZs3t8nqSLly5bLclpiYqNDQUJu20NBQJSYmOr1PcnKyLl68qNOnTys9Pd1hn507dzocc+bMmapVq5bDNXnKli2rgwcPZpkHnoOiCwAAAADkodtvv10Wi8X6ODo6WmPGjFF6erp27NihQoUKqXHjxtbtJUuWVM2aNbVjxw5J0o4dO9SxY0ebMZs2barx48crPT1d3t7eOWa4ePGi/P39bdp27dqlOnXq2LQ3atTIbt/Jkydr1qxZSkhI0MWLF5WWlqaoqCibPlWrVpWX1z8XToSGhqp27drWx97e3ipZsqR1vZJMderUsdlHkiIjI23art0nKSlJr7/+ulasWKHjx48rPT1dKSkpSkhIyPK1Fy5cWNWqVcty+83g4sWL+vTTTzVo0CCH2wMCApSSkpLPqeAKLi8CAAAAgAImJCREp0+fdnq/zz//XP3791ePHj30448/atOmTYqLi1NaWppNv0KFbP9+b7FY5OPjY9eWkZFh03Ztn8zC1PVt1+7TrVs3bdq0SRMmTNDq1au1adMmlSxZ0i7PtW708qKwsDAlJSXZtCUlJSksLMzpfYKDgxUQEKCQkBB5e3vnetyvvvpKKSkpio11fMvyU6dOqVSpUlnmgedgpgsAAAVIwvDInDtJqjh4q8lJAODfa82aNTaPM9ci8fb2Vq1atXTlyhWtWbPGetnI33//rV27dikiIkKSVKtWLa1atUqdOnWyjrFq1SrVqFEjV7NcJKlevXqaMmWKDMOwFjdq1qypTz75RKmpqfLz85N0dW2Wa2Ve9vTcc89Z2/bu3evcAchDq1at0vvvv682bdpIkg4dOqSTJ09mu8+NXl4UHR2tZcuWqW/fvta2pUuXKjo6Ott9rr+t9LX7+Pr6qlatWlq2bJn1fc3IyNCyZcvUu3dvu/FmzpypDh06ZFlY+fPPP9WlS5cs88BzMNMFAAAAAPJQQkKC+vXrp127dumzzz7Te++9pz59+kiSqlevro4dO6pnz5767bfftHnzZj3++OMqV66c9ZKil156ScuWLdP06dP1119/afbs2Zo0aZL69++f6wx33323zp8/r23btlnbHn30UWVkZKhXr17asWOHlixZotGjR0v6Z9ZJ9erVtW7dOi1ZskR//fWXBg0aZFeYyU/Vq1fX//73P+3YsUNr1qzRY489poCAgGz3yby8KLuv7Mbo06ePFi9erDFjxmjnzp0aOnSo1q1bZ1McefXVV21moTzzzDPat2+fBgwYoJ07d+r999/XF198oRdffNHa54knntCMGTM0e/Zs7dixQ88++6wuXLiguLg4m+ffs2ePfv31Vz311FMO8x04cEBHjhyxW7gXnomZLgAAAABuGuvfdXy5has2b96sunXr5umYsbGxunjxoho1aiRvb2/16dNHvXr1sm7/8MMP1adPH7Vr105paWm66667tHDhQutlNrfddpu++OILDRgwQDNmzFCZMmU0fPjwXC+iK11dJ6Zz586aM2eORo4cKenq4rfff/+9nn32WUVFRSkyMlKDBw/Wo48+al3n5emnn9bGjRv10EMPyWKx6JFHHtFzzz2nRYsW5d0BcsLMmTPVq1cv3XbbbapQoYLeeustp4pPrmjSpIk+/fRTvf7663rttddUvXp1zZs3z2bNmmPHjtmsK1O5cmUtWLBAL774oiZMmKDy5cvrgw8+sC4aLF29m1FgYKAGDx6sxMRERUVFafHixXaL686aNUvly5dXy5YtHeb77LPP1LJlS1WqVCmPXznMYDGuvWH8v0BycrKKFi2qs2fPKjg42N1x7ISFhWW7KrY7kc15nppLIpurPDWbp+aSyOYqV7OZfXlRQTxm+YFszvPUXBLZXOVMtkuXLmn//v2qXLmy3WKweS2viy7NmzdXVFSUxo8ff8Nj3Wi2LVu26L777tPevXsVFBTksM+cOXMUFxens2fP5jiDJC+zmclTs+VFrrS0NFWvXl2ffvqp9Y5PecFTj5nk3mzZnYtyW1tgpgsAAAAAFEB16tTRO++8o/3791vvEPTxxx+rSpUqKleunDZv3qyBAweqa9euThVc4D4JCQl67bXX8rTgAnNRdAEAAACAAur6S5ISExOtl7eUKVNGDz74oN588033hIPTMtekwc2DogsAAAAA5JEVK1a4O0K2BgwYoAEDBrg7BvCvwd2LAAAAAAAATEDRBQAAAAAAwAQUXQAAAAAAAExA0QUAAAAAAMAEFF0AAAAAAABMQNEFAAAAAADABNwyGgAAAMBNI2F4ZJ6OV1xSwndZb684eGuePl9eCQ8PV9++fdW3b98s+6SlpSkiIkIff/yxmjRpkn/hPIDFYtG3336rTp06Ody+fft2tWzZUrt27VLhwoVzHO+uu+7SM888o0cffTSPk8Jdbr/9dr388st64IEHTH0eZroAAAAAQAE0depUVa5c+aYuuBw4cEAWi0WbNm3K03EjIiJ0++23a+zYsTn2nT9/vpKSkvTwww/naYZ/gxUrVui2226Tn5+fqlWrpo8++ijH/h07dlSZMmVUuHBhRUVFacGCBTZ9tm3bpgceeEDh4eGyWCwaP3683Ti//vqr2rdvr7Jly8pisWjevHl2fV5//XW98sorysjIuIFXmDOKLgAAAABQwBiGoUmTJqlHjx43PM6VK1fyKJVniYuL05QpU3J8fRMnTlRcXJy8vPj12Rn79+9X27Ztdffdd2vTpk3q27evnnrqKS1ZsiTLfVavXq06dero66+/1pYtWxQXF6dBgwbphx9+sPZJSUlRlSpV9PbbbyssLMzhOBcuXFDdunU1efLkLJ+rdevWOnfunBYtWuT6i8wFPjUAAAAAkEeaN2+u3r17q3fv3ipatKhCQkI0aNAgGYZh7XP69GnFxsaqePHiCgwMVOvWrbV7926bcb7++mvdf//98vPzU3h4uMaMGeNUjvXr12vv3r1q27attS1z1sjnn3+uJk2ayN/fX7Vr19Yvv/xi7bNixQpZLBYtWrRI9evXl5+fn3777TdlZGRo5MiRqly5sgICAtS1a1d99dVXdvstWbJE9erVU0BAgO655x4dP35cixYtUq1atRQcHKxHH31UKSkp1v0WL16sO+64Q8WKFVPJkiXVrl077d2717q9cuXKkqR69erJYrGoefPm1m2zZs3SrbfeKj8/P5UpU0a9e/e2OQYnT55U586dFRgYqOrVq2v+/Pk22++77z6dOnXK5vVf78SJE/r555/Vvn17m/adO3fqjjvukL+/vyIiIvTTTz/ZzagYOHCgatSoocDAQFWpUkWTJ0/W5cuXrduHDh2qqKgozZo1SxUrVlRQUJCee+45paena9SoUQoLC1Pp0qX15ptv2jy3xWLRtGnT1K5dOwUGBqpWrVqKj4/Xnj171Lx5cxUuXFhNmjSxOY579+5Vx44dFRoaqqCgIDVs2FA//fRTlq87L2TOtBozZoxq1aql3r17q0uXLho3blyW+7z22msaMWKEmjRpoqpVq6pPnz5q0qSJvvnmG2ufhg0b6t1339XDDz8sPz8/h+O0bt1ab7zxhjp37pzlc3l7e6tNmzb6/PPPXX+RuUDRBQAAAADy0OzZs1WoUCGtXbtWEyZM0NixY/XBBx9Yt3fv3l3r1q3T/PnzFR8fL8Mw1KZNG+sv5OvXr1fXrl3VqlUrbd26VUOHDtWgQYNyvDTjWitXrlSNGjVUpEgRu20vv/yyXnrpJW3cuFHR0dFq3769/v77b5s+r7zyit5++23t2LFDderU0ciRI/Xxxx9r6tSp2rZtmx577DE9/vjjdgWLoUOHatKkSVq9erUOHTqkrl27avz48fr000+1YMEC/fjjj3rvvfes/S9cuKB+/fpp3bp1WrZsmby8vNS5c2frJR9r166VJP300086duyY9ZfvKVOm6Pnnn1evXr20detWzZ8/X9WqVbPJMmzYMHXt2lVbtmxRmzZt9Nhjj+nUqVPW7b6+voqKitLKlSuzPI6//fabtbCRKT09XZ06dVJgYKDWrFmj6dOn67///a/dvkWKFNFHH32k7du3a8KECfrmm2/sCg579+7VokWLtHjxYn322WeaOXOm2rZtq8OHD+uXX37RO++8o9dff11r1qyx2W/EiBGKjY3Vpk2bdMstt+jRRx/V008/rVdffVXr1q2TYRg2Rajz58+rTZs2WrZsmTZu3KhWrVqpffv2SkhIyPK1r1y5UkFBQdl+zZkzJ8v94+Pj1aJFC5u2mJgYxcfHZ7mPI+fPn1eJEiWc2ie3GjVqlO37nxdYSBcAAAAA8lCFChU0btw4WSwW1axZU1u3btW4cePUs2dP7d69W/Pnz9eqVausa63MmTNHFSpU0Lx58/Tggw9q7Nixuvfee9WrVy/VqFFDNWrU0Pbt2/Xuu++qe/fuucpw8OBBlS1b1uG23r17WxcPnTJlihYvXqyZM2dqwIAB1j7Dhw/XfffdJ0lKTU3VW2+9pZ9++knR0dGSpI4dOyohIUHTpk1Ts2bNrPu98cYbatq0qSSpR48eevXVV7V3715VqVJFktSlSxctX75cAwcOlCS7RUxnzZqlUqVKafv27apdu7ZKlSolSSpZsqTNpSRvvPGGXnrpJfXp08fa1rBhQ5uxunfvrkceeUSS9NZbb2nixIlau3atWrVqZe1TtmxZHTx4MNvjGBoaanNp0dKlS7V3716tWLHCmunNN9+0Hq9Mr7/+uvX/w8PDFRsbqy+++MLmOGdkZGjWrFkqUqSIIiIidPfdd2vXrl1auHChvLy8VLNmTb3zzjtavny5GjdubN0vLi5OXbt2lXR1Rk10dLQGDRqkmJgYSVKfPn0UFxdn7V+3bl3VrVvX+njEiBH69ttvNX/+fLsZQpkaNGiQ41o6oaGhWW5LTEy02x4aGqrk5GRdvHhRAQEB2Y4tSV988YW2bdumTz75JMe+rihbtqwOHTqkjIwM0y4fo+gCAAAAAHno9ttvl8VisT6Ojo7WmDFjlJ6erh07dqhQoUI2v0CXLFlSNWvW1I4dOyRJO3bsUMeOHW3GbNq0qcaPH6/09HR5e3vnmOHixYvy9/d3uC2zcCJJhQoVUoMGDazPnalBgwbW/9+zZ49SUlJsigoZGRm6cuWK6tWrZ7NfnTp1rP8fGhpqvbTm2rbM2SuStHv3bg0ePFhr1qzRyZMnrTNcEhISVLt2bYf5jx8/rqNHj+ree+/N8vVfn6Vw4cIKDg7W8ePHbfoEBATYXO50PUfHcdeuXapQoYJNEahRo0Z2+86dO1cTJ07U3r17df78eV2+fFlFixa16RMeHm4zGyk0NFTe3t42BYDQ0FC73NcfZ0mKjIy0abt06ZKSk5MVHBys8+fPa+jQoVqwYIGOHTumK1eu6OLFi9nOdAkICLCbPZSfli9frri4OA0ePFi33nqrKc8REBCgjIwMpaam5qoI5AqKLgAAAABQwISEhGjrVtdvd33tbZTPnz8vSVqwYIHKlSsn6WphqFatWnZravj4+Fj/32Kx2DzObLv2bjHt27dXpUqVNGPGDJUtW1YZGRmqXbu20tLSssyW21+Oc3puSTp16pSqVq2a5RghISE6ffp0rp7vWvHx8Xrsscc0bNgwxcTEqGjRoho/frzd5TiOMuYm9/XHOau2zP369++vpUuXavTo0apWrZoCAgLUpUuXbI/zypUr1bp162xf57Rp0/TYY4853BYWFqakpCSbtqSkJAUHB+f4Hv7yyy9q3769xo0bZ1OgzGunTp1S4cKFTSu4SBRdAAAAACBPXb/+xu+//67q1avL29tbtWrV0pUrV7RmzRrr5UV///23du3apYiICElSrVq1tGrVKnXq1Mk6xqpVq1SjRo1czXKRri48O2XKFBmGYTPrJjPPXXfdJUm6cuWK1q9fn+UlJtLV2yv7+fkpISHBeinRhQsXbngWRObrnjFjhu68805JV9dQuZavr6+kq+uoZCpSpIjCw8O1bNky3X333TeU4c8//1SXLl2y3F6vXj0lJibq9OnTKl68uCSpZs2aOnTokJKSkqyzTP744w+b/VavXq1KlSrZrPVy7NixG8p6I1atWqXu3btbF5Y9f/68Dhw4kO0+N3p5UXR0tBYuXGjTtnTpUpuZVo6sWLFC7dq10zvvvKNevXpp8+bN2fa/EX/++afdbK28RtEFAAAAAPJQQkKC+vXrp6efflobNmzQe++9Z737UPXq1dWxY0f17NlT06ZNU5EiRfTKK6+oXLly1kuKXnrpJTVs2FDTp09Xnz59FB8fr0mTJun999/PdYa7775b58+f17Zt2+wu05k8ebKqV6+uWrVqady4cTp9+rSefPLJLMcqUqSI+vfvrxdffFEZGRm64447tGPHDv36668KDg5Wt27dXDhKUvHixVWyZElNnz5dZcqUUUJCgl555RWbPqVLl1ZAQIAWL16s8uXLy9/fX0WLFtXQoUP1zDPPqHTp0tZb/65atUr/+c9/cv38Bw4c0JEjR+wWe71WvXr1FBISolWrVqldu3aSrt71qGrVqurWrZtGjRqlc+fOWddvySxwVa9eXQkJCfr888/VsGFDLViwQD///LOzhyjPVK9eXd98843at28vi8WiQYMG2c2eud6NXl70zDPPaNKkSRowYICefPJJ/fzzz/riiy+0YMECa59Jkybp22+/1bJlyyRdvaSoXbt26tOnjx544AElJibq5MmTOnXqlHUx3bS0NG3fvt36/0eOHNGmTZsUFBRkzXv+/Hnt2bPH+jz79+/Xpk2bVKJECVWsWNHavnLlSrVs2dLl15gbFF0AAAAA3DQqDnb9khlHNm/ebLPAaF6IjY3VxYsX1ahRI3l7e6tPnz7q1auXdfuHH36oPn36qF27dkpLS9Ndd92lhQsXWi8Pue2226wLrs6YMUNlypTR8OHDc72IrnR1nZjOnTtrzpw5GjlypM22t99+W2+//bY2bdqkatWqaf78+QoJCcl2vBEjRqhUqVIaOXKk9u3bp6CgIDVq1EivvfZa7g/Mdby8vPT555/rhRdeUO3atVWzZk1NnDjR5rbQhQoV0sSJEzV8+HANHjxYd955p1asWKFu3brp0qVLGjdunPr376+QkJBsZ6w48tlnn6lly5aqVKlSln28vb0VFxenOXPmWIsu3t7emjdvnp566ik1bNhQVapU0bvvvqv27dtb13/p0KGDXnzxRfXu3Vupqalq27atevbsqRkzZjh/oPLA2LFj9eSTT6pJkyYKCQnRwIEDlZycbOpzVq5cWQsWLNCLL76oCRMmqHz58vrggw+si/1KV2/rfe2trWfPnq2UlBSNHDnS5nPbrFkzrVixQpJ09OhRm9kpo0eP1ujRo236rFu3zmYWVL9+/SRJ3bp1s94F7MiRI1q9erVpi/RmshjX3jD+XyA5OVlFixbV2bNnFRwc7O44dsLCwpSYmOjuGA6RzXmemksim6s8NZun5pLI5ipXsyUMj8y5k1z/paUgHrP8QDbneWouiWyucibbpUuXtH//flWuXDnLxWDzSl4XXZo3b66oqCiNHz/+hse60WxbtmzRfffdp7179yooKEgHDhxQ5cqVtXHjRkVFRbk1m5lyky0tLU3Vq1fXp59+ar3bUlYSExN16623asOGDVkWaFatWqU77rhDe/bsyXKNmJv9mLmLWdkGDhyo06dPa/r06Vn2ye5clNvaAjNdAAAAAKAAqlOnjt555x3t37/f5s42uHoJ2GuvvZZjwUW6WjCcOXOmEhISrEWXb7/9VkFBQapevbr27NmjPn36qGnTptkuygvPUrp0aesMGDNRdAEAAACAAsqZS5L+TapVq+bUeiXXLmosSefOndPAgQOVkJCgkJAQtWjRwrpuD24OL730Ur48D0UXAAAAAMgjmWtKeKLw8HD9y1aXME1sbKxiY2PdHQM3AS93BwAAAAAAACiIKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAW0YDAAAAuGk0fa9p3g/6a9abVv1nVd4/nwfbtWuXmjVrpt27d6tIkSLujoM8MHXqVC1YsEDff/+9u6P8KzHTBQAAAADySPPmzdW3b193x7DhTKZXX31V//nPfyi4OMkwDA0ePFhlypRRQECAWrRood27d+e43+TJkxUeHi5/f381btxYa9eutdl+6dIlPf/88ypZsqSCgoL0wAMPKCkpyaZPQkKC2rZtq8DAQJUuXVovv/yyrly5Yt3+5JNPasOGDVq5cmXevFg4haILAAAAAHiYtLS0fH/OhIQE/fDDD+revXu+P/fNbtSoUZo4caKmTp2qNWvWqHDhwoqJidGlS5ey3Gfu3Lnq16+fhgwZog0bNqhu3bqKiYnR8ePHrX1efPFFff/99/ryyy/1yy+/6OjRo7r//vut29PT09W2bVulpaVp9erVmj17tj766CMNHjzY2sfX11ePPvqoJk6caM6LR7YougAAAABAHujevbt++eUXTZgwQRaLRRaLRQcOHFB6erp69OihypUrKyAgQDVr1tSECRPs9u3UqZPefPNNlS1bVjVr1pQkrV69WlFRUfL391eDBg00b948WSwWbdq0ybrvn3/+qdatWysoKEihoaF64okndPLkyWwzOfLFF1+obt26KleunE37jBkzVKFCBQUGBqpz584aO3as7rjjDuv2vXv3qmPHjgoNDVVQUJAaNmyon376yWaM8PBwvfHGG4qNjVVQUJAqVaqk+fPn68SJE+rYsaOCgoJUp04drVu3zrrPRx99pGLFiumHH35QzZo1FRgYqC5duiglJUWzZ89WeHi4ihcvrhdeeEHp6enW/X744Qc1aNBARYoUUVhYmB599FGbQkZeMwxD48eP1+uvv66OHTuqTp06+vjjj3X06FHNmzcvy/3Gjh2rnj17Ki4uThEREZo6daoCAwM1a9YsSdLZs2c1c+ZMjR07Vvfcc4/q16+vDz/8UKtXr9bvv/8uSfrxxx+1fft2ffLJJ4qKilLr1q01YsQITZ482aZw1759e82fP18XL1407TjAMYouAAAAAJAHJkyYoOjoaPXs2VPHjh3TsWPHVKFCBWVkZKh8+fL68ssvtX37dg0ePFivvfaavvjiC5v9ly1bpl27dmnp0qX64YcfdP78ebVv316RkZHasGGDRowYoYEDB9rsc+bMGd1zzz2qV6+e1q1bp8WLFyspKUldu3bNNpMjK1euVIMGDWzaVq1apWeeeUZ9+vTRpk2bdN999+nNN9+06XP+/Hm1adNGy5Yt08aNG9WqVSu1b99eCQkJNv3GjRunpk2bauPGjWrbtq2eeOIJxcbG6vHHH9eGDRtUtWpVxcbGyjAM6z4pKSmaOHGiPv/8cy1evFgrVqxQ586dtXDhQi1cuFD/+9//NG3aNH311VfWfa5cuaIRI0Zo8+bNmjdvng4cOJDj7J1nnnlGQUFB2X5lZf/+/UpMTFSLFi2sbUWLFlXjxo0VHx/vcJ+0tDStX7/eZh8vLy+1aNHCus/69et1+fJlmz633HKLKlasaO0THx+vyMhIhYaGWvvExMQoOTlZ27Zts7Y1aNBAV65c0Zo1a7I9Dsh7LKQLAAAAAHmgaNGi8vX1VWBgoMLCwqzt3t7eGjZsmPVx5cqVFR8fry+++MJaHJGkwoUL64MPPpCvr68k6fXXX5fFYtGMGTPk7++viIgIHTlyRD179rTuM2nSJNWrV09vvfWWtW3WrFmqUKGC/vrrL9WoUcNhJkcOHjxoV3R577331Lp1a/Xv31+SVKNGDa1evVrfffedtU/dunVVt25d6+MRI0bo22+/1fz589W7d29re5s2bfT0009LkgYPHqwpU6aoYcOGevDBByVJAwcOVHR0tJKSkqxZL1++rClTpqhq1aqSpC5duuh///ufkpKSFBQUpIiICN19991avny5HnroIUlSp06drHmqVKmiiRMnqmHDhjp//nyWxZPhw4dbX6OzEhMTJcmm8JH5OHPb9U6ePKn09HSH++zcudM6rq+vr4oVK5bluImJiQ7HuDaXJAUGBqpo0aI6ePCgk68ON4qiCwAAAACYbPLkyZo1a5YSEhJ08eJFpaWlKSoqyqZPZGSkteAiSQcOHFCdOnXk7+9vbWvUqJHNPps3b9by5csdFhP27t2rGjVq5DrjxYsXbZ5Luno3o86dO9u0NWrUyKbocv78eQ0dOlQLFizQsWPHdOXKFV28eNFupkudOnWs/59ZGIiMjLRrO378uLXoEhgYaC24ZPYJDw+3eb2hoaE2lw9t375dr7/+ujZv3qzTp08rIyND0tU1ayIiIhy+9tKlS6t06dJZHZoCISAgQCkpKe6O8a9D0QUAAAAATPT555+rf//+GjNmjKKjo1WkSBG9++67dpd6FC5c2OmxMy9Beuedd+y2lSlTxqmxQkJCdPr0aacz9O/fX0uXLtXo0aNVrVo1BQQEqEuXLnaLAfv4+Fj/32KxZNmWWSS5fntmH0dtmftcuHBBzz33nNq0aaM5c+aoVKlSSkhIUExMTLaLEz/zzDP65JNPsn2d58+fd9ieWSBKSkqyOeZJSUl2hbVMISEh8vb2trsT0bWzfMLCwpSWlqYzZ87YzHa5vs/1dzzKHPP6mU2nTp1SqVKlsn2NyHsUXQAAAAAgj/j6+tos6ipdXRelSZMmeu6556xte/fuzXGs8PBwLVmyRKmpqfLz85Mk/fHHHzZ9brvtNn399dcKDw9XoUKOf71zlMmRevXqafv27TZtNWvWtHvO6x+vWrVK3bt3t86IOX/+fJaL9Zpt586dOnPmjN5++23r2jXXLs6blRu5vKhy5coKCwvTsmXLrEWW5ORkrVmzRs8++6zDfXx9fVW/fn0tW7ZMnTp1knS12LRs2TLrJVn169eXj4+Pli1bpgceeEDS1ZlHCQkJio6OliRFR0frzTff1PHjx60zdZYuXarg4GCbWT179+7VpUuXVK9ePZdeI1zHQroAAAAAkEfCw8O1Zs0aHThwQCdPnlRGRoaqV6+udevWacmSJfrrr780aNAgu8KFI61bt1ZGRoZ69eqlHTt2aMmSJRo9erSkf2aFPP/88zp16pQeeeQR/fHHH9q7d6+WLFmiuLg4a6HFUSZHYmJiFB8fb1Og+c9//qOFCxdq7Nix2r17t6ZNm6ZFixZZn1+Sqlevrm+++UabNm3S5s2b9eijj2b5HGarWLGifHx89N5772nfvn2aP3++RowYkeN+pUuXVrVq1bL9yorFYlHfvn31xhtvaP78+dq6datiY2NVtmxZa0FFknr16qVJkyZZH/fr108zZszQ7NmztWPHDj377LO6cOGC4uLiJF1dI6hHjx7q16+fli9frvXr1ysuLk7R0dG6/fbbJUktW7ZURESEnnjiCW3evFlLlizR66+/rueff95aqJOuLpJcpUoVm0u1kD+Y6QIAAADgprHqP6vydLzNmzfbLAJ7o/r3769u3bopIiJCFy9e1P79+/X0009r48aNeuihh2SxWPTII4/oueee06JFi7IdKygoSN9//72effZZRUVFKTIyUoMHD9ajjz5qXXulbNmyWrVqlQYOHKiWLVsqNTVVlSpVUqtWreTl5ZVlpvDwcLvna926tQoVKqSffvpJMTExkqSmTZtq6tSpGjZsmF5//XXFxMToxRdf1Pjx4637jR07Vk8++aSaNGmikJAQDRw4UMnJyXlzQJ1UqlQpDR8+XNOmTdPEiRN12223afTo0erQoYOpzztgwABduHBBvXr10pkzZ3THHXdo8eLFNmvkHDp0yHorb0l66KGHdOLECQ0ePFiJiYmKiorS4sWLbRbGHTdunLy8vPTAAw8oNTVVMTExev/9963bvb299cMPP+jZZ59VdHS0ChcurG7dumn48OE2+T777DObBZiRfyzGtffj+hdITk5W0aJFdfbsWQUHB7s7jp2wsLAsV7h2N7I5z1NzSWRzladm89RcEtlc5Wq2hOGROXeSVHHwVqfHlgrmMcsPZHOep+aSyOYqZ7JdunRJ+/fvV+XKle0Wds1reV10yUuOss2ZM0dxcXE6e/asAgIC8vw5J0+erPnz52vJkiVZ9unZs6fWr1+vDRs25Pnz5wVPfU/dlWvbtm2655579Ndff6lo0aIO+3jqMZPcmy27c1FuawvMdAEAAAAAD/Xxxx+rSpUqKleunDZv3qyBAweqa9euphRcJOnpp5/WmTNndO7cORUpUkSSNHr0aN13330qXLiwFi1apNmzZ+vVV1815fmR944dO6aPP/44y4ILzEXRBQAAAAA8VGJiovXykzJlyujBBx/Um2++adrzFSpUSP/9739t2tauXatRo0bp3LlzqlKliiZOnGhdyBWer0WLFu6O8K9G0QUAAAAAPNSAAQM0YMAAt2b44osv7No2b97shiTAzYe7FwEAAAAAAJiAogsAAAAAj+Su2w4DgJQ35yAuLwIAAADgUXx9feXl5aWjR4+qVKlS8vX1lcViMeW5DMPQpUuXTBn7RpHNNZ6azVNzSWRz9JxpaWk6ceKEvLy85Ovr6/JYFF0AAAAAeBQvLy9VrlxZx44d09GjR019ruPHj8vPz8/U53AV2Vzjqdk8NZdEtqwEBgaqYsWK8vJy/SIhii4AAAAAPI6vr68qVqyoK1euKD093bTneeKJJ/Tbb7+ZNv6NIJtrPDWbp+aSyOaIt7e3ChUqdMOz7Ci6AAAAAPBIFotFPj4+8vHxMe05Dh8+LH9/f9PGvxFkc42nZvPUXBLZzMRCugAAAAAAACag6AIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYAKKLgAAAAAAACag6AIAAAAAAGACjyi6TJ48WeHh4fL391fjxo21du3aXO33+eefy2KxqFOnTuYGBAAAAAAAcJLbiy5z585Vv379NGTIEG3YsEF169ZVTEyMjh8/nu1+Bw4cUP/+/XXnnXfmU1IAAAAAAIDcc3vRZezYserZs6fi4uIUERGhqVOnKjAwULNmzcpyn/T0dD322GMaNmyYqlSpko9pAQAAAAAAcqeQO588LS1N69ev16uvvmpt8/LyUosWLRQfH5/lfsOHD1fp0qXVo0cPrVy5MtvnSE1NVWpqqvVxcnKyJOny5cu6fPnyDb6CvGcYhkfmksjmCk/NJZHNVZ6azVNzSWRzlavZ0r38ctXP1dddEI9ZfiCb8zw1l0Q2V3lqNk/NJZHNVZ6azVNzSWRzRW4zubXocvLkSaWnpys0NNSmPTQ0VDt37nS4z2+//aaZM2dq06ZNuXqOkSNHatiwYXbtP/74owIDA53ObLa0tDQtXLjQ3TEcIpvzPDWXRDZXeWo2T80lkc1VLmeLHJSrbltcfN0F8pjlA7I5z1NzSWRzladm89RcEtlc5anZPDWXRDZXpKSk5KqfxTAMw+QsWTp69KjKlSun1atXKzo62to+YMAA/fLLL1qzZo1N/3PnzqlOnTp6//331bp1a0lS9+7ddebMGc2bN8/hczia6VKhQgWdPHlSwcHBef+iblD58uV1+PBhd8dwiGzO89RcEtlc5anZPDWXRDZXuZrt8DvROXeSVH5g1jNKs92vAB6z/EA253lqLolsrvLUbJ6aSyKbqzw1m6fmksjmiuTkZIWEhOjs2bPZ1hbcOtMlJCRE3t7eSkpKsmlPSkpSWFiYXf+9e/fqwIEDat++vbUtIyNDklSoUCHt2rVLVatWtdnHz89Pfn72U619fHzk4+OTFy8jT1ksFo/MJZHNFZ6aSyKbqzw1m6fmksjmKlezeWek5txJcvl1F8Rjlh/I5jxPzSWRzVWems1Tc0lkc5WnZvPUXBLZXJHbTG5dSNfX11f169fXsmXLrG0ZGRlatmyZzcyXTLfccou2bt2qTZs2Wb86dOigu+++W5s2bVKFChXyMz4AAAAAAECW3DrTRZL69eunbt26qUGDBmrUqJHGjx+vCxcuKC4uTpIUGxurcuXKaeTIkfL391ft2rVt9i9WrJgk2bUDAAAAAAC4k9uLLg899JBOnDihwYMHKzExUVFRUVq8eLF1cd2EhAR5ebn9ztYAAAAAAABOcXvRRZJ69+6t3r17O9y2YsWKbPf96KOP8j4QAAAAAADADWIKCQAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJigkLsDAADcJ2F4ZK77Vhy81cQkAAAAQMHDTBcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwQSF3BwBwc0kYHpnrvhUHbzUxCQAAAAB4Nma6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJigkLsDAAAAAAD+HRKGR+aqX8XBW01OAuQPZroAAAAAAACYgKILAAAAAACACbi8CADgkXI7/VhiCjIAAAA8EzNdAAAAAAAATEDRBQAAAAAAwAQUXQAAAAAAAExA0QUAAAAAAMAEFF0AAAAAAABMQNEFAAAAAADABBRdAAAAAAAATEDRBQAAAAAAwAQUXQAAAAAAAEzgEUWXyZMnKzw8XP7+/mrcuLHWrl2bZd9vvvlGDRo0ULFixVS4cGFFRUXpf//7Xz6mBQAAAAAAyJnbiy5z585Vv379NGTIEG3YsEF169ZVTEyMjh8/7rB/iRIl9N///lfx8fHasmWL4uLiFBcXpyVLluRzcgAAAAAAgKwVcneAsWPHqmfPnoqLi5MkTZ06VQsWLNCsWbP0yiuv2PVv3ry5zeM+ffpo9uzZ+u233xQTE5MfkQEAAAAABUzC8Mhc9as4eKvJSVCQuLXokpaWpvXr1+vVV1+1tnl5ealFixaKj4/PcX/DMPTzzz9r165deueddxz2SU1NVWpqqvVxcnKyJOny5cu6fPnyDb6CvGcYhkfmksjmCk/NJbmeLd3LL9d9XX3tBfG4ma0gvp+enC0/mH3cOGb5i2zO89RcEtlc5anZPDWXVDCzmf19SvLcbAXx/cwPnpott5ncWnQ5efKk0tPTFRoaatMeGhqqnTt3Zrnf2bNnVa5cOaWmpsrb21vvv/++7rvvPod9R44cqWHDhtm1//jjjwoMDLyxF2CCtLQ0LVy40N0xHCKb8zw1l3QD2SIH5brrFhdfe4E8biYrkO+nJ2fLB2YfN45Z/iKb8zw1l0Q2V3lqNk/NJRXQbCZ/n5I8N1uBfD/zgadmS0lJyVU/i2EYhslZsnT06FGVK1dOq1evVnR0tLV9wIAB+uWXX7RmzRqH+2VkZGjfvn06f/68li1bphEjRmjevHl2lx5Jjme6VKhQQSdPnlRwcHCev6YbVb58eR0+fNjdMRwim/M8NZfkerbD70Tn3CnzOQbmPGPN4X4F8LiZrSC+nwUhm6u5JM/N5qn/BqSCmc2TP2tm89RcEtlc5anZPDWXVDCzefJ5je+hZHNGcnKyQkJCdPbs2WxrC26d6RISEiJvb28lJSXZtCclJSksLCzL/by8vFStWjVJUlRUlHbs2KGRI0c6LLr4+fnJz89+mpiPj498fHxu7AWYwGKxeGQuiWyu8NRckuvZvDNSc+70/1x97QXxuJmtIL6fBSHbjXxWPDWbp/4bkApmNk/+rJnNU3NJZHOVp2bz1FxSwczmyec1voeSzRm5zeTWuxf5+vqqfv36WrZsmbUtIyNDy5Yts5n5kpOMjAyb2SwAAAAAAADu5va7F/Xr10/dunVTgwYN1KhRI40fP14XLlyw3s0oNjZW5cqV08iRIyVdXaOlQYMGqlq1qlJTU7Vw4UL973//05QpU9z5MgAAAAAAAGy4vejy0EMP6cSJExo8eLASExMVFRWlxYsXWxfXTUhIkJfXPxNyLly4oOeee06HDx9WQECAbrnlFn3yySd66KGH3PUSAAAAAAAA7Li96CJJvXv3Vu/evR1uW7Fihc3jN954Q2+88UY+pAIAAAAAAHCdW9d0AQAAAAAAKKgougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmMAjbhkNAAAAAMgbCcMjc9234uCtJiYBwEwXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwgcu3jD5z5ozWrl2r48ePKyMjw2ZbbGzsDQcDAAAAAAC4mblUdPn+++/12GOP6fz58woODpbFYrFus1gsFF0AAAAAAMC/nkuXF7300kt68skndf78eZ05c0anT5+2fp06dSqvMwIAAAAAANx0XCq6HDlyRC+88IICAwPzOg8AAAAAAECB4FLRJSYmRuvWrcvrLAAAAAAAAAVGrtd0mT9/vvX/27Ztq5dfflnbt29XZGSkfHx8bPp26NAh7xICAAAAAADchHJddOnUqZNd2/Dhw+3aLBaL0tPTbygUAAAAAADAzS7XRZfrbwsNAAAAAP9WCcMjc9234uCtJiYB4MlcWtMFAAAAAAAA2XOp6PLCCy9o4sSJdu2TJk1S3759bzQTAAAAAADATc+losvXX3+tpk2b2rU3adJEX3311Q2HAgAAAAAAuNm5VHT5+++/VbRoUbv24OBgnTx58oZDAQAAAAAA3OxcKrpUq1ZNixcvtmtftGiRqlSpcsOhAAAAAAAAbna5vnvRtfr166fevXvrxIkTuueeeyRJy5Yt05gxYzR+/Pi8zAcAAAAAAHBTcqno8uSTTyo1NVVvvvmmRowYIUkKDw/XlClTFBsbm6cBAQAAAAAAbkYuFV0k6dlnn9Wzzz6rEydOKCAgQEFBQXmZCwAAAAAA4Kbm0pou99xzj86cOSNJKlWqlLXgkpycbL3cCAAAAAAA4N/MpZkuK1asUFpaml37pUuXtHLlyhsOBQAAAM+WMDwyV/0qDt5qchIAADyXU0WXLVu2WP9/+/btSkxMtD5OT0/X4sWLVa5cubxLBwAAAAAAcJNyqugSFRUli8Uii8Xi8DKigIAAvffee3kWDgAAAAAA4GblVNFl//79MgxDVapU0dq1a1WqVCnrNl9fX5UuXVre3t55HhIAAAAAAOBm41TRpVKlSpKkjIwMU8IAAAAAAAAUFC7fMlq6uq5LQkKC3aK6HTp0uKFQAAAAAAAANzuXii779u1T586dtXXrVlksFhmGIUmyWCySri6qCwAAAAAA8G/m5cpOffr0UeXKlXX8+HEFBgZq27Zt+vXXX9WgQQOtWLEijyMCAAAAAADcfFya6RIfH6+ff/5ZISEh8vLykpeXl+644w6NHDlSL7zwgjZu3JjXOQEAAAAAAG4qLs10SU9PV5EiRSRJISEhOnr0qKSrC+3u2rUr79IBAAAAAADcpFya6VK7dm1t3rxZlStXVuPGjTVq1Cj5+vpq+vTpqlKlSl5nBAAAAAAAuOm4VHR5/fXXdeHCBUnS8OHD1a5dO915550qWbKk5s6dm6cBAQAAzJQwPDLXfSsO3mpiEuQF3k8AgCdxqegSExNj/f9q1app586dOnXqlIoXL269gxEAAAAAAMC/mUtFF0dKlCiRV0MBAAAAAADc9Fwquly6dEnvvfeeli9fruPHjysjI8Nm+4YNG/IkHAAAAAAAwM3KpaJLjx499OOPP6pLly5q1KgRlxQBAAAAAABcx6Wiyw8//KCFCxeqadOmeZ0HAAAAAACgQPByZady5cqpSJEieZ0FAAAAAACgwHCp6DJmzBgNHDhQBw8ezOs8AAAAAAAABYJLlxc1aNBAly5dUpUqVRQYGCgfHx+b7adOncqTcAAAAAAAADcrl4oujzzyiI4cOaK33npLoaGhLKQLAAAAAABwHZeKLqtXr1Z8fLzq1q2b13kAAAAAAAAKBJfWdLnlllt08eLFvM4CAAAAAABQYLhUdHn77bf10ksvacWKFfr777+VnJxs8wUAAAAAAPBv59LlRa1atZIk3XvvvTbthmHIYrEoPT39xpMBAAAAAADcxFwquixfvjyvcwAAAAAAABQoLhVdmjVrltc5AAAAAAAAChSX1nRZvHixfvvtN+vjyZMnKyoqSo8++qhOnz6dZ+EAAAAAAABuVi4VXV5++WXrgrlbt25Vv3791KZNG+3fv1/9+vXL04AAAAAAAAA3I5cuL9q/f78iIiIkSV9//bXat2+vt956Sxs2bFCbNm3yNCAAAAAAAMDNyKWZLr6+vkpJSZEk/fTTT2rZsqUkqUSJEtwyGgAAAAAAQC7OdLnjjjvUr18/NW3aVGvXrtXcuXMlSX/99ZfKly+fpwEBMyUMj8xVv4qDt5qcBAAAAABQ0Lg002XSpEkqVKiQvvrqK02ZMkXlypWTJC1atEitWrXK04AAAAAAAAA3I5dmulSsWFE//PCDXfu4ceNuOBAAAAAAAEBBkOuiS3JysoKDg63/n53MfgAAAAAAwHW5XRJBYlkET5Trokvx4sV17NgxlS5dWsWKFZPFYrHrYxiGLBaL0tPT8zQkAAAAAADAzSbXRZeff/5ZJUqUkCQtX77ctEAAAAAAAAAFQa6LLs2aNbP5/0uXLmnLli06fvy4MjIyTAkHAAAAAABws3JpId3FixcrNjZWJ0+etNvG5UUAAAAAAAAu3jL6P//5jx588EEdO3ZMGRkZNl8UXAAAAAAAAFwsuiQlJalfv34KDQ3N6zwAAAAAAAAFgktFly5dumjFihV5HAUAAAAAAKDgcGlNl0mTJunBBx/UypUrFRkZKR8fH5vtL7zwQp6EAwAAAAAAuFm5VHT57LPP9OOPP8rf318rVqyQxWKxbrNYLBRdAAAAAADAv55LRZf//ve/GjZsmF555RV5ebl0hRIAAAAAAECB5lLFJC0tTQ899BAFFwAAAAAAgCy4VDXp1q2b5s6dm9dZAAAAAAAACgyXLi9KT0/XqFGjtGTJEtWpU8duId2xY8fmSTgAAAAAAICblUtFl61bt6pevXqSpD///NNm27WL6gIAAAAAAPxbuVR0Wb58eV7nAAAAAAAAKFBYCRcAAAAAAMAEFF0AAAAAAABMQNEFAAAAAADABB5RdJk8ebLCw8Pl7++vxo0ba+3atVn2nTFjhu68804VL15cxYsXV4sWLbLtDwAAAAAA4A5uL7rMnTtX/fr105AhQ7RhwwbVrVtXMTExOn78uMP+K1as0COPPKLly5crPj5eFSpUUMuWLXXkyJF8Tg4AAAAAAJA1txddxo4dq549eyouLk4RERGaOnWqAgMDNWvWLIf958yZo+eee05RUVG65ZZb9MEHHygjI0PLli3L5+QAAAAAAABZc+mW0XklLS1N69ev16uvvmpt8/LyUosWLRQfH5+rMVJSUnT58mWVKFHC4fbU1FSlpqZaHycnJ0uSLl++rMuXL99AenMYhuGRuaSCmS3dyy9X/Vx93f/mYyZx3PJTQXw/C0K2G/mseGo2T/03IPFZc5WnZiuI72d+IJvzCuJnrSBk47z2D09+P/ODp2bLbSa3Fl1Onjyp9PR0hYaG2rSHhoZq586duRpj4MCBKlu2rFq0aOFw+8iRIzVs2DC79h9//FGBgYHOhzZZWlqaFi5c6O4YDhXIbJGDctVti4uv+998zCSOW34qkO9nAcjmai7Jc7N56r8Bic+aqzw1W4F8P/MB2ZxXID9rBSAb57VrePL7mQ88NVtKSkqu+lkMwzBMzpKlo0ePqly5clq9erWio6Ot7QMGDNAvv/yiNWvWZLv/22+/rVGjRmnFihWqU6eOwz6OZrpUqFBBJ0+eVHBwcN68kDxUvnx5HT582N0xHCqI2Q6/E51zJ0nlB+Zu5pXdfv/iYyZx3PJTQXw/C0I2V3NJnpvNU/8NSHzWXOWp2Qri+5kfyOa8gvhZKwjZOK/9w5Pfz/zgqdmSk5MVEhKis2fPZltbcOtMl5CQEHl7eyspKcmmPSkpSWFhYdnuO3r0aL399tv66aefsiy4SJKfn5/8/OynY/n4+MjHx8e14CayWCwemUsqmNm8M1Jz7iS5/Lr/zcdM4rjlp4L4fhaEbDfyWfHUbJ76b0Dis+YqT81WEN/P/EA25xXEz1pByMZ57R+e/H7mB0/NlttMbl1I19fXV/Xr17dZBDdzUdxrZ75cb9SoURoxYoQWL16sBg0a5EdUAAAAAAAAp7h1posk9evXT926dVODBg3UqFEjjR8/XhcuXFBcXJwkKTY2VuXKldPIkSMlSe+8844GDx6sTz/9VOHh4UpMTJQkBQUFKSgoyG2vAwAAAAAA4FpuL7o89NBDOnHihAYPHqzExERFRUVp8eLF1sV1ExIS5OX1z4ScKVOmKC0tTV26dLEZZ8iQIRo6dGh+RgcAAAAAAMiS24suktS7d2/17t3b4bYVK1bYPD5w4ID5gQAAAAAAAG6QW9d0AQAAAAAAKKgougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJigkLsDAPAM9V/+OFf9vi1ichAAAAAAKCCY6QIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYALuXgQAAEyXMDwy130rDt5qYhIAAID8w0wXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMEEhdwcAgLySMDwyV/0qDt5qchJ7npwNAAAAgDmY6QIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYAKKLgAAAAAAACag6AIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYAKKLgAAAAAAACag6AIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABgAoouAAAAAAAAJqDoAgAAAAAAYAKKLgAAAAAAACag6AIAAAAAAGACii4AAAAAAAAmoOgCAAAAAABggkLuDgAAAAAAWUkYHpmrfhUHbzU5CQA4j5kuAAAAAAAAJqDoAgAAAAAAYAIuLyogcjvtUmLqJQAAAAAA+YGiC0zHdbgAAAAAgH8jLi8CAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATFHJ3AAAAAAAAcPNJGB6Z674VB281MYnnYqYLAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACdxedJk8ebLCw8Pl7++vxo0ba+3atVn23bZtmx544AGFh4fLYrFo/Pjx+RcUAAAAAADACW4tusydO1f9+vXTkCFDtGHDBtWtW1cxMTE6fvy4w/4pKSmqUqWK3n77bYWFheVzWgAAAAAAgNwr5M4nHzt2rHr27Km4uDhJ0tSpU7VgwQLNmjVLr7zyil3/hg0bqmHDhpLkcLsz4uPjVbhw4Vz3r1mzpkqVKmXTlpaWlu3MHEeKFi2qyMhIu/bt27fr1KlTSktL02+//ZarsW677TYFBgbatJ1JuaLdJ1Kz3S/huvHLli2rKlWq2PVbu3at0tLSrI9zyubl5aUmTZrYtR85k6ajZy9nm+n6XDVq1FDp0qVttl++fFlr1qxxuG9W2YKDg1WnTh279h07dujvv/9W0sELOebKzFavXj27z8zp06e1bdu2LPdzlKtMmTKqWrWqXd8//vhDqanZv3fXslgsatq0qV37oUOHdPDgwRz3vzZb9erV7bYb6Vd04dg++5yBWR+zwn5eiggLsGvPPN65lZaWpgsXLtgd7zNnzujPP//Mcj9H72fpIoVUqYSfXfu6det06dKlXGeSpDvuuMOu7fDhwzpw4ECO+16brVIJX5Uu4mOz/Uq6oY2HU+z+fWYnKChIUVFRdu07d+7UyZMnczVGZq6IMH8V9vO22ZZ8KV27kv45RrnJFhYWpmrVqtm1r1+/XhcvXsxVpkwVHbQlJl/WodNpdu3ZZatatarKlClj05aenq74+HinzrmFCxdWvXr17Nr3nkzVqQtXHO6TVa66deuqSJEiNm1nz57V1q1brY9zky00NNThv9+tRy/q0uWMbPe9PlvTpk1lsVhs2o4ePap9+2zPAznlqlKlisqWLWvTlpGRoT9yeb7NzBYYGKjbbrvNbttff/2V5R9nsspWp04dBQcH27QlJydry5YtkhyfOxwpWbiQw8/lhg0blJKSku2+12dr0qSJvLxs//bl6HjnlK1icV+FBtueTwzD0KpVq7Ld7/psGzZscHi8d+/eraSkJIf7ZZWtZqi/gv1tzyfnzp3T5s2bc51Jkq5ccfzvauPGjbpwIevj4ijXbRUC5e1l+/lOOnfZqXOuJFWuXFnlypWza8/teSRTQECA6tevb9e+Z88eJSYmOjVWZGSkihYtatN2/vx5bdq0yalxQkJCdMstt9i1b9q0SefPn3dqrNtvv12FCtn+mpGYmOjUOVeSwsPDVb58ebv2rM4nWb2f/v7+atCggV373r17dezYMady1a5dW8WKFbNpS0nL0LZj2X+Puz5byZIlVatWLbt+mzdv1rlz56yPc5OtcePG8vGxPQ+cOH9FB/7O3c+VmdkqVaqkChUq2G1ftWqVDMOwa88qm5+fn/V3tmtlHm9nfv6+9dZbVbx4cZv2CxcuaOPGjdnue322rI73li1blJycbH2cm2xR5QPt2o4fP66//vorx32vzVWxYkVVrGj/XWX16tXKyLD9Hp5dLh9vi8NM+/bt09GjR3PMdG22U6dOqUSJEjbtKSkp2rBhQ5b7OcpWNMBbNUr727Vv3bpVZ8+ezXUmSWrUqJFd24kTJ7Rr1y6nxsnqeMfHxys9PT3X4/j4+Khx48ZOPbcMN0lNTTW8vb2Nb7/91qY9NjbW6NChQ477V6pUyRg3blyO/S5dumScPXvW+nXo0CFDktNfH3/8sZGWlmbzdfDgQafHueuuu+zGSUtLM9q2bev0WFu3brXuv29EfWPfiPrGB49Xc3qcPn36OMxUrlw5p8YJDAx0OE6/e8s6nenDDz+0G+fIkSNOj9OkSROHmTp27Oj0WBs3brQb54cffnB6nOeff95hpkqVKjk1jq+vr8NxRowY4XSmDz74wLh94GybrwYvTHZ6nHoVCls/i/tG1Ldmuv/++50ea926dXavbdGiRU6P83ijUjaZMnNVrVrVqXG8vb2NtLQ0o3Tp0jaZRo4c6XSmkR0r2WXa/N8op8epX/+fY3xtrq5duzo91vxna9ll+vTJGk6P89RTT9m9b6VLlzaqV6/u9FjX59k3or7xWqvyTo8zefJku0ynT592epyoqCi7c+6+EfWNjnVKOD3W6tWr7TItX77c6XHi4uLsxtk3or5RvZS/02OlpKTYjTV27Finx5kwYYLdOOfOnXN6nNq1azs8xz3xxBNOj/Xrr7/ajfPrr786Pc4D9Uo6zFS7dm2nxzp37pzdOBMmTHB6nMFtKticb9PS0oyUlBSnx6lVq5bD1xYXF+f0WHOfqml3zl29erXT4/j5+TnMFBUV5fRYfw6KsjufvNGhotPjjBo1yuH3AmfHqV69usPX9tRTTzk91tKlS+3OuWvWrHF6nK5duzrMVL9+fafHOnnypN04U6dOdXqckSNH2p1z942ob3h7OTdO1apVHb62Z555xulMixYtsvtesOD5Wk6Pc//99zvM1LhxY6fHSkxMtBtnVGfnfq6UZIwYMcJhJl9fX6fGqVSpksNxnn/+eacz/fDDD3bjbNy40elxOnbs6DBTkyZNnB7rj1fq2I3z4YcfOj3O0KFDHWYKDAx0apywYB+HP3/36dPH6Uzz5s2zy7N161anx7m3ZlGHP8fdddddTo918OBBu3Puxx9/7PQ4r7/+usPjXaRIEeeOd1iYdd+TJ08akoyzZ89mW5Nw20yXkydPKj09XaGhoTbtoaGh2rlzZ549z8iRIzVs2LAbHmfTpk12fyU7deqU0+P8/fffWrhwoV17Vn+1y86vv/6qvXv3Xn0QOUiSdCB1naQ3nBpn//79DjM5OwsgPT3d4TiJoc0lferUWJs3b7arajtbFZWuzkRxlCmrv9plZ+XKlXYzSHKqsjty4MABh5ly+ivp9TIyMhyO42zVV7p6vF+5916btnPnvPSEk+OkBJbXlv//LErSlv/P5+xf7aSrfzU8fPiwXU5n/V2ygbZEPm3TtmXhwmz/SuqIYRhauHCh0tLSbI67K+erw+XbaUvkfTZtV9//R50a5+zZs9Ys1+Y6duyY05l2V3tKGdfNwNqrrZIGOd4hCwkJCXafy7T/n7nkrGs/S5mO7ftO0odOjfPnn3/aZXL2/CZdnRlhHeeabGd+GifpF6fGWrVqld15f/v27U5nOnTokP15IHKQLvn/R9Ihp8ZatGiRvL1tZye4kmnbtm12mS5fznm24/XOnTvn8Bx3/XkhN1avXm33PduVf7unitVxmOnav0rn1uLFi+3+Mp3dzMmsHC0boy2R7aznW0lO/cUu0/nz5x2+tkOHnPscSdLeKt3kFxFhfbxl4ULt3r3b6XGy+j537V+lc+vPW1+Rv7/tX12PHF0iaYpT4+zYscPh9wJnXbhwweH+CQkJTo/1+++/25xj05ycTZLp2LFjDjO58vPXjz/+aDcb+9qZfLm1c+fOq5mu+35g6H5J2c/mu1ZWxzs3M4Ovt3bt2n9mJmf+/F3kgKS+To2TmJjoMNOZM2eczrR06VK72ZOHyneQ9J5T4+zatcthputnXeQkJSXF4Ti5mRl8vT/++MNu1psr/06SkpIcZjp9+rTTY22v9ZKOXDeWKz+j/vXXXw4zOXsOv+wT7PDn7/379zudad26dXZtR44ccXqc5OAa2hL5X7v2vz+3b8vJsmXL7M65zs7kk67O3HR0vLOaVZmV1NRU6zi5/f3NrZcX5YdXX31V/fr1sz5OTk52OG0uJ1FRUWrTpo1Nmyu/2JQsWdJuHEmaMWOG02PdddddqlmzpiTp8DvRkqSTB5z/xli5cmWHma7/4SQn3t7eDsf59b3nnM5Ut25du7FOnDjh9DjFixd3mOnDD537pU2S7rzzTt166602bddPnc2N8PBwh5mu/+EkJ15eXg7HceWHmrp16+rteNvPzpWLzk0llqTAlMOqs3WE9XH5gfGSpI8//tjpse644w67S8P8/OwvE8pJyb/Xqc5W219uyw907vJC6erlXG3atJGvr6/Ncd+xY4fTmcof/kF1tv5u03bukvO/JBUtWtSa5dpcn37qXJFTkqrv+UC1U2w/gyn7nf9FsmLFinafS19fX6ePtySbz1KmtcecL5jWrl3bLpMrRaDg4GDrOJnnXEkqdtr5H2qaNm1qN9X9+ssDcqNChQp2r+3wO9Hyv+T8+bJ169Z257TrL3XJjVtvvdUukzOXTmYqUqSIw3Pc119/7fRYTZo00e23327Tdv306dwocWaLw0yvv/6602O1atXK7pzmyi+AZY8uUZ2tG63nW8n5HyClq5crOnpt3333ndNjVd03W3XSg6yPyw+Md/iDfE6y+j43dOhQp8eqve1tBfraFhX/POL8v5NatWo5/F7grMKFCzvc/4cffnB6rNtvv13NmjWzPvb19XV4OWxOypQp4zDTiBH25+KctGzZ0u6Pla78AeaWW25RmzZtbM65kmRxouAiZX28Fy9e7HSmRo0a6d7//0NVZi6fROf+cCZdvRzXUaaRI0c6PdZ9991nd077a3Yfp8epWbOmw0zXXwqZk8DAQIfjLF261OlMDRs2VMuWLW3aXClQh4aGOsw0atQop8eK2DFGdYfbntNcKd7UqFHDYabr/wCSE5/LyQ5//l6+fLnTmRo0aGCXyZU/6AYn/+Xw57iSJUs6Pda9995rd851pfhevXp1h8fb2d/n/Pz8rOPkNofFMBxcoJcP0tLSFBgYqK+++kqdOnWytnfr1k1nzpzJ8Zt8eHi4+vbtq759+zr1vMnJySpatKgWL17skWu6dOjQQfPnz8/VWNeu6ZIw/OqYuVnTJTTO9hfg3K7pklO2rNZ0ie9XM1drulyby9k1XbLKluOaLh/G5pgrM5sra7o4yuUpa7pcm6169epqM3qJzfas1nR5KzDrX+ivX9Ol4uCrBSBn13Tp0KGDDh065PyaLg7eT0drulQcvNXlNV3CwsJsfnDM9Zou12TLbk2X6/99ZufaNV2uzeXUmi7/nys3a7rkJpujNV3CwsK0YMEC59d0+flZu7as1nTJLlt2a7o4c869dk2XzHOulP2aLlnlys2aLrnJ5mhNl4Thkbla0+X6bLld0yWnXFmt6fJtT/u1frLL5sqaLllly3FNl1x+LyhZuJCaT7S/Zj83a7pcny3Xa7rkkC1zTZfM860kp9d06dChg3766Sfn13TJItv1a7pUHLzVpTVdOnXq5PBcluOaLg5yZbWmS2rHD5zKlLmmy/XfCzxpTZewsDDt2bPHI9d0iYiIyPU5V/pnTZdrz7lS1mu6ZHXOzWlNF2e+F1y7pktmrtys6XJ9ttyu6ZKbbI7WdFk/oFau13TJzObsmi5ZZctxTRcnfv52dU2X67Plek2XXGSLKh+oqsNsfx7N7Zou1+Zyak2XbHJdv6ZL5vcDZ9d06dChg/bs2eP8mi4OsmW1psvZzp+6tKZLxYoVbc6NnrKmS2Zt4ezZs3Y/Z1zLbUUX6eoJolGjRnrvvatT3zIyMlSxYkX17t07x4Vyb7ToktOBcZfrv4nn1vXfjLJz7Q9mzjA7m6u5JM/N5mqu/HB9tvov5+6X/W+LvJvr5+Cz9g9P/awVhHOH5LnZ+Kz9oyC8n5LnZuOz9g9Pfj/zQ0HMxmft35mN89o/CsL7KRW8c25uawtuvbyoX79+6tatmxo0aKBGjRpp/PjxunDhgvVuRrGxsSpXrpx1ml1aWpr1+vK0tDQdOXJEmzZtUlBQkMO7ZQAAAAAAALiLW4suDz30kE6cOKHBgwcrMTFRUVFRWrx4sXVx3YSEBJupt0ePHrW5Xefo0aM1evRoNWvWTCtWrMjv+AAAAAAAAFly+0K6vXv3Vu/evR1uu76QEh4e7vB6QgAAAAAAAE/j3FLUAAAAAAAAyBWKLgAAAAAAACag6AIAAAAAAGACt6/pAgAAAMC98uM2vgDwb8RMFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAE1B0AQAAAAAAMAFFFwAAAAAAABNQdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAExRyd4CbScLwyFz3rTh4q4lJAAAAAACAp6PoAgAAAAAACpTcTpowe8IElxcBAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmICiCwAAAAAAgAkougAAAAAAAJiAogsAAAAAAIAJKLoAAAAAAACYgKILAAAAAACACSi6AAAAAAAAmKCQuwMAAAAA/wYJwyNz3bfi4K0mJgEA5BdmugAAAAAAAJiAogsAAAAAAIAJPKLoMnnyZIWHh8vf31+NGzfW2rVrs+3/5Zdf6pZbbpG/v78iIyO1cOHCfEoKAAAAAACQO25f02Xu3Lnq16+fpk6dqsaNG2v8+PGKiYnRrl27VLp0abv+q1ev1iOPPKKRI0eqXbt2+vTTT9WpUydt2LBBtWvXdsMrAPIe13wDAAAAwM3P7UWXsWPHqmfPnoqLi5MkTZ06VQsWLNCsWbP0yiuv2PWfMGGCWrVqpZdfflmSNGLECC1dulSTJk3S1KlT7fqnpqYqNTXV+vjs2bOSpFOnTuny5ctOZT2TlvvDVfjvv50aO1N6err+dmHfgpDN1VyS52a7md5PrysXc7UfnzXPzHYzfdZyqyBk47P2j4Lwfkqem43P2j8KwvspeW42Pmv/KAjvp+S52fis/aMgvJ+S52ZzNde5c+ckSYZhZN/RcKPU1FTD29vb+Pbbb23aY2NjjQ4dOjjcp0KFCsa4ceNs2gYPHmzUqVPHYf8hQ4YYkvjiiy+++OKLL7744osvvvjiiy++8vTr0KFD2dY93DrT5eTJk0pPT1doaKhNe2hoqHbu3Olwn8TERIf9ExMTHfZ/9dVX1a9fP+vjjIwMnTp1SiVLlpTFYrnBVyAlJyerQoUKOnTokIKDg294vLziqbkksrnKU7N5ai6JbK7y1Gyemksim6s8NZun5pLI5ipPzeapuSSyucpTs3lqLolsrvLUbJ6aS8r7bIZh6Ny5cypbtmy2/dx+eZHZ/Pz85OfnZ9NWrFixPH+e4OBgj/tQSZ6bSyKbqzw1m6fmksjmKk/N5qm5JLK5ylOzeWouiWyu8tRsnppLIpurPDWbp+aSyOYqT83mqbmkvM1WtGjRHPu49e5FISEh8vb2VlJSkk17UlKSwsLCHO4TFhbmVH8AAAAAAAB3cGvRxdfXV/Xr19eyZcusbRkZGVq2bJmio6Md7hMdHW3TX5KWLl2aZX8AAAAAAAB3cPvlRf369VO3bt3UoEEDNWrUSOPHj9eFCxesdzOKjY1VuXLlNHLkSElSnz591KxZM40ZM0Zt27bV559/rnXr1mn69Oluye/n56chQ4bYXcLkbp6aSyKbqzw1m6fmksjmKk/N5qm5JLK5ylOzeWouiWyu8tRsnppLIpurPDWbp+aSyOYqT83mqbkk92WzGEZO9zcy36RJk/Tuu+8qMTFRUVFRmjhxoho3bixJat68ucLDw/XRRx9Z+3/55Zd6/fXXdeDAAVWvXl2jRo1SmzZt3JQeAAAAAADAnkcUXQAAAAAAAAoat67pAgAAAAAAUFBRdAEAAAAAADABRRcAAAAAAAATUHQBAAAAAAAwAUUXAAAAAAAAExRyd4CbzZUrV7Rt2zYlJiZKksLCwhQRESEfHx83JwPgyP79+1WhQgUVKsTpDkDOUlNTJUl+fn5uTgIAAAoCbhmdSxkZGRo8eLAmT56ss2fP2mwrWrSoevfurWHDhsnLi8lDBcXevXvVs2dP/fzzz/n+3MeOHdOyZctUokQJtWjRQr6+vtZtFy5c0JgxYzR48OB8zyVJS5cu1W+//aZmzZrpnnvu0a+//qqRI0cqNTVVTzzxhOLi4tySKyu+vr7avHmzatWq5e4oVkePHtW0adO0Z88elSlTRk899ZRuueUWd8cCTLd9+3ZNmjRJ8fHxNn+8iI6OVu/evRUREeGWXEuXLtW4ceMUHx+v5ORkSVJwcLCio6PVr18/tWjRwi25JM89ZmS7cWfPnrXJVrRoUTcn8vw/LnriMctEttw7efKkZs2aZffvs0mTJurevbtKlSrltmyeeu7w5GNGtpxRdMmlAQMG6KOPPtKIESMUExOj0NBQSVJSUpJ+/PFHDRo0SN27d9c777zj5qSOHTp0SEOGDNGsWbPy/bkvXryo9evXq0SJEnYnqkuXLumLL75QbGxsvufKyebNm3XbbbcpPT09X5/3jz/+UMuWLZWRkaHLly+rXLlymjdvnm699VZJVz9zZcuWzfdckvTJJ58oLi5OderU0V9//aX33ntPL774orp06aKMjAx98sknmjNnjrp06ZLv2e6//36H7d99953uueceFSlSRJL0zTff5GcsSVJgYKAOHjyoUqVKafv27WrSpIlKlSqlevXqaevWrUpISFB8fLzq1KmT79lykpSUpGnTprmtyJcdd57XsuPJx8yd2RYtWqROnTrptttus/s+unTpUq1fv17fffedYmJi8jXX7Nmz9dRTT6lLly4Ov79/9dVXmjlzpp544ol8zSV57jEj24354IMPNHbsWO3atcumvWbNmnrppZfUo0ePfM/k6X9c9MRjlolszvnjjz8UExOjwMBAtWjRwubf57Jly5SSkqIlS5aoQYMG+Z7NU88dnnzMyJZLBnIlNDTUWLx4cZbbFy9ebJQuXTofEzln06ZNhpeXV74/765du4xKlSoZFovF8PLyMu666y7j6NGj1u2JiYluyWUYhjFhwoRsvwYMGOCWbC1atDDi4uKM9PR0Izk52Xj22WeNkiVLGhs2bDAMw73HLCoqypgwYYJhGIbx008/GQEBAcbYsWOt20ePHm00bdrULdksFovRrFkzo3v37jZfXl5eRqdOnayP3ZUtKSnJMAzD6Nixo9G+fXvj8uXLhmEYRnp6uvHwww8b7dq1c0u2nLjr3JEbnprNU3MZhnuz1alTxxg0aFCW24cMGWJERkbmY6KrqlevbkyaNCnL7ZMnTzaqVauWj4n+4anHzDDI5qpRo0YZgYGBxiuvvGIsX77c2L59u7F9+3Zj+fLlxquvvmoULlzYePfdd/M918svv2yUKlXKmDp1qrF//34jJSXFSElJMfbv329MmzbNKF26tDFgwIB8z2UYnnvMyOaaxo0bG7169TIyMjLstmVkZBi9evUybr/99nzPZRiee+7w5GNGttxhpksuFS5cWL///rsiIyMdbt+yZYuaNGmi8+fP53Oyq+bPn5/t9n379umll17K99kRnTt31uXLl/XRRx/pzJkz6tu3r7Zv364VK1aoYsWKbp214eXlpTJlythcunOttLQ0JSYm5nu2EiVK6Pfff1eNGjWsbW+//bZGjRqlJUuWqGLFim47ZkFBQdq6dasqV64s6eqlO+vWrbPO0Ni5c6fuuOMOnTx5Mt+zff7553r55Zc1fPhwm0ucfHx8tHnzZrdOJffy8lJiYqJKly6tihUras6cObrzzjut2zdu3Ki2bdvq6NGj+Z5ty5Yt2W7fuXOnHnnkEbd83jz1vObJx8yTswUEBGjTpk2qWbOmw+27du1SVFSULl68mK+5/P39tXnzZo/LJXnuMZPI5qpKlSrp3XffVdeuXR1unzt3rl5++WUlJCTka66wsDDNnj07y7/gL1myRLGxsUpKSsrXXJLnHjOJbK4ICAjQxo0bs7yseufOnapXrx7njutyefIxI1vOWFkyl5o3b67+/ftrzpw5CgkJsdl28uRJDRw4UM2bN3dPOEmdOnWSxWJRdjU0i8WSj4muWr16tX766SeFhIQoJCRE33//vZ577jndeeedWr58uQoXLpzvmTJVqlRJ77zzTpbfjDZt2qT69evnc6qrLl26ZPP4lVdeUaFChdSyZUu3Xkrh4+OjtLQ062M/Pz8FBQXZPHbHSVWSHn74Yd1+++16/PHH9cMPP+iDDz5Q8eLF3ZLlehaLxfrvz8vLy+5a6mLFiun06dPuiKaoqKgszx2Z7e44d0iee17z5GPmydnCw8O1YMGCLH+YXbBggSpVqpTPqaRbb71VM2fO1KhRoxxunzVrltuKtp56zCSyuer48eNZ/gFPkiIjI93yh4tz586pbNmyWW4vU6aMLly4kI+J/uGpx0wimyvCwsK0du3aLH8RXrt2rfUykPzmqecOTz5mZMsdii65NHXqVLVp00ZlypRRZGSkzTVhW7duVUREhH744Qe35StTpozef/99dezY0eF2dxUQLl68aHPXGIvFoilTpqh3795q1qyZPv3003zPlKl+/fpav359lkWXnH7ZM0vt2rW1evVqu/U9+vfvr4yMDD3yyCP5nilTtWrVtHPnTus3oyNHjljXSpGuLj5cvnx5d8VTeHi4fv31Vw0bNkx169bVjBkz3PYL5rUMw1CNGjVksVh0/vx5bdmyxeb93bNnj8LCwtySrUSJEho1apTuvfdeh9u3bdum9u3b53Oqqzz1vObJx8yTsw0fPlyPPvqoVqxY4fDa6sWLF7vle8KYMWPUrl07LV682GGuffv2acGCBfmeS/LcY0Y21zVs2FBvv/22Zs6caXdXvfT0dL3zzjtq2LBhvufy5D8ueuoxI5tr+vfvr169emn9+vW699577f59zpgxQ6NHj873XJLnnjs8+ZiRLXcouuRShQoVtHnzZi1ZskS///67dfXjRo0a6a233lLLli3deueizAJCVr+cuKuAcMstt2jdunV2d46ZNGmSJKlDhw75ninT8OHDlZKSkuX2iIgI7d+/Px8TXRUbG6tffvlFzzzzjN22AQMGyDAMTZ06Nd9zSdJrr71mM3skODjYZvu6deuyLGLlFy8vLw0bNkz33XefYmNj3XIZxfU+/PBDm8fVqlWzefz777+rc+fO+RnJqn79+jp69GiWf7k5c+aMW84dkuee1zz9mHlqtgcffFDlypXTxIkTNWbMGLu7QqxYsULR0dH5nqt58+b6888/NWXKFJvv72FhYWrdurWeeeYZhYeH53suyXOPGdlcN2nSJMXExCgsLEx33XWXzS8Bv/76q3x9ffXjjz/mey5P/uOipx4zsrnm+eefV0hIiMaNG6f333/f+nOat7e36tevr48++shtP0t66rnDk48Z2XKHNV0KiJUrV+rChQtq1aqVw+0XLlzQunXr1KxZs3zNNXLkSK1cuVILFy50uP25557T1KlTlZGRka+5XLFq1So1aNBAfn5+7o5iw1NzSe7Pdv78ee3du1e1atWyW7vH3dmyk5/Zvv32W124cEGPP/64w+2nT5/W/Pnz1a1bN9OzXM9Tz2uefMw8ORuAq86dO6dPPvnErsgXHR2tRx991O4PGvklIyPD7o+Lmbnc/cdFTz1mZLsxly9ftl7iFBIS4jG3JvdknnzMyJY1ii7/UocPH1bZsmXd+g3UEU/NJV2d1bFp0yZVqVLF3VFseGouiWyu8uRsnsyTzx8AAAD4d+In0zxSq1YteXt7uztGrkVEROjAgQPujmHHU3NJctuU/Jx4ai6JbK7y5GzBwcHat2+fu2M45KnnD08+Zp6U7bXXXtOTTz7p7hh2unXrpnvuucfdMRzy1GMmkQ2Aa95//30NHz7c3TEc8tRzhycfM7JdRdElj4wcOdKtd5Vxlqf+UuepuQBc5cn/Rj01m6fmkjwr25EjRzyyaFauXDm33ekmJ556zCSyuapFixYeOcvRk/+46KnHTCKbK77++mt99NFH7o7hkKeeOzz5mJHtKhbSzSOdOnVydwQAAG5as2fPdncEh9566y13R/i/9u48LKry7+P45wy7gLIquAKBKAaCWuZSCrllv9x6tNTEXNMUDMWlfqmhJi6BSmplKi6PS1limikYigppKujgAoq4UOaCEhKigDPf5w8eJsZhkSnm3ML3dV1z5dxnct4Cw8zcc859KiTq1wzgNn0NHDhQtlMMVyY8PBz379+XO6Ncon7NAG7TR3x8vNwJFRL1d4fIXzNuK8GTLowxxhhjrNYjIkiSJHdGpSZNmiR3QrlE/nBR1K8ZwG2MsRJ8eNG/JC0tTchd9Ni/R9QXaqJ2AdymL5HbGPsn7t69iyVLlmDgwIHo1KkTOnXqhIEDB2Lp0qXIzs6WO69cv/32m6zH8D98+BCJiYm4cOGCzrZHjx5h06ZNMlSVSEtLQ3R0NNLT0wEA6enpmDhxIkaPHo2DBw/K1lURMzMzpKWlyZ2hpbCwEIWFhXJnsDokISEBDx8+lLWhqKgI3377LUJCQjB06FAMHToUISEh2LFjB4qKimRtq8zt27dlXZ/k999/R35+vs54cXExjhw5IkNRiXv37uHQoUPIyckBUPJcv3jxYsybN0+437kA4ObmhoyMDIPeJ+/p8i8pKirC9evX5c54aqK+qRO1CxBr7YOyRO0CuE1fIreJ/BgVtU3ULsCwbSdPnkTv3r1Rr1499OjRAy1btgRQ8iI2KioKixYtQmxsLDp06GCwpqeRk5ODjRs3yrJu26VLl9CrVy9kZWVBkiR07doV27dvh7OzMwDg/v37GDVqFAIDAw3etn//fvTv3x9WVlYoKChATEwMAgMD0bZtW6jVavTq1QtxcXGyLEI8derUcsdVKhUWLVoEe3t7AEBkZKQhszQOHDiAZcuW4dixY8jLywNQsqh1p06dMHXqVPTo0UOWrsqkpaXh9ddfl23hbaVSiT179sDOzg5DhgyBg4ODZlteXh4++OAD2dZWXLt2LY4ePYru3btj1KhR+Oabb/DJJ5+gsLAQI0aMQFhYmCxdFenVqxeUSiVat24ty/1fvnwZvXv3xh9//IGOHTuiUaNGAIDTp0/jyy+/RNOmTbFv3z64u7vL0leZW7duISwsDHPmzDHo/d68eRP9+/dHcnIyJEnCsGHDsHr1alhZWQEoeZ7y9/eHSqUyaBcAnDhxAr169UJeXh5sbGxw4MABDB48GMbGxlCr1Vi0aBESExPRrl07g7dFRUWVO56VlYXo6Gg4OTkBAIKDg2u8hU8Z/ZQqegIvlZ2dja1bt8ryw64Pa2trKJVK4fbOkaNr7ty5GD16tHALJYraBXCbvkRue1qi/u4AxG0TtQswbNtLL72Etm3b4ssvv9SZ7CEiTJgwAampqTh27FiNt5S1e/fuSrdfuXIF06ZNk+X5feDAgSguLsaGDRuQm5uLDz74ABcuXEBCQgKaN2+O27dvo3HjxrK0de7cGQEBAViwYAG2b9+O999/HxMnTsSnn34KAPjwww+RnJyMuLg4g7cpFAq0bdsWNjY2WuOHDx9Ghw4dYGlpCUmSZNkbZ+PGjRg7diz+53/+B71799a84bx9+zbi4uLw3XffYd26dRgxYoTB2yqjVCrRrl07WX7W4uLi8MYbb8DDwwN//fUXHjx4gB07dsDf3x8AZH0cLF++HB9//DF69+6NY8eOYdKkSVi2bBlCQkKgUqkQERGBpUuXYvz48QZvq+hN7pkzZ9CqVSuYm5sDAFJSUgyZhZ49e8LS0hKbNm1C/fr1tbbl5eUhMDAQDx8+RGxsrEG7ACA1NbXS7enp6Rg6dKjBf9ZGjhyJixcvYuXKlcjNzcWsWbMgSRLi4uJga2uL27dvw9nZGWq12qBdQMn308XFBZGRkfjqq6+wYsUK9OnTB19//TUAYPTo0fjzzz8RExNj8DaFQoEmTZrA2Fh7P5Pr16+jcePGMDExgSRJhplMJvZUFAoFtWvXjrp3717upUOHDqRQKGRtLCoqIiMjIzp79myVt83KyqLHjx8boErcrlJt27YlIyMjCggIoC1bttCjR48Mev8VEbWLiNv0JXLb0zp69Kiw3XL8/ngaIn/NDNlmbm5OaWlpFW5PS0sjc3Nzg7SUJUkSKRQKkiSpwotcz+8NGzak1NRUzXW1Wk0TJkyg5s2bU2ZmJt26dUu2tvr161NGRgYREalUKjI2NqaUlBTN9rNnz1KjRo1kaQsPDydXV1eKj4/XGjc2Nqbz58/L0lTKw8ODVq5cWeH2VatWkbu7uwGLSoSEhFR6eeedd2T7WevUqRN99NFHRFTyGFi8eDFZWVnRvn37iIhkfRy0atWKtmzZQkREKSkpZGxsTGvXrtVsX7t2LbVv316WNmNjY+rTpw998sknmsvcuXNJoVDQ+++/rxkzNAsLi0rfE6SmppKFhYUBi/5W2fNB6bgcP2uNGzemX3/9VXP90aNH9MYbb5Cvry/du3dP1seAra0tXbhwgYhK3vMpFAqt1uTkZGrSpIksbe+99x75+vpq+krJ8VzAky5PqWXLlrR58+YKt58+fVr2SRciIldXVzpz5ozcGTpE7SqVkpJCQUFB5ODgQDY2NjRhwgQ6ceKE3FnCdhFxm75EbDt//jxNnDiRfH19ycnJiZycnMjX15cmTpwo+xuUyly+fJn8/f1lue8//viDNm/eTHv37qXCwkKtbfn5+RQWFiZLFxFRXFwczZkzR/OG8/Dhw9SnTx/y9/en9evXy9bl4uJCGzdurHD7xo0bqUWLFoYL+n+NGzemXbt2Vbhdzud3a2trnReLRESTJk2ipk2b0pEjR2SddLl8+bLmupWVFWVmZmquX7t2TZZJtFInTpygli1b0rRp06ioqIiIxJh0MTMzo/T09Aq3p6eny/J1E/nDxSd/1oiItmzZQpaWlrRnzx5Z33BaWFjQ9evXNdfNzMzo3LlzmusZGRlkY2MjRxolJibSc889R3PmzCGVSqUZl/tx4OzsTHv27Klw++7du8nZ2dmARX+zt7endevW0bVr18q97N27V5afNUtLS7p06ZLWWHFxMQ0YMIB8fHwoNTVVtseApaUlXb16VXP9yeeC69evy/pcsHPnTmrWrBl9/vnnmjGedBHYsGHD6IMPPqhw+5kzZ0iSJAMWlW/t2rXUt29funfvntwpWkTtelJRURF9//339J///IdMTEzI29ubli9fTrm5udzFbbWy7aeffiJTU1N66aWXaO7cubR69WpavXo1zZ07lzp37kxmZma0f/9+gzY9rTNnzsjyIuPEiRNkY2ND9evXJwsLC3J3d9d6kS3nG4DNmzeTsbExtWvXjqysrCg6OppsbGxo7NixNHr0aDI1NaUdO3bI0rZy5UoyMzOj4OBg+uGHH+j48eN0/Phx+uGHHyg4OJgsLCxo1apVBu964403aPbs2RVul/P5/YUXXqBNmzaVu23SpElkY2Mj28+aj4+PZk8DopI9W4qLizXXjxw5Qq6urnKkafz1118UGBhIPj4+dPbsWTIxMZF90qVdu3Y0ffr0CrfPmDGD2rVrZ8CiEiJ/uOjo6EinTp3SGd+2bRvVq1ePvvjiC9na7O3ttSZGmzZtSteuXdNcz8jIICsrKznSiIgoNzeX3n77berYsaNm4kruSZfZs2eTra0tRUZGklKppFu3btGtW7dIqVRSZGQk2dnZ0dy5c2Vp69WrF82fP7/C7XI9H3h7e9N3332nM1468dK8eXNZ9/Yqu1fhjz/+SAUFBZrrx48fp6ZNm8qRpvH7779TQEAA9enTh27evMmTLiK7efOm1i9RUfn6+pKVlRWZmZlRy5Ytyc/PT+vCXZUrLCyk7du3U69evcjY2JheeeUVcnd3J2tra9q+fTt3cVuta/Px8an0DefcuXPJ29vbYD1lrVixotLLjBkzZHmR0aNHDxo1ahSpVCrKy8ujiRMnkr29vebQCjknXXx9fWnFihVERPTzzz+ThYUFRUZGarZ/9tln1KVLF1naiIi2b99OHTt2JGNjY80u28bGxtSxY0f65ptvZGk6cuSI1uTBk/Lz8ykhIcGARX9buHAhvfbaaxVunzhxomwTQl988QX9+OOPFW7/8MMPacyYMQYsqti2bduoUaNGpFAoZJ90OXToEFlaWpK3tzeFhITQokWLaNGiRRQSEkI+Pj5kZWVFhw8fNniXyB8u9uzZk5YuXVrutq1bt5KJiYlsv3O7dOlS6XP2nj176PnnnzdgUfnWr19PTk5O9NVXXwkx+bho0SJydnbWHK5TeuiOs7MzLV68WLaunTt3Vjr5mJOTQxs2bDBgUYkZM2ZQr169yt1WXFxM/fr1k+0x8Mknn9C2bdsq3P7RRx/RoEGDDFhUPrVaTQsXLiQnJycyMjIy+GOAF9KtIdu2bUO/fv1gaWlp0PutaoX0uXPnGqhEm6hdpZKTkxEdHY1t27bBzMwMgYGBGDt2rGbl9M8//xwLFizA7du3uYvbalWbhYUFzpw5A09Pz3K3X7x4Eb6+vrKcXlKhUMDZ2Rmmpqblbi8qKsKtW7cMvqCdnZ0djh8/rjn7DgAsWrQIS5YsQWxsLJo3by7boo5WVlY4e/YsXF1dAQCmpqY4deoUfHx8AJQsAti1a1fcvXvX4G1lFRcXaxocHBxgYmKic5vff/8djRs3hkKhMHRepUTtAritqvtPTk5Gjx49dF6bGbrt2rVr+OKLL3D8+HHcunULAODk5IROnTphwoQJcHFxMUhHWbdu3UJhYaGQC73HxMTgyJEjWLZsWbnbt27diq+//hqHDh0ycBmQlJQES0tL+Pr6lrt99erVUKvVmDx5smHDypGRkYHhw4fj1KlTOHfuHLy8vOROwtWrV7UeA6XPXUzb48ePUVBQoLPwcNntN27cEPLxW1BQACMjI5iZmcmdAqDkdXhiYiICAwNha2truDs26BRPHWJtba11PBsT1/PPP0/GxsbUt29fiomJKXchzuzsbIN/wiNqF7fVrrZWrVpRREREhdsjIiLI09PTYD1lubi4VLr3g1y7u9va2pJSqdQZX7p0KdnY2NDOnTtl+8TJxsZGa72IJ4+tvnLlCtWrV0+OtGoT9XlU1C4ibtOXyG1bt26l/Px8uTN0iNpFxG2VUalUlJubS2q1Wmeb3G0VEfnxKWqbqF1EdbfNuOppGaYPknkHouTkZKSlpQEA2rRpAz8/P1l7SonYNWTIEIwePRpNmjSp8DYODg4GPw2bqF0At+lLxLZ58+Zh2LBhSEhIQI8ePbROXxofH4/9+/dj69atBuspq3379khOTsaQIUPK3S5Jkiy/a59//nn88ssvmr1HSoWGhkKtVmPo0KEGbyrl7u6O9PR0zZ5LN27cgLW1tWZ7ZmYmmjZtKldetcj9PFoRUbsAbtOXyG3vvfceOnbsKNwp50XtAritMgqFAg0aNCh3m9xtFRH58Slqm6hdQN1tE2//U/aP3LlzBwEBAXjhhRcQHByM4OBgtG/fHq+++iqys7O56wnFxcXYsGED8vLyZGsoj6hdALfpS9S2wYMH4/Dhw6hXrx4iIiIQGBiIwMBAREREwMLCAgkJCXjzzTdlaZs3bx4GDx5c4XYvLy9cvXrVgEUlAgMDkZSUVO62GTNmICwsDM2bNzdwVYmPPvpIa3fZ+vXrQ5IkzfVTp05VOInFGBOPqG9QRO0CuE1fIrcx9qzjSZdaJigoCH/99RfOnz+PnJwc5OTk4Ny5c8jLy0NwcDB3PcHExASPHj2S7f4rImoXwG36Ermtc+fO2L59O65fv47CwkIUFhbi+vXr2L59Ozp16qR126SkJBQWFhqky8vLCx06dKhwu4mJidbxy4ZqGzt2LDZv3lzh9pkzZ2pNBhnyazZw4EC88sorFW6fNWsW5s+fr7luyDbGGGOMsbqIJ11qmf3792P16tVo3bq1ZszLywurVq3Cvn37uKsckyZNwuLFi/H48WNZO54kahfAbfoSue1pvfbaa7hx44bcGeUStU3ULkDsNsYYY4yx2oDXdKll1Gp1uWeBMDExkWUNi1KidgHAyZMnER8fj7i4OHh7e+uc1WDnzp3c9QRu04/IbU9L5N2PRW0TtQsQu63sYVEiEbUL4DZ9idzGWF0n8uNT1DZRu4C628aTLtWgUqmQlJQEHx8f2NjYVHrbFi1alDvJUNMCAgIwZcoUbNu2DY0bNwZQspBiSEgIXn31VYP3iN4FADY2NrKtWVEZUbsAbtOXyG2MiUbUCSFRuwBu05fIbYzVdSI/PkVtE7ULqMNtNXJOpFrMzMyMrly5IndGhbKyssjX15dMTEzIzc2N3NzcyMTEhPz8/Oi3337jLsbYP/LkKYhFImqbqF1E8rZlZGTQ/v37qaCggIhI5xSmWVlZ5Z5Wva52EXGbvkRuq0qbNm0oKytL7gwdonYRcZu+DN0WFhZGDx480BkvKCigsLAwzfWjR4/So0ePDNZFJG6bqF1E3FYVnnSppvbt29PPP/8sd0al1Go1xcXFUVRUFEVFRdGBAwfkTiIicbv8/f3pzz//1Bm/f/8++fv7Gz7o/4naRcRt+hK57WnxBEL1idpFJE/b3bt36dVXXyVJkkihUGjuf9SoUTR16lSDtjwLXdxWO9tcXV3p7t27OuN//vknubq6ylBUQtQuIm7Tl6htCoWCbt++rTN+9+5dUigUMhT9TdQ2UbuIuK3Khprbh6Z2WrBgAUJDQ/Hjjz/i5s2byMvL07qIQJIk9OzZE0FBQQgKCkKPHj3kTgIgbldCQgKKiop0xh89eoSjR4/KUFRC1C6A2/QlctvTqqvH4v4TonYB8rSFhITA2NgYWVlZqFevnmb8rbfewv79+w3eI3oXwG36Ernt2rVrUKlUOuOFhYWyLm4tahfAbfoStY2Iyn0OUiqVsLOzk6Hob6K2idoFcFtVeE2Xaurbty8AoF+/flrfvNJvZnm/1GpaVFTUU9/WkKdnFrWrVGpqqubPFy5cwK1btzTXVSoV9u/fjyZNmnBXGdymH5Hbqovq6rG4/4CoXYA8bXFxcYiNjUXTpk21xj08PHD9+nWD95QStQvgNn2J2LZ7927Nn2NjY9GgQQPNdZVKhfj4eLi4uHBXGdymH1HbbG1tIUkSJElCy5Yttd5PqVQq5OfnY8KECQbvErlN1C5ue3o86VJNhw4dkjtBx7Jly57qdpIkGXRyQ9SuUr6+vpoHYkBAgM52CwsLfP7559xVBrfpR+S2UnPnzsXo0aPRokWLSm/3119/Gajob6K2idoFiN324MEDrb0OSuXk5MDMzMzgPaVE7QK4TV8itg0YMABAyWufkSNHam0zMTGBi4sLIiIiuKsMbtOPqG3Lly8HEWH06NEICwvTmgwyNTWFi4sLOnXqZPAukdtE7eK2pyeRyB/BMVaDrl+/DiKCm5sbTpw4AUdHR802U1NTNGzYEEZGRtzFbbW6rZSvry/OnTuHbt26YcyYMXjzzTdlf8NUStQ2UbsAsdv69u2L9u3bY/78+bC2tkZqaipatGiBt99+G2q1Gt999x13cVutb3N1dcXJkyfh4OAgW0N5RO0CuE1forYdPnwYnTt3luVsr1URtU3ULoDbqsKTLno4evQovvrqK1y5cgU7duxAkyZNsHnzZri6uqJr165y52mUfmtFW09A1C7G6rrTp08jOjoa27Ztw+PHj/H2229j9OjReOGFF+ROE7ZN1C6R286dO4dXX30V7dq1w8GDB9GvXz+cP38eOTk5SEpKwnPPPcdd3Fbr2xhjgFqtxuXLl3Hnzh2o1Wqtba+88opMVSVEbRO1C+C2yvCkSzV9//33GDFiBIYPH47NmzfjwoULcHNzw8qVK/HTTz/hp59+kjsRmzZtwtKlS5GRkQEAaNmyJaZPn44RI0ZwVwUyMjJw6NChch+Ic+bMkalK3C6A2/Qlclup4uJi7NmzB9HR0YiNjUWrVq0wZswYvPvuu1q7ZnKb+F2itt2/fx8rV66EUqlEfn4+2rVrh0mTJsHZ2VmWHtG7uK12tsXHxyM+Pr7c54P169fLVCVuF8Bt+hKx7fjx4xg2bJhmb+Cy5Fons5SobaJ2AdxWFZ50qSY/Pz+EhIQgMDAQ1tbWUCqVcHNzw+nTp/Haa69pLZAph8jISMyePRuTJ09Gly5dAACJiYlYtWoVFixYgJCQEO56wtdff42JEyfCwcEBTk5OWnvgSJKElJQU7uK2Wt9WVlFREWJiYrB+/XocPHgQnTt3xh9//IHbt2/j66+/xltvvcVtz0iX6G2M1VVhYWGYN28eOnToAGdnZ529f2NiYrjrCdymH1HbfH190bJlS4SFhZXbJecHFqK2idoFcFuVaviU1LWOhYUFXb16lYiIrKysKDMzk4iIMjMzyczMTMayEi4uLrRx40ad8Q0bNpCLi4sMRSVE7SIiat68OS1atEjWhvKI2kXEbfoSuY2I6NSpUzRp0iSys7MjZ2dnmjlzJmVkZGi2R0VFUcOGDbntGegSuU2pVJZ7SU1NpUuXLtGjR48M3iRyF7fVzjYnJyfatGmTbPdfEVG7iLhNX6K21atXT+s5SSSitonaRcRtVeFJl2pydXWlAwcOEJH2pMvGjRupdevWcqYREZGZmVm5P1SXLl2SdVJI1C4iImtra833USSidhFxm75Ebnv++efJ2NiY+vbtSzExMfT48WOd22RnZ5MkSdwmeJfobZIkkUKhIIVCQZIkaV1XKBRkZmZGgYGB9PDhQ+7itlrbZmdnR5cvXzb4/VZF1C4ibtOXqG3+/v60b98+uTPKJWqbqF1E3FYVRc3vS1O7jBs3DlOmTMGvv/4KSZLwxx9/YMuWLQgNDcXEiRPlzoO7uzu+/fZbnfFvvvkGHh4eMhSVELULAAYPHoy4uDhZG8ojahfAbfoSuW3IkCG4du0a9u7diwEDBpR7NiUHBwedY8HrcpuoXaK3xcTEwMPDA2vWrIFSqYRSqcSaNWvg6emJrVu3Yt26dTh48CA+/vhj7uK2Wts2duxYbN261eD3WxVRuwBu05dIbampqZpLUFAQpk2bhg0bNiA5OVlrW2pqKrcJ3sVt1cNrulQTEWHhwoUIDw9HQUEBAMDMzAyhoaGYP3++zHUlC/2+9dZb6NGjh2btlKSkJMTHx+Pbb7/FwIEDuesJ4eHhiIyMxOuvvw5vb2+d04kFBwdz1xO4TT+ithUXF6NVq1b48ccf0bp1a1kaKiJqm6hdgNhtAPDiiy9i/vz56N27t9Z4bGwsZs+ejRMnTmDXrl2YNm0aMjMz63wXt9WetqlTp2r+rFarsXHjRvj4+MDHx0fn+SAyMrLGe0Tv4rba16ZQKCBJks5ipqVKt8mx8KqobaJ2cVv18KSLnoqKinD58mXk5+fDy8sLVlZWcidpJCcnY9myZUhLSwMAtG7dGtOmTYOfnx93lcPV1bXCbZIk4cqVKwas+ZuoXQC36UvktiZNmuDnn38W8k26qG2idgFit1lYWOD06dNo1aqV1nh6ejr8/Pzw8OFDXLt2DV5eXpoPN+pyF7fVnjZ/f/+nup0kSTh48GAN1/xN1C6A2/Qlatv169ef+rYtWrSowRJdoraJ2gVwW3XwpAtjjDEsXLgQly5dwtq1a2FsbCx3jhZR20TtAsRu8/PzQ9u2bbFmzRqYmpoCKNk7Z9y4cVAqlTh9+jSSkpLwzjvv4OrVq3W+i9tqZxtjjLG6Q6xXYoIaNGjQU992586dNVhStZ9++glGRkbl7kqrVqvx2muvcRdjTMfJkycRHx+PuLg4eHt7w9LSUmu7nL/bRG0TtQsQu23VqlXo168fmjZtCh8fHwDA2bNnoVKp8OOPPwIArly5gvfff5+7uK3WtjFW1+3evbvccUmSYG5uDnd390r3EK5JoraJ2gVwW1V4T5enMGrUKM2fiQgxMTFo0KABOnToAKDksJnc3FwMGjQI0dHRcmUCAHx8fLBo0SL07dtXa3z//v2YOXMmlEoldz1h9OjRlW5fv369gUq0idoFcJu+RG4r+3uuPHL+bhO1TdQuQOw2APjrr7+wZcsWXLp0CQDg6emJYcOGwdramrsqwG36EbVt4MCBkCRJZ7zsm4Bhw4bB09OTu7itVrZVtOZG2bU2unbtil27dsHW1pbbBO7itqrxpEs1zZw5Ezk5Ofjyyy81Z4NQqVR4//33Ub9+fSxdulTWPgsLC6SlpcHFxUVr/Nq1a2jTpg0ePHjAXU94chHf4uJinDt3Drm5uQgICJDtE2FRuwBu05fIbYwZ2oULF5CVlYWioiKt8X79+slUVELULoDb9CVi27vvvotdu3bBxsYG7du3BwCkpKQgNzcXvXr1glKpxLVr1xAfH685AUFd7uK22tcWHx+P//73v/j000/x4osvAgBOnDiB2bNn4+OPP0aDBg3w3nvvoWPHjli3bp3BukRuE7WL255CzZ+VunZxcHCg9PR0nfH09HSys7OToUhbo0aNKD4+Xmf8wIED5OjoKENRCVG7KqJSqWj8+PG0ePFiuVO0iNpFxG36ErmNsZqQmZlJPj4+JEkSKRQKzX9LL9zFbXWhbebMmTRx4kRSqVSaMZVKRZMnT6YPP/yQ1Go1jR8/nrp06cJd3FYr29q0aUNJSUk644mJieTl5UVEJe8TmjVrZtAuInHbRO0i4raq8KRLNdnY2NCuXbt0xnft2kU2NjYyFGkbP348eXt70+XLlzVjGRkZ5OPjQ2PGjOGuakhPTycnJye5M3SI2kXEbfoSpW3Hjh00ePBg6tixI/n5+Wld5CZqm6hdIrf95z//of79+1N2djZZWVnR+fPn6ejRo/Tiiy/SkSNHuIvb6kSbg4MDXbx4UWf84sWLZG9vT0REqamp1KBBA+76f9ymH1HbzM3N6ezZszrjqampZG5uTkRE165dIwsLC4N2EYnbJmoXEbdVRVEz+8/UXqNGjcKYMWMQGRmJxMREJCYmIiIiAmPHjq3yGHpDWLJkCSwtLdGqVSu4urrC1dUVrVu3hr29PT777DPuqobMzEw8fvxY7gwdonYB3KYvEdqioqIwatQoNGrUCKdPn8aLL74Ie3t7XLlyRfaFrkVtE7VL9LZjx45h3rx5cHBwgEKhgJGREbp27Yrw8HAEBwdzF7fVibbHjx8jPT1dZzw9PR0qlQoAYG5uXu5aHHWxC+A2fYna1r59e0yfPh3Z2dmasezsbMyYMQMvvPACACAjIwPNmjUzaJfIbaJ2cVvV+OxF1fTZZ5/ByckJERERuHnzJgDA2dkZ06dPx7Rp02SuAxo0aIBffvkFBw4cgFKphIWFBXx8fPDKK69wVwWmTp2qdZ2IcPPmTezduxcjR46UqUrcLoDb9CVy2+rVq7FmzRoMHToUGzZswIwZM+Dm5oY5c+YgJyeH256hLtHbVCqVZhFTBwcH/PHHH/D09ESLFi1w8eJF7uK2OtE2YsQIjBkzBh999JHmRf/JkyexcOFCBAYGAgAOHz6MNm3acBe31cq2devWoX///mjatKnmze5vv/0GNzc3/PDDDwCA/Px8fPzxxwbtErlN1C5uqxovpPsP5OXlAQDq168vc0mJ4uJiWFhY4MyZM3j++eflztEQtauUv7+/1nWFQgFHR0cEBARg9OjRMDaWZ25S1C6A2/Qlclu9evWQlpaGFi1aoGHDhjhw4ADatm2LjIwMvPTSS7h37x63PSNdore9/PLLmDZtGgYMGIBhw4bhzz//xMcff4w1a9YgOTkZ586d4y5uq/VtKpUKixYtwsqVK3H79m0AQKNGjRAUFISZM2fCyMgIWVlZUCgUaNq0aZ3v4rba2aZWqxEXF6d1drGePXtCoZD/YAxR20TtAritUjV24BKThaurK505c0buDB2idjHGSri6ulJKSgoREbVv356+/PJLIiKKjY0lW1tbOdOEbRO1i0jstv3799P3339PRCVre3l6epIkSeTg4FDugut1vYvbamdbWffv36f79+/LnaFD1C4ibtOXyG2M1Wa8p0s13b59G6GhoYiPj8edO3d0zvddemykXNatW4edO3di8+bNsLOzk7WlLFG7ysrOztbsbuzp6QlHR0eZi0qI2gVwm75EbBs7diyaNWuGuXPnYtWqVZg+fTq6dOmCU6dOYdCgQQY/vd+z0CZql+ht5cnJyYGtra0s6x1URtQugNv0JXIbY7VdVFQUxo8fD3Nzc0RFRVV6W0OvuyRqm6hdALdVB0+6VNNrr72GrKwsTJ48Gc7OzjpP2v3795eprISfnx8uX76M4uJitGjRApaWllrbU1JSuOsJDx48QFBQEDZt2gS1Wg0AMDIyQmBgID7//HPUq1ePu7it1rep1Wqo1WrNIU7bt2/HL7/8Ag8PD7z33nswNTXltmekS/Q2xuqqdu3aIT4+Hra2tvDz86t04seQr4tE7QK4TV+itrm6uuLUqVOwt7eHq6trhbeTJAlXrlwxWBcgbpuoXQC3VQcvpFtNiYmJOHr0KHx9feVOKdeAAQPkTiiXqF1AyeKmhw8fxp49e9ClSxcAJd/n4OBgTJs2DV988QV3cVutb1MoFFrHtb799tt4++23ZespS9Q2UbsAsdsYq6v69+8PMzMzAGK9LhK1C+A2fYnadvXq1XL/LAJR20TtAritOnhPl2ry8vLCli1b4OfnJ3cK+5c4ODjgu+++Q/fu3bXGDx06hCFDhmidXoy7SnCbfkRuA4Dc3FycOHECd+7c0eyJU6r0DAdyEbVN1C5A7DbGGGMMAIqKinD16lU899xzsp5QoDyitonaBXBbhWRcT+aZFBsbS7169aKrV6/KncL+JRYWFnThwgWd8XPnzlG9evVkKCohahcRt+lL5Lbdu3eTtbU1SZJEDRo0IBsbG81F7oVXRW0TtUv0NsZYiT///JO+/vprmjVrFt27d4+IiJKTk+n333/nrgpwm35EbHvw4AGNHj2ajIyMyMjIiDIzM4mIaPLkyRQeHi5bl8htonZxW9V40qWabGxsyNTUlBQKBVlZWZGtra3WRQ62traUnZ2t6XuySa4+UbueFBAQQIMHD6aHDx9qxgoKCmjw4MH06quvclc5uE0/Ird5eHjQlClT6MGDB7J2lEfUNlG7iMRuY4wRKZVKcnR0JHd3dzI2Nta8Cfjvf/9LI0aM4C5uq/VtwcHB1L59ezp69ChZWlpqunbt2kW+vr6ydYncJmoXt1VNrH1+ngHLly+XO0HHsmXLYG1tDUCsPlG7nrR8+XL06dMHTZs2Rdu2bQEASqUSZmZmiIuL4y5uqxNtN27cQHBwsKyL+VZE1DZRuwCx2xhjJWt8vfvuu1iyZInmtRIA9O3bF8OGDeOucnCbfkRt27VrF7755hu89NJLWgv9tmnTBpmZmbJ1AeK2idoFcFtVeNKlmkaOHCl3go6yTSL1idr1JG9vb2RkZGDLli1IT08HAAwdOhTDhw+HhYUFd3FbnWjr3bs3Tp06BTc3N1k7yiNqm6hdgNhtjDHg5MmT+Oqrr3TGmzRpglu3bslQVELULoDb9CVqW3Z2Nho2bKgz/uDBA9lP6S5qm6hdALdVhSdd9JCZmYno6GhkZmZixYoVaNiwIfbt24fmzZujTZs2cudpPHr0CEVFRVpj9evXl6nmb6J1hYeHo1GjRhg3bpzW+Pr165GdnY2ZM2dy1xO4TT8it73++uuYPn06Lly4AG9vb5iYmGht79evn0xl4raJ2gWI3cYYA8zMzJCXl6czfunSJTg6OspQVELULoDb9CVqW4cOHbB3714EBQUBgObN79q1a9GpUyfZugBx20TtAritSgY5iKkWSUhIIAsLC+rRoweZmppqjgkLDw+nN998U+Y6ovz8fJo0aRI5OjqSQqHQuXCXrhYtWlBSUpLO+PHjx8nFxUWGohKidhFxm75EbpMkqcKL3I9RUdtE7RK9jTFGNGbMGBowYAAVFRWRlZUVXblyha5fv05+fn40ZcoU7uK2Wt929OhRsrKyogkTJpC5uTlNmTKFevbsSZaWlnTq1CnZukRuE7WL26qmMMzUTu0xa9YsLFiwAAcOHICpqalmPCAgAMePH5exrMSMGTNw8OBBfPHFFzAzM8PatWsRFhaGxo0bY9OmTdxVjlu3bsHZ2Vln3NHRETdv3pShqISoXQC36UvkNrVaXeFFpVJx2zPUJXobYwyIiIhAfn4+GjZsiIcPH6Jbt25wd3eHlZUVPv30U+7itlrf1rVrVyiVSjx+/Bje3t6Ii4tDw4YNcezYMbRv3162LpHbRO3itqrx4UXVdPbsWWzdulVnvGHDhrh7964MRdr27NmDTZs2oXv37hg1ahRefvlluLu7o0WLFtiyZQuGDx/OXU9o1qwZkpKS4OrqqjWelJSExo0by1QlbhfAbfoSuY0xxpjhNGjQAAcOHEBSUhKUSiXy8/PRrl079OjRg7u4rU60BQYGwt/fH7NmzcJzzz0na8uTRG0TtQvgtqrwpEs12djY4ObNmzpvmk6fPo0mTZrIVPW3nJwczcKJ9evXR05ODoCSGb6JEydyVznGjRuHDz74AMXFxQgICAAAxMfHY8aMGZg2bRp3cVutbYuKisL48eNhbm6OqKioSm8bHBxsoKoSoraJ2gWI3cYY0xUfH4/4+HjcuXMHarUa6enpmg/21q9fz13cVqvbTE1NER4ejrFjx6Jx48bo1q0bunfvjm7dusHDw0OWJtHbRO3itqpJREQGuadaIjQ0FL/++it27NiBli1bIiUlBbdv30ZgYCACAwMxd+5cWft8fHzw+eefo1u3bujRowd8fX3x2WefISoqCkuWLMHvv//OXU8gIsyaNQtRUVGaBX7Nzc0xc+ZMzJkzh7u4rda2ubq64tSpU7C3t9eZSC5LkiRcuXLFgGXitonaBYjdxhjTFhYWhnnz5qFDhw5wdnbWOYNGTEwMdz2B2/QjchsA3LhxA0eOHMHhw4dx+PBhXLp0Cc7OzrK+NxC9TdQubqsYT7pUU1FRESZNmoQNGzZApVLB2NgYjx8/xvDhw7FhwwYYGRnJ2rds2TIYGRkhODgYP//8M9544w0QEYqLixEZGYkpU6ZwVwXy8/ORlpYGCwsLeHh4wMzMTO4kAOJ2AdymL5HbgJLJIQCyn+KvPKK2idoFiN3GWF3l7OyMJUuWYMSIEXKnaBG1C+A2fYncBgAFBQVITEzEoUOHkJCQgJSUFHh5eeH06dNypwnbJmoXt1WMJ1309Ntvv+Hs2bPIz8+Hn5+f7LtNVeT69etITk6Gu7s7fHx85M7RELWLsbps3bp1WLZsGTIyMgAAHh4e+OCDDzB27FiZy8RtE7ULELuNsbrO3t4eJ06cEG7tA1G7AG7Tl6htH330ERISEnD69Gm0bt1ac8jHK6+8AltbW257hrq4rWo86VJNU6dOLXdckiSYm5vD3d0d/fv3h52dnYHL/vbkcZtliXSMcFlyH+vKWF03Z84cREZGIigoCJ06dQIAHDt2DCtXrkRISAjmzZvHbc9Il+htjDFg5syZsLKywuzZs+VO0SJqF8Bt+hK1TaFQwNHRESEhIRg0aBBatmwpd5KGqG2idgHcVhWedKkmf39/pKSkQKVSwdPTEwBw6dIlGBkZoVWrVrh48SIkSUJiYiK8vLwM3ifqcZuidjHGSjg6OiIqKgpDhw7VGt+2bRuCgoJkPTubqG2idgFitzFWV5X94E6tVmPjxo3w8fGBj48PTExMtG4bGRlZ57u4rXa2lVIqlTh8+DASEhJw9OhRmJqaavZA6N69u6xv2kVtE7WL26rGky7VtHz5chw9ehTR0dGoX78+AOD+/fsYO3YsunbtinHjxmHYsGF4+PAhYmNjDd4n6nGbonYxxkrY2Njg5MmTOodKXrp0CS+++CJyc3PlCYO4baJ2AWK3MVZX+fv7P9XtJEnCwYMHa7jmb6J2AdymL5HbKqJUKrFs2TJs2bIFarUaKpVK7iQNUdtE7QK47Uk86VJNTZo0wYEDB3T2Yjl//jx69eqFGzduICUlBb169ZLlk0RRj9sUtYsxViIoKAgmJiY6n3iFhobi4cOHWLVqlUxl4raJ2gWI3cYYY4wREU6fPo2EhAQkJCQgMTEReXl58PHxQbdu3bBs2TJue0a6uK1qxjV+D7XM/fv3cefOHZ1Jl+zsbOTl5QEo+YSx9HSwhjZ27Fhs3bpVuOM2Re1irC4ru/uxJElYu3Yt4uLi8NJLLwEAfv31V2RlZSEwMJDbBO8SvY0xxhgry87ODvn5+Wjbti26deuGcePG4eWXX4aNjY3cacK2idrFbVXjPV2qafjw4Th27BgiIiLwwgsvAABOnjyJ0NBQdO7cGZs3b8b27dvx2Wef4dSpUwZpEvW4TVG7GGMlRN79WNQ2UbsAsdsYY4yxsvbu3YuXX35Zs1yDSERtE7UL4Laq8KRLNeXn5yMkJASbNm3C48ePAQDGxsYYOXIkli1bBktLS5w5cwYA4Ovra5AmUV9oi9rFGGOMMcYYY4wZAk+66Ck/Px9XrlwBALi5ucHKykrmIsYYY4wxxhhjjImEJ10YY4wxxhhjjDHGaoBC7gDGGGOMMcYYY4yx2ognXRhjjDHGGGOMMcZqAE+6MMYYY4wxxhhjjNUAnnRhjDHGGGOMMcYYqwE86cIYY4yxZxIRYfz48bCzs4MkSThz5ozcSYwxxhhjWvjsRYwxxhh7Ju3btw/9+/dHQkIC3Nzc4ODgAGNj43/0d7777rvIzc3Frl27/p1IxhhjjNVp/+yVCWOMMcaYTDIzM+Hs7IzOnTvLnaJDpVJBkiQoFLxTMWOMMVaX8SsBxhhjjD1z3n33XQQFBSErKwuSJMHFxQVqtRrh4eFwdXWFhYUF2rZti++++07z/6hUKowZM0az3dPTEytWrNBs/+STT7Bx40b88MMPkCQJkiQhISEBCQkJkCQJubm5mtueOXMGkiTh2rVrAIANGzbAxsYGu3fvhpeXF8zMzJCVlYXCwkKEhoaiSZMmsLS0RMeOHZGQkGCgrxJjjDHG5MZ7ujDGGGPsmbNixQo899xzWLNmDU6ePAkjIyOEh4fjf//3f/Hll1/Cw8MDR44cwTvvvANHR0d069YNarUaTZs2xY4dO2Bvb49ffvkF48ePh7OzM4YMGYLQ0FCkpaUhLy8P0dHRAAA7Ozv88ssvT9VUUFCAxYsXY+3atbC3t0fDhg0xefJkXLhwAdu3b0fjxo0RExODPn364OzZs/Dw8KjJLxFjjDHGBMCTLowxxhh75jRo0ADW1tYwMjKCk5MTCgsLsXDhQvz888/o1KkTAMDNzQ2JiYn46quv0K1bN5iYmCAsLEzzd7i6uuLYsWP49ttvMWTIEFhZWcHCwgKFhYVwcnKqdlNxcTFWr16Ntm3bAgCysrIQHR2NrKwsNG7cGAAQGhqK/fv3Izo6GgsXLvwXvhKMMcYYExlPujDGGGPsmXf58mUUFBSgZ8+eWuNFRUXw8/PTXF+1ahXWr1+PrKwsPHz4EEVFRfD19f1XGkxNTeHj46O5fvbsWahUKrRs2VLrdoWFhbC3t/9X7pMxxhhjYuNJF8YYY4w98/Lz8wEAe/fuRZMmTbS2mZmZAQC2b9+O0NBQREREoFOnTrC2tsbSpUvx66+/Vvp3ly6GW/aEj8XFxTq3s7CwgCRJWk1GRkZITk6GkZGR1m2trKyq8a9jjDHG2LOKJ10YY4wx9swru3htt27dyr1NUlISOnfujPfff18zlpmZqXUbU1NTqFQqrTFHR0cAwM2bN2FrawugZCHdqvj5+UGlUuHOnTt4+eWXq/PPYYwxxlgtwZMujDHGGHvmWVtbIzQ0FCEhIVCr1ejatSvu37+PpKQk1K9fHyNHjoSHhwc2bdqE2NhYuLq6YvPmzTh58iRcXV01f4+LiwtiY2Nx8eJF2Nvbo0GDBnB3d0ezZs3wySef4NNPP8WlS5cQERFRZVPLli0xfPhwBAYGIiIiAn5+fsjOzkZ8fDx8fHzw+uuv1+SXhDHGGGMC4FNGM8YYY6xWmD9/PmbPno3w8HC0bt0affr0wd69ezWTKu+99x4GDRqEt956Cx07dsS9e/e09noBgHHjxsHT0xMdOnSAo6MjkpKSYGJigm3btiE9PR0+Pj5YvHgxFixY8FRN0dHRCAwMxLRp0+Dp6YkBAwbg5MmTaN68+b/+72eMMcaYeCQqe4AyY4wxxhhjjDHGGPtX8J4ujDHGGGOMMcYYYzWAJ10YY4wxxhhjjDHGagBPujDGGGOMMcYYY4zVAJ50YYwxxhhjjDHGGKsBPOnCGGOMMcYYY4wxVgN40oUxxhhjjDHGGGOsBvCkC2OMMcYYY4wxxlgN4EkXxhhjjDHGGGOMsRrAky6MMcYYY4wxxhhjNYAnXRhjjDHGGGOMMcZqAE+6MMYYY4wxxhhjjNWA/wPSQhyZEdwF3wAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -2788,7 +3447,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2798,7 +3457,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAWpCAYAAAAFtVMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeViU9f7/8dcM6yDihgsqhB5R4bjvaJqVW578anXStHKpY+ekFIZm2nG30rIUt/K0qFlup+V4bDWz1ETT1DRLJLUMjztupCAMzPz+8McUgTrAMHPDPB/XxSVzz33fn/fczsyL98y9mOx2u10AAAAAAMDjzJ4uAAAAAAAAXEWTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABiEr6cLcDebzabjx4+rYsWKMplMni4HAADZ7Xb9+uuvql27tsxmPj93BfIeAGAkRcl6r2vSjx8/rvDwcE+XAQBAAUePHlXdunU9XUa5QN4DAIzImaz3uia9YsWKkq5unJCQEA9Xg8JYrVZ99tln6tGjh/z8/DxdDlDm8ZoyvvT0dIWHhzsyCiVH3juH9wfcCM8R3AjPEecUJeu9rknP2+UtJCSE0DYoq9WqoKAghYSE8EIHXIDXVNnBbtmuQ947h/cH3AjPEdwIz5GicSbrOfANAAAAAACDoEkHAAAAAMAgaNIBAAAAADAIrzsmHYD3stvtysnJUW5urqdLcSur1SpfX19duXLF6x67Ufj4+MjX15djzgGglHlr1nsSf2f8xs/PTz4+PiVeD006AK+QnZ2tEydOKCMjw9OluJ3dbletWrV09OhRmkQPCgoKUlhYmPz9/T1dCgCUS96c9Z7E3xm/MZlMqlu3roKDg0u0Hpp0AOWezWbTzz//LB8fH9WuXVv+/v5eFSI2m02XLl1ScHCwzGaOcnI3u92u7OxsnTlzRj///LOioqL4fwAAF/P2rPck/s64ym6368yZM/rf//6nqKioEn2jTpMOoNzLzs6WzWZTeHi4goKCPF2O29lsNmVnZyswMNCrw9OTLBaL/Pz89Msvvzj+LwAAruPtWe9J/J3xm+rVq+vIkSOyWq0latK9eysC8CreHhzwLJ5/AFD6eK+FJ7lq7w2exQAAAAAAGARNOgDgurp27apRo0YZZj0AAMD1yHvj4Jh0AIBLbdy4UbfeeqvOnz+vypUrO6a///778vPz81xhAADAZfLy/uzZs/kOMyDvS44mHQDgFlWrVvV0CQAAoJSR9yXH7u4AYFBdu3ZVXFyc4uLiVKlSJYWGhmrixImy2+2SpPPnz2vw4MGqUqWKgoKCdMcdd+jgwYOO5ZcuXarKlStrzZo1at26tYKCgtSzZ08dPXrUMc/QoUPVr1+/fOOOGjVKXbt2vWZdb731ltq0aaOKFSuqVq1aGjRokE6fPi1JOnLkiG699VZJUpUqVWQymTR06FDH4/n97m/O1r9u3TpFR0crODhYvXr10okTJ4qzOQEAMCRX5n1UVJQCAwPdmvfVqlVTlSpVNGzYMMfjIe9LhiYdAAzszTfflK+vr3bs2KG5c+dq9uzZev311yVdDdydO3dq7dq12rZtm+x2u3r37i2r1epYPiMjQzNmzNArr7yir776ShcuXNB9991XopqsVqumT5+uvXv3as2aNTpy5IijEQ8PD9d7770nSUpJSdGJEyc0d+7cQtfjbP0vvvii3nrrLW3evFmpqakaM2ZMieoHAMBoXJH3zz77rJYtW6akpCS35n1ycrIOHDigxMTEQtdD3hcdu7sDgIGFh4drzpw5MplMatSokfbt26c5c+aoa9euWrt2rZKSktSxY0dJ0vLlyxUeHq41a9bo3nvvlXQ1YOfNm6fo6GiFhITozTffVHR0tHbs2KF27doVq6aHHnrI8Xv9+vU1b948tW3bVpcuXVJwcLBjN7caNWrkOyb99w4ePOh0/YsWLdKf/vQnSVJcXJymTZtWrLoBADAqV+T9ggUL1L59e0lye96bzWaFhIQUWAd5Xzx8kw4ABtahQ4d819yMjY3VwYMHtX//fvn6+jrCWLq6u1mjRo2UnJzsmObr66u2bds6bjdu3FiVK1fON09R7dq1S3369FFERIQqVqyoW265RZKUmprq9DqSk5Odqj8oKMgR2JIUFhbm2NUOAIDygrwn73+PJh0AvJjZbHYc85bn97uf/dHly5fVs2dPhYSEaPny5frmm2/0n//8R5KUnZ3t8vr+eHZYk8lUoF4AAHB95H3ZQpMOAAa2ffv2fLe//vprRUVFKSYmRjk5OfnuP3v2rFJSUhQTE+OYlpOTo507dzpup6Sk6MKFC4qOjpYkVa9evcCJWfbs2XPNeg4cOKCzZ89q5syZ6ty5sxo3blzgk25/f39JUm5u7jXXEx0d7VT9AAB4A/Iev0eTDgAGlpqaqoSEBKWkpGjlypWaP3++4uPjFRUVpb59+2r48OHasmWL9u7dqwceeEB16tRR3759Hcv7+fkpPj5eO3fu1K5duzR06FB16NDBcXzabbfdpp07d2rZsmU6ePCgJk+erO+///6a9URERMjf31/z58/XTz/9pLVr12r69On55rnppptkMpn04Ycf6syZM7p06VKB9ThbPwAA3sAVef/YY49p+/btHsn7tLQ08t6FaNIBwMAGDx6szMxMtWvXTiNHjlR8fLweeeQRSdKSJUvUunVr3XnnnYqNjZXdbtfHH3+cb5exoKAgPfnkkxo+fLg6d+6s4OBgrV692nF/z549NXHiRI0dO1Zt27bVr7/+qsGDB1+znurVq2vp0qV65513FBMTo5kzZ+rFF1/MN0+dOnU0depUjRs3TjVr1lRcXFyh63KmfgAAvIEr8v6pp57SoEGD1KlTJ7fm/dNPP62GDRvqscceK3Rd5H3RmexetrN/enq6KlWqpIsXLxZ6BkJ4ntVq1ccff6zevXvz4oVLXLlyRT///LPq1aunwMBAT5fjtK5du6pFixbXvKTJjSxdulSjRo3SuXPnlJ6erpCQEJnNfDbrKdd7HpJNrsc2dQ6ZixspK8+Rspr1kuvy/sKFCy6ty1k2m42/M/4/V2W9d29FAAAAAAAMhCYdAAAAAACD8PV0AQCAwm3cuLFEyw8dOlRDhw6VzWZzTUEAAMDlXJX3KD/4Jh0AAAAAAIOgSQcAAAAAwCBo0gEAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAILgEGwCvlpqaqrS0NLeNFxoaqoiICLeN56zIyEiNGjVKo0aNuuY82dnZiomJ0bJly9SxY0f3FWcAJpNJ//nPf9SvX79C79+/f7969OihlJQUVahQwb3FAQCui6y/iqy/PiNlPU06AK+Vmpqqxo2jlZmZ4bYxLZYgHTiQbMjwvpFFixapXr16ZTq0jxw5onr16unbb79VixYtXLbemJgYdejQQbNnz9bEiRNdtl4AQMmQ9UVD1l+bO7OeJh2A10pLS1NmZobaPzRZIWGRpT5e+okj2r54qtLS0spccNvtdi1YsEDTpk0r8Xpyc3Pl61v+4mfYsGEaPny4xo8fXy4fHwCURWS988j6G3NX1nNMOgCvFxIWqaoRjUr9pzh/HHTt2lVxcXGKi4tTpUqVFBoaqokTJ8putzvmOX/+vAYPHqwqVaooKChId9xxhw4ePJhvPWvXrlXTpk0VEBCgyMhIvfTSS0WqY9euXTp8+LD+8pe/OKYdOXJEJpNJq1atUseOHRUYGKgmTZpo06ZNjnk2btwok8mkTz75RK1bt1ZAQIC2bNkim82mGTNmqF69erJYLGrevLnefffdAsutW7dOLVu2lMVi0W233abTp0/rk08+UXR0tEJCQjRo0CBlZPz27cinn36qm2++WZUrV1a1atV055136vDhw47769WrJ0lq2bKlTCaTunbt6rhv8eLF+vOf/6yAgACFhYUpLi4u3zZIS0vTXXfdpaCgIEVFRWnt2rX57u/evbvOnTuX7/EDAIzBG7L+vffec+SYu7O+SpUqZL0L0aQDgMG9+eab8vX11Y4dOzR37lzNnj1br7/+uuP+oUOHaufOnVq7dq22bdsmu92u3r17y2q1SroausOGDdOAAQO0b98+TZkyRRMnTtTSpUudruGrr75Sw4YNVbFixQL3Pfnkkxo9erS+/fZbxcbGqk+fPjp79my+ecaNG6eZM2cqOTlZzZo104wZM7Rs2TItWrRIP/zwg5544gk98MADBUJvypQpWrBggbZu3aqjR4+qf//+SkxM1IoVK/TRRx/ps88+0/z58x3zX758WQkJCdq5c6c2bNggs9msu+66SzabTZK0Y8cOSdLnn3+uEydO6P3335ckvfLKKxo5cqQeeeQR7du3T2vXrlWDBg3y1TJ16lT1799f3333nXr37q37779f586dc9zv7++vFi1a6KuvvnJ6uwIAILkm6/v376/77rvPY1n/9NNPk/UuUv72QQCAciY8PFxz5syRyWRSo0aNtG/fPs2ZM0fDhw/XwYMHtXbtWiUlJTmOH1u+fLnCw8O1Zs0a3XvvvZozZ45uueUWTZgwQWazWQ0bNtT+/fs1a9YsDR061KkafvnlF9WuXbvQ++Li4nTPPfdIuhqAn376qd544w2NHTvWMc+0adPUvXt3SVJWVpaee+45ff7554qNjZUk1a9fX1u2bNG//vUv3XLLLY7lnnnmGXXq1EmS9PDDD2v8+PE6fPiw6tevL0n661//qi+//FJPPfWUJDnqyLN48WJVr15d+/fvV5MmTVS9enVJUrVq1VSrVq1844wePVrx8fGOaW3bts23rqFDh2rgwIGSpOeee07z5s3Tjh071KtXL8c8tWvX1i+//HL9jQkAwB+UNOtnz56t22+/3XGstCeyfsqUKWS9i/BNOgAYXIcOHWQymRy3Y2NjdfDgQeXm5io5OVm+vr5q37694/5q1aqpUaNGSk5OliQdOHAg3/2S1KlTJ8c6nJGZmanAwMBC78sLX0ny9fVVmzZtHGPnadOmjeP3Q4cOKSMjQ927d1dwcLDjZ9myZfl2V5OkZs2aOX6vWbOmgoKCHKGdN+306dOO2wcPHtTAgQNVv359hYSEKDIyUtLVEwddy+nTp3X8+HHdfvvt19kC+WupUKGCQkJC8o0tSRaLJd8ueQAAOKOkWZ+cnOxodPOQ9b8pa1nv8SZ94cKFioyMVGBgoNq3b+/YPeFaEhMT1ahRI1ksFoWHh+uJJ57QlStX3FQtAHin0NBQnT9/vtjL//5SJZcuXZIkffTRR9qzZ4/jZ//+/fmOVZMkPz8/x+8mkynf7bxpebu3SVKfPn107tw5vfbaa9q+fbu2b98u6eolZa7FYrE49RhuNLYknTt3zvEJPvIj7wHA2Mh642S9R5v01atXKyEhQZMnT9bu3bvVvHlz9ezZs8CnFXlWrFihcePGafLkyUpOTtYbb7yh1atX6+mnn3Zz5QDgPnnhk+frr79WVFSUfHx8FB0drZycnHzznD17VikpKYqJiZEkNW7cuMA6kpKS1LBhQ/n4+DhVQ8uWLXXgwIF8J7H5fT15cnJytGvXLkVHR19zXTExMQoICFBqaqoaNGiQ7yc8PNypegqT97gnTJig22+/XdHR0QX+2PD395ekfN8qVKxYUZGRkdqwYUOxx87z/fffq2XLliVeT3lD3gPA9ZU066Ojo5WUlJRvHWR92c16jx6TPnv2bA0fPlzDhg2TdPW6fB999JEWL16scePGFZh/69at6tSpkwYNGiRJioyM1MCBAws8qQGgPElNTVVCQoL+/ve/a/fu3Zo/f77jjK1RUVHq27evhg8frn/961+qWLGixo0bpzp16qhv376SpISEBLVv317PPPOM7rvvPm3btk0LFizQyy+/7HQNt956qy5duqQffvhBTZo0yXffwoULFRUVpejoaM2ZM0fnz5/XQw89dM11VaxYUWPGjNETTzwhm82mm2++WRcvXlRSUpJCQkI0ZMiQYmwlqUqVKqpWrZpeffVVhYWFKTU1tUCW1KhRQxaLRZ9++qnq1q2rwMBAVapUSVOmTNE//vEP1ahRQ3fccYd+/fVXJSUl6bHHHnN6/CNHjujYsWPq1q1bseovz8h7ALi+kmb96NGj1bZtW02fPl0DBgwg68t41nusSc/OztauXbs0fvx4xzSz2axu3bpp27ZthS7TsWNHvf3229qxY4fatWunn376SR9//LEefPDBa46TlZWlrKwsx+309HRJktVqdZwNEcaS9//C/w9cxWq1ym63y2az5dtlKe/39ONHpIIfGrtc+okjjnH/uOvU9Tz44IPKyMhQu3bt5OPjo8cff1x/+9vfHOt44403NGrUKN15553Kzs5W586d9eGHH8rHx0c2m00tW7bUkiVL9Pzzz+uZZ55RWFiYpk6dqsGDB+erI28bFaZKlSrq16+f3n77bT333HOOxyFdPbHKzJkztWfPHjVo0EBr1qxR1apV8z3OPz7mqVOnKjQ0VDNmzNBPP/2kypUrq2XLlho/fvw1l/vjv3k1/37aihUrNGrUKDVp0kSNGjVSYmKibrvtNsd6zGazEhMT9cwzz2jSpEnq3LmzvvjiC8c2njt3rsaMGaPQ0FDdc889BZ4vf9w+v5+2YsUKde/eXeHh4YVuR5vNJrvdLqvVWuBbjfL8fkfeGxuZixspK88Rb8/6Fi1aaNWqVZoyZYqmT5/u1qzPy+I/rpusL37Wm+yF7c/gBsePH1edOnW0devWfCciGDt2rDZt2nTNT8vnzZunMWPGyG63KycnR//4xz/0yiuvXHOcKVOmaOrUqQWmr1ixQkFBQSV/IAAMz9fXV7Vq1VJ4eLhjFyhJOnr0qNq1b68rmZluqyXQYtGO7dud3tXrzjvvVNOmTTVjxoxSruzGvv/+e919993avXu3goODlZqaqubNm2vz5s1q2rSpp8vzqOzsbLVu3VqvvfaaOnTocM15jh49qpMnTyonJyfffRkZGRo0aJAuXryokJAQd5TsNuQ9AHcg612DrL82d2Z9mboE28aNG/Xcc8/p5ZdfVvv27XXo0CHFx8dr+vTpjssN/NH48eOVkJDguJ2enq7w8HD16NGj3P0hVF5YrVatX79e3bt3L3DyBqA4rly5oqNHjyo4ODjfWUv//Oc/K3n/fqWlpbmtltDQUEVERDg9v6+vr/z9/Uv0fmW32/Xrr7+qYsWK+c4cW1QdO3bUzJkzdfbsWdWuXVvBwcGSfjv7qTc7dOiQnn76afXo0eOa81y5ckUWi0VdunQpcPbcvG99cRV57z5kLm6krDxHvD3rXaU4We+qvzOMzp1Z77EmPTQ0VD4+Pjp16lS+6adOncp3Pbvfmzhxoh588EH97W9/kyQ1bdpUly9f1iOPPKJ//vOfMpsLngcvICBAAQEBBab7+fkZ+o0G/B/BdXJzc2UymWQ2mwu8T0RGRjou3WFUebUXV97uWCVdj6R8x5/lrauw7eptGjZsqIYNG153HrPZ7Dhr7R/f28rzex15XzawnXAjRn+OeHvWu1JRs96Vf2cYmTuz3mNNur+/v1q3bq0NGzaoX79+kq7+B2/YsEFxcXGFLpORkVHgPz5vX38P7bUPAKVq48aNni7hmiIjI3nvxQ2R9wBwfWQ9/siju7snJCRoyJAhatOmjdq1a6fExERdvnzZcfbXwYMHq06dOo7jM/r06aPZs2erZcuWjt3fJk6cqD59+jh9aQEAAOBe5D0AAM7zaJM+YMAAnTlzRpMmTdLJkyfVokULffrpp6pZs6akq5ci+P0n6RMmTJDJZNKECRN07NgxVa9eXX369NGzzz7rqYcAAABugLwHAMB5Hj9xXFxc3DV3d/vjrh++vr6aPHmyJk+e7IbKAACAq5D3AAA4p/we2Q8AAAAAQBlDkw4AAAAAgEHQpAMAAAAAYBAePyYdADwpNTVVaWlpbhsvNDRUERERbhvPGZGRkRo1apRGjRrl6VIAAHA5sp6sL2to0gF4rdTUVEU3bqSMzCtuGzPIEqjkAymGC28AAMojsh5lEU06AK+VlpamjMwrevuRFooOCy718ZJPXNIDr+5RWloawQ0AgBuQ9SiLaNIBeL3osGC1iqzk6TIK1bVrVzVp0kSS9NZbb8nPz0+PPvqopk2bJpPJpPPnzys+Pl4ffPCBsrKydMstt2jevHmKiopyrOO9997TpEmT9NNPPyksLEyPPfaYRo8e7amHBACA23lL1h86dIisLwc4cRwAGNybb74pX19f7dixQ3PnztXs2bP1+uuvS5KGDh2qnTt3au3atdq2bZvsdrt69+4tq9UqSdq1a5fuu+8+3X333dq7d6+mTJmiiRMnaunSpR58RAAA4PdKmvX9+/fXfffdp3379pH15QDfpAOAwYWHh2vOnDkymUxq1KiR9u3bpzlz5qhr165au3atkpKS1LFjR0nS8uXLFR4erjVr1ujee+/V7Nmzddttt+nJJ59USEiIGjdurP3792vWrFkaOnSoZx8YAACQVPKsv/322zVx4kRJUsOGDcn6Mo5v0gHA4Dp06CCTyeS4HRsbq4MHD2r//v3y9fVV+/btHfdVq1ZNjRo1UnJysiQpOTlZnTp1yre+Tp066eDBg8rNzXXPAwAAANdF1uP3aNIBAAAAADAImnQAMLjt27fnu/31118rKipKMTExysnJyXf/2bNnlZKSopiYGElSdHS0kpKS8i2flJSkhg0bysfHp/SLBwAAN0TW4/do0gHA4FJTU5WQkKCUlBStXLlS8+fPV3x8vKKiotS3b18NHz5cW7Zs0d69e/XAAw+oTp066tu3ryRp9OjR+uKLLzRr1iz9+OOPevPNN7VgwQKNGTPGw48KAADkKWnWb9iwQdOnTyfrywlOHAfA6yWfuGTocQYPHqzMzEy1a9dOPj4+io+P1yOPPCJJWrJkieLj43XnnXcqOztbXbp00ccffyw/Pz9JUqtWrbRq1SpNmjRJs2bNUlhYmKZNm8aJZAAAXqW8Z/2///1vTZo0SdOnTyfrywGadABeKzQ0VEGWQD3w6h63jRlkCVRoaGiRlvHz81NiYqJeeeWVAvdVqVJFy5Ytu+7y99xzj7p3766QkBCZzQV3oDpy5EiR6gEAoKzwpqy/5557rnk/WV+20KQD8FoRERFKPpCitLQ0t40ZGhqqiIgIt40HAIA3I+tRFtGkA/BqERERBCkAAOUYWY+yhiYdAAxs48aNni4BAACUIrIef8TZ3QEAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgkuwAfBqqampSktLc9t4oaGhXKsVAAA3IutR1tCkA/BaqampahzdWJkZmW4b0xJk0YHkA06Hd9euXdWiRQslJiaWbmFOMlo9AABcD1lfdEarxxvRpAPwWmlpacrMyFSXsV1UKbxSqY938ehFbX5hs9LS0tz6CXt2drbbxgIAwEi8Kev9/f3dNh5KF8ekA/B6lcIrKTQqtNR/ivrHwdChQ7Vp0ybNnTtXJpNJJpNJhw8f1sMPP6x69erJYrGoUaNGmjt3boHl+vXrp2effVa1a9dWdHS0JGnr1q1q0aKFAgMD1aZNG61Zs0Ymk0l79uxxLPv999/rjjvuUHBwsGrWrKkHH3zQsYtgYfUcOXKkRNseAAB3KO9Z36hRI0lkfXnBN+kAYFBz587Vjz/+qCZNmmjatGmSpCpVqqhu3bp65513VK1aNW3dulWPPPKIwsLC1L9/f8eyGzZsUEhIiNavXy+bzab09HT17dtXvXv31ooVK/TLL79o1KhR+ca7cOGCbrvtNv3tb3/TnDlzlJmZqaeeekr9+/fXF198UWg91atXd9v2AACgvHFV1ktSenq6+vTpQ9aXAzTpAGBQlSpVkr+/v4KCglSrVi3H9KlTpzp+r1evnrZt26Z///vf+YK7QoUKev311+Xv7y+bzabExESZTCa99tprCgwMVExMjI4dO6bhw4c7llmwYIFatmyp5557zjFt8eLFCg8P148//qiGDRsWWg8AACgeV2W9JC1atIisLydo0gGgjFm4cKEWL16s1NRUZWZmKjs7Wy1atMg3T9OmTfMdm3bo0CE1a9ZMgYGBjmnt2rXLt8zevXv15ZdfKjg4uMCYhw8fVsOGDV37QAAAQKGKk/UpKSlkfTlBkw4AZciqVas0ZswYvfTSS4qNjVXFihU1a9Ysbd++Pd98FSpUKPK6L126pD59+uj5558vcF9YWFixawYAAM4j60GTDgAG5u/vr9zcXMftpKQkdezYUSNGjHBMO3z48A3X06BBA73zzjvKyspSQECAJOmbb77JN0+rVq303nvvKTIyUr6+hcfDH+sBAAAl46qsb9Sokd5++22yvhzg7O4AYGCRkZHavn27jhw5orS0NEVFRWnnzp1at26dfvzxR02cOLFAABfmr3/9q2w2mx555BElJydr3bp1evHFFyVJJpNJkjRy5EidO3dOAwcO1DfffKPDhw9r3bp1GjZsmCOs/1iPzWYrvQcPAIAXcFXWDxo0iKwvJ/gmHYDXu3j0omHHGTNmjIYMGaKYmBhlZmbqwIED+vbbbzVgwACZTCYNHDhQI0aM0CeffHLd9YSEhOi///2vRo4cqRYtWqhp06aaNGmSBg0a5Dh2rXbt2kpKStJTTz2lHj16KCsrSzfddJN69eols9lcaD0///yzIiMji/y4AABwJ2/J+g8++ECPPvooWV/Gmex2u93TRbhTenq6KlWqpIsXLyokJMTT5aAQVqtVH3/8sXr37i0/Pz9Pl4Ny4MqVK/r5559Vr169fCdTSU1NVePoxsrMyHRbLZYgiw4kH1BERITbxsy7BFtISIgjgCVp+fLlGjZsmC5evCiLxeK2erzVtZ6HEtlUGtimziFzcSNl5Tni7Vl/Le7I+mv9neGNXJX1fJMOwGtFREToQPIBpaWluW3M0NBQj4X2smXL1KBBA9WpU0d79+51XBeVBh0AUF55Y9bXr1+frC/jaNIBeLWIiAhDfNLtDqdOndKUKVN08uRJhYWF6d5779Wzzz7r6bIAAChV3pT1J0+e1KRJk8j6Mo4mHQC8xJNPPqmnnnrK02UAAIBSMnbsWI0dO9bTZaCEvPugAQAAAAAADIQmHQAAAAAAg6BJB+A1uM4nPInnHwCUPt5r4UmuunAax6QDKPf8/f1lNpt1/PhxVa9eXf7+/jKZTJ4uy21sNpuys7N15coVr780iifY7XZlZ2frzJkzMpvN8vf393RJAFDueHvWexJ/Z1xlt9t15swZmUymEl+ukCYdQLlnNptVr149nThxQsePH/d0OW5nt9uVmZkpi8XCHyweFBQUpIiICK/+AwYASou3Z70n8XfGb0wmk+rWrSsfH58SrYcmHYBX8Pf3V0REhHJycpSbm+vpctzKarVq8+bN6tKlS4k/2UXx+Pj4yNfX1+v/eAGA0uTNWe9J/J3xGz8/vxI36BJNOgAvkrf7kbcFiI+Pj3JychQYGOh1jx0A4F28Nes9ib8zXI997gAAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACD8HiTvnDhQkVGRiowMFDt27fXjh07rjv/hQsXNHLkSIWFhSkgIEANGzbUxx9/7KZqAQBAcZD3AAA4x9eTg69evVoJCQlatGiR2rdvr8TERPXs2VMpKSmqUaNGgfmzs7PVvXt31ahRQ++++67q1KmjX375RZUrV3Z/8QAAwCnkPQAAzvNokz579mwNHz5cw4YNkyQtWrRIH330kRYvXqxx48YVmH/x4sU6d+6ctm7dKj8/P0lSZGSkO0sGAABFRN4DAOA8jzXp2dnZ2rVrl8aPH++YZjab1a1bN23btq3QZdauXavY2FiNHDlS//3vf1W9enUNGjRITz31lHx8fApdJisrS1lZWY7b6enpkiSr1Sqr1erCRwRXyft/4f8HcA1eU8ZXnv9vyHtj4/0BN8JzBDfCc8Q5Rdk+HmvS09LSlJubq5o1a+abXrNmTR04cKDQZX766Sd98cUXuv/++/Xxxx/r0KFDGjFihKxWqyZPnlzoMjNmzNDUqVMLTP/ss88UFBRU8geCUrN+/XpPlwCUK7ymjCsjI8PTJZQa8r5s4P0BN8JzBDfCc+T6ipL1Ht3dvahsNptq1KihV199VT4+PmrdurWOHTumWbNmXTO0x48fr4SEBMft9PR0hYeHq0ePHgoJCXFX6SgCq9Wq9evXq3v37o7dHAEUH68p48v71hdXkffuw/sDboTnCG6E54hzipL1HmvSQ0ND5ePjo1OnTuWbfurUKdWqVavQZcLCwuTn55dvV7fo6GidPHlS2dnZ8vf3L7BMQECAAgICCkz38/PjSWRw/B8BrsVryrjK8/8LeV82sJ1wIzxHcCM8R66vKNvGY5dg8/f3V+vWrbVhwwbHNJvNpg0bNig2NrbQZTp16qRDhw7JZrM5pv34448KCwsrNLABAIBnkfcAABSNR6+TnpCQoNdee01vvvmmkpOT9eijj+ry5cuOs78OHjw434lmHn30UZ07d07x8fH68ccf9dFHH+m5557TyJEjPfUQAADADZD3AAA4z6PHpA8YMEBnzpzRpEmTdPLkSbVo0UKffvqp4+QyqampMpt/+xwhPDxc69at0xNPPKFmzZqpTp06io+P11NPPeWphwAAAG6AvAcAwHkeP3FcXFyc4uLiCr1v48aNBabFxsbq66+/LuWqAACAK5H3AAA4x6O7uwMAAAAAgN/QpAMAAAAAYBDFatK//PJLV9cBAAAMhrwHAMD9itWk9+rVS3/605/0zDPP6OjRo66uCQAAGAB5DwCA+xWrST927Jji4uL07rvvqn79+urZs6f+/e9/Kzs729X1AQAADyHvAQBwv2I16aGhoXriiSe0Z88ebd++XQ0bNtSIESNUu3ZtPf7449q7d6+r6wQAAG5G3gMA4H4lPnFcq1atNH78eMXFxenSpUtavHixWrdurc6dO+uHH35wRY0AAMDDyHsAANyj2E261WrVu+++q969e+umm27SunXrtGDBAp06dUqHDh3STTfdpHvvvdeVtQIAADcj7wEAcC/f4iz02GOPaeXKlbLb7XrwwQf1wgsvqEmTJo77K1SooBdffFG1a9d2WaEAAMC9yHsAANyvWE36/v37NX/+fN19990KCAgodJ7Q0FAu3QIAQBlG3gMA4H7F2t198uTJuvfeewsEdk5OjjZv3ixJ8vX11S233FLyCgEAgEeQ9wAAuF+xmvRbb71V586dKzD94sWLuvXWW0tcFAAA8DzyHgAA9ytWk26322UymQpMP3v2rCpUqFDiogAAgOeR9wAAuF+Rjkm/++67JUkmk0lDhw7Nt/tbbm6uvvvuO3Xs2NG1FQIAALci7wEA8JwiNemVKlWSdPWT9YoVK8pisTju8/f3V4cOHTR8+HDXVggAANyKvAcAwHOK1KQvWbJEkhQZGakxY8awqxsAAOUQeQ8AgOcU6xJskydPdnUdAADAYMh7AADcz+kmvVWrVtqwYYOqVKmili1bFnoimTy7d+92SXEAAMC9yHsAADzL6Sa9b9++jhPH9OvXr7TqAQAAHkTeAwDgWU436b/f5Y3d3wAAKJ/IewAAPKtYx6TDu6SmpiotLc1t49lsNknS3r17ZTab3TJmVlZWvksMlUehoaGKiIjwdBlOcfdzzhPK0v8HAAAA3MfpJr1KlSrXPS7t986dO1fsgmAsqampim7cSBmZV9w2psVi0cqVK9WlSxdlZma6ZUyzSbLZ3TKUx1iCLDqQfMDwjWFqaqoaN45WZmaGp0spVRZLkA4cSDb8/we8D3kPAIBnOd2kJyYmlmIZMKq0tDRlZF7R24+0UHRYsFvGtJn9dUzS5nGxMtuyS3283T+d0fC3UtRycEvVbVu31MfzhItHL2rzC5uVlpZm+KYwLS1NmZkZav/QZIWERXq6nFKRfuKIti+eWib+P+B9yHsAADzL6SZ9yJAhpVkHDC46LFitIiu5ZSyr/HRMUvOIEPnJWurjXc64LEkKrhWs0KjQUh8PzgkJi1TViEaeLgPwOuQ9AACe5XSTnp6erpCQEMfv15M3HwAAKFvIewAAPKtIx6SfOHFCNWrUUOXKlQs9Xs1ut8tkMik3N9elRQIAAPcg7wEA8Cynm/QvvvhCVatWlSR9+eWXpVYQAADwHPIeAADPcrpJv+WWWwr9HQAAlB/kPQAAnlXs66SfP39eb7zxhpKTkyVJMTExGjZsmOPTdwAAUPaR9wAAuFexmvTNmzerT58+qlSpktq0aSNJmjdvnqZNm6YPPvhAXbp0cWmRRpaamqq0tDRPl1Fq8v4oA+B67np92Ww2SdLevXtlNpvdMqYkZWVlKSAgwG3jeUJoaGi5voweeQ8AgPsVq0kfOXKkBgwYoFdeeUU+Pj6SpNzcXI0YMUIjR47Uvn37XFqkUaWmpqpx42hlZmZ4upRSZtKJi1ckuecSbEB5Z83KliQ98MADbhnPYrFo5cqV6tKlizIzM90ypiSZTZLN7rbhPMISZNGB5APltlEn7wEAcL9iNemHDh3Su+++6whsSfLx8VFCQoKWLVvmsuKMLi0tTZmZGWr/0GSFhEV6upxScebnA9qz4nldyMjxdClAuZGTc/X1NP3uhurdtEapj2cz++uYpM3jYmW2ZZf6eJK0+6czGv5WiloObqm6beu6ZUx3u3j0oja/sFlpaWnltkkn7wEAcL9iNemtWrVScnKyGjVqlG96cnKymjdv7pLCypKQsEhVjWh04xnLoMzL5X0vAcBz6oUGqVVk6e+hYpWfjklqHhEiP1lLfTxJupxxWZIUXCtYoVGhbhkTrkfeAwDgfk436d99953j98cff1zx8fE6dOiQOnToIEn6+uuvtXDhQs2cOdP1VQIAALcg7wEA8Cynm/QWLVrIZDLJbv/tAMOxY8cWmG/QoEEaMGCAa6oDAABuRd4DAOBZTjfpP//8c2nWAQAADIC8BwDAs5xu0m+66abSrAMAABgAeQ8AgGcV68Rxefbv36/U1FRlZ+c/W/D//d//lagoAABgHOQ9AADuU6wm/aefftJdd92lffv25TtuzWQySbp6DVUAAFC2kfcAALifuTgLxcfHq169ejp9+rSCgoL0ww8/aPPmzWrTpo02btzo4hIBAIAnkPcAALhfsb5J37Ztm7744guFhobKbDbLbDbr5ptv1owZM/T444/r22+/dXWdAADAzch7AADcr1jfpOfm5qpixYqSpNDQUB0/flzS1ZPNpKSkuK46AADgMeQ9AADuV6xv0ps0aaK9e/eqXr16at++vV544QX5+/vr1VdfVf369V1dIwAA8ADyHgAA9ytWkz5hwgRdvnxZkjRt2jTdeeed6ty5s6pVq6bVq1e7tEAAAOAZ5D0AAO5XrCa9Z8+ejt8bNGigAwcO6Ny5c6pSpYrjjK8AAKBsI+8BAHC/El0nXZKOHj0qSQoPDy9xMQAAwJjIewAA3KNYJ47LycnRxIkTValSJUVGRioyMlKVKlXShAkTZLVaXV0jAADwAPIeAAD3K9Y36Y899pjef/99vfDCC4qNjZV09TItU6ZM0dmzZ/XKK6+4tEgAAOB+5D0AAO5XrCZ9xYoVWrVqle644w7HtGbNmik8PFwDBw4ktAEAKAfIewAA3K9Yu7sHBAQoMjKywPR69erJ39+/pDUBAAADIO8BAHC/YjXpcXFxmj59urKyshzTsrKy9OyzzyouLs5lxQEAAM8h7wEAcD+nd3e/++67893+/PPPVbduXTVv3lyStHfvXmVnZ+v22293bYUAAMBtyHsAADzL6Sa9UqVK+W7fc889+W5zSRYAAMo+8h4AAM9yuklfsmRJqRWxcOFCzZo1SydPnlTz5s01f/58tWvX7obLrVq1SgMHDlTfvn21Zs2aUqsPAABvUVp5T9YDAOCcYh2TnufMmTPasmWLtmzZojNnzhRrHatXr1ZCQoImT56s3bt3q3nz5urZs6dOnz593eWOHDmiMWPGqHPnzsUaFwAAOKekeU/WAwDgvGI16ZcvX9ZDDz2ksLAwdenSRV26dFHt2rX18MMPKyMjo0jrmj17toYPH65hw4YpJiZGixYtUlBQkBYvXnzNZXJzc3X//fdr6tSpql+/fnEeAgAAuAFX5T1ZDwCA84p1nfSEhARt2rRJH3zwgTp16iRJ2rJlix5//HGNHj3a6eumZmdna9euXRo/frxjmtlsVrdu3bRt27ZrLjdt2jTVqFFDDz/8sL766qvrjpGVlZXvrLTp6emSJKvVKqvV6lSd12Kz2WSxWORnlnxNthKty6j8fUyyWCySb4Cs8nPLmHnjuGs8u4+/LBaL/H385Wsv1kvC8PxMfrJYLLLZbCV+3pc2Xleu5+7XlMTrqqiM+rp0Rd67I+ul0s378ixv27CNyqf//e9/Onv2bInWYbNdzeJvv/1WZnOJdsJVVlaWAgICSrQOV6tWrZrq1q3r6TLKNN5HnFOU7WOy2+32og4QGhqqd999V127ds03/csvv1T//v2d3hXu+PHjqlOnjrZu3arY2FjH9LFjx2rTpk3avn17gWW2bNmi++67T3v27FFoaKiGDh2qCxcuXPM4tSlTpmjq1KkFpq9YsUJBQUFO1QkAQGnKyMjQoEGDdPHiRYWEhHi6HAdX5L07sl4i7wEAxlaUrC/W1xsZGRmqWbNmgek1atQo8u7uRfHrr7/qwQcf1GuvvabQ0FCnlhk/frwSEhIct9PT0xUeHq4ePXqU+A+hvXv3qkuXLrp1zMuqEh5VonUZ1YmU77Tt5dF6bVgz9W8b5pYxrfLT+ir3q/v55fJT6X8ity3lhHrN/U4dR3VU/S7lc5fKs4fP6pMnP9HmzZsdl1EyKl5Xrufu15TE66qo8r71NRpP5H1xsl4q3byXXPONpCu56ts/q9Wq9evXq3v37vLzc9/eNih9eXn62rBmalSzQrHXYzP760TTfyhs3yKZbdnFr+dImh5bdVDNBjZTnVZ1ir0eV0o/lq6kxKQy8feRkfE+4pyiZH2xmvTY2FhNnjxZy5YtU2BgoCQpMzNTU6dOzfcp+Y2EhobKx8dHp06dyjf91KlTqlWrVoH5Dx8+rCNHjqhPnz6OaXm74Pj6+iolJUV/+tOf8i0TEBBQ6G41fn5+JX4Smc1mZWZmymqTcuwl2/3HqLJz7crMzJRystz2x30eP1ndMqYpN1uZmZnKzs1Wjimn1MfzBKvdqszMTJnNZsO/efK6Kj3uek1JvK6KyqivS1fkvTuyXirdvE9NTdWf/9xEmZml90VEUVksQTpwIFkREREuWZ8rthOMJS9Po6v7qVWEpdjrscpPJyS1rBsoP/kUez2Zl3yUmZkp/1B/VWpQ6cYLuEFZ+vuoLOB95PqKsm2K1aQnJiaqV69eqlu3ruNTp7179yowMFDr1q1zej3+/v5q3bq1NmzYoH79+km6GsQbNmxQXFxcgfkbN26sffv25Zs2YcIE/frrr5o7dy7XbgUAwIVckfflIevT0tKUmZmh9g9NVkhYpNvH/6P0E0e0ffFUpaWluaxJB+CdUlNTlZaWVqJ15H2Qunfv3nJ53oLQ0FC3v9cWq0lv2rSpDh48qOXLl+vAgQOSpIEDB+r++++/ejKkIkhISNCQIUPUpk0btWvXTomJibp8+bKGDRsmSRo8eLDq1KmjGTNmKDAwUE2aNMm3fOXKlSWpwHQAAFAyrsr78pL1IWGRqhrRyKM1AICrpKamKrpxI2VkXinReiwWi1auXKkuXbpc3VOwBMwmyVbkM6aVLkuQRQeSD7i1US9yk261WtW4cWN9+OGHGj58eIkLGDBggM6cOaNJkybp5MmTatGihT799FPHMXCpqakl/kQGAAAUjSvznqwHAONJS0tTRuYVvf1IC0WHBRd7PTazv45J2jwutkTnLdj90xkNfytFLQe3VN22xjjj/sWjF7X5hc1u33OpyE26n5+frlwp2actfxQXF1foLm+StHHjxusuu3TpUpfWAgAAXJ/3ZD0AGFN0WLBaRRb/PAFW+emYpOYRISU6983ljMuSpOBawQqNcv7EoeVRsT62HjlypJ5//nnl5JTPkwEBAADyHgAATyjWMenffPONNmzYoM8++0xNmzZVhQr5L+vw/vvvu6Q4AADgOeQ9AADuV6wmvXLlyrrnnntcXQsAADAQ8h4AAPcrUpNus9k0a9Ys/fjjj8rOztZtt92mKVOmFPmM7gAAwLjIewAAPKdIx6Q/++yzevrppxUcHKw6depo3rx5GjlyZGnVBgAAPIC8BwDAc4rUpC9btkwvv/yy1q1bpzVr1uiDDz7Q8uXLHRewBwAAZR95DwCA5xSpSU9NTVXv3r0dt7t16yaTyaTjx4+7vDAAAOAZ5D0AAJ5TpCY9JydHgYGB+ab5+fnJai3+9fAAAICxkPcAAHhOkU4cZ7fbNXToUAUEBDimXblyRf/4xz/yXZaFS7IAAFB2kfcAAHhOkZr0IUOGFJj2wAMPuKwYAADgeeQ9AACeU6QmfcmSJaVVBwAAMAjyHgAAzynSMekAAAAAAKD00KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYhK+nCwAAAADKutTUVKWlpXm6DIfk5GRPlwCgmGjSAQAAgBJITU1V48bRyszM8HQpf2DSiYtXJFXydCEAioAmHQAAACiBtLQ0ZWZmqP1DkxUSFunpciRJZ34+oD0rnteFjBxPlwKgiGjSAQAAABcICYtU1YhGni5DkpR52Wjf6gNwFk06AAAAAJQyzlsAZ9GkAwAAAEAp4rwFKAqadAAAAAAoRZy3AEVBkw4AAAAAbsB5C+AMs6cLAAAAAAAAV9GkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABuHr6QIkaeHChZo1a5ZOnjyp5s2ba/78+WrXrl2h87722mtatmyZvv/+e0lS69at9dxzz11zfgAA4HlkveslJyeXeB02m02StHfvXpnNJfvuJisrSwEBASWuyZVCQ0MVERHh6TIAoEg83qSvXr1aCQkJWrRokdq3b6/ExET17NlTKSkpqlGjRoH5N27cqIEDB6pjx44KDAzU888/rx49euiHH35QnTp1PPAIAADA9ZD1rmXNypYkPfDAAyVel8Vi0cqVK9WlSxdlZmaWaF1mk2Szl7gkl7IEWXQg+QCNOoAyxeNN+uzZszV8+HANGzZMkrRo0SJ99NFHWrx4scaNG1dg/uXLl+e7/frrr+u9997Thg0bNHjwYLfUDAAAnEfWu1ZOTo4kafrdDdW7acEPOYrCZvbXMUmbx8XKbMsu9np2/3RGw99KUcvBLVW3bd0S1eQqF49e1OYXNistLY0mHUCZ4tEmPTs7W7t27dL48eMd08xms7p166Zt27Y5tY6MjAxZrVZVrVq10PuzsrKUlZXluJ2eni5JslqtslqtJaj+6i5iFotFfmbJ12Qr0bqMyt/HJIvFIvkGyCo/t4yZN467xrP7+Mtiscjfx1++do9/blUq/Ex+slgsstlsJX7elzZeV67n7teUxOuqqIz+uiwJd2S95F15n/ceUq9WFTWNDC3Ruqzy0zFJMRHV5Kfib6dLWVZZLBZVrVNVtRrUKlFNruLO7DPac0RyXda4KkOMmAs8R3iO3Iinst5kt9s9tmPS8ePHVadOHW3dulWxsbGO6WPHjtWmTZu0ffv2G65jxIgRWrdunX744QcFBgYWuH/KlCmaOnVqgekrVqxQUFBQyR4AAAAukJGRoUGDBunixYsKCQnxdDku5Y6sl8h7AICxFSXrjfERRTHNnDlTq1at0saNG68Z2uPHj1dCQoLjdnp6usLDw9WjR48S/yG0d+9edenSRbeOeVlVwqNKtC6jOpHynba9PFqvDWum/m3D3DKmVX5aX+V+dT+/vESf6jtrW8oJ9Zr7nTqO6qj6XeqX+niecPbwWX3y5CfavHmzmjdv7ulyrovXleu5+zUl8boqqrxvfVGQM1kveVfeu/I9xFXvD0Z8zbsz+4z2HJFc9zzhOeIaPEdurLw/R4qS9R5t0kNDQ+Xj46NTp07lm37q1CnVqnX9XaVefPFFzZw5U59//rmaNWt2zfkCAgIKPdOon5+f/PxKtkuG2WxWZmamrDYpx14+r2aXnWu/eiKZnCy3/XGfx09Wt4xpys1WZmamsnOzlWPKKfXxPMFqtyozM1Nms7nEz/vSxuuq9LjrNSXxuioqo78uS8IdWS95V96XxntISd8fjPiad2f2Ge05Irn+ecJzpGR4jtxYeX+OFGV5jz5D/P391bp1a23YsMExzWazacOGDfl2ifujF154QdOnT9enn36qNm3auKNUAABQDGQ9AABF4/Hd3RMSEjRkyBC1adNG7dq1U2Jioi5fvuw4A+zgwYNVp04dzZgxQ5L0/PPPa9KkSVqxYoUiIyN18uRJSVJwcLCCg4M99jgAAEDhyHoAAJzn8SZ9wIABOnPmjCZNmqSTJ0+qRYsW+vTTT1WzZk1JUmpqqszm377wf+WVV5Sdna2//vWv+dYzefJkTZkyxZ2lAwAAJ5D1AAA4z+NNuiTFxcUpLi6u0Ps2btyY7/aRI0dKvyAAAOBSZD0AAM4xxlkLAAAAAAAATToAAAAAAEZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGIQhmvSFCxcqMjJSgYGBat++vXbs2HHd+d955x01btxYgYGBatq0qT7++GM3VQoAAIqDrAcAwDkeb9JXr16thIQETZ48Wbt371bz5s3Vs2dPnT59utD5t27dqoEDB+rhhx/Wt99+q379+qlfv376/vvv3Vw5AABwBlkPAIDzPN6kz549W8OHD9ewYcMUExOjRYsWKSgoSIsXLy50/rlz56pXr1568sknFR0drenTp6tVq1ZasGCBmysHAADOIOsBAHCerycHz87O1q5duzR+/HjHNLPZrG7dumnbtm2FLrNt2zYlJCTkm9azZ0+tWbOm0PmzsrKUlZXluH3x4kVJ0rlz52S1WktUf3p6ugIDA3Xp2I+SNbNE6zKqzJM/KTAwUClp2dr4469uGdNm9lfGnzP01aFLMtuyS328749nKzAwUBnHM5S2L63Ux/OEX0/8qsDAQKWnp+vs2bOeLue6eF25nrtfUxKvqyKv69erzwO73e6K0gzFHVkveVfeu/I9xFXvD0Z8zbsz+4z2HJFc9zzhOeIaPEdurLw/R4qU9XYPOnbsmF2SfevWrfmmP/nkk/Z27doVuoyfn599xYoV+aYtXLjQXqNGjULnnzx5sl0SP/zwww8//Bj+5+jRo64JWANxR9bb7eQ9P/zwww8/ZePHmaz36Dfp7jB+/Ph8n8bbbDadO3dO1apVk8lk8mBluJb09HSFh4fr6NGjCgkJ8XQ5QJnHa8r47Ha7fv31V9WuXdvTpZRZ5H3x8P6AG+E5ghvhOeKcomS9R5v00NBQ+fj46NSpU/mmnzp1SrVq1Sp0mVq1ahVp/oCAAAUEBOSbVrly5eIXDbcJCQnhhQ64EK8pY6tUqZKnSygV7sh6ibwvKd4fcCM8R3AjPEduzNms9+iJ4/z9/dW6dWtt2LDBMc1ms2nDhg2KjY0tdJnY2Nh880vS+vXrrzk/AADwHLIeAICi8fju7gkJCRoyZIjatGmjdu3aKTExUZcvX9awYcMkSYMHD1adOnU0Y8YMSVJ8fLxuueUWvfTSS/rLX/6iVatWaefOnXr11Vc9+TAAAMA1kPUAADjP4036gAEDdObMGU2aNEknT55UixYt9Omnn6pmzZqSpNTUVJnNv33h37FjR61YsUITJkzQ008/raioKK1Zs0ZNmjTx1EOAiwUEBGjy5MkFdlsEUDy8puBpZL1x8f6AG+E5ghvhOeJ6Jru9HF7vBQAAAACAMsijx6QDAAAAAIDf0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw5DWbhwoSIjIxUYGKj27dtrx44dni4JKNM2b96sPn36qHbt2jKZTFqzZo2nSwJgEGQurof8wI3MmDFDbdu2VcWKFVWjRg3169dPKSkpni6rXKBJh2GsXr1aCQkJmjx5snbv3q3mzZurZ8+eOn36tKdLA8qsy5cvq3nz5lq4cKGnSwFgIGQuboT8wI1s2rRJI0eO1Ndff63169fLarWqR48eunz5sqdLK/O4BBsMo3379mrbtq0WLFggSbLZbAoPD9djjz2mcePGebg6oOwzmUz6z3/+o379+nm6FAAeRuaiKMgPOOPMmTOqUaOGNm3apC5duni6nDKNb9JhCNnZ2dq1a5e6devmmGY2m9WtWzdt27bNg5UBAFC+kLkASsPFixclSVWrVvVwJWUfTToMIS0tTbm5uapZs2a+6TVr1tTJkyc9VBUAAOUPmQvA1Ww2m0aNGqVOnTqpSZMmni6nzPP1dAEAAAAAgLJr5MiR+v7777VlyxZPl1Iu0KTDEEJDQ+Xj46NTp07lm37q1CnVqlXLQ1UBAFD+kLkAXCkuLk4ffvihNm/erLp163q6nHKB3d1hCP7+/mrdurU2bNjgmGaz2bRhwwbFxsZ6sDIAAMoXMheAK9jtdsXFxek///mPvvjiC9WrV8/TJZUbfJMOw0hISNCQIUPUpk0btWvXTomJibp8+bKGDRvm6dKAMuvSpUs6dOiQ4/bPP/+sPXv2qGrVqoqIiPBgZQA8iczFjZAfuJGRI0dqxYoV+u9//6uKFSs6zmlRqVIlWSwWD1dXtnEJNhjKggULNGvWLJ08eVItWrTQvHnz1L59e0+XBZRZGzdu1K233lpg+pAhQ7R06VL3FwTAMMhcXA/5gRsxmUyFTl+yZImGDh3q3mLKGZp0AAAAAAAMgmPSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAImnQAAAAAAAyCJh0AAAAAAIOgSQcAAAAAwCBo0gGUmqFDh6pfv36eLgMAgHKja9euGjVqVLGXX7p0qSpXruyyeq4lMjJSiYmJpT4OUB7RpAMAAABeYsCAAfrxxx89XQaA66BJB2BYdrtdOTk5ni4DAIByw2KxqEaNGte8Pzs7243VXJtR6gA8gSYd8AK//vqr7r//flWoUEFhYWGaM2dOvt3lsrKyNGbMGNWpU0cVKlRQ+/bttXHjRsfyebvGrVu3TtHR0QoODlavXr104sQJxzy5ublKSEhQ5cqVVa1aNY0dO1Z2uz1fHTabTTNmzFC9evVksVjUvHlzvfvuu477N27cKJPJpE8++UStW7dWQECAtmzZUqrbBgCAssZms2ns2LGqWrWqatWqpSlTpjjumz17tpo2baoKFSooPDxcI0aM0KVLlxz3/3F39ylTpqhFixZ6/fXXVa9ePQUGBkqSLly4oL///e+qWbOmAgMD1aRJE3344YeO5d577z39+c9/VkBAgCIjI/XSSy9dt+bU1FT17dtXwcHBCgkJUf/+/XXq1Kkb1gF4I5p0wAskJCQoKSlJa9eu1fr16/XVV19p9+7djvvj4uK0bds2rVq1St99953uvfde9erVSwcPHnTMk5GRoRdffFFvvfWWNm/erNTUVI0ZM8Zx/0svvaSlS5dq8eLF2rJli86dO6f//Oc/+eqYMWOGli1bpkWLFumHH37QE088oQceeECbNm3KN9+4ceM0c+ZMJScnq1mzZqW0VQAAKJvefPNNVahQQdu3b9cLL7ygadOmaf369ZIks9msefPm6YcfftCbb76pL774QmPHjr3u+g4dOqT33ntP77//vvbs2SObzaY77rhDSUlJevvtt7V//37NnDlTPj4+kqRdu3apf//+uu+++7Rv3z5NmTJFEydO1NKlSwtdv81mU9++fXXu3Dlt2rRJ69ev108//aQBAwZctw7Aa9kBlGvp6el2Pz8/+zvvvOOYduHCBXtQUJA9Pj7e/ssvv9h9fHzsx44dy7fc7bffbh8/frzdbrfblyxZYpdkP3TokOP+hQsX2mvWrOm4HRYWZn/hhRcct61Wq71u3br2vn372u12u/3KlSv2oKAg+9atW/ON8/DDD9sHDhxot9vt9i+//NIuyb5mzRrXPHgAAMqZW265xX7zzTfnm9a2bVv7U089Vej877zzjr1atWqO20uWLLFXqlTJcXvy5Ml2Pz8/++nTpx3T1q1bZzebzfaUlJRC1zlo0CB79+7d80178skn7TExMY7bN910k33OnDl2u91u/+yzz+w+Pj721NRUx/0//PCDXZJ9x44d16wD8Fa+Hv6MAEAp++mnn2S1WtWuXTvHtEqVKqlRo0aSpH379ik3N1cNGzbMt1xWVpaqVavmuB0UFKQ//elPjtthYWE6ffq0JOnixYs6ceKE2rdv77jf19dXbdq0cezyfujQIWVkZKh79+75xsnOzlbLli3zTWvTpk1JHjIAAOXaH/cy+30mf/7555oxY4YOHDig9PR05eTk6MqVK8rIyFBQUFCh67vppptUvXp1x+09e/aobt26Bf42yJOcnKy+ffvmm9apUyclJiYqNzfX8Y377+cPDw9XeHi4Y1pMTIwqV66s5ORktW3bttA6AG9Fkw54uUuXLsnHx0e7du0qEKrBwcGO3/38/PLdZzKZChxzfqNxJOmjjz5SnTp18t0XEBCQ73aFChWcXi8AAN6msEy22Ww6cuSI7rzzTj366KN69tlnVbVqVW3ZskUPP/ywsrOzr9mk/zF3LRZLqdV+PeQ/cBXHpAPlXP369eXn56dvvvnGMe3ixYuOy6+0bNlSubm5On36tBo0aJDvp1atWk6NUalSJYWFhWn79u2OaTk5Odq1a5fjdkxMjAICApSamlpgnN9/sg4AAIpn165dstlseumll9ShQwc1bNhQx48fL/J6mjVrpv/973/XvFRbdHS0kpKS8k1LSkpSw4YNC3zgnzf/0aNHdfToUce0/fv368KFC4qJiSlyfUB5xzfpQDlXsWJFDRkyRE8++aSqVq2qGjVqaPLkyTKbzTKZTGrYsKHuv/9+DR48WC+99JJatmypM2fOaMOGDWrWrJn+8pe/ODVOfHy8Zs6cqaioKDVu3FizZ8/WhQsX8tUxZswYPfHEE7LZbLr55pt18eJFJSUlKSQkREOGDCmlLQAAgHdo0KCBrFar5s+frz59+igpKUmLFi0q8npuueUWdenSRffcc49mz56tBg0a6MCBAzKZTOrVq5dGjx6ttm3bavr06RowYIC2bdumBQsW6OWXXy50fd26dVPTpk11//33KzExUTk5ORoxYoRuueUWDnEDCsE36YAXmD17tmJjY3XnnXeqW7du6tSpk6Kjox2XN1myZIkGDx6s0aNHq1GjRurXr5+++eYbRUREOD3G6NGj9eCDD2rIkCGKjY1VxYoVddddd+WbZ/r06Zo4caJmzJih6Oho9erVSx999JHq1avn0scLAIA3at68uWbPnq3nn39eTZo00fLlyzVjxoxireu9995T27ZtNXDgQMXExGjs2LHKzc2VJLVq1Ur//ve/tWrVKjVp0kSTJk3StGnTNHTo0ELXZTKZ9N///ldVqlRRly5d1K1bN9WvX1+rV68u7kMFyjWTvSgHlQIoFy5fvqw6deropZde0sMPP+zpcgAAAAD8f+zuDniBb7/9VgcOHFC7du108eJFTZs2TZIKnJkVAAAAgGfRpANe4sUXX1RKSor8/f3VunVrffXVVwoNDfV0WQAAAAB+h93dAQAAAAAwCE4cBwAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEL6eLsDdbDabjh8/rooVK8pkMnm6HAAAZLfb9euvv6p27doym/n83BXIewCAkRQl672uST9+/LjCw8M9XQYAAAUcPXpUdevW9XQZ5QJ5DwAwImey3uua9IoVK0q6unFCQkI8XI3zrFarPvvsM/Xo0UN+fn6eLsdj2A6/YVtcxXa4iu1wVVndDunp6QoPD3dkFEqurOa9tyirr1XAyHhdGVtRst7rmvS8Xd5CQkLKVGhbrVYFBQUpJCTEq190bIffsC2uYjtcxXa4qqxvB3bLdp2ymvfeoqy/VgEj4nVVNjiT9Rz4BgAAAACAQdCkAwAAAABgEDTpAAAAAAAYhNcdkw7Au+Xm5spqtXq6DJezWq3y9fXVlStXlJub6+lyPMao28HPz08+Pj6eLgMAvEJ5zfobMWoGehN/f3+XXEqVJh2AV7Db7Tp58qQuXLjg6VJKhd1uV61atXT06FGvPvmYkbdD5cqVVatWLcPVBQDlRXnP+hsxcgZ6C7PZrHr16snf379E66FJB+AV8kK7Ro0aCgoKKnfhZbPZdOnSJQUHB7vkE9yyyojbwW63KyMjQ6dPn5YkhYWFebgiACifynvW34gRM9Cb2Gw2HT9+XCdOnFBERESJnn806QDKvdzcXEdoV6tWzdPllAqbzabs7GwFBgZ6dTAbdTtYLBZJ0unTp1WjRg12fQcAF/OGrL8Ro2agN6levbqOHz+unJycEl0Gj/89AOVe3nFpQUFBHq4E3izv+eeNx0kCQGkj62EEebu5l/ScADTpALyGt+32BmPh+QcApY/3WniSq55/NOkAAAAAABgEx6QDAK6ra9euatGihRITEw2xHsATUlNTlZaW5ukySlVoaKgiIiI8XQYADyHvjYMmHQDgUhs3btStt96q8+fPq3Llyo7p77//folOogJ4Smpqqho3jlZmZoanSylVFkuQDhxIplEH4BTyvvTQpAMA3KJq1aqeLgEolrS0NGVmZqj9Q5MVEhbp6XJKRfqJI9q+eKrS0tJo0gGUCHlfchyTDgAG1bVrV8XFxSkuLk6VKlVSaGioJk6cKLvdLkk6f/68Bg8erCpVqig4OFh//etfdfDgQcfyS5cuVeXKlbVmzRpFRUUpMDBQPXv21NGjRx3zDB06VP369cs37qhRo9S1a9dr1vXWW2+pTZs2qlixomrVqqVBgwY5rgF+5MgR3XrrrZKkKlWqyGQyaejQoY7HM2rUKMd6fl9/UFCQ7rjjjkLrX7dunaKjoxUcHKxevXrpxIkTxdmcQImFhEWqakSjcvlTXj98AMqCouT99fJyzZo1at26tYKCgsj7Mo4mHQAM7M0335Svr6927NihuXPnavbs2Xr99dclXQ3cnTt3au3atUpKSpIk3Xnnnfku8ZWRkaFnn31Wy5YtU1JSki5cuKD77ruvRDVZrVZNnz5de/fu1Zo1a3TkyBFHMIeHh+u9996TJKWkpOjEiROaO3duoev5ff3btm2T3W5X7969C9T/4osv6q233tLmzZuVmpqqMWPGlKh+AACMxtm8v15ezpgxQ6+88oq++uor8r6MY3d3ADCw8PBwzZkzRyaTSY0aNdK+ffs0Z84cde3a1dGcd+zYUTabTa+++qqaNGmiNWvW6N5775V0NWAXLFig9u3bS7r6R0B0dLR27Nihdu3aFaumhx56yPF7/fr1NW/ePLVt21aXLl1ScHCwYze3GjVq5DtG7fcOHjyYr35JWr58ucLDwwvUv2jRIv3pT3+SJMXFxWnatGnFqhsAAKNyNu+la+flvHnzFB0drZCQEPK+jOObdAAwsA4dOuS75mZsbKwOHjyo/fv3y9fX19F8S1ePAWvUqJGSk5Md03x9fdW2bVvH7caNG6ty5cr55imqXbt2qU+fPoqIiFDFihV1yy23SLp6ci1nJScnF6i/WrVqBeoPCgpyBLYkhYWFOXa1AwCgvChK3heWl+R9+UKTDgBezGw2O455y/P73c/+6PLly+rZs6dCQkK0fPlyffPNN/rPf/4jScrOznZ5fX88O6zJZCpQLwAAuD7yvmyhSQcAA9u+fXu+219//bWioqIUExOjnJycfPefO3dOKSkpiomJcUzLycnRzp07HbdTUlJ04cIFRUdHS5KqV69e4MQse/bsuWY9Bw4c0NmzZzVz5kx17txZjRs3LvBJt7+/vyQpNzf3muuJjo4uUP/Zs2cL1A8AgDcoSt4XlpfkfflCkw4ABpaamqqEhASlpKRo5cqVmj9/vuLj4xUVFaW+fftq+PDh2rJli/bu3atHHnlEderUUd++fR3L+/n56bHHHtP27du1a9cuDR06VB06dHAcn3bbbbdp586dWrZsmQ4ePKjJkyfr+++/v2Y9ERER8vf31/z58/XTTz9p7dq1mj59er55brrpJplMJn344Yc6c+aMLl26VGA9hdX/wAMPFKgfAABvUJS8Lywv/fz8FB8fr507d5L35QBNOgAY2ODBg5WZmal27dpp5MiRio+P1yOPPCJJWrJkiVq3bq0777xTnTp1kiR9+OGH+XYZCwoK0lNPPaVBgwapU6dOCg4O1urVqx339+zZUxMnTtTYsWPVtm1b/frrrxo8ePA166levbqWLl2qd955RzExMZo5c6ZefPHFfPPUqVNHU6dO1bhx41SzZk3FxcUVuq7f1x8bGyu73a6PP/64wC5vAACUd87m/bXyMigoSE8++aSGDx+uzp07k/dlnMnuZTv7p6enq1KlSrp48aJCQkI8XY7TrFarPv74Y/Xu3durn9Bsh9+wLa5yZjtcuXJFP//8s+rVq6fAwEA3V1h8Xbt2VYsWLZSYmHjDeW02m9LT0xUSEiKz+ernr0uXLtWoUaN04cKF0i3UQArbDkZxvedhWc0mI3PlNt29e7dat26t7v9coqoRjVxUobGcS03R+meHadeuXWrVqlWpj0eGwdXKatZLRcv7wuTl/blz5wybgd7CVVnP/x4AAAAAAAZBkw4AAAAAgEH4eroAAEDhNm7cWKLlhw4dqqFDh7qkFgAAUDpclfc2m801BcHj+CYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAImnQAAAAAAAyCJh0AAAAAAIOgSQcAAAAAwCC4BBsAr5aamqq0tDS3jRcaGqqIiAi3jeesyMhIjRo1SqNGjbrmPNnZ2YqJidGyZcvUsWNH9xVnACaTSf/5z3/Ur1+/Qu/fv3+/evTooZSUFFWoUMG9xQEArousv4qsvz4jZT1NOgCvlZqaqsaNo5WZmeG2MS2WIB04kGzI8L6RRYsWqV69emU6tI8cOaJ69erp22+/VYsWLVy23piYGHXo0EGzZ8/WxIkTXbZeAEDJkPVFQ9ZfmzuzniYdgNdKS0tTZmaG2j80WSFhkaU+XvqJI9q+eKrS0tLKXHDb7XYtWLBA06ZNK/F6cnNz5etb/uJn2LBhGj58uMaPH18uHx8AlEVkvfPI+htzV9ZzTDoArxcSFqmqEY1K/ac4fxx07dpVcXFxiouLU6VKlRQaGqqJEyfKbrc75jl//ryGDBmiyMhIBQcH64477tDBgwfzree9997Tn//8ZwUEBCgyMlIvvfRSkerYtWuXDh8+rL/85S+OaUeOHJHJZNKqVavUsWNHBQYGqkmTJtq0aZNjno0bN8pkMumTTz5R69atFRAQoC1btshms2nGjBmqV6+eLBaLmjdvrnfffbfAcuvWrVPLli1lsVh022236fTp0/rkk08UHR2tkJAQDRo0SBkZv3078umnn6pXr16qWrWqqlWrpjvvvFOHDx923F+vXj1JUsuWLWUymdS1a1fHfYsXL3Zso7CwMMXFxeXbBmlpabrrrrsUFBSkqKgorV27Nt/93bt317lz5/I9fgCAMZSHrB88eLCqVKmioKCga2Z9bGysLBZLuc/6m2++WZUrVy63WU+TDgAG9+abb8rX11c7duzQ3LlzNXv2bL3++uuO+4cOHapdu3ZpxYoVSkpKkt1uV+/evWW1WiVdDd3+/fvrvvvu0759+zRlyhRNnDhRS5cudbqGr776Sg0bNlTFihUL3Pfkk09q9OjR+vbbbxUbG6s+ffro7Nmz+eYZN26cZs6cqeTkZDVr1kwzZszQsmXLtGjRIv3www964okn9MADDxQIvSlTpmjBggXaunWrjh49qv79+ysxMVErVqzQRx99pM8++0zz5893zH/58mWNHDlSO3bs0IYNG2Q2m3XXXXfJZrNJknbs2CFJ+vzzz3XixAm9//77kqRXXnlFI0eO1COPPKJ9+/Zp7dq1atCgQb5apk6dqv79++u7775T7969df/99+vcuXOO+/39/dWiRQt99dVXTm9XAAAk57J+586dWrt2rbZt21Zo1t933326++67tXfv3nKf9QkJCdq5c2e5zfrytw8CAJQz4eHhmjNnjkwmkxo1aqR9+/Zpzpw5Gj58uA4ePKi1a9fqq6++UpMmTRQSEqLly5crPDxca9as0b333qvZs2fr9ttvdxw/1bBhQ+3fv1+zZs3S0KFDnarhl19+Ue3atQu9Ly4uTvfcc4+kqwH46aef6o033tDYsWMd80ybNk3du3eXJGVlZem5557T559/rtjYWElS/fr1tWXLFv3rX//SLbfc4ljumWeeUadOnSRJDz/8sMaPH6/Dhw+rfv36kqS//vWv+vLLL/XUU09Jku655x6lp6crJCREZrNZixcvVvXq1bV//341adJE1atXlyRVq1ZNtWrVyjfO6NGjFR8f75jWtm3bfI9z6NChGjhwoCTpueee07x587Rjxw716tXLMU/t2rX1yy+/OLVNAQDI40zWJyUlOY4VLyzrb7vtNj355JMKCQlR48aNy3XW/155zHq+SQcAg+vQoYNMJpPjdmxsrA4ePKjc3FwlJyfL19dX7du3d9xfrVo1NWrUSMnJyZKk5ORkR/jl6dSpk2MdzsjMzFRgYGCh9+WFryT5+vqqTZs2jrHztGnTxvH7oUOHlJGRoe7duys4ONjxs2zZsny7q0lSs2bNHL/XrFlTQUFBjtDOm3b69GnH7YMHD+rhhx9WgwYNFBISosjISElXTxx0LadPn9bx48d1++23X2cL5K+lQoUKCgkJyTe2JFkslny75AEA4Ayy/ipns37gwIGqX79+uc16jzfpCxcuVGRkpAIDA9W+fXvH7gnXkpiYqEaNGslisSg8PFxPPPGErly54qZqAcA7hYaG6vz588Ve/veXKrl06ZIk6aOPPtKePXscP/v37893rJok+fn5OX43mUz5budNy9u9TZL69u2rCxcu6F//+pe2b9+u7du3S7p6SZlrsVgsTj2GG40tSefOnXN8go/8yHsAMLaykvV9+vTRuXPn9Nprr5XbrPdok7569WolJCRo8uTJ2r17t5o3b66ePXsW+LQiz4oVKzRu3DhNnjxZycnJeuONN7R69Wo9/fTTbq4cANwnL3zyfP3114qKipKPj4+io6OVk5OTb56zZ88qJSVFMTExkqTo6GglJSXlW0dSUpIaNmwoHx8fp2po2bKlDhw4kO8kNr+vJ09OTo527dql6Ojoa64rJiZGAQEBSk1NVYMGDfL9hIeHO1VPYfIe9+jRo3X77bcrOjq6wB8b/v7+kpTvW4WKFSsqMjJSGzZsKPbYeb7//nu1bNmyxOspb8h7ALg+st45eY97woQJ5TrrPXpM+uzZszV8+HANGzZM0tXr8n300UdavHixxo0bV2D+rVu3qlOnTho0aJAkKTIyUgMHDizwpAaA8iQ1NVUJCQn6+9//rt27d2v+/PmOM7ZGRUWpb9+++vvf/64XX3xRtWrV0tNPP606deqob9++kqTRo0erbdu2mj59ugYMGKBt27ZpwYIFevnll52u4dZbb9WlS5f0ww8/qEmTJvnuW7hwoaKiohQdHa05c+bo/Pnzeuihh665rooVK2rMmDF64oknZLPZdPPNN+vixYtKSkpSSEiIhgwZUoytJFWpUkXVqlXTm2++qQYNGuh///tfgSypUaOGLBaLPv30U9WtW1eBgYGqVKmSpkyZon/84x+qUaOG7rjjDv36669KSkrSY4895vT4R44c0bFjx9StW7di1V+ekfcAcH3OZP3w4cP1r3/9SxUrVtS4ceMKzfpZs2bpwQcf1Pbt28t11r/66qsKCwtTampqucx6jzXp2dnZ2rVrl8aPH++YZjab1a1bN23btq3QZTp27Ki3335bO3bsULt27fTTTz/p448/1oMPPnjNcbKyspSVleW4nZ6eLkmyWq2OsyGWBXm1lqWaSwPb4Tdsi6uc2Q5Wq1V2u102my3fLkt5v6cfPyIV/NDY5dJPHHGM+8ddp67nwQcfVEZGhtq1aycfHx89/vjj+tvf/uZYxxtvvKFRo0bpvvvuk9VqVefOnfXhhx/Kx8dHNptNLVq00KpVqzRlyhRNnz5dYWFhmjp1qgYPHpyvjrxtVJgqVaqoX79+evvtt/Xcc885Hod09cQqM2fO1J49e9SgQQOtWbNGVatWzfc4//iYp06dqtDQUM2YMUM//fSTKleurJYtW2r8+PHXXO6P/+bV/Ptpy5cvV3x8vJo1a6ZGjRopMTFRt912m2M9ZrNZiYmJeuaZZzRp0iR17txZX3zxhWMbz507V2PGjFFoaKjuueeeAs+XP26f309bsWKFunfvrvDw8EK3o81mk91ul9VqLfCtRnl+HZeHvLfZbLJYLPIzS74m51+7ZYmf+eruoDabzS3PRzIMruYtWX/nnXcqOzv7mlk/adIkzZo1q1xn/YoVKzRq1Cg1adKk3Ga9yV7Y/gxucPz4cdWpU0dbt27NdyKCsWPHatOmTdf8tHzevHkaM2aM7Ha7cnJy9I9//EOvvPLKNceZMmWKpk6dWmD6ihUrFBQUVPIHAsDwfH19VatWLYWHhzt2gZKko0ePql379rqSmem2WgItFu3Yvt3pXb3uvPNONW3aVDNmzCjlym7s+++/1913363du3crODhYqampat68uTZv3qymTZt6ujyPys7OVuvWrfXaa6+pQ4cO15zn6NGjOnnypHJycvLdl5GRoUGDBunixYsKCQlxR8luQ94DcAey3jXI+mtzZ9aXqUuwbdy4Uc8995xefvlltW/fXocOHVJ8fLymT5/uuLTQH40fP14JCQmO2+np6QoPD1ePHj3K1B9CVqtV69evV/fu3Quc0MCbsB1+w7a4ypntcOXKFR09elTBwcH5zlr65z//Wcn79ystLc1d5So0NFQRERFOz+/r6yt/f/8bvl/Z7Xb9+uuvqlixYr6zw7pSx44dNXPmTJ09e1a1a9dWcHCwpN/OfmoE7tgOhTl06JCefvpp9ejR45rzXLlyRRaLRV26dClw9ty8b31xldHyfu/everSpYtuHfOyqoRHlWhdRnX+6EF9+eIIbd68Wc2bNy/18cgwuJo3ZP2NuCIDy0LWe4o7s95jTXpoaKh8fHx06tSpfNNPnTqV73p2vzdx4kQ9+OCD+tvf/iZJatq0qS5fvqxHHnlE//znP2U2FzwPXkBAgAICAgpM9/PzK5OhUFbrdjW2w2/YFlddbzvk5ubKZDLJbDYXeJ+IjIx0XLrDqPJqv568Xa6cmbckfn/8Wd44hW1XT3HXdvijhg0bqmHDhtedx2w2O85a+8fnanl+DZeHvDebzcrMzJTVJuXYjfFcdzWr7erll8xms1ufj2QYXMUbsv5GXJWBRs96T3Fn1nusSff391fr1q21YcMG9evXT9LVJ9aGDRsUFxdX6DIZGRkFnhx5+/p7aK99AChVGzdu9HQJ1xQZGcl7L26IvAeA6yPr8Uce3d09ISFBQ4YMUZs2bdSuXTslJibq8uXLjrO/Dh48WHXq1HEcn9GnTx/Nnj1bLVu2dOz+NnHiRPXp08fpSwsAAAD3Iu8BAHCeR5v0AQMG6MyZM5o0aZJOnjypFi1a6NNPP1XNmjUlXb0Uwe8/SZ8wYYJMJpMmTJigY8eOqXr16urTp4+effZZTz0EAABwA+Q9AADO8/iJ4+Li4q65u9sfd/3w9fXV5MmTNXnyZDdUBgAAXIW8BwDAOd599D8AAAAAAAZCkw4AAAAAgEHQpAMAAAAAYBAePyYdADwpNTVVaWlpbhsvNDRUERERbhvPGZGRkRo1apRGjRrl6VIAAHA5sp6sL2to0gF4rdTUVEU3bqSMzCtuGzPIEqjkAymGC28AAMojsh5lEU06AK+VlpamjMwrevuRFooOCy718ZJPXNIDr+5RWloawQ0AgBuQ9SiLaNIBeL3osGC1iqzk6TIK1bVrVzVp0kSS9NZbb8nPz0+PPvqopk2bJpPJpPPnzys+Pl4ffPCBsrKy1KVLF82fP19RUVGOdbz33nuaNGmSDh06pLCwMD322GMaPXq0px4SAABuV56y/pZbbtG8efPI+nKME8cBgMG9+eab8vX11Y4dOzR37lzNnj1br7/+uiRp6NCh2rlzp9asWaN169bJbrerd+/eslqtkqRdu3apf//+uu+++7Rv3z5NmTJFEydO1NKlSz34iAAAwO85k/Vr167Vtm3brpn1AwYMUFJSkiZNmkTWl3F8kw4ABhceHq45c+bIZDKpUaNG2rdvn+bMmaOuXbtq7dq1SkpKUocOHZSenq63335bN910k9asWaN7771Xs2fP1u23366JEydKkho2bKj9+/dr1qxZGjp0qGcfGAAAkORc1nfs2FGStHz5coWHhxfI+gkTJig9PV2tWrXSgQMHyPoyjG/SAcDgOnToIJPJ5LgdGxurgwcPav/+/fL19VX79u0d91WrVk2NGjVScnKyJCk5OVmdOnXKt75OnTrp4MGDys3Ndc8DAAAA10XW4/do0gEAAAAAMAiadAAwuO3bt+e7/fXXXysqKkoxMTHKycnJd//Zs2eVkpKimJgYSVJ0dLSSkpLyLZ+UlKSGDRvKx8en9IsHAAA3RNbj92jSAcDgUlNTlZCQoJSUFK1cuVLz589XfHy8oqKi1LdvXw0fPlxbtmzRvn379OCDD6pOnTrq27evJGn06NHasGGDpk+frh9//FFvvvmmFixYoDFjxnj4UQEAgDzOZv3evXv1wAMPFJr1zzzzjA4dOkTWlwOcOA6A10s+ccnQ4wwePFiZmZlq166dfHx8FB8fr0ceeUSStGTJEsXHx+v//u//lJ2drc6dO+vjjz+Wn5+fJKlVq1b697//rUmTJmn69OkKCwvTtGnTOJEMAMCrlIesv/POO5Wdna0uXbpcM+ufeeYZsr4coEkH4LVCQ0MVZAnUA6/ucduYQZZAhYaGFmkZPz8/JSYm6pVXXilwX5UqVbRs2TLZbDalp6crJCREZnP+naTuuece3XPPPddc/5EjR4pUDwAAZUV5yvrrueeee3TXXXdd828Bsr5soUkH4LUiIiKUfCBFaWlpbhszNDRUERERbhsPAABvRtajLKJJB+DVIiIiCFIAAMoxsh5lDU06ABjYxo0bPV0CAAAoRWQ9/oizuwMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBJdgA+DVUlNTlZaW5rbxQkNDuVYrAABuRNajrKFJB+C1UlNT1Ti6sTIzMt02piXIogPJB5wO765du6pFixZKTEws3cKcZLR6ALhWcnKyW8ax2WySpL1798psdt+OnVlZWQoICHDbeJ5Ag5gfWV90RqvHG9GkA/BaaWlpyszIVJexXVQpvFKpj3fx6EVtfmGz0tLS3PoHVHZ2tvz9/d02HoCyx5qVLUl64IEH3DKexWLRypUr1aVLF2Vmuq95Mpskm91tw3lEURvE8s6bst7Xl9auvOB/EoDXqxReSaFRoZ4uo4ChQ4dq06ZN2rRpk+bOnStJOnTokJ577jl98cUXOnnypCIiIjRixAg99thj+Za7cOGC2rZtq4ULFyogIEA///yztm7dqhEjRujAgQNq0qSJJkyYoLvuukvffvutWrRoIUn6/vvv9eSTT+qrr75ShQoV1KNHD82ZM0ehoaGF1vPzzz8rMjLS3ZsGgIvl5ORIkqbf3VC9m9Yo9fFsZn8dk7R5XKzMtuxSH0+Sdv90RsPfSlHLwS1Vt21dt4zpbp5qEMuC8pD18fHx+Zb7Y9YfPnxY27dv11NPPUXWl3E06QBgUHPnztWPP/6oJk2aaNq0aZKkKlWqqG7dunrnnXdUrVo1bd26VY888ohq1qypXr16OZbdsGGDQkJCtH79eklSenq6+vTpo969e2vFihX65ZdfNGrUqHzjXbhwQbfddpv+9re/ac6cOcrMzNRTTz2l/v3764svvii0nurVq7tnYwBwi3qhQWoVWfrfNlrlp2OSmkeEyE/WUh9Pki5nXJYkBdcKNmSzBu9UlKwPCwtT//79HcsWlvUDBw4k68sBmnQAMKhKlSrJ399fQUFBqlWrlmP61KlTHb/Xq1dP27Zt0zvvvJOvSa9QoYJef/11x27uixYtkslk0muvvabAwEDFxMTo2LFjGj58uGOZBQsWqGXLlnruuecc0xYvXqzw8HD9+OOPatiwYaH1AACA4ilK1v/73//O16T/MetffvllmUwmvfrqqwoKCiLryzCadAAoYxYuXKjFixcrNTVVmZmZys7OduzClqdp06b5jkNPSUlRs2bNFBgY6JjWrl27fMvs3btXX375pYKDgwuMefjwYTVs2NC1DwQAABSqOFn/448/6s9//jNZXw7QpANAGbJq1SqNGTNGL730kmJjY1WxYkXNmjVL27dvzzdfhQoVirzuS5cuqU+fPnr++ecL3BcWFlbsmgEAgPPIetCkA4CB+fv7Kzc313E7KSlJHTt21IgRIxzTDh8+fMP1NGrUSG+//Xa+yw998803+eZp1aqV3nvvPUVGRl7zDLF/rAcAAJSMq7K+YcOGjqy3WCySyPqyiiYdgNe7ePSiYceJjIzU9u3bdeTIEQUHBysqKkrLli3TunXrVK9ePb311lv65ptvVK9eveuuZ9CgQfrnP/+pRx55ROPGjVNqaqpefPFFSZLJZJIkjRw5Uq+99poGDhyosWPHqmrVqjp06JBWrVql119/XT4+PgXqqVq1qluvcQwAQHF4S9ZPmDBBf//73zV+/HiyvgyjSQfgtUJDQ2UJsmjzC5vdNqYlyKLQUOfPKjxmzBgNGTJEMTExyszM1IEDB/Ttt99qwIABMplMGjhwoEaMGKFPPvnkuusJCQnRBx98oEcffVQtWrRQ06ZNNWnSJA0aNMhx7Frt2rWVlJSkp556Sj169FBWVpZuuukm9erVyxHOf6yHy7IAAIzM27J+5cqVGjt2LFlfxtGkA/BaEREROpB8QGlpaW4bMzQ0tEjXrm3YsKG2bduWb9qSJUu0ZMmSfNOeffZZpaenS5KWLl1a6Lo6duyovXv3Om4vX75cfn5++eqJiorS+++/X6R6AAAwqvKU9TNmzHD8fq2sb9++vb799ltHw03Wl0006QC8WkRERJGCtCxbtmyZ6tevrzp16mjv3r2O66LmHbcGAEB55E1Zv2rVKsXExCg8PJysL8No0gHAS5w8eVKTJk3SyZMnFRYWpnvvvVfPPvusp8sCAAAucurUKc2cOZOsL+No0gHAS4wdO1Zjx471dBkAAKCUxMfHa+LEiZzorYzjfw8AAAAAAIOgSQfgNex2u6dLgBfj+QcApY/3WniSq55/NOkAyj0/Pz9JUkZGhocrgTfLe/7lPR8BAK5D1sMIsrOzJUk+Pj4lWg/HpAMo93x8fFS5cmWdPn1akhQUFCSTyeThqlzLZrMpOztbV65c8erj0Iy4Hex2uzIyMnT69GlVrly5xMENACjIG7L+RoyYgd7EZrPpzJkzCgoKkq9vydpsmnQAXqFWrVqS5Ajv8sZutyszM1MWi8Xr/ij5PSNvh8qVKzuehwAA1yvvWX8jRs5Ab2E2mxUREVHi7U+TDsArmEwmhYWFqUaNGrJarZ4ux+WsVqs2b96sLl26ePXu1EbdDn5+fnyDDgClrLxn/Y0YNQO9ib+/v0v2YqBJB+BVfHx8ymWz5OPjo5ycHAUGBnp1MLMdAADlNetvhAwsPzhYAQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAIjzfpCxcuVGRkpAIDA9W+fXvt2LHjuvNfuHBBI0eOVFhYmAICAtSwYUN9/PHHbqoWAAAUB3kPAIBzfD05+OrVq5WQkKBFixapffv2SkxMVM+ePZWSkqIaNWoUmD87O1vdu3dXjRo19O6776pOnTr65ZdfVLlyZfcXDwAAnELeAwDgPI826bNnz9bw4cM1bNgwSdKiRYv00UcfafHixRo3blyB+RcvXqxz585p69at8vPzkyRFRka6s2QAAFBE5D0AAM7zWJOenZ2tXbt2afz48Y5pZrNZ3bp107Zt2wpdZu3atYqNjdXIkSP13//+V9WrV9egQYP01FNPycfHp9BlsrKylJWV5bidnp4uSbJarbJarS58RKUrr9ayVHNpYDv8hm1xFdvhKrbDVWV1O5S1eouiPOS9zWaTxWKRn1nyNdlKtC6j8vcxyWKxSL4Bssqv1MfLG8MdY+Wx+/jLYrHI38dfvnaPfk9VavxMfrJYLLLZbOX6fQWFK6sZ6C2K8v/isXeotLQ05ebmqmbNmvmm16xZUwcOHCh0mZ9++klffPGF7r//fn388cc6dOiQRowYIavVqsmTJxe6zIwZMzR16tQC0z/77DMFBQWV/IG42fr16z1dgiGwHX7DtriK7XAV2+GqsrYdMjIyPF1CqSkveb9y5cr//1taiddlSDVq6/HOVx+jO4/8X1/lfvcN1kFa2eH//5513TnLrrrS4JWDdezYMR07dszT1cBDyloGeouiZH2Z+hjRZrOpRo0aevXVV+Xj46PWrVvr2LFjmjVr1jVDe/z48UpISHDcTk9PV3h4uHr06KGQkBB3lV5iVqtV69evV/fu3R27/nkjtsNv2BZXsR2uYjtcVVa3Q963vrjKaHm/d+9edenSRbeOeVlVwqNKtC6jOpHynba9PFqvDWum/m3DSn08q/y0vsr96n5+ufzknm/9tqWcUK+536njqI6q36W+W8Z0t7OHz+qTJz/R5s2b1bx5c0+XAzcrqxnoLYqS9R5r0kNDQ+Xj46NTp07lm37q1CnVqlWr0GXCwsLk5+eXb1e36OhonTx5UtnZ2fL39y+wTEBAgAICAgpM9/PzK5NP3rJat6uxHX7DtriK7XAV2+GqsrYdylKtRVUe8t5sNiszM1NWm5Rj9/iFcUpFdq5dmZmZUk6W25pmSfKT1W3jmXKzlZmZqezcbOWYctwyprtZ7VZlZmbKbDaX6/cVXF9Zy0BvUZT/E48ljb+/v1q3bq0NGzY4ptlsNm3YsEGxsbGFLtOpUycdOnRINttvx4P9+OOPCgsLKzSwAQCAZ5H3AAAUjUc/Dk5ISNBrr72mN998U8nJyXr00Ud1+fJlx9lfBw8enO9EM48++qjOnTun+Ph4/fjjj/roo4/03HPPaeTIkZ56CAAA4AbIewAAnOfRY9IHDBigM2fOaNKkSTp58qRatGihTz/91HFymdTUVJnNv32OEB4ernXr1umJJ55Qs2bNVKdOHcXHx+upp57y1EMAAAA3QN4DAOA8j584Li4uTnFxcYXet3HjxgLTYmNj9fXXX5dyVQAAwJXIewAAnFM+z34CAAAAAEAZVKwm/csvv3R1HQAAwGDIewAA3K9YTXqvXr30pz/9Sc8884yOHj3q6poAAIABkPcAALhfsZr0Y8eOKS4uTu+++67q16+vnj176t///reys7NdXR8AAPAQ8h4AAPcrVpMeGhqqJ554Qnv27NH27dvVsGFDjRgxQrVr19bjjz+uvXv3urpOAADgZuQ9AADuV+ITx7Vq1Urjx49XXFycLl26pMWLF6t169bq3LmzfvjhB1fUCAAAPIy8BwDAPYrdpFutVr377rvq3bu3brrpJq1bt04LFizQqVOndOjQId1000269957XVkrAABwM/IeAAD3KtZ10h977DGtXLlSdrtdDz74oF544QU1adLEcX+FChX04osvqnbt2i4rFAAAuBd5DwCA+xWrSd+/f7/mz5+vu+++WwEBAYXOExoayqVbAAAow8h7AADcr1i7u0+ePFn33ntvgcDOycnR5s2bJUm+vr665ZZbSl4hAADwCPIeAAD3K1aTfuutt+rcuXMFpl+8eFG33npriYsCAACeR94DAOB+xWrS7Xa7TCZTgelnz55VhQoVSlwUAADwPPIeAAD3K9Ix6XfffbckyWQyaejQofl2f8vNzdV3332njh07urZCAADgVuQ9AACeU6QmvVKlSpKufrJesWJFWSwWx33+/v7q0KGDhg8f7toKAQCAW5H3AAB4TpGa9CVLlkiSIiMjNWbMGHZ1AwCgHCLvAQDwnGJdgm3y5MmurgMAABgMeQ8AgPs53aS3atVKGzZsUJUqVdSyZctCTySTZ/fu3S4pDgAAuBd5DwCAZzndpPft29dx4ph+/fqVVj0AAMCDyHsAADzL6Sb997u8sfsbAADlE3kPAIBnFes66QAAAAAAwPWc/ia9SpUq1z0u7ffOnTtX7IIAAIDnkPcAAHiW0016YmJiKZYBAACMgLwHAMCznG7ShwwZUpp1AAAAAyDvAQDwLKeb9PT0dIWEhDh+v568+QAAQNlC3gMA4FlFOib9xIkTqlGjhipXrlzo8Wp2u10mk0m5ubkuLRIAALgHeQ8AgGc53aR/8cUXqlq1qiTpyy+/LLWCAACA55D3AAB4ltNN+i233FLo7wAAoPwg7wEA8Cynm/Q/On/+vN544w0lJydLkmJiYjRs2DDHp+8AAKDsI+8BAHAvc3EW2rx5syIjIzVv3jydP39e58+f17x581SvXj1t3rzZ1TUCAAAPIO8BAHC/Yn2TPnLkSA0YMECvvPKKfHx8JEm5ubkaMWKERo4cqX379rm0SAAA4H7kPQAA7lesb9IPHTqk0aNHOwJbknx8fJSQkKBDhw65rDgAAOA55D0AAO5XrCa9VatWjmPTfi85OVnNmzcvcVEAAMDzyHsAANzP6d3dv/vuO8fvjz/+uOLj43Xo0CF16NBBkvT1119r4cKFmjlzpuurBAAAbkHeAwDgWU436S1atJDJZJLdbndMGzt2bIH5Bg0apAEDBrimOgAA4FbkPQAAnuV0k/7zzz+XZh0AAMAAyHsAADzL6Sb9pptuKs06AACAAZD3AAB4VrEuwZZn//79Sk1NVXZ2dr7p//d//1eiogAAgHGQ9wAAuE+xmvSffvpJd911l/bt25fvuDWTySTp6jVUAQBA2UbeAwDgfsW6BFt8fLzq1aun06dPKygoSD/88IM2b96sNm3aaOPGjS4uEQAAeAJ5DwCA+xXrm/Rt27bpiy++UGhoqMxms8xms26++WbNmDFDjz/+uL799ltX1wkAANyMvAcAwP2K9U16bm6uKlasKEkKDQ3V8ePHJV092UxKSorrqgMAAB5D3gMA4H7F+ia9SZMm2rt3r+rVq6f27dvrhRdekL+/v1599VXVr1/f1TUCAAAPIO8BAHC/YjXpEyZM0OXLlyVJ06ZN05133qnOnTurWrVqWr16tUsLBAAAnkHeAwDgfsVq0nv27On4vUGDBjpw4IDOnTunKlWqOM74CgAAyjbyHgAA9yvRddIl6ejRo5Kk8PDwEhcDAACMibwHAMA9inXiuJycHE2cOFGVKlVSZGSkIiMjValSJU2YMEFWq9XVNQIAAA8g7wEAcL9ifZP+2GOP6f3339cLL7yg2NhYSVcv0zJlyhSdPXtWr7zyikuLBAAA7kfeAwDgfsVq0lesWKFVq1bpjjvucExr1qyZwsPDNXDgQEIbAIBygLwHAMD9irW7e0BAgCIjIwtMr1evnvz9/UtaEwAAMADyHgAA9ytWkx4XF6fp06crKyvLMS0rK0vPPvus4uLiXFYcAADwHPIeAAD3c3p397vvvjvf7c8//1x169ZV8+bNJUl79+5Vdna2br/9dtdWCAAA3Ia8BwDAs5xu0itVqpTv9j333JPvNpdkAQCg7CPvAQDwLKeb9CVLlpRmHQAAwADIewAAPKtYx6TnOXPmjLZs2aItW7bozJkzxV7PwoULFRkZqcDAQLVv3147duxwarlVq1bJZDKpX79+xR4bAABcnyvynqwHAMA5xWrSL1++rIceekhhYWHq0qWLunTpotq1a+vhhx9WRkZGkda1evVqJSQkaPLkydq9e7eaN2+unj176vTp09dd7siRIxozZow6d+5cnIcAAABuwFV5T9YDAOC8YjXpCQkJ2rRpkz744ANduHBBFy5c0H//+19t2rRJo0ePLtK6Zs+ereHDh2vYsGGKiYnRokWLFBQUpMWLF19zmdzcXN1///2aOnWq6tevX5yHAAAAbsBVeU/WAwDgPKePSf+99957T++++666du3qmNa7d29ZLBb1799fr7zyilPryc7O1q5duzR+/HjHNLPZrG7dumnbtm3XXG7atGmqUaOGHn74YX311VfXHSMrKyvfpWPS09MlSVarVVar1ak6jSCv1rJUc2lgO/yGbXEV2+EqtsNVZXU7GLVeV+S9O7JeKt28t9lsslgs8jNLviZbidZlVP4+JlksFsk3QFb5lfp4eWO4Y6w8dh9/WSwW+fv4y9derD+BDc/P5CeLxSKbzWbY9xWUnrKagd6iKP8vxXqHysjIUM2aNQtMr1GjRpF2f0tLS1Nubm6BddWsWVMHDhwodJktW7bojTfe0J49e5waY8aMGZo6dWqB6Z999pmCgoKcrtUo1q9f7+kSDIHt8Bu2xVVsh6vYDleVte1Q1EPF3MUVee+OrJdKP+9Xrlz5/39LK/G6DKlGbT3e+epj/NiNw66vcr/7Busgrezw/3/Puu6cZVddafDKwTp27JiOHTvm6WrgIWUtA71FUbK+WE16bGysJk+erGXLlikwMFCSlJmZqalTpyo2NrY4q3TKr7/+qgcffFCvvfaaQkNDnVpm/PjxSkhIcNxOT09XeHi4evTooZCQkNIq1eWsVqvWr1+v7t27y8/PfZ86Gw3b4Tdsi6vYDlexHa4qq9sh71tfo/FE3hcn66XSzfu9e/eqS5cuunXMy6oSHlWidRnViZTvtO3l0XptWDP1bxtW6uNZ5af1Ve5X9/PL5Sf3fOu3LeWEes39Th1HdVT9LuXzEIqzh8/qk//H3p3HN1Wn/f9/J11T2gJSdloLUqAMS5GlFBUR2WTkFlcEFYoOODd0brBu4E82N1AUioKiMoA4LO4M4wJiR0ShsoMopQKKZdjLVqChTZv8/uBLxtgWuqQ5p+3r+Xjk0eZsn+uc5OTKlfM55zz+hdauXav27dsbHQ58rLLmwOqiNLm+TEV6SkqK+vXrpyZNmrg/AHbs2KHg4GCtWrWqxMuJiIiQn5+fjh496jH86NGjatCgQaHp9+3bp/3792vAgAHuYU7nxW5n/v7+ysjI0DXXXOMxT1BQkIKCggotKyAgoFK+eStr3N7GdvgvtsVFbIeL2A4XVbbtYNZYvZHvfZHrpYrN91arVXa7XQ6nlO8q141xTCuvwCW73S7l5/qsaJakADl81p6lIE92u115BXnKt+T7pE1fc7gcstvtslqtpv1cQcWrbDmwuijNa1KmIr1t27bas2ePFi9e7O6qNnjwYN13330Xz2cqocDAQHXs2FGpqanuW6s4nU6lpqYqKSmp0PStWrXSzp07PYY9/fTTOnv2rGbNmqXIyMiyrA4AACiCN/I9uR4AgNIpdZHucDjUqlUrffrppxoxYkS5A0hOTtawYcPUqVMndenSRSkpKTp//ryGDx8uSRo6dKgaN26sqVOnKjg4WG3atPGYv1atWpJUaDgAACg7b+Z7cj0AACVX6iI9ICBAFy5c8FoAgwYN0vHjxzVx4kQdOXJEcXFxWrlypfsCM5mZmbJaq2bXMgAAzMqb+Z5cDwBAyZWpu/vo0aP14osvat68efL3L/8tLJKSkors8iZJa9asuey8CxcuLHf7AACgMG/me3I9AAAlU6aMu2nTJqWmpurLL79U27ZtVaNGDY/xH3/8sVeCAwAAxiHfAwDge2Uq0mvVqqU777zT27EAAAATId8DAOB7pSrSnU6npk+frp9//ll5eXnq2bOnJk+eXKorugMAAHMj3wMAYJxSXaXl+eef11NPPaXQ0FA1btxYr776qkaPHl1RsQEAAAOQ7wEAME6pivRFixbp9ddf16pVq7R8+XL961//0uLFi+V0OisqPgAA4GPkewAAjFOqIj0zM1P9+/d3P+/Vq5csFosOHTrk9cAAAIAxyPcAABinVEV6fn6+goODPYYFBATI4XB4NSgAAGAc8j0AAMYp1YXjXC6XEhMTFRQU5B524cIF/fWvf/W4LQu3ZAEAoPIi3wMAYJxSFenDhg0rNOz+++/3WjAAAMB45HsAAIxTqiJ9wYIFFRUHAAAwCfI9AADGKdU56QAAAAAAoOJQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgEn4Gx0AAAAAAFQ1mZmZysrK8ll7TqdTkrRjxw5Zrb45Fpubm6ugoCCftGWUiIgIRUVF+bRNinQAqGDeSNJGJAgAAFA2mZmZim3VUjn2Cz5r02azaenSperevbvsdrtP2rRaJKfLJ00ZxhZi0+703T79HkaRDgAVKDMzU61axcpuzynXcmy2EO3enU6hDgBAJZCVlaUc+wX9Y2ScYhuG+qRNpzVQByWtHZcgqzOvwtvb+stxjXg3Qx2GdlCTzk0qvD0jnDlwRmtfWqusrCyKdACoKrKysmS35yj+wUkKbxhdpmVkH96vDfOn+DxBAACA8oltGKpro2v6pC2HAnRQUvuocAXIUeHtnc85L0kKbRCqiJiICm+vOqFIB1AhvHUeVlXp5h3eMFpXRbU0OgwAAACYHEU6AK/zVhdviW7eAAAAqF4o0gF4nTe6eEt08wYAAED1Q5EOoMLQxRsAAAAoHd/cQA8AAAAAAFwRRToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEv5GBwD8XmZmprKysood73Q6JUk7duyQ1Vr8b0y5ubkKCgoqdzwRERGKiooq93IAb0hPTy92XEn3Dd7TAAAA5kaRDtPIzMxUbKuWyrFfKHYam82mpUuXqnv37rLb7cVOZ7VITlf5Y7KF2LQ7fTdFDQzlyM2TJN1///3FTlPSfSPEFqz03Rm8pwEAAEzKFEX6nDlzNH36dB05ckTt27fXa6+9pi5duhQ57dtvv61Fixbpxx9/lCR17NhRL7zwQrHTo/LIyspSjv2C/jEyTrENQ4ucxmkN1EFJa8clyOrMK3Karb8c14h3M9RhaAc16dykzPGcOXBGa19aq6ysLAoaGCo/P1+S9OwdLdS/bb0ipynJvpF++Jzuf2s772kYglwPAEDJGF6kv/fee0pOTtbcuXMVHx+vlJQU9e3bVxkZGapXr/CX0TVr1mjw4MHq1q2bgoOD9eKLL6pPnz766aef1LhxYwPWAN4W2zBU10bXLHKcQwE6KKl9VLgC5ChymvM55yVJoQ1CFRETUVFhFutKXfZLim7J+KOmESHl2jcAo5DrAQAoOcOL9BkzZmjEiBEaPny4JGnu3Ln67LPPNH/+fI0bN67Q9IsXL/Z4Pm/ePH300UdKTU3V0KFDfRIzUJzMzEy1ahUruz2n3MsKDrbpww8/UMOGDYscX5JzkDk3H4AZkOsBACg5Q4v0vLw8bdmyRePHj3cPs1qt6tWrl9LS0kq0jJycHDkcDl111VVFjs/NzVVubq77eXZ2tiTJ4XDI4ag8R5suxVqZYi4tp9Mpm80mpzVQDgUUOc2l4cWNlySXX6BsNpsC/QLl7yr7WzzAEnAxHqezxNv92LFjkly6YeQUhdUve1F76j/7tH3ZK7r77ruLncZms2n+/Pnq27dvsecge/Pc/M2bNqtJk5KdPnDptQywSv4WZ5nbDbDqiq+B2fcNb2yLQD+LbDab5B9Urn3DaQ0s9Xu6sjH7+6E4lS3e0vBFrpcqNt976zPNzEryOeNNJfnM8jZvfT8ws7J8d0HFKMn3Wm/z9X7FPlU6pZnf4nK5vPAVvmwOHTqkxo0ba/369UpISHAPf+KJJ/TNN99ow4YNV1zGqFGjtGrVKv30008KDg4uNH7y5MmaMmVKoeFLlixRSEhI+VYAAAAvyMnJ0ZAhQ3TmzBmFh4cbHY5X+SLXS+R7AIC5lSbXV+qfPKZNm6Zly5ZpzZo1xSbt8ePHKzk52f08OztbkZGR6tOnT6X6IuRwOLR69Wr17t1bAQG++9XZl3bs2KHu3btr7bgEtY8q+rVxKECra9+n3qcWF3vebVrGYfWb9YO6je2mZt2blTmeE/tO6IvHv9DatWvVvn37Uq3DTY+9rtqRMWVu+3DGD0p7/VG9Pbyd7ulcdHf3K22LqrAdTh3Yo69fHnXZts2+b3hjW3jj/SBJG/cdV+9XtpYphj8qbe8KXzH7+6E4l476orCS5HqpYvO9tz7TzKwknzPeVJLPLG/zVl40s7LkbFSMknyv9TZf71fsU6VTmlxvaJEeEREhPz8/HT161GP40aNH1aBBg8vO+/LLL2vatGn66quv1K5du2KnCwoKKvKc3ICAgEr1Be6Syhp3SVitVtntdlmdeVf8YAmQo9hpLAV5stvtyivIU74lv8zxOFyOi/FYrSXe5pfWweGU8l3F36v6SvIKXBe7sOfnlnlbVIXt4HCqxG2bdd/wxrbwxvtBkpy5ObLb7V6788GpU6fUtGnTMi+nIpn1/VCcyhRrafki10sVm++99ZlmZqX5nPGmy31meZu38qKZlSVno2KU5nutt/lqv2KfKp3SzG9okR4YGKiOHTsqNTVVAwcOlHTx/I3U1FQlJSUVO99LL72k559/XqtWrVKnTp18FC0AVA1G3fkA1RO5HgCA0jG8u3tycrKGDRumTp06qUuXLkpJSdH58+fdV4AdOnSoGjdurKlTp0qSXnzxRU2cOFFLlixRdHS0jhw5IkkKDQ1VaGjR99YGAFQNV7rFYUnueiBx5wNfI9cDAFByhhfpgwYN0vHjxzVx4kQdOXJEcXFxWrlyperXry/p4hey33/ReuONN5SXl6e77rrLYzmTJk3S5MmTfRk6AMCHMjMzFduqpXLsF4qdxmazaenSperevXuxdz2QvHvng93puynUr4BcDwBAyRlepEtSUlJSsV3e1qxZ4/F8//79FR8QAFNJT08vdlxJj5xyxLPyy8rKUo79gv4xMk6xDYs+muq0BuqgpLXjEmR15hU5zdZfjmvEuxleOzc/KyuL91YJkOsBACgZUxTpAFAUR+7FIuv+++8vdpqSHjkNsQUrfXcGxVQVENswVNdG1yxynEMBOiipfVR4sRfNOZ9zXhLn5gMAAHOiSAdgWvn5F68U+uwdLdS/bb0ipynJkdP0w+d0/1vbOeIJAAAA06NIB2B6TSNCynXkFAAAAKgsqubNPgEAAAAAqIQo0gEAAAAAMAmKdAAAAAAATIIiHQAAAAAAk6BIBwAAAADAJCjSAQAAAAAwCYp0AAAAAABMgiIdAAAAAACToEgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCIh0AAAAAAJOgSAcAAAAAwCQo0gEAAAAAMAmKdAAAAAAATIIiHQAAAAAAk6BIBwAAAADAJCjSAQAAAAAwCYp0AAAAAABMwt/oAAAAAABUL5mZmcrKyjI6jAqTnp5udAioxCjSAVQb5U2YERERioqK8lI0AABUT5mZmWrVKlZ2e47RoVQwiw6fuSCpptGBoJKhSIfXlPcXUX5xREXJzcuVJN1///3lWo4txKbd6bsp1MuIzwgAgCRlZWXJbs9R/IOTFN4w2uhwKsTxX3dr+5IXdTon3+hQUAlRpMMrvPeLKL84wvvy8y8myA5DO6hJ5yZlWsaZA2e09qW1ysrKokgvAz4jAAB/FN4wWldFtTQ6jAphP1/VewmgIlGkwyu88YsovziiooU2CFVETITRYVRLfEYAAACUDEV6FeONi3CU57zb8vwiyi+OQNXHZwQAAMDlUaRXIZmZmWoV20r2HHu5lsN5twAAAABgDIr0KiQrK0v2HLu6P9FdNSPLdr4m590CAAAAgHEo0qugmpE1Oe8WAAAAACohq9EBAAAAAACAiyjSAQAAAAAwCYp0AAAAAABMgiIdAAAAAACToEgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCIh0AAAAAAJOgSAcAAAAAwCQo0gEAAAAAMAmKdAAAAAAATIIiHQAAAAAAk6BIBwAAAADAJCjSAQAAAAAwCYp0AAAAAABMgiIdAAAAAACToEgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCIh0AAAAAAJOgSAcAAAAAwCQo0gEAAAAAMAlTFOlz5sxRdHS0goODFR8fr40bN152+g8++ECtWrVScHCw2rZtq88//9xHkQIAgLIg1wMAUDKGF+nvvfeekpOTNWnSJG3dulXt27dX3759dezYsSKnX79+vQYPHqyHHnpI27Zt08CBAzVw4ED9+OOPPo4cAACUBLkeAICSM7xInzFjhkaMGKHhw4erdevWmjt3rkJCQjR//vwip581a5b69eunxx9/XLGxsXr22Wd17bXXavbs2T6OHAAAlAS5HgCAkvM3svG8vDxt2bJF48ePdw+zWq3q1auX0tLSipwnLS1NycnJHsP69u2r5cuXFzl9bm6ucnNz3c/PnDkjSTp58qQcDkc510A6duyYjh49Wu7lWK1WOZ3OYsc7nU7l5OTo22+/ldVa9G8re/bsUXBwsM7+ela6ULY4zh4+q+DgYGVnZ+vEiRMlni87O1vBwcE6d/BnyWEvU9v2I78oODhYGVl5WvPz2SKncVoDlfOnHH2795yszrwip/nxUJ6Cg4OVcyhHWTuzyhSLVLZt4Y3tIHlnW7Ad/ssb24J947+Mek9Uhe1Q7LLOXlwfl8tVruWYkS9yvVSx+d5bn2lmVpL9y5tKsq96m7f2fTPz5udSRWKfqhi+3q/Yp0q5rNLkepeBDh486JLkWr9+vcfwxx9/3NWlS5ci5wkICHAtWbLEY9icOXNc9erVK3L6SZMmuSTx4MGDBw8epn8cOHDAOwnWRHyR610u8j0PHjx48Kgcj5LkekOPpPvC+PHjPX6NdzqdOnnypOrUqSOLxWJgZKWTnZ2tyMhIHThwQOHh4UaHYxi2w3+xLS5iO1zEdriosm4Hl8uls2fPqlGjRkaHUmlVlXxfXVTWfRUwM/YrcytNrje0SI+IiJCfn1+h7uJHjx5VgwYNipynQYMGpZo+KChIQUFBHsNq1apV9qANFh4ezk4ntsPvsS0uYjtcxHa4qDJuh5o1axodQoXwRa6Xql6+ry4q474KmB37lXmVNNcbeuG4wMBAdezYUampqe5hTqdTqampSkhIKHKehIQEj+klafXq1cVODwAAjEOuBwCgdAzv7p6cnKxhw4apU6dO6tKli1JSUnT+/HkNHz5ckjR06FA1btxYU6dOlSSNGTNGN954o1555RX9+c9/1rJly7R582a99dZbRq4GAAAoBrkeAICSM7xIHzRokI4fP66JEyfqyJEjiouL08qVK1W/fn1JUmZmpsfVzLt166YlS5bo6aef1lNPPaWYmBgtX75cbdq0MWoVfCIoKEiTJk0q1JWvumE7/Bfb4iK2w0Vsh4vYDuZErscfsa8C3sd+VXVYXK4qeL8XAAAAAAAqIUPPSQcAAAAAAP9FkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRXgnMmTNH0dHRCg4OVnx8vDZu3Gh0SD63du1aDRgwQI0aNZLFYtHy5cuNDskQU6dOVefOnRUWFqZ69epp4MCBysjIMDosn3vjjTfUrl07hYeHKzw8XAkJCfriiy+MDstw06ZNk8Vi0dixY40OxecmT54si8Xi8WjVqpXRYQEoBt9tAO/he3LVQ5Fucu+9956Sk5M1adIkbd26Ve3bt1ffvn117Ngxo0PzqfPnz6t9+/aaM2eO0aEY6ptvvtHo0aP1/fffa/Xq1XI4HOrTp4/Onz9vdGg+1aRJE02bNk1btmzR5s2b1bNnT91222366aefjA7NMJs2bdKbb76pdu3aGR2KYf70pz/p8OHD7sd3331ndEgAisB3G8C7+J5c9XCfdJOLj49X586dNXv2bEmS0+lUZGSk/va3v2ncuHEGR2cMi8WiTz75RAMHDjQ6FMMdP35c9erV0zfffKPu3bsbHY6hrrrqKk2fPl0PPfSQ0aH43Llz53Tttdfq9ddf13PPPae4uDilpKQYHZZPTZ48WcuXL9f27duNDgXAFfDdBqg4fE+uGjiSbmJ5eXnasmWLevXq5R5mtVrVq1cvpaWlGRgZzOLMmTOSLhao1VVBQYGWLVum8+fPKyEhwehwDDF69Gj9+c9/9visqI727NmjRo0aqVmzZrrvvvuUmZlpdEgA/oDvNgBwZf5GB4DiZWVlqaCgQPXr1/cYXr9+fe3evdugqGAWTqdTY8eO1XXXXac2bdoYHY7P7dy5UwkJCbpw4YJCQ0P1ySefqHXr1kaH5XPLli3T1q1btWnTJqNDMVR8fLwWLlyoli1b6vDhw5oyZYpuuOEG/fjjjwoLCzM6PAD/D99tAODKKNKBSmr06NH68ccfq+15ty1bttT27dt15swZffjhhxo2bJi++eabalWoHzhwQGPGjNHq1asVHBxsdDiGuuWWW9z/t2vXTvHx8br66qv1/vvvV8tTIAAAQOVFkW5iERER8vPz09GjRz2GHz16VA0aNDAoKphBUlKSPv30U61du1ZNmjQxOhxDBAYGqnnz5pKkjh07atOmTZo1a5befPNNgyPznS1btujYsWO69tpr3cMKCgq0du1azZ49W7m5ufLz8zMwQuPUqlVLLVq00N69e40OBcDv8N0GAK6Mc9JNLDAwUB07dlRqaqp7mNPpVGpqarU997a6c7lcSkpK0ieffKJ///vfatq0qdEhmYbT6VRubq7RYfjUzTffrJ07d2r79u3uR6dOnXTfffdp+/bt1bZAly5eTG/fvn1q2LCh0aEA+B2+2wDAlXEk3eSSk5M1bNgwderUSV26dFFKSorOnz+v4cOHGx2aT507d87jiNivv/6q7du366qrrlJUVJSBkfnW6NGjtWTJEv3zn/9UWFiYjhw5IkmqWbOmbDabwdH5zvjx43XLLbcoKipKZ8+e1ZIlS7RmzRqtWrXK6NB8KiwsrND1CGrUqKE6depUu+sUPPbYYxowYICuvvpqHTp0SJMmTZKfn58GDx5sdGgA/oDvNoB38T256qFIN7lBgwbp+PHjmjhxoo4cOaK4uDitXLmy0AVXqrrNmzfrpptucj9PTk6WJA0bNkwLFy40KCrfe+ONNyRJPXr08Bi+YMECJSYm+j4ggxw7dkxDhw7V4cOHVbNmTbVr106rVq1S7969jQ4NBvnPf/6jwYMH68SJE6pbt66uv/56ff/996pbt67RoQH4A77bAN7F9+Sqh/ukAwAAAABgEpyTDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAABQSfTo0UNjx44tdnx0dLRSUlJ8Fg8A76NIB1Bh9u/fL4vFou3btxsdCgAA1cKmTZs0cuRIo8MokQ8++ECtWrVScHCw2rZtq88//9zokABToEgHYLi8vDyjQwAAoEqoW7euQkJCKrQNb+Tt9evXa/DgwXrooYe0bds2DRw4UAMHDtSPP/7ohQiByo0iHajCnE6nXnrpJTVv3lxBQUGKiorS888/L0nauXOnevbsKZvNpjp16mjkyJE6d+6ce96iutMNHDhQiYmJ7ufR0dF64YUX9OCDDyosLExRUVF666233OObNm0qSerQoYMsFot69OghSUpMTNTAgQP1/PPPq1GjRmrZsqWeeeYZtWnTptA6xMXFacKECV7aIgAAVH75+flKSkpSzZo1FRERoQkTJsjlckkq3N3dYrFo3rx5uv322xUSEqKYmBitWLHCPb6goEAPPfSQmjZtKpvNppYtW2rWrFke7VVE3p41a5b69eunxx9/XLGxsXr22Wd17bXXavbs2WXcKkDVQZEOVGHjx4/XtGnTNGHCBO3atUtLlixR/fr1df78efXt21e1a9fWpk2b9MEHH+irr75SUlJSqdt45ZVX1KlTJ23btk2jRo3S//7v/yojI0OStHHjRknSV199pcOHD+vjjz92z5eamqqMjAytXr1an376qR588EGlp6dr06ZN7mm2bdumH374QcOHDy/nlgAAoOp455135O/vr40bN2rWrFmaMWOG5s2bV+z0U6ZM0T333KMffvhB/fv313333aeTJ09KuviDfpMmTfTBBx9o165dmjhxop566im9//77Hsvwdt5OS0tTr169PIb17dtXaWlppdkUQJXkb3QAACrG2bNnNWvWLM2ePVvDhg2TJF1zzTW6/vrr9fbbb+vChQtatGiRatSoIUmaPXu2BgwYoBdffFH169cvcTv9+/fXqFGjJElPPvmkZs6cqa+//lotW7ZU3bp1JUl16tRRgwYNPOarUaOG5s2bp8DAQPewvn37asGCBercubMkacGCBbrxxhvVrFmzsm8IAACqmMjISM2cOVMWi0UtW7bUzp07NXPmTI0YMaLI6RMTEzV48GBJ0gsvvKBXX31VGzduVL9+/RQQEKApU6a4p23atKnS0tL0/vvv65577nEP93bePnLkSKHvG/Xr19eRI0dKviGAKooj6UAVlZ6ertzcXN18881Fjmvfvr27QJek6667Tk6n030UvKTatWvn/t9isahBgwY6duzYFedr27atR6KXpBEjRmjp0qW6cOGC8vLytGTJEj344IOligcAgKqua9euslgs7ucJCQnas2ePCgoKipz+97m6Ro0aCg8P98jVc+bMUceOHVW3bl2FhobqrbfeUmZmpscyyNuA73AkHaiibDZbuea3Wq3u89sucTgchaYLCAjweG6xWOR0Oq+4/N//QHDJgAEDFBQUpE8++USBgYFyOBy66667Shk5AAD4vcvl6mXLlumxxx7TK6+8ooSEBIWFhWn69OnasGGDxzzeztsNGjTQ0aNHPYYdPXq0UM87oDriSDpQRcXExMhmsyk1NbXQuNjYWO3YsUPnz593D1u3bp2sVqtatmwp6eLVYQ8fPuweX1BQUOorrl76xb24X/b/yN/fX8OGDdOCBQu0YMEC3XvvveX+sQEAgKrmjwX0999/r5iYGPn5+ZV6WevWrVO3bt00atQodejQQc2bN9e+fftKNG958nZCQkKh7yirV69WQkJCqdcBqGo4kg5UUcHBwXryySf1xBNPKDAwUNddd52OHz+un376Sffdd58mTZqkYcOGafLkyTp+/Lj+9re/6YEHHnCfH9azZ08lJyfrs88+0zXXXKMZM2bo9OnTpYqhXr16stlsWrlypZo0aaLg4GDVrFnzsvP85S9/UWxsrKSLXxwAAICnzMxMJScn6+GHH9bWrVv12muv6ZVXXinTsmJiYrRo0SKtWrVKTZs21bvvvqtNmza579ByJWXN22PGjNGNN96oV155RX/+85+1bNkybd682eMuMUB1xZF0oAqbMGGCHn30UU2cOFGxsbEaNGiQjh07ppCQEK1atUonT55U586dddddd+nmm2/2uO3Jgw8+qGHDhmno0KHui8DcdNNNpWrf399fr776qt588001atRIt9122xXniYmJUbdu3dSqVSvFx8eXep0BAKjqhg4dKrvdri5dumj06NEaM2aMRo4cWaZlPfzww7rjjjs0aNAgxcfH68SJE+4LwpZEWfN2t27dtGTJEr311ltq3769PvzwQy1fvrzI27oB1Y3F9ceTTgHAQC6XSzExMRo1apSSk5ONDgcAAFwGeRvwPrq7AzCN48ePa9myZTpy5Aj3RgcAwOTI20DFoEgHYBr16tVTRESE3nrrLdWuXdvocAAAwGVcLm+HhoYWO98XX3yhG264oaLDAyotursDAAAA8Kq9e/cWO65x48bcvQW4DIp0AAAAAABMgqu7AwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYhL/RAfia0+nUoUOHFBYWJovFYnQ4AADI5XLp7NmzatSokaxWfj/3BvI9AMBMSpPrq12RfujQIUVGRhodBgAAhRw4cEBNmjQxOowqgXwPADCjkuT6alekh4WFSbq4ccLDww2OBkVxOBz68ssv1adPHwUEBBgdDlDpsU+ZX3Z2tiIjI905CuVHvjc3PpcA72O/MrfS5PpqV6Rf6vIWHh5O0jYph8OhkJAQhYeH8wEDeAH7VOVBt2zvId+bG59LgPexX1UOJcn1nPgGAAAAAIBJUKQDAAAAAGASFOkAAAAAAJhEtTsnHUD15XK5lJ+fr4KCAqND8SmHwyF/f39duHCh2q27Wfj5+cnf359zzgGgglXXXC+R780gICBAfn5+5V4ORTqAaiEvL0+HDx9WTk6O0aH4nMvlUoMGDXTgwAGKRAOFhISoYcOGCgwMNDoUAKiSqnOul8j3ZmCxWNSkSROFhoaWazkU6QCqPKfTqV9//VV+fn5q1KiRAgMDq1XycjqdOnfunEJDQ2W1cpaTr7lcLuXl5en48eP69ddfFRMTw+sAAF5W3XO9RL43msvl0vHjx/Wf//xHMTEx5TqiTpEOoMrLy8uT0+lUZGSkQkJCjA7H55xOp/Ly8hQcHEzSNojNZlNAQIB+++0392sBAPCe6p7rJfK9GdStW1f79++Xw+EoV5HOqweg2iBhwUi8/wCg4vFZCyN5q/cG72IAAAAAAEyCIh0AAAAAAJOgSAcAXFaPHj00duxY0ywHAAB4H/nePLhwHADAq9asWaObbrpJp06dUq1atdzDP/74YwUEBBgXGAAA8BryfcWhSAcA+MRVV11ldAgAAKCCke/Lj+7uAGBSPXr0UFJSkpKSklSzZk1FRERowoQJcrlckqRTp05p6NChql27tkJCQnTLLbdoz5497vkXLlyoWrVqafny5erYsaNCQkLUt29fHThwwD1NYmKiBg4c6NHu2LFj1aNHj2Ljevfdd9WpUyeFhYWpQYMGGjJkiI4dOyZJ2r9/v2666SZJUu3atWWxWJSYmOhen993fytp/KtWrVJsbKxCQ0PVr18/HT58uCybEwAAUyLfk+//iCIdAEzsnXfekb+/vzZu3KhZs2ZpxowZmjdvnqSLCXfz5s1asWKF0tLS5HK51L9/fzkcDvf8OTk5mjp1qt544w19++23On36tO69995yxeRwOPTss89qx44dWr58ufbv3+9OzJGRkfroo48kSRkZGTp8+LBmzZpV5HJKGv/LL7+sd999V2vXrlVmZqYee+yxcsUPAIDZkO/J979Hd3cAMLHIyEjNnDlTFotFLVu21M6dOzVz5kz16NFDK1as0Lp169StWzdJ0uLFixUZGanly5fr7rvvlnQxwb766quKjY1VeHi43nnnHcXGxmrjxo3q0qVLmWJ68MEH3f83a9ZMr776qjp37qxz584pNDTU3c2tXr16Hueo/d6ePXtKHP/cuXN1zTXXSJKSkpL0zDPPlCluAADMinxPvv89jqQDgIl17dpVFovF/TwhIUF79uzRrl275O/vr/j4ePe4OnXqqGXLlkpPT3cP8/f3V+fOnd3PW7VqpVq1anlMU1pbtmzRgAEDFBUVpbCwMN14442SpMzMzBIvIz09vUTxh4SEuBO2JDVs2NDd1Q4AgKqCfE++/z2KdACoxqxWq/uct0t+3/3sj86fP6++ffsqPDxcixcv1qZNm/TJJ59IkvLy8rwe3x+vDmuxWArFCwAALo98X7lQpAOAiW3YsMHj+ffff6+YmBi1bt1a+fn5HuNPnDihjIwMtW7d2j0sPz9fmzdvdj/PyMjQ6dOnFRsbK0mqW7duoQuzbN++vdh4du/erRMnTmjatGm64YYb1KpVq0K/dAcGBkqSCgoKil1ObGxsieIHAKA6IN/j9yjSAcDEMjMzlZycrIyMDC1dulSvvfaaxowZo5iYGN12220aMWKEvvvuO+3YsUP333+/GjdurNtuu809f0BAgMaMGaPNmzdry5YtSkxMVNeuXd3np/Xs2VObN2/WokWLtGfPHk2aNEk//vhjsfFERUUpMDBQr732mn755RetWLFCzz77rMc0V199tSwWiz799FMdP35c586dK7ScksYPAEB1QL7H71GkA4CJDR06VHa7XV26dNHo0aM1ZswYjRw5UpK0YMECdezYUbfeeqsSEhLkcrn0+eefe3QZCwkJ0eOPP64RI0bohhtuUGhoqN577z33+L59+2rChAl64okn1LlzZ509e1ZDhw4tNp66detq4cKF+uCDD9S6dWtNmzZNL7/8ssc0jRs31pQpUzRu3DjVr19fSUlJRS6rJPEDAFAdkO/xexZXNevsn52drZo1a+rMmTMKDw83OhwUweFw6PPPP1f//v3ZeeEVFy5c0K+//qqmTZsqODjY6HBKrEePHoqLi1NKSkqZ5l+4cKHGjh2rkydPKjs7W+Hh4bJa+W3WKJd7H5KbvI9tam7kenhbZc31Evm+KvFWrufVAwAAAADAJCjSAQAAAAAwCX+jAwAAFG3NmjXlmj8xMVGJiYlyOp3eCQgAAHgd+R5/xJF0AAAAAABMgiIdAAAAAACToEgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCq7sDqNYyMzOVlZXls/YiIiIUFRXls/YAAKjuyPWobCjSAVRbmZmZatUqVnZ7js/atNlCtHt3uumSd3R0tMaOHauxY8cWO01eXp5at26tRYsWqVu3br4LzgQsFos++eQTDRw4sMjxu3btUp8+fZSRkaEaNWr4NjgAQLHI9f9Frr88M+V6inQA1VZWVpbs9hzFPzhJ4Q2jK7y97MP7tWH+FGVlZZkucZfE3Llz1bRp00qdtPfv36+mTZtq27ZtiouL89pyW7dura5du2rGjBmaMGGC15YLACgfcn3pkOuL58tcT5EOoNoLbxitq6JaGh2GqblcLs2ePVvPPPNMuZdTUFAgf/+ql36GDx+uESNGaPz48VVy/QCgMiPXXxm5/sp8leu5cBwAmFiPHj2UlJSkpKQk1axZUxEREZowYYJcLpd7mlOnTmno0KGqXbu2QkJCdMstt2jPnj0ey1mxYoXatm2roKAgRUdH65VXXilVHFu2bNG+ffv05z//2T1s//79slgsWrZsmbp166bg4GC1adNG33zzjXuaNWvWyGKx6IsvvlDHjh0VFBSk7777Tk6nU1OnTlXTpk1ls9nUvn17ffjhh4XmW7VqlTp06CCbzaaePXvq2LFj+uKLLxQbG6vw8HANGTJEOTn/7cK4cuVKXX/99apVq5bq1KmjW2+9Vfv27XOPb9q0qSSpQ4cOslgs6tGjh3vc/Pnz9ac//UlBQUFq2LChkpKSPLZBVlaWbr/9doWEhCgmJkYrVqzwGN+7d2+dPHnSY/0BALgSb+X6jz76SAkJCbLZbOR6Ve5cT5EOACb3zjvvyN/fXxs3btSsWbM0Y8YMzZs3zz0+MTFRmzdv1ooVK5SWliaXy6X+/fvL4XBIuph0hw8frkGDBmnnzp2aPHmyJkyYoIULF5Y4hm+//VYtWrRQWFhYoXGPP/64Hn30UW3btk0JCQkaMGCATpw44THNuHHjNG3aNKWnp6tdu3aaOnWqFi1apLlz5+qnn37SI488ovvvv79Q0ps8ebJmz56t9evX68CBA7rnnnuUkpKiJUuW6LPPPtOXX36p1157zT39+fPnlZycrM2bNys1NVVWq1W33367nE6nJGnjxo2SpK+++kqHDx/Wxx9/LEl64403NHr0aI0cOVI7d+7UihUr1Lx5c49YpkyZonvuuUc//PCD+vfvr/vuu08nT550jw8MDFRcXJy+/fbbEm9XAAAk7+T6e++9V3fccYd27NhBrlflzvVVrw8CAFQxkZGRmjlzpiwWi1q2bKmdO3dq5syZGjFihPbs2aMVK1Zo3bp17vPHFi9erMjISC1fvlx33323Zs6cqRtvvFFPP/20rFarWrRooV27dmn69OlKTEwsUQy//fabGjVqVOS4pKQk3XnnnZIuJsCVK1fq73//u5544gn3NM8884x69+4tScrNzdULL7ygr776SgkJCZKkZs2a6bvvvtObb76pG2+80T3fc889p+uuu06S9NBDD2n8+PHat2+fmjVrJkm666679PXXX+vJJ5+UJHccl8yfP19169bVrl271KZNG9WtW1eSVKdOHTVo0MCjnUcffVRjxoxxD+vcubPHshITEzV48GBJ0gsvvKBXX31VGzduVL9+/dzTNGrUSL/99tvlNyYAAH9Q3lw/Y8YM9ezZU48//rjCw8PVqlUrcn0lzvWGH0mfM2eOoqOjFRwcrPj4ePcvH8VJSUlRy5YtZbPZFBkZqUceeUQXLlzwUbQA4Htdu3aVxWJxP09ISNCePXtUUFCg9PR0+fv7Kz4+3j2+Tp06atmypdLT0yVJu3fv9hgvSdddd517GSVht9sVHBxc5LhLyVeS/P391alTJ3fbl3Tq1Mn9/969e5WTk6PevXsrNDTU/Vi0aJFHdzVJateunfv/+vXrKyQkxJ20Lw07duyY+/mePXs0ePBgNWvWTOHh4YqOjpZ08eq+xTl27JgOHTqkm2+++TJbwDOWGjVqKDw83KNtSbLZbB5d8vBf5HsAKF55c316erq70L2EXP9flS3XG3ok/b333lNycrLmzp2r+Ph4paSkqG/fvsrIyFC9evUKTb9kyRKNGzdO8+fPV7du3fTzzz8rMTFRFotFM2bMMGANAKB6iIiI0M6dO8s8/+9vVXLu3DlJ0meffabGjRt7TBcUFOTxPCAgwP2/xWLxeH5p2KXubZI0YMAAXX311Xr77bfVqFEjOZ1OtWnTRnl5ecXGZrPZSrQOV2pbkk6ePKlrrrmmRMurTsj3AGB+5Hrz5HpDj6TPmDFDI0aM0PDhw9W6dWvNnTtXISEhmj9/fpHTr1+/Xtddd52GDBmi6Oho9enTR4MHD77ir/EAUJlt2LDB4/n333+vmJgY+fn5KTY2Vvn5+R7TnDhxQhkZGWrdurUkqVWrVoWWsW7dOrVo0UJ+fn4liqFDhw7avXu3x0Vsfh/PJfn5+dqyZYtiY2OLXVbr1q0VFBSkzMxMNW/e3OMRGRlZoniKcmm9n376ad18882KjY3VqVOnPKYJDAyUJI+jCmFhYYqOjlZqamqZ277kxx9/VIcOHcq9nKqGfA8Al1feXB8bG6t169Z5LINcX3lzvWFH0vPy8rRlyxaNHz/ePcxqtapXr15KS0srcp5u3brpH//4hzZu3KguXbrol19+0eeff64HHnig2HZyc3OVm5vrfp6dnS1Jcjgc7gstwFwuvS68PvAWh8Mhl8slp9Pp8Wvopf+zD+2XCucjr8s+vN/d7h9/lb2czMxMPfLIIxo5cqS2bt2q1157TdOnT5fT6dQ111yj//mf/9GIESP0xhtvKCwsTOPHj1fjxo01YMAAOZ1OPfLII+rataueffZZDRo0SGlpaZo9e7Zmz57tEcelbVSUG2+8UefOndPOnTvVpk0b93pIF7sxX3PNNYqNjVVKSopOnTqlxMREj/X8/f81atTQo48+qkceeUT5+fm6/vrrdebMGa1fv15hYWEaNmxYkfP98e+lmC8Nq1mzpurUqaM333xT9evXV2Zmpp566imP5URERMhms+mLL75Qo0aNFBwcrJo1a2rixIkaNWqU6tatq379+uns2bNav369x1Vfi3rdfj9s//79OnjwoHr27FnkdnQ6nXK5XHI4HIW+MFXlzzvyPYpCroe3kesfUXx8vKZPn677779f33//Pbm+Eud6w4r0rKwsFRQUqH79+h7D69evr927dxc5z5AhQ5SVlaXrr79eLpdL+fn5+utf/+p+YYoydepUTZkypdDwL7/8UiEhIeVbCVSo1atXGx0Cqgh/f381aNBA586d8+gKFRQUpGCbTRsWFP6MqCjBNpuCgoLcBcSV5Ofna9CgQTpz5ozi4+Pl5+enhx9+WPfee697GbNmzdK4ceM0YMAAORwOdevWTcuWLZPdbpfdbldMTIwWLFigqVOn6vnnn1f9+vU1fvx43XHHHe5lOJ1OXbhwodi4AgICdOutt2rBggWaNGmSpP92ZZswYYKmTp2qnTt3qlmzZlqyZIkCAwOVnZ3tPmfr7Nmzslr/23nrscceU1hYmKZOnar9+/erZs2aat++vR555JFi57tw4YJcLpdHjLm5uSooKHAPmzdvnsaNG6d27dqpefPmevHFF3XrrbfKbre7p5k2bZpeeuklTZo0SQkJCfr00091++236/Tp05ozZ44ef/xx1alTR//zP//j0dbvlyFd/NLw+222cOFC9ezZU7Vr1y5yO+bl5clut2vt2rXKz8/3GFeVz2Mn3+NyyPXwluqe65s3b+7O9dOnTyfXV/Jcb3EV1Z/BBw4dOqTGjRtr/fr1HhcieOKJJ/TNN98U6vIhXbyX3r333qvnnntO8fHx2rt3r8aMGaMRI0ZowoQJRbZT1C/rkZGRysrKUnh4uPdXDOXmcDi0evVq9e7du9B5IUBZXLhwQQcOHHBftOr3MjMzlZWV5bNYIiIiFBUVVeLpe/bsqfbt22vmzJllbtPlcuns2bMKCwvzuChNaf3www/q27ev9uzZo9DQUO3fv1/XXHONtmzZori4uDIvtyrIy8tTy5Yt9Y9//KPQhXsuuXDhgvbv36/IyMhC78Ps7GxFRETozJkzVS43ke9RFHI9vK2653rJO/meXF88X+Z6w46kR0REyM/PT0ePHvUYfvToUY9L5f/ehAkT9MADD+gvf/mLJKlt27Y6f/68Ro4cqf/v//v/PH65uSQoKKjQxQmki78UkRTMjdcI3lJQUCCLxSKr1VrocyI6Otp9VVCzuhR7WV3qjlXe5cTFxenFF1/Ub7/9prZt27qXVdR2rW7+85//6KmnntINN9xQ7DRWq9V9QZw/frZV5c868j0uh9cH3lLdc73knXxPri+eL3O9YVs6MDBQHTt29Dh53+l0KjU11eOX9t/Lyckp9Oa41NffoA4BAFCtJCYmqm3btkaHYTrNmzfXww8/bHQYpkS+B4DKhVxfNF/mekNvwZacnKxhw4apU6dO6tKli1JSUnT+/HkNHz5ckjR06FA1btxYU6dOlXTxcvszZsxQhw4d3N3fJkyYoAEDBpT4qoUAUJmsWbPG6BCKFR0dTcGEEiHfA0DxyPX4I0OL9EGDBun48eOaOHGijhw5ori4OK1cudJ9cZnMzEyPX9KffvppWSwWPf300zp48KDq1q2rAQMG6PnnnzdqFQAAwBWQ7wEAKDnDLhxnlOzsbNWsWbNKXpynqnA4HPr888/Vv39/zlODV1y4cEG//vqrmjZtWugiHtWB0+lUdna2wsPDq/35ZEa63PuQ3OR9bFNzI9fD26p7rpfI92bgrVzPqwcAAAAAgElQpAMAAAAAYBIU6QAAAAAAmIShF44DAKNlZmYqKyvLZ+1FREQoKirKZ+0BAFDdketR2VCkA6i2MjMzFduqpXLsF3zWZogtWOm7M0yVvKOjozV27FiNHTvW6FAAAPAqcv1F5PrKhSIdQLWVlZWlHPsF/WNknGIbhlZ4e+mHz+n+t7YrKyvLVIkbAICqilyPyogiHUC1F9swVNdG1zQ6DAAAUEHI9ahMuHAcAJhYjx49lJSUpKSkJNWsWVMRERGaMGGCXC6XJOnUqVMaOnSoateurZCQEN1yyy3as2ePxzI++ugjJSQkyGazKTo6Wq+88ooRqwIAAIrgrVzftm1b1a9fX82aNSPXV3IU6QBgcu+88478/f21ceNGzZo1SzNmzNC8efMkSYmJidq8ebNWrFihtLQ0uVwu9e/fXw6HQ5K0ZcsW3Xvvvbrjjju0Y8cOTZ48WRMmTNDChQsNXCMAAPB75c3199xzjwYNGqR169Zp4sSJ5PpKju7uAGBykZGRmjlzpiwWi1q2bKmdO3dq5syZ6tGjh1asWKF169apW7dukqTFixcrMjJSy5cv1913360ZM2aoZ8+eevzxxxUeHq5WrVpp165dmj59uhITE41dMQAAIKn8uf7mm2/W008/rezsbF177bXavXs3ub4S40g6AJhc165dZbFY3M8TEhK0Z88e7dq1S/7+/oqPj3ePq1Onjlq2bKn09HRJUnp6uq677jqP5V133XXas2ePCgoKfLMCAADgssj1+D2KdAAAAAAATIIiHQBMbsOGDR7Pv//+e8XExKh169bKz8/3GH/ixAllZGSodevWkqTY2FitW7fOY/5169apRYsW8vPzq/jgAQDAFZHr8Xuckw6g2ks/fM7U7WRmZio5OVkPP/ywtm7dqtdee02vvPKKYmJidNttt2nEiBF68803FRYWpnHjxqlx48a67bbbJEmPPvqoOnfurOnTp+uBBx7Qhg0bNHv2bL3++uveXDUAAEytOuT65557Tv3799fOnTvJ9ZUcRTqAaisiIkIhtmDd/9Z2n7UZYgtWREREqeYZOnSo7Ha7unTpIj8/P40ZM0YjR46UJC1YsEBjxozRrbfeqry8PHXv3l2ff/65AgICJEnXXnutli1bpokTJ2r69Olq2LChnnnmGS4kAwCoFqpLrn///fc1ceJEPffcc+T6KoAiHUC1FRUVpfTdGcrKyvJZmxEREYqKiirVPAEBAUpJSdEbb7xRaFzt2rW1aNGiy85/5513qnfv3goPD5fVWvgsp/3795cqHgAAKovqlOtvv/12ZWdnF5nvyfWVC0U6gGotKiqq1IkUAABUHuR6VDZcOA4AAAAAAJPgSDoAmNiaNWuMDgEAAFQgcj3+iCPpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgEV3cHUK1lZmYqKyvLZ+1FRERwr1YAAHyIXI/KhiIdQLWVmZmpVrGtZM+x+6xNW4hNu9N3lzh59+jRQ3FxcUpJSanYwErIbPEA8B5fFjJOp1OStGPHDlmtvuvYmZubq6CgIJ+1ZwQKRE/k+tIzWzzVEUU6gGorKytL9hy7uj/RXTUja1Z4e2cOnNHal9YqKyvLp1+g8vLyfNYWgMopMzNTsa1aKsd+wSft2Ww2LV26VN27d5fd7rviyWqRnC6fNWeI0haIVV11yvX+/pR2VQWvZDn5uvuMEfhFFlVdzciaioiJMDqMQhITE/XNN9/om2++0axZsyRJe/fu1QsvvKB///vfOnLkiKKiojRq1CiNGTPGY77Tp0+rc+fOmjNnjoKCgrRt2zatX79eSUlJ2r17t9q0aaOnn35at99+u7Zt26a4uDhJ0o8//qjHH39c3377rWrUqKE+ffpo5syZioiIKDKeX3/9VdHR0b7eNAC8LCsrSzn2C/rHyDjFNgyt8Pac1kAdlLR2XIKsTt/8kLj1l+Ma8W6GOgztoCadm/ikTV8zqkCsDKpDrt+3b582bNigJ598klxfyVGkl0NmZqZatYqV3Z5jdCgVymYL0e7d6XzYAz42a9Ys/fzzz2rTpo2eeeYZSVLt2rXVpEkTffDBB6pTp47Wr1+vkSNHqmHDhrrnnnvc86ampio8PFyrV6+W0+lUdna2brvtNvXv319LlizRb7/9prFjx3q0d/r0afXs2VN/+ctfNHPmTNntdj355JO655579O9//7vIeOrWreuz7QGg4sU2DNW10RV/tNGhAB2U1D4qXAFyVHh7knQ+57wkKbRBqCmLNVRP3sr1kpSdna3BgweT66sAivRyyMrKkt2eo/gHJym8YbTR4VSI7MP7tWH+FH6RBQxQs2ZNBQYGKiQkRA0aNHAPnzJlivv/pk2bKi0tTe+//75H4q5Ro4bmzZunwMBAOZ1OpaSkyGKx6O2331ZwcLBat26tgwcPasSIEe55Zs+erQ4dOuiFF15wD5s/f74iIyP1888/q0WLFkXGAwAAysZbuV6SXn/9dVksFr311lsKCQkh11diFOleEN4wWldFtTQ6DADVxJw5czR//nxlZmbKbrcrLy/P3YXtkrZt27qTtnSx61y7du0UHBzsHtalSxePeXbs2KGvv/5aoaGFu7ru27dPLVq08O6KAACAIpUl1//888/605/+RK6vAijSAaASWbZsmR577DG98sorSkhIUFhYmKZPn64NGzZ4TFejRo1SL/vcuXMaMGCAXnzxxULjGjZsWOaYAQBAyZHrQZEOACYWGBiogoIC9/N169apW7duGjVqlHvYvn37rric5s2b64MPPvC4/dCmTZs8prn22mv10UcfKTo6utgrxP4xHgAAUD7eyvUtWrTQP/7xD+Xm5spms0ki11dWvrsxJQCg1KKjo7Vhwwbt379fWVlZiomJ0ebNm7Vq1Sr9/PPPmjBhQqEEXJS77rpLTqdTI0eOVHp6ulatWqWXX35ZkmSxWCRJo0eP1smTJzV48GBt2rRJ+/bt06pVqzR8+HB3sv5jPJfudQwAAMrGW7l+yJAhcjqdevjhh8n1lRxH0gFUe2cOnDFtO4899piGDRum1q1by263a/fu3dq2bZsGDRoki8WiwYMHa9SoUfriiy8uu5zw8HD985//1OjRoxUXF6e2bdtq4sSJGjJkiPvctUaNGmndunV68skn1adPH+Xm5urqq69Wv379ZLVai4yH27IAACqD6pLrly5dqieeeIJcX8lRpAOotiIiImQLsWntS2t91qYtxKaIiJLf+qdFixZKS0vzGLZgwQItWLDAY9jUqVPd/y9cuLDIZXXr1k07duxwP1+8eLECAgI87twQExOjjz/+uFTxAABgVtUt18fHx2vbtm3ugptcXzlRpAOotqKiorQ7fbeysrJ81mZERIRhtzNctGiRmjdvrsaNG2vHjh3u+6JeOm8NAICqprrl+mXLlql169aKjIwk11diFOkAqrWoqCjDEqmvHT16VJMnT9aRI0fUsGFD3X333Xr++eeNDgsAgApV3XL9tGnTyPWVHEU6AFQTjz/+uJ588kmjwwAAABVkzJgxmjBhgru7OyonXj0AAAAAAEyCIh0AAAAAAJOgSAdQbbhcLqNDQDXG+w8AKh6ftTCSt95/FOkAqryAgABJUk5OjsGRoDq79P679H4EAHgPuR5mkJeXJ0ny8/Mr13K4cByAKs/Pz0+1atXSsWPHJEkhISGyWCwGR+U7TqdTeXl5unDhAheSMYDL5VJOTo6OHTumWrVqlTtxAwAKq+65XiLfG83pdOr48eMKCQmRv3/5ymyKdADVQoMGDSTJnbyrE5fLJbvdLpvNVu2+sJhJrVq13O9DAID3VedcL5HvzcBqtSoqKqrc258iHUC1YLFY1LBhQ9WrV08Oh8PocHzK4XBo7dq16t69O12tDRIQEMARdACoYNU510vkezMIDAz0Si8GinQA1Yqfn1+1K5b8/PyUn5+v4OBgkjYAoMqrjrleIt9XJZysAAAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGAShhfpc+bMUXR0tIKDgxUfH6+NGzdedvrTp09r9OjRatiwoYKCgtSiRQt9/vnnPooWAACUBfkeAICSMfQ+6e+9956Sk5M1d+5cxcfHKyUlRX379lVGRobq1atXaPq8vDz17t1b9erV04cffqjGjRvrt99+U61atXwfPAAAKBHyPQAAJWdokT5jxgyNGDFCw4cPlyTNnTtXn332mebPn69x48YVmn7+/Pk6efKk1q9fr4CAAElSdHS0L0MGAAClRL4HAKDkDCvS8/LytGXLFo0fP949zGq1qlevXkpLSytynhUrVighIUGjR4/WP//5T9WtW1dDhgzRk08+KT8/vyLnyc3NVW5urvt5dna2JMnhcMjhcJRrHZxOp2w2mwKskr/FWa5lmVWAVbLZbHI6neXeXiV1qR1ftQdUdexT5leVX5uqkO+rg0vfaZzWQDkUUOHtXWrDF21d4vILlM1mU6BfoPxdhh6nqjABlgCff2+DeZDvza00r4thn1BZWVkqKChQ/fr1PYbXr19fu3fvLnKeX375Rf/+979133336fPPP9fevXs1atQoORwOTZo0qch5pk6dqilTphQa/uWXXyokJKTc67F06dL/919WuZdlSvVqa+TSpTp48KAOHjzo06ZXr17t0/aAqo59yrxycnKMDqHCVJV8Xx0sXbpUByX5Mtuvrn2f7xrrKi3t+v/+z73slJVXE2no0qGGfG+DeZDvzak0ub5S/YzodDpVr149vfXWW/Lz81PHjh118OBBTZ8+vdikPX78eCUnJ7ufZ2dnKzIyUn369FF4eHi54tmxY4e6d++umx57XbUjY8q1LLM6dWCPvn55lNauXav27dv7pE2Hw6HVq1erd+/e7m6OAMqOfcr8Lh31xUVmy/fVwaXvNGvHJah9VMVvL4cCtLr2fep9arEC5JujfmkZh9Vv1g/qNrabmnVv5pM2fe3EvhP64vEvfPq9DeZBvje30uR6w4r0iIgI+fn56ejRox7Djx49qgYNGhQ5T8OGDRUQEODR1S02NlZHjhxRXl6eAgMDC80TFBSkoKCgQsMDAgLK/ea1Wq2y2+1yOKV8l+EXyq8QDqdkt9tltVp9vrN74zUC8F/sU+ZVlV+XqpDvq4NL32mszjyfFc2SFCCHz9qzFOTJbrcrryBP+ZZ8n7Tpaw6Xw7DvbTAPPvfMqTSviWGVZWBgoDp27KjU1FT3MKfTqdTUVCUkJBQ5z3XXXae9e/fK6fzv+d8///yzGjZsWGTCBgAAxiLfAwBQOoYe/k1OTtbbb7+td955R+np6frf//1fnT9/3n3116FDh3pcaOZ///d/dfLkSY0ZM0Y///yzPvvsM73wwgsaPXq0UasAAACugHwPAEDJGXpO+qBBg3T8+HFNnDhRR44cUVxcnFauXOm+uExmZqas1v/+jhAZGalVq1bpkUceUbt27dS4cWONGTNGTz75pFGrAAAAroB8DwBAyRl+4bikpCQlJSUVOW7NmjWFhiUkJOj777+v4KgAAIA3ke8BACiZqnm1MwAAAAAAKiGKdAAAAAAATKJMRfrXX3/t7TgAAIDJkO8BAPC9MhXp/fr10zXXXKPnnntOBw4c8HZMAADABMj3AAD4XpmK9IMHDyopKUkffvihmjVrpr59++r9999XXl6et+MDAAAGId8DAOB7ZSrSIyIi9Mgjj2j79u3asGGDWrRooVGjRqlRo0b6v//7P+3YscPbcQIAAB8j3wMA4HvlvnDctddeq/HjxyspKUnnzp3T/Pnz1bFjR91www366aefvBEjAAAwGPkeAADfKHOR7nA49OGHH6p///66+uqrtWrVKs2ePVtHjx7V3r17dfXVV+vuu+/2ZqwAAMDHyPcAAPiWf1lm+tvf/qalS5fK5XLpgQce0EsvvaQ2bdq4x9eoUUMvv/yyGjVq5LVAAQCAb5HvAQDwvTIV6bt27dJrr72mO+64Q0FBQUVOExERwa1bAACoxMj3AAD4Xpm6u0+aNEl33313oYSdn5+vtWvXSpL8/f114403lj9CAABgCPI9AAC+V6Yi/aabbtLJkycLDT9z5oxuuummcgcFAACMR74HAMD3ylSku1wuWSyWQsNPnDihGjVqlDsoAABgPPI9AAC+V6pz0u+44w5JksViUWJiokf3t4KCAv3www/q1q2bdyMEAAA+Rb4HAMA4pSrSa9asKeniL+thYWGy2WzucYGBgeratatGjBjh3QgBAIBPke8BADBOqYr0BQsWSJKio6P12GOP0dUNAIAqiHwPAIBxynQLtkmTJnk7DgAAYDLkewAAfK/ERfq1116r1NRU1a5dWx06dCjyQjKXbN261SvBAUBVlZmZqaysLJ+05XQ6JUk7duyQ1Vqm64WWSW5ubrH31q4qIiIiFBUVZXQYXkW+BwDAWCUu0m+77Tb3l62BAwdWVDwAUOVlZmYqtlVL5dgv+KQ9m82mpUuXqnv37rLb7T5pU5KsFsnp8llzhrCF2LQ7fXeVKtTJ9wAAGKvERfrvu7zR/Q0Ayi4rK0s59gv6x8g4xTYMrfD2nNZAHZS0dlyCrM68Cm9Pkrb+clwj3s1Qh6Ed1KRzE5+06WtnDpzR2pfWKisrq0oV6eR7AACMVaZz0gEA5RfbMFTXRtes8HYcCtBBSe2jwhUgR4W3J0nnc85LkkIbhCoiJsInbQIAAFQFJS7Sa9eufdnz0n7v5MmTZQ4IAAAYh3wPAICxSlykp6SkVGAYAADADMj3AAAYq8RF+rBhwyoyDgAAYALkewC+4Mu7nBilKt4BBL5R4iI9Oztb4eHh7v8v59J0AACgciHfA6homZmZatUqVnZ7jtGhVCibLUS7d6dTqKPUSnVO+uHDh1WvXj3VqlWryPPVXC6XLBaLCgoKvBokAADwDfI9gIqWlZUluz1H8Q9OUnjDaKPDqRDZh/drw/wpVe4OIPCNEhfp//73v3XVVVdJkr7++usKCwgAABiHfF+0qt41Nz093egQUA2FN4zWVVEtjQ4DMJ0SF+k33nhjkf8DAICqg3xfWHXpmitZdPjMBUkVf2tIAEDxynyf9FOnTunvf/+7+5fX1q1ba/jw4e5f3wEAQOVHvq8eXXOP/7pb25e8qNM5+UaHAgDVXpmK9LVr12rAgAGqWbOmOnXqJEl69dVX9cwzz+hf//qXunfv7tUgAQCA75HvPVXlrrn281W9lwAAVB5lKtJHjx6tQYMG6Y033pCfn58kqaCgQKNGjdLo0aO1c+dOrwYJAAB8j3wPAIDvWcsy0969e/Xoo4+6E7Yk+fn5KTk5WXv37vVacAAAwDjkewAAfK9MR9KvvfZapaenq2VLzy5f6enpat++vVcCg7n48qqvTqdTkrRjxw5ZrWX6HanUcnNzFRQU5JO2jBIREcEtQACUCvkeAADfK3GR/sMPP7j//7//+z+NGTNGe/fuVdeuXSVJ33//vebMmaNp06Z5P0oYxpGbJ0m6//77fdamzWbT0qVL1b17d9ntdp+0abVITpdPmjKMLcSm3em7KdQBXBb5HgAAY5W4SI+Li5PFYpHL9d9K5oknnig03ZAhQzRo0CDvRAfD5edfvMrrs3e0UP+29XzSptMaqIOS1o5LkNWZV+Htbf3luEa8m6EOQzuoSecmFd6eEc4cOKO1L61VVlYWRTqAyyLfAwBgrBIX6b/++mtFxgGTaxoRomujfXPfVIcCdFBS+6hwBchR4e2dzzkvSQptEKqImIgKbw8AzIx8DwCAsUpcpF999dUVGQcAADAB8j0AAMYq04XjLtm1a5cyMzOVl+fZJfl//ud/yhUUAAAwD/I9AAC+U6Yi/ZdfftHtt9+unTt3epy3ZrFYJF28hyoAAKjcyPcAAPheme5vNWbMGDVt2lTHjh1TSEiIfvrpJ61du1adOnXSmjVrvBwiAAAwAvkeAADfK9OR9LS0NP373/9WRESErFarrFarrr/+ek2dOlX/93//p23btnk7TgAA4GPkewAAfK9MR9ILCgoUFhYmSYqIiNChQ4ckXbzYTEZGhveiAwAAhiHfAwDge2U6kt6mTRvt2LFDTZs2VXx8vF566SUFBgbqrbfeUrNmzbwdIwAAMAD5HgAA3ytTkf7000/r/PmL95Z+5plndOutt+qGG25QnTp19N5773k1QAAAYAzyPQAAvlemIr1v377u/5s3b67du3fr5MmTql27tvuKrwAAoHIj3wMA4Hvluk+6JB04cECSFBkZWe5gAACAOZHvAQDwjTJdOC4/P18TJkxQzZo1FR0drejoaNWsWVNPP/20HA6Ht2MEAAAGIN8DAOB7ZTqS/re//U0ff/yxXnrpJSUkJEi6eJuWyZMn68SJE3rjjTe8GiQAAPA98j0AAL5XpiJ9yZIlWrZsmW655Rb3sHbt2ikyMlKDBw8maQMAUAWQ7wEA8L0ydXcPCgpSdHR0oeFNmzZVYGBgeWMCAAAmQL4HAMD3ylSkJyUl6dlnn1Vubq57WG5urp5//nklJSV5LTgAAGAc8j0AAL5X4u7ud9xxh8fzr776Sk2aNFH79u0lSTt27FBeXp5uvvlm70YIAAB8hnwPAICxSlyk16xZ0+P5nXfe6fGcW7IAAFD5ke8BADBWiYv0BQsWVGQcAADABMj3AAAYq0znpF9y/Phxfffdd/ruu+90/PjxMi9nzpw5io6OVnBwsOLj47Vx48YSzbds2TJZLBYNHDiwzG0DAIDL80a+J9cDAFAyZSrSz58/rwcffFANGzZU9+7d1b17dzVq1EgPPfSQcnJySrWs9957T8nJyZo0aZK2bt2q9u3bq2/fvjp27Nhl59u/f78ee+wx3XDDDWVZBQAAcAXeyvfkegAASq5MRXpycrK++eYb/etf/9Lp06d1+vRp/fOf/9Q333yjRx99tFTLmjFjhkaMGKHhw4erdevWmjt3rkJCQjR//vxi5ykoKNB9992nKVOmqFmzZmVZBQAAcAXeyvfkegAASq7E56T/3kcffaQPP/xQPXr0cA/r37+/bDab7rnnHr3xxhslWk5eXp62bNmi8ePHu4dZrVb16tVLaWlpxc73zDPPqF69enrooYf07bffXraN3Nxcj1vHZGdnS5IcDoccDkeJ4iyO0+mUzWZTgFXytzjLtSyzCvSzyGazSf5BcijAJ21easdX7bn8AmWz2RToFyh/V5l2CdMLsATIZrPJ6XSW+32P8rv02eG0Bvrkfe7rfUpivyots+6X3sj3vsj1Evm+vHyd7/lcqhiVJd9Xh30qwCqfvxaX2jHza1+dleZ1sbhcLldpGwgJCdGWLVsUGxvrMfynn35Sly5ddP78+RIt59ChQ2rcuLHWr1+vhIQE9/AnnnhC33zzjTZs2FBonu+++0733nuvtm/froiICCUmJur06dNavnx5kW1MnjxZU6ZMKTR8yZIlCgkJKVGcAABUpJycHA0ZMkRnzpxReHi40eG4eSPf+yLXS+R7AIC5lSbXl+lnxISEBE2aNEmLFi1ScHCwJMlut2vKlCkeCdjbzp49qwceeEBvv/22IiIiSjTP+PHjlZyc7H6enZ2tyMhI9enTp9xfhHbs2KHu3bvrpsdeV+3ImHIty6wOZ/ygtNcf1dvD2+mezg190qZDAVpd+z71PrVYAar4XwLTMg6r36wf1G1sNzXrXjW7VJ7Yd0JfPP6F1q5d677XMYxz6bNj7bgEtY+q+ILM1/uUxH5VWpeO+pqNEfm+LLleIt+Xl6/zPZ9LFaOy5PvqsE+dOrBHX788yqevhcPh0OrVq9W7d28FBPiulwpKpjS5vkxFekpKivr166cmTZq433Q7duxQcHCwVq1aVeLlREREyM/PT0ePHvUYfvToUTVo0KDQ9Pv27dP+/fs1YMAA9zCn82IXGX9/f2VkZOiaa67xmCcoKEhBQUGFlhUQEFDuN6/VapXdbpfDKeW7ynWhfNPKK3DJbrdL+bk+S6KXBMjhkzYtBXmy2+3KK8hTviW/wtszgsPlkN1ul9Vq5UPbBC59dlideT7dr3y1T0nsV6Vl1v3SG/neF7leIt+Xl1H5ns8l76os+b467FMOpwx7LbzxuQfvK81rUqYivW3bttqzZ48WL16s3bt3S5IGDx6s++677+L5TCUUGBiojh07KjU11X1rFafTqdTUVCUlJRWavlWrVtq5c6fHsKefflpnz57VrFmzFBkZWZbVAQAARfBGvifXAwBQOqUu0h0Oh1q1aqVPP/1UI0aMKHcAycnJGjZsmDp16qQuXbooJSVF58+f1/DhwyVJQ4cOVePGjTV16lQFBwerTZs2HvPXqlVLkgoNBwAAZefNfE+uBwCg5EpdpAcEBOjChQteC2DQoEE6fvy4Jk6cqCNHjiguLk4rV65U/fr1JUmZmZmyWqtmNxgAAMzKm/meXA8AQMmVqbv76NGj9eKLL2revHny9y//LSySkpKK7PImSWvWrLnsvAsXLix3+wAAoDBv5ntyPQAAJVOmjLtp0yalpqbqyy+/VNu2bVWjRg2P8R9//LFXggMAAMYh3wMA4HtlKtJr1aqlO++809uxAAAAEyHfAwDge6Uq0p1Op6ZPn66ff/5ZeXl56tmzpyZPnlyqK7oDAABzI98DAGCcUl2l5fnnn9dTTz2l0NBQNW7cWK+++qpGjx5dUbEBAAADkO8BADBOqYr0RYsW6fXXX9eqVau0fPly/etf/9LixYvldDorKj4AAOBj5HsAAIxTqiI9MzNT/fv3dz/v1auXLBaLDh065PXAAACAMcj3AAAYp1RFen5+voKDgz2GBQQEyOFweDUoAABgHPI9AADGKdWF41wulxITExUUFOQeduHCBf31r3/1uC0Lt2QBAKDyIt8DAGCcUhXpw4YNKzTs/vvv91owAADAeOR7AACMU6oifcGCBRUVBwAAMAnyPQAAxinVOekAAAAAAKDiUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYhL/RAQDAH2VmZiorK8voMCpMenq60SEAAADApCjSAZhKZmamWrWKld2eY3QoFcyiw2cuSKppdCAAAAAwEYp0AKaSlZUluz1H8Q9OUnjDaKPDqRDHf92t7Ute1OmcfKNDAQAAFciXveecTqckaceOHbJafXNWc25uroKCgnzSllEiIiIUFRXl0zYp0gGYUnjDaF0V1dLoMCqE/XxV7yUAAED15sjNkyTdf//9PmvTZrNp6dKl6t69u+x2u0/atFokp8snTRnGFmLT7vTdPi3UKdIBAAAAwIvy8y/2lnv2jhbq37aeT9p0WgN1UNLacQmyOvMqvL2tvxzXiHcz1GFoBzXp3KTC2zPCmQNntPaltcrKyqJIBwAAAIDKrmlEiK6N9s31ZxwK0EFJ7aPCFSBHhbd3Pue8JCm0QagiYiIqvL3qhFuwAQAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYhCmK9Dlz5ig6OlrBwcGKj4/Xxo0bi5327bff1g033KDatWurdu3a6tWr12WnBwAAxiPXAwBQMoYX6e+9956Sk5M1adIkbd26Ve3bt1ffvn117NixIqdfs2aNBg8erK+//lppaWmKjIxUnz59dPDgQR9HDgAASoJcDwBAyRlepM+YMUMjRozQ8OHD1bp1a82dO1chISGaP39+kdMvXrxYo0aNUlxcnFq1aqV58+bJ6XQqNTXVx5EDAICSINcDAFBy/kY2npeXpy1btmj8+PHuYVarVb169VJaWlqJlpGTkyOHw6GrrrqqyPG5ubnKzc11P8/OzpYkORwOORyOckQvOZ1O2Ww2BVglf4uzXMsyq0A/i2w2m+QfJIcCfNLmpXZ81Z7LL1A2m02BfoHydxm6S1SYAEuAbDabnE5nud/3FY39yvt8vU9J7FelZfb9sjx8kesl8n158blUNVSWfM8+VTH4Du19RuV6i8vlcpWrtXI4dOiQGjdurPXr1yshIcE9/IknntA333yjDRs2XHEZo0aN0qpVq/TTTz8pODi40PjJkydrypQphYYvWbJEISEh5VsBAAC8ICcnR0OGDNGZM2cUHh5udDhe5YtcL5HvAQDmVppcX6l/8pg2bZqWLVumNWvWFJu0x48fr+TkZPfz7Oxs97lt5f0itGPHDnXv3l03Pfa6akfGlGtZZnU44welvf6o3h7eTvd0buiTNh0K0Ora96n3qcUKUMX/CpyWcVj9Zv2gbmO7qVn3ZhXenhFO7DuhLx7/QmvXrlX79u2NDuey2K+8z9f7lMR+VVqXjvqisJLkeol8X158LlUNlSXfs09VDL5De59Rud7QIj0iIkJ+fn46evSox/CjR4+qQYMGl5335Zdf1rRp0/TVV1+pXbt2xU4XFBSkoKCgQsMDAgIUEFC+riBWq1V2u10Op5TvMvz0/gqRV+CS3W6X8nN9lkQvCZDDJ21aCvJkt9uVV5CnfEt+hbdnBIfLIbvdLqvVWu73fUVjv6o4vtqnJPar0jL7flkevsj1Evm+vPhcqhoqS75nn6pYfIf2HqNyvaF7RWBgoDp27OhxIZhLF4b5fZe4P3rppZf07LPPauXKlerUqZMvQgUAAGVArgcAoHQM7+6enJysYcOGqVOnTurSpYtSUlJ0/vx5DR8+XJI0dOhQNW7cWFOnTpUkvfjii5o4caKWLFmi6OhoHTlyRJIUGhqq0NBQw9YDAAAUjVwPAEDJGV6kDxo0SMePH9fEiRN15MgRxcXFaeXKlapfv74kKTMzU1brfw/4v/HGG8rLy9Ndd93lsZxJkyZp8uTJvgwdAACUALkeAICSM7xIl6SkpCQlJSUVOW7NmjUez/fv31/xAQEAAK8i1wMAUDJV80oNAAAAAABUQhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJUKQDAAAAAGASpijS58yZo+joaAUHBys+Pl4bN2687PQffPCBWrVqpeDgYLVt21aff/65jyIFAABlQa4HAKBkDC/S33vvPSUnJ2vSpEnaunWr2rdvr759++rYsWNFTr9+/XoNHjxYDz30kLZt26aBAwdq4MCB+vHHH30cOQAAKAlyPQAAJWd4kT5jxgyNGDFCw4cPV+vWrTV37lyFhIRo/vz5RU4/a9Ys9evXT48//rhiY2P17LPP6tprr9Xs2bN9HDkAACgJcj0AACXnb2TjeXl52rJli8aPH+8eZrVa1atXL6WlpRU5T1pampKTkz2G9e3bV8uXLy9y+tzcXOXm5rqfnzlzRpJ08uRJORyOcsWfnZ2t4OBgnTv4s+Swl2tZZmU/8ouCg4OVkZWnNT+f9UmbTmugcv6Uo2/3npPVmVfh7f14KE/BwcHKOZSjrJ1ZFd6eEc4ePqvg4GBlZ2frxIkTRodzWexX3ufrfUpivyr1ss5efB+4XC5vhGYqvsj1Evm+vPhcqhoqS75nn6oYfIf2PsNyvctABw8edElyrV+/3mP4448/7urSpUuR8wQEBLiWLFniMWzOnDmuevXqFTn9pEmTXJJ48ODBgwcP0z8OHDjgnQRrIr7I9S4X+Z4HDx48eFSOR0lyvaFH0n1h/PjxHr/GO51OnTx5UnXq1JHFYjEwMhQnOztbkZGROnDggMLDw40OB6j02KfMz+Vy6ezZs2rUqJHRoVRa5PvKhc8lwPvYr8ytNLne0CI9IiJCfn5+Onr0qMfwo0ePqkGDBkXO06BBg1JNHxQUpKCgII9htWrVKnvQ8Jnw8HA+YAAvYp8yt5o1axodQoXwRa6XyPeVFZ9LgPexX5lXSXO9oReOCwwMVMeOHZWamuoe5nQ6lZqaqoSEhCLnSUhI8JheklavXl3s9AAAwDjkegAASsfw7u7JyckaNmyYOnXqpC5duiglJUXnz5/X8OHDJUlDhw5V48aNNXXqVEnSmDFjdOONN+qVV17Rn//8Zy1btkybN2/WW2+9ZeRqAACAYpDrAQAoOcOL9EGDBun48eOaOHGijhw5ori4OK1cuVL169eXJGVmZspq/e8B/27dumnJkiV6+umn9dRTTykmJkbLly9XmzZtjFoFeFlQUJAmTZpUqNsigLJhn4LRyPX4Iz6XAO9jv6o6LC5XFbzfCwAAAAAAlZCh56QDAAAAAID/okgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCIh2mMmfOHEVHRys4OFjx8fHauHGj0SEBldratWs1YMAANWrUSBaLRcuXLzc6JAAg3wNeRK6veijSYRrvvfeekpOTNWnSJG3dulXt27dX3759dezYMaNDAyqt8+fPq3379pozZ47RoQCAJPI94G3k+qqHW7DBNOLj49W5c2fNnj1bkuR0OhUZGam//e1vGjdunMHRAZWfxWLRJ598ooEDBxodCoBqjHwPVBxyfdXAkXSYQl5enrZs2aJevXq5h1mtVvXq1UtpaWkGRgYAALyFfA8AV0aRDlPIyspSQUGB6tev7zG8fv36OnLkiEFRAQAAbyLfA8CVUaQDAAAAAGASFOkwhYiICPn5+eno0aMew48ePaoGDRoYFBUAAPAm8j0AXBlFOkwhMDBQHTt2VGpqqnuY0+lUamqqEhISDIwMAAB4C/keAK7M3+gAgEuSk5M1bNgwderUSV26dFFKSorOnz+v4cOHGx0aUGmdO3dOe/fudT//9ddftX37dl111VWKiooyMDIA1RX5HvAucn3Vwy3YYCqzZ8/W9OnTdeTIEcXFxenVV19VfHy80WEBldaaNWt00003FRo+bNgwLVy40PcBAYDI94A3keurHop0AAAAAABMgnPSAQAAAAAwCYp0AAAAAABMgiIdAAAAAACToEgHAAAAAMAkKNIBAAAAADAJinQAAAAAAEyCIh0AAAAAAJOgSAcAAAAAwCQo0oEqpEePHho7dmyx46Ojo5WSkuKzeAAAgHeR64GqjyIdqEY2bdqkkSNHGh3GFf3000+68847FR0dLYvFwpcNAABKqLLk+rfffls33HCDateurdq1a6tXr17auHGj0WEBpkCRDlQjdevWVUhISIW2kZeXV+5l5OTkqFmzZpo2bZoaNGjghagAAKgeKkuuX7NmjQYPHqyvv/5aaWlpioyMVJ8+fXTw4EEvRAhUbhTpQBWTn5+vpKQk1axZUxEREZowYYJcLpekwl3gLBaL5s2bp9tvv10hISGKiYnRihUr3OMLCgr00EMPqWnTprLZbGrZsqVmzZrl0V5iYqIGDhyo559/Xo0aNVLLli31zDPPqE2bNoVii4uL04QJE664Dp07d9b06dN17733KigoqIxbAgCAqqkq5PrFixdr1KhRiouLU6tWrTRv3jw5nU6lpqaWcasAVQdFOlDFvPPOO/L399fGjRs1a9YszZgxQ/PmzSt2+ilTpuiee+7RDz/8oP79++u+++7TyZMnJUlOp1NNmjTRBx98oF27dmnixIl66qmn9P7773ssIzU1VRkZGVq9erU+/fRTPfjgg0pPT9emTZvc02zbtk0//PCDhg8fXjErDgBANVEVc31OTo4cDoeuuuqqUs8LVDX+RgcAwLsiIyM1c+ZMWSwWtWzZUjt37tTMmTM1YsSIIqdPTEzU4MGDJUkvvPCCXn31VW3cuFH9+vVTQECApkyZ4p62adOmSktL0/vvv6977rnHPbxGjRqaN2+eAgMD3cP69u2rBQsWqHPnzpKkBQsW6MYbb1SzZs0qYrUBAKg2qmKuf/LJJ9WoUSP16tWr1PMCVQ1H0oEqpmvXrrJYLO7nCQkJ2rNnjwoKCoqcvl27du7/a9SoofDwcB07dsw9bM6cOerYsaPq1q2r0NBQvfXWW8rMzPRYRtu2bT2StiSNGDFCS5cu1YULF5SXl6clS5bowQcf9MYqAgBQrVW1XD9t2jQtW7ZMn3zyiYKDg0s9P1DVcCQdqOYCAgI8nlssFjmdTknSsmXL9Nhjj+mVV15RQkKCwsLCNH36dG3YsMFjnho1ahRa7oABAxQUFKRPPvlEgYGBcjgcuuuuuypuRQAAQJHMnOtffvllTZs2TV999ZXHjwlAdUaRDlQxf0yq33//vWJiYuTn51fqZa1bt07dunXTqFGj3MP27dtXonn9/f01bNgwLViwQIGBgbr33ntls9lKHQMAAPBUVXL9Sy+9pOeff16rVq1Sp06dSh07UFVRpANVTGZmppKTk/Xwww9r69ateu211/TKK6+UaVkxMTFatGiRVq1apaZNm+rdd9/Vpk2b1LRp0xLN/5e//EWxsbGSLn4JKKm8vDzt2rXL/f/Bgwe1fft2hYaGqnnz5qVfEQAAqpCqkOtffPFFTZw4UUuWLFF0dLSOHDkiSQoNDVVoaGjpVwSoQijSgSpm6NChstvt6tKli/z8/DRmzBiNHDmyTMt6+OGHtW3bNg0aNEgWi0WDBw/WqFGj9MUXX5Ro/piYGHXr1k0nT55UfHx8ids9dOiQOnTo4H7+8ssv6+WXX9aNN96oNWvWlHY1AACoUqpCrn/jjTeUl5dXqHv8pEmTNHny5NKsAlDlWFyXbqoIAF7mcrkUExOjUaNGKTk52ehwAACAl5HrAe/jSDqACnH8+HEtW7ZMR44c4d7oAABUQeR6oGJQpAOoEPXq1VNERITeeust1a5d22Pc5c41++KLL3TDDTdUdHgAAKCcyPVAxaC7OwCf27t3b7HjGjduzFXgAQCo5Mj1QNlRpAMAAAAAYBJWowMAAAAAAAAXUaQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBIU6QAAAAAAmARFOgAAAAAAJkGRDgAAAACASVCkAwAAAABgEhTpAAAAAACYBEU6AAAAAAAmQZEOAAAAAIBJ+BsdgK85nU4dOnRIYWFhslgsRocDAIBcLpfOnj2rRo0ayWrl93MAAKqzalekHzp0SJGRkUaHAQBAIQcOHFCTJk2MDgMAABio2hXpYWFhki5+EQoPDzc4GhTF4XDoyy+/VJ8+fRQQEGB0OEClxz5lftnZ2YqMjHTnKAAAUH1VuyL9Uhf38PBwinSTcjgcCgkJUXh4OAUF4AXsU5UHp2EBAABOfAMAAAAAwCQo0gEAAAAAMAmKdAAAAAAATKLanZNeUgUFBXI4HEaHUS05HA75+/vrwoULKigoMDocnwoICJCfn5/RYQAAAAAwCEX6H7hcLh05ckSnT582OpRqy+VyqUGDBjpw4EC1vIhSrVq11KBBg2q57gAAAEB1R5H+B5cK9Hr16ikkJIRCyQBOp1Pnzp1TaGiorNbqc0aGy+VSTk6Ojh07Jklq2LChwREBAAAA8DWK9N8pKChwF+h16tQxOpxqy+l0Ki8vT8HBwdWqSJckm80mSTp27Jjq1atH13cAAACgmqleFdAVXDoHPSQkxOBIUJ1dev9xTQQAAACg+qFILwJd3GEk3n8AAABA9UWRDgAAAACASVCkw2t69OihsWPHlns5PXv21Pjx48sfEAAAAABUMlw4DoZZs2aNbrrpJp06dUq1atVyD//www9lt9uNCwwAAAAADMKRdJjOVVddpbCwMKPDAAAAAACfo0ivAnr06KGkpCQlJSWpZs2aioiI0IQJE+RyuSRJp06d0tChQ1W7dm2FhITolltu0Z49e9zzL1y4ULVq1dLy5csVExOj4OBg9e3bVwcOHHBPk5iYqIEDB3q0O3bsWPXo0aPYuN5991116tRJYWFhatCggYYMGeK+B/j+/ft10003SZJq164ti8WixMRESYW7u5c0/lWrVik2NlahoaHq16+fDh8+XKbtCQAAAABGoUivIt555x35+/tr48aNmjVrlmbMmKF58+ZJulhgb968WStWrFBaWppcLpf69+/vcYuvnJwcPf/881q0aJHWrVun06dP69577y1XTA6HQ88++6x27Nih5cuXa//+/e5CPDIyUh999JEkKSMjQ4cPH9asWbOKXE5J43/55Zf17rvvau3atcrMzNRjjz1WrvgBAAAAwNc4J72KiIyM1MyZM2WxWNSyZUvt3LlTM2fOVI8ePbRixQqtW7dO3bp1kyQtXrxYkZGRWr58ue6++25JFwvq2bNnKz4+XtLFoj82NlYbN25Uly5dyhTTgw8+6P6/WbNmevXVV9W5c2edO3dOoaGhuuqqqyRJ9erV8zgn/ff27NlT4vjnzp2ra665RpKUlJSkZ555pkxxAwAAAIBROJJeRXTt2tXj/toJCQnas2ePdu3aJX9/f3fxLUl16tRRy5YtlZ6e7h7m7++vzp07u5+3atVKtWrV8pimtLZs2aIBAwYoKipKYWFhuvHGGyVJmZmZJV5Genp6ieIPCQlxF+iS1LBhQ3fXegAAAACoLCjSUSJWq9V9jvslv+9u/kfnz59X3759FR4ersWLF2vTpk365JNPJEl5eXlejy8gIMDjucViKRQvAAAAAJgdRXoVsWHDBo/n33//vWJiYtS6dWvl5+d7jD9x4oQyMjLUunVr97D8/Hxt3rzZ/TwjI0OnT59WbGysJKlu3bqFLsS2ffv2YuPZvXu3Tpw4oWnTpumGG25Qq1atCh3ZDgwMlCQVFBQUu5zY2NgSxQ8AAAAAVQFFehWRmZmp5ORkZWRkaOnSpXrttdc0ZswYxcTE6LbbbtOIESP03XffaceOHbr//vvVuHFj3Xbbbe75AwIC9Le//U0bNmzQli1blJiYqK5du7rPR+/Zs6c2b96sRYsWac+ePZo0aZJ+/PHHYuOJiopSYGCgXnvtNf3yyy9asWKFnn32WY9prr76alksFn366ac6fvy4zp07V2g5JY0fAAAAAKoCivQqYujQobLb7erSpYtGjx6tMWPGaOTIkZKkBQsWqGPHjrr11luVkJAgl8ulzz//3KOLeEhIiJ588kkNGTJE1113nUJDQ/Xee++5x/ft21cTJkzQE088oc6dO+vs2bMaOnRosfHUrVtXCxcu1AcffKDWrVtr2rRpevnllz2mady4saZMmaJx48apfv36SkpKKnJZJYkfAAAAAKoCi6uanbibnZ2tmjVr6syZMwoPD/cYd+HCBf36669q2rSpgoODDYqw9Hr06KG4uDilpKSUaf6FCxdq7NixOn36tFfjKiun06ns7GyFh4fLaq1+vyNV1vchzMvhcOjzzz9X//79+XHLpC6XmwAAQPVS/SogAAAAAABMiiIdAAAAAACT8Dc6AJTfmjVryjV/YmKiEhMTvRILAAAAAKDsOJIOAAAAAIBJUKQDAAAAAGASFOkAAAAAAJgERToAAAAAACZBkQ4AAAAAgElQpAMAAAAAYBLcgq2EMjMzlZWV5bP2IiIiFBUV5bP2Sio6Olpjx47V2LFji50mLy9PrVu31qJFi9StWzffBWcCFotFn3zyiQYOHFjk+F27dqlPnz7KyMhQjRo1fBscAAAAANOjSC+BzMxMtWoVK7s9x2dt2mwh2r073ZSF+pXMnTtXTZs2rdQF+v79+9W0aVNt27ZNcXFxXltu69at1bVrV82YMUMTJkzw2nIBAAAAVA0U6SWQlZUluz1H8Q9OUnjD6ApvL/vwfm2YP0VZWVmVrkh3uVyaPXu2nnnmmXIvJz8/X4GBgV6KzDyGDx+uESNGaPz48fL3ZxcEAAAA8F+ck14K4Q2jdVVUywp/lOWHgB49eigpKUlJSUmqWbOmIiIiNGHCBLlcLvc0p06d0tChQ1W7dm2FhITolltu0Z49ezyW89FHH+lPf/qTgoKCFB0drVdeeaVUcWzZskX79u3Tn//8Z/ew/fv3y2KxaNmyZerWrZuCg4PVpk0bffPNN+5p1qxZI4vFoi+++EKdO3dW/fr19d1338npdGrq1Klq2rSpbDab2rdvrw8//LDQfKtWrVKHDh1ks9nUs2dPHTt2TF988YViY2MVHh6uIUOGKCfnvz0hVq5cqeuvv161atVSnTp1dOutt2rfvn3u8U2bNpUkdejQQRaLRT169HCPmz9/vnsbNWzYUElJSR7bICsrS7fffrtCQkIUExOjFStWeIzv3bu3Tp486bH+AAAAACBRpFcp77zzjvz9/bVx40bNmjVLM2bM0Lx589zjExMTtXnzZq1YsUJpaWlyuVzq37+/HA6HpIsF9j333KN7771XO3fu1OTJkzVhwgQtXLiwxDF8++23atGihcLCwgqNe/zxx/Xoo49q27ZtSkhI0IABA3TixAmPacaNG6cXXnhBGzZsULt27TR16lQtWrRIc+fO1U8//aRHHnlE999/f6ECd/LkyZo9e7bWr1+vAwcO6J577lFKSoqWLFmizz77TF9++aVee+019/Tnz59XcnKyNm/erNTUVFmtVt1+++1yOp2SpI0bN0qSvvrqKx0+fFgff/yxJOmNN97Q6NGjNXLkSO3cuVMrVqxQ8+bNPWKZMmWK7rnnHv3www/q37+/7rvvPp08edI9PjAwUHFxcfr2229LvF0BAAAAVA/0ta1CIiMjNXPmTFksFrVs2VI7d+7UzJkzNWLECO3Zs0crVqzQunXr3OeKL168WJGRkVq+fLnuvvtuzZgxQzfffLP7XOkWLVpo165dmj59uhITE0sUw2+//aZGjRoVOS4pKUl33nmnpIvF7sqVK/X3v/9dTzzxhHuaZ555Rr1791Z2draCgoL0wgsv6KuvvlJCQoIkqVmzZvruu+/05ptv6sYbb3TP99xzz+m6666TJD300EMaP3689u3bp2bNmkmS7rrrLn399dd68sknJckdxyXz589X3bp1tWvXLrVp00Z169aVJNWpU0cNGjTwaOfRRx/VmDFj3MM6d+7ssazExEQNHjxYkvTCCy/o1Vdf1caNG9WvXz/3NI0aNdJvv/12xe0JAAAAoHrhSHoV0rVrV1ksFvfzhIQE7dmzRwUFBUpPT5e/v7/i4+Pd4+vUqaOWLVsqPT1dkpSenu4udC+57rrr3MsoCbvdruDg4CLHXSq0Jcnf31+dOnVyt31Jp06d3P/v3btXOTk56t27t0JDQ92PRYsWeXRNl6R27dq5/69fv75CQkLcBfqlYceOHXM/37NnjwYPHqxmzZopPDxc0dHRki5eJLA4x44d06FDh3TzzTdfZgt4xlKjRg2Fh4d7tC1JNpvNo/s9AAAAAEgmKNLnzJmj6OhoBQcHKz4+3t3NuDgpKSlq2bKlbDabIiMj9cgjj+jChQs+ihZXEhERoVOnTpV5/t/fluzcuXOSpM8++0zbt293P3bt2uVxXrokBQQEuP+3WCwezy8Nu9SVXZIGDBigkydP6u2339aGDRu0YcMGSRdvH1ccm81WonW4UtuSdPLkSffRegAAAAC4xNAi/b333lNycrImTZqkrVu3qn379urbt2+ho46XLFmyROPGjdOkSZOUnp6uv//973rvvff01FNP+Thyc7pUaF7y/fffKyYmRn5+foqNjVV+fr7HNCdOnFBGRoZat24tSYqNjdW6des8lrFu3Tq1aNFCfn5+JYqhQ4cO2r17t8cF634fzyX5+fnasmWLYmNji11W69atFRQUpMzMTDVv3tzjERkZWaJ4inJpvZ9++mndfPPNio2NLfTDwqWryv++B0FYWJiio6OVmppa5rYv+fHHH9WhQ4dyLwcAAABA1WLoOekzZszQiBEjNHz4cEkX76/92Wefaf78+Ro3blyh6devX6/rrrtOQ4YMkSRFR0dr8ODBhYrT6iozM1PJycl6+OGHtXXrVr322mvuq7PHxMTotttu04gRI/Tmm28qLCxM48aNU+PGjXXbbbdJkh599FF17txZzz77rAYNGqS0tDTNnj1br7/+eoljuOmmm3Tu3Dn99NNPatOmjce4OXPmKCYmRrGxsZo5c6ZOnTqlBx98sNhlhYWF6bHHHtMjjzwip9Op66+/XmfOnNG6desUHh6uYcOGlWErSbVr11adOnX01ltvqWHDhsrMzCz0fqtXr55sNptWrlypJk2aKDg4WDVr1tTkyZP117/+VfXq1dMtt9yis2fPat26dfrb3/5W4vb379+vgwcPqlevXmWKHwAAAEDVZViRnpeXpy1btmj8+PHuYVarVb169VJaWlqR83Tr1k3/+Mc/tHHjRnXp0kW//PKLPv/8cz3wwAPFtpObm6vc3Fz38+zsbEmSw+FwX9X8EofDIZfLJafT6dE9+dL/2Yf2S4UPEHtd9uH97nb/2E36ch544AHl5OSoS5cu8vPz0//93//pL3/5i3sZf//73zV27FjdeuutysvL0w033KBPP/1Ufn5+cjqdiouL07JlyzR58mQ9++yzatiwoaZMmaKhQ4d6xHFpGxWldu3aGjhwoP7xj3/ohRdecK+HdPEiatOmTdP27dvVvHlzLV++XFdddZXHejqdTvdReJfLpSlTpigiIkJTp07VL7/8olq1aqlDhw4aP358ofl+///v/15a1u+HLVmyRGPHjlWbNm3UsmVLpaSkqGfPnu7lWK1WpaSk6LnnntPEiRN1ww036N///rd7G8+aNUuPPfaYIiIidOeddxZ6v/xx+/x+2JIlS9S7d29FRkYWuR0vbQOHw1HiHgzA5Vz6rPvjZx7Mg9cGAABcYnEV1S/ZBw4dOqTGjRtr/fr1HhcUe+KJJ/TNN98Ue3T81Vdf1WOPPSaXy6X8/Hz99a9/1RtvvFFsO5MnT9aUKVMKDV+yZIlCQkI8hvn7+6tBgwaKjIx0d3eWpAMHDqhLfLwu2O2lXc0yC7bZtHHDhhJ367711lvVtm1bTZ06tYIju7Iff/xRd9xxh7Zu3arQ0FBlZmaqffv2Wrt2rdq2bWt0eIbKy8tTx44d9fbbb6tr167FTnPgwAEdOXJE+fn5Po4QgBFycnI0ZMgQnTlzRuHh4UaHAwAADFSpbsG2Zs0avfDCC3r99dcVHx+vvXv3asyYMXr22Wfdtw37o/Hjxys5Odn9PDs7W5GRkerTp0+hL0IXLlzQgQMHFBoa6nGF8j/96U9K37VLWVlZFbNiRYiIiFBUVFSJp/f391dgYKApvtx169ZN06ZN04kTJ9SoUSOFhoZK+u+Vzq/E5XLp7NmzCgsL87hafVWwd+9ePfXUU+rTp0+x01y4cEE2m03du3cv9kr5Vdl//vMfderUWXZ71b76vc0Wos2bN6lJkyYV3pbD4dDq1avVu3fvQhc2hDlc6uUFAABgWJEeEREhPz8/HT161GP40aNHPe5L/XsTJkzQAw88oP+/vbuPi6rO+z/+noEZGDRvalIRMbDFu58KKUnYFdmupeu1XlltmlYqle6VUrSTa9kqeHOZlWVYmj7MS7vzrrt1u9V1KWVTUtNEt1DTcnE1UKSkYGRGZn5/eDkbgS4gzByY1/Px8PHgfOd8z/dz4JzHY96ec77nvvvukyT17t1bZWVlmjBhgv74xz/KbK4+D15YWJjCwsKqtVsslmpfVisrK2UymWQ2m6ttKyYmxveaLqM6V7sR/PRZ83M11fR7rcm5W8CNtD8NpWvXruratesF1zGbzb4Z6oMxUH333XcqKTmppHsy1SoyJtDlNIrSbw9r2/KZ+u677xQbG+u3cYP1mGoK+LsAAIBzAhbSrVar+vXrp+zsbA0fPlzS2XCWnZ2ttLS0GvuUl5dXC23nntkN0F37hrFp06ZAl3BeMTExQf/3Qd21iozRpZ27BboMAAAAwK8Ceru7w+HQ2LFjlZiYqP79+ysrK0tlZWW+2d7HjBmjqKgo33PWw4YN0/z583XVVVf5bnefPn26hg0bxgRbAAAAAIAmL6AhfeTIkTpx4oQyMjJUWFiohIQErV+/Xu3bt5d09pViP71yPm3aNJlMJk2bNk1Hjx7V5ZdfrmHDhmnOnDmB2gUAAAAAABpMwCeOS0tLO+/tiudGqAAAK8JJREFU7T+/hTs0NFSZmZnKzMz0Q2UAAAAAAPhX85qVCwAAAACAJoyQDgAAAACAQRDSAQAAAAAwiIA/k95UFBQUqLi42G/j2e12de7c2W/j1UZMTIweeughPfTQQ4EuBQAAAACaJUJ6LRQUFKhH924qd57225gRtnDl79tvuKAOAAAAAGg8hPRaKC4uVrnztF6bkKAekS0bfbz8b3/UXUt3q7i4mJAOAAAAAEGEkF4HPSJbqm9M60CXUaOBAweqV69ekqRXX31VFotF999/v2bNmiWTyaTvvvtO6enpevfdd1VRUaHrr79ezz33nOLi4nzbeOutt5SRkaGDBw8qMjJSDzzwgB5++OFA7RIAAAAABB0mjmtGXn75ZYWGhmr79u1asGCB5s+fr2XLlkmSxo0bp88++0zvvPOOcnNz5fV6NXToULndbknSzp07NWLECN1xxx3au3evZsyYoenTp+ull14K4B4BAAAAQHDhSnozEh0drWeffVYmk0ndunXT3r179eyzz2rgwIF65513tGXLFg0YMECStHLlSkVHR2vdunW6/fbbNX/+fP3qV7/S9OnTJUldu3bVl19+qXnz5mncuHEB3CsAAAAACB5cSW9GrrnmGplMJt9ycnKyvvrqK3355ZcKDQ1VUlKS77PLLrtM3bp1U35+viQpPz9f1157bZXtXXvttfrqq69UWVnpnx0AAAAAgCBHSAcAAAAAwCAI6c3Itm3bqix/+umniouLU8+ePXXmzJkqn588eVL79+9Xz549JUk9evTQli1bqvTfsmWLunbtqpCQkMYvHgAAAABASG9OCgoK5HA4tH//fq1evVrPP/+80tPTFRcXp5tvvlnjx4/XJ598ory8PN11112KiorSzTffLEl6+OGHlZ2drdmzZ+vAgQN6+eWXtXDhQk2ePDnAewUAAAAAwYOJ4+og/9sfDT3OmDFj5HQ61b9/f4WEhCg9PV0TJkyQJK1YsULp6en6zW9+I5fLpZSUFH3wwQeyWCySpL59++r1119XRkaGZs+ercjISM2aNYtJ4wAAAADAjwjptWC32xVhC9ddS3f7bcwIW7jsdnud+lgsFmVlZWnx4sXVPmvbtq1eeeWVC/a/7bbbdNttt53388OHD9epHgAAAABA3RDSa6Fz587K37dfxcXFfhvTbrerc+fOfhsPAAAAABB4hPRa6ty5M6EZAAAAANCoCOnNxKZNmwJdAgAAAADgIjG7OwAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCV7DVUkFBgYqLi/02nt1u573sAAAAABBkCOm1UFBQoO49ustZ7vTbmLYIm/bl76t1UB84cKASEhKUlZXVuIXVktHqAQAAAICmgJBeC8XFxXKWO5UyJUWto1s3+ninjpxSzlM5Ki4u9uvVdJfLJavV6rfxAAAAAABV8Ux6HbSObi17nL3R/9X1PwLGjRunzZs3a8GCBTKZTDKZTDp06JDuvfdexcbGymazqVu3blqwYEG1fsOHD9ecOXPUsWNHdevWTZK0detWJSQkKDw8XImJiVq3bp1MJpN2797t6/v3v/9dv/71r9WyZUu1b99ed999t+9xgJrqOXz48EX97gEAAAAgGHAlvRlYsGCBDhw4oF69emnWrFmSpLZt26pTp0564403dNlll2nr1q2aMGGCIiMjNWLECF/f7OxstWrVShs3bpQklZaWatiwYRo6dKhWrVqlf/zjH3rooYeqjPf999/rl7/8pe677z49++yzcjqdeuSRRzRixAh99NFHNdZz+eWX++eXAQAAAABNGCG9GWjdurWsVqsiIiLUoUMHX/vMmTN9P8fGxio3N1evv/56lZDeokULLVu2zHeb+5IlS2QymfTiiy8qPDxcPXv21NGjRzV+/Hhfn4ULF+qqq67S448/7mtbvny5oqOjdeDAAXXt2rXGegAAAAAAF0ZIb8YWLVqk5cuXq6CgQE6nUy6XSwkJCVXW6d27d5Xn0Pfv368+ffooPDzc19a/f/8qffLy8vTxxx+rZcuW1cY8dOiQunbt2rA7AgAAAABBgpDeTK1Zs0aTJ0/WM888o+TkZF1yySWaN2+etm3bVmW9Fi1a1HnbP/74o4YNG6Ynn3yy2meRkZH1rhkAAAAAgh0hvZmwWq2qrKz0LW/ZskUDBgzQxIkTfW2HDh36t9vp1q2bXnvtNVVUVCgsLEyStGPHjirr9O3bV2+99ZZiYmIUGlrzIfTzegAAAAAA/x6zuzcTMTEx2rZtmw4fPqzi4mLFxcXps88+04YNG3TgwAFNnz69WtiuyejRo+XxeDRhwgTl5+drw4YNevrppyVJJpNJkjRp0iSVlJRo1KhR2rFjhw4dOqQNGzYoNTXVF8x/Xo/H42m8nQcAAACAZoIr6XVw6sgpw44zefJkjR07Vj179pTT6dS+ffv0+eefa+TIkTKZTBo1apQmTpyoDz/88ILbadWqld59913df//9SkhIUO/evZWRkaHRo0f7nlPv2LGjtmzZokceeUQ33XSTKioqdMUVV2jIkCEym8011vPNN98oJiamzvsFAAAAAMGEkF4Ldrtdtgibcp7K8duYtgib7HZ7rdfv2rWrcnNzq7StWLFCK1asqNI2d+5c388vvfRSjdsaMGCA8vLyfMsrV66UxWJR586dfW1xcXF6++2361QPAAAAAODCCOm10LlzZ+3L36fi4mK/jWm326uEYn965ZVX1KVLF0VFRSkvL8/3DnSbzRaQegAAAAAgWBDSa6lz584BC83+VlhYqIyMDBUWFioyMlK333675syZE+iyAAAAAKDZI6SjmilTpmjKlCmBLgMAAAAAgg6zuwMAAAAAYBCE9Bp4vd5Al4AgxvEHAAAABC9C+k9YLBZJUnl5eYArQTA7d/ydOx4BAAAABA+eSf+JkJAQtWnTRsePH5ckRUREyGQyBbiq4OPxeORyuXT69Gnfe9eDgdfrVXl5uY4fP642bdooJCQk0CUBAAAA8DNC+s906NBBknxBHf7n9XrldDpls9mC8j9J2rRp4zsOAQAAAAQXQvrPmEwmRUZGql27dnK73YEuJyi53W7l5OQoJSUl6G75tlgsXEEHAAAAghgh/TxCQkIISwESEhKiM2fOKDw8POhCOgAAAIDgFjwP/AIAAAAAYHCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABhEwEP6okWLFBMTo/DwcCUlJWn79u0XXP/777/XpEmTFBkZqbCwMHXt2lUffPCBn6oFAAAAAKDxhAZy8LVr18rhcGjJkiVKSkpSVlaWBg8erP3796tdu3bV1ne5XLrxxhvVrl07vfnmm4qKitI//vEPtWnTxv/FAwAAAADQwAIa0ufPn6/x48crNTVVkrRkyRK9//77Wr58uR599NFq6y9fvlwlJSXaunWrLBaLJCkmJsafJQMAAAAA0GgCFtJdLpd27typqVOn+trMZrMGDRqk3NzcGvu88847Sk5O1qRJk/TnP/9Zl19+uUaPHq1HHnlEISEhNfapqKhQRUWFb7m0tFSS5Ha75Xa7G3CP0FDO/V34+wQnj8cjm80mi1kKNXkCXU6jsJglm80mj8fjl+Occ8r4+NsAAIBzAhbSi4uLVVlZqfbt21dpb9++vfbt21djn6+//lofffSR7rzzTn3wwQc6ePCgJk6cKLfbrczMzBr7zJ07VzNnzqzW/pe//EUREREXvyNoNBs3bgx0CQiQ1atX/99PxQGto9G0a6sJq1fr6NGjOnr0qN+G5ZwyrvLy8kCXAAAADCKgt7vXlcfjUbt27bR06VKFhISoX79+Onr0qObNm3fekD516lQ5HA7fcmlpqaKjo3XTTTepVatW/ioddeB2u7Vx40bdeOONvscaEDzy8vKUkpKiGya/oLbRcYEup1F8d+Qrffz0ROXk5Cg+Pr7Rx+OcMr5zd3kBAAAELKTb7XaFhISoqKioSntRUZE6dOhQY5/IyEhZLJYqt7b36NFDhYWFcrlcslqt1fqEhYUpLCysWrvFYuHLqsHxNwpOZrNZTqdTbo90xhvwF1A0CrdHcjqdMpvNfj3GOaeMi78LAAA4J2DfgK1Wq/r166fs7Gxfm8fjUXZ2tpKTk2vsc+211+rgwYPyeP71nOqBAwcUGRlZY0AHAAAAAKApCehlKofDoRdffFEvv/yy8vPzdf/996usrMw32/uYMWOqTCx3//33q6SkROnp6Tpw4IDef/99Pf7445o0aVKgdgEAAAAAgAYT0GfSR44cqRMnTigjI0OFhYVKSEjQ+vXrfZPJFRQUyGz+1/8jREdHa8OGDfr973+vPn36KCoqSunp6XrkkUcCtQsAAAAAADSYgE8cl5aWprS0tBo/27RpU7W25ORkffrpp41cFQAAAAAA/tc8Z2UCAAAAAKAJqldI//jjjxu6DgAAAAAAgl69QvqQIUN05ZVX6n/+53905MiRhq4JAAAAAICgVK+QfvToUaWlpenNN99Uly5dNHjwYL3++utyuVwNXR8AAAAAAEGjXiHdbrfr97//vXbv3q1t27apa9eumjhxojp27KgHH3xQeXl5DV0nAAAAAADN3kVPHNe3b19NnTpVaWlp+vHHH7V8+XL169dP1113nb744ouGqBEAAAAAgKBQ75Dudrv15ptvaujQobriiiu0YcMGLVy4UEVFRTp48KCuuOIK3X777Q1ZKwAAAAAAzVq93pP+wAMPaPXq1fJ6vbr77rv11FNPqVevXr7PW7RooaefflodO3ZssEIBAAAAAGju6hXSv/zySz3//PO69dZbFRYWVuM6drudV7UBAAAAAFAH9brdPTMzU7fffnu1gH7mzBnl5ORIkkJDQ3X99ddffIUAAAAAAASJeoX0G264QSUlJdXaT506pRtuuOGiiwIAAAAAIBjVK6R7vV6ZTKZq7SdPnlSLFi0uuigAAAAAAIJRnZ5Jv/XWWyVJJpNJ48aNq3K7e2Vlpfbs2aMBAwY0bIUAAAAAAASJOoX01q1bSzp7Jf2SSy6RzWbzfWa1WnXNNddo/PjxDVshAAAAAABBok4hfcWKFZKkmJgYTZ48mVvbAQAAAABoQPV6BVtmZmZD1wEAAAAAQNCrdUjv27evsrOz1bZtW1111VU1Thx3zq5duxqkOAAAAAAAgkmtQ/rNN9/smyhu+PDhjVUPAAAAAABBq9Yh/ae3uHO7OwAAAAAADa9e70kHAAAAAAANr9ZX0tu2bXvB59B/qqSkpN4FAQAAAAAQrGod0rOyshqxDAAAAAAAUOuQPnbs2MasAwZWUFCg4uJiv43n8XgkSXl5eTKb/fNERkVFhW9ixObKbrerc+fOgS4DAAAAwAXUOqSXlpaqVatWvp8v5Nx6aPoKCgrUo3s3lTtP+21Mm82m1atXKyUlRU6n0y9jmk2Sx+uXoQLGFmHTvvx9BHUAAADAwOr0TPq3336rdu3aqU2bNjU+n+71emUymVRZWdmgRSJwiouLVe48rdcmJKhHZEu/jOkxW3VUUs6jyTJ7XI0+3q6vT2j8q/t11Zir1OnqTo0+XiCcOnJKOU/lqLi4mJAOAAAAGFitQ/pHH32kSy+9VJL08ccfN1pBMKYekS3VN6a1X8Zyy6KjkuI7t5JF7kYfr6y8TJLUskNL2ePsjT4eAAAAAJxPrUP69ddfX+PPAID6yc/P98s4gZjnQWKuBwAAgPqodUj/ue+++07/+7//6/uS2bNnT6WmpvqutgMAauauOPsYx1133eWX8QIxz4PEXA8AAAD1Ua+QnpOTo2HDhql169ZKTEyUJD333HOaNWuW3n33XaWkpDRokQDQnJw5c0aSNPvWrhrau12jj+fveR4k5noAAACor3qF9EmTJmnkyJFavHixQkJCJEmVlZWaOHGiJk2apL179zZokQDQHMXaI/wy14O/53mQmOsBAACgvur1cOLBgwf18MMP+wK6JIWEhMjhcOjgwYMNVhwAAAAAAMGkXiG9b9++NU54lJ+fr/j4+IsuCgAAAACAYFTr29337Nnj+/nBBx9Uenq6Dh48qGuuuUaS9Omnn2rRokV64oknGr5KAAAAAACCQK1DekJCgkwmk7zef03VO2XKlGrrjR49WiNHjmyY6gAAAAAACCK1DunffPNNY9YBAAAAAEDQq3VIv+KKKxqzDgAAAAAAgl69XsF2zpdffqmCggK5XFXfu/tf//VfF1UUAAAAAADBqF4h/euvv9Ytt9yivXv3VnlO3WQySTr7znQAAAAAAFA39XoFW3p6umJjY3X8+HFFREToiy++UE5OjhITE7Vp06YGLhEAAAAAgOBQryvpubm5+uijj2S322U2m2U2m/Uf//Efmjt3rh588EF9/vnnDV0nAAAAAADNXr2upFdWVuqSSy6RJNntdh07dkzS2cnl9u/f33DVAQAAAAAQROp1Jb1Xr17Ky8tTbGyskpKS9NRTT8lqtWrp0qXq0qVLQ9cIAAAAAEBQqFdInzZtmsrKyiRJs2bN0m9+8xtdd911uuyyy7R27doGLRAAAAAAgGBRr5A+ePBg38+/+MUvtG/fPpWUlKht27a+Gd4BAAAAAEDdXNR70iXpyJEjkqTo6OiLLgYAAAAAgGBWr4njzpw5o+nTp6t169aKiYlRTEyMWrdurWnTpsntdjd0jQAAAAAABIV6XUl/4IEH9Pbbb+upp55ScnKypLOvZZsxY4ZOnjypxYsXN2iRAAAAAAAEg3qF9FWrVmnNmjX69a9/7Wvr06ePoqOjNWrUKEI6AAAAAAD1UK/b3cPCwhQTE1OtPTY2Vlar9WJrAgAAAAAgKNUrpKelpWn27NmqqKjwtVVUVGjOnDlKS0trsOIAAAAAAAgmtb7d/dZbb62y/Ne//lWdOnVSfHy8JCkvL08ul0u/+tWvGrZCAAAAAACCRK1DeuvWrass33bbbVWWeQUbAAAAAAAXp9YhfcWKFY1ZBwAAAAAAQa9ez6Sfc+LECX3yySf65JNPdOLEiXpvZ9GiRYqJiVF4eLiSkpK0ffv2WvVbs2aNTCaThg8fXu+xAQAAAAAwinqF9LKyMt1zzz2KjIxUSkqKUlJS1LFjR917770qLy+v07bWrl0rh8OhzMxM7dq1S/Hx8Ro8eLCOHz9+wX6HDx/W5MmTdd1119VnFwAAAAAAMJx6hXSHw6HNmzfr3Xff1ffff6/vv/9ef/7zn7V582Y9/PDDddrW/PnzNX78eKWmpqpnz55asmSJIiIitHz58vP2qays1J133qmZM2eqS5cu9dkFAAAAAAAMp9bPpP/UW2+9pTfffFMDBw70tQ0dOlQ2m00jRozQ4sWLa7Udl8ulnTt3aurUqb42s9msQYMGKTc397z9Zs2apXbt2unee+/V3/72twuOUVFRUeVVcaWlpZIkt9stt9tdqzqDmcfjkc1mk8dslVsWv4x5bhx/jecNscpms8kaYlWot16nhOFZTJazf0ePx/DH/bljzmKWQk2eQJfTKKwhJtlsNik0zC/Hub/PKYnzqq6Mfl4CAAD/MXm9Xm9dO0VERGjnzp3q0aNHlfYvvvhC/fv3V1lZWa22c+zYMUVFRWnr1q1KTk72tU+ZMkWbN2/Wtm3bqvX55JNPdMcdd2j37t2y2+0aN26cvv/+e61bt67GMWbMmKGZM2dWa1+1apUiIiJqVScAAI2pvLxco0eP1qlTp9SqVatAlwMAAAKoXpc3kpOTlZmZqVdeeUXh4eGSJKfTqZkzZ1YJ2w3thx9+0N13360XX3xRdru9Vn2mTp0qh8PhWy4tLVV0dLRuuukmvgjVQl5enlJSUpTzaLLiO/vn9+WWRRvb3qkbv1spixr/6lLu/m81ZMEeDXhogLqkNM/HJ04eOqkP//ChcnJyFB8fH+hyLujcMXfD5BfUNjou0OU0im/371HuCw/rxdQ+GnF1ZKOP5+9zSuK8qqtzd3kBAADUK6RnZWVpyJAh6tSpk++LSV5ensLDw7Vhw4Zab8dutyskJERFRUVV2ouKitShQ4dq6x86dEiHDx/WsGHDfG0ez9nbYUNDQ7V//35deeWVVfqEhYUpLCys2rYsFossFv/d+tlUmc1mOZ1OmT0uv325P8cit1/GNFW65HQ65ap06YzpTKOPFwhur/vs39FsNvxxf+6Yc3ukM96LegGFYbkqvXI6ndKZCr+eV/46pyTOq7oy+nkJAAD8p14hvXfv3vrqq6+0cuVK7du3T5I0atQo3XnnnWefs6wlq9Wqfv36KTs72/caNY/Ho+zsbKWlpVVbv3v37tq7d2+VtmnTpumHH37QggULFB0dXZ/dAQAAAADAEOoc0t1ut7p376733ntP48ePv+gCHA6Hxo4dq8TERPXv319ZWVkqKytTamqqJGnMmDGKiorS3LlzFR4erl69elXp36ZNG0mq1g4AAAAAQFNT55BusVh0+vTpBitg5MiROnHihDIyMlRYWKiEhAStX79e7du3lyQVFBTIbG6et7wCAAAAAPBT9brdfdKkSXryySe1bNkyhYZe/Kt10tLSary9XZI2bdp0wb4vvfTSRY8PAAAAAIAR1Cth79ixQ9nZ2frLX/6i3r17q0WLFlU+f/vttxukOAAAAAAAgkm9QnqbNm102223NXQtAAAAAAAEtTqFdI/Ho3nz5unAgQNyuVz65S9/qRkzZtRpRncAAAAAAFCzOs3INmfOHD322GNq2bKloqKi9Nxzz2nSpEmNVRsAAAAAAEGlTiH9lVde0QsvvKANGzZo3bp1evfdd7Vy5Up5PJ7Gqg8AAAAAgKBRp5BeUFCgoUOH+pYHDRokk8mkY8eONXhhAAAAAAAEmzqF9DNnzig8PLxKm8VikdvtbtCiAAAAAAAIRnWaOM7r9WrcuHEKCwvztZ0+fVr//d//XeU1bLyCDQAAAACAuqtTSB87dmy1trvuuqvBigEAAAAAIJjVKaSvWLGiseoAAAAAACDo1emZdAAAAAAA0HgI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgzBESF+0aJFiYmIUHh6upKQkbd++/bzrvvjii7ruuuvUtm1btW3bVoMGDbrg+gAAAAAANBUBD+lr166Vw+FQZmamdu3apfj4eA0ePFjHjx+vcf1NmzZp1KhR+vjjj5Wbm6vo6GjddNNNOnr0qJ8rBwAAAACgYYUGuoD58+dr/PjxSk1NlSQtWbJE77//vpYvX65HH3202vorV66ssrxs2TK99dZbys7O1pgxY/xS808VFBSouLjY7+P6S35+fqBLAAAAAICgEdCQ7nK5tHPnTk2dOtXXZjabNWjQIOXm5tZqG+Xl5XK73br00ktr/LyiokIVFRW+5dLSUkmS2+2W2+2+iOqlf/7zn0pMvFpOZ/lFbcfobLYIHfvRo96y+GU89/+N4/bTeN4Qq2w2m6whVoV6A/7/Vo3CYrLIZrPJ4/Fc9HHf2Dwej2w2myxmKdTkCXQ5jcIaYpLNZpNCw/xynPv7nJI4r+rK6OclAADwH5PX6/UGavBjx44pKipKW7duVXJysq99ypQp2rx5s7Zt2/ZvtzFx4kRt2LBBX3zxhcLDw6t9PmPGDM2cObNa+6pVqxQREXFxOwAAQAMoLy/X6NGjderUKbVq1SrQ5QAAgABq0pc3nnjiCa1Zs0abNm2qMaBL0tSpU+VwOHzLpaWlvufYL/aLUF5enlJSUnTD5BfUNjruorZlVN/u36PcFx7Wi6l9NOLqSL+M6ZZFG9veqRu/WymLGv/qUu7+bzVkwR4NeGiAuqR0afTxAuHkoZP68A8fKicnR/Hx8YEu54I4rxqev88pifOqrs7d5QUAABDQkG632xUSEqKioqIq7UVFRerQocMF+z799NN64okn9Ne//lV9+vQ573phYWEKCwur1m6xWGSxXNytn2azWU6nU26PdMYb8Dn4GoWr0iun0ymdqfDbl/tzLHL7ZUxTpUtOp1OuSpfOmM40+niB4Pa65XQ6ZTabL/q4b2ycV43HX+eUxHlVV0Y/LwEAgP8E9Buw1WpVv379lJ2d7WvzeDzKzs6ucvv7zz311FOaPXu21q9fr8TERH+UCgAAAABAowv47e4Oh0Njx45VYmKi+vfvr6ysLJWVlflmex8zZoyioqI0d+5cSdKTTz6pjIwMrVq1SjExMSosLJQktWzZUi1btgzYfgAAAAAAcLECHtJHjhypEydOKCMjQ4WFhUpISND69evVvn17SWdfcWY2/+uC/+LFi+VyufTb3/62ynYyMzM1Y8YMf5YOAAAAAECDCnhIl6S0tDSlpaXV+NmmTZuqLB8+fLjxCwIAAAAAIACa56xMAAAAAAA0QYR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAI6QAAAAAAGAQhHQAAAAAAgyCkAwAAAABgEIR0AAAAAAAMgpAOAAAAAIBBENIBAAAAADAIQjoAAAAAAAZBSAcAAAAAwCAMEdIXLVqkmJgYhYeHKykpSdu3b7/g+m+88Ya6d++u8PBw9e7dWx988IGfKgUAAAAAoPEEPKSvXbtWDodDmZmZ2rVrl+Lj4zV48GAdP368xvW3bt2qUaNG6d5779Xnn3+u4cOHa/jw4fr73//u58oBAAAAAGhYAQ/p8+fP1/jx45WamqqePXtqyZIlioiI0PLly2tcf8GCBRoyZIj+8Ic/qEePHpo9e7b69u2rhQsX+rlyAAAAAAAaVmggB3e5XNq5c6emTp3qazObzRo0aJByc3Nr7JObmyuHw1GlbfDgwVq3bl2N61dUVKiiosK3fOrUKUlSSUmJ3G73RdVfWlqq8PBw/Xj0gOR2XtS2jMpZ+LXCw8O1v9ilTQd+8MuYHrNV5f+vXH87+KPMHlejj/f3Yy6Fh4er/Fi5ivcWN/p4gfDDtz8oPDxcpaWlOnnyZKDLuSDOq4bn73NK4ryq87Z+OHsceL3ehigNAAA0YSZvAL8RHDt2TFFRUdq6dauSk5N97VOmTNHmzZu1bdu2an2sVqtefvlljRo1ytf2wgsvaObMmSoqKqq2/owZMzRz5szG2QEAABrQkSNH1KlTp0CXAQAAAiigV9L9YerUqVWuvHs8HpWUlOiyyy6TyWQKYGU4n9LSUkVHR+vIkSNq1apVoMsBmjzOKePzer364Ycf1LFjx0CXAgAAAiygId1utyskJKTaFfCioiJ16NChxj4dOnSo0/phYWEKCwur0tamTZv6Fw2/adWqFYECaECcU8bWunXrQJcAAAAMIKATx1mtVvXr10/Z2dm+No/Ho+zs7Cq3v/9UcnJylfUlaePGjeddHwAAAACApiLgt7s7HA6NHTtWiYmJ6t+/v7KyslRWVqbU1FRJ0pgxYxQVFaW5c+dKktLT03X99dfrmWee0X/+539qzZo1+uyzz7R06dJA7gYAAAAAABct4CF95MiROnHihDIyMlRYWKiEhAStX79e7du3lyQVFBTIbP7XBf8BAwZo1apVmjZtmh577DHFxcVp3bp16tWrV6B2AQ0sLCxMmZmZ1R5TAFA/nFMAAABNR0BndwcAAAAAAP8S0GfSAQAAAADAvxDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkwlEWLFikmJkbh4eFKSkrS9u3bA10S0KTl5ORo2LBh6tixo0wmk9atWxfokgAAAHABhHQYxtq1a+VwOJSZmaldu3YpPj5egwcP1vHjxwNdGtBklZWVKT4+XosWLQp0KQAAAKgFXsEGw0hKStLVV1+thQsXSpI8Ho+io6P1wAMP6NFHHw1wdUDTZzKZ9Kc//UnDhw8PdCkAAAA4D66kwxBcLpd27typQYMG+drMZrMGDRqk3NzcAFYGAAAAAP5DSIchFBcXq7KyUu3bt6/S3r59exUWFgaoKgAAAADwL0I6AAAAAAAGQUiHIdjtdoWEhKioqKhKe1FRkTp06BCgqgAAAADAvwjpMASr1ap+/fopOzvb1+bxeJSdna3k5OQAVgYAAAAA/hMa6AKAcxwOh8aOHavExET1799fWVlZKisrU2pqaqBLA5qsH3/8UQcPHvQtf/PNN9q9e7cuvfRSde7cOYCVAQAAoCa8gg2GsnDhQs2bN0+FhYVKSEjQc889p6SkpECXBTRZmzZt0g033FCtfezYsXrppZf8XxAAAAAuiJAOAAAAAIBB8Ew6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSgWZk4MCBeuihh877eUxMjLKysvxWDwAAAIC6IaQDQWTHjh2aMGFCoMv4t95++20lJiaqTZs2atGihRISEvTqq68GuiwAAACg0YUGugAA/nP55Zc3+hgul0tWq/WitnHppZfqj3/8o7p37y6r1ar33ntPqampateunQYPHtxAlQIAAADGw5V0oJk5c+aM0tLS1Lp1a9ntdk2fPl1er1dS9dvdTSaTli1bpltuuUURERGKi4vTO++84/u8srJS9957r2JjY2Wz2dStWzctWLCgynjjxo3T8OHDNWfOHHXs2FHdunXTrFmz1KtXr2q1JSQkaPr06f92HwYOHKhbbrlFPXr00JVXXqn09HT16dNHn3zyST1/KwAAAEDTQEgHmpmXX35ZoaGh2r59uxYsWKD58+dr2bJl511/5syZGjFihPbs2aOhQ4fqzjvvVElJiSTJ4/GoU6dOeuONN/Tll18qIyNDjz32mF5//fUq28jOztb+/fu1ceNGvffee7rnnnuUn5+vHTt2+Nb5/PPPtWfPHqWmptZpf7xer2/7KSkpdeoLAAAANDXc7g40M9HR0Xr22WdlMpnUrVs37d27V88++6zGjx9f4/rjxo3TqFGjJEmPP/64nnvuOW3fvl1DhgyRxWLRzJkzfevGxsYqNzdXr7/+ukaMGOFrb9GihZYtW1blNvfBgwdrxYoVuvrqqyVJK1as0PXXX68uXbrUaj9OnTqlqKgoVVRUKCQkRC+88IJuvPHGOv8+AAAAgKaEK+lAM3PNNdfIZDL5lpOTk/XVV1+psrKyxvX79Onj+7lFixZq1aqVjh8/7mtbtGiR+vXrp8svv1wtW7bU0qVLVVBQUGUbvXv3rvYc+vjx47V69WqdPn1aLpdLq1at0j333FPr/bjkkku0e/du7dixQ3PmzJHD4dCmTZtq3R8AAABoiriSDgQ5i8VSZdlkMsnj8UiS1qxZo8mTJ+uZZ55RcnKyLrnkEs2bN0/btm2r0qdFixbVtjts2DCFhYXpT3/6k6xWq9xut37729/Wui6z2axf/OIXks4+y56fn6+5c+dq4MCBddxDAAAAoOkgpAPNzM8D9Keffqq4uDiFhITUeVtbtmzRgAEDNHHiRF/boUOHatU3NDRUY8eO1YoVK2S1WnXHHXfIZrPVuYZzPB6PKioq6t0fAAAAaAoI6UAzU1BQIIfDod/97nfatWuXnn/+eT3zzDP12lZcXJxeeeUVbdiwQbGxsXr11Ve1Y8cOxcbG1qr/fffdpx49ekg6G/hra+7cuUpMTNSVV16piooKffDBB3r11Ve1ePHieu0HAAAA0FQQ0oFmZsyYMXI6nerfv79CQkKUnp6uCRMm1Gtbv/vd7/T5559r5MiRMplMGjVqlCZOnKgPP/ywVv3j4uI0YMAAlZSUKCkpqdbjlpWVaeLEifrnP/8pm82m7t2767XXXtPIkSPrtR8AAABAU2HynnuBMgA0MK/Xq7i4OE2cOFEOhyPQ5QAAAACGx5V0AI3ixIkTWrNmjQoLC+v8bnQAAAAgWBHSATSKdu3ayW63a+nSpWrbtm2Vz1q2bHnefh9++KGuu+66xi4PAAAAMCRudwfgdwcPHjzvZ1FRURc1CzwAAADQlBHSAQAAAAAwCHOgCwAAAAAAAGcR0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAzi/wNb68WOoaC4hgAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAWpCAYAAAAFtVMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeViU9f7/8dcM6yDihgsqhB5R4bjvaJqVW578anXStHKpY+ekFIZm2nG30rIUt/K0qFlup+V4bDWz1ETT1DRLJLUMjztupCAMzPz+8McUgTrAMHPDPB/XxSVzz33fn/fczsyL98y9mOx2u10AAAAAAMDjzJ4uAAAAAAAAXEWTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABiEr6cLcDebzabjx4+rYsWKMplMni4HAADZ7Xb9+uuvql27tsxmPj93BfIeAGAkRcl6r2vSjx8/rvDwcE+XAQBAAUePHlXdunU9XUa5QN4DAIzImaz3uia9YsWKkq5unJCQEA9Xg8JYrVZ99tln6tGjh/z8/DxdDlDm8ZoyvvT0dIWHhzsyCiVH3juH9wfcCM8R3AjPEecUJeu9rknP2+UtJCSE0DYoq9WqoKAghYSE8EIHXIDXVNnBbtmuQ947h/cH3AjPEdwIz5GicSbrOfANAAAAAACDoEkHAAAAAMAgaNIBAAAAADAIrzsmHYD3stvtysnJUW5urqdLcSur1SpfX19duXLF6x67Ufj4+MjX15djzgGglHlr1nsSf2f8xs/PTz4+PiVeD006AK+QnZ2tEydOKCMjw9OluJ3dbletWrV09OhRmkQPCgoKUlhYmPz9/T1dCgCUS96c9Z7E3xm/MZlMqlu3roKDg0u0Hpp0AOWezWbTzz//LB8fH9WuXVv+/v5eFSI2m02XLl1ScHCwzGaOcnI3u92u7OxsnTlzRj///LOioqL4fwAAF/P2rPck/s64ym6368yZM/rf//6nqKioEn2jTpMOoNzLzs6WzWZTeHi4goKCPF2O29lsNmVnZyswMNCrw9OTLBaL/Pz89Msvvzj+LwAAruPtWe9J/J3xm+rVq+vIkSOyWq0latK9eysC8CreHhzwLJ5/AFD6eK+FJ7lq7w2exQAAAAAAGARNOgDgurp27apRo0YZZj0AAMD1yHvj4Jh0AIBLbdy4UbfeeqvOnz+vypUrO6a///778vPz81xhAADAZfLy/uzZs/kOMyDvS44mHQDgFlWrVvV0CQAAoJSR9yXH7u4AYFBdu3ZVXFyc4uLiVKlSJYWGhmrixImy2+2SpPPnz2vw4MGqUqWKgoKCdMcdd+jgwYOO5ZcuXarKlStrzZo1at26tYKCgtSzZ08dPXrUMc/QoUPVr1+/fOOOGjVKXbt2vWZdb731ltq0aaOKFSuqVq1aGjRokE6fPi1JOnLkiG699VZJUpUqVWQymTR06FDH4/n97m/O1r9u3TpFR0crODhYvXr10okTJ4qzOQEAMCRX5n1UVJQCAwPdmvfVqlVTlSpVNGzYMMfjIe9LhiYdAAzszTfflK+vr3bs2KG5c+dq9uzZev311yVdDdydO3dq7dq12rZtm+x2u3r37i2r1epYPiMjQzNmzNArr7yir776ShcuXNB9991XopqsVqumT5+uvXv3as2aNTpy5IijEQ8PD9d7770nSUpJSdGJEyc0d+7cQtfjbP0vvvii3nrrLW3evFmpqakaM2ZMieoHAMBoXJH3zz77rJYtW6akpCS35n1ycrIOHDigxMTEQtdD3hcdu7sDgIGFh4drzpw5MplMatSokfbt26c5c+aoa9euWrt2rZKSktSxY0dJ0vLlyxUeHq41a9bo3nvvlXQ1YOfNm6fo6GiFhITozTffVHR0tHbs2KF27doVq6aHHnrI8Xv9+vU1b948tW3bVpcuXVJwcLBjN7caNWrkOyb99w4ePOh0/YsWLdKf/vQnSVJcXJymTZtWrLoBADAqV+T9ggUL1L59e0lye96bzWaFhIQUWAd5Xzx8kw4ABtahQ4d819yMjY3VwYMHtX//fvn6+jrCWLq6u1mjRo2UnJzsmObr66u2bds6bjdu3FiVK1fON09R7dq1S3369FFERIQqVqyoW265RZKUmprq9DqSk5Odqj8oKMgR2JIUFhbm2NUOAIDygrwn73+PJh0AvJjZbHYc85bn97uf/dHly5fVs2dPhYSEaPny5frmm2/0n//8R5KUnZ3t8vr+eHZYk8lUoF4AAHB95H3ZQpMOAAa2ffv2fLe//vprRUVFKSYmRjk5OfnuP3v2rFJSUhQTE+OYlpOTo507dzpup6Sk6MKFC4qOjpYkVa9evcCJWfbs2XPNeg4cOKCzZ89q5syZ6ty5sxo3blzgk25/f39JUm5u7jXXEx0d7VT9AAB4A/Iev0eTDgAGlpqaqoSEBKWkpGjlypWaP3++4uPjFRUVpb59+2r48OHasmWL9u7dqwceeEB16tRR3759Hcv7+fkpPj5eO3fu1K5duzR06FB16NDBcXzabbfdpp07d2rZsmU6ePCgJk+erO+///6a9URERMjf31/z58/XTz/9pLVr12r69On55rnppptkMpn04Ycf6syZM7p06VKB9ThbPwAA3sAVef/YY49p+/btHsn7tLQ08t6FaNIBwMAGDx6szMxMtWvXTiNHjlR8fLweeeQRSdKSJUvUunVr3XnnnYqNjZXdbtfHH3+cb5exoKAgPfnkkxo+fLg6d+6s4OBgrV692nF/z549NXHiRI0dO1Zt27bVr7/+qsGDB1+znurVq2vp0qV65513FBMTo5kzZ+rFF1/MN0+dOnU0depUjRs3TjVr1lRcXFyh63KmfgAAvIEr8v6pp57SoEGD1KlTJ7fm/dNPP62GDRvqscceK3Rd5H3RmexetrN/enq6KlWqpIsXLxZ6BkJ4ntVq1ccff6zevXvz4oVLXLlyRT///LPq1aunwMBAT5fjtK5du6pFixbXvKTJjSxdulSjRo3SuXPnlJ6erpCQEJnNfDbrKdd7HpJNrsc2dQ6ZixspK8+Rspr1kuvy/sKFCy6ty1k2m42/M/4/V2W9d29FAAAAAAAMhCYdAAAAAACD8PV0AQCAwm3cuLFEyw8dOlRDhw6VzWZzTUEAAMDlXJX3KD/4Jh0AAAAAAIOgSQcAAAAAwCBo0gEAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAILgEGwCvlpqaqrS0NLeNFxoaqoiICLeN56zIyEiNGjVKo0aNuuY82dnZiomJ0bJly9SxY0f3FWcAJpNJ//nPf9SvX79C79+/f7969OihlJQUVahQwb3FAQCui6y/iqy/PiNlPU06AK+Vmpqqxo2jlZmZ4bYxLZYgHTiQbMjwvpFFixapXr16ZTq0jxw5onr16unbb79VixYtXLbemJgYdejQQbNnz9bEiRNdtl4AQMmQ9UVD1l+bO7OeJh2A10pLS1NmZobaPzRZIWGRpT5e+okj2r54qtLS0spccNvtdi1YsEDTpk0r8Xpyc3Pl61v+4mfYsGEaPny4xo8fXy4fHwCURWS988j6G3NX1nNMOgCvFxIWqaoRjUr9pzh/HHTt2lVxcXGKi4tTpUqVFBoaqokTJ8putzvmOX/+vAYPHqwqVaooKChId9xxhw4ePJhvPWvXrlXTpk0VEBCgyMhIvfTSS0WqY9euXTp8+LD+8pe/OKYdOXJEJpNJq1atUseOHRUYGKgmTZpo06ZNjnk2btwok8mkTz75RK1bt1ZAQIC2bNkim82mGTNmqF69erJYLGrevLnefffdAsutW7dOLVu2lMVi0W233abTp0/rk08+UXR0tEJCQjRo0CBlZPz27cinn36qm2++WZUrV1a1atV055136vDhw47769WrJ0lq2bKlTCaTunbt6rhv8eLF+vOf/6yAgACFhYUpLi4u3zZIS0vTXXfdpaCgIEVFRWnt2rX57u/evbvOnTuX7/EDAIzBG7L+vffec+SYu7O+SpUqZL0L0aQDgMG9+eab8vX11Y4dOzR37lzNnj1br7/+uuP+oUOHaufOnVq7dq22bdsmu92u3r17y2q1SroausOGDdOAAQO0b98+TZkyRRMnTtTSpUudruGrr75Sw4YNVbFixQL3Pfnkkxo9erS+/fZbxcbGqk+fPjp79my+ecaNG6eZM2cqOTlZzZo104wZM7Rs2TItWrRIP/zwg5544gk98MADBUJvypQpWrBggbZu3aqjR4+qf//+SkxM1IoVK/TRRx/ps88+0/z58x3zX758WQkJCdq5c6c2bNggs9msu+66SzabTZK0Y8cOSdLnn3+uEydO6P3335ckvfLKKxo5cqQeeeQR7du3T2vXrlWDBg3y1TJ16lT1799f3333nXr37q37779f586dc9zv7++vFi1a6KuvvnJ6uwIAILkm6/v376/77rvPY1n/9NNPk/UuUv72QQCAciY8PFxz5syRyWRSo0aNtG/fPs2ZM0fDhw/XwYMHtXbtWiUlJTmOH1u+fLnCw8O1Zs0a3XvvvZozZ45uueUWTZgwQWazWQ0bNtT+/fs1a9YsDR061KkafvnlF9WuXbvQ++Li4nTPPfdIuhqAn376qd544w2NHTvWMc+0adPUvXt3SVJWVpaee+45ff7554qNjZUk1a9fX1u2bNG//vUv3XLLLY7lnnnmGXXq1EmS9PDDD2v8+PE6fPiw6tevL0n661//qi+//FJPPfWUJDnqyLN48WJVr15d+/fvV5MmTVS9enVJUrVq1VSrVq1844wePVrx8fGOaW3bts23rqFDh2rgwIGSpOeee07z5s3Tjh071KtXL8c8tWvX1i+//HL9jQkAwB+UNOtnz56t22+/3XGstCeyfsqUKWS9i/BNOgAYXIcOHWQymRy3Y2NjdfDgQeXm5io5OVm+vr5q37694/5q1aqpUaNGSk5OliQdOHAg3/2S1KlTJ8c6nJGZmanAwMBC78sLX0ny9fVVmzZtHGPnadOmjeP3Q4cOKSMjQ927d1dwcLDjZ9myZfl2V5OkZs2aOX6vWbOmgoKCHKGdN+306dOO2wcPHtTAgQNVv359hYSEKDIyUtLVEwddy+nTp3X8+HHdfvvt19kC+WupUKGCQkJC8o0tSRaLJd8ueQAAOKOkWZ+cnOxodPOQ9b8pa1nv8SZ94cKFioyMVGBgoNq3b+/YPeFaEhMT1ahRI1ksFoWHh+uJJ57QlStX3FQtAHin0NBQnT9/vtjL//5SJZcuXZIkffTRR9qzZ4/jZ//+/fmOVZMkPz8/x+8mkynf7bxpebu3SVKfPn107tw5vfbaa9q+fbu2b98u6eolZa7FYrE49RhuNLYknTt3zvEJPvIj7wHA2Mh642S9R5v01atXKyEhQZMnT9bu3bvVvHlz9ezZs8CnFXlWrFihcePGafLkyUpOTtYbb7yh1atX6+mnn3Zz5QDgPnnhk+frr79WVFSUfHx8FB0drZycnHzznD17VikpKYqJiZEkNW7cuMA6kpKS1LBhQ/n4+DhVQ8uWLXXgwIF8J7H5fT15cnJytGvXLkVHR19zXTExMQoICFBqaqoaNGiQ7yc8PNypegqT97gnTJig22+/XdHR0QX+2PD395ekfN8qVKxYUZGRkdqwYUOxx87z/fffq2XLliVeT3lD3gPA9ZU066Ojo5WUlJRvHWR92c16jx6TPnv2bA0fPlzDhg2TdPW6fB999JEWL16scePGFZh/69at6tSpkwYNGiRJioyM1MCBAws8qQGgPElNTVVCQoL+/ve/a/fu3Zo/f77jjK1RUVHq27evhg8frn/961+qWLGixo0bpzp16qhv376SpISEBLVv317PPPOM7rvvPm3btk0LFizQyy+/7HQNt956qy5duqQffvhBTZo0yXffwoULFRUVpejoaM2ZM0fnz5/XQw89dM11VaxYUWPGjNETTzwhm82mm2++WRcvXlRSUpJCQkI0ZMiQYmwlqUqVKqpWrZpeffVVhYWFKTU1tUCW1KhRQxaLRZ9++qnq1q2rwMBAVapUSVOmTNE//vEP1ahRQ3fccYd+/fVXJSUl6bHHHnN6/CNHjujYsWPq1q1bseovz8h7ALi+kmb96NGj1bZtW02fPl0DBgwg68t41nusSc/OztauXbs0fvx4xzSz2axu3bpp27ZthS7TsWNHvf3229qxY4fatWunn376SR9//LEefPDBa46TlZWlrKwsx+309HRJktVqdZwNEcaS9//C/w9cxWq1ym63y2az5dtlKe/39ONHpIIfGrtc+okjjnH/uOvU9Tz44IPKyMhQu3bt5OPjo8cff1x/+9vfHOt44403NGrUKN15553Kzs5W586d9eGHH8rHx0c2m00tW7bUkiVL9Pzzz+uZZ55RWFiYpk6dqsGDB+erI28bFaZKlSrq16+f3n77bT333HOOxyFdPbHKzJkztWfPHjVo0EBr1qxR1apV8z3OPz7mqVOnKjQ0VDNmzNBPP/2kypUrq2XLlho/fvw1l/vjv3k1/37aihUrNGrUKDVp0kSNGjVSYmKibrvtNsd6zGazEhMT9cwzz2jSpEnq3LmzvvjiC8c2njt3rsaMGaPQ0FDdc889BZ4vf9w+v5+2YsUKde/eXeHh4YVuR5vNJrvdLqvVWuBbjfL8fkfeGxuZixspK88Rb8/6Fi1aaNWqVZoyZYqmT5/u1qzPy+I/rpusL37Wm+yF7c/gBsePH1edOnW0devWfCciGDt2rDZt2nTNT8vnzZunMWPGyG63KycnR//4xz/0yiuvXHOcKVOmaOrUqQWmr1ixQkFBQSV/IAAMz9fXV7Vq1VJ4eLhjFyhJOnr0qNq1b68rmZluqyXQYtGO7dud3tXrzjvvVNOmTTVjxoxSruzGvv/+e919993avXu3goODlZqaqubNm2vz5s1q2rSpp8vzqOzsbLVu3VqvvfaaOnTocM15jh49qpMnTyonJyfffRkZGRo0aJAuXryokJAQd5TsNuQ9AHcg612DrL82d2Z9mboE28aNG/Xcc8/p5ZdfVvv27XXo0CHFx8dr+vTpjssN/NH48eOVkJDguJ2enq7w8HD16NGj3P0hVF5YrVatX79e3bt3L3DyBqA4rly5oqNHjyo4ODjfWUv//Oc/K3n/fqWlpbmtltDQUEVERDg9v6+vr/z9/Uv0fmW32/Xrr7+qYsWK+c4cW1QdO3bUzJkzdfbsWdWuXVvBwcGSfjv7qTc7dOiQnn76afXo0eOa81y5ckUWi0VdunQpcPbcvG99cRV57z5kLm6krDxHvD3rXaU4We+qvzOMzp1Z77EmPTQ0VD4+Pjp16lS+6adOncp3Pbvfmzhxoh588EH97W9/kyQ1bdpUly9f1iOPPKJ//vOfMpsLngcvICBAAQEBBab7+fkZ+o0G/B/BdXJzc2UymWQ2mwu8T0RGRjou3WFUebUXV97uWCVdj6R8x5/lrauw7eptGjZsqIYNG153HrPZ7Dhr7R/f28rzex15XzawnXAjRn+OeHvWu1JRs96Vf2cYmTuz3mNNur+/v1q3bq0NGzaoX79+kq7+B2/YsEFxcXGFLpORkVHgPz5vX38P7bUPAKVq48aNni7hmiIjI3nvxQ2R9wBwfWQ9/siju7snJCRoyJAhatOmjdq1a6fExERdvnzZcfbXwYMHq06dOo7jM/r06aPZs2erZcuWjt3fJk6cqD59+jh9aQEAAOBe5D0AAM7zaJM+YMAAnTlzRpMmTdLJkyfVokULffrpp6pZs6akq5ci+P0n6RMmTJDJZNKECRN07NgxVa9eXX369NGzzz7rqYcAAABugLwHAMB5Hj9xXFxc3DV3d/vjrh++vr6aPHmyJk+e7IbKAACAq5D3AAA4p/we2Q8AAAAAQBlDkw4AAAAAgEHQpAMAAAAAYBAePyYdADwpNTVVaWlpbhsvNDRUERERbhvPGZGRkRo1apRGjRrl6VIAAHA5sp6sL2to0gF4rdTUVEU3bqSMzCtuGzPIEqjkAymGC28AAMojsh5lEU06AK+VlpamjMwrevuRFooOCy718ZJPXNIDr+5RWloawQ0AgBuQ9SiLaNIBeL3osGC1iqzk6TIK1bVrVzVp0kSS9NZbb8nPz0+PPvqopk2bJpPJpPPnzys+Pl4ffPCBsrKydMstt2jevHmKiopyrOO9997TpEmT9NNPPyksLEyPPfaYRo8e7amHBACA23lL1h86dIisLwc4cRwAGNybb74pX19f7dixQ3PnztXs2bP1+uuvS5KGDh2qnTt3au3atdq2bZvsdrt69+4tq9UqSdq1a5fuu+8+3X333dq7d6+mTJmiiRMnaunSpR58RAAA4PdKmvX9+/fXfffdp3379pH15QDfpAOAwYWHh2vOnDkymUxq1KiR9u3bpzlz5qhr165au3atkpKS1LFjR0nS8uXLFR4erjVr1ujee+/V7Nmzddttt+nJJ59USEiIGjdurP3792vWrFkaOnSoZx8YAACQVPKsv/322zVx4kRJUsOGDcn6Mo5v0gHA4Dp06CCTyeS4HRsbq4MHD2r//v3y9fVV+/btHfdVq1ZNjRo1UnJysiQpOTlZnTp1yre+Tp066eDBg8rNzXXPAwAAANdF1uP3aNIBAAAAADAImnQAMLjt27fnu/31118rKipKMTExysnJyXf/2bNnlZKSopiYGElSdHS0kpKS8i2flJSkhg0bysfHp/SLBwAAN0TW4/do0gHA4FJTU5WQkKCUlBStXLlS8+fPV3x8vKKiotS3b18NHz5cW7Zs0d69e/XAAw+oTp066tu3ryRp9OjR+uKLLzRr1iz9+OOPevPNN7VgwQKNGTPGw48KAADkKWnWb9iwQdOnTyfrywlOHAfA6yWfuGTocQYPHqzMzEy1a9dOPj4+io+P1yOPPCJJWrJkieLj43XnnXcqOztbXbp00ccffyw/Pz9JUqtWrbRq1SpNmjRJs2bNUlhYmKZNm8aJZAAAXqW8Z/2///1vTZo0SdOnTyfrywGadABeKzQ0VEGWQD3w6h63jRlkCVRoaGiRlvHz81NiYqJeeeWVAvdVqVJFy5Ytu+7y99xzj7p3766QkBCZzQV3oDpy5EiR6gEAoKzwpqy/5557rnk/WV+20KQD8FoRERFKPpCitLQ0t40ZGhqqiIgIt40HAIA3I+tRFtGkA/BqERERBCkAAOUYWY+yhiYdAAxs48aNni4BAACUIrIef8TZ3QEAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgkuwAfBqqampSktLc9t4oaGhXKsVAAA3IutR1tCkA/BaqampahzdWJkZmW4b0xJk0YHkA06Hd9euXdWiRQslJiaWbmFOMlo9AABcD1lfdEarxxvRpAPwWmlpacrMyFSXsV1UKbxSqY938ehFbX5hs9LS0tz6CXt2drbbxgIAwEi8Kev9/f3dNh5KF8ekA/B6lcIrKTQqtNR/ivrHwdChQ7Vp0ybNnTtXJpNJJpNJhw8f1sMPP6x69erJYrGoUaNGmjt3boHl+vXrp2effVa1a9dWdHS0JGnr1q1q0aKFAgMD1aZNG61Zs0Ymk0l79uxxLPv999/rjjvuUHBwsGrWrKkHH3zQsYtgYfUcOXKkRNseAAB3KO9Z36hRI0lkfXnBN+kAYFBz587Vjz/+qCZNmmjatGmSpCpVqqhu3bp65513VK1aNW3dulWPPPKIwsLC1L9/f8eyGzZsUEhIiNavXy+bzab09HT17dtXvXv31ooVK/TLL79o1KhR+ca7cOGCbrvtNv3tb3/TnDlzlJmZqaeeekr9+/fXF198UWg91atXd9v2AACgvHFV1ktSenq6+vTpQ9aXAzTpAGBQlSpVkr+/v4KCglSrVi3H9KlTpzp+r1evnrZt26Z///vf+YK7QoUKev311+Xv7y+bzabExESZTCa99tprCgwMVExMjI4dO6bhw4c7llmwYIFatmyp5557zjFt8eLFCg8P148//qiGDRsWWg8AACgeV2W9JC1atIisLydo0gGgjFm4cKEWL16s1NRUZWZmKjs7Wy1atMg3T9OmTfMdm3bo0CE1a9ZMgYGBjmnt2rXLt8zevXv15ZdfKjg4uMCYhw8fVsOGDV37QAAAQKGKk/UpKSlkfTlBkw4AZciqVas0ZswYvfTSS4qNjVXFihU1a9Ysbd++Pd98FSpUKPK6L126pD59+uj5558vcF9YWFixawYAAM4j60GTDgAG5u/vr9zcXMftpKQkdezYUSNGjHBMO3z48A3X06BBA73zzjvKyspSQECAJOmbb77JN0+rVq303nvvKTIyUr6+hcfDH+sBAAAl46qsb9Sokd5++22yvhzg7O4AYGCRkZHavn27jhw5orS0NEVFRWnnzp1at26dfvzxR02cOLFAABfmr3/9q2w2mx555BElJydr3bp1evHFFyVJJpNJkjRy5EidO3dOAwcO1DfffKPDhw9r3bp1GjZsmCOs/1iPzWYrvQcPAIAXcFXWDxo0iKwvJ/gmHYDXu3j0omHHGTNmjIYMGaKYmBhlZmbqwIED+vbbbzVgwACZTCYNHDhQI0aM0CeffHLd9YSEhOi///2vRo4cqRYtWqhp06aaNGmSBg0a5Dh2rXbt2kpKStJTTz2lHj16KCsrSzfddJN69eols9lcaD0///yzIiMji/y4AABwJ2/J+g8++ECPPvooWV/Gmex2u93TRbhTenq6KlWqpIsXLyokJMTT5aAQVqtVH3/8sXr37i0/Pz9Pl4Ny4MqVK/r5559Vr169fCdTSU1NVePoxsrMyHRbLZYgiw4kH1BERITbxsy7BFtISIgjgCVp+fLlGjZsmC5evCiLxeK2erzVtZ6HEtlUGtimziFzcSNl5Tni7Vl/Le7I+mv9neGNXJX1fJMOwGtFREToQPIBpaWluW3M0NBQj4X2smXL1KBBA9WpU0d79+51XBeVBh0AUF55Y9bXr1+frC/jaNIBeLWIiAhDfNLtDqdOndKUKVN08uRJhYWF6d5779Wzzz7r6bIAAChV3pT1J0+e1KRJk8j6Mo4mHQC8xJNPPqmnnnrK02UAAIBSMnbsWI0dO9bTZaCEvPugAQAAAAAADIQmHQAAAAAAg6BJB+A1uM4nPInnHwCUPt5r4UmuunAax6QDKPf8/f1lNpt1/PhxVa9eXf7+/jKZTJ4uy21sNpuys7N15coVr780iifY7XZlZ2frzJkzMpvN8vf393RJAFDueHvWexJ/Z1xlt9t15swZmUymEl+ukCYdQLlnNptVr149nThxQsePH/d0OW5nt9uVmZkpi8XCHyweFBQUpIiICK/+AwYASou3Z70n8XfGb0wmk+rWrSsfH58SrYcmHYBX8Pf3V0REhHJycpSbm+vpctzKarVq8+bN6tKlS4k/2UXx+Pj4yNfX1+v/eAGA0uTNWe9J/J3xGz8/vxI36BJNOgAvkrf7kbcFiI+Pj3JychQYGOh1jx0A4F28Nes9ib8zXI997gAAAAAAMAiadAAAAAAADIImHQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACD8HiTvnDhQkVGRiowMFDt27fXjh07rjv/hQsXNHLkSIWFhSkgIEANGzbUxx9/7KZqAQBAcZD3AAA4x9eTg69evVoJCQlatGiR2rdvr8TERPXs2VMpKSmqUaNGgfmzs7PVvXt31ahRQ++++67q1KmjX375RZUrV3Z/8QAAwCnkPQAAzvNokz579mwNHz5cw4YNkyQtWrRIH330kRYvXqxx48YVmH/x4sU6d+6ctm7dKj8/P0lSZGSkO0sGAABFRN4DAOA8jzXp2dnZ2rVrl8aPH++YZjab1a1bN23btq3QZdauXavY2FiNHDlS//3vf1W9enUNGjRITz31lHx8fApdJisrS1lZWY7b6enpkiSr1Sqr1erCRwRXyft/4f8HcA1eU8ZXnv9vyHtj4/0BN8JzBDfCc8Q5Rdk+HmvS09LSlJubq5o1a+abXrNmTR04cKDQZX766Sd98cUXuv/++/Xxxx/r0KFDGjFihKxWqyZPnlzoMjNmzNDUqVMLTP/ss88UFBRU8geCUrN+/XpPlwCUK7ymjCsjI8PTJZQa8r5s4P0BN8JzBDfCc+T6ipL1Ht3dvahsNptq1KihV199VT4+PmrdurWOHTumWbNmXTO0x48fr4SEBMft9PR0hYeHq0ePHgoJCXFX6SgCq9Wq9evXq3v37o7dHAEUH68p48v71hdXkffuw/sDboTnCG6E54hzipL1HmvSQ0ND5ePjo1OnTuWbfurUKdWqVavQZcLCwuTn55dvV7fo6GidPHlS2dnZ8vf3L7BMQECAAgICCkz38/PjSWRw/B8BrsVryrjK8/8LeV82sJ1wIzxHcCM8R66vKNvGY5dg8/f3V+vWrbVhwwbHNJvNpg0bNig2NrbQZTp16qRDhw7JZrM5pv34448KCwsrNLABAIBnkfcAABSNR6+TnpCQoNdee01vvvmmkpOT9eijj+ry5cuOs78OHjw434lmHn30UZ07d07x8fH68ccf9dFHH+m5557TyJEjPfUQAADADZD3AAA4z6PHpA8YMEBnzpzRpEmTdPLkSbVo0UKffvqp4+QyqampMpt/+xwhPDxc69at0xNPPKFmzZqpTp06io+P11NPPeWphwAAAG6AvAcAwHkeP3FcXFyc4uLiCr1v48aNBabFxsbq66+/LuWqAACAK5H3AAA4x6O7uwMAAAAAgN/QpAMAAAAAYBDFatK//PJLV9cBAAAMhrwHAMD9itWk9+rVS3/605/0zDPP6OjRo66uCQAAGAB5DwCA+xWrST927Jji4uL07rvvqn79+urZs6f+/e9/Kzs729X1AQAADyHvAQBwv2I16aGhoXriiSe0Z88ebd++XQ0bNtSIESNUu3ZtPf7449q7d6+r6wQAAG5G3gMA4H4lPnFcq1atNH78eMXFxenSpUtavHixWrdurc6dO+uHH35wRY0AAMDDyHsAANyj2E261WrVu+++q969e+umm27SunXrtGDBAp06dUqHDh3STTfdpHvvvdeVtQIAADcj7wEAcC/f4iz02GOPaeXKlbLb7XrwwQf1wgsvqEmTJo77K1SooBdffFG1a9d2WaEAAMC9yHsAANyvWE36/v37NX/+fN19990KCAgodJ7Q0FAu3QIAQBlG3gMA4H7F2t198uTJuvfeewsEdk5OjjZv3ixJ8vX11S233FLyCgEAgEeQ9wAAuF+xmvRbb71V586dKzD94sWLuvXWW0tcFAAA8DzyHgAA9ytWk26322UymQpMP3v2rCpUqFDiogAAgOeR9wAAuF+Rjkm/++67JUkmk0lDhw7Nt/tbbm6uvvvuO3Xs2NG1FQIAALci7wEA8JwiNemVKlWSdPWT9YoVK8pisTju8/f3V4cOHTR8+HDXVggAANyKvAcAwHOK1KQvWbJEkhQZGakxY8awqxsAAOUQeQ8AgOcU6xJskydPdnUdAADAYMh7AADcz+kmvVWrVtqwYYOqVKmili1bFnoimTy7d+92SXEAAMC9yHsAADzL6Sa9b9++jhPH9OvXr7TqAQAAHkTeAwDgWU436b/f5Y3d3wAAKJ/IewAAPKtYx6TDu6SmpiotLc1t49lsNknS3r17ZTab3TJmVlZWvksMlUehoaGKiIjwdBlOcfdzzhPK0v8HAAAA3MfpJr1KlSrXPS7t986dO1fsgmAsqampim7cSBmZV9w2psVi0cqVK9WlSxdlZma6ZUyzSbLZ3TKUx1iCLDqQfMDwjWFqaqoaN45WZmaGp0spVRZLkA4cSDb8/we8D3kPAIBnOd2kJyYmlmIZMKq0tDRlZF7R24+0UHRYsFvGtJn9dUzS5nGxMtuyS3283T+d0fC3UtRycEvVbVu31MfzhItHL2rzC5uVlpZm+KYwLS1NmZkZav/QZIWERXq6nFKRfuKIti+eWib+P+B9yHsAADzL6SZ9yJAhpVkHDC46LFitIiu5ZSyr/HRMUvOIEPnJWurjXc64LEkKrhWs0KjQUh8PzgkJi1TViEaeLgPwOuQ9AACe5XSTnp6erpCQEMfv15M3HwAAKFvIewAAPKtIx6SfOHFCNWrUUOXKlQs9Xs1ut8tkMik3N9elRQIAAPcg7wEA8Cynm/QvvvhCVatWlSR9+eWXpVYQAADwHPIeAADPcrpJv+WWWwr9HQAAlB/kPQAAnlXs66SfP39eb7zxhpKTkyVJMTExGjZsmOPTdwAAUPaR9wAAuFexmvTNmzerT58+qlSpktq0aSNJmjdvnqZNm6YPPvhAXbp0cWmRRpaamqq0tDRPl1Fq8v4oA+B67np92Ww2SdLevXtlNpvdMqYkZWVlKSAgwG3jeUJoaGi5voweeQ8AgPsVq0kfOXKkBgwYoFdeeUU+Pj6SpNzcXI0YMUIjR47Uvn37XFqkUaWmpqpx42hlZmZ4upRSZtKJi1ckuecSbEB5Z83KliQ98MADbhnPYrFo5cqV6tKlizIzM90ypiSZTZLN7rbhPMISZNGB5APltlEn7wEAcL9iNemHDh3Su+++6whsSfLx8VFCQoKWLVvmsuKMLi0tTZmZGWr/0GSFhEV6upxScebnA9qz4nldyMjxdClAuZGTc/X1NP3uhurdtEapj2cz++uYpM3jYmW2ZZf6eJK0+6czGv5WiloObqm6beu6ZUx3u3j0oja/sFlpaWnltkkn7wEAcL9iNemtWrVScnKyGjVqlG96cnKymjdv7pLCypKQsEhVjWh04xnLoMzL5X0vAcBz6oUGqVVk6e+hYpWfjklqHhEiP1lLfTxJupxxWZIUXCtYoVGhbhkTrkfeAwDgfk436d99953j98cff1zx8fE6dOiQOnToIEn6+uuvtXDhQs2cOdP1VQIAALcg7wEA8Cynm/QWLVrIZDLJbv/tAMOxY8cWmG/QoEEaMGCAa6oDAABuRd4DAOBZTjfpP//8c2nWAQAADIC8BwDAs5xu0m+66abSrAMAABgAeQ8AgGcV68Rxefbv36/U1FRlZ+c/W/D//d//lagoAABgHOQ9AADuU6wm/aefftJdd92lffv25TtuzWQySbp6DVUAAFC2kfcAALifuTgLxcfHq169ejp9+rSCgoL0ww8/aPPmzWrTpo02btzo4hIBAIAnkPcAALhfsb5J37Ztm7744guFhobKbDbLbDbr5ptv1owZM/T444/r22+/dXWdAADAzch7AADcr1jfpOfm5qpixYqSpNDQUB0/flzS1ZPNpKSkuK46AADgMeQ9AADuV6xv0ps0aaK9e/eqXr16at++vV544QX5+/vr1VdfVf369V1dIwAA8ADyHgAA9ytWkz5hwgRdvnxZkjRt2jTdeeed6ty5s6pVq6bVq1e7tEAAAOAZ5D0AAO5XrCa9Z8+ejt8bNGigAwcO6Ny5c6pSpYrjjK8AAKBsI+8BAHC/El0nXZKOHj0qSQoPDy9xMQAAwJjIewAA3KNYJ47LycnRxIkTValSJUVGRioyMlKVKlXShAkTZLVaXV0jAADwAPIeAAD3K9Y36Y899pjef/99vfDCC4qNjZV09TItU6ZM0dmzZ/XKK6+4tEgAAOB+5D0AAO5XrCZ9xYoVWrVqle644w7HtGbNmik8PFwDBw4ktAEAKAfIewAA3K9Yu7sHBAQoMjKywPR69erJ39+/pDUBAAADIO8BAHC/YjXpcXFxmj59urKyshzTsrKy9OyzzyouLs5lxQEAAM8h7wEAcD+nd3e/++67893+/PPPVbduXTVv3lyStHfvXmVnZ+v22293bYUAAMBtyHsAADzL6Sa9UqVK+W7fc889+W5zSRYAAMo+8h4AAM9yuklfsmRJqRWxcOFCzZo1SydPnlTz5s01f/58tWvX7obLrVq1SgMHDlTfvn21Zs2aUqsPAABvUVp5T9YDAOCcYh2TnufMmTPasmWLtmzZojNnzhRrHatXr1ZCQoImT56s3bt3q3nz5urZs6dOnz593eWOHDmiMWPGqHPnzsUaFwAAOKekeU/WAwDgvGI16ZcvX9ZDDz2ksLAwdenSRV26dFHt2rX18MMPKyMjo0jrmj17toYPH65hw4YpJiZGixYtUlBQkBYvXnzNZXJzc3X//fdr6tSpql+/fnEeAgAAuAFX5T1ZDwCA84p1nfSEhARt2rRJH3zwgTp16iRJ2rJlix5//HGNHj3a6eumZmdna9euXRo/frxjmtlsVrdu3bRt27ZrLjdt2jTVqFFDDz/8sL766qvrjpGVlZXvrLTp6emSJKvVKqvV6lSd12Kz2WSxWORnlnxNthKty6j8fUyyWCySb4Cs8nPLmHnjuGs8u4+/LBaL/H385Wsv1kvC8PxMfrJYLLLZbCV+3pc2Xleu5+7XlMTrqqiM+rp0Rd67I+ul0s378ixv27CNyqf//e9/Onv2bInWYbNdzeJvv/1WZnOJdsJVVlaWAgICSrQOV6tWrZrq1q3r6TLKNN5HnFOU7WOy2+32og4QGhqqd999V127ds03/csvv1T//v2d3hXu+PHjqlOnjrZu3arY2FjH9LFjx2rTpk3avn17gWW2bNmi++67T3v27FFoaKiGDh2qCxcuXPM4tSlTpmjq1KkFpq9YsUJBQUFO1QkAQGnKyMjQoEGDdPHiRYWEhHi6HAdX5L07sl4i7wEAxlaUrC/W1xsZGRmqWbNmgek1atQo8u7uRfHrr7/qwQcf1GuvvabQ0FCnlhk/frwSEhIct9PT0xUeHq4ePXqU+A+hvXv3qkuXLrp1zMuqEh5VonUZ1YmU77Tt5dF6bVgz9W8b5pYxrfLT+ir3q/v55fJT6X8ity3lhHrN/U4dR3VU/S7lc5fKs4fP6pMnP9HmzZsdl1EyKl5Xrufu15TE66qo8r71NRpP5H1xsl4q3byXXPONpCu56ts/q9Wq9evXq3v37vLzc9/eNih9eXn62rBmalSzQrHXYzP760TTfyhs3yKZbdnFr+dImh5bdVDNBjZTnVZ1ir0eV0o/lq6kxKQy8feRkfE+4pyiZH2xmvTY2FhNnjxZy5YtU2BgoCQpMzNTU6dOzfcp+Y2EhobKx8dHp06dyjf91KlTqlWrVoH5Dx8+rCNHjqhPnz6OaXm74Pj6+iolJUV/+tOf8i0TEBBQ6G41fn5+JX4Smc1mZWZmymqTcuwl2/3HqLJz7crMzJRystz2x30eP1ndMqYpN1uZmZnKzs1Wjimn1MfzBKvdqszMTJnNZsO/efK6Kj3uek1JvK6KyqivS1fkvTuyXirdvE9NTdWf/9xEmZml90VEUVksQTpwIFkREREuWZ8rthOMJS9Po6v7qVWEpdjrscpPJyS1rBsoP/kUez2Zl3yUmZkp/1B/VWpQ6cYLuEFZ+vuoLOB95PqKsm2K1aQnJiaqV69eqlu3ruNTp7179yowMFDr1q1zej3+/v5q3bq1NmzYoH79+km6GsQbNmxQXFxcgfkbN26sffv25Zs2YcIE/frrr5o7dy7XbgUAwIVckfflIevT0tKUmZmh9g9NVkhYpNvH/6P0E0e0ffFUpaWluaxJB+CdUlNTlZaWVqJ15H2Qunfv3nJ53oLQ0FC3v9cWq0lv2rSpDh48qOXLl+vAgQOSpIEDB+r++++/ejKkIkhISNCQIUPUpk0btWvXTomJibp8+bKGDRsmSRo8eLDq1KmjGTNmKDAwUE2aNMm3fOXKlSWpwHQAAFAyrsr78pL1IWGRqhrRyKM1AICrpKamKrpxI2VkXinReiwWi1auXKkuXbpc3VOwBMwmyVbkM6aVLkuQRQeSD7i1US9yk261WtW4cWN9+OGHGj58eIkLGDBggM6cOaNJkybp5MmTatGihT799FPHMXCpqakl/kQGAAAUjSvznqwHAONJS0tTRuYVvf1IC0WHBRd7PTazv45J2jwutkTnLdj90xkNfytFLQe3VN22xjjj/sWjF7X5hc1u33OpyE26n5+frlwp2actfxQXF1foLm+StHHjxusuu3TpUpfWAgAAXJ/3ZD0AGFN0WLBaRRb/PAFW+emYpOYRISU6983ljMuSpOBawQqNcv7EoeVRsT62HjlypJ5//nnl5JTPkwEBAADyHgAATyjWMenffPONNmzYoM8++0xNmzZVhQr5L+vw/vvvu6Q4AADgOeQ9AADuV6wmvXLlyrrnnntcXQsAADAQ8h4AAPcrUpNus9k0a9Ys/fjjj8rOztZtt92mKVOmFPmM7gAAwLjIewAAPKdIx6Q/++yzevrppxUcHKw6depo3rx5GjlyZGnVBgAAPIC8BwDAc4rUpC9btkwvv/yy1q1bpzVr1uiDDz7Q8uXLHRewBwAAZR95DwCA5xSpSU9NTVXv3r0dt7t16yaTyaTjx4+7vDAAAOAZ5D0AAJ5TpCY9JydHgYGB+ab5+fnJai3+9fAAAICxkPcAAHhOkU4cZ7fbNXToUAUEBDimXblyRf/4xz/yXZaFS7IAAFB2kfcAAHhOkZr0IUOGFJj2wAMPuKwYAADgeeQ9AACeU6QmfcmSJaVVBwAAMAjyHgAAzynSMekAAAAAAKD00KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYhK+nCwAAAADKutTUVKWlpXm6DIfk5GRPlwCgmGjSAQAAgBJITU1V48bRyszM8HQpf2DSiYtXJFXydCEAioAmHQAAACiBtLQ0ZWZmqP1DkxUSFunpciRJZ34+oD0rnteFjBxPlwKgiGjSAQAAABcICYtU1YhGni5DkpR52Wjf6gNwFk06AAAAAJQyzlsAZ9GkAwAAAEAp4rwFKAqadAAAAAAoRZy3AEVBkw4AAAAAbsB5C+AMs6cLAAAAAAAAV9GkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABuHr6QIkaeHChZo1a5ZOnjyp5s2ba/78+WrXrl2h87722mtatmyZvv/+e0lS69at9dxzz11zfgAA4HlkveslJyeXeB02m02StHfvXpnNJfvuJisrSwEBASWuyZVCQ0MVERHh6TIAoEg83qSvXr1aCQkJWrRokdq3b6/ExET17NlTKSkpqlGjRoH5N27cqIEDB6pjx44KDAzU888/rx49euiHH35QnTp1PPAIAADA9ZD1rmXNypYkPfDAAyVel8Vi0cqVK9WlSxdlZmaWaF1mk2Szl7gkl7IEWXQg+QCNOoAyxeNN+uzZszV8+HANGzZMkrRo0SJ99NFHWrx4scaNG1dg/uXLl+e7/frrr+u9997Thg0bNHjwYLfUDAAAnEfWu1ZOTo4kafrdDdW7acEPOYrCZvbXMUmbx8XKbMsu9np2/3RGw99KUcvBLVW3bd0S1eQqF49e1OYXNistLY0mHUCZ4tEmPTs7W7t27dL48eMd08xms7p166Zt27Y5tY6MjAxZrVZVrVq10PuzsrKUlZXluJ2eni5JslqtslqtJaj+6i5iFotFfmbJ12Qr0bqMyt/HJIvFIvkGyCo/t4yZN467xrP7+Mtiscjfx1++do9/blUq/Ex+slgsstlsJX7elzZeV67n7teUxOuqqIz+uiwJd2S95F15n/ceUq9WFTWNDC3Ruqzy0zFJMRHV5Kfib6dLWVZZLBZVrVNVtRrUKlFNruLO7DPac0RyXda4KkOMmAs8R3iO3Iinst5kt9s9tmPS8ePHVadOHW3dulWxsbGO6WPHjtWmTZu0ffv2G65jxIgRWrdunX744QcFBgYWuH/KlCmaOnVqgekrVqxQUFBQyR4AAAAukJGRoUGDBunixYsKCQnxdDku5Y6sl8h7AICxFSXrjfERRTHNnDlTq1at0saNG68Z2uPHj1dCQoLjdnp6usLDw9WjR48S/yG0d+9edenSRbeOeVlVwqNKtC6jOpHynba9PFqvDWum/m3D3DKmVX5aX+V+dT+/vESf6jtrW8oJ9Zr7nTqO6qj6XeqX+niecPbwWX3y5CfavHmzmjdv7ulyrovXleu5+zUl8boqqrxvfVGQM1kveVfeu/I9xFXvD0Z8zbsz+4z2HJFc9zzhOeIaPEdurLw/R4qS9R5t0kNDQ+Xj46NTp07lm37q1CnVqnX9XaVefPFFzZw5U59//rmaNWt2zfkCAgIKPdOon5+f/PxKtkuG2WxWZmamrDYpx14+r2aXnWu/eiKZnCy3/XGfx09Wt4xpys1WZmamsnOzlWPKKfXxPMFqtyozM1Nms7nEz/vSxuuq9LjrNSXxuioqo78uS8IdWS95V96XxntISd8fjPiad2f2Ge05Irn+ecJzpGR4jtxYeX+OFGV5jz5D/P391bp1a23YsMExzWazacOGDfl2ifujF154QdOnT9enn36qNm3auKNUAABQDGQ9AABF4/Hd3RMSEjRkyBC1adNG7dq1U2Jioi5fvuw4A+zgwYNVp04dzZgxQ5L0/PPPa9KkSVqxYoUiIyN18uRJSVJwcLCCg4M99jgAAEDhyHoAAJzn8SZ9wIABOnPmjCZNmqSTJ0+qRYsW+vTTT1WzZk1JUmpqqszm377wf+WVV5Sdna2//vWv+dYzefJkTZkyxZ2lAwAAJ5D1AAA4z+NNuiTFxcUpLi6u0Ps2btyY7/aRI0dKvyAAAOBSZD0AAM4xxlkLAAAAAAAATToAAAAAAEZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGIQhmvSFCxcqMjJSgYGBat++vXbs2HHd+d955x01btxYgYGBatq0qT7++GM3VQoAAIqDrAcAwDkeb9JXr16thIQETZ48Wbt371bz5s3Vs2dPnT59utD5t27dqoEDB+rhhx/Wt99+q379+qlfv376/vvv3Vw5AABwBlkPAIDzPN6kz549W8OHD9ewYcMUExOjRYsWKSgoSIsXLy50/rlz56pXr1568sknFR0drenTp6tVq1ZasGCBmysHAADOIOsBAHCerycHz87O1q5duzR+/HjHNLPZrG7dumnbtm2FLrNt2zYlJCTkm9azZ0+tWbOm0PmzsrKUlZXluH3x4kVJ0rlz52S1WktUf3p6ugIDA3Xp2I+SNbNE6zKqzJM/KTAwUClp2dr4469uGdNm9lfGnzP01aFLMtuyS328749nKzAwUBnHM5S2L63Ux/OEX0/8qsDAQKWnp+vs2bOeLue6eF25nrtfUxKvqyKv69erzwO73e6K0gzFHVkveVfeu/I9xFXvD0Z8zbsz+4z2HJFc9zzhOeIaPEdurLw/R4qU9XYPOnbsmF2SfevWrfmmP/nkk/Z27doVuoyfn599xYoV+aYtXLjQXqNGjULnnzx5sl0SP/zwww8//Bj+5+jRo64JWANxR9bb7eQ9P/zwww8/ZePHmaz36Dfp7jB+/Ph8n8bbbDadO3dO1apVk8lk8mBluJb09HSFh4fr6NGjCgkJ8XQ5QJnHa8r47Ha7fv31V9WuXdvTpZRZ5H3x8P6AG+E5ghvhOeKcomS9R5v00NBQ+fj46NSpU/mmnzp1SrVq1Sp0mVq1ahVp/oCAAAUEBOSbVrly5eIXDbcJCQnhhQ64EK8pY6tUqZKnSygV7sh6ibwvKd4fcCM8R3AjPEduzNms9+iJ4/z9/dW6dWtt2LDBMc1ms2nDhg2KjY0tdJnY2Nh880vS+vXrrzk/AADwHLIeAICi8fju7gkJCRoyZIjatGmjdu3aKTExUZcvX9awYcMkSYMHD1adOnU0Y8YMSVJ8fLxuueUWvfTSS/rLX/6iVatWaefOnXr11Vc9+TAAAMA1kPUAADjP4036gAEDdObMGU2aNEknT55UixYt9Omnn6pmzZqSpNTUVJnNv33h37FjR61YsUITJkzQ008/raioKK1Zs0ZNmjTx1EOAiwUEBGjy5MkFdlsEUDy8puBpZL1x8f6AG+E5ghvhOeJ6Jru9HF7vBQAAAACAMsijx6QDAAAAAIDf0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw5DWbhwoSIjIxUYGKj27dtrx44dni4JKNM2b96sPn36qHbt2jKZTFqzZo2nSwJgEGQurof8wI3MmDFDbdu2VcWKFVWjRg3169dPKSkpni6rXKBJh2GsXr1aCQkJmjx5snbv3q3mzZurZ8+eOn36tKdLA8qsy5cvq3nz5lq4cKGnSwFgIGQuboT8wI1s2rRJI0eO1Ndff63169fLarWqR48eunz5sqdLK/O4BBsMo3379mrbtq0WLFggSbLZbAoPD9djjz2mcePGebg6oOwzmUz6z3/+o379+nm6FAAeRuaiKMgPOOPMmTOqUaOGNm3apC5duni6nDKNb9JhCNnZ2dq1a5e6devmmGY2m9WtWzdt27bNg5UBAFC+kLkASsPFixclSVWrVvVwJWUfTToMIS0tTbm5uapZs2a+6TVr1tTJkyc9VBUAAOUPmQvA1Ww2m0aNGqVOnTqpSZMmni6nzPP1dAEAAAAAgLJr5MiR+v7777VlyxZPl1Iu0KTDEEJDQ+Xj46NTp07lm37q1CnVqlXLQ1UBAFD+kLkAXCkuLk4ffvihNm/erLp163q6nHKB3d1hCP7+/mrdurU2bNjgmGaz2bRhwwbFxsZ6sDIAAMoXMheAK9jtdsXFxek///mPvvjiC9WrV8/TJZUbfJMOw0hISNCQIUPUpk0btWvXTomJibp8+bKGDRvm6dKAMuvSpUs6dOiQ4/bPP/+sPXv2qGrVqoqIiPBgZQA8iczFjZAfuJGRI0dqxYoV+u9//6uKFSs6zmlRqVIlWSwWD1dXtnEJNhjKggULNGvWLJ08eVItWrTQvHnz1L59e0+XBZRZGzdu1K233lpg+pAhQ7R06VL3FwTAMMhcXA/5gRsxmUyFTl+yZImGDh3q3mLKGZp0AAAAAAAMgmPSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAImnQAAAAAAAyCJh0AAAAAAIOgSQcAAAAAwCBo0gGUmqFDh6pfv36eLgMAgHKja9euGjVqVLGXX7p0qSpXruyyeq4lMjJSiYmJpT4OUB7RpAMAAABeYsCAAfrxxx89XQaA66BJB2BYdrtdOTk5ni4DAIByw2KxqEaNGte8Pzs7243VXJtR6gA8gSYd8AK//vqr7r//flWoUEFhYWGaM2dOvt3lsrKyNGbMGNWpU0cVKlRQ+/bttXHjRsfyebvGrVu3TtHR0QoODlavXr104sQJxzy5ublKSEhQ5cqVVa1aNY0dO1Z2uz1fHTabTTNmzFC9evVksVjUvHlzvfvuu477N27cKJPJpE8++UStW7dWQECAtmzZUqrbBgCAssZms2ns2LGqWrWqatWqpSlTpjjumz17tpo2baoKFSooPDxcI0aM0KVLlxz3/3F39ylTpqhFixZ6/fXXVa9ePQUGBkqSLly4oL///e+qWbOmAgMD1aRJE3344YeO5d577z39+c9/VkBAgCIjI/XSSy9dt+bU1FT17dtXwcHBCgkJUf/+/XXq1Kkb1gF4I5p0wAskJCQoKSlJa9eu1fr16/XVV19p9+7djvvj4uK0bds2rVq1St99953uvfde9erVSwcPHnTMk5GRoRdffFFvvfWWNm/erNTUVI0ZM8Zx/0svvaSlS5dq8eLF2rJli86dO6f//Oc/+eqYMWOGli1bpkWLFumHH37QE088oQceeECbNm3KN9+4ceM0c+ZMJScnq1mzZqW0VQAAKJvefPNNVahQQdu3b9cLL7ygadOmaf369ZIks9msefPm6YcfftCbb76pL774QmPHjr3u+g4dOqT33ntP77//vvbs2SObzaY77rhDSUlJevvtt7V//37NnDlTPj4+kqRdu3apf//+uu+++7Rv3z5NmTJFEydO1NKlSwtdv81mU9++fXXu3Dlt2rRJ69ev108//aQBAwZctw7Aa9kBlGvp6el2Pz8/+zvvvOOYduHCBXtQUJA9Pj7e/ssvv9h9fHzsx44dy7fc7bffbh8/frzdbrfblyxZYpdkP3TokOP+hQsX2mvWrOm4HRYWZn/hhRcct61Wq71u3br2vn372u12u/3KlSv2oKAg+9atW/ON8/DDD9sHDhxot9vt9i+//NIuyb5mzRrXPHgAAMqZW265xX7zzTfnm9a2bVv7U089Vej877zzjr1atWqO20uWLLFXqlTJcXvy5Ml2Pz8/++nTpx3T1q1bZzebzfaUlJRC1zlo0CB79+7d80178skn7TExMY7bN910k33OnDl2u91u/+yzz+w+Pj721NRUx/0//PCDXZJ9x44d16wD8Fa+Hv6MAEAp++mnn2S1WtWuXTvHtEqVKqlRo0aSpH379ik3N1cNGzbMt1xWVpaqVavmuB0UFKQ//elPjtthYWE6ffq0JOnixYs6ceKE2rdv77jf19dXbdq0cezyfujQIWVkZKh79+75xsnOzlbLli3zTWvTpk1JHjIAAOXaH/cy+30mf/7555oxY4YOHDig9PR05eTk6MqVK8rIyFBQUFCh67vppptUvXp1x+09e/aobt26Bf42yJOcnKy+ffvmm9apUyclJiYqNzfX8Y377+cPDw9XeHi4Y1pMTIwqV66s5ORktW3bttA6AG9Fkw54uUuXLsnHx0e7du0qEKrBwcGO3/38/PLdZzKZChxzfqNxJOmjjz5SnTp18t0XEBCQ73aFChWcXi8AAN6msEy22Ww6cuSI7rzzTj366KN69tlnVbVqVW3ZskUPP/ywsrOzr9mk/zF3LRZLqdV+PeQ/cBXHpAPlXP369eXn56dvvvnGMe3ixYuOy6+0bNlSubm5On36tBo0aJDvp1atWk6NUalSJYWFhWn79u2OaTk5Odq1a5fjdkxMjAICApSamlpgnN9/sg4AAIpn165dstlseumll9ShQwc1bNhQx48fL/J6mjVrpv/973/XvFRbdHS0kpKS8k1LSkpSw4YNC3zgnzf/0aNHdfToUce0/fv368KFC4qJiSlyfUB5xzfpQDlXsWJFDRkyRE8++aSqVq2qGjVqaPLkyTKbzTKZTGrYsKHuv/9+DR48WC+99JJatmypM2fOaMOGDWrWrJn+8pe/ODVOfHy8Zs6cqaioKDVu3FizZ8/WhQsX8tUxZswYPfHEE7LZbLr55pt18eJFJSUlKSQkREOGDCmlLQAAgHdo0KCBrFar5s+frz59+igpKUmLFi0q8npuueUWdenSRffcc49mz56tBg0a6MCBAzKZTOrVq5dGjx6ttm3bavr06RowYIC2bdumBQsW6OWXXy50fd26dVPTpk11//33KzExUTk5ORoxYoRuueUWDnEDCsE36YAXmD17tmJjY3XnnXeqW7du6tSpk6Kjox2XN1myZIkGDx6s0aNHq1GjRurXr5+++eYbRUREOD3G6NGj9eCDD2rIkCGKjY1VxYoVddddd+WbZ/r06Zo4caJmzJih6Oho9erVSx999JHq1avn0scLAIA3at68uWbPnq3nn39eTZo00fLlyzVjxoxireu9995T27ZtNXDgQMXExGjs2LHKzc2VJLVq1Ur//ve/tWrVKjVp0kSTJk3StGnTNHTo0ELXZTKZ9N///ldVqlRRly5d1K1bN9WvX1+rV68u7kMFyjWTvSgHlQIoFy5fvqw6deropZde0sMPP+zpcgAAAAD8f+zuDniBb7/9VgcOHFC7du108eJFTZs2TZIKnJkVAAAAgGfRpANe4sUXX1RKSor8/f3VunVrffXVVwoNDfV0WQAAAAB+h93dAQAAAAAwCE4cBwAAAACAQdCkAwAAAABgEDTpAAAAAAAYBE06AAAAAAAGQZMOAAAAAIBB0KQDAAAAAGAQNOkAAAAAABgETToAAAAAAAZBkw4AAAAAgEHQpAMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEL6eLsDdbDabjh8/rooVK8pkMnm6HAAAZLfb9euvv6p27doym/n83BXIewCAkRQl672uST9+/LjCw8M9XQYAAAUcPXpUdevW9XQZ5QJ5DwAwImey3uua9IoVK0q6unFCQkI8XI3zrFarPvvsM/Xo0UN+fn6eLsdj2A6/YVtcxXa4iu1wVVndDunp6QoPD3dkFEqurOa9tyirr1XAyHhdGVtRst7rmvS8Xd5CQkLKVGhbrVYFBQUpJCTEq190bIffsC2uYjtcxXa4qqxvB3bLdp2ymvfeoqy/VgEj4nVVNjiT9Rz4BgAAAACAQdCkAwAAAABgEDTpAAAAAAAYhNcdkw7Au+Xm5spqtXq6DJezWq3y9fXVlStXlJub6+lyPMao28HPz08+Pj6eLgMAvEJ5zfobMWoGehN/f3+XXEqVJh2AV7Db7Tp58qQuXLjg6VJKhd1uV61atXT06FGvPvmYkbdD5cqVVatWLcPVBQDlRXnP+hsxcgZ6C7PZrHr16snf379E66FJB+AV8kK7Ro0aCgoKKnfhZbPZdOnSJQUHB7vkE9yyyojbwW63KyMjQ6dPn5YkhYWFebgiACifynvW34gRM9Cb2Gw2HT9+XCdOnFBERESJnn806QDKvdzcXEdoV6tWzdPllAqbzabs7GwFBgZ6dTAbdTtYLBZJ0unTp1WjRg12fQcAF/OGrL8Ro2agN6levbqOHz+unJycEl0Gj/89AOVe3nFpQUFBHq4E3izv+eeNx0kCQGkj62EEebu5l/ScADTpALyGt+32BmPh+QcApY/3WniSq55/NOkAAAAAABgEx6QDAK6ra9euatGihRITEw2xHsATUlNTlZaW5ukySlVoaKgiIiI8XQYADyHvjYMmHQDgUhs3btStt96q8+fPq3Llyo7p77//folOogJ4Smpqqho3jlZmZoanSylVFkuQDhxIplEH4BTyvvTQpAMA3KJq1aqeLgEolrS0NGVmZqj9Q5MVEhbp6XJKRfqJI9q+eKrS0tJo0gGUCHlfchyTDgAG1bVrV8XFxSkuLk6VKlVSaGioJk6cKLvdLkk6f/68Bg8erCpVqig4OFh//etfdfDgQcfyS5cuVeXKlbVmzRpFRUUpMDBQPXv21NGjRx3zDB06VP369cs37qhRo9S1a9dr1vXWW2+pTZs2qlixomrVqqVBgwY5rgF+5MgR3XrrrZKkKlWqyGQyaejQoY7HM2rUKMd6fl9/UFCQ7rjjjkLrX7dunaKjoxUcHKxevXrpxIkTxdmcQImFhEWqakSjcvlTXj98AMqCouT99fJyzZo1at26tYKCgsj7Mo4mHQAM7M0335Svr6927NihuXPnavbs2Xr99dclXQ3cnTt3au3atUpKSpIk3Xnnnfku8ZWRkaFnn31Wy5YtU1JSki5cuKD77ruvRDVZrVZNnz5de/fu1Zo1a3TkyBFHMIeHh+u9996TJKWkpOjEiROaO3duoev5ff3btm2T3W5X7969C9T/4osv6q233tLmzZuVmpqqMWPGlKh+AACMxtm8v15ezpgxQ6+88oq++uor8r6MY3d3ADCw8PBwzZkzRyaTSY0aNdK+ffs0Z84cde3a1dGcd+zYUTabTa+++qqaNGmiNWvW6N5775V0NWAXLFig9u3bS7r6R0B0dLR27Nihdu3aFaumhx56yPF7/fr1NW/ePLVt21aXLl1ScHCwYze3GjVq5DtG7fcOHjyYr35JWr58ucLDwwvUv2jRIv3pT3+SJMXFxWnatGnFqhsAAKNyNu+la+flvHnzFB0drZCQEPK+jOObdAAwsA4dOuS75mZsbKwOHjyo/fv3y9fX19F8S1ePAWvUqJGSk5Md03x9fdW2bVvH7caNG6ty5cr55imqXbt2qU+fPoqIiFDFihV1yy23SLp6ci1nJScnF6i/WrVqBeoPCgpyBLYkhYWFOXa1AwCgvChK3heWl+R9+UKTDgBezGw2O455y/P73c/+6PLly+rZs6dCQkK0fPlyffPNN/rPf/4jScrOznZ5fX88O6zJZCpQLwAAuD7yvmyhSQcAA9u+fXu+219//bWioqIUExOjnJycfPefO3dOKSkpiomJcUzLycnRzp07HbdTUlJ04cIFRUdHS5KqV69e4MQse/bsuWY9Bw4c0NmzZzVz5kx17txZjRs3LvBJt7+/vyQpNzf3muuJjo4uUP/Zs2cL1A8AgDcoSt4XlpfkfflCkw4ABpaamqqEhASlpKRo5cqVmj9/vuLj4xUVFaW+fftq+PDh2rJli/bu3atHHnlEderUUd++fR3L+/n56bHHHtP27du1a9cuDR06VB06dHAcn3bbbbdp586dWrZsmQ4ePKjJkyfr+++/v2Y9ERER8vf31/z58/XTTz9p7dq1mj59er55brrpJplMJn344Yc6c+aMLl26VGA9hdX/wAMPFKgfAABvUJS8Lywv/fz8FB8fr507d5L35QBNOgAY2ODBg5WZmal27dpp5MiRio+P1yOPPCJJWrJkiVq3bq0777xTnTp1kiR9+OGH+XYZCwoK0lNPPaVBgwapU6dOCg4O1urVqx339+zZUxMnTtTYsWPVtm1b/frrrxo8ePA166levbqWLl2qd955RzExMZo5c6ZefPHFfPPUqVNHU6dO1bhx41SzZk3FxcUVuq7f1x8bGyu73a6PP/64wC5vAACUd87m/bXyMigoSE8++aSGDx+uzp07k/dlnMnuZTv7p6enq1KlSrp48aJCQkI8XY7TrFarPv74Y/Xu3durn9Bsh9+wLa5yZjtcuXJFP//8s+rVq6fAwEA3V1h8Xbt2VYsWLZSYmHjDeW02m9LT0xUSEiKz+ernr0uXLtWoUaN04cKF0i3UQArbDkZxvedhWc0mI3PlNt29e7dat26t7v9coqoRjVxUobGcS03R+meHadeuXWrVqlWpj0eGwdXKatZLRcv7wuTl/blz5wybgd7CVVnP/x4AAAAAAAZBkw4AAAAAgEH4eroAAEDhNm7cWKLlhw4dqqFDh7qkFgAAUDpclfc2m801BcHj+CYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAImnQAAAAAAAyCJh0AAAAAAIOgSQcAAAAAwCC4BBsAr5aamqq0tDS3jRcaGqqIiAi3jeesyMhIjRo1SqNGjbrmPNnZ2YqJidGyZcvUsWNH9xVnACaTSf/5z3/Ur1+/Qu/fv3+/evTooZSUFFWoUMG9xQEArousv4qsvz4jZT1NOgCvlZqaqsaNo5WZmeG2MS2WIB04kGzI8L6RRYsWqV69emU6tI8cOaJ69erp22+/VYsWLVy23piYGHXo0EGzZ8/WxIkTXbZeAEDJkPVFQ9ZfmzuzniYdgNdKS0tTZmaG2j80WSFhkaU+XvqJI9q+eKrS0tLKXHDb7XYtWLBA06ZNK/F6cnNz5etb/uJn2LBhGj58uMaPH18uHx8AlEVkvfPI+htzV9ZzTDoArxcSFqmqEY1K/ac4fxx07dpVcXFxiouLU6VKlRQaGqqJEyfKbrc75jl//ryGDBmiyMhIBQcH64477tDBgwfzree9997Tn//8ZwUEBCgyMlIvvfRSkerYtWuXDh8+rL/85S+OaUeOHJHJZNKqVavUsWNHBQYGqkmTJtq0aZNjno0bN8pkMumTTz5R69atFRAQoC1btshms2nGjBmqV6+eLBaLmjdvrnfffbfAcuvWrVPLli1lsVh022236fTp0/rkk08UHR2tkJAQDRo0SBkZv3078umnn6pXr16qWrWqqlWrpjvvvFOHDx923F+vXj1JUsuWLWUymdS1a1fHfYsXL3Zso7CwMMXFxeXbBmlpabrrrrsUFBSkqKgorV27Nt/93bt317lz5/I9fgCAMZSHrB88eLCqVKmioKCga2Z9bGysLBZLuc/6m2++WZUrVy63WU+TDgAG9+abb8rX11c7duzQ3LlzNXv2bL3++uuO+4cOHapdu3ZpxYoVSkpKkt1uV+/evWW1WiVdDd3+/fvrvvvu0759+zRlyhRNnDhRS5cudbqGr776Sg0bNlTFihUL3Pfkk09q9OjR+vbbbxUbG6s+ffro7Nmz+eYZN26cZs6cqeTkZDVr1kwzZszQsmXLtGjRIv3www964okn9MADDxQIvSlTpmjBggXaunWrjh49qv79+ysxMVErVqzQRx99pM8++0zz5893zH/58mWNHDlSO3bs0IYNG2Q2m3XXXXfJZrNJknbs2CFJ+vzzz3XixAm9//77kqRXXnlFI0eO1COPPKJ9+/Zp7dq1atCgQb5apk6dqv79++u7775T7969df/99+vcuXOO+/39/dWiRQt99dVXTm9XAAAk57J+586dWrt2rbZt21Zo1t933326++67tXfv3nKf9QkJCdq5c2e5zfrytw8CAJQz4eHhmjNnjkwmkxo1aqR9+/Zpzpw5Gj58uA4ePKi1a9fqq6++UpMmTRQSEqLly5crPDxca9as0b333qvZs2fr9ttvdxw/1bBhQ+3fv1+zZs3S0KFDnarhl19+Ue3atQu9Ly4uTvfcc4+kqwH46aef6o033tDYsWMd80ybNk3du3eXJGVlZem5557T559/rtjYWElS/fr1tWXLFv3rX//SLbfc4ljumWeeUadOnSRJDz/8sMaPH6/Dhw+rfv36kqS//vWv+vLLL/XUU09Jku655x6lp6crJCREZrNZixcvVvXq1bV//341adJE1atXlyRVq1ZNtWrVyjfO6NGjFR8f75jWtm3bfI9z6NChGjhwoCTpueee07x587Rjxw716tXLMU/t2rX1yy+/OLVNAQDI40zWJyUlOY4VLyzrb7vtNj355JMKCQlR48aNy3XW/155zHq+SQcAg+vQoYNMJpPjdmxsrA4ePKjc3FwlJyfL19dX7du3d9xfrVo1NWrUSMnJyZKk5ORkR/jl6dSpk2MdzsjMzFRgYGCh9+WFryT5+vqqTZs2jrHztGnTxvH7oUOHlJGRoe7duys4ONjxs2zZsny7q0lSs2bNHL/XrFlTQUFBjtDOm3b69GnH7YMHD+rhhx9WgwYNFBISosjISElXTxx0LadPn9bx48d1++23X2cL5K+lQoUKCgkJyTe2JFkslny75AEA4Ayy/ipns37gwIGqX79+uc16jzfpCxcuVGRkpAIDA9W+fXvH7gnXkpiYqEaNGslisSg8PFxPPPGErly54qZqAcA7hYaG6vz588Ve/veXKrl06ZIk6aOPPtKePXscP/v37893rJok+fn5OX43mUz5budNy9u9TZL69u2rCxcu6F//+pe2b9+u7du3S7p6SZlrsVgsTj2GG40tSefOnXN8go/8yHsAMLaykvV9+vTRuXPn9Nprr5XbrPdok7569WolJCRo8uTJ2r17t5o3b66ePXsW+LQiz4oVKzRu3DhNnjxZycnJeuONN7R69Wo9/fTTbq4cANwnL3zyfP3114qKipKPj4+io6OVk5OTb56zZ88qJSVFMTExkqTo6GglJSXlW0dSUpIaNmwoHx8fp2po2bKlDhw4kO8kNr+vJ09OTo527dql6Ojoa64rJiZGAQEBSk1NVYMGDfL9hIeHO1VPYfIe9+jRo3X77bcrOjq6wB8b/v7+kpTvW4WKFSsqMjJSGzZsKPbYeb7//nu1bNmyxOspb8h7ALg+st45eY97woQJ5TrrPXpM+uzZszV8+HANGzZM0tXr8n300UdavHixxo0bV2D+rVu3qlOnTho0aJAkKTIyUgMHDizwpAaA8iQ1NVUJCQn6+9//rt27d2v+/PmOM7ZGRUWpb9+++vvf/64XX3xRtWrV0tNPP606deqob9++kqTRo0erbdu2mj59ugYMGKBt27ZpwYIFevnll52u4dZbb9WlS5f0ww8/qEmTJvnuW7hwoaKiohQdHa05c+bo/Pnzeuihh665rooVK2rMmDF64oknZLPZdPPNN+vixYtKSkpSSEiIhgwZUoytJFWpUkXVqlXTm2++qQYNGuh///tfgSypUaOGLBaLPv30U9WtW1eBgYGqVKmSpkyZon/84x+qUaOG7rjjDv36669KSkrSY4895vT4R44c0bFjx9StW7di1V+ekfcAcH3OZP3w4cP1r3/9SxUrVtS4ceMKzfpZs2bpwQcf1Pbt28t11r/66qsKCwtTampqucx6jzXp2dnZ2rVrl8aPH++YZjab1a1bN23btq3QZTp27Ki3335bO3bsULt27fTTTz/p448/1oMPPnjNcbKyspSVleW4nZ6eLkmyWq2OsyGWBXm1lqWaSwPb4Tdsi6uc2Q5Wq1V2u102my3fLkt5v6cfPyIV/NDY5dJPHHGM+8ddp67nwQcfVEZGhtq1aycfHx89/vjj+tvf/uZYxxtvvKFRo0bpvvvuk9VqVefOnfXhhx/Kx8dHNptNLVq00KpVqzRlyhRNnz5dYWFhmjp1qgYPHpyvjrxtVJgqVaqoX79+evvtt/Xcc885Hod09cQqM2fO1J49e9SgQQOtWbNGVatWzfc4//iYp06dqtDQUM2YMUM//fSTKleurJYtW2r8+PHXXO6P/+bV/Ptpy5cvV3x8vJo1a6ZGjRopMTFRt912m2M9ZrNZiYmJeuaZZzRp0iR17txZX3zxhWMbz507V2PGjFFoaKjuueeeAs+XP26f309bsWKFunfvrvDw8EK3o81mk91ul9VqLfCtRnl+HZeHvLfZbLJYLPIzS74m51+7ZYmf+eruoDabzS3PRzIMruYtWX/nnXcqOzv7mlk/adIkzZo1q1xn/YoVKzRq1Cg1adKk3Ga9yV7Y/gxucPz4cdWpU0dbt27NdyKCsWPHatOmTdf8tHzevHkaM2aM7Ha7cnJy9I9//EOvvPLKNceZMmWKpk6dWmD6ihUrFBQUVPIHAsDwfH19VatWLYWHhzt2gZKko0ePql379rqSmem2WgItFu3Yvt3pXb3uvPNONW3aVDNmzCjlym7s+++/1913363du3crODhYqampat68uTZv3qymTZt6ujyPys7OVuvWrfXaa6+pQ4cO15zn6NGjOnnypHJycvLdl5GRoUGDBunixYsKCQlxR8luQ94DcAey3jXI+mtzZ9aXqUuwbdy4Uc8995xefvlltW/fXocOHVJ8fLymT5/uuLTQH40fP14JCQmO2+np6QoPD1ePHj3K1B9CVqtV69evV/fu3Quc0MCbsB1+w7a4ypntcOXKFR09elTBwcH5zlr65z//Wcn79ystLc1d5So0NFQRERFOz+/r6yt/f/8bvl/Z7Xb9+uuvqlixYr6zw7pSx44dNXPmTJ09e1a1a9dWcHCwpN/OfmoE7tgOhTl06JCefvpp9ejR45rzXLlyRRaLRV26dClw9ty8b31xldHyfu/everSpYtuHfOyqoRHlWhdRnX+6EF9+eIIbd68Wc2bNy/18cgwuJo3ZP2NuCIDy0LWe4o7s95jTXpoaKh8fHx06tSpfNNPnTqV73p2vzdx4kQ9+OCD+tvf/iZJatq0qS5fvqxHHnlE//znP2U2FzwPXkBAgAICAgpM9/PzK5OhUFbrdjW2w2/YFlddbzvk5ubKZDLJbDYXeJ+IjIx0XLrDqPJqv568Xa6cmbckfn/8Wd44hW1XT3HXdvijhg0bqmHDhtedx2w2O85a+8fnanl+DZeHvDebzcrMzJTVJuXYjfFcdzWr7erll8xms1ufj2QYXMUbsv5GXJWBRs96T3Fn1nusSff391fr1q21YcMG9evXT9LVJ9aGDRsUFxdX6DIZGRkFnhx5+/p7aK99AChVGzdu9HQJ1xQZGcl7L26IvAeA6yPr8Uce3d09ISFBQ4YMUZs2bdSuXTslJibq8uXLjrO/Dh48WHXq1HEcn9GnTx/Nnj1bLVu2dOz+NnHiRPXp08fpSwsAAAD3Iu8BAHCeR5v0AQMG6MyZM5o0aZJOnjypFi1a6NNPP1XNmjUlXb0Uwe8/SZ8wYYJMJpMmTJigY8eOqXr16urTp4+effZZTz0EAABwA+Q9AADO8/iJ4+Li4q65u9sfd/3w9fXV5MmTNXnyZDdUBgAAXIW8BwDAOd599D8AAAAAAAZCkw4AAAAAgEHQpAMAAAAAYBAePyYdADwpNTVVaWlpbhsvNDRUERERbhvPGZGRkRo1apRGjRrl6VIAAHA5sp6sL2to0gF4rdTUVEU3bqSMzCtuGzPIEqjkAymGC28AAMojsh5lEU06AK+VlpamjMwrevuRFooOCy718ZJPXNIDr+5RWloawQ0AgBuQ9SiLaNIBeL3osGC1iqzk6TIK1bVrVzVp0kSS9NZbb8nPz0+PPvqopk2bJpPJpPPnzys+Pl4ffPCBsrKy1KVLF82fP19RUVGOdbz33nuaNGmSDh06pLCwMD322GMaPXq0px4SAABuV56y/pZbbtG8efPI+nKME8cBgMG9+eab8vX11Y4dOzR37lzNnj1br7/+uiRp6NCh2rlzp9asWaN169bJbrerd+/eslqtkqRdu3apf//+uu+++7Rv3z5NmTJFEydO1NKlSz34iAAAwO85k/Vr167Vtm3brpn1AwYMUFJSkiZNmkTWl3F8kw4ABhceHq45c+bIZDKpUaNG2rdvn+bMmaOuXbtq7dq1SkpKUocOHZSenq63335bN910k9asWaN7771Xs2fP1u23366JEydKkho2bKj9+/dr1qxZGjp0qGcfGAAAkORc1nfs2FGStHz5coWHhxfI+gkTJig9PV2tWrXSgQMHyPoyjG/SAcDgOnToIJPJ5LgdGxurgwcPav/+/fL19VX79u0d91WrVk2NGjVScnKyJCk5OVmdOnXKt75OnTrp4MGDys3Ndc8DAAAA10XW4/do0gEAAAAAMAiadAAwuO3bt+e7/fXXXysqKkoxMTHKycnJd//Zs2eVkpKimJgYSVJ0dLSSkpLyLZ+UlKSGDRvKx8en9IsHAAA3RNbj92jSAcDgUlNTlZCQoJSUFK1cuVLz589XfHy8oqKi1LdvXw0fPlxbtmzRvn379OCDD6pOnTrq27evJGn06NHasGGDpk+frh9//FFvvvmmFixYoDFjxnj4UQEAgDzOZv3evXv1wAMPFJr1zzzzjA4dOkTWlwOcOA6A10s+ccnQ4wwePFiZmZlq166dfHx8FB8fr0ceeUSStGTJEsXHx+v//u//lJ2drc6dO+vjjz+Wn5+fJKlVq1b697//rUmTJmn69OkKCwvTtGnTOJEMAMCrlIesv/POO5Wdna0uXbpcM+ufeeYZsr4coEkH4LVCQ0MVZAnUA6/ucduYQZZAhYaGFmkZPz8/JSYm6pVXXilwX5UqVbRs2TLZbDalp6crJCREZnP+naTuuece3XPPPddc/5EjR4pUDwAAZUV5yvrrueeee3TXXXdd828Bsr5soUkH4LUiIiKUfCBFaWlpbhszNDRUERERbhsPAABvRtajLKJJB+DVIiIiCFIAAMoxsh5lDU06ABjYxo0bPV0CAAAoRWQ9/oizuwMAAAAAYBA06QAAAAAAGARNOgAAAAAABkGTDgAAAACAQdCkAwAAAABgEDTpAAAAAAAYBJdgA+DVUlNTlZaW5rbxQkNDuVYrAABuRNajrKFJB+C1UlNT1Ti6sTIzMt02piXIogPJB5wO765du6pFixZKTEws3cKcZLR6ALhWcnKyW8ax2WySpL1798psdt+OnVlZWQoICHDbeJ5Ag5gfWV90RqvHG9GkA/BaaWlpyszIVJexXVQpvFKpj3fx6EVtfmGz0tLS3PoHVHZ2tvz9/d02HoCyx5qVLUl64IEH3DKexWLRypUr1aVLF2Vmuq95Mpskm91tw3lEURvE8s6bst7Xl9auvOB/EoDXqxReSaFRoZ4uo4ChQ4dq06ZN2rRpk+bOnStJOnTokJ577jl98cUXOnnypCIiIjRixAg99thj+Za7cOGC2rZtq4ULFyogIEA///yztm7dqhEjRujAgQNq0qSJJkyYoLvuukvffvutWrRoIUn6/vvv9eSTT+qrr75ShQoV1KNHD82ZM0ehoaGF1vPzzz8rMjLS3ZsGgIvl5ORIkqbf3VC9m9Yo9fFsZn8dk7R5XKzMtuxSH0+Sdv90RsPfSlHLwS1Vt21dt4zpbp5qEMuC8pD18fHx+Zb7Y9YfPnxY27dv11NPPUXWl3E06QBgUHPnztWPP/6oJk2aaNq0aZKkKlWqqG7dunrnnXdUrVo1bd26VY888ohq1qypXr16OZbdsGGDQkJCtH79eklSenq6+vTpo969e2vFihX65ZdfNGrUqHzjXbhwQbfddpv+9re/ac6cOcrMzNRTTz2l/v3764svvii0nurVq7tnYwBwi3qhQWoVWfrfNlrlp2OSmkeEyE/WUh9Pki5nXJYkBdcKNmSzBu9UlKwPCwtT//79HcsWlvUDBw4k68sBmnQAMKhKlSrJ399fQUFBqlWrlmP61KlTHb/Xq1dP27Zt0zvvvJOvSa9QoYJef/11x27uixYtkslk0muvvabAwEDFxMTo2LFjGj58uGOZBQsWqGXLlnruuecc0xYvXqzw8HD9+OOPatiwYaH1AACA4ilK1v/73//O16T/MetffvllmUwmvfrqqwoKCiLryzCadAAoYxYuXKjFixcrNTVVmZmZys7OduzClqdp06b5jkNPSUlRs2bNFBgY6JjWrl27fMvs3btXX375pYKDgwuMefjwYTVs2NC1DwQAABSqOFn/448/6s9//jNZXw7QpANAGbJq1SqNGTNGL730kmJjY1WxYkXNmjVL27dvzzdfhQoVirzuS5cuqU+fPnr++ecL3BcWFlbsmgEAgPPIetCkA4CB+fv7Kzc313E7KSlJHTt21IgRIxzTDh8+fMP1NGrUSG+//Xa+yw998803+eZp1aqV3nvvPUVGRl7zDLF/rAcAAJSMq7K+YcOGjqy3WCySyPqyiiYdgNe7ePSiYceJjIzU9u3bdeTIEQUHBysqKkrLli3TunXrVK9ePb311lv65ptvVK9eveuuZ9CgQfrnP/+pRx55ROPGjVNqaqpefPFFSZLJZJIkjRw5Uq+99poGDhyosWPHqmrVqjp06JBWrVql119/XT4+PgXqqVq1qluvcQwAQHF4S9ZPmDBBf//73zV+/HiyvgyjSQfgtUJDQ2UJsmjzC5vdNqYlyKLQUOfPKjxmzBgNGTJEMTExyszM1IEDB/Ttt99qwIABMplMGjhwoEaMGKFPPvnkuusJCQnRBx98oEcffVQtWrRQ06ZNNWnSJA0aNMhx7Frt2rWVlJSkp556Sj169FBWVpZuuukm9erVyxHOf6yHy7IAAIzM27J+5cqVGjt2LFlfxtGkA/BaEREROpB8QGlpaW4bMzQ0tEjXrm3YsKG2bduWb9qSJUu0ZMmSfNOeffZZpaenS5KWLl1a6Lo6duyovXv3Om4vX75cfn5++eqJiorS+++/X6R6AAAwqvKU9TNmzHD8fq2sb9++vb799ltHw03Wl0006QC8WkRERJGCtCxbtmyZ6tevrzp16mjv3r2O66LmHbcGAEB55E1Zv2rVKsXExCg8PJysL8No0gHAS5w8eVKTJk3SyZMnFRYWpnvvvVfPPvusp8sCAAAucurUKc2cOZOsL+No0gHAS4wdO1Zjx471dBkAAKCUxMfHa+LEiZzorYzjfw8AAAAAAIOgSQfgNex2u6dLgBfj+QcApY/3WniSq55/NOkAyj0/Pz9JUkZGhocrgTfLe/7lPR8BAK5D1sMIsrOzJUk+Pj4lWg/HpAMo93x8fFS5cmWdPn1akhQUFCSTyeThqlzLZrMpOztbV65c8erj0Iy4Hex2uzIyMnT69GlVrly5xMENACjIG7L+RoyYgd7EZrPpzJkzCgoKkq9vydpsmnQAXqFWrVqS5Ajv8sZutyszM1MWi8Xr/ij5PSNvh8qVKzuehwAA1yvvWX8jRs5Ab2E2mxUREVHi7U+TDsArmEwmhYWFqUaNGrJarZ4ux+WsVqs2b96sLl26ePXu1EbdDn5+fnyDDgClrLxn/Y0YNQO9ib+/v0v2YqBJB+BVfHx8ymWz5OPjo5ycHAUGBnp1MLMdAADlNetvhAwsPzhYAQAAAAAAg6BJBwAAAADAIGjSAQAAAAAwCJp0AAAAAAAMgiYdAAAAAACDoEkHAAAAAMAgaNIBAAAAADAIjzfpCxcuVGRkpAIDA9W+fXvt2LHjuvNfuHBBI0eOVFhYmAICAtSwYUN9/PHHbqoWAAAUB3kPAIBzfD05+OrVq5WQkKBFixapffv2SkxMVM+ePZWSkqIaNWoUmD87O1vdu3dXjRo19O6776pOnTr65ZdfVLlyZfcXDwAAnELeAwDgPI826bNnz9bw4cM1bNgwSdKiRYv00UcfafHixRo3blyB+RcvXqxz585p69at8vPzkyRFRka6s2QAAFBE5D0AAM7zWJOenZ2tXbt2afz48Y5pZrNZ3bp107Zt2wpdZu3atYqNjdXIkSP13//+V9WrV9egQYP01FNPycfHp9BlsrKylJWV5bidnp4uSbJarbJarS58RKUrr9ayVHNpYDv8hm1xFdvhKrbDVWV1O5S1eouiPOS9zWaTxWKRn1nyNdlKtC6j8vcxyWKxSL4Bssqv1MfLG8MdY+Wx+/jLYrHI38dfvnaPfk9VavxMfrJYLLLZbOX6fQWFK6sZ6C2K8v/isXeotLQ05ebmqmbNmvmm16xZUwcOHCh0mZ9++klffPGF7r//fn388cc6dOiQRowYIavVqsmTJxe6zIwZMzR16tQC0z/77DMFBQWV/IG42fr16z1dgiGwHX7DtriK7XAV2+GqsrYdMjIyPF1CqSkveb9y5cr//1taiddlSDVq6/HOVx+jO4/8X1/lfvcN1kFa2eH//5513TnLrrrS4JWDdezYMR07dszT1cBDyloGeouiZH2Z+hjRZrOpRo0aevXVV+Xj46PWrVvr2LFjmjVr1jVDe/z48UpISHDcTk9PV3h4uHr06KGQkBB3lV5iVqtV69evV/fu3R27/nkjtsNv2BZXsR2uYjtcVVa3Q963vrjKaHm/d+9edenSRbeOeVlVwqNKtC6jOpHynba9PFqvDWum/m3DSn08q/y0vsr96n5+ufzknm/9tqWcUK+536njqI6q36W+W8Z0t7OHz+qTJz/R5s2b1bx5c0+XAzcrqxnoLYqS9R5r0kNDQ+Xj46NTp07lm37q1CnVqlWr0GXCwsLk5+eXb1e36OhonTx5UtnZ2fL39y+wTEBAgAICAgpM9/PzK5NP3rJat6uxHX7DtriK7XAV2+GqsrYdylKtRVUe8t5sNiszM1NWm5Rj9/iFcUpFdq5dmZmZUk6W25pmSfKT1W3jmXKzlZmZqezcbOWYctwyprtZ7VZlZmbKbDaX6/cVXF9Zy0BvUZT/E48ljb+/v1q3bq0NGzY4ptlsNm3YsEGxsbGFLtOpUycdOnRINttvx4P9+OOPCgsLKzSwAQCAZ5H3AAAUjUc/Dk5ISNBrr72mN998U8nJyXr00Ud1+fJlx9lfBw8enO9EM48++qjOnTun+Ph4/fjjj/roo4/03HPPaeTIkZ56CAAA4AbIewAAnOfRY9IHDBigM2fOaNKkSTp58qRatGihTz/91HFymdTUVJnNv32OEB4ernXr1umJJ55Qs2bNVKdOHcXHx+upp57y1EMAAAA3QN4DAOA8j584Li4uTnFxcYXet3HjxgLTYmNj9fXXX5dyVQAAwJXIewAAnFM+z34CAAAAAEAZVKwm/csvv3R1HQAAwGDIewAA3K9YTXqvXr30pz/9Sc8884yOHj3q6poAAIABkPcAALhfsZr0Y8eOKS4uTu+++67q16+vnj176t///reys7NdXR8AAPAQ8h4AAPcrVpMeGhqqJ554Qnv27NH27dvVsGFDjRgxQrVr19bjjz+uvXv3urpOAADgZuQ9AADuV+ITx7Vq1Urjx49XXFycLl26pMWLF6t169bq3LmzfvjhB1fUCAAAPIy8BwDAPYrdpFutVr377rvq3bu3brrpJq1bt04LFizQqVOndOjQId1000269957XVkrAABwM/IeAAD3KtZ10h977DGtXLlSdrtdDz74oF544QU1adLEcX+FChX04osvqnbt2i4rFAAAuBd5DwCA+xWrSd+/f7/mz5+vu+++WwEBAYXOExoayqVbAAAow8h7AADcr1i7u0+ePFn33ntvgcDOycnR5s2bJUm+vr665ZZbSl4hAADwCPIeAAD3K1aTfuutt+rcuXMFpl+8eFG33npriYsCAACeR94DAOB+xWrS7Xa7TCZTgelnz55VhQoVSlwUAADwPPIeAAD3K9Ix6XfffbckyWQyaejQofl2f8vNzdV3332njh07urZCAADgVuQ9AACeU6QmvVKlSpKufrJesWJFWSwWx33+/v7q0KGDhg8f7toKAQCAW5H3AAB4TpGa9CVLlkiSIiMjNWbMGHZ1AwCgHCLvAQDwnGJdgm3y5MmurgMAABgMeQ8AgPs53aS3atVKGzZsUJUqVdSyZctCTySTZ/fu3S4pDgAAuBd5DwCAZzndpPft29dx4ph+/fqVVj0AAMCDyHsAADzL6Sb997u8sfsbAADlE3kPAIBnFes66QAAAAAAwPWc/ia9SpUq1z0u7ffOnTtX7IIAAIDnkPcAAHiW0016YmJiKZYBAACMgLwHAMCznG7ShwwZUpp1AAAAAyDvAQDwLKeb9PT0dIWEhDh+v568+QAAQNlC3gMA4FlFOib9xIkTqlGjhipXrlzo8Wp2u10mk0m5ubkuLRIAALgHeQ8AgGc53aR/8cUXqlq1qiTpyy+/LLWCAACA55D3AAB4ltNN+i233FLo7wAAoPwg7wEA8Cynm/Q/On/+vN544w0lJydLkmJiYjRs2DDHp+8AAKDsI+8BAHAvc3EW2rx5syIjIzVv3jydP39e58+f17x581SvXj1t3rzZ1TUCAAAPIO8BAHC/Yn2TPnLkSA0YMECvvPKKfHx8JEm5ubkaMWKERo4cqX379rm0SAAA4H7kPQAA7lesb9IPHTqk0aNHOwJbknx8fJSQkKBDhw65rDgAAOA55D0AAO5XrCa9VatWjmPTfi85OVnNmzcvcVEAAMDzyHsAANzP6d3dv/vuO8fvjz/+uOLj43Xo0CF16NBBkvT1119r4cKFmjlzpuurBAAAbkHeAwDgWU436S1atJDJZJLdbndMGzt2bIH5Bg0apAEDBrimOgAA4FbkPQAAnuV0k/7zzz+XZh0AAMAAyHsAADzL6Sb9pptuKs06AACAAZD3AAB4VrEuwZZn//79Sk1NVXZ2dr7p//d//1eiogAAgHGQ9wAAuE+xmvSffvpJd911l/bt25fvuDWTySTp6jVUAQBA2UbeAwDgfsW6BFt8fLzq1aun06dPKygoSD/88IM2b96sNm3aaOPGjS4uEQAAeAJ5DwCA+xXrm/Rt27bpiy++UGhoqMxms8xms26++WbNmDFDjz/+uL799ltX1wkAANyMvAcAwP2K9U16bm6uKlasKEkKDQ3V8ePHJV092UxKSorrqgMAAB5D3gMA4H7F+ia9SZMm2rt3r+rVq6f27dvrhRdekL+/v1599VXVr1/f1TUCAAAPIO8BAHC/YjXpEyZM0OXLlyVJ06ZN05133qnOnTurWrVqWr16tUsLBAAAnkHeAwDgfsVq0nv27On4vUGDBjpw4IDOnTunKlWqOM74CgAAyjbyHgAA9yvRddIl6ejRo5Kk8PDwEhcDAACMibwHAMA9inXiuJycHE2cOFGVKlVSZGSkIiMjValSJU2YMEFWq9XVNQIAAA8g7wEAcL9ifZP+2GOP6f3339cLL7yg2NhYSVcv0zJlyhSdPXtWr7zyikuLBAAA7kfeAwDgfsVq0lesWKFVq1bpjjvucExr1qyZwsPDNXDgQEIbAIBygLwHAMD9irW7e0BAgCIjIwtMr1evnvz9/UtaEwAAMADyHgAA9ytWkx4XF6fp06crKyvLMS0rK0vPPvus4uLiXFYcAADwHPIeAAD3c3p397vvvjvf7c8//1x169ZV8+bNJUl79+5Vdna2br/9dtdWCAAA3Ia8BwDAs5xu0itVqpTv9j333JPvNpdkAQCg7CPvAQDwLKeb9CVLlpRmHQAAwADIewAAPKtYx6TnOXPmjLZs2aItW7bozJkzxV7PwoULFRkZqcDAQLVv3147duxwarlVq1bJZDKpX79+xR4bAABcnyvynqwHAMA5xWrSL1++rIceekhhYWHq0qWLunTpotq1a+vhhx9WRkZGkda1evVqJSQkaPLkydq9e7eaN2+unj176vTp09dd7siRIxozZow6d+5cnIcAAABuwFV5T9YDAOC8YjXpCQkJ2rRpkz744ANduHBBFy5c0H//+19t2rRJo0ePLtK6Zs+ereHDh2vYsGGKiYnRokWLFBQUpMWLF19zmdzcXN1///2aOnWq6tevX5yHAAAAbsBVeU/WAwDgPKePSf+99957T++++666du3qmNa7d29ZLBb1799fr7zyilPryc7O1q5duzR+/HjHNLPZrG7dumnbtm3XXG7atGmqUaOGHn74YX311VfXHSMrKyvfpWPS09MlSVarVVar1ak6jSCv1rJUc2lgO/yGbXEV2+EqtsNVZXU7GLVeV+S9O7JeKt28t9lsslgs8jNLviZbidZlVP4+JlksFsk3QFb5lfp4eWO4Y6w8dh9/WSwW+fv4y9derD+BDc/P5CeLxSKbzWbY9xWUnrKagd6iKP8vxXqHysjIUM2aNQtMr1GjRpF2f0tLS1Nubm6BddWsWVMHDhwodJktW7bojTfe0J49e5waY8aMGZo6dWqB6Z999pmCgoKcrtUo1q9f7+kSDIHt8Bu2xVVsh6vYDleVte1Q1EPF3MUVee+OrJdKP+9Xrlz5/39LK/G6DKlGbT3e+epj/NiNw66vcr/7Busgrezw/3/Puu6cZVddafDKwTp27JiOHTvm6WrgIWUtA71FUbK+WE16bGysJk+erGXLlikwMFCSlJmZqalTpyo2NrY4q3TKr7/+qgcffFCvvfaaQkNDnVpm/PjxSkhIcNxOT09XeHi4evTooZCQkNIq1eWsVqvWr1+v7t27y8/PfZ86Gw3b4Tdsi6vYDlexHa4qq9sh71tfo/FE3hcn66XSzfu9e/eqS5cuunXMy6oSHlWidRnViZTvtO3l0XptWDP1bxtW6uNZ5af1Ve5X9/PL5Sf3fOu3LeWEes39Th1HdVT9LuXzEIqzh8/qk//H3p2HN1Xn7R+/k64pbQEpO60FKVCGpchSioqIbDLyiCuCCkUHnAc6A9YNfGRzA0WhKCgqA4jD4s4wLiB2RBQqO4hSEFAsw162Ag1t2uT3B79GYgt0SXNO2/frunpBTs45309Om3xyJ2d5/AutXr1abdu2Nboc+FhF7YFVRUl6falCekpKivr06aNGjRq5XwC2bdum4OBgrVixotjriYiIkJ+fn44cOeIx/ciRI6pXr16h+ffu3at9+/apX79+7mlO54Xdzvz9/bVr1y5dc801HssEBQUpKCio0LoCAgIq5B9vRa3b29gOv2NbXMB2uIDtcEFF2w5mrdUb/d4XvV4q335vtVplt9vlcEp5rjJdGMe0cvNdstvtUl6Oz0KzJAXI4bPxLPm5stvtys3PVZ4lzydj+prD5ZDdbpfVajXt6wrKX0XrgVVFSX4npQrprVu31u7du7Vw4UL3rmoDBw7Ufffdd+F4pmIKDAxU+/btlZqa6r60itPpVGpqqpKSkgrN36JFC23fvt1j2tNPP60zZ85oxowZioyMLM3DAQAARfBGv6fXAwBQMiUO6Q6HQy1atNCnn36qYcOGlbmA5ORkDRkyRB06dFCnTp2UkpKic+fOaejQoZKkwYMHq2HDhpo8ebKCg4PVqlUrj+Vr1KghSYWmAwCA0vNmv6fXAwBQfCUO6QEBATp//rzXChgwYICOHTum8ePH6/Dhw4qLi9Py5cvdJ5jJyMiQ1Vo5dy0DAMCsvNnv6fUAABRfqXZ3HzlypF588UXNmTNH/v5lv4RFUlJSkbu8SdKqVasuu+z8+fPLPD4AACjMm/2eXg8AQPGUquNu2LBBqamp+vLLL9W6dWtVq1bN4/6PP/7YK8UBAADj0O8BAPC9UoX0GjVq6M477/R2LQAAwETo9wAA+F6JQrrT6dTUqVP1888/Kzc3V927d9fEiRNLdEZ3AABgbvR7AACMU6KztDz//PN66qmnFBoaqoYNG+rVV1/VyJEjy6s2AABgAPo9AADGKVFIX7BggV5//XWtWLFCS5cu1b///W8tXLhQTqezvOoDAAA+Rr8HAMA4JQrpGRkZ6tu3r/t2jx49ZLFYdPDgQa8XBgAAjEG/BwDAOCUK6Xl5eQoODvaYFhAQIIfD4dWiAACAcej3AAAYp0QnjnO5XEpMTFRQUJB72vnz5/XXv/7V47IsXJIFAICKi34PAIBxShTShwwZUmja/fff77ViAACA8ej3AAAYp0Qhfd68eeVVBwAAMAn6PQAAxinRMekAAAAAAKD8ENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmIS/0QUAAAAAQGWTkZGhzMxMn43ndDolSdu2bZPV6pvvYnNychQUFOSTsYwSERGhqKgon45JSAeAcuaNJm1EgwAAAKWTkZGh2BbNlW0/77MxbTabFi9erK5du8put/tkTKtFcrp8MpRhbCE27Uzf6dP3YYR0AChHGRkZatEiVnZ7dpnWY7OFaOfOdII6AAAVQGZmprLt5/XP4XGKrR/qkzGd1kAdkLR6TIKsztxyH2/zL8c07N1daje4nRp1bFTu4xnh9P7TWv3SamVmZhLSAaCyyMzMlN2erfgHJyi8fnSp1pF1aJ/WzZ3k8wYBAADKJrZ+qK6Nru6TsRwK0AFJbaPCFSBHuY93LvucJCm0XqgiYiLKfbyqhJAOoFx46zisyrKbd3j9aF0V1dzoMgAAAGByhHQAXuetXbwldvMGAABA1UJIB+B13tjFW2I3bwAAAFQ9hHQA5YZdvAEAAICS8c0F9AAAAAAAwBUR0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJPyNLgC4WEZGhjIzMy95v9PplCRt27ZNVuulP2PKyclRUFBQmeuJiIhQVFRUmdcDAAAAAMVBSIdpZGRkKLZFc2Xbz19yHpvNpsWLF6tr166y2+2XnM9qkZyustdkC7FpZ/pOgjoAAAAAnzBFSJ81a5amTp2qw4cPq23btnrttdfUqVOnIud9++23tWDBAv3444+SpPbt2+uFF1645PyoODIzM5VtP69/Do9TbP3QIudxWgN1QNLqMQmyOnOLnGfzL8c07N1daje4nRp1bFTqek7vP63VL61WZmYmIR0AyoheDwBA8Rge0t977z0lJydr9uzZio+PV0pKinr37q1du3apTp06heZftWqVBg4cqC5duig4OFgvvviievXqpZ9++kkNGzY04BHA22Lrh+ra6OpF3udQgA5IahsVrgA5ipznXPY5SVJovVBFxESUV5mXdKVd9ouLXe0BVBb0egAAis/wkD5t2jQNGzZMQ4cOlSTNnj1bn332mebOnasxY8YUmn/hwoUet+fMmaOPPvpIqampGjx4sE9qBi4lIyNDLVrEym7PLvO6goNt+vDDD1S/fv0i7y/O8fkcmw/ADOj1AAAUn6EhPTc3V5s2bdLYsWPd06xWq3r06KG0tLRirSM7O1sOh0NXXXVVkffn5OQoJyfHfTsrK0uS5HA45HAU/U2sGRXUWpFqLimn0ymbzSanNVAOBRQ5T8H0S90vSS6/QNlsNgX6BcrfVfo/8QBLwIV6nM5ib/ejR49KcumG4ZMUVrf0ofbkf/dq65JXdPfdd19yHpvNprlz56p3796XPD7fm8fmb9ywUY0aFe/wgYLfZYBV8rc4Sz1ugFVX/B2Y/bnhjW1RGbaDr1TU7VDR6i0JX/R6qXz7vbde08ws0M8im80m+Qddtsd6S3H6ubd56/2BmZXmvQvKR3He13qbr59XPKdKpiTLW1wulxfewpfOwYMH1bBhQ61du1YJCQnu6U888YS++eYbrVu37orrGDFihFasWKGffvpJwcHBhe6fOHGiJk2aVGj6okWLFBISUrYHAACAF2RnZ2vQoEE6ffq0wsPDjS7Hq3zR6yX6PQDA3ErS6yv0Rx5TpkzRkiVLtGrVqks27bFjxyo5Odl9OysrS5GRkerVq1eFeiPkcDi0cuVK9ezZUwEBvvvU2Ze2bdumrl27avWYBLWNKvp341CAVta8Tz1PLrzkMelpuw6pz4wf1GV0FzXp2qTU9Rzfe1xfPP6FVq9erbZt25boMdz02OuqGRlT6rEP7fpBaa8/qreHttE9HYve3f1K26IybIdje3fo21dHXXaegj0KHnzwwcue8T/EFqwNGzcVe28Ab/HGtvDmdjBq7wpfqaivlQXf+qKw4vR6qXz7vbde08ysOH3Hm4rTz73NW33RzErTs1E+ivO+1tt8/bziOVUyJen1hob0iIgI+fn56ciRIx7Tjxw5onr16l122ZdffllTpkzRV199pTZt2lxyvqCgoCKPyQ0ICKhQb+AKVNS6i8Nqtcput8vqzL3iC0uAHJecx5KfK7vdrtz8XOVZ8kpdj8PluFCP1VrsbV7wGBxOKc916eu4X0luvutC0MrLKfW2qAzbITvnwtjP3tFMfVsXPrmU9PsZ/1eMirvkGf/TD53V/W9t1cmTJ9W4ceNS11Ma3tgW3toO3r7ygRHbs7gq2mtlRaq1pHzR66Xy7ffeek0zs5L0HW+6XD/3Nm/1RTMrTc9G+SjJ+1pv89XziudUyZRkeUNDemBgoNq3b6/U1FT1799f0oXjN1JTU5WUlHTJ5V566SU9//zzWrFihTp06OCjagEYpXFESJnO+F9ZlHU7GH3lA1RN9HoAAErG8N3dk5OTNWTIEHXo0EGdOnVSSkqKzp075z4D7ODBg9WwYUNNnjxZkvTiiy9q/PjxWrRokaKjo3X48GFJUmhoqEJDi762NgCgcrjSJQ6Lc9UDiSsf+Bq9HgCA4jM8pA8YMEDHjh3T+PHjdfjwYcXFxWn58uWqW7eupAtvyC5+o/XGG28oNzdXd911l8d6JkyYoIkTJ/qydACAD2VkZCi2RXNl289fch6bzabFixera9euPjs2f2f6ToL6FdDrAQAoPsNDuiQlJSVdcpe3VatWedzet29f+RcEADCdzMxMZdvP65/D4xRbv+hvUwuOzV89JsFnx+ZnZmYS0ouBXg8AQPGYIqQDAFBcsfVDOTYfAABUWpXzFKUAAAAAAFRAhHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJuFvdAEAAAAAqpaMjAxlZmYaXUa5SU9PN7oEVGCEdABVRlkbZkREhKKiorxUDQAAVVNGRoZatIiV3Z5tdCnlzKJDp89Lqm50IahgCOnwmrJ+IsonjigvObk5kqT777+/TOuxhdi0M30nQb2UeI0AAEhSZmam7PZsxT84QeH1o40up1wc+3Wnti56Uaey84wuBRUQIR1e4b1PRPnEEd6Xl3ehQbYb3E6NOjYq1TpO7z+t1S+tVmZmJiG9FHiNAAD8UXj9aF0V1dzoMsqF/Vxl30sA5YmQDq/wxieifOKI8hZaL1QRMRFGl1El8RoBAABQPIT0SsYbJ+Eoy3G3ZflElE8cgcqP1wgAAIDLI6RXIhkZGWoR20L2bHuZ1sNxtwAAAABgDEJ6JZKZmSl7tl1dn+iq6pGlO16T424BAAAAwDiE9EqoemR1jrsFAAAAgArIanQBAAAAAADgAkI6AAAAAAAmQUgHAAAAAMAkCOkAAAAAAJgEIR0AAAAAAJMgpAMAAAAAYBKEdAAAAAAATIKQDgAAAACASRDSAQAAAAAwCUI6AAAAAAAmQUgHAAAAAMAkCOkAAAAAAJgEIR0AAAAAAJMgpAMAAAAAYBKEdAAAAAAATIKQDgAAAACASRDSAQAAAAAwCUI6AAAAAAAmQUgHAAAAAMAkCOkAAAAAAJgEIR0AAAAAAJMgpAMAAAAAYBKmCOmzZs1SdHS0goODFR8fr/Xr1192/g8++EAtWrRQcHCwWrdurc8//9xHlQIAgNKg1wMAUDyGh/T33ntPycnJmjBhgjZv3qy2bduqd+/eOnr0aJHzr127VgMHDtRDDz2kLVu2qH///urfv79+/PFHH1cOAACKg14PAEDxGR7Sp02bpmHDhmno0KFq2bKlZs+erZCQEM2dO7fI+WfMmKE+ffro8ccfV2xsrJ599llde+21mjlzpo8rBwAAxUGvBwCg+PyNHDw3N1ebNm3S2LFj3dOsVqt69OihtLS0IpdJS0tTcnKyx7TevXtr6dKlRc6fk5OjnJwc9+3Tp09Lkk6cOCGHw1HGRyAdPXpUR44cKfN6rFarnE7nJe93Op3Kzs7Wt99+K6u16M9Wdu/ereDgYJ359Yx0vnR1nDl0RsHBwcrKytLx48eLvVxWVpaCg4N19sDPksNeqrHth39RcHCwdmXmatXPZ4qcx2kNVPafsvXtnrOyOnOLnOfHg7kKDg5W9sFsZW7PLFUtUum2hTe2g+SdbcF2+J03tgXPjd8Z9TdRGbbDJdd15sLjcblcZVqPGfmi10vl2++99ZpmZsV5fnlTcZ6r3uat576ZefN1qTzxnCofvn5e8Zwq4bpK0utdBjpw4IBLkmvt2rUe0x9//HFXp06dilwmICDAtWjRIo9ps2bNctWpU6fI+SdMmOCSxA8//PDDDz+m/9m/f793GqyJ+KLXu1z0e3744YcffirGT3F6vaHfpPvC2LFjPT6NdzqdOnHihGrVqiWLxWJgZSWTlZWlyMhI7d+/X+Hh4UaXYxi2w+/YFhewHS5gO1xQUbeDy+XSmTNn1KBBA6NLqbAqS7+vKirqcxUwM55X5laSXm9oSI+IiJCfn1+h3cWPHDmievXqFblMvXr1SjR/UFCQgoKCPKbVqFGj9EUbLDw8nCed2A4XY1tcwHa4gO1wQUXcDtWrVze6hHLhi14vVb5+X1VUxOcqYHY8r8yruL3e0BPHBQYGqn379kpNTXVPczqdSk1NVUJCQpHLJCQkeMwvSStXrrzk/AAAwDj0egAASsbw3d2Tk5M1ZMgQdejQQZ06dVJKSorOnTunoUOHSpIGDx6shg0bavLkyZKkUaNG6cYbb9Qrr7yiP//5z1qyZIk2btyot956y8iHAQAALoFeDwBA8Rke0gcMGKBjx45p/PjxOnz4sOLi4rR8+XLVrVtXkpSRkeFxNvMuXbpo0aJFevrpp/XUU08pJiZGS5cuVatWrYx6CD4RFBSkCRMmFNqVr6phO/yObXEB2+ECtsMFbAdzotfjj3iuAt7H86rysLhclfB6LwAAAAAAVECGHpMOAAAAAAB+R0gHAAAAAMAkCOkAAAAAAJgEIR0AAAAAAJMgpAMAAAAAYBKE9Apg1qxZio6OVnBwsOLj47V+/XqjS/K51atXq1+/fmrQoIEsFouWLl1qdEmGmDx5sjp27KiwsDDVqVNH/fv3165du4wuy+feeOMNtWnTRuHh4QoPD1dCQoK++OILo8sy3JQpU2SxWDR69GijS/G5iRMnymKxePy0aNHC6LIAXALvbQDv4X1y5UNIN7n33ntPycnJmjBhgjZv3qy2bduqd+/eOnr0qNGl+dS5c+fUtm1bzZo1y+hSDPXNN99o5MiR+v7777Vy5Uo5HA716tVL586dM7o0n2rUqJGmTJmiTZs2aePGjerevbtuu+02/fTTT0aXZpgNGzbozTffVJs2bYwuxTB/+tOfdOjQIffPd999Z3RJAIrAexvAu3ifXPlwnXSTi4+PV8eOHTVz5kxJktPpVGRkpP72t79pzJgxBldnDIvFok8++UT9+/c3uhTDHTt2THXq1NE333yjrl27Gl2Ooa666ipNnTpVDz30kNGl+NzZs2d17bXX6vXXX9dzzz2nuLg4paSkGF2WT02cOFFLly7V1q1bjS4FwBXw3gYoP7xPrhz4Jt3EcnNztWnTJvXo0cM9zWq1qkePHkpLSzOwMpjF6dOnJV0IqFVVfn6+lixZonPnzikhIcHocgwxcuRI/fnPf/Z4raiKdu/erQYNGqhJkya67777lJGRYXRJAP6A9zYAcGX+RheAS8vMzFR+fr7q1q3rMb1u3brauXOnQVXBLJxOp0aPHq3rrrtOrVq1Mrocn9u+fbsSEhJ0/vx5hYaG6pNPPlHLli2NLsvnlixZos2bN2vDhg1Gl2Ko+Ph4zZ8/X82bN9ehQ4c0adIk3XDDDfrxxx8VFhZmdHkA/j/e2wDAlRHSgQpq5MiR+vHHH6vscbfNmzfX1q1bdfr0aX344YcaMmSIvvnmmyoV1Pfv369Ro0Zp5cqVCg4ONrocQ91yyy3u/7dp00bx8fG6+uqr9f7771fJQyAAAEDFRUg3sYiICPn5+enIkSMe048cOaJ69eoZVBXMICkpSZ9++qlWr16tRo0aGV2OIQIDA9W0aVNJUvv27bVhwwbNmDFDb775psGV+c6mTZt09OhRXXvtte5p+fn5Wr16tWbOnKmcnBz5+fkZWKFxatSooWbNmmnPnj1GlwLgIry3AYAr45h0EwsMDFT79u2VmprqnuZ0OpWamlplj72t6lwul5KSkvTJJ5/oP//5jxo3bmx0SabhdDqVk5NjdBk+dfPNN2v79u3aunWr+6dDhw667777tHXr1iob0KULJ9Pbu3ev6tevb3QpAC7CexsAuDK+STe55ORkDRkyRB06dFCnTp2UkpKic+fOaejQoUaX5lNnz571+Ebs119/1datW3XVVVcpKirKwMp8a+TIkVq0aJH+9a9/KSwsTIcPH5YkVa9eXTabzeDqfGfs2LG65ZZbFBUVpTNnzmjRokVatWqVVqxYYXRpPhUWFlbofATVqlVTrVq1qtx5Ch577DH169dPV199tQ4ePKgJEybIz89PAwcONLo0AH/AexvAu3ifXPkQ0k1uwIABOnbsmMaPH6/Dhw8rLi5Oy5cvL3TClcpu48aNuummm9y3k5OTJUlDhgzR/PnzDarK99544w1JUrdu3Tymz5s3T4mJib4vyCBHjx7V4MGDdejQIVWvXl1t2rTRihUr1LNnT6NLg0H++9//auDAgTp+/Lhq166t66+/Xt9//71q165tdGkA/oD3NoB38T658uE66QAAAAAAmATHpAMAAAAAYBKEdAAAAAAATIKQDgAAAACASRDSAQAAAAAwCUI6AAAAAAAmQUgHAAAAAMAkCOkAAAAAAJgEIR0AAACoILp166bRo0df8v7o6GilpKT4rB4A3kdIB1Bu9u3bJ4vFoq1btxpdCgAAVcKGDRs0fPhwo8solg8++EAtWrRQcHCwWrdurc8//9zokgBTIKQDMFxubq7RJQAAUCnUrl1bISEh5TqGN/r22rVrNXDgQD300EPasmWL+vfvr/79++vHH3/0QoVAxUZIByoxp9Opl156SU2bNlVQUJCioqL0/PPPS5K2b9+u7t27y2azqVatWho+fLjOnj3rXrao3en69++vxMRE9+3o6Gi98MILevDBBxUWFqaoqCi99dZb7vsbN24sSWrXrp0sFou6desmSUpMTFT//v31/PPPq0GDBmrevLmeeeYZtWrVqtBjiIuL07hx47y0RQAAqPjy8vKUlJSk6tWrKyIiQuPGjZPL5ZJUeHd3i8WiOXPm6Pbbb1dISIhiYmK0bNky9/35+fl66KGH1LhxY9lsNjVv3lwzZszwGK88+vaMGTPUp08fPf7444qNjdWzzz6ra6+9VjNnzizlVgEqD0I6UImNHTtWU6ZM0bhx47Rjxw4tWrRIdevW1blz59S7d2/VrFlTGzZs0AcffKCvvvpKSUlJJR7jlVdeUYcOHbRlyxaNGDFC//u//6tdu3ZJktavXy9J+uqrr3To0CF9/PHH7uVSU1O1a9curVy5Up9++qkefPBBpaena8OGDe55tmzZoh9++EFDhw4t45YAAKDyeOedd+Tv76/169drxowZmjZtmubMmXPJ+SdNmqR77rlHP/zwg/r27av77rtPJ06ckHThA/1GjRrpgw8+0I4dOzR+/Hg99dRTev/99z3W4e2+nZaWph49enhM6927t9LS0kqyKYBKyd/oAgCUjzNnzmjGjBmaOXOmhgwZIkm65pprdP311+vtt9/W+fPntWDBAlWrVk2SNHPmTPXr108vvvii6tatW+xx+vbtqxEjRkiSnnzySU2fPl1ff/21mjdvrtq1a0uSatWqpXr16nksV61aNc2ZM0eBgYHuab1799a8efPUsWNHSdK8efN04403qkmTJqXfEAAAVDKRkZGaPn26LBaLmjdvru3bt2v69OkaNmxYkfMnJiZq4MCBkqQXXnhBr776qtavX68+ffooICBAkyZNcs/buHFjpaWl6f3339c999zjnu7tvn348OFC7zfq1q2rw4cPF39DAJUU36QDlVR6erpycnJ08803F3lf27Zt3QFdkq677jo5nU73t+DF1aZNG/f/LRaL6tWrp6NHj15xudatW3s0ekkaNmyYFi9erPPnzys3N1eLFi3Sgw8+WKJ6AACo7Dp37iyLxeK+nZCQoN27dys/P7/I+S/u1dWqVVN4eLhHr541a5bat2+v2rVrKzQ0VG+99ZYyMjI81kHfBnyHb9KBSspms5VpeavV6j6+rYDD4Sg0X0BAgMdti8Uip9N5xfVf/AFBgX79+ikoKEiffPKJAgMD5XA4dNddd5WwcgAAcLHL9eolS5boscce0yuvvKKEhASFhYVp6tSpWrdunccy3u7b9erV05EjRzymHTlypNCed0BVxDfpQCUVExMjm82m1NTUQvfFxsZq27ZtOnfunHvamjVrZLVa1bx5c0kXzg576NAh9/35+fklPuNqwSful/pk/4/8/f01ZMgQzZs3T/PmzdO9995b5g8bAACobP4YoL///nvFxMTIz8+vxOtas2aNunTpohEjRqhdu3Zq2rSp9u7dW6xly9K3ExISCr1HWblypRISEkr8GIDKhm/SgUoqODhYTz75pJ544gkFBgbquuuu07Fjx/TTTz/pvvvu04QJEzRkyBBNnDhRx44d09/+9jc98MAD7uPDunfvruTkZH322We65pprNG3aNJ06dapENdSpU0c2m03Lly9Xo0aNFBwcrOrVq192mb/85S+KjY2VdOGNAwAA8JSRkaHk5GQ9/PDD2rx5s1577TW98sorpVpXTEyMFixYoBUrVqhx48Z69913tWHDBvcVWq6ktH171KhRuvHGG/XKK6/oz3/+s5YsWaKNGzd6XCUGqKr4Jh2oxMaNG6dHH31U48ePV2xsrAYMGKCjR48qJCREK1as0IkTJ9SxY0fddddduvnmmz0ue/Lggw9qyJAhGjx4sPskMDfddFOJxvf399err76qN998Uw0aNNBtt912xWViYmLUpUsXtWjRQvHx8SV+zAAAVHaDBw+W3W5Xp06dNHLkSI0aNUrDhw8v1boefvhh3XHHHRowYIDi4+N1/Phx9wlhi6O0fbtLly5atGiR3nrrLbVt21Yffvihli5dWuRl3YCqxuL640GnAGAgl8ulmJgYjRgxQsnJyUaXAwAALoO+DXgfu7sDMI1jx45pyZIlOnz4MNdGBwDA5OjbQPkgpAMwjTp16igiIkJvvfWWatasaXQ5AADgMi7Xt0NDQy+53BdffKEbbrihvMsDKix2dwcAAADgVXv27LnkfQ0bNuTqLcBlENIBAAAAADAJzu4OAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAk/A3ugBfczqdOnjwoMLCwmSxWIwuBwAAuVwunTlzRg0aNJDVyufn3kC/BwCYSUl6fZUL6QcPHlRkZKTRZQAAUMj+/fvVqFEjo8uoFOj3AAAzKk6vr3IhPSwsTNKFjRMeHm5wNSiKw+HQl19+qV69eikgIMDocoAKj+eU+WVlZSkyMtLdo1B29Htz43UJ8D6eV+ZWkl5f5UJ6wS5v4eHhNG2TcjgcCgkJUXh4OC8wgBfwnKo42C3be+j35sbrEuB9PK8qhuL0eg58AwAAAADAJAjpAAAAAACYBCEdAAAAAACTqHLHpAOoulwul/Ly8pSfn290KT7lcDjk7++v8+fPV7nHbhZ+fn7y9/fnmHMAKGdVtddL9HszCAgIkJ+fX5nXQ0gHUCXk5ubq0KFDys7ONroUn3O5XKpXr572799PSDRQSEiI6tevr8DAQKNLAYBKqSr3eol+bwYWi0WNGjVSaGhomdZDSAdQ6TmdTv3666/y8/NTgwYNFBgYWKWal9Pp1NmzZxUaGiqrlaOcfM3lcik3N1fHjh3Tr7/+qpiYGH4PAOBlVb3XS/R7o7lcLh07dkz//e9/FRMTU6Zv1AnpACq93NxcOZ1ORUZGKiQkxOhyfM7pdCo3N1fBwcE0bYPYbDYFBATot99+c/8uAADeU9V7vUS/N4PatWtr3759cjgcZQrp/PYAVBk0LBiJvz8AKH+81sJI3tp7g79iAAAAAABMgpAOAAAAAIBJENIBAJfVrVs3jR492jTrAQAA3ke/Nw9OHAcA8KpVq1bppptu0smTJ1WjRg339I8//lgBAQHGFQYAALyGfl9+COkAAJ+46qqrjC4BAACUM/p92bG7OwCYVLdu3ZSUlKSkpCRVr15dERERGjdunFwulyTp5MmTGjx4sGrWrKmQkBDdcsst2r17t3v5+fPnq0aNGlq6dKnat2+vkJAQ9e7dW/v373fPk5iYqP79+3uMO3r0aHXr1u2Sdb377rvq0KGDwsLCVK9ePQ0aNEhHjx6VJO3bt0833XSTJKlmzZqyWCxKTEx0P56Ld38rbv0rVqxQbGysQkND1adPHx06dKg0mxMAAFOi39Pv/4iQDgAm9s4778jf31/r16/XjBkzNG3aNM2ZM0fShYa7ceNGLVu2TGlpaXK5XOrbt68cDod7+ezsbE2ePFlvvPGGvv32W506dUr33ntvmWpyOBx69tlntW3bNi1dulT79u1zN+bIyEh99NFHkqRdu3bp0KFDmjFjRpHrKW79L7/8st59912tXr1aGRkZeuyxx8pUPwAAZkO/p99fjN3dAcDEIiMjNX36dFksFjVv3lzbt2/X9OnT1a1bNy1btkxr1qxRly5dJEkLFy5UZGSkli5dqrvvvlvShQb76quvKjY2VuHh4XrnnXcUGxur9evXq1OnTqWq6cEHH3T/v0mTJnr11VfVsWNHnT17VqGhoe7d3OrUqeNxjNrFdu/eXez6Z8+erWuuuUaSlJSUpGeeeaZUdQMAYFb0e/r9xfgmHQBMrHPnzrJYLO7bCQkJ2r17t3bs2CF/f3/Fx8e776tVq5aaN2+u9PR09zR/f3917NjRfbtFixaqUaOGxzwltWnTJvXr109RUVEKCwvTjTfeKEnKyMgo9jrS09OLVX9ISIi7YUtS/fr13bvaAQBQWdDv6fcXI6QDQBVmtVrdx7wVuHj3sz86d+6cevfurfDwcC1cuFAbNmzQJ598IknKzc31en1/PDusxWIpVC8AALg8+n3FQkgHABNbt26dx+3vv/9eMTExatmypfLy8jzuP378uHbt2qWWLVu6p+Xl5Wnjxo3u27t27dKpU6cUGxsrSapdu3ahE7Ns3br1kvXs3LlTx48f15QpU3TDDTeoRYsWhT7pDgwMlCTl5+dfcj2xsbHFqh8AgKqAfo+LEdIBwMQyMjKUnJysXbt2afHixXrttdc0atQoxcTE6LbbbtOwYcP03Xffadu2bbr//vvVsGFD3Xbbbe7lAwICNGrUKG3cuFGbNm1SYmKiOnfu7D4+rXv37tq4caMWLFig3bt3a8KECfrxxx8vWU9UVJQCAwP12muv6ZdfftGyZcv07LPPesxz9dVXy2Kx6NNPP9WxY8d09uzZQuspbv0AAFQF9HtcjJAOACY2ePBg2e12derUSSNHjtSoUaM0fPhwSdK8efPUvn173XrrrUpISJDL5dLnn3/usctYSEiIHn/8cQ0bNkw33HCDQkND9d5777nv7927t8aNG6cnnnhCHTt21JkzZzR48OBL1lO7dm3Nnz9fH3zwgVq2bKkpU6bo5Zdf9pinYcOGmjRpksaMGaO6desqKSmpyHUVp34AAKoC+j0uZnFVsZ39s7KyVL16dZ0+fVrh4eFGl4MiOBwOff755+rbty9PXnjF+fPn9euvv6px48YKDg42upxi69atm+Li4pSSklKq5efPn6/Ro0frxIkTysrKUnh4uKxWPps1yuX+DulN3sc2NTd6PbytovZ6iX5fmXir1/PbAwAAAADAJAjpAAAAAACYhL/RBQAAirZq1aoyLZ+YmKjExEQ5nU7vFAQAALyOfo8/4pt0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQ4uzuAKi0jI0OZmZk+Gy8iIkJRUVE+Gw8AgKqOXo+KhpAOoMrKyMhQixaxstuzfTamzRainTvTTde8o6OjNXr0aI0ePfqS8+Tm5qply5ZasGCBunTp4rviTMBiseiTTz5R//79i7x/x44d6tWrl3bt2qVq1ar5tjgAwCXR639Hr788M/V6QjqAKiszM1N2e7biH5yg8PrR5T5e1qF9Wjd3kjIzM03XuItj9uzZaty4cYVu2vv27VPjxo21ZcsWxcXFeW29LVu2VOfOnTVt2jSNGzfOa+sFAJQNvb5k6PWX5steT0gHUOWF14/WVVHNjS7D1Fwul2bOnKlnnnmmzOvJz8+Xv3/laz9Dhw7VsGHDNHbs2Er5+ACgIqPXXxm9/sp81es5cRwAmFi3bt2UlJSkpKQkVa9eXRERERo3bpxcLpd7npMnT2rw4MGqWbOmQkJCdMstt2j37t0e61m2bJlat26toKAgRUdH65VXXilRHZs2bdLevXv15z//2T1t3759slgsWrJkibp06aLg4GC1atVK33zzjXueVatWyWKx6IsvvlD79u0VFBSk7777Tk6nU5MnT1bjxo1ls9nUtm1bffjhh4WWW7Fihdq1ayebzabu3bvr6NGj+uKLLxQbG6vw8HANGjRI2dm/78K4fPlyXX/99apRo4Zq1aqlW2+9VXv37nXf37hxY0lSu3btZLFY1K1bN/d9c+fO1Z/+9CcFBQWpfv36SkpK8tgGmZmZuv322xUSEqKYmBgtW7bM4/6ePXvqxIkTHo8fAIAr8Vav/+ijj5SQkCCbzUavV8Xu9YR0ADC5d955R/7+/lq/fr1mzJihadOmac6cOe77ExMTtXHjRi1btkxpaWlyuVzq27evHA6HpAtNd+jQoRowYIC2b9+uiRMnaty4cZo/f36xa/j222/VrFkzhYWFFbrv8ccf16OPPqotW7YoISFB/fr10/Hjxz3mGTNmjKZMmaL09HS1adNGkydP1oIFCzR79mz99NNPeuSRR3T//fcXanoTJ07UzJkztXbtWu3fv1/33HOPUlJStGjRIn322Wf68ssv9dprr7nnP3funJKTk7Vx40alpqbKarXq9ttvl9PplCStX79ekvTVV1/p0KFD+vjjjyVJb7zxhkaOHKnhw4dr+/btWrZsmZo2bepRy6RJk3TPPffohx9+UN++fXXffffpxIkT7vsDAwMVFxenb7/9ttjbFQAAyTu9/t5779Udd9yhbdu20etVsXt95dsHAQAqmcjISE2fPl0Wi0XNmzfX9u3bNX36dA0bNky7d+/WsmXLtGbNGvfxYwsXLlRkZKSWLl2qu+++W9OnT9eNN96op59+WlarVc2aNdOOHTs0depUJSYmFquG3377TQ0aNCjyvqSkJN15552SLjTA5cuX6x//+IeeeOIJ9zzPPPOMevbsKUnKycnRCy+8oK+++koJCQmSpCZNmui7777Tm2++qRtvvNG93HPPPafrrrtOkvTQQw9p7Nix2rt3r5o0aSJJuuuuu/T111/rySeflCR3HQXmzp2r2rVra8eOHWrVqpVq164tSapVq5bq1avnMc6jjz6qUaNGuad17NjRY12JiYkaOHCgJOmFF17Qq6++qvXr16tPnz7ueRo0aKDffvvt8hsTAIA/KGuvnzZtmrp3767HH39c4eHhatGiBb2+Avd6w79JnzVrlqKjoxUcHKz4+Hj3Jx+XkpKSoubNm8tmsykyMlKPPPKIzp8/76NqAcD3OnfuLIvF4r6dkJCg3bt3Kz8/X+np6fL391d8fLz7/lq1aql58+ZKT0+XJO3cudPjfkm67rrr3OsoDrvdruDg4CLvK2i+kuTv768OHTq4xy7QoUMH9//37Nmj7Oxs9ezZU6Ghoe6fBQsWeOyuJklt2rRx/79u3boKCQlxN+2CaUePHnXf3r17twYOHKgmTZooPDxc0dHRki6c3fdSjh49qoMHD+rmm2++zBbwrKVatWoKDw/3GFuSbDabxy55+B39HgAuray9Pj093R10C9Drf1fRer2h36S/9957Sk5O1uzZsxUfH6+UlBT17t1bu3btUp06dQrNv2jRIo0ZM0Zz585Vly5d9PPPPysxMVEWi0XTpk0z4BEAQNUQERGh7du3l3r5iy9VcvbsWUnSZ599poYNG3rMFxQU5HE7ICDA/X+LxeJxu2Bawe5tktSvXz9dffXVevvtt9WgQQM5nU61atVKubm5l6zNZrMV6zFcaWxJOnHihK655ppira8qod8DgPnR683T6w39Jn3atGkaNmyYhg4dqpYtW2r27NkKCQnR3Llzi5x/7dq1uu666zRo0CBFR0erV69eGjhw4BU/jQeAimzdunUet7///nvFxMTIz89PsbGxysvL85jn+PHj2rVrl1q2bClJatGiRaF1rFmzRs2aNZOfn1+xamjXrp127tzpcRKbi+spkJeXp02bNik2NvaS62rZsqWCgoKUkZGhpk2bevxERkYWq56iFDzup59+WjfffLNiY2N18uRJj3kCAwMlyeNbhbCwMEVHRys1NbXUYxf48ccf1a5duzKvp7Kh3wPA5ZW118fGxmrNmjUe66DXV9xeb9g36bm5udq0aZPGjh3rnma1WtWjRw+lpaUVuUyXLl30z3/+U+vXr1enTp30yy+/6PPPP9cDDzxwyXFycnKUk5Pjvp2VlSVJcjgc7hMtwFwKfi/8fuAtDodDLpdLTqfT49PQgv9nHdwnFe5HXpd1aJ973D9+Kns5GRkZeuSRRzR8+HBt3rxZr732mqZOnSqn06lrrrlG//M//6Nhw4bpjTfeUFhYmMaOHauGDRuqX79+cjqdeuSRR9S5c2c9++yzGjBggNLS0jRz5kzNnDnTo46CbVSUG2+8UWfPntX27dvVqlUr9+OQLuzGfM011yg2NlYpKSk6efKkEhMTPR7nxf+vVq2aHn30UT3yyCPKy8vT9ddfr9OnT2vt2rUKCwvTkCFDilzuj/8W1FwwrXr16qpVq5befPNN1a1bVxkZGXrqqac81hMRESGbzaYvvvhCDRo0UHBwsKpXr67x48drxIgRql27tvr06aMzZ85o7dq1Hmd9Ler3dvG0ffv26cCBA+revXuR29HpdMrlcsnhcBR6w1SZX+/o9ygKvR7eRq9/RPHx8Zo6daruv/9+ff/99/T6CtzrDQvpmZmZys/PV926dT2m161bVzt37ixymUGDBikzM1PXX3+9XC6X8vLy9Ne//tX9iynK5MmTNWnSpELTv/zyS4WEhJTtQaBcrVy50ugSUEn4+/urXr16Onv2rMeuUEFBQQq22bRuXuHXiPISbLMpKCjIHSCuJC8vTwMGDNDp06cVHx8vPz8/Pfzww7r33nvd65gxY4bGjBmjfv36yeFwqEuXLlqyZInsdrvsdrtiYmI0b948TZ48Wc8//7zq1q2rsWPH6o477nCvw+l06vz585esKyAgQLfeeqvmzZunCRMmSPp9V7Zx48Zp8uTJ2r59u5o0aaJFixYpMDBQWVlZ7mO2zpw5I6v19523HnvsMYWFhWny5Mnat2+fqlevrrZt2+qRRx655HLnz5+Xy+XyqDEnJ0f5+fnuaXPmzNGYMWPUpk0bNW3aVC+++KJuvfVW2e129zxTpkzRSy+9pAkTJighIUGffvqpbr/9dp06dUqzZs3S448/rlq1aul//ud/PMa6eB3ShTcNF2+z+fPnq3v37qpZs2aR2zE3N1d2u12rV69WXl6ex32V+Th2+j0uh14Pb6nqvb5p06buXj916lR6fQXv9RZXUfsz+MDBgwfVsGFDrV271uNEBE888YS++eabQrt8SBeupXfvvffqueeeU3x8vPbs2aNRo0Zp2LBhGjduXJHjFPXJemRkpDIzMxUeHu79B4YyczgcWrlypXr27FnouBCgNM6fP6/9+/e7T1p1sYyMDGVmZvqsloiICEVFRRV7/u7du6tt27aaPn16qcd0uVw6c+aMwsLCPE5KU1I//PCDevfurd27dys0NFT79u3TNddco02bNikuLq7U660McnNz1bx5c/3zn/8sdOKeAufPn9e+ffsUGRlZ6O8wKytLEREROn36dKXrTfR7FIVeD2+r6r1e8k6/p9dfmi97vWHfpEdERMjPz09HjhzxmH7kyBGPU+VfbNy4cXrggQf0l7/8RZLUunVrnTt3TsOHD9f//d//eXxyUyAoKKjQyQmkC58U0RTMjd8RvCU/P18Wi0VWq7XQ60R0dLT7rKBmVVB7aRXsjlXW9cTFxenFF1/Ub7/9ptatW7vXVdR2rWr++9//6qmnntINN9xwyXmsVqv7hDh/fG2rzK919HtcDr8feEtV7/WSd/o9vf7SfNnrDdvSgYGBat++vcfB+06nU6mpqR6ftF8sOzu70B9Hwb7+Bu0QAABVSmJiolq3bm10GabTtGlTPfzww0aXYUr0ewCoWOj1RfNlrzf0EmzJyckaMmSIOnTooE6dOiklJUXnzp3T0KFDJUmDBw9Ww4YNNXnyZEkXTrc/bdo0tWvXzr3727hx49SvX79in7UQACqSVatWGV3CJUVHRxOYUCz0ewC4NHo9/sjQkD5gwAAdO3ZM48eP1+HDhxUXF6fly5e7Ty6TkZHh8Un6008/LYvFoqeffloHDhxQ7dq11a9fPz3//PNGPQQAAHAF9HsAAIrPsBPHGSUrK0vVq1evlCfnqSwcDoc+//xz9e3bl+PU4BXnz5/Xr7/+qsaNGxc6iUdV4HQ6lZWVpfDw8Cp/PJmRLvd3SG/yPrapudHr4W1VvddL9Hsz8Fav57cHAAAAAIBJENIBAAAAADAJQjoAAAAAACZh6InjAMBoGRkZyszM9Nl4ERERioqK8tl4AABUdfR6VDSEdABVVkZGhmJbNFe2/bzPxgyxBSt95y5TNe/o6GiNHj1ao0ePNroUAAC8il5/Ab2+YiGkA6iyMjMzlW0/r38Oj1Ns/dByHy/90Fnd/9ZWZWZmmqpxAwBQWdHrURER0gFUebH1Q3VtdHWjywAAAOWEXo+KhBPHAYCJdevWTUlJSUpKSlL16tUVERGhcePGyeVySZJOnjypwYMHq2bNmgoJCdEtt9yi3bt3e6zjo48+UkJCgmw2m6Kjo/XKK68Y8VAAAEARvNXrW7durbp166pJkyb0+gqOkA4AJvfOO+/I399f69ev14wZMzRt2jTNmTNHkpSYmKiNGzdq2bJlSktLk8vlUt++feVwOCRJmzZt0r333qs77rhD27Zt08SJEzVu3DjNnz/fwEcEAAAuVtZef88992jAgAFas2aNxo8fT6+v4NjdHQBMLjIyUtOnT5fFYlHz5s21fft2TZ8+Xd26ddOyZcu0Zs0adenSRZK0cOFCRUZGaunSpbr77rs1bdo0de/eXY8//rjCw8PVokUL7dixQ1OnTlViYqKxDwwAAEgqe6+/+eab9fTTTysrK0vXXnutdu7cSa+vwPgmHQBMrnPnzrJYLO7bCQkJ2r17t3bs2CF/f3/Fx8e776tVq5aaN2+u9PR0SVJ6erquu+46j/Vdd9112r17t/Lz833zAAAAwGXR63ExQjoAAAAAACZBSAcAk1u3bp3H7e+//14xMTFq2bKl8vLyPO4/fvy4du3apZYtW0qSYmNjtWbNGo/l16xZo2bNmsnPz6/8iwcAAFdEr8fFOCYdQJWXfuisqcfJyMhQcnKyHn74YW3evFmvvfaaXnnlFcXExOi2227TsGHD9OabbyosLExjxoxRw4YNddttt0mSHn30UXXs2FFTp07VAw88oHXr1mnmzJl6/fXXvfnQAAAwtarQ65977jn17dtX27dvp9dXcIR0AFVWRESEQmzBuv+trT4bM8QWrIiIiBItM3jwYNntdnXq1El+fn4aNWqUhg8fLkmaN2+eRo0apVtvvVW5ubnq2rWrPv/8cwUEBEiSrr32Wi1ZskTjx4/X1KlTVb9+fT3zzDOcSAYAUCVUlV7//vvva/z48Xruuefo9ZUAIR1AlRUVFaX0nbuUmZnpszEjIiIUFRVVomUCAgKUkpKiN954o9B9NWvW1IIFCy67/J133qmePXsqPDxcVmvho5z27dtXonoAAKgoqlKvv/3225WVlVVkv6fXVyyEdABVWlRUVIkbKQAAqDjo9ahoOHEcAAAAAAAmwTfpAGBiq1atMroEAABQjuj1+CO+SQcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgrO7A6jSMjIylJmZ6bPxIiIiuFYrAAA+RK9HRUNIB1BlZWRkqEVsC9mz7T4b0xZi0870ncVu3t26dVNcXJxSUlLKt7BiMls9ALzHl0HG6XRKkrZt2yar1Xc7dubk5CgoKMhn4xmBgOiJXl9yZqunKiKkA6iyMjMzZc+2q+sTXVU9snq5j3d6/2mtfmm1MjMzffoGKjc312djAaiYMjIyFNuiubLt530yns1m0+LFi9W1a1fZ7b4LT1aL5HT5bDhDlDQgVnZVqdf7+xPtKgt+k2Xk691njMAnsqjsqkdWV0RMhNFlFJKYmKhvvvlG33zzjWbMmCFJ2rNnj1544QX95z//0eHDhxUVFaURI0Zo1KhRHsudOnVKHTt21KxZsxQUFKQtW7Zo7dq1SkpK0s6dO9WqVSs9/fTTuv3227VlyxbFxcVJkn788Uc9/vjj+vbbb1WtWjX16tVL06dPV0RERJH1/Prrr4qOjvb1pgHgZZmZmcq2n9c/h8cptn5ouY/ntAbqgKTVYxJkdfrmg8TNvxzTsHd3qd3gdmrUsZFPxvQ1owJiRVAVev3evXu1bt06Pfnkk/T6Co6QXgYZGRlq0SJWdnu20aWUK5stRDt3pvNiD/jYjBkz9PPPP6tVq1Z65plnJEk1a9ZUo0aN9MEHH6hWrVpau3athg8frvr16+uee+5xL5uamqrw8HCtXLlSTqdTWVlZuu2229S3b18tWrRIv/32m0aPHu0x3qlTp9S9e3f95S9/0fTp02W32/Xkk0/qnnvu0X/+858i66ldu7bPtgeA8hdbP1TXRpf/t40OBeiApLZR4QqQo9zHk6Rz2eckSaH1Qk0Z1lA1eavXS1JWVpYGDhxIr68ECOllkJmZKbs9W/EPTlB4/WijyykXWYf2ad3cSXwiCxigevXqCgwMVEhIiOrVq+eePmnSJPf/GzdurLS0NL3//vsejbtatWqaM2eOAgMD5XQ6lZKSIovForffflvBwcFq2bKlDhw4oGHDhrmXmTlzptq1a6cXXnjBPW3u3LmKjIzUzz//rGbNmhVZDwAAKB1v9XpJev3112WxWPTWW28pJCSEXl+BEdK9ILx+tK6Kam50GQCqiFmzZmnu3LnKyMiQ3W5Xbm6uexe2Aq1bt3Y3benCrnNt2rRRcHCwe1qnTp08ltm2bZu+/vprhYYW3tV17969atasmXcfCAAAKFJpev3PP/+sP/3pT/T6SoCQDgAVyJIlS/TYY4/plVdeUUJCgsLCwjR16lStW7fOY75q1aqVeN1nz55Vv3799OKLLxa6r379+qWuGQAAFB+9HoR0ADCxwMBA5efnu2+vWbNGXbp00YgRI9zT9u7de8X1NG3aVB988IHH5Yc2bNjgMc+1116rjz76SNHR0Zc8Q+wf6wEAAGXjrV7frFkz/fOf/1ROTo5sNpsken1F5bsLUwIASiw6Olrr1q3Tvn37lJmZqZiYGG3cuFErVqzQzz//rHHjxhVqwEW566675HQ6NXz4cKWnp2vFihV6+eWXJUkWi0WSNHLkSJ04cUIDBw7Uhg0btHfvXq1YsUJDhw51N+s/1lNwrWMAAFA63ur1gwYNktPp1MMPP0yvr+D4Jh1AlXd6/2nTjvPYY49pyJAhatmypex2u3bu3KktW7ZowIABslgsGjhwoEaMGKEvvvjisusJDw/Xv/71L40cOVJxcXFq3bq1xo8fr0GDBrmPXWvQoIHWrFmjJ598Ur169VJOTo6uvvpq9enTR1artch6uCwLAKAiqCq9fvHixXriiSfo9RUcIR1AlRURESFbiE2rX1rtszFtITZFRBT/0j/NmjVTWlqax7R58+Zp3rx5HtMmT57s/v/8+fOLXFeXLl20bds29+2FCxcqICDA48oNMTEx+vjjj0tUDwAAZlXVen18fLy2bNniDtz0+oqJkA6gyoqKitLO9J3KzMz02ZgRERGGXc5wwYIFatq0qRo2bKht27a5r4tacNwaAACVTVXr9UuWLFHLli0VGRlJr6/ACOkAqrSoqCjDGqmvHTlyRBMnTtThw4dVv3593X333Xr++eeNLgsAgHJV1Xr9lClT6PUVHCEdAKqIxx9/XE8++aTRZQAAgHIyatQojRs3zr27OyomfnsAAAAAAJgEIR0AAAAAAJMgpAOoMlwul9EloArj7w8Ayh+vtTCSt/7+COkAKr2AgABJUnZ2tsGVoCor+Psr+HsEAHgPvR5mkJubK0ny8/Mr03o4cRyASs/Pz081atTQ0aNHJUkhISGyWCwGV+U7TqdTubm5On/+PCeSMYDL5VJ2draOHj2qGjVqlLlxAwAKq+q9XqLfG83pdOrYsWMKCQmRv3/ZYjYhHUCVUK9ePUlyN++qxOVyyW63y2azVbk3LGZSo0YN998hAMD7qnKvl+j3ZmC1WhUVFVXm7U9IB1AlWCwW1a9fX3Xq1JHD4TC6HJ9yOBxavXq1unbtyq7WBgkICOAbdAAoZ1W510v0ezMIDAz0yl4MhHQAVYqfn1+VC0t+fn7Ky8tTcHAwTRsAUOlVxV4v0e8rEw5WAAAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkYHtJnzZql6OhoBQcHKz4+XuvXr7/s/KdOndLIkSNVv359BQUFqVmzZvr88899VC0AACgN+j0AAMVj6HXS33vvPSUnJ2v27NmKj49XSkqKevfurV27dqlOnTqF5s/NzVXPnj1Vp04dffjhh2rYsKF+++031ahRw/fFAwCAYqHfAwBQfIaG9GnTpmnYsGEaOnSoJGn27Nn67LPPNHfuXI0ZM6bQ/HPnztWJEye0du1aBQQESJKio6N9WTIAACgh+j0AAMVnWEjPzc3Vpk2bNHbsWPc0q9WqHj16KC0trchlli1bpoSEBI0cOVL/+te/VLt2bQ0aNEhPPvmk/Pz8ilwmJydHOTk57ttZWVmSJIfDIYfDUabH4HQ6ZbPZFGCV/C3OMq3LrAKsks1mk9PpLPP2Kq6CcXw1HlDZ8Zwyv8r8u6kM/b4qKHhP47QGyqGAch+vYAxfjFXA5Rcom82mQL9A+bsM/Z6q3ARYAnz+vg3mQb83t5L8Xgx7hcrMzFR+fr7q1q3rMb1u3brauXNnkcv88ssv+s9//qP77rtPn3/+ufbs2aMRI0bI4XBowoQJRS4zefJkTZo0qdD0L7/8UiEhIWV+HIsXL/7//8ss87pMqU5NDV+8WAcOHNCBAwd8OvTKlSt9Oh5Q2fGcMq/s7GyjSyg3laXfVwWLFy/WAUm+7PYra97nu8E6S4s7////51x2zoqrkTR48WBD3rfBPOj35lSSXl+hPkZ0Op2qU6eO3nrrLfn5+al9+/Y6cOCApk6desmmPXbsWCUnJ7tvZ2VlKTIyUr169VJ4eHiZ6tm2bZu6du2qmx57XTUjY8q0LrM6uX+3vn55hFavXq22bdv6ZEyHw6GVK1eqZ8+e7t0cAZQezynzK/jWFxeYrd9XBQXvaVaPSVDbqPLfXg4FaGXN+9Tz5EIFyDff+qXtOqQ+M35Ql9Fd1KRrE5+M6WvH9x7XF49/4dP3bTAP+r25laTXGxbSIyIi5OfnpyNHjnhMP3LkiOrVq1fkMvXr11dAQIDHrm6xsbE6fPiwcnNzFRgYWGiZoKAgBQUFFZoeEBBQ5j9eq9Uqu90uh1PKcxl+ovxy4XBKdrtdVqvV5092b/yOAPyO55R5VebfS2Xo91VBwXsaqzPXZ6FZkgLk8Nl4lvxc2e125ebnKs+S55Mxfc3hchj2vg3mweueOZXkd2JYsgwMDFT79u2VmprqnuZ0OpWamqqEhIQil7nuuuu0Z88eOZ2/H//9888/q379+kU2bAAAYCz6PQAAJWPo17/Jycl6++239c477yg9PV3/+7//q3PnzrnP/jp48GCPE8387//+r06cOKFRo0bp559/1meffaYXXnhBI0eONOohAACAK6DfAwBQfIYekz5gwAAdO3ZM48eP1+HDhxUXF6fly5e7Ty6TkZEhq/X3zxEiIyO1YsUKPfLII2rTpo0aNmyoUaNG6cknnzTqIQAAgCug3wMAUHyGnzguKSlJSUlJRd63atWqQtMSEhL0/fffl3NVAADAm+j3AAAUT+U82xkAAAAAABUQIR0AAAAAAJMoVUj/+uuvvV0HAAAwGfo9AAC+V6qQ3qdPH11zzTV67rnntH//fm/XBAAATIB+DwCA75UqpB84cEBJSUn68MMP1aRJE/Xu3Vvvv/++cnNzvV0fAAAwCP0eAADfK1VIj4iI0COPPKKtW7dq3bp1atasmUaMGKEGDRro73//u7Zt2+btOgEAgI/R7wEA8L0ynzju2muv1dixY5WUlKSzZ89q7ty5at++vW644Qb99NNP3qgRAAAYjH4PAIBvlDqkOxwOffjhh+rbt6+uvvpqrVixQjNnztSRI0e0Z88eXX311br77ru9WSsAAPAx+j0AAL7lX5qF/va3v2nx4sVyuVx64IEH9NJLL6lVq1bu+6tVq6aXX35ZDRo08FqhAADAt+j3AAD4XqlC+o4dO/Taa6/pjjvuUFBQUJHzREREcOkWAAAqMPo9AAC+V6rd3SdMmKC77767UMPOy8vT6tWrJUn+/v668cYby14hAAAwBP0eAADfK1VIv+mmm3TixIlC00+fPq2bbrqpzEUBAADj0e8BAPC9UoV0l8sli8VSaPrx48dVrVq1MhcFAACMR78HAMD3SnRM+h133CFJslgsSkxM9Nj9LT8/Xz/88IO6dOni3QoBAIBP0e8BADBOiUJ69erVJV34ZD0sLEw2m819X2BgoDp37qxhw4Z5t0IAAOBT9HsAAIxTopA+b948SVJ0dLQee+wxdnUDAKASot8DAGCcUl2CbcKECd6uAwAAmAz9HgAA3yt2SL/22muVmpqqmjVrql27dkWeSKbA5s2bvVIcAFRWGRkZyszM9MlYTqdTkrRt2zZZraU6X2ip5OTkXPLa2pVFRESEoqKijC7Dq+j3AAAYq9gh/bbbbnO/2erfv3951QMAlV5GRoZiWzRXtv28T8az2WxavHixunbtKrvd7pMxJclqkZwunw1nCFuITTvTd1aqoE6/BwDAWMUO6Rfv8sbubwBQepmZmcq2n9c/h8cptn5ouY/ntAbqgKTVYxJkdeaW+3iStPmXYxr27i61G9xOjTo28smYvnZ6/2mtfmm1MjMzK1VIp98DAGCsUh2TDgAou9j6obo2unq5j+NQgA5IahsVrgA5yn08STqXfU6SFFovVBExET4ZEwAAoDIodkivWbPmZY9Lu9iJEydKXRAAADAO/R4AAGMVO6SnpKSUYxkAAMAM6PcAABir2CF9yJAh5VkHAAAwAfo9AF/w5VVOjFIZrwAC3yh2SM/KylJ4eLj7/5dTMB8AAKhY6PcAyltGRoZatIiV3Z5tdCnlymYL0c6d6QR1lFiJjkk/dOiQ6tSpoxo1ahR5vJrL5ZLFYlF+fr5XiwQAAL5BvwdQ3jIzM2W3Zyv+wQkKrx9tdDnlIuvQPq2bO6nSXQEEvlHskP6f//xHV111lSTp66+/LreCAACAcej3Ravsu+amp6cbXQKqoPD60boqqrnRZQCmU+yQfuONNxb5fwAAUHnQ7wurKrvmShYdOn1eUvlfGhIAcGmlvk76yZMn9Y9//MP9yWvLli01dOhQ96fvAACg4qPfV41dc4/9ulNbF72oU9l5RpcCAFVeqUL66tWr1a9fP1WvXl0dOnSQJL366qt65pln9O9//1tdu3b1apEAAMD36PeeKvOuufZzlX0vAQCoOEoV0keOHKkBAwbojTfekJ+fnyQpPz9fI0aM0MiRI7V9+3avFgkAAHyPfg8AgO9ZS7PQnj179Oijj7obtiT5+fkpOTlZe/bs8VpxAADAOPR7AAB8r1TfpF977bVKT09X8+aeu3ylp6erbdu2XikM5uLLs746nU5J0rZt22S1lupzpBLLyclRUFCQT8YySkREBJcAAVAi9HsAAHyv2CH9hx9+cP//73//u0aNGqU9e/aoc+fOkqTvv/9es2bN0pQpU7xfJQzjyMmVJN1///0+G9Nms2nx4sXq2rWr7Ha7T8a0WiSnyydDGcYWYtPO9J0EdQCXRb8HAMBYxQ7pcXFxslgscrl+TzJPPPFEofkGDRqkAQMGeKc6GC4v78JZXp+9o5n6tq7jkzGd1kAdkLR6TIKsztxyH2/zL8c07N1daje4nRp1bFTu4xnh9P7TWv3SamVmZhLSAVwW/R4AAGMVO6T/+uuv5VkHTK5xRIiujfbNdVMdCtABSW2jwhUgR7mPdy77nCQptF6oImIiyn08ADAz+j0AAMYqdki/+uqry7MOAABgAvR7AACMVaoTxxXYsWOHMjIylJvruUvy//zP/5SpKAAAYB70ewAAfKdUIf2XX37R7bffru3bt3sct2axWCRduIYqAACo2Oj3AAD4XqmubzVq1Cg1btxYR48eVUhIiH766SetXr1aHTp00KpVq7xcIgAAMAL9HgAA3yvVN+lpaWn6z3/+o4iICFmtVlmtVl1//fWaPHmy/v73v2vLli3erhMAAPgY/R4AAN8r1Tfp+fn5CgsLkyRFRETo4MGDki6cbGbXrl3eqw4AABiGfg8AgO+V6pv0Vq1aadu2bWrcuLHi4+P10ksvKTAwUG+99ZaaNGni7RoBAIAB6PcAAPheqUL6008/rXPnLlxb+plnntGtt96qG264QbVq1dJ7773n1QIBAIAx6PcAAPheqUJ679693f9v2rSpdu7cqRMnTqhmzZruM74CAICKjX4PAIDvlek66ZK0f/9+SVJkZGSZiwEAAOZEvwcAwDdKdeK4vLw8jRs3TtWrV1d0dLSio6NVvXp1Pf3003I4HN6uEQAAGIB+DwCA75Xqm/S//e1v+vjjj/XSSy8pISFB0oXLtEycOFHHjx/XG2+84dUiAQCA79HvAQDwvVKF9EWLFmnJkiW65ZZb3NPatGmjyMhIDRw4kKYNAEAlQL8HAMD3SrW7e1BQkKKjowtNb9y4sQIDA8taEwAAMAH6PQAAvleqkJ6UlKRnn31WOTk57mk5OTl6/vnnlZSU5LXiAACAcej3AAD4XrF3d7/jjjs8bn/11Vdq1KiR2rZtK0natm2bcnNzdfPNN3u3QgAA4DP0ewAAjFXskF69enWP23feeafHbS7JAgBAxUe/BwDAWMUO6fPmzSvPOgAAgAnQ7wEAMFapjkkvcOzYMX333Xf67rvvdOzYsVKvZ9asWYqOjlZwcLDi4+O1fv36Yi23ZMkSWSwW9e/fv9RjAwCAy/NGv6fXAwBQPKUK6efOndODDz6o+vXrq2vXruratasaNGighx56SNnZ2SVa13vvvafk5GRNmDBBmzdvVtu2bdW7d28dPXr0ssvt27dPjz32mG644YbSPAQAAHAF3ur39HoAAIqvVCE9OTlZ33zzjf7973/r1KlTOnXqlP71r3/pm2++0aOPPlqidU2bNk3Dhg3T0KFD1bJlS82ePVshISGaO3fuJZfJz8/Xfffdp0mTJqlJkyaleQgAAOAKvNXv6fUAABRfsY9Jv9hHH32kDz/8UN26dXNP69u3r2w2m+655x698cYbxVpPbm6uNm3apLFjx7qnWa1W9ejRQ2lpaZdc7plnnlGdOnX00EMP6dtvv73sGDk5OR6XjsnKypIkORwOORyOYtV5KU6nUzabTQFWyd/iLNO6zCrQzyKbzSb5B8mhAJ+MWTCOr8Zz+QXKZrMp0C9Q/q5SPSVML8ASIJvNJqfTWea/e5RdwWuH0xrok79zXz+nJJ5XJWXW56U3+r0ver1Evy8rX/d7XpfKR0Xp91XhORVglc9/FwXjmPl3X5WV5PdicblcrpIOEBISok2bNik2NtZj+k8//aROnTrp3LlzxVrPwYMH1bBhQ61du1YJCQnu6U888YS++eYbrVu3rtAy3333ne69915t3bpVERERSkxM1KlTp7R06dIix5g4caImTZpUaPqiRYsUEhJSrDoBAChP2dnZGjRokE6fPq3w8HCjy3HzRr/3Ra+X6PcAAHMrSa8v1ceICQkJmjBhghYsWKDg4GBJkt1u16RJkzwasLedOXNGDzzwgN5++21FREQUa5mxY8cqOTnZfTsrK0uRkZHq1atXmd8Ibdu2TV27dtVNj72umpExZVqXWR3a9YPSXn9Ubw9to3s61vfJmA4FaGXN+9Tz5EIFqPw/CUzbdUh9ZvygLqO7qEnXyrlL5fG9x/XF419o9erV7msdwzgFrx2rxySobVT5BzJfP6cknlclVfCtr9kY0e9L0+sl+n1Z+brf87pUPipKv68Kz6mT+3fr65dH+PR34XA4tHLlSvXs2VMBAb7bSwXFU5JeX6qQnpKSoj59+qhRo0buP7pt27YpODhYK1asKPZ6IiIi5OfnpyNHjnhMP3LkiOrVq1do/r1792rfvn3q16+fe5rTeWEXGX9/f+3atUvXXHONxzJBQUEKCgoqtK6AgIAy//FarVbZ7XY5nFKeq0wnyjet3HyX7Ha7lJfjsyZaIEAOn4xpyc+V3W5Xbn6u8ix55T6eERwuh+x2u6xWKy/aJlDw2mF15vr0eeWr55TE86qkzPq89Ea/90Wvl+j3ZWVUv+d1ybsqSr+vCs8ph1OG/S688boH7yvJ76RUIb1169bavXu3Fi5cqJ07d0qSBg4cqPvuu+/C8UzFFBgYqPbt2ys1NdV9aRWn06nU1FQlJSUVmr9Fixbavn27x7Snn35aZ86c0YwZMxQZGVmahwMAAIrgjX5PrwcAoGRKHNIdDodatGihTz/9VMOGDStzAcnJyRoyZIg6dOigTp06KSUlRefOndPQoUMlSYMHD1bDhg01efJkBQcHq1WrVh7L16hRQ5IKTQcAAKXnzX5PrwcAoPhKHNIDAgJ0/vx5rxUwYMAAHTt2TOPHj9fhw4cVFxen5cuXq27dupKkjIwMWa2VczcYAADMypv9nl4PAEDxlWp395EjR+rFF1/UnDlz5O9f9ktYJCUlFbnLmyStWrXqssvOnz+/zOMDAIDCvNnv6fUAABRPqTruhg0blJqaqi+//FKtW7dWtWrVPO7/+OOPvVIcAAAwDv0eAADfK1VIr1Gjhu68805v1wIAAEyEfg8AgO+VKKQ7nU5NnTpVP//8s3Jzc9W9e3dNnDixRGd0BwAA5ka/BwDAOCU6S8vzzz+vp556SqGhoWrYsKFeffVVjRw5srxqAwAABqDfAwBgnBKF9AULFuj111/XihUrtHTpUv373//WwoUL5XQ6y6s+AADgY/R7AACMU6KQnpGRob59+7pv9+jRQxaLRQcPHvR6YQAAwBj0ewAAjFOikJ6Xl6fg4GCPaQEBAXI4HF4tCgAAGId+DwCAcUp04jiXy6XExEQFBQW5p50/f15//etfPS7LwiVZAACouOj3AAAYp0QhfciQIYWm3X///V4rBgAAGI9+DwCAcUoU0ufNm1dedQAAAJOg3wMAYJwSHZMOAAAAAADKDyEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAS/kYXAAB/lJGRoczMTKPLKDfp6elGlwAAAACTIqQDMJWMjAy1aBEruz3b6FLKmUWHTp+XVN3oQgAAAGAihHQAppKZmSm7PVvxD05QeP1oo8spF8d+3amti17Uqew8o0sBAADlyJd7zzmdTknStm3bZLX65qjmnJwcBQUF+WQso0RERCgqKsqnYxLSAZhSeP1oXRXV3OgyyoX9XGXfSwAAgKrNkZMrSbr//vt9NqbNZtPixYvVtWtX2e12n4xptUhOl0+GMowtxKad6Tt9GtQJ6QAAAADgRXl5F/aWe/aOZurbuo5PxnRaA3VA0uoxCbI6c8t9vM2/HNOwd3ep3eB2atSxUbmPZ4TT+09r9UurlZmZSUgHAAAAgIqucUSIro32zflnHArQAUlto8IVIEe5j3cu+5wkKbReqCJiIsp9vKqES7ABAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEzCFCF91qxZio6OVnBwsOLj47V+/fpLzvv222/rhhtuUM2aNVWzZk316NHjsvMDAADj0esBACgew0P6e++9p+TkZE2YMEGbN29W27Zt1bt3bx09erTI+VetWqWBAwfq66+/VlpamiIjI9WrVy8dOHDAx5UDAIDioNcDAFB8hof0adOmadiwYRo6dKhatmyp2bNnKyQkRHPnzi1y/oULF2rEiBGKi4tTixYtNGfOHDmdTqWmpvq4cgAAUBz0egAAis/fyMFzc3O1adMmjR071j3NarWqR48eSktLK9Y6srOz5XA4dNVVVxV5f05OjnJycty3s7KyJEkOh0MOh6MM1UtOp1M2m00BVsnf4izTuswq0M8im80m+QfJoQCfjFkwjq/Gc/kFymazKdAvUP4uQ58S5SbAEiCbzSan01nmv/vyxvPK+3z9nJJ4XpWU2Z+XZeGLXi/R78uK16XKoaL0e55T5YP30N5nVK+3uFwuV5lGK4ODBw+qYcOGWrt2rRISEtzTn3jiCX3zzTdat27dFdcxYsQIrVixQj/99JOCg4ML3T9x4kRNmjSp0PRFixYpJCSkbA8AAAAvyM7O1qBBg3T69GmFh4cbXY5X+aLXS/R7AIC5laTXV+iPPKZMmaIlS5Zo1apVl2zaY8eOVXJysvt2VlaW+9i2sr4R2rZtm7p27aqbHntdNSNjyrQuszq06welvf6o3h7aRvd0rO+TMR0K0Mqa96nnyYUKUPl/Cpy265D6zPhBXUZ3UZOuTcp9PCMc33tcXzz+hVavXq22bdsaXc5l8bzyPl8/pySeVyVV8K0vCitOr5fo92XF61LlUFH6Pc+p8sF7aO8zqtcbGtIjIiLk5+enI0eOeEw/cuSI6tWrd9llX375ZU2ZMkVfffWV2rRpc8n5goKCFBQUVGh6QECAAgLKtiuI1WqV3W6XwynluQw/vL9c5Oa7ZLfbpbwcnzXRAgFy+GRMS36u7Ha7cvNzlWfJK/fxjOBwOWS322W1Wsv8d1/eeF6VH189pySeVyVl9udlWfii10v0+7LidalyqCj9nudU+eI9tPcY1esNfVYEBgaqffv2HieCKTgxzMW7xP3RSy+9pGeffVbLly9Xhw4dfFEqAAAoBXo9AAAlY/ju7snJyRoyZIg6dOigTp06KSUlRefOndPQoUMlSYMHD1bDhg01efJkSdKLL76o8ePHa9GiRYqOjtbhw4clSaGhoQoNDTXscQAAgKLR6wEAKD7DQ/qAAQN07NgxjR8/XocPH1ZcXJyWL1+uunXrSpIyMjJktf7+hf8bb7yh3Nxc3XXXXR7rmTBhgiZOnOjL0gEAQDHQ6wEAKD7DQ7okJSUlKSkpqcj7Vq1a5XF737595V8QAADwKno9AADFUznP1AAAAAAAQAVESAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkAwAAAABgEqYI6bNmzVJ0dLSCg4MVHx+v9evXX3b+Dz74QC1atFBwcLBat26tzz//3EeVAgCA0qDXAwBQPIaH9Pfee0/JycmaMGGCNm/erLZt26p37946evRokfOvXbtWAwcO1EMPPaQtW7aof//+6t+/v3788UcfVw4AAIqDXg8AQPEZHtKnTZumYcOGaejQoWrZsqVmz56tkJAQzZ07t8j5Z8yYoT59+ujxxx9XbGysnn32WV177bWaOXOmjysHAADFQa8HAKD4/I0cPDc3V5s2bdLYsWPd06xWq3r06KG0tLQil0lLS1NycrLHtN69e2vp0qVFzp+Tk6OcnBz37dOnT0uSTpw4IYfDUab6s7KyFBwcrLMHfpYc9jKty6zsh39RcHCwdmXmatXPZ3wyptMaqOw/ZevbPWdldeaW+3g/HsxVcHCwsg9mK3N7ZrmPZ4Qzh84oODhYWVlZOn78uNHlXBbPK+/z9XNK4nlV4nWdufB34HK5vFGaqfii10v0+7LidalyqCj9nudU+eA9tPcZ1utdBjpw4IBLkmvt2rUe0x9//HFXp06dilwmICDAtWjRIo9ps2bNctWpU6fI+SdMmOCSxA8//PDDDz+m/9m/f793GqyJ+KLXu1z0e3744YcffirGT3F6vaHfpPvC2LFjPT6NdzqdOnHihGrVqiWLxWJgZbiUrKwsRUZGav/+/QoPDze6HKDC4zllfi6XS2fOnFGDBg2MLqXCot9XLLwuAd7H88rcStLrDQ3pERER8vPz05EjRzymHzlyRPXq1StymXr16pVo/qCgIAUFBXlMq1GjRumLhs+Eh4fzAgN4Ec8pc6tevbrRJZQLX/R6iX5fUfG6BHgfzyvzKm6vN/TEcYGBgWrfvr1SU1Pd05xOp1JTU5WQkFDkMgkJCR7zS9LKlSsvOT8AADAOvR4AgJIxfHf35ORkDRkyRB06dFCnTp2UkpKic+fOaejQoZKkwYMHq2HDhpo8ebIkadSoUbrxxhv1yiuv6M9//rOWLFmijRs36q233jLyYQAAgEug1wMAUHyGh/QBAwbo2LFjGj9+vA4fPqy4uDgtX75cdevWlSRlZGTIav39C/8uXbpo0aJFevrpp/XUU08pJiZGS5cuVatWrYx6CPCyoKAgTZgwodBuiwBKh+cUjEavxx/xugR4H8+rysPiclXC670AAAAAAFABGXpMOgAAAAAA+B0hHQAAAAAAkyCkAwAAAABgEoR0AAAAAABMgpAOU5k1a5aio6MVHBys+Ph4rV+/3uiSgApt9erV6tevnxo0aCCLxaKlS5caXRIA0O8BL6LXVz6EdJjGe++9p+TkZE2YMEGbN29W27Zt1bt3bx09etTo0oAK69y5c2rbtq1mzZpldCkAIIl+D3gbvb7y4RJsMI34+Hh17NhRM2fOlCQ5nU5FRkbqb3/7m8aMGWNwdUDFZ7FY9Mknn6h///5GlwKgCqPfA+WHXl858E06TCE3N1ebNm1Sjx493NOsVqt69OihtLQ0AysDAADeQr8HgCsjpMMUMjMzlZ+fr7p163pMr1u3rg4fPmxQVQAAwJvo9wBwZYR0AAAAAABMgpAOU4iIiJCfn5+OHDniMf3IkSOqV6+eQVUBAABvot8DwJUR0mEKgYGBat++vVJTU93TnE6nUlNTlZCQYGBlAADAW+j3AHBl/kYXABRITk7WkCFD1KFDB3Xq1EkpKSk6d+6chg4danRpQIV19uxZ7dmzx337119/1datW3XVVVcpKirKwMoAVFX0e8C76PWVD5dgg6nMnDlTU6dO1eHDhxUXF6dXX31V8fHxRpcFVFirVq3STTfdVGj6kCFDNH/+fN8XBACi3wPeRK+vfAjpAAAAAACYBMekAwAAAABgEoR0AAAAAABMgpAOAAAAAIBJENIBAAAAADAJQjoAAAAAACZBSAcAAAAAwCQI6QAAAAAAmAQhHQAAAAAAkyCkA5VIt27dNHr06EveHx0drZSUFJ/VAwAAvIteD1R+hHSgCtmwYYOGDx9udBlX9NNPP+nOO+9UdHS0LBYLbzYAACimitLr3377bd1www2qWbOmatasqR49emj9+vVGlwWYAiEdqEJq166tkJCQch0jNze3zOvIzs5WkyZNNGXKFNWrV88LVQEAUDVUlF6/atUqDRw4UF9//bXS0tIUGRmpXr166cCBA16oEKjYCOlAJZOXl6ekpCRVr15dERERGjdunFwul6TCu8BZLBbNmTNHt99+u0JCQhQTE6Nly5a578/Pz9dDDz2kxo0by2azqXnz5poxY4bHeImJierfv7+ef/55NWjQQM2bN9czzzyjVq1aFaotLi5O48aNu+Jj6Nixo6ZOnap7771XQUFBpdwSAABUTpWh1y9cuFAjRoxQXFycWrRooTlz5sjpdCo1NbWUWwWoPAjpQCXzzjvvyN/fX+vXr9eMGTM0bdo0zZkz55LzT5o0Sffcc49++OEH9e3bV/fdd59OnDghSXI6nWrUqJE++OAD7dixQ+PHj9dTTz2l999/32Mdqamp2rVrl1auXKlPP/1UDz74oNLT07Vhwwb3PFu2bNEPP/ygoUOHls8DBwCgiqiMvT47O1sOh0NXXXVViZcFKht/owsA4F2RkZGaPn26LBaLmjdvru3bt2v69OkaNmxYkfMnJiZq4MCBkqQXXnhBr776qtavX68+ffooICBAkyZNcs/buHFjpaWl6f3339c999zjnl6tWjXNmTNHgYGB7mm9e/fWvHnz1LFjR0nSvHnzdOONN6pJkybl8bABAKgyKmOvf/LJJ9WgQQP16NGjxMsClQ3fpAOVTOfOnWWxWNy3ExIStHv3buXn5xc5f5s2bdz/r1atmsLDw3X06FH3tFmzZql9+/aqXbu2QkND9dZbbykjI8NjHa1bt/Zo2pI0bNgwLV68WOfPn1dubq4WLVqkBx980BsPEQCAKq2y9fopU6ZoyZIl+uSTTxQcHFzi5YHKhm/SgSouICDA47bFYpHT6ZQkLVmyRI899pheeeUVJSQkKCwsTFOnTtW6des8lqlWrVqh9fbr109BQUH65JNPFBgYKIfDobvuuqv8HggAACiSmXv9yy+/rClTpuirr77y+DABqMoI6UAl88em+v333ysmJkZ+fn4lXteaNWvUpUsXjRgxwj1t7969xVrW399fQ4YM0bx58xQYGKh7771XNputxDUAAABPlaXXv/TSS3r++ee1YsUKdejQocS1A5UVIR2oZDIyMpScnKyHH35Ymzdv1muvvaZXXnmlVOuKiYnRggULtGLFCjVu3FjvvvuuNmzYoMaNGxdr+b/85S+KjY2VdOFNQHHl5uZqx44d7v8fOHBAW7duVWhoqJo2bVryBwIAQCVSGXr9iy++qPHjx2vRokWKjo7W4cOHJUmhoaEKDQ0t+QMBKhFCOlDJDB48WHa7XZ06dZKfn59GjRql4cOHl2pdDz/8sLZs2aIBAwbIYrFo4MCBGjFihL744otiLR8TE6MuXbroxIkTio+PL/a4Bw8eVLt27dy3X375Zb388su68cYbtWrVqpI+DAAAKpXK0OvfeOMN5ebmFto9fsKECZo4cWJJHgJQ6VhcBRdVBAAvc7lciomJ0YgRI5ScnGx0OQAAwMvo9YD38U06gHJx7NgxLVmyRIcPH+ba6AAAVEL0eqB8ENIBlIs6deooIiJCb731lmrWrOlx3+WONfviiy90ww03lHd5AACgjOj1QPlgd3cAPrdnz55L3tewYUPOAg8AQAVHrwdKj5AOAAAAAIBJWI0uAAAAAAAAXEBIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAShHQAAAAAAEyCkA4AAAAAgEkQ0gEAAAAAMAlCOgAAAAAAJkFIBwAAAADAJAjpAAAAAACYBCEdAAAAAACTIKQDAAAAAGAS/kYX4GtOp1MHDx5UWFiYLBaL0eUAACCXy6UzZ86oQYMGslr5/BwAgKqsyoX0gwcPKjIy0ugyAAAoZP/+/WrUqJHRZQAAAANVuZAeFhYm6cIbofDwcIOrQVEcDoe+/PJL9erVSwEBAUaXA1R4PKfMLysrS5GRke4eBQAAqq4qF9ILdnEPDw8npJuUw+FQSEiIwsPDCRSAF/Ccqjg4DAsAAHDgGwAAAAAAJkFIBwAAAADAJAjpAAAAAACYRJU7Jr248vPz5XA4jC6jSnI4HPL399f58+eVn59vdDk+FRAQID8/P6PLAAAAAGAQQvofuFwuHT58WKdOnTK6lCrL5XKpXr162r9/f5U8iVKNGjVUr169KvnYAQAAgKqOkP4HBQG9Tp06CgkJISgZwOl06uzZswoNDZXVWnWOyHC5XMrOztbRo0clSfXr1ze4IgAAAAC+Rki/SH5+vjug16pVy+hyqiyn06nc3FwFBwdXqZAuSTabTZJ09OhR1alTh13fAQAAgCqmaiWgKyg4Bj0kJMTgSlCVFfz9cU4EAAAAoOohpBeBXdxhJP7+AAAAgKqLkA4AAAAAgEkQ0uE13bp10+jRo8u8nu7du2vs2LFlLwgAAAAAKhhOHAfDrFq1SjfddJNOnjypGjVquKd/+OGHstvtxhUGAAAAAAbhm3SYzlVXXaWwsDCjywAAAAAAnyOkVwLdunVTUlKSkpKSVL16dUVERGjcuHFyuVySpJMnT2rw4MGqWbOmQkJCdMstt2j37t3u5efPn68aNWpo6dKliomJUXBwsHr37q39+/e750lMTFT//v09xh09erS6det2ybreffdddejQQWFhYapXr54GDRrkvgb4vn37dNNNN0mSatasKYvFosTEREmFd3cvbv0rVqxQbGysQkND1adPHx06dKhU2xMAAAAAjEJIryTeeecd+fv7a/369ZoxY4amTZumOXPmSLoQsDdu3Khly5YpLS1NLpdLffv29bjEV3Z2tp5//nktWLBAa9as0alTp3TvvfeWqSaHw6Fnn31W27Zt09KlS7Vv3z53EI+MjNRHH30kSdq1a5cOHTqkGTNmFLme4tb/8ssv691339Xq1auVkZGhxx57rEz1AwAAAICvcUx6JREZGanp06fLYrGoefPm2r59u6ZPn65u3bpp2bJlWrNmjbp06SJJWrhwoSIjI7V06VLdfffdki4E6pkzZyo+Pl7ShdAfGxur9evXq1OnTqWq6cEHH3T/v0mTJnr11VfVsWNHnT17VqGhobrqqqskSXXq1PE4Jv1iu3fvLnb9s2fP1jXXXCNJSkpK0jPPPFOqugEAAADAKHyTXkl07tzZ4/raCQkJ2r17t3bs2CF/f393+JakWrVqqXnz5kpPT3dP8/f3V8eOHd23W7RooRo1anjMU1KbNm1Sv379FBUVpbCwMN14442SpIyMjGKvIz09vVj1h4SEuAO6JNWvX9+9az0AAAAAVBSEdBSL1Wp1H+Ne4OLdzf/o3Llz6t27t8LDw7Vw4UJt2LBBn3zyiSQpNzfX6/UFBAR43LZYLIXqBQAAAACzI6RXEuvWrfO4/f333ysmJkYtW7ZUXl6ex/3Hjx/Xrl271LJlS/e0vLw8bdy40X17165dOnXqlGJjYyVJtWvXLnQitq1bt16ynp07d+r48eOaMmWKbrjhBrVo0aLQN9uBgYGSpPz8/EuuJzY2tlj1AwAAAEBlQEivJDIyMpScnKxdu3Zp8eLFeu211zRq1CjFxMTotttu07Bhw/Tdd99p27Ztuv/++9WwYUPddttt7uUDAgL0t7/9TevWrdOmTZuUmJiozp07u49H7969uzZu3KgFCxZo9+7dmjBhgn788cdL1hMVFaXAwEC99tpr+uWXX7Rs2TI9++yzHvNcffXVslgs+vTTT3Xs2DGdPXu20HqKWz8AAAAAVAaE9Epi8ODBstvt6tSpk0aOHKlRo0Zp+PDhkqR58+apffv2uvXWW5WQkCCXy6XPP//cYxfxkJAQPfnkkxo0aJCuu+46hYaG6r333nPf37t3b40bN05PPPGEOnbsqDNnzmjw4MGXrKd27dqaP3++PvjgA7Vs2VJTpkzRyy+/7DFPw4YNNWnSJI0ZM0Z169ZVUlJSkesqTv0AAAAAUBlYXFXswN2srCxVr15dp0+fVnh4uMd958+f16+//qrGjRsrODjYoApLrlu3boqLi1NKSkqplp8/f75Gjx6tU6dOebWu0nI6ncrKylJ4eLis1qr3OVJF/TuEeTkcDn3++efq27cvH26Z1OV6EwAAqFqqXgICAAAAAMCkCOkAAAAAAJiEv9EFoOxWrVpVpuUTExOVmJjolVoAAAAAAKXHN+kAAAAAAJgEIR0AAAAAAJMgpAMAAAAAYBKEdAAAAAAATIKQDgAAAACASRDSAQAAAAAwCS7BVkwZGRnKzMz02XgRERGKiory2XjFFR0drdGjR2v06NGXnCc3N1ctW7bUggUL1KVLF98VZwIWi0WffPKJ+vfvX+T9O3bsUK9evbRr1y5Vq1bNt8UBAAAAMD1CejFkZGSoRYtY2e3ZPhvTZgvRzp3ppgzqVzJ79mw1bty4Qgf0ffv2qXHjxtqyZYvi4uK8tt6WLVuqc+fOmjZtmsaNG+e19QIAAACoHAjpxZCZmSm7PVvxD05QeP3och8v69A+rZs7SZmZmRUupLtcLs2cOVPPPPNMmdeTl5enwMBAL1VmHkOHDtWwYcM0duxY+fvzFAQAAADwO45JL4Hw+tG6Kqp5uf+U5oOAbt26KSkpSUlJSapevboiIiI0btw4uVwu9zwnT57U4MGDVbNmTYWEhOiWW27R7t27Pdbz0Ucf6U9/+pOCgoIUHR2tV155pUR1bNq0SXv37tWf//xn97R9+/bJYrFoyZIl6tKli4KDg9WqVSt988037nlWrVoli8WiL774Qh07dlTdunX13Xffyel0avLkyWrcuLFsNpvatm2rDz/8sNByK1asULt27WSz2dS9e3cdPXpUX3zxhWJjYxUeHq5BgwYpO/v3PSGWL1+u66+/XjVq1FCtWrV06623au/eve77GzduLElq166dLBaLunXr5r5v7ty57m1Uv359JSUleWyDzMxM3X777QoJCVFMTIyWLVvmcX/Pnj114sQJj8cPAAAAABIhvVJ555135O/vr/Xr12vGjBmaNm2a5syZ474/MTFRGzdu1LJly5SWliaXy6W+ffvK4XBIuhCw77nnHt17773avn27Jk6cqHHjxmn+/PnFruHbb79Vs2bNFBYWVui+xx9/XI8++qi2bNmihIQE9evXT8ePH/eYZ8yYMXrhhRe0bt06tWnTRpMnT9aCBQs0e/Zs/fTTT3rkkUd0//33Fwq4EydO1MyZM7V27Vrt379f99xzj1JSUrRo0SJ99tln+vLLL/Xaa6+55z937pySk5O1ceNGpaamymq16vbbb5fT6ZQkrV+/XpL01Vdf6dChQ/r4448lSW+88YZGjhyp4cOHa/v27Vq2bJmaNm3qUcukSZN0zz336IcfflDfvn1133336cSJE+77AwMDFRcXp2+//bbY2xUAAABA1cC+tpVIZGSkpk+fLovFoubNm2v79u2aPn26hg0bpt27d2vZsmVas2aN+1jxhQsXKjIyUkuXLtXdd9+tadOm6eabb3YfK92sWTPt2LFDU6dOVWJiYrFq+O2339SgQYMi70tKStKdd94p6ULYXb58uf7xj3/oiSeecM/zzDPPqGfPnsrKylJQUJBeeOEFffXVV0pISJAkNWnSRN99953efPNN3Xjjje7lnnvuOV133XWSpIceekhjx47V3r171aRJE0nSXXfdpa+//lpPPvmkJLnrKDB37lzVrl1bO3bsUKtWrVS7dm1JUq1atVSvXj2PcR599FGNGjXKPa1jx44e60pMTNTAgQMlSS+88IJeffVVrV+/Xn369HHP06BBA/32229X3J4AAAAAqha+Sa9EOnfuLIvF4r6dkJCg3bt3Kz8/X+np6fL391d8fLz7/lq1aql58+ZKT0+XJKWnp7uDboHrrrvOvY7isNvtCg4OLvK+gqAtSf7+/urQoYN77AIdOnRw/3/Pnj3Kzs5Wz549FRoa6v5ZsGCBx67pktSmTRv3/+vWrauQkBB3QC+YdvToUfft3bt3a+DAgWrSpInCw8MVHR0t6cJJAi/l6NGjOnjwoG6++ebLbAHPWqpVq6bw8HCPsSXJZrN57H4PAAAAAJIJQvqsWbMUHR2t4OBgxcfHu3czvpSUlBQ1b95cNptNkZGReuSRR3T+/HkfVYsriYiI0MmTJ0u9/MWXJTt79qwk6bPPPtPWrVvdPzt27PA4Ll2SAgIC3P+3WCwetwumFezKLkn9+vXTiRMn9Pbbb2vdunVat26dpAuXj7sUm81WrMdwpbEl6cSJE+5v6wEAAACggKEh/b333lNycrImTJigzZs3q23bturdu3ehbx0LLFq0SGPGjNGECROUnp6uf/zjH3rvvff01FNP+bhycyoImgW+//57xcTEyM/PT7GxscrLy/OY5/jx49q1a5datmwpSYqNjdWaNWs81rFmzRo1a9ZMfn5+xaqhXbt22rlzp8cJ6y6up0BeXp42bdqk2NjYS66rZcuWCgoKUkZGhpo2berxExkZWax6ilLwuJ9++mndfPPNio2NLfTBQsFZ5S/egyAsLEzR0dFKTU0t9dgFfvzxR7Vr167M6wEAAABQuRh6TPq0adM0bNgwDR06VNKF62t/9tlnmjt3rsaMGVNo/rVr1+q6667ToEGDJEnR0dEaOHBgoXBaVWVkZCg5OVkPP/ywNm/erNdee819dvaYmBjddtttGjZsmN58802FhYVpzJgxatiwoW677TZJ0qOPPqqOHTvq2Wef1YABA5SWlqaZM2fq9ddfL3YNN910k86ePauffvpJrVq18rhv1qxZiomJUWxsrKZPn66TJ0/qwQcfvOS6wsLC9Nhjj+mRRx6R0+nU9ddfr9OnT2vNmjUKDw/XkCFDSrGVpJo1a6pWrVp66623VL9+fWVkZBT6e6tTp45sNpuWL1+uRo0aKTg4WNWrV9fEiRP117/+VXXq1NEtt9yiM2fOaM2aNfrb3/5W7PH37dunAwcOqEePHqWqHwAAAEDlZVhIz83N1aZNmzR27Fj3NKvVqh49eigtLa3IZbp06aJ//vOfWr9+vTp16qRffvlFn3/+uR544IFLjpOTk6OcnBz37aysLEmSw+Fwn9W8gMPhkMvlktPp9Ng9ueD/WQf3SYW/IPa6rEP73OP+cTfpy3nggQeUnZ2tTp06yc/PT3//+9/1l7/8xb2Of/zjHxo9erRuvfVW5ebm6oYbbtCnn34qPz8/OZ1OxcXFacmSJZo4caKeffZZ1a9fX5MmTdLgwYM96ijYRkWpWbOm+vfvr3/+85964YUX3I9DunAStSlTpmjr1q1q2rSpli5dqquuusrjcTqdTve38C6XS5MmTVJERIQmT56sX375RTVq1FC7du00duzYQstd/P+L/y1Y18XTFi1apNGjR6tVq1Zq3ry5UlJS1L17d/d6rFarUlJS9Nxzz2n8+PG64YYb9J///Me9jWfMmKHHHntMERERuvPOOwv9vfxx+1w8bdGiRerZs6ciIyOL3I4F28DhcBR7Dwbgcgpe6/74mgfz4HcDAAAKWFxF7ZfsAwcPHlTDhg21du1ajxOKPfHEE/rmm28u+e34q6++qscee0wul0t5eXn661//qjfeeOOS40ycOFGTJk0qNH3RokUKCQnxmObv76969eopMjLSvbuzJO3fv1+d4uN13m4v6cMstWCbTevXrSv2bt233nqrWrdurcmTJ5dzZVf2448/6o477tDmzZsVGhqqjIwMtW3bVqtXr1br1q2NLs9Qubm5at++vd5++2117tz5kvPs379fhw8fVl5eno8rBGCE7OxsDRo0SKdPn1Z4eLjR5QAAAANVqEuwrVq1Si+88IJef/11xcfHa8+ePRo1apSeffZZ92XD/mjs2LFKTk52387KylJkZKR69epV6I3Q+fPntX//foWGhnqcofxPf/qT0nfsUGZmZvk8sCJEREQoKiqq2PP7+/srMDDQFG/uunTpoilTpuj48eNq0KCBQkNDJf1+pvMrcblcOnPmjMLCwjzOVl8Z7NmzR0899ZR69ep1yXnOnz8vm82mrl27XvJM+ZXZf//7X3Xo0FF2e+U++73NFqKNGzeoUaNG5T6Ww+HQypUr1bNnz0InNoQ5FOzlBQAAYFhIj4iIkJ+fn44cOeIx/ciRIx7Xpb7YuHHj9MADD+gvf/mLJKl169Y6d+6chg8frv/7v/+T1Vr4PHhBQUEKCgoqND0gIKDQm9X8/HxZLBZZrdZC64qOjnZfpsusCmo3g4uPNS+oqajtWpSCXcDN9Hi8pVmzZmrWrNll57Fare4z1FfFQHXy5EmdOHFc8Q9OUHj9aKPLKRdZh/Zp3dxJOnnypBo3buyzcavq31RFwO8FAAAUMCykBwYGqn379vp/7d19XFR13v/x9wwMMGje1KQiYmiLdz8VUpKwK7RdS9drvbLaNK1UanGvkKKdXMsuBW8us7IMS9OHeWl33nW3bre6LoVcKalpoluoabm4GihaUjAyIzO/P7ycjUCX25kD83o+Hj4enO+c7/l+DpzzeMzbc873ZGdna/To0ZLOh7Ps7GylpaXV2Ke8vLxaaLvwzK6f7to3jJycHH+XcFHR0dEB//dB3bWJiNblXXv6uwwAAADAp/x6u7vdbtfEiRMVHx+vQYMGKSsrS2VlZd7Z3idMmKDIyEjvc9ajRo3SwoULdc0113hvd585c6ZGjRrFBFsAAAAAgGbPryF97NixOnnypDIyMlRUVKS4uDht3LhRHTt2lHT+lWI/vXI+Y8YMmUwmzZgxQ8eOHdOVV16pUaNGad68ef7aBQAAAAAAGo3fJ45LS0u76O3tP7+FOzg4WJmZmcrMzPRBZQAAAAAA+FbLmpULAAAAAIBmjJAOAAAAAIBBENIBAAAAADAIvz+T3lwUFhaqpKTEZ+PZbDZ17drVZ+PVRnR0tB566CE99NBD/i4FAAAAAFokQnotFBYWqnevnip3nPXZmOHWMBXsP2C4oA4AAAAAaDqE9FooKSlRueOsXpscp94RrZt8vIJvf9Tdy/eopKSE9tup+QAAKyFJREFUkA4AAAAAAYSQXge9I1prQHRbf5dRo6FDh6pv376SpFdffVUWi0X333+/5syZI5PJpO+++07p6el69913VVFRoSFDhui5555TTEyMdxtvvfWWMjIydOjQIUVEROiBBx7Qww8/7K9dAgAAAICAw8RxLcjLL7+s4OBg7dixQ4sWLdLChQu1YsUKSdKkSZP02Wef6Z133lFeXp48Ho9Gjhwpl8slSdq1a5fGjBmjO++8U/v27dOsWbM0c+ZMvfTSS37cIwAAAAAILFxJb0GioqL07LPPymQyqWfPntq3b5+effZZDR06VO+88462bt2qwYMHS5JWr16tqKgobdiwQXfccYcWLlyoX/3qV5o5c6YkqUePHvryyy+1YMECTZo0yY97BQAAAACBgyvpLch1110nk8nkXU5MTNRXX32lL7/8UsHBwUpISPB+dsUVV6hnz54qKCiQJBUUFOj666+vsr3rr79eX331lSorK32zAwAAAAAQ4AjpAAAAAAAYBCG9Bdm+fXuV5U8//VQxMTHq06ePzp07V+XzU6dO6cCBA+rTp48kqXfv3tq6dWuV/lu3blWPHj0UFBTU9MUDAAAAAAjpLUlhYaHsdrsOHDigtWvX6vnnn1d6erpiYmJ0yy23KCUlRZ988ony8/N19913KzIyUrfccosk6eGHH1Z2drbmzp2rgwcP6uWXX9bixYs1depUP+8VAAAAAAQOJo6rg4JvfzT0OBMmTJDD4dCgQYMUFBSk9PR0TZ48WZK0atUqpaen6ze/+Y2cTqeSkpL0wQcfyGKxSJIGDBig119/XRkZGZo7d64iIiI0Z84cJo0DAAAAAB8ipNeCzWZTuDVMdy/f47Mxw61hstlsdepjsViUlZWlpUuXVvusffv2euWVVy7Z//bbb9ftt99+0c+PHDlSp3oAAAAAAHVDSK+Frl27qmD/AZWUlPhsTJvNpq5du/psPAAAAACA/xHSa6lr166EZgAAAABAkyKktxA5OTn+LgEAAAAA0EDM7g4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACD4BVstVRYWKiSkhKfjWez2XgvOwAAAAAEGEJ6LRQWFqpX715ylDt8NqY13Kr9BftrHdSHDh2quLg4ZWVlNW1htWS0egAAAACgOSCk10JJSYkc5Q4lTUtS26i2TT7emaNnlPtUrkpKSnx6Nd3pdCokJMRn4wEAAAAAquKZ9DpoG9VWthhbk/+r638ETJo0SVu2bNGiRYtkMplkMpl0+PBh3XffferWrZusVqt69uypRYsWVes3evRozZs3T507d1bPnj0lSdu2bVNcXJzCwsIUHx+vDRs2yGQyac+ePd6+f/vb3/TrX/9arVu3VseOHXXPPfd4HweoqZ4jR4406HcPAAAAAIGAK+ktwKJFi3Tw4EH17dtXc+bMkSS1b99eXbp00RtvvKErrrhC27Zt0+TJkxUREaExY8Z4+2ZnZ6tNmzbavHmzJKm0tFSjRo3SyJEjtWbNGv3973/XQw89VGW877//Xr/85S/1u9/9Ts8++6wcDoceeeQRjRkzRh999FGN9Vx55ZW++WUAAAAAQDNGSG8B2rZtq5CQEIWHh6tTp07e9tmzZ3t/7tatm/Ly8vT6669XCemtWrXSihUrvLe5L1u2TCaTSS+++KLCwsLUp08fHTt2TCkpKd4+ixcv1jXXXKPHH3/c27Zy5UpFRUXp4MGD6tGjR431AAAAAAAujZDegi1ZskQrV65UYWGhHA6HnE6n4uLiqqzTr1+/Ks+hHzhwQP3791dYWJi3bdCgQVX65Ofn6+OPP1br1q2rjXn48GH16NGjcXcEAAAAAAIEIb2FWrdunaZOnapnnnlGiYmJuuyyy7RgwQJt3769ynqtWrWq87Z//PFHjRo1Sk8++WS1zyIiIupdMwAAAAAEOkJ6CxESEqLKykrv8tatWzV48GClpqZ62w4fPvwvt9OzZ0+99tprqqioUGhoqCRp586dVdYZMGCA3nrrLUVHRys4uOZD6Of1AAAAAAD+NWZ3byGio6O1fft2HTlyRCUlJYqJidFnn32mTZs26eDBg5o5c2a1sF2T8ePHy+12a/LkySooKNCmTZv09NNPS5JMJpMkacqUKTp9+rTGjRunnTt36vDhw9q0aZOSk5O9wfzn9bjd7qbbeQAAAABoIbiSXgdnjp4x7DhTp07VxIkT1adPHzkcDu3fv1+ff/65xo4dK5PJpHHjxik1NVUffvjhJbfTpk0bvfvuu7r//vsVFxenfv36KSMjQ+PHj/c+p965c2dt3bpVjzzyiG6++WZVVFToqquu0ogRI2Q2m2us55tvvlF0dHSd9wsAAAAAAgkhvRZsNpus4VblPpXrszGt4VbZbLZar9+jRw/l5eVVaVu1apVWrVpVpW3+/Pnen1966aUatzV48GDl5+d7l1evXi2LxaKuXbt622JiYvT222/XqR4AAAAAwKUR0muha9eu2l+wXyUlJT4b02azVQnFvvTKK6+oe/fuioyMVH5+vvcd6Far1S/1AAAAAECgIKTXUteuXf0Wmn2tqKhIGRkZKioqUkREhO644w7NmzfP32UBAAAAQItHSEc106ZN07Rp0/xdBgAAAAAEHGZ3BwAAAADAIAjpNfB4PP4uAQGM4w8AAAAIXIT0n7BYLJKk8vJyP1eCQHbh+LtwPAIAAAAIHDyT/hNBQUFq166dTpw4IUkKDw+XyWTyc1WBx+12y+l06uzZs973rgcCj8ej8vJynThxQu3atVNQUJC/SwIAAADgY4T0n+nUqZMkeYM6fM/j8cjhcMhqtQbkf5K0a9fOexwCAAAACCyE9J8xmUyKiIhQhw4d5HK5/F1OQHK5XMrNzVVSUlLA3fJtsVi4gg4AAAAEMEL6RQQFBRGW/CQoKEjnzp1TWFhYwIV0AAAAAIEtcB74BQAAAADA4AjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAi/h/QlS5YoOjpaYWFhSkhI0I4dOy65/vfff68pU6YoIiJCoaGh6tGjhz744AMfVQsAAAAAQNMJ9ufg69evl91u17Jly5SQkKCsrCwNHz5cBw4cUIcOHaqt73Q6ddNNN6lDhw568803FRkZqb///e9q166d74sHAAAAAKCR+TWkL1y4UCkpKUpOTpYkLVu2TO+//75WrlypRx99tNr6K1eu1OnTp7Vt2zZZLBZJUnR0tC9LBgAAAACgyfgtpDudTu3atUvTp0/3tpnNZg0bNkx5eXk19nnnnXeUmJioKVOm6M9//rOuvPJKjR8/Xo888oiCgoJq7FNRUaGKigrvcmlpqSTJ5XLJ5XI14h6hsVz4u/D3CUxut1tWq1UWsxRscvu7nCZhMUtWq1Vut9snxznnlPHxtwEAABf4LaSXlJSosrJSHTt2rNLesWNH7d+/v8Y+X3/9tT766CPddddd+uCDD3To0CGlpqbK5XIpMzOzxj7z58/X7Nmzq7X/5S9/UXh4eMN3BE1m8+bN/i4BfrJ27dr/+6nEr3U0mQ7tNXntWh07dkzHjh3z2bCcU8ZVXl7u7xIAAIBB+PV297pyu93q0KGDli9frqCgIA0cOFDHjh3TggULLhrSp0+fLrvd7l0uLS1VVFSUbr75ZrVp08ZXpaMOXC6XNm/erJtuusn7WAMCR35+vpKSknTj1BfUPirG3+U0ie+OfqWPn05Vbm6uYmNjm3w8zinju3CXFwAAgN9Cus1mU1BQkIqLi6u0FxcXq1OnTjX2iYiIkMViqXJre+/evVVUVCSn06mQkJBqfUJDQxUaGlqt3WKx8GXV4PgbBSaz2SyHwyGXWzrn8fsLKJqEyy05HA6ZzWafHuOcU8bF3wUAAFzgt2/AISEhGjhwoLKzs71tbrdb2dnZSkxMrLHP9ddfr0OHDsnt/udzqgcPHlRERESNAR0AAAAAgObEr5ep7Ha7XnzxRb388ssqKCjQ/fffr7KyMu9s7xMmTKgysdz999+v06dPKz09XQcPHtT777+vxx9/XFOmTPHXLgAAAAAA0Gj8+kz62LFjdfLkSWVkZKioqEhxcXHauHGjdzK5wsJCmc3//H+EqKgobdq0SX/4wx/Uv39/RUZGKj09XY888oi/dgEAAAAAgEbj94nj0tLSlJaWVuNnOTk51doSExP16aefNnFVAAAAAAD4XsuclQkAAAAAgGaoXiH9448/buw6AAAAAAAIePUK6SNGjNDVV1+t//7v/9bRo0cbuyYAAAAAAAJSvUL6sWPHlJaWpjfffFPdu3fX8OHD9frrr8vpdDZ2fQAAAAAABIx6hXSbzaY//OEP2rNnj7Zv364ePXooNTVVnTt31oMPPqj8/PzGrhMAAAAAgBavwRPHDRgwQNOnT1daWpp+/PFHrVy5UgMHDtQNN9ygL774ojFqBAAAAAAgINQ7pLtcLr355psaOXKkrrrqKm3atEmLFy9WcXGxDh06pKuuukp33HFHY9YKAAAAAECLVq/3pD/wwANau3atPB6P7rnnHj311FPq27ev9/NWrVrp6aefVufOnRutUAAAAAAAWrp6hfQvv/xSzz//vG677TaFhobWuI7NZuNVbQAAAAAA1EG9bnfPzMzUHXfcUS2gnzt3Trm5uZKk4OBgDRkypOEVAgAAAAAQIOoV0m+88UadPn26WvuZM2d04403NrgoAAAAAAACUb1CusfjkclkqtZ+6tQptWrVqsFFAQAAAAAQiOr0TPptt90mSTKZTJo0aVKV290rKyu1d+9eDR48uHErBAAAAAAgQNQppLdt21bS+Svpl112maxWq/ezkJAQXXfddUpJSWncCgEAAAAACBB1CumrVq2SJEVHR2vq1Knc2g4AAAAAQCOq1yvYMjMzG7sOAAAAAAACXq1D+oABA5Sdna327dvrmmuuqXHiuAt2797dKMUBAAAAABBIah3Sb7nlFu9EcaNHj26qegAAAAAACFi1Duk/vcWd290BAAAAAGh89XpPOgAAAAAAaHy1vpLevn37Sz6H/lOnT5+ud0EAAAAAAASqWof0rKysJiwDAAAAAADUOqRPnDixKeuAgRUWFqqkpMRn47ndbklSfn6+zGbfPJFRUVHhnRixpbLZbOratau/ywAAAABwCbUO6aWlpWrTpo3350u5sB6av8LCQvXu1VPljrM+G9NqtWrt2rVKSkqSw+HwyZhmk+T2+GQov7GGW7W/YD9BHQAAADCwOj2T/u2336pDhw5q165djc+nezwemUwmVVZWNmqR8J+SkhKVO87qtclx6h3R2idjus0hOiYp99FEmd3OJh9v99cnlfLqAV0z4Rp1ubZLk4/nD2eOnlHuU7kqKSkhpAMAAAAGVuuQ/tFHH+nyyy+XJH388cdNVhCMqXdEaw2IbuuTsVyy6Jik2K5tZJGryccrKy+TJLXu1Fq2GFuTjwcAAAAAF1PrkD5kyJAafwYA1E9BQYFPxvHHPA8Scz0AAADUR61D+s999913+p//+R/vl8w+ffooOTnZe7UdAFAzV8X5xzjuvvtun4znj3keJOZ6AAAAqI96hfTc3FyNGjVKbdu2VXx8vCTpueee05w5c/Tuu+8qKSmpUYsEgJbk3LlzkqS5t/XQyH4dmnw8X8/zIDHXAwAAQH3VK6RPmTJFY8eO1dKlSxUUFCRJqqysVGpqqqZMmaJ9+/Y1apEA0BJ1s4X7ZK4HX8/zIDHXAwAAQH3V6+HEQ4cO6eGHH/YGdEkKCgqS3W7XoUOHGq04AAAAAAACSb1C+oABA2qc8KigoECxsbENLgoAAAAAgEBU69vd9+7d6/35wQcfVHp6ug4dOqTrrrtOkvTpp59qyZIleuKJJxq/SgAAAAAAAkCtQ3pcXJxMJpM8nn9O1Ttt2rRq640fP15jx45tnOoAAAAAAAggtQ7p33zzTVPWAQAAAABAwKt1SL/qqquasg4AAAAAAAJevV7BdsGXX36pwsJCOZ1V37v7H//xHw0qCgAAAACAQFSvkP7111/r1ltv1b59+6o8p24ymSSdf2c6AAAAAACom3q9gi09PV3dunXTiRMnFB4eri+++EK5ubmKj49XTk5OI5cIAAAAAEBgqNeV9Ly8PH300Uey2Wwym80ym836t3/7N82fP18PPvigPv/888auEwAAAACAFq9eV9IrKyt12WWXSZJsNpuOHz8u6fzkcgcOHGi86gAAAAAACCD1upLet29f5efnq1u3bkpISNBTTz2lkJAQLV++XN27d2/sGgEAAAAACAj1CukzZsxQWVmZJGnOnDn6zW9+oxtuuEFXXHGF1q9f36gFAgAAAAAQKOoV0ocPH+79+Re/+IX279+v06dPq3379t4Z3gEAAAAAQN006D3pknT06FFJUlRUVIOLAQAAAAAgkNVr4rhz585p5syZatu2raKjoxUdHa22bdtqxowZcrlcjV0jAAAAAAABoV5X0h944AG9/fbbeuqpp5SYmCjp/GvZZs2apVOnTmnp0qWNWiQAAAAAAIGgXiF9zZo1WrdunX7961972/r376+oqCiNGzeOkA4AAAAAQD3U63b30NBQRUdHV2vv1q2bQkJCGloTAAAAAAABqV4hPS0tTXPnzlVFRYW3raKiQvPmzVNaWlqjFQcAAAAAQCCp9e3ut912W5Xlv/71r+rSpYtiY2MlSfn5+XI6nfrVr37VuBUCAAAAABAgah3S27ZtW2X59ttvr7LMK9gAAAAAAGiYWof0VatWNWUdAAAAAAAEvHo9k37ByZMn9cknn+iTTz7RyZMn672dJUuWKDo6WmFhYUpISNCOHTtq1W/dunUymUwaPXp0vccGAAAAAMAo6hXSy8rKdO+99yoiIkJJSUlKSkpS586ddd9996m8vLxO21q/fr3sdrsyMzO1e/duxcbGavjw4Tpx4sQl+x05ckRTp07VDTfcUJ9dAAAAAADAcOoV0u12u7Zs2aJ3331X33//vb7//nv9+c9/1pYtW/Twww/XaVsLFy5USkqKkpOT1adPHy1btkzh4eFauXLlRftUVlbqrrvu0uzZs9W9e/f67AIAAAAAAIZT62fSf+qtt97Sm2++qaFDh3rbRo4cKavVqjFjxmjp0qW12o7T6dSuXbs0ffp0b5vZbNawYcOUl5d30X5z5sxRhw4ddN999+l///d/LzlGRUVFlVfFlZaWSpJcLpdcLlet6gxkbrdbVqtVbnOIXLL4ZMwL4/hqPE9QiKxWq0KCQhTsqdcpYXgWk+X839HtNvxxf+GYs5ilYJPb3+U0iZAgk6xWqxQc6pPj3NfnlMR5VVdGPy8BAIDvmDwej6euncLDw7Vr1y717t27SvsXX3yhQYMGqaysrFbbOX78uCIjI7Vt2zYlJiZ626dNm6YtW7Zo+/bt1fp88sknuvPOO7Vnzx7ZbDZNmjRJ33//vTZs2FDjGLNmzdLs2bOrta9Zs0bh4eG1qhMAgKZUXl6u8ePH68yZM2rTpo2/ywEAAH5Ur8sbiYmJyszM1CuvvKKwsDBJksPh0OzZs6uE7cb2ww8/6J577tGLL74om81Wqz7Tp0+X3W73LpeWlioqKko333wzX4RqIT8/X0lJScp9NFGxXX3z+3LJos3t79JN362WRU1/dSnvwLcasWivBj80WN2TWubjE6cOn9KHf/xQubm5io2N9Xc5l3ThmLtx6gtqHxXj73KaxLcH9irvhYf1YnJ/jbk2osnH8/U5JXFe1dWFu7wAAADqFdKzsrI0YsQIdenSxfvFJD8/X2FhYdq0aVOtt2Oz2RQUFKTi4uIq7cXFxerUqVO19Q8fPqwjR45o1KhR3ja3+/ztsMHBwTpw4ICuvvrqKn1CQ0MVGhpabVsWi0UWi+9u/WyuzGazHA6HzG6nz77cX2CRyydjmiqdcjgcclY6dc50rsnH8weXx3X+72g2G/64v3DMudzSOU+DXkBhWM5KjxwOh3Suwqfnla/OKYnzqq6Mfl4CAADfqVdI79evn7766iutXr1a+/fvlySNGzdOd9111/nnLGspJCREAwcOVHZ2tvc1am63W9nZ2UpLS6u2fq9evbRv374qbTNmzNAPP/ygRYsWKSoqqj67AwAAAACAIdQ5pLtcLvXq1UvvvfeeUlJSGlyA3W7XxIkTFR8fr0GDBikrK0tlZWVKTk6WJE2YMEGRkZGaP3++wsLC1Ldv3yr927VrJ0nV2gEAAAAAaG7qHNItFovOnj3baAWMHTtWJ0+eVEZGhoqKihQXF6eNGzeqY8eOkqTCwkKZzS3zllcAAAAAAH6qXre7T5kyRU8++aRWrFih4OCGv1onLS2txtvbJSknJ+eSfV966aUGjw8AAAAAgBHUK2Hv3LlT2dnZ+stf/qJ+/fqpVatWVT5/++23G6U4AAAAAAACSb1Cert27XT77bc3di0AAAAAAAS0OoV0t9utBQsW6ODBg3I6nfrlL3+pWbNm1WlGdwAAAAAAULM6zcg2b948PfbYY2rdurUiIyP13HPPacqUKU1VGwAAAAAAAaVOIf2VV17RCy+8oE2bNmnDhg169913tXr1arnd7qaqDwAAAACAgFGnkF5YWKiRI0d6l4cNGyaTyaTjx483emEAAAAAAASaOoX0c+fOKSwsrEqbxWKRy+Vq1KIAAAAAAAhEdZo4zuPxaNKkSQoNDfW2nT17Vv/5n/9Z5TVsvIINAAAAAIC6q1NInzhxYrW2u+++u9GKAQAAAAAgkNUppK9ataqp6gAAAAAAIODV6Zl0AAAAAADQdAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDIKQDAAAAAGAQhHQAAAAAAAyCkA4AAAAAgEEQ0gEAAAAAMAhCOgAAAAAABkFIBwAAAADAIAjpAAAAAAAYBCEdAAAAAACDMERIX7JkiaKjoxUWFqaEhATt2LHjouu++OKLuuGGG9S+fXu1b99ew4YNu+T6AAAAAAA0F34P6evXr5fdbldmZqZ2796t2NhYDR8+XCdOnKhx/ZycHI0bN04ff/yx8vLyFBUVpZtvvlnHjh3zceUAAAAAADSuYH8XsHDhQqWkpCg5OVmStGzZMr3//vtauXKlHn300Wrrr169usryihUr9NZbbyk7O1sTJkzwSc0/VVhYqJKSEp+P6ysFBQX+LgEAAAAAAoZfQ7rT6dSuXbs0ffp0b5vZbNawYcOUl5dXq22Ul5fL5XLp8ssvr/HziooKVVRUeJdLS0slSS6XSy6XqwHVS//4xz8UH3+tHI7yBm3H6KzWcB3/0a1+svhkPNf/jePy0XieoBBZrVaFBIUo2OP3/7dqEhaTRVarVW63u8HHfVNzu92yWq2ymKVgk9vf5TSJkCCTrFarFBzqk+Pc1+eUxHlVV0Y/LwEAgO+YPB6Px1+DHz9+XJGRkdq2bZsSExO97dOmTdOWLVu0ffv2f7mN1NRUbdq0SV988YXCwsKqfT5r1izNnj27WvuaNWsUHh7esB0AAKARlJeXa/z48Tpz5ozatGnj73IAAIAfNevLG0888YTWrVunnJycGgO6JE2fPl12u927XFpa6n2OvaFfhPLz85WUlKQbp76g9lExDdqWUX17YK/yXnhYLyb315hrI3wypksWbW5/l276brUsavqrS3kHvtWIRXs1+KHB6p7UvcnH84dTh0/pwz9+qNzcXMXGxvq7nEvivGp8vj6nJM6rurpwlxcAAIBfQ7rNZlNQUJCKi4urtBcXF6tTp06X7Pv000/riSee0F//+lf179//ouuFhoYqNDS0WrvFYpHF0rBbP81msxwOh1xu6ZzH73PwNQlnpUcOh0M6V+GzL/cXWOTyyZimSqccDoeclU6dM51r8vH8weVxyeFwyGw2N/i4b2qcV03HV+eUxHlVV0Y/LwEAgO/49RtwSEiIBg4cqOzsbG+b2+1WdnZ2ldvff+6pp57S3LlztXHjRsXHx/uiVAAAAAAAmpzfb3e32+2aOHGi4uPjNWjQIGVlZamsrMw72/uECRMUGRmp+fPnS5KefPJJZWRkaM2aNYqOjlZRUZEkqXXr1mrdurXf9gMAAAAAgIbye0gfO3asTp48qYyMDBUVFSkuLk4bN25Ux44dJZ1/xZnZ/M8L/kuXLpXT6dRvf/vbKtvJzMzUrFmzfFk6AAAAAACNyu8hXZLS0tKUlpZW42c5OTlVlo8cOdL0BQEAAAAA4Actc1YmAAAAAACaIUI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCGCOlLlixRdHS0wsLClJCQoB07dlxy/TfeeEO9evVSWFiY+vXrpw8++MBHlQIAAAAA0HT8HtLXr18vu92uzMxM7d69W7GxsRo+fLhOnDhR4/rbtm3TuHHjdN999+nzzz/X6NGjNXr0aP3tb3/zceUAAAAAADQuv4f0hQsXKiUlRcnJyerTp4+WLVum8PBwrVy5ssb1Fy1apBEjRuiPf/yjevfurblz52rAgAFavHixjysHAAAAAKBxBftzcKfTqV27dmn69OneNrPZrGHDhikvL6/GPnl5ebLb7VXahg8frg0bNtS4fkVFhSoqKrzLZ86ckSSdPn1aLperQfWXlpYqLCxMPx47KLkcDdqWUTmKvlZYWJgOlDiVc/AHn4zpNoeo/P+V638P/Siz29nk4/3tuFNhYWEqP16ukn0lTT6eP/zw7Q8KCwtTaWmpTp065e9yLonzqvH5+pySOK/qvK0fzh8HHo+nMUoDAADNmMnjx28Ex48fV2RkpLZt26bExERv+7Rp07RlyxZt3769Wp+QkBC9/PLLGjdunLfthRde0OzZs1VcXFxt/VmzZmn27NlNswMAADSio0ePqkuXLv4uAwAA+JFfr6T7wvTp06tceXe73Tp9+rSuuOIKmUwmP1aGiyktLVVUVJSOHj2qNm3a+LscoNnjnDI+j8ejH374QZ07d/Z3KQAAwM/8GtJtNpuCgoKqXQEvLi5Wp06dauzTqVOnOq0fGhqq0NDQKm3t2rWrf9HwmTZt2hAogEbEOWVsbdu29XcJAADAAPw6cVxISIgGDhyo7Oxsb5vb7VZ2dnaV299/KjExscr6krR58+aLrg8AAAAAQHPh99vd7Xa7Jk6cqPj4eA0aNEhZWVkqKytTcnKyJGnChAmKjIzU/PnzJUnp6ekaMmSInnnmGf37v/+71q1bp88++0zLly/3524AAAAAANBgfg/pY8eO1cmTJ5WRkaGioiLFxcVp48aN6tixoySpsLBQZvM/L/gPHjxYa9as0YwZM/TYY48pJiZGGzZsUN++ff21C2hkoaGhyszMrPaYAoD64ZwCAABoPvw6uzsAAAAAAPgnvz6TDgAAAAAA/omQDgAAAACAQRDSAQAAAAAwCEI6AAAAAAAGQUiHoSxZskTR0dEKCwtTQkKCduzY4e+SgGYtNzdXo0aNUufOnWUymbRhwwZ/lwQAAIBLIKTDMNavXy+73a7MzEzt3r1bsbGxGj58uE6cOOHv0oBmq6ysTLGxsVqyZIm/SwEAAEAt8Ao2GEZCQoKuvfZaLV68WJLkdrsVFRWlBx54QI8++qifqwOaP5PJpD/96U8aPXq0v0sBAADARXAlHYbgdDq1a9cuDRs2zNtmNps1bNgw5eXl+bEyAAAAAPAdQjoMoaSkRJWVlerYsWOV9o4dO6qoqMhPVQEAAACAbxHSAQAAAAAwCEI6DMFmsykoKEjFxcVV2ouLi9WpUyc/VQUAAAAAvkVIhyGEhIRo4MCBys7O9ra53W5lZ2crMTHRj5UBAAAAgO8E+7sA4AK73a6JEycqPj5egwYNUlZWlsrKypScnOzv0oBm68cff9ShQ4e8y99884327Nmjyy+/XF27dvVjZQAAAKgJr2CDoSxevFgLFixQUVGR4uLi9NxzzykhIcHfZQHNVk5Ojm688cZq7RMnTtRLL73k+4IAAABwSYR0AAAAAAAMgmfSAQAAAAAwCEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDrQgQ4cO1UMPPXTRz6Ojo5WVleWzegAAAADUDSEdCCA7d+7U5MmT/V3Gv/T2228rPj5e7dq1U6tWrRQXF6dXX33V32UBAAAATS7Y3wUA8J0rr7yyycdwOp0KCQlp0DYuv/xy/dd//Zd69eqlkJAQvffee0pOTlaHDh00fPjwRqoUAAAAMB6upAMtzLlz55SWlqa2bdvKZrNp5syZ8ng8kqrf7m4ymbRixQrdeuutCg8PV0xMjN555x3v55WVlbrvvvvUrVs3Wa1W9ezZU4sWLaoy3qRJkzR69GjNmzdPnTt3Vs+ePTVnzhz17du3Wm1xcXGaOXPmv9yHoUOH6tZbb1Xv3r119dVXKz09Xf3799cnn3xSz98KAAAA0DwQ0oEW5uWXX1ZwcLB27NihRYsWaeHChVqxYsVF1589e7bGjBmjvXv3auTIkbrrrrt0+vRpSZLb7VaXLl30xhtv6Msvv1RGRoYee+wxvf7661W2kZ2drQMHDmjz5s167733dO+996qgoEA7d+70rvP5559r7969Sk5OrtP+eDwe7/aTkpLq1BcAAABobrjdHWhhoqKi9Oyzz8pkMqlnz57at2+fnn32WaWkpNS4/qRJkzRu3DhJ0uOPP67nnntOO3bs0IgRI2SxWDR79mzvut26dVNeXp5ef/11jRkzxtveqlUrrVixospt7sOHD9eqVat07bXXSpJWrVqlIUOGqHv37rXajzNnzigyMlIVFRUKCgrSCy+8oJtuuqnOvw8AAACgOeFKOtDCXHfddTKZTN7lxMREffXVV6qsrKxx/f79+3t/btWqldq0aaMTJ05425YsWaKBAwfqyiuvVOvWrbV8+XIVFhZW2Ua/fv2qPYeekpKitWvX6uzZs3I6nVqzZo3uvffeWu/HZZddpj179mjnzp2aN2+e7Ha7cnJyat0fAAAAaI64kg4EOIvFUmXZZDLJ7XZLktatW6epU6fqmWeeUWJioi677DItWLBA27dvr9KnVatW1bY7atQohYaG6k9/+pNCQkLkcrn029/+ttZ1mc1m/eIXv5B0/ln2goICzZ8/X0OHDq3jHgIAAADNByEdaGF+HqA//fRTxcTEKCgoqM7b2rp1qwYPHqzU1FRv2+HDh2vVNzg4WBMnTtSqVasUEhKiO++8U1artc41XOB2u1VRUVHv/gAAAEBzQEgHWpjCwkLZ7Xb9/ve/1+7du/X888/rmWeeqde2YmJi9Morr2jTpk3q1q2bXn31Ve3cuVPdunWrVf/f/e536t27t6Tzgb+25s+fr/j4eF199dWqqKjQBx98oFdffVVLly6t134AAAAAzQUhHWhhJkyYIIfDoUGDBikoKEjp6emaPHlyvbb1+9//Xp9//rnGjh0rk8mkcePGKTU1VR9++GGt+sfExGjw4ME6ffq0EhISaj1uWVmZUlNT9Y9//ENWq1W9evXSa6+9prFjx9ZrPwAAAIDmwuS58AJlAGhkHo9HMTExSk1Nld1u93c5AAAAgOFxJR1Akzh58qTWrVunoqKiOr8bHQAAAAhUhHQATaJDhw6y2Wxavny52rdvX+Wz1q1bX7Tfhx9+qBtuuKGpywMAAAAMidvdAfjcoUOHLvpZZGRkg2aBBwAAAJozQjoAAAAAAAZh9ncBAAAAAADgPEI6AAAAAAAGQUgHAAAAAMAgCOkAAAAAABgEIR0AAAAAAIMgpAMAAAAAYBCEdAAAAAAADIKQDgAAAACAQfx/CYqJZk6x/XEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -2836,7 +3495,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.9.19" } }, "nbformat": 4,