From 6026dde6fcb32b71cb9a03df93d51db37196eb1d Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Wed, 16 Sep 2026 23:38:38 +0100 Subject: [PATCH 1/8] feat: implemented cluster-aware bootstrap to enable full repeated measures estimation --- CHANGELOG.md | 5 + dabest/_api.py | 16 + dabest/_dabest_object.py | 57 +++ dabest/_effsize_objects.py | 282 +++++++++++-- dabest/_modidx.py | 20 +- dabest/_stats_tools/confint_2group_diff.py | 250 ++++++++++- dabest/_stats_tools/precompile.py | 7 +- nbs/API/confint_2group_diff.ipynb | 246 ++++++++++- nbs/API/dabest_object.ipynb | 57 +++ nbs/API/effsize_objects.ipynb | 282 +++++++++++-- nbs/API/load.ipynb | 16 + nbs/API/precompile.ipynb | 7 +- nbs/tests/test_cluster_bootstrap.py | 331 +++++++++++++++ ...shared_control_and_repeated_measures.ipynb | 388 ++++++++++++++++++ 14 files changed, 1870 insertions(+), 94 deletions(-) create mode 100644 nbs/tests/test_cluster_bootstrap.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f5c9d60b..40ad8b48 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,11 @@ +## Unreleased + +### New Features +1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. + ## v2025.10.20 ### New Features diff --git a/dabest/_api.py b/dabest/_api.py index 62d0218d..d81ae521 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -25,6 +25,7 @@ def load( x1_level=None, mini_meta=False, ps_adjust=False, + cluster_col=None, ): """ Loads data in preparation for estimation statistics. @@ -88,6 +89,20 @@ def load( ps_adjust : boolean, default False Indicator of whether to adjust calculated p-value according to Phipson & Smyth (2010) # https://doi.org/10.2202/1544-6115.1585 + cluster_col : string, default None + Name of the column identifying the independent sampling unit (cluster) + that each observation belongs to, for example a participant who + contributes several observations, or several pairs of paired + observations. When supplied, the bootstrap resamples whole clusters + with replacement (a cluster bootstrap) and the permutation test + reshuffles labels at the cluster level, so that the confidence + intervals and permutation p-values account for the correlation between + observations from the same cluster. This works with both unpaired data + and paired data (`paired` with `id_col`): for paired data, `id_col` + identifies the pairs and `cluster_col` the units the pairs are nested + in, and every pair must belong to a single cluster. The parametric and + rank-based tests reported in `statistical_tests` do not account for + clustering. Returns ------- @@ -112,6 +127,7 @@ def load( x1_level, mini_meta, ps_adjust, + cluster_col=cluster_col, ) # %% ../nbs/API/load.ipynb #570ff65a diff --git a/dabest/_dabest_object.py b/dabest/_dabest_object.py index 3153ed61..29bc42d4 100644 --- a/dabest/_dabest_object.py +++ b/dabest/_dabest_object.py @@ -41,6 +41,7 @@ def __init__( x1_level, mini_meta, ps_adjust, + cluster_col=None, ): """ Parses and stores pandas DataFrames in preparation for estimation @@ -60,6 +61,7 @@ def __init__( self.__is_proportional = proportional self.__is_mini_meta = mini_meta self.__ps_adjust = ps_adjust + self.__cluster_col = cluster_col # after this call the attributes self.__experiment_label and self.__x1_level are updated self._check_errors(x, y, idx, experiment, experiment_label, x1_level) @@ -128,6 +130,11 @@ def __repr__(self): resamples_line2 = "will be used to generate the effect size bootstraps." out.append(resamples_line1 + resamples_line2) + if self.__cluster_col is not None: + cluster_line1 = "Whole clusters, as defined by `{}`, ".format(self.__cluster_col) + cluster_line2 = "will be resampled by the bootstrap and reshuffled by the permutation test." + out.append(cluster_line1 + cluster_line2) + return "\n".join(out) @@ -341,6 +348,15 @@ def id_col(self): """ return self.__id_col + @property + def cluster_col(self): + """ + Returns the cluster column declared to `dabest.load()`, if any. + When set, the bootstrap resamples whole clusters of observations and + the permutation test reshuffles labels at the cluster level. + """ + return self.__cluster_col + @property def ci(self): """ @@ -582,6 +598,23 @@ def _check_errors(self, x, y, idx, experiment, experiment_label, x1_level): if self.__id_col not in self.__output_data.columns: err = "`id_col` was given as '{}'; however, '{}' is not a column in `data`.".format(self.__id_col, self.__id_col) raise IndexError(err) + + # Check if `cluster_col` is valid + if self.__cluster_col is not None: + if self.__cluster_col not in self.__output_data.columns: + err = "`cluster_col` was given as '{}'; however, '{}' is not a column in `data`.".format(self.__cluster_col, self.__cluster_col) + raise IndexError(err) + + if y is not None and self.__cluster_col == y: + err = "`cluster_col` cannot be the same column as `y`." + raise ValueError(err) + + if x is None and idx is not None: + # Wide format: the cluster column cannot also be one of the groups. + groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))] + if self.__cluster_col in groups: + err = "`cluster_col` ('{}') cannot also be one of the groups in `idx`.".format(self.__cluster_col) + raise ValueError(err) # Check if x and y are supplied (relevant to long format data) if x is None and y is not None: @@ -677,8 +710,32 @@ def _get_plot_data(self, x, y, all_plot_groups): plot_data[self.__xvar], categories=all_plot_groups, ordered=True ) + if self.__cluster_col is not None: + self._check_clusters(plot_data) + return plot_data + def _check_clusters(self, plot_data): + """ + Check that the cluster labels are complete and, for paired data, + consistent within each `id_col` value. + """ + clusters = plot_data[self.__cluster_col] + if clusters.isnull().any(): + err1 = "`cluster_col` ('{}') contains missing values.".format(self.__cluster_col) + err2 = " Every observation must belong to a cluster." + raise ValueError(err1 + err2) + + if self.__is_paired: + clusters_per_id = plot_data.groupby(self.__id_col, observed=True)[self.__cluster_col].nunique() + inconsistent = clusters_per_id.index[clusters_per_id > 1].tolist() + if inconsistent: + err1 = "Each value of `id_col` must belong to a single cluster in `cluster_col`," + err2 = " but the following values of '{}' have more than one cluster label: {}.".format( + self.__id_col, inconsistent[:10] + ) + raise ValueError(err1 + err2) + def _compute_effectsize_dfs(self): ''' Function to compute all attributes based on EffectSizeDataFrame. diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 0671958c..8ed64a4f 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -59,6 +59,16 @@ class TwoGroupsEffectSize(object): ps_adjust : boolean, default False. If True, adjust calculated p-value according to Phipson & Smyth (2010) # https://doi.org/10.2202/1544-6115.1585 + control_clusters : array-like, default None + test_clusters : array-like, default None + The cluster (e.g. participant) that each observation in `control` + and `test` belongs to. When supplied, the bootstrap resamples whole + clusters with replacement and the permutation test reshuffles + labels at the cluster level, so that the confidence interval and + permutation p-value account for the correlation between + observations from the same cluster. A label present in both + arrays denotes the same cluster. For paired data the two arrays + must be identical, since observations are paired by position. Returns @@ -98,6 +108,8 @@ def __init__( permutation_count=5000, random_seed=12345, ps_adjust=False, + control_clusters=None, + test_clusters=None, ): from ._stats_tools import confint_2group_diff as ci2g from ._stats_tools import effsize as es @@ -118,7 +130,8 @@ def __init__( self.__ci = ci self.__is_proportional = proportional self.__ps_adjust = ps_adjust - self._check_errors(control, test) + self.__is_clustered = control_clusters is not None or test_clusters is not None + self._check_errors(control, test, control_clusters, test_clusters) # Convert to numpy arrays for speed. # NaNs are automatically dropped. @@ -128,26 +141,65 @@ def __init__( self.__test = test[~isnan(test)] self.__permutation_count = permutation_count + if self.__is_clustered: + # Keep the cluster labels aligned with the NaN-filtered observations. + self.__control_clusters = array(control_clusters)[~isnan(control)] + self.__test_clusters = array(test_clusters)[~isnan(test)] + (control_codes, test_codes), self.__n_clusters = ci2g.cluster_codes( + self.__control_clusters, self.__test_clusters + ) + if self.__is_paired and not np.array_equal(control_codes, test_codes): + err1 = "In a paired analysis every control observation must belong to the same " + err2 = "cluster as the test observation it is paired with. Check that the data " + err3 = "are sorted so that paired rows are aligned, and that each pair has a single cluster label." + raise ValueError(err1 + err2 + err3) + else: + self.__control_clusters = None + self.__test_clusters = None + self.__n_clusters = None + self.__alpha = ci2g._compute_alpha_from_ci(self.__ci) self.__difference = es.two_group_difference( self.__control, self.__test, self.__is_paired, self.__effect_size ) - self.__jackknives = ci2g.compute_meandiff_jackknife( - self.__control, self.__test, self.__is_paired, self.__effect_size - ) + if self.__is_clustered: + self.__jackknives = ci2g.compute_cluster_jackknife( + self.__control, + self.__test, + self.__control_clusters, + self.__test_clusters, + self.__is_paired, + self.__effect_size, + ) + else: + self.__jackknives = ci2g.compute_meandiff_jackknife( + self.__control, self.__test, self.__is_paired, self.__effect_size + ) self.__acceleration_value = ci2g._calc_accel(self.__jackknives) - bootstraps = ci2g.compute_bootstrapped_diff( - self.__control, - self.__test, - self.__is_paired, - self.__effect_size, - self.__resamples, - self.__random_seed, - ) + if self.__is_clustered: + bootstraps = ci2g.compute_cluster_bootstrapped_diff( + self.__control, + self.__test, + self.__control_clusters, + self.__test_clusters, + self.__is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) + else: + bootstraps = ci2g.compute_bootstrapped_diff( + self.__control, + self.__test, + self.__is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) self.__bootstraps = bootstraps sorted_bootstraps = npsort(self.__bootstraps) @@ -223,13 +275,21 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): pval_rounded = base_string_fmt.format(self.pvalue_permutation) - p1 = "The p-value of the two-sided permutation t-test is {}, ".format( - pval_rounded - ) + if self.__is_clustered: + p1 = "The p-value of the two-sided cluster-level permutation test is {}, ".format( + pval_rounded + ) + bs1 = "{} cluster bootstrap samples were taken, resampling {} clusters with replacement; ".format( + self.__resamples, self.__n_clusters + ) + else: + p1 = "The p-value of the two-sided permutation t-test is {}, ".format( + pval_rounded + ) + bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) p2 = "calculated for legacy purposes only. " pvalue = p1 + p2 - bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) bs2 = "the confidence interval is bias-corrected and accelerated." bs = bs1 + bs2 @@ -253,10 +313,20 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): else: return "{}\n{}".format(out, pvalue) - def _check_errors(self, control, test): + def _check_errors(self, control, test, control_clusters=None, test_clusters=None): ''' Function to check configuration errors for the given control and test data. ''' + if self.__is_clustered: + if control_clusters is None or test_clusters is None: + err1 = "Both `control_clusters` and `test_clusters` must be supplied " + err2 = "for a cluster-aware analysis." + raise ValueError(err1 + err2) + if len(control_clusters) != len(control) or len(test_clusters) != len(test): + err1 = "`control_clusters` and `test_clusters` must have the same lengths " + err2 = "as `control` and `test` respectively." + raise ValueError(err1 + err2) + kosher_es = [a for a in self.__EFFECT_SIZE_DICT.keys()] if self.__effect_size not in kosher_es: err1 = "The effect size '{}'".format(self.__effect_size) @@ -342,6 +412,8 @@ def _perform_statistical_test(self): self.__is_paired, self.__permutation_count, ps_adjust = self.__ps_adjust, + control_clusters=self.__control_clusters, + test_clusters=self.__test_clusters, ) if self.__is_paired and not self.__is_proportional: @@ -462,20 +534,41 @@ def _get_bootstrap_baseline_ec(self): ) self.__bec_difference = difference - jackknives = ci2g.compute_meandiff_jackknife( - self.__control, self.__control, is_paired, self.__effect_size - ) + if self.__is_clustered: + # The two copies of the control group are resampled independently, + # so the clusters of the second copy are given distinct labels. + (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters) + codes_copy = codes + n_clusters + jackknives = ci2g.compute_cluster_jackknife( + self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size + ) + else: + jackknives = ci2g.compute_meandiff_jackknife( + self.__control, self.__control, is_paired, self.__effect_size + ) acceleration_value = ci2g._calc_accel(jackknives) - bootstraps = ci2g.compute_bootstrapped_diff( - self.__control, - self.__control, - is_paired, - self.__effect_size, - self.__resamples, - self.__random_seed, - ) + if self.__is_clustered: + bootstraps = ci2g.compute_cluster_bootstrapped_diff( + self.__control, + self.__control, + codes, + codes_copy, + is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) + else: + bootstraps = ci2g.compute_bootstrapped_diff( + self.__control, + self.__control, + is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) self.__bootstraps_baseline_ec = bootstraps sorted_bootstraps = npsort(self.__bootstraps_baseline_ec) @@ -558,6 +651,22 @@ def is_paired(self): def is_proportional(self): return self.__is_proportional + @property + def is_clustered(self): + """ + Whether whole clusters of observations, rather than individual + observations, were resampled by the bootstrap and permutation test. + """ + return self.__is_clustered + + @property + def n_clusters(self): + """ + The number of distinct clusters resampled by the cluster bootstrap; + None if the observations are not clustered. + """ + return self.__n_clusters + @property def ci(self): """ @@ -876,8 +985,17 @@ def __pre_calc(self): reprs = [] grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)} + + # The cluster label of every observation, for a cluster-aware analysis. + cluster_col = getattr(self.__dabest_obj, "cluster_col", None) + if cluster_col is not None: + grouped_clusters = {name: group[cluster_col].to_numpy() for name, group in dat.groupby(xvar, observed=False)} + else: + grouped_clusters = {name: None for name in grouped_data} + if self.__delta2: mixed_data = [] + mixed_clusters = [] for j, current_tuple in enumerate(idx): if self.__is_paired != "sequential": cname = current_tuple[0] @@ -890,6 +1008,8 @@ def __pre_calc(self): test = grouped_data[tname] mixed_data.append(control) mixed_data.append(test) + mixed_clusters.append(grouped_clusters[cname]) + mixed_clusters.append(grouped_clusters[tname]) bootstraps_delta_delta = ci2g.compute_delta2_bootstrapped_diff( mixed_data[0], mixed_data[1], @@ -899,6 +1019,7 @@ def __pre_calc(self): self.__resamples, self.__random_seed, self.__is_proportional, + clusters=mixed_clusters if cluster_col is not None else None, ) for j, current_tuple in enumerate(idx): @@ -921,7 +1042,9 @@ def __pre_calc(self): self.__resamples, self.__permutation_count, self.__random_seed, - self.__ps_adjust + self.__ps_adjust, + control_clusters=grouped_clusters[cname], + test_clusters=grouped_clusters[tname], ) r_dict = result.to_dict() r_dict["control"] = cname @@ -961,6 +1084,7 @@ def __pre_calc(self): "test", "control_N", "test_N", + "n_clusters", "effect_size", "is_paired", "difference", @@ -1683,6 +1807,15 @@ class PermutationTest: ps_adjust : bool, default False If True, the p-value is adjusted according to Phipson & Smyth (2010). # https://doi.org/10.2202/1544-6115.1585 + control_clusters : array-like, default None + test_clusters : array-like, default None + The cluster (e.g. participant) that each observation in `control` and + `test` belongs to. When supplied, labels are reshuffled at the cluster + level: for paired data, control and test are swapped for whole clusters + at a time; for unpaired data with clusters nested within groups, whole + clusters are reassigned between the groups; and for unpaired data with + clusters spanning both groups, the group labels are reshuffled within + each cluster. Returns @@ -1703,9 +1836,16 @@ def __init__(self, control: array, permutation_count:int=5000, # The number of permutations (reshuffles) to perform. random_seed:int=12345,#`random_seed` is used to seed the random number generator during bootstrap resampling. This ensures that the generated permutations are replicable. ps_adjust:bool=False, + control_clusters=None, # Cluster label of each observation in `control`; see the class docstring. + test_clusters=None, # Cluster label of each observation in `test`. **kwargs): from ._stats_tools.effsize import two_group_difference - from ._stats_tools.confint_2group_diff import calculate_group_var + from ._stats_tools.confint_2group_diff import ( + calculate_group_var, + cluster_codes, + cluster_tables, + expand_cluster_draw, + ) self.__permutation_count = permutation_count @@ -1714,6 +1854,12 @@ def __init__(self, control: array, if is_paired and len(control) != len(test): raise ValueError("The two arrays do not have the same length.") + is_clustered = control_clusters is not None or test_clusters is not None + if is_clustered and (control_clusters is None or test_clusters is None): + err1 = "Both `control_clusters` and `test_clusters` must be supplied " + err2 = "for a cluster-aware permutation test." + raise ValueError(err1 + err2) + # Initialise random number generator. # rng = random.default_rng(seed=random_seed) rng = RandomState(PCG64(random_seed)) @@ -1734,8 +1880,75 @@ def __init__(self, control: array, self.__permutations = [] self.__permutations_var = [] - for i in range(int(self.__permutation_count)): + # The number of distinct (two-sided) permutations, used by the + # Phipson & Smyth (2010) adjustment. + if is_clustered: + (control_codes, test_codes), n_clusters = cluster_codes(control_clusters, test_clusters) + if len(control_codes) != CONTROL_LEN or len(test_codes) != TEST_LEN: + err1 = "`control_clusters` and `test_clusters` must have the same lengths " + err2 = "as `control` and `test` respectively." + raise ValueError(err1 + err2) + if is_paired: + if not np.array_equal(control_codes, test_codes): + err1 = "In a paired analysis every control observation must belong to the " + err2 = "same cluster as the test observation it is paired with." + raise ValueError(err1 + err2) + # Control and test are swapped for whole clusters at a time; each + # pattern of swaps and its mirror image give the same |effect size|. + totalPermutations = 2.0 ** n_clusters / 2 + else: + bag_codes = array([*control_codes, *test_codes]) + offsets, members = cluster_tables(bag_codes, n_clusters) + cluster_sizes = offsets[1:] - offsets[:-1] + control_per_cluster = np.bincount(control_codes, minlength=n_clusters) + clusters_shared = bool( + ((control_per_cluster > 0) & (control_per_cluster < cluster_sizes)).any() + ) + + if clusters_shared: + # Clusters contribute to both groups: the group labels are + # reshuffled within each cluster. In the bag sorted by cluster, + # the first `control_per_cluster[g]` slots of cluster g are + # assigned to control. + slot = arange(len(BAG)) - repeat(offsets[:-1], cluster_sizes) + control_slot = slot < repeat(control_per_cluster, cluster_sizes) + totalPermutations = float( + np.prod([binomcoeff(n, k) for n, k in zip(cluster_sizes, control_per_cluster)]) + ) + else: + # Clusters are nested within groups: whole clusters are + # reassigned between the control and test groups. + n_control_clusters = int((control_per_cluster > 0).sum()) + if 2 * n_control_clusters == n_clusters: + totalPermutations = binomcoeff(n_clusters, n_control_clusters) / 2 + else: + totalPermutations = binomcoeff(n_clusters, n_control_clusters) + elif CONTROL_LEN == TEST_LEN: + totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) / 2 + else: + totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) + + for i in range(int(self.__permutation_count)): + if is_clustered and is_paired: + # Swap control and test for whole clusters at a time. + flip = rng.randint(0, 2, n_clusters).astype(bool)[control_codes] + control_sample = np.where(flip, test, control) + test_sample = np.where(flip, control, test) + + elif is_clustered and clusters_shared: + # Reshuffle the group labels within each cluster. + order = np.lexsort((rng.random_sample(len(BAG)), bag_codes)) + control_sample = BAG[order[control_slot]] + test_sample = BAG[order[~control_slot]] + + elif is_clustered: + # Reassign whole clusters between the control and test groups. + perm = rng.permutation(n_clusters).astype(np.int64) + control_sample = BAG[expand_cluster_draw(perm[:n_control_clusters], offsets, members)] + test_sample = BAG[expand_cluster_draw(perm[n_control_clusters:], offsets, members)] + + elif is_paired: # Select which control-test pairs to swap. random_idx = rng.choice(CONTROL_LEN, rng.randint(0, CONTROL_LEN+1), @@ -1759,7 +1972,7 @@ def __init__(self, control: array, False, effect_size) group_var = calculate_group_var(var(control_sample, ddof=1), - CONTROL_LEN, + len(control_sample), var(test_sample, ddof=1), len(test_sample)) self.__permutations.append(es) @@ -1776,11 +1989,6 @@ def __init__(self, control: array, # https://rdrr.io/cran/statmod/src/R/permp.R # (assumes two-sided test) - if CONTROL_LEN == TEST_LEN: - totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)/2 - else: - totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) - if totalPermutations <= 10e3: # use exact calculation p = arange(1, totalPermutations + 1)/totalPermutations diff --git a/dabest/_modidx.py b/dabest/_modidx.py index 96231c81..66d052d2 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -19,6 +19,8 @@ 'dabest/_stats_tools/confint_1group.py')}, 'dabest._stats_tools.confint_2group_diff': { 'dabest._stats_tools.confint_2group_diff._calc_accel': ( 'API/confint_2group_diff.html#_calc_accel', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff._check_paired_clusters': ( 'API/confint_2group_diff.html#_check_paired_clusters', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._compute_alpha_from_ci': ( 'API/confint_2group_diff.html#_compute_alpha_from_ci', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._compute_quantile': ( 'API/confint_2group_diff.html#_compute_quantile', @@ -33,8 +35,20 @@ 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.calculate_weighted_delta': ( 'API/confint_2group_diff.html#calculate_weighted_delta', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_bootstrap_draws': ( 'API/confint_2group_diff.html#cluster_bootstrap_draws', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_codes': ( 'API/confint_2group_diff.html#cluster_codes', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_strata': ( 'API/confint_2group_diff.html#cluster_strata', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_tables': ( 'API/confint_2group_diff.html#cluster_tables', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_bootstrapped_diff', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.compute_cluster_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_cluster_bootstrapped_diff', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.compute_cluster_jackknife': ( 'API/confint_2group_diff.html#compute_cluster_jackknife', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_delta2_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_delta2_bootstrapped_diff', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_interval_limits': ( 'API/confint_2group_diff.html#compute_interval_limits', @@ -48,7 +62,11 @@ 'dabest._stats_tools.confint_2group_diff.create_repeated_indexes': ( 'API/confint_2group_diff.html#create_repeated_indexes', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.delta2_bootstrap_loop': ( 'API/confint_2group_diff.html#delta2_bootstrap_loop', - 'dabest/_stats_tools/confint_2group_diff.py')}, + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.delta2_cluster_bootstrap_loop': ( 'API/confint_2group_diff.html#delta2_cluster_bootstrap_loop', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expand_cluster_draw': ( 'API/confint_2group_diff.html#expand_cluster_draw', + 'dabest/_stats_tools/confint_2group_diff.py')}, 'dabest._stats_tools.effsize': { 'dabest._stats_tools.effsize._cliffs_delta_core': ( 'API/effsize.html#_cliffs_delta_core', 'dabest/_stats_tools/effsize.py'), 'dabest._stats_tools.effsize._compute_hedges_correction_factor': ( 'API/effsize.html#_compute_hedges_correction_factor', diff --git a/dabest/_stats_tools/confint_2group_diff.py b/dabest/_stats_tools/confint_2group_diff.py index c662ea29..06667787 100644 --- a/dabest/_stats_tools/confint_2group_diff.py +++ b/dabest/_stats_tools/confint_2group_diff.py @@ -6,7 +6,9 @@ # %% auto #0 __all__ = ['create_jackknife_indexes', 'create_repeated_indexes', 'compute_meandiff_jackknife', 'bootstrap_indices', - 'compute_bootstrapped_diff', 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', + 'compute_bootstrapped_diff', 'cluster_codes', 'cluster_tables', 'cluster_strata', 'cluster_bootstrap_draws', + 'expand_cluster_draw', 'compute_cluster_jackknife', 'compute_cluster_bootstrapped_diff', + 'delta2_cluster_bootstrap_loop', 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', 'compute_meandiff_bias_correction', 'compute_interval_limits', 'calculate_group_var', 'calculate_bootstraps_var', 'calculate_weighted_delta'] @@ -162,6 +164,227 @@ def compute_bootstrapped_diff( return out +def cluster_codes(*cluster_labels): + """ + Convert cluster labels from one or more groups into contiguous integer codes. + + The labels of all groups are pooled, so that the same label appearing in + several groups (e.g. a participant measured under every condition) maps + to the same code. Codes are assigned in order of first appearance. + + Returns + ------- + codes : list of int64 numpy arrays, one per input group. + n_clusters : int + The number of distinct clusters across all groups. + """ + import pandas as pd + + arrays = [np.asarray(a) for a in cluster_labels] + joined = np.concatenate(arrays) if len(arrays) > 1 else arrays[0] + codes, uniques = pd.factorize(pd.Series(joined), sort=False) + codes = codes.astype(np.int64) + if (codes < 0).any(): + raise ValueError("Cluster labels must not contain missing values.") + + out, start = [], 0 + for a in arrays: + out.append(codes[start : start + len(a)]) + start += len(a) + return out, len(uniques) + + +def cluster_tables(codes, n_clusters): + """ + Build the membership tables used by `expand_cluster_draw`. + + Returns `(offsets, members)` such that `members[offsets[g]:offsets[g+1]]` + holds the positions (in the original array) of the observations that + belong to cluster `g`. A cluster absent from the array has an empty slice. + """ + codes = np.asarray(codes, dtype=np.int64) + members = np.argsort(codes, kind="stable").astype(np.int64) + counts = np.bincount(codes, minlength=n_clusters) + offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64) + return offsets, members + + +def cluster_strata(codes_per_group, n_clusters): + """ + Partition the clusters into resampling strata. + + Clusters are stratified by the pattern of groups in which they appear, so + that every bootstrap resample preserves the observed design. For a fully + within-cluster design (every cluster present in every group) there is a + single stratum and clusters are resampled jointly across the groups; for a + nested design (each cluster present in one group only) the clusters are + resampled separately within each group. + + Returns `(strata_clusters, strata_offsets)`: the cluster codes concatenated + stratum by stratum, and the boundaries of each stratum in that array. + """ + pattern = np.zeros(n_clusters, dtype=np.int64) + for k, codes in enumerate(codes_per_group): + present = np.zeros(n_clusters, dtype=bool) + present[np.asarray(codes, dtype=np.int64)] = True + pattern |= present.astype(np.int64) << k + + strata_clusters = np.argsort(pattern, kind="stable").astype(np.int64) + _, counts = np.unique(pattern, return_counts=True) + strata_offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64) + return strata_clusters, strata_offsets + + +@njit(cache=True) # parallelization must be turned off for random number generation +def cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed): + """ + Draw clusters with replacement, separately within each stratum + (see `cluster_strata`). + + Returns an array of shape `(resamples, n_clusters)` holding, for each + resample, the codes of the clusters drawn. + """ + np.random.seed(random_seed) + n_clusters = len(strata_clusters) + n_strata = len(strata_offsets) - 1 + draws = np.empty((resamples, n_clusters), dtype=np.int64) + + for i in range(resamples): + for s in range(n_strata): + start = strata_offsets[s] + size = strata_offsets[s + 1] - start + picks = np.random.choice(size, size) + for k in range(size): + draws[i, start + k] = strata_clusters[start + picks[k]] + return draws + + +@njit(cache=True) +def expand_cluster_draw(draw, offsets, members): + """ + Expand a draw of cluster codes into the positions of all the observations + that belong to those clusters (see `cluster_tables`). + """ + total = 0 + for j in range(len(draw)): + g = draw[j] + total += offsets[g + 1] - offsets[g] + + out = np.empty(total, dtype=np.int64) + pos = 0 + for j in range(len(draw)): + g = draw[j] + for k in range(offsets[g], offsets[g + 1]): + out[pos] = members[k] + pos += 1 + return out + + +def _check_paired_clusters(c0, c1): + """Paired observations must share a cluster.""" + if len(c0) != len(c1) or not np.array_equal(c0, c1): + err1 = "In a paired analysis every control observation must belong to the same cluster " + err2 = "as the test observation it is paired with. Check that the data are sorted so " + err3 = "that paired rows are aligned, and that each pair has a single cluster label." + raise ValueError(err1 + err2 + err3) + + +def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size): + """ + Delete-one-cluster jackknife of the effect size for 2 groups. + + Used to compute the acceleration term of the BCa interval when the + observations are clustered. `c0` and `c1` hold the cluster label of each + observation in `x0` and `x1`. + """ + from . import effsize as __es + + x0, x1 = np.asarray(x0), np.asarray(x1) + (c0, c1), n_clusters = cluster_codes(c0, c1) + if is_paired: + _check_paired_clusters(c0, c1) + + out = [] + for g in range(n_clusters): + keep0 = c0 != g + keep1 = c1 != g + if not keep0.any() or not keep1.any(): + # Deleting this cluster would empty one of the groups. + continue + out.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size)) + return out + + +def compute_cluster_bootstrapped_diff( + x0, x1, c0, c1, is_paired, effect_size, resamples=5000, random_seed=12345 +): + """ + Cluster bootstrap of the effect size for 2 groups. + + Instead of resampling individual observations (or pairs), whole clusters + of observations (e.g. all the observations contributed by one participant) + are resampled with replacement, so that the correlation between + observations from the same cluster is preserved in every resample. + + `c0` and `c1` hold the cluster label of each observation in `x0` and `x1`; + a label present in both groups denotes the same cluster. In a paired + analysis the two label arrays must be identical, as the observations are + paired by position. + + When every observation is its own cluster this reduces exactly to + `compute_bootstrapped_diff`. + """ + from . import effsize as __es + + x0, x1 = np.asarray(x0), np.asarray(x1) + (c0, c1), n_clusters = cluster_codes(c0, c1) + if is_paired: + _check_paired_clusters(c0, c1) + + tables0 = cluster_tables(c0, n_clusters) + tables1 = cluster_tables(c1, n_clusters) + strata_clusters, strata_offsets = cluster_strata((c0, c1), n_clusters) + draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed) + + out = np.empty(resamples, dtype=np.float64) + for i in range(resamples): + idx0 = expand_cluster_draw(draws[i], *tables0) + idx1 = idx0 if is_paired else expand_cluster_draw(draws[i], *tables1) + out[i] = __es.two_group_difference(x0[idx0], x1[idx1], is_paired, effect_size) + + return out + + +def delta2_cluster_bootstrap_loop( + x1, x2, x3, x4, c1, c2, c3, c4, resamples, pooled_sd, rng_seed, is_paired, proportional=False +): + """ + Cluster-bootstrap counterpart of `delta2_bootstrap_loop`: whole clusters + are resampled with replacement, jointly across the four groups. + """ + xs = [np.asarray(x) for x in (x1, x2, x3, x4)] + (c1, c2, c3, c4), n_clusters = cluster_codes(c1, c2, c3, c4) + if is_paired: + _check_paired_clusters(c1, c2) + _check_paired_clusters(c3, c4) + + tables = [cluster_tables(c, n_clusters) for c in (c1, c2, c3, c4)] + strata_clusters, strata_offsets = cluster_strata((c1, c2, c3, c4), n_clusters) + draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, rng_seed) + + deltadelta = np.empty(resamples) + out_delta_g = np.empty(resamples) + + for i in range(resamples): + means = [np.mean(x[expand_cluster_draw(draws[i], *t)]) for x, t in zip(xs, tables)] + delta_delta = (means[3] - means[2]) - (means[1] - means[0]) + + deltadelta[i] = delta_delta + out_delta_g[i] = delta_delta if proportional else delta_delta / pooled_sd + + return out_delta_g, deltadelta + + @njit(cache=True) def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False): """ @@ -211,18 +434,29 @@ def compute_delta2_bootstrapped_diff( is_paired: str = None, resamples: int = 5000, random_seed: int = 12345, - proportional: bool = False + proportional: bool = False, + clusters=None, # Optional: four array-likes with the cluster label of every observation in x1, x2, x3 and x4. ) -> tuple: """ - Bootstraps the effect size deltas' g or proportional delta-delta + Bootstraps the effect size deltas' g or proportional delta-delta. + + If `clusters` is supplied, whole clusters are resampled with replacement + (see `compute_cluster_bootstrapped_diff`) instead of individual observations. """ x1, x2, x3, x4 = map(np.asarray, [x1, x2, x3, x4]) + + def _bootstrap_loop(pooled_sd, is_proportional): + if clusters is None: + return delta2_bootstrap_loop( + x1, x2, x3, x4, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional + ) + return delta2_cluster_bootstrap_loop( + x1, x2, x3, x4, *clusters, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional + ) if proportional: # For proportional data, pass 1.0 as dummy pooled_sd (won't be used) - out_delta_g, deltadelta = delta2_bootstrap_loop( - x1, x2, x3, x4, resamples, 1.0, random_seed, is_paired, proportional=True - ) + out_delta_g, deltadelta = _bootstrap_loop(1.0, True) # For proportional data, delta_g is the empirical delta-delta delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) else: @@ -241,9 +475,7 @@ def compute_delta2_bootstrapped_diff( if np.isnan(pooled_sample_sd) or pooled_sample_sd == 0: raise ValueError("Pooled sample standard deviation is NaN or zero.") - out_delta_g, deltadelta = delta2_bootstrap_loop( - x1, x2, x3, x4, resamples, pooled_sample_sd, random_seed, is_paired, proportional=False - ) + out_delta_g, deltadelta = _bootstrap_loop(pooled_sample_sd, False) delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) / pooled_sample_sd return out_delta_g, delta_g, deltadelta diff --git a/dabest/_stats_tools/precompile.py b/dabest/_stats_tools/precompile.py index c0e0f2f9..c9ac90f1 100644 --- a/dabest/_stats_tools/precompile.py +++ b/dabest/_stats_tools/precompile.py @@ -44,7 +44,12 @@ def precompile_all(): (confint_2group_diff.delta2_bootstrap_loop, (dummy_control, dummy_test, dummy_control, dummy_test, 10, 1.0, 12345, False)), (confint_2group_diff._compute_quantile, (0.5, 0.1, 0.1)), - (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)) + (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)), + (confint_2group_diff.cluster_bootstrap_draws, + (np.array([0, 1, 2], dtype=np.int64), np.array([0, 3], dtype=np.int64), 10, 12345)), + (confint_2group_diff.expand_cluster_draw, + (np.array([0, 1], dtype=np.int64), np.array([0, 1, 3], dtype=np.int64), + np.array([0, 1, 2], dtype=np.int64))), ] for func, args in tqdm(funcs, desc="Compiling numba functions"): diff --git a/nbs/API/confint_2group_diff.ipynb b/nbs/API/confint_2group_diff.ipynb index bdc009b3..b769a133 100644 --- a/nbs/API/confint_2group_diff.ipynb +++ b/nbs/API/confint_2group_diff.ipynb @@ -214,6 +214,227 @@ " return out\n", "\n", "\n", + "def cluster_codes(*cluster_labels):\n", + " \"\"\"\n", + " Convert cluster labels from one or more groups into contiguous integer codes.\n", + "\n", + " The labels of all groups are pooled, so that the same label appearing in\n", + " several groups (e.g. a participant measured under every condition) maps\n", + " to the same code. Codes are assigned in order of first appearance.\n", + "\n", + " Returns\n", + " -------\n", + " codes : list of int64 numpy arrays, one per input group.\n", + " n_clusters : int\n", + " The number of distinct clusters across all groups.\n", + " \"\"\"\n", + " import pandas as pd\n", + "\n", + " arrays = [np.asarray(a) for a in cluster_labels]\n", + " joined = np.concatenate(arrays) if len(arrays) > 1 else arrays[0]\n", + " codes, uniques = pd.factorize(pd.Series(joined), sort=False)\n", + " codes = codes.astype(np.int64)\n", + " if (codes < 0).any():\n", + " raise ValueError(\"Cluster labels must not contain missing values.\")\n", + "\n", + " out, start = [], 0\n", + " for a in arrays:\n", + " out.append(codes[start : start + len(a)])\n", + " start += len(a)\n", + " return out, len(uniques)\n", + "\n", + "\n", + "def cluster_tables(codes, n_clusters):\n", + " \"\"\"\n", + " Build the membership tables used by `expand_cluster_draw`.\n", + "\n", + " Returns `(offsets, members)` such that `members[offsets[g]:offsets[g+1]]`\n", + " holds the positions (in the original array) of the observations that\n", + " belong to cluster `g`. A cluster absent from the array has an empty slice.\n", + " \"\"\"\n", + " codes = np.asarray(codes, dtype=np.int64)\n", + " members = np.argsort(codes, kind=\"stable\").astype(np.int64)\n", + " counts = np.bincount(codes, minlength=n_clusters)\n", + " offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64)\n", + " return offsets, members\n", + "\n", + "\n", + "def cluster_strata(codes_per_group, n_clusters):\n", + " \"\"\"\n", + " Partition the clusters into resampling strata.\n", + "\n", + " Clusters are stratified by the pattern of groups in which they appear, so\n", + " that every bootstrap resample preserves the observed design. For a fully\n", + " within-cluster design (every cluster present in every group) there is a\n", + " single stratum and clusters are resampled jointly across the groups; for a\n", + " nested design (each cluster present in one group only) the clusters are\n", + " resampled separately within each group.\n", + "\n", + " Returns `(strata_clusters, strata_offsets)`: the cluster codes concatenated\n", + " stratum by stratum, and the boundaries of each stratum in that array.\n", + " \"\"\"\n", + " pattern = np.zeros(n_clusters, dtype=np.int64)\n", + " for k, codes in enumerate(codes_per_group):\n", + " present = np.zeros(n_clusters, dtype=bool)\n", + " present[np.asarray(codes, dtype=np.int64)] = True\n", + " pattern |= present.astype(np.int64) << k\n", + "\n", + " strata_clusters = np.argsort(pattern, kind=\"stable\").astype(np.int64)\n", + " _, counts = np.unique(pattern, return_counts=True)\n", + " strata_offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64)\n", + " return strata_clusters, strata_offsets\n", + "\n", + "\n", + "@njit(cache=True) # parallelization must be turned off for random number generation\n", + "def cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed):\n", + " \"\"\"\n", + " Draw clusters with replacement, separately within each stratum\n", + " (see `cluster_strata`).\n", + "\n", + " Returns an array of shape `(resamples, n_clusters)` holding, for each\n", + " resample, the codes of the clusters drawn.\n", + " \"\"\"\n", + " np.random.seed(random_seed)\n", + " n_clusters = len(strata_clusters)\n", + " n_strata = len(strata_offsets) - 1\n", + " draws = np.empty((resamples, n_clusters), dtype=np.int64)\n", + "\n", + " for i in range(resamples):\n", + " for s in range(n_strata):\n", + " start = strata_offsets[s]\n", + " size = strata_offsets[s + 1] - start\n", + " picks = np.random.choice(size, size)\n", + " for k in range(size):\n", + " draws[i, start + k] = strata_clusters[start + picks[k]]\n", + " return draws\n", + "\n", + "\n", + "@njit(cache=True)\n", + "def expand_cluster_draw(draw, offsets, members):\n", + " \"\"\"\n", + " Expand a draw of cluster codes into the positions of all the observations\n", + " that belong to those clusters (see `cluster_tables`).\n", + " \"\"\"\n", + " total = 0\n", + " for j in range(len(draw)):\n", + " g = draw[j]\n", + " total += offsets[g + 1] - offsets[g]\n", + "\n", + " out = np.empty(total, dtype=np.int64)\n", + " pos = 0\n", + " for j in range(len(draw)):\n", + " g = draw[j]\n", + " for k in range(offsets[g], offsets[g + 1]):\n", + " out[pos] = members[k]\n", + " pos += 1\n", + " return out\n", + "\n", + "\n", + "def _check_paired_clusters(c0, c1):\n", + " \"\"\"Paired observations must share a cluster.\"\"\"\n", + " if len(c0) != len(c1) or not np.array_equal(c0, c1):\n", + " err1 = \"In a paired analysis every control observation must belong to the same cluster \"\n", + " err2 = \"as the test observation it is paired with. Check that the data are sorted so \"\n", + " err3 = \"that paired rows are aligned, and that each pair has a single cluster label.\"\n", + " raise ValueError(err1 + err2 + err3)\n", + "\n", + "\n", + "def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size):\n", + " \"\"\"\n", + " Delete-one-cluster jackknife of the effect size for 2 groups.\n", + "\n", + " Used to compute the acceleration term of the BCa interval when the\n", + " observations are clustered. `c0` and `c1` hold the cluster label of each\n", + " observation in `x0` and `x1`.\n", + " \"\"\"\n", + " from . import effsize as __es\n", + "\n", + " x0, x1 = np.asarray(x0), np.asarray(x1)\n", + " (c0, c1), n_clusters = cluster_codes(c0, c1)\n", + " if is_paired:\n", + " _check_paired_clusters(c0, c1)\n", + "\n", + " out = []\n", + " for g in range(n_clusters):\n", + " keep0 = c0 != g\n", + " keep1 = c1 != g\n", + " if not keep0.any() or not keep1.any():\n", + " # Deleting this cluster would empty one of the groups.\n", + " continue\n", + " out.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size))\n", + " return out\n", + "\n", + "\n", + "def compute_cluster_bootstrapped_diff(\n", + " x0, x1, c0, c1, is_paired, effect_size, resamples=5000, random_seed=12345\n", + "):\n", + " \"\"\"\n", + " Cluster bootstrap of the effect size for 2 groups.\n", + "\n", + " Instead of resampling individual observations (or pairs), whole clusters\n", + " of observations (e.g. all the observations contributed by one participant)\n", + " are resampled with replacement, so that the correlation between\n", + " observations from the same cluster is preserved in every resample.\n", + "\n", + " `c0` and `c1` hold the cluster label of each observation in `x0` and `x1`;\n", + " a label present in both groups denotes the same cluster. In a paired\n", + " analysis the two label arrays must be identical, as the observations are\n", + " paired by position.\n", + "\n", + " When every observation is its own cluster this reduces exactly to\n", + " `compute_bootstrapped_diff`.\n", + " \"\"\"\n", + " from . import effsize as __es\n", + "\n", + " x0, x1 = np.asarray(x0), np.asarray(x1)\n", + " (c0, c1), n_clusters = cluster_codes(c0, c1)\n", + " if is_paired:\n", + " _check_paired_clusters(c0, c1)\n", + "\n", + " tables0 = cluster_tables(c0, n_clusters)\n", + " tables1 = cluster_tables(c1, n_clusters)\n", + " strata_clusters, strata_offsets = cluster_strata((c0, c1), n_clusters)\n", + " draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed)\n", + "\n", + " out = np.empty(resamples, dtype=np.float64)\n", + " for i in range(resamples):\n", + " idx0 = expand_cluster_draw(draws[i], *tables0)\n", + " idx1 = idx0 if is_paired else expand_cluster_draw(draws[i], *tables1)\n", + " out[i] = __es.two_group_difference(x0[idx0], x1[idx1], is_paired, effect_size)\n", + "\n", + " return out\n", + "\n", + "\n", + "def delta2_cluster_bootstrap_loop(\n", + " x1, x2, x3, x4, c1, c2, c3, c4, resamples, pooled_sd, rng_seed, is_paired, proportional=False\n", + "):\n", + " \"\"\"\n", + " Cluster-bootstrap counterpart of `delta2_bootstrap_loop`: whole clusters\n", + " are resampled with replacement, jointly across the four groups.\n", + " \"\"\"\n", + " xs = [np.asarray(x) for x in (x1, x2, x3, x4)]\n", + " (c1, c2, c3, c4), n_clusters = cluster_codes(c1, c2, c3, c4)\n", + " if is_paired:\n", + " _check_paired_clusters(c1, c2)\n", + " _check_paired_clusters(c3, c4)\n", + "\n", + " tables = [cluster_tables(c, n_clusters) for c in (c1, c2, c3, c4)]\n", + " strata_clusters, strata_offsets = cluster_strata((c1, c2, c3, c4), n_clusters)\n", + " draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, rng_seed)\n", + "\n", + " deltadelta = np.empty(resamples)\n", + " out_delta_g = np.empty(resamples)\n", + "\n", + " for i in range(resamples):\n", + " means = [np.mean(x[expand_cluster_draw(draws[i], *t)]) for x, t in zip(xs, tables)]\n", + " delta_delta = (means[3] - means[2]) - (means[1] - means[0])\n", + "\n", + " deltadelta[i] = delta_delta\n", + " out_delta_g[i] = delta_delta if proportional else delta_delta / pooled_sd\n", + "\n", + " return out_delta_g, deltadelta\n", + "\n", + "\n", "@njit(cache=True)\n", "def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False):\n", " \"\"\"\n", @@ -263,18 +484,29 @@ " is_paired: str = None,\n", " resamples: int = 5000,\n", " random_seed: int = 12345,\n", - " proportional: bool = False\n", + " proportional: bool = False,\n", + " clusters=None, # Optional: four array-likes with the cluster label of every observation in x1, x2, x3 and x4.\n", ") -> tuple:\n", " \"\"\"\n", - " Bootstraps the effect size deltas' g or proportional delta-delta\n", + " Bootstraps the effect size deltas' g or proportional delta-delta.\n", + "\n", + " If `clusters` is supplied, whole clusters are resampled with replacement\n", + " (see `compute_cluster_bootstrapped_diff`) instead of individual observations.\n", " \"\"\"\n", " x1, x2, x3, x4 = map(np.asarray, [x1, x2, x3, x4])\n", + "\n", + " def _bootstrap_loop(pooled_sd, is_proportional):\n", + " if clusters is None:\n", + " return delta2_bootstrap_loop(\n", + " x1, x2, x3, x4, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional\n", + " )\n", + " return delta2_cluster_bootstrap_loop(\n", + " x1, x2, x3, x4, *clusters, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional\n", + " )\n", " \n", " if proportional:\n", " # For proportional data, pass 1.0 as dummy pooled_sd (won't be used)\n", - " out_delta_g, deltadelta = delta2_bootstrap_loop(\n", - " x1, x2, x3, x4, resamples, 1.0, random_seed, is_paired, proportional=True\n", - " )\n", + " out_delta_g, deltadelta = _bootstrap_loop(1.0, True)\n", " # For proportional data, delta_g is the empirical delta-delta\n", " delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1)))\n", " else:\n", @@ -293,9 +525,7 @@ " if np.isnan(pooled_sample_sd) or pooled_sample_sd == 0:\n", " raise ValueError(\"Pooled sample standard deviation is NaN or zero.\")\n", " \n", - " out_delta_g, deltadelta = delta2_bootstrap_loop(\n", - " x1, x2, x3, x4, resamples, pooled_sample_sd, random_seed, is_paired, proportional=False\n", - " )\n", + " out_delta_g, deltadelta = _bootstrap_loop(pooled_sample_sd, False)\n", " delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) / pooled_sample_sd\n", "\n", " return out_delta_g, delta_g, deltadelta\n", diff --git a/nbs/API/dabest_object.ipynb b/nbs/API/dabest_object.ipynb index f082c62b..41c872e5 100644 --- a/nbs/API/dabest_object.ipynb +++ b/nbs/API/dabest_object.ipynb @@ -144,6 +144,7 @@ " x1_level,\n", " mini_meta,\n", " ps_adjust,\n", + " cluster_col=None,\n", " ):\n", " \"\"\"\n", " Parses and stores pandas DataFrames in preparation for estimation\n", @@ -163,6 +164,7 @@ " self.__is_proportional = proportional\n", " self.__is_mini_meta = mini_meta\n", " self.__ps_adjust = ps_adjust\n", + " self.__cluster_col = cluster_col\n", "\n", " # after this call the attributes self.__experiment_label and self.__x1_level are updated\n", " self._check_errors(x, y, idx, experiment, experiment_label, x1_level)\n", @@ -231,6 +233,11 @@ " resamples_line2 = \"will be used to generate the effect size bootstraps.\"\n", " out.append(resamples_line1 + resamples_line2)\n", "\n", + " if self.__cluster_col is not None:\n", + " cluster_line1 = \"Whole clusters, as defined by `{}`, \".format(self.__cluster_col)\n", + " cluster_line2 = \"will be resampled by the bootstrap and reshuffled by the permutation test.\"\n", + " out.append(cluster_line1 + cluster_line2)\n", + "\n", " return \"\\n\".join(out)\n", "\n", "\n", @@ -445,6 +452,15 @@ " return self.__id_col\n", "\n", " @property\n", + " def cluster_col(self):\n", + " \"\"\"\n", + " Returns the cluster column declared to `dabest.load()`, if any.\n", + " When set, the bootstrap resamples whole clusters of observations and\n", + " the permutation test reshuffles labels at the cluster level.\n", + " \"\"\"\n", + " return self.__cluster_col\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " The width of the desired confidence interval.\n", @@ -685,6 +701,23 @@ " if self.__id_col not in self.__output_data.columns:\n", " err = \"`id_col` was given as '{}'; however, '{}' is not a column in `data`.\".format(self.__id_col, self.__id_col)\n", " raise IndexError(err)\n", + "\n", + " # Check if `cluster_col` is valid\n", + " if self.__cluster_col is not None:\n", + " if self.__cluster_col not in self.__output_data.columns:\n", + " err = \"`cluster_col` was given as '{}'; however, '{}' is not a column in `data`.\".format(self.__cluster_col, self.__cluster_col)\n", + " raise IndexError(err)\n", + "\n", + " if y is not None and self.__cluster_col == y:\n", + " err = \"`cluster_col` cannot be the same column as `y`.\"\n", + " raise ValueError(err)\n", + "\n", + " if x is None and idx is not None:\n", + " # Wide format: the cluster column cannot also be one of the groups.\n", + " groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))]\n", + " if self.__cluster_col in groups:\n", + " err = \"`cluster_col` ('{}') cannot also be one of the groups in `idx`.\".format(self.__cluster_col)\n", + " raise ValueError(err)\n", " \n", " # Check if x and y are supplied (relevant to long format data)\n", " if x is None and y is not None:\n", @@ -780,8 +813,32 @@ " plot_data[self.__xvar], categories=all_plot_groups, ordered=True\n", " )\n", "\n", + " if self.__cluster_col is not None:\n", + " self._check_clusters(plot_data)\n", + "\n", " return plot_data\n", "\n", + " def _check_clusters(self, plot_data):\n", + " \"\"\"\n", + " Check that the cluster labels are complete and, for paired data,\n", + " consistent within each `id_col` value.\n", + " \"\"\"\n", + " clusters = plot_data[self.__cluster_col]\n", + " if clusters.isnull().any():\n", + " err1 = \"`cluster_col` ('{}') contains missing values.\".format(self.__cluster_col)\n", + " err2 = \" Every observation must belong to a cluster.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", + " if self.__is_paired:\n", + " clusters_per_id = plot_data.groupby(self.__id_col, observed=True)[self.__cluster_col].nunique()\n", + " inconsistent = clusters_per_id.index[clusters_per_id > 1].tolist()\n", + " if inconsistent:\n", + " err1 = \"Each value of `id_col` must belong to a single cluster in `cluster_col`,\"\n", + " err2 = \" but the following values of '{}' have more than one cluster label: {}.\".format(\n", + " self.__id_col, inconsistent[:10]\n", + " )\n", + " raise ValueError(err1 + err2)\n", + "\n", " def _compute_effectsize_dfs(self):\n", " '''\n", " Function to compute all attributes based on EffectSizeDataFrame.\n", diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 22fe2412..3f6ff917 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -153,6 +153,16 @@ " ps_adjust : boolean, default False.\n", " If True, adjust calculated p-value according to Phipson & Smyth (2010)\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " control_clusters : array-like, default None\n", + " test_clusters : array-like, default None\n", + " The cluster (e.g. participant) that each observation in `control`\n", + " and `test` belongs to. When supplied, the bootstrap resamples whole\n", + " clusters with replacement and the permutation test reshuffles\n", + " labels at the cluster level, so that the confidence interval and\n", + " permutation p-value account for the correlation between\n", + " observations from the same cluster. A label present in both\n", + " arrays denotes the same cluster. For paired data the two arrays\n", + " must be identical, since observations are paired by position.\n", " \n", "\n", " Returns\n", @@ -192,6 +202,8 @@ " permutation_count=5000,\n", " random_seed=12345,\n", " ps_adjust=False,\n", + " control_clusters=None,\n", + " test_clusters=None,\n", " ):\n", " from ._stats_tools import confint_2group_diff as ci2g\n", " from ._stats_tools import effsize as es\n", @@ -212,7 +224,8 @@ " self.__ci = ci\n", " self.__is_proportional = proportional\n", " self.__ps_adjust = ps_adjust\n", - " self._check_errors(control, test)\n", + " self.__is_clustered = control_clusters is not None or test_clusters is not None\n", + " self._check_errors(control, test, control_clusters, test_clusters)\n", "\n", " # Convert to numpy arrays for speed.\n", " # NaNs are automatically dropped.\n", @@ -222,26 +235,65 @@ " self.__test = test[~isnan(test)]\n", " self.__permutation_count = permutation_count\n", "\n", + " if self.__is_clustered:\n", + " # Keep the cluster labels aligned with the NaN-filtered observations.\n", + " self.__control_clusters = array(control_clusters)[~isnan(control)]\n", + " self.__test_clusters = array(test_clusters)[~isnan(test)]\n", + " (control_codes, test_codes), self.__n_clusters = ci2g.cluster_codes(\n", + " self.__control_clusters, self.__test_clusters\n", + " )\n", + " if self.__is_paired and not np.array_equal(control_codes, test_codes):\n", + " err1 = \"In a paired analysis every control observation must belong to the same \"\n", + " err2 = \"cluster as the test observation it is paired with. Check that the data \"\n", + " err3 = \"are sorted so that paired rows are aligned, and that each pair has a single cluster label.\"\n", + " raise ValueError(err1 + err2 + err3)\n", + " else:\n", + " self.__control_clusters = None\n", + " self.__test_clusters = None\n", + " self.__n_clusters = None\n", + "\n", " self.__alpha = ci2g._compute_alpha_from_ci(self.__ci)\n", "\n", " self.__difference = es.two_group_difference(\n", " self.__control, self.__test, self.__is_paired, self.__effect_size\n", " )\n", "\n", - " self.__jackknives = ci2g.compute_meandiff_jackknife(\n", - " self.__control, self.__test, self.__is_paired, self.__effect_size\n", - " )\n", + " if self.__is_clustered:\n", + " self.__jackknives = ci2g.compute_cluster_jackknife(\n", + " self.__control,\n", + " self.__test,\n", + " self.__control_clusters,\n", + " self.__test_clusters,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " )\n", + " else:\n", + " self.__jackknives = ci2g.compute_meandiff_jackknife(\n", + " self.__control, self.__test, self.__is_paired, self.__effect_size\n", + " )\n", "\n", " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", - " bootstraps = ci2g.compute_bootstrapped_diff(\n", - " self.__control,\n", - " self.__test,\n", - " self.__is_paired,\n", - " self.__effect_size,\n", - " self.__resamples,\n", - " self.__random_seed,\n", - " )\n", + " if self.__is_clustered:\n", + " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", + " self.__control,\n", + " self.__test,\n", + " self.__control_clusters,\n", + " self.__test_clusters,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", + " else:\n", + " bootstraps = ci2g.compute_bootstrapped_diff(\n", + " self.__control,\n", + " self.__test,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", " self.__bootstraps = bootstraps\n", "\n", " sorted_bootstraps = npsort(self.__bootstraps)\n", @@ -317,13 +369,21 @@ "\n", " pval_rounded = base_string_fmt.format(self.pvalue_permutation)\n", "\n", - " p1 = \"The p-value of the two-sided permutation t-test is {}, \".format(\n", - " pval_rounded\n", - " )\n", + " if self.__is_clustered:\n", + " p1 = \"The p-value of the two-sided cluster-level permutation test is {}, \".format(\n", + " pval_rounded\n", + " )\n", + " bs1 = \"{} cluster bootstrap samples were taken, resampling {} clusters with replacement; \".format(\n", + " self.__resamples, self.__n_clusters\n", + " )\n", + " else:\n", + " p1 = \"The p-value of the two-sided permutation t-test is {}, \".format(\n", + " pval_rounded\n", + " )\n", + " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", " p2 = \"calculated for legacy purposes only. \"\n", " pvalue = p1 + p2\n", "\n", - " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", " bs = bs1 + bs2\n", "\n", @@ -347,10 +407,20 @@ " else:\n", " return \"{}\\n{}\".format(out, pvalue)\n", "\n", - " def _check_errors(self, control, test):\n", + " def _check_errors(self, control, test, control_clusters=None, test_clusters=None):\n", " '''\n", " Function to check configuration errors for the given control and test data.\n", " '''\n", + " if self.__is_clustered:\n", + " if control_clusters is None or test_clusters is None:\n", + " err1 = \"Both `control_clusters` and `test_clusters` must be supplied \"\n", + " err2 = \"for a cluster-aware analysis.\"\n", + " raise ValueError(err1 + err2)\n", + " if len(control_clusters) != len(control) or len(test_clusters) != len(test):\n", + " err1 = \"`control_clusters` and `test_clusters` must have the same lengths \"\n", + " err2 = \"as `control` and `test` respectively.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " kosher_es = [a for a in self.__EFFECT_SIZE_DICT.keys()]\n", " if self.__effect_size not in kosher_es:\n", " err1 = \"The effect size '{}'\".format(self.__effect_size)\n", @@ -436,6 +506,8 @@ " self.__is_paired,\n", " self.__permutation_count,\n", " ps_adjust = self.__ps_adjust,\n", + " control_clusters=self.__control_clusters,\n", + " test_clusters=self.__test_clusters,\n", " )\n", "\n", " if self.__is_paired and not self.__is_proportional:\n", @@ -556,20 +628,41 @@ " )\n", " self.__bec_difference = difference\n", "\n", - " jackknives = ci2g.compute_meandiff_jackknife(\n", - " self.__control, self.__control, is_paired, self.__effect_size\n", - " )\n", + " if self.__is_clustered:\n", + " # The two copies of the control group are resampled independently,\n", + " # so the clusters of the second copy are given distinct labels.\n", + " (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters)\n", + " codes_copy = codes + n_clusters\n", + " jackknives = ci2g.compute_cluster_jackknife(\n", + " self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size\n", + " )\n", + " else:\n", + " jackknives = ci2g.compute_meandiff_jackknife(\n", + " self.__control, self.__control, is_paired, self.__effect_size\n", + " )\n", "\n", " acceleration_value = ci2g._calc_accel(jackknives)\n", "\n", - " bootstraps = ci2g.compute_bootstrapped_diff(\n", - " self.__control,\n", - " self.__control,\n", - " is_paired,\n", - " self.__effect_size,\n", - " self.__resamples,\n", - " self.__random_seed,\n", - " )\n", + " if self.__is_clustered:\n", + " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", + " self.__control,\n", + " self.__control,\n", + " codes,\n", + " codes_copy,\n", + " is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", + " else:\n", + " bootstraps = ci2g.compute_bootstrapped_diff(\n", + " self.__control,\n", + " self.__control,\n", + " is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", " self.__bootstraps_baseline_ec = bootstraps\n", "\n", " sorted_bootstraps = npsort(self.__bootstraps_baseline_ec)\n", @@ -653,6 +746,22 @@ " return self.__is_proportional\n", "\n", " @property\n", + " def is_clustered(self):\n", + " \"\"\"\n", + " Whether whole clusters of observations, rather than individual\n", + " observations, were resampled by the bootstrap and permutation test.\n", + " \"\"\"\n", + " return self.__is_clustered\n", + "\n", + " @property\n", + " def n_clusters(self):\n", + " \"\"\"\n", + " The number of distinct clusters resampled by the cluster bootstrap;\n", + " None if the observations are not clustered.\n", + " \"\"\"\n", + " return self.__n_clusters\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " Returns the width of the confidence interval, in percent.\n", @@ -1085,8 +1194,17 @@ " reprs = []\n", "\n", " grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)}\n", + "\n", + " # The cluster label of every observation, for a cluster-aware analysis.\n", + " cluster_col = getattr(self.__dabest_obj, \"cluster_col\", None)\n", + " if cluster_col is not None:\n", + " grouped_clusters = {name: group[cluster_col].to_numpy() for name, group in dat.groupby(xvar, observed=False)}\n", + " else:\n", + " grouped_clusters = {name: None for name in grouped_data}\n", + "\n", " if self.__delta2:\n", " mixed_data = []\n", + " mixed_clusters = []\n", " for j, current_tuple in enumerate(idx):\n", " if self.__is_paired != \"sequential\":\n", " cname = current_tuple[0]\n", @@ -1099,6 +1217,8 @@ " test = grouped_data[tname]\n", " mixed_data.append(control)\n", " mixed_data.append(test)\n", + " mixed_clusters.append(grouped_clusters[cname])\n", + " mixed_clusters.append(grouped_clusters[tname])\n", " bootstraps_delta_delta = ci2g.compute_delta2_bootstrapped_diff(\n", " mixed_data[0],\n", " mixed_data[1],\n", @@ -1108,6 +1228,7 @@ " self.__resamples,\n", " self.__random_seed,\n", " self.__is_proportional,\n", + " clusters=mixed_clusters if cluster_col is not None else None,\n", " )\n", "\n", " for j, current_tuple in enumerate(idx):\n", @@ -1130,7 +1251,9 @@ " self.__resamples,\n", " self.__permutation_count,\n", " self.__random_seed,\n", - " self.__ps_adjust\n", + " self.__ps_adjust,\n", + " control_clusters=grouped_clusters[cname],\n", + " test_clusters=grouped_clusters[tname],\n", " )\n", " r_dict = result.to_dict()\n", " r_dict[\"control\"] = cname\n", @@ -1170,6 +1293,7 @@ " \"test\",\n", " \"control_N\",\n", " \"test_N\",\n", + " \"n_clusters\",\n", " \"effect_size\",\n", " \"is_paired\",\n", " \"difference\",\n", @@ -2216,6 +2340,15 @@ " ps_adjust : bool, default False\n", " If True, the p-value is adjusted according to Phipson & Smyth (2010).\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " control_clusters : array-like, default None\n", + " test_clusters : array-like, default None\n", + " The cluster (e.g. participant) that each observation in `control` and\n", + " `test` belongs to. When supplied, labels are reshuffled at the cluster\n", + " level: for paired data, control and test are swapped for whole clusters\n", + " at a time; for unpaired data with clusters nested within groups, whole\n", + " clusters are reassigned between the groups; and for unpaired data with\n", + " clusters spanning both groups, the group labels are reshuffled within\n", + " each cluster.\n", "\n", " \n", " Returns\n", @@ -2236,9 +2369,16 @@ " permutation_count:int=5000, # The number of permutations (reshuffles) to perform.\n", " random_seed:int=12345,#`random_seed` is used to seed the random number generator during bootstrap resampling. This ensures that the generated permutations are replicable.\n", " ps_adjust:bool=False,\n", + " control_clusters=None, # Cluster label of each observation in `control`; see the class docstring.\n", + " test_clusters=None, # Cluster label of each observation in `test`.\n", " **kwargs):\n", " from ._stats_tools.effsize import two_group_difference\n", - " from ._stats_tools.confint_2group_diff import calculate_group_var\n", + " from ._stats_tools.confint_2group_diff import (\n", + " calculate_group_var,\n", + " cluster_codes,\n", + " cluster_tables,\n", + " expand_cluster_draw,\n", + " )\n", " \n", "\n", " self.__permutation_count = permutation_count\n", @@ -2247,6 +2387,12 @@ " if is_paired and len(control) != len(test):\n", " raise ValueError(\"The two arrays do not have the same length.\")\n", "\n", + " is_clustered = control_clusters is not None or test_clusters is not None\n", + " if is_clustered and (control_clusters is None or test_clusters is None):\n", + " err1 = \"Both `control_clusters` and `test_clusters` must be supplied \"\n", + " err2 = \"for a cluster-aware permutation test.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " # Initialise random number generator.\n", " # rng = random.default_rng(seed=random_seed)\n", " rng = RandomState(PCG64(random_seed))\n", @@ -2267,8 +2413,75 @@ " self.__permutations = []\n", " self.__permutations_var = []\n", "\n", - " for i in range(int(self.__permutation_count)):\n", + " # The number of distinct (two-sided) permutations, used by the\n", + " # Phipson & Smyth (2010) adjustment.\n", + " if is_clustered:\n", + " (control_codes, test_codes), n_clusters = cluster_codes(control_clusters, test_clusters)\n", + " if len(control_codes) != CONTROL_LEN or len(test_codes) != TEST_LEN:\n", + " err1 = \"`control_clusters` and `test_clusters` must have the same lengths \"\n", + " err2 = \"as `control` and `test` respectively.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " if is_paired:\n", + " if not np.array_equal(control_codes, test_codes):\n", + " err1 = \"In a paired analysis every control observation must belong to the \"\n", + " err2 = \"same cluster as the test observation it is paired with.\"\n", + " raise ValueError(err1 + err2)\n", + " # Control and test are swapped for whole clusters at a time; each\n", + " # pattern of swaps and its mirror image give the same |effect size|.\n", + " totalPermutations = 2.0 ** n_clusters / 2\n", + " else:\n", + " bag_codes = array([*control_codes, *test_codes])\n", + " offsets, members = cluster_tables(bag_codes, n_clusters)\n", + " cluster_sizes = offsets[1:] - offsets[:-1]\n", + " control_per_cluster = np.bincount(control_codes, minlength=n_clusters)\n", + " clusters_shared = bool(\n", + " ((control_per_cluster > 0) & (control_per_cluster < cluster_sizes)).any()\n", + " )\n", + "\n", + " if clusters_shared:\n", + " # Clusters contribute to both groups: the group labels are\n", + " # reshuffled within each cluster. In the bag sorted by cluster,\n", + " # the first `control_per_cluster[g]` slots of cluster g are\n", + " # assigned to control.\n", + " slot = arange(len(BAG)) - repeat(offsets[:-1], cluster_sizes)\n", + " control_slot = slot < repeat(control_per_cluster, cluster_sizes)\n", + " totalPermutations = float(\n", + " np.prod([binomcoeff(n, k) for n, k in zip(cluster_sizes, control_per_cluster)])\n", + " )\n", + " else:\n", + " # Clusters are nested within groups: whole clusters are\n", + " # reassigned between the control and test groups.\n", + " n_control_clusters = int((control_per_cluster > 0).sum())\n", + " if 2 * n_control_clusters == n_clusters:\n", + " totalPermutations = binomcoeff(n_clusters, n_control_clusters) / 2\n", + " else:\n", + " totalPermutations = binomcoeff(n_clusters, n_control_clusters)\n", + " elif CONTROL_LEN == TEST_LEN:\n", + " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) / 2\n", + " else:\n", + " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)\n", + "\n", + " for i in range(int(self.__permutation_count)):\n", + " if is_clustered and is_paired:\n", + " # Swap control and test for whole clusters at a time.\n", + " flip = rng.randint(0, 2, n_clusters).astype(bool)[control_codes]\n", + " control_sample = np.where(flip, test, control)\n", + " test_sample = np.where(flip, control, test)\n", + "\n", + " elif is_clustered and clusters_shared:\n", + " # Reshuffle the group labels within each cluster.\n", + " order = np.lexsort((rng.random_sample(len(BAG)), bag_codes))\n", + " control_sample = BAG[order[control_slot]]\n", + " test_sample = BAG[order[~control_slot]]\n", + "\n", + " elif is_clustered:\n", + " # Reassign whole clusters between the control and test groups.\n", + " perm = rng.permutation(n_clusters).astype(np.int64)\n", + " control_sample = BAG[expand_cluster_draw(perm[:n_control_clusters], offsets, members)]\n", + " test_sample = BAG[expand_cluster_draw(perm[n_control_clusters:], offsets, members)]\n", + "\n", + " elif is_paired:\n", " # Select which control-test pairs to swap.\n", " random_idx = rng.choice(CONTROL_LEN,\n", " rng.randint(0, CONTROL_LEN+1),\n", @@ -2292,7 +2505,7 @@ " False, effect_size)\n", " \n", " group_var = calculate_group_var(var(control_sample, ddof=1), \n", - " CONTROL_LEN, \n", + " len(control_sample), \n", " var(test_sample, ddof=1), \n", " len(test_sample))\n", " self.__permutations.append(es)\n", @@ -2309,11 +2522,6 @@ " # https://rdrr.io/cran/statmod/src/R/permp.R\n", " # (assumes two-sided test)\n", "\n", - " if CONTROL_LEN == TEST_LEN:\n", - " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)/2\n", - " else:\n", - " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)\n", - "\n", " if totalPermutations <= 10e3:\n", " # use exact calculation\n", " p = arange(1, totalPermutations + 1)/totalPermutations\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index 86c7782c..85d165a3 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -72,6 +72,7 @@ " x1_level=None,\n", " mini_meta=False,\n", " ps_adjust=False,\n", + " cluster_col=None,\n", "):\n", " \"\"\"\n", " Loads data in preparation for estimation statistics.\n", @@ -135,6 +136,20 @@ " ps_adjust : boolean, default False\n", " Indicator of whether to adjust calculated p-value according to Phipson & Smyth (2010)\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " cluster_col : string, default None\n", + " Name of the column identifying the independent sampling unit (cluster)\n", + " that each observation belongs to, for example a participant who\n", + " contributes several observations, or several pairs of paired\n", + " observations. When supplied, the bootstrap resamples whole clusters\n", + " with replacement (a cluster bootstrap) and the permutation test\n", + " reshuffles labels at the cluster level, so that the confidence\n", + " intervals and permutation p-values account for the correlation between\n", + " observations from the same cluster. This works with both unpaired data\n", + " and paired data (`paired` with `id_col`): for paired data, `id_col`\n", + " identifies the pairs and `cluster_col` the units the pairs are nested\n", + " in, and every pair must belong to a single cluster. The parametric and\n", + " rank-based tests reported in `statistical_tests` do not account for\n", + " clustering.\n", "\n", " Returns\n", " -------\n", @@ -159,6 +174,7 @@ " x1_level,\n", " mini_meta,\n", " ps_adjust,\n", + " cluster_col=cluster_col,\n", " )" ] }, diff --git a/nbs/API/precompile.ipynb b/nbs/API/precompile.ipynb index 95b8c834..e6e4dcc9 100644 --- a/nbs/API/precompile.ipynb +++ b/nbs/API/precompile.ipynb @@ -99,7 +99,12 @@ " (confint_2group_diff.delta2_bootstrap_loop, \n", " (dummy_control, dummy_test, dummy_control, dummy_test, 10, 1.0, 12345, False)),\n", " (confint_2group_diff._compute_quantile, (0.5, 0.1, 0.1)),\n", - " (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3))\n", + " (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)),\n", + " (confint_2group_diff.cluster_bootstrap_draws,\n", + " (np.array([0, 1, 2], dtype=np.int64), np.array([0, 3], dtype=np.int64), 10, 12345)),\n", + " (confint_2group_diff.expand_cluster_draw,\n", + " (np.array([0, 1], dtype=np.int64), np.array([0, 1, 3], dtype=np.int64),\n", + " np.array([0, 1, 2], dtype=np.int64))),\n", " ]\n", " \n", " for func, args in tqdm(funcs, desc=\"Compiling numba functions\"):\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py new file mode 100644 index 00000000..29f38bb3 --- /dev/null +++ b/nbs/tests/test_cluster_bootstrap.py @@ -0,0 +1,331 @@ +"""Tests for the cluster-aware bootstrap and permutation test (`cluster_col`).""" + +import numpy as np +import pandas as pd +import pytest + +from dabest._api import load +from dabest._effsize_objects import TwoGroupsEffectSize, PermutationTest +from dabest._stats_tools import confint_2group_diff as ci2g + + +def make_clustered_data(n_participants=12, n_sets=4, sd_participant=1.5, seed=3): + """ + Within-subject design in long format: every participant contributes + `n_sets` paired sets of observations across three levels, so that the + pairs (identified by `pair`) are nested within participants (`ID`). + """ + rng = np.random.default_rng(seed) + levels = ["L1", "L2", "L3"] + rows = [] + for p in range(n_participants): + u_p = rng.normal(0, sd_participant) # participant-specific sensitivity + for s in range(n_sets): + u_s = rng.normal(0, 0.5) + for k, level in enumerate(levels): + rows.append( + dict( + ID="P{:02d}".format(p), + pair=p * n_sets + s, + Level=level, + Y=3 + 0.4 * k * (1 + u_p) + u_s + rng.normal(0, 0.5), + ) + ) + return pd.DataFrame(rows).sort_values(["pair", "Level"]).reset_index(drop=True) + + +DF = make_clustered_data() +PAIRED_KWARGS = dict( + idx=("L1", "L2", "L3"), + x="Level", + y="Y", + paired="sequential", + id_col="pair", + resamples=500, + random_seed=11, +) + + +@pytest.fixture(scope="module") +def naive(): + return load(DF, **PAIRED_KWARGS) + + +@pytest.fixture(scope="module") +def clustered(): + return load(DF, cluster_col="ID", **PAIRED_KWARGS) + + +# --------------------------------------------------------------------------- +# Low-level resampling machinery +# --------------------------------------------------------------------------- +def test_cluster_codes_pool_labels_across_groups(): + (c0, c1), n = ci2g.cluster_codes(["a", "b", "a"], ["b", "c"]) + assert n == 3 + assert c0.tolist() == [0, 1, 0] + assert c1.tolist() == [1, 2] + + with pytest.raises(ValueError): + ci2g.cluster_codes(["a", None, "b"]) + + +def test_cluster_tables_and_expand_cluster_draw(): + codes = np.array([2, 0, 2, 1, 0]) + offsets, members = ci2g.cluster_tables(codes, 3) + assert offsets.tolist() == [0, 2, 3, 5] + assert members[offsets[0] : offsets[1]].tolist() == [1, 4] + assert members[offsets[2] : offsets[3]].tolist() == [0, 2] + + draw = np.array([2, 2, 1], dtype=np.int64) + idx = ci2g.expand_cluster_draw(draw, offsets, members) + assert idx.tolist() == [0, 2, 0, 2, 3] + + +def test_cluster_strata_follow_the_design(): + # Fully within-cluster: every cluster in both groups -> one stratum. + strata, offsets = ci2g.cluster_strata(([0, 1, 2], [0, 1, 2]), 3) + assert offsets.tolist() == [0, 3] + + # Nested: clusters 0-1 only in control, 2-3 only in test -> one stratum per group. + strata, offsets = ci2g.cluster_strata(([0, 1], [2, 3]), 4) + assert offsets.tolist() == [0, 2, 4] + assert sorted(strata[:2].tolist()) == [0, 1] + assert sorted(strata[2:].tolist()) == [2, 3] + + # Mixed: one stratum per membership pattern. + strata, offsets = ci2g.cluster_strata(([0, 1, 2], [1, 2, 3]), 4) + assert offsets.tolist() == [0, 1, 2, 4] + + +def test_cluster_bootstrap_reduces_to_ordinary_bootstrap_for_singleton_clusters(): + rng = np.random.default_rng(1) + x0 = rng.normal(0, 1, 15) + x1 = rng.normal(0.5, 1, 15) + ids = np.arange(15) + + # Paired: every pair is its own cluster. + plain = ci2g.compute_bootstrapped_diff(x0, x1, "baseline", "mean_diff", 300, 7) + clus = ci2g.compute_cluster_bootstrapped_diff(x0, x1, ids, ids, "baseline", "mean_diff", 300, 7) + assert np.array_equal(plain, clus) + + # Unpaired: every observation is its own cluster (nested design). + x1u = rng.normal(0.5, 1, 20) + plain = ci2g.compute_bootstrapped_diff(x0, x1u, None, "mean_diff", 300, 7) + clus = ci2g.compute_cluster_bootstrapped_diff( + x0, x1u, np.arange(15), 100 + np.arange(20), None, "mean_diff", 300, 7 + ) + assert np.array_equal(plain, clus) + + # The delete-one jackknife also coincides. + plain = ci2g.compute_meandiff_jackknife(x0, x1, "baseline", "mean_diff") + clus = ci2g.compute_cluster_jackknife(x0, x1, ids, ids, "baseline", "mean_diff") + assert plain == pytest.approx(clus) + + +def test_cluster_bootstrap_keeps_pairs_together(): + # With a constant within-pair difference in every cluster, every paired + # cluster-bootstrap resample must reproduce that difference exactly. + x0 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) + x1 = x0 + np.array([0.5, 0.5, 1.0, 1.0, 2.0, 2.0]) + clusters = np.array([0, 0, 1, 1, 2, 2]) + boots = ci2g.compute_cluster_bootstrapped_diff(x0, x1, clusters, clusters, "baseline", "mean_diff", 200, 3) + # Three equally sized clusters are drawn with replacement, so every + # resample's mean difference is the mean of three cluster differences. + from itertools import combinations_with_replacement + + allowed = {round(np.mean(c), 10) for c in combinations_with_replacement([0.5, 1.0, 2.0], 3)} + assert set(np.round(boots, 10)).issubset(allowed) + + +def test_cluster_bootstrap_rejects_misaligned_paired_clusters(): + x = np.arange(6, dtype=float) + with pytest.raises(ValueError, match="same cluster"): + ci2g.compute_cluster_bootstrapped_diff(x, x, [0, 0, 1, 1, 2, 2], [0, 1, 1, 2, 2, 0], "baseline", "mean_diff", 10, 1) + + +# --------------------------------------------------------------------------- +# dabest.load with cluster_col +# --------------------------------------------------------------------------- +def test_point_estimates_are_unchanged_by_clustering(naive, clustered): + for effect_size in ["mean_diff", "cohens_d", "hedges_g"]: + n = getattr(naive, effect_size).results["difference"].to_numpy() + c = getattr(clustered, effect_size).results["difference"].to_numpy() + assert n == pytest.approx(c) + + +def test_cluster_intervals_are_wider_under_participant_effects(naive, clustered): + rn = naive.mean_diff.results + rc = clustered.mean_diff.results + sd_ratio = [np.std(c) / np.std(n) for c, n in zip(rc["bootstraps"], rn["bootstraps"])] + assert all(r > 1.2 for r in sd_ratio) + assert ((rc["bca_high"] - rc["bca_low"]) > (rn["bca_high"] - rn["bca_low"])).all() + + +def test_results_report_clusters(naive, clustered): + rc = clustered.mean_diff.results + assert rc["n_clusters"].tolist() == [12, 12] + assert "n_clusters" not in naive.mean_diff.results.columns + + assert clustered.cluster_col == "ID" + assert naive.cluster_col is None + assert "clusters" in repr(clustered) + assert "cluster" in repr(clustered.mean_diff) + assert "cluster" not in repr(naive.mean_diff) + + +def test_baseline_pairing_with_clusters(): + result = load(DF, cluster_col="ID", **dict(PAIRED_KWARGS, paired="baseline")).mean_diff.results + assert result["n_clusters"].tolist() == [12, 12] + assert result["control"].tolist() == ["L1", "L1"] + + +def test_unpaired_with_clusters_spanning_both_groups(): + kwargs = dict(idx=("L1", "L3"), x="Level", y="Y", resamples=300, random_seed=5) + naive = load(DF, **kwargs).mean_diff.results + clustered = load(DF, cluster_col="ID", **kwargs).mean_diff.results + assert clustered["n_clusters"].iloc[0] == 12 + assert clustered["difference"].iloc[0] == pytest.approx(naive["difference"].iloc[0]) + assert 0 <= clustered["pvalue_permutation"].iloc[0] <= 1 + assert len(clustered["permutations"].iloc[0]) == 5000 + + +def test_unpaired_with_clusters_nested_within_groups(): + # Participants P00-P05 measured at L1 only; P06-P11 at L3 only. + df = DF[DF["Level"].isin(["L1", "L3"])] + first_half = df["ID"] < "P06" + df = df[(first_half & (df["Level"] == "L1")) | (~first_half & (df["Level"] == "L3"))] + result = load( + df, idx=("L1", "L3"), x="Level", y="Y", cluster_col="ID", resamples=300, ps_adjust=True + ).mean_diff.results + assert result["n_clusters"].iloc[0] == 12 + assert result["control_N"].iloc[0] == 24 + assert 0 <= result["pvalue_permutation"].iloc[0] <= 1 + + +def test_wide_format_with_clusters(): + wide = DF.pivot(index="pair", columns="Level", values="Y").reset_index() + wide["ID"] = wide["pair"] // 4 + result = load( + wide, idx=("L1", "L2", "L3"), paired="sequential", id_col="pair", cluster_col="ID", resamples=300 + ).mean_diff.results + long_result = load(DF, cluster_col="ID", **dict(PAIRED_KWARGS, resamples=300)).mean_diff.results + assert result["n_clusters"].tolist() == [12, 12] + assert result["difference"].to_numpy() == pytest.approx(long_result["difference"].to_numpy()) + + +def test_delta2_and_mini_meta_with_clusters(): + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + + delta2 = load( + df, x=["Level", "Env"], y="Y", delta2=True, experiment="Env", + paired="sequential", id_col="pair", cluster_col="ID", resamples=300, + ) + dd = delta2.mean_diff.delta_delta + assert dd.bca_low < dd.difference < dd.bca_high + assert len(dd.bootstraps_delta_delta) == 300 + dg = delta2.hedges_g.delta_delta + assert dg.bca_low < dg.difference < dg.bca_high + + mini_meta = load( + df, idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=300, + ) + mm = mini_meta.mean_diff.mini_meta + assert mm.bca_low < mm.difference < mm.bca_high + + +def test_other_effect_sizes_and_plot_with_clusters(clustered): + import matplotlib + + matplotlib.use("Agg") + assert len(clustered.median_diff.results) == 2 + fig = clustered.mean_diff.plot() + assert fig is not None + + +# --------------------------------------------------------------------------- +# Validation +# --------------------------------------------------------------------------- +def test_cluster_col_validation(): + with pytest.raises(IndexError, match="not a column"): + load(DF, cluster_col="missing", **PAIRED_KWARGS) + + with pytest.raises(ValueError, match="same column as `y`"): + load(DF, cluster_col="Y", **PAIRED_KWARGS) + + bad = DF.copy() + bad.loc[0, "ID"] = "P99" # one row of pair 0 now belongs to another participant + with pytest.raises(ValueError, match="single cluster"): + load(bad, cluster_col="ID", **PAIRED_KWARGS) + + bad = DF.copy() + bad.loc[0, "ID"] = None + with pytest.raises(ValueError, match="missing values"): + load(bad, cluster_col="ID", **PAIRED_KWARGS) + + wide = DF.pivot(index="pair", columns="Level", values="Y").reset_index() + with pytest.raises(ValueError, match="one of the groups"): + load(wide, idx=("L1", "L2"), paired="sequential", id_col="pair", cluster_col="L1") + + +def test_two_groups_effect_size_direct_api(): + rng = np.random.default_rng(2) + control = rng.normal(0, 1, 8) + test = rng.normal(0.5, 1, 8) + clusters = np.repeat([0, 1, 2, 3], 2) + + result = TwoGroupsEffectSize( + control, test, "mean_diff", is_paired="baseline", resamples=200, + control_clusters=clusters, test_clusters=clusters, + ) + assert result.is_clustered + assert result.n_clusters == 4 + assert result.to_dict()["n_clusters"] == 4 + + plain = TwoGroupsEffectSize(control, test, "mean_diff", is_paired="baseline", resamples=200) + assert not plain.is_clustered + assert plain.n_clusters is None + + with pytest.raises(ValueError, match="same lengths"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, control_clusters=clusters[:4], test_clusters=clusters) + + with pytest.raises(ValueError, match="Both"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, control_clusters=clusters) + + with pytest.raises(ValueError, match="same cluster"): + TwoGroupsEffectSize( + control, test, "mean_diff", is_paired="baseline", resamples=200, + control_clusters=clusters, test_clusters=clusters[::-1], + ) + + +def test_cluster_permutation_test(): + rng = np.random.default_rng(4) + control = rng.normal(0, 1, 12) + test = control + 1.0 + clusters = np.repeat([0, 1, 2, 3], 3) + + # Paired: with a constant difference of 1 in every pair, each cluster-level + # sign flip changes the mean difference by a multiple of 2 * 3 / 12. + paired = PermutationTest( + control, test, "mean_diff", is_paired="baseline", permutation_count=200, + control_clusters=clusters, test_clusters=clusters, + ) + assert 0 <= paired.pvalue <= 1 + assert set(np.round(paired.permutations, 10)).issubset({-1.0, -0.5, 0.0, 0.5, 1.0}) + + # Unpaired with shared clusters, adjusted p-value. + shared = PermutationTest( + control, test, "mean_diff", permutation_count=200, ps_adjust=True, + control_clusters=clusters, test_clusters=clusters, + ) + assert 0 <= shared.pvalue <= 1 + assert len(shared.permutations_var) == 200 + + # Unpaired with nested clusters, adjusted p-value. + nested = PermutationTest( + control, test, "mean_diff", permutation_count=200, ps_adjust=True, + control_clusters=clusters, test_clusters=clusters + 10, + ) + assert 0 <= nested.pvalue <= 1 diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index de380b59..11c80d29 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -638,6 +638,394 @@ "multi_baseline_repeated_measures.mean_diff.plot();" ] }, + { + "cell_type": "markdown", + "id": "3e06bc8e", + "metadata": {}, + "source": [ + "## Cluster-correlated data: several pairs per participant\n", + "\n", + "The repeated-measures plots above assume that every row of `id_col` is an\n", + "independent pair. In many within-subjects experiments, however, each\n", + "participant contributes *several* sets of paired observations, for example\n", + "by rating several stimuli under each condition. Pairs from the same\n", + "participant are then correlated, and resampling them as if they were\n", + "independent (a form of pseudoreplication) produces confidence intervals\n", + "that are too narrow and permutation p-values that are too small.\n", + "\n", + "`dabest.load()` handles this with the `cluster_col` argument, which names the\n", + "column identifying the independent sampling unit (the *cluster*, here the\n", + "participant) that every observation belongs to. `id_col` still identifies\n", + "the pairs, and `cluster_col` identifies the units the pairs are nested in:\n", + "\n", + "- the bootstrap resamples whole participants with replacement, keeping all\n", + " of a participant's pairs together (a *cluster bootstrap*), and\n", + "- the permutation test swaps control and test labels for whole participants\n", + " at a time.\n", + "\n", + "Every pair must belong to a single cluster. `cluster_col` also works for\n", + "unpaired data, where a participant may contribute several observations to\n", + "each group. The parametric and rank-based tests reported by\n", + "`.statistical_tests` are unchanged and still treat every observation as\n", + "independent, so prefer the bootstrap interval and the permutation p-value\n", + "when the data are clustered.\n", + "\n", + "Let us simulate such an experiment, in which each participant's sensitivity\n", + "to the treatment varies:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "97e41158", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParticipantPairConditionScore
0P000Control3.308213
1P000Test 14.157010
2P000Test 25.310708
3P000Test 36.217601
4P001Control1.292431
5P001Test 12.661625
6P001Test 23.387853
7P001Test 34.506913
\n", + "
" + ], + "text/plain": [ + " Participant Pair Condition Score\n", + "0 P00 0 Control 3.308213\n", + "1 P00 0 Test 1 4.157010\n", + "2 P00 0 Test 2 5.310708\n", + "3 P00 0 Test 3 6.217601\n", + "4 P00 1 Control 1.292431\n", + "5 P00 1 Test 1 2.661625\n", + "6 P00 1 Test 2 3.387853\n", + "7 P00 1 Test 3 4.506913" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(2024)\n", + "\n", + "n_participants, n_stimuli = 15, 5\n", + "conditions = [\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"]\n", + "rows = []\n", + "for participant in range(n_participants):\n", + " sensitivity = np.random.normal(1, 0.4) # participant-specific response to the treatment\n", + " for stimulus in range(n_stimuli):\n", + " baseline = np.random.normal(3, 0.5)\n", + " for k, condition in enumerate(conditions):\n", + " rows.append({\"Participant\": \"P{:02d}\".format(participant),\n", + " \"Pair\": participant * n_stimuli + stimulus,\n", + " \"Condition\": condition,\n", + " \"Score\": baseline + 0.5 * k * sensitivity + np.random.normal(0, 0.3)})\n", + "\n", + "clustered_df = pd.DataFrame(rows)\n", + "clustered_df.head(8)" + ] + }, + { + "cell_type": "markdown", + "id": "c2dda2ee", + "metadata": {}, + "source": [ + "Loading the data with `id_col` alone treats the 75 pairs as independent.\n", + "Adding `cluster_col=\"Participant\"` resamples the 15 participants instead:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a33a5d4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good evening!\n", + "The current time is Wed Sep 16 21:59:31 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 1 is 0.589 [95%CI 0.447, 0.744].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 2 is 1.24 [95%CI 1.0, 1.49].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 3 is 1.78 [95%CI 1.42, 2.12].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated.\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pairs_only = dabest.load(clustered_df, idx=(\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"),\n", + " x=\"Condition\", y=\"Score\",\n", + " paired=\"baseline\", id_col=\"Pair\")\n", + "\n", + "by_participant = dabest.load(clustered_df, idx=(\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"),\n", + " x=\"Condition\", y=\"Score\",\n", + " paired=\"baseline\", id_col=\"Pair\",\n", + " cluster_col=\"Participant\")\n", + "\n", + "by_participant.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "b7565cc1", + "metadata": {}, + "source": [ + "The paired mean differences are identical, but the cluster-aware confidence\n", + "intervals are wider because they reflect the between-participant variation\n", + "in the treatment effect. The number of clusters resampled is reported in the\n", + "`n_clusters` column of the results:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3953893f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
controltestdifferencebca_lowbca_highpvalue_permutationn_clusters
pairs resampled (id_col only)0ControlTest 10.5886220.4798060.6967050.0NaN
1ControlTest 21.2416031.1077751.3864820.0NaN
2ControlTest 31.7788281.6062551.9577610.0NaN
participants resampled (cluster_col)0ControlTest 10.5886220.4473070.7442000.015.0
1ControlTest 21.2416031.0018191.4871590.015.0
2ControlTest 31.7788281.4156822.1228700.015.0
\n", + "
" + ], + "text/plain": [ + " control ... n_clusters\n", + "pairs resampled (id_col only) 0 Control ... NaN\n", + " 1 Control ... NaN\n", + " 2 Control ... NaN\n", + "participants resampled (cluster_col) 0 Control ... 15.0\n", + " 1 Control ... 15.0\n", + " 2 Control ... 15.0\n", + "\n", + "[6 rows x 7 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = [\"control\", \"test\", \"difference\", \"bca_low\", \"bca_high\", \"pvalue_permutation\"]\n", + "pd.concat({\"pairs resampled (id_col only)\": pairs_only.mean_diff.results[columns],\n", + " \"participants resampled (cluster_col)\": by_participant.mean_diff.results[columns + [\"n_clusters\"]]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db75c6cb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "by_participant.mean_diff.plot();" + ] + }, { "cell_type": "markdown", "id": "9a08d862", From 41eb26ad5b07e3d6417afdd924b932ca9424fd2b Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Thu, 17 Sep 2026 10:33:44 +0100 Subject: [PATCH 2/8] fix: permutation test Bug (fixed): for unpaired data where the same clusters appear in both groups, the permutation test reshuffled labels within each cluster. That tests the strong null of no effect in any participant, so participant-specific effects that average to zero still caused rejections: 20% at the 5% level. It now swaps each cluster's whole control and test sets, the direct analogue of the paired sign flip. After the fix it rejects 3% at the 5% level and 10% at the 10% level. See dabest/_effsize_objects.py:1885. --- dabest/_api.py | 4 +- dabest/_effsize_objects.py | 63 ++++++++++++++++++++--------- nbs/API/effsize_objects.ipynb | 63 ++++++++++++++++++++--------- nbs/API/load.ipynb | 4 +- nbs/tests/test_cluster_bootstrap.py | 21 ++++++++++ 5 files changed, 113 insertions(+), 42 deletions(-) diff --git a/dabest/_api.py b/dabest/_api.py index d81ae521..f82e1d0d 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -95,7 +95,9 @@ def load( contributes several observations, or several pairs of paired observations. When supplied, the bootstrap resamples whole clusters with replacement (a cluster bootstrap) and the permutation test - reshuffles labels at the cluster level, so that the confidence + reshuffles labels at the cluster level (swapping the control and test + observations of whole clusters, or reassigning whole clusters between + groups when clusters are nested within groups), so that the confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works with both unpaired data and paired data (`paired` with `id_col`): for paired data, `id_col` diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 8ed64a4f..1e11b56c 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -298,10 +298,16 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): + "effect size (or greater),\nassuming the null hypothesis of " + "zero difference is true." ) - pval_def2 = ( - "\nFor each p-value, 5000 reshuffles of the " - + "control and test labels were performed." - ) + if self.__is_clustered: + pval_def2 = ( + "\nFor each p-value, 5000 reshuffles of the control and test labels " + + "were performed at the level of whole clusters." + ) + else: + pval_def2 = ( + "\nFor each p-value, 5000 reshuffles of the " + + "control and test labels were performed." + ) pval_def = pval_def1 + pval_def2 if show_resample_count and define_pval: @@ -1659,6 +1665,9 @@ def statistical_tests(self): "bca_high", ] + if "n_clusters" in results_df.columns: + default_cols.insert(default_cols.index("effect_size"), "n_clusters") + cols_of_interest = default_cols + stats_columns return results_df[cols_of_interest] @@ -1785,6 +1794,14 @@ def is_delta_delta(self): return self.__delta2 # %% ../nbs/API/effsize_objects.ipynb #5d49f77f +def _count_sign_patterns(n): + """The number of ways to swap or not swap each of `n` clusters, as a float.""" + try: + return float(2 ** int(n)) + except OverflowError: + return float("inf") + + class PermutationTest: """ A class to compute and report permutation tests. @@ -1814,8 +1831,10 @@ class PermutationTest: level: for paired data, control and test are swapped for whole clusters at a time; for unpaired data with clusters nested within groups, whole clusters are reassigned between the groups; and for unpaired data with - clusters spanning both groups, the group labels are reshuffled within - each cluster. + clusters spanning both groups, each cluster's control and test + observations are swapped as whole sets. In every case the observations + within a cluster are kept together, so that heterogeneity of the effect + between clusters is reflected in the null distribution. Returns @@ -1896,7 +1915,7 @@ def __init__(self, control: array, raise ValueError(err1 + err2) # Control and test are swapped for whole clusters at a time; each # pattern of swaps and its mirror image give the same |effect size|. - totalPermutations = 2.0 ** n_clusters / 2 + totalPermutations = _count_sign_patterns(n_clusters) / 2 else: bag_codes = array([*control_codes, *test_codes]) offsets, members = cluster_tables(bag_codes, n_clusters) @@ -1907,15 +1926,18 @@ def __init__(self, control: array, ) if clusters_shared: - # Clusters contribute to both groups: the group labels are - # reshuffled within each cluster. In the bag sorted by cluster, - # the first `control_per_cluster[g]` slots of cluster g are - # assigned to control. - slot = arange(len(BAG)) - repeat(offsets[:-1], cluster_sizes) - control_slot = slot < repeat(control_per_cluster, cluster_sizes) - totalPermutations = float( - np.prod([binomcoeff(n, k) for n, k in zip(cluster_sizes, control_per_cluster)]) - ) + # Clusters contribute to both groups: a cluster's control and + # test observations are swapped as whole sets (the analogue of + # the paired sign flip). Clusters present in one group only + # are left where they are. + shared_cluster = (control_per_cluster > 0) & (control_per_cluster < cluster_sizes) + n_shared = int(shared_cluster.sum()) + is_control = arange(len(BAG)) < CONTROL_LEN + if n_shared == n_clusters: + # Swapping every cluster mirrors the effect size exactly. + totalPermutations = _count_sign_patterns(n_shared) / 2 + else: + totalPermutations = _count_sign_patterns(n_shared) else: # Clusters are nested within groups: whole clusters are # reassigned between the control and test groups. @@ -1937,10 +1959,11 @@ def __init__(self, control: array, test_sample = np.where(flip, control, test) elif is_clustered and clusters_shared: - # Reshuffle the group labels within each cluster. - order = np.lexsort((rng.random_sample(len(BAG)), bag_codes)) - control_sample = BAG[order[control_slot]] - test_sample = BAG[order[~control_slot]] + # Swap the control and test sets of randomly chosen shared clusters. + swap = rng.randint(0, 2, n_clusters).astype(bool) & shared_cluster + new_is_control = is_control ^ swap[bag_codes] + control_sample = BAG[new_is_control] + test_sample = BAG[~new_is_control] elif is_clustered: # Reassign whole clusters between the control and test groups. diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 3f6ff917..6452589b 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -392,10 +392,16 @@ " + \"effect size (or greater),\\nassuming the null hypothesis of \"\n", " + \"zero difference is true.\"\n", " )\n", - " pval_def2 = (\n", - " \"\\nFor each p-value, 5000 reshuffles of the \"\n", - " + \"control and test labels were performed.\"\n", - " )\n", + " if self.__is_clustered:\n", + " pval_def2 = (\n", + " \"\\nFor each p-value, 5000 reshuffles of the control and test labels \"\n", + " + \"were performed at the level of whole clusters.\"\n", + " )\n", + " else:\n", + " pval_def2 = (\n", + " \"\\nFor each p-value, 5000 reshuffles of the \"\n", + " + \"control and test labels were performed.\"\n", + " )\n", " pval_def = pval_def1 + pval_def2\n", "\n", " if show_resample_count and define_pval:\n", @@ -1868,6 +1874,9 @@ " \"bca_high\",\n", " ]\n", "\n", + " if \"n_clusters\" in results_df.columns:\n", + " default_cols.insert(default_cols.index(\"effect_size\"), \"n_clusters\")\n", + "\n", " cols_of_interest = default_cols + stats_columns\n", "\n", " return results_df[cols_of_interest]\n", @@ -2318,6 +2327,14 @@ "outputs": [], "source": [ "#| export\n", + "def _count_sign_patterns(n):\n", + " \"\"\"The number of ways to swap or not swap each of `n` clusters, as a float.\"\"\"\n", + " try:\n", + " return float(2 ** int(n))\n", + " except OverflowError:\n", + " return float(\"inf\")\n", + "\n", + "\n", "class PermutationTest:\n", " \"\"\"\n", " A class to compute and report permutation tests.\n", @@ -2347,8 +2364,10 @@ " level: for paired data, control and test are swapped for whole clusters\n", " at a time; for unpaired data with clusters nested within groups, whole\n", " clusters are reassigned between the groups; and for unpaired data with\n", - " clusters spanning both groups, the group labels are reshuffled within\n", - " each cluster.\n", + " clusters spanning both groups, each cluster's control and test\n", + " observations are swapped as whole sets. In every case the observations\n", + " within a cluster are kept together, so that heterogeneity of the effect\n", + " between clusters is reflected in the null distribution.\n", "\n", " \n", " Returns\n", @@ -2429,7 +2448,7 @@ " raise ValueError(err1 + err2)\n", " # Control and test are swapped for whole clusters at a time; each\n", " # pattern of swaps and its mirror image give the same |effect size|.\n", - " totalPermutations = 2.0 ** n_clusters / 2\n", + " totalPermutations = _count_sign_patterns(n_clusters) / 2\n", " else:\n", " bag_codes = array([*control_codes, *test_codes])\n", " offsets, members = cluster_tables(bag_codes, n_clusters)\n", @@ -2440,15 +2459,18 @@ " )\n", "\n", " if clusters_shared:\n", - " # Clusters contribute to both groups: the group labels are\n", - " # reshuffled within each cluster. In the bag sorted by cluster,\n", - " # the first `control_per_cluster[g]` slots of cluster g are\n", - " # assigned to control.\n", - " slot = arange(len(BAG)) - repeat(offsets[:-1], cluster_sizes)\n", - " control_slot = slot < repeat(control_per_cluster, cluster_sizes)\n", - " totalPermutations = float(\n", - " np.prod([binomcoeff(n, k) for n, k in zip(cluster_sizes, control_per_cluster)])\n", - " )\n", + " # Clusters contribute to both groups: a cluster's control and\n", + " # test observations are swapped as whole sets (the analogue of\n", + " # the paired sign flip). Clusters present in one group only\n", + " # are left where they are.\n", + " shared_cluster = (control_per_cluster > 0) & (control_per_cluster < cluster_sizes)\n", + " n_shared = int(shared_cluster.sum())\n", + " is_control = arange(len(BAG)) < CONTROL_LEN\n", + " if n_shared == n_clusters:\n", + " # Swapping every cluster mirrors the effect size exactly.\n", + " totalPermutations = _count_sign_patterns(n_shared) / 2\n", + " else:\n", + " totalPermutations = _count_sign_patterns(n_shared)\n", " else:\n", " # Clusters are nested within groups: whole clusters are\n", " # reassigned between the control and test groups.\n", @@ -2470,10 +2492,11 @@ " test_sample = np.where(flip, control, test)\n", "\n", " elif is_clustered and clusters_shared:\n", - " # Reshuffle the group labels within each cluster.\n", - " order = np.lexsort((rng.random_sample(len(BAG)), bag_codes))\n", - " control_sample = BAG[order[control_slot]]\n", - " test_sample = BAG[order[~control_slot]]\n", + " # Swap the control and test sets of randomly chosen shared clusters.\n", + " swap = rng.randint(0, 2, n_clusters).astype(bool) & shared_cluster\n", + " new_is_control = is_control ^ swap[bag_codes]\n", + " control_sample = BAG[new_is_control]\n", + " test_sample = BAG[~new_is_control]\n", "\n", " elif is_clustered:\n", " # Reassign whole clusters between the control and test groups.\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index 85d165a3..c81fd4aa 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -142,7 +142,9 @@ " contributes several observations, or several pairs of paired\n", " observations. When supplied, the bootstrap resamples whole clusters\n", " with replacement (a cluster bootstrap) and the permutation test\n", - " reshuffles labels at the cluster level, so that the confidence\n", + " reshuffles labels at the cluster level (swapping the control and test\n", + " observations of whole clusters, or reassigning whole clusters between\n", + " groups when clusters are nested within groups), so that the confidence\n", " intervals and permutation p-values account for the correlation between\n", " observations from the same cluster. This works with both unpaired data\n", " and paired data (`paired` with `id_col`): for paired data, `id_col`\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py index 29f38bb3..826396d8 100644 --- a/nbs/tests/test_cluster_bootstrap.py +++ b/nbs/tests/test_cluster_bootstrap.py @@ -323,6 +323,27 @@ def test_cluster_permutation_test(): assert 0 <= shared.pvalue <= 1 assert len(shared.permutations_var) == 200 + # Shared clusters are permuted by swapping each cluster's control and test + # sets as a whole. When the two sets of every cluster hold the same values, + # no swap can change the effect size, whereas reshuffling observations + # within clusters would. + values = np.array([1.0, 5.0, 2.0, 8.0, 3.0, 9.0]) + sets = np.repeat([0, 1, 2], 2) + identical = PermutationTest( + values, values, "mean_diff", permutation_count=100, + control_clusters=sets, test_clusters=sets, + ) + assert np.allclose(identical.permutations, 0.0) + + # When every cluster's sets differ by a constant, the permutation effect + # sizes can only take the values produced by whole-set swaps. + shifted = PermutationTest( + values, values + 2.0, "mean_diff", permutation_count=100, + control_clusters=sets, test_clusters=sets, + ) + allowed = {-2.0, -2 / 3, 2 / 3, 2.0} + assert all(any(np.isclose(v, a) for a in allowed) for v in shifted.permutations) + # Unpaired with nested clusters, adjusted p-value. nested = PermutationTest( control, test, "mean_diff", permutation_count=200, ps_adjust=True, From 25053aeb64dc8c2d1e8f2ca3afbf6f70a2a584bb Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Thu, 17 Sep 2026 11:18:58 +0100 Subject: [PATCH 3/8] chore: clarified docs and examples for baseline error curve Baseline error curve documentation did not mention the details that make its use questionable to paired or clustered analyses. show_baseline_ec docstring (dabest/_effsize_objects.py:1584): now explains what the curve actually computes, states plainly that it's always an unpaired self-comparison regardless of paired, and calls out the scale mismatch with cluster_col. cluster_col docstring (dabest/_api.py:92): adds a pointer to that same caveat, since a user reading about cluster_col alone wouldn't otherwise know it affects the baseline curve disproportionately. Plot Aesthetics tutorial (08-plot_aesthetics.ipynb): rewrote the "Baseline error curve" section and added a new subsection with a worked, executed example. It builds a 15-participant, 3-pairs-each dataset and plots the same comparison with id_col alone versus id_col plus cluster_col, side by side. The real paired contrast stays essentially unchanged between the two; the baseline curve at the "Control" position visibly widens, from a 95% width of about 1.2 to about 2.0 in this example. That's the same phenomenon you flagged, reproduced deliberately and small enough to read at a glance, rather than buried in a large real dataset. Changelog: added a Documentation entry alongside the existing cluster-aware bootstrap entry. --- CHANGELOG.md | 3 + dabest/_api.py | 5 +- dabest/_effsize_objects.py | 20 ++++- nbs/API/effsize_objects.ipynb | 20 ++++- nbs/API/load.ipynb | 5 +- nbs/tutorials/08-plot_aesthetics.ipynb | 111 ++++++++++++++++++++++++- 6 files changed, 151 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 40ad8b48..be486f0f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,9 @@ ### New Features 1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. +### Documentation +1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. + ## v2025.10.20 ### New Features diff --git a/dabest/_api.py b/dabest/_api.py index f82e1d0d..5d134c86 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -104,7 +104,10 @@ def load( identifies the pairs and `cluster_col` the units the pairs are nested in, and every pair must belong to a single cluster. The parametric and rank-based tests reported in `statistical_tests` do not account for - clustering. + clustering. Note that the baseline error curve shown by + `.plot(show_baseline_ec=True)` is always an unpaired comparison (see + that argument's docstring), so with `cluster_col` set it can become + much wider than a paired analysis's real effect-size curves. Returns ------- diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 1e11b56c..878057c1 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -1582,10 +1582,22 @@ def plot( {"linestyle": "-", "linewidth": 2, "zorder": -2, "color": 'dimgray', "alpha": 1} show_baseline_ec : boolean, default False - Whether or not to display the baseline error curve. The baseline error curve - represents the distribution of the effect size when comparing the control - group to itself, providing a reference for the inherent variability or noise - in the data. When True, this curve is plotted alongside the main effect size + Whether or not to display the baseline error curve (bec). The bec is the + bootstrap distribution obtained by comparing the leftmost ("control") group + of each `idx` tuple to a resample of itself, so that its own difference is + 0 and its spread shows the sampling noise inherent to that group alone. It + is always computed as an *unpaired* comparison, even when `paired` is set + for the main analysis, because it stands in for "no relationship between + the two sides of the comparison" rather than for the design actually used. + For a paired analysis this means the bec is not directly comparable in + scale to the real (paired) effect-size curves: pairing removes shared + between-subject variation from the real curves but not from the bec, and + when `cluster_col` is set this asymmetry is amplified, since the bec then + resamples whole clusters against an independent resample of themselves, + while the real paired curves largely cancel the between-cluster variation. + The bec can be much wider than the real curves in that case, and may need + its own `contrast_ylim`; see the Plot Aesthetics tutorial for an example. + When True, this curve is plotted alongside the main effect size distribution, allowing for a visual comparison of the observed effect against the baseline variability. diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 6452589b..204ad7c0 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -1791,10 +1791,22 @@ " {\"linestyle\": \"-\", \"linewidth\": 2, \"zorder\": -2, \"color\": 'dimgray', \"alpha\": 1}\n", " \n", "\t\tshow_baseline_ec : boolean, default False\n", - " Whether or not to display the baseline error curve. The baseline error curve\n", - " represents the distribution of the effect size when comparing the control\n", - " group to itself, providing a reference for the inherent variability or noise\n", - " in the data. When True, this curve is plotted alongside the main effect size\n", + " Whether or not to display the baseline error curve (bec). The bec is the\n", + " bootstrap distribution obtained by comparing the leftmost (\"control\") group\n", + " of each `idx` tuple to a resample of itself, so that its own difference is\n", + " 0 and its spread shows the sampling noise inherent to that group alone. It\n", + " is always computed as an *unpaired* comparison, even when `paired` is set\n", + " for the main analysis, because it stands in for \"no relationship between\n", + " the two sides of the comparison\" rather than for the design actually used.\n", + " For a paired analysis this means the bec is not directly comparable in\n", + " scale to the real (paired) effect-size curves: pairing removes shared\n", + " between-subject variation from the real curves but not from the bec, and\n", + " when `cluster_col` is set this asymmetry is amplified, since the bec then\n", + " resamples whole clusters against an independent resample of themselves,\n", + " while the real paired curves largely cancel the between-cluster variation.\n", + " The bec can be much wider than the real curves in that case, and may need\n", + " its own `contrast_ylim`; see the Plot Aesthetics tutorial for an example.\n", + " When True, this curve is plotted alongside the main effect size\n", " distribution, allowing for a visual comparison of the observed effect against\n", " the baseline variability.\n", "\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index c81fd4aa..d1df73ca 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -151,7 +151,10 @@ " identifies the pairs and `cluster_col` the units the pairs are nested\n", " in, and every pair must belong to a single cluster. The parametric and\n", " rank-based tests reported in `statistical_tests` do not account for\n", - " clustering.\n", + " clustering. Note that the baseline error curve shown by\n", + " `.plot(show_baseline_ec=True)` is always an unpaired comparison (see\n", + " that argument's docstring), so with `cluster_col` set it can become\n", + " much wider than a paired analysis's real effect-size curves.\n", "\n", " Returns\n", " -------\n", diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index 5d20a4aa..5a134246 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2107,13 +2107,19 @@ }, { "cell_type": "markdown", - "id": "e3969990", + "id": "a07fa970", "metadata": {}, "source": [ "## Baseline error curve\n", "\n", - "In DABEST **v2025.03.27**, we introduce a new aspect to the contrast axes: the baseline dot and error curve. \n", - "While the baseline dot is always present, the error curve can be turned on by setting `show_baseline_ec=True` in the `.plot()` method." + "In DABEST **v2025.03.27**, we introduced a new aspect to the contrast axes: the baseline dot and error curve.\n", + "While the baseline dot is always present, the error curve can be turned on by setting `show_baseline_ec=True` in the `.plot()` method.\n", + "\n", + "The baseline error curve (bec) is a *reference*, not a second comparison. For the leftmost (\"control\") group of\n", + "each `idx` tuple, DABEST draws bootstrap resamples of that group and compares them to independent bootstrap\n", + "resamples of the very same group, giving a bootstrap distribution centred on 0 whose spread reflects the sampling\n", + "noise inherent to that group alone. It is a visual gauge for \"how wide would a comparison look if there were no\n", + "effect at all\", which the real effect-size curves can be judged against." ] }, { @@ -2136,6 +2142,105 @@ "source": [ "repeated_measures.mean_diff.plot(show_baseline_ec=True); " ] + }, + { + "cell_type": "markdown", + "id": "0377c3e2", + "metadata": {}, + "source": [ + "A key detail, not obvious from the plot alone: **the bec is always computed as an unpaired comparison**,\n", + "even when the main analysis uses `paired=\"baseline\"` or `paired=\"sequential\"`. This is because the bec stands in\n", + "for \"no relationship between the two sides\", so pairing (which assumes a real, shared relationship) would not\n", + "make sense for it. For most datasets this distinction barely matters and the bec looks like a modest reference\n", + "band, as above.\n", + "\n", + "### Baseline error curve with clustered (repeated-measures) data\n", + "\n", + "The unpaired-only nature of the bec interacts with `cluster_col` (see the\n", + "[Shared Control & Repeated Measures tutorial](03-shared_control_and_repeated_measures.html#cluster-correlated-data-several-pairs-per-participant))\n", + "in a way worth knowing about. When a participant contributes several pairs of observations, the *real* paired\n", + "effect-size curves mostly cancel out each participant's own baseline level, so cluster-aware resampling barely\n", + "widens them. The bec gets no such cancellation, because it is always unpaired: it resamples whole participants\n", + "against an independent resample of the same participants, so its width is set by how much participants differ\n", + "from each other, divided by the number of participants, rather than by the number of rows. If participants vary\n", + "a lot in their average response, the bec can become far wider than the real contrasts once `cluster_col` is set,\n", + "even though nothing is wrong with either curve. Rescale `contrast_ylim` to fit it, or set `show_baseline_ec=False`\n", + "for plots where the reference curve is not the point.\n", + "\n", + "Let's demonstrate with a small repeated-measures dataset where 15 participants each contribute 3 pairs of\n", + "observations, and participants vary considerably in their average score:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae800dbf", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(101)\n", + "\n", + "n_participants, n_pairs = 15, 3\n", + "participant_level = np.random.normal(0, 1.2, n_participants) # participants differ a lot from each other\n", + "\n", + "rows = []\n", + "for p in range(n_participants):\n", + " for s in range(n_pairs):\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p),\n", + " \"Pair\": p * n_pairs + s,\n", + " \"Control\": 3 + participant_level[p] + np.random.normal(0, 0.4),\n", + " \"Test\": 3 + participant_level[p] + 0.5 + np.random.normal(0, 0.4)})\n", + "\n", + "bec_demo_df = pd.DataFrame(rows)\n", + "\n", + "bec_demo_naive = dabest.load(bec_demo_df, idx=(\"Control\", \"Test\"),\n", + " paired=\"baseline\", id_col=\"Pair\")\n", + "bec_demo_clustered = dabest.load(bec_demo_df, idx=(\"Control\", \"Test\"),\n", + " paired=\"baseline\", id_col=\"Pair\",\n", + " cluster_col=\"Participant\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adc27763", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# `float_contrast=False` is used here so the baseline dot and error curve\n", + "# (plotted at the \"Control\" position) share the same axis as the real\n", + "# comparison, rather than the default floating Gardner-Altman axis, which\n", + "# only has room for the single \"Test minus Control\" delta.\n", + "f, axx = plt.subplots(ncols=2, figsize=(11, 5), gridspec_kw={\"wspace\": 0.35})\n", + "\n", + "bec_demo_naive.mean_diff.plot(show_baseline_ec=True, float_contrast=False, ax=axx[0],\n", + " contrast_ylim=(-1.5, 1.5), title=\"id_col only\");\n", + "bec_demo_clustered.mean_diff.plot(show_baseline_ec=True, float_contrast=False, ax=axx[1],\n", + " contrast_ylim=(-1.5, 1.5), title=\"id_col + cluster_col\");" + ] + }, + { + "cell_type": "markdown", + "id": "c900d30e", + "metadata": {}, + "source": [ + "The real paired mean difference (the black dot and violin above \"Test minus Control\") is nearly\n", + "identical between the two plots. The baseline error curve at the \"Control\" position, however, is visibly wider\n", + "once `cluster_col` accounts for the fact that these 15 participants (not 45 independent pairs) are the real\n", + "resampling unit — and at higher between-participant variance, or with a stronger effect of participant count, it\n", + "can extend beyond a `contrast_ylim` that comfortably fits the real contrasts." + ] } ], "metadata": { From 2a10cf07b6109cd83ef3f0a560855069dcf23423 Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Mon, 21 Sep 2026 10:38:20 +0100 Subject: [PATCH 4/8] docs: cluster-aware bootstrap tutorial and additions Added new tutorial to demonstrate the use and value of the cluster-aware bootstrap feature, and added hooks in associated notebooks. --- CHANGELOG.md | 1 + ...shared_control_and_repeated_measures.ipynb | 8 + nbs/tutorials/08-plot_aesthetics.ipynb | 6 +- .../11-cluster_robust_bootstrap.ipynb | 882 ++++++++++++++++++ 4 files changed, 895 insertions(+), 2 deletions(-) create mode 100644 nbs/tutorials/11-cluster_robust_bootstrap.ipynb diff --git a/CHANGELOG.md b/CHANGELOG.md index be486f0f..da32d759 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ ### Documentation 1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. +2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that the naive dummy-ID bootstrap's 95% interval excludes zero (p = 0.0026, conventionally "significant") while the cluster-aware interval for the identical data spans zero (p = 0.087, "not significant"), making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, while the cluster-aware interval recovers to about 90%. ## v2025.10.20 diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index 11c80d29..edc00294 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -1026,6 +1026,14 @@ "by_participant.mean_diff.plot();" ] }, + { + "cell_type": "markdown", + "id": "2fbb942d", + "metadata": {}, + "source": [ + "For a deeper look at why this matters, including a simulation showing how often each method's confidence interval actually contains a known true effect, see the [Cluster-Robust Bootstrap for Repeated Measures](11-cluster_robust_bootstrap.html) tutorial." + ] + }, { "cell_type": "markdown", "id": "9a08d862", diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index 5a134246..d1724b2f 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2145,7 +2145,7 @@ }, { "cell_type": "markdown", - "id": "0377c3e2", + "id": "558d2349", "metadata": {}, "source": [ "A key detail, not obvious from the plot alone: **the bec is always computed as an unpaired comparison**,\n", @@ -2168,7 +2168,9 @@ "for plots where the reference curve is not the point.\n", "\n", "Let's demonstrate with a small repeated-measures dataset where 15 participants each contribute 3 pairs of\n", - "observations, and participants vary considerably in their average score:" + "observations, and participants vary considerably in their average score:\n", + "\n", + "For a simulation-based demonstration of why `cluster_col` matters for the real comparisons too, not just the baseline curve, see the [Cluster-Robust Bootstrap for Repeated Measures](11-cluster_robust_bootstrap.html) tutorial." ] }, { diff --git a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb new file mode 100644 index 00000000..ff3753ad --- /dev/null +++ b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb @@ -0,0 +1,882 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8cca6a3d", + "metadata": {}, + "source": [ + "# Cluster-Robust Bootstrap for Repeated Measures\n", + "\n", + "> A worked, simulation-based example of `cluster_col`, for designs where a single participant contributes several sets of paired observations.\n", + "\n", + "- order: 11" + ] + }, + { + "cell_type": "markdown", + "id": "b65c5815", + "metadata": {}, + "source": [ + "## The problem: pairs nested within participants\n", + "\n", + "DABEST's `paired` and `id_col` arguments handle the common repeated-measures case where every\n", + "participant contributes exactly one paired observation (one row of `id_col`). Some experiments,\n", + "though, ask each participant to provide *several* paired comparisons: several stimuli rated under\n", + "each of two conditions, several trials of a before/after manipulation, and so on. A common\n", + "workaround is to build a \"dummy\" pairing ID for each set, for example with\n", + "\n", + "```python\n", + "data[\"dummyID\"] = data.groupby([\"ParticipantID\", \"OtherGroupingVars\"]).ngroup()\n", + "```\n", + "\n", + "so that `id_col=\"dummyID\"` pairs each set correctly. This gets the *point estimate* right: an\n", + "average of several valid within-participant differences is still an unbiased estimate of the\n", + "average effect. It does not get the *uncertainty* right, because the bootstrap has no way of\n", + "knowing that several dummy IDs came from the same participant. It resamples dummy IDs as if\n", + "they were independent, which is a form of pseudoreplication: participants who happen to be drawn\n", + "more than once contribute more than once to a resample, but their sets are correlated with each\n", + "other, not independent new evidence, so the resulting interval is typically too narrow.\n", + "\n", + "`cluster_col` fixes this by naming the column that identifies the actual independent sampling\n", + "unit (the participant). With it set, the bootstrap resamples whole participants with replacement,\n", + "keeping all of a participant's sets together in every resample, and the permutation test\n", + "reshuffles labels at the participant level too. See the\n", + "[Shared Control & Repeated Measures tutorial](03-shared_control_and_repeated_measures.html#cluster-correlated-data-several-pairs-per-participant)\n", + "for the basic mechanics, and the\n", + "[Plot Aesthetics tutorial](08-plot_aesthetics.html#baseline-error-curve-with-clustered-repeated-measures-data)\n", + "for how it interacts with the baseline error curve. This tutorial instead focuses on *why it\n", + "matters*: because we simulate the data ourselves, we know the true effect, and can check directly\n", + "whether each method's confidence interval actually contains it as often as it claims to." + ] + }, + { + "cell_type": "markdown", + "id": "3a17decd", + "metadata": {}, + "source": [ + "## Load libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6473d3d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-compiling numba functions for DABEST...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling numba functions: 100%|██████████| 13/13 [00:00<00:00, 27.94it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numba compilation complete!\n", + "We're using DABEST v2025.10.20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import dabest\n", + "\n", + "print(\"We're using DABEST v{}\".format(dabest.__version__))" + ] + }, + { + "cell_type": "markdown", + "id": "7263fd55", + "metadata": {}, + "source": [ + "## Simulating a matching dataset\n", + "\n", + "Fifteen participants each rate six different stimuli under two conditions, `Baseline` and\n", + "`Treatment`, giving each participant six paired sets (`StimSet` plays the role of the dummy\n", + "pairing ID). Participants are not identical: each has their own personal sensitivity to the\n", + "treatment, drawn from a distribution centred on 1. Their true effect is\n", + "`true_effect * sensitivity[participant]`, so someone with a sensitivity of 1.4 shows a 40% larger\n", + "effect than average, and this applies consistently across all six of their stimuli. This\n", + "\"participant differs in how much they respond, not just in their baseline level\" structure is\n", + "exactly what a dummy-ID bootstrap cannot see.\n", + "\n", + "The parameters below are deliberately chosen, not arbitrary. With a modest true effect, considerable\n", + "between-participant variability, and several stimuli per participant driving the sample size up\n", + "without adding genuinely independent evidence, this combination sits exactly where the two methods\n", + "disagree about what counts as a \"real\" effect, which is the whole point of the demonstration." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2dcfc4d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "180 rows, 15 participants, 90 paired sets\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Participant", + "rawType": "object", + "type": "string" + }, + { + "name": "StimSet", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Condition", + "rawType": "object", + "type": "string" + }, + { + "name": "Rating", + "rawType": "float64", + "type": "float" + } + ], + "ref": "f3fac723-0663-4e5e-a275-53409cba16ea", + "rows": [ + [ + "0", + "P00", + "0", + "Treatment", + "6.71267335166737" + ], + [ + "1", + "P00", + "0", + "Baseline", + "5.611587700591365" + ], + [ + "2", + "P00", + "1", + "Treatment", + "7.069194468440081" + ], + [ + "3", + "P00", + "1", + "Baseline", + "5.483890971910106" + ], + [ + "4", + "P00", + "2", + "Treatment", + "6.5238176799938685" + ], + [ + "5", + "P00", + "2", + "Baseline", + "5.515260518749756" + ], + [ + "6", + "P00", + "3", + "Treatment", + "6.771715866260884" + ], + [ + "7", + "P00", + "3", + "Baseline", + "5.460908061097622" + ] + ], + "shape": { + "columns": 4, + "rows": 8 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParticipantStimSetConditionRating
0P000Treatment6.712673
1P000Baseline5.611588
2P001Treatment7.069194
3P001Baseline5.483891
4P002Treatment6.523818
5P002Baseline5.515261
6P003Treatment6.771716
7P003Baseline5.460908
\n", + "
" + ], + "text/plain": [ + " Participant StimSet Condition Rating\n", + "0 P00 0 Treatment 6.712673\n", + "1 P00 0 Baseline 5.611588\n", + "2 P00 1 Treatment 7.069194\n", + "3 P00 1 Baseline 5.483891\n", + "4 P00 2 Treatment 6.523818\n", + "5 P00 2 Baseline 5.515261\n", + "6 P00 3 Treatment 6.771716\n", + "7 P00 3 Baseline 5.460908" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(2024)\n", + "\n", + "n_participants = 15\n", + "n_stimuli = 6 # each participant rates 6 different stimuli per condition\n", + "true_effect = 0.3 # average Treatment-minus-Baseline effect: modest, relative to how much participants vary\n", + "participant_sd = 1.4 # how much participants differ in their OWN sensitivity to the treatment: considerable\n", + "noise_sd = 0.6 # trial-to-trial measurement noise\n", + "\n", + "sensitivity = np.random.normal(1, participant_sd, n_participants)\n", + "\n", + "rows = []\n", + "for p in range(n_participants):\n", + " for s in range(n_stimuli):\n", + " stim_baseline = np.random.normal(5, 1.0) # this stimulus's baseline level for this participant\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p), \"StimSet\": p * n_stimuli + s,\n", + " \"Condition\": \"Baseline\",\n", + " \"Rating\": stim_baseline + np.random.normal(0, noise_sd)})\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p), \"StimSet\": p * n_stimuli + s,\n", + " \"Condition\": \"Treatment\",\n", + " \"Rating\": stim_baseline + true_effect * sensitivity[p] + np.random.normal(0, noise_sd)})\n", + "\n", + "sim_df = pd.DataFrame(rows).sort_values([\"StimSet\", \"Condition\"], ascending=[True, False]).reset_index(drop=True)\n", + "print(\"{} rows, {} participants, {} paired sets\".format(len(sim_df), sim_df[\"Participant\"].nunique(), sim_df[\"StimSet\"].nunique()))\n", + "sim_df.head(8)" + ] + }, + { + "cell_type": "markdown", + "id": "400d2a9f", + "metadata": {}, + "source": [ + "## The dummy-ID (naive) analysis\n", + "\n", + "This is exactly the workflow described above: `id_col=\"StimSet\"` correctly pairs each of the 90\n", + "sets, with no mention yet of which participant each set belongs to." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "61fe4aed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good morning!\n", + "The current time is Mon Sep 21 10:15:37 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Baseline and Treatment is 0.35 [95%CI 0.132, 0.568].\n", + "The p-value of the two-sided permutation t-test is 0.0026, calculated for legacy purposes only. \n", + "\n", + "5000 bootstrap samples were taken; the confidence interval is bias-corrected and accelerated.\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "naive = dabest.load(sim_df, idx=(\"Baseline\", \"Treatment\"),\n", + " x=\"Condition\", y=\"Rating\",\n", + " paired=\"baseline\", id_col=\"StimSet\",\n", + " resamples=5000, random_seed=2024)\n", + "naive.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "05ef4c09", + "metadata": {}, + "source": [ + "## Adding `cluster_col`\n", + "\n", + "The only change is one extra argument, naming the column that identifies each participant. The\n", + "pairing (`id_col`) is unchanged, since the sets themselves are still correctly paired; only the\n", + "*resampling unit* changes, from \"one set\" to \"one participant, and all their sets together\"." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af815b94", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good morning!\n", + "The current time is Mon Sep 21 10:15:41 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Baseline and Treatment is 0.35 [95%CI -0.109, 0.639].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0866, calculated for legacy purposes only. \n", + "\n", + "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated.\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed at the level of whole clusters.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clustered = dabest.load(sim_df, idx=(\"Baseline\", \"Treatment\"), x=\"Condition\", y=\"Rating\",\n", + " paired=\"baseline\", id_col=\"StimSet\", cluster_col=\"Participant\",\n", + " resamples=5000, random_seed=2024)\n", + "clustered.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "c4a70a83", + "metadata": {}, + "source": [ + "Side by side, the point estimate is identical and the interval is wider once `cluster_col` accounts for the fact that 15 participants, not 90 sets, are the real resampling unit:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "64e293da", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "(None, None)", + "rawType": "object", + "type": "unknown" + }, + { + "name": "control", + "rawType": "object", + "type": "string" + }, + { + "name": "test", + "rawType": "object", + "type": "string" + }, + { + "name": "difference", + "rawType": "float64", + "type": "float" + }, + { + "name": "bca_low", + "rawType": "float64", + "type": "float" + }, + { + "name": "bca_high", + "rawType": "float64", + "type": "float" + }, + { + "name": "pvalue_permutation", + "rawType": "float64", + "type": "float" + }, + { + "name": "n_clusters", + "rawType": "float64", + "type": "float" + } + ], + "ref": "c2089106-790a-4fb5-9bba-13c80bd33bd7", + "rows": [ + [ + "('id_col only (naive)', 0)", + "Baseline", + "Treatment", + "0.3495310948462324", + "0.1317644695755602", + "0.5681423855464638", + "0.0026", + null + ], + [ + "('id_col + cluster_col', 0)", + "Baseline", + "Treatment", + "0.3495310948462324", + "-0.10855726048830822", + "0.6393167608301641", + "0.0866", + "15.0" + ] + ], + "shape": { + "columns": 7, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
controltestdifferencebca_lowbca_highpvalue_permutationn_clusters
id_col only (naive)0BaselineTreatment0.3495310.1317640.5681420.0026NaN
id_col + cluster_col0BaselineTreatment0.349531-0.1085570.6393170.086615.0
\n", + "
" + ], + "text/plain": [ + " control test difference bca_low bca_high \\\n", + "id_col only (naive) 0 Baseline Treatment 0.349531 0.131764 0.568142 \n", + "id_col + cluster_col 0 Baseline Treatment 0.349531 -0.108557 0.639317 \n", + "\n", + " pvalue_permutation n_clusters \n", + "id_col only (naive) 0 0.0026 NaN \n", + "id_col + cluster_col 0 0.0866 15.0 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compare_cols = [\"control\", \"test\", \"difference\", \"bca_low\", \"bca_high\", \"pvalue_permutation\"]\n", + "pd.concat({\n", + " \"id_col only (naive)\": naive.mean_diff.results[compare_cols],\n", + " \"id_col + cluster_col\": clustered.mean_diff.results[compare_cols + [\"n_clusters\"]],\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "3619c6bf", + "metadata": {}, + "source": [ + "To see that difference clearly, we turn off the delta dots (the per-pair swarm on the contrast\n", + "axis, on by default) and the lines connecting them, since with 90 of them they mostly obscure the\n", + "interval; switch off the floating Gardner-Altman layout so the contrast axis gets its own,\n", + "independently-scaled y-axis rather than one stretched to match the raw data panel above it; zoom\n", + "that axis to the two intervals themselves, since both otherwise sit inside a small fraction of the\n", + "default axis range; and annotate each panel with its own `[bca_low, bca_high]` directly, so the\n", + "numbers don't have to be read off the axis at all." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7580ef30", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = pd.concat([naive.mean_diff.results[[\"bca_low\", \"bca_high\"]],\n", + " clustered.mean_diff.results[[\"bca_low\", \"bca_high\"]]])\n", + "shared_ylim = (bounds.bca_low.min() - 0.35, bounds.bca_high.max() + 0.35)\n", + "palette = {\"Baseline\": \"#4C72B0\", \"Treatment\": \"#C44E52\"} # a non-neutral palette\n", + "\n", + "f, axx = plt.subplots(ncols=2, figsize=(11, 5),\n", + " gridspec_kw={\"wspace\": 0.45})\n", + "for ax, dabest_obj, title in [(axx[0], naive, \"id_col only\"),\n", + " (axx[1], clustered, \"id_col + cluster_col\")]:\n", + " dabest_obj.mean_diff.plot(ax=ax, delta_dot=False,\n", + " contrast_paired_lines=False,\n", + " float_contrast=False,\n", + " custom_palette=palette,\n", + " contrast_marker_size=8,\n", + " contrast_ylim=shared_ylim,\n", + " title=title)\n", + "\n", + " result = dabest_obj.mean_diff.results.iloc[0]\n", + " tick = ax.contrast_axes.get_xticks()[-1]\n", + " ax.contrast_axes.text(tick, result.bca_low - 0.3,\n", + " \"[{:.2f}, {:.2f}]\".format(result.bca_low, result.bca_high),\n", + " ha=\"center\", va=\"bottom\", fontsize=10.5, fontweight=\"bold\")" + ] + }, + { + "cell_type": "markdown", + "id": "226c013d", + "metadata": {}, + "source": [ + "Inspect the two bracketed intervals: the cluster-naive one sits entirely above 0, while the\n", + "cluster-aware one spans across the zero line. This could impact on the conclusions drawn from the estimation plot.\n", + "Same data, same point estimate, opposite verdict at the conventional 5% threshold. Treating each dummy ID as an independent participant could lead to reporting more certainty in an effect size than is warranted by the data, once cluster-correlation is accounted for in resampling. This is the practical implication of the pseudoreplication concern that motivates `cluster_col`." + ] + }, + { + "cell_type": "markdown", + "id": "edf41cc1", + "metadata": {}, + "source": [ + "## Does it matter for real inference? A coverage check\n", + "\n", + "One worked example makes the risk concrete, but could this particular result be a fluke of this\n", + "particular random dataset? Because this dataset is simulated, we know the true effect\n", + "(`true_effect = 0.3`) exactly. That\n", + "lets us ask the question a single dataset can't answer: across many independent samples from the\n", + "same population, how often does each method's 95% interval actually contain the true effect? A\n", + "trustworthy 95% interval should hit close to 95% of the time; consistently missing more often\n", + "than that means the interval is too narrow to be trusted.\n", + "\n", + "We repeat the simulation above 200 times with fresh random data each time, and compute both a\n", + "naive and a cluster-aware bootstrap interval for each dataset, calling the same lower-level\n", + "functions that `dabest.load()` uses internally, so that the whole comparison runs in a few\n", + "seconds instead of a few minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "992fc77c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
95% CI covers the true effectmean CI width
method
id_col only (naive)0.8150.382
id_col + cluster_col0.9000.511
\n", + "
" + ], + "text/plain": [ + " 95% CI covers the true effect mean CI width\n", + "method \n", + "id_col only (naive) 0.815 0.382\n", + "id_col + cluster_col 0.900 0.511" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dabest._stats_tools import confint_2group_diff as ci2g\n", + "\n", + "def simulate_dataset(seed, n_participants=15, n_stimuli=6, true_effect=0.3,\n", + " participant_sd=1.4, noise_sd=0.6):\n", + " rng = np.random.default_rng(seed)\n", + " sensitivity = rng.normal(1, participant_sd, n_participants)\n", + " control, test, cluster = [], [], []\n", + " for p in range(n_participants):\n", + " for s in range(n_stimuli):\n", + " stim_baseline = rng.normal(5, 1.0)\n", + " control.append(stim_baseline + rng.normal(0, noise_sd))\n", + " test.append(stim_baseline + true_effect * sensitivity[p] + rng.normal(0, noise_sd))\n", + " cluster.append(p)\n", + " return np.array(control), np.array(test), np.array(cluster)\n", + "\n", + "def percentile_ci(bootstraps, ci=95):\n", + " lo, hi = np.percentile(bootstraps, [(100 - ci) / 2, 100 - (100 - ci) / 2])\n", + " return lo, hi\n", + "\n", + "n_simulated_datasets = 200\n", + "resamples_per_dataset = 1000\n", + "true_effect = 0.3\n", + "\n", + "naive_hits = cluster_hits = 0\n", + "naive_widths, cluster_widths = [], []\n", + "\n", + "for seed in range(n_simulated_datasets):\n", + " control, test, cluster = simulate_dataset(seed, true_effect=true_effect)\n", + "\n", + " boot_naive = ci2g.compute_bootstrapped_diff(\n", + " control, test, \"baseline\", \"mean_diff\", resamples_per_dataset, seed)\n", + " boot_cluster = ci2g.compute_cluster_bootstrapped_diff(\n", + " control, test, cluster, cluster, \"baseline\", \"mean_diff\", resamples_per_dataset, seed)\n", + "\n", + " lo_n, hi_n = percentile_ci(boot_naive)\n", + " lo_c, hi_c = percentile_ci(boot_cluster)\n", + "\n", + " naive_hits += lo_n <= true_effect <= hi_n\n", + " cluster_hits += lo_c <= true_effect <= hi_c\n", + " naive_widths.append(hi_n - lo_n)\n", + " cluster_widths.append(hi_c - lo_c)\n", + "\n", + "coverage = pd.DataFrame({\n", + " \"method\": [\"id_col only (naive)\", \"id_col + cluster_col\"],\n", + " \"95% CI covers the true effect\": [naive_hits / n_simulated_datasets, cluster_hits / n_simulated_datasets],\n", + " \"mean CI width\": [np.mean(naive_widths), np.mean(cluster_widths)],\n", + "}).set_index(\"method\").round(3)\n", + "coverage" + ] + }, + { + "cell_type": "markdown", + "id": "cc4266e4", + "metadata": {}, + "source": [ + "With a nominal target of 95%, the naive dummy-ID bootstrap covers the true effect noticeably\n", + "less often than that across these 200 simulated datasets, because it cannot tell that groups of sets came from the same participant and so understates the true sampling uncertainty. Once `cluster_col` tells it, coverage recovers to close to the nominal 95%, at the cost of a correspondingly wider (but now trustworthy) interval.\n", + "\n", + "Similarly, the permutation test also yields p-values biased to be too small in the cluster-naive case; defining the `cluster_col` argument ensures permuation test is reshuffled at the cluster level, producing values that account for the cluster-correlation." + ] + }, + { + "cell_type": "markdown", + "id": "a2249805", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- Use `cluster_col` whenever a real participant (or other independent unit) contributes more\n", + " than one row of `id_col`, whether the design is paired or unpaired.\n", + "- Ignoring clustering can lead to confidence intervals being estimated as too narrow.\n", + "- The point estimate (the mean difference itself) is unaffected; only the bootstrap confidence intervals change, because they are the parts of the analysis that depend on which observations are treated as independent.\n", + "- The interval widens to reflect real between-participant variability that a cluster-naive bootstrap cannot account for. The example simulation above shows the naive interval can give a false sense of precision.\n", + "- Permutation tests are similarly reshuffled at the cluster-level, yielding larger values than the cluster-naive approach.\n", + "- The parametric and rank-based tests reported in `.statistical_tests` (Welch's t, Mann-Whitney, Wilcoxon, and so on) do not account for clustering and are unaffected by `cluster_col`; prefer the cluster-aware bootstrap interval for clustered data." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "refmap-psychoacoustics", + "language": "python", + "name": "refmap-psychoacoustics" + }, + "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.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 66f9ba46dcfb27352d85d56eccd1c86f0da03860 Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Sun, 27 Sep 2026 19:31:34 +0100 Subject: [PATCH 5/8] feat: cluster-aware bootstrap sampling plotting updates Ensure plot labels reflect both observations and cluster sample sizes. --- CHANGELOG.md | 3 +- dabest/_effsize_objects.py | 7 + dabest/_modidx.py | 4 +- dabest/misc_tools.py | 121 ++++++++++++++---- dabest/plotter.py | 12 +- nbs/API/effsize_objects.ipynb | 7 + nbs/API/misc_tools.ipynb | 121 ++++++++++++++---- nbs/API/plotter.ipynb | 12 +- nbs/tests/test_cluster_bootstrap.py | 101 +++++++++++++++ ...shared_control_and_repeated_measures.ipynb | 2 +- nbs/tutorials/08-plot_aesthetics.ipynb | 2 +- .../11-cluster_robust_bootstrap.ipynb | 34 ++--- 12 files changed, 339 insertions(+), 87 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index da32d759..97582488 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,10 +6,11 @@ ### New Features 1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. +2. **Cluster count on plots**: when `cluster_col` is set, each group's axis label reports the number of distinct clusters on a second line below the number of observations, `(N=,` / ` n=)` instead of the usual `(N=)`, since the cluster count is what the bootstrap actually resamples. To make room, the gap between the raw-data and contrast axes of vertical Cumming plots is then sized to the height of the labels (including the taller labels of two-column Sankey plots), so they clear the contrast axes. Unclustered plots are unchanged. ### Documentation 1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. -2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that the naive dummy-ID bootstrap's 95% interval excludes zero (p = 0.0026, conventionally "significant") while the cluster-aware interval for the identical data spans zero (p = 0.087, "not significant"), making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, while the cluster-aware interval recovers to about 90%. +2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that, for the identical data and point estimate, the naive dummy-ID bootstrap's 95% interval lies entirely above zero while the cluster-aware interval spans it, making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, while the cluster-aware interval recovers to about 90%. ## v2025.10.20 diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 878057c1..e26f7fee 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -1430,6 +1430,13 @@ def plot( observations. show_sample_size : boolean, default True Whether or not to display the sample size of each group in the axis label. + When `cluster_col` was set in `dabest.load()`, the label also reports the + number of distinct clusters in that group, on its own line, since that is + the count the cluster-aware bootstrap actually resamples: `(N=, + n=)` instead of the usual `(N=)`. For vertical + Cumming plots, including two-column Sankey plots, the gap between the + raw-data and contrast axes is then sized to the labels, so they clear the + contrast axes. show_delta2, show_mini_meta : boolean, default True If delta-delta or mini-meta delta is calculated, whether or not to show the delta-delta plot or mini-meta plot. diff --git a/dabest/_modidx.py b/dabest/_modidx.py index 66d052d2..c0a19c53 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -97,7 +97,9 @@ 'dabest.forest_plot.forest_plot': ('API/forest_plot.html#forest_plot', 'dabest/forest_plot.py'), 'dabest.forest_plot.get_kwargs': ('API/forest_plot.html#get_kwargs', 'dabest/forest_plot.py'), 'dabest.forest_plot.load_plot_data': ('API/forest_plot.html#load_plot_data', 'dabest/forest_plot.py')}, - 'dabest.misc_tools': { 'dabest.misc_tools.add_counts_to_ticks': ( 'API/misc_tools.html#add_counts_to_ticks', + 'dabest.misc_tools': { 'dabest.misc_tools._hspace_for_tick_labels': ( 'API/misc_tools.html#_hspace_for_tick_labels', + 'dabest/misc_tools.py'), + 'dabest.misc_tools.add_counts_to_ticks': ( 'API/misc_tools.html#add_counts_to_ticks', 'dabest/misc_tools.py'), 'dabest.misc_tools.color_picker': ('API/misc_tools.html#color_picker', 'dabest/misc_tools.py'), 'dabest.misc_tools.draw_zeroline': ('API/misc_tools.html#draw_zeroline', 'dabest/misc_tools.py'), diff --git a/dabest/misc_tools.py b/dabest/misc_tools.py index 4060b7ca..d64001a1 100644 --- a/dabest/misc_tools.py +++ b/dabest/misc_tools.py @@ -700,20 +700,44 @@ def get_color_palette( return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors, plot_palette_raw, plot_palette_contrast, plot_palette_sankey) +def _hspace_for_tick_labels( + n_lines: int, + fontsize, + available_height: float, + minimum: float, + ) -> float: + """ + Vertical gap, as a fraction of each axes' height, that keeps multi-line + tick labels on the upper (raw data) axes clear of the lower (contrast) axes. + + `available_height` is the height in inches shared by both axes and the gap + between them. The gap needed is `n_lines` of text at `fontsize`, plus room + for the tick marks and a small margin. Never returns less than `minimum`. + """ + from matplotlib.font_manager import FontProperties + + size_pt = FontProperties(size=fontsize).get_size_in_points() + needed = (n_lines * 1.2 * size_pt + 14) / 72 # inches + # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h. + remaining = max(available_height - needed, 0.25 * available_height) + return max(minimum, 2 * needed / remaining) + + def initialize_fig( - plot_kwargs: dict, - dabest_obj: object, - show_delta2: bool, - show_mini_meta: bool, - is_paired: bool, - show_pairs: bool, + plot_kwargs: dict, + dabest_obj: object, + show_delta2: bool, + show_mini_meta: bool, + is_paired: bool, + show_pairs: bool, proportional: bool, float_contrast: bool, - effect_size_type: str, - yvar: str, - horizontal: bool, + effect_size_type: str, + yvar: str, + horizontal: bool, show_table: bool, color_col: str, + two_col_sankey: bool = False, ): """ Initialize the figure and axes for the plotter function. @@ -746,6 +770,9 @@ def initialize_fig( A boolean flag to determine if the table will be shown in horizontal plot. color_col : str The column name for coloring the data points. + two_col_sankey : bool, default False + Whether the plot is a two-column (non-flow) Sankey diagram, whose raw + data tick labels span several lines. """ # Params fig_size = plot_kwargs["fig_size"] @@ -786,6 +813,18 @@ def initialize_fig( width_ratios_ga = [2.5, 1] h_space_cummings = (0.1 if plot_kwargs["gridkey"] is not None else 0.3) + # Cluster-aware sample-size labels add a line to each raw-data tick label + # (see `add_counts_to_ticks`), on top of the two lines of an ordinary label + # or the four of a two-column Sankey label. In that case the gap between the + # raw data and contrast axes is sized to the labels, so they clear the + # contrast axes below. + size_gap_to_labels = ( + plot_kwargs["gridkey"] is None + and plot_kwargs["show_sample_size"] + and getattr(dabest_obj, "cluster_col", None) is not None + ) + n_label_lines = (4 if two_col_sankey else 2) + 1 + fontsize_rawxlabel = plot_kwargs.get("fontsize_rawxlabel") if plot_kwargs["ax"] is not None: # New in v0.2.6. @@ -836,6 +875,13 @@ def initialize_fig( contrast_axes = axins else: + if size_gap_to_labels: + h_space_cummings = _hspace_for_tick_labels( + n_label_lines, + fontsize_rawxlabel, + (ax_position.y1 - ax_position.y0) * fig.get_figheight(), + h_space_cummings, + ) axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1]) plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings) rawdata_axes.set_position( @@ -871,6 +917,15 @@ def initialize_fig( **init_fig_kwargs ) else: + if size_gap_to_labels: + subplot_height = (plt.rcParams["figure.subplot.top"] + - plt.rcParams["figure.subplot.bottom"]) + h_space_cummings = _hspace_for_tick_labels( + n_label_lines, + fontsize_rawxlabel, + fig_size[1] * subplot_height, + h_space_cummings, + ) fig, axx = plt.subplots( nrows=2, gridspec_kw={"hspace": h_space_cummings}, **init_fig_kwargs ) @@ -1027,13 +1082,14 @@ def get_plot_groups( def add_counts_to_ticks( - plot_data: pd.DataFrame, - xvar: str, - yvar: str, - rawdata_axes: axes.Axes, - plot_kwargs: dict, - flow: bool, - horizontal: bool + plot_data: pd.DataFrame, + xvar: str, + yvar: str, + rawdata_axes: axes.Axes, + plot_kwargs: dict, + flow: bool, + horizontal: bool, + cluster_col: str = None ): """ @@ -1055,24 +1111,33 @@ def add_counts_to_ticks( Whether sankey flow is enabled or not. horizontal : bool A boolean flag to determine if the plot is for horizontal plotting. + cluster_col : str, default None + Name of the column identifying the cluster (e.g. participant) each + observation belongs to, as declared to `dabest.load()`. When supplied, + each group's label also reports the number of distinct clusters + contributing to that group, on its own line below the observation + count, since that is the count the cluster-aware bootstrap actually + resamples. """ # Add the counts to the rawdata axes xticks. counts = plot_data.groupby(xvar, observed=False).count()[yvar] - - def lookup_value(text): + if cluster_col is not None: + cluster_counts = plot_data.groupby(xvar, observed=False)[cluster_col].nunique() + + def lookup_value(series, text): try: - return str(counts.loc[text]) + return str(series.loc[text]) except KeyError: try: numeric_key = pd.to_numeric(text, errors='coerce') if pd.notnull(numeric_key): - return str(counts.loc[numeric_key]) + return str(series.loc[numeric_key]) except (ValueError, KeyError): pass print(f"Key '{text}' not found in counts.") return "N/A" - + ticks_with_counts = [] if horizontal: get_label, get_ticks = rawdata_axes.get_yticklabels, rawdata_axes.get_yticks @@ -1080,7 +1145,7 @@ def lookup_value(text): else: get_label, get_ticks = rawdata_axes.get_xticklabels, rawdata_axes.get_xticks set_label, set_major_loc_method = rawdata_axes.set_xticklabels, rawdata_axes.xaxis.set_major_locator - + for ticklab in get_label(): t = ticklab.get_text() @@ -1089,11 +1154,17 @@ def lookup_value(text): else: te = t.split('\n')[-1] # Get the last line of the label - value = lookup_value(te) + value = lookup_value(counts, te) + if cluster_col is not None: + n_clusters = lookup_value(cluster_counts, te) + count_text = "(N={},\n n={})".format(value, n_clusters) + else: + count_text = "(N={})".format(value) + if horizontal: - ticks_with_counts.append(f"{t} (N={value})") + ticks_with_counts.append(f"{t} {count_text}") else: - ticks_with_counts.append(f"{t}\n(N={value})") + ticks_with_counts.append(f"{t}\n{count_text}") set_major_loc_method(plt.FixedLocator(get_ticks())) diff --git a/dabest/plotter.py b/dabest/plotter.py index f40685c8..0dfe1039 100644 --- a/dabest/plotter.py +++ b/dabest/plotter.py @@ -180,7 +180,8 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi yvar = yvar, horizontal = horizontal, show_table = table_kwargs['show'], - color_col = color_col + color_col = color_col, + two_col_sankey = two_col_sankey, ) # Plotting the rawdata. @@ -314,13 +315,14 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi # Add the counts to the rawdata axes xticks. if show_sample_size: add_counts_to_ticks( - plot_data = plot_data, - xvar = xvar, - yvar = yvar, - rawdata_axes = rawdata_axes, + plot_data = plot_data, + xvar = xvar, + yvar = yvar, + rawdata_axes = rawdata_axes, plot_kwargs = plot_kwargs, flow = sankey_kwargs["flow"], horizontal = horizontal, + cluster_col = dabest_obj.cluster_col, ) # Add counts to prop plots (embedded in the plot bars) diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 204ad7c0..55394da3 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -1639,6 +1639,13 @@ " observations.\n", " show_sample_size : boolean, default True\n", " Whether or not to display the sample size of each group in the axis label.\n", + " When `cluster_col` was set in `dabest.load()`, the label also reports the\n", + " number of distinct clusters in that group, on its own line, since that is\n", + " the count the cluster-aware bootstrap actually resamples: `(N=,\n", + " n=)` instead of the usual `(N=)`. For vertical\n", + " Cumming plots, including two-column Sankey plots, the gap between the\n", + " raw-data and contrast axes is then sized to the labels, so they clear the\n", + " contrast axes.\n", " show_delta2, show_mini_meta : boolean, default True\n", " If delta-delta or mini-meta delta is calculated, whether or not to\n", " show the delta-delta plot or mini-meta plot.\n", diff --git a/nbs/API/misc_tools.ipynb b/nbs/API/misc_tools.ipynb index 3e28644e..874a486c 100644 --- a/nbs/API/misc_tools.ipynb +++ b/nbs/API/misc_tools.ipynb @@ -751,20 +751,44 @@ " return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors,\n", " plot_palette_raw, plot_palette_contrast, plot_palette_sankey)\n", "\n", + "def _hspace_for_tick_labels(\n", + " n_lines: int,\n", + " fontsize,\n", + " available_height: float,\n", + " minimum: float,\n", + " ) -> float:\n", + " \"\"\"\n", + " Vertical gap, as a fraction of each axes' height, that keeps multi-line\n", + " tick labels on the upper (raw data) axes clear of the lower (contrast) axes.\n", + "\n", + " `available_height` is the height in inches shared by both axes and the gap\n", + " between them. The gap needed is `n_lines` of text at `fontsize`, plus room\n", + " for the tick marks and a small margin. Never returns less than `minimum`.\n", + " \"\"\"\n", + " from matplotlib.font_manager import FontProperties\n", + "\n", + " size_pt = FontProperties(size=fontsize).get_size_in_points()\n", + " needed = (n_lines * 1.2 * size_pt + 14) / 72 # inches\n", + " # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h.\n", + " remaining = max(available_height - needed, 0.25 * available_height)\n", + " return max(minimum, 2 * needed / remaining)\n", + "\n", + "\n", "def initialize_fig(\n", - " plot_kwargs: dict, \n", - " dabest_obj: object, \n", - " show_delta2: bool, \n", - " show_mini_meta: bool, \n", - " is_paired: bool, \n", - " show_pairs: bool, \n", + " plot_kwargs: dict,\n", + " dabest_obj: object,\n", + " show_delta2: bool,\n", + " show_mini_meta: bool,\n", + " is_paired: bool,\n", + " show_pairs: bool,\n", " proportional: bool,\n", " float_contrast: bool,\n", - " effect_size_type: str, \n", - " yvar: str, \n", - " horizontal: bool, \n", + " effect_size_type: str,\n", + " yvar: str,\n", + " horizontal: bool,\n", " show_table: bool,\n", " color_col: str,\n", + " two_col_sankey: bool = False,\n", " ):\n", " \"\"\"\n", " Initialize the figure and axes for the plotter function.\n", @@ -797,6 +821,9 @@ " A boolean flag to determine if the table will be shown in horizontal plot.\n", " color_col : str\n", " The column name for coloring the data points.\n", + " two_col_sankey : bool, default False\n", + " Whether the plot is a two-column (non-flow) Sankey diagram, whose raw\n", + " data tick labels span several lines.\n", " \"\"\"\n", " # Params\n", " fig_size = plot_kwargs[\"fig_size\"]\n", @@ -837,6 +864,18 @@ " width_ratios_ga = [2.5, 1]\n", " h_space_cummings = (0.1 if plot_kwargs[\"gridkey\"] is not None\n", " else 0.3)\n", + " # Cluster-aware sample-size labels add a line to each raw-data tick label\n", + " # (see `add_counts_to_ticks`), on top of the two lines of an ordinary label\n", + " # or the four of a two-column Sankey label. In that case the gap between the\n", + " # raw data and contrast axes is sized to the labels, so they clear the\n", + " # contrast axes below.\n", + " size_gap_to_labels = (\n", + " plot_kwargs[\"gridkey\"] is None\n", + " and plot_kwargs[\"show_sample_size\"]\n", + " and getattr(dabest_obj, \"cluster_col\", None) is not None\n", + " )\n", + " n_label_lines = (4 if two_col_sankey else 2) + 1\n", + " fontsize_rawxlabel = plot_kwargs.get(\"fontsize_rawxlabel\")\n", "\n", " if plot_kwargs[\"ax\"] is not None:\n", " # New in v0.2.6.\n", @@ -887,6 +926,13 @@ "\n", " contrast_axes = axins\n", " else:\n", + " if size_gap_to_labels:\n", + " h_space_cummings = _hspace_for_tick_labels(\n", + " n_label_lines,\n", + " fontsize_rawxlabel,\n", + " (ax_position.y1 - ax_position.y0) * fig.get_figheight(),\n", + " h_space_cummings,\n", + " )\n", " axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1])\n", " plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings)\n", " rawdata_axes.set_position(\n", @@ -922,6 +968,15 @@ " **init_fig_kwargs\n", " )\n", " else:\n", + " if size_gap_to_labels:\n", + " subplot_height = (plt.rcParams[\"figure.subplot.top\"]\n", + " - plt.rcParams[\"figure.subplot.bottom\"])\n", + " h_space_cummings = _hspace_for_tick_labels(\n", + " n_label_lines,\n", + " fontsize_rawxlabel,\n", + " fig_size[1] * subplot_height,\n", + " h_space_cummings,\n", + " )\n", " fig, axx = plt.subplots(\n", " nrows=2, gridspec_kw={\"hspace\": h_space_cummings}, **init_fig_kwargs\n", " )\n", @@ -1078,13 +1133,14 @@ "\n", "\n", "def add_counts_to_ticks(\n", - " plot_data: pd.DataFrame, \n", - " xvar: str, \n", - " yvar: str, \n", - " rawdata_axes: axes.Axes, \n", - " plot_kwargs: dict, \n", - " flow: bool, \n", - " horizontal: bool\n", + " plot_data: pd.DataFrame,\n", + " xvar: str,\n", + " yvar: str,\n", + " rawdata_axes: axes.Axes,\n", + " plot_kwargs: dict,\n", + " flow: bool,\n", + " horizontal: bool,\n", + " cluster_col: str = None\n", " ):\n", " \"\"\"\n", "\n", @@ -1106,24 +1162,33 @@ " Whether sankey flow is enabled or not.\n", " horizontal : bool\n", " A boolean flag to determine if the plot is for horizontal plotting.\n", + " cluster_col : str, default None\n", + " Name of the column identifying the cluster (e.g. participant) each\n", + " observation belongs to, as declared to `dabest.load()`. When supplied,\n", + " each group's label also reports the number of distinct clusters\n", + " contributing to that group, on its own line below the observation\n", + " count, since that is the count the cluster-aware bootstrap actually\n", + " resamples.\n", " \"\"\"\n", "\n", " # Add the counts to the rawdata axes xticks.\n", " counts = plot_data.groupby(xvar, observed=False).count()[yvar]\n", - " \n", - " def lookup_value(text):\n", + " if cluster_col is not None:\n", + " cluster_counts = plot_data.groupby(xvar, observed=False)[cluster_col].nunique()\n", + "\n", + " def lookup_value(series, text):\n", " try:\n", - " return str(counts.loc[text])\n", + " return str(series.loc[text])\n", " except KeyError:\n", " try:\n", " numeric_key = pd.to_numeric(text, errors='coerce')\n", " if pd.notnull(numeric_key):\n", - " return str(counts.loc[numeric_key])\n", + " return str(series.loc[numeric_key])\n", " except (ValueError, KeyError):\n", " pass\n", " print(f\"Key '{text}' not found in counts.\")\n", " return \"N/A\"\n", - " \n", + "\n", " ticks_with_counts = []\n", " if horizontal:\n", " get_label, get_ticks = rawdata_axes.get_yticklabels, rawdata_axes.get_yticks\n", @@ -1131,7 +1196,7 @@ " else:\n", " get_label, get_ticks = rawdata_axes.get_xticklabels, rawdata_axes.get_xticks\n", " set_label, set_major_loc_method = rawdata_axes.set_xticklabels, rawdata_axes.xaxis.set_major_locator\n", - " \n", + "\n", " for ticklab in get_label():\n", " t = ticklab.get_text()\n", "\n", @@ -1140,11 +1205,17 @@ " else:\n", " te = t.split('\\n')[-1] # Get the last line of the label\n", "\n", - " value = lookup_value(te)\n", + " value = lookup_value(counts, te)\n", + " if cluster_col is not None:\n", + " n_clusters = lookup_value(cluster_counts, te)\n", + " count_text = \"(N={},\\n n={})\".format(value, n_clusters)\n", + " else:\n", + " count_text = \"(N={})\".format(value)\n", + "\n", " if horizontal:\n", - " ticks_with_counts.append(f\"{t} (N={value})\")\n", + " ticks_with_counts.append(f\"{t} {count_text}\")\n", " else:\n", - " ticks_with_counts.append(f\"{t}\\n(N={value})\")\n", + " ticks_with_counts.append(f\"{t}\\n{count_text}\")\n", "\n", " set_major_loc_method(plt.FixedLocator(get_ticks()))\n", "\n", diff --git a/nbs/API/plotter.ipynb b/nbs/API/plotter.ipynb index 9d4a0986..ad955b3b 100644 --- a/nbs/API/plotter.ipynb +++ b/nbs/API/plotter.ipynb @@ -235,7 +235,8 @@ " yvar = yvar,\n", " horizontal = horizontal,\n", " show_table = table_kwargs['show'],\n", - " color_col = color_col\n", + " color_col = color_col,\n", + " two_col_sankey = two_col_sankey,\n", " )\n", " \n", " # Plotting the rawdata.\n", @@ -369,13 +370,14 @@ " # Add the counts to the rawdata axes xticks.\n", " if show_sample_size:\n", " add_counts_to_ticks(\n", - " plot_data = plot_data, \n", - " xvar = xvar, \n", - " yvar = yvar, \n", - " rawdata_axes = rawdata_axes, \n", + " plot_data = plot_data,\n", + " xvar = xvar,\n", + " yvar = yvar,\n", + " rawdata_axes = rawdata_axes,\n", " plot_kwargs = plot_kwargs,\n", " flow = sankey_kwargs[\"flow\"],\n", " horizontal = horizontal,\n", + " cluster_col = dabest_obj.cluster_col,\n", " )\n", "\n", " # Add counts to prop plots (embedded in the plot bars)\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py index 826396d8..d27fe927 100644 --- a/nbs/tests/test_cluster_bootstrap.py +++ b/nbs/tests/test_cluster_bootstrap.py @@ -244,6 +244,107 @@ def test_other_effect_sizes_and_plot_with_clusters(clustered): assert fig is not None +def test_plot_tick_labels_report_cluster_count(naive, clustered): + import matplotlib + + matplotlib.use("Agg") + + naive_labels = [t.get_text() for t in naive.mean_diff.plot().axes[0].get_xticklabels()] + for label in naive_labels: + assert "n=" not in label + assert "(N=" in label + + clustered_labels = [t.get_text() for t in clustered.mean_diff.plot().axes[0].get_xticklabels()] + for label in clustered_labels: + assert "(N=48,\n n=12)" in label # 12 participants x 4 sets each = 48 observations per level + + # A design where each participant contributes several sets: the cluster + # count in the label must be lower than the observation count. + df = make_clustered_data(n_participants=6, n_sets=5) + clustered_multi = load( + df, idx=("L1", "L2", "L3"), x="Level", y="Y", paired="sequential", + id_col="pair", cluster_col="ID", resamples=200, random_seed=1, + ) + labels = [t.get_text() for t in clustered_multi.mean_diff.plot().axes[0].get_xticklabels()] + for label in labels: + assert "(N=30,\n n=6)" in label + + # Horizontal orientation keeps the group label and N on one line, but still + # breaks N and n onto separate lines. + horiz_labels = [t.get_text() for t in clustered.mean_diff.plot(horizontal=True).axes[0].get_yticklabels()] + for label in horiz_labels: + assert " (N=48,\n n=12)" in label + + +def test_cumming_layout_makes_room_for_cluster_label(naive, clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + + def gap(fig): + raw, contrast = fig.axes[0].get_position(), fig.axes[1].get_position() + return raw.y0 - contrast.y1 + + # Figures created by dabest. + naive_gap = gap(naive.mean_diff.plot(float_contrast=False)) + clustered_gap = gap(clustered.mean_diff.plot(float_contrast=False)) + assert clustered_gap > naive_gap + + # Figures drawn into a user-supplied axes (the contrast axes is an inset). + def inset_gap(dabest_obj): + f, ax = plt.subplots() + dabest_obj.mean_diff.plot(ax=ax, float_contrast=False) + raw = ax.get_position() + contrast = ax.contrast_axes.get_position() + return raw.y0 - contrast.y1 + + assert inset_gap(clustered) > inset_gap(naive) + + # Without sample-size labels there is nothing extra to make room for. + assert gap(clustered.mean_diff.plot(float_contrast=False, show_sample_size=False)) == pytest.approx(naive_gap) + plt.close("all") + + +def _label_clearance(raw_ax, contrast_ax): + """Pixels between the lowest raw-data tick label and the top of the contrast axes.""" + fig = raw_ax.figure + fig.canvas.draw() + renderer = fig.canvas.get_renderer() + labels = [t for t in raw_ax.get_xticklabels() if t.get_text()] + label_bottom = min(t.get_window_extent(renderer).y0 for t in labels) + return label_bottom - contrast_ax.get_window_extent(renderer).y1 + + +def test_cluster_labels_clear_the_contrast_axes(): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + rng = np.random.default_rng(0) + df = DF.copy() + df["Yes"] = (rng.random(len(df)) < 0.4).astype(int) + proportional_kwargs = dict(idx=("L1", "L2", "L3"), x="Level", y="Yes", proportional=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=200) + + cases = [ + (load(DF, cluster_col="ID", **PAIRED_KWARGS), dict(fig_size=(5, 4))), + (load(DF, cluster_col="ID", **PAIRED_KWARGS), dict(fontsize_rawxlabel=16)), + # Two-column Sankey labels span four lines before the cluster count is added. + (load(df, **proportional_kwargs), dict(sankey_kwargs={"flow": False})), + (load(df, **proportional_kwargs), dict(sankey_kwargs={"flow": False}, fig_size=(5, 4))), + ] + for dabest_obj, plot_kwargs in cases: + fig = dabest_obj.mean_diff.plot(**plot_kwargs) + assert _label_clearance(fig.axes[0], fig.axes[1]) > 0, plot_kwargs + + user_kwargs = {k: v for k, v in plot_kwargs.items() if k != "fig_size"} + f, ax = plt.subplots(figsize=(5.5, 5)) + dabest_obj.mean_diff.plot(ax=ax, **user_kwargs) + assert _label_clearance(ax, ax.contrast_axes) > 0, user_kwargs + plt.close("all") + + # --------------------------------------------------------------------------- # Validation # --------------------------------------------------------------------------- diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index edc00294..6dcd09f5 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -1013,7 +1013,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA64AAARECAYAAAB1fkwYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzsvQu0fVdV33+Ql4oFW2rREkhCyIMQHgEiL0tIg61YylMrLwNV6BAoLbS0abH032I1Kh2I4CgyAMEClsdQlKcFIqEEQoESEvIAYsIz1WqxQPEB2vIfn93f545vVtbe53HPuffce+d3jD3Oueees/faa6299/yuOed33uSb3/zmN2eFQqFQKBQKhUKhUChsKb5lvxtQKBQKhUKhUCgUCoXCFIq4FgqFQqFQKBQKhUJhq1HEtVAoFAqFQqFQKBQKW40iroVCoVAoFAqFQqFQ2GoUcS0UCoVCoVAoFAqFwlajiGuhUCgUCoVCoVAoFLYaRVwLhUKhUCgUCoVCobDVKOJaKBQKhUKhUCgUCoWtRhHXQqFQKBQKhUKhUChsNYq4FgqFQqFQKBQKhUJhq1HEtVAoFAqFQqFQKBQKW40iroVCoVAoFAqFQqFQ2GoUcS0UCoVCoVAoFAqFwlajiGuhUCgUCoVCoVAoFLYaRVwLhUKhUCgUCoVCobDVKOJaKBQKhUKhUCgUCoWtRhHXQqFQKBQKhUKhUChsNYq4FgqFQqFQKBQKhUJhq3Gz/W5A4eDghS984eyrX/3q7Na3vvXsn/yTf7LfzSkUCoVCoVAoFApHBDf55je/+c39bkThYOC4446bXX/99bPb3/72sy9+8Yv73ZxCoVAoFAqFQqFwRFChwoVCoVAoFAqFQqFQ2GoUcS0UCoVCoVAoFAqFwlajiGuhUCgUCoVCoVAoFLYaRVwLhUKhUCgUCoVCobDVKOJaKBQKhUKhUCgUCoWtRhHXQqFQKBQKhUKhUChsNYq4HgA8+MEPnt3kJjdZarvooov2u9mFQqFQKBQKhUKhsBYUcT2E+JZv+ZbZySefvN/NKBQKhUKhUCgUCoW14Gbr2U1hk3jVq141++M//uPJ71x11VWzH/mRHxnen3vuubPb3/72NSiFQqFQKBQKhULhUKCI6wHAiSeeOPc7r3nNa3ben3feeRtuUaFQKBQKhUKhUCjsHSpU+BDg//7f/zt73eteN7z/ju/4jtmjH/3o/W5SoVAoFAqFQqFQKKwNRVwPAS688MLZ9ddfP7z/oR/6odm3f/u373eTCoVCoVAoFAqFQmFtKOJ6CPAf/+N/3HlfYcKFQqFQKBQKhULhsKFyXA84vva1r83e/OY3D++PP/74oXTOKvjiF7849zv/5//8n5X2XSgUCoVCoVAoFAq7QRHXA45f//Vf31EcfuITnzjUcF0Fd7jDHdbcskKhUCgUCoXCYcdf/MVfDM6NW97ylvvdlMIhRxHXA44KEy4UCoVCoVAo7LUw6Je//OXZH/3RH82++tWvzv7yX/7LC1XBKBR2gyKuBxiE91500UXD+/vd736zU045ZeV9feELX5j7nbPOOmv2+7//+ysfo1AoFAqFQqFwMPHNb35zIKmQVUgr5FXwN17Xm970pvvaxsLhRhHXA4zXvva1OzeNJz3pSbva13HHHTf3O3UzKhQKhUKhUDhaICXtS1/60ux//a//NYQFt7jFLW4x+yt/5a8MxLZQ2CSKuB5gvOY1rxleySn4kR/5kf1uTqFQKBQKhULhEODP/uzPBs8q29e//vWuM4PwYAjrX/pLf2lf2lg4eijiekDx0Y9+dHbVVVcN7x/2sIcNN49CoVAoFAqFQmEV/Pmf//kOWf2TP/mTG/3/W77lW2a3uc1tBrLK66qCoIXCqijieghEmXYbJlwoFAqFQqFQOHogL5UQYMjq//7f/7v7nVvf+tYDWf3O7/zOShsr7CuKuB7QFbHXv/71w/vv+q7vmj30oQ/d7yYVCoVCoVAoFA4A0Ef5yle+MpBVXnu5qbe61a0GskpE381vfvN9aWeh0KKI6wHEO9/5ztkf/uEfDu8f//jHz252sxrGQqFQKBQKhUIfkNOvfe1rA1nFw4qntQWaKZBVtm/91m+trixsHYrxHEBU7dZCoVAoFAqFwjyQq2reKhF7LfCmKrKEl7VQ2GYUcT1gYJXsbW972/D+jDPOmN3rXvfa7yYVCoVCoVAoFLYEqABLVlEH7ikCk6+qInCJLBUOCoq4HjC84Q1v2JElP++88/a7OYVCoVAoFAqFfQb1VSWr1F1tATlNRWAUgguFg4Yirge0diurZU94whP2uzmFQqFQKBQKhX0Aeapf/vKXdxSBeyJLeFRVBC5NlMJBRxHXA4YPfOAD+92EQqFQKBQKhcI+AHL61a9+dSCrkFYUglt827d9247I0i1ucYsap8KhQRHXQqFQKBQKhUJhi5GKwIQFt4CgSlYhroXCYUQR10KhUCgUCoVCYcvwp3/6pzt5q9/4xjdu9H9Cf1UE/o7v+I59aWOhsJco4looFAqFQqFQKGwBIKiSVYhrC0SVVAS+9a1vXYrAhSOFIq6FQqFQKBQKhcI+gdBf8lW/9KUvDSHBPUVgRJZue9vbDqS1FIELRxVFXAuFQqFQKBQKhT0Eokpf+cpXBs8qrz1F4Fvd6lY7eaulCFwoFHEtFAqFQqFQKBQ2DsgpZWtUBKacTYtv/dZv3SGrt7zlLWtUCoVAeVwLhUKhUCgUCoUN4Y//+I93FIH//M///Eb/v/nNb75DVr/927+9xqFQGEER10KhUCgUCoVCYY34+te/PuSsQlh53+KmN73pDRSByWMtFArTKOJaKBQKhUKhUCjsEnhT8apCWP/kT/7kRv+HnN7mNrcZyCqvJbJUKCyHIq6FQqFQKBQKhcIKIE+VfFU8q1/96le730ERGLKKhxVPa6FQWA1FXAuFQqFQKBQKhSVEllIRGIXgFuSqmrdKDmuhUNg9irgWCoVCoVAoFApzoCIw4cA9RWBUgCWrqAMXCoX1oohroVAoFAqFQqHQwZ/+6Z8OOauQ1W984xs3NqRvdrMdskrd1UKhsDkUcS0UCoVCoVAoFI4BgopnlQ3i2gJRpe/8zu8cyOqtb33rI6sIjNeZUj94oiHwt7vd7fa7SYVDjiKuhUKhUCgUCoUjjb/4i78YvKqQ1a997Ws3+j/kFJIKWYW0HkVFYIgqfQNR5RXlZPJ9AaHRRVwLm0YR10KhUCgUCoXCkQOiSqkILAlLUGNVRWC8ikeNzLdEdQx/9md/Nnz/qPVRYW9Rs6tQKBQKhUKhcCQAOYWkQlYhrT1FYLyHt73tbQfCeotb3GJ2lOrQJlHthUknvu3bvm0g9pT74bVIa2HTKOJaKBQKhUKhUDjUIBfTvFU8gy0gqHhVIawQsqNCVCGpElW8plOgxE8R1cJ+oohroVAoFAqFQuHQASImWf36179+o//f9KY3HcgqnlW8hkdBdCqJaq9PMqe3Jar0V6GwnyjiWigUCoVCoVA4NF5EyWovJxNRpdvc5jYDWeX1MCsCQ0yTqPbK+bREFZLKRmmfIqqFbUMR10KhUCgUCoXCgVa7VREYktZDKgIfVkKGhzmJKiR+iqhCTpOoHkWl5MLBQhHXQqFQKBQKhcKBAqJKX/nKVwayymtPERgypiLwzW9+89lhA+JJklRee7m7AlKaRBXvahHVwkFDEddCoVAoFAqFwtYDcgpJg6ziYcXT2uKWt7zlQFbZUAc+TOfeEtXe+QtIaeanQloPc1h04WigiGuhUCgUCoVCYWtBrqp5q73wV7ypiixB0A4LUeW8JapsU0SV8OckqnhUi6gWDhuKuBYKhUKhUCgUtk5YSLLaK9OCRzEVgQ86SYOoUrIniWqvxqygZmoSVUr47Ecf0Ea835QTOgrKzIX9RRHXQqFQKBQKhcK+gxxNySokrgXELBWBD3KOJoSvJaq9PN30KrdEdT/BYsIf/uEfzr70pS8NnmBzZwuFTaKIa6FQKBQKhUJh3wjcl7/85YEAQeJ65A2idtvb3nZQBMbTeFDP09xUXiGtU0QVD2YS1W3I13WsIKycQ4LzwktOjnGhsCkczKu/UCgUCoVCoXAgAWH76le/OnhWIUK9kFg8ioosQeIOGvBCJlElX3WKqEL4kqhuEwHEu/o//+f/HBYXWuViQ7b/6l/9q1vV5sLhRBHXQqFQKBQKhcLGkYrAvdItEFTJ6n6Hwi4LzqclqlPAg5pEddvIOSSbcYKw9mrj0v7v+q7vGsbqoHrBCwcPNdMKhUKhUCgUChsBJVzMW/3GN75xY0P0ZjfbEVmCwB0UoG6cRJXznAJEPInqttaVJdzX3NV2cYEcY8YKwnqQxqpweFDEtVAoFAqFQqGwNkBQJas9Qkd4KfmqkNVb3/rWB0IRGKIKSZWo9pSOE5SjSaK6zV5JvKvmro55VwkFJs94m8+jcPhRs69QKBQKhUKhsCvgnVNkqRXuAZBTSBzkB0Vg6o5uO/lOoooncgycW0tUt/38AOdk7mpbH5dzYnEB72qpBRe2BUVcC4VCoVAoFApLA1Glr3zlK4Nnldee+NCtbnWrwbNKiOm2hsdK4pKo9sKaW6JqCRjO8SAQVcAYMVZ4VxHIaoHAEt5VtvKuFrYNRVwLhUKhUCgUCgsTH8idisCo5/ZCSxVZ2lalWUJ9Jam8th7HlqhCTpOoHrQashBxvKtsY95VyCqh24XCtqKIa6FQKBQKhUJhEtQdVRG4R/LwpkpW8UZuG8i1TaLaUzUWkNIkqpzPQSOq6V2FrPLaAiVjQoEJ395mb3ihIIq4FgqFQqFQKBS64bPkP0JYezmehMemIvC2iCxB2Fqi2vMMC0hp5qdCWrflXDbhXSXHGMK6Tu8qfX6Q+6xwMFDEtVAoFAqFQqEwAKKDVxXC2qtFKvGBrPK6DZ5ISBNtlaiyTRFVCHcSVTyqB5100QfkrJK7OuZdNXd1Hd5VjocXnnBxjgfZP+GEE3a930JhCkVcC4VCoVAoFI4wIHkQEDyrPcEeAMlTZGm/hYgkTUlUEYoaAyJDSVSpqXrQiWouNOhd7QlKZe7qbs+ZecL8gKiyZbg178vrWtg0irgWCoVCoVAoHDGY/6gicI/44YmUrOKx2y/Qtpao9hSMBR7FlqgeNqR3te0Lzl/v6m7HDTLMMVjYoP97/Y7QFf0Mea1c2cImUcS1UCgUCoVC4YhARWDCgXvhtKgAK7KEOvB+EVVzU3mFtE4RVchZEtX9avdeeFcJ4Yaw9ryrhG5DVnndjXeVsGuIKhu5wj2wf8YJsopHm74v0lrYNIq4FgqFQqFQKBxiQD4gPJDVHuGBeOBVRV2WXMW9BgQ6iSrEaYqoQq6TqG5ryZ11elcJBYZIbsK7CgGl781XHSsNxP7Z+D8b5FWyym8lsYXCplCzq1AoFAqFQuGQAYKKZ5Wt5zVDVIn8Rzyr68h/XAYQnJaoTgEPahLV/Qxb3ss+Mne1p+jMmKEMvKp3FeJprirEeCxHmIUM+pzFBTzfjFcLQrEhzoclb7iwvSjiegDx+c9/fvbKV75y9va3v332uc99brjxc/NCze2cc86Z/b2/9/dmZ5xxxn43s1AoFAqFwh6THbyqkNUewYBYQHggq5DWvVIEhiQlUR0LP00ilET1KIWg0keEAo95V/GKQxJX8TLT7+arQkJ7YE7Q784Pvv8Hf/AHN2oL/2Me0Zb98NIXjiaKuB4wvOQlL5n9y3/5L290w/niF784bBdffPGwcvaiF71o39pYKBQKhUJhb4CnLBWBeyG2kD9FlvYilBOiCgGTqCLeMwVEoJKoHrVwUxYczF0d865CECGTy3g1mQuMgWS1FyYuIcZzy8aiAYsfv//7v99tCySVtmyDunTh6OFo3RkOOP7dv/t3s+c973nD+1NOOWX21Kc+dXbWWWcNNxpueJdeeunszW9+81bUVCsUCoVCobDZmp2QVQhJL8yT8Fq8cxCMTeeAQoiSqPYIj4B4tUT1qBIg+otQYIhiu+AAeTd3dZnxgwQzN5gXvI7Vs4WgQoSxIRkP82h7KsW0Re/qYVRoLhwc3OSbU9nvha3BhRdeOHvIQx4yvD/vvPNmr3jFK0ZDZ3iAbCL/47jjjptdf/31s9vf/vaDd7dQKBQKhcLegWgr81azhqbg2a/I0iYJBsRUksrrmCcviSoklQ2P3VElqoBxY/zwrvY80fQR6V/LeFcZD4WVxkoFsS/2DVFl38wVxs082p4gE9/X01tOkcI2oDyuBwCspD7taU8b3t/jHvcY8lunwmiOgmhBoVAoFApHAZAbyWrPkwkJhKziEYNobKoNSVTHVGclSJDTJKpFemZD30EQGceeR9Pc1UVK+fB7FjEMAR4LxWZuSFQJN+Zvfstv0EjBy9pit3m0hcImUcT1AOBd73rX7Jprrhnen3/++Ucu96NQKBQKhaMEiKFktae4CxGEkEBWd1uzc0zEJ4lqz7ubbUmiine1iOr/A2G6pHJBWHuCVIRJ612d12fsC6KpEvDYmEA22R8b4+LcgNz+3u/93tCe3m/XVQO2UNgkigEdALzpTW8aXrmRPOxhD9v5nAcaNyBWxnh4FQqFQqFQOJiAmKgIDFnsIRWB1xVuiweuJapjeZEAgpX5qUmOCv8PeEMJBWY82/xjxg27DcI6z7tKKK9eVcZlLLuPcTBfNffJsZlPEOeeyjQkV+/qUVJuLhxcFHE9APjQhz40vFLuhgfFr/3ar80uuOCC2RVXXLHzHcWanvnMZ1ZoR6FQKBQKBwAQC4gJ5KInigPwYCqytA5ywTHw4kpU2aaIKkQriSrtKaJ6Y9CH5q6OeVdV453yrjI25quO1bfV4+7WRuLxO8OS27Fl7GgDbdlUaHmhsCmUONMBeKjxoOIVBeH73//+sxe/+MWj33/AAx4w1Hdl5W0ZLCK2xPGRRy9xpkKhUCgUVieOkEVIBR65HmnEE4ZnlW2RnMd5x8MDmES1p0IsIEFJVBF5KqI6DvpWkjjmXZ1S4+U3jI1kdSx/GP0S81UZm3ZMJM60pUd4OT7tYE5VylnhoKKI65aDh5phwDy8yFH4nu/5ntkLXvCC2Q/+4A8On33kIx8Zcl/1zD7qUY+a/cZv/MZSx1nmoVTEtVAoFAqF5QCZMG+1R04sOcJG+O2qgAi1RHWqgASL4y1RLUxjHklk/AgFHvOuMv7mqpK3OraQwH4kq2Pjwvji5e2VReLYlrHZzZwqFLYFRVy3HHhC73CHO+z8TYjOxz72sdmpp556g+8RloI39rLLLhv+hsTe9773Xfg4RVwLhUKhUFgvUAGWrPaUXyEWqQi8imcTsmJuKq+Q1imiiucuiepuPbpHCZBUSOKYd5VxhLD2SCZ2mvmqjFEPzAfGxXzVsdBwiK+iTz2laUiqYclHufRQ4fChcly3HO0D5SlPecqNSCvgJvnTP/3TO+JNb3jDG5Yirl/4whcWDhUuFAqFQqEwXaeTrUdQIKepCLysAi/eviSqkKkpokrYcRLVKnGyHBQ4grD2vKs4FCCrjGeOpSHhhgD3CCaAnJqrivjW2Hxgf3hnIau9fOhFwpI3CeZlkeTCplHEdcvRJs7/rb/1t0a/e+655w6hRjw0CR9eBscdd9zc79QNqVAoFAqFPrmBoOAFG1N/hTRCbvCCLZNjyDO9JarzFryTqFZt99WAh1TvapuHbAguhBXiKvieXlVI5pjoFcTSEOB5IbwoC0NWmVu8b8E4Q1YXKamzLJh7eHfZeu/zlXl3+umnr/X4hUKLIq5bDlZGuTFy8wQZNtyCmwY3L7yifr9QKBQKhcL6oTKvWy9PEYJi3uqiBBIikES1p1DbHiOJapU1WR2MIdoi2FA9bzkkVYEjF/PxpOpVHcsnxsvO+EhW580F9sE+IawQ4BaMsd7VZTzo7BcyPUVGfc825clvMVXrt1BYF4q4HgDc9a53nV100UXD+ynJ+vx/KcYVCoVCobA+kKMKmYRIQFDGDHVIiWR1kZBNiILkl/32cmFb8pREtZ73uweLA3o1x7yrChyp0qxndWy8ILYSVUKAF4laY1+2oze/2B/t4NV8aNoj0ZxHRscUi1cFbWD+QaRrwaSwFyjiegDwoAc9aIe4XnfddbMzzzyz+z1zH1T+LRQKhUKhsBrwpKVHdcrox2iHoEBwIJNTINwziepY7qPEoCWqlbazXu8qdhPj0IJFB3NXtbHwxEJYxxYt8H4qrMRYLSK21WuHnlGOA3GG+LKxPz3Ce0VGfT/2WaGwl6gZdwDwmMc8Zvb85z9/eP/mN795+LsH/mdYx9/4G39jT9tYKBQKhcJBhp5PCAqvvXxCAXmESEImeJ1S5pUAG/47tV+JKvtkw8NXRHW9wKsJ8RvzrpKDDGGFmEFScRiM5S0DCKpkdWoetJ5R9v0Hf/AHO8rAElU2yKz75ZU2z/PEr0JGe+8XJaO0kXB5vNW0jXn63d/93Su3sVBYBFUO54CAmq3vfOc7h5vqu971rkGIKUFeK6q/lM8hTIkb7bq9rgg4XX/99VXHtVAoFAoHHhCE9KhOEQPLlLjhjRvzphlSLFGd8oixD8hpEtV1C+wU/h9p1FPZ865COC1jw5hBKsdEsBifVAEGPcGi3nvIKQsjYyHG2G+S4HkEkrkzzyO6LBkd6zvaKkHllQ2yDXnlfOgvCP8555yz8nEKhUVQHtcDghe96EWzSy65ZLjZUfLmWc961kBmucl++MMfnl1wwQUDaQU/9VM/VaHChUKhUCiMlJHB2J4SPYIUGJ4LOcELOkZUISWQIvc9JVID6Umiyn6LqG4OUzmjliWCtDI3cAAwlhmm68YYMVbYXIQDuzixqCARJFil4dZzSzuYYyoMzyOh6yCjPdAuyGiPoGabzfHlXPJ86LsqiVPYNMrjeoBw8cUXz37oh35o9j/+x//o/p+b30/+5E8OxHUTKI9roVAoFA4K8AZJJtmm6p2u4vlk34R6QkjG9ss+Mj+V/S6S91hYHSry4l1l3P1MMgoYA+cHodt6Q30FEFrHbSoEeAzsC08kG8cilFbCaaj57W53u8HTy/4hpHsVFt4jqLyfUhHmN54PfQSBzw3yjZholV8qbBJFXA8YWDV8yUteMvvN3/zN2Wc+85nhhvs93/M9swc/+MGzZz7zmaPCTetAEddCoVAobCv0BKXw0ZQhnrmki4oeKaQDYe2FkrKPJKpTntrC7mDOqKG4jD0L+xBWSFiSUYgZYzM1xrl4MU+t2TDdnheUY0PuaE97TN5TxoYt679uCtiIPYLaK93UA/0HYfU3klTJKeejgvY8UbJCYR0o4lpYGEVcC4VCobBNxAVDXDEliOqUQY5XSzGlZcvIQAAgRISdtuGh7AevGaGeU7mvhcXGdF45l7bOKGOPhzXrrpqXybgxPox9j7Tq+WQ+sEHKFgnVbffFcXAsMD964lscgzI2zJFNhIbTJz2COq+EomDOcu7MX/pKj2wvnN7QZsg3odYV6l7YS1SOa6FQKBQKhQMBDOkUVJoyzDHEU1BplTqTHAPC2gsHxmP21/7aXxtEacp4Xx8ZXQTmFWdpGuYC8wNPuLnEEMUMz+UVgsqYQbz8/yphupwXx2d+sHjSgn3qXV0l1LgHvcctQV2034AEVZLqK/0G+SaaoHddMd85F7yrLvqwUPRHf/RHQ34w/X388cev5TwLhTEUcS0UCoVCobCVsJSMXtUpAx2ikCVqVs210xjHgG89TnibID0QVgz1owpI2xgJXZWMLnJMvOqQRciaZJTjWAvXuquQM/+v0JZqvfxvU4JPgGPgXeV1Ve+7JLwlqMvUbGX+9whqLrLoKWbr1ROWfNOn/F5AcumD3/u93xtIK6/0/R3veMeKOChsFEVcC4VCoVAobAUwpNOjOlXzFGKSHtXderU4lnU1W48TBjyGOYRkFc/tQSej7ftFQ1AXBWRqLDw3S65AniCjWWpIRd7MseQ7EEc+5/+7FT0yt5m50SunA0lkbkDyllkwYb89gjo171vQRz2COnbOjB3nAlntnQtjQb9xLlxXkm9+54LO5z//+dkXvvCF2X//7/99CNGG9NLfD33oQ/ckd7dwdFHEtVAoFAqFwr7XUoWc9Lw+PeEjyEh6gHYDjq06cAu8qoYDH8Tc1f0mo4vWGW1JFu1mPhCGC8lSdAuiRTv5HeTKUF+AJ1WvKvNkHeOlZxHC1vYP++d4ENYkeGMENfNGJahT870F59kSVIn8PJgLDFllnvdywTkHw6dzn/wOkoog6Gc/+9mh9CLjoLeZNtDn3/3d310h84WNo4hroVAoFAqFPQHGf3pUp2qpZikZa56uizxiuJvPB4FIcAxCIyGs2+g9kowuEqq7aTI6VWd0FS+noauEnkIWs4xRhvxaVoi/9ayuK49UzyKEtacczXH0rrYCX1kLNQlqO8emQL/1COoqdVs5Pv3J+fTCjNm/ocDpKYaYfupTn5pdc801g1fVPF4JL2NMv1vSh+oWRCTsVTmfwtFFEddCoVAoFAp7Uks1lV/n1VJdl9csAamArGLMj4UDs61CEjZJRvP9fpFRtk2IUOldxaunNy+JXnpXIVcQJrd1jhPHhazi4W09kpw3XncIK/OSNkOy+U1LUKdKMLX77BHU3YaiM0cgqszx3sIQfaY4lXnazC36HqJ67bXXDmWFuFa4XiXveX1CVk888cTZySefPOyLPjmsIfSF7UIR10KhUCgUCmutpaqYEu+nDPmWqG5KnZf2QFjJk2zBcfGuQozWSZQhP4uIF22SjE55RDdJRhcBxIjQ08997nMD0WqFjlT/ZZO4zgvJXRYc0zI2Pa8oHnfD0i2JBMFephYq/Zu5pxLUVcXDeqAtzG3OhbneXnP0GUTfEjbMN64HvKqcD2PA9WpIM9et/aGHGa8qZPXUU08diGt5Vwv7gSKuhUKhUCgUVgIGMh4ZParzaqlisKeg0iaNX4xzDHnIRktKIBOER+Jd3W04MEa+oZj7SUbz/baW56Ff8OyRL4kabTtXaD8EFZLEYgIkaxPh2pA7yGqWOWLcLC0jueTvXrhwD5BDSF6SUwnqpvKjud6Y43iJe/ONhSHIKn3IOdPveFM5d/7m9xBVxoFzNXeV7+NNRSWYsbjDHe4wkNXdKjIXCrtFEddCoVAoFApL11LV8J1XS9XyNGx7EYKLAW44cEuMIBGqA++2LfTD9ddf3/XiLgprix5kMrpIP0GU8K6SL9nLtWRuQI6OO+64wcO6ibBT82chzMxfCBufKZKkuBPzlb6eWoDpEVR+vxcCXrTVvNWxEjYQT+YNc/PSSy8dCDrnylhwzRoJwTnyXnXmu93tbrMTTjhhRx2ZxQOulfKuFrYFRVwLhUKhUCiMAsM+BZWm6nJi7KZHdZ3hkPOAkQ5hhVC3oC168HZLLiALEDCIwzwyOi9U96CS0UXqrUKW6CeIIn+34asQveOPP34gSpCjdfcFCyp4S/EwIvaE552xy4UWy+bgVex5E/msR1D3etymStgY3st8MsrA3Fv6PAXRuHaZ/5Yf4vxPOumkQRHYskF4afGurjt0vlBYB4q4FgqFQqFQuFEtVfNUex6ytpaqXtW9DiXEKMebJylJYJzjOcLDuo7SOfQDBIjjJQmDnEN86AP64zCS0UXGgYUD8ywh9RCtdu4wPyBJd7rTnWZ//a//9bUQI45tHVRfaQdzgtfeQgvkTFEh2sAYtgSVv/dzLBWtsoRNhjRzjpByzl0izme+N4RfAsu5cB2ovGwpn1Rjpj8grAo2LQOOC4EugabCplHEtVAoFAqFIwzIRXpU59VSTY/qumqpLguMcYhJLxwYcmQ48DpCHCEKeA05Xh4LkgoJ41hHkawyTyBUkEMIkl5W5pAkC4LEHIEU4V29/e1vv/LihnmYSVDZWGjx/xybNvTyUiFVzAnIGV7WFEvaplBY2i75Z+5ZXkciyt96S9swfcOBzdPFmw055Xv0S5axYc6yD/qEaIRVoiMMy+fa4Dh4bwuFTaKIa6FQKBQKRwgYtZaowaMzVWMya6mqrrpf4YOQIcOBaXsL2ocBzuu6PHkci1DTNrwU8sOxtonw7JViNGMACVLIyL8lkMwZFzYg9mzLhJ1ynB5BHVtQ4TsSaBcWGBe9qIwT3l1et9UjaAkby/FAUjlny9HQt5wT7ZdgOichsXpe6XMElfCaMg7si41rmM89fxYP6A8iElaZw9w3CAMnx9tFC647Fif2upRU4WihZlehUCgUCocYeqLcplRSIRcSVTYM4P3Oc4McGQ4sOWrDgTHCDXlcR39xPMKCM8yUfuA4ELGjYpzTF5AUiaH9wRyCEOldhRCh0szcgcDgxcMTPeVd5Xd6E1uCOq8WqnmbtInv6mWXrNIO2sDc2Naxom/xrKKyzOKIZBUSa59kySjmn8rFiC+Zqwr4m8/5jN8ZiYB3lX7wGqZf9Dgve12zP64J6rxyLdLet771rUPbAWPwlre8ZXbnO995dv7556+9vwoFsJ1Xc6FQKBQKhZWgUqhEdVtqqS4LjHc8nniieuHAu/EY9UAfYfBjnCdBxsDnOOSx7qXY1H6Bc9eLmmG/5rFCWPkO3ndIkbnNvPI3YcEtKeoRVN7PI6htLVTmAYSJ3zJv8eTmdzg2bWAebyPMk4as8ko/cE72CRvzmfazEKBCMH3NK+fM99kP38u5r1owv4HES9gZC/qF62Uqf9W6w7lxHK6J6667bvb5z39+R0Wc77qowd9cF9vqzS4cLhRxLRQKhULhAEMhFsWUegquCYxgxZQwkLcp3JV2Q5ggrK16KsBTZDjwOgEZI/SxDZuGPBBmetjrVzJ/9Kq2Hnn/x3hAniDxzBuIERt/QxYhlhBaw8+ToE6VlknoUUyBJAgRx8YLzr4gqEnAaBPHZ6y2aS4Da6NC/girNWoAIm8f8V6ySkkg5rZk1UUl4G8Uk8poCl75Pt7UBISVjT6zLdYabgmqY2RIOP3NNaFXO8G4uJjDuSlKti2LXoXDiyKuhUKhUCgcMEAmMvx3Xs3JFFTaxtBJjGeMerZWiRaj3nDgdRNISBaEoiVrEGSEhPZLfGrTkPDoWW37XO+qHjzIFCHSEhPGAaLF3IJQUaMVYjRV0zcB+WIfSVDbWqiMDeQpFXVzTkBUIayQvG2AhM+cT73TvHIuLZHXQ3ziiScO58J5QEghq/Q37/k+EQeMD33LdcKrHmz+ZnwcT/7Hfpm/7MMc13ngd7SZdrJoRJvbRRzGhXZCrlnMoZ1XX3310JYirYW9wvY9vQqFQqFQKHRrqWJYYmAuUktVr+o2h/BBGA0H7nl1DAdetyeHPlRYJgEZg7Bua6jpbpBCSsyj3mJHEisJlB5CSKREE0ypTyd6BNV8zBYcCw8ex2rzmYG5q3oR9xOSPTdIK/3Ge4WWzFu1firXpkrUzGvA9WkoMO8ZnyuvvHInDNfNmqyA9+0ClJ5nS/wsqiYuoZZ0cw7m0XIMSDDli0455ZQb5cZyvF7d5EJhUyjiWigUCoXClgFSkB7VqVqqGLvpUd32sFaMbrxAEFaM5RbkLWLYrzscGGCgQ1ghcAmMdAjrJo65n7CmKWSo19eZ28j/9eox/yzHAqliTCApU2QRUtYjqPMIpmrREL12XEAbjrxfgEgnUaVvBX1HWC1lkwyVVrTKPFX6kD7hfFROZnEA7zHn/bnPfa4blptEkb7Mv3nPNU//uBhgCHdutIFXzkGCync5Pp+Zp2q4tQsEENajWu6psJ0o4looFAqFwhbVUsXw7XmberVUIVr7acwve46qA/fCgRdRol0VEDGIBWQsQd8R9ogH7zAA0mM9VUhQ6xWFpDK3IKR+FyLTjofhppCtdn7pIWwJ6rL5pXpx8bD2FmZUJ16mlM66van0ox5qiGp6QPkMRV3mM9ctfQb5Y/7SR/SJOaqcA+/ZJJi9UkIJa7UyTtZcddNzyyYZdkvwW2vbphcbTzDXgmWlaC9tpK3kybLfw7aIUzgcKOJaKBQKhcIeA6M1ParzaqmmR3U/a6muAogR3lW8rK03iXMhHBhPzya8OhjqqLdCjvLYGP4Iy+CpOkh92YP5qG6qvhri66Y3jn4Yq4uqd9Ucy5agsu1GAIl2SaJ6tXg5pt7VdSo460lOMaL8W1EpF44M+23bzucQPjZ+A0mlndb0pY/xrpp/6/Vqn1muRo+tdZL5v55RFgz4uzc+i4TPOx8k3BlezN+0nTbQLhaKOL5tZt+HNa+7cDhQxLVQKBQKhT3y4CxbS1WF0YNGrjCSMZAhrL1zxcOJ0axi6roBGSFsk+MnYYUcQFjnhb1uOyA1egMlIklS9WBCQuhjCA/jAKFpCRl9gpdNz7MEdZ0iXpA0vautgBNz23qjzPdF5npPFXfqs3bBhM9okzmovdI81pm133g1pJZ2KkjExt+Emh933HEDqTQ/1BBdfsdYsXgD2W2jCiSPliJqc9j1hNJPPfA7vexZwshzda5wXD2rto/rMMvnLApFougXjiEJLxQ2iSKuhUKhUCisGXpn9OJg3I2VqDHXTI8q7w8qqYIsqA7cGt8YxoYDb6oeKsY0ZJUQziRIeLAw/PWMHcT5BOnhvDg/5hWkAcKS80ryoNoucxDCAjmz1IzhrJBUiNam+oT+p80Q1l5+LW2wjI2hswqPTZFRhYqWAf0kSeV1LBQ/Q6nN/eV4tJF5Sz/Rx8xlPrvjHe84bL1Qc8eMBZSedxnSyD7YF4STce2p+DJve15QCTXj21scgoy7UME9BfVix5m5wX57NXfH+kUBJzZr6XKdO7YH8boqHDwUcS0UCoVCYU2lMPSozquliuEoUd22WqqrgPPF8O6VLuFcIUebVILFsMaIhiQkYeZ4EA5y9raxDFAL+g7iJEngnOjXsTxQwHm54KHXjt9DcvkfHjb6H6JkCZYsIyMh7LVlmb/9jLnAOEBYJZqG6kqimPN6AlsP7Nh+F/1bTyl9wPEl9xJOrjVzcvncGqYQODY+N5Rajyrfc4EJjz3eVaMFVOUV5o/mudk+xZTYOP9PfvKTNwoJtvyTpFJCm4thbLS71w98zuZCBa/+RiEn5oIhz719eE56o3ntjQvEXGVujnNYcsUL24vtv4sXCoVCobBl0LjTo2oZiTFgQFqeBqP9IJCoeeB8MXwhV63HByNWwrTJ8EHGAVJHHmt60Tg+5AySsclyQIw/x+e1JU9tO9u/IS6G+JqPqliSpGFs8QNvJSRK0R/mE/MQkiNpab8PqWAOSmIWRXoes5ZoW1dU718vN9MSTbRVxeJlYY5uihTxt95a+5BXCSjIRSHaSr9yTl6v9I19n30OYbVMjXm3zGU+d4FKcHz6dOr8CfPl/Pne5z//+RvdL8zvNQzZfGUXxKbuMfzWRY8ce37DvpgnjD/fUxRKSPKZi27zPNqSYq4t9kkf8/6gpTQUDh4O/pOzUCgUCoU9AMZdCiq1nqIExnAKKm1zLdVlgXEMWcWj1gsHNmdu0+cM+UEpuCUKhFeSr7mpskAcD7LKNqX+LCwvI6mSrEpCzBOcCmGV+EA+zKHkM76P14vN/UkeeIUEmbcqpghofubfUyTGa6IXCm/YMltvLFTK7ZHR9nPe662fl5/aLgqlN9kcVfYlWWUe63HNmrP0Nxt92FtoMsoCstqLsLD/VUW2Pm37Pcgsc9YFHonlVIqBIlCQR85PUpvE0VBkxZ6A8y+J6tSCm7BfFOnib3PxJcFFWgt7gSKuhUKhUChM1FLVq9qStF4tVb2qm8rh3E/o0cNQb4HxbTjwpg1YDGUIa+vlxUAnhHMTqqjmK0I+evmK5j4yZ9KLynsXOOwXPZi039qp/h8iwNxh63n6+A6/19Or+i3EylBc5yJjwt+0IWu0GvaaSLJrWZWx7+hdZOO95ZkMxaWtECY9fLRH8pmbRHTsOIL221dsehWtkdoKOvme8+T8s/ZpkkL2Q7sJI6evJWa0W7Lfm8sQRfperzHElE1w/owb85HjGJFAn7AB2mTeLMfhHBVXsnZuO4/pM8k0/Wk4MufJfnIOcS1yTo69eakcl88NE+/1t2V8+I6vbSqDv3nPe96z0OJNobAuFHEtFAqFQuGYNyI9qlMGmXmFbgelluqq4cAQ1szjy5w2jGQM3E0Dr9L111+/k1Mn6H88rJsIScbgx0sGaW097PSNHkEJTY8YAIWH3PTIqzDrZv4nr5C+FCgyj5j2QIz1irbevfbYqyJVcTlHiA9klVeOld5QhZbYdnMtQMLYf/aVC0aWhWqh94/fSs4TfMb1bF1b+hZiaci+obR8xv57ZNUyPoaFe1w9yezHRQb6jDH64he/uHMPcUz4HtcL35Oskg+cUQPZf8wB2gZZ1bvJHPAaMKqB9kk46Qf22eYtuyiRcIEkieqy+fb0L+di7nChsEkUcS0UCoXC7KjXUlWldQwYZVmi5rDXOqQvDAduCZslNDTSNw2IDB7WzMsDGNp4WBmPdQKDH7LOubf1dRUykvCYq9pDhgDzGz2Pet3oVz43PxCY20rfZ+3NMeVYiIe5q1N50+lJlYzm1vvMc7CMDW2FmCQ54bjMA8Nhl4U5nJLUXv3U9jzM6bXvzVnthfHSd/yP6xUV3Wy7QkW0fYys0eeGhfdSAyzjwyskVSGt9rscn+9xHO43V1111ei8YV6zPxch2Bdj8LnPfW44hl50zpt9SFj537zFttaTuur1q2I081TPM/sv4lrYNIq4FgqFQuFIQM+LW+tB7OXn6VE9iLVUVwGGPsZ3SxIB/QFh3YtwYIBxDmHFQE5gHFtzdF2A6HDOEIRWaAlyAAkyPDUXLSRItBXD3fBga36mirLzLRdBxkofmbuqQE+v7iljAXHskc6WjC7jRdPLTl+MlXGBhEH6ls0jNh/TbaqecfYVY067rIfcet2FYdrmshIGnP3Lfmg3iwdj4fz81vPvtU/vsuq8tOUzn/nMjeYpMOSXfeKBHctX5RwNObZdnAciTvwu83n5nDYYjt2bP/Rb60ldR/oC8wFibk51LvaZH10obBJFXAuFQqFwKIFhhVEpUe3VkhyrpYoheRSIahrqENbWw2gtSXPm9gKQNlSCMZDT0MfwhrBa93MdgAzoUUsPmPnNzCGOq9JrhrMyn3iv56/1FiahgGhIVi1RkjDs1nBcjm9ZFMNxmZ94Ddk2kUNNX0DWmAutN1CyDGFrc0qnwHxKojoV1QA4L0OlJbr0R28hJWHYdM/rx2eKWk2FtDPehoX3hKbcB2PI//ke10x7X9GLzrm0pXIE/ze025xV9kl/ffaznx0IK/umv7It5q9mWLzqx5ybRHWdns95YmQujDDHD3pZr8L2o4hroVAoFA4FMjxQojqliNoS1U3VGN1WYJCOhTZidBsOvFeleyBLEFbCD1uVWMra0J51ENYxj5oKubxCBNL7lZ5VINFQoGgsBxqyw37Mp+x5RWmPirN8ZihxlhXi3Hv5nbtFeld7Czutd3EK9lGG/U4JmgH6WeVh+pQ5SZ+SyzwWMmweMbBOa+YaJ9FWJGls3vBbSVmPVJsPy5iwf8aK+rhcN5I4S2PpdadttLE9d/pPrypjye/pI6IKsvZt2w7nAHNJVd/0po6JSG1SjIxzVnhLsTE+25SSd6EgirgWCoVC4UBCz5ce1Xm1VDHwUlDpqHoH8F5BDsfCgfHorJqzuAokA2w5foyPHsZ1LCqoxKtHLecPcwdSIEn03C1Rw3f5P20i31QvGt/LvGdJzlTeZIYmQ9B6NVVT7GgTCweKTkFa22tG0S2OPUWWM2xXojq1UGRUg0SV/nShiXDYVkwoQd/q9bZmbC8sVaJJ+8f6jTYyhoaFt3DxgPM3LJxjQjAtncNmfVXabami9ppxAUSizW+Y59ddd92OkJTljHq55IQ6H3fccTth5exvkwtslgfK8koCYm6uNK+cNxvf01u87nzzQqFFEddCoVAoHBjoFcPgxMiaV0vV8jRse+U53Ebo1TP8MGFpDgjrXopOYfBCoPE0pXeK9tAWCOtux6wNc0zCwWZ91BNOOGHnWOanSlYx0iE69J21MrP0kSRvkRBa2gAxYOupvkJy3Ne6QR/rXe2FryogZHhyr+1JVKdyxIGlcZKoGgrdK2eUsMwNG2PEb2h7zyvK/5m/tHsqRHYqFHpMaIrzhGgy/io7G81h/dUMP+Z3tIE2WaKoN9aQPNqR+dScszm4d7zjHYew+L24Z7VeZ3OJDZe3zzknzi9r/nJu9A1tL29rYS9wdJ/ihUKhUNh6YOCloNJU6CGGVXpUD2Mt1VX6z3Dg1oNC/0AQMZT3ktRjqGPwEhacBj1GMcSBsODdqBW3YY5tKRqIMSTl+OOP3yE69JOeVQ1wPdPWDW3FuiR58/ouhZ96Xm7DshcJx10F83I39S62+Z8Qvey3efU6zeNNoso+JKpTERGKoSVZVbW2J8TU5pzOCwu35m0LjuM4Zlg4v4Gw0gY98pyLiwsnnnjicL7sn88VwuL/Y3mtgH2xb/qS/rF8kIsGLNasu7SU5ZRyc0GH/mV8zBFWBdvyNpZsAnlOltGh7fxfte2jogtQ2D8UcS0UCoXCVtZSxaCaCh80j1DPV63435AoaZS2oK8grFO5f5sCRjskpvWcQZ7wMO1mDLPmai54YHDTJxAjjmGtThWAAcQDMsQ+8ABLliAREAp+y3fGSN4q3tVUBl43OJ55s2O5m5wH58N5K2SW2zyFWIhLElX6h+PS5/ThvOuX30tUaQ99wm9Y0MCL1ws75ruWsJkKmW3VbxcJhdaDSNkZ5mnWcrZOKwSTc9LLKIGzLT1i7lxjbkEGKeHkYgd/MwfYFlloUwjMLev89j43ckBASrk3WCbI0jqqFnNOqodn/3IOnGfWLFZsS/XsIq2FvUAR10KhUCjsGzR03ebVUk2P6mGvpbosrPcIYe2FA2N4Y5DuR7+Zz9l6oiAgkMlV25Q1VzlGeseydAvHgSzwffoJg53/SSogOeZNQqLILTQPGkOefYyVHkko2DSWQ6yHbxM1cD22fdESP8lXlnHREwpxmcpP5bwzP5X39I2EF+8kx54KH87w36w7y7GZG2MhvIuUsFmErOslV2hJcHxyTiGseh/pCz3t5pW6mMG8SAGttp8UTuL8DEtXmCnPicUj5pT1fK3LOkVMVyk3wz6YD5Bt81KzvI731Tvc4Q47ysBsnDfttP6w/aGKMO8ZFxd/+HxKY6BQWAeKuBYKhUJh62upKn5Tq/o3Bn1IOHBPaAdDVHXg/RCjYowlRwnGFM/TKmGRGXorYUrvmOGceDQhERIyy6Xwf/qJfbDRf3yPflL9F2NdkjeVN2neJ23Au2cupB4oXxV9StGmdXmqDPvseXaBEQkSKUhaW/ZoXn5q1jE2V9Q886nwX69dtuxH2snY0e7ePUCBJPp/qgzTvDBsSwq1+2GMEIS69tprB+8wfcjGePJqNAdtGEs90AuZCr/8jnZYzslcUEkn9zDmJX3G8Sl7symkSrbnxbhzbO4LEGfOzzlvnWLnLb9JotwuLjGehncbsVAobBpFXAuFQqGwMeiRkVxMCbK0eYSGDxbGDXYIa69cBcak4cD7Ab1obagyY4qHdZXwWAkTxj4Esc15VsE1vXmKKUli2IeEFcOb/jF0c5ESKoYgm39JO/iMrefhtPyJpX7YWnAcycIim9+nHRwfMpokmY22QKQUNqK9UyRZEuKWIdt6tb2GFw3/bWshMxa0F0LXC2GX4NP/84Su6G/mQlt/V3D/0NMuoYK40Q/XXHPNQFiZA5AzRbs4Hse9053uNHhCrZXK/jP/mT5VfMmFOPqHjf23RDznleR9Xr5wC2v5mks7VlqJc1Qx2bxtQ+UNS7Ycj/3ivKIPptqVGgKSVfbFeRcKe4UiroVCoVBYG1rV1qqlul6Yh6doUALjE2Md43TKS7hJYCzjYcWAT9AeCGKGSy4T/vzZz352h6Snhw+DHVLAfvXeqoqafQZRwqDHeMfoPumkk3bIraGorThSlstRkVkP1hR5g/BYu3WRhRdL8ywSZkn/ch6GtHq+egw5PxVee8eW4OolNOyXvmA+sW/L/XDuXL+GiCYx9r3knz617m1+b16+qf2F568N4W3B+bKPsZqzHJsx5BrQO8q5MB/ZmEN6V83vZOOYed14HI6RdVMlepJd5xbH4PstgaZPreObAl6G246Rz97nU/OIuUif4MHl1dxTIcFsF2OYc0Yf9MZFr7NEtTQECtuAIq6FQqFQWBoYOuZLsemJwmiaypWzHiPGEAbrUa2luiwgEZDVXjgwxrWqtPvVnxjykAMISgICgYcVUrKM95zzhGh84QtfuNGc0jMPKTDX0Pko+D7EA1IBEWHOUWJEAqEqrcJLgO9BCBW2kiBB4sZEdyQ1EAP2Z/3QJEaS0kW2/K7nzHuJN22hnXp5JWFGKvTGP0NaaW9bC5SxY/+cK9tUvqu1WN0MP2ZLb7KlVCTY6VHmPSSIsaO/mL+cC6Sy52GmPRBDQ4Hdl8SdsYWUQdD4zqc//emdusB6idnynCRlzE0iE1TIlajOu4703jIm7s86v4wFOdLmMbfEdB3XqKWkyMul3+n/nKN6j50TbJw//TZ2fEO7MzWjUNg2FHEtFAqFwg2QhBSjtvd+qixNAmMuBZWOci3VZYGhaf3QXkkQjHWM7k2o0i4KQ2AxopMYYKBjvEOoFyWskIvPfOYzOyI5LXliLkF22Cf7t6xHgjlqCCiGN23IOaeaLoTJMHbCRs0RVrCmBwx+PZUKXSkSZjtagta+Xwa0jXbRv4aqKuTDvlQk5vhJdlNYx3DhljxLLN2mRH8k5+Zxjo0n48G+zBtuYRkic4+BpNdzy3ItEkPGwxxRvensC/Krp9hFM8dBxWhLtJi/yXGZE3j/Jc3WJ3V8XABh/yoH+8r+mSe0lznA9efvWLzg76nyPLsBx5SssqDTS7vwfJKwjkVfVGpG4SCiLIhCoVA4ItDonSKkbFMe03nQaHK1fxN1KQ87MNIxUNnakNQMa9zP0D3mkl6t9PTQPohBGvRTwPjGs4ox3npr3R9kldquliJRbEZwfBWp+T4EIuedarp4wvg9/XrllVfueDDHFmEkOuYLK2QjeUsiMRU6nJhHbDkXPI96C82dlXwx5hA/PYx6fY1gSBGz3Dcw19xFAfNZ6VuJLa8KM+lVtV097zHzgH6EzEFYzRXlPiARpc20ybqn5rn6fwmpodmqQnsf4tXFMs7ZsjuSWucC32MOsA+9vLSfvmFOcJ6Mox5V1XHdUi0XSKIh1vQZbc6wab2XLqZ4TTAnFslTXuQ7HJ/jSlbbBQHHg/7mHF2sGFsgtD+cL7sVVFJ92cWU8tIWNo0irgcEi65Yn3322bOLLrpo4+0pFArbAw27KUKqAMluoedCL0S+xyiqPKjVgYFsOHDP24jRDQHbT/VO5hBeQMhVeuloE+2DtM4LheQ8zTnkfHvzUrIKEWPuQkZacmi4LGDupRAV/ee85DtXX331DWq69sDcxeiXiPDam9P8HjLBOSwrsqNn0b7jlTaxP0hPLxQ8PWOGo5qbyd+QFPuC8ObsH0ig4c7uq81V7YWImvuo8FMb0qwgEeTRe4skinOizxSmatV4kwSzmbdr2C1jplAQ7bYUD68q40qUDPFVEZg5cPzxx++EbvM/80yXDdGFNHqOOdcNuc39Zt7rbmHaRaou55jRFo5FnzBetEP1bPvBcTU1Q083c8X/WfZnGWVrFxcMweYaMIS7iGthL1DEtVAoFLYY1vKbIqSLhu3OA0ZNj5Dm+wr1XS8wBAmJhAz2BGc2HX64TDshRYStJoHE4IXkQVjHvOv8FiMXkooicE9YKkvkcM4Y1ZAuyYzQaLcOq2JPhv1i9BtZYAmQHhQWskarCszWJx0DY4Wx3oYT6+1qc1Tb97TH8FjOjb6ABPQ8tnpXzcOVpI0tXLAP983WC/+VOHM9p0JuKv5m+ZYk2XxGH7P12ku/KfjEb9iXXnRJl2Q5CZAeUtrAMdgPbYKQMa8kZLwyRxw7vufnKhHTR7aDhQ8XM+blE+dG30EaJaySQv4HEaRd7L+Xj7wKOAbHpF8lyllmyNBp+twFAfrFBYEkzS4gZi1ZfmsEx7KRAGwSaeeV7WFj8Yl7AmPomBUKm0QR1wOGpz3tabOnP/3po/9fpSZeoVDYeygmM0VIdxu2KzA+5hFSww4LewNDVnu1Nw0Hhky13qr9ItaQtZYEQhYgBz0vu4JCGOKUxYHA9BSmJRgavBjsvXqceofYIA8YzxjLtAtDn+MpftOD3jmIDEQ781MXmfe0iWO1eYWQJcj2WK1RvZ5J+NjYD9e43jDPjb6ElCAaZPmUlmj5ak4p40M/65WWeOZm+K7XuuJV88TUJHIuCowJP0mse+G3fqanlrmgpzaPbQ6xZWZUIVYlWZItgQbm8nLubIwp/Sapso1jodnpyWSftM3z5H8q+jI/b3e72+14fts6vVmGqKcW3W6SduaV3mZDw1PwzkUGQ9UdO0H7Mv+4d7/wmPRbhnhnznB+Zri13nqJsc8l2mVZqauuumr4nosJVcu1sGkUcT1g4OZ1xhln7HczCoXCCDAqrPs3RUinxFCWDdudR0hLuXd7gCGIdxWjvCUMGOEaqNtgAFpKpM2rw+MDsWrz2Zj3GuKeI3/nXDfvUIEk5qbEqAVGuddT1stkv9auNReznePmp9KX9CnH43vLLgTQLoh32z6OC2FNRWIJSRJVoyEsm8KWERKGJ0OkUT3m1XOWnCcBtXaruap81iOe9B2E2DzVqfM2FFiipQdQpWG9qPSxpE2BKvOJ/Z9EzfBu94NXzhxRjyPSu6fwEnOLRQbarSKu/QJBykV6vk87JHYtPKcezLllTvUWkAwH5hjzvJZjfevCCNdRei2THBriSxsYO87vuOOOG/qY946PfaMCMucr4ZSYpsiV104uevQWQBwr563tUbma77gI4/+MvjEveF4d2EJhHSjiWigUCgvCMMV5+aRruTkf8x5NEdISPjoYwKAzHLj12GHwGQ4sCdpvQI4ga23oMkQIwpqkIWt/QlLdkuxibCscJNHJ/NSE9Uc5Nnm0ElW9ie4Lgz49vbzPsF/zU1ddAOB49AGkKwHJhLCae0voM8I5jK1CSkKvJv2hZzOvawkY54vwDh7ClmBBGOhLt6k8dUWQFEKSJOU46P1sPaNsHFsyxXHa0ikKX3HuEmFDkvXCOa7mp47lFSu0RFsNWzb/UnJFv3BM0yWy3qgeduv3mnfcfiffu18FhZizbZkcQLsgzcynDHfuYV59Vckq/UobJH/MCb2r9oXeU73LzL8staPK8bKEuecV1qOrp9o+tryS5NfnWS622h7aSMSIodnMi0olKWwaRVwLhcKRR1uTdIyQrkPcCCNiEUK6DR63wu7A3DEcuM1DxsBTHXi/w4Fb0aSWrGGUQtbMs1VMR0KpIZ4kIJVpebW2aeZMCsV46CtrwbYkzdxCDHuuDQxnSIthv7xfh6Ip5wZhaHNrOR6knT5QlVhvNONMH+h1NSeQvjFf0y1za1UnzsUufy9RHVsIU2FYZWBFpHqEtFXLTTAvGW/GMhcSvP/wCokzfzTJl0Q1vWy0l/+1JXYkTYYD0+bevGcu+D+Jr+HGgnFWJXrZ9AbmOOfKeVtHVs+j9XgzfzW9knov81Uvp1E2rRfV71l2yNI+9EMuYLi5sMFYSmDzHBd9BrWhzC6A0C7HTDLa5jNLbv3bBReJswskKikbjaDXvVDYJIq4FgqFQ4111iSdh3mE1LC3wuGG9TchP603B+MYjyAG87YYeWNkDeMUsoYxj8HrdzR89a5KrpjjEDsMf8NHs8yLSHEX1XR7ni+MZZVuIU+G/Zqfus6IA9piOGuCa5bcRtp2zTXXDGTVXF3OyT6QmFs3VFKd52KJKEOggcJD9imbasF6jCWgnK99YRit+1gGfN/8Svs9FWFVMbbkjoQMD7hiSIJ26d3Vu6pX3AUJwHfGQpat9cy50X8s9Lh4ouAVbeL/zIGxfOKp88Vzz4KDnk8XGUB6C/mcfsmw2zGyKBk3J1TPMvuxdJPh1s4Jnwcuvkji6Z9eTVmJp8+NVABOT6pjIWiPi0u8mlOd+aqtF9pFFc87ySrtMvTeMH+OT8SBfVoo7AWKuB4wvOlNb5q98Y1vHEKKrJf3gAc8YPbkJz95ds4556y83y9+8Ytzv7OOnLxC4SDVJBUajVOEVBGPwtEEhhvGMYS1zQlV3AUisy3hwIBrRQ9nAmMVwSTmNEY8xqmGroTHkGc9nyqvanRnGC+GvWGZChNB7nltr08JCscn5zPzU1cl+mNKv+bk0QeQpRSAUswIUv3hD394aHuqxzLG9AXnbfuSSOvp1NCnj/Qcsg9+n2Snd27mA0t4DSteFRAoxpp5ajkXRbEkXIakSsb43NDZLDeUnnf6kLl9hzvcYdgHf0vWDLnNdvPe2qqWaKFdXDuMAWOe/ci+8bAaNpzewam/OQfGtY14kKCZv7pMeGvWmjWkWlEi9qMgGePK/LH+MN9RyIrzI3+VucH5q5Cc2zLj7HXJXKUPIej0vyrIzqNcLHHO0UbFzuy39Kpa91UBNc7RecvmvFdEq1DYNG7yzXVYdYWNY5Gb2CMf+cjZq1/96hs9XNa1f0HI2CJEt1A4yDVJ8/22eMYKByscmLljOPA2GXVcQ3jPaHfrPYNkMN8xhF2sxEBVEEhjWCKlB87f+v0UUfI647j8bWipJFKCd+KJJ85OOOGE4T3XXksyewqt877TCgEJxgqylCJZej8l173cTHMwDV3WQwax0ptKv5hnqxfPUFGVY8cAYVBpmP3tNkKDvjZPM1WhFd5R7MhSWPPgONI3hiuzX8OD6XNskJYQKujkvAHsA6LFRntS6ZbzNkR5bAzHwHkpDNYTQGPc2O+U3cP/Ug3ZXFDHzpBpyxs5ry1Hw3EcO/oXogqxX0dqAMeVqHIN03/8bRSDeap5LnrGDVk3NNlcVxdV9ACnN5jvm7PcOjCwOc3FZYy5Du50pzvNzj///F2dY6EwhvK4HhBwA3n4wx8+O/fcc2ennXbacDPhhvW+971v9su//MvDQ+k3f/M3Z494xCNm7373u7fKSCoURNUkLRwWYKgaDtxC4oKBvE1eeIxOCCvtltRpkBrGbhisocCqrRq6ikGOAc8+ODf/TnEmv8/GNc8+0wvNsQxFxZgnHFnSixGNB3STfcA5KeTDuXJMiPZYhAb9AuFi0wOZz2YFqyBDLFTwGX1ijdZeGaB235LVXmmhVc+Rc2Kemt9o7ixjq2rv1Bw1vJfzSUVj81g5Nz6DKJnLzJhzDP4vWVUwKvM8aRu/74XSQ/j10i6zQGk5G/o+y92oDsw1SR/3xKnyb36jR10RpexbS8SYg8w50JeOXdaRNWpg1fuAtXlNP2CBzHmlEFa7YEb7DaU379lxYHwU4dIrzne5JlMVWtLdU/tukSkB5QsrbBpFXA8IWNGy0Hri+7//+2fPfOYzZw996ENnl1566UBkX/rSl87+0T/6R0vtH0XDeTjrrLMGo6dQaFE1SQtHZZ5jGGM4joUDY6SuUk97rObjIh7Feb/BUMXgxfB18UhxHQxbPXsZBolBbKgg35FsuG/IiqQsS5ioaGudR4CxTJ6o5M8cOb2760KSlbZWJ0jCShv5G6+VOZ20zZxBFWslHhAuyRiAFOhBk+jzHfaX3upeGyW5Ch6tY3GDNnh8ntN6BxkHS+YoCoVXDJijS1sVkUoBHs7p2muvHcbdfel5tA8dU/pFgmdfcrwxYtn2ifVX8zdj6sf5Gb81PJfPWUSQfC5TD1mRKvpD76UEnPbqrU6vsKWMHFPLGuFdNax2GVgzVxViSSrnxoKBiw49FWRrErdeVckq7ef6x5bUA2tf6il2LMfmo/u0lqx9oJBT1QIv7AUqVPiQ4Lrrrhs8sRgkd77znQcRiXWDmzE3vQoVPjqomqSFRWBYnorJKmPm60ESpWpJpCGNGJJ6WNIzgYfI0MhVSeYmPBXsE4OXdks4MIo5B3MMab+quJynxq5kVU+q+aBJ2PW4snHuigy1IkIa0xATDHrz/cZIZu/vRb4z1gecP8JLnCNEgPecl/m5hoPyXUgXnjK9qIw7HmAVWPmeHnWOPyXes+7w3zaXkzZxPqTucE6Mk2kUbqr4smXdTQmNr/6P30CAJXDOm8zF5RwMIXUOSHraPF/+z/64R1hiR1LJ7+lHFjVsQxLURUL02dpFAvqb/ZoXOwbOyygBhaW8RrK0kefkta+wksrQjCvHYltU2TrznCWrLqzwqmJ3e26G/Nrf5qJ63vSpC0suNikS57Waiy+Gdee4Jek1ZN+SR0ni21BhQ+ZPOumkChUubAzlcT0kIKcA7+s73vGO2e/+7u8OD1oevIXCGKomaWE3wJjBuMJgnsrZE4qXjBFb84rb0hdgHXmOy/xGgxWiwzn2wuUw6qwVihENwdkW0H6McQiNQkqWudCzZVgw/6PfIQ+cE4Yzzw/OW0+q9TUzdBSjXSNYEpJiN3ou+RuvF8b9Js+3V6qEc0HIkPNhnnJOGN2SDkkDf0N0eGbSTs7J3+Tc5rwQRKQPp5TI6Q+JatY81fud+ZzzBIay7IqhoZAsyDikJEvRCFV9HaMkqLz2UolcpIAI6mVk3xJNxlEvOefj3+b5tqSTc5VYSpiE/c08XNbjznjhVe4pdjMuzOOx/FX6Uq8qv7dsjaHs7s/+s1QRfePig4sA1rTlHOblywIFq9KjyjgyhsxTlX8Tikh53dn/huCrYG0b2YfzyznEb/Wwu0/24fg5Nob2GzpPW+irNrKkB+8RVcO1sBco4nqIcPrppw/EFbACVsT1aIftVk3Swl4RVo0dVVlbT2KSQudo+7/W86g3LUMD89VtWQXOebAcBufYkoIsydGGQS6K9BKu2+vIe8iq4Z2GL9NejHrCGBU3o5+JnrHMDVE6kG/z89IYN1eRjX0oOqToUtv/GMKQVb83D1kzsiVti3zWejwZO/pA4m65HsaM8zIUFvKEd1VlW8C+6AfDooWq0FmWhPd4nFBdtjYnGwJTT33qUwdySdhu1sNcBFkiJ2u6GsbdE41SsRaSQt9LSBizsTBbADnhWuZ8VaJlrlhuB4JjjVzfT4WT0kYXPsaI5bICkkYOQFhpY3vezDMXXloYss4GQUzimPPGmrics6JLSVbtL/t4am6bB5sb+9SrqnBZei5VsbZ+qwtjeugVDIPsch6tJ9YFAMvYZGi0tXGZ62yck8JMGZbcU/luwXEk78wtFnJ6iyeFwqZQxPUQYZtEQAqbQdUkLewXrIWIIZ5eKAxpjEKMUQwsDXS9RK0XbBNltVqjvCW2+ZoeHkmfXguVcy0NYiikXgsIgSImq4SyZs3FdcE8RUga0TZp2Es49YJKevg+JIANY9Vw0vSA6XWC3B5//PEDyaMfFOVJA9f3hh3yPcZZD9CyxHMVsB8I01VXXTWcVxrTGVrJObKoaz5lzg/6gt8CSSoEAiIquc3cSr3VhsA67xX2WRSSVAWUDFPlGNZQTcEhc4MlN4wRm3mVKTLUA+OPJ5o5k/m49oVh3pbxsdzRPA8/fddGJ0gsmT/L1l+lXXptW3JEOxmjVrE7SzbxO171IOe9x+iD9GCy8TnnnaSU92OhwOaFtyRVr6Vhv7Qp81MVTJKoKtJl/VvaSrsNw+3BEH0XoxhvBb6sCwuhZ7PWLm1in70w5BaGgUtS2Qzzz74pFPYSNeMOEXhgi/K2HixUTdLCthNWvDLpIbAEBoYMRvMy+8vwR9/rhVVIJj1USTDzfeY2tuQwv8Or+wQK0EBCzXODNGCEabQqzoNhzOs2LQzSR4Y7phhPQuEYPsf7qBdZ7x2QrCq2wjlj5CJIhPAQhIPvQgCuvvrqnfzJJJx6MTG6Mc6XIWy7geOKMQ4Jw2OMNwpkuQ88QhBv0ml4Luo9y/GkPyFxEADOGfB/vFP8vh17jkOfmwM6hdbL6b3esiUSMsOLmWuSFo6jYi3z0JBOvse58Nminn/aiRYG3uGeN9S6ppL6VMkdA+Ov6FfeG6aI5SKA9LFPhbQS9AFzlLZ67fN9PaqSZ85XT3urZm1EAb/nO5YESliD1r5wDug5lQQaUm0esNeZCxHmxNKXLn54j0oyqLgV99qxhRxLTqmMbJ+b26pXmP5mnrNf9sm4T4W2C0vgmA7AVqXgCtuGIq6HBJ/5zGeGMjiAxPhlDMnC5lA1SQsHee5iCGKgp1GqSIdCHEIl0VW8kL7OW9Qxr2vsdVHPHe3HwLUESs9gxTBWXZc+aPNw21cN0k0B4xiiam4eRjGkQXJj2RnGylDF9OQZGqniaHoKIesQVUgaf6f3spfjpqiL4aSroA0DHwtnbT/jd5w/BAyy+rnPfW7Ha6zyPgb3ySefPDvjjDMG8jklmMMcQFU/DXvmMmS3JTP0PXOhDVfV+2nYNMe85z3vOYyLBEey43FShRlY65VjSKQUslLJlb+tF7sIGDv6h43Fhxb2GedqCO8iHjRzupl/rddOLx8LAMuSHhYC2K9q1AnapjK1AlIQRMOSLVHTC5+29JL1gSWa5oi25Y0MBXb8WLRz/Kx/q3ectjrGesrN+bXEk0TV0GP2zTElwdxne3DxLJWRs14uc8f7MX0ngQWGR4/BerOSVEPKdwOjBAqFTaKI6wHAW9/61qHczdgDBQPsMY95zM5N++lPf/oet7Cg2ihjkLmli6xyLgLDFjWce+8rZKewDqjCioHeGoJ6Q7PcC/PP8g+bgMRlEc+S+d1jxFZhFwzFlrBKDNJ4z4WnRTBPfCpf06hPL3SG02Kkmg9n2RnIKOPDOWDAqvLJ5j1Bj56GtCQJA9hwXsgVxnCWpEmV1V4OpaIuGrk9grkoGV3GwLXUCwu0kDBzUJNAWvrkHve4x0BY55Ukon8gv+khZh/MZfaTx6b/uR5aEg9RoD9c2GH8rH8L6Z+X+2cuK5u1bzl+3stVrOU4ixBB5gxtxQvdU9wFzAHIKp51PY+7FUZiPwojLQOuWcaSMW3710UV5inguITD813rwbYwn5ON9hjmTB9zzfTInASRa4Tzog85T8emzTPOvyVr5qi6eCZpVsDKkjTsm+s3F9k4vqSTecs561U24oXfZCi5x3fxQS9sD+atJ0ld1gs+BVXJFZEqFDaJIq4HANRp5aEGOb3//e8/5Ntwg+VGdtFFF81e9rKXDe/B933f982e8Yxn7HeTjxwIM1sld48H8zxCWrXRCvtNWDGsMMrToGbuYlzppdsGGJKXIY7m32Hscl4akpJFPVsYdHp3Jbq+l7CPwX1hmBpK24bUtp9nm1XlVIRFo1SPKJ+b78Z5YLhq+HJsyTDHl3TyGwgPRj/hmnpIMXAx6vUSsx/zVjm2v/O49AvjjDFtLt66BbGmiBL3VsiqtUQhL4YEW5oFbzEeTsiYuab2dU9RGlKCp85xZaNfOEeOoQcWomMYbAqJWdqHfqDffP4Kw0fHCAR9JwHRo5rgb71+8zzaeh9pq/3U85JzXPrnxBNPXGqRSWEk+qGXv+ocW7QMjLCUD1u7wMs5M2eZbxz3kksuGc4vS9RkGyzH41znPfNWbyYe0ySK1t1VpItxYQzNT85Nj6YeV5W2Jaw+wxVUom8VdJIE03/sQ4LKdcgY+zvFsNjMA2ZeEVFA29vcZ47Jd4msa+eO4klJUueFfK8KxsbFJNrG+ZxyyikbOVahIIq4HhDwkH3JS14ybGOA2L7iFa/Y2E2qMA7FFIThR/MI6UGqbVk4nDBPDcLaehY1vlpDGOMMz9CqYaJ7gSQeLYnAuNPgtgTEPAEh8xHpC9/7ao3PRUhuC/uXTcOYMdFYxoBVgVQj2/Za+5L/MRYYzKSKMDYYtZaoUVjGew7nb0kViG5LnqxNy29260FpVaPnlSjinHne4Q213AvnivHP/6xH6fjhNcTjRD9ddtllOwSzB/q0LXFDn7D4Qj8a+qqgTkuoOK5eajAlLNUSCMZCIuX11Irc2OfzRIwyx9kyP61gFmA/zAXye9OLvAg4N/NXFxVGWgSQ+p5qM/B+Qj+Rlwnp642lYbicE2NnmRjzPi2DZLtzMYj96Rnku+Z9MydcqOLaMCyY7zBO7Jtz9VoxjxoCqTeTdumRpQ1GiiiO5PPefGYXktgvx6Itn/zkJ4f5PzaeqjqbXqFytHOtFU9aJ+gb2sViEtca1yi57+Yic47rEForFKZQxPUA4Fd/9Vdn73vf+4ZVR27mPEy4eXCjZqX5AQ94wOxJT3rS4I0t7A8wDkDmwFWuR+GgElbDzjCO0xDBSOKes2iO3V4hiaehkoYDp8fTsDrabz7hKqq2XudjpK4lvvmqNzdrSPI/wxBVJZUA0zYFeyTKGdqo0Iy5jxjUem8gQhrMHC8Jj95c+4+/VSC2XAltMYd21bq4i5B4zom5aFkW56PeYNqhsrN1My23wznMS8mwpij7TmSJG/ZhWHY7HwzfhBy0OdoZ+m1INETFHFf6mrnYE62yzu0itUAZe3Occ8tr13BuyDWRWZzbsikkU/mrEvdl81cz6kFveX5uqPSU0q2LFYa4M9c9NxcbDAVuQ2pd7Mj8T6IXXHQyH9z8cKMRvMatpcrvsxQM1wn9kClC5tO24DeSVfbltQ7B9n7VqxdNOwzv5/dJUq2jvCm4kGR/4V01VNtFAcPkFQ5bZtGuUFgFRVwPAM4+++xhK2wvlq1LVyjsFzTiCZdsCav5YIZlCgxyVUw3sSCTYbXL1O/MTbGWnsorRh7Gtp6yXm7cslg2t9OwQdVPJVEYfhiHGaarAIzGrUSTscHDxCv7VQVUlWTDFvktXhFCXu0biNNYTiDjbh6eQlS98kLrNJIliniX6I8UAONc7RPaBgkzvFmvpOHK84S/FNeh//mtuYcuwHAM63tKCPwt32fe+1nv/CGprVgT7Sd8skeCAefCvtmmom4cezYImGGnSXAso8IziHNapeyMx+KeQJtbrJq/ytzLcOtUDHaBwqiBFi4yWXuU+dlGeDCnmePWd6WPuHY4Lq9eg8w1zit1KHJBy0UH+tEyMpZK8vpw0YS+ZR/mdSrwpOhZtl+iqUeV6xny5+8d2x5Z53yJmqDfmS9ZS3aToF30K88I2krf8p4xy3nudcSCjqHRkNeKIitsGkVcC4VC4QgAAw3jA0Ok9VBhmGFEY2RCJBKQVYz3eZ6bLG+zDOlcNrS2PWbP8wTMA8MA7KVPtAQzSY9iK4YI5t9+Lz2M+V5hJD7DSMdghjjRr+ZnZq6eaqOG+EniJDwYg5BVvTuMg6UuNBYVlck+Vn0UY7MlT5kXyKt1bOeJUPG9tj6u7zMVQjG5llBaczZzda01q/eatrMfPXsScv6GwNBXi9TEpR/MVWUOOyfYB2SAPoakG7Lq8c3b5DuLlpqx3ZyPYdutUqx5sWxj6TzmqzJP6Cfnkn9LcNiXNT/N61xUvCmhR1jil2Bf9P+y/QBoM2QHr62hu7xngxiZZ932A2PA8SSr7XHZF+PFogzXlOq6hvDzt/VM6SPvc967XCAzL9x8eL2plpGxZrO54RzX2rC9UkLC/RhxZR3X3vjmApshxfQL0VtseyVylHm4EFX6VrXyDJsGLpYx10499dTZ6aefPnvDG94w3Nu2ReegcPhRxLVQKBQOMTDU9LC2hBVSh+GLQYbRkgaZqQg9743lVnJbl4I2kAwmIfRzNuslYlRJXiRJGI4Y3BhX6SVsyWcSvXXmZdEmDDkMawxAPYe9/EcFXTwnBWOs94mRqBdIpVSVj/VAJgwFZmO/htfaj3xf0kAfpGCUoi+L1MQd+yzHD2NfUkufQFSZh5JVhYr4jmGGGu+ZNwmBgMQsk08NUdLbLOhHxInoI1JuMNTbMVHNdepYmZNsSaJevVHAOZpjrLe/RY6ZoflZGsd8WPrIklNs80jwqvmr9L35q8uGGUOAmPv0vUTVaAHar2euzZVlfPEuZri0/WK4OtcT/azH2c/pH/O9LX2joKGicv4/lXu9PgxBNvTcEjPsm+Nb37eFiuMZjWBObAtFxRROoy0ey/Brjs+47kWKkSJuLCBxLXBdZk63EQ+Qa/rS/mGcIKwIMClmZ14xv6Xtyy5yFArLoojrCLj5vvGNb5xdfPHFw02Yi5qLlELuCS5schQANyJWxguFQmG/wf0Kw5StJZXeq7h/YbikYYahwoo/3wGSqiSprXGmxyM9kJnj2BPoaT2bWctVASG9oRIpy7UomJJGkqSuJQibFAvRq4rnDiOQV3NJW+jNSdLBOZnfRjsNOcSY1QsOScXjzbmpMtsSS8vm4BUylLb1nGF4TnlxOP68OrmpsjyvXxgnyIYhhq2XyrBfyIPhnfQl52LINGSGNltzs1dKKMG8IEQ38yj5vkJi7f8Ax4I4sLVEzXmdpVD0potUeBbMS9R7x7ygEgdJmPtj/3xmPiznDlmQjFnTc1WCw3HNX23bzJyz/uoy+2Y/2EiICkHyMs3AnFsIKf1vTi/3HsaWPtcTr2iT9xj+NgKERTdLP+W9in1DfC3p44IJ31G9V890elcVReJ/qjwzvoYe90ShDN93AcgSUy4Atf0p+bUv9FRyfO9djCXzfNOl7PT00r/c77lXqdLcI+OcK2097bTTdiIf9D7zf8Wj2M/ll18+XFf8zTnTp6UsXNgkirg24EJ+znOeM6jz5g1yrLAyn1OChocQteNQWisUCoX9JqwYe23uFAYIhjCfY2y0OUsYlBgsGHEoRpo31hpxGpoYeGzsDyMuRWoUrkkSmq+LGseGA6dHIL2s5mcu6pGbyokcy5P0vedtuCIGXIoJ6Z2wjXpWVPlVVAbj+CMf+cjwe4xEDXyMWksMmd/G+fWUW7Oeq8dPkqTqKn2zSBif3upF+lExrCS0bPQF58bcMtQ1BZoybxESj7HrIoih4xyfdtN37K8VVLKtbV1cxXmytBD9zfHwKLWhsPzOMj+gLYNiKZRF4DEtb6L3LiEpTS8qSMEsjse4Sdiz/i77W5XgWJe09TIDyAj9sKjgGmPJuTD3IKuUbJG0tPmdkkb2zzkZ6q1iNnPFEFw+4z3j7WJOEivH3HJW7D8XUegniapCTPaX3l691V7LElWOn55n9qmwE/PTcWBMpq4Pw/0VV1NUKc+BtjOeYx74dYG2WyIJ54oCYe293DBlIyAcM/qOPmG8IL3WBTbn1RB7VIVdaLGawqJ1rwuFVVDENcDFd84558w+/vGPL5xzxYX+1Kc+dfaCF7xgdsUVVwyrT3e/+91XGoxCoVBYFRhKeljb0kx6WDFOXG33Nxg4GBsYWfwWL1kPGHAYwCp/YuxgzC1Sa3IMUwSSdkFGDAfWy5TGPJtkeR7pXIYsC41pDTb7LvNG9ZJ6PhiqhFhTggRjnXbT7/TtVVddNbvyyitvJICDcUgY68knnzyQXIzbHlnlmBK01nOYxJltkyF7We7LUHQMWyOTVF5NEiMRx6iFLNB+CQbzkD5QIGoe9KyxMU+YsxkFYB6wYZ4pmsV7jsN7/o8HSi/avPq0LkbQbvOLIWO9mq3YEIb7tjnYqrXyOe2GKLAfPXjrKEfEMRgP5m0rWNaWg5oH80chq4wzi1q98GjrrzL/Df+lnzg+1xEkx/IzfsYrf1vuyIUcFX2z1iltVeyI/Vr3tCX0lobiN7z6f65n5irHVS1bT38qEQND842MaGHIsW00n91FiQzhVsRonhjXbsB5KHbGnIb8u3iUyJx66+86f7m/6zW3PyxJ1QOfe+0Ac/97CtqFwrpQxDXwxCc+cXbppZcO73nAPutZz5r9zb/5N4faqa997WtHO/Hxj3/8QFzBO9/5ziKuhUJhz4DR7yp4j7CaH4hxTx4rxokGGt9RfKUN/2VfhuZZIkJ13jTuMxxQIZ15BHKMRGpsG96sh0RACvVarht6UzGgDae0nueY51mCRCgv9VMJD1VECWA4fuITnxhKSEDWWq8f/YbACYudGMhjCwDW/8SIbL2A9CPH5Pe87kWOHH1heYz0OGebrPULIWdu0Lf8BsKQdWOZU/SfirUKXM0LWzZEuxW/YQ46jwwb1fCWUDMuY5Dc0j7JixvzLkueGUEgOC7Hok+IvmrHyhBhvsP+IXlJcAwjX9RL3oMLCczhdlwUvXLBZwy00xxP+thrImvQtnmqLLow/7NeLVEF3m/0Xro5LhkGrteUPjEfWw+riwW9+c13JanmhGeILOcBmbINetRpl0TZ/Fj6p70OvfepOm1utmSeed3zZBqiv4rK8yLgnLivG+WgNz/b4nv6l/4xtJq2S3AtA8VYWavWed0TZPPZoKCVCs4utk1dX4XCblHE9Rje+973zt72trcNFymGxHve857BoFuk1Mk97nGP4WbADeyDH/zgrgelUCgUFiWsGJTp+ZCwct/iO5/+9KcHgpGr4BjF3LMwCNMQVOFXwZ6xEgzWCtVQ3K0XAcNVFdLW2MZQUuFzVc/u2DE1sC3PYW6drxmqqKcCoxVyASFj4zmR54/hiEGIIck5qSSc4bL85t73vvfsLne5y6i4juVi6JOWLACMS72rPe/suoHBjzfHkMHWC6NXHG8b/WJ+p/3RhqlCRCCsGUoJ+I25iGPAMMbrZ06mpZAYU0mJysxGE7C/XiSVXlS9UB47x5S5YA5mgu9I7PL6oR8krZIn/ieZSdKY4jerCC0Jzpf7Qc8TynVMX7XXu6DfaCMbv7emqMrU3DsyHF1STxSHofGMCfaP4bu0R5Vl5kr2veVqJNLsT8+qtYTZ/5g3mDa4WEZfJzE0j5cx8dqRpKZaN8c2R5bfpzBZ1mrlNe87tFvhtfa8gPeHXHzo5ZKu8jft59jMOea/5+fYZK1o5hr9Sfs5V1W2WUyAaLcLlap7O/ezHFa2I8mx3mqfF0bilMe1sEkUcT0GParc1F/3utftkNZFAXmF7JLzUSgUCpsCRooeVo0whUPMw7IEC99ri9pjFOrpwSDTADGkErRESFKCoQgJWFcYKm3TyGyNNdU2MfTXUWrBcEfIoPl+KpLqhTFUMQ1Ya27SZ4a7tuI49B2GJKQOo9K8RXPKXEyA1PGs4LV3ToaXqsba9sle5sh5XpwP50WftQY458V8o18gq9ZXTaLb5qgy7xSbWtY7zHzBe21bXHhg3qqUbJ6uYZ6tim16TPWa9ry6i4h6SRScR4J2QQ7cD9cLx9FT7PVEH0hyOadVSI1ks0cW2LclhcwX9npXBElhL8m5569yr9EW5h8bHs73nKOSU72oknbHQ0EiwWecO/vNGs6GmnL/ynnj4oLXI/cGiXXmnRtCb53UdkFPImdItkJv/N4QcL5jX3AdtqHdPeEm5rz5rBLbsZSLZUD7OS896KpyO9+SqNrnRrPwGW32mnWxwHlqtIAh2Y6RUQMKTrnxWSuyxvg5n8zx5t7G9V0obApFXI/h/e9//3DR3uc+91kp1JdwPODDp1AoFDZBWDGIzAsz5NcQQ4wQRTk0UjN0k3BWyz3wuzb3LdGqb66rTp95mhhi7fFVHYWw7oaYWc7B/FTrEqp83ObsYswZIsex6SvaIcnntc01dDzwJjImChEpNsN7zgEjjpBZwihb76yw1iVbL5+MYyu0tKkcOUFf0Gd4jCFfPW8vc0iy2pZN0XDnXNLIpX95TnIe8wgr87MVSrLEkOrHihlJzARzVU9s5qJKHheFpGAsXJn5ZTi5i0Ma/vyPOeB5Sh4w7JlLXFf0mWGzy0LVZo7dW0xQkZrjcR58TzLGpkKvfavatyVmVM/lc8XU9Dzytwq8lkFp8z6Z97xmqRTTCICLRY5XejzdnyRToprz3r43xLWn7AwstZSbBFWSOjUXJedsPSVtvcPrKmPjwpX3LBaN+NtwaxcM9GZnOSva13pIhQso1q4Vjqd1n1NILdtkaDdgnHgmcF/jOiO9jt+al3zCCScM99BCYVMo4noM3CDAXe9615U60lXdKUOwUCgUlgGGhDVWIRFZDkIDFTIgceC7EEI9OhrulvrA2Gw9sAKDhN9IVncTttgDhEaDrDUCzZOD1KwSDqw3AANTxUu9DRpiWX+TfsRgo2/wEOj5slampJW/E7QbQoYH0vHIcFCOT/shdIbB0veEVLY5hfzGcMae0BLfN4R007URMVxVIOW8euVraAPnwbnx2nrl6Rueo8y/1ivD9xnfljhaTqglqUneDY/0c+Y47yFm5jNm28ZUmJeF4ZJ5HVj/VNJov7Clwm3WtTUHuTeflkVPYVtYLscQVcllhr2rBG54aUYbuICjJ1pS43vDRI0g4Nqx/JR5n+YXsx+9duzDiBAJrErDOU56/vif4a0cx3xKFbRTbdg+9tpK8ay8ht16ufU9wkm/uSDRlt1S2ThL28zb39R3GB/uWeaqcu/Sm5xjw6bHVIE6vdnqBjhnXUAxPNrzlugabZPq7L02c4ws42Uuvc8TjqU3WFGxvcixLxxtFHE9BsMsVl3NNkxHgYlCoVBYBhoahvBhJKLw2IaMSlgVWDHcEUOL+xcr3hilFo/HQBnLOcIgk6hiMK7Lq5rQg9ALfZVULyNGIwHFsOOc2TdEwhqbCWvQ6p1QBVYPqoYnRpmGbkucJQsQOsZDb6ptMaQSIoWSsAQNA09hrIRGeE9oCTAejO2mhZYkzpBVVX7b8aHtjI9EvLeYYZgrW3q9zOXl97xnTkqaNMZzYaEFn0NSzOOjjxkL+vVud7vbMHf0kLckaJk+yNq0vY3/c/0Yvt169qzbS19JcJhHaGW0uY7Lkhr/pp/Mw+ZaTTvD/FWOrXfOsaTfmK+Wm4H4SGQcE86H+a8nXO+c9YQlgh6Xeak4EZAU8jvFzYxk8HqUvKsC7PxI5V/mlmG/bEZlSOQkzJYvErTDyAj6gX31lIbngf6RHBvab0kj28+x2f9urkvOjeuN1AI2c6Q5X8aprZftPVzyaLh21sCWqBpy7T1PSFzN4W5hCSf60PQM723AkGLzpBM8N1KMadGKHIXCqijiegxcsNxMMExWAWVwAKu+hUKhsKiXMAWBNKQxnnqEFUOYsNMkXhA3jB+JAfvhfz11TAyQ9KquU+yol5uF4dmGmhq2TPsWKfVhPh7nhmHJll6j3vfN+dKTq8GcZWs4/wzbbPdB/1sCB6OyDeHFqORczHt1H5wbJC+9NHo02XpRORqOmxZaslSFZLW3mMDxMVwJbebcxryEjDHjy9xrCbhkhPG59tprb5QDOgXmqOHk5oPSJp6tLARImpg/Gaas4Z6Ecx4hnTKy+b/1VXvzTA8nY5Z50Yw71+i97nWv2W4BAWUOSgxybiRhJCLD8GQJkGWr9Hymuref67kzdcC8cgmKYboeV6+oG/2HzUQtV0OMs08tWWNJGpWZ+Zt+0gvMHDLXNr2NPdBm5qft3I1om/PMe8q6r0vOgfnD+XG9cS9hY0zNOfYZwBg4110EsT619bDFWH1hPay9aAmVmjkXF5Qkq4Y6szEehOUz5yW5CqllPxvpYN1Xy+KUx7WwaRRxPQbyWln9uuSSS4aLf5nQLASZqM/HBXu/+91vU2NVKBQOKFIMRZLaGsP8bRiihod5Xne84x0HT6oCNBgJGKuQAgVGAIYFZCPzQy0xoVd1k4YFxrClZFrjCuNLQ2nKCORczLXT46KHrpfHZrkGYGinYb9JSFNAJUvWtGTVWoiWwWnzNM0T07Mj2CfGXX4GSYSssq8xoSUMyU2U90nQl1kyox0b1W7xrBI6PbWgwHm4WKJXyE3PnAq1U1AsJ/NQmb/sm7xhBYMYc711tFtPHf9j/icZ3S2yfEqWLkohG8bLxRDmF0q6tMXvSD5WBf2rgFgu+tC/zCO9a4oK6d10LBRHShKkuJJeV2C0hjVGITMqG0tws/yL9UpVdP7Yxz7WndcSekvZSFTpGyNK+L2h3xLVrI0s9BJapkbCtaw3tcVU1IMRLRK6RaBAl+HZ7NsawbwSBsyxXFCgz+w3+tlSQC6uuSWmFlkMxeY7hg27gIKuAQs+ztmxyBb6nmvPGt+AMeN+wDPFkHgVoD3XFG1qc2gLhU2giOsx/OAP/uBQDocL8Zd+6Zdmz3nOcxbuxH/6T//pThjL3/k7f2cjA1UoFA4GuBdkSZVUduyBBz/GAt+ztqNGDF4mvXl8z5qBKKu2oWAWuLf+oWR1L0qlKILUljwBen97KrL2FYYr+4Co8joVRqrgCq96Ecy5a40yjegxARWMVoxJvcO0n7/TmGUfhhJLTvI4GNW5WOB4Wi6j1x+QH8Zqk0JL9CFGM2SV9rTEjnPgnFgUYZsSmDEMFELP/hSLcXyYa1OeLwl/birKsm/2RVtZAGYc3DfjS1/xHUO6GZtWqXgZZF1KN8ZJsm1kQ+bxcR2N1Vdty6XsVhRL76Nht5JojsH5mwbA53zPvEfaac5jvrd/DXf1c8OsJauWojFnVeVda89eeeWVO6HyvT6lj7hXQZJsgx5Va0wbvmwERXtfdCHDUk/sz9Dk3cJ5w3XZi3rgmHpXx4hx5sm7MWdU3oaoco1Y89axSdEjF0Akgc4fw3+nYB6p5FTCrOffhQKF0xadly6aAuYE48C+TjnllB0njueqcnOK3HluloMqFDaJIq7HcN55582e//znD6ucz3ve84YL9uEPf/hk53FTevrTnz575zvfOdxQKMD9yEc+cqMDVigUtgt6EZKsznt4a7xoeGL0q0zO/zQo2TdGkaVVMIhaTxZGC95Ya7diCO1FuJYhzRg8bVifOWKcVxqdqrGan8pv7bOx0EBz7DDI2JdlRXpCK35fstozeM3ttOSGOYDp3ZKsWidVFc8E/YyHlT63hAfn08snxhCmPxjT3Qr0TIE2Si6ZK61XX4IBUVWUKvuwJ5bE2DDOWbvVsFwFepiz5iE6tyWn/G1obg/sk1rDtDvFjZw/GcrYgwJCY1uWvknVVeevYj/Mp6zZLmlm20RIvbmIzEW84VznzCFDbukX2gCRpN38j3FV4dUcVOa5ee6K7hiGqxdcISH7g3OC3EgKM2eVMXAhijYZBdKLdmAucd9S2Zl2WU9XZGkdlWsB3zdkOEXRMrR4HTDFgHa152DUQ3ufAvR/Ki9LuLERjV5gY94a2myKAsfRa818k4y7YOD10S5c5W96YkvmInPd8bcaBe6H/1vqrIfMW7Y93rd8/nAsy1VxXniLmZPt9euiE58bCbEXi6SFQhHXY+BG8Iu/+Iuzxz72scMN61GPetSwPe5xj9tZiTKXlQv5Ax/4wOxXfuVXdmp1cdG+7GUvq/j+QuEQg4d0klRzk6agN1ADUSElSJN5XxnKikHBfvFwWEPPsLZctcdAOe2007qKtZtECtX0wgQlG7QJ4xligAFkyCznNpafas6duXEYaYrIsC/FZFqDj++rqNpL81Cd2fw/S9akIBHtNf8Xw433/F/1WMH+New4D5VAe6GqGOCcA23b1GICz6ustdpbRGCOETYIYYW0SP7pB4WuJBdZF5I+gsDwHYVf6EsMXj0z5hIbStrzqvfA7wh3x0uVfUdbWYihrdb6HCOkrfd70dzrsbqnm6iTm2I5+WpIOm0xbNYFAaHSM/AeYt6jeav2vWGgkl5JuCHZhoIzd3PxxPBoNvrEUOlMQWhDdxUustxNRlq4+OF84tyMkmDuSZoMU07RpnVdI6p/c5/qRbsYHq34Em10nudiDfadomyMleHbeY3oTZV06j3Vs234bM5ZtySnzmPDvPX+mk7A9WaYfqsbYFQL/eoY9ba8VtgH9wy9z3rE6RPnHfeI3CSq1ib2eWbkDP/LxZ9CYRMo4hr44R/+4eEG9c/+2T8bLsw3v/nNwwa8oZ555pk36EBXmP/Df/gPs7PPPnsjg1QoFPYe1jVMktoL/WzhA50NA0mDDAPKXKc8hjn1GDZtCKTlbTAY0itx5zvfeTBm9gpT3lUJmnUj6ScMIr2PGoI9gp+5XXq36Ddzgtuw3ZaMjSkBA2uq6lWlnzXIJc2SVQmm+ab0OYQ0SRfHUJEYMnv11VePCi1t0lMHmA+0kX62VIyQ/EguaTPzi7ZCEll81dMvGW3JJX1Fv6lAq/EtqacPFglzlljlxrEgAHhZOY4qzOyfhZhTTz11baRRMJesbdybT3rXl1G3bmEZGHOlESzKBRrDTBkvFhqYm4pJSWb5Tuae0t+MoQsNeloNXTaXW08nY6x3P9MNFLWyHYbmQ1LNLc3cXnMwjWzI9APHJvOKM5KC89DrK1HVE2fY9abSGKYW1TgP78ncP5gLXD+KJ1nKiblp/nZ6FN3sQ/NJJaOmLnhPy3zQHjl1y9QBVX3beSixbvOuDfXnd3m8qQUA2g0J59xdwOPVUHE+b0N+2Z99Z8ky1asV1GIOLfJ8LBR2iyKuDZ797GcPQk1Pe9rThjwy4Y2gvRliQL70pS+dnXvuubsejEKhsD/QqEyS2q5q95Aqm3pEWoNeY1XPHWTA/C7DWs1XEnoq+Zw8L0P5eI8husncyEVL2WgI0hb664orrtjpQ43wRNZY5HcYQCqXYjRZBxXDs+elm6cEnGSVvmZfhj0qigJob4rGJMnEYEVsL0MKrUNK2zHSILS9kENLFK1baMmQPOYNRjXkEy+QeWZ6fTQ26U8XEehLo4LmwXBEy7u4IMD5m3ttWOqiYblpfFuPFcJKuxgHyRQe1nve855rJaxtKHALzk2v224EZfRc54KOxFChMd4zt7iWDCnld3pZ7d+MFpAEs2WOraVecq47p1lUkEhxbiqLcz0yd/SsOn/pF64TF5hUyjYMn/G2Xm57zzFFwvnHdW2+bEJxOMOS1x15YH4m4+wY8JmRBDoXDOenHxSQMwLDfk6PInBRhy3Dfw31NdxW0ud7vuO1ySb5db4pNDWvRrPebF7NceaVvrRmcQuFu5hbbs415h/3NwXv+K7XgTnJWcPVZxvvOR/Drtl/knEjg+iTeRFIhcJuUcS1A0jopz71qdlb3/rW2Tve8Y5BaZgVKm5wXMTccO573/vOHvawh80e85jHbKT2YaFQ2BxU5Eyl314OV4+oJUmd8qhJWBUDSeVMjJeWgErsXFUnB01gqJCTuKqBreGlkTn1qoGjwa9R4pY5V2N5qfaXarF6NFU25nOMKYwy+qhXiiLDpzHK+W3vXmuJF8lq5g7yuW1W6dSwYogAr5Z1waBNo0sywKuEYyrkcNHFhLHSLL3PGQv7yDBFx1IPnO3w/PRiTS28SEZTLRZCwzyFQGmU8j9CjK3FugrpoB2QNtVV9cqwL/ZLFFNbm3NVGBI+lmu8TiVnxofzYe44N1xA4Nh45F00YX4nObIUDWPG9aHxbwkSCWMbsqz30gUiVbIFv8U+4dw4JgsctCEXxXhP/5gvb8ixCubmTSrklH2bZFrPbjsnsuQW2ybyHrkGrK3M5r3Ve7mh14yL94bMvU2Pp6G+SVB9rxiSCzKMlWG/klavC/dHnypWpgoy21RdZsO5M6SX9rI/9pHjaxkxzoUxTIIqSW1TW9iYq9zHclHQeyvHZ6zZr2rQtsPwafbN/OD/1gemb114cZGr7OHCplHEdQRcyIgzzRNoKhQK2w3D2JKoziud0a44a9AtYrgbkolBpefWVf82HNHVcww9SCLkxDwp2sgrXhTaINlelIDm6zxSDmgrxpJeCmHIoEbJWN9h3BkazTlJDjC8U5kSg5NyGL0w20WUgMfIKu2y7qbEACNLUadUDeUYWYc0z0kjjvNNfQPhOBoGqTd0ql7oMiVb9HrSLoxNzydzzFTYNayQ9povpwCRBjf9nxu/o93mJ3IMFinoKzbgvOsRk0WhsZyKzfYv+z399NOHxZh1GLqLhgIvGuI8b3w4H3IAvafopfb/jAHXvzmtqSzu9WF9VAWY6BND5TN3NWummicOklR6rwLcQ7i+hMqz/FayKglTBMn5lF5RSZmLWV4XPbgvQ4nX5VXVU0jfWVqKc2NeWYqFMXCBwJDrdpEpyahEPZV5vUda0sXrKMsJZRSBCw18n+vPerJ6UcfIumVqMpRYAqyCs+eXuaUcxwUKIj7GwFi1qS383oU3FbU5Ph5bhbXYGDfO1VB3vdHA33l/VSiKxVXOVw/sMmUkC4VVUcT1GCwWzgV90UUXlTpaoXAAgTHBgzsf3lNeQWGoV+alLmNQZxikXqU0kiRhGhbmq2IMYExeeumlg9FlaJriHBgUeKo2BcleqwRqzUeLyusV0rvgK/0lyeR8PK80cDHqOQdD3nqYpwQM6BfFkvRGSPLYN2OtAW54tfVJIQR6rviNIbSZk5VtY4z0LvmqcW4tS/axyILAolBdFsIjAWvDEzGOIZScH+eTRFWDWC+33qEeGGuO04ZlcwyMWebequTDsFjFfiBSlmthLDB2qS25W3XlRUKBXWDYbSiwHk5IBbVjmX+SAheoOJ7f5X/kuEqi9U7SltaraSim5NNyNLTZ8FYivjK/kXlhLinf0ytmzrx/m9PtIpjq3ELFYdqmwq9zXqVckfPBRSHJ6qq53BzLGsB6SA2tZv5I/LkeIF+WyzIfV3E1Q3clla3nL8NZDd31unZRUaJu+Kt1cN1fek/dxkh6lrtpyWl6R83JNTqn9YhybPNfx6JN8nnHeekdpm0u2LpYx3hBWKmakfdZ2uIiYEa/GI6uLgD7VNzL54DCYKZu7IWifeFoo4jrMVx22WU79VxL0rtQ2H6oXtnmpS5SikYj37qBPGw1asyNmufJVDzIshGtB9EwV8lYS4gVXmrL2yjIshulYA24VK7MVz2f1q2EqKT6qcquhovZZomheaY9gzW9oSmE1MJSKuxrbKVeYorhas4qSKEl8zoJadVbxN96fA1xtOwDJFpian6ihn3b53p/LfcBFsl97o1Hemz0vtL/tIdNI9ywZn9nfUzJqgsJ7bbIQgvHNNcySTfHJHRdIaBVQze9DuhX65Fq9DMeeFgh37sNBYas9uqJ7iYUOK99PUuWSZKMtwTZaAKuY5WlNei93iXPvJeUGvqei2XZ746TJY2817kQZzix6rlet/wvc57NU00yocgYCwgSIkkuiwxj90/JtlEMixAU2pGkNF9dDLDUVBJY743WRO0teikWZs4v7fE+3hLUjIhQtTfvh/5tSSTIGf3DK/N1rLZrhvcmcfbYEkKJ6pTKdV6PRiVwXCMErM3b9qltzsUmrz/+h3iTC4yQVvrLkmAcW3El5xmvLgYyPnl+3DeYI0YJOPc5lm3MFJdCYRMo4noM3CC4eXCjKhQK2wONEIwbjHvVDF1hbnMwc+NBbG1DX4FEdxmkcqa/5+HeEhm9VmyKabTno6dII9H8We4/etKmiOe8155R2ZaIMKdJQ12jH8Mjf58EHKO1F2opodDYX1UJOMmqnlXJqkag6ql6F/VMuQBAnzMmlhEB7A+jS+LhXKLdtIX99No5Jha0aL1QDVgMTL1gtJ+2YJQnGU+PBePC/GHxwJw2CeoqC6u0o5fHq/gX2yohtPQ7hq+kTg8hx/I6MI8O0rqqZ25eKDDjZNmheeehEBtk1PlqHipzrM0H5Zitt5MxYlxJCWAcGV+9bPQpbbnrXe862BUuPPCZRHVsDOlD+o5zbSNHTF+w/nN6y/UoK0JkmLh588xv2sAYQIj0huPhH1OC5TwUMGMMe15rjtUjpZJQBcPyM4mqYb6WBuPV+5MRK97LVDWWMHm96vXWc5rh9G2orcTWc1OUSJJK37C1ER9+t/XGskmKU/BqmYUeztUFBr3GEGXF4FSTViOB69c5mjnHPiP9Pu2xTA3/k7jioPEZ5vVqewwpNy0k51oqsNP/3m/Ni3dRYS/LshWOLmqWHQOr9WOruIVCYf0iQFOvPJw12Ax9WyQ/UA+qhr7hWatAAzcf9MB8K1e7VZLEMDjxxBN3DPQeoeT+gpGvMe/vMZw2Vd4G40IFTUOpXQDgbz0MaZjSfr2qU94Vxgn1dTZz5/RmSywlqhlOpqGUOaAYcpITw6bZUhWYfRuSDBgfPZR6W7MWJr+BCFiHVGPLsFXzli0/onfF8kQ9UtoTKaL9isKo0GqoNTDPzJzP1gvNfpkPeEROPvnkgfCto64lxzcioM3jhRCvWgPY2sIa0oDz5Tj0v3VwmUd4fHrqp/NAH9FXY7U454UC66U0BDIJKtfuVGSGNWy59i1v4rUjaVC5l3NzX3yX8yYU8xGPeMROXeZ548icUbzKUFnvfebBskmg+Yx90wbDeq2va4kc663SRuaSXrS2zFPPi6lXlfuT3kKJfXpGW9IrkUsPKptCbBJUIygst+P9wIVGw/zdJI7OC4W3vH9ke1zMTC+qqsyWh2JOcs/lHJn/Htu2SE69lyhC1Io3SR5b4ar0evt998kcMi/fz4HCR4zxVVddtfPcG4tYAfSJY00f6SUVhgyzH0lywtByyTP7yUgFF1RTp0DS7n3Q+6L9XShsGkVcj4EQ4Y9//OOzD3zgAxvv9EJhW5BhVcu+9j6bF6bbg+q0eqTMEZuHzCPy4d3ztizjqVTy3xXuDI3VOwBUFeaBDuHAEMIwGjNQ+S0GI/vUGOO7mypvk95VFwCSrErSMJRssyTT8LspYNSjvP6Zz3xmx7CyHiXHMc8SY4o+41WPAkaOxNIQRX6TRpXhahIHQ381jDJssSVe9KWkR8NPA5oxY3FBox8jGcNe434ezC3MTTIzNgYqS6fAjaTOxY473elOOyUp1oHM403Dl+PTjxjvq3g/9dxaWzhJLGOfKrjML8jBMuekJ2rZUGCvzSSozKlF60qmqq4ElfcufDCXNOxbksz3DCk35Jf+5bqeAuNCziy5sOYEK0Sk+I0q0eYSqgAtqbEMDX1iGRbbwt+WUBrLLdeL633UHEzrGOv5bOHiYhJUCZCh/S44KfiWRNLzMSLBfmzLDjp3rDmcJFVCrEe1FbuTtJvfbpi+wnfUK80yN3pQJZyep8Rz7DXJWy5u5XuOq/hdOyfNeWZ/zIMpTYZ2vJyLirnZJgXcOL7eV4Wh+CyVvS1hlMJTzB+vs14kSYZXU17H2rGV31rYCxRxPYYf+7Efm73whS8cwn5+5Vd+Zfi7UNgm+LDcDbFslWZXIZq7hflNeqUyZMmHn2FuEjzrpZojhmGimMY8QjoFw1IxsiQ6Qq8eBoeeJI6NQa6xoSrj2AMbA4h7Cl6vBMYVUR7rVmE0JNbcWUO5MndSo3aRfNUE+8ArBGHlnNq8NA1r9s3cGgvHznwzCYO5WxkWaei03ha+R19LuHvhupYoYbzMWeSV84QcqprL33rLxrwEhjImSe15/hIqchoGzN964yXvzKsMA15neF2K+bQGMH3XetYXBYYwBKjNjXVxgX7lXABzGs/xMjVZ6WfI71QosLVpmdOEgVuOg23KK5WQfLI/xZEUToMsEzmA2JLloDg/w1OdJwot4RknHPhVr3rVsIAzD4bTs39E3CCG7aIH+zYknza5QGauttca7aYNeV6Gdqo+7DhJ+LJ8kh5cjmdI8hjSy8r3vO6zRrIE1dB+7+N6FM3/NJTZiJosQ5Nhr0Bvp7mi+X89s3opjbRx4UAvtekFLhiuUq6lJaI9YjoF0wPyekwPpxEn7jNFotiYe84HNvvScHPr87IIytiwP8vveK6Zd0v/SWATfKYQ1DKLWs6jdQrVFQpTKOJ6DBg1L3rRi2Y/8RM/MXvGM54x3AAf+9jHTnZeoTAFH7y7JZjLlDTZa8wTAdLYckVeksr/eRhLHHLjga6wiWRonQRP8Q+N3rF+lajQHkimD3oe1PMIK+doHmMa4vyWUGKMinXBPDwMYYx/jJgkWHpkNHo02PU6zgP7+sQnPjG78sorh+NotALGC88SJMyQScc6BWN4NdzaMEvniJ4mQxvpHxVOza+1lMlUyDLnD4HIvGPOVyOOvu+Flkpw261HoHrgHDhHw5zNEcvapNbXpJ/or1VzPacgYW5zruk3lUCXhR67Vn3YWqQKLwHGRk/jIp4XveKKC+W+nTfeD2gDEVGLElTA/DE/U4KaobuqukIkL7zwwp3SQwog8T2uGxcbmJt3vvOdZ6eeeuqweOI5jp2rnmg91AoNuZDUttWSKtYYlizTN1wj1k5l06smMTQUPfNM3QwhlthxPp57eg4zMkEClJER5sWq6CvxBJmr73WdQkWGEOs51avpPOLvNjzXZ59RCmymCejhMzUhaxIb7bHIHJQAtltGiHiP9HySOKaqd0toOS9zlbn+7FvaxTg7vi2Rdt5a83rsHs21Q0ixInv0l/nUPqscW/uxjSpJ1XVze/Wmp5jVWKkvF2a9P5jfXShsEkVcj4GQnR/4gR+Y/fzP//zsuc997uwJT3jC7Bd/8RcH8nrve997uNEs+uAnbLBwtEC4lw/gXBXeNuxW9GdKBMgQuwxNzbAoDYEWGh0S1XXk9iUM/81af2Pw4W0+ZV7zelgt2D4GzhsSlcY4fYXxAola17npeeJYrdcpBZXSqzpPDTTVSzFIMIwIqWsJA33BfU6vsTUns+aheXHmp2pUqwStt0nxGA00yYPCKda11HBP8HvKk+Aps76g5285IcbLEFY9PZagWDQsPb1ahupxLhISSUDWulRoBbLKeWyqxiHHbsulAIxY+29Z0C94rTGOE5IFw80FfYuXdd45piiNZWxSbI05oRd+0edt1hB1zhtVkKDN5nsbws31Y9+pSK6oFPOG+UMoNxvX7tRCj6GzLti8+tWv3hF0y/uOHkaOA2HgOoLsW0aK89f7y28lDkYAtJ7K3gKLqsbOV2uEGl4sicrFU6CwjyTV0OusUes8aJ8H3lfa/RnSm2Qny9BIVl3wMQUkc3sliVnyybrERr+kN9WFMcNpM6VET60kPol2+3xr3y9y72acXURUH4FzU825Vbu2TE2Gho9BYb+rr776BrnKqvnye9ua6TuOCfMnS3vRB9aOdWwWWSB3cYmNOeICMG0v4lrYNIq4HgPGRd6UuNg//OEPD9syME+icLQwT0RhFRgqu06iuS4kwclSNPNgyG96U9ed3wl4GOtVnVJ8VK0Sg1cvqQTA+8GihBXDklBa82AFxilGxTrKbHEMiCRbr46o3lVW3S01M5W7KZHLBQcMefbfkhbAPs3JxNDKvDuQqrka6vYx/cv+LQciudUA4r4p+bDNbRijSsjMGTxlGG953THHFWHRa2utzUVKJeVx2pqofIYRipGnp6Ptf86J40PiIPWL5M2uCtrCWLXllOgfhWdW2SeEtc0vpV8ZF4lZEgTOc8xYVQ3ciADr+apEqtdQUaGxKAAXDcxrTsGvKe+1YlmWrdJbyDnSdy6eGJpOvzF2zB9eOa8eGXcus3CBsjBEIlMe+B8h9RLPFMph7tNnWb7J8iWSasNjec17K/vgfJO4ukiaRE8RII/fklz+n/nlRp+0i3oSwF6N0/Q4ZxqL3lXLIkmabEMqHZsmkAJDnoevpockWTXUWyKa9VL9bC8VblXXZrGBOZ7PwlTX9plu+K/3qCkoFMb+ufew/1x08Low/1zFZgWnhPm/XDfeexdZtGMMvUfnvdpzMeXD+VEobBpFXBu0sunb6DUrbB8sfbEOgtnzZu43UuVXojNvZVZFwiSpmwiRTG+KZHVK4EKjQYKEIY33pc3zMhcRQ3PesTE6CWfMPuF8e+UVlgWGA8YKZJJ2tv2umAaeGwzusVIzrrjnOEr6eNV72y5AYFiddNJJs7vd7W47HlbmpiG2elRTeTmhQrBCMq1BaSkTXnMxpM3/U3DoYx/72EBE3afeH7xj9AFjy+eM6zyoytluaYDRFvqe/unlYCoYBNFhvFchjMuAfoF0teSSdkO8VglD55phbln6QjBW1l1t57clbgw91ai1TBQEjOvCXNEeyaetjLuLOub4eX1KThfJwQbmXUpWaQfHdm4avs+8NQTY/GfGj/5jLrZjaN1m9mNZIfbFfCQ83fshm2ScucK1L8Fi81zZz+WXX76jMMvfznWVchVGkpBJEgz7lAC5gKT3slW9dRFP76kesrRtFO5hP60Aj2hrpGYYaaYIWEvW/Uo8M29Xktqqduttt9/4jSJBXN/81rDh/X4+qs7OOLvQl32aUR+Zp+rzIGs5t+G3LvY4ZswF00AE/cX9mP06xi1ccHIOjsH55Px1k9h6nzR0OUkq50d7M4y9UNgkirgeAwbPft8ICwcXiHQcFljaIwnOvCgCPSJtXuomrykelulVHXtgmtfpCneGpGJwtESN8yDEcpESHngXIZVtSPRuy9vQJgx+yWqPiGNEcN9iw7hLspWlfLKsUAv6znBJQ3EVWOL8Iavk9Nkmzlcl3anV+szLNg8tYZikipZtOQ5h7ihElTxb+sP8O408zt36txp6hpqmJybDDNOLOtb/9AmkRA9YgnlN/0DcIDypzrwpcN60qfXoW05p3gLLWNgu5LJdtKFf8NrTV4oImfvG7yCzvDIm9Df9JXFhTkHEeh5uPZsYu5lr7cYYLlPCSs+nRNWQ41TQpk0Y/QqkMQ9Y4OFY9Bvzm3PNGrCqWrupkuu9hn0p5sZ48LlEz3qXLHpxHRj6qmKxXmu9zirsGr5r/n+GwLoZGqsQUxuKy3iqrmzZmVSQzZqovRJPek/bUlUZ4usChCRHsmoOKn1pOTI9inpQkxSbD8r/FaSybA3zwz7YFrvMvGDnAOdsuSZDbCXszC/D9K0zzfzkXmI/tpDEsv+8HrOUjSHgeu5VcW+hLgDfyQWCHG/Dz03hMIw8w6x7sA1ujPei6RaFwjpQxPUYMIgKhaMGy3skwZnyVgrzhFIQY9M13KzDKVkde1hi6KRXtV1pxqCDDLaElXPA2FyEsPJbDPo0GqyNyT6WDZlS3VjvLx6d1iuS4k7m3GnUueKe3soxIs/nkBUIN8e0HqblNDh/VvL5jPMkLHYZYTC/24ZGS/b0aE0pMXMO9ANEjfA42msOnPlvGGXmHbaejsy5E4ZZGlrYklb6kGPyLKD/e2SVdktWpxSJ1wnmuSV1EubMTZVh6kHV2V7pDZVFeWVBw7BE55ReF8Ylrz++I8lz/PWeMVYQEUgifafnjGOs0n8prqYQmXmyznvLsqSwkWG/nAPvEVpi/tA+55v78dXao+Z7cu+QxDOf2Bf7dk56Pi7MWPbIhSRLbRlOayitdXzdzHU1rFZ9ACMM2A9zlLZBotnaCAM9sklWvFb0lEo8DS1NQabevHEB0+tIssm1oKKxXlbrJGfpFNsi+fL54b26V95qL5F9Y/6mm/mhioopxCbZ4zzIVU61ePPox2BNWuZa+z32qxqxzzHap5ddlXjHls9ZUHJO5zm5UGLZKEnqPLiQmUS1vW+uIwWmUFgGRVwLhSOEXl7qvNAeDQ2NDMPJ9gI8aF3lxlgba6v5O4ZjtcTRMiEYp63nkXNjdXyREMux8jYcF6N8GQEeC9trHFtOokcmMEYgqxj/lo3hXHohtVOhYIQ58jtFkcyvo0/M8TMftSVKCYxQDCleNfZUDG3JCP2rFyXnjXnSqeQLoaJvHe+se6gqJmQN4ij5sc8zNLLnXZZYtUTWWp0pQpPAIGR+0P+cw17lcZn3SH/kvKfd9AHkaxniR9+wLwhPqs7q5eO6MSwawqpXnXYousLx9AYx1vQnvzfHku8kEaGdzKleuHyqx7ZlvnLLsivmYRqanp7dVD/lvXmAevwkmF6neNMvu+yynTBiQ9+Zc3rULN1FH0i8IAt67ukzvWSZD8oxiFaQoLIP5q9kj/Yy99wH+9N76nG8vgxvzhDlvEfovfT7ksQMXTbfVKK1SM1t/p+Ceb5KWl3oss/18tEOvXlCb6z7MJ95k17Vdk7M2xSTG4tQcXGR+WEIt+fD/Zm5P++5aA1rI5qcV/SNHn/vL8wZomkssUUfcR9KomhpJvpdjz6/k2hbzmuR8F3nY26LklIXNVSwLhQ2iSKuhcIagBAHD7550vp7uZqssEd64eaV+JAcJEndyweR4VIaqWOCV3q/NJDHCOMUYeXcFM2YB4mcuZWrlrfhfFzB10NkqGEqdmL8GYrKq4rNeD8X9Yg7fhguqF4jIqMBqwI2x9GDOGakaNBYazU9WmPzqTWoUmQma6K6L3PvzJW07A7QY4cRh5dM43gqpDSNQ181pPmftU4Z05wXklnGE6JKGClelL28bmkfhBWikl4RDFragpG8KGF1nCCiihFluRMXpdg310iKk3lsc02tpyvZZey4/tr7m9cl++U7RCa0ZHSe6rpeVOeMIbapRg0kalkuzDqhmfPJ92kPv6WsToa7ppfV85L48TtJl556w4CNzuC3EEqOp6cUzxeeUxZiJFApjiTx4xjMddpmpAG/sYRO60XNcOScA+bgZshqhvXOA+3mXLjO3CzJY3+au+v1K3kzb9OFApWh+VyymsrPq3hVlyWhfncenGfOq7E56X2EOU5orNeCtZEZv15daTc9q4wn7TJVIWEfmaZgTjbgmrduL+Ovl5s5xPcts5QCYVNIZWW3RcbERU7OhXso9+1PfvKTQ1QM/2O/5IsXCptEEddCYQ0w7GtergcPnR65bTceIsusQk8J70wh699pYOx1TlHmqLUlPRLmP+pVnTLeFUeBALSEFWMKo5P9LIKx8jbsAyNmXn+5Au756WlN76pCVnpkDPHTm7NIOBcbc4f2cM6qnWLUpDHD/xUTypqbelHdNN4NJZ8ndmSItmqhtEGFzdaINDdRYRrFXegjPWN46gy9VnRpUehBVGRHAS2MLDyK9L01ZYUh0xiivNKvEBLalF4n+2bdoC0cjy0XBDgW/cBY6Y1JlViVe/Wu+Mrc0WNr2R83CabhnYap897QQ87V3E9VSLNcjfMmCbDRDnzWE4sZg6Qtc+qde0lWDas1UiDVdv1+hrOaj0e7JBC03zxYw36t8Ws4rkSXOScJZR6ecsopO2JVApElc0Gz/R/5yEduoA5sOCevhhzb74yR3lDnpDmnubV1v5ep8W3UBefJuRDS6rxS3djFK+9ZXicuHujddU54HfB/nyXWWm1F8PI+OUU2x7Z1wDksWU0RqTakWsEr7ksKSPk/SCT9NyV45P2tF0Uj6BfV3/k+EQDcrz1f9Ra8F5uXz/4I5V8E5lfnNhU1klEr9FEKe3ndGI3AnGXBy2fUuisrFAo9FHFdAMrUc8HyACQkhJt9oSA0AOc9YF29XkTMYIrUprCCK63zoOcs81L3Q76+Df0b6zNX7SWri3h+Jaw9QSNDPhdVfV21vE0SAc7RdiSBVb08i9hLWjE0xow1+kRxFsdOgx3Cg2FBmw31TBhiSukvvZaGPDI39NpocM2by4YzphFtDcipPlXVVALEOfMbzsfcUT129PMiOcdj48DY4Q1gU8BL4aH03HNP55iSh4RquXjC/A3nnWS2FSLL8iBTYbCSJJ4v5vFm6RC9YJKbrBOaRDTVQBk/roFe6DPttG9d5NDopE8Mq6XfVQtNle6MbFAVmG3etZmlvfQamrYg0TbcPOu6OhZ6iDSq+T3Hpe85R/qO33leGfZouK5h54bJcy24EGH4PW1jLqhyzfc4DuRC9WSiLjTaaTcLRIQdew7mQZoHrJfKWtKSbb3OktIULHL+pCDSvPBe+9aN9kOuuKasRcuYumhkPVjBsZg3enrt+xRvUok5yZ0iaP7PzzLcfRMkdAz2oR5ESZjjI/FkASLz4a2nqtAa/cCY0Y+Ce4VCcC3sV8Wxxp7xhgUrqMd95b/+1/86LI4CrwPzo53X1o4eI8EpkOgzYkp7oi1zY0qO4fjOkbzP6HVPmOObediFwiZRxHUEF1988eylL33p7KKLLhpuvC0gruecc87sJ37iJ2bf933ft9FBKmw/7nKXuwyvFlJfZJuHlKTP8Mo2HCgf1G5ZF9FQv/3KPWmVP1tCldBQ1Ou4qGdrSnDG0L5FCaueL/aVD2GMADx/vXy9zFfVa5if0zYJQpYTMGfOwvEtXGHPEl2qTDoHVKxUxCgNQwWRTj755Nnpp5++k5+X3qGeUFUPkjQVKTXG54WmZXgp81kvloSNfWDESYA4X4xDjMtlvf+0BdKDN4L+0IvYC2MmRJrjGLIpOcj8Sfsow1vzNb1dhn/S/p74U6+tjBt9kPcDvX3Mf0mohMv/t8ak9wnFigDzyTBe8w8zR9EIDa4L617yPf5mPnBc+t/zkRBZnsSaqy1hajdA+ywdYj638yE9YJJS5qjiPobzAuYfc9jyXNbxdTFOAqKHVeLHZzyzHR/7X5VkPVvObc5fY7xdjFFxmOsZckMbuL5zMYFz5Dt6Jd3y2nfhK8vLmCfewt9KcHPjfBS+UrhNkqrn3VDoni1jKSQXOvTsSvbMn5XAcv62g/fen+xv9rOMt30KvWdb7zM3c7AlYD5rjDBo921YO6/MtbFSUy6itVEf3m/0rI6RcvavZ5W20DYWF5k7LHqwD++R/J/x4x7JPaB3DzSlJ7ee2JmLmklQs4SZn5kr7v0kSxoJhfH0phvRYt61Y7AtKtCFw4ubfLOKLt0APIB+/Md/fPbWt751+Huqe7xAH/7wh89e8YpX7Kr8xUEAq7esNnMD56ZbWB16Z1syy8MjVz6zvt8YFP1w5dv8vxa5Kjq2maO1Wxgq6HmM5UJqPEhWl63zau4pBlm7wj21Or5MeRsextZ3bM9Ropo5qhISIzUUrlHUytp6GDHpwVKV1E3Demz8+RzDGYJGuzViJSZcrwjE0Acqmi5a3sjwY71OCvFwXmOLLm2osflu7fhzbEvMWAJFw1fRITDmoex5MjH89DTTF/5WzyVgfhEayYahtygUkUohqUUiJiwpkdelXiDzrjPnWBJgzVI9L1mSxL5PLx2gbeZj5hyArFnayYUHvofBrBCQYYh6J3tzg98psJVRGnp6WyJtrrL528wd225YuMTZdjtv6Cu9QYanKmqTeZb+znsp7YIcsA/b4jPac8pQUEOE836X6r55nl4/Elb6j43rj/BO5l8q5zKnyceW2NtX6T3NkOC87nvk1PnEGHBdQ1CJnIDg8LffsbaoOgES4ay76mIa9yY9gxwz67Bm+oGhv5bg8bNlRfoyHHfRbRES5D0mSyBNpTJkDnaqskNYWXBIMBe5frLUFPvnWHpWe8+2zEOVrDIezBmue8P4s/Yrc5GFUcY1o3mMsmlJavaN15tj6CY5zdBfc7l7XlTHiOOrk2CuMsf1fp1lxX7hF35hiDrI8mfkuZ5//vkLzIpCYXkUcQ1gTOE9/fSnP30jwmr+Rk9tjhsIuS94aQ8zeS3iul5o2GduV88gbsOseLhIMjXEFlGJXBTuvyculVtbN1SjzrqOYzB3zFC/VVZo6Ts9rG2fsW8I0DKEddHyNm2+KtAjzt8Yg7TLepUZ0qvgkqv2GrWe/6JjqGgHRrNkx3w+xkUlV967kj4PGUJOv2ncep5j7cK4ed3rXjcYYwrh0D4IzqMf/egbeCcVCqLNhrAZKsn3DQleNNSM46iS3DMgDQOGvGUe3zqgR8pNgiDpSGVXw39zYUrSpJfEkGm9WKnQbJitZNRXy8JghGpoms+GAcwcSGLB/lSnzZB9iVa7YJVCS/yvJaa9RZVWVMl5o+fH6wSkMm/mVBv6rKceZGiu6QWSP86d9tMvfg9k6SM2vuN4tHPM/GbuSc5j0zC8zzDPJB6eO22wdFJez5wPIboep+eJzrmSc1YPJ+PHOLIfNq5r2pnPAvrSHERzDyWnec2288/FEAmNnlbGwxq7RnsY/usiVlvaZp0kdBHQZnP/eZ1ahFPwSO9gO8cN6VZEa6zUFONoP2cYdYJ9S1YN66WNzp18XnD/5tWQbo7DIkRbeka9gLy3uiVJdZHLz7P0Ui4qeY9UhE6SqhdVETIjG7Lmdeb2p+3ywhe+cCCu7NuFtyKuhU2iQoUDj3/84wd1WG+wD33oQ2dPecpTZg984AMHA1Zw0/nABz4we+UrXzl7+9vfPnwG2X3CE54w++3f/u2NDljhYEKvTZLURRQADd/LvNSxVe6eB7e3zSMG5pHNU6/VePcBOmbMaJTrVd1N3TfalvmACctv9EJ5Vy1vQ9v1NGKwOG7pfcscPR7uKdikMagRkEJIqTI6BkVvUuxIIZfM+WNfGD+WLJkSUmq9Kbzye4kqURVTXlXJDPtxnmD4JWngPDHohV4mFzwMCVW9VA/YPHAMiJfeitZotb8hqoaHt+Gsi4S3LvO9rGNKmwwb5NX+MPRWD6PEwVxN2sk80iOkAemihNe8eZbmBEtm9LYz93plcgwlt520jflE35sLbJs0Yv28zfGeJ6qUY54h4qnibSgvoB16y7yfZCkPPTl6p60NC8xplcRmvymGJIkwx9lwYsP008tPv1x77bXDZign4+b1zn7yHM1HlSjqCc+xa5HeLb2oePVoB6/YGvRPihWZSyuZnlcGK/UWVGr3d/ax7WBcuNcxd/SmmdfLRv+1YbqbECcbg+2XqE49l+jvDP8de9aYF829NO87GfWR89/FphbW2fUapW9JUzB8OFMpvMeyP/qYcWdjcULS6oKUzxjudY5XqqKnd9w0nDbqIYUgVX/WY25kA8fjGuB/SVJ7Na59/rV1wlPkqpcDWyisG0Vcj+E973nP7N3vfvfOaulrX/va2SMf+chup5F7wP/Y3vKWtwyEl4uX37OfhzzkIWsfqMLBgjlYeaOfZ5gbEpQqv8uEzmpcTCkd5ur7vK0lVbnKygN5KlwyV+lpk95kHn6rKCmvm7AaYgxpTeOPBznGI+3QO2VxeOs52h77SJVNV735njl6ii3NM/Q0gDIEy4LzEEnUcGmvRFEvCd/FG6PQyNhYSFAVEgIqRnKeWd+0hYI+hv/yXQx7Q0D5fU8NWu+Mixr2gXm3GIdteHSPPNKvliIyxNh9pBCN4ZPWU8xjrgPm9abx35IAQJst0US7UTGm3Xo/gLUfNSbdOC9rfuotMjeOzzG0DUPMfoaomxNsnr33II5P30mq+VwRGhcXJCtT8wiwb0mlJE6vjSQ48/D5TINcj5HE2XDWDGmUPLtgo9iLpXcMM/Z4ElVJsNcic4Bz0vtLH6kUbTgwf+MJozwO6tvkGroo5Fg7vuk5TeLrlvdKQ/zp74yOYawhh4ZvW/uzd4/3elRsyz6f0kYwrNo2KlSnV14PvgsItINrhn7N2rubqqu6KLJEUeap9tDLU50CfWA93Bwz9sPYcA1xXBYJMv3DdkkgXZSgP1N/YkpwkN8y3qeddtoOOeSYHJvrQX2GtBNc+HEuusCT6QVA4pwENevtGonB+aVwU+/ZZOqFtsui6UopiFUobBI1y47h9a9//U6nvPzlLx8lrS3Mb4W8gv/0n/5TEdcjBgUakqQuIr4kuUtCsRcGgzle8x7yGhAY3RhArurqOaOthsupMDmW+7SIkrIPvzYcGWNAr0+GnektWSZfEXBOeJ8yhNZzYPwuueSSHe9KW0ZGIpWhgv5NuzRGp/rWxYU2DCvHnr6+4oorhggQCas5fxgkaXTm71pvaipHGxqKgTRVI1evKpu5b4w/80BDpl3U0EB3XlnnMoVc2OgbQiANOxub77QVEgHpghg7VjnW7EPV1HmEa1FIOjIkz61nvBlu2W6G6nH+9AvtNKQV41HvjHOsNTK9fmgLixbMfw1TSRP7MqdTkafMWWO8XGDw2uO7zB33MaYKrOFrDqltZVPhV3LEedI+oxb0iPJ/DHJzxjX8vUe29wQXIDSuJQN8bhi2kRB6/I3o4Ddce/QH+2eOGz5uyLF1J/kfJJVNz1HmnkoKzI9ulWf1OrroktEVel25/iAozHfaRPssD2N+ZW9RhfkkSVUULO/XltPJNqRoE/3F9cI5+ntz6hl7KyIYDrxqXdV1wpzl1HUY89pN5alOwYVPFipa8Tq9yjzD6bvWq5n5445h5k4bqWIKmeJgXs9814U99sl1okCdYfsZ5eTijt7lFErK/FPa4nWmV9XNsc28caNacjOcOGsZe020InT5WRJjow2M5lomRadQWAVFXI+B/FRw0kknzR73uMct1YmPfexjZ//6X//r2e/+7u/u7GevQAL8z//8z+/8/d73vnf24Ac/eE/bcNTBTZuxnwqR4SafJHVKpn4/ofCEK8cZltWWJfEhrmx/67FNxVO9GFNIRWbaoQJpS5L0XNA2PElT+bitgIXiPbSFVz14Gn89mN/ngoRKqxroGAUYP4alJlzpztIzY+Fr7B9CfeWVVw4himnAaQxDgPDWSIzTs53e1GVr5GrsGPrIb5jTLsi0ebJ6bjguY6FBpUfOkiO2h7lDu6eiATQu9RCOeXExvPGsctxVw85bwzS33nWchmVu7CfDQrMOaOod8D/GjjbnfOC3Gu6OlXl0GLiS0VwkMbwvQ/7cH/OPa+aaa64Z5neGpdIe1U0hMJAX255Ele/qFVUdN8ObeZVk6P30XFTczRq5en57Im0qHkM6MeQVVmLeGXHg/uk7lWElufaluYof/ehHd45P/0HgFElzsaYXnu+YWT9WQpr5nKkanSJPzoMcD87nYQ972A3Ck/muXmU+V7jH8G8Fp4yQaJ8PLg6BJAoSdRek/K5zgns042194m3wqpr/qZDUInmqyyrNAxdwzEsWinkxlpaZanPWXWhSid3+ynJnLlj6PDAX1SgArp+8d7JP5jHnwP9SWMpFYa8bFyXcrwspea9xriic5efAe0l6cI0k0EtsKP4UnEt6aFO3AbRaF4XCplHE9RgUF7nf/e63UkfyOwy9ntz8pkCIE4nxhf2FN3ZDmvQ+JkndTV7nppEhThpaPWhkakS0JG2R8h/zwpPN6xkjrOnN9ME7BQmpeZGeI8Ye54OxbIixRFuPMoaHIcGuoqd3xTwwV7NbgjoVImzYtR5tvD/kRmUpHWBYI14mPUo5t9oxWKZGruG/hrvRR5AdIwfa/s8yCLTFVX1qEGIg9SIN+C4e1rEwbvPIIKstWW+NPcgqxvcy4fNj3tMxb7OhqIboSW7TK+oiVOZasj/IEf3OmFl3mP7CIwxpbRV46eP82/dGOHDcFO5S+MT5L2kxDJ95rXc+PfnMcRRu6TvJvgTU4zIGhhKrHJ3j73zVq+S50RZrQLrQwHwy99WwZw1wrxFIszmd1hTmvJkDHEdVZY5rKKtGtiTZMlMQD64dFqWYw2wpfpOlpEQKI9FWxtc8Yb9rm10Q8r5Om5nTbJzDG97whiH0NMPT+R8pQ7zPxSPL/0g2mfd6EVtiZri4pEXvviJnikYx7kZiSLJcTOO+wdzbb6/qsnmqLojupt3MaRYznLPmaUo21WjIe4G1XA071sNoiZhUyc/nmfcHhca4DpkT3kNSvOvyyy+/geJ5lvfJeeqYOi8z991FwbZvjBjxvdEfy6iht0rovQoFmc6RaT7buBhfOHwo4noMmSuwCvzdIiGi6wA3tX/wD/7B8EDAiDTkpLA/wAvEg0KDdpthDovkZuxhlgaVYUe7gZ7K3jVm7hEbhiwGmB4QQyJ5OLZEtyU5+bCWBEMKWzEsRa40JnmPMc2m2Av9kmGC1ns0Ty09PvPuG4ZIGmrrSjsLZhg4rXIvRgNG56mnnjq8ShJa6OFcxKtKO/UKc//gN+an6qVKKOTBZsijQmEa44SiWt4hQX+gtN6rnatH11qrtLtHVlXahARMhV7rDe0R1ClvgsZoip+kR8PQQIV+WuhlNsxO77ehdSpI8z9Kpky1RcKafaHhyD7oC9qRnkEJo/mmLsbQLkkOpJVx47v0NeNtrdIsj9TzQhq2mnVqme8el2tLQq13KsvY0G6uFUVg+L+K1+Z2cr7kExISr2e3ve4VMmM/WQKKhWLmkJ4rQ335rl4w86Qlr3pOVTmWQCVZ5HcqukL6JKm85/6Qyq+8f//733+ja8dICxcrJBu5QGi/mmriHDKsOMm6oeeSdb2UivzoBeP6tKRKm0awlzAM1XNdNE/VBZ9F9j+2QU6J2LCeLCTShVAXkSWNqlK72MhYcT9m854/pengYobPRut/pzCbaS2mArX3MkN9veeYby5p9PqZN5beE/KeBlygceEt86C9x+WWCzBTgnSCa3zquVMorBtFXI8B8sdq71VXXbVSR/q7VB/eJF784hfPPvKRjwx5NI961KNmF1xwwZ4ct9BH1nnbRrTkZsyrqlfHVed15A0uK5ahgWkpminSYjkIN40kjBWMWjwvrnjrScUgUAEYA1qRH3P1UojFfCK+R3sMr9SYVPGzzcvFyElioBHD9zGirBmowaswF0SDaxrSxzj0sKxXVUOQY0kybVuSKcORFWrhnJ0Lkk3GakxhEyiqo/BQguNCOBiXXkkJ+o3+xeiGrLe5y5KitiTEPPXrNg81a3oy3xWfakPL2/NyEYON/jAU1fxN+xwiIeGaEr1yTJirjEUKEtEu+hCyJHkGHIvvqzbKMZiz/C0RY7xdXKGtEB1+kyGCIEvr6Gn0WtF4pV/0TEksOXfDlfW4uvDhtaKxzX4ZU+Y1c0mCjgo//adolXmm7J/fce56H+lj7g9GTVh+BmR+qvndjqMeLhcY+ExBsnaB2XE7+eSTB++05WdcqMn6mVPQM8o1wjm2EQSSAwmRXm9JN30I6eK93moJlOJw3rfoJ0kfxJpFnjadY6/QLqB5j9Cz6IKCf0v6VUz399Zhnbe1MIeZ+yrzwwgA7/nWRpbUGSbs/Af0ryXFXCjIkk6ep/s0x1nVeY7HfU3vPf+39JtE0Tx16667KJy1UZNcjm2K3qWqPcd1fvWg4nqmlqzqqEkBOO8p5qEvI5JYKKyCIq7HcOaZZw5G1Yc//OEhBPee97znwp3Iajrhcly0y/xuVdDO5z3vecP7X/7lXx7yWguFXmiWRsRYJIC1LiUo8wyzdUHPiV6bbA+GLkZ32xY9QL3yGzw4DRtkAcqQMOBDGmPYPD/2zXHN49O7Sj9IHPT4tGHRLVky/M8HuP9L1VG+4+o/35WkYIDSHsIPya+3vElCo86xnOdV1XBJr6pEtecZSq9qinroMVHtcmwczb90/PgdBJmQOL3etIH206YM3aRf6V89WrSdscCTm+UdUijL3+d+NO7zN+YWZg6a45v5aqkGLTFtlY0z/1Ghqpb067Fvw/cM9ctcUg1twJhLeNJTC5ifKltzzFyoYDz5jPZzXvQh8xuSCPgubeU4Graej7nMknoXXAwRdGGA4zv2WctTDy9j6j49d+8pqmrzf/bDc4u2WBuV95JVXg1B528WN7yeVVrNPHmOoUquRn+WackQYRV+k4SoPgzBZ6HoHve4x1B7MtM7xrxclvkx6sOFIMOvjcxoywjpNVZgif7Rm8dmiLPePeclrwppmXNp2oSh1t6f2oWSHulKAph/9/6fXuz2N5YYyvPvLYi60JHk39/12tn7Oz/PeqWG70JWnavei0zh8VmToniZK2xpLu/jeofb/vG68dnhcbzPsh/nvwuvjJXh5o6fYb49zzL7TO+0/aDGgkQ1o4fG+s5F2tzoC3Pop/o+dSkkqG25PYF4nBF/nDcLKIXCJlHENdSBf+u3fmu4aBFnuvDCC4eHwjxgoCHOpJG0qBrxbvCMZzxjeFA86UlPmp199tlFXAtLCfFowOtV3euafBgZGGgtYcUAg7Dq0UyCyqYBzUOTB7ikU2NYgRsVOM0J4kHKfs0JdbWa39APeDc1/LiOJfI9wSmNNVfj9br2YH1TxkOFWcmLBrGCS5AN/s/9ROKaK+r2UQtrVWZNzAz/bb2qqTrM+Ksuyns9RXplx4xH9+er3kj7j3FlTD74wQ/uCGH1Vv5VW1WchpIki9QB1HjNWqgS4vR8O9+yHqbvgYQrCWWGjOZmOKc5yPk/CAQEyDBhkOJdtkOlZOY/+0rSxnHpCwxdc1z53MUDjWv73bq55hxzLOY47/VMY6jiOWRBxGOZW+sCi3nJev+T9OdcyYUec28NjbaOpbmJ1gXmu7mIZA1Zjp8hvM4hFnUQlRor3SW5cswUwGk9cfa514A1ZLnOnHNc82ecccZAVl2wk7zkdZ55wJkD75jSf3hIGdO8zmgb56LXjf3rpVeVW5LiJkG0n/jM/tFb6OIVc44xpM/oy1b1tacEu1vhHD3C8+57jmeraGuKSptWsKwmgqB/6E/rOXvO3l9clOOaSkGqzG82d9t5LSRqhvam6FFCNWQ1DvgOhJXrLvNRl1HZN5rHdJd5fQ28HnPrHdPFqiSlvs/PV8U8oadCYR0o4noMP/qjPzr76Z/+6SEfjnybu9/97oNSMJ/3wkC50VHr9fnPf/5gRHDj4CH4xCc+caMz841vfOPsbW972/Dw/ff//t9v9FiF7cYyIaPpVd2PHFwJKyuzracqc1rN9zT0KAVyJKuZM+W55Kq+3lIIK6F/5h27Om8uYIbiKmLDdZXe1Qz5NYxSQkKfZk5ekiPap9BRKuwafgnRYdM7yrlhgI3lmwK9t5wPx1ZgxHIxbaF6+zfFnJKo6vmgTzC+p7zyeugkWSAXPNrcYjYNSo19y3IoMMTf84zYJC0eB6SgifM+xWskBuntNH8siXaL9GJ43hqnwPJCWQtUgR++Z+5hnreLMFynrbGqJ83cURYN3I8eQsNeVaW15ATz1f1zbobcpxc6ibdeZfMOXeCyNI0hwm56hhlHw6MNNfR6yr7mb9qvqnSOkV4pz8tFNnNO9fhKLvyOY5/edT3hzlfD+Z0vijtBIMgRd1GBOcczmlBgPfscg+t0LGc+Icmxz7xGJRYSnSxPY+1dx83FAhcJUpxHr7KLBswtha74X6p0Q1jZJFZ6ideZ2sExve/a3kTOL3M9c360fSFZzNcsJ+SCgYscLvQp1CWhZ7xcXHMRyYUnrknG22uq7Q/H17BmF1Wcw/a/nvHW6+51wSv74D7KgpH3FvKLs8byIsj7pvnqUzA3NUmq88L7jn01Rkp7YmW+9gh62we5QMizu63VXShsEkVc7Yib3Wz2ute9bnbuuefuGJHPfvazZ895znOGhx8raIqSEPJEeIQrpID/8ftNKvdxk/3H//gfD+9/7ud+blh1XRdQZJyHnoBHYe9gXpRkdUrwIksIpBruXkOxC4w3yYciEoaOaYikwI4GTHolNNA5Nx6WnJMhgHpSeNXLxPf0SuD56dUe5fsqC6dhKlkdI3MSIr1OnIceMs6F37Fv2pl5VkRx8BkGlSv9nH8v5zOPlXVPMdjo0wxPboWdUlTLnEv6x1y5to5tizQYNXpaOE4agBrYQG+GXj/CYT1voAfITdKpdyg9fxmeqdcww5Mld+aCZlkIDan2eCBJWm4a21xjLAqoKq0n07zYDCucEqhhP+2iUip0Zxkhx4Rrlv7K9pgLKQGlzxlXRWWECwyqhXONWGeSLUtuaASrRmuOn+1JRVbOwXBvF4dUvfX+YskYPa7mAeu9dEwULzK8VxVir78MT01yIkF1UUFCZ+kchZWyvin75hqFYPB9PKE9cp/E2PcSTftC8SuPY7/YJ85lzpf7gLmqLsBJwmmz+aje6yRKXuuG0etR5/jem9r55PVCm/TCG0Gw6OYcc9GA42V+ZpJNIz2MasnyOmOkKOdn3rvsH/efc9A57HmrjKsn1Wtd0S/DsCWcuWjDdaBivWrCzsW8bxqZYzivY6WiO7+zZrHg/9znWvuvPXcXsXy+0A8SwJ6YluTfBdksuZWRAL53gWtV5L0zj5fn5SKPx7VuO20q4lrYCxRxDdz3vvedveMd75g94QlPGDwQPoQQXmpFm9JQ5Ib5a7/2a7Pv/d7v3ehg/fN//s8HI+CBD3zg7Md//MfXum/EUArbB3MjU4a/B0U6NIZXFV1YF1KdsTVSVCDl4d0WWAc+hCUxKpJmKKjhiqeffvqOAcPDXVEfyCDkrCeOo7gJ/aVn0DIc88Lp0rhRCAZirCgIxnrme9I2Q8cgkFl6SM8QHgK+kyGtGm56GvgN52QIYRIVhZ1cfdeY1KDAQMLQatVjFa7REM+QSb6L8S1xyvA1yZ8Gru3K/XLse9/73jfK+TRvz9V/jR/Jiec/Ng7mIUuQMkw1kYZXj8yqztuGgaaBK2lTMdQ8aQ3dlgwnCWceMMaGY2tQ6qGxxqt5qPSjCwuZy8v3zTPWwFeEhXH2PPTYSFT5jV6+NhfOhZAkHZJNvT6Mhx4+5yHtkVi5+OQx6DeOab6mqQrmBGZuYYaOmrtnREMrvkNbFXnyvQtCerb0eJpf6Nwy9cDICr3mY/MqvZ7OB4mDnmFAe7nWOYZKz5KFJHfOLyMNvD7pA69h7yf2iWOuaFybb+2m59xFkdaLCczRZxsrx5YlXrjevXZ7AjsKDTlvFiEpbTi0AkyS9cxh957mAqILNd6f7D/7mXawQElUjfcYw7clu+aBt+r5LtiY6+zzwDrHemwz15lzMfTd/uT3eFm5dlt4PaVIXy+Sxvue8zbTF5zTi4ZXr0JKk+jm3KetWV92DClOV6HChb1AEdcGD3rQg2af+MQnZr/wC78we/nLXz4YDGNGFA9FStI861nP2riaH5L7r3jFK4YbGYJM++VBK2wWzDXz2nj4TnnFNCRUvtzvOWEeIOH2ePANQ9VDZv1LDW2hYShp0UhMciJ55UGrAmvmx+HJ5P+QSMpk9B60GtCA6xojZApZjzdX4gFtwHhlgYtjpnoobcT4YUELby4GnrmjYwYA52C+saRQQ0+jXoVW829TFdacLv5W3VIv9hgMO9ZwUs0U6LEzRFCPgPWKJdCSV6BhSRsgDfwGEpWr8xKgRSDJ8RzdWuOrNfIkjxpghs05D8fu55yP6rwJzgnCqspxhia2hFjhE2uUCgkr88iSJiqQJvE2V415xoJAWyYGmLrC/yUejoeGY4aVcgwXdnhOKVBmuw0HZV8SJQm04kdshvsqGKXYmIrFKWyVitCSa71yhjC2NXWTZCssA6FQcIr+07vMuUvaMryRc2as2CQc6U13nvheb5zXmn3cLoboEfb+xHUoSfZ6cYHHMSVVIWuRJjnLvHTPl3O1TNA8MI7MMect/eF8EC4icJ9LUScJyVQpNPsgo3bmRZNJGr0/mNaRxNTFiUSGFEvejGRxbkswrXXLvZU28T9q4eZcSoXijEZxnljjFsJpjduxvFBh+a7sL+7DLEhmLedWlyEjVno5pXrqfTa1tbkXzTcdI6Xpdc57ogsfSTpXheNXocKFvUIR1w64Qf7bf/tvhw3BkEsvvXRHVMHcIlSI73KXu+zJIHFzgSBz8yF8GVGJdWOeEQ/OOuusweAvrH9806s69iDRY5MhhvsJc8S4LiBxKMFadN0HoivjGAoaJ9an07uRqplJUPyuyox6kjxv82MxZvkfHlbhw9myNzzINW7GYK6YJFXvo1AUB6MdUqhaq9A45P5Ae+mDqesqRTvMV9bg0rgXeqkNS3YO8Eq/OnfsH+t3Zu6tuVuKTmFUGuKrcZnhpPYHx1BwiT42B1kj0Pqa5h0aJdC7V/RIa6r+mr9rLrZGWIomZahaiuisKiqi8rGiQRp9tAMPPiQljcKe6AnzHgLXhssxHyxLw/9Z1DGaQCJtyLULCLSD7+plUaRGssU+2nxmvaKG2Np+rg8ItB4l5g7tM+eW+WKeZZJNvX5cO8x1jmkEhecJ2Jfn51jQpvSeO78NhzfM276SXEomEE6C9EEqjGrQc+b9RTEqw0qJWiB/ld9IQPQmpTecftS7qOhVehlTzEgCr6dMETG9y5xDqsRKQjg2fQex1LvvYluWNaIt1ug1TNQ5vSwkmKYfKDYkibOWNftO4bokyebfp+CXaMX+zCV2IYNNL6nn1oNee4W1vI7Zv9c642DkA3PF8kHes/hM8bKxWtm5uGT4NPdErgXmiiHueQ33SDzHYP4z57Of2A/txz7MCJq836aQl+cuSZWoZv+PtSHzao04cpEuSakLEqkCPKY8vAy8941tzBUVtPd78bxwNFDEdQ4gp3tFUMfwMz/zM0NOLQ/1/+//+/82cgwe+POw6ZqeRwWZ+2ZI3xhUf01VxP0AD2CNXR7irqbzmeU68uFIO2mz9RgNkTOETpEjDZj8nQSQ3/M/wnBZ7c79awDo/Um1S/NnM5xwypvqNrbajhFgrh7nnkq5WY5DL8oYQTZvSiPaEGDJf4YqK6iV7cuafxqN11133aihS1vSI5+lECRKtMcwX40QPdx6/zl3RUPMo3N8+A1eQY3FKdAejeLcWs+Whhd9aCmndYSgaWhlnhjjydzGmDUsmvPHMJ1Xm5n2MScwontzn43xpbyatUPdNPIlXqmEa11Xc+D0YCrO1I63hIn2QpYg23qIW+NclWvz4TLU2rHhOyxCXXzxxUPkhHM5CaDGM21zHmfJDMlrKtzmAgq/0/sLASXkkz534UhSxfdtM9c285JzdG7zGwirHtCxe61ENXOSvf8A221edyrN5tiam5zXuvc0+8hxhPD0iIiCNmwckzm0rgVhw1M5vmWbeN9rh2HJerPbe4TwOszSN+ndHINELRegeO/Clrn/Xnf0OQt93M9dCAPmMTM3+X6WGcpcT4XouA4khQrSpSihpVvm9SNtdP4bQm9bPvShD81dKGsjh1yAMxTasmhtFEDmFPuc0Nu/DuXfHJ8kwu2rW0KBsbwH6RVXDM+opkJhUyjiuuWAsF5wwQXD+5e85CVV3PmAIksZ8PAfM8T1PLqCvkmxrzHoZbDWojlCCpEAjY8MkTWfDRKg8YxB4kqyYX0tzAGTaKpgy3EJX/WYPjQNvU2iangeRgtGWNtv87ypPXAMCauhiZmDmOJMipi0MI9KT6GKyD2vaubP6iVwLvB724P3ZMxgzPnDPjiGZUb0lKYxrpfFMiYaTc4BPaB6mPSg6+EznNB5YNgYbaA+pt4FPX2ZQ6V67m7LdIyF7ravKbgDqVAN3nw+vgcRGiNBwhIoGMDp/aU/7EMM8Lw2JEPmZju+5s4xRniz9TIZdif5ZCwkfIoUmcMIkeOa64m7eL70tcSMMEte+a4hy3iOWARhkait25lljzSsDSGXFOntNUfP7+kNUuCGewLHd0ErSyI5RuZNG2Fhuzlna71CVhXjSehh9D7bjkEq10re9Wipaj6WnuFc4neMV4bq663NcNA2p1LBrV7+6G6ggJSLHflskSAbDp0LFip70y/M5yxPlGW/xryniVTvNn9adWH3J/nL8H292c7RDPvmPBxzSZ9j4D3KxbecP/b1WApNjlMvfJd20B9cG44jbXF/PUG29CRnikuPlPp976G2wfDddYhgOq97ZDQXC5aFeemOJ69cCzwbwX5HgRWOBoq4bjnIteVGwYOaG+brX//6G33niiuu2Hn/O7/zOzurt3/37/7dIrr7BB50lpyQ9I0hFWAzXG+vgAHBQ1qi2vM0CAmrwkLmTamqCGE1FJH9pGhPGhB6HTjntpaseVl6IDmeq/CWgMl9Gops3xn6lyJKiy4AsG/Dge0TQ8AkHeaaqjLZMxiEq9MS1cy5kmTaxsxZNpeUuUPO7lTonfNH0s/1D1HVU9p6WxTy0rjMMGRDlvWm603kO3jHNBYVxAIZgprh4Lx6/ho2y0ISNEVKFx1b+tCwv9aLBvkjvNM5msJREh36AmLHNdIKCElC6XO9ihrqeiz5jqTYRQhDLc0R9fh6dmynXj5Vog0vVYE2c8ENU1eB3HNk/kFOMcqtJ2vuYe9aT2Ei2yQx0mjN8GS+p6CNoer0KaG/5hKay23JEr3PXG94t1wkkrDaDkl8hsAzjlxPejzVBlB5NvMqJSaSTDb6kO8yN+mP7AN/YySF6Q2W7rFPbGO2VfLGWDMm1uedN08XjabhWN5PJJZJnBJ60t3oK8+XuUwf6v1T+Mv5ouBbuzjgfJMceg/P/jESh+NwD5UE26/pbfUaznspx2aOMNbeE80THotQUmlYhfhcJMut9VaqaM5+uRbpFxePPE/mSkaGqNrvvddnWI5hRh+MhQ5LJs1HX2ReZL/Zd/naEuRVoKc3yyG5+NVGLKkO7gLWbhciC4V5KOIaeO5znztcoKy6UwZnUVBPlZsdNzHquq4TEh4Mjsc97nFzv/9TP/VTO+/xzKx7dbcwjlSMnfIkGW4m2dirEGxDPzHADXnl/ZRARxqOhjaSf2Zul8akIacYn2NhTOarStZa8FBkzmJYW1zeWoUYDklaJc0a9CmitIg3tYX1FjG29DJbc5LzZp/m/WFMpRGT3rxWoCRL6uhps60ahRp+jI8Ksm1OWYJjO3/4vWVbLr/88qHdvRV7yakk3xw3S3BwzpYtcQFDL7aGIPtVdMnx0ijTUEpxp2VDd9vXVvFyVdA+zq0tycR7FUQZZ8JjJTxJTO2T1hOXRF2hE0MojS6wn10EMD/VOeP8ksABVU41iN0UKVL92eNn/h8LPlwztIe57HkrOqVHqneNanTq7dUz5blKxiWsesfwfFIbFXVXvaCS+bxOjIZwgYk2uzhk+CnHkIyDDPc0n5vfqe4qUbW/VWTNzd9rYGcOdpboydq/LGR4z2mR4akuMOSCI+2AdJ199tlref66CGq4s/NQEbiECwN6+xR6o6+Ye/azfc13FdZpvWWeJ+OITcSiJP1i2K33PL2FLIR8+tOfHu7fCkVlSSvg/U+1c37H346TCx0cz2gDQ57NqwcSQRfu7GejcFooHMbvk4gZ/ksbjapxnrAxjs5ZSRqbol4pPDcVRTWPnK4SObJb6PGlH1L52HHxHum93/feq/wN402/uWhTKGwaRVzDU/mzP/uzw8X3ghe8YKlO5DcvetGLhte//bf/9lCupnB0wA2eULsxApheMb1pm4Y1RX3o82qx9XmQFLLRbo35NOKs0cmDNAlB77wNA269AYb1YZCRw8pmPhqvqndmCQT2hXGMQbGsN7UFxzdHlv7B8JI0mk/HmHGsNJxTBdMHeZY9SK8q++C3Gj0YL5JO3ps3zHHHCL/5rob/Mrb0OUQ1y7aMLZCosipRtb8Mx8ajm6HhElb6XdINYdIQ5jw5b/7u9b+eBFWgN22A9aAxjVHFpqdHr4AhqhpqLVxEoE/aaAnDE/UAmYvaikaxseCod0mvKBvzjb42DJZxxUBmUUjvnN4sy6LoBfZ3Gp7m4hFqrJeL/WetVueq0Bh1nmYJjqzraW6qizGMN9cfbeX1bne720AyzHV1X4LPISOq/BpBYXgh+6StLvTxfb5r3UwX9liYwVuuRza9g4msyylhsOxTlg1SfMw8Vc7VMjstwTCCQy+UY6aRLslWrMySPauS1qlw54Shz7nQw/foJz39zsOpRdQUlHOBgs+9RwmOxRzzexyD8eC+yZiM3Yf0ciu+5wIN4yzJ5lXVbdrLPl1EbPM6zc3NBdBeREp6DVVA975lyKwlyrhmmGeMm95fNEUM/XdxiDm7SvRIhjmPKQAvE2br9bvI5ncl696vcgFjCvajqUJ5P/Ra994yL++5UFgHirgew1ve8padG8wTn/jEpTqR759//vnDBfvmN795rcT11a9+9bBN4d/8m38zKCCD9773vbMHP/jBazt+YT56xCm9Yq5qbwo+mPUUGmrXrnb3wMPSsFce4hiZqjpiAGFUeo7mUimM1Io0ZL6qW1u4vF3ZpZ0aPhhpip3oFTRvFSMZQ8KQzN3AHDUMIwxiNgwXV/A5ruI89I3H1IAx19ZzsFxJhuHq/VXwSO+6obgcc6rUkQQ3a0dC7GmnypE9QDbxirBhjBrCm1CUyBq7LWFls/4k/cA56B2zf9LIMkxRIqDS7KmnnjrbFDJXMcN59XrqyWtD85znY4sduZjC+yxlYqgc7yHDCmrpVZcIOlcMM+RVw5E5pwef8FkXE7jurKnqppCL16BgP3iHWXCQrPZIQ5anUOFbr0kKM7V9keJKzH/Ogbmkt02PIl5WYJ5i3uPYJ8SE39l/hqayb/rX+rV6PTln55/5fm3tS9pMOzIUVJJtWGx6W4ERCRn9YFirOcKZruCii9e9HsvewpKLW3xnN/f4LFHDq/NWwpShzxLxzAnO0lVjcHHCeenipGkWOQ84H0ip4dsK8LhA50KNC1zpafMeofAWc5txMyzeEHEXRDgP3jOfJYa9hVAjdsaep0YSuG8jJ5wbHCdrZbtowjllbipzm7b7nJn3DM10hrFFulwsbIklY6YCfks2x7Zl81DbWulTMP82y2TZJiMbvMeluJyq9YvU9y0UdoMirseAShy4613vOjxwlwE3OkrUUP/1kksu2dWAFA4meKByo09v2rphWI+GlF4bV5PnPWAVSDH3jIdzm7/EfqiLJ5FRQIdXxVRao6GXryoBoI2S1TSqeBhiFEGO9eBpEGsgQ5owfNjnOmAoM2GGem8k3q6+G0qbObOGkklSM6zRfE6+b5gyxo/zAMNFBWmM56lSR9ZKNCxbNVXDBHuGM+229Ab9NVVPWk8thFVy5zhrXFmzlf3RJr32LiCkUcJnHJsxWqWExxjSWG9JaS/8MH/HdQE5yr7SU09bW4VT33OuCnFJlJjzzBX7qA2rk6ypjN2KoGTYMXNEgTCvH9oFsSMEk7FvS3R4TpwPRJnr0rI0QMLWKnkqIJb5p34/BWOEZJY+UliNhSJJm+AYkG1Cgjk3xakSafgDxkMPsOH45lUaFmwouuGWU2kWjiWEmmMYkZFeQI4hsWeOt9eNYZuMO+NDGxkTPcO0xzzQ3rw2EsRICq7zLJeyCAztlqhmXq5z3c32GtJrOZ7e4pXhpjm3aZ/ea/NW8x5uLWDVhF1ElCizeV0pUCckiByP+w86BywwSmByATR/x/+833IsF3TGokZc2JEMOtZZ79qFJYlrS9SMlHDsOZ4LrLkoks/uzB/13uw4+AqSbPaIaHstrgPpCc1tSkwr262glvcCF+ckq94vDNn2N1kPnXvgRz/60Z0+k8AWCptEEddj4CHHxQlxXQWnn376ELrHfgpHDxh764QPEXNJePBjNLgKOiWHr7dHIRcMLB78U+V02KdKqxjlhqgBfo8xkqSFB5dhjBhvPCz5nZ4Nc4da0G4McAgBv7EYPBt9aNjalFdsGWAs4JXS4Df/z7YpiGQeHJtGnQI3bva5RD3L/OhV5VXDknOcInRpjBqaqicgSwy0hhfHpI8gF4bwToF9YhiyqQKJIcoxPb71EiEmevn4zFDpbAPjznE5V8OmVyGmYx7TRSIF2v0pdkSbzefllXYyd/USZ54mG0a6ixganvSNiwYSKud0quZqBKe32WgEVX8ZK8Ow7SfDxykBk+Wa6EsJIW1iU53YfErDxh1Xc4xdXGn7LevSej3pbcVIZ9HBEjq0lX3Rj/RB5ugyByAm9AHXU0sKFJ6yRBXGrIsA/MYFGMBxkmgrgmRfg/RgWevUxbacby6uOY7mV/I51zZ97dzSM6SYmJthxPweFX/25zjaVhensubqMuDcDD2XAOa8z/5U6Mqxk8wn6AMJu4swen8zFzPzhdkP52YIriRVopJzx5It6QG2hJFzLVNB2Pi/ueJ8bk3i3K9RD7SZ/TLXXPBx4c4weRcDgdE5zqN2vz3kNepcMtqEPnDhh77kPsEcT1KXnsd1lOPaDXoqyHrfJaOMtwvHuXm/SqLt+FqOLaMaXMhLwu08c0HO+s/OU9GmJBQKm0AR12NQfXGs7uM8uGq3qnpm4WhCYyJXjzEmzJV0JX7ew5kHlsRLIZJFQnY0RDH40iDgwYWRll62VJG0risGAIb1vNxZyRPHYX8YCj5QMRggF5Kh3QIjzLIxHM88Ur08GmB6SwxLpj3mAKkAnDlubhq15lnpmcQQxKM7ZlC1D3qNBWtNSlbTQ5ZGqJ6sNgR7DBg2kHX6gvGRsEqADEWVGLh4wb7pk/Q8cM4uKMwjyor6MJ96HtPd5EG5KKOxTpshA7w/4YQTdsR3VHPl+6pmp3FuuLiq0byXwOr5S7Ee81AhT0l8XLjIre1/6wq70INCPGOJkcdxmTNshoIr/JLe5cxTy7C/3jwwn07PG68sSLApOtSSLw16rhPmHETWciZ8n3aw4JRqy4Y8Qy4UhrLeaorV0b/mPXOtuJhjqGorpuR9xoWg1jvsoprXXNambUHbEPthkUchN+9d7Ifxoe/bPNIs4eWc0zvLcdqSWo6Ri1B8l/uqc0x9gXbeS0RS6EvSYH1e7zUZJcCYMveSgKfH3vI3ersVssrrz7BZXzP9wTZZDsu54IKouamSW++tbBzP3G5TZjKP1ueF+zN0V/LF5nwzLNlr0i3LNXncFHuT1FtuyvOzxI2LuHqKvddlpMI64Hg6vvM2F296XvdF7vk+3wzndb61teON4BnLifXZZpi3C1Beu/lsyEiOdQnqFQpTKOJ6DKpzrko8/V0rQFMoCI0JCam5dFmPdEwsIcOcLLVgqJUlTZYBxsWnPvWpG+Va8nBkvykQo1ciywXMW1XlOlBICGNB76Mr6JwPRvRd7nKXnTy4VeFD2bYZfuyKsg9bjpElDPRWYqgpyqTBQh+b72tonQa1hhX7xriaEgbJPENVkTWksqSFhpekSC9PK1KzCGgb54PRLEEzRy/Jivlilh/iGIyJY2HZGxVux/qeeaGxK8Fi/FEYXRaZh9cL6bVtzCn6nvNK4SW+I9GCkGR9Rr3Z9A0LGqprS0bYt0RPr4MGnMq+CsLYDs5VozI3wxYlTBqmtIuonHe/+90Dscm5Y8klf5v5ePatoaDt9SK50htPOC8eXUPtW6Xkdr7QL+baarxbOgVCnZ7BDNflb643PTCKd1kKS8+g48hvIO0pEqYSrkQ1n6Gcu142r2mOyd8co62pqUcaMsJiGHOhXcCTbLFAyP8YI/MBsyY07cn7qiGphqJ7X6H0lF5o+4j7kPPE8bJfzaV3rkuCnXtJTv1eElQ9yRIT0zloA+ekxoERGzn/k6zaX46pStAKaTk+rThcilFxb2LBiN9zvbFYmB50+pPFAeYIZfvSS+wCqdeaIbZ6OKdKNLlgYkSAC4pjBM+cdxcPgV78sQXeZQjn2PfG9p1iSeZzz4ukSngvcA7kfcL37D9Lm7WLy7nAxdhyr+f65D371x7WqdPTxqAPSZFLD2+hsGnc5JsVkD7gtNNOGwwtBEVQiF0WGOAQAYwFHmSHEazYY/DxoOchVZj2oiZBNRwrH1aqHLZIdcqsA6jHb5X8WXM0MagwnFvBFwkrD3KMC/7modirA9qi9UjSfoxKCALHy8Ug9qkaqXlwq8DaoBqgehUUOVHAiP5NA8fcVclWlpZo69KlAjDnaF3engqt+Y96DlyFTrKpF5KNfpVoZMgi35estvVt54Fzos8tcZSeHseJY+jloh1ZEkZSS7sMy+yVyNBbpUH0qle9argvJBjjJz/5yTdqY9Yf7JHTtr/0MPrKOUGkGIc0xjW+FJLKxxp/W4NVr2JGMmhMO27ME0MH2TDkGR+9hZkTnLVX9SAZBorB7kKKwmMtDKdk05MqAfT8HLdWrdeQaDyKaCxAVll4sDzPWEkliQhjaWpAesXtu9aI5neKNVmn2T7kmOZIsl9rakomVOw14sCFAGvRCvaXCzq5qObCWYr3sD+vIfO8OVYbyst+mANj5b/SEGd/5uibquECRy4yOm4sQnAPEvyW6+l7v/d7dxZUgPcXPb9e9ymSxbHbUGaJvItdeFHNFVZDwLnTy+10fPTSZo6rXt0MIVV5N5XlPX56ahVCU5HdxZGs9c3frcec3yqkpadO4uw8z9cs5eVvphY6Jbd6rrn+chGR84dsG2UzRjjXoXqeIke5LaLubx/7HGsXsRwHrwUXCjyGi2KtorFCaFlDnP7UbjF0uF2M8xqxvm6R1MJ+oTyux3Df+953IK5s5Ofc5z73WbgTP/zhDw+klRvdMr8rHA5wwycMVoLqinE+RKzvmFDYR4PXkDDzlCRRqz5AzavC4DIMsjVmVQ6FqGgMTNUQzfIGrnRreCrEgtFiLpdGMA89vD93v/vdb1R7cNFzUcxEL6pGkyFw/N/8Nr2r5lMp3qKoFedN2y2rI3HRq8Y5GeqIF6E14q1lpwqyBdlbsSsVVO1TxpP+hthpPKaRaN7oMjDE1zIpEtYk5ZZ4oK30l2GvlpMY8662pTk4jylvu8ahoc09EaQxz4P1PN0svyC54xprc/0UjUohLQkmbaZfMKrT65C5ol5jEBaMWRYg8dQxRl4/zAHJQEvkDTfnHPAo4X1gUc8SUYoPZemkLC+TBqy5v3rGJRoZZsv4oKfAwg96DMwj+o42uljUM37Zt+NAO6666qobeFJSbbidf3rWaIvhsnpJMxzVkj4SLRfdJGoSVfvDucvvHfPWoFeFW8+6nlDJKvukTzhOW0PSBQu21jPrXDVvNdXKJc8SU37rfNE7bUmeLIHkggP96P3ERaHMNc3xTtEexYxUODcix03C0yMMHtfcU8mJ84++yedResckvbkAye+97sfCZs0t1vNs37hYyLlnXxo67AKTNYj5vgsZWY/bLRf1FvGCOo70I9cii1CCRSiumU2QrhQ3sq/bCKok/rll/ecM2Z3yYppSkGRYgmpOv55zRa5cQPL/RlLpobf/E6n/sA7diUJht6hZeAwPe9jDZq95zWuG90972tNm73vf+25QVHwM3JD5fu6ncLTAgwVyI5HpiV24aixBNZRW8peevt3A1W4MPcPreICbg+QquTmLhoWBHiGRhGQ703i3zIW5QxwP4zlLy2AYEsmAgbkMKfOByvmoPJxkXIVXDFP7W7GQDF3CCNDDaX1FFwQUmTK3ln1DkNLTY9hv1gI0xI8+bA0LSbUExAd/nruEKz0ay4J7D8TM/D7r9Wqk65nQy8X3OR4ETSOfPkkxrCwH4zZFVA3Z0xi1LzhfIjRy0cF6nVlGSOM/PQcJ5itjLfHP0ElIEsc1RFPlUxcwFDMz7FYiSL/zW+Y+RJUoGUg25++1w/U8Fqro9+hvwjNZtGTOpIHvdaP3U09J69VMT4rkUqOSviXXlJxYySrtTjJ35ZVX3mC/uQFJAG3hd1yrCnMBQ14Nkzaf11rO9BH/M0xXT7D1VPmb9jLWmQuP59MyMxxfksI+zIvPMlK96BDnteHPRoJIOFWaTSiu5YJWb/yYM0axeB2xuJH5nW2osgrukpP0ftln6SlknJhXfk+hu7wH8N56wxKHXORs6+4aFpqiQi56ujDgeZmmIfl0PkgUM6/U+7rPgZw/PShqpnKuQmf0gQJdjitt4t5Pm5jTeqrNe85IFzfLsxnpsixoO1EZOf60TS/rbmHd7vSguijWEtI2TNvFOMN8hWQ8/+6du6J2elyNCuJ6S3Vz03xS/TqPp+I/Wy/VxZQLx7NQ2CZUqPAxcCPAiFEV+Kyzzpr96q/+6mQtQgyW8847b/aRj3xkuClQPJ7PDmtyeoUKj88d6vfyAFPwIQmqng6MiVbkZx3IEDoNJI0xSZ3GKQ9ujOGsU9fzpmrwjpXosFyExgH71yBND6Lhe4sQcgmOIcCpyMvD1fwtw/f0Bti3hoZZh9HyI56LRqVebf6vtyoJWoZ66xWToE3lE7uSbmhWC3NWNSxXBW01/FTCCmGjTyRMGri2RZKsR0LDn/mQuVBZQ7IHV/PNR2TfF1xwwRCpIgGlvyA8j3jEI3YWc5bNSKGNlh3SY+B1pIc1Q8RVfeb7fJ7eO70NzHtqj2LAUraDNnrt9PIlgQrLigDR78xz/2e4eYZp6vXIRQ89vf4uQzoN3+Q6UUSJNhICzHXKueqZ5Ngam+5XkkCfuciUtXYVzGGOJAFSpIZjpGooY8vfzAUIqrVqVVemb5NgA/623easm3vuNs9bn8JP/L4VmOPaY862JblUlXaceseQELFP+s32eA3lJtE0LzLJtdeTEQz0NaHC9FOOKX36/d///Tu/c3HFVAYXh6yHqtc1BYja6yFVci2vlAtTSaqc+224pznHtj33kaG5me7gswy48GREA3+rLuxc4Hfmhud9zoVCFw4l1hnRkFBEbxkSq55C7k8F9mXtMkW88t7oPaklpe14ZS5zwj6egt8xlSQFwExhadV8garSY7XjmROS1V4NcSMEemXyWrRpHL5nDpCyUChsEkVcA+9///tnD3nIQ25gCJx77rmzc845Z1j15mLmxsVq/O/8zu/MLrzwwhso2v3n//yfZw9+8INnhxVFXMdBeLn17PIBnXmp68iZSY+EZFViYA4g4VHW2zNPSjGizGWc501toTKtoj8+oPkbssB+9CCyEXKZ+WvzvKq9+o16jHnYKsqid9XrzvPh3CAjmQsFPH/z+jheEuMM3dRbnqS3Je/2G696u8bIHt+TNO525Zo+gjjpFbKsA3/rOaE/XTyxRInhxxxfL5UGY84fw9NczTd0VCPZ3D89DBKaX//1X98hc4JxmBd9Yr5rLpZwHMlRhtbSHtqSCxiOnwsezH1Dtw3JxvPFvRtCxXvGwvxow08THJd8XRd9OC/DLz2Woct6UjPf0nmRqrQgw0iB6sIsdmJUs8BjSK3zjXOUqLaqt4I+8XrLGrHAOqXmX/K3pCxVl4FzhrG1ZJTkh773XDMf2z6mbyHdCjNp4M+rLe0+9Pq24mFt7n17/TD/jDLoeW5TqdcFqgzvzVxovcEuYEg6Mv/TUFrv5bYb4kqfSSbMcSX9SHKqcZ+ktC0T40JTKxJmbqJkKEWyjCiRTBnyq0fP72TosIuphlsnGfbvFChjnxBzogssy6aYmXPW+08Kybm44b2X7/XIp9evJXrGSKyhrkbUJGiPue+Cc2ButsJyRg1kmLdzNhWrF1lwc0HChUL3r2K+89lIjVwgcLOfXHDyvuf9dQwuwtrHPWHQLO/VplnYLsvmpW3guLTE1PdjzzvOmXSgQmGTKOLa4PWvf/3sx37sx3aM4ymy4U2NG8YrX/nK2eMf//jZYUYR13FArriZu5q8bq97hshmPVc3V1L5np5djR+MPh5Kkpkpb2qLnndV6KmSsEpEmCdjeaxTXtW2jIjkROEjSWvWpjMsEaJkDqdeI8NXNVo1/u27LFqvByXFKtowbz7394oD9WB+l+I0uwHHM0fZPCaMSJWTFdvQ054k3XxGV+gl/lMGmWG49oELIhouvbCyt73tbaPE1ZDqNndN9Vi9V+yXBUGM46yd65ilimtvLgFDDC3jABnEs8pn/N5rx3Ez5BWiSgiteeqG3GVIZYaGWs9VuFBlbq1ed8sN0X7aAEElfJSNPrAvJQ6ej16tMeNQYRvzAiUj6R0zLNj+M1Tb0PAUYzH8tb2+DY9XsCpz7+lfPfiOU098qtduCQy/4Rpvz9NwXu9beY9SdIxzcQFHT61zZpFakkmWXYjRW24bJL1J8rwmsvzNb/3Wbw1zSCEd9sM5nnnmmcO+nAs+EySUkjtTSCSNKY6X30+SnZEC3sNynrpQ5RxxTkuapryXnl/WFM7SYKl+7nuJV9a97S2C6sm1P3rvs454Ro6k6BJzz3JtzFvuG3n+zB/uQZJAN+dI1nJepG60BDUjFnLxJRWNx7aex9zayS6mTqVm6NlOhefe89sIhKxF3cJFTevy9ryniwhIte1jnpHWsK5F+kKhhyKuHVx66aWzZz7zmbMPfvCDs3l44AMfOHvxi1+885A6zCjiurfQ2GbTqE6yBVzNl3BoLJgfB6lbpWROz7sqzFPS6AI8qPBosbVGkUTPB3PPSGjzWRUHUZCHNmQulyIb5iwpksOrHiKJcavwrPHRhswJPpeoGlpozuSYYiftkDT1+jmFWFJ8Y+wzxh7DAwIvYWUsVO+0vfxP4xEjxPqchlBLnsZgOGCq1k6VZfJ809B8+9vfPrRNEmq42L/6V/9qNCzOmpGMLZ4SwvskQM6BNlzUcGHOzbFQTEsyxCteTNV1nXeWd4BguNGXluNg3ymO1FNntV8SekzsK729tgnyxTzlvWQgPSW8z1IvY3m11sGUzElS2/6lXzk35qvnzDyyXnLmj2qwp5GpR92+VcCL41luyDDP3iJGwusoyarht71QRY4BGVHNWm8Y3+U+wKa3L4XwMrS4Z8ybW5ih2lnLNGtouhkSj3FvaRcJLu/NEeTe/F/+y3/Zma+Z4/2gBz3oBnmpKb5nXr0ROvPguFlP0wW6JEW8mtNoSZP09qayvV4zvWr5bDHNhGva+e488Z7JMbgHW5KN8W1LVq0zskgF6ywnZpqE5be8JmgX7czyRG1IfXqlve/pXZb4p4fUqJA2j7S3QC1BTXKaSshJVNmmriNVpr1fTC040FcuYLeLqp6TXncgQV02jcPawva57/m8CGthL1DEdY5a8G//9m/PPvShD+0oU3LzwAC43/3uN3voQx865MIeFRRx3Tx4mGAw4AnCyynhasPK2HgY++BVeAYD1/DDZYUt9K5aMqSF4XFZCw9A2JgbehczHFcDuYXhueYJ6sXi/C31wGcKfhjyarhnGoG0xdBNyzCkumMqGychlXwZLu0G2I+ha5KYDKflPftxUQBMEdJFjYMkG3oJJLC814vKeTne1gnl/xpZvbBkwxglahpeeghTsTPFrdLDbd9lKY8XvOAFs+uuu+4GxyIM9vzzz985J/OS05uKJ4ewdnNSDXd0EcJSIBpFQHJneKKA1OFd5bcacOxfkor3UW+cIlKGWY6VEBHm4pk/rdFrP5oTphEnwdYDBVRTZb7oAVWcymsrQ0StI4wRnorfU23knuE8UaDI0jSKRBlK3RqZhphKHvmNKrEulDDPxtqhUZx1NfVOclzvKek1TO+kOZKGWJtDmZEZki5JSOadZ5imZCVzozNawnxovUqSWom60Rt6oV04sz6q5FWihn3ANZrXGQsnj370o3cIahvF0es/oyfy+nSBRzGjlhjonTZ3fpF54rVoBIILY/yN55LrJaMbVJ5nIdRSKHrsvRfm/RG4GOC1lsJV3odSmG1q0wMsafc+Ylix1zD7pw+8X/Sef7YL2PZULOZ31h3O8O3cfOa6iJMlzbxntV52hQSt1zoGFyEzYmgKvQgE+9VoJT3v89J2Et6Lkpj6WmVwCvuNUhWeAHXY2AqFTYGHJ0adZTssadJCwSFgOQNFflyVxVhapdTMlHdVwwjw0E2ywHExZjg2baL9GZKbMIdMsq3hKmmRMHsMDCUIuASGvzk/ztnVdH6DmJreKnPT7FeOkavekg4/s36iRAKvn8ZpGmUiQyb1IHnc3YJjKTakN4H+xMtkXUX6hf7j2BB4vZF65AxN1mhyP4Zw9wjLGFqjzHDURaBxTH+mUqreHMgqm6QI0EbmLgTUhQQNQUNo+X3mq3E+kAw2jLcPfOADA0HF8GbxQ4O3DTdcJARO41TDmnP3FWJHJIPhwRnym0RKsmoUAH3Bde7/DN+XrPDehYhFyyJxblw3nLcRCtatdN7zGW2XEPc8Q46tpV7Yh3Ubue5aYzXLP7Xk0f189rOf3YkYaMWPJBmqQrtQZnkdzikVdnPxSaKWuaYSI0PT9byaI89c9P6jh47NsHLL6bgAZnisUQC8lxQ6NrbJvtCw528WDilX5FySjGbOar4aGuzCFWOgmJZzPee9pb5ctBqD5+DWkiYJoSWc6BvuLS7AQFQRCeNYLgok2e/Nx7bMS09dNz2a3peNGvJc28VCFx30GJuvbU6xnnGJm/oEzu0slZORFmPhtoaDe+/V0+i1mv3ePgdonwQ7F54zBF2vuUr4Puu8z/MsaBcT+R3np1CbEQitR9l9ZpmnFuyvTTEYi+QoFLYJNTsLhT0EDxdVYSUmY6FCGa6myqchuT6MVCO1tMOi0BNi3dXesTHoeGjTzgyR5CGKQcNDjocrBmqPDBiCJjQmOWf2qRiK54WhQYgp56JoBAYgZEaDjmNBUhSuSA+oYkLmpOl1lLRodIC2TuIY+bS2q16TRUOhMh9Lw6MtcK/hY3iX+YcYkfQP50M/mztnOR+NCw143uuN0quoqNK8QvGG/yVBXTRHW69J5ghaxoN588lPfnKnj/m/YlJ6jvXgcg6MsyRCY0vjPUVFzDtlH3z+3/7bfxtIWwpt6fXJMfC3U2OlYZjqrObK0eeSSr115jjSx6pWSz75TCPT+orsp+1Xz1/DexlwPRBmrUeZa9n8PtqjJ80FgMxfNvTXsOH0sPF/IihSWdRohZ531OvYaBHmrjnXCcV8JOyAsVIV23quesFUULV8jR4ovcOWDzIMU6LE+Vx77bU7Yl0SDSMUMlqDzySnbRkoCbORDHkvseYx1ydzmv5XzIj/8z+qFCwSOsv5KDjmolkLj+lc6V3Tiobl1oskMNddrzznTbu590haENYjV5F+B22uqGV8JGwSND3ibTmfHsYWkBQ8a0meKSDOB3NdzXM1tDlF5vS6u+AoMe55i/UQO2Z6vU29mELmz07lpzu3U/jPsfS39oH3DhcKDJnmO70ILCMecjGIfslwZe/xbmO5xr12J5kf+xusWt6tUFgURVyXADcPSt9AOrjBc3O/5z3vucwuCocUhsGlAIZiLXoUmTdTCqGABwvGEOSUh7PqsRgFWVqA93ogV/GuYtT1DAcNMua36sQCo8AwLM4lw/4M11KNVKETPVUKCpmrpHHj6rAhVnqGJKuUl7rkkkt2jPAezLsypy7VMQ1XFKke2QvZ0juigqWEpEdE87PcNLRaZDs4TwxevRwYf5KQrPlHH3EezAkNdw0ra84a7qxRQhsckyR9EgGNFlfYE4Zktu2VyGXOnOTNcN/0ttAHEFeNW9WO6Ve9Tngu8aqj/EnbGV/DpA0VV7XauqF6XPS0ZaigwjFZT7aFZBPkd9gH7eG6y1BiS3/odeHv1uOlYrfeYEM7gZ494W8lcMvkndt+5gzlhxCzykUlDVe9PXo0DVOlzwwjbnN1HRvOqa3nqpee8eHYzNEkJalQ3d7XvL6NDvHab1Vk9TxlySbnuiJyfO6ijca8uaYtAXeRx7HMdnBfddGF85HAWd82S5nYDmvJmmfsIoWLLewrF7UkCfP0C+iDsbz/JGZtfmOqe+vZ6wndJbwO9Xpbe9XcTs6H+U/IPedM30DIFyGhErGE/ZjqvYb+Zj5xlofyOs58YRc36Ke8vxhdxLm7gMvvOA590i4IuyCh+jybZdHY5i3WZXs5Rool6lV1cTRJsfnX3nf1rGfpIu+7bv7e8kmGpydhdI6YsqIgVorDGRHCMbxHO38yoqgln3mf9DjtQkJv4/zRfSkUNokirguAm8ZP/uRPzl7+8pff6IGPQfkv/sW/mP3Df/gPK/b/CAMhLxVb9X4ZYqaxll4dHyrmcGIQMZdcTccgveKKK25gjBj66sq4IZc9oyc/470KnklkUhlTryLfQ5xMYuuKOt9VVTMf4ClYo6qgwirmIfGA95w1UjRCDTHUWOF8P/GJTwz9NqbaKyHWUM9SDhrn5qKxX70D5ra1+UqGTGnop+dLQ2ldMGdVIzlDZ7OwvLmJzgfLdKQ6peRT40TyAPQyaZSlOIjzsedplzBnTmEvLNC5o7dI41vvhbmcLmAoREOb8a4Sfsh810sHGUqhJhY5MJot5WJoXuYPOxckFhIHCbRem1Rn1TiFxNAONgxeFoFoB546+5q2uYjC/i0boRqnuX56+TD0e7CusSHAy+SIGWJvuR/IKv1jiCCQZBrKDPEwBN7FhhSq0Wi2D5lnnJeLGIZy5iJGi1RpzgUlQ0Ddp94XjXRz/fQa+X/npJEXhvuqkOx9RtKtWFAqPxsemW1xMUJhKu4L5GMzv+hPzy8X0oxWYJzNeTU82GMokAUWLXXmokF7H04YMs98yXBxr2+9cuoDjM2ZjDrQI6qegCW0csGAczT8vectn4fM0W23zCXPedCWJsrN5w79xLNQsmoEDNdrLrq1wmku0vmcshyQIoX0EYth7N+FJD9PEpfRPIaRs9n/WdrI77qQ6GIq0BttRQDP3XsV8N7pYrfkOwmmXuEMLfa+3oZV7xbpNZ4nxCYWTScpFHaDI0lcqTPFA4Qb4UUXXTSs+o+B76EOeOWVV3YJAje/Zz/72UMN2De84Q1FXo8guMHjXTK8LHNwWmhkWzJF4obhZCkQBYEyhIcHlKG7kkGgEZw5V7kqnIqMSTglwa7U8kCFPGnUGKakh4jjSwAVfQDmlAGFRCSNCgEp+W/IpATRhzxQiCWFb1Tc1BDmNxiiepEM+8oQT9EKq4DWA6JoRasqvAkooqFXCpKEAZ1CKBo/qtJmCRmNoCSgjvsqAhqpkpolUSSpbhpTSaidPxqmznONqgzzy7q6vL/zne88fE5fcE9lzl1zzTVDrrIefo3BjFzQoNVA9hxtj97z9IIbFs4+IC5JVC2zYi4ZkTTml7togCdYFV8NRYkn17fh3D04hnoal4Felpy/XJeEyaumLGGTUCte5vl43nqGUgTHhQWMf8ZkmdBwSZBeaA1+56SeJQ3wvCewaVx7f+E8rCnLAgF964IJCwFZli7VS/mtnvcsM6KIFGPswgj9dvHFFw/Paq8/cyG9x7mASH+kVzXDm61Pugz0dBkt0APHdiFEESnzlSWq9tWYgJEk1Fx2w4a9Lgw1zfJGknDOdyy802u63VxAc3NRyQgLFcO9p6SnMElhPi/ze0YrsVnOyjB4xliPfdtG+yBTSADt4V7r4mXeW/ydJWJMzckSSxL/HnxGuR/6l/b1NCPG+thavLbPiJQU7DLCY5GUldajPSakNeZ5BTlOea5pc7R/b/o5WigcSeJKThSeLC4yCOkUaQVPfvKTh++35ED42W/8xm/MfvZnf3b23Oc+d6PtL2wffAgoQpI5Wj7MssSKxr0PesWBJJj5wJAYqtSb4TyJ9Cplfbo2rEfiqAcMYMxhhLf5VRpS1jr0vKwRqhfHUCe9XIZOSoYUD7JUCyvJErQMlcxz0JjFgOQBnivL+d0cA42lLDGgZ1JY51QDaKwfF/l8ke9y/hjg5u9Bzq666qod0aXMndObxznTf/S/CpdAcRAJrPlobRmdNEzSw5G1a7MMQnsezhWhMZjEIct4sGjj8SWXGFinnXbazoID58Uco+YrXlX6Qc+hizwZiaCHNaMCXKDwHDU+NZyFObNukJFsv7V9Ic94WM2R1fNOeyGtlmbRm0s723q1OeaWJDIcelEYIdDOXRc4aKNhfpI+cx71tBpi7pwwWsLxNLrB+rZjRMWxdowNe7RtLqZkjqP3DD2EEhHGVrKUi11GW1i2RM8w80G44KUYm/c/Ns+Hc3FMLdHC97kPkGLw3ve+d4f8Aj23klXuBTz/jXaxT1wMcNFh0bx2YYj+1VdfPZo7byiz+fz0k9eDixU9guq80KNoSDJzWjXtrAUqcWasjFLx/sF5G5qdIbpeV15veS/x+dMrsTNWD9U84QwZ9ns537yO2Rce8Vz4pb0sRlh2x+s4RegyHNn+y/5mY44YYt6GVzNXuJcZ9u0zW6Eq86rNnU01Yo8/Bklehp+br+292OgA+10PP5+r6O09Mklj7nfV/y2C9OjmQmZ+tuy1UiisgiNHXPGMih/90R+d/C7e2Le85S07FyMPR4jpD/zADww3s49//OOzCy64YAht5KL+mZ/5mdkznvGMG4QrFQ4/FLZgfuRDWEEfPRoZ5ijJwGDhgclv2If/04A25G9RY4lNEZY2J1bPl/lNKgkbgmp+pOqo5nEp+KBBrLcDGBbsKrbiUyof2wZIG21kPxiJredCQ9b83kVCKjWorbGqByqJqg9/jcRlcwpXhR5FvOi8h6hB2GinoYgaEBjgGNCct/nF9r2GneqXkjYNr4SGeZsv1c4f5+g8lUmJiwsGkso02Azt1PvpXOf8IBmQLvqAEFdD3/TIGz7vXMgcKj2fSUzzuHkuGLSSVL2krQeafTBXIKl4eBXUMcxV4nnSSScN+3BRg/7MUicJvXEuBC3qjctr1RI1Qi8UJB/yxf2BzxQPAoY2Sh4y6sEcYNWP7QPaaJmbJKXtlnmFKY6V5aVcjNLTm4JnlvEyFDbHVC+4eZWZQiFZdGHG/zN/2ZfpDFkaiO9wXbMxRpdddtkwzyT5bN6rrPVKexGeSq+q+9azOm/RwfBO7+HmzHs+LuARRZAE1IVDFxfNt8+SL+n58ljA69HxNMdVFXdDf70+XMhjP/abv+U+Y8RBCwmIJMxnRZs+sChBlTx6D/N50rtWOK41fp3TfJ/ru1cfPDFGxtIjnarWkluuP8i+gn9Jzlx09L7oHFGhvlWIToVw71c+jzJtI0PGeyJOhqnntbUN0LNcKOw3jtwsJCTMi/ARj3jE5Hdf9rKXDa+Gxb3rXe8a6rcKPArsA88tnlxudG9605tmT3nKUzZ8FoVtgrlUhhu5tTf5zOW0/Iuy/RqehgS3Qhdtzqqvemp5lSRrADFnJWzmDak6q0fG1WRDRM2rdBWfz3mo4w3gNz6AzaPRw2bdOAlrrg5rOFt701xYPR3LiEypLClZ7YVvsf8Uz9nkw1YSSXsgQ5BTDFaMIYWwMObpd0mgnlbOHRVlRN5UWpVopVHZrua3eahu85QvHQ/FQtxS4TLJYY+kAnMFFbRx7J1fbHguIOt65Q1LNrwzvafO1fT0ZZ3Z9jojhxOiD8mk77Lea2uM68kjXFQF1Qy153jMS/ZFaSc9Pr38X5DqwouqTGd+nIJEbXkY3/N/CLW5o3rIOTfuC9bqdEFGj6VKzZyDXnoF3NgUbpnXXsm95XWyZJHHZH9Z4oc536tPmWrYttWFsVQ2tV22W3IkOYAw5BzQC8v1Rq11ju+x89rg+HyP9kJWIT96VVMl2T5kHFwAy+gFX3MO20b6i4gsFhoy7JLfsLCdiuKmb8yD+ZgK/ZgekKVjMmffe7Yhp5JhySrgf/yt2nULr9PMa897Suu5S6+mudOZ4sH91+u49TZ67Zvzbskr7pWMU+ahc52bQzzlQVwUkn2eaWx6rplTfK54IuduikrWkW5z5zNSxE2BQc7Lez6fMUdc0GmJu6WnjPDYL7SRO8tshjhbBqpQ2BSOHHFFjRGQa8VNYgxciIS1eVM877zzbkBaBTeZX/qlX5rd//73H/4mPKmI69HCz/3cz80uvPDCnYcYG0bSD//wD9+gXh8PKxU4gSFuEkxLgrQlVNoHs0rDbCpPJiSePIQssaAhgFGFUar3S48Hq9o8ODXQMK71rOgNoZ0WrteYNXdKQ9Mt1X7NVzKPTANcMQwMUI0IyVK+B3o1xhSZ6S9VUZfJRes9qNuHdhqwErMkboypoZ56eFzFT8Pd8MBTTz11KDVhmZUxZJ6gm57InCMat+28SZGQzJPtEbxFQN/rCSQ0FULOK1EsWfsWMLaE+9kftjnns6Sxl7trHp4Elfu1pZLmjS3jxLFV3XWuMm6MCf1qKSHGA2IjYW0hWZOsTomPSCAlvswBF1hSjKX3O/oWgq3HyT6jH7kvqJALieNaVXXbHNG87swnNgx1Xl/RRsaRrbcYJBExn9k6p4oFuZ8MATU0mes9x9goAgmLBM1rJpWJ08PmIgFz7vLLLx/uYXrGXDDTs0pbuf+yeW/ku+bde82Ze9oio0p8ZXz8PD2rzivHVgKX10J6MBN6YHOx0xSGjLRwXL0vc59xkav1LnIsFsT8nN8ayeK115JTFyBpj/cK576LD7kYoFBfpg2M3VOSoGaag21nX8wlxtVINT43xH83oadG/6iir1e1F9JM33Af4D6jCrfRPD5zWi0F3lumqXcfN7TddIh27F2M4lpmP3rSafcqi63Ov7Hn2CLbItFdU5i3eFoorANHjrgStsYN54wzzpj83sc+9rGdhzLf//t//++Pfve+973vYGBhKPFQLRw9mIeqwYChyeox4HMeXjyc04DBEMjVcsKSLDqeni7f6y3iQdoSFPMCMXSSHAPFLPBM8PA2LFIhkiyhQZskVJIh2mTdWb0KGFF8rqdHw9J9a7CaJ8hnbZjuVF6QRoc1VjMf0/M2XzcFcBSjmnqo5wN97EGdYbeGR+pVytI8vJew0n/0iXl4WY6EPqCuI4aRYdc5vul1yzA7yafe6jEo+pUb47eMgm0Lzh3vMSHP5Otx72SRwVA7jVmJWeZmS3CAc9PcLvNeJTGOJd5C+gfFYUgqc3OZ/CvmJ55VPL1pKDLOGK/AaIbMKdaAFrTHsFGvTWCUQdZXzPIu1licEnJJDxbHtEyWuZgSCPrH8GfaiWeZEGba0ta2dX/cc7h222iNsRIq1n5tVWS9VvSAa8Qb3ur79tox71RBK+8hSVIlPOm1576kynEKTwHay5yDVEMiJGeGSZvHzzhCVCEf3guc+6ZstGSgJagKSUnkJG2p3iz5S49fqsVLOhkz5nErZGSYtwtsqYbdg6HqLrg4J4ULKUYy9Mou0X4V7nthvvZTL8XA8F7TR8aE3zz3HPMkqD3QHmym9NQzdszzRb2OLlxkzq2LhsyvqRJBWU9Vz2qmGKTQHddpK7AlyXQO6WG1ZnWWn0n4zDcdhjYzvzNn1PZleka7mN2SzrF7zqaR7dqrVJzC0caRI64+8Ke8reBDH/rQzntu2D1va4J6rtyEISeFowcecCmjD/gbY5aHaKswzJzCwMsHdJb5EObBGl6Y8KGcHkofIuZ3SXZ9sCo2YsiepIOHqYRVQxwCkDUGOQYPZIuaQ8w1bDGS+D0Gtrl0fKf1WPbea7TqqTIHsqduC/TS6AGmnfOQhDdFSPSOGCongbRdGiWpbmpotF5ry1PwW8gq5EsjD+/Yfe5zn8HDap3aFEuS+LZGx1geqvmAbbjlbsOhDaklJxWPKhtE1TBACal9YYivfZHCMUDCnR5hRbEYN+Y+nlS2O93pTsO8WcXowUhFnTnDRdvz4hwgNobYGkKbx8tw1iznhPHZetiAuY2GR4+VTHKua9SlkI4hubQ7yxzZL8wdyDxGLveQ9B63+fVs7XxxjmYJlQyV9l7jIgR9laG8jKGLYIaftkSF8/H4kLE2f9bQSY6lcjnnYih9XtepNqywk17SFIJzsYxjSlZdXNCLb21ovYY5b70Gvc7zPpTpDUattIsNbBktwDWTtX8B90JCJpMYuWAyDxxP8tVTIrZkDqCfDOfO8Gja1i7iGars9/yNol5u1vLt3VOSoOZ9aJkoDvrPut65IMk4Mp7tfjJXOUlqkmznuSKCPaTeAc8o7tVJUqfuodbSVqlfT6wLEtzDVf3O46iSbRi1Oa4Kaa1KOl0ETK+879NLv8h+MjWkt7XpI+1WgkyFvcaRI64+hOaFRHz0ox8dXrkozzzzzLkPHB6iYKw+W+FwI1fBXRk35xUDyAeUyp48MHseQN/rwcnQWMN4M//GB5ReUFfVFctxhd06gOZE8eA2FJGHKEaxhqEhqhoMGuh8n/PhAW4ZHYxrjGzLargSnARwLGzJNlt/NMmq/aiCpuqOqhkvG9bkuehByTZm3lYqJGdOqKTCvlE8KUv86NnhFSIGWVVdGRI4VZt2zEBsvajrEOugn/GkYnCz2Abpw4jUk2wbJRIaiYZBtrll+ZnGO/3A3DB/DG+zJJXolEVzmnvg2qDdGIp6dVvQT9ZhddwAxqQLNllGxfq6Y0hBLIWlEhJToy5c0HGxyBrFeDhpOx4WriuF1LhfsOBBP2HAu7CKt5G50y5oMfe4Dvme13qS1GyjeeESwfQu6uFVeIb3fKbAkkQgQ/gt1aHaqQaz96d2AYFjGTKZi29ek/zPxTJ/7z3Le5L59xB5vNBcV6ZfGPbtQknmDTun/cyFDPvTUjiOm4sxkmUjJyRnKVom9LTZR7SLMaTs3qLQA501nhOSIfqAeUjKkx5Fz0U1d0X0jKBxvCX8noPErbdglPefVsl8N0SF/mf+p9oy+8bL6rMoiWkuGgqJn8+lXniqpM7ay6rT99qfat1T+Zvts4t+ZbGPxaee3cc40MeQcWtB946bz6V2G3vGee24KOZ9Nxdmc4HB8UtVab9bKBw0HDni6ur1PM8oog/i3ve+99z9auzV6tPRhWUCeJjqgdXA4QGWYWw9aDzj1dSraG4nRgpzC2OVB48PWguV8xCzhAS/xeBVsZT96uVik3zpxdVw5/vsy99oRJqLa9v5TEKCAUF4vKFMPjSn3mt4tJ6qzB9UxZGtzR/KB/TYOGT7zYEzn9dQRVfxrZ+XCp6W/GmNcvrMkhUaTZZucTEBA5N9ojaehkSGVOWmh0Tiu5s81LYfmEuo6GIssmFo8ZnnmvlrEnf7xbFJj37C1X1Fdxxnxgvi/tSnPnV2r3vda0f0aDegryHYiiy1Bp051LTFGquSFcZIpU7PSZEj+6ndX9a51ZsuKdFrrOCOBMd8vna+sg9DmCGEipio7grBJ3WFCAb2zff5bo/AMEe4B3AMv9d6mlz8MRfVKIkMcafNLgYpFsczMc/V+e/3rPmZyr5jMFS8FW0yT1yyqihc1inV+0lf0kfMHzaIh/MoFa+NLGFetJ643kKRhCBDxHnVg9rmbv7/7J0F+DVVub6H7pCQ+OgGKSlBJEQQpEEpkTqUCvxBPUc5KgIWoYKKiqIiKSKoiIiCICAICqiUdEmHhCAl8f2vezzP9v2tb/beM7vjua9rrl2zJ9as2Xs9663YR1iilY71aY8oxLRduTE3SiTE8XJ9FHahfen4+Z4mrORSLjd4xc4qgRXfY5JDv/cSmjGrcLr/bgnUFOUy4PcnxuurRjhCvF58ZJw0kpdLjBONkyqaBNLEanSpVVx0Oy62SuAVs4Er6ZXuQ45Hv+Og/zrFM+uc5Y2iMJCiJVYiiCXHJKbLTN4qOZxi/CEm0krLX8Us9sYMImMnXMlIyR+FLKpF8APHD6lu3Le//e1Nt6sYKpfCGT/481D2z/RPkD80Bl+NBCt/gvQfCUn9QSsDMH2KmD/FuWowrVIg/PGxHn+oDO5jTUdZKXnOHy19WwKKPz/2qQFfdMuVdTjGu3IOvOaPV6IxCqBG7SMLj8RedFHSoIPBBu2FwEiFo85Dg1UJqThZEOuUKglLFBFaT2IflHgn1t1V+6jeJwMuhBADR9WKVeZIuX8qAUos4xNrL4LEgNzwFD8ml0wWJVQpSlJV7znfZ5DMcUYrKoPE1CKpGf4Yq6vjjNZuuYxG90i9p1l7lRehn3B9VXKJ/oHlcPvtt8/agfagvyL6EFXR1VNiRQNv7hE+p+/HvshnWDLlEVA02aEkOYqXi0nL6I+KtY1eDRo8ygW6yIqjUle4FdJn6H9yF6WdEKpY5RS7yvpkY47usRIn6itsK7pwS+zJu0I1mfk9SetlRndluQJrkkIxrZoY072m2rQS65H0HuY191UUq/IKUTyrrEvqi2pTWdXkeszvmhK4aYKORwnXoqRlUVyq/SRQYxiH2jJ1s1SfU/vH+zX+lirRk9x4Fc8YoQ2ZuCqC73M+sWZrzDDN53HSjvbhmqqkmKzJyhTMtYmCWnHZEsqayNMkmSZFFW9cVN9Tv9FxKUsU3vQtlcWif8fyOFxj9Y0ozNS++g9UrH8UdDEuV2EpKvWkhGNFibdaQWXXYjIyiJOSXAO5H9NW+p+gP9WbxOW3U7XSWxWJcvOPLuDxeT1RHq9RERK29cStha3pJ2MnXNdaa628dA1/BL/4xS+yrbbaaop1fvjDH9b+8Plx2nDDDZtulwQm3OwIYzNe8OcQEwgBgwJcReslmeAPhwEPA1vN4PJHJ3dZJcPgT44/YERIKkb5Y2dAr6RAGixq4KEafvxJKpOqMpgqforPGPyABn8cc3SP43uawS6K+SoazCp7pQSZXO4U9yPYprYfB8ZFbocxIZAsK3J1LMqoGxN3yKVXrpsMMuQuBcrYquNAAFEXEpdarpMGUqAZfQbYCCKJtzhYljCNArVM3JEGmUUTARKdStiCqFPSLF7LAqD2lRCN2W6VlTiNH9b3YqIZHbfaTKVVlLEVKxjnfvLJJ+ftFeOGqw50JRbp65wTcasIcVkAozufEoDR/nLDlzgEJQvDpVRx2HHR4Ev9g33wXVlOJVTkWsq9xbpygaYPF1mQ5farkjYa7PI6Zm1lwM5EFCKR/ePdo/hVXSedt66BJmnSsAFl2o4W1XgNlQ1V25EVSn1F76lNtK4SCOkekUCO9zfravJLIkyWRnknSKzouNPEVmozJezS/rj2tLss27I0FblPxjjJaNeNcIkAAQAASURBVEGN1zLN7h6JfT0m6OlkGS2VOuK8lJU9TixoAkZxkHwe41w1oaXfMPp1TBymfUjU6npqm7EOtCzhVUnFLdvSpIO8WuJ5afJG9Ur1nq41fV7bhWhZlAt3FEj6LYuZmJWATscmkdvsNyjmOShalDRJYpV98lsfxaeyZit+vpGFVtn9db15n77AolAT7jdNQpdFk5j1ErLF8JdU1MrboZmwLXKDjvdM+rta9RyMqcrYCdcdd9wxO/HEE/PnH/7wh3NxQeyVYMab8ia68d71rnc1TeQkSwffobarGS/kfqrC6ZrNVqbe6JbEHzliUwNbzShroKV4OP7kEKuqx6g4FYkWWRUVPxbFDv1QcT0ScAyE+Z7c12QpYt98xj4QI8pKKtdiBtdyZYp/9EUoGZUsECpNEQckUZTHmNg0MVWajEOD+iI0qNVASuJMgx8NgEBCWgNm/eGyLuIL10vuZZWykXiRWFIyGLlM8lpuYTFRSdouZZJUxWy9HKOSOHEsKhmhDKMSHkqapH1EISoXTFkHtZ4sdOq7UWTL3ZbzYnDMooy29CnF2anMUQy/qIeOIx1AaVH8JQNZ+k10u1Q/4DxlpdQgTQNjvq96nRwLA0kmEDUJEV03uef4vVYm6CiCJLgkGpXIiTaJg/7YV9W/2A7XSBmNlYVaMWgamCrxE7U/r7766pqIifGcMaabfimvAh2bvCNin9Jkhe53CQT2q8zhbFfrxmRCEiOKc9V92QglbdJvD8emUlly59Qx6RoqxlvlcGiP6BavfiJhrPaIaJvppFmcmIhiPyXGNaeZY1MLY9lFFj+dg/qGhI/EarQ06/dali2OVb91vEf7SoDKaq2yabLQxXjb6JFSltQNNf0NkbU/JkSK4RWNXGyVVDBeP46fvqhJPv3e6fc6RdbNmDE9WsZVgi2N74xhC0XZ+eN3YjxztKzqPk8tzirpxnVQzXQmGIr6hbavsAD+W5XPgf1Esa3wBl1jFu7HdgVgdKGud52Kfpv1vJ77tn5Pi+5PcsIY003GTrhusMEGefkaZrkZqK6yyirZNttskw90cLHDCitRwI/GIYcc0nSbP/nJT2rPm2UfNqNJTIKkOqtYjfTnoCyK/GnFH3vVt5Sw0sBNFiVZViRW9UemQbSEKN9RpmL+WDUwUHym3ABluZFllz9TLED6Y1O2zjJxbMC244yyBiCxrqRKM/BnnFoJovulrJosEp6ylsjaG4VXTLqiNlXsUETiLnUz00wy147fAiYKZHmrJ1g5Dx5pSwkoubAymCoaKMXnsviwXVnXNKjnNYMXxA99RWJV1vwobmM8oMSNBsQaeMjKkVrJY5IdFsQN54OFksRJiEPOWYNitWe01Gg77FuCWv1B1+nXv/71hMyx0RomoaPyQXIhjwMiWf/pj6qhKhGnJDwcA8erQaLqraqOaoyNi4JPxxDjoKOVR1Y+iUCIcYOKDeU+5/wVdytXf8UeqpYo9ySPHA//M0pUFAeGbJNzlbVHExSso2RgErQxWZbuf8Uz0j91DWNm4RSJLtpL3h1F62jRJINi4WNiNR2n+iLrKhEUbRjjxiWydG/Iqh+taxLWUZzyPLruRu+TKGjVN2MZHk0uddKKKiQkY19XiRPlH5BQkkjTBIvKQqk9JJzi/cK14d7kukZrcBR+aZb2ehNjMUYyuk/HiaTofh2zhccY6ij69LlQYihNuioLMs9j8jttQxM0WmRRpb/EEjxRkLaK7tGIEhfWK5+j/y9N6kC7rsicS6Pa5OrDmkxSCEojgVxvKfu57q34mf5nYgKpNMmhvg+dSB5oTDOmmlwmunvEoCbhuuuuW/uDiLNaMWkDMVrnnntuKfdjYmb5HnEtWHFHEQZD/BnzJ1qmBMm4gIWe6x8HoQwyNttss1pCjTijrB99CTL+FOX6xA+/Bn2y1kogaGAnt2INpONMsAa2SsgQazRKLLEuglVZRDX4QrwoRqcRsURPdH9K/5hjvUIN2tJY1LQwez2UyCJamjSAEnIllRjReWgQkFoUEBtKmpOKw5gYRnF/MYapCrJaxEGhSn4w+JEVVVbe1M1Xj9HaHY81JqKJYjX2OWWZ5Bw4HyYrmKwjy68sgfG8NGBptrC/Cy64ILcqRehfW2655YT35AIriwPXSOJL1h1NwHCM9OcYoyy3VpWkSK34nJsSbUlYpUlN4gBd7qOaHInnL1e4aJlT22tiSpMKai9lRKXf03ck1HhU8iCOQxMXPMoCqftDcZxpSRnFeUYXXw1q6ZP8NnNNuddk+Yz/b6mFkLalvTRhVm9QKxdXJlQU1qBkT4o7lRiIk06Kh5blUxMCsZ6rYhJTN2hl+I3x+VrSe69b2bfjfRcFXnS91z2rSRfOXbkKYnZunb+s37S92l39ku0oy3ScWFICL93vrSQUErH/S5g28mQpQr+luhe1yCqs81CfpQ04b01CxNwIakv1SXlzsL203YuWdj6XC68ybRedJ8dD25ctY9Qqygiue6ro/1QeEUrsNCjZgONEicY0GIeM6SZjZ3EFEodceuml2fvf//68XmFRzAyxr6eddlrTbbEdJXrCWjGqotU0hh9sDWgkgkiiwh8MwkCDBf4QGWAibBU3KiGo+obxjyoO1CT4eE9JwBgsaHvsUwNLWaMU18q+o3sesB1eyz24ERILLPVKPin9v5KqyFWaAa/cL8ugmXplZtaAK7qQRsGmtlVGWw3MiwQm32MQrhhKts3gUJZt2kslNxi4cE4q+xGtnNGCoQmL1GIRrQtyodZgV1lEUxe9KDQiagftTwMzfQbxd4zjZpDMuRBPSYIi1QblHGnjtPSCXGVjjct0sByPUW6p9ZAbXJxMUNvI+qzvc72VBEgTFBJpcsPmGJhoiFYRucRyvHwWJx4liDU4VyyZhGhqpZNLPo9c+1gTkeNV7VX6D+vRnmxD2UTlWs97nDd9RvG3sioqPID1dY/HUivRIigxqOyrXEuVfpH1VRlNOUf6FZMwus/iPc36isdLsx6naFInWv7pu7IORYudaojKq0MCX6JfE3MqFxX3LTEmt9fo5qvPo9DgUWI4Wlt1D7Ct1GJZJDqbidLUyqv3JU41KSB3VS2sI9GpPqMstzG2mN8dXWsli5NFUeeiRHWyzJVFcfBRmEaXztStVmEt0RtFn0ucapJB90fRBAJ9j99UTUjSx+WpUuSyHRO51bP2dxquj5KEcQ1VV1qf6beEdqe/akKlmwJan7M/9TF5NchdWevJQqv4WmWh76eITUOHWqnFbUxVxlK4An74WEfPO++87OKLL84tifwAMBjZdtttSyVkAkqB7LTTTrV4WDN+yNqiQQIocYksEIjDZZddNh848hl/nAwMFSMWB3oRDXiUIEYDHlmYWPi+yt+oTA3fkzsmAwMGEBoUS9SoFmI9GGRJrBbNSkO0rCg2i0FMGUcO1teMvYQq31OyHAaHMSFRWuYiigzat56ro2rmIqAVv8r3lQ2XdmKwsuaaa+aCVRYb1dNMPTIU8yWRpwkFwXHLzZeF/WpwL7EbBWA8VpaiuDN9rmNIP5N1gGvKObBEqx3XCWHHEgenRUmt4nNZzPR+tGLLYkkSKx2Pjp9jkcuuLJExRlP9Rpb/OHiOgzIlBlLJEA3U2JYmSuTWKzdiuV1r4kaWHFkvZQHTwFVLFBzqSxwv9xbuvVxH+qL6DYI0TnbwPfavySjiWGWF1P2jGsr0rSIBEBPS8LjMMstMEHuaSFH9VtqEvAxFngty0YzJwzS5lg6qOV7FdzPhhjjXfa9+KxdBlUrie2liJyWKoU30mcQ9bRknA+SSrRjZeB9EgapF11kW9Wbis8zncfKnaD2Qd4QS4KVldtJMzQr1YFIhutzLvZzt0nfo0zE+WROJXNsil2bdH/E3QpYuPZdVU1ZRrkMjF1uJ1+gCHy3ljaCNaBM82Pi903+fJlO572K/llDVvdYr9J/EsRZNnnKutDn3SZqfoJ/Qvvyn01f0X5hCX5Abs7Kbd1NgN/vcwtX0grF0FTatYVfhYr7whS9k559//oQSFQyoN9lkk9wCw5+ismwqLlUDmTSmRAM/lSxQDGBcT7UcVWJG7pUMnOTaJ/EQM/zxubLg1pul5Tj5PscaB5MQMxHKvbLZ4EYoQYTEpga1EqmaCY8CVZY/IauVzjXdtxILaWGftA+WAMpbISI1cJGQZHDJhAKPEmKICtooFajRshIzQyp+mUfVD42WWA0mI6mVNVpzNRCIQlZWUbnF0g4asOg6S/zH2L6y10fEGNh0kTWMx5it8owzzqjVxZbbGMdECIWsi3LNVWIu7g8lAVMmylh7UTBgQ0ipbAhtoUkbzi3G88oKqezQcRCqfejzRlZHWRyVRE0eA+qX8qjgGGTtlaBBUOn+k+VRWXo5ZyVy0jHp+nE8Et4SIHFAqLI0tI8ytapsS7ro/GVxjVZxPpcFjmNW32XiljZWn0+ThWlSIrpP6zdJgkfJsGKZGT3KVTQ9L60TvxezYsf1O0ka46f3YsZceUjIyhy/owkWhXcok7US96QDeAlHZXSXYJUY5fdHdb71XrzvFXOvBElVzzVaqaNIrSI0NKkoa6Cs8VFQ8ZvEf1MqVJtZ+TsNbSSx2mhSR/fwoCNrsf6bi0Qs/Um/M2kuCWNGibG1uBrTKeQaqHg1Bh9yyaOeJu7omgHX4Iw/IrlPatDHoFSigAEzf1Bx0KkBMH9aDKo0YGJgorI4WkeiVy5RyuYoi1fMqqiyGrL+Qox/UgIoWVI41kbIchyFajxnBhS0ixJOSRCkg1POTUk9lOQDlHgljW2LSYSUHIslxhgr2ykWSbwraCtdO8VXIT4RS/F4VCdVVlQJVYlNKLKgxvjKiARqPRdhPdd50u70KV1bzlWxZTE2TFbrNGOotpkm6kjFadFgR1ZplVxJE5jIPTDNFkwbSkjLhVxZUeU+qtexlI72hXWYayeXS7m7y21Yrn1MxujekciRu7kWuSXL5U6x2dGSwD1Av0HEcW15HidPJGiUnZdkXvpcoi62pcS0+ib74LViv1lffbUoKUwsk8F+sPrGGLgo6thHdB2Uh4EEaixtwT5VikOxwNETIGZ5lXeHJoLUP1lf4kQTSTHxWEyeJqGn378oomJW42YJZNI+rN/eVtZNUaiASpQpCZkmibQtZWpG8Miar0mSKETThQkY+hXb47dH8F2FNXCNESa6VlXjWNNJBT3Xf0QrKGu98ipoQoPfyFhSh3Pk95TJbdqlndqkrSK3fE02pHA8SpTGPdjr42sHhQcp3plrIRGryVj6i5JGNUqIaMywY+FqTJvICqpMvbJaMliRlTAiS4vKKMgKAsq0mloaGSgps67e4zl/XHJPVI1UubMqc6USPjEog+iOq/IjUajKlVCDNg38VWdT5yxBofWipZNjY/u4H8rdWKU/okiLA81oFdN2Y4yVxFmRlYBjZsDJgmBikJ9mfeQPHmsAIp596U8eawdtFWNUGZhJnDLgZLv1YnRT171UEMl9S+6IcUCqwa5qyyqhjwahskSpjSRWFYeluFBZreot9SzsabyuSsZooKqyMRIisTSGBrVMstC31D4a4GuRsFbiMMXXSjzFZF1yb6e9ZV2S269cijUw13nFBD3qh0oUo+sTl/ge58C+VLKE/hAtjhJhSgamaxv3q0G6BCXvqVSSJnpULkWurkyoqO5palVU/B/7pB9LMKgP6R6WdwZtwXlwDjFZiq6v7nXOk3PU/R77psr2yGqjvqcBr64p58X9ozj22JbqYxLrMbFVWddQbScK2qLXjT4r81qWc64F15zfXGV61m+Q4HyUqZnzVux7Gbg/+A1UebCYGIxt6R4rSwzNSEVqJ2IdFWOp34B0QoV7k99FZaynLXALJrdHP9xs6bty46ZvF1nmOUZ+W+vVXx425B7MQqkyrpV+u6KI1X+u1o+xu8YMMxauxrSJBrSKC2LBCqREXfzBa4ZerpBKvKCBqJJ2yM1S1jMliYkD55hVVdZUDXwV96fYJsG6scaqLGTR5UguZYjdaOHUOWiAVJQYRccUhari0JoNwmJmZW1fcZkqVcCiY4wDUAaeShglS6myMceBOX/atBMgaFSnlv0hTG+44Yaaa6jq8qXXOGbaTctJyJVSQjR1idRn7FdWQo6HfsExqJxOdJ9UhlFZ8BkgIoZUTzXNhNsKKt8SM/HGpC4xvjH2QSXCUbkP3ovZcmUtVxZMCTcJ4+h+LcEsa3yMp+Yco/ulrrs8GLRo0C7X7rT9QW6vrKOMohy/EuTITTcKcF07WYR17tENVtZvWeLkEiwxrkkPCXS2qeNVm8mqzrmoPJPuTfUDfS/WHo0Wf/VTJUXjN0bWJ7k369rwfU2yxJhSeXHIaqzsw9wrquestomZZaN3RauCsp41tBPIq0QJbmL94DQkgmOQICN2mfu02WBfv8ua0OE3hN8ifmvjJKTCNerV1dT+i4RplQmAssgDQUK1Xi4DeflwLvLe4XgQTvSRXsNx0rejWIsonEATt6NKFLH0VYUqxLrBEvcsWl+Tnp3qT5ogY19KeGVMt7BwNaZNNHCNySkY+Ky44oq1+mtp8ibNTjPQ1GCdAQGZqWUJ0qBFsA4DDN5jwBD/dNiPEt3I6stARHGXDJ71RyZrlWanOfYYN5qWoJDFT4NiiQ7VvtPgT6KnHjGlf8wyGi2KzZA1WS59HANik0Xxp1H0yerM9vlDV7yasi9LXMfkLKmbrdopWuvS7Jy6lnK11Oextq6sVcoIreybWk8DCblnItYYjOi6tjvIUBIxDVRlbY8F51OXbZ4rhlMWKsWtRmEVM8KyMOhfeeWVayWKlJxH94EmTuRqG7OrSgwq4ZQEuvYj10eJzNQtMMYGK5GOLGxRbEvMSPzxHSVtkkiOmV4VXyz3ZlklFVOWWpxieyvOLg6iY2y6hJSON9bo1GSG9qnMtlpHGbclypUMK9YPZb8xkY8SCGmbmiiiDRT7p0kVvh8tqNGzIrVmq/ZxP5d4b+l6q6/STmkZL74jTwY8Mrjn6mUlV3IqtXV8VIyyMjBH6Bvcx2nCoihM44RgN91YOcbo/ltvclECnkeEOMev46K/U06rl8l4NCHA/2WRa32caGk0MTDqnl8s9GF5E8TJkyhimVhR9uoqIlb9XP8F+j8AhYEY000sXI3pAEqMI0sIfwRy1ylCMXf8AfDHgaiRm7DiqGJmQcX3MbCKAkoxZsAfOnGBPKrshgZnspDoe3xHYkrxtdEyJrESFw2Go4BhPbkTQ0wspEG+MpvKlTkViUWv9VxWOWWGxCqtxDQ8V6IT7U8DdVmUiEMke7jcLYv2H61yKdE6FJfo2ikhoDhUWahYlM2WR1kpmUioV+ieASFuiXyXNuXcsWIr63kVt8no9qsMsXK9jZmKY0Ka6Eqp6x5dHGVtlEWfNuf4lIlZWYDZniy4aUZoPtfkCO3C58roqfhlJmYQ+TE+OrZ56mKrGEVZOWXVjWJFdUfVfxWvKquwvBxk2Yx9RddW8Y6qU1zkMqtJHQlqCT21teIilUiNdaNIVf+VBVbxsvHaKfY8ZvvV+cvzQr8fmoBRFmclxYr9TvcoFn2J2ThxlaJrOQjod4Jz1xJFqSY3dM2jp4e8PfQ7xbkyIcb9pnbVYzzfIrEs1/kI+8HFmHZNraidcO0tA8eu34GYx6AIxUrrnlAdcvUn2o7z4fepF3C9FLdaZA3Wfy19V1l1zX/+41lSEavJcyV8YiHnRBSx8fcheuVoqfd/qXvP18F0EwtXY9qEH/GY/ETcddddNcsffwQaICkzqOq6yrU21r1TgXS5AzNIZn29J5GpbLyKlYqDtgj7RAggfDV4ZZCmAb9cGiU00hg5WczSwarc2uQ2KEuNZr3L/IFFN7voQqqkMnLrTAUsx8YfM9/nD1kZffX96OYZrXDx2DV4VObTKOSi9U/rSyjJkhtdfjUxEGN/OR6Ol1jFooG+LFxc9yIXwjQmtl77RQt4jE+r9125/Ra9JwGrQb+y9kr469zkfk0/j+JJghBrv65DamVi0TWW5Z2FdkC4p66ZsR+pv8jaJRdHiQv2z2veV9xiFH1y1VY2ZpURkuBTTLjixLlnJDzrZeZm29yHSuiUHisoAzHryX1Yrvk6dll9Zf1MBVisi8t3YtIcuQJr8gBkSZQLb0zmRFsjQpTNVpa+okzF9ZZ+wLnFeqEx03e6jiYrFIscPTwkXmkvfl/4TUnDJ8qga8bC74AmqrBI0sa9HsRz7nIVV0K1evC/FLP/SrDQp0gqGH+z+Jxz6rbrLdeS66G446J+xjHLLd8xm81RvgHud4lYjUGEStApeWPZqgHRY0FltyxcTTexcDWmTeTaWyQS5IbLwJDPmdlU5kgVsddgmOcIHMXoqYQAg1wNuOV2qgFwtCzpWGJ8rIQAf/Qa8Er8yZpWNOCTUI2DcA1yYlZQxTGWySQpN98oTjW4TN0jFZ+nMii8RpgiDCSOZFFUohBZyDTQiVlOIbr3ptl05eqquEUN4BVzjHihHWlPnkukSiyoTA/fp+24zrgvKwss7RPjXbmGbI+FdixjhVZJDA3Y6T8xgVI91FbqHxKfmriQ5Y5+I6uwkhRpUC4roWqs8h7XEou2MkSnFlFc0TSIj2VqeI9zkOskbSYrq1zroxVZLreKZ1aMtvpQFHRKtEOfkUWX50ogpiy9PMedmQyvHKuEL9+XOz6WCnkz0Ac43ugGJ7c7zl2DQLlc67hkXeM9vCF0zykJWhS18p6QCNK10UAzunfqvpTFCbQtZSlnWxqASiDTxksvvXTe7zph8asicltdZDHVosk5hQXIGshr/b7pN0Fx7THxnNz7NfGh7zZCE2AKs0gfBevwG8F+e2VRhVimJmaeTpHFX7/Zad1w7jWszYj4+B0Ej9qyW6hUkMpJpXCs9OFRj1vtpYilvfmfwrLOb5nyFdSzwitZYEy+p0kxY3qFhasxbSKXXQZCsnggbpZbbrlaAhT+jBkMaHDBH4RqybE+gwUJ1jgQkhBlcMofu6wCGpjLxVF/IipELkHANnHlLCo3A4qHlVhlIKfSFWyb44tWCg2w48C4aJtsR6JKMZXKZhpFqixFwOsYg8gj7cIiISXhJ5dKWUrlDilLSlqaJNYhlRVV70drluL7GHzKCpoOkqKQk7BRMhasjNFFWxZU9qH4OawWjeoaSvhEcS/hIuu4rKMaOMTEXRqk65zlyq26m4p/ZtFEgfaj2XbVpFRCIk0CcG6Kl9b2JW7jBAFtSIy3MkJrMkViW5M9bEeu0VxDTWLIe0GTO3JTj9mNtcgFmu8rERrHqv7CvcN1lLcDYpVrwL6UjEv9i3PieFRCgm3xXV0vWYNUMkcxu8rSC7pf2Df3nuKqY1kd2oLjUswzrzUZpQmpWGYoWpPZjyZOZEXmvDluzlHuvbQ7x8/5MkiVq34n6UZCJc5JIjVOzHHsElyR6BUCXOPYVrQN97LipeuhdeXGHh/1G9BIYMs9sxcWQMVEayKjXsZzUM1n/S/Uu160H5MrcbKS9RdbbLGuZQxmX4pbLZp8U3I2ZdU3rZO6/HLPaIJA9WzlrRMnOuWpxLWStwq/Xf3IIm0MWLga0wEYeMdBHNacVVZZJf8TwOVKbosaxCoeEwui4gZjcgQlMpK1Rll1ZUnVn4asBhKLbC+6F6YiTZlIZWUDiV8G0RJ2RbOtEqoahCubr+Jpo0Wkirsd31XpGc4TYYR1VUlVZDWVJU4W0miZU91O1ThVZlSduyYUJHpZ5NKs2D7+kIsSVNAmEqk8yqqK2Ln77rvzyQSVNomwLfoFVi6WKFblXh4FaipWo+t0EbLIsV8NrlWjUJZLYFtyY9WkgK5P3IZqSkrMaxCvAWN0pVU78h6lXRT3qQkDhNJqq61Ws5jSV7jGsV+oBBD7v/HGG2sDcYkOiBMcmpzQBIT6uMrt8L7KzfD5UkstVcuAymuec41pA9yb6WPKSsp2uFZy+WZdtstntB3bZH2W6OGge0nikUf6MeuoDZWsjXZTPJ6yBytJitzwFb8aY8w1mRAFkmKBFTsea/tyr/L7w0JfGHRriCapNGlV1N/VzqopzfmrdFKRqzDrKMSC6x+R5TTN2tvLuNOqyBNCwqLebwIowZhKMTVLukPbMYFDv43tx4RHTMjUKXRP6b5KiTHXHL/dTqsTPae0NPLKgZh4Tv/z6f8P22AyjkUT25osM6ZXWLga0wHigEcxRpdcckkubGLKfgaw/NBrAB9dyjTjL8tAtDDG5COKX5L7YyxLE5EFTpYquZtKkGhAI1Ety5ksZDzKBQ1xIguXsrU2SvKRosEmx6BMwLiZImYYwEicxMzLUZxGVz0JcFlXlVwqFaiC10qWpAERz+sN6KKrpYSqkmRpgIeFQCWNInLJxLLKwj5kfVZt0pjYRhbvuKTbVPIhPZf7p8oeKU4PFN/J9VJt0pjlmHZRgi0eFZtMP5Lw1LWXW3VsS/UR2kiWEKw0DGRihmWE+uqrr56fJ+7vnDeTA6q3yLoI6XvuuWdC/1R/lRttFOUq0aR+HEvU0Kd4n2MiM7eELMeJpRsRxzZvu+22XCgqdk7xntxzii3lHOiXfKbETnLvTxP2qEQJ3+Ec5U7PcaiMlTwYuFZ8R2VFJMZ0b6cZgkHlkOTGznYUmyv3eLl+YnFVjdVBFWAga3osTQMS7fpt0aMs1FxT2kO/f/XcSZXlWRMWqTjtdEmZbiD39Vimpp77rzJES6xWERH0NbmwC9oNK2sjr5Cq6Hdfv5tF58KxK251kPvvIFKU5beZ+7tKs8WlqN3ZthI7xX6i8QjeJ6ojr0k0Y7rJ4P+CGzMkgwwNPPmDZiAfXUzleitrlQaeGkwpRlLuPLGMhwQigxMG4JpFV41NiT4l1YnJovhjiccJslQoG2+M1eIzDazTDLRCVk5ZM/VcwicKSQYpCCiVrEH0yWVYx6TzlOVL9XAl0CSmorDguZL6RHhfA3gGQbI+NnLfU9tLrGpgq7I5qn/Lo5L9xLZQ4hfEsMoK8GePpT1tO5Vh0RJduKPVMsa2RpdwiVTF/alOJ4vcauWGLvdeCW/FcapMkAb22m/MIitLYYz91cAytWKlWWp1XW+//fZ8kZszx0hbyTtBscE8KtmQLIlyb1b8rwbxMRkY66rfaH0JSFAsHH3ummuuyWNxFR/JdVGtWWVIVT1djpVJBvqt2lMTSBrsqa6sJgVUBkmCVCVkaC9NFsQEY7JkaHIpuhErFje2qWLlde4Sq4hyWdkHNUmNfm+id0Z0adej7n9NyKmetbKfpomv4vXAMshvI22iUIFhQ1mJY8KtIjhvlR1R3HlVqyRtKi+X+PtDG8bM9e3CeSgGvOh8VKNaEz2mOZqcjEszDyflNYgitWycMPeT8jEoPwYTkLGUHNeZvkS/WXfddR2DbLqKhasxbaLSH7Ii8EPOwFafycrKYFSDcVCMocp3YIGMs6QaxDKwjoJKn0ngyWqnDKsxYY1EnspiQMxYqvgwJUFqNFiSOJUrrsSkrGAIFGbvEagM/GVJ1X5iCRbQMWrbsqjIwqZYwXjeskDJgoJljz9UBIJclhrFe6lNo1CNA365W0ukKlOvrN9ysdYxck3lqsq25dKdWlMlWJSZN8bOSaRq8iF17VbsJ0JKrpGK55Xwj9c6DkhUy5P35DrKddP+eF8WvLSermIK+bxefKCurWb8lXwLqybPozeB2poBjixpcm3FOk1bakClRDtKehbFCG0gLwYmKBSjLAuoJnY4HkohpXF7Eu5yfWcgxiA+xgtGV1JNGEisKjkWi+4jWf8Z9Ot+43MlQVMcuVyKNVEgy3G8vyRmFUutAadiy+U5MIhiVVZqDW5jreAo0Iti+DU5o36tEAKunX5vZBmXOzfLsLqTKqY/5j2oB31LQrXZRFwz6IvcE3FSk7bHytqJOFK2L1fgonNSSAOL41bL3U9RpDYrQ6VyY/rd0uR4/J/h/y2WytLS7HWE+1QTirLEKvmeMd3EwtWYNuGPBKGm+CsJOwbjKnHCgE1uNQxSGKwyGE0HIBqkK5mN3GRlWWJ9CQW56tRz2ZUlNmbO1Z9X7Qfg/45D60R3zzSTpsQBf1QMfHC7RIRw7nLVTAWNjiHG/+rPUIN3CWm5MMdMofo+A/hll102W3755XMBpnhcWRHjORdZJyRS0zbnOBFCKkmkeFBZCWRFi9dF7pjpADK1pkoYys2VRdeOfSKQ1cYSL3JJliUqusuqrXhM62jKFVj70YCFgb7iqaN4VhKv1DVMrqiyVOuYlAQpTYqEmL7uuutya2bMUEw7//Wvf62JwJg8jO0y2UAbKjZTccRcewkcuSwLJSpi3SWWWGKC1Y7tcH0V24ULslyUlQBMWX45b9pT8cQSVYorj9dC1g36NxNLIA8FTaqozArnwb2g7NmaUJBnheKOVd+W9VQySpMcSoxF+yiuXBNfgyZWFQMnkaISG0Uxp0KW6NhPo9cHaKBO23Kvxz6qiTwlDhsm9FsjoRqFYwrnHt1/OyEG2D8x2kwsRiurMs+3I/5jYrGi8+Jacb8zwch5jTvRoyaKQ01iy4tG1tSijPNaNGmm3yR5jsjDoVuo/BOLMv/bTdj0AgtXY9pErqxy4dTgkz8SBrKaldSAXhYZBnkxS6isW3GWVIJRsaapUNOAPLr1ysVW7mRpdt24aPCnwTVLLAWDgCORDSJArr4cdyx7InfWKFbjH6osKGkNVQ2UZIGSaOY7+kNkUEXMIoN2Wa0QEIqpTJNPxXq5tCWDpXTQp7ZnEKfrozIqUYBLcDLQktDjURZmCR9Zk2OMKOchS7YSV/EdTQTI1VXCSCJMMaQxCZfWUZkLZQpWAiEWCWm1f3TRVBZgjp9BfxxcyCNAngCaJFGZhJgoCaLrN1ZV1kMkyrUxliNinxyjSiVpMoI245jYlvq4XORloVE8rrYTa8uqL7E9DYbZDv2C46Jv6F7QtaQfLbnkkvn5K+OwBoYSYLLuygsgxlfLXVr9R9Z3HTfEttf6mqyQ5VH3ZXSBlviVmOd6yLrYb7GqiRbFZivmV66CzWLp5A6uJG+arIhxpwopYCInZgYWfK7fg2Gz0MUM3voNKEL3oYRqWs+5Xbh+TDbGZEi0Pb+tre5Lv6OKW01RgiyFFwxj3GqRuKxqpSx6rd8weePUy2+QIld6WVNZuuViHcvH6Xmz18M2mWSGk6kmN4vgNn2FP4QLL7wwt2pcf/31ucWOQR8/cgwCVlhhhWzzzTfP9t577/wPopuQKZT9k22QwaH5N0cddVT2q1/9qjYQ1yBk1VVXrbm5xZgSBmLK4CcXV4mGtLyDErVwm8ryF/8MeV8WxVgGp94gQTOyEtr6A1WdVJJJcW0RqCrfU4/0z0o/JTF5kixw2o+OX2KA40VMxJhUiZNojWrm+ptacIREfSyvollslYGRG6nckOMiwao4UX1HIlMujRKWsoBHK6lccGO5Gh5lmZdLtAb0HEe0uMpiKSEbM8jK7VdxkzG7M+eoeEm+r3PWREOME41liiTAJO5oN/oCwkJ1TmVVow2wtrINWSBZcJnddNNNaxMYsqKrPSQeJewl/tNySSoxlSLBq3slJn3RQIpHLHP8XnF/yFuA9SVI5SEhD4c0cY/6bcwcrMmS2FZqC21LHhYssijHTJ36jcAjg2OUWOE594ImGHoR9xczXBc9asJIma4bDRmUNExJ0OS+r34d4VrILT+9x2kf7r34mzAMyPIkt/NGCezkJh8ztncD7l3+t2Mby8padZ9ce85LFvai32aV0lKG8m6T/rc0E49V1u3kMepe0tIsyy9El9/ohVWUb6KRmCwrPONrYwYVW1wHnGuvvTbbZZddCj9DwF5xxRX58qUvfSk744wz8sGi6S2Kx5OIkTBTWRDFgmpgysAuCiwNHGOGUf15RoEqQapkQMr+WzSoU7ZYiSJQ4hkGHbKYEUPGwIaBfyO3IonRWOcwltaJ6HyUtVWDAI6XAROxVNTRlDtkdHtmPVlWojCINV9jfCjHFbMnqx4gi1yuYpZWtXGc3Y6CURZrWVVpG5VxiceiRSJVcauaFOCaSHxyDEo6pEQyDFQlTFQLNWaaVZKZdKDC9zSQ5/w4tljzUu0kl+vokhzFarSMg441inDVjVUmaSUpUhZTWQrV3joXjhFX3u22266WpEt9gGtB32MgHdsublv3lF5r+/HaS1hLVPFaNSrlHk4/Yl1ZneVqX5QpuUiQSYzKfVq1VrU/IY8BJWCi/dSHNGDV5Ii8IFQHUf00WmC4pqCBZKwpGt0B43sxa3QchOq1jqNImMb7VzH3ykxaVHYlhhBEkYLYbuYGKmt+vbqdSmjFMujZf+Xaqd8utVk95A2iWNVuT0rQ1lhZ6f+Ca8bvr+pPl4XzUtxykRiX2yj9oMhdNHVz7YTVUs8H0fYSy1kp8VwqNJXFNybl0wSlQlv021JPaA7LhI4xnWSw/xlMDrGS73znO/PyEjxnwM8PNpaxc889N/vpT3+aD0633nrrXOhSP9T0Fok0DSYRrCuttFKt1iJ/6rLcqQahytAwcNWgsmhQwJ9ZtALGGNQoUKOYZLtyfVVcE4/0EwYgRfXzQH+MEqhRIGrAL/GXDmol5OQixp+vsrYiVIlX4xglJDk2ZbXk+OX6KmS905+4LLBpzVOVilCSHlk8lMRIYkM1TJUQJmYljm7TtA+CVeejDMtRrMTSO4qJ5DrKNZLzV7ZXJQKKlkO1qbbNQKyojIXiLuVqy3W85ZZb8mspkRSFYxQyiiWUeAS1RbQQa/9yf5UoVx+TuFX/49y4VksvvXR+Xc8+++z8eKIIx+KKpVMDe/qdSh9poKlEMxq4ySouMSULJ+uo6H0sq8GiMjWacKCdlbBJQkITBBrkxiVNiqQJCnlFSPApdhWiBZV2iiWHdH+rNqnuX36zNRCVAFeWcQl3thNLEJV1uyuKk46x7HJ9josGvnIF1j2t6y7hnYpl9WsJMIUCaJu6DnFAzXFwnepNjskyzu9Ep11kuylSm1mfde/GtuoV9FfGB9FqyD3EPdnImhbFocQqiyZTowDlGiuMgnPTb2yR0Oyk9bJbtGKVjJNC0eUXlASwqL3lKRSz/LoWqjHlsKvwgKPYuUacd955uXUDeETIdgO7ChdzzDHHZFdddVU+eJWla5lllskOO+ywmlDTAECD7UYuZLE8jkSHLHnROqhBsxYN6FVnlAXBUGQFiLO8MdlMnOGtF+uWDkJk3WJQhFCNg2iVxokxjHGwlwrWKJjV72UZKmozxQkqEYWEl+Lx5JKl2WzFyEVXVwkHWZi0v4gG8lr0nq6VYkTVfrGd5e6lsjHKFCnhHwf5GvBFIc0gFAsl1zOdLIgxhCojEjNX65wkTBSzqnbm+2nNTJBwVNZhhCgDXx6ZPGMSQuvR/6kbG63SWNZ33XXXCSWE0nhsCRxZJGJyLpWqoW9oUMxkAveOYpJlMafv0P84PrZZVEpEIjgmuFLCKlnmte9YbiJeD4lyfScmzooDV95TPGeM7ZOnhCzyEgGaIInJzPQosaD+poFytDzF5FMxNjfew7rfYxx6LD+jRcJb3h2xf6uOblmU5VxiJrUC00ZyBdbvRRQHjSzIRe91yvoURarCNZqJVBHL1MgDoNPE7LCpFZLjxHVfdW7lOs9vs8IKGlkweVRIRVGSpRiL20335nrE698Jd9i0HzWD9iyqmdqMmKBOE9G2lhrTGhauI8Jyyy2X141k1pqBbjewcC2GgTsZVBl8qjwNg+htttmmlqm20aBHMbAMBLA8yBIoKyrbjeJUljZZMWRFLRI2IKtgdLHVALXRwEMuuBI+/NEqYRLnx+BFjxyXBLmshxLXReeuZFQq8yOhlmY9To9HFkO1hxIW6Txi7Vu5aPMZ21TbyNopERWzQUugxoRR2neMb9RjkTt3HPizDtdKVmBZE6NQiQl9dI006FfJpHSQpYmNmMxHMZ/avuJDJVCjZVGDLx4lXlhPgk+WFJXBUYZi1lGb6bhPOeWUXFgLJYLaYIMNahZlra/EW8p8qdqtGsQptlGulHJtl7iln+l6KUu0asFGa2H0QJCoZz/R2kz7qJ9KxGpyRKVoZKmNGbwl+OLgFZSIBsEty6esKmUGqur7sbax7j3tXxMRqbu63L7j/RNFapwEjcnMomCU+6JEt36HYp9uJlw1mabrlKKJENU77iSpaC8jdkHtHF2nU+t0+lz3YD1vGOhkrGX6O1OEEs7F30/amd/oRpPfCnGR90/R9pUsTCECzagqHsuu22uxpwlXJXJTOEsjdB/FZdDd3o0ZJnw3jQiKLSoSLqa78EfPn34cTPLnFgfzEQbLco2TCzHvKfsoAxCVzVF9Px6jFbUoRow/9ujeG0t2VJkZ5zgYwHFczNQjVCVWo9sX28a6i+uqZuflnqqYzSikVLZE5WRYL8Z5RZfc1EVXiS20TYlv2jEmJdK5chx8Rwl75OoYB0DahupzQqxTq7aT8EtrpkaBq+8q9pLrqMQzsvpKUMckVhynxLtqyMZBvwZuam9lBpb1K5ZGim6vssRG8a2BOa8lemUNZ598roy3soSyD9qHay43Xw2iZb3lHCWw5bYrq6Us3Ux60dflNqoYaPU3jkkZdCUKcS3W5IImgLSernOatIpFliaJDbZFP5VLudpeIlz1ZuU5oMzKilPTNZcQlJWFc6MvExKgeFq5yatucxQM0UIa20iCNLqgxgzHEis6vyIkpmIyMv0XxH4bB90xg3Va/1fHklo0lVQtWsZVwkjlknRt2K5cShWb3U132TRzeYomr+LSrCZmbKdY15dz0/fl4q3Jil67xnJdFesuuAZyT6+HXPNZFE+ujOgKp4j1VqsIz2FE3jtxaeQZBWqnKFJdEsaY7mLhOgJgab3hhhtqllfTW2JSpohcEpXARNlCeU9ZGRGoWGuVqZVtqDREdC+Of6CKaVOm4ihQW0lHz3dw/eTYNMBEpGqWOGY0lpurslvHeptyf5SoljWNP3IG8QykWE+ilPWiSGX7sjrK0hWTAineLiZ5UdZjCUsJ3Zigh+OLmWE1kJf4VLxjLMmTlqeRBU+DVoiWTdpE1nBZgYWOW5ljZSEFWTroC1x/uZOyXx1rdNNUzK5EZLroeqkvxoG0xJpey5quxGFKBMX5K6aYcyFWLk2UpcEq25TolVjhkT5En5LljnaRENUxxrqctA3npYkbiRBecwy0F9uTOMRlWZbNeC1UnkilgNSv5Jqs447WXwksiTU+14RATLAll3OOleRTSkTTSKzGTNJpUqRUNNGWsnIXIXEhy6diaSXCdL4SxqkLaLSsR0+EeA/qOjdC7au+npZ50QSKLNC0k2L44v4VyxstotHSmSZ3ixblRu/p9yrNhlwmi2t07Y9eL/XEWIyL7qVrrF7z+8fvMMes2G7aHHd+XeO033PduK+Ac+P+E5qoYhuxhvIoognPKi6/8o6KLr/DKtSNGVYsXIcUiYdf/OIX2bHHHlsbEB5yyCEtba9MeZtu/TkPOxJAXAOJAyyVJNTSII+BAvUu//SnP9XipRhkMYiIIhVBkiYBiuV0JOparZfGd7F+LbLIIvmCAJD4SK+vxI0GfspGrPgpCTklW5JglIDWoE9un8Qoqr1iwhe5oMqVUzFW8XgkJnlfpV5i6RENSuXWGmNf5UockxdFy7QGHjquOFiVgFTGXdpA1jC1jaxyWl8Dcg0WY5ZIkBBSyQxZ/Dg+faZrzsBIMXfRYhfFhkSgBI0G/On1VPvpWmlAm2YellttmqBL1yt1mZZLduxjXFMGz7QX/V7XQP1W2WNpF/bPbxmPEg6KF2UwTq1JTTzIWg+qbxxjdBVjquy4ug6KFZd7scrxyEKs+yomSpMgk1iVwFY20ChWZc3TBEQUqFWznqqfxlqnOj4JcsXlSjAWWWPTvieBHvtQagFWSSJ5OESRrYkBzlGeIClqY7lZs03cVxsllFJfiy7J6nsxCVp00Zfw1eSajlGTBHGii+sT3bDjxI7W0YSUJqXKCuT0deqS3G4cZj3XWNqVrPBcL+4JtT3J0nR/CE0A8f8SrbLxWvAdJZMbxdhLufxqUbKpRshrJQrVXpSnMsY0xsJ1iCCWbK+99qr7+aGHHpq9//3vb2nbDDJN6zDQ0OCPP8Xbb789+/73vz9hsC7rWoxVlUujBmyyfMV6l63C97muEqkManD5ZX9yZU3rtCrxjGILFQvJc96PVhuVlJHwU/IaCXiV/olW4bRWJusymJL7qAamtINc2RC8cp+Nbo9yi4zWv5gROYowDYLT2pyyxIEscxrIRzdJDZwlkmXZ03dlIZL4VRwfA3i5Ueo81JYSkHLhlNBAIMnirHVkMZMwjpmWlRyIbXPdJGijhTS6XcdYV1mmdawx7rHRIqGtfqukR7EEzH333TfBZReUkEeulvRBYP9MotCneE+WaQk12oS+zHZk6ZNIlWValm+5hkukxgkAxaop6RDHKwuUvq++jCiN5UtA31PsOdcUAVHVNVTeGNGqp0fd83JLpq8g/qKrcxExA7eSonUC9kkbYdmj73Id1J8kaGN94RgrKotuUakh9dN6FIlbueOmkzdFxPs2ihC1kYRIkTgeZCsa14IETHGCk77Kb3z8jdNvjf5nUpTUjO+28z8zaETvCS1lrO1FLr+jKOKNGXYsXEeAVVddNTvppJOyNddcs9+HMpbwR8lgW4MDzb6TaVUiVbGWUaTGGDENmjTIl5ipl2QkhT9ZCdRoTY3rMtDHYirXY8XOcnyyZEZBpQRBfE8DP9Ufja7BMbkSg3z2y+BQrogSeDyq/IpcDCV+JZhlbZVrpgSdBsBRVCqeNooACVTNjMcEJ9HFku9LaEoM6v04WGEdlTigLeRyGy2PcttmAMj7cuUlrpLzkBunSvRowA/alkSjYks5V7ksyrU4WqBkEVSpCgknJY2RJTSWK1E/0+BWCVdkGVN/gyg2o3goSjJyzTXX1Gqb6pFtx3hSJkzwQuBcJMbkAq2+SXvJtVcDTQQtopW2u/vuu/P15OGg/iTrCdtiIM53JEpkNeT7cktmfblY6npI7NJ/o2u4+h3fifHAZdAkT2o91WRKCvuRJZXHoqyuEYlzCbFOx9bFcigxgZi8GpoJH00ERVfpmLlbbV/PtVmJ2HT/pSWpIMZ1xz7KtVYZKbWN+nPMxl6PNF48Fbf13quXAKoT0CZMkvDbIjgGfuu5BsC9pcz1aVsB7aDybNFLYpgpyvLbzMtBsfdxGeTJinrUCxXp1FJ1e+qPxnQTC9chYtttt83WWGON/Dk/zrjg/fjHP85+9rOfZbvsskv21a9+Ndtyyy1b2vaDDz7YdB2EMYNL8x8YkCmbbkyswiA1ijoGCs2ycpZ1xVa8Hy6/WD9YcBeT8NKASgmjuGZcXwbqiiFUuQOJ7Bj/KRdYXutPXda9mLhHgzPOl2NS0hzF70YBJGtWbKNYakKD0pg5MyankThFWCi7pdz74qA5ikkNsKtYE2KSG8X86foRoxutyjHhE+3BeStBDeckS150q9TAX+fBojgpnWM6kaF+IZdlWbmUqIhrH912VYYjltyRhZRjJn6Z/iP381gap16/jDGQmnSIiyZmlCCMbePiSx9FsHL+WCeJc42DStVILYoL5riYEMK6JNHHOog6iXvOlX0wGKcd+VzHxPeVhEpilf1r8kRu1hI0ugZKKMQ+NaHQqL9EoRsfmwkD9h/dfpvF2MntXmK1G8KDNpU3RpFwpk25F5QZuhHyPtBxFyFxqxhxJaSjTbiXNEHEOUfreprJO7oay+ofXWRTy23qnhwzW0P07GiXNIa3leeKNZfnBe/RryUS8G7Q/1D0igB5v3DNBrVOblliqapYsqoRmswrKuskwaXJq14JvE5ta9AYlckQM9i4HM4IcPrpp2d77LFH/meFe+qee+7Zlf24HM6UYOmmzRl8a+DO4BdBssoqq0yIqYqWhXrlEdI/JSXPUAZiBiAaxMUlWjPkXimRGkWhBkOK4dSffrTy6vgVmyoBGF3+JKxUwid1S1Rcpo5DYkOiIbr76VFugHL3lVWHc9d5a1CqgZ3Wi6VvikpXpElg0gQssmIqQ28c0MjtMS2TwbnRvhKsmvmXlVVuuRI2cl9GtKp8TYwjlViLg2r2oxqz2n+Ksn8iYmlLWYZTV14s4bRlWSEvl2hZvPQ8dYtNy+GwfZLEHXnkkfmxIFi5/hG5CdN+cluO2XRlAaXdYjkY3uc8dS58ruPT/aJ+wj6VhVsZQmXplkUtWuQY0MYSTRH1s1SgKqFV2faMFtVmGW01CSGx2q34Ok0G6HqkA2LFQCoDervuk7Jgx6VRW0RviyLXYU2oNCL+xhZZd/XbGLOOx9eaGOq16yjHxf0TrcMcD32fR8R+vTrdKmnFNYtx942Esr6r84wCOL5X5nm7okwuv7GervpJ0fb0PGaA1u+uXX57A/fkyiuv3KO9mXHFFtcRYLfddssuuOCC3Pp64IEHZltvvXU+kDXdJ3WL0QBJFrhmRJc0BuQqOyOxqoy4slAywJQLqixqSgATY/hUOkZ/6kpmJBdZBIWEnwYZcpXUIFnZZnVeErtKwKKyLBr8qNQJAy0GwRJb6aBC9UJ5HUvPKEmKXFglICQamrla1rP2pIsGMsqMKoEv0SrrlyzSskrSnnKtllCN5XoU96rz4fhlyeR85FYZE32k1iJNIERxE92JtR7fx9JKX2EfanPgGgquT5qBN0VJd1KBWtYDICbkUvvCrbfeOkGQqH/G+rQamPKac1NMtNxmEZ5sn9+zxRZbLD8XUP/nOrBv9quyOXiicE1l5Y4u0DHWUY/q80VWUz224kYoF3GJ1WZxdnJvVXKjZn28XTi+oqzl8Xg0WdbqscRrLPFRJt5QoQCxTmqjmMPolhxrB6d1hFs9D02uxbjZNKlSXDcVytFKHD9vJOhoK2Kb4+846H4vsrzpd0Ju7UyoKileo33pvU6STiA2ex7dyjVZCHG9dOE3I8amKgnbMNMsv0Cjpd3vd2J7xnSb4b7DTY1tttkmF64MDn7961+3nKTJVKPVeA4Gy7ieIlRlPdLgWwM9Bh16Hl2ZNOjRgIk/fAbsDJCjRUEDKyXwkZjjNX/wyoTKZ3I9lJhV3GMUL/wpMThQ2Rxes09EAkuaCViCRi7T0fVOxxQz2CpmThZcCc16oiFmCU6XejGExPjicseAkGOWQI1uymoDjpv7SWJV1kCQBUPfY58ISVnulDVXNXBTl2a5mGqCQEJax6KyRHEgwHoIUIlfDWw5j3TQyXcVaxzPPwpTPa/iDqnJBVm55bau7LwSa6wn0ap9xSRfsX6pkkPR7kpgpmywtJ1q9XKexI2DSgNJCMhtUF4B0Sqs7NMShCpNhehXEpZ6faYKHGO0qDZqV91Lsqgq03G3aZZhVm7xKiNVhViXNv5uNaPIlbNqYpw4UVUPidsoZovEbRESq6JKCZzUdTc9pli6SgIXscm9ojwBtKu8RBRnHz0TJNzi+0UiNf2sm8R9pmgyNsY/N0twpt/MOIGphHlyL1efqZfVWRPFMbdB+n5qaY/vxXXrrd+uUDTGNMbCdURQSnwgJsz0VrjKkhkFmwZfsqTKmsq1QrDI0qT4JZWgiK7FGmiAMuHKdVRWPw2CGZDL4sVr9sXAWPGQLDEhk9aTpU+WQiVnin/Osk6xP8TSnXfemQ+sFGuoDL9RYEd3O7llSpDKisoxq01khdQAke83spqmA8GYcEqZkVk4XgaCsizJepK6DrI/ucfKLTUmfUFIcXwasCrODJEoMScrFeckcR4FaizzEWsqqmwPxNjBVKwC1472T91vOX72zcSCXG/ZvgRqowyuKdGVWo+0RcxQTBupnBN9IQ7kaU+JI9XcZd3ojk37cP11rEqYwrlyjVmH+0IxrhyHBne6B9LstYoBVIZdxfbRv7j/FAveLrKIRYtqIyFDX0kz2vYyGYys1/S1VCDQXvIIKFsORXGp7YpU1XftxaC9jLhVeEA9q22zTMitHFPsB7Qjk2v6badf0V8VXy94T3HyzWKN64mkIktrKmrVV9L367npptvUf5nueU2aKRZXIlT9Llr5dM9rIjAmmus2mlBoJca51TjmVr/XjURgxgwyFq4jQowxU71I032UtAgxwZ+0/myJB95+++1rZV30h02SpLvuumtCMqR6KLuqBsQSkcqayQA/JkNQ4h0G6Kyj2CcJUyXAWXrppfMBvcSfajwyuJXVQRlrZUlTcqcYz6nYMgk/CQ+OTS7IEmkxbpP9yT1Twk4z7rKiarCi70AsVyLRqYyxEg+qAytBIStcdM2LMbWacIiJTFSzM9YqldWYY41JlWSpk3VV36tHPbEaKRKrylyNCFfCJZXLURIt2ou2kMtwGYrqZcrKo5jMmFW2CB0DSNCyDfpMdK2We7BcnTVJogkUWblpHwmc6PYsgauM1zrOGMsrjwDVpVSd1XbFquLt1LdiDdUiFP8tiyrn0muLCtdCrsBFMaTyCqCdGsXPRpEqi2oZ8RZFqn4XeiVSWyVOllUVt2qTVixtbJP/cCbYJOwQaiTek5u/wkm4XtwXjVxo+2nBU/mvWDOV609fE2lNXXlFxEXtUlQ3t+h52XW7jf5j+lH3vtdC2aLZ9AML1xHhnHPOqT1faaWV+nos4wbJCBhIx/qLquXa7I9SQjTWzowiStZFibZoCZX7I2KV+D8GNardp/0qSyjHx4CeQbQGNEq0IndTWc8Y6MqSqsF6WotR4gNRoPIjbEt1UXVees4gjP3FUiXRuhrrjar0jISxLA9yOdVEgASTBgqxfqn+UDVokRWOwXO0UsiqGi3Dys4r4ShLauq2rMRZyhjdabGq73J9EIFKTqKFc2IQK2tFUZIWtauEd+rSpvZuNAgs+iy6WpKpl34jayfbZsB6ww035H1JkxK0I+1FP5AlNx6TrPCxjaM3APvSo2KrU+sT90InxKriceMESKN7WXHfsqhG63Av4bh1H6cWeaCtZYWO/UwoO3q0pJYRqYodTt19R5Ey4rbK9cLCevPNN9d+t+UtgJVVydxU5mnQrGr6r4tCtVl/of3kHq+lE21ZlioitxNCeZxEM7/PK664Ys/3bcYLC9cBh4ydO++8c8NBwPHHH59deOGF+XNKUKy33no9PELDAEMWKlDsY3Q11aMsXLEMCuvH2EqtzwBAtU0lpGIiCmIYGdCwHuJG8X/A/uW+yYAHF0nFAgGf3X///fn3Yk3VogQmUfRp5hyBwIBKcWOq7RpdY5VASMIuuuFqkUtvzIYcB0Eq/VKEssSq9ifIeqp21cBP9V4lakHXQhZgBlNYTWXhKCq1INdvTQJ0UqzKoqhyQtRsJBEX78XBkuI/eaTNmKyQ9SeWy9AgWBMI6aCr0UBKVmlZWrWu2lkTEzpXLRI9tK2s+XJDpY01WSHX45gROi4SteoTtGG0aPFd2p924D5AjLUjVjnf6PYrV/F6cB6xNE2/RRrtjlil3xQNWovET4ynt0jtLfJkwOVfGenVt/ltwdJaxhreS/T7FH+j5f3RCH6nokjth/dBJCZq6zW9Fsq9Fs3N4pSN6QQWrgPOEUcckX3sYx/L3vve92bveMc7siWXXDIfLPHHxyztmWeemf3+97/P12XAR3mWfvwgjzPRsifBpHqHciVWllCtG+N8onUwDqBjXJxiURW7ygBUsY6ycsqCphqMvIewI0YQFzRlJmZwq0RDsnKCBKcsvbKcIKyoxYlAZyClWFAJI+1XbsNy82X/WOMQ1LEOqKx8sUSJ3tcfrISJLLlaFNOo2K/YpnIzloVUljxlXQa5+6pMAttXjCrHIFduHYMmHNTuCHH2oYRYWkdWSNoW4amSNOkAQi6kbINBH20TLckqH6TvxxhcZXnmnBC1cZJA554Octl3kfBPBzRpfJraW+67smwrwVOcZOBYaAv1Z9WpJf47ZvtUaQ76rtpfbsqcE+uwD7ZLH5bVPd5nmmQgIZSEWCtiVTVUda+VqaEaLaq9tBA1Oge5AhcJCHkEKMM8vwlMhGhyoUz8XrSkRndf03oWZ/0+YGmNLtz0rbe85S35b23VxFi9cvltJkyUyyAuw57ld1xFcyvi2Nfa9ALXcR1wcAEtk2yJmMqTTz4522STTbp2LK7jWswxxxyTXXXVVRNKzjBjvssuu9QEmqyZ9ZAgU4ba6JbKI4N+WUsY+DCwl+CTa61Kuqi8iVxqZaEqqp/KfhgwydVSYgArFuKAa85nWAUkJpSIKSbaUGwvQkSCWNZYLUUCVdbcuETrNNtVuRkJUNpAgk0DAAlluTcrY2qa/ZFjUuIsBuG0Ae1WJDRjiRKdV2qplKuchIDaWuchN2W5TnIM6gvRqqlYUFlXBevLWqaYX4m9Rsjimsb26lFtD1HAxufyHFAiJFnldS1jkiqdr64J1w3hitBPsxsLZbNmP1wDJjlkPY5I9NIfNWlTdYCkyQ5ZVJtZimIWYtUzHgQUA4wAoq1SZOVWX4t9sxkSHdHd1yK1PejL/F6zyIqv2sL6LeP+XnbZZbOlllqqb5ZI7vsoUsu6/EYPIIVVGGNMN/FU2IBz0UUXZb/85S9zq+rdd9+du3byx8cfBoO4VVddNdtyyy2zHXfcsVZz0/QeBh9RpDFAZiAeRZDEhCxaEmWsL5Em5PKpwQDbYwJD8acqI6DERLKgRlGo5EuKU5MVTUmcZLWSBUlZcCVy//KXv2SXXnppzWU2JjnS9mVdhShWZSmMWXmjKFVZA5WJkVVTAkFCif6eWgVZOCa1l4SyBK3cfyVqNSBXNldQHKDqlSrmE+QWTbtrf3HgH+O6JDSjuI5ZmWUR1oSB0P5ivUK1h9yuVSZJFl0tEoh6HbNPy8IaMyWrHZqJvZh0RoPXmJE4Cl6OMx6LxCqiksk2lqL9ycKtCZg77rijZq2NyMUb65Pq0FYRq7RrTNJVpoZqtKgOmuWA/iZrXeyLmkCSlwTtqmzajVAft0jtXpwx1yteB/ok/wlcL90HTOwsscQSPf3vlstvFKnNPA4glt3RBMegxdwaY0YfW1xNaWxxLeaoo47K/vSnP01wo2LAveeeexZmGQWJMgYQGnwqo69ighhgIK5w78N9NLpsqbSA3JNBQkLuWUq6o0y+ijtVRsoo9lSeRbVE9d1oYdT5RWtiTH4kd+WYRTgmnZL1U26iEmR8XyJcWYALf6yS2qcgASyraix7ofbWAIv2kpjR9uIxM5BUHHHM2KmagwxEsTyrvq4SZkl8ar8q+ZNm9tS1kkDke0qUJGgbiacoVGUxjpbUNKlUWfezeG2UQZqFwbYGseqLqYVZ7a/jVJsp02lqceGYZM3ne/R5YqsRYKlYVZIlfmdwS68iVmMsLI+NrEWygKud4yTHIKE4dU2w6HdCng70S12DmF28kUiV4Gi0vmk9mZfi0+N/AfeP6hfTv1m4JsTTM3nYbStrnIjS/0ez5D1yEY9CdVC8Dowx481gTSsbM4QU1ZZTjKYsgAxkiDMlflLutlEQSNAxWEBA3HPPPblAYrAji6msXhJwylwqi5dK0GhgIoEq8cN3+JyBrwSIYgolhiVGo3VV+5A1UKInZg2WBVHiUd+RJSjGAcuVWQNwHusNpJThV0JX+9M+ZM0Ejk1CROfKZ8qwqraL2ZuVDVYWD9wvGXjKtVTZliWGipI1SbCxLVl/lQQqJkgCWWR1vNqGhKBqpXK8VRNdaHIgum2r/qGuG+3NtiWIVGe1yCKpbaldFZ+qckA65xTVZZRYJZbvpptuyvt/KijlKim3dARwGcuwzkOiu5ErrGLFZVHtdQ3VKnBu/D5QGgWRr/tDk1TKyCpPiRR5LkRLqkVq51CW8/jbpUnHevC7yrVSORjuDzwSirI6twt9JM3yW6a+bipS7fJrjBlULFyNaRMJMsU4KnkRbmFKhiThpOzDij8FfZcBK+sqJi1aPPVcVsoovBTPpv1HlMFYcW8axCpOUftim7I0RvGBqJAFt0igS0THhEeKJdWgTq6zsqzK8ihRlAolDZzkqqtzl/hNXXqjVVXXQ3VoEZ3aN+2vOF9Zark+iDgJSsULa8AnoZrGncqtF2Gm5FgqUcRxx0RJbFMWcx2LxK2y6sq9UJMFUZyrD8T3JOTjJEKseas2UDIeBLnEt44h1uJTX+JYZMXDTRmrp+Jro1t33G/cv6yXiFVczdl/OnBWkiXEKnGwzTKnyjU8WlQbiXp5HciiqgRfg4oySSNW+c0oOj/an0kDTW4AbZa6+1qkdobUuq3nZWOFuW90T0eBqtwBnZo4KXL5bZZB1i6/xphhxsLVmDZhUIwwiCVZ4Oqrr64ls1EZGF7LrVMClwGH4vAkbqOwkCiIwlBxorI+yZooVN8VUcCgV4JXA7EYoxqtp7KsSYBEYaPC8HGgzHFpUBddGGWJjK6oLNpGLIWibUqoNnLzjAN01S6VezPXACsVluo0LlfiUtZpCVMJyCiyo3us2kWiDEGHeJBAldVaglAxy4hfWbLjtZTYRBSyvTiATcVKLOuja6FrrH4Sy9CoH2nfsmSn1v24fSUhUpmjKPYQqhp808YSr8qqLPGv42Mdahen2VLjtcOFftFFF21Y+1aJYiRSed5IqMpqLotqv2qoliGWg+I6KQygKMZQ7uuaeErdfe262R7cE5pATAVqFW+H+FvGbx6PZNqOdXS5T7CyFlnJyxLvcy3NXH7lbWCXX2PMqGDhakwHUAylxA+Dir/+9a8TsgVH0SGrq6xREjUxaZFcPiU6NdsvCxLf5TOVc8EiQ2wgtXxVY5XvyOLLsbFOOqhX3CuDfllwNRDTI8cSkxKptEaRG1qsP8tgUAIJES1rpARbam1WPdKY5EiWRFly42CNdlE9WMXlxrqisq6mmXh5HhMeSZRKWGoQqlqKGnDGEkKxxqkmG1Qmh3MBzleJqtQOslymNX5jzGo8tig6FR+reGTOG8Eua4vaR2IuomvJ9aYfcH6yDNfLHqtjp+8UZbFtBtvFwsSgnYmUIrGlElCyqFapocoyCKVD6omiGJMuF35ZwIvq+6pOsDIoW6S2T/T+iAI1lskqgyYP42+jJq8E7vdM3sTfKBIw4QZfxcqq37W0pnUzirL8DuokjjHGtIKFqzFtgpAg46/cUDVQwu0vv8mCRRNkwWPwLYGq0iByeY0xoYqX1cBfM+1yWeU9xR7KSqbyKogBDc7iwElZqVkUoxmTCmmAzeBJbq5RpMriJ2GjwTiPiuuUCGe/ErPRKqnvxtIwfFexmSrHoeOJg0EGcYo/jWV21C58N3WRVvwo58ESEz1JOMr1WAM+bZtz0zHE49Yxsz1ZOuXWK1dm2pfBK4IkivBm6Lwl5CVSGXirdI7OQ8croSs3UsWl6jrLPVuTAHJd14RBbEedX3quzWDfCC8sq0ykpGJVVnhZVOljjYiJtnTPDBLyZIgCNa15SdtyzdJyPxJDEquDUsNzmIiZvyVK5YmhpFYxM3l8TN9j0e+x7pV4z8R1dV/qPV1fwTa4B7jvmqFJjphAqdm9pmR7McvvICYZM8aYTmLhaky7N9G009YscDEekcGoBkCy8DGY5bVcTiVIGdzEbK5CAkQWTlkQJTL5Pm6nDKwUr6mapLF0Cd9hH4qxYv8SnhJFuNhKfEXrXXRLldhRvGp0x1UGYQlZJZTSdurN/KseIMcn12UhN9yY1Elu1RKGCDO1E22BlVRWTfZLm6jGra6XjpPzlSWUNpRIbYaST4Gum+JDNVGhJDqK401LA8VYUR2rrPASOohz1exMJw9kSVYfo/3oc2Qr5TpzjVtJtBItyGmReQncooXP6ctYl6JY1aSFxGqzGqpKBiWr6iDFbaYiNVq6UzSBJFdriVR5SHBt6K+6f7V9XeNUUBU9L/teK98Z1H1Hj4z4vJnbbL3Y/ChUY4y+hG8rcN9Ty7tISKrWdBSqzWJnNRkXheog3RfGGNMrLFyNaZOYTVf1ULE0rbfeerUYSAYZKhuiBCsMXhnMY5klNlOWLwZhcldl4EvMoMSuBIEEK4M13NMktmJdTVk9JZB5zj5uvfXW2oBbMbj1iMKVc0wTS0m0xvUjsZZqjJeNxyVxEmupxmRMKjXBwoCNdowJl2I9WI6P+DLWpe0YIBYNHpV9VVZqEa0cso7KKhtfK6YWlAlXQhTxhniUCI9lgUQUPypDg6hDqGopEkQ6Fgl9LLnsj0dlzG3X6hJLF1VBli3OSSJVkwz1hAnIuq7YWu2Xz+VO2y/BFWPTZc2TmI/fjc8Vc00fVVZt3bea3JJQZVKCxUxEAj6GVOh5lfhTeaVEkarr0Q0XWraLlZXfFZ0H/SGK1GYTN6BazloGOW7bGGN6iYWrMW3CgILBCoNSDfhl+ZMLrgQM6yBUsAKqGH1MyqSyKGyT9eRiLPc3WRgRTVhgQWJKQg8hKusf3+V77C8t25C66UbrqVxdo7sq242ZaJUFWAP0mHwoClWJLYSW4kX1PQl1CWgdhyyOtIHEj6x9fC7hq9Im+o5iwSQioviSWFXiIcUURzEoEaVyMtE6qiRctKUS5wjWRUBy3VPBx/FInEqsci6yqLI9nqcxbMryK1dFrjvbl1CVS3M/Uf1XJguYQJFgq4dK/8jiqBhuWc36JeLSRD1ayrpGa9JEtXlj31D/kDt/2dq0o45+r6IojRb9dF3QBEBaIzmW64r5AaJAjd9Jn5d9r9Hn+j2k3zz00EM1N/hmfSj+Lmmxy68xxhTjf1BjOgCDDcUBMgBTKRKeY/mL2YVVskCDHgYpsp4BYkYCUK7FCBb2IRc2ZYsUMa6U7yL2sOLG+MQYo6hMtxJHipGSkIjxYTG7rb6r92Od1VgyR4NSBpKypNIWlPyIMZQxPo33FSurWrcSyhLnTAZgcWWfMbY2tWLo3BB3EnuIZp2jXO2iq249OFdqkCLMZFFWW7A93HI5JiXMou0lUhWPzPuKyZU7d7ROy+1Z1iFZg+kTLLr+/R7QygqqBFS0CWKzXq1IuYGr3WPZon6RilT6eZlEPXIPj4l5VHNXln3VAwZNbiBYda+2K446+Z1e7luhBWrrmMhO1tAyGXclTtOl15MBqucaLfHNJm3UHqnL76DFbBtjzCBj4WpMmyiOMma15fkNN9xQi0nVQGfCzTfttLlgRVTJ6oR4kwBUdlieK9GSRKASQGk70b1SMbaxbI4swbJEaMCnQZMy1LLIsqrv8lyWUIlIBuRy45VQlyCPNUYlYCVU07IxiuuU4AeVnpGVU7VoWdi/9sf3OX6Eo86Fc2M9XHURfFFIVIWBKOIfgZaKGvaBEFZpnXvuuWdCrJrq90qsxiRZug5pEhi2J5HN46AMaGOsJotEOIvOVwI11oiMNVT7JcLk7isXTQmNGDMYLXfx+0oKpUkdJb9hW4h17nn6b5p8R9moEaz9Fum9Jk7ORct1o3CEFLV9/J3S0uv25Ljjueh5mXquoLrUMYGSXX6NMaZ1LFyNaRNlzZVoVdwlyTlkdVNcJ4MvWekQVqr5Cbi+aqCtODqJNLn5yrKljLHKIlyU9EeCSANA9h/j8+RCHOtkSrDyGhGrpEqKmY2ufEq+pPOSG58SpehznmufEsM6nrTcTXQ3ZuCPAEUkRmtNUXkbzhWrJ0s7YhUQZwhW2l1IWMtaG2NcVc4FMYOYixZgzkcJeWIsLttBnCpGFdE6SCKHc5KrtmoUcy2V6EoWe8UoE9OtpF/9GpjLGyFm9tVkSqQoqY3uy7hE6zbnjnWZpShGkeuKWGUZ9aQ5cu8tEqhVEiTp3kgFqjKJ9xLOp0igVjkfeU1EoWq3cGOM6SwWrsa0iUSf3HoVfynLHwKMRQmVEFe4nuJKjGhkfbnHyhrEQFmxkLHIPdvRwFilXaJwjaIwllKRS6zeK4rfU71OWUSVXbMoc6fEpizFqimr2FZluY2CQAlGVNaFc1OcqY5dtWgRALSFYlxBMajdEKucJ8KT66KJgmgt4tqpBq7q4rI+xye3Zp0356xJBVmN5QrOwqRFGbfIXqOMypwf56T+QRvIvRliUi0EN308uq33Q6TKolomJjX2yRhnm8K2aA/EamwPoczh3NODeD3bRd4URQK1TDsL1YZOBWqvBb4Ed5FArZLwKXUX13OLVGOM6T4Wrsa0CYNerGZR3DGYUQ3LmJCGhEy33HJLvg4DbiXmAQlBJUdiMCzBKREp4SjBJzGnMg6ppUL1TtMC9oodjSJW+5WrsdyO5f6rzK8a6MuKzPsSzBLuEgJaRyVR2JcSUOmYOT8EEMKQzzneO++8s7CtOylWgf2RWIhkKjo+TRZISCM6ES633377hGy/cvPl2CVSgUeOT9ZUlkG1wnGuileN7swgl1jahOtFmRtZIuXS3IvkUBKpMblVFZEaXX3LxNiyfbkCF7mEKm6aazxIVvJW0YRVKlDTZGHN0G9AKlB7LejktVJ0TlUEt35fU4Ha7zhzY4wZZyxcjenAwE+xobIcKu6UAT8DHqyrN998c63kCWIV0aiYQIlTZZhkUKz4Oj0WxXnJOhpdd5XpNWaqVQIkBm+KR1U24CgyY9ZgZSaWWE0zX6qsRFoLUc+VhVdJjSQchKyYsmxh7eymWEUASfggSh588MF8n7G0SbRwc0ysI2uyrKmxLJEmJbAQI2awPnKcgzy4VZZjTWhEaANEOouSYSkuj74iq3Gs09pJ4jWqKlKV/KmKSBXcC/QJBCv7TKE/yxV4UGKPW40/TQVdK/GnRQK11yJecf7p+ZRJtBVJ42n1fBQmJYwxZtSwcDWmTRjgKLaVQaCy6T755JPZXXfdlYsEJV6SeyxWPBZZHZWcR0JBZVBSASQBERfWYcAWxZ/KzyBMJERUA5H1EaMx9jS69PE9RKVEKccj174Yj5p+JiHLAFLulSlK7MQxIBAQht0Qq0VWOr1GoCDelRiK9/U6ZhpW7d1YUkMTC4pPVf3UQR/kyu1aFuN6ghGRTt8jPlvQDrg3c86dPM9UpJatcanJgtTdt+qxSaTL5TsVO+yH6889qRJVwxR/2k68pn6TUoHaj/jTaBFOBWqrCZ/0yHuDfu8aY4z5DxauxnSAmAVYwo4BMYNxBpLKjouFUfU3lVEYl2Lel7uptpEKVO1D7r+4HbMokRD7kWuvrCsSqgy8EcbpQI5BP/vmM7nvxgF8kfuxYNvsV/uWlVdlbHQeEtEMFvmMY1bsZyfEKscbRWoa7yiLLlZvHpVBmXVVngJxIpfrmFlWrqYxidKwZAalHZQJuJ4gVNwzSxqnyXkqRrvd82X7Re6+zYjXIMZKtyM22C/3JkuRtZF90R+UNXoQSd1hY1mfKvGamqxKRWo/XNvlEZK699YrtdRMcKcCdRjuWWOMMY2xcDWmTTS4luUTUcTgkUE6nzHwx1qFQMVyRawggiC11MlaomRHPMpyyTZ5xFqIaE3dJ+U2JyuESnkoFlYDfyU/YuGYmsVsSSjH49Jz9idhlLpXyjU5xlGmbZZaL6N4V53blFjeRCK1KHMs+0ZQI+oRyuw/Wpg570UWWSS/Bjp/RLbib1WSBusw7w3DoJdzUxkela0pQm7nXEPW53vR9ZdJBvXPVlD8duru24xY87VTIjUek+rOpu7RwPnL4yEmAOs3qbVRok6TVFXjTwchoVB0WY4CtYrLskIZigT3MNyrxhhjWsPC1Zg2QSTJ7VFuwgyAV1hhhVyQIVQRrAyMGVhJACKq9ByRhThVgictGtyx7dQ1TgNAHjXwZkGwapFYVR3Uqm63iLo0NlWuwBw3+0Bsyg1aWYkleIsGoxyrXKWV3EcCOBW2IIugSuvIAq0BqsoGyR1YLtMq5wNy/VVNWMXtqu4rIpVrJmv4sMC5K26a9qtXX1LxxLQD62JtjNCW9B36aRnhpuuhiQxNZqRJwMqKVLn7dlp0RFfg1BLJvnTt6Yv9FDyq/ZwK1FbjTwchXjO6LMdzK1sDFVQ6ahAswsYYY/qPhasxHUDJhyQmEEAIVwbGDLIYQBPzKnEXS8xE9z6JMFkUNciT5TQKMaxiCGNZTjXwVgytxGonrCocH9be1GLFvpSRWC7BcX8SOBxbLD2i849xd0WlN4qsShLFEsgxzljiXxmaZU2VFVHZixWbKvfoYYK2pj8pyVdR7KJqrOJ2zfnK+hxr00LMEKx2kKt5FKXpUiVeUiI1dfftllDk+ssVuMjqrBq69IVeWxzTciytiLnUHVaCrl/usLpv03u3Sh+Rt0MaU9utJGDGGGOGEwtXY9qEwT8DRkQBgy1EK4KRgRtxlRrY1Ys/U61UiQVgwIbQ0mCUgS37QYhES6VQtltZEzs1gEWkIlYRrfHYOR65mSpJU0qjmFVZSBFgiC8WWY/ZtlyF1TZqP7n7auE1x0HbR+uUSllgQVx88cWzSZMm5UKFY0FADZtLIecZa6wW9SMEDX2Dc6QfcH5ctzvuuGOCq64EhUr98Prhhx+uiVIlGGsFxQyn7r7dbmvaQ5Zk1f2NqOSSkp91E00+FQnUKvGnqbVRoq4fEy06p6KarlXOKbosx3NzDVRjjDFlsHA1pgPEwRcDPAQD9UEFA3clKlLyJlkdGfghIJSVV7GuDBBZT5bBaH2QRU1itZMlOhAyHD8W4piBVhZNji1mB24mVpW4KcalptYYiRz2IZdf2oq2QUjxGYNkxUvynrIlA8cjq5Osq8TxxhjW1B1ZrsMq35M+77ewpS10zJxnkZjk3LgOmtDgmGm7++67L4/tldVertz0J7mOcy2LRF4jlGSs3tJrqx8TFqq5WiSgOE/EaicSTKUorjwVclXLsajvplbUflgbY9Kn9LyqlpgpEqiDmuzKGGPMcGDhakybMCBGiDGQRRgw4MSqt+CCC04orxJdMBETMYuvrIYIFFltcWeMlgiJRRZESqfj1tg/1lUsVxIBEqt8xrEgABBJ9cQqx6hsto888kj+vJ4bpAbJqinLa2UxZlG2YIlctk2bsT/EAfuTBUdWX8QqbRfbuR6yMKbusyIVZL0QthL5LEWiUu2kuFCOg3PFsn/PPffkj0WlXVgfd+A0c3BKjAUuWoqyQfca2kiuwEXxtIoxZ+mE+FO221TIVcl2W1QvtJ9iLtZATc+r1ZjaeG4uMWOMMaYbWLga0wEQkxJJDNoQVUsvvfQEFzsGuhIAvFbcIcJD7sUIrzjoQ5y0mlipDBwzAgDBqkGrxKqsfIhVRHgcYDNgjfGhCNR65UUEn0mkShgri3Cs6RlFlyYB2LfKfcjdU26oiHhcgmmjFERvTB6UPi8jbOtRJGzj87ICT+WNlGBJ1tFoKYVYFiZmalZ5F65ZKli5RsqU28xaqprCgwj9g/PlPIvqA8uNnske2qgV5JKeCrmq8af1BGo/BL+yEsdzUlbiqlnTU3E6LNm2jTHGjA4WrsZ0AAbLDOIYQDPQRXDFkiQSZqp7yrqIVaxgMQawG4mVimDwj1iVdS6KVQa37BsxqFhaiajozsz368H5ShxKTHFubE9u0LQH29DnSuKjbLOsq/qfPKpcjiyyCBWOsZGgV5xgvUy58TiLxG07wpZ2ipZaiUK583LuCDHF56b7UvZlzrvo+OUmq1JEsW4u/YrJBrmYy/I/bGhCBFfgomQ/nB9ilTYqI7rjRFIq6KrGnxYJuX65mBdZhatmJY5Jn+J5uQaqMcaYQcHC1Zg2UaIgiR4GwIhSuf+y8FwuwAsvvPCEmNRuJVaq52KpUjZRrCJ+VDqHRz7nmPksJlSR0EuRa65EqMoC8V0G0Kq3GmPlJMwkLCXymARQrCv7i21VlAW3HVQPspGwTWvrFglbxeKmltL4nurPyn2ac1H2Y4lO2l6Zj6Mg5zglPmkXEjWxDdpCrugSrGRMHuZkN7QXQpW+GmOsBf1BrsD1+kB0hY2CrpX40yKB2q9JAGUlTwVq1RIz9QSqMcYYM8gM7+jGmAGrpSnLJQsDb2IOEWFYhXABlpjoZmKlomND5CBWJXaiWJWVE6HEYF8W0LTOapGYU9Zf1ufcouBkIbmTRK72I7dVJbPi3GPNWY6LGqyppQiBgnWV7/cyJlBWKIlLCUwtEqOybsXY2ljWqCghlerT0gZyCVe5ILarEkKqlSsLq2JcZWHkM7XNoLr6lu2nnB+PqbiU+z3nyL0jNCGQCtRW4k8HKZlQ6rasxyolZuir6fnwfBgt78YYYwxYuBrTAVT+IsZlEuOqgW9MrBQz3XbzeOSKynEhVhEEuAYzAJaFjkeEFYILoYowSMWqStBE67LW4XuIMrbNdiQYVI4G62F0N+Q55y+xynp8h1jfBx98cAp3TdoRUdaNrLCpEG+0NLLScS2V9EiJtpR9WTG8ir9V0inaRtmiG5WLYRt33333hIRZgu+SPRlBJ2t6jLUdBhErl2kmeoqshrQrfZJ+oBhp2kJCroqlMcZqRkEX3bh7ScwengrvKm7LRVZhng+z1d0YY4wpwv9sxrSJYlsZXGuwqLIs3UysVDQQZlAvIYDFEzGDWJWLpCzAshymltUoUEGZkiWsJNBVKkclVpQkKVpTgfNGfEisxsE0Au+hhx7KjzkFoYpgbZYFt0ybyAoal/heFfFTBOcU4yZVwkhZllXnV/GqLGqHKJqjGzKWZ7Iycx1T0Swxpz5V1H6g2NZ6WZH7JWzlkRDjc6OQo02UhIrnRRMaZV1ho6DrV/xpUV3X1G2+DHLZTwWqS8wYY4wZFyxcjWkTBsPK9CqxgGvwcsst15O2ZRCMAPzb3/6WWy6VeZVBsVx0EVE8cmwSq3HQy7pRHGiAzznJ9ZcF66tKzxBfGa2p0bVVSzqolksox5mWoUFIIcgQrGXdp2PW4KKF468iDlI4/qLsu7wvF2Csq5q4iBltOR8mLVQ3tUhgxIQ4wLZoG8Qd8aq0sWJkEcMqgySR2yyLsyziRchVu15W5E4KW64BfVKJljj+GDfMcbJP2ok2pC/WK1OUWhpTgdovV1jFf6cCtWpcrdyWdT56HAYLujHGGNNNLFyN6QBKqhSzA3cD1T5lUI9FDrH68MMP569jDUZEiaycDHwRBLLSyd1X8bjptqNQBSUvUnZbnRsDaVlw2Q/P6w2uGdQjWhBlaXInhAYJhdKkQvWspXGpEvOXwrWKVsl6AlVwLIrDLCo9A6wvq2rZWrtsB6s4bZOKTI6P7MCI2CJBlro5p8mjGglbXf8ywrbIatvs3Lg2WIMfffTRvL4s+0mPCUGmtqp3z8T40yjk+mVppM2LrKdFScua1UBNraf9cls2xhhjhgELV2M6QLcGmxKSSvKDaMJNFzGAeIpiVZZfhCQikPhSxVAiIuTOmg7AVZqGRbGpfA+xlGb0lSWVz9lXM9dLRArHy1JU7gVLMNvjM4RbKkzbQXG89RY+b3b8HAOiEgFWzwLIdjgPBBjtUtYdtZGYV4ZgLK6NBFpqsS3aB9egqORPJ4RtFLJcTyWkIsEWLutFWYE5H7nQ67jT+NO49EvIqRRTO4mfdF5FAtU1UI0xxphqTDW5HT86M1YstNBCuXVv0qRJuWuq6SwxC210zWXBvZK25zGKT1AJFUQOAkpZV1OhqIG4ts0AXNbUoni5aLWV5bbsYJvt00ckRmOJGEQO241utVXhOBqJ0nZcXWlfidUYgxlh+whV2ls1fMtCWyDsisQ8bayES70QNoorrVfLtkikyWIv13K9Zl0s0kXWaNUt5ryYVEnLy/RTyHENigRqKzVQU4Har7haY4wxZhSxxdWYPqA6qRKRReVSiAlErOJmKcsVYhKhisBE/OH+i+VKiVtAYkgDcu1D2WzlOpzGkbKNmEipnhVP2y5y3UVYYw1GwESUnAgrYqPtlrWWdjqOkfaRWE0nBlK3VsRXK8m2EISKQY7xxFwX2pu2oe0lAqNA1PO4dPt9oJ+lrseKrdVkRBF8TwnKEOK4OyuLdL9QVuK0DmorNVDT+NN+npcxxhgzLtjiakpji2trKEFOdPmtN1hmIE3sKoKVwbVcWoXiSlUiJopAuXUqIYyy/daLCURYSKTyqMG33EsbxZamwguhqqQ7RfU3sQjrPHivmShtxz20rEjDMohYVYmgKNhi2R8lRaK9WhGCXBPV0U2FoSYfyoj5QURxyBKyXDv6m9yce5FNOyVmeI4CtWoN1NR62s/ET8YYY4yxxdWYjhKz8EqkNnM5ZMCvmqtYWbFOauCsQTgiFRdt3CwlchR/KWuqrEGIxCILENuTJZXPZdmTtbFeeZgoxCAmd0KsYqXkebTSsQ8lXELwMeDnnFj4PAo4WW+rWAObWQqL4DPOFcHKUm/yINZYpZ2UZKgqxMQWxXlyfbmeCNZBEkJKLhYXlUIq8z7vqQRUt+NSVWKmSKBWrYFaJFBdA9UYY4wZPOwqbEybMFC+7777anGjzWBQz8CYwTZuwLjW8l1ex0y5WFZxs8S6ymCagTrry+Ipd1o+QzgwmGcbiF/EskSiLJgq15HGJtZbtE5E8XoS52yfRaJUFkQlKeJc6sWJ9gLOlf3TJgjJIqtbTGqlGretIuszkxCasJDI41rRNrI+NxOHVYVju+8PIsp0XSRQq9ZALRKoroFqjDHGDA8Wrsa0CYP/W2+9tVavMS4xWyqDZCx9CFXcgRE4qdVP4kblTxBd99xzT74txA7vsU1lfNWCIFPNUSycLK0MymUZ5VGLXrMfLLOcg1yQBYIPQdZN19CyYkzuuRKrug4x4y/f5bVK16hdWxWCCGSsqyyq3Sq49kw+0D4udVIM7VckTqvWQC0qm+MaqMYYY8xoYOFqTAdAvGAJjYNmlQcheywWWQQrQip1ZUQYInZws0R48jmiVuKI18ourEF8FMRYZstk0eXzKEiLapimggwQgVgQERRRACKMEWNyX+60NbCKRRBRTZvh0it3a5VciefPa2JuG9UNrQLXXBmCdV11rLhlKxbZ/Bv6cD2BWpa0dE4UqINqOTbGGGNM+1i4GtMBiD9FxDEIxyJJ9lhElGJQ5aKrRXGsCCkEDkh4yvUWJNp4D2smg3QeZcGNIk/iUzGssrxqSa2KZWuMsi6JdgTbUfxqP2MBccVVcqWiEiygNlaZoE5ZPOXmzTVO94tQxcW7nXI/ww4TCUUCtUoN1FijNgpU10A1xhhjxhMLV2M6YEViQI6IYUHwYf3D8qd4VESWBuKIqGZWPyVnQvzosVkm3k5YmzhOWRDTeFCOQy6v/bJsMQEgsYr1ugjaQmVrmBTo5LEikBGsXNuIxH3Zcj8paUxxmgirzHutftap9eXui1CtUmJG2a9T66lroBpjjDEmYuFqTJswYL/00ktzUaMETXIbVYZd4laxUCKkUisloocBu+ItZR2MorTbSWQQG1hXyRKcWhAR2AhW1RhVRt9eCSWODaHKZADPi9annThOFkQ+7yMuWdoVaSzsnwmJmGhKmZxV7ofrL0FbtS3GAdqqnkA1xhhjjGmGhasxbYKIQ/AhbGJCJlx6VR4EMSUBKrdfJfFRbGsUMsSVsnTb8obY4riVxEifcw4cF4JMArCXYLljnxxfPfdSiVUENe2tjL4snbquCFaubVrSiGtJ23D9sBiqlqn5d9sUxZ8OUukfY4wxxgwfFq5DwPXXX59deOGF2VVXXZVnr8WNk0HgggsumK277rrZ3nvvnb3jHe/o92GOLVhQETlcEwQqVlUlBiIeTy7Cik9lkdW11Rqh7SCBhyBLk+JwrAgylWzp5TGplA8iup4IpB1Vtoa27QaxPm2aSEvW8xgvK1fk+Fj2vVFaX3HWroFqjDHGmG4w1eRx8lUbQtZff/3syiuvbLre7rvvnn33u9/tqtvdQgstlD388MN5IqKHHnqoa/sZRk499dRc7CBoZGWSSOV1v+pFRsGBSMaCiCBDnMXP6DcSrDrWbgsgQKRiVUVIx5jauL4mArBuxrjHTh8PIl7u0ulxsG/cpbHwOnOtMcYYY0zvscV1wKHeJ2Bd3WGHHbL11lsvW2SRRfJB/jXXXJN95StfycXkaaedllupfvjDH/b7kMeStddeO29/RBZW17SMSz+sYAJBRsIlaowqMZTgWFWypReCDAsmVlUlWKIf01bxmDgOJgB4D8HabRdTxDOCleOBmNEZIU/7xJq1xhhjjDGm99jiOuBsueWWuTX1ve99b6HVDjGCu/Cdd96Zv77iiityK203sMV1uCBGVmV5UmRBVCmeboI4xaKqBEup+y0gXrFmKkFVLyzUHA8ZgmmnCPtWhmAnDjLGGGOMGQxscR1wLrjggoafM8DG6rrVVlvlr88999yuCVcz+CgDLoI1FWSIQwmybsWHClyRZVWNmX1TgSgXYB47VWO1TCIt2ocEUBEsu4h52qhfrt3GGGOMMaYYC9cR4J3vfGft+T333NPXYzH9AUGG9R2X4DThEoIMsYog62biHFylse4iVolbLYL9y6ray3hRhDRJzWiftMboINSnNcYYY4wxjbFwHQGiULGlaLxALCLGEGUxuVGvBBl9TwmfUgtvFM7EqyJWcU3upTiklA7WVUR96qJMHC3tg7XXGGOMMcYMNhauIwBxrWL55ZdvaRtlsgSnwsj0D0rHKANu6oaLJVMZcLu1b4lVnheBK7LEKgmges2LL75Yi+9N24fjmn/++fOMz8YYY4wxZjiwcB1ysCIdffTRtdc77rhjS9tZeOGFO3hUplsQL4og4zHS7Qy4WFMlVlNXZMF+EaoIw35l4aVdSLiUuir3Mr7XGGOMMcZ0HgvXIef444/Prr322vz59ttvn62++ur9PiTTYbAYKqFQauHENXzeeefNBVkny8awT8rEKMESLrdFYE2VWO2XIGzUPsTU0ja0UTfje40xxhhjTHdxOZwhdxHeeOON82QzDM5vvvnm/LFbrsJrrrlmbs2aNGlSqfVNe3BdlXCJWNYIIlEJlzqVjRcBiKVSCZbSJEYxNlQJlvpZLgbXddoHwVrUPlif55577p5kKzbGGGOMMd3FJogh5a9//Wu23Xbb5eJixhlnzM4555yWRatqtDbDiZ96A664iLGnnnpqioRCWDgRZIjGTiQ5Yvu41yJWqbFaFMfMfmKN1X5bLhslpKJ9iF8l4ZIzBBtjjDHGjA4WrkPIfffdl7373e/OxQZi8kc/+pFrt44AuOYiWLF2puCKi2DtRKIjxB4ilf6DaE3FMWCljDVWB2HSolFCKo4RwUrWYmOMMcYYM3pYuA4ZjzzySO4ezCMWpZNPPjnbZptt+n1YpkUQYAhVBFlaTqaTCYWwzCu5Eu7AqfADxCkCEJGMhXVQXGw5XtoHsR2h/+MKjKDH68AYY4wxxowuFq5DBPF8m2yySXbvvffmr0844YRs99137/dhmRbAyqn41TRLL0mWlFCoHUsnCZWUXCnNsitw+1VyJWJXB8W9tpGg71ZCKmOMMcYYM7hYuA4JWJs23XTT7NZbb81fUwLngAMO6PdhmQ7GZ1JCBushZW1aFZCIYCVXSgWfIKGSxCqux4MiViXoie1FsKaCnuNWwqVBcF02xhhjjDG9w8J1CHjxxRezLbbYIvvzn/+cv/7Upz6VfeITn+j3YZkOxWfilosg47HVbUuspuVgBK7GCFWWmWeeeeCuHa7MEvRpNmMEPfGrHPsgiWxjjDHGGNM7LFwHHNw9yR78+9//Pn998MEHZ5///Of7fVimJCQ/QrDyGEGAYVlFsCLMqoI1VWI1tUwKBKoyAbeyj35nUG5X0BtjjDHGmNHBwnXA2WWXXbKLL744f77RRhtle++9d3bLLbfUXR93ymWWWaaHR2hSsKgixLAgphbQVuMz2SZZhyVW07qlAtdfLJOI1XYTOnUThDeClfNJBb0yKA+iZdgYY4wxxvSHqSYXpRc1A0NV18hFF100u//++7tyLNR6ffjhh7NJkyZlDz30UFf2Mczg4oqrK0sqLBGRis8sm62XWxNLrRIspS606h+UgJFYHfRkRcRqP/bYY7kIL8qgTBsx+WKMMcYYY0zEFldj2gRBSXmiIndXRCVijDIzZSYh+D7iDqHKY5rACdgO7rOIVbZLZuBhsEBjYX355Ze7kkHZGGOMMcaMNoM94jWF9TbNYIGQTEWr3F1x3W0G4lRWVSysqfiVRTLWWB0Gkcd5YX3GZTq1QFN3VRZoJ1wyxhhjjDHNsHA1pk0Qkbi5UpeVRyyIzeJLEXKxxmrRBAXbVXIlxGpZF+NBSCimDMH1LNCckzHGGGOMMWWxcDWmAyywwALZggsu2NASiqBTcqU0xjO6zkqszjbbbENljSQRFfGrnGMqxDkfStqUsUAbY4wxxhiTYuFqTAeoF2dKTCdCFTFHPd4iSEak5EoIu2ESq41K/mAhxhUYC+sgZzg2xhhjjDGDj4WrMR0GgSqxmiYjijGeEqvDWPYFiyrnh2BNBTkiXiV/Bj1xlDHGGGOMGQ48qjSmA+D6K7GKS3ARCFSJVYTrMELMKrG8CNb0PLGqIlaJ8x2WeFxjjDHGGDMcWLga0yYkWrrjjjsKPyMZEUIVwTrM9Uk5RyVcSkv0IMiJX+U8h83N2RhjjDHGDAcWrsa0CQmVEKhYXRFuJFVSgiU+G2Zwdca6SrmfNOES5XmIX+V8jTHGGGOM6SYWrsZ0AAQcLrKIuVGI60SEI1hxf44gzOeaa678fGeaaaa+HZ8xxhhjjBkvhn+EbcwAMAp1SbGo/uMf/8hL2rzwwguFtWoRrMNuRTbGGGOMMcOHhasxYw4Jl3AFxsL6yiuvTPgMkSprcqMatcYYY4wxxnQTC1djxpTXXnstT7ZE0iWeR3ADRrDiFuyES8YYY4wxpt9YuBozZmBVRaxS1gZra4RESwhWYnWNMcYYY4wZFCxcjRkTXnzxxTx+lVqzKZTroaQNpW2MMcYYY4wZNCxcjRlxSLhE/Orzzz8/4f2pp546j11985vfnM0wwwx9Oz5jjDHGGGOaYeFqzAhChuCnn346F6wvvfTShM8o14NYnXfeeUeidI8xxhhjjBl9PGo1ZoR4/fXX89hVBOurr7464TOsqsSvzj333Lm11RhjjDHGmGHBwtWYEQCRilhFtCJeI7PMMksev0rCJWcINsYYY4wxw4iFqzFDDG7ACFbcgnEPjsw555y5hXXWWWft2/EZY4wxxhjTCSxcjRlCSLSEYCXxUgSLKq7ACNYZZ5yxb8dnjDHGGGNMJ7FwNWZIwKL67LPP5iVtKG0TmWaaafJkSyRdmm666fp2jMYYY4wxxnQDC1djBpw33ngje+qpp3IL6yuvvDLhs+mnn76WcAnxaowxxhhjzChi4WrMgPLaa69lTzzxRPbkk0/mzyMzzzxzLljf9KY3OeGSMcYYY4wZeSxcjRkwsKpiXcXKirU1Mvvss+eClUdjjDHGGGPGBQtXYwaEF154IY9fJY41TbiEZRXBiqXVGGOMMcaYccPC1Zg+Q2ZgBOs///nPCe9PPfXUtYRLxLIaY4wxxhgzrli4GtOnDMFKuPTyyy9P+IyswIhVRKsTLhljjDHGGGPhakxPef311/NkSyRdevXVVyd8Rt1VZQjGPdgYY4wxxhjzb2xxNaYH/Otf/6plCE4TLs0666zZ/PPPn80xxxy+FsYYY4wxxhRg4WpMF3nppZfy+NVnnnkmdw+OKOHSLLPM4mtgjDHGGGNMAyxcjekCzz33XB6/ymOacAlXYATrDDPM4LY3xhhjjDGmBBauxnQILKpYVhGsL7744sQbbdppaxmCeW6MMcYYY4wpj0fQxrQJMat///vfc8FKLGsEq6oSLmFtNcYYY4wxxlTHwtWYNnnttdeyhx56aEIM68wzz5wnXJpzzjmdIdgYY4wxxpg2sXA1pk2mn376bK655srrspIZGAvrbLPN5nY1xhhjjDGmQ1i4GtMBFlhggVywzjTTTG5PY4wxxhhjOoyFqzEdwBmCjTHGGGOM6R7OFmOMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDzbT9PgBjRonjjjsuX4wxxhhjxoWPfvSj+WJMN5lq8uTJk7u6BzMyIMiee+65bPbZZ/ePU8JDDz2ULbzwwv25MMYYY4wxfebBBx/MFlpooX4fhhlhbHE1pfFMWjnmn3/+bJpppnHPMmPD66+/nj322GP5c/d/M264/5txJvZ/Y7qNhasxHea6667zjKMZW48D938zbrj/m3HGHmemlzg5kzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGmqkmT548ud8HYYwxxhhjjDHG1MMWV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMaYhRxxxRDbVVFPlC8+NMcYYY4zpNRaupq8899xz2dlnn53ts88+2aqrrppNmjQpm2GGGbLZZpstW2SRRbKNN944+9///d/smmuu8ZUyI839999fmyDo1DJuEw333Xdf9uMf/zj7+Mc/nr3zne/MZp999gntYQYX9//2eOaZZ7Jzzjkn+/CHP5y9/e1vz9785jdn008/fX4PLLnkktnOO++cnXnmmdmrr77aoStmOon7f+u89NJL2eWXX54dddRR2fvf//5s9dVXz/v/jDPOmI8nec498bGPfSz7y1/+0sGrZvrBtH3Zqxl7XnzxxeyrX/1q9uUvfzn/w03517/+lf3zn//MHnzwwezSSy/Njj766GyZZZbJB+L8AQ/jIDQe8+TJk/t6LMb0EgYVCEnYYIMN8ted5NFHH81WWmml7Kmnnurodo0Z9P7P/+Quu+ySXXzxxfn/ZgpC9fnnn8/uvffefJL405/+dHbqqadm66+/fseOwZh+/v5/85vfzP7nf/6n7udPPvlkvmAAOe6447Kddtop+9a3vpXNNddcvnBDiIWr6TkPPPBAttVWW2U33XTThPexsK688srZvPPOm73++uvZY489lt14443Z448/nn9+55135rNpiFksKsaMElhGDjjggIbrXHvttdl1112XP19wwQWz7bbbruH6a621VjYOvPLKKxatQ477f+vC9YILLpjw3nzzzZetscYa2fzzz58L1xtuuKH2f4tl713velf2s5/9LNtyyy07cOVMJ3D/7wwzzzxztvzyy+deBnPOOWf22muvZQ899FD2hz/8IffwAyZwbr311uyqq67K290MFxaupqfwp7nOOuvkolRWSGaLP/nJT2Zvectbplgfy+T111+fnXDCCbmb0xtvvJFba40ZNZj9/cY3vtFwHTwOJFyXXnrppuuPG7POOmu22mqr5YJ9zTXXzF5++eVsjz326PdhmRK4/7fHm970pmz33XfP9tprr2yVVVaZ4nMG6XyOOz2D+V133TWfDEbkmv7j/t86/Bd+4QtfyDbddNO870877ZTShv8CvPw+9alP5ePIm2++OR93+j90+LBwNT0DN6YddtihJlqJPzjrrLOybbfdtu53ELYMQE877bTcyorINcaYCIPvW265JZ9pn3rq/6Ru6LRLmjGDBnGsn/nMZ/L4vUbWo3e84x3Zb3/723xgj+WJhYE8cYHGDDPbbLNNvjSC8eahhx6aj0MPP/zw/D3GlYSr8ZkZHpycyfSMY489NreeCuJsGonWlBVXXDF399hkk026dITGmGFkpplmyj02omg1ZlwsdUceeWQpl8fFFlss++AHP1h7/ctf/rLLR2fMYPFf//VftefEft999919PR5THf/Lm55lffv6179ee7399ttnO+64Y+XtzDLLLNm6665b9/O//e1v+ezz2muvnVthmI3mkdfMshEf2wysNMpCuuGGG9beZ7aaxFBLLLFEPkM399xz5wkucDWpl6kxbitSLwssrtRFWQYZcESXL7IwL7fcctkcc8yRf37IIYcU7v+iiy7Kf6hJbMXAhgH+oosumsdGnnLKKc4wOeLcdtttuTsUrrO6H4ghf9vb3pbfJ4888kjpOLpvf/vb2RZbbJHHohNHNN100+X9j35IzPoXv/jF3OpZVEpJiTngiiuuKOz7sY8b4/7fHeL/Z/y/MaOHf/+nhP+/COLVDBmTjekBp512Gml0a8tVV13V8X18/vOfnzzjjDNO2E+68PnRRx/dcDuXXXZZbf0NNthg8iuvvDJ53333bbjd1VZbbfKTTz7ZcFtllvvuu6/2XZ7r/UUXXTQ/jv3337/wewcffPCE/T7++OOT3/WudzXd39JLLz35uuuua9gehx9+eG19npv+Ea8FfbMeL7/8ct5XpplmmobXf6aZZpp8wgknNNzn1VdfPXnSpEml+/Crr75aeLzNFvp4p0nvPzPcuP+3z/nnn1+7H2aeeeYObNH0Cvf/9vnzn/884T/hkUce6cBWTS9xjKvpCVgrBRabRlbTVjjwwAPzlOgxSQtWHrIqElN72WWX5VYjAvSJc+C9448/vtS299tvv9ytGTdELFVYmAjux235jjvuyNf585//nCe+uPDCCyd8l7q0yhQbj69e9thG7l4f+chHsu985zv5c0p/EKuE1YsEG9FFkizMtO8999xTe48Mexw7Nc3IpvfHP/4xf/+uu+7K2+nXv/51x6+J6Q8vvPBCnqTi97///YTrT207Erg8/fTT+WdYW/GEOOigg/J4NyyzKXgosC3NStPfiDlfaqmlcqsr+8JqQ/ZvZWyMYOmlrz/88MPZeeed1zAbMh4Mxrj/dxeS0oiFF17YHW7E8O9/fYhvZfwnqO26wAIL9OS6mA7SU5lsxpYll1yyNsO1ww47dHTbZ5999oQZtD333HPyP/7xjwnr8PoDH/jAhPV+8pOfNLXSzDDDDPnjmmuuOfm2226bsN4bb7wx+atf/eqEbV5xxRV1j7Oq5SdaXGU5W3jhhSf/7ne/K7Swife85z21780yyyyTzzrrrCnWx8q6xBJL1NZju88880zhcdjiOlwz7rvvvnttnWWWWSbvzymvvfba5G9961u1/k3/wrKacsghh9S2td56601++OGHC/eJlfXyyy+fvOuuu+bbbubF0CtscR0t3P/b4/XXX5+83HLL1e7FAw44oENXxvQC9//q4Kl2//33Tz799NMnr7rqqrW+P9tss03+05/+1IWrZLqNhavpCdNOO23tB+OII47o6B/x4osvPkEUIyiL4P1tttmmti5imu83G+ziTvv888/XPYb3ve99tXU/+MEPdkW4yq3rjjvuaPid3/72txO+c8EFFzTc/hxzzFFb98gjjyxcz8J1eAYuTGrE/l3kvh75wQ9+UFt/s802m+Lz1Vdfvfb5XXfd1fJxW7iaTuD+3x6EBeh+nnrqqSffcsst7phDhPt/OZqFyDChe/PNN3f5aplu4eRMpuvgQkjdOEFR6E5x8cUX53XpgMQzJIBKEyEJ3sddF3dHwJX2N7/5TdN9HH300bnrcZksdddee23WLXCHJslSI+RKDFtvvXWeTKceJMOJ7qEk3/m3vjbDynHHHVd7/pWvfCWbZ555Gq6/55575q7vSuT11FNPTfg8uv+mSS2MGTTc/+vz17/+Nfvf//3f2uu99967sHa6GV7c/xszzTTT5GMe7gWqVJjhxMLVdJ00a1sjEdhO7Ozmm2+ex7Q2gpjTzTbbrPaa2NdGkD2YjKmNeOtb39qTLI1kNG5GPJ8oqOtBsXrFxz766KO1mF0zfDA5pIkYYqW33HLLUt9Txl8mLWJcbBoDx8SGMYOK+399nn322bz0HHkeYOmll54gcszw4/7/H8iroIXJ2Xe9613ZbLPNlr3++ut59nvqfZPXwwwnTs5kug4/GBH9eXaCv/zlLxMC7ctAEqJf/OIXtaRKjVh22WVrFtp6xKQyRQlqOgHHQEKmRpAA54knnqjUHljRsOLefvvttfaQBc4MFzfddFOemEP95eCDDy71veuuu672PC0XRckqTQ6R1AJhvOuuu+a1lBdaaKGOHr8x7eD+XwwJCbfZZptavUomtc4999yOTiCb/uP+/x++9rWvTdE+/DficUcZOO4FvNFOPvnkbI899ujpdTLtY+Fqug5/lNNOO23NXZjZ307x5JNP1p5Tn7QMsV7k3//+94brUqeyGVHYRpfoTkI2WNqwbFtQr7WsayftIeHarD3M4BJrsuLyG7NYl+WZZ56Z8Jp6wcxMKyPwpZdemi/KDr7eeuvlFlsGxs3cko3pJu7/U8L/0U477ZT97ne/q3kQnX/++dnKK6/szjhiuP83ZpZZZsk+/vGP594G22+/fV4Z4oMf/GD+H7bEEkv06CqZTmBXYdMToqikHEuniNZbfpjKENdrVny6Xrxsr0GIdqMt0nVdjHt4+cc//tH2NtKJF2KCfvrTn2bf+973shVWWGHCZw888EB25pln5uKWEjc8UmrHmH7g/j8RBua4SSJUgYnPc845J9tggw36cn1Md3H/Lwel2HAdljfCt771ra5eF9N5LFxNT3jHO95Re64aop0gujvJTbIZcb3UjXmYaaUtRrk9xo04AYFF5f+yxldajjjiiMLJGxK5kNCCGOiTTjopd6+Ks9Svvvpq9v3vfz+v2xot/8b0Cvf/iWBNYmIJyGNw2mmnlY57N8OH+395CHURaV4HM/hYuJqesNFGG9We/+1vf8uuvvrqjmw3usNiASpDTKA0Su6NsS1eeuml0m6/o9oe48Z8881Xe/7YY491ZR/EQ++7777ZKaeckmflRsh+9KMfzS2zwHtHHnlkV/ZtTCPc///DRz7ykey73/3uhGzzu+yyizvQCOP+Xy30SqSZ9M3gY+FqesIOO+wwQRR1KqNhzOhbVgzH9VZbbbVsVCBj8pvf/OZK7YG4vfPOO0eyPcaNVVddNZthhhny5yTpUjKWboKQpexOFKtyTRxEl3szurj//5tPfepT2Ve/+tVauxx//PG5G78Zbdz/y0MFBTHXXHN15XqY7mHhanoWo/n//t//q73+yU9+ki9Vwa01CrJoyb3wwgsnZNWtl8DgV7/6VeH3uw2JMaJrZTdQaRPAKtYM1iEWCohTJIuyGd57LPbnXsbuUDNYPP74433p+2a8cf/Psi984Qt5uQ/x2c9+NjvkkEP6el1Mb3D/L88FF1xQe05pHDNcWLiankFGt2jR22233Wplacpwyy23ZGuvvXZ28cUX195797vfnS2++OL581deeaXhnzQxfAcddFBt4LzkkktmG2+8cdYrYtkcStd0g/3337/2/Gc/+1l20UUX1V0Xl20GOvG7towNN5/4xCdqz0844YTskksuKf3dIvfisu7msYxOtPr3su8bM879nxIgn/70pyf83x522GFd2ZcZTMax/2PMIMlSWU488cTs+uuvr71+73vf29HjMd3HwtX0DNwYyWqoHzbiMCmKvvvuu2e33XZbXbFJnUmSwayyyiq5eI2QdOLoo4+uvT7rrLPyGLy0VizZcvfaa688Q6o49thj8+/3ihVXXLH2nHbolsX1Pe95T+31+973vsJ9/elPf8pFu0oTLbzwwhMs4mY4IWOo6tKRIZhadUcddVTd2sn84VPqhnI20WoqKHnDhMYVV1xRs8ynMAhgQkjE/ieYXJp55plrEyaxdqwxnWJc+z/1KIlrFQcccEB2zDHHdHQfZvAZx/5/1113ZUsttVT2pS99aYo65Kkw5x7h3hCUwnHCsuFjqskoA2N6CMmAttpqqylEKPVEyYZKLOzrr7+e/9DccMMNU7gefvnLX84+9rGPTXjvwAMPnFC3kuy4iDgSFuA+TO3J+OONZZbYnyIuv/zymsstfwS8bka0VNa7pUiWsd9++9XW33DDDbO3vOUttbhExScpcQDtJGsy5YRiEqVG0F7rrrtunihHULvsbW97Wzb99NPn5YjI7KzjJBshllm+UwSZZhXDePjhhxdmnjW9IV6Len0TzwMGIdEzgUED15+BCP2NCQv6B/cg68Pqq68+YSY67dfcU8RR0RfpM8zGU/+XbMMxQRj3LG7nKbvuumv2wx/+sHY8m222WX48SuxErNEnP/nJltuGwvJpfC33fLwPmPxKwZ2yaNBmBg/3/ym5+eab8/tSwoJ7E/FS1nvm4IMPzv8fzODj/j8l/N/EXCeMIzESMI7kv+65557L/6duuummfFwpCIu67LLLsgUWWKBHV890DISrMb3m+eefn/zZz3528pxzzol6KrWsssoqk3/2s5/V3ebnPve5yTPMMEPDbcw444yTv/jFLzY8tssuu6y2/gYbbFDqfOI+6vGvf/1r8vrrr9/w+O67777a+jzX+4suuujkKjz22GOTN9poo6ZtutRSS02+9tprG27r8MMPr63Pc9M/4rVo1Ddfe+21yYcddtjkmWeeudS9Nd10000+4IADptjOrLPOWun+vO222+oe0/333z95/vnnr/v9qn08ZY899ih9rHH5wQ9+0NZ+Te9w/2/8f9XKwvfNcOD+PyW33HLL5Kmnnrp0f2fdfffdd/LTTz/dhytoOsG0nZPAxlSrOUr8De6pJFX6zW9+k7uvYh19+umnc8sgFpjlllsutxThUtws4y3xPcTNfu9738stiPfdd19uWZpzzjnzmpObbrppnl0RK08/mG666fKYE+pdkpgKaxfn+q9//avj+8LSjJX517/+dXb22WdnV111VW7BJr4XV21mKGnTD3zgA/lxmdECKyaWRFy4qN9Iv8PSjpWUPjD77LPnltOVVlop9y7YfPPNJ5RTiqUCfve73+WuYrh34ZaFRR8XM6ymCy20UG6pJU4Iq2Uj13v2d+ONN2bf+MY3cmsw2axx4celzRj3f2P8+18VvNYY2zCGJHEnltV77703/+/ivw5PIWJs+a/Dq4yyUFRgMMOLXYWNMcYYY4wxxgw0Ts5kjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXE3fOOSQQ7Kpppoqm3nmmbOHHnrIV2KA2HnnnfNr8+Y3vzl79tln+304I4n7/+Di/t993P8HF/f/7uP+P7i4/w84k43pAzfffPPkaaeddjJd8NBDDy1cZ4MNNsg/17LwwgtPfvnll0tt//DDD699b6eddpo8CPzgBz+YcD5Vl8suu6xwu7xfdVvvete7Gh7rXXfdVbs+Bx10UJdaZHxx/3f/H2fc/93/xxn3f/d/0zq2uJq+8PGPfzx77bXXsllmmSX77//+71LfefDBB7PvfOc72bgy//zz92xfSy21VPb+978/f37iiSdm99xzT8/2PQ64/1fH/X90cP+vjvv/6OD+Xx33fyOmrT0zpkf8/ve/z371q1/lz/fdd99s7rnnLv3dL37xi9k+++yTuxcPG8svv3x2wAEHlF7/3HPPzR5//PH8+eqrr54tt9xyTb+z4IILZtttt13T9cps6xOf+ER22mmn5RMMhx9+eHbGGWeUPHLTCPf/crj/jybu/+Vw/x9N3P/L4f5v6tKGtdaYlthyyy1zF9Sppppq8p133ll3vdRVWMtRRx01lK7CVXjqqacmTz/99LVz+PrXv1533egqTJt1El2DaaaZZvL999/f0W2PK+7/zXH/H13c/5vj/j+6uP83x/3fNMKuwqan3HXXXdkvf/nL/Pn666+fLb300qW+t/baa9eef+lLX8qee+65bJT50Y9+lP3rX//Kn0833XTZLrvs0pfjwLoNr7/+evaNb3yjL8cwSrj/l8P9fzRx/y+H+/9o4v5fDvd/0wgLV9NTfvCDH2Dlz5/vtNNOpb/3gQ98IFt22WXz508//XT2la98JRtlTj311NrzLbfcMptnnnn6chzbbLNNNsMMM+TP5TZsWsf9vxzu/6OJ+3853P9HE/f/crj/m0ZYuJqecuaZZ9aeb7vttqW/N80002RHHnlk7fXxxx+fPfXUU9kocvvtt2fXXntt7fUee+zRt2OZbbbZsne961358yeeeCL7zW9+07djGQXc/5vj/j+6uP83x/1/dHH/b477v2mGhavpGTfddFP2wAMP1JIDLbDAApW+v+OOO2arrLJK/vz555/PjjnmmGwUwbIp5p133mzzzTfv6/FstNFGtecXXHBBX49lmHH/L4f7/2ji/l8O9//RxP2/HO7/phnOKmx6RrTWrbfeepW/P9VUU2Wf+9znsq233jp/TczlRz7ykcoCeJB54403stNPP732mpI0xLiW5aWXXsp+8YtfZDfeeGPuUk25ofnmmy9729velr31rW/Npp22+i0fr5Utrq3j/t8c9//Rxf2/Oe7/o4v7f3Pc/00ZLFxNz/jjH/9Ye77yyiu3tI2tttoqF2FsC5H2hS98oa2kQRdeeGG+dJLddtstP8ZW+O1vf5s99NBDLbsJ42IsYV9UKgehf/DBB1cSwyuttFLuqk2CJpJLPPPMM9mb3vSmSsdl3P/L4P4/uvj3vznu/6OL+39z3P9NKRrmHDamgyy77LK1si2/+c1vmq4fy+GceOKJtff5rt6nZExRmZay5XDiep1afvCDH7TcRh/4wAdq21lppZVKfSeWwymzrL322pMfe+yxSse1xBJL1L5/+eWXt3h24437f3Pc/0cX9//muP+PLu7/zXH/N2VwjKvpCWQS/tvf/lZ7vdBCC7W8rY033jjbcMMN8+eUjPnsZz+bjQL//Oc/s5/97Ge113vuuWfp7xIL++EPfzj//r333pu9+OKL2csvv5w/J0PfmmuuWVv3D3/4Q265xmJdlkmTJtWe33///aW/Z/6N+39z3P9HF/f/5rj/jy7u/81x/zelKSVvjWmTZ555ZoLV74knnmjZ4gpXXXVV7bNppplm8p133tmSxXWQwFKrY5522mlLW0Wff/75ya+88krDdd54443Jhx122IRr8LnPfa70sW233Xa17x199NGlv2f+jft/c9z/Rxf3/+a4/48u7v/Ncf83ZbHF1fSEF154YcLrmWeeua3trbvuutl73vOe/Dmxl4cffng2SrXLNt100zypUhlmnXXWbPrpp2+a2ArLNMmexHHHHVe6Lmu8Xum1NM1x/2+O+//o4v7fHPf/0cX9vznu/6YsFq6mb64z7fL5z38+F2Rw9tlnZzfffHM2rOBGfcUVV7TkJlyF6FZNkiXchnt1vUxn29P9vzru/4OB+/9E/Ps/Xrj/T8T931TBwtX0BMqyRKrEV9ZjtdVWy7bbbrtaGvXDDjssG1YogaM/MzL2EoPaDZZccslsscUWq72+7bbbSn0vXq/0WprmuP83xv1/tHH/b4z7/2jj/t8Y939TBZfDMT1hjjnmyGacccY8YRD8/e9/zxMKdcKCct555+XC9ec//3l23XXXTUhENCzlcGLR7Z133jmbYYYZsm5B3VslWOI6lOHJJ5+sPZ9//vm7dmyjivt/Y9z/Rxv3/8a4/4827v+Ncf83VbBwNT0Bl14sfbfffnv+mlqlyy+/fNvbfctb3pLHbZ5xxhn5609/+tPZRRddVKnu6Te/+c2sk6yxxhqVhOvVV1+d10fttptwUbxNWevpww8/XHseLbamHO7/9XH/H33c/+vj/j/6uP/Xx/3fVMWuwqZnrLzyyrXnd9xxR8e2e8QRR2TTTvvvOZiLL744+93vfpcNE3G2cbnllsvWWmutru2LMjmx7RdccMFS34mljFZZZZWuHd8o4/5fjPv/eOD+X4z7/3jg/l+M+7+pioWr6RlRkN14440djdvca6+9aq+xulYRvcSWdnKpYjF95ZVX8sRSYo899si6yQ9/+MN8n5oFXn/99Zt+55ZbbsldsWHppZfO5pxzzq4e46ji/j8l7v/jg/v/lLj/jw/u/1Pi/m9awcLV9IxNNtmk9vyqq67q6LZJzKS40CuvvLKSu3A/IS732WefzZ9PPfXUeXxsFbCGSlQ2A3fkQw89tPb63e9+d/bmN7+56fdoz6JraKrh/j8l7v/jg/v/lLj/jw/u/1Pi/m9awcLV9NRVZpFFFsmfE+v66KOPdmzbCy+8cLb//vvXXpct8zJItcs23njjbNKkSZW+T4wucb4nnnhi9sQTTxSuQ51bYoDXWWed7Kmnnsrfo+7rMcccU2ofv/3tb2vPt9xyy0rHZ/6D+/+UuP+PD+7/U+L+Pz64/0+J+79pBQtX01N23XXX2nOyAXeST37yk9nMM8+cDQuPP/54HpPbrpswkwAf/vCH82zByy67bLb99ttn++yzT7bffvtlW2+9dZ4FGEuuROs000yTx5WUiVV9/vnns0svvTR/jnXWFtf2cP//D+7/44f7/39w/x8/3P//g/u/aZnJxvSQO++8c/JUU01FwdLJG2ywQcN1+Zz1WE488cRS2z/00ENr39Gy0047TR5EvvKVr9SOcfbZZ5/84osvVt7GZZddNsX5NlqWXXbZyb///e9Lb/+MM86offdjH/tY5eMzE3H//w/u/+OH+/9/cP8fP9z//4P7v2kVW1xNTyG5zxZbbJE/v+KKKyaUgekEH//4x/OaacPmJrPjjjtmM800U+VtrLfeetn111+fnXDCCdkuu+ySrbbaatmiiy6azTrrrNl0002XzTPPPNlb3/rW7IMf/GBer/a2227L3v72t5fe/ve+972alfbAAw+sfHxmIu7//8H9f/xw//8P7v/jh/v/f3D/N60yFeq15W8b0wLU7Vp33XXz5wcffHD21a9+1e04gNx6663ZiiuumGdKplbumWee2e9DGgnc/4cD9//u4P4/HLj/dwf3/+HA/X9wsXA1fWHzzTfPfvWrX2WzzDJLXiN07rnn9pUYMCjrw6woNXKx1C611FL9PqSRwf1/8HH/7x7u/4OP+3/3cP8ffNz/Bxe7Cpu+cOyxx+aC6IUXXsi+/OUv+yoMGPfcc09e8xVwM7Zo7Szu/4ON+393cf8fbNz/u4v7/2Dj/j/Y2OJq+sYhhxySfe1rX8tjO4l1rVoKxnQP4mV/9KMfZfPOO2925513ZnPOOaebu8O4/w8u7v/dx/1/cHH/7z7u/4OL+/9gY+FqjDHGGGOMMWagsauwMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwaaaft9AGZ4OO6447Lnnnsum3322bOPfvSj/T4cY4wxxhhjzJgw1eTJkyf3+yDMcLDQQgtlDz/8cDZp0qTsoYce6vfhGGOMMcYYY8YEuwobY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY0xLPPzww9n555+fPfLII139jjEWrsYYY4wxxpjK/Otf/8rOPPPM7Lrrrssfed2N7xgDFq7GGGOMMcaYyiA+//nPf2Y33XRT9vzzz+evu/EdY8DC1RhjjDHGGFMJLKW///3vs8ceeyz7xz/+kT/yupEFtZXvGCMsXI0xxhhjjDGVkOX0b3/7WzbVVFPlj7xuZEFt5TvGCAtXY4wxxhhjTGmi5fSVV17JVlhhhfyxkQW1le8YE7FwNcYYY4wxxpQmWk7f/OY3Z/POO2/+2MiC2sp3jIlYuBpjjDHGGGNKkVpOF1tssfz9RRddtK4FtZXvGJNi4WqMMcYYY4wpRWo5nXnmmfP3Z5lllroW1Fa+Y0yKhasxxhhjjDGmKanldMEFF8xeffXV2sLr1ILayneMKWLawneNMcYYY4wxJvCnP/2pZjmFG264obB9+Hz++efP14eq31lnnXXc7mYKLFyNMcYYY4wxTfn73/+evf7669nSSy/ddF3WY309r/odY1IsXI0xxhhjjDFNecc73pG98cYb2QsvvNB0XeJXWR9a+Y4xKVNNnjx58hTvGlPAQgstlD388MPZpEmTsoceeshtZIwxxhhjjOkJTs5kjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0zio84Dz33HPZhRdemF133XXZ9ddfnydHevLJJ7OXXnopm3POObMVVlgh23zzzbO99947m3vuuft9uMYYY4wxxhjTcZxVeMC55JJLsk022aTpevPMM092xhlnZJtuumnXjsVZhY0xxhhjTC/BaPOnP/0pW2ONNbIFF1ywa98xg48trkPAwgsvnL3zne/MVl999fz5AgsskNfDoiTNueeem/30pz/NizVvvfXW2bXXXputssoq/T5kY4wxxhhj2uJf//pXduaZZ2bPP/98dscdd2QHH3xwNv3003f8O2Y4sHAdcBCsDzzwQN3Pd9xxx+y8887Ltttuu/xGPfLII3Mha4wxxhhjzDBDqNw///nP7KabbsoNM7xed911O/4dMxw4OdOAM8000zRdZ9ttt82WXXbZ/PmVV17Zg6MyxhhjjDGme2CQ+f3vf5899thj2T/+8Y/8kde838nvmOHBwnVEmG222fLHl19+ud+HYowxxhhjTFvIcvq3v/0tm2qqqfJHXvN+J79jhgcL1xEA//0bbrghf77ccsv1+3CMMcYYY4xpmWg5feWVV/IqGjw2sqC28h0zXFi4Dikvvvhidtddd2XHHXdctsEGG2SvvfZa/v4hhxzS70MzxhhjjDGmZaLl9M1vfnM277zz5o+NLKitfMcMF07ONESccsop2V577VX380MPPTR7//vf39K2yVDcjNdff72lbRtjjDHGGFOG1HK62GKL5e8vuuiiufiUBXXNNdesZQtu5Ttm+LBwHQFWXXXV7KSTTspvxlahzI4xxhhjjDHdplGd1dRyOvPMM+fvzzLLLDUL6vzzzz8hW3Ar3zHDh12FhwiyB9988835Qr3Ws846Ky+DQ3zrLrvskl1wwQX9PkRjjDHGGGOa1llFRPIYY09Tyymi9tVXX60tvE7jVlv5jhlObHEdIuacc858EVhYd9555+z000/P9thjj2ybbbbJvv/972d77rln5W0/+OCDTddhf9z0xhhjjDHGtEKjOqtYYWU5BSUfTZEFlfWh6nfWWWcdX7whxMJ1BNhtt91ya+uPf/zj7MADD8y23nrrbK655qq0jYUWWqgjNWWNMcYYY4ypUmdVsad///vf85wqSy+9dNMGZD3W1/Oq3zHDh4XriIC1FeH6wgsvZL/+9a9bTtJkjDHGGGNMJ+JVy9RZjbGn73jHO7I33ngjH882g/hV1odWvlPluM1gYOE6IpDyW8hVwhhjjDHGmG7Hqz7//PPZHXfckR188MF1s/amsahvectbsr/+9a8TrK5vetObcmNMVap+p8pxm8HByZlGBGaNxKyzztrXYzHGGGOMMeMVr4oIbFQrdZDqrFY5bjM4WLiOCOecc07t+UorrdTXYzHGGGOMMeMZr1qUtbdRndVeZ/ytctxmsLBwHXBOOeWU7OWXX264zvHHH59deOGF+fPFF188W2+99Xp0dMYYY4wxZhwpiletZzktU2e1V1bXKsdtBgsL1wHniCOOyCZNmpTtt99+2WmnnZbPCN14443ZVVddlZ144ol5gPlHP/rRfF1880866SRn/zXGGGOMMV0jtaCusMIKdS2ng1Rntcpxm8HDyZmGgKeffjr77ne/my+NytmcfPLJ2cYbb9zTYzPGGGOMMeNFo3jVmCW41dqs3aqzWuW4zeBh4TrgXHTRRdkvf/nLfBbo7rvvzh5//PHsqaeeymaaaab8Rlt11VWzLbfcMttxxx1rbhfGGGOMMcZ0g0bxqgi/TtVmbYVGJW6qHrcZPCxcB5xll102X+QObIwxxhhjTL8oE6/aidqsVWlW4qbqcZvBw8LVGGOMMcYY05R68aqC10888URHarO2U+JmlVVWmSBAWzluW10HDwtXY4wxxhhjTFN6Fa/ayOW3SokbCdBBirM1rWPhaowxxhhjjGlKL+JVm7n8li1xE91+exlna7qHhasxxhhjjDGmKb2IV23k8ltE6gb8lre8JfvrX/86weraqzhb010sXI0xxhhjjDFN6Xa8ajOX33ZK3PQiztZ0l6m7vH1jjDHGGGOMaUqRyy+veb+IRiVueC3hy3pm+LFwNcYYY4wxxnQNki2df/752SOPPFJ3nVSErrDCCk3FZ5kSN42ErxkuLFyNMcYYY4wxXUHJlhCPPNazfjZy+S0Sn/VK3Gjhta2uo4WFqzHGGGOMMaYrxGRLZAousn624vJbVOKGdbSo5I2EL+ub4cbJmYwxxhhjjDF9S7ZUxuU3JloCl7gZPyxcjTHGGGOMMR2nWX3VRi6/gtdPPPHEFKLXJW7GDwtXY4wxxhhjTEcpU18VAVrk8luERC/rr7POOl0vzWMGDwtXY4wxxhhjTEcpW1/VLr+mLBauxhhjjDHGmI7RKNkSgjVaXe3ya8pi4WqMMcYYY4zpGFWTLQ2iyy+1Z3FLXmONNfI4W9N/LFwLeOaZZ/JZoAcffDB//tprr2Wf+cxnen91jDHGGGOMGSJaTbY0iLVnKd9zxx13ZAcffPDAHeM4YuEa+OMf/5h99rOfzS666KJs8uTJExoqFa6PP/54Pjv0xhtv5AHiX/va13pzxYwxxhhjjBlQy2SryZYGtfbsKqusMiELsukfFq7/x9FHH52L09dff30K0Ur67pT55psvv9nOP//8vFPz3bnnnrs3V80YY4wxxpgBtEwOe7KlsrVnTe+xcM2y7Jvf/Gb2yU9+stYoyy23XPbOd74zn125/vrr6zbeXnvtlQtX3B8uvPDCbLfdduvNVTPGGGOMMWYALZODmGypSrxqmdqzpj+MvXB99NFHs49//ON5Y8w444zZiSeemO2xxx7564MOOqihcN1ss82yGWaYIZ+ZueyyyyxcjTHGGGPMWNDIMjlIyZaqxKuWrT1r+sPU2Zjz7W9/O3vppZfyGZXjjz++JlrLgGhdccUVc9fim2++uavHaYwxxpjBBGsOHliPPPJIvw/FmJ5RZJnkNe8PqlUY8dro+BrVnh3Ecxs3xl64kogJcBvYb7/9KjfgkksumT8qAN0YY4wx44OsOQxoeeS1MaNOaplcYYUV8kdZJrt5H1SZKKpnFS46vka1Z3t1bqYxYy9c77333nyWCJ/1oiRMzZhzzjnzx+eee67yd40xxhgz3FSx5hgzKvTLMll1oqiKVbhM7VlbXfvL2AtXZl9grrnmaqkBmYGB6aabrqMXxhhjjDGDTRVrjjGjQictk1Xd7KtMFFWxCterPauF17a69p+xF65vetOb8oZ45plnWmrABx54IH+cZ555OnphjDHGGDPYDEuMnzGdpFOWyarW06oTRVWswkW1Z9m2FtWi1XdZ3/SesReuzA6RXKmVDkia7z/+8Y/5nxWzOMYYY4wZD/oZ42dMv+ikZbKqm32ViaKqVuFYe5bEq/UWPh/E2rPjwtiXw9l4443zDn/PPfdkV155ZbbeeuuVbrwTTjghe/HFF/Obh+0YY4wxZjxoZM1xzUczqhRZJovQfcD666yzTqVSOkXlZqqWqSljFY736SDWnjVTMvbCdbfddsuOPfbYvLPuv//+2VVXXVUq3vXSSy/NjjjiiPw5N8Puu+/e9DvGGGOMGX4aWXMYCLvmoxlVomWyGY0sk0XW00YTPlUmiupZhQWvn3jiiQn3KaGDg1R71hQz9sJ1ueWWy/bee+/spJNOyosSr7322tlxxx2XbbHFFnWzEH/rW9/Kra3cBNxsH/vYx7K55567ThMbY4wxZpSoas0xZlTohGWyqvW06kRRp6zCZvAYe+EKX//617Nbbrklu/rqq3OXYWZcZp999gmZgt/61rfmNwYzNEBcLLz73e/ODj/88D5dPmOMMcb0klasOUWuj8YMI80sk2QJRgiuscYa+b3QCTf7qhNFnbIKm8HDwjXL8j+Uiy++OPvQhz6UnX766XnD4G+PNVW1XQkcl1gVe+yxR/ad73ynpfqvxhhjjBk+bM0xpnGWYBIt4cV48MEHTzFpU9V62spEkeNVRxcL1/+D2ZtTTz0122effXJX4UsuuaTQDWKGGWbINtpoo+wTn/hEtv766/f6ehljjDGmj9iaY0zzLMGrrLJKoat8VetpqxNFjlcdTSxcE8gqzILrADceBZGxvnJDzTfffNmqq66azTjjjP25WsYYY4zpK7bmGJO1lCW4FeupJ4pMxMK1DtNMM00e18pijDHGGAPOPmpMa1mCW7GeeqLIRCxcjTHGGGOMMS1RNktwK9bTYZsoKpOcyrSOhasxxhhjzBAPVvu9fzPelM0SPEzW01buqTLJqUx7jL1wZUZnt912y15++eV8BuiYY44p3XgkaLrrrruy2WabLU/sZIwxxpjxot+D1X7v34w3VbIED4v1tNV7qkxyKtMeU2djzoUXXpj96Ec/yn7+859nSy21VKXvsv55552XnXHGGdlFF13UtWM0xhhjzGASB6sMdHk9Tvs3402ZLMF83s9+ifX0/PPPzxOuduueqpecivdN5xh74frLX/4yb4jpppsu23HHHSs1HuvzPfjFL37RwctijDHGmEGn34PVfu/fjDf1sgRr4TXvd6pfVhWg0XqK+OSx2TG0ek8VJafqt2AfRcZeuKpDYdKfY445KjUe61MeZ/Lkydm1117bpUtkjDHGmEGk34PVfu/fjDdFWYIReVqUNVj9kvVbFaFVBWir1tNW7qlUwK+wwgodFezmP4y9cL333nvzjrnssstmrbDMMsvUtmOMMcaY8aDfg9V+79+YmCV4xRVXrLvwubIEtypCe+G+2+o91Sg5lSeSOsvYJ2dSZjN88Vth1llnzR+fe+65jl4YY4wxxgx/JtVuZTXt9v6NaUarWYKrJjGqJ0BVZqed2rLt3lNVklM5aVr7jL1wnX322bNnnnkme/rpp1tqQH2vVeFrjDHGmOGi24PVZllNPVg2g4CyBFcpHdOKCK0qQKvUlm33ni6TnMoTSZ1j7F2FF1hggbZiVPW9+eabr4OXxRhjjDHjmkm1mVvkMGRyNeNBVbffqjGkvXLfbeWe6nVyKmPhWpupeeCBB7Lf/OY3lfrExRdfXLvx1llnHfcnY4wxZsTp9mC1WVyeB8tmkKgSe9qKCG0lfrSR9bRof63eU+0kpzKtMfauwttuu2120kkn5Y3xoQ99KPvDH/6QzTPPPE0b7oknnsjXj9sxxhhjzGhTNFgtQi6CrF9lcruZW2S3929MWaq6/VaNIe2V+26r91RMTtWMmJzKtM7YC9fNNtssW3311bM///nP2X333ZettdZa2Xe+851sk002qdtoWGb333//7P7778//VAgsx8ffGGOMMaNNNwerZeLyPFg2g0KV2NNWRGgr8aP1rKeC1xifOnFPtZqcyrTO2AtXOOWUU7K3v/3t+c2BGEXM0nk33HDDbIkllsgzB/MZwvayyy7L7rrrrloD8tmpp57axiUwxhhjzLDQzcFqGYuUB8tmEKia/KiqCG1FgLK/Vqynrd5TSk5leoeFa5blN9vPf/7zbMcdd8xnUUjWhDiNAjXC5zDXXHNlP/7xj7OVVlqph5fMGGOMMf2iW4PVKhYpD5ZNv6ni9tuKCO2l+64F6PBg4fp/YF3FXfjQQw/Nxehrr71Wv9GmnTbbaaedsqOOOipbaKGFenWtjDHGGDOkVK3L6rIaZlCp6vbbigi1+64pwsI1gAg944wzsmOPPTa75JJL8kRNjz/+eJ4lbbbZZstL3qy99tp5/CtldIwxxhhjOl2XtaxbpDH9oOokSysi1O67pggL1wL4g9h9993zxRhjjDGmUyVDSOiYJq9xpmAzLNSbZEFwTjPNNIWTLK2IULvvmiIsXI0xxhhj+lgyxJmCzbBQb5Ll5Zdfzmaccca6saeOyzadwMLVGGOMMaaPJUOcKdgMC/UmWZ599tlszjnnnPCea5eaTmPhaowxxhjTx5Ihdos0w0K9SZYHHnggW2SRRSa859qlptNYuCaQjOn666/P67k+99xzE5IjNOMzn/lMp6+PMcYYY8agZIgxw0C9SRbGzmTMNqabWLj+H9dee232yU9+Mrv88strdVqrYuFqjDHGmFZKhhgzzNDHjek2U3d9D0PA9773vXzG87LLLsvdHxCuVRdjjDHGmColQ/ic9YwZhYkaY7rN2FtciTX50Ic+lAeQA4kTmP1861vfms0999zZdNNN1/WLYIwxxpjh5eGHH86zp+IqSTkQ12U144aFq+kFYy9cjz/++Fy0IlhJmnDWWWflj8YYY4wxZQbsZ555Zvb8889nd9xxR3bwwQe7LqsZOyiHY0y3GXvhinswzDTTTNmvfvWrbNKkSV1vdGOMMcaMlkvwTTfdlK2yyir566effrqwZEgRLhliRgELV9MLxl64Pvroo7m1daONNrJoNcYYY0xpokvwP/7xj1rCpT322KOwZEgRLhliRgH6OjlfGFMb0y3GXrjyh0EmNFtajTHGGNNqAiYG7Cpzc/fddxeWDDFmVMFzAPE666yz9vtQzAgz9lmFF1988bwhnnrqqX5fC2OMMcYMCWkCphVWWCF/lNXVyWrMuPH3v/+934dgRpyxF67vfe97c9eGK6+8MnfrMcYYY4ypWu5m3nnndZkbk417+J0x3WTshet+++2Xp65/4oknshNOOKGrjW2MMcaY0bO2LrbYYvn7iy66qK2uZmx58MEHc2OQMd1i7IXrm970puzss8/OY13/53/+J/v+97/ftcY2xhhjzOhZW2eeeeb8fcYSvOZ9Pmc9Y8aFZ599tu3QO2oin3/++dkjjzzSseMyo8PYJ2f63e9+lzfEUUcdlf33f/93boHF8rrDDjtkK620UjbHHHOUzpC2/vrrd/lyGWOMMWaQrK14bb366qu1z+XFpVjXNddcM5t++unb3i8D+j/96U/ZGmuske/DmEHk9ttvz97xjnd0rCZyJ+4dMzqMvXDdcMMNJwhTXBxuvvnmfKkC23jttde6cImMMcYYMyggHmVthRtuuKFwPWUYZv111lmnrX16QG+GhTvvvDOfXJlxxhk7UhN53XXX7cpxmuFk7IUrpP749s83xhhjTL3MqZT+WHrppZs2EOt1ItOqB/RmWMCIg/EHT4MqXgL1aiJ3ymNhkLE3RXnGXrji3utiycYYY4wpA26QVCGgZmUziHlt1W1SjPOA3gwnt9xyS7bMMstUcvutVxN51K2u9qaoxtgL18svv7xikxljjDFmnJM6brPNNj3b37gO6M3wQsw3orWs228aN/6Wt7wl++tf/zoWkzT2pqjG2GcVNsYYY4wZRNIB/QorrOByO2Yo3IUvvfTS7P7775/gJUB/HvWayFWyItfzpqjXTsbC1RhjjDFmIBmlAb0ZHxCsTLQo0Wmj/jqoNZFbKcsjt1/Ok8dmx1zkTeH7ujG2uBpjjDHG9JhmA+NBHdAbI/bdd988YzbL0UcfnS+nnnpqds899+QWxBdffDFbYIEFGvbXQayJXFWAFrn9Etvb6JjtTdEaFq4FPPPMM9kFF1yQnXjiidkXv/jF7LOf/WyLzWuMMcaYUaeqdabMwHgQB/TGpEmY/vCHP+TLvffem9133335glB9+umns9lmmy0Xr3POOWdhf61XE1kLr/sxSVNFgBady7i5R/cSC9fAH//4x2yLLbbIOw+JFw488MDssMMOy4488sgpGu7xxx/P1l577WyttdbKM6UZY4wxZvxoxTrTbGA8qAN6Y5rx8ssv58KNONe55547z8DNwvtpfy2qicznWlQjWWKO9btNq3GnVdx+7U3ROhau/wfuDeutt17261//Or/BqOWqpYj55psvz+p3/fXXZ9/5zneyp556qo3LYIwxxphhpKp1pszAeBAH9MaUgTG0rK3KBMxYmveJfY1iLtZEXnHFFesufN5OTeQqHhGtxJ1Wdfu1N0XrjH05HPjmN7+ZffKTn6w1ynLLLZe9853vzDsWwrQee+21V34jMPt54YUXZrvttlsbl8IYY4wxw0QrNVbLlLeJA/pmtDOgN6bT0B8ZF9OneS64H/BWfPTRR2v3SC9qIlepk9pqWZ5Gbr/pvV3Pm0Lw+oknnhiLUkCtMPbClRvo4x//eN4YM844Yx7Xuscee+SvDzrooIbCdbPNNstmmGGGvBNedtllFq7GGGPMGFG1xmrZgXEvBvTNLFRYcddYY418IG1MWXARhgcffLDw87/85S/5PUL/IqlTt2siV6mTWkWAlnH7Zf303i7ypihC+1Q7mX8z9sL129/+dvbSSy/lfzjHH398TbSWAdGKCwOdSim/uwHiGYvuVVddld16663Zk08+mU033XT5nwk30N57793xPy1jjDHG1KcV60zZgfGb3vSmrg/oO2GhMiaF8emkSZMaNsztt9+eLbLIIvl4turkSJVJlSoeEVUFaBW333hv25uiPcZeuF500UV5Q9D599tvv8oNuOSSS+Y3kGZOOs3666+fXXnllVO8zw1211135cspp5yS7b777tl3v/td/7kYY4wxPaCqdabVgXGvqWKhMqbIqMPYuBHTTDNNdvHFF+d9v8rkSNVJlSoeEVUFaKtuv/32phh2xl64kr6bzkwn5LEqpPiG5557rguXJ6sFktP5d9hhhzyBFLNUxA1cc8012Ve+8pV89um0007Lb5Yf/vCHXTkOY4wxxrQuQlsZGA9DzK4xqcWVihuNuPvuu/Ox66WXXpoLs7J9vsqkShWPiFbjTlt1++2XN8UoMPbClR9mmGuuuVpqQDq4btRuQKIoasm+973vzWeoIpTjISEUN+2dd96ZnXXWWdkHP/jB3EprjDHGmO5QVYR2IiFLq3GnVb5XNWbXjDdYDlMoe0Oc67TTFksMPrvnnnvy8TdWR8Qe76266qr5/dOpSZUqHhGtClC7/faesReuxJHgY//MM8+01IAPPPBA/jjPPPNk3eCCCy5o+Dn7xeq61VZb5a/PPfdcC1djjDGmS7QiQttNyNJq3GkvMqqa8aXI3VVlb5ZaaqnC7/AZ/YuSOUyO8EgiJ8ayGF8Ql+1OqlT1iGhVgNrtt/eMvXClE/MH00oNNG7YP/7xj/kNRM2mfkHpHsEsljHGGGO6QysitF3LTKtxp93OqGrGF8QhEyJF/ZexKGIxtbpGayvPF1hggby6B69vvPHG7Cc/+Um22mqrZauvvvqE71adVKnqEdGqAO1nErVxZeyF68Ybb5x3XG4kkiARQ1qWE044IXvxxRdz4cp2+oXclSF1JzbGGGNM52hFhLZjmWk17rQXGVXN+EK/iHVaBYKUPlRkdY3W1tlmmy1fEJi8nmOOObL77rsvH8eyHveAshN3u06qBejwMPbClRjRY489Nv9D2X///fOSM2XiXQkoP+KII/LnzOSQ1bdfXHHFFbXnyy+/fEvbeOihh5quU/QDZYwxxowTrYjQdgbGrcaddjujqhlfJA55LIKJktTqmlpb55577vx9xtz0r/gdnv/yl7/MsxNjfXWdVCPGXriS/Ig6qCeddFIe/0HCo+OOOy7bYostsnpZiL/1rW/l1lZmcPgz+NjHPla7AXsNf55HH3107fWOO+7Y0nYWXnjhDh6VMcYYM5p0yjpTJmlSq3GnvcioasYXTXQUCdepp566ZkGNVtfU2qo+RPkcXhd9ByGLoYjPXCfVwNgLV/j617+e3XLLLdnVV1+d3yT8Ic0+++wTMgW/9a1vzX+0+fGGyZMn54/vfve7s8MPP7xvven444/Prr322vz59ttvn89MGWOMMWZwKZs0qdW4015kVDXjSZzoKMoqjIWViY9oQQVZW/mMfhS9+BCslJVMLbVYZrk/GHsjXnFdd53U8cbCNcvyPwsKIX/oQx/KTj/99LxhuHmwpqq2K4kNJFbFHnvskX3nO99pqf5rp1yEDz300Pw5f0gnnnhiy9sio1szmGXlh8oYY4wxrVMmaVKrcae9yqhqxpN0oqNe3hVZULWerK2NxpzxO7gJ86jvIVgvv/zybNZZZ80ttHHs7Tqp44OF6/9BPMepp56a7bPPPrmr8CWXXFIYv4JLw0YbbZR94hOf6GvZGVx+tttuu3w2asYZZ8zOOeecuinEy7DQQgs1XceJn4wxxpj2KJs0qdW4015lVDXjSZzoIBNwmlmYPqykSvQr+qKelxmnxu/wWPQ9xuKMWxn/Ck+qjAcWrglkFWbhBmAm9JFHHsn/WPixnm+++fICyfFG6QdkXcNFmdqziMkf/ehHrt1qjDHG9Iky8apVkia1GnfqjKqm28SJjosuuih7/PHHJ3zOGBlrKdAnFa+K12K9ZE6R+B0e632PWNrFF188L6kDnlQZD8ZeuBLfCvx5UPhYca0IQuJaWQYJhDSld3jkmE8++WTXkDLGGGMGPF61StKkVuNOHa9qepmcjESld99994TPceVda621pvgehp+qIEabfQ/LKxM+9gocD8ZeuB5yyCG5AKTg8UEHHZQNunvGJptskmc21g9GP8vwGGOMMeNOmXjVqkmTWo07dbyqGTduv/327KmnnsrD+IiPNaPN2AtXZnNefPHFbMUVV8wGGdyVN9100+zWW2/NX1MC54ADDuj3YRljjDFjS9l41apJk1qNO3W8qhlHnnzyyeynP/1p9va3vz1bZpll+pY01XSfsReu+MaTenuQOznCmrqyf/7zn/PXn/rUp/LkUMYYY4zpH2XiVVtNmtRKrdhO1JitEq9rTEpagaNXEANOtQ3G9OSqIfOwGT2mzsYcfpi5yWTJHDSYoSV7MLOwQOzM5z//+X4fljHGGDPWpBbUFVZYIX+U5TQmlKmXNEkLr+t9tx/xuohnHvt1HGZ4UTmcfvHQQw/llTb+8pe/TKgVa0aDsbe47rbbbnlW3uuvvz4Xr/zxDBK77LJLXmMW8N/fe++9s1tuuaXu+rgm4SZhjDHGmO5RNl4VhiVpUpV4XWNipmtB/8FTUB4F/YBSkfTdO++8M3cfXnjhhft2LKazjL1wfc973pNtu+222XnnnZftuuuu2W9/+9vc1WZQwGdfcGwrr7xyw/WJlbn//vt7cGTGGGPMeFIlXpUJ5X4lTari9lslXteML/SN008/PfvBD35QC2GLkF37ox/9aC4WEY1rr712NtNMM/XtWH/1q1/l9ycTMLjlm+Fm7IUrnHLKKdkHPvCB7IILLsiTNB1++OHZjjvumM0555z9vj7GGGOMGTCqxqu2mzSplbjTKmV6qsbrmvEDK+axxx6bffGLX2zajwnBe+CBB/LlZz/7WbbZZpvlCUb7VbIGgw73ECJ6ueWW63teGya7cGXm3rr22mvz5a677qrFB3cqTnixxRareXmU5b777qtNxKXg8fntb387jyVmuy+//HKeyZmyXltvvXW27777dj22eKrJ/YqiHhBwvwWagZlFbkx1aAob4/pTZqaI71x66aXZKEOtLG78SZMm5TEExhhjzLiBIPzqV7+a16/EFZE6k9GSw6AeV2DCdpZaaqm87F47FkvtDwE6++yzNxWggjHNRRddlN1444252y/CoZ4ATc9J9WU7dQ5m+EvOYOBh8qRVFllkkTzcjcmQfoJXxIYbbpjNMMMMfTuGvfbaKzea1aNfwnWOOebIPS1mnHHGKT475phj8uSwjeKGsbKff/75LdXsLcvYW1wvv/zyCTMvek6nYdaBpRms2+/ZG2OMMcZ0n17Hq7YSd1rV7bdKvK4ZL8gBw6TH008/3dZ2sL5isWXiBfHYL+jTP//5z/Nz6lfd1yhMsVCuttpquVcE92knM3xffPHFTROsXXLJJdlHPvKR/DnepkWi9ayzzsoOPfTQ/Dm/H5Tj3HjjjbN55pknz+L8rW99K7vqqquyBx98MLeuM9HRLa/Vsc8qrA6ULvXer7euMcYYY0afGK9KeFG9hc+L4lUZjGKVeOSRR5ruq54AbTYYLXL75TXvV4nXHYRMx6Z/IEA6IVqjN8LXvva1KQRar3n22WezX/ziF/k9VYb0nj3iiCPy+wrLbav5dYgRxvWWY8GItuyyy3Y8w/cyyyzT8DeK5Zprrqmtv/vuuxdu5wtf+MKE3DvHHXdctvnmm2drrbVWnkT2yiuvzLbffvv888cffzz73ve+l3WLsbe4XnbZZV1rXGOMMcaMFu3Eq/Yi7jQVonL7rWd1rRqva8YnYzDuwZ0SrYL75uSTT84+8YlP9C3mFch8fOGFF+YlJ4usjI3u2XbZaaedBiLD9z/+8Y9ckMMSSywxRWw9PPfcc/nvB2AZ3mKLLQq3RX4gJZSNYrjTjL1w3WCDDbrWuMYYY4wZLag8sM0227T03SqD0aoCtBW333r1ZQWvn3jiCWcYHkO+9KUvtRXT2gj6IvHXWO36CWIUAxburfVC/oru2W7TqwzfP/7xj/MES42srdHSi7itx5JLLln4naFxFWYWpdvLtNOOve42xhhjzBBQ1e23kQDtlNtvUbwun2tR/K722S0hYwYL+ifZg7vJr3/96+yll17K+g1xmcTfVrlnGyUo6gRVXP3bEYunnXZa/sg+dtttt8J1iGOda6658uf33ntv3W0R6ypSt+ehEK5V40RbXYwxxhhjBp1exJ2WcfuN+2w3XteMJtRpLeMK3w704z/84Q9Zr3nmmWfyTNvElopbb7210j1LzGs3iff+CiusUCrW/LqKlmCSz7I9wEW4kTX1gx/8YP5I3V4mHIr43Oc+lz9iVNxnn32ybtFVk2UZYRmz+HZyXWOMMcaYQaAXcaetuP22W1/WjCYkDuoFV199dfbOd74z6xWUvKRmKu6x3Afvete7cqHFfZFWCGl0z2Kl7SZVM3z/6/+OtUoMLNZW6al6bsLik5/8ZO5tgXv3tttumx144IF522GNxQp74okn5rVd8Yb9xje+kdfKHTrhyg9hMzi5//7v/84b/O1vf3u2xx575CnjqfXEDyQ/pHQOgnxpYFItU3fpy1/+cp6KuRsoe5fSOjMzw7nQ2SPM1HDDqb7pyiuv3JXjMcaYYaDdtP3GjDK9iDtttUxPq/G6ZjRRHeJewDib/t5K3Cbjc1x88UIoW3rl/vvvz++phx56KK85ymvqFDPGT2NcG92z3c6wXeRpwfE81mSiq6pVHWaaaaa8DE4j0GQXXHBBrsVwIf/KV76SLxGyClMyh2PrJn0LEv385z+fZ6BCiJ5xxhnZ+9///inWodA2MxwsmJ1/9KMfZf/1X/+V/b//9//yLGeHHXZYx47nySefzAsC/+pXv6q9p5mIooBtLuK+++6bd6LFF188L9ptjDHjSNVMqcaME43cfosGo60K0Oj22wy7/Zp64EZbxvjUCRhn46bLOLuKAK1nOW32HeIwiVUltpZHXnM/Uku1yj0rkdgtD9BWPS3KguFNMalMXKG3mkF7o9fqxbn+5je/ycU9JXi6WR+3L8IVH2lqIMFJJ51UKFqL2HnnnfMfWwKIP/vZz+Z1kJjdbxfqMmHxZeanbCecbrrpcp9vxDd+4vjpr7322m0fizHGDBu9SNtvzLB6HFR1+21VgNrtd3i57bbbJljV+wk1RXsJ42dcTrGCrr/++qUSryKeFGs6adKkfMK0UYxm/A6GKoQ5j9yLfJfxO/9fjO2XX375/F6kXI/ADbaI3/3ud3WzEcvles8998zKEPVHO54WVZIyAd6uzTj33HPz0kgcFx6mRx55ZH6tEPxop7PPPjuPcf3Od76Tt8kll1zSNc+rvgjXb3/723mnwTxPQ1Rh1113zRuMmQJEbyeE6/ve975aRjGCoLHkbrTRRvl+vvWtbzUU0ghXwO/bwtUYM270Km2/McPocdDLuNN2yvSY/kKfIASN2qL9hP5611139XSfWE0RoNwLiEu8GJtZTvFypL2wnPLI6wUWWKCu6I3foa3nm2++7PHHH699d/XVV8+fY/HVPdvrCS9+PyLd8LQAfocogwO02SabbJI1gnZCfCvOF2stvzuCCYP//d//zdZaa618W0zCHHTQQdlPfvKTbGSEq2YoWhV6fI+OVm8GpArnnXdePtvD8fDjj6uwZkMbzaIAnYSZHiy2f/zjH9s+FmOMGTaKsi7WSyBhzLh5HDju1JQF0YoI6WWpR6x89F3C71gQT91OPJSCIOI4mPhEuDYSoEBcKmKXGFe+x+Oss86avy+X3kbfQXQxzudR37399ttz7weEq+5ZRGE9KzjjfhaO9dhjj81WXXXVwvXIgVN2wivGzZLJuxueFvCLX/wiP2/A45WESo0gTFPbJklTFK0R3LVZsLairdgHk2kjIVyVRrrV2Xh9j07TLpp14CY59dRTa6K1LJjMOR86nTHGjBNVM6UaM24eB447NVVgLFrWctauhROByiOvI2XiHTsJ1lBcdJ977rlc6OCBUM/tl3U5ZkQ+Yg0rLfccr3kfT85U9KbfwS2ZdXjE25L3EbYIVdA9u9pqqzWM90SDcNzEczYTmmUmvKae+j8VSglf7JanxWkV3YSxoIpGbQJYrhGutPOdd96Zve1tb8tGQrhyoeHmm29u6fu33HLLhO20g6ytdNh6MzWNYIYG8JU3xphxokqmVGPG0ePAcaem32CVRIwhVIkjbTZenXvuufO+3KvSk1j8uGcQoIhX8sZQXaTI6orQZLJIllItvEZw83kqetPvaDKVR14z4cTEK0KL5Etl7tlHH300v8eJ8WylRFTRhFfcX9ncP1Xh2qsOK1bilVZaqel34nVIK6ykRAt1tzwH+iJcmRG5/vrr84VZC/yiy8L6LNxUSy65ZNvHwswOkAWrFWacccb8kU5vjDHjQtVMqcaMo8eB405NP8CKikhlKbKqNgKjEOJVrqjdhMoiCM4yAhTRhKhF3PJ8rrnmyt/nkfWLRG/6HayjWFMFr7lf2S/ZjTfccMNS9ywi96c//WlutW3FHbZowiseV7c466yzauKyjLUVYszxlVde2dC6TCgocE6tGAPL8B+7dA/Zbrvt8kdmc6gdVDYQnLjWWGuImkHtItN8q6m/iQmAsim8jTFmFCiTKZXPWc+YcfM4cN83vYQxLIYYqnacf/75eewkeWBIZFpFtIrlllsu6wVYLKMARVxKgKbWvWaWU97ncyVbBYS7vgOIeLathddYfJ966qk80RPitdcTXiSF5bGV2rBTTTVVJZEoN2GEfVmr7hZbbFHL+fOFL3yhFu6ZQsJcDJLKRcTkx8hYXA844IDsG9/4Rn7R6GCYq6nNSpkbLmCRfzWFcr/+9a/nHQtwK2A77cIfDeZ5/NtbgR8J6FbaZ2OMGTRayZRqq6sZJexxYPoN4+FoVW3X808uuyQU2nTTTfMkRRpzdwPEEPsrEqCp1bWM5ZTJotTqynuKa60HAovzZD0J3G4ijySy8zLhq/hbXIbFKaecMuE7uCPjrdoOiHKuKWy22Wa1UMcykxh77bVXdvLJJ+fH+ta3vjU75JBDsvXWW69WDocETj/84Q9r/eiLX/xi1i36IlzpkNT82XzzzXPRSIchKxcLjbDwwgvnF5MLyQ1JRwT52zOjz/c7EUBOCmrVYWU/VbaJyzKzWdx8juMyxowLrWZKNWZUqFqb1Zh2Ue1RidVOuPJqzI1YTbP5IlYalYRsF1xssbKWEaBFltMiJHpZHyskwhftUM+aiasy61HyhWNplnyoUxNeuBoTVlAP2j6tB9uucD0tJGXafffdK32XfoBeQ3vRBz/1qU8VrsfvH5ZXXK5HSrhq9uCyyy7LraykoZYopbNGU30aHL7sssvm1tdO1G+FrbbaKjvnnHNy8cwMwdFHH13qe1gXqNUmtt12244cjzHGDDrOlGrGmXoeB4xXmMgeVI+DWDPSXmLja1VFoCJUWRCK9UDcME6PWWU7BflhCLErK0DLWE4F67E+MKHUKAER2XzZDyGLHE8nDGKN7jNNeCGUe8kbb7yRu48D57n11ltX+j4CH6vq/vvvn1uDMfapP9JmaLONN94422+//RqWAOoEU03uVdqwOvBjTyN8//vfz32ji2JNiUOlA+yzzz75jdTJPwBcDjCDM7PDH85xxx2Xuy0DBXS/+c1v5u/HGSFmGxDcF198cf4Z6Z+xvo46dEY6KrVr+TExxownDCpIwlCmbhwzsOuvv35X6rkZ0w+uueaavOY79dujkGD8EktaMNijHMR73vOevnscILa/+tWv5jUjGWgy8T4IYtr8G0qiUF6F31bEpDIAE3vZLlxvCdVmNVJTCKPbe++9J7ixtgvJn0jw06z85EwzzZQn+2NdPDDxcCwTB0q/Jnlr3P6zzz6btyfWZYl12kOJhyRcEZqUuWx1oqfRfabPyNeDxZUwyVgTlf9TvJdIFot1FXdc36MDZHGNHXjffffNF9UzQhjyHF93YlDpRDzvBtzA3/ve93J/fkTsRz7ykdyiu/POO+eFkAXB7qS/ZvaUTGLy++fGQHQbY8y44EypZpyp53HAe1i00vd6kZ21as1IuzAPDohCPA8RM1jqm5UcKWtVlQtwO1ZErJ3kpDnwwAM7Il4Ro5tsskmpY0K0Kca1meW0EbQnApRJJtqXiVQst40SGiEysVAiQO+4447SEz2N7jOH2IyIcI0gTpsV3e0G+GKfccYZ2Z577pkLUhIuKemSMmkpEzLISM3xklq61ZvJGGOMMcNFvTqPDHbTwS0WlVbqPNajVStQWjNykFyYxw0mM/DyI8aR0Disq+2CFVFWVWKrO1lDc/nll88NNIcddlhbbsMI6Q984AN5DHiRBbQMrXxP2YixaOMxiHGMxEIa33dqoqfZfeYQmxEUrv1khx12yDMa4yaMT3+kqBAzYveEE07I67YZY4wxZrw9DhisVhmEV6VdK1CsGenEUb2FvoFIRawi/trN1otVlYkLidVOxGY2AuskCYJI8EN22SolduijxD9utNFG+XEXWUDLCO1WvhezEXPMLEw4NYqSbHWip9l9Vm/Cq4hOT3iNEhauAUTopZdems+wXHjhhXkcCzM0dFw60XzzzZfHq2y55ZZ5BzbGGGOMAeLwuilc27UCMeBnnIN4stW1d1ZVlk7kBemmVbUM7O+//uu/sh133DEfIxNCh4tzEQg3rJuMmfEOIBlTPQtoLHvTiFa+F2u/4qbMc+4Drgkxpp2a6ClznznEZoSEK52BWcSrrroqd5mggzErkfr54yJA3SPgxlUAdadhu93atjHGGGNGDya5iS3shttvJ6xAuGiSN8TleroDY1S5/yLo2rWqIhSjVZXSNYMAYXKIV5Y99thjirIuiDzyxRT1y9QCmpa9qUcr39N3SAKLaCXhEblrcNm98cYbc3FJnp0I67Yy0eP7bEyEK37m1CoiO5+Q+b7I9xyrJ0mc6EBkAiMzVxk0I8MNdvjhh08xGwO4WZBRzBhjjDGmKqox2Q23305YgZSMhkytfM9W1/atqmS6lQtwvdIuVSAJEWNWWVXTZF+DRsyiHbNp1+vL0QIay940s55W/R7Hxf0y99xz50KVZEyqG0u/53WR1fWWW26pPNHj+6y3TNnjegSmfmYuEK2IVS2NYGbkgx/8YL4esyjUESqbzptOV5RWnB9yRPBnPvOZls/FGGOMMeMLouWiiy7KxzZV3X4Rr7yuRzowJh8HjxKe9UqEpFYglQfBCKDBOJ832reZCIKJNj/ppJOy//mf/8nLm1AasVXRisjDw49kQcSBYn3HvRZX2EEXrfWoN5aPVlOeIwR5lPW0XjblKt9DMDMxgyB9+umnc+8E7g95QvBdXsvqioVV8JxyNEUTPY3uN99nYyJc3/e+9+UzJXRwfoTJzktB3g9/+MMNv0eZGsGfhDHGGGNMv5D19Oabb84fm9WarOf2W1aARitQPeGZil1cThmYa+F1GfE77iCKKFPzs5/9LPv85z+ffepTn8qvMQKnSoKiCCIKkUoy0GOPPTY3yOCS2qyu6bAQaxvXs5ribqyF17wvD8hWvofHJNmP11prrdx9mLqsuGrTv7GyKsYWl2FZXfk8ujlznYlTrzLR4/tsTFyFzzvvvNxairsLWbOwuqqDNEpPDdRNYyaKWU2Kf5eBDsuN1MkCysYYY4wxEpZYfxAgzZImVXH7bdUN0TUjWwdLndx/ceNuVaBGq+pyyy2X9w0MNQinUYF8NCn0UwR/jD1NraZqAx4RnvViVht9j5w4vMc9QvsqXpWJGaypWFX5DLfgaJXlNdc4xrryOdecOOU40SN4TSbj9H7zfTYmwvXHP/7xv3c+7bTZqaeeWnmWCbcK3DL4QSkDMyV08L/85S8tHa8xxhhjTEoUlojRRx99tGESl6pZfsu4IRaJXteMLA+ihVhVZQDmGrYLQgeRyvVdcskle54BuFcUJaBCzKaxp6nVVH2cR1lPi2JWi77HZA/ik0cspMQax3hVlRvinpIltQjFurI+GoHvcO3ZBxb1InS/IVjXWWcd32d9oC93kqytXHTNHlaBH2sldyoD8QJ0fjr2/vvvn+255565q0YMKifGpJ6bQlmYKTLGGGPMeJBaT7EOMb6oZ3Wtkn20nhtiMysQuGZkY7C4SahiBKnn3loWPPuWXXbZkbSq1oO+iHCsVwpI1tPUakpZH9YRvOaeSK2uRd+jnXELZvxODDCiNM0SjNWU7S+88MJNz4H1WB8NgOBm34jZZt9hn+D7bEyEKz+0sMwyy7T0ffmql/2h2WeffbJzzjknf/69730vXyLE2VJUmaVV+MOqF1hujDHGmNEiFZYI1hdeeKGu9bSq2287boiqGVml5M6oiyxZVXEJ7ZRVFbHEgpVwVK2q9aAtowAVvKfYU9qFGrYxI3C9RFayurI+90b8HkKVcD/uB6yj9SyneGRieUWElnHxRk+wPqWG8GYgBraZEQpvBwQruDZr7+nLXSZLZ5FvfNmZMihbvmaTTTbJPvGJT2THHHNM3XWaZTQ2xhhjjKlnPcXVEPFSz323qttvu+6+VUvujBpUkpBVFctcJ6yqJACSC/A4l1BUHGmRwYbxdLSe0ucZ7zezZALrsT7oe2wDa2ujHDiynALid8MNN6x0PrghM+nDZATi1wwufRGuuMYwK0mZmlb485//nD9WmT086qijsq222io7/fTT8+8zg8ONJ/ceOu04uHYYY8yoYyuT6TZF1lMsPogbBtyp9bQVt9923RBjyZ1VVlmladKoYYf2vPvuu2tilUoV7UI9VQlVrIfDWqKm09C+TNTEPixoozRmFTFbJnM194piXHlE7DI+b5a4VZZTM/r0RbjisqI6rMzK0LnLcu211+buHnTiqj/Ab3/72/OlyPq7xx57ZF//+tcrbc8YY8xgictxtzKZ3lDPesrYhCyyqfW0Vbdf3H1boV7JnXpJo4YVrMzRqtpuWR9cRWMG4HG2qtYjZu0t8pxEuMY6q1hMV1pppcr74RowcWBM34Urlk9iTpmt+eIXv5gdffTRpW8WBiFi22237eJRGmOM6QbdFJfjZmUyvaee9VTxfjyStCaKxU5k+a0y2VOl5M4wQTtTo1PlajphVSWJj6yqiy++uK2qTUiz9qZo8iCNWa3CUkstlceMGzMQwnXnnXfOjjjiiHwm5stf/nL+A0wh5kaQQXi33XbLa7fyI7z66qvnBZzLoGzB3EDp7NkGG2yQP5b5MzHGGDO44nJcrEymv9SznlJfPnpz4bYq62m7br9VJnuqltwZdBj/RatqkXtqVasqsaqyqhI/acoTs/ZyPdLMwmT2pd+nMatlYHxP4lZVDzFmIIQryQvI7Lvpppvm7gQf+chH8thTBO29995bW+/888+v1UT76U9/WqsXhUvO97///dL7Y6aHm+GAAw6Ywh2Y0jh8xo+YMcaY7tJNcTmqViYzWETr6W9/+9tawkgN4BGeuJvSBxnks37MPtqKm3yVyZ4qJXcG9TcCq6oyAKsSRTsgspQBmDGhY1VbJ2btJeRP/T/Gm2K5TmNWm8E1oa9i0eXe4bkxKX3L3U3GrzPOOCMXjghSEiYp6ZKCsLfbbrspsv4SpH3WWWe15C9fxF577VUTtQycjDHGdI9uictRszKZwSVaTy+66KIp3FUZuC+55JL5cwQuiR8Zw9DfW3GTrzLZU7XkzqCAOJVQ7YRVFQOHrKo82qraOWLW3rPPPnuK8jRM3OAVWdUKzkTQeeedl08A8b+wyy675NZbYyJ9LTq1ww475G4auAlfdtllEz7jBz4tUcONcsIJJ+Q/RK3gkjfGGNMdyliRuikuh93KZIaHaD1lTIJLcIQJ9rXWWqv2mj6OdWr99ddvyU2+ymRP1ZI7g2BVZcEduF1IAiSrKkLdVtX+grcB8a1YuxtNHMw999y5e/Att9ySG7LoF7ymXzhTsEnpe7VkfmAuvfTS/Ef8wgsvzK655po8ToRZRX5o55tvvuxtb3tbtuWWW7ZsEeVPhJnRTvwwGmOMmUhZK1K3xOWwWpnM+EA1BPoh90cVN/kqkz2tlNzp5f0gqyoL4qRdqypjxBirOttss3XsWE17EAbIRCb9kOvOpA1hgim4FE+aNClfX5mK+Y/gkddcW1tdzUAJV0HB324V/WW2B5/5q666Kv9h98DFGGM6RxkrUjfF5bBYmcx4w0CcsQiD8qKSOUVUmexpteROt+CeR6jj/svSrvEAa3NqVVVJQzNYkBSV648hCmGqeq4CaziTDngvxLqw/A9wnXmkhqutro15uEtl5QaZvghX4j2ADL/8qHV7NgUXY/4sSPTExcVvnjTb8Qfv9ttvz0477bS29rP77rt34GiNMWZ4KBt/1y1xOehWJmMAixJWV9wnSWaDpQkPhU7Gq3ai5E47EI6VWlU573bg9wFrqhZbVQcf+gFVQ6jjiot8rOeK1ZW+Sp4a/QfEurD0eQQuiVptdW3MuNYs74twpRPTsRGUvXABOOigg7KTTz45v8j8mH7605+e8DnHgrsyS6swQ2ThaowZN8rE33VTXA6alcmYIu6///687yNaEV+MfXh988035yFRnYhXbbfkTitwDiRTklh96qmn2toevyEIc1lVETu2qg4X9Al+86njGuu5YnXFyop3JQnMRLS2YtjCCsujra6NuW5Ma5b3Rbji6sIgpVd1mkhLT+YzMgjrRkpx4iZjjKlG2fi7borLfluZjClrbcUjgeckowEG5/R5cnvgOtluvGpMGtUtGCuxT1x/uddJTNWuVZU8JFhTlQGY12Z4ob9ioKJf8HtOf+E1fZ3+GUVram3FGxL4Hn1snKyuVdx+/1XH08nCtUswg8YPbi8HEFtvvXU+23PBBRfkZXcQsNwwp556aj7Dt+yyy+ZJoIwxxpSjbPxdN8VlP6xMxjQinQhPra0Sp8S58powJgaslPrDc4sxySB5EuDuKasqYqITVlXcnpVUyVbV0YLfY8bYTEBo4TXu8dwLMVNwam2VqKU8zjhZXau6/V5Xx9NpHOiLxZUZFxr9d7/7XT5I6VXKcgYtO+20U74IhCtsvPHG2de//vWeHMf/b+88wKeo7jV8xIIFK1dRwYKgYASJGMXYCIoNCyiKFSsEFGs0qFhAEzsiiSUWbFixB7uIoHItaMDCVWNEFBTFHjGxof/7vOfes5n/sGXm7Ozu7M73Ps8+22Z2ZmfPzP6+82tGCCHqnDj5d5USl26Gmm1kpTCFSD+cD/m8rUyWY1xi9zhoE4I3itzXiRMnWiG744471jSSwHlVXfgv+y+vqogK45Hx4urZcM/kDAI16D0Ne1sRqMFxxnMme7LgdY0T9vtDkUinLFAT4XrkkUea0aNH21m7iy++2Jx++um12A0hhBCexM2/SzqEMauFKUS6YEImn4cSA5xCNJwHztsK8+bNy/s5vI+IffHFF613Ci/kZpttZsd5NSIJ2GfOI+dVdfvrC14gPGwuV7Vdu3bKVc2QcMXL6q7HeFGZWAx7Tyma6rytgFc/H249lq9U95E0hv0WqvXwUpFIpyxQE+GKMXPjjTeaAQMGmLPOOste4IYPH16Ti9rIkSPtfbBZuBBCiHRX8q1EYYosthYQ5ZEvigAxS0hkx44d7RjleZSaHizH8hj+VGHlnEH0denSxYZOJgleVbxgTqiSqxr0BPtAAR5X/ZdcVQS1yB6MLSZh3HhiXPAcYRr0nhJlwDK0rCwFy7F8tfH5T0gq7NenrVwWqIlwJUSYIgKjRo2ywvGMM84wV155pdl3333N5ptvbmcPol6kaWqchHAVQggRjVrn38WdoY76mfLgirhjBuM0n5FNeC1GJeIVQz6K55Sxy/LBz585c6adnKFFCAIW+8gXvFtBr2qhYpVRwchmv1xhJXlVs0eHDh1yEzgu5JdwXgQfkAoY9N4Hvad4XZmswdtfCry25eS4MpHKNhmrUc8h3/+EpMJ+fdrKZYGaCFfa4HDBc3BRZ5DHzTHlM8rNuxBCCBGPWlfyjTNDHfczs9ZaQPjDGMnnpcQuwQh1Xtdyi8qwDXqicsPoxrhFMJSqD4JtNX/+/Ga5qvlCm328qq4CsDOcRTZx7SVxSD3yyCN2csTBtZnxSsh8Pu8pgpVlnMOqUiKUaKBHH33U/Pvf/7b/FQceeGCkXFmf/4Qkw3592splgZoI10LtZ9SSRggh0k+liy0VC8uKO0NdKw+uaGzcmAkWYnJwbuBlcl7XsOFeDp9++qmZOnWqzYWl1R/jPygeEQ5vvfVWrl1NueGVpHCFvapBx4MQwOTMrFmzmkUWUJQpnxcQ7yljiS4fccWkjwh1lYuZ+Nloo40iVSj2/U9IMuzXt61co1MT4Up4bzUvfBSDcrDd66+/Pu975RD+XCGEaFRK9YusZF5QnBnqWnpwReOCIXvOOefY9jX5ogkYy/RmxTvJsnvuuWfiOaoY4oQRky/Ypk0b+xp5qkl4VclHdEIVcVwJryqGOvvPOTZ9+nR7Q1g4B0ZSjgyOxbRp08xjjz1mnnvuOSvqmVRAPFEAC3t06NCh3kV/yBPmWLkJgp49e9qJhazhvKdEGDB+mKxBcBWatEF0xRWTPiI0WLmYa3zUCsU+/wlJh/2W01aukamJcK32SX3TTTc1E8pBgRl+rxwkXIUQWaeSeUFxZ6ij7m/SHlzRmBACTCeE888/P1K0AW1uJk+ebJ599lmz2267mV122SWR9n8uLxADnntCkoHx62PPOK+qqwDctm3bijsXEIvYX5WGa0S+Ss4IGhdCfc0115hTTjnFXHjhhbG/93HHHVeTokFpwnlB586da8N4mQxgUqCQaPUVkz7rBfvE8ttG6Qvr+5+QdNhvuMBhnEinRqZmocLVxs3e5bsoJTGzp9AZIYSobF5Q3BnqKFTCgysaDzx1hxxyiI0kiAvj+69//av1MB511FF2XPl8hhOr+cKToWXLlvbGsixXrErwKqusYg1yvIV4VZP2CJciaHfRu7Z79+52oivpXpTk+AKewP79+9tzGVHA8ZkyZYq57LLLbJEqJiSYVGBSIioPPviguffee+31ApGRVZw45Fgz6YGALXbN9BGTPuuF+8QyOfPuu++WFLw+/wmVCvsNFzjsm3BbuXokE8KV1js+7wkhhIhOJfOCKtGCpxIeXNF4vPzyy9ZbWm5vUwx6BBJRCIyxOF7VOK1qGKvcGNOsz2fhVaWgk/Oqcr6UM+FOVwjCpUuFxhZKG8ADTaFOzi2KPLF/PE9auNLqkO4RO++882LfFw/WQQcdZAUBucOXXHKJGTRokBU4peB6NWzYMPt49OjR5tBDDzVZJCgOGadEGSxYsKDg2PIVkz7rBYUu+bakuHBfTPCyHZ//hEqG/VaiwGE9kwnhethhh3m9J4QQIjqVzAuqRAueSnhwReN5WpMQrQ7C/P70pz/Z3vVhz2sUr2ocGM+tW7e23sbevXtbL6sTk3gL4/YrDorQctMG9t9/f1MNyGstBmL+7LPPtiG/hII/8MAD5ne/+13Jzx0xYoQNQe7Vq5cZOHBgZoVrUBwC3mvEXiEvqI+Y9FkvLHTXWmst+zrnHIXLCgleCkzF/U+odNhvnAKHWSATwlUIIURlqXReUDkz1Pm8PpXw4IrGgvFAeHBSotWBsXrDDTeY3//+93YbPl7VQlB0iBuhv84gZ/8JVWYMI9R8ctDDIjTKvtZLiynEp4PiVqWgkNSVV15pj9tf/vIXk1XC4pDrNddLKv7mE4W+YtJnvbDQ5ZwAzotCgpftMCHK+RnnP0Fhvw0iXAmJCUKidqH3yiH4uUIIIWpDpfOCfGeoC3l9KuHBFY0FoaM+Oa1RYFzdc889ZQs58jIxxrlhnBcK0eT8orruxIkTrZDlXIgjJsMilMmgRmkxFfRulyqehVd28ODB9lp06qmnmk6dOpmsEhaHHDs8oYg7rv1hL6iPmPRZLyx0eY/fzcFzzoGg4HVVuV2bnTj/CQr7bRDhigHiLqDcBwdN8L1yCH+uEEKI6uObKxo3VNenMEUhr4+MDVEMxFacQj0+cE4QBUBBpXK9qlHAXmL8k8+Jgc45FkVM5hOh+Sr11muLqaeffjr3mHzbYpDPyrWE8GvChbNKPi8oghWv5AcffLCYF9RHTPqu9+abbzYLX3777bfzfgcneFmec4mxzYRE3Kgehf02WKhwsYq9SfXpEkIIUTt8ckWrEapbzOsjY0MU45Zbbql42wnG++uvv14yZ7SYV5WcQqLYmCRyOayFoG0O59rnn39ujf8ZM2bY87OUmMwnQjm3GqHFFAJ+7Nix9jETCMUmxwgjPvfcc+1jQoWd5y+LFPKC0rs4nxfUR0zSW9dnPdoTISzXWWedkt+D5Viec4txiseYaKE4UT2l+pqLOhGuhPAW8qoWe68SuAtNpSHBXwghsoSvAK1GqG4pr4+MDVHrjgN4iRCuVGPlHMFzhfGPiHJCtZBXFfFJviX5say74447FuydybIILyZweMx2PvroI/Piiy/a7RQSk4VEKOdVIQdEPbWYItzXpa9RJbhYsSp6zyKiKCxFleKsUsgLigikOnQ+L6iPmASf9RDKrip3KTi/WJ5KyLRlIt8ZwSwyKFxdQ+y471UCyrZXQyhLuAohsoavAK10qG49eX1EusDTWmgcJw0GMwY2niLGOWMVURQlBNh5UAnNxLDnOSGsxZZFUGCgc+O8RbzyXZ9//nnb2iaqCHWhwgjuem0xRe77FVdckQsR/uMf/1hw2fHjx5snn3zSTirQ+zXLFPKCMikSLGQW9IL6iEnwWY/fiNZKcc9DUR9kpqpwnLBkRG6x5fO9X00PshBCpAVfAVpOqG6h3pD16vUR6QIvEWOzGmBLMJ7xsCIGCbNnjBYSoPk8qIgI7nmOUAx7XcPeVlrkACGdbAuj/e6777YTSkExGcWuQfQWW47wZcRE2lpM0Xv2qKOOyh2He++913qe88E16+STT7aPzzvvvFxV26xSyAtK7nQ4zNZ5QX3EJPiuJxqXTAhXmk+Xggv6VVddZUMg+CNp27at6dGjhw1r5oKLccWfCmE1zG4CfzTHHHOMPbGEECKL+ApQ8oIQnqUEaJzekPXo9RH/B16ZYIh5LUHUVBPGMfYE5xD5p/SObdOmTcGwX3j33XftxAxigfOPe0Qvn7XBBhsUXBZxhtDkWBPWyXNeZ5nbb7/d2j2lChTFAeHifte0tJh6+eWXzV577WWvDa1atTKPPPJIs+8cnhijryvilefYfFmnkBeUkOtwpw+OMeM6n6gVwgcJ1/8Pc+jTp481dohtp2oczboLMXnyZDv7RmU5eqNx0dtoo428fgAhhKhnXGGKKF7QuALUtzekT7EoUVsQN3hmKJZTazCyqwkCAOOeSXNCLRFTCMn27dvnXR6vKa07OF4cN0QuXlOe8zoeQSd6w8siHoITBIQMcw6y3RdeeMF07do1d36edNJJVoxwvtD2JeiRZBKfwlKEgg4cONDeCMWn5Q7nptsGxaMQqbVqMRW+LrGPu+66q/3OTBY88MADVqwXui7tt99+tlAX7LDDDuauu+4quj2E+Z133mkf8/sFP7tRKOQFZfIpOAHAGGAyhHOac+rAAw+MVQVbiMwK12IQYrPPPvuYOXPm2MIGDz74YMlKcSzHRXuPPfawIpb1KZDgjCMhhMgSPiI0igD16Q1ZjWrFojJg4OLZKuZprBSIRsYjYwMDvJowTtm+E6CMbYRrUICG81URu4hCJmOwPbjnOaKX912UASLRLevCkvOBsCVf9Y033jCbb765FXt8Fuc0n+0izRwutxWPKsuxjZVXXtmGIXfv3j3xvPW4E2P5rkvYbDvttJP1anNcJ0yYYO25YtclvLOOiy++uOQ2GTsINDjssMMaUrgWIixKXeXhf/zjH9a5E+7PWi3cOf2LX/wistfXZ7yJ6pB54XrTTTfZCzUzb7feemvk8uYszywcM2qcEFQgpCKdEEJkjbgiNIoA9e0NWY1qxaJyICii5EsnBYKO/E+EIgIHqj0JjVeUyAWEH4Y+opDnGNzhsF+WxahG5BOuiceTY8Y93lFe531yZHndhQQTaVCs3Q7nHZ/H8YiSu852OIfwwjoRWqkWU0lEZ2CrIVIpRsXxuPnmmxerKp7vulSs7Y9oTnCSJVh5mN8g3J+1WrAfjz76aG68RvH6+o43kRHhymBCAFKtDQODwc1giVJMCcMl2IjYhzvuuMPeE/bAbGccMHoonf3YY4/ZmTsJVyFE1vARoVEEqG+V4EpXKxb1D8IQocrNCbUgeA1LFWlMEoQjBYKAewQo+0gkGDmDQUHAe5wLzrvqzjHuec7rhHKyHKKXG9+jkADDiKfIDqHCbNt5S0uJUAQg5ytie8stt7TLV6qfZbnRGYSpPv300/b6BFdffbU56KCDIl+XCH8utT1XoIrKzNXOkU4LQUEY7PPKsQn3da0WPl5fn/EmMiJcqWJHXyzXr6lafxJByP3gpAonlEfFVVXjc4QQImvEFaG+bWqiVgmulNdH1DeMB4QgYrVUDisGOOK1GpMaRG8hNEsJUGCinu+AqOUxopHJFwfPOUeCohfvsctbDcN2CJ9kHzDsqQDsik2WEqHUBrnvvvus6OacZfmoxAnDLDUx5gQjhdeCrRbd9QLbjFxc13f2+OOPN4MHDy66HbXPKk+4hvu8Mn4576rtdfXx+rKOTzSQyIBwxQ1/6KGHLiZY3UWoULuZpMWtm20l58EHt16+WVshhGhkfIw9nzY1caoEV8rrI+oP8i4RMxjNeAjj0LlzZ+tpqzQUR4oiQPG6kmfqvK1QKF/ViV6Wd+dKGM61Dh062LBZQpLJ5dxss80i5/O5/WUfseeihlO6MEx+D+7JOXUeZdcX1KVxAYJ61qxZ1iPMcnGiM5xAdqKV8GmE9syZMxcTLrzGOCH1i9xitc+Kj5u8CHpb8eLzOvdJeF3j5Kv6eH0Za3GjgUQGhCtiD08rIpSLB02fDz/8cHPuueeaK6+80g4WZszd4HnmmWfMtddea2dKmCHk8QEHHJDIvhAezIzmlClTrEHEzGNUWJ71oFj+iBBCNCJxRahvmxpVCRZRYYzxn07eKsLFZ7Ibu4TKs4i5cMuPJMHWQbhGFaCcay6vtRTOhiqUQ+w+w+UAsg2i3xDsUXD7jCeb9K6ohr07lylo+dxzzxWs0nvEEUc0e05VY3JUwxNjxbaB6HVFpADv62WXXWZvhWDSwOW8q31W/PMm7G11PW/5P6CeTDle1zj5qj5eX9YhZZExLa97emlRi41ec801dmBw0T7//PPN73//+7wzJ4hUBtfRRx9tZsyYYS644AJ7MTr44IPNuHHjEtkXd6Hlgn3qqafGWve0006zfyx8D83ECCGyRDERynNnXAZz66IIUN5nuULbcVWC3Y3nhbYnsgFhs3hWqfJP+w3yGRFicUQrnjjGMC1PyH9EuB555JEV3W9SjRi/GPX5bojLoADF+Mb7SqGhUjeWCxd2YqKe8Nyg8HVeKc49BAEep1JwjtHX3h37qOde8FyOEsofBAEfnBgLXyfybcPnWsCEWZTrkshP2NvqCp5SxMt5XXmf5crJV2WsFvuMYl7fQtsn/N2J4vBErH7/jHtc+XNxFyLyDaKAOERYcrHDQ0tYCoWRCHUph0GDBuUKNF1++eV2cF5yySVF8zUQucOHDzfXX3997rXf/va3Ze2HEELUE3G9oL5talQlWOQDQTd//nzrWWWsBcdSVLAr2rZtawUeEy7hUFfSmYiqqkR7HMQj+dWE6haDfXICtFi+ajGwtfgMvLuFvFIY80zE43HCk1WqujdeSfad8zpqOGXwmoGNtfPOO9t2Mbvsskve9ICxY8daLymCggJQ+bygXEsKRWcg3pmAcODxI28xuM3wdggh9WmfVYsaLWkj7OVkjAcLqPKckG8fr2ucfFUfry/7yXvY93GigURGhCt/AvxhbLXVVgUHLfkTzICGOfPMM204MYPrhhtuMOedd15Z+4L4JSSFdjbsE/c0j+7Tp4+9MLviBszCEH5Eg+5HHnnEPudCxTr06srXjFkIIRoRHxHqK0BVJVg4+M9lTBHy53qZ+uDyOzFOi7XAI6z2D3/4gznqqKNyFWmTAJuCAkG+KUbYP3iU8dgS2lpsO3xHPE2uTkixHEDOWWyeJKp7l7ueT3pANa9LIr9t78YTMBGQD5dryvKbbrpppEMZJ181itc3vC4TYKxD7nW7du0ijTeRIeHKjAswOIIERSwDiFDhMFzYEIn333+/jXUvV7gCObNsD8HKCYEovffee+0tH8GZtf32289cd911Ze+DEELUCz7Gnq8AVZXgbMP/LWPBta/h/9kHwv7wOhJGizEaFYTfFVdcYY499thExCvGMzU+MIajCtAgeIY4nxBmiLDtt9++Wbsctw0EKN85n2DN55XC84xBz/MkqnuXs141ozM0MZYcjGeu3a7bRjFYjt8BL3+pQktx8lV9vL5Av1b2hXWijjeRIeGKJ5VBEfa2ujLsQAgQPZfyQZl64IKf1P6QF7PbbrtZjy65G6XCPjgxmYl1lZGFECIr+Bh7vgJUVYKzCUakE6vBAjtxoL0LnlUM3aB9EZeNN97YpgadddZZZYUNYzcccsghVrBFEaD5cH1csZEQm8F2OXiJcAjw+YUEayGvFMcHDzYeJ5fPV05176BhH3e9akZnaGIsGRjDXNsZ41FEHfY/4dnY8aUKLcWpUuzj9QV3HnLeyOuebmoiXBksDNbwn1HQA0vfrULC1V3MqGSXJAMHDrR/Ko8//rjNa6E8Ov3euIDi/WVGiHLxhBeTm1EqN0UIIRoRH2MvKEDj9HEU2YHxhBDj/9+3xRx5nAg5bhi3SYHYIpVo/Pjx9h7jOCoY8r1797aFn1wKVDEBWohgH1dEpmuXg9eI/WNSv5RgLZQDiCfbeUCTru4dd71qRmdoYqx8gtV+Oa7FRKgDcUiRJW7Y+oVa1MTNV43r9WV5YNzwX8T+F6vaHRxvIkPClXLreDWZSQ0SHLQ0tu7fv/9i6zIbSAl1KNXDyQcu+iTzBxP6hRBC/IdyjD3Xx5GJR8KzovZ/FI0J4bdMYtD2Do+HDwghQoDxrmJ0RhFvPuARpdLwgAEDbK2LiRMnmrfeeqto4ScKATFBE8ylLSRAXb/WQjix60Q9Ag1xxzpRWuQUywFEdHDP8yTDd33WU3RGfRGs9ltMhPoUWoqbr8oNERol/53PcvvJZCqTSvy3cR5GiQYSGRKuFGWaNGmSHWjBIkybb7659brijZ0wYYItkETrGweGDv1eXSsdDR4hhKgvnPfltddeM926dVOxiwzC74/HhT6pGLs+FVnpuY6XEbFKm5dqRkARgYV45UakVjh8mPdPP/30nGexlAB1/VqLeV2d2OXYIVQx8ilQhV0Up0JroRxAd8MhgA2WVPiu73q+E2OiusQRoXELLfnkq3Ie+RRLZXKJ1AImUqIWjBIZEq477bSTzQ9lkOM93W677ezrDOATTzzRnHLKKfaPjPzRiy66yJZ/ZzaQ3mzB4ggUS8gCzEbSrJsbRh+3zz//3L5HReObbrqp1rsohBAlCXpfuJar2EV2wAPCZAVilRA/vCJxwRDGG4JYxZuZhnQdvIhh2C/Gdj4RGvS28hixxrKlvK4Y5whi0pcIlyQsmHWKVVfNR6EcQF5ju4hUtpNUdW8VP2ps4lT7jVtoqZJVikX9UhPhSugJsxrkdtx888054QqEjZFjikeWk4DBH2wU7GZmR4wYYbbeemuTBZhNFkKIeieY68b1XS0GGhuM1FmzZlnxQ96qT69VIrLIV8PA5T5KAaNqwffJV+UY4VZIhAa9rQhEdyvkdaXaMAIS4x7xzzaj9KXMNwGOYY/YzZcDSK4fXuxgjl8S1b1V/KhxiSNCfQot+earisamJv8AGCyEuDDQwjOm/Ek9+OCDZtSoUbYEPUZOEGZZ8dYSMpxF+CMkR/iJJ56o9a4IIURkfPs/ivqC/3XyPhGrhIX69Fp1+aEYwlSeTeu4cOlOYXiN8R4WoWFvqysexT3LBr2uGPSEQhO+yHGM25eyUPEcbCxsiPAkAp9BaHMwxy+J6t4qftS4xBGhPoWWfPNVRWNTs6lLZiELzZzyJ3X++edb8Up4LJ5ZBC5/AFT1rVThhbRy9tlnW6OOG95XRD+FKIQQIi2UqhTs2/9RpB+My9mzZ9swYKrxhyeco0L4K8YvBY2CxYzSiDPCgzl3wciwfKG/YW+rE+QuPJfX+f7YOOR/c++T51fIy+WK53Ccw0Y+79Uqx09VxuuPuCLUp9CSb76qaGyqJlwRn1dddZV58sknc33ZCIFBgFEm/uijj7YzrEG4mKsAkzHnnHNOtX4mIYRIvFKwb/9HkV4QZwgxxCoTFr5heowBJjswXrEL+Jy0i9agEZ4v/BmvZjj0N+xtxf4JemsRjeSvMv6ZzGEZDP5y8/x8iudUE1UZr0/iitAkJmCEqJpwHTdunDn++ONzRQxcnioXaQYphsuYMWPMZZddZoYMGaJfRgghGqhSsG//R5E+aEmHWOXGf7gPeGcQq3QS4PcHxk64t3taCRrh+YpMIVwxyoNeVyr1BisJ42V0YKBj+HNbsGCBjUZwArTcPL+4xXOq7TlVlfH6w0eEqtCSqBvhesstt5jf/va39jEXzXDZe57zOjHsxxxzjJ2toZqwEEKI9FOqUrBv/0eRHjBAnWc1KLjiQHgqgoZbOLqq3ggb4WEY8+C8rohWJm4QucF+q4QQ43mlKFIhAVpOnp9P8Zxqek5VZbw+8RGhKrQk6kK4Mtt43HHHNROtzMZTDZg8Di7qGCrMtLr38cz269fPXuxF9eCPtRT5ilAIIbJNqUrBvn0c05hTl6VcPCYh+K7c8Br6gCjr3r27PV6EhzdKfYqgEY7RHq4sjBhkLAOik/GPaMTGcaKWcEqM+nwtfYICtJw8v7jFc8oZ6z6eU1UZr098RKgKLYm6EK7jx4+34pU/K/7Abr31VtOnT5/Flnv44YdtE28GN7N1rJeVHq1pIcoFSAgh4lYKTlsfR9+cuizk4tHqhOJKeFcp1hOOkIoCYeAUUUTw8Junoddq0gSN8BdeeMGGRYaFpyugyBhBtHJc6EnPc6r6YhO5FjW/+MUvbHhwHEqt61M8x3es+3hOVWW8fvERoSq0JOpCuFKIyXHjjTfmFa2w++67mxtuuMHss88+ufUkXIUQIt1EqRSctj6Ovjl1jZqLh/HJd0KsImjy5WyWglBXjgk5qxtvvHGqeq1WgqARPmHCBDNv3rzFxjHHIgwez06dOlmhGGxRw/ly4IEHRg7bjbJu3OI55Yx1H8+pqozXL1kQoVmKrqk3KvrvwmweMOtaqv8X4cEsxywvF0tRXcJ/vPlg9rRQTo8QIlvEqRTs0/+xEgaGb05do+XiIXwQLIjV119/PW9l3FIgTrt06WKPO/f1eBwqRT5PNQWauLlw6XCLmjjFkkqt61M8J7hunLHu4zlVlXGRZrIQXVPPVFS4fv755/YizYUrCltuuaW9ELOeqC7t2rUruQyVEoUQIi2VguMaGL45dWnLxfPxBhCG/cwzz5i//vWv1lPn4xUl7JcwV7aLJw7vXdbp0KGDjSZgDDJG8HyuuOKKufcZL4hLVz253BY1Udb1KZ7jfstZs2bFGus+ntM0XDuEyFp0TaNQUeHKD8+Fj/5kUXDL+TYvF0IIUXnSUik4joHhm1OXtly8OGKdsF+qyHJc8K4+99xzdn2Wp9VK1MnIjh07WrFK7mpQlAljTj31VHP77bfbqCW81wg35+FESBI6TUXlpFrURFnXp3gOwpVzmOJpCPEoY93Hc5qWa4fIDnFyyeNGHIjqU5VElHqpJMifwUMPPWSmT59u3nvvPVtYKmoIFd9x8uTJFd9HIYSoNWmoFBw3fNc3py5tuXilxDphqogoXue4u7Yq9F/l/4yIJoQOxpwr2JMPwlpdr1VyM0VpIRlsgTN37lyz2267LSZay2lRE3Vdn+I59I91FZKjjnUfz2karh1pwkVPuGMnihO3oFncXPK4EQei+jR2BYUYXHLJJeaPf/yjl7fX9aIVQogskIZKwXHCd31z6tKWi1dMrCNIXa9VjLvwb8CyGG98Bvc8R1wEva4cP9drNRjaKkwkIcnx47gy6c3vkU/wl9OiJuq6PsVzEFAU52KiI8pY9/WcpuHakRaC0RN4uXv16mWygk9FbZ+CZnFyyeNGHIjaIOFqjBk0aJCteuxT+l8IIbJGJSsFR8nfjBu+65tTl7ZcvLBYf+edd+xvQBX+YjmrGIkYZRjIrMc934XXKayEV5Xj3bZtW03CxiAsJJkEaNWqlZ1UwJNZqmhSnBY15awbhdmzZ9vvgmeemhelxrqv5zRtVcZrSTB6gmOEx5tzsNHxragdt6BZ3FzyuBEHooGFK6G35557bqTlHFGWh7PPPrusfaOHLK14nMeUnBBOInJ5CPHx+QMQQohGBk9PJSoFR83fjBO+6+sZSlsuntsfQlAJ60RY8H3ZPj1BC+WsBr2tCAZ+OzyC1JSgNcuZZ55p29mIeOQTkowHBCyvUbU3bCSX06KmnHWjfBfON8Kc+S5Rxrqv59Tn2uHbmsRnvWptKxw9wcQTedFPs1ygAABcRElEQVRt2rQxjY5PRW2fgmZxcsk59nEiDkSDC1d+dG5RcALynHPOqYpwHTduXO7xQQcdZK6//nr9iQshRA2IUmwpbviur2coTbl4eKfGjx9v6ygQXsf3wlhDtAS9p/lyVp23FeGKJ43jwmsYy3wO4cXyIsSnkJDkt0B8hI1knxY1ziAvZ90oMKY4lxgX2GBRxnq1PKe+rUl81qvmtsLRE3i6mUDC801Br0bFt6J23IJmcXPJ40YciAYXrpUKwU0ir/TFF1+09wxMRGwaZ56nTZtmQ8IcwZwPXr/pppuaLX/44YdXdf+EEKJaxZbihu/6eoaqmYuXz1tDYR0EPMKSgiEzZ860x4VtEY4K3GNsFcpZxYuDcYa45/j06NHDHi8Er7wI/hQSku63ofJyWEj6tKjBiw7lrBsFvEyIUMYe44TPKDXWGXPYYOTSVtIz6duaxGe9am0rX6oDEYd4vBG+u+yyS8NG+/lU1PYpaBYnl9wn4kBe1wYVrttvv33q82X4c2EfSYp3M6ZpA0F98803532Pk4hbEAlXIUSt8TVQixVb8gnf9fUM+a7nEzLovDWEqu24447WGKO1ivturiIwyyA6nZGWz+tKuguGHNvn9aeeespO0OIFlBchGQoJSSYWEK5u8iAoJH1a1DjKWbcUjBnGOJMehI9j4FNRuthY33LLLa1NUmnPZNzK4eWsV81t5Ut1QFTxW3CO+oR710OxJd+K2nELmsXNB/eJOGjkSteZFq5Tp041aYdBj1Gg3nRCCJEM5RioxYot+Ybv+uTj+niUfEIGX3jhBTNnzhwrLlmW+2DIbzBHlccYttw7eI5RR7QQhV3+8Ic/2JxX9mXs2LGpydFtJAoJSY4l4y6fkPRpUeMoZ92oRXIYQ3vssYcNuS/lrWW8VMMzGadyeLnrVWtbhVIdOOexRfH6lVNkK83FlnwqavsUJYubD+4TcSBqR+arCpNLwMWCvndphVDgcDiwEEKklXIM1GLFlnzDd8vxgsbxKEX93hhJeBoQrdddd5359NNPrfGExwvjNxjyy3vO2wpBowlDjEnX9u3bW4MLowxjLm05uo1GISFJGxp+i3xC0qdFTfBzg+v6tBIpVSQHYx3PMcK1GNXyTMatHF7OetXcVqFUB85lzn/aKPGb1JPXNUqxJd+q2HFFqE8+OOvxH8E1N0rEQSNXuq4HMi9cBw4caAtePPvssznDQQghhB/lGqjFii35hO+WUzgljkep1Pem1gMTpHwWIpH/GyZN+S752tQ4ww5xxLp4UQGh6sR9OL2lVjm6WaOQCGW8xMktrWYrkVJFcjDaERClxHW1PJNxKoeXu161tlUs1YF7V5G63NZGaSy25FMV20eE+uaDM6mJ/c9vUulzWJRH5oXrwQcfbK655ho7833yySfbqsJCCCH8KNdALZWHGTfsN25Yo69HqdD3RmS0aNHCilUEabE2NYQJhgstIWAxqKh0iTfPCdhK5egKf4r10s2Hj+fUp5VIlCI5ePoYrxQCo69vPqrlmYxbObyc9aq5rWJRELzOZ5ZTZCutxZZ8q2L7iNBK5oOLdJB54YphcPfdd5tdd93VhuNyUl166aXWaBBCCBEdwq3KMVCTzsMst3BKVI9S+Ht06NDBLo9onTRpUt4eq65NjSu4xA3vqvO68jn9+vWzngByV+MWOqxUr12RH35PJkcQoFFEqI/n1LeVSJQiOZynTJwgptiXcvsnl7Ne3Mmsctar5raKRUHwHpNMnPdMVNWDqIpabMnXC+ojQiuVDy7SQ+aF67nnnmsPBOXHmcG8/fbbzT333GNnn7t27Wpnt6MaDOX2lBVCiHrGeTejGqiVzsMst3BKVI8Sn4fHipY1rIcBiiBBCFDNN9xjNextde1tWrdubfe3Y8eOtv5Cnz59VDCpDnAilN+U+ygi1Mdz6tNKpNTnuCI52DqMU/L7kuif7Lue72SWz3pQrW2xXrEoiLlz5+YiLrhG1YOoilpsydcL6iNCy8klF/VB5oXrqFGjFhOmXIhoIcAtDhKuQois4ow5DJmohm0l8zCTKJxSSnhjZNJ/ccyYMbanNl5d520r1mM16G1lOTwVGLsIV7wNGLAYt2p2Xx84A37+/PlWAJYSkj6eU99WIqU+x02oIDQY57yeRP9k3/V8J7N81oNqbYv1ikVB4K1n/CDaolwPa02cYku+XlCJUJGPzAtXoPBFlNeKkfZ+tUIIUUkwPBFcCxYsiGzY+uRhRq0QXG7hlELCm0gcijzxGiLzgw8+sAZnlB6rGHdOgPN98MZuvfXWuXZs5H2pTU19ETTgEa9RhKSP59SnlUiUz3FFcminRIgqBcM4b8rtn+zrmfSdzPJdr5rbaiTiFluSF1QkReaF68iRIxM7mEIIkUWcgYpojWPYxs3DZDu0jylVIdgnrLGYZwgDjKI1GPUs57yqUXqs8h43vn/v3r3ta3zeyy+/bEULnpZ8qE1NfRBXhPp4Tn1biZTadrBIDvcIDiZikuqf7LOeb1Ex3/Wqua1GwbfYkhBJIOEq4SqEEGXhDFSEHWK0Uj1Do7apiRuemM8zxD15q3wnvLy8RxgfoaAY+IT9FuuxCggZto1Hdfvttzfdu3e3yxBWnGVvTaPgI0J9PKc+rUTyUaxIDq9TFRmhGj5Pq+kF9S0q5rteNbfVKPgWWwqTVD9ikS0yL1yFEEKUhzNQydHEeMegTlqMRa0Q7BOeGPQMYZA98cQTVowGvafgwn4RrBj24R6rDp678GS3b7TE4Xtn3VvTSMQVoT6e0yS8W04gfP311wWL5DApQ7iwizAInqfV9oKKdJNEy5mk+hGL7CHhKoQQoiwwOBFzFCrC+MVLUyjvP2igRs1XjVMhOG54IiG7b731lhUZGOqIXURmoX6pCFVXZAThwXOMMCfa6bXqqgTn+95Z99Y0Cj4i1MdzWq53KygQiBLo3Llzs4mc4PpMyjA+qSwcPE8r5QWNc/6L9JBEy5mk+hGL7CHhKoQQwpvBgwfb0F0MXzw6GKLz5s0zEydOLFq0DmP/tttuK5mvGrdCcNTwRLxACFYMJ5eLiqFdCkSIEykY+P379zebb765LbQkskNcEerrOS3XuxUWCEyw5BMIvE9xJgRkvrDOpIlz/ot0UW6136T6EYtsIuEqhBDCG4oW4WkNgnidOnWqzet0LWB881XjVgguFp6IkTxnzhx7I38VIwlDHS8xntIoIErwEHFr27atKspnEB8R6us5Lce7lWaBEOf8F41FUv2I86G82cZHwjUEYV+E+RBexkUeQ4c/jSioj6sQImvkuz5iZGN4k4u600472bBDn3xVnwrB4fBEPn/GjBk2JBjBCniduMXxMFBYCbGKwE17+zOFYFYWHxHq6zktx7tVSYFQDnHOf1EfRBWMSfUjLvTZypttfCRcAwP+kksuMVdddZWtIumDhKsQImvk82wiZt977z1bpfTee+812223nRWcTvBFzVcNLxu1PyxhvzNnzrRiFVERty+3C/ncbLPNrFgl7LiQ5zhtKASz8viI0CTyAtMiEMolzvkv0k8cwZhUP+Jin6282cZGwtUYG9KDVwAvaxQDhwtteLm0z8ALIUTSYBC7VjBhY3327NlWrGKoT5o0ybRr185sueWW1oMUNV81ToVgQpO5DmOUEzUTrggcBbZLeCZideONN655OKUPCsGsPD4itNy8wDQJhHK8/HHy1UV9EFUwJtWPOB9pDosXySLhaowZMGCAnZ13J9Dee+9tZ+oxADCE8KRinPFH4S64vM6M/7Bhw3JFGYQQIktwjcxXoRSjBOMar2vHjh3tax988IG9UcCJqJYo+aqlKgQjHtgO12WMFJbnM+KAVxjvFQZ3165dbb5rmsJ346ynEMzqkIQITbNAiDtW43j54+Sri/QTRzAm1Y+4nsLiRfK0MBmHfn1PPfWUHejM9FFl8sorr7SeAcfIkSPN6NGjzd13320NL+7xHhAi9/jjj5vf/va3dhkhhMgC5KWNHTvW7L///nlTKzBkH3vsMXPdddeZJ5980hoUQAGb559/3k4Mci3FYGFZ8lXxvjivC6+FKwR36dLF3hCZGNMITkQwXi+u33x2FA8YsDxtQQYOHGguvPBCM3ToUGukRxWtGPZUTZ4/f36k5Z1hj1HOvft+Sa+XLwST57wu0gfRAk8//bRtJeUrEPJNHEURCLzPcvm2E3esBr38iNdC461Yvnq+81+kn3yCMd/YKlTQzN14zuvFxnUhwp9NHQLfzxLpJ/PC9c4778wdjOuvv97OpBY9YC1a2PYHGF6dOnWyJ8UBBxzglUMlhBD1BAbG+eefb6vpnnTSSVbAFYPcPib6Tj31VPPII4/YHDsMVNIzMKK5f/31162IRTQSXhwUWlQIZhJxq622sjl6GEa02sHgB4wdvDTc8No4z1IhOnToYMX2BRdcYI4//njbb9blzEbFR4QWM+w5pldffbXNA8b7xHFhP4cMGWImTJgQSRDkEwUIfCcGOI4cu1K3KF5EClzx2zOJsOKKK9rIIyYWjjnmmLxCSBQP+8UDyn0p47paAoEq4VHHXDEvf77zIkq+uiZa6oc4gjFfQTOWcTdX4MyNa5aPSrGw+EITNKJ+yXyoMLP/QFgDf8RRwcC49dZb7Sz9tGnTrHFGyLEQQjQiRKMccsghNoQwLgiov/71r7ZPJAIUgwax6fJQMXgxqhGlGL20qsGQpSASy2DEfPnll3bZQgVxMHjxgLJesIoxy3Odptcqxky54btxc0iLhe/iMe7Tp89i4gCBf+2115obbrjBimsmTEvlABYLwUwK9um4445bTJS888479sbk76WXXmqOPfbYxLbZqMQpJBOn0JJv2x23HcLxiSaLWu03aqGlOPnqynWtD+LkUZfTj7hYQbJK5s2KdJJ54epmL8ltKlRsiYtsvhAy1x4Bw4eZdwlXIUQjQoTJLrvsYj2k5YAxghGBkYpIzQfik+svIbwYIQhajBOMDh7ni27B0EEAYLiwjd69e1svLdfnNm3aJFZ91yeHtJBh/8ILL5gzzjgjJ1r32WcfM3jwYGv4vfjiizb9BLH+7LPP2v+nYjmApVoGOUhrQXgWIty2KBydhBcYVl55ZXPyySebHXbYwf43UiPi4osvtuIVTzaCOWv/h3H6R8YtJFMtgYDIdYWfolT7jVNoqVS+usNtk+WZtBHpJK5g9K2qXaogWSXzZkU6ybxwda0c8AQU+gPnwl7I+MFLi1FHuJsQQjSipzUJ0Ro0lsmLpdWMu85i0DiBymMMEQQlxhC5rNwcwbBHlkfIIhpYhs/u0aOH3V/CY5OuvhsUoRSeIj8Rcch6cQ37yy+/3EbrAGG21FZwYGAh7Mkj5jvOnTvXipVCQrlUCKaDz4oTWeTAaETYQ6tWrex+Bz+HCQJCsDnm/BciXvEks2wWiNs/Mk4hmWoJBM4nPg97J2q13ziFloL56qVgOZYX6SWuYPQtaFYsMqFQWLyD5/xvyevaWGReuJKjw4U6fJHHSHAQklNIuLr1XFiOEEI0ChgGhAcnJVodGBfkSuIZdQLUgZGCMRy8BgcJCllCaBFnTEDi+cNbi3h47rnnbG5sIS+oj+c0LEIx0jHQ3etxDfsZM2bYZTDy6CEeXg9DEM8pBhv7yHbyCYIoIZgOxDDLx203Qn6yyytGwOYTvximY8aMsa3lFixYYG666aZcyLBvReWsh/1WUyCQX852mFSi+GSpar+lvPzhc4pJDQR1vr7PYTinS008idrhKxjjRCVEiUwoJyxe1C+ZF65cZBGu4ap+9PBzEKpVKGSFkwjUd0wI0WggqHxyWqOAEYJBETSG8bRMnz7deqEIO8UwJ881CGIVox3jFiOe5ciJRQizPoYx12PqF/Ts2bOsvLxC62DQOyHH5KUrKBPVsMdT6zxKFPsLFogKroexhRgC/qcQ52FBEDUE0322TwgmUUWO3XbbreByCCZ+E47JPffcY4WrT0h2PVHJsN+kPEqlBAPb4bchNJ3HpURo1EJLwXOK79m3b98Ej7yoFT6CEZs6TlRClMiEcsLiRf2SeeHK7At/9OEKZuRHYTAxQ0jFR0K5wmFP/BmzHicUFYaFEKJRwMtHBeFKgjEcbEODxxQDHUObKBeeY5RwjQ2KVVeDACMeT5Er7kQYJR4jjHg+g8+i7Q1ePieA4+TlFROhTrjyHxHXsA/m6VKhOUhwPTxfrVu3tsKc75Uv1zVKCCZC2e2rTwgm23cUij4CPOGIMH43Jg74TXxCsuuJSob9JuFRihLGzL4yrhnTfE4pEapCS9nGRzDGiUqIGpngGxYv6pvMC1dmiMePH29PCAwD90fCrOSuu+5qHn74YXvR3n777c2ZZ55pDQf+AOjhR0sFB4U1hBCiUbjlllsihfWVA8YJOZGIVwwc2uIgcjCiuSfklGsuKR3BgnkO8kxdex2W4cZ6PKeA0KRJk6wnFjGJCFx33XVz24iSl+coJEKBz45r2GNsOfByufDdfOshBBGOiHP2NVx5NUoIpsufZT9POeUUm4+KkGeft956a3P44YebXr16FVw/OGnLfhQCQU6lZOC7IMbihmTXE5UO+03Co1RKMLjv4LytjLFS1X5VaCnbxBWMnAcPPfRQ5KiEOJEJPmHxor7JvHDdfffdc57V+++/33pWHRdddJF58skn7R8SJ9l+++2X9yDyZzVs2LAq/mxCCFFZbrzxxqocYq6tCFfnbcWwwZhBuOHBw2jO11877G3FMwkYNwg0Xud9F/aIoMBjNXnyZBu2irh1KSHFQiILiVDXyoflXL/UqIZ9sKIy39GF7+ZbLyhI2UdEc7jyaqkQzIMPPnix7Qbb2DB5269fP5uXiuAPE0ydwXtLa6F8UF2Y/XdwrOOGZNcTlQ77LdejFCWM2Xl1nVedYmxM7oQJjjkVWso2cfOouY5FjUoAtbgRxci8cGV2kYISGE3hRvTkgzzwwAPmgAMOKDjLzAzmgw8+mJnqiUKIxgexVCxXMknwqmKcYzjjsSOH1YX8BsVnsLJwPm+rE5qEHfPceV1ZrmPHjs3WoVgQXi4+m4ryeGMLeV0LiVAnAp1Qi2PYsx8OJk5d+G6+9fBg8v8EHAdXJThO5VX+2/baay+z44472tBp/q8QLEzWMjmLt43/OgQwXuqwF4S8Vo4/Qou8Z/aBVjjBQkv8hrT3CUIBKo5z1JDseqJaYb/leJSihDE7ry4h4Jw7hAezTD7cmFOhJVGpqITwuFWLGxEm88IVivW1o60CITbXXXednT3GgMCw4uTbc889zWGHHVbXf75CCBEGgyIYzlpJEKtOFCKg8oX8BsVn2NuKYYRYcB5QYB0EX9jrmm8dBDPGu8tbDQurQiLU5Qxi6Lsqu1EN+6lTpzarp+AqqOZbj/8cPJnO8+nqKQQrr5aq2sv7wZZvGJBPPPGE/SyELJOvCHK8qX/5y19sO5sghKoOHTrUXHHFFfb4UGCJ/7/Ro0dbEcy6o0aNMo8//ngu5BnwbHNMo4Zk1xO1CPuFqJVZowoG59VlPDHBgdeYkPp8uDGnQkuiElEJ+catWtyIMBKuEeDEOf300+1NCCEqAcZoMLeslgSFVbW+O94ePHN4fjgOhKNhvCMsCV/kded1JW8VYUs1eIxuJ3zD8D7GuPNuFVuH54guvGXOc0r+ZykQlsEerPlCrskhDRf2w2Bz3kwnevIJAle5HvCahsN0o1TtDfcpDxdM4r+Ntkccd/rLhoUrIFI5JhRdYkLh5ptvtrcgCGcEP+LXiXv2L0qV2nqiFmG/brtRK7NGFQwu7JMJesYJEx9qGSKSwCfkVy1uRCkkXIUQIiV/8gg1jNJaE24PVmkw5vEy4tFBnGLgc89zBABePbxF7du3t8vjTQ3mtRaD5VzBoGLrIKAw3BHQccJwfcCj7EBAOuGaz3Ma9L7mS0mJW7U3Xw9bPpcw4scee8zmvCLGw55bQk0Rzvwu4VxWPKmDBw+2BQxPOumk3Ot40PnNSlWprTdqEfYLUSuzKkdQpAGfkF+1uBGlkHAVQoiUgGhFMIXzOasVsovXDg8nnrtqgqeV7WPEBL3OCCr2CYGFcGXGnmNDuCUi1IWkFgNB6sIzi62DMGM5DCpCcgmJpOJxIa666irrWURkhgtZkbeLRwFPQvfu3Rdbl5xaB4Vw+N6FPKcul5b9C65XSISW8mQW6mGLR86BgA4LV9ZjfGJ08p1JmeE47bTTTjZsmOcQHDvsQ7iicr4qtfXmda122G/cfrHKERS1xjfkVy1uRCkkXAswa9YsazAwY8zJduihh5Y8mEIIUS4Is2I9OZMEo5oiSIiXuXPn5ry9bma8WnCNxWhB8IVBEOExRVhh5BB2yv4FhVZUiq3D9jt06NAsVJLlC+WPuiJJwRxXwEh75JFHrADFk+zyUIMgVByEQWOsFfKc8j4gkthWFBFayJNZrIetKwCVj0Lr8TpClXBnxCfjiYJMgMDlmBYq8hWujFxPVDvsN06/WOUIiloQnoTxjUqIW7FYZA8J1wD8eVx88cXmjjvuWKyKcFi4YmCRB4SXAINm+PDh1fnFhBCiDBAbePm43jE5ly+vlnBajGOub9UAQUh13WIgFFx4Kh4svgNiLl/7lnwUWgdhQTGafJXjo+SP+oTuBsUsBZHoA57Pc8q+OoMv/BnFRGghT2a4H22wYFJQuObztkbpfTtlypTcccQbGxT0+ah0SHalyGdcx/Gexgn7jVuZVTmCotrkm4RRyK+oFBKu/w9idciQITafKGys5Wt8T6EQ/qgwOphdp/+rWuIIIdIIBgUeVSdQSlUMxghGvFZDVJDviVAKtyMLgwjDYMc7i5cOscY1ePvtty8ZWh1eB9GBuOA6Tmgw13iXB5t0/mg+EYlQQdghMu666y6z77775vWcnn/++bl19t57by8xmW/fOA7BgknPPPOMrbgMHOO2bdtGWi9YaIkJXCoLA7/HwIEDc17pQgQrI9czcb2nccJ+41ZmlWAQ1abQJEy5UQlC5EPC1Rhz77332oqKgGilQAehS/yRFwpvgEGDBlnhyglLUQuMDyGESAMYsBjR3HyKLdEmZdq0aabSIJIw5BGGUXJ78TQhphDgrIsgR2wVg2UwosipogUMYjkYrpuPJPNH8wneU045xRx11FF2n8466yzrnQx6Tvnvobcq0AooKFyD+8Z/EOu5zwxX7aVFDaG8YaHrJgr4z2NbbjKjT58+eb8TRimTGfkKLXGPWGObMGLECHPiiSearBDHexon7Nen0JIEg6gmxSZhFPIrKkHmhSvGHdUQXeP7s88+25x22mm2siT9XYsJV1dhkXAnerxKuAohagXXMASqE6v5Ql+jwnWtd+/eVrQ4UVQJXHgw24giQPGc0goH7ygz+dzznFDfsOjls/FMEQnDdRyxyTHCK0bRpa5duxb1iiWZP5pP8NID/IYbbrDv0WKGiVJENZ/D9+I1HvO/9Oc//7nZ9wvuWzDEOl/VXv7HMC7xlPK/Rt0GRBLHhOWoEIyIAjzQCCO26/qxuu+Ep3r69Ok2vJzjTbgscPzxZlPUCxDJZ5xxhskKcb2nccJ+fQotKUdQVJM4kzBCJEHmheu1115rxSsn3MiRI+3Md1SYtSfcCyMo2GtPCCFqWVzJB5frSQgoobsIJcQK1XMrhas4W0yABuE7YuwjvoB7DHUnehF5GE2IN/JYeU5xILYRx7CKIkLDxA3dRXASJtyjRw+be8ux5vbss882W6Zfv362VU2hfQsKV75nuGov4J0O5rDmK5jEMcELzYSAK5jEvftOwPjie3DLxx577GHuueeeuqsSXE3DPU7YrwotiTQTdxJGiCTIvHAlPxUIgTr11FNjH0BmyBGunKxCCFFpMBDweiEmEDz5iivFmXxDqHJDZLmWJsGidBTcIRczaRCceI0Q32EBWsrbymPEIMY+z7nfYYcdcu1yyjWsoojQIFHzQMNeV74Pntf77rvPesupscA+87uQssL3QUwGRW9YTAbb+zihCm5fKRzI6y+88IINS0Y0sQ2+N95oliEsnPtwwSTueU6Va8Ky2SfGnOs3jFDDy8t75Lj279/fenWzQtzxFTfsV4WWRJqJMwkjRFJkXrhSKZI/3+22285rlti1VygnLE8IIYqBoHHFlfCwliquVAwMCudZ5fqVr/icAxH4hz/8weZiJnmNwyhv3769FWBBAVrM6xr0tuJNZT32ndd4TqhquK+mj2GFuIgiQsnjdMWIeJ4vfzRf6K4ToE7s4h1lmZ133rlZuxt+czyjYdEbFJNQrHKv6zV6xRVX2AJMfGYpggWTuGesufUIH4+yXlaIO77ihv2q0JJIK3EnYYRIiswLV2agoVT1w2KGAYQ9FUII4Qu5mAjFcoorORB3GBUIL0Rh3OrnCDeEz7HHHpuIeHUVJBGg7Iu7FfK6EgqLYc/7PEYUYgzxObxeyEjyNazo4R1HhIa9rS782REO3XUCNOw5jdrvNCwmi+HEJIKqb9++sX8r3/WyQNzx5RP2q0JLIq3EnYQRIikyL1zdTL3rDxgXmtO7UGMhhChHrGK4vvfee9ZwLbe4Urt27axYxeNWbvgmufzXX3+9rQFQTtgw+0SFXPIoMdoxcIB7BCteV0JRCTvlNYQswpHjgWGEeOVaG8VI8jGsEBcISERhVBHqK0DDntNiBMN3JSbTQdzx5Rv2q8qsIm0o91rUkswLV3Jz3Aynz8lL5Uc8GpTAF0KIuNcQDFiuPwgaV901qeJKSYLn9cYbbzTjx4+393H2FQ8jYaaEB9MyhHBnvKy8TrQKYoxjgScKYcpj58HyMZLAZ5133nkn14szqgj1FaA+nlORDnzGpMJ+RaOg3GtRSzIvXHv16mX/WJgVpck8M5xRwXjDQ4BwpTCIEEKUAmHE9cZdd8ppN0MRHwQlYpUCQpVOWUAMH3nkkWbAgAHmwQcftCK2WBgzES1cY6mcy7r0HHXFlRCmCFbnqULEIuKTKFADcdfBU4aXGzEZR4T6CtB68ZwSVYRAxwvOhIjwM9wV9isaBU3CiFqSeeF60EEHmbFjx9qDMXToUFtBM0pYHXlQVGu0B3GppcwhhxxS8R9LCFG/f/SIMW4YueUWV3KVgKnyWqy4UqXAW0r4MMLrjjvuWEy0cQ3F+4uHlVBlxCkh0HinEO6EALv2L6VCJX2NpLjrIFwRywhKJgEqnT9aD/B73XbbbWbhwoW2kOEJJ5yQqVY3hfAZk+qvKhoFTcKIWpJ54cos8j777GPbEbz44ou2X97VV19dsFIjs6zkep155pk5b+ugQYOskSaEEC5fFQHmxKoLPS23uBK3YOXZNIRK8l3DIG4Q58FKwayDIMQLG0eA+hpJcddZsGCB9WDjIY4TeVNPxPWeurZARCN169ZtsV60WUWGu8gymoQRtSTzwhXGjRtnqwC+9dZbNmeVP2h65wVzuPbee29riJLzxCy0M9Y222wzM2bMmJr9gEKIdIBQQqQh6DD083kTo0KIrCuuxH3aemMGQyXxVIarrDtcpWA8slxDOTZxBaivkRR3HYRrIxPXexqslkwIdaFetFlEhrsQQtQGCVdjbLgdIcIHHnigmTp1qj0wCFlwYXgTJ06090HvAnmtd911V+qMSiFEdcCLyIQXQvX111+3HkZfEIC0W8Hrt/nmmydeXKlSoZLBcMn58+c3W472NRRbwtAnpDZNFVKZWECAM0kZJTS43onrPXXLEy3A/2C+XrRCCCFENUmvZVRl2rRpYyZPnmxuvfVWc9lllxWsJgnkdp166qk2r1X9W4XIFuRokuOO95AJrnKKKyFUERHc8IRRbRdRmGbRWixUMjiJR0sQclVpZ5NkH78kBCcTDo8++miugjCTlo0c9hvXexruTUvuL4XE5HUVQghRS9JtHVUZZpUHDhxob/xBEzaMB4E/evLKELdUx6TgiBAiO9DaAo9qEsWVqAJMDiViFQ+Wi+rAE1bvoZJcJ5nM69y5c0V6W+cTnIRV+/bgpDUPrcx4nobc4UqF/cb1ngaXZ3KFCQLu5XUVQghRSyRcC8CfOjlZQojsQUoA3k9XXGnu3Lnen4WQ69SpkxWqCFZSExqZjh07VkS0FhKccb25wcJSiDPXfmfLLbc0jRj2G9d7Gl6eiRYg35rtyOsqhBCiVki4CiHE/xdXevfdd3PFlYr1J41SXAiBgKjgPljAqJHhe+OZqwSFBKfr9xpX/CLA8D669juzZ8+299XueRp3nbhhv3G9p+HlCfUGPNLyugohhKglEq5CiMyCCCDU0olVDPZywmddCDDeQJ8Q1nqHvNY4fWXj5KsWEpxxvK5B8ctvv8EGG9jJCp5T+bh79+6mmj1PfdaJE/Yb13saXh4hzTFz8JzfTF5XIYQQtUDCVQiRKciPJF8VoVpucSXy3l1xJcRA1ou1xckTjZOvWkxwxvG6BsUvIptKx9zzHFFG/jK/ow8+PU/jrhM37Deu9xTPr1seChUpdOux/K9//Wuv4yWEEELERcI1AAbNww8/bKZPn277MdLaIjjbXAxmvqlKLIRIZ3El51UlP7Kc4koUZ3P5qhjv4v/AEzdjxgwrnqJU+42Tr1pMcEb1uobF71prrWVf5zdkAoOes9z7tOzx6Xnqs06csF8f7ynHhjZHG264YcnvzHIsL4QQQlQLCdf/L8RyySWXmPPOO88rVJD144THCSEqC+ckFcFdcaV58+Z5fxa9SF1xpa5duzZ8cSUfnPcUAYaYKVXtN06+ainBGdXrGha/5OMC+cc8R8TxmbQ6oo9uHHx6nsZdJ27Yr4/3dNttt7WTOoRNlwKvLcsLIYQQ1ULC1Rjbj/XOO++0xq4Qov6LKzmh4wuipkuXLtarmqXiSr44Ufjee+9FqvYbJ1+1lOCM4nUNi1+WX7RoUe59nlMkCa8rAg/hXSrXtJyepz7rxA379fGe4snu27dvpO8thBBCVJvMC9fbb7/d3HHHHTmPKZ6VAQMGWKMVo2ippTJ/iIRILQiAt956y4oS8lbLKa608sorNyuupHO/MtV+4+SrRhGchIGX2iYFoJz4BXJZ84HXdd11183lbkap+OvT8zTuOj5hv/KeVpc4hcaEEEL4kXlVNm7cuNzBOOmkk2zIcNYLrAiRZjD4CedEqGAoYtT7gkhwxZUQLDr34xO32m+cfNWogtOty/JMPoT56quvrFdxnXXWKfg9WKZly5bWc++EcqmKvz49T33W8S2aJO9pdYhTaEwIIYQ/mReuFGvB2KLgyujRo5WrKkQK+fzzz+25ilh95513vIsrca4jFJxYpSqw8Cdutd+4+apRBKeD5Vg+H23btrUeea7ztC3KB4KR8Fu8l3gro1T89el56rOOiialmziFxoQQQviTeeH63Xff2QOx3XbbSbQKkRLINydM04nVcoorEfIbLK5ESLBIhrjVfuPmq3JjksJdp4vBZ+UTC4jladOmWW86n7P33nvn9YYhOii8hXBFRJaq+OsTvgs+fVIV9ts4ofJCCCH8ybxwJTyQMDCFCApRW/CYzZ49OydW8bL6ghAiTx2xSs6ZE0giOeJ6T33yVfGO+rSnKdcbFqXir0/4LviE/KpoUuOEygshhPAn88K1R48etrgLuVFCiOqCgOHcc8WVorThKATeMldciUqqKq5UWeJ6T5PKV620N4x1olT89Q3fVZ/U7IbKCyGEKI/MC9djjz3W3HzzzXYmnYIveGmEENUproRnLhgqGRe8fE6sqrhS9fDxniaVr1ppbxhjM0rFX9/wXfVJzW6ovBBCiPLIvHCl0fzQoUPN1VdfbSsBTp061bRu3brMwyqECIKACRZX8u2ZjPjAq+HEKoJCVB8f72kS+apx2o74eMNYh/BdxGipir++4buq9JvNUHkhhBDlk3nhCldccYWd4b/uuuusx/WMM84w/fv3z/0RCSHigTD94IMPrOGGYOWx90VqqaVM586dc8WVClWFFdXDx3uaRL5qnLYjPt4wBLj77KgVfx1Rer6K7IbKCyGEKB8JV2NsYaZrrrnGbLzxxuZ3v/ud7dfHjeqj3PDylIJlKCwjRNaLKyFWuREq6gvGHyIVz6qKK6WPpLynlSq05OMNI9SZ9xDZcSr+QpSeryLbofLyugohRPlIuP7/n9Dxxx9vbrjhBitAXRgjBgytEErB8lHErRCNBkYbxj5e1SSKK7n+qhS8WXLJJRPdV5EcSXhP44T9xi205OMNI4yYdT766CMrOqNW/IUoPV9F41CLQmNCCCEkXK2XiJyjxx9/3I6HcO6dby6eEI0KXiVXXAmDrJziSnixnFgl7FQTQNkhTthvnEJLvt4wxjVeZIp8sUzUKsHBfq6Fer6KxqIWhcaESDNxJiGFKIfMe1yvvfZa89hjj+U8rb1797YGFGGK5ESppYYQ/1dcyYUAEw5cTnGlDh06WKGKB0J/cNk1XOL0V41TaMnXG9apUyeb04pXFvEatUpwlJ6vorGoVai8EI0wCSlEOWReuNIKxzF69Gib4ypE1kGYzps3L1cJmMIzvjD5Q/64K6604oorJrqvov4Ml7j9VeMUWvL1hrVq1cqG/hIFEDWsM+htLdbzVTQWSYXKC9EIxJmEFKJcMi9cOcGYJcdLINEqsgxGPK1qXCXgcoor4bmiQjdiFdHqcgxFYxLXcInTXzVuoaVqesOC3tZiPV+FEKIRiTsJKUS5ZF64Onr06FH2wRSi3sBLhPHPHw15q3jMfMED5vqrduzYUcWVMkJcwyVuf9W4hZaS9IYVa3ET9rYW6/kqr6sQohGJMwkpRBJkXri2bdvWegnwNgmRBShCQwVgRMJbb71VVnElzh9XXKldu3YqrpRB4houccJ+a9l2pFSLm7C3NU7PV5FtVMhGNAJxJyGFSILMC9cddtjBFu8o1PpAiEbg008/zeWrJlVciVup6quisYlruMQN+02q7YiPUCjW4ibsbY3T81VkGxWyEY1CnElIIZIi88J1yJAh5rrrrrPGybPPPmu22267xA6uELUuruQqAc+fP9/7sxAQrrgSeasqriR8DZe4Yb9JtB3xEQqlWtwQPuy8rRCn56vINipkIxqBuJOQQiRF5oUrxvh5551nTjvtNHPAAQeYyZMnm86dOyd2gEXjg0GM4YqniQs4hi2eJwxvFz5YDTDcCXt3xZW+/PJL788i3JEKwHivEK0tW7ZMdF9F9gwXn7DfJAot+QiFUi1u2EfOtw033LDkfgV7vopso0I2olGIOwkpRFJkXrjC8OHDzSqrrGJzmDbffHMzdOhQ079/f+tdotCHEGHwwtxyyy3mxhtvtKIV4zpMixYt7AX7iCOOMIceemhFxhIGPSIBoUreKn8kvvBn40KACQdecsklE91XkW3DxTfsN1xoKU7Yr49QYJ1SLW7o4co5/69//avkcQr2fBXZRoVsRCNQy9oDQmReuIaNc0Isx44da29xYFY+eOKKxoTf+OKLLzbnn39+SaMVw3bGjBn2hkd/xIgRdpKEvqbl8PXXXzcrrlTOuKOgkqsErOJKopKGSy3Cfn2EAtW1o7S46du3b+TjJYQK2YhGIanaA0L4kHnhilDFoHEEH/sWsBGNCSLxkEMOsflqcUHknnHGGea+++4zt956a+xwdLxMLgSYkORyiivRqsZ5Vlu3bu31OSLb+Bgu1Q779REKrEMEBeerWtyIJFEhG9EoJDEJKYQvmReuIIEqSvHyyy+bXXbZxXqRygHRi7fmiSeesGHpxcbk3Llzc8WVPvroI+9tYpwTVumKK7Vq1cr7s4TwNVzy9VetZNivj1BAgDtvrlrciDgUG8sqZCMaiSQmIYXwJfPCNV9uYprBoPrzn/9sHn74YVs1lqI55CMOGDDADBs2rKrFgLLkaU1CtDr4nJ133tnmywU9r4RaBosrlTNL6YorIVYprqRWHCJthkslw359hALnH+9x3qnFjYhDqbGsQjaikcg3CSlEtci8cK0nHnzwQRuqSo6jgz9KvIHcxo0bZwUtoaAiOYOEY56UaHXweQMHDjRTpkyxXh6MaHLryimuRNivCwEmLFLFlUSaDZdKhv36CAU+j3WIbmCiRy1uRBJjWYVshBAiOSRc64SZM2ea/fff3/45Eup5+umnm169etnnd955p+1FiwDafffdrYhVr81kuOSSS7xyWqPA77TTTjuZzTbbzPszCNVEqFL4oG3bts1ytIWoJmkJ+/UVCgsXLrRe5HXXXdcuUwy1uBFRx7IK2QghRHJIuNYJtOrBcKMiLfmRwWb2O+ywg+0nSMVaxOull15qRo0aVdP9bZSWN1QPriSIVwycqKG8tNhxxZUQqyquJNJAmsJ+fYVCp06dbKoFXlnEazHU4kZEHcsqZCOEEMkh4VoHTJ8+3Tz77LP28VFHHdVMtDpOPvlk21MUI+xPf/qTrWCrvlnlQZ/WKH0aywFPEIY1RZMKgagNFlfCaBYiTaQp7NdXKBDJwrV17bXXVusGEYkoY1mFbIQQIjkkXOuABx54IPf4iCOOKOiJO/TQQ20IMYYYuZMUABL+MBFQDZhsCAtXjGhXXIkCTiquJNJK2sJ+JRREtYg6llXIRgghkkHCtQ6YNm2avcfTVqyFSs+ePXOPqVgr4eoPntZCxVmS5vPPP7cGOiGQweJKTEYIkXbSGPYroSAqjVrcCCFE9ZFwrQMwxoDcRnJcCxFsreLWicoHH3wQKazO9RitdAhtrXnhhReq1iqJ40mRpj59+uSKK5VTXVjUJ+SH0l6GW738/hjv5GkjHNnn9u3bmzlz5tjnvM4ETNDrSpsnqqJ/+OGHZuWVV7aVr/kMrms8d6/PmDHDCtAFCxbY4+EEbjFYjuV9j5079vwOjX59SyP1Nv7jjuW0o/FfW+pt/DcajTD+V8hIGtkSTVjNIrVwIpHLBVQMfuihh4ouT4gpJ91WW21lnn/++cjbUTVaIYQQQggh6o+mjMg5xSKmHFo0BEVp1BkXcs2EEEIIIYQQohFQqHAdeFwdUQr0tGzZ0t7HDTWZN29eyWW22GILGwJI1c1CuWaNwh133GEGDx5cte2NGzfOHHDAAVXbnkgfb731lg01rBcIlSSknlxWJtUIE3YQLszkGbmqRH8QKklldJaNMqnG57HudtttZ6oNoc3BtAtRHepp/NfLWPZB47821NP4b2Q0/tOPhGvKca0fgGImpfj+++/tvQsvjkq7du1KLkMOjwsrbvRYetrPVHt7jX5MRXGKFV5LG1yLnnnmGZvPx7WGCtjB8YuxTnEz3qfKeffu3W2fVNaJkj/EZ22//fa2SqvIBvU0/jWWRZbHvxC1RMI15ay44oq5x1Fmd51RGCWsWBSGaqhU9a1GgSa2QyVhIeqFv/3tb/Z69P7779vnhSpw8z4Vg1meHql9+/at8p4KkTxMqGgsCyFE9ZFwrQOPa+vWrW3LlFKVf7/88succF1nnXWqtIeNyfLLL2/FKxUhKw3bYXtC1Au0raHK+IYbblhyWZZjeR+ozIro/dWvfmVTFIQQQgiRXSRc6wDCSMmpeeedd8yiRYsKtsQhR8Kx8cYbV3EPG5MjjjiiKsL1yCOPrPg2hEiSbbfd1kYjRA37pS3OxIkTYwlQwpFvu+02W6Du73//uznhhBMi5fkLIYQQojGRcK0TIxHhipGI96FHjx55l3v66adzj7fZZpsq7mFjMnDgQHPaaadVtKcXRj3bEaJRQyURoGPHjo0tQF966SUbjkwRKELpea7rmhBCCJFd1A6nDujXr1/u8Y033ph3Gbwf48ePt49XWWUV06tXr6rtX6NC8/gRI0ZUdBt8/korrVTRbQhRS4ICFPHK8yhi97//+79tFfN//vOf9p7nUQrUCSGEEKIxkXCtA7bccstcKf3rr7/ePP/884stc+mll5o333zTPsajQUlvUT7Dhw+vWLU/wib5fCEaFV8B6sQuxZ2oYs49z6OIXiGEEEI0JhKudcKf/vQn23aCHNedd97ZXHDBBbaH4pQpU8yQIUNyAmijjTYyJ598cq13t2Egn/jWW281q622WqKfy+fxuYXylYVoBHwEaFDs0t6LHH/u5XUVQgghso2Ea52w2WabmQkTJtiwUgw/QkxpL7HDDjuYa6+9NidaH3744WYtdET5dO7c2TzxxBOJiVc+h8+jF6AQjYqvAA2K3TXWWMOsvvrq9l5eV5FmqIBNAbL58+fXeleEEKJhkXCtI/bcc0+bJ3bSSSdZkUoLFfJZCTm96KKLzMyZM03Hjh1rvZsNCeHCGNvlhg3zWz333HNqNi4aHh8BGha766+/vn19vfXWk9dVpBZXAZsxzb1ysYUQojJIuNYZGHBjxoyx1TmpdkvvVv4sCRVWL9DKe14Jzz7vvPNsNeA4sDzrkZ8sT6todHwFaFjsumsa54+8rqKRCpAJIYSIj4SrEDEgJ5UwbcLBrrjiCtO9e3fTokX+04jXeZ/lWJ71lNMqsoCPAA2LXfq9/vjjj7kbz5XrKtKGKmALIUT1UGUYITwg13jYsGH29u9//9u8+uqr5t1337WGdcuWLc0GG2xge0/KCy6yRiEB6uD5J598kvO6brHFFravKz2qndiFV155Je/n8/6aa65plyfPP+k8RT6XkH72UwifAmSMT/UdFkKI5JFwFaJMEKcY0Ekb0ULUI74C9LPPPjM//fST2XDDDUtug+VYvhJ5ioR6kopBWzEEtRBRJ2k22WQT8z//8z+LTcoIIYRIBglXIYQQiXkrv/jiCy8Buu2225qff/7Z5u6XgpBjlq9UniLREvKYiXIKkMnrKoQQySPhKoQQIjFvJXnctO+KUlk1KEBXXXVV07dv31TlKcpjJnwKkCFoNYZEllCahagWEq5CCCES9VautdZaZptttqmbo6o8RVGJAmTyuoosoDQLUU1UVVgIIURmq6qGPWe/+MUvVL1YxBozqoAtsozaQYlqIuEqhBAiUW9luNVNveYp1tP3ELUtQIaQdTdXkMyNIZYXohGp94lLUX8oVFgIIUTDVlUtlnulPEXhQ60rYAuRFpRmIaqNhKsQQojUV1X1Kf5RKvdKeYrCh1pXwBYiDdTDxKVoPCRchRBCxKaa3krf4h/FWtwUylN08PyTTz6RESYWo5YVsIVIC2oHJWqBclyFEELEJoq3Ml+OKJ7TiRMnmvnz58feFgIU8Rol77RU7pXyFIUQIvmJS54r11VUCnlchRBCxMLXW+njOfXtsVoq90p5ikII4YfSLEStkHAVQggRi3zeynw4scjyv/71r4uG7iZZ/CNK7pXyFIUQIj5KsxC1RMJVCCFELHy8lT6eU9/iH1Fzr5SnKIQQ1Zm4FCIJJFyFEELEwsdb6eM59Sn+oRY3QghROZRmIWqJhKsQQoiKVlX18Zz6ClDlXgkhROVQmoWoJRKuQgghKoqP59RHgCr3SgghKovaQYlaonY4QgghUtU2oZAAdTee51tXLW6EEEKIxkUeVyGEEGVDf1aE469+9SsrLMvxnPoW/1DulRBCCNG4SLgKIYQoi0L9WX1Dd30FqHKvhBBCiMZFwlUIIURZFOrP6us59RWgyr0SQgghGhcJVyGEEN4U68/q6zmVABVCCCFEGAlXIYQQ3hTrz6rQXSGEEEIkhYSrEEIIL6L0Z43T71UIIYQQohBqhyOEECLx/qy8zvtCCCGEEEkg4SqEEKIq/VmFEEIIIXyRcBVCCBGbKP1Z5XUVQgghRFJIuAohhIhFof6s7sZzeV2FEEIIkSQqziSEECIWvv1ZhRBCCCF8kXAVQggRC9/+rEIIIYQQvki4CiGEiIX6swohhBCi2ki4CiGEiMWqq66q/qxCCCGEqCoqziSEEEIIIYQQItVIuAohhBBCCCGESDUSrkIIIYQQQgghUo2EqxBCCCGEEEKIVCPhKoQQQgghhBAi1Ui4CiGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIIYQQQohUI+EqhBBCCCGEECLVLFXrHRCikRgzZoy9CSGEEEJkhd/97nf2JkQlWaKpqampolsQDQOC7OuvvzYrrbSSLk4hPvjgA7POOuvU5ocRQgghhKgx8+bNM+3atav1bogGRh5XERnNpEVjzTXXNEsuuaRGlsgMP/30k/n444/tY41/kTU0/kWWCY5/ISqNhKsQCfPSSy9pxlFkNuJA419kDY1/kWUUcSaqiYozCSGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIIYQQQohUI+EqhBBCCCGEECLVSLgKIYQQQgghhEg1Eq5CCCGEEEIIIVKNhKsQQgghhBBCiFSzRFNTU1Otd0IIIYQQQgghhCiEPK5CCCGEEEIIIVKNhKsQQgghhBBCiFQj4SqEEEIIIYQQItVIuAohhBBCCCGESDUSrkIIIYQQQgghUo2EqxBCCCGEEEKIVCPhKoQQQgghhBAi1Ui4CiGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIIYQQQohUI+EqhBAp4L333jNLLLFEordRo0aZLDFnzhxz1113meHDh5tevXqZlVZaqdnxEOlF4788vvzyS3P33XebY445xmy99dZmjTXWMMsss4w9Bzp06GAOOOAAc9ttt5kff/wxoV9MJInGvz/ffvutmTp1qrngggvMQQcdZDbffHM7/pdddlnTsmVL+5hz4uSTTzYzZ85M8FcTtWCpmmxVCCFEZsCoQEhCz5497fMk+eijj0zXrl3N559/nujnCpH28f/NN9+YAw880DzxxBPmhx9+WOx9hOrChQvNu+++ayZMmGDOPPNMc/PNN5vtt98+sX0QopbX/yuvvNL8/ve/L/j+p59+am/PP/+8GTNmjNl///3NVVddZVZbbTX9cHWIhKsQQqQAPCPDhg0rusz06dPNSy+9ZB+vvfbaZu+99y66/JZbbmmywPfffy/RWudo/PsL14ceeqjZa23atDG/+tWvzJprrmmF6yuvvGJee+21nGdvxx13NPfff7/ZY489EvjlRBJo/CfD8ssvbzbeeGMbZbDKKquYRYsWmQ8++MC88MIL5uuvv7bLMIHzxhtvmGnTptnjLuoLCVchhEgBzP5eccUVRZch9NcJ1w033LDk8lmjVatWpnv37lawb7HFFua7774zhx12WK13S0RA4788Vl11VXPooYeaI444wnTr1m2x9zHSeZ9weoz5gw8+2Lz99ttW5Irao/HvD/+F5513ntlll13s2F9qqcWlDf8FY8eONWeccYb5+eefzeuvv25GjBih/9A6RMJVCCFEXYPxPWvWLDvT3qLFf0o3JB2SJkTaII/17LPPtvl7xbxH2267rXnqqaesYY/niRuGPHmBQtQzffv2tbdikO962mmn2XD6kSNH2tfGjx9vRo8ebd8T9YOKMwkhhKhrlltuObPJJps0E61CZMVTd84550QKeVx//fXN0KFDc88ffvjhCu+dEOniyCOPzD0m9/udd96p6f6I+OhfXgghGpQ333zThkMROotXEu/M6quvbnr06GG9NPPnz4+cR3f11Veb3Xff3ay77ro2j2jppZc2K6+8suncubPZc889zfnnn2+9nuHQZqr5usIc8PTTT+etgIxRLYTGf2XZZpttco/JdxWNi67/i8P/XxDEq6gzmoQQQtQFI0eObOKyza1nz54Fl/vuu++ahgwZ0rTkkkvmls93W2655Zouv/zyott87rnnmtq2bVv0c4K3H3/8Me/+lrqtt956TUkzZcqUZtsQ9Y3Gf/lMnDgxdz4sv/zyCXyiqBYa/+UzY8aMZv8J8+fPT+BTRTVRjqsQQjQQ//rXv2yRiv/+7//OvUaFRXrbUcDliy++sO/hbaX/3XHHHWfz3fDMhpk3b579LDcrjZeVokcdO3a0Xle2hdfm1VdfzVVsDIKnl0rJH374oXnggQeKVkNu3bp1wkdCZBGN/+JQlMaxzjrrVPz3ENVF478w5LeS5+qgt+taa61Vld9FJEhVZbIQQoiKzrgfeuihuWU22mgj63UMs2jRoqarrrqqqWXLlnY5PLN4VsOceOKJuc/abrvtmj788MO828TLOnXq1KaDDz7YfnYxz2cxT3HSyOPaWGj8l8dPP/3U1Llz59y5OGzYsIR+GVENNP7j8/333ze99957TbfcckvTL3/5y9zYX3HFFZv+9re/VeBXEpVGHlchhGgQnn32WVsp0XlZ8az+13/912LLLbnkkuboo4+2RY1on/HTTz+Zc8891zz66KOLfZ7jhhtusN7SfNB+gMby3ISoFRr/xbnqqqvMW2+9ZR9TyIxrgGgcNP7/83/Ef1ohNtpoI3PvvfeaLl26VO23Ecmh4kxCCNEgjBkzJvf40ksvzStagxx++OG2uBI8/vjj5vPPP2/2fjD8N1zUQoi0ofFfmP/5n/8xp59+eu75UUcdZStxi8ZB4784TNiSEsO5INFav0i4CiFEA7Bo0SIzadIk+5jWGHvssUek9VzF36ampmZ5seEcOKoKC5FWNP4L89VXX5l+/frZ6uCw4YYbNhM5ov7R+P8P1FVwNyZnd9xxR7PiiitaLyzV7+n3/dhjj9Xw1xLloFBhIYRoAF577TVbmMMVUTrhhBMirffSSy81K8YUZMCAAeapp56yjylqgTA++OCDzU477WTatWuX6P4LUQ4a//n57rvvTN++fXP9KpnUuueee0yrVq004BoIjf//8Kc//Wmx48N/45VXXmnbwHEu0NqN9JfDDjusqr+TKB8JVyGEaACCPVkJ+eVPOi5ffvlls+eDBg2yM9OuIvDkyZPtDejnut1221mPLYZxqbBkISqJxn9+L9z+++9vnnnmGft82WWXNRMnTjSbbrqpBmODofFfnBVWWMEMHz7cRhvss88+5ueffzZDhw61/2EbbLBBlX4lkQQKFRZCiAbgn//8ZyKGbjgn6L777jPjxo0zv/jFL5q9N3fuXHPbbbdZcUvRJu5ptSNELdD4bw6GOWGSCFVXsObuu+9WAbUGReM/GrRiI3TYRSNQsEzUFxKuQgjRADCj7MCjQs5q3NuoUaMW+9wllljCFnKhoMXf//53c+2119rwquAs9Y8//miuv/5627f1008/rdp3FsKh8d8cvElMLLkKwlQbj5r3LuoPjf/okOriCNd1EOlHwlUIIRqANm3a5B5//PHHFdkGbQQGDx5sbrrpJjN79mwrZH/3u99Zzyzw2jnnnFORbQtRDI3//3DSSSeZ6667Lvf8mmuuMQceeKAGUAOj8R+dVVddNfc4XElfpB8JVyGEaAB++ctfmpYtW9rHn3zySa4YSyVByNJ2JyhWXWhi2GsrRCXR+P8/zjjjDDN27NjccbnssstsGL9obDT+o/PRRx/lHq+22moV+T1E5ZBwFUKIBmC55ZYzO+ywQ+55NXN39tprr9zjBQsWLPY+RWGCYcVCJI3GvzHnnXeebffhOPfcc82JJ56owZYBNP6j89BDD+Ue0xpH1BcSrkII0SCceuqpuceXX365efLJJyOvmy+8+LPPPou0brCNzhprrLHY+61bt849/vDDDyPvkxBxyPL4pwXImWeemXtOBdWzzjqrItsS6SSL4582NxRZispf/vIX8/LLL+ee9+/fP9H9EZVHwlUIIRqEnj175vrSUSGYXnUXXHCB+eabb/Iuzx8+rW5oZxP0mjpoeTNkyBDz9NNP2yql+cAIOO6443LPd9ttt8WWad++vVl++eXt4/fff79Z71ghkiKr459+lOS1OoYNG2YuuuiiRLch0k8Wx/8//vEP07FjR3PJJZcs1oc8LMw5Rzg3HLTCUcGy+mOJJkpJCiGESD1U/XX5pBgpU6dOXWyZ77//3hohTzzxRO41jIYePXpYQ4Q82K+++soWUpo1a5ZdHjbffPNmM9Hh3NQVV1zR5lGtt956toIls/FvvfWWrTbsWH311c0rr7xi2+OEOfjgg83tt9+e259dd93V7o8r7ESu0YgRI7yPDY3lw/m1GGx8T0e3bt0WW49wynxGm0gfGv+L8/rrr9vz0gkLzk3ES9S88hNOOMH2thTpR+N/cfi/2WyzzXLP119/fdOlSxfbV5z/uq+//tr+T7322mvmp59+yi3XqVMnM2XKFLPWWmtV6dcTiYFwFUIIkX5GjhzJRKO99ezZs+ByixYtajrrrLOall9++dzyxW5LL71007Bhwxb7nFatWkVan1u3bt2a3nzzzYL79N577zWtueaaBddfb731yjo2hx12WOR9Dd5uvPHGsrYrqofG/+JMmTLFa9y7G+uL+kDjf3FmzZrV1KJFi8jjnWUHDx7c9MUXX9TgFxRJsFRyElgIIUQawIuJJ5EQLvo3kuv0xhtvWC8pxZFWWmkl6znt2rWr6dWrl+nTp4/1loahVcAzzzxjQ8UI7yIsi+JLhJjhNW3Xrp311JInhNeSfpGFYHuvvvqqueKKK6w3+O233zYLFy60IW1CaPwLoet/XDbZZBMbBjxp0iTz3HPPWc/qu+++a/+7+K8jUogcW/7rttlmG9sWqm3bthpqdYxChYUQQgghhBBCpBoVZxJCCCGEEEIIkWokXIUQQgghhBBCpBoJVyGEEEIIIYQQqUbCVQghhBBCCCFEqpFwFUIIIYQQQgiRaiRchRBCCCGEEEKkGglXIYQQQgghhBCpRsJVCCGEEEIIIUSqkXAVQgghhBBCCJFqJFyFEEIIIYQQQqQaCVchhBBCCCGEEKlGwlUIIYQQQgghRKqRcBVCCGGZOnWqWWKJJeztN7/5jY6KyBQa/yLLaPyLekDCVQghhBBCCCFEqpFwFUIIIYQQQgiRaiRchRBCCCGEEEKkmiWampqaar0TQgghhBBCCCFEIeRxFUIIIYQQQgiRaiRchRBCCCGEEEKkGglXIYRICa4VDTfHK6+8Yo4++mjTqVMn06pVK3vr0aOHueqqq8yiRYsW+4yXX37ZHH744WbjjTc2K6ywgmndurXp1auXue222xJph/Dee+/llll//fWbbXfQoEFmo402Mssvv7xZddVVzZZbbmnOP/98869//avodgt9ZjFYzq3D+oX47LPPzOjRo03v3r3N2muvbZZddlmz9NJLm1VWWcVssskmZt999zVjxowxc+bMibRdUTk0/jX+s4zGv8a/iAA5rkIIIWoPl2R3g4suuqhpySWXbPZ68LbLLrs0fffdd3bZRYsWNR199NEFl+V2wAEH2OUKMWXKlNyyPXv2zLvMnDlzcsust956TT///HPT2Wef3dSiRYuC223fvn3T7NmzC243/JlRYDm3Duvn44EHHmhaddVVix4Td2vbtm2k7YrKofGv8Z9lNP41/kVplooiboUQQlSXa665xpx66qn28aabbmp++ctfmiWXXNK8+OKL5o033rCvP/744+b444+3yx5zzDHm2muvNS1atDBbbLGF9bj+/PPP5tlnn815E++8807TrVs3c9pppyW2n+ecc44599xz7WP2sWvXrtajiad4xowZ9nW2369fP/t8qaWq87eDBxhvqvNKL7fccmarrbayntqWLVuar7/+2syePdu8/vrr5t///ndV9klER+O/PDT+6xuN//LQ+G9gIohbIYQQVZ5xb9myZdOaa65pvaBhRo8enVtuqaWWahozZox9vPHGGze98sorzZbFw3riiSfmlm/VqlXTN998k4jHdZlllmlaYoklmjp06ND04osvLrbsXXfd1bT00kvnlr/55pur5nHt169f7v3+/fs3ffHFF3k/59tvv216+OGHm4YMGRJpu6JyaPxr/GcZjX+Nf1EaCVchhEih4bLssss2zZo1q+CyvXv3brb8Gmus0bRgwYK8yyJeO3XqlFt2woQJiQhXbq1bt2768MMPC+7nKaecklt21113rZpwZb/cBMDChQsjfaaoLRr/Gv9ZRuNf41+URsWZhBAihQwZMsQWDyrEgQce2Oz5iBEjzBprrJF3WUKMBwwYkHs+ffr0xPaT7VL0qBBHHnlk7vFLL71kqgWhwEChKApaifpC4788NP7rG43/8tD4b1wkXIUQIoWQn1kMcknjLN+lS5fc4yQr6O63335F3+/cubPNL4XPP//cLFy40FSDddZZx95/+eWXZsKECVXZpkgOjf/y0PivbzT+y0Pjv3GRcBVCiBQSFJr5oN2MY+WVVzZt27Ytuvxqq6222Gx0ubBdZyAUa/EQ3Nektl2KoIcZ7/Q+++xjBewnn3xSle2L8tD4Lw+N//pG4788NP4bFwlXIYRIIYjCYgSr85ZaNrz8jz/+WObeRd8uUGU46W2X4swzz7RVhIH0sfvvv98ccMABpk2bNrbX7FFHHWVuv/32qnmARTw0/stD47++0fgvD43/xkXCVQghUgieykosmyS12m4UVlhhBfP000+bSy65xLbACfKPf/zD3HDDDebggw82a665phk+fLj59ttva7avYnE0/stD47++0fgvD43/xkXCVQghRN1Bj9pSLLPMMuaUU04x7777ru0r++c//9l6XYNh1fRwRdz26tVL4lXUDRr/Isto/GcXCVchhBA1JRhKvGjRokjr/POf/4zlvejWrZs57rjjzB133GE++OADM2PGDHPEEUfklnnxxRfNlVdeGXPPhSgfjX+RZTT+RRwkXIUQQtSUlVZaKfeYKsD/19KwMHPnzi27yNNmm21mw4UHDRqUe23ixIllfaYQPmj8iyyj8S/iIOEqhBCipqy44oq5qseE7r799ttFl7/rrrsS2/Zee+2Ve7xgwYLEPleIqGj8iyyj8S/iIOEqhBCi5vTo0SP3+Kabbiq4HGG+F1xwQdHP+v77780333wTabvz5s3LPV5jjTUirSNE0mj8iyyj8S+iIuEqhBCi5hx00EG5x2PGjDH33nvvYsu88MILpmfPnjacmMJLhfjoo49sf1kKM7388ssFl5s0aZIZOXJk7vluu+1W1ncQwheNf5FlNP5FVP7T2E8IIYSoEVT7HT16tHn11VfNDz/8YPbdd1/TvXt388tf/tL89NNP5rXXXjMzZ860y44aNcrceOON5v333y/4eV999ZW59NJL7Y0wZHJaqSa87LLLmk8++cR+HtWGHfR2PeGEE6ryXYUIo/EvsozGv4iKhKsQQoias9RSS5n777/f9O7dOycoqfzLLVgdeMSIEebss8+2wrVYlcqWLVvakGH44osvzOTJkwsu/5vf/MZWG6b3nxC1QONfZBmNfxEVCVchhBCpoH379tYTevnll5v77rvPFmlCfK699tpmu+22M0cffXSzXKhC4Fn9/PPPzVNPPWWeffZZ87e//c2888475tNPP7XeXIqBrLfeemaLLbYw+++/vxXLQtQajX+RZTT+RRSWaCrVd0AIIYQQQgghhKghKs4khBBCCCGEECLVSLgKIYQQQgghhEg1Eq5CCCGEEEIIIVKNhKsQQgghhBBCiFQj4SqEEEIIIYQQItVIuAohhBBCCCGESDUSrkIIIYQQQgghUo2EqxBCCCGEEEKIVCPhKoQQQgghhBAi1Ui4CiGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIUYBRo0aZJZZYwt54LESW0PgXWUbjP30sVesdEEKIrPL111+bRx991EyaNMm8/PLL5tNPPzWfffaZWWaZZcyqq65qNtpoI7PFFluYvfbay/z617+u9e4KkSga/yLLaPwLER8JVyGEqDL//ve/zdixY83o0aPNl19+udj7P/zwg/nmm2/MvHnzzOTJk82FF15oRSyzvwcccID1/tUbwX1uamqq6b6I2qLxr/GfZTT+Nf6FPxKuQghRRebOnWv23HNP89prrzV7fd111zWbbrqpWX311c1PP/1kPv74Y/Pqq6+aBQsW2Pfffvttc9BBB1kxO3z4cP1moi7R+BdZRuNfiPKQcBVCiCrx3nvv2ZBfRKnzQh544IFmxIgRZpNNNllseTyThBBffvnl5rbbbjM///yzna0Xoh7R+BdZRuNfiPJRcSYhhKgChP/ut99+OdG67LLLmvvuu88K0nyi1QlbclzHjx9vva9dunTRbyXqEo1/kWU0/oVIBnlchRCiClx88cXWe+q4+eabTb9+/SKvj2h94YUXzCuvvFKhPRSicmj8iyyj8S9EMsjjKoQQFebbb781f/7zn3PP99lnHzNgwIDYn7PCCiuYbbbZpuD777//vjn77LPNVlttZdq0aWOrE3PP85EjR9r82FJMnTo11/7lN7/5Te71p556yhaG2mCDDay3uHXr1mb77bc3V1xxhfnxxx9LflYQ91r4Riidg8fu9fXXXz/3+rRp08ygQYNM586dzcorr2zfP/HEE/Nu//HHHzdHHnmkLWy10kormeWWW86st956Zu+99zY33XRTwf0WyaLxr/GfZTT+Nf5FgjQJIYSoKOPHj6eMYu42bdq0xLfxxz/+sWnZZZdttp3wjfcvvPDCop8zZcqU3PI9e/Zs+v7775sGDx5c9HO7d+/e9Omnnxb9rCi3OXPm5NblsXt9vfXWs/sxZMiQvOudcMIJzba7YMGCph133LHk9jbccMOml156qejxGDlyZG55Hov4aPxr/GcZjX+Nf5EcChUWQogKg7cyWD24mNfUh2OPPdZceeWVueetWrUyvXr1MmuuuabNqZ0yZYptr/Pdd9+Z0047zb522WWXRfrs3/72tzasuUWLFqZHjx7W00mRKMKW//73v9tlZsyYYQ499FDzyCOPNFu3bdu2ZtiwYfZxcP/ca2HwihbipJNOMtdcc4193LVrV9OtWzez9NJL22rL7JuDKswc39mzZ+de69Chg933li1bmjfeeMO8+OKL9vV//OMf9jg99thjif8m4j9o/Gv8ZxmNf41/kSAJimAhhBB56NChQ85rt99++yV6jCZMmNDMi3j44Yc3/fOf/2y2DM8POeSQZsvde++9eT8v6CVt2bKlvd9iiy2a3nzzzWbL/fzzz01jx45t9plPP/10wf0MLheFoMd1ySWXtPfrrLNO0zPPPLPYst99913u8W677ZZbb4UVVmi64447FlseL+sGG2yQW47P/fLLL/Puhzyu5aPxr/GfZTT+Nf5Fcki4CiFEhVlqqaVyImnUqFGJfe5PP/3U1L59+2aiGEGZD17v27dvblmMKdYvFd5LOO3ChQsL7sO+++6bW3bo0KEVEa7cll9++aa///3vRdd56qmnmq3z0EMPFf38lVdeObfsOeeck3c5Cdfy0fjX+M8yGv8a/yI5VJxJCCEqyNdff20WLVqUe77KKqsk9tlPPPGEmTNnjn1MISYKQIULITl4nXBdwmuBUNpJkyaV3MaFF15oQ48LQfEjx/Tp002lIByaIkvFcKHEsNdee5ndd9+94LIUfKJ/ruPqq6+2fXNFsmj8J4PGf32i8Z8MGv/CIeEqhBAVZOHChc2eFxOB5eRO9enTx+a0FoOc01133TX3nNzXYlA9eM899yy6zGabbZZ7HKwKnDRUNC5F8PsEBXUhjjjiiFx+7EcffZTL2RXJofGfDBr/9YnGfzJo/AuHhKsQQlSQFVdcsdlziiQlxcyZM3OPt95660jrBIsQUVSpGJ06dcp5aAtBW5ygd6ESsA8UZCrGhx9+aD755JNYx2P11Vdv5sUtdTxEfDT+y0fjv37R+C8fjX8RRMJVCCEqCJVyl1rqPwXcv/rqq8Q++9NPP809pj9pFII9UT/77LOiy9IntRRBYRsMiU6SVVddtdkxLHUs6NeKKE36eIj4aPyXj8Z//aLxXz4a/yKIhKsQQlSYoKikHUtSBL23K6ywQqR1gsuFw9jCFMqXrTYI0Uoci7jHQ/ih8V8eGv/1jcZ/eWj8iyASrkIIUWG23Xbb3GPXQzQJgvmy//rXvyKtE1wuHMZWz/gci0Y+HmlC47/yaPynF43/yqPxnx0kXIUQosLssMMOucfvv/++ee655xL53GA47Ny5cyOtEyyg9F//9V+mUQgei2+//TZy2G+jHo80ofFfeTT+04vGf+XR+M8OEq5CCFFh9ttvv2aiaMyYMYl8brCib1QxHFyue/fuplGgYvIaa6wR63ggbt9+++2GPB5pQuO/8mj8pxeN/8qj8Z8dJFyFEKIKOTrHH3987vm9995rb3EhrDUoyIIz+Y888kizqrr5mD9/vnn00Ufzrl9paK3j+PHHHyuyjV69euUe33TTTSWXZ5mff/7ZPl577bVtFWWRPBr/Gv9ZRuNf418kh4SrEEJUgeHDhzfz6A0cONA8+OCDkdefNWuW2WqrrcwTTzyRe23nnXc27du3t4+///57c+KJJxZcv6mpyRx33HE50dihQwfTu3dvUy2CbXNoXVMJhgwZknt8//33m8cff7zgsoRsn3feec3WTUsxqkZE41/jP8to/Gv8i2SQcBVCiCrQsmVLc/fdd+fCWcnD7Nevnzn00EPNm2++WVBsvvTSS+awww4z3bp1s+I1SIsWLcyFF16Ye37HHXeYwYMHL9Yrlmq5RxxxhLnvvvtyr1188cV2/WrRpUuX3GOOQ6U8rrvttlvu+b777pt3W3/729+saHetidZZZ51mHnGRPBr/Gv9ZRuNf418kQ/HGeEIIIRJjgw02sFWF99xzTytCCVO95ZZb7I1+optuuqnNhf3pp5/Mxx9/bF555RWzYMGCZp8Rrnw7YMAA88wzz5grr7zSPh83bpyZMGGCFXFt2rSx4cOTJ09uJmbxzO6zzz5V/WX79++f84CeeuqpNmR5k002sQad44wzzrA9+8rhxhtvNNtss42ZPXu2/c4cnw033ND06NHDLLPMMrYdEb8BkwKuHQ6Cf5VVVinzG4pSaPxr/GcZjX+Nf5EATUIIIarKwoULm84999ymVVZZBfUU6datW7em+++/v+Bn/uEPf2hq2bJl0c9Ydtllm84///yi+zZlypTc8j179oz0fYLbKMQPP/zQtP322xfdvzlz5uSW57F7fb311muKw8cff9y0ww47lDymHTt2bJo+fXrRzxo5cmRueR6L8tH41/jPMhr/Gv/CH3lchRCiBj3nzjrrLBueSlGlSZMm2fBVvKNffPGF9QyuttpqpnPnztZTSEhxqYq3Z555ps2bxeOKZ3POnDk2FBZPIjP9u+yyixk0aJBZd911TS1YeumlzZNPPmmuv/56W5gKjzPf9Ycffkh8W3ia8TI/9thj1vs8bdo068Emv5dQbaoxc0wPOeQQu1+iumj8a/xnGY1/jX/hzxKo1zLWF0IIIYQQQgghKoqKMwkhhBBCCCGESDUSrkIIIYQQQgghUo2EqxBCCCGEEEKIVCPhKoQQQgghhBAi1Ui4CiGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIIYQQQohUI+EqhBBCCCGEECLVSLgKIYQQQgghhEg1Eq5CCCGEEEIIIVKNhKsQQgghhBBCiFQj4SqEEEIIIYQQItVIuAohhBBCCCGESDUSrkIIIYQQQgghUo2EqxBCCCGEEEKIVCPhKoQQQgghhBAi1Ui4CiGEEEIIIYRINRKuQgghhBBCCCFSjYSrEEIIIYQQQohUI+EqhBBCCCGEECLVSLgKIYQQQgghhEg1Eq5CCCGEEEIIIVKNhKsQQgghhBBCiFQj4SqEEEIIIYQQItVIuAohhBBCCCGEMGnmfwGllgKfHggRLQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA64AAARECAYAAAB1fkwYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzsvQmwRGlZ3t8oKC6AWUzCJgPDzMCwR9kJS6ASVFQojWETo2JKJFQgkpBgkQWDoFgEwQqxWGJUCGpFDKuiCBGQVYaZYRhmGFYBjWZBwBXM/OvX/n/XZ975zunue7vv+j5Vp7pv3+5zvu18533e9TpXX3311YtGo9FoNBqNRqPRaDSOKb7oqBvQaDQajUaj0Wg0Go3GHJq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNYo4lro9FoNBqNRqPRaDSONZq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNYo4lro9FoNBqNRqPRaDSONZq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNY47pH3YDGycFznvOcxWc+85nFDW94w8U/+2f/7Kib02g0Go1Go9FoNM4IrnP11VdffdSNaJwM3OxmN1t88pOfXNz0pjddfOITnzjq5jQajUaj0Wg0Go0zgnYVbjQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go9FoHGs0cW00Go1Go9FoNBqNxrFGE9dGo9FoNBqNRqPRaBxrNHFtNBqNRqPRaDQajcaxRhPXRqPRaDQajUaj0WgcazRxbTQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go9FoHGs0cW00Go1Go9FoNBqNxrFGE9dGo9FoNBqNRqPRaBxrNHFtNBqNRqPRaDQajcaxRhPXRqPRaDQajUaj0WgcazRxbTQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go7EvXH311Ys///M/79Fr7BzX3f0lGo1Go9FoNBqNxmkiq5/73OcW//f//t/lcaMb3WhxzjnnHHWzGqccTVwbjUaj0Wg0Go3GSiRZ/fznP7/3+ac//eklmb3Oda7To9jYGZq4NhqNRqPRaDQajSH+8A//cPF//s//uRZZFV/0RV+0uMENbrD4whe+sLje9a7Xo9jYGZq4NhqNRqPRaDQajWuQVS2rf/Znf3atkcGyinvwX/krf2X5+sVf/MU9eo2do4lro9FoNBqNRqNxxvFHf/RHS6KKdXWKrN7whjdcktWv+qqvarLaOHQ0cW00Go1Go9FoNM4g/viP/3jPDfhP//RPr/X/JquN44Qmro1Go9FoNBqNxhkiq7oB/8mf/MmQrBKzqmX1utdtutA4HuiV2Gg0Go1Go9FonGJAUHUDHpFVAFn9q3/1rzZZbRxbNHFtNBqNRqPRaDROKVnlwMo6QlpWOyNw47ijiWuj0Wg0Go1Go3EKQJyqZJVkSyN85Vd+5ZKscjRZbZwkNHFtNBqNRqPRaDROKMgAbIKlKbL6FV/xFXtuwF/yJV9y6G1sNLaBJq6NRqPRaDQajcYJI6taVqm5OkVWtaw2WW2cBjRxbTQajUaj0Wg0jjk+//nP7yVYmiKrX/7lX75HVr/0S7/00NvYaOwSTVwbjUaj0Wg0Go1jTFY5Pve5zw2/82Vf9mVLN+Amq43TjiaujUaj0Wg0Go3GMcEXvvCFPbL62c9+dpKsalm9/vWvf+htbDSOAk1cG41Go9FoNBqNIyarn/70p5duwFNkFYIKUcW62mS1cRbRxLXRaDQajUaj0Tgisqpl9eqrr77Wd4hT1Q0YK2ujcZbRxLXRaDQajUaj0TgE/Pmf//keWf3MZz4zSVZ1AybZUqPR+As0cW00Go1Go9FoNHZIVv/gD/5g6QY8RVYpV6MbcJPVRmOMJq6NRqPRaDQajcYW8f/+3//bs6xCWufIKgc1VxuNxjyauDYajUaj0Wg0Glsgq5BUySp/V1zvetfbI6tf+ZVf2WPeaGyAJq6NRqPRaDQajcY+ADnF/Rc34CarjcZu0cS10Wg0Go1Go9HYkKxiWcUdeGRZve51r3sNy+p1rnOdHt9G44Bo4tpoNBqNRqPRaMyAGNUkqyRcupZQfd3rLr7qq75qmWCpyWqjsX00cW00Go1Go9FoNPZBVr/4i794z7J6gxvcoC2rjcYO0cS10Wg0Go1Go9H4/8nqZz/72T2y+oUvfGFIVrGsQlZveMMbnkmyyjj98R//8eJzn/vc4g//8A+XSadudrObHXWzGqccTVwbjUaj0Wg0GmcWkDAIGAmW5sjqjW50o6Ub8Fkkq8TxQlAZJ8lqWqC/9Eu/tIlrY+do4tpoNBqNRqPROJNkFcsqx4isftEXfdE1LKv8fVbAeEhSOf7oj/5oWItWfP7zn1/+hjjfRmNX6NXVaDQajUaj0TgTSLIK2aqAnGJZhazyelbI6p/8yZ9cg6j+6Z/+6ez3cQ0mAZXHl33Zl505K3Tj8NHEtdFoNBqNRqNxaoFbK27Ac2QViypuwGeBrGI5xYKaRHVkcU5c//rXvwZRxTW40ThsNHFtNBqNRqPRaJw6sqpl9c/+7M+u9X+sg2lZJYb1tIJY1BqfOqo9m2PzFV/xFXsklfftAtw4Dmji2mg0Go1Go9E48cCKCFHFujpFVrGsQlaJXT2tZJW+pzWV7L9zYBzSmvrlX/7lp97q3DiZaOLaaDQajUaj0TiRgJTpBjyKyzztZBW33xqfOiLtCdx806JKfGqjcRLQxLXRaDQajUajcaLIqm7AkLYRWb3BDW6wR1ZPk5trlqXxNcvSjIAFNS2qJFZqNE4iTs+d3Gg0Go1Go9E4lYCg6gY8IqtAsspxWsjqpmVpcPGt8amnzcrcOLs4HXd1o9FoNBqNRuNUklWOqTjNtKyeBksi7s5JVKdI+nEqS4PFl+NLvuRLDvW6jbOHJq6NRqPRaDQajWND3CSrWBdHgKBpWT3JZPWkl6X5zGc+s/jf//t/L+eKUkLnnHPOkbWlcTbQxLXRaDQajUajcWQgmZBuwFNkFZdXyBGW1ZNq2dtPWZoan3rULtDMFWT1f/2v/3WNJFDM381vfvN2S27sFE1cG41Go9FoNBpHQlY5IHBTZFXL6kkkq/QxieoUKT/uZWkg15/+9KeXhBUrawVkGqXCXOxto7ENNHFtNBqNRqPRaOwcn//85/fIKkRuBMiaZPUo3WD3A+JwNylLAxmv8anHCRBtLKtYwkeZi290oxst/tpf+2tLK/hhx9U2ziaauDYajUaj0Wg0joysQtiw2J0ksooVssanrlOWJjP+HkcrMjG2EFUI6yghFvMDWeU4ju1vnG40cW00Go1Go9FobJX8SFY/+9nPTpJVLaskHDruOM1laegH8wRZxSW49ou+ME+QVbI4NxpHhSaujUaj0Wg0Go0DEztID9a6KbIKQZWsHje32IOWpSHOs8anHnf3WfpI3CrHyK0Zsv3X//pfX87XcSXdjbOFJq6NRqPRaDQajX2TVS2rIwskrqW6AR9Xskq7a3wqLs4npSzNpi7OzBdkdaRggIBjWYWwngRLeONsoYlro9FoNBqNRmMtEMcpWSXD7BRZ1bKK5fG44TSUpdkU9BFXYOatxuLSvxve8IZLskrCpeNuKW6cXZysu67RaDQajUajcaiA6PzBH/zB0g14iqySqAeiinX1uJFVrKc1PnUOuMXW+NTjUJZmPxZxa66OXJ2xqJpo6XrXu96RtLHR2ARNXBuNRqPRaDQaw9qdWOggrXNklQNyd1wASUuiSiznJmVpIHQn1erIPKFcgKyO5g0CjnIBskpft0WQUW6cFHfpxslFE9dGo9FoNBqNxpKsQnYkqyP3WSxzktVtEZ+DAGKWbr/rlKUh1jaJ6mko6wJZN9HSKD6XfppoaRvWY6zWrBFIMmNOLddzzz33wOdtNObQxLXRaDQajUbjjAJyCvnADXiOrEJMsNQdNVnFulfjU1eVpanxqaclQy4E3URLoxq5zJuuwAdNtMS1WCccrJNKjnUhP6mW6sbJQBPXRqPRaDQajTNIViE9uAOPyCrJh9KyelSEJMvSQFLJ/nvaytJsCsbCREt17ugrCZawrpJw6SB9Z6wlqlxzpCCgjA7WXq4HuT1pSasaJwu9uhqNRqPRaDROOYx9lKyO3GkhHVhWIas3uMENDp3w7acsDXGVNT71NIJx0BV4KtES5BHr6n7JowoNyeqotqvzxHddQxBkrtmktbFrNHFtNBqNRqPROKNkFbdZLauHTVYhPzU+dZOyNCSEOs3ZcJk/CCTW1VE2Z+bOREv7TY4FCZaoTtXiBcQBcz1ctSHRvE+Xa2JesY53gqbGLtHEtdFoNBqNRuOUAOIBAZGsQjQqIBxaVg/qTnqQsjRYV1fFp6Y19aSWpdkUjIvW1dH8oWDAusocbjoeKAZYH5LVqYzLrAmuAxE1rnjkpt0ldRqHiSauJxAf//jHFy9+8YsXr3nNaxYf+9jHlhvQV3/1Vy/OOeecxQMe8IDFt3/7ty9uf/vbH3UzG41Go9FoHAIgfxBByCrHiOxAcEywdFhkddOyNFhPk6iS/fe0xaeuSrSEdRWSOLJ4mmhpU6sm455W1SmrNtcgPpaxR8lAe37/93//Wt/bhqW30dgPmrieMDz/+c9f/Kt/9a+utal94hOfWB5vectblpvTc5/73CNrY6PRaDQajeNDVrWs7tJaaVmadP0dtem0l6XZFBBJLKtTiZaYP6yrm7hxa3WXrI5iYj0/4w5ZZX0Q00pbPvrRj17LEs53+Q5klTadFYVC43ihiesJwr//9/9+8bSnPW35/vzzz1987/d+7+Kud73rcsNho7nooosWr3jFK86EG02j0Wg0GmcRSVZHiYuQAZALIKu87komwEKY1tRVZWkgOljnTmNZmk0hQeQYWaEh9JBVrJrrJjzinBJVXqesqli1WRcckGHb8sEPfnC4nmgLZJW2nOZ44sbJwHWunttlGscGb3jDGxYPetCDlu8f85jHLF70ohdNbiBsQrvQWt7sZjdbfPKTn1zc9KY3XVp3G41Go9Fo7B6QQuqszpFVrGGQi12RVWSLGp+6TlkaySqvZ9lKh7hNzLGJlqbcbyGsJKBa53ysC4gqx9x8aFXlgIhiCWc9QVhJqjSaO12B12lLo3FYaIvrCQBas8c97nHL93e6052W8a1zGriz6GrTaDQajcZpAqREy+qoLIn1OrWsbtN62WVptgcIJWQVojhynU7321UKB5QWaVUdZYkGyIgSVc7P2jBD8ac+9anl68gVmO/TFl7PspKhcXzRxPUE4PWvf/3ShQM85SlP6TpZjUaj0WicQmD9gqhCcqbIKkQEsgrR2RZZrWVpeD9FimxHjU9tN9K/BGPHHEJYRxZNDAzWXJ0zNkAu+b1W1dG5BBZtyWpaSVcRZ76rK3DXYW0cdzRxPQH4hV/4hb0HxUMe8pC9z3XzcMNpNBqNRqNxsgCx0A14FO9oWRKe89siq1jukqhCiLoszcGBFdRESyOLJgoHEy1NAXKZVtWpBFesg7SqJunUFRjCOnIhRsmgKzAKiEbjpKCJ6wnA29/+9uUr5W7Y7F72spctnvnMZy7e97737X3HZE1PeMIT9lX8eZ2Y1Tnta6PRaDQajfUAmdANeJTxVbKqZfWglrAuS7M7YBmHIEJYR1ZyLJomWppSOqRVdVQKJ88lUa0xw7oC044pV2DWEmT1MGv3NhrbRCdnOubAfQfNGK9kEL7nPe+5eN7znjf5/Xvd617L+q5sTptgkw2skzM1Go1Go7E5edQNeKo8iWSVY79kVffSTKS0qizN9a9//Wu4/e5HAX6WgExmoiXKzkwlN4KwjiyaGAK0qnLMWVUhmZLVkTs2cw1ZnXIFhuBCVg+yphqN44ImrsccPOR0A+bBwsPuxje+8eLZz3724hu+4RuWn73rXe9axr5qmX3Ywx62+MVf/MWNrtPEtdFoNBqN3ZBVjqmsrxBF3YD3EydqWRpdf3mdKoUyKkvD+yY06wGSaLzoyAvN5EajOqfMf1pVp1yzIboSVeZnJJ/h6m242JQrMO3gQE5sNE4Lmrgec+DCe/Ob3/wabiLvec97FhdccME1vsfGhTX24osvXv4Nib373e++0XVWAYvv7/7u77bFtdFoNBqNCRCnKlmdSqYDIdGyuilZ3bQsDVa7tKYiR3S99/WxKl4U67SuwJloCWKLNVayOipjlKWMJKtTyZpQRqQr8Og8ugJjuT9MV2D6qodgo7FLtM/AMUfVlD32sY+9FmlVQ/eMZzxjL3nTz/3cz21EXKnRugpntVB4o9FoNBqryKRuwFNkFcumZHXdsnVY5Wp86iiOshKprJ/ayXc2B+NuoiVcgqt1FJJooiXGWDBXElXmasqqimwnUV1FMrHO6go8svJyfV2BtyWn0W4IO2R79Fo/4/usswsvvHAr1280ptDE9ZijZp77e3/v701+94EPfODS3YeNBPfhRqPRaDQa2wfCOtY0yAmvUzGrm5LVTcvSACyoXZZme9ZySCLW1ZGFlPmErEoStYJ6TCkVILrIc5LVVTHEnEdX4NHaYi3pCrxuPLKEcx1Cup9knFMW5UZjm2jieszBhvTVX/3Vi9///d9f/p1uwyMNHhsq7rx+v9FoNBqNxsEAkUiiOipbk0RSsrqKVEAU0pq6TlmaGp/a3lAHA+QTazkkcSrREgQR+Qo5S3ILUeX7U/PF3KdVdZV7tgmfODfW3gqtvLoC833WD8qNdQjp3LraD7ASMzYcuAi3m3DjMNDE9QTgdre73eJNb3rT8v0qLZj/70QLjUaj0WjsD5CTJKpz7rkI8JBV4gtXkVXOm0R1ylIrIANpTcUds8uYbAcQPiyrkNYqWzHGJlqCJPJdDAKQ1SmlhSWMjFddNykS60BXYNYZJJP2+Mp5OC9rjPXysY99bElI5xJw7RcoQSSi+Tr1WaNx2OhVdwJw3/ved4+4fvjDH17c5S53GX4PDR2bsCVrGo1Go9ForAaEIInqnNujWXkhExLKkTWty9IcP5iNF1lppDSAJEpWzSD8kY98ZJIk4rKrVZWjrgN+N7KCem7IMAmfJKkCcogixGRNJnrar1W0ks4RIeVYJ2mXcde6yPse0ouhpdHYJZq4ngB867d+6+LpT3/68v0rXvGK5d8j8D9dQf7O3/k7h9rGRqPRaDROCiALSVTn6pzqnitR5f1IwIdc1PjUVWVpanxqW7F2l2gJoojFdCrREpZy5hDr5yc/+cnJ80FumTcOSB9ElLnGzbe67Ob8897araMEXlp5OTj3FCSZ6xDSg7iR016JKfeL77E4M4b8n3uHPtF/xrCJa2PX6HI4JwTUbH3d61633GBf//rXLxMxJYhrpVwNZW3QzmGZ3bbVlczDbOacd53yOY1Go9FoHDUQspOocqwiqhJJyCpEdco9F4IC0ZkrfSO6LM3hApLF3HCMLOgQVeQlY0tNSpSuuhzMPS7aEFZ+sykZhNRBViF4ozhT1hhWXsvprCKk23YVp69JTCWqI/d42s/9Q18yvpc2MTYPfehDW/nS2Cna4npC8NznPnfxtre9bbm5UvLmiU984pLMspm+853vXDzzmc/cI5M/9EM/1K7CjUaj0TiT0EU3iepcfogklMYSriIHnBs3z1GpFAEJqfGpjd2CecYVGGU+5EryyecQU+NTmTOJ6mj+mCvmDHfddWNVR9mhJXesMZI7QTx5jzLkb/yNv7H4m3/zb+7r/PsB/R1ZUFdlA/Z+Yjy5l+gDa5v+8Gr5JYh3o7FrtMX1BOEtb3nL4tu+7dsW//N//s/h/3nQ/uAP/uCSuO4CbXFtNBqNxnEDgrUuupLVORddiINuv7yum/AIAmSplFF8pG6/Zv1dt1ZrYzWmsub6HosmigQs32lN15oIIFyQrNFcq7xg7jiqyzZW+FVuuZyXtYcyg/U4ugbkDusq19gVsJSOLKiblLihrcayctB/1rP9BPQb92D6lLVsG41doi2uJwj3uc99Fpdddtni+c9//uKXfumXlgkD2KBufOMbL+5///svnvCEJ0wmbmo0Go1G4zQga51CVFfFkiJgV6K6CbgOZBVLXrXOcW4sT5Sta6K62RyuU090rpQLn0MSdfMFfA+5CAsh/9fqXd17IV98Tjwp5It1Ud108/1U0iKuxxpkfdCO0TokwRJrhGutk/xoHXBdrMcjC+om2Ybpm27QWn51q+f8jEmua9qPFRqySr8YR9qC4kDy32jsEm1xbayNtrg2Go1G47CBIK7Lr0R1riYlZCOJ6n5cMXU5NetrBeeFrCLEd3mavyBSksx1COl+S7kYYwlJ5NW5Yo4gWpybeYeMSlh1z4WAQbg8DlJ31PhZS9hMZSfmOMh1GCcJarWiblKXlb5LTpOoMja0H0s1fZlKGgVJZcxY75JvvstvCFPjPuH/9773vffd10ZjHbTFtdFoNBqNxrEBRCSJKgLynJCOUJ5Eda6O6ipwLYRwBPJKrhDyISJYzw4rLvEoYYKikRV0REi3DQiTFk/LwVgShs9xzYbMsTZQImg5Tasm37Gu6lySrU2UGRDWbbsCc+4kpRLVqZqxU2DtV3LKUS3OzJdkVQVABWMpWdV1mvnm/uCgnuynPvWp5XvmhXEmSWh7HjR2iSaujUaj0Wg0jgySkiSqq4TzJKoHFZQhqFpXR9fmOpBViNG2XD2P0io655abr5tY9NbFqHboVOwokCgyL5ZigTTSRr4HSYSUugaMX7aszEGsnVlKhzaMEnFpjaQd61jfaffIvXdktZ0C10hSKlHlvphbn2ZPZkynMhxD9KtF2vuDqhKQ1Y9+9KPL98yJ7bZE0CZxtI3GftDEtdFoNBqNxqEB4T2J6sgVN4FQLEndZtIjrktsIqSkCtxaz7DkHedswGbLXYeQ7oJUQJTmEhbtp5QLawJLnpmBWSe6xhqbCknUgsr8aFXlf9tw3WZt6Ao8yrrLNS1hMyLH/GaUIGkTyzRjO3LvnUowNUe86cdUDC7npB8oZtKTAEXOVVddtfjQhz60Z1lN6yz9ZswZe+4TsiSfZMVO42SgiWuj0Wg0Go2dASE+ieooI++oFIlE9aBWs5HVqQrhAqsRQjiC/FEI4SYtWjdx0S6soqvIZ362rTHCcqf7KSQLq2oSRsgaZBWSpGu4VtVtKTIYz7TwVtBnXYFZJwALMImJqgV10wy+1bWXv/fbL+OA6QvuwKO2MHdaVu0L7b/88suXRJXkn9wnjEPWPbatjD+lfM4555zF13zN1+y5R7ebcGPXaOLaaDQajUZja4CESFLNTjoHy8hIVGspkm0AMqF1tVq9IF9aVxXitwVIRFpFVxHSXVhFTVA055bre757WMmmGBusqrie/s7v/M5evGrOC8QUwipp1aq6zey8EE/WBa9TrsBcE/LMOqIk4X4y+DK+IwvqthQzJkuashJbvsZYYC3bHMwBc8G9yjrkXCZB08rN725yk5ssbn3rWy/OO++85d9NVBuHjSaujUaj0Wg09g2E3SSqc/F6CMGVqNbEMdsCQrfWVZP6JCAPWlcP0gb6j2VripBuG4zhunGic6VcjgIQPYgfllXiJEdu4ljuIEWU+uMVsnqQhFtzbuKQPOeItrF2mU8ti1wXV1tI7bqAzI0sqLtY55BnyepIQWT5GsYQ/N7v/d5y7Hml/9y3Kgw4l7HErDGJKhUlOLCucq90Fu3GUaKJa6PRaDQajbWBYCtR5XUVUYWISFR5vyuiWt1OsaJVy5MCOYT1oDUnIQpYCrnOQcGYrBMnqlX0JIFxYox++7d/e1k6ZURW6RdzgtsprzU78DYAQaUdkDaIKO3ikKxC3rTqGus5pXhgHZnBt1pQd60oWKd8DW2z1A3WVL6rldiM3RB1Ds7BQduJU735zW++uMUtbrG8VyGqfLZtT4RGY79o4tpoNBqNRmMSEI0kqiM3RKFbYRLVw7D4mYQGwjqyjiHIQ4iIxTuoK/I6hDVLuaxDSE+TFYu5YK0wD7ihYmHl7+qGy7owTvKmN73p1ksM6fIKUXW+IG5JRl2vf+tv/a1huZzM4FutqIc5Z5av4ajeA9axZTwtq0O/taTyW8mq9y6EVcs9JBWLKvcG/cJizL1CJu1duO03GgdBr8hGo9FoNBp7MCGLRHXO3RVhOYkqlpnDdE1FEMflkaNafhHMcZPUgndQTBFWhHusUlxDInrSrKIHBWMPUbV0DBY+/q5KDsaG+YAsYV3dRowk164lZiB4tIP2jOKGIaFYVpkz3amTmPqe9h2VUmGqfA3rkH7aV/rHemMcjLnlM+9jvs+6tMaxmaB1IZawmx2Yzzbts+WTOua1sWs0cW00Go1G44wCYbMS1bkEQRJVhGCJ6lEI9mldrZY8LUZYkLaR+EbCCoHIayH8YzHkWmeNqJq5VrJKIh/Wj5loq8USkgRRxbK3n/JCXA9iNioxI1lDwUJ7dAOeygqMdRVylkT1uBCuWr4GQmg/Ofgf46CV3nUncfR73MPcmygI6KslqOinhJ3fcj9jWWUN78fizTm5DzmY4wsuuGAHo9Jo/CWauDYajUajccaIqomUIBxzRBXhNokqwv5RWaAQvrWujogJAjkCOJajbbRxirAyJpCfs0ZYIUcSVS2ZkCoIFp9LICFVxjWT3AdrNKRmnTkxSVC1oFrHtYJrSqCzvBFtMAaVeSLRE+3YZmmlbYJ7kXWmW7Xuvtyf1n9lrdkn4Zjyf8YCZQ1jDWllfrR8c2/gkm3/jWfdT2Iyzos1myRPL3jBC5axy3zGuVFOkHX4KU95ypZHqNH4CzRxbTQajUbjlMLkK0lU50p4IPBnxt+jJKoCQoJFB/fPSl4QlrEYcWzLajZHWLGwIvCfBcJK31kvklUtqZAk/oawqkCw9i4HJIn5mLN4swZH5NQkSavAb2gXr6xZ5h5yCrHTqsj1ScR1XOeKdU2yKuKAGU/6otsz71EUMH4oAXR1N9sxfWQMLXUEUYWM8hnnYv0yFhDTtHBDanVr3xSshazxSvt4tS4z1ttd1BVuNBJNXBuNRqPROCVAcNVt04Qsc8IkgnElqscBWnUgrArGiYPE402hCetfuttaAkZrvCQWosKagqRAqCCHvEKkIIkQ1szWbOKgSlLnMlFPZcmFpGmJ5DMIWMZT0wbaw7Ht8jnbzK5MGSCIJfeoVuskq5aL0pVZUsor9yvf4T6nj659PuNeYf6YDyyf/g9iqztwVe5wfWsIjw7aiEX14x//+LLt1TvDe/OwMio3Gk1cG41Go9E4oUCQTKLK+zmiiuCaRHXbmVwPCtqvdbVahhXAObZJTM46YU2rKu8TEExdgbXGm33WUkeSVcgT5CtLr8xloK6A9NTap6xXz0n7QM49v4Ew06ZtJODatqcD9yRr2fXFZ6w3iaoEnr5iHVURwN8cKGjoI98z+VKST87PuazXmnuCygTmhs+w7lZiWvcK282c2+ZKVpl3xhoLN4QW130+ow1H7Z3ROP1o4tpoNBqNxgkBQmQmUkLInCOqCPlJVI+jJcpYPATgUV1K2o21CCF8m4LxWSWsuvpqVa1Zo3U3ZY1ZLuaWt7zlkrhCRI23tLYnhGguTrqC345KzOTaZG1j4YP0jc7Nejae8zjMEWsJssjh/WmyKvogUU1XaEgpZYCsKUz/GVOzU3MveE8wBh4QWK7DXJjBmjkhPlZSCQmGuNqmOXAevTMYc9ZE3VdcB1hyOTg/bbz44ouXfYK0trW1cRho4tpoNBqNxjGFNRiTqM4B4ddESgiaxyVb6ggI8lhXEZardRVhHGKy32yncziLhJV1I1HNJEaJLK8CIcINW5IEAYOoQLZYVyZFmgPnqLVP+Xsq7pVrsRY4Rsm3WNusCUjTUSpgtEpKUiWRfG6WXfqQ4wkcUxQwHJJOSTvv+e0HPvCBIdk0c7BuwhBF3nNwLs4JkV9VexUSqnVcMq11WFdjsw7zevOb33xx7rnnLu/FCtbDcQkvaJwNNHFtNBqNRuOYQOuHRBXBcg4IvUlUj2vWVIGQjQUKAX0knCM0a13dtgUHAf13f/d3l6TitBNWyFJaVUcuuyZIYo1p1eMzCKTjg+IDMsT4TBEivjOyoK4iULbBmqus+QrmQ1fgjJ09TDAeElTvTQie8aFYRVlXvJqlm7Vr4iTGhD5gTWV96wrMK9/hN1itR/Ho/A3RtFZrvSfyfrGG8OgASbY5L+SXv/mceaB9uoNDsCmlQ/bs46z8apw9NHFtNBqNRuOIAKHQrdB4tTkg8EpSeV2HHBwH0C8tUdX1E2EcYkKspO6n28RZIazW+dSqal91L2UcJKXWRB254UKUIKscaU2D6FQLKsd+xo71rivwKMs1ljxdgXfpglpjPr0fdZXmVaupB9+j3R58BrmDODIevJoNmPZDKnnP2pYEck6IrmWFBGNp2RvubebKzyTCnNsSP3Nk3szL3Hdax62/S7tVHGVGaL0cdqE4ajS2gZPxxGs0Go1G4xQAwpBEdeQSmTDmTcHypBBVhWQEZAT0kTUNgRkheT+1JNfBaSesxqJKVrGcmcTHzL0cun9CmnQRrXGtQMsg42ImW4mqrqnbyKrLMcoqzHV0Bd6PlW9VhtzRkS6zuvZWq6eZfxlj3MuzBI+WTsD4cK+yplHC6Fat1VPSyHxxXS2bSVYtacM1ajv4P3PDGI3Wra7KtJMjx5i+4u7NQX9YDxJf++G8bwra6Xo67h4fjZOPk/MEbDQajUbjhAFhXZLK61wZECxdlaieRGJFnyGrHJUgmQUW4R7heVfXP62EFQJFv37v935vLxbUIy13ljmCGOk2DOmqJWZYbxAYDqyDWWJlG+DaugKPYmKZh8ymmyRsUxK6qoYo/7ecjiR1lQu1yiVrpjJGrF2TEUH6cKe92c1utkxaBFll7Pku48jvIIv036zI2U++wxxxLq45GiP+z5rl3BXsJxJV9pdqvaYPJoeSrDLnzj99YezXVYgxn4yfBwmhuM8B/TazcaOxKzRxbTQajUZjS0BATKI6Vw7EciJJVE+qex6kQLdEBfQEliStq7uyGp82wmrSHIkqBIF1NXKtdS25jrSw8TsIhUm7tOpJWCBD2y5hwtjrCkwbaItEVHdbyBPX5pW/P/WpT12DhI766Lnn/s7POI8k1cOxSisnf/PdzPhrbCrtk4QKPmc9QVZvcpObXOue1asCRQGkkXPWdhrvSj+Zo0q8JfRZ+on7yjrNWtqnLMSsE9rBeYyrdUwA52Y90C/u29FYOn45htVDhDb4GdeDZDcau0QT10aj0Wg09gmEuSSqIxdMgYCbRJX3J5WoCoRVrauVpCMUY11F+N5ljc2jJKxa1Jj7EUGZI1a+N95Uy6kxiCbn8vv1XJArCBCHLqmQEMYCGHeppZFX64Py9yc/+cnlMTr3VLt1C9UtN18hOLSb8bDmaBIyrcDreBKssp7mGqPf3Ee6/npoJdU66nt+o8VV8D+zBdc4c8bROqusJwg315Q8CuZuLhkW/YfY8Vst0LWfKBW4Z7gebaFOKv0yqdKU4sIxcz5os3sL57HOqyWlINVpgec31t7dpAZvEuR2E24cBpq4NhqNRqOxBhAMk6haPmIKCItZQxWium3r1lGNAwI6ZBWSUoGFCLLKscuY3KMirFoUtahNEYmE2XpNkCRJlWClC+sUYdCqatkT632aUMi5cI3xOUQGssRhoiWJnUSnHmkZrZ/VvvKZpGoUr+09UGsIj4hpWkIzGdHoMwm/Lr0Sc67HdWq5HMfbazNujB+/pf2pIOB/xvZK9nQBrmBcjCsdZQCnPfyWazHmrJkaLmDtVTMPA92GV2UWp52Wt7Gua95zEmHaIJGVpDpuHHP7WLazJubCcm9/VAo0GrtEE9dGo9FoNAZAkIVMJFEdZWEVCNVJVI0lOy1AMIYk4g48Er4hRwiyo1i8bYJrU4f1sAkrgj7XhHxMkcvM4JsktX4fomAZmpqIRyuiWWqx9GXtT2CyINxMXZMSS+t8sgYhNvzNd83o7PcqWRmt1fzMdqUCJ+sK2za+x3UhfVonPZJ8+ne+jq6fsan2O8fT69V50EKspZlreE9zL3MeSaz1SHUPNqvyVA1h+o7SwqRjlSxzPmOGtUKbFEm3XayizK3JydxjTN4E8vtJhGkn56tJmBwPro3iiL5l4in67rxb+iYzEzvfxttzOC6MBZ/nmqDtjsFp2usaxxdNXBuNRqPR+P+JKtaXJKpz1rQU/CCrWj9OGxgPyCrCd7WUIXxrXd21q+AcYYWsQlq3TVi1knHNkeWL/0u6tEryt0J/ki+T/bDG+K4EybhTXXuNPYWw8Ldxn7plW96EzyAynFuyyvlQIGy79qb9895gzZOUKIkn7WUeOCqR3ARcJ+umMm70TyvfKAGQ46Arc41L9b6GFPI/khRliRrGWRI5lVmXc1jCh2tU0kefmTsUDLQZpQLXs3yN4Ddm8NW1mHtL12Z+n6DPWs3pJ2uANUlfq5LIGrHG2aZygnkaKZVyvXqsm6TL8UM5cxr3vsbxQxPXRqPRaJxJmOhEYZz3q4hq1lA9iHB+3IHAi5COkDyqLYsQDVnlddcC62ETVtYA5ARyUBNNabHz+sYS8huzzFYCphutsZasH103XW9Zeob+Qk45AOsy42gTjD3ng8yt64qeFs9VB7AMDP1h3We8Mt8xK/B+S6norus9uKpEVI5zWpCzTUDrLOfk+7TvFre4xZ5lVJJI+xnD0dgxFyouRveBhJf+857vXXnlldfqg9m0aQPKDtbzlAuwrsOSVdrOeiQemb6kmzSHiaQ4+L/1WUfIuOgkqfsNF3BstFxvW2HSaFQ0cW00Go3GmQDCrUQCEqAQOAXj4CSqU26DpwmMTVp0qtCrdXU/wu5xJqw1E24SIQmo1tSspyuR5dDaB2kxVtWkQBWQDAlsriuvy2+1xI3ckrXC6c66LhHlWEVuzRBNqRPdaUdu4ZC1TRUXmWhIkrUqRtjkSI4P4zEikcDkVlpdLSVjG01SBNmcyqjMPFvCZlR/2HPQf+Nksa5yz9S+0Abmh1fPOYKJmzhUarD+OS+ElT5l4iTnADI8dS8y11qVPQ5KLKvV2XWfMdWNxi7RxLXRaDQapxKWhZCoppA1AkJdEtXDIGfHZZwQurHwjaxAjAWujgjrh+EOeJiElTVhhtUkiCbHgQixLiATrgfalDHPWvxod62lOkpSBJkYxXMay8laZR4kycaF0g7mwZqeZtPdFiy9o3W1AuIDWVu3pJH9SbffVdZUE1AlUdVyOgXGXNLE72lfjc1lvPicNTwasznFRd4HxhtzDsgb1tVae1ViyXxJ1Eegn5JVxlbr88c+9rHFJz7xiSVpreVuWIOsf92GhRblPLbluk8bvEemEnCZFOsklZtqnEw0cW00Go3GqUC6ZtbEMSNY21Kietbc3BgfyOqUpUjr6mFZmg+LsOr+ySFRN76ZtcO4QJx0hwaMT11TZtQdWZkkYMacmpV2ZAGlPRAziJAunwl+q1v2tssn6RI+FcObrrCrXOMlaWlRXceamgmIVDZh9V+lZAIQVrPdVpipN5NabZpwiz2CvnNwTb6DJTrLP1lGh8O499FewtplLplHswx7D7K2yJA9lXWYcxp/K0nVmsq8bDu+nLn0HhkRb+ZJwqqnwUkv7dU4GWji2mg0Go0TiUwWo5VqDgi3SVTPYt1BhGytqyNiz9hAkrQqHQYQ1BHaK1mRsHIctKzOyP0zFR2MBSQAUgFBhixk1lb+Zr3QpszkajyiWaR1IWX85taXxID2jObBpFcSpm1CV2DGmzjFkSuw/ZhypwU1NnXKfTfPa81ZaxhrYf7Upz41S3IhZ/xGy3a6+ec65fxaRafGDcKIkmBq7JljybqEmj5iBTVBGedIq7tKjnrPuOewFvgfYwbxxaqqRZpzjhKfseZZize5yU32rLIcuyoxZU1iY7uzPZJz20V/vEfM4Ezfdp1RvNFo4tpoNBqNEwHrVUpUVwnKCLuSCo6zSFQFQqXW1WohVFDHDfUwE07tmrBmAhndP2t9TC2rZMg1c27GdfJ/iZ6Ce9bm1AV1LmYy28O6tf5tJSrGTkKAMgHSYbkCQ9Ik3XXcs16rVtVV8Yzcb5JUXumf5V5ox1zt0PSGyLq5I3LLd52DKe+ALAk0RdZr3C6/Ya5w2bVskWuHtasVNMvV8BuJHa+MkUm2RPYnlW0QbdrP/N/sZjdbEtZd1kHOtmh11+Vayzf/06qd7tt+h/HhO7TzrIRWNI4WTVwbjUajcSxhSQcFqFXxcVpzFHh3LfQdd2hBsXzKaLwgqwjfh+nmt2vCKkHDqqZ1TsKBEG4iHIiBcYjGPxuLalwl1jE+p22QStYWRAWSCsnhs1Xuy6xbiUF1A03CaD3PwyznY/kdjiR9NTZ1XWuqJFUyZwkaxnGq9q3tMGMxY6s7N1bOEcFdp3wNoO2uhRHRpp2exzXHfHHPsEZpu4ncslyN8d58l3WiNZ5Xvmcd3wT9oB18n3XGeJucy3txW8oj+moZpXrwPxUoxq0aJ2zNV75HuxgfCanrx/hdPueVfktuuyROY9c420/1RqPRaBwbmBEUoYpjJOSP3A4lqp0Y5C8AyUAoHVm1EJi1ru6nfMlxJaxZtkSSmnGWGV9onUsPxoQ1JAmhjYwbbZGsMlYI8hnvuI7SQItUBef2XNu2cqd1cZTUqGbFtSwUpMoxW8eamiSV8eE8ED0OMuHOKZqYD0mqGbtNlEWc8+jeX6d8TSoKppIJMXe6AidZp90f//jH97L4JtGXWPPKObHCQtySpI+g5ZZzaaXluiqKuD73Ip9N7V9JQucIaR6j+GCub91Y3kuwk6yqlKmWa0soSU5ti8oexsJ410Zjl2ji2mg0Go0jgVYdieqcRcZkNxJV3jdR/UsgMGpdHRElyJExk4c9brsirAjO1luVICbhMKkNZJVXhfVMooMArkWQ9ag11jq9o3jHdcqFjFyyd13/dtW1JU30i74ydlg0V8WG6yaabr+QPy13nAfCN3eerF/r2GqxNAnQyKq7TvmaXAsqLkbngfTS/yS97Dkf/ehHFx/5yEeWv9dVlnaxXnTfNXM062Mq2RPXoF/WRnV/49X4VN1s+R7n4ZU1yPrbhIRumgcAsip5lqia/ZjxwFXecApJKu91eVb5w5HeGcwN605rc6OxazRxbTQajcahwBgxCcYqompsqkS1s1ZeGwiikFXj0+oYIhxj0WEcDxu7IKzGrXJOLHMI5HUtGbcK0ZHA0RauxbWt5wtZQOi2DNKNb3zjJUlZp06pBJjzQLqwwNEuEzlxsF7NeCv5hdBwH0CM/L/ZWT1Gn/n5nKV5RPzor5loITEQ1XWtqZJUfs/1HTeVI1NlXvL+1f2XcyVZtO7pKDnSOuVrci1YwmZE8NKl2/Mw9qxLCCtJkiR0HPzPhFvOfxJtoasv4+rB+mJMzDpseSQPQDs4bMM2QZsskUSfGBtLEFn/lTEyjpbxpX/eE65bjlVkWWsz57B0U6NxGGji2mg0Go2twyyTSVTnkrFkncsq6DauPbYIpRCIkSsoQqXuh0cR5ztFWJljsqTuh7BCCCA7v/3bv720jNVSK5At3Xp5z3U5zH4KIEmMF2On4E1bjOGbS05krKzuv5Iu1vgoYZDkizbpkk27DwrJF20xYVSSXUghB32yrqa/qcTYV9onwdRt1/9LxLyH5wgN4+c5TMY0so6PPAKARGiufM06SaZ06eZcEErr7tKPq666armGGDsInXPHK7/D8sjvIKq03yRFzL/WRy2LlsDx/FNEnHOtytBcwfdGpZOmDuaZa6vQYY0zd+l9wFrUXZ6+ac3l1bUARnNssiznVld51k6T1sZhoolro9FoNA4MhB0tUAq5c5YdhJ0kqghATVTnASFBMNWak1AwhbDuIiPtURBWzke8IW6onLO6ombcqm6YxtzlOSApJtBhbG51q1vtkY9RvKM1Xc22qoVRy9wIWqoQ8CXQ2xbok3jT10wCpKVQV1XjKqcssPSV79pnkyhxHrMGZxbltCL7t+7Duv86ppYXyvPyWi3RkmZd2OfqBa9KMsW6ynlEwXDFFVcsSRyldiCtEGdjMx0/XYi9b1R68D/WxlRNVsC5LGUz8nZgXeoOvAkJ1Wq67pqAiEvGq0KHczE/elxYwoY+zmUBZgzTYt5uwI3jgiaujUaj0ZgFgpCWnKkjrRdzyVgUhqrrXWMaaV2t1hCEaq2rRyVczhFWyCqkdV3CqjsrLpycc0QIWEOQQ4iBJINXiZGxl4yXls9zzjlnrw0Z78ha5BoI/JAck1pZl3TKwsi4mxyMPurWisCvtVdyZPvy73U/pw3GgBq/a3wihwogrj+a/ySougwnuG8hP5LV0T2sAorzS4yxrjqeZstN0s/YMwej8TOOmHnht8yzbrNJjoHKA9vmuABeaQd94vuXXHLJntswa9IsubpQuz74PtdmXVJ2hnMwPhyr7iF+b5Ij2qSniPGfjA3n5YAYbkJC1wV9QpkDWR2FCKgQMPOvSZN0+R6ha1w3TgqauDYajcYZBYKfAt7csSombgST36ixP8z6oKcBCPRaV0eZURH8IaybuB8eV8JKXxHCEcaxjo3Wm8ml0s0xvydh0hrJmoOUpNXTuEmEeUgg5Ji2Q7IgN1Mx11oXLZ3iuEtYcGGGuHGMXHFHn+X/TGzjZ/SFc0GkISZmfuVzxhPSnZZmoPXQdvKadTeTCEsqGSv6bOIda6b6fT6TqGo1lFhXQH7NKDyaP35rCAB9NQESvzNTbtYPhXw6lznHtNfxor+6w9Iv22YCIt2IjTPm2qwh1iZjZ91ezuFvTEhUD64pIde6bdy93g6e13mlLZy/zvt+a61KVlFiVIWAc6hLr/vv1P2ntVxl4kGVXlpxz3oJssbu0Sus0Wg0ThmsyTd1SFbnLKSbAIEMwSdj5ebc/hrTMPkNxKUKp4wxgjfHqnIsx52wQjQgqQjjlp+pQAiXDFiGJBPdeB6EetYy648YxbQqaSWUDBLjCFmas6a6liGHWlNNUiTxoA0QVlxQ96PYGY0pJJXzWe+1tk+yQTskUCZR0mpI3+mbVkHaBiGT4Fn+R+ujhNn3uv3yan9HhJvzcn7XAWNqnChz6f4igba+qW1JgsxBm3UpNvuznhz+LYnkb4htKnQyE7DljVg3EEqIfrojax1dx5Wb9rJOuV7dL63ty/kB64FjDiPFxSgxl4Sa8zHG6Wpt8iQTfKnEoC3G5mbMqmsnPV4OSjCZGzNKm8WaPYl2NBq7RBPXRqPROCFQIFx1bJuQ5oFwMrJGNPYPhD5jKUeZYRFMsfLtooTKYRFWE9iYYAmCNrJwsp44D0I4aw3iUMkq94GJgiTzjktmT5X4eI4RtMZZKsZx1jJYwXloO/3YL2HV8qmVUjfwEXmnDcaRcuj2a6meHF/7qesvr3O1VLUaek7mkXZIRKollCMttib1yUPX2SxZ5TkySZT1TbVimgCJOTNpkNZlMz3TF68p8VRJxyvjw/eNLzabM397vXVctTkX7WIcRpmTGS8THW3qBsz1RuvGLNVcT8VVum4bzywxd73SN/42UZRwjajoYIy0Yq9DnOtndV2xDizjoxJFEt1o7BJNXBuNRuOYEtLqxrut4u662q06mpDuFimkVmUDQrtEai6JynEmrAi7EiEsq/RzlFiH/kE+IQOWi9FSKBTcHSfIpcI+CZwQyvmNWXSnCL4WWBNZcV2Ee8nRFKYIK7+BHFFKh7ZnfGu655qwjDnnFQKR44HA7289J2OrlRASX4mWGWE9J9fQ8snnScR8HZVvGdU9rX237ZUI215dlDOOkrZIhNLCSTuZL8m6bs4eknLL7zBWzp3t1gqrlc/rWhKGedWVV3fdLBczsnxmLVj6pTXVPhoXzXn9bF0yPPosk9kZw8wYS/Qtz8PeTz+5/i1ucYthPWFjmD3q3p1KEclzrou6VjJJl9Z6k4Cxnnmlve9+97v37j3m7bzzzptdS43GQdHEtdFoNHaEdayjuySkI+uosWGNowECHkKq7pUVkCgIFULqUSevYm1CWCHX6xJWBFozrfJbXkdlVBBy6SPkQPfPUSZcrW+SG8YMcpHWI4X16j6tNdWanIwr19MSuA64vi6glbByTlyTU7Fgdm0JIa/e4zVpkXGfkjXGlLjcm9zkJnvZbbl+HpyLfkv8LDMl2ZGIOS+0TXddyXla8fK9xFlrtXGwrlPGTDLouOum6r6S1lATGUF0aK+Zfb0m3885y9+4f3EN+mAdWmujquTI+bBGqrG4U2V3KlhztIu+jtzzPa8WxrrG1olntm+MhWSQe8V6uP6twtK94Ja3vOVynaWbOu1wbFKpobWa3+d6cW3kOqn9VFEkYc3ats6hccC0WYurHiKMefWMaDR2gSaujUajsQEUJldZRxW4t7JR//+1A1cdTUiPL6yxiDVnFCsnsToOscGbEFYJmUQKUj5K0sNvjcU0MY5kqZaY0folcYJUWLOU+0rCh1Ut3Xn5HIKGtdJYYIjVfizW6xBWCAPt++AHP7gkNKNMxBJADl1aU8HEeOgWzbnIjHvRRRftkQDHJ7MJz+0rnEfrm/GOko9a85d2WANUS7XEhes4Z4yh3+HcZgRO0imJoY26rVpSyLjVJMYSLa5hzdncy6p10ERNJj1SMcDvaAvt8trrhErous55R+75jJ/rVGK5KYzdtV16DGhldVz43GRYrgnmzljeK6+8cu8ZoLXcvb66as8dGdvMfGVGaV59hklKnVP/dj3mWpA0mwyq0dg1mrg2Go1GZKxc59jaBhzCyBwhPWrLW2N/QKCDdEEAR4IvAqrW1eOgdFiXsOpSqdXT+qIceX8Ynwm54FWXUVDJBWuc30PsIfgI9Qr0toHxSrdeSQsE1XGcK/mxDrSqQVizjUlYISKQCWtnIvCbHVfLluSEPlibU9IBHBNeJZZCoippmCNiknXHRlfaTECUBNU5qIqHWr4mySPfl6zSXuuX2r7MyJykshLCrB9qsiDe1/3N/0ucauxvWlenFD1JkG2XZBnlim7KWnN1/TWpE+NTE0hlrO8o/tcYYOvY6vKeGa/5zDwEjLHPAMm7a5vf5ZpxTZuUab/PN4mqVlkt2Dk+Wu7TdZi2mNjKdjFWrl1L/3RW4cau0cS10WicOUI6KgEzSoyyX6xjHW1CenqB8Ar5g4RV1zkEUEuqWMrkJBBWXZx1/dWSCAFI914TwmiRkWAmOTG+j/vQmELOOyIo1kr1gDxKVBGct5VdeRVhpV+M0WWXXbaXYdYyJbq/KsRLSqw3q5VLspZun45/tahmXdCMzczMv2bv1g01scrbQ2WDSZayv4DrQeCst+yaHhFJE0NJ2CSBxvw6HpLrJGFe0/9xXdfVyG2Xe4d2rXL1TisjoG0qRNJF2gRfZlEGEtAaB1rbk9ZL58+xoe+6AjvGtEW3anMIZJ1dSbT3S1qoa6Zgrw3yM79n7LOx1Vp+qwuxhDzdt9MbItvlmjY2nPVnwrWppFONxrbRxLXRaJxIqB1edWyLkCIMqGmeI6N8py2kZw+WW1E4rkA4ReBD8D4uSa/mCCttRUhF+L3iiiv2CJXuu8atWnoE4uG6l3DZT+5B3X0hdromIkiPrIncY5BFYj2xcNIWyeN+761RYiPJJmOgS3Ba6EwC9L73vW/Z9kysI+mmj5IpBPw6t4wDbTfJkpY8LZVa5dI6mn3ULXobZaYYc5QPtJvzcKCUELRDokIbkoiNEgKZYZi1QD9vetObLvdALXmsLy2YNUOzSZU4WGechzlgbfAb5r7WLKYNU5bO0QFxNFt3uuM6xlxHK/06yNI9WpUZI2vc0kc+Y3y1XltSiWv4fKA/JPOyHjDtkMhWC/lIKTFqF9dD8WLtZ+aZeVRpYCkpQ11cx5Z+8nkKbCdzxNww7oYy8F2TNGXfOfdBa8E2GuugiWuj0TjWhHRkHdWdaRuwfuHcoftdo1GBAKewWJUkkDoEY4Xu44Ipwsp7BFHWuzVF0zpnnKEJa1Lg5bdazBDqrX2p5UzhNpMVZdIlxofERDe/+c2XpEXLnCSTcyGMj8jnKGtr/V8Fc0Ufs16ulmD3nZGbroI/pIDEOSYrgoxYhoX/MecQFsmWlrcaU1njb1UEeBzUKs/6ZNw48rpmh81ESMz9qnAIMxZLBFnf9B3CxsE88beKBmHWWS3nXI+x/tjHPrYkrFqqU3lg4ictsOuCfqkoybl3r88kTqvgGtSiqneB7TQZF23kf5wTZQBrwxhjDj6D2Ofa3g8kzvSN+5d9h/uUdSWhzOzb/kaLP/3Xyiux5XysW9cAa1Z3bdrKq9/TTVnXZufTsWo0do2WxBqNxqHAenurjm0S0lXWUTXLjcYmQBBUcLRURwLBUOvqcVpfElati8bLQSa1sOjqqXCslTQT/nAehGUT6/hdSItukboX6naZpIlrmZEWyxOENeN8zUq8C1TCKlnlM2tkVgFcYi2JtOYpoJ9YhSWa1tY0YRVlgEbZo3Ofsu6p7qoH9dhgfuifJVYkqR787fjT3inC4Twxj5m0iXEysZH1V1kXrg9r1EqWJEN8jzYRG0z7RtmmGU/um6yRum6ypVpiyGy+1hc1q7SxmDUOOC2cmVzKRFVZ5se4Zokc52Ud6KpLnyGrmSV6U3gfZr1fyarx08aq1t/VhFcqQfgs6xvz3bT4+ntdltfJ65Bu2dtKSNhoTOH4PFEbjcaJJ6RT1lGTUWwDxnnNWUe7BmljF2B9a12twpx1Ho39WgerLIerrIjrvtcqbMyt2UR19TNmMOt10j/JKq8I0JCOrDGpy6/9N1bPmEeEa2MdjUmV3EFOtFBuC3OlSYzRTQurlkjaQFsyHpXP+BvSQdslClmXFAsa823mX901P/zhD08K8MbtSlS12B4U9g9LN3NdXZFZB1rImG8TAPEbXt1Xs84rc/uJT3xiqZTINaPbOOfLrMNaY7XCpWu3ico4anKhKbfdKWKZB+dFQcB5aTOKEMkq/Vk3W7fkUDIuYbQ0jPGgWjM5OCf9dE51C4es8roJWfXcXlOiyj3LHLn+RqEv1iaWrDIOzIuWVf7P71kXKA0Me3G+dYvXa2BqPZpEyvb6O+d3HbfmRuOgaOLaaDSGGJV82SUhrTVIp47jEh/Y+Asg9GLBs6am1gyt2fX9cZu/zBw6RRgRjBH6eK2ZRumTroeAsYC8rEMqD+MeNt7NEiVaVBFQsRAZy2jCJQRdrVLM6Sc/+cm9MjTpxpl1PXUJ9TwI8JCFzESLEA1ZNRNsJZhThHOT9yOhWeswh+SSOaKdtB3yqTsoYFywlEGAaCdE8AMf+MDevDEGkBUI6+/8zu8sj1VgfIxlNHHVupAM1vhN+kUfbAMkx5jhzBJrQh36yt9mtjXG1UMCYuyu1nPJqooavkdfdPfNxEockjXJPW3XzdyxsI4uv8edmoPPk5A6p1NwHnUHTmK6Tjy59XCTrNJPlTF6/tgGkw+xlrN2sGVzMo55HUiMk6hKUh2vWibK8VcBYTxyxti6li1/hBKFa0hu05Kt23TGIKto8tyZvEmre+5dWfZtmyXgGo0pNHFtNM4oIZ2zjhqDtktCWt14Oz7mZEFCADHaxL3bOLNKajNzar4Hu7RITq1zS35wjKyrZow1vmtXrq37AW3HJRhCo1ujiWkgXFi2zDrK3Ek0+S6/g6xpSdWSY4Zgs8NySFx0KdVN1nnjc8gDx7ZjfJPAjRLzQAzox0c+8pG9eF6FbsmT1jTmEBIPYdWCBmGvNVzpL99b1RfL9HAuXX9NKmR921WHCXTSaq4FVUtxJRE1oZPzNEVScyxZvxAnDtcM8F40AZWEibVvfKsKxSy5I7Gkv4wFh+AckFUt3JvMucmWaqkdS+Ro2a9gDHVv1qU4lTk5z8aBSgB55ZyuG8fQtb2qfmmtl2piJy3QKgnqXEpSTWTl9QHr3rHTdVulhRmRtQTn2Os2zdzRdteEJYGM5zWufR05wL38OIVFNE4vepU1GqcAJgxZx0K6LUIq6Vh1NCE9XUAIgwggQLqWLPtQyWEm4Fn1fgoSo4xJq+/z74OuN4TKqfg7rpPC+jrY1HJ4EGsjc3DVVVct3TsRXrWC6cbMe11HTSgEueD7vLI/GKeYwriuh3wf4pa1Qus4cC0tULqkVqxD3FYdU0CI/+hHP7r40Ic+tCR3WapHy6AxfxBViajtZNxY3/k7/pcxy2kZfOELX7i0alnuhP/jKvqd3/mdS4K1KXTlrjGpmcl25OWiazOKCRUFKhfqPeN9oqICBZS1PXVjdrx0HzVRkgRqLn7YLL7bKgPFXOg2W/vOXFoeqa5FxgySajy6xLESVV2VIXCOv5/pKu89xhhL4kdrO13oM3u2+4pEtY6PMea6+3pt73HdlU1QlrB0jgqPjJPWss39iBcBa95+2j7apPv3Khg+4IEr/cgy3GjsCk1cG40TQEhXWUdXJU84KCEdJTnqWJazBYVchJzqigp0y6vlKqwb6HsJ66gu4gh8Z5M1rotiJbSu4VrSyDg5kwtxHd1/FRoR2hGO87N1SeUuwRgimDMHkCdeaxZVE/4gpJIoCIEZkgoJ0LVUoqoFFVgq5Wu+5muW7rQKuwjOWjnNLmu8n+6wnEP36k1I50HGgXZRtocstUk6gcmPWKMI7/QH4pHrAxgbaqwy84fAzxiYIdbxoe+MozGHGetXXarn2p0ElYOxde1wbomWMYQSJucM4k1/eLUczyoXW8aIWEfWfMZMem+k66vu3nPWNNoHMWQOar+Nb+Zcm1jkzCTNeUflpUZWW/piBmLmht9LGmu7jE9lHNMdls9q3WHXDusiXY9N0JSEWKu4ybmse5zkznJRXMfyaSqMLJfE90eJ34TPZb0OWC/ew1ppTUhlQjXahxdCvT+mYMItD925E62Ybhw2mrg2GkeAFManjlG2wINgHetoE9JGBYIghDWFKOM+eUXAT4FUkrhO8px0880jY/Tyff5+0/cVum1yINBlfG6WNNEi5/+OWmHDvmCZGZQICPbG3uZ3aCdjBhlDiE7rD2Oa1h1gzUksKBAhiAb7EGTk0ksv3SOoeR32C4kN56vZg7cJFRJJNFmbuPReeeWVSyIOdGvmOxANypKce+65i1vc4hbLdo7mjz5idQbGKnMOSvOkmyWgf1go9TioRNx1VGM2JSMeJtrhfyZMkqxqJeQ3EAb6oUsnf0PYuO+mrH4VECes0JDVkcWONtBP1joH500r9FzdYtYf56+wfunUmE+BNcea5bxVWaUiQTJGG1jXjJVhC0n0E8yJVmiz6KoUToWN4Py6AvN/2mLMr2Q1FQ7pqWFJGsfWeqi590kKJZkSy6n7x8zWrE/bntm7TUDmZ8barhODTZuqJVVrb6Nx3NDEtdHYInhYruOuuy1CmtkB56yjx0HgbpwsQIYgrAhkCV0VzUQLEHAsCbJp8px1IUnw/tE1fvTeY85KOcpuCiQK9IX/Y52aiueaSkCV77cBhWLjGhG2tXAZq4pQzav9tpQGRFXSyXxlrCN9hFxosaO9Wq0uu+yyoWVGC7QZcdeBWXpXHatKlBjjyJxwQFqNDdS1mXNAOO9whzssSatrcgTGByt0WvTony6V+TszBtd6ogr9ElXdihlTSU61uPmbkRIF8D8T/ZgMiPHWRXVVcidLw9A3yepoTjgnbs20FUI0pXBKcJ9ZkqUSS9q1bhbfCsZIK2kl1paX4twme8IlnvngdyOiqhVTd2eIPu2jzSabMhGRoP9mu5YUW84oSaoxoJbKsURQKlg8r/se7XBf4TsmOnKNJCwzpes3/aZt9JW+m81Xwsw9YVyu98EUAXbtWd5JS+pBSapW3+OWfK9x+tDEtdHYAt7//vcvH1zbrEG6jnW0CWljm0BYQ8hFIKykRffQ1MSzThGsEPT3U6dwE2Ss6yZu9pJaBHn6hWCslUULF7AcSgqyI8yR4hFss2MmuanWYP8vOdd12TqqEndIgzGJxj8iyFrCRPfdFKQRUhF+EZytN2nMq9ZAheIa22s7JU78ThfrdY+DCMX2GaKKm6OlT7KdutDe9ra3Xdz5zndetnFOScJ4cS6IUvaVsYHIMV+6NUMKHO+Myc64YWMWXRvMA8RqnfXp71SYZLs5t2O+at27xrEcQ+iz7E+CecT1mUPX94MSS7P4ztWEHYHxNCZ2pCQxnhQwBzxnTao06pvleVgLKB54ZS44N9cZkTnL+pjpmu+xNjIZliWAPPRcyHua81iCxxhVEzcxp5JMQyuAic70fjBbtUnOMmaYubU9upTzO8aIvo7Why7l1d13m5ZUxok20jf6QFsajV2iiWujsQWsG7tVCenIOiohbTQOC7qUWjIkoQualkSBUIiQv6ll5bCglc/ELFo1EAqFgqKEYcqKqxCrmyfvzfo6cmt2P9gklpfzKZRyDQku14Y0MD+SEV36Ob/CsklhAMIpVjSsqQrwluzJLLCcG4FYqyX/l3xY6sakRLtWTNSxgCRpVdVimdlXjemjfxdccMHSysoapU8Qj6ls0owhngQSfsDv6KexuWbZ5bvVqsg4qADQfXTkKptgLK1xa1wrc+1+n4BcSFZXWUBZ07STscIllLkcZcCGrDI+55xzzp4r9DpgfFBkcf5KLFdl8Z0D/TfZUn1umqGafjCPuKlPZU92jUretJZyDj0Ucm5YVyp7zNjL+DNu9DE9FExeZChBlsfJmreZTIl2qNjTosqemiVsaKPuvSYJ04OB9eH6fd/73rdsvyQ1+8x3LSuV82HW4SSpu/C0ok2sN9r47ne/e9leiTT7aaOxS7R03GhsASZzWMdC2mgctxqsmWRGIBQZl5fCDwIRhHVTYfUwYRZSEwlZC1OiIpEzLhMr1boZbBWWk6DWBFT5uYR4JHhbJsPyI8a5ZcIX2qdFFXAuhPGMyVUgxvLN3JhVFmFeS6sWZq7DuKQFKuM42af4Pb9D8JX4OY7bKEM0+p/tQgjWAqdVUndQyaqJg4jHNdMvZHQOjLWWU8HceK4cG+O3E9ahXRWzqZsnYy958Lyj5EWA7xtPOacI0s0dZYzn430llZIb1gJklfW+CRgr3YFHxBKyCkFZx7VYMJcqkWrSIdaWpZmsBTy6XyRneg1Imi1dw/lRdJh0Ki2UHLTd0i98bjZdPRSMYVVBlc9uswvr2WDGbj43RlXlk67CNeEZsDyNRNVETtQKhgxOZQ3ODM8qQqoldVfhQCpomDuyddtWxo5nB2OmR0yjsWv0Kms0toDzzz+/x7Fx4mqwIohUQVrBCEGl1jY0ac9hIcnhqoM+IYgibNv2LLWDkAiBQ2A0Tu8gMHZ3yhJZkwkZo0nbENwhR1pTjIOUrOm+aOIerTf8ns8hDVpWTDhjoheVaAjRCPGQcmMoTRyjNVqXZQROy53wasmjXcfFWyuXazFv9t//2V76d6tb3WqP2Eny1hGUdUfN8k2uc4gv46W7o7Gu6U7JmGC5Njaxxm7TDn6XcbwQKsgVJIQY05FruZbbVTVuWSMQMQ6uY9bcSu60+tEnCOsmbsBCy2ON4wW0kXFY5YZdYeZx7je9OSzrkoqlKRLsOFm6qLrzMx4oOyBS1uX1vlJhpNLG/pn8kPvO6+vJYA1craKsN+NHJY+OrefhvpxSOPBb7ikzBntd+u5c1uzOgjbYd625WZ5nV2A8aBv3JuuXfYSDMa7eBSrybFejsWs0cZ0Bm+HP//zPL97ylrcsb16EIjYoNE4JNiEy9gEeQmyujUajcRJqsArdQdnn0l3YxEsIT5sIwsZkVivkJsc6Lrb0yVjQah3SndGsrOtCMjeK1ZTsrcpkrEXR9qEo4JliHUeEbOsqK1wjFCvYKoCbTZk+WI7DBCsS1TwYAzPSas2ZcrU0mYsutlrf6zg4FqNauvn/dYRp1oLuuhAaE2RpQdbqxnvIKiTdxEcQQsiT9aFXlSJiHBhz14DjZnyn2WiZBy2v9pv31rycgwoD+8ZY0zdK81SY6ThjHyuYpyQ0jA/jwXuIV7qsWuaHMeIe3Y9Lt3G8zHtNVsY1rL26biIuwThwTuUmyyNxLcgP7XbtJZg3XX/pE31LomrMs0SKsZI8OlYceU9mQsSsIa1bsgRVa6oKIxUkrAXGVcuwNattb+6LWtyz1BbzZtbrtJqP3K8tcYQCgr7vmqQ6Juw5tAlFFwmpmCsVJBx6Z9AWLc4kPwPMrX3uTMSNXaOJ6wDcoE9+8pMXL3rRi64RW2BChgo+v8997rO8yW9/+9svLr744t3OWqPRaBywBmsmV0J407U2gcA6lXhJYcfDMiuS1HVI536h8GeWXYVIhVKtqwjAJkZKQTMJpp9lwinPoyVXQXddmIEWwdpyNAjVo2ypWmIkJ46fFh7JSZbzMDupliHg75gL4/vM9Jkuv2ZbTdKwbkkhx0DX6/od46CN35MI5JiYjRahvip5dYmUrAK+B1nlWNcVkbG2TqkhHLxChjgQtMmaXJP16AbLsYoA0gd+j1BP3zJpV1rPGBcUEmYEHskQJuOSnOqa7WcqkrTeWT7HRD6O1X7c6SFUdW0zZ7oDb+L+aUws8+xcc37G2wRUrFkswgn6JFG1Hq3nk1Cp7NA1NUs8GQNtYiStpJlMC+jCm9ZUxk6lkSTVfpvpmX7U2P+cO5DKG8mzMEOxNV2N0ebaHvSfvTbr0u4SrF3LSWF4UclgP3mVsBqLy4HXzYUXXrj0MmPeLFtkToBVye0ajYOiiWsBm9QDHvCAxXvf+961BS8etN/7vd+7ePazn70MVr/kkksWd7zjHQ88OY1Go7HtGqxA6xWChy7DiZp4Setdxl6mW6eCTsYupmVjk/cj4uSRLq8Kf37XzLIIngjIc8jrHhQSeEgqY81B+0aufwqrunVCQHQbhHRm0hf+x/yYvEU3TfpoPJuE2/g+BGOtZAjfknHOqUXR8jDVIr6qvNB+rfuS91FGV8bBsjrWkWQeWVv0CRKDMK/FdRX4DeuZ6+bccg3OY5mf2h9jUkdZcTNpVmaY9Ry6fCcY3ySro7Zbf5TDxGG6kvtZxnSyHnyf87gJmHPay/2eJYCE5ZHWrQ8rGJOPfOQjy3q6Zh5OS7qkR2UA8yxRZV74m/lSeaMyjDaaeEoFUK11yrpxfHJdS6K4lyTMmcHXrL/eYxBPkzHRl1oGLJUVKl5MuiS5r/uJbt7sB8bX0l+9JWgXc7mu2/tB4N7J/fHhD394z/OmWtnZx93bGZvzzjtvuSaYKzwV+Mx+QXgvv/zy5XgZnsEaxVOi0dgVmrgWPPrRj15cdNFFy/dsrE984hMXf/fv/t3F85///MXP/uzPTg7kIx/5yCVxBa973euauDYajWNXgxXhiH0NAoQA88EPfvAa5BOhw3Iglr8wbqwq8nSbM3GOxEuX2ny/6jOtoiM3M60VlkABSUyNgUPY3obwl8R55H5qTCqCNNYKYwK1ZmrRtC/WS2XcsVZAKGkzY8+B4GisKr/luwiJJh8yXrJaACWrCJ8IpIyT1ptKng5qxcnSQnMEl3FhPBiXqfIjzJH1Kc2azPl55TBulHEzpjN/O1Uzl2uzpmmHpIL/IXQjjDPWlViYlZj2aK2uBLVm6Z2DFj/Iya1vfetr/C9dRDP7r+vbGFYTULFWWBP0hTXBeqCd+6mTybWMM6394Xqcm3Fa151egk3WZxL14F5a9wgIokoJ1qTkh7GhfyrCaJNjwnhLrjhYQ1XJwBibIdt9wAzRElSt0hJXCaYE2qRJZtW2lm+GGpg93ORNjJNeEHOJ6RgDxth1bYyqoC0qkfZjKV8XjAf7JeMIwWSOUJCN9nL3Y8aa+5LD8QO8Mke/9mu/treOTLLF/Lv/uD9uqyxgozFCE9fAG9/4xsWrX/3q5cMUVwhuUjecVVn57nSnOy0FDG7q3/zN35z9bqPRaBxmDVaENGt3skehJded1zqSkhvqT468TRTsJasKcpbvsA7itmCsJkKR2XmN99L9EuEPIXVVrOPU+9H/kuAh/NFfxpVxQ/izFmxaKhDyaowexIOMrgjqjDuCMPkR3vOe9+xlMc7f8B2+z8FcTRFxxh6B3tjBCgTrTZIXrYPMmF5BvyCrWpst8wJR0X2ZdtAf+sV8OZ7Oq0Kv7Z4iZxLkJMQmGkuCq6WS6xJrmjG5EkPGG+gquYmwTf9UEnAe1kjW1PY+yMRKNZmS/2N9mxn6Fre4xd4ahyxIcDbJ3jsVZzpyU7f26ioyzNjQftY9axcLm3M9cvVW6SJRNXsu7WA+6Ldu1vSf/0nqs0ar2XxNjsQYqRzgNb0S+Cz3nxFRlXDrheI9nCRVhYU1VnVdH+1txsiyDtwf+X26yDsu7lebWrM39fzgXoCIc9RQimyPMb20x72P/pg5mPGxxNaodi9QsVPDCUbW/EZjW2jiGtCiys330pe+dONCypBXyC4aqEaj0TjqGqwIVBJWhBi8SbRsWC9UslBdQjO5j3GenE+31RTktAql5XQVQZx6LzFDiLVtwjqBWi13FfdlKRAJYq3lmDD+y9IjkA/JtC6U1DrEPc+kSTluCPiElpDohN+NSAQCtiVsqmuf42J83mFk9mTdsN6wuI0UJRJHiBHuhfSR8cDlkz5YSiTd1mm/1qpV1l1dyzkX8+SY6gKuxwDfN/Mrv9M9kzmj7bXNNQFVxhl7SJKcJ/7vWrT9CPqEDdW5og1aViWrrBl/zzmdx02TIQlr1RoLWmHt1SyBVCHB01XXe4H3o1I1zDVzjFsp7Weu+R5rlvVvVuzcdzhqMiVjeFWS6P5PmyWhZneusPyM3+GekMzplZBtyIMxMzsu10PpVJU+ktSsk2piq5FlGOzaFZi2Q8JJQAZR1UOmtiXDEBhL2mMyNkLbTBhnTLikNpH3hs8GXZ6Nd3f/r6EpjcY20cQ18OY3v3l5037d133dvlx90SwCHuSNRqNxVDVYEa50L2U/etvb3nYtrTn/1y1YaH019tH6kpVMaVmxHiEC2kGsCJbMyCyzCYRJhe1tWSvMAGsJHbOd6vo8iuM1YyiCMfs9JBVipvVOYRK3VIgRRI1xhwB4HjOH3uY2t1nc5S53WfZrJIgz/rTNdlVopUUwnspQu01ANBCSEZBHZBUg7KLUkKwi2DIe1qdMsKZQDvP9Td1fGVOspKxB5oPxMemTQrWEBJh5d8ojwHlVYDeBj/eGZXs48jf8P8vHeH1LGKXLpuNlcq1MBrYNaxzzo8Kl7ge0k/6z1kbWW0sPsU61hvu3R96XJt/SDZY+8X/jXDmfrt8emdhLhYLjYU1YkyfpCmwW7RH4fpJZ+8U4aL01LraSVMfd0krMl3Wr09KrNdXMw86xZY5GigHG2vtSV+BRPehK/lf9DSSb3Idcn/vQurPOowe/zwzg9FfXXojuKIM0Y8BRFTgmnTJZllZcrsGY6r3DZ/y+iWtjl2jiGrCA+e1ud7t9DabxFqPNrNFoNHZRgxWBwYQaCFcIgrxHuBolYUFIQ4BN116FHWPBRuD7ElXOsZ9YuwrahnA5cmVEeNS6ul9XSSGZkeB4TV3dtPwgkKXV2sQu9BlBFEsMhNXyGDWLLWSV54hEJwkr5+G3ZJ6HtI76xHctnTHlnmdb9lOnc1PQr7SsTiVYkqzqFgr4LkRmW4SVsWD+cGVHeOf8zJdlRqyVmSVqTI5kPWCtscbFplCflt11EjNyTi2HPPOTLNIuxkzrsFlugcoR3Yx1CZds1T7P/Q3Mrj0iCxIzrsX6RumQ8ekmQOJeUFljjCKfa73TndtSKIYI8F3WO2OgZTtLz9Rsu65XSWdaqlWG0Vb+pk25L0gmtXhaYsd6qGbStvYvbcnxsk6rLt66L5twyc840uKca2/k8p3KKO5J2mfbDwrr3WrtZj/XnTlJqu7ztFvrMe/5zLbyt54HtllSag1W5iqTW5mJ3LXO+ki3YxPDScxVZmToRKOxbTRxDagR269A5oNjzgWn0Wg09gOztKItzyynvJq8BeHDRCyV+PAdLIQIFbpdStIQQCqR0gVWsrot11zd6xTCKrgWxPog1icFczOoKtAqyCFsOX58jzZVa4+kB5LFq+6/gt8zF5aS0FJt3KKu1SZlIlnPVGkh3Rlp58jlkHnV5fCgJH7ddQbxkiBWmIX35je/+TXIKpiysJoYjLld9YxVkeAcMT6MNe1RUWPpIMYklS1a8CypY8kTy56sAwX3OXdlXdrTIq6rMvMP6bGf/l9XWNYTbdatd1O4zmrNZWCCLwkrSGLKYVwph9ZQk2tZX1SlmC67nMtwAD0kaiIe3WlNnMTv/I4libz/tLjqgu1YSZTS6pkWT35PG1lf9MtatyNSX0vOJDn1mHPhZf2xh2T93ATnYy4dl4NCLwsTILHeWUdaVSWoJhFzz1HpqNU6900Tqxlr7v6jazafaUkdZVnXqpr7kp4VHO9///uXv9W1HqUc7u+Nxq7QxDXAAxWtOckH9gNiBUCtTddoNBr7AQIZAkxavNLVDQERl0wECWNdEaQRInR/QzjRRdDspSOYtEaiuu2Ml1ybviCYVQHJTJu0c9M6gApdxtSZpVRrijB5ikKfCV9wl8ZKQJ+1KiOMctQ4Q7PmOh+ShiSsjDOEjnmxTzwTKmHV5ZD5GrndMibGO64q77ONdQbZ1A145K4tWdWyWudpP4RVT4GayTfXB+vGNlkuhfeWMtECyBgzl5L7g7hOa4lKuH5cw1revMfSkqWV0b9dU/uNWxX023jEStR0UWVPAJJQs4KrpFGBIxH3c8fdckwqI5LsqJzXrVQLo+ST32Vcse6qaf0zqZLfd57SomrZGkkT7UNxwdqi75VEZmIsFRXew7r7mqwrUdeIJbd0C/c+SMWMcaKMNffA6BwVU98x5pn7hoNEYcbT66rt3KlkSE8Q+5QlwUwwx1xmpm7gmjHbsqieG7ZPDwXuLeOHIaso4szWzPxwT+T1G41doolrgLhWHtzEg3EzbpLkgrgBNE/ctPe4xz12MVeNRuMUAwEj66Sqca8lbYxtNOEHAoTF4tmzIBaey6RJujRW6AZr2Yptu54iYBozNwqh0G2Z/qwr8JjoBYFPEjFVskeyY9+5HqSS6+lOSp+TrFarnJY1ng1cL/shYeU6WPguuOCCvVqgI8KKMIlAbLKYCpURZkvepRAo0TRWbkRWWU8Iqljq6ctIqcD4cp5qOUzCanbmSlDnMvki1NMuyZfZZmkPSgEFdy0/m3gESNqyhu3UIVnMeqsJP6Mt3j/MIS7hliIaWZhXEZ4kD671TKZWXVS5hsSUQ48D3Vt1ic0xNyMsa1dSp7up1mFjPI0lda+QMGlZNUuyc5XZgfl/xsOnR0fGqGpd16WfPuv66xhXhRrnYTxYZxyci2tsYgF1jK03rJJm2/elrvfsJdx3EFX76T6WtWoZNzMUq1hTkZAZ0Gtd5lTaZS1nY7crMimYsdZavi07RRssHZWgXbpU245GY5do4hr4hm/4hmU5HASKn/iJn1g8+clPXnsgf+AHfmAvTuMbv/EbdzFXjUbjlEBimURVgRIhYGSFQ7iAPKDtRjhDeESwQPjRnUwBFeECYb4KbwpAlpDYVdF765zSj2pdpR9aIlcpBxkThTmtqSZPGhFxrQwKXYwR40Bf0+KCECdRrS7AxrNxPbxvTFSTApnxYpwPF2AEf60NI8LqnI6szQDywZjMJaPZBnRvNgPpaAyZEwRUyeqUe+2IsEoGjYOGDOB2vEmpGQkM40/7nEfH1UymzCvjrptrJhZbRUZXYVVMI9Cqx7w5jsaIozy6853vvDgIdMeVsDo2gD5677C2mFPL1UgetXzWeFNgLKpuwM4Pc8aYWrYoYx+1smoR5besaa6tYirXti7LWmUzmZJ7l/tfWrFTSTGCbvOuh4PcM6tc9C3tM1eiaQRDEczKzB7NXkKZGe4Hrmd26YxDNeEXY2voh+68Wa5Ll/SEVu1RnV4JK+9N0iVJdd9xbZmROufS2tKuH169Dy1vpbKjLa6NXaOJa+Axj3nM4ulPf/pSI/a0pz1tcf755y+++Zu/eXYAeQB8//d//+J1r3vd8oYlHfxDH/rQXc9bo9E4IbAWXsaYVSFJjT9CVArBlp9BEMZSqPsc36PcBsQhCS6CFu6SCrVaXCWrm7rhbgLj9RBCq5XYtmldHVl20y0Q5aEJlMzuOyJ8gHNZB1SXUQXuFKIYS4TokcumtQe5HoKlFtEkXNbWtNRLCnsjwkpfFIpHBNHkQQiOu5yXdciqsbisszmyCpgLhHDGKbPGWguYcfGzOXCNGndI28jIbA1KEyrp/svacHy1Fm8Trj0O1kS6/ZrEhvlC+NfqSN12xtiSTuAgygfd0em/8aB8BinlVfJishzmQ5dSiaouuY6xyXVsp/GIrDuVO8ZyS05MwGQyJBM8MfcmyBopJPgu59Ha7DilqzXzaxy6iqgRcdRlmXPZxoN6Iqxy0Zc0rlNayj1LDwLmiH2LNUxiMuOy2VeYI7NOe7i+JJaMse/XXUMSVkvSqEBjDrifOSw3xb05paw0XMAx0ZpOvCpj7z3KnPDdzDjtb2jLtkNMGo2KJq4BbtIf//EfXzz84Q9fbvIPe9jDlscjHvGI5WaUsazc4G9961sXL3nJS5bvARvGT/7kT7bGqdE4o1CYTKI6Z+HRdRRB2ZqFCghquSUCZtA0U2tq3LVAac3YVpmaTawWHFWQRZDSja/GaVqOBsFVwuuYTZEek8RYkzATx1RX0bT4jFyAaSvjbjIU3UGT2GXZH4XYJJmVsNIn+sFYjMg7bc0SNrsCgqRkNS12oxq/WFZZOyOyqlDM+Rgfz5drWgt6KiTSbbHOla9+h3VtBmJih9Mdl/njvCodXEOrSPEIWeJD90cOyITxhIDrGY9rAhvnbBRrnGVz9gvGgjUIEdfyaMw07dJaaX3UdP/lMLGYljBfdfvVQpvlflh/zLvuwBJUX61DTBsgYqynqUzXWkFN1GW2WebSzMBpYeWocyhJ5bD8FeO+Dc8Qrq1i0MRpCdqrKzDXq3sm38+asyZIwpJqNnGVOdwfKnJUInjo+mvpJcMVMiZ6CpJSFSTGJ7v3034t5re61a1myz8lWN9mtGYtmMWduURZyjmYL71GLIWTYyPMot1o7BJNXAv+wT/4B8sN6J//83++vAFf8YpXLA/gZkbtvYQb0n/8j/9xcb/73W+nE9ZoNI4HsqSEAtk6bogKlVpLEBaMWUu3UQu5sx8hCGklSMGAc2FhRatudstdl0jJMg0I2yOrBYKwWn5JigJrus0qAI4sN1o4U6jmXFoWRv1kPBgHhLjqAmy7EdBUAjC+vM8+GDdoRmGtKimgSVj5P4KfQjGvo1IZlrDhnLuaH8kqQjTCc3UZrGTVtgNJRU2UZPIkrEaMkyTINahyxHtAt0Zj4tJyJMnKLMW6uuNCmYSV3zq+o0zKlXzWv0dHkhH6ZY1c5z6taxlHPiIyB4GWTw7Wn5Zj1o6fu8Z1veR7jJNu8BKfVNgkGVLhYLZwyZGxmoQbQHZ0+7UMitZby21ZambKGqrCgnOkW7/Qg6K6/9KeVNJppVXhtkl+kTlYLknr/SoXfQlq3gMcZkGXoDIXzFt1yTYTcyZLMgmcllRr4FYyLilNcio4p9Z+2uy8MpfeGyZzG3m0qNjIbMpmtUYZlbHD3nvgwx/+8FJB4v0+yrZtCSXX62E8fxpnG01cB3jSk560TNT0uMc9bukSM0qWkCDG6QUveMHigQ984K7nq9FoHAF8QCdRHRGDCoQJSRcHD3atiwgDCgsmwVDoREASJmbxenwP4eWWt7zlcu/ZpZtpgn3Puqsjy4vCPkIP/WSszDKL4CcxmipdoWs0h26GCvoK7H5vFGuoW2IF42aWUC1YNXaRtutSjUBPP7huVRSYyAbyZw1L5nMk2Ctocq5tlRLaL1klmRHWE+aGfjEGWDjTVVMLqYdxypZyEWapZpwsMbOp1ZExZeyw5NEH4/A4B5YewnR0T1xFQjctNSIZq1DB4No7iACusiOPzJhMG+i/ih/HPOuPShCsPWrJK8uX6BpvciYzvJpY0mRrem9AVlFwpaWfOXY8dPnU+pZWepUVXEN3cPcu44HTi8KD32lJdb0Ya5mJ4WjTtpQDjJseIKNSThJuxsd5gry53iGlEHcO9i/mibGpMdQ1jEAymUobEyLpDiyxS5KaY2zZIPcN9hrGjfuN79O+mtRNjwfWbS31I1mt+w9zyb5BHyXr9FFCzecSU9ehbs5ZpkgSbcw016MtjcYu0cR1ApDQK664YvGqV71q8drXvnaZaZgbnQ2dDQ9N8N3vfvfFQx7ykMW3fuu3tpap0ThlJDWJ6rok1Qe6ZFVtuLUxEaZ0G+MzBD4Jm26ANdYNwYpzadnAwgoR2RUZqqCdJloajQNtMvERgu+ll156jTqRI1JnopcUyLV6cA3J5Qi6AEtWRy6uWtQgq4ypZVQybpX2ch6tLlpE+R0C64iwIhzSNgjXSCg2wynn2lWsly6K1o+V1KdbqEm4dJFmHHh+VcvxCLqlWzKIMZI8QSrnXBBXWT4t2cT4Mc4I5BIWnql3uMMdlq/bIjFZ83PKzZX1a6be/bqkauGUfCDAX3bZZXv/916XEKWbrwod405VBmSNUbP/sg9oVWNeuI5Zj80qnvVrTWJk1m6t5xJVSZj3myTamqHG9lpbuRJMxjP3ScsDGQMuSQVmKfbYZmI4XYFHxM7SPFo6mSfCvZgH9mTGw/3NMXEMfG+yN6+lddHxkajqISJpzLqqVTEETO6lIohX1mOOsfuv/fJ6rAXLbulyPHXfMJeSS+6Fyy+/fK+/HIZ0jJSgPtd0lVeBqaeKCabS4txo7BJNXGfAJkByplUJmhqNxsmEFoIkquuQVISHtKSaNbOCc2qVM/5VIoXgOXKD1CKGcGNsqNYgSOsuk18ooGm1wIpnTJiJchROtHwhAKqVnyJGEh8JuLFk/K1FFOFsFIuZLsC6E47iwbi2ZNWsw9V6ZDZhrauSTOaAfqCsrISV9iKIMif8v2JVfNw6YMwy623NjMu1IasmLZKsOi/GOWp9QwDld8zhKuiSDbSSOSaSKSzM1gKuZDTJ6lTfJUyZ1EfiwrXudKc7LQXwbcESRqyHkYuolqEpYX1dqCCptWsZe8ubsB7dA5xXsyVL9LCGZkZW3U29X7QC21aJMuub30H2JS6SEIgQYO3o8qkSiWubOVuX/Uzuw72qIoc1nfebGdFdp2aWTSXEYdSFrq7A7q3pmqy3hlnJ3R+0uEsivc/SJdb5yZI+WiS1ZGaCsczQnF4LgDnkHjITNmPF2E7dL5J9FYAqVyTI3o/GutJP9jlJuiTV95yDsTFBW60Fnm0xCVkqX3WfzuzBmT+BdkjYm7g2do0mroG//bf/9vKVG/BNb3rToVk0Go3G7sEDvrr7ThGlRH2Qq92eg0QDgVV3TOOAFGLS4qCmXpfNdLficwgrwp+QQFZLW/1s1f/rZ1wfAWgUq8n4Iaisk0REYY4xQ1BDMEKI1T3POFMEqalkHukCPJVkymyrCt8mXNJ6BBC8aINEWSsH48n3Iay1/APQ4mVsZ4WW4lqns5LQdWqGjsgV7ddCZ63Y6ronoYf0VYJR50TLCXPAXOjqx7iiNGCdakHSqsM6XTfJywjGS2rdyoyljNuFF164zFq6DQurJXSmsjgbA8gxcinfBIw/VnkUO8aAqkDw2mT9lnhYskd3YbP5Wm9UV+m0/ua60vVXC6dkJvuh2zDzxneuvPLKa3g7GJdu7CrtVDEhQZGEsqYy/jnXL7+hbaM5Mwu67r/bjHfUlZp73RqoSVgtL8M6ziR57mOZMCwVcElO6ZPZpE0o5qHLr38bh8pvJcjs7dYu9pjKol4TUkmGgWTcPcj7njHlYE8y6dqIKNaa4KzDmjyP65kdm/mmncyrybDMP8BhG5l/s26bGEqXby3LTVwbu0YT18DFF1+8V8+1SWujcfJJalpSNyGpSVTXtcjwwCZxB7GDCBUK6bqWZcIghBCEFq6BQIAggFXEOCIEDNqCYIEwwHmTZG4zcyNjZf3HHCOTtSis0s4RMTLzLgKV1lT/tiSNrrq4q46y7VYXYI6pcbdepVbsUc1NrovQqDul1m3dkemTpSpyLBH4tCBqPc6YNj63Bi7zaAmdVSR0XTBO1nzUAq3QKnQBhVRqhZNsavmUlHoYW5hkwxhkXbLNmMuz7yCElTFjTCCrjI81OoGKG7Kechz0OavrowRmF9bw6p0BacJN23qp/E0ftZgy/yquWI+6lJv0CyUUbclSL2aElTzm/sN3uBZrNYk/0J1bC7vVD/R+yBItxjByPtZwJvWRrHo94LrXu0JLYyLdf3UpP8j4GuMr8ZSMsj+arVtlgfHqHIyz7rsqBGvZGfuqy7oWVpV2WpvzPpKcJlE1Hj7JqYnoRu7P7p2VoGotVdlBfz7wgQ/sZe127Pm9ygyzcK/KZq/CQiWh4SbO4bnnnrvMj8A5jXn2OaBFOl2jdSXn3IZ3oCzzGcbnukp3HdfGrtHENcDDjY1xmy5LjUZjt9BSmJbUdcplIDhUd1+FGoUZs6BOWSoVriAaHAiWqc03PowHvS5bklW+w29qUh0e/MZc0saRQH5QmOVXy6SWVAQPEygxFpJQ/68rIu03SYu1H004MkrkdBAX4Iyp4nCsatyqmYw5jwK67qDWv7WmKdY/Y9iM6eT/xuRJQJkj51AyvU6N0nXgNWg/JA+iQ38UorXCuT4hkzybTMQDFIZrPdQ54bESVsGYEcPqutsUtJv5tlasViETDDEPWKNIKsb9sF8ovBujt+0kS1pGvT88GLOMKfZagDXC962lSv/4rplfJR5aJPU+4L2W07TAAtaqZE1liJY0Xi2Rw7o1JjkTQem9oQcE61fwGX8bs8w1dTmFBNbEQ/k+60Jv4v7LuCQx9X2GT3hv0QfmlvvUOFSJarZN910VAda4zTZrZU1vBc/BOGhdlagCrarsb4yR8accutGP3O0lppkZWIus7rwqo7RM0l8zkieSsNY17HNJ0mvSJK2nvGdMuR/5vXsI+weJz2w/52B83Ucz/ECyyqtWecbDNvMdreoScO6BTs7U2DWauAbQhI42kEajcfxIKg9ahcW0RObD11dgsgxjk3i4SybN8rsKmTVTaxvtqAmIspyHbpkpfJh4qZaSQcjld1VzrxA0Kpkwej/1ma52CLpa44x/4uA7xNvVUjJaVSWZI4HVuL6aBKlC0st5aiISwVxYqobDcyn88Rl90b2S9ngeXo05M4OzCU6M0eKw35JnXiWkWRJn3Yyno2REEvEsH+E4WfNRsgq0fpi8CoEZwso6sp9JUDchZVOENV2C92MtYU5Yy95DCsOML22l7boz7zfxUiZZ4nV0r+pmu24WZ+aCNuptoAukydi0eGnhz3tc5ZTu3LQr40O5f25zm9ss26PiyjjQJKu1nZJQY8ury6ck1KzdyCu1XZKitDB7T3B95oF1Zey015nCOu6/XndETD3Sosoa8b1KKe4JSxTR/3TzzfIykrAk+WmhlKBWt3pdgDMuUxd6xgqCyn1AwiPvh1qWJ2O6bZPjYaKtUZjFCPSdPWlEWJkf7hWfVZJf9yzDNuy/ylTH1D1TEs1vmEfG91d/9Vf3lAA1qZLxwCoufWbqAmyWfA7+x1y5/h2fJq6NXaOJawAX4fe+972Lt771rTsf+EbjrGC/cZg8gDPRBq+6b84JBgr9HqmNFwo667Tda/tAT210CtBqyBV8JBa1aDxCPucycYnWDxRnCob5G60C+wXttSSNyXeMu9XFjutDWNOSsI41FCBkkiUWAcYatUmsVrkAp9BlOxGwFDolq1qHs16lwjdIIpwZjU2eI6kygYvZhFNJoGXKhExTZHT0mef32r7XQsw1M2a1ki/JMusHN1rmQ7J6kFhBrouVuWZbPShhNfGY1motrow3/aBWrFYa1vYoedkqZAKh0f3KWtAqNVX7M5N0JUHNuZnqn+7ormOTt9FXLXXMkUSCg34yd9R0h4AYUzsXcqCbLx4YjKeKMWtDe1+ZdRtIYrme90nd+8wyzDxzfeMduV+n9lBdhz3oo/sx8zFFTIUZebWeejieSVKNTacvmcHXRGNaPnW3zSzL6Z6v5dE4cJNfOU7upyadYl6YI0sEMUfGphumwfdti/dHloXJGNl8n/1Izw0JIr/XzbyScrNFM87WieV9JmOrcM6ZX8lzfo97kH4bx173HRU4vOqpYtiA45ehH3PYZghLozGFJq6B7/7u71485znPWT7kX/KSlyz/bjTOCnwAb5LMZ53/r4MU+nV3WycmdSSorRtnk8QwiSJCgq521phUKy+RNbOjVksEIMhGJlAaJXNBaMti76PES9tCuuqmVVUrL+3G+pJWT5MXGe82NY4IOcT5IQBnRtWMv6VvuhObOMnYKQVOM6MqpGciFV0I+Y6JnjLRiW0dJSVKwqrrpwKdMZYSAS1RlvtYVaYj16oumryv61V3bBQVEDxd8YCCOKSD9pCgCBc+2rAq+dW6UPgdEVZdgvdDWBG66U+WbuIa9NP6wsa7QQo2XdtmL0WBsUmSJeYgLf4e65QAynObsde1Yn1PLfwp1PsbrZJ6IzCX97rXvVZejz5Sg5fDOF2JHutcK6f7k5ZGIBmEbEgqspSOa5nvIdNMeUCYvViFEL9RWWQCoBHBl8ym9dS9U3Lqq4qC3HPdVyX+qejLJEneD1p007Lrq9ZWlQdmD3edSFZ1o1URYT1T3PT5fX6eBLS+B3r0JHm1vVXJxashD4aT1OzLfIf1gPJiTqGiW3KW3dF66/0iQeY77n117iTDJtti3VQrtJ4xtT8ZT0xumJzTRmPXaOIaQJh57nOfu/i+7/u+xeMf//jlZv7whz9855PQaGyK/WSMXfX/w8oGqOCfRHUVSU03PF2VTDpjQo1N3GbTiskDXPKkiyvf48FtbKohBAgKWMSMRzNJzlSsF2OKQA+BSMGRhz6kcb/kYQq2lWtaw9SMxkD3U+soKhxLVle5WCKEQlZJJKWQrQDJvGbWZa6J4MuR0Lqi5SJdarWIsi60llv2QXdH41Z1FczDNnJNBTzaZVIcfqvgmmV5RlC404LqWp1zq6xklffGqnI9XdQRCFF2YJWkL9siq7sirIyF6yrr1+qCTf8g364p3ZvXFWTXTbJk2Q7uxQ996EN7ltRc4+tAsqkngJ4PkBjGzmzIunHr6pu/p38kuIE0MdeJqfFlvBhD2s7BWs2YWcC6VomS8fd6bJhATE+SGu/JwViYqAlkjKfZzU0ERV/0KBlBglotqNXNWos2Y6cVsboq+1laLjPWM91WdU/N8i5ZtiZLBplUyjnlPeNgH12/tNdnwKb3QE3c5NglOR2td8t9pWJOYqmStd6r6Yaca9Vnn2Wp+J7KGtaj86KLfrbNMQYmmEoSz2HG9ZopfQ5Y9C2Z1mgcBpq4BijN8OAHP3jxoz/6o4unPvWpi0c96lGLH//xH1+S16/92q9dPkzWTUaAprnRWLdsyabE87hCjXOSw3Qtk+j4f4Uytez5mllRTWi0DZJncpdV8V1aAxlzrm/sKW3gYW3txCkgUKDJz/PTZ36HYL8t7TTtoz8I3By6wmb9QUsdqKGXqK6TaRVBEbJ66aWXLs/vXHp+zkGWSkhRKiUkecad6XLNZwpKuti6pmkT44PwZHyWGYKtaTvVRogGhBryY3Zh67BKWCEfCmaZSCoVKWn1Xwf+3vg83pvQyWQmuktDnnVN3LZ1gj5DvGrCooMQVl3bTbIkzDRK3zm3fWH+UOysk4nb+5D5SsFdspKulHzG83nk6jgHE/eonOHV8kq0WYJK6RrOzxxqFZMcSrjYA7hvsaaed955ewqPt73tbZPX1xLN+EmKR27iKpA4v+00qZhkhPHi77wHXGsqWaq7rAfjZx1llX18xznUxTWJqdZULZysL/qTGbwT7gepJJSA2da03kpedb12rl0b1dIpEdV9nvcSOL1t/J8W6HXvsSR4qQjz/LorZ/Kn7GdaIv0t/XOc2NNyTiylpdXSZ6a/NYyE703FFXPeyy+/fC+rNOel/9yPyqnGrUr0R6V5WBNaprMEkpbsUSmv/BulDfsev+HcHePa2DWauAZqPTlu9He+853LYxOoUWycHaA9NwFEPnSPsxZyG8l+8jNg7TfjUnW5y6QaFWrjM8NvJts5KEywIlGdsiwA+6RbG9bJ/B/kic/mLJNcC3eveh0e6FjZtlVqi/MjbFOOwzqfCcbTEjwZY7oqTsk5RKC/7LLLlmSwnlurGhZDhCGtmwpiCm6MhdlfaYNWE+4PY7dUUkh2uG8Q9BkvM3paKqSC7+qyDOlIAVjCKlnlb4k1fUuCuu59apxclh+hrfSFcyt0HhZZnSOsurPvh7A6RsxdHRsVEZmllrmhj/nZCPyWe5Bx49y6sLPeaL+ZcCVo61p9jE02LjOTiNl35sekbtw3kEheOQwLUPjW8mTSHiyr9M+5HcFMrxK0n/mZn9m7l0au8IDzQ2pYI8bpsob4DWW1VMBIenSfz1jM0XPGWFv3UuNUTYQkGZXUSBAlqO6X6YVS265issbjO9aGBKQ7r+32GelvMkxFEmj8sC6xkkj/TiukFte0HqbbcGb8NeGQv3HMJacSydqvUe6B0f1Mf1FYsi9rBbdsEfejJbkS9EEPn7n6tyopKZuDe3nud2Y81tVZZYTu7+Y2SI8i3cl5fpjoS7frORjmYV4CPRMY1yaujV2jiesAGSvh343GHEzasQtk8oZN3WHn/n8QmFFTYTMTJ63qi5p/ra3bJKmCtmWdvykrjQlxjF81q2jGOeoWuCr+UIHFmpVC8jJlLdwEjDFEDWG7FpQHuqFiEUaAWJVYqWYtlQR5/gr6gEUNCysCWNab5BqZgEWLpSRCsqpgTxvtk2vHEiG6blpvVRhjyLwx1vwv3cz53LhaLcx8hnDFd9e11rlOs9QM16adCKSQefo4SrDEfDNGEJ2RhWNbYF3r1pqgnZAtiNCm91W6yCZ0yZRAqWTgc4TxKQ8CBVyIKuPGHFgPUsug7uJ6VkwlcTIeMsmpFtRRXLJ1iHVjZT373pJIWfOSPqEkYd6433llHEdeCZJglBYoLSESuf8xjlhxJQrCWFjOyxrhHtX6yRgZk55WUxWAmaTJ/tkW4zONb+V7/N49Ir+rtSzj3kelZkQNxfDItWEbkqya8EfSlDVVs3yM7s1JJLWoui5cG3xHsqorNd/z/rT/me9gm274U9AVmX0BpWWuBcaNZ0cSVvsheZxro5Zbzs++zL5nKa8ki7znfznmNXmg947Pomo1r9D7wRJFvqZhRov+qtwAjca20CstwINq2wJ042xA4WM/lspV/z/qNakAmHVSa4KJucRJ1ZK6C0Gesc841TklgsKjQgOCIkJsdQ1F6NFtda7NukvhEphjQt8hrKusUKvAeCMMoWGv13CcFYat8zkiyZLUJKoKqswn56+uzQChEsvqbW9722XiHevdKpwi/Fi+YhSrnJ/Trpqsh/kwZlVBPS1ggvdayRhvheSM2WIPV5jV7Xfd5F5ZasbYM8uwMDZmfB2RVbNCc/391A49SsJKH1E2QFhrfKmZsukz5D/XHvNIf1kL6R5uUiRruhq3Wtetc5bWdsmXyiSVHoypcZ5zsP6npZR0bdW6b13QLPcBoWB943HFHEIy6hyaUZeDcdL9FzKBIkkXZmMXeeU7KnbSQqi1/sorr9xzu2V8XFdmCJac+Fvaq1u6c5OeKv7fOQX83hhUra28937MGFRDNqrra66TtM5KgCVIEpt0/QW66FcCap/MZGtyIImoLt7Mj2WO+Ns4cY6jejaquGBMJZRm1xa6zdJu17Pr3QzGHFq00xVXBaCu6+YuSC8evV4YE0MxKjKj+1TpsUSW7NKNW6u6VuqqwHjHO96xbJ9rpg09jV2jiWuAB1CjsR8g1KeV/qRCkprkZh2SCrSkpmCyKwFetzcFsjmCouCkIKTbHII1AkclW7Rbl665+ZxKvMTDG5fg/SZesm8IyLSPdo5CDxjntOylC7IEMJUN9Ry2H0sYQrhac5MrIbxfeOGFS+uq7tPG0lZSWZGJVlReJGir2T7nEltxHdqI2+T73//+PWKddTZpJ4SduUV45jsKw3lk5tW0otY5spYm48JRBdKjIKuANYGlsFpJ9ktYLV/D+NZ7ACFVl3iuqZXc77HemJt3vetde3HLKkYkeCMlhgRJi7i1cjPmepPYROM007sis2frHimB1tXUBGWM2wUXXLBUUNEmBW/vHa2REgiJCuezPBNjyHdS2WisobU06ZdCf2YtZw0zxrTJ8ZXwaIFM93tJXbr/OvbWPNbjwWzitXaptY91Y5VwqKhJAlXdezOLbpa9sd0mD/LekjDZj3QD1iU368Qa28uxSQ3lXSPDTXT7ps/s0ZZqylh9lB88QyyDRB+YD9bK1L6pB5NEVfC35bwYY8vVsF61bldkLL9JpDIzsJbUzNDM+0xyNwXDfnzecy+Zt6DROAw0cW00toBdC627gNr7JDcjy8gII3ffXY6BwqQCqrFfI2jJkawmMUKwgHgheFYih5BkcpRVmEu8ZDbHTWD5CQQU3Y1HZFxXXaxD1t9E4Mg5tPbjFJhzrIe6zuoiicDC3wiNEG+EHr571VVXrdWHTCBG/2uCHsZH68lUUihdGCXItJGD8ZAESy4QzBAQQa6FtOAoIHPtdJms3gyS1YwZniKrKgsYn8MQ1rZNWFlrrH+E6Ooaau1exgaLIAoN1xTrzPvd8iFpfeLINStBYR5YqygXIPq6mNP+TfcM2puurenizt8mA8vPTbTEWtE9lfcoZHRXZ62xzrVOutfwt6TVhG561kg4JeNpoTSrq5l/s90mPMoyLtajNXOy59HS5Tga4wh5NguzxDkJqq7uuqHaNt16M8Ow9Y6rpTSR9Uk5bE8STttnKRXm2TnOxEPGrmZ2eM/B747C5TRLdJmBOev+Ou+WSjKu03tAV2fuR/ZO9z5DaqauafyzccsJ/jbG3HrTvGe8dDvOg/FjXbOmVWL6jFcBbVmidXOwWHYniWp15a810huNXaOJa6OxBahxPEr3pTnkAyxJzjoktbr7ajnYNUZlaqZg7JuuWHUOEDrQjiOIV403gqI1WVeBsYPYjBIvIZhPxedNafAVjhCEdOPLOVEo5tyQVQRb3baJrWMO14mtNv7UDJBmGU2LCYI2LpMS/bn4JwXSmul6RNhHmXz5vsmRdOk1kRPjYRKdrH3Kb609a0kiXXu1FumymG7QIoXRFCq1UjEGEt0cf9rN9TgOi6wC+m6W6AT9RUBe5RFQYcIt7gHn3ENyxBgTm6kV1hhUrskc8j0/c94cN0sVSUYgYtxXtFWlSB7pXjt1jIiqbrvp7m4CIwmIFiUVKN6XlprhcxKPpWVWN2dJuOTSeEWtlYy7Lrr0UyuZ5Mz6tXe84x33YgI5n9ZkE+ZkoiHGTxdhLasqs1AyMWcQ1OquDcy8XZMSScC07Far4By8l1I56auu3SZVksibCE5XaNuZyfc8TxLeVcniNoEEeyoD7tTfzv/cs9FYU+bahHJaP1H8zZW1YgwknlkjXJnBNakyTUs6JNjnINdjj879SYWHxFYXY8+/rrdU5p6o2adXIbNR65rcaOwSTVwbjS0AEqFmVa2yQrDv62e70iwnSZWornLtFD6I05J6GMktFAzS7W+uXiYP7HT/nWrjVHZUs87O1WDdduIlBR+1+Onel+TThCQIgpaAQYiFdEKaV0F3X+YPoYL4TNYnY6CVJUvFELc6lVxH4VqhS8GXcZ0TgC2xQB9M0IPVsNbt5ZzMtWTVmC8Jq4IQVgTayWFm5FXrkvGt3gS6lkIIzQZcBTv66vXIJgvxWqe8y3EirAqTjDX9ND7XOFQtbNa5BFxPt3TnmjFmDq3rKJHjO96D6crK4X3J5xCtUZKvOSSBMBOvCg4+SzdKlSeuaSAhsRSXhJB1Y/kdx8g4RZOGAZUgrm/JlS663JMQCt2NXdtaNvmdSjAzDWfcqjGDIK1gWnmZL9ro9Z2LWopFeI391uU2QZ1JzczGbR1e3VFV9GixyxjbjG20PmkSVfdpjnViLZ2fSjJXEdF1S8VZJib3h6nnI+dVkaFSQmWILsG1pmu65dImLfasM+4LXeMF46zVWuWSuRoMPXFNmaRMaz/zgXfEqlro9fmQBHVVqTnXAOPgM8zn2EUXXbRss4mimrg2do0mrmsCoZGHumUdEGzYsBoNkMTDh+g6iWFWkVuPKQvn6AE89xBOKFykJfWwSGpaHdOaMoXMiGiCkzloXaxEc90arCPX4v0kXqIdPuQVwiVqSUzMoMkr5/Rv4/XmxsVMrAq0rD1INsJMjb8FrCesllhXFYYs82I2T4Vl4xZrIqAKx8Z4UiBhGoF7w3FR0Hbt0if2Vt3eENoUDjeBpS8QyFkHlg+y1qrkRmuapUkgJLoy810Ohb08tk1muQ8gQK4TM7Uab8q6sJyMY5Z1Z6sFG/JjwiWtpyZbUWhVsGYezFpr7COKB70IJEegunlbWiOzlYJ1SYSu7pbFkYAZ88fnWlMlbtaZ5NV6nloXs6SKsYCsSeOitaxqVdPipQKL79kn1h8HfcPjQdICJP+/9mu/tremjCulP5dccslePLZkNS2w9Ivvp6LAfbuSVPs8qvO9DnTX1bvEMlMQVGsmq0iljekirUXaZ5Axu4y5zwv3oZFV1T1GYulaW0VEt53kZ2RR1cqpIiz/Zj14z+T/GSfGzvCKEbhOza5ewW91DWdM2a8p65Xfl+C6bmkHc56eI+soopOkTpVjS8upChW9gHS7dy/J/cRYb7CLeWs0Kpq4zuAtb3nL4gUveMHiTW9601IIruAB8IAHPGDxfd/3fYv73Oc+c6dqnHIgHGXckG5Zc9CdbR1NqTFVusLpxqaQlRrekebUMiJJVA+TpAofiGb7XFWmRqJqCZRVQNDiXuX8iXVrsObcQLwgEjXxEsK88aUVltRRsFChoVCrFl33SudLIYa+TikpUsDK2EzHlPPSXqyyjEO1MDOWkFUsicb+phCuiyQKulVQuZLlNYCCzwj0WSWF5TAgR7oJcw9BDrSoIlDvh7A6DxA3iCrkOccj3d0Zc+NEGddMmpOoluBMlJKH9+gmB+e0NItkVcLKOuMz4i8zkYr3fsYr6vZd4+9y/SgI6xqsEA9hlwCatEgli0JpusF7f9YEOrXG5egwtk+LjdZCXo1V1aon+VRgt/SGQji/M/GSbTI7rfHQnEevBq1C3MNarQDX5X/GYBsbqnWM+4XzkCQs93l+B+EgsaPzYTuxRKWl2DUjCXW8as3QJKgecxiNMXOIwgeizT3PfJod3dJlCa6hosN6yNX1mN+avRhkfVRdxSV89Ie5NanQrjGydqpsYfyNfTakpJaEo/1m/aVPjAH7YD4rzGEwIqwm1GOd5b5fwfiYJZvr8F3WFPd3LRFlCTHWXT4XRuPp3CRBHeWdUCGU5W18XrkufA64x7jfjAiprvGuC8ariWtj17jO1b3KrgW0p9/zPd+zeNWrXrX8e26IfGB/8zd/8+JFL3rRqS6+jIUJSw4PxClLSuMvYYxRTS8/+mwEHy55rCMEmJTDB7GuboflqjwqU5MJLubanVr6TeJoLWlTrbb0E0FjVQ3WgyRe0kJh/FOWouBcCNbGrioM62qWRCKR8dJpZaqk0HIt3I9YV6vLMQIFRPV2t7vdUljnPLUkzqo1ZbZQ1pBZRxV+Vv3OWD3JoGTCseHg3IyBZHK/hNUsuZAIyXvNhAq0OjEeXDOtXR7pap/JiVY9LkdkdqofuuZq0UqLqATMa0pQ09KhGyzgVYtIJsIxFs9MrZJAk1E5RxIo7j3XiP2RbEmImB/OpSdIHmBEpp1r3SVV7OU481kdP0uDSOT5vwmFIEW6LPs/zmmcu4SPz9JzRauQr1pXJbkSHAmsUEkkueb63HOve93rlvd4kg7aDmF0rx3VP03X+7S21vU0OrTg0m6ex6xlSSrKH65vOy0FlJAQsf7Y6zKHQM6LyjLHOMtFqQjdZi3uunaTiE654vocsxSSx1wCIhNIedAnwzEYk1rWZkRYDf1QITm1j6rggawyhj6rWDuMvfHkKgu4jgq80TPaeUiimnuMXli19qpu8ZkB3L+TpNZ+ONZ6aFnWyBrKP/uzP3sNV3leb3WrWy2e8pSnbDj7jcZ6aOI6IK1YT9GiViHFJDUjjSUbzvnnn7+00p5W8trEdTcwC6aaz4zxrG5U9aEyKvuxLiHdhqvyNsrUZEzcpuOG8HiQGqwJ5gACWF1za+KlmljJa2s1Yg8xkYoxomqks66eQrFueBm7lkRrBJNNYVFknM3y6WHWVISgtKauyiaZiVR0+2Qdzrly/9RP/dRSCMsSFyQy+q7v+q49V2APrs+4sC4UfHXXRQgyI+a61krOByFCcGIdjJKRSLhUPKwbY1chYU9F0jrZOU3q4/iYQEXhWrLEvcsYpFurr2kBk7xwTsmUZVV0+eQczD1khjE1GyjfY40b5+neo2A6GhfjlTm4bgq5o1ctXZlpOONPMzlNZi7VTd2su2av1Z1Za7TWIJMDqZxw3dqGtF6qMPL+kPglkTQRl9lwba/u+pa+gmxIcGgrn9ke1z/tQHgXWk6rK/AUKfUVGEuK1dSM1hBUDtY159Tt2OeHyhDvEa9PO1l7JqFyn9Gan1ZuFYhJVtMdeE4R6PiuQzrz702Ule5LHnNKUUm+R+Y14HfM4Yiwcg9lQiTzEhjqMdqjDTuw3BPn13vHLN0cWeaMtclz5rzzztuLEbXGdLWkGk+sUijJqW6+xqJnrW1j/L1Pc+9yLvTESIKaCuW0qhsX+4xnPGPp4uw9RzubuDZ2iXYVLnjkIx+5uOKKK/YeGl//9V+/eOxjH7u4973vvdzEBBvQW9/61sWLX/zixWte85rlZ5DdRz3qUYtf/uVf3umkNU421Ham1au6oyI8VfBQUYCQUGo5qNbcdaxD+3FVruRWlyzj6uascHNlajYBwhgPfYjbfmuwbpp4iT5yTa2qCue6ommB4b2COIKmghjzZp8lsBn7ZlvnrJ8mm2Hv4WDNWHZCod5MrlyPtkFs51CTqNBe444zQcyoLal557uMo9Yd2klhetuVCZ0k8WZNhcQjtPFdyMEqGCdngqU5sspYIHiu62pe+5iEgrmzVIlHxoUpJGbyI4mplq90I5Q4GYfLHEhiVRyZpVVSKvniOpYI0s1XxRVKFp5V1QqTru/GGNMWy8Ro9VWgZW4lKP52an1mnL3ZgkVNrMQ4sm6ZGxPSeD9xHq4r4dIN3ntNS3ASea1/zoFj5aGg7ZzUtcL3GX/WoFl/GVss9+wL9p3PvIauk6M4VPdkLcjunWbizbI1uV79HnPHHHowP4xTJitiLb3nPe+5hlv1CHpp+Bu+K0m1H6515oT9Q4LCvDD/kjD3rnWI6C7CUJKoTtUJFnoaSFRHyfMYBxQQ1rCeIqysZ541GctZoYJSxRFtxQXYJEvOjy7ZtD/zNqCM8FnjoQJLUsr1aYdzp2dD7j1m286M4V47n+F6YFnfWqutSboyaVO6HBuPTh+81zM0R6VHo7FLNHENkGThV3/1V/esDrhAPPShDx0OHA8T/sfxyle+ckl4uZH5Ped50IMetNOJa5wM8OCoNTbXSVqC0JAPMTM3Hqar8kgAUtjRmlKFVJACjEKPBeVNOrSpddX+QGwOWoN13cRLtBPtOgKIdVUVoBUc1GKzZ5gIJgUKXcSMTZ2yaiUUxrVC8TsEBdxfs/ambpQKuxBlEyONhDqzUaaLH9BCPlIEJCTfFrBHkEJZh3DPb3Md6AKZZWq8nn2UsK5TQqiSVa3cWrmME2b8EfZxn0QgXCfmcs4dcwpp0chXS4G4TkzSQruzLIklUUx0xHcQOhW0FbpdNxIJ3fu0gqzjEs/cfvjDH96r/WnpH92zscCaqIrPMsmSRLFCATbrBjsHKrMcI9rtvan7YybnMsO2wreHSXE4L/+zpqnELxMCSVJNGOTYqiDhfFqibSNt0V2cGMNLL710uZ4ZD8Yqs+janiSr7mPVSiqB1Xqp0K9l2Laz9k3yw7xxsH6r1VHSovV6VOqpKiN97/dNEpQkhjawz+kGK0k1s7AZow+r/FMF/UiL6tzepFI0LapT7V5FWDkYM5QVNeN7uuLyKlE1Hpx1o+dUba+Ej/aRrZwxZs4J5dDTQIuuBNU91T3F+0QvgHTz9TnkulSG0MtAMqyiR4uwz5nqrWXWbRO8GS4xh07O1DgMNHENvPzlL997/8IXvnCStFYY3wp5Bf/1v/7XJq5nEMbyJVFdx5XQ4uWZOGk/xK4iMyTOIS0EI3JrrUuOVS5ZtFtLTSaAMsZtP67KQCvjQWqwZn85F2Qi54f2aPUisQp9tXRLCjiZ+TKtpxJb487WcVM2XikP5wvhB8Ih6UjFgbGgF1xwwfA6umwlSdW1VIsqgtkUMQGWNrGPfFfX5AyXqLHXurgxN2nRkRCixEBYVpM/degKDmFHeNLawW+FBECLxSbrYBVSWEyFRQqUQsurZI1X2o6iwURcjKVZbCWHSWx0/+VI91j+1rXT8jUK5fyNAMyaYw1m/VWzKHPwXm8IyQnnoK2jJEsjaMGx/64P5jProKpM4ZwI5oA1RzsUuvXOSNdFYdZa1pBttuawFnvWgN+RiLLGjb8F7FcSXpV4kmOULXhMUSbK2PBMiuQ8ShBTmZFWxhrba+Zjrsnvtfzjrs36xNWXV/6eUkRa/ieJal1vEk9Jk14bKpVce/7WMCfWC4SFPROCpseEXjBHkbBPMAdJVFd571SL6iqCPUdYWTOMEWNOHeMkjBkvyjUYQ2u4JsGuFln3QctIsYYhqSo1TBKFYnSkIM7s0ypOvFdcfybFyrJU6W2gl4hWdI8qX+hunnHR1i/Wi8D1nZ8Zc+44qlhqNHaJJq4B4lMBsWGPeMQjNhrIhz/84Yt//a//9VJz63kOAwTA/+iP/uje32984xsX97///Q/t+o2/2PTR1m9CUpOoboOkHgQSSB+CSW508zNmFEE0426NLeMBnclTtuGqnBlSQT6sEVCxMOpCp7AsyZoCwiwWFTXmusRmrNeo3WrZM4mMQozCoMdIINWVLN2vRjVyGevLL798edDOtNDrCcL+BDFOlywF01GyFBUPCoRzmZzNqql7L0RIa49JckbE22v6W61Zee51ki5xTQRLas9aGkZIEBhLBM1tkFUT0VRyOlWn1nqcqUTQFVNLuQI459aibNIhCEu6XdoG7ymFdWM5GQcUPsZ8GudOnyVprOEks3yPtYOra86ZWYq1uJgtV0ulVhrvI8lbuuhK3GiPyiz2CvcQLVDuHSZ78Vy6MdZ1xPqBTHv/6Fbs3sgr/+ee15KqW6Kkm+tAQq2pze8hb6wjPtfinDVPbYfr3XE2A7Bz5Pua3E4rrm10XiGFhBnRtrq/m8hH0pUZcF1XEmKVDMZ/ZvZh28x7y3+h4DERXL0/3b91PdYN/ahgVmb3pamyMRma4JhtEqcuYWUt5N5nsjjmR8Vg9aLgO1qiMzkT59FbgDWtEsF2mdBOa7nXZV1adovPdD/Xk0KrpoqUVFBoNXUf1APBQ4Wx97PeTSqmTSSVpcfc1yWpc3APy+dYKpf1NGo0do0mrgEebmw697jHPfY1mPwO4joqnbMLvPe971085znPOZRrNaaRWvcp10yJ6lGT1IOWqbGkRiZrmBIg9uuqzEPUmskJvm+GVB7KIysuSGut7xEOEOYlcMaq8pBHMFQgyTg/+prtU+kgEdG1UpfL0cN9SsMNEBSsj8eeQYILrWMpREjUtNQoiGZsahJg2msCFsvkTMH26d7I+NiGkceAZEHrFu2BZFujknXEeYzR5ry0HcIxJSSb3XREVvO6XAuyCiHe1MI+EkpNAjTVpiSoklQTBhlvqqWDv+m7sccKmMav0m6tzK6rUVIjxou1gJXZuGHnQI8A1z//45lVE6OhbMhMuibrQtkhedH6xrhKmFkr3lO6OmZSOL0vTPxjTC2CuARXkq0CyyRMrmcJroSTtqDMkOAzfqxB5tffGINqlmEFepNNGUvImEneWE9m+vW6o31K65FKuCSFtjWz6XrvM6+saY53v/vdyzWrpZzfMd/f+I3fuEcOGANJiB4auvBmvPgo7t/fpKVL0mfohImC9LQwmQ/jZtZh1up+E5NtA8Z6r0tUJYwS1U0SN00RVuNATdiVbv2uN+NjTeSWCfN8PqqYcl70JNDjiPuK9ZgJkdwXIMkoulXqOKeZeTqv6VrXmsk6s1JAWlczT4J9ArrKZ6jLKpKqtTgTMa2j5OgiJY3DQBPXgELMOjFXI/i7w9A6sTn943/8j5cbL5rAdZKaNHYHHiQ8IJKo7ncdHQYOo0zNpq7KCOoQFwutK1QDBZh1rq1Qp+siAgQCfj7MObe1Go1x5WFtP81sa8KKvC7jgUBoXFgS1DlXKRPYSAoRWi1HYdyh0LqK0Ek8lO7QI+UH7XQuzSg6BTNGKpzr/mu7qnuelgOFYK01/G35CUiOWWqz/VrFRwIP85qW1ZHLcpJVE5fMYSrudM7lUNJWSWoKi1oztEbW+TVDKMi4WubPhD+sSRQnNZunMGZYsqrVTri+FLR1UzfOmrnTVVGCZFkXst3rWmt9TYRnfzNKECf0uNDLQKuPwjD9zvhTYGwoYO5V7HCYlAkiJQGnPSREZC2kZRlI6NJNk+/QfhQ9KIpZP45b1j01SVDGnzo3khbvuaw/aSy6CWuYP9rMWqbdvPK394XZyFN5xLolQ2zGZ2v5HYU8qKQzTt58AJJqlQbsa+wV9F+ySvv4jfsPa5D7hftGa+1RgH4nUZ3bl7ZBVCX2KnTY183yzmH5JxV1WSaLMcowHe+N3LenvFVU5nlfECdtxmnDKFTwMHeZyCr3klSUqCxxLJKgzo1LKpe8d2ub8z7wfWaSV4GS1v25w5jgKeVQo7FtNHENcAMi5L7//e/f12D6uxQ4doXnPe95i3e9612L29zmNouHPexhi2c+85k7v2ZjGpQmOM7IMjW68e2qTM2mQEDIGqwQpKmEMwpyWSfSmBxJuGTKEgcK+grDWjX4jfF9liAwgcZIMEH4R3CFjCSRGZUMyhI0mcBGN2ysQvQ5rdsmeEIo5r7GJXgq2ZSuZfZ5StMt8ZTIaIUw+2TNyJvlcBgTxt7xQRDlegiE6YKaSg8tAowVtQgT9J/fQpSnyKpu4FNktcad5utcRuaMVcv4xXS3o8/WWqzCoX1V6ORgDBGIjT/LsjZm6jVubApZz9b1mTGblvDRLc+6uKwfrbKMI2tdgkkbWJ+MH/3hHrD0RpI7LYfZX0mn7rxJ4FW2mGRISy7nYDzpp1YlP5foQlKZV9rDuSWerIV0bdVNl/XG93U9h6CydiB9Knpq/J1tcr0nSZUoGIue6zeTPdFW4lBZu4xfJvqSnFQPiury7xhCZrk3c50zDpBJiZBu1unxwVxaJ11yoTLO73NN9kZjKLlHaS/PIffPwwZtT9df+z2KjeRVq7AHyDCVdUtieTCmjB37m541zrP7GeOpxTHvfeA+4nrw2VIVTbY/M/tzPa7Nq8oQvW+yvJLwtypGTMjm+lIJMZU0TsVjlrxxT9OCb03mTBpmmzJJX7of72fO9dZx/12lqG40DoomroG73OUuywfpO9/5zqUb7p3vfOe1B/Liiy9eln/gJt7kd/sBbXza0562fP+f/tN/Wsa1NhoJrWkS1ep+mjCWSrJ6GA+e/dZgHSXAMkbQTKUI9JZJkdBIgnVzNrbP+E8EYTXe6f5p/cp0sUvLbXXNksSYvCYTqCCQQSDMomryDMabviIsm22y9jst5FleYQQF63T/VUgeWdYUIOmjMZhaDhUiIQsjYigZNmGU7pvMLVY0rgVJYZ6nXDclqwjeZkbme8yjllAT6+iel7/Pv02SlHUpJSVaLOjblDJEcjuKKTTJD2tFS2MdR8Zvyo05LSqpSOJvyJFzrvs6cyJR18rGdbVccX1j87TU0Qb6xqvu/8awVYu+hE7XW70crOGoBd5EOXopSNS8B/m/45txb5ZX4ZXfM/8QUF2SWSO6ULqeFfL5P9+lfypmnCNJt69ajHTVFd5/ZkflnHXt0x/WHEnObnvb2y6t05YDkUSMLJbG82UpsAwzYBxQLkzdn5JL4xyZV120jSk24ZWu12Znt13ME+uGg31NK2LOc93zM6Y3k1ElARz9XUlnluXxsM01kY/Qim37Jbqj9s39nQmMdNHVZTrXuUo0DuNIVULq6i+pc9x8pnhvOxb213WuAsnfm0BJ5UmWF9LNNhMlJUGtmeZHz2nXsGvNWPE5WFarJv7Tk8nsx1PrYxTWU0N++B6hInr8cW6Ujo3GLtHEtWQH/u///b8vb0aSM73hDW+4RoKRKaBpIzmT7obrZiPeLx7/+McvN8rv/M7vXNzvfvdr4tpYwjg1rXBzZXcQeiSqhxn3tEkN1lobMkmqfbW8h4ktrCenS6zlUXiYIjQoMEkyESzI9KgFhQez5JXfp8Dsg1s3Sc9hoqcKBVCT2CiApsspgjMWHoVPyYiWAQWVOSFFqwG/MTskgoQZKasbuFYpx8estAg1KjvIZDwX/6llT4KebqKSO7K2jghexpFBWLUM0GZLs6xCElTbqRUlY5s5r1mgsw6mArbkxmy9meCrEmTGM8tj+LmEVfLAXKWbcboEMra4xLJua7uM31YRorKjWu0yMYzXZi4ViiVQ/B4BOd1Nq+ApMWKNse6Mt9UarUJDZYiKHr5n/FsmhNFyxN+MlyVFXMNa49ybnA/WLq8oK7T0OncSFcmQiZJy3TufwDmV8Ktk0hIOAUQxhoL5jne845K40gdL72TcsTGK6eGRCZzoF4pkFDO5bmnXBz7wgb2SKZ47rWTuQ97nJqrTU4PPM3OxLunGBnM+xpdDl9e5DLAjMrkJUkE3yrZekbWFtQxLNke5CUbQS0ClknHXPh+4j1SAZP+8tqEq1qflfVoggQoeS7ulIiut+P42YV+YS/d17hmeN+xt6eZbwwwk7iPyrieJz5mpZ8w6yZNy/lQu1DrTuTekd9I6SPf8jnFtHAaauAa+4zu+Y/GMZzxjmewBawEPNTIF87nJRhI8kKn1+vSnP3350GdTutWtbrV49KMfvbMJ+/mf//nFq1/96uVG/GM/9mM7u07j+MNkF5LVOXKjpemoyh4Y0zhVg5X7y9giyzhkLUjJYrqAZTkaS08g0JnpE+HUcjH0X6GQ72YdU8B4cE9BAtI91bIiHggZuliqfc/yOFrI0trFZ55TNz/aBKG2riVtQ2j3OiMXXl1IFaQkWZLbdJvN32a5JV0wjZ2STBhbPIUUgEFa5TNBicl46ANW2qxbqgurrse62VWtf103kgWvbWKVdANNUqql1WtKTLV2KtCN7gEtDfm3ShKJrnOvhZpXhV2zgqYwaBZP+llJvJYZCSf3h+NXvSTor4K/iic+Y3yYXxPHVMFcS7SEI5OTGXuo4F+zdxvH6vWzvJLjzm8dS+bcxDuuWZOj8YyUSJph2Hs14+G5ju687mnGqqalWKWS3hEmhFJZo1KI+5p9wfhaYk9RFDnX7CnsTVPxx0KiqiJN5YLtdL2pQJLcOsYS8FRGOeaZJdg50CorKa11nTncT7RkbnNft71JrOeIiVZFSd6oxm11d81Xibv3u/dK1v42dwGKAtZw3uO63FoPV2VctWaqqPEeUImQ1mQ9D6rFPfdh1gBtN6QhE3Zt4np70ORJklXGKa3+ujlXa+lByaVz5pzYhqkklY3GttHENQfjutddvPSlL1088IEPXG4iPBie9KQnLZ785CcvBWDiR9jMrI+HRjU1vfyP30/VZzsoeMD+03/6T5fvf+RHfmQpNG0LxtTMYc6C19g9Mv5HUjQF1mC6/x5VoigelFhXMyGJgoMZGOmHyVWSfGnlkAzxXiGVtc9D0uQy9BFBD4EFoRThFIHV5BxmewUpyPA7Y+8UQo23nSq4niUAgIKjQjOCPveqbrO6NJqp0oQ9aY2dSo6T18yESrpCZwKQ/K5Jbexflhrhd1q8p4QYCQJId9tK6HTBZP5ScPe7jIFxmgiU/J1JUTxXxp1aPsVyKBJcyaEkwetlUh0zv9bY47xm9llXbl99z3e4x7IOawp+1qCVQIyg9Zs1WgkR18gYcoml97SxoZlgKK1Kzr33t2ta8qOSRrdcBXSF9NF6sZSNwqcWrjyvcaySWNuo8kLFgC7qrFPWmu6+qXwxEY4u7fbfElBpKQT+zt9k3LZzbMkfy8yoZNLzgmsypyqaXesj93Oto2n5SjKuVVdFiQTMebdOdCYNsy9ap9OjI0mAlmSVTYY1uC9V6OLqnJjZthLFVACkC7yfJVHlvd4ndYySKHKogKt7yOjvzOTrnEtSM5aT86k0MiZfF1n+x36iMoo512tF19tMwMRv3KcM1TCLt0o4vUBUCvqs4TD+nbEwOVhm/1VJUrNC1zFQuZVzaRJA42BH3k/pgq/CMpV6qXTJ0nbrzEf9LMtipaXY8VQR5rXf/OY37+Vq2JXs22gkepUV3P3ud1+89rWvXTzqUY9aao99sJB4qSZtSgGITfNlL3vZ4m53u9tiV/gX/+JfLIXqe9/73ovv+Z7v2eq52XQbJ7dMTSZkMIbmKIFAYgKi1CZrZdHayf/TQighkpzQLwUTBQUtQXzXmFD6y8Od+5BxQEBBsTTKZGnsqmSTsTXr8CoocKfVCYGIvcJSHkmkEKRoO/GrXDPduS3vw3nSYitRTBKC4C/BNQmP0Oqie5jWVLMh831cf6sFL60HzokCebpdmr1Wa5MEUusRxCyVKLYHjxWT9AjXQloBMiZNi8cIulmna6oCH++TWOsyXOuTSnAc31qOxsRBSVglzsYiu3ZHZNhzGq9oZlCthCbfYk1ojTOusZ5P1z/mnfWs8kb3U9pSs1Vbq1GlS+4XtlFh3cQsrhuJmvGa/i/Jo9lO0+XVOFfjqDmM/9NCrXVYC2sK3hlXmFZ9x8C58/5XIZdJZfhuJkij7/SPsea+0ytj6h6XjHn/uSZss+tJl13dqiU9ksS891UyaD3N0lO6aPP7qgCw5BGH18wD6NKfZVmqRVNPFq9doRIs5865GoH/SVTXTdpXvTD0WqmW1SRekjsVNXq26LFhX+kTxgRCPXSJzxwIJgzj3qlJltzXXE8qL40/ZtwyY7yJvfCK4bxaw7W4ss9NxaXanpEiVOVm7odpzUxF2lzNc/s0h7yX8p4S7r8ZTmBoxJyVNj0H5hLkNRrbQhPXAe573/su62z9h//wHxYvfOELl8L11I3Lg5GyNE984hN3ms0PrdaLXvSi5eZEQqbDiklsHC42TcKznzI1u2x7ljixNIsPZMuKgFFSCK2TJpTIEgBqvVn3CAIZb8T3LbuCQAlJq/er19d1DFK96iGbMX4eNYukGU6TuFl3EgsPr5wHwYlrjvYRyTnXygRQuiBqiZScK6Qb46fwa9+05GrxmYIadcfH9qUFVDdtk+1oBZFsKJCaJVRrkfGe7J1JChXK1oHtS4Ka8WIphNW1b/Ic+2HJp6l9vFpY55IuVauEB2No7KkZXgX3KFZn5knLj7FtWsdth4IqbSHzrlmxVeSYAduMwunuCxTGPZ+1Z00Ooxul4+haSxfsBG1jXo1d5t7mPjdbMddPi15NOGMbjGO19FONF00FgNZH7h/rBZNcTYsX53DdJbguJMJMzFU5U49MyKWSy/8lsrRIuvG6pqr1n3YQNqRiit/oVZGu/rnW6afeGOuC6xl7zZGu6CqJmC/LEpkYbK68i9Aq7DHntZOKLfcfFTJJTkceLKlEyqzYQKUY60oFpdm2aZOZhJ1DFV+pQMnrZNI9lJxm3k532xFY53ilpVKN8SSW1TFNcu441LjRGkagQiyVjnXtrePamzWbM05/ak+URG/Di06lT7sKNw4LTVwnwGb27/7dv1seZE276KKLlg9rS2jwcCQLMZkIdw02GsgxGxiuy7e//e23fg00iatw17vedSmINrYHH7LHsUzNHHThtXwMD3UOBA0TaKQQrcVUwdbEK36vFlM3M6NJZ1j7uhNnvKjurxIkkHGmZpZUIz/lXq0GP0lqFSC5NkTVMjsIZ7ZfC4cJdqw3OVVfOR/2Cr4mCFHwSYFF4u5hIh7eZ6wz/daCM7Li2qcsI1TLyijs6QKNMG18sQKhro1aJLROGc+pRSgxJRRmWQhdIyVL1SLg/Ep6MovzfmCMLQoPzuP6ZE1ZDxOBOUlqFSxVSqiMsZ+017hp14Juw0nmU8DWwk573AtMoqTVTzdv3aUzoUwSP+87BHSeV2YETkuvZC09NGi3FieTSVl/lHblumSMdNtnzl0b7gFJ7GqGVqEyg3Ph+WNYDu8liLSDfuuSznetUcragdTifUFfdXlOa5VW4yzXwnu/I6l3TXjo1un8S7j5va68HHrDuMeZAVirJm3W3dOQD35PP/ielkTbVtfoKtA+xkAPHee2Hia3cq/S5d1z6KlhuS8JZbrDu/dnfgXX8BQ5zbXl/u6a4HdJKnnPOdlv/I1Z492nWIcJ93YzaFeX9CwtZR6D3E9qkiTH3D0//6cnDW346Ec/uvfbmuSo7km6rbvXqTiaaoN9z30n3XZtJ++9vvfeQQhpDaWo1/fV91keqg0qjcNAE9c1ADk9DII6hR/+4R9euj2i3fs3/+bf7OQaCGircFSFzE8TjnuZmhF03bLepNYiHuojTT9QQ47ArGunD1xJTsZy5e/oK4KBWXYhxPlAV0DkYamAXwuu+/upMatEMAW4hNZViKoZUmlLugRm8iOJwUgBYSyZfdCVTaKawrxZkT1vWtYVVHRRnlo/nMNyJMav6cJqrKPtyiQfCpa0x6zNuqPyG2ud2hYUe6nhT8FKGBOZbswKcLUkhRYa4ym3gYyPVODSjZA2QJScH9qGtVyr5Qi0lXGBTNWMvxy6xvJ/Qky0PKWLtetYN1FLo/Ab14RxhioijEtOd1rJm4lhaDvCea59ySrrxRhJLWrpDs3a4Pq/9Vu/tZfhWdLna1oxAWPo2siSNVphJaspUEtUaSftxTqJ95LrkP5yPciyZXk4N/c0ihTaq8WLuRu5t0o8JYPVQmtSrUz+ZTZvlXLCvYF20WYVaxmX7TW1vtVyOCo2dEf1/nFf3QZsu8nATGRXE7axn7n2GE9Ir67X/l6CLdn3vXOxilBn5me9JoC5ALzfTKrFGDDfacF33FVoaVl1rCXKzIEKSq3Wrm+fBa7XkXJA5DmNz9aSnIrQVQRNL5r0GEnFncTWBIMqUCok5NVKe1BkrHYmY6vvp/qZ5XAyU7hxwo3GLtHE9ZgDwvrMZz5z+f75z3/+NTKhNk5XmRoeEjx4j6JMjdDd0aQzErXMdKhAw/fUrqtNps0IosR00pd0CZxSfOgSiHBhn82ym5r+TEyicKhAJuFAo65AKIzf9JAozIHzWrbHbKiSBl1eJRRap0ZIMqylQrKabmyMTRah51WlBdfRwoHVbi7OWQHPuFm+zx5incEqwDJnjL0ZOG2z7sBaYSTiSWq93nve8569mGPdRTnnbW5zmz0LA+Ntxst0z6xW2U1RY1mry5xHWihYU7oXpjDJGED85ggr44ACg99nBmHvA4VzMtOriNAKrdt1lpDhb8ki52UcU6BPguSacz2bQdU4zhrHKCFQqcPvEOrpI59xf5FkUJd396ZaPgUoWGeCsKxfmsmyJCx6VegZwb1JW7GkQv5UxJhIyGRHjIfWaS2ZKrpUhmGV5Tw5f1NENZN9jTLWOm7GX1ZiYA1b26jSwftfl9V0Ba17vERbd91twftURUdelzHzmpaPylhl20F7sRyiYEnrdMYuziFd513bmdHXrLkmCLO97ke68zum6UmkkksylYpOY73r54416yvj62vpl5ptV6WSHhR6D6hgmlOEJjlX8ZJE0HFKuB8al7uN+NBVrvEZN7sJMsY2a+jyt4or0MaNxmGgiesxB3G2bA5opNncXv7yl1/rO+973/v23v/6r//6njvvN33TNzXRPQKclDI1PnQkZpaamSLWWm10c1No03KC9YO/FT6TlGS/tCSPBDmuzfrVHZJr8Z62KRQk+K2k12QbGZdqmYJ1oHUVTTtHWidNKGR8G/3VTTl/X7NZZimdLHEj0batOZb00VhnrF5zrnd81/VDWxgrhFCzDtcYV8mmxFghi7+NxTWujHWhgK8gxhrQVTldDBUcU3hUaJ1b/1OQpK0ipOvGdVfCmpCwWh7IezYP5o91yTkqsVEgVOlT63Man8wY6xJobKjWMC2UuqNqPdKN1cRrJvuS9FUXew7Op/uzVn3rfdIHSKEWtbTe1vGSPGfSFqCgne6QWphoD+2DSEMysYaS4VsrKf3Rwud9yT3HOqd9tM0axELrPue17+5VQJIlMaskNbOt6kbPeRhz7/esK6tFUYuksckZPwj4jmtFxZz7E2sKt2UT/cwpQ6YwUlqa4C5d9t1P8xoSGO91PRtUFnEf6P6ttXyqvI33PnA9un/nnqWCin1TDxVeaWfWw1XBpYdK3R/0FEEByquZgiW9leC5ftOTwzlJl/Vcq5mozTWiCzL3TsaSc05zFWQ2ZROE6a3j3m8sac32u985n1PSpSeJr/uFzy2fd5n5WcWCCmrDRFSoScL13Gg0dokmrgVPfepTlzcjmyZlcNYFNVXZqNnkqOu6LShkkXDmEY94xMrv/9AP/dDee7T+baHdPY57mRoJlARVS+pcO4UPecDDCSuHiV0UVFljuhlOlQYxYY/CTiUcPNyxALHOEUhpqy7Ias99qBsbZhxZklTjZzeB1lUEZok8rz6wjS2G3CiE+pDXdVJIcrLUgePIWElWk4zoski/ESTXiXN2DphPyMh73/vevVqjFRnThsCuZds4XkmZRN14Tz0AFEx0WdaSxvWM1V034dJUYqP697YUOIwH/bHEUQqUlkmhb6y7kYDJXCh859hKNGmnro+ZDKqSPq4v0bKvaXlWOcF4kyVVK7gEwayntcyJQrmJpbTcZvIk10UqVRJaJTM7bZZIyVhAlSG6TNImFFZYQDO7aiYLA8ah0g/HTG8GlSW6y/K9LBFC/72vjbnVDdYxz3qo7k2WMKFNEk++z2/Za8zgmjHC/O19PsrEm2VAjLXlSNdT5pZzkOTxoOtYC6BHKrFGmeMlFe7Z9BVruhb/tLryXci1YQAZrpAx/8bts/fzfcbGkA9jalE8GP9fa9RWJWPW1FYR6DMRRQfeOsYbs365d1gn1VLK+GdeAhPT1eea90vW0NX7IceZ9UebaY/eDsiBrFmTJ9H2JKZm155CtSCvyvY72g+zBNSm8Bk1ijFPy7evKgYydt4jk/al944Zz+1Lo7FrNHENYK181rOetdwgnv3sZ280kPzmuc997vL17//9v78sWdM4G2BTv/LKK4f/O+wyNVlbU/Kn1XAV1DJrJaDdPJxrPJAPauMmp87N7yWrKQTqaii5Q9hBkMw4Kr6jJVfhj/MgSOjOqUVqP0jrKsIRbUBAMsmIMXgILVqPEFp44CvgSwCyzEMKllozk1RLOnnAW2eTa09Ba4qld8z+i/tvJoeq0F3OhCRmN3W87D8kwEQoCCAK71qO+J6CpfFMWd8xraxaeSTKzNXIQrALVEsbbZTE6cbpfDEXkpmpZDJaRVMgs4SLsV9aWBXUGRstE+kuatIZ1hDQNZjvpMUcoZ12OX7Mn9nCJWipGKKPEG4OrVvc9/YzlSpJPtPSaoZqE6xkHLYkQUGf9YPnD8QSl18sqZBWQwLMCJ6gX3zfBGusM/YlM46rLJFYa4XT3RToIs93M4FYkjBgqR0PlQN6fyi8azmTAHFd96kaZmB2Y66joM5vq8LRsj8c/D/vtU3gOvKo1shc5463pIa+aGV3jFZZv+gHc3Tuuedeowaq/U0rNGuM51xaTzOr+NT5LcuTZb9UJDgXJttSicS+7LpIqEybUoACrYYqHl0nXktSbty4Vlbby5iyZ6KIyXne1HskEytNkdEpJV2SR12Yk3hWIjr3Wd4vqShbxzJaa+6qsMs9JkMLDBdoNHaJJq6BV77ylctXNsNHP/rRGw0k33/KU56yvGlf8YpXbI24/tRP/dTymMO//bf/dpn9GLzxjW9c3P/+99/KtRvrQUFF97bDKFOjQGlWX119a+zkFCRmCAsckjPLY2gNMSOo5My4qZH7refUQqoQy4PSOJjMmMt1IG0IpSb9AIwlhFWLE1p+tP3bSPrANRCKsBDoLqf7pwINY5G1/LSc6T6YZQ+yTixjZ8kGXZTTjVfrCa68q+JUFWhol1amJPUjGEcIsa/JeQTXZV5NAKQFXpKjO7Aunca3Qur5v/0Z1XfMpCW0hXZsCxK3qUMCr+UfElcJqeuqKo/sN3OkMsE6oKwH1qulZywlkklwMl5S67O1So3b9LyWU2FNS264Xyz1okU+65HaL+aNdYsnjZl+cx0pULpeU0mhcGkM8kiRoLufGXBRPOgmyVyqfGKNQ3T42/h3lRaAa3AP0Se+Q9+JpVUxwprjnteCqPule48JafhNzXCqdQ1I2iSqxlE7n9yb3OtYAlUueD69NnQ/NuY4FU1apVhP6TkhVEZwz+3HHd75TaIqOR7F5Ko0SbLj+K8qe6XyhH4xn+797lOuHdc1c8R6ZeycqyQwqaxMZYFeJewdKGG0sOY+w8Gzythn2sG1UF5O7W/5TM2YUV1THSMty3lfaFWXePlb3psdmnboSm6SsDlkzG31FMmauyOiyVo08dwU8dyU/EnWK0ldl6B6DsdJ63QmWXPf8G/dlLlfGHfDOzqzcGPXaOIaePvb3758vd3tbrd86G4CHl6UqaH+69ve9rbtzlLj2IOHHZv+tsvU+KCTLJmBMsuYzCFd+nStRahI11vBwwfhwSyyEiWuo7titTRYRkL3U0mucWo1Wy7gYYrgrQsbYMwQdCCotNGyBbrlHgRmJ0XgN84vrZUSbuM+tbxIMmhvuv8qCPg7hWmtC8aOKhhxzbk41UyYwbmZa4Q8hdkkx8L4O8YMgrFK2KKvjAHzwvm0xqcgz3tjFGmPrt/WMU2SQ1+tO0kbprJ07sdaOjpWCV9zhJX5YIwsa5OJaSQJzBFESYLDPBuHqpXI+9A1rXUmy0Nwr3lOrZmsZRUe2Q9jQFnvOXf2BWLqeuW+9LoSU91nU+B1PGvMYrojJqG1xqvrCAsq7TU21t9K+rG4ZrbfBOfhucn3HFNdpA1V0OWTMZM02V7dkkfr3e+rYDPWld+7diWq7C1Y7SzNlRm0DdWQqJoFnDbRfhWB/M5kO7n/8JmKPhUgm+z3upVD1LjOKJ4616+EQULk+huNj+tPMp97mR4f3sPGKZs/oNZddZ1KpLXAmpRLJYjeB7p06w7Os4bPmQ8Jq5Cw0h7ONVLkmavAeGnnWSuvSiPJ/qpsu+7NehYYI02bJYquLfqUSp5MluY8uGYdk7z/domM554iqNlOY5v9zLXsvuW86v7rM8B7TbgGsu6395XKuqlQhEZj22jiGrjqqquWNx7EdT+48MILF5dccsnyPI2zBesN7hdqu3XL08pjbc5qMRhBgUUtdgpYc+SPB7jWx5r0g3NgHUprSibmsFSOCV/miDT9QEjhOsaiSfyw6CAw65p7UJdSLYtcTzKe5Ye0bGpVMwmIhCatw5k5ORMqKfgqCANLrEzFPSkA6FKb1kQ18SMXQUvVcH1IKmOlq+4cdJllLCSsWv4yAQ99YAxoC4RNF2E+y9hiE1NtkmxmXWvpfmGGa2AWZq3frCsTu6joUdjlb+bKhEreB5ItxkBXOV3gzJzqupV8ee9Z11BLfSa5Uhjnt8TxMY4mY2KOuK5k1YQ5GcMpUbaOrZ+nu3Yia1lKMjggF6wfXnGH5J7To8BarSbI0c2Teef/tM89yHbwXdYD10E59I53vGNPkWEMpEKx4+Ta5G+9UtKN0vqbKkeql4f7jvH6tEuFm2tV12yJdyYwSiFbazjW7Eo+Mls5a4kxy9jdVWD+uZ+Mm/ferpYwSVAlSloo0zKdyhfzDNAv3V+traxSg7FnjRsbbPK1zDAuEcsarfkccB2h3JAA62GQVjbjuXEp5vySILNMu4/pEg3MkaCXQLoB8x32by296YHgHua9mV4FKh1UCjrfKk9y7+N+pF819MT7/6D70zpIcun8Z73nPPyeCd+SqGbGZZVBIN3/JdsqlKrFV0Wd96vx6lxDbyld44HPMj1N2uLa2DWauAbMgjqqCbcOTCigENVojCBJSQsOwlcS11q2JGHdxiSp1uvcJDkRQipKFl1105KIBYbzei2tG5zbhDUIFKu0qyaQ4RoINJwb4mU/eI/b4ciFc1Po1ocAyuGDOTM7K/wZd6xQbLkGXc2AVi3G2ERG1gZUsOK7nJ/+jaCgkAKJGn0tuQqJWVdVqy3Xd36zXNAqcF7IkHGBaT1Mt2AT/vB9LOCcn7lPkqC1zfUw1U/jOjk/a4ts5+tYS+dgPGE9aDvjznW0fCchYNxoj+6mmdjF+XJ8aibbzFisgMjYuw4kBxLJGvPo/GjRRvGjMM44Mj4QrXe9611LxQpzU9eL7p+OqZ+bGCnL0yQkFCaS4doc3Gd6XVSlEOd0/3GutcxyLj6HiKRFkFeT9vAeC6dJoPS6kCBlsifA71hjJqdzPnU598g1yP1pkiwVSiZ1qpZfwLhAMuk7hNOkVoLzMOfMg4oJ2phJnoxH954z2RX/kyTyPvMISDJp00//9E8v32f5kXQDNr5WoqXiY2q9SxaSoEoKtTgzJqx522RGX2Nicz1JUky443rzvJJU17kE2SzF9se5cD4sYeSzwrJaykfp+ux4awkFjLHEuiYHyvfOk6EZxvHrdp5lYPg+zx+urXzHb1FIHETp7L7uvTj39+gzxyOzkFdPqsxmXKG3QI6Pc+szJuvw6rVRXZJVHDG/7PNa6lX06QUx8rjye9Wq22jsCk1cA9yAaiT3A3+3bvmNxulGuhdWopoPqimSqoZaksrDxIdKpuFfF1oXEJYVNBM8uHTzyoe/CSxWuUJlKRpd/rTkWuLDfuGSeNvb3nbP2rMfqLWXwCDwmCwnyaDCmEIoAq2JeRRgHX++Z2ynlgVJrsletAKMyjJIOlLgSIu3JEFSDVQMaCnRrc0yP6virRIm/kn3TF5dYwq/lg9SmIGAmBgo1wJHvb5CsgKR1q7EXNKuxEhIz4Px0xrl2GLVg2TbL+fYe4T28f8kfta0NaZaUpX1V43xVmHBnOg+yFxoXXWMam3ELIvD+OAGzLhY95Wx0pqdkOhVgpEZQCWrdS70XKBtWE9JmMR1mTfW0JzigPHVZdRSJlp/s+Zuwhq9CPwqO/wOc6FF3/PTDi02rK/0plBQrkTV8cBCKVFVqSMhrhm0TTDF9RgHE4MlMqbbNhuX6VhKymije7XrOGvi5vq/+OKLl/tPukkyZ6xTx1AiwfiZeMuM6BkTn/GblaDyyu9NwGfZLnMceD/kmh8ly8ms1BlyULPXmgjJ/S/JahJKXXidK/dklaFaPG2HSrMswzVy9U0FjcokPV5cM+soahmf3OP5vt4YWhLXIZ6jv9eFsaOumxFBnYPKhZzXLPEjYU0S7H5S48T1evD+ywSKfFcPFtaUc+Cz0ERahogwFw95yEP2FH2NxmGgiWsAgRah8qKLLtrXYPq7TeNjDwqSM3E0jgZqnX0weRiDUuuhjR7QtRaj1hGJ4KYkVfCAQ4jgIYSrGA/wKoyagVahclW2YJGlCDj4bdaFRQDOeCyug4skLvX7qWtoyRjLDumGaFIqNf9mEFXQMQmJ8T6OR5ZoUIBUkFNQ45o8yNHWV5exVEwowClUpWXSeEFd7xREJYUKkQoQksp1wXpi3Gmj19I6ZeIc15UuewgmjI0kPmPPagy06zs19xlDOVX3d8pamlYkr5GlYRSAPSxdwZwhqEtWva4WUa6nsKwlKRPMeC6FZK1quhXyHssk5WhQrHA/aGEYxV0KrfC0jWzPWLwkyKwLa0s6lrrYGi+Y95kCaCWrWua0jCA03uY2t1nmVeCeoq1mOda7IM9rPUnH3YRJuv75nbxOQmUH//cek7Az5t6DjAPtkeTohq8rsYQjrXbOOfuFQn3CurQmzUqXU2PsmbcaK+y8SexG+5n3nQpB+60rMufnupbtURmkhdrvZhZYhX/uwSwpozUw722JsdZuExAZe8t5WEv0n2tKUGsCoilIOrIOc9YW9T4wlwLn1b3XsXS/HLk3a2WVxJrUh3uRNeo4mtnbNgETCUpgOdL92PlVucD30tNglTWTc3Pv8zu8elw3KHYOGtozhRzHfB0l70rFVCWdaTnN7OQVWvCz7qpjbOZ33e9dC1kTWrkiS+Pwfe6n9BTwPja7fqNxlGjiGrj73e++dIniePe73734uq/7urUH8p3vfOfiiiuuWG6Om/yucTqAwDoq3F1Jqi5xeWRdTbXvB9FeGtPkoZVB7buE2qQ7WbOQ/48sNGYPtI3G8Jn1FquSQrOlDICZaHHZo9bjJnWFJUwSVeNTabuucFzPEhs+4CV/CjJajfl9au11H7QkhG1L1+1sSyYnQcgwDq/G5GrZRug0EzHfYwxS+NBVd660wxzokwmXJGlavDKm0vgj5575xiJlmyXR9iPbL1GdE5K1+mVWTc5/5zvf+RpjYtKjtKRJiBWma0yZygrjUBPGHpoIi3OYvMx6tLqJe07ap/UdwZr1f/755y9JIG1WiNMFdURYJZ8SCazvl1122bUSVOlarvJIwbRaMlN4dV2oCDKTLsI2bcRLAcUPc+b9bQIw3Yl15ZVo5JrXwyCvr3JJ4RZImjOeWYsP7dHSLoHV/dfEUSbq4bNMWGbGYImu90iFLt30T48J9ymtRfytZTlBO93zRrHm7km63zsGJpyqmdm5vrHruZ60mKkg0urOnHFu1pXzKwk1rrcmZDNcI106tZ4mMpbRuM10NU7S6R5tG71/cn831lMXZC2Y9nmEJKx6Q/jcy/hu/scra0hlhu6rILPvcn29YSBNWM2rNXRd6BZsPLYEnLXIHryfMkWjMUhymt5T6Y49dWgN9RmqAq9m+h4pkTJe3wzwPkucQ/di1oIeIypwTcqkbKDiwcRlgjmRrI5qGjcaR4UmrgFcHn7mZ35m+f5xj3vc4n/8j/+xVtwdDzq+n+dpnB3w4MH9NoVcBWTdfLV2ZbkFj4M+SFO4l8whHOgilXX9LHNCdtCpWO4sO2F7q7aXc5roQlc4E5AYY2gin0003BIwjxS2tK5q4TELpjFnCjpqq9Xg55hbZ1Grj25unLvGGuoqqMZcoYw+Va2zFj4FFv6PEFbd2BwXren7AddhXs2gazZd515X46zZaTZUszQjpJhhmnHT9VCr0hxRVcCRkED4LJ0gOaN9ZGmXnBpbtW68q2ua3+uyqDcAc0C7mUf6TTxzxvIp/Es+XAP0H4EYIRqXWt4jzOp+CgGdqumKNVCXdBORmVCtJjihjcaGauGtNSAdKxUb1nNlfRiXqneCpWfoF9dHQWr/Ml5SAdj1bikS+4DHhUTOsj58X5dVlQ+uUe4NrYvOoUox2m1SNQVtfkdWcKzVhhvoQiopTAvvaM4ld4yPY6HVW8JpXHoK9Na4RRAfZd0F/JZ26SJtDWWtgc6Ha1jlB+fk+5mkzHhcSBZ7v6Rc5WC6xqo8UyGUJDUTwK1zf6iEkpzqQmwiJi35rjnjiyXVlSg67xLhvE6SZC14Wubcu+gH/2cNMb7+RiLlOkhkjL/JvfIZyPx/6EMf2lvDo3NMgbaxzvNZTP94Bu3Hy8fkVllj3L2mktO0jvrbtG7n+lE5tQo5B66NnLdUluiCbWy2Xg7CZ6il80aeMqOs2VNQUZZhHLSFPaDR2CWuc3Xnrt4DDx402mYFvutd77r4L//lvywtRVNAiHjMYx6zTLTBxoGbGZ9tQ6t33ICgh+sNwgTCYuMv8Ru/8RvLjVuiaixhJarbWhc88NPiIlmzjAYCvaTONmhhSiFAQdfv6M42Ag86HnoIc2rj2T54CBrjlaVxEGq55lwMktp7iWp157MGLMTBuB0F7izJoGbdsj1aVBXKdP/lwe41tSRmRmddvo2ZzFISVbDTkitpGM0tvzGOSKF5v6B9jIP1MBl3hGCFENqqQKjyoQp+ukXq4mlSFa1CKXz7meOne6ZWM4+XvvSly30hAWlfR4Enic4MqcYSKqxJJhTiXBOsdR9fZu+1L1k+BaEVRQ2vEA1JoPdOPgKtWcs9ZNw0bck4Pfuv9S3JijHKkghjzGr2U60hEj3IP/cLbbRshzGjkqepWHgtnt6/Sejoj6WfVD55/2CtTuFUK5mKIevWSnLTY0EFEL+n3ZBs7nVj+LSmrqpvqsDtWFUSM/IIEFrYrRFdYXylyixDCWqWVpU0uafqLaM10+tmGR9AH3/lV35lOUeOIf2hvcgP3iOpxFglcrmWJCJZxkhCmbGruuimZ0FaZLXK+jzSTdtza6XTXVdFq8pWrse4QQi5J1wb7jnua2YENvTCa2Ymdj0Jsq+uN46p9WIiQs9dwRjgdcD+KFzjrM+RxTaVFcxNklPXb9Z+nZorz+P33Ccy/j3hsyMVChy6lDOWJrcyc/gqJSKHCRRr+/QWyBJw9RyS1eq9kORUBbjvp4jvHe5wh8n2NhrbQFtcy4byohe9aPGgBz1oecNCRimN88AHPnDxgAc8YCn8cGOzEZB44dd//dcXb3jDG66RjZXfn0bS2pgHCgseXmlJPWhJl4TaegUr45yMseQzhAreSzCM0bOsicQghYhVpXKA8VoIifkQ1e3QMgkKK5AWhIXRfZDlJ7Q4VEGOa5jpVbdcXdeydpwaZ8g41zNpla5vxqnqcsz4KGRkLLJCqoKd5Cbbr4XC9mU8URWKUoDTCnEQME6QKcaM9iOEQBSN06Wt9AmhLWOYJCUmIqKdnEeL6ihxCzBxisKopYUUWOpv5mrUVuVIrj3JluVaIIuWvqCfkmpjCKsQpwuu5W3oO/eh6501YV1S4zrNIgs4L+PBwXg6xpJoiZzukFqxRjFrWit1cZX0KMRyQGZoDyQPwoqwqDXc3zO3EIQ50idBdgwlUnkAE0Gxnk1MxFxxf6rksD60luMcXxOR0X+zzDp3rC+Jr+76jOGquEuVQcYg6pbLWKXCjDFJjwDB+OoOrkeGBFS38xTOp0hiZtPNfUCy4b3uPKq8UvHl/3Sl1E3U9ugFkf02+c0oWVImYPK7NVGS19QKaAIk135NxpQlU7zPJEySpmrp1CtHQkYfdAnX9VcPFy2Yuj+bdd5z6MJvO6sVt/7NWBqjb9kg7yHdy1UkqMigDWZSzkRtfId1T7tof+77NXZ+5JJdYWywBDWfmfZdhXUelZzq/aFbt15CtMN+z8XT6y2UyalGMCTDe350HkvmWZ7IDPmryOkc0vOj0dgV2uI6wMtf/vLFd3/3d+9puOduQh8SbFwvfvGLF4985CMXpxVtcT1cKARrWTPmLsvlaOFQmPVByAMeCwgCshbQTcg0DyDICoJLtYLqRse5MpGQNV+r1pffa1FVEK7QMmTGXc5pG3SBzXqMkBNrvyoUZOkKNeijpFmZJMRxyXIZXsekWBmXN0XSjFW2vEzdM9KCqYA59d5DV2/j3RgLMwZLKvncWpMSZV0hFcJXwe/pVqgFZ536hYzVa17zmmXbUkDDvfUHfuAH9qyHdTwkLaxdyCpkTaHNNQC0YAJdcBkbrWJaGrQqq0SBINInhTHmDcWFdVI59BLIRFHp/leJ/Yi46/aXBIPxs3QI9wQCNPcFY6Hg6zpm3WTyrimiZZZnhHVLR6VVLMdVjwvaoWsg19TbQhLLWDvnCdcb14TkqgSRxCmgr7Kmeh9JnGgr82qm69H3M25VcmkpHL0LFLLNouteKJmva75av1WCaP3MWFPvU/dTE5Xp0eJ94X7AQUgR6zFjT+nHPe95z2vFomY9WePbM1P1FFS+uafZ7uoCLKFUYSYxk1hLTjORVMZoSuz0Nqh7vxZUSzvxjLF0SpLjbSCzxvvcyEMLud4x7oncI9Ydri7gWfc458XXTI5m3GfGi2b25ySn9R7KmOM8VG6plOOYqvmdma51/53Losy60AOh3pvuZypFrG0t2d8UKtvSOu/R2YUbu0ZbXAd4+MMfvnQPfsITnrD4zd/8zZWuPfe+970Xz3ve8xZ3uctddjVPjTMCBAeEBqw/CHgKE6MSGpI53XGNk4Os4nK4aUIF3X4lixUKfHwPwih4sKLU0Erhg1myOhJwrXWY2VW1bJmZmM8lpAj/XIdXBCYtiyY18poSvUya4dil27SCdApjfm6NUEuZKMTUwzg3rZN8D2LJbyoZ3SS2kzmwZAfjI2GVTFiqw+zTCI5cX6uTFrKRAKHLrQliFLiqFUS39vq5SV8cL+YBawceKAmER7OrmxjLeD5LZkCwsNJJVCUFkj7nyEzItIHf0o5b3/rW17DEGWtrXVES7CVJZfxUOihoWv9ScjQF4521ODlmWmUtK6HLpcQkM1U75hAaS0VpxRZ6Cmjx5btJDuag9djES1oljc3mvJYQSvJZ9xM+h2RL1iTV/E+liPtAhbHVuTZAxmCne6sWLK2wWn5YTyocTNCUsXSSTktVZfZn26xCx3VuzK4J1jLDruekHRBVyXomiDIhnDG0SWq0Oqfygv5j/c9Y8OrFUZHtdW1lCAPXYy3Uc2wSN6/nijkCLB+mldiwDL7nGmDOaL+hH4ZigHSBz9ALLY3pFptZf/1dKommEhmpMDFUxPGQtPp7rbb0zfEbjXG1Xqu8yVIxqQROcpvXUlEgmc3SRdlnFcysnVHW7No+10sqYqeQicgy7j0TtOV9qQJkKg58FTlVQdDktHGUaIvrGtmCf/mXf3mZaERrBxsKgvs97nGPxdd//dcvY1nOAtriun3wYEHAZm1BWHUHrVBbr2Cme5kPWEt5IFRs+lDRomHsZAUPYq+b4EGGkIvAxEMz3X8rtFIoqEsYzBZs7KyCtYmdjGnScmV8pokmsuyLLpxaVbR8eSRRVZhXQ5wWFF0mK9lUIFUY3aYruC6QzIFjDRGhfwrpwD4x37RB65KCq/0x1jWJqvF567Q711ceo7X1Iz/yI8u6wEAXQ9YFXisZ46d3ANZVSyUlmaRPZqFNdzrJxcjarasbawfCY83UTEJUrSzrKBEUcBUEFVo5l3VMs9avllsFRMdcQmacKO3yf7U8kDHaZpleZ544L2PJoSs05JXx0r1dYqILrIJwtkPCJLFTSeK6qm3JGp8qMlyLjC9rWSKtQiLjSi3BlR4bJuRizau0U/jOdamrsvuSh/3w/qR/3M/ubbqGQjwUyrWqmnAt65Bq3dSyK2Gsyh6U23xHoZ428Kz8R//oH12j3TnOddy1VNJXSWWtVZtjr4fFXNw8/bT9vlaFgx4OeD2496SVkXFBSSRhrsnAEpWM1qNmz67lbGppG+fVjO6uTRQwymKWjlGB6D2uki0tseldkOO+KpTDWF3vU58b6WlR78nMAVC9NLLklEpCLao+V1JpmO+dU2QFY/qT4Oe96Tnn+ue+kxbTJqeN4462uK7A3e52t+XRaBwUal6tuYlQh4A3JUgrCCs48sDygSyBQPCS0G0SV6IrKkLdSPtqjBlt4wGZhFZ3LB5y/I+smjW2LR/eae3kc4RrLaoSRf9P/J81OSXj9I320tbLL798r4arQksKOKkxV7hIty3jsLQu1wy0FZmBuCa+mYNCUloZ6t9mNGYeGAtrUiJEsjZoI4KjsZW0nbEwgZY1H1kbWpnojyTKTLpzBEiXyHqs42Ksy2bGompp5prMlfHXuh8y7xnXaZ1drKWZSIp2aeFKC4VKDi2BZkIG6UbomtPyI6butXQdtG9clzFEaGdMJNa6EwKtfrpJ6jKugkDSpnW+zgW/4/tZjmkd0A/uBxQGxue6lyjES/ySTKsQSMWGWZGzTSoQskxHzWbqujT5S7qYjpQM/Mb6kbaBeVRpxzlUbOmGmWReod7kW8B7XWsq5+M8JFiUiLkn0HfXl/cOc2ZsodmpTc6jskLlj4nEOFSscdB+xj8TKEGGKV8kQZrbm1UcuheO4H6oh0UlI2lJyxjOEXSxzfvL2sCSM1zt8TqjfxlHrNutnjJaQN2PR0mvpqDFO5EKjiR4knrmRjdlQ1WMc2W+DQUxxEsS6P3rferzIhOmObepXHCvHikyc+xr7OycciyTNqYV3oR7mYXcQ4utnikjZH4DvS6YZ597WfvY+2FEkC31k3ui/feof/uZ7v6Nxi7RxLXR2AIQXnz4KSwbEyVZVcgekSQftDyEcVXDosMDiAc1DyDLT/hdHj64blnSZtWD1VdjzEaEmeub2Ib/IRAr/JjYwgcg5KrGZ6ZW3yy/fB+iyfggnPH/FIAU/I3/kXzyGWP33ve+dy8BiYJQtluhxPgjz5WuXn6fc+iulXUNE7pRKtgqLCcRTfKpcFVJ6dw8AIV83ScZGyyGfKbbphY+iYSul2bB1HopKc8+A62cohL4JPLOsUJtQsGpZpZ0/BD4LYOkVcXaxlrvtFgh0KvZR/gk4R2u7Yyd1+ZcCqGMC1ZUk4PpSjyKCVbonIqzyuy/eTg3xo8q8NomrY+6suoRYHIY32vRtxwJqAqAJG8qHTYBY8I6+eAHP7gcd8cEeA/pJmt8pq7WWvJRilQiRZ8kAZm4R0u9CXLS3dcxZU9B4B65QGZW7bTosh/4myzP5LhrFXXcDYXwHshkMvRHTw/WsNZN9lD7bjsQqhXs+S1jKekxVlaLYrrHsw8wnrrK6r3Audiv01UYGG87gm61kscpIpIWb8tY+XvdZSVLo3CSkYuwFmcTWdkPn130hfuR9ygYGZ9VyIRgiSwHk4mNVJq4p/sM4Xu6S+c9bHy6ibfcF03mxBgy1ig5mS9d+6v3kC7hKqPMsu++uU6csXuN82dmcj6zFI0uufbVzM2Ok6EChsXoCeCalgjaD8lqJvbyvec2o7AxtFl6x+dAJZogCajnHcHnXyoT0ovF/9EWEpk2GrtEE9cNwQZCtmE2dTYKNJN3vvOddzM7jRODt7zlLXvCj8JZCu2mt89EELr/mj3TpCv87uKLL14+FGvyFAUoPtM9cxUkBJbUSAulLnbG0+hqqBuWcUW0lYejLlxA4UMBQYsTMOtlJlYCkh2tKbpS2ke+D2GeSgyUcYDGAdV6him8mIFTi0Am5Mj6dxlXVF3v7O9+klhUqDiwbQhkWKyth5vX0yWSthornHFHEmzH1n6acbnWEK4ZRKvA7HxmLGEKUqM4X2NyLSvjOrcPulezxp0nyCoH7yUNrDHIGJYyLVh8DoxHtQyIxNr4UuM1vb7E3+t7pFLB5F6WoWEczWqsq6hxnWbPNXGQ2Ti5tm7mupOOwG+1Gq6TxTuh4GpMsCVJTOTkeNsvxlmLnOPgPZ8KIxUMtF9CJ8k2hs0kXbVfSbxqQqnMymtcZ8aSmmDIzK98V6Gd/zM+tse9xP+xzlgXKWRnLVx+k+RD5Qjzy/3NWoaIXXLJJXshBiCTLukWmnsyBMc1pkLL0lpeZ9WcmihLN+Cp/W0Ur2rW5nT5HVkzJVUZh+mYq4A0h4F7mXsw9wGklb7UmsOr4F6qlTLfS8Bsl0owSV11IdeSa1+1RLvGVXDQVvdp10FVxnpPGMfqnsk5tIyiFDOZlR4GI8tiZnFW6VmJoIfKFq+l0sCkSSp2hdcBXD/zAaRCWkWKnjlmza+JxTzfpvM4B+dqFUYKjEZj22jiuibYSH7wB39w8cIXvvBaLjgINv/yX/7LxT/5J/+kg9bPIHhYIHBrGdRlqkILRmZCzY0egd2HY30Y6jLMA0mBKy1G+bcPukyvXwUdsxUam8Z3Kfou+fbhaiyayYf8H1AzjoDl5wgZavbTWuP5FOJNjgK0AtguXUUlmJmhlUNXyCkXvCyp4L2qZTfHyv5vO151Smg1GQ9tM6GRQizXl4RokdMFlfcKQpkYQxJf45NGfdGioRuYCgm18ZY+SIVGWkOqJj5j9tJCaWZexxeh33hELDlYReg/JBXCDhFjHCCMxmLat8zaqVAuWVUozdjrFG6TTFhTWJLKwWfGXaMowa1Z8qLliUOrZVojQS27MnLrVLhcx+16RFS9Bp8xRuwPWk4kk9aq1XrLbyC4CrMqz7RSAdoDIWM+0lK8Cib/ygRPJkdzbqqbuQK/mZ2TpLreTULFnLg+TU5WvQXMmF1jVTOWnTXHHNMO1tX73//+PVdq17Vt0FKmV4NWVZNhpSv3pkoHEx6xJ64Tr6rCgfHlN5Aq97AaO1r/TmWV94Slxowd5pwqKt1fHPu6BlLRU7Pn1lIvfFfPItev76cInl4jzoPzaZiDoSZm0/Ze091e8u0zqsYOp5JO93IVZGmdrt4FZoa3dJH75JTSMtvguHitdWLpQV6HsTCO2+ekRFjL+1Sd9RGqktrrjay3U595nvpZyh/u/Zu0rdHYL84scb3jHe+4p8l705vetMwAOAW+d9/73ndx2WWXDTcjHopPetKTFm9+85sXP/dzP9fk9Ywh42OA1h8fiMYbmsjFh0hauNSop5YXaIHgb+t2TglPChBqa0W69UgcM8OgiTkyW6IWE12NJKIIdQg5ac2RyNJXE9d4brN1Wljd/hrjM+qLsZzGkOn+m/0cWYC0lCnwakEVunJJQkbXnhvbdT/3M4QtrGMQIwQt9gmy3eLimTUjTYREXyFLurCpUa9EUZcwyW66a0tQtDQnMVXglzBke3XBrP2RBOqGOkrcAelzPTD2fB9h88ILL9wTiLHiv/71r1+SVetCmvzG+dJyk5ZwCbfr0rYrWGfiFdcO5BiSKlG1Fqjjpsu4rpBacBV6rf8KqXONKvxPQSuIpafWJTgK+q7fJMOMDYSV9ZNlTcwU7BqmL1imXBuSP92irWlMu1xfVbnB2NZkURJQ2wa4Jp+7pvgfY2vsaJa/MnlMupWr4DDOlbmzXqzXUFBnD/Cc1n4GZrbOpDIqAmkXnii/9Vu/tVxz7k251xrGwD7FwXjoplz3iE0VWmZG59pYdqeQyeIYQ2sIez9k+ZZKJtwL7LthFezhriGfI1rGvcctwWRSKt3fJb8Z7iApTov7yCsjwzgSWkLrwec1QZnxlnpwJNGn7dyT3NfuP5ltvFptp67n88D7QxfrrNHM/eYeqRuuz237lApDY2ade/cnCX098j7zmlxfT5+MK80a7O4p6bVVzzv3d1VyHxTVA8e+NxqHgTNJXHmove9971veyBDSOdIKyA7I90FatISf/eIv/uLiWc961uKpT33qTtvfOF6wzIWCow80rXmj2mvGhhn3mhkyWUvpupRxfFMuYgqX1mozZseHbJJVyUxmrqS9uhrp0qk7Lm3hPKkh10phu3x4S0Zopy7NWgjUnletLO3TwoUgaemKOegy6qG2vpYNkaivUypiG0BQwlJyxRVXLEmapAKCpBZegQjopof1C7KqYDlKEAKcv/T6yPgo50cBPeFaGCHXbsbC5vXTOmF7mG/f+1tjGF/96lfvWbqMd9PVTvdxj2yrwl9mW802CD5nvUg0SexFNuOMJzNWjnUOATQeV+8GwXUQjM8///zlnPAb1u1Ushxd57XGTWV2rTCzcia0ykMrHd4PrCP+9n5lDLkWgqwZVPViYFz09tDV1fngPmWcjC+uBLVaqLiOWb5Zu6kAqXWDFagZJ9Z7uuAqQOeYuW84vrqS1xhtrbN5PfcTz63nBe3k+cz104U6CZaEFBd1S2rp2WFCG62qorq5piuu1mcO7m2VCyqO+JyQosz4mm6oNVvyFHRdzsMxMLusHjWZ9M0505LsmNNH+z6HubCBinQDroTR+9c9z3t5BBUeWuGdM+7tOeK2isip/EqFQIayMIaQZfdU16zkVkUu6512cc/7PJekpou091yWhkpvAe4tkzBVcA6uwf2bHkLHDRmWkcc2yXGjMYUzSVyxjIrv+I7vmP0u1thXvvKV13A7g5g++MEPXm5GJI955jOfubj00kuXN/MP//APLx7/+MevrLvXOF3QzctEJArMuuzlhp5xjkASY50+BLQkDDUZUFqAtGrwm5pgQeuIwrAWXS0cZsu01Igkygykui/plqXgxDmM6dPlS8sRsO0+yNV0K1DRfgRpiKq1N6cKuSe4nq53NbZOKNBmfdODoj6cFUYtnYGwzgFJw4qny7gJuaw9ajZWQPsgSeeee+4emZ9y83VOp6wdUy5pNYOxiWZMZGWdUd3FkxymFbOOhXVmIVb0GXdfCGG64XEdCbaWQi03SVYVuK2FmNbkJD2uGcgpBwSEWsW0fSoZE/OAhRtiQZtd9xJpXfJYfygvOVfGx1bUDLfrCGneP4yX2ZBrwhrnD0Ga9cNacuzMrmp8rRl0M/szv9fy5mese+4va7KuAufASmipkVEZD+YIJYElimgvZJF70iykQG8SSzeZjTjdeXO9S2oyM3DGyiZUltFG8gAwXlpzU2nD9Wkva4Y9RldkM5+a0C0tuirAqudC3mu8GoMoucZKx32eYE1zf7gPpovlFLSyaRF1zPRCcG+QMOvhYhZXSy7RJpMOuUbNxGt/JXfpvp01bYUEUK+QzCrs+pVcmyBID40kjzW8ITOY02fuDy3Dfp95Q8mwDTJEm7kPrVGuZ46x0dw77um66GupTcWaz1FdebWUZgZ7wycYI/rFGnVvVCGXccCMFXuQYTC7JH9ThHOdI383tZatLd5o7BJnkriiCQVsEN/yLd8y+92f/MmfXL4ax4C7G/VbBSnvOQeWWyy5bE6/8Au/sHjsYx+74140jguoY4mCI7P5IeB927d92x5h0GKJ4KxrsdpoBCjq/kFapyxcqQU2w6rCWVoJfIjyfR6wtMmsg6xNSIblL7Q2GHuoRcwYJa1wart52COgmUFT66q1KbXQAX+nizQPeQRvrUWOkzUoRcYpSqq1UukymuOj6xXnNdYvyW9aTeaOue8o0EnQTUaUpMxkH2aQZn5MpiTh0OKDCy3zPYp9TPe6tBLU2ofGFmdG43zvuKcla53MmSPQBgggWYJxw0Qg53B9Ea/K/GgpdcxNsiU5Tfe5tEpku+wf9wJkkvGijiQEXwXPHFiPrHEt3JIa5skEWJKCjGvU5TBh4iLJalWCpOVM4Z97RIuKZHmELKnDOJo5WcKqsst4TRN1QUQhIEAvhhR09V5I6+QIEjDGRAXEiLC71oxJ10Mky37UcTMpEm0wJk+LUyZSMymbY5bhDfYpYzRpI2vKWM10h9ddlXnSHVplGecyaZnlfFS+aVFP0qZ10T7mHNf6pVp2XedJvDJW3yNLrmRNaJUhEh/vY5WUWgdpk5Z+r6Onjms77zNLTWXJLNeYygbnJ9d0EnXfuxb0MJir98m1R4qKugcxl9yrZoMGjANKqf3ES9pWxsns5LpQT5EtPXXyeSXxdC1wTudD5Jz7HM/ndMZ2r8q2zdyyRkfeEFrZR4RzUxK6a3feqVjgRmObOJPEFSEMIBDxcJ27CXF3c7N6zGMecw3SKtjofuInfmJxz3vec/n3G9/4xiauZwxq8wUPdwQGY3Yy2UjG6qll5cGI1WoE3YqNF0sLGtCyURPl6I4HqUDgQziU8EDyFJ6METWGFYuWsU9YYTjSksbn1uPUYiV4EKs9ViOdD/RVyL5quazZErWaaDGhTwjfCQmU4+CYVNKb1kWtKx4SUcm5QqzWEwk1n2sJlsQjuKvJ55WaiLe73e32CIVzo/Uia/epuV8HtRSObrL7IaiA9rMOsaSR1EaLpXFfSeSztIYWipqAJYVw15vxlo49GnoJqpbUTWqa0mYTPUH+UkClfdb9VcmTsdhVeaBbvV4TzouKiJGFKrOgTgluKiEkFP6thVXiZY1Q9g4s8qwj3kNYJY4SvCSmEraRdVVLku00syzjkvGLrn9eVTSwDiV4NXZe6IJqFl6TiSVBzZjstEIb3pACuPcd7dMSJ2HM+8T6uFwTxYZZcUEqRtKtWnfUtM7qPZL1R1VCppdLlupJN3f2OH5jlmmthcgDEtV0G7V+59w9SlstDcV8qThPa5bEThfX9MpQUcZnuJ1XwlJzFPheAikpdX+fIqh+tx7Gn06B65BbwbwNriPWOfM4Ny66z+dezZriXK7RUWmmSqqdC5MxZcx0Pk/XSbSVidBUAOkqDdw/rbVq8ifOy72QsaI+72pyvFpjNg+VFbuC98I6R6Oxa5xJ4oogxo14+9vffvZ773nPe/Y0snz/u77ruya/e/e7331pIcBtaC4pQ+N0wvhRyRXCEg8dE4QouOtya9KhOei+lg9KNeI8mCVkPARdpxIJiZaZWo1j0zKmiyjfVagymYfurrqBcU21xwpFWGh170RQxYKI8GhtS10YFZAyBjMPrqEwbcF0CdHIkiP5UCCo8Z7roFrK0mXTNudRs2oqNEtSeKVNlrHQqoPwSqksFAGMrdYhrbUjC8Dowa973TYJKtdmzCF87FkcED8UHLr12r60ONcyM0ChS+g6yBrXYoAQrYVBd1+P/biWSVatfVvHMmMcdfH1HjTJi4lnsrYtfWJcRucESVRHtSIdW9eT5E/SQrtY47QbC6IxdN6PPENQchDXZyI0Y6QrKebcJjCTsHn/Z41PhWbvYT0uFLIVuI1pl1TRP+5J42vTuqSbNUoZiIbu5h7A0jcSQa9fSYUx+oYbuH95j+W9yvVZS+w3zCPXdy0mMZRgqggzrtFzWlNUgqr7Ku+TwGZsqn3WMqrVES+EvA+5h9kHb3vb2+5Z8dYV6BkH62yPlCDut/SFZ4uk27mkbawH2qpCKfddv2c5oiwt5v062lNq5uZVoQ1zoH/WARf0iTXP9UfkNN+n4tA1PrWfpnVTrxy9fio5HSHJo8871pzKaPYJFTCMdypXdYFHocOzIMlqHulZM4dV5W2qC7JH5i5Yl3xW5e5+nzONxi5wJomrsXhz1lbw9re/fe89D4SRtTWBkIoAiEDSOFtIwVEyxYaPm18+nBG2jKUbuanyMDZm0qQblrkwrsoyFJy/ElUewgpg6eoqYUUYpg1afXX/VUjL2FVLGihomsREKwRtMOkLD0XWPW6/mQ0yXVhTQOAaWlU9v2U6qmY83bdG7lEKxn6e1/Z/tZSE/5dgWyKjuiNLPDK7sgK5Y2WCGd25aC8EBELGeDC+1cI7EgZSgK4uvgfRptMnBEUEbAkqf7smsoaiQlRapLTApftittkYvnRZZm1gOT3vvPOWrtEoNSCprL/99oV1AoHjQGivgqoWTcZQspWx2pIr5qRa49Idex2iqoAoyXMtai03yZakh/WCVwBtRzGkNUZlB2MF0THmm7lh3ZjxOEGbIYv8TpfEFOCF97MJwozJNnOtVjxrGLMWEMLThdZ5l6SlZdWYxpxPx8F1Z6bvtNS6R9I3SfZIiLeN9Jc9C2scB3Pnfel9kuW6tLjVmNeRciPj9Xw1KZBEJQleTTZlxnTbpFWWMaLN665rXVqTmKhgo432kbmkukG6n+oJ497peSR5SV4swTYiqCqcqhfHQRRkCdrE3qMiVuWAChrujanEcial06IqSRTe97pam2XaXAf5PPQ5az3WuWNEhlMJU9eaa98xZA0Z62quh8x0X/tYCW3N2pvP1BoeMgoZSXdz90fX6SiLeCdXapwEnEni6uayKlnCu9/97uUrN/Nd7nKXlZs3GzCYK5vQOJ2QQPrQNWEGawdBFIKXMXrpVqMVhocbD0OtfKw33Q8RgngIm7VV0se1stwH50AAQMBJt2K1zHwGaVFw1uKpFTDL9Cg0KuAr5Cq4GoNa3XRHSC26hNyHaj5kdYezZmsmm6nZZZNcAoUHiYqWliS3ugaqCKjCRmaGVINtfKRF5M2MC/y+7sEoKhgj2jClwDJBh8KhVpkUfoGCHf3KuN8ptzDd0nEN1HUWt1/mJ0mZLpOZACjdL7WeatHXuq31yfHRauG46h6K0HinO91p8WM/9mMHdh2zXJOW1VT0GKfJewmErs41qRAWOl235+qWJtHRwscYaLGh7/ZXN1stcSMSB2Gk/SYUM9u25yS+nNJsEDLrU1pTtkLywjlQQBhjrHAr+WYvgRxD0PWcqOWN0m06E7BlYidLfXBdnm3ej3MwNEGFlAorr8M4uKfp3ZACtpZT1pBkVVKt54h7o26/aY2rxE/34nRld32bFMx73Vctxt4nabnPMjR138k5Q7FCZvEa4+qh66mJrWrIAOPCtRgHxpzz6VKece/uyXq0+BzQgirprHG2+3Hv3RQSb9qFJwf7kXNEH1R8Zikkf+fzVAWhJLPWk82kc5nsyfVRcyjsF65rlS2C8fJeMm8Bn6n8TRLpZ1pts/5yVWpOWTnTVb4enn8KEvY5N+pRjO1U9vFG46hwJokrGjjrKs7hne985977r/3ar115XjeN1lqdLfAQhtAkeOhY3mUqXlGB0RISWjokdsYpsZ747lVXXbUnnGS5En6LsI6wasKNtHpKiNKdDoGANvsQ86HEA9AHsUK+liGtSFlbsKK6FmWsqDGnWrkUaLXkmCAjka7AGbdba/dVq6Dt8EFvG3SR030r63umEML5IEtYNxC4TMjEIZljPBBAFOqrZVSSl6UsFHzrHmEs5rrrjT7RJvYwDmORaV9m8czi846DgnKtAesYG6uXf2cWVvrN2FkH8zd+4zf2xsU+Qjr2I+RonYDsma2V9kpYsyyHShTWDvcN302LKO3Eyst9aFtM5uXhuGTZlCS2mQDIsdWSkmUx6lzSFr0mLP+jIiRdglk7nJdyLuwFknKVL8y1ihGtt3noucDa0aqq+2smdstkObpjWraKvpjJ3IPfZF3avJ/Tg8LPJasK9SrEjNFUQSSRVGHi+Wwb+4yuuPSLhGD237GV4I3GXSLs+OQekzWQPWqyHb9f79k6z+m2OXLz5H8qt/L87vfG7doX22oIAG1jjNh7+I3u3rm2mbN00ZYwSejtb1qM7Utmua1HJbpzh/33qHWjdWn2meY9SNt55Znm/uSzwnvAezWz73pN/s7s6KNEdweN5QSSZsaL9qho9L7ivYnIVAQ5fvTFJG2jslool1njlmuzDNccVGxOlXZTwTNKsOUxZ7BZ5Y6s98XU0VbbxmHgTBJX3LJ4eGhRHQErBYlJ3Cjvda97rTwv5wRdCudswQerMaE8YBFIEZi1zihUab2DaCpopuVETTIHwq/CtNpky4xoudAdT2IoAbFmqg9DSyWYmMSHH4fxXzw8fQhrBeQ9/TADaCYzSuiOZBkY2odwZnbhJEkmk9JFcYrYZ2xlWlRWPXjN9MvY0FatKbrBpZtaJl/hPYSJ+x6BkfZLljgnv0erDlmDmDHH1l5NUiCx1XW41oKsNSHTvVJIqBT+sBqgmICkmtgmLTx1fPP8Ctb5f4VFBdXMdqqQaPkTrF70lxg09k7Xg32mTbghr0K6IefB/NIfBFzOpVCfVhs9ACCpWClV6PA9fmP9UpOdQVgh10lU6J9ufpaSythmkK6mmXXV+8+1YwyiVkquQ7uZJy1jWYJK90XWDK/8/61vfeuyLRLbPKoV13vLthm77txmIrIEbc4SXSqwnONMKMT/FKId33WTqLmHWG7IvSnvS+daS5Sxx1p2ddt3v5SA1qysGQ6Qbr58XyKXVtSRh4L9TwvqSKG0Cum6KbzntaaaZZy/s70q4FQO0RbjNg3/cK7MFsy8sMZVrvD/7EOSiCkSlOs9P6v7R+4jGeNeX/1NxrnrHl/Juwofywelp8Bo/Ur4JI0e9Nvz5/6d1th8nXqfpYZcJyqCzESsQtPrWCc5M+RnGEu2h+cD97zrgSMzHGeZHpOc6d68n/hh3b3nvEqUSaYstwex2uqd2Mabxi5xJonr3e52t2XpGoSMV73qVYtv+qZvutZ3Xvayl+1tLmxA97///VeeF+sMNyzCXeNsQSESIQOhg7WFFQWY3MgMolWoyyyeSWB191IotFyGAlu6rAJjCy1DIflRAOGBj9Cj+yvt4DOIGOTEZFG8akVc5wFkiRjJNFDAyLalUGx8rsQwLc5ZJzEFKOMoM/ZI17nMNqwba1r8Mn4oXStVGpgABwFCl2mtQgrYjCtEjjmBwErwFSpHrszp4jwSJNNKYXkS3HxRbBgzTNskJyPSmwJjxqxmX5OwajFTwNVSSr9cC/TPmr6Z2IPvGtvl31lX17lizPBYSQHJ69sPSy/php0ZpFNJkSVpdNXlmlpxzJJtFlRItrUhjUmWDFTXWi2bGZeebuJVoK9xgGb6hXSbGTitWbTNDNMmv9GN1PWVRMwkX46P9zx/q1jQmgoknhmzzTipcDA7+JQbobHq3JOratOavC2TLPG382//gfeWCicFfi32GWepcindVd3j8p6RREhiKmFLMuerrs56C2QZnrQabmJhrH//yq/8ynIMdPHNfAHW7tU6p5ssvzWRW7oruw84ju5zzA9zalyx/fV+yP0gE0+tozDzGCWs81yrwqoSeoNk+AWvWvVTgZHzlC7jmQjLPXYUyzmVQ2EVJMvuOSp1TSZWQbtTAZRx4JtCJbKW3PSOysNasRlLvh+r+NTv3E+87/O+qwmkVJCtstq2xbVxGDiTxPXbv/3bFy94wQuW77//+79/L3mIwD2J2pxuhA984ANXJnJCGCG2jN9Q27VxtqDQmODhjeWetVGTk7j5SxrMhmnNVP7PQzRLISj0WSpCIqqQbS1AE8ZoefQh43V51Yqmy5HuWxDWVXFsatMtDzDlWoQwIlk1IYXJZDLxU/191hUcIa0A6RIsaarn9YGtZVfBjbYwP1hZ6Y/CnMIMbTchDH0wtjfbZqKQVeOlMJhuzowdxMTELJYoUXiohFPilBaC7EtmO1bYTKKqJZg5Z90YQ2gJmowPA44n55T0+XceuPSyxhNcz7JjwvNIdrRqSg49v67prEWTySiYujYZJy359pO1Tx9RQBgbl8oPlQSZ0TpJQLoiKqxJfCRIZgZn7WNlhpg4NxJW2qrixxJAgDg/2pSCo8oV+6fHgkm6PIdZqU065TowIzjEXWWDygUzdEvY7JtKJM6dydZGh/c6/TRmVo+KTKzkd1UAmFWVdqXV2/VXa7l6n7pXudZ15U+SOnILrV4pvm4rJs85TuWMmWXNKZCxz4zBpZdeeg2lhAmULBmkC7RJsSzlpCWc/1mH1fCFJJmuhSlk3gD7kOTUZ1AqS3Wr9vtpIa7vUxnhvKjUcs0aesJ3aGuSpyRRIGP9VUJU1/h65P1fj1XzSTslq6NxZCy4P0zUtS2oYOaQNGs9TuWSymrgs9+610cJPUDqs0Alb6Oxa5xJ4nq/+91vWb4GiwDCBIlEvuVbvmUpvCGEYYVV4OcmfeITn7jynP/tv/23vfersg83Th+0BEqcIEMXX3zxNZJHZIZIYtxMzqAGF+KCMOQD3nITQqEf6MrHAaFCaOW8JkDRlUdNLddG+EMIQmhSoNOt2fqiU1BYt47dlMCkxUhBmXboGj1XsqDCjKEgLQnp3pvuk1qU1O6PYk4Bv0EY+OAHP7gUOGmfArElhiB0zk+65+Ucj/qfGulaHxHBVnLqa3Wzq5a90RzkdyqxBb5Kimg3a4P+QFCpDYrLr/2RaOiOrfXX9teMzdmGdaCAbVKsdPt1DCU51v5VeSMRArq5Sv6A7nkqOiCSOS+Sz8wqa8IbhW3PoyCdhCqtPFybtmTsqm59WnRZN1israWqJQ2hlH6zntL6S78ln+muqjWVvuhVYekbhFe9Fhgn7lutzbqk8n3anHsH/XMd8/u5e10PEcbaJE8c3P+6BRt37Npxz5LI1ARAKtWylFUqYzJGTtdrSV1+N12zq8JBwpJrrJKbSnSm/jf6nsoJwyBUVHB/MTeuPQmgyYSM39dCnxZ03uvuapIeYEIsQ0PWLfk1IqepqEmk9VKSXy2aqRDQcu2R+yvrhfuP+dCSyP9w2R+RGf5nqIjEcNvupSMym+WG3B+Zm1Ty6d2hB9J+SPMmhFtFXZLpDJcArgH2n8wEvotxW2dcq1JEbCvWuNGYw5kkruAlL3nJ4t73vvfeA+jlL3/53v8krOBhD3vY4sEPfvDK8/3n//yfr0GMG2cHmVhCK58uhwrtPAhRjJhdmIcTD1CEQ7P/VsuI5+EBYdZPXTYREIw/NZssrqVmyuR6JkjhuwjVWqt0U0MwmkrND4zTS1fQUd8z6QltRMidswQkaG9aSiRKuiFmjKlkShdL3e/4rRk0Rw9xvkd7EOwRrkziY8ZOxohrk90VzwszPeo6mzG4CoaWZpCESMp4j/VRYZ/3xlJWNz33mdpm25tu0klmk+im8G82VtYEllRcCy3poRUHCzPtyiyW6W6Xn2cSkuqOJ/Hk83e84x17cYkqFHT7VNmgBVxhn98z9lr+JG+6y7IunVu+a1IbawQryPN7riOhUcDzPpTcaalIt20zIDtuJjHLODjOw7VRaHIv0BfWhcoI7g3a5FhL3phj7m1L1ahcMQER6ypJXN5PjjHfZS4l2t67lqRhbGgTSqEpq7/ZkLlmJi3S2paEEJLK/YGrOmvE+z5jk93nXJNapLOGJG2t9U6Bmcv9XrrX17i5dMlOt1iTs2WyonXI50Hecy3G2dhdFSHZVvcw2+jaVonnOKiY4HysZ63+wjCNOcuVCpt0C07rV97HJtkbkdLcg1NxolJnyrqda5Uxwe2dfcX5o330gXWX7tWsCS2NmfBrV3BvZc5UHLovSNZ9zzypSD4u8ZnWUVYZBSoBZr4l/7ymAmfbhHud33XW4cZh4MwSV2rmveENb1g88pGPXG68VSjnb2Jff/qnf3rluTiPiZ6wbOB63Dg7YK3w4E4LGsINRNK6qTxgEAwpdWGGUa0RbvYKROkeZ0xZus8ijHBehU1JBtpt2mIiEIu6e36uaUKhKYEEIVuLQgqSnDfremZmTv5e5S6rq1xq7+kj/TUZhlbZSlCFglgWkE9kdlLdpWkXllWyVyKM64plmxkjCCvEQwsbZAFiYOKrapH0IU2bJageCEfVMmrbnAf3mrTcKnimBVXylLHAkkNdx7SiMa8Zx6flMIXiFPRXzVVNWpK1/3iV7Bif7LgoPHMOrNr+L5Uz1iCVmEq6JTuZlIS1TKIsrZaSJWPNdKnXEs/a8DwK7JkB1OtIUkcwYYoJsVB0GK/J9fQ44FrcX/SbNhgSYFvTPVuCLrl1/LTwpDunrx7cj1otLXkFwayxkK4bEzLRV2PpGEPnXgKqkoW9i8MSNulynnG46T0iSbOPtEvlgHubpNT1pFAt4VJxk0nBsrxUluUaKc22hXShluwwBkkaXNMc9lm3VvcNvU3cn+r6cp0wf1rbLVfD7yyl5Zg5TtUdU6XdyOI1hSSnSUydp3WgxdKkXKwZnnGppDShmy7hGT+9a6KaYN1KVkfWasaX+4m54vUw27YufE7iJWVoidnt837w+YQi5KDJnRqNk4AzvbLJfkYcyi/90i8tXv/61y815GxgWF0e+tCHrpWQCVxyySWLf/gP/+FePGzjbCE14AojatpZUwiZWSpEwlXj6BQGjXkyvhVAJHUr5DcI1lnaAgEbQZTvcG3+JwHlN5BVhCzjOhXSQMbYSJIySYfJVRSGec04pYrsT7Wmch0esAjS1pqtBFXoZqdrmiQsM70mUXUsjB2FOHEdxtJxNBMvRO+8885bPuDtr0SP3zKeIyLj4XhLNucE65rcJN1uk9ymYOznzrmEnXlM11JJqgI0YzGy2Ore5XUy7rVm16wZUnUfloTWucpkWipf+B5WSq1M1uXVMkAfrNfLZ5IWXe1Zt64RFTOSQNcB37UkTioyJLfp9pv/4/y66kqKdIWHpHLPqoTIMi56A2i55D7Suqu7a45jlu1wXswubE1mxq26BQq/S9+5LgqYbLf94b3EUeLP+UwYlUoX44vpJ0daEF0rmTBKb4rMKu7Ym7CGI62u6Rmgm6rjU5MpZemljHv0Pk+PhP0kpMlz1789H+Nnki6zW+uO7r2VruRasXMt16zrNQM7Y855tZg7PpJdE+axP9Z6tOtCcprEdFNymtB1NbNHGysOYa2JAVGckvHbNXHY1jdLaWkZr/AZpgfCSbIOqnRWYa0nlF4gQM8rDl2x6ad7TaNxWnCdq3epymycKhDLg1CHGyLWscZf4FnPetbita997Z4FhAcLhOg+97nPnjCb4DOFHbNoKkAjDFhqI7/P+XQjVvjSWomgoxXJh3EmYKmp8bOYOg+5rKmoAAv4naRx9OBLd77M3KkVQAJiXKzkpgqPvpds2BfP63vJ2f/H3lmAT1OV7//QHQJKdyNIKSDSgpQSKiUlgon+wAKbEBUwUBEwkDIQMRAQ6RYpQQVBeOl+QUKQBt//9Zm/9/p8552Nme3d+3Ndc23NzM6cObN77vOUrHRxUKsYYQaHuDoiejR4idZMlSniu1R2BDHIYJJ90hbRzVeutXEwD7IWReupMv/Wc6uK1tQ4kJagYYAhSw3nqD4iq4wsrYp9jlma1c+iJTxasIoGrvm41ZjpVwNV2lBiJl+aSNa8Sy+9tJZYRgKZwSF5BJRwRRMeuqbK2BvdhzURQP9XDLDaXZMY6guxfEm05kdrYN4NOy9qOH+57CsxlhKHxespwVrkQqiJk+gSKTd+PC0kbiRcVY5HpVJiX1G/Uj9XZt68yBYx1pPvjdY53cMSZLSp6kXL1VfHq/PTPa12jJleZRXX5IliNuN5qz9H8aT2aTXbaLwnOv1cj7Sh2pVFdVXrZZSlPeR+L7f2ViydfA+TA/wWKZRAC22j3/R2xamed8LClheq+ZAP+hG/iwoRoS2wCJKQsuy5dAKVpkKw1svyq3rbyqg/SmgyWIK1XikbTZBoQt2YYWa07mJj+oAGOxqQMzhioPP617++NqhmkCJhpxn+OGjlz0e17RTjJPczWRK1vqw0fI9iOyWKZO3Nx7vIRU1uxEX12lg/upnqT573NUjWQFTWEllV5KoUY2KbWQ0k0FjkTiaLdIyN0wCT449IBGhhMgWhGUs4KP5Ts9WcC8epAT/HS/ZbiVWVcdCAPrpiyhU2JhWKYkLWUhFFqxL8yGoTa8DKKiP3UolOWWw08GLiSG7MskC2E48lYRQXWXs0iaHXEnH6TOUjeKQ9YmZYxS0Tx6kEIhKZ7IeBb4xFlXWffXGNo/WRayTXYokfDd5ltYv3h6zDRZMGUXDHSRv1rzhxk7f06bu1P3lQKPmU+rBEHcfI/uhriOKiTNdR7GmCiO2UQCYeQ3QtjpZKtamWGHvNva4az/KaUOy9XM91HypJnESm7ne5ocuqrT4sr4e8e7p+t6qKy27AuavcltyhaSf6AH04/zvIcdAeCDIlXmp0bLFvKZM7FkkmefP1LrlvVQe5HnLHLnLt7bTwoh0UqpHPahtRX+Y6cV9rQgpXee7NXqJyWPxWcOxFaHKPiZZRThgUk0lxLRTqwxLrfOs3jv9HjREUrtFuTK+SlrFoTGJMN7FwNaZN5MoYy7PwR4JwlVDVAEYiR66LEnyAmxXvyz1RLqHxz5r1GUjizh7FggaYyo4rSwIiQS6DipvUQEOCSoOQmAgluvWxKCZUA31Z5lT+gCUmfCly5GA/yrCp7LHNEoDkkRs156aZdgaI0R1Y+1NtUtqR41PMJc/zFq98YpZGmXPjgGVawUQAAQAASURBVFsDWllRaYPoiqsYVNXxVDmdWGJGg/3oaknbMOiiT3BdlTCq6iCf85GgUaKZvBVIcYc6H00AaDAuYSshBLEGZ3SHJ85t+eWXr8VScn1i+RSJOIli7Tu62sbJjFgXN3oc5C34WmKGZ9ZRAq2YKEnWR11/3cfqk5qwie7Wcr9jPU2yaKIo34/lmitPDAlCobqzSk7EvaT2yFtONZmkTNDyXlBbyj071k7VhILOQ+2g/akcVjxfZXeWO2VMuJT/XYheD8qAHMv95K9Ju0sr+wNNEuh6a6JJHgVqZ6GSRVxDJTWTO2+8f6I4jWVvNNFC/4hJlyLsP5Ya073SC3EakTuyliIXdcFx0Ca6Z2kboVrWvXK3lXssvyNcv6L/F9qWflvkZTQOyD2YhWtTVF9dfUATtQot0m9Ys/8VjWViUsJYLUCJEo3pJhauxnQAiY+YtVFiLl8cXe6EKj7OgIA/E7nU8sMvcSl3W0Ds6U9B7n2Kf2RggeVQJSvybl5xgCEBKUtKjEXl2GQNk2VCtVo18NUfFq9lEYzZiaOVWfVPGVBIxEehGB/jc1lx4zEoQ69qXcZYNImdaHFjAHnLLbfU1tF1ieKsUXxqXqDGAXIU5xJvGvBzjXjkvOVuzfayDHMOEU1q0D5yMZUrJudazy2/njskS6xRKEERk+JEsQeyqPK+LK2K/VVfk2t1tMxpciCWl1G/k9utrLYSmdG9VrUvNWBXPWIEO+0pt/AidA3kbizhxvfKaipXQt6LAlZxl4oHjxZPTfDo+nJMXE+VnVH/jnVQ1ZZK3kS7K6YuiiCVF1FYAP1ax6OYZrlRq+4pxxkTJsX4c4lzTcjoOuq66npHl3i5LefdCLGkYQ2MsfhxoqBe+/cTxURrsi7WrQZ5qGiSAnRuWpRdmuuC14u8NmKsfz4OvcgNXRMJQuVW6MuqZ9sLcRqJye+UNKwe8bdcNUYJu+D+jJOBZMdvlI2+U9DmmmSLsZwRjkdi1S6wE9F/OhMxyoydT+5EH+d/kkXWWyV3UuhMFKn5+ysPn8cM+MZ0AwtXY9pEg6PoZsUfKslp8oNDBkj8iTDbCUp6w58BA0cGOaBZUgZWbCNrAaJHCXuYxedPiERBPEoIR2RF4c+dQancLqPIk9tcLCMCEgTRUhaR26IWCTeVH2k2G8+xxjJCeq46hxIdnLP+NHHBQ7DKYhfdAGOmUrWDYvb0fbF94jr5mFNZmorcqDSrrJIPStQSP1cMLdeRgXC9rMtyG0aslk0YokF7tH4XTVpENCmg7MT56xGzp+r6axAPikNW/DTXmgR3sqjKMskjScnknqoJHQ2mgGNWPKgEPpaC6HqYj09Usihdd4njWLNV/VlusjGOl++W4OR7lNxJrvG6broPNOmiySeec7249+J1UD/lmFSTMQp2JSeTsJbbr34PJI4kVmONWZAFVoNI9qlrHa+Nvkf1bWVJlDt1TPSCK6xq+kqg5l2s1S/aXTqFXLMlVKM7ZOzHMZmYksXJ3Vxtr/hxXuez47aKvABktdX1k0VStUB7hTKha2lU/5U2iEJVE5f0H8X2R/h/os90U5Rw7bg/VGqq6JpErwB+M0xzaLNmyZ1UfkeTjfL8KfImEZrEk9dWJ1yPjWmGhasxbRKtePE9ucPKHZA/CcqyyAKgrIysxwD2/vvvzzJUM/jQrLzq8vFc7qbAnw6ClQGs/iii+1mMo2RAIgsmgwKEX9HMu9w6tcSELexT7pGyuGngr7p89USXympIKOv8JTZlSZJYZcAlV1YN9pn5Z3ApK7YsUNEFUxZUtUXMWAoxe26MJY2JjXQtZWXk2jBgi0scjCpBiYQ6x4qFlGsjt0muQYyX5VozC87Aluf5hE7R+qy2kyCTQNXMuRLtFAkFtWe8jjpe1ViVIAK1qxJ+aVCi6xstrUqihJs2/ZZjipYoTSrIaqf9KCs256fawnzOc7KSyhKr66BkMRKGOmdZhOOEhzwWlPFWYjSW0JE1gUEvng4cj85Xlh1gPa6bxKzuJVnKNMCWK74mX3SfcWyx5JPqXErIqu05V01qxYRHEmi61vq9yFtVJaB1P3OssvIqTpyF/SM6CDGg3/Ujy2hZsavYOZ17jJuXtTSuL0HLwvVn0kH3geKXeV/lh2L8OdepnlBvlPQs/5une7tXgpW+HoVqPqY2EoWIsrXnRQb7IJlUnBCgH3NvdkskyvtAmfSL4mz1/8d92+vJgFGDPksbKoRAdcf57ctPFHBd+Ey/3/ImklCVN5ExvcTC1ZgOoLqfikPkj36VVVapxaZSyoI/CFmIFNvIwh82g38lR5KbMcRSFLixsR/+XDQg1QCd9fLxhrj/sE0sexIHWjExjay1Er6cjwRHjLuMQjX+YXE+0U1Z8WU8l8iQQC2ywEiwKsMrIoJj1x+q3DdlEch+vKaffkJm0+iGqsGlluiKGi2AKu8ADIywSMtlUtmHI8r2KxdtJS2hPi+PceAY3XFpT6zpuNkVDbyitVDPFYsrF8gYT8f5MYAAucvmS4/EY9UkiMoRycqvWqzaP8cqy5RcViUk2V6xxDEOlf6g41LbIvTWXHPN2uCGa8J3cE1l1ZY1CCHB87/+9a81lzT1SfUXWdHVj2ICKU16cM5cO8WB8pmupZILMfDiOrA/RDeLrAwgF3r2peccn9yMVRZJNVvjIFuDPiVmUrmZOBhUX+SYFBIgEczvBJMzEtJyC44uwboPYmkeCX+5S8r6x3EjVhHo9JV+Z1TNu9fWi8OOvyHRPTRa66MLrwS+JnyidYi2UsKsRq6kMXY3X06m0cA8il3o9iCe84uZv+tl0gVNbMiimv/Nzrc9E27Kt6Dt6T/cQ92woikZG/dfUaytXK1ZlGzQlIe2je6++d8t0O8k95L6FuTLzum6qcyXr4npBxauxnQABkb51/wREGOJlZUBrwbTcq2Ri6NcL+XOqPg2DfAVY8QfiGKP4sBNiZfknqjMuBGJGyWjkQux/pT4/ijuZJnQHxbrKkEJ1qMoThVfWMYlUKVIEA7sj0E+AxhZVeTOqiRHEtxyzZOY1mca1CrRTF6sS/Cq/REyUagysM8P6iTWJdhZ5GalUjn5xBeCY5BIYuHY1H6qDyortIS93pPVqMgNUkIzCjqV1oiWNmAfSl5F+yo+ScJH4ph9KVZMLqOaRNHAXYIrb2FiPVyCNcjXhMCSSy6ZNthgg6y9NXGjOpDqv8rKe/PNN9cmOOLnUbRFd1gJaU1ccN5yrdX1ZeIIMafBulzlOVes97RJtO6o1rFEnyYXEJIk9aIdlY1b1yAmUtIATu/JMhdr1LJPxcLT7vKa0D4lyJW4S5MJ0YVX+5K7uhLRRJEisaHsxoOKYnO1xEmf+BsX+4DEt94rukeUpCafNTWK0ShQG8XxNiMmjeqmNTIK1Ua/s4rXlXdDK+el+zOKR7Zlkk1ipVOoNBP3U5HXj+LOFX5hYVQO/XZEodooAZfQ7x6TXLKm6re7k8mdjOkEFq7GdABZQCROiPs75phjJsQYyV0RGFAyuNQPvQbhsuQpq220ikrMyBoUS4zIfVDIOhUz5PJdGpDrWFXPFaILnESwrBgxs6rEYLRc5q25gs/Yjj8/uXsqfirWp4zWJbVVTHoTLcmyLCsrK+0Vy4PEayKXTwb4SkBTz9VM4iJaVEGZeHGhQwAqk3Jsbwk9Blx8B98lqyKDQlkHhbLBaikS/vmyOyCBqRqvnHfMXovVRDVJZX2VVS7GrbJPiT651Mo1WFZ+tWV0q5aVVbHMPPKdiNcI6yAUEYgci86HfqCyTRIjOv8o2GXV1fnKsp7PZsw6KqWjjNVyz6WPaWKC/V955ZXZexr8y3NBNXyVJEqCXlZ/rn0UUZr4Ufsr2VLMGqx12Z/qfup+k0CNJXJkOdRkliaQ6Ee6F6Lbtvo/++accU/legzq4DHGnUa333ySqZgYTL+J3Iey6ivZWJF4U6kZ7ndlS5ZAVf8fdKJ7vM61XnZz0GSmljITFbQnv01xopPtES94GnQK7j2J1aKYW66L3PeVFMg0R5n+o0htVoIOuK9iTKr+P4vWi8mdJGLj/VeU3ImJ2lEuQWT6j4WrMW3CjzhiQQmUlKBFf9KKoZLLpAbXGmArgyl/RAzy+ROIrjwqq4IlpSiWVGJOoiTGj8q9UEIpWplimREGD7HERqvWU1m+ZAVlOxVEp00Ut6SkQDE+T+cst0i5+koIxzqvOkfFacbaoMB7CBRZUpU8qFEsnyYKlOhK1gXVh8WqquPPWzs0KaDrqrgfZfSNM9RKohTFWd59VNc0xsLK4qnJBFC2YMX7KuZXExFqH/UvkLDj2JWMSOcq93AlAdPkQBSqEnda6g1K1M84T6yUxx9/fNZ20b1ZWXhlaVb/5DPN2qvmscrEMOhl/ThZItd02kpJWtQXlPGX60FbXXzxxZkrvjwelL1XdVeVSVkW/xh/Lgu/2lMiWu7AMbGS4pE5B9ViVkIlhQjErNfaRhNLiuPjuscSPZpEkaeGrIlKtKZ4tUFCbr9KtKNrmBepEbklKv6SPqF9MIEQPUUUJsG63PdY1wexHVohL1QbJYlSRngJ1aru3/zHMOEUv0u1QDsR/8z1lRtwkUeKMm6r7NIgewYMArFWavRyaoZqwUehqkRt+t3RpHGcoI4T1nHRZBm/vaqDHNfnc7xtjOkmFq7GtIksSXlLgGYgldCAPxFlIGWRi2bR4ENJdGTV0QBDtS5lPZNFtp4LmYSMMkjGhEVK7BMtsqpbCfnaibJ6SrjwnQgoZu2xZHFOMdW+/hwlqkT8c9R++VOVYFJsrdxUZUnlc8UpkmBG7SqX5kYoCU60qMZ2pw1x29SfMddSmS01yFZMoa6N6j3G7+aco0CNFjSJQY4jinZduxiDq7jHKI7kgipXXw04ZFHNny8onlJiVS7JbMuxK5Y5D+cnoRpFoeKldFy0G663lGJSyR3ep6/xfbLSS4TTvkogJHdAZdtWv4oZefkMUSJ3WbmU0k4rrrjihAEd7aIkO/THO++8M+uf0aoPSobEuoqzk6hSf9R1kEeDJnNYVxMrEvyyhMbSNdwHcs+OZVhk7VA7xWse7wuJVSV447Xi/eQCOyhwvJwvbcNklZJk5cvDFN2Pqk+rOH7QJBv3H0jMSqwqvlvZoIeNmGQtZoUuQveKlnZFJfcVniOKYQT6n7JLt4Mmf+gH9WJvOQf1437HXA+D1T0f712vjJz+s/NeBjGRHvdm3Ec78DunCWKOTccaPXWM6Rb+5TCmTRQ7qbhL/igYWC633HK1TLMMouWiKesJP/CxXIcsZfpc+5ZVLNZrzLuW5uMCZcGRS6XiD2PCIsXAxfdk5YyudXwf4pRz+Mc//lErSRNjEmM2W52PhJ7EgM5Hg34JAInSaGmV2FVWXwZWWJyVOEjZlmMiHp2vRGLe7Te6oHEccl/mXJTVUpllZUWTFZjtZc1VzUdQTLEsiLIeyiok67Lc5eRiHI9T7tRy9WKJliX1Bw3oZcGIxxZn1DVoUfIoDXwYKDNwRHDnhY9impU9WO6sDHYQ9BKSio3lfayY9Isbb7wxa7voss5xkrBK5WcUl6rj43zZRu2uyRkJ3Xgt1X6cvwZj6l+gEjUcN+dITLlqcbK+hLrWUyZnZbjmO2LsuBI+6bX6Z94yLmu3SlLFxGMxURjnH93+Qfe52pNH2kZu2BKrEvbso9PxhmXQJEvM4KyJHc6/WRydflckVtWnNchWQjpZumVNzQ+UaZthS9RDm8XMv43aivOOQlVeE+1Cv1RcfnQ95jeNScCqIlLJB7mHoxiO0JdVa3VUXEjzojEfUtPqZ7GkWau1UkFhHXGJHkgQy3p1C03Ox994Y7qNhasxbSIrAH8++kPhD/22226rJZ3Rn4uEVnbz/Vc8KlYwuobqD40/MgkjiLGg0b1HokBJemTBiII0opg5DYxkKeS7EBzMyiNQZUkt+iPV7L8ssvojlvuwrEiyVsaZYe1PgpVHLIOqi8o5qB4sSKTUGxzJkhldi5W9WVZgWXFk7ZD1MLpval8Su9HyyPmq7IksaWp7xebFhFVK2iNXU7mMg9aV4NY6ciOXpU8JaNiW46GNJGokBDjeWGJFMbkMUnkty51qBGsCRJZtWQoZfEqAxXhtuScrmy6PtKGSCimbsmq2ql+TVZjrKOJ5qp9LWCsxT+wvigtWrG4clGnyg/3hlsz5KluyPpebLxMfuK/RZuwXS6is3Jo40aKyT5qQkRBXNtdYPkUCX/1e564JGCXi4txinLEEsWKq8RzgusoFVGWvFN/aK9TmcZHYVqkVTZw0G1jTNpyLRLcs8PHa026y0CkOOkJbScgrZnwY4NpyPhKqjcQD/UQiNe+90Sm4ZnhFRJdd+hXJl+LkQKsoQZ2uW1FfULy/kof1g6pispVtGsUdNyIm4FNyvlZEakykqHFCq5M3+l2W91Jc6r3f6LP8+8b0GgtXY9pEsan6M1PsHQN8Weo0yOZPh0EY7ykpTMwGKBGgP7T4B8qj/oQkUBslV4DodhsFKoNwrKcMaBArHCtWtEblFfJCU4NquWHGP7J8+Y74J8uxkwBE2U+xAHL8srgoK6gsq1FIScAqgZCsN7LSMjCg/bgGPOe6qKSMhL7WiTFCih9kkWuikuCo3IZEiwYesSSLrr3cTGOZHglFWWM1qJeFVJmQdWyxzEl0+1LbSqDL6kefyQtmkIin3RCxWEfl7s3+1KfUtjofzfzTbortjbG0IEu+spjKkipLIxbyjTfeuDapoz6gQT0CWK60akNZRvMlk+Q6LCu7+p0s43JdVmZduXNLNLEO5657Klr4IxKv6scxzlSWbSWDkhVN96jiu3U8cgOW67ImFnSM3AMq0aLfD91H9BXuSfULib0o+vVc7drqIFLtnBenanuto2Rw+fuk6PdAEy5yAVXpoaK4RcXAy6W4SADIQjcIJXyaoQkxuaurznA9FLKhpVu1UYG21W97vJ+YJOH3t4zoYF/cb/JIKbpuigFXnHYr++ykmMx/1m8UyhNFatFxxd8dJX3Tf5H+32OOh7ICdJi8E4xphcH+VzBmCOCPIbrG8geOxWTVVVedMLjXYFUiU4JI1ozoYqv9ynIk18Io1ER0S9RMrJLksG+JFg1imClnaeSypu+Nbq8x068GvYpTlQVFcbP6s1QsI+1BiRJm+eXCKtdXjkWZJZdaaqmprEzKhiwrI2igKBcrZX6VKJe1QxYzCbI4QI+lfnQO2rcmIqJ1W5bAfPvEsjsS60r8FGMUlRiDbdQ+seyHaqjmB+ucv8Qh63E9//a3v9USR+laSNgpDlmxpVpiv6O9Yr1UWacVz6u+IUEra6QmDFTjFIH6xz/+MRMi6uuc4zLLLJM233zz2oCN76PvySrKMTJxIcum+qyErLaTtYrvk6uhrjH75PyVrIl1lbmbtmJ/0Uqq7L8SiLFGrQZ/cQAsl3n1H4R2vCa6jkrmxXbyblAGZL5f1nKOX7HV+m6VctKEiKzrrRLLV+lRA+EYax6vaRwo58VsvH+16N6XYOYcFGPKOeXd8ItQDdx6NTslepT8apCzuEah2sxiJk8YWdN7VfuSfofXTH5yjt/gVuOjFU7BPct1i14zccImWotpIyalWhGZw0Qz66MSs8WJIN3jmqAsEpRRpOq/3YmqjGmMhasxbcIfDYN4lb/gNQINi5OS38gyJtHYLCmHXIJkAdSgNC9Q5bbKAIPSIwwaEKjKiMtgkQF+vcFVdKmUqNI5REuprIFFx63XcnlU+QoN1JWMSCKVYxLsX4NgCTYdT7TUcZ6cU1GbaTAkCxHPNdCO4kUusxJwGjzpHHV+Mc5RxNjFGHspwSs3LllDo/iUJTjGQEsUS/hr/xJrEkGq+UkGUK5rUV0+xbOqTqiEqgaS6nuKU9WgSoMuCTvti+00+JIQVBZbLDX0bR5lEVPcnAakTBjgZn799dfXMkzLFThfr1QutRyjxCCLrDbKFM2+6TuIR1l/WV9Jzzg+LPf0Ow0eNcCOpaXUr2UdlmeArCISqrI6yt1bnhKapJKA0XVi4B4t+fKKQNgr220cxMoSK2t3nLiSqJaAjINkvY4iQJMzalt9V7zHosVG/S/WoI33fz5WXJ4N0TVdAoVF36HBuI43usxGd2+tw/5loVMZH01E5fcVn8fX3RKB6hP5UmTNkEVdFlUJll7FWdLm/FZIPGqiRq7n3EP8FtQTk7L4K8FWkcBUlnslbpPA7Seddn/NLxGFY8gzJR+3rP/oerVSY06CQfcoMGYQ8V1jTAdgUM9gJw6MsTDhjisxVA/FxUqoKjlLtAbKNZEBglLRq36ays40yuaYF6haJKaKBoByfZSYkrhSuQ9ZUxEx/AnLPZd1ZalV4on8AEDlEGSFjG6ZGshL7EQkAmVtU+bd6JYrC6ZKAWhQrG3VDlG48N2yKEnI6XglGPIWVg3sY8IerR9ji2WRY2JBLsuykEaxIuEmqzLb6PzicciNWOemJC5qO7meKotkTPIUJwIk8GJtXl0H+p6y/sqaIquRRCTilO+in6sWsK4R333zzTfX+kOcDIjXnfeU3VjtLWs1j0psprqfemRdhGEsFSN3RpCFFTQZw/ewTnSrVp1VnbvaOlqY9b4yTHN+9H+Vv5IlPyahYZ/qz3m30Cgo6j2XpTsvniSMlek4bwXLT1BJhMc6z5ociFZaxc4ri60G1+pbMZFYETpmTVzEyYr8bx1tw34l6PV7VpUiQVvmebwXNGGjCaW82M6/FyeromVNaIKgU+6v8f38taYvck/G/xqOi6zcrM9n9ZAXhrxUitpY97/KflW9Rt0Qmd1C/blbtVKNMeWxcDWmTVSmQxYMLXfddVfh+hq8KUumhCrEuoUaSKg0i6yVjVx9o6CKLn4SJq0Q3Z44RrJOMvjB+oVY0OCN/XJcWAKZ5ZfFWVk/JXY1yJbLqc5ZA74o/JQ9Vtto0aBB4idaoGMcahQt7I/32JdEpJIk6fvkyicBGmMyNWCPg/ZoJZPVVWhAK5HDQFHxtRJvccApcaT4WtZhfdoyuvjFgTbryUKlSQe5eUaxrH1Gy7mSfSlhExYY1lP5BRZZ8+VqrOOVNYz+qIGzrk20zsjVlONhUkXtKXHKvpWMSfuVBVZWeiXWQhDrO5QZWRMecieXoI7xn3LR0/0gSzr3jKyS0dqsgSjb8v16X5MuOl8Jfwlf4H5Ydtlla8mVJGZoWxa2iXHEcVFceyydJPEkC6wmQ+RGWO/3pyhWWZZ7oX1FoRyTXOk3Q79nHBu/Q9FtWL8v6iOaBNI9Kmtz3l1ZFmuuXaddIVuNadQERBSorSTHqZfFlUUTGYrNzwvMXsD3c6/EBFccC31S2V6L4Nw1OSbLuybFJBDp35rA0m9JFYvlMMRZdrpWqjGmO1i4GtMmGujlByr8WUtcxcQlDOL4U9SAH6GCINBAKorTeq6+DAYk2vICtcoMNNtrgKISNAx8FI8nF1yJE8Qqg1pZaSRClbU1xurKgoaLKW0g0SOXtGiNkyBWZmVZJyHGZikDstpGYkWunIozjbUeZXGNyaTypYCie7QGLRrcS2QqTk3HF921VZsxilPFMCkmTG3F98vSwQSAss8ywI/nJBczJXyK4iRfiii6D8rKJouPBC3fgajU4F2uzmp3tlFcrqw4UWypfSVidOz5/s6Eh+JN2Q/fKSGl4+U7cfFlfdUbpP/ouFUfme+S2z3fg8UT98eYpVkJs3Tu8nSQkNYAWnGg7DMOMiVoJLgkSpRZl/0rjpcYXmW9Zr+aCMiXrZH7ZlFCpGi5kRtxkTiNydlAfVXuuHGfcj+P26itJVTlaRH3ESfcWoFjp68zwM//9qltlZhOE3Oa/InhCHlhk7dwRhEY+3az5/IUiQK11dIgEuYxLCOWB8tfm17Ea+ZdpbXw26HYa7my8xuOi7p+Y+KiyTGuHefJ9eFe0rkp14DqY3fTmtlP4mSdRGqRh0Ae3etRpPYra7Ix44qFqzFtohlniQOVdqEciJLOMFCg7uXf//737DV/nLynwuASqbFkAUSLSN7Ft+osNgMcSqOwqAyPrEwRWdP4Y2dwxgCJ2ClENq8lliUaZMGM9WPleihLmywT8VwY/GuWX4l3ovjTAFbWZ32/LADRnS5aBWLdTB2PEu5IiMpdEnRcEndx8BytdhJH2r+sjBrk6dposKj4U4mSKNoV/yfxyL5UWzQm4mL/KkIvoSFhJdGgNowiQsekfqjyP7I6KqkWfU/nr0ROMdY4To5I5Krfc4xqZwla3mPyg3PEGhTdp2MyHvoGbcHkjcQv66ieIUIQYSvBjliVFUl1ZiXYlDEb1Cd1PdSOGnDqOkRX6ehOruvAa5XIUfkQuZ7La0I1YGVpzwvJsmhSSn001jpVP5TVWm1dJHhlodekhyZw8pbffNbuvNjTeSh5lvptkcjVZABtowG9JuGKjk/3Xz7BVPSQ0D0dl5gQTfeCJnPyWbUbuWXHSRu1s37L64njep/FhFudcH+Nn+V/6zlXki9x/Nwf6udMFiFG8+uqRnX8f4m/ewr74L9h1JID6Xchuvu2WitV95Z+N2K2eGNMf7BwNaZNNBjSAIpBzO23355OP/302p+cBJdcs5j1jtk7NUiT22O+3EUVGPTg4otAZUCjR/bLgJ9F1kxZISWmlVRF8ZkSCHKZY3AZ431irVINCGMtynhOEnay5Mpqo9hFCQm+D7GMpU6JciQQJdokwGRJk6iX5U8iLGZ7lTVNrsuRmDBJA0cNkkEumDrvuF6caOC8sVjEOF+Jfk0GyJVT4pNtGfDL0q3PYsyd2lpuqLJCy3LLY3Sx1kA+itwoAOS2rnhRCdZo+YqLxEa03EX3apX14buxyut4hdyBaSO5orKdEj3RLvQ/iR+JdAlW9s1+Y5KwfMKk6EKsbM6K49TANdZCpH/LPTduL6uT4vrYPlriFDfIhFRZFAcfxan2Lat3zJDNOTezGKr+sNquUxlsuQbc//RfWVdjCSOFCEj0RVflaP3No/00Snqk38ZYFzomlooJrOptHydYYoZvWduLhHH+HhkU6BfcM8TLxzbl3sDKKjHKNVF4Sb28B7oX5Z4/KhSJ1GZu2/pfi5ZUfiMG6dobY/4/o/NrZUwfQYzEpCoMxm644YZMTOSthxroK/tsrNEp4SYXx3rZNKOwAAaOEqdaKDeihBDK/MgAmAGN6k0qyVG0/mmwqUGz3IGVgCSWxslbQBjo43rGH388D4kCPY81R5V0R7GDsibFDKkx+QuLXDZZZAXUoF8iSq68kZhYKVo6oqU2DlbkBiyhqYG0yppIFGsgLMFNG9999921jLmatIjJinQcHLv2JwuShLjciqMVlGNUKSAy+qo+qGJmta8YPxwzxqqvKUGORJ36H0TXQbVbTEQVufrqq2vxx7IKR7durgvWV5J4KUaU41fiJ64t/RABGJMT8d0IdI6RyQvFUcv6GGskyiUb65Pqo4LcAWXZ532V0lHiI527vAOiRV6WdQl8xTC3kmE2upzmBWpeKChpFKJE90IzF1Qlc1OpqE66LOr3AuGjGrOg71BJJKx7XKMi4RhLPeVdd2M8b3Rr1iP3gK6P1o0J4vLkPT1iiZE4eSHqJX+rt++8lbfekv+dzj/G52WhDai7HYUo54QnAH2eNlPmen5viogJxEYhWVCsO617vRXX7SKROkhu0TEEpN7Sr/Uarcs9stxyy/Wx5cw4YOFqTBvcdttt6ZZbbskGeRJi/IAr46tKPmhA1ezPUTPDRX+++sNgIIY4xDKHRZVF5WQ0eGLgglsyg07Fo8rSK4GoY827vGlAKTdXWZz0587AK5Z0ievxXK6BGuzFJDSaAZfLarQQKiGTXO40kJX7nWJWldgpxqbKkhgtgLKqNSNaE+VqG2u2MjCnvRXnJqusXI1lqcYlFtGhGX/FvGpwrkkKCSu5nWq/+di/aOmVK6omRaKlNFqkFHOlNpf7tkSrsowiJOU2rc/qWReiN4HcVLWo5m3+uziv5ZdfvuaOrlg8iQV9F5Y8xUpLzKmt+E7EP/uVaOQzxefyPXJ7V/3b2Kc0SAeOEYuh4jJlgY4eArKWx9rLzWqU6poVCdRGLpdyF49uv41cF6PLuZZOu3Ty/fxuyK20yErFMSi5WjPhE0MCGqE+pNhLCXddD85VsboxblfhAjFLsn5jYwIx+gv3pq5z3jU5/zx/vfX7WMXtu1n7tCJyWZRBPm6nOrpY/fkfUhhGnASVu6tKjsmKOEgirVU0MabJzVgarEhQ6bnCP+Tqqwk9raffjEERh8PMKEyGmMHHwtWYNqBWJYMGBsEaxDIoYOCO61b8s2ql/EFcYqIMDTx4VPIXudrhlhytGTHxk6ycEmHRugiy7km4AvvHciUrhYSVXHijlZXji7VRdVwci+J2JXAkKHT+cpXVAFmCTYNdBhiqIcqjLG2sr7aOGT5jNtN8kpeYFVX7jrGasupIgMkNUkJRgyUl9uFzBsOKG9O6EiGyDmnQFM9JIl+WPa0TY241AJfFl/3n6wNK7NI2sV4wC+8jTjUQ5/uY6FBW6EbIKq4+pYFd3lVVx4PAixYejgPr/yqrrJKJUiZ24kSMLEP0DU1SsG/Fh/Ke9i0xSlsr3pRJBM6Nc5JnAAvfqxIutAH7p5SOythEt3aQKJLYj2VrYhtFC2xenLYqAOQurgF3M4utrIYSqZ1y+y2CtmqUqVyJ2+hjRfUpW0WTL7G8jyb7BO0pS3x+27zolOuwrLqa9GpE3rqr5zqufJhA/nk+VrsdJL4bQRsx8Rj7C99N++BtwW9/PGeJH00esR7tgrhlP3kBFZNiQfTiKXqMS9FnkaJ9ivzrvHhTlmr1EcXlN7u+sdZ5/F9gf+2WXTL1if+1xnQbC1dj2gBrT0SDIYmYRmggJMsCwoIBuTL6MuhQHTm57fLHy4BFf+oxuYqKoav8CsTBgMSqBmeyUICSzWgQH+NFIYpVFmb6ldWV9ZQoB0GiLLMaSLKwf7nzavAR49ck7pQIRwP2fOIUiZlGREGYf5RokUWUwRzHHWt7xnhaWXR0HWSx1kBK11oDZw2cENtxEoO2Ysm3cRyMg7LhSqwqsRB9QetxDogI7Y9jwpooKyTiVNcUwUFfkutsRMmJostt2YRCsrBqgMixqa2w+Auuufow/UOJflT+SfVdOR9Q3WJZlpkEwlIck3zxufow+0d4UYJKEyX6XgmPfP+iTSRWdb3yAjW68beK3H6jUG0mUJR5uxtuv0UoYQ9Lkcss11JZ0HVNyrZBUQ3aVkrEyLqsSR5Zylq5DvIMkBdHrOscPTuqWoYkNuXqH0MNNLlXJIyjV0v+s3rv8VsqoaVJSnli5MUqyONCtWQVAjLIaNI0xuTrGuXFUJyEBHmQxEUTdVpH173RhGYvzrGe+C9a+rVeO/s0ppdYuBrTQeHaCogQxASDQrl7MTCLAoKMkYqli4OeOEuvWEe5P8ZYPQkJxYBKJMXSDhK+sjLpj1xCQH/4GpjxvkrmcFyxbI8sbtHlWAIoZrrVYEPWMcX7ya2TRQN3Jc/JI1FdT5zGbRQrxzFidcBypyRJEp8S/2pnjleiTsXnFXMp8Sj3WR45H7kva8BNG2G1RmzFjK8xU2+cOFCcFvuUlTnCdqoNKisK53HfffdNJYrYv8rFcKxcKwbAeZFapoyHXLXlahetGZy7yhpFEQqqr8v5KZ5alm0W2k8WdW2vvsG9RV9Q6RWsp+pDsYSNxKEma+Q2Htsj1k2mXWR91oRJO4Ov6ParyY8ybr+cay+S43BdlLCnKAayaikUuaXnLWStIJf+eO/Uu+9boRVraBRKRcK2kfVWvwFCv8dF91KcmCwD/YgJNU02KUcCE5qqsxsnBOVlQF8uypwcX+v84/P8Ot10WdVEXywNpbYrst4qPEATn3ECU94vWlex6M2EmIheOHpsluk5TlTksz4X5UvQZ/XinC38jCmPhasxbUACJA1mouuVBt+KReVRmWBV2kSuvUqwk3dj0+AhusMpyYlcKvnzY0CuQY0SFSGIlQk1Hl90eVUMH8jqK7c5oUQqfA+fkUBHCWSiO62sj7EsRIyflFiNMWk6TpYYs6rjVRsqvjZvAVMiLA2EGJBHaxyvOVZZSdWuOlZZZ2JMbYx9jGJd1meJVVk2JX7kdsq6XGslP5HIjvF3oAROio2u/SCHQbFiONmXYjwRcFgV8y5vHJOyUrMd12zSpEnZ97Ri5YrfH69VHHhrYK94VcX6MhkQLTu8xzWQi7DiF+VyrXI/yqCtODO56/IZ10GTDBLKEvnaZ5zYif1cbrayGMqDgdfN4i3LuP3qXmrm9qtkXr1w+81D2yoruBLI5VG/bSW7rFxqozW1VQs91zcKVB77ERPHPaiJsVatt/UEbidruPJ99Hf6ve4TrhfXRRMJEjz67VEd4W5Y5aJLsR6L4jWL1gHV/M5b3YvWzwvmKFD1e9QvotDvBnkLcCOR263PjBkmLFyNaQO5HuLWJeuNauttsMEGtbqIDPQRqK0QXcb0x6KBnspAaMCnmV6VUZGA1QBBM74SdLLwxji/WLJFCS9UtkcDVAa9strpGKJQjQNRuWtF4Rqz78o1U+vnxZ0yAnM8iDt9Xz6ZhtyRJV5VOkbHHAfUsYSGhGmsEylLs6zTMcNwtDbSdgguuSwr+RbtXi+7qpB7sqyORcjNmEWZeZWQiEGt3MBjdmJlyORYlcClHrIUS+SpHWJiKmVBbtQ342AzDuhlxWf/XDv6vUSTBn9cf1mT1HfVbjHxVBRR6g+axNGkQswkTX9iMM/10USRkjZVRW6/0fV30Nx+i+B4aXfdP0XHKA+HouPjuuoei8KjFaHG9ctbUWOG62GhjPVWvz9QRUTy33DrrbfWYrW5Jngc8D+iyTr6sjxeBs09s1GtVK67XPLzNKqVmhe18bHV99r9rFdt18vvK6JTophrjUeLMd3EwtWYNkGgnnvuuRP+BPnTxjW18KYLZRViJmANYuTqq3jQ6H4oa4FcDBGrDHDYDxZGWeJYhwEV7zGgYEDPurKcymWLrK24pSmeSi609bJoaqDBd0eBpYFGdOOVhZFBq+oFysKmQbGS/qgup4QnjzE5kF7nrRzR9UzuffHzKDxpM45X8XISP5pskGs1AyzaS3UeiwavMcNxPWuA4jplWa1nmeI7ZVlV8hvOgWuHhZt+pDbRPmSN5ZoqSY3iU6N1CNS3YnItXjcavMXniunT4Dy6RvI5NSVjoiWV7bjgggtqcb+xDIfcw/MZoOWyq0kP3RfAudNO+ZIo0fKtyQOeVxVJylwasyY3cpvkeGNMdq/cfouI7vtFVmBNsrDEckWxBq5EKtewFXdR3TPRiirhMQ60ar0tgjbm3sYzgesWrxN9WZbWsq7bg1wrVX1EIrVRrdRoiewXvRDHjT7rlst20Xl2wnuA32MLV9NtLFyNaRMGarL66Y9WA/yY5VDlT/JlcfIlGfgTQUCyMCCQdSRaMVQ/kUEDlrg4UJUbKmhAxWCWGEEG48r2i0U1usPxvTqOmHhHFhO+j5hNiT8JaVlOo8iTWJFbpFwMVR5GCTh4X6690X1a9WSLEpyobVU+R3Gp0YIoK6REkv6Yo/urBpwcN+ekkkISw8oWrAkGxY4yqIwD/wjbco4IVSUhigMUrRPj0hR7qKRbKhGj2Dadp8rEKAkJ6xdZkNWPWo3djN+hY8y7BKrNJKzVPjFbriYd2EZ9Xf0mWtdVt1aWayXN0oSHauEqdjufPEhu7gzs6Y88qhRTWZQgKp7DoLr9FsF1o+8owVievKVOVnEmq3T9WqlJC1yffNKkfrpwDiNKisU1Y8KH3+4o+OjHyy67bG0SZhCs1PlaqarVPOy1UltBE5/9opHVuVdiugzjMmFl+ouFqzEdQINCidCFF144veUtb5lKCCluqdEgmv3EGB8lf5FI5DUleBB7sZ4qYokBrASIYjsVDyuRKiEYs2NqEC7XZw12ieHFXU2WPQ3wJXRkoZKVViVf+AOTqIrZIvMJUPJ/jLJgyWomMaoEMLHOaxTXss4pYYdKusgtNiZvkkuwBt+yamPdLLI8cg2UwArLNBaS6EYsC7IGdtFSoOOKdVxZlAVYyUliuQa9p+sESuYj4SjLtyYLGg0Y4n4k4GMfiC7part8wpZYakl9ShZwzoX32F6uu3LXjWWclKFW10vIbViiXVb/iMp7sA/6JP1Tcb+tIjfoWD+1jNsv/bKdcjCdQve2Jp+Kfk9Ue5n+wbXiGmEFL3IbzkObKrYwWlP7ZUkedri3lRRL9w4TB3FChvtlxRVXTEsuuWRf2zn+T8UM683Q/0YUqYMguoedQbQ6NxK+Fq6mF/ifyJgOgNUHZBFUjF++9mWeKCiVoTX+SSl2j4EAg9UHHnigZomSG62ytUYX4BjHCAyWJCRj+RtEKWKAgZMSIXEMikdi3zfccEMmJuSmqz8pWTA1YOFY9R2yiOpRf2gSb2zHOck6GMvh8FqJPeROrCRUajMtirlRO0Yrt+IblSVY3813sD5tRntKKOrc1O4SLEoWFK+lEmxFt8pouZRYl7iNtXAjEoXKiKnz0XWXi7UEYRwYRNFflOQkuvSqjST6Y8bLfIbLaAmX0Msn4ZI4ZTusQzE2meNlAE4JG/pRfjCjbYG+zIQB/Sx/r7Ce6s9KrNazdBeh0kJV3H71OEhijXtQ8cJ5d3lZTZUoTKWxmhHj58uWnjGN+x7XKWZwpu+pZJjyAnAfcK+w9FroqYRaFKqtJNqS5V2/+0qsZ0aTfludjcnjXxtj2kSWRv3py52TwXY+ZlCiShZECYK4MCiVGyv7xMVXroAagMtFU+IoDjQVdxUtbYoFlDBV3cpobVN5HbmpyuoVhWIUdnLBRXxEl918sgbFj8r6rO+UezEwyFPG5Ggp1fnoUX+ico2Vy290NVX8Jt8jt1QW1qUNEUkSw4j22G6qJararVGIs43cMjleuVnGTKOgGGXVcYVYS5A2k8Uy776siQCOg0GtXGclqtUmEp2RKjPz2rcmQjQpIkuLLPRCcbJyKZdljmOlTy2++OK1CYZ4XJwT67A9g3k8BrgO+YEy+2Y9xDD3D321VSunSuNUcfvVpM2gWQxUyolFEwcx7pvXav/oxl2EagJ3qvSMmQj3EX2aa5W3hHO9sLLyHjGAcqXnfilKWtRpFMcchWqzSVVQQr0oVPuRCdoYY4SFqzFtIldWWQDjIFGDQ14zSFf8osRZHLjLHZJ9MCt/xx13ZI8xiVGMpZW40ffJuii33JgtFiSGNcCS2JMok/VQYjtm4dV3yNWW74i1SDnXWL8uCkuJnGj1k2U41hdtZA2TS2zMWKzziq6sMQ6Pc+XYKS9BCRmVnYnWRVmeVRpIGZh1/lhLEKscp7LaRlEtkSoRrsy80eIcs4cqvlcCNYp8jpn32JfcWhkAN4szivG9eRGcT37EesqSq5JBcl+MFnUdl66dyiwpcZWEKq+jQI/XS4Nz9kc87o033pi1Y949l21V93aRRRZpqWxN3u1XNXBbcfuVNXUQ3H6LUFI1hA59LyYqUzxzzMxdJDwHpfTMKBK9JOK1UXx3fl3lEmAiRjkHNDHTDcu27o0oUluJY47eM3p0DLMxZtCwcDWmQ0jQRIGG8FS231hzMtYfBcVJqoSFrHFR6EUBCRJ7EpMSBHJLleuwBIfcAFmX7WKNPVnzYgwlzyVSlC01FlsHiVzFkUroRFdVDep03rGUjUSS4mIllhTjK8tudGuNrq18JyJEMX2KcaWtGDDS9iBXWwlKvcf2HBPZPVUXVImxFMsbr4Guldx/lQyJc5TAk2iQ1VVWafYZr40Guopl1iA4uvzGc41ZdnWN4oSA1lGb8VoDV1maOYaY8CpayGMCJol5ZY5WTKnaUd+viQktuha06X333ZduvvnmwvqhEqvEgkusNnI3rOr2GzP+Dqo7I+fBOdEHEatMbOm3oij2O5YPipla46Nd+9pHHiBFmc2bod9k7jfuHcG1wcpaxuW9EfQRTTpKqOaTmRWhfAlRqPajbJMxxpRlMP/JjRkyEJtxIM2A8tJLL80GpIp3lIBTploJDlmOeIxxltE9NGbB1bYSdsrQGwfmMZsoQkJuvRLLEsxsj7tszLSLoGBRFsi8UFSWYQkuuZvqHJUMSoPrWGYjWisljnUeGnRHl1jIC0dZkmTdZP98L4NEDfwRinKlVDvK0ikRrMmDvAWlyMIZE9bI5VrCVEIRopWa48HSGONX9aiJBAl2XfMiMRZrGuraqn0kQDlu1d2VS7kSfSkuNbZrdDmO11LlZJSsSwI8TkTETNOyNMtyT7zqddddl4nk/LnwnewboSqxWk9gVXH7jSJV/WPQiKVnlBGcpV6SJfU3WbbHufRMN9DEWlH5rbIZVfXbyfVisoZJyzjBgEcBWbCrXi9NbuZFaqMJHH13kUh1vzHGDCMWrsZ0AJXw0MKg4i9/+UvNbVcDbw0WFBcpcSXLV3TvlEUvxm3Kgsp6EogSfsoGjBWLRVY3Df4loCBfN1YDLgY2INdQCZponZQILcqSLEtkdOHkmGXJk9iTa6sEkeI+Y9xvbDdZcjnefDZixfvqu5SlVwJSLs4x6UyMPea7ZGGM10DZhGV11nWIGZljrT29rzhR1pULsq6d2iAOaKOLbyyNVE/UKSuzzhuRyHeq7WL7SFRKtMqSrcRPcjfVdckPZjVYZmEwXhb2x3cgVEnWVFSPsorbr2oZaxlEt19dI90rmrTiUdesKKuxaiEidHR97LZZHd3jRe69rSQjisTfsbjo3uEeuffeeyfsl/6JlbVMH9XvYbdrpRpjzLBh4WpMmzAouvvuu2vWO1lRGTBItCmTbhRqDHYYyEt4KpGQRB0oRpLPGMyyrtxJFeupGrFYTiU8EQByT5VoUdkR4Fj4bjK2qkZsHIhJTCjOEjfGWKIkllOJ8ZjKPiwrpEQjx8pnWCFi3Kz2ofeU4CmW44jW4tjmij2NdWG1X8ULc26yiioWWbHFtHWMnZVgVOkZxcjGLMrxeOP7cjFWHGz24xoSGHFtWHSto5U2ki8vEOva0sZy91U9XPU5idFoUZUbNQvtQHkalTyShTS2W/5axPfKFKeXWEWostA348A5uv3KjbmZ26+uySC6/cZJFwnUfBkRrhPXLJ89WdcJkUHcIxNO3OeDdH6DTszoHeNNo4dL9FiIz+M+4qPukVjrWd4lcT3uC/Vlrq/qZwO/N0zYcN81Iy9SeWzF4lskUgfR08AYYzqF/x2Nafcm+m/sZLTiMXhAGGrQI/HFIpGq5DVy51XWUGWalYBlXQZhiD4GvtpesYgMdBm4MODBVVZxjELCmYENQpUBMiJKx83gTkmIonU2L071qOdKMMVxx2yzGsjHLMkxnrIIjk/us9Hyp1IfElg6PoljtqOdFRfLedEeSnKlRDcSSbJksp3q37IvWUE16aBETo3Q/lmXfXAMEh0q5cK1jfVG85bVmHAq1rmV66/EDou+ByR+dRyqo0hbcAwkfqEtNKBtJISiK3a+Pl9cYnKweJxR/DJIl1gtcvtV9uJhdfuNMYUSqfUsYXIXVwbq6N0gyzf3o7LMxu1ibDUUia5WPxul9eNvS/6xzOQKxDj1GK8e49Bb/S3Iw33IfVCU3ChfK5XHVo49Xyt1kO4LY4zpFRauxrSJXG5VFocBKW5+6623Xu0zJTpiUV1OWSHJesvgNgoXCVae87ncVpVAg0ELVi0GuMR0Tpo0qZbYSK6uqgcaY+QQDWQrvummmyaU1ChCCaGiKJeVT65weeuFEi5JyCqeVG6+sUROtKBJhEWLoSzFHIPEAutGMS1XYAlS3iPOUkIpZlcuyqDJ/uq50kW37bjwvizM2k/M4osQYXJAscVxiYmZNCiWpRZxyuQBi2J085ahWItWyZOIm0Mwqs5p2UygMeFVVeRSrNI6xG3m3X7riZEYuxmTxPCZ4nX7IZjoO0XWu0b7kLBV8rEoiFg0wcF50u+4/iSxMhPRhFgUpvrdaRbTGdFkQVwkVLuRwIpru+iii2YTVp2slarfGGOMGXcsXI1pEwZHxDBJRKk+KAJV7luqYSrrJkIVgZJPniOXTwQAlkIN4hUDKJdJ1QXMu+OCRK9iSdmWfSnhiNyVJUrzj3JvlvVU1rZYpzUO/PhMglSDwnw5lVgeRUl9ZLGLlmYdB+dHG3HcGuyx6PjYXnGp2hftI8Gg6xJFnEoUyQ1YxyZrrRIOKeYz70bMcXFMLHyOQBWsi/VMlmyher2ymCoOVddE+4suxvF4NdDmuBCmCFS+g0fasp/JeTg3iW3El7JhN3P7jW7gujckUln6gWIg86VnWkFZtCWuJMTrJe5xWZr/TUzp3s/Xs873oVh+Kp9gTNdAVuzo3htLNcXt8vto9lkr62uyjuOn9nb0kGjWf6JIdekiY4ypj4WrMR1A1lElZGEw8sADD9QEp1wqtWhgJsEnS6wy/io2MpYZYUAjkQtK9hEtj+wPcYeVVkIvH5Op75VFVtZgid1YwiauK2SllYVR1oBotdOgPwpq2gFxo2OBGFOpOEAlGpKAlriUW7DqfCoJFgIwigwdh8SChB7bRXGarw1bD8SZMr9CtHwgHhGsHFcUzxKpcmHURIWEaj7OMWbnlUsgVhu5PrMMgmsg117nwPlIfNeLx1PZjTgh0M9zkKtpswyyRWJFfUr3iRKyqWySBLnWl7eDPCzaEUXDvH7Mqq7ft1h3WdbFZqj9ixIj9dIaGRM9yRrfaqIn10o1xpj2sHA1pk0YsFB/VSJFQuy2226riaiiGCwGbAgTBIriLSVi2EblTFiPAZKsmDEGTpZPWWYlMjXIU+kc7Tc/6FMNUrnWqqyPRK0sIxKxspgpuQ/bcu4S5LLUyuqBdVnJkGRVjTGREt1x+1iih+9DtKtEi9w32S/fgxUSt1wNYGUJlVCtWpuQ4+S8EKz5Uiy0jdyMaRtctckkqmvCdYtCNbq6xjjH6L6IAJZIlRAehAQ9Oh/EO+cSJwu4BvUG5LSNSgb1S0TJJTsuHH+sN1tv/5xPFNwS3Vxjzl2eAJwj1y32Dfqd4tbHJZurYtHjhIDEadnYU4Vb5EVqWRf4bpyPYv9bQb8T0ZrqWqnGGNMe/R8ZGTPkqI5pLEPCgJcMoQyWEa0MXGSdVC1LBmOIIwmbOFiS4OQ5oiFmeZVlh0GQ3NN4P7q1KlOpLIsSwxpIs1+EVb70iIS2Bp16T67OnEuMx5XA1fcqwzDHHGvSAp9z7LLQSrCyf52vYkU5bgQpAjTGDUb33ig2FO/J0o7g47wRoiTCklu1rgmvNfhEtCmDskQdS8waq7ZBwESRynsIG1lSEaqDVM6F81RSKM5JglxuwUqupHOj7enPXK+YuXoQSs/kKeobsvhFkRpFEu1BO+BBIat7RP2Pa0r/67dVvJvUKyvTiktsRJnD85bTXlvkNRGWX8qej37b8rHa4zJxYYwxvcLC1ZgOwCCeAa5iqhjQk6BJ1kJlEWZgy6CI8jIIHz5HqCFgEQYSjorVVEyn3EdlBZW1U9ZRWSmU0EjWJQbcEkxso2Qn+cy2SiKiTMESudFqIgGjBFDRRU/CO1qqonuoas8qvpf9xnq17JN1lPGY/bGeyvnELLqgrM20J4/tugrS9lwTBGt+EMtxIUpof15jhZVIVe3Y6EbKMUmgymIsd2VZggdtQEtfk1CNWakV1ysXb85P8bWcl86pV9bhVkrPtBpfG2Nsi76HduC+rOcKLXdurucoxa2qvFOR9bRVa6OQ50WRp0c/3cO1lC3zpN/Z/DII3hHGGDMO+NfWmDaRiELEaKZebsASeHwu9+GYQVbxjrI4SAAqUZPK3sgNUoJIyUckmIsS4miAz/dEC4IErDLa8jzuO2b/lRBFjGmwH626MRGKXscYU2VSlSjmPaxzGujJWoUQklUPt9vCH6v/ugazqNxNVVR/ESuaLGkxKQyPtD3ihHa69dZba22lMhosWEyV6EnXHSEjd2WWQXUP5HpIrOaTIjGolzswbcB5qH6qrOHdFuCx9Ex8bEU8KUFZFKit1LiUGzRLUcxidO8fJCt5WZQYKW85bTVWM8L9UGQ5jYmRekGs45oX3O2cTzyvQZtwMsaYccPC1Zg2YaAnyxsDW5XGUD3WBx98MN14442ZgEQIKPEQ6yrpkhIE8VyWWWXgjTFe9QZOssAiRBBkfI8G+xwbgzdeqwZqdvP/NxYVYZLfr+Jh4/fHYvcqY8Pz6JKshUEk1irFv9IOrC+0L85ZArII9iWxGuuhlkGZfbUg1MjIzKOuVUwgA4o5Vhwx7cQxRCuz4jqjyy/XblBdRTkXTZpw7vkBvT5HxHMOnAuldmR95/w5x3gdO0W8Ruq3zeq9ConpKFLLiAzuB4QqfbXoO7nOCFXV5B0m9LuQF3LNsj/noS3rWU97aW2U9bTIgtpqFmhRz3o6StZzY4wZNSxcjWkTBjqa7ZcrLYNhSoQgIBUzhRjiMwkcWWyU4AXxo4Q2GjwhGvK1QGNNUAb5uK4Sl6mBt+JB5RYsV1/2yXcrJjYuir9FLOsYVGsy79KrWqagQSNCSPVNlVQq1j7VdhJ+HBPHWwTfjTVPVt4y8L1RpMaSFIgyZcGVtUmxqrLQqVSOrMU6T7mZYjnH+si14poNutWNa4sQlWtzkWukxA1tx3kTmy04f1mOO5UcR54AMSa1VStfrPmqyY8qQoNzZiJJMeZ5uN5ca64xj4NsaeukmFOsZj45Uq+tjUWCW6K7jOAuiqXthzXYGGNMZ7BwNaZNJFYVLyc3XAbFGjhqQMhAGEGG8CEGdqGFFqq5YOYX9qsyMar/yj4RqZS74Tnvx4GcxKrcf/nOaAWUgOQ7EbFY1HD71DoanOp741IkLmLWWcWj5olux8punF9oEyW3aVUMxlhHLfmBOusg7IlfRcBpIkHHjkCmBi/tEQeyEkgxiRLrDIM1JiaMqndN5BquDM9MUkS4BqpLW3WAr2zU+aRJrcQVcnyx1qse24llliu6Ji+K2kXxyPSLXpZYKesKG0VqWTEn62mRmOu19bRT7spFGdN7nYnYGGNM97FwNaZNGAgysJZ4w7Kqsiw8Yq0irpOF95TMhYGoRCaL3HtlBZTVVFl65T4ZY/x4roEf+5NbK98ZM1wqLlHJj/JCpRXkPithhHhGRCuRVFwPcRKFsLYF1pcwQTBzvLzH/rCCRZfjGMcra6qEUF4AqS34HJGK+zGiVe7AEs20v8rrqPwO10klaWg7jmsQ6qa2ilyg1U+K4Fw1QUF/kaUxihU+10RGq0RX6yhSW3VHrVd6plMWPlnaWYpEsyaUmKTot9Cpl0hI93cZ1K+Lysr00nqq+7LdZE+aiOt3HVdjjDH9w8LVmDZRHVQGVghChAHWqtVWWy17ZECsMiEIC8SeBFh05+W5BqdRBMRYRImEWBpHZWOwVkqkKikUAgSR1m4yI303ghBLr5L5cH7RGsRAVFl2VTJHZW90vIqPzVt3opU3P8iV8IzlcBRHrAkAvkMJh2g32iCWZ5ELMiKF9+X2q/jZQXf7Lcp6my/BUy9GmOtP+2iiIcK1ok2KyvKov8niHq3vjSzx9WhWeqZTKLkUS1FyHk1gcN5l3dE7WYYlL1LLJhJSErSi5Ei9FnP1rKdlS8sopKDIejrILtvGGGO6j4WrMW2iQZVc3BQfiqAE3FQlTPVYz1ooQQuKK43xWDwiROTOGMWfyvAgyGTJ7JRAokxM3r2Sc5XVTjGy+YElg+dYtgYkeGQZRXjJWo0gLrLSSZxqYKzESbLuqt1U11blfmRpxiV7scUWqyUXKhLOgw5toHhVHuu53CoLNAvtgFglU3PeYhetz+xLkypVRWnV0jOdgvOTWM1nSc7fO9wn3RZBsS5z3sW3TBkW0O9Av11hi85JS1nradH59ENwG2OMGR6Ga+RmzIAiS6BcHBn033nnnQ3jCyGKBGWuZYAvSyKfs2+JLT6LA26528r1tVODcQaiMSuwYNCKwJRbMt+dFyOKWZWlj2NifURuUdZYZaxlob2UNAnxwaOEarTgRtdhiRRlSVa2ZsQqMbyyprJvhBkCLe+OHJdBsupw7rKq0n71+hPtrMkBzoF1SQ7GhIMEqPoTn6v8EK7ULFWJibtYVHamldIznYB+QPsgVhHzRe1DH1VseTeOSRNSeSFX1tKYTyQUhV2vXdZlES6Kpy2DS8sYY4zpJBauxrSJBssM0hjwISR4DwtkPrMugjSKL2WwBQaGEmuymuUTAilOUVbVTiYL4thUFiRarDguRAEikUF0UQIliW6VjJGglFt0vUF8jEuNMZGKR+Uc8xbqWLJFFlVlAWZ93H9xzy4SoDHerh5RiMnSFV932yJEu0ms5t16QW0US79wXrQJkyUI0XxSJolbxV1XEaX5dlHN314jLwD6KjHRRZY+JdZi6cQ9ko/TjGKujKWxXhkW9bFBiKetYhGuZz0dNq8GY4wxg43/VYxpEwbvCMyYkIgB8zLLLJMNmvNWVYQPg10EHSIMocggkn3gukk5kmhhQQBLrDIg76RYiHGrsa4px4Y44PhiGZi8tVcxitomZlJuNlCOcau0B+0SP8tbbdgvQo7v5FhiXVnEq2I0Y1xmTH4Vl0ZiQ5bdIndTHU8ji21ZQcexKF6VRS7n0UqqCRFZMzlPZexlHbZDxOXbnmOlT+XdyhuJUj0fJMszcK70LwRrkQszxyyxGmOby1AUX10ly220NObLyvTaetqpbMQ6pyKROmh9xRhjzGhi4WpMB0B0qk4ryBoaYzYVR8h7DMKVqIhsw9EKJsuhlm5YLfIiQEIaEYtY5RgQq0sssUQtERIDXSV94nPFqdZDyZLiABlxoYQyfKaar0WZQ+VuKrdLLIaIerlOKnsyVsRoBZUrtlyGiygq99Os9I/gOko0FiFrcZGg1XGq/VkQnErMxRLFhGrLypIdoV3Ylj6VF/psQ7kl2idajAdVlNaDdlHcalF7S5gjVukfZWuE5oVc2TjNvPVUoq7XZZNiaZl2a7kWWYT7cU7GGGNMHgtXY9pECYEYECPEeGQQjRVMVlXeZ1CMdRBBiACTIJXFVlbVqtaiZjCARejIFZjj5NhkWUUM8v2LLrpodkwMeomRlIWRY5d1NB/rJquOBJ/aRLUhFdtKm0Q3RLkYS6jyWjG+qvmZFyS0E9ZVHqsKMNXKrZdRNpb+0ZK33kaxqAzHRZZSCVK5T/Oo2OWiRS7XRQmkeK04Y9obMYFAlSs6QhXrc6sibhChHekn9FPOMw/XnH6KWOWxyIJZT8gpXroMqsFclL231xMAUXTnhXcZ66niaYusp8NSAsoYY8z4YeFqTJswYMTqBRIvCMRJkyZNSBQU3XxVqoYFkdGtuMm8K7AyASv5EQIN0aMSOoqvRKRyXAih/LEp3k+WHL4jJpZR8iW+Nw6o9T3R3ZV9810svCcrYhR2zUq2dANZdGXlLCoJIxGqRVbTKFgRFlovb/nSflTHVLVkOWfaQe+rzZS0ivan3yBugfXUNp3IJN0PYj/lXiqyfHIfIVaj27MmBIqy95YRcvkst/F5P+I0O+WyrIRx/c5GbIwxxnQCC1djOoDcZhksK7vtUkstVRMSKlUjq2q3BUZ0BVbCJ8VQavAr91G5pyIMED8IJVldlOUXIcHgXoKC42c9DajZ/+TJk2v7ZnvElmqmSgAoQzJClUf2QduRUIgsuHnBUs8duJO0Uqe0kQiSGABZ3fMJpPJxgCofpCRbtEuRpYvvp124bvm2oV0V28u+89mShyExDm0ld+kil1auP2KVtlJffOCBB2pCtawb7CDVCM0nfIoW1LIuy0WC26VljDHGjBqDP7IxZsBh4CiBgljgtbICy6qKSOu2C57qWCIEEIK4+apMiBISIZ45FsU78pz3ZA2WpRBUJ1WZdHmu2E72i6VLglbxurKmyqKj9yVUJfBkYSMLLo95OuEO3AlR2gqK/1U8r1yQEaVy4VXcqWraIjDYTlbZfIwtQo76v7LkR9g3EwKqm8ukQZFLLf2tURKpfsW6cr7qp9HlXHHHiH+JfaAdylpPB0nIxdIy7ZTLkcvyIIhuY4wxph9YuBrTJgwaEREMUJX8hrjDlVZaqettq9qkDz74YLr33ntrYlWCQJloZflkII9QZYkDXsWdMrCXwJaoQljGcjWKQ0VYap/sR+0QhWre6sf3cIwccz5Otqw7sFxyiwRpp0Qpx1+UdVcZjrEY0i7R6povXaQJjHxbKImTkt4wCYBgZZ+0Be7lWFQ1mSCLPfuN51mPKqV/8uV/OiX0FF/NdVcyqvy1kthXPeJmbrFFbrA69l4LOVmDiyyoZUrLDJrLsjHGGDNI+J/QmA6gwbYGzN2w7Miyp7IzDz30ULr77rtrmYrjAFmxtRKRiB65KMuSCjpeZe+VRVUJhCQOFO8arVZy+9V3yAJYBPvGCsxxt+IO3EiU6nknRGlRbdL4PLpMY9WkrRFf9QQj28mqSpu1IqA4H/bJknd9pb1JlkX7FAmXWPqnXhKpfpT+YZ/0Ia45FlNZV/NiVJ4J9eK8By2JUCwtkxeoVcvl9DvhkzHGGDMsWLga0wE6PYhGkEhAakE4YU2VEODzKErkjopVDsul3IKVCTgKVu0/ClWQq+8CCywwlZVHbr8Sqs2sonIHRrxEd2Bl2VV9WB75/jvuuKNrorRIoDa7ZkwE0N7El3L89SxnEl+qs9sqEnZ8R/58aV8szyQiaiRkYumfevSq9A9tzv6UCIw2KxLNiDPaikX9q15ZmX4kEcrXG47itGxMbT3rqUvLGGOMMeWZZkq7I0QzNlBvFJdUSrmQIMV0BtVQ1SKhwK2pjMVYV7HI8Xm8ZRn4y/UXocMjA+S8KFP2VRYNxGO91BiXCtHtV0K1FVdFudA+/PDDmcBWnVa5uyKEECwIsqoJqhqJUj2vOpGAOKG9EV4kWCr6eaRtaGeJ1TLiiv2xbwQr+8/vl33iHkx7dxv1L5U3qrco7lRtoe3yC9eYyZUiIcw1I8kSlmOVP4qCrh/W03xpmaoZiWNG7UE4L2OMMWZUscXVmB4iYReFalEMIqIGsYoAlFhVtmJQrCrutRKXcZAst18JYQ2uEahKDhQtedHtV9l+85a+aLkrct2VRRhhlh/4IyhVd7ORG3XeNbWTorQeiGuJ1XqWRY5LLsCKMxVFIk4Wbi20HbG9CFa5lWo9xfbSPpyjyhXV21e9pZX14jqtoH4Ty/wU1aqN1mhl7qWv0T+J9+axX9bTeqVlylpPB8kqbIwxxowjtrialrHFtRyK88vX+mwkoGSpREApflAiQ9lWJQQUUxqz/apeqAbZsV5qJLr9sijhT1GCIz0vEju8h9BSUqE8HCOCTN/RyHU3nm9ZEVZmHdpR8aq4syqJU1xAWZeVLbnedzQCkUrbFIl5zltiftgtc7Qz7UqbcT4I8V6eV1FpGS1VMxIPQkytMcYYY/6HLa7GdAAlTZKFU8mNmsG6iBriAhFSElsMoGX9w8KHWMWFFOGKQGD/1E3le6OrIhZBXkdRJcuSBCICkn3wnQhlJfDJi7Eo/PQ6ij9ZKdme72S/Kv2CIFNNWL3HOenYywrAdqENENha6n0fAlViNcbwli1dIjGfdwcG9o2rNI/dQEnCihauU6PPW12naD1eF2WS7iT1rKet3GuNMhJH66mTIxljjDGDiYWrMW2CuLvmmmuaWv9U6gIQjcQLI24QqIojFAi+mGlXSY7kWhoH2Up2xD545LskUKMlsyp8n/bDMWJZ5ZhVrxZhrXWK3IHZpkxJkE6BqMeyinhslFxIWZfzoqusqFP8qsq90AZMJGg72obriTiuKg5bWWfYUcxtkUBtlCG5WWmZftdzNcYYY0x7WLga0yYIB+IXlZlX78X6i4g9BA1iVaVB8rAuLpYSgliRcBtmAC6LJQN3xKmy3EqkymqEACuTsVSCUwmP9FyveWQdxB/xq4qXjcmDojtwEe1a8lpdB5R9mQXxqGsQ1+OcsHjGzLZF39EqfI/K2bAvJhwEkwtYnmOpH/P/oX8XidOy1m3avCgxkkvLGGOMMaOFhasxHQDhhvVRVlCEKUKP7Mu49OaTMCFAo/UU0YdQZNDOdhJmEQk2lRPBcsfzesJLMaVKlhNjS/W63rayIHIsCG1eI6oRYNo3r3Ff5jgaicxuQhsi4rF04rost2gJFyE3apaixFNVYDKCa1sUv8r1pG24TqNgBe10aRmWslb4etbTbromG2OMMWZw8D++MR0QT1hJeUTkIaQQfDxiqVQZGFlLZbFE7LKd4kCj0IvWQT7XIuuh3IAbZeCtauHDqor1kHPhmKMI5BELIqK1XxZELHUSqrRxvXhVxKPEatXSO3n4LiznuG3nk1FxXWJs7zAQ45ebPTZbpyhBUtmavPSpeqVlxnkCwBhjjDEWrsa0DaL06quvzgQNLqoIGgRqFKoMvBFSuJEi+uqV0GA9RK1Kr8gSmxeonRaNqheLIOMc8iCwEWQcVzepJ4qwWNO+HKMEY34dhA3HqQXRr/qicj9tRYAVrcM+EPK4hCsLsciXs2HSgqXqd1Vdp8r++kW+tIyWMm7uxhhjjBkvbHE1pk0QAXIJliiILr3KIKuSGoobZZBOTCoiS/GWStyj/UaxgfiKNUCL1qn3WO8zhDUiC0FWFFuIGOP4gfMj5rbqd7WyTmxTxatita6XNZa2VGIlrJyy9CHAOwH7kmDOHyPXU7GyfIawNakwzjtvPXVpGWOMMcaUxcJ1CLj++uvTOeeck6688sp0yy23ZG6ciJ6FFlooveUtb0l77713Wm+99fp9mGMLg3CuCW6rqvmJmEFQ8SgLqWJZ+Ty6/YIEV6/gu3C3LYrPzGcHRiwXJZPqhuU6lqypl0FW7Uj7xpI1nYTvR4jGhFuC71VMcz/Iu5Q3e+zlOjEOtZ5XgTHGGGNMFaaZ0m+fMdOQDTbYIF1xxRVNW2mPPfZIP/rRj7o6WFxkkUWyrLgLL7xwZmE0/+PYY4/NRKBqgCoBkgSqEjf1E251ZQcuEmTNsgMX0a7gwZKqLMDxmPLbc0xYphGNilfttABDKCsZVd7Ci2WXtsHVW/GWnRJ7Zdc1xhhjjBlHbHEdcB566KHsEevqDjvskNZff/202GKLZdapP/3pT+mb3/xmJiZPOeWUbLD985//vN+HPJa84Q1vyKyYCCssqggtlbDppwUMlDRKlnqy3QplByZ+leMu+51VQKDK2ourMt+r747HpThfBGs3E0FhTca1mDbivoqlfgYhGZUxxhhjjLHFdeB5+9vfnllT3/WudxUOnIlNxF349ttvz15fdtllmZW2G9jiOlyQHRhBhhUx73bbS0HGd2NRJU4UsVovXhWLtLIAI/y7bWHkmGgfjqlfyaiMMcYYY0xr2OI64Jx99tkNP6euJlbXd7zjHdnrX/3qV10TrmbwGZTswFhSJVSJ/a0XrxozKOetrt2A4yDZEommEPb5WGWVs+nFsRhjjDHGmNaxcB0BNt5449rzO++8s6/HYvoDLq5Y3xGs+ezACDImOIjP7FYyI8BVWmKVWNoiVLIGoarEVb0AKy+u0iyI6gjHgFiljYhlNcYYY4wxg4dHaSNAzPjqOLzxop/uwFh3qakqsVovKzJiMMar9rIUCvG0WFexsubz0GHtpX0oaePER8YYY4wxg42F6whAXKtYccUVK+2jlSzBWPXMeLsDI45x/UWocgx566XAsiurKgKxl8KQ9uH4aJ+85ZfjQKjSPjEJkzHGGGOMGWwsXIcchMThhx9ee73jjjtW2s+iiy7awaMy3QCRSObbIndgZQfuhjswbrayqiKU68WrklBJYrWbLslV3KWx+uIKjGDtlXuyMcYYY4zpHBauQ85RRx2Vrr322uz5O9/5zrTmmmv2+5DMCLgD850Sq7gDF4HLb4xX7Vd8KC7KKmeTbx+SLNE+JF3qpYuyMcYYY4zpLNNMyQd+maFyEd50000zSxyD85tuuil77Jar8Jve9Kb0yCOPpIUXXril9U333IERilxrhGOnvg+3WrkAx7jpCNZKCVVq1vZTDOKyTPwqj91uH2OMMcYY019scR1S/v73v6ftt98+E624ZZ5++umVRatqtDbDiZ+6D9cTd1ey33bbHRjX2hivWi+GGatljFftJ1hU5S6dTwal7MncB1iijTHGGGPM6GDhOoTcfffd6W1ve1uWKRUx84tf/MK1W0fYHRiRiljthDswYlhCFUtukcMFCYwUr8oy44wzpn7DcaucTV5gc3wqZ+PJFWOMMcaY0cTCdch46KGHMvdgHhEYJ5xwQtp22237fVhmgN2BKQkjscrzIhB8fJ+WQRGAuC/TPhx/XmTjqqzsyS5nY4wxxhgz2li4DhG4kG622Wbprrvuyl4fffTRaY899uj3YZkBcwdG4CGEEXssZAUuAkulrKpYWAdF/HH8eBMQv5oX2hwjiZYQrLPOOmvfjtEYY4wxxvQWC9chAWvZ5ptvnm655ZbsNSVw9t13334flhkQd2DEMH1ES72SNcSoYqFErBK7OkhwDnIHzottkkLRPrgDu5yNMcYYY8z4YeE6BGB12nrrrdMNN9yQvf785z+fDjzwwH4flumzOzCZf+UCjEttvXhV9i2xOoiiD0GPdRVBnz8HrKoqZzMoFmFjjDHGGNN7LFwHHFxJyR78xz/+MXu93377pcMOO6zfh2U64A5cJfstNVXlApzPqiuopyqhimgdxPqlzQT9a17zmqx9cGE2xhhjjDHGwnXA2WWXXdL555+fPd9kk03S3nvvnW6++ea66xO3uNxyy/XwCE033YHZByVrEHmIVQRxEQhgxaviDjyo1kkyAqucTb5WLG2icjaDkMnYGGOMMcYMDtNMKfIvNANDWQGy+OKLp3vuuacrx0Kt1wcffDAtvPDC6YEHHujKdwwjnXYHJr5TQpX91YtXxRopy2on6rp2E0Qq7YNozZez4dhpHwT9IFqHjTHGGGNM/7HF1Zg2wRX4zjvvbMsdGLdfuQDjDlwEog7xi1BFsOISPOggvIlfRYjn4VxUzsYYY4wxxphGDP7Id8yxQXzwkZsuolPWQ5IJNXIH5rqSUEmW1bzbrCCZkqyq1C0dBoskFmJcpbGw4jod4fgl6AfdSmyMMcYYYwYHC1djOsCCCy6Yxa82cgfGRZZ4VWUCzrvMCsrUyKpKvOqwgIuzytnkY3GJWVU5m2GwFBtjjDHGmMHCI0hjOgBlW+q5Ecd41Xola4hXlVgtm2m43+DajHX1ySefnOr8OC+sq5zboCaMMsYYY4wxg4+FqzFdqLsrscrzInAjjvGqrWYZHhQQqJwf8av5mFwEqsrZDJPF2BhjjDHGDC4WrsZ0QMRhTZULcL5ua3SXlVAlXnUYLZCN6tPiAow7MAuxucYYY4wxxnQKC1dj2oRY1UmTJtV1IZZYredOPAyQ9VjlbPLleYjJVUKqYUgeZYwxxhhjhg8LV2PavYmmnz6L5SRLMFZUrKkSq1hZhxnVpyWpVB7OEcHK+RpjjDHGGNNNLFyN6QALLLBAZokkbnXY4lXzcB5YVhGsWFrbqU9rjDHGGGNMJ7BwNaYDYF0ddohZRawSw5ov1YNIRawiWoddmBtjjDHGmOHDwtWYMQcXZ5WzyYMbMIIVYT6MyaSMMcYYY8xoYOFqzJhmQn7iiScywZov2YNAlTswiZeMMcYYY4zpNxauxowRlLOhlA3Lyy+/POEzStionA0Jp4wxxhhjjBkUPDo1ZgzAqop1FSsr1tYIZXrmn3/+9JrXvMbuwMYYY4wxZiCxcDVmREGgqpzNM888M5U7sMrZUMrHGGOMMcaYQcbC1ZgRg4zAZAbGHfjFF1+c8BkZgeUOPOw1Zo0xxhhjzPhg4WrMiIBIVTkbarFGZp555lo5m2mnnbZvx2iMMcYYY0wVLFyNGXKefvrpTLDiFpxnzjnnzOJXeTTGGGOMMWZYsXA1ZgjBoqpyNs8///yEz7CoqpwNllZjjDHGGGOGHQtXY4YIStjIHZjSNhFiVhGr8803XxbLaowxxhhjzKhg4WrMEPDss89mgvXJJ5+cqpwNWYERrGQJJluwMcYYY4wxo4aFqzEDCgIVoYpgRbhGEKjUXSV+lTqsxhhjjDHGjDIWrsYMGLgA4wqMYMU1ODL99NPXytnMMMMMfTtGY4wxxhhjeomFqzEDAkmWEKskXcqXs5llllky6ypWVpezMcYYY4wx44aFqzF9hjI2CFbK2uQhbpX41TnmmKMvx2aMMcYYY8wgYOFqTB/Aoip34BdffHHCZ2QEVjmbmWaaydfHGGOMMcaMPRauxvQQROpjjz2WidZXX311wmeIVMQqotXlbIwxxhhjjPkfFq7G9IB///vfafLkyempp56a6jPcgIlfnXPOOV3OxhhjjDHGmAIsXI3pYjkbEi3hDvzcc89N+IwES/PMM09mYSXxkjHGGGOMMaY+Fq7GdBhK2OAOzEJpmwglbBCr8803X1baxhhjjDHGGNMcj5yN6RBYVVXOBmtrZLbZZssEK+VspplmGre5McYYY4wxJbBwNaZNXnrppXT33XdncawRBCrlbIhfRbgaY4wxxhhjqmHhakyb4P77wgsv1F6TEfi1r31ttsw444xuX2OMMcYYY9rEwtWYNsGyikh98sknM+sqSZdIvmSMMcYYY4zpDBauxnSABRdcMC200EJuS2OMMcYYY7qAzULGdAAnXDLGGGOMMaZ7WLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgWb6fh+AMaPEt771rWwxxhhjjBkXPvGJT2SLMd1kmilTpkzp6jeYkQFB9vTTT6c555zTP045HnjggbTooov258IYY4wxxvSZ+++/Py2yyCL9PgwzwtjialrGM2mtscACC6TpppvOPcuMDa+++mp65JFHsufu/2bccP8340zs/8Z0GwtXYzrMdddd5xlHM7YeB+7/Ztxw/zfjjD3OTC9xciZjjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDTTTJkyZUq/D8IYY4wxxhhjjKmHLa7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2NMQw4++OA0zTTTZAvPjTHGGGOM6TUWrqavPP300+m0005L++yzT1pttdXSwgsvnGaaaaY0xxxzpMUWWyxtuumm6bOf/Wz605/+5CtlRpp77rmnNkHQqWXcJhruvvvu9Mtf/jIdcMABaeONN05zzjnnhPYwg4v7f3s8+eST6fTTT08f+chH0rrrrpte97rXpRlnnDG7B5Zeeum08847p5/97Gfp5Zdf7tAVM53E/b86zz//fLr00kvT1772tfSe97wnrbnmmln/n3nmmbPxJM+5Jz75yU+mG2+8sYNXzfSD6fvyrWbsee6559K3v/3t9I1vfCP7w83z0ksvpX//+9/p/vvvTxdddFE6/PDD03LLLZcNxPkDHsZBaDzmKVOm9PVYjOklDCoQkrDhhhtmrzvJww8/nFZZZZX0+OOPd3S/xgx6/+d/cpdddknnn39+9r+ZB6H6zDPPpLvuuiubJP7CF76QTj755LTBBht07BiM6efv/zHHHJM+/elP1/38scceyxYMIN/61rfSTjvtlI499tg0zzzz+MINIRaupufcd9996R3veEf629/+NuF9LKxveMMb0mtf+9r06quvpkceeST99a9/TZMnT84+v/3227PZNMQsFhVjRgksI/vuu2/Dda699tp03XXXZc8XWmihtP322zdcf6211krjwIsvvmjROuS4/1cXrmefffaE9+aff/70xje+MS2wwAKZcP3LX/5S+7/FsvfWt741/fa3v01vf/vbO3DlTCdw/+8Ms846a1pxxRUzL4O55547vfLKK+mBBx5IV199debhB0zg3HLLLenKK6/M2t0MFxaupqfwp/nmN785E6WyQjJb/LnPfS69/vWvn2p9LJPXX399OvroozM3p//85z+ZtdaYUYPZ3+9973sN18HjQMJ12WWXbbr+uDH77LOnNdZYIxPsb3rTm9ILL7yQ9txzz34flmkB9//2eM1rXpP22GOPtNdee6VVV111qs8ZpPM57vQM5nfddddsMhiRa/qP+391+C/8yle+kjbffPOs708//dTShv8CvPw+//nPZ+PIm266KRt3+j90+LBwNT0DN6YddtihJlqJPzj11FPTdtttV3cbhC0D0FNOOSWzsiJyjTEmwuD75ptvzmbap532f6kbOu2SZsygQRzrl770pSx+r5H1aL311ksXX3xxNrDH8sTCQJ64QGOGmW233TZbGsF48zOf+Uw2Dj3ooIOy9xhXEq7GZ2Z4cHIm0zOOPPLIzHoqiLNpJFrzrLzyypm7x2abbdalIzTGDCOzzDJL5rERRasx42KpO+SQQ1pyeVxiiSXShz70odrr3//+910+OmMGi/e9732158R+33HHHX09HlMe/8ubnmV9++53v1t7/c53vjPtuOOOpfcz22yzpbe85S11P7/33nuz2ed11lkns8IwG80jr5llIz62GVhplIV0o402qr3PbDWJoZZaaqlshm7eeefNElzgalIvU2PcV6ReFlhcqYuyDDLgiC5fZGFeYYUV0lxzzZV9vv/++xd+/3nnnZf9UJPYioENA/zFF188i4086aSTnGFyxLn11lszdyhcZ3U/EEO+9tprZ/fJQw891HIc3fe///209dZbZ7HoxBHNMMMMWf+jHxKz/tWvfjWzehaVUlJiDrjssssK+37s48a4/3eH+P8Z/2/M6OHf/6nh/y+CeDVDxhRjesApp5xCGt3acuWVV3b8Ow477LApM88884TvyS98fvjhhzfczyWXXFJbf8MNN5zy4osvTnn/+9/fcL9rrLHGlMcee6zhvlpZ7r777tq2PNf7iy++eHYcH/zgBwu322+//SZ87+TJk6e89a1vbfp9yy677JTrrruuYXscdNBBtfV5bvpHvBb0zXq88MILWV+ZbrrpGl7/WWaZZcrRRx/d8DuvuuqqKQsvvHDLffjll18uPN5mC3280+TvPzPcuP+3z5lnnlm7H2adddYO7NH0Cvf/9rnhhhsm/Cc89NBDHdir6SWOcTU9AWulwGLTyGpahY9+9KNZSvSYpAUrD1kViam95JJLMqsRAfrEOfDeUUcd1dK+P/CBD2RuzbghYqnCwkRwP27Lt912W7bODTfckCW+OOeccyZsS11aZYqNx1cve2wjd6+Pf/zj6Qc/+EH2nNIfxCph9SLBRnSRJAsz7XvnnXfW3iPDHsdOTTOy6V1zzTXZ+5MmTcra6dxzz+34NTH94dlnn82SVPzxj3+ccP2pbUcClyeeeCL7DGsrnhAf+9jHsng3LLN58FBgX5qVpr8Rc77MMstkVle+C6sN2b+VsTGCpZe+/uCDD6YzzjijYTZkPBiMcf/vLiSlEYsuuqg73Ijh3//6EN/K+E9Q23XBBRfsyXUxHaSnMtmMLUsvvXRthmuHHXbo6L5PO+20CTNo733ve6f861//mrAOr3fbbbcJ6/36179uaqWZaaaZssc3velNU2699dYJ6/3nP/+Z8u1vf3vCPi+77LK6x1nW8hMtrrKcLbroolMuv/zyQgub2HLLLWvbzTbbbFNOPfXUqdbHyrrUUkvV1mO/Tz75ZOFx2OI6XDPue+yxR22d5ZZbLuvPeV555ZUpxx57bK1/07+wrObZf//9a/taf/31pzz44IOF34mV9dJLL52y6667Zvtu5sXQK2xxHS3c/9vj1VdfnbLCCivU7sV99923Q1fG9AL3//LgqXbPPfdM+clPfjJltdVWq/X9OeaYY8qf//znLlwl020sXE1PmH766Ws/GAcffHBH/4iXXHLJCaIYQVkE72+77ba1dRHTbN9ssIs77TPPPFP3GN797nfX1v3Qhz7UFeEqt67bbrut4TYXX3zxhG3OPvvshvufa665ausecsghhetZuA7PwIVJjdi/i9zXIyeeeGJt/S222GKqz9dcc83a55MmTap83BauphO4/7cHYQG6n6eddtopN998szvmEOH+3xrNQmSY0L3pppu6fLVMt3ByJtN1cCGkbpygKHSnOP/887O6dEDiGRJA5RMhCd7HXRd3R8CV9oILLmj6HYcffnjmetxKlrprr702dQvcoUmy1Ai5EsM222yTJdOpB8lwonsoyXf+v742w8q3vvWt2vNvfvObab755mu4/nvf+97M9V2JvB5//PEJn0f333xSC2MGDff/+vz9739Pn/3sZ2uv995778La6WZ4cf9vzHTTTZeNebgXqFJhhhMLV9N18lnbGonAdmJnt9pqqyymtRHEnG6xxRa118S+NoLswWRMbcTqq6/ekyyNZDRuRjyfKKjrQbF6xcc+/PDDtZhdM3wwOaSJGGKl3/72t7e0nTL+MmkR42LzMXBMbBgzqLj/1+epp57KSs+R5wGWXXbZCSLHDD/u//+DvApamJx961vfmuaYY4706quvZtnvqfdNXg8znDg5k+k6/GBE9OfZCW688cYJgfatQBKis846q5ZUqRHLL798zUJbj5hUpihBTSfgGEjI1AgS4Dz66KOl2gMrGlbcf/zjH7X2kAXODBd/+9vfssQc6i/77bdfS9tdd911tef5clGUrNLkEEktEMa77rprVkt5kUUW6ejxG9MO7v/FkJBw2223rdWrZFLrV7/6VUcnkE3/cf//H9/5znemah/+G/G4owwc9wLeaCeccELac889e3qdTPtYuJquwx/l9NNPX3MXZva3Uzz22GO159QnbYVYL/Kf//xnw3WpU9mMKGyjS3QnIRssbdhqW1CvtVXXTtpDwrVZe5jBJdZkxeU3ZrFulSeffHLCa+oFMzOtjMAXXXRRtig7+Prrr59ZbBkYN3NLNqabuP9PDf9HO+20U7r88strHkRnnnlmesMb3uDOOGK4/zdmttlmSwcccEDmbfDOd74zqwzxoQ99KPsPW2qppXp0lUwnsKuw6QlRVFKOpVNE6y0/TK0Q12tWfLpevGyvQYh2oy3y67oY9/Dyr3/9q+195CdeiAn6zW9+k44//vi00korTfjsvvvuSz/72c8ycUuJGx4ptWNMP3D/nwgDc9wkEarAxOfpp5+eNtxww75cH9Nd3P9bg1JsuA7LG+HYY4/t6nUxncfC1fSE9dZbr/ZcNUQ7QXR3kptkM+J6eTfmYaZKW4xye4wbcQICi8p/s8aXWg4++ODCyRsSuZDQghjoH/7wh5l7VZylfvnll9OPf/zjrG5rtPwb0yvc/yeCNYmJJSCPwSmnnNJy3LsZPtz/W4dQF5HP62AGHwtX0xM22WST2vN77703XXXVVR3Zb3SHxQLUCjGB0ii5N8a2eP7551t2+x3V9hg35p9//trzRx55pCvfQTz0+9///nTSSSdlWbkRsp/4xCcyyyzw3iGHHNKV7zamEe7//+PjH/94+tGPfjQh2/wuu+ziDjTCuP+XC70S+Uz6ZvCxcDU9YYcddpggijqV0TBm9G1VDMf11lhjjTQqkDH5da97Xan2QNzefvvtI9ke48Zqq62WZppppuw5SbqUjKWbIGQpuxPFqlwTB9Hl3owu7v//n89//vPp29/+dq1djjrqqMyN34w27v+tQwUFMc8883TlepjuYeFqehaj+X//93+117/+9a+zpSy4tUZBFi2555xzzoSsuvUSGPzhD38o3L7bkBgjulZ2A5U2AaxizWAdYqGAOEWyKJvhvcdif+5l7A41g8XkyZP70vfNeOP+n9JXvvKVrNyHOPTQQ9P+++/f1+tieoP7f+ucffbZteeUxjHDhYWr6RlkdIsWvd13371WlqYVbr755rTOOuuk888/v/be2972trTkkktmz1988cWGf9LE8H3sYx+rDZyXXnrptOmmm6ZeEcvmULqmG3zwgx+sPf/tb3+bzjvvvLrr4rLNQCdua8vYcHPggQfWnh999NHpwgsvbHnbIvfiVt3NYxmdaPXvZd83Zpz7PyVAvvCFL0z4v/3iF7/Yle8yg8k49n+MGSRZapXjjjsuXX/99bXX73rXuzp6PKb7WLianoEbI1kN9cNGHCZF0ffYY49066231hWb1JkkGcyqq66aidcISScOP/zw2utTTz01i8HL14olW+5ee+2VZUgVRx55ZLZ9r1h55ZVrz2mHbllct9xyy9rrd7/73YXf9ec//zkT7SpNtOiii06wiJvhhIyhqktHhmBq1X3ta1+rWzuZP3xK3VDOJlpNBSVvmNC47LLLapb5PAwCmBASsf8JJpdmnXXW2oRJrB1rTKcY1/5PPUriWsW+++6bjjjiiI5+hxl8xrH/T5o0KS2zzDLp61//+lR1yPPCnHuEe0NQCscJy4aPaaagDIzpISQDesc73jGVCKWeKNlQiYV99dVXsx+av/zlL1O5Hn7jG99In/zkJye899GPfnRC3Uqy4yLiSFiA+zC1J+OPN5ZZYn+KuPTSS2sut/wR8LoZ0VJZ75YiWcYHPvCB2vobbbRRev3rX1+LS1R8khIH0E6yJlNOKCZRagTt9Za3vCVLlCOoXbb22munGWecMStHRGZnHSfZCLHMsk0RZJpVDONBBx1UmHnW9IZ4Ler1TTwPGIREzwQGDVx/BiL0NyYs6B/cg6wPa6655oSZ6Hy/5p4ijoq+SJ9hNp76v2QbjgnCuGdxO8+z6667pp///Oe149liiy2y41FiJ2KNPve5z1VuGwrL5+NruefjfcDkVx7cKYsGbWbwcP+fmptuuim7LyUsuDcRL616z+y3337Z/4MZfNz/p4b/m5jrhHEkRgLGkfzXPf3009n/1N/+9rdsXCkIi7rkkkvSggsu2KOrZzoGwtWYXvPMM89MOfTQQ6fMPffcqKeWllVXXXXKb3/727r7/PKXvzxlpplmariPmWeeecpXv/rVhsd2ySWX1NbfcMMNWzqf+B31eOmll6ZssMEGDY/v7rvvrq3Pc72/+OKLTynDI488MmWTTTZp2qbLLLPMlGuvvbbhvg466KDa+jw3/SNei0Z985VXXpnyxS9+ccqss87a0r01wwwzTNl3332n2s/ss89e6v689dZb6x7TPffcM2WBBRaou33ZPp5nzz33bPlY43LiiSe29b2md7j/N/6/qrKwvRkO3P+n5uabb54y7bTTttzfWff973//lCeeeKIPV9B0guk7J4GNKVdzlPgb3FNJqnTBBRdk7qtYR5944onMMogFZoUVVsgsRbgUN8t4S3wPcbPHH398ZkG8++67M8vS3HPPndWc3HzzzbPsilh5+sEMM8yQxZxQ75LEVFi7ONeXXnqp49+FpRkr87nnnptOO+20dOWVV2YWbOJ7cdVmhpI23W233bLjMqMFVkwsibhwUb+RfoelHSspfWDOOefMLKerrLJK5l2w1VZbTSinFEsFXH755ZmrGO5duGVh0cfFDKvpIosskllqiRPCatnI9Z7v++tf/5q+973vZdZgslnjwo9LmzHu/8b4978seK0xtmEMSeJOLKt33XVX9t/Ffx2eQsTY8l+HVxlloajAYIYXuwobY4wxxhhjjBlonJzJGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuJq+sv/++6dpppkmzTrrrOmBBx7w1TBjhfu/GWfc/8044/5vTHksXE3fuPnmm9MxxxyTPd9vv/3SIossMtU6G220USZstSy22GLpxRdfbGn/Bx98cG27nXfeOQ0CJ5100oTzKbtceumlhfvl/bL72nTTTXt+/uZ/uP+7/48z7v/u/+OM+7/7v6mGhavpGwcccEB65ZVX0myzzZY+9alPtbTN/fffn37wgx+kcWWBBRbo9yGYDuH+Xx73/9HB/b887v+jg/t/edz/DUzvZjD94I9//GP6wx/+kD1///vfn+add96Wt/3qV7+a9tlnn8y9eNhYccUV07777tvy+r/61a/S5MmTs+drrrlmWmGFFZpus9BCC6Xtt9++6Xqt7Mt0B/f/1nD/H03c/1vD/X80cf9vDfd/U4SFq+kLhx9+ePaIy+pHPvKRUtsi5L773e+mz3zmM2nYWHvttbOlFZ544on0ox/9qPZ6zz33bGm7ZZddNn3ve9+rfIym+7j/N8f9f3Rx/2+O+//o4v7fHPd/Uw+7CpueM2nSpPT73/8+e77BBhtkQqsV1llnndrzr3/96+npp59Oo8wvfvGL9NJLL2XPZ5hhhrTLLrv0+5BMB3D/bw33/9HE/b813P9HE/f/1nD/N/WwcDU958QTT0xTpkzJnu+0004tb7fbbrul5ZdfvjYb981vfjONMieffHLt+dvf/vY033zz9fV4TGdw/28N9//RxP2/Ndz/RxP3/9Zw/zf1sHA1PednP/tZ7fl2223X8nbTTTddOuSQQ2qvjzrqqPT444+nUeQf//hHuvbaa0u7CZvBx/2/Oe7/o4v7f3Pc/0cX9//muP+bRli4mp7yt7/9Ld1333215EALLrhgqe133HHHtOqqq2bPn3nmmXTEEUekUeSUU06pPX/ta1+bttpqq74ej+kM7v+t4f4/mrj/t4b7/2ji/t8a7v+mEU7OZHrKBRdcUHu+/vrrl96eZE5f/vKX0zbbbJO9JgnRxz/+8dICeJD5z3/+k37yk5/UXr/nPe/JYlxb5fnnn09nnXVW+utf/5q5VFNuaP7558+SQq2++upp+ul92/cL9//muP+PLu7/zXH/H13c/5vj/m+a4RGs6SnXXHNN7fkb3vCGSvt4xzvekYkw9oVI+8pXvtJWFt1zzjknWzrJ7rvv3nL24DwXX3xxeuCBByq7CeNiLGFfVCoHob/ffvuVEsOmM7j/N8f9f3Rx/2+O+//o4v7fHPd/0wwLV9NzV5lO1BE97LDD0mabbZY9p2TMpz/96bT44otX2hdC75hjjkmd5I1vfGNl4RqTEqyyyiqZlbRTPPTQQ1lb/frXv05nnHFGZok1vcP9vznu/6OL+39z3P9HF/f/5rj/m2Y4xtX0DDIJ33vvvbXXiyyySOV9bbrppmmjjTbKnlMy5tBDD02jwL///e/029/+tvb6ve99b8vbEgtLTVy2v+uuu9Jzzz2XXnjhhew5fwZvetObauteffXVmeUai7XpDe7/zXH/H13c/5vj/j+6uP83x/3ftMQUY3rEk08+SQ2c2vLoo4823WbDDTesrX/cccdN+OzKK6+sfTbddNNNuf322yd8ftBBB9U+32mnnaYMAyeeeGLtmKeffvopjzzySEvbPfPMM1NefPHFhuv85z//mfLFL35xwjX48pe/3KEjN81w/2+O+//o4v7fHPf/0cX9vznu/6YVbHE1PePZZ5+d8HrWWWdta39vectb0pZbbpk9f/XVV9NBBx2Uhp3oJrP55pu37Mo7++yzpxlnnLFpYiss0yR7Et/61rfSK6+80sYRm1Zx/2+O+//o4v7fHPf/0cX9vznu/6YVLFxNX11n2oVYVwQZnHbaaemmm25Kwwpu1JdddlklN+EyRLfqJ598MnMbNr3H/X8i7v/jhfv/RNz/xwv3/4m4/5tWsXA1PYOyLJFOxFeuscYaafvtt6+lUf/iF7+YhhVK4OjP7DWveU0Wg9oNll566bTEEkvUXt96661d+R4zEff/xrj/jzbu/41x/x9t3P8b4/5vWsVZhU3PmGuuudLMM8+cJQyCf/7zn1lCoU5YEMmQi3D93e9+l6677roJiYiGpRxOLLq98847p5lmmil1C+re3nPPPbXrYLqP+39j3P9HG/f/xrj/jzbu/41x/zetYuFqegYuvVj6/vGPf2SvqVW64oortr3f17/+9Vnc5k9/+tPs9Re+8IV03nnnDVU5nKuuuipNmjSp627CRfE2+Zlg0x3c/+vj/j/6uP/Xx/1/9HH/r4/7vymDXYVNT3nDG95Qe37bbbd1bL8HH3xwmn76/z8Pc/7556fLL788DRNxtpH6tmuttVbXvosyObHtF1pooa59l5mI+38x7v/jgft/Me7/44H7fzHu/6YMFq6mp0RB9te//rWjcZt77bVX7TVW1zKil9jSTi5lLKYvvvhillhK7Lnnnqmb/PznP8++U7PAG2ywQVe/z/wP9/+pcf8fH9z/p8b9f3xw/58a939TFgtX01M222yz2vMrr7yyo/smMZPiQq+44opS7sL9hLjcp556Kns+7bTTZvGxZS2oxPe2Au7In/nMZ2qv3/a2t6XXve51JY/YVMX9f2rc/8cH9/+pcf8fH9z/p8b935TFwtX03FVmscUWy54T6/rwww93bN+LLrpo+uAHP1h7PSxlXmLtsk033TQtvPDCpbYnRpc43+OOOy49+uijhetQ55YY4De/+c3p8ccfz96j7usRRxzRcN8bbbRRZpVl4blpD/f/qXH/Hx/c/6fG/X98cP+fGvd/UxYLV9Nzdt1119pzsgF3ks997nNp1llnTcPC5MmTs5jcdt2EmQT4yEc+kmULXn755dM73/nOtM8++6QPfOADaZtttkkLLLBAZsmVaJ1uuumyuJJVV121Y+diWsP9/3+4/48f7v//w/1//HD//x/u/6YKFq6m5xCLigUPYmxnJ5h//vnT//3f/6Vh4Wc/+1l65ZVXsudzzjlnrSZtVXAZvv3229Nvf/vb9OMf/zj96Ec/SmedddaEkjcIW5JX7bTTTqWKpCN2Tfu4//8P9//xw/3/f7j/jx/u///D/d9UwcLV9Jxll102bb311tnzyy67bEIZmE5wwAEHZDXThs1NZscdd0yzzDJL6X2sv/766frrr09HH3102mWXXdIaa6yRFl988TT77LOnGWaYIc0333xp9dVXTx/60IeyerW33nprWnfddVsSrTfffHPt9W677Vb62MzUuP//D/f/8cP9/3+4/48f7v//w/3fVGGaKdGkYkyPoG7XW97yluz5fvvtl7797W+77QeMG2+8MRPBstL+/e9/t9W1Q7j/Dz7u/93D/X/wcf/vHu7/g4/7/+Bii6vpC1j8ttxyy+z58ccfX4u9NIPDxRdfXHt+6KGHWrR2EPf/wcf9v3u4/w8+7v/dw/1/8HH/H1wsXE3fOPLII9P000+fnn322fSNb3zDV2JAf7hxM95hhx36fTgjh/v/YOP+313c/wcb9//u4v4/2Lj/Dy4WrqZvrLzyymnffffNnn/nO99JDz74oK/GgEDCKGrhwmGHHVZLpmU6h/v/4OL+333c/wcX9//u4/4/uLj/DzaOcTXGGGOMMcYYM9DY4mqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RiTXnzxxbTEEkukaaaZJm222WZuETNWuP+bccb934wz7v/DhYWrMT3gX//6V7r44ovTEUcckXbYYYeaSNRy0kknldrfwQcfPGH7VpbDDjus7v5mmmmmdMghh2TPL7zwwvSb3/ym7XM2Rrj/m3HG/d+MM+7/ppNM39G9GWOmYpdddkmnnXZamjJlykC3zm677ZYOPfTQdNddd6UDDzwwbbPNNmn66f0TYdrD/d+MM+7/Zpxx/zedxqNSY7rMww8/3FXR+qY3vSmttdZaLa3XiOmmmy596lOfSh/5yEfSHXfckVmB99lnnw4eqRlH3P/NOOP+b8YZ93/TaSxcjekB0047bVpxxRUz8ajlXe96V7r//vvb3vdWW22VuQ53gt133z0dcMAB6d///nf6+te/nvbee+/MzdiYdnD/N+OM+78ZZ9z/TSexcDWmyxx77LFpscUWS7PPPvtUP+aDBse40047pR//+Mfp9ttvT+ecc07aeuut+31YZohx/zfjjPu/GWfc/02nGbyRszEjxkorrTSVaB1kdtxxx9rzE044oa/HYoYf938zzrj/m3HG/d90GgtXM7AQY6mMuO9973tr7//2t79N73jHOzIrJtlwX/e616W3ve1t6ac//enAJ0AaBjbZZJM011xzZc/PPvvs9NRTT/X7kMYS9//+4P4/GLj/9wf3/8HA/b8/uP8PPhauZqhSqm+77bbpne98ZyaoiA996aWX0mOPPZYuuOCCLD6TeM/nn3++34c61JBJeP3118+e0760rek/7v+9wf1/MHH/7w3u/4OJ+39vcP8ffBzjaoaCV155JUtmdNFFF6UZZ5wxrbvuumnppZdOL7zwQrriiivSfffdl6137rnnpk984hPpuOOOS+PC5MmTM2szMakkVZp77rnTIossktZbb7203HLLVdonwpXJAUC4UnvW9A/3//q4/48+7v/1cf8ffdz/6+P+P35YuJqh4Fe/+lV68cUX05Zbbpl+9KMfpYUXXnjCj/pnP/vZ9I1vfCN7/YMf/CCrQ7rEEksU7us73/lOmjRpUkePj/qn88wzT+oH3//+97OliDXWWCN98YtfTNttt12pfa622mq159dee23bx2jaw/2/Pu7/o4/7f33c/0cf9//6uP+PIVOMGVBOPPFEAlZry/rrrz/l5ZdfLlz3P//5z5Q3velNtXUPP/zwuvvdcMMNJ+y3E8vdd99d+vwWX3zx2vacaxkOOuigUse3zz77THnllVda3v99991X23b66aev2+6me7j/18f9f/Rx/6+P+//o4/5fH/f/8cYxrmZo+Pa3v53FHxRBAqe99tprrKyEK6ywQvrCF76QuU9T5Jt41GeeeSbddNNNWQ1W3IXF8ccfn/bbb7+W973gggvWyvVg0X7wwQe7cg6mddz/J+L+P164/0/E/X+8cP+fiPv/GNNv5WxMKzOOSy21VNOG+tOf/lRbf4011hj4hm3H4vrPf/6z6Tr/+te/pmy55ZYTLK9XXHFFy9/xmte8prbd1VdfXer4TPu4/9fH/X/0cf+vj/v/6OP+Xx/3//HGFlczFKyyyipN15l33nlrz59++uk0ysRzrcecc86ZxcYsu+yytfeOOOKIlr9j1llnrT1/9tlnKxyl6RTu/xNx/x8v3P8n4v4/Xrj/T8T9f7yxcDVDgeqKNmKGGWaoPX/55Ze7fETDAeKTRFXi4osvzlyKW8E1cQcH9/9quP+PBu7/1XD/Hw3c/6vh/j+aWLiaoYAYVlONTTfdtPb8ueeeS/fee29L28V6uLPNNpubv4+4/1fH/X/4cf+vjvv/8OP+Xx33/9HD5XDM2DFq5XBaSbQU+ec//znBfbgILNZPPfVU7fUCCyzQteMzvcX93/1/nHH/d/8fZ9z/3f+HHQtXM3b89re/TZdddllH9/mpT31qYIVrPj61FespWYrlKkwm51g31ww37v/u/+OM+7/7/zjj/u/+P+zYVdiYEefGG2+c8HqhhRZqus2tt95ae/7617++bhkiYwYd938zzrj/m3HG/X/08GjUjB2XXnppGidOOOGECSJ0vvnma7rNX//619rztdZaq2vHZnqP+7/7/zjj/u/+P864/7v/Dzu2uBozZPz73/9ueV3K4fz85z+vvd5tt91a2u6KK66oPd9ss81KHqEx3cP934wz7v9mnHH/NxauxgwZ3/zmNzMx+etf/3pC5t/Iv/71r3TQQQelnXfeuRaruuSSS6b99tuv6f5feeWVmnCdccYZLVzNQOH+b8YZ938zzrj/G7sKG9Nlrr/++rTPPvtM9f5DDz1Ue/6lL30pffvb357w+Rvf+MZ0/PHHT7UdQvTCCy/Mlplmmilz/11mmWXS3HPPndVoveeee9I111wzQdTiHnzOOeekWWaZpenxUusV4Qtbb711tl9jquL+b8YZ938zzrj/m05j4WpMD1xbYsxoEffff3+2RFoRjC+++GK64YYbsqUeW2yxRSaAW80MfPrpp9eev+9972tpG2Pq4f5vxhn3fzPOuP+bTmPhasyQ8elPfzptuOGG6aqrrkpXX311uvfee9Pjjz+eLRQqR/BSp3XddddNu+yyS1p11VVL/cn84he/yJ6zDyyuxgwS7v9mnHH/N+OM+7+ZZooC4IwxY89xxx2XPvKRj2Tt8MMf/jC9//3vH/s2MeOD+78ZZ9z/zTjj/j8cWLgaYzJeffXVtNxyy6W77rorLb300ukf//iH67eascH934wz7v9mnHH/Hx6cVdgYk/Gzn/0sE61wxBFHWLSascL934wz7v9mnHH/Hx5scTXGZEmell9++SxedtNNN00XXHCBW8WMDe7/Zpxx/zfjjPv/cGHhaowxxhhjjDFmoLGrsDHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDzfT9PgAzPHzrW99KTz/9dJpzzjnTJz7xiX4fjjHGGGOMMWZMmGbKlClT+n0QZjhYZJFF0oMPPpgWXnjh9MADD/T7cIwxxhhjjDFjgl2FjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcaYSjz44IPpzDPPTA899FBXtzHGwtUYY4wxxhhTmpdeein97Gc/S9ddd132yOtubGMMWLgaY4wxxhhjSoP4/Pe//53+9re/pWeeeSZ73Y1tjAELV2OMMcYYY0wpsJT+8Y9/TI888kj617/+lT3yupEFtco2xggLV2OMMcYYY0wpZDm999570zTTTJM98rqRBbXKNsYIC1djjDHGGGNMy0TL6YsvvphWWmml7LGRBbXKNsZELFyNMcYYY4wxLRMtp6973evSa1/72uyxkQW1yjbGRCxcjTHGGGOMMS2Rt5wuscQS2fuLL754XQtqlW2MyWPhaowxxhhjjGmJvOV01llnzd6fbbbZ6lpQq2xjTB4LV2OMMcYYY0xT8pbThRZaKL388su1hdd5C2qVbYwpYvrCd40xxhhjjDEm8Oc//7lmOYW//OUvhe3D5wsssEC2PpTd5s1vfrPb3UyFhasxxhhjjDGmKf/85z/Tq6++mpZddtmm67Ie6+t52W2MyWPhaowxxhhjjGnKeuutl/7zn/+kZ599tum6xK+yPlTZxpg800yZMmXKVO8aU8AiiyySHnzwwbTwwgunBx54wG1kjDHGGGOM6QlOzmSMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDTOKjzgPP300+mcc85J1113Xbr++uuz5EiPPfZYev7559Pcc8+dVlpppbTVVlulvffeO80777z9PlxjjDHGGGOM6TjOKjzgXHjhhWmzzTZrut58882XfvrTn6bNN9+8a8firMLGGGOMMaZfYMD585//nN74xjemhRZaqO/7Mb3FFtchYNFFF00bb7xxWnPNNbPnCy64YFYPi5I0v/rVr9JvfvObrFjzNttsk6699tq06qqr9vuQjTHGGGOM6RgvvfRS+tnPfpaeeeaZdNttt6X99tsvzTjjjH3bj+k9Fq4DDoL1vvvuq/v5jjvumM4444y0/fbbZzfiIYcckglZY4wxxhhjRgXC5v7973+nv/3tb5mRhtdvectb+rYf03ucnGnAmW666Zqus91226Xll18+e37FFVf04KiMMcYYY4zpDRhn/vjHP6ZHHnkk/etf/8oeec37/diP6Q8WriPCHHPMkT2+8MIL/T4UY4wxxhhjOoaspPfee2+aZpppskde834/9mP6g4XrCIB//l/+8pfs+QorrNDvwzHGGGOMMaYjRCvpiy++mFXU4LGstbRT+zH9wzGuQ8pzzz2XZUQ766yz0pFHHpleeeWV7P3999+/0v5I9NSMV199tdK+jTHGGGOMqUK0kr7uda9Lr33ta7NHXi+wwAItx6h2aj+mf1i4DhEnnXRS2muvvep+/pnPfCa95z3vqbRvshUbY4wxxhjTK5qVpclbSZdYYons/cUXXzwTmrKWvulNb2qYGbhT+zH9xa7CI8Bqq62WlcH52te+lvnrG2OMMcYYM8ioLA3CkcciV928lXTWWWfN3p9tttlq1tJWYlQ7tR/TXyxchwiyB990003ZglA99dRTszI4xLfusssu6eyzz6687/vvv7/pghuFMcYYY4wx7RLL0lBTNS8a81ZSLLIvv/xybeF1KzGqndqP6T92FR4i5p577mwRuDPsvPPO6Sc/+Unac88907bbbpt+/OMfp/e+972l973IIot0pDSPMcYYY4wxVcrSRFddXIhlJQUlIs2jGFXWf/Ob3zzV553aj+k/Fq4jwO67755ZW3/5y1+mj370o2mbbbZJ88wzT78PyxhjjDHGjHmcaqtlafIJkv75z39miUGXXXbZpvtjPdYvOqZ29mMGCwvXEQFrK8L12WefTeeee27lJE3GGGOMMcaUiVPF1ZfyjPvtt1/T5EZ5193Xv/716e9///tUVtf11lsv/ec//8nGts0gVpX1i45pjz32qLQfM3hYuI4IpPQWcoUwxhhjjDGmF3Gqq666akslZVotS/Oa17wmM8y0e0x33HFHpf2YwcPJmUYEXCLE7LPP3tdjMcYYY4wx4xmn2ii5UaOyNJ1IkFTlmMzwYOE6Ipx++um156usskpfj8UYY4wxxow2RXGqzUrKdLssTZVjMsODheuAc9JJJ6UXXnih4TpHHXVUOuecc7LnSy65ZFp//fV7dHTGGGOMMWbcyFtOV1pppaYW026XpalyTGa4cIzrgHPwwQenT37yk+ld73pXFiy+9NJLZ67ABJxTz5Xgc25GIJD9hz/8ocvWGGOMMcaYrtFqnGovy9JUOSYzXFi4DgFPPPFE+tGPfpQtjeqwnnDCCWnTTTft6bEZY4wxxpjxoVGcKuKwqCZrJ8vbFJXcqXpMZriwcB1wzjvvvPT73/8+u9nIijZ58uT0+OOPp1lmmSWbRVpttdXS29/+9rTjjjvW4gSMMcYYY4zpBq3EqRZZODtV3qao5E7VYzLDhYXrgLP88stnyyc+8Yl+H4oxxhhjjBlj6sWpCl4/+uijhRZOlbdpZj0tW3KnnWMyw4WFqzHGGGOMMaYp7captmI9baW8TRSf3Y6dNYODhasxxhhjjDGmKe3EqbZiPW2lvE3e5bfdYzLDg4WrMcYYY4wxpilV41RbtZ5G8i7Ar3/969Pf//73qbZr55jMcGHhaowxxhhjjGmK4lSr0Ir1tEp5m3aOyQwX0/b7AIwxxhhjjDHDCcmWzjzzzPTQQw/VXSdvPV1ppZWyR1lP+bzV8jaNtjOjjYWrMcYYY4wxpjRKtoT1k8d6QrKR9ZT3+bxseZui7cxoY+FawJNPPpnOPvvsdNxxx6WvfvWr6dBDD+39lTHGGGOMMWaAicmWyBRcJCTLWk/rlbfRwmtbXccTx7gGrrnmmkyknnfeeWnKlCkTGupLX/rShNeTJ0/O/OkJBiel9ne+853eXDFjjDHGGGP6TKvJllqxnsaYVZe3MfWwcP0vhx9+eCZOSZOdF60EkOeZf/75s5sMn35mmdh23nnnrdvQxhhjjDHGjAqtJFuqZz0VvH700UcniF6XtzH1sHBNKR1zzDHpc5/7XK1RVlhhhbTxxhtnN971119ft/H22muvTLhyA55zzjlp9913r7uuMcYYY4wxo0CrpWqqWE9d3sbUY+yF68MPP5wOOOCArDFmnnnmLK51zz33zF5/7GMfayhct9hiizTTTDNlN+8ll1xi4WqMMcYYY0aeVkvVVLGeuryNqcfYC9fvf//76fnnn89cHI466qiaaG0FROvKK6+czQ7ddNNNLW9njDHGGGPMMNIo2RKCNVpdbT01nWTshSuJmORj/4EPfKB0Ay699NKZcJULhDHGGGOMMaNK2WRLJDMdxtq0jO/f+MY3ZhrBDAZjXw7nrrvuyqyt3FhFSZiaMffcc2ePTz/9dBcujzHGGGOMMYPBMJaqQYSSk+ahhx7qaG1a03vG3uJK+m6YZ555KjUgNyfMMMMMHb0wxhhjjDHGDBLDVqpGIpQas7fddlvab7/9JpTqaVabdtVVV52QJdn0l7EXrgSAP/bYY+nJJ5+s1ID33Xdf9jjffPN1+NIYY4wxxhgzOAxbqZqyIrTV2rSmP4y9cCWQnPpRzAiV5dlnn03XXHNN5mK80kordeUCGWOMMcYYMwj0M9lS2bjTKiK0ldq0pn+MvXDddNNNs8545513piuuuCKtv/76LTfe0UcfnZ577rmsY7MfY4wxxowfTuRixoV+lappx+W3VRHaam1a0z/GPjnT7rvvnqabbrqsMT74wQ+mJ554oqWGu+iii9LBBx+cPSeb2h577NHVC2WMMcaYwcOJXIzpfsKk6PKLeOV1s/syilA8I5sljWpUm5b3m32n6T5jL1xXWGGFtPfee6cpU6ZkMzjrrLNOOvvss7PX9bIQf+pTn0pbbbVV1umZwfnkJz+Z5p133h5cLmOMMcYMEmUH1MaMO2Une+q5/DbarqwIbVSbdtCyJI8zYy9c4bvf/W5ad911M7GKyzAuEGQZPu2002oNtfrqq6cFF1wwC0Y/6qijspTf8La3vS0ddNBBfbuAxhhjjOkPVQbUxow7ZSd7ilx+G1lAq4jQVmrT2urafyxcU8r81c8///zMbRjxysIf0OOPP16r7crNNXny5NrnsOeee6bf/e53leq/GmOMMWa4KTugNmbc3X7LTvZ0wuW3mQgdxtq044qF63+hU5988snpsssuyyyudG6J1ChWZ5ppprTlllumSy+9NJ144okO0jbGGGPGkCoDamPG3e237GRPuy6/rYjQotq0fKZFtWr1nVUqkZjOMPZZhfOQVZiF2lNYWZk9YkYIITv//POn1VZbLc0888wdan5jjDHGDCONBtQun2HGhTJ1Ustm7W3k8sv3FG1XJEKL0H3K+sNWm3acsXCtA5mGiWtlMcYYY4xpZ0BtzKhRtk5q2cmeVlx+89tVEaH9rE1rymHhaowxxhhTgioDamNGjTJ1UstO9tRz+RW8fvTRR6farooI7VdtWlMeC1djjDHGmBapOqA2ZpQo6/ZbdrKnisvvm9/85qEUoSS34vjf+MY3Zr8fpj5jL1xxEyCb8AsvvJC5FRxxxBGpVQ488MA0adKkNMccc2SJnYwxxhgz2lQdUBszSpRx+60y2TMucadKbkVZoNtuuy3tt99+nuhqwNgL13POOSf94he/yFwcvv/976cyLLPMMunrX/96tu173vOetPnmm5fa3hhjjDHDxbgMqI2pR1m33yqTPeMSd1omuZWxcE2///3vs34wwwwzpB133LFUn2D9j370o+mVV15JZ511loWrMcYYM+KMy4DamHqUdfutMtkzjC6/3U5uZSxca/WfmOWYa665SvUJ1qc8Dvu49tpr3Z+MMcaYEWccBtTG1KOK268ne9pPbmX+P2PvKnzXXXdlnWX55ZdPVVhuueWyDsZ+jDHGGGP6gRO8mEGO8R6XyZ5W78Oyya3M/2fshatcfXBvqMLss8+ePT799NOVtjfGGGPMcNNv0egEL6ZXjFOMd9n7usx9WLamrfn/jL1wnXPOOdOTTz6ZnnjiiVQFbVdV+BpjjDFmeBkE0egEL6ZXjIvbb5X7utX7sGxyK/M/xl64Lrjggpn4rBqjqu3mn3/+StsbY4wxZnjpt2h0ghczLjHeVT0bqmxX9r4ucx+WTW5l/se0acxRh7jvvvvSBRdcUGrb888/vxZQ7RptxhhjzHhRb7DK+/1M8MJrJZ80ZhSQBZR+zWOr91iV7arc163eh/WSW2nhNe/347dkGBh74brddtvVGuPDH/5wy774ZExj/aL9GGOMMWb06bdozA+CV1ppJQ96zVCAFfTMM89MDz30UGkLKO67rd5jVbYre1+XuQ+LkluxjhYlu9J3sr75H2MvXLfYYou05pprZo1x9913p7XWWqup5ZXP11lnnWx9OjQuBOOSLc0YY4wxgyEaGyV4sdXVDCplraBVPRuqbFflvi5zH8bkViuvvHLdhc+HPblVNxj7GFc46aST0rrrrpt1rnvuuScTs3SYjTbaKC211FJZ5mA+Q6hecskladKkSbUG5LOTTz65KxfHGGOMMYNJt7OCNovLc4IXM6yUjR+tWu+0ynZl7+uy9+G4JLfqFhauKWW1k373u9+lHXfcMZvZmDJlSiZOo0CN8DnMM8886Ze//GVaZZVVunaBjDHGGDNYdFs0tpLR1AlezKBQJvlR2WRiVeudVtmuyn1d9j7sZ3KrUWDsXYUF1tUbbrghvec970nTTz99Jk7rLXy+6667Zn7om2yySV8voDHGGGN6SyuD1XZcdZvF5TnBixlWt9+y8aNV3eGrbFf2vvZ92HtscQ0sssgi6ac//Wk68sgj04UXXpiuvvrqNHny5OxPY4455shK3hDbutlmm2VldIwxxhgzXtQbrApek8CxqtW1FYtUUYKXImTtYX1XPzD9dvstawWt6tlQZbsq97Xvw95j4VoAnXOPPfbIFmOMMcYY0e3BaitxeTHBSzOc4MV0i7Juv2XjR6u6w1fZrsp97fuw91i4GmOMMca0SDcHq61apJzgxQwCZZIflbWCVvVsqLpdlfva92HvsXA1xhhjjGmRbg5WW7VIOcGL6Tdl3X7LWkGrejZU3a7Kfe37sPdYuBpjjDHGtEg7g9VG2Vdd3sYME2XcfqtYQat6NlTdziJ0OLBwzUEypuuvvz6r5/r0009PuLGa8aUvfanT18cYY4wxI0CzEjcub2OGhbKTLFWsoFU9G+y+O9pYuP6Xa6+9Nn3uc59Ll156aa1Oa1ksXI0xxhhTNvtqtzMVG9NJyk6yVLGCVrWA2nI62li4ppSOP/749OEPfzib2akqWglKN8YYY4wpm33VZTXMsFBvkoV+PddccxVOstgKajrF2AtXAskRrczwSIByk62++upp3nnnTTPMMEPHGtsYY4wx40ez7Ksuq2GGhXqTLM8//3yaZZZZ6iY/qhoXbkxk7IXrUUcdlYlW/kjIiHbqqadmj8YYY4wxvci+aouUGRbqTbI8/vjjmcEn4hrCptOMvXC95JJLsoZglugPf/hDWnjhhTveyMYYY4wZT1rNvmqLlBkG6k2y3H333WnJJZdsqxyUMc0Ye+H68MMPZ9bWTTbZxKLVGGOMMR3DJW7MqFEv+dFVV12V1l133b4ckxkfpk1jDrNBYEurMcYYY3qdfZXPWc+YYQY3eGO6zdgLV7k14JtvjDHGGFOWBx98MJ155pnpoYceapp9VQuveV+xrqxvzLBi4Wp6wdi7Cr/rXe9K119/fbriiisyn/1ppx17LW+MMcaYFkFw/uxnP0vPPPNMuu2229J+++3nEjdm7LBwNb1g7IXrBz7wgXT00Udnsa488odjjDHGGFPGHfhvf/tbWnXVVV3ixowlzz33XL8PwYwBYy9cCTI/7bTT0pZbbpk+/elPp9lnnz3tvffe/b4uxhhjjBlwojvwv/71L5e4MWMLWYYpfzPddNP1+1DMCDP2wvXyyy/PGuJrX/ta+tSnPlWzwO6www5plVVWSXPNNVeWdbgVNthggy5fLmOMMcYMYvIlxgoucWPGlSlTpmSTN/PMM0+/D8WMMGMvXDfaaKMJwpQb76abbsqWMrCPV155pQuXyBhjjDGDRj750utf//r097//fYLVdcYZZ+z3YRrTMx599FELV9NVnInov2JVS/51mcUYY4wx41nq5rWvfa1L3Jix5oEHHuj3IZgRZ+wtrrj3tuoKbIwxxhiTt7YuscQSWaMsvvjimaC11dWMWzmov/zlL1lm7Q033DDNMMMM/T4kM6KMvXC99NJL+30NjDHGGDPE1tZZZ501e3+22WarWV0XWGCBWobhTomDP//5z+mNb3xjVgPWmEEqB3XPPfdkEzabbbZZliPGmG5gV2FjjDHGmIrWVkTkyy+/XFt4zfuyurJ+p8QBQpjHTuzTmE5O4uAmTL//3e9+5/A50zUsXI0xxhhjWgSrp6ytgIskAlULr4HPWY/1O1krFndMXhszSJM4zz//fJZV+MYbb0y33357vw9tqMCb4swzz0wPPfRQT7YbZsbeVdgYY4wxplX++c9/ZvUql1122abrsh7rd6tWrLMWm0EqB/XEE09kZSR/+ctfps9//vNp2mltH2vVm4IJqdtuuy3tt99+Ld3XL1XcbtixcC3gySefzP4U7r///uw5ZW6+9KUv9f7qGGOMMWagWG+99dJ//vOf9OyzzzZdl5hX1u9mrVhjBsFlfsEFF0wPP/xwNrmC1wHeAauttpovTglvilVXXbXl+/q6itsNOxaugWuuuSYdeuih6bzzzpvKPz8vXCdPnpy23Xbb7M/rzW9+c/rOd77TmytmjDHGmL7xmte8Jvv/7wWuFWuGJUEZrsK8ltX1V7/6VVp++eXTLLPMksaJMknUqnpTvFRnu3EQrrbh/5fDDz88rb/++uncc8/NxGiz+qzzzz9/NuN5/fXXpx/84Afp8ccf7+V1M8YYY8wQ00p8mmvFmmEqBzXPPPNkXoqIqVtvvTVddtllaVipEj9aNolakTcFr5vFsF9XZ7txwMI1pXTMMcekz33uc9nNhlBdYYUV0oc//OFstqQRe+21V/ZIFsFzzjmnN1fMGGOMMUNNKwPcRrViO5212JgySDgx9r3pppvSz3/+83TllVdm72PIwepKH7344ovT3XffPXSNWzWLd5kkavn7e6WVVmrpvn6pwXbjwNgLV/zxDzjggKwxZp555nTiiSemW265JROza6+9dsPG22KLLdJMM82UPb/kkkt6csGMMcYYM9zWmVYGuK3Uim3FOmNMJ4nC6emnn85EKv3/qaeeyhaVhcLqeuedd2bilT4+TFTJ4l3PfbeeAK3qTXFdg+3GgbEXrt///vczv3xM7UcddVTac889W248ROvKK6+cWWmZcTLGGGPMeFHWOtPKALcftWKNqVIOKg/9EmR1pTTO+eefn/XbYaCsAK3i9lvVm+KlJtuNA2MvXEnEBPwJfOADHyjdgEsvvXT2OC4zHcYYY4ypbp1pZYDbj1qxxpQtByUvgAhJhRZeeOHMCkjOGPon7sMXXHBBtt2ge0RUiTst6/Zb1ZviuibbjQNjL1zvuuuurGOSiYvHssw999zZI+4SxhhjjBkfylpnWh3gRnGAZ1e9hc87USu2E4lpzHhAeae11lorrbvuummOOeaY6nPC7jDqsGARXGaZZbL3H3jggUy8kk9mUD0iqsadlnH7repN0cp248DYl8Phj0aZ0Kog0/wMM8zQ0QtjjDHGmMGmbI3VRgPcuF2va8UWDfSxHt92221pv/32a1iaw4xvOaijjz463XHHHRM+n3322TNhW8R9992X/vCHP6S3ve1ttRwx3aZMvdNW789W3XdZP1/ipsibogh9J+tTdrPV7UadsReu3ICPPfZYevLJJys1IDchzDfffKlbUHKHzG1kbCNxFMeLUGZ2hRto77337uifljHGGGM6W2O1zAC3l7Vi2xnoG1MlKeoZZ5yRVllllUz0tlLvtBd1UssK0DJuv1H0Rm+KZkRvijLbjTJjL1zpkI8++mil+BBmQq+55ppslhV3gm6wwQYbpCuuuGKq97nBJk2alC0nnXRS2mOPPdKPfvQjz4oaY4wxPaCsdabsALcflBnoG1MECUubQczrwQcfnPX7Mlb9st4AZTwiqtyf9dx3Ba/RGPE+qupNUWa7UWbsheumm26adUJSdiMQ119//ZYbDxeJ5557LrsZ2E83UHwJnX+HHXbIjm+xxRbLZl3+9Kc/pW9+85vZ7NMpp5yS3SzU0jLGGGNM9yhrnakywO2UUCxjoSrr+mxMnlay295zzz3Z+JlxN/2N8eyGG27YUW+AMh4RVe/Pqm6/Vbwp+umFMUiMvXDdfffd05FHHpnNYnzwgx/M3HFbiXe96KKLstkiYFYGi2c3WGGFFdJXv/rV9K53vStNN910Ez5bZ511suPnpiXd+Kmnnpo+9KEPZVZaY4wxxnSHstaZqgPcdkRoWQtVWddnYxg753nhhReyBEzTT18sMfgMYxEWfcpR8vyHP/xhWmqppdKiiy7aMW+AMh4RVe/Pqm6/pjpjL1wRhsSIctPwo44Y/Na3vpW23nrrulmIjz322MzaymwMM5Kf/OQn07zzzpu6wdlnn93wc2Jrsbq+4x3vyF7/6le/snA1xhhjukQV60wnBrhVkiZ1OzGNGW+K3FYRs1hUlU04D59x31DnlTE0j3PNNVf63ve+l7bbbrtsUqYo4WkZb4CyHhFV789+JlEbV8ZeuMJ3v/vddPPNN6errroqm/nBFD/nnHNOuHFWX331rKPzZxR9+MmMdtBBB6V+svHGG9eec/zGGGOM6Q5VrDOdGOCWTZrUi8Q0ZnyhzzCJUiTsGIvSh/JW12ht5fmCCy6YJWviNYmabrzxxnT33Xdn/ZqwOJWpLOsNUNYjour9affd3mPh+t9iyeeff3768Ic/nH7yk59kDcNNxA2jm4Y/inzA+Z577pl+8IMfVKr/2q14grw7sTHGGGM6RxXrTLsD3CpJk7qdmMaMN/QF+nceBCnj0iKra7S2UgOWhX4nq6u2Oe+88zK3YWrF8n4Zb4AqHhEWoMODhet/4Uf65JNPTvvss0/mKnzhhRcWzrxQd2qTTTZJBx544MC45F522WW15yuuuGKlfVAYuhlFP1DGGGPMONEp98BuJk3qRWIaM76oz/BYBJMreatr3tqqEDvyytCf89vcf//96fTTT0/LL798lsSp23VSzXBg4ZqDrL0siDSsrGT15Wbiz2f++edPq622Wpp55pnToMCf5+GHH157veOOO1baT6OAeGOMMcb8fzphnel20qReJKYx44v6V5FwnXbaaaeyoBZZW9VnMQjxumgbxrhnnXVWloAUzwUmUbpVJ9UMB2MvXIlvBWYwyciruFZcbolrZRlkjjrqqHTttddmz9/5znemNddcs9+HZIwxxpg+JU3qVWIaM57E/lWUVRhrKRb7aEEFWVv5jH4bvfgQrE8//fRUVldZaan7itWfSSPWkXjtZJ1UMxyMvXDdf//9M9G6xhprpI997GNpmMBF+DOf+Uz2nD+x4447rvK+cMloBj8I/DgYY4wxphrdTprUq8Q0ZjzJW+jr5V2RBVXrydraaMwZt1l66aWzx7gd3gksWGhnn332Wo6ZTtRJNcPB2AtXfoQpgrzyyiunYQI3oe233z6bjcJ1mTgA/pCqssgiizRdx4mfjDHGmN7Fq5YVoU5MY7pNtND/9a9/nSqzMBMoCy+8cPacCRH6r563Mk6N2/BYbzvGvoxdcTUGewOMB2MvXEnFjRtCvzMDl4FU4ZThefLJJzMx+Ytf/GJgEkUZY4wx40S34lWriFDHq5puEy30ZP+dPHnyVIISaynQlxWvSmWOesmcInEbHhttRzztUkstlU3e2BtgPBh74crsKLWjbrnlljQMkCxq0003zR4R2yeccIJdIowxxpgRi1etIkIdr2p6mZzs6KOPzsbQEVx411prram2I7lpWRCjrWyHEYr7xtmuR5+xF6677757ZrG8/vrrM/G60korpUGFP6TNNtss3XXXXbUfjD322KPfh2WMMcaMJd2MV60iQh2vasaRSZMmZfcP3odyUzajydgL1y233DJtt9126Ywzzki77rpruvjii7PZpEGDP8TNN9+8ZhmmBM6+++7b78MyxhhjxpZuxqtWEaGdKNVTJl7XmDy49vYDXPV///vfp+WWWy6tvfbaaZZZZunLcZjuMvbCFU466aS02267pbPPPjtL0nTQQQdl9VDnnnvuNAiQPGrrrbdON9xwQ/b685//fDrwwAP7fVjGGGPM2NLteNVOiNBuxusaE0vaCPoO/ahf/Yaar9SCpTwk9yRxsGZ0GHvhuskmm9RmiKgZ9fDDD6cPf/jD2bLkkktm8SetzNow03rRRRd1/AJx85M9mD8y4E/ksMMO6/j3GGOMMaZ1uh2vSlmPdilrPS0Tr2vGEzwAf/KTn6QTTzyxZlCJUHP1//7v/9Kiiy6a1l133bTOOuv03PrJ2PlPf/pT5qXI9y+22GJDlYTV1Gfsheull146oTPrOUKW7L0szWDdbt0Qu+yySzr//PNrInvvvfdON998c931meHCTcIYY4wx3aEX8aq9tp6Widc14wflF4888sj01a9+tan7OuPi++67L1t++9vfpi222CILd+t1WUX6MZmPiXtlAmZQPCn5zbjxxhuz34prr702W4jTlZt1p9ytl1hiibr1duuB7tHvWR70x/e///102WWXZft94YUXsrq7WLa32Wab9P73vz+rsdtNppnSL2f0AaFTLgQI1yKXiU7stwz8aeIi0Q2ol8XsLT8ADzzwQFe+wxhjjBl0EHQMiK+55pps4BYTO2LlYcBMnB2DdQbMlK+7/PLLW45XJclMzLdRJe5Ux0itTaynOpZWzkmunvEczPjyj3/8Iwupow9WBasnxhc8Cvo13idD8eqrr95zAZ1nr732ysIU69Ev4TrXXHNlE1aUNMpzxBFHZKGKjbQOVvYzzzyzUgbpVhl7i+sll1zStcY1xhhjzGjR63jVKnGnZa2nZeJ1zXhB1Q0mL5544om29oP1FYst/RcjS68h0RmuzQg5ykoi0rpBK5NMUZhioVxjjTWye5v7rZPfd/755zetnXvhhRemj3/849lz8vsUidZTTz01feYzn8me8ztAcljacL755kt33nlnOvbYY9OVV16Z7r///sy6zkRHt6zbYy9cN9xwwzTIjLlB3BhjjBkoeh2vWiXutEy247LxumZ8QIB0QrQKPA6+853vpAMOOKBvlldicHFffutb35pZCKtw8MEHp0MOOSTTEIQclp1koqLJRhttlE0Irbjiipk1mNdlhetLue/79Kc/PeHzVkIHv/zlL9ee1yux+ZWvfKX2/De/+U2WMFZQs5ewxne9613ZZ5MnT07HH398+tSnPpW6QddSbWGG7/ZCMiVjjDHGmF4R41WpRFBv4fOieFUsJLjTPfTQQ02/q57ltJEVJW89xY2Zx3rbNorXbbSdGW3wIsA9uFOiNYrXE044oSvhda1CX8YtvlEemzL3adEkE2KS10XstNNO6b3vfW/bWY+vy31fWfhN4RxhqaWWykpq5Xn66acz7wvAMhxFa4SKLILEWN2ia8pPCYtsMTTGGGPMqFClvmpVt9+yltMq1tOy9WXNePD1r3+9rZjWRtCnEI5bbbVV6hfcwxdffHEmxPLW316457fLSwXfV5Zf/vKXWYKlRtbWOGGFuK3H0ksvXbhNp+mqybIV0Rqz+HZyXWOMMcaYTtNOvGoZt98qcadlsx1Xidd1rOvogxAie3A3Offcc9PGG2/c81I5Eay+iNcddtghzTDDDD11z2+X6wq+ryynnHJK9sj2u+++e+E6xLHOM888meX9rrvuqrsvYl3F8ssvn7rFtN2cyWi2fPe73806CkKUWk8/+MEPsk7y1FNPZT+cPN50003phz/8YTZjyXr8YB599NHZ9t1wM6Aj7L///lmQ8/zzz599X5FLMsd2zjnnZAvHbIwxxhjTKbffRpZT3i9yQ2zFehq3LYrX5Zi0KH5X23XLAmcGC+q0tuJR0A5MlFx99dWpF5DVm+zajN3z0K/RGr10z2+Xl+p8Xxlwk2YfgMZqZE390Ic+lD2S3IoJh0axsmimffbZJ3WLvgWJHnbYYZk/9EwzzZR++tOfpve85z1TrTPnnHNmM4wsNMIvfvGL9L73vS8rbIzy/+IXv9ix43nsscey9NR/+MMfau/JsltUkoY/AeoV0WmWXHLJdMcdd3TsWIwxxhgzWpSxyJS1nBZt04r1tB/1Zc3gc+KJJ/bke6666qrM6trt+rPUScUllr5PUqa8QQprIfGbvXLPb5fr6nxfWWurdE49N2Hxuc99Lpu0wr17u+22Sx/96EezdsQaixX2uOOOy2q7kn/oe9/7XlphhRXSSAlXFDsZuQBrapFoLWLnnXfOfjgxZx966KFZVi4so+1C4DUWX9I4t+qGjKWYGQjEN7MWzBqts846bR+LMcYMI1XqTBozLpR1+60Sd1ol23E78bpmNKEv1Os7nYZxt2oGl7GeUlqHSZxWSq7cc8892T33wAMPZFmEeb3MMstMWAfLKuN/Jnq67Z7fLi81+L6yVnXAVZsyOM3u/bPPPjsTu7iQf/Ob38yWyDvf+c6sZA7n2U36Ily///3vZz+UdBwylpVh1113zVJQMzuC6O2EcH33u9+d3QSAuR1L7iabbJJ9D7WJGglpZdFiFsLC1RgzjlRJZGHMOFHGIlM17rSK9bSdeF0zmuBSyxi9FyAWb7311iyOtFPW0/z66AWE6fPPP5898hqxF7fDGIV1tYrltNfJza5r8H1lLN2KSeX+x8O1GbQ7HrL14lwvuOCCrL0owdOtGrl9E66XX3551kGqCj22wzUXs3S7nHHGGZm1lONhJhFXYXWCIhfhCH8OCy+8cGaxveaaa9o+FmOMGUaqJLIwZlw8DspaZKrWibX1dHhBvMXJiX4S65L2AsbgxFe2UuIS0cS9wf3G+JuJ0kaxmVqfcEDEOI+M8fPbEbbIfUR9V8q/cJ+efvrpE/Z1/vnnT6h5CuiQRl4Im222WXb/d8rq+lKTSa2ySZlgzz33bLr+r371q8zQyHe+4Q1vyAx7G2ywQZpjjjkyq/lpp52WtQ25itB4F154Ydc8r/oiXOlwUPXiabsytZUapYIGbpiTTz65JlpbhQvI+XATGGPMuNHrEgDGDJvHQVmLTNW4U1tPhxclJH3uuef6ehxYQOWB2CuwhCIwyRfTCKynGK1oJ7bhkdcLLrhgoeiN69O+JFydPHly4XYYqhDQ3MO6TzsBbcm9nZ9kqjoh9ucWJ7UagfiU9qENENeNoM2oOSvXaay10brLBMBnP/vZtNZaa2X7YhLmYx/7WPr1r3+dRka4KuV0zOJVhptvvnnCftpB1lY6kmZBy6DOzSyOMcaMG70uAWDMMHkcVHH7teV0PEG0MgnRiuWxk9AvEXPEjkrU9fr7Ea71BKggNhUXYY4Tgc3j7LPPnr1fNH6P6yO0mDDisWg7hDD5dzh/3acxMy6fMymFl8Riiy2WxQETrkjI40YbbZTd/0XwPVhzqyQ3K5oQ+2eJSa16nHXWWVkbADmGSKjUCBLjKgaeJE31XJJx22bB2oo3K9/BZNpICFcu9PXXX58t+Eyj0luF9VkYIMVit1XhDwPwya7CzDPPnD2WTUNtjDHDTpU6k8aMk8dBVbdfx52OJwi3dkRJK2CJpJ9izWORiBGtxDt2+nhw42U8Xs/tl3U4VsQ96yIsOQde8z66Iore/Ppkv+VzHrGC5rdjX4jThx9+OLtvi+5TBBsiEjHKvQ5Ycd/+9rd3JblZ0YTYeiWSqXXKTRgLqlDm5XqsueaamXDlGG+//fa09tprp5EQrttvv30mWpkxIZMVAb2t3KjMAsXMV2Swapdpp/3/pWyrBqJTlgdayWxmjDGjRK9LABgzbB4HLjdj+g1j7ccff7wmVHH9bDTmnXfeebO+3GqVjXbB4kdcKRU6sGYWWV0Rm0wSyVqqhdcIbT6Poje/viZQecxvt/zyy2f3MG3C9yNuG4HFUy7dHGs3JpkaTYht28b34R2qOqyrrbZaWmWVVZpuk58QaET0JumW50BfhOu+++6b1fnhQtBpaDxqs1Lmhqy+RWqftM3f/e53sxkR4I+B/bQLAy1mLnAZqAKuBeDyD8aYcaLXJQCMGUaPA7v9mn6AECMPDEKVR1xmW4UwPMRrL2r2Ih5Z6glQiSVELeKW5/PMM0/2Po+snxe9+fXJcIvYFLymfbQdugPxiisxpWHYTzPLaTMBN6ghOKeeempNXLZibYUYe3zFFVeklVdeue66JGYCjrlK+OXAClc6Jxmottpqq0w0IkaPPPLIbCFDFXWW6EDMaFB3ic4Fmv2h07B9J9wZCHhWHVa+p8w+cVkmnTQXyFYFY8w40esSAMYMq8eB3X5Nt0GM4OYqq6pcWauywgorpCuvvDJ1GzID1xOgVayniF50g9aPCWHzaDss0AhXXPQxQpF0tRk33nhj6iathuBM89/qJ0wYt2KAk5sw7Ut8aytsvfXW6dOf/nSmwb7yla+kbbbZJrtueYj5xZtW1V+Y/BgZ4QrMQl5yySWZlfUf//hHTZTScW+55ZbaenlXBToX1tdO1G+Fd7zjHVnKa8QzRXUPP/zwln8kCJQW2223XUeOxxhjBp2qdSaNGRXscWD6CW6tuP8i0rCo8nvbidqrCDlECSKOeGt5OXbLRZj/CkRUPbffstZTRK/cfpu5/ALrNSt92Q34b5TLbnxP8L+JYYwJYYQ3j+1OBt9yyy3ZNYUtttii5czJTGLstdde6YQTTsiOZfXVV0/7779/Wn/99WvlcEjg9POf/7x2XdFT3aJvwlVBvBQ6Pumkk9KPf/zjTKnTifJilThUhCoZvvbYY4+ODoB23nnndPDBB2cd/hvf+EZ2E+G23MxHHMFN7VY6POex6aabduyYjDFmkKmacMaYUcEeB6bXkBhIFlXEKpMn7cJ4GqHK2JdHhIhArBx77LGpW+BKyhgaIVokQBG0Za2nrI/oRUe00j58L4Y0JWrtFRjsaN96nHnmmRNeIzSZJH6kjcngmJQJLVUG+gEesni7ooE+//nPF66HxxWWVzItj6RwlS/9+9///mxR9iwahefMwOB6g9me592AG+P4449Pm2++eTab8/GPfzyz6CJoSc8dOxFuGHSY3/zmN7VZKGZBEN3GGDMuOOGMGWfqeRwwWGYg3guPg3x9RzOa/QyBqlhVhc21A4YgLG2IVBbcOZWkNA/iBs/ImFW2U1AihvsFkVpPgCJsy1pPWZ/tWkk6xL1Ktl7EelXhitWb69PqPaj7tuykA+3Fcd5b0epK21BaR8lkcfct+/1YVT/4wQ9mxkbCKzkXfv+4XnjDYsD7wAc+kBZZZJHUTfouXCOI03XXXbfn38vMwE9/+tOswK5qOSnpklwIyIQsZBHmeAl0buUGMcaYUcEJZ8w4U8/jgMFhFAHd8jgoqu9oV/zhh/5DbCrjT0QBRpxOZPZFqMiqSq1UDEatGna+/OUvp7333rvtmNn8fkmIpLwI9QQolLGecg/UK6dTBAJXohWPT1xgWxWg1DPl+LkHuRdbuQfjfYvYQ/TFbfj829/+dlZBhVIyJK6NNVOxeD6amxBrtX/wu4RLb7tsvPHG2dJPBkq49pMddtghu5FwE2aGKVKUFhyxe/TRR2dB08YYM05QVNwJZ8y4Us/jgPeI78q/1+nsrEX1HZ0AbfhgXIk4xaJJ6BlWxk5kq5155plrrr8sUfyUBXFHFZCPfvSjHRGvCLW3vvWtDRP3sA6f33zzzVmy1jLGoaeeeirzlmQ73IDrQf1V2gZPiT/84Q9Z27Mt8ZzdugebbeMQnNawcA0gQi+66KKsU51zzjnpT3/6U+YCwM3KjU9Hp5guxYaZ6TDGGGPMeFHP4wALCi51EcYOrN+L+o7tWF3tetwb6DNYyYlxRLDiatouTJYwPpVYVR3WTrHiiitmIXFf/OIX23IbRkzutttuTZMCId4vu+yy7H7CwrjBBhu0VBOU7RB/zbbj+5l0oo3I1ounJd4RCH7EMnlrOn0PtrKNQ3CGSLgy64D5nNTbmLLxcedPIT/zxGzIVVddlT3Hh7qVlNVVYL/d2rcxxhhjRs/jgLELnw1bfUe7HncPZcVF8CFWuV6dcP+ln8miyvVvRdi1A5bXE088MUvwQ3bZMnVhEWbEP26yySZTeSQUofI3GI44v6LarlW2434h6RMCmudYW0kQi2BEvHL/4va/yy67NJwEqnIPtrKNQ3CGQLjiIkFWLcz0Qjd00WwRM5ckcWKmgoK4+IG3gjouxXYPOuigCZ/RsQF/c+IAjDHGGGPKQuxaVeHaisUznxSqUX3HMtj1uHMwhqUuKEKVZdKkSdm1apdZZpllQvbfevGh3QRx/L73vS/tuOOOmVciSUsR40Uwhuc48VKkT2PNbIVY/gZxXK+2a9ntGOMvvfTSExK9ytrK/cPxYqVl/UYCtMo92Oo2DsEZcOHKjAiJmLCwtjr7RED5hz70oUx80iHJakWR22ZQlJdOWeSSoXTc++67b/rud79b6VyMMcYYM97gFcbAt1sWz3wJHqou8NiO1bVbrsfjhK6bxCr9oF2wTHJNZVVF1PSj3mgRiD/EKwsGIURYhOOmQkeV/iOrqcrfFNV2LbMd435iajFMxfaL1la2o43p+7xu1P+r3IPduG/HmeIc2D3g3e9+d9bREK0kRSI7L7NUH/nIRxpuR5kacd555/XgSI0xxhhjGqNBczsWT0QQr/PkrTZMusPiiy8+ob5j2TIbRS6MvC46BvM/0YNQPeOMM9LXvva1dOCBB2bus+RFaUe0kkwIN9Ytt9wyiwWldieJieaZZ56BEa15ikrpEOcdRR9tQuxos+RO0WrKc0Qdj7Ke1ktcVbQdx4Wxi5hihHa+/aK1lfaV1yVlL+v1/yr3YLfu23GmLxZXbnaspXQkfLpxFZbbQ7Obk4BqZkaw2JKFrRVwUaCDdDKdtzHGGGOMXH3PP//8bIxSpq5qqxbPvNVGYyZCqKpab7rlejxqYGBB0ET3X8RruyCUSHxEJlvyujDxgcgbpbq8rSZMyltNEZtamlldtR33D0mqqCnKe1hbKf9Dn6a0TD1rK+s899xztfuok/dgN+7bcacvFtdf/vKX2SOd9+STTy7tq0/iJH5ImPFqBWUwu/HGGyscrTHGGGNMY1ffW265JXssYz1pxeKZF5gIGwbfWnhdxXrTyIVx3K2uiCCMIyeddFJWs/Owww5Lv/71r7NrXFW0YolceeWVs/KLZOj9yle+knbfffdMIBHDOorEhEn0UeWVaWY1xQoKPDayulJuinw56AnakDhWuVnzvYhTRGq8Znlrq+JveeR1p+7Bbt23405fLK6ytlKQW2bzMkiI0llbgeBwbhY66wc/+MH03ve+N5thiS4OuOfUu6FapUpsizHGGGOGFwlABta4drZqPWnV4tmN+o6NXBg5/nGzutIeJPxU9l8s6O2iLLayqmIt7Hb230GiTKKlvLVVfY7HIqsrbsAIP6y4fE4umyhCEbG8ph/PN998Natr3trKZxynFiZvqOnaiXsQOn3fmj4JVzoaLLfccpW2V8dsNVPbPvvsk04//fTs+fHHH58tEay3pPhmaecHqhOFo40xxhgzHEQBiLshgqdVwddq0pZu1HccdxdGXHO5VnL/vfPOOzsyhkMsIVRZcFmlPceVVhMt5a2txPrSjwWv6at8zrYbbbRRVhKTa3jJJZdMJUIFr5944oma1ZWJIa61rK1w++23Z4+8h5iWUM6Lyar3YKfvW9Mn4SpLJ52uCnREaLV8zWabbZYFzx9xxBF11+lEXS1jjDHGjA95V9+77rory8PRTPCVsXi2U9+xqMxOPRdGIUvWqFldiR+VUMWqynVrFwwpGGEkVpl8GNRESr2kKGES/anI6oqFMwrcetZuxOW8886buXFzn0SX3yhC88jqqozPiESSYEV4H1du7h/WzYvJqvdg1fvWDJhw5cbmQmLar8INN9yQPZYJYCfz2zve8Y70k5/8JNueG4Qfav3ZMMMin3pjjDHGmEbkBSAhSIihVgRfWYvntttu27EyO91wPR5EcE8lkRIilYUES50wvDDJgOsvQpXnxFSa6omW6IsIPAnGPAhcygHhHoyRSZmb64nQIliP9XEX5rvoGxHuWe5Bvkdhf1FMVq2xWmUbM4DClZk/1WFl9oVO3CrXXntt5tKB2CzrvkLdWJYi6y+1qFzH1RhjhoMiS5IxvSQvPrH+aEK8kZttryyesczOqquu2lXX40EAQYIgQqRiXcP6HV1O2zG2SKji/juqiZQ6BeKyXqIlrk/e6oqAZZui5ESIR+4HTQ5g4VaG4HoitAhth97A1TgPExx4cfJdJIA1g0tfhCuWT2JO+ZH/6le/mg4//PCWtuOHnRlDsd1223XxKI0xxgyiAK1nSTKmVxS5+iKWGGg3KmsDVS2eZe6VRmV22nE9HjQoeSKhym9BK+fUDISphCqP9SyBphjuhzKJlrB0ktQsD6VtmFyp53pdT4Sa0aYvwnXnnXdOBx98cDbj8o1vfCP7Af6///u/htuQQZi04aQnpxOvueaaadNNN23p+5QtWAWGIxtuuGH22MrMozHGmM5RVYDWsyQZ0yvqufoSJ4coxDOsntW1isWz7L1SVGanXdfjQQCDB7GMEqtK9tkOeN4hoCRUiZ+MVSdMeeHaSqKlehmGgeRLTAY5XtgMhHClk5LZd/PNN8869sc//vEs9hRBi2uHOPPMM7OYBGYJf/Ob32Q/WMAfxI9//OOWv0+df999953KHZjSOHzGD5YxxpjeUUWANrIk2epqekHsg/Rd3ByvvPLKLKuwxigM0Jk0L+qbVSyeZe6VVsvsDAOIHkS3hCpip2piz7w1TwmVmEBQtQrTPlyfZomWZHUlMVO+LCaTCCQ4M6aIvhWUwrz/05/+NBOOCFISJinpkmZYtt9++6my/uJmcOqppxa6FVRhr732qolafsyNMcZ0n6oCtJklyZhuE119EZ9YQSPE3DFWYT3i+vLJjRC49F3GQa24x5e9V1otszOo4GGn7L9YV2W0aAcmAKL7r5NxdpdW3KsRuDGzM3GsxBCTOdiYevS1EvIOO+yQVlpppcxNmFpMEX7U8yVq+JE/+uijs9nDKrjkjTHGdI8yMXhVBOgoWZLM8BJdfakPmReu9EFZjHDrvf7669M666yT9fMq7vFl7pUyZXYG5V5ByNMWEqvErXbCs2/ppZeuiVVcT+3+2xvoV0suuWRL6ymzMF4KXCe53BszkMIVGHhcdNFFmfvLOeeck/70pz+lhx56KJtVZIYMd4611147vf3tb69sEWXmk1lRZvGMMcZ0njID8qoCdNgtSWY0iK6+5513Xpo8efKEz3E7RTQB/ZiQKNYjpwaeZWXc48veK2XL7PQDRD8uvxKqHFMnDAtMlkmoLrPMMlm8sek9WE7JQ9MqjPO5X1xWyAyFcBWkn+5WCmpqPPHjSAwKfwKDMstojDGjQpkYvCoCdBgtSWY0iTUd8QK74447pposX2uttSa8R7zrL37xi2xS54knnmjZPb7MvdKrMjtlQZTyvbfccksWq4r7L8fXLsRI4loq99988k3TfYrijbm2TNYUJV2KIFSZYKA/m2o8OIZl4foiXBVbwI8MP+IUFe4muBgjXEn0xMXdZZddskLh0W2EH9NTTjmlre/ZY489OnC0xhgzXJSJwasqQIfBkmRMIxiHIN7o4/TfsvVem90rVcvsdAOOg3GVkiopWU87MFZE6Miqiju2s872l6L4Y9XTlRtwvZJDXEN+v001XhrTsnB9Ea6kwWYGDkHZbdEKH/vYx9IJJ5yQXWRcbL7whS9M+JxjwV2ZpSr8eFq4GmPGkTIxeFUE6KBakoxpFSxQlMhhYoeBJlmHEXOqnFDUZ8veK1XK7HQK7keqQkio3n///R1x/yU2FaFKPhTcSXsxZjStX3Nl0i5yBa9X6oa+z/VsZpE1jbluTMvC9aXX4OrCIKNX7gH86J122mlZBuF6s35O3GSMMeUpE4NXVYAOkiXJmCrcc889WZ/HTXiOOebIRCgiVpmH84POKvdKlTI7VWHMhOhGpCJWJ02alB1zuyBqVKYGN2Dcgc1gwu98rNEqeI++UGR1xdOS/wgnymrP7felOl5OFq5dglkYfnA7OdvXjG222Sa7ic4+++wsOQIClj+Bk08+ObMQ8ANJEihjjDGtUyYGr6oA7aclyZiy5CfCo7WV5yr3gWClr5OUEnHKgFUJhareK4q97Za3XHT/5XzahYkp7muJVc7F7r+DD+NnMmrTn4v6P30lb3VlsgRLq0Vr+26/19XxchoH+mJx5YeVRr/88suzQUavMolx0+y0007ZIhCusOmmm6bvfve7PTkOY4wZBcrG4FUVoL20JOUZx+QXpj3yiYfy1lYNSBGpvKb8CwmevvWtb6UPfehDWfKnQZis4f5GcMuq+sADD7S9TwbZJMyUUKVsit1/h9PaSnxr9AIQjOkxDmEtl9WV97jezhzcvtvvSw28nMaBvgjX973vfekb3/hG9mN95JFHps9+9rP9OAxjjDFtUDYGr6oAjVlce8m4Jr8w7WVVfeGFF2pZVaO1lUE+90N0r8Q1FusUn1PvlbCm1VdfPctK3OvJGr6PcoQqU8NxFwmTsmBZVuZfvNvIumyG39rKZElR/0ec0u+j1ZWkWiRkGhc64fZbpSzcONAX4coP94knnph23HHH9MUvfjGbgTvggAP64j5w0EEHZY/51PXGGGPqUyUGrxMCtJcW0HFNfmFap0hYMpjHyspgncGkrK1A0qIi+BwRy0CfsRAWTvocgq+b9Uifeuqpmusvj0zStAvHi0BV9l8G1Xb/HR3oK1hb61n4FOssqyt9bFjdWKv833TK7bdKWbhxoC/CFRdhBjAHH3xwJhw///nPp2OOOSa9+93vzooWM3vQ6szMBhts0BHhaowxpnX6kTCplxbQsrPgZvygjxQJPSyqWCsZVHKPIGRbSUbJeqwPDEqvvfbadOONN6blllsuiw1k3NQu7Be3ZFlVSbDULgy2OVdZVXH/tUvo6IIQpY/j8j158uRarLMEKx4AEqrEu+IO3++JCyZR6e/cR2iMbv7fdMrtt0pZuHGgL8KVMjixE9OxmdUoG2PKPooCw40xxnSXfsTg9dICWmYW3Iwn9IUiV1oGo5QJkdWVMU4rGXcZoLJ+hP0zkGWh/ryEYaulRBDDxKZSPxaLKiVrOjFumm+++Sa4/2oAbUaf1VZbLetXuMTzOyzoX3mwBNbzaKwiJqtsxz30hz/8Ibsn+R3fZZddWoqrrvJ/00m33ypl4caBvhVRKio/45I0xhgzHHQiYVI344DaoewsuBkv6H+EO5Gro8hiSf8599xz09VXX50222yzbODZifg+vovlqquuyqywCEfKixS5HcuiiqWolXu0GRx/dP8tIzTMaIH7Lwaoot/5/HpveMMbCq2tVcVkle2USIqSTdw3vEZ8d+P/ppNuv1XLwo06fRGuuPf20m2AZFCC7/3xj39c+Fk75PdrjDGjTD5etWwsUDfjgNqlzCy4GR+wVJJQ8qtf/WpLYhCXytNPPz2deeaZaYsttkibb755R1xoGeTedNNN2bLIIotkg3GOR6VqcN9sF+Jssewq+y8Jdjrp/ss54AbNvYRLNAvCQgaMThkymFy78sors4kEBD/tg7CfeeaZs3NiPEomZwRWFZhIwPLHtYYNN9wwXXrppWncwAp68803Z+7DxGoD3gP1xvpVxGSV7WIiKX7TeeQ1k5GNBG+V/5tOu/3mv7OMl9Mo0xfh2uub+qSTTppw80SBmf+sHSxcjTHjSJVYoG7GAbV7LmVmwc14gODZbbfdssmZstCPfve732VCbe+99+5Iohr6KQN4RCqCjAEtr1txSa4Hg2UJVQbH3cwCi1hk/NVtuH+LEmJFF+wf/OAH6VOf+lQ6/PDDS48HP/axj9VE67giKyilbxCwTAYweZm3wLYrJqtsJ6HL7zbXlkfc3BsJ3qr/N512+80nNyzj5TTK9M1VuNdo9q7oR6kTM3v9Djw3xph+UTYWqJtxQJ06l1Znwc3oQ5karKXKDFwVBvZYbJnYYSKkrLWXmEIt+TIkWEMpM8P7DNTztWSLoE/j/qtY1XnnnTf1ijjuInnPGmuskU16dboWJeV9ZP1717veld2ziALa6JJLLklHHXVUlv2W60IbYk1vlbPOOiv9+te/zn4XEBnjisQhbb3wwgtn/bxRpY4qYrLKdlHo8p9DPVlivJsJ3ir/N91y+80nN9y2D2XhBo2xEK7EolT5zBhjTOp4LFA344DaocosuK2uo29p7YRoFVhLvvOd76QPfvCDmQClHxfFqSr5jZZWEyrh4osgxVqqbQXCjMG7rKq4dVYtQ0hViEMOOaSya+yWW26ZxUlyD3EsHAevOy1cEVBUj3jb2942lYEBC9Z73vOeTBA89thj6etf/3raZ599sjZqBr9f++67b/acWOc99tgjjSNRHNLXqN2K+3S938WqYrLKdlHoUkuY8BYeGwlevqfK/0033X47ldxwVBgL4brnnntW+swYY0xjysYCdTsOaNhK/JjBhUEs7sGdEq1RvJ5wwglpnXXWyfr9W9/61ixLMPeDxGYrFtNGIAS5V4g3JA6WeE5EBf21TPbRbtVN3mmnnVIvwI26EUsvvXT60pe+lLn8MjlwxhlnpE984hNN9/u5z30uc0HeeOON0+677z62wjWKQ8B6jcirZwWtIiarbJcXumTkBn63ybBdT/ASp1v2/6bbbr/1khuOK2MhXI0xxnSeKrFA3Y4DqmIB1eAcgeJZcCOwwFWJaW0F4iKJeV1llVWyCZL555+/I2FLCFasrSQfYsHKyr2DdxkDferL7r///i3dJ72sm9xPEJ+C9mkGiaSOOeaYrC2OO+64NK7kxSG/3/wWIzCLRGFVMVllu7zQ5V4A7o16gpfv4V5ETJb5v7Hb74gIV3zcI8z21fusHeJ+jTHG9I6ysUC9igMqQxycY/VaffXVW0pw41nw0Qa39zLxjlVgEExyJSwvxJdWydqLl8NMM81UE6pFwpJ6slhbGaTjlnvxxRdnWY4HqW5yP4nW7WbXAKvs+9///uyaHXjggVmM8LiSF4e0HZZQ+jX/A3kraBUxWWW7vNDls+hqz2smKaPghTvuuKNWZqfM/43dfkdEuDIgUTwBj7HTxM/aIb9fY4wxvaFK7OkgxgHlB+fM5o/i4NyU4yc/+UnXs3diYSWhDe68PBJz2gpYlWRVRbQ2Gk8xRsKKiBBn8I93wfHHH58N3tdcc8262/aybnK/ueyyy2rPEfaNIJ6V3wqSPeEuPK4UWUERrFglH3jggamsoFXEZNXtqF8c3Zdvv/32wnOQ4GV97if6ORMSZf9v7PY7Yq7CjVxfOlWnyxhjTG8pK0IHMQ5onAbnphy9StyIJZT7iME+90CRxY/3ZFGV+2+rYG3lfmNwj0jlEaH8y1/+Mkuis+mmmxaWvelW3eRuxcxWBQvbt7/97ew5kwCNsrYyAXDooYdmz3EVluVvHKlnBaVv0aZ5K2gVMUlt3Srb4YaPsGxlIoj1WJ97ANGLxRjPoTL/N/ma5mZIhSsuvPVm8hp91g30Q9NtCPA3xphRp4oIHcQ4oG4Nzs1ww0RJvf7ZabhvSGhDKRtZXeX+K6tqo9qWjYjWVp5jFUOs8pr38ZL4zW9+k7beeusJmY1biV2vwiDGzOLuq/A1sgQ3EtPUnkVEkViKLMXjSj0rKCKQvltkBa0iJqHKdghlZeVuBvcX6+OyT1km4p0RzGYMhSuzfFU+6wakbe+FULZwNcaMA1VEaK/igFq16FQtMm9GHwbb+Tqp3YQBNlYqSrLgro41p9mYBbGL4KpXTidvbWVQzsJ9K6srn+PyevbZZ6ftt98++95WY9erMGgxs4jo733vezUX4cMOO6zuuqecckq68MIL05xzzpnVfh1n6llB8R6IGbijFbSKmIQq23GNKK1UBoSrGQ7GJqtwGbdk/jAarV/0eS8tyMYY00+qiNAqbr9l3QrLWHSqFJk33YPBbbTa95MqdUnbAesq9wX3Cv2vWR1RrFtMrjCYx8V4gw02yBKL5dehBu3jjz+eiVeyFtO+DOqxSvE+n/M+IuTMM8/MJm8Y22hC5/zzz5/qu3nvy1/+8oT40EbjH1yu3/ve9w6cWz7XeO+9986e4+r661//utBlGvj9+uQnP5k9/8pXvlLLajuu1LOCMvGSd7OVFbSKmISq2/WLQXOFH0XGQrhSfLoZ/JAee+yx2Q87P9wLL7xwWnvttTO3ZgZR/KlQs+uaa67J/ij0Z/ORj3wku7GMMWZcqCJCy8YBMdD90Y9+VMqtsFWLTpXEUqa78N/LABfLY79hAN5L6GM6fzKbIozyQjRy9913Z2IT12IGx3fddVdacsklC9fBAsY9yP64Z3nkNe/jnqxttS+ssNGbYhTd8q+//vq0zTbbZPc+bXDOOefUTcqEEKGWL+IVMcKYb9ypZwVljJwXs9F6OuoMoiv8KGLh+l83h6222irrdPi2kzWOhAX1uOiii7LZNwZHv/vd77IfveWWW66X180YY/pGWRHK4O+KK64oNQtd1q2wjEWnbGIp0xsQrQiERqKt2yAgey1c6a8IKMW60v+YRCkCSypiU1mCeeR1FLtxHc4Hd81ozeY7GFzHbZmIx9Uz1rHcddddJ1gh+T4G5Bwb9/TVV1+d3dONElktssgiA+GWL0sY7tI77LBDdv6c8xlnnJEZKYrguKnTKgv8hhtumCW1agSx/b/4xS+y50wI1Nv3MFPPCkrfGKXyQGWtp4PmCj+qjIVwbQQ/xO985zuz2cm3vvWt6ayzzmqaKY71sLy+/e1vz0Qs21OQWoMfY4wx1Wehq7gVtmrRqZJYyrPmvQPx1YoLeifBckR/YRyA5bHXVl/6qTy3pp122qw/1huHIDSxdiEyWZdH1c6UizFW07hOUfxe3JbJgpVWWmmqOpbyLoswucO9rHuC1yuvvHLD8+M+6pRbfhVXTP0G8X2UOVLN5tNOOy0bz9WD46KNxDe/+c2WXN532WWX7Pmee+45ksK1Hv2ccGoE9wbXhT7eSsbgKv9bg+YKP8oMZi/rISeddFK65ZZbspm3n/70py2nN2d9fgCZUeOGYMaRjHTGGGPam4Uu61ZYxqJTNbuxGb1Ja4lVMu3GvBXzzjtv01wXnYLvob9q0E8/rRfjiiWV40VM8Zz+SR/nNe8T2sR+6N8IVyytzWA9shZjiUS0t1rHkgRWrVDGLb9brph8D+fGeA9hjmg/+eSTG3qN6Lh7bX0fZqpmv+4mTAL94Q9/qE3IMKnQynGW/d8aJFf4UafvwpXOhAAkWxsDCGb++FFq5Q+DzhELEVfh1FNPzR5xeyBJQRnolKTOPvfcc7OZOwtXY4xpbxa6ilthmURLvcpubAYPxhtYI1noT/XGGQxsEa+9uPbKp0F8KxZOYgTreW+RRZj7Qy7FWniNxZbPEb0snBvrtvL9lHbBKlWmjmVsm0ZW0DJu+d2YBKMNzjvvvJpohe222y69+93vbum7iAVmfMhvDtdp8803L/xOJajCnbjXyb0GhUEUrqo3O2nSpCykT3VlO/m/NQiu8ONEX4Xr6aefntXFUr2mXsxu5sE1hh8cZiqroEB09mOMMaa9Weiy2X7LJlqqkljKDC9c5yhWW2WFFVZIV155Zeo2iCEm4BF+9F8EZL0swdHaSiZc4BHBGq2uiMNVVlml4fdON9102UBeVlm+F6sr7pQM9Ju54qoECuO2elbQsm75jcaA9cSE7k/u96JSixdffHH64Q9/mG0DxGAiLBr9BlmIVEPllAbF7TfWm+U/JdaVbSSyy/5vOUP9mAhXfuj22GOP7Hn8sdKsVb1yM50Wt8xUAqnhq6DttB9jjDHVBn9Vsv2WTbRUNrGUGT7oDxKrVeszIurIZdHNEj30YQSiLKm4s2IBleW0kbVV/Z/HIqtrI6jhyvnlQ6M4V6yT7K9VV1wEcz0raCO3fM5FNT8RFFynKDyxkEZIElUkJhqBmMY4oj6AlwXinPAw9sVvRV7A8LvBdXCprPJ0u8JGWbdfWVv536DPqK5sI6sr31Hmf8sZ6sdEuCL2+DFBhNLpKPpMna9DDz00HXPMMVkHY0ZcPxyXX355NmPGTAk/qDzfeeedO3IsuAfzQ3/JJZdknZTY1VZhfbYDBkjGGGOqz0KXFaFOtGSiSEH4YHVsJy4RF2FyVzBpgrCjTF63oHoBllVZUkkSlY9XLbK2IjxxYxe85r4p2jbCeIvzYtxTVHsVKyqigARQrbri8p31XCobueXjXvynP/2p9hpxENlrr70mvCYT8Nxzzz2VmGgEIvz/tXcn8FbN+//HvxSFIrrKT0iKckVkyJRuyZAxUyKzEkLh/kOGws2YhLiGDJmHq1xzhSYXZSjVJa6UQpKxuKZy/o/3997vvuvs9rDW2mvvvfZer+fjsR9nn3P2dPb57r2/n/X5fD/fTzzb+qhc1G2HIzfeeOMq11G2+8ADD2SrrBgKUvbrzbbqc0IHczSu82Vd58yZE+hziw71CQlc77jjDlu+ozfOq666KrWxczoFqRpcOinQve6668xFF11kW7RrYPXu3bvgx6IBqMBV5coXXHCBGTFihO/rXnjhhfYop/4OFl8DQPij0GGCUBotJZuCVQVqClgLCVaVhXHBqjdrpKowHZxWaWLUtMyoS5cudkLsMqmSKXOqta/eyyjoy8RdV5d3rzlRMyK9frQ1TbYMlQJiZSI1FwrSFVWBabaSylxl+bovbUXjl94TMgUT2ej5cgFqEC6DzFZZ8RK07NebbVU5vSpt9DVX1lX34d0OKt/nFgdOExS4agsZ0RvsOeec4+s6elNUYKkBpQytSljUGKlly5YFPRYFv65B0y233GJfENdff70d5NnojX3gwIHm7rvvTv3stNNOK+hxAEC1CHMUOkwQSqOl5HFZRQWrhTRPUvDjglWVj2airOWVV15pTj311NQaySjo9XDcccfZqrNidAnW5d28SbepIDlfNdm8efPsRF8dlnXZfOv6Bg0aZP8O9fdQpjZTSWW+snzN5fI1d1JwoISCu5/0YKJPnz6mVatWZsCAAbWup98puFDjKWWktSbSGzTr/5nebMl7X0G3yipHj5YkCVL2m55t1T7FovGs/322oNdVHPj93OLAaYICVx291MDbddddsx7901E8NQ9Id8kll9hyYgWP99xzjxk6dGhBj0XBr0pStJ2NHpO+avPoAw44wG6B4BodaDDrCKg23H7++eft93qj0nW0V1emzZgBIGnCHoUOE4TSaCkZFGQokNPJrYsMQ5NPF6yqossPXXbkyJHmrLPOiiR41XxCFWR6LCpdjLpLsF5LCuQ0WVepswJSBW65Gtno9ak1rbpfnd9hhx0i7eRdyBY3YQ6ChX0PIhAp7V6pfq8TtOw3Pdvq1nJrnXS2rKu34sDvmOHAaYICV/fBo7IVL+/A06DL9MGiNxcFiWPHjrWLtAsNXEVrZnV/ClgViCooffLJJ+0pE++RNa27uOuuuwp+DABQDcJO/sIEoTRaql6aQLpgtZDmh1rP6YLVsF1Pt956a1thdemllxZUNqzMpzKtCrii7hIsOtivgFUNnjSXefjhh301stEE3nU01oQ+6k7eYbe4KXUASiBSur1Sg1wnSNlvepCr33u3zdT3ikHSg14Fwq7iQGPIz5jhwGmCAle9uWpwpQ9S79oSdXXT4utszRNE6ziiejx6g+/WrZvN6C5atChv2Yc+gFRC5DojA0CSuXI/TQrC7JNKEJps+sxVsKYSYAUxbpu8oFx5rIIpnbLtiRqUbksVWffff7/9qkmuX5rr7LPPPnZNq6ski7JLsEp7FcTp73ZNmTTx9tPIxk30XbbVlVVG2ck77H6ZpQ5ACURKt1eq3+sELfvVgSUX5Hq3bUrngl5dfrvttrMZfx041YGifCX5bszwmZWgwFWDQkGnPqS8vBnY2bNnZw1c3ZuYBlqUjj/+eHs0VJ3o1JBhxowZtuGD3jj1QaKjkCqhUXmx1k2o4QEAJJ233E8TZ71P+ilrZJ/UZFOwqgMe+qxVh9lCglVNaF2wqpLAYtDYPuWUU0yPHj3skqGnn37azJ07N+vlFXwpoNTeoZo3uKA1qi7B6rKrv1sH871dgoM0snEBhHZ70O25564Unbzz7ZdZ6gCUQCS4MHulhhmffst+9R6isaDkUj66nHvP0WtUB2B0u3q95cLnVgIDV23sraymUvNe3qMtY8aMMUccccQq11Ua/7XXXrPn/dbRB6E3z/3339+eAAD5pZf7aTJNp3VkC1Z14Pqdd96xAauCnLCf1QqSFKgqO1isYDUTHchW8KqTelykb+WiCbDKdRU8KeDU3xxVl2BN7FX+rAAv29/st5GNN4DQeQUC+uoC0WJ28vazzzMBaPyF2Ss1zPj0W/ar6+t1p62l8lEQ7O5Pr2mNU415ZWARX2UJXNWUacKECXaQepsw7bjjjjbrqjfpxx57zDZI0tY3jo7ma79Xt5WOO0pW7fTBMX36dHvSBFEnHR0VfWimb9QNAKWSr9wPcIGbAlVXyRSGPvcVEGrNqrIiLvtSTpkqr9xe9FF2CVYAqwNCuk6uaq8gjWzSyyp1Oc2/0vuLFKOTt9/mTrm6EqO8wuyVWsj49Fv2S7PU6laWwFVrPbQ+VG9ayp527Ngx9WavluZ//vOf7Qed1o9ee+21timBFnBPnjy5Vlc/dflLAh1dBYA4ylfuh2TSZ7jWq7pg1R1sDUpBmoJVl1nNt61LHChgi6pLsCbkWhvrsp9Tp07N2YU1SCMbb1mltgTSc6syyEwBdZSdvKNs7oTyCbNXatjxGaTsF9WtLIGrJjN6E1YDptGjR6cCV1ErdK0xVUZWkyANYm8ZjmuapD3Edt99d5M0OmKrUuvx48eX+6EASDg/5X5MPJNDAY2CVVcGHLYbsIJVVV8poNFnXiUEq16apxTaJViBqbus3y6sQRvZeMsq9ZrVfSmQyLTGL8pO3lE1d0L5hNkrtZDxGaTsF9WtLIGrAlJ9uOkISXrJi8qGn3nmGTNkyBC7d5rbSNvRkVdla1UynBSXXXaZnQDqpOyrnjuVSgFAOUW1l2OcuiLvtNNO9sAq/NHEUqV+Cla13jFs1kOf/Ro/ahBU6Qc89LeE7RKsv1+f7+nlun66sAZtZKPH48oqdbu67yjX+GV6TUXZ3AnlE2av1ELGJ1DWwNXecd26Gbvkid6krrrqKhu8al2nMrMKcPVmr26V3u55SXD55ZeX+yEAQNWW+3m7In/wwQe28ifuj7ncwepHH31ks6oKVr1LeIJQVqVt27b2c12UcVHgW+nPvQLXoF2ClW1UwKqMZpgurGH3ryz1ayqq5k4onzBjTeI0PlG5Sha4Kvi87bbbzEsvvWSPzuoNXG/meqPu2rWrOeOMM2w21UtvcklpwAQAlaSayv3SuyJXwmMuNQViClaVWdXEMn07O7/0ua5gtX379nZy6sqA9dxXC03MFaD67RKsgz16rWQ7KO+nC2vYRjbFqkjI9pqKqrkTyifMWJNijk8kR0kC11GjRplzzjnHHpX3rlNVZ0G9KekNbfjw4ebGG280ffv2LcVDAgCEVE3lfnRFzh6gaGmKJpgus5q+dMcvBada06nMqoLVuI6FqCgYVSCaq0uwaI2fgtZcmSW/XViL2cgmaEVCrtdUFM2dUF5hxxqNllARgesDDzxgTjvtNHteRwpd0Oroe/1ci6/PPPNMW+uubsIoLR0Bzsdb+gQguaIs9yv32lK6ItcOOPSZrT4KjzzyiA2s/DRGyUTr15QxUbCqLrhJKvvT356tD4UCPrffpDr55uO3C2sxG9kErUjI95pii5vMdDBC76Vaa5yta3QchB1rNFpC7ANXlRKdffbZtYJWvempG7DefFU2o6NwejN0v1dmtnv37racBqXj58gZAEhU5X7lXltKV+T/0FqzuXPn2v3TtZxn8eLFNijSxNR1/vRDB571Ga9gVd3vkxSspmcKtS99JuqWrCyr+naoKkElkdm2twnShdVvIxt3n64CLuqKBF5T4eh/PXHiRDsvVvfoTF2j4yJs06RKa7RU7oOqKEPgev/999vgVUGp1rM++OCD5oADDljlcs8995w5/vjjbTmBJjC6XlL2aAWAShNVuV+515ZWU1fkMBNlBTAqA9bz7/4PCk4UfGjbFQUpej7UbCgbrW3W/05rVlu3bp216WKSpFeWiYIQPT+u+ZKf7W3CdG7Nxc99FlqRkOTXVCHmzJlj/9d6nho3buz7f4riKPdBVWRX1E8YHbl17r333oxBqxx44IHmnnvuMYcffnjqegSupbVo0aK8l9ERVrewHkByZdrLMejR6WKvLc33eKqpK7Lf50B/szJ1ClZnz55dq9RPmTgFNpqoKUDRVwWl+nl61lUHIzSpVmZVwViuwDaJ0rOZKgneeuuta+1Hm297m2J0CfazpU4h2dMkvKaKQc+bSoSVbdX/h8665Vfug6ooU+CqN1NROVm+NQ0qD9bl9IZaTd0FK4XKl/JhcgIgqqPTxVxb6ufxVFNX5FzPgSqZXnnlFVuOmq1EVOXcCiqUiVMm3S3l8WZdVTWlIEeZVX1W83nwH1rLqkaTel71fCnjrABVQabOK3uWHtz72d4m6i7Bfu6z0Oxptb+mikXPh8aODhJl6xqN8PKV5KejYV+8rV7MG//666/ti1BH1/zYZZddUtcDAFTe0WkFi/o+l/TMjCYU+uoyMvp9MR9Ptq7I7qTvo3w8pabHrqU5U6dONY8++qh59dVXbYlotnWN3myrylDdSYGTsq1am3b11VebY4891q5dJWj9n0MOOcQcdNBBNjjVAWCd9BwtXLjQBh/KtKY/X5m2t9H3+nmmzq0tW7bMetLv/XQJ9nOfXrmyp5leG9X+mioW97zpQIKeJ20LqZ+5Awvebu34z3vV5MmT7cEiP1x5vCpN9NXP85npoKq+z/e5hirIuOofrX+6OqT54S4XtuU+AKC0whydLuY6OD+PJ8quyHGhsl+tk1MZsCa8esz6+/XzXOtV07OtyhAqGFJ5nPZtVfClpSS6HAFrbenlvBorei7V20N712vrmvS9Wf1ubxNll2A/95kuaPa0Gl9ThfKzfMI9z2qIpjmwGh9pjXS1Z12DZkHDrtEOWh6v+whSHo/SK0kXhWybaseNBvezzz5rpk+fbrcD0IeP36Nd+htffvnloj9GAIiToCW/xV4H5+fxRNUVudyTYH1maa2qglVlFNznlSbBfter6mcKSDUBVLCq5919ZuszkPLO7NKbJ+l5bNCggc1+KuuqiXn6JNnv9jZhO7f6eZyZ7lMBaSH7NFfia6qY/CxX8D7PLiudrWt0XDsMhxEmAA0bhAYtj9fBP5qLxRvt//7r+uuvN3/5y19CZXvdXrQAkCRhtr4o5jo4v48nqq7I5ZgEK1Dda6+97ARLgZG3YY/f9aoKsBS4tG3b1ga9Cl7cZNB7e5kCFLIN2beq0XOl51VfFbymT5KDbG+TaWIdNkvl5z7dUi0Jkz0t9Wsq7FYlYa4X5jp+mvt43wtd12hl2MN2ja4UQQPQsEFopvL4XM+n7kNjXWOY5mLxReBqjOndu7ftepyphT0AwERS8hsmkxMkUPL7eDJ1RY6zKVOm2H1W33rrLdv4R1+z7a+aab2qJsP6XmXAymxrraq+vvHGGzZ40XpMobzTv1xb1biS4fRJciHb2xSapcp3n/PmzbNfJUz2tJSvqbBblYS5Xtjr5FuukP5eqLXROmjkTmG6RleCMAFo2CDUT0m+lxqgudcXzcUSHriq9PaKK67wdTnHz+XlsssuK+ixaQ9ZbcXjMqZa26MPBLX514d8NbxRAEDUwpT8FnMdXDm24ihm9kbPkyZYeuyPP/64zeDppHVwfterqmxVGW01fFmyZIktX1WnW92vPvMo7wwn21Y1ev6VTVSZr7Lc6WtIC9neptAsVb77VJZJHaMlbPa0VFnQsFuVhLleIdfJtVwh/b1QB6b0P9L/RwcVgnaNrhRBA9CwQajfknxHz7sO4uk9thgHVVFhgaterH67cbkA8vLLLy9J4Dpq1KjUeR2Fvvvuu2vttRYH6gipJhmOd22Ifn7ffffVuvxJJ51U0scHIHnClPxGEShlm+QWUoIcZsJdjOyNfq6J2DvvvGOP/it40HpVXc/velVNtlzgrvJPBVG6nsus6jruOai0kum4yLZVjbJrOljgDih4gw4Ju71N2CxVkC11NO41n9CBHh340JjRGttivh7CXC/sViVhrlfodXItV0h/L3QHD3Sd9IamfrpGl5ufMvYwAWiYIDRMSb4eh+5D77f6/1B9kvDAtVgluFGsK502bZr9qomNgti4Ba2ixzV69OiMv9MboU5eBK4AiilsyW+hgVK2SW4hJchhJ9xRZW+23XZbO0nSWlMFFt7PS7/rVUUVQvq5gtpPP/3UVg3pvMuwZXoOKq1kOi68W9V46bnV5Dhb0JHpOpmkByphslS5Hmcmer0oONPXUr0ewlwv7P7PYa5X6HVyLVdIfy/UQSX32k4fQ/m6Rpeb3zL2oAFo2CA0TEm+xrv+H5tttlmqZD7JzcUSG7iqgUTcmxapTEaPsXPnzqnBDQDILmzJrzdQirLhSSElyGEm3IVmYrRXubKqClZVxrv66qsHXq+qoFQTKO0jqiBVf5smjzoYq880MgbFk22rGmW3W7RokTXoCLO9TdgslXucCoZ0eY0zPb5sdDndluuqWuzXQ5jrhWkGF/Z6UVwn13KF9INGer61hZIONvipSIkTP2XsYRuTBQ1Cg5THe+9P+zDrPVW3q+A1F6pPqjhwnTRpkok7DWKVBjRs2NDElUqB08uBAaBcCi35jbrhSdjHE3bCHSYTo+3SFBQosNR1Faw2bdrUrjnN1Ggp03pV0f1omxqtV9UkcZ999rGPVcE425GURratahR85FqHmH4dP+WVYbJUjibhCoRct9rDDjssa5CroEOXe+2112wWsNivhzDXC7v/c5jrRXGdKDumx5XfMvYwWdAwQWiQ8nhvSb7eX3UwUwdRq2EtcTVLfFfhrbfe2gau2mAdAJBftpJf/Sw9e5jp6HTUDU/CliCHmXAHycRoUqWsqm7v73//uw0GdH+5Sn4zZVvd1jV6bJpgKUOxdOlSe1usV40H/b+0VZEOQvjZqsZPeWWh2+cEbejk7apajNdDIdcL23wtzPWiuE5Smvv4KWMPmwUNE4QGKY+vhLXDWFXiA9fjjz/eHgmfOnVqqmMjACC7bGsj1blWWcRcitXwJOhazbAT7nyZmJdeeslOuhSwLliwwF5HB0dzlfymN1rShEq/1+3qMajJkgJu0e2wXjVeXBCq8nd99bNVjZ+gstDtc4I0dErvqhrV6yGqLGjYbGaY64W5TjE7pseV3zL2sFnQMEFotjL+TOK+dhiZJT5w7dWrl7njjjvsfnbnn3++7SoMAAhOJaz5AtdiNjwJIsxtZsvE6HoqeX7xxRfNhAkT7KTLZVCzlfzqqyZz3qxry5Yt7XpVBRGvv/66LSumw2X8uQBTTbEUUObLbPoJKsNmqcI2dNI+rq6rqvYULeT1EHUWNGw2M8z1JMx9JXFrKb9l7GGzoGGC0Gxl/KgeiQ9cNbl44oknzP7772/XkeqN7oYbbrBv2AAAf5RtUjmsthXL1myp2A1P/Jbehb1Nb7C73nrr2WYqmugrYFeZsgIJBe7eDGp6gyUXXOirvlcw0qpVK9O9e3fTrVs3+7tnnnkmcZPgSuUNMHXeT9MkP0Fl2CxVmIZOurwOvKh8XefDvB6KmQUNm80Mcz0Jc19J21oqSBl72CwoQSgySXzgesUVV9gnYr/99rMlOw8//LD529/+Zt9UtE2BJid+OyMXuqcsAFQi12xJExVt55Kt2VJcGp6EuU39jcqo6mcKItTQT42VHN2GsqfeDKq4bKsCTNcJWJkJ3b5uY+7cuTaA1frIvffeO5Jtg1A63iBU67vzZTb9BpWFrNUL2tBJ3+sAjg6y6Pd+Xw+lyoKGzWaGvV6Y6yRta6mgZexkQRGVxAeuQ4YMWSUw1ZvpK6+8Yk9BELgCSCIXCOrgn8pdoyorLEbDk6C3qW1ENPlSNllb2Ggdryasum4mbt2qmieJblvPjSZ0Cmxc8KoMtZ9tgxBfYbaq8RtUhs1SBW3o5C7vsq06mOTnNVbKLGjYAzlhr8dBo9wKLWMHCpH4wFW8G77n+lkucd+vFgCKIb3ZkspnoyorLEbDk3y3qfd+/U1vvfWWzayq/4FuW+sX9TtV4eSjy7mgWH+f1q3Wq1cv53Uo+a08QTObQYLKsGWSQTNhriRZewuLKgA01vO9xkqZBQ17ICfs9TholFshZexBt4MC0iU+cB08ePAqTwoAwB9vQCqaiChgi6KsMMqGJ8pwatKtTED6bSrQdE1ylClVaa83eyoKMnQ57+NOp4yqJvfaZk2N/1QKPGXKlNiU/LrnYKeddsq6Dhn+hNmqppAuwcXKhLmSZK3N1sEVjUNdLt9rrNRZUC/GcXlFseWMn+2ggEwIXAlcASAUTY7PPfdcu+2LK2lcuHChDULVNbfQssKo1nq6NbgKRLUuVRlQBdDKMumx66QGS6JMl06iiZQLSDSpb9GiRcZgtU2bNvY2tSet6xoct+yN9zlQI55s65DhT9AgNOryykzZqjCZMFeSrNePDtIoS7nZZpvlfY2VOgvqMI7LL4otZ4LuMQw4iQ9cAQDhKKuq0mC3ntObEdHk2GVdw2ZOo1rr6bLCCgi0tlYTem95pIJlnYJ0o1ew2r59e1sC5/ZYjTP3HMyaNcsG2GG2EMJ/hAlCoyqvzJWtCpMJcyXJCiC0j70y8dnuNw4Yx+VXaLffoHsMB0H5cfUjcAUABObKf/U1nUpqtUZUX1WWWs4uucoKaHsZPR5Nzj/66CO7TtW716ofytSqBFiZVV3XlRCXS5ByyfR1yGG2EML/hAlCoyivzJetiiITFmeM4/gKEjAG3WPYL8qPk4HAFQAQOvORKXBV+ayymZpY33rrreaMM84oacmsJu/z58+3XYAVtGrNoboB6+du3ap3r9VcwaqyAApWtT2aykDjIGi5pHcdsiaKYbYQwv+ECUKjCipzZasqcd/LIAdgGMfxFCRgDNOJ2y/Kj5OBwBUAEDrzocn4Kh8sdevaCYqye7qcMpzK7ulovHfv0yjpccybN8/MmDHDnnTfChoUPGtCpd+r9Fjbfnj3Wk3PumrSpMmTyoDbtm2bWrtYqeWS6Y2x9LdpgkfWNbwwQWhUQWWxslVRCNo0KcgBGMZxfAUJGIN24o5D+THihcA1jUrbdHRezUM08PWGmmlilgn7uAJIAm+zpUxbh2liovdNrfNT0KpSSgWRbiKhktuw2Uvv5FhZQ02WFKjqPds1WHKUVdWERu/juj+dFGykZ101WVaQqmBVwXXYYDVst9Nilv2mb0OkMr5s2w/Bn3JlNouZrSp0HIdpmhTkAAzjOJ6CBIxhOnFXwwEdRIvA1fOCuv76681tt91mFi9eHOrJJHAFkAQKeqZNm2YDRk1WMr2fKvvpOuxqgtKyZUs7sdBaU5XwqkmSjs5vsskmtrTYD012HnjgAXv/jz76qJ1Uu61r0ilQ1uTFZVvdY9FXPQ5lH5X9Pemkk+zEptC1nmG7nerxnX322fZ5cVv16O/q2rWrOeecc+wkLmy5pAtyr7zyyoz3PX78+Fq/69Spk5k0aVLOx6sS7JtvvtlMmDDB3reeWz3effbZx/Tr12+Vx4vo1gkWK1uV/toNM46DNk0KcgAmPduq9w5p3ry5vR+qB8onSMBYrO2gSnVAB/Hgb7ZQ5TRZ2HXXXc2ll15qO2Qqg5DrJJl+BgDVTJ1Tr7rqKtO7d28b9KR3E06niayOpN9///3m+eeft0GZKNjRxOLFF1+0gaiCJQVE2fZI1fV0O0OHDjV///vf7XoqZXEVHGeTnm3VxEWBqia7msi4/VZ1mSgaFHkn7rpPfZ+PJlbKao0dO9YsWrTINq9SRljPzZ133ml23HFHM2rUqKwTeAU4+uom7unrjd1jiooek7opjxgxwk4uddsKvNXw6q9//avNWI8cOTKy+0viOkGNc31Nfy3kylbpezdJz7XPsB9z5swJPI6zBaGZ1r/nOgCj7zPdX3q21TVGUyM3Vz2Q7boonvQxqe3Cso3FbJ243Unfhx3HuQ7o6Of6PaoHGVdjTI8ePWzmwH0IHHbYYfbot94E9YaqTKrewPXm6N6c9XO9aeoIcxzXQAFAlObOnWuOO+44W0IYlCYkCjj1Pnvqqaemtp7RelPt+6rGSQpElXlt2rSpadasmf2qg4oqAdYkWmXA+qqJsW4v1zpVb7ZVBxZ1BF57U2pypMsqQNTt5srUFLtrrx5j9+7dbYZN9Nh0X61atbKP95prrrHBd9++fe3z0a1bt0Dlkt7H5Ciw1Ek0oVNGTYG8npvjjz/eboeSjTLceiyi8u/zzz/fdOnSxe5vq//rddddZwNYZYn1mPS5mlRhtuTIt06wWNkqLwULel3o9RGk+3TQpklB1qumX1avRW9Qo+/1fJN1Lb0gFQCFbAeV6/VUzPJjxFPiA1dlDV555RX7ZqtJg8qftH5FpVvu6N3gwYNTT5gyBTo6ft5555lPP/3UjBs3zjz33HN5u1MCQKXSgbz99tvPBpKFUJCqAEflhwrGpk+fbjOMmqzsvffeNqhUtlFZH01yFNzpaLzed9Wl2GVQ9X6dqzuwfqfAV4GwO5KvoEonLzfBVoC62267BSr7HTJkiLn88sttea0ywUG79o4ePdpOyEXdaVVK7RpI7bLLLvZ3yrgqYFcwqMlXkHJJ7zpkx3V6dnTwVX+jyqf1f1DGJBMdANBzILrsq6++atcEO/rsPProo+02RrNnz7aP94ADDkiVZydJmC058q0TDLNvbJhJuoIJ97j9juMwTZOCHIBJH8cKrDPJ9lpGcQQNGMNuB5Xv9VSKAzqIl8QHrjqK7Nx99902aM1FE6EjjjjC7LXXXnbCohdmz549bamb3ugBoNoyrVEErY6yOTfddJMNdDTR1QFATXaUTdUE1rv0Qu+pmqTofVfZWU1o9DNdThMjN2HRpFfv3Vpbp4yiJuCa/CprlI9uU7cVdr2eHm+Yrr3qqSDKWCr4VDbBe70BAwaYiy66yJ4UcN9www12EperXNI76dffpL9tyy23tAdoRZfzBpy5ngMvlXnrAIEogM10G3r+hw8fbte6KoN+3333mbPOOsskTZgtOfKtEywkW+WXAmEFHAoYgozjoE2Tgq5X9Y7jfPKNY0QnaMAYdjuoXK+nUh3QQbwkPnB9/fXX7ROhAZ3pwzgbvTk/+OCD9kizjj4/8cQTiS6NAlB9NDFQeXBUQas3eH3yySdtWawmygpMNeFQtjG97FfUe0ATEwWiyuIpSNL3mgTpSL+yt4cffrid/DZs2ND+TAGA7icfBX7KFIYt+1VGNGjXXgUeOiAgurweb6brqXGUAlcZM2aMfQx+yyX1N2miqOdAe+mKsh2777573ucgU8bdUclyNuq0q0mn/i9/+9vffAeuKsvWwd/GjRtn/P9XijBbcvhpLBM2WxWkdFnrxRUgqDmlGqb5Gcdhmib5Wa/qvT/vOM4n3zhGNMIEjK4Td5Ay+nyvp1Ic0EH8JD5wdUc4tbm8lzd7qjdkHRVPpyP7ClxVmqKyMgJXANVEWcEwa1r9UFCoCboCTReQKkBNn5xrIq6srCYuOq91mJoEK9jTz/X+rMmMJiZqvqSj/Sq77dy5c6qCJsh61aDr9RS4Bu126u3cq78/1/WUZdCETM2rNLEPUi556KGH2p/36tXLftXn3LHHHmuCUomxoxLsbNzzr/+jDgprMptv315Xlq2ssgKUcmwzE5UwW3L4XScYJlvlt3RZl1FJvKoadN7vOA4ahIZZr6rnw41jxEPYgDFoGX2+11OhB3RQmRIfuLqjeOlNKfTG62iwZ/uwVpZWR6O1rgcAqoWCSXUQLia9t2pyrKPzmgArENXk1Zt1UxCkCY/eqzWhV1bOG/S5vWIXLFhgM7j6XidNljV5VvZIfQjc5DzX9h5h1utpQuR34u5MnDgxdV6PL9f11MVXE0P9PxRQ5Ct1y1Uuqcqgxx9/3D5Xeo51H8rAKrOrQD8b71rVXOXXKpt2e+m6dcV6/Lm44Ed/o/73yvyp23OlCbMlR5B1gmEDej+ly/qZxruCRgUGfsZxmCCU9arVIWzAGKSM3s/rqZADOqhciQ9cNfHRiyp94Oson6MXS7bA1V3P27kRACqdtqnxU55XCAU6ag6kCXJ61lWBlYJEvT+7da8KXN2WOqKAVYGSrquAR4GdN8OnifNrr71mgwCVQCrjqO7G6uabKQAMsl7PPQ5NqoJ0O9Xl9XgcNUTKdT1vhljr/PJljHOVS3rvV1zDKm1XpOdE61L1nKbzBpKTJ0+2TaMySd/XV824cgWu3uBH11PGTwcXtKa60taihdljtdiNZfyULrvLuGyrxryfcRwmCGW9anUIEzAGLaP3+3qq5AoNhJP4wFVH+zUxSt+P0PtBPXXq1Kxd6vTCkyj2AQSAuLj33ntLcj9q5KPJi4JknfRerAmJAjAFowoQ3Rpb7XWaicu6apKsMmFHpaq6DQW2CpB1Xg35VPrqOvnqpIlT0PV6CrDFTd78lu/qq0rlHJXRaY1vtuvpcTvKimYLGnNRBu2QQw6xnZsVSOoAgZ5nBaG33367fT6eeuopW5KpzvrpE0mta9UBAT2fasB0wgkn2MmjlyayF198ca2feR+7n7JsBUh6rJXWATTMlhylaCzjp3TZlX26cnCtvVblQ75xHCYIZb1qdXDrVYPQ+6PfMnq2uEEuiQ9cVXevF5TbS8/Zdddd7RF/fRjrg/3MM89cpbW/1uXoenoRtm7dOucTDQCVwu1zWgoKXBSsqARYAaOCOGVHVfar3+k92K3tzEWX82b7RCWxuk0FAHqfdgGuqmh0P1r7Om3aNPt+7zIBfst+XfCp7FjuKWVXAABGvUlEQVS+xn7e8l199Wa0lAXO1pHebQfkaOIXhv7OTHu0qgOwtn5TYKpsqQLZv/71r3Y7G++6YAX5p59+uhk5cqT9uf5+bWukQFpBvMaKtgfS9nD63HTZ6FyBa/qBAh1AUJCnzF+ldQANkzkNu07Qb3Mbv6XLruxTVWXq5aHxnn5QItM4DhOEsl41mYKW0bPFDXJJfOCqo0Yqk9KLSJMld6RUHwj777+/XRulCYu2v7nkkkvsJEMTlqefftpcffXVqSdSHS0BoBpoMqFJaaloAq9JrTKq3rJfBa8qE9ZkJx8FULp8pmyrzuu9Xe/x6WXFCppefvllm/lNX6+XvsZX28pceeWVtX6mzKvr2pvJaaedZvdldeW7+qrAwJVYZutW7Cb83mBcgVAYCi6mTJmSsTmVAhZ1AFYmVn/zLbfcYoPU9H1shw0bZj8ntTWOgiyVFqfTbegxu4ZeuZbQpJdl6/+v4FqZP42HSsm6hs2chlknGKS5jd9SS1f2qf+bDtbocptttlneMnSCUBSjjJ4tbpBP4gPXAw88MJVZHTt2rM2sOtdee6156aWX7IeRPnCOOuqojE+ijh7169cv75MNANkoi+LNxJWTt+ttKbjuwqISVk2gFRxp/WfQahaXldRtKjDS7SngUxZMX93tKyDTe7eoY6+CWgXO+h9EmW32dvcVTdoUYLvg7qCDDsqa4RKV7noDUB009dMdOb1rrzcITQ+U9Two+6qgVGteFRxl2sf2mWeeMffcc48N1PWZ6NYeK/A85ZRTbFWS7sub8db9p99fprJsPT7djgK8Stp3MWzmNMw6Qb/NbYKUWrqyT92mDhxoXLFlCKIStOyXLW6QT+IDV2VWtWZHR81daZijUhyt++nZs2fWTor68NCHeXoZMQAE/YBXVsW7/rHUXLOkOXPmlPR+FbR6G+ApY6WmS9kCeb0fax2eOvJmaiak6ysAc1kqTZIUJGhiruBUP9fvNYlS1lX3pRJVVy7pAkk3yfLSe72COU26VFarIDLXemA9xlw/09+RK3B163pVTqysqQK9fN2RM2U204PQdPq8U+AqOmCr+8m0j23v3r3tSeNEWWp9bur51fY3KhXWz7zPVab7y7SNim5PAZr+n4U2JaqEDqsKGPWcR7WnpRelloiLoGORLW6QT+IDV9Ean2zU3VBHIu+66y5bTqYAV2ujdIT64IMPNieeeCKNmQBEQkGrJqT59r6MkgI6TRZUzqgyTbctRilp4uKd+CtA0vfekktHP9MWZHqcCpK0nUv686VMnzJZCkZV3qjf6+/UV32vnyuo0uWU7dN9ubW0mkxlK5UUXV9LR2666abU9/nWuKZToOIo4MsVnKlZjuixKWORLwDNltnMFIR6edfZaqKpgDnXPrY62OCy5O5+9PnotsPRBFXn0+8v2zYqOul/q4MLGn+VknUNuyVH1HtaOpRaohwyrb0OMxbZ4gb5ELj6oBfXRRddZE8AUEwKrvx06iyEJssKTLRdiYKN9ABR2aBSUnMk18U3H5UAK1DQRKlZs2b2qyv5Ff0taiCkv1GXU2muNyjT9+73+qqyXXUO1s8VwCuD2rVrV9+PXcFX0PJdrXl11GPh1FNPzXgAVMGJKz1V9tdPAJqra2+2IDR9qxwFSH73sfXej0qs3VjS/zPT/WXbRkU/0+RW11c2Jr20Nq5cqa3fpklO1HtauqCXUkuUWraDMGHHIlvcIBcCVwCocioBVjZVgaoCVtcZNBt1+FWg49YwFpPuR1lLPxTUaD2qMnnKcOmrvleG1GVdVXqryb2yqqLgNBP9XkGVAjFtf6amRPp7dZvKqPrd4kwBiwKzIOW7Cj41UXOBh7Zc01Y16bSvqqOuu34CUCc9s5krCNVz6NbSKoDX48q3j236/WiNsIIwUVWSmvjo+/T7y7aNin6uNbx6rK4Dsre0Ns6CZk+LtaelUGqJUst2EIaxiGIgcAWAKqTJsbKpClYVzAVZO6vJs4LXfAFuFFSyO3v2bBss5iuR1t/iDUr1VRkv/dxlXd0WOpnWjaoRn9aw6qSyTZW6KjhStlEBk4Jc3Z6fMlxH1w9TvqvMnNasasJ36aWXmo4dO9YKetX52HWu1/9CwZz+H+kBaK9evVLZS++BBpcF1VcFvdmCUJVbH3HEEanOzZp4ZtrHVmXV2i4nPeuq3ynY1/pWVyasoFXZcAXo6feXbRsV/Q/1/9Q41eXTS2vjLEj21Hv5YuxpSaklSinXQRjGIoqBwDULNSdRZkIfpDrKrw3XASDO1OBG71s6KQPm9tMMQ1lIZQKLTdlWBUre4DNftlXnNXHXhD8966rbcFvoKFDV7av0VF81sfeWDSsw0gTr2WefTQVNmnj5KcN1z63uJ0z5roJnBcl6/Frnqn4KF154oc2mTZ8+3W67o98pe7nvvvva/2mmLKieu1zZVpXfqRGVrq/rKkOsAEnjQ3/3qFGjUgcotNZXwbweQ/o+tpqMjhkzxpb2KqOo51vjTWt9NU6U0RcFyeqkrAmtSqd1f97nJts2Kgr+daBFWZpil8pHKWj2tNh7WrrSZaAU8h2EYSwiagSuHpoIaFP1Rx55ZJUuwumBq45Sa5N2TZC0tmngwIGR/3MAIBdlrrS9i1uv6jKRYWlSrOBFp8MOO8wGGG57mWJQUKYJeKaS31zZVmVp3Sk966pJk/YTVZZSQZc3UM1EgZj+RgVeuqwCOpepzJU9dSXIKlkOU76r88p0ag9VBYDagih9GyIFt9ouR3+ngrr0LKgrA861tlXBu84rGPb+zenUYKp9+/b2Oq5hkqPvNRFVlvSJJ56wp0z09+uyb7zxRq2fu+dG61sV1FaTINnT9MuzpyUqWdCDMEAUCFz/S8Fq37597Qdz+rquTBMfbZugI8kqndIWAtr/lS1xABSbJggq/XWZ1UyBSxCaPCtQVdCojJz3/e7kk082t912WwSPOvt9K3jNVPKbK9uq67nr6zoKzNSd8pBDDrEltfmC1UwTL51XtlABRb7sqf4HbpsaHTxQ2W+QJkZuGxg958qmquRTP9ff5zrtas2ryodVfjpt2rTUtjHeLKhuR/efa21rt27d7GeVAm233ZJ+rgmlnj8Fxnq8GlO6n2yBrbapURms7k+3odvSZ6UOPKh8VQcLXIlvtgx1KUrP4zxxZ09LVJMgB2GAqBC4GmOefPJJc9xxx9knRB/EmvjoqLDWGGXrgibay06Bq164L774ojnyyCMj+8cAgKMKENdYSZOCQpomKQOnwMhlVnMdcFOlycSJE225adQUfClYzVbymyvb6tap6r1az4WyngqgFMhp8hRm4qXATCfdT77sqX6uzwgF3bpOkCZGLqB02dMWLVrYQEdrP9XheMCAATbo1eVHjBixyrYxjivD7dGjR+p6mbr26rb1ON3/29Hz16FDBxvY6jK6vJ8SXf296gKt7eD0/9A63fT1qtn+3/obkzxxZ09LVIugB2GAqCQ+cNVR4z59+tjJjz7cL7vsMrvOSB/q2t81V+Cqo/uaYOlIsvZ4JXAFEAVltTT5dSXArulNWMrUKSBU4KKAx+8+sbqc1lpqu5b05ROF0ERGgZ7WU2Yr+XX0/uq27NH1FFy5/UPdREnv00EnSukTL7eVjSZgakSULXuaLQD1lu9mul56tjVT9tQb9GbbNiZdehlutq69ubKg2Rom5QtAs61XTYKgE3f2tEQ1CXoQBohK4gPXO++80wavKi0bPHiw7e7olyZPamCijpj6gAKAsDQJUKCqkk016/Fm18JQFtCVAGsi4bd8Np0Cs5EjR5qzzjorkuBVk/jWrVvbvze95FcBuv5+9Q1QUKT3WFW+uL1XFQiqFDOToPt+pk+8dLDSTbxyZU+DBqCZgt1s2VNv0BsmAJUwQWiSA9BSTdzZ0xLVIsxBGLKuiEriA1etTxU18rjgggsCP4GagClwzTaZAoBMVOWhTKLeP9TFvND3EE0MtAWJKwnVBDoqOkB399132wN7hZQNK7BTIKYJjbKsCkRVuqyJviY+Cur0Xuw60oqCWQVm3jLXbPzu+5lp4qUgRI8hWzdcV74bNADV9cJkT8mCVtfEnT0tUS3CHoQBopD4wFWbxisTkb6Hnl9uPVWUZXQAqnfCqw95F6xqclsIZSRdVlUBj4LAYlHm9d577zX333+//Rqk27DeW7t06WKXY+hvVoCpIFvvn+59V4F3ppLfKPYCVDCpyZOaKCkTnWnipe9VGq3H49b9ppfhlrJ8lyxodU3c2dMS1YKDMCinxAeubuKoTEAYbi8/TcgAINOHvMoFFazOnTvXZmjC0kE2dTR3waoa5YQtAQ5Dgd0pp5xiGwJpmcW4ceNS+3dmC6y1xcr+++9vJ/E6UKgAVD933XvzHaX37kuZHoD6PVjwwgsv2E64Cii1B2mmiZd+pnJhlc/q/jOV4ZayfBfVNXFnf1VUCw7CoJwSH7hq4qeJl46ih+H28lN5GwAoQNFaVZdV1drNQigDuMkmm9hAVV/dWsxy0mPQe54qVRS8pmdfte5TAbZOClJdMyj3fZiS30wBqJ91U24toraV0XYubs1hehZXAbMetzKdeq4zBZKU70KYuCPJOAiDckp84KpyNVeaFpQmUmqiooyHJkQAkkkBkLKpClR1KrQLsLZ5cWtVFezFraLDWyqpYM9lfV0FikqW3f6sOjjourDPmDEjdMlvtgDU71pEHZz0liG7LK6j29XzrnWq2dZjVWv5rg7AqqxZTbHc2mJkx8QdAMoj8YFr586d7URGk6BZs2YFWkCudV6aoGrSpvVbAJJDlRoKUpVZ1Ro3b3OWoBToaTsNBU5qqhT3RhbeUklvuaSaTXkpqHVrbxXApgeLfuUKQHNlXb2dX/U+Xe1bNIQJQFW6/tBDD5nly5fbUu7+/fuH6vcAAECxJT5wPfbYY+0m73L66aebiRMn+irF04R14MCB/3kS69Y1xx13XNH/WQDKR6Wl8+fPT5UApwdpQakBUNu2bc22225ru/Yq+NVt+umKG9dSSffeqWBSAavKbP02TMolTACa3vlVe8Oqc3O1btEQNgB12/vowG27du1W2f4HAIC4SHzgqiPThx9+uBkzZoyZNm2a2Xvvvc3tt99uJ5SZaPKkbSEuueSSVLa1d+/etdZEAagOWk/53nvv2UBVQZKf5jq5aI2qAlW9vzRv3jx2JcCFlkoqUNVJf2OuoDDIetWwAWj6Ppsq8820v2a1CBOAerf3UWf89G18AACIk8QHrjJq1Cg7OdUaNa1Z1Ye+sgDehiOHHXaY/VDX9gf6sNcejLLDDjuY4cOHl+0fCCBaS5YssYGqAoB58+bZzGJYCqi017MCOQVYCpyqmQ7kKXucL5MZZL1qmAA0PdhVGbYoC6z3+mJmXaNaLxrkdsIGoC7Y1cED/e/cNj5kXQEAcUTg+t9GKCoR1lH/SZMm2SdGkxtxTUeefvpp+9UFrKJ1rY8//ngsunwCCEdrUxWguhJglbAW+n7isqoKWpOUuXJrdKNarxo2AE0PdlWuLHpsfrOu5VwvGvR2wgSg3mD3l19+sc+hng+yrgCAuCJw/S917nz55ZfNgw8+aG688casG8uLMgoXXHCBXddaqaV+QJIpINAkXYGqAiA/nW6zUaCgsl8XrKocuJR7q8YtcM0nyHrVMAFoerCr33sbZ+l77d+dK2Au93rRILcTNgD1Brvax1zrjPWVrCsAIK4IXD00iTr++OPtSR/6KhtWsxSVXmndloLbDh06mBYtWpTvPwYgMFVK6LWsrKpOCxYsqFU9EZSqLLScQIGqAgWt+Uw6Zap1wE/PTbZmS0HWq4YNQL1b9YiaXmXigl5dPr2LcznXiwa9nTABaHqwu/nmm9uf6wCMLk/WFQAQRwSuWegDX+taAVQmBT4KWlwJsIKcQijIUVZVp5YtW1ZVR9pCuWZL6ois5zlbs6Ug61XDBqDerXry0eXSuzjrbynnetEgtxM2AE0PdrVtkegALVlXAEBcEbgCqBoKQhSk6qRma5rYh6VlAMoIuhJgBQ9JLQHOxwWkymQr4xpFw6SwAWi2rXoyybRVj8ZOudaLBr2dMAFo+n1o/a7+N46+V/acrCsAIG4IXAFULAUoCxcutMGGMquLFi0q6PY08VewoEBVpcAKAJCbNyDVdkFRNUwKG4Bm26rHz76x+ltU7qy/oxzrRYPcTtgAVA2n3H1Itn4O7j51+d122y3vY0+6IPsSAwDCIXAFUFEUyCib6jKr2k+5EMr8KVBVZlXr1+vUqRPZY00CP82WwqxXzRaAhuF331iVI7vLlHq9aNDbCRuA6jlWhnrLLbfM+7zpcro8cguyLzEAIDwCVw9Nvp577jkzffp0M3/+fDsh9h7BzkUTNnUlBhC9r7/+OrVWVcGFN+gJSoGpJu1uvaqCJoTjt9lSFA2TCsls+dk3VmNKJcsqOS7HetGgtxM2AN1zzz1tJltZ5Xx037o8TGT7EgMAwiNw/W/H0euvv94MHTrUThzCXJ+1b0B0NNHWwSNXArx48eKCbq9hw4Y2q6qTtrNyZaoojN9mS4U2TCoks+V331jt5au/RWNNWxqVcr1omNsJG4Dqf3TooYfmvQ78CbIvMQCgMASuxtj9WB999NGCtscAUBgFI8p4KVhVwONnQp6LgiRXArzZZpux53LEgjRbKrRhUiGZLb+lzNqv9dtvv7V/S6nXi4a9HQLQ8guyLzEAoDCJD1wffvhh88gjj6Qypq1btzY9evSwE15lDurWTfxTBBSFDhQpGHB7qyrjpeAmLGU39PpViamCJWWWUDxBmy0Vul41TGYrSCmzMp0aj/osKPV6UdadVqYg+xIDAAqX+Khs1KhRqSfj3HPPtSXD2gYDQPS0jvCjjz5KlQAvXbq0oNtr1KhRarsaBa1+thxB4cI0Wyp0Ah8msxWklFkHTZRZVVltrnXPxVgvqoDnjTfesGXs+Q64sO40PoLsSwwAKFziA9dZs2bZSZC6iQ4bNoy1qkDEli9fbidwClSV2fJTLpqNXqtqmuNKgJs1a8Zrtgyiarbkt9FSmMxW0FLmzz77zDbuUvCh0vJSrRfVY1NTQB0wVbl8nz59OABTAYLuSwwAKFziA1c3ie7YsSMTYCCiEmAFAS6rumDBgoLWj6sEVZkoBaqaBKrREsorimZLQRothclsBS1l3mmnnWwGX1nXbB2Ni8F1E9ZB1Hbt2vne8xXlFXR8AQAKl/jAVUfW1ZSD8mAgPGUclHVzW9aoyU0hNOFz29W0atWKteYxE0WzJb+NlsJktsKUMpeDt5vw999/73vPVySvVB4AQOBqOnToYObOnWvL1QD4pyyay6rqNeR3z+NMdOCoZcuWqRLgpk2bUgERY+uuu25BzZaCNFoKk9kKU8qs24uCqg3UvEkZXGVvc/Hu3aoyeL97vqK8otyXGKgGYfbXBsJIfMb1rLPOMqNHj7YTBU3CNXEGsCpl2BYuXJgKVhctWlTQ06R9MhWoKFDVh53bNxPVP3nx22gpbGYrTClzFIGrHuNDDz1k13Wrkqd///5ZM6fpe7fqsevvJ+saf1HtSwxUgzD7awNhJT5w3XHHHc3pp59ubr/9dvtimzRpkmncuHHoJxSoJioFVTZVgaom1cuWLSvo9lTm6bKqaoimZjhI1uQlSKOlsJmtMKXMS5YsKel6VW+2tUmTJjbQ11eyrvEX1b7EQDUIs782EFbiA1cZOXKkPSp611132Un1xRdfbI444ojUWiogSRRAuLWq+iDyZriC0j7I2uPSBau5thlBMiYvQRothc1shSllLjRwDbJeNT3bqk7Z0rx5cxvQknWt7lJ5oFqE2V8bKASB63/X191xxx22c+l5551ny7t0Wm+99exJpWz56DLz5s0r6J8BlIMm/PPnz0+VAC9evLjgSZ0rAW7Tpk1qTSKql9/JS9BGS+XObBVrvWp6ttWVyWurHbKuACpFmP21gUIQuP53MnXOOeeYe+65x77w3NYdOnqvI+f56PJ+glsgLlTOqUBBgaq+/vjjjwXdnjJiClSVWVWnbrp0J4vfyUvQRkvlzGwVa71q+mUVEHsbm+l7rRUm61rdaGaDShdmf22gUIkPXJVt0gby48aNs09I+n6Thew/CcSFxrFKIV0JsKoDlMkKSx9Gyqa6YFX7XyKZ/E5eyrmFSJggoVjrVZXBdZeVmTNnZrxNd11dfrfddgv9tyN+aGaDahBmf22gUIkPXO+8807z4osvpjKtXbt2tU1FNCHXi1Br9IBKpKDgo48+SgWrS5cuLej29Hpwa1W1hpF9JhFk8lKuLUTCBAnFXK+qwFwHTLX2Ox9dTpdHdaGZDSpdmP21gSgkPirTVjjOsGHD7BpXIAhNiJU1UZZJb+CanCrrpMl6qbd4UVmjJkUKVjXx97M2MBsdzNEk3GVVmzVrRkk8Qk9eyrWFSJggoZjrVffcc09b7eCnPF+3ocujetDMBtUgzP7aQBQSH7jqRaWJiUrICFrhl7IwDzzwgLn33ntt0Jqp7FbrPPWGffLJJ5sTTjjBrteLmqoE1EDGZVUXLFhQUHm7PnzUpEzBqoKNhg0bRvp4kezJSxSNloKU/YYJEnSdYq5XVUZay1OQTDSzQaUr57IPIPGBq9OhQwdGA/LSm/N1111nrrrqqrwZE03S33nnHXu68MILzaBBg8zAgQMLLj/XB4WaxbguwIVmpjT5d1nVVq1aUR6Pok1eCm20FLTsN0yQoNcV61VRDDSzQTUo17IPQBIfuKr8USVkKk0Dcpk7d6457rjjbLOUoBTkan/gMWPGmAcffNA2NgpCwakLVPU4vFmdoJQJbtmypQ1WdVI5I12xUQmTlyBlv2GCBF1HFRR6vbJeFVGjmQ2qQbmWfQCS+MC1S5cudsKVrbNj3CjLcPPNN5vnnnvOLFq0yNSrV88GIT169DD9+vUr+ZrKpHjrrbfMfvvtZzNIhVDQq3Vu48ePNzvuuGPObO3ChQtTJcD6XxdCa+VUWqlAVV8ZJ4jD5KWYZb9hggR9FrhsLutVEUS+sUwzG1SLcu+vjWRLfODat29fc9ddd9ktD6ZOnWo6duxo4uqZZ56xGb9ly5alfqZJloIqnUaNGmUDWpV7IjrKcEYRtDq6nX333deuefNmXvUhoImPAlWd1GipEGqU40qAW7RoYerUqRPBoweimbwUs+w3TJCgMmf9TgE261URhJ+xTDMbVIty7q8NJD5w1f58Q4cOtWsQe/bsaV5++eXAZZylMGPGDHP00UfbiVuDBg3MRRddZDp37my/f/TRR23wrWzBgQceaINYmupENyHRwYKoglZHt3f88cfbgxEuWFX5o3eNYFBaO6vySQWqOmlSD8R18lLMst8wQYJuT9dZvHixbb7E/qqIaizTzAYAopH4wFXUMKdRo0amf//+tnzz9NNPN0cccYSd/BejE2wYemz6YFRwojJT74b0KnfWnoD6OxS83nDDDWbIkCFlfbzV4vrrrw+1ptUPHWBQd9FcJcP5aHxq0q7Mqg64uAk6UGpxKfsNGySowkEZ5M022yzvQR/2V0WQsUwzGwCIRuID1/TySW0lMmLECHsKQqVrhWTLcpk+fbotY5ZTTz21VtDqnH/++XZrFn1A3nTTTbYREO3HC9/yRt2Di0kdhxV0uu01/NCaQlcCrEm2mi0B5RSnst+wQULr1q3t2m9lZfW6yoX9VRFkLNPMBgCikfjAVYGqt6Oq93wh+2FG6amnnkqd156gmSh40V6hKiHWh+TEiRPtOkqEp31a8215Uygd7NDEWkFoNpqMa29VVwKs6gAgTuJU9hs2SNASDB0U1N6rbN0AP/yOZZrZAEA0Eh+4xilAzebVV19NHeXPVVbaqVOn1Hk1/iFwLYwy2KWgjE964KpSSLddjcrAg2RkgVKKW9kvQQJKxe9YppkNAEQj8YGr1jTFnQIbUbdgrXHNxttUyl0H4SjTWqotkr7++ms7GVeA6kqAtb8we6uiEsSx7JeOlyg2trcBgNJLfOAad9pqQpM52WSTTXJeVkd7lZVV0BV0389PP/3UV1mdy1AXu4S23N54442SHdTQ83nwwQfbJluO1goiWfQ/1+tdJwVrlTJ5V5MxBY56zNp2af78+fZ7/Vylk96sq7Yd03Zen332mVlvvfVsjwHdhg7I6Xv3c639VgC6ZMkS+3y4ADcXXU6XD/vcuede/4dqf3+Lo0ob/0HHctwx/sur0sZ/tamG8b/OOuuYJFitJu51sgm3dOlS06RJE3te2+Fo65tcmjZtart7Kms3e/Zs3/dDdg8AAACoPDUJCedoRxpzOgLk+FnnWK9ePfuVI3YAAAAAqgWlwjHn3ZdTa8Ly+eWXX1IdN4PwU1q888472xJAdd3MttasWjzyyCOmT58+Jbu/UaNGmZ49e5bs/hA/c+fOtaWGlUKlkiqp11pWdeRVmbCjcmE1atJa1V133dWWSmpLL11WP89Ht6frduzY0ZSaSpu9/QJQGpU0/itlLIfB+C+PShr/1YzxH38ErjHXsGHD1Hk/H5KuNl8flkHkWz/r3fNWZcXVXkv/xz/+seT3V+3PKXLL1TE8bnQQbcqUKXY9nw6SqamYd/zq/UfNzfR7bTfTvn17u0+qruNn/ZBua6+99rLr9pEMlTT+GctI8vgHyonAtQIyro0bN7adZ/M1UPr2229Tk0I/exgiO3VD1d64pWjQpPtp164d/w5UjLffftseSPvkk0/s99k6cOv36hisy2uP1EMPPTTwfanJja6/00472WoPoNx0QCXMWAYAFIbAtQIoG6fSpI8++shum5JtSxyVmjhbb711CR9h9Vl77bVt8KqOkMWm+9H9AZVCnc7VZVxbOOWjy+nyYQJQZXYfeughs3z5cvPBBx+Y/v37s6cxAAAJReBaAfbcc08buCqbqolfhw4dMl5u8uTJqfN77LFHCR9hdTr55JNLEriecsopRb8PIEp6T1I1gt+y31122cWMHj06cAD65ptv2syu1tOqKkHf894GAEAysR1OBZg+fXoqWO3bt6+5/fbbV7mMJpHaAuf99983jRo1slviePdPjILWwSpr0qxZM1/7vla677//3v6txdzTS5P6zz//3Ky77rpFuw+g3P7xj3+YcePGmXfffdcGoPvtt1/eAFTZ1hEjRthKEzWD22qrrUyrVq3MgAEDyLoCAJBAbIdTAZStcB0J7777bvP666+vcpkbbrjBBq2ibEbUQWsSafP4QYMGFfU+dPsErahmCkAVuKojuQ4G6au+z9cl3WVbtU5WDeH0Vd/r5wAAIHkIXCvETTfdZLt3ao3rvvvua66++mq7FcXEiRNtFnbgwIH2cspKnH/++eV+uFVDz2uxuv1prZ/7vwHVKkwA6g12tcWX1vnrq9+gFwAAVB8C1wqxww47mMcee8xm5zTpU6ZOXTq7dOli7rzzzlTQ+txzz9XaQgeFUSOsBx980GywwQaRPpW6Pd1utkZbQDUIG4B6g90mTZqYDTfc0H4l64q40jKap59+2i79AAAUB4FrBTn44INtk5Jzzz3XBqnqRKv1rMrcXXvttWbGjBl2DRii1aZNGzN+/PjIglfdjm5PewEC1SxMAJoe7G6++eb2582bNyfrilhy3a81nvWVigAAKA4C1wqjydvw4cNtZ041DdLerfqwVMkpW6oUj8qFNZkutGxYBxlee+01NhtH1QsbgKYHu+59TY3MyLoijrzdr9U5m3XYAFAcBK5AgMyr1hUPHTrUTqKD0OV1PTXWItOKJAgTgKYHu9rv9bfffkud9D1rXVENzccAAMERuAIBaE2q1hdrHdPIkSNN+/btzeqrZ34Z6ef6vS6ny+t6rGlFEoQNQLVPtQt2ZebMmfb37qTvxQW9unyUWKeIoOh+DQClQ2cYIAQ1yerXr589/fvf/7b7U3788cd2Ml6vXj2zxRZb2P0qKd9GUijoUyCpcngXWHoD0Ez0+4022sheT83mvvrqK7Ny5Uqz5ZZb5r0/XU6Xj3qdoko9tRRD24qtueaakd0+qv8AzTbbbGP++c9/pg7I7LzzzowhAIgQgStQIAWnmnTrBCRRetDXsmXLUAHonnvuaX7//Xe7fj8flRzr8sVYp6iDTvp+jz32iOz2kazmYzogwxhCEg9cqqIGKBYCVwBApEGf9pzeZZddAgeg66+/vjn00ENjs06RjBnCNB/T64ExhKSgWgWlROAKAIg06Js9e7YZMGBAxZRJZlqnSMYMhTYfYwwhCahWQSnRnAkAkNjmNOmZsz/+8Y90LkagMUP3ayQVXbVRagSuAIDEBn251ilWUgCO0il392sgLir9wCUqD6XCAIDYN6cJ2/wj1/VYp4gwytn9GogLumqjHAhcAQCBlTLoC9v8I9/1WKeIMMrZ/RqIC7pqoxwIXAEAgRUS9AXNnoZt/pHretnWKTr6/ssvv6Q7LFZRru7XQFxQrYJyYY0rAKBkzWlcFlRBpL7mWwcbtvlHvuuxThEAinfgkrWuKAYyrgCAQDIFfZm4rKsuv9tuu4XKnobdqibf9VinCADBUa2CciJwBQAEEjboy5YFzbYONmzzDz/XY50iAJT2wCVQKAJXAEAgYYO+oNnTsM0//F6PdYoAEAzVKignAlcAQNGb0wTNnoZt/kHTEAAoHqpVUE4ErgCAoguaPQ3btZgtbgCgeOiqjXKiqzAAoKhyZUEzdR8O27W4kG7HAAAg3si4AgAKlmtv1qBZ0LDNP2gaAgBA9SJwBQAUxO3Nunz5cvPBBx+Y/v37p9adhtk6IWzzD5qGAABQvQhcAQAFybU3a5gsaNjmHzQNAQCgehG4AgBCy7c3a5gsaNjmHzQNAQCgehG4AgBCy7c3K1lQAAAQBQJXAEAofvZmJQsKAACiwHY4AIDI92bVz/V7AACAKBC4AgCKvjcrAABAIQhcAQCB+dmblawrAACICoErACCQbHuzupO+J+sKAACiRHMmAEAgYfZm3W233XiWAQBAaASuAIBAwuzNCgAAUAgCVwBAIOzNCgAASo3AFQAQCHuzAgCAUqM5EwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMRa3XI/AKCaDB8+3J4AAACS4rzzzrMnoJhWq6mpqSnqPaBqKCBbtmyZWXfddXlzSvPpp5+aTTfdtDz/GAAAgDJbtGiR2WSTTcr9MFDFyLjCN46k+bPRRhuZOnXqMLKQGCtXrjRffPGFPc/4R9Iw/pFk3vEPFBuBKxCxN998kyOOSGzFAeMfScP4R5JRcYZSojkTAAAAACDWCFwBAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAAAAgFhbraampqbcDwIAAAAAgGzIuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAQAwsWLDCrrbZapKchQ4aYJJk/f755/PHHzcCBA03nzp3NuuuuW+v5QHwx/gvz7bffmieeeMKceeaZZvfddzdNmjQxa665pn0NtGzZ0vTs2dM89NBD5rfffovoP4YoMf7D++mnn8ykSZPM1VdfbY499liz44472vFfv359U69ePXter4nzzz/fzJgxI8L/GsqhblnuFQCQGJpUKJCUTp062e+jtHjxYrPtttuar7/+OtLbBeI+/n/44QdzzDHHmPHjx5tff/11ld8rUF2+fLn5+OOPzWOPPWYuueQSM3r0aLPXXntF9hiAcr7/33rrreb//b//l/X3S5cutafXX3/dDB8+3Bx99NHmtttuMxtssAH/uApE4AoAMaDMSL9+/XJeZvr06ebNN9+05zfeeGNz2GGH5bz8LrvsYpLgl19+IWitcIz/8IHrs88+W+tnTZs2NTvttJPZaKONbOA6c+ZMM2vWrFRmb++99zZjx441Bx10UAT/OUSB8R+Ntdde22y99da2yqBRo0ZmxYoV5tNPPzVvvPGGWbZsmb2MDuC899575tVXX7XPOyoLgSsAxICO/o4cOTLnZVT66wLXLbfcMu/lk6ZBgwamffv2NmDfeeedzc8//2xOPPHEcj8s+MD4L8z6669vTjjhBHPyySebdu3arfJ7TdL1e5XTazLfq1cv8+GHH9ogF+XH+A9Pn4VDhw41++23nx37deuuGtros2DEiBHm4osvNr///ruZPXu2GTRoEJ+hFYjAFQBQ0TT5njNnjj3Svvrq/2vdEHVJGhA3Wsd62WWX2fV7ubJHe+65p3nllVfsxF6ZJ500kde6QKCSHXroofaUi9a7XnjhhbacfvDgwfZn999/vxk2bJj9HSoHzZkAABVtrbXWMttss02toBVISqbu8ssv91XyuPnmm5vTTz899f1zzz1X5EcHxMspp5ySOq+13x999FFZHw+C41MeAKrU+++/b8uhVDqrrKSyMxtuuKHp0KGDzdJ8/vnnvtfR3X777ebAAw80m222mV1HtMYaa5j11lvPtGnTxhx88MHmqquuslnP9NJmdfN1jTlk8uTJGTsga1INMP6La4899kid13pXVC/e/1elzz8vBa+oMDUAgIowePDgGr1t69SpU6esl/v5559r+vbtW1OnTp3U5TOd1lprrZpbbrkl532+9tprNc2aNct5O97Tb7/9lvHx5js1b968JmoTJ06sdR+obIz/wj399NOp18Paa68dwS2iVBj/hXvnnXdqfSZ8/vnnEdwqSok1rgBQRX788UfbpOIf//hH6mfqsKi97dTA5ZtvvrG/U7ZV+9+dffbZdr2bMrPpFi1aZG/LHZVWllVNj1q1amWzrrovZW3efffdVMdGL2V61Sn5s88+M0899VTObsiNGzeO+JlAEjH+c1NTGmfTTTct+v8DpcX4z07rW7XO1dHerv/3f/9Xkv8LIlTSMBkAUNQj7ieccELqMltttZXNOqZbsWJFzW233VZTr149ezllZpVZTTdgwIDUbXXs2LHms88+y3ifyrJOmjSpplevXva2c2U+c2WKo0bGtbow/guzcuXKmjZt2qRei/369YvoP4NSYPwH98svv9QsWLCg5oEHHqjZfvvtU2O/YcOGNW+//XYR/ksoNjKuAFAlpk6dajsluiyrMqt/+MMfVrlcnTp1zBlnnGGbGmn7jJUrV5orrrjCvPDCC6vcnnPPPffYbGkm2n5AG8vrBJQL4z+32267zcydO9eeVyMzvQegejD+//d5pM+0bLbaaivz5JNPmrZt25bsf4Po0JwJAKrE8OHDU+dvuOGGjEGr10knnWSbK8m4cePM119/Xev33vLf9KYWQNww/rP75z//aS666KLU96eeeqrtxI3qwfjPTQdstSRGrwWC1spF4AoAVWDFihVmwoQJ9ry2xjjooIN8Xc91/K2pqam1LjZ9DZy6CgNxxfjP7rvvvjPdu3e33cFlyy23rBXkoPIx/v9HfRXcSQdn9957b9OwYUObhVX3e+33/eKLL5bxv4VCUCoMAFVg1qxZtjGHa6LUv39/X9d78803azVj8urRo4d55ZVX7Hk1tVBg3KtXL7PPPvuYTTbZJNLHDxSC8Z/Zzz//bA499NDUfpU6qPW3v/3NNGjQgAFXRRj//3PTTTet8vzos/HWW2+128DptaCt3bT85cQTTyzp/wmFI3AFgCrg3ZNVJb/6kA7q22+/rfV979697ZFp1xH45ZdftifRfq4dO3a0GVtNjPOVJQPFxPjPnIU7+uijzZQpU+z39evXN08//bTZbrvtGIxVhvGf2zrrrGMGDhxoqw0OP/xw8/vvv5vTTz/dfoZtscUWJfovIQqUCgNAFfj+++8jmeimrwkaM2aMGTVqlPnjH/9Y63cLFy40Dz30kA1u1bRJX7XVDlAOjP/aNDFXmaQCVdew5oknnqCBWpVi/PujrdhUOuyqEdSwDJWFwBUAqoCOKDvKqGjNatDTkCFDVrnd1VZbzTZyUUOLDz74wNx55522vMp7lPq3334zd999t923denSpSX7mwGH8V+bskk6sOQ6CKvbuN9176g8jH//tNTFSe/rgPgjcAWAKtC0adPU+S+++KIo96FtBPr06WPuu+8+M2/ePBvInnfeeTYzK/rZ5ZdfXpT7BnJh/P/Pueeea+66667U93fccYc55phjGEBVjPHv3/rrr586n95JH/FH4AoAVWD77bc39erVs+e//PLLVDOWYlIgq213vMGqK01Mz9oCxcT4/4+LL77YjBgxIvW83HjjjbaMH9WN8e/f4sWLU+c32GCDovw/UDwErgBQBdZaay3TpUuX1PelXLtzyCGHpM4vWbJkld+rKYy3rBiIGuPfmKFDh9rtPpwrrrjCDBgwgMGWAIx//5599tnUeW2Ng8pC4AoAVeKCCy5Inb/lllvMSy+95Pu6mcqLv/rqK1/X9W6j06RJk1V+37hx49T5zz77zPdjAoJI8vjXFiCXXHJJ6nt1UL300kuLcl+IpySOf21zoyZLfv31r381b731Vur7I444ItLHg+IjcAWAKtGpU6fUvnTqEKy96q6++mrzww8/ZLy8PvC11Y22s/FmTR1tedO3b18zefJk26U0E00Czj777NT33bp1W+UyLVq0MGuvvbY9/8knn9TaOxaISlLHv/aj1LpWp1+/fubaa6+N9D4Qf0kc///6179Mq1atzPXXX7/KPuTpgbleI3ptONoKh4ZllWe1GrWSBADEnrr+uvWkmqRMmjRplcv88ssvdhIyfvz41M80aejQoYOdiGgd7HfffWcbKc2ZM8deXnbcccdaR6LT16Y2bNjQrqNq3ry57WCpo/Fz58613YadDTfc0MycOdNuj5OuV69e5uGHH049nv33398+HtfYSWuNBg0aFPq50cby6etrNWHT3+m0a9duleupnDLTpA3xw/hf1ezZs+3r0gUWem0qePG7rrx///52b0vEH+N/Vfq82WGHHVLfb7755qZt27Z2X3F91i1btsx+Ts2aNcusXLkydbnWrVubiRMnmv/7v/8r0X8PkVHgCgCIv8GDB+tAoz116tQp6+VWrFhRc+mll9asvfbaqcvnOq2xxho1/fr1W+V2GjRo4Ov6OrVr167m/fffz/qYFixYULPRRhtlvX7z5s0Lem5OPPFE34/Ve7r33nsLul+UDuN/VRMnTgw17t1J10dlYPyvas6cOTWrr7667/Guy/bp06fmm2++KcN/EFGoG10IDACIA2UxlUlUCZf2b9Rap/fee89mSdUcad1117WZ02233dZ07tzZHHDAATZbmk5bBUyZMsWWiqm8S2VZar6kEjNlTTfZZBObqdU6IWUttV9kNrq/d99914wcOdJmgz/88EOzfPlyW9IGMP4B3v+D2mabbWwZ8IQJE8xrr71mM6sff/yx/ezSZ50qhbTGVp91e+yxh90WqlmzZgy1CkapMAAAAAAg1mjOBAAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAAAACAWCNwBQAAAADEGoErAAAAACDWCFwBAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAGvSpElmtdVWs6c//elPPCtIFMY/kozxj0pA4AoAAAAAiDUCVwAAAABArBG4AgAAAABibbWampqacj8IAAAAAACyIeMKAAAAAIg1AlcAAAAAQKwRuAJATLitaHRyZs6cac444wzTunVr06BBA3vq0KGDue2228yKFStWuY233nrLnHTSSWbrrbc266yzjmncuLHp3LmzeeihhyLZDmHBggWpy2y++ea17rd3795mq622MmuvvbZZf/31zS677GKuuuoq8+OPP+a832y3mYsu566j62fz1VdfmWHDhpmuXbuajTfe2NSvX9+sscYaplGjRmabbbYxRx55pBk+fLiZP3++r/tF8TD+Gf9Jxvhn/MMHrXEFAJSf3pLdSa699tqaOnXq1Pq597TffvvV/Pzzz/ayK1asqDnjjDOyXlannj172stlM3HixNRlO3XqlPEy8+fPT12mefPmNb///nvNZZddVrP66qtnvd8WLVrUzJs3L+v9pt+mH7qcu46un8lTTz1Vs/766+d8TtypWbNmvu4XxcP4Z/wnGeOf8Y/86voJbgEApXXHHXeYCy64wJ7fbrvtzPbbb2/q1Kljpk2bZt577z3783HjxplzzjnHXvbMM880d955p1l99dXNzjvvbDOuv//+u5k6dWoqm/joo4+adu3amQsvvDCyx3n55ZebK664wp7XY9x2221tRlOZ4nfeecf+XPffvXt3+33duqX52FEGWNlUl5Vea621zK677moztfXq1TPLli0z8+bNM7Nnzzb//ve/S/KY4B/jvzCM/8rG+C8M47+K+QhuAQAlPuJer169mo022shmQdMNGzYsdbm6devWDB8+3J7feuuta2bOnFnrssqwDhgwIHX5Bg0a1Pzwww+RZFzXXHPNmtVWW62mZcuWNdOmTVvlso8//njNGmuskbr86NGjS5Zx7d69e+r3RxxxRM0333yT8XZ++umnmueee66mb9++vu4XxcP4Z/wnGeOf8Y/8CFwBIIYTl/r169fMmTMn62W7du1a6/JNmjSpWbJkScbLKnht3bp16rKPPfZYJIGrTo0bN6757LPPsj7OP//5z6nL7r///iULXPW43AGA5cuX+7pNlBfjn/GfZIx/xj/yozkTAMRQ3759bfOgbI455pha3w8aNMg0adIk42VVYtyjR4/U99OnT4/scep+1fQom1NOOSV1/s033zSlolJgUaMoNbRCZWH8F4bxX9kY/4Vh/FcvAlcAiCGtz8xFa0mDXL5t27ap81F20D3qqKNy/r5NmzZ2fal8/fXXZvny5aYUNt10U/v122+/NY899lhJ7hPRYfwXhvFf2Rj/hWH8Vy8CVwCIIW+gmYm2m3HWW28906xZs5yX32CDDVY5Gl0o3a+bIOTa4sH7WKO673y8GWZlpw8//HAbwH755ZcluX8UhvFfGMZ/ZWP8F4bxX70IXAEghhQU5uLtzpvvsumX/+233wp8dP7vV9RlOOr7zueSSy6xXYRFy8fGjh1revbsaZo2bWr3mj311FPNww8/XLIMMIJh/BeG8V/ZGP+FYfxXLwJXAIghZSqLcdkolet+/VhnnXXM5MmTzfXXX2+3wPH617/+Ze655x7Tq1cvs9FGG5mBAwean376qWyPFati/BeG8V/ZGP+FYfxXLwJXAEDF0R61+ay55prmz3/+s/n444/tvrI333yzzbp6y6q1h6uC286dOxO8omIw/pFkjP/kInAFAJSVt5R4xYoVvq7z/fffB8petGvXzpx99tnmkUceMZ9++ql55513zMknn5y6zLRp08ytt94a8JEDhWP8I8kY/wiCwBUAUFbrrrtu6ry6AP9nS8PsFi5cWHCTpx122MGWC/fu3Tv1s6effrqg2wTCYPwjyRj/CILAFQBQVg0bNkx1PVbp7ocffpjz8o8//nhk933IIYekzi9ZsiSy2wX8YvwjyRj/CILAFQBQdh06dEidv++++7JeTmW+V199dc7b+uWXX8wPP/zg634XLVqUOt+kSRNf1wGixvhHkjH+4ReBKwCg7I499tjU+eHDh5snn3xylcu88cYbplOnTracWI2Xslm8eLHdX1aNmd56662sl5swYYIZPHhw6vtu3boV9DcAYTH+kWSMf/j1v439AAAoE3X7HTZsmHn33XfNr7/+ao488kjTvn17s/3225uVK1eaWbNmmRkzZtjLDhkyxNx7773mk08+yXp73333nbnhhhvsSWXIWtOqbsL169c3X375pb09dRt2tLdr//79S/K3AukY/0gyxj/8InAFAJRd3bp1zdixY03Xrl1TAaU6/+rk7Q48aNAgc9lll9nANVeXynr16tmSYfnmm2/Myy+/nPXyf/rTn2y3Ye39B5QD4x9JxviHXwSuAIBYaNGihc2E3nLLLWbMmDG2SZOCz4033th07NjRnHHGGbXWQmWjzOrXX39tXnnlFTN16lTz9ttvm48++sgsXbrUZnPVDKR58+Zm5513NkcffbQNloFyY/wjyRj/8GO1mnz7DgAAAAAAUEY0ZwIAAAAAxBqBKwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgBAFkOGDDGrrbaaPek8kCSMfyQZ4z9+6pb7AQBAUi1btsy88MILZsKECeatt94yS5cuNV999ZVZc801zfrrr2+22mors/POO5tDDjnE7LbbbuV+uECkGP9IMsY/EByBKwCU2L///W8zYsQIM2zYMPPtt9+u8vtff/3V/PDDD2bRokXm5ZdfNtdcc40NYnX0t2fPnjb7V2m8j7mmpqasjwXlxfhn/CcZ45/xj/AIXAGghBYuXGgOPvhgM2vWrFo/32yzzcx2221nNtxwQ7Ny5UrzxRdfmHfffdcsWbLE/v7DDz80xx57rA1mBw4cyP8MFYnxjyRj/AOFIXAFgBJZsGCBLflVUOqykMccc4wZNGiQ2WabbVa5vDKTKiG+5ZZbzEMPPWR+//13e7QeqESMfyQZ4x8oHM2ZAKAEVP571FFHpYLW+vXrmzFjxtiANFPQ6gJbrXG9//77bfa1bdu2/K9QkRj/SDLGPxANMq4AUALXXXedzZ46o0ePNt27d/d9fQWtb7zxhpk5c2aRHiFQPIx/JBnjH4gGGVcAKLKffvrJ3HzzzanvDz/8cNOjR4/At7POOuuYPfbYI+vvP/nkE3PZZZeZXXfd1TRt2tR2J9ZXfT948GC7PjafSZMmpbZ/+dOf/pT6+SuvvGIbQ22xxRY2W9y4cWOz1157mZEjR5rffvst7215uZ+ln1RK5+i8+/nmm2+e+vmrr75qevfubdq0aWPWW289+/sBAwZkvP9x48aZU045xTa2Wnfddc1aa61lmjdvbg477DBz3333ZX3ciBbjn/GfZIx/xj8iVAMAKKr7779fbRRTp1dffTXy+/jLX/5SU79+/Vr3k37S76+55pqctzNx4sTU5Tt16lTzyy+/1PTp0yfn7bZv375m6dKlOW/Lz2n+/Pmp6+q8+3nz5s3t4+jbt2/G6/Xv37/W/S5ZsqRm7733znt/W265Zc2bb76Z8/kYPHhw6vI6j+AY/4z/JGP8M/4RHUqFAaDIlK30dg/OlTUN46yzzjK33npr6vsGDRqYzp07m4022siuqZ04caLdXufnn382F154of3ZjTfe6Ou2TzvtNFvWvPrqq5sOHTrYTKeaRKls+YMPPrCXeeedd8wJJ5xgnn/++VrXbdasmenXr58973187mfplBXN5txzzzV33HGHPb/tttuadu3amTXWWMN2W9Zjc9SFWc/vvHnzUj9r2bKlfez16tUz7733npk2bZr9+b/+9S/7PL344ouR/0/wP4x/xn+SMf4Z/4hQhEEwACCDli1bprJ2Rx11VKTP0WOPPVYri3jSSSfVfP/997Uuo++PO+64Wpd78sknM96eN0tar149+3XnnXeuef/992td7vfff68ZMWJErducPHly1sfpvZwf3oxrnTp17NdNN920ZsqUKatc9ueff06d79atW+p666yzTs0jjzyyyuWVZd1iiy1Sl9PtfvvttxkfBxnXwjH+Gf9Jxvhn/CM6BK4AUGR169ZNBUlDhgyJ7HZXrlxZ06JFi1pBsQLKTPTzQw89NHVZTaZ0/XzlvSqnXb58edbHcOSRR6Yue/rppxclcNVp7bXXrvnggw9yXueVV16pdZ1nn3025+2vt956qctefvnlGS9H4Fo4xj/jP8kY/4x/RIfmTABQRMuWLTMrVqxIfd+oUaPIbnv8+PFm/vz59rwaMakBVHojJEc/V7muymtFpbQTJkzIex/XXHONLT3ORs2PnOnTp5tiUTm0mizl4kqJ5ZBDDjEHHnhg1suq4ZP2z3Vuv/12u28uosX4jwbjvzIx/qPB+IdD4AoARbR8+fJa3+cKAgtZO3XAAQfYNa25aM3p/vvvn/pea19zUffggw8+OOdldthhh9R5b1fgqKmjcT7ev8cbUGdz8sknp9bHLl68OLVmF9Fh/EeD8V+ZGP/RYPzDIXAFgCJq2LBhre/VJCkqM2bMSJ3ffffdfV3H24RITZVyad26dSpDm422xfFmF4pBj0ENmXL57LPPzJdffhno+dhwww1rZXHzPR8IjvFfOMZ/5WL8F47xDy8CVwAoInXKrVv3fw3cv/vuu8hue+nSpanz2p/UD++eqF999VXOy2qf1Hy8ga23JDpK66+/fq3nMN9zof1aFZRG/XwgOMZ/4Rj/lYvxXzjGP7wIXAGgyLxBpbZjiYo3e7vOOuv4uo73cullbOmyrZctNQWixXgugj4fCIfxXxjGf2Vj/BeG8Q8vAlcAKLI999wzdd7tIRoF73rZH3/80dd1vJdLL2OrZGGei2p+PuKE8V98jP/4YvwXH+M/OQhcAaDIunTpkjr/ySefmNdeey2S2/WWwy5cuNDXdbwNlP7whz+YauF9Ln766SffZb/V+nzECeO/+Bj/8cX4Lz7Gf3IQuAJAkR111FG1gqLhw4dHcrvejr5+g2Hv5dq3b2+qhTomN2nSJNDzoeD2ww8/rMrnI04Y/8XH+I8vxn/xMf6Tg8AVAEqwRuecc85Jff/kk0/aU1Aqa/UGZN4j+c8//3ytrrqZfP755+aFF17IeP1i09Y6zm+//VaU++jcuXPq/H333Zf38rrM77//bs9vvPHGtosyosf4Z/wnGeOf8Y/oELgCQAkMHDiwVkbv+OOPN88884zv68+ZM8fsuuuuZvz48amf7bvvvqZFixb2/C+//GIGDBiQ9fo1NTXm7LPPTgWNLVu2NF27djWl4t02R1vXFEPfvn1T58eOHWvGjRuX9bIq2R46dGit68alGVU1Yvwz/pOM8c/4RzQIXAGgBOrVq2eeeOKJVDmr1mF2797dnHDCCeb999/PGmy++eab5sQTTzTt2rWzwavX6quvbq655prU94888ojp06fPKnvFqlvuySefbMaMGZP62XXXXWevXypt27ZNndfzUKyMa7du3VLfH3nkkRnv6+2337ZBu9uaaNNNN62VEUf0GP+M/yRj/DP+EY3cG+MBACKzxRZb2K7CBx98sA1CVab6wAMP2JP2E91uu+3sWtiVK1eaL774wsycOdMsWbKk1m2kd77t0aOHmTJlirn11lvt96NGjTKPPfaYDeKaNm1qy4dffvnlWsGsMrOHH354Sf+zRxxxRCoDesEFF9iS5W222cZO6JyLL77Y7tlXiHvvvdfsscceZt68efZv1vOz5ZZbmg4dOpg111zTbkek/4EOCrjtcBTwN2rUqMC/EPkw/hn/Scb4Z/wjAjUAgJJavnx5zRVXXFHTqFEjRU++Tu3atasZO3Zs1tu88sora+rVq5fzNurXr19z1VVX5XxsEydOTF2+U6dOvv4e731k8+uvv9bstddeOR/f/PnzU5fXeffz5s2b1wTxxRdf1HTp0iXvc9qqVaua6dOn57ytwYMHpy6v8ygc45/xn2SMf8Y/wiPjCgBl2HPu0ksvteWpaqo0YcIEW76q7Og333xjM4MbbLCBadOmjc0UqqQ4X8fbSy65xK6bVcZVmc358+fbUlhlEnWkf7/99jO9e/c2m222mSmHNdZYw7z00kvm7rvvto2plHHW3/rrr79Gfl/KNCvL/OKLL9rs86uvvmoz2Frfq1JtdWPWc3rcccfZx4XSYvwz/pOM8c/4R3irKXot4PoAAAAAABQVzZkAAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAAAAgFgjcAUAAAAAxBqBKwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAAAACAWCNwBQAAAADEGoErAAAAACDWCFwBAAAAACbO/j9+TTJr9hQGHwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index d1724b2f..936d0bdc 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2210,7 +2210,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB50AAAPdCAYAAAC5rX+kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzsvQe4JVWVvl/k1IFukiRBlKQYEDEiYEQUdBgxYMKcUcdxRMdxTJjGHEYdR1AxYVbMARFBUVQUFUVRYgMNNA1002S4/2fV7//dWXf1rqpd59SJ932fZz/nnLp16lQ65+5vf2utvc7MzMxMAQAAAAAAAAAAAAAAAAAA0APr9vImAAAAAAAAAAAAAAAAAAAATGcAAAAAAAAAAAAAAAAAAOgLMp0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAAAAAAAAAAAAAAAAAKBnMJ0BAGCqOPDAA4t11llntv30pz8d6Od96lOfmvN5z3zmMwf6efMJf16tQXsuuOCCOedw55135jQCAAAAwNiBjpse0HHjyRvf+MY518ZeA8D/wfgeQDdgOgMAAAAAAAAAAAAAAAAAQM+s3/tbAQAAAAAAAAAAAAAAxpf3v//9xTXXXDP7+hWveEWx+eabj3SfAACmEUxnAAAAAAAAAAAAAACYWtP5wgsvnH1tU6NhOgMAdA/ltQEAAAAAAAAAAAAAAAAAoGfIdAYAgKnipz/96ah3AQAAAAAAAFqAjgMAAACYfMh0BgAAAAAAAAAAAICpZueddy7WWWedsh144IGj3h0AAICpA9MZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6hjmdAQAAEpx55pnFn//85+LSSy8tX9/hDnco7n3vexd77bXXRJ6vc889t/jDH/5QrFixoli5cmWx/vrrF0uWLCl222234h73uEex+eab97ztW2+9tTjjjDOK888/v7jiiiuKm266qdhqq62KbbfdtnjgAx/Y17ZHyXXXXVf84he/KC655JLiyiuvLNZbb71i6623Lnbaaafi/ve/f7HhhhsO5HOXL19efq6dTzuXS5cuLcvAPfjBDy4222yzgXwmAAAAAMA0gI7LZ1p13LRx2223lff1P/7xj1LPX3vttcWmm25abLnllsWee+5Z3P3udy822mijYtq45ZZbir/85S/Fn/70p/K4V69eXY5jmCa2e/ROd7pTcde73rXYeOONi3Hg6quvLk4//fTi8ssvL8cPbF/t+7TrrrsW++67bzme0DU333xz8atf/ao455xziquuuqq4/fbbyzGLpzzlKeU9Mkps3+z35aKLLpq9fnbtbGzNrps1O0e9YuNadr5t/MTOt90Hdr7vcpe7FPe5z30Gcr4BIJMZAACAKeKAAw6YsX9vaieffHL2e2+77baZD33oQzN3vvOd52zDt1133XXmk5/85Ox77Ln/+5FHHjkzLlx00UUzL33pS2d23HHHyuOxtu66687su+++M+985ztnLr/88uzt/+1vf5t52tOeNrN48eLKba+33nozD37wg2e++c1vtt7/uK1h8eMf/3jm4Q9/+MyGG25YeVwLFiyYOfzww2f+8Ic/tNr2G97whjnbsdfijDPOmDnooINm1llnneRn2v4861nPmlm2bFn2551//vlztrHTTjsl13vrW986Zz37HvXKu971rjnbuv/979/ztgAAAABgfoCO+z/QcYPD9FAXmmcY/PKXvyw1Z53etrbJJpuUOvL444+fueGGG3rSoilsbMOv78dBcrCxmF405gUXXDDzghe8YGbJkiW1x21tgw02mLnvfe87c8wxxyR1sr/ebVvO8d56663leqZ5beyjaltLly6deeELXzhz6aWXdqLlbTsvetGLynGJ1OfZe0fF97///ZmDDz54ZtNNN609v4sWLZo57LDDZr7+9a/P3HLLLdnb//KXvzzzgAc8oBzHqjvfNnbS9jyM8/gewCRBeW0AAICiKCO799tvv+Koo44qI4jrMoaf9axnFY973OOK66+/fizPnUWsv/rVry4jPD/84Q8XF198ce36Fg3761//ujj66KOLJz3pSY3bNz/43//938vI1M9+9rNlpHVdVPapp55anq+HPOQh5XkeV+w4Dj300OLhD3948eMf/7iMzK3Lgv7KV75S3Ote9ype+tKXlue8H975zncWD3jAA4of/OAH5flNYfvzyU9+svzM3/zmN0WXPPe5z50THX/KKaeUUeVtsX3/n//5nznLXvSiF3WyjwAAAAAAEXQcOm7asKxN06VWXcs0Z53eNm644YZSRz7jGc8odeUkc+yxx5bZ26YpLXM4Jxvasmn/4z/+o/jyl79cDBPT5FY1zsaHfvnLX5ZjH3VZuR/72MfKMRrT9P3wne98p9hjjz2Kj370o+W4xLhw3nnnFQ960IOKRz3qUcX3vve9xvGyVatWFV//+teLww47rPjc5z7XuP1ly5aVYyZPeMITygxnG8eqO992nnfffffimGOO6el4AKB3MJ0BAGDeY6LuoQ99aNlxTbF48eK1SimfeOKJxZOf/ORKg3BUmDA76KCDine9612VpumiRYuKhQsXJv/WdDxmrlqppre//e1Jo9WMS9t+ip/+9KdlmTYTI+PGZZddVpav/va3v538+4IFC4pNNtlkreUmdP77v/+7NNVN7PfCm9/85uI1r3nNHJFqZaasrHaqJJSVpjIhZ2W7usJKcJl485gobouZ9X//+99nX9sxPPGJT+xkHwEAAAAAPOi4/2O+6rhpw6bEslLMVbp03XXXLTVWSpsa4zY+0YbPf/7zZTB0SlebLrZy73bsG2ywQTFqvvGNbxQHHHBAOSVbZJ111inHkFJTY5kR++xnP7t4xzve0dPnmt42k9YMW499d0dZZvzkk08u71ubJiyFXT+7dlVl4JvuWwuIt98gM/dT2PGnpj+zMbHXv/71xXOe85xakxoAugXTGQAA5j1HHnlkcfbZZ885D/vss08ZKWvzzlxzzTXFjTfeWJppZhCaAWl861vfWiurc5SYaXn44YcXP/nJT+YsN8Hzute9ruyg2zxdFiltIsWe29xQlg1tWcgmYJv4z//8z+KEE06Ys8zEn0VU21xgdp60/S996UvlefRYFvk//dM/lZ89TufNjNE//vGPc5Zb9PDxxx9fRsnafWAC0eZ3/tCHPlTOQ+T57ne/W7z85S9v/dkWkf7GN76xfG5zbFsUrglXE0c2J5Odp5/97GfFIx/5yDnvs7+96lWvKrrkJS95yZzXduxts/kt2trzzGc+c2zm2AIAAACA6QIdN7913LRhgdAWQH7hhRfOWW7ZsR/84AeLv/71r7M60XSaXSurUPWmN72p2GuvvYpJxjJ2X/ayl81ZZpr7v/7rv8qxGjOiLcDejt3OgVU4MKPTjt3Mzire+ta3lhrVmpmeHtPe+luqWVZtCjNWLWDba2XT8hZIbvMr23fExpDsmCxg3Mz0e97znnO2YZXjLBu47Tl62tOeVmZ3G/Z9VEaxfXftHNn8xja+ozGrYWDXxzLzbdzEs/feexef+MQnigsuuKDcZ7t29jtjjz/60Y/K6nw2L3cTa9asKYP8YwW/+93vfmUlABurseO3bdvv1Nve9ra1AmiOO+64no1+AOiBUdf3BgAAGOVcYDbvUZz/xebasbl5qjjvvPMq5wYa5Zwvr3vd69ban0c96lEzV111VfYczR/96Ecr/37aaaetNW/OXnvtVTsvkZ1Hm1c67tcrX/nKsZnT+e1vf/tan/WUpzxl5sYbb6x8z8qVK2ce+MAHrvW+E088sfaz4jxaajan9vLlyyvfd/vtt88885nPXGuO5yuuuKKTOZ3FPvvsM2f9Y489diaXSy65ZGb99deffa/NTW33FAAAAABAE+g4dNx8ntPZ9N5+++23lk7893//9+z5bn/yk5/U6tFxntP5hBNOmLPuLrvs0qh1Pb///e9nfvWrX9WuE8dwepn32MZWdtxxxznbedjDHlar5Q27hi9+8YvnvG/rrbeeWbNmTbaW9/NYf+ELX5gZB2z/d9111zn7Z3Nbf/jDHy7v6SZsHZvT+dRTT61cx+b3jufg3/7t32Zuu+22yvdcdNFFa+2XjVWceeaZtfvDnM4A3UCmMwAAzGss8tVjkcUf+chHkmWNhUVjWobqOGVwWkTru9/97jnLrASzZWPHiN4qdt111+KFL3xh7bnyJYm23HLLMkJ12223rXyPnUeLyrYSUB6LHLao31Fj0cDxvFmZrE9/+tOVpZ8UyWzZzTvvvPOc5W95y1ta78OOO+5YfP/73y+22WabynWsRJdFLPt1LML7m9/8ZjHIbOc2JbYtitmX6nvYwx5W3lMAAAAAAF2DjpvfOm7asHLNp5122lqZuHbtbOqlHCzr3TJOJxGrwOaxLNitttoq+/2WSXzf+963GDTvfe9752TcWja0lUKv0/KGXUPT84997GNnl1m2tmXgtuV973tfOdXbOGCV/84999w5y2wsxcYVbAyjCVvHMrb322+/5N+t0pzN8+2xbG/LgK+r8GBjLFaK3Gc821iFZUEDwODBdAYAgHmLlWOyElVRCOR0jnfffffOyxv3gwkPX+rMTFHr7OcK1CastLgZox4rTxTLTNcZpptuuukcs/d///d/i1Fjpa6svJMfXDHhlHPerGz5+9///jnLfv3rX1fODV6FlbTLCQywOaGe+tSnzln229/+tuiSI444othiiy3mHE/OZ1iJ8ng9X/SiF3W6bwAAAAAABjoun2nVcdNGLP1rJtxrX/vaYr5gpbM9OWWXh42Vt7YEBT92YIHXuckI9n16z3veMyfB4eMf/3irfbj73e9evPjFLy7GASuZbcfjsXnj45hFP1gQvA9stykB4hhMFXe84x3L6fE8X//619cq0w0A3YPpDAAA85YTTzxxzmubN9fmS8rFoslz5s8aBjaXjed5z3tesfXWW3e2fZsr6P9VvP5/mElqEaa5bLfdduW8Rx7LFB41cR8s090CCnKxSOWY7dzmuMzgjeeljgc96EFzXp9zzjlFl5hgfs5znlM7T3MKi+5etmzZnOvto7gBAAAAALoCHZfPtOq4acJMsDPOOGOtOX/HZaxhGJiZ6PnNb35TjBtW7c6b41bZ6653vWurbdh4033uc5/Z13/605/Wmgu5DhvnyUmSGAa//OUvy0xkz+te97pOPyP+1pip7YPkm7CxDQve98HyP/zhDzvdRwBYm27SnwAAACaQX/3qV3NeP+5xj2v1/u23377Yd99919rOKETqeeedN2dZm4GEHH7xi1/Mef2Yxzymtvx0isMPP7zMvvZC0kpEb7jhhsWoiMf1+Mc/vtX7TfDZe3yEb9xmk4ncJht9l112mfP6mmuuKbrGMpSt5LhK8J1wwgnl8VlmdxXRmH7uc5/bWZY9AAAAAIAHHZfPtOq4XqYDMlavXj37/NJLL231/oULF3aaxSl++tOfznltpppNlTWfiKWxraz4brvtVt5748Ipp5wy5/XBBx/c03bufe97z/6GWUCImbePfvSjs0uojwvxvrXjamvC17FmzZriD3/4Q1/jNQsWLCi/S1/96lfn/CbGQHsA6BZGAwEAYN5y1llnrdVJ7kcwjMv8RzZvzd3udrdOPyN29n10bi7xPTfeeGM5/0/X+5rLlVdeWc6F3fVxxXNVR8ySzhno8KxataroGtsnG4yy+cAl9o4//vjiqKOOSq5//vnnz4kWtnJhFoENAAAAADAI0HHzW8d1NaWPHUOb9++0004DMZ2jnrd5gsclm3VYHHLIIWVQvzJnr7/++jLD3kzMJz3pSaVxaGMvowxsNnM43j9tgx6knz2XXXZZ1vvs2Pfcc89iXIj37QMf+MBOt//nP/95Tmlt+07ss88+Pf1+edO5zXgNAPQGpjMAAMxLTCibkIkisi1tTcNBmadx/qOuS3HFkk+9zLFk84ZZ+WY791XbHSapz+7luOJ7rOSWRSznDBTEMmJN+PmfVB5qELzkJS+ZNZ0Nm+e6ynS2v/mSfTZgsMMOOwxkvwAAAABgfoOOa8c06rhpI+r5O9/5zsV8w+6vz3zmM2X28E033TTHeHzDG95QNiuTbAaizXd94IEHFvvvv/9Qs+0vv/zyOa/9/M79kPtdsspjcTxgmu/beF6WLFlSW32tivibx28XwOCZP5NDAAAANJQltgzhtvTS6e2aq666qi8jMwc/d1Gv5yp1vkbZ4Y/HZEa9lV/q95jMCM7NQB7XCHab39zKmYmzzz67+NnPfrbWelZW77jjjuss2wAAAAAAoA50XDumUcdNG8PQ85OAlY7++c9/Xuy9997Jv1sFLitxbaW3H/GIRxTbbLNN8YIXvKD4xz/+MZT9G9Q9H5MhquhlrGKS71t+uwAmF0xnAAAAAFjLDH/xi19cO2+zYWWqfISzRTebYQ0AAAAAADBorOJSm+armx1wwAGt3nvBBRdwQQeMlU/+7W9/W3z/+98vnva0p5XGcl0Aysc//vFijz32KI455pg51bcGgQVcD4JB7zcAwLDBdAYAgHlJKgqzl/lxr7322mLUbLHFFo3R//1ipYy6mEs4nq+lS5cWoyIe0+23315cd911fR+TlbzqNYNgnHjmM59ZljATX/va19YqoRXnsLJI83HN3gYAAACAyQcd145p1HHTxjD0/Cgwfd0LpicPOuigstz28uXLi7/85S+lufyMZzwjWR7e5v19/etfX7ZBEu/57373u62DHlLtjW98YzGJDPq+5bcLYHLBdAYAgHmJzRm06aabzll24YUXtt7OOEQ7b7XVVnNen3/++T0LvFxB0ctxm2D084CNerAiHlOvx2XnO4qjaTBerYSeRZf7yO5jjz12zvxavuT2RhttVDzrWc8a+n4CAAAAwPwBHdeOadRx00bU83//+9+LcSDOH2zTSLWhKxPSMpmf97znFZ/+9KeL8847r9ShRx999JwAaeMd73hH8de//rUY1nWK5aXnG4O+b+Nvl5Xb7iXpI47X8NsFMHgwnQEAYN5yz3vec87rM888s/U2ennPIEpQxej1P/3pT51+xt3vfvc5r3/zm9+03kZ8jw0Y+XmDh82WW25ZbLvttp0f1z3ucY9iWnjJS14y57VFmCugIWY5H3744eU5BQAAAAAYJOi4+a3jpo2o53/5y1+ORcnlOIdw26pgvQT157DnnnuWBrONxfjKB2aKn3DCCcWguNe97jXn9e9+97tiPhPv21/84hedX+f1119/9rV9J3oZf5vm8RqAcQXTGQAA5i33u9/95rz+5je/2er9l1xySfHrX/+6GDU77LBDOZeu57Of/Wynn/HABz5wzuvvfOc7rec0svl/Pfe5z32KDTbYoBglD3jAA+a8/vrXv97q/SZ8rOx03bmaZGyQav/9958TJfyDH/yguP7664vjjz9+zrovetGLRrCHAAAAADDfQMflM606bpo48MAD18qg/d73vleMWyn7mDHaxCmnnFIMEgt8sOmdPH/4wx8q1/cGZi+Z2494xCPmvLZrNA7BAeNy35oJb1noXWGZ7NEgbjtes2bNmnL8YlrHawDGFUxnAACYtxx66KFzXv/whz9sVRLIMj27LmPdK0984hPnvP7EJz5RXHHFFZ1t/+CDD55TMtqE8Be+8IXs91922WXFl7/85TnLHvOYxxSjJu6DCcd//OMf2e//9re/vZb4Hofj6pKXvvSlc15/9KMfLa+9L21l5vSDHvSgEewdAAAAAMw30HH5TKuOmyYsiDwGQ7/97W8fuaFpZa09P//5z7Pfu2zZsnLO40ET53g2k7GKhQsXznndtlSzfZf8FG021/Q3vvGNYr5y//vfv9hxxx3nLHvrW9/a6WfE35rPfe5zZZntXI477rg5GfpWMt7mCweAwYLpDAAA85aHPOQhxa677jr7+tZbby0Nthxx97e//a1497vfXYwLL3/5y8syZ8I64kceeWR5TF1wl7vcpRRZHptHacWKFVnvf9nLXjZHAG6yySblvEyj5ogjjpgzV5CdL8vYzQkmsDLmdt49++67bym+ponDDjus2G677WZf2+DBO9/5zjnrvPCFLxzBngEAAADAfAQdl8+06rhp4zWvec2c16eddlrxtre9rRgl973vfdcqU3zWWWdlvffFL35xccstt2R/Vq/jFmb8eu5whztUrhv/Ft/bhE0lZcflsbGDfsqIjzqwoB8sc/xVr3rVnGWf//znS2O4K2ycwVdVWLly5VqfWRf48J//+Z9zlv3zP/9zGeQBAIMF0xkAAOYtFvH9ute9bs4yK71j89jWlVqyzFaLjrzxxhuLcWGbbbYp/u3f/m3Osu9///vFYx/72OxI0HPPPXeteXo9dq7WXff/ug6XX3558chHPrK48sorK99j5/EVr3hF8ZWvfGXOchNr3uwdFTZoEkXLj370o+K5z31urUi+5ppryqjbmOUcRc00YGLSly2za2r3ip/r6+lPf/qI9g4AAAAA5hvouLnMRx03jdn7BxxwwJxl//Ef/1G8/vWvzzZkf/rTnxbf+ta3Otsnm8IrzmNsOnn16tWV77F9Ne3Ydj+sdPWrX/3qVgaumeD/+7//u1ZAShV77733nNcf//jHWxnjCtjwAdn2XXrwgx9cnHrqqa22Y2WozbCOwQaThgWg7L777nOWWfLDRz7ykSxD3daxae4syCKFnetnP/vZa2Uv27hL3fZtKjy7p2zcxo9rvPa1r804KgDoF0xnAACY11iHOM7NY+WDbZ4wm7vKR3Wfd955xTHHHFPOK3PBBReUy8Ypq/UNb3hD8dCHPnStctG77LJLKVZt/mkvquz573//+1IQPOxhDyvLZ51wwgmV27e5b0xkxXl79txzz+I973lPcdFFF80utxJGdv6sTNgHPvCBOe+xUsxdl13qBzPr99tvvznLPvnJTxb3vve9yyhdL1SsvJydr7ve9a5rCaPnP//5xSGHHFJMI3ZsVfO2PfWpT12rVBkAAAAAwCBBx6Hjpi2QwrR4zMa18QfTnh/+8IfL4AJfkcvMXzM73/zmN5ca2wzX3/72t53u11FHHbWW0WtjIF/72teK66+/fnb58uXLSw1tYyVm5radO9cC5d/1rneV5bJtLMayvH/84x+vlZFvgf9nnHFG8a//+q/F/vvvP2cftt9+++Lxj3985WdYQL7nZz/7WXlu/+Vf/qV4//vfXwZu+PbXv/41me1s8wr7KnMXX3xxGTBgFQWsdL2Ni3hD1K6ZmelmxP/7v/97cbe73a1s9hl15cAnAQvit3Efm3/ZB6xYIofN/W4GsZ0ffz4sW/mkk04qDXerxPBP//RPtdPc2ViTr1BovOUtbynNfitv7u8BSwp4xzveUZ7fc845Z8577HsSAw8AYEDMAAAATBEHHHCA9WZn28knn9z4nssvv3xmzz33nPM+3xYvXjyz0UYbrbX8cY973Mxxxx03Z9mRRx45M0pWrlw5c+CBB1Yei45n0aJFyb/Z+avjlltumXnSk55UuW07T7b9qr/vsssuM3//+9+zjiW+d5BceumlM3vttVflfi9cuHBmk002qfz7wQcfPHP99dc3fs4b3vCGOe+z1204//zz57x/p5126nT9Op785Ccnj/13v/tdz9sEAAAAADDQcei4YWB6KFf7joKzzjprZscdd6zUneuuu+7M0qVLZzbddNPk3+v0ZS9a9Pbbb68cX1hnnXVmlixZktTJj3zkI2d+9KMfZY813POe96w85vXXX39miy22mNl8883L40+ts/HGG8+cdNJJjcfzsIc9rHasxLdPfvKTldv5wQ9+UB571XvXW2+98jrZOIKdp6r1XvKSlwxFyw8aO/d2fZquoV2ntufa+POf/zyzww47tB6zU3v2s589c9tttzUeh+3HOI3vAUwqZDoDAMC8Z+utty5OPvnkteYsEtdee21x0003zVn2uMc9rpyvxiKSx4klS5YUP/zhD8u5t6x8UNXx2HzEKXzZtRS2TYvetbJEqe3bebLtp7Do39NPP70s0zVubLvttmXmclWmskWR33DDDcnzZSXmTjzxxDLKd5qx+c4jFuUeS64BAAAAAAwDdNz/MV913LRhmcKWyRursfmsWcsU9dmdbe6Dtth4h5VYT42VWJy4ZShHnWzz5lo2cNV4RNXn1JXsvuqqq8oKZD7TW9zxjncsp8iKVd9S2BiOZUj3i5Wnt6zyqm1Ztq9dJxtHqCoDbdnSVm1uGrBz/6tf/arMbq67hlVT1DXdt1Zdz36DqioNpsbsjA033LDMcD722GM7/24AQDV82wAAAP7/OZGtE/vBD36wLOlUhZX1sbJRVsZn0003HctzZ2WQraT1X/7yl+I5z3lOsdVWW9Wuv95665Wlr+w9ViYrRxBauauzzz67eNrTnlYsXry4dttWutrOl80xZQND44odh5W8sjJeVm68qpy05jE+/PDDy/Li//3f/91KUE8qVip90aJFc5bZPFQAAAAAAKMCHYeOmzasxLYFkltg/GMe85jGcQcrbWxzQn/pS18ayJy1Noe3aXkbA6ibz9vm9v3MZz5TlltuO1Zix2qG8NOf/vRi5513znrPPe95z7L0spXBjtNlNQWq2Pm1uaf33XffcrzEl8vOxcaNTjnllPLcWInoqJWrkgQOO+ywci5qK0meCuyeVHbbbbdySjcbUzrwwANLw7fpXDzpSU8qp4Sz697EDjvsUI7Z2X1uYxN1JrJt+1nPelZZYtummgOA4bKOpTsP+TMBAADGHotaNVPV5vBVJqzN8bvXXnsVk4b9qz/rrLNKMXbllVeWEcKWlWsdcRMGNv9TnXHchEWtWjS2zXl9xRVXFDfffHM519F2221Xmtmbb755MYnYvNQ///nPi0suuaQ8b2agm0jdaaedSpHTJKKmje9///vlPFVi6dKl5bnpRaADAAAAAAwCdFw+06rjpg3L4LQsUpsX2OY4tnmALQjaAi7M6LUximFpU8vgNWPxT3/6U5m5amMNZpJbhmuXYyV2P5phaHP02udYZvdGG21UGrtmSpvhHOe/HjV2biwo3eYnVma27fPChQtLw9Syms2oni8Zt3afmkms8RT7fbH71sbWLHPZmo2x9Iplkv/iF78ozXv7Xti5tgACmyfaggn62TYA9AemMwAAAAA0YtHb3/zmN2dfv/KVrywjywEAAAAAAAAAAAAwnQEAAACglgsuuKCMGLbobZVY/9vf/lYuAwAAAAAAAAAAAJgf9RwAAAAAoGfe/OY3zxrOxqMf/WgMZwAAAAAAAAAAAJiFTGcAAAAAqOSrX/1q8YQnPKGcr0ucdtppxYMe9CDOGgAAAAAAAAAAAJSs//8eAAAAAGC+85vf/KZsxpVXXlmcfvrpxfe+97056xx66KEYzgAAAAAAAAAAADAHTGcAAAAAKPn2t79dvOlNb6o8G4sXLy7++7//m7MFAAAAAAAAAAAAc8B0BgAAGCAnnnhicemllw5k2w95yEOK3XfffSDbBogsWbKkvJ933HFHTg4AAAAATDXoOACYRFavXl187nOfG9j2X/jCFw5s2wAwHWA6AwAADJD3vve9xSmnnDKQbX/yk5/EdIaBsmDBguIud7lL8ehHP7o46qijijvc4Q6ccQAAAACYetBxADCJXHXVVcWLXvSigW0f0xkAmsB0BgAAAICSN77xjWUDAAAAAAAAAAAAaMO6rdYGAAAAAAAAAAAAAAAAAABwrDMzMzPjFwAAAAAAAAAAAAAAAAAAAORCpjMAAAAAAAAAAAAAAAAAAPQMpjMMnZtvvrn4xCc+URx00EHFtttuW2y00UbFggULit1337141rOeVfziF7/gqgAAAAAAAACgpwEAAAAAYEKgvDYMlQsvvLB4zGMeU5x99tm16x111FHFBz7wgWKdddYZ2r4BAAAAAAAAjCvoaQAAAAAAGGcwnWFo3HLLLcXee+89azjf4x73KF75yleWGc6rV68uTjvttOI973lPsWbNmvLvb3/724vXvOY1XCEAAAAAAACY16CnAQAAAABg3MF0hqHxla98pXjCE55QPn/AAx5QnHrqqcV66603Z53f/va35d9MUG+++ebFlVdeWay//vqd7cN73/veYtWqVcWiRYtKwxsAAAAAAABg3EFPAwAAAADAuMOczjA0/FzNr33ta9cynI199tmnOOSQQ8rn11xzTfGXv/yl030w0/lNb3pT+QgAAAAAAAAwCaCnAQAAAABg3MF0hqFx8803zz7fZZddKte7853vnHwPAAAAAAAAwHwEPQ0AAAAAAOMOpjMMDZu7WZx33nmV6/3jH/8oH9dZZ51i1113Hcq+AQAAAAAAAIwr6GkAAAAAABh3mNMZhsaKFSvKLGabU/lBD3pQccopp6xVYvt3v/tdcf/737+M4n7qU59afPazn83e/rJlyxrX2XfffYvly5cX22+/fdb6AAAAAAAAAKMGPQ0AAAAAAOMOpjMMlRNPPLE44ogjiuuvv77Ye++9i1e84hXFbrvtVlx33XXFz3/+8+I973lPsXr16uLe97538d3vfrfYZpttsrdtmdG5YDoDAAAAAADAJIGeBgAAAACAcQbTGYbOOeecU5rLxx57bDEzMzPnb2Yyv/a1ry2e97znFZtuummr7WI6AwAAAAAAwDSDngYAAAAAgHFl/VHvAMwvrGz28ccfX3zzm99cy3A2Lr/88rKk9p3udKfisY99bKttX3zxxdnltQEAAAAAAAAmCfQ0AAAAAACMM2Q6w9BYs2ZNcfDBBxennnpqOZfzv/7rvxbPetazil122aW48cYbi1/96lfFm9/85uK0004rs5bf/e53F6985Ss73YcddtihuOSSSyivDQAAAAAAABMDehoAAAAAAMYdTGcYGv/2b/9WGsnGpz71qeLII49ca51bb721eOQjH1mcfPLJxbrrrluceeaZxT3vec/O9gHTGQAAAAAAACYN9DQAAAAAAIw76456B2B+YKW0jzvuuPL5brvtljScjfXXX794y1veUj6//fbbS3MaAAAAAAAAYL6CngYAAAAAgEkA0xmGgs3VvHLlyvL53nvvXbvuPvvsM/v8nHPOGfi+AQAAAAAAAIwr6GkAAAAAAJgEMJ1hKFgGsy+hXcctt9ySfB8AAAAAAADAfAM9DQAAAAAAkwCmMwyFpUuXFosWLSqfn3766bXG8ymnnDL7/E53utNQ9g8AAACgDTYNyG233cZJAwCAgYOeBgAAgGmaNqQpKQ0AJhfSSGEorLvuusVjHvOY4gtf+EJx6aWXFm9961uLN7zhDWutd/XVVxdHH3307OtDDjmEKwQAAABDMZFN+FrFFXtUq3pt62+xxRbFzjvvzNUBAICBgp4GAACAcTaRLSA7V0vLcL7HPe5RbLDBBqPefQDomHVm7FcBYAjY/Mw2X/P1119fvj700EOLI488sthll12KG2+8sfjlL39ZvP/97y8uuuii8u8Pe9jDih//+Med7sMOO+xQXHLJJcX2229fLFu2rNNtAwAAwPhgpnAb0Wvrt8WquOy6664D2X8AAAAPehoAAACGmYmcq6V7zVrec889i0033bTz/QeA0YLpDEPFTOQjjjiiWLFiRe16D33oQ4uvfOUrxZIlSzr9fExnAACAycQip9uI3l5M5Nx5Na1ZRPZmm21WBrIBAAAMA/Q0AAAA9GsiN2npQZW+tsot0tL2aFp6k002GchnAcDooLw2DJWHP/zhZYT2scceW3zve98rzj777OKaa64p/9Hc4Q53KPbdd9/iKU95SvHYxz62WGeddbg6AAAA88BEzslIHlRxHi96vaGcer3eeuvRPwEAgJGBngYAAABvIudoadPegzKRc7W0NVsfAKYfMp1hXkGmMwAAwGBN5NyS1oMwkS1gzQvcHEMZAAAA8kBPAwAADM5EztXSgzKRLci6jZbGRAaAFIy0AQAAAMBamJBtMyfyMEzkJtGLiQwAAAAAAACjxLRxGy09DBM5R0tjIgNAF2A6AwAAAMwD4hxNTSJ40CZyThkuE8kAAAAAAAAAo+L2229vpaUHbSLnlrRm6koAGAWYzgAAAAATSBvRO2gTuc2cyAAAAAAAAADjYCLnZCTb+oPA9HGbOZExkQFgEsB0BgAAABgxZgi3mRPZ1h2UidxG9GIiAwAAAAAAwDiYyLklrQdlIsdy1U3aGhMZAKYRTGcAAACAAZnIbeZxGgQ2J1Mb0YuJDAAAAAAAAKPETOE2WnoYJnLOnMiYyAAAmM4AAAAAWSZy2zmRB20i52Qk2/oAAAAAAAAAo0JVvXK19KBN5BwtbQHZmMgAAO0h0xkAAACK+W4i58yJPEgTOSdqGhMZAAAAAAAAxslEzslIHsTUUEYbLY2JDAAwHDCdAQAAYKpM5Nw5kQdlIleJ3NRrMpEBAAAAAABgHEzk3JLWgzKRcw1kTQ1FJjIAwPiB6QwAAABjayLnit5hmsh1rzGRAQAAAAAAYJSYPm4zJ/IgTGQzhHODsdUAAGDy4dccAAAABo6J2Daid1AmskVDtxG9mMgAAAAAAAAwSuLUT03aehgmck5WMgAAzD/49QcAAIDW3H777a1E7zBM5JyMZMpvAQAAAAAAwChpo6WHYSLnaGnT3gAAAE1gOgMAAMAcEzknI9nWH6SJnFvSGhMZAAAAAAAARkkbLW0B2YM0kXO1NCYyAAAMAkxnAACAKTaRc0taD9JEbjMnMiYyAAAAAAAAjAozhNvOiTwITBu30dKYyAAAMA5gOgMAAEwAZgq3Eb2DMpHjHE1NIhgTGQAAAAAAAEZpIredE3kQrLvuuq20NCYyAABMIpjOAAAAI8Aip9uI3mGYyE2iFxMZAAAAAAAAxslEzpkTedAmck5Gsq0PAAAw7WA6AwAAdGwi52QkD2IOJ6ON6LXIaTKRAQAAAAAAYBxM5Nw5kQdpIueWtMZEBgAAWBtMZwAAgBoTOSdqetAmcq7oxUQGAAAAAACAcTCRc7X0IE3kNnMiYyIDAAD0D6YzAADMC0zIVonc1OtBmMiWVdx2TmQAAAAAAACAUWHaONdAtsdBmcgWZN1GS2MiAwAADB9GswEAYCKJArcpknoYJnLOnMgAAAAAAAAAo+L222/PNpCHZSLnaGlMZAAAgPGH0W8AABgL2hjIwzCRc+dEBgAAAAAAABhXEzm+HrSJnFvS2vQ3AAAATBeYzgAAMBDaiN5Bm8ht5kQGAAAAAAAAGAcTuUlL22tbfxCYPm4zJzImMgAAAGA6AwBAI2YIWzR0rui1x0FgIraN6MVEBgAAAAAAgHEwkXO19KBM5FiuuklbYyIDAABAWzCdAQDmsYmcK3qHZSKn5m3CRAYAAAAAAIBxwUzhNlp6GCZyzpzImMgAAAAwaDCdAQCmxERuOyfyIFh33XVbCV8ykQEAAAAAAGCUqKpXrpbGRAYAAABIg+kMADABJnLOnMiDNpFzylrb+gAAAAAAAADjYCLnZCSb/h4EbbS0BWSTiQwAAACTDqYzAMCQTeQc0WsieZAmcu68yJjIAAAAAAAAMA4mcm5J60GayLlaGhMZAAAA5iOYzgAAfZjIuaJ3kCZyrujFRAYAAAAAAIBRY/q4zZzIgzCRLas4znncpK0BAAAAoB56TAAAmZjYPeeccwZqIls0dBvRSyYyAAAAAAAAjDuXXHJJcdVVVw3NRG7S0pjIAAAAAN2D6QwAkIkZvDfddFPPJnKO6MVEBgAAAAAAgGnj9ttvL7OXezGRc+dEBgAAAIDRgukMAJCJGcIbbrhhKX5zS1rbugAAAAAAAADzGdPSppPbzIkMAAAAAJMFpjMAQAvufve7c74AAAAAAAAAWrDNNtuUDQAAAACml3VHvQMAAAAAAAAAAAAAAAAAADC5YDoDAAAAAAAAAAAAAAAAAEDPYDoDAAAAAAAAAAAAAAAAAEDPMKczAAAAAMw7br/99tk2MzMz53Vu23TTTZmbEAAAAAAAAOYNVfq5ra6+4x3vWKy/PvYUwLTBtxoAAAAAxoYqQdqrMVzVutrXbbbZppNtAQAAAAAAAPRKk2buSlPbdrpgu+22w3QGmEIwnQEAAACgkRzhOSwz2D7LN+2ff51aR8/1OXXrVDW/zg033FDc+c535u4BAAAAAACASv2aa+YO2gzO0cB+nwepr01Lb7zxxtw1AFMGpjMAAADABNNGgPrXt912W7JV/W3UgtSv04Z11lmnbOuuu+7so3+e8/eqZUuWLOnwSgIAAAAAAMCwaGvy+vWjXr711lvXWq7XXivnBksPSl+3pY1G9stz3rPhhht2dCUBYJzAdAYAAADoAy/gvICsMnWrWnxPSsh60erF6zDEZtdUmb1RiFoz2pjBcdmgWG+99Qa2bQAAAAAAgGmmKthYeteM3DaB0lEvp557c7gfM3fUpLRvndkbTeFcXQ0A0BZMZwAAABg5TRmu3lztdz0vXuvEaJUpHIWs/9yu5zgaBb1m/nZhBms7cbt1bVTraV0AAAAAAIBRMgjdnFqvKpM3ZvmmgqXrtLTX0+MSJN0rvRi7vejq1OeOQg/3sx56GmA6wXQGAACYIoYhNPtdL7WukRKbbZb5bde9Z1JpI0AtAzf1aG399defszz1fFRmLgAAAAAAwCgYpR7ucpuD1NWTrqdzjF+vjVN6Ourn2EYVLA0AMC5gOgMAAATGzaRtIzQHQb+iNQrXSTGDq0zR1PIqUZpaljJ9o4i1pvWiGYzYBAAAAACAcSRXt46jvh7U+ejKDK7T1eOmp6u0s+F1rVGloasCpOPzqK+rDOFcMxcAAPoD0xkAAAbCpArNcRNrdXQlWqvEaxdmcJ1RKzHYRpBWmcC+XLPffl0Ect3fvAlcNc+wXwYAAAAAANAVk6CbU+tOCoMwg1O6ugs9XaeBzXDNDZZuq6+rMn6rTN8mLV2lqQEAYLrAdAYAGHOGIQwHsd58pmvRKvGu8+rPb06UbmqZF6dtzdzU+yQWc6KEU8ZtV81vGzMYAAAAAGD+Mgm6uarNVwZhBled19yqVinj1pdR1rIu9XWdnh6UliawGgAAugDTGQAgExMoK1asGLoghW6Ihq0/t/F8x2tgYi93MCJHtJrh24XY7JpBmsHeCMYMBgAAAACYX1x33XXFDTfcMFQjF7olpZnjc/+6TmOnlqX0dKoUcyqAuklfDwPMYAAAAExnAIBsTABddNFF8/6MNUX+esGXs54/v1UiNPX3KoO+akDCC9BJAzMYAAAAAAAmmauvvrq44oorivlOr7q5LvO2rYau+1vKuNfjpAYQYwYDAAAMDzKdAQAy6VpcdS02ByFejShKVaaqqzbJEehVc/ySGQwAAAAAADAYPT1OurlqvSpztxfNfOutt1b+bZLxc/8OSldPokkOAAAwyWA6AwBkYmJl55137kyU9oqPPs4RqLfddtu8NIOr5vntsgEAAAAAAEAzS5YsKTbZZJNOTN9+iJp3UHp6UqnSzl1rasxgAACA6QTTGQCgBVtssUXl36Jgtde9CtT5YgYPSsACAAAAAADA+LDZZpuVrYoqs7fraluTSo5m7kJXYwYDAABAP2A6AwBkYqL3H//4x7wyg7sWsAAAAAAAADD/sPmcbV7n+WgGd6GpMYMBAABgEsB0BgDIxETe6tWrh3q+2opQzGAAAAAAAAAYN2666abiuuuuG9rn9aqP274PMxgAAADg/8B0BgDIxGfq9hOdTGYwAAAAAAAAzEc93W8Frdz3YwYDAAAADB9MZwCAFuy9996UiQYAAAAAAABowXbbbVc2zGAAAACA6QXTGQCgBcxLDAAAAAAAANAOzGYAAACA6ef/asUCAAAAAAAAAAAAAAAAAAC0BNMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6BtMZAAAAAAAAAAAAAAAAAAB6Zv3e3wrQHxdddFFx7LHHFt/5zneKCy+8sFi9enWx1VZbFTvvvHPxkIc8pHjiE59Y7LXXXpxmAAAAAAAAAPQ0AAAAAACMMZjOMBI+9KEPFa997WuLNWvWzFm+bNmysp122mnFqlWrive///1cIQAAAAAAAAD0NAAAAAAAjDGYzjB0jjnmmOL1r399+Xy33XYrnve85xX77rtvsXjx4uKqq64qfve73xVf//rXi3XXpfo7AAAAAAAAAHoaAAAAAADGnXVmZmZmRr0TMH846aSTioc//OHl82c84xnFJz7xiWKDDTZIrnvzzTcXG264Yaefv8MOOxSXXHJJsf3225cZ1QAAAAAAAACTAHoaAAAAAADGGTKdYWjcfvvtxYte9KLy+T3vec9yPuf116++Bbs2nAEAAAAAAAAmEfQ0AAAAAACMO9QvhqHxwx/+sDj33HPL50cffXSt4QwAAAAAAAAA6GkAAAAAAJgMMJ1haHz5y18uH9dZZ53ikEMOmV2+cuXK0oy2RwAAAAAAAABATwMAAAAAwGSB6QxD45e//GX5uPPOOxcLFy4sPv/5zxd3v/vdiy222KLYbbfdysfdd9+9ePe7313cdNNNXBkAAAAAAAAA9DQAAAAAAEwA68zMzMyMeidgfsw/tcEGG5SP++67b/GABzyg+OAHP1i5/gMf+MDiO9/5TrH55ptnf8ayZcsa17HPXr58ebH99ttnrQ8AAAAAAAAwStDTAAAAAAAwCWA6w1C4+uqri6VLl5bPN9544+LGG28stt122+Jd73pX8ehHP7pc9utf/7qc61kZ0Ycddljxta99LfszrGx3LpjOAAAAAAAAMAmgpwEAAAAAYBLAdIahYFnFO+644+zrTTfdtDjzzDPLctqeG264ocyCPuuss8rXZkDf7373y/oMTGcAAAAAAACYNtDTAAAAAAAwCaw/6h2A+YFlMnue+9znrmU4G5tssknx1re+tTjkkEPK11/84hezTeeLL744u7w2AAAAAAAAwCSAngYAAAAAgEkA0xmGwsKFC+e8fuQjH1m57sMe9rBi/fXXL2699day5HYuO+ywQ+M66623Xvb2AAAAAAAAAEYNehoAAAAAACaBdUe9AzA/2GijjYqtttpq9rUvtZ2K4t5yyy3L51deeeVQ9g8AAAAAAABgHEFPAwAAAADAJIDpDEPjbne72+zz2267rXZd/d0yngEAAAAAAADmM+hpAAAAAAAYdzCdYWjsv//+s8/PO++8yvVWrVpVrFixony+/fbbD2XfAAAAAAAAAMYV9DQAAAAAAIw7mM4wNB7/+MfPPv/6179euZ79bWZmpnz+4Ac/eCj7BgAAAAAAADCuoKcBAAAAAGDcwXSGoXGPe9yjOPjgg8vnX/jCF4qTTjpprXWWL19e/Md//Ef5fMMNNyye9axncYUAAAAAAABgXoOeBgAAAACAcQfTGYbK+9///mLzzTcvbr/99uKQQw4pXvva1xannnpq8Zvf/Kb4yEc+Uuy7777FsmXLynXf8pa3UF4bAAAAAAAAAD0NAAAAAABjzjozqmMMMCROO+204vDDDy8uv/zy9E25zjrF6173utJ07poddtihuOSSS0ozW+Y2AAAAAAAAwCSAngYAAAAAgHFl/VHvAMw/9ttvv+Lss88uPvShDxXf+MY3ivPPP7+4+eabi2233bY48MADi6OOOqrYe++9R72bAAAAAAAAAGMFehoAAAAAAMYVMp1hXkGmMwAAAAAAAAB6GgAAAAAAuoU5nQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGcwnQEAAAAAAAAAAAAAAAAAoGfW7/2tMM7ceOONxfe///3itNNOKy6++OLi6quvLm677bbipJNOmrPezMxMccMNN5TPN9hgg7IBAAAAAAAAzFfQ0wAAAAAAAO3BdJ5C3v3udxf/9V//VVx11VVzzOV11llnrXVXrlxZ3PGOdyxF9f3ud7/iF7/4xZD3FgAAAAAAAGA8QE8DAAAAAAD0BuW1p4hbbrmleMxjHlMcffTRpeFsRrNaFVtssUVx5JFHluv86le/Kv7+978PdZ8BAAAAAAAARg16GgAAAAAAoD8wnaeIF73oRcX3vve90kDeaKONihe84AXFF7/4xeJxj3tc7fue9rSnzT7/7ne/O4Q9BQAAAAAAABgf0NMAAAAAAAD9gek8Jfz2t78tPvnJT5YltHfYYYfizDPPLD760Y8WT3jCE8rXdTzwgQ8sFi9eXD4/9dRTh7THAAAAAAAAAKMHPQ0AAAAAANA/mM5TghnOKqP9mc98pthjjz1avf9e97pX+f6//OUvA9pDAAAAAAAAgPEDPQ0AAAAAANA/mM5Twsknn1w+7rXXXsUBBxzQ+v3Khr7kkks63zcAAAAAAACAcQU9DQAAAAAA0D/rd7ANGAMuvfTSsrT23nvv3dP7FyxYUD6uWbOm4z0DAAAAmA7e+c53Fuedd96cZbvssktx9NFHj2yfAACgf9DTAAAAAIMFPQ0wPyDTeUq48cYby8eNN964p/dfd911c8xnAAAAAAAAgPkAehoAAAAAAKB/MJ2nhK222qp8XL58eU/vP+ecc+ZsBwAAAAAAAGA+gJ4GAAAAAADoH0znKWGPPfYoZmZmitNPP7247bbbWr334osvLn7/+9+X5bn33Xffge0jAAAAwLRg/S5rAAAw+aCnAQAAAIYHWhpgemFO5ynhUY96VPHjH/+4WLFiRXH88ccXz3rWs7Lf+/rXv740qs10Puiggwa6nwAAAADjyO23317ceuuts+2WW26Z89raFVdcUaxcubIUyLZ+r9OaAADAeIGeBgAAAOidJi1tyy6//PLiqquumg3g3mKLLTjlAFMIpvOU8MxnPrN4y1veUqxatap45StfWdz97ncv7nOf+zS+781vfnNpUpvhvN122xVPfvKTh7K/AAAAAMMykaPoTb229Zu4+eab51SUyXkPAACMP+hpAAAAgP+HGcKme3O1tK2bk7kcdTd6GmA6wXSeEpYuXVocc8wxxVFHHVUazw9+8IOLl7zkJcURRxxR3HTTTbPr2d8uu+yy4uc//3nx0Y9+tDjzzDNn//a+972v2GCDDUZ0BAAAAADNJnKO6LXHQQnYddf9f7PTWMCeNQAAmHzQ0wAAADCtmCEcM4+btPUgMP3s9TQATCeYzlOEmcznnntu8cEPfrDMxDET2Zr/B7NkyZI571EUkpXYPvzww4e+zwAAADA/UeR0bjbyoEzk9dZbb47olQj2qPyXrevnciZYDwBgekBPAwAAwCSayE1aelAmsmlnH4wdA7N99rM9t795XY/xDDCdYDpPGe9///uLe9zjHsWrXvWq4pprrlnrBz+Wuth8881LY/rII48cyf4CAADA9JnIOdnIOeW3us5Ettf6XIldXy67iVg2jHJgAADTBXoaAAAARmki55azHgQxENubydrPqIfbaOK47qDGBABgtGA6TyHPfvaziyc+8YnFcccdV3z3u98tTj/99GL16tWzf99oo42K+973vsUhhxxSvOAFLygWLVo00v0FAACA8cOEbCpCukoED0IwKho6it0YPS0zua3obYN9hmU6r7/++rMR3cqSBgCA6QE9DQAAAP1g2jQn+1jLBmUiG3Va2u+vN5QHsT/S0lYtTGW2yXQGmE4wnaeUBQsWFC972cvKZqxZs6a49tpri80226xYvHjxqHcPAAAAhkyb+ZsGbSJ7qoSmX1f7EvfJDGYvkP3rpucSutZMAPvnMpT9OjK2ldGtQD4AAJg+0NMAAAAgTEO20dKDMG2lhevM41jZy7+OWroXDa3nRpWW9gHaCiDXNFU6j9qXTTfdlJsMYArBdJ4nmNlsDQAAAKaDtnM4dW0iR/FpYlLlp73Q1Tr2N5+R3I/IjWW9JGR9syjqusfcqGqfPa3P9ucAAACmH/Q0AADAdJrIOeWsB1FNK+pavdZn+UpeqeV1hnDUsKnnXsvKMJZWrtLUvuWQ2i/0NMD0g+kMAAAAMGJkyrYpweVpa9am/maf7+csznn/oMphedGbEr69it62+LJf9milwOyzFbFtzwEAAAAAAGB0mDbNMY/13JvIOVq56bmqYSkYu2l7g9TSMSB7ww03nKOfU88Hqevr9DTltQGmE0bKAAAyeOc731mcd955c5btsssuxdFHH835A4ASH4EsA/nmm28um39uYtQvl/jtIuPXIwPZC7lYrjrSxrzNFYh1WchVZnLcZy9U+3nedl3th66ZTVFy1VVXzQ4UMKczAAAAQDPoaQCow+tbGcgpPe2X67k10769lolOaWOfEZyre9vMUdzGbK3KQs4NyB60bq7bhs6lrtOiRYuKjTfeePb82noAMH1gOgMAAMDU4IVqV88VuewNYy9wfcS0soW7nsNJ++QjoqNAi2WquswAlgErIWkRyjnNoqrtsVdhO+joZ0W8pwYufNO5XbFiRbF69erZ9zOnMwAAAAAATKPx24turvq711bSXV5bex09iKmhtG0/H7IPyI5zH8vo7UqLeq1rJnHUzVqmrGTTmfqb9qMf43cQeDM5dX19QICwAO7rrrtu9jVzOgNMJ5jOU0KXg8qxZCcAAEAbehWiXQjbXHwJLG8Wx+d63fUcTrGUdTSQfVSw/q7SWN6M9c/j69zn3iCWyJVZ7JepTUI0sjeT60zlfgczBjG3FwAADB/0NAAAjANd6ua272tD1M5N2rpLE1n7G01kIQPZf6b9nzcjtxe9XKe9bbteN8fgaz3KVJ6ESllVZnLU1V0E2qOnAaYTTOcpIUZlAQDA/GYYorRqG6M63ihu60Rwr+KmSnD6LOQoTONrw5fByhW4OShyWk0Ct65NEikzOWUqd3UfegPempUDu/baa2ev6yQMGgAAQDPoaQAA8P8Thh083Yvx2yUp7VynrXvVW14jG/YYS1nr7z5j1//NHqXP2gRj59BWS09CQLbwGed1Vb66SkaLFdJMV9t0VVY5zF9jAJg+JmukEWrp5R9+09yOAADQG3HOoGGawNPwmx5N5ChydZzeQK4TmCZyLLI5JyvYn1O/fjQYta7+JgO5S1LCtk78Tqpo83Ng15nKXZrJMQo91eLghJnOm2yySSf7AAAA4wV6GgBgfBhF8PSojd+ukE6uCsT2xysD2U/hFDWysnlzA6V1Hq35baSykfWZCsjukmkPyBaxfHmVrh6UmVylq1PXc+HChUxRBTAPmMxfU1iL3E6R/SOyDJ0//vGPxRe/+MXiE5/4RPnP4n/+53+Kpz/96ZxZgAauvvrq2Q61PV+2bFmyo2qdK3sc5PwpMBzjt1dhOw3Gbx1t5xTy50hGsX/uH1WmSe/feOONW2f8pspox/JPqe+n5kI2g7rLOZxSordJAHf9+aM0k5siqrsa3EnNj5UylSf9vAIAQLegpwEGzw033FDceOONszrhmmuuKS699NKpC6acJkZR4lnPp5lUVaymeXmjjk7paq+p9V7TQtEcboM3rKvKWUfsMxWU3SXzJSC7zkxO6equzGS7pnUB2fob1b4AoAlM53mG/QPZfPPNiwc/+MFle85znlMcdNBBxTOf+czi+uuvL17wgheMehcBxrrDt2LFivK5yqr+8pe/nH2u6E1fJkYdMzOwlGmp13Ge1Gk1qr3xO6zI5Pli/NaJ0jaGcI7Ijct8BrJKHvvX1kwI6XnOwIH/3uSK3qYKHvpe2ndLmc5d0RQlHQXwpIveOjO5ylQepJmcMpWn7fcTAADGC/Q0QO9cd911pdHsDbfTTz99zrQlXksrENRras2bquXTZjKlGIZuxvjtVis3PTeatHRc1oRttylT1663ryIWx0tS1TBlHstI7or5GJAdr0NTla8uzeScKl+TmukNAOMHvybznL333rv49Kc/XTzmMY8pXvGKVxQHHHBAsccee4x6twDGEpXa9WWILFK7H1KGte8MxubNay+6mzr/OcbvoAzh+Wr8DsME7hJvIpvIuemmmyoFb1dz5sYsZJ/hnFpXx63yXsqA7lKI5RrJ0yR6Pfa9bRK/XZrJupZ14tfaOAwg2j1ox2+/+/ou2H4DAMD8BT0NkI/0gzSi9f0t+7lXvE6SlvZ9S29YR03tg8HrAl7FIIOnm7Y3zUR9O6iA6dTzLrWcN3O9YVilpVPB070QA7L9mFXq+Py0UHb/d6mx5nNAdrwPcuZN7tpMrjOVx8VMlpa2pDeNAVliHABMH+PxqwMj5eCDDy6N5r/+9a/FRz/60eIDH/gAVwQggXWKt9xyy1mBvMUWWxQ77bRT5Vw5fpk3YGOTkPTP69ZPNXU2JbRj9rQ1mdO+JE4qqnwSjbRhRCPXRSmPcyZqU8S0XndhIqfu/yjodb/qUaK363LWGnBqEr8SwNMoej32m5IjfrsaANH5b4qoHtfzbufLxLBvJpCvuOKKYvXq1bPrjev+AwDA8EBPA+SxYMGCsv8nU3Xp0qXFjjvuWKmhfetHK6e0t6+KZY8K/pZ+lkaJesIHfacCyCexb1inkQddQWtc9bTKGudq6S40VCog25vHvpKXXus+VVWvru4/ArLrzeQ6Xd3l+W+q8jUuZnIKS2KIetrOoVWPXLNmzex60x5YAzBfGd9fJxgq97nPfYpzzjmn+OEPf8iZB6jBlwIz0bz99tvPER0SCcoE9KIkdkZTwsVHqA668+UNZy+SfRSq78zq0Zc880Lbi3QfvTqs8lTTTq7gVevXRE6J3tQ9KQPZ0P3jB2i6QKXCmuZs8m2+3BfeTK4Tv4Myk6tM5UkacLN73LJsosGcAyIZAAAM9DRAM1HDLVy4cC097TV11DrKHpXu8bpa/V0/z+0gK275CkxeR0sPe83i+8jeoPaGtTe7fVDsMEzg+aCb7H5oo6W70E6pYIomYsJAV5qKgOxqqoKxva7uKkhf4xpN8yaPs5kcsfOi7GU109Y53yG7v7sapwCA8WJyfsVgoFiJUmPZsmWcaYAaLMvNY3M6x2hoLziVwbnppps2luT1pbQklqvmdYkmtje6fQSsN8kNb9J6kRmbhLpt0y+vEtH2aPvgBbQXS77FfYjGd1y3S7E1TrQRvV2IHN1TfhBHhpmuhzeQDT/wYfdxV+InBic0Gcldzh01yWZyylTuSqTZd6xJ/E6amZzCzlmMuLbzmTM4ZfeivjP6HcspxwgAANMPehogf05nYbrjN7/5zRz953W01yF+WRVeS1f1pf08qlFXe7O6TitX6Wyvp6Tb47p1JYdT58DraW9U67O8Xk7p6Ki/pwXfT2/S0l1MDZQKyPaZyP786rPiPbzZZpt1ch0IyM7DB6vUGctdBafkVPma9OB4u7dTBnPV9yvOSW7nwE+bZkySwQ4A+fDNhhLLcjYmfTAZYJBIPOq7onlvTUj4MjoxajgK1hjt3NQkNHOygiWGtG+2v/7RL4/GVRTpElGpTrjvODbhTehoQGtZXCd2xL2gbjKom14PopPvz3uTeaxlXXxeqgRdVbS6Px92T22yySadmLle9OYayZMstLoq1dY0b3KXZnKT+FWVgmnDl/RSJnPqOxkzauy5vidmIlizyha+ZKKEdb/fZQAAmA7Q0wDNqJ8rvWL9KOlpEU3a+Nz3bX3GoD23PltVXzc341eaSvpZLepo36Sbfaa1Xqe0tK2j9zbhM6GrjPmUro7kBHrnvB7UmGGsEtekpfs1kVMB2dJfVVo1FQjRha4lILsdMQGjSlcPwkyu0tXTOMZh34dUNbD4vUk1jRHZb7J9V/TbbPhxS2OQFSkAYHRgOkPx85//vGz2w3+nO92JMwJQg2Usy4i1jqZ1oCR4cjM2qzqj6rylyrpGIdLUrFNnpmLbqN1USxnWihaOojplXPus7Vy6MKrrtt0kuq35eb9Sj7Gz3aXo1aMtTxnw9vk+C9mud1Pkfy5191rq/p5Gs7IfM7lJ/HZlUvoBtzpTeT5cH5X0uvbaa4tVq1aVzeZd9pUhqqoG2PdJxrJlH0gY5/yeTNvAAgAA9AZ6GiAPBb4a1h+TtjDNo/K/MfM3ao8607PKyK0Kkq1rtq8WdJhDnQkjXRAN66idm17be3LNmTZGtdfCueSY03HubR2Hf52qwNVFQLbX1Klz48+RHz/pwkQmILs7M7lKVw/STE7NmTwfNJ+de9PPpqft0ZpVpkj9psXvqp0n6WmbMsEec7OX7TeD6aoAphNM53mMRSl97nOfK17zmtfMlrc49NBDR71bAGONF55bbrllsfvuu1cKHYkdE5gSjbHEVp3B5wW1tmfbyqWtUa0IxC6M6qpMwroo8CrDWuetKWK8zqi2pvf490ax669dDlVzcqnj7D/Tl+WN83/5axXLqPVD0wBLykSeD6KqHzO5SvwO0kxOCeD5YCYbcZoB+w00U1kGs4lha3EgTgNa/juo75YChqzZc61n19C2tWbNmjm/Iz77hUhsAAAQ6GmAdljfy0wJr6f32GOPyiBc6V/7rnk9KL1Sp3e9gej787n0alTnEqdxyWkpM7rKsPYaW4Hkft22RrU/l75/nSo5nTs1lM8497pY29aj9lfBCV6D+/m0tb+mlVTVq19tS0B2/6hyQNPUUV3pLI1zVFX50pzJ82HcQxpX59maaV3paZnL9hsbfxeinjbs/ElDK3vZJ2xYILg1/52MVSWEvbbPpOIqwHSC6TwlPPShD81e1/7hXHXVVcXf//73OYPk1uF/5StfOaA9BJh8JG58pK51qLxg9Jmp3lTWa9/iHM4S1Km5pKKgihHgqQ7ztBjVdeW3Yplwe27XJM7fI+EdBboRs56ryofpmkWTXH/TMRoxatxvu4poRPt90b3kxZM6+ykTjSzkvPuxbm4nP9dbF2j+3zrx25WZ7AViVctdr9dWt30/x15VRLsMZvs+xykCqgYk/ICUnW99F3z5RW3DSoXp91XfMT/fXVWAy4oVK+bMRWjVLwAAYPJBTwMMnlhRyvpa0r+xvLGaL4/tm+F1nYxVaWCZGbF8dir4NqXRejGqpdXbaOpBG9VV/WavpaMpZf3vGFzr9a+v/hUNYG8yaXncBx9goOvtz7sP6s6dm9r36VNB4Xqd0tHS0jLSCMhuHxxcZyp3lcmq723TtFFdmMnD1sdtm869P+8pXW2aV99p6emq6xE/Q7+RPuvbUHVGM6s1duH1tKiaru/KK6+co6cXLVrU9/UCgPED03lK+OlPf9r6H6v/4d9uu+2Kb33rW8WSJUsGsHcA04M3Qa1DFQ1XLwQlnlNzEVVl6zYhgRezfqvmvtLraFDHeX9TIj53mTqiEnGxYxpFgMS1CTttU8fio6O98WTNOsx67gcUYkS8hKq1lCHuByJSJngU0j6aXgMVKeFbFXFdJY79tWkqe+bFu7/XFEkat1s3B1fV39qI+kmK5q0zlrV+kxisW2akstT9Mj3GbchU7VqojgpflaBu8EtZyX7gSlUhosms4/FzPvnvpgSxAmAsq8GarxYQMzQi3gxvyyjPNwAAdAd6GmDwxP6W9c98AJ80YV1Acr/lmFPZwUZqjmcjVifrRTfrdWpdVTnyRnh8jJpa++O3k9LS6ndLM/o5qv359O/1wZspQ9yfv9ScyOq/e02tY5eW9RopnpNoOFfNUa3t1Wno1N880oSW+elpq5urXk9qBmesNFWlq6Mmq9PNVcv92E1d1QLdK/792q/Utvs1h0dF24ASP/Wbn4deJrNPvvC62p9/TTclPa2m35pUQkZEv6O5FQM9oz7nADAYMJ2niLY/1PaPxUoZPeUpTymOOuoooosAOsA6YlUCLdIkpFOC2huKbX4brMNppm00qFMi2H9Wr6TEaCqiWb9bPpu7ynRNmeTxs7yR7Et7xezmuA1dN2/Yx3WqTHrhjdpoPsuQj/OU+Y57fN7r+ZeB10WGrr8eMePev47HnFq3X+Hns2NTWe5xnqdcw7gKnwnR1Dw6920qDIwjXpz6gYZUdQGfWRLnaovmskRxjMa2ZfE7qe+/PTcRbI9mKNvgpDWbg9lex0E3I3dA0PD7ps9OrW9t8eLFZUaOyK30AAAA4w96GmC0+P53E6lg7yp97b/bPjg4F/VdY3+1SlPb5/VjOKr/HHV0XXnsmBmcMmRT++3776mgbN+Pj5noQtpPYyBNejrVH09VIPJNma0KYPfHpObHOvo5/zrvbbLcU1SZ6FFHV2nsWJK414BktarA7Kjv/FRh/ejpnNLk0cyU9uz33I8Dsaqh184K/IjXwo9Z+UzhqLFjdrPGvWIAh5oPZPE62h5NZ6e+k7l6Ot4bKQ1dp6e7qPQGAOMHpvOUcPLJJ2eva/9krHzFTjvtNGc+HQCoxzpIS5cune1cb7311uWczlUmWT8Gm3+dijSNho832+L7faczF703Gobq+Po5pfz++Xmbe6FuLiojluqSkFGJJWWaqjRWrnHrRbYeq0x4f26rIplTc1mlImer9i921qPgjMLdC9FowqeuhTf7686Jf2+TEGkiVeIsltiLJdvi/GRdZF/3aiaPmirRZkRzPj6PLZYh9JkQ/vfEfxf8Pui5HmOWiv+boq59qXv7flr/oyojQfeKj7a25zKXq+ah07moe+5/F/WYKq9dhUp2C0QyAMB0gJ4GGDzWX/QBe3V6uo1ebmop/ZwqRetNHv9ZbY3qaICmzN2UlvZlrHvBm4upaaVSmsxr6Vi+2AypfjLIo27QPmr9GHTu14la2kr55mhYv41o7ur4UxrfawY/FpGa5zb1vGofmnRzrp72xxK1tO631D3mr0u/ZrzQd8EH06faOGV615mgUSc3/Z7E7OLUb0kM2oj7oed69JUA/Xr6/fKlsa1pzvKUhvbZ4TFz2ZbF76fG/fS8aYwovo6BIk1EPT1O9wkAdMd4jahCzxxwwAGcPYAh4MWQdZYWLFgwVufdd3hj51fGjzqsPiPYd4xjeWufOWrE5zJ6oyEazS179JGcfj4ZPyeU304sUe2Fn++AV5m7VRGemo/aZyCr8+uFaNWghvbZn6tUVneMUO9qPqMqonCPHf94jWT4RrO36nUTKdEejWPffERualtVJneMfPfZ5Kl5uTTftcou+1JdPrs9tV3/95wW9z1lDqeygVMit8qAr8t08Fkfda2u9FXbagr6nmmAyJvYMvlt0KqqxLUt84JY1y4axroWsfLBKOk1wAYAAMYL9DTA4InaZNz0tPrRddPzSEt7/Swt6PvaflmsqhODe63va4Z81D2xkpe9R58ddbpMpBi4HCsCxTK7tl2riObxQZpRa8Vy3958tH6811f+eP12/edrH+y8+nGDqgzvQfa9dbwxOzkGeuu5NyzrNHS8/nWf7x+NGKCQ0tQpPd1kcsfMa5mUyij3GlraOpqXfgqwOi0d96fXVqWZ6zKC/TopLR01sdbNLW9ddR31/chF39NUwomui/1GVBm0/pr5qaa8npa+H7eAgEGPkQHAaMB0BgCYEOqiLb049pmLMRvaR2NGs9kL4xidaURT1Udix7K6wpe88savdYZtgCGW+RLqcKfEgaKiU6Wq6oRO1bn0YltRnqltpuZo8mZbFNFVy2L57zgntc55KjK2CW/mthXWPtI9NReWPxcxMMHfQ7HEU6rJOPTzeMVHfz/4/UjN75QqzSW0jxYdnzr+VPZ11b5URcl7894HJXjBG7dVZ1KnlsX7xA9A+e+mD7ioG2yI92RqHTuuGMGue8OLcc0VZ8v8/WSCN27X/u4NZmveYB40/jr38twycqwcWNW5BQAAAIDxo0qXGNavztHSVdonms2xPLXXnSk9HQOUY3/e90VlQMn8izoqBhVHg03b9lraf0bKSIz93Xj+FNjujeoqPZ3qX/tjbtLTXhN53ezPbdTTuUa1v0Y56LykdKnX0zGQXsfRpKW1H1FnSkun9iWlNXW+q3S0Xxaxz9Wc4Ndee+1anxl1dCqTPOpn3SP6u55XBWDHpIIm3Rw/W9o3Vuvz94pflnp/3K6ui/bbZw7799bNT+2vu4JJdJ40ZpbSmrEamII9hkHq+9z2uelpG3tDTwNMN5jOAACZWKfSOtvqXK5ataq45JJLZv/WZauLmo6d5F7KWasT743NaGT5LGQvcvSoTrNfnmPAKOPZmuGFihdEPqrWP/cGlaK14/mI56iLiGidn5TIiZHfsdxU6nlONK/OazSlq577Y266FilD3N9zPkjBTDb/NyOatSZ2zGT0osIPYOgzdA/I4I8C1UeU69Hfo34wwN+/Kgcdo82jaG167PVeSUV4N73218Hvrz8+X+rPm8MSzznX2ZvMOscxSyFlLts+2j6ZCF69evVagrhK1PsBjmgwa3BM19UEZxSd/j7QAI0Pgkg1/zc/WBYHQfollgMDAAAAgDx8YKrX0221slH3d28i1+mlfspZx+BobyRXZb1qvw3r76r/bUTTquk8WlOGcjR0pU0tM9LraWVDevPPqNLQ/rj61dPSminN4PVHSpfEjGpv4OboaV8JKmVYx2pvbcZXoiGeCjzQtdJy+9yoUWQyVmUNx6Bh3U9eO8cpg/Q3fw9Wjfv485AyfTUGEO/r1GMvxACLXD2dynqO40OqCBANZf9dzEVjGKmM/3jPan9tHywAXlpaWf2poO9473qDOWYwW1OQTHy/188xyaBJZ8dy3VUBBb2iYwCA6YZRMwCAFvhsSRPJy5cvz3pflVmcEsC9mMhVoreqdJA6orFD6bNc23YqvSmmznjVejGDtiky1UcEm/Hvl0mgyQxSSaj4qPdXmdOxyazromOtbZrI0LE1RRrnRB5X4Y1qa3bOTOgqStk32ye11H2nctVtSJmXuja6Vj4y398rcYAgRiCnxLCEsjds674HqeUxsCIOavnl8bn2VduQsE3tW8zaTxGjwL1Q1Lnyws8HPsRBmZRBW4UMZvudkyCWiE3hv592TU0Iq6SXMpjjwEFqUCS1PLVvClTJJWcgKhVEkmq6jpdffnmxcuXK2Wvd9rsBAAAAMF+x/qUv5Zyrp6OJ1KSt25rIuQHZvu/v++Z6lKkbKyjlEjNsY5/Y69NYhaupT6tlmv7GB4mqNHbU0F5f23pRTzW1rrS09JXXJVX62RtnsbXZF2/EyjRWi1paj6lqY036K4UfK5B5advQNVHz5mN8v0jp35iB7+/7mPmb0tJ14066XlErN+lp7Yfh98HvX0pPp8YvvI42YtW2GOCu51FH+7Exb8ZW3Ue6Ty1gX2X4ZTDXXWt9n6Wh9Wi6WvdtnfFedVxx33Q/59JWLzfpbH2+/eZfddVVs9dviy22yN4nAJgcMJ1hLDj66KOL//qv/5p9ffLJJxcHHnjgSPcJoA51eJUBWieCq0zkVKfN8IIuRqXGFsWiPWqu4pShmfq8uo6kNwt957uq5Yo5ZdKmWizb3BZlUa9Zs2at8x331zr0qWOSyeSvaU7LHeBICecmolGtcx2jkGO0cZzz2rDrapHv1oTWjeffP9c95z+rSuBIaPUTFZ+KvPXBEj5QokkE+uNMfYf0t1QkuL7vMmH9/OgqL+3vAUWUe+oM69Tf9RgzF+JjSljGDA8fVKLnfmDB/2bpevpSXX5AQ3+ze0eCeJglvdqQk7le9R2PGQrazqWXXlqKZOG/QwAAAKMALQ2TQux3KwMw6umorav6cyk9q35rrCKUeu23I30lM08aIxpPbbR0NA+r9LS0tvrqbbRkSrfFOZ/boHNvRmokdRymB+LxSBeksoubWq9B3TlEMzpWbdO94fV01X4pe9xTdR1iBrU+U7oxBhPr/lXgeK/E4IRUFqu9tmuYE6Cs8xQz+aV9fcZ3KrPanxOZ9L6kvcaI4vb8Z6cMbf83/1rnIGbsxuzdVICIrr2CJ+J5tPXj75T2XeM0phMXLVo0Z/syt+2cey0d76VJ0dL6zqSmGvDnxQfUXHbZZWUQt1i8ePFAjwMARgOm8wTx0Ic+dOCfYf8YTzrppGKY/P73vy/e+973DvUzAXrBOlTKdLbvihnO9lodT+sobrbZZmsJT599WZV16aM3fVZjNI+jWGiL3psqAdRvdm3b/VDp3RxBXSWi2whq+7sv611HqvSwmu2zP4eeqtJdbY3q+N4415MXZt5wjqWtfMZ5jOb1gyI6Np+F7E35qujwVGZxTiZ5DvqOmCD1Rq6+U1XmcqqUVCwp5Qd4bDt118r/zaNtVKHj9Ka1ro32MwpQtbjvddnBTeXH7D3KdvctZ1DH3i/zWUEK1nIirvXZqaCEOGBQ1XSP9dIURBHn54ut33KB/bwXAACGyzTqabQ0TBJmoElPW79Qppo3e1N6JZVhKd3l9Yc0QirrNaWt22bhats5WlrmaxeZvqn9yK1G1WWwtzRRkxGaCvbWOTNtsWDBgjnB3kKaqU6P5RjV3iyOzQcRx4zfVOloHY/XM36ZoeAEVfXSPWAaauHChbVjKzGLv05X+wpaTXgzMAZY1GnpaLD6gG/d/8qA9+MhOeMefr/9GFquue1fpyqD+X2vym5uqrZVZUYro91nuOdcB90HNq5iOtrGC301sKr9qdPYOj/96uW69/oggSodrd8PbadX0NMA0wmm8wTx05/+dCAdVlHX8RgU9o/s+c9/fvnPauutty6uuOKKoX4+QBvs+6HOsjWb4/Siiy5ay0T23ydfpsebeX5OpWiAtdmfKGybxO+wv+OjFtRVkcZNSBilIrzj/kUh7SO8VSZJ590+XyJFmcAm2i2AwZfs8pmz3nT2Ayo5xKzg1MCLzwZQubCm9WNmsRdLdm97ge7PlRcxPtjCH5sX1VHwt8HObY4J7iPM/flIlczz5zMlEv1gg+7bODe5vvupaOvU99NnY8TgldRru5csy1/NXueYq/bZcf5l29e4T20z9FOf4891DLJpem34+yf1/fZlzHRPNkWPp4S33u9/Q88666w5AwAx8AQAAMaXadPTaGmYNGRkqK917bXXFueff/5a08/4fpgMPV/y2b/W9C4+wzYXb0LnaOlxrOzTdbB3TsD3MIK9db59GWlVnpJeVnCyNLTpHpU2jnq6Keg7x4BNaWh/X+hzU9W66nS119M+qDmlpY1UAkNK8/rM47bYtryerjLDveaKmtmbpV7bRSPbr5OjpWV6x+1XVQnI1dEaT7LAGNPRVv5f4zRV1Qs9Gt/zLWpF20ab7PwUqcD61OtUdrYC+XXc0VT2332ROx5XlYkef2P/8Ic/zLl2TFcFMJ0wUjZhTFsE0Ac/+MHi17/+dbHHHnsUhx12WPH2t7991LsEUIl1ylasWDEnotJKrfrsyRhBHUvfqjOruZQ86nD5pnlR9ajn6nBHsTKfaSOofWfaz2ksM1giVgavz1JNNV962XfYY+R9Kos9ZuH6+6cKfw/WlXbz0eLxGGQ0SxSk7h8vbv3503u9SEx9B6pEdm7pOP+ZOg5/ncwg1/WKZa9VCitGpvt9tnsltY6PnI4DXf55FJVNg1W9fEc1mJE6J3b8GlxR03WxDAJrHn/t9Rui3xb7jKr5uVKve8Vnx8d9q8rurxokioMUPrs6vo6DEoo694MX8Rqn7tMtt9yyHIAAAIDJZJr0NFoaJg0zmW2aEh+8Z4kH6m97HSSd5Pvp1g+UDoh9NJ+F6fWzN7C8tvYZqXWG1Xyh12BvP3dt1NUKfI2lzX1gsc/gjXo6VoUzqgw1fx1zgk5TVcCiljaqgqKlk3VsVZ9RpaV9kLZPJojl3FO6WhnjbbSlryLmr5cf+/CaWsEFVVpa3zWf7R11tTft43zhKYM2ThPXVdCHDxD3aP5la6q6IENY98/SpUvnXDtdb+2/N8UVGJFjbvfTF0ndc1VVAlK6Op6bJt1cpbE1luAD6+O4SWocw+Zwtv8FADDdYDpPEDbP8TRhGaKvf/3ry+cf+9jHpu74YPqwjtXmm28+26mz+VnMgPBR2T7LLpbCiQajOt9R7EpMW+fQOr51pXXi9n3nzhuYKVPTP04CsZxafF73t7rnKXT+lO3syxOnRHVO9rQX6DmCyJe79h16DZb47FgvWmNkaTSKfWRrVemuXsSQ7ttcvAj10d1RqPoBIC/K7Rz4OZJSpnHdcfrt6bmRErh12DlSdH0TXkTXCepoVCuC35vL9jrn+th95EtjKxukX5qEtI+eVnBAVYBHm4yDKgNb36uYmZwazNFvsTLDreVmX1vkux2Pv9cAAGAymCa9iZaGScQCIn3lMHu9ZMmSOfpMlaCkX1L9MZ8BHft3hn2GZSrWaWkt8xmrXk/n6uhJMay9YdaLZq56ntIjdj6kOXygsLR01NT2mKs763S3r6jkA/ltP2x/vK7WNdT7Uno69Tzq6bqS2G31TVW58CpiBmvKII4mupZr+qT4PfDfD6NurCBl1kctlvP9yM2Kj3ouR1f7LPQYrJ1Tvcs+U6WxvZ7u9zvvdWyTrvbfnTgW5add68XIjga27gUFQBgak4hjGbZM+xGN6Tpdbb/Nek9VgD0ATD58syeIAw44oJgmXvKSl5SDt0ceeWR5bNM0CADTi8+MNIG82267zel4+WbETmNTFqGPBu4n+jGab15EpESFBLYvbRUz/hS92GRYdy1m68zhXolZlVWZlSmhqAxZOxc2UOKjtPUef039/GL2qM62BkZ8MEJKMNYZmylRVyW4ej1PqQhznyHt71fds7ovquZikiiSiMq91yVKvGiJ3z2f1eDL7cWWEop1EcJ184nlonNZZ87b3/18Ubovq7LifbPjNSPe5oqSKK6bd7pfdH+nyu55ARwHoKw1DYDF5isFpH7b/KBkLv4e1vHEuax8GTt7vnz58jJDR+s0VVYAAIDxYZr0NFoaJhFlGUvrWMbbXe9612RWp7RTro72mqXNdEQpYiBs1M5xma+MlMr08wZoHDuImsTrpV40cxtzuB/q5u71Vb9Sn6tz4/Vh3fW1bXnjVFouZjh7E9mbrobMMZsizV/nHNOybZUu4e9fH9Qd9UfUILrPot6O11OBt22ubVUGta9c5oPdTbdVzc+dO87SpKtzzXlfAr5uHZm0Mmptfa8Vq3S1HZfNwW1N5rKfKq1LtE2NAVbNmxyvr35HfEWz1P2Reu2TFryujlq6bQa97lON6zRpa6sWeeWVV84e1zbbbNPhmQWAcQHTGUbCl770peLb3/52Wark3e9+N1cBJgLrfN3pTnea7TTZcxu8ahJ8bV572hrW6rB7E7TOrI0iz3cE43NtJ2WGxzI7sTSaN6r9vMfq7Mdo2n5IiRxfclkC2BukEnS6xqmyV8JHOuu4q8oq+2X+2OKASJ0AyzneVGRwKpLfZ077eZG0XC2WJosmn4RR1Zxfil5Xhngq8lvnIVfQVEU1pwYFdN20D9GYzzHp2xiJ/RjVPoPem8wp4nJf3lvHYftipaosoKuXjGodT5PwVfnyXogDLYZ9vsqp+d8PH1SgKhAxwyAOxsjo1qOugQJ6/PKUud2UlWADVRYZLyYhswUAAKYLtDRMKmYyq1yt9d923nnn4kEPelDfWjplrLYxrH2/0GtF9QlT/fNUn7QqMDcu90Qj2/eHYwWzqKW9SeQDlvuhSktLA+hceYNU5yMi7eh1hpbr2P083XVaJV7XHGOzyYytMzHjdVHwgJ+Wp2q+4Sot7TPx63SWBZpHLe2fq4yzzm2O6ZyrCbWP2h/TPjnv87ozt0x7G6M6XnPdg37sQS3nfCiRQEEw+s7p3OeOG/i/i3h9q3R1r4Eg8TfFJ5DUVWWI43ypR+171NX+Gvm/Vf0u1x2bjVX4ZIquA2IAYDzAdIahc8011xQvf/nLy+fvfOc7y/LEXbBs2bLGdbrOloT5iY8E7DrLLdVp89HCMRu3at5TRXT6kjvRjEl9ljdjh4EXc7EkT+zgyxzWunH/NdAgoRRFYpvyPVqvSfy2yaoUGhzQHEgpQarBAx9AkLpePvI7lSHdhAYRrMSRF+feiPfo/EfxnyLnu+Ejx6uOQUK67SBCkzFfR51RXSVAm47Xl/Sy820C3q6ffZbMftuGv58l6nQvKuLcWp3ZGTOqJSLrxK+/v+pKD/rlPnI5RjX78moxKz31HfK/XV2iz2lbUjyVSWCvLfLdhLKOdZCZ5AAAAMPS0gZ6GoaB7+NbH81XwOmXmBWqPnEMlFU/W4GUXlvrtZ+XWNMp+XVyjO9BE7OvvZ72Qd7SndJyVefK73vUAynztI66gOwYMNz2mH3QbJWWjpnCMfNbxytDM2qdHGxbMjrjdlPHpfPrxzeqyDFuZZb6cxFLavsy2dHEzaVtdS8jV0urNR1vnG7K9Jg1fZbKp1vFL6+jZdJLD0pL12m4VDCCX+b1tP8d0f3lv4tRP8cxD2nKaCRrTEb3ScxQ998njRu1Ge/IRWMVbZF+To1lmZ62sZAYuAIA0wWmMwydV7/61WV5Sotofc5zntPZdnfcccfOtgXQC72Wump6noM6oHUdwiiKfcdWHUIZU3WlsmKWa+xgG1HQxuhmPfeZ1HG/onCLVHXgq57L4JTBlyoh7qOso8j2gjl29quEbt3zrqLRdW2roqVNlJkQ9hHTvUSCp85/ykBUSS7NE1VX4rqf4+8lu3hYRrUGt7QNRVzXXXt7nZq/W99pHVPqGtu11fx3PtrbD5Dl/pY0EbMwfLlAlTaX6K8qlZiD/33Q69zl8Tr7wU0/CJN6rNqurpv/bZBBDwAAMOla2kBPwyiJmrCr5zn9f5l3TUZUSjtHfe377NHw9hpBZpXeK1PP90ernmt/9Oj7+n4/fKBy6pir9HNKT/vxBmVVVmlpBRV7DRz1s8/c9iWe2+jqrrS0zmGqkpd0tJquXWy9aK2qoFxNE+VbLG1dV+K6zTG3yTAepFEdkwX0PfFJFKnA6FiJLupoVQXTd8J/93Sd7TNszERZ5nHecR17VwElftzAV6GL2fN+jMW3XKr0cWp5ldb2+6zr5B+jFvbb8YkMsby5rklXYxQAMH5gOsNQOfXUU4tPfOIT5T+Zj33sYwOZGwNgUFinaNWqVbOdMBvwOeuss1qZw8MiJYp9p0+dPF+O2Kgyh/06qRJeOgdepHnjS8133tUksmPGZFOn3otp7ZdEijfFYiSooWX+GHwUtBczMpnV/LGqLFA0k9u+rlqn6jeyzoCMQQFCwqupHJmPDO6lxLUXvxLnOo9VzV+j3P8LVYEWMaDCRww3lbjyTaI0lcXrl/n72pf0arp/FTUsY94e7RrpHPrvqx/U0nWKAjgKRn+9YwlBbccHdihoRL8VcfDH36P6HGv6butzdX60rdSj7m0fle8/z//dZyr4e8MLXh/wEv/u99VHklcJbX8fpQZbLrzwwmLFihWz69sc2gAAAMMALQ2Tjgwd9aMuu+yy4ve//322OTxMoqHs+8DRkPXL/XNviGmbUQNqffXHpeFiQKk0tH9UgGk0vquMI0/sH8e+t9fTPug6GmDedPJa2lcZ8+9LVTjK0cVt14n7Fo89V0vr/NgxWIam1whNQc+RnOpZdSWuU/o5ttyA2KpAizgeE5MCYqn1qKvjeU3dl1Gf2/3t52HOLT2toGdpaWs+8Nl/B6MO9lUD4++PPde1iJXI6rS1P7d1gRT+d0LnSVnbWl43vliX1OArjPlHv+1oHPv99utpWZV2jvo6UjXudMEFF5R6WnRZsQUAxgdM5ynF5nQ87bTTyg68/ZhbJyXHFLN/KMcee+xA9sk6Ec9//vPLf0b/8i//Uuy1116dbv/iiy9uXGffffctjUKAXvGZj72UGWoyhw1vzvjnWt+v47cTDRh1tK3jPYgo4KpM6FQUrOY4kkETI6mjwaZHGeNeuFZFZddlc6dex/NXNZ9TxIvwKMp9xz719yZS4tVH7Pv7pCoSPfU6LlPUr1ElWOP+VmVTR+NTIjFl0kaRGYWKPU+VkIrnNwY7+POTMhJzlqe+T3YevKBUaWyV9jJRHOeDS32OF/USsLa+/W+2MpleuOp8apt+O/4eNHSN4rWOZm4cyFAUtQaS9Dd/HXxmRFwWzWpvNA8imCwlpOP3yx+7F/NV+HMdf7vqIvljxjzTdgAATCfjpqcHraUN9DQMGmX6+tf99qVS5rDvg4umDOJoDvsgyFwjLwdfvruuwpjvb0ZzMFW+Nx6H/73S372O8hra6/E6LR2D2j25YyPRkMvV0TmZzSlDOJX5HoPMm7RzfK0MVZ27qqBqHW+V0e01SAwyTunnHG1tRMMxlU1uzeu6VMBCL5rav5bm1fdeWeOmo/XokxD8fea3r2Py8xbbebXtmVmb0tG6F+O27NFfT/+o7cbzFDPyYzCGT37QZ1RpZ31XvBEevzdd62k/LpDS1PE7p9d1aP/rkhmqAgfibz56GmA6wXSeMq6++uri6KOPLj73uc+V/4B7YVCm89ve9rbinHPOKe54xzsWb3jDGzrf/g477NC4TptSJACRKN6sc2RiscocbhPp3LU53BbfafTiN2U4+X32YlxzRUUBnGrehItlufzy3O9sldBIPfrOsTJZ68R0k+DWfeDf4zvYdaZoFHepc1UVpR2N3RhFnCo/Fp9HMaztxvvZ37+pdSQqJBb9ufb3U8rsT4nWqr/5537AoiryXsfqv7spQey3G4WxMvJlpqf2yb/297jOn7Zn4tqLTG3PB5x4fJCFX+azkv2xVxmw8bvn3+8HOfQeff9ySRnVqWAJL661D/44/THG5fHc+Hspvjfer6n99ZkXZsAvWLBgTkCL/x3z7dxzz51zrnuZ4woAAMaXcdXTg9bSBnoahkHU0z6ou05L+/f6vt6gzOG2VBkwMUg21de01xYQnOq3p3S1jreqtHXb6YykCXJ1dBw3aKOd/TpeL8Z1U+c2ZYpGfV2VFR3PQ3xv1Oop7Zy6NrHEdZWW9lrU/92fD6+XU+MyqQDnNtraP+pc6Ri88ei1pQ9ISJnMVRpeGtpn5vtrG6+xDwRJBRHbsZtJrYpkMTDCn2+/TcP/Luha6Jj8PVIV6JDKUk6NL/j16kr1p0gFdvvjTLV4rCndnBpP0Ofp3FWNQcTr6q+TNZ+Zb3Np+8D3qKv983/84x9zxm7anisAmAwwnacIK1FxwAEHFMuWLascaK36p+6XDQITyG9/+9vL5x/60IfKf0gAk4Y6svqejJPhUBW56IWM77ymnqsjaOWJtJ22eDO5TgD3M/9QCnVY7bPqBFFquc/Sluj1QjoOIKiMmQ1EymCN2b+x7FTMCo0GXFU2aRTfXvj57FWfxeo7/71eR0+dmIzL9JgSeIYtl8HqhX2M9vX/m6oMxfi31Lp69IImnjMJRn22XTMNCPlzkIr+j9+33JJmURBqH+Igh3/U+UyJxmiMVv2t6nz6gR9FWvt7Ss9jKXQ96jseByfqRKeRMqpTEeG+6f3+uxq/s7qfUuej6brIhPal2vx8an/84x/nlOYfVL8JAACGz7jqabQ0TAvqUwvpt1ETjSX/3Iiara6PqpK/0TTLpaoKVdTUXf7WeA2fq6F9i1m7df10rRPn6/Vz7HpNLbMymvepgNaUto6B2SlzNc4xHbV0v+c6lW1b9ej/p+j+83ouFdDuNXQqCL5KI6f+rvfF72k8Z15X+/Os6xhNYG3PXwst9+MbOdNt5QQlRz0az2OdMZv6W+pz/d/8mJr+lhqjUbZ26nseq5XFYPbYUvd/3W+UN+f1vY0JGT6wpBctrXsjNS+5SqD/6U9/yq5OBgCTC6bzlGD/MA477LDZklj3uMc9iqc+9anFD3/4w+Kkk04qf8iPO+64siyYzUf4s5/9rPj1r39drmvZPRYtPch5FN73vveV/8B22WWXMjrthBNOWGsd+8cjfvKTn8yWwT700EMxqWFs6LdTVGUOt33uO5kSc9HwVMmulGA0/OtoAqXWT807lJrjKQpTicdc0Rr/ViUcYwZljPqMWcRaJ/U3H+npBXMseeY77f59TZHdKTPZXwcfsa6M9xhV7cVFSlRqf+M+xKjUeB9HQaj71D/6+z8lylLiLUYCV63vB5u8MRmvjb9+8bpGUVn1Wtc3zj0VBX88R9GItKbBpLpz4/8mU7quaTCpTlz6lhpkSZm1/u+517HueFJocMEP0jTN/V1VJs+24+d994NSKsemfbbPtc+y45N4j9/VeC2qBvOqBvE0Z56VQrcSq5YFJ8ZhoBQAAKZbT6OlYVroV0vXmcNtn6sv7QOQU5paestI6VXDZ4JWTbfj+8a+XG/sG/ttqakvmquf4/KUae71ojekUjq5Tj/H9VJTb3kzWuc8pVmjSeyfR03jj88bdV5jeD3odYf0gbanZQoq199Sn+Px2lH3Z0pbxb9XmZdRW3qzNG7fH5vP8vfHGa9d1TXzYw8pPa3qc/47o9LYfvwhpaX1GOdfNm3tdVTq3MW/2f744Iuq56lqVf5+SJm2MUkgamr//UldszbjJCls+3YuvRmbMq1TiQYpNOYRtbRKnOv3xI/JWIvjCKky2f46+CppPmgjHptNUWbNuOKKK4qVK1fOnqPFixfXnhsAmEwwnaeEr3zlK8VZZ51V/mAfdNBBxYknnlj+0F900UWlSDaOPPLIOe/57W9/W84L9bvf/a74wAc+UArqPfbYYyD7Z//QjPPOO6844ogjGtd/y1veMvv8/PPPx3SGsZrfTR1G6zTb/WnEDqw37VJGmpEygNX5V4RoLKfks2/9++J24vZTnVwti6WJZXrF8kLR9DNSAiMuqzIK4zaathu34U3UeA7iuZBwiGZUqkNdta3U+U6t45/H82j77LNh9SjBI7yxnfr8qqhddfC9MPRR+l40pu7Z1H0SzW+/LN7rMSs33i/+b/51fN5EFG86fxKEKmVtwsYGh+25L20ds6n9NmWCK0LXmgSU7be+fybY9DcTz1bBwzcT0yag7Ln93ZuZ/Q649UrO3Eupv+eia6D/+VXoGvlSenGgqa5kul2fKrNXIti3mIHddA7aHPOoriUAAMwfPY2WhmnB+uNeT1sf2fR01CReK3j9YUQtKbyWThmfqbLXKX2e0nRV/T2vwaJB5A1yaadco7hKP/u/1a1TpXeatGydDvYZkNGIi0ZySsPGx6jlq7R0bF4j+GsTg8+rjt9fu6iH/dRTXtd6IzcGN8flqXskVZ45lcXqP8ffc/78RNM5flY/WtqPmdh4lGlpM5cV9OtLZPsg+rhNBdLLWJZm1jW3bdn2lfVr42rWop5euHBhsWjRovJ3wrYRr/koiL8vTbraB7g3YetJIzfhA2X8913fST+OF3W1/c3OdxUykdU0fqWWM6YQ74+6Y64yzgFgssF0nhK+/vWvz/7z/ehHP5pVunafffYpTjvttOIRj3hE8Ytf/KJ44hOfWJxxxhm1/3wA5jMpwddmrreUUPPL1EFrMnT9vsT98suiOJOQsb/5DnvK+NE24mOOgOxy3fhc++wFUiqrWOc7nsOUyZkSa1EQRhEVs719Zz5GqvvtRbM4imh/fHViKlVOLEZ+x5LVMcM6Hn9ddG48TxqksabnMYvWiOLGi+mYiRyXpQZSYrS8oqvte6ioXXtMiTuJXR/Zr/313w9/3yn4I85z5TN5m66Vj1JuynROlafOWRavafz8qv1qWpaKeJaITM3tpnswBs2kBHiv+2Ro8ELNv44msx+8qRqMSy33lQP8PadMZ61n2W0AADD5oKcBBk/sdymQM4eYeeg1dFzmPytWmKozfv1rr1NiXzwG/9ox+O2kgqoHrZvr1vF4bRfNqpgRG3VTfL9/9H+PAcY+6FkaKjX9UdV0UdEgztHYdfrMm3MpHR2X+2XRuK7SzSmNrc+WdtZzrRdLGnuTPWrWuvOg8x0DFPQdiVn9ZiZLR1uz11Gv2TZtrNifO+2/D67waDzCtGHU0m2mA9P6cWqnlL5OfV/jXMM+McDfK/3o5tQye63p35rGAuOyVLCMX9brfur4o45WJro9rwqaib9rVb93GouKpfZ1bFdeeWWZ6az3WmABAEwfmM5TgpnF9k/g3ve+d7HTTjtlv88ixj71qU8Ve+65Z3H22WcXn//854tnP/vZne+ffYa1Ot74xjcWb3rTm8rnJ598cnHggQd2vh8A/SBhpg6VdZ4s6tPPV6R5ULzp4ucYjdms0eTNEZGxk5zqNEfTLoqcKHDqRGPqdcoYTW0vbqNKpHpRr/1Mid1Ycqtqn1L7Es25KIjj/LW+k+2Fcd0xpz47ZSZXvS9nHR1L0zpeWPl1/Hn1UeoyE/3zGMXeFanvQqp8eWpgKAZpaP+U4WpCKSWC7NglThVNbeumxKf2Ke5XKls+NZgTj1X72jSoFgdh4mvfPHHwocrgj+vE34xUxH28Bj76XS01j3lTZYHY/HXy372U2a/y2m2I2/O/nanPqxqs0j7G3ywAAJhsxllPo6VhWoja1/qOq1atmtXSaqkgxmj6xcxW/1gX0JzqC8f+n/rMUf/kBDLHv0XdHR/r/ha3V/de3+f3pn40lP0yfzxNujlq/KhHU1WKcnWMvy7jrq+9Jmqjo3N0Yy4xoCIVkBH/7r8L0RDUenYONO9uSocrSMCuq6ab8oau15LeaNX+pbRhTkasrSPdWYe+u033X2pMp1/tXBWc4s+f/w7qeKSrVf7aVzasM6j9vRarDHhTP6V/bb+uu+66VvdclUaPv59Rt1ehv8XfAwCYHjCdpwSLFDJM7Hr8j7wNdqeymO9yl7sUD3zgA4tTTz21nGt5EKYzwDRgHTkr1eujn61kvEiJT0Vf5ohG3ymum7MlZYT0QhSnKRFX9bfUY5XhqWU+QriqPJcvdZYSt34f/DGkRIPOaYx+VXSsj5LVPMrx/VVCvuoapIRklbjMXXcQ7+91m97srTIV/TITTmYQ+qhciVv/OvW5fvDJz8Fct58SWCp3bVmovimi1wuiaDqm9sNHc8eoeO2XMqz9PnvhGOfb9sfgBwV89HJVloSOVc2XVY+ityoaOX5uDPTw1zlG+TcN5tQNGOn6+Dmf4hx2/hz734fU61zarm94Aa391P0cB/UAAGCyQU8DDB4L2Dazw/dnbY70lL6SySFTyy+Pz30/MxVI7Jd1ZXI09YNT+rlKc1ct86+N2Eeu0mJ6Txw7aNLOqf57at5Wr6V9+d26sYCqzxkHjTus93st4wOptdxXWdLfpDGVfZwKwK7KfI261FoqEEPoutn1lJZWmWtrpuF07VOGbmqsKmrJVIZ5Kpg5BjnHwJNUwob+5stOp9ZVwHoqcSMuqzKO61q8xjF5Io53xd+GunE12z9/HXwggNaNAQ8xICJm9uegYIV+jGrtr93Lti30NMB0g+k8JSh7KpZ59K+tfMV2222XfP+uu+5ams5//etfB7ynAJNL7ACqM96ENyxSTR1G39nNEarxb6lI7aaM6KaObpOINlKix3e0fdnwOtHZhmgiV5UrJgtxMPjM/liey4vbaFinjEQJSs0VpebnjDKj2L5rqYhlbzArg7lqigkvdKtEq49sjlHOMWo6Rjb77UWDWRHa/rwpojlmCjdtp+pv+p758x4jnb2567+TXgQb+n1qgx8c1PcyBtFIuMffFG+Yp4IB/LnXoKIfiIuDCTEz3Wd26D11wj6uI/7yl7/MOeaquaUBAGCyQE8DDJ5oRFpfsWmqktgHjxow9jPb6Ge/3Pf3U9ra74det9HNVU19+JShGDO96zJ8216Hpml/dG6he7wxmgqyVrPrvnjx4vI9qQBcb1hLS3tNrfXsfrXvWUxwkGEpc9kynE1L+4D8uN9qXu/HCgNVOlrLbPt+TMpnHtfp3jjFlj3a/2691t98pnfU+3XL/PRKIn7v/XciBjV73WnH1otObBo7VNCMPsP/1ugxpf3jGIoPXPfXzl9nHxTh7z+dF12zuoDzuK7x5z//ec55I9sZYDqhBzEl2BwIZipbB8OzxRZbzD7/+9//Xmk6X3vtteXjFVdcMeA9BZhcrDPlTWb7fu2xxx6zEb6puUXtMUZ+9iJGc9btEp/BGef7ictyyBGsXvzWGckx2h26oyq7OLamjNGqjFoNqtj/KkVtS6zKQDbRG0WSF8yas1fCSaJXYtv+n+k4YpnuQeLNZz9HVRR9Oib7bTBhn8qwrhtsapobueq7q/MtEa7roke//1XBKvZoAxE+00HPY/CM/80ycn7reg0S8UayPktBJ/FYvEEdyzL6ZXVR4DHSHQAAJh/0NMDgsX6k9X/V99tyyy2Lvfbaq+y3xflF9SiDypvKXRm+TVWs+kH97iZjMacST26Gdp2GJjB7NGZy6rrnZIxWZdSaNtHcy9akC6V77H/Z0qVL58zLa9g69joVqCGN6auU+SCIuuzoLvGGaZ2O1nMbm7PjjeWyNeZQpaFjYoRH59hfs3huotmsa5MqNx2f6zfNVw3weropoMUHnlRp7V7PvX+u8YqUnjaqAuN1XmI2e+p8xSB4AJguMJ2nhDvf+c6l6bx8+fI5y+92t7vNPv/JT35S7L///mu91378zzzzzPK5CQAAqP+uqRNmz5/whCdM1OmKwjclhiUyusJnPdY1Ihx7oy4DVs/9XEESvsqyjYIqt3SUN9ziujKFfYSsHn20sI9+9eWq7bUylhXEIdHTllQ0eIwMjxnYufNLeXwprRiM0SQUJbB9drC+F2bE+0wOfZY+zz5LmeH2qEzpWK5N0dB+fyIya2Uge1NZ+ydhqGscBwJ0XDFgIIrOJmO3F3zkesxuTpU1y1kvfo8sOO+aa66Z/cwufysBAGB0oKcBBs9WW21VGs3qA++yyy7FYYcdNjGn3mdD1rWUmdUrMgpzspIxb9rTpKP16CtUSVP7R59hGzVz6nOq9LXQ9fS6TlrTZ67qHpHRatg+2T0hPd1UDayOVGnmHB1dNYVW07VIJTXUBTFL30o/+4oICmqPFbhixrZ0tDfyU8fUlPQhTV/3PdW1qprqyxvV1lIatk5f94O/R+s0dFtdbfh9tOlMvJ62/wkAMH1gOk8J97rXvYozzjijLFPhuf/9718O1FsH6GMf+1jx4he/uNh6663nrPP+97+/OP/888t/fhZlOire+MY3lg1gnBnHElMxorZOCHcpfnMjqadF/NaVesp93vX7qiJ2dQ9URfD2ikxJmcG+zJMEjy91JZHhTdXUNm1bEsPW7HUv9000cpueN/09JaaiwJOw8pnc9rzXaGP//bXMbf86liz3x+yjwTXI4AWr4ed80vdX2zA0iNB0jg0J8KZ1Y/UCZUp7ce23GUuj+WV6TM0L7qPO43XqN9PdB0rEUoMEywAATAeTrqfR0jAJjOvUR77aU13rMtjQB5nOh8DsXjTwoPW3N3S9tki1LoiBxj7j2PD7orLROdnuFiDsdXSvBnNVFYBedLTXl776WNTRKU3tSzi3/c1QELvO4erVqxuzzH2GdV1gdcwUj9O52d81FtB0nn3AfZvfCbu+2odY/l/b8+MH/rfNV4Oze8sHzMc5s1PjIP3g79+op7saqwKA8WL83BPoiQMPPLD4+Mc/Xixbtqw477zzyohRw+b/ePzjH198/vOfL6OJ7nOf+xSveMUrirvf/e7lYPaJJ55YfPrTn57dzpOf/GSuAMCY4DuIdUZyVyJoXOZ3GobA7OV9o4qirzOVuzSTqwSwb7ae7ZvPlLb/JfY8ClUTu14o6jOsooZvFn3cr6D1paXGhZjhrUdFUavEuI+qttZ2MEsCXe/z8zXFUvVRtNv+pOZ58tHfXozKVI8BDb1EQOfMXxXng/bNBHcv50nmvZrP/ve/qdHQ1utLL720jMzWMdk+2ntf/epXj909CAAA+aCnAaYL329tal1qvRwdneqXd8m46eh+MzDbon5/VUD2IM3kpmb4IG17vO6662Yrgvl5eTW3ste8KlFvzcpLK5O3Xx3dT2nmQeADAqRHFZjs5622c2h6TmMSqSDt3CQOP24hbVo3BiZd63WrqodGPR21ZSxf3rY6VyoQPUdDexO7l2ti+5yqnueD5KsCxPU9ND199dVXzx6fTY9G1VWA6QPTeUp49KMfXXZI7Af8K1/5Sjn4Kd75zncW3/ve98pB0ksuuaT4t3/7t+Q27n3vexfPfe5zh7jXAPOTHCNZWXtdkcpKTpk7RpVQVMd4zZo1AxWm04w66k3i12cIV83Zo2zgVNO6mgNZJZIVGevnElLp5JQAtf2QGSphZ0JCkdR12HZlKksY27JpRoZ8NDV9GXN/j+u7aHNRCf990/3iDc6YIeyjhrVuFKY+87xJwOZGNas0mN/v2HQfa9/jXFD+eH1mc/w+ROM+tU9efPtji6JX+17VmpDIFrZNE8r22It4BwCA8QA9DTAZ+EzGphLXgw7M9kGbvk9epYGtH2l98kEavNOsp1NmcpWmFlV9fplvWqeqdLPXzv65dLUeq4xcTYUkg9QeDXuPmcZV2Da8jramSlbTTCpA2L/2Adp2LnRulixZMrtcOjaWya4qYe3HPlLaOFbVyjWG9bcqpD31nY362X+/tY/af69bZZrbvZWjp1NB7v63w39uapzK62Zv1PtjqsOuqf+OWsCANQCYLjCdJ4zjjz++OPzww9eKArIB6y984QvlXIPbb7/9nL/Z6x//+MdlxvMFF1yQ3K7N9fylL32JAVOADjJTU81HAHqhaETDNYrGlJGjdWUWe6EbywGpA+jL8w472ngSaBsJ7COIFUmv+yB29L3o8aWZZMKmRG6dCVZVjk1iuCqztQ7bP0UNq+NvwjgHE9sxg3kcS9H3iwzcKhHcVB7LE4WqoRJ6dj59hLK+z34uJF9+TMt0z2h7cY4t/zz1t7h/KcO3ygiuWx6NX788it743VLzr3Oj8Kve75f1UrYthV1/TGcAgPEHPQ0wntRpad/39iZPk2Y2Uqasmp+exmtqv9yXrlW1omk3d3uhVx2tZT6bNT5PBWb7KZpin76pEpbPJK7KSFdgdi52P+j+UDNdnVPFyu6xGKyt45omZI5WaWlrueNUKXM3Zvn6sTFfwjxqaK+FFVjtDeccHR2refkAiUHp6SodX6WfowZuokqXx0DyLqrOdTl1AQCMB9M3IjzlPPOZzyxe+tKXlsbzM57xjLIMmDjssMMq37f33nsX55xzTvHVr361OOmkk8pyFvaPwcpwH3roocUjHvGIIR0BwORinbkVK1bMyfr99re/PRtxWWUMtxWkqTKzqbLHTfM7yQgdN3op9dRriai2cw61iaT3ZYSqOskyl42ccsC2P03it4tybJov2Dc/Z1QVdjy+pJfE8bTMNaaSXV4EKyPBBg2UqZxTBis2H5nsM9D999rvh0pX1QW3xAj/mN0R1009+ue6pyViI/E3zT/6QR6foR+/W7rH67Le/WBijCCPA4XaZl32clMQh/89aGpV2Lmry1YAAIDxAD0NMDpWrVpV9qnVt7P+0ze/+c05ZWZTrQ0yFHOmbWkySpoyFUdBzMQdBx1d10eOOsM301hNJc5ztIOnLiDba69+TDK7J5S97A3mnHslNd1U22mDxhW7hikzWWa8xs16rb7lEy3iNFLepNdvS2r//LzZKU3cz990vHod7+nU+KB+46JerdOvcewgdZwpLa3vWeoz4+9KlcauIhXc3UZPYzoDTB+YzhOIlba1eZit3fGOdyzN56c//enFXe5yl9r3WYfriCOOKBsAtMc6ZlZG1X8XrWx9Ljlz/PjM5H7pRVQOQ5iOU5StF7opU7mrzq8de5P4VZZr12iOI99yghHsWsWIa3ve1f05CLyoSkUx+1Lhdl6s+edVIrgOiVcjJcb0fi9wU0ZxlSkc3yNSAjBV3iq3SbT3QlU1htwSgZEmg7dJUMdlnhwxXSW8Dc0XFs99myx3AAAYLehpgNFg/W4znv3r1atX9xSYXTdvaVeMm45uMn6GiUy2VED2IObLbqrw1YWZnMI0nDeXVQ0s57g03ZRv41wZyeunlJZWCWfNo+y1tOanThnITehzvO7S++y1dGNV4HQqqFqJAXFdvz9ttHKqaf/0qMz7Xs99Lzo6FZhj+5Y7rhS1s6/gl9Lrubq5yrC2R5/woHEITGeA6QPTecKwDoof2LzwwguLY445pmwPeMADysjtJz7xiXPmhwSAbkh13NRJ8nP8RCGkv9eJyUEI0/mIxEiT+O0qA9ybyXWG8jAyge3YUwZzTgfejiMK4kGX9KoSs70uU+lrXXedC5nM9lhXxipVwiqWrfJC3D9v+r71I2D9XFOp9caBfvanX8O6H0EdI+ubshPst1xTJOj31r7fW2655bz9zQUAmDTQ0wCjI9Vf8tmKeh7nz5WeGodKWNNOqoJSSlMPykxO6epBmMl10035FitPjct0U9IwXWlpZQfr+nstLT2tv6c0c1NpaI1JpIKEjabr209wtebgThmg40I/43j9GNb9BHunAr+bjtGuhUxt/dYuWLCgbAAwXWA6TxjLly8v527+zGc+U/zqV78ql6mzd/rpp5ftZS97WfFP//RPZQb0QQcdNFb/SAEmnR122GG2Y2bVBZ7ylKfwHRuBmVwlfgdlJleZyqMqK23nI0ZcD6qkl5/PqB8xq0hjn12eyvatygDWexVVrWhqX77Li9xeytqr9HWqSQhq0KONgcz/4cEZ1jHrxWe++Hnu/bXzy+NApx/I8Pun78HXvva1si+m+8tKau+3336l8QwAAOMPehpgdGy++ebFwoULZ/vcpqef/OQnc0nGYM7srs3k3DmTR6WThjndVJdB1tLDOfo5PnodLS0tPW3Nm8U54woeXz65bm50LdN7dE5zNDUMxrBOVYvwGttfT11HaWkfLBQrN/rrZst0D0tPi5122qnYfffdubwAUwam84SxZMmS4sUvfnHZzj333LLE9uc+97ky41mdQ+s8fPGLXyzbHe5wh+JpT3taaUDf7W53G/XuA0w8JiiEOlzQrZmcEr9dmcmKrmyKqB6nOYqtcx7NZWupAQEfdWodeol9E8bWJO4lXK2c3cqVK2fFpwSnb35eorZzB8f16wYxmuZGTr03GrtqKlvmBVjKSPYiCkHbHfqe+RazVar+FpfVrdvPd1XfkZjR7ufjUvO/SQrS0PvH6bcCAACaQU8DjA5pLoGW7h8F9lZV+NLfujSTc6aNGqdrmzvdVKoSkmlolU2245IOsPVsuzZdg+Ytjhpaxm5TKeicuYPjVEsp6rR0lYmcMnd90K5fFvWzf50yGqF3/HesrUZus24/gR92T0Ud7X+PvJbWo303VFXPl1UHgOkD03mC2XXXXWdLa59yyimlAf3Vr361NBHUobzsssuKd7/73WXbe++9y/LbNqfzFltsMerdB4ApRnPBNInfLs3kJuFrfxsngygVvWzn5Lrrrit/x22+cJvzzJ4rmjkaYDEqPUa5SgjUmcRto5h7QZmiVaWU1bzgTYndqmjnVFS1f42Qmfsd6VKoptYdxTn3JnLMsE+9rlsnhSK9FcChe9aOGQAAJhP0NACMK34+2jpTuSst583kOl09LroqVV7aHs0ENj1tWtp09LXXXlsGbPtzmHr05YZ9pSOvnasM42Gg815XKtlrZp+VqmVVlbj8+qlHnZP5TmpavUHp6VGc71wd3aSrUwEumvPamiXyyHT29y0ATBeYzlPCAQccULaPfOQjZakKK7/94x//eM4P/u9+97uyvepVryoOPvjg4sgjjywOOeSQgc4zAgDThYRXk/i11qVR1iR+Bz1fksxbX44qPo9lnxXd7EtZ+YhPrWsi2L8vp5xVVfnnLmhTOtq3KHzjPD9+222pM5QnXQTnGsH9itpRlq/LLd3eq0ncSzn1UZYxAwCA8QM9DQCjMJOrdPWgzOQqXT1IneADoU33an5g6WCvhb229qWf9V6vp6WlvTbPmWrJBzh7TdkFOWWiU/MTG1FHx0pgfvtt9jeWvk49Tiq274MyfuPycTxPvhR7v8HXw0bnc9g6HgCGA27jlGHRQjbHrDWbI+Gzn/1saUD/8Y9/nP0ht87ZiSeeWLalS5eW61r57X322WfUuw8AY2Im1xnKgzCTq8Rvk5ms/VZZK28Ee/Hp/5YSsbGcbmw55azqqOro55AqZaVzmCNg27aq81wnaKrKX+cwjpHVimJua/y2NYnH0QjOIXUv9BIVPQpxm8Lfc3HOqvja+k2WPcEcYwAA0wl6GgC6NJOjru6q/2v90qYqX5qbtQ6VifbaOOrp2Py8wl5re2NYz31GcK/HHisaqeWQmmapH62cayCnznMMtrXz4udw7pVxq/pVN9VSl9nB4zYtWi+B1/0GX4+DYasgjiYdrWaVV6Wnda8CwPSB6TzF2HzOltVs7fe//31ZfvuEE04oLr/88tl/TFdddVXx4Q9/uGx77rlnWX7b1geA6SFH/HZpJntxq3I5itQ1JKpUNtoLWglWPwdSXXSzF+7+M0ZJnNtGYsALVG+m+qZIdP9YJ4oHKXzi635FSJWxnHssfmClS+M3itpxjWLu+hr3ahJPqrite90Gm4OKktoAAPMD9DQAWP83Z87kLs3klFEYpyiyz7TS0an5hNsEWatvPy5aOhrMMqtjaWgfvOunZ4pa2uvNuhLT/e6zz0hOlf3u59x2UfXLT7U0yLLQ9jit01t1VaFrnAKv+9XRvVxrK6+NngaYfjCd5wn3ute9ymZzO//gBz8oDehvfetbZedUnZ8///nPxdFHH43pDDAh5M6ZrO+4RFtqHqLUfL+xjLbvLHtTVc+1vp8Tqa6NK20im1PCw5DQ1fYi1lHXHLFqg8zorRPA/URWq5yVzc2juW5NRNhrM+c0X08XonYajeAc2kRBI24BAAAGA3oaYDrN5KYqX9J3cX7flH6O+lp/M9NXmlkByj5QWev57Wgf/eMk6Ok22cFGNOsUrC0dmNLHvjy2b4PS0qmqX1Ff93o97Dg11630tOlo6WoZdP3q6UmtsDWIwOtedfU4fOdi0EE/pjEAwCDBdJ5n2D+WRz/60WVbtWpV8epXv7r4+Mc/PpuJCADDRVHKErrWrr/++nJuInv0zzVfkZre50VqzAKuEsxRqMYsXC0zxnXO3GGXl46DAamI5VTnPWUwd93JjwZyLE0d5/KKGdWpZXo0wbvZZpuV4tceFyxYUD63RxPBCJb0/dKvSTxt4nbS5wsDAAAw0NMA44M0mtfTppNt6iXTzmrS0mpeS8dgazVfGlrrRB2txzpd6vX1uDHM8tLRXE+V206dp2EYzNGY9NpH108GbkpH63Xqb/Y+08zS06ah7blalbE+3+mqQte4ZRX3m1nMvQIAkwKm8zzkkksumZ3r+S9/+Qv/tAAyMHFqgRrR2PvpT386R+R689ibvxLAtp04F1KqdG1K0Oa89shw9I9RPA2r09qVgB1Ueek6g7nNfM4pQaz977UstD1PlQHz90CqhFgufh8swjpGTY/rIMkgQNyubRIjbgEAAOaCngZo38deuXJlcc0118wpQ2ya5aSTTsrS06abZRj7KZp8CeYYtNlGU6cCPaWfo672Ab7Doovg6kGVl04ZuE0GcwoFS8dgbZ3zXstCK0g6jiH4ffLmcZvrqimgUlraXtv25gu+NHq/unociNOC9WMaAwDMN+bPf795jkV2fuUrXymNZjPJfOdKnWuLujvssMNGuJcA48sFF1xQzo3uBelFF11Ufreq5mmRuEqZyf1QZSbH573Sr4AdlqDtgjivsl0bW2ZRx03ZwfabuXDhwtm2aNGi2fJXUQDXRWMr2903P++WDbL0es/YZ1aZybZMhvYkM1/FbdM6iFsAAIDuQE8D9I71uW0cyoK4o542I7mq9G1qHtSu9HQqGNtr6V41UlfB1cMItu4CP2eyX1ZXSUvVtCzr15rpaHs0TV1lKNdpmxioEOew7kfn2T6nzORoaE8yXVXoGoesYn2Pu6jQNc7fOwCAcQfTeYqxjviPf/zj0mj++te/XgplLRf2T3T//fcvjjzyyOIJT3hC2dEDgLWxjqd9d6xUl75H1rk2odwVdQZyykzuSsCOm6D10cK9ZgenXhu+DHluBrOdEzOTzWRWs9e5pp7dJyrhlhLBmrOrF2wf6kSw5pWeVnGbKnE+ruI2V/COw3cQAAAA0NMAXRuTKlmt/rv15S+++OLOPidHS9fp6UGWlx4WCjpumuO3zXzACqKWfrbrJi2bgwK2fZM+b8LuFW8qRy1trR+zMxWYPQlVv3zgdb+6ehyIwdO96upxvV4AAPMNTOcp5Oyzzy6OP/744vOf/3xx6aWXlsvioPwuu+xSPOMZzyjbzjvvPKI9BZg8oZyqEtBELMGV6hh7w6mNgTwsNI9Rv8Zvzrr9CgW7LiZGNSe2tauuuipLUNlne2NZj3Xn2s+lHUWwyqf3ion7OhE87HJd/Ypbv2zcxW2bqGjELQAAwPSAngboFulhlV5uq6dTujnVHx/nalx1OrhLk7iL+Y5Nq3ktbYH3FkSdg+nVaDDXaVa7B6p0dFdVv6oqf1kbdpBAVxW6xiXwuqsKXaMO1gAAgG7BdJ4SrrjiitJkNrP5rLPOKpfFToiVrLFsZstq3m+//Ua0pwCTicomeQPYRJ1VB/CdZc0B5DvUgzKIvYjq2viNy8a1bJT9zllJNhPDerSWE+1sxxQFsYnReK00h1hVya5+Iqt1vqvKX3dhZmpwp60pnHo9TuK23/mVELcAAAAg0NMAg8XPj6w+vWkeG6dKmVTD6LPHAN+us4N9oPC4mmqmdb3BbC03g9kHaUtPx3ED05Km0+umkuo3ML6q8ldXVb/8lGn9Bl+PA11V6CLwGgAAqsB0nmCso/aNb3yjNJp/9KMfzWaOeVPAOgEPf/jDS6PZ5mu2eVMAoD0STzbXr2Gi0QTytttuu9a6daK0S5NYhvZ8QYLVC2J7nWOEVpX0UmS1NYvgvvrqq9cymPuJrLbPrSt/XXf9NC94PybxOInbfk1ixC0AAAB0CXoaYHjI4DV9JA1kenqbbbZJTrXUtfEb17XH+Waa2W9e1NM5pm/ddFO+6pdVF4taOmc6qyrsXqjT0k0Z1L1W5Iqvxy3wul9dDQAAMGgwnSeQn/3sZ6XR/NWvfrVYtWpVuSx2gvbcc8/SaH7a055WbLfddiPaU4DpYYsttii/V974utOd7lS84hWvWGuuo/lkBA+KWNLLWpuSXhLFFmhj10Qlt034mrF8+eWXt5qHqqnkeIxk132Sioq+7rrrELcAAAAAIwI9DTB87nnPexZLly5dS0+/8pWvnKOn55sRPAhS001ZazvdlDWZ89LOZlpfe+21s9q6i6pf3kyWlpahHA1gGxOwYPEmI3mcAq+7CL5mjAkAACYJTOcJw+ZivvDCC2c7ktbxkOFsHfgjjjiiNJvvc5/7jHhPAaYLE1xbbbXVnGWLFy8utt5665Ht07Rg0dUx4tpEbK5QVflvCVQTmfZ+M3dzI6u9OayoaB9NrG3HjFtbT+IbcQsAAAAw3qCnAUaDVQgzzeSxTGcL7oZuppvy1cByp5synasmc9P0rRnLV155ZVaWr6Zz8lM62bJYstlPRabgAlvfTGRLqNH7Ro20fheZxQAAAPMRTOcJ44ILLphjNFun7eCDDy6N5kMOOaSzOUsAAAaBCdgYcV1X0stMY/u7PUahar+FEtgSt77FZfG1vV/zcFuTgW3NMqSjSFTU9DiLWy/gAQAAAGAu6GkAmC/TTdn6pqWlt2MwtS23YO0m3RyDs7XMb880tC+hHivA2Xv7mb85h67KT5NVDAAA0B+YzhOIddb23nvv0mh+ylOeUmy55Zaj3iUAgLWw0ldREJt5LJHq538ysavms5MlXE38SeT6xzokdr2R7I3lrszZLkxixC0AAADAcEBPA8CkTjfljV+Zxqan7W/S1j7AWpo4Tv3UlAmt91Zp6br5lNvgM5/7NY0BAABgPMB0njD+9V//tTSb99prr1HvCgDMIyRuU3MnqSSWlbO2RzWJYC+GrZmpbE0lrOM8TiZifXRxat5l+7sXvZr/yS+ri1DuVdzGZYhbgOlCATHxN07NSg3ab53K/1FhBgBgskBPA8AoqJuD2AxjaWkzl+25LTMd7QO0lbUsPW3vlxaWlpaebqrWpezkqlZXGlqGdhfB12QVA0znuKFa1NbXXHNNsXr16nJdawsXLhz1bgPAAMB0njDe9a53jXoXAGBKxG3ua59VbH8zwassZhPEmjs5tihuTViaGLYo6ZQgrjKVZShLTNv77dGX2m4reBG3APND5FaJ3arWVEHBBLKfj5DfEgCAyQI9DQC99i370dXCTGPT0taflNFsr9VX9aay75dKH5sO3mSTTcrHuupdMSBbutrea3ral9luG3xN4DXA/AzAbtLWOXPJK6hGjMM87gDQPZjOAABTJm79sn6wqGozWCSG7dGMZh9ZXYWJ2E033XTWJJbRrHmLTfRKLOvv1iSCbTniFmB+4X/LehG7OSK3axDJAAAAAONFFyZxTjBiHbYt086mp01L61GVv+q2r2pgpom9Xpbhq4Bsr6O9lrbHGKBN4DXAdDOMAOxBMAoNDwCDB9MZAKADrHPm50fq1SQeZkfPOp4q0eUjrdXs7zKJ1UwAK7ravzaD2ZbZowndBQsWzIpfiWVlN2uOZgCYHyI3V+yOQuTab1jM4lCLGSDWttpqq3IAUb/5ZHoAAAAA9I+fb7jf4OthoDmVVQJbGlqa2vS1ylBLN3vDWMvstXS0HvXc62mvpZumkgKAyWMSA7AN/a5VaeqorbfeeutST+s3n+mqAKYTTGcAgEzMZPBzj1x++eXFH/7wh5F28CK+5JXvtPrnJoCtk6c5lq3JPLG2aNGiYvPNN19r2zKYrdm8K7be4sWLS0HsRbBENABMDqlBuzZid5Qit84kbjKSm36r7LhUAtF+/1etWlXO66zjtYFAAAAAAGjG+lOmPaWnly9fXpx11lkjCz6sC0ZUQKUPLFfpa9PS1j+UlrblMpVlHKdMYeuHWt/R/i4tbcHaXkdrGikAmBzmSwB2qjUFwNhvpP32axzy6quvLud11vHa7x4ATB/0ZAAAWmDzGQtFNnfd0cudkzh2Xu3RG8nWibP91RzMarauJ0YWqpyXjGUJYmsmkomsBhgvlHXbz/xL4yZyc8Vul1keURDbo59vyrDfU2+wx99TAAAAAEhj/SbrbwlN29QvTXMQp17HvrOqgElLa7nX0TKaPbZNM4rj/my22WZzArUtqNuWUfULYPwgALubcygt7fV01Mv2O+vHHtDTANMJpjMAQCZmblhTB8kEprJ625rGTaaJBLmaGR2KDFc0tUcGcxTFKSNJprKZx9ZMJMtUVrNllOwCGJ3IbZNtPCqhlhrca5NtPKqKCLmCuApVhbBjoBwYAAAAQB5eXyr40HRnrzparyOmgb2BLJ0cK315rM8dtXRVgLn1/6w/Kz0dzWXLXmY6KYDhQAD28NH4pNfTPkGnCf8bTpVEgOkE0xkAoAVLly6dNZ+322674u53v3tP509ZydYx8+JXy+rMDxPI3mDWcxnMMkJM7GrOKAliy1Q2Qay5oqzFyGwAaEcvJrFfb1TlBHstST2ILONBYb+PJoJtbj0rj+0NZpVB8+UTfbPl9rvpf0M1qKHsGAAAAADIQ3MVS09vu+22xV577dX69Fl/TBVqoo5WgHZd/9r+Hg1m9es0z7L1+ywz2RvM1ic0LW3L/dzLmCYAgwnAztXXo2BSA7DboOn5NGe95q23a6LrVqeplajjNbW2q+tmv6MAMH1gOgMAtCC3Y2hCNhrK/nXu/KfWEYsZzPZeH1ltEdVbbrnlrMGsfbTn3ly2RlYeQDuRmyN2x0Xktp1/aZzx8+f5x6rn9ptrIthMZZnMJpDtuuWY+qr6YM0GDy1Ax35Do7EeX4/D/IMAAAAAk4DM5iZi1a+opdtMcRWDte39vvKX9fvMSNZrzafs52f2BvMkBF0CDJNeTGICsAeLAqWjZq7S1DKXvZZW9rJtq0nz2u+i6WfpabWc+enR0wDTCaYzAECPHTjrgF111VXJjOVeOk7W8VaWs7LolGlnHTbLXK6aT9k6eF4M22NOBw9g0uknIjrXkBwEvUZEj2uWcZWwbRK5VcuqrosyWzRfvQYScwcfoyDW8zoTXga/j9TW+ed3FgAAAKAdyoIzk+Pyyy9fy2DupZqMppuyPqH6lLYd68NZ/80Cta3fluq72ToxWJvppmA+YN+btiYxAdiDITfYOmdZXZKLxh2jns4dF1EFRW8up4K1hS33AfO2rjX/dwCYPnAkAAAysQ7ctddeO5vZaObuBRdc0Or8ybTQ9qLBbAK3rtMlwyRGXI971iJACpVg6iUielyzjHON5HGgH2M4/j23ekMbehXEyqKJv5VWCtGW2bXx19Cbyn6Z9sFXrrC/+dJhk1AWDQAAAGAcsLKsvi9n/bNly5a12oaykf10J2oyQ5reH4O1mW4KJpX5EoAd1xsHo9Jrwi409SD2z/Srqjyo5QRra5oBr6Pt99IeVV0xpZ/jXM26z6Sl7dG27QPNx+FaAkD3YDoDAGSiTlMdPnJPEX+KHpV5YWVqYvR2KuI6VdLLRDQmB4wL/URES2iMgn5KUo9y/qW2wrbp7+OCHZf9Nuo30k9D4AWtVXuw8ocSsWp27exvJoLVcoJx7BzEko2+akUqy0Ylu8Wo7mEAAACASaTO5DLzQXN/Sktbf07zh/q5mP12qoI6mW4KxplJDcCWIdlPEPao6CLYWsvGqSy07g9NPyBNrSxjazaWKI0c9bQtl562R3vdFIwjDS8N7acwqKsAqeqOAj0NMJ1gOgMAtOxcG9ZRW7hwYbHjjjvOimITyDKV1az8do4YUEkvbzJbp5CoPxiGyO1V7I4C+070U5Z62CK3y+jncRK2ug510c2pZXYMJkij2RvLbFVhv7X6rVSrEsSaBiGayXqeW7pRmTTKprFrIQEPAAAAAHnEIE4LJtx5553nlGf184quXLmy7LflkKoGxjQoMEimKQC7TRD2MDWQH7PoQlOPE3WauUpT26Ofakr6VttrMoptHY05ej2duqbRVI5aOndaQV1DPep7YZ9pv/njNMYBAN2B6QwA0IIlS5aUj9YxUuds1apVpSg2gZzTkfVlavycUQBt8AZYL2J33ERurtgdtMiVudhVRvE4kWsM5wjfpoAYmcv6bVTLnXvZB+JUCWKZyjbtgRff9pl6HkVuzqNt199zNghq96UFFun4BYFBAAAAAHmoP2dYv8v6VtZfu/rqq8v+W27ZV23H62mCAaENBGAPBmmprjKKx8mQ9MHvXWjqJuz3UEE4a9asKZ+3mXtZmc1eU/sgb5nKtn1vJku3KyPZB2DnNkNTWtnvvG8xEYDfboDpBNMZACAT63CpNLY9N6P4wgsvrH0PJb0gV+S2yTYelQDzQquXbGNFs45C2OYK33EStip31asx3FbY9orEqjeXcwWxrWP3h4liX0rRlqmEolWMMNEr8atH+3sUuLnXzwtfVapQOUf77Kr7NJ7HcbpfAAAAAMYZ68Op2oz128wEueyyyyrXT003Za8J+gMCsAcTdN2Fph4nugi2zg267hU7Z6Z5ZTBLT+dU5dKcyKZn1VRBzP5mmtkMa9PT0tAqg22PfgykzViInRP7DNPP0vLRWK4inkf0NMB0gukMAJCJdY6sY9ZU9tU3SnpNJ15g9ZJtPCoxpvlve8027sq4rBK2vYjccRe2/YjccRtQU+DN6tWrS/FqTZHRORHPdjwSwRKjtsy2u2LFitk5qDQflS3vFQlgfVauqayy2VXlzGyOK/ttt/UosQ0AAACQj/p4dVVuvLnMdFPTCQHY/Z+/fozh+PdxDbruV1OPYwatjSded911pY62R00lkJtB7IOmNWZjy63yl+ZyVkls+73t9doqQ1naOWrqOlO5TkvbI3oaYH6A6QwAkIk6SSq9utlmm5VzOksU13W8YDJEbq6RPC5Zxm2yjfuJzpWwlRHYb/TzuAnbrqKfx03YVmWA5zwqwlqlvFSyOgeZyzJ+VVrLrrvdQ5rTuQtTWRnSmtvZXkuENwne1KOuoe2rfgf8owKJdB8TWAQAAACQh/pNCoRduHBhscsuuzDd1JQHYMf15mMAtjKzu8goHqegax+w24WmHqeg67qKak2Pdq2lo72ezr12dg9K00rX2rmx7ZqWtin+ujKVvYa2R+nrXrW0rqH/7ns9rXFTjasx1SDAdILpDADQgsWLF892pGx+56233przN2S86Ool23iUIreNSRzXaStyvfCJZnGOMTwNwjZH+I6LsO1H1FY95mDrav5jE7Aqt5VzzbVOvEft0b5v0aRWdrDWNzGr1/HRi141ZbwoyCfn+vnSe/5Rc1Sl/qYBIV0Xv3z58uXFypUrZ01nzUsIAAAAAPWo/Kv6jKatTVPDeAVgN+nr+RCArfMkLSE93aumHie6nL5pnIKuu9bSufe55kP2ejpnfnrDPsefSzXbBzOp4z54zWy/pVVaWsHZKS1tSTO+6lgdXgv7R6+lU3ranz87FlUzs2ZTKli5b41/oKcBphNMZwCAFpDN3J2x1ktZ6nEUubliN7dD78VpW7O4reE4LPo1hsdR2I5K1PZDL4JY+2aPPnPZrofKa0WRXNeEymz7eZz9HFTx++J/D2y/q8RtFL5151XrVjU7N/HaWGlxP80Cmc4AAAAAeYxLP37aArDbaOtpDsBOaWJNA9RWU49TZS6NRXShqccl6HpUAdf9ILM16umqe0XTSElLK7vY39t+6qeUeewf/bWz51FD+8c4bhnH4HJMYz1WoYAMr51Tmjr+5ljmtw9OH7exKwDoBkxnAADoW+S2EbujwAuvXsRulcitEqzW4TYB0qZU1jgL235F7qiZRFHbTwa4Ha+fz0nNkGi1uZSs+XtS31/7u8xlldpKGcF1aK6paCbrvvAiVQNCVnasSvi2oclMVquKHNd5tGPXa/0WWBlIizpX1rYdEwAAAABAEwRgr30+qvSx6YK2GcXjRC+auerv42AST2LAdVt8oLRMVNOo9iiTVn83DWhaUVXhYvl4ZRJrvZQR3LQvVWaythNNY5sjuioYu02wiaaZqjKRtTy1TX/f+rmn/XKrcCE9PU5JBQDQLZjOAADziF4jokdtjPYaER2FWkrY+ue+7G5ORvE40VX08zgIW4m3roTtuF0rQwKrKgI951HzOina2sSbDdAoe9m+D3bPW7N1leksQ9rOj0SwtUWLFmUJYjufMmL9o983fZ8s+EICuN/BIC+eq0SwDOoobr3oT/0tFVyiTG7Nd2WP2267bfkZcc4qAAAAAJhuCMCeG3Sdem599FyzeJyMR1/ZrAtNPUrmW8B1P492rnzmsmlpBTzIOBWmpaVvpad9kLaVrbbn9p46jSh9roph0qYxG13a1vYtlqzuBZnJTdnJ9jkpnWyPVgrbAtdTf4vjSDp/sZ166qnl56KnAaYbTGcAgAlBncQ2JnFsoyBl7jSZxL4Dq7JETSZwTinqcRe2bYzh+HxUzAdRa1Rdi14eezEr7XstEWxNBrOJUAlgRWKr+QxhE3gSxJatqyxenXcvan0UdzS5fXS1tq8s6i7M5FiKS6Jc311ffcCe+4hvf37rsPfJRI5Ny1XmLLLZZpuR3QwAAAAwgUx7AHZqPevP1mUU67lpgJwqXeNEF8HWXueMivmURdylnm6DnROZyhYQ7fW0rxAWM5x1Lu3+0NzIpqWVfWz43wvbpsYz4v76Zt9TvSd3/ue6Y9NvlTeRdS9IU/t9UrPjiUHkTUETtl7UzqlWtR0zrr2ZDwDTCaYzAMCQ6MUk9uuMUuTmmsQSbF4EpOYq9pnFTWbxONGvMTwOwpYs4sGL2n7wgthE66pVq4prrrlmVhB7Y1m/C36AQVHTKo+tCGqfFS1TWX+XYJSJq/f0S9wvL3j13P7uzWwTob1+R/zx1IlgspMBAAAAJotpDMBO6WsfnKrHOrM4aun493EyIL3x2IWmHgUEXA8n4Lof7DdAhvLq1auLa6+9tnz0OtqbynF8xPbbl8eWIStT2UxrrRf1prS0vadf/Dha1NA+OFv7IjNYerrtd0RTR9UFZteZyQAAHkxnAIBMfIfUnlsndsWKFdlidxRobtY6oes7pF4MNIlcleeNf58EYduLyB2FsO1a1I7b9RFdRTzHgZpxx8SuiWAzlq+++urSXLbXZjpbs79741YmsxfEPmtXcyYZEstVre39rPMr0a2AEP8YhbEM8H7RsaREsF82KdcdAAAAYD7i9Yg1M3CuuOKKiQnArgrCjiZxKgA76jLT0tbfjybxOAVdp0oY96OpR9FXJ+B6vAOu+8G+WzKVrZmWNk29Zs2a2XLZqfEQn9ygoGWvp3Wv+oDmWCmrF1NZvx2aAsuI5nHU01q/H+xYcgKzuzDKAQAEvygAAJlYp2/lypWzr6+66qriwgsvHOj5qzOKq0ziKOZS2cWTIGy7iH4etrBF1E6vqM3FD44pytqa/XaYEDaDWc0CV3KCNewcmThUM1Foc0bJZE4Jx6rz6gfMvPDV8ih4feBDqmx3Cvve5Xz3UsZ4m2MZNL7suJpFtttAhgYHEOcAAAAAeVgfyowgYf3jiy++eOgB2FFL+75mXZax+sPRLB4negmsrtLUw+6Dz6cs4vkYcN22ooGqdKn6l4K07bmZzdY0h3jdmJZ+B0xnqiy2ParMs7KZc0xl/5uS0tN1RrK0tB1PUxBNznfPH1edph6VXvVlv32z62b/C3TdFi1aNJL9A4DBgukMAJBJ2868LxmrDqjMmCazOCVyVTpr3MRTF6WmRyFsySJG1NbdG9E89gEbejTRaMaxDTyZeJQoNiFly01MSVzmZGf4KGQTwTZ/sJnL9pgSklHkVglgfa+0737eZ/tdsf3PMZNzUWmvpvJcw/y+pwxkfz2r5pSO2ECHXWNhAxYAAAAA0Ezbvl9VNnFdALb1uf1y36fXvMXjFnTdRbD1KAxIAq4JuK67N1IaOi5ThS/TzmoqYa2MZVX/ykHB2qbRTEOr+eDtlJZu0tN+jMCX6bZm+2j7a8u7qsiQE5ht+zWs73uVgdykq1NYVrrX0+P0ewwA3YHpDADQAouqlGlsxpKVA/OdUxkpWiaRO04ljXOEba7wHaawRdQiavuNlM4RvnrU+72g9EatNZnKet1GENtvxYIFC8rIXmuLFy8um4liM5xNWFYZygpi0fHFfdP8z751aSY3iWDt3zAN5CYRPCgxi0gGAAAAyMP6qKanFWxsRo1NV6U+poIl1d9VlqD1b8eJLoKto5k+aAi4JuC6F3K1c/ybxr+03M+jrKbgba+lc3WrfW8sONv09Oabbz6rp+1x4403LvV0naGs753mRY/a2UxR/7orzVeVmew19TDM5LbmcVfB6SnQ0wDTCaYzAEBLoSasg2wltttmPMdytqllMQq8VxGb+vswhK2f/7qr8ljjZNwLSmMNB28y5ohcPTYJGJm2KaGpzF+tYxHM3mD2glgDZxoo8xHWJnoXLlxYLFmypBTCS5cuLbbYYotSJNdle3hx7g1uL9i7mt/OZ1jXieBBmMnRQG4yjwdpIPsyZb75AQu7fjZAqiybaSsPDwAAADAo4vROZjpdeeWVje/zQd05ujpqXq/Hu8goHgYEXBNwPYgs1bbB2E34stFeo+q57uNoLPtgba+rTD/reyc9rUBt09PWTI+Z0VxnzmredDVV9oqtqyqCfv7nOl09iLG4ttW8BmkgG147p3S1jYXY2Iau+zSVhweA/wPTGQCgBdZJiuZzCt9xjs0LVb8tiQF1stVR1bytTa0f82M+iNqqDO9+HqH3ktVtoqZ7NVajqRwN5rhtu0dS+2ToupvolZAyQ9mavqsWUR0zlu3vXkjJTDbjMgp03+Ix67Vfnlrm/yYz2f9O+HJiMTO5ats6F037kDKQdZ6bDOSmY6l7Xnf8fvDRZ87UNb897acFHdhyE8gqB8aczgAAAAD5SA9rvtOcddUHV78uGhW+Lyk9KvPK+rl6rDNC1HqFgGuyiIeB7u+2wdj9GKveVJZujaaysO+k147+8/U91hRS9lpaWt9R06i+Cpita81/N2Umq6R13LcqM7lJQ1bpSf1uSD97Da3lfmwotW3bZ9tfP5991T5orCB1Pat0de6x1K1X9Z5UwI8PyPHVKfSo+0DHrmADLVPpdP3drjUATB+YzgAAmVgn6g53uMNsee2dd965eNSjHjWbhSuxWTffSVvzTB00T/wcPWofJcL1qObnvlLz2xo3yCLOF0f9LGv7HpWcjuJWy1Ji15u3OfuTu19e1EqESfzqu1EV+JESb8pe9gLTi0svOr1ItkcZtyagbN7fuE967oV5nWlat9yI+1Y1eOZLhLdBwSN+sCAGDcRlg/wdiRkqXvjGkmm+NeGnQKg7Nj1fvnx5WeFC19EGTQAAAACgGctOtABO9e1MTx900EFzNGkqkDGlJ3KoyupTPze2lJaWho7a2pve4xhw7XVP6nG+BFwPSkP3o6ulQfVYN3WQf4zBulWf12a/vJaXmewTEnwyhQ/+8AHl3oj225ceVcav9Jo9l46WlrZHBYBb9YPLLrtsjob2RmzbsYQU0pNNmtrWs3PhDeNcvIbM1dWDJBrIORUkmrKQexkzsGtr0yro+uh/AgBMF5jOAABtfjT//yhLlWBVlGYUpr5z5jvtypizDrnK9cayvf61z8asyyLuJXJTxxGjFVMRjH6Zj1zUtlNiROt6YeuFfCpi3bemY/Ed3GGIyC4M236uVdfonvRN57Pub8PaPy9oda19BoOe697RfWaiNh6nn+dY37NUGWU/95MMSy9IvZFp+3Dttdf2HFBShaoc1IngtmXyx9FAjhHSOaUSc9Hvpf2W5hyrH8SpQ1HqGlCx1k9WDAAAAMB8wmtFw/pRNg2N14Le6DW8FpD5pP5Yqnl9bY9e23hNEcnVapGcUt3xb6ltN2njlJaOy/z5TWn2eCzeNIzrTYOuHiTedE1p56q/DSvg34/HVOlomZz+Xoolq30As1V70vfM3ht1q42N+WBt7UcMFla1AzNyV69e3VNASd1x5wRmty2T7zVjTqDyMA3kXF3ddvwglTFfp6tz7mt7n0qd+/sSAKYPRsoAADKxztD5558/2ym6+uqri09+8pNzsuSiQSZDVh08/+gzjw3/2j/3HbEolPWZ/nNlxNWRMspzl0lcqBMfzbDYwfX7Bt2Tip7NEb7DEuQ+MzUOvihyOAZV+Axp7afP2E8ZfV4Qy2zUPaf70+ZRtoEtiWkvmmJ2hT7Pl4QSqe+XHxyL33e/D/574787KtnVtB1D+5sSe1XXPG7HbzuaulXrVf09p1xhzBhv2nYM3ImZ803zfAt/bHWfp3swRtP757aOXR/Nx2XPLVABAAAAAJqxDEarCKQ+98qVK4tPfOITc3Ss19Xqo8WKXXFZSld7Da7+fepR/cao4+v0tNclvejqqAfUP04ZR/q8YRhZ8xEf0NAmKHtYYxtxuqCqAAY/FqX9lTnst1UXMGvrmiGozGUdp9dxKnct4ziW8Pb7ov1LVd2K36/UmJl/7qeNivMke43tzdWq7VRpZq8xo9au2p4/r/7c5upcI1buqtPQeu7PV9Pn+Yz2aBhXlWX3Y0Wp+ahTn+e3E6u+aZnGEm3sI1aNAIDpAtMZACAT63hp7hHDnluZ1UFTJ2qtw1ZVAkwlwlLbi6I+flbs/PnsYp9F2FS+W9SV7ukiEnNY5IqHtsuMlDHss4ujoeyjk1PnKmUqVn120z6mIpRjoIF/7Z/7uZ+UbaDsA81d3Ha/fGktL7Cj2Ksqy6fBHl/Oy1rutfLYMapkWGx+eer9uq5tWhzgSIncXmlrIPcSJR7FaBSiqeuVGyCh30Rrqc+N5c4VYa3ftfhbZEEKcdnWW289Z9Ak9VkAAAAAsDZmaFm2pLDnFsg9aKpM4BhMGM3qiAzvlHmtv+sxVf1MAbfSQirZG9eP700Zjzm6etzoWkPH8+uDmKNRHJ/7oOM6/Wn4eyX195zj0/vjtYu6Kj4aXkv7yl1+7uIqQzO1X35sIWY9q8y1taoAX+luXx5bAdRV56Fu36r0s19WdT+ntGVTi6Sub6+kynY3tTbjXl2MH9RR9duhz/U62icJKGjf39d2b8RKctbOOOOMOQH9k1q6HwDqwXQGAMjEOlEypqxjZZ3rxYsXzwpPLfcdp5QR60WljEB10H1pI//3nAjJuCzXONMyb+JVCbS66N7U50WBnxL7qeU6JxIvUYSoE6vl9lyd9mi+dyVkey1DVBU9GqNMPb7EuDdDuxJBqWjaumV1QsCXuNOjL72VMgwlOOw7VIXMXC+EbWDGPkMDBCnz0t+Xtt8SwlbuS4I4ZxDGZ/RXCWAFfRip/bHz0JUAHEcDWRH0bUTvIDLsleVelcESRbA3k3O/43b9rdl7rfnpBAAAAAAgrz9Vp6ejlo4aWv22ulLUqWXaln+Mz/vRhrbcB2fHQOFUlmzUSanP82MKdbo5/s2baNLO0tXq00rfSFdLI/lz2/actAncTeHPX512Tv0taowuAnJT5Gjn1GPVebB999Os6dESHKSzUug6VmGfp2xS3Zu2XX2G4StHqakSgf8cuz9M/0hX55iz0Uyu0tX+OqUyZW2KrC6Ck8fVQG5rmg+q2oHX6qlKij5AW/eDxi5z0NiONZvD2cZmfEU8AJg++GYDAGRiHaI73/nOs4LuTne6U/Hc5z53TnmjnE5XVXS0f8xd1nb9rucQ8qZpVbnfuCx1LowuOtAxozpVcskLbJmGMYs8drBj+edY+i2WMI7R6V3TRuT6573sk5+/yc+f5ue27fUYJDxsvyS4JYbtM6+77rrZKNqm+8O2I2NZ2cspQawBmLrsZDtXKRGuCPNhG8hGW8Hb1gyVcTuoqOl+RL7/zTT891Dfwaps8hxSA3C++W0vXbq0HIwBAAAAgHZYxZgttthitq9nevr5z3/+HC2d058bhE7OXb/L/q83o3N1ddResXJZP8SM6joN7Y3slAGu40iZV3W62mjKOO/iONuYxz5Lsy12fCpZndLSVaZyzjEo+N5nREtL22ealrbHnOBfO+emoc0Q9JXAUuNbOYHZugdSWtoM9WkzkLvKuu4Sn5SR+k3zzY61LiGgDgU4pDS0nvvvzuabb15OrQAA0w2mMwBAC3xHTBF+bfFRyKNiWOZ2fFSJ2yZjOrZc9Nkq2+xNqaqIc10PXxbNR8rHxzZiM0ajR0FeZ4x7cS+Dts4oj9njufeXz1SOEdb9mMqpbAPDtmfbtahlm9dt9erVs3Mw56DoWkVa+3JeVQayz46IGckxgrrtPTcNBvKgj9kP7KTEfEr82n7pPqm7B5vOTZUI9o2SXgAAAACDR/0/Yf2wXoyOmIk7bFJB5MMKJE9l+Tbp6lw957dveM0cgz613Zitba+9BpR+9po6t+/tM7591rd0ne4nla2W9pMhHjW0/3udhm4TRG7no05L92MqRy2t49b2V61aVRrLppdydbu0kdfTCtbWeUtV9vLnI5qrsbrXuBnIbTJyRS8ZyIM85ng8/nlVcIzuybp7MOf76IMLqsxlAIAIpjMAwDzEC8BR0EZoWydZ83/JhFL0rqKGY/SwDDfDZ0fGMui94g1oGcdeoPnnEnF+/aayvDINlWXcK4owrhNNWs8L2SqjXE3nVIIv3k/2aJ/pI631qICAnH3XQJRFXFtbuHDhbGZ03Dc/SKIS34MsQSXaCt625aNSZbtHVXaryUBOHa/2X6JXzQZI7LHffa0Sv2ptzzcAAAAAwLgHkeea1aomZRpamszraelnW+aDkaXZqlo/SDv6IOw4fZbv43sT2evwOlPYZ9b2iw+c16Ov/FSnoY24TNcoHos/Po0HmGby16ptsLammZKetjl2Y1C2mj8uVfeaBgNZBmwbPT3IY24zBZb238/lrXEvC97PHVupws5lU4D2ICv4AcD0wkgcAAAMhV7nZ4olzDQna12WuQR2VeS3z3KVeDRSc2EZcZ5tLVMHPFX615aZOFSmpt4by5b58mVxWQ46Dm+263lbERLPezSbdbwq0xSFXBRDPns8im9/nm1QwQSwmolje5SotP0xwW3R3FWR7lVGeRvaGMcxU2PSy271knVdZybrfugHX4K9KqoaEQwAAAAA044COZu0c+pvEWW5Llq0qPLz6qqQST9HzSIdlsrO1TKvB7XMG+b+uUxwaUq/3ToNrWW5mcrSzWoyKNsGyPoscF9RTfuhx5RpLqPX62l7njKHo/6VuSwtbdfWjGZlKUurr1ixovysuuDyOP4xbgbyOE8Jldt03VNmsubyVutn31WCvU5Pj7JiBABMN5jOAACQjTdzq0RulfAdZLSokKD15mDOvMfqbOdkkHaVUeqFdaoEuY6nykDXvnjxqixke49EnMSvRLRMapnK+hx/7vzcUBGVo04ZzIoK9sLam7++1LF9hoxDmbf2XstQ7ie7W/gsdJVU82XDfGlzibGqMms6r/4e8HN/x5Ltvqz7uEZNNw3G+JJcKtnmB0C6EMFt5n4CAAAAAJh0oqbIDcYepHFWZaK10dUKFG5TmakfbRQ1tA8Cl06R1pU203nUowK0vRb2mdzSjnqPD/D2JrtvOj+mdVM6SxpLVdy8yR3nDE8Ff2uqqain9XfpNcuC7bK6VZwSzDcFCvvy6VFXG14f+2sTNXQs4z4sA7lNRS+1OtPcj5foevvWb3C5xjXqKn4RoA0AowLTGYbGb37zm+K73/1ucdpppxV//vOfy7k8rYOy3XbbFQ960IOK5zznOcV+++3HFQEYAlXzQeUI4GHgO/w5prGPcO4HCadBlj72pakNn3Xto6pzMpWr5r/2QlnC1KKfFy9ePDtvkzdZ60qaq/m5orwYt/XjXE+ay8sLHonUXkqcN2WEp1puZLvKlEVh29X8aDnl1qrmKIuCPs5V7U3aeA38tqoixFWWPpWl3q8I9uZxKsJ6Uud+Ovroo0e9CwAAME9BTwOMDznaObVsGIHYRlvTWI/9mFTSYaY1B10FyuucqkxlP+VWCq99Y6C8Ldc50ZRZlhkuLa0gbR+gLI2sz5WOtuxVlTe3vyl42WP6KE7BlZpnWVq7zX0kbZlTac1PB9aE7YOda8OOs67SXGpZjoGsa5w7FZjXwjp3uoZRQ8e5iqtM8xSaSiwayV5XD6LstdfVoyzv3w/oaYD5AaYzDIX999+/OPXUU9dabv+Izz333LJ96lOfKp7xjGcU//u//1v+AwWAZlJlo3OipocVKR0FTZXIjcsmpQOtkkV1BpqdbwkSzcdkolNGrkp8RwGm17a+v57+GvpzJ1Hql0lIa97rGDWs54YEt8cLG5tP2Qsxfw5kakuAW1P2ciQGCUhc+/Jg/tGXn8qZA1zNDzb45gcg/Pkc1ACQLweXI/TrMpBz5/luytLX9z9XtMfXGkyKTfeAPXrBDgAAAP2BngboHlWU6iUYexh4s7BtMPak0GRU++pL0tTS0TJyo7GpwHAfVBu1n8pfRy3tNbX9XZrZPsumEUpVtdJ++uXWorFp04NFjWvI1PZ6umouXZ+JntLOvvnPqtLOVbq6SkP71/G8DwKv0XVMuQZ6RPvZNM93PP6UYe4z5OuCy6t0ta63XXt7tOvttbRPEAAAmEQwnWEoXHrppeWjZTU/4QlPKB784AcXd7zjHct/1qeffnrxnve8p7jkkkuK448/vvyn/vnPf54rA/O2ZHUb4TuKSOk2UdPzwXDyprIXw3r0Br+PpPYtzktk69m5szmZLDtZgjGKwzjnk58HSMLPCzAJTt07TYMmEvNCkcESQwsWLCibz55OGZASTr3cE6lscm+8p6Ljvei186Z9iqTmDqsq1eYjyr2QlwnrDdnUHOApcd8LvrxbagCg7TzedVUGYoa1lvljivdIiqoya7GMedOyXtcHAACYdNDTAPklq3N19bCqeMkobBuMPR/6sd5UTmlpTTsl6jKgfWCxTF8zen1Ats9kTlUaMy0tTaVsZ998drQM6Crt5efpjdMLmc63fTMtrXmYq4J6patV2aotVdnkdVraH5O0oO2nJ0dD61z751FLp0xz6Wg9pgzyXjWvv1+qgtP7wfY/amgFNuh1zNKvY5A6OWfZfBjTA4DuwXSGobDHHnsUb3vb24rHP/7xa0Wc3f/+9y+e/vSnlyW2//a3vxVf+MIXihe+8IVlNDfAJCFzrJdo6VGVrM6Nmp7PSIRGAexNZW+MRgPZL5fYkkjSNfECS1mihiJxY/kpH+GsCNmY5WyfKUNQJb1URlp/l5jQPah9sG2YqFTbbLPNykcZx3UlrG1bqXmZtV2jquRzfO4zsQeBv++7mLepLanIcmWlq+y3SmDrtb+P9D5l3CtLoM409xHiKWN5EMEicX6yYTNIEa7BLAAAgEGCnob5QC8VvAZZsSjSS8bxfJ9XVSWYq7S0DLc6M9k3XWu7/jGbV8ae6WOvJU0HeyPVj4uY6ZvSfNpvr6Wt6d5TiWyfXe0NVNNk0tKmFfQ8VvxKId0X8Vq06p6KU1kN8vshE72Nlu5Sa0atq2AAr6H9o+45n42u9+p6aLwiGuXeWPff7dRc110HiyhZYFSkSpd3qattrGm+jzkCTCOYzjAUvv3tb9f+fcsttyyznQ899NDy9Ve+8hVMZxg7rLNnRpo6nTYvuc1PPuyS1d5wbCN850OkdJemshcpdZHUvuyShKdESozWVfMln3yUvQSwn7/Jm4Mp49MLKyv5Zc9tmQSvNZt/asmSJcnSU4qwts6+IqhlSjc1fVbOnE29ZBO0mX9K56uN8B22uLHjT8375LPVqwYFdGx1tJ37yYvt3PLlXa4/rAFCX02ia+y7teuuu3a+XQAAAA96GqYBBVCqL3jFFVcUf/rTn4ZesrqXCl7zpYpXV6ayn1qqLjBbmjJqaRm7TSaWNwftM2QY26OmfEo1v/8+2HfVqlWz8xTrupuJLWMspT+lpZWRrH1o0tI+0zp3LuS2+il3aicZ9nXnLNWG+Z1Q2es6PV2l9zTu0RQs7HVzqvl7xxiUTs5dNgxi5nrX7LnnngRxA0whmM4wNjzkIQ+Zff6Pf/xjpPsCUIXP3jRh0lRWto62GcddR4bOV1NZZrJdS18+yws/L5rjHMheDPvMYBnDimz2gsRHU6dM5DoT1AtBic1YStn+ZmJXpbhT94gtT0Vby4SsKv1d12Rse7y5rv3wr3PLwreds0llt5R9ntO6FMsacIkmco4IzqXKSK4SwU3EeaeGTSo6vUsRnrN+vxDMAwAA4wJ6GsYd6xt7/Sy91WXJ6iZDmYy6/kxlPfcZwNFE9ev7MtTSm94o9povBl77frZM0TpNndLBXqt7vevHADQdk59zOYWZylFPKyg4x2ROlbeuux9TujpWQKt7b27gtg+qUFWtNnq6q++Uxm2qgrMVDNArtp9NAdptxwV0r4zqd2VY5nbqb12Z0OhpgOkE0xnGBi82EAIwjqiz740Kn4mZm3E8igzLacaLE/sdMTPZMn5NBNujvfblib2ZnDKU64ziGPmbWiclgnW9c8s5+yhelfKy5ucUrpqn2JB4koBSmScJXIvgXrlyZbJUWVtyBm/icXszuqocWCydl7t/Mp7biNLU9zZ1TbzIioZy01xMOftQF1Vt13DaAk5GbXob/Yrwqu8gAADAsEFPw7hTFRjbVk/XGYPQe+Csr55lGnr16tXl86ilfSWwGJTtNVvUVZqWxldiS61TlVHrpxSq09LSvabPND4gc1xIK9fpMq+nvWlt27SxBq+lew0u9uMJOevEsST/nfLnPgaU5xqE3jzv5RhSQfW6Jt6stvMV9XQ/JqafL7sqW3kax+AUXDAqmiqn5ejqtoHzADAZ8M2GseGUU06ZU14DYByxTFIJnu233764973vPepdmnpMkJj4NdF77bXXloapiV89qgS2xHDKQG4SR7Eks+aCqhOzZjY1rRMFVxxosX20/TcRLDEcBXE0YGOpau2vBLi1tqZrG3y0eG7rwiz187bltlxM8Nr5jyXTfQR8NL3bZGLba4uEt3umylRm4Gw0xHL3AAAAkwp6GsYd007q90pP3+te9xr1bs0LU9m0jrS0NdPWCtKOZnLKQE7hM5Q1X7E0qV3nqlLN0q52P1SZzFVmcsQHadvx2XHa8fh9rypd7Stf+aZ5oPupaldHWy3dhU6R0ds2Ezt32yktHaci6ycTW2MvdQHaMD+DyAFgPMF0hrHAOinveMc7Zl8/8YlPbL2NZcuWNa4ziPkcYX7hO7PTlnU4LLyJas0EyjXXXFMKX0VT++bn/mqDhEwUsiZWVBrLm85+eZOZ3EuZc4l9OyYdp7320dFVYliRu8putv1buHBh31GhTZnauWJ/GEh4tsksVQR1NPV9U9BC2zl/FdigucN0n3lD2s+rrc+wx34CFQAAAABS/RL0NIw7MdCPfm5v+CxW0xapwGxV/pIJ20sWqWmZqKW9bvbZwJrPWFo6BnX3qylt/2WSS0vbo9dxXkf7imZ+jmc1m4PZHvu9B3MrmY1a32lasDbmrM/stvtIU5R5HW2P9ve21dN8RrUy2O3zVN3Lz9+tabTss5S9Pu5jFwAA8x1MZxgL3ve+9xVnnHFG+fyf//mfi3322af1NnbccccB7BkAtDGQffPluaKZrL8pM7kXoqksoWslu8yQtTmOo5GciqbuR/iljtuErxf6eswtGSVBbMcggzlHEOcYyFEUT0N2Z93cT1VlrzUHtrXU/eybLZNIl+iN82vl3j/aZpu561LXbRwHMgAAAGB0oKcBJpNYBtnPOSxzL+ppGX4Knu0VbyrLODbdLJ1kutrrac1h3JWxV3XsXkPruR2ztFkdpoO8hvbVyabFQO6S1LRRsaXGMHRfbL755mttL5r/Mo998zo69/7RFGRtprWKVdpyrjFGNQBA/2A6w1iUAXvNa15TPt96662Lj370o6PeJYB5SZ2BHE1ViVwZxz7KVdHUKqnU69w8ini1KGQTvPYoM9keFy1aVAodiWGV8upV+PVSvtnPb6XzkSuCJIh984K4bQbyNBjIdfMzRyO567mfquZ/ajqvud+bXuf88kEcubQNPsgZhAEAAIDxBD0NMB5UmajRTPZa2pvLUV9LN7St+CWsz2/6UnpaWtp0tD23ZTKTVQq7V8PNZ67mNmWtej3dJivbB577JiOzrZ6edAM5RZOh3GZKqhTKfk+Vu9Zj03nN+d7Elvud8OMJubS9d5hjHgBgbRhlhJFy9tlnF4cddljZabDO4pe//OXSeO6Fiy++uHGdfffdt1i+fHlP2weYJHKNML+OREdKCEZhLEO5jansM0WVoWwC2JvJJoAlgu2x15JXXQsXZaf2KohVwkvNjtUeq+awmoao6dxI5WgiD0MEdzn3k88wz2VYRnUbCHIAAACYPNDTAIOhrZ7UNDpVJrNMZR+c3cZU9qWG9WhmcdTSelyyZEn5914Ck+sM5CoNU6dVNK901NO5wdp2vGaQS0NLT9dNiTUfslV1z1UFZ1vrNWDBsHPYFKDdxXn2n5OLz6aeRKN6WoMcAAAEpjOMjPPPP7945CMfWVx99dVlR/iEE04o9t9//563t8MOOzSuM42ZgDD95BhUqb/793vRG9ezzrSJYIkUzYNbZyr7OYEkfCV+JUbMaFVpLhO+irCWWMw1lAcZ+dqLINZx2v7LQJfIkJGu47YBAGtdmJvTIIKjIO5SBKcM5XEdbOjVqG4z8DNoo1rl7ed7Nj4AAMCoQE8D5NFGT/qywKJufR+krfmFm0xlbyDLINWjdKbpGV/ty/S0XqvlaJ1BB7tG7L0y172e1jmQhrBmx6NzoGUy0mWg27Hbsvlm0Glcoi5Au5/rZKRMZN/GuRqW7pe2RnXu938YRrW/9zGqAWDaGN//IDDVXHrppcXDH/7w8tE6j8cdd1zxuMc9btS7BTBwmkRf1d+qtlUlfKtep0xlw2cgS/TKVJWhrGXWTKBYMwEYxa/mekqVUvL7bHMz5Yjefson11FlwntD0I7VosS9INAxaSBAJclUlmw+COJe535qW1q9TgTPNwNT56RNAEMvZe5yr5vfdptjyC33jVENAABQDXoa5iu5BrLX1VX9W62T0oS5Wtpe+wxk6WbLwo2ZydIx0tP2aHoy6uk6vaN9tqDx3P79IE3RlJbwBrKZxnqtZtg50ViC19PzRePZuWoK0O4Hf79VBWjPh3ELj+4/+97l0kvARq5RrWzttsfQdiqt+XadAWA8wHSGobNixYriEY94RHHeeeeVrz/0oQ8Vz3jGM7gSMJG0NY9zRF80plMiWII3Cm/fydVza95MNpFhYlbR1LEUkEo+y1RWhrI1iWRFvqZEf52Z3G80bq+Glj9vahK6TcxHQTyquZ8kgOejCJ4vRrW+f22OoW2psnHNcAcAAOgC9DRMC1XGZZ2mzul3pt6X0tTSyn59LbPPsWbPfVUv0yumBf2yqj6ppliSqawAbl9KOB6rZQavWbOm8pz0Uymqiapj0X7KDJVW1NhAE7ZO1NNtjL9Jw2e9VrV+rqPpoyZDeZrHKqbNqG4ztiKj2n4n2hxD2+pkjMUAQL9gOsNQufbaa4uDDjqo+POf/1y+fsc73lG85CUv4SrAxIiHVatWzYpQ69CfddZZrbaRE0GtTqePjJbglSjWo5bLJPadwyazRoJZZnIsk23v9x1mE7/2HR6WgdxL59j26/rrry8jv63ZPttjStSljClFm8fs5flQ9tobzZMw9xOMj1EdA1/mg1GtgUhjnEvPAQDAdIGehknGdJqZJV5P//GPf+ypz1kVmC1jVnrS+njS0dqGNWlpa5o2yrKTPV6PKjA7ZSorc9lraX2u37eYnTwKA7mpupDmn5amtvGPVD88ZWoquzkazNOk/aRN6gzlQZW91vL5OHXXNBvVddUQ+0lmGWej2gf2kI0NMJ2sMzPIXg6AwzqtNofzz3/+8/L16173uuKYY44Z6jmyeZ8vueSSYvvtty+WLVvG9YFWWIfod7/7XfJvOQaLMo5jGWvrnEUTWR3DlGjJMVQk7Pz8UN5MtufRVB4kbQ2gpshcO0cmiL3BbC3XmJIgjgbzpAtiP/dT1fxP83nuJ5jcufV6mQPcZ6joeeq1Nfs9VNPvox7jcz+IaeX3d9lll4GdJwAAAIGehknn4osvLq644orsfqFMZAVd+/mApRll7nodrf6dsqhjH1Imc9SgWuYNlJSW1qM3lQc1JZT2t62ebjKAZIJ7Pe3nXm7CDPpoMLeZX3dcUUZ3XYB2l2WvU9qaLFMYh7na/e9q1M4+GUavo46O+lnL/W+asddee01dogcAkOkMQ8I6Zocddtis4fzyl7986IYzQL9YR2rlypVzylark6VOk5+/SGLYOlcSzb4cVTQBfXavIq0XLFiwVmfNkCmtzpzv1GkeJS821TnswlwednmergSxN5gnVRBXiWDmfoJJQxnx9huRyjhJvVbJQf2Gph59azOnVi/Y79od7nAHTGcAABg46GmYBkzPXXnllbP9M2np/4+9+wCXorz+OP5K7/3Se5OiIEqVjg2wYO8IKmoSa2KiiYmKRo29a9SIgIol9oaKBVFRiiKiFFGU3jvSROD//F7/s5m7bJntOzvfz/PMs212d+7ce3fnzDnveZ1khBNLOx25nNtOYW2keNqdVA5PzlapUiWUmHbiUXey2HmOO5Z2tsndothdFJ6qbE8do58lfPSyM+LaC71/eHLZma/a722vIxVop1I84HSMilWgTdtrpIPzOaK/J/3NeYml3R3vwj9Hwz9bnYKfTBbTiLa/SZMmJJ2BAsRwJGTFGWecYSZMmGCvDxgwwJx//vnm22+/jbq+DsZat27Nbwd5RcGmRrWFJ1B1IOY+SFNQ5wTATlLZHTA6QbUTkEh4MlnPUzDoHEy657p15lpOx7y3maiaTlbQA2LmfkK+8poUTmadVDkncNTaMBLnvZxKcOcz1lki3ReeqA6v1nafnAxvwwgAQCYQT6MQaDRbUVHRPvc7BdpOssPpYOXE1OIUZrtHzCnecxdnO8d8WpxY0l3oGB5Tp5oA9JpAdhdtZzLp6JxDcMfTiq+9/iyRRi/7pZWzU0gQq0A71QJ8528oVscvRikj0t9msrF0vOelWmDtbokfb0S117g6UowfLZZ2j3gGUFhor43s/KElmKRSpdPChQvTvh2010YqdAD10Ucf7VMN6K7ODp9T2T3SOFJrL6eFV3gA7CyJ/O8kmkB2qr5zwQmIw0cvJxoQu0cv53NAnMu5n9x/WyhcmQpkM13dnC7hwat7jvpo90VbJ7yFWHjrMvftypUrm0aNGuX6xwcAFDjiaRSC+fPnm59++qnYiDr3iGN3/Oy+Hm2ksbuQ20lKu2OfRBO86Z4SKlN0fOqeYsqJqb3Gk04RuzvBrPg6nxOm7lGa0Tp+pZKAc4oTYsXTfilmR+LCW/Ons+jaD7OahieDvcTS0eJrpwAovGNZtKVt27YknoECRDkJAHikQEZzgjvzlYQHwpGSM05SWVXdkRLL0QK7bLfdykZA7E4wJxMQu0cv51tAzNxPiCfSXEjpSgr7MTGcSiAbvk54wQ8AAADyz6pVq8zKlStDx23u+DVSfKj1wotonetODJwvU0JliqaWCY+ndZ8X+nncyWUnps63kYVO+/RYS6baXruLFpDfwuPfdHbi8ltiOJ2xdL5+9gHwN75VkRV++AIH4nHm4HH/PTsV1eEBsHPdSUwnE/T6TToDYifBnA/BXzbmfnIHvMz9lN+J4WQDWb8lhtMdyOZjUQwAAH5BPI1C4MzTHCkOci9OEtCJBaPF0rFibL8lUdwtwd3xtNcYwpkH2x1Pq/A9H/ZDtI5f7pbq6Wx7HR5Xp2NaMniTjlg62vP8IFZiONVYmr9hAH6S+7P5AOATOtBTi3YFNe45jgoxgRyUgNhpex2r9TVzP+WXSK2P05EUjjSXb77KVCBLYhgAAACZUqNGDTstiRMHqoOVl4LsQkq2KN5wF2s78bTiTi90vB4+ejmXxdrhba8jxdWptr2OVZythRgmMZlKCvulyNpJDCcTS8d7XiF9VgFAKkg6A0AC+vTpE5gDyfCA2Eku+ykgZu6n3CeG05kU9kvrK8lUIMtJFQAAAPhRs2bNTPPmzU1QqHjZnVx2lkSKtZ1id2fJZrG20/Y6VoF2qiNQ4yWU86HzWS5kKinsp8RwOgqqI90Oyvk8AMilYH57A0CSCvUANTwgVoJ5x44dnoMSBb/ho5cVJGZyf2nbYgXAmZz7yd1K3e+J4UwEsn5JDGcqkCUxDAAAAAQjllbso9g5PJ722jbaKdYOTzBnumOazgHEiqVTbXut7Y+VUPZ72+t0FFRHu+0H4fFvOmNpP/9dAABIOgNAoKQjIA4PhjMVEMdKKDstsQt97if9vjKRFPZLYtg9J1K6A1kSwwAAAAASTdQ6HcDci9fYSsXakUYvp5vivXgJ5VQLtGMlk3WZ62nGwqdlSncnLj9IRyxNYhgAkCj/DtECAMSkQDJSO698CIizMfdTpERyJuZ+ymQg68fEcDpbSuc66Q8AAAAguMXa4Qlmr4XPimUijV5ORwyqbYtXoK3keCoiFWSH385UYjhdRdd+TAynuxMXAAC5QNIZAHxOgVqk5HIiAXGk0cvJBin5OPdTePDpzKWValI41Z8jF4nhdAeyJIYBAAAA+JXi1vDkshLOXguAy5Urt0+CWTFputpeR4qrU6EYTsXksWJqd4wXnhjW9uzcuTMtnbj8UGQtmYqlSQwDAAoRSWcACEhArMAx0ujlRAPiTM395ASfThCmxLGz6LZzny7dbafdQW+0RLGfEsOZCGRJDAMAAAAIMsWFkUYvex0VrFjUiaGdmFoJ50QSh07b61gF2snEr05iWLQ97lg6PJ5WbOiOm7UPtm7dGjWW9lNiOF2xNIlhAACSR9IZAAo4IHYnmL0ExPHmflJyV9vgbv8c3g46Uoto96U7eewEc1pUaa37dZ/TMizVeZvTTQF6pgJZEsMAAAAAkDrFroqf3fG04muvMV+k0cvxWkorho1VoK1Y2kkqx4udo912x8/uRXG0ts+ZokgJYy16z3ySytRL8dYBAAD5gaQzAOSYAs9Io5eTDYg1mllBV3iV8qZNm2zQqdd2XzqLu7I6WgAcjxPsOpfhS3jb60wID0bTGciSGAYAAACA/OCM1A1PMHudBkkxqnv0smJr3RceD+u1VRDtxNB6D3cs7Szu2NlpH+3cjhdPK9aMFD+7L7ORXE21y1as+wAAQOEj6QwAWeJuXeUsTvAaKSh133ZGCDvzLimx7MxdrPU2b95s1q5dG2rV5SyqtHZfpkJBsPOe4UGws3hNymYqKUxiGAAAAAAKj5PsVRz9888/h5LMkWLnSF233HMWO3MaK37Va+j1nEJsd/zsjqtTnbYpPH4Ov+61QNuZlikTsTSJYQAAkCqSzgDgkQLVLVu27DPHUaR5j5zW2E5i2amE9jJi2Jl7WYszitmptnbmfnKS1e4llbmW9J5OoOsEvk5i29kOp7I6HYEsI4YBAAAAIDicUcLxYmnFtk4M7Y6nncfjcWJZd0ytGNRJJCumX79+vb3tLtJOhXu6KHc87by/4mp3bJxKophYGgAA5DOSzgDgkQLc77//vth9zjxJ4W2rvSaAnZHL7jmOFUQ6AbBaYisIjtYezKlyduZCdp4fnuB1J4/dwa+zuINg5xIAAAAAgHRYvXq1WbNmTei2YmZnrmN3PO21Q5cz1ZQTSztxrFOsrUS1OoIpro4Un+v5TuyseDhSLO0ssWJpZxvcsTSJYQAAEFQknQHAIwWqCloTDYidANc9H5OzOO2+woNeBa667lQyRwuAxQmSoy3ZmvsJAAAAAIBIFENrhLE7nvZSrO2easrdnUvxsdNJzB0zO+u6Y2n3Y+513YXg0Ravba8BAABA0hkAPFNAq8BYwWnFihVN5cqV7XWNQnYWVVG7k8panMRvstXOkZLIBMEAAAAAAL/QyGPF1IplnSJrUQzttM5WAtlJKitBrOsaWazrydDz4hVoMyoZAAAgfSjXAwCPVA29YMGCUHsuBacKUjXnsrNUqFAh1Kraaa0VqzLanZQmCAaA3NPnuzPFgVNMFGnRY5UqVTINGjTI9SYDAADkvY0bN5p58+aFOn0pFlby2R1Pa3FiafcUUpE400jFKtBONlkNAEiOO4aOF0+3atWKbhJAASLpDAAJJCKc1teqtnYnk3XAtGXLFru4g2CnStsdTOu5Sk7rutOuy5mHyj1CmoprAEiNTmqGB7axgl7n0itOZAIAAHiPp6NNAaVR0FrcnFjaKfR2Ymp3bO2On93xNMdoAJD6Z3ak+DlaTO3c72XaBIfTLRJAYeG/GgA8UhK4du3adh5nHUy555VygmFncYLdaEmQn3/+2S6xuCu8w5do9zN3M4BClUjA627TmEmJBNQAAABBVrVqVVOjRg17jKZjqEgxtPt6tNhWU15p0cjpaJwC8ETiaWe+ZwAoNIqL4yWLI92fSc50hQAKD0lnAPD6gVmqlBk4cGAoEHa3YPVa8ZfIAZUzT/Qvv/zi+TlOcO0lQe2+HwByXTEd63PUOTmZSYl+btKRAgAAwLv27dubNm3a2JHOSignkwDxejyo9VQsriUR0ZLRsY4LKfwGkE3OucJE4ulMF2M7UwvG+9x0P0ZHCqBwkWkAgARUrFgx4hxS6ZwrNNL9ibx+MsF1ookWki0A3O2rEwl6s1Ex7fVkofsxAAAAZE543JxMAXQic4Umk2xxkjkaSZ1MssVrPE2yBYAk+nmWaPvqZCRSfOM8RvENADfOsAFAFikZ4oyUTkQyVeCJBNeJJrcjVTJ6CbQJroH8lemTeMlI9HOG0SYAAACFy4kpy5YtmzdtZfX66k6WaIeyRKfSov03kL+S6YSY6Dm4RPE5AyBXSDoDQAEH14ke8GYjuE5k5CHBNZC+9tXxPgOy0b460ZNrzKsHAACAVIsYtSRS+B3peNpLPJ1I++9kkk6RRkzHO7ZmBCKQmPBzaV4+AzLdzcspxvZ6Ho2OCgByiaQzABQoHZQm2/47kUrwXM2tFS/IJrhGoVZMp3NkRjK8FI9ECnhJIAMAAMAP3Me7iXCOzxOJp7PV/juRmJoOZSgUic59nO321V6TyJzfAuAnJJ0BABlp/x0v0M7m3Fpeg2yCa2SS83ecSNCb7fbVXoJe/k8AAACAfSUzpVS0ItN48XSiHcrS0ZY3XkxNkSkyxf1/kkhRR6Z5/R/h/wRAkJB0BgDkvP2316AhW+2/E60CJ7gOnnh/u5Eey2bFtNegl4ppAAAAwF+F3+Htv73G09lq/51IC2DikeDJ9FRwqXY3SKTYAgCwL5LOAABftf9OpKo1l+2/4yWuCa7zQ6SRBV7+xjIp2siCeH9XFD8AAAAAhS+V9t+JxtPJdChL9mdJJJ5Gfsh017tUBkUkkkTm/AwApA/f0gCAwMytlUgVeDbbfycyLy68V0x7+Z1numI63hxq/J4BAAAAZIOTjEu08DuTRbrJFn4nkqB2Fop0c1fgn6xE2lbzewaA/EDSGQBQ8JJt/51M0JXp9t9BGQGb6NzH2W5f7TXoLZSKaWffuvexl/sKff1y5cqZoqKiqPsNAAAACFr7b0m06DvReC7Z9t+JxtN+jOecYuxE9n2221d7iaf9ei4jXK5j1lTXz+R71qtXL+HPFgD5j6QzAAARKLjUksrcWl4DvWzNrZVIJbiX4NpLcBFp9LGq2MP3hXOfLp2A12tAk8j2uPeJO5h1j0iO9lj4azrXnd+lX4LGZIJMRFa1alWSzgAAAECYZDqUZbpzlbN+ooXfibb+9vJze43X3DG0sx/CY+fwWFvP9xrzedme8OvhxfBOvKxLdxztXtznF9yv74x0d34n+RoTp5KoRXS1a9cm6QwUIJLOAIC0yveD/1xWdboD1kiBZLQ24JGuKyBPNfEaa30n6e4EiM6lHtPPofd3Vx07z9f2uSurMz1fkxPwhieLnW2OFvRGko122wAAAAAQiR9j3GyurxhPrcG1OPe5E9VOPOckY51LJ4aOV/idzkStO9kannSNJjyOzkb76liJ4khxdrTRx9peZ/sTmXYMwUZiHihMJJ0BIIGDoTVr1oSuu++Pd19Q1kf2WoJrn7uD51iLk6R2J1SdQNa5333bCRbdt70EvAo+3Ulgd4AdKYHtXHeCVneiONqI4/CA2I/tztLFHew712Pdl+j66XgNv68f7zUSHb0BAAAQVD///LPZtm2b72LcbL4nste1LFLM7E72Roqz3b+z8JjZ/dxocXY8TiwdK3aOdH+k53pJIhdK++pk5WsMmusYN5vrJzIFHgD/4EwZAHikwGLJkiXsL+QFZ9S0AkV3IOyujtbfrDvh7LTbcrfcchZ38OyMZnYng93BbKRtCX8svJVWpFHHThsuLZobN1a7Mt2nkwbu1/BTMJWu9aP9DgAAAIB8tmHDBrN69epcbwZgOTGpE0MrxnTHzoo9w+Nrd0vr8CS0O6527lPc5o6lI8Vy0WK/8LbVzmWkaaEUS2v0tztWdsfOkWLsROLSfI6JU3kNAEBmkHQGAI/8fHCaD4GBn6svs/UzuZPE4e20w6uw3fclM1+WV07y2Vmc4Nn9eKRgO10V+9FaXjuBeKLzawEAAADIPr/G08S4/tkHTpwcnih2x9DhjzkF0rFGRafCSTi7i7jdsXIm42m9hlN0Hi5W7OwuDnfH00HuMgYA8I6zrwDgkYKBZs2aha67L73el4v1kRvuwDbaEr5OMvMfJ/J7jhQ8xkvURpv/OB4ngR7r5410fzoC6FgSSVCHV4EDAAAASE6NGjVMhQoV8i6GjvcayL7wWDJWbJ1MLOnm9Xet9bzGj+77k/1bivQzx4unEzmf4Dw3kfmXoyWjY+2TZM8nAAD8i6QzACQYKCNY3HMnJxL0ZnpurmjBXazAL5snT/ReqhZPtGI8kQS1sySyr5M5IeFuDe51X1MFDgAAAPyPEs5aECzuLl5e4+lIna7SyT3vsdcYL9vJUycGTWTO20gd0+Lt+0T2tV7/l19+sYtXToeyROLpoM81DQB+R9IZABAYkUbfegl6MyleEBbpsUIOwpJpFR7pREa8QDuR36uzfjLBdaIjqwEAAAAgHyVSGJxMgXAyYs1bHO3+Qi0Q1s+luZ21pFJk7yWe9vp7TbZDWbRkdKzfb6H+XgHAbzi7CQDwpfD5jb0ER8m0r06Eu92U1yQy7aZyF1wnM6o6W+2/E6kEL9QCBAAAAADp58RCXttWJ9MtKhnJFO0SC6XGXSydCK/d4MLn007k9bUk2/7bazzN+RgASD+SzgCAnEukbXUuKqaprC08ybb/znR1fzIndLI5VzcAAACA/OGlpXL4Y9nq5uU1PiH55z+ptP9OJKbORvvvbM7VDQBBQNIZAJCx9tVeg95MIohAPs2t5TXIztbcWolUghNcAwAAAJnjdfSo+7FsdvPympSjzTGi/S0l0p0sVvvveDF1Iu2/kzkvFWnEdLz/Ef4vAAQFSWcAgOd5cuMFvZmumNZBeiJzH1MxDb+3/060CjzTc2sl2vpb9xFcAwAAIEgyPU9uspjKB0Fr/53I/2G22n8nGk8DgN+QdAaAAMh0S+BkhI+g9HLQTfIKQZHO9t/x/v8TCa6d5yY7t5bX/3mCawAAAOQDHSsnOvdxtttX07UIKC6ZKaWi/a/Hi6cTef1EupPF6twX73+e9t8AcomkMwD4SLzRj9Eey7RED4A5CAbys/231wKVbLX/TrQKnOAaAAAAyY5+jPRYLtpXx+vuRYEmkJn/RS2JFH6HdzXwGk9ns/03gzwAZBtJZwDIES+JnvDHsl0x7fUgFUDw2n9nsmVgsu2/k6kCp4MCAACAv0Q6FvVybJrNbl5ej0c5FgWC2f470Xg6G+2/k/kMA4BwZAoAIA28BrzJtrRNV8V0vANGAl4A2ZhbK5GTg9maWyuRKnCCawAAgPRwj+TLREvbZNB1B0AmOR0LEi38TvRzMtH231oSLfxOpEsDnQ+BYCDpDAAe6aBt6dKlKY3eS1aiCRHaVwMotPbfiVSCZ6P9t36OKlWqmGbNmnl+HgAAQFCtW7fObN68OaXRe8nwUmAY/hgFhgDyjWJQtf5Otv13IvF0Iuc4k23/raVFixamQoUKCT0XQP4j6QwACVi7dm1a21d7SSIzTymAIHPafyciWvvveIF2onNrZXrKAwAAgEKxdetWs379+pReI1L3mXhJZLp5AQiqZDuUuacD9BpPJxIbO+tr+wAUHpLOAOCRk/x1khKR2lfHC3qpmAaA/G//7bUKPNFkOAAAQFC5j8ucrjGJxtMkKAAge4XfqbT/9hJTJxqvA/AH/rMBIAHt2rULJY+pmAaAwkJxEAAAQGYUFRWZmjVr0r4aAApQMu2/ARQmks4AkIBy5cqxvwAAAAAASACJCAAAgMJXItcbAAAAAAAAAAAAAADwL5LOAAAAAAAAAAAAAICkkXQGAAAAAAAAAAAAACSNpDMAAAAAAAAAAAAAIGkknQEAAAAAAAAAAAAASSPpDAAAAAAAAAAAAABIGklnAAAAAAAAAAAAAEDSSDoDAAAAAAAAAAAAAJJG0hkAAAAAAAAAAAAAkDSSzgAAAAAAAAAAAACApJF0BgAAAAAAAAAAAAAkrVTyTwWAYLr77rvtAgAIrj/96U92AQAAgHfE0wAA4mmgcO23d+/evbneCCCbwc3mzZtNlSpVOFGMhC1dutQ0atSIPQcAsJYsWWIaNmzI3gAABALxNFJBPA0AcCOeBgoTI50RKIxIQrrUrVvXlCxZkh0KAAGze/dus3LlylxvBgAAWUc8jXQhngaAYCKeBgofSWcASML06dMZ3QYAAcQoHQAAgNQQTwNAMBFPA4WvRK43AAAAAAAAAAAAAADgXySdAQAAAAAAAAAAAABJI+kMAAAAAAAAAAAAAEgaSWcAAAAAAAAAAAAAQNJIOgMAAAAAAAAAAAAAkkbSGQAAAAAAAAAAAACQNJLOAAAAAAAAAAAAAICk7bd37969yT8dAAAAAAAAAAAAABBkjHQGAAAAAAAAAAAAACSNpDMAAAAAAAAAAAAAIGkknQEAAAAAAAAAAAAASSPpDAAAAAAAAAAAAABIGklnAAAAAAAAAAAAAEDSSDoDAAAAAAAAAAAAAJJG0hkAAAAAAAAAAAAAkDSSzgAAAAAAAAAAAACApJF0BgAAAAAAAAAAAAAkjaQzAMAaOXKk2W+//eyi6wAAAAAAIDZiaQAAgN+QdAaQFZs3bzbPP/+8GTFihDnooINMgwYNTNmyZU3lypVN48aNzeGHH27+9re/mc8//5zfCAAgpoULF4aKZNK1UGwDAADyEbE0ACCdiKcBZBJJZwAZtW3bNnPLLbeYpk2bmtNPP92MGjXKfP3112b58uXml19+MT///LNZsmSJ+eCDD8ytt95qDj30ULP//vubZ5991uzdu9eXvx13EgMAgER89NFHoe+Qfv36sfMAAAgoYmkAABJDPA3kXqlcbwCAwrV48WJz7LHHmlmzZhW7XyObO3ToYIqKiszu3bvNypUrbSJ61apV9vH58+ebM8880yajr7rqqhxtPQAgX1WpUsVcfPHFMdeZNm2amT59ur1ev359c8IJJ8Rcv2vXrmndRgAAgGQRSwMAMoV4GkAmkXQGkLFWLT169LAJZdGIrTPOOMNcc801pn379vusr1HNX3zxhXnggQfMuHHjzJ49e2xlNwAA4WrUqGEefPDBmDtG7bKdpHOrVq3irg8AAJAPiKUBAJlEPA0gk2ivDSDt1Db7lFNOCSWcy5UrZ15++WWbTI6UcHaS0l26dDFPPvmkHfV8wAEH8JsBAAAAAAQGsTQAAAD8jJHOANLu9ttvt6OWHWPHjjXHH3+85+cr4TxlyhQzc+ZMfjsAAAAAgEAglgYAAICfMdIZQFpt377d3H///aHbJ554ojn11FMTfp2KFSuanj17Rn180aJF5rrrrjPdu3c3derUMWXKlLGXun399dfb+aDj+eijj+wIay39+vUL3f/hhx+a008/3TRv3tyO0q5Zs6bp06ePbc26a9euuK/l5twXvqhlmkPXnfubNm0auv/TTz81I0aMMG3atDFVq1a1j19xxRUR3//dd9815513nmndurWdm6V8+fKmSZMmdg7TMWPGRN1uAMBv5s6da6eA0NzOzvdKUVGR6datm/2+Wb58uadd9fPPP5tHHnnEHH300aZx48amQoUKpnTp0vZzXJ/nxx57rLnlllvMt99+u087cH3O9+/fP3TfpEmTIn6HuL8rAABAYSCWJpYGAL8ingbgYKQzgLR68cUXzZo1a0K3//SnP6V9D998883mpptuMjt27Ch2/+rVq+0ydepUWyGuE/hXX311Qq3MLrnkEvOf//yn2P07d+40n3zyiV1Gjx5tE7y1atVK288TaTsuu+wy8+ijj8ZdVz/vmWeeaT744IN9Hlu8eLFdXn31VZvgeOaZZ0znzp0ztNUA4E/6jL/88svN448/bnbv3l3ssbVr19pl2rRp5s4777TfLfqeiObzzz+300ssW7Zsn8c2b95sl++++868+eab5u9//7stCCpVisNxAABALJ0OxNIAkF3E0wDCcZYLQFpplLBDI7xijVZOhk72P/TQQ6HblSpVsqPC6tata+eQnjhxoh1lpoT0X//6V3vfPffc4+m1L7zwQtsKvESJEnZkm0ak7dmzx7b6VpJAZsyYYc455xwzfvz4Ys9t0KCBufjii+119/Y594XTaORo/vjHP4YSzgceeKDp2LGjHSU3f/58u22OVatW2f27YMGC0H0tWrSw2162bFkzZ84cm4CX77//3u6nd955J+2/EwDwq61bt5qjjjrKTJ48udjn6CGHHGKqV69u1q9fbx/TKGeNPrr00ktt4lgjosOpw4Zea8uWLfa2Pre7dOliWrZsaUc7673U2eLrr7+2rxFOI6z1naGEtYqFpH79+rZjRTh14AAAAIWFWJpYGgD8hHgaQER7ASCNWrRosVcfLVpOOeWUtO7b559/PvTaWoYPH75306ZNxdbR7bPPPrvYei+99FLE15s4cWJonbJly9rLLl267J07d26x9fbs2bP33nvvLfaakyZNirqd7vW8+Omnn0LrlyxZ0l42atRo78cff7zPujt27AhdHzRoUOh5FStW3Pvss8/us/706dP3Nm/ePLSeXnfDhg0Rt+P6668PrafrAOBn7s+0vn37RlznnHPOCa3TunVr+70Q7tdff9378MMPh74n9Dn92Wef7bPeFVdcEXqt3r177122bFnE99y1a9fejz76aO9ZZ51lXzvWd1O07QYAAIWHWJpYGgDyBfE0gGQxpzOAtNJcy4727dun7XU14lgjlx1qX/rEE0/sM2JYt5988kkzZMiQ0H1XXXWVfX68djCtWrWy1eUa4eym+TPVevXkk08O3ffss8+aTFBrV42Ie//9903v3r33eVwjmEUjut9+++3Q/c8//7ydhzqc2mmr9bbmEnVG4rnn3AaAoNKUCfq+cEY3a0Rzv3799lmvZMmS5ve//72dp9n5nL7xxhsjvp5D308apRyJ2mn37dvXPP300/a1AQAAhFg6NcTSAJA9xNMAoiHpDCBt1C70119/Dd2uVq1a2l57woQJ5qeffrLXy5QpYxOnSgZHovvV4lqtTUXtp997772473Hrrbfadt3RnHfeeaHrmt8zU9RCvHXr1jHXcc/3fNxxx5mjjz466rpNmzYt1gpWiZPfisgBILjuvvvu0PW77rrL1KpVK+b6w4cPDxUlvfvuu2bdunXFHne3zC4qKkr79gIAgMJFLJ0exNIAkB3E0wCiIekMIG2ceSwdsRK4qcxvNXjwYDuHcyyaY3ngwIGh2xoZHEu5cuXMscceG3OdTp06ha5rXs5MiTRiOZz753Enw6M599xzQ/NBr1ixIjRHNQAEkQqknGIkdcg45phjPD2vf//+9lKFO+55oKVRo0ah686oaAAAAC+IpdODWBoAMo94GkAspWI+CgAJqFy5crHbP//8c9r231dffRW6fuihh3p6Ts+ePc0bb7xhr8+YMSPmuvvvv39oZHQ0NWvWjDiiLZ20DQceeGDMdZYtW2ZWr16d0P7QqDuNnp43b15of4S3EQeAoJg1a5bZunVr6HNXUyh4MX369NB1TVfgduqpp4YKpDQdhJLaZ511ljniiCNMw4YN07r9AACgsBBLp45YGgCyg3gaQCwknQGkjUaLaa5Kp8X2xo0b0/baa9asCV1v0qSJp+eorbRj7dq1Mdd15jyOxZ2UdrcRT6fq1avbfeh1X5QvX95zG1ftDyfpHG9/AEAhW758eei62mRrSoZEbdiwodjtESNGmHfeece8+uqr9vYHH3xgF2ncuLHp3bu3HSk9ZMiQuK28AQBAsBBLp45YGgCyg3gaQCy01waQVu6E8Jw5c9L2uu5R0xUrVvT0HPd64e3KwkWbHzrblETOxL5IdH8AQCHbtGlTyq8RXnxUsmRJ8/LLL5vHH3/ctGvXrthjixcvNuPGjbOJ6fr169vL9evXp7wNAACgcBBLp4ZYGgCyg3gaQCwknQGkVa9evULXp06dmrbXdc8P7bREjce9Xni7Mj9LZl8U8v4AgES5i3A6dOhg52hOdBk5cmTEAqbzzz/fzJ4923z33XfmscceM8OGDTPNmzcPrbNr1y4zatQo07Vr12KdKwAAQLARS2cesTQApI54GkAsJJ0BpNWAAQNC1xctWmQ+++yztLyuu4W0Rox5sXDhwtD1Qmpl6t4X27dv99wqu1D3BwAkqk6dOqHrK1euzMgObN26tbngggvMmDFjzIIFC2wS+k9/+pMdES2674YbbsjIewMAAP8hls48YmkASB3xNIBYSDoDSKtTTjmlWELz7rvvTsvrdurUKXTdayLbvd7BBx9sCkWDBg1M7dq1E9ofSkzPnz+/IPcHACTqoIMOMmXLlrXXV69ebX744YeM70Qloe+6665iiebXX389b6d7AAAA2UUsnXnE0gCQOuJpALGQdAaQ9nmULrvsstDtl156yS6JUitodzLVXfU9fvx4mySIZfny5ebtt9+O+PxMK1euXLE2qpnQv3//0HWNootH6+zZs8de13yi+++/f0a2CwD88l3l/l54+OGHs/bexx13XOj6qlWrcvIdAgAA8g+xNLE0APgB8TSAWEg6A0i7q666qthI2qFDh5o33njD8/O//fZb0717dzNhwoTQfUceeaRp1qyZvb5z505zxRVXRH2+5tq89NJLQyfrW7RoYQ4//HCTLTVr1gxdX7ZsWUbe46KLLgpdf+WVV8y7774bdV21Ob/55puLPZeRdACC7uqrrw5df+CBB8z777/v+bmRWnJ7nepgyZIloevurhXZ/A4BAAD5iViaWBoA/IB4GkA0JJ0BpJ1alr7wwguhk+mad/j4448355xzjpk7d27URPH06dPNsGHDTMeOHW3iudiHVYkS5tZbbw3dfvbZZ+1cmT///HOx9bZs2WLOPfdc8/LLL4fuu/322+3zs+WAAw4IXdd+yNRI50GDBoVun3zyyRHf68svv7QJ940bN9rbjRo1KjYSHQCCqm/fvvY7R3799Vdz9NFHm3/961/7fK84duzYYV599VUzZMiQYqOVHY0bN7ZFPZMmTQp1lgj3xRdf2KIoh/tz3KECqwoVKoSKhvTdCAAAgoFYmlgaAPyAeBpANKWiPgIAKWjevLmZOnWqOfbYY20CWSfgn3rqKbs0bdrUdOjQwc79vHv3bjtibObMmfu0Ga1cuXKx26eeeqr5+OOPzUMPPWRvP/744+b555+3Cdg6derYltsffPBBsYSBRkSfeOKJWf1dnnTSSaGRx6r8U5vv9u3bh+YPlb///e+mevXqKb3P6NGjTc+ePc2CBQvsz6z906pVK9OtWzdTpkwZM2fOHPs7UEJfKlasaJP11apVS/EnBIDC8Oijj5oVK1bYzhq//PKLueaaa8xNN91kP0eVRNbntop29Dmr7zJ12pBDDjlkn9dSgdVjjz1mF31/aZ6rJk2a2M9ejYKeN2+emT17dmj9oqIiM3LkyH1ep2TJkrZQ65lnnrG3+/XrZwYOHGi3R49JjSwXxZEAAMj0SURBVBo17LYCAIDCQyxNLA0AfkA8DSCivQCQQVu2bNl744037q1WrZoyn56Wjh077n3llVeivuY///nPvWXLlo35GuXKldt7yy23xNy2iRMnhtbv27evp5/H/R7R/PLLL3v79OkTc/t++umn0Pq67tzfpEmTvYlYuXLl3gEDBsTdpy1bttw7bdq0mK91/fXXh9bXdQDwM/dnWqzP+F9//XXvtddeu7dChQqevqNKly699+KLL97ndSpVqpTQ99zcuXOjbtPChQv31q1bN+rzE/2uAAAA/kMsTSwNALlCPA0gWYx0BpBRlSpVMtdee61t6Tx+/Hjz3nvv2ZbPGpW8fv16OyJXI7batGljR5ZpdJd7PuhI/vGPf9h5ojXSWSOKf/rpJzsSTSN4VRV+1FFHmREjRthRYblQunRpOzfoqFGjzEsvvWRHx+ln1Si6dNMIb43ufuedd+yo708//dSOHNd81mpv3qlTJ7tPzz77bLtdAIDiNHr4xhtvtG2vn3zySfv5rU4RGp2sz9IqVarYEcsHHnig7awxePBgO0o53Lp162w3DrXXVkvs77//3nbwUFtutctu2LChHSGtbhhqzx1r2ge939dff20efPBBOwp7/vz5dvoItQEHAADBQCxNLA0A+Y54GkC4/ZR53udeAAAAAAAAAAAAAAA8iD7EAgAAAAAAAAAAAACAOEg6AwAAAAAAAAAAAACSRtIZAAAAAAAAAAAAAJA0ks4AAAAAAAAAAAAAgKSRdAYAAAAAAAAAAAAAJI2kMwAAAAAAAAAAAAAgaSSdAQAAAAAAAAAAAABJI+kMAAAAAAAAAAAAAEgaSWcAAAAAAAAAAAAAQNJIOgMAAAAAAAAAAAAAkkbSGQAAAAAAAAAAAACQNJLOADLuiiuuMPvtt5+pUKGCWbp0KXs8j5x++un2d1O7dm2zcePGXG8OgALF90D+4nsAAID8xTFU/uIYCkC28F2Qv/guAPZF0hlARn377bfmoYcestcvv/xy07Bhw33W6devn018Okvjxo3Nzp07Pb3+yJEjQ8/TF71fnHjiicV+Zu2DeD766KNiz/GyHH744TFf86abbjKlSpUya9asMdddd10af0IA+A3fA5HxPQAAAGLhGIpjKADgu4DvAsBvSDoDyKirrrrK/Prrr6ZixYrmz3/+s6fnLFmyxDz66KMF+5t56aWXzCuvvGLyQcuWLc2ZZ55pr//73/82CxYsyPUmASgwfA/si+8BAADAMVTiOIYCEDTE0/viuwDIb6VyvQEACtfkyZPN22+/ba9fcMEFpmbNmp6fe8stt5gRI0bYltyFRC2sL7nkkpRfp379+uaEE06Iu16bNm3irnP11VebJ5980hYHXH/99ebpp59OefsAQPge2BffAwAAIB6OoTiGAgC+C/guAPyIpDOAjLn11lvtpdo8/+EPf0jouatWrTL333+/+etf/2oKiUZ7r1y50pQuXdocf/zx5oUXXkjqdVq1amUefPDBtGxTu3btTN++fc2kSZPMc889Z26++WbTpEmTtLw2gGDje2BffA8AAACOoRLHMRSAoCGe3hffBUD+o702gIz4/vvvzVtvvWWv9+nTxyZJvejevXvo+h133GE2b95cML+hDz/80IwaNSrUHkfJ3nyhUeWye/futCWzAQQb3wP74nsAAABwDJU4jqEABA3x9L74LgD8gaQzgIwYPXq02bt3r71+2mmneX7e2Wefbfbff397ff369eauu+4qiN/Q9u3bzYUXXhiaR/kf//iHySdDhgwxZcuWtdedVtsAkAq+B4rjewAAAHAMlTiOoQAEEfF0cXwXAP5B0hlARowbNy50XW2kvSpZsqS54YYbQrfvueces27dOuN3mit5wYIF9vq///1vU65cOZNPKleubA477DB7ffXq1ea9997L9SYB8Dm+B4rjewAAAHAMlTiOoQAEEfF0cXwXAP5B0hlA2s2aNcssXrzYXm/Tpo2pV69eQs8/9dRTTceOHe31LVu2mNtuu83Xv6Uvv/zS3H333aGR3IcffrjJRwMGDAhdf/PNN3O6LQD8je+B4vgeAAAAHEMljmMoAEFEPF0c3wWAv5TK9QYAKDzuUbK9e/dO+Pn77bef+ec//2mOO+44e1tzDP/xj39MOHmdD9SmWvMla67kGjVqhJLP6Wgr88Ybb5ivv/7atiGvWLGiqVOnjunWrZvp1KmTKVUq8Y939++Kkc4AUsH3wP/wPQAAADiGShzHUACCinj6f/guAPyHpDOAtJs6dWroeocOHZJ6jWOPPdYmUPVaSrDefPPNNvmcrPHjx9slnYYOHWq3MZY777zTzJw5016/4447TFFRUVree9q0aaGkfLj69evbJP3ll19uSpcu7fk1DzzwQNveXAny77//3mzYsMFUr149LdsLIFj4HvgfvgcAAADHUMURSwMA8TTfBUBhIukMICNtYBxqr52sm266yRxxxBH2+n/+8x/zl7/8xTRp0iTpJO1DDz1k0qlz584xk85K3DrzU/ft29ece+65JhuWL19u99VLL71kXn31VTsC2ovy5cvb/fvjjz+Gfo/abgBIFN8Dv+F7AAAAcAy1L2JpACCe5rsAKEzM6Qwgrfbu3WsWLVoUut2wYcOkX0tzH/fr189e/+WXX8yNN95o/LQfLrjgArNjxw5TpkwZ8+ijj9q24anSSOk//OEP5pVXXrHJ4W3bttn30PWxY8eaLl26hNadMmWKHTGukeJeNWjQIHR94cKFKW8vgODhe+B/+4HvAQAAwDFU4seSHEMBCCri6f/tB74LAH8i6QwgrTZt2mSToI6aNWum9Hoa7exQUlWjxpIxcuRIe8CSzmX48OFR308jsydNmmSv/+1vfzP777+/SUcF4NKlS+2I7eOPP940a9bMjk4uW7asvX7OOefYlrbXXntt6DnTp083d911l+f3qFWrVuj6ypUrU95mAMHD98Bv+B4AAAAcQxFLAwDfBXwXAEFC0hlAWm3durXY7QoVKqT0ej179jSDBg2y1zXX8PXXX2/yndpbX3XVVfa6ks1KOqdDpUqV7KjpWDSaWiPCzzzzzNB9d999t/n11189vYf79xX+uwQAL/ge4HsAAAAkjmMojqEAgO8CvgsAvyPpDCCjNCI4VRrt7LSmfv75580333xj8tnFF19sR/rJI488YkciZ5u7FfmGDRtsq+1s/b4AIN2fK3wPJI7vAQAA/I1jKGJpAOC7gO8CwG9IOgNIq4oVKxa7nch8wtEcfPDB5oQTTrDX9+zZU6x9dL557bXXzKuvvmqvq/22Myd1trVo0cI0bdo0dHvu3Lmenuf+fYX/LgHAC74H+B4AAACJ4xiKYygA4LuA7wLA70rlegMAFJaqVauacuXKheZ1Xrt2rSkqKkrLiC0lc5V0VmJXcxV36dLF8/PHjx9vl3QaOnSo6datW7H7vvrqq9D1adOmme7du0d9vuZndsyYMaPYug8//LBNtqeiXr16ZuHChaHfgxdr1qwJXa9bt25K7w8gmPge4HsAAABwDBULsTQAEE/zXQAUJpLOANJKbbA1wnbevHmhxGrbtm1Tft327dvbeYqffvppe/sf//iHeffddz0/Xwnghx56yKRT586d90k6u82ZM8fza23ZssVMnTo1dHvz5s1pnQfG66jlZcuWha67R0oDgFd8D/wP3wMAAIBjqH0RSwMA8TTfBUBhor02gLTr0KFD6Pp3332XttcdOXKkKVXqt1qZCRMmmI8//jhtr11otm3bVmzf169f39NzFi1aFLrdsWPHjG0fgMLG90Du8T0AAID/cAyVexxDAcg1vgtyj+8CIHkknQGkXdeuXUPXv/7667TOU3zuueeGbmu0cyIJ671796Z10ZzNqbzP9ddfH3pe3759iz2W6lzQzzzzjNm5c2do1GGfPn3iPufbb7+17culVatWplq1ailtA4Dg4nuA7wEAAMAxFLE0APBdwHcBECwknQGk3RFHHBG6/umnn6b1ta+99lpTtmxZe/2TTz5JqMW23yvsnIRwPN9//73561//Grp95JFHmtq1a8d9nvZnpN8hACSK74H043sAAIDCxzFU+nEMBcBv+C5IP74LgOwh6QwgI21gGjdubK9rbucVK1ak7bUbNWpkLrrootDtKVOmmCDQnNSa1/rf//63Wb16dcR1du/ebee87tGjh1m3bp29r0yZMua2227z9B4ffvhh6PoxxxyTpi0HEER8D6Qf3wMAABQ+jqHSj2MoAH7Dd0H68V0AZA9JZwAZcdZZZ4Wuv/rqq2l97WuuucZUqFDBBI0S+H/4wx9MvXr1zP77729OPPFEM2LECHPhhRea4447ztStW9cMHTo0lHAuWbKkefLJJz3NzbxlyxbzwQcf2OsaFc1IZwCp4nsg/fgeAACg8HEMlX4cQwHwG74L0o/vAiA7SDoDyAjNvay5hOX5559P62vXqVPHXHbZZSao1GZ7/vz55pVXXjGjRo0y//nPf8wbb7xh1q5dG1pHSemPP/7YnHbaaZ5e8/XXXw/NAa3EdalSpTK2/QCCge+BzOF7AACAwsUxVOZwDAXAL/guyBy+C4DMIukMICNatWpljj76aHt90qRJdp7hdLrqqqtM1apVTVD07t3bfPHFF+aBBx4wZ5xxhjn44INNkyZNTKVKlUzp0qVNrVq1TKdOnczvfvc7M378eDN37lxz6KGHen79xx9/PDQ6+pJLLsngTwIgKPgeSC++BwAACAaOodKLYygAfsR3QXrxXQBkz3579+7dm8X3AxAgn332menZs6e9fvnll5t7770315uECObMmWMOOOAAo6+DM88804wbN479BCAt+B7wB74HAADILxxD+QPHUAAyie8Cf+C7ACiOpDOAjBo8eLB5++23TcWKFc2iRYtMzZo12eN5Zvjw4Wbs2LG2pbZGSLds2TLXmwSggPA9kP/4HgAAIP9wDJX/OIYCkGl8F+Q/vguA4mivDSCjbr/9dpvM3Lp1q7nzzjvZ23lmwYIF5plnnrHX1ZqbhDOAdON7IL/xPQAAQH7iGCq/cQwFIBv4LshvfBcA+2KkM4CMu+KKK8x9991nypcvb+d2btCgAXs9T2h+6Oeee84UFRWZ+fPnm2rVquV6kwAUIL4H8hffAwAA5C+OofIXx1AAsoXvgvzFdwGwL5LOAAAAAAAAAAAAAICk0V4bAAAAAAAAAAAAAJA0ks4AAAAAAAAAAAAAgKSRdIZZvXq1efPNN811111nBg0aZGrVqmX2228/uwwfPjxte2jkyJGh1423fPTRR/xmAAAAAAB5i1gaAAAAAP6nlOs6AqpOnTq53gQAAAAAAHyFWBoAAAAA/oekM4pp3LixadOmjZkwYUJG98w333wT8/FmzZrxmwEAAAAA+AKxNAAAAICgI+kM21a7S5cudlGl9sKFCzOe9D3ggAPY8wAAAAAA3yKWBgAAAID/IekMc8MNN7AXAAAAAABIALE0AAAAAPxPCdd1AAAAAAAAAAAAAAASQtIZAAAAAAAAAAAAAJA02msjJ4488kgzc+ZMs3HjRlOtWjXTrl07M3DgQHPRRReZ6tWrJ/WaS5cu9bRew4YNk3p9AAAAAAAKLZYW4mkAAAAAqSLpjJx47733QtfXrFljJk2aZJfbbrvNjBkzxgwZMiTh12zUqJGn9fbu3ZvwawMAAAAAUIixtBBPAwAAAEgVSWdk1YEHHmiOP/5407VrV1O/fn2za9cu891335lx48aZCRMm2Grtk046ybzxxhtm0KBBGdmGkSNHmipVqpg//elPGXl9AAAAAAAKLZYW4mmko3CiRo0a5pBDDmFnAgAAFJj99jLsE2EWLlxomjVrZq8PGzbMVkung9P+K5pHH33U/O53v7PXFUQvWLDAlCtXLq3twLp06WJWrlxpGjRo4Ll9GAAAAAAAhRpLC/E0spl0rlSpkunRowc7HQAAoMAw0hlZEytIFs1BNX36dDNq1CizfPly89JLL5mzzjrL8+t7mau5ZMmSnl8PAAAAAIBCj6WFeBrZ9Msvv7DDAQAAClCJXG8AEB4sOzQvFQAAAAAAiI1YGn6yc+fOXG8CAAAAMoCkM/JKu3btQteXLVuW020BAAAAAMAPiKXhJzt27Mj1JgAAACADSDojr+y333653gQAAAAAAHyFWBp+QtIZAACgMJF0Rl6ZM2dO6Hr9+vVzui0AAAAAAPgBsTT8ZPv27bneBAAAAGQASWfklUcffTR0vW/fvjndFgAAAAAA/IBYGn6b03nPnj253gwAAACkGUlnpMWYMWNsOy8tI0eO3Ofxb775xvzwww8xX+Oxxx4zjz/+uL1et25dc8IJJ/DbAQAAAAAULGJpBBWjnQEAAApPqVxvAHLv008/LZYQXrt2bei67lcQ7DZ8+PCE3+PLL780I0aMMP379zeDBg0yBx54oKlZs6b59ddfzbx588y4cePMhAkT7LolS5a0CeiKFSum9HMBAAAAAJApxNJA8n7++WfO+wAAABQYks6wo4vHjh0bcU9MnjzZLqkmnWX37t3m/ffft0s0SkSPGjXKHHvssfxmAAAAAAB5i1gaSC3pXKdOHXYhAABAASHpjKwYPHiwTSZ//vnn5quvvjKrVq0y69atM3v37jU1atQwHTt2NAMHDrQJ7SpVqvBbAQAAAAAEHrE0CjnpDAAAgMKy315l/YCAaNiwoVm2bJlp0KCBWbp0aa43BwAAAAAAXyCeRjq899575qeffjLt2rUzvXr1YqcCAAAUkBK53gAAAAAAAAAAwbFp06ZcbwIAAADSjKQzAAAAAAAAgKwh6QwAAFB4SDoDAAAAAAAAyOqczrt27WKPAwAAFBCSzgAAAAAAAACyitHOAAAAhYWkMwAAAAAAAICs2rBhA3scAACggJB0BgAAAAAAAJBV69atY48DAAAUEJLOAAAAAAAAALKKpDMAAEBhIekMAAAAAAAAIKvWr1/PHgcAACggJJ0BAAAAAAAAZNX27dvNtm3b2OsAAAAFgqQzAAAAAAAAgKxbs2YNex0AAKBAkHQGAAAAAAAAkHUknQEAAAoHSWcAAAAAAAAAWbd69Wr2OgAAQIEg6QwAAAAAAAAgJyOd9+7dy54HAAAoACSdAQAAAAAAAGTdzp07zebNm9nzAAAABYCkMwAAAAAAAICcWLlyJXseAACgAJB0BgAAAAAAAJATJJ0BAAAKA0lnAAAAAAAAADmxatUq9jwAAEABIOkMAAAAAAAAICc2btxotm/fzt4HAADwOZLOAAAAAAAAAHJm+fLl7H0AAACfI+kMAAAAAAAAIGeWLVvG3gcAAPA5ks4AAAAAAAAAcpp03rt3L78BAAAAHyuV6w3IRxs2bDCTJ082S5Yssdd//fVXc9111+V6swAAAAAAyGvE0wCSsWXLFrN582ZTtWpVdiAAAIBPkXR2mTp1qrnxxhvNu+++u091ZXjSedWqVWbIkCFmz549pkePHua+++7Lzm8MAAAAvhq18+WXX5rOnTub+vXr53pzACBjiKcBpGrx4sXmwAMPZEcCAIilAZ+ivfb/u/XWW03v3r3NO++8YxPJSjo7SyR16tQxdevWNV988YV59NFHzbp167L5ewMAAECe++WXX8y4cePM9OnT7aVuA0AhIp4GkA4LFy5kRwIAiKUBHyPpbIx56KGHzDXXXGPbaCvJ3KZNG/P73//ejkiJ5dxzz7WXu3btMuPHj8/ObwwAAAC+oGTzzz//bGbNmmVbRuo2ABQa4mkA6bJy5Uqzfft2digABByxNOBfgU86r1ixwlx11VV2Z5QrV86MHj3azJkzxwbO3bp1i7nzBg4caMqWLWuvT5w4MSu/MAAAAOQ/jWqePHmyPXm6adMme6nbjHYGUEiIpwGkkwaCqMU2ACC4iKUBfwt80vmRRx6xVZT77befueeee8ywYcM87zwlnA844AB7UPzNN99k9BcFAACA/Jmn+fXXXzfLly+PW5m9aNEie5ypS91mtDOAQkI8DSDdfvzxR3YqAAQ4niaWBvwt8Ennd9991+6I+vXrmwsvvDDhHdiiRQt7qROJAAAAKGxe5ml2V2bv3LnTtGvXzl4y2hlAoSGeBpBuS5cuNdu2bWPHAkAA42liacD/Ap90VgWlRp/07NnTXiaqWrVq9nLz5s0Z+PUAAADAb3NLuSuza9eubYqKiuwlo50BFBriaQDppm6CP/zwAzsWAAIYTxNLA/4X+KSz5tiTGjVqJLUDNWpFSpcundZfDAAAAPw3t1R4ZXbTpk3t/U2aNGG0M4CCQzwNIBPmz59vk88AgODE08TSQGEIfNK5evXqdkds2LAhqR24ePFie1mrVq20/mIAAACQX7zMLRVemV2hQgV7f8WKFRntDKDgEE8DyIT169ebtWvXsnMBIEDxNLE0UBgCn3TWqBNVT3755ZcJ77ytW7eaqVOn2g9JzdUHAACAwuRlbqnwderXr2927doVWnSbuZ0BFBLiaQCZMm/ePHYuAAQknlbymVgaKAylTMAdfvjhtopmwYIF5pNPPjG9e/f2/NwHHnjAbNu2zSad9ToAAAAoTO6q68qVK9sROLrU7bp169rHS5QoEVpHZs6cGfG1nOeo6LFHjx5Z/kkAIH2IpwFkiuZ17tatmylTpgw7GQAKPJ4eN24csTRQIAKfdB46dKi5/fbbzZ49e8xFF11kPv30U0/zO3/wwQdm5MiR9rraJp5zzjlZ+HUBAAAgl1XZO3bssIvmoFLhoTjV2S1btjS7d+82rVq1ivuaWo+2kQD8jngaQKaoS8z3339v2rdvz04GgAKPpzWFqZLPxNKA/wU+6dymTRtz/vnnm8cee8x89913pnv37ubuu+82Rx99dMQd9uOPP5qHH37YjnLWAbA+HK+88kpTs2ZN41erV68206ZNs4uqjrSsW7fOPjZs2DAzZsyYtL/ns88+a0aPHm1mzZplNm7caOrUqWNHmV988cWM+AEAAHlblV2yZEmbMF61apUNinXbqc4uX7686dq1q52CJR7N8dyrV6+sbD8AZErQ42liaSCz5syZY1uwOokJAEBhxtMdOnQw1apVs5fxEEsD+S3wSWe5//77zbfffms+++wz22Z7yJAhpkqVKqZ06dKhHdWpUydbdaOgUjQPtBx55JHm+uuvN36mhG+2bN++3Zx88slm/Pjxxe5XNZPaaCgZfd111/l+nwIAgMKrytZxjLrjKKms65s3b7YB76+//mof/+abb8wVV1xBG0gAgRLkeJpYGsisDRs2mBUrVpj69euzqwGggONpjXwuKiqyeQOmVQD8rUSuNyAf6INswoQJtjWYgl8t+qDTaF+nmlIjclWB4zzujAJ+7bXXCqrisnHjxjbwz5TzzjsvlHDu37+/efXVV+0I61GjRpkWLVrYLx61LVelPJDPB0zO5wAAoLBp3mWnKnvLli1myZIlZuHChTZA1qVu6349rvW0PgAECfH0b4ilgcyYPXs2uxYAfIp4GggeRjr/P83LPHbsWDNixAjbDuz999+P2BqxbNmyZsCAAebqq682ffr0MYVAI4u7dOliF1Vq6wRqs2bN0v4+H374oXnuuefs9WOPPda88sortoWG6L2PO+44c8ghh9hRz9q/p5xyiqlevXratwNIleYe0d+u8/cLAChcmndZ7b+aN29uk8uVKlWyldg1atQw69evt7fVVluPM08zgKAKajxNLA14c8EFF9iOCKJBHoqpGzRoYAd/xKNzVCrs0zEXAMBfiKeB4CHpHEbzCmvRSUONbl6+fLk9IFarByVkDzroIFOuXDlTSG644YasvM+dd95pL0uVKmXn8QpP2NWqVcvcdttt5owzzrDzPD/++OPmL3/5S1a2DUgUI50BIBg077I6scyYMcMeC+qkZ6NGjeyJ0mXLlplt27bZ+2vXrm0OPvhg5mkGEGhBi6eJpQFvlHCeMmVK0rG35nbu2rUruxsAfIZ4Gggeks5RKCGqeae0IHUaGfTBBx/Y64cffrhp2LBhxPVOPPFEO/+XWlZqJDRJZ+QrnUhTAQUAoLCp68qgQYPMd999Z+eY0tyCOumpUX0a3Tx9+nR7vxIqWo/5pwCAeDqdiKUBY+bNm2eL+4jBAcBfiKeB4GFOZ2SFTshqHlzp27dv1PV0orZ79+6h5+zatYvfEPKSRr0BAIJBxyTOvM4a0ayEsyjRrNvOfM5aDwCAdH8HEUsj6NSOe8GCBbneDABAEoingWBhmB6yQq2QHG3atIm5rh6fMGGCnS/x+++/N+3atfP0HkuXLvU0OhVIB/19AgAKn070T5482axcudLs3LnT1K9fv1hRnG6vXr3aPq71unTpwmhnAICvYmkhnka+mz17tmndurXZb7/9cr0pAACPiKeB4Al80llJyKFDh9qqyVatWtk5hb26+uqrbSBXuXJlM3bs2Iz+ovzOHcBGa63t0DyJjiVLlngOlN3PAzKNpDMABMOXX34ZGuUsM2fOjLieHq9bt65dv0ePHlneSgDIDeLpwoilw58L5KO1a9faQj/NDw8A8AfiaSB4Ap90Hj9+vHnuuedspeQjjzyS0M5r2bKlueOOO+xzzzzzTHPUUUdl7BdVCPNQOSpVqhRzXbWqdOgkL5CPSDoDQHBOcCqpouLEeLSe1geAoCCezjxiaaD4aGeSzgDgH8TTQPAEPun81ltv2R1RunRpc+qppya087T+JZdcYpNPb7zxBknnGDSS3D1vcyxly5YNXd++fbvn34cqueNRy0u1vwRSxXzjABAMvXr1Mnv27DFbt26Nu64K57Q+AAQF8XRhxNJCPA0/+PHHH0337t1NhQoVcr0pAAAPiKeB4Al80lkT2UvHjh1N1apVE9p5Wv+ggw6yrzFt2rQM/YoKQ7ly5YrN5RCL5kt0lC9f3vN7xGs1JiVLlvT8eoDXv1MAQOGqXr26GTJkSK43AwDyEvF0YcTSQjwNP1AhoOY579y5c643BQDgAfE0EDwlTMCpSlLtsffff/+knt+6devQ6yA6zXvttWW2eyRRvFbcQK6QdAYAAEDQEU9nHrE0UNzcuXPtlCYAAADIP4FPOjsJTvc8wolwkqKbN29O6y+m0LirppcuXeq5rVejRo0yul1AOtrcAQAQbtmyZeb11183y5cvz/jzkn0vAEgV8XTmEUsDxal1/IIFC9gtAFDAshkXE08D6RX4pHOVKlXsjli/fn1SO9B5XrJJ66Bo165d6Pq8efNirus8XqpUKdOqVauMbxuQjETnSAMABIfan44bN862ndVlvHaoqTwv2fcCgHQgns48YmlgX99++63Zu3cvuwYAClA242LiaSD9Ap90rlevnj1QTXZOZud5derUSfOvprB06dLFlClTxl6fNGlSzA/6KVOmhJ5TunTprG0jkIht27axwwAAESnQ1XQis2bNMlu2bAnNeZqJ5yX7XgCQDsTTmUcsDexr7dq1dmQaAKDwZDMuJp4G0i/wSeeePXvaHbF48WLz3nvvJbTzJkyYYBYtWmTnhO7Ro0cGfj2FNQ/VYYcdZq+///77UVtsv/zyy6FW5SeccEJWtxFIBElnAEC0ArrJkyeblStXmk2bNtlL3Y5XaZ3M85J9LwBIF+LpzCOWBiL76quv2DUAUGCyGRcTTwOZEfik8/HHHx/aGb///e9ttaQXq1evtutHep0gGjNmjE2+axk5cmTEdf785z/by19//dVcfPHFZvfu3cUe176/+uqr7fVq1aqZESNGZGHLgdTmrwMAIFKltFOYqEvdjldpnczzkn0vAEgX4unUEUsDyVmxYoVdAACFI5txMfE0kBmBTzoPHDjQHHLIIXZn/PTTT6Zr165xRzzr8e7du9v19UHWsWNHM2TIEONXn376qQ10neXFF18MPfbDDz8Ue0xLsgYMGGBOP/10e/311183RxxxhL384osvzOjRo+0+1Yhzue2220z16tXT8NMBmaGDF+aQAoBgUjtHHcMsX748aqX0zp077TycuoxXaZ3M85J9LwBIp6DH08TSQG7NmDGDXwEABDiezmYMDsCbUh7XK2hKpB566KE2ibRw4UIbOLdq1cr069fPNG/e3FSqVMk+pqB44sSJ5vvvvw89V4+NHTvW+Nnjjz8e9WfQh6wWt+HDhyf9Xk888YRtnz1+/Hi7L7W4lShRwlx77bXmwgsvTPo9gGzYs2ePbbFdsWJFdjgABIiCz3Hjxtl5or777jtz+eWXmzJlyuxTKV27dm1TVFRkL3W7bt269nGnFa1bMs9L9r0AIN2CHE8TSwO5T1woQaBjHwBA8OLpbMbgALwh6WyMad++vXnttdfMqaeeals8a/SiAmF3MOzmjG6sUaOG+e9//2sOPPBAj7sb5cuXN2+99ZZ55pln7MmJr7/+2mzcuNHUqVPH9O7d21xyySXMjw3fUAEFSWcACBYnOJ01a5YdnecEo+GV0k2bNrXrN2nSxK7jVEx36dIlFFRLMs9L9r0AIBOIp7ODWBqI7PPPP7et/tU5AQAQnHg6mzE4AO8C317boSpsteU588wzTalSpWxiOdqix8866ywzc+ZM2zLa75T8jfXzhi+RaPSz83i0OZ3dtJ8nTJhgVq1aZT/c1VZbVU49evTIwE8IZC7pDAAIDndwumnTpmKtt8IrpStUqGCfo+Ikp2I60rxSyTwv2fcCgEwJajxNLA3k3po1a6IOGgEAFG48nc0YHIB3jHR2adiwoXn66afN7bffbt5//30zZcoUmxRVu4fKlSvb0biae0pzEderVy+B3QygEOkACQAQHO7gVKNpnNZbn332mZk2bVqoUrp+/fpm165doefp9urVq/epmA6vsPbyPEn0OVRnA8gG4mkAuaLjsGbNmpnSpUvzSwCAAMTTycbFycTgxNNAYkg6R6APl3POOccuABCNWsMDAIIhPDhVO9nZs2fb2y+88IKpVq2aDZpFo/cicYLqL7/80nZ30aUTdHt9niT6HDrJAMgm4mkA2bZt2zbz1Vdfma5du7LzASAA8XSycXEyMTjxNJAYks4AkKQNGzaw7wAgIMJbcBUVFYVab1WvXt0+1qpVq7ivs3v3brN27Vp7XZe6nejzknkOAABAIdP8oC1btjQ1atTI9aYAALIQTycTFycbgwPwjqQzAKQwp7NasNDCCwCCVZXdtGlTe3+TJk1s8Fy2bFl7W6NrNFdpLJonqlevXva6Lvfs2WO2bt0adxvcz0vmOQAAAIVMx0eTJk0yQ4YMMSVKlMj15gAAMhxPJxMXJxuDA/COpDMAJGnv3r1m/fr1dr53AEBwqrIrVKgQCkJ1W8Fzt27dTIsWLUzPnj09v64qunViNFHJPAcAAKDQrVmzxnz99demU6dOud4UAECG4+lk4uJkY3AA3pF0DrNq1SrzxRdfmIULF4ZGMXp13XXXJbDrARRKUEvSGQCCU5WtuUrdx4e6vXr1avu41uvSpYspU6ZMTrcZAHKFeBpArmn+TY2eo802AOQe8TQQPCSd/9+0adPMNddcYz766CM7ejEZJJ2B4FGiAQBQ2CcunapsmTlzZsT19HjdunXt+j169MjyVgJAbhFPA8gXapuqc3sayVayZMlcbw4ABBrxNBA8JJ2NMY8//rj5/e9/bw9Mk00477fffun+3QDwAZLOAFDY1q5da3bv3m1atWoVd12tp/UBIEiIpwHkGx2PqZ1r9+7dc70pABBoxNNA8AQ+6Tx79mybcNZJQid5rLaImv+lZs2apnTp0rn+HQHIY2rDv3XrVjsPCQCg8PTq1csWJuqzPh59F2h9AAgK4mkA+WrWrFl2GpTGjRvnelMAILCIp4HgCXzS+Z577rEJZyWb27dvb5599ll7CQBeaR7PFi1asMMAoABVr17dtmd0W7ZsmW0T1rlzZ3sy06tknwcA+Yp4GkA+U5vtk046iSJxAPB5PE0sDfhHCRNwEydOtJfly5c3b7/9NglnAAlbvnw5ew0AAuKXX34x48aNsy0bdanbmXweAOQz4mkA+WzHjh32cyrZqfQAAOmVTFxMLA34S+CTzitWrLCjnAcMGGAaNGiQ698HAB8i6QwAwaHg+Oeff7YtG7ds2WJvZ/J5AJDPiKcB+CFe14g6AEDuJRMXE0sD/hL4pLMzDysJZwDJ2rRpkz1gAgAUNlVYT5482U6roM9+Xep2vOrsZJ+XDmpD9vrrr1MgBSAjiKcB+MGMGTPM4sWLc70ZABBoycTFxNKA/wQ+6dysWTO7I9atW5fr3wUAH9NJfQBAYXMqrBctWmQ75ehSt+NVZyf7vFTRhgxAphFPA/ALtdnWqDoAQG4kExcTSwP+E/ik80knnWTndvnkk0/Mnj17cv37AOBTJJ0BoLC5K6x37txp2rVrZy/jVWcn+7x0jFymDRmATCOeBuAXOv56//33ze7du3O9KQAQOMnExcTSgD8FPul84YUXmvr165vVq1ebBx54INe/DwA+pSSAClgAAIXJXWFdu3ZtU1RUZC/jVWdHe978+fPt/IJvv/12RkYu57INGYDgIJ4G4Cdr1qyxx0PE7gCQ//F0rOesWLHC3HPPPZ6nkSKWBrIn8Enn6tWrm+eff97ORfWXv/zFjBo1Kou7H0Ch2L59O236AaBAhVdYN23a1N7fpEmTmNXZ0Z7XsGFDs2TJEpt4fuyxx2wg7UUiI5dz1YYMQLAQTwPwm3nz5pm5c+fmejMAIDCSiadjPWfHjh3ms88+MxMmTDBjx471VFhNLA1kTykTcB9//LG9/Ne//mX+/Oc/20ptjXg+5ZRTzIEHHmiqVq1qT9R50adPnwxvLYB8pgRCrVq1cr0ZAIA0C6+wrlChgr1fRYvOqGWNJtao5SFDhsR93saNG03ZsmVtl4zKlSubp556yvz+97+PuQ3RRi536dLFlClTJuq6CtDbt29vZs+eHfM5AJAM4mkAfqRkhYpm6tWrl+tNAYCCl0w8Hes5JUuWNGvXrrVxtZ6rdXv27Bn1/YmlgewKfNK5X79+xZLKarHzzTff2CUReo1ff/01A78iAH6xePFi06lTp1xvBgAgjcITuJqWZdeuXaHH69SpY7744gsbJGvU8mGHHWYqVaoU9XmaR3DhwoWmRIkSdh1N8fLGG2+YoUOH2uclMnK5bt26EQPsWG3Ioj0HAJJBPA3Aj/bs2WPee+89c8IJJ9gCQABA/sTTKpCO9hzF03rNbdu22dtz5swxkyZNillYTSwNZFfgk84SPpcLc7sASIYSBzrocarvAAD+p3mXnQSuzJw5s9jjCo4V+DqjljXX8kUXXRT1eVp//fr1ZvPmzfa2KrSVEHaeF0kiI5djtSFTsM1oZwDpRjwNwI/UnlWtWY877jhTunTpXG8OABSkZOLpDh06RH2OE0/rM1zF2Iqnf/jhh6iF1cTSQPYFPumslthe22cDQLwTbj/99JNNBgAACoOCWAXBrVq12ucx3f/111/bEcrqeKN5lj///HNz7rnnRnxe+Po1atSwAbP7eZGqsxMZuRyvdRmjnQGkE/E0AD9bt26d+fDDD80RRxxhu9AAAHIfTyvejfScSPG0ktBKWEebRopYGsi+wCedP/rooxzsdgCFStV1JJ0BoHD06tXLtmDcunXrPo999913th2YkrxVq1a19ylAVmAb6Xnu9Rs1amQaNGhgA2SNSHaeF16dncjIZYnVuky31ZWD0c4A0oV4GoDfqSBPx086dmNQCgDkPp4uX7686dq16z7PiRRPK7ZVzKv7wuNpYmkgNwKfdAaAdFq1apXZsGGDqV69OjsWAAqAPs+HDBlS7D4liqdMmWIrrRUU63PfaXmtSmsnCex+ngLee++9N7S+gmiNQm7evLkNjt3Pc1dnJzJyWSN0YrUuczjPUauzHj16ZGjPAQAA+MPcuXPtyLlOnTrlelMAwAQ9nv7mm2/MFVdcUSwujhdPRyqsJpYGcoOkMwCk2Zw5cyLOIwIA8D8Fu5pnSp/1S5cutSNi4rW8TrbtdXhldryRyy1btozauiyc1lOrMwAAAPx2rKbEs5fjKABAfsfTxNJA7pB0BoA0mz9/vjnkkENMuXLl2LcAUGCcUcmqzFagu3fv3tComEgtr1VlnWjA6zxPI5ETGbmsgDtSG7JItK5anQEAAOA3kyZNsnG82rYCADIXT0+bNs1+3mYqniaWBnKHpHMEatGgD6glS5bY65qY/rrrrsv+bweAL+nA59tvvzWdO3fO9aYAANLICXbV7kuJXSWEa9SoYcqWLRuzyjrRgNdpe62RyImMXNb2hbcuA4BsI54G4Fead3TChAlm4MCBdq5QAEDm4unNmzdnLJ4mlgZyh6Szy9SpU82NN95o3n33XVtl4xaedNa8rTqppwNSnRS87777svMbA+ALSjofcMABjHYGgAKsyp43b54NmLXohKSCW2dETKQq60QDXqfttUYi61iTkcsA/IB4GkAh0LGYzgsOGjTI1KtXL9ebAwAFG0/v2LEjY/E0sTSQOySd/9+tt95qE8v6YApPOGtugXB16tSxlTOvv/66mTVrln1uzZo1s/NbA5D3dPD01Vdf2aIUAEDhVGWrqEgtvUqVKmWD5MWLF5s1a9aYhg0bmhIlSkSssk424K1evTojlwH4AvE0gEKijofvvPOOGTx4sD3/BwBIbzxdunRps3379ozF08TSQO6QdDbGPPTQQ+aaa64J7ZQ2bdqY/v372+qbL774IurOO/fcc23SWa10x48fb4YOHZqd3xoAX5g9e7Zp3769qVKlSq43BQCQIh0XqqWXgmLN5az5p9QGTCclVXhYVFS0z2gYp8qagBdAISOeBlCIdK7v7bffNkcffbQ9zgMApC+erly5cmi+ZuJpoLAEPum8YsUKc9VVV9mdoZOH//73v82wYcPs7UsvvTRm0llzvOhkoz4cJ06cSNIZQDGqwvv888/NUUcdxZ4BgAKoylaLLwXITZs2tScilUzWsaQTMHft2tWOgI40ahkAChHxNIBCPwZ86623bKttRjwDQPriaY1q1vzNCxYsIJ4GCkzgk86PPPKIbeWgFtr33HNPKOHshRLOmrNVbR6++eabjP6iAOTWBRdcYFvAuEeuad6ReB0O1A5GVXyNGzfO0pYCADJVla3PdH32t2vXzmzbts1+F9SqVcvOS6X5pVq0aGF69uzJLwBAYBBPAwhK4lnF5DoOBACkHk87lIQmngYKy/8a5QfUu+++G5qk/sILL0z4+Tq5KPrQBFC4lHCeMmWKXXSw9NNPP5lly5Z5eq6q+TQiDgDg76pszT2lY8Z169aZefPmmaVLl9p5pnS/Htd6Wh8AgoJ4GkCQ5njm3B8ApCee1pSE69evt7eJp4HCEviRzj/++KMd5axRKbpMVLVq1ezl5s2bM/DrAVAItmzZYlv19+jRI9ebAgBIkDraOFXZMmPGDJtsVvC8Y8cOGzCrvbYeVwJa6/N5DyAoiKcBBIU6nk2YMMH079/ftGzZMtebAwC+jqe3bt1qp6Nq2LChbbVNPA0UjsCPdFb7BqlRo0ZSO1CVOFK6dGnjd/pwv/LKK02bNm3sh772SZcuXcwdd9xhW0imYsyYMTap72XRukAhjpRWVR8AwF/UQlsnGdU+W9OqFBUVmZo1a9rAuFKlSmbv3r32xKMed6ZfAICgIJ7+H+JpoPDpuG/ixIlm7ty5ud4UAPB1PC0q3tZt3U88DRSOwI90rl69ulmzZo3ZsGFDUjtQc7WK5vPzszfeeMOcffbZxUZsK9Gs0ZlaHn/8cTuHDdWcQPLB6YcffmhOOukkOx88AMAfevXqZfbs2WMrsdVa8e2337bBsRItKpYrVaqULT48+OCDbfCs9QEgKIinf0M8DQQrtv/kk0/M9u3bTadOnZLqmggAQY+ny5QpY8+P6rJr1642rtYgOOJpwP8Cn3Ru0qSJWb16tW31kCh9WE6dOtUeYLZr18741VdffWVOO+00e8CsETt/+9vfbLsg3X7uuefMf/7zHzN//nxz9NFH2wS0vhhSnfdL8zVEo7YaQCFSOxlVRR911FEEpgDgE0qoDBkyxF7XXFSqwNbcU7Vr17ZFi7rUsZEC5MMPP9xeAkBQEE8TTwNBpfNjOm926KGHEt8DQILxtO5XMlq3W7RoYac+BVAYAp901snB6dOnmwULFthKxd69e3veeQ888IAdDayks17Hry6//HJ7oKyKIs1P456HcMCAAfbD/6qrrrKJ57vuusuMHDkypfdr3bq1adq0aRq2HPAfdUeYNm2a6datW643BQCQAM3hrCBZUyVoepX999/ffPrpp3bEs44jdWzz+uuv2yK9KlWqsG8BBALxNPE0EGSzZ8+259M0cKNkyZK53hwA8E083bhxY/PDDz/Y+Z11v6b41KhnAP4X+Dmdhw4dGjowvOiii2yljRcffPBBKPlaoUIFc8455xg/UvJLyXY5//zziyWcHZrnuW3btvb6fffdZ3bt2pX17QQKyddff21mzZqV680AACRARYrqWKE5OzW6Wa20NcJZx44KmhcuXGi2bNliE8/r1q1j3wIIBOJp4mkg6H788UfbLlYJFQCAt3i6atWqtuOqzpEqjtbjAApD4JPObdq0sclWzcny3Xffme7du5s333zT3o52MPnnP//ZDB482B5QapSzkrI68ehHr776auj6ueeeG3GdEiVKhJLqGzdutO2BAaRmypQpZu7cuexGAPBRVfZ///tf8/nnn9uCvaefftp8//33tjLbGe2sOarUBUeJZ91OxbJly+zrLF++PG0/BwCkG/E08TQAY4/XdC5Ro54BALFHOTsdUGvUqGET0Zr2VDF2uop3iKWB3Ap8e225//77zbfffms+++wze4JQ8wyoLWLp0qVDO6pTp072g1HzP4uTlD7yyCPN9ddfb/xKbSFF8w8ecsghUdfr27dv6Lq+JPRzA0iNDqiUnDj44IOZAwoAfFCVrWNBVWFrcajjjUY7q1Jbo51btmxpu8KoK47ahWk6hWrVqiX0fgq2x40bZ99HRZGaCoVWYwDyFfE08TQAY9auXWsLBjVIRd1wAACRRzkrhpayZcvaz0vd/9VXX9k8hab6TAWxNJB7gR/pLDqJp7mM1RpMyWQtGrGi1ogaySxqhbtq1arQ4zJs2DDz2muv+TpZ5Iy01AlSzekcq4I9/DnJ0ojq+vXr2/1eq1YtO7r8H//4h61CAoLGqebbs2dPrjcFABCnKjvSZ7WOn5Rkdo92dih4fuGFF8y7775rlixZ4vmz3gnKdfxJqzEA+Y54mngawG90PKjzhF6n7gOAIMXTim8//vhj89hjj5l33nnHng9VpwjF07ocNWpUyp+fxNJA7pF0/n+qsBk7dqyZNGmSHemskb9OgtmdaFYFzqBBg8xHH31kRo8e7etRJzt27LCVmNKwYcOY61avXt3uE9FJ01Ro361YscJ+oSixP3XqVHPzzTfbxPejjz6a9OuqvWW8Zffu3SltO5AJ8+bNM2+88YZNMAAA8q84yKnKjkTtwcSZ2zl8PR1D6r5nnnnGTsmiqU10LBXtmMQdlOvEpS51m3kCAeQz4mniaQC/UTczxfcauAIAQeeOp7du3Wo/G5UXUPyseNdJMju31UEnPPHstV02sTSQH2ivHaZ379520YlAVd/ow0wfeEq41qlTxxx00EGmXLlyphC4W0NWqlQp7vraB/pySDYx1rx5c3PiiSeaHj16mEaNGoXmyH7ppZfMiy++aJPgv/vd7+zI8QsvvDDh13deE/AjHXTpf6F///6mcePGud4cAMD/U4GejgtbtWplvv7662LHT6ICxAYNGtjrGskc6ThJo5+nTZtmj3UWL15sjy/Lly9vO7+o8E/PV3tuHQO5W4/pti7r1q1r7+/Zsye/FwB5jXg6OuJpIDhUiPjWW2+ZI444gnNVAAIt0Xh6zZo15pVXXjGdO3c2BxxwgH2u16mniKWB/BD4pLOqZ0Qn9ZTwdOZxLlmypJ3HWUuh0olPh5cR2xrlLdu3b0/4vU444QTbjjy8FXmXLl3MaaedZt58802bkNbo5z/+8Y/muOOOsydYgaAFpmovo4Oqrl27xmx5DwDIjl69etngV4V3apMdPmpFxYgtWrQIHU+pc0s4zfWsz3h1XVGRnDP3sxLKzshojRLUtCPvv/++DbS1fvv27c3s2bNDo5113OTnLjsACg/x9G+IpwFEKjrUVH6HHXaYadq0KTsIQCAlE08r0azOqN9++60dvbxhwwYzZ84c07Fjx6jF2O5RzsTSQG4FPqNxxRVX2ETowQcfbC699FITJO4R215aNjrtIzUyJ1EavRPLMcccY6677jpz7bXX2lZEmsPh73//e0Lv4aXtt07W6ssHyGc6qNLfc79+/WyHBQBA7miKEU29Ig888ID54Ycf9hm5pkKhWCccNdezOueocM+Z+1knH93FRTr++fDDD+2UCz/99JN93Y0bN9qCSFV0FxUVMdoZQN4hnv4N8TSASJQ4UUHhgAEDbPc/AAiaVOJpxc4ffPCBWb16tU08KzbWEqkY2z3KuXbt2jZ+1iWdw4DsC/yczs48xRpZGDSVK1cOXffSMlsVSV5bcSdDLbWdkdCaWztRak8Zb9EIdsAPdGCl+UqmTJliExYAgPzkFOVF44xy1rxUOs5x5n7W/dGS07qu4Hzz5s32OSqY+/jjj83DDz9sq8M1BYzmwUp0nmevc2EBgFfE078hngYQjUb4KWny/fffs5MAIIF42h1Lqzvq3Llz7QjoW2+91Xz++ed2wI5i5/BRzk53iSZNmtjbTuewRONnN2JpwLvAj3SuV6+ePcEX3vY5KCOda9asadatW2fbPcaiaiIn6ZypuZNVfaTt0VwP+iAHgm7v3r02saCDLM2P58xxAgDI3UnDSNOVKNCNNCVCeCJZx51KFkca7ewOqFUY6FRua3oT3db96hyjk5buFt5VqlSxx0/OohbdatUdfmyrANvrXFgA4BXxNPE0AG+x/UcffWSPJffff392GYBASiSejhVLa25oxb3ffPONHWCm3IZGUKu4R/kFxcNOcWQ6RjsTSwOJCfxIZ01Kr4M/zQsQRO3atbOX+mCONZpSrR4dbdu2zdj2BDH5D8SjkW5vvfWWDVLdc7EDALJLCdtIAWi0kSvhiWRncY92VmHfjBkz7NQKCqBVwa3kstoxOotu634nWa1jNj1PwfbixYttO+4vvvjCjoJWYvmpp56y3xvqlqFjPD1v2rRpdiSeipn0cyjgBoBUEU8TTwPwRuce1dWPEc8AgiqReNpLLC0axfzqq6/a2FiD2DRFlUZEaxS01tW0heGjnRMdtey07iaWBrwJ/EjnoUOHmueee86eqFPi2UnCBkWvXr3MJ598Ykcxf/nll6Zbt24R13O3u06mIsiLNWvW2FHOUr9+/Yy8B+Bn8+fPtwdNPXr0MC1atKBIAwCyQAlbJXGfeOIJG7yG0zHUvffeazvB6Bipe/fupnz58vtUZmsUstSoUcNWWut+BddaVq1aZZPITvGdPusjcUY7//jjjzbRrEIkBc+HHXZYscpw3a9A2ukco/dX4ZLeU8dbqvhWx5tIc2EBQCKIp4mnASRGx2Q6/lLbVwAodMnE05q3OV4srcc1leZ7771nY1wN2FEXMCWjw6ey0utt27bNlChRwrz55pt2cN327ds9dQBzt+7W+zrJa2JpILrAj3QeNGiQOf744217h7POOsue8AsS/eyO0aNHR1xH++bJJ5+016tVq2b69++fkW157LHHbOWn9O3bNyPvAfidDoo+/PBD884770SsEAQApIeC21tuucVObXDppZear776Kub6ShSrkPHPf/6zefnll21iOF67bCWbtahNmEYy6zG9X7RFrcF0XOa8tqZHiTQ/dDg9riBb6yuoVxX4Z599Zu68805bta33j9TqDIXzt/zII4/YqTqKiopsUYSK1y666CIze/bslF9fJ3j0t3/llVfaY3i1f1dxhP7m9Tfbr18/c/vtt9u2d8nQ36YK7lSU4SzIH8TTxNMAEqPzXu+//77nEXYAELR4euzYsfb8Z6xYWnGwOnspvlUyWDFOpUqVosbRKrxWl7Cnn37axsLjx4+32zRmzBibfFZcHmnOZ2eUs5LdikN0qdt0DgsO4unE7bfXyfIFmE6UnH322bbSRfMDXH/99ebUU0+1CdYg6NOnjx3trBEyH3/8sT2p43bHHXeYq666yl7Xvhk5cuQ+VZpOInrYsGH2w9rNaR3ZqVOnqNugfX/SSSfZD3d9SWjUTybmr1UFlEb96LXjzWMNuOn/Qgczbs2aNTN//etfc7aj9D+ryroDDjiAE7AAkEaqfNaxobrAJEvHkc2bN7cFQqraVoDsUICsgNeZ2kTBq0YeK0hu3769nZcqGj2mk5RqG6bAWO3CFESHj3Z26D00D/Tq1avt4syFpee4n6fta9y4sV10vOTeXviXuggNHjw46kkR/Z4ffPBBM2LEiKTfQyfOjzjiiLjrad41neQ56qijEnp9bZ9OVLkRwuYX4mniacCP8XSuaeTdMcccYwvCAKCQpCOeVpJY8YOKZcNjaSWo9dmpY1DN36zbSkar8DVWPO0lltbr6XUUz2sbXnzxRfsc5Tf02irabd26tS20veKKK+gcVuCIp5MT+PbaAwYMCJ240IeLTsL9/ve/t4sOgJ3RAPHoZKFO6PnRfffdZ9tXqILoyCOPNNdcc41NIuu2Kow0Aln0gaoRDInSh7JeT0HGscceazp27Gg/0EUjdfThrcU5eaRRN5lIOAOFRomEzz//3P4faWRRUAplACCTNOWKkmKqnk6FAlmNKNaUIZHaZasFthbRsaaOJXV8pGNPBbDRaI5mFdBp+/Qcp+W2jrciPS/SXFiqzA5/ntZx2n3rdevWrWuPx5Sk1nbFSoQjP2k+8BNOOCGUcD7xxBPNBRdcYNvSTZ061dx00022EEEjnvW71ojVZKmwQsf7hxxyiL2uvxuNUFaRp47zNfpfAftxxx1n5xdXPOCF/tYVm+hvUm31nKl4kD+Ip4mnASRHXW7efvttM2TIEHtMBgCFIF3xtEYwKzehmEIF2uGUCFYuR7GtYlxdjxdPe4ml1SFMi3JEWl/TsWpqK8XsSlQrxlKcr1bdb7zxhk1Y6/2JlwsP8XTyAp901ihdd4s257oSoPpA0RKP1vVzmzeNQH7++edtBZIqhHRiJ5wSzm+99Zb9EE2WkmNaolEl0T333GMuvPDCpN8DCCId9Lz00kvm4IMPtidxdeADAEiuIjsdAbI7SFGwqmMtVUk7nGScioeU7NXcUzrx6MxN1bRp06ijlt1zWzmjlqM9z8u80pGep2Nbva4WUQCtKnP3Ur16db5vMkzdhW644QZbWKaYJVFqS/fpp5/a63/4wx/MQw89FHqsa9euNsmsJLGO/y+77DI7x1qkv7t4lGzWyP1o1EHq1VdftQlwdTXSz6QktBeXXHKJ7RZw3nnn2b/VSZMmJbx9yCziaeJpAMlTAeKECRPs1Hca+QwAfpbueFpxc6x4Wp+hut6kSZOYcXG6YmnF7ko+q3BXI541l7TOyerzW9unvIli+/CFLmK5QTxtchZPBz7pHKs9W5DatmkE8qxZs+yoZyWX9cGt+RJU5XPKKafYP1AlhZOhk1lqpaeEs6qd9IGuUQr6wNYJS7WmUFWQ2vo5I6ABJJ7Y0EgmVedp7kT9bwEAvFPSVwV46QqQHTreURGjjrWcoqCVK1fa4FNBqxLAGmWq+W7TNWo52vqR5sKK9X7u7xhn/mmHfhZ12ND3jX4GLbqu1/VzMWYhUfcg0e9G0+WE0+/8b3/7m11Uxf/KK6/Y4/5Eeanq18n0/fff386Xpml9vFBiWslqFTloTmhNxYP8RDxNPA0geZqOTieBdV6MYygAfpWLeFoxtEY2x4uLsxFL67W0OIXbbhqprXW1zbp02nfrMpmiX2QH8XTyAv9XPXHixBR2X2FRVdDdd99tl0QowRUrQa8P4rPOOssuADJLVXY6Sdu5c2fToUMHglYA8EhJuVTmnIpFxXYKSjW3rjPHsuZvVtsuVVQrgI03+jjRUcvu9XUCQO2ylTx2KMDVCNd4o6ujUUW5fiYter47Aekko92LAmxOpGbP/Pnz7chlZ6RxtOLR4cOH26SzJJt09srpmOS0lY9Ff5vOPM7633T+3pF/iKf/h3gaQLI0ZZYSJ16nnwCAfJOreFrzMkuseDrXsbQztZa7iFsUH+vncMfP2ibdpvtFbhFPpybwSWe1qwOAQqIDIc3V6MynrhP9AIDoFCzecsstGd1F77zzjv1M1hxSyYw+TrTSWsGzs75EmldanOdp/RYtWqTlO0gV51rcnGS0MyraWZQMJRmdfk5b7Xjxjk6gaBodBdWTJ082maIRzjNnzrTX27RpE3f9v/71r3aetj59+tjEOPIX8TQApMe0adNsIqRhw4bsUgC+ku/xdL7G0hrEp9bHWtzvofhY53L1naCuTypK0uJsNzKPeDpPk87ZmDxd/4CqPAEARJ/ruVu3bqZt27ac1AeAKJ566imzdevWjO4fBa2fffaZPXZNtGI6mUprtfbSaGQvU5doPa2fSdGS0Wo15gTTzsKo6NTNmTMndD1eklePK+msEx36P3DPl5YKjTzQSaE33njDtsd24rYrrrgi5vM0Jc8jjzxiq/v//e9/m6AingaAYFHyQd0j1HVEx0cA4Bf5HE+L32JpfR9oe7SoE4ZDI6Hr169vF03RRRI6c4in8zTprH8OJYWDNC8yAOQbHVCpOkvVehqJkq4TyQBQSEaPHp2V99F8fZr+INGK6WQqrVWhrePwX375Je52KViNNadzJqnNmBKTWhw60apKbgX5OimglmnMdZWYpUuXhq7HGzHVqFEje6m/Fz1Pcy8na8yYMebcc8+NOYL5zDPPjHnccsEFF9ht+fOf/2zatWtngop4GgCCZ/v27bbziOZ3BgC/yOd4Wgollt6wYYNdZs+ebee3rlevnmnWrJldypcvn5VtCAri6Txur+0l4ey000v3ugCA4l+WL7zwgunRo4dto0krUwD4jSqynba/mbZ69WqbVEu0YjqZSmsVGR100EHGj5SI1skA54SARnzqZ9d8qc2bN7fzXiE2tWhzxNtf7oK0TI1419/iY489Zrp06RJzvdtuu82eRNGJk2uvvdYEHfE0AASPRtrpeEffhQCQ7/wQTxdiLK1tdYq3VazkxMsqKNY0Vpz3TQ3xdJ4mnfWHH8+DDz5oK9hVNXLooYeaYcOG2YRI48aN7T+3PrR0skkt1p588kk7Wk+99u+8805z8cUXZ2S7p0+fbsaNG2ffS++t6hH9LOFtvDdu3GhbOjijBzp06JCR7QGAdNFnraoC1ZpFcyQy6hlAUJM4avurVlVqo/XJJ594Om5N13vrs9cZWeq1YjpfK62zRe3PVqxYYZcpU6bYY28lLzUaGtET9454bdcUX7lHWKXi+OOPt6MPnNfSifP//ve/5pVXXjFnnHGGuffee80xxxwT8bnff/+9ufnmm0NxYtCr9YmnASC4dE5SI9hosw0g3yjpqzjaaUmthGe+x9OFHkvr59MUi1qmTZtm4yh1DNP3iBaS0Ikjns7jkc6x3HTTTeb666+3JzmefvrpiG3WNJ9b+/bt7TJixAjz3HPPmfPOO89cdtlltuVBOqvf16xZY1vBvf322/tUlkeqDNEHnFq/rVy50lYf/vDDD2nbFgDIJBXUaNRz9+7dbQtNqt8A/5k7d64N9vA/CnQVGCihrMJFXYYvul+JMPccTprLNpt0DHnggQd6Xl/bq9ZZibY8TjV5mM+UnNSxd8eOHW1Fd9u2bY1fefkOVsFYrPXUzm748OHF7nOfpNYJllgnrdVuzpFqordatWp2cag44PTTT7fzvKnAeMiQIWbUqFH7bK9cdNFF9n/4pJNOMoMHD05pO4KAeBoACpeO4zQAp3///rneFKDgEEtHppghUgwdHl+7Ywc/xNMStFha26/cmTMvsaaqUoxWs2ZNu7iLjkuXLk08TTxdGEnnGTNmmJEjR9rrarMWa14vN52w0EnCoUOHmhtvvNEMGjQoVEmfiuXLl9uR1krEeG3drX/I3/3udzZx/tNPP9lRF0rgAIBfDiY//vhje9K+d+/edt4SAP6hhLO6rijoK3Q69lNgq2RU+GX4fcm+fjZpOykYSA9VclevXj1Nr1ZYKleuHLquFnGxks46ieTIVOtyxW9vvvmmHfV8ySWXmOOOO85W3DueeOIJM3HiRLvd9913X0a2oZAQTwNA4VORXbt27UydOnVyvSlAQQlSLO2M8PUSTycbFxNP++NvXolodQ4TxVz6blE85i4Yxv8QT/sw6fzII4/Y0ShqV3D22Wcn9NyzzjrL3HDDDbZVmxLW6Ug6n3zyyWbx4sX2ug7oNIJ6wIAB9n0efvjhmElwJZ3l3XffJekMwHdUdPPiiy/az1JVCmo0HQB/UJC8du1aW7XqR5q6RAFwvCV8ipN003zB2aQRq5n+mYJASdRCmCbim2++ifqY4pB///vf9jta1dfRqN14rPuWLl1qatWqFfX5ztzZ+tuM9FrpolHOSjoryf3OO+8UKzzWXM7St29f2/I+2hxuDnXAEv0NHHvssSZoiKcBIBg0rZ+mrqA7GZBefo+lnWSyl8XrALtkEU/7j6aTVWt0nQf2e9KZeDo/4+mcfLJqdJ0OmJIdGaznaXSeWs2l6tVXX7WjlLU9vXr1su21K1SoYB+Ld1DXqlUr06BBA5u0mTp1asrbAgC5oKpEfYapmEdzPcc6MQ0gvyhI1vFIvlBAq0ppp/WWqmndl+7r+ZJ41XQu2cT8fKlRUKzjb50kyvYJjkw44IADoj6m1uFOIBhrvUhUSOuYN2+eOeigg6Kuq8dFc6NlMpHvnoN70aJFxR5zOhVoNLSWeDQ/tDRp0iSQSWfiaQAIBk0FqBHPrVu3zvWmAAUn32JpUYwcKXYOj63zqf0z8bQ///ZVxF0IBU3E0/kZT+ck6bxs2bLQ5OzJcJ6nZG+qVG3v/LONHTs2lHD2qkOHDvbn+e6771LeFgDIJZ3Af+WVV2yl2yGHHGKnEQAAUYcaJ7iNFwBrXT/RnEYKtjJdAS56n0IYnZttmgJCvycVRTnzT61bty7Xm5XXVEzrUKGuOjRFsnLlytA8bD179sxKDJjJNt5BQTwNAMExbdo006xZM+JzwKcUZ6q9sZfCbI1M9ptsx9P169fP+PsUIuW8VCCgltqaokoDjxAd8bQPk85OIiPW8PdYvv3222KvkwpnlHOPHj1M06ZNE36+MwJB1YcA4Hc6SJw1a5ZZuHChHfXMwRxQ2LxUUmvRHE9+Vr58ebso0HIu3deVlNMokkxTok3Hv/p89Wsrt2zQMb4CYScgZl8lTiOi2rZta+bOnWuLbO+6666IxbVjxowJXT/hhBNMJr3wwguh6ypwc9NxRzz9+vULdbrKxkmtfEY8DQDBoWPxmTNnmi5duuR6UwC46HhUcbKXeDrb8x6nk2KxaHG0c11deJxC1kxS0pRpAWNTNzD9TlTs7l4YWJQY4unU5ORsl+Zy/uKLL+yiir2uXbt6fq7W16JEcYsWLVLeFqeXebKtatSKwD2EHQAKwebNm207DrXn7NatGwcnQAFUUkeqqvZjJbVDwWasRLJzXUu8wFRz5d1xxx0Z32YFezpmXLx4sWnevHnG389PlJB3ksyVK1cuiFZfufbnP//ZnH/++Wb9+vXmqquuMg8++GCxx1Xd/q9//SsUn0VLOqsw12mHHSnZq8S1RlI7cVEk99xzjxk/fry9rtFavXv3TulnCzriaQAIFhUtKjanYw6QvS5f8RLJuu7nQkh1kIoUR4ff56VT7ZAhQ7IST2uqKmLp3yiJHOkciH5fxNLpQTzts6SzTmgo4awP5lNPPdW89957nuZQ0DzOWt9x4oknprwtzknIZFtB6iSO+H3SdQCIZM6cOfaArm/fvnYOTQC5o2OVrVu3mk2bNtn/S00zsnHjRtsaP2iV1LpUkJyuYOroo4+2CblMzo3lJMlV1PPTTz+Zxo0bB3oErxKUqlRXklnH0clOu4Pohg0bZp544gkzefJk89BDD9lW2hdccIHd5yri/ec//2n/HvW3ef/99yf99zhy5Ehz5ZVXmpNOOsm2IVNhsIoItmzZYk+Sjxs3zm6D6Pf82GOPFcR83LlEPA0AwetONH36dNv1A0ByVHCtWHrFihU2lt6wYYONp8MTyX7u8qX4OFKXr0jxdDqPx7MRT+tnU4wRtFhacbP79+f8Dhm5nHnE08nLyX/nxRdfbD+IdOJDJ00POuggc9lll5mhQ4fayr1wagv31FNP2ZMhzodX3bp17eukqqioyJ7A9dLSLZIZM2bYS1rQAihUP//8s3nrrbdsK0y19ArKgR2QLUoQK/hV8keLrju33de1+G2+ZC+V1OHBcC6Sjwpezz33XPPwww9n7D00ilfJPZ3cULI1SBXa+t7QPtboHI1i1s/vzM2MzNGJpFdffdUMHjzYnqh+6aWX7OKm34PiskGDBqX0XirE/c9//mOXaBo2bGiT4IcffnhK7wXiaQAIIk0Fo5hc86cC+I0GtClX4MTNseJqPyeTnZbJ8eJpJShz0X46G/G0CmdV1Kq4utBiaadAPVLXNop1c4d4Onk5yRzoRNPzzz9vT4Ao4asvh9tvv90uOhHVqFEj+8+lCqOlS5faLwdxWlbohJWer9dJVefOnW2FjOZ21vsk8poaIaC2dKq06dmzZ8rbAgD5TKOV9Jncv39/U6tWrVxvDuCbSupICWT3dRV2+FWuKqkz4ZxzzjETJ060xY7ppmNXHWOqaFJFl4U62tkJlvXzOr9/XU/nqHQkRt/Xn332mU0GP/PMM/bvW/GXCmYPO+wwc/nll5v27duntFvfffddW5ym0czqTLVq1Sqzbt06+7dQu3ZtW2B8zDHH2I5VkeaVRuKIpwEgeHRO9PPPP7cjCjmuQqFTsbUSjF4KszW1lN9bJEeKo923/dAyOZPxtOLJNm3a2DjDr7G0c+7EGbnsXGohXs5fxNPJ2W9vDicf+PLLL+3o5nnz5hXfKNeHaPjm7b///nbUs5LF6fD000/bD0W951/+8hdz6623hh679NJLbSs6PRbeplJfaH369DFTp061j+tkC1X7+U8jLJYtW2bbBCt5BnjVo0cPW5zipjkJ//rXvwZuJyqp0LVrV1tlne8HvUC2KqkjXRZCJXW8RHKuKqkzRZ1vNAeufn/pPJGg4w930ll/G02aNLHHtX6s0I7WAl1/D9n6XtBoH7XlVvK0Q4cOWXlPIN8QTyPbiKeRLOLp9NG5Rz8ePwJOq/hISeTw+5Rw9nOXr/CWyNG6fBVai+RMxNM636BpWZs2bZr3sbTOo4QnlXWpJd8Sy8TTyKScloMccsgh5uuvvzZjxowxo0aNsvM86wslPNGsDxclmUeMGGETxOlsu3j66afbechUIXPnnXfaE1dq9R3LmjVrbLLcSTjr5yDhDCAo9DmtBPySJUvsqGdGLaHQKqnjteVSoOxXhVRJnQkKZNVq+JJLLklLoKz9rWBYhQpqAyZOO7B4FdqaX0wFcuoAVLVqVU/vl8xz4gXNGqnsHrmsRT9XEP8+gHxDPA0AwaPRzjrWK7RkFfxNicBYI5KdS3Xc8StnpGqk5DEtkTMTTytOVuG2M61pJmNpr89ztzp3j1bWdeJk4Dc570Ggf8YLLrjALmovOWvWLJvU1XXNB6A5lzV6QdczQR9Mjz/+uDnqqKPsSeQ//vGPdiS1ktE//vhjaL3XX3/drFixwraNe/nll0NzS+tLRQlzAAgadQ148cUXbdcHHVgC+UidSdzJYyqpOTkVT9u2be2x3bXXXptSazC1FVZF9tq1a+1xrFM0qUvdjjW3s45JNYJx586dZvXq1fZzNl7rsGSe46YgWcllbZsz/3JQiw8APyGeBoBgUdLuq6++st3HgEzSoDD9vcUamexcKgbxKyURo41GDu/yRWyUvXhasbLmsNdlpmPpSM/TAEO9R3hBATEy4IOks5s+NA499NCsv2+/fv1sm+3hw4fbZPKMGTPsIs6XyQknnBBa3xmJre199tlnbYtZAAhqNeuECRPs3CpqmUa1NbL5t1foldTq9KIgR4uqbLU41xVk6WdTQNSuXbu8ny/Zb1RIM3r0aPPkk0/aS6fY0AsFoQMGDLC/v/Xr19vgVb8z91Qtuq0Cy2gV2gqeNSf48uXL7ZQgkYLpcIk8R5/VlStXDi06puXzG/A/4mkACAYN2FE3nXR0tkHwKC5xd/mKFktr8XOXLyUII8XS+vkU3yl2UoKU0an5F09rOkNNpaQC7kzH0mp7raSy1tOxtGJ4jXRWETY5H6AAks65dMopp9iTtmqtrUnv3ZR4Dm/5rUT1Aw88YNq3b5/lLQWA/DNv3jzbDULttjW6D0h3JXV4AOznSmoFteGBb/ilFgU50eZL1okmBVFq/0TCOTMUuJ533nnm1FNPNY899ph59913zbp166Kur+TtwQcfbAYOHGjnmlJVt4oDnM4QOmGjv1sFtU5Q7FRoq4WX0zFC6yl41t+5U1wRq3WYl+coiHYKGLRQpQ8g3YinASC7UwN98skn5uijj2bkJfbp8hUvllbCOfw8t1/oHL0Sg9FiaPd90abndMfS6ZzCE+mJp1UIoO6zixYtSmss7YxYdk8dpes6n6L/HY1y1nO0KPGsKWGV96E4G0gcSWcXfZB88MEH9stn/Pjxdp4UfQnpS1kfQnXq1DHdunUzxxxzjOnSpUsSuxsACpc+K1977TU7JULnzp1JhCFqJXW0tlyFUEkdL/jVQsLPXxTYqq1X7969baAcXqWtYFXHiFoUKCsIVuW1TgbWqlXLrqOTOgqWnQBZ6zrddLSe1g+vzHYS1rFah0V6jl5X/28NGza076cuFIm02QaAZBFPA0D26Hylir+VoEHhUhzhtcvXtm3bjF8p8RctjnbfVrxF0XVhx9NKLqcaS+v/QQUF+t/RiGm9rs5TRjN79my7XSoe12vrUu+v+w866KAM7RmgcOXFGajp06ebcePGmU8//dQsWbLEnjDTh0b4iWdVIH322Wf2uk6kKbGRCXrdTL02ABQyHQyqGlAViX379rUHgyhcqgZ1B7tUUlMlXYg0YtkdgEYqqtCIdHeltZLD+jxUwCuaE0qPqWJal6rOd7pCKBh2ksnuymxdr1u3rn3faKOd9b4K4lUxrm1T4UPLli1tZbier8vu3btnbV8ByA3iaQAIpilTptg2sDq2hL/ovLe6fEVKIocXaDsxhR8pVnEnk6MVZivxGK3LF4IVTys+VtzrNZZW0aPOPaq4X++lmFjXFWMrHlZSWsnjjh07Rhy1rPNaOo+pVt56T+d5us1oZ8CHSec1a9aYc88917z99tuh+5z2HpE+hDTa+IILLrAfUurt/8MPP3h6H+dE3rBhw8z1119f7DFVwIg+tFT5AgBInYqEXn/9dXvwp84QtKMpvEpqZx6kQqykdl+nkhr6PFMgrBN68+fP32cEgT7flBx2V1qrvZcz/5OSv5MmTbLHsXquLhUcK+gNH4HsHrGsYNpZnABcx86dOnWy9+lvUydn1KFHlwqMVY1dvXp1U6NGDaqzgQAgngaAYFOyRG22Nb1LpPOoyD7FDeHdvKLF1Yod/EoxjTuJHKvLF4It0Xha8XOsWFpx8ODBg23sq+vO+caZM2fa569atcrGw17jYvco50SeByAPk85qA3PooYfakc1e55HQh8jvfvc7mzjWaA9V9HkZvbFw4UJ78BVp3gCdFNRjF198sbn//vuT+lkAAPvSZ/u3335rP4N79eplKxWRn5XU4ZeFVEkdrS0XldTwSgGm/n9UjKFjT1VYu6kqW8WQ4aOWE22XHT7KWS3IdJKmSZMm9nNUFdsKhnXs6gTW4VXZ9erVs/craJ8zZw7V2UABI54GAIjOq37//femdevW7JAMclr2OnF0pFhai2JuP8+XrCRevMJsLQwsQDLxtAqlVXituFZttDUYQH9X0eJpxcyKeVXYrXM4eh0lhZWAVmLYkWxcTDwNFFjS+eSTTw6NMm7Xrp259tprzYABA8wNN9xgHn744ajPO/3000OjlTUPAC0DASC/6eDwnXfeMS1atLDFRkqcIHOV1LHaXRdCJXW8tlxUUiPd9PfVr18/e/3ZZ5/d53ElnSONWk60XbaOi/X/rAC6QYMGNth2RqzoPlVsFxUVFau0Dq/Kdv7+9TlLdTZQ2IinAQAOTUVYv3592mwnSMlhHUvH6u7lXFfCzK8Ub8QakexcKuFMi2tkMp4+7LDDzDPPPGOLZdQKWwlkjSaOFE/rtv7/NLDASUZHa3udbFxMPA0UUNL51VdftSNFdCJNo9/UXlvVKhKvHUyrVq3siThVdk+dOtXT++mDRtUzOkgAAOTGggUL7FynPXr0sJ/ltP+KTdWZsUYjU0kNZF+klvIq5ggftey1XbbzPKddmAJqBdc6aagEtEMBskZYuwNscVdzax0ltmM9hxEJQGEgngYAuOlYUC1o1XKWOPt/U954KczWSEe/0vnuWElk51Ln3Pm7QD5wJ3n1NxmpC5hiYnX7WrFihY1fNadzrLbX4aOVvcbFyT4PQJ4mnf/73//+9ualSpmxY8eGEs5edejQwSxbtsx89913ntbX5PKqoPnqq6+S2l4AQHqoAOijjz6y7b/69OljK2mDhErqfedLppIafqGgNHz+KVFyOHzUcqRRzk77L10qqNb9CqSPPvpoW0ypoFsBtGiuq0icAFtV4eIE7F6fo2NoAP5HPA0ACKfzpGoj6xQnFiIdU8dLIutyy5Ytvu7ypSLVWN29nOtKzgF+EZ7kVaH1okWLinUB01RSutT/rzomemmXrTg3mbg42ecByNOkszPKWaPd9GGSKCWRZc2aNZ7W79atmz25pwqYiy66yAwfPtx+WLlPdOuAxGn3nSzmKwUA7wHxiy++aNtta+4pv1fdxqqkDg+IqaQG/EnHke7Rxw7dp0A4fLRz+ChntQQTXSrxrM8CnSxSBwh9Nuh1GjVqFHc7tN7GjRtD1xN9DgD/I54GAESijpANGza0x5h+4nSnjNfiWvMl+5XOQXudLznStD2A34W3sla3L6cLmEYxq4jCmdv5m2++8dwuO9lYWpfE00Bm5ORbTG0RRImGZDgfNDoo8WLEiBHmhRdesNcff/xxu4SPPHvyySftkiwlTNwtGAAAsSnhohZgqmzs3bt3Xs71HKmSOtJloVRShwe7VFIDxauyIx3r6TgyfI7m8FHO+l/SZ4S6++j/TUG1KqnXrVtnX/eYY46xj3uZK07Hwc48VMk8B4D/EU8DACLRcac6ix133HE5L+zWMbK6BHlJJns9v5uP1G433ohkLUqw0eULQRU+ylmDAfX/rwSyirAVQ6sjYpcuXez6ibS9TjaW1iXxNFBASWfnSzbZE/T6YJFq1ap5Wv+II44wV199tbnttttiHgwBALJv4cKF9uTp4YcfblvlZIMORmPNk1woldRO8phKaiA9VdkKhvX/pGBVx7EKnkuWLLnPXFQKnJ1Rznpcx646IRV+8s+p0Fb3h379+iW8Xck8B4D/EU8DAKJZtWqVHSWYqTawOgZW0XWs7l7OdT8PzlFRfLw4Wte1Xq4T/IDfRjkrntZnhLqAqc22utnWqVPHrqfj3ETaXicbS+t/mHgaKKCkc1FRkT2Rr0RDMmbMmGEv9aHk1b/+9S9z7LHHmqeeeso+XycBdaJQI+x0cKBRJ85cewAQLlJLVSUulVRwWqYieaqAfvPNN+20C+3atUsqaKOSmkpqINNV2WrZpU49OtmmE3r6blBQrEDXPdpZ7fbVHqxNmzbFviMUPCsBrWNOp7sDra8BJIp4GoDfEE9n1/Tp0+0xqdfBOs4xr9f5kv06cMc5/+tOIocXaTv3cZ4HyMwoZyWK9VmiGFqfURr1rMSyM3JZMXekttfE0oB/5CTp3LlzZ3tSTnNR6aBFX+ZeTZs2zSxYsMAeKPTs2TOh99XcoVoiVYkPGzbM3H///Qm9HoDCpoMgFaqMHj06VOzitmLFCnPZZZfZAyF9tnTv3j0vW0T7hZI4kydPthWOaret0YFeKqndAXEhV1I711URSiU1kD1z584tVmn93Xff2YSzPm+0KFDW/6Qz2lmfYWppqPZg7hZfWvezzz6zJ7AUeOt4WCOnaX0NIFHE0wD8gHg6d5Sw0VRWGnyj1tWxuns5lyoE9yudO3Anj6PF0ppT2TnPACC38bRiZcXGSjornnZGLuvcWPv27YmlAR/LSdJZBz2aY1kfOLfccou59dZbPT1PJ+guv/zy0O3jjz8+g1sJIKiUGLj99tvt51O89sqq8FU7VS2vvPKKGThwoDnqqKMIZDzQvlMwHL58/vnnZurUqfa6AuBCrKQOD4CppAby18aNG4tVWqsCWwGyRixrbjYtTgGlRjfXrl3bNGjQwC5uM2fOtCNOVMWt12rYsCHzLANICvE0gHxGPJ0dKs6OFE87y/Lly82nn37q6ymjlJCKF0trqVChAvMlAz6LpzXqWQXcWpRsFq2n/E9422tiacBfcpJ0Pv30083IkSPtaOc777zTtsnWaMFYNGpk6NChNhGhk/iHHHKInf/TCyWDRAck4a1l+vbtay9btWqV9M8DoHDMmzfPnH322ebLL79M+LmqIH7ttdfMV199Zc4///yszU+cj8GvEwDrhEO0YFj3x6Ln5mvC2amkjhQAU0kNFJaDDjrIfl4pMHZGK+vElk7g6USYRis3adLEjpxo2bKlOfjgg2O2FFPrbad1mCq4NdczACSCeBpAviKeTl2sRLJ78ULHqhrBnG8xtY6lvRRm0+ULKNx4WgXbKuBWPKy4OFoXMGJpwH9yknTWh8jjjz9uRwPqw+aPf/yjbWGr4PnHH38Mrff666/b9rVqt/ryyy/bkdGiD6ZRo0Z5fr+mTZvaRPXFF1+8Twvt4cOH28fatm1rgk7zW2v/vPXWW2bJkiX2w79Fixbm1FNPtftO+z0d3n77bfPYY4/ZOWZUTKA5ybp06WIuvPBCM2jQoLS8B5CML774wn4uafRaKlToopHS6sygRERQKqmdJV0Brb4rlMTRaOds0eeel7ZcVFIDwaH/fafS2qmw1ueS5mXWsamOY1RkdMopp0RNIM+ePTvUUszdOkz3hwfVABAP8XR+Ip5G0BFPJ97ly12Q7RRsp5OOO51iyUzTeyl+jxRHh9+m6BIIjmjxdM2aNe1ngW7H6gJGLA34T06SzqIPm6efftomfXUSTvOlOnOmOnNVnnDCCaH1nSSG2pQ+++yz5sADD0zLdpx77rmhhLQSn0H1xhtv2NGd7uSOqiEVNGhRkYCS0RrBkywdPCuxHF4wsGzZMru8+uqrZsSIEebRRx+lLQ5yUpGdjoSzQ0HdfffdZ6666qq8H/GczkrqdHMSzxrxnOlKame+ZACIxF1hrVZgKir69ttv7bGT5nP2+rzmzZvbIktGOwNIBfF0fiGeRtAFNZ6O1dUrkS5fmS6sVlc2JbWTjcndcXS0WFrna5kvGYDXuLhZs2Z20FusuJhYGvCnnCWdRSNC2rVrZ1trT5w4sdhjSgSHj5ZTYP3AAw/YD6Fk5Fs7mXyhVsCnnXaaTf7rIPFvf/ub6d+/v7393HPPmf/85z92/sGjjz7aJqCVAErG3//+91DCuVOnTjZ40EjqBQsW2FGh2g4ltzViSHPpAtmigxgVXaQrQHYHyk888YS5+uqrsx585aqSOhN00KmWO+HV2bEqqcOrqqmkBpAqd4W1RjlryhYdN23atMkWy0UbtRz+vOrVq9tLRjsDSBXxdH4gnkbQFWI8ne0uX5mmIuzwDmJKRseLpZ0uX87gIABIVnhcrJHO+pyPFRcTSwP+lNOksyiB/MEHH5hZs2aZ8ePHm88//9wsX77cnsBTkqFOnTqmW7du5phjjkl6JLJOCOpDTK2csS+1ANaHvqoXJ0yYYHr06BF6bMCAAXa+ayWIlXi+66677HzcidJzNX+3dO7c2Xz88cemfPny9rZ+r8cdd5ydX1tJ7TvuuMOcd955KY2qBhKhv7lk5nD22mbv3XffNYMHDw5MJXWqFNAqgaPPJF3qBIOCXRWp6PPICYKVcNbjAJBp4RXW9erVs/crWNbx5bp16yJWZ0d7nkbszJkzh9HOAFJGPJ17xNMIOj/F0/nc5StdnBg6fNHgEsXUTmE2Xb4AZEukuFifS7HiYmJpwL9ynnR2dOjQwS6Z0KhRIzN37lzz6aef2g+2MmXKZOR9/GjatGnmk08+sdfPP//8Yglnx5VXXmlGjx5t96HaG2nEcqKjBu+9995QKx+NVncSzg5VTup+vb/Wu+eee8xDDz2U0s8GeKECl0yPrH/nnXdsgBf+d1/IldTRksmRgt/wJVoiWZXzKkSqXbt21rcdQLCFV1jrJJ2OKXWpz6Vo1dmRnif6PmC0M4B0Ip7ODeJpBF0+xNPxunwVQmG2eI2lo41K3rFjB4M7AOREMnExsTTgXzlJOuvDRNSW8Lvvvst421O15VbCdMWKFXaU7RlnnGEratyJDc0/8+STT6b0Puecc47xG82j7J7fOhLtJ/1saru9ceNG2wr9yCOP9PweCgBee+01e71Nmzame/fuEdfT/fvvv7/9m9D6Dz74IC18kHFPPfXUPm2b003zJ6m449BDDw1UJXX4kmpLLp0kUJeEE088kRHOALImvMJawbAK5LQoWFbnBc3pHF6dHe15Dt1WMQ1zOwNIFPF0/iCeRtBlK55WHKhBCkEozHbia3fnr3S0F1+1apVZvXo1RdwAsiqZuFiIpQH/yknSWfOI6KBQyeBszLN56aWX2nlg9MGmKpl//OMfxR7XtqjFt5ZUDhT9mHTW6G9RK/NDDjkk6npqfe2YPHlyQknnn376ybZMD3+daO+jpPOyZcvMwoULTbNmzTy/D5AMjeLPBv3fqOgiSJXUmaADUbXeOeCAA7L2ngCCTYWLTlW2M2WIOCc5dUJQnOpsra8Rh9GeFy78eQAQD/F0/iCeRtBlK57+7LPPTNu2bY1fOMnieAXa2Z4u6ptvvjGHHXZYVt8TQLAlExcLsTTgXzlJOhcVFWW1uk6Jnueff96O5NVIlEj8XBmZCueDXPMnOydNI3Eny5zneKUEUaTX8fI+JJ2RSarInjlzZlZ2sqqKVd2XjUKbVFtcO4FxvpoxY4Zp164do50BZIW6vCjBrOlaHAqANZezgmJNEeLQelo/2vOicT8PAOIhns4fxNMIsiDG09nq8pUpP/74o+3AFmvqLwDIRjytQSXq3uP+PHLHxcTSgH/lJOncuHFjm3RW24RsOe6448zixYvNm2++aRMWSj7rgHXs2LH2YFBtnbt162aCRPO5OL+Dhg0bxly3evXqdjS0goolS5Yk9D5Lly4NXY/3Pu4voFTeJxqnjbGKDDLdAgr5b8qUKVmb10l/c/obbdCgQVaC32iV1fEqqbU/tLhb3eQbtVdTsKxpEoCg2rZtm/0e16KADZmjY0TtY332iD4f9f2hz1Tt/44dO4YK98qWLRtaP/x5sbifB2+cv3/9L3BMlzuKD5B9xNP5gXiaeDroCimejlWM7V7i8cP0WepG2KRJk1xvBpAzxNL5E0/rfnX7Co+nhVg6s4inc69iAcfSOUk6DxkyxEyfPt3OyaKDsWyNqNMv8rTTTrOLQ0lnOfzww839999vgmTLli2h65UqVYq7vpN0/vnnnzP2Pu5/tkTfx8tIIofafXv5mYF0euaZZ9ihAFBgUpmeBfC7oHaLyjXi6fxAPE08jewingaAwkM8jaDaW8CxdHYnD/l/5513nqlWrZpZt26duf3223OxCfj/ihZHmTJl4u4TVRtJoqNwEnkf5z2SeR8AAAAAKHTE0/mBeBoAAAAA8mCkc926dc3o0aPNqaeeaq699lrb3vqqq67Kyfyc119/vb3s2rWrCZpy5cqFrv/yyy9x13faYCQ690si7+NuQZno+3hpx92lSxezcuVKU79+fTN//vyEXh+F59lnnzUXXHBB1t7vzDPPtJ81ufisKzQHH3ywOeigg3K9GUDOzJs3z04TguyaNWuWbQU2e/Zsm2zQMU779u1N9+7dbVswZJ/mdmzTpg27HoFCPJ0fiKeJp4MuF/G0psXL1/mS/XTsdPbZZ7MfEVjE0vkRT+t8hj6PiKdzi3gaBZN0VlttzRE8cuRIm/T9+9//bh566CFz8sknm0MOOcQUFRV5Tjj26dMnLUnnIKpcuXJCrayd+fISbUudyPu45+RL9H3izRctTit3BSmF3Dcf3rRr1y6ru0p/o4kWUyCy1q1b8z+MQNPxErJLhXM6htV8U/os1+9gzpw59vbGjRttMYyXzjEAkCri6fxAPE08HXS5iKfdxR5InvajM4cqEDTE0vkRT3fu3Nkmn4mngcKTkyOMfv36FauoU//yZcuWJTynsl5Dk88j+YPMmjVr2jbnS5cujbnuhg0bQgnhROZODk8Gx3sf92jlRN8HSJRGymrU8Z49ezK+8/R5xd90ejRp0sQWJwFANk2fPt0Wzy1atMjUrl3bLmvXrrW3NepQj/fs2ZNfCoCMI57OD8TTCDriaX/SYAxnQAYA5Cqe1nk9XRJPA4UnZz1elWh2lkj3eV2QnsrUH374IWYCX61HHG3btk3qPcJfJ93vAySqQoUKWWvRrIQzI+BSp30YxOkQAOS+Knvy5Ml2ig5NBdK0adNQEYxu63497mW6EgBIB+Lp/EA8jSAjnvZvTE2LcgDZRDwNBEtORjqrJXY2D3DOO++80HW976hRoyI+lorw1/WLXr16mU8++cSOYv7yyy/t/DiRTJo0KXQ90VE8zZo1s3MoL1++vNjrRKI2G9KgQYPQCV0gk84991wzY8aMjO/kQw89NOPvUejUcmfgwIF2egYAyGVVtk6yiqbqoDobQLYRT+cP4mkEHfG0/5QtWzbXmwAgYIingWDZb28Ahgurfa47yb179+6oj6XC/bp+MW3atFCi+aKLLjKPPPLIPuuo9fABBxxg5s6da6pVq2ZWr15tJ5lPxB/+8Afz73//217//PPPTffu3fdZZ8qUKaZHjx6h9TXPd7qp1bdauSupHa/VN4Jh06ZN9u/BPZ94JoK62267jfmcU6D2X0ceeSQtygHkpCr73nvvtV1h5s+fbztkKNns0PfHzJkz7VzzLVu2NFdccQWdLQAUFOLp6IinEXTE0/5Tr149c+yxx+Z6MwAEBPE0EDw5a6+dbbHacSfT1rtQ2nyrTW3v3r3tdY3UVkI43F133WUTznL55Zfvk3D+6KOPbOJey/DhwyO+j07AOnPGXHrppWb79u3FHtdt3e+MZtT6QDZUrVrVXHPNNRl9D43OLV++fEbfo5BVrlzZDBkyhIQzgJxQJxhnlLMowaxW2s6i26LHtZ7WB4BCQzwdGfE0go542n8aN26c600AECDE00Dw5KS9draNHj06qceC4r777rMts5X41UhCJeD69+9vbz/33HPmscces+tpBM+VV16Z1HvouX/5y1/Mrbfear744gv7fldffbVp0aKFWbBggR0F+tVXX9l1tV6rVq3S+jMCsVx11VXm5ZdfzkiiQPN9HnXUUfwCUth//fr1owUYgJxZu3at7Wbj5dhE62l9ACgkxNOxEU8j6Iin/aV58+a53gQAAUI8DQRPINprI7433njDnH322Wbz5s1Rk8ZvvfWWbRsZTiOdlaSWYcOGmTFjxkR8DbXpvuCCC8wTTzwRdTvOP/98m+RWC7dMoL02opk3b54thli/fn3adpLaryoAr1u3Ljs+Qep40KVLF9vaP11TIABAMjZs2GA+/vhjT9Mw6HNfc60y9zwABAvxNIKOeNofioqKzAknnJDrzQAQIMTTQPAEYqQz4tN8LrNmzbJV2koua77jMmXK2CTzKaecYi655BJToUKFlHalEslq4X3SSSfZxPL06dNttVOtWrVscklzSg8aNIhfF3KiTZs2ZsKECXa0fzoSz0o8qB09CefEaZ/17dvXtmoDgFxTAlkt/gEAiIZ4GkFHPO0PzZo1y/UmAAgY4mkgeDI20nnx4sVR5wwJfywVzEWCRDDSGV4qtDXqP5VW22oJfd5555FwTpDmi1cBSvv27RndDAAAAo14GvmIeBrxEE/nd7x9+umnm/Lly+d6UwAAQAHLWNJZo1qdlqi6/PXXXyM+lorw1wXiIUiGF/pcuf32280tt9ziqZ2qo2zZsmbgwIF2DueSJUuysxPQqFEj07t3b1OpUiX2G4C8t2zZMluc1LlzZ1O/fv1cbw6AAkQ8jXxEPA0viKfz08EHH2yPXQEg14ingcKW8aSzXl6Xu3fvjvhYKsJfF4iHIBmJ0BznTz31lJ2HfMaMGVE/h5QwPfTQQ0337t2pGk6Qqqy175o3b87oZgC+8Msvv5h7773XbNmyxVSpUsVOpaApSQAgnYinkY+Ip5EI4un8Ua5cOTvKmWNWALlGPA0UvozN6ay219FGM8d6LBNuvPHGrLzPddddl5X3AZAdSiZcfPHFdunataudh9ytXr165pprriFwS1KrVq1Mjx49bAAMAH6h74Kff/7ZzJo1y3Ts2NHe7tmzZ643C0CBIZ4G4HfE0/mjU6dOnLcAkBeIp4HCl7Gk88KFC5N6LBNGjhyZlSQ3SWegcEVql61kKZXCiVMLbbXS1ghxAPBbVfbkyZPNypUrzaZNm+ylbms+er4PAKQT8TSAQkI8nTuVK1c27dq1y+EWAMBviKeBYChhAkKtvL0u8daP9DgAIL62bduak08+mYQzAF9XZS9atMgWNOpSt8M7YQBAoSGeBgB/UsF3pKQ/AGQb8TQQDBkb6ZxPrr/++rjraLTKww8/bHbt2mUD6gYNGphu3brZtmYVK1Y0W7duNUuWLDFTp041S5cutc8pW7as+cMf/mBbBgEAotPnaJ8+fUg2AyiIquydO3ea9u3bm9mzZzPaGUDBI54GAH9q3bq1nYsdAHKNeBoIDpLOxpj58+ebwYMH2w+/Dh06mDvvvNMcfvjhUXfaBx98YK688ko7l99rr71mxo8fbw/kAAD7atGihenVq5ct1AGAQqjKrl27tikqKrKXul23bl3mdgYQ2KQz8TQA5J/y5cubHj165HozAMAingaCIzDttaPZvn27OfHEE81PP/1kDjvsMDNlypSYCWfRehrxrMsff/zRPn/btm1Z22YA8APNbzpgwAD7WUnCGUAhVWU3bdrU3t+kSRN725nbWesBQJAQTwNAfurZsydxOIC8QDwNBEvgk85jxowxc+bMscmRp59+2pQrV87TjlMC5amnnrKXc+fONaNHj874LwsA/KJevXp27uaWLVvmelMAIO1V2RUqVAhNHeCMdmZuZwBBRDwNAPnZbaxZs2a53gwAsIingWDJedJZI4QfffRRc8opp5hWrVqZ6tWrm1KlSpmSJUvGXbReqp599ll72a9fP1OnTp2EnqtWiv3797dzQD///PMpbwsA+F2JEiVM165dzTHHHGMqVaqU680BgLRXZdevX9/s2rUrtOg2o50B5ArxNADATUWRmt5qv/32Y8cAyDniaSB4cjqn8wsvvGB+97vfmY0bN9rbSt5m2w8//GAPxBo3bpzU8xs1ahR6HQAIsqpVq9p22prnFAAKxZdffhka5SwzZ86MuJ4zt7PWZ/48ANlAPA0ACKdBNUxvBSBfEE8DwZOzpPO4cePMOeecs0+y2anEC09AR7s/VRs2bLCX69atS+r5zvOc1wGAIGrbtq3p3r27KV26dK43BQDSau3atWb37t22I088Wk/rA0CmEU8DAMIdeOCBpkGDBuwYAHmDeBoInpwknZWo1QhnJZCVoLjpppvM8OHDzY033mgeeughm2Des2dPaFTJxx9/bB577DHz9ddf23atun766aenZVvUUnvx4sVm4sSJtjViItWAWl/PE83nBwBBU65cOdOnTx/TtGnTXG8KAGSE2hPquHTr1q2e2xkCQCYRTwMAwtWoUcNOdQUA+YR4GgienCSdNYezTtwpuXzLLbeYK6+8MuJ6SjC3b9/eLkpS33777eZvf/ubOeuss2xCesSIESlvS8+ePW3SWS2+r776anPvvfd6fu5f//pXO8JZP4deBwCCRBXUat2lJAsAFKrq1aubIUOGFLtv2bJltk1Y586d7ZzOAJBNxNMAALdSpUqZww47zJQsWZIdAyCvEE8DwVMiF2/6wQcf2MsqVaqYyy67zNNzlNhVUvgf//iHHSF9+eWXmwULFqS8Le7E9QMPPGBvx2uVrQT1hRdeaO6///7QfboNAEFQokQJ061bNzN48GASzgAC55dffrFtbadPn24vdRsAsol4GgDgpoEwSuwAQL4jngYKX06SznPnzrVJ5Fjzf2pOvEiUdNaB1I4dO8wTTzyR8rb079/fnHvuuaG5okePHm0aNWpkTj31VHPPPfeYl156ybz99tv2UrdPO+00+/ioUaPsc/RzDBs2zI72A4BCV7lyZXPccceZjh072s8/AAgaJZvVcWfWrFlmy5Yt9jYAZBPxNADA0apVK9O6dWt2CABfIJ4GCl9O2muvX7/eXjZs2LDY/e4E9Pbt22177XBlypSxCd5XXnnFJoNvvvnmlLdHc0Tr/Z577jmbRNm2bZtNMmuJxElQyymnnGL+85//pLwNAJDvmjVrZvr27Ws/hwEgqFXZkydPNitXrjSbNm2yl7rdpUsXPhsBZA3xNABAqlataudLpSAcgB8QTwPBkJORzs4cI+GjnNVu27F8+fKoz69Zs6a9XLp0adq255lnnjFjx44NJcKVWI62iEY7jxkzxiaqmTMFQCFzOlMcfvjhJFUABJpTlb1o0SL72ahL3Wa0M4BsIp4GAOic6hFHHBG1gyQA5BviaSAYcjLSuVatWjZhvHnz5mL3u0c+f/PNN1Hbw+gEn6ilYToNHTrUnH322ebdd981EydONF999ZVZs2aNPZmoUddFRUWmU6dOtiX3kUceaec1BYBCVr58eZtsrlevXq43BQDypip7586dpn379mb27NmMdgaQdcTTAAB1IatRowY7AoAvEE8DwZGTpHObNm3MkiVLzI8//ljs/oMOOih0/eWXXzYnnXTSPs9dsWKF+eyzz+x1JYHTTaNWBg4caBcACPoJzaOOOspUrFgx15sCAHlVlV27dm17HKpL3a5bt659vGfPnrneTAABQDwNAMGm86fNmzfP9WYAgGfE00Bw5GSortq0ikaH7N69O3T/IYccYkc7q4X1888/b8aNG1fseRrZPHz4cLN161abHNa8JQCAzMzffOyxx5JwBoAIVdlNmza1+6VJkyb2tjO3s9YDgEwjngaA4NJ0f126dMn1ZgCAZ8TTQLDkJOmsOUdEo0WcUcuiRPIVV1xhryvxfM4555gOHTqYs846y5xwwgn2xN77778fWv+SSy7JwdYDQOFXTaulNnNDAUDkquwKFSrY+9UJwhntzNzOALKFeBoAgqlq1apmwIAB9vwpAPgF8TQQLDlJOqv1YP369W1ieezYscUeu/zyy20Qrcec0dDPPfecef31182mTZtC919zzTXm0EMPzcXmA0BBUuDau3dv07VrV4JYAIhSla1j2F27doUW3Wa0M4BsIp4GgOApV66cnQqwbNmyud4UAPCMeBoInlK5SmwsXLjQttYuUaJ43rtkyZLmjTfeMCNHjjQPPvigHTXi1qBBA/PPf/7TttkGAKSHRjUfdthhpnHjxuxSAHD58ssvQ6OcZebMmRH3jzO3s9bv0aMH+xBAxhBPA0Cw6FzpUUcdZUc6A4CfEE8DwVMqZ29cqpRdIilTpoy55ZZbbOJ52rRpZvny5TY53bx5c9OpUydG4AFAGqk9rCqma9asyX4FgDBr1661hZKtWrWKu2+0ntYHgEwjngaA4Ojfv7+pU6dOrjcDABJGPA0ET9aSzkocP/zww3ZO5h9//NFs3rzZVug1a9bMzh36+9//3o5iDk8+9+rVK1ubCACBU6tWLVsxrcQzAGBfOhbds2eP2bp1a9zdo89Sjl0BZALxNAAEU7du3ewgHADwI+JpIHiyknR+/PHHzWWXXWbnuxNnXuY1a9bYahdNJn/33Xebe+65x1x00UXZ2CQACLyWLVvaOZzVWhsAEFn16tXNkCFDit23bNky2yasc+fOdk5nAMgk4mkACKb27dubDh065HozACBpxNNA8BSfUDkDnnrqKXPhhReaHTt2FEs4O5zbevwPf/iDefLJJzO9SQAQaJquoGfPnrZFFwlnAEjML7/8YsaNG2eLJnWp2wCQKcTTABBMGt186KGHMsUggIJCPA0UvoyOdFYL7UsvvdRe32+//WyCuWPHjvagSVUuGzZsMJMnTzazZs0KPa4R0ccff7ypUqVKJjcNAAJJn63MBwUAyVOy+eeff7bHrzqu1W0V8gBAuhFPA0Aw1atXz8btOlcKAIWEeBoofBlNOmvUsgJlHSRp/uann37aDB48eJ/13nrrLTN06FCzceNGs2XLFvu8Sy65JJObBgCB07ZtW9O9e3dGNwNAClXZKphcuXKl2bRpk73U7S5dupgyZcqwXwGkFfE0AARPzZo1zVFHHWVKliyZ600BgLQingaCIaPttd9///3Q9dGjR0dMOMvRRx9tnnjiiYjPAwCkpmLFimbQoEHM3wwAaarKXrRokS2q1KVu634ASDfiaQAIlkqVKpmBAwdSzAigIBFPA8GQ0aTz119/bS9btWplhgwZEnNdtdTWemqxrXaFAIDUKCFywAEHmFNOOcU0atSI3QkAaarK3rlzp2nXrp29dEY7M7czgHQjngaA4ChbtqwtFlfROAAUGuJpIDgymnRet26dTXqo5aAXXbt2DT0PAJC82rVrmxNOOMEceuihVEkDQJqrsvUZW1RUZC8Z7QwgU4inASAY1Er7yCOPNNWrV8/1pgBARhBPA8GR0aSzTsxJtWrVPK3vrOc8DwCQmPLly9s22uouUatWLXYfAGSgKrtp06b2/iZNmjDaGUDGEE8DQDD069fP1KtXL9ebAQAZQTwNBEupbLyJRjv7wfbt282bb75ppk2bZhYuXGg2b95sdu3a5fln/OCDD4xfbdu2zTz44IPmhRdeMAsWLLAnUNWOV/NtX3bZZfakaiq0P5s1a+Zp3WHDhpkxY8ak9H5A0JQoUcK0b9/eHHzwwbYtFwAgc1XZFSpUsPer/aEz2rlu3bp2vZ49e7LrAaQV8XT+I54GkKzu3bubFi1asAMBFCziaSBYspJ09oM77rjD3HTTTUmNstY81H45ERDJDz/8YAYPHmy+//77Yvd/9913dnn88cfNuHHjzDHHHJOzbQQQnQpEevTo4bmrBAAg+ars+vXrFytK1O3Vq1eH5nbWtDJlypRhFwMIFOJp4mkAiWvXrp058MAD2XUAChbxNBA8JJ2NMSNGjDCjR4+2yeOg2bJlix3N7CScL7jgAnP66afbFr0TJ040//rXv+yI79NOO82eSD3ooINSfk8l99X6NxrmsAG8qVq1qp2zWUlnAEBmfPnll6FRzjJz5kybfNYxVOXKlUPdJZzRzlpfhUAAEBTE08TTABLXoEEDG8/7eRALAMRDPA0ET1aSzmpXfeONN3paz+FlfbnuuutS2ra33nrLPPHEE6GDPCVvzjjjDNOpUydTs2ZNU7p0aVPoFenz58+312+//Xbzl7/8JfSYTphqXpm+ffvadmFXXHGF+eijj9JyYH3AAQek/DpAUGkEndpoq512yZIlc705AFDQ1q5da3bv3m1atWplb+v6119/bcqVK2ePH9u2bRv6LNZjWh8A0ol4On8RTwNItoD88MMPt9NkAUAhI54GgqdUtvr2a/HCSf7ecMMNWUk6q3W048wzzzSjRo0KzHyoag15//332+s6YXrllVfus46qLs8//3zz6KOPmkmTJtnfo9pGAsiNli1b2jmfnPlEAQCZ1atXL7Nnzx6zdetWe1tTj9SpU8csXrzYXmpO5/333z80x7PWB4B0Ip7OT8TTAJKhc44DBw4MzLlHAMFGPA0ET1aSzplqW52OFjRTp061lzphqAR0kA761D5706ZN9vqwYcOiVlgOHz7cJp3llVdeIekM5KgSumfPnqZhw4bsfwDIIk374UwLovmo7r33XlNUVGQ2bNhgL5VoPvnkk5nHGUDGEE/nJ+JpAMmcx9QIZ8X3ABAExNNA8GQ06dynT5+8n5tk/fr1dhv79+9v2yQGyaeffhq6rhba0XTu3NmOqlSLbc3rDCB79PmkudTVTptW2gCQ+9GGzvzO+nx25nHW/SoMAoB0Ip7Ob8TTABKlrmWacg4Agoh4GgiGjCad0zH/b6bVqlXLrFixwlSuXNkEzZw5c0LX27RpE3W9UqVK2Za+s2bNMnPnzk35fR944AFz0003maVLl9qR5Rq52bt3b3PhhRfaxBqA3+hzacCAAbZ9KwAgtzTKWcV3K1euNDt37jTt27c3s2fPtrd1v6YfKVOmDL8mAGlDPJ3fiKcBJKJ169bmgAMOYKcBCCTiaSA4stJeO59pLmMlnZcsWWKC5v/auxMwqaozYcCHfWkWAVlkRwFxQURFdNQARuMWRE1kCBqjDoZxn5iMOmaimESTGDXORDPuEkdBx7j8JiZRRHFJjKIGGVfUCAouiAtblKXp/zk305Vu6G66q6u6qvq+7/Pcp25VnXvv6VOR1Fff/c5ZunRp8hinhdxmm23qbDtgwIAk6fzhhx8mP7Q2Zhry559/PrMfzxWD9bjFKbynT58e/uM//iOr81f+PXUpLy9v8HmhEIYNG5ZUzUlgABTfXdlxWZY4tXZ8VO0MpJl4WjwNbF383hiLLYp9NkiAfBFPQ3qkPun89a9/PcydOzc88cQT4dNPP91q8rU5Wb16dfLYqVOnrbaNielK8QfXbJLCcWyPPvroMH78+CShFqczjwn/hx56KNx0003JeWPiOfbr9ttvb/D5Y2IcSl0MQmOyeeeddy50VwCo5a7swYMHJ68PGjQoCZ5VOwNpJZ4WTwN1i8vVfelLX7JcFpBa4mlIl5Yh5Y477riw7777JusVf/vb3w5p8vnnnyeP9amkrJpk/uyzzxp8rb59+4Zly5aFm2++OZxwwgnJmI8ePTocfvjh4aqrrkqqnwcOHJi0nTVrVrj//vsbfA0odfG/xcMOO0zCGaDI78qOPx5W3pRXWe0c34/tANJEPC2eBmrXqlWrcPDBB1cr5ABIG/E0pEvqk87xC+Bdd92VrMs3c+bM5E7t5cuXh2KrfGzsFv+2zcVK48q7jbYmVvVU6tChQ1bJtMofaGsSK59vu+22aus+N1ScIn1rW58+fRp8XmgK8b+PSZMmJWucA1C8d2XHG+k2bNiQ2eLz+HpltXN9vlcBNBfiafE0ULtx48aF3r17GyIgtcTTkD6pn177+9//fjIQhxxySHj99deTKttf/epXYf/99w8jR44MXbt2rfeaKxdeeGEoJZ07d04eY2XO1qxduzazX5/puLMR17eJUwrH9Z2ffPLJsGnTptCyZf3vi6hPsi7+KALFmHD+8pe/nKrp/QFKxXPPPZepco4WLFhQY7vKtZ1j+zijC0AaiKfF00DN9thjjzB06FDDA6SaeBrSJ/VJ5xkzZmyRVI7VKo888kiyNUS+ks6vvPJKo8+x3Xbb1Zikffrpp5OE8tbWs45VwlHPnj2zWs+5viqTznHq748++ii5HjRnceaAI444QsIZoEitWLEilJeXJ7OybE1sF9sDpIV4WjwNbGnIkCFhzz33NDRA6omnIX1Sn3SOKioq6vVaXepbDZ2NESNG5C3Be/fddyf7r776athnn31qbLdx48bw5ptvJvs77bRTyKd8jiMUm1h5H2dZ6NatW6G7AkAt4uw3cfaVqrO+1Cau1xfbA6SJeFo8DfxdLJ6YMGGC37cAxNOQSqlPOl900UUhrar+KPrYY4/VmnR+9tlnMz+07rfffnntU6xyjmI1dY8ePfJ6LSi0GIj26tWr0N0AoA7xxqBJkyZVe23ZsmXJNGF77bVXsqYzQFqJp/9GPA1EcQbBww47LLRunfqfWwES4mlIn9R/C0pzkDx+/PhkzeqVK1eGX/7yl+Hcc8+t8U7MmTNnZvaPPvrovPXnD3/4Q3jppZcyCfGGrOcMpSZOtbX99tsXuhsANND69evD7bffHlavXh1ee+21cPbZZ4e2bdsaRyCVxNPiaeDvM94cfvjhoX379oYEoBbiaWj+ZPVSLP5AetZZZ2XWjb788su3aPPUU0+Fm266KdkfN25cGDNmTI3nisnquA0ePLjG9++77746pyx/4403wtSpUzPPTzvttAb/PVAqBgwYEPbYY49CdwOALMyfPz+sWbMmLFy4MEk8x+cApI94GqgUE80x4dypUyeDAlAH8TQ0f6mvdE67f/3Xfw133nlnWLRoUVLpHJO/U6ZMCR06dAiPPvpouPTSS5M1nePzq666KuvrxArpoUOHhmOOOSbsvffeoX///skU2u+991548MEHk8R2/AE3mjx5ctIOmqMYhFrfCaB078qOM7O8//77yUwx8TE+jzflqXYGSB/xNNCmTZtw6KGHJlPIAlA78TSkg6RzynXu3Dk88MADyR2Zr7/+erj++uuTraouXbok00juvvvujbpWTGhfdtlldbY59dRTw89+9rNGXQeKVZwN4MADDzTdFkCJ35W9ZMmS5N/0+NinT5/k9f3226/Q3QOgiYmnId3i2s2HHHJI6NWrV6G7AlD0xNOQDpLOJBXIf/7zn8M111wT7rrrriQ5HO88ilMAx2R0XKtw0KBBjRqp+++/P5mq++mnn05+oF2xYkVYu3ZtktCO69oecMAB4eSTTw677rqrT4RmK06pHZMTAJT2Xdnr1q0Lu+yyS3jppZdUOwOknHga0ptwPuyww8J2221X6K4AFD3xNKSHpPNm4rrDL7/8cliwYEGSGI1r9W3atKleg3nhhReGUlVWVpZMrx23bNS1XnM0ceLEZIO06tmzZxg9enShuwFADu7KjtUs8d/1+KjaGeDvxNPiaUgDCWeAhhFPQ3pIOv+fDRs2hJ/+9KfhF7/4RbLOcDZKOekM1K1qFX55eXlyU0q/fv3qNWytWrUK48ePDy1btjTMAM3gruzBgwcnr8eZYGLwbG1nIO3E00BaSDgDNIx4GtJF0jmE8PHHH4eDDz44qW7eWsVuFNfw27xdfA1ovm644YbM/qpVq8Idd9xR72NjhXO3bt3y1DMAmvqu7I4dO2ZmiinGaudly5aF5557Luy1116hb9++he4O0MyJp4G0aNOmTTj00ENNqQ3QAOJpSBdJ5xDC5MmTkzWNo/iD4dFHHx2effbZ5B/EmEyOFcxxmu34g2JllUt8Pf7QePrpp4f27dsX+nMEilTXrl3DqFGjCt0NAHJ0V3ZM4saKvkrx+fLly4um2jn29/bbb0++u7722mvh7LPPLmh/gOZPPA2kQfw+Fddw7t27d6G7AlAyxNOQPqlPOj/00EPhkUceSZLIsRpkzpw5oUuXLuHMM89Mks7RRRddlBmwuL7zvffeG84555ywdOnS8OCDD4YHHnjAXY5Ajfbdd99kem0ASlOsGK6sco7izDg1qax2ju3jv/2FqlyuvIt84cKFyU1PxVJ9DTRP4mkgDdq1axcOP/zw0LNnz0J3BaCkFDqebugsYOJpaLzUJ52rTpF70003JQnnusQ1Wb/yla+EL3zhC2HcuHHhhRdeCFOmTAnz5s0zxTZQTfwyM3DgQKMCUMJWrFgRysvLw7BhwzKvxaD5ww8/TKbWjjPfVIrtYvtcTnvdkMrlqneRr1y5smiqr4HmSzwNNHcdOnRIEs49evQodFcAUhtP5zuWrmwvnobGaxlS7qmnnkoed9lll7DrrrvW+7h4d+Ntt92WrO385JNPhrvuuiuPvQRK0d57713oLgDQSPvvv3/y7/k//MM/JFvcj9Nsx2A1Pm7+XmxfV8Ab75yOj/F5fVS90zoGy5Uz8dTVNt4lHmfxiY/xeV3HADSGeBpozjp27Bi+/OUvSzgDFDCebopYump78TQ0TuqTzpXrM48cObLawMTXKsV/AGuyxx57JHfXRPEfPIBKgwYNSu7YA6C0devWLUyaNClMnTo12XbYYYfkLu245MrQoUOT55XvxXaxfS4C3rrutK4pyN58raydd945eazrGIDGEk8DzTnhPHHixFq/2wHQNPF0vmPpzduLp6FxUp90Xrt2bTIQ22yzTbWBqTq1w6efflrrAMbq6Fjt/L//+7+N/CiA5iTelAJA89LQwLWxxzXkTuuqbeNNT3FWnvio2hnIJ/E00JwrnLt27VrorgA0G9nExU0RS2/eXjwNjZP6pHPnzp2Tgfj888+rDUzVu2r+8pe/1DqAlcfFf/AAov79+yc/9gPQvGQ73VY2xzXkTuvN2w4ePDgz64ZqZyCfxNNAc1zDOSacNy9OAaBxsomL8x1L19RePA2Nk/qkc/wxLoqL11e10047ZfafeOKJWgfwhRdeSB7rWoQeSJfRo0cXugsA5Fi2021le1xD7rTevG2szqmcuUe1M5BP4mmgOZFwBsiPbOLipoila2ovnobGSX3Sebfddkumx37llVeqDcw+++wTWrVqlexfe+21yT88m4vrOMfj4l02O+64YyM/CqA56NOnT9huu+0K3Q0Acizb6bayOa4hd1pv3rZv375hw4YNmS0+V+0M5It4Gmgu2rdvn1Q4W8MZIPeyiYvzHUvX1F48DY2X+qTz+PHjM1Nov/fee5mBif+IHXrooUlCOv5D9oUvfCHcc8894fXXX0+qm3/wgx+EU045JdP+mGOOycHHAZQ6Vc4AzU+2021le1xD7rR+7rnnMm2jBQsWJOes3OLzqPKY2B4gV8TTQHPQunXr5DdACWeA3MsmLm6KWDoST0PutQ4pd8QRRyQVzZs2bQr33ntvOO200zLv/eQnPwkPP/xw8o9XTDQfe+yxNZ5j++23D6effnoT9hooRvFmlbieMwDNS30C1zjTRWy33377Neq42u60rhSfL1++PBNkDx06NJSXl4dhw4Zt9e+I7VasWJGHEQLSSjwNlLo4e+HBBx+cfDcDIPeyiYubIpYeM2ZMEh+LpyG3Up90jkmiK6+8Mrz77ruZf7wqxXUC7rvvvjBlypSwcuXKGgdw+PDh4de//nXo1KlTjj8aoNTsvvvuScAKQPORTeDatm3brI+r6U7rmlQG2THo3nvvvcPatWu3+rfEtvvvv39OxgUgEk8DpW7cuHFhwIABhe4GQLOUTVwcNUUsHdvH+DgWI4qnIXdSn3SOzjzzzFoH6JBDDkmm1L7hhhvC3Llzk+R0y5Ytk+rmiRMnhm984xvJP2pAusVpuCqnegGg+cgmcN13332zPq6hd1rHIH7SpEmN+hsBGkM8DZSqeONeLCYBID+yiYujpoilY/v4e654GnJL0rkett122/Bv//ZvyQZQk1GjRqlyBmiGsp1uK9vj3GkNNDfiaaAY7bjjjkkcD0D+ZBsXi6WhdEk6AzRShw4dwg477GAcAZqhbJPA2R7nTmsAgPzq3bt38t3L8lgA+ZVtXCyWhtIl6QzQSDvttFNo1aqVcQRohrJNAkseAwAUn5jUOPjgg8XwAE0g27jYlNdQuiSda/Hiiy+Gd955J3zyySdh48aN4YQTTmjaTwYoGSNGjCh0FwAAoGiIp4FiFG8W/9KXvhQ6duxY6K4AADRLks6bLT5/2WWXhdmzZ4eVK1dWG6jNk84ffPBBOOuss0JFRUXYa6+9wrnnnts0nxhQVPr06RM6depU6G4AAEBBiaeBYnfAAQeEnj17FrobAADNlqTz/4mJ5unTpyfrC8REclU1rfES139Zvnx5eOyxx8Jvf/vbcNppp0k8QQpZyxkAgLQTTwPFbscddwzDhw8vdDcAAJq1loXuQDG4++67w/HHH59JOG+zzTbhsMMO2+qX0WnTpiWPn332Wfj973/fRL0Fikm/fv0K3QUAACgY8TRQ7Lp37x7222+/QncDAKDZS33S+dNPPw2nnHJKkmyOFc0XXXRReO+998IDDzwQDj744DoH78gjjwytW/+tWHzu3LlN9JEBxSKuA9W1a9dCdwOAJrZs2bJw//33h3fffdfYA6kmngaKXfzd7otf/GLm9zsACks8Dc1b6pPO119/fRIoVyac49auXbt6DV7nzp3DTjvtlCSsX3jhhbx/WEBxiWtB1TT9PgDN1/r168Ptt98e5s+fnzzG5wBpJZ4Git3+++8funXrVuhuACCehlRIfdI5rscc9ejRI5x33nlZrQkT/eUvf8n5hwMUN4ErQPrEZPOaNWvCwoULw+rVq5PnAGklngaK2bBhw6zjDFBExNPQ/KU+6fzaa68llYoHHHBAaNu2bdZJp5UrV+bh4wGKWVz/HYD0iFXNf/jDH8L777+ffPeLj/G5amcgrcTTQLGKsxNaxxmgeIinIR1Sn3T++OOPk4Ho1atXVgNYXl7+t4FsmfqhhNQpKysrdBcAKMBd2UuWLEluWoyP8blqZyCtxNNAMYrf0yZMmJBVcQkA+SGehnRIfaa0a9euyUDEHwyzXfi+cnpuIF06duxY6C4AUIC7stetWxd23nnn5FG1M5Bm4mmgGI0ePTr06dOn0N0A4P+IpyE9Up907tevX6ioqAgvvPBCgwdvw4YN4amnnkruoBw+fHhePiCgeHXo0KHQXQCgAHdlxxlyevbsmTyqdgbSTDwNFJv4/WyPPfYodDcAqEI8DemR+qRznG4neumll8LChQsbNHi33HJLWLVqVbJ/4IEH5uUDAoqXqboA0nlX9uDBg5PXBw0apNoZSDXxNFBMWrVqFcaPH28JPIAiIp6GdEl90nnq1KmZwfjnf/7n5IfD+njxxRfDueeem+y3bt06HH/88Xn7kIDiE/+7t5Y7QDrvyq5cXqGsrEy1M5Bq4mmgmIwZMyZss802he4GAFWIpyFdUp903muvvcIxxxyTTLH99NNPhy9+8YtJQrk2n332Wbj66qvD/vvvn1Q5x6m1p02bFgYOHNikHxxQWG3atPERAKTwruy+ffsmS6xUbvG5tZ2BtBJPA8Wid+/eYeTIkYXuBgBViKchfVoXugPF4MYbbwwvv/xyePXVV5M1mkeNGhV23nnnJMFc6eijj05+bFywYEHyj2VMUkejR48OV155ZQF7DxSq0hmA5u+5557LVDlH8btgTeL7ffr0Sdrvu+++TdxLgMIRTwPFMq12LAwBoHiIpyF9ZE1CSKbeefTRR8PXvva1MG/evGRgYhI6qvzCev/99yePlcnmynWc/+d//ie0a9euEJ8dUOCgFoDmb8WKFaG8vDwMGzZsq21ju9geIE3E00AxzLrQtWvXQncDgM2IpyF9JJ2rTMMzd+7ccNttt4Wf/exntVaxRDvttFM477zzknWcS31N11i58/zzz4dnnnkm2eIaC4sXL07eGzRoUGY/l/74xz+GX/ziF+GJJ54IH3zwQfIjRawuP/HEE5PEP5QCSWeAdIhLqmzatCmsXbt2q23jGs+xPUDaiKfF01AoPXr0MK02QJEST0P6tKioWrpLRpxKO061/e6774aVK1cmPyLGQHrs2LFhyJAhzWakJkyYkKnu3lw+ks4zZswIP/jBD5Ifb2tyxBFHhF/96lehffv2IR/69+8fli1bFvr16xeWLl2al2vQ/MX13ONNKnHafQAAoDrxtHgaqopLj/zpT3+q9lr8be38889v1EDF2QknTZoUevXqZcABAIqASudaxDX50pBQqnrPQffu3ZMpiWIlcqyAzrXrrrsuXHzxxcn+DjvsEC644ILkbtSY2P+P//iPZIrzBx54IJx88slh1qxZOb8+5FKpz3IAAAD5Ip4WT0NT2HnnnSWcAQCKiKRzyk2dOjVMnz49jBkzJgwdOjR5bfDgwTlPOn/88cfJlOTRwIEDkztct91228z7X/7yl5Mk/69//eswe/bs8M1vfjOMHz8+p32AXJJ0BgCAdBNPQ+F07Ngx+S0LAIDioVQv5WJyN66jXJlwzpcbb7wxmaY8+slPflIt4Vy5Pm5c57lyndyf/vSnee0PNJakMwAApJt4GgonLn/Xtm1bHwEAQBGRdKZJ3Hfffcljly5dwjHHHFPressHHXRQsh/Xy129erVPh6Il6QwAADQF8TRU17t377wXTwAA0HCm167is88+S9YUfuaZZ8Jbb70VVq1aFTZs2FCvgWzRokWSKGVL69evT8Y02nfffeu8E3XcuHHhwQcfDOvWrQvPPvtsmDBhgiGlKEk6AwDA34mn80M8DVuKvy3F3+EAACguks4hhIqKimQ650suuSSrtYzj8b7s1m7RokWhvLw82R8xYkSdY1n1/VdeeaVBSeelS5dutU1lP6CxKqeCBwCANBNP55d4GqobPnx46NWrl2EBAChCks4hhOOPPz7ccccdSbBM7lVNBscptOsyYMCAzP4777zToOtUPRbyTaUzAACIp/NNPA1/17p16zBmzBhDAgBQpFKfdJ41a1aYPXt2plJ5xx13DJMnTw677rpr6N69e/KFlsapujZzp06d6mxbVlaW2c+m6hyaikpnAADSTjydf+JpmoP4G1ullStXhs8//zz069evwecZOXJktd+NAAAoLqnPqN54442ZwfjWt76VTLOtgjG3YjBRqa71nKN27dpVWxOsIepTGR3viH3//fcbdF6oiaQzAABpJ57OP/E0zcENN9yQ2Z8zZ0546623GnyO9u3bh1GjRuW4ZwAA5FLqk84LFy5MqpyHDBkSLr/88qJcmzkXfbrlllvCiSeeGAohBgaV1q9fX2fbdevWZfY7dOjQoOtsberuSKKQXPG/JQAA0k48nX/iafib0aNHb7WQAQCAwmoZUq7yruEDDjigKBPOzUHnzp3rPWX22rVr6z0VNxSSqfcBAEg78XT+iafhb78P7bzzzoYCAKDIpb7SeeDAgeG1114r6im1X3nllUafY7vttguFUrUCeenSpfWeInvAgAF57Rc0hqQzAABpJ57OP/E0/K3K2WxjAADFL/VJ57Fjx4ZXX301J4ndfBkxYkQoZcOHD0+Cg/Ly8mSs61L1/Z122qkJegfZkXQGACDtxNP5J54m7crKypL/DgAAKH7FW97bRM4444zkcf78+eHFF18sdHeapbjmzt57753sP/XUU3Wu6/zYY48lj+3atQt77bVXk/URGqpNmzYGDQCAVBNP5594mrTbfffdVTkDAJSI1Ced99xzz/DP//zPSRXu1772tfDRRx8V+jNplo466qjkcdWqVeGee+6psU2cevvhhx9O9r/4xS9WW7sKio2kMwAAaSeebhriadKqY8eOJT/7HwBAmqQ+6RxdffXV4ZRTTgkvvfRS2HXXXZPn7733XqE/m5KxePHi0KJFi2QbP358jW2mTZsWunbtmuyff/75WyT3Y9L/tNNOSx6jf/3Xf22CnkN24v/WY8UBAACknXi6ccTTULv4G521nAEASkfq13SOWrZsGa677rpkDeFzzjknnH322ckWk6RxiwmmrYlt3nzzzVBq3njjjfDkk09We23NmjWZx5kzZ1Z779BDDw19+vRp8HW6d+8efvKTnyRV5UuWLEnW/vrud78bRo4cGd59991w1VVXhUcffTRpGyvOa0teQzGIVfgq8QEAQDwtnob8aN26dfI7HQAApUPSOYSwYcOGcNZZZ4Wbb745SR5XVFQkg/Ppp5+GlStXbnUQY/v6JKaLUQyQTzrppBrfi9XIm78XE8PZJJ2j6dOnJwnmH/zgB0mC/uSTT96izeGHH558DgAAABQ/8bR4GvJh6NChoV27dgYXAKCEpH567Tid86RJk8L1118fNm7cmEk4V4rPt7ZRfxdffHGS6J46dWoYMGBAMkVxr169wsEHHxxmzZoVHnjggdC+fXtDCgAAUOTE001LPE2a7LLLLoXuAgAADdSiIuVZ0//6r/8Kp59+eqbC+aCDDkqmd47TPnfr1i2Zzqe+Bg0alNe+0nj9+/cPy5YtC/369QtLly41pAAAAFkST6eLeJpcmDNnTnjrrbfqbLPddtuFiRMnGnAAgBKT+um1f/nLX2YG4/LLL0/WdAYAAADqJp4G8mHYsGEGFgCgBKV+eu2XXnopqXLeeeedJZwBAACgnsTTQK61atUqDBkyxMACAJSg1CedK40dO7agHwQAAACUIvE0kCsDBgwI7dq1M6AAACUo9UnnuLZvVF5eXujPAgAAAEqGeBrINVNrAwCUrtQnnQ888MBQUVERFixYUOjPAgAAAEqGeBrI9dTasdIZAIDSlPqk8/Tp05MvtQsXLgxPPPFEoT8PAAAAKAniaSCX+vTpE1q3bm1QAQBKVOqTzqNGjQqXXHJJUu08ZcqU8Oqrrxb6MwEAAICiJ54GckmVMwBAaUt90jk699xzw7XXXhs+/vjjsOeee4Zvf/vb4Y9//GNYtWpVoT8fAAAAKFriaSBX+vfvbzABAEpYi4pY4pticWrtquJwtGjRosHnicds3Lgxhz0jXwHMsmXLQr9+/cLSpUsNMgAAQJbE0+kiniYX5syZE956660tXu/YsWM47rjjsvpNDgCA4pD6hVI2TzJX3U95Ph4AAABqJZ4Gcrmes4QzAEBpS33SOZJcBgAAgIYTTwO50KtXLwMJAFDiUp903rRpU6E/AwAAACg54mkgV3r37m0wAQBKXMtCdwAAAAAASKeWLVuGbbfdttDdAACgkSSdAQAAAICC6N69e2jVqpXRBwAocZLOAAAAAEBB9OjRw8gDADQDks4AAAAAQEFIOgMANA+SzgAAAABAQUg6AwA0D5LOAAAAAEBBSDoDADQPks4AAAAAQJPr1KlTaNu2rZEHAGgGJJ0BAAAAgCbXrVs3ow4A0ExIOgMAAAAATa579+5GHQCgmZB0BgAAAACanEpnAIDmQ9IZAAAAAGhyks4AAM2HpDMAAAAA0OS22WYbow4A0ExIOgMAAAAATaqsrCy0adPGqAMANBOSzgAAAABAk1LlDADQvEg6AwAAAABNStIZAKB5kXQGAAAAAJpU165djTgAQDMi6QwAAAAANClJZwCA5kXSGQAAAABoUpLOAADNi6QzAAAAANBkWrZsGTp16mTEAQCaEUlnAAAAAKDJxIRzTDwDANB8+HYHAAAAADQZVc4AAM2PpDMAAAAA0GQknQEAmh9J55Rbs2ZNePzxx8Pll18eJk+eHIYMGRJatGiRbIMHD87ZdebNm5c579a2GTNm5Oy6AAAAkA/iache586dDR8AQDPTutAdoLAmTpyYJIQBAAAA8TQ0hbKyMgMNANDMSDqnXEVFRWa/e/fuYa+99gp//OMfkzu28+Xmm28OY8aMqfX9Xr165e3aAAAAkAviaciepDMAQPMj6ZxyU6dODdOnT0+SwEOHDk1ei9Nq5zPpHKfw3nXXXfN2fgAAAMg38TRkr0OHDoYPAKCZkXROuW9+85uF7gIAAACUHPE0ZK9jx46GDwCgmWlZ6A4AAAAAAOnQokWL0L59+0J3AwCAHJN0BgAAAACaRNu2bUPLln6SBABobkyvTZP77ne/G5YuXRref//9ZDqluIb0+PHjw6mnnhqGDx+e9XnjObemvLw86/MDAABAIYmnaQ7atWtX6C4AAJAHLSoqKirycWJKV0wCL1myJAwaNCgsXrw4J+ecN29emDBhQp1t4l2u3/ve98JFF12UTLXUUA05pl+/fvVKUkNNrrzyymQDIL3OOeecZAOAqsTTULfp06eHX/3qV6FDhw6GCiClxNPQfKl0pslst9124Zhjjgn7779/2H777UPr1q3D22+/HX7zm9+EW2+9NWzYsCFcfPHFYf369eHSSy/NWz9iUrtLly55Oz/NV7xRYcCAAYXuBgBF4Nvf/naYPHly6N+/f6G7AkAKiKcpdeJpACqJp6H5UulMk9yZvXbt2mTNnjZt2tT4/jPPPBO+9KUvhZUrVyYVy3/+85/DqFGjGnSN+lYu+3GYXATJffr0Ca1atTKYACkTl+qIS4RE77zzju8VAFQjnoaaiacBEE9D86fSuQRkM9X05m655ZZw4oknhkIpKyur8/299947XH311eHrX/96iDO+x/0bbrihQdeQTKYpzZ8/3//mAFJIlQ5AaRFP1494mqYkngZIJ/E0NH8tC90BqDRlypTMtNePPfaYgQEAAIB6EE8DAACFptK5BLzyyis5Wf+p2MU1nocPHx6effbZsGzZskJ3BwAAgBInngYAAGgaks4lYMSIESEtcjH1GQAAAETiaQAAgKZhem2KxsaNG8OiRYuS/b59+xa6OwAAAFASxNMAAEChSTpTNO68886wcuXKZH/cuHGF7g4AAACUBPE0AABQaJLONNrixYuTabHjNn78+C3e/+STT8K8efPqPMczzzwTzjjjjGQ/nufUU0/1yQAAANCsiacBAIDmwprOKffGG2+EJ598stpra9asyTzOnDmz2nuHHnpo6NOnT4OuEauXJ0yYEHbbbbdw1FFHhT333DNst912oVWrVuHtt98Ov/nNb8J///d/h/Xr1yftv/Od7yRtAAAAoFiJpwEAAP5O0jnlYsL5pJNOqvG9jz76aIv3Hn300QYnnSstXLgw2WoTk9Df+973woUXXpjV+SHf+vfvHyoqKgw0QIr5/wIAKomnwXcoAPx/AfB3ks7kXd++fcNdd90VnnrqqWQa7WXLloUVK1aEzz//PHTt2jXsuOOOybTc06ZNC4MHD/aJAAAAgHgaAAAoIS0qlO0BAAAAAAAAkKWW2R4IAAAAAAAAAJLOAAAAAAAAAGRN0hkAAAAAAACArEk6AwAAAAAAAJA1SWcAAAAAAAAAsibpDAAAAAAAAEDWJJ0BAAAAAAAAyJqkMwAAAAAAAABZk3QGAKCkLF68OLRo0SKn24wZMwr9ZwEAAEBeiaeBfJJ0BgCAIjFv3rxMInz8+PGF7g4AAACUBPE0FF7rQncAAAAaokuXLuH000+vs80zzzwT5s+fn+z37ds3HH300XW233vvvX0IAAAANGviaSCfJJ0BACgp3bt3D1dffXWdbeJ02ZVJ52HDhm21PQAAADR34mkgn0yvDQAAAAAAAEDWJJ0BAAAAAAAAyJqkMwAAqffKK6+ECy64IFnbuXfv3qFt27ahZ8+eYezYseHCCy8M7777br3GaM2aNeHaa68NRxxxRBg4cGDo2LFjaNOmTejatWsYMWJEmDhxYrj00kvDiy++uMV04C1atAgTJkzIvPbYY48lr22+DR48OPWfFwAAAMVBPA1UsqYzAACptW7dunD22WeHG2+8MZSXl1d7b8WKFcn2zDPPhMsvvzxcdtll4Ywzzqj1XE899VQ49thjw7Jly7Z4b9WqVcn22muvhd/85jfhu9/9btiwYUNo3drXcQAAAEqPeBrYnF+5AABIpbVr14ZDDjkk/OEPf8i8tsMOO4Q999wzdOvWLXz88cfJe7HK+bPPPgtnnnlmkjiOFdGbe+edd5JzrV69Onkeq5vHjBkThg4dmlQ7x2stXrw4vPDCC8k5NhcrrE8//fQkYX3fffclr/Xt2zccffTRW7Tt0aNHjkcCAAAA6k88DdRE0hkAgFQ67bTTMgnn4cOHh+uuuy6MHz++WptY/Xz99deHb33rW8ld3HGq7TgF9r777lut3ZVXXplJOB9wwAHhjjvuSJLGm9u4cWNyzRtuuCGZKrvS4Ycfnmzz5s3LJJ2HDRsWrr766rz87QAAAJAt8TRQE0lnAABS54knngi33nprpro5JoK33XbbLdq1atUqnHrqqaFDhw7hpJNOSpLQ3//+98Pvfve7Lc5X6eabb64x4RzF6bTHjRuXbAAAAFBqxNNAbVrW+g4AADRTsTK50hVXXFFjwrmqE088MYwYMSLZf/DBB8NHH31U7f2qU2b37Nkz5/0FAACAYiCeBmoj6QwAQKrEKa7nzJmT7Hfp0iV8+ctfrtdxcVrtqKKioto60NGAAQMy+9dee21O+wsAAADFQDwN1MX02gAApMrChQvD2rVrk/02bdqEs88+u17HzZ8/P7P/zjvvVHtv8uTJ4ZFHHkn2zz///CSpfdxxx4WDDz449O/fP6f9BwAAgEIQTwN1kXQGACBV3n333cx+nCb7mmuuafA5Pvnkk2rPp02bFn7/+9+H++67L3k+d+7cZIsGDhwYDjjggKRSetKkSVudyhsAAACKkXgaqIvptQEASJWVK1fmZEqxqlq1ahXuueeecOONN4add9652ntvv/12uP3225PEdN++fZPHjz/+uNF9AAAAgKYkngbqIukMAECqlJWVZfZ32223ZI3mhm4zZszY4rwtWrQI//RP/xReeuml8Nprr4Xrr78+fOMb3wjbb799ps2GDRvCTTfdFPbee+/w4YcfNtnfDAAAAI0lngbqIukMAECq9O7dO7P//vvv5+Uaw4cPD6ecckqYOXNmePPNN5Mk9DnnnJNUREfxtYsvvjgv1wYAAIB8EE8DdZF0BgAgVXbffffQrl27ZH/58uXhjTfeyPs1YxL6iiuuqJZovv/++2uslgYAAIBiJJ4G6iLpDABAqnTo0CEceOCBmee/+MUvmuzaRx55ZGb/gw8+2OL99u3bV5uKGwAAAIqFeBqoi6QzAACpc95552X2f/7zn4eHH3643sfWNCX3ihUr6nXsO++8k9nv1avXFu/36NEjs79s2bJ69wkAAACagngaqI2kMwAAqTNu3LjwjW98I9nfuHFjOOKII8KPfvSjsGbNmhrbf/755+G+++4LkyZNqlatXGngwIFh+vTp4bHHHgubNm2q8RzPPvtsOPPMMzPPDzvssC3aDBkyJHTs2DHZX7JkSZg/f37WfyMAAADkmngaqE2LioqKilrfBQCAEjRjxozM+skxIJ43b94WbdatW5ckkB966KHMazHhO3bs2CSJHNd9/vTTT8Obb74ZXnzxxaR9tOeeeyYJ5NrWYu7cuXOyztWgQYNCWVlZUgX96quvhpdeeinTpmfPnmHBggWhb9++W/TruOOOC7Nmzcr059BDD03606pVq+S17t27hwsuuCAHowQAAADViaeBbEk6AwCQyiA5Ki8vT9pdccUV4a9//etWz9umTZvwzW9+M1x99dXVXo+J5tqqpDc3atSocMcdd4QRI0bU+H6scN5nn31qnMY7isnsxYsX1+taAAAA0BDiaSBbrbM+EgAASlysHv7+97+fTHt96623Jms7v/zyy0l18oYNG0KXLl2SJO/IkSPDhAkTwuGHH55UKW/uo48+Co8//ngyvXacEvv1118PH3zwQTItd6xW7t+/f1Ih/ZWvfCWprm7ZsvZVbuL1XnjhhSSxHauwFy1aFFavXp1MAw4AAADFQDwNbE6lMwAAAAAAAABZq73EAgAAAAAAAAC2QtIZAAAAAAAAgKxJOgMAAAAAAACQNUlnAAAAAAAAALIm6QwAAAAAAABA1iSdAQAAAAAAAMiapDMAAAAAAAAAWZN0BgAAAAAAACBrks4AAAAAAAAAZE3SGQAAAAAAAICsSToDAAAAAAAAkDVJZwAAUmnevHmhRYsWyTZ+/PhCdwcAAACKnlgaqI2kMwAAAAAAAABZk3QGAAAAAAAAIGuSzgAAAAAAAABkrUVFRUVF9ocDAAAAAAAAkGYqnQEAAAAAAADImqQzAAAAAAAAAFmTdAYAoCBatGiR2SotWLAgnHrqqWHHHXcMnTp1SraxY8eGX/ziF2Hjxo1bnOPZZ58NJ554Ythpp51CWVlZ6NGjR5gwYUK4/fbbt3r9efPmZa4/fvz4GtssXrw402bw4MHVrjtt2rQwfPjw0LFjx9CtW7ew9957h0svvTSsXbu2zuvWds66xHaVx8Tja7NixYpw+eWXh4MOOij07ds3tG/fPrRp0yZss802YZdddglf/epXw5VXXhneeuutel0XAACA4iKWFktDsbKmMwAABVE12VxRUREuu+yycMEFF4Ty8vIa2x9yyCHh//2//xfatWuXtDnzzDPDf/3Xf9V6/ilTpoTbbrsttGrVqtakc0xQR+PGjUueby4meIcMGZLsDxo0KEnWzpgxI/zwhz8MmzZtqvG8sf3DDz8ctt9++xrf3/ycdSWRqyadlyxZkuzHPtSUrI5jc9JJJ4VPPvlkq+fr169fWLp06VbbAQAAUFzE0mJpKFatC90BAAC47rrrwnnnnZcMxG677RZ23333JFn89NNPh5dffjl5/cEHHwxnnXVW0va0004L119/fWjZsmUYM2ZMUukck8BPPPFEpor3jjvuCKNGjQrnn39+zgb44osvDt///veT/djHkSNHJpXEsUL7+eefT16P1z/qqKOS561bN83X7Vh5HauYK6vBO3ToEPbZZ58kOR2T9KtWrQpvvvlm+N///d/w17/+tUn6BAAAQH6JpRtHLA25JekMAEDBnX322aFPnz5h9uzZW0x1fcUVV4TvfOc7yf7NN98cRowYkSScY6I5to+J5UqxAjq2veqqq5Lnl1xySVIRHafebqz33nsvSTjvsMMOYdasWcl02lXddddd4bjjjgsbNmxIkruxzQknnBCaQvw7KxPOX/nKV8INN9yQTPm9uc8//zw88sgj4f7772+SfgEAAJA/YunGEUtDblnTGQCAopgeLE5JXdPayt/+9reTNYqjmFg955xzQq9evZLpsKsmnKNYHR3XNI5rQkdr1qwJDzzwQE76uH79+tC9e/fw+OOPb5Fwjo499tgk4K8UE+JNJVZ4R7GqeebMmTUmnKO4xvPhhx8err322ibrGwAAAPkhlm4csTTklqQzAAAFN3369LDLLrvU+v7Xvva1as/j2s8x8VyTmHiePHly5vkzzzyTs37G6/bt27fW908++eTM/vz580NTidNnRx07dgydOnVqsusCAABQOGLpxhFLQ25JOgMAUHBxPeK6xLWTG9J+1113zexXrvGcC7GauS5x6u+4nnL00UcfhdWrV4emMGDAgOTxk08+CXfeeWeTXBMAAIDCEks3jlgackvSGQCAgquaJK5J1emiu3btGvr161dn+zgN9uZ3LjdWvG5lQFrX1GZV+5qra29N1cruWBV+zDHHJMnn5cuXN8n1AQAAaHpi6cYRS0NuSToDAFBwMaFbl9atW9e77ebtN2zY0Mje1f+6UZs2bXJ+7a3593//97DPPvsk+xUVFeHee+8NU6ZMCb179w7Dhw8P//RP/xRmzZrVZJXXAAAA5J9YunHE0pBbks4AABRcrBDOR9tcKtR166OsrCw89thj4ac//WkYPHhwtfdef/31cPPNN4fjjjsu9OnTJ5x77rnhs88+K1hfAQAAyA2xdOOIpSG3JJ0BAKDIbdq0aatt2rZtG77zne+Ev/zlL2HBggXhP//zP5Nq56pTkf/1r39NEtMTJkyQeAYAAKBZE0tD05J0BgCAJlR1+u2NGzfW65iVK1c26E73UaNGhTPPPDPMnj07LF26NDz//PPhpJNOyrR5+umnwzXXXNPAngMAAEBhiKWh+Ek6AwBAE+rSpUtm/5NPPknWYK7L22+/HVatWtWoa44ePTqZYnvatGmZ1+6///5GnRMAAACailgaip+kMwAANKHOnTuH7t27Z6a7XrRoUZ3t/+d//idn1z7yyCMz+x988EHOzgsAAAD5JJaG4ifpDAAATWzs2LGZ/ZkzZ9baLk6N/aMf/ajOc61bty6sWbOmXtd95513Mvu9evWq1zEAAABQDMTSUNwknQEAoIlNnTo1s3/llVeGu+++e4s2f/rTn8K4ceOSKbjbtm1b67nee++9MGDAgPCd73wnPPvss7W2mzNnTrjooosyzw877LBG/Q0AAADQlMTSUNxaF7oDAACQNlOmTAmXX355eOGFF8L69evDV7/61bDHHnuE3XffPZSXl4eFCxeGP//5z0nbGTNmhFtuuSUsWbKk1vN9+umn4Yorrki2OHV3XMO5X79+oX379mH58uXJ+f7yl79k2g8fPjycffbZTfK3AgAAQC6IpaG4SToDAEATa926dbj33nvDQQcdlEkGP//888lWqUWLFuGCCy4IF154YZJ0rk2bNm1Cu3btkmm2o48//jjMnTu31vbjx48Ps2fPDmVlZTn9mwAAACCfxNJQ3CSdAQCgAIYMGZJUIP/85z8P99xzT1i0aFGSOO7bt2844IADwqmnnlptvaraxIrmjz76KDzyyCPhiSeeCM8991x44403wocffphUUXfu3DkMGjQojBkzJvzjP/5jkugGAACAUiSWhuLVoqKioqLQnQAAAAAAAACgNLUsdAcAAAAAAAAAKF2SzgAAAAAAAABkTdIZAAAAAAAAgKxJOgMAAAAAAACQNUlnAAAAAAAAALIm6QwAAAAAAABA1iSdAQAAAAAAAMiapDMAAAAAAAAAWZN0BgAAAAAAACBrks4AAAAAAAAAZE3SGQAAAAAAAICsSToDAAAAAAAAkDVJZwAAIDFjxozQokWLZIv7AAAAQN3E0vA3rf/vEQAA8mrVqlXhd7/7XZgzZ0549tlnw4cffhhWrFgR2rZtG7p16xaGDx8exowZE4488siw7777+jQAAABIPbE0UCoknQEAyKu//vWv4aqrrgqXX355+OSTT7Z4f/369WHNmjXhnXfeCXPnzg0//vGPkwR0vFN4ypQpSdVtqana54qKioL2BQAAgNIjlhZLQ6mRdAYAIG/efvvtMHHixLBw4cJqrw8cODDstttuoWfPnqG8vDy8//774YUXXggffPBB8v6iRYvC1KlTk0T0ueee6xMCAAAgNcTSQCmSdAYAIC8WL16cTJMdE8qV1b9f+9rXwgUXXBB22WWXLdrHiuA47fbPf/7zcPvtt4dNmzYld3YDAABAWoilgVLVstAdAACg+YlTZh977LGZhHP79u3DPffckySTa0o4Vyal45rOt956a1L1vOuuuzZxrwEAAKBwxNJAKVPpDABAzl122WVJ1XKlX/7yl+Goo46q9/Ex4fynP/0pLFiwwKcDAABAKoilgVKm0hkAgJz67LPPwn/+539mnh9zzDFh8uTJDT5PWVlZ2G+//Wp9f8mSJeHCCy8M++yzT+jdu3do27Zt8hifX3TRRcl60Fszb968pMI6buPHj8+8/sgjj4QpU6aE7bffPqnS7tGjR/jCF74Qrr766rBhw4atnquqytc23+KUaZXifuXrgwcPzrz+5JNPhmnTpoURI0aErl27Ju//y7/8S43Xf/DBB8PJJ58chg8fHrp06RI6dOgQBg0aFI4++ugwc+bMWvsNAABA4YmlxdJQ6lQ6AwCQU7/61a/Chx9+mHl+zjnn5HyEL7nkkvDDH/4wfP7559VeX758ebI9/fTTyR3iM2bMCOedd16DpjI744wzwg033FDt9XXr1oUnnngi2W655ZYkwbvtttvm7O+pqR9nnXVWuO6667baNv69U6dODXPnzt3ivbfffjvZ7rvvvnDppZeGWbNmhb322itPvQYAACBbYunGE0tDYUk6AwCQU7FKuNLAgQPrrFbORkwKX3PNNZnnnTp1ChMmTAh9+vRJ1pB+9NFHw5o1a5KE9Pnnn5+89rOf/axe5/7mN7+ZTAXesmXLMHbs2KTCeNOmTclU36+99lrS5vnnnw8nnHBC+O1vf1vt2H79+oXTTz892a/av8rXNherkWvzrW99K5NwHjlyZBg1alRo06ZNWLRoUdK3Sh988EEyvm+++WbmtR122CHpe7t27cLLL7+cJOCj119/PRmn3//+9zn/TAAAAGgcsbRYGkpeBQAA5NAOO+xQEb9mxu3YY4/N6djeeeedmXPH7cQTT6xYuXJltTbx+fHHH1+t3d13313j+R599NFMm3bt2iWPY8aMqXjllVeqtdu0aVPFVVddVe2cjz32WK39rNquPt56661M+1atWiWPAwYMqHj88ce3aPv5559n9g877LDMcWVlZRWzZ8/eov38+fMrtt9++0y7eN5PPvmkxn5cdNFFmXZxHwAAgKYhlhZLQ6mzpjMAADkV11qutMsuu+TsvLHiOFYuVzr22GPDzTffvEXFcHx+6623hkmTJmVeO/fcc5Pj6xKn0B42bFhyd3mscK4qrqV89tlnh69+9auZ12bPnh3yoby8PHTs2DE8/PDD4YADDtji/VjBHMWK7t/97neZ1++8885kHerNxem049TbcU3oKK51XXXNbQAAAApPLN04YmkoPElnAAByZtWqVWHjxo2Z59tss03Ozv3QQw+Ft956K9lv27ZtkjiNyeCaxNfjFNdxSuooTj89Z86crV7jxz/+cTJdd21OPvnkzP4zzzwT8iVOIT58+PA621Rd7/nII48MRxxxRK1tBw8eHC644ILM82uvvTaWYOeotwAAADSGWDo3xNJQWJLOAADkzOrVq6s9ryuB25j1rQ4//PBkDee6xDWWDz300MzzWBlcl/bt24eJEyfW2Wb06NGZ/cWLF4d8qalieXNV/56qyfDanHTSSZn1oN97773MGtUAAAAUllg6N8TSUFiSzgAA5Eznzp2rPV+zZk3Ozv3nP/85s/8P//AP9Tpmv/32y+w///zzdbbdcccdM5XRtenRo0e1O9HzIfZh5MiRdbZZtmxZWL58eYPGo2fPntWqp7c2HgAAADQNsXTjiaWh8CSdAQDImbiecuvWrTPPP/3005yd+8MPP8zsDxo0qF7HxGmlK61YsaLOtpVrHtelalK66jTiudStW7dqY7i1sejQoUOSUM71eAAAANA0xNKNJ5aGwpN0BgAgp6omhF9++eWcnbdq1XRZWVm9jqnabvPpyjZX2/rQTS0mkfMxFg0dDwAAAJqOWLpxxNJQeJLOAADk1P7775/Zf/rpp3N23qrrQ69du7Zex1Rtt/l0ZaUsm7FozuMBAABQ6sTS+SeWhvySdAYAIKcOPPDAzP6SJUvCH//4x5yct+oU0m+//Xa9jlm8eHFmf9tttw3NRdWx+Oyzz+o9VXZzHQ8AAIBSJ5bOP7E05JekMwAAOXXsscdWS2heeeWVOTnv6NGjM/v1TWRXbbfHHnuE5qJfv36hV69eDRqPmJhetGhRsxwPAACAUieWzj+xNOSXpDMAADlfR+mss87KPL/77ruTraHiVNBVk6lV7/r+7W9/G5YvX17n8e+++2743e9+V+Px+da+ffvM/oYNG/JyjQkTJmT2Z86cudX2sc2mTZuS/b59+4Ydd9wxL/0CAACg4cTSYmkodZLOAADk3LnnnlutkvbrX/96+PWvf13v41988cWwzz77hIceeijz2pe+9KUwZMiQZH/dunXhX/7lX2o9vqKiIpx55pmZhO8OO+wQDjrooNBUevTokdlftmxZXq4xffr0zP69994bHnzwwVrbxmnOL7nkkmrHtmjRIi/9AgAAIDtiabE0lDJJZwAAcq5du3bhrrvuykwBHdcdPuqoo8IJJ5wQXnnllVoTxfPnzw/f+MY3wqhRo5LEc7Uvri1bhh//+MeZ57Nnzw6nnHJKWLNmTbV2q1evDieddFK45557Mq9ddtllyfFNZdddd83sx3HIV6XzYYcdlnn+1a9+tcZrPffcc0nC/dNPP02eDxgwoFolOgAAAMVBLC2WhlLWutAdAACgedp+++3D008/HSZOnJgkkOPUzv/93/+dbIMHDw677bZbsvZzeXl5eP/998OCBQvCBx98UO0cnTt3rvZ88uTJ4fHHHw/XXHNN8vzGG28Md955Z5KA7d27dzLl9ty5c6slomNF9DHHHBOa0le+8pVM5fF5552XTPO9yy67JD8gVPrud78bunXr1qjr3HLLLWG//fYLb775ZvI3x/EZNmxYGDt2bGjbtm14+eWXk88gJvSjsrKyJFm/zTbbNPIvBAAAIB/E0mJpKFWSzgAA5E1MLj/11FPhZz/7Wbjyyisz1baLFy9OttrESucZM2Yk1dGbu/rqq0OfPn3CD3/4w2Sa7VjZfP/999e4rvKFF14Y/u3f/i00tRNPPDHcdtttSYI8JnwfffTRZKvqjDPOaHTSOSba//CHP4SpU6eGRx55JHnt9ddfT7bNDR06NMyaNSuMGTOmUdcEAAAgv8TSYmkoRZLOAADkVadOncL3vve9ZErn3/72t2HOnDnJlM+xKvnjjz9OKnK7d+8eRowYkVToxkRz1fWga/Lv//7vyTrRsdI5VhS/9dZbSUI7VvDGu8IPOeSQMG3atDBw4MCCfLpt2rQJDz/8cLjpppvC3XffnVR6x791/fr1Ob9WTDzH6u7f//73SdX3k08+mVSOx/Ws4/Tmo0ePTsb0+OOPT/oFAABA8RNLi6Wh1LSoqJxrDwAAAAAAAAAaqGVDDwAAAAAAAACASpLOAAAAAAAAAGRN0hkAAAAAAACArEk6AwAAAAAAAJA1SWcAAAAAAAAAsibpDAAAAAAAAEDWJJ0BAAAAAAAAyJqkMwAAAAAAAABZk3QGAAAAAAAAIGuSzgAAAAAAAABkTdIZAAAAAAAAAElnAAAAAAAAAJqeSmcAAAAAAAAAsibpDAAAAAAAAEDWJJ0BAAAAAAAAyJqkMwAAAAAAAABZk3QGAAAAAAAAIGuSzgAAAAAAAABkTdIZAAAAAAAAgKxJOgMAAAAAAACQNUlnAAAAAAAAALIm6QwAAAAAAABA1iSdAQAAAAAAAMiapDMAAAAAAAAAWZN0BgAAAAAAACBk6/8DSYiS6l9dVDoAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] diff --git a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb index ff3753ad..12f9c877 100644 --- a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb +++ b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6473d3d4", "metadata": {}, "outputs": [ @@ -126,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2dcfc4d5", "metadata": {}, "outputs": [ @@ -329,7 +329,7 @@ "7 P00 3 Baseline 5.460908" ] }, - "execution_count": 2, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -374,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "61fe4aed", "metadata": {}, "outputs": [ @@ -399,7 +399,7 @@ "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" ] }, - "execution_count": 3, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -426,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "af815b94", "metadata": {}, "outputs": [ @@ -451,7 +451,7 @@ "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" ] }, - "execution_count": 4, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -473,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "64e293da", "metadata": {}, "outputs": [ @@ -616,7 +616,7 @@ "id_col + cluster_col 0 0.0866 15.0 " ] }, - "execution_count": 5, + "execution_count": null, "metadata": {}, "output_type": "execute_result" } @@ -645,13 +645,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "7580ef30", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -863,18 +863,6 @@ "display_name": "refmap-psychoacoustics", "language": "python", "name": "refmap-psychoacoustics" - }, - "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.11.15" } }, "nbformat": 4, From 07b7e77a08d9cd2572f18759227014107ff4edb2 Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Sun, 27 Sep 2026 22:21:15 +0100 Subject: [PATCH 6/8] feat: implementation of expanded percentile adjustment for small cluster sample sizes Hesterberg expanded percentile adjustment to expand coverage for small numbers of clusters. Active when cluster_col is assigned, opt-out argument also available. --- CHANGELOG.md | 3 +- dabest/_api.py | 28 ++ dabest/_dabest_object.py | 26 ++ dabest/_delta_objects.py | 111 ++++- dabest/_effsize_objects.py | 213 +++++++++- dabest/_modidx.py | 14 +- dabest/_stats_tools/confint_2group_diff.py | 182 ++++++++- nbs/API/confint_2group_diff.ipynb | 173 +++++++- nbs/API/dabest_object.ipynb | 26 ++ nbs/API/delta_objects.ipynb | 111 ++++- nbs/API/effsize_objects.ipynb | 213 +++++++++- nbs/API/load.ipynb | 28 ++ nbs/tests/test_cluster_bootstrap.py | 289 +++++++++++++ ...shared_control_and_repeated_measures.ipynb | 34 +- nbs/tutorials/08-plot_aesthetics.ipynb | 2 +- .../11-cluster_robust_bootstrap.ipynb | 381 ++++++++---------- 16 files changed, 1537 insertions(+), 297 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 97582488..2991e562 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,10 +7,11 @@ ### New Features 1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. 2. **Cluster count on plots**: when `cluster_col` is set, each group's axis label reports the number of distinct clusters on a second line below the number of observations, `(N=,` / ` n=)` instead of the usual `(N=)`, since the cluster count is what the bootstrap actually resamples. To make room, the gap between the raw-data and contrast axes of vertical Cumming plots is then sized to the height of the labels (including the taller labels of two-column Sankey plots), so they clear the contrast axes. Unclustered plots are unchanged. +3. **Small-sample expansion of cluster-bootstrap intervals**: bootstrap intervals are too narrow when there are few independent units, so with `cluster_col` set, confidence intervals are now expanded for the number of clusters by default, using the expanded percentile method of Hesterberg (2015). Each interval is read further into the tails of the same bootstrap distribution, at a level derived from a t distribution with degrees of freedom based on the number of clusters (for nested or mixed designs, those of the smallest group of clusters). This applies to the percentile and bias-corrected and accelerated intervals, and to those of the baseline error curve, delta-delta and mini-meta analyses. The reported confidence level (`ci`) is unchanged, and the level actually read is reported as `ci_expanded` in the results and in the printed summary. In simulations, expanded intervals came close to nominal coverage for every effect size once there were at least 6 clusters, and at least 4 in each independently resampled group of clusters; below that, a warning is given. Pass `cluster_ci_expansion=False` to `dabest.load()` to turn the expansion off. `cluster_col` can also no longer be the same column as `x`. ### Documentation 1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. -2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that, for the identical data and point estimate, the naive dummy-ID bootstrap's 95% interval lies entirely above zero while the cluster-aware interval spans it, making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, while the cluster-aware interval recovers to about 90%. +2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that, for the identical data and point estimate, the naive dummy-ID bootstrap's 95% interval lies entirely above zero while the cluster-aware interval spans it, making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, the unexpanded cluster-aware interval about 90%, and the default expanded cluster-aware interval about 95%. A section on the small-sample expansion explains when and why it applies. ## v2025.10.20 diff --git a/dabest/_api.py b/dabest/_api.py index 5d134c86..8f8ae21e 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -26,6 +26,7 @@ def load( mini_meta=False, ps_adjust=False, cluster_col=None, + cluster_ci_expansion=True, ): """ Loads data in preparation for estimation statistics. @@ -108,6 +109,32 @@ def load( `.plot(show_baseline_ec=True)` is always an unpaired comparison (see that argument's docstring), so with `cluster_col` set it can become much wider than a paired analysis's real effect-size curves. + cluster_ci_expansion : boolean, default True + Only used when `cluster_col` is set. Bootstrap confidence intervals are + too narrow when there are few independent units: with around 15 to 30 + clusters, a nominal 95% cluster-bootstrap interval typically covers the + true effect only 90 to 94% of the time. When True, the percentile and + bias-corrected and accelerated intervals (including those of the + baseline error curve, delta-delta and mini-meta analyses) are therefore + expanded for the number of clusters with the expanded percentile + method of Hesterberg (2015, The American Statistician, 69(4), + 371-386): each interval is read further into the tails of the same + bootstrap distribution, at a level derived from a t distribution with + degrees of freedom based on the number of clusters. When clusters are + nested within groups, or some clusters appear in only some groups, the + conservative choice of the smallest group of clusters' degrees of + freedom is used. The reported confidence level (`ci`) is unchanged; the + level actually read is reported as `ci_expanded` in the results. The + correction fades as the number of clusters grows. In simulations the + expanded intervals came close to nominal coverage for every effect size + once there were at least 6 clusters in all and at least 4 in each + independently resampled group of clusters (for example 6 participants + who each take part in every condition, or 8 participants split between + two conditions); with fewer, no bootstrap interval is reliable, and a + warning is given. Because expanded intervals are read further into the + tails of the bootstrap distribution, consider increasing `resamples` + (to 20000, say) when there are few clusters. Set to False to report + unexpanded cluster-bootstrap intervals. Returns ------- @@ -133,6 +160,7 @@ def load( mini_meta, ps_adjust, cluster_col=cluster_col, + cluster_ci_expansion=cluster_ci_expansion, ) # %% ../nbs/API/load.ipynb #570ff65a diff --git a/dabest/_dabest_object.py b/dabest/_dabest_object.py index 29bc42d4..0b434126 100644 --- a/dabest/_dabest_object.py +++ b/dabest/_dabest_object.py @@ -42,6 +42,7 @@ def __init__( mini_meta, ps_adjust, cluster_col=None, + cluster_ci_expansion=True, ): """ Parses and stores pandas DataFrames in preparation for estimation @@ -62,6 +63,7 @@ def __init__( self.__is_mini_meta = mini_meta self.__ps_adjust = ps_adjust self.__cluster_col = cluster_col + self.__cluster_ci_expansion = cluster_ci_expansion # after this call the attributes self.__experiment_label and self.__x1_level are updated self._check_errors(x, y, idx, experiment, experiment_label, x1_level) @@ -134,6 +136,11 @@ def __repr__(self): cluster_line1 = "Whole clusters, as defined by `{}`, ".format(self.__cluster_col) cluster_line2 = "will be resampled by the bootstrap and reshuffled by the permutation test." out.append(cluster_line1 + cluster_line2) + if self.__cluster_ci_expansion: + out.append( + "Confidence intervals will be expanded for the number of clusters " + "(set `cluster_ci_expansion=False` to turn this off)." + ) return "\n".join(out) @@ -357,6 +364,14 @@ def cluster_col(self): """ return self.__cluster_col + @property + def cluster_ci_expansion(self): + """ + Returns whether confidence intervals of clustered data are expanded for + a small number of clusters, as declared to `dabest.load()`. + """ + return self.__cluster_ci_expansion + @property def ci(self): """ @@ -599,6 +614,10 @@ def _check_errors(self, x, y, idx, experiment, experiment_label, x1_level): err = "`id_col` was given as '{}'; however, '{}' is not a column in `data`.".format(self.__id_col, self.__id_col) raise IndexError(err) + # Check if `cluster_ci_expansion` is valid + if not isinstance(self.__cluster_ci_expansion, (bool, np.bool_)): + raise TypeError("`cluster_ci_expansion` must be True or False.") + # Check if `cluster_col` is valid if self.__cluster_col is not None: if self.__cluster_col not in self.__output_data.columns: @@ -609,6 +628,12 @@ def _check_errors(self, x, y, idx, experiment, experiment_label, x1_level): err = "`cluster_col` cannot be the same column as `y`." raise ValueError(err) + x_columns = x if isinstance(x, (list, tuple)) else [x] + if self.__cluster_col in x_columns: + err1 = "`cluster_col` cannot be the same column as `x`: every group would " + err2 = "then be a single cluster, leaving nothing to resample." + raise ValueError(err1 + err2) + if x is None and idx is not None: # Wide format: the cluster column cannot also be one of the groups. groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))] @@ -755,6 +780,7 @@ def _compute_effectsize_dfs(self): x2=self.__x2, mini_meta=self.__is_mini_meta, ps_adjust=self.__ps_adjust, + cluster_ci_expansion=self.__cluster_ci_expansion, ) self.__mean_diff = EffectSizeDataFrame( diff --git a/dabest/_delta_objects.py b/dabest/_delta_objects.py index 3a201cfe..1685785f 100644 --- a/dabest/_delta_objects.py +++ b/dabest/_delta_objects.py @@ -18,6 +18,29 @@ import datetime as dt # %% ../nbs/API/delta_objects.ipynb #1bb53e06 +def _bca_interval_idx(bias, acceleration, resamples, ci, ci_expanded=None): + """ + Indexes of the BCa interval limits. When `ci_expanded` is given (the + interval is expanded for a small number of clusters), the interval is read + at that level; if the BCa adjustment is undefined there, the expanded + percentile limits are used instead. + """ + from ._stats_tools import confint_2group_diff as ci2g + + if ci_expanded is None: + return ci2g.compute_interval_limits(bias, acceleration, resamples, ci) + + low, high = ci2g.expanded_interval_limits(bias, acceleration, resamples, ci_expanded) + if (isnan(low) or isnan(high)) and np.isfinite(bias): + warnings.warn( + "The bias-corrected and accelerated adjustment is undefined at the " + "expanded confidence level; the expanded percentile interval is " + "reported in its place." + ) + low, high = ci2g.percentile_interval_idx(ci_expanded, resamples) + return low, high + + class DeltaDelta(object): r""" A class to compute and store the delta-delta statistics for experiments with a 2-by-2 arrangement where two independent variables, A and B, each have two categorical values, 1 and 2. The data is divided into two pairs of two groups, and a primary delta is first calculated as the mean difference between each of the pairs: @@ -48,7 +71,8 @@ class DeltaDelta(object): """ def __init__( - self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95 + self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95, + ci_expanded=None, ): from ._stats_tools import effsize as es from ._stats_tools import confint_1group as ci1g @@ -57,6 +81,9 @@ def __init__( self.__effsizedf = effectsizedataframe.results self.__dabest_obj = effectsizedataframe.dabest_obj self.__ci = ci + # The level at which the bootstrap distribution is read when the interval + # is expanded for a small number of clusters (see `expanded_ci_level`). + self.__ci_expanded = ci_expanded self.__resamples = effectsizedataframe.resamples self.__effect_size = effectsizedataframe.effect_size self.__alpha = ci2g._compute_alpha_from_ci(ci) @@ -88,8 +115,9 @@ def __init__( self.__acceleration_value = ci2g._calc_accel(self.__jackknives) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( - self.__bias_correction, self.__acceleration_value, self.__resamples, ci + bca_idx_low, bca_idx_high = _bca_interval_idx( + self.__bias_correction, self.__acceleration_value, self.__resamples, ci, + self.__ci_expanded, ) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -128,8 +156,9 @@ def __init__( warnings.warn(err_temp.substitute(lim_type="upper"), stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples + ) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_delta_delta[pct_idx_low] @@ -189,8 +218,14 @@ def __repr__(self, header=True, sigfig=3): pvalue = p1 + p2 bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs1 = "{} cluster bootstrap samples were taken; ".format(self.__resamples) + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = ( "Any p-value reported is the probability of observing the " @@ -221,11 +256,13 @@ def __compute_results(self): # With some inspiration from @jungyangliao delta_delta_results_df = pd.Series(self.to_dict()).to_frame().T - column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', - 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', + column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', + 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', 'bootstraps_delta_delta', 'permutations_control', 'permutations_test', 'permutations_delta_delta', 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives' ] + if self.__ci_expanded is not None: + column_index.insert(column_index.index('ci') + 1, 'ci_expanded') delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]] delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]] delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]] @@ -242,6 +279,15 @@ def ci(self): """ return self.__ci + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters. None if the interval was not expanded. + """ + return self.__ci_expanded + @property def alpha(self): """ @@ -440,6 +486,24 @@ def __init__(self, effectsizedataframe, permutation_count, self.__bootstraps_variance = ci2g.calculate_bootstraps_var(self.__bootstraps) + # Expand the interval for a small number of clusters. The weighted delta + # averages the experiments' deltas with weights w_j, so experiment j + # contributes (w_j / sum(w))^2 of its own variance; its stratum + # components are scaled accordingly and combined across experiments. + self.__ci_expanded = None + if (getattr(self.__dabest_obj, "cluster_col", None) is not None + and getattr(effectsizedataframe, "cluster_ci_expansion", False)): + per_experiment = effectsizedataframe._expansion_components + if all(c is not None for c in per_experiment): + weights = 1 / self.__bootstraps_variance + shares = weights / weights.sum() + combined = [(v * share ** 2, n) + for components, share in zip(per_experiment, shares) + for v, n in components] + level, df = ci2g.expanded_ci_level(ci, combined) + if df is not None: + self.__ci_expanded = level + # Compute the weighted average mean differences of the bootstrap data # using the pooled group variances of the raw data as the inverse of # weights @@ -464,9 +528,9 @@ def __init__(self, effectsizedataframe, permutation_count, self.__acceleration_value = ci2g._calc_accel(self.__jackknives) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = _bca_interval_idx( self.__bias_correction, self.__acceleration_value, - self.__resamples, ci) + self.__resamples, ci, self.__ci_expanded) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -506,8 +570,8 @@ def __init__(self, effectsizedataframe, permutation_count, stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha/2) * self.__resamples) - pct_idx_high = int((1-(self.__alpha/2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_weighted_deltas[pct_idx_low] @@ -587,8 +651,14 @@ def __repr__(self, header=True, sigfig=3): bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs1 = "{} cluster bootstrap samples were taken; ".format(self.__resamples) + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = "Any p-value reported is the probability of observing the" + \ "effect size (or greater),\nassuming the null hypothesis of " + \ @@ -627,6 +697,8 @@ def __compute_results(self): 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps', 'bootstraps_weighted_delta', 'permutations', 'permutations_var', 'permutations_weighted_delta', 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives'] + if self.__ci_expanded is not None: + column_index.insert(column_index.index('ci') + 1, 'ci_expanded') mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index) mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True) @@ -641,6 +713,15 @@ def ci(self): """ return self.__ci + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters. None if the interval was not expanded. + """ + return self.__ci_expanded + @property def alpha(self): diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index e26f7fee..861d66cb 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -69,6 +69,11 @@ class TwoGroupsEffectSize(object): observations from the same cluster. A label present in both arrays denotes the same cluster. For paired data the two arrays must be identical, since observations are paired by position. + cluster_ci_expansion : boolean, default True + Only used when clusters are supplied. If True, the confidence + intervals are expanded for a small number of clusters (see + `dabest.load`); if False, the unexpanded cluster-bootstrap + intervals are reported. Returns @@ -94,6 +99,10 @@ class TwoGroupsEffectSize(object): The bias-corrected and accelerated confidence interval lower limit and upper limits, respectively. `pct_low, pct_high` : float The percentile confidence interval lower limit and upper limits, respectively. + `ci_expanded` : float or None + For clustered data, the confidence level at which the bootstrap + distribution was read so that the reported `ci`% intervals allow for + a small number of clusters; None if the intervals were not expanded. """ def __init__( @@ -110,6 +119,7 @@ def __init__( ps_adjust=False, control_clusters=None, test_clusters=None, + cluster_ci_expansion=True, ): from ._stats_tools import confint_2group_diff as ci2g from ._stats_tools import effsize as es @@ -131,6 +141,9 @@ def __init__( self.__is_proportional = proportional self.__ps_adjust = ps_adjust self.__is_clustered = control_clusters is not None or test_clusters is not None + if not isinstance(cluster_ci_expansion, (bool, np.bool_)): + raise TypeError("`cluster_ci_expansion` must be True or False.") + self.__cluster_ci_expansion = bool(cluster_ci_expansion) self._check_errors(control, test, control_clusters, test_clusters) # Convert to numpy arrays for speed. @@ -165,7 +178,7 @@ def __init__( ) if self.__is_clustered: - self.__jackknives = ci2g.compute_cluster_jackknife( + jackknives, deleted, codes, n_codes = ci2g.cluster_jackknife_by_cluster( self.__control, self.__test, self.__control_clusters, @@ -173,13 +186,25 @@ def __init__( self.__is_paired, self.__effect_size, ) + self.__jackknives = jackknives + # How the jackknife variance splits across the resampling strata, + # used to expand the interval for small numbers of clusters. + self.__expansion_components = ci2g.cluster_variance_components( + jackknives, deleted, codes, n_codes + ) else: self.__jackknives = ci2g.compute_meandiff_jackknife( self.__control, self.__test, self.__is_paired, self.__effect_size ) + self.__expansion_components = None self.__acceleration_value = ci2g._calc_accel(self.__jackknives) + # Small-sample expansion of the interval for clustered data. + self.__ci_expanded, self.__expansion_df = self._expanded_level( + self.__expansion_components + ) + if self.__is_clustered: bootstraps = ci2g.compute_cluster_bootstrapped_diff( self.__control, @@ -225,13 +250,14 @@ def __init__( self._compute_bca_intervals(sorted_bootstraps) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self._interval_level(), self.__resamples + ) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_bootstraps[pct_idx_low] self.__pct_high = sorted_bootstraps[pct_idx_high] - + self._get_bootstrap_baseline_ec() self._perform_statistical_test() @@ -290,8 +316,13 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): p2 = "calculated for legacy purposes only. " pvalue = p1 + p2 - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = ( "Any p-value reported is the probability of observing the" @@ -355,18 +386,76 @@ def _check_errors(self, control, test, control_clusters=None, test_clusters=None ) raise ValueError(err1) - def _compute_bca_intervals(self, sorted_bootstraps): + def _expanded_level(self, components): ''' - Function to compute the bca intervals given the sorted bootstraps. + The level at which to read the cluster-bootstrap distribution, expanded + for small numbers of clusters, and its degrees of freedom. Returns + `(None, None)` when the interval is not expanded. ''' from ._stats_tools import confint_2group_diff as ci2g + if not (self.__is_clustered and self.__cluster_ci_expansion): + return None, None + + ci_expanded, df = ci2g.expanded_ci_level(self.__ci, components) + if df is None: + warnings.warn( + "There are too few clusters (fewer than 2 in every resampling stratum) " + "to expand the confidence interval for a small number of clusters; " + "the unexpanded interval is reported, and it will be too narrow." + ) + return None, None + # In simulations, expanded intervals came close to nominal coverage once + # there were at least 6 clusters in all, and at least 4 in the smallest + # group of clusters that sets the degrees of freedom. + n_total = sum(n for _, n in components if n >= 2) + if n_total < 6 or df + 1 < 4: + warnings.warn( + "Only {} clusters are available to resample ({} in the smallest group of " + "clusters); even after expansion for the small number of clusters, the " + "confidence interval is unreliable and likely too narrow. At least 6 " + "clusters, and at least 4 in every group of clusters, are " + "recommended.".format(int(n_total), int(df + 1)) + ) + return ci_expanded, df + + def _interval_level(self): + ''' + The confidence level at which the bootstrap distribution is read: + the expanded level when the interval is expanded, otherwise `ci`. + ''' + return self.__ci_expanded if self.__ci_expanded is not None else self.__ci + + def _bca_interval_idx(self, bias, acceleration, ci_expanded): + ''' + Indexes of the BCa interval limits. When `ci_expanded` is given, the + interval is read at that expanded level; if the BCa adjustment is + undefined there, the expanded percentile limits are used instead. + ''' + from ._stats_tools import confint_2group_diff as ci2g + + if ci_expanded is None: + return ci2g.compute_interval_limits(bias, acceleration, self.__resamples, self.__ci) + + low, high = ci2g.expanded_interval_limits(bias, acceleration, self.__resamples, ci_expanded) + if (isnan(low) or isnan(high)) and np.isfinite(bias): + warnings.warn( + "The bias-corrected and accelerated adjustment is undefined at the " + "expanded confidence level; the expanded percentile interval is " + "reported in its place." + ) + low, high = ci2g.percentile_interval_idx(ci_expanded, self.__resamples) + return low, high + + def _compute_bca_intervals(self, sorted_bootstraps): + ''' + Function to compute the bca intervals given the sorted bootstraps. + ''' # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = self._bca_interval_idx( self.__bias_correction, self.__acceleration_value, - self.__resamples, - self.__ci, + self.__ci_expanded, ) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -545,16 +634,28 @@ def _get_bootstrap_baseline_ec(self): # so the clusters of the second copy are given distinct labels. (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters) codes_copy = codes + n_clusters - jackknives = ci2g.compute_cluster_jackknife( + jackknives, deleted, jack_codes, n_codes = ci2g.cluster_jackknife_by_cluster( self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size ) + bec_components = ci2g.cluster_variance_components(jackknives, deleted, jack_codes, n_codes) else: jackknives = ci2g.compute_meandiff_jackknife( self.__control, self.__control, is_paired, self.__effect_size ) + bec_components = None acceleration_value = ci2g._calc_accel(jackknives) + # The baseline curve is expanded for small numbers of clusters in the same + # way as the effect size itself; the warning for too few clusters, if any, + # has already been given for the effect size. + bec_ci_expanded = None + if self.__ci_expanded is not None: + level, df = ci2g.expanded_ci_level(self.__ci, bec_components) + if df is not None: + bec_ci_expanded = level + self.__bec_ci_expanded = bec_ci_expanded + if self.__is_clustered: bootstraps = ci2g.compute_cluster_bootstrapped_diff( self.__control, @@ -585,11 +686,10 @@ def _get_bootstrap_baseline_ec(self): ) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = self._bca_interval_idx( bias_correction, acceleration_value, - self.__resamples, - self.__ci, + bec_ci_expanded, ) self.__bec_bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -628,8 +728,9 @@ def _get_bootstrap_baseline_ec(self): warnings.warn(err_temp.substitute(lim_type="upper"), stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + bec_ci_expanded if bec_ci_expanded is not None else self.__ci, self.__resamples + ) self.__bec_pct_interval_idx = (pct_idx_low, pct_idx_high) self.__bec_pct_low = sorted_bootstraps[pct_idx_low] @@ -673,6 +774,40 @@ def n_clusters(self): """ return self.__n_clusters + @property + def cluster_ci_expansion(self): + """ + Whether the confidence interval of clustered data is expanded for a + small number of clusters. + """ + return self.__cluster_ci_expansion + + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters (see `dabest.load`'s `cluster_ci_expansion`). + None if the interval was not expanded. + """ + return self.__ci_expanded + + @property + def expansion_df(self): + """ + The degrees of freedom used to expand the confidence interval for a + small number of clusters; None if the interval was not expanded. + """ + return self.__expansion_df + + @property + def _expansion_components(self): + """ + The stratum-by-stratum `(variance, n_clusters)` components of the + cluster jackknife variance; None if the observations are not clustered. + """ + return self.__expansion_components + @property def ci(self): """ @@ -956,6 +1091,7 @@ def __init__( experiment_label=None, mini_meta=False, ps_adjust=False, + cluster_ci_expansion=True, ): """ Parses the data from a Dabest object, enabling plotting and printing @@ -976,6 +1112,9 @@ def __init__( self.__delta2 = delta2 self.__is_mini_meta = mini_meta self.__ps_adjust = ps_adjust + self.__cluster_ci_expansion = cluster_ci_expansion + self.__expansion_components = [] + self.__delta2_ci_expanded = None def __pre_calc(self): from .misc_tools import print_greeting, get_varname @@ -989,6 +1128,8 @@ def __pre_calc(self): out = [] reprs = [] + self.__expansion_components = [] + self.__delta2_ci_expanded = None grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)} @@ -1027,6 +1168,15 @@ def __pre_calc(self): self.__is_proportional, clusters=mixed_clusters if cluster_col is not None else None, ) + if cluster_col is not None and self.__cluster_ci_expansion: + # Expand the delta-delta interval for a small number of clusters. + components = ci2g.delta2_cluster_variance_components( + *[np.asarray(x) for x in mixed_data[:4]], + *mixed_clusters[:4], + self.__is_paired, + ) + level, df = ci2g.expanded_ci_level(self.__ci, components) + self.__delta2_ci_expanded = level if df is not None else None for j, current_tuple in enumerate(idx): if self.__is_paired != "sequential": @@ -1051,7 +1201,9 @@ def __pre_calc(self): self.__ps_adjust, control_clusters=grouped_clusters[cname], test_clusters=grouped_clusters[tname], + cluster_ci_expansion=self.__cluster_ci_expansion, ) + self.__expansion_components.append(result._expansion_components) r_dict = result.to_dict() r_dict["control"] = cname r_dict["test"] = tname @@ -1095,6 +1247,7 @@ def __pre_calc(self): "is_paired", "difference", "ci", + "ci_expanded", "bca_low", "bca_high", "bca_interval_idx", @@ -1150,7 +1303,8 @@ def __pre_calc(self): ) elif self.__delta2: self.__delta_delta = DeltaDelta( - self, self.__permutation_count, bootstraps_delta_delta, self.__ci + self, self.__permutation_count, bootstraps_delta_delta, self.__ci, + ci_expanded=self.__delta2_ci_expanded, ) reprs.append(self.__delta_delta.__repr__(header=False)) @@ -1686,6 +1840,8 @@ def statistical_tests(self): if "n_clusters" in results_df.columns: default_cols.insert(default_cols.index("effect_size"), "n_clusters") + if "ci_expanded" in results_df.columns: + default_cols.insert(default_cols.index("ci") + 1, "ci_expanded") cols_of_interest = default_cols + stats_columns @@ -1695,6 +1851,27 @@ def statistical_tests(self): def _for_print(self): return self.__for_print + @property + def cluster_ci_expansion(self): + """ + Whether confidence intervals of clustered data are expanded for a small + number of clusters. + """ + return self.__cluster_ci_expansion + + @property + def _expansion_components(self): + """ + For each comparison, in the order of `results`, the stratum-by-stratum + `(variance, n_clusters)` components of its cluster jackknife variance, + or None if the observations are not clustered. + """ + try: + self.__results + except AttributeError: + self.__pre_calc() + return self.__expansion_components + @property def _plot_data(self): return self.__dabest_obj._plot_data diff --git a/dabest/_modidx.py b/dabest/_modidx.py index c0a19c53..f0fd1bec 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -39,10 +39,14 @@ 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.cluster_codes': ( 'API/confint_2group_diff.html#cluster_codes', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_jackknife_by_cluster': ( 'API/confint_2group_diff.html#cluster_jackknife_by_cluster', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.cluster_strata': ( 'API/confint_2group_diff.html#cluster_strata', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.cluster_tables': ( 'API/confint_2group_diff.html#cluster_tables', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_variance_components': ( 'API/confint_2group_diff.html#cluster_variance_components', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_bootstrapped_diff', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_cluster_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_cluster_bootstrapped_diff', @@ -65,8 +69,16 @@ 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.delta2_cluster_bootstrap_loop': ( 'API/confint_2group_diff.html#delta2_cluster_bootstrap_loop', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.delta2_cluster_variance_components': ( 'API/confint_2group_diff.html#delta2_cluster_variance_components', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.expand_cluster_draw': ( 'API/confint_2group_diff.html#expand_cluster_draw', - 'dabest/_stats_tools/confint_2group_diff.py')}, + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expanded_ci_level': ( 'API/confint_2group_diff.html#expanded_ci_level', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expanded_interval_limits': ( 'API/confint_2group_diff.html#expanded_interval_limits', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.percentile_interval_idx': ( 'API/confint_2group_diff.html#percentile_interval_idx', + 'dabest/_stats_tools/confint_2group_diff.py')}, 'dabest._stats_tools.effsize': { 'dabest._stats_tools.effsize._cliffs_delta_core': ( 'API/effsize.html#_cliffs_delta_core', 'dabest/_stats_tools/effsize.py'), 'dabest._stats_tools.effsize._compute_hedges_correction_factor': ( 'API/effsize.html#_compute_hedges_correction_factor', diff --git a/dabest/_stats_tools/confint_2group_diff.py b/dabest/_stats_tools/confint_2group_diff.py index 06667787..ae2b9431 100644 --- a/dabest/_stats_tools/confint_2group_diff.py +++ b/dabest/_stats_tools/confint_2group_diff.py @@ -7,10 +7,11 @@ # %% auto #0 __all__ = ['create_jackknife_indexes', 'create_repeated_indexes', 'compute_meandiff_jackknife', 'bootstrap_indices', 'compute_bootstrapped_diff', 'cluster_codes', 'cluster_tables', 'cluster_strata', 'cluster_bootstrap_draws', - 'expand_cluster_draw', 'compute_cluster_jackknife', 'compute_cluster_bootstrapped_diff', - 'delta2_cluster_bootstrap_loop', 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', - 'compute_meandiff_bias_correction', 'compute_interval_limits', 'calculate_group_var', - 'calculate_bootstraps_var', 'calculate_weighted_delta'] + 'expand_cluster_draw', 'compute_cluster_jackknife', 'cluster_jackknife_by_cluster', + 'cluster_variance_components', 'expanded_ci_level', 'percentile_interval_idx', 'expanded_interval_limits', + 'compute_cluster_bootstrapped_diff', 'delta2_cluster_bootstrap_loop', 'delta2_cluster_variance_components', + 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', 'compute_meandiff_bias_correction', + 'compute_interval_limits', 'calculate_group_var', 'calculate_bootstraps_var', 'calculate_weighted_delta'] # %% ../../nbs/API/confint_2group_diff.ipynb #fa733643 import numpy as np @@ -297,6 +298,21 @@ def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size): observations are clustered. `c0` and `c1` hold the cluster label of each observation in `x0` and `x1`. """ + values, _, _, _ = cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size) + return values + + +def cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size): + """ + Delete-one-cluster jackknife of the effect size for 2 groups, keeping track + of which cluster each jackknife value leaves out. + + Returns `(values, deleted_codes, (codes0, codes1), n_clusters)`, where + `values[i]` is the effect size with cluster `deleted_codes[i]` removed, and + `codes0`/`codes1` are the integer cluster codes of the observations in + `x0`/`x1` (see `cluster_codes`). Clusters whose removal would empty a group + are skipped. + """ from . import effsize as __es x0, x1 = np.asarray(x0), np.asarray(x1) @@ -304,15 +320,141 @@ def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size): if is_paired: _check_paired_clusters(c0, c1) - out = [] + values, deleted = [], [] for g in range(n_clusters): keep0 = c0 != g keep1 = c1 != g if not keep0.any() or not keep1.any(): # Deleting this cluster would empty one of the groups. continue - out.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size)) - return out + values.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size)) + deleted.append(g) + return values, deleted, (c0, c1), n_clusters + + +def cluster_variance_components(jackknife_values, deleted_codes, codes_per_group, n_clusters): + """ + Split the delete-one-cluster jackknife variance of an estimate into the + contributions of the resampling strata (see `cluster_strata`). + + Returns a list of `(variance, n)` pairs, one per stratum of `n` clusters, + where `variance` is that stratum's term of the stratified jackknife + variance estimate. Strata with fewer than 2 clusters are left out: the + cluster bootstrap cannot vary them, and they carry no information about + the number of degrees of freedom. Non-finite jackknife values are ignored. + """ + strata_clusters, strata_offsets = cluster_strata(codes_per_group, n_clusters) + value_of = {g: v for g, v in zip(deleted_codes, jackknife_values) if np.isfinite(v)} + + components = [] + for s in range(len(strata_offsets) - 1): + members = strata_clusters[strata_offsets[s] : strata_offsets[s + 1]] + n = len(members) + if n < 2: + continue + values = np.array([value_of[g] for g in members if g in value_of], dtype=float) + if len(values) < 2: + continue + variance = (n - 1) / n * np.sum((values - values.mean()) ** 2) + components.append((float(variance), int(n))) + return components + + +# The smallest tail probability an expanded interval is read at. It keeps the +# quantile functions finite; any value this small already selects the extreme +# bootstrap resamples for any practical number of resamples. +_MIN_EXPANDED_ALPHA = 1e-6 + +# Strata carrying less than this share of the variance do not set the degrees +# of freedom, so that a stray handful of clusters (say, two participants seen in +# only one condition) cannot inflate the expansion. +_MIN_VARIANCE_SHARE_FOR_DF = 0.1 + + +def expanded_ci_level(ci, components): + """ + The confidence level at which to read a cluster-bootstrap distribution so + that the resulting interval has approximately `ci`% coverage when there + are few clusters. + + Bootstrap intervals are too narrow when there are few independent units: + the bootstrap reproduces a variance with divisor `n` rather than `n - 1`, + and normal rather than t-distributed tails. This applies the expanded + percentile correction of Hesterberg (2015, The American Statistician, + 69(4), 371-386) with the number of clusters as `n`: the interval is read + at the level whose normal quantile equals `sqrt(n/(n-1))` times the + t quantile with `n - 1` degrees of freedom. + + When the bootstrap resamples several strata independently (for example + clusters nested within groups), `components` holds each stratum's + `(variance, n)` (see `cluster_variance_components`). The narrowness + correction is then applied stratum by stratum, weighted by each stratum's + share of the variance, and the degrees of freedom are those of the + smallest stratum carrying at least 10% of the variance. This is the + conservative (Hsu) alternative to the Welch-Satterthwaite approximation, + which in simulations under-covered for unbalanced and mixed designs. Both + reduce to the single-sample correction above for one stratum. + + Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least + 2 clusters, in which case no expansion is possible. + """ + from scipy.stats import t as student_t + + components = [(v, n) for v, n in components if n >= 2] + if not components: + return ci, None + + variances = np.array([v for v, _ in components], dtype=float) + n = np.array([n for _, n in components], dtype=float) + if not np.all(np.isfinite(variances)) or variances.sum() <= 0: + # No usable variance information: weight the strata equally. + variances = np.ones_like(n) + + total = variances.sum() + narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n)) + shares = variances / total + # Never let the threshold exclude every stratum (e.g. many equal strata). + threshold = min(_MIN_VARIANCE_SHARE_FOR_DF, shares.max()) + df = float(n[shares >= threshold].min() - 1) + + alpha = _compute_alpha_from_ci(ci) + z = narrowness * student_t.ppf(1 - alpha / 2, df) + alpha_expanded = max(2 * norm.sf(z), _MIN_EXPANDED_ALPHA) + return 100 * (1 - alpha_expanded), float(df) + + +def percentile_interval_idx(ci, n_boots): + """ + Indexes of the percentile interval limits in a sorted array of `n_boots` + bootstrap values, kept within the array. + """ + alpha = _compute_alpha_from_ci(ci) + low = int((alpha / 2) * n_boots) + high = int((1 - alpha / 2) * n_boots) + return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + + +def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded): + """ + Indexes of the BCa interval limits at the expanded level `ci_expanded` + (see `expanded_ci_level`), kept within the array of bootstrap values. + + Returns `(nan, nan)` if the BCa adjustment is undefined at this level, + which can happen when a large acceleration meets a very extreme level; + callers should then fall back to the expanded percentile interval. + """ + alpha = _compute_alpha_from_ci(ci_expanded) + for z in (norm.ppf(alpha / 2), norm.ppf(1 - alpha / 2)): + if not np.isfinite(bias) or not np.isfinite(acceleration) or 1 - acceleration * (bias + z) <= 0: + return np.nan, np.nan + + low, high = compute_interval_limits(bias, acceleration, n_boots, ci_expanded) + if isnan(low) or isnan(high): + return np.nan, np.nan + low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + if low > high: + return np.nan, np.nan + return low, high def compute_cluster_bootstrapped_diff( @@ -385,6 +527,32 @@ def delta2_cluster_bootstrap_loop( return out_delta_g, deltadelta +def delta2_cluster_variance_components(x1, x2, x3, x4, c1, c2, c3, c4, is_paired): + """ + Stratum-by-stratum jackknife variance components of the delta-delta + `(mean(x4) - mean(x3)) - (mean(x2) - mean(x1))`, for use with + `expanded_ci_level`. Delta g divides the delta-delta by a constant, which + leaves the relative size of the components, and so the expansion, + unchanged. + """ + xs = [np.asarray(x) for x in (x1, x2, x3, x4)] + codes, n_clusters = cluster_codes(c1, c2, c3, c4) + if is_paired: + _check_paired_clusters(codes[0], codes[1]) + _check_paired_clusters(codes[2], codes[3]) + + values, deleted = [], [] + for g in range(n_clusters): + keeps = [c != g for c in codes] + if not all(k.any() for k in keeps): + # Deleting this cluster would empty one of the groups. + continue + means = [x[k].mean() for x, k in zip(xs, keeps)] + values.append((means[3] - means[2]) - (means[1] - means[0])) + deleted.append(g) + return cluster_variance_components(values, deleted, codes, n_clusters) + + @njit(cache=True) def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False): """ diff --git a/nbs/API/confint_2group_diff.ipynb b/nbs/API/confint_2group_diff.ipynb index b769a133..df221657 100644 --- a/nbs/API/confint_2group_diff.ipynb +++ b/nbs/API/confint_2group_diff.ipynb @@ -347,6 +347,21 @@ " observations are clustered. `c0` and `c1` hold the cluster label of each\n", " observation in `x0` and `x1`.\n", " \"\"\"\n", + " values, _, _, _ = cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size)\n", + " return values\n", + "\n", + "\n", + "def cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size):\n", + " \"\"\"\n", + " Delete-one-cluster jackknife of the effect size for 2 groups, keeping track\n", + " of which cluster each jackknife value leaves out.\n", + "\n", + " Returns `(values, deleted_codes, (codes0, codes1), n_clusters)`, where\n", + " `values[i]` is the effect size with cluster `deleted_codes[i]` removed, and\n", + " `codes0`/`codes1` are the integer cluster codes of the observations in\n", + " `x0`/`x1` (see `cluster_codes`). Clusters whose removal would empty a group\n", + " are skipped.\n", + " \"\"\"\n", " from . import effsize as __es\n", "\n", " x0, x1 = np.asarray(x0), np.asarray(x1)\n", @@ -354,15 +369,141 @@ " if is_paired:\n", " _check_paired_clusters(c0, c1)\n", "\n", - " out = []\n", + " values, deleted = [], []\n", " for g in range(n_clusters):\n", " keep0 = c0 != g\n", " keep1 = c1 != g\n", " if not keep0.any() or not keep1.any():\n", " # Deleting this cluster would empty one of the groups.\n", " continue\n", - " out.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size))\n", - " return out\n", + " values.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size))\n", + " deleted.append(g)\n", + " return values, deleted, (c0, c1), n_clusters\n", + "\n", + "\n", + "def cluster_variance_components(jackknife_values, deleted_codes, codes_per_group, n_clusters):\n", + " \"\"\"\n", + " Split the delete-one-cluster jackknife variance of an estimate into the\n", + " contributions of the resampling strata (see `cluster_strata`).\n", + "\n", + " Returns a list of `(variance, n)` pairs, one per stratum of `n` clusters,\n", + " where `variance` is that stratum's term of the stratified jackknife\n", + " variance estimate. Strata with fewer than 2 clusters are left out: the\n", + " cluster bootstrap cannot vary them, and they carry no information about\n", + " the number of degrees of freedom. Non-finite jackknife values are ignored.\n", + " \"\"\"\n", + " strata_clusters, strata_offsets = cluster_strata(codes_per_group, n_clusters)\n", + " value_of = {g: v for g, v in zip(deleted_codes, jackknife_values) if np.isfinite(v)}\n", + "\n", + " components = []\n", + " for s in range(len(strata_offsets) - 1):\n", + " members = strata_clusters[strata_offsets[s] : strata_offsets[s + 1]]\n", + " n = len(members)\n", + " if n < 2:\n", + " continue\n", + " values = np.array([value_of[g] for g in members if g in value_of], dtype=float)\n", + " if len(values) < 2:\n", + " continue\n", + " variance = (n - 1) / n * np.sum((values - values.mean()) ** 2)\n", + " components.append((float(variance), int(n)))\n", + " return components\n", + "\n", + "\n", + "# The smallest tail probability an expanded interval is read at. It keeps the\n", + "# quantile functions finite; any value this small already selects the extreme\n", + "# bootstrap resamples for any practical number of resamples.\n", + "_MIN_EXPANDED_ALPHA = 1e-6\n", + "\n", + "# Strata carrying less than this share of the variance do not set the degrees\n", + "# of freedom, so that a stray handful of clusters (say, two participants seen in\n", + "# only one condition) cannot inflate the expansion.\n", + "_MIN_VARIANCE_SHARE_FOR_DF = 0.1\n", + "\n", + "\n", + "def expanded_ci_level(ci, components):\n", + " \"\"\"\n", + " The confidence level at which to read a cluster-bootstrap distribution so\n", + " that the resulting interval has approximately `ci`% coverage when there\n", + " are few clusters.\n", + "\n", + " Bootstrap intervals are too narrow when there are few independent units:\n", + " the bootstrap reproduces a variance with divisor `n` rather than `n - 1`,\n", + " and normal rather than t-distributed tails. This applies the expanded\n", + " percentile correction of Hesterberg (2015, The American Statistician,\n", + " 69(4), 371-386) with the number of clusters as `n`: the interval is read\n", + " at the level whose normal quantile equals `sqrt(n/(n-1))` times the\n", + " t quantile with `n - 1` degrees of freedom.\n", + "\n", + " When the bootstrap resamples several strata independently (for example\n", + " clusters nested within groups), `components` holds each stratum's\n", + " `(variance, n)` (see `cluster_variance_components`). The narrowness\n", + " correction is then applied stratum by stratum, weighted by each stratum's\n", + " share of the variance, and the degrees of freedom are those of the\n", + " smallest stratum carrying at least 10% of the variance. This is the\n", + " conservative (Hsu) alternative to the Welch-Satterthwaite approximation,\n", + " which in simulations under-covered for unbalanced and mixed designs. Both\n", + " reduce to the single-sample correction above for one stratum.\n", + "\n", + " Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least\n", + " 2 clusters, in which case no expansion is possible.\n", + " \"\"\"\n", + " from scipy.stats import t as student_t\n", + "\n", + " components = [(v, n) for v, n in components if n >= 2]\n", + " if not components:\n", + " return ci, None\n", + "\n", + " variances = np.array([v for v, _ in components], dtype=float)\n", + " n = np.array([n for _, n in components], dtype=float)\n", + " if not np.all(np.isfinite(variances)) or variances.sum() <= 0:\n", + " # No usable variance information: weight the strata equally.\n", + " variances = np.ones_like(n)\n", + "\n", + " total = variances.sum()\n", + " narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n))\n", + " shares = variances / total\n", + " # Never let the threshold exclude every stratum (e.g. many equal strata).\n", + " threshold = min(_MIN_VARIANCE_SHARE_FOR_DF, shares.max())\n", + " df = float(n[shares >= threshold].min() - 1)\n", + "\n", + " alpha = _compute_alpha_from_ci(ci)\n", + " z = narrowness * student_t.ppf(1 - alpha / 2, df)\n", + " alpha_expanded = max(2 * norm.sf(z), _MIN_EXPANDED_ALPHA)\n", + " return 100 * (1 - alpha_expanded), float(df)\n", + "\n", + "\n", + "def percentile_interval_idx(ci, n_boots):\n", + " \"\"\"\n", + " Indexes of the percentile interval limits in a sorted array of `n_boots`\n", + " bootstrap values, kept within the array.\n", + " \"\"\"\n", + " alpha = _compute_alpha_from_ci(ci)\n", + " low = int((alpha / 2) * n_boots)\n", + " high = int((1 - alpha / 2) * n_boots)\n", + " return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + "\n", + "\n", + "def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded):\n", + " \"\"\"\n", + " Indexes of the BCa interval limits at the expanded level `ci_expanded`\n", + " (see `expanded_ci_level`), kept within the array of bootstrap values.\n", + "\n", + " Returns `(nan, nan)` if the BCa adjustment is undefined at this level,\n", + " which can happen when a large acceleration meets a very extreme level;\n", + " callers should then fall back to the expanded percentile interval.\n", + " \"\"\"\n", + " alpha = _compute_alpha_from_ci(ci_expanded)\n", + " for z in (norm.ppf(alpha / 2), norm.ppf(1 - alpha / 2)):\n", + " if not np.isfinite(bias) or not np.isfinite(acceleration) or 1 - acceleration * (bias + z) <= 0:\n", + " return np.nan, np.nan\n", + "\n", + " low, high = compute_interval_limits(bias, acceleration, n_boots, ci_expanded)\n", + " if isnan(low) or isnan(high):\n", + " return np.nan, np.nan\n", + " low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + " if low > high:\n", + " return np.nan, np.nan\n", + " return low, high\n", "\n", "\n", "def compute_cluster_bootstrapped_diff(\n", @@ -435,6 +576,32 @@ " return out_delta_g, deltadelta\n", "\n", "\n", + "def delta2_cluster_variance_components(x1, x2, x3, x4, c1, c2, c3, c4, is_paired):\n", + " \"\"\"\n", + " Stratum-by-stratum jackknife variance components of the delta-delta\n", + " `(mean(x4) - mean(x3)) - (mean(x2) - mean(x1))`, for use with\n", + " `expanded_ci_level`. Delta g divides the delta-delta by a constant, which\n", + " leaves the relative size of the components, and so the expansion,\n", + " unchanged.\n", + " \"\"\"\n", + " xs = [np.asarray(x) for x in (x1, x2, x3, x4)]\n", + " codes, n_clusters = cluster_codes(c1, c2, c3, c4)\n", + " if is_paired:\n", + " _check_paired_clusters(codes[0], codes[1])\n", + " _check_paired_clusters(codes[2], codes[3])\n", + "\n", + " values, deleted = [], []\n", + " for g in range(n_clusters):\n", + " keeps = [c != g for c in codes]\n", + " if not all(k.any() for k in keeps):\n", + " # Deleting this cluster would empty one of the groups.\n", + " continue\n", + " means = [x[k].mean() for x, k in zip(xs, keeps)]\n", + " values.append((means[3] - means[2]) - (means[1] - means[0]))\n", + " deleted.append(g)\n", + " return cluster_variance_components(values, deleted, codes, n_clusters)\n", + "\n", + "\n", "@njit(cache=True)\n", "def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False):\n", " \"\"\"\n", diff --git a/nbs/API/dabest_object.ipynb b/nbs/API/dabest_object.ipynb index 41c872e5..f1c0a0a8 100644 --- a/nbs/API/dabest_object.ipynb +++ b/nbs/API/dabest_object.ipynb @@ -145,6 +145,7 @@ " mini_meta,\n", " ps_adjust,\n", " cluster_col=None,\n", + " cluster_ci_expansion=True,\n", " ):\n", " \"\"\"\n", " Parses and stores pandas DataFrames in preparation for estimation\n", @@ -165,6 +166,7 @@ " self.__is_mini_meta = mini_meta\n", " self.__ps_adjust = ps_adjust\n", " self.__cluster_col = cluster_col\n", + " self.__cluster_ci_expansion = cluster_ci_expansion\n", "\n", " # after this call the attributes self.__experiment_label and self.__x1_level are updated\n", " self._check_errors(x, y, idx, experiment, experiment_label, x1_level)\n", @@ -237,6 +239,11 @@ " cluster_line1 = \"Whole clusters, as defined by `{}`, \".format(self.__cluster_col)\n", " cluster_line2 = \"will be resampled by the bootstrap and reshuffled by the permutation test.\"\n", " out.append(cluster_line1 + cluster_line2)\n", + " if self.__cluster_ci_expansion:\n", + " out.append(\n", + " \"Confidence intervals will be expanded for the number of clusters \"\n", + " \"(set `cluster_ci_expansion=False` to turn this off).\"\n", + " )\n", "\n", " return \"\\n\".join(out)\n", "\n", @@ -461,6 +468,14 @@ " return self.__cluster_col\n", "\n", " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Returns whether confidence intervals of clustered data are expanded for\n", + " a small number of clusters, as declared to `dabest.load()`.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " The width of the desired confidence interval.\n", @@ -702,6 +717,10 @@ " err = \"`id_col` was given as '{}'; however, '{}' is not a column in `data`.\".format(self.__id_col, self.__id_col)\n", " raise IndexError(err)\n", "\n", + " # Check if `cluster_ci_expansion` is valid\n", + " if not isinstance(self.__cluster_ci_expansion, (bool, np.bool_)):\n", + " raise TypeError(\"`cluster_ci_expansion` must be True or False.\")\n", + "\n", " # Check if `cluster_col` is valid\n", " if self.__cluster_col is not None:\n", " if self.__cluster_col not in self.__output_data.columns:\n", @@ -712,6 +731,12 @@ " err = \"`cluster_col` cannot be the same column as `y`.\"\n", " raise ValueError(err)\n", "\n", + " x_columns = x if isinstance(x, (list, tuple)) else [x]\n", + " if self.__cluster_col in x_columns:\n", + " err1 = \"`cluster_col` cannot be the same column as `x`: every group would \"\n", + " err2 = \"then be a single cluster, leaving nothing to resample.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " if x is None and idx is not None:\n", " # Wide format: the cluster column cannot also be one of the groups.\n", " groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))]\n", @@ -858,6 +883,7 @@ " x2=self.__x2,\n", " mini_meta=self.__is_mini_meta,\n", " ps_adjust=self.__ps_adjust,\n", + " cluster_ci_expansion=self.__cluster_ci_expansion,\n", " )\n", "\n", " self.__mean_diff = EffectSizeDataFrame(\n", diff --git a/nbs/API/delta_objects.ipynb b/nbs/API/delta_objects.ipynb index 91656b16..14b72fb1 100644 --- a/nbs/API/delta_objects.ipynb +++ b/nbs/API/delta_objects.ipynb @@ -120,6 +120,29 @@ "outputs": [], "source": [ "#| export\n", + "def _bca_interval_idx(bias, acceleration, resamples, ci, ci_expanded=None):\n", + " \"\"\"\n", + " Indexes of the BCa interval limits. When `ci_expanded` is given (the\n", + " interval is expanded for a small number of clusters), the interval is read\n", + " at that level; if the BCa adjustment is undefined there, the expanded\n", + " percentile limits are used instead.\n", + " \"\"\"\n", + " from ._stats_tools import confint_2group_diff as ci2g\n", + "\n", + " if ci_expanded is None:\n", + " return ci2g.compute_interval_limits(bias, acceleration, resamples, ci)\n", + "\n", + " low, high = ci2g.expanded_interval_limits(bias, acceleration, resamples, ci_expanded)\n", + " if (isnan(low) or isnan(high)) and np.isfinite(bias):\n", + " warnings.warn(\n", + " \"The bias-corrected and accelerated adjustment is undefined at the \"\n", + " \"expanded confidence level; the expanded percentile interval is \"\n", + " \"reported in its place.\"\n", + " )\n", + " low, high = ci2g.percentile_interval_idx(ci_expanded, resamples)\n", + " return low, high\n", + "\n", + "\n", "class DeltaDelta(object):\n", " r\"\"\"\n", " A class to compute and store the delta-delta statistics for experiments with a 2-by-2 arrangement where two independent variables, A and B, each have two categorical values, 1 and 2. The data is divided into two pairs of two groups, and a primary delta is first calculated as the mean difference between each of the pairs:\n", @@ -150,7 +173,8 @@ " \"\"\"\n", "\n", " def __init__(\n", - " self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95\n", + " self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95,\n", + " ci_expanded=None,\n", " ):\n", " from ._stats_tools import effsize as es\n", " from ._stats_tools import confint_1group as ci1g\n", @@ -159,6 +183,9 @@ " self.__effsizedf = effectsizedataframe.results\n", " self.__dabest_obj = effectsizedataframe.dabest_obj\n", " self.__ci = ci\n", + " # The level at which the bootstrap distribution is read when the interval\n", + " # is expanded for a small number of clusters (see `expanded_ci_level`).\n", + " self.__ci_expanded = ci_expanded\n", " self.__resamples = effectsizedataframe.resamples\n", " self.__effect_size = effectsizedataframe.effect_size\n", " self.__alpha = ci2g._compute_alpha_from_ci(ci)\n", @@ -190,8 +217,9 @@ " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", - " self.__bias_correction, self.__acceleration_value, self.__resamples, ci\n", + " bca_idx_low, bca_idx_high = _bca_interval_idx(\n", + " self.__bias_correction, self.__acceleration_value, self.__resamples, ci,\n", + " self.__ci_expanded,\n", " )\n", "\n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -230,8 +258,9 @@ " warnings.warn(err_temp.substitute(lim_type=\"upper\"), stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples\n", + " )\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_delta_delta[pct_idx_low]\n", @@ -291,8 +320,14 @@ " pvalue = p1 + p2\n", "\n", " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs1 = \"{} cluster bootstrap samples were taken; \".format(self.__resamples)\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = (\n", " \"Any p-value reported is the probability of observing the \"\n", @@ -323,11 +358,13 @@ " # With some inspiration from @jungyangliao\n", " delta_delta_results_df = pd.Series(self.to_dict()).to_frame().T\n", "\n", - " column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', \n", - " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', \n", + " column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx',\n", + " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test',\n", " 'bootstraps_delta_delta', 'permutations_control', 'permutations_test', 'permutations_delta_delta',\n", " 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives'\n", " ]\n", + " if self.__ci_expanded is not None:\n", + " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", " delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]]\n", " delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]]\n", " delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]]\n", @@ -345,6 +382,15 @@ " return self.__ci\n", "\n", " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters. None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", + " @property\n", " def alpha(self):\n", " \"\"\"\n", " Returns the significance level of the statistical test as a float\n", @@ -638,6 +684,24 @@ " \n", " self.__bootstraps_variance = ci2g.calculate_bootstraps_var(self.__bootstraps)\n", "\n", + " # Expand the interval for a small number of clusters. The weighted delta\n", + " # averages the experiments' deltas with weights w_j, so experiment j\n", + " # contributes (w_j / sum(w))^2 of its own variance; its stratum\n", + " # components are scaled accordingly and combined across experiments.\n", + " self.__ci_expanded = None\n", + " if (getattr(self.__dabest_obj, \"cluster_col\", None) is not None\n", + " and getattr(effectsizedataframe, \"cluster_ci_expansion\", False)):\n", + " per_experiment = effectsizedataframe._expansion_components\n", + " if all(c is not None for c in per_experiment):\n", + " weights = 1 / self.__bootstraps_variance\n", + " shares = weights / weights.sum()\n", + " combined = [(v * share ** 2, n)\n", + " for components, share in zip(per_experiment, shares)\n", + " for v, n in components]\n", + " level, df = ci2g.expanded_ci_level(ci, combined)\n", + " if df is not None:\n", + " self.__ci_expanded = level\n", + "\n", " # Compute the weighted average mean differences of the bootstrap data\n", " # using the pooled group variances of the raw data as the inverse of \n", " # weights\n", @@ -662,9 +726,9 @@ " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = _bca_interval_idx(\n", " self.__bias_correction, self.__acceleration_value,\n", - " self.__resamples, ci)\n", + " self.__resamples, ci, self.__ci_expanded)\n", " \n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", "\n", @@ -704,8 +768,8 @@ " stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha/2) * self.__resamples)\n", - " pct_idx_high = int((1-(self.__alpha/2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples)\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_weighted_deltas[pct_idx_low]\n", @@ -785,8 +849,14 @@ "\n", "\n", " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs1 = \"{} cluster bootstrap samples were taken; \".format(self.__resamples)\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = \"Any p-value reported is the probability of observing the\" + \\\n", " \"effect size (or greater),\\nassuming the null hypothesis of \" + \\\n", @@ -825,6 +895,8 @@ " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps', 'bootstraps_weighted_delta', \n", " 'permutations', 'permutations_var', 'permutations_weighted_delta', 'pvalue_permutation', \n", " 'permutation_count', 'bias_correction', 'jackknives']\n", + " if self.__ci_expanded is not None:\n", + " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", " mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index)\n", " mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True)\n", "\n", @@ -839,6 +911,15 @@ " \"\"\"\n", " return self.__ci\n", "\n", + " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters. None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", "\n", " @property\n", " def alpha(self):\n", diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 55394da3..8007c144 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -163,6 +163,11 @@ " observations from the same cluster. A label present in both\n", " arrays denotes the same cluster. For paired data the two arrays\n", " must be identical, since observations are paired by position.\n", + " cluster_ci_expansion : boolean, default True\n", + " Only used when clusters are supplied. If True, the confidence\n", + " intervals are expanded for a small number of clusters (see\n", + " `dabest.load`); if False, the unexpanded cluster-bootstrap\n", + " intervals are reported.\n", " \n", "\n", " Returns\n", @@ -188,6 +193,10 @@ " The bias-corrected and accelerated confidence interval lower limit and upper limits, respectively.\n", " `pct_low, pct_high` : float\n", " The percentile confidence interval lower limit and upper limits, respectively.\n", + " `ci_expanded` : float or None\n", + " For clustered data, the confidence level at which the bootstrap\n", + " distribution was read so that the reported `ci`% intervals allow for\n", + " a small number of clusters; None if the intervals were not expanded.\n", " \"\"\"\n", "\n", " def __init__(\n", @@ -204,6 +213,7 @@ " ps_adjust=False,\n", " control_clusters=None,\n", " test_clusters=None,\n", + " cluster_ci_expansion=True,\n", " ):\n", " from ._stats_tools import confint_2group_diff as ci2g\n", " from ._stats_tools import effsize as es\n", @@ -225,6 +235,9 @@ " self.__is_proportional = proportional\n", " self.__ps_adjust = ps_adjust\n", " self.__is_clustered = control_clusters is not None or test_clusters is not None\n", + " if not isinstance(cluster_ci_expansion, (bool, np.bool_)):\n", + " raise TypeError(\"`cluster_ci_expansion` must be True or False.\")\n", + " self.__cluster_ci_expansion = bool(cluster_ci_expansion)\n", " self._check_errors(control, test, control_clusters, test_clusters)\n", "\n", " # Convert to numpy arrays for speed.\n", @@ -259,7 +272,7 @@ " )\n", "\n", " if self.__is_clustered:\n", - " self.__jackknives = ci2g.compute_cluster_jackknife(\n", + " jackknives, deleted, codes, n_codes = ci2g.cluster_jackknife_by_cluster(\n", " self.__control,\n", " self.__test,\n", " self.__control_clusters,\n", @@ -267,13 +280,25 @@ " self.__is_paired,\n", " self.__effect_size,\n", " )\n", + " self.__jackknives = jackknives\n", + " # How the jackknife variance splits across the resampling strata,\n", + " # used to expand the interval for small numbers of clusters.\n", + " self.__expansion_components = ci2g.cluster_variance_components(\n", + " jackknives, deleted, codes, n_codes\n", + " )\n", " else:\n", " self.__jackknives = ci2g.compute_meandiff_jackknife(\n", " self.__control, self.__test, self.__is_paired, self.__effect_size\n", " )\n", + " self.__expansion_components = None\n", "\n", " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", + " # Small-sample expansion of the interval for clustered data.\n", + " self.__ci_expanded, self.__expansion_df = self._expanded_level(\n", + " self.__expansion_components\n", + " )\n", + "\n", " if self.__is_clustered:\n", " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", " self.__control,\n", @@ -319,13 +344,14 @@ " self._compute_bca_intervals(sorted_bootstraps)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self._interval_level(), self.__resamples\n", + " )\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_bootstraps[pct_idx_low]\n", " self.__pct_high = sorted_bootstraps[pct_idx_high]\n", - " \n", + "\n", " self._get_bootstrap_baseline_ec()\n", "\n", " self._perform_statistical_test()\n", @@ -384,8 +410,13 @@ " p2 = \"calculated for legacy purposes only. \"\n", " pvalue = p1 + p2\n", "\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = (\n", " \"Any p-value reported is the probability of observing the\"\n", @@ -449,18 +480,76 @@ " )\n", " raise ValueError(err1)\n", "\n", - " def _compute_bca_intervals(self, sorted_bootstraps):\n", + " def _expanded_level(self, components):\n", " '''\n", - " Function to compute the bca intervals given the sorted bootstraps.\n", + " The level at which to read the cluster-bootstrap distribution, expanded\n", + " for small numbers of clusters, and its degrees of freedom. Returns\n", + " `(None, None)` when the interval is not expanded.\n", " '''\n", " from ._stats_tools import confint_2group_diff as ci2g\n", "\n", + " if not (self.__is_clustered and self.__cluster_ci_expansion):\n", + " return None, None\n", + "\n", + " ci_expanded, df = ci2g.expanded_ci_level(self.__ci, components)\n", + " if df is None:\n", + " warnings.warn(\n", + " \"There are too few clusters (fewer than 2 in every resampling stratum) \"\n", + " \"to expand the confidence interval for a small number of clusters; \"\n", + " \"the unexpanded interval is reported, and it will be too narrow.\"\n", + " )\n", + " return None, None\n", + " # In simulations, expanded intervals came close to nominal coverage once\n", + " # there were at least 6 clusters in all, and at least 4 in the smallest\n", + " # group of clusters that sets the degrees of freedom.\n", + " n_total = sum(n for _, n in components if n >= 2)\n", + " if n_total < 6 or df + 1 < 4:\n", + " warnings.warn(\n", + " \"Only {} clusters are available to resample ({} in the smallest group of \"\n", + " \"clusters); even after expansion for the small number of clusters, the \"\n", + " \"confidence interval is unreliable and likely too narrow. At least 6 \"\n", + " \"clusters, and at least 4 in every group of clusters, are \"\n", + " \"recommended.\".format(int(n_total), int(df + 1))\n", + " )\n", + " return ci_expanded, df\n", + "\n", + " def _interval_level(self):\n", + " '''\n", + " The confidence level at which the bootstrap distribution is read:\n", + " the expanded level when the interval is expanded, otherwise `ci`.\n", + " '''\n", + " return self.__ci_expanded if self.__ci_expanded is not None else self.__ci\n", + "\n", + " def _bca_interval_idx(self, bias, acceleration, ci_expanded):\n", + " '''\n", + " Indexes of the BCa interval limits. When `ci_expanded` is given, the\n", + " interval is read at that expanded level; if the BCa adjustment is\n", + " undefined there, the expanded percentile limits are used instead.\n", + " '''\n", + " from ._stats_tools import confint_2group_diff as ci2g\n", + "\n", + " if ci_expanded is None:\n", + " return ci2g.compute_interval_limits(bias, acceleration, self.__resamples, self.__ci)\n", + "\n", + " low, high = ci2g.expanded_interval_limits(bias, acceleration, self.__resamples, ci_expanded)\n", + " if (isnan(low) or isnan(high)) and np.isfinite(bias):\n", + " warnings.warn(\n", + " \"The bias-corrected and accelerated adjustment is undefined at the \"\n", + " \"expanded confidence level; the expanded percentile interval is \"\n", + " \"reported in its place.\"\n", + " )\n", + " low, high = ci2g.percentile_interval_idx(ci_expanded, self.__resamples)\n", + " return low, high\n", + "\n", + " def _compute_bca_intervals(self, sorted_bootstraps):\n", + " '''\n", + " Function to compute the bca intervals given the sorted bootstraps.\n", + " '''\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = self._bca_interval_idx(\n", " self.__bias_correction,\n", " self.__acceleration_value,\n", - " self.__resamples,\n", - " self.__ci,\n", + " self.__ci_expanded,\n", " )\n", "\n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -639,16 +728,28 @@ " # so the clusters of the second copy are given distinct labels.\n", " (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters)\n", " codes_copy = codes + n_clusters\n", - " jackknives = ci2g.compute_cluster_jackknife(\n", + " jackknives, deleted, jack_codes, n_codes = ci2g.cluster_jackknife_by_cluster(\n", " self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size\n", " )\n", + " bec_components = ci2g.cluster_variance_components(jackknives, deleted, jack_codes, n_codes)\n", " else:\n", " jackknives = ci2g.compute_meandiff_jackknife(\n", " self.__control, self.__control, is_paired, self.__effect_size\n", " )\n", + " bec_components = None\n", "\n", " acceleration_value = ci2g._calc_accel(jackknives)\n", "\n", + " # The baseline curve is expanded for small numbers of clusters in the same\n", + " # way as the effect size itself; the warning for too few clusters, if any,\n", + " # has already been given for the effect size.\n", + " bec_ci_expanded = None\n", + " if self.__ci_expanded is not None:\n", + " level, df = ci2g.expanded_ci_level(self.__ci, bec_components)\n", + " if df is not None:\n", + " bec_ci_expanded = level\n", + " self.__bec_ci_expanded = bec_ci_expanded\n", + "\n", " if self.__is_clustered:\n", " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", " self.__control,\n", @@ -679,11 +780,10 @@ " )\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = self._bca_interval_idx(\n", " bias_correction,\n", " acceleration_value,\n", - " self.__resamples,\n", - " self.__ci,\n", + " bec_ci_expanded,\n", " )\n", "\n", " self.__bec_bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -722,8 +822,9 @@ " warnings.warn(err_temp.substitute(lim_type=\"upper\"), stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " bec_ci_expanded if bec_ci_expanded is not None else self.__ci, self.__resamples\n", + " )\n", "\n", " self.__bec_pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__bec_pct_low = sorted_bootstraps[pct_idx_low]\n", @@ -768,6 +869,40 @@ " return self.__n_clusters\n", "\n", " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Whether the confidence interval of clustered data is expanded for a\n", + " small number of clusters.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters (see `dabest.load`'s `cluster_ci_expansion`).\n", + " None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", + " @property\n", + " def expansion_df(self):\n", + " \"\"\"\n", + " The degrees of freedom used to expand the confidence interval for a\n", + " small number of clusters; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__expansion_df\n", + "\n", + " @property\n", + " def _expansion_components(self):\n", + " \"\"\"\n", + " The stratum-by-stratum `(variance, n_clusters)` components of the\n", + " cluster jackknife variance; None if the observations are not clustered.\n", + " \"\"\"\n", + " return self.__expansion_components\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " Returns the width of the confidence interval, in percent.\n", @@ -1165,6 +1300,7 @@ " experiment_label=None,\n", " mini_meta=False,\n", " ps_adjust=False,\n", + " cluster_ci_expansion=True,\n", " ):\n", " \"\"\"\n", " Parses the data from a Dabest object, enabling plotting and printing\n", @@ -1185,6 +1321,9 @@ " self.__delta2 = delta2\n", " self.__is_mini_meta = mini_meta\n", " self.__ps_adjust = ps_adjust\n", + " self.__cluster_ci_expansion = cluster_ci_expansion\n", + " self.__expansion_components = []\n", + " self.__delta2_ci_expanded = None\n", "\n", " def __pre_calc(self):\n", " from .misc_tools import print_greeting, get_varname\n", @@ -1198,6 +1337,8 @@ "\n", " out = []\n", " reprs = []\n", + " self.__expansion_components = []\n", + " self.__delta2_ci_expanded = None\n", "\n", " grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)}\n", "\n", @@ -1236,6 +1377,15 @@ " self.__is_proportional,\n", " clusters=mixed_clusters if cluster_col is not None else None,\n", " )\n", + " if cluster_col is not None and self.__cluster_ci_expansion:\n", + " # Expand the delta-delta interval for a small number of clusters.\n", + " components = ci2g.delta2_cluster_variance_components(\n", + " *[np.asarray(x) for x in mixed_data[:4]],\n", + " *mixed_clusters[:4],\n", + " self.__is_paired,\n", + " )\n", + " level, df = ci2g.expanded_ci_level(self.__ci, components)\n", + " self.__delta2_ci_expanded = level if df is not None else None\n", "\n", " for j, current_tuple in enumerate(idx):\n", " if self.__is_paired != \"sequential\":\n", @@ -1260,7 +1410,9 @@ " self.__ps_adjust,\n", " control_clusters=grouped_clusters[cname],\n", " test_clusters=grouped_clusters[tname],\n", + " cluster_ci_expansion=self.__cluster_ci_expansion,\n", " )\n", + " self.__expansion_components.append(result._expansion_components)\n", " r_dict = result.to_dict()\n", " r_dict[\"control\"] = cname\n", " r_dict[\"test\"] = tname\n", @@ -1304,6 +1456,7 @@ " \"is_paired\",\n", " \"difference\",\n", " \"ci\",\n", + " \"ci_expanded\",\n", " \"bca_low\",\n", " \"bca_high\",\n", " \"bca_interval_idx\",\n", @@ -1359,7 +1512,8 @@ " )\n", " elif self.__delta2:\n", " self.__delta_delta = DeltaDelta(\n", - " self, self.__permutation_count, bootstraps_delta_delta, self.__ci\n", + " self, self.__permutation_count, bootstraps_delta_delta, self.__ci,\n", + " ci_expanded=self.__delta2_ci_expanded,\n", " )\n", " reprs.append(self.__delta_delta.__repr__(header=False))\n", "\n", @@ -1895,6 +2049,8 @@ "\n", " if \"n_clusters\" in results_df.columns:\n", " default_cols.insert(default_cols.index(\"effect_size\"), \"n_clusters\")\n", + " if \"ci_expanded\" in results_df.columns:\n", + " default_cols.insert(default_cols.index(\"ci\") + 1, \"ci_expanded\")\n", "\n", " cols_of_interest = default_cols + stats_columns\n", "\n", @@ -1905,6 +2061,27 @@ " return self.__for_print\n", "\n", " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Whether confidence intervals of clustered data are expanded for a small\n", + " number of clusters.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", + " def _expansion_components(self):\n", + " \"\"\"\n", + " For each comparison, in the order of `results`, the stratum-by-stratum\n", + " `(variance, n_clusters)` components of its cluster jackknife variance,\n", + " or None if the observations are not clustered.\n", + " \"\"\"\n", + " try:\n", + " self.__results\n", + " except AttributeError:\n", + " self.__pre_calc()\n", + " return self.__expansion_components\n", + "\n", + " @property\n", " def _plot_data(self):\n", " return self.__dabest_obj._plot_data\n", "\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index d1df73ca..2f7f84b8 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -73,6 +73,7 @@ " mini_meta=False,\n", " ps_adjust=False,\n", " cluster_col=None,\n", + " cluster_ci_expansion=True,\n", "):\n", " \"\"\"\n", " Loads data in preparation for estimation statistics.\n", @@ -155,6 +156,32 @@ " `.plot(show_baseline_ec=True)` is always an unpaired comparison (see\n", " that argument's docstring), so with `cluster_col` set it can become\n", " much wider than a paired analysis's real effect-size curves.\n", + " cluster_ci_expansion : boolean, default True\n", + " Only used when `cluster_col` is set. Bootstrap confidence intervals are\n", + " too narrow when there are few independent units: with around 15 to 30\n", + " clusters, a nominal 95% cluster-bootstrap interval typically covers the\n", + " true effect only 90 to 94% of the time. When True, the percentile and\n", + " bias-corrected and accelerated intervals (including those of the\n", + " baseline error curve, delta-delta and mini-meta analyses) are therefore\n", + " expanded for the number of clusters with the expanded percentile\n", + " method of Hesterberg (2015, The American Statistician, 69(4),\n", + " 371-386): each interval is read further into the tails of the same\n", + " bootstrap distribution, at a level derived from a t distribution with\n", + " degrees of freedom based on the number of clusters. When clusters are\n", + " nested within groups, or some clusters appear in only some groups, the\n", + " conservative choice of the smallest group of clusters' degrees of\n", + " freedom is used. The reported confidence level (`ci`) is unchanged; the\n", + " level actually read is reported as `ci_expanded` in the results. The\n", + " correction fades as the number of clusters grows. In simulations the\n", + " expanded intervals came close to nominal coverage for every effect size\n", + " once there were at least 6 clusters in all and at least 4 in each\n", + " independently resampled group of clusters (for example 6 participants\n", + " who each take part in every condition, or 8 participants split between\n", + " two conditions); with fewer, no bootstrap interval is reliable, and a\n", + " warning is given. Because expanded intervals are read further into the\n", + " tails of the bootstrap distribution, consider increasing `resamples`\n", + " (to 20000, say) when there are few clusters. Set to False to report\n", + " unexpanded cluster-bootstrap intervals.\n", "\n", " Returns\n", " -------\n", @@ -180,6 +207,7 @@ " mini_meta,\n", " ps_adjust,\n", " cluster_col=cluster_col,\n", + " cluster_ci_expansion=cluster_ci_expansion,\n", " )" ] }, diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py index d27fe927..77f463c6 100644 --- a/nbs/tests/test_cluster_bootstrap.py +++ b/nbs/tests/test_cluster_bootstrap.py @@ -451,3 +451,292 @@ def test_cluster_permutation_test(): control_clusters=clusters, test_clusters=clusters + 10, ) assert 0 <= nested.pvalue <= 1 + + +# --------------------------------------------------------------------------- +# Small-sample expansion of cluster-bootstrap intervals (`cluster_ci_expansion`) +# --------------------------------------------------------------------------- +def _hesterberg_level(n, ci=95): + """Hesterberg's (2015) expanded percentile level for a single sample of n units.""" + from scipy import stats + + alpha = (100 - ci) / 100 + z = np.sqrt(n / (n - 1)) * stats.t.ppf(1 - alpha / 2, n - 1) + return 100 * (1 - 2 * stats.norm.sf(z)) + + +def test_expanded_level_matches_hesterberg_for_one_stratum(): + for n in (3, 5, 8, 15, 30, 200): + level, df = ci2g.expanded_ci_level(95, [(0.37, n)]) + assert level == pytest.approx(_hesterberg_level(n)) + assert df == pytest.approx(n - 1) + # Any confidence level, and the result does not depend on the variance scale. + assert ci2g.expanded_ci_level(90, [(5.0, 12)])[0] == pytest.approx(_hesterberg_level(12, ci=90)) + assert ci2g.expanded_ci_level(95, [(1e-9, 12)])[0] == pytest.approx(_hesterberg_level(12)) + + +def test_expanded_level_behaviour(): + levels = [ci2g.expanded_ci_level(95, [(1.0, n)])[0] for n in (4, 8, 16, 32, 64, 1000)] + assert all(a > b for a, b in zip(levels, levels[1:])) # fewer clusters, more expansion + assert levels[-1] > 95 and levels[-1] == pytest.approx(95, abs=0.05) + + # Two equal, independently resampled strata: the conservative (Hsu) degrees of + # freedom are those of the smaller stratum, so the result equals one stratum's. + level, df = ci2g.expanded_ci_level(95, [(1.0, 8), (1.0, 8)]) + assert df == 7 + assert level == pytest.approx(_hesterberg_level(8)) + + # Unequal strata: the smallest stratum that carries real variance sets the df. + _, df = ci2g.expanded_ci_level(95, [(1.0, 5), (3.0, 20)]) + assert df == 4 + # A stratum carrying a negligible share of the variance does not set the df ... + level_dominated, df = ci2g.expanded_ci_level(95, [(1.0, 40), (1e-9, 3)]) + assert df == 39 + assert level_dominated == pytest.approx(_hesterberg_level(40), rel=1e-4) + # ... and the narrowness correction follows the variance shares. + level_dominated, df = ci2g.expanded_ci_level(95, [(1e-9, 40), (1.0, 6)]) + assert df == 5 + assert level_dominated == pytest.approx(_hesterberg_level(6), rel=1e-4) + # Many equal strata, each below the 10% share threshold: still well defined. + level, df = ci2g.expanded_ci_level(95, [(1.0, 10)] * 12) + assert df == 9 and level == pytest.approx(_hesterberg_level(10)) + + # Strata of a single cluster carry no information and are ignored. + assert ci2g.expanded_ci_level(95, [(1.0, 1), (1.0, 10)])[0] == pytest.approx(_hesterberg_level(10)) + assert ci2g.expanded_ci_level(95, [(1.0, 1)]) == (95, None) + assert ci2g.expanded_ci_level(95, []) == (95, None) + + # No usable variance information: strata are weighted equally. + assert ci2g.expanded_ci_level(95, [(0.0, 8), (0.0, 6)])[1] == 5 + + # Extreme expansion is floored so that quantile functions stay finite. + level, _ = ci2g.expanded_ci_level(95, [(1.0, 2)]) + assert 100 - level == pytest.approx(100 * ci2g._MIN_EXPANDED_ALPHA) + + +def test_cluster_variance_components_follow_the_strata(): + x = np.arange(12, dtype=float) + y = x + np.linspace(0, 1, 12) + + # Paired: one stratum holding every cluster. + clusters = np.repeat(np.arange(4), 3) + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster(x, y, clusters, clusters, "baseline", "mean_diff") + components = ci2g.cluster_variance_components(values, deleted, codes, n) + assert [n_s for _, n_s in components] == [4] + assert components[0][0] > 0 + + # Nested: one stratum per group. + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster( + x[:6], y[6:], np.repeat([0, 1, 2], 2), np.repeat([5, 6, 7], 2), None, "mean_diff") + assert sorted(n_s for _, n_s in ci2g.cluster_variance_components(values, deleted, codes, n)) == [3, 3] + + # Mixed: clusters in both groups, and single-group clusters; a stratum of one + # cluster is left out. + c0 = np.array([0, 0, 1, 1, 2, 2, 3]) + c1 = np.array([0, 0, 1, 1, 2, 2, 4, 4]) + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster(x[:7], y[:8], c0, c1, None, "mean_diff") + assert sorted(n_s for _, n_s in ci2g.cluster_variance_components(values, deleted, codes, n)) == [3] + + # The delta-delta counterpart. + comps = ci2g.delta2_cluster_variance_components(x, y, x + 1, y + 2, clusters, clusters, clusters, clusters, "baseline") + assert [n_s for _, n_s in comps] == [4] + + +def test_interval_index_helpers(): + assert ci2g.percentile_interval_idx(95, 1000) == (25, 975) + assert ci2g.percentile_interval_idx(99.9999999999, 10) == (0, 9) + + # BCa at an expanded level: valid indexes, within the array. + low, high = ci2g.expanded_interval_limits(0.05, 0.02, 1000, 98.0) + assert 0 <= low < high <= 999 + # Undefined when a large acceleration meets an extreme level. + low, high = ci2g.expanded_interval_limits(0.0, 0.5, 1000, 99.99) + assert np.isnan(low) and np.isnan(high) + low, high = ci2g.expanded_interval_limits(np.inf, 0.0, 1000, 98.0) + assert np.isnan(low) and np.isnan(high) + + +def test_expansion_is_on_by_default_and_can_be_turned_off(clustered): + expanded = clustered.mean_diff.results + unexpanded = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + + # 12 participants, all present in every group: a single stratum. + assert expanded["ci_expanded"].to_numpy() == pytest.approx(_hesterberg_level(12)) + assert (expanded["ci"] == 95).all() + assert "ci_expanded" not in unexpanded.columns + + # Same point estimates and bootstrap distributions; only where they are read changes. + assert expanded["difference"].to_numpy() == pytest.approx(unexpanded["difference"].to_numpy()) + for boot_on, boot_off in zip(expanded["bootstraps"], unexpanded["bootstraps"]): + assert np.array_equal(boot_on, boot_off) + + for kind in ("bca", "pct", "bec_bca", "bec_pct"): + width_on = expanded[f"{kind}_high"] - expanded[f"{kind}_low"] + width_off = unexpanded[f"{kind}_high"] - unexpanded[f"{kind}_low"] + assert (width_on > width_off).all(), kind + + # The percentile limits are the bootstrap quantiles at the reported levels. + resamples = PAIRED_KWARGS["resamples"] + for row_on, row_off in zip(expanded.itertuples(), unexpanded.itertuples()): + on, off = np.sort(row_on.bootstraps), np.sort(row_off.bootstraps) + a = (100 - row_on.ci_expanded) / 200 + assert row_on.pct_low == on[int(a * resamples)] + assert row_on.pct_high == on[int((1 - a) * resamples)] + assert row_off.pct_low == off[int(0.025 * resamples)] + assert row_off.pct_high == off[int(0.975 * resamples)] + + assert "ci_expanded" in clustered.mean_diff.statistical_tests.columns + assert "read at the" in repr(clustered.mean_diff) + assert "cluster_ci_expansion=False" in repr(clustered) + unexpanded_repr = repr(load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff) + assert "read at the" not in unexpanded_repr + + +def test_unclustered_results_are_unaffected(naive): + results = naive.mean_diff.results + assert "ci_expanded" not in results.columns + resamples = PAIRED_KWARGS["resamples"] + for row in results.itertuples(): + boot = np.sort(row.bootstraps) + assert row.pct_low == boot[int(0.025 * resamples)] + assert row.pct_high == boot[int(0.975 * resamples)] + # The switch only concerns clustered data. + with_switch = load(DF, cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + assert with_switch["bca_low"].to_numpy() == pytest.approx(results["bca_low"].to_numpy()) + assert "Confidence intervals will be expanded" not in repr(naive) + + +def test_expansion_for_unpaired_nested_and_mixed_designs(): + kwargs = dict(x="Level", y="Y", resamples=500, random_seed=4) + # Nested: participants P00-P05 at L1 only, P06-P11 at L3 only (two strata of 6). + df = DF[DF["Level"].isin(["L1", "L3"])] + first_half = df["ID"] < "P06" + nested = df[(first_half & (df["Level"] == "L1")) | (~first_half & (df["Level"] == "L3"))] + result = load(nested, idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + # Two strata of 6: the expansion of a single sample of 6 clusters. + assert result["ci_expanded"] == pytest.approx(_hesterberg_level(6)) + + # Mixed: a participant measured only in the test group adds a stratum of one, + # which cannot be resampled and so does not change the expansion. + extra = pd.DataFrame({"ID": ["P99"] * 4, "pair": range(900, 904), "Level": "L3", "Y": [5.0, 6.0, 7.0, 5.5]}) + shared = DF[DF["Level"].isin(["L1", "L3"])] + base = load(shared, idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + mixed = load(pd.concat([shared, extra]), idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + assert mixed["ci_expanded"] == pytest.approx(base["ci_expanded"]) + + +def test_expansion_for_delta2_and_mini_meta(): + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2_kwargs = dict(x=["Level", "Env"], y="Y", delta2=True, experiment="Env", + paired="sequential", id_col="pair", cluster_col="ID", resamples=500) + mini_meta_kwargs = dict(idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=500) + + for effect_size in ("mean_diff", "hedges_g"): + on = getattr(load(df, **delta2_kwargs), effect_size).delta_delta + off = getattr(load(df, cluster_ci_expansion=False, **delta2_kwargs), effect_size).delta_delta + # Every participant contributes to all four groups: a single stratum of 12. + assert on.ci_expanded == pytest.approx(_hesterberg_level(12)) + assert off.ci_expanded is None + assert (on.bca_high - on.bca_low) > (off.bca_high - off.bca_low) + assert (on.pct_high - on.pct_low) > (off.pct_high - off.pct_low) + assert "ci_expanded" in on.results.columns and "ci_expanded" not in off.results.columns + assert "read at the" in repr(on) + + on = load(df, **mini_meta_kwargs).mean_diff.mini_meta + off = load(df, cluster_ci_expansion=False, **mini_meta_kwargs).mean_diff.mini_meta + assert on.ci_expanded > 95 and off.ci_expanded is None + assert (on.bca_high - on.bca_low) > (off.bca_high - off.bca_low) + assert (on.pct_high - on.pct_low) > (off.pct_high - off.pct_low) + assert "ci_expanded" in on.results.columns and "ci_expanded" not in off.results.columns + assert "read at the" in repr(on) and "read at the" not in repr(off) + + +def test_expansion_edge_cases(): + import warnings + + rng = np.random.default_rng(7) + # Two or three clusters: extreme but valid limits, and no index errors. + for n_clusters in (2, 3): + clusters = np.repeat(np.arange(n_clusters), 4) + control = rng.normal(0, 1, clusters.size) + test = control + 0.5 + rng.normal(0, 1, clusters.size) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + result = TwoGroupsEffectSize(control, test, "mean_diff", is_paired="baseline", resamples=300, + permutation_count=10, control_clusters=clusters, test_clusters=clusters) + assert result.ci_expanded > 99 + assert result.bca_low <= result.difference <= result.bca_high + assert result.pct_low <= result.pct_high + + # Too few clusters to resample: the user is warned the interval is unreliable, + # whether there are too few clusters overall ... + clusters = np.repeat(np.arange(5), 4) + control = rng.normal(0, 1, clusters.size) + with pytest.warns(UserWarning, match="Only 5 clusters"): + TwoGroupsEffectSize(control, control + 0.5 + rng.normal(0, 1, clusters.size), "mean_diff", + is_paired="baseline", resamples=300, permutation_count=10, + control_clusters=clusters, test_clusters=clusters) + # ... or too few in one of the independently resampled groups of clusters. + control, test = rng.normal(0, 1, 12), rng.normal(1, 1, 24) + with pytest.warns(UserWarning, match=r"Only 9 clusters .*\(3 in the smallest"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=300, permutation_count=10, + control_clusters=np.repeat(np.arange(3), 4), + test_clusters=np.repeat(np.arange(10, 16), 4)) + # Enough clusters: no such warning. + clusters = np.repeat(np.arange(6), 4) + control = rng.normal(0, 1, clusters.size) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + TwoGroupsEffectSize(control, control + 0.5 + rng.normal(0, 1, clusters.size), "mean_diff", + is_paired="baseline", resamples=1000, permutation_count=10, + control_clusters=clusters, test_clusters=clusters) + assert not any("available to resample" in str(w.message) for w in caught) + + # One cluster per group: nothing can be expanded, and the user is told so. + control, test = rng.normal(0, 1, 5), rng.normal(1, 1, 5) + with pytest.warns(UserWarning, match="too few clusters"): + result = TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, permutation_count=10, + control_clusters=np.zeros(5), test_clusters=np.ones(5)) + assert result.ci_expanded is None + + # Opt-out on the direct API, and argument validation. + clusters = np.repeat(np.arange(6), 2) + control = rng.normal(0, 1, 12) + result = TwoGroupsEffectSize(control, control + 1, "mean_diff", is_paired="baseline", resamples=200, + permutation_count=10, control_clusters=clusters, test_clusters=clusters, + cluster_ci_expansion=False) + assert result.ci_expanded is None and result.expansion_df is None + with pytest.raises(TypeError, match="cluster_ci_expansion"): + TwoGroupsEffectSize(control, control + 1, "mean_diff", resamples=200, control_clusters=clusters, + test_clusters=clusters, cluster_ci_expansion="yes") + with pytest.raises(TypeError, match="cluster_ci_expansion"): + load(DF, cluster_col="ID", cluster_ci_expansion=1, **PAIRED_KWARGS) + with pytest.raises(ValueError, match="same column as `x`"): + load(DF, cluster_col="Level", **PAIRED_KWARGS) + + +def test_expansion_for_every_effect_size_and_plot(clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + for effect_size in ("mean_diff", "median_diff", "cohens_d", "hedges_g"): + results = getattr(clustered, effect_size).results + assert (results["ci_expanded"] > 95).all(), effect_size + assert (results["bca_low"] <= results["difference"]).all() + assert (results["difference"] <= results["bca_high"]).all() + + unpaired = load(DF, idx=("L1", "L3"), x="Level", y="Y", cluster_col="ID", resamples=300) + assert unpaired.cliffs_delta.results["ci_expanded"].iloc[0] > 95 + + df = DF.copy() + df["Yes"] = (np.random.default_rng(1).random(len(df)) < 0.4).astype(int) + proportional = load(df, idx=("L1", "L3"), x="Level", y="Yes", proportional=True, + cluster_col="ID", resamples=300) + for effect_size in ("mean_diff", "cohens_h"): + assert getattr(proportional, effect_size).results["ci_expanded"].iloc[0] > 95 + + assert clustered.mean_diff.plot(show_baseline_ec=True) is not None + plt.close("all") diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index 6dcd09f5..4e018805 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -827,24 +827,25 @@ "==================\n", " \n", "Good evening!\n", - "The current time is Wed Sep 16 21:59:31 2026.\n", + "The current time is Sun Sep 27 21:38:55 2026.\n", "\n", "The paired mean difference for repeated measures against baseline \n", - "between Control and Test 1 is 0.589 [95%CI 0.447, 0.744].\n", + "between Control and Test 1 is 0.589 [95%CI 0.432, 0.764].\n", "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", "\n", "The paired mean difference for repeated measures against baseline \n", - "between Control and Test 2 is 1.24 [95%CI 1.0, 1.49].\n", + "between Control and Test 2 is 1.24 [95%CI 0.975, 1.51].\n", "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", "\n", "The paired mean difference for repeated measures against baseline \n", - "between Control and Test 3 is 1.78 [95%CI 1.42, 2.12].\n", + "between Control and Test 3 is 1.78 [95%CI 1.38, 2.17].\n", "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", "\n", - "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated.\n", + "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated, and expanded for the small number of clusters\n", + "(the 95% interval is read at the 97.36% level of the bootstrap distribution).\n", "Any p-value reported is the probability of observing theeffect size (or greater),\n", "assuming the null hypothesis of zero difference is true.\n", - "For each p-value, 5000 reshuffles of the control and test labels were performed.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed at the level of whole clusters.\n", "\n", "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" ] @@ -874,7 +875,12 @@ "source": [ "The paired mean differences are identical, but the cluster-aware confidence\n", "intervals are wider because they reflect the between-participant variation\n", - "in the treatment effect. The number of clusters resampled is reported in the\n", + "in the treatment effect. With only 15 participants they are also expanded\n", + "slightly, by default, to keep their coverage close to 95% (the printed output\n", + "gives the level at which the bootstrap distribution is read, also reported in\n", + "the `ci_expanded` column; see the\n", + "[Cluster-Robust Bootstrap tutorial](11-cluster_robust_bootstrap.html#few-clusters-the-small-sample-expansion),\n", + "and pass `cluster_ci_expansion=False` to turn this off). The number of clusters resampled is reported in the\n", "`n_clusters` column of the results:" ] }, @@ -953,8 +959,8 @@ " Control\n", " Test 1\n", " 0.588622\n", - " 0.447307\n", - " 0.744200\n", + " 0.432037\n", + " 0.764288\n", " 0.0\n", " 15.0\n", " \n", @@ -963,8 +969,8 @@ " Control\n", " Test 2\n", " 1.241603\n", - " 1.001819\n", - " 1.487159\n", + " 0.974880\n", + " 1.514503\n", " 0.0\n", " 15.0\n", " \n", @@ -973,8 +979,8 @@ " Control\n", " Test 3\n", " 1.778828\n", - " 1.415682\n", - " 2.122870\n", + " 1.379295\n", + " 2.165135\n", " 0.0\n", " 15.0\n", " \n", @@ -1013,7 +1019,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA64AAARECAYAAAB1fkwYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzsvQmwRGlZ3t8oKC6AWUzCJgPDzMCwR9kJS6ASVFQojWETo2JKJFQgkpBgkQWDoFgEwQqxWGJUCGpFDKuiCBGQVYaZYRhmGFYBjWZBwBXM/OvX/n/XZ975zunue7vv+j5Vp7pv3+5zvu18533e9TpXX3311YtGo9FoNBqNRqPRaDSOKb7oqBvQaDQajUaj0Wg0Go3GHJq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNYo4lro9FoNBqNRqPRaDSONZq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNYo4lro9FoNBqNRqPRaDSONZq4NhqNRqPRaDQajUbjWKOJa6PRaDQajUaj0Wg0jjWauDYajUaj0Wg0Go1G41ijiWuj0Wg0Go1Go9FoNI41mrg2Go1Go9FoNBqNRuNY47pH3YDGycFznvOcxWc+85nFDW94w8U/+2f/7Kib02g0Go1Go9FoNM4IrnP11VdffdSNaJwM3OxmN1t88pOfXNz0pjddfOITnzjq5jQajUaj0Wg0Go0zgnYVbjQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go9FoHGs0cW00Go1Go9FoNBqNxrFGE9dGo9FoNBqNRqPRaBxrNHFtNBqNRqPRaDQajcaxRhPXRqPRaDQajUaj0WgcazRxbTQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go9FoHGs0cW00Go1Go9FoNBqNxrFGE9dGo9FoNBqNRqPRaBxrNHFtNBqNRqPRaDQajcaxRhPXRqPRaDQajUaj0WgcazRxbTQajUaj0Wg0Go3GsUYT10aj0Wg0Go1Go7EvXH311Ys///M/79Fr7BzX3f0lGo1Go9FoNBqNxmkiq5/73OcW//f//t/lcaMb3WhxzjnnHHWzGqccTVwbjUaj0Wg0Go3GSiRZ/fznP7/3+ac//eklmb3Oda7To9jYGZq4NhqNRqPRaDQajSH+8A//cPF//s//uRZZFV/0RV+0uMENbrD4whe+sLje9a7Xo9jYGZq4NhqNRqPRaDQajWuQVS2rf/Znf3atkcGyinvwX/krf2X5+sVf/MU9eo2do4lro9FoNBqNRqNxxvFHf/RHS6KKdXWKrN7whjdcktWv+qqvarLaOHQ0cW00Go1Go9FoNM4g/viP/3jPDfhP//RPr/X/JquN44Qmro1Go9FoNBqNxhkiq7oB/8mf/MmQrBKzqmX1utdtutA4HuiV2Gg0Go1Go9FonGJAUHUDHpFVAFn9q3/1rzZZbRxbNHFtNBqNRqPRaDROKVnlwMo6QlpWOyNw47ijiWuj0Wg0Go1Go3EKQJyqZJVkSyN85Vd+5ZKscjRZbZwkNHFtNBqNRqPRaDROKMgAbIKlKbL6FV/xFXtuwF/yJV9y6G1sNLaBJq6NRqPRaDQajcYJI6taVqm5OkVWtaw2WW2cBjRxbTQajUaj0Wg0jjk+//nP7yVYmiKrX/7lX75HVr/0S7/00NvYaOwSTVwbjUaj0Wg0Go1jTFY5Pve5zw2/82Vf9mVLN+Amq43TjiaujUaj0Wg0Go3GMcEXvvCFPbL62c9+dpKsalm9/vWvf+htbDSOAk1cG41Go9FoNBqNIyarn/70p5duwFNkFYIKUcW62mS1cRbRxLXRaDQajUaj0Tgisqpl9eqrr77Wd4hT1Q0YK2ujcZbRxLXRaDQajUaj0TgE/Pmf//keWf3MZz4zSVZ1AybZUqPR+As0cW00Go1Go9FoNHZIVv/gD/5g6QY8RVYpV6MbcJPVRmOMJq6NRqPRaDQajcYW8f/+3//bs6xCWufIKgc1VxuNxjyauDYajUaj0Wg0Glsgq5BUySp/V1zvetfbI6tf+ZVf2WPeaGyAJq6NRqPRaDQajcY+ADnF/Rc34CarjcZu0cS10Wg0Go1Go9HYkKxiWcUdeGRZve51r3sNy+p1rnOdHt9G44Bo4tpoNBqNRqPRaMyAGNUkqyRcupZQfd3rLr7qq75qmWCpyWqjsX00cW00Go1Go9FoNPZBVr/4i794z7J6gxvcoC2rjcYO0cS10Wg0Go1Go9H4/8nqZz/72T2y+oUvfGFIVrGsQlZveMMbnkmyyjj98R//8eJzn/vc4g//8A+XSadudrObHXWzGqccTVwbjUaj0Wg0GmcWkDAIGAmW5sjqjW50o6Ub8Fkkq8TxQlAZJ8lqWqC/9Eu/tIlrY+do4tpoNBqNRqPROJNkFcsqx4isftEXfdE1LKv8fVbAeEhSOf7oj/5oWItWfP7zn1/+hjjfRmNX6NXVaDQajUaj0TgTSLIK2aqAnGJZhazyelbI6p/8yZ9cg6j+6Z/+6ez3cQ0mAZXHl33Zl505K3Tj8NHEtdFoNBqNRqNxaoFbK27Ac2QViypuwGeBrGI5xYKaRHVkcU5c//rXvwZRxTW40ThsNHFtNBqNRqPRaJw6sqpl9c/+7M+u9X+sg2lZJYb1tIJY1BqfOqo9m2PzFV/xFXsklfftAtw4Dmji2mg0Go1Go9E48cCKCFHFujpFVrGsQlaJXT2tZJW+pzWV7L9zYBzSmvrlX/7lp97q3DiZaOLaaDQajUaj0TiRgJTpBjyKyzztZBW33xqfOiLtCdx806JKfGqjcRLQxLXRaDQajUajcaLIqm7AkLYRWb3BDW6wR1ZPk5trlqXxNcvSjIAFNS2qJFZqNE4iTs+d3Gg0Go1Go9E4lYCg6gY8IqtAsspxWsjqpmVpcPGt8amnzcrcOLs4HXd1o9FoNBqNRuNUklWOqTjNtKyeBksi7s5JVKdI+nEqS4PFl+NLvuRLDvW6jbOHJq6NRqPRaDQajWND3CSrWBdHgKBpWT3JZPWkl6X5zGc+s/jf//t/L+eKUkLnnHPOkbWlcTbQxLXRaDQajUajcWQgmZBuwFNkFZdXyBGW1ZNq2dtPWZoan3rULtDMFWT1f/2v/3WNJFDM381vfvN2S27sFE1cG41Go9FoNBpHQlY5IHBTZFXL6kkkq/QxieoUKT/uZWkg15/+9KeXhBUrawVkGqXCXOxto7ENNHFtNBqNRqPRaOwcn//85/fIKkRuBMiaZPUo3WD3A+JwNylLAxmv8anHCRBtLKtYwkeZi290oxst/tpf+2tLK/hhx9U2ziaauDYajUaj0Wg0joysQtiw2J0ksooVssanrlOWJjP+HkcrMjG2EFUI6yghFvMDWeU4ju1vnG40cW00Go1Go9FobJX8SFY/+9nPTpJVLaskHDruOM1laegH8wRZxSW49ou+ME+QVbI4NxpHhSaujUaj0Wg0Go0DEztID9a6KbIKQZWsHje32IOWpSHOs8anHnf3WfpI3CrHyK0Zsv3X//pfX87XcSXdjbOFJq6NRqPRaDQajX2TVS2rIwskrqW6AR9Xskq7a3wqLs4npSzNpi7OzBdkdaRggIBjWYWwngRLeONsoYlro9FoNBqNRmMtEMcpWSXD7BRZ1bKK5fG44TSUpdkU9BFXYOatxuLSvxve8IZLskrCpeNuKW6cXZysu67RaDQajUajcaiA6PzBH/zB0g14iqySqAeiinX1uJFVrKc1PnUOuMXW+NTjUJZmPxZxa66OXJ2xqJpo6XrXu96RtLHR2ARNXBuNRqPRaDQaw9qdWOggrXNklQNyd1wASUuiSiznJmVpIHQn1erIPKFcgKyO5g0CjnIBskpft0WQUW6cFHfpxslFE9dGo9FoNBqNxpKsQnYkqyP3WSxzktVtEZ+DAGKWbr/rlKUh1jaJ6mko6wJZN9HSKD6XfppoaRvWY6zWrBFIMmNOLddzzz33wOdtNObQxLXRaDQajUbjjAJyCvnADXiOrEJMsNQdNVnFulfjU1eVpanxqaclQy4E3URLoxq5zJuuwAdNtMS1WCccrJNKjnUhP6mW6sbJQBPXRqPRaDQajTNIViE9uAOPyCrJh9KyelSEJMvSQFLJ/nvaytJsCsbCREt17ugrCZawrpJw6SB9Z6wlqlxzpCCgjA7WXq4HuT1pSasaJwu9uhqNRqPRaDROOYx9lKyO3GkhHVhWIas3uMENDp3w7acsDXGVNT71NIJx0BV4KtES5BHr6n7JowoNyeqotqvzxHddQxBkrtmktbFrNHFtNBqNRqPROKNkFbdZLauHTVYhPzU+dZOyNCSEOs3ZcJk/CCTW1VE2Z+bOREv7TY4FCZaoTtXiBcQBcz1ctSHRvE+Xa2JesY53gqbGLtHEtdFoNBqNRuOUAOIBAZGsQjQqIBxaVg/qTnqQsjRYV1fFp6Y19aSWpdkUjIvW1dH8oWDAusocbjoeKAZYH5LVqYzLrAmuAxE1rnjkpt0ldRqHiSauJxAf//jHFy9+8YsXr3nNaxYf+9jHlhvQV3/1Vy/OOeecxQMe8IDFt3/7ty9uf/vbH3UzG41Go9FoHAIgfxBByCrHiOxAcEywdFhkddOyNFhPk6iS/fe0xaeuSrSEdRWSOLJ4mmhpU6sm455W1SmrNtcgPpaxR8lAe37/93//Wt/bhqW30dgPmrieMDz/+c9f/Kt/9a+utal94hOfWB5vectblpvTc5/73CNrY6PRaDQajeNDVrWs7tJaaVmadP0dtem0l6XZFBBJLKtTiZaYP6yrm7hxa3WXrI5iYj0/4w5ZZX0Q00pbPvrRj17LEs53+Q5klTadFYVC43ihiesJwr//9/9+8bSnPW35/vzzz1987/d+7+Kud73rcsNho7nooosWr3jFK86EG02j0Wg0GmcRSVZHiYuQAZALIKu87komwEKY1tRVZWkgOljnTmNZmk0hQeQYWaEh9JBVrJrrJjzinBJVXqesqli1WRcckGHb8sEPfnC4nmgLZJW2nOZ44sbJwHWunttlGscGb3jDGxYPetCDlu8f85jHLF70ohdNbiBsQrvQWt7sZjdbfPKTn1zc9KY3XVp3G41Go9Fo7B6QQuqszpFVrGGQi12RVWSLGp+6TlkaySqvZ9lKh7hNzLGJlqbcbyGsJKBa53ysC4gqx9x8aFXlgIhiCWc9QVhJqjSaO12B12lLo3FYaIvrCQBas8c97nHL93e6052W8a1zGriz6GrTaDQajcZpAqREy+qoLIn1OrWsbtN62WVptgcIJWQVojhynU7321UKB5QWaVUdZYkGyIgSVc7P2jBD8ac+9anl68gVmO/TFl7PspKhcXzRxPUE4PWvf/3ShQM85SlP6TpZjUaj0WicQmD9gqhCcqbIKkQEsgrR2RZZrWVpeD9FimxHjU9tN9K/BGPHHEJYRxZNDAzWXJ0zNkAu+b1W1dG5BBZtyWpaSVcRZ76rK3DXYW0cdzRxPQH4hV/4hb0HxUMe8pC9z3XzcMNpNBqNRqNxsgCx0A14FO9oWRKe89siq1jukqhCiLoszcGBFdRESyOLJgoHEy1NAXKZVtWpBFesg7SqJunUFRjCOnIhRsmgKzAKiEbjpKCJ6wnA29/+9uUr5W7Y7F72spctnvnMZy7e97737X3HZE1PeMIT9lX8eZ2Y1Tnta6PRaDQajfUAmdANeJTxVbKqZfWglrAuS7M7YBmHIEJYR1ZyLJomWppSOqRVdVQKJ88lUa0xw7oC044pV2DWEmT1MGv3NhrbRCdnOubAfQfNGK9kEL7nPe+5eN7znjf5/Xvd617L+q5sTptgkw2skzM1Go1Go7E5edQNeKo8iWSVY79kVffSTKS0qizN9a9//Wu4/e5HAX6WgExmoiXKzkwlN4KwjiyaGAK0qnLMWVUhmZLVkTs2cw1ZnXIFhuBCVg+yphqN44ImrsccPOR0A+bBwsPuxje+8eLZz3724hu+4RuWn73rXe9axr5qmX3Ywx62+MVf/MWNrtPEtdFoNBqN3ZBVjqmsrxBF3YD3EydqWRpdf3mdKoUyKkvD+yY06wGSaLzoyAvN5EajOqfMf1pVp1yzIboSVeZnJJ/h6m242JQrMO3gQE5sNE4Lmrgec+DCe/Ob3/wabiLvec97FhdccME1vsfGhTX24osvXv4Nib373e++0XVWAYvv7/7u77bFtdFoNBqNCRCnKlmdSqYDIdGyuilZ3bQsDVa7tKYiR3S99/WxKl4U67SuwJloCWKLNVayOipjlKWMJKtTyZpQRqQr8Og8ugJjuT9MV2D6qodgo7FLtM/AMUfVlD32sY+9FmlVQ/eMZzxjL3nTz/3cz21EXKnRugpntVB4o9FoNBqryKRuwFNkFcumZHXdsnVY5Wp86iiOshKprJ/ayXc2B+NuoiVcgqt1FJJooiXGWDBXElXmasqqimwnUV1FMrHO6go8svJyfV2BtyWn0W4IO2R79Fo/4/usswsvvHAr1280ptDE9ZijZp77e3/v701+94EPfODS3YeNBPfhRqPRaDQa2wfCOtY0yAmvUzGrm5LVTcvSACyoXZZme9ZySCLW1ZGFlPmErEoStYJ6TCkVILrIc5LVVTHEnEdX4NHaYi3pCrxuPLKEcx1Cup9knFMW5UZjm2jieszBhvTVX/3Vi9///d9f/p1uwyMNHhsq7rx+v9FoNBqNxsEAkUiiOipbk0RSsrqKVEAU0pq6TlmaGp/a3lAHA+QTazkkcSrREgQR+Qo5S3ILUeX7U/PF3KdVdZV7tgmfODfW3gqtvLoC833WD8qNdQjp3LraD7ASMzYcuAi3m3DjMNDE9QTgdre73eJNb3rT8v0qLZj/70QLjUaj0WjsD5CTJKpz7rkI8JBV4gtXkVXOm0R1ylIrIANpTcUds8uYbAcQPiyrkNYqWzHGJlqCJPJdDAKQ1SmlhSWMjFddNykS60BXYNYZJJP2+Mp5OC9rjPXysY99bElI5xJw7RcoQSSi+Tr1WaNx2OhVdwJw3/ved4+4fvjDH17c5S53GX4PDR2bsCVrGo1Go9ForAaEIInqnNujWXkhExLKkTWty9IcP5iNF1lppDSAJEpWzSD8kY98ZJIk4rKrVZWjrgN+N7KCem7IMAmfJKkCcogixGRNJnrar1W0ks4RIeVYJ2mXcde6yPse0ouhpdHYJZq4ngB867d+6+LpT3/68v0rXvGK5d8j8D9dQf7O3/k7h9rGRqPRaDROCiALSVTn6pzqnitR5f1IwIdc1PjUVWVpanxqW7F2l2gJoojFdCrREpZy5hDr5yc/+cnJ80FumTcOSB9ElLnGzbe67Ob8897araMEXlp5OTj3FCSZ6xDSg7iR016JKfeL77E4M4b8n3uHPtF/xrCJa2PX6HI4JwTUbH3d61633GBf//rXLxMxJYhrpVwNZW3QzmGZ3bbVlczDbOacd53yOY1Go9FoHDUQspOocqwiqhJJyCpEdco9F4IC0ZkrfSO6LM3hApLF3HCMLOgQVeQlY0tNSpSuuhzMPS7aEFZ+sykZhNRBViF4ozhT1hhWXsvprCKk23YVp69JTCWqI/d42s/9Q18yvpc2MTYPfehDW/nS2Cna4npC8NznPnfxtre9bbm5UvLmiU984pLMspm+853vXDzzmc/cI5M/9EM/1K7CjUaj0TiT0EU3iepcfogklMYSriIHnBs3z1GpFAEJqfGpjd2CecYVGGU+5EryyecQU+NTmTOJ6mj+mCvmDHfddWNVR9mhJXesMZI7QTx5jzLkb/yNv7H4m3/zb+7r/PsB/R1ZUFdlA/Z+Yjy5l+gDa5v+8Gr5JYh3o7FrtMX1BOEtb3nL4tu+7dsW//N//s/h/3nQ/uAP/uCSuO4CbXFtNBqNxnEDgrUuupLVORddiINuv7yum/AIAmSplFF8pG6/Zv1dt1ZrYzWmsub6HosmigQs32lN15oIIFyQrNFcq7xg7jiqyzZW+FVuuZyXtYcyg/U4ugbkDusq19gVsJSOLKiblLihrcayctB/1rP9BPQb92D6lLVsG41doi2uJwj3uc99Fpdddtni+c9//uKXfumXlgkD2KBufOMbL+5///svnvCEJ0wmbmo0Go1G4zQga51CVFfFkiJgV6K6CbgOZBVLXrXOcW4sT5Sta6K62RyuU090rpQLn0MSdfMFfA+5CAsh/9fqXd17IV98Tjwp5It1Ud108/1U0iKuxxpkfdCO0TokwRJrhGutk/xoHXBdrMcjC+om2Ybpm27QWn51q+f8jEmua9qPFRqySr8YR9qC4kDy32jsEm1xbayNtrg2Go1G47CBIK7Lr0R1riYlZCOJ6n5cMXU5NetrBeeFrCLEd3mavyBSksx1COl+S7kYYwlJ5NW5Yo4gWpybeYeMSlh1z4WAQbg8DlJ31PhZS9hMZSfmOMh1GCcJarWiblKXlb5LTpOoMja0H0s1fZlKGgVJZcxY75JvvstvCFPjPuH/9773vffd10ZjHbTFtdFoNBqNxrEBRCSJKgLynJCOUJ5Eda6O6ipwLYRwBPJKrhDyISJYzw4rLvEoYYKikRV0REi3DQiTFk/LwVgShs9xzYbMsTZQImg5Tasm37Gu6lySrU2UGRDWbbsCc+4kpRLVqZqxU2DtV3LKUS3OzJdkVQVABWMpWdV1mvnm/uCgnuynPvWp5XvmhXEmSWh7HjR2iSaujUaj0Wg0jgySkiSqq4TzJKoHFZQhqFpXR9fmOpBViNG2XD2P0io655abr5tY9NbFqHboVOwokCgyL5ZigTTSRr4HSYSUugaMX7aszEGsnVlKhzaMEnFpjaQd61jfaffIvXdktZ0C10hSKlHlvphbn2ZPZkynMhxD9KtF2vuDqhKQ1Y9+9KPL98yJ7bZE0CZxtI3GftDEtdFoNBqNxqEB4T2J6sgVN4FQLEndZtIjrktsIqSkCtxaz7DkHedswGbLXYeQ7oJUQJTmEhbtp5QLawJLnpmBWSe6xhqbCknUgsr8aFXlf9tw3WZt6Ao8yrrLNS1hMyLH/GaUIGkTyzRjO3LvnUowNUe86cdUDC7npB8oZtKTAEXOVVddtfjQhz60Z1lN6yz9ZswZe+4TsiSfZMVO42SgiWuj0Wg0Go2dASE+ieooI++oFIlE9aBWs5HVqQrhAqsRQjiC/FEI4SYtWjdx0S6soqvIZ362rTHCcqf7KSQLq2oSRsgaZBWSpGu4VtVtKTIYz7TwVtBnXYFZJwALMImJqgV10wy+1bWXv/fbL+OA6QvuwKO2MHdaVu0L7b/88suXRJXkn9wnjEPWPbatjD+lfM4555zF13zN1+y5R7ebcGPXaOLaaDQajUZja4CESFLNTjoHy8hIVGspkm0AMqF1tVq9IF9aVxXitwVIRFpFVxHSXVhFTVA055bre757WMmmGBusqrie/s7v/M5evGrOC8QUwipp1aq6zey8EE/WBa9TrsBcE/LMOqIk4X4y+DK+IwvqthQzJkuashJbvsZYYC3bHMwBc8G9yjrkXCZB08rN725yk5ssbn3rWy/OO++85d9NVBuHjSaujUaj0Wg09g2E3SSqc/F6CMGVqNbEMdsCQrfWVZP6JCAPWlcP0gb6j2VripBuG4zhunGic6VcjgIQPYgfllXiJEdu4ljuIEWU+uMVsnqQhFtzbuKQPOeItrF2mU8ti1wXV1tI7bqAzI0sqLtY55BnyepIQWT5GsYQ/N7v/d5y7Hml/9y3Kgw4l7HErDGJKhUlOLCucq90Fu3GUaKJa6PRaDQajbWBYCtR5XUVUYWISFR5vyuiWt1OsaJVy5MCOYT1oDUnIQpYCrnOQcGYrBMnqlX0JIFxYox++7d/e1k6ZURW6RdzgtsprzU78DYAQaUdkDaIKO3ikKxC3rTqGus5pXhgHZnBt1pQd60oWKd8DW2z1A3WVL6rldiM3RB1Ds7BQduJU735zW++uMUtbrG8VyGqfLZtT4RGY79o4tpoNBqNRmMSEI0kqiM3RKFbYRLVw7D4mYQGwjqyjiHIQ4iIxTuoK/I6hDVLuaxDSE+TFYu5YK0wD7ihYmHl7+qGy7owTvKmN73p1ksM6fIKUXW+IG5JRl2vf+tv/a1huZzM4FutqIc5Z5av4ajeA9axZTwtq0O/taTyW8mq9y6EVcs9JBWLKvcG/cJizL1CJu1duO03GgdBr8hGo9FoNBp7MCGLRHXO3RVhOYkqlpnDdE1FEMflkaNafhHMcZPUgndQTBFWhHusUlxDInrSrKIHBWMPUbV0DBY+/q5KDsaG+YAsYV3dRowk164lZiB4tIP2jOKGIaFYVpkz3amTmPqe9h2VUmGqfA3rkH7aV/rHemMcjLnlM+9jvs+6tMaxmaB1IZawmx2Yzzbts+WTOua1sWs0cW00Go1G44wCYbMS1bkEQRJVhGCJ6lEI9mldrZY8LUZYkLaR+EbCCoHIayH8YzHkWmeNqJq5VrJKIh/Wj5loq8USkgRRxbK3n/JCXA9iNioxI1lDwUJ7dAOeygqMdRVylkT1uBCuWr4GQmg/Ofgf46CV3nUncfR73MPcmygI6KslqOinhJ3fcj9jWWUN78fizTm5DzmY4wsuuGAHo9Jo/CWauDYajUajccaIqomUIBxzRBXhNokqwv5RWaAQvrWujogJAjkCOJajbbRxirAyJpCfs0ZYIUcSVS2ZkCoIFp9LICFVxjWT3AdrNKRmnTkxSVC1oFrHtYJrSqCzvBFtMAaVeSLRE+3YZmmlbYJ7kXWmW7Xuvtyf1n9lrdkn4Zjyf8YCZQ1jDWllfrR8c2/gkm3/jWfdT2Iyzos1myRPL3jBC5axy3zGuVFOkHX4KU95ypZHqNH4CzRxbTQajUbjlMLkK0lU50p4IPBnxt+jJKoCQoJFB/fPSl4QlrEYcWzLajZHWLGwIvCfBcJK31kvklUtqZAk/oawqkCw9i4HJIn5mLN4swZH5NQkSavAb2gXr6xZ5h5yCrHTqsj1ScR1XOeKdU2yKuKAGU/6otsz71EUMH4oAXR1N9sxfWQMLXUEUYWM8hnnYv0yFhDTtHBDanVr3xSshazxSvt4tS4z1ttd1BVuNBJNXBuNRqPROCVAcNVt04Qsc8IkgnElqscBWnUgrArGiYPE402hCetfuttaAkZrvCQWosKagqRAqCCHvEKkIIkQ1szWbOKgSlLnMlFPZcmFpGmJ5DMIWMZT0wbaw7Ht8jnbzK5MGSCIJfeoVuskq5aL0pVZUsor9yvf4T6nj659PuNeYf6YDyyf/g9iqztwVe5wfWsIjw7aiEX14x//+LLt1TvDe/OwMio3Gk1cG41Go9E4oUCQTKLK+zmiiuCaRHXbmVwPCtqvdbVahhXAObZJTM46YU2rKu8TEExdgbXGm33WUkeSVcgT5CtLr8xloK6A9NTap6xXz0n7QM49v4Ew06ZtJODatqcD9yRr2fXFZ6w3iaoEnr5iHVURwN8cKGjoI98z+VKST87PuazXmnuCygTmhs+w7lZiWvcK282c2+ZKVpl3xhoLN4QW130+ow1H7Z3ROP1o4tpoNBqNxgkBQmQmUkLInCOqCPlJVI+jJcpYPATgUV1K2o21CCF8m4LxWSWsuvpqVa1Zo3U3ZY1ZLuaWt7zlkrhCRI23tLYnhGguTrqC345KzOTaZG1j4YP0jc7Nejae8zjMEWsJssjh/WmyKvogUU1XaEgpZYCsKUz/GVOzU3MveE8wBh4QWK7DXJjBmjkhPlZSCQmGuNqmOXAevTMYc9ZE3VdcB1hyOTg/bbz44ouXfYK0trW1cRho4tpoNBqNxjGFNRiTqM4B4ddESgiaxyVb6ggI8lhXEZardRVhHGKy32yncziLhJV1I1HNJEaJLK8CIcINW5IEAYOoQLZYVyZFmgPnqLVP+Xsq7pVrsRY4Rsm3WNusCUjTUSpgtEpKUiWRfG6WXfqQ4wkcUxQwHJJOSTvv+e0HPvCBIdk0c7BuwhBF3nNwLs4JkV9VexUSqnVcMq11WFdjsw7zevOb33xx7rnnLu/FCtbDcQkvaJwNNHFtNBqNRuOYQOuHRBXBcg4IvUlUj2vWVIGQjQUKAX0knCM0a13dtgUHAf13f/d3l6TitBNWyFJaVUcuuyZIYo1p1eMzCKTjg+IDMsT4TBEivjOyoK4iULbBmqus+QrmQ1fgjJ09TDAeElTvTQie8aFYRVlXvJqlm7Vr4iTGhD5gTWV96wrMK9/hN1itR/Ho/A3RtFZrvSfyfrGG8OgASbY5L+SXv/mceaB9uoNDsCmlQ/bs46z8apw9NHFtNBqNRuOIAKHQrdB4tTkg8EpSeV2HHBwH0C8tUdX1E2EcYkKspO6n28RZIazW+dSqal91L2UcJKXWRB254UKUIKscaU2D6FQLKsd+xo71rivwKMs1ljxdgXfpglpjPr0fdZXmVaupB9+j3R58BrmDODIevJoNmPZDKnnP2pYEck6IrmWFBGNp2RvubebKzyTCnNsSP3Nk3szL3Hdax62/S7tVHGVGaL0cdqE4ajS2gZPxxGs0Go1G4xQAwpBEdeQSmTDmTcHypBBVhWQEZAT0kTUNgRkheT+1JNfBaSesxqJKVrGcmcTHzL0cun9CmnQRrXGtQMsg42ImW4mqrqnbyKrLMcoqzHV0Bd6PlW9VhtzRkS6zuvZWq6eZfxlj3MuzBI+WTsD4cK+yplHC6Fat1VPSyHxxXS2bSVYtacM1ajv4P3PDGI3Wra7KtJMjx5i+4u7NQX9YDxJf++G8bwra6Xo67h4fjZOPk/MEbDQajUbjhAFhXZLK61wZECxdlaieRGJFnyGrHJUgmQUW4R7heVfXP62EFQJFv37v935vLxbUIy13ljmCGOk2DOmqJWZYbxAYDqyDWWJlG+DaugKPYmKZh8ymmyRsUxK6qoYo/7ecjiR1lQu1yiVrpjJGrF2TEUH6cKe92c1utkxaBFll7Pku48jvIIv036zI2U++wxxxLq45GiP+z5rl3BXsJxJV9pdqvaYPJoeSrDLnzj99YezXVYgxn4yfBwmhuM8B/TazcaOxKzRxbTQajUZjS0BATKI6Vw7EciJJVE+qex6kQLdEBfQEliStq7uyGp82wmrSHIkqBIF1NXKtdS25jrSw8TsIhUm7tOpJWCBD2y5hwtjrCkwbaItEVHdbyBPX5pW/P/WpT12DhI766Lnn/s7POI8k1cOxSisnf/PdzPhrbCrtk4QKPmc9QVZvcpObXOue1asCRQGkkXPWdhrvSj+Zo0q8JfRZ+on7yjrNWtqnLMSsE9rBeYyrdUwA52Y90C/u29FYOn45htVDhDb4GdeDZDcau0QT10aj0Wg09gmEuSSqIxdMgYCbRJX3J5WoCoRVrauVpCMUY11F+N5ljc2jJKxa1Jj7EUGZI1a+N95Uy6kxiCbn8vv1XJArCBCHLqmQEMYCGHeppZFX64Py9yc/+cnlMTr3VLt1C9UtN18hOLSb8bDmaBIyrcDreBKssp7mGqPf3Ee6/npoJdU66nt+o8VV8D+zBdc4c8bROqusJwg315Q8CuZuLhkW/YfY8Vst0LWfKBW4Z7gebaFOKv0yqdKU4sIxcz5os3sL57HOqyWlINVpgec31t7dpAZvEuR2E24cBpq4NhqNRqOxBhAMk6haPmIKCItZQxWium3r1lGNAwI6ZBWSUoGFCLLKscuY3KMirFoUtahNEYmE2XpNkCRJlWClC+sUYdCqatkT632aUMi5cI3xOUQGssRhoiWJnUSnHmkZrZ/VvvKZpGoUr+09UGsIj4hpWkIzGdHoMwm/Lr0Sc67HdWq5HMfbazNujB+/pf2pIOB/xvZK9nQBrmBcjCsdZQCnPfyWazHmrJkaLmDtVTMPA92GV2UWp52Wt7Gua95zEmHaIJGVpDpuHHP7WLazJubCcm9/VAo0GrtEE9dGo9FoNAZAkIVMJFEdZWEVCNVJVI0lOy1AMIYk4g48Er4hRwiyo1i8bYJrU4f1sAkrgj7XhHxMkcvM4JsktX4fomAZmpqIRyuiWWqx9GXtT2CyINxMXZMSS+t8sgYhNvzNd83o7PcqWRmt1fzMdqUCJ+sK2za+x3UhfVonPZJ8+ne+jq6fsan2O8fT69V50EKspZlreE9zL3MeSaz1SHUPNqvyVA1h+o7SwqRjlSxzPmOGtUKbFEm3XayizK3JydxjTN4E8vtJhGkn56tJmBwPro3iiL5l4in67rxb+iYzEzvfxttzOC6MBZ/nmqDtjsFp2usaxxdNXBuNRqPR+P+JKtaXJKpz1rQU/CCrWj9OGxgPyCrCd7WUIXxrXd21q+AcYYWsQlq3TVi1knHNkeWL/0u6tEryt0J/ki+T/bDG+K4EybhTXXuNPYWw8Ldxn7plW96EzyAynFuyyvlQIGy79qb9895gzZOUKIkn7WUeOCqR3ARcJ+umMm70TyvfKAGQ46Arc41L9b6GFPI/khRliRrGWRI5lVmXc1jCh2tU0kefmTsUDLQZpQLXs3yN4Ddm8NW1mHtL12Z+n6DPWs3pJ2uANUlfq5LIGrHG2aZygnkaKZVyvXqsm6TL8UM5cxr3vsbxQxPXRqPRaJxJmOhEYZz3q4hq1lA9iHB+3IHAi5COkDyqLYsQDVnlddcC62ETVtYA5ARyUBNNabHz+sYS8huzzFYCphutsZasH103XW9Zeob+Qk45AOsy42gTjD3ng8yt64qeFs9VB7AMDP1h3We8Mt8xK/B+S6norus9uKpEVI5zWpCzTUDrLOfk+7TvFre4xZ5lVJJI+xnD0dgxFyouRveBhJf+857vXXnlldfqg9m0aQPKDtbzlAuwrsOSVdrOeiQemb6kmzSHiaQ4+L/1WUfIuOgkqfsNF3BstFxvW2HSaFQ0cW00Go3GmQDCrUQCEqAQOAXj4CSqU26DpwmMTVp0qtCrdXU/wu5xJqw1E24SIQmo1tSspyuR5dDaB2kxVtWkQBWQDAlsriuvy2+1xI3ckrXC6c66LhHlWEVuzRBNqRPdaUdu4ZC1TRUXmWhIkrUqRtjkSI4P4zEikcDkVlpdLSVjG01SBNmcyqjMPFvCZlR/2HPQf+Nksa5yz9S+0Abmh1fPOYKJmzhUarD+OS+ElT5l4iTnADI8dS8y11qVPQ5KLKvV2XWfMdWNxi7RxLXRaDQapxKWhZCoppA1AkJdEtXDIGfHZZwQurHwjaxAjAWujgjrh+EOeJiElTVhhtUkiCbHgQixLiATrgfalDHPWvxod62lOkpSBJkYxXMay8laZR4kycaF0g7mwZqeZtPdFiy9o3W1AuIDWVu3pJH9SbffVdZUE1AlUdVyOgXGXNLE72lfjc1lvPicNTwasznFRd4HxhtzDsgb1tVae1ViyXxJ1Eegn5JVxlbr88c+9rHFJz7xiSVpreVuWIOsf92GhRblPLbluk8bvEemEnCZFOsklZtqnEw0cW00Go3GqUC6ZtbEMSNY21Kietbc3BgfyOqUpUjr6mFZmg+LsOr+ySFRN76ZtcO4QJx0hwaMT11TZtQdWZkkYMacmpV2ZAGlPRAziJAunwl+q1v2tssn6RI+FcObrrCrXOMlaWlRXceamgmIVDZh9V+lZAIQVrPdVpipN5NabZpwiz2CvnNwTb6DJTrLP1lGh8O499FewtplLplHswx7D7K2yJA9lXWYcxp/K0nVmsq8bDu+nLn0HhkRb+ZJwqqnwUkv7dU4GWji2mg0Go0TiUwWo5VqDgi3SVTPYt1BhGytqyNiz9hAkrQqHQYQ1BHaK1mRsHIctKzOyP0zFR2MBSQAUgFBhixk1lb+Zr3QpszkajyiWaR1IWX85taXxID2jObBpFcSpm1CV2DGmzjFkSuw/ZhypwU1NnXKfTfPa81ZaxhrYf7Upz41S3IhZ/xGy3a6+ec65fxaRafGDcKIkmBq7JljybqEmj5iBTVBGedIq7tKjnrPuOewFvgfYwbxxaqqRZpzjhKfseZZize5yU32rLIcuyoxZU1iY7uzPZJz20V/vEfM4Ezfdp1RvNFo4tpoNBqNEwHrVUpUVwnKCLuSCo6zSFQFQqXW1WohVFDHDfUwE07tmrBmAhndP2t9TC2rZMg1c27GdfJ/iZ6Ce9bm1AV1LmYy28O6tf5tJSrGTkKAMgHSYbkCQ9Ik3XXcs16rVtVV8Yzcb5JUXumf5V5ox1zt0PSGyLq5I3LLd52DKe+ALAk0RdZr3C6/Ya5w2bVskWuHtasVNMvV8BuJHa+MkUm2RPYnlW0QbdrP/N/sZjdbEtZd1kHOtmh11+Vayzf/06qd7tt+h/HhO7TzrIRWNI4WTVwbjUajcSxhSQcFqFXxcVpzFHh3LfQdd2hBsXzKaLwgqwjfh+nmt2vCKkHDqqZ1TsKBEG4iHIiBcYjGPxuLalwl1jE+p22QStYWRAWSCsnhs1Xuy6xbiUF1A03CaD3PwyznY/kdjiR9NTZ1XWuqJFUyZwkaxnGq9q3tMGMxY6s7N1bOEcFdp3wNoO2uhRHRpp2exzXHfHHPsEZpu4ncslyN8d58l3WiNZ5Xvmcd3wT9oB18n3XGeJucy3txW8oj+moZpXrwPxUoxq0aJ2zNV75HuxgfCanrx/hdPueVfktuuyROY9c420/1RqPRaBwbmBEUoYpjJOSP3A4lqp0Y5C8AyUAoHVm1EJi1ru6nfMlxJaxZtkSSmnGWGV9onUsPxoQ1JAmhjYwbbZGsMlYI8hnvuI7SQItUBef2XNu2cqd1cZTUqGbFtSwUpMoxW8eamiSV8eE8ED0OMuHOKZqYD0mqGbtNlEWc8+jeX6d8TSoKppIJMXe6AidZp90f//jH97L4JtGXWPPKObHCQtySpI+g5ZZzaaXluiqKuD73Ip9N7V9JQucIaR6j+GCub91Y3kuwk6yqlKmWa0soSU5ti8oexsJ410Zjl2ji2mg0Go0jgVYdieqcRcZkNxJV3jdR/UsgMGpdHRElyJExk4c9brsirAjO1luVICbhMKkNZJVXhfVMooMArkWQ9ag11jq9o3jHdcqFjFyyd13/dtW1JU30i74ydlg0V8WG6yaabr+QPy13nAfCN3eerF/r2GqxNAnQyKq7TvmaXAsqLkbngfTS/yS97Dkf/ehHFx/5yEeWv9dVlnaxXnTfNXM062Mq2RPXoF/WRnV/49X4VN1s+R7n4ZU1yPrbhIRumgcAsip5lqia/ZjxwFXecApJKu91eVb5w5HeGcwN605rc6OxazRxbTQajcahwBgxCcYqompsqkS1s1ZeGwiikFXj0+oYIhxj0WEcDxu7IKzGrXJOLHMI5HUtGbcK0ZHA0RauxbWt5wtZQOi2DNKNb3zjJUlZp06pBJjzQLqwwNEuEzlxsF7NeCv5hdBwH0CM/L/ZWT1Gn/n5nKV5RPzor5loITEQ1XWtqZJUfs/1HTeVI1NlXvL+1f2XcyVZtO7pKDnSOuVrci1YwmZE8NKl2/Mw9qxLCCtJkiR0HPzPhFvOfxJtoasv4+rB+mJMzDpseSQPQDs4bMM2QZsskUSfGBtLEFn/lTEyjpbxpX/eE65bjlVkWWsz57B0U6NxGGji2mg0Go2twyyTSVTnkrFkncsq6DauPbYIpRCIkSsoQqXuh0cR5ztFWJljsqTuh7BCCCA7v/3bv720jNVSK5At3Xp5z3U5zH4KIEmMF2On4E1bjOGbS05krKzuv5Iu1vgoYZDkizbpkk27DwrJF20xYVSSXUghB32yrqa/qcTYV9onwdRt1/9LxLyH5wgN4+c5TMY0so6PPAKARGiufM06SaZ06eZcEErr7tKPq666armGGDsInXPHK7/D8sjvIKq03yRFzL/WRy2LlsDx/FNEnHOtytBcwfdGpZOmDuaZa6vQYY0zd+l9wFrUXZ6+ac3l1bUARnNssiznVld51k6T1sZhoolro9FoNA4MhB0tUAq5c5YdhJ0kqghATVTnASFBMNWak1AwhbDuIiPtURBWzke8IW6onLO6ombcqm6YxtzlOSApJtBhbG51q1vtkY9RvKM1Xc22qoVRy9wIWqoQ8CXQ2xbok3jT10wCpKVQV1XjKqcssPSV79pnkyhxHrMGZxbltCL7t+7Duv86ppYXyvPyWi3RkmZd2OfqBa9KMsW6ynlEwXDFFVcsSRyldiCtEGdjMx0/XYi9b1R68D/WxlRNVsC5LGUz8nZgXeoOvAkJ1Wq67pqAiEvGq0KHczE/elxYwoY+zmUBZgzTYt5uwI3jgiaujUaj0ZgFgpCWnKkjrRdzyVgUhqrrXWMaaV2t1hCEaq2rRyVczhFWyCqkdV3CqjsrLpycc0QIWEOQQ4iBJINXiZGxl4yXls9zzjlnrw0Z78ha5BoI/JAck1pZl3TKwsi4mxyMPurWisCvtVdyZPvy73U/pw3GgBq/a3wihwogrj+a/ySougwnuG8hP5LV0T2sAorzS4yxrjqeZstN0s/YMwej8TOOmHnht8yzbrNJjoHKA9vmuABeaQd94vuXXHLJntswa9IsubpQuz74PtdmXVJ2hnMwPhyr7iF+b5Ij2qSniPGfjA3n5YAYbkJC1wV9QpkDWR2FCKgQMPOvSZN0+R6ha1w3TgqauDYajcYZBYKfAt7csSombgST36ixP8z6oKcBCPRaV0eZURH8IaybuB8eV8JKXxHCEcaxjo3Wm8ml0s0xvydh0hrJmoOUpNXTuEmEeUgg5Ji2Q7IgN1Mx11oXLZ3iuEtYcGGGuHGMXHFHn+X/TGzjZ/SFc0GkISZmfuVzxhPSnZZmoPXQdvKadTeTCEsqGSv6bOIda6b6fT6TqGo1lFhXQH7NKDyaP35rCAB9NQESvzNTbtYPhXw6lznHtNfxor+6w9Iv22YCIt2IjTPm2qwh1iZjZ91ezuFvTEhUD64pIde6bdy93g6e13mlLZy/zvt+a61KVlFiVIWAc6hLr/vv1P2ntVxl4kGVXlpxz3oJssbu0Sus0Wg0ThmsyTd1SFbnLKSbAIEMwSdj5ebc/hrTMPkNxKUKp4wxgjfHqnIsx52wQjQgqQjjlp+pQAiXDFiGJBPdeB6EetYy648YxbQqaSWUDBLjCFmas6a6liGHWlNNUiTxoA0QVlxQ96PYGY0pJJXzWe+1tk+yQTskUCZR0mpI3+mbVkHaBiGT4Fn+R+ujhNn3uv3yan9HhJvzcn7XAWNqnChz6f4igba+qW1JgsxBm3UpNvuznhz+LYnkb4htKnQyE7DljVg3EEqIfrojax1dx5Wb9rJOuV7dL63ty/kB64FjDiPFxSgxl4Sa8zHG6Wpt8iQTfKnEoC3G5mbMqmsnPV4OSjCZGzNKm8WaPYl2NBq7RBPXRqPROCFQIFx1bJuQ5oFwMrJGNPYPhD5jKUeZYRFMsfLtooTKYRFWE9iYYAmCNrJwsp44D0I4aw3iUMkq94GJgiTzjktmT5X4eI4RtMZZKsZx1jJYwXloO/3YL2HV8qmVUjfwEXmnDcaRcuj2a6meHF/7qesvr3O1VLUaek7mkXZIRKollCMttib1yUPX2SxZ5TkySZT1TbVimgCJOTNpkNZlMz3TF68p8VRJxyvjw/eNLzabM397vXVctTkX7WIcRpmTGS8THW3qBsz1RuvGLNVcT8VVum4bzywxd73SN/42UZRwjajoYIy0Yq9DnOtndV2xDizjoxJFEt1o7BJNXBuNRuOYEtLqxrut4u662q06mpDuFimkVmUDQrtEai6JynEmrAi7EiEsq/RzlFiH/kE+IQOWi9FSKBTcHSfIpcI+CZwQyvmNWXSnCL4WWBNZcV2Ee8nRFKYIK7+BHFFKh7ZnfGu655qwjDnnFQKR44HA7289J2OrlRASX4mWGWE9J9fQ8snnScR8HZVvGdU9rX237ZUI215dlDOOkrZIhNLCSTuZL8m6bs4eknLL7zBWzp3t1gqrlc/rWhKGedWVV3fdLBczsnxmLVj6pTXVPhoXzXn9bF0yPPosk9kZw8wYS/Qtz8PeTz+5/i1ucYthPWFjmD3q3p1KEclzrou6VjJJl9Z6k4Cxnnmlve9+97v37j3m7bzzzptdS43GQdHEtdFoNHaEdayjuySkI+uosWGNowECHkKq7pUVkCgIFULqUSevYm1CWCHX6xJWBFozrfJbXkdlVBBy6SPkQPfPUSZcrW+SG8YMcpHWI4X16j6tNdWanIwr19MSuA64vi6glbByTlyTU7Fgdm0JIa/e4zVpkXGfkjXGlLjcm9zkJnvZbbl+HpyLfkv8LDMl2ZGIOS+0TXddyXla8fK9xFlrtXGwrlPGTDLouOum6r6S1lATGUF0aK+Zfb0m3885y9+4f3EN+mAdWmujquTI+bBGqrG4U2V3KlhztIu+jtzzPa8WxrrG1olntm+MhWSQe8V6uP6twtK94Ja3vOVynaWbOu1wbFKpobWa3+d6cW3kOqn9VFEkYc3ats6hccC0WYurHiKMefWMaDR2gSaujUajsQEUJldZRxW4t7JR//+1A1cdTUiPL6yxiDVnFCsnsToOscGbEFYJmUQKUj5K0sNvjcU0MY5kqZaY0folcYJUWLOU+0rCh1Ut3Xn5HIKGtdJYYIjVfizW6xBWCAPt++AHP7gkNKNMxBJADl1aU8HEeOgWzbnIjHvRRRftkQDHJ7MJz+0rnEfrm/GOko9a85d2WANUS7XEhes4Z4yh3+HcZgRO0imJoY26rVpSyLjVJMYSLa5hzdncy6p10ERNJj1SMcDvaAvt8trrhErous55R+75jJ/rVGK5KYzdtV16DGhldVz43GRYrgnmzljeK6+8cu8ZoLXcvb66as8dGdvMfGVGaV59hklKnVP/dj3mWpA0mwyq0dg1mrg2Go1GZKxc59jaBhzCyBwhPWrLW2N/QKCDdEEAR4IvAqrW1eOgdFiXsOpSqdXT+qIceX8Ynwm54FWXUVDJBWuc30PsIfgI9Qr0toHxSrdeSQsE1XGcK/mxDrSqQVizjUlYISKQCWtnIvCbHVfLluSEPlibU9IBHBNeJZZCoippmCNiknXHRlfaTECUBNU5qIqHWr4mySPfl6zSXuuX2r7MyJykshLCrB9qsiDe1/3N/0ucauxvWlenFD1JkG2XZBnlim7KWnN1/TWpE+NTE0hlrO8o/tcYYOvY6vKeGa/5zDwEjLHPAMm7a5vf5ZpxTZuUab/PN4mqVlkt2Dk+Wu7TdZi2mNjKdjFWrl1L/3RW4cau0cS10WicOUI6KgEzSoyyX6xjHW1CenqB8Ar5g4RV1zkEUEuqWMrkJBBWXZx1/dWSCAFI914TwmiRkWAmOTG+j/vQmELOOyIo1kr1gDxKVBGct5VdeRVhpV+M0WWXXbaXYdYyJbq/KsRLSqw3q5VLspZun45/tahmXdCMzczMv2bv1g01scrbQ2WDSZayv4DrQeCst+yaHhFJE0NJ2CSBxvw6HpLrJGFe0/9xXdfVyG2Xe4d2rXL1TisjoG0qRNJF2gRfZlEGEtAaB1rbk9ZL58+xoe+6AjvGtEW3anMIZJ1dSbT3S1qoa6Zgrw3yM79n7LOx1Vp+qwuxhDzdt9MbItvlmjY2nPVnwrWppFONxrbRxLXRaJxIqB1edWyLkCIMqGmeI6N8py2kZw+WW1E4rkA4ReBD8D4uSa/mCCttRUhF+L3iiiv2CJXuu8atWnoE4uG6l3DZT+5B3X0hdromIkiPrIncY5BFYj2xcNIWyeN+761RYiPJJmOgS3Ba6EwC9L73vW/Z9kysI+mmj5IpBPw6t4wDbTfJkpY8LZVa5dI6mn3ULXobZaYYc5QPtJvzcKCUELRDokIbkoiNEgKZYZi1QD9vetObLvdALXmsLy2YNUOzSZU4WGechzlgbfAb5r7WLKYNU5bO0QFxNFt3uuM6xlxHK/06yNI9WpUZI2vc0kc+Y3y1XltSiWv4fKA/JPOyHjDtkMhWC/lIKTFqF9dD8WLtZ+aZeVRpYCkpQ11cx5Z+8nkKbCdzxNww7oYy8F2TNGXfOfdBa8E2GuugiWuj0TjWhHRkHdWdaRuwfuHcoftdo1GBAKewWJUkkDoEY4Xu44Ipwsp7BFHWuzVF0zpnnKEJa1Lg5bdazBDqrX2p5UzhNpMVZdIlxofERDe/+c2XpEXLnCSTcyGMj8jnKGtr/V8Fc0Ufs16ulmD3nZGbroI/pIDEOSYrgoxYhoX/MecQFsmWlrcaU1njb1UEeBzUKs/6ZNw48rpmh81ESMz9qnAIMxZLBFnf9B3CxsE88beKBmHWWS3nXI+x/tjHPrYkrFqqU3lg4ictsOuCfqkoybl3r88kTqvgGtSiqneB7TQZF23kf5wTZQBrwxhjDj6D2Ofa3g8kzvSN+5d9h/uUdSWhzOzb/kaLP/3Xyiux5XysW9cAa1Z3bdrKq9/TTVnXZufTsWo0do2WxBqNxqHAenurjm0S0lXWUTXLjcYmQBBUcLRURwLBUOvqcVpfElati8bLQSa1sOjqqXCslTQT/nAehGUT6/hdSItukboX6naZpIlrmZEWyxOENeN8zUq8C1TCKlnlM2tkVgFcYi2JtOYpoJ9YhSWa1tY0YRVlgEbZo3Ofsu6p7qoH9dhgfuifJVYkqR787fjT3inC4Twxj5m0iXEysZH1V1kXrg9r1EqWJEN8jzYRG0z7RtmmGU/um6yRum6ypVpiyGy+1hc1q7SxmDUOOC2cmVzKRFVZ5se4Zokc52Ud6KpLnyGrmSV6U3gfZr1fyarx08aq1t/VhFcqQfgs6xvz3bT4+ntdltfJ65Bu2dtKSNhoTOH4PFEbjcaJJ6RT1lGTUWwDxnnNWUe7BmljF2B9a12twpx1Ho39WgerLIerrIjrvtcqbMyt2UR19TNmMOt10j/JKq8I0JCOrDGpy6/9N1bPmEeEa2MdjUmV3EFOtFBuC3OlSYzRTQurlkjaQFsyHpXP+BvSQdslClmXFAsa823mX901P/zhD08K8MbtSlS12B4U9g9LN3NdXZFZB1rImG8TAPEbXt1Xs84rc/uJT3xiqZTINaPbOOfLrMNaY7XCpWu3ico4anKhKbfdKWKZB+dFQcB5aTOKEMkq/Vk3W7fkUDIuYbQ0jPGgWjM5OCf9dE51C4es8roJWfXcXlOiyj3LHLn+RqEv1iaWrDIOzIuWVf7P71kXKA0Me3G+dYvXa2BqPZpEyvb6O+d3HbfmRuOgaOLaaDSGGJV82SUhrTVIp47jEh/Y+Asg9GLBs6am1gyt2fX9cZu/zBw6RRgRjBH6eK2ZRumTroeAsYC8rEMqD+MeNt7NEiVaVBFQsRAZy2jCJQRdrVLM6Sc/+cm9MjTpxpl1PXUJ9TwI8JCFzESLEA1ZNRNsJZhThHOT9yOhWeswh+SSOaKdtB3yqTsoYFywlEGAaCdE8AMf+MDevDEGkBUI6+/8zu8sj1VgfIxlNHHVupAM1vhN+kUfbAMkx5jhzBJrQh36yt9mtjXG1UMCYuyu1nPJqooavkdfdPfNxEockjXJPW3XzdyxsI4uv8edmoPPk5A6p1NwHnUHTmK6Tjy59XCTrNJPlTF6/tgGkw+xlrN2sGVzMo55HUiMk6hKUh2vWibK8VcBYTxyxti6li1/hBKFa0hu05Kt23TGIKto8tyZvEmre+5dWfZtmyXgGo0pNHFtNM4oIZ2zjhqDtktCWt14Oz7mZEFCADHaxL3bOLNKajNzar4Hu7RITq1zS35wjKyrZow1vmtXrq37AW3HJRhCo1ujiWkgXFi2zDrK3Ek0+S6/g6xpSdWSY4Zgs8NySFx0KdVN1nnjc8gDx7ZjfJPAjRLzQAzox0c+8pG9eF6FbsmT1jTmEBIPYdWCBmGvNVzpL99b1RfL9HAuXX9NKmR921WHCXTSaq4FVUtxJRE1oZPzNEVScyxZvxAnDtcM8F40AZWEibVvfKsKxSy5I7Gkv4wFh+AckFUt3JvMucmWaqkdS+Ro2a9gDHVv1qU4lTk5z8aBSgB55ZyuG8fQtb2qfmmtl2piJy3QKgnqXEpSTWTl9QHr3rHTdVulhRmRtQTn2Os2zdzRdteEJYGM5zWufR05wL38OIVFNE4vepU1GqcAJgxZx0K6LUIq6Vh1NCE9XUAIgwggQLqWLPtQyWEm4Fn1fgoSo4xJq+/z74OuN4TKqfg7rpPC+jrY1HJ4EGsjc3DVVVct3TsRXrWC6cbMe11HTSgEueD7vLI/GKeYwriuh3wf4pa1Qus4cC0tULqkVqxD3FYdU0CI/+hHP7r40Ic+tCR3WapHy6AxfxBViajtZNxY3/k7/pcxy2kZfOELX7i0alnuhP/jKvqd3/mdS4K1KXTlrjGpmcl25OWiazOKCRUFKhfqPeN9oqICBZS1PXVjdrx0HzVRkgRqLn7YLL7bKgPFXOg2W/vOXFoeqa5FxgySajy6xLESVV2VIXCOv5/pKu89xhhL4kdrO13oM3u2+4pEtY6PMea6+3pt73HdlU1QlrB0jgqPjJPWss39iBcBa95+2j7apPv3Khg+4IEr/cgy3GjsCk1cG40TQEhXWUdXJU84KCEdJTnqWJazBYVchJzqigp0y6vlKqwb6HsJ66gu4gh8Z5M1rotiJbSu4VrSyDg5kwtxHd1/FRoR2hGO87N1SeUuwRgimDMHkCdeaxZVE/4gpJIoCIEZkgoJ0LVUoqoFFVgq5Wu+5muW7rQKuwjOWjnNLmu8n+6wnEP36k1I50HGgXZRtocstUk6gcmPWKMI7/QH4pHrAxgbaqwy84fAzxiYIdbxoe+MozGHGetXXarn2p0ElYOxde1wbomWMYQSJucM4k1/eLUczyoXW8aIWEfWfMZMem+k66vu3nPWNNoHMWQOar+Nb+Zcm1jkzCTNeUflpUZWW/piBmLmht9LGmu7jE9lHNMdls9q3WHXDusiXY9N0JSEWKu4ybmse5zkznJRXMfyaSqMLJfE90eJ34TPZb0OWC/ew1ppTUhlQjXahxdCvT+mYMItD925E62Ybhw2mrg2GkeAFManjlG2wINgHetoE9JGBYIghDWFKOM+eUXAT4FUkrhO8px0880jY/Tyff5+0/cVum1yINBlfG6WNNEi5/+OWmHDvmCZGZQICPbG3uZ3aCdjBhlDiE7rD2Oa1h1gzUksKBAhiAb7EGTk0ksv3SOoeR32C4kN56vZg7cJFRJJNFmbuPReeeWVSyIOdGvmOxANypKce+65i1vc4hbLdo7mjz5idQbGKnMOSvOkmyWgf1go9TioRNx1VGM2JSMeJtrhfyZMkqxqJeQ3EAb6oUsnf0PYuO+mrH4VECes0JDVkcWONtBP1joH500r9FzdYtYf56+wfunUmE+BNcea5bxVWaUiQTJGG1jXjJVhC0n0E8yJVmiz6KoUToWN4Py6AvN/2mLMr2Q1FQ7pqWFJGsfWeqi590kKJZkSy6n7x8zWrE/bntm7TUDmZ8barhODTZuqJVVrb6Nx3NDEtdHYInhYruOuuy1CmtkB56yjx0HgbpwsQIYgrAhkCV0VzUQLEHAsCbJp8px1IUnw/tE1fvTeY85KOcpuCiQK9IX/Y52aiueaSkCV77cBhWLjGhG2tXAZq4pQzav9tpQGRFXSyXxlrCN9hFxosaO9Wq0uu+yyoWVGC7QZcdeBWXpXHatKlBjjyJxwQFqNDdS1mXNAOO9whzssSatrcgTGByt0WvTony6V+TszBtd6ogr9ElXdihlTSU61uPmbkRIF8D8T/ZgMiPHWRXVVcidLw9A3yepoTjgnbs20FUI0pXBKcJ9ZkqUSS9q1bhbfCsZIK2kl1paX4twme8IlnvngdyOiqhVTd2eIPu2jzSabMhGRoP9mu5YUW84oSaoxoJbKsURQKlg8r/se7XBf4TsmOnKNJCwzpes3/aZt9JW+m81Xwsw9YVyu98EUAXbtWd5JS+pBSapW3+OWfK9x+tDEtdHYAt7//vcvH1zbrEG6jnW0CWljm0BYQ8hFIKykRffQ1MSzThGsEPT3U6dwE2Ss6yZu9pJaBHn6hWCslUULF7AcSgqyI8yR4hFss2MmuanWYP8vOdd12TqqEndIgzGJxj8iyFrCRPfdFKQRUhF+EZytN2nMq9ZAheIa22s7JU78ThfrdY+DCMX2GaKKm6OlT7KdutDe9ra3Xdz5zndetnFOScJ4cS6IUvaVsYHIMV+6NUMKHO+Myc64YWMWXRvMA8RqnfXp71SYZLs5t2O+at27xrEcQ+iz7E+CecT1mUPX94MSS7P4ztWEHYHxNCZ2pCQxnhQwBzxnTao06pvleVgLKB54ZS44N9cZkTnL+pjpmu+xNjIZliWAPPRcyHua81iCxxhVEzcxp5JMQyuAic70fjBbtUnOMmaYubU9upTzO8aIvo7Why7l1d13m5ZUxok20jf6QFsajV2iiWujsQWsG7tVCenIOiohbTQOC7qUWjIkoQualkSBUIiQv6ll5bCglc/ELFo1EAqFgqKEYcqKqxCrmyfvzfo6cmt2P9gklpfzKZRyDQku14Y0MD+SEV36Ob/CsklhAMIpVjSsqQrwluzJLLCcG4FYqyX/l3xY6sakRLtWTNSxgCRpVdVimdlXjemjfxdccMHSysoapU8Qj6ls0owhngQSfsDv6KexuWbZ5bvVqsg4qADQfXTkKptgLK1xa1wrc+1+n4BcSFZXWUBZ07STscIllLkcZcCGrDI+55xzzp4r9DpgfFBkcf5KLFdl8Z0D/TfZUn1umqGafjCPuKlPZU92jUretJZyDj0Ucm5YVyp7zNjL+DNu9DE9FExeZChBlsfJmreZTIl2qNjTosqemiVsaKPuvSYJ04OB9eH6fd/73rdsvyQ1+8x3LSuV82HW4SSpu/C0ok2sN9r47ne/e9leiTT7aaOxS7R03GhsASZzWMdC2mgctxqsmWRGIBQZl5fCDwIRhHVTYfUwYRZSEwlZC1OiIpEzLhMr1boZbBWWk6DWBFT5uYR4JHhbJsPyI8a5ZcIX2qdFFXAuhPGMyVUgxvLN3JhVFmFeS6sWZq7DuKQFKuM42af4Pb9D8JX4OY7bKEM0+p/tQgjWAqdVUndQyaqJg4jHNdMvZHQOjLWWU8HceK4cG+O3E9ahXRWzqZsnYy958Lyj5EWA7xtPOacI0s0dZYzn430llZIb1gJklfW+CRgr3YFHxBKyCkFZx7VYMJcqkWrSIdaWpZmsBTy6XyRneg1Imi1dw/lRdJh0Ki2UHLTd0i98bjZdPRSMYVVBlc9uswvr2WDGbj43RlXlk67CNeEZsDyNRNVETtQKhgxOZQ3ODM8qQqoldVfhQCpomDuyddtWxo5nB2OmR0yjsWv0Kms0toDzzz+/x7Fx4mqwIohUQVrBCEGl1jY0ac9hIcnhqoM+IYgibNv2LLWDkAiBQ2A0Tu8gMHZ3yhJZkwkZo0nbENwhR1pTjIOUrOm+aOIerTf8ns8hDVpWTDhjoheVaAjRCPGQcmMoTRyjNVqXZQROy53wasmjXcfFWyuXazFv9t//2V76d6tb3WqP2Eny1hGUdUfN8k2uc4gv46W7o7Gu6U7JmGC5Njaxxm7TDn6XcbwQKsgVJIQY05FruZbbVTVuWSMQMQ6uY9bcSu60+tEnCOsmbsBCy2ON4wW0kXFY5YZdYeZx7je9OSzrkoqlKRLsOFm6qLrzMx4oOyBS1uX1vlJhpNLG/pn8kPvO6+vJYA1craKsN+NHJY+OrefhvpxSOPBb7ikzBntd+u5c1uzOgjbYd625WZ5nV2A8aBv3JuuXfYSDMa7eBSrybFejsWs0cZ0Bm+HP//zPL97ylrcsb16EIjYoNE4JNiEy9gEeQmyujUajcRJqsArdQdnn0l3YxEsIT5sIwsZkVivkJsc6Lrb0yVjQah3SndGsrOtCMjeK1ZTsrcpkrEXR9qEo4JliHUeEbOsqK1wjFCvYKoCbTZk+WI7DBCsS1TwYAzPSas2ZcrU0mYsutlrf6zg4FqNauvn/dYRp1oLuuhAaE2RpQdbqxnvIKiTdxEcQQsiT9aFXlSJiHBhz14DjZnyn2WiZBy2v9pv31rycgwoD+8ZY0zdK81SY6ThjHyuYpyQ0jA/jwXuIV7qsWuaHMeIe3Y9Lt3G8zHtNVsY1rL26biIuwThwTuUmyyNxLcgP7XbtJZg3XX/pE31LomrMs0SKsZI8OlYceU9mQsSsIa1bsgRVa6oKIxUkrAXGVcuwNattb+6LWtyz1BbzZtbrtJqP3K8tcYQCgr7vmqQ6Juw5tAlFFwmpmCsVJBx6Z9AWLc4kPwPMrX3uTMSNXaOJ6wDcoE9+8pMXL3rRi64RW2BChgo+v8997rO8yW9/+9svLr744t3OWqPRaBywBmsmV0J407U2gcA6lXhJYcfDMiuS1HVI536h8GeWXYVIhVKtqwjAJkZKQTMJpp9lwinPoyVXQXddmIEWwdpyNAjVo2ypWmIkJ46fFh7JSZbzMDupliHg75gL4/vM9Jkuv2ZbTdKwbkkhx0DX6/od46CN35MI5JiYjRahvip5dYmUrAK+B1nlWNcVkbG2TqkhHLxChjgQtMmaXJP16AbLsYoA0gd+j1BP3zJpV1rPGBcUEmYEHskQJuOSnOqa7WcqkrTeWT7HRD6O1X7c6SFUdW0zZ7oDb+L+aUws8+xcc37G2wRUrFkswgn6JFG1Hq3nk1Cp7NA1NUs8GQNtYiStpJlMC+jCm9ZUxk6lkSTVfpvpmX7U2P+cO5DKG8mzMEOxNV2N0ebaHvSfvTbr0u4SrF3LSWF4UclgP3mVsBqLy4HXzYUXXrj0MmPeLFtkToBVye0ajYOiiWsBm9QDHvCAxXvf+961BS8etN/7vd+7ePazn70MVr/kkksWd7zjHQ88OY1Go7HtGqxA6xWChy7DiZp4Setdxl6mW6eCTsYupmVjk/cj4uSRLq8Kf37XzLIIngjIc8jrHhQSeEgqY81B+0aufwqrunVCQHQbhHRm0hf+x/yYvEU3TfpoPJuE2/g+BGOtZAjfknHOqUXR8jDVIr6qvNB+rfuS91FGV8bBsjrWkWQeWVv0CRKDMK/FdRX4DeuZ6+bccg3OY5mf2h9jUkdZcTNpVmaY9Ry6fCcY3ySro7Zbf5TDxGG6kvtZxnSyHnyf87gJmHPay/2eJYCE5ZHWrQ8rGJOPfOQjy3q6Zh5OS7qkR2UA8yxRZV74m/lSeaMyjDaaeEoFUK11yrpxfHJdS6K4lyTMmcHXrL/eYxBPkzHRl1oGLJUVKl5MuiS5r/uJbt7sB8bX0l+9JWgXc7mu2/tB4N7J/fHhD394z/OmWtnZx93bGZvzzjtvuSaYKzwV+Mx+QXgvv/zy5XgZnsEaxVOi0dgVmrgWPPrRj15cdNFFy/dsrE984hMXf/fv/t3F85///MXP/uzPTg7kIx/5yCVxBa973euauDYajWNXgxXhiH0NAoQA88EPfvAa5BOhw3Iglr8wbqwq8nSbM3GOxEuX2ny/6jOtoiM3M60VlkABSUyNgUPY3obwl8R55H5qTCqCNNYKYwK1ZmrRtC/WS2XcsVZAKGkzY8+B4GisKr/luwiJJh8yXrJaACWrCJ8IpIyT1ptKng5qxcnSQnMEl3FhPBiXqfIjzJH1Kc2azPl55TBulHEzpjN/O1Uzl2uzpmmHpIL/IXQjjDPWlViYlZj2aK2uBLVm6Z2DFj/Iya1vfetr/C9dRDP7r+vbGFYTULFWWBP0hTXBeqCd+6mTybWMM6394Xqcm3Fa151egk3WZxL14F5a9wgIokoJ1qTkh7GhfyrCaJNjwnhLrjhYQ1XJwBibIdt9wAzRElSt0hJXCaYE2qRJZtW2lm+GGpg93ORNjJNeEHOJ6RgDxth1bYyqoC0qkfZjKV8XjAf7JeMIwWSOUJCN9nL3Y8aa+5LD8QO8Mke/9mu/treOTLLF/Lv/uD9uqyxgozFCE9fAG9/4xsWrX/3q5cMUVwhuUjecVVn57nSnOy0FDG7q3/zN35z9bqPRaBxmDVaENGt3skehJded1zqSkhvqT468TRTsJasKcpbvsA7itmCsJkKR2XmN99L9EuEPIXVVrOPU+9H/kuAh/NFfxpVxQ/izFmxaKhDyaowexIOMrgjqjDuCMPkR3vOe9+xlMc7f8B2+z8FcTRFxxh6B3tjBCgTrTZIXrYPMmF5BvyCrWpst8wJR0X2ZdtAf+sV8OZ7Oq0Kv7Z4iZxLkJMQmGkuCq6WS6xJrmjG5EkPGG+gquYmwTf9UEnAe1kjW1PY+yMRKNZmS/2N9mxn6Fre4xd4ahyxIcDbJ3jsVZzpyU7f26ioyzNjQftY9axcLm3M9cvVW6SJRNXsu7WA+6Ldu1vSf/0nqs0ar2XxNjsQYqRzgNb0S+Cz3nxFRlXDrheI9nCRVhYU1VnVdH+1txsiyDtwf+X26yDsu7lebWrM39fzgXoCIc9RQimyPMb20x72P/pg5mPGxxNaodi9QsVPDCUbW/EZjW2jiGtCiys330pe+dONCypBXyC4aqEaj0TjqGqwIVBJWhBi8SbRsWC9UslBdQjO5j3GenE+31RTktAql5XQVQZx6LzFDiLVtwjqBWi13FfdlKRAJYq3lmDD+y9IjkA/JtC6U1DrEPc+kSTluCPiElpDohN+NSAQCtiVsqmuf42J83mFk9mTdsN6wuI0UJRJHiBHuhfSR8cDlkz5YSiTd1mm/1qpV1l1dyzkX8+SY6gKuxwDfN/Mrv9M9kzmj7bXNNQFVxhl7SJKcJ/7vWrT9CPqEDdW5og1aViWrrBl/zzmdx02TIQlr1RoLWmHt1SyBVCHB01XXe4H3o1I1zDVzjFsp7Weu+R5rlvVvVuzcdzhqMiVjeFWS6P5PmyWhZneusPyM3+GekMzplZBtyIMxMzsu10PpVJU+ktSsk2piq5FlGOzaFZi2Q8JJQAZR1UOmtiXDEBhL2mMyNkLbTBhnTLikNpH3hs8GXZ6Nd3f/r6EpjcY20cQ18OY3v3l5037d133dvlx90SwCHuSNRqNxVDVYEa50L2U/etvb3nYtrTn/1y1YaH019tH6kpVMaVmxHiEC2kGsCJbMyCyzCYRJhe1tWSvMAGsJHbOd6vo8iuM1YyiCMfs9JBVipvVOYRK3VIgRRI1xhwB4HjOH3uY2t1nc5S53WfZrJIgz/rTNdlVopUUwnspQu01ANBCSEZBHZBUg7KLUkKwi2DIe1qdMsKZQDvP9Td1fGVOspKxB5oPxMemTQrWEBJh5d8ojwHlVYDeBj/eGZXs48jf8P8vHeH1LGKXLpuNlcq1MBrYNaxzzo8Kl7ge0k/6z1kbWW0sPsU61hvu3R96XJt/SDZY+8X/jXDmfrt8emdhLhYLjYU1YkyfpCmwW7RH4fpJZ+8U4aL01LraSVMfd0krMl3Wr09KrNdXMw86xZY5GigHG2vtSV+BRPehK/lf9DSSb3Idcn/vQurPOowe/zwzg9FfXXojuKIM0Y8BRFTgmnTJZllZcrsGY6r3DZ/y+iWtjl2jiGrCA+e1ud7t9DabxFqPNrNFoNHZRgxWBwYQaCFcIgrxHuBolYUFIQ4BN116FHWPBRuD7ElXOsZ9YuwrahnA5cmVEeNS6ul9XSSGZkeB4TV3dtPwgkKXV2sQu9BlBFEsMhNXyGDWLLWSV54hEJwkr5+G3ZJ6HtI76xHctnTHlnmdb9lOnc1PQr7SsTiVYkqzqFgr4LkRmW4SVsWD+cGVHeOf8zJdlRqyVmSVqTI5kPWCtscbFplCflt11EjNyTi2HPPOTLNIuxkzrsFlugcoR3Yx1CZds1T7P/Q3Mrj0iCxIzrsX6RumQ8ekmQOJeUFljjCKfa73TndtSKIYI8F3WO2OgZTtLz9Rsu65XSWdaqlWG0Vb+pk25L0gmtXhaYsd6qGbStvYvbcnxsk6rLt66L5twyc840uKca2/k8p3KKO5J2mfbDwrr3WrtZj/XnTlJqu7ztFvrMe/5zLbyt54HtllSag1W5iqTW5mJ3LXO+ki3YxPDScxVZmToRKOxbTRxDagR269A5oNjzgWn0Wg09gOztKItzyynvJq8BeHDRCyV+PAdLIQIFbpdStIQQCqR0gVWsrot11zd6xTCKrgWxPog1icFczOoKtAqyCFsOX58jzZVa4+kB5LFq+6/gt8zF5aS0FJt3KKu1SZlIlnPVGkh3Rlp58jlkHnV5fCgJH7ddQbxkiBWmIX35je/+TXIKpiysJoYjLld9YxVkeAcMT6MNe1RUWPpIMYklS1a8CypY8kTy56sAwX3OXdlXdrTIq6rMvMP6bGf/l9XWNYTbdatd1O4zmrNZWCCLwkrSGLKYVwph9ZQk2tZX1SlmC67nMtwAD0kaiIe3WlNnMTv/I4libz/tLjqgu1YSZTS6pkWT35PG1lf9MtatyNSX0vOJDn1mHPhZf2xh2T93ATnYy4dl4NCLwsTILHeWUdaVSWoJhFzz1HpqNU6900Tqxlr7v6jazafaUkdZVnXqpr7kp4VHO9///uXv9W1HqUc7u+Nxq7QxDXAAxWtOckH9gNiBUCtTddoNBr7AQIZAkxavNLVDQERl0wECWNdEaQRInR/QzjRRdDspSOYtEaiuu2Ml1ybviCYVQHJTJu0c9M6gApdxtSZpVRrijB5ikKfCV9wl8ZKQJ+1KiOMctQ4Q7PmOh+ShiSsjDOEjnmxTzwTKmHV5ZD5GrndMibGO64q77ONdQbZ1A145K4tWdWyWudpP4RVT4GayTfXB+vGNlkuhfeWMtECyBgzl5L7g7hOa4lKuH5cw1revMfSkqWV0b9dU/uNWxX023jEStR0UWVPAJJQs4KrpFGBIxH3c8fdckwqI5LsqJzXrVQLo+ST32Vcse6qaf0zqZLfd57SomrZGkkT7UNxwdqi75VEZmIsFRXew7r7mqwrUdeIJbd0C/c+SMWMcaKMNffA6BwVU98x5pn7hoNEYcbT66rt3KlkSE8Q+5QlwUwwx1xmpm7gmjHbsqieG7ZPDwXuLeOHIaso4szWzPxwT+T1G41doolrgLhWHtzEg3EzbpLkgrgBNE/ctPe4xz12MVeNRuMUAwEj66Sqca8lbYxtNOEHAoTF4tmzIBaey6RJujRW6AZr2Yptu54iYBozNwqh0G2Z/qwr8JjoBYFPEjFVskeyY9+5HqSS6+lOSp+TrFarnJY1ng1cL/shYeU6WPguuOCCvVqgI8KKMIlAbLKYCpURZkvepRAo0TRWbkRWWU8Iqljq6ctIqcD4cp5qOUzCanbmSlDnMvki1NMuyZfZZmkPSgEFdy0/m3gESNqyhu3UIVnMeqsJP6Mt3j/MIS7hliIaWZhXEZ4kD671TKZWXVS5hsSUQ48D3Vt1ic0xNyMsa1dSp7up1mFjPI0lda+QMGlZNUuyc5XZgfl/xsOnR0fGqGpd16WfPuv66xhXhRrnYTxYZxyci2tsYgF1jK03rJJm2/elrvfsJdx3EFX76T6WtWoZNzMUq1hTkZAZ0Gtd5lTaZS1nY7crMimYsdZavi07RRssHZWgXbpU245GY5do4hr4hm/4hmU5HASKn/iJn1g8+clPXnsgf+AHfmAvTuMbv/EbdzFXjUbjlEBimURVgRIhYGSFQ7iAPKDtRjhDeESwQPjRnUwBFeECYb4KbwpAlpDYVdF765zSj2pdpR9aIlcpBxkThTmtqSZPGhFxrQwKXYwR40Bf0+KCECdRrS7AxrNxPbxvTFSTApnxYpwPF2AEf60NI8LqnI6szQDywZjMJaPZBnRvNgPpaAyZEwRUyeqUe+2IsEoGjYOGDOB2vEmpGQkM40/7nEfH1UymzCvjrptrJhZbRUZXYVVMI9Cqx7w5jsaIozy6853vvDgIdMeVsDo2gD5677C2mFPL1UgetXzWeFNgLKpuwM4Pc8aYWrYoYx+1smoR5besaa6tYirXti7LWmUzmZJ7l/tfWrFTSTGCbvOuh4PcM6tc9C3tM1eiaQRDEczKzB7NXkKZGe4Hrmd26YxDNeEXY2voh+68Wa5Ll/SEVu1RnV4JK+9N0iVJdd9xbZmROufS2tKuH169Dy1vpbKjLa6NXaOJa+Axj3nM4ulPf/pSI/a0pz1tcf755y+++Zu/eXYAeQB8//d//+J1r3vd8oYlHfxDH/rQXc9bo9E4IbAWXsaYVSFJjT9CVArBlp9BEMZSqPsc36PcBsQhCS6CFu6SCrVaXCWrm7rhbgLj9RBCq5XYtmldHVl20y0Q5aEJlMzuOyJ8gHNZB1SXUQXuFKIYS4TokcumtQe5HoKlFtEkXNbWtNRLCnsjwkpfFIpHBNHkQQiOu5yXdciqsbisszmyCpgLhHDGKbPGWguYcfGzOXCNGndI28jIbA1KEyrp/svacHy1Fm8Trj0O1kS6/ZrEhvlC+NfqSN12xtiSTuAgygfd0em/8aB8BinlVfJishzmQ5dSiaouuY6xyXVsp/GIrDuVO8ZyS05MwGQyJBM8MfcmyBopJPgu59Ha7DilqzXzaxy6iqgRcdRlmXPZxoN6Iqxy0Zc0rlNayj1LDwLmiH2LNUxiMuOy2VeYI7NOe7i+JJaMse/XXUMSVkvSqEBjDrifOSw3xb05paw0XMAx0ZpOvCpj7z3KnPDdzDjtb2jLtkNMGo2KJq4BbtIf//EfXzz84Q9fbvIPe9jDlscjHvGI5WaUsazc4G9961sXL3nJS5bvARvGT/7kT7bGqdE4o1CYTKI6Z+HRdRRB2ZqFCghquSUCZtA0U2tq3LVAac3YVpmaTawWHFWQRZDSja/GaVqOBsFVwuuYTZEek8RYkzATx1RX0bT4jFyAaSvjbjIU3UGT2GXZH4XYJJmVsNIn+sFYjMg7bc0SNrsCgqRkNS12oxq/WFZZOyOyqlDM+Rgfz5drWgt6KiTSbbHOla9+h3VtBmJih9Mdl/njvCodXEOrSPEIWeJD90cOyITxhIDrGY9rAhvnbBRrnGVz9gvGgjUIEdfyaMw07dJaaX3UdP/lMLGYljBfdfvVQpvlflh/zLvuwBJUX61DTBsgYqynqUzXWkFN1GW2WebSzMBpYeWocyhJ5bD8FeO+Dc8Qrq1i0MRpCdqrKzDXq3sm38+asyZIwpJqNnGVOdwfKnJUInjo+mvpJcMVMiZ6CpJSFSTGJ7v3034t5re61a1myz8lWN9mtGYtmMWduURZyjmYL71GLIWTYyPMot1o7BJNXAv+wT/4B8sN6J//83++vAFf8YpXLA/gZkbtvYQb0n/8j/9xcb/73W+nE9ZoNI4HsqSEAtk6bogKlVpLEBaMWUu3UQu5sx8hCGklSMGAc2FhRatudstdl0jJMg0I2yOrBYKwWn5JigJrus0qAI4sN1o4U6jmXFoWRv1kPBgHhLjqAmy7EdBUAjC+vM8+GDdoRmGtKimgSVj5P4KfQjGvo1IZlrDhnLuaH8kqQjTCc3UZrGTVtgNJRU2UZPIkrEaMkyTINahyxHtAt0Zj4tJyJMnKLMW6uuNCmYSV3zq+o0zKlXzWv0dHkhH6ZY1c5z6taxlHPiIyB4GWTw7Wn5Zj1o6fu8Z1veR7jJNu8BKfVNgkGVLhYLZwyZGxmoQbQHZ0+7UMitZby21ZambKGqrCgnOkW7/Qg6K6/9KeVNJppVXhtkl+kTlYLknr/SoXfQlq3gMcZkGXoDIXzFt1yTYTcyZLMgmcllRr4FYyLilNcio4p9Z+2uy8MpfeGyZzG3m0qNjIbMpmtUYZlbHD3nvgwx/+8FJB4v0+yrZtCSXX62E8fxpnG01cB3jSk560TNT0uMc9bukSM0qWkCDG6QUveMHigQ984K7nq9FoHAF8QCdRHRGDCoQJSRcHD3atiwgDCgsmwVDoREASJmbxenwP4eWWt7zlcu/ZpZtpgn3Puqsjy4vCPkIP/WSszDKL4CcxmipdoWs0h26GCvoK7H5vFGuoW2IF42aWUC1YNXaRtutSjUBPP7huVRSYyAbyZw1L5nMk2Ctocq5tlRLaL1klmRHWE+aGfjEGWDjTVVMLqYdxypZyEWapZpwsMbOp1ZExZeyw5NEH4/A4B5YewnR0T1xFQjctNSIZq1DB4No7iACusiOPzJhMG+i/ih/HPOuPShCsPWrJK8uX6BpvciYzvJpY0mRrem9AVlFwpaWfOXY8dPnU+pZWepUVXEN3cPcu44HTi8KD32lJdb0Ya5mJ4WjTtpQDjJseIKNSThJuxsd5gry53iGlEHcO9i/mibGpMdQ1jEAymUobEyLpDiyxS5KaY2zZIPcN9hrGjfuN79O+mtRNjwfWbS31I1mt+w9zyb5BHyXr9FFCzecSU9ehbs5ZpkgSbcw016MtjcYu0cR1ApDQK664YvGqV71q8drXvnaZaZgbnQ2dDQ9N8N3vfvfFQx7ykMW3fuu3tpap0ThlJDWJ6rok1Qe6ZFVtuLUxEaZ0G+MzBD4Jm26ANdYNwYpzadnAwgoR2RUZqqCdJloajQNtMvERgu+ll156jTqRI1JnopcUyLV6cA3J5Qi6AEtWRy6uWtQgq4ypZVQybpX2ch6tLlpE+R0C64iwIhzSNgjXSCg2wynn2lWsly6K1o+V1KdbqEm4dJFmHHh+VcvxCLqlWzKIMZI8QSrnXBBXWT4t2cT4Mc4I5BIWnql3uMMdlq/bIjFZ83PKzZX1a6be/bqkauGUfCDAX3bZZXv/916XEKWbrwod405VBmSNUbP/sg9oVWNeuI5Zj80qnvVrTWJk1m6t5xJVSZj3myTamqHG9lpbuRJMxjP3ScsDGQMuSQVmKfbYZmI4XYFHxM7SPFo6mSfCvZgH9mTGw/3NMXEMfG+yN6+lddHxkajqISJpzLqqVTEETO6lIohX1mOOsfuv/fJ6rAXLbulyPHXfMJeSS+6Fyy+/fK+/HIZ0jJSgPtd0lVeBqaeKCabS4txo7BJNXGfAJkByplUJmhqNxsmEFoIkquuQVISHtKSaNbOCc2qVM/5VIoXgOXKD1CKGcGNsqNYgSOsuk18ooGm1wIpnTJiJchROtHwhAKqVnyJGEh8JuLFk/K1FFOFsFIuZLsC6E47iwbi2ZNWsw9V6ZDZhrauSTOaAfqCsrISV9iKIMif8v2JVfNw6YMwy623NjMu1IasmLZKsOi/GOWp9QwDld8zhKuiSDbSSOSaSKSzM1gKuZDTJ6lTfJUyZ1EfiwrXudKc7LQXwbcESRqyHkYuolqEpYX1dqCCptWsZe8ubsB7dA5xXsyVL9LCGZkZW3U29X7QC21aJMuub30H2JS6SEIgQYO3o8qkSiWubOVuX/Uzuw72qIoc1nfebGdFdp2aWTSXEYdSFrq7A7q3pmqy3hlnJ3R+0uEsivc/SJdb5yZI+WiS1ZGaCsczQnF4LgDnkHjITNmPF2E7dL5J9FYAqVyTI3o/GutJP9jlJuiTV95yDsTFBW60Fnm0xCVkqX3WfzuzBmT+BdkjYm7g2do0mroG//bf/9vKVG/BNb3rToVk0Go3G7sEDvrr7ThGlRH2Qq92eg0QDgVV3TOOAFGLS4qCmXpfNdLficwgrwp+QQFZLW/1s1f/rZ1wfAWgUq8n4Iaisk0REYY4xQ1BDMEKI1T3POFMEqalkHukCPJVkymyrCt8mXNJ6BBC8aINEWSsH48n3Iay1/APQ4mVsZ4WW4lqns5LQdWqGjsgV7ddCZ63Y6ronoYf0VYJR50TLCXPAXOjqx7iiNGCdakHSqsM6XTfJywjGS2rdyoyljNuFF164zFq6DQurJXSmsjgbA8gxcinfBIw/VnkUO8aAqkDw2mT9lnhYskd3YbP5Wm9UV+m0/ua60vVXC6dkJvuh2zDzxneuvPLKa3g7GJdu7CrtVDEhQZGEsqYy/jnXL7+hbaM5Mwu67r/bjHfUlZp73RqoSVgtL8M6ziR57mOZMCwVcElO6ZPZpE0o5qHLr38bh8pvJcjs7dYu9pjKol4TUkmGgWTcPcj7njHlYE8y6dqIKNaa4KzDmjyP65kdm/mmncyrybDMP8BhG5l/s26bGEqXby3LTVwbu0YT18DFF1+8V8+1SWujcfJJalpSNyGpSVTXtcjwwCZxB7GDCBUK6bqWZcIghBCEFq6BQIAggFXEOCIEDNqCYIEwwHmTZG4zcyNjZf3HHCOTtSis0s4RMTLzLgKV1lT/tiSNrrq4q46y7VYXYI6pcbdepVbsUc1NrovQqDul1m3dkemTpSpyLBH4tCBqPc6YNj63Bi7zaAmdVSR0XTBO1nzUAq3QKnQBhVRqhZNsavmUlHoYW5hkwxhkXbLNmMuz7yCElTFjTCCrjI81OoGKG7Kechz0OavrowRmF9bw6p0BacJN23qp/E0ftZgy/yquWI+6lJv0CyUUbclSL2aElTzm/sN3uBZrNYk/0J1bC7vVD/R+yBItxjByPtZwJvWRrHo94LrXu0JLYyLdf3UpP8j4GuMr8ZSMsj+arVtlgfHqHIyz7rsqBGvZGfuqy7oWVpV2WpvzPpKcJlE1Hj7JqYnoRu7P7p2VoGotVdlBfz7wgQ/sZe127Pm9ygyzcK/KZq/CQiWh4SbO4bnnnrvMj8A5jXn2OaBFOl2jdSXn3IZ3oCzzGcbnukp3HdfGrtHENcDDjY1xmy5LjUZjt9BSmJbUdcplIDhUd1+FGoUZs6BOWSoVriAaHAiWqc03PowHvS5bklW+w29qUh0e/MZc0saRQH5QmOVXy6SWVAQPEygxFpJQ/68rIu03SYu1H004MkrkdBAX4Iyp4nCsatyqmYw5jwK67qDWv7WmKdY/Y9iM6eT/xuRJQJkj51AyvU6N0nXgNWg/JA+iQ38UorXCuT4hkzybTMQDFIZrPdQ54bESVsGYEcPqutsUtJv5tlasViETDDEPWKNIKsb9sF8ovBujt+0kS1pGvT88GLOMKfZagDXC962lSv/4rplfJR5aJPU+4L2W07TAAtaqZE1liJY0Xi2Rw7o1JjkTQem9oQcE61fwGX8bs8w1dTmFBNbEQ/k+60Jv4v7LuCQx9X2GT3hv0QfmlvvUOFSJarZN910VAda4zTZrZU1vBc/BOGhdlagCrarsb4yR8accutGP3O0lppkZWIus7rwqo7RM0l8zkieSsNY17HNJ0mvSJK2nvGdMuR/5vXsI+weJz2w/52B83Ucz/ECyyqtWecbDNvMdreoScO6BTs7U2DWauAbQhI42kEajcfxIKg9ahcW0RObD11dgsgxjk3i4SybN8rsKmTVTaxvtqAmIspyHbpkpfJh4qZaSQcjld1VzrxA0Kpkwej/1ma52CLpa44x/4uA7xNvVUjJaVSWZI4HVuL6aBKlC0st5aiISwVxYqobDcyn88Rl90b2S9ngeXo05M4OzCU6M0eKw35JnXiWkWRJn3Yyno2REEvEsH+E4WfNRsgq0fpi8CoEZwso6sp9JUDchZVOENV2C92MtYU5Yy95DCsOML22l7boz7zfxUiZZ4nV0r+pmu24WZ+aCNuptoAukydi0eGnhz3tc5ZTu3LQr40O5f25zm9ss26PiyjjQJKu1nZJQY8ury6ck1KzdyCu1XZKitDB7T3B95oF1Zey015nCOu6/XndETD3Sosoa8b1KKe4JSxTR/3TzzfIykrAk+WmhlKBWt3pdgDMuUxd6xgqCyn1AwiPvh1qWJ2O6bZPjYaKtUZjFCPSdPWlEWJkf7hWfVZJf9yzDNuy/ylTH1D1TEs1vmEfG91d/9Vf3lAA1qZLxwCoufWbqAmyWfA7+x1y5/h2fJq6NXaOJawAX4fe+972Lt771rTsf+EbjrGC/cZg8gDPRBq+6b84JBgr9HqmNFwo667Tda/tAT210CtBqyBV8JBa1aDxCPucycYnWDxRnCob5G60C+wXttSSNyXeMu9XFjutDWNOSsI41FCBkkiUWAcYatUmsVrkAp9BlOxGwFDolq1qHs16lwjdIIpwZjU2eI6kygYvZhFNJoGXKhExTZHT0mef32r7XQsw1M2a1ki/JMusHN1rmQ7J6kFhBrouVuWZbPShhNfGY1motrow3/aBWrFYa1vYoedkqZAKh0f3KWtAqNVX7M5N0JUHNuZnqn+7ormOTt9FXLXXMkUSCg34yd9R0h4AYUzsXcqCbLx4YjKeKMWtDe1+ZdRtIYrme90nd+8wyzDxzfeMduV+n9lBdhz3oo/sx8zFFTIUZebWeejieSVKNTacvmcHXRGNaPnW3zSzL6Z6v5dE4cJNfOU7upyadYl6YI0sEMUfGphumwfdti/dHloXJGNl8n/1Izw0JIr/XzbyScrNFM87WieV9JmOrcM6ZX8lzfo97kH4bx173HRU4vOqpYtiA45ehH3PYZghLozGFJq6B7/7u71485znPWT7kX/KSlyz/bjTOCnwAb5LMZ53/r4MU+nV3WycmdSSorRtnk8QwiSJCgq521phUKy+RNbOjVksEIMhGJlAaJXNBaMti76PES9tCuuqmVVUrL+3G+pJWT5MXGe82NY4IOcT5IQBnRtWMv6VvuhObOMnYKQVOM6MqpGciFV0I+Y6JnjLRiW0dJSVKwqrrpwKdMZYSAS1RlvtYVaYj16oumryv61V3bBQVEDxd8YCCOKSD9pCgCBc+2rAq+dW6UPgdEVZdgvdDWBG66U+WbuIa9NP6wsa7QQo2XdtmL0WBsUmSJeYgLf4e65QAynObsde1Yn1PLfwp1PsbrZJ6IzCX97rXvVZejz5Sg5fDOF2JHutcK6f7k5ZGIBmEbEgqspSOa5nvIdNMeUCYvViFEL9RWWQCoBHBl8ym9dS9U3Lqq4qC3HPdVyX+qejLJEneD1p007Lrq9ZWlQdmD3edSFZ1o1URYT1T3PT5fX6eBLS+B3r0JHm1vVXJxashD4aT1OzLfIf1gPJiTqGiW3KW3dF66/0iQeY77n117iTDJtti3VQrtJ4xtT8ZT0xumJzTRmPXaOIaQJh57nOfu/i+7/u+xeMf//jlZv7whz9855PQaGyK/WSMXfX/w8oGqOCfRHUVSU03PF2VTDpjQo1N3GbTiskDXPKkiyvf48FtbKohBAgKWMSMRzNJzlSsF2OKQA+BSMGRhz6kcb/kYQq2lWtaw9SMxkD3U+soKhxLVle5WCKEQlZJJKWQrQDJvGbWZa6J4MuR0Lqi5SJdarWIsi60llv2QXdH41Z1FczDNnJNBTzaZVIcfqvgmmV5RlC404LqWp1zq6xklffGqnI9XdQRCFF2YJWkL9siq7sirIyF6yrr1+qCTf8g364p3ZvXFWTXTbJk2Q7uxQ996EN7ltRc4+tAsqkngJ4PkBjGzmzIunHr6pu/p38kuIE0MdeJqfFlvBhD2s7BWs2YWcC6VomS8fd6bJhATE+SGu/JwViYqAlkjKfZzU0ERV/0KBlBglotqNXNWos2Y6cVsboq+1laLjPWM91WdU/N8i5ZtiZLBplUyjnlPeNgH12/tNdnwKb3QE3c5NglOR2td8t9pWJOYqmStd6r6Yaca9Vnn2Wp+J7KGtaj86KLfrbNMQYmmEoSz2HG9ZopfQ5Y9C2Z1mgcBpq4BijN8OAHP3jxoz/6o4unPvWpi0c96lGLH//xH1+S16/92q9dPkzWTUaAprnRWLdsyabE87hCjXOSw3Qtk+j4f4Uytez5mllRTWi0DZJncpdV8V1aAxlzrm/sKW3gYW3txCkgUKDJz/PTZ36HYL8t7TTtoz8I3By6wmb9QUsdqKGXqK6TaRVBEbJ66aWXLs/vXHp+zkGWSkhRKiUkecad6XLNZwpKuti6pmkT44PwZHyWGYKtaTvVRogGhBryY3Zh67BKWCEfCmaZSCoVKWn1Xwf+3vg83pvQyWQmuktDnnVN3LZ1gj5DvGrCooMQVl3bTbIkzDRK3zm3fWH+UOysk4nb+5D5SsFdspKulHzG83nk6jgHE/eonOHV8kq0WYJK6RrOzxxqFZMcSrjYA7hvsaaed955ewqPt73tbZPX1xLN+EmKR27iKpA4v+00qZhkhPHi77wHXGsqWaq7rAfjZx1llX18xznUxTWJqdZULZysL/qTGbwT7gepJJSA2da03kpedb12rl0b1dIpEdV9nvcSOL1t/J8W6HXvsSR4qQjz/LorZ/Kn7GdaIv0t/XOc2NNyTiylpdXSZ6a/NYyE703FFXPeyy+/fC+rNOel/9yPyqnGrUr0R6V5WBNaprMEkpbsUSmv/BulDfsev+HcHePa2DWauAZqPTlu9He+853LYxOoUWycHaA9NwFEPnSPsxZyG8l+8jNg7TfjUnW5y6QaFWrjM8NvJts5KEywIlGdsiwA+6RbG9bJ/B/kic/mLJNcC3eveh0e6FjZtlVqi/MjbFOOwzqfCcbTEjwZY7oqTsk5RKC/7LLLlmSwnlurGhZDhCGtmwpiCm6MhdlfaYNWE+4PY7dUUkh2uG8Q9BkvM3paKqSC7+qyDOlIAVjCKlnlb4k1fUuCuu59apxclh+hrfSFcyt0HhZZnSOsurPvh7A6RsxdHRsVEZmllrmhj/nZCPyWe5Bx49y6sLPeaL+ZcCVo61p9jE02LjOTiNl35sekbtw3kEheOQwLUPjW8mTSHiyr9M+5HcFMrxK0n/mZn9m7l0au8IDzQ2pYI8bpsob4DWW1VMBIenSfz1jM0XPGWFv3UuNUTYQkGZXUSBAlqO6X6YVS265issbjO9aGBKQ7r+32GelvMkxFEmj8sC6xkkj/TiukFte0HqbbcGb8NeGQv3HMJacSydqvUe6B0f1Mf1FYsi9rBbdsEfejJbkS9EEPn7n6tyopKZuDe3nud2Y81tVZZYTu7+Y2SI8i3cl5fpjoS7frORjmYV4CPRMY1yaujV2jiesAGSvh343GHEzasQtk8oZN3WHn/n8QmFFTYTMTJ63qi5p/ra3bJKmCtmWdvykrjQlxjF81q2jGOeoWuCr+UIHFmpVC8jJlLdwEjDFEDWG7FpQHuqFiEUaAWJVYqWYtlQR5/gr6gEUNCysCWNab5BqZgEWLpSRCsqpgTxvtk2vHEiG6blpvVRhjyLwx1vwv3cz53LhaLcx8hnDFd9e11rlOs9QM16adCKSQefo4SrDEfDNGEJ2RhWNbYF3r1pqgnZAtiNCm91W6yCZ0yZRAqWTgc4TxKQ8CBVyIKuPGHFgPUsug7uJ6VkwlcTIeMsmpFtRRXLJ1iHVjZT373pJIWfOSPqEkYd6433llHEdeCZJglBYoLSESuf8xjlhxJQrCWFjOyxrhHtX6yRgZk55WUxWAmaTJ/tkW4zONb+V7/N49Ir+rtSzj3kelZkQNxfDItWEbkqya8EfSlDVVs3yM7s1JJLWoui5cG3xHsqorNd/z/rT/me9gm274U9AVmX0BpWWuBcaNZ0cSVvsheZxro5Zbzs++zL5nKa8ki7znfznmNXmg947Pomo1r9D7wRJFvqZhRov+qtwAjca20CstwINq2wJ042xA4WM/lspV/z/qNakAmHVSa4KJucRJ1ZK6C0Gesc841TklgsKjQgOCIkJsdQ1F6NFtda7NukvhEphjQt8hrKusUKvAeCMMoWGv13CcFYat8zkiyZLUJKoKqswn56+uzQChEsvqbW9722XiHevdKpwi/Fi+YhSrnJ/Trpqsh/kwZlVBPS1ggvdayRhvheSM2WIPV5jV7Xfd5F5ZasbYM8uwMDZmfB2RVbNCc/391A49SsJKH1E2QFhrfKmZsukz5D/XHvNIf1kL6R5uUiRruhq3Wtetc5bWdsmXyiSVHoypcZ5zsP6npZR0bdW6b13QLPcBoWB943HFHEIy6hyaUZeDcdL9FzKBIkkXZmMXeeU7KnbSQqi1/sorr9xzu2V8XFdmCJac+Fvaq1u6c5OeKv7fOQX83hhUra28937MGFRDNqrra66TtM5KgCVIEpt0/QW66FcCap/MZGtyIImoLt7Mj2WO+Ns4cY6jejaquGBMJZRm1xa6zdJu17Pr3QzGHFq00xVXBaCu6+YuSC8evV4YE0MxKjKj+1TpsUSW7NKNW6u6VuqqwHjHO96xbJ9rpg09jV2jiWuAB1CjsR8g1KeV/qRCkprkZh2SCrSkpmCyKwFetzcFsjmCouCkIKTbHII1AkclW7Rbl665+ZxKvMTDG5fg/SZesm8IyLSPdo5CDxjntOylC7IEMJUN9Ry2H0sYQrhac5MrIbxfeOGFS+uq7tPG0lZSWZGJVlReJGir2T7nEltxHdqI2+T73//+PWKddTZpJ4SduUV45jsKw3lk5tW0otY5spYm48JRBdKjIKuANYGlsFpJ9ktYLV/D+NZ7ACFVl3iuqZXc77HemJt3vetde3HLKkYkeCMlhgRJi7i1cjPmepPYROM007sis2frHimB1tXUBGWM2wUXXLBUUNEmBW/vHa2REgiJCuezPBNjyHdS2WisobU06ZdCf2YtZw0zxrTJ8ZXwaIFM93tJXbr/OvbWPNbjwWzitXaptY91Y5VwqKhJAlXdezOLbpa9sd0mD/LekjDZj3QD1iU368Qa28uxSQ3lXSPDTXT7ps/s0ZZqylh9lB88QyyDRB+YD9bK1L6pB5NEVfC35bwYY8vVsF61bldkLL9JpDIzsJbUzNDM+0xyNwXDfnzecy+Zt6DROAw0cW00toBdC627gNr7JDcjy8gII3ffXY6BwqQCqrFfI2jJkawmMUKwgHgheFYih5BkcpRVmEu8ZDbHTWD5CQQU3Y1HZFxXXaxD1t9E4Mg5tPbjFJhzrIe6zuoiicDC3wiNEG+EHr571VVXrdWHTCBG/2uCHsZH68lUUihdGCXItJGD8ZAESy4QzBAQQa6FtOAoIHPtdJms3gyS1YwZniKrKgsYn8MQ1rZNWFlrrH+E6Ooaau1exgaLIAoN1xTrzPvd8iFpfeLINStBYR5YqygXIPq6mNP+TfcM2puurenizt8mA8vPTbTEWtE9lfcoZHRXZ62xzrVOutfwt6TVhG561kg4JeNpoTSrq5l/s90mPMoyLtajNXOy59HS5Tga4wh5NguzxDkJqq7uuqHaNt16M8Ow9Y6rpTSR9Uk5bE8STttnKRXm2TnOxEPGrmZ2eM/B747C5TRLdJmBOev+Ou+WSjKu03tAV2fuR/ZO9z5DaqauafyzccsJ/jbG3HrTvGe8dDvOg/FjXbOmVWL6jFcBbVmidXOwWHYniWp15a810huNXaOJa6OxBahxPEr3pTnkAyxJzjoktbr7ajnYNUZlaqZg7JuuWHUOEDrQjiOIV403gqI1WVeBsYPYjBIvIZhPxedNafAVjhCEdOPLOVEo5tyQVQRb3baJrWMO14mtNv7UDJBmGU2LCYI2LpMS/bn4JwXSmul6RNhHmXz5vsmRdOk1kRPjYRKdrH3Kb609a0kiXXu1FumymG7QIoXRFCq1UjEGEt0cf9rN9TgOi6wC+m6W6AT9RUBe5RFQYcIt7gHn3ENyxBgTm6kV1hhUrskc8j0/c94cN0sVSUYgYtxXtFWlSB7pXjt1jIiqbrvp7m4CIwmIFiUVKN6XlprhcxKPpWVWN2dJuOTSeEWtlYy7Lrr0UyuZ5Mz6tXe84x33YgI5n9ZkE+ZkoiHGTxdhLasqs1AyMWcQ1OquDcy8XZMSScC07Far4By8l1I56auu3SZVksibCE5XaNuZyfc8TxLeVcniNoEEeyoD7tTfzv/cs9FYU+bahHJaP1H8zZW1YgwknlkjXJnBNakyTUs6JNjnINdjj879SYWHxFYXY8+/rrdU5p6o2adXIbNR65rcaOwSTVwbjS0AEqFmVa2yQrDv62e70iwnSZWornLtFD6I05J6GMktFAzS7W+uXiYP7HT/nWrjVHZUs87O1WDdduIlBR+1+Onel+TThCQIgpaAQYiFdEKaV0F3X+YPoYL4TNYnY6CVJUvFELc6lVxH4VqhS8GXcZ0TgC2xQB9M0IPVsNbt5ZzMtWTVmC8Jq4IQVgTayWFm5FXrkvGt3gS6lkIIzQZcBTv66vXIJgvxWqe8y3EirAqTjDX9ND7XOFQtbNa5BFxPt3TnmjFmDq3rKJHjO96D6crK4X3J5xCtUZKvOSSBMBOvCg4+SzdKlSeuaSAhsRSXhJB1Y/kdx8g4RZOGAZUgrm/JlS663JMQCt2NXdtaNvmdSjAzDWfcqjGDIK1gWnmZL9ro9Z2LWopFeI391uU2QZ1JzczGbR1e3VFV9GixyxjbjG20PmkSVfdpjnViLZ2fSjJXEdF1S8VZJib3h6nnI+dVkaFSQmWILsG1pmu65dImLfasM+4LXeMF46zVWuWSuRoMPXFNmaRMaz/zgXfEqlro9fmQBHVVqTnXAOPgM8zn2EUXXbRss4mimrg2do0mrmsCoZGHumUdEGzYsBoNkMTDh+g6iWFWkVuPKQvn6AE89xBOKFykJfWwSGpaHdOaMoXMiGiCkzloXaxEc90arCPX4v0kXqIdPuQVwiVqSUzMoMkr5/Rv4/XmxsVMrAq0rD1INsJMjb8FrCesllhXFYYs82I2T4Vl4xZrIqAKx8Z4UiBhGoF7w3FR0Hbt0if2Vt3eENoUDjeBpS8QyFkHlg+y1qrkRmuapUkgJLoy810Ohb08tk1muQ8gQK4TM7Uab8q6sJyMY5Z1Z6sFG/JjwiWtpyZbUWhVsGYezFpr7COKB70IJEegunlbWiOzlYJ1SYSu7pbFkYAZ88fnWlMlbtaZ5NV6nloXs6SKsYCsSeOitaxqVdPipQKL79kn1h8HfcPjQdICJP+/9mu/tremjCulP5dccslePLZkNS2w9Ivvp6LAfbuSVPs8qvO9DnTX1bvEMlMQVGsmq0iljekirUXaZ5Axu4y5zwv3oZFV1T1GYulaW0VEt53kZ2RR1cqpIiz/Zj14z+T/GSfGzvCKEbhOza5ewW91DWdM2a8p65Xfl+C6bmkHc56eI+soopOkTpVjS8upChW9gHS7dy/J/cRYb7CLeWs0Kpq4zuAtb3nL4gUveMHiTW9601IIruAB8IAHPGDxfd/3fYv73Oc+c6dqnHIgHGXckG5Zc9CdbR1NqTFVusLpxqaQlRrekebUMiJJVA+TpAofiGb7XFWmRqJqCZRVQNDiXuX8iXVrsObcQLwgEjXxEsK88aUVltRRsFChoVCrFl33SudLIYa+TikpUsDK2EzHlPPSXqyyjEO1MDOWkFUsicb+phCuiyQKulVQuZLlNYCCzwj0WSWF5TAgR7oJcw9BDrSoIlDvh7A6DxA3iCrkOccj3d0Zc+NEGddMmpOoluBMlJKH9+gmB+e0NItkVcLKOuMz4i8zkYr3fsYr6vZd4+9y/SgI6xqsEA9hlwCatEgli0JpusF7f9YEOrXG5egwtk+LjdZCXo1V1aon+VRgt/SGQji/M/GSbTI7rfHQnEevBq1C3MNarQDX5X/GYBsbqnWM+4XzkCQs93l+B+EgsaPzYTuxRKWl2DUjCXW8as3QJKgecxiNMXOIwgeizT3PfJod3dJlCa6hosN6yNX1mN+avRhkfVRdxSV89Ie5NanQrjGydqpsYfyNfTakpJaEo/1m/aVPjAH7YD4rzGEwIqwm1GOd5b5fwfiYJZvr8F3WFPd3LRFlCTHWXT4XRuPp3CRBHeWdUCGU5W18XrkufA64x7jfjAiprvGuC8ariWtj17jO1b3KrgW0p9/zPd+zeNWrXrX8e26IfGB/8zd/8+JFL3rRqS6+jIUJSw4PxClLSuMvYYxRTS8/+mwEHy55rCMEmJTDB7GuboflqjwqU5MJLubanVr6TeJoLWlTrbb0E0FjVQ3WgyRe0kJh/FOWouBcCNbGrioM62qWRCKR8dJpZaqk0HIt3I9YV6vLMQIFRPV2t7vdUljnPLUkzqo1ZbZQ1pBZRxV+Vv3OWD3JoGTCseHg3IyBZHK/hNUsuZAIyXvNhAq0OjEeXDOtXR7pap/JiVY9LkdkdqofuuZq0UqLqATMa0pQ09KhGyzgVYtIJsIxFs9MrZJAk1E5RxIo7j3XiP2RbEmImB/OpSdIHmBEpp1r3SVV7OU481kdP0uDSOT5vwmFIEW6LPs/zmmcu4SPz9JzRauQr1pXJbkSHAmsUEkkueb63HOve93rlvd4kg7aDmF0rx3VP03X+7S21vU0OrTg0m6ex6xlSSrKH65vOy0FlJAQsf7Y6zKHQM6LyjLHOMtFqQjdZi3uunaTiE654vocsxSSx1wCIhNIedAnwzEYk1rWZkRYDf1QITm1j6rggawyhj6rWDuMvfHkKgu4jgq80TPaeUiimnuMXli19qpu8ZkB3L+TpNZ+ONZ6aFnWyBrKP/uzP3sNV3leb3WrWy2e8pSnbDj7jcZ6aOI6IK1YT9GiViHFJDUjjSUbzvnnn7+00p5W8trEdTcwC6aaz4zxrG5U9aEyKvuxLiHdhqvyNsrUZEzcpuOG8HiQGqwJ5gACWF1za+KlmljJa2s1Yg8xkYoxomqks66eQrFueBm7lkRrBJNNYVFknM3y6WHWVISgtKauyiaZiVR0+2Qdzrly/9RP/dRSCMsSFyQy+q7v+q49V2APrs+4sC4UfHXXRQgyI+a61krOByFCcGIdjJKRSLhUPKwbY1chYU9F0jrZOU3q4/iYQEXhWrLEvcsYpFurr2kBk7xwTsmUZVV0+eQczD1khjE1GyjfY40b5+neo2A6GhfjlTm4bgq5o1ctXZlpOONPMzlNZi7VTd2su2av1Z1Za7TWIJMDqZxw3dqGtF6qMPL+kPglkTQRl9lwba/u+pa+gmxIcGgrn9ke1z/tQHgXWk6rK/AUKfUVGEuK1dSM1hBUDtY159Tt2OeHyhDvEa9PO1l7JqFyn9Gan1ZuFYhJVtMdeE4R6PiuQzrz702Ule5LHnNKUUm+R+Y14HfM4Yiwcg9lQiTzEhjqMdqjDTuw3BPn13vHLN0cWeaMtclz5rzzztuLEbXGdLWkGk+sUijJqW6+xqJnrW1j/L1Pc+9yLvTESIKaCuW0qhsX+4xnPGPp4uw9RzubuDZ2iXYVLnjkIx+5uOKKK/YeGl//9V+/eOxjH7u4973vvdzEBBvQW9/61sWLX/zixWte85rlZ5DdRz3qUYtf/uVf3umkNU421Ham1au6oyI8VfBQUYCQUGo5qNbcdaxD+3FVruRWlyzj6uascHNlajYBwhgPfYjbfmuwbpp4iT5yTa2qCue6ommB4b2COIKmghjzZp8lsBn7ZlvnrJ8mm2Hv4WDNWHZCod5MrlyPtkFs51CTqNBe444zQcyoLal557uMo9Yd2klhetuVCZ0k8WZNhcQjtPFdyMEqGCdngqU5sspYIHiu62pe+5iEgrmzVIlHxoUpJGbyI4mplq90I5Q4GYfLHEhiVRyZpVVSKvniOpYI0s1XxRVKFp5V1QqTru/GGNMWy8Ro9VWgZW4lKP52an1mnL3ZgkVNrMQ4sm6ZGxPSeD9xHq4r4dIN3ntNS3ASea1/zoFj5aGg7ZzUtcL3GX/WoFl/GVss9+wL9p3PvIauk6M4VPdkLcjunWbizbI1uV79HnPHHHowP4xTJitiLb3nPe+5hlv1CHpp+Bu+K0m1H6515oT9Q4LCvDD/kjD3rnWI6C7CUJKoTtUJFnoaSFRHyfMYBxQQ1rCeIqysZ541GctZoYJSxRFtxQXYJEvOjy7ZtD/zNqCM8FnjoQJLUsr1aYdzp2dD7j1m286M4V47n+F6YFnfWqutSboyaVO6HBuPTh+81zM0R6VHo7FLNHENkGThV3/1V/esDrhAPPShDx0OHA8T/sfxyle+ckl4uZH5Ped50IMetNOJa5wM8OCoNTbXSVqC0JAPMTM3Hqar8kgAUtjRmlKFVJACjEKPBeVNOrSpddX+QGwOWoN13cRLtBPtOgKIdVUVoBUc1GKzZ5gIJgUKXcSMTZ2yaiUUxrVC8TsEBdxfs/ambpQKuxBlEyONhDqzUaaLH9BCPlIEJCTfFrBHkEJZh3DPb3Md6AKZZWq8nn2UsK5TQqiSVa3cWrmME2b8EfZxn0QgXCfmcs4dcwpp0chXS4G4TkzSQruzLIklUUx0xHcQOhW0FbpdNxIJ3fu0gqzjEs/cfvjDH96r/WnpH92zscCaqIrPMsmSRLFCATbrBjsHKrMcI9rtvan7YybnMsO2wreHSXE4L/+zpqnELxMCSVJNGOTYqiDhfFqibSNt0V2cGMNLL710uZ4ZD8Yqs+janiSr7mPVSiqB1Xqp0K9l2Laz9k3yw7xxsH6r1VHSovV6VOqpKiN97/dNEpQkhjawz+kGK0k1s7AZow+r/FMF/UiL6tzepFI0LapT7V5FWDkYM5QVNeN7uuLyKlE1Hpx1o+dUba+Ej/aRrZwxZs4J5dDTQIuuBNU91T3F+0QvgHTz9TnkulSG0MtAMqyiR4uwz5nqrWXWbRO8GS4xh07O1DgMNHENvPzlL997/8IXvnCStFYY3wp5Bf/1v/7XJq5nEMbyJVFdx5XQ4uWZOGk/xK4iMyTOIS0EI3JrrUuOVS5ZtFtLTSaAMsZtP67KQCvjQWqwZn85F2Qi54f2aPUisQp9tXRLCjiZ+TKtpxJb487WcVM2XikP5wvhB8Ih6UjFgbGgF1xwwfA6umwlSdW1VIsqgtkUMQGWNrGPfFfX5AyXqLHXurgxN2nRkRCixEBYVpM/degKDmFHeNLawW+FBECLxSbrYBVSWEyFRQqUQsurZI1X2o6iwURcjKVZbCWHSWx0/+VI91j+1rXT8jUK5fyNAMyaYw1m/VWzKHPwXm8IyQnnoK2jJEsjaMGx/64P5jProKpM4ZwI5oA1RzsUuvXOSNdFYdZa1pBttuawFnvWgN+RiLLGjb8F7FcSXpV4kmOULXhMUSbK2PBMiuQ8ShBTmZFWxhrba+Zjrsnvtfzjrs36xNWXV/6eUkRa/ieJal1vEk9Jk14bKpVce/7WMCfWC4SFPROCpseEXjBHkbBPMAdJVFd571SL6iqCPUdYWTOMEWNOHeMkjBkvyjUYQ2u4JsGuFln3QctIsYYhqSo1TBKFYnSkIM7s0ypOvFdcfybFyrJU6W2gl4hWdI8qX+hunnHR1i/Wi8D1nZ8Zc+44qlhqNHaJJq4B4lMBsWGPeMQjNhrIhz/84Yt//a//9VJz63kOAwTA/+iP/uje32984xsX97///Q/t+o2/2PTR1m9CUpOoboOkHgQSSB+CSW508zNmFEE0426NLeMBnclTtuGqnBlSQT6sEVCxMOpCp7AsyZoCwiwWFTXmusRmrNeo3WrZM4mMQozCoMdIINWVLN2vRjVyGevLL798edDOtNDrCcL+BDFOlywF01GyFBUPCoRzmZzNqql7L0RIa49JckbE22v6W61Zee51ki5xTQRLas9aGkZIEBhLBM1tkFUT0VRyOlWn1nqcqUTQFVNLuQI459aibNIhCEu6XdoG7ymFdWM5GQcUPsZ8GudOnyVprOEks3yPtYOra86ZWYq1uJgtV0ulVhrvI8lbuuhK3GiPyiz2CvcQLVDuHSZ78Vy6MdZ1xPqBTHv/6Fbs3sgr/+ee15KqW6Kkm+tAQq2pze8hb6wjPtfinDVPbYfr3XE2A7Bz5Pua3E4rrm10XiGFhBnRtrq/m8hH0pUZcF1XEmKVDMZ/ZvZh28x7y3+h4DERXL0/3b91PdYN/ahgVmb3pamyMRma4JhtEqcuYWUt5N5nsjjmR8Vg9aLgO1qiMzkT59FbgDWtEsF2mdBOa7nXZV1adovPdD/Xk0KrpoqUVFBoNXUf1APBQ4Wx97PeTSqmTSSVpcfc1yWpc3APy+dYKpf1NGo0do0mrgEebmw697jHPfY1mPwO4joqnbMLvPe971085znPOZRrNaaRWvcp10yJ6lGT1IOWqbGkRiZrmBIg9uuqzEPUmskJvm+GVB7KIysuSGut7xEOEOYlcMaq8pBHMFQgyTg/+prtU+kgEdG1UpfL0cN9SsMNEBSsj8eeQYILrWMpREjUtNQoiGZsahJg2msCFsvkTMH26d7I+NiGkceAZEHrFu2BZFujknXEeYzR5ry0HcIxJSSb3XREVvO6XAuyCiHe1MI+EkpNAjTVpiSoklQTBhlvqqWDv+m7sccKmMav0m6tzK6rUVIjxou1gJXZuGHnQI8A1z//45lVE6OhbMhMuibrQtkhedH6xrhKmFkr3lO6OmZSOL0vTPxjTC2CuARXkq0CyyRMrmcJroSTtqDMkOAzfqxB5tffGINqlmEFepNNGUvImEneWE9m+vW6o31K65FKuCSFtjWz6XrvM6+saY53v/vdyzWrpZzfMd/f+I3fuEcOGANJiB4auvBmvPgo7t/fpKVL0mfohImC9LQwmQ/jZtZh1up+E5NtA8Z6r0tUJYwS1U0SN00RVuNATdiVbv2uN+NjTeSWCfN8PqqYcl70JNDjiPuK9ZgJkdwXIMkoulXqOKeZeTqv6VrXmsk6s1JAWlczT4J9ArrKZ6jLKpKqtTgTMa2j5OgiJY3DQBPXgELMOjFXI/i7w9A6sTn943/8j5cbL5rAdZKaNHYHHiQ8IJKo7ncdHQYOo0zNpq7KCOoQFwutK1QDBZh1rq1Qp+siAgQCfj7MObe1Go1x5WFtP81sa8KKvC7jgUBoXFgS1DlXKRPYSAoRWi1HYdyh0LqK0Ek8lO7QI+UH7XQuzSg6BTNGKpzr/mu7qnuelgOFYK01/G35CUiOWWqz/VrFRwIP85qW1ZHLcpJVE5fMYSrudM7lUNJWSWoKi1oztEbW+TVDKMi4WubPhD+sSRQnNZunMGZYsqrVTri+FLR1UzfOmrnTVVGCZFkXst3rWmt9TYRnfzNKECf0uNDLQKuPwjD9zvhTYGwoYO5V7HCYlAkiJQGnPSREZC2kZRlI6NJNk+/QfhQ9KIpZP45b1j01SVDGnzo3khbvuaw/aSy6CWuYP9rMWqbdvPK394XZyFN5xLolQ2zGZ2v5HYU8qKQzTt58AJJqlQbsa+wV9F+ySvv4jfsPa5D7hftGa+1RgH4nUZ3bl7ZBVCX2KnTY183yzmH5JxV1WSaLMcowHe+N3LenvFVU5nlfECdtxmnDKFTwMHeZyCr3klSUqCxxLJKgzo1LKpe8d2ub8z7wfWaSV4GS1v25w5jgKeVQo7FtNHENcAMi5L7//e/f12D6uxQ4doXnPe95i3e9612L29zmNouHPexhi2c+85k7v2ZjGpQmOM7IMjW68e2qTM2mQEDIGqwQpKmEMwpyWSfSmBxJuGTKEgcK+grDWjX4jfF9liAwgcZIMEH4R3CFjCSRGZUMyhI0mcBGN2ysQvQ5rdsmeEIo5r7GJXgq2ZSuZfZ5StMt8ZTIaIUw+2TNyJvlcBgTxt7xQRDlegiE6YKaSg8tAowVtQgT9J/fQpSnyKpu4FNktcad5utcRuaMVcv4xXS3o8/WWqzCoX1V6ORgDBGIjT/LsjZm6jVubApZz9b1mTGblvDRLc+6uKwfrbKMI2tdgkkbWJ+MH/3hHrD0RpI7LYfZX0mn7rxJ4FW2mGRISy7nYDzpp1YlP5foQlKZV9rDuSWerIV0bdVNl/XG93U9h6CydiB9Knpq/J1tcr0nSZUoGIue6zeTPdFW4lBZu4xfJvqSnFQPiury7xhCZrk3c50zDpBJiZBu1unxwVxaJ11yoTLO73NN9kZjKLlHaS/PIffPwwZtT9df+z2KjeRVq7AHyDCVdUtieTCmjB37m541zrP7GeOpxTHvfeA+4nrw2VIVTbY/M/tzPa7Nq8oQvW+yvJLwtypGTMjm+lIJMZU0TsVjlrxxT9OCb03mTBpmmzJJX7of72fO9dZx/12lqG40DoomroG73OUuywfpO9/5zqUb7p3vfOe1B/Liiy9eln/gJt7kd/sBbXza0562fP+f/tN/Wsa1NhoJrWkS1ep+mjCWSrJ6GA+e/dZgHSXAMkbQTKUI9JZJkdBIgnVzNrbP+E8EYTXe6f5p/cp0sUvLbXXNksSYvCYTqCCQQSDMomryDMabviIsm22y9jst5FleYQQF63T/VUgeWdYUIOmjMZhaDhUiIQsjYigZNmGU7pvMLVY0rgVJYZ6nXDclqwjeZkbme8yjllAT6+iel7/Pv02SlHUpJSVaLOjblDJEcjuKKTTJD2tFS2MdR8Zvyo05LSqpSOJvyJFzrvs6cyJR18rGdbVccX1j87TU0Qb6xqvu/8awVYu+hE7XW70crOGoBd5EOXopSNS8B/m/45txb5ZX4ZXfM/8QUF2SWSO6ULqeFfL5P9+lfypmnCNJt69ajHTVFd5/ZkflnHXt0x/WHEnObnvb2y6t05YDkUSMLJbG82UpsAwzYBxQLkzdn5JL4xyZV120jSk24ZWu12Znt13ME+uGg31NK2LOc93zM6Y3k1ElARz9XUlnluXxsM01kY/Qim37Jbqj9s39nQmMdNHVZTrXuUo0DuNIVULq6i+pc9x8pnhvOxb213WuAsnfm0BJ5UmWF9LNNhMlJUGtmeZHz2nXsGvNWPE5WFarJv7Tk8nsx1PrYxTWU0N++B6hInr8cW6Ujo3GLtHEtWQH/u///b8vb0aSM73hDW+4RoKRKaBpIzmT7obrZiPeLx7/+McvN8rv/M7vXNzvfvdr4tpYwjg1rXBzZXcQeiSqhxn3tEkN1lobMkmqfbW8h4ktrCenS6zlUXiYIjQoMEkyESzI9KgFhQez5JXfp8Dsg1s3Sc9hoqcKBVCT2CiApsspgjMWHoVPyYiWAQWVOSFFqwG/MTskgoQZKasbuFYpx8estAg1KjvIZDwX/6llT4KebqKSO7K2jghexpFBWLUM0GZLs6xCElTbqRUlY5s5r1mgsw6mArbkxmy9meCrEmTGM8tj+LmEVfLAXKWbcboEMra4xLJua7uM31YRorKjWu0yMYzXZi4ViiVQ/B4BOd1Nq+ApMWKNse6Mt9UarUJDZYiKHr5n/FsmhNFyxN+MlyVFXMNa49ybnA/WLq8oK7T0OncSFcmQiZJy3TufwDmV8Ktk0hIOAUQxhoL5jne845K40gdL72TcsTGK6eGRCZzoF4pkFDO5bmnXBz7wgb2SKZ47rWTuQ97nJqrTU4PPM3OxLunGBnM+xpdDl9e5DLAjMrkJUkE3yrZekbWFtQxLNke5CUbQS0ClknHXPh+4j1SAZP+8tqEq1qflfVoggQoeS7ulIiut+P42YV+YS/d17hmeN+xt6eZbwwwk7iPyrieJz5mpZ8w6yZNy/lQu1DrTuTekd9I6SPf8jnFtHAaauAa+4zu+Y/GMZzxjmewBawEPNTIF87nJRhI8kKn1+vSnP3350GdTutWtbrV49KMfvbMJ+/mf//nFq1/96uVG/GM/9mM7u07j+MNkF5LVOXKjpemoyh4Y0zhVg5X7y9giyzhkLUjJYrqAZTkaS08g0JnpE+HUcjH0X6GQ72YdU8B4cE9BAtI91bIiHggZuliqfc/yOFrI0trFZ55TNz/aBKG2riVtQ2j3OiMXXl1IFaQkWZLbdJvN32a5JV0wjZ2STBhbPIUUgEFa5TNBicl46ANW2qxbqgurrse62VWtf103kgWvbWKVdANNUqql1WtKTLV2KtCN7gEtDfm3ShKJrnOvhZpXhV2zgqYwaBZP+llJvJYZCSf3h+NXvSTor4K/iic+Y3yYXxPHVMFcS7SEI5OTGXuo4F+zdxvH6vWzvJLjzm8dS+bcxDuuWZOj8YyUSJph2Hs14+G5ju687mnGqqalWKWS3hEmhFJZo1KI+5p9wfhaYk9RFDnX7CnsTVPxx0KiqiJN5YLtdL2pQJLcOsYS8FRGOeaZJdg50CorKa11nTncT7RkbnNft71JrOeIiVZFSd6oxm11d81Xibv3u/dK1v42dwGKAtZw3uO63FoPV2VctWaqqPEeUImQ1mQ9D6rFPfdh1gBtN6QhE3Zt4np70ORJklXGKa3+ujlXa+lByaVz5pzYhqkklY3GttHENQfjutddvPSlL1088IEPXG4iPBie9KQnLZ785CcvBWDiR9jMrI+HRjU1vfyP30/VZzsoeMD+03/6T5fvf+RHfmQpNG0LxtTMYc6C19g9Mv5HUjQF1mC6/x5VoigelFhXMyGJgoMZGOmHyVWSfGnlkAzxXiGVtc9D0uQy9BFBD4EFoRThFIHV5BxmewUpyPA7Y+8UQo23nSq4niUAgIKjQjOCPveqbrO6NJqp0oQ9aY2dSo6T18yESrpCZwKQ/K5Jbexflhrhd1q8p4QYCQJId9tK6HTBZP5ScPe7jIFxmgiU/J1JUTxXxp1aPsVyKBJcyaEkwetlUh0zv9bY47xm9llXbl99z3e4x7IOawp+1qCVQIyg9Zs1WgkR18gYcoml97SxoZlgKK1Kzr33t2ta8qOSRrdcBXSF9NF6sZSNwqcWrjyvcaySWNuo8kLFgC7qrFPWmu6+qXwxEY4u7fbfElBpKQT+zt9k3LZzbMkfy8yoZNLzgmsypyqaXesj93Oto2n5SjKuVVdFiQTMebdOdCYNsy9ap9OjI0mAlmSVTYY1uC9V6OLqnJjZthLFVACkC7yfJVHlvd4ndYySKHKogKt7yOjvzOTrnEtSM5aT86k0MiZfF1n+x36iMoo512tF19tMwMRv3KcM1TCLt0o4vUBUCvqs4TD+nbEwOVhm/1VJUrNC1zFQuZVzaRJA42BH3k/pgq/CMpV6qXTJ0nbrzEf9LMtipaXY8VQR5rXf/OY37+Vq2JXs22gkepUV3P3ud1+89rWvXTzqUY9aao99sJB4qSZtSgGITfNlL3vZ4m53u9tiV/gX/+JfLIXqe9/73ovv+Z7v2eq52XQbJ7dMTSZkMIbmKIFAYgKi1CZrZdHayf/TQighkpzQLwUTBQUtQXzXmFD6y8Od+5BxQEBBsTTKZGnsqmSTsTXr8CoocKfVCYGIvcJSHkmkEKRoO/GrXDPduS3vw3nSYitRTBKC4C/BNQmP0Oqie5jWVLMh831cf6sFL60HzokCebpdmr1Wa5MEUusRxCyVKLYHjxWT9AjXQloBMiZNi8cIulmna6oCH++TWOsyXOuTSnAc31qOxsRBSVglzsYiu3ZHZNhzGq9oZlCthCbfYk1ojTOusZ5P1z/mnfWs8kb3U9pSs1Vbq1GlS+4XtlFh3cQsrhuJmvGa/i/Jo9lO0+XVOFfjqDmM/9NCrXVYC2sK3hlXmFZ9x8C58/5XIZdJZfhuJkij7/SPsea+0ytj6h6XjHn/uSZss+tJl13dqiU9ksS891UyaD3N0lO6aPP7qgCw5BGH18wD6NKfZVmqRVNPFq9doRIs5865GoH/SVTXTdpXvTD0WqmW1SRekjsVNXq26LFhX+kTxgRCPXSJzxwIJgzj3qlJltzXXE8qL40/ZtwyY7yJvfCK4bxaw7W4ss9NxaXanpEiVOVm7odpzUxF2lzNc/s0h7yX8p4S7r8ZTmBoxJyVNj0H5hLkNRrbQhPXAe573/su62z9h//wHxYvfOELl8L11I3Lg5GyNE984hN3ms0PrdaLXvSi5eZEQqbDiklsHC42TcKznzI1u2x7ljixNIsPZMuKgFFSCK2TJpTIEgBqvVn3CAIZb8T3LbuCQAlJq/er19d1DFK96iGbMX4eNYukGU6TuFl3EgsPr5wHwYlrjvYRyTnXygRQuiBqiZScK6Qb46fwa9+05GrxmYIadcfH9qUFVDdtk+1oBZFsKJCaJVRrkfGe7J1JChXK1oHtS4Ka8WIphNW1b/Ic+2HJp6l9vFpY55IuVauEB2No7KkZXgX3KFZn5knLj7FtWsdth4IqbSHzrlmxVeSYAduMwunuCxTGPZ+1Z00Ooxul4+haSxfsBG1jXo1d5t7mPjdbMddPi15NOGMbjGO19FONF00FgNZH7h/rBZNcTYsX53DdJbguJMJMzFU5U49MyKWSy/8lsrRIuvG6pqr1n3YQNqRiit/oVZGu/rnW6afeGOuC6xl7zZGu6CqJmC/LEpkYbK68i9Aq7DHntZOKLfcfFTJJTkceLKlEyqzYQKUY60oFpdm2aZOZhJ1DFV+pQMnrZNI9lJxm3k532xFY53ilpVKN8SSW1TFNcu441LjRGkagQiyVjnXtrePamzWbM05/ak+URG/Di06lT7sKNw4LTVwnwGb27/7dv1seZE276KKLlg9rS2jwcCQLMZkIdw02GsgxGxiuy7e//e23fg00iatw17vedSmINrYHH7LHsUzNHHThtXwMD3UOBA0TaKQQrcVUwdbEK36vFlM3M6NJZ1j7uhNnvKjurxIkkHGmZpZUIz/lXq0GP0lqFSC5NkTVMjsIZ7ZfC4cJdqw3OVVfOR/2Cr4mCFHwSYFF4u5hIh7eZ6wz/daCM7Li2qcsI1TLyijs6QKNMG18sQKhro1aJLROGc+pRSgxJRRmWQhdIyVL1SLg/Ep6MovzfmCMLQoPzuP6ZE1ZDxOBOUlqFSxVSqiMsZ+017hp14Juw0nmU8DWwk573AtMoqTVTzdv3aUzoUwSP+87BHSeV2YETkuvZC09NGi3FieTSVl/lHblumSMdNtnzl0b7gFJ7GqGVqEyg3Ph+WNYDu8liLSDfuuSznetUcragdTifUFfdXlOa5VW4yzXwnu/I6l3TXjo1un8S7j5va68HHrDuMeZAVirJm3W3dOQD35PP/ielkTbVtfoKtA+xkAPHee2Hia3cq/S5d1z6KlhuS8JZbrDu/dnfgXX8BQ5zbXl/u6a4HdJKnnPOdlv/I1Z492nWIcJ93YzaFeX9CwtZR6D3E9qkiTH3D0//6cnDW346Ec/uvfbmuSo7km6rbvXqTiaaoN9z30n3XZtJ++9vvfeQQhpDaWo1/fV91keqg0qjcNAE9c1ADk9DII6hR/+4R9euj2i3fs3/+bf7OQaCGircFSFzE8TjnuZmhF03bLepNYiHuojTT9QQ47ArGunD1xJTsZy5e/oK4KBWXYhxPlAV0DkYamAXwuu+/upMatEMAW4hNZViKoZUmlLugRm8iOJwUgBYSyZfdCVTaKawrxZkT1vWtYVVHRRnlo/nMNyJMav6cJqrKPtyiQfCpa0x6zNuqPyG2ud2hYUe6nhT8FKGBOZbswKcLUkhRYa4ym3gYyPVODSjZA2QJScH9qGtVyr5Qi0lXGBTNWMvxy6xvJ/Qky0PKWLtetYN1FLo/Ab14RxhioijEtOd1rJm4lhaDvCea59ySrrxRhJLWrpDs3a4Pq/9Vu/tZfhWdLna1oxAWPo2siSNVphJaspUEtUaSftxTqJ95LrkP5yPciyZXk4N/c0ihTaq8WLuRu5t0o8JYPVQmtSrUz+ZTZvlXLCvYF20WYVaxmX7TW1vtVyOCo2dEf1/nFf3QZsu8nATGRXE7axn7n2GE9Ir67X/l6CLdn3vXOxilBn5me9JoC5ALzfTKrFGDDfacF33FVoaVl1rCXKzIEKSq3Wrm+fBa7XkXJA5DmNz9aSnIrQVQRNL5r0GEnFncTWBIMqUCok5NVKe1BkrHYmY6vvp/qZ5XAyU7hxwo3GLtHE9ZgDwvrMZz5z+f75z3/+NTKhNk5XmRoeEjx4j6JMjdDd0aQzErXMdKhAw/fUrqtNps0IosR00pd0CZxSfOgSiHBhn82ym5r+TEyicKhAJuFAo65AKIzf9JAozIHzWrbHbKiSBl1eJRRap0ZIMqylQrKabmyMTRah51WlBdfRwoHVbi7OWQHPuFm+zx5incEqwDJnjL0ZOG2z7sBaYSTiSWq93nve8569mGPdRTnnbW5zmz0LA+Ntxst0z6xW2U1RY1mry5xHWihYU7oXpjDJGED85ggr44ACg99nBmHvA4VzMtOriNAKrdt1lpDhb8ki52UcU6BPguSacz2bQdU4zhrHKCFQqcPvEOrpI59xf5FkUJd396ZaPgUoWGeCsKxfmsmyJCx6VegZwb1JW7GkQv5UxJhIyGRHjIfWaS2ZKrpUhmGV5Tw5f1NENZN9jTLWOm7GX1ZiYA1b26jSwftfl9V0Ba17vERbd91twftURUdelzHzmpaPylhl20F7sRyiYEnrdMYuziFd513bmdHXrLkmCLO97ke68zum6UmkkksylYpOY73r54416yvj62vpl5ptV6WSHhR6D6hgmlOEJjlX8ZJE0HFKuB8al7uN+NBVrvEZN7sJMsY2a+jyt4or0MaNxmGgiesxB3G2bA5opNncXv7yl1/rO+973/v23v/6r//6njvvN33TNzXRPQKclDI1PnQkZpaamSLWWm10c1No03KC9YO/FT6TlGS/tCSPBDmuzfrVHZJr8Z62KRQk+K2k12QbGZdqmYJ1oHUVTTtHWidNKGR8G/3VTTl/X7NZZimdLHEj0batOZb00VhnrF5zrnd81/VDWxgrhFCzDtcYV8mmxFghi7+NxTWujHWhgK8gxhrQVTldDBUcU3hUaJ1b/1OQpK0ipOvGdVfCmpCwWh7IezYP5o91yTkqsVEgVOlT63Man8wY6xJobKjWMC2UuqNqPdKN1cRrJvuS9FUXew7Op/uzVn3rfdIHSKEWtbTe1vGSPGfSFqCgne6QWphoD+2DSEMysYaS4VsrKf3Rwud9yT3HOqd9tM0axELrPue17+5VQJIlMaskNbOt6kbPeRhz7/esK6tFUYuksckZPwj4jmtFxZz7E2sKt2UT/cwpQ6YwUlqa4C5d9t1P8xoSGO91PRtUFnEf6P6ttXyqvI33PnA9un/nnqWCin1TDxVeaWfWw1XBpYdK3R/0FEEByquZgiW9leC5ftOTwzlJl/Vcq5mozTWiCzL3TsaSc05zFWQ2ZROE6a3j3m8sac32u985n1PSpSeJr/uFzy2fd5n5WcWCCmrDRFSoScL13Gg0dokmrgVPfepTlzcjmyZlcNYFNVXZqNnkqOu6LShkkXDmEY94xMrv/9AP/dDee7T+baHdPY57mRoJlARVS+pcO4UPecDDCSuHiV0UVFljuhlOlQYxYY/CTiUcPNyxALHOEUhpqy7Ias99qBsbZhxZklTjZzeB1lUEZok8rz6wjS2G3CiE+pDXdVJIcrLUgePIWElWk4zoski/ESTXiXN2DphPyMh73/vevVqjFRnThsCuZds4XkmZRN14Tz0AFEx0WdaSxvWM1V034dJUYqP697YUOIwH/bHEUQqUlkmhb6y7kYDJXCh859hKNGmnro+ZDKqSPq4v0bKvaXlWOcF4kyVVK7gEwayntcyJQrmJpbTcZvIk10UqVRJaJTM7bZZIyVhAlSG6TNImFFZYQDO7aiYLA8ah0g/HTG8GlSW6y/K9LBFC/72vjbnVDdYxz3qo7k2WMKFNEk++z2/Za8zgmjHC/O19PsrEm2VAjLXlSNdT5pZzkOTxoOtYC6BHKrFGmeMlFe7Z9BVruhb/tLryXci1YQAZrpAx/8bts/fzfcbGkA9jalE8GP9fa9RWJWPW1FYR6DMRRQfeOsYbs365d1gn1VLK+GdeAhPT1eea90vW0NX7IceZ9UebaY/eDsiBrFmTJ9H2JKZm155CtSCvyvY72g+zBNSm8Bk1ijFPy7evKgYydt4jk/al944Zz+1Lo7FrNHENYK181rOetdwgnv3sZ280kPzmuc997vL17//9v78sWdM4G2BTv/LKK4f/O+wyNVlbU/Kn1XAV1DJrJaDdPJxrPJAPauMmp87N7yWrKQTqaii5Q9hBkMw4Kr6jJVfhj/MgSOjOqUVqP0jrKsIRbUBAMsmIMXgILVqPEFp44CvgSwCyzEMKllozk1RLOnnAW2eTa09Ba4qld8z+i/tvJoeq0F3OhCRmN3W87D8kwEQoCCAK71qO+J6CpfFMWd8xraxaeSTKzNXIQrALVEsbbZTE6cbpfDEXkpmpZDJaRVMgs4SLsV9aWBXUGRstE+kuatIZ1hDQNZjvpMUcoZ12OX7Mn9nCJWipGKKPEG4OrVvc9/YzlSpJPtPSaoZqE6xkHLYkQUGf9YPnD8QSl18sqZBWQwLMCJ6gX3zfBGusM/YlM46rLJFYa4XT3RToIs93M4FYkjBgqR0PlQN6fyi8azmTAHFd96kaZmB2Y66joM5vq8LRsj8c/D/vtU3gOvKo1shc5463pIa+aGV3jFZZv+gHc3Tuuedeowaq/U0rNGuM51xaTzOr+NT5LcuTZb9UJDgXJttSicS+7LpIqEybUoACrYYqHl0nXktSbty4Vlbby5iyZ6KIyXne1HskEytNkdEpJV2SR12Yk3hWIjr3Wd4vqShbxzJaa+6qsMs9JkMLDBdoNHaJJq6BV77ylctXNsNHP/rRGw0k33/KU56yvGlf8YpXbI24/tRP/dTymMO//bf/dpn9GLzxjW9c3P/+99/KtRvrQUFF97bDKFOjQGlWX119a+zkFCRmCAsckjPLY2gNMSOo5My4qZH7refUQqoQy4PSOJjMmMt1IG0IpSb9AIwlhFWLE1p+tP3bSPrANRCKsBDoLqf7pwINY5G1/LSc6T6YZQ+yTixjZ8kGXZTTjVfrCa68q+JUFWhol1amJPUjGEcIsa/JeQTXZV5NAKQFXpKjO7Aunca3Qur5v/0Z1XfMpCW0hXZsCxK3qUMCr+UfElcJqeuqKo/sN3OkMsE6oKwH1qulZywlkklwMl5S67O1So3b9LyWU2FNS264Xyz1okU+65HaL+aNdYsnjZl+cx0pULpeU0mhcGkM8kiRoLufGXBRPOgmyVyqfGKNQ3T42/h3lRaAa3AP0Se+Q9+JpVUxwprjnteCqPule48JafhNzXCqdQ1I2iSqxlE7n9yb3OtYAlUueD69NnQ/NuY4FU1apVhP6TkhVEZwz+3HHd75TaIqOR7F5Ko0SbLj+K8qe6XyhH4xn+797lOuHdc1c8R6ZeycqyQwqaxMZYFeJewdKGG0sOY+w8Gzythn2sG1UF5O7W/5TM2YUV1THSMty3lfaFWXePlb3psdmnboSm6SsDlkzG31FMmauyOiyVo08dwU8dyU/EnWK0ldl6B6DsdJ63QmWXPf8G/dlLlfGHfDOzqzcGPXaOIaePvb3758vd3tbrd86G4CHl6UqaH+69ve9rbtzlLj2IOHHZv+tsvU+KCTLJmBMsuYzCFd+nStRahI11vBwwfhwSyyEiWuo7titTRYRkL3U0mucWo1Wy7gYYrgrQsbYMwQdCCotNGyBbrlHgRmJ0XgN84vrZUSbuM+tbxIMmhvuv8qCPg7hWmtC8aOKhhxzbk41UyYwbmZa4Q8hdkkx8L4O8YMgrFK2KKvjAHzwvm0xqcgz3tjFGmPrt/WMU2SQ1+tO0kbprJ07sdaOjpWCV9zhJX5YIwsa5OJaSQJzBFESYLDPBuHqpXI+9A1rXUmy0Nwr3lOrZmsZRUe2Q9jQFnvOXf2BWLqeuW+9LoSU91nU+B1PGvMYrojJqG1xqvrCAsq7TU21t9K+rG4ZrbfBOfhucn3HFNdpA1V0OWTMZM02V7dkkfr3e+rYDPWld+7diWq7C1Y7SzNlRm0DdWQqJoFnDbRfhWB/M5kO7n/8JmKPhUgm+z3upVD1LjOKJ4616+EQULk+huNj+tPMp97mR4f3sPGKZs/oNZddZ1KpLXAmpRLJYjeB7p06w7Os4bPmQ8Jq5Cw0h7ONVLkmavAeGnnWSuvSiPJ/qpsu+7NehYYI02bJYquLfqUSp5MluY8uGYdk7z/domM554iqNlOY5v9zLXsvuW86v7rM8B7TbgGsu6395XKuqlQhEZj22jiGrjqqquWNx7EdT+48MILF5dccsnyPI2zBesN7hdqu3XL08pjbc5qMRhBgUUtdgpYc+SPB7jWx5r0g3NgHUprSibmsFSOCV/miDT9QEjhOsaiSfyw6CAw65p7UJdSLYtcTzKe5Ye0bGpVMwmIhCatw5k5ORMqKfgqCANLrEzFPSkA6FKb1kQ18SMXQUvVcH1IKmOlq+4cdJllLCSsWv4yAQ99YAxoC4RNF2E+y9hiE1NtkmxmXWvpfmGGa2AWZq3frCsTu6joUdjlb+bKhEreB5ItxkBXOV3gzJzqupV8ee9Z11BLfSa5Uhjnt8TxMY4mY2KOuK5k1YQ5GcMpUbaOrZ+nu3Yia1lKMjggF6wfXnGH5J7To8BarSbI0c2Teef/tM89yHbwXdYD10E59I53vGNPkWEMpEKx4+Ta5G+9UtKN0vqbKkeql4f7jvH6tEuFm2tV12yJdyYwSiFbazjW7Eo+Mls5a4kxy9jdVWD+uZ+Mm/ferpYwSVAlSloo0zKdyhfzDNAv3V+traxSg7FnjRsbbPK1zDAuEcsarfkccB2h3JAA62GQVjbjuXEp5vySILNMu4/pEg3MkaCXQLoB8x32by296YHgHua9mV4FKh1UCjrfKk9y7+N+pF819MT7/6D70zpIcun8Z73nPPyeCd+SqGbGZZVBIN3/JdsqlKrFV0Wd96vx6lxDbyld44HPMj1N2uLa2DWauAbMgjqqCbcOTCigENVojCBJSQsOwlcS11q2JGHdxiSp1uvcJDkRQipKFl1105KIBYbzei2tG5zbhDUIFKu0qyaQ4RoINJwb4mU/eI/b4ciFc1Po1ocAyuGDOTM7K/wZd6xQbLkGXc2AVi3G2ERG1gZUsOK7nJ/+jaCgkAKJGn0tuQqJWVdVqy3Xd36zXNAqcF7IkHGBaT1Mt2AT/vB9LOCcn7lPkqC1zfUw1U/jOjk/a4ts5+tYS+dgPGE9aDvjznW0fCchYNxoj+6mmdjF+XJ8aibbzFisgMjYuw4kBxLJGvPo/GjRRvGjMM44Mj4QrXe9611LxQpzU9eL7p+OqZ+bGCnL0yQkFCaS4doc3Gd6XVSlEOd0/3GutcxyLj6HiKRFkFeT9vAeC6dJoPS6kCBlsifA71hjJqdzPnU598g1yP1pkiwVSiZ1qpZfwLhAMuk7hNOkVoLzMOfMg4oJ2phJnoxH954z2RX/kyTyPvMISDJp00//9E8v32f5kXQDNr5WoqXiY2q9SxaSoEoKtTgzJqx522RGX2Nicz1JUky443rzvJJU17kE2SzF9se5cD4sYeSzwrJaykfp+ux4awkFjLHEuiYHyvfOk6EZxvHrdp5lYPg+zx+urXzHb1FIHETp7L7uvTj39+gzxyOzkFdPqsxmXKG3QI6Pc+szJuvw6rVRXZJVHDG/7PNa6lX06QUx8rjye9Wq22jsCk1cA9yAaiT3A3+3bvmNxulGuhdWopoPqimSqoZaksrDxIdKpuFfF1oXEJYVNBM8uHTzyoe/CSxWuUJlKRpd/rTkWuLDfuGSeNvb3nbP2rMfqLWXwCDwmCwnyaDCmEIoAq2JeRRgHX++Z2ynlgVJrsletAKMyjJIOlLgSIu3JEFSDVQMaCnRrc0yP6virRIm/kn3TF5dYwq/lg9SmIGAmBgo1wJHvb5CsgKR1q7EXNKuxEhIz4Px0xrl2GLVg2TbL+fYe4T28f8kfta0NaZaUpX1V43xVmHBnOg+yFxoXXWMam3ELIvD+OAGzLhY95Wx0pqdkOhVgpEZQCWrdS70XKBtWE9JmMR1mTfW0JzigPHVZdRSJlp/s+Zuwhq9CPwqO/wOc6FF3/PTDi02rK/0plBQrkTV8cBCKVFVqSMhrhm0TTDF9RgHE4MlMqbbNhuX6VhKymije7XrOGvi5vq/+OKLl/tPukkyZ6xTx1AiwfiZeMuM6BkTn/GblaDyyu9NwGfZLnMceD/kmh8ly8ms1BlyULPXmgjJ/S/JahJKXXidK/dklaFaPG2HSrMswzVy9U0FjcokPV5cM+soahmf3OP5vt4YWhLXIZ6jv9eFsaOumxFBnYPKhZzXLPEjYU0S7H5S48T1evD+ywSKfFcPFtaUc+Cz0ERahogwFw95yEP2FH2NxmGgiWsAgRah8qKLLtrXYPq7TeNjDwqSM3E0jgZqnX0weRiDUuuhjR7QtRaj1hGJ4KYkVfCAQ4jgIYSrGA/wKoyagVahclW2YJGlCDj4bdaFRQDOeCyug4skLvX7qWtoyRjLDumGaFIqNf9mEFXQMQmJ8T6OR5ZoUIBUkFNQ45o8yNHWV5exVEwowClUpWXSeEFd7xREJYUKkQoQksp1wXpi3Gmj19I6ZeIc15UuewgmjI0kPmPPagy06zs19xlDOVX3d8pamlYkr5GlYRSAPSxdwZwhqEtWva4WUa6nsKwlKRPMeC6FZK1quhXyHssk5WhQrHA/aGEYxV0KrfC0jWzPWLwkyKwLa0s6lrrYGi+Y95kCaCWrWua0jCA03uY2t1nmVeCeoq1mOda7IM9rPUnH3YRJuv75nbxOQmUH//cek7Az5t6DjAPtkeTohq8rsYQjrXbOOfuFQn3CurQmzUqXU2PsmbcaK+y8SexG+5n3nQpB+60rMufnupbtURmkhdrvZhZYhX/uwSwpozUw722JsdZuExAZe8t5WEv0n2tKUGsCoilIOrIOc9YW9T4wlwLn1b3XsXS/HLk3a2WVxJrUh3uRNeo4mtnbNgETCUpgOdL92PlVucD30tNglTWTc3Pv8zu8elw3KHYOGtozhRzHfB0l70rFVCWdaTnN7OQVWvCz7qpjbOZ33e9dC1kTWrkiS+Pwfe6n9BTwPja7fqNxlGjiGrj73e++dIniePe73734uq/7urUH8p3vfOfiiiuuWG6Om/yucTqAwDoq3F1Jqi5xeWRdTbXvB9FeGtPkoZVB7buE2qQ7WbOQ/48sNGYPtI3G8Jn1FquSQrOlDICZaHHZo9bjJnWFJUwSVeNTabuucFzPEhs+4CV/CjJajfl9au11H7QkhG1L1+1sSyYnQcgwDq/G5GrZRug0EzHfYwxS+NBVd660wxzokwmXJGlavDKm0vgj5575xiJlmyXR9iPbL1GdE5K1+mVWTc5/5zvf+RpjYtKjtKRJiBWma0yZygrjUBPGHpoIi3OYvMx6tLqJe07ap/UdwZr1f/755y9JIG1WiNMFdURYJZ8SCazvl1122bUSVOlarvJIwbRaMlN4dV2oCDKTLsI2bcRLAcUPc+b9bQIw3Yl15ZVo5JrXwyCvr3JJ4RZImjOeWYsP7dHSLoHV/dfEUSbq4bNMWGbGYImu90iFLt30T48J9ymtRfytZTlBO93zRrHm7km63zsGJpyqmdm5vrHruZ60mKkg0urOnHFu1pXzKwk1rrcmZDNcI106tZ4mMpbRuM10NU7S6R5tG71/cn831lMXZC2Y9nmEJKx6Q/jcy/hu/scra0hlhu6rILPvcn29YSBNWM2rNXRd6BZsPLYEnLXIHryfMkWjMUhymt5T6Y49dWgN9RmqAq9m+h4pkTJe3wzwPkucQ/di1oIeIypwTcqkbKDiwcRlgjmRrI5qGjcaR4UmrgFcHn7mZ35m+f5xj3vc4n/8j/+xVtwdDzq+n+dpnB3w4MH9NoVcBWTdfLV2ZbkFj4M+SFO4l8whHOgilXX9LHNCdtCpWO4sO2F7q7aXc5roQlc4E5AYY2gin0003BIwjxS2tK5q4TELpjFnCjpqq9Xg55hbZ1Grj25unLvGGuoqqMZcoYw+Va2zFj4FFv6PEFbd2BwXren7AddhXs2gazZd515X46zZaTZUszQjpJhhmnHT9VCr0hxRVcCRkED4LJ0gOaN9ZGmXnBpbtW68q2ua3+uyqDcAc0C7mUf6TTxzxvIp/Es+XAP0H4EYIRqXWt4jzOp+CgGdqumKNVCXdBORmVCtJjihjcaGauGtNSAdKxUb1nNlfRiXqneCpWfoF9dHQWr/Ml5SAdj1bikS+4DHhUTOsj58X5dVlQ+uUe4NrYvOoUox2m1SNQVtfkdWcKzVhhvoQiopTAvvaM4ld4yPY6HVW8JpXHoK9Na4RRAfZd0F/JZ26SJtDWWtgc6Ha1jlB+fk+5mkzHhcSBZ7v6Rc5WC6xqo8UyGUJDUTwK1zf6iEkpzqQmwiJi35rjnjiyXVlSg67xLhvE6SZC14Wubcu+gH/2cNMb7+RiLlOkhkjL/JvfIZyPx/6EMf2lvDo3NMgbaxzvNZTP94Bu3Hy8fkVllj3L2mktO0jvrbtG7n+lE5tQo5B66NnLdUluiCbWy2Xg7CZ6il80aeMqOs2VNQUZZhHLSFPaDR2CWuc3Xnrt4DDx402mYFvutd77r4L//lvywtRVNAiHjMYx6zTLTBxoGbGZ9tQ6t33ICgh+sNwgTCYuMv8Ru/8RvLjVuiaixhJarbWhc88NPiIlmzjAYCvaTONmhhSiFAQdfv6M42Ag86HnoIc2rj2T54CBrjlaVxEGq55lwMktp7iWp157MGLMTBuB0F7izJoGbdsj1aVBXKdP/lwe41tSRmRmddvo2ZzFISVbDTkitpGM0tvzGOSKF5v6B9jIP1MBl3hGCFENqqQKjyoQp+ukXq4mlSFa1CKXz7meOne6ZWM4+XvvSly30hAWlfR4Enic4MqcYSKqxJJhTiXBOsdR9fZu+1L1k+BaEVRQ2vEA1JoPdOPgKtWcs9ZNw0bck4Pfuv9S3JijHKkghjzGr2U60hEj3IP/cLbbRshzGjkqepWHgtnt6/Sejoj6WfVD55/2CtTuFUK5mKIevWSnLTY0EFEL+n3ZBs7nVj+LSmrqpvqsDtWFUSM/IIEFrYrRFdYXylyixDCWqWVpU0uafqLaM10+tmGR9AH3/lV35lOUeOIf2hvcgP3iOpxFglcrmWJCJZxkhCmbGruuimZ0FaZLXK+jzSTdtza6XTXVdFq8pWrse4QQi5J1wb7jnua2YENvTCa2Ymdj0Jsq+uN46p9WIiQs9dwRjgdcD+KFzjrM+RxTaVFcxNklPXb9Z+nZorz+P33Ccy/j3hsyMVChy6lDOWJrcyc/gqJSKHCRRr+/QWyBJw9RyS1eq9kORUBbjvp4jvHe5wh8n2NhrbQFtcy4byohe9aPGgBz1oecNCRimN88AHPnDxgAc8YCn8cGOzEZB44dd//dcXb3jDG66RjZXfn0bS2pgHCgseXmlJPWhJl4TaegUr45yMseQzhAreSzCM0bOsicQghYhVpXKA8VoIifkQ1e3QMgkKK5AWhIXRfZDlJ7Q4VEGOa5jpVbdcXdeydpwaZ8g41zNpla5vxqnqcsz4KGRkLLJCqoKd5Cbbr4XC9mU8URWKUoDTCnEQME6QKcaM9iOEQBSN06Wt9AmhLWOYJCUmIqKdnEeL6ihxCzBxisKopYUUWOpv5mrUVuVIrj3JluVaIIuWvqCfkmpjCKsQpwuu5W3oO/eh6501YV1S4zrNIgs4L+PBwXg6xpJoiZzukFqxRjFrWit1cZX0KMRyQGZoDyQPwoqwqDXc3zO3EIQ50idBdgwlUnkAE0Gxnk1MxFxxf6rksD60luMcXxOR0X+zzDp3rC+Jr+76jOGquEuVQcYg6pbLWKXCjDFJjwDB+OoOrkeGBFS38xTOp0hiZtPNfUCy4b3uPKq8UvHl/3Sl1E3U9ugFkf02+c0oWVImYPK7NVGS19QKaAIk135NxpQlU7zPJEySpmrp1CtHQkYfdAnX9VcPFy2Yuj+bdd5z6MJvO6sVt/7NWBqjb9kg7yHdy1UkqMigDWZSzkRtfId1T7tof+77NXZ+5JJdYWywBDWfmfZdhXUelZzq/aFbt15CtMN+z8XT6y2UyalGMCTDe350HkvmWZ7IDPmryOkc0vOj0dgV2uI6wMtf/vLFd3/3d+9puOduQh8SbFwvfvGLF4985CMXpxVtcT1cKARrWTPmLsvlaOFQmPVByAMeCwgCshbQTcg0DyDICoJLtYLqRse5MpGQNV+r1pffa1FVEK7QMmTGXc5pG3SBzXqMkBNrvyoUZOkKNeijpFmZJMRxyXIZXsekWBmXN0XSjFW2vEzdM9KCqYA59d5DV2/j3RgLMwZLKvncWpMSZV0hFcJXwe/pVqgFZ536hYzVa17zmmXbUkDDvfUHfuAH9qyHdTwkLaxdyCpkTaHNNQC0YAJdcBkbrWJaGrQqq0SBINInhTHmDcWFdVI59BLIRFHp/leJ/Yi46/aXBIPxs3QI9wQCNPcFY6Hg6zpm3WTyrimiZZZnhHVLR6VVLMdVjwvaoWsg19TbQhLLWDvnCdcb14TkqgSRxCmgr7Kmeh9JnGgr82qm69H3M25VcmkpHL0LFLLNouteKJmva75av1WCaP3MWFPvU/dTE5Xp0eJ94X7AQUgR6zFjT+nHPe95z2vFomY9WePbM1P1FFS+uafZ7uoCLKFUYSYxk1hLTjORVMZoSuz0Nqh7vxZUSzvxjLF0SpLjbSCzxvvcyEMLud4x7oncI9Ydri7gWfc458XXTI5m3GfGi2b25ySn9R7KmOM8VG6plOOYqvmdma51/53Losy60AOh3pvuZypFrG0t2d8UKtvSOu/R2YUbu0ZbXAd4+MMfvnQPfsITnrD4zd/8zZWuPfe+970Xz3ve8xZ3uctddjVPjTMCBAeEBqw/CHgKE6MSGpI53XGNk4Os4nK4aUIF3X4lixUKfHwPwih4sKLU0Erhg1myOhJwrXWY2VW1bJmZmM8lpAj/XIdXBCYtiyY18poSvUya4dil27SCdApjfm6NUEuZKMTUwzg3rZN8D2LJbyoZ3SS2kzmwZAfjI2GVTFiqw+zTCI5cX6uTFrKRAKHLrQliFLiqFUS39vq5SV8cL+YBawceKAmER7OrmxjLeD5LZkCwsNJJVCUFkj7nyEzItIHf0o5b3/rW17DEGWtrXVES7CVJZfxUOihoWv9ScjQF4521ODlmWmUtK6HLpcQkM1U75hAaS0VpxRZ6Cmjx5btJDuag9djES1oljc3mvJYQSvJZ9xM+h2RL1iTV/E+liPtAhbHVuTZAxmCne6sWLK2wWn5YTyocTNCUsXSSTktVZfZn26xCx3VuzK4J1jLDruekHRBVyXomiDIhnDG0SWq0Oqfygv5j/c9Y8OrFUZHtdW1lCAPXYy3Uc2wSN6/nijkCLB+mldiwDL7nGmDOaL+hH4ZigHSBz9ALLY3pFptZf/1dKommEhmpMDFUxPGQtPp7rbb0zfEbjXG1Xqu8yVIxqQROcpvXUlEgmc3SRdlnFcysnVHW7No+10sqYqeQicgy7j0TtOV9qQJkKg58FTlVQdDktHGUaIvrGtmCf/mXf3mZaERrBxsKgvs97nGPxdd//dcvY1nOAtriun3wYEHAZm1BWHUHrVBbr2Cme5kPWEt5IFRs+lDRomHsZAUPYq+b4EGGkIvAxEMz3X8rtFIoqEsYzBZs7KyCtYmdjGnScmV8pokmsuyLLpxaVbR8eSRRVZhXQ5wWFF0mK9lUIFUY3aYruC6QzIFjDRGhfwrpwD4x37RB65KCq/0x1jWJqvF567Q711ceo7X1Iz/yI8u6wEAXQ9YFXisZ46d3ANZVSyUlmaRPZqFNdzrJxcjarasbawfCY83UTEJUrSzrKBEUcBUEFVo5l3VMs9avllsFRMdcQmacKO3yf7U8kDHaZpleZ544L2PJoSs05JXx0r1dYqILrIJwtkPCJLFTSeK6qm3JGp8qMlyLjC9rWSKtQiLjSi3BlR4bJuRizau0U/jOdamrsvuSh/3w/qR/3M/ubbqGQjwUyrWqmnAt65Bq3dSyK2Gsyh6U23xHoZ428Kz8R//oH12j3TnOddy1VNJXSWWtVZtjr4fFXNw8/bT9vlaFgx4OeD2496SVkXFBSSRhrsnAEpWM1qNmz67lbGppG+fVjO6uTRQwymKWjlGB6D2uki0tseldkOO+KpTDWF3vU58b6WlR78nMAVC9NLLklEpCLao+V1JpmO+dU2QFY/qT4Oe96Tnn+ue+kxbTJqeN4462uK7A3e52t+XRaBwUal6tuYlQh4A3JUgrCCs48sDygSyBQPCS0G0SV6IrKkLdSPtqjBlt4wGZhFZ3LB5y/I+smjW2LR/eae3kc4RrLaoSRf9P/J81OSXj9I320tbLL798r4arQksKOKkxV7hIty3jsLQu1wy0FZmBuCa+mYNCUloZ6t9mNGYeGAtrUiJEsjZoI4KjsZW0nbEwgZY1H1kbWpnojyTKTLpzBEiXyHqs42Ksy2bGompp5prMlfHXuh8y7xnXaZ1drKWZSIp2aeFKC4VKDi2BZkIG6UbomtPyI6butXQdtG9clzFEaGdMJNa6EwKtfrpJ6jKugkDSpnW+zgW/4/tZjmkd0A/uBxQGxue6lyjES/ySTKsQSMWGWZGzTSoQskxHzWbqujT5S7qYjpQM/Mb6kbaBeVRpxzlUbOmGmWReod7kW8B7XWsq5+M8JFiUiLkn0HfXl/cOc2ZsodmpTc6jskLlj4nEOFSscdB+xj8TKEGGKV8kQZrbm1UcuheO4H6oh0UlI2lJyxjOEXSxzfvL2sCSM1zt8TqjfxlHrNutnjJaQN2PR0mvpqDFO5EKjiR4knrmRjdlQ1WMc2W+DQUxxEsS6P3rferzIhOmObepXHCvHikyc+xr7OycciyTNqYV3oR7mYXcQ4utnikjZH4DvS6YZ597WfvY+2FEkC31k3ui/feof/uZ7v6Nxi7RxLXR2AIQXnz4KSwbEyVZVcgekSQftDyEcVXDosMDiAc1DyDLT/hdHj64blnSZtWD1VdjzEaEmeub2Ib/IRAr/JjYwgcg5KrGZ6ZW3yy/fB+iyfggnPH/FIAU/I3/kXzyGWP33ve+dy8BiYJQtluhxPgjz5WuXn6fc+iulXUNE7pRKtgqLCcRTfKpcFVJ6dw8AIV83ScZGyyGfKbbphY+iYSul2bB1HopKc8+A62cohL4JPLOsUJtQsGpZpZ0/BD4LYOkVcXaxlrvtFgh0KvZR/gk4R2u7Yyd1+ZcCqGMC1ZUk4PpSjyKCVbonIqzyuy/eTg3xo8q8NomrY+6suoRYHIY32vRtxwJqAqAJG8qHTYBY8I6+eAHP7gcd8cEeA/pJmt8pq7WWvJRilQiRZ8kAZm4R0u9CXLS3dcxZU9B4B65QGZW7bTosh/4myzP5LhrFXXcDYXwHshkMvRHTw/WsNZN9lD7bjsQqhXs+S1jKekxVlaLYrrHsw8wnrrK6r3Audiv01UYGG87gm61kscpIpIWb8tY+XvdZSVLo3CSkYuwFmcTWdkPn130hfuR9ygYGZ9VyIRgiSwHk4mNVJq4p/sM4Xu6S+c9bHy6ibfcF03mxBgy1ig5mS9d+6v3kC7hKqPMsu++uU6csXuN82dmcj6zFI0uufbVzM2Ok6EChsXoCeCalgjaD8lqJvbyvec2o7AxtFl6x+dAJZogCajnHcHnXyoT0ovF/9EWEpk2GrtEE9cNwQZCtmE2dTYKNJN3vvOddzM7jRODt7zlLXvCj8JZCu2mt89EELr/mj3TpCv87uKLL14+FGvyFAUoPtM9cxUkBJbUSAulLnbG0+hqqBuWcUW0lYejLlxA4UMBQYsTMOtlJlYCkh2tKbpS2ke+D2GeSgyUcYDGAdV6him8mIFTi0Am5Mj6dxlXVF3v7O9+klhUqDiwbQhkWKyth5vX0yWSthornHFHEmzH1n6acbnWEK4ZRKvA7HxmLGEKUqM4X2NyLSvjOrcPulezxp0nyCoH7yUNrDHIGJYyLVh8DoxHtQyIxNr4UuM1vb7E3+t7pFLB5F6WoWEczWqsq6hxnWbPNXGQ2Ti5tm7mupOOwG+1Gq6TxTuh4GpMsCVJTOTkeNsvxlmLnOPgPZ8KIxUMtF9CJ8k2hs0kXbVfSbxqQqnMymtcZ8aSmmDIzK98V6Gd/zM+tse9xP+xzlgXKWRnLVx+k+RD5Qjzy/3NWoaIXXLJJXshBiCTLukWmnsyBMc1pkLL0lpeZ9WcmihLN+Cp/W0Ur2rW5nT5HVkzJVUZh+mYq4A0h4F7mXsw9wGklb7UmsOr4F6qlTLfS8Bsl0owSV11IdeSa1+1RLvGVXDQVvdp10FVxnpPGMfqnsk5tIyiFDOZlR4GI8tiZnFW6VmJoIfKFq+l0sCkSSp2hdcBXD/zAaRCWkWKnjlmza+JxTzfpvM4B+dqFUYKjEZj22jiuibYSH7wB39w8cIXvvBaLjgINv/yX/7LxT/5J/+kg9bPIHhYIHBrGdRlqkILRmZCzY0egd2HY30Y6jLMA0mBKy1G+bcPukyvXwUdsxUam8Z3Kfou+fbhaiyayYf8H1AzjoDl5wgZavbTWuP5FOJNjgK0AtguXUUlmJmhlUNXyCkXvCyp4L2qZTfHyv5vO151Smg1GQ9tM6GRQizXl4RokdMFlfcKQpkYQxJf45NGfdGioRuYCgm18ZY+SIVGWkOqJj5j9tJCaWZexxeh33hELDlYReg/JBXCDhFjHCCMxmLat8zaqVAuWVUozdjrFG6TTFhTWJLKwWfGXaMowa1Z8qLliUOrZVojQS27MnLrVLhcx+16RFS9Bp8xRuwPWk4kk9aq1XrLbyC4CrMqz7RSAdoDIWM+0lK8Cib/ygRPJkdzbqqbuQK/mZ2TpLreTULFnLg+TU5WvQXMmF1jVTOWnTXHHNMO1tX73//+PVdq17Vt0FKmV4NWVZNhpSv3pkoHEx6xJ64Tr6rCgfHlN5Aq97AaO1r/TmWV94Slxowd5pwqKt1fHPu6BlLRU7Pn1lIvfFfPItev76cInl4jzoPzaZiDoSZm0/Ze091e8u0zqsYOp5JO93IVZGmdrt4FZoa3dJH75JTSMtvguHitdWLpQV6HsTCO2+ekRFjL+1Sd9RGqktrrjay3U595nvpZyh/u/Zu0rdHYL84scb3jHe+4p8l705vetMwAOAW+d9/73ndx2WWXDTcjHopPetKTFm9+85sXP/dzP9fk9Ywh42OA1h8fiMYbmsjFh0hauNSop5YXaIHgb+t2TglPChBqa0W69UgcM8OgiTkyW6IWE12NJKIIdQg5ac2RyNJXE9d4brN1Wljd/hrjM+qLsZzGkOn+m/0cWYC0lCnwakEVunJJQkbXnhvbdT/3M4QtrGMQIwQt9gmy3eLimTUjTYREXyFLurCpUa9EUZcwyW66a0tQtDQnMVXglzBke3XBrP2RBOqGOkrcAelzPTD2fB9h88ILL9wTiLHiv/71r1+SVetCmvzG+dJyk5ZwCbfr0rYrWGfiFdcO5BiSKlG1Fqjjpsu4rpBacBV6rf8KqXONKvxPQSuIpafWJTgK+q7fJMOMDYSV9ZNlTcwU7BqmL1imXBuSP92irWlMu1xfVbnB2NZkURJQ2wa4Jp+7pvgfY2vsaJa/MnlMupWr4DDOlbmzXqzXUFBnD/Cc1n4GZrbOpDIqAmkXnii/9Vu/tVxz7k251xrGwD7FwXjoplz3iE0VWmZG59pYdqeQyeIYQ2sIez9k+ZZKJtwL7LthFezhriGfI1rGvcctwWRSKt3fJb8Z7iApTov7yCsjwzgSWkLrwec1QZnxlnpwJNGn7dyT3NfuP5ltvFptp67n88D7QxfrrNHM/eYeqRuuz237lApDY2ade/cnCX098j7zmlxfT5+MK80a7O4p6bVVzzv3d1VyHxTVA8e+NxqHgTNJXHmove9971veyBDSOdIKyA7I90FatISf/eIv/uLiWc961uKpT33qTtvfOF6wzIWCow80rXmj2mvGhhn3mhkyWUvpupRxfFMuYgqX1mozZseHbJJVyUxmrqS9uhrp0qk7Lm3hPKkh10phu3x4S0Zopy7NWgjUnletLO3TwoUgaemKOegy6qG2vpYNkaivUypiG0BQwlJyxRVXLEmapAKCpBZegQjopof1C7KqYDlKEAKcv/T6yPgo50cBPeFaGCHXbsbC5vXTOmF7mG/f+1tjGF/96lfvWbqMd9PVTvdxj2yrwl9mW802CD5nvUg0SexFNuOMJzNWjnUOATQeV+8GwXUQjM8///zlnPAb1u1Ushxd57XGTWV2rTCzcia0ykMrHd4PrCP+9n5lDLkWgqwZVPViYFz09tDV1fngPmWcjC+uBLVaqLiOWb5Zu6kAqXWDFagZJ9Z7uuAqQOeYuW84vrqS1xhtrbN5PfcTz63nBe3k+cz104U6CZaEFBd1S2rp2WFCG62qorq5piuu1mcO7m2VCyqO+JyQosz4mm6oNVvyFHRdzsMxMLusHjWZ9M0505LsmNNH+z6HubCBinQDroTR+9c9z3t5BBUeWuGdM+7tOeK2isip/EqFQIayMIaQZfdU16zkVkUu6512cc/7PJekpou091yWhkpvAe4tkzBVcA6uwf2bHkLHDRmWkcc2yXGjMYUzSVyxjIrv+I7vmP0u1thXvvKV13A7g5g++MEPXm5GJI955jOfubj00kuXN/MP//APLx7/+MevrLvXOF3QzctEJArMuuzlhp5xjkASY50+BLQkDDUZUFqAtGrwm5pgQeuIwrAWXS0cZsu01Igkygykui/plqXgxDmM6dPlS8sRsO0+yNV0K1DRfgRpiKq1N6cKuSe4nq53NbZOKNBmfdODoj6cFUYtnYGwzgFJw4qny7gJuaw9ajZWQPsgSeeee+4emZ9y83VOp6wdUy5pNYOxiWZMZGWdUd3FkxymFbOOhXVmIVb0GXdfCGG64XEdCbaWQi03SVYVuK2FmNbkJD2uGcgpBwSEWsW0fSoZE/OAhRtiQZtd9xJpXfJYfygvOVfGx1bUDLfrCGneP4yX2ZBrwhrnD0Ga9cNacuzMrmp8rRl0M/szv9fy5mese+4va7KuAufASmipkVEZD+YIJYElimgvZJF70iykQG8SSzeZjTjdeXO9S2oyM3DGyiZUltFG8gAwXlpzU2nD9Wkva4Y9RldkM5+a0C0tuirAqudC3mu8GoMoucZKx32eYE1zf7gPpovlFLSyaRF1zPRCcG+QMOvhYhZXSy7RJpMOuUbNxGt/JXfpvp01bYUEUK+QzCrs+pVcmyBID40kjzW8ITOY02fuDy3Dfp95Q8mwDTJEm7kPrVGuZ46x0dw77um66GupTcWaz1FdebWUZgZ7wycYI/rFGnVvVCGXccCMFXuQYTC7JH9ThHOdI383tZatLd5o7BJnkriiCQVsEN/yLd8y+92f/MmfXL4ax4C7G/VbBSnvOQeWWyy5bE6/8Au/sHjsYx+74140jguoY4mCI7P5IeB927d92x5h0GKJ4KxrsdpoBCjq/kFapyxcqQU2w6rCWVoJfIjyfR6wtMmsg6xNSIblL7Q2GHuoRcwYJa1wart52COgmUFT66q1KbXQAX+nizQPeQRvrUWOkzUoRcYpSqq1UukymuOj6xXnNdYvyW9aTeaOue8o0EnQTUaUpMxkH2aQZn5MpiTh0OKDCy3zPYp9TPe6tBLU2ofGFmdG43zvuKcla53MmSPQBgggWYJxw0Qg53B9Ea/K/GgpdcxNsiU5Tfe5tEpku+wf9wJkkvGijiQEXwXPHFiPrHEt3JIa5skEWJKCjGvU5TBh4iLJalWCpOVM4Z97RIuKZHmELKnDOJo5WcKqsst4TRN1QUQhIEAvhhR09V5I6+QIEjDGRAXEiLC71oxJ10Mky37UcTMpEm0wJk+LUyZSMymbY5bhDfYpYzRpI2vKWM10h9ddlXnSHVplGecyaZnlfFS+aVFP0qZ10T7mHNf6pVp2XedJvDJW3yNLrmRNaJUhEh/vY5WUWgdpk5Z+r6Onjms77zNLTWXJLNeYygbnJ9d0EnXfuxb0MJir98m1R4qKugcxl9yrZoMGjANKqf3ES9pWxsns5LpQT5EtPXXyeSXxdC1wTudD5Jz7HM/ndMZ2r8q2zdyyRkfeEFrZR4RzUxK6a3feqVjgRmObOJPEFSEMIBDxcJ27CXF3c7N6zGMecw3SKtjofuInfmJxz3vec/n3G9/4xiauZwxq8wUPdwQGY3Yy2UjG6qll5cGI1WoE3YqNF0sLGtCyURPl6I4HqUDgQziU8EDyFJ6METWGFYuWsU9YYTjSksbn1uPUYiV4EKs9ViOdD/RVyL5quazZErWaaDGhTwjfCQmU4+CYVNKb1kWtKx4SUcm5QqzWEwk1n2sJlsQjuKvJ55WaiLe73e32CIVzo/Uia/epuV8HtRSObrL7IaiA9rMOsaSR1EaLpXFfSeSztIYWipqAJYVw15vxlo49GnoJqpbUTWqa0mYTPUH+UkClfdb9VcmTsdhVeaBbvV4TzouKiJGFKrOgTgluKiEkFP6thVXiZY1Q9g4s8qwj3kNYJY4SvCSmEraRdVVLku00syzjkvGLrn9eVTSwDiV4NXZe6IJqFl6TiSVBzZjstEIb3pACuPcd7dMSJ2HM+8T6uFwTxYZZcUEqRtKtWnfUtM7qPZL1R1VCppdLlupJN3f2OH5jlmmthcgDEtV0G7V+59w9SlstDcV8qThPa5bEThfX9MpQUcZnuJ1XwlJzFPheAikpdX+fIqh+tx7Gn06B65BbwbwNriPWOfM4Ny66z+dezZriXK7RUWmmSqqdC5MxZcx0Pk/XSbSVidBUAOkqDdw/rbVq8ifOy72QsaI+72pyvFpjNg+VFbuC98I6R6Oxa5xJ4oogxo14+9vffvZ773nPe/Y0snz/u77ruya/e/e7331pIcBtaC4pQ+N0wvhRyRXCEg8dE4QouOtya9KhOei+lg9KNeI8mCVkPARdpxIJiZaZWo1j0zKmiyjfVagymYfurrqBcU21xwpFWGh170RQxYKI8GhtS10YFZAyBjMPrqEwbcF0CdHIkiP5UCCo8Z7roFrK0mXTNudRs2oqNEtSeKVNlrHQqoPwSqksFAGMrdYhrbUjC8Dowa973TYJKtdmzCF87FkcED8UHLr12r60ONcyM0ChS+g6yBrXYoAQrYVBd1+P/biWSVatfVvHMmMcdfH1HjTJi4lnsrYtfWJcRucESVRHtSIdW9eT5E/SQrtY47QbC6IxdN6PPENQchDXZyI0Y6QrKebcJjCTsHn/Z41PhWbvYT0uFLIVuI1pl1TRP+5J42vTuqSbNUoZiIbu5h7A0jcSQa9fSYUx+oYbuH95j+W9yvVZS+w3zCPXdy0mMZRgqggzrtFzWlNUgqr7Ku+TwGZsqn3WMqrVES+EvA+5h9kHb3vb2+5Z8dYV6BkH62yPlCDut/SFZ4uk27mkbawH2qpCKfddv2c5oiwt5v062lNq5uZVoQ1zoH/WARf0iTXP9UfkNN+n4tA1PrWfpnVTrxy9fio5HSHJo8871pzKaPYJFTCMdypXdYFHocOzIMlqHulZM4dV5W2qC7JH5i5Yl3xW5e5+nzONxi5wJomrsXhz1lbw9re/fe89D4SRtTWBkIoAiEDSOFtIwVEyxYaPm18+nBG2jKUbuanyMDZm0qQblrkwrsoyFJy/ElUewgpg6eoqYUUYpg1afXX/VUjL2FVLGihomsREKwRtMOkLD0XWPW6/mQ0yXVhTQOAaWlU9v2U6qmY83bdG7lEKxn6e1/Z/tZSE/5dgWyKjuiNLPDK7sgK5Y2WCGd25aC8EBELGeDC+1cI7EgZSgK4uvgfRptMnBEUEbAkqf7smsoaiQlRapLTApftittkYvnRZZm1gOT3vvPOWrtEoNSCprL/99oV1AoHjQGivgqoWTcZQspWx2pIr5qRa49Idex2iqoAoyXMtai03yZakh/WCVwBtRzGkNUZlB2MF0THmm7lh3ZjxOEGbIYv8TpfEFOCF97MJwozJNnOtVjxrGLMWEMLThdZ5l6SlZdWYxpxPx8F1Z6bvtNS6R9I3SfZIiLeN9Jc9C2scB3Pnfel9kuW6tLjVmNeRciPj9Xw1KZBEJQleTTZlxnTbpFWWMaLN665rXVqTmKhgo432kbmkukG6n+oJ497peSR5SV4swTYiqCqcqhfHQRRkCdrE3qMiVuWAChrujanEcial06IqSRTe97pam2XaXAf5PPQ5az3WuWNEhlMJU9eaa98xZA0Z62quh8x0X/tYCW3N2pvP1BoeMgoZSXdz90fX6SiLeCdXapwEnEni6uayKlnCu9/97uUrN/Nd7nKXlZs3GzCYK5vQOJ2QQPrQNWEGawdBFIKXMXrpVqMVhocbD0OtfKw33Q8RgngIm7VV0se1stwH50AAQMBJt2K1zHwGaVFw1uKpFTDL9Cg0KuAr5Cq4GoNa3XRHSC26hNyHaj5kdYezZmsmm6nZZZNcAoUHiYqWliS3ugaqCKjCRmaGVINtfKRF5M2MC/y+7sEoKhgj2jClwDJBh8KhVpkUfoGCHf3KuN8ptzDd0nEN1HUWt1/mJ0mZLpOZACjdL7WeatHXuq31yfHRauG46h6K0HinO91p8WM/9mMHdh2zXJOW1VT0GKfJewmErs41qRAWOl235+qWJtHRwscYaLGh7/ZXN1stcSMSB2Gk/SYUM9u25yS+nNJsEDLrU1pTtkLywjlQQBhjrHAr+WYvgRxD0PWcqOWN0m06E7BlYidLfXBdnm3ej3MwNEGFlAorr8M4uKfp3ZACtpZT1pBkVVKt54h7o26/aY2rxE/34nRld32bFMx73Vctxt4nabnPMjR138k5Q7FCZvEa4+qh66mJrWrIAOPCtRgHxpzz6VKece/uyXq0+BzQgirprHG2+3Hv3RQSb9qFJwf7kXNEH1R8Zikkf+fzVAWhJLPWk82kc5nsyfVRcyjsF65rlS2C8fJeMm8Bn6n8TRLpZ1pts/5yVWpOWTnTVb4enn8KEvY5N+pRjO1U9vFG46hwJokrGjjrKs7hne985977r/3ar115XjeN1lqdLfAQhtAkeOhY3mUqXlGB0RISWjokdsYpsZ747lVXXbUnnGS5En6LsI6wasKNtHpKiNKdDoGANvsQ86HEA9AHsUK+liGtSFlbsKK6FmWsqDGnWrkUaLXkmCAjka7AGbdba/dVq6Dt8EFvG3SR030r63umEML5IEtYNxC4TMjEIZljPBBAFOqrZVSSl6UsFHzrHmEs5rrrjT7RJvYwDmORaV9m8czi846DgnKtAesYG6uXf2cWVvrN2FkH8zd+4zf2xsU+Qjr2I+RonYDsma2V9kpYsyyHShTWDvcN302LKO3Eyst9aFtM5uXhuGTZlCS2mQDIsdWSkmUx6lzSFr0mLP+jIiRdglk7nJdyLuwFknKVL8y1ihGtt3noucDa0aqq+2smdstkObpjWraKvpjJ3IPfZF3avJ/Tg8LPJasK9SrEjNFUQSSRVGHi+Wwb+4yuuPSLhGD237GV4I3GXSLs+OQekzWQPWqyHb9f79k6z+m2OXLz5H8qt/L87vfG7doX22oIAG1jjNh7+I3u3rm2mbN00ZYwSejtb1qM7Utmua1HJbpzh/33qHWjdWn2meY9SNt55Znm/uSzwnvAezWz73pN/s7s6KNEdweN5QSSZsaL9qho9L7ivYnIVAQ5fvTFJG2jslool1njlmuzDNccVGxOlXZTwTNKsOUxZ7BZ5Y6s98XU0VbbxmHgTBJX3LJ4eGhRHQErBYlJ3Cjvda97rTwv5wRdCudswQerMaE8YBFIEZi1zihUab2DaCpopuVETTIHwq/CtNpky4xoudAdT2IoAbFmqg9DSyWYmMSHH4fxXzw8fQhrBeQ9/TADaCYzSuiOZBkY2odwZnbhJEkmk9JFcYrYZ2xlWlRWPXjN9MvY0FatKbrBpZtaJl/hPYSJ+x6BkfZLljgnv0erDlmDmDHH1l5NUiCx1XW41oKsNSHTvVJIqBT+sBqgmICkmtgmLTx1fPP8Ctb5f4VFBdXMdqqQaPkTrF70lxg09k7Xg32mTbghr0K6IefB/NIfBFzOpVCfVhs9ACCpWClV6PA9fmP9UpOdQVgh10lU6J9ufpaSythmkK6mmXXV+8+1YwyiVkquQ7uZJy1jWYJK90XWDK/8/61vfeuyLRLbPKoV13vLthm77txmIrIEbc4SXSqwnONMKMT/FKId33WTqLmHWG7IvSnvS+daS5Sxx1p2ddt3v5SA1qysGQ6Qbr58XyKXVtSRh4L9TwvqSKG0Cum6KbzntaaaZZy/s70q4FQO0RbjNg3/cK7MFsy8sMZVrvD/7EOSiCkSlOs9P6v7R+4jGeNeX/1NxrnrHl/Juwofywelp8Bo/Ur4JI0e9Nvz5/6d1th8nXqfpYZcJyqCzESsQtPrWCc5M+RnGEu2h+cD97zrgSMzHGeZHpOc6d68n/hh3b3nvEqUSaYstwex2uqd2Mabxi5xJonr3e52t2XpGoSMV73qVYtv+qZvutZ3Xvayl+1tLmxA97///VeeF+sMNyzCXeNsQSESIQOhg7WFFQWY3MgMolWoyyyeSWB191IotFyGAlu6rAJjCy1DIflRAOGBj9Cj+yvt4DOIGOTEZFG8akVc5wFkiRjJNFDAyLalUGx8rsQwLc5ZJzEFKOMoM/ZI17nMNqwba1r8Mn4oXStVGpgABwFCl2mtQgrYjCtEjjmBwErwFSpHrszp4jwSJNNKYXkS3HxRbBgzTNskJyPSmwJjxqxmX5OwajFTwNVSSr9cC/TPmr6Z2IPvGtvl31lX17lizPBYSQHJ69sPSy/php0ZpFNJkSVpdNXlmlpxzJJtFlRItrUhjUmWDFTXWi2bGZeebuJVoK9xgGb6hXSbGTitWbTNDNMmv9GN1PWVRMwkX46P9zx/q1jQmgoknhmzzTipcDA7+JQbobHq3JOratOavC2TLPG382//gfeWCicFfi32GWepcindVd3j8p6RREhiKmFLMuerrs56C2QZnrQabmJhrH//yq/8ynIMdPHNfAHW7tU6p5ssvzWRW7oruw84ju5zzA9zalyx/fV+yP0gE0+tozDzGCWs81yrwqoSeoNk+AWvWvVTgZHzlC7jmQjLPXYUyzmVQ2EVJMvuOSp1TSZWQbtTAZRx4JtCJbKW3PSOysNasRlLvh+r+NTv3E+87/O+qwmkVJCtstq2xbVxGDiTxPXbv/3bFy94wQuW77//+79/L3mIwD2J2pxuhA984ANXJnJCGCG2jN9Q27VxtqDQmODhjeWetVGTk7j5SxrMhmnNVP7PQzRLISj0WSpCIqqQbS1AE8ZoefQh43V51Yqmy5HuWxDWVXFsatMtDzDlWoQwIlk1IYXJZDLxU/191hUcIa0A6RIsaarn9YGtZVfBjbYwP1hZ6Y/CnMIMbTchDH0wtjfbZqKQVeOlMJhuzowdxMTELJYoUXiohFPilBaC7EtmO1bYTKKqJZg5Z90YQ2gJmowPA44n55T0+XceuPSyxhNcz7JjwvNIdrRqSg49v67prEWTySiYujYZJy359pO1Tx9RQBgbl8oPlQSZ0TpJQLoiKqxJfCRIZgZn7WNlhpg4NxJW2qrixxJAgDg/2pSCo8oV+6fHgkm6PIdZqU065TowIzjEXWWDygUzdEvY7JtKJM6dydZGh/c6/TRmVo+KTKzkd1UAmFWVdqXV2/VXa7l6n7pXudZ15U+SOnILrV4pvm4rJs85TuWMmWXNKZCxz4zBpZdeeg2lhAmULBmkC7RJsSzlpCWc/1mH1fCFJJmuhSlk3gD7kOTUZ1AqS3Wr9vtpIa7vUxnhvKjUcs0aesJ3aGuSpyRRIGP9VUJU1/h65P1fj1XzSTslq6NxZCy4P0zUtS2oYOaQNGs9TuWSymrgs9+610cJPUDqs0Alb6Oxa5xJ4nq/+91vWb4GiwDCBIlEvuVbvmUpvCGEYYVV4OcmfeITn7jynP/tv/23vfersg83Th+0BEqcIEMXX3zxNZJHZIZIYtxMzqAGF+KCMOQD3nITQqEf6MrHAaFCaOW8JkDRlUdNLddG+EMIQmhSoNOt2fqiU1BYt47dlMCkxUhBmXboGj1XsqDCjKEgLQnp3pvuk1qU1O6PYk4Bv0EY+OAHP7gUOGmfArElhiB0zk+65+Ucj/qfGulaHxHBVnLqa3Wzq5a90RzkdyqxBb5Kimg3a4P+QFCpDYrLr/2RaOiOrfXX9teMzdmGdaCAbVKsdPt1DCU51v5VeSMRArq5Sv6A7nkqOiCSOS+Sz8wqa8IbhW3PoyCdhCqtPFybtmTsqm59WnRZN1israWqJQ2hlH6zntL6S78ln+muqjWVvuhVYekbhFe9Fhgn7lutzbqk8n3anHsH/XMd8/u5e10PEcbaJE8c3P+6BRt37Npxz5LI1ARAKtWylFUqYzJGTtdrSV1+N12zq8JBwpJrrJKbSnSm/jf6nsoJwyBUVHB/MTeuPQmgyYSM39dCnxZ03uvuapIeYEIsQ0PWLfk1IqepqEmk9VKSXy2aqRDQcu2R+yvrhfuP+dCSyP9w2R+RGf5nqIjEcNvupSMym+WG3B+Zm1Ty6d2hB9J+SPMmhFtFXZLpDJcArgH2n8wEvotxW2dcq1JEbCvWuNGYw5kkruAlL3nJ4t73vvfeA+jlL3/53v8krOBhD3vY4sEPfvDK8/3n//yfr0GMG2cHmVhCK58uhwrtPAhRjJhdmIcTD1CEQ7P/VsuI5+EBYdZPXTYREIw/NZssrqVmyuR6JkjhuwjVWqt0U0MwmkrND4zTS1fQUd8z6QltRMidswQkaG9aSiRKuiFmjKlkShdL3e/4rRk0Rw9xvkd7EOwRrkziY8ZOxohrk90VzwszPeo6mzG4CoaWZpCESMp4j/VRYZ/3xlJWNz33mdpm25tu0klmk+im8G82VtYEllRcCy3poRUHCzPtyiyW6W6Xn2cSkuqOJ/Hk83e84x17cYkqFHT7VNmgBVxhn98z9lr+JG+6y7IunVu+a1IbawQryPN7riOhUcDzPpTcaalIt20zIDtuJjHLODjOw7VRaHIv0BfWhcoI7g3a5FhL3phj7m1L1ahcMQER6ypJXN5PjjHfZS4l2t67lqRhbGgTSqEpq7/ZkLlmJi3S2paEEJLK/YGrOmvE+z5jk93nXJNapLOGJG2t9U6Bmcv9XrrX17i5dMlOt1iTs2WyonXI50Hecy3G2dhdFSHZVvcw2+jaVonnOKiY4HysZ63+wjCNOcuVCpt0C07rV97HJtkbkdLcg1NxolJnyrqda5Uxwe2dfcX5o330gXWX7tWsCS2NmfBrV3BvZc5UHLovSNZ9zzypSD4u8ZnWUVYZBSoBZr4l/7ymAmfbhHud33XW4cZh4MwSV2rmveENb1g88pGPXG68VSjnb2Jff/qnf3rluTiPiZ6wbOB63Dg7YK3w4E4LGsINRNK6qTxgEAwpdWGGUa0RbvYKROkeZ0xZus8ijHBehU1JBtpt2mIiEIu6e36uaUKhKYEEIVuLQgqSnDfremZmTv5e5S6rq1xq7+kj/TUZhlbZSlCFglgWkE9kdlLdpWkXllWyVyKM64plmxkjCCvEQwsbZAFiYOKrapH0IU2bJageCEfVMmrbnAf3mrTcKnimBVXylLHAkkNdx7SiMa8Zx6flMIXiFPRXzVVNWpK1/3iV7Bif7LgoPHMOrNr+L5Uz1iCVmEq6JTuZlIS1TKIsrZaSJWPNdKnXEs/a8DwK7JkB1OtIUkcwYYoJsVB0GK/J9fQ44FrcX/SbNhgSYFvTPVuCLrl1/LTwpDunrx7cj1otLXkFwayxkK4bEzLRV2PpGEPnXgKqkoW9i8MSNulynnG46T0iSbOPtEvlgHubpNT1pFAt4VJxk0nBsrxUluUaKc22hXShluwwBkkaXNMc9lm3VvcNvU3cn+r6cp0wf1rbLVfD7yyl5Zg5TtUdU6XdyOI1hSSnSUydp3WgxdKkXKwZnnGppDShmy7hGT+9a6KaYN1KVkfWasaX+4m54vUw27YufE7iJWVoidnt837w+YQi5KDJnRqNk4AzvbLJfkYcyi/90i8tXv/61y815GxgWF0e+tCHrpWQCVxyySWLf/gP/+FePGzjbCE14AojatpZUwiZWSpEwlXj6BQGjXkyvhVAJHUr5DcI1lnaAgEbQZTvcG3+JwHlN5BVhCzjOhXSQMbYSJIySYfJVRSGec04pYrsT7Wmch0esAjS1pqtBFXoZqdrmiQsM70mUXUsjB2FOHEdxtJxNBMvRO+8885bPuDtr0SP3zKeIyLj4XhLNucE65rcJN1uk9ymYOznzrmEnXlM11JJqgI0YzGy2Ore5XUy7rVm16wZUnUfloTWucpkWipf+B5WSq1M1uXVMkAfrNfLZ5IWXe1Zt64RFTOSQNcB37UkTioyJLfp9pv/4/y66kqKdIWHpHLPqoTIMi56A2i55D7Suqu7a45jlu1wXswubE1mxq26BQq/S9+5LgqYbLf94b3EUeLP+UwYlUoX44vpJ0daEF0rmTBKb4rMKu7Ym7CGI62u6Rmgm6rjU5MpZemljHv0Pk+PhP0kpMlz1789H+Nnki6zW+uO7r2VruRasXMt16zrNQM7Y855tZg7PpJdE+axP9Z6tOtCcprEdFNymtB1NbNHGysOYa2JAVGckvHbNXHY1jdLaWkZr/AZpgfCSbIOqnRWYa0nlF4gQM8rDl2x6ad7TaNxWnCdq3epymycKhDLg1CHGyLWscZf4FnPetbita997Z4FhAcLhOg+97nPnjCb4DOFHbNoKkAjDFhqI7/P+XQjVvjSWomgoxXJh3EmYKmp8bOYOg+5rKmoAAv4naRx9OBLd77M3KkVQAJiXKzkpgqPvpds2BfP63vJ2f/H3lmAT1OV7//QHQJKdyNIKSDSgpQSKiUlgon+wAKbEBUwUBEwkDIQMRAQ6RYpQQVBeOl+QUKQBt//9Zm/9/p8552Nme3d+3Ndc23NzM6cObN77vOUrHRxUKsYYQaHuDoiejR4idZMlSniu1R2BDHIYJJ90hbRzVeutXEwD7IWReupMv/Wc6uK1tQ4kJagYYAhSw3nqD4iq4wsrYp9jlma1c+iJTxasIoGrvm41ZjpVwNV2lBiJl+aSNa8Sy+9tJZYRgKZwSF5BJRwRRMeuqbK2BvdhzURQP9XDLDaXZMY6guxfEm05kdrYN4NOy9qOH+57CsxlhKHxespwVrkQqiJk+gSKTd+PC0kbiRcVY5HpVJiX1G/Uj9XZt68yBYx1pPvjdY53cMSZLSp6kXL1VfHq/PTPa12jJleZRXX5IliNuN5qz9H8aT2aTXbaLwnOv1cj7Sh2pVFdVXrZZSlPeR+L7f2ViydfA+TA/wWKZRAC22j3/R2xamed8LClheq+ZAP+hG/iwoRoS2wCJKQsuy5dAKVpkKw1svyq3rbyqg/SmgyWIK1XikbTZBoQt2YYWa07mJj+oAGOxqQMzhioPP617++NqhmkCJhpxn+OGjlz0e17RTjJPczWRK1vqw0fI9iOyWKZO3Nx7vIRU1uxEX12lg/upnqT573NUjWQFTWEllV5KoUY2KbWQ0k0FjkTiaLdIyN0wCT449IBGhhMgWhGUs4KP5Ts9WcC8epAT/HS/ZbiVWVcdCAPrpiyhU2JhWKYkLWUhFFqxL8yGoTa8DKKiP3UolOWWw08GLiSG7MskC2E48lYRQXWXs0iaHXEnH6TOUjeKQ9YmZYxS0Tx6kEIhKZ7IeBb4xFlXWffXGNo/WRayTXYokfDd5ltYv3h6zDRZMGUXDHSRv1rzhxk7f06bu1P3lQKPmU+rBEHcfI/uhriOKiTNdR7GmCiO2UQCYeQ3QtjpZKtamWGHvNva4az/KaUOy9XM91HypJnESm7ne5ocuqrT4sr4e8e7p+t6qKy27AuavcltyhaSf6AH04/zvIcdAeCDIlXmp0bLFvKZM7FkkmefP1LrlvVQe5HnLHLnLt7bTwoh0UqpHPahtRX+Y6cV9rQgpXee7NXqJyWPxWcOxFaHKPiZZRThgUk0lxLRTqwxLrfOs3jv9HjREUrtFuTK+SlrFoTGJMN7FwNaZN5MoYy7PwR4JwlVDVAEYiR66LEnyAmxXvyz1RLqHxz5r1GUjizh7FggaYyo4rSwIiQS6DipvUQEOCSoOQmAgluvWxKCZUA31Z5lT+gCUmfCly5GA/yrCp7LHNEoDkkRs156aZdgaI0R1Y+1NtUtqR41PMJc/zFq98YpZGmXPjgGVawUQAAQAASURBVFsDWllRaYPoiqsYVNXxVDmdWGJGg/3oaknbMOiiT3BdlTCq6iCf85GgUaKZvBVIcYc6H00AaDAuYSshBLEGZ3SHJ85t+eWXr8VScn1i+RSJOIli7Tu62sbJjFgXN3oc5C34WmKGZ9ZRAq2YKEnWR11/3cfqk5qwie7Wcr9jPU2yaKIo34/lmitPDAlCobqzSk7EvaT2yFtONZmkTNDyXlBbyj071k7VhILOQ+2g/akcVjxfZXeWO2VMuJT/XYheD8qAHMv95K9Ju0sr+wNNEuh6a6JJHgVqZ6GSRVxDJTWTO2+8f6I4jWVvNNFC/4hJlyLsP5Ya073SC3EakTuyliIXdcFx0Ca6Z2kboVrWvXK3lXssvyNcv6L/F9qWflvkZTQOyD2YhWtTVF9dfUATtQot0m9Ys/8VjWViUsJYLUCJEo3pJhauxnQAiY+YtVFiLl8cXe6EKj7OgIA/E7nU8sMvcSl3W0Ds6U9B7n2Kf2RggeVQJSvybl5xgCEBKUtKjEXl2GQNk2VCtVo18NUfFq9lEYzZiaOVWfVPGVBIxEehGB/jc1lx4zEoQ69qXcZYNImdaHFjAHnLLbfU1tF1ieKsUXxqXqDGAXIU5xJvGvBzjXjkvOVuzfayDHMOEU1q0D5yMZUrJudazy2/njskS6xRKEERk+JEsQeyqPK+LK2K/VVfk2t1tMxpciCWl1G/k9utrLYSmdG9VrUvNWBXPWIEO+0pt/AidA3kbizhxvfKaipXQt6LAlZxl4oHjxZPTfDo+nJMXE+VnVH/jnVQ1ZZK3kS7K6YuiiCVF1FYAP1ax6OYZrlRq+4pxxkTJsX4c4lzTcjoOuq66npHl3i5LefdCLGkYQ2MsfhxoqBe+/cTxURrsi7WrQZ5qGiSAnRuWpRdmuuC14u8NmKsfz4OvcgNXRMJQuVW6MuqZ9sLcRqJye+UNKwe8bdcNUYJu+D+jJOBZMdvlI2+U9DmmmSLsZwRjkdi1S6wE9F/OhMxyoydT+5EH+d/kkXWWyV3UuhMFKn5+ysPn8cM+MZ0AwtXY9pEg6PoZsUfKslp8oNDBkj8iTDbCUp6w58BA0cGOaBZUgZWbCNrAaJHCXuYxedPiERBPEoIR2RF4c+dQancLqPIk9tcLCMCEgTRUhaR26IWCTeVH2k2G8+xxjJCeq46hxIdnLP+NHHBQ7DKYhfdAGOmUrWDYvb0fbF94jr5mFNZmorcqDSrrJIPStQSP1cMLdeRgXC9rMtyG0aslk0YokF7tH4XTVpENCmg7MT56xGzp+r6axAPikNW/DTXmgR3sqjKMskjScnknqoJHQ2mgGNWPKgEPpaC6HqYj09Usihdd4njWLNV/VlusjGOl++W4OR7lNxJrvG6broPNOmiySeec7249+J1UD/lmFSTMQp2JSeTsJbbr34PJI4kVmONWZAFVoNI9qlrHa+Nvkf1bWVJlDt1TPSCK6xq+kqg5l2s1S/aXTqFXLMlVKM7ZOzHMZmYksXJ3Vxtr/hxXuez47aKvABktdX1k0VStUB7hTKha2lU/5U2iEJVE5f0H8X2R/h/os90U5Rw7bg/VGqq6JpErwB+M0xzaLNmyZ1UfkeTjfL8KfImEZrEk9dWJ1yPjWmGhasxbRKtePE9ucPKHZA/CcqyyAKgrIysxwD2/vvvzzJUM/jQrLzq8vFc7qbAnw6ClQGs/iii+1mMo2RAIgsmgwKEX9HMu9w6tcSELexT7pGyuGngr7p89USXympIKOv8JTZlSZJYZcAlV1YN9pn5Z3ApK7YsUNEFUxZUtUXMWAoxe26MJY2JjXQtZWXk2jBgi0scjCpBiYQ6x4qFlGsjt0muQYyX5VozC87Aluf5hE7R+qy2kyCTQNXMuRLtFAkFtWe8jjpe1ViVIAK1qxJ+aVCi6xstrUqihJs2/ZZjipYoTSrIaqf9KCs256fawnzOc7KSyhKr66BkMRKGOmdZhOOEhzwWlPFWYjSW0JE1gUEvng4cj85Xlh1gPa6bxKzuJVnKNMCWK74mX3SfcWyx5JPqXErIqu05V01qxYRHEmi61vq9yFtVJaB1P3OssvIqTpyF/SM6CDGg3/Ujy2hZsavYOZ17jJuXtTSuL0HLwvVn0kH3geKXeV/lh2L8OdepnlBvlPQs/5une7tXgpW+HoVqPqY2EoWIsrXnRQb7IJlUnBCgH3NvdkskyvtAmfSL4mz1/8d92+vJgFGDPksbKoRAdcf57ctPFHBd+Ey/3/ImklCVN5ExvcTC1ZgOoLqfikPkj36VVVapxaZSyoI/CFmIFNvIwh82g38lR5KbMcRSFLixsR/+XDQg1QCd9fLxhrj/sE0sexIHWjExjay1Er6cjwRHjLuMQjX+YXE+0U1Z8WU8l8iQQC2ywEiwKsMrIoJj1x+q3DdlEch+vKaffkJm0+iGqsGlluiKGi2AKu8ADIywSMtlUtmHI8r2KxdtJS2hPi+PceAY3XFpT6zpuNkVDbyitVDPFYsrF8gYT8f5MYAAucvmS4/EY9UkiMoRycqvWqzaP8cqy5RcViUk2V6xxDEOlf6g41LbIvTWXHPN2uCGa8J3cE1l1ZY1CCHB87/+9a81lzT1SfUXWdHVj2ICKU16cM5cO8WB8pmupZILMfDiOrA/RDeLrAwgF3r2peccn9yMVRZJNVvjIFuDPiVmUrmZOBhUX+SYFBIgEczvBJMzEtJyC44uwboPYmkeCX+5S8r6x3EjVhHo9JV+Z1TNu9fWi8OOvyHRPTRa66MLrwS+JnyidYi2UsKsRq6kMXY3X06m0cA8il3o9iCe84uZv+tl0gVNbMiimv/Nzrc9E27Kt6Dt6T/cQ92woikZG/dfUaytXK1ZlGzQlIe2je6++d8t0O8k95L6FuTLzum6qcyXr4npBxauxnQABkb51/wREGOJlZUBrwbTcq2Ri6NcL+XOqPg2DfAVY8QfiGKP4sBNiZfknqjMuBGJGyWjkQux/pT4/ijuZJnQHxbrKkEJ1qMoThVfWMYlUKVIEA7sj0E+AxhZVeTOqiRHEtxyzZOY1mca1CrRTF6sS/Cq/REyUagysM8P6iTWJdhZ5GalUjn5xBeCY5BIYuHY1H6qDyortIS93pPVqMgNUkIzCjqV1oiWNmAfSl5F+yo+ScJH4ph9KVZMLqOaRNHAXYIrb2FiPVyCNcjXhMCSSy6ZNthgg6y9NXGjOpDqv8rKe/PNN9cmOOLnUbRFd1gJaU1ccN5yrdX1ZeIIMafBulzlOVes97RJtO6o1rFEnyYXEJIk9aIdlY1b1yAmUtIATu/JMhdr1LJPxcLT7vKa0D4lyJW4S5MJ0YVX+5K7uhLRRJEisaHsxoOKYnO1xEmf+BsX+4DEt94rukeUpCafNTWK0ShQG8XxNiMmjeqmNTIK1Ua/s4rXlXdDK+el+zOKR7Zlkk1ipVOoNBP3U5HXj+LOFX5hYVQO/XZEodooAZfQ7x6TXLKm6re7k8mdjOkEFq7GdABZQCROiPs75phjJsQYyV0RGFAyuNQPvQbhsuQpq220ikrMyBoUS4zIfVDIOhUz5PJdGpDrWFXPFaILnESwrBgxs6rEYLRc5q25gs/Yjj8/uXsqfirWp4zWJbVVTHoTLcmyLCsrK+0Vy4PEayKXTwb4SkBTz9VM4iJaVEGZeHGhQwAqk3Jsbwk9Blx8B98lqyKDQlkHhbLBaikS/vmyOyCBqRqvnHfMXovVRDVJZX2VVS7GrbJPiT651Mo1WFZ+tWV0q5aVVbHMPPKdiNcI6yAUEYgci86HfqCyTRIjOv8o2GXV1fnKsp7PZsw6KqWjjNVyz6WPaWKC/V955ZXZexr8y3NBNXyVJEqCXlZ/rn0UUZr4Ufsr2VLMGqx12Z/qfup+k0CNJXJkOdRkliaQ6Ee6F6Lbtvo/++accU/legzq4DHGnUa333ySqZgYTL+J3Iey6ivZWJF4U6kZ7ndlS5ZAVf8fdKJ7vM61XnZz0GSmljITFbQnv01xopPtES94GnQK7j2J1aKYW66L3PeVFMg0R5n+o0htVoIOuK9iTKr+P4vWi8mdJGLj/VeU3ImJ2lEuQWT6j4WrMW3CjzhiQQmUlKBFf9KKoZLLpAbXGmArgyl/RAzy+ROIrjwqq4IlpSiWVGJOoiTGj8q9UEIpWplimREGD7HERqvWU1m+ZAVlOxVEp00Ut6SkQDE+T+cst0i5+koIxzqvOkfFacbaoMB7CBRZUpU8qFEsnyYKlOhK1gXVh8WqquPPWzs0KaDrqrgfZfSNM9RKohTFWd59VNc0xsLK4qnJBFC2YMX7KuZXExFqH/UvkLDj2JWMSOcq93AlAdPkQBSqEnda6g1K1M84T6yUxx9/fNZ20b1ZWXhlaVb/5DPN2qvmscrEMOhl/ThZItd02kpJWtQXlPGX60FbXXzxxZkrvjwelL1XdVeVSVkW/xh/Lgu/2lMiWu7AMbGS4pE5B9ViVkIlhQjErNfaRhNLiuPjuscSPZpEkaeGrIlKtKZ4tUFCbr9KtKNrmBepEbklKv6SPqF9MIEQPUUUJsG63PdY1wexHVohL1QbJYlSRngJ1aru3/zHMOEUv0u1QDsR/8z1lRtwkUeKMm6r7NIgewYMArFWavRyaoZqwUehqkRt+t3RpHGcoI4T1nHRZBm/vaqDHNfnc7xtjOkmFq7GtIksSXlLgGYgldCAPxFlIGWRi2bR4ENJdGTV0QBDtS5lPZNFtp4LmYSMMkjGhEVK7BMtsqpbCfnaibJ6SrjwnQgoZu2xZHFOMdW+/hwlqkT8c9R++VOVYFJsrdxUZUnlc8UpkmBG7SqX5kYoCU60qMZ2pw1x29SfMddSmS01yFZMoa6N6j3G7+aco0CNFjSJQY4jinZduxiDq7jHKI7kgipXXw04ZFHNny8onlJiVS7JbMuxK5Y5D+cnoRpFoeKldFy0G663lGJSyR3ep6/xfbLSS4TTvkogJHdAZdtWv4oZefkMUSJ3WbmU0k4rrrjihAEd7aIkO/THO++8M+uf0aoPSobEuoqzk6hSf9R1kEeDJnNYVxMrEvyyhMbSNdwHcs+OZVhk7VA7xWse7wuJVSV447Xi/eQCOyhwvJwvbcNklZJk5cvDFN2Pqk+rOH7QJBv3H0jMSqwqvlvZoIeNmGQtZoUuQveKlnZFJfcVniOKYQT6n7JLt4Mmf+gH9WJvOQf1437HXA+D1T0f712vjJz+s/NeBjGRHvdm3Ec78DunCWKOTccaPXWM6Rb+5TCmTRQ7qbhL/igYWC633HK1TLMMouWiKesJP/CxXIcsZfpc+5ZVLNZrzLuW5uMCZcGRS6XiD2PCIsXAxfdk5YyudXwf4pRz+Mc//lErSRNjEmM2W52PhJ7EgM5Hg34JAInSaGmV2FVWXwZWWJyVOEjZlmMiHp2vRGLe7Te6oHEccl/mXJTVUpllZUWTFZjtZc1VzUdQTLEsiLIeyiok67Lc5eRiHI9T7tRy9WKJliX1Bw3oZcGIxxZn1DVoUfIoDXwYKDNwRHDnhY9impU9WO6sDHYQ9BKSio3lfayY9Isbb7wxa7voss5xkrBK5WcUl6rj43zZRu2uyRkJ3Xgt1X6cvwZj6l+gEjUcN+dITLlqcbK+hLrWUyZnZbjmO2LsuBI+6bX6Z94yLmu3SlLFxGMxURjnH93+Qfe52pNH2kZu2BKrEvbso9PxhmXQJEvM4KyJHc6/WRydflckVtWnNchWQjpZumVNzQ+UaZthS9RDm8XMv43aivOOQlVeE+1Cv1RcfnQ95jeNScCqIlLJB7mHoxiO0JdVa3VUXEjzojEfUtPqZ7GkWau1UkFhHXGJHkgQy3p1C03Ox994Y7qNhasxbSIrAH8++kPhD/22226rJZ3Rn4uEVnbz/Vc8KlYwuobqD40/MgkjiLGg0b1HokBJemTBiII0opg5DYxkKeS7EBzMyiNQZUkt+iPV7L8ssvojlvuwrEiyVsaZYe1PgpVHLIOqi8o5qB4sSKTUGxzJkhldi5W9WVZgWXFk7ZD1MLpval8Su9HyyPmq7IksaWp7xebFhFVK2iNXU7mMg9aV4NY6ciOXpU8JaNiW46GNJGokBDjeWGJFMbkMUnkty51qBGsCRJZtWQoZfEqAxXhtuScrmy6PtKGSCimbsmq2ql+TVZjrKOJ5qp9LWCsxT+wvigtWrG4clGnyg/3hlsz5KluyPpebLxMfuK/RZuwXS6is3Jo40aKyT5qQkRBXNtdYPkUCX/1e564JGCXi4txinLEEsWKq8RzgusoFVGWvFN/aK9TmcZHYVqkVTZw0G1jTNpyLRLcs8PHa026y0CkOOkJbScgrZnwY4NpyPhKqjcQD/UQiNe+90Sm4ZnhFRJdd+hXJl+LkQKsoQZ2uW1FfULy/kof1g6pispVtGsUdNyIm4FNyvlZEakykqHFCq5M3+l2W91Jc6r3f6LP8+8b0GgtXY9pEsan6M1PsHQN8Weo0yOZPh0EY7ykpTMwGKBGgP7T4B8qj/oQkUBslV4DodhsFKoNwrKcMaBArHCtWtEblFfJCU4NquWHGP7J8+Y74J8uxkwBE2U+xAHL8srgoK6gsq1FIScAqgZCsN7LSMjCg/bgGPOe6qKSMhL7WiTFCih9kkWuikuCo3IZEiwYesSSLrr3cTGOZHglFWWM1qJeFVJmQdWyxzEl0+1LbSqDL6kefyQtmkIin3RCxWEfl7s3+1KfUtjofzfzTbortjbG0IEu+spjKkipLIxbyjTfeuDapoz6gQT0CWK60akNZRvMlk+Q6LCu7+p0s43JdVmZduXNLNLEO5657Klr4IxKv6scxzlSWbSWDkhVN96jiu3U8cgOW67ImFnSM3AMq0aLfD91H9BXuSfULib0o+vVc7drqIFLtnBenanuto2Rw+fuk6PdAEy5yAVXpoaK4RcXAy6W4SADIQjcIJXyaoQkxuaurznA9FLKhpVu1UYG21W97vJ+YJOH3t4zoYF/cb/JIKbpuigFXnHYr++ykmMx/1m8UyhNFatFxxd8dJX3Tf5H+32OOh7ICdJi8E4xphcH+VzBmCOCPIbrG8geOxWTVVVedMLjXYFUiU4JI1ozoYqv9ynIk18Io1ER0S9RMrJLksG+JFg1imClnaeSypu+Nbq8x068GvYpTlQVFcbP6s1QsI+1BiRJm+eXCKtdXjkWZJZdaaqmprEzKhiwrI2igKBcrZX6VKJe1QxYzCbI4QI+lfnQO2rcmIqJ1W5bAfPvEsjsS60r8FGMUlRiDbdQ+seyHaqjmB+ucv8Qh63E9//a3v9USR+laSNgpDlmxpVpiv6O9Yr1UWacVz6u+IUEra6QmDFTjFIH6xz/+MRMi6uuc4zLLLJM233zz2oCN76PvySrKMTJxIcum+qyErLaTtYrvk6uhrjH75PyVrIl1lbmbtmJ/0Uqq7L8SiLFGrQZ/cQAsl3n1H4R2vCa6jkrmxXbyblAGZL5f1nKOX7HV+m6VctKEiKzrrRLLV+lRA+EYax6vaRwo58VsvH+16N6XYOYcFGPKOeXd8ItQDdx6NTslepT8apCzuEah2sxiJk8YWdN7VfuSfofXTH5yjt/gVuOjFU7BPct1i14zccImWotpIyalWhGZw0Qz66MSs8WJIN3jmqAsEpRRpOq/3YmqjGmMhasxbcIfDYN4lb/gNQINi5OS38gyJtHYLCmHXIJkAdSgNC9Q5bbKAIPSIwwaEKjKiMtgkQF+vcFVdKmUqNI5REuprIFFx63XcnlU+QoN1JWMSCKVYxLsX4NgCTYdT7TUcZ6cU1GbaTAkCxHPNdCO4kUusxJwGjzpHHV+Mc5RxNjFGHspwSs3LllDo/iUJTjGQEsUS/hr/xJrEkGq+UkGUK5rUV0+xbOqTqiEqgaS6nuKU9WgSoMuCTvti+00+JIQVBZbLDX0bR5lEVPcnAakTBjgZn799dfXMkzLFThfr1QutRyjxCCLrDbKFM2+6TuIR1l/WV9Jzzg+LPf0Ow0eNcCOpaXUr2UdlmeArCISqrI6yt1bnhKapJKA0XVi4B4t+fKKQNgr220cxMoSK2t3nLiSqJaAjINkvY4iQJMzalt9V7zHosVG/S/WoI33fz5WXJ4N0TVdAoVF36HBuI43usxGd2+tw/5loVMZH01E5fcVn8fX3RKB6hP5UmTNkEVdFlUJll7FWdLm/FZIPGqiRq7n3EP8FtQTk7L4K8FWkcBUlnslbpPA7Seddn/NLxGFY8gzJR+3rP/oerVSY06CQfcoMGYQ8V1jTAdgUM9gJw6MsTDhjisxVA/FxUqoKjlLtAbKNZEBglLRq36ays40yuaYF6haJKaKBoByfZSYkrhSuQ9ZUxEx/AnLPZd1ZalV4on8AEDlEGSFjG6ZGshL7EQkAmVtU+bd6JYrC6ZKAWhQrG3VDlG48N2yKEnI6XglGPIWVg3sY8IerR9ji2WRY2JBLsuykEaxIuEmqzLb6PzicciNWOemJC5qO7meKotkTPIUJwIk8GJtXl0H+p6y/sqaIquRRCTilO+in6sWsK4R333zzTfX+kOcDIjXnfeU3VjtLWs1j0psprqfemRdhGEsFSN3RpCFFTQZw/ewTnSrVp1VnbvaOlqY9b4yTHN+9H+Vv5IlPyahYZ/qz3m30Cgo6j2XpTsvniSMlek4bwXLT1BJhMc6z5ociFZaxc4ri60G1+pbMZFYETpmTVzEyYr8bx1tw34l6PV7VpUiQVvmebwXNGGjCaW82M6/FyeromVNaIKgU+6v8f38taYvck/G/xqOi6zcrM9n9ZAXhrxUitpY97/KflW9Rt0Qmd1C/blbtVKNMeWxcDWmTVSmQxYMLXfddVfh+hq8KUumhCrEuoUaSKg0i6yVjVx9o6CKLn4SJq0Q3Z44RrJOMvjB+oVY0OCN/XJcWAKZ5ZfFWVk/JXY1yJbLqc5ZA74o/JQ9Vtto0aBB4idaoGMcahQt7I/32JdEpJIk6fvkyicBGmMyNWCPg/ZoJZPVVWhAK5HDQFHxtRJvccApcaT4WtZhfdoyuvjFgTbryUKlSQe5eUaxrH1Gy7mSfSlhExYY1lP5BRZZ8+VqrOOVNYz+qIGzrk20zsjVlONhUkXtKXHKvpWMSfuVBVZWeiXWQhDrO5QZWRMecieXoI7xn3LR0/0gSzr3jKyS0dqsgSjb8v16X5MuOl8Jfwlf4H5Ydtlla8mVJGZoWxa2iXHEcVFceyydJPEkC6wmQ+RGWO/3pyhWWZZ7oX1FoRyTXOk3Q79nHBu/Q9FtWL8v6iOaBNI9Kmtz3l1ZFmuuXaddIVuNadQERBSorSTHqZfFlUUTGYrNzwvMXsD3c6/EBFccC31S2V6L4Nw1OSbLuybFJBDp35rA0m9JFYvlMMRZdrpWqjGmO1i4GtMmGujlByr8WUtcxcQlDOL4U9SAH6GCINBAKorTeq6+DAYk2vICtcoMNNtrgKISNAx8FI8nF1yJE8Qqg1pZaSRClbU1xurKgoaLKW0g0SOXtGiNkyBWZmVZJyHGZikDstpGYkWunIozjbUeZXGNyaTypYCie7QGLRrcS2QqTk3HF921VZsxilPFMCkmTG3F98vSwQSAss8ywI/nJBczJXyK4iRfiii6D8rKJouPBC3fgajU4F2uzmp3tlFcrqw4UWypfSVidOz5/s6Eh+JN2Q/fKSGl4+U7cfFlfdUbpP/ouFUfme+S2z3fg8UT98eYpVkJs3Tu8nSQkNYAWnGg7DMOMiVoJLgkSpRZl/0rjpcYXmW9Zr+aCMiXrZH7ZlFCpGi5kRtxkTiNydlAfVXuuHGfcj+P26itJVTlaRH3ESfcWoFjp68zwM//9qltlZhOE3Oa/InhCHlhk7dwRhEY+3az5/IUiQK11dIgEuYxLCOWB8tfm17Ea+ZdpbXw26HYa7my8xuOi7p+Y+KiyTGuHefJ9eFe0rkp14DqY3fTmtlP4mSdRGqRh0Ae3etRpPYra7Ix44qFqzFtohlniQOVdqEciJLOMFCg7uXf//737DV/nLynwuASqbFkAUSLSN7Ft+osNgMcSqOwqAyPrEwRWdP4Y2dwxgCJ2ClENq8lliUaZMGM9WPleihLmywT8VwY/GuWX4l3ovjTAFbWZ32/LADRnS5aBWLdTB2PEu5IiMpdEnRcEndx8BytdhJH2r+sjBrk6dposKj4U4mSKNoV/yfxyL5UWzQm4mL/KkIvoSFhJdGgNowiQsekfqjyP7I6KqkWfU/nr0ROMdY4To5I5Krfc4xqZwla3mPyg3PEGhTdp2MyHvoGbcHkjcQv66ieIUIQYSvBjliVFUl1ZiXYlDEb1Cd1PdSOGnDqOkRX6ehOruvAa5XIUfkQuZ7La0I1YGVpzwvJsmhSSn001jpVP5TVWm1dJHhlodekhyZw8pbffNbuvNjTeSh5lvptkcjVZABtowG9JuGKjk/3Xz7BVPSQ0D0dl5gQTfeCJnPyWbUbuWXHSRu1s37L64njep/FhFudcH+Nn+V/6zlXki9x/Nwf6udMFiFG8+uqRnX8f4m/ewr74L9h1JID6Xchuvu2WitV95Z+N2K2eGNMf7BwNaZNNBjSAIpBzO23355OP/302p+cBJdcs5j1jtk7NUiT22O+3EUVGPTg4otAZUCjR/bLgJ9F1kxZISWmlVRF8ZkSCHKZY3AZ431irVINCGMtynhOEnay5Mpqo9hFCQm+D7GMpU6JciQQJdokwGRJk6iX5U8iLGZ7lTVNrsuRmDBJA0cNkkEumDrvuF6caOC8sVjEOF+Jfk0GyJVT4pNtGfDL0q3PYsyd2lpuqLJCy3LLY3Sx1kA+itwoAOS2rnhRCdZo+YqLxEa03EX3apX14buxyut4hdyBaSO5orKdEj3RLvQ/iR+JdAlW9s1+Y5KwfMKk6EKsbM6K49TANdZCpH/LPTduL6uT4vrYPlriFDfIhFRZFAcfxan2Lat3zJDNOTezGKr+sNquUxlsuQbc//RfWVdjCSOFCEj0RVflaP3No/00Snqk38ZYFzomlooJrOptHydYYoZvWduLhHH+HhkU6BfcM8TLxzbl3sDKKjHKNVF4Sb28B7oX5Z4/KhSJ1GZu2/pfi5ZUfiMG6dobY/4/o/NrZUwfQYzEpCoMxm644YZMTOSthxroK/tsrNEp4SYXx3rZNKOwAAaOEqdaKDeihBDK/MgAmAGN6k0qyVG0/mmwqUGz3IGVgCSWxslbQBjo43rGH388D4kCPY81R5V0R7GDsibFDKkx+QuLXDZZZAXUoF8iSq68kZhYKVo6oqU2DlbkBiyhqYG0yppIFGsgLMFNG9999921jLmatIjJinQcHLv2JwuShLjciqMVlGNUKSAy+qo+qGJmta8YPxwzxqqvKUGORJ36H0TXQbVbTEQVufrqq2vxx7IKR7durgvWV5J4KUaU41fiJ64t/RABGJMT8d0IdI6RyQvFUcv6GGskyiUb65Pqo4LcAWXZ532V0lHiI527vAOiRV6WdQl8xTC3kmE2upzmBWpeKChpFKJE90IzF1Qlc1OpqE66LOr3AuGjGrOg71BJJKx7XKMi4RhLPeVdd2M8b3Rr1iP3gK6P1o0J4vLkPT1iiZE4eSHqJX+rt++8lbfekv+dzj/G52WhDai7HYUo54QnAH2eNlPmen5viogJxEYhWVCsO617vRXX7SKROkhu0TEEpN7Sr/Uarcs9stxyy/Wx5cw4YOFqTBvcdttt6ZZbbskGeRJi/IAr46tKPmhA1ezPUTPDRX+++sNgIIY4xDKHRZVF5WQ0eGLgglsyg07Fo8rSK4GoY827vGlAKTdXWZz0587AK5Z0ievxXK6BGuzFJDSaAZfLarQQKiGTXO40kJX7nWJWldgpxqbKkhgtgLKqNSNaE+VqG2u2MjCnvRXnJqusXI1lqcYlFtGhGX/FvGpwrkkKCSu5nWq/+di/aOmVK6omRaKlNFqkFHOlNpf7tkSrsowiJOU2rc/qWReiN4HcVLWo5m3+uziv5ZdfvuaOrlg8iQV9F5Y8xUpLzKmt+E7EP/uVaOQzxefyPXJ7V/3b2Kc0SAeOEYuh4jJlgY4eArKWx9rLzWqU6poVCdRGLpdyF49uv41cF6PLuZZOu3Ty/fxuyK20yErFMSi5WjPhE0MCGqE+pNhLCXddD85VsboxblfhAjFLsn5jYwIx+gv3pq5z3jU5/zx/vfX7WMXtu1n7tCJyWZRBPm6nOrpY/fkfUhhGnASVu6tKjsmKOEgirVU0MabJzVgarEhQ6bnCP+Tqqwk9raffjEERh8PMKEyGmMHHwtWYNqBWJYMGBsEaxDIoYOCO61b8s2ql/EFcYqIMDTx4VPIXudrhlhytGTHxk6ycEmHRugiy7km4AvvHciUrhYSVXHijlZXji7VRdVwci+J2JXAkKHT+cpXVAFmCTYNdBhiqIcqjLG2sr7aOGT5jNtN8kpeYFVX7jrGasupIgMkNUkJRgyUl9uFzBsOKG9O6EiGyDmnQFM9JIl+WPa0TY241AJfFl/3n6wNK7NI2sV4wC+8jTjUQ5/uY6FBW6EbIKq4+pYFd3lVVx4PAixYejgPr/yqrrJKJUiZ24kSMLEP0DU1SsG/Fh/Ke9i0xSlsr3pRJBM6Nc5JnAAvfqxIutAH7p5SOythEt3aQKJLYj2VrYhtFC2xenLYqAOQurgF3M4utrIYSqZ1y+y2CtmqUqVyJ2+hjRfUpW0WTL7G8jyb7BO0pS3x+27zolOuwrLqa9GpE3rqr5zqufJhA/nk+VrsdJL4bQRsx8Rj7C99N++BtwW9/PGeJH00esR7tgrhlP3kBFZNiQfTiKXqMS9FnkaJ9ivzrvHhTlmr1EcXlN7u+sdZ5/F9gf+2WXTL1if+1xnQbC1dj2gBrT0SDIYmYRmggJMsCwoIBuTL6MuhQHTm57fLHy4BFf+oxuYqKoav8CsTBgMSqBmeyUICSzWgQH+NFIYpVFmb6ldWV9ZQoB0GiLLMaSLKwf7nzavAR49ck7pQIRwP2fOIUiZlGREGYf5RokUWUwRzHHWt7xnhaWXR0HWSx1kBK11oDZw2cENtxEoO2Ysm3cRyMg7LhSqwqsRB9QetxDogI7Y9jwpooKyTiVNcUwUFfkutsRMmJostt2YRCsrBqgMixqa2w+Auuufow/UOJflT+SfVdOR9Q3WJZlpkEwlIck3zxufow+0d4UYJKEyX6XgmPfP+iTSRWdb3yAjW68beK3H6jUG0mUJR5uxtuv0UoYQ9Lkcss11JZ0HVNyrZBUQ3aVkrEyLqsSR5Zylq5DvIMkBdHrOscPTuqWoYkNuXqH0MNNLlXJIyjV0v+s3rv8VsqoaVJSnli5MUqyONCtWQVAjLIaNI0xuTrGuXFUJyEBHmQxEUTdVpH173RhGYvzrGe+C9a+rVeO/s0ppdYuBrTQeHaCogQxASDQrl7MTCLAoKMkYqli4OeOEuvWEe5P8ZYPQkJxYBKJMXSDhK+sjLpj1xCQH/4GpjxvkrmcFyxbI8sbtHlWAIoZrrVYEPWMcX7ya2TRQN3Jc/JI1FdT5zGbRQrxzFidcBypyRJEp8S/2pnjleiTsXnFXMp8Sj3WR45H7kva8BNG2G1RmzFjK8xU2+cOFCcFvuUlTnCdqoNKisK53HfffdNJYrYv8rFcKxcKwbAeZFapoyHXLXlahetGZy7yhpFEQqqr8v5KZ5alm0W2k8WdW2vvsG9RV9Q6RWsp+pDsYSNxKEma+Q2Htsj1k2mXWR91oRJO4Ov6ParyY8ybr+cay+S43BdlLCnKAayaikUuaXnLWStIJf+eO/Uu+9boRVraBRKRcK2kfVWvwFCv8dF91KcmCwD/YgJNU02KUcCE5qqsxsnBOVlQF8uypwcX+v84/P8Ot10WdVEXywNpbYrst4qPEATn3ECU94vWlex6M2EmIheOHpsluk5TlTksz4X5UvQZ/XinC38jCmPhasxbUACJA1mouuVBt+KReVRmWBV2kSuvUqwk3dj0+AhusMpyYlcKvnzY0CuQY0SFSGIlQk1Hl90eVUMH8jqK7c5oUQqfA+fkUBHCWSiO62sj7EsRIyflFiNMWk6TpYYs6rjVRsqvjZvAVMiLA2EGJBHaxyvOVZZSdWuOlZZZ2JMbYx9jGJd1meJVVk2JX7kdsq6XGslP5HIjvF3oAROio2u/SCHQbFiONmXYjwRcFgV8y5vHJOyUrMd12zSpEnZ97Ri5YrfH69VHHhrYK94VcX6MhkQLTu8xzWQi7DiF+VyrXI/yqCtODO56/IZ10GTDBLKEvnaZ5zYif1cbrayGMqDgdfN4i3LuP3qXmrm9qtkXr1w+81D2yoruBLI5VG/bSW7rFxqozW1VQs91zcKVB77ERPHPaiJsVatt/UEbidruPJ99Hf6ve4TrhfXRRMJEjz67VEd4W5Y5aJLsR6L4jWL1gHV/M5b3YvWzwvmKFD1e9QvotDvBnkLcCOR263PjBkmLFyNaQO5HuLWJeuNauttsMEGtbqIDPQRqK0QXcb0x6KBnspAaMCnmV6VUZGA1QBBM74SdLLwxji/WLJFCS9UtkcDVAa9strpGKJQjQNRuWtF4Rqz78o1U+vnxZ0yAnM8iDt9Xz6ZhtyRJV5VOkbHHAfUsYSGhGmsEylLs6zTMcNwtDbSdgguuSwr+RbtXi+7qpB7sqyORcjNmEWZeZWQiEGt3MBjdmJlyORYlcClHrIUS+SpHWJiKmVBbtQ342AzDuhlxWf/XDv6vUSTBn9cf1mT1HfVbjHxVBRR6g+axNGkQswkTX9iMM/10USRkjZVRW6/0fV30Nx+i+B4aXfdP0XHKA+HouPjuuoei8KjFaHG9ctbUWOG62GhjPVWvz9QRUTy33DrrbfWYrW5Jngc8D+iyTr6sjxeBs09s1GtVK67XPLzNKqVmhe18bHV99r9rFdt18vvK6JTophrjUeLMd3EwtWYNkGgnnvuuRP+BPnTxjW18KYLZRViJmANYuTqq3jQ6H4oa4FcDBGrDHDYDxZGWeJYhwEV7zGgYEDPurKcymWLrK24pSmeSi609bJoaqDBd0eBpYFGdOOVhZFBq+oFysKmQbGS/qgup4QnjzE5kF7nrRzR9UzuffHzKDxpM45X8XISP5pskGs1AyzaS3UeiwavMcNxPWuA4jplWa1nmeI7ZVlV8hvOgWuHhZt+pDbRPmSN5ZoqSY3iU6N1CNS3YnItXjcavMXniunT4Dy6RvI5NSVjoiWV7bjgggtqcb+xDIfcw/MZoOWyq0kP3RfAudNO+ZIo0fKtyQOeVxVJylwasyY3cpvkeGNMdq/cfouI7vtFVmBNsrDEckWxBq5EKtewFXdR3TPRiirhMQ60ar0tgjbm3sYzgesWrxN9WZbWsq7bg1wrVX1EIrVRrdRoiewXvRDHjT7rlst20Xl2wnuA32MLV9NtLFyNaRMGarL66Y9WA/yY5VDlT/JlcfIlGfgTQUCyMCCQdSRaMVQ/kUEDlrg4UJUbKmhAxWCWGEEG48r2i0U1usPxvTqOmHhHFhO+j5hNiT8JaVlOo8iTWJFbpFwMVR5GCTh4X6690X1a9WSLEpyobVU+R3Gp0YIoK6REkv6Yo/urBpwcN+ekkkISw8oWrAkGxY4yqIwD/wjbco4IVSUhigMUrRPj0hR7qKRbKhGj2Dadp8rEKAkJ6xdZkNWPWo3djN+hY8y7BKrNJKzVPjFbriYd2EZ9Xf0mWtdVt1aWayXN0oSHauEqdjufPEhu7gzs6Y88qhRTWZQgKp7DoLr9FsF1o+8owVievKVOVnEmq3T9WqlJC1yffNKkfrpwDiNKisU1Y8KH3+4o+OjHyy67bG0SZhCs1PlaqarVPOy1UltBE5/9opHVuVdiugzjMmFl+ouFqzEdQINCidCFF144veUtb5lKCCluqdEgmv3EGB8lf5FI5DUleBB7sZ4qYokBrASIYjsVDyuRKiEYs2NqEC7XZw12ieHFXU2WPQ3wJXRkoZKVViVf+AOTqIrZIvMJUPJ/jLJgyWomMaoEMLHOaxTXss4pYYdKusgtNiZvkkuwBt+yamPdLLI8cg2UwArLNBaS6EYsC7IGdtFSoOOKdVxZlAVYyUliuQa9p+sESuYj4SjLtyYLGg0Y4n4k4GMfiC7part8wpZYakl9ShZwzoX32F6uu3LXjWWclKFW10vIbViiXVb/iMp7sA/6JP1Tcb+tIjfoWD+1jNsv/bKdcjCdQve2Jp+Kfk9Ue5n+wbXiGmEFL3IbzkObKrYwWlP7ZUkedri3lRRL9w4TB3FChvtlxRVXTEsuuWRf2zn+T8UM683Q/0YUqYMguoedQbQ6NxK+Fq6mF/ifyJgOgNUHZBFUjF++9mWeKCiVoTX+SSl2j4EAg9UHHnigZomSG62ytUYX4BjHCAyWJCRj+RtEKWKAgZMSIXEMikdi3zfccEMmJuSmqz8pWTA1YOFY9R2yiOpRf2gSb2zHOck6GMvh8FqJPeROrCRUajMtirlRO0Yrt+IblSVY3813sD5tRntKKOrc1O4SLEoWFK+lEmxFt8pouZRYl7iNtXAjEoXKiKnz0XWXi7UEYRwYRNFflOQkuvSqjST6Y8bLfIbLaAmX0Msn4ZI4ZTusQzE2meNlAE4JG/pRfjCjbYG+zIQB/Sx/r7Ce6s9KrNazdBeh0kJV3H71OEhijXtQ8cJ5d3lZTZUoTKWxmhHj58uWnjGN+x7XKWZwpu+pZJjyAnAfcK+w9FroqYRaFKqtJNqS5V2/+0qsZ0aTfludjcnjXxtj2kSWRv3py52TwXY+ZlCiShZECYK4MCiVGyv7xMVXroAagMtFU+IoDjQVdxUtbYoFlDBV3cpobVN5HbmpyuoVhWIUdnLBRXxEl918sgbFj8r6rO+UezEwyFPG5Ggp1fnoUX+ico2Vy290NVX8Jt8jt1QW1qUNEUkSw4j22G6qJararVGIs43cMjleuVnGTKOgGGXVcYVYS5A2k8Uy776siQCOg0GtXGclqtUmEp2RKjPz2rcmQjQpIkuLLPRCcbJyKZdljmOlTy2++OK1CYZ4XJwT67A9g3k8BrgO+YEy+2Y9xDD3D321VSunSuNUcfvVpM2gWQxUyolFEwcx7pvXav/oxl2EagJ3qvSMmQj3EX2aa5W3hHO9sLLyHjGAcqXnfilKWtRpFMcchWqzSVVQQr0oVPuRCdoYY4SFqzFtIldWWQDjIFGDQ14zSFf8osRZHLjLHZJ9MCt/xx13ZI8xiVGMpZW40ffJuii33JgtFiSGNcCS2JMok/VQYjtm4dV3yNWW74i1SDnXWL8uCkuJnGj1k2U41hdtZA2TS2zMWKzziq6sMQ6Pc+XYKS9BCRmVnYnWRVmeVRpIGZh1/lhLEKscp7LaRlEtkSoRrsy80eIcs4cqvlcCNYp8jpn32JfcWhkAN4szivG9eRGcT37EesqSq5JBcl+MFnUdl66dyiwpcZWEKq+jQI/XS4Nz9kc87o033pi1Y949l21V93aRRRZpqWxN3u1XNXBbcfuVNXUQ3H6LUFI1hA59LyYqUzxzzMxdJDwHpfTMKBK9JOK1UXx3fl3lEmAiRjkHNDHTDcu27o0oUluJY47eM3p0DLMxZtCwcDWmQ0jQRIGG8FS231hzMtYfBcVJqoSFrHFR6EUBCRJ7EpMSBHJLleuwBIfcAFmX7WKNPVnzYgwlzyVSlC01FlsHiVzFkUroRFdVDep03rGUjUSS4mIllhTjK8tudGuNrq18JyJEMX2KcaWtGDDS9iBXWwlKvcf2HBPZPVUXVImxFMsbr4Guldx/lQyJc5TAk2iQ1VVWafYZr40Guopl1iA4uvzGc41ZdnWN4oSA1lGb8VoDV1maOYaY8CpayGMCJol5ZY5WTKnaUd+viQktuha06X333ZduvvnmwvqhEqvEgkusNnI3rOr2GzP+Dqo7I+fBOdEHEatMbOm3oij2O5YPipla46Nd+9pHHiBFmc2bod9k7jfuHcG1wcpaxuW9EfQRTTpKqOaTmRWhfAlRqPajbJMxxpRlMP/JjRkyEJtxIM2A8tJLL80GpIp3lIBTploJDlmOeIxxltE9NGbB1bYSdsrQGwfmMZsoQkJuvRLLEsxsj7tszLSLoGBRFsi8UFSWYQkuuZvqHJUMSoPrWGYjWisljnUeGnRHl1jIC0dZkmTdZP98L4NEDfwRinKlVDvK0ikRrMmDvAWlyMIZE9bI5VrCVEIRopWa48HSGONX9aiJBAl2XfMiMRZrGuraqn0kQDlu1d2VS7kSfSkuNbZrdDmO11LlZJSsSwI8TkTETNOyNMtyT7zqddddl4nk/LnwnewboSqxWk9gVXH7jSJV/WPQiKVnlBGcpV6SJfU3WbbHufRMN9DEWlH5rbIZVfXbyfVisoZJyzjBgEcBWbCrXi9NbuZFaqMJHH13kUh1vzHGDCMWrsZ0AJXw0MKg4i9/+UvNbVcDbw0WFBcpcSXLV3TvlEUvxm3Kgsp6EogSfsoGjBWLRVY3Df4loCBfN1YDLgY2INdQCZponZQILcqSLEtkdOHkmGXJk9iTa6sEkeI+Y9xvbDdZcjnefDZixfvqu5SlVwJSLs4x6UyMPea7ZGGM10DZhGV11nWIGZljrT29rzhR1pULsq6d2iAOaKOLbyyNVE/UKSuzzhuRyHeq7WL7SFRKtMqSrcRPcjfVdckPZjVYZmEwXhb2x3cgVEnWVFSPsorbr2oZaxlEt19dI90rmrTiUdesKKuxaiEidHR97LZZHd3jRe69rSQjisTfsbjo3uEeuffeeyfsl/6JlbVMH9XvYbdrpRpjzLBh4WpMmzAouvvuu2vWO1lRGTBItCmTbhRqDHYYyEt4KpGQRB0oRpLPGMyyrtxJFeupGrFYTiU8EQByT5VoUdkR4Fj4bjK2qkZsHIhJTCjOEjfGWKIkllOJ8ZjKPiwrpEQjx8pnWCFi3Kz2ofeU4CmW44jW4tjmij2NdWG1X8ULc26yiioWWbHFtHWMnZVgVOkZxcjGLMrxeOP7cjFWHGz24xoSGHFtWHSto5U2ki8vEOva0sZy91U9XPU5idFoUZUbNQvtQHkalTyShTS2W/5axPfKFKeXWEWostA348A5uv3KjbmZ26+uySC6/cZJFwnUfBkRrhPXLJ89WdcJkUHcIxNO3OeDdH6DTszoHeNNo4dL9FiIz+M+4qPukVjrWd4lcT3uC/Vlrq/qZwO/N0zYcN81Iy9SeWzF4lskUgfR08AYYzqF/x2Nafcm+m/sZLTiMXhAGGrQI/HFIpGq5DVy51XWUGWalYBlXQZhiD4GvtpesYgMdBm4MODBVVZxjELCmYENQpUBMiJKx83gTkmIonU2L071qOdKMMVxx2yzGsjHLMkxnrIIjk/us9Hyp1IfElg6PoljtqOdFRfLedEeSnKlRDcSSbJksp3q37IvWUE16aBETo3Q/lmXfXAMEh0q5cK1jfVG85bVmHAq1rmV66/EDou+ByR+dRyqo0hbcAwkfqEtNKBtJISiK3a+Pl9cYnKweJxR/DJIl1gtcvtV9uJhdfuNMYUSqfUsYXIXVwbq6N0gyzf3o7LMxu1ibDUUia5WPxul9eNvS/6xzOQKxDj1GK8e49Bb/S3Iw33IfVCU3ChfK5XHVo49Xyt1kO4LY4zpFRauxrSJXG5VFocBKW5+6623Xu0zJTpiUV1OWSHJesvgNgoXCVae87ncVpVAg0ELVi0GuMR0Tpo0qZbYSK6uqgcaY+QQDWQrvummmyaU1ChCCaGiKJeVT65weeuFEi5JyCqeVG6+sUROtKBJhEWLoSzFHIPEAutGMS1XYAlS3iPOUkIpZlcuyqDJ/uq50kW37bjwvizM2k/M4osQYXJAscVxiYmZNCiWpRZxyuQBi2J085ahWItWyZOIm0Mwqs5p2UygMeFVVeRSrNI6xG3m3X7riZEYuxmTxPCZ4nX7IZjoO0XWu0b7kLBV8rEoiFg0wcF50u+4/iSxMhPRhFgUpvrdaRbTGdFkQVwkVLuRwIpru+iii2YTVp2slarfGGOMGXcsXI1pEwZHxDBJRKk+KAJV7luqYSrrJkIVgZJPniOXTwQAlkIN4hUDKJdJ1QXMu+OCRK9iSdmWfSnhiNyVJUrzj3JvlvVU1rZYpzUO/PhMglSDwnw5lVgeRUl9ZLGLlmYdB+dHG3HcGuyx6PjYXnGp2hftI8Gg6xJFnEoUyQ1YxyZrrRIOKeYz70bMcXFMLHyOQBWsi/VMlmyher2ymCoOVddE+4suxvF4NdDmuBCmCFS+g0fasp/JeTg3iW3El7JhN3P7jW7gujckUln6gWIg86VnWkFZtCWuJMTrJe5xWZr/TUzp3s/Xs873oVh+Kp9gTNdAVuzo3htLNcXt8vto9lkr62uyjuOn9nb0kGjWf6JIdekiY4ypj4WrMR1A1lElZGEw8sADD9QEp1wqtWhgJsEnS6wy/io2MpYZYUAjkQtK9hEtj+wPcYeVVkIvH5Op75VFVtZgid1YwiauK2SllYVR1oBotdOgPwpq2gFxo2OBGFOpOEAlGpKAlriUW7DqfCoJFgIwigwdh8SChB7bRXGarw1bD8SZMr9CtHwgHhGsHFcUzxKpcmHURIWEaj7OMWbnlUsgVhu5PrMMgmsg117nwPlIfNeLx1PZjTgh0M9zkKtpswyyRWJFfUr3iRKyqWySBLnWl7eDPCzaEUXDvH7Mqq7ft1h3WdbFZqj9ixIj9dIaGRM9yRrfaqIn10o1xpj2sHA1pk0YsFB/VSJFQuy2226riaiiGCwGbAgTBIriLSVi2EblTFiPAZKsmDEGTpZPWWYlMjXIU+kc7Tc/6FMNUrnWqqyPRK0sIxKxspgpuQ/bcu4S5LLUyuqBdVnJkGRVjTGREt1x+1iih+9DtKtEi9w32S/fgxUSt1wNYGUJlVCtWpuQ4+S8EKz5Uiy0jdyMaRtctckkqmvCdYtCNbq6xjjH6L6IAJZIlRAehAQ9Oh/EO+cSJwu4BvUG5LSNSgb1S0TJJTsuHH+sN1tv/5xPFNwS3Vxjzl2eAJwj1y32Dfqd4tbHJZurYtHjhIDEadnYU4Vb5EVqWRf4bpyPYv9bQb8T0ZrqWqnGGNMe/R8ZGTPkqI5pLEPCgJcMoQyWEa0MXGSdVC1LBmOIIwmbOFiS4OQ5oiFmeZVlh0GQ3NN4P7q1KlOpLIsSwxpIs1+EVb70iIS2Bp16T67OnEuMx5XA1fcqwzDHHGvSAp9z7LLQSrCyf52vYkU5bgQpAjTGDUb33ig2FO/J0o7g47wRoiTCklu1rgmvNfhEtCmDskQdS8waq7ZBwESRynsIG1lSEaqDVM6F81RSKM5JglxuwUqupHOj7enPXK+YuXoQSs/kKeobsvhFkRpFEu1BO+BBIat7RP2Pa0r/67dVvJvUKyvTiktsRJnD85bTXlvkNRGWX8qej37b8rHa4zJxYYwxvcLC1ZgOwCCeAa5iqhjQk6BJ1kJlEWZgy6CI8jIIHz5HqCFgEQYSjorVVEyn3EdlBZW1U9ZRWSmU0EjWJQbcEkxso2Qn+cy2SiKiTMESudFqIgGjBFDRRU/CO1qqonuoas8qvpf9xnq17JN1lPGY/bGeyvnELLqgrM20J4/tugrS9lwTBGt+EMtxIUpof15jhZVIVe3Y6EbKMUmgymIsd2VZggdtQEtfk1CNWakV1ysXb85P8bWcl86pV9bhVkrPtBpfG2Nsi76HduC+rOcKLXdurucoxa2qvFOR9bRVa6OQ50WRp0c/3cO1lC3zpN/Z/DII3hHGGDMO+NfWmDaRiELEaKZebsASeHwu9+GYQVbxjrI4SAAqUZPK3sgNUoJIyUckmIsS4miAz/dEC4IErDLa8jzuO2b/lRBFjGmwH626MRGKXscYU2VSlSjmPaxzGujJWoUQklUPt9vCH6v/ugazqNxNVVR/ESuaLGkxKQyPtD3ihHa69dZba22lMhosWEyV6EnXHSEjd2WWQXUP5HpIrOaTIjGolzswbcB5qH6qrOHdFuCx9Ex8bEU8KUFZFKit1LiUGzRLUcxidO8fJCt5WZQYKW85bTVWM8L9UGQ5jYmRekGs45oX3O2cTzyvQZtwMsaYccPC1Zg2YaAnyxsDW5XGUD3WBx98MN14442ZgEQIKPEQ6yrpkhIE8VyWWWXgjTFe9QZOssAiRBBkfI8G+xwbgzdeqwZqdvP/NxYVYZLfr+Jh4/fHYvcqY8Pz6JKshUEk1irFv9IOrC+0L85ZArII9iWxGuuhlkGZfbUg1MjIzKOuVUwgA4o5Vhwx7cQxRCuz4jqjyy/XblBdRTkXTZpw7vkBvT5HxHMOnAuldmR95/w5x3gdO0W8Ruq3zeq9ConpKFLLiAzuB4QqfbXoO7nOCFXV5B0m9LuQF3LNsj/noS3rWU97aW2U9bTIgtpqFmhRz3o6StZzY4wZNSxcjWkTBjqa7ZcrLYNhSoQgIBUzhRjiMwkcWWyU4AXxo4Q2GjwhGvK1QGNNUAb5uK4Sl6mBt+JB5RYsV1/2yXcrJjYuir9FLOsYVGsy79KrWqagQSNCSPVNlVQq1j7VdhJ+HBPHWwTfjTVPVt4y8L1RpMaSFIgyZcGVtUmxqrLQqVSOrMU6T7mZYjnH+si14poNutWNa4sQlWtzkWukxA1tx3kTmy04f1mOO5UcR54AMSa1VStfrPmqyY8qQoNzZiJJMeZ5uN5ca64xj4NsaeukmFOsZj45Uq+tjUWCW6K7jOAuiqXthzXYGGNMZ7BwNaZNJFYVLyc3XAbFGjhqQMhAGEGG8CEGdqGFFqq5YOYX9qsyMar/yj4RqZS74Tnvx4GcxKrcf/nOaAWUgOQ7EbFY1HD71DoanOp741IkLmLWWcWj5olux8punF9oEyW3aVUMxlhHLfmBOusg7IlfRcBpIkHHjkCmBi/tEQeyEkgxiRLrDIM1JiaMqndN5BquDM9MUkS4BqpLW3WAr2zU+aRJrcQVcnyx1qse24llliu6Ji+K2kXxyPSLXpZYKesKG0VqWTEn62mRmOu19bRT7spFGdN7nYnYGGNM97FwNaZNGAgysJZ4w7Kqsiw8Yq0irpOF95TMhYGoRCaL3HtlBZTVVFl65T4ZY/x4roEf+5NbK98ZM1wqLlHJj/JCpRXkPithhHhGRCuRVFwPcRKFsLYF1pcwQTBzvLzH/rCCRZfjGMcra6qEUF4AqS34HJGK+zGiVe7AEs20v8rrqPwO10klaWg7jmsQ6qa2ilyg1U+K4Fw1QUF/kaUxihU+10RGq0RX6yhSW3VHrVd6plMWPlnaWYpEsyaUmKTot9Cpl0hI93cZ1K+Lysr00nqq+7LdZE+aiOt3HVdjjDH9w8LVmDZRHVQGVghChAHWqtVWWy17ZECsMiEIC8SeBFh05+W5BqdRBMRYRImEWBpHZWOwVkqkKikUAgSR1m4yI303ghBLr5L5cH7RGsRAVFl2VTJHZW90vIqPzVt3opU3P8iV8IzlcBRHrAkAvkMJh2g32iCWZ5ELMiKF9+X2q/jZQXf7Lcp6my/BUy9GmOtP+2iiIcK1ok2KyvKov8niHq3vjSzx9WhWeqZTKLkUS1FyHk1gcN5l3dE7WYYlL1LLJhJSErSi5Ei9FnP1rKdlS8sopKDIejrILtvGGGO6j4WrMW2iQZVc3BQfiqAE3FQlTPVYz1ooQQuKK43xWDwiROTOGMWfyvAgyGTJ7JRAokxM3r2Sc5XVTjGy+YElg+dYtgYkeGQZRXjJWo0gLrLSSZxqYKzESbLuqt1U11blfmRpxiV7scUWqyUXKhLOgw5toHhVHuu53CoLNAvtgFglU3PeYhetz+xLkypVRWnV0jOdgvOTWM1nSc7fO9wn3RZBsS5z3sW3TBkW0O9Av11hi85JS1nradH59ENwG2OMGR6Ga+RmzIAiS6BcHBn033nnnQ3jCyGKBGWuZYAvSyKfs2+JLT6LA26528r1tVODcQaiMSuwYNCKwJRbMt+dFyOKWZWlj2NifURuUdZYZaxlob2UNAnxwaOEarTgRtdhiRRlSVa2ZsQqMbyyprJvhBkCLe+OHJdBsupw7rKq0n71+hPtrMkBzoF1SQ7GhIMEqPoTn6v8EK7ULFWJibtYVHamldIznYB+QPsgVhHzRe1DH1VseTeOSRNSeSFX1tKYTyQUhV2vXdZlES6Kpy2DS8sYY4zpJBauxrSJBssM0hjwISR4DwtkPrMugjSKL2WwBQaGEmuymuUTAilOUVbVTiYL4thUFiRarDguRAEikUF0UQIliW6VjJGglFt0vUF8jEuNMZGKR+Uc8xbqWLJFFlVlAWZ93H9xzy4SoDHerh5RiMnSFV932yJEu0ms5t16QW0US79wXrQJkyUI0XxSJolbxV1XEaX5dlHN314jLwD6KjHRRZY+JdZi6cQ9ko/TjGKujKWxXhkW9bFBiKetYhGuZz0dNq8GY4wxg43/VYxpEwbvCMyYkIgB8zLLLJMNmvNWVYQPg10EHSIMocggkn3gukk5kmhhQQBLrDIg76RYiHGrsa4px4Y44PhiGZi8tVcxitomZlJuNlCOcau0B+0SP8tbbdgvQo7v5FhiXVnEq2I0Y1xmTH4Vl0ZiQ5bdIndTHU8ji21ZQcexKF6VRS7n0UqqCRFZMzlPZexlHbZDxOXbnmOlT+XdyhuJUj0fJMszcK70LwRrkQszxyyxGmOby1AUX10ly220NObLyvTaetqpbMQ6pyKROmh9xRhjzGhi4WpMB0B0qk4ryBoaYzYVR8h7DMKVqIhsw9EKJsuhlm5YLfIiQEIaEYtY5RgQq0sssUQtERIDXSV94nPFqdZDyZLiABlxoYQyfKaar0WZQ+VuKrdLLIaIerlOKnsyVsRoBZUrtlyGiygq99Os9I/gOko0FiFrcZGg1XGq/VkQnErMxRLFhGrLypIdoV3Ylj6VF/psQ7kl2idajAdVlNaDdlHcalF7S5gjVukfZWuE5oVc2TjNvPVUoq7XZZNiaZl2a7kWWYT7cU7GGGNMHgtXY9pECYEYECPEeGQQjRVMVlXeZ1CMdRBBiACTIJXFVlbVqtaiZjCARejIFZjj5NhkWUUM8v2LLrpodkwMeomRlIWRY5d1NB/rJquOBJ/aRLUhFdtKm0Q3RLkYS6jyWjG+qvmZFyS0E9ZVHqsKMNXKrZdRNpb+0ZK33kaxqAzHRZZSCVK5T/Oo2OWiRS7XRQmkeK04Y9obMYFAlSs6QhXrc6sibhChHekn9FPOMw/XnH6KWOWxyIJZT8gpXroMqsFclL231xMAUXTnhXcZ66niaYusp8NSAsoYY8z4YeFqTJswYMTqBRIvCMRJkyZNSBQU3XxVqoYFkdGtuMm8K7AyASv5EQIN0aMSOoqvRKRyXAih/LEp3k+WHL4jJpZR8iW+Nw6o9T3R3ZV9810svCcrYhR2zUq2dANZdGXlLCoJIxGqRVbTKFgRFlovb/nSflTHVLVkOWfaQe+rzZS0ivan3yBugfXUNp3IJN0PYj/lXiqyfHIfIVaj27MmBIqy95YRcvkst/F5P+I0O+WyrIRx/c5GbIwxxnQCC1djOoDcZhksK7vtUkstVRMSKlUjq2q3BUZ0BVbCJ8VQavAr91G5pyIMED8IJVldlOUXIcHgXoKC42c9DajZ/+TJk2v7ZnvElmqmSgAoQzJClUf2QduRUIgsuHnBUs8duJO0Uqe0kQiSGABZ3fMJpPJxgCofpCRbtEuRpYvvp124bvm2oV0V28u+89mShyExDm0ld+kil1auP2KVtlJffOCBB2pCtawb7CDVCM0nfIoW1LIuy0WC26VljDHGjBqDP7IxZsBh4CiBgljgtbICy6qKSOu2C57qWCIEEIK4+apMiBISIZ45FsU78pz3ZA2WpRBUJ1WZdHmu2E72i6VLglbxurKmyqKj9yVUJfBkYSMLLo95OuEO3AlR2gqK/1U8r1yQEaVy4VXcqWraIjDYTlbZfIwtQo76v7LkR9g3EwKqm8ukQZFLLf2tURKpfsW6cr7qp9HlXHHHiH+JfaAdylpPB0nIxdIy7ZTLkcvyIIhuY4wxph9YuBrTJgwaEREMUJX8hrjDlVZaqettq9qkDz74YLr33ntrYlWCQJloZflkII9QZYkDXsWdMrCXwJaoQljGcjWKQ0VYap/sR+0QhWre6sf3cIwccz5Otqw7sFxyiwRpp0Qpx1+UdVcZjrEY0i7R6povXaQJjHxbKImTkt4wCYBgZZ+0Be7lWFQ1mSCLPfuN51mPKqV/8uV/OiX0FF/NdVcyqvy1kthXPeJmbrFFbrA69l4LOVmDiyyoZUrLDJrLsjHGGDNI+J/QmA6gwbYGzN2w7Miyp7IzDz30ULr77rtrmYrjAFmxtRKRiB65KMuSCjpeZe+VRVUJhCQOFO8arVZy+9V3yAJYBPvGCsxxt+IO3EiU6nknRGlRbdL4PLpMY9WkrRFf9QQj28mqSpu1IqA4H/bJknd9pb1JlkX7FAmXWPqnXhKpfpT+YZ/0Ia45FlNZV/NiVJ4J9eK8By2JUCwtkxeoVcvl9DvhkzHGGDMsWLga0wE6PYhGkEhAakE4YU2VEODzKErkjopVDsul3IKVCTgKVu0/ClWQq+8CCywwlZVHbr8Sqs2sonIHRrxEd2Bl2VV9WB75/jvuuKNrorRIoDa7ZkwE0N7El3L89SxnEl+qs9sqEnZ8R/58aV8szyQiaiRkYumfevSq9A9tzv6UCIw2KxLNiDPaikX9q15ZmX4kEcrXG47itGxMbT3rqUvLGGOMMeWZZkq7I0QzNlBvFJdUSrmQIMV0BtVQ1SKhwK2pjMVYV7HI8Xm8ZRn4y/UXocMjA+S8KFP2VRYNxGO91BiXCtHtV0K1FVdFudA+/PDDmcBWnVa5uyKEECwIsqoJqhqJUj2vOpGAOKG9EV4kWCr6eaRtaGeJ1TLiiv2xbwQr+8/vl33iHkx7dxv1L5U3qrco7lRtoe3yC9eYyZUiIcw1I8kSlmOVP4qCrh/W03xpmaoZiWNG7UE4L2OMMWZUscXVmB4iYReFalEMIqIGsYoAlFhVtmJQrCrutRKXcZAst18JYQ2uEahKDhQtedHtV9l+85a+aLkrct2VRRhhlh/4IyhVd7ORG3XeNbWTorQeiGuJ1XqWRY5LLsCKMxVFIk4Wbi20HbG9CFa5lWo9xfbSPpyjyhXV21e9pZX14jqtoH4Ty/wU1aqN1mhl7qWv0T+J9+axX9bTeqVlylpPB8kqbIwxxowjtrialrHFtRyK88vX+mwkoGSpREApflAiQ9lWJQQUUxqz/apeqAbZsV5qJLr9sijhT1GCIz0vEju8h9BSUqE8HCOCTN/RyHU3nm9ZEVZmHdpR8aq4syqJU1xAWZeVLbnedzQCkUrbFIl5zltiftgtc7Qz7UqbcT4I8V6eV1FpGS1VMxIPQkytMcYYY/6HLa7GdAAlTZKFU8mNmsG6iBriAhFSElsMoGX9w8KHWMWFFOGKQGD/1E3le6OrIhZBXkdRJcuSBCICkn3wnQhlJfDJi7Eo/PQ6ij9ZKdme72S/Kv2CIFNNWL3HOenYywrAdqENENha6n0fAlViNcbwli1dIjGfdwcG9o2rNI/dQEnCihauU6PPW12naD1eF2WS7iT1rKet3GuNMhJH66mTIxljjDGDiYWrMW2CuLvmmmuaWv9U6gIQjcQLI24QqIojFAi+mGlXSY7kWhoH2Up2xD545LskUKMlsyp8n/bDMWJZ5ZhVrxZhrXWK3IHZpkxJkE6BqMeyinhslFxIWZfzoqusqFP8qsq90AZMJGg72obriTiuKg5bWWfYUcxtkUBtlCG5WWmZftdzNcYYY0x7WLga0yYIB+IXlZlX78X6i4g9BA1iVaVB8rAuLpYSgliRcBtmAC6LJQN3xKmy3EqkymqEACuTsVSCUwmP9FyveWQdxB/xq4qXjcmDojtwEe1a8lpdB5R9mQXxqGsQ1+OcsHjGzLZF39EqfI/K2bAvJhwEkwtYnmOpH/P/oX8XidOy1m3avCgxkkvLGGOMMaOFhasxHQDhhvVRVlCEKUKP7Mu49OaTMCFAo/UU0YdQZNDOdhJmEQk2lRPBcsfzesJLMaVKlhNjS/W63rayIHIsCG1eI6oRYNo3r3Ff5jgaicxuQhsi4rF04rost2gJFyE3apaixFNVYDKCa1sUv8r1pG24TqNgBe10aRmWslb4etbTbromG2OMMWZw8D++MR0QT1hJeUTkIaQQfDxiqVQZGFlLZbFE7LKd4kCj0IvWQT7XIuuh3IAbZeCtauHDqor1kHPhmKMI5BELIqK1XxZELHUSqrRxvXhVxKPEatXSO3n4LiznuG3nk1FxXWJs7zAQ45ebPTZbpyhBUtmavPSpeqVlxnkCwBhjjDEWrsa0DaL06quvzgQNLqoIGgRqFKoMvBFSuJEi+uqV0GA9RK1Kr8gSmxeonRaNqheLIOMc8iCwEWQcVzepJ4qwWNO+HKMEY34dhA3HqQXRr/qicj9tRYAVrcM+EPK4hCsLsciXs2HSgqXqd1Vdp8r++kW+tIyWMm7uxhhjjBkvbHE1pk0QAXIJliiILr3KIKuSGoobZZBOTCoiS/GWStyj/UaxgfiKNUCL1qn3WO8zhDUiC0FWFFuIGOP4gfMj5rbqd7WyTmxTxatita6XNZa2VGIlrJyy9CHAOwH7kmDOHyPXU7GyfIawNakwzjtvPXVpGWOMMcaUxcJ1CLj++uvTOeeck6688sp0yy23ZG6ciJ6FFlooveUtb0l77713Wm+99fp9mGMLg3CuCW6rqvmJmEFQ8SgLqWJZ+Ty6/YIEV6/gu3C3LYrPzGcHRiwXJZPqhuU6lqypl0FW7Uj7xpI1nYTvR4jGhFuC71VMcz/Iu5Q3e+zlOjEOtZ5XgTHGGGNMFaaZ0m+fMdOQDTbYIF1xxRVNW2mPPfZIP/rRj7o6WFxkkUWyrLgLL7xwZmE0/+PYY4/NRKBqgCoBkgSqEjf1E251ZQcuEmTNsgMX0a7gwZKqLMDxmPLbc0xYphGNilfttABDKCsZVd7Ci2WXtsHVW/GWnRJ7Zdc1xhhjjBlHbHEdcB566KHsEevqDjvskNZff/202GKLZdapP/3pT+mb3/xmJiZPOeWUbLD985//vN+HPJa84Q1vyKyYCCssqggtlbDppwUMlDRKlnqy3QplByZ+leMu+51VQKDK2ourMt+r747HpThfBGs3E0FhTca1mDbivoqlfgYhGZUxxhhjjLHFdeB5+9vfnllT3/WudxUOnIlNxF349ttvz15fdtllmZW2G9jiOlyQHRhBhhUx73bbS0HGd2NRJU4UsVovXhWLtLIAI/y7bWHkmGgfjqlfyaiMMcYYY0xr2OI64Jx99tkNP6euJlbXd7zjHdnrX/3qV10TrmbwGZTswFhSJVSJ/a0XrxozKOetrt2A4yDZEommEPb5WGWVs+nFsRhjjDHGmNaxcB0BNt5449rzO++8s6/HYvoDLq5Y3xGs+ezACDImOIjP7FYyI8BVWmKVWNoiVLIGoarEVb0AKy+u0iyI6gjHgFiljYhlNcYYY4wxg4dHaSNAzPjqOLzxop/uwFh3qakqsVovKzJiMMar9rIUCvG0WFexsubz0GHtpX0oaePER8YYY4wxg42F6whAXKtYccUVK+2jlSzBWPXMeLsDI45x/UWocgx566XAsiurKgKxl8KQ9uH4aJ+85ZfjQKjSPjEJkzHGGGOMGWwsXIcchMThhx9ee73jjjtW2s+iiy7awaMy3QCRSObbIndgZQfuhjswbrayqiKU68WrklBJYrWbLslV3KWx+uIKjGDtlXuyMcYYY4zpHBauQ85RRx2Vrr322uz5O9/5zrTmmmv2+5DMCLgD850Sq7gDF4HLb4xX7Vd8KC7KKmeTbx+SLNE+JF3qpYuyMcYYY4zpLNNMyQd+maFyEd50000zSxyD85tuuil77Jar8Jve9Kb0yCOPpIUXXril9U333IERilxrhGOnvg+3WrkAx7jpCNZKCVVq1vZTDOKyTPwqj91uH2OMMcYY019scR1S/v73v6ftt98+E624ZZ5++umVRatqtDbDiZ+6D9cTd1ey33bbHRjX2hivWi+GGatljFftJ1hU5S6dTwal7MncB1iijTHGGGPM6GDhOoTcfffd6W1ve1uWKRUx84tf/MK1W0fYHRiRiljthDswYlhCFUtukcMFCYwUr8oy44wzpn7DcaucTV5gc3wqZ+PJFWOMMcaY0cTCdch46KGHMvdgHhEYJ5xwQtp22237fVhmgN2BKQkjscrzIhB8fJ+WQRGAuC/TPhx/XmTjqqzsyS5nY4wxxhgz2li4DhG4kG622Wbprrvuyl4fffTRaY899uj3YZkBcwdG4CGEEXssZAUuAkulrKpYWAdF/HH8eBMQv5oX2hwjiZYQrLPOOmvfjtEYY4wxxvQWC9chAWvZ5ptvnm655ZbsNSVw9t13334flhkQd2DEMH1ES72SNcSoYqFErBK7OkhwDnIHzottkkLRPrgDu5yNMcYYY8z4YeE6BGB12nrrrdMNN9yQvf785z+fDjzwwH4flumzOzCZf+UCjEttvXhV9i2xOoiiD0GPdRVBnz8HrKoqZzMoFmFjjDHGGNN7LFwHHFxJyR78xz/+MXu93377pcMOO6zfh2U64A5cJfstNVXlApzPqiuopyqhimgdxPqlzQT9a17zmqx9cGE2xhhjjDHGwnXA2WWXXdL555+fPd9kk03S3nvvnW6++ea66xO3uNxyy/XwCE033YHZByVrEHmIVQRxEQhgxaviDjyo1kkyAqucTb5WLG2icjaDkMnYGGOMMcYMDtNMKfIvNANDWQGy+OKLp3vuuacrx0Kt1wcffDAtvPDC6YEHHujKdwwjnXYHJr5TQpX91YtXxRopy2on6rp2E0Qq7YNozZez4dhpHwT9IFqHjTHGGGNM/7HF1Zg2wRX4zjvvbMsdGLdfuQDjDlwEog7xi1BFsOISPOggvIlfRYjn4VxUzsYYY4wxxphGDP7Id8yxQXzwkZsuolPWQ5IJNXIH5rqSUEmW1bzbrCCZkqyq1C0dBoskFmJcpbGw4jod4fgl6AfdSmyMMcYYYwYHC1djOsCCCy6Yxa82cgfGRZZ4VWUCzrvMCsrUyKpKvOqwgIuzytnkY3GJWVU5m2GwFBtjjDHGmMHCI0hjOgBlW+q5Ecd41Xola4hXlVgtm2m43+DajHX1ySefnOr8OC+sq5zboCaMMsYYY4wxg4+FqzFdqLsrscrzInAjjvGqrWYZHhQQqJwf8av5mFwEqsrZDJPF2BhjjDHGDC4WrsZ0QMRhTZULcL5ua3SXlVAlXnUYLZCN6tPiAow7MAuxucYYY4wxxnQKC1dj2oRY1UmTJtV1IZZYredOPAyQ9VjlbPLleYjJVUKqYUgeZYwxxhhjhg8LV2PavYmmnz6L5SRLMFZUrKkSq1hZhxnVpyWpVB7OEcHK+RpjjDHGGNNNLFyN6QALLLBAZokkbnXY4lXzcB5YVhGsWFrbqU9rjDHGGGNMJ7BwNaYDYF0ddohZRawSw5ov1YNIRawiWoddmBtjjDHGmOHDwtWYMQcXZ5WzyYMbMIIVYT6MyaSMMcYYY8xoYOFqzJhmQn7iiScywZov2YNAlTswiZeMMcYYY4zpNxauxowRlLOhlA3Lyy+/POEzStionA0Jp4wxxhhjjBkUPDo1ZgzAqop1FSsr1tYIZXrmn3/+9JrXvMbuwMYYY4wxZiCxcDVmREGgqpzNM888M5U7sMrZUMrHGGOMMcaYQcbC1ZgRg4zAZAbGHfjFF1+c8BkZgeUOPOw1Zo0xxhhjzPhg4WrMiIBIVTkbarFGZp555lo5m2mnnbZvx2iMMcYYY0wVLFyNGXKefvrpTLDiFpxnzjnnzOJXeTTGGGOMMWZYsXA1ZgjBoqpyNs8///yEz7CoqpwNllZjjDHGGGOGHQtXY4YIStjIHZjSNhFiVhGr8803XxbLaowxxhhjzKhg4WrMEPDss89mgvXJJ5+cqpwNWYERrGQJJluwMcYYY4wxo4aFqzEDCgIVoYpgRbhGEKjUXSV+lTqsxhhjjDHGjDIWrsYMGLgA4wqMYMU1ODL99NPXytnMMMMMfTtGY4wxxhhjeomFqzEDAkmWEKskXcqXs5llllky6ypWVpezMcYYY4wx44aFqzF9hjI2CFbK2uQhbpX41TnmmKMvx2aMMcYYY8wgYOFqTB/Aoip34BdffHHCZ2QEVjmbmWaaydfHGGOMMcaMPRauxvQQROpjjz2WidZXX311wmeIVMQqotXlbIwxxhhjjPkfFq7G9IB///vfafLkyempp56a6jPcgIlfnXPOOV3OxhhjjDHGmAIsXI3pYjkbEi3hDvzcc89N+IwES/PMM09mYSXxkjHGGGOMMaY+Fq7GdBhK2OAOzEJpmwglbBCr8803X1baxhhjjDHGGNMcj5yN6RBYVVXOBmtrZLbZZssEK+VspplmGre5McYYY4wxJbBwNaZNXnrppXT33XdncawRBCrlbIhfRbgaY4wxxhhjqmHhakyb4P77wgsv1F6TEfi1r31ttsw444xuX2OMMcYYY9rEwtWYNsGyikh98sknM+sqSZdIvmSMMcYYY4zpDBauxnSABRdcMC200EJuS2OMMcYYY7qAzULGdAAnXDLGGGOMMaZ7WLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgWb6fh+AMaPEt771rWwxxhhjjBkXPvGJT2SLMd1kmilTpkzp6jeYkQFB9vTTT6c555zTP045HnjggbTooov258IYY4wxxvSZ+++/Py2yyCL9PgwzwtjialrGM2mtscACC6TpppvOPcuMDa+++mp65JFHsufu/2bccP8340zs/8Z0GwtXYzrMdddd5xlHM7YeB+7/Ztxw/zfjjD3OTC9xciZjjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDTTTJkyZUq/D8IYY4wxxhhjjKmHLa7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2NMQw4++OA0zTTTZAvPjTHGGGOM6TUWrqavPP300+m0005L++yzT1pttdXSwgsvnGaaaaY0xxxzpMUWWyxtuumm6bOf/Wz605/+5CtlRpp77rmnNkHQqWXcJhruvvvu9Mtf/jIdcMABaeONN05zzjnnhPYwg4v7f3s8+eST6fTTT08f+chH0rrrrpte97rXpRlnnDG7B5Zeeum08847p5/97Gfp5Zdf7tAVM53E/b86zz//fLr00kvT1772tfSe97wnrbnmmln/n3nmmbPxJM+5Jz75yU+mG2+8sYNXzfSD6fvyrWbsee6559K3v/3t9I1vfCP7w83z0ksvpX//+9/p/vvvTxdddFE6/PDD03LLLZcNxPkDHsZBaDzmKVOm9PVYjOklDCoQkrDhhhtmrzvJww8/nFZZZZX0+OOPd3S/xgx6/+d/cpdddknnn39+9r+ZB6H6zDPPpLvuuiubJP7CF76QTj755LTBBht07BiM6efv/zHHHJM+/elP1/38scceyxYMIN/61rfSTjvtlI499tg0zzzz+MINIRaupufcd9996R3veEf629/+NuF9LKxveMMb0mtf+9r06quvpkceeST99a9/TZMnT84+v/3227PZNMQsFhVjRgksI/vuu2/Dda699tp03XXXZc8XWmihtP322zdcf6211krjwIsvvmjROuS4/1cXrmefffaE9+aff/70xje+MS2wwAKZcP3LX/5S+7/FsvfWt741/fa3v01vf/vbO3DlTCdw/+8Ms846a1pxxRUzL4O55547vfLKK+mBBx5IV199debhB0zg3HLLLenKK6/M2t0MFxaupqfwp/nmN785E6WyQjJb/LnPfS69/vWvn2p9LJPXX399OvroozM3p//85z+ZtdaYUYPZ3+9973sN18HjQMJ12WWXbbr+uDH77LOnNdZYIxPsb3rTm9ILL7yQ9txzz34flmkB9//2eM1rXpP22GOPtNdee6VVV111qs8ZpPM57vQM5nfddddsMhiRa/qP+391+C/8yle+kjbffPOs708//dTShv8CvPw+//nPZ+PIm266KRt3+j90+LBwNT0DN6YddtihJlqJPzj11FPTdtttV3cbhC0D0FNOOSWzsiJyjTEmwuD75ptvzmbap532f6kbOu2SZsygQRzrl770pSx+r5H1aL311ksXX3xxNrDH8sTCQJ64QGOGmW233TZbGsF48zOf+Uw2Dj3ooIOy9xhXEq7GZ2Z4cHIm0zOOPPLIzHoqiLNpJFrzrLzyypm7x2abbdalIzTGDCOzzDJL5rERRasx42KpO+SQQ1pyeVxiiSXShz70odrr3//+910+OmMGi/e9732158R+33HHHX09HlMe/8ubnmV9++53v1t7/c53vjPtuOOOpfcz22yzpbe85S11P7/33nuz2ed11lkns8IwG80jr5llIz62GVhplIV0o402qr3PbDWJoZZaaqlshm7eeefNElzgalIvU2PcV6ReFlhcqYuyDDLgiC5fZGFeYYUV0lxzzZV9vv/++xd+/3nnnZf9UJPYioENA/zFF188i4086aSTnGFyxLn11lszdyhcZ3U/EEO+9tprZ/fJQw891HIc3fe///209dZbZ7HoxBHNMMMMWf+jHxKz/tWvfjWzehaVUlJiDrjssssK+37s48a4/3eH+P8Z/2/M6OHf/6nh/y+CeDVDxhRjesApp5xCGt3acuWVV3b8Ow477LApM88884TvyS98fvjhhzfczyWXXFJbf8MNN5zy4osvTnn/+9/fcL9rrLHGlMcee6zhvlpZ7r777tq2PNf7iy++eHYcH/zgBwu322+//SZ87+TJk6e89a1vbfp9yy677JTrrruuYXscdNBBtfV5bvpHvBb0zXq88MILWV+ZbrrpGl7/WWaZZcrRRx/d8DuvuuqqKQsvvHDLffjll18uPN5mC3280+TvPzPcuP+3z5lnnlm7H2adddYO7NH0Cvf/9rnhhhsm/Cc89NBDHdir6SWOcTU9AWulwGLTyGpahY9+9KNZSvSYpAUrD1kViam95JJLMqsRAfrEOfDeUUcd1dK+P/CBD2RuzbghYqnCwkRwP27Lt912W7bODTfckCW+OOeccyZsS11aZYqNx1cve2wjd6+Pf/zj6Qc/+EH2nNIfxCph9SLBRnSRJAsz7XvnnXfW3iPDHsdOTTOy6V1zzTXZ+5MmTcra6dxzz+34NTH94dlnn82SVPzxj3+ccP2pbUcClyeeeCL7DGsrnhAf+9jHsng3LLN58FBgX5qVpr8Rc77MMstkVle+C6sN2b+VsTGCpZe+/uCDD6YzzjijYTZkPBiMcf/vLiSlEYsuuqg73Ijh3//6EN/K+E9Q23XBBRfsyXUxHaSnMtmMLUsvvXRthmuHHXbo6L5PO+20CTNo733ve6f861//mrAOr3fbbbcJ6/36179uaqWZaaaZssc3velNU2699dYJ6/3nP/+Z8u1vf3vCPi+77LK6x1nW8hMtrrKcLbroolMuv/zyQgub2HLLLWvbzTbbbFNOPfXUqdbHyrrUUkvV1mO/Tz75ZOFx2OI6XDPue+yxR22d5ZZbLuvPeV555ZUpxx57bK1/07+wrObZf//9a/taf/31pzz44IOF34mV9dJLL52y6667Zvtu5sXQK2xxHS3c/9vj1VdfnbLCCivU7sV99923Q1fG9AL3//LgqXbPPfdM+clPfjJltdVWq/X9OeaYY8qf//znLlwl020sXE1PmH766Ws/GAcffHBH/4iXXHLJCaIYQVkE72+77ba1dRHTbN9ssIs77TPPPFP3GN797nfX1v3Qhz7UFeEqt67bbrut4TYXX3zxhG3OPvvshvufa665ausecsghhetZuA7PwIVJjdi/i9zXIyeeeGJt/S222GKqz9dcc83a55MmTap83BauphO4/7cHYQG6n6eddtopN998szvmEOH+3xrNQmSY0L3pppu6fLVMt3ByJtN1cCGkbpygKHSnOP/887O6dEDiGRJA5RMhCd7HXRd3R8CV9oILLmj6HYcffnjmetxKlrprr702dQvcoUmy1Ai5EsM222yTJdOpB8lwonsoyXf+v742w8q3vvWt2vNvfvObab755mu4/nvf+97M9V2JvB5//PEJn0f333xSC2MGDff/+vz9739Pn/3sZ2uv995778La6WZ4cf9vzHTTTZeNebgXqFJhhhMLV9N18lnbGonAdmJnt9pqqyymtRHEnG6xxRa118S+NoLswWRMbcTqq6/ekyyNZDRuRjyfKKjrQbF6xcc+/PDDtZhdM3wwOaSJGGKl3/72t7e0nTL+MmkR42LzMXBMbBgzqLj/1+epp57KSs+R5wGWXXbZCSLHDD/u//+DvApamJx961vfmuaYY4706quvZtnvqfdNXg8znDg5k+k6/GBE9OfZCW688cYJgfatQBKis846q5ZUqRHLL798zUJbj5hUpihBTSfgGEjI1AgS4Dz66KOl2gMrGlbcf/zjH7X2kAXODBd/+9vfssQc6i/77bdfS9tdd911tef5clGUrNLkEEktEMa77rprVkt5kUUW6ejxG9MO7v/FkJBw2223rdWrZFLrV7/6VUcnkE3/cf//H9/5znemah/+G/G4owwc9wLeaCeccELac889e3qdTPtYuJquwx/l9NNPX3MXZva3Uzz22GO159QnbYVYL/Kf//xnw3WpU9mMKGyjS3QnIRssbdhqW1CvtVXXTtpDwrVZe5jBJdZkxeU3ZrFulSeffHLCa+oFMzOtjMAXXXRRtig7+Prrr59ZbBkYN3NLNqabuP9PDf9HO+20U7r88strHkRnnnlmesMb3uDOOGK4/zdmttlmSwcccEDmbfDOd74zqwzxoQ99KPsPW2qppXp0lUwnsKuw6QlRVFKOpVNE6y0/TK0Q12tWfLpevGyvQYh2oy3y67oY9/Dyr3/9q+195CdeiAn6zW9+k44//vi00korTfjsvvvuSz/72c8ycUuJGx4ptWNMP3D/nwgDc9wkEarAxOfpp5+eNtxww75cH9Nd3P9bg1JsuA7LG+HYY4/t6nUxncfC1fSE9dZbr/ZcNUQ7QXR3kptkM+J6eTfmYaZKW4xye4wbcQICi8p/s8aXWg4++ODCyRsSuZDQghjoH/7wh5l7VZylfvnll9OPf/zjrG5rtPwb0yvc/yeCNYmJJSCPwSmnnNJy3LsZPtz/W4dQF5HP62AGHwtX0xM22WST2vN77703XXXVVR3Zb3SHxQLUCjGB0ii5N8a2eP7551t2+x3V9hg35p9//trzRx55pCvfQTz0+9///nTSSSdlWbkRsp/4xCcyyyzw3iGHHNKV7zamEe7//+PjH/94+tGPfjQh2/wuu+ziDjTCuP+XC70S+Uz6ZvCxcDU9YYcddpggijqV0TBm9G1VDMf11lhjjTQqkDH5da97Xan2QNzefvvtI9ke48Zqq62WZppppuw5SbqUjKWbIGQpuxPFqlwTB9Hl3owu7v//n89//vPp29/+dq1djjrqqMyN34w27v+tQwUFMc8883TlepjuYeFqehaj+X//93+117/+9a+zpSy4tUZBFi2555xzzoSsuvUSGPzhD38o3L7bkBgjulZ2A5U2AaxizWAdYqGAOEWyKJvhvcdif+5l7A41g8XkyZP70vfNeOP+n9JXvvKVrNyHOPTQQ9P+++/f1+tieoP7f+ucffbZteeUxjHDhYWr6RlkdIsWvd13371WlqYVbr755rTOOuuk888/v/be2972trTkkktmz1988cWGf9LE8H3sYx+rDZyXXnrptOmmm6ZeEcvmULqmG3zwgx+sPf/tb3+bzjvvvLrr4rLNQCdua8vYcHPggQfWnh999NHpwgsvbHnbIvfiVt3NYxmdaPXvZd83Zpz7PyVAvvCFL0z4v/3iF7/Yle8yg8k49n+MGSRZapXjjjsuXX/99bXX73rXuzp6PKb7WLianoEbI1kN9cNGHCZF0ffYY49066231hWb1JkkGcyqq66aidcISScOP/zw2utTTz01i8HL14olW+5ee+2VZUgVRx55ZLZ9r1h55ZVrz2mHbllct9xyy9rrd7/73YXf9ec//zkT7SpNtOiii06wiJvhhIyhqktHhmBq1X3ta1+rWzuZP3xK3VDOJlpNBSVvmNC47LLLapb5PAwCmBASsf8JJpdmnXXW2oRJrB1rTKcY1/5PPUriWsW+++6bjjjiiI5+hxl8xrH/T5o0KS2zzDLp61//+lR1yPPCnHuEe0NQCscJy4aPaaagDIzpISQDesc73jGVCKWeKNlQiYV99dVXsx+av/zlL1O5Hn7jG99In/zkJye899GPfnRC3Uqy4yLiSFiA+zC1J+OPN5ZZYn+KuPTSS2sut/wR8LoZ0VJZ75YiWcYHPvCB2vobbbRRev3rX1+LS1R8khIH0E6yJlNOKCZRagTt9Za3vCVLlCOoXbb22munGWecMStHRGZnHSfZCLHMsk0RZJpVDONBBx1UmHnW9IZ4Ler1TTwPGIREzwQGDVx/BiL0NyYs6B/cg6wPa6655oSZ6Hy/5p4ijoq+SJ9hNp76v2QbjgnCuGdxO8+z6667pp///Oe149liiy2y41FiJ2KNPve5z1VuGwrL5+NruefjfcDkVx7cKYsGbWbwcP+fmptuuim7LyUsuDcRL616z+y3337Z/4MZfNz/p4b/m5jrhHEkRgLGkfzXPf3009n/1N/+9rdsXCkIi7rkkkvSggsu2KOrZzoGwtWYXvPMM89MOfTQQ6fMPffcqKeWllVXXXXKb3/727r7/PKXvzxlpplmariPmWeeecpXv/rVhsd2ySWX1NbfcMMNWzqf+B31eOmll6ZssMEGDY/v7rvvrq3Pc72/+OKLTynDI488MmWTTTZp2qbLLLPMlGuvvbbhvg466KDa+jw3/SNei0Z985VXXpnyxS9+ccqss87a0r01wwwzTNl3332n2s/ss89e6v689dZb6x7TPffcM2WBBRaou33ZPp5nzz33bPlY43LiiSe29b2md7j/N/6/qrKwvRkO3P+n5uabb54y7bTTttzfWff973//lCeeeKIPV9B0guk7J4GNKVdzlPgb3FNJqnTBBRdk7qtYR5944onMMogFZoUVVsgsRbgUN8t4S3wPcbPHH398ZkG8++67M8vS3HPPndWc3HzzzbPsilh5+sEMM8yQxZxQ75LEVFi7ONeXXnqp49+FpRkr87nnnptOO+20dOWVV2YWbOJ7cdVmhpI23W233bLjMqMFVkwsibhwUb+RfoelHSspfWDOOefMLKerrLJK5l2w1VZbTSinFEsFXH755ZmrGO5duGVh0cfFDKvpIosskllqiRPCatnI9Z7v++tf/5q+973vZdZgslnjwo9LmzHu/8b4978seK0xtmEMSeJOLKt33XVX9t/Ffx2eQsTY8l+HVxlloajAYIYXuwobY4wxxhhjjBlonJzJGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuJq+sv/++6dpppkmzTrrrOmBBx7w1TBjhfu/GWfc/8044/5vTHksXE3fuPnmm9MxxxyTPd9vv/3SIossMtU6G220USZstSy22GLpxRdfbGn/Bx98cG27nXfeOQ0CJ5100oTzKbtceumlhfvl/bL72nTTTXt+/uZ/uP+7/48z7v/u/+OM+7/7v6mGhavpGwcccEB65ZVX0myzzZY+9alPtbTN/fffn37wgx+kcWWBBRbo9yGYDuH+Xx73/9HB/b887v+jg/t/edz/DUzvZjD94I9//GP6wx/+kD1///vfn+add96Wt/3qV7+a9tlnn8y9eNhYccUV07777tvy+r/61a/S5MmTs+drrrlmWmGFFZpus9BCC6Xtt9++6Xqt7Mt0B/f/1nD/H03c/1vD/X80cf9vDfd/U4SFq+kLhx9+ePaIy+pHPvKRUtsi5L773e+mz3zmM2nYWHvttbOlFZ544on0ox/9qPZ6zz33bGm7ZZddNn3ve9+rfIym+7j/N8f9f3Rx/2+O+//o4v7fHPd/Uw+7CpueM2nSpPT73/8+e77BBhtkQqsV1llnndrzr3/96+npp59Oo8wvfvGL9NJLL2XPZ5hhhrTLLrv0+5BMB3D/bw33/9HE/b813P9HE/f/1nD/N/WwcDU958QTT0xTpkzJnu+0004tb7fbbrul5ZdfvjYb981vfjONMieffHLt+dvf/vY033zz9fV4TGdw/28N9//RxP2/Ndz/RxP3/9Zw/zf1sHA1PednP/tZ7fl2223X8nbTTTddOuSQQ2qvjzrqqPT444+nUeQf//hHuvbaa0u7CZvBx/2/Oe7/o4v7f3Pc/0cX9//muP+bRli4mp7yt7/9Ld1333215EALLrhgqe133HHHtOqqq2bPn3nmmXTEEUekUeSUU06pPX/ta1+bttpqq74ej+kM7v+t4f4/mrj/t4b7/2ji/t8a7v+mEU7OZHrKBRdcUHu+/vrrl96eZE5f/vKX0zbbbJO9JgnRxz/+8dICeJD5z3/+k37yk5/UXr/nPe/JYlxb5fnnn09nnXVW+utf/5q5VFNuaP7558+SQq2++upp+ul92/cL9//muP+PLu7/zXH/H13c/5vj/m+a4RGs6SnXXHNN7fkb3vCGSvt4xzvekYkw9oVI+8pXvtJWFt1zzjknWzrJ7rvv3nL24DwXX3xxeuCBByq7CeNiLGFfVCoHob/ffvuVEsOmM7j/N8f9f3Rx/2+O+//o4v7fHPd/0wwLV9NzV5lO1BE97LDD0mabbZY9p2TMpz/96bT44otX2hdC75hjjkmd5I1vfGNl4RqTEqyyyiqZlbRTPPTQQ1lb/frXv05nnHFGZok1vcP9vznu/6OL+39z3P9HF/f/5rj/m2Y4xtX0DDIJ33vvvbXXiyyySOV9bbrppmmjjTbKnlMy5tBDD02jwL///e/029/+tvb6ve99b8vbEgtLTVy2v+uuu9Jzzz2XXnjhhew5fwZvetObauteffXVmeUai7XpDe7/zXH/H13c/5vj/j+6uP83x/3ftMQUY3rEk08+SQ2c2vLoo4823WbDDTesrX/cccdN+OzKK6+sfTbddNNNuf322yd8ftBBB9U+32mnnaYMAyeeeGLtmKeffvopjzzySEvbPfPMM1NefPHFhuv85z//mfLFL35xwjX48pe/3KEjN81w/2+O+//o4v7fHPf/0cX9vznu/6YVbHE1PePZZ5+d8HrWWWdta39vectb0pZbbpk9f/XVV9NBBx2Uhp3oJrP55pu37Mo7++yzpxlnnLFpYiss0yR7Et/61rfSK6+80sYRm1Zx/2+O+//o4v7fHPf/0cX9vznu/6YVLFxNX11n2oVYVwQZnHbaaemmm25Kwwpu1JdddlklN+EyRLfqJ598MnMbNr3H/X8i7v/jhfv/RNz/xwv3/4m4/5tWsXA1PYOyLJFOxFeuscYaafvtt6+lUf/iF7+YhhVK4OjP7DWveU0Wg9oNll566bTEEkvUXt96661d+R4zEff/xrj/jzbu/41x/x9t3P8b4/5vWsVZhU3PmGuuudLMM8+cJQyCf/7zn1lCoU5YEMmQi3D93e9+l6677roJiYiGpRxOLLq98847p5lmmil1C+re3nPPPbXrYLqP+39j3P9HG/f/xrj/jzbu/41x/zetYuFqegYuvVj6/vGPf2SvqVW64oortr3f17/+9Vnc5k9/+tPs9Re+8IV03nnnDVU5nKuuuipNmjSp627CRfE2+Zlg0x3c/+vj/j/6uP/Xx/1/9HH/r4/7vymDXYVNT3nDG95Qe37bbbd1bL8HH3xwmn76/z8Pc/7556fLL788DRNxtpH6tmuttVbXvosyObHtF1pooa59l5mI+38x7v/jgft/Me7/44H7fzHu/6YMFq6mp0RB9te//rWjcZt77bVX7TVW1zKil9jSTi5lLKYvvvhillhK7Lnnnqmb/PznP8++U7PAG2ywQVe/z/wP9/+pcf8fH9z/p8b9f3xw/58a939TFgtX01M222yz2vMrr7yyo/smMZPiQq+44opS7sL9hLjcp556Kns+7bTTZvGxZS2oxPe2Au7In/nMZ2qv3/a2t6XXve51JY/YVMX9f2rc/8cH9/+pcf8fH9z/p8b935TFwtX03FVmscUWy54T6/rwww93bN+LLrpo+uAHP1h7PSxlXmLtsk033TQtvPDCpbYnRpc43+OOOy49+uijhetQ55YY4De/+c3p8ccfz96j7usRRxzRcN8bbbRRZpVl4blpD/f/qXH/Hx/c/6fG/X98cP+fGvd/UxYLV9Nzdt1119pzsgF3ks997nNp1llnTcPC5MmTs5jcdt2EmQT4yEc+kmULXn755dM73/nOtM8++6QPfOADaZtttkkLLLBAZsmVaJ1uuumyuJJVV121Y+diWsP9/3+4/48f7v//w/1//HD//x/u/6YKFq6m5xCLigUPYmxnJ5h//vnT//3f/6Vh4Wc/+1l65ZVXsudzzjlnrSZtVXAZvv3229Nvf/vb9OMf/zj96Ec/SmedddaEkjcIW5JX7bTTTqWKpCN2Tfu4//8P9//xw/3/f7j/jx/u///D/d9UwcLV9Jxll102bb311tnzyy67bEIZmE5wwAEHZDXThs1NZscdd0yzzDJL6X2sv/766frrr09HH3102mWXXdIaa6yRFl988TT77LOnGWaYIc0333xp9dVXTx/60IeyerW33nprWnfddVsSrTfffHPt9W677Vb62MzUuP//D/f/8cP9/3+4/48f7v//w/3fVGGaKdGkYkyPoG7XW97yluz5fvvtl7797W+77QeMG2+8MRPBstL+/e9/t9W1Q7j/Dz7u/93D/X/wcf/vHu7/g4/7/+Bii6vpC1j8ttxyy+z58ccfX4u9NIPDxRdfXHt+6KGHWrR2EPf/wcf9v3u4/w8+7v/dw/1/8HH/H1wsXE3fOPLII9P000+fnn322fSNb3zDV2JAf7hxM95hhx36fTgjh/v/YOP+313c/wcb9//u4v4/2Lj/Dy4WrqZvrLzyymnffffNnn/nO99JDz74oK/GgEDCKGrhwmGHHVZLpmU6h/v/4OL+333c/wcX9//u4/4/uLj/DzaOcTXGGGOMMcYYM9DY4mqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RiTXnzxxbTEEkukaaaZJm222WZuETNWuP+bccb934wz7v/DhYWrMT3gX//6V7r44ovTEUcckXbYYYeaSNRy0kknldrfwQcfPGH7VpbDDjus7v5mmmmmdMghh2TPL7zwwvSb3/ym7XM2Rrj/m3HG/d+MM+7/ppNM39G9GWOmYpdddkmnnXZamjJlykC3zm677ZYOPfTQdNddd6UDDzwwbbPNNmn66f0TYdrD/d+MM+7/Zpxx/zedxqNSY7rMww8/3FXR+qY3vSmttdZaLa3XiOmmmy596lOfSh/5yEfSHXfckVmB99lnnw4eqRlH3P/NOOP+b8YZ93/TaSxcjekB0047bVpxxRUz8ajlXe96V7r//vvb3vdWW22VuQ53gt133z0dcMAB6d///nf6+te/nvbee+/MzdiYdnD/N+OM+78ZZ9z/TSexcDWmyxx77LFpscUWS7PPPvtUP+aDBse40047pR//+Mfp9ttvT+ecc07aeuut+31YZohx/zfjjPu/GWfc/02nGbyRszEjxkorrTSVaB1kdtxxx9rzE044oa/HYoYf938zzrj/m3HG/d90GgtXM7AQY6mMuO9973tr7//2t79N73jHOzIrJtlwX/e616W3ve1t6ac//enAJ0AaBjbZZJM011xzZc/PPvvs9NRTT/X7kMYS9//+4P4/GLj/9wf3/8HA/b8/uP8PPhauZqhSqm+77bbpne98ZyaoiA996aWX0mOPPZYuuOCCLD6TeM/nn3++34c61JBJeP3118+e0760rek/7v+9wf1/MHH/7w3u/4OJ+39vcP8ffBzjaoaCV155JUtmdNFFF6UZZ5wxrbvuumnppZdOL7zwQrriiivSfffdl6137rnnpk984hPpuOOOS+PC5MmTM2szMakkVZp77rnTIossktZbb7203HLLVdonwpXJAUC4UnvW9A/3//q4/48+7v/1cf8ffdz/6+P+P35YuJqh4Fe/+lV68cUX05Zbbpl+9KMfpYUXXnjCj/pnP/vZ9I1vfCN7/YMf/CCrQ7rEEksU7us73/lOmjRpUkePj/qn88wzT+oH3//+97OliDXWWCN98YtfTNttt12pfa622mq159dee23bx2jaw/2/Pu7/o4/7f33c/0cf9//6uP+PIVOMGVBOPPFEAlZry/rrrz/l5ZdfLlz3P//5z5Q3velNtXUPP/zwuvvdcMMNJ+y3E8vdd99d+vwWX3zx2vacaxkOOuigUse3zz77THnllVda3v99991X23b66aev2+6me7j/18f9f/Rx/6+P+//o4/5fH/f/8cYxrmZo+Pa3v53FHxRBAqe99tprrKyEK6ywQvrCF76QuU9T5Jt41GeeeSbddNNNWQ1W3IXF8ccfn/bbb7+W973gggvWyvVg0X7wwQe7cg6mddz/J+L+P164/0/E/X+8cP+fiPv/GNNv5WxMKzOOSy21VNOG+tOf/lRbf4011hj4hm3H4vrPf/6z6Tr/+te/pmy55ZYTLK9XXHFFy9/xmte8prbd1VdfXer4TPu4/9fH/X/0cf+vj/v/6OP+Xx/3//HGFlczFKyyyipN15l33nlrz59++uk0ysRzrcecc86ZxcYsu+yytfeOOOKIlr9j1llnrT1/9tlnKxyl6RTu/xNx/x8v3P8n4v4/Xrj/T8T9f7yxcDVDgeqKNmKGGWaoPX/55Ze7fETDAeKTRFXi4osvzlyKW8E1cQcH9/9quP+PBu7/1XD/Hw3c/6vh/j+aWLiaoYAYVlONTTfdtPb8ueeeS/fee29L28V6uLPNNpubv4+4/1fH/X/4cf+vjvv/8OP+Xx33/9HD5XDM2DFq5XBaSbQU+ec//znBfbgILNZPPfVU7fUCCyzQteMzvcX93/1/nHH/d/8fZ9z/3f+HHQtXM3b89re/TZdddllH9/mpT31qYIVrPj61FespWYrlKkwm51g31ww37v/u/+OM+7/7/zjj/u/+P+zYVdiYEefGG2+c8HqhhRZqus2tt95ae/7617++bhkiYwYd938zzrj/m3HG/X/08GjUjB2XXnppGidOOOGECSJ0vvnma7rNX//619rztdZaq2vHZnqP+7/7/zjj/u/+P864/7v/Dzu2uBozZPz73/9ueV3K4fz85z+vvd5tt91a2u6KK66oPd9ss81KHqEx3cP934wz7v9mnHH/NxauxgwZ3/zmNzMx+etf/3pC5t/Iv/71r3TQQQelnXfeuRaruuSSS6b99tuv6f5feeWVmnCdccYZLVzNQOH+b8YZ938zzrj/G7sKG9Nlrr/++rTPPvtM9f5DDz1Ue/6lL30pffvb357w+Rvf+MZ0/PHHT7UdQvTCCy/Mlplmmilz/11mmWXS3HPPndVoveeee9I111wzQdTiHnzOOeekWWaZpenxUusV4Qtbb711tl9jquL+b8YZ938zzrj/m05j4WpMD1xbYsxoEffff3+2RFoRjC+++GK64YYbsqUeW2yxRSaAW80MfPrpp9eev+9972tpG2Pq4f5vxhn3fzPOuP+bTmPhasyQ8elPfzptuOGG6aqrrkpXX311uvfee9Pjjz+eLRQqR/BSp3XddddNu+yyS1p11VVL/cn84he/yJ6zDyyuxgwS7v9mnHH/N+OM+7+ZZooC4IwxY89xxx2XPvKRj2Tt8MMf/jC9//3vH/s2MeOD+78ZZ9z/zTjj/j8cWLgaYzJeffXVtNxyy6W77rorLb300ukf//iH67eascH934wz7v9mnHH/Hx6cVdgYk/Gzn/0sE61wxBFHWLSascL934wz7v9mnHH/Hx5scTXGZEmell9++SxedtNNN00XXHCBW8WMDe7/Zpxx/zfjjPv/cGHhaowxxhhjjDFmoLGrsDHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcYYYwYaC1djjDHGGGOMMQONhasxxhhjjDHGmIHGwtUYY4wxxhhjzEBj4WqMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDQWrsYYY4wxxhhjBhoLV2OMMcYYY4wxA42FqzHGGGOMMcaYgcbC1RhjjDHGGGPMQGPhaowxxhhjjDFmoLFwNcYYY4wxxhgz0Fi4GmOMMcYYY4wZaCxcjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDzfT9PgAzPHzrW99KTz/9dJpzzjnTJz7xiX4fjjHGGGOMMWZMmGbKlClT+n0QZjhYZJFF0oMPPpgWXnjh9MADD/T7cIwxxhhjjDFjgl2FjTHGGGOMMcYMNBauxhhjjDHGGGMGGgtXY4wxxhhjjDEDjYWrMcYYY4wxxpiBxsLVGGOMMcYYY8xAY+FqjDHGGGOMMWagsXA1xhhjjDHGGDPQWLgaY4wxxhhjjBloLFyNMcYYY4wxxgw0Fq7GGGOMMcaYSjz44IPpzDPPTA899FBXtzHGwtUYY4wxxhhTmpdeein97Gc/S9ddd132yOtubGMMWLgaY4wxxhhjSoP4/Pe//53+9re/pWeeeSZ73Y1tjAELV2OMMcYYY0wpsJT+8Y9/TI888kj617/+lT3yupEFtco2xggLV2OMMcYYY0wpZDm999570zTTTJM98rqRBbXKNsYIC1djjDHGGGNMy0TL6YsvvphWWmml7LGRBbXKNsZELFyNMcYYY4wxLRMtp6973evSa1/72uyxkQW1yjbGRCxcjTHGGGOMMS2Rt5wuscQS2fuLL754XQtqlW2MyWPhaowxxhhjjGmJvOV01llnzd6fbbbZ6lpQq2xjTB4LV2OMMcYYY0xT8pbThRZaKL388su1hdd5C2qVbYwpYvrCd40xxhhjjDEm8Oc//7lmOYW//OUvhe3D5wsssEC2PpTd5s1vfrPb3UyFhasxxhhjjDGmKf/85z/Tq6++mpZddtmm67Ie6+t52W2MyWPhaowxxhhjjGnKeuutl/7zn/+kZ599tum6xK+yPlTZxpg800yZMmXKVO8aU8AiiyySHnzwwbTwwgunBx54wG1kjDHGGGOM6QlOzmSMMcYYY4wxZqCxcDXGGGOMMcYYM9BYuBpjjDHGGGOMGWgsXI0xxhhjjDHGDDTOKjzgPP300+mcc85J1113Xbr++uuz5EiPPfZYev7559Pcc8+dVlpppbTVVlulvffeO80777z9PlxjjDHGGGOM6TjOKjzgXHjhhWmzzTZrut58882XfvrTn6bNN9+8a8firMLGGGOMMaZfYMD585//nN74xjemhRZaqO/7Mb3FFtchYNFFF00bb7xxWnPNNbPnCy64YFYPi5I0v/rVr9JvfvObrFjzNttsk6699tq06qqr9vuQjTHGGGOM6RgvvfRS+tnPfpaeeeaZdNttt6X99tsvzTjjjH3bj+k9Fq4DDoL1vvvuq/v5jjvumM4444y0/fbbZzfiIYcckglZY4wxxhhjRgXC5v7973+nv/3tb5mRhtdvectb+rYf03ucnGnAmW666Zqus91226Xll18+e37FFVf04KiMMcYYY4zpDRhn/vjHP6ZHHnkk/etf/8oeec37/diP6Q8WriPCHHPMkT2+8MIL/T4UY4wxxhhjOoaspPfee2+aZpppskde834/9mP6g4XrCIB//l/+8pfs+QorrNDvwzHGGGOMMaYjRCvpiy++mFXU4LGstbRT+zH9wzGuQ8pzzz2XZUQ766yz0pFHHpleeeWV7P3999+/0v5I9NSMV199tdK+jTHGGGOMqUK0kr7uda9Lr33ta7NHXi+wwAItx6h2aj+mf1i4DhEnnXRS2muvvep+/pnPfCa95z3vqbRvshUbY4wxxhjTK5qVpclbSZdYYons/cUXXzwTmrKWvulNb2qYGbhT+zH9xa7CI8Bqq62WlcH52te+lvnrG2OMMcYYM8ioLA3CkcciV928lXTWWWfN3p9tttlq1tJWYlQ7tR/TXyxchwiyB990003ZglA99dRTszI4xLfusssu6eyzz6687/vvv7/pghuFMcYYY4wx7RLL0lBTNS8a81ZSLLIvv/xybeF1KzGqndqP6T92FR4i5p577mwRuDPsvPPO6Sc/+Unac88907bbbpt+/OMfp/e+972l973IIot0pDSPMcYYY4wxVcrSRFddXIhlJQUlIs2jGFXWf/Ob3zzV553aj+k/Fq4jwO67755ZW3/5y1+mj370o2mbbbZJ88wzT78PyxhjjDHGjHmcaqtlafIJkv75z39miUGXXXbZpvtjPdYvOqZ29mMGCwvXEQFrK8L12WefTeeee27lJE3GGGOMMcaUiVPF1ZfyjPvtt1/T5EZ5193Xv/716e9///tUVtf11lsv/ec//8nGts0gVpX1i45pjz32qLQfM3hYuI4IpPQWcoUwxhhjjDGmF3Gqq666akslZVotS/Oa17wmM8y0e0x33HFHpf2YwcPJmUYEXCLE7LPP3tdjMcYYY4wx4xmn2ii5UaOyNJ1IkFTlmMzwYOE6Ipx++um156usskpfj8UYY4wxxow2RXGqzUrKdLssTZVjMsODheuAc9JJJ6UXXnih4TpHHXVUOuecc7LnSy65ZFp//fV7dHTGGGOMMWbcyFtOV1pppaYW026XpalyTGa4cIzrgHPwwQenT37yk+ld73pXFiy+9NJLZ67ABJxTz5Xgc25GIJD9hz/8ocvWGGOMMcaYrtFqnGovy9JUOSYzXFi4DgFPPPFE+tGPfpQtjeqwnnDCCWnTTTft6bEZY4wxxpjxoVGcKuKwqCZrJ8vbFJXcqXpMZriwcB1wzjvvvPT73/8+u9nIijZ58uT0+OOPp1lmmSWbRVpttdXS29/+9rTjjjvW4gSMMcYYY4zpBq3EqRZZODtV3qao5E7VYzLDhYXrgLP88stnyyc+8Yl+H4oxxhhjjBlj6sWpCl4/+uijhRZOlbdpZj0tW3KnnWMyw4WFqzHGGGOMMaYp7captmI9baW8TRSf3Y6dNYODhasxxhhjjDGmKe3EqbZiPW2lvE3e5bfdYzLDg4WrMcYYY4wxpilV41RbtZ5G8i7Ar3/969Pf//73qbZr55jMcGHhaowxxhhjjGmK4lSr0Ir1tEp5m3aOyQwX0/b7AIwxxhhjjDHDCcmWzjzzzPTQQw/VXSdvPV1ppZWyR1lP+bzV8jaNtjOjjYWrMcYYY4wxpjRKtoT1k8d6QrKR9ZT3+bxseZui7cxoY+FawJNPPpnOPvvsdNxxx6WvfvWr6dBDD+39lTHGGGOMMWaAicmWyBRcJCTLWk/rlbfRwmtbXccTx7gGrrnmmkyknnfeeWnKlCkTGupLX/rShNeTJ0/O/OkJBiel9ne+853eXDFjjDHGGGP6TKvJllqxnsaYVZe3MfWwcP0vhx9+eCZOSZOdF60EkOeZf/75s5sMn35mmdh23nnnrdvQxhhjjDHGjAqtJFuqZz0VvH700UcniF6XtzH1sHBNKR1zzDHpc5/7XK1RVlhhhbTxxhtnN971119ft/H22muvTLhyA55zzjlp9913r7uuMcYYY4wxo0CrpWqqWE9d3sbUY+yF68MPP5wOOOCArDFmnnnmLK51zz33zF5/7GMfayhct9hiizTTTDNlN+8ll1xi4WqMMcYYY0aeVkvVVLGeuryNqcfYC9fvf//76fnnn89cHI466qiaaG0FROvKK6+czQ7ddNNNLW9njDHGGGPMMNIo2RKCNVpdbT01nWTshSuJmORj/4EPfKB0Ay699NKZcJULhDHGGGOMMaNK2WRLJDMdxtq0jO/f+MY3ZhrBDAZjXw7nrrvuyqyt3FhFSZiaMffcc2ePTz/9dBcujzHGGGOMMYPBMJaqQYSSk+ahhx7qaG1a03vG3uJK+m6YZ555KjUgNyfMMMMMHb0wxhhjjDHGDBLDVqpGIpQas7fddlvab7/9JpTqaVabdtVVV52QJdn0l7EXrgSAP/bYY+nJJ5+s1ID33Xdf9jjffPN1+NIYY4wxxhgzOAxbqZqyIrTV2rSmP4y9cCWQnPpRzAiV5dlnn03XXHNN5mK80kordeUCGWOMMcYYMwj0M9lS2bjTKiK0ldq0pn+MvXDddNNNs8545513piuuuCKtv/76LTfe0UcfnZ577rmsY7MfY4wxxowfTuRixoV+lappx+W3VRHaam1a0z/GPjnT7rvvnqabbrqsMT74wQ+mJ554oqWGu+iii9LBBx+cPSeb2h577NHVC2WMMcaYwcOJXIzpfsKk6PKLeOV1s/syilA8I5sljWpUm5b3m32n6T5jL1xXWGGFtPfee6cpU6ZkMzjrrLNOOvvss7PX9bIQf+pTn0pbbbVV1umZwfnkJz+Z5p133h5cLmOMMcYMEmUH1MaMO2Une+q5/DbarqwIbVSbdtCyJI8zYy9c4bvf/W5ad911M7GKyzAuEGQZPu2002oNtfrqq6cFF1wwC0Y/6qijspTf8La3vS0ddNBBfbuAxhhjjOkPVQbUxow7ZSd7ilx+G1lAq4jQVmrT2urafyxcU8r81c8///zMbRjxysIf0OOPP16r7crNNXny5NrnsOeee6bf/e53leq/GmOMMWa4KTugNmbc3X7LTvZ0wuW3mQgdxtq044qF63+hU5988snpsssuyyyudG6J1ChWZ5ppprTlllumSy+9NJ144okO0jbGGGPGkCoDamPG3e237GRPuy6/rYjQotq0fKZFtWr1nVUqkZjOMPZZhfOQVZiF2lNYWZk9YkYIITv//POn1VZbLc0888wdan5jjDHGDCONBtQun2HGhTJ1Ustm7W3k8sv3FG1XJEKL0H3K+sNWm3acsXCtA5mGiWtlMcYYY4xpZ0BtzKhRtk5q2cmeVlx+89tVEaH9rE1rymHhaowxxhhTgioDamNGjTJ1UstO9tRz+RW8fvTRR6farooI7VdtWlMeC1djjDHGmBapOqA2ZpQo6/ZbdrKnisvvm9/85qEUoSS34vjf+MY3Zr8fpj5jL1xxEyCb8AsvvJC5FRxxxBGpVQ488MA0adKkNMccc2SJnYwxxhgz2lQdUBszSpRx+60y2TMucadKbkVZoNtuuy3tt99+nuhqwNgL13POOSf94he/yFwcvv/976cyLLPMMunrX/96tu173vOetPnmm5fa3hhjjDHDxbgMqI2pR1m33yqTPeMSd1omuZWxcE2///3vs34wwwwzpB133LFUn2D9j370o+mVV15JZ511loWrMcYYM+KMy4DamHqUdfutMtkzjC6/3U5uZSxca/WfmOWYa665SvUJ1qc8Dvu49tpr3Z+MMcaYEWccBtTG1KOK268ne9pPbmX+P2PvKnzXXXdlnWX55ZdPVVhuueWyDsZ+jDHGGGP6gRO8mEGO8R6XyZ5W78Oyya3M/2fshatcfXBvqMLss8+ePT799NOVtjfGGGPMcNNv0egEL6ZXjFOMd9n7usx9WLamrfn/jL1wnXPOOdOTTz6ZnnjiiVQFbVdV+BpjjDFmeBkE0egEL6ZXjIvbb5X7utX7sGxyK/M/xl64Lrjggpn4rBqjqu3mn3/+StsbY4wxZnjpt2h0ghczLjHeVT0bqmxX9r4ucx+WTW5l/se0acxRh7jvvvvSBRdcUGrb888/vxZQ7RptxhhjzHhRb7DK+/1M8MJrJZ80ZhSQBZR+zWOr91iV7arc163eh/WSW2nhNe/347dkGBh74brddtvVGuPDH/5wy774ZExj/aL9GGOMMWb06bdozA+CV1ppJQ96zVCAFfTMM89MDz30UGkLKO67rd5jVbYre1+XuQ+LkluxjhYlu9J3sr75H2MvXLfYYou05pprZo1x9913p7XWWqup5ZXP11lnnWx9OjQuBOOSLc0YY4wxgyEaGyV4sdXVDCplraBVPRuqbFflvi5zH8bkViuvvHLdhc+HPblVNxj7GFc46aST0rrrrpt1rnvuuScTs3SYjTbaKC211FJZ5mA+Q6hecskladKkSbUG5LOTTz65KxfHGGOMMYNJt7OCNovLc4IXM6yUjR+tWu+0ynZl7+uy9+G4JLfqFhauKWW1k373u9+lHXfcMZvZmDJlSiZOo0CN8DnMM8886Ze//GVaZZVVunaBjDHGGDNYdFs0tpLR1AlezKBQJvlR2WRiVeudVtmuyn1d9j7sZ3KrUWDsXYUF1tUbbrghvec970nTTz99Jk7rLXy+6667Zn7om2yySV8voDHGGGN6SyuD1XZcdZvF5TnBixlWt9+y8aNV3eGrbFf2vvZ92HtscQ0sssgi6ac//Wk68sgj04UXXpiuvvrqNHny5OxPY4455shK3hDbutlmm2VldIwxxhgzXtQbrApek8CxqtW1FYtUUYKXImTtYX1XPzD9dvstawWt6tlQZbsq97Xvw95j4VoAnXOPPfbIFmOMMcYY0e3BaitxeTHBSzOc4MV0i7Juv2XjR6u6w1fZrsp97fuw91i4GmOMMca0SDcHq61apJzgxQwCZZIflbWCVvVsqLpdlfva92HvsXA1xhhjjGmRbg5WW7VIOcGL6Tdl3X7LWkGrejZU3a7Kfe37sPdYuBpjjDHGtEg7g9VG2Vdd3sYME2XcfqtYQat6NlTdziJ0OLBwzUEypuuvvz6r5/r0009PuLGa8aUvfanT18cYY4wxI0CzEjcub2OGhbKTLFWsoFU9G+y+O9pYuP6Xa6+9Nn3uc59Ll156aa1Oa1ksXI0xxhhTNvtqtzMVG9NJyk6yVLGCVrWA2nI62li4ppSOP/749OEPfzib2akqWglKN8YYY4wpm33VZTXMsFBvkoV+PddccxVOstgKajrF2AtXAskRrczwSIByk62++upp3nnnTTPMMEPHGtsYY4wx40ez7Ksuq2GGhXqTLM8//3yaZZZZ6iY/qhoXbkxk7IXrUUcdlYlW/kjIiHbqqadmj8YYY4wxvci+aouUGRbqTbI8/vjjmcEn4hrCptOMvXC95JJLsoZglugPf/hDWnjhhTveyMYYY4wZT1rNvmqLlBkG6k2y3H333WnJJZdsqxyUMc0Ye+H68MMPZ9bWTTbZxKLVGGOMMR3DJW7MqFEv+dFVV12V1l133b4ckxkfpk1jDrNBYEurMcYYY3qdfZXPWc+YYQY3eGO6zdgLV7k14JtvjDHGGFOWBx98MJ155pnpoYceapp9VQuveV+xrqxvzLBi4Wp6wdi7Cr/rXe9K119/fbriiisyn/1ppx17LW+MMcaYFkFw/uxnP0vPPPNMuu2229J+++3nEjdm7LBwNb1g7IXrBz7wgXT00Udnsa488odjjDHGGFPGHfhvf/tbWnXVVV3ixowlzz33XL8PwYwBYy9cCTI/7bTT0pZbbpk+/elPp9lnnz3tvffe/b4uxhhjjBlwojvwv/71L5e4MWMLWYYpfzPddNP1+1DMCDP2wvXyyy/PGuJrX/ta+tSnPlWzwO6www5plVVWSXPNNVeWdbgVNthggy5fLmOMMcYMYvIlxgoucWPGlSlTpmSTN/PMM0+/D8WMMGMvXDfaaKMJwpQb76abbsqWMrCPV155pQuXyBhjjDGDRj750utf//r097//fYLVdcYZZ+z3YRrTMx599FELV9NVnInov2JVS/51mcUYY4wx41nq5rWvfa1L3Jix5oEHHuj3IZgRZ+wtrrj3tuoKbIwxxhiTt7YuscQSWaMsvvjimaC11dWMWzmov/zlL1lm7Q033DDNMMMM/T4kM6KMvXC99NJL+30NjDHGGDPE1tZZZ501e3+22WarWV0XWGCBWobhTomDP//5z+mNb3xjVgPWmEEqB3XPPfdkEzabbbZZliPGmG5gV2FjjDHGmIrWVkTkyy+/XFt4zfuyurJ+p8QBQpjHTuzTmE5O4uAmTL//3e9+5/A50zUsXI0xxhhjWgSrp6ytgIskAlULr4HPWY/1O1krFndMXhszSJM4zz//fJZV+MYbb0y33357vw9tqMCb4swzz0wPPfRQT7YbZsbeVdgYY4wxplX++c9/ZvUql1122abrsh7rd6tWrLMWm0EqB/XEE09kZSR/+ctfps9//vNp2mltH2vVm4IJqdtuuy3tt99+Ld3XL1XcbtixcC3gySefzP4U7r///uw5ZW6+9KUv9f7qGGOMMWagWG+99dJ//vOf9OyzzzZdl5hX1u9mrVhjBsFlfsEFF0wPP/xwNrmC1wHeAauttpovTglvilVXXbXl+/q6itsNOxaugWuuuSYdeuih6bzzzpvKPz8vXCdPnpy23Xbb7M/rzW9+c/rOd77TmytmjDHGmL7xmte8Jvv/7wWuFWuGJUEZrsK8ltX1V7/6VVp++eXTLLPMksaJMknUqnpTvFRnu3EQrrbh/5fDDz88rb/++uncc8/NxGiz+qzzzz9/NuN5/fXXpx/84Afp8ccf7+V1M8YYY8wQ00p8mmvFmmEqBzXPPPNkXoqIqVtvvTVddtllaVipEj9aNolakTcFr5vFsF9XZ7txwMI1pXTMMcekz33uc9nNhlBdYYUV0oc//OFstqQRe+21V/ZIFsFzzjmnN1fMGGOMMUNNKwPcRrViO5212JgySDgx9r3pppvSz3/+83TllVdm72PIwepKH7344ovT3XffPXSNWzWLd5kkavn7e6WVVmrpvn6pwXbjwNgLV/zxDzjggKwxZp555nTiiSemW265JROza6+9dsPG22KLLdJMM82UPb/kkkt6csGMMcYYM9zWmVYGuK3Uim3FOmNMJ4nC6emnn85EKv3/qaeeyhaVhcLqeuedd2bilT4+TFTJ4l3PfbeeAK3qTXFdg+3GgbEXrt///vczv3xM7UcddVTac889W248ROvKK6+cWWmZcTLGGGPMeFHWOtPKALcftWKNqVIOKg/9EmR1pTTO+eefn/XbYaCsAK3i9lvVm+KlJtuNA2MvXEnEBPwJfOADHyjdgEsvvXT2OC4zHcYYY4ypbp1pZYDbj1qxxpQtByUvgAhJhRZeeOHMCkjOGPon7sMXXHBBtt2ge0RUiTst6/Zb1ZviuibbjQNjL1zvuuuurGOSiYvHssw999zZI+4SxhhjjBkfylpnWh3gRnGAZ1e9hc87USu2E4lpzHhAeae11lorrbvuummOOeaY6nPC7jDqsGARXGaZZbL3H3jggUy8kk9mUD0iqsadlnH7repN0cp248DYl8Phj0aZ0Kog0/wMM8zQ0QtjjDHGmMGmbI3VRgPcuF2va8UWDfSxHt92221pv/32a1iaw4xvOaijjz463XHHHRM+n3322TNhW8R9992X/vCHP6S3ve1ttRwx3aZMvdNW789W3XdZP1/ipsibogh9J+tTdrPV7UadsReu3ICPPfZYevLJJys1IDchzDfffKlbUHKHzG1kbCNxFMeLUGZ2hRto77337uifljHGGGM6W2O1zAC3l7Vi2xnoG1MlKeoZZ5yRVllllUz0tlLvtBd1UssK0DJuv1H0Rm+KZkRvijLbjTJjL1zpkI8++mil+BBmQq+55ppslhV3gm6wwQYbpCuuuGKq97nBJk2alC0nnXRS2mOPPdKPfvQjz4oaY4wxPaCsdabsALcflBnoG1MECUubQczrwQcfnPX7Mlb9st4AZTwiqtyf9dx3Ba/RGPE+qupNUWa7UWbsheumm26adUJSdiMQ119//ZYbDxeJ5557LrsZ2E83UHwJnX+HHXbIjm+xxRbLZl3+9Kc/pW9+85vZ7NMpp5yS3SzU0jLGGGNM9yhrnakywO2UUCxjoSrr+mxMnlay295zzz3Z+JlxN/2N8eyGG27YUW+AMh4RVe/Pqm6/Vbwp+umFMUiMvXDdfffd05FHHpnNYnzwgx/M3HFbiXe96KKLstkiYFYGi2c3WGGFFdJXv/rV9K53vStNN910Ez5bZ511suPnpiXd+Kmnnpo+9KEPZVZaY4wxxnSHstaZqgPcdkRoWQtVWddnYxg753nhhReyBEzTT18sMfgMYxEWfcpR8vyHP/xhWmqppdKiiy7aMW+AMh4RVe/Pqm6/pjpjL1wRhsSIctPwo44Y/Na3vpW23nrrulmIjz322MzaymwMM5Kf/OQn07zzzpu6wdlnn93wc2Jrsbq+4x3vyF7/6le/snA1xhhjukQV60wnBrhVkiZ1OzGNGW+K3FYRs1hUlU04D59x31DnlTE0j3PNNVf63ve+l7bbbrtsUqYo4WkZb4CyHhFV789+JlEbV8ZeuMJ3v/vddPPNN6errroqm/nBFD/nnHNOuHFWX331rKPzZxR9+MmMdtBBB6V+svHGG9eec/zGGGOM6Q5VrDOdGOCWTZrUi8Q0ZnyhzzCJUiTsGIvSh/JW12ht5fmCCy6YJWviNYmabrzxxnT33Xdn/ZqwOJWpLOsNUNYjour9affd3mPh+t9iyeeff3768Ic/nH7yk59kDcNNxA2jm4Y/inzA+Z577pl+8IMfVKr/2q14grw7sTHGGGM6RxXrTLsD3CpJk7qdmMaMN/QF+nceBCnj0iKra7S2UgOWhX4nq6u2Oe+88zK3YWrF8n4Zb4AqHhEWoMODhet/4Uf65JNPTvvss0/mKnzhhRcWzrxQd2qTTTZJBx544MC45F522WW15yuuuGKlfVAYuhlFP1DGGGPMONEp98BuJk3qRWIaM76oz/BYBJMreatr3tqqEDvyytCf89vcf//96fTTT0/LL798lsSp23VSzXBg4ZqDrL0siDSsrGT15Wbiz2f++edPq622Wpp55pnToMCf5+GHH157veOOO1baT6OAeGOMMcb8fzphnel20qReJKYx44v6V5FwnXbaaaeyoBZZW9VnMQjxumgbxrhnnXVWloAUzwUmUbpVJ9UMB2MvXIlvBWYwyciruFZcbolrZRlkjjrqqHTttddmz9/5znemNddcs9+HZIwxxpg+JU3qVWIaM57E/lWUVRhrKRb7aEEFWVv5jH4bvfgQrE8//fRUVldZaan7itWfSSPWkXjtZJ1UMxyMvXDdf//9M9G6xhprpI997GNpmMBF+DOf+Uz2nD+x4447rvK+cMloBj8I/DgYY4wxphrdTprUq8Q0ZjzJW+jr5V2RBVXrydraaMwZt1l66aWzx7gd3gksWGhnn332Wo6ZTtRJNcPB2AtXfoQpgrzyyiunYQI3oe233z6bjcJ1mTgA/pCqssgiizRdx4mfjDHGmN7Fq5YVoU5MY7pNtND/9a9/nSqzMBMoCy+8cPacCRH6r563Mk6N2/BYbzvGvoxdcTUGewOMB2MvXEnFjRtCvzMDl4FU4ZThefLJJzMx+Ytf/GJgEkUZY4wx40S34lWriFDHq5puEy30ZP+dPHnyVIISaynQlxWvSmWOesmcInEbHhttRzztUkstlU3e2BtgPBh74crsKLWjbrnlljQMkCxq0003zR4R2yeccIJdIowxxpgRi1etIkIdr2p6mZzs6KOPzsbQEVx411prram2I7lpWRCjrWyHEYr7xtmuR5+xF6677757ZrG8/vrrM/G60korpUGFP6TNNtss3XXXXbUfjD322KPfh2WMMcaMJd2MV60iQh2vasaRSZMmZfcP3odyUzajydgL1y233DJtt9126Ywzzki77rpruvjii7PZpEGDP8TNN9+8ZhmmBM6+++7b78MyxhhjxpZuxqtWEaGdKNVTJl7XmDy49vYDXPV///vfp+WWWy6tvfbaaZZZZunLcZjuMvbCFU466aS02267pbPPPjtL0nTQQQdl9VDnnnvuNAiQPGrrrbdON9xwQ/b685//fDrwwAP7fVjGGGPM2NLteNVOiNBuxusaE0vaCPoO/ahf/Yaar9SCpTwk9yRxsGZ0GHvhuskmm9RmiKgZ9fDDD6cPf/jD2bLkkktm8SetzNow03rRRRd1/AJx85M9mD8y4E/ksMMO6/j3GGOMMaZ1uh2vSlmPdilrPS0Tr2vGEzwAf/KTn6QTTzyxZlCJUHP1//7v/9Kiiy6a1l133bTOOuv03PrJ2PlPf/pT5qXI9y+22GJDlYTV1Gfsheull146oTPrOUKW7L0szWDdbt0Qu+yySzr//PNrInvvvfdON998c931meHCTcIYY4wx3aEX8aq9tp6Widc14wflF4888sj01a9+tan7OuPi++67L1t++9vfpi222CILd+t1WUX6MZmPiXtlAmZQPCn5zbjxxhuz34prr702W4jTlZt1p9ytl1hiibr1duuB7tHvWR70x/e///102WWXZft94YUXsrq7WLa32Wab9P73vz+rsdtNppnSL2f0AaFTLgQI1yKXiU7stwz8aeIi0Q2ol8XsLT8ADzzwQFe+wxhjjBl0EHQMiK+55pps4BYTO2LlYcBMnB2DdQbMlK+7/PLLW45XJclMzLdRJe5Ux0itTaynOpZWzkmunvEczPjyj3/8Iwupow9WBasnxhc8Cvo13idD8eqrr95zAZ1nr732ysIU69Ev4TrXXHNlE1aUNMpzxBFHZKGKjbQOVvYzzzyzUgbpVhl7i+sll1zStcY1xhhjzGjR63jVKnGnZa2nZeJ1zXhB1Q0mL5544om29oP1FYst/RcjS68h0RmuzQg5ykoi0rpBK5NMUZhioVxjjTWye5v7rZPfd/755zetnXvhhRemj3/849lz8vsUidZTTz01feYzn8me8ztAcljacL755kt33nlnOvbYY9OVV16Z7r///sy6zkRHt6zbYy9cN9xwwzTIjLlB3BhjjBkoeh2vWiXutEy247LxumZ8QIB0QrQKPA6+853vpAMOOKBvlldicHFffutb35pZCKtw8MEHp0MOOSTTEIQclp1koqLJRhttlE0Irbjiipk1mNdlhetLue/79Kc/PeHzVkIHv/zlL9ee1yux+ZWvfKX2/De/+U2WMFZQs5ewxne9613ZZ5MnT07HH398+tSnPpW6QddSbWGG7/ZCMiVjjDHGmF4R41WpRFBv4fOieFUsJLjTPfTQQ02/q57ltJEVJW89xY2Zx3rbNorXbbSdGW3wIsA9uFOiNYrXE044oSvhda1CX8YtvlEemzL3adEkE2KS10XstNNO6b3vfW/bWY+vy31fWfhN4RxhqaWWykpq5Xn66acz7wvAMhxFa4SKLILEWN2ia8pPCYtsMTTGGGPMqFClvmpVt9+yltMq1tOy9WXNePD1r3+9rZjWRtCnEI5bbbVV6hfcwxdffHEmxPLW316457fLSwXfV5Zf/vKXWYKlRtbWOGGFuK3H0ksvXbhNp+mqybIV0Rqz+HZyXWOMMcaYTtNOvGoZt98qcadlsx1Xidd1rOvogxAie3A3Offcc9PGG2/c81I5Eay+iNcddtghzTDDDD11z2+X6wq+ryynnHJK9sj2u+++e+E6xLHOM888meX9rrvuqrsvYl3F8ssvn7rFtN2cyWi2fPe73806CkKUWk8/+MEPsk7y1FNPZT+cPN50003phz/8YTZjyXr8YB599NHZ9t1wM6Aj7L///lmQ8/zzz599X5FLMsd2zjnnZAvHbIwxxhjTKbffRpZT3i9yQ2zFehq3LYrX5Zi0KH5X23XLAmcGC+q0tuJR0A5MlFx99dWpF5DVm+zajN3z0K/RGr10z2+Xl+p8Xxlwk2YfgMZqZE390Ic+lD2S3IoJh0axsmimffbZJ3WLvgWJHnbYYZk/9EwzzZR++tOfpve85z1TrTPnnHNmM4wsNMIvfvGL9L73vS8rbIzy/+IXv9ix43nsscey9NR/+MMfau/JsltUkoY/AeoV0WmWXHLJdMcdd3TsWIwxxhgzWpSxyJS1nBZt04r1tB/1Zc3gc+KJJ/bke6666qrM6trt+rPUScUllr5PUqa8QQprIfGbvXLPb5fr6nxfWWurdE49N2Hxuc99Lpu0wr17u+22Sx/96EezdsQaixX2uOOOy2q7kn/oe9/7XlphhRXSSAlXFDsZuQBrapFoLWLnnXfOfjgxZx966KFZVi4so+1C4DUWX9I4t+qGjKWYGQjEN7MWzBqts846bR+LMcYMI1XqTBozLpR1+60Sd1ol23E78bpmNKEv1Os7nYZxt2oGl7GeUlqHSZxWSq7cc8892T33wAMPZFmEeb3MMstMWAfLKuN/Jnq67Z7fLi81+L6yVnXAVZsyOM3u/bPPPjsTu7iQf/Ob38yWyDvf+c6sZA7n2U36Ily///3vZz+UdBwylpVh1113zVJQMzuC6O2EcH33u9+d3QSAuR1L7iabbJJ9D7WJGglpZdFiFsLC1RgzjlRJZGHMOFHGIlM17rSK9bSdeF0zmuBSyxi9FyAWb7311iyOtFPW0/z66AWE6fPPP5898hqxF7fDGIV1tYrltNfJza5r8H1lLN2KSeX+x8O1GbQ7HrL14lwvuOCCrL0owdOtGrl9E66XX3551kGqCj22wzUXs3S7nHHGGZm1lONhJhFXYXWCIhfhCH8OCy+8cGaxveaaa9o+FmOMGUaqJLIwZlw8DspaZKrWibX1dHhBvMXJiX4S65L2AsbgxFe2UuIS0cS9wf3G+JuJ0kaxmVqfcEDEOI+M8fPbEbbIfUR9V8q/cJ+efvrpE/Z1/vnnT6h5CuiQRl4Im222WXb/d8rq+lKTSa2ySZlgzz33bLr+r371q8zQyHe+4Q1vyAx7G2ywQZpjjjkyq/lpp52WtQ25itB4F154Ydc8r/oiXOlwUPXiabsytZUapYIGbpiTTz65JlpbhQvI+XATGGPMuNHrEgDGDJvHQVmLTNW4U1tPhxclJH3uuef6ehxYQOWB2CuwhCIwyRfTCKynGK1oJ7bhkdcLLrhgoeiN69O+JFydPHly4XYYqhDQ3MO6TzsBbcm9nZ9kqjoh9ucWJ7UagfiU9qENENeNoM2oOSvXaay10brLBMBnP/vZtNZaa2X7YhLmYx/7WPr1r3+dRka4KuV0zOJVhptvvnnCftpB1lY6kmZBy6DOzSyOMcaMG70uAWDMMHkcVHH7teV0PEG0MgnRiuWxk9AvEXPEjkrU9fr7Ea71BKggNhUXYY4Tgc3j7LPPnr1fNH6P6yO0mDDisWg7hDD5dzh/3acxMy6fMymFl8Riiy2WxQETrkjI40YbbZTd/0XwPVhzqyQ3K5oQ+2eJSa16nHXWWVkbADmGSKjUCBLjKgaeJE31XJJx22bB2oo3K9/BZNpICFcu9PXXX58t+Eyj0luF9VkYIMVit1XhDwPwya7CzDPPnD2WTUNtjDHDTpU6k8aMk8dBVbdfx52OJwi3dkRJK2CJpJ9izWORiBGtxDt2+nhw42U8Xs/tl3U4VsQ96yIsOQde8z66Iore/Ppkv+VzHrGC5rdjX4jThx9+OLtvi+5TBBsiEjHKvQ5Ycd/+9rd3JblZ0YTYeiWSqXXKTRgLqlDm5XqsueaamXDlGG+//fa09tprp5EQrttvv30mWpkxIZMVAb2t3KjMAsXMV2Swapdpp/3/pWyrBqJTlgdayWxmjDGjRK9LABgzbB4HLjdj+g1j7ccff7wmVHH9bDTmnXfeebO+3GqVjXbB4kdcKRU6sGYWWV0Rm0wSyVqqhdcIbT6Poje/viZQecxvt/zyy2f3MG3C9yNuG4HFUy7dHGs3JpkaTYht28b34R2qOqyrrbZaWmWVVZpuk58QaET0JumW50BfhOu+++6b1fnhQtBpaDxqs1Lmhqy+RWqftM3f/e53sxkR4I+B/bQLAy1mLnAZqAKuBeDyD8aYcaLXJQCMGUaPA7v9mn6AECMPDEKVR1xmW4UwPMRrL2r2Ih5Z6glQiSVELeKW5/PMM0/2Po+snxe9+fXJcIvYFLymfbQdugPxiisxpWHYTzPLaTMBN6ghOKeeempNXLZibYUYe3zFFVeklVdeue66JGYCjrlK+OXAClc6Jxmottpqq0w0IkaPPPLIbCFDFXWW6EDMaFB3ic4Fmv2h07B9J9wZCHhWHVa+p8w+cVkmnTQXyFYFY8w40esSAMYMq8eB3X5Nt0GM4OYqq6pcWauywgorpCuvvDJ1GzID1xOgVayniF50g9aPCWHzaDss0AhXXPQxQpF0tRk33nhj6iathuBM89/qJ0wYt2KAk5sw7Ut8aytsvfXW6dOf/nSmwb7yla+kbbbZJrtueYj5xZtW1V+Y/BgZ4QrMQl5yySWZlfUf//hHTZTScW+55ZbaenlXBToX1tdO1G+Fd7zjHVnKa8QzRXUPP/zwln8kCJQW2223XUeOxxhjBp2qdSaNGRXscWD6CW6tuP8i0rCo8nvbidqrCDlECSKOeGt5OXbLRZj/CkRUPbffstZTRK/cfpu5/ALrNSt92Q34b5TLbnxP8L+JYYwJYYQ3j+1OBt9yyy3ZNYUtttii5czJTGLstdde6YQTTsiOZfXVV0/7779/Wn/99WvlcEjg9POf/7x2XdFT3aJvwlVBvBQ6Pumkk9KPf/zjTKnTifJilThUhCoZvvbYY4+ODoB23nnndPDBB2cd/hvf+EZ2E+G23MxHHMFN7VY6POex6aabduyYjDFmkKmacMaYUcEeB6bXkBhIFlXEKpMn7cJ4GqHK2JdHhIhArBx77LGpW+BKyhgaIVokQBG0Za2nrI/oRUe00j58L4Y0JWrtFRjsaN96nHnmmRNeIzSZJH6kjcngmJQJLVUG+gEesni7ooE+//nPF66HxxWWVzItj6RwlS/9+9///mxR9iwahefMwOB6g9me592AG+P4449Pm2++eTab8/GPfzyz6CJoSc8dOxFuGHSY3/zmN7VZKGZBEN3GGDMuOOGMGWfqeRwwWGYg3guPg3x9RzOa/QyBqlhVhc21A4YgLG2IVBbcOZWkNA/iBs/ImFW2U1AihvsFkVpPgCJsy1pPWZ/tWkk6xL1Ktl7EelXhitWb69PqPaj7tuykA+3Fcd5b0epK21BaR8lkcfct+/1YVT/4wQ9mxkbCKzkXfv+4XnjDYsD7wAc+kBZZZJHUTfouXCOI03XXXbfn38vMwE9/+tOswK5qOSnpklwIyIQsZBHmeAl0buUGMcaYUcEJZ8w4U8/jgMFhFAHd8jgoqu9oV/zhh/5DbCrjT0QBRpxOZPZFqMiqSq1UDEatGna+/OUvp7333rvtmNn8fkmIpLwI9QQolLGecg/UK6dTBAJXohWPT1xgWxWg1DPl+LkHuRdbuQfjfYvYQ/TFbfj829/+dlZBhVIyJK6NNVOxeD6amxBrtX/wu4RLb7tsvPHG2dJPBkq49pMddtghu5FwE2aGKVKUFhyxe/TRR2dB08YYM05QVNwJZ8y4Us/jgPeI78q/1+nsrEX1HZ0AbfhgXIk4xaJJ6BlWxk5kq5155plrrr8sUfyUBXFHFZCPfvSjHRGvCLW3vvWtDRP3sA6f33zzzVmy1jLGoaeeeirzlmQ73IDrQf1V2gZPiT/84Q9Z27Mt8ZzdugebbeMQnNawcA0gQi+66KKsU51zzjnpT3/6U+YCwM3KjU9Hp5guxYaZ6TDGGGPMeFHP4wALCi51EcYOrN+L+o7tWF3tetwb6DNYyYlxRLDiatouTJYwPpVYVR3WTrHiiitmIXFf/OIX23IbRkzutttuTZMCId4vu+yy7H7CwrjBBhu0VBOU7RB/zbbj+5l0oo3I1ounJd4RCH7EMnlrOn0PtrKNQ3CGSLgy64D5nNTbmLLxcedPIT/zxGzIVVddlT3Hh7qVlNVVYL/d2rcxxhhjRs/jgLELnw1bfUe7HncPZcVF8CFWuV6dcP+ln8miyvVvRdi1A5bXE088MUvwQ3bZMnVhEWbEP26yySZTeSQUofI3GI44v6LarlW2434h6RMCmudYW0kQi2BEvHL/4va/yy67NJwEqnIPtrKNQ3CGQLjiIkFWLcz0Qjd00WwRM5ckcWKmgoK4+IG3gjouxXYPOuigCZ/RsQF/c+IAjDHGGGPKQuxaVeHaisUznxSqUX3HMtj1uHMwhqUuKEKVZdKkSdm1apdZZpllQvbfevGh3QRx/L73vS/tuOOOmVciSUsR40Uwhuc48VKkT2PNbIVY/gZxXK+2a9ntGOMvvfTSExK9ytrK/cPxYqVl/UYCtMo92Oo2DsEZcOHKjAiJmLCwtjr7RED5hz70oUx80iHJakWR22ZQlJdOWeSSoXTc++67b/rud79b6VyMMcYYM97gFcbAt1sWz3wJHqou8NiO1bVbrsfjhK6bxCr9oF2wTHJNZVVF1PSj3mgRiD/EKwsGIURYhOOmQkeV/iOrqcrfFNV2LbMd435iajFMxfaL1la2o43p+7xu1P+r3IPduG/HmeIc2D3g3e9+d9bREK0kRSI7L7NUH/nIRxpuR5kacd555/XgSI0xxhhjGqNBczsWT0QQr/PkrTZMusPiiy8+ob5j2TIbRS6MvC46BvM/0YNQPeOMM9LXvva1dOCBB2bus+RFaUe0kkwIN9Ytt9wyiwWldieJieaZZ56BEa15ikrpEOcdRR9tQuxos+RO0WrKc0Qdj7Ke1ktcVbQdx4Wxi5hihHa+/aK1lfaV1yVlL+v1/yr3YLfu23GmLxZXbnaspXQkfLpxFZbbQ7Obk4BqZkaw2JKFrRVwUaCDdDKdtzHGGGOMXH3PP//8bIxSpq5qqxbPvNVGYyZCqKpab7rlejxqYGBB0ET3X8RruyCUSHxEJlvyujDxgcgbpbq8rSZMyltNEZtamlldtR33D0mqqCnKe1hbKf9Dn6a0TD1rK+s899xztfuok/dgN+7bcacvFtdf/vKX2SOd9+STTy7tq0/iJH5ImPFqBWUwu/HGGyscrTHGGGNMY1ffW265JXssYz1pxeKZF5gIGwbfWnhdxXrTyIVx3K2uiCCMIyeddFJWs/Owww5Lv/71r7NrXFW0YolceeWVs/KLZOj9yle+knbfffdMIBHDOorEhEn0UeWVaWY1xQoKPDayulJuinw56AnakDhWuVnzvYhTRGq8Znlrq+JveeR1p+7Bbt23405fLK6ytlKQW2bzMkiI0llbgeBwbhY66wc/+MH03ve+N5thiS4OuOfUu6FapUpsizHGGGOGFwlABta4drZqPWnV4tmN+o6NXBg5/nGzutIeJPxU9l8s6O2iLLayqmIt7Hb230GiTKKlvLVVfY7HIqsrbsAIP6y4fE4umyhCEbG8ph/PN998Natr3trKZxynFiZvqOnaiXsQOn3fmj4JVzoaLLfccpW2V8dsNVPbPvvsk04//fTs+fHHH58tEay3pPhmaecHqhOFo40xxhgzHEQBiLshgqdVwddq0pZu1HccdxdGXHO5VnL/vfPOOzsyhkMsIVRZcFmlPceVVhMt5a2txPrSjwWv6at8zrYbbbRRVhKTa3jJJZdMJUIFr5944oma1ZWJIa61rK1w++23Z4+8h5iWUM6Lyar3YKfvW9Mn4SpLJ52uCnREaLV8zWabbZYFzx9xxBF11+lEXS1jjDHGjA95V9+77rory8PRTPCVsXi2U9+xqMxOPRdGIUvWqFldiR+VUMWqynVrFwwpGGEkVpl8GNRESr2kKGES/anI6oqFMwrcetZuxOW8886buXFzn0SX3yhC88jqqozPiESSYEV4H1du7h/WzYvJqvdg1fvWDJhw5cbmQmLar8INN9yQPZYJYCfz2zve8Y70k5/8JNueG4Qfav3ZMMMin3pjjDHGmEbkBSAhSIihVgRfWYvntttu27EyO91wPR5EcE8lkRIilYUES50wvDDJgOsvQpXnxFSa6omW6IsIPAnGPAhcygHhHoyRSZmb64nQIliP9XEX5rvoGxHuWe5Bvkdhf1FMVq2xWmUbM4DClZk/1WFl9oVO3CrXXntt5tKB2CzrvkLdWJYi6y+1qFzH1RhjhoMiS5IxvSQvPrH+aEK8kZttryyesczOqquu2lXX40EAQYIgQqRiXcP6HV1O2zG2SKji/juqiZQ6BeKyXqIlrk/e6oqAZZui5ESIR+4HTQ5g4VaG4HoitAhth97A1TgPExx4cfJdJIA1g0tfhCuWT2JO+ZH/6le/mg4//PCWtuOHnRlDsd1223XxKI0xxgyiAK1nSTKmVxS5+iKWGGg3KmsDVS2eZe6VRmV22nE9HjQoeSKhym9BK+fUDISphCqP9SyBphjuhzKJlrB0ktQsD6VtmFyp53pdT4Sa0aYvwnXnnXdOBx98cDbj8o1vfCP7Af6///u/htuQQZi04aQnpxOvueaaadNNN23p+5QtWAWGIxtuuGH22MrMozHGmM5RVYDWsyQZ0yvqufoSJ4coxDOsntW1isWz7L1SVGanXdfjQQCDB7GMEqtK9tkOeN4hoCRUiZ+MVSdMeeHaSqKlehmGgeRLTAY5XtgMhHClk5LZd/PNN8869sc//vEs9hRBi2uHOPPMM7OYBGYJf/Ob32Q/WMAfxI9//OOWv0+df999953KHZjSOHzGD5YxxpjeUUWANrIk2epqekHsg/Rd3ByvvPLKLKuwxigM0Jk0L+qbVSyeZe6VVsvsDAOIHkS3hCpip2piz7w1TwmVmEBQtQrTPlyfZomWZHUlMVO+LCaTCCQ4M6aIvhWUwrz/05/+NBOOCFISJinpkmZYtt9++6my/uJmcOqppxa6FVRhr732qolafsyNMcZ0n6oCtJklyZhuE119EZ9YQSPE3DFWYT3i+vLJjRC49F3GQa24x5e9V1otszOo4GGn7L9YV2W0aAcmAKL7r5NxdpdW3KsRuDGzM3GsxBCTOdiYevS1EvIOO+yQVlpppcxNmFpMEX7U8yVq+JE/+uijs9nDKrjkjTHGdI8yMXhVBOgoWZLM8BJdfakPmReu9EFZjHDrvf7669M666yT9fMq7vFl7pUyZXYG5V5ByNMWEqvErXbCs2/ppZeuiVVcT+3+2xvoV0suuWRL6ymzMF4KXCe53BszkMIVGHhcdNFFmfvLOeeck/70pz+lhx56KJtVZIYMd4611147vf3tb69sEWXmk1lRZvGMMcZ0njID8qoCdNgtSWY0iK6+5513Xpo8efKEz3E7RTQB/ZiQKNYjpwaeZWXc48veK2XL7PQDRD8uvxKqHFMnDAtMlkmoLrPMMlm8sek9WE7JQ9MqjPO5X1xWyAyFcBWkn+5WCmpqPPHjSAwKfwKDMstojDGjQpkYvCoCdBgtSWY0iTUd8QK74447pposX2uttSa8R7zrL37xi2xS54knnmjZPb7MvdKrMjtlQZTyvbfccksWq4r7L8fXLsRI4loq99988k3TfYrijbm2TNYUJV2KIFSZYKA/m2o8OIZl4foiXBVbwI8MP+IUFe4muBgjXEn0xMXdZZddskLh0W2EH9NTTjmlre/ZY489OnC0xhgzXJSJwasqQIfBkmRMIxiHIN7o4/TfsvVem90rVcvsdAOOg3GVkiopWU87MFZE6Miqiju2s872l6L4Y9XTlRtwvZJDXEN+v001XhrTsnB9Ea6kwWYGDkHZbdEKH/vYx9IJJ5yQXWRcbL7whS9M+JxjwV2ZpSr8eFq4GmPGkTIxeFUE6KBakoxpFSxQlMhhYoeBJlmHEXOqnFDUZ8veK1XK7HQK7keqQkio3n///R1x/yU2FaFKPhTcSXsxZjStX3Nl0i5yBa9X6oa+z/VsZpE1jbluTMvC9aXX4OrCIKNX7gH86J122mlZBuF6s35O3GSMMeUpE4NXVYAOkiXJmCrcc889WZ/HTXiOOebIRCgiVpmH84POKvdKlTI7VWHMhOhGpCJWJ02alB1zuyBqVKYGN2Dcgc1gwu98rNEqeI++UGR1xdOS/wgnymrP7felOl5OFq5dglkYfnA7OdvXjG222Sa7ic4+++wsOQIClj+Bk08+ObMQ8ANJEihjjDGtUyYGr6oA7aclyZiy5CfCo7WV5yr3gWClr5OUEnHKgFUJhareK4q97Za3XHT/5XzahYkp7muJVc7F7r+DD+NnMmrTn4v6P30lb3VlsgRLq0Vr+26/19XxchoH+mJx5YeVRr/88suzQUavMolx0+y0007ZIhCusOmmm6bvfve7PTkOY4wZBcrG4FUVoL20JOUZx+QXpj3yiYfy1lYNSBGpvKb8CwmevvWtb6UPfehDWfKnQZis4f5GcMuq+sADD7S9TwbZJMyUUKVsit1/h9PaSnxr9AIQjOkxDmEtl9WV97jezhzcvtvvSw28nMaBvgjX973vfekb3/hG9mN95JFHps9+9rP9OAxjjDFtUDYGr6oAjVlce8m4Jr8w7WVVfeGFF2pZVaO1lUE+90N0r8Q1FusUn1PvlbCm1VdfPctK3OvJGr6PcoQqU8NxFwmTsmBZVuZfvNvIumyG39rKZElR/0ec0u+j1ZWkWiRkGhc64fZbpSzcONAX4coP94knnph23HHH9MUvfjGbgTvggAP64j5w0EEHZY/51PXGGGPqUyUGrxMCtJcW0HFNfmFap0hYMpjHyspgncGkrK1A0qIi+BwRy0CfsRAWTvocgq+b9Uifeuqpmusvj0zStAvHi0BV9l8G1Xb/HR3oK1hb61n4FOssqyt9bFjdWKv833TK7bdKWbhxoC/CFRdhBjAHH3xwJhw///nPp2OOOSa9+93vzooWM3vQ6szMBhts0BHhaowxpnX6kTCplxbQsrPgZvygjxQJPSyqWCsZVHKPIGRbSUbJeqwPDEqvvfbadOONN6blllsuiw1k3NQu7Be3ZFlVSbDULgy2OVdZVXH/tUvo6IIQpY/j8j158uRarLMEKx4AEqrEu+IO3++JCyZR6e/cR2iMbv7fdMrtt0pZuHGgL8KVMjixE9OxmdUoG2PKPooCw40xxnSXfsTg9dICWmYW3Iwn9IUiV1oGo5QJkdWVMU4rGXcZoLJ+hP0zkGWh/ryEYaulRBDDxKZSPxaLKiVrOjFumm+++Sa4/2oAbUaf1VZbLetXuMTzOyzoX3mwBNbzaKwiJqtsxz30hz/8Ibsn+R3fZZddWoqrrvJ/00m33ypl4caBvhVRKio/45I0xhgzHHQiYVI344DaoewsuBkv6H+EO5Gro8hiSf8599xz09VXX50222yzbODZifg+vovlqquuyqywCEfKixS5HcuiiqWolXu0GRx/dP8tIzTMaIH7Lwaoot/5/HpveMMbCq2tVcVkle2USIqSTdw3vEZ8d+P/ppNuv1XLwo06fRGuuPf20m2AZFCC7/3xj39c+Fk75PdrjDGjTD5etWwsUDfjgNqlzCy4GR+wVJJQ8qtf/WpLYhCXytNPPz2deeaZaYsttkibb755R1xoGeTedNNN2bLIIotkg3GOR6VqcN9sF+Jssewq+y8Jdjrp/ss54AbNvYRLNAvCQgaMThkymFy78sors4kEBD/tg7CfeeaZs3NiPEomZwRWFZhIwPLHtYYNN9wwXXrppWncwAp68803Z+7DxGoD3gP1xvpVxGSV7WIiKX7TeeQ1k5GNBG+V/5tOu/3mv7OMl9Mo0xfh2uub+qSTTppw80SBmf+sHSxcjTHjSJVYoG7GAbV7LmVmwc14gODZbbfdssmZstCPfve732VCbe+99+5Iohr6KQN4RCqCjAEtr1txSa4Hg2UJVQbH3cwCi1hk/NVtuH+LEmJFF+wf/OAH6VOf+lQ6/PDDS48HP/axj9VE67giKyilbxCwTAYweZm3wLYrJqtsJ6HL7zbXlkfc3BsJ3qr/N512+80nNyzj5TTK9M1VuNdo9q7oR6kTM3v9Djw3xph+UTYWqJtxQJ06l1Znwc3oQ5karKXKDFwVBvZYbJnYYSKkrLWXmEIt+TIkWEMpM8P7DNTztWSLoE/j/qtY1XnnnTf1ijjuInnPGmuskU16dboWJeV9ZP1717veld2ziALa6JJLLklHHXVUlv2W60IbYk1vlbPOOiv9+te/zn4XEBnjisQhbb3wwgtn/bxRpY4qYrLKdlHo8p9DPVlivJsJ3ir/N91y+80nN9y2D2XhBo2xEK7EolT5zBhjTOp4LFA344DaocosuK2uo29p7YRoFVhLvvOd76QPfvCDmQClHxfFqSr5jZZWEyrh4osgxVqqbQXCjMG7rKq4dVYtQ0hViEMOOaSya+yWW26ZxUlyD3EsHAevOy1cEVBUj3jb2942lYEBC9Z73vOeTBA89thj6etf/3raZ599sjZqBr9f++67b/acWOc99tgjjSNRHNLXqN2K+3S938WqYrLKdlHoUkuY8BYeGwlevqfK/0033X47ldxwVBgL4brnnntW+swYY0xjysYCdTsOaNhK/JjBhUEs7sGdEq1RvJ5wwglpnXXWyfr9W9/61ixLMPeDxGYrFtNGIAS5V4g3JA6WeE5EBf21TPbRbtVN3mmnnVIvwI26EUsvvXT60pe+lLn8MjlwxhlnpE984hNN9/u5z30uc0HeeOON0+677z62wjWKQ8B6jcirZwWtIiarbJcXumTkBn63ybBdT/ASp1v2/6bbbr/1khuOK2MhXI0xxnSeKrFA3Y4DqmIB1eAcgeJZcCOwwFWJaW0F4iKJeV1llVWyCZL555+/I2FLCFasrSQfYsHKyr2DdxkDferL7r///i3dJ72sm9xPEJ+C9mkGiaSOOeaYrC2OO+64NK7kxSG/3/wWIzCLRGFVMVllu7zQ5V4A7o16gpfv4V5ETJb5v7Hb74gIV3zcI8z21fusHeJ+jTHG9I6ysUC9igMqQxycY/VaffXVW0pw41nw0Qa39zLxjlVgEExyJSwvxJdWydqLl8NMM81UE6pFwpJ6slhbGaTjlnvxxRdnWY4HqW5yP4nW7WbXAKvs+9///uyaHXjggVmM8LiSF4e0HZZQ+jX/A3kraBUxWWW7vNDls+hqz2smKaPghTvuuKNWZqfM/43dfkdEuDIgUTwBj7HTxM/aIb9fY4wxvaFK7OkgxgHlB+fM5o/i4NyU4yc/+UnXs3diYSWhDe68PBJz2gpYlWRVRbQ2Gk8xRsKKiBBn8I93wfHHH58N3tdcc8262/aybnK/ueyyy2rPEfaNIJ6V3wqSPeEuPK4UWUERrFglH3jggamsoFXEZNXtqF8c3Zdvv/32wnOQ4GV97if6ORMSZf9v7PY7Yq7CjVxfOlWnyxhjTG8pK0IHMQ5onAbnphy9StyIJZT7iME+90CRxY/3ZFGV+2+rYG3lfmNwj0jlEaH8y1/+Mkuis+mmmxaWvelW3eRuxcxWBQvbt7/97ew5kwCNsrYyAXDooYdmz3EVluVvHKlnBaVv0aZ5K2gVMUlt3Srb4YaPsGxlIoj1WJ97ANGLxRjPoTL/N/ma5mZIhSsuvPVm8hp91g30Q9NtCPA3xphRp4oIHcQ4oG4Nzs1ww0RJvf7ZabhvSGhDKRtZXeX+K6tqo9qWjYjWVp5jFUOs8pr38ZL4zW9+k7beeusJmY1biV2vwiDGzOLuq/A1sgQ3EtPUnkVEkViKLMXjSj0rKCKQvltkBa0iJqHKdghlZeVuBvcX6+OyT1km4p0RzGYMhSuzfFU+6wakbe+FULZwNcaMA1VEaK/igFq16FQtMm9GHwbb+Tqp3YQBNlYqSrLgro41p9mYBbGL4KpXTidvbWVQzsJ9K6srn+PyevbZZ6ftt98++95WY9erMGgxs4jo733vezUX4cMOO6zuuqecckq68MIL05xzzpnVfh1n6llB8R6IGbijFbSKmIQq23GNKK1UBoSrGQ7GJqtwGbdk/jAarV/0eS8tyMYY00+qiNAqbr9l3QrLWHSqFJk33YPBbbTa95MqdUnbAesq9wX3Cv2vWR1RrFtMrjCYx8V4gw02yBKL5dehBu3jjz+eiVeyFtO+DOqxSvE+n/M+IuTMM8/MJm8Y22hC5/zzz5/qu3nvy1/+8oT40EbjH1yu3/ve9w6cWz7XeO+9986e4+r661//utBlGvj9+uQnP5k9/8pXvlLLajuu1LOCMvGSd7OVFbSKmISq2/WLQXOFH0XGQrhSfLoZ/JAee+yx2Q87P9wLL7xwWnvttTO3ZgZR/KlQs+uaa67J/ij0Z/ORj3wku7GMMWZcqCJCy8YBMdD90Y9+VMqtsFWLTpXEUqa78N/LABfLY79hAN5L6GM6fzKbIozyQjRy9913Z2IT12IGx3fddVdacsklC9fBAsY9yP64Z3nkNe/jnqxttS+ssNGbYhTd8q+//vq0zTbbZPc+bXDOOefUTcqEEKGWL+IVMcKYb9ypZwVljJwXs9F6OuoMoiv8KGLh+l83h6222irrdPi2kzWOhAX1uOiii7LZNwZHv/vd77IfveWWW66X180YY/pGWRHK4O+KK64oNQtd1q2wjEWnbGIp0xsQrQiERqKt2yAgey1c6a8IKMW60v+YRCkCSypiU1mCeeR1FLtxHc4Hd81ozeY7GFzHbZmIx9Uz1rHcddddJ1gh+T4G5Bwb9/TVV1+d3dONElktssgiA+GWL0sY7tI77LBDdv6c8xlnnJEZKYrguKnTKgv8hhtumCW1agSx/b/4xS+y50wI1Nv3MFPPCkrfGKXyQGWtp4PmCj+qjIVwbQQ/xO985zuz2cm3vvWt6ayzzmqaKY71sLy+/e1vz0Qs21OQWoMfY4wx1Wehq7gVtmrRqZJYyrPmvQPx1YoLeifBckR/YRyA5bHXVl/6qTy3pp122qw/1huHIDSxdiEyWZdH1c6UizFW07hOUfxe3JbJgpVWWmmqOpbyLoswucO9rHuC1yuvvHLD8+M+6pRbfhVXTP0G8X2UOVLN5tNOOy0bz9WD46KNxDe/+c2WXN532WWX7Pmee+45ksK1Hv2ccGoE9wbXhT7eSsbgKv9bg+YKP8oMZi/rISeddFK65ZZbspm3n/70py2nN2d9fgCZUeOGYMaRjHTGGGPam4Uu61ZYxqJTNbuxGb1Ja4lVMu3GvBXzzjtv01wXnYLvob9q0E8/rRfjiiWV40VM8Zz+SR/nNe8T2sR+6N8IVyytzWA9shZjiUS0t1rHkgRWrVDGLb9brph8D+fGeA9hjmg/+eSTG3qN6Lh7bX0fZqpmv+4mTAL94Q9/qE3IMKnQynGW/d8aJFf4UafvwpXOhAAkWxsDCGb++FFq5Q+DzhELEVfh1FNPzR5xeyBJQRnolKTOPvfcc7OZOwtXY4xpbxa6ilthmURLvcpubAYPxhtYI1noT/XGGQxsEa+9uPbKp0F8KxZOYgTreW+RRZj7Qy7FWniNxZbPEb0snBvrtvL9lHbBKlWmjmVsm0ZW0DJu+d2YBKMNzjvvvJpohe222y69+93vbum7iAVmfMhvDtdp8803L/xOJajCnbjXyb0GhUEUrqo3O2nSpCykT3VlO/m/NQiu8ONEX4Xr6aefntXFUr2mXsxu5sE1hh8cZiqroEB09mOMMaa9Weiy2X7LJlqqkljKDC9c5yhWW2WFFVZIV155Zeo2iCEm4BF+9F8EZL0swdHaSiZc4BHBGq2uiMNVVlml4fdON9102UBeVlm+F6sr7pQM9Ju54qoECuO2elbQsm75jcaA9cSE7k/u96JSixdffHH64Q9/mG0DxGAiLBr9BlmIVEPllAbF7TfWm+U/JdaVbSSyy/5vOUP9mAhXfuj22GOP7Hn8sdKsVb1yM50Wt8xUAqnhq6DttB9jjDHVBn9Vsv2WTbRUNrGUGT7oDxKrVeszIurIZdHNEj30YQSiLKm4s2IBleW0kbVV/Z/HIqtrI6jhyvnlQ6M4V6yT7K9VV1wEcz0raCO3fM5FNT8RFFynKDyxkEZIElUkJhqBmMY4oj6AlwXinPAw9sVvRV7A8LvBdXCprPJ0u8JGWbdfWVv536DPqK5sI6sr31Hmf8sZ6sdEuCL2+DFBhNLpKPpMna9DDz00HXPMMVkHY0ZcPxyXX355NmPGTAk/qDzfeeedO3IsuAfzQ3/JJZdknZTY1VZhfbYDBkjGGGOqz0KXFaFOtGSiSEH4YHVsJy4RF2FyVzBpgrCjTF63oHoBllVZUkkSlY9XLbK2IjxxYxe85r4p2jbCeIvzYtxTVHsVKyqigARQrbri8p31XCobueXjXvynP/2p9hpxENlrr70mvCYT8Nxzzz2VmGgEIvz/tXcn8FbN+//HvxSFIrrKT0iKckVkyJRuyZAxUyKzEkLh/kOGws2YhLiGDJmHq1xzhSYXZSjVJa6UQpKxuKZy/o/3997vvuvs9rDW2mvvvfZer+fjsR9nn3P2dPb57r2/n/X5fD/fTzzb+qhc1G2HIzfeeOMq11G2+8ADD2SrrBgKUvbrzbbqc0IHczSu82Vd58yZE+hziw71CQlc77jjDlu+ozfOq666KrWxczoFqRpcOinQve6668xFF11kW7RrYPXu3bvgx6IBqMBV5coXXHCBGTFihO/rXnjhhfYop/4OFl8DQPij0GGCUBotJZuCVQVqClgLCVaVhXHBqjdrpKowHZxWaWLUtMyoS5cudkLsMqmSKXOqta/eyyjoy8RdV5d3rzlRMyK9frQ1TbYMlQJiZSI1FwrSFVWBabaSylxl+bovbUXjl94TMgUT2ej5cgFqEC6DzFZZ8RK07NebbVU5vSpt9DVX1lX34d0OKt/nFgdOExS4agsZ0RvsOeec4+s6elNUYKkBpQytSljUGKlly5YFPRYFv65B0y233GJfENdff70d5NnojX3gwIHm7rvvTv3stNNOK+hxAEC1CHMUOkwQSqOl5HFZRQWrhTRPUvDjglWVj2airOWVV15pTj311NQaySjo9XDcccfZqrNidAnW5d28SbepIDlfNdm8efPsRF8dlnXZfOv6Bg0aZP8O9fdQpjZTSWW+snzN5fI1d1JwoISCu5/0YKJPnz6mVatWZsCAAbWup98puFDjKWWktSbSGzTr/5nebMl7X0G3yipHj5YkCVL2m55t1T7FovGs/322oNdVHPj93OLAaYICVx291MDbddddsx7901E8NQ9Id8kll9hyYgWP99xzjxk6dGhBj0XBr0pStJ2NHpO+avPoAw44wG6B4BodaDDrCKg23H7++eft93qj0nW0V1emzZgBIGnCHoUOE4TSaCkZFGQokNPJrYsMQ5NPF6yqossPXXbkyJHmrLPOiiR41XxCFWR6LCpdjLpLsF5LCuQ0WVepswJSBW65Gtno9ak1rbpfnd9hhx0i7eRdyBY3YQ6ChX0PIhAp7V6pfq8TtOw3Pdvq1nJrnXS2rKu34sDvmOHAaYICV/fBo7IVL+/A06DL9MGiNxcFiWPHjrWLtAsNXEVrZnV/ClgViCooffLJJ+0pE++RNa27uOuuuwp+DABQDcJO/sIEoTRaql6aQLpgtZDmh1rP6YLVsF1Pt956a1thdemllxZUNqzMpzKtCrii7hIsOtivgFUNnjSXefjhh301stEE3nU01oQ+6k7eYbe4KXUASiBSur1Sg1wnSNlvepCr33u3zdT3ikHSg14Fwq7iQGPIz5jhwGmCAle9uWpwpQ9S79oSdXXT4utszRNE6ziiejx6g+/WrZvN6C5atChv2Yc+gFRC5DojA0CSuXI/TQrC7JNKEJps+sxVsKYSYAUxbpu8oFx5rIIpnbLtiRqUbksVWffff7/9qkmuX5rr7LPPPnZNq6ski7JLsEp7FcTp73ZNmTTx9tPIxk30XbbVlVVG2ck77H6ZpQ5ACURKt1eq3+sELfvVgSUX5Hq3bUrngl5dfrvttrMZfx041YGifCX5bszwmZWgwFWDQkGnPqS8vBnY2bNnZw1c3ZuYBlqUjj/+eHs0VJ3o1JBhxowZtuGD3jj1QaKjkCqhUXmx1k2o4QEAJJ233E8TZ71P+ilrZJ/UZFOwqgMe+qxVh9lCglVNaF2wqpLAYtDYPuWUU0yPHj3skqGnn37azJ07N+vlFXwpoNTeoZo3uKA1qi7B6rKrv1sH871dgoM0snEBhHZ70O25564Unbzz7ZdZ6gCUQCS4MHulhhmffst+9R6isaDkUj66nHvP0WtUB2B0u3q95cLnVgIDV23sraymUvNe3qMtY8aMMUccccQq11Ua/7XXXrPn/dbRB6E3z/3339+eAAD5pZf7aTJNp3VkC1Z14Pqdd96xAauCnLCf1QqSFKgqO1isYDUTHchW8KqTelykb+WiCbDKdRU8KeDU3xxVl2BN7FX+rAAv29/st5GNN4DQeQUC+uoC0WJ28vazzzMBaPyF2Ss1zPj0W/ar6+t1p62l8lEQ7O5Pr2mNU415ZWARX2UJXNWUacKECXaQepsw7bjjjjbrqjfpxx57zDZI0tY3jo7ma79Xt5WOO0pW7fTBMX36dHvSBFEnHR0VfWimb9QNAKWSr9wPcIGbAlVXyRSGPvcVEGrNqrIiLvtSTpkqr9xe9FF2CVYAqwNCuk6uaq8gjWzSyyp1Oc2/0vuLFKOTt9/mTrm6EqO8wuyVWsj49Fv2S7PU6laWwFVrPbQ+VG9ayp527Ngx9WavluZ//vOf7Qed1o9ee+21timBFnBPnjy5Vlc/dflLAh1dBYA4ylfuh2TSZ7jWq7pg1R1sDUpBmoJVl1nNt61LHChgi6pLsCbkWhvrsp9Tp07N2YU1SCMbb1mltgTSc6syyEwBdZSdvKNs7oTyCbNXatjxGaTsF9WtLIGrJjN6E1YDptGjR6cCV1ErdK0xVUZWkyANYm8ZjmuapD3Edt99d5M0OmKrUuvx48eX+6EASDg/5X5MPJNDAY2CVVcGHLYbsIJVVV8poNFnXiUEq16apxTaJViBqbus3y6sQRvZeMsq9ZrVfSmQyLTGL8pO3lE1d0L5hNkrtZDxGaTsF9WtLIGrAlJ9uOkISXrJi8qGn3nmGTNkyBC7d5rbSNvRkVdla1UynBSXXXaZnQDqpOyrnjuVSgFAOUW1l2OcuiLvtNNO9sAq/NHEUqV+Cla13jFs1kOf/Ro/ahBU6Qc89LeE7RKsv1+f7+nlun66sAZtZKPH48oqdbu67yjX+GV6TUXZ3AnlE2av1ELGJ1DWwNXecd26Gbvkid6krrrqKhu8al2nMrMKcPVmr26V3u55SXD55ZeX+yEAQNWW+3m7In/wwQe28ifuj7ncwepHH31ks6oKVr1LeIJQVqVt27b2c12UcVHgW+nPvQLXoF2ClW1UwKqMZpgurGH3ryz1ayqq5k4onzBjTeI0PlG5Sha4Kvi87bbbzEsvvWSPzuoNXG/meqPu2rWrOeOMM2w21UtvcklpwAQAlaSayv3SuyJXwmMuNQViClaVWdXEMn07O7/0ua5gtX379nZy6sqA9dxXC03MFaD67RKsgz16rWQ7KO+nC2vYRjbFqkjI9pqKqrkTyifMWJNijk8kR0kC11GjRplzzjnHHpX3rlNVZ0G9KekNbfjw4ebGG280ffv2LcVDAgCEVE3lfnRFzh6gaGmKJpgus5q+dMcvBada06nMqoLVuI6FqCgYVSCaq0uwaI2fgtZcmSW/XViL2cgmaEVCrtdUFM2dUF5hxxqNllARgesDDzxgTjvtNHteRwpd0Oroe/1ci6/PPPNMW+uubsIoLR0Bzsdb+gQguaIs9yv32lK6ItcOOPSZrT4KjzzyiA2s/DRGyUTr15QxUbCqLrhJKvvT356tD4UCPrffpDr55uO3C2sxG9kErUjI95pii5vMdDBC76Vaa5yta3QchB1rNFpC7ANXlRKdffbZtYJWvempG7DefFU2o6NwejN0v1dmtnv37racBqXj58gZAEhU5X7lXltKV+T/0FqzuXPn2v3TtZxn8eLFNijSxNR1/vRDB571Ga9gVd3vkxSspmcKtS99JuqWrCyr+naoKkElkdm2twnShdVvIxt3n64CLuqKBF5T4eh/PXHiRDsvVvfoTF2j4yJs06RKa7RU7oOqKEPgev/999vgVUGp1rM++OCD5oADDljlcs8995w5/vjjbTmBJjC6XlL2aAWAShNVuV+515ZWU1fkMBNlBTAqA9bz7/4PCk4UfGjbFQUpej7UbCgbrW3W/05rVlu3bp216WKSpFeWiYIQPT+u+ZKf7W3CdG7Nxc99FlqRkOTXVCHmzJlj/9d6nho3buz7f4riKPdBVWRX1E8YHbl17r333oxBqxx44IHmnnvuMYcffnjqegSupbVo0aK8l9ERVrewHkByZdrLMejR6WKvLc33eKqpK7Lf50B/szJ1ClZnz55dq9RPmTgFNpqoKUDRVwWl+nl61lUHIzSpVmZVwViuwDaJ0rOZKgneeuuta+1Hm297m2J0CfazpU4h2dMkvKaKQc+bSoSVbdX/h8665Vfug6ooU+CqN1NROVm+NQ0qD9bl9IZaTd0FK4XKl/JhcgIgqqPTxVxb6ufxVFNX5FzPgSqZXnnlFVuOmq1EVOXcCiqUiVMm3S3l8WZdVTWlIEeZVX1W83nwH1rLqkaTel71fCnjrABVQabOK3uWHtz72d4m6i7Bfu6z0Oxptb+mikXPh8aODhJl6xqN8PKV5KejYV+8rV7MG//666/ti1BH1/zYZZddUtcDAFTe0WkFi/o+l/TMjCYU+uoyMvp9MR9Ptq7I7qTvo3w8pabHrqU5U6dONY8++qh59dVXbYlotnWN3myrylDdSYGTsq1am3b11VebY4891q5dJWj9n0MOOcQcdNBBNjjVAWCd9BwtXLjQBh/KtKY/X5m2t9H3+nmmzq0tW7bMetLv/XQJ9nOfXrmyp5leG9X+mioW97zpQIKeJ20LqZ+5Awvebu34z3vV5MmT7cEiP1x5vCpN9NXP85npoKq+z/e5hirIuOofrX+6OqT54S4XtuU+AKC0whydLuY6OD+PJ8quyHGhsl+tk1MZsCa8esz6+/XzXOtV07OtyhAqGFJ5nPZtVfClpSS6HAFrbenlvBorei7V20N712vrmvS9Wf1ubxNll2A/95kuaPa0Gl9ThfKzfMI9z2qIpjmwGh9pjXS1Z12DZkHDrtEOWh6v+whSHo/SK0kXhWybaseNBvezzz5rpk+fbrcD0IeP36Nd+htffvnloj9GAIiToCW/xV4H5+fxRNUVudyTYH1maa2qglVlFNznlSbBfter6mcKSDUBVLCq5919ZuszkPLO7NKbJ+l5bNCggc1+KuuqiXn6JNnv9jZhO7f6eZyZ7lMBaSH7NFfia6qY/CxX8D7PLiudrWt0XDsMhxEmAA0bhAYtj9fBP5qLxRvt//7r+uuvN3/5y19CZXvdXrQAkCRhtr4o5jo4v48nqq7I5ZgEK1Dda6+97ARLgZG3YY/f9aoKsBS4tG3b1ga9Cl7cZNB7e5kCFLIN2beq0XOl51VfFbymT5KDbG+TaWIdNkvl5z7dUi0Jkz0t9Wsq7FYlYa4X5jp+mvt43wtd12hl2MN2ja4UQQPQsEFopvL4XM+n7kNjXWOY5mLxReBqjOndu7ftepyphT0AwERS8hsmkxMkUPL7eDJ1RY6zKVOm2H1W33rrLdv4R1+z7a+aab2qJsP6XmXAymxrraq+vvHGGzZ40XpMobzTv1xb1biS4fRJciHb2xSapcp3n/PmzbNfJUz2tJSvqbBblYS5Xtjr5FuukP5eqLXROmjkTmG6RleCMAFo2CDUT0m+lxqgudcXzcUSHriq9PaKK67wdTnHz+XlsssuK+ixaQ9ZbcXjMqZa26MPBLX514d8NbxRAEDUwpT8FnMdXDm24ihm9kbPkyZYeuyPP/64zeDppHVwfterqmxVGW01fFmyZIktX1WnW92vPvMo7wwn21Y1ev6VTVSZr7Lc6WtIC9neptAsVb77VJZJHaMlbPa0VFnQsFuVhLleIdfJtVwh/b1QB6b0P9L/RwcVgnaNrhRBA9CwQajfknxHz7sO4uk9thgHVVFhgaterH67cbkA8vLLLy9J4Dpq1KjUeR2Fvvvuu2vttRYH6gipJhmOd22Ifn7ffffVuvxJJ51U0scHIHnClPxGEShlm+QWUoIcZsJdjOyNfq6J2DvvvGOP/it40HpVXc/velVNtlzgrvJPBVG6nsus6jruOai0kum4yLZVjbJrOljgDih4gw4Ju71N2CxVkC11NO41n9CBHh340JjRGttivh7CXC/sViVhrlfodXItV0h/L3QHD3Sd9IamfrpGl5ufMvYwAWiYIDRMSb4eh+5D77f6/1B9kvDAtVgluFGsK502bZr9qomNgti4Ba2ixzV69OiMv9MboU5eBK4AiilsyW+hgVK2SW4hJchhJ9xRZW+23XZbO0nSWlMFFt7PS7/rVUUVQvq5gtpPP/3UVg3pvMuwZXoOKq1kOi68W9V46bnV5Dhb0JHpOpmkByphslS5Hmcmer0oONPXUr0ewlwv7P7PYa5X6HVyLVdIfy/UQSX32k4fQ/m6Rpeb3zL2oAFo2CA0TEm+xrv+H5tttlmqZD7JzcUSG7iqgUTcmxapTEaPsXPnzqnBDQDILmzJrzdQirLhSSElyGEm3IVmYrRXubKqClZVxrv66qsHXq+qoFQTKO0jqiBVf5smjzoYq880MgbFk22rGmW3W7RokTXoCLO9TdgslXucCoZ0eY0zPb5sdDndluuqWuzXQ5jrhWkGF/Z6UVwn13KF9INGer61hZIONvipSIkTP2XsYRuTBQ1Cg5THe+9P+zDrPVW3q+A1F6pPqjhwnTRpkok7DWKVBjRs2NDElUqB08uBAaBcCi35jbrhSdjHE3bCHSYTo+3SFBQosNR1Faw2bdrUrjnN1Ggp03pV0f1omxqtV9UkcZ999rGPVcE425GURratahR85FqHmH4dP+WVYbJUjibhCoRct9rDDjssa5CroEOXe+2112wWsNivhzDXC7v/c5jrRXGdKDumx5XfMvYwWdAwQWiQ8nhvSb7eX3UwUwdRq2EtcTVLfFfhrbfe2gau2mAdAJBftpJf/Sw9e5jp6HTUDU/CliCHmXAHycRoUqWsqm7v73//uw0GdH+5Sn4zZVvd1jV6bJpgKUOxdOlSe1usV40H/b+0VZEOQvjZqsZPeWWh2+cEbejk7apajNdDIdcL23wtzPWiuE5Smvv4KWMPmwUNE4QGKY+vhLXDWFXiA9fjjz/eHgmfOnVqqmMjACC7bGsj1blWWcRcitXwJOhazbAT7nyZmJdeeslOuhSwLliwwF5HB0dzlfymN1rShEq/1+3qMajJkgJu0e2wXjVeXBCq8nd99bNVjZ+gstDtc4I0dErvqhrV6yGqLGjYbGaY64W5TjE7pseV3zL2sFnQMEFotjL+TOK+dhiZJT5w7dWrl7njjjvsfnbnn3++7SoMAAhOJaz5AtdiNjwJIsxtZsvE6HoqeX7xxRfNhAkT7KTLZVCzlfzqqyZz3qxry5Yt7XpVBRGvv/66LSumw2X8uQBTTbEUUObLbPoJKsNmqcI2dNI+rq6rqvYULeT1EHUWNGw2M8z1JMx9JXFrKb9l7GGzoGGC0Gxl/KgeiQ9cNbl44oknzP7772/XkeqN7oYbbrBv2AAAf5RtUjmsthXL1myp2A1P/Jbehb1Nb7C73nrr2WYqmugrYFeZsgIJBe7eDGp6gyUXXOirvlcw0qpVK9O9e3fTrVs3+7tnnnkmcZPgSuUNMHXeT9MkP0Fl2CxVmIZOurwOvKh8XefDvB6KmQUNm80Mcz0Jc19J21oqSBl72CwoQSgySXzgesUVV9gnYr/99rMlOw8//LD529/+Zt9UtE2BJid+OyMXuqcsAFQi12xJExVt55Kt2VJcGp6EuU39jcqo6mcKItTQT42VHN2GsqfeDKq4bKsCTNcJWJkJ3b5uY+7cuTaA1frIvffeO5Jtg1A63iBU67vzZTb9BpWFrNUL2tBJ3+sAjg6y6Pd+Xw+lyoKGzWaGvV6Y6yRta6mgZexkQRGVxAeuQ4YMWSUw1ZvpK6+8Yk9BELgCSCIXCOrgn8pdoyorLEbDk6C3qW1ENPlSNllb2Ggdryasum4mbt2qmieJblvPjSZ0Cmxc8KoMtZ9tgxBfYbaq8RtUhs1SBW3o5C7vsq06mOTnNVbKLGjYAzlhr8dBo9wKLWMHCpH4wFW8G77n+lkucd+vFgCKIb3ZkspnoyorLEbDk3y3qfd+/U1vvfWWzayq/4FuW+sX9TtV4eSjy7mgWH+f1q3Wq1cv53Uo+a08QTObQYLKsGWSQTNhriRZewuLKgA01vO9xkqZBQ17ICfs9TholFshZexBt4MC0iU+cB08ePAqTwoAwB9vQCqaiChgi6KsMMqGJ8pwatKtTED6bSrQdE1ylClVaa83eyoKMnQ57+NOp4yqJvfaZk2N/1QKPGXKlNiU/LrnYKeddsq6Dhn+hNmqppAuwcXKhLmSZK3N1sEVjUNdLt9rrNRZUC/GcXlFseWMn+2ggEwIXAlcASAUTY7PPfdcu+2LK2lcuHChDULVNbfQssKo1nq6NbgKRLUuVRlQBdDKMumx66QGS6JMl06iiZQLSDSpb9GiRcZgtU2bNvY2tSet6xoct+yN9zlQI55s65DhT9AgNOryykzZqjCZMFeSrNePDtIoS7nZZpvlfY2VOgvqMI7LL4otZ4LuMQw4iQ9cAQDhKKuq0mC3ntObEdHk2GVdw2ZOo1rr6bLCCgi0tlYTem95pIJlnYJ0o1ew2r59e1sC5/ZYjTP3HMyaNcsG2GG2EMJ/hAlCoyqvzJWtCpMJcyXJCiC0j70y8dnuNw4Yx+VXaLffoHsMB0H5cfUjcAUABObKf/U1nUpqtUZUX1WWWs4uucoKaHsZPR5Nzj/66CO7TtW716ofytSqBFiZVV3XlRCXS5ByyfR1yGG2EML/hAlCoyivzJetiiITFmeM4/gKEjAG3WPYL8qPk4HAFQAQOvORKXBV+ayymZpY33rrreaMM84oacmsJu/z58+3XYAVtGrNoboB6+du3ap3r9VcwaqyAApWtT2aykDjIGi5pHcdsiaKYbYQwv+ECUKjCipzZasqcd/LIAdgGMfxFCRgDNOJ2y/Kj5OBwBUAEDrzocn4Kh8sdevaCYqye7qcMpzK7ulovHfv0yjpccybN8/MmDHDnnTfChoUPGtCpd+r9Fjbfnj3Wk3PumrSpMmTyoDbtm2bWrtYqeWS6Y2x9LdpgkfWNbwwQWhUQWWxslVRCNo0KcgBGMZxfAUJGIN24o5D+THihcA1jUrbdHRezUM08PWGmmlilgn7uAJIAm+zpUxbh2liovdNrfNT0KpSSgWRbiKhktuw2Uvv5FhZQ02WFKjqPds1WHKUVdWERu/juj+dFGykZ101WVaQqmBVwXXYYDVst9Nilv2mb0OkMr5s2w/Bn3JlNouZrSp0HIdpmhTkAAzjOJ6CBIxhOnFXwwEdRIvA1fOCuv76681tt91mFi9eHOrJJHAFkAQKeqZNm2YDRk1WMr2fKvvpOuxqgtKyZUs7sdBaU5XwqkmSjs5vsskmtrTYD012HnjgAXv/jz76qJ1Uu61r0ilQ1uTFZVvdY9FXPQ5lH5X9Pemkk+zEptC1nmG7nerxnX322fZ5cVv16O/q2rWrOeecc+wkLmy5pAtyr7zyyoz3PX78+Fq/69Spk5k0aVLOx6sS7JtvvtlMmDDB3reeWz3effbZx/Tr12+Vx4vo1gkWK1uV/toNM46DNk0KcgAmPduq9w5p3ry5vR+qB8onSMBYrO2gSnVAB/Hgb7ZQ5TRZ2HXXXc2ll15qO2Qqg5DrJJl+BgDVTJ1Tr7rqKtO7d28b9KR3E06niayOpN9///3m+eeft0GZKNjRxOLFF1+0gaiCJQVE2fZI1fV0O0OHDjV///vf7XoqZXEVHGeTnm3VxEWBqia7msi4/VZ1mSgaFHkn7rpPfZ+PJlbKao0dO9YsWrTINq9SRljPzZ133ml23HFHM2rUqKwTeAU4+uom7unrjd1jiooek7opjxgxwk4uddsKvNXw6q9//avNWI8cOTKy+0viOkGNc31Nfy3kylbpezdJz7XPsB9z5swJPI6zBaGZ1r/nOgCj7zPdX3q21TVGUyM3Vz2Q7boonvQxqe3Cso3FbJ243Unfhx3HuQ7o6Of6PaoHGVdjTI8ePWzmwH0IHHbYYfbot94E9YaqTKrewPXm6N6c9XO9aeoIcxzXQAFAlObOnWuOO+44W0IYlCYkCjj1Pnvqqaemtp7RelPt+6rGSQpElXlt2rSpadasmf2qg4oqAdYkWmXA+qqJsW4v1zpVb7ZVBxZ1BF57U2pypMsqQNTt5srUFLtrrx5j9+7dbYZN9Nh0X61atbKP95prrrHBd9++fe3z0a1bt0Dlkt7H5Ciw1Ek0oVNGTYG8npvjjz/eboeSjTLceiyi8u/zzz/fdOnSxe5vq//rddddZwNYZYn1mPS5mlRhtuTIt06wWNkqLwULel3o9RGk+3TQpklB1qumX1avRW9Qo+/1fJN1Lb0gFQCFbAeV6/VUzPJjxFPiA1dlDV555RX7ZqtJg8qftH5FpVvu6N3gwYNTT5gyBTo6ft5555lPP/3UjBs3zjz33HN5u1MCQKXSgbz99tvPBpKFUJCqAEflhwrGpk+fbjOMmqzsvffeNqhUtlFZH01yFNzpaLzed9Wl2GVQ9X6dqzuwfqfAV4GwO5KvoEonLzfBVoC62267BSr7HTJkiLn88sttea0ywUG79o4ePdpOyEXdaVVK7RpI7bLLLvZ3yrgqYFcwqMlXkHJJ7zpkx3V6dnTwVX+jyqf1f1DGJBMdANBzILrsq6++atcEO/rsPProo+02RrNnz7aP94ADDkiVZydJmC058q0TDLNvbJhJuoIJ97j9juMwTZOCHIBJH8cKrDPJ9lpGcQQNGMNuB5Xv9VSKAzqIl8QHrjqK7Nx99902aM1FE6EjjjjC7LXXXnbCohdmz549bamb3ugBoNoyrVEErY6yOTfddJMNdDTR1QFATXaUTdUE1rv0Qu+pmqTofVfZWU1o9DNdThMjN2HRpFfv3Vpbp4yiJuCa/CprlI9uU7cVdr2eHm+Yrr3qqSDKWCr4VDbBe70BAwaYiy66yJ4UcN9www12EperXNI76dffpL9tyy23tAdoRZfzBpy5ngMvlXnrAIEogM10G3r+hw8fbte6KoN+3333mbPOOsskTZgtOfKtEywkW+WXAmEFHAoYgozjoE2Tgq5X9Y7jfPKNY0QnaMAYdjuoXK+nUh3QQbwkPnB9/fXX7ROhAZ3pwzgbvTk/+OCD9kizjj4/8cQTiS6NAlB9NDFQeXBUQas3eH3yySdtWawmygpMNeFQtjG97FfUe0ATEwWiyuIpSNL3mgTpSL+yt4cffrid/DZs2ND+TAGA7icfBX7KFIYt+1VGNGjXXgUeOiAgurweb6brqXGUAlcZM2aMfQx+yyX1N2miqOdAe+mKsh2777573ucgU8bdUclyNuq0q0mn/i9/+9vffAeuKsvWwd/GjRtn/P9XijBbcvhpLBM2WxWkdFnrxRUgqDmlGqb5Gcdhmib5Wa/qvT/vOM4n3zhGNMIEjK4Td5Ay+nyvp1Ic0EH8JD5wdUc4tbm8lzd7qjdkHRVPpyP7ClxVmqKyMgJXANVEWcEwa1r9UFCoCboCTReQKkBNn5xrIq6srCYuOq91mJoEK9jTz/X+rMmMJiZqvqSj/Sq77dy5c6qCJsh61aDr9RS4Bu126u3cq78/1/WUZdCETM2rNLEPUi556KGH2p/36tXLftXn3LHHHmuCUomxoxLsbNzzr/+jDgprMptv315Xlq2ssgKUcmwzE5UwW3L4XScYJlvlt3RZl1FJvKoadN7vOA4ahIZZr6rnw41jxEPYgDFoGX2+11OhB3RQmRIfuLqjeOlNKfTG62iwZ/uwVpZWR6O1rgcAqoWCSXUQLia9t2pyrKPzmgArENXk1Zt1UxCkCY/eqzWhV1bOG/S5vWIXLFhgM7j6XidNljV5VvZIfQjc5DzX9h5h1utpQuR34u5MnDgxdV6PL9f11MVXE0P9PxRQ5Ct1y1Uuqcqgxx9/3D5Xeo51H8rAKrOrQD8b71rVXOXXKpt2e+m6dcV6/Lm44Ed/o/73yvyp23OlCbMlR5B1gmEDej+ly/qZxruCRgUGfsZxmCCU9arVIWzAGKSM3s/rqZADOqhciQ9cNfHRiyp94Oson6MXS7bA1V3P27kRACqdtqnxU55XCAU6ag6kCXJ61lWBlYJEvT+7da8KXN2WOqKAVYGSrquAR4GdN8OnifNrr71mgwCVQCrjqO7G6uabKQAMsl7PPQ5NqoJ0O9Xl9XgcNUTKdT1vhljr/PJljHOVS3rvV1zDKm1XpOdE61L1nKbzBpKTJ0+2TaMySd/XV824cgWu3uBH11PGTwcXtKa60taihdljtdiNZfyULrvLuGyrxryfcRwmCGW9anUIEzAGLaP3+3qq5AoNhJP4wFVH+zUxSt+P0PtBPXXq1Kxd6vTCkyj2AQSAuLj33ntLcj9q5KPJi4JknfRerAmJAjAFowoQ3Rpb7XWaicu6apKsMmFHpaq6DQW2CpB1Xg35VPrqOvnqpIlT0PV6CrDFTd78lu/qq0rlHJXRaY1vtuvpcTvKimYLGnNRBu2QQw6xnZsVSOoAgZ5nBaG33367fT6eeuopW5KpzvrpE0mta9UBAT2fasB0wgkn2MmjlyayF198ca2feR+7n7JsBUh6rJXWATTMlhylaCzjp3TZlX26cnCtvVblQ75xHCYIZb1qdXDrVYPQ+6PfMnq2uEEuiQ9cVXevF5TbS8/Zdddd7RF/fRjrg/3MM89cpbW/1uXoenoRtm7dOucTDQCVwu1zWgoKXBSsqARYAaOCOGVHVfar3+k92K3tzEWX82b7RCWxuk0FAHqfdgGuqmh0P1r7Om3aNPt+7zIBfst+XfCp7FjuKWVXAABGvUlEQVS+xn7e8l199Wa0lAXO1pHebQfkaOIXhv7OTHu0qgOwtn5TYKpsqQLZv/71r3Y7G++6YAX5p59+uhk5cqT9uf5+bWukQFpBvMaKtgfS9nD63HTZ6FyBa/qBAh1AUJCnzF+ldQANkzkNu07Qb3Mbv6XLruxTVWXq5aHxnn5QItM4DhOEsl41mYKW0bPFDXJJfOCqo0Yqk9KLSJMld6RUHwj777+/XRulCYu2v7nkkkvsJEMTlqefftpcffXVqSdSHS0BoBpoMqFJaaloAq9JrTKq3rJfBa8qE9ZkJx8FULp8pmyrzuu9Xe/x6WXFCppefvllm/lNX6+XvsZX28pceeWVtX6mzKvr2pvJaaedZvdldeW7+qrAwJVYZutW7Cb83mBcgVAYCi6mTJmSsTmVAhZ1AFYmVn/zLbfcYoPU9H1shw0bZj8ntTWOgiyVFqfTbegxu4ZeuZbQpJdl6/+v4FqZP42HSsm6hs2chlknGKS5jd9SS1f2qf+bDtbocptttlneMnSCUBSjjJ4tbpBP4gPXAw88MJVZHTt2rM2sOtdee6156aWX7IeRPnCOOuqojE+ijh7169cv75MNANkoi+LNxJWTt+ttKbjuwqISVk2gFRxp/WfQahaXldRtKjDS7SngUxZMX93tKyDTe7eoY6+CWgXO+h9EmW32dvcVTdoUYLvg7qCDDsqa4RKV7noDUB009dMdOb1rrzcITQ+U9Two+6qgVGteFRxl2sf2mWeeMffcc48N1PWZ6NYeK/A85ZRTbFWS7sub8db9p99fprJsPT7djgK8Stp3MWzmNMw6Qb/NbYKUWrqyT92mDhxoXLFlCKIStOyXLW6QT+IDV2VWtWZHR81daZijUhyt++nZs2fWTor68NCHeXoZMQAE/YBXVsW7/rHUXLOkOXPmlPR+FbR6G+ApY6WmS9kCeb0fax2eOvJmaiak6ysAc1kqTZIUJGhiruBUP9fvNYlS1lX3pRJVVy7pAkk3yfLSe72COU26VFarIDLXemA9xlw/09+RK3B163pVTqysqQK9fN2RM2U204PQdPq8U+AqOmCr+8m0j23v3r3tSeNEWWp9bur51fY3KhXWz7zPVab7y7SNim5PAZr+n4U2JaqEDqsKGPWcR7WnpRelloiLoGORLW6QT+IDV9Ean2zU3VBHIu+66y5bTqYAV2ujdIT64IMPNieeeCKNmQBEQkGrJqT59r6MkgI6TRZUzqgyTbctRilp4uKd+CtA0vfekktHP9MWZHqcCpK0nUv686VMnzJZCkZV3qjf6+/UV32vnyuo0uWU7dN9ubW0mkxlK5UUXV9LR2666abU9/nWuKZToOIo4MsVnKlZjuixKWORLwDNltnMFIR6edfZaqKpgDnXPrY62OCy5O5+9PnotsPRBFXn0+8v2zYqOul/q4MLGn+VknUNuyVH1HtaOpRaohwyrb0OMxbZ4gb5ELj6oBfXRRddZE8AUEwKrvx06iyEJssKTLRdiYKN9ABR2aBSUnMk18U3H5UAK1DQRKlZs2b2qyv5Ff0taiCkv1GXU2muNyjT9+73+qqyXXUO1s8VwCuD2rVrV9+PXcFX0PJdrXl11GPh1FNPzXgAVMGJKz1V9tdPAJqra2+2IDR9qxwFSH73sfXej0qs3VjS/zPT/WXbRkU/0+RW11c2Jr20Nq5cqa3fpklO1HtauqCXUkuUWraDMGHHIlvcIBcCVwCocioBVjZVgaoCVtcZNBt1+FWg49YwFpPuR1lLPxTUaD2qMnnKcOmrvleG1GVdVXqryb2yqqLgNBP9XkGVAjFtf6amRPp7dZvKqPrd4kwBiwKzIOW7Cj41UXOBh7Zc01Y16bSvqqOuu34CUCc9s5krCNVz6NbSKoDX48q3j236/WiNsIIwUVWSmvjo+/T7y7aNin6uNbx6rK4Dsre0Ns6CZk+LtaelUGqJUst2EIaxiGIgcAWAKqTJsbKpClYVzAVZO6vJs4LXfAFuFFSyO3v2bBss5iuR1t/iDUr1VRkv/dxlXd0WOpnWjaoRn9aw6qSyTZW6KjhStlEBk4Jc3Z6fMlxH1w9TvqvMnNasasJ36aWXmo4dO9YKetX52HWu1/9CwZz+H+kBaK9evVLZS++BBpcF1VcFvdmCUJVbH3HEEanOzZp4ZtrHVmXV2i4nPeuq3ynY1/pWVyasoFXZcAXo6feXbRsV/Q/1/9Q41eXTS2vjLEj21Hv5YuxpSaklSinXQRjGIoqBwDULNSdRZkIfpDrKrw3XASDO1OBG71s6KQPm9tMMQ1lIZQKLTdlWBUre4DNftlXnNXHXhD8966rbcFvoKFDV7av0VF81sfeWDSsw0gTr2WefTQVNmnj5KcN1z63uJ0z5roJnBcl6/Frnqn4KF154oc2mTZ8+3W67o98pe7nvvvva/2mmLKieu1zZVpXfqRGVrq/rKkOsAEnjQ3/3qFGjUgcotNZXwbweQ/o+tpqMjhkzxpb2KqOo51vjTWt9NU6U0RcFyeqkrAmtSqd1f97nJts2Kgr+daBFWZpil8pHKWj2tNh7WrrSZaAU8h2EYSwiagSuHpoIaFP1Rx55ZJUuwumBq45Sa5N2TZC0tmngwIGR/3MAIBdlrrS9i1uv6jKRYWlSrOBFp8MOO8wGGG57mWJQUKYJeKaS31zZVmVp3Sk966pJk/YTVZZSQZc3UM1EgZj+RgVeuqwCOpepzJU9dSXIKlkOU76r88p0ag9VBYDagih9GyIFt9ouR3+ngrr0LKgrA861tlXBu84rGPb+zenUYKp9+/b2Oq5hkqPvNRFVlvSJJ56wp0z09+uyb7zxRq2fu+dG61sV1FaTINnT9MuzpyUqWdCDMEAUCFz/S8Fq37597Qdz+rquTBMfbZugI8kqndIWAtr/lS1xABSbJggq/XWZ1UyBSxCaPCtQVdCojJz3/e7kk082t912WwSPOvt9K3jNVPKbK9uq67nr6zoKzNSd8pBDDrEltfmC1UwTL51XtlABRb7sqf4HbpsaHTxQ2W+QJkZuGxg958qmquRTP9ff5zrtas2ryodVfjpt2rTUtjHeLKhuR/efa21rt27d7GeVAm233ZJ+rgmlnj8Fxnq8GlO6n2yBrbapURms7k+3odvSZ6UOPKh8VQcLXIlvtgx1KUrP4zxxZ09LVJMgB2GAqBC4GmOefPJJc9xxx9knRB/EmvjoqLDWGGXrgibay06Bq164L774ojnyyCMj+8cAgKMKENdYSZOCQpomKQOnwMhlVnMdcFOlycSJE225adQUfClYzVbymyvb6tap6r1az4WyngqgFMhp8hRm4qXATCfdT77sqX6uzwgF3bpOkCZGLqB02dMWLVrYQEdrP9XheMCAATbo1eVHjBixyrYxjivD7dGjR+p6mbr26rb1ON3/29Hz16FDBxvY6jK6vJ8SXf296gKt7eD0/9A63fT1qtn+3/obkzxxZ09LVIugB2GAqCQ+cNVR4z59+tjJjz7cL7vsMrvOSB/q2t81V+Cqo/uaYOlIsvZ4JXAFEAVltTT5dSXArulNWMrUKSBU4KKAx+8+sbqc1lpqu5b05ROF0ERGgZ7WU2Yr+XX0/uq27NH1FFy5/UPdREnv00EnSukTL7eVjSZgakSULXuaLQD1lu9mul56tjVT9tQb9GbbNiZdehlutq69ubKg2Rom5QtAs61XTYKgE3f2tEQ1CXoQBohK4gPXO++80wavKi0bPHiw7e7olyZPamCijpj6gAKAsDQJUKCqkk016/Fm18JQFtCVAGsi4bd8Np0Cs5EjR5qzzjorkuBVk/jWrVvbvze95FcBuv5+9Q1QUKT3WFW+uL1XFQiqFDOToPt+pk+8dLDSTbxyZU+DBqCZgt1s2VNv0BsmAJUwQWiSA9BSTdzZ0xLVIsxBGLKuiEriA1etTxU18rjgggsCP4GagClwzTaZAoBMVOWhTKLeP9TFvND3EE0MtAWJKwnVBDoqOkB399132wN7hZQNK7BTIKYJjbKsCkRVuqyJviY+Cur0Xuw60oqCWQVm3jLXbPzu+5lp4qUgRI8hWzdcV74bNADV9cJkT8mCVtfEnT0tUS3CHoQBopD4wFWbxisTkb6Hnl9uPVWUZXQAqnfCqw95F6xqclsIZSRdVlUBj4LAYlHm9d577zX333+//Rqk27DeW7t06WKXY+hvVoCpIFvvn+59V4F3ppLfKPYCVDCpyZOaKCkTnWnipe9VGq3H49b9ppfhlrJ8lyxodU3c2dMS1YKDMCinxAeubuKoTEAYbi8/TcgAINOHvMoFFazOnTvXZmjC0kE2dTR3waoa5YQtAQ5Dgd0pp5xiGwJpmcW4ceNS+3dmC6y1xcr+++9vJ/E6UKgAVD933XvzHaX37kuZHoD6PVjwwgsv2E64Cii1B2mmiZd+pnJhlc/q/jOV4ZayfBfVNXFnf1VUCw7CoJwSH7hq4qeJl46ih+H28lN5GwAoQNFaVZdV1drNQigDuMkmm9hAVV/dWsxy0mPQe54qVRS8pmdfte5TAbZOClJdMyj3fZiS30wBqJ91U24toraV0XYubs1hehZXAbMetzKdeq4zBZKU70KYuCPJOAiDckp84KpyNVeaFpQmUmqiooyHJkQAkkkBkLKpClR1KrQLsLZ5cWtVFezFraLDWyqpYM9lfV0FikqW3f6sOjjourDPmDEjdMlvtgDU71pEHZz0liG7LK6j29XzrnWq2dZjVWv5rg7AqqxZTbHc2mJkx8QdAMoj8YFr586d7URGk6BZs2YFWkCudV6aoGrSpvVbAJJDlRoKUpVZ1Ro3b3OWoBToaTsNBU5qqhT3RhbeUklvuaSaTXkpqHVrbxXApgeLfuUKQHNlXb2dX/U+Xe1bNIQJQFW6/tBDD5nly5fbUu7+/fuH6vcAAECxJT5wPfbYY+0m73L66aebiRMn+irF04R14MCB/3kS69Y1xx13XNH/WQDKR6Wl8+fPT5UApwdpQakBUNu2bc22225ru/Yq+NVt+umKG9dSSffeqWBSAavKbP02TMolTACa3vlVe8Oqc3O1btEQNgB12/vowG27du1W2f4HAIC4SHzgqiPThx9+uBkzZoyZNm2a2Xvvvc3tt99uJ5SZaPKkbSEuueSSVLa1d+/etdZEAagOWk/53nvv2UBVQZKf5jq5aI2qAlW9vzRv3jx2JcCFlkoqUNVJf2OuoDDIetWwAWj6Ppsq8820v2a1CBOAerf3UWf89G18AACIk8QHrjJq1Cg7OdUaNa1Z1Ye+sgDehiOHHXaY/VDX9gf6sNcejLLDDjuY4cOHl+0fCCBaS5YssYGqAoB58+bZzGJYCqi017MCOQVYCpyqmQ7kKXucL5MZZL1qmAA0PdhVGbYoC6z3+mJmXaNaLxrkdsIGoC7Y1cED/e/cNj5kXQEAcUTg+t9GKCoR1lH/SZMm2SdGkxtxTUeefvpp+9UFrKJ1rY8//ngsunwCCEdrUxWguhJglbAW+n7isqoKWpOUuXJrdKNarxo2AE0PdlWuLHpsfrOu5VwvGvR2wgSg3mD3l19+sc+hng+yrgCAuCJw/S917nz55ZfNgw8+aG688casG8uLMgoXXHCBXddaqaV+QJIpINAkXYGqAiA/nW6zUaCgsl8XrKocuJR7q8YtcM0nyHrVMAFoerCr33sbZ+l77d+dK2Au93rRILcTNgD1Brvax1zrjPWVrCsAIK4IXD00iTr++OPtSR/6KhtWsxSVXmndloLbDh06mBYtWpTvPwYgMFVK6LWsrKpOCxYsqFU9EZSqLLScQIGqAgWt+Uw6Zap1wE/PTbZmS0HWq4YNQL1b9YiaXmXigl5dPr2LcznXiwa9nTABaHqwu/nmm9uf6wCMLk/WFQAQRwSuWegDX+taAVQmBT4KWlwJsIKcQijIUVZVp5YtW1ZVR9pCuWZL6ois5zlbs6Ug61XDBqDerXry0eXSuzjrbynnetEgtxM2AE0PdrVtkegALVlXAEBcEbgCqBoKQhSk6qRma5rYh6VlAMoIuhJgBQ9JLQHOxwWkymQr4xpFw6SwAWi2rXoyybRVj8ZOudaLBr2dMAFo+n1o/a7+N46+V/acrCsAIG4IXAFULAUoCxcutMGGMquLFi0q6PY08VewoEBVpcAKAJCbNyDVdkFRNUwKG4Bm26rHz76x+ltU7qy/oxzrRYPcTtgAVA2n3H1Itn4O7j51+d122y3vY0+6IPsSAwDCIXAFUFEUyCib6jKr2k+5EMr8KVBVZlXr1+vUqRPZY00CP82WwqxXzRaAhuF331iVI7vLlHq9aNDbCRuA6jlWhnrLLbfM+7zpcro8cguyLzEAIDwCVw9Nvp577jkzffp0M3/+fDsh9h7BzkUTNnUlBhC9r7/+OrVWVcGFN+gJSoGpJu1uvaqCJoTjt9lSFA2TCsls+dk3VmNKJcsqOS7HetGgtxM2AN1zzz1tJltZ5Xx037o8TGT7EgMAwiNw/W/H0euvv94MHTrUThzCXJ+1b0B0NNHWwSNXArx48eKCbq9hw4Y2q6qTtrNyZaoojN9mS4U2TCoks+V331jt5au/RWNNWxqVcr1omNsJG4Dqf3TooYfmvQ78CbIvMQCgMASuxtj9WB999NGCtscAUBgFI8p4KVhVwONnQp6LgiRXArzZZpux53LEgjRbKrRhUiGZLb+lzNqv9dtvv7V/S6nXi4a9HQLQ8guyLzEAoDCJD1wffvhh88gjj6Qypq1btzY9evSwE15lDurWTfxTBBSFDhQpGHB7qyrjpeAmLGU39PpViamCJWWWUDxBmy0Vul41TGYrSCmzMp0aj/osKPV6UdadVqYg+xIDAAqX+Khs1KhRqSfj3HPPtSXD2gYDQPS0jvCjjz5KlQAvXbq0oNtr1KhRarsaBa1+thxB4cI0Wyp0Ah8msxWklFkHTZRZVVltrnXPxVgvqoDnjTfesGXs+Q64sO40PoLsSwwAKFziA9dZs2bZSZC6iQ4bNoy1qkDEli9fbidwClSV2fJTLpqNXqtqmuNKgJs1a8Zrtgyiarbkt9FSmMxW0FLmzz77zDbuUvCh0vJSrRfVY1NTQB0wVbl8nz59OABTAYLuSwwAKFziA1c3ie7YsSMTYCCiEmAFAS6rumDBgoLWj6sEVZkoBaqaBKrREsorimZLQRothclsBS1l3mmnnWwGX1nXbB2Ni8F1E9ZB1Hbt2vne8xXlFXR8AQAKl/jAVUfW1ZSD8mAgPGUclHVzW9aoyU0hNOFz29W0atWKteYxE0WzJb+NlsJktsKUMpeDt5vw999/73vPVySvVB4AQOBqOnToYObOnWvL1QD4pyyay6rqNeR3z+NMdOCoZcuWqRLgpk2bUgERY+uuu25BzZaCNFoKk9kKU8qs24uCqg3UvEkZXGVvc/Hu3aoyeL97vqK8otyXGKgGYfbXBsJIfMb1rLPOMqNHj7YTBU3CNXEGsCpl2BYuXJgKVhctWlTQ06R9MhWoKFDVh53bNxPVP3nx22gpbGYrTClzFIGrHuNDDz1k13Wrkqd///5ZM6fpe7fqsevvJ+saf1HtSwxUgzD7awNhJT5w3XHHHc3pp59ubr/9dvtimzRpkmncuHHoJxSoJioFVTZVgaom1cuWLSvo9lTm6bKqaoimZjhI1uQlSKOlsJmtMKXMS5YsKel6VW+2tUmTJjbQ11eyrvEX1b7EQDUIs782EFbiA1cZOXKkPSp611132Un1xRdfbI444ojUWiogSRRAuLWq+iDyZriC0j7I2uPSBau5thlBMiYvQRothc1shSllLjRwDbJeNT3bqk7Z0rx5cxvQknWt7lJ5oFqE2V8bKASB63/X191xxx22c+l5551ny7t0Wm+99exJpWz56DLz5s0r6J8BlIMm/PPnz0+VAC9evLjgSZ0rAW7Tpk1qTSKql9/JS9BGS+XObBVrvWp6ttWVyWurHbKuACpFmP21gUIQuP53MnXOOeeYe+65x77w3NYdOnqvI+f56PJ+glsgLlTOqUBBgaq+/vjjjwXdnjJiClSVWVWnbrp0J4vfyUvQRkvlzGwVa71q+mUVEHsbm+l7rRUm61rdaGaDShdmf22gUIkPXJVt0gby48aNs09I+n6Thew/CcSFxrFKIV0JsKoDlMkKSx9Gyqa6YFX7XyKZ/E5eyrmFSJggoVjrVZXBdZeVmTNnZrxNd11dfrfddgv9tyN+aGaDahBmf22gUIkPXO+8807z4osvpjKtXbt2tU1FNCHXi1Br9IBKpKDgo48+SgWrS5cuLej29Hpwa1W1hpF9JhFk8lKuLUTCBAnFXK+qwFwHTLX2Ox9dTpdHdaGZDSpdmP21gSgkPirTVjjOsGHD7BpXIAhNiJU1UZZJb+CanCrrpMl6qbd4UVmjJkUKVjXx97M2MBsdzNEk3GVVmzVrRkk8Qk9eyrWFSJggoZjrVffcc09b7eCnPF+3ocujetDMBtUgzP7aQBQSH7jqRaWJiUrICFrhl7IwDzzwgLn33ntt0Jqp7FbrPPWGffLJJ5sTTjjBrteLmqoE1EDGZVUXLFhQUHm7PnzUpEzBqoKNhg0bRvp4kezJSxSNloKU/YYJEnSdYq5XVUZay1OQTDSzQaUr57IPIPGBq9OhQwdGA/LSm/N1111nrrrqqrwZE03S33nnHXu68MILzaBBg8zAgQMLLj/XB4WaxbguwIVmpjT5d1nVVq1aUR6Pok1eCm20FLTsN0yQoNcV61VRDDSzQTUo17IPQBIfuKr8USVkKk0Dcpk7d6457rjjbLOUoBTkan/gMWPGmAcffNA2NgpCwakLVPU4vFmdoJQJbtmypQ1WdVI5I12xUQmTlyBlv2GCBF1HFRR6vbJeFVGjmQ2qQbmWfQCS+MC1S5cudsKVrbNj3CjLcPPNN5vnnnvOLFq0yNSrV88GIT169DD9+vUr+ZrKpHjrrbfMfvvtZzNIhVDQq3Vu48ePNzvuuGPObO3ChQtTJcD6XxdCa+VUWqlAVV8ZJ4jD5KWYZb9hggR9FrhsLutVEUS+sUwzG1SLcu+vjWRLfODat29fc9ddd9ktD6ZOnWo6duxo4uqZZ56xGb9ly5alfqZJloIqnUaNGmUDWpV7IjrKcEYRtDq6nX333deuefNmXvUhoImPAlWd1GipEGqU40qAW7RoYerUqRPBoweimbwUs+w3TJCgMmf9TgE261URhJ+xTDMbVIty7q8NJD5w1f58Q4cOtWsQe/bsaV5++eXAZZylMGPGDHP00UfbiVuDBg3MRRddZDp37my/f/TRR23wrWzBgQceaINYmupENyHRwYKoglZHt3f88cfbgxEuWFX5o3eNYFBaO6vySQWqOmlSD8R18lLMst8wQYJuT9dZvHixbb7E/qqIaizTzAYAopH4wFXUMKdRo0amf//+tnzz9NNPN0cccYSd/BejE2wYemz6YFRwojJT74b0KnfWnoD6OxS83nDDDWbIkCFlfbzV4vrrrw+1ptUPHWBQd9FcJcP5aHxq0q7Mqg64uAk6UGpxKfsNGySowkEZ5M022yzvQR/2V0WQsUwzGwCIRuID1/TySW0lMmLECHsKQqVrhWTLcpk+fbotY5ZTTz21VtDqnH/++XZrFn1A3nTTTbYREO3HC9/yRt2Di0kdhxV0uu01/NCaQlcCrEm2mi0B5RSnst+wQULr1q3t2m9lZfW6yoX9VRFkLNPMBgCikfjAVYGqt6Oq93wh+2FG6amnnkqd156gmSh40V6hKiHWh+TEiRPtOkqEp31a8215Uygd7NDEWkFoNpqMa29VVwKs6gAgTuJU9hs2SNASDB0U1N6rbN0AP/yOZZrZAEA0Eh+4xilAzebVV19NHeXPVVbaqVOn1Hk1/iFwLYwy2KWgjE964KpSSLddjcrAg2RkgVKKW9kvQQJKxe9YppkNAEQj8YGr1jTFnQIbUbdgrXHNxttUyl0H4SjTWqotkr7++ms7GVeA6kqAtb8we6uiEsSx7JeOlyg2trcBgNJLfOAad9pqQpM52WSTTXJeVkd7lZVV0BV0389PP/3UV1mdy1AXu4S23N54442SHdTQ83nwwQfbJluO1goiWfQ/1+tdJwVrlTJ5V5MxBY56zNp2af78+fZ7/Vylk96sq7Yd03Zen332mVlvvfVsjwHdhg7I6Xv3c639VgC6ZMkS+3y4ADcXXU6XD/vcuede/4dqf3+Lo0ob/0HHctwx/sur0sZ/tamG8b/OOuuYJFitJu51sgm3dOlS06RJE3te2+Fo65tcmjZtart7Kms3e/Zs3/dDdg8AAACoPDUJCedoRxpzOgLk+FnnWK9ePfuVI3YAAAAAqgWlwjHn3ZdTa8Ly+eWXX1IdN4PwU1q888472xJAdd3MttasWjzyyCOmT58+Jbu/UaNGmZ49e5bs/hA/c+fOtaWGlUKlkiqp11pWdeRVmbCjcmE1atJa1V133dWWSmpLL11WP89Ht6frduzY0ZSaSpu9/QJQGpU0/itlLIfB+C+PShr/1YzxH38ErjHXsGHD1Hk/H5KuNl8flkHkWz/r3fNWZcXVXkv/xz/+seT3V+3PKXLL1TE8bnQQbcqUKXY9nw6SqamYd/zq/UfNzfR7bTfTvn17u0+qruNn/ZBua6+99rLr9pEMlTT+GctI8vgHyonAtQIyro0bN7adZ/M1UPr2229Tk0I/exgiO3VD1d64pWjQpPtp164d/w5UjLffftseSPvkk0/s99k6cOv36hisy2uP1EMPPTTwfanJja6/00472WoPoNx0QCXMWAYAFIbAtQIoG6fSpI8++shum5JtSxyVmjhbb711CR9h9Vl77bVt8KqOkMWm+9H9AZVCnc7VZVxbOOWjy+nyYQJQZXYfeughs3z5cvPBBx+Y/v37s6cxAAAJReBaAfbcc08buCqbqolfhw4dMl5u8uTJqfN77LFHCR9hdTr55JNLEriecsopRb8PIEp6T1I1gt+y31122cWMHj06cAD65ptv2syu1tOqKkHf894GAEAysR1OBZg+fXoqWO3bt6+5/fbbV7mMJpHaAuf99983jRo1slviePdPjILWwSpr0qxZM1/7vla677//3v6txdzTS5P6zz//3Ky77rpFuw+g3P7xj3+YcePGmXfffdcGoPvtt1/eAFTZ1hEjRthKEzWD22qrrUyrVq3MgAEDyLoCAJBAbIdTAZStcB0J7777bvP666+vcpkbbrjBBq2ibEbUQWsSafP4QYMGFfU+dPsErahmCkAVuKojuQ4G6au+z9cl3WVbtU5WDeH0Vd/r5wAAIHkIXCvETTfdZLt3ao3rvvvua66++mq7FcXEiRNtFnbgwIH2cspKnH/++eV+uFVDz2uxuv1prZ/7vwHVKkwA6g12tcWX1vnrq9+gFwAAVB8C1wqxww47mMcee8xm5zTpU6ZOXTq7dOli7rzzzlTQ+txzz9XaQgeFUSOsBx980GywwQaRPpW6Pd1utkZbQDUIG4B6g90mTZqYDTfc0H4l64q40jKap59+2i79AAAUB4FrBTn44INtk5Jzzz3XBqnqRKv1rMrcXXvttWbGjBl2DRii1aZNGzN+/PjIglfdjm5PewEC1SxMAJoe7G6++eb2582bNyfrilhy3a81nvWVigAAKA4C1wqjydvw4cNtZ041DdLerfqwVMkpW6oUj8qFNZkutGxYBxlee+01NhtH1QsbgKYHu+59TY3MyLoijrzdr9U5m3XYAFAcBK5AgMyr1hUPHTrUTqKD0OV1PTXWItOKJAgTgKYHu9rv9bfffkud9D1rXVENzccAAMERuAIBaE2q1hdrHdPIkSNN+/btzeqrZ34Z6ef6vS6ny+t6rGlFEoQNQLVPtQt2ZebMmfb37qTvxQW9unyUWKeIoOh+DQClQ2cYIAQ1yerXr589/fvf/7b7U3788cd2Ml6vXj2zxRZb2P0qKd9GUijoUyCpcngXWHoD0Ez0+4022sheT83mvvrqK7Ny5Uqz5ZZb5r0/XU6Xj3qdoko9tRRD24qtueaakd0+qv8AzTbbbGP++c9/pg7I7LzzzowhAIgQgStQIAWnmnTrBCRRetDXsmXLUAHonnvuaX7//Xe7fj8flRzr8sVYp6iDTvp+jz32iOz2kazmYzogwxhCEg9cqqIGKBYCVwBApEGf9pzeZZddAgeg66+/vjn00ENjs06RjBnCNB/T64ExhKSgWgWlROAKAIg06Js9e7YZMGBAxZRJZlqnSMYMhTYfYwwhCahWQSnRnAkAkNjmNOmZsz/+8Y90LkagMUP3ayQVXbVRagSuAIDEBn251ilWUgCO0il392sgLir9wCUqD6XCAIDYN6cJ2/wj1/VYp4gwytn9GogLumqjHAhcAQCBlTLoC9v8I9/1WKeIMMrZ/RqIC7pqoxwIXAEAgRUS9AXNnoZt/pHretnWKTr6/ssvv6Q7LFZRru7XQFxQrYJyYY0rAKBkzWlcFlRBpL7mWwcbtvlHvuuxThEAinfgkrWuKAYyrgCAQDIFfZm4rKsuv9tuu4XKnobdqibf9VinCADBUa2CciJwBQAEEjboy5YFzbYONmzzDz/XY50iAJT2wCVQKAJXAEAgYYO+oNnTsM0//F6PdYoAEAzVKignAlcAQNGb0wTNnoZt/kHTEAAoHqpVUE4ErgCAoguaPQ3btZgtbgCgeOiqjXKiqzAAoKhyZUEzdR8O27W4kG7HAAAg3si4AgAKlmtv1qBZ0LDNP2gaAgBA9SJwBQAUxO3Nunz5cvPBBx+Y/v37p9adhtk6IWzzD5qGAABQvQhcAQAFybU3a5gsaNjmHzQNAQCgehG4AgBCy7c3a5gsaNjmHzQNAQCgehG4AgBCy7c3K1lQAAAQBQJXAEAofvZmJQsKAACiwHY4AIDI92bVz/V7AACAKBC4AgCKvjcrAABAIQhcAQCB+dmblawrAACICoErACCQbHuzupO+J+sKAACiRHMmAEAgYfZm3W233XiWAQBAaASuAIBAwuzNCgAAUAgCVwBAIOzNCgAASo3AFQAQCHuzAgCAUqM5EwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMRa3XI/AKCaDB8+3J4AAACS4rzzzrMnoJhWq6mpqSnqPaBqKCBbtmyZWXfddXlzSvPpp5+aTTfdtDz/GAAAgDJbtGiR2WSTTcr9MFDFyLjCN46k+bPRRhuZOnXqMLKQGCtXrjRffPGFPc/4R9Iw/pFk3vEPFBuBKxCxN998kyOOSGzFAeMfScP4R5JRcYZSojkTAAAAACDWCFwBAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAAAAgFhbraampqbcDwIAAAAAgGzIuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAQAwsWLDCrrbZapKchQ4aYJJk/f755/PHHzcCBA03nzp3NuuuuW+v5QHwx/gvz7bffmieeeMKceeaZZvfddzdNmjQxa665pn0NtGzZ0vTs2dM89NBD5rfffovoP4YoMf7D++mnn8ykSZPM1VdfbY499liz44472vFfv359U69ePXter4nzzz/fzJgxI8L/GsqhblnuFQCQGJpUKJCUTp062e+jtHjxYrPtttuar7/+OtLbBeI+/n/44QdzzDHHmPHjx5tff/11ld8rUF2+fLn5+OOPzWOPPWYuueQSM3r0aLPXXntF9hiAcr7/33rrreb//b//l/X3S5cutafXX3/dDB8+3Bx99NHmtttuMxtssAH/uApE4AoAMaDMSL9+/XJeZvr06ebNN9+05zfeeGNz2GGH5bz8LrvsYpLgl19+IWitcIz/8IHrs88+W+tnTZs2NTvttJPZaKONbOA6c+ZMM2vWrFRmb++99zZjx441Bx10UAT/OUSB8R+Ntdde22y99da2yqBRo0ZmxYoV5tNPPzVvvPGGWbZsmb2MDuC899575tVXX7XPOyoLgSsAxICO/o4cOTLnZVT66wLXLbfcMu/lk6ZBgwamffv2NmDfeeedzc8//2xOPPHEcj8s+MD4L8z6669vTjjhBHPyySebdu3arfJ7TdL1e5XTazLfq1cv8+GHH9ogF+XH+A9Pn4VDhw41++23nx37deuuGtros2DEiBHm4osvNr///ruZPXu2GTRoEJ+hFYjAFQBQ0TT5njNnjj3Svvrq/2vdEHVJGhA3Wsd62WWX2fV7ubJHe+65p3nllVfsxF6ZJ500kde6QKCSHXroofaUi9a7XnjhhbacfvDgwfZn999/vxk2bJj9HSoHzZkAABVtrbXWMttss02toBVISqbu8ssv91XyuPnmm5vTTz899f1zzz1X5EcHxMspp5ySOq+13x999FFZHw+C41MeAKrU+++/b8uhVDqrrKSyMxtuuKHp0KGDzdJ8/vnnvtfR3X777ebAAw80m222mV1HtMYaa5j11lvPtGnTxhx88MHmqquuslnP9NJmdfN1jTlk8uTJGTsga1INMP6La4899kid13pXVC/e/1elzz8vBa+oMDUAgIowePDgGr1t69SpU6esl/v5559r+vbtW1OnTp3U5TOd1lprrZpbbrkl532+9tprNc2aNct5O97Tb7/9lvHx5js1b968JmoTJ06sdR+obIz/wj399NOp18Paa68dwS2iVBj/hXvnnXdqfSZ8/vnnEdwqSok1rgBQRX788UfbpOIf//hH6mfqsKi97dTA5ZtvvrG/U7ZV+9+dffbZdr2bMrPpFi1aZG/LHZVWllVNj1q1amWzrrovZW3efffdVMdGL2V61Sn5s88+M0899VTObsiNGzeO+JlAEjH+c1NTGmfTTTct+v8DpcX4z07rW7XO1dHerv/3f/9Xkv8LIlTSMBkAUNQj7ieccELqMltttZXNOqZbsWJFzW233VZTr149ezllZpVZTTdgwIDUbXXs2LHms88+y3ifyrJOmjSpplevXva2c2U+c2WKo0bGtbow/guzcuXKmjZt2qRei/369YvoP4NSYPwH98svv9QsWLCg5oEHHqjZfvvtU2O/YcOGNW+//XYR/ksoNjKuAFAlpk6dajsluiyrMqt/+MMfVrlcnTp1zBlnnGGbGmn7jJUrV5orrrjCvPDCC6vcnnPPPffYbGkm2n5AG8vrBJQL4z+32267zcydO9eeVyMzvQegejD+//d5pM+0bLbaaivz5JNPmrZt25bsf4Po0JwJAKrE8OHDU+dvuOGGjEGr10knnWSbK8m4cePM119/Xev33vLf9KYWQNww/rP75z//aS666KLU96eeeqrtxI3qwfjPTQdstSRGrwWC1spF4AoAVWDFihVmwoQJ9ry2xjjooIN8Xc91/K2pqam1LjZ9DZy6CgNxxfjP7rvvvjPdu3e33cFlyy23rBXkoPIx/v9HfRXcSQdn9957b9OwYUObhVX3e+33/eKLL5bxv4VCUCoMAFVg1qxZtjGHa6LUv39/X9d78803azVj8urRo4d55ZVX7Hk1tVBg3KtXL7PPPvuYTTbZJNLHDxSC8Z/Zzz//bA499NDUfpU6qPW3v/3NNGjQgAFXRRj//3PTTTet8vzos/HWW2+128DptaCt3bT85cQTTyzp/wmFI3AFgCrg3ZNVJb/6kA7q22+/rfV979697ZFp1xH45ZdftifRfq4dO3a0GVtNjPOVJQPFxPjPnIU7+uijzZQpU+z39evXN08//bTZbrvtGIxVhvGf2zrrrGMGDhxoqw0OP/xw8/vvv5vTTz/dfoZtscUWJfovIQqUCgNAFfj+++8jmeimrwkaM2aMGTVqlPnjH/9Y63cLFy40Dz30kA1u1bRJX7XVDlAOjP/aNDFXmaQCVdew5oknnqCBWpVi/PujrdhUOuyqEdSwDJWFwBUAqoCOKDvKqGjNatDTkCFDVrnd1VZbzTZyUUOLDz74wNx55522vMp7lPq3334zd999t923denSpSX7mwGH8V+bskk6sOQ6CKvbuN9176g8jH//tNTFSe/rgPgjcAWAKtC0adPU+S+++KIo96FtBPr06WPuu+8+M2/ePBvInnfeeTYzK/rZ5ZdfXpT7BnJh/P/Pueeea+66667U93fccYc55phjGEBVjPHv3/rrr586n95JH/FH4AoAVWD77bc39erVs+e//PLLVDOWYlIgq213vMGqK01Mz9oCxcT4/4+LL77YjBgxIvW83HjjjbaMH9WN8e/f4sWLU+c32GCDovw/UDwErgBQBdZaay3TpUuX1PelXLtzyCGHpM4vWbJkld+rKYy3rBiIGuPfmKFDh9rtPpwrrrjCDBgwgMGWAIx//5599tnUeW2Ng8pC4AoAVeKCCy5Inb/lllvMSy+95Pu6mcqLv/rqK1/X9W6j06RJk1V+37hx49T5zz77zPdjAoJI8vjXFiCXXHJJ6nt1UL300kuLcl+IpySOf21zoyZLfv31r381b731Vur7I444ItLHg+IjcAWAKtGpU6fUvnTqEKy96q6++mrzww8/ZLy8PvC11Y22s/FmTR1tedO3b18zefJk26U0E00Czj777NT33bp1W+UyLVq0MGuvvbY9/8knn9TaOxaISlLHv/aj1LpWp1+/fubaa6+N9D4Qf0kc///6179Mq1atzPXXX7/KPuTpgbleI3ptONoKh4ZllWe1GrWSBADEnrr+uvWkmqRMmjRplcv88ssvdhIyfvz41M80aejQoYOdiGgd7HfffWcbKc2ZM8deXnbcccdaR6LT16Y2bNjQrqNq3ry57WCpo/Fz58613YadDTfc0MycOdNuj5OuV69e5uGHH049nv33398+HtfYSWuNBg0aFPq50cby6etrNWHT3+m0a9duleupnDLTpA3xw/hf1ezZs+3r0gUWem0qePG7rrx///52b0vEH+N/Vfq82WGHHVLfb7755qZt27Z2X3F91i1btsx+Ts2aNcusXLkydbnWrVubiRMnmv/7v/8r0X8PkVHgCgCIv8GDB+tAoz116tQp6+VWrFhRc+mll9asvfbaqcvnOq2xxho1/fr1W+V2GjRo4Ov6OrVr167m/fffz/qYFixYULPRRhtlvX7z5s0Lem5OPPFE34/Ve7r33nsLul+UDuN/VRMnTgw17t1J10dlYPyvas6cOTWrr7667/Guy/bp06fmm2++KcN/EFGoG10IDACIA2UxlUlUCZf2b9Rap/fee89mSdUcad1117WZ02233dZ07tzZHHDAATZbmk5bBUyZMsWWiqm8S2VZar6kEjNlTTfZZBObqdU6IWUttV9kNrq/d99914wcOdJmgz/88EOzfPlyW9IGMP4B3v+D2mabbWwZ8IQJE8xrr71mM6sff/yx/ezSZ50qhbTGVp91e+yxh90WqlmzZgy1CkapMAAAAAAg1mjOBAAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAAAACAWCNwBQAAAADEGoErAAAAACDWCFwBAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAGvSpElmtdVWs6c//elPPCtIFMY/kozxj0pA4AoAAAAAiDUCVwAAAABArBG4AgAAAABibbWampqacj8IAAAAAACyIeMKAAAAAIg1AlcAAAAAQKwRuAJATLitaHRyZs6cac444wzTunVr06BBA3vq0KGDue2228yKFStWuY233nrLnHTSSWbrrbc266yzjmncuLHp3LmzeeihhyLZDmHBggWpy2y++ea17rd3795mq622MmuvvbZZf/31zS677GKuuuoq8+OPP+a832y3mYsu566j62fz1VdfmWHDhpmuXbuajTfe2NSvX9+sscYaplGjRmabbbYxRx55pBk+fLiZP3++r/tF8TD+Gf9Jxvhn/MMHrXEFAJSf3pLdSa699tqaOnXq1Pq597TffvvV/Pzzz/ayK1asqDnjjDOyXlannj172stlM3HixNRlO3XqlPEy8+fPT12mefPmNb///nvNZZddVrP66qtnvd8WLVrUzJs3L+v9pt+mH7qcu46un8lTTz1Vs/766+d8TtypWbNmvu4XxcP4Z/wnGeOf8Y/86voJbgEApXXHHXeYCy64wJ7fbrvtzPbbb2/q1Kljpk2bZt577z3783HjxplzzjnHXvbMM880d955p1l99dXNzjvvbDOuv//+u5k6dWoqm/joo4+adu3amQsvvDCyx3n55ZebK664wp7XY9x2221tRlOZ4nfeecf+XPffvXt3+33duqX52FEGWNlUl5Vea621zK677moztfXq1TPLli0z8+bNM7Nnzzb//ve/S/KY4B/jvzCM/8rG+C8M47+K+QhuAQAlPuJer169mo022shmQdMNGzYsdbm6devWDB8+3J7feuuta2bOnFnrssqwDhgwIHX5Bg0a1Pzwww+RZFzXXHPNmtVWW62mZcuWNdOmTVvlso8//njNGmuskbr86NGjS5Zx7d69e+r3RxxxRM0333yT8XZ++umnmueee66mb9++vu4XxcP4Z/wnGeOf8Y/8CFwBIIYTl/r169fMmTMn62W7du1a6/JNmjSpWbJkScbLKnht3bp16rKPPfZYJIGrTo0bN6757LPPsj7OP//5z6nL7r///iULXPW43AGA5cuX+7pNlBfjn/GfZIx/xj/yozkTAMRQ3759bfOgbI455pha3w8aNMg0adIk42VVYtyjR4/U99OnT4/scep+1fQom1NOOSV1/s033zSlolJgUaMoNbRCZWH8F4bxX9kY/4Vh/FcvAlcAiCGtz8xFa0mDXL5t27ap81F20D3qqKNy/r5NmzZ2fal8/fXXZvny5aYUNt10U/v122+/NY899lhJ7hPRYfwXhvFf2Rj/hWH8Vy8CVwCIIW+gmYm2m3HWW28906xZs5yX32CDDVY5Gl0o3a+bIOTa4sH7WKO673y8GWZlpw8//HAbwH755ZcluX8UhvFfGMZ/ZWP8F4bxX70IXAEghhQU5uLtzpvvsumX/+233wp8dP7vV9RlOOr7zueSSy6xXYRFy8fGjh1revbsaZo2bWr3mj311FPNww8/XLIMMIJh/BeG8V/ZGP+FYfxXLwJXAIghZSqLcdkolet+/VhnnXXM5MmTzfXXX2+3wPH617/+Ze655x7Tq1cvs9FGG5mBAwean376qWyPFati/BeG8V/ZGP+FYfxXLwJXAEDF0R61+ay55prmz3/+s/n444/tvrI333yzzbp6y6q1h6uC286dOxO8omIw/pFkjP/kInAFAJSVt5R4xYoVvq7z/fffB8petGvXzpx99tnmkUceMZ9++ql55513zMknn5y6zLRp08ytt94a8JEDhWP8I8kY/wiCwBUAUFbrrrtu6ry6AP9nS8PsFi5cWHCTpx122MGWC/fu3Tv1s6effrqg2wTCYPwjyRj/CILAFQBQVg0bNkx1PVbp7ocffpjz8o8//nhk933IIYekzi9ZsiSy2wX8YvwjyRj/CILAFQBQdh06dEidv++++7JeTmW+V199dc7b+uWXX8wPP/zg634XLVqUOt+kSRNf1wGixvhHkjH+4ReBKwCg7I499tjU+eHDh5snn3xylcu88cYbplOnTracWI2Xslm8eLHdX1aNmd56662sl5swYYIZPHhw6vtu3boV9DcAYTH+kWSMf/j1v439AAAoE3X7HTZsmHn33XfNr7/+ao488kjTvn17s/3225uVK1eaWbNmmRkzZtjLDhkyxNx7773mk08+yXp73333nbnhhhvsSWXIWtOqbsL169c3X375pb09dRt2tLdr//79S/K3AukY/0gyxj/8InAFAJRd3bp1zdixY03Xrl1TAaU6/+rk7Q48aNAgc9lll9nANVeXynr16tmSYfnmm2/Myy+/nPXyf/rTn2y3Ye39B5QD4x9JxviHXwSuAIBYaNGihc2E3nLLLWbMmDG2SZOCz4033th07NjRnHHGGbXWQmWjzOrXX39tXnnlFTN16lTz9ttvm48++sgsXbrUZnPVDKR58+Zm5513NkcffbQNloFyY/wjyRj/8GO1mnz7DgAAAAAAUEY0ZwIAAAAAxBqBKwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgBAFkOGDDGrrbaaPek8kCSMfyQZ4z9+6pb7AQBAUi1btsy88MILZsKECeatt94yS5cuNV999ZVZc801zfrrr2+22mors/POO5tDDjnE7LbbbuV+uECkGP9IMsY/EByBKwCU2L///W8zYsQIM2zYMPPtt9+u8vtff/3V/PDDD2bRokXm5ZdfNtdcc40NYnX0t2fPnjb7V2m8j7mmpqasjwXlxfhn/CcZ45/xj/AIXAGghBYuXGgOPvhgM2vWrFo/32yzzcx2221nNtxwQ7Ny5UrzxRdfmHfffdcsWbLE/v7DDz80xx57rA1mBw4cyP8MFYnxjyRj/AOFIXAFgBJZsGCBLflVUOqykMccc4wZNGiQ2WabbVa5vDKTKiG+5ZZbzEMPPWR+//13e7QeqESMfyQZ4x8oHM2ZAKAEVP571FFHpYLW+vXrmzFjxtiANFPQ6gJbrXG9//77bfa1bdu2/K9QkRj/SDLGPxANMq4AUALXXXedzZ46o0ePNt27d/d9fQWtb7zxhpk5c2aRHiFQPIx/JBnjH4gGGVcAKLKffvrJ3HzzzanvDz/8cNOjR4/At7POOuuYPfbYI+vvP/nkE3PZZZeZXXfd1TRt2tR2J9ZXfT948GC7PjafSZMmpbZ/+dOf/pT6+SuvvGIbQ22xxRY2W9y4cWOz1157mZEjR5rffvst7215uZ+ln1RK5+i8+/nmm2+e+vmrr75qevfubdq0aWPWW289+/sBAwZkvP9x48aZU045xTa2Wnfddc1aa61lmjdvbg477DBz3333ZX3ciBbjn/GfZIx/xj8iVAMAKKr7779fbRRTp1dffTXy+/jLX/5SU79+/Vr3k37S76+55pqctzNx4sTU5Tt16lTzyy+/1PTp0yfn7bZv375m6dKlOW/Lz2n+/Pmp6+q8+3nz5s3t4+jbt2/G6/Xv37/W/S5ZsqRm7733znt/W265Zc2bb76Z8/kYPHhw6vI6j+AY/4z/JGP8M/4RHUqFAaDIlK30dg/OlTUN46yzzjK33npr6vsGDRqYzp07m4022siuqZ04caLdXufnn382F154of3ZjTfe6Ou2TzvtNFvWvPrqq5sOHTrYTKeaRKls+YMPPrCXeeedd8wJJ5xgnn/++VrXbdasmenXr58973187mfplBXN5txzzzV33HGHPb/tttuadu3amTXWWMN2W9Zjc9SFWc/vvHnzUj9r2bKlfez16tUz7733npk2bZr9+b/+9S/7PL344ouR/0/wP4x/xn+SMf4Z/4hQhEEwACCDli1bprJ2Rx11VKTP0WOPPVYri3jSSSfVfP/997Uuo++PO+64Wpd78sknM96eN0tar149+3XnnXeuef/992td7vfff68ZMWJErducPHly1sfpvZwf3oxrnTp17NdNN920ZsqUKatc9ueff06d79atW+p666yzTs0jjzyyyuWVZd1iiy1Sl9PtfvvttxkfBxnXwjH+Gf9Jxvhn/CM6BK4AUGR169ZNBUlDhgyJ7HZXrlxZ06JFi1pBsQLKTPTzQw89NHVZTaZ0/XzlvSqnXb58edbHcOSRR6Yue/rppxclcNVp7bXXrvnggw9yXueVV16pdZ1nn3025+2vt956qctefvnlGS9H4Fo4xj/jP8kY/4x/RIfmTABQRMuWLTMrVqxIfd+oUaPIbnv8+PFm/vz59rwaMakBVHojJEc/V7muymtFpbQTJkzIex/XXHONLT3ORs2PnOnTp5tiUTm0mizl4kqJ5ZBDDjEHHnhg1suq4ZP2z3Vuv/12u28uosX4jwbjvzIx/qPB+IdD4AoARbR8+fJa3+cKAgtZO3XAAQfYNa25aM3p/vvvn/pea19zUffggw8+OOdldthhh9R5b1fgqKmjcT7ev8cbUGdz8sknp9bHLl68OLVmF9Fh/EeD8V+ZGP/RYPzDIXAFgCJq2LBhre/VJCkqM2bMSJ3ffffdfV3H24RITZVyad26dSpDm422xfFmF4pBj0ENmXL57LPPzJdffhno+dhwww1rZXHzPR8IjvFfOMZ/5WL8F47xDy8CVwAoInXKrVv3fw3cv/vuu8hue+nSpanz2p/UD++eqF999VXOy2qf1Hy8ga23JDpK66+/fq3nMN9zof1aFZRG/XwgOMZ/4Rj/lYvxXzjGP7wIXAGgyLxBpbZjiYo3e7vOOuv4uo73cullbOmyrZctNQWixXgugj4fCIfxXxjGf2Vj/BeG8Q8vAlcAKLI999wzdd7tIRoF73rZH3/80dd1vJdLL2OrZGGei2p+PuKE8V98jP/4YvwXH+M/OQhcAaDIunTpkjr/ySefmNdeey2S2/WWwy5cuNDXdbwNlP7whz+YauF9Ln766SffZb/V+nzECeO/+Bj/8cX4Lz7Gf3IQuAJAkR111FG1gqLhw4dHcrvejr5+g2Hv5dq3b2+qhTomN2nSJNDzoeD2ww8/rMrnI04Y/8XH+I8vxn/xMf6Tg8AVAEqwRuecc85Jff/kk0/aU1Aqa/UGZN4j+c8//3ytrrqZfP755+aFF17IeP1i09Y6zm+//VaU++jcuXPq/H333Zf38rrM77//bs9vvPHGtosyosf4Z/wnGeOf8Y/oELgCQAkMHDiwVkbv+OOPN88884zv68+ZM8fsuuuuZvz48amf7bvvvqZFixb2/C+//GIGDBiQ9fo1NTXm7LPPTgWNLVu2NF27djWl4t02R1vXFEPfvn1T58eOHWvGjRuX9bIq2R46dGit68alGVU1Yvwz/pOM8c/4RzQIXAGgBOrVq2eeeOKJVDmr1mF2797dnHDCCeb999/PGmy++eab5sQTTzTt2rWzwavX6quvbq655prU94888ojp06fPKnvFqlvuySefbMaMGZP62XXXXWevXypt27ZNndfzUKyMa7du3VLfH3nkkRnv6+2337ZBu9uaaNNNN62VEUf0GP+M/yRj/DP+EY3cG+MBACKzxRZb2K7CBx98sA1CVab6wAMP2JP2E91uu+3sWtiVK1eaL774wsycOdMsWbKk1m2kd77t0aOHmTJlirn11lvt96NGjTKPPfaYDeKaNm1qy4dffvnlWsGsMrOHH354Sf+zRxxxRCoDesEFF9iS5W222cZO6JyLL77Y7tlXiHvvvdfsscceZt68efZv1vOz5ZZbmg4dOpg111zTbkek/4EOCrjtcBTwN2rUqMC/EPkw/hn/Scb4Z/wjAjUAgJJavnx5zRVXXFHTqFEjRU++Tu3atasZO3Zs1tu88sora+rVq5fzNurXr19z1VVX5XxsEydOTF2+U6dOvv4e731k8+uvv9bstddeOR/f/PnzU5fXeffz5s2b1wTxxRdf1HTp0iXvc9qqVaua6dOn57ytwYMHpy6v8ygc45/xn2SMf8Y/wiPjCgBl2HPu0ksvteWpaqo0YcIEW76q7Og333xjM4MbbLCBadOmjc0UqqQ4X8fbSy65xK6bVcZVmc358+fbUlhlEnWkf7/99jO9e/c2m222mSmHNdZYw7z00kvm7rvvto2plHHW3/rrr79Gfl/KNCvL/OKLL9rs86uvvmoz2Frfq1JtdWPWc3rcccfZx4XSYvwz/pOM8c/4R3irKXot4PoAAAAAABQVzZkAAAAAALFG4AoAAAAAiDUCVwAAAABArBG4AgAAAABijcAVAAAAABBrBK4AAAAAgFgjcAUAAAAAxBqBKwAAAAAg1ghcAQAAAACxRuAKAAAAAIg1AlcAAAAAQKwRuAIAAAAAYo3AFQAAAAAQawSuAAAAAIBYI3AFAAAAAMQagSsAAAAAINYIXAEAAAAAsUbgCgAAAACINQJXAAAAAECsEbgCAAAAAGKNwBUAAAAAEGsErgAAAACAWCNwBQAAAADEGoErAAAAACDWCFwBAAAAACbO/j9+TTJr9hQGHwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index 936d0bdc..7af0cc5a 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2210,7 +2210,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb index 12f9c877..266bcd3a 100644 --- a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb +++ b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb @@ -67,20 +67,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pre-compiling numba functions for DABEST...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Compiling numba functions: 100%|██████████| 13/13 [00:00<00:00, 27.94it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Pre-compiling numba functions for DABEST...\n", "Numba compilation complete!\n", "We're using DABEST v2025.10.20\n" ] @@ -89,7 +76,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "\n" + "\r", + "Compiling numba functions: 0%| | 0/13 [00:00\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", + "
controltestn_clusterscici_expandedbca_lowbca_high
0BaselineTreatment159597.358565-0.1843060.675824
\n", + "" + ], + "text/plain": [ + " control test n_clusters ci ci_expanded bca_low bca_high\n", + "0 Baseline Treatment 15 95 97.358565 -0.184306 0.675824" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clustered.mean_diff.results[[\"control\", \"test\", \"n_clusters\", \"ci\", \"ci_expanded\", \"bca_low\", \"bca_high\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "e1266ac6", + "metadata": {}, + "source": [ + "The expansion fades as the number of clusters grows: with 15 participants the interval is read at\n", + "about the 97.4% level, with 30 at about 96.2%, and with 100 at about 95.4%. In simulations covering\n", + "paired and between-subject designs and every effect size DABEST offers, expanded intervals came close\n", + "to nominal coverage once there were at least 6 clusters in all and at least 4 in each\n", + "independently resampled group of clusters: for example 6 participants who each take part in every\n", + "condition, or 8 participants split between two conditions. With fewer, no bootstrap interval is\n", + "reliable: DABEST warns you, and the results are best treated as indicative. Because the expanded\n", + "interval is read further into the tails of the bootstrap distribution, it is also worth increasing\n", + "`resamples` (to 20000, say) when there are few clusters.\n", + "\n", + "If you prefer the unexpanded cluster-bootstrap interval, pass `cluster_ci_expansion=False` to\n", + "`dabest.load()`. That is appropriate only if you are confident the number of clusters is large enough\n", + "for the correction not to matter." + ] + }, { "cell_type": "markdown", "id": "a2249805", @@ -851,6 +821,9 @@ "- Use `cluster_col` whenever a real participant (or other independent unit) contributes more\n", " than one row of `id_col`, whether the design is paired or unpaired.\n", "- Ignoring clustering can lead to confidence intervals being estimated as too narrow.\n", + "- With `cluster_col` set, intervals are also expanded for the number of clusters by default, which\n", + " keeps their coverage close to nominal when there are few participants; the level actually read\n", + " is reported as `ci_expanded`, and `cluster_ci_expansion=False` turns this off.\n", "- The point estimate (the mean difference itself) is unaffected; only the bootstrap confidence intervals change, because they are the parts of the analysis that depend on which observations are treated as independent.\n", "- The interval widens to reflect real between-participant variability that a cluster-naive bootstrap cannot account for. The example simulation above shows the naive interval can give a false sense of precision.\n", "- Permutation tests are similarly reshuffled at the cluster-level, yielding larger values than the cluster-naive approach.\n", From 6ee3b507933b40b865d5cbef56020bbab62d7836 Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Sun, 27 Sep 2026 23:08:21 +0100 Subject: [PATCH 7/8] feat: switched degrees of freedom adjustment Degrees of freedom adjustment for percentile expansion switched from Hsu to Welch-Satterthwaite to avoid over-conservatism. Plots also now indicate expanded intervals with thinner lines, also editable. --- CHANGELOG.md | 2 +- dabest/_api.py | 24 ++- dabest/_delta_objects.py | 86 +++++++++ dabest/_effsize_objects.py | 110 ++++++++++- dabest/_modidx.py | 12 +- dabest/_stats_tools/confint_2group_diff.py | 93 ++++++--- dabest/forest_plot.py | 36 +++- dabest/plot_tools.py | 157 +++++++++++---- dabest/plotter.py | 11 +- nbs/API/confint_2group_diff.ipynb | 84 ++++++-- nbs/API/delta_objects.ipynb | 86 +++++++++ nbs/API/effsize_objects.ipynb | 110 ++++++++++- nbs/API/forest_plot.ipynb | 36 +++- nbs/API/load.ipynb | 24 ++- nbs/API/plot_tools.ipynb | 152 ++++++++++++--- nbs/API/plotter.ipynb | 11 +- nbs/tests/test_cluster_bootstrap.py | 182 ++++++++++++++++-- ...shared_control_and_repeated_measures.ipynb | 7 +- nbs/tutorials/08-plot_aesthetics.ipynb | 6 +- .../11-cluster_robust_bootstrap.ipynb | 71 ++++--- 20 files changed, 1097 insertions(+), 203 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2991e562..38e73eac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ ### New Features 1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. 2. **Cluster count on plots**: when `cluster_col` is set, each group's axis label reports the number of distinct clusters on a second line below the number of observations, `(N=,` / ` n=)` instead of the usual `(N=)`, since the cluster count is what the bootstrap actually resamples. To make room, the gap between the raw-data and contrast axes of vertical Cumming plots is then sized to the height of the labels (including the taller labels of two-column Sankey plots), so they clear the contrast axes. Unclustered plots are unchanged. -3. **Small-sample expansion of cluster-bootstrap intervals**: bootstrap intervals are too narrow when there are few independent units, so with `cluster_col` set, confidence intervals are now expanded for the number of clusters by default, using the expanded percentile method of Hesterberg (2015). Each interval is read further into the tails of the same bootstrap distribution, at a level derived from a t distribution with degrees of freedom based on the number of clusters (for nested or mixed designs, those of the smallest group of clusters). This applies to the percentile and bias-corrected and accelerated intervals, and to those of the baseline error curve, delta-delta and mini-meta analyses. The reported confidence level (`ci`) is unchanged, and the level actually read is reported as `ci_expanded` in the results and in the printed summary. In simulations, expanded intervals came close to nominal coverage for every effect size once there were at least 6 clusters, and at least 4 in each independently resampled group of clusters; below that, a warning is given. Pass `cluster_ci_expansion=False` to `dabest.load()` to turn the expansion off. `cluster_col` can also no longer be the same column as `x`. +3. **Small-sample expansion of cluster-bootstrap intervals**: bootstrap intervals are too narrow when there are few independent units, so with `cluster_col` set, confidence intervals are now expanded for the number of clusters by default, using the expanded percentile method of Hesterberg (2015). Each interval is read further into the tails of the same bootstrap distribution, at a level derived from a t distribution with degrees of freedom based on the number of clusters (for nested or mixed designs, whose groups of clusters are resampled independently, combined with the Welch-Satterthwaite approximation). This applies to the percentile and bias-corrected and accelerated intervals, and to those of the baseline error curve, delta-delta and mini-meta analyses. The reported confidence level (`ci`) is unchanged, and the level actually read is reported as `ci_expanded` in the results and in the printed summary, with the unexpanded limits alongside (`bca_low_unexpanded` and so on). Because the plotted bootstrap distribution is unchanged, estimation plots and forest plots draw an expanded interval in two parts: the unexpanded interval as the usual thick bar, and the expansion beyond it as a thinner line, which can be styled with `contrast_expanded_errorbar_kwargs` in `.plot()` (or `expanded_errorbar_kwargs` in `forest_plot()`). In simulations, expanded intervals came within about 3 percentage points of nominal coverage for every effect size once there were at least 6 clusters, and at least 4 in each independently resampled group of clusters; below that, a warning is given. Pass `cluster_ci_expansion=False` to `dabest.load()` to turn the expansion off. `cluster_col` can also no longer be the same column as `x`. ### Documentation 1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. diff --git a/dabest/_api.py b/dabest/_api.py index 8f8ae21e..0f65178a 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -122,16 +122,22 @@ def load( bootstrap distribution, at a level derived from a t distribution with degrees of freedom based on the number of clusters. When clusters are nested within groups, or some clusters appear in only some groups, the - conservative choice of the smallest group of clusters' degrees of - freedom is used. The reported confidence level (`ci`) is unchanged; the - level actually read is reported as `ci_expanded` in the results. The + groups of clusters are resampled independently, and their degrees of + freedom are combined with the Welch-Satterthwaite approximation. The + reported confidence level (`ci`) is unchanged; the level actually read + is reported as `ci_expanded` in the results, alongside the unexpanded + limits (`bca_low_unexpanded` and so on). Plots draw the unexpanded + interval (the nominal `ci`% interval of the plotted bootstrap + distribution) as the usual thick bar, and the expansion beyond it as a + thinner line (see `contrast_expanded_errorbar_kwargs` in `plot()`). The correction fades as the number of clusters grows. In simulations the - expanded intervals came close to nominal coverage for every effect size - once there were at least 6 clusters in all and at least 4 in each - independently resampled group of clusters (for example 6 participants - who each take part in every condition, or 8 participants split between - two conditions); with fewer, no bootstrap interval is reliable, and a - warning is given. Because expanded intervals are read further into the + expanded intervals came within about 3 percentage points of nominal + coverage for every effect size once there were at least 6 clusters in + all and at least 4 in each independently resampled group of clusters + (for example 6 participants who each take part in every condition, or + 8 participants split between two conditions); with fewer, no bootstrap + interval is reliable, and a warning is given. Because expanded + intervals are read further into the tails of the bootstrap distribution, consider increasing `resamples` (to 20000, say) when there are few clusters. Set to False to report unexpanded cluster-bootstrap intervals. diff --git a/dabest/_delta_objects.py b/dabest/_delta_objects.py index 1685785f..7ccc6dde 100644 --- a/dabest/_delta_objects.py +++ b/dabest/_delta_objects.py @@ -164,6 +164,14 @@ def __init__( self.__pct_low = sorted_delta_delta[pct_idx_low] self.__pct_high = sorted_delta_delta[pct_idx_high] + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + self.__unexpanded = (None, None, None, None) + if self.__ci_expanded is not None: + self.__unexpanded = ci2g.unexpanded_interval_limits( + sorted_delta_delta, self.__bias_correction, self.__acceleration_value, ci + ) + def __permutation_test(self): """ Perform a permutation test and obtain the permutation p-value @@ -263,6 +271,9 @@ def __compute_results(self): ] if self.__ci_expanded is not None: column_index.insert(column_index.index('ci') + 1, 'ci_expanded') + position = column_index.index('pct_interval_idx') + 1 + column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded', + 'pct_low_unexpanded', 'pct_high_unexpanded'] delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]] delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]] delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]] @@ -288,6 +299,38 @@ def ci_expanded(self): """ return self.__ci_expanded + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[0] + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[1] + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[2] + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[3] + @property def alpha(self): """ @@ -576,6 +619,14 @@ def __init__(self, effectsizedataframe, permutation_count, self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_weighted_deltas[pct_idx_low] self.__pct_high = sorted_weighted_deltas[pct_idx_high] + + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + self.__unexpanded = (None, None, None, None) + if self.__ci_expanded is not None: + self.__unexpanded = ci2g.unexpanded_interval_limits( + sorted_weighted_deltas, self.__bias_correction, self.__acceleration_value, ci + ) @@ -699,6 +750,9 @@ def __compute_results(self): 'permutation_count', 'bias_correction', 'jackknives'] if self.__ci_expanded is not None: column_index.insert(column_index.index('ci') + 1, 'ci_expanded') + position = column_index.index('pct_interval_idx') + 1 + column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded', + 'pct_low_unexpanded', 'pct_high_unexpanded'] mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index) mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True) @@ -722,6 +776,38 @@ def ci_expanded(self): """ return self.__ci_expanded + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[0] + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[1] + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[2] + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[3] + @property def alpha(self): diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 861d66cb..089e29ec 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -258,6 +258,17 @@ def __init__( self.__pct_low = sorted_bootstraps[pct_idx_low] self.__pct_high = sorted_bootstraps[pct_idx_high] + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + if self.__ci_expanded is not None: + (self.__bca_low_unexpanded, self.__bca_high_unexpanded, + self.__pct_low_unexpanded, self.__pct_high_unexpanded) = ci2g.unexpanded_interval_limits( + sorted_bootstraps, self.__bias_correction, self.__acceleration_value, self.__ci + ) + else: + self.__bca_low_unexpanded = self.__bca_high_unexpanded = None + self.__pct_low_unexpanded = self.__pct_high_unexpanded = None + self._get_bootstrap_baseline_ec() self._perform_statistical_test() @@ -407,15 +418,16 @@ def _expanded_level(self, components): return None, None # In simulations, expanded intervals came close to nominal coverage once # there were at least 6 clusters in all, and at least 4 in the smallest - # group of clusters that sets the degrees of freedom. + # independently resampled group of clusters. n_total = sum(n for _, n in components if n >= 2) - if n_total < 6 or df + 1 < 4: + n_smallest = ci2g.smallest_cluster_group(components) + if n_total < 6 or n_smallest < 4: warnings.warn( "Only {} clusters are available to resample ({} in the smallest group of " "clusters); even after expansion for the small number of clusters, the " "confidence interval is unreliable and likely too narrow. At least 6 " "clusters, and at least 4 in every group of clusters, are " - "recommended.".format(int(n_total), int(df + 1)) + "recommended.".format(int(n_total), int(n_smallest)) ) return ci_expanded, df @@ -736,6 +748,15 @@ def _get_bootstrap_baseline_ec(self): self.__bec_pct_low = sorted_bootstraps[pct_idx_low] self.__bec_pct_high = sorted_bootstraps[pct_idx_high] + if bec_ci_expanded is not None: + (self.__bec_bca_low_unexpanded, self.__bec_bca_high_unexpanded, + self.__bec_pct_low_unexpanded, self.__bec_pct_high_unexpanded) = ci2g.unexpanded_interval_limits( + sorted_bootstraps, bias_correction, acceleration_value, self.__ci + ) + else: + self.__bec_bca_low_unexpanded = self.__bec_bca_high_unexpanded = None + self.__bec_pct_low_unexpanded = self.__bec_pct_high_unexpanded = None + @property def difference(self): """ @@ -881,6 +902,38 @@ def pct_high(self): """ return self.__pct_high + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__bca_low_unexpanded + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__bca_high_unexpanded + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__pct_low_unexpanded + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__pct_high_unexpanded + @property def pvalue_brunner_munzel(self): try: @@ -1068,6 +1121,38 @@ def bec_pct_high(self): The percentile confidence interval lower limit for baseline error. """ return self.__bec_pct_high + + @property + def bec_bca_low_unexpanded(self): + """ + The baseline error curve's BCa lower limit before expansion for a + small number of clusters; None if it was not expanded. + """ + return self.__bec_bca_low_unexpanded + + @property + def bec_bca_high_unexpanded(self): + """ + The baseline error curve's BCa upper limit before expansion for a + small number of clusters; None if it was not expanded. + """ + return self.__bec_bca_high_unexpanded + + @property + def bec_pct_low_unexpanded(self): + """ + The baseline error curve's percentile lower limit before expansion for + a small number of clusters; None if it was not expanded. + """ + return self.__bec_pct_low_unexpanded + + @property + def bec_pct_high_unexpanded(self): + """ + The baseline error curve's percentile upper limit before expansion for + a small number of clusters; None if it was not expanded. + """ + return self.__bec_pct_high_unexpanded # %% ../nbs/API/effsize_objects.ipynb #024b1d00 @@ -1254,6 +1339,10 @@ def __pre_calc(self): "pct_low", "pct_high", "pct_interval_idx", + "bca_low_unexpanded", + "bca_high_unexpanded", + "pct_low_unexpanded", + "pct_high_unexpanded", "bootstraps", "resamples", "random_seed", @@ -1286,6 +1375,10 @@ def __pre_calc(self): "bec_pct_interval_idx", "bec_pct_low", "bec_pct_high", + "bec_bca_low_unexpanded", + "bec_bca_high_unexpanded", + "bec_pct_low_unexpanded", + "bec_pct_high_unexpanded", ] self.__results = out_.reindex(columns=columns_in_order) self.__results.dropna(axis="columns", how="all", inplace=True) @@ -1493,6 +1586,7 @@ def plot( contrast_marker_kwargs=None, # es_marker_kwargs=None, OLD contrast_errorbar_kwargs=None, # es_errorbar_kwargs=None, OLD + contrast_expanded_errorbar_kwargs=None, prop_sample_counts=False, prop_sample_counts_kwargs=None, @@ -1729,6 +1823,16 @@ def plot( contrast_errorbar_kwargs: dict, default None Pass relevant keyword arguments to the effectsize errorbar plotting. If none, the following keywords are passed: {'color': 'black', 'lw': 2, 'linestyle': '-', 'alpha': 1,'zorder': 1,} + contrast_expanded_errorbar_kwargs: dict, default None + When `cluster_col` is set, intervals are expanded for the number of + clusters (see `dabest.load`'s `cluster_ci_expansion`). The plotted + bootstrap distribution does not change, so the expanded interval + reaches further into its tails than its nominal `ci`% interval. To + show this, the unexpanded interval (the nominal `ci`% interval of + the plotted distribution) is drawn as the usual errorbar, and the + expansion beyond it as a thinner line. Pass keyword arguments here + to style the thinner line; by default it takes the errorbar's + keywords at 40% of its line width. prop_sample_counts: bool, default False Show the sample counts for each group in proportional plots diff --git a/dabest/_modidx.py b/dabest/_modidx.py index f0fd1bec..ad68a511 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -27,6 +27,8 @@ 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._create_two_group_jackknife_indexes': ( 'API/confint_2group_diff.html#_create_two_group_jackknife_indexes', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff._usable_components': ( 'API/confint_2group_diff.html#_usable_components', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.bootstrap_indices': ( 'API/confint_2group_diff.html#bootstrap_indices', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.calculate_bootstraps_var': ( 'API/confint_2group_diff.html#calculate_bootstraps_var', @@ -78,7 +80,11 @@ 'dabest._stats_tools.confint_2group_diff.expanded_interval_limits': ( 'API/confint_2group_diff.html#expanded_interval_limits', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.percentile_interval_idx': ( 'API/confint_2group_diff.html#percentile_interval_idx', - 'dabest/_stats_tools/confint_2group_diff.py')}, + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.smallest_cluster_group': ( 'API/confint_2group_diff.html#smallest_cluster_group', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.unexpanded_interval_limits': ( 'API/confint_2group_diff.html#unexpanded_interval_limits', + 'dabest/_stats_tools/confint_2group_diff.py')}, 'dabest._stats_tools.effsize': { 'dabest._stats_tools.effsize._cliffs_delta_core': ( 'API/effsize.html#_cliffs_delta_core', 'dabest/_stats_tools/effsize.py'), 'dabest._stats_tools.effsize._compute_hedges_correction_factor': ( 'API/effsize.html#_compute_hedges_correction_factor', @@ -197,10 +203,13 @@ 'dabest.plot_tools.effect_size_curve_plotter': ( 'API/plot_tools.html#effect_size_curve_plotter', 'dabest/plot_tools.py'), 'dabest.plot_tools.error_bar': ('API/plot_tools.html#error_bar', 'dabest/plot_tools.py'), + 'dabest.plot_tools.expanded_errorbar_kwargs_from': ( 'API/plot_tools.html#expanded_errorbar_kwargs_from', + 'dabest/plot_tools.py'), 'dabest.plot_tools.get_swarm_spans': ('API/plot_tools.html#get_swarm_spans', 'dabest/plot_tools.py'), 'dabest.plot_tools.gridkey_plotter': ('API/plot_tools.html#gridkey_plotter', 'dabest/plot_tools.py'), 'dabest.plot_tools.halfviolin': ('API/plot_tools.html#halfviolin', 'dabest/plot_tools.py'), 'dabest.plot_tools.normalize_dict': ('API/plot_tools.html#normalize_dict', 'dabest/plot_tools.py'), + 'dabest.plot_tools.plot_ci_whisker': ('API/plot_tools.html#plot_ci_whisker', 'dabest/plot_tools.py'), 'dabest.plot_tools.plot_minimeta_or_deltadelta_violins': ( 'API/plot_tools.html#plot_minimeta_or_deltadelta_violins', 'dabest/plot_tools.py'), 'dabest.plot_tools.sankeydiag': ('API/plot_tools.html#sankeydiag', 'dabest/plot_tools.py'), @@ -210,5 +219,6 @@ 'dabest.plot_tools.swarmplot': ('API/plot_tools.html#swarmplot', 'dabest/plot_tools.py'), 'dabest.plot_tools.table_for_horizontal_plots': ( 'API/plot_tools.html#table_for_horizontal_plots', 'dabest/plot_tools.py'), + 'dabest.plot_tools.unexpanded_limits': ('API/plot_tools.html#unexpanded_limits', 'dabest/plot_tools.py'), 'dabest.plot_tools.width_determine': ('API/plot_tools.html#width_determine', 'dabest/plot_tools.py')}, 'dabest.plotter': {'dabest.plotter.effectsize_df_plotter': ('API/plotter.html#effectsize_df_plotter', 'dabest/plotter.py')}}} diff --git a/dabest/_stats_tools/confint_2group_diff.py b/dabest/_stats_tools/confint_2group_diff.py index ae2b9431..a4154544 100644 --- a/dabest/_stats_tools/confint_2group_diff.py +++ b/dabest/_stats_tools/confint_2group_diff.py @@ -8,10 +8,11 @@ __all__ = ['create_jackknife_indexes', 'create_repeated_indexes', 'compute_meandiff_jackknife', 'bootstrap_indices', 'compute_bootstrapped_diff', 'cluster_codes', 'cluster_tables', 'cluster_strata', 'cluster_bootstrap_draws', 'expand_cluster_draw', 'compute_cluster_jackknife', 'cluster_jackknife_by_cluster', - 'cluster_variance_components', 'expanded_ci_level', 'percentile_interval_idx', 'expanded_interval_limits', - 'compute_cluster_bootstrapped_diff', 'delta2_cluster_bootstrap_loop', 'delta2_cluster_variance_components', - 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', 'compute_meandiff_bias_correction', - 'compute_interval_limits', 'calculate_group_var', 'calculate_bootstraps_var', 'calculate_weighted_delta'] + 'cluster_variance_components', 'smallest_cluster_group', 'expanded_ci_level', 'percentile_interval_idx', + 'unexpanded_interval_limits', 'expanded_interval_limits', 'compute_cluster_bootstrapped_diff', + 'delta2_cluster_bootstrap_loop', 'delta2_cluster_variance_components', 'delta2_bootstrap_loop', + 'compute_delta2_bootstrapped_diff', 'compute_meandiff_bias_correction', 'compute_interval_limits', + 'calculate_group_var', 'calculate_bootstraps_var', 'calculate_weighted_delta'] # %% ../../nbs/API/confint_2group_diff.ipynb #fa733643 import numpy as np @@ -365,10 +366,39 @@ def cluster_variance_components(jackknife_values, deleted_codes, codes_per_group # bootstrap resamples for any practical number of resamples. _MIN_EXPANDED_ALPHA = 1e-6 -# Strata carrying less than this share of the variance do not set the degrees -# of freedom, so that a stray handful of clusters (say, two participants seen in -# only one condition) cannot inflate the expansion. -_MIN_VARIANCE_SHARE_FOR_DF = 0.1 +# Strata carrying less than this share of the variance are not counted when +# judging whether the smallest group of clusters is too small for a reliable +# interval (see `smallest_cluster_group`), so that a stray handful of clusters +# (say, two participants seen in only one condition) does not trigger a warning. +_MIN_VARIANCE_SHARE = 0.1 + + +def _usable_components(components): + """Strata with at least 2 clusters, as arrays of variances and sizes.""" + components = [(v, n) for v, n in components if n >= 2] + if not components: + return None, None + variances = np.array([v for v, _ in components], dtype=float) + n = np.array([n for _, n in components], dtype=float) + if not np.all(np.isfinite(variances)) or variances.sum() <= 0: + # No usable variance information: weight the strata equally. + variances = np.ones_like(n) + return variances, n + + +def smallest_cluster_group(components): + """ + The number of clusters in the smallest stratum that carries at least 10% + of the variance (see `cluster_variance_components`); None if no stratum + has at least 2 clusters. + """ + variances, n = _usable_components(components) + if n is None: + return None + shares = variances / variances.sum() + # Never let the threshold exclude every stratum (e.g. many equal strata). + threshold = min(_MIN_VARIANCE_SHARE, shares.max()) + return int(n[shares >= threshold].min()) def expanded_ci_level(ci, components): @@ -389,33 +419,26 @@ def expanded_ci_level(ci, components): clusters nested within groups), `components` holds each stratum's `(variance, n)` (see `cluster_variance_components`). The narrowness correction is then applied stratum by stratum, weighted by each stratum's - share of the variance, and the degrees of freedom are those of the - smallest stratum carrying at least 10% of the variance. This is the - conservative (Hsu) alternative to the Welch-Satterthwaite approximation, - which in simulations under-covered for unbalanced and mixed designs. Both - reduce to the single-sample correction above for one stratum. + share of the variance, and the degrees of freedom come from the + Welch-Satterthwaite approximation. Both reduce to the single-sample + correction above for one stratum. In simulations of unbalanced or mixed + designs whose smallest group held only 4 to 6 clusters, Welch-Satterthwaite + intervals covered 1 to 3 points below nominal; the more conservative + alternative of the smallest stratum's degrees of freedom over-covered by + similar amounts, with intervals about 10% wider. Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least 2 clusters, in which case no expansion is possible. """ from scipy.stats import t as student_t - components = [(v, n) for v, n in components if n >= 2] - if not components: + variances, n = _usable_components(components) + if n is None: return ci, None - variances = np.array([v for v, _ in components], dtype=float) - n = np.array([n for _, n in components], dtype=float) - if not np.all(np.isfinite(variances)) or variances.sum() <= 0: - # No usable variance information: weight the strata equally. - variances = np.ones_like(n) - total = variances.sum() narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n)) - shares = variances / total - # Never let the threshold exclude every stratum (e.g. many equal strata). - threshold = min(_MIN_VARIANCE_SHARE_FOR_DF, shares.max()) - df = float(n[shares >= threshold].min() - 1) + df = float(total ** 2 / np.sum(variances ** 2 / (n - 1))) alpha = _compute_alpha_from_ci(ci) z = narrowness * student_t.ppf(1 - alpha / 2, df) @@ -434,6 +457,26 @@ def percentile_interval_idx(ci, n_boots): return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) +def unexpanded_interval_limits(sorted_bootstraps, bias, acceleration, ci): + """ + The BCa and percentile limits at the nominal level `ci`, as + `(bca_low, bca_high, pct_low, pct_high)`, for an interval that has been + expanded for a small number of clusters. Plots show this unexpanded + interval, which the bootstrap distribution itself spans, as the thick part + of the interval, and the expansion beyond it as a thinner line. If the BCa + limits cannot be computed, the percentile limits are used for both. + """ + n_boots = len(sorted_bootstraps) + pct_low, pct_high = percentile_interval_idx(ci, n_boots) + low, high = compute_interval_limits(bias, acceleration, n_boots, ci) + if isnan(low) or isnan(high): + low, high = pct_low, pct_high + else: + low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + return (sorted_bootstraps[low], sorted_bootstraps[high], + sorted_bootstraps[pct_low], sorted_bootstraps[pct_high]) + + def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded): """ Indexes of the BCa interval limits at the expanded level `ci_expanded` diff --git a/dabest/forest_plot.py b/dabest/forest_plot.py index eca7ed18..fb11f918 100644 --- a/dabest/forest_plot.py +++ b/dabest/forest_plot.py @@ -22,7 +22,8 @@ def load_plot_data( effect_size: str = "mean_diff", contrast_type: str = None, ci_type: str = "bca", - idx: Optional[List[int]] = None + idx: Optional[List[int]] = None, + include_unexpanded: bool = False, ) -> List: """ Loads plot data based on specified effect size and contrast type. @@ -40,11 +41,17 @@ def load_plot_data( idx: Optional[List[int]], default=None List of indices to select from the contrast objects if delta-delta experiment. If None, only the delta-delta objects are plotted. + include_unexpanded: bool, default False + If True, also return, for each curve, the `(low, high)` limits of its + interval before expansion for a small number of clusters, or + `(None, None)` if the interval was not expanded. Returns ------- List: Contrast plot data based on specified parameters. """ + from .plot_tools import unexpanded_limits + # Effect size and contrast types effect_attr = "hedges_g" if effect_size == 'delta_g' else effect_size contrast_attr = {"delta2": "delta_delta", "mini_meta": "mini_meta"}.get(contrast_type) @@ -52,6 +59,7 @@ def load_plot_data( # Testing if idx is not None: bootstraps, differences, bcalows, bcahighs = [], [], [], [] + unexpanded = [] for current_idx, index_group in enumerate(idx): current_contrast = data[current_idx] if len(index_group)>0: @@ -83,6 +91,7 @@ def load_plot_data( differences.append(current_plot_data.results.difference[index_val]) bcalows.append(current_plot_data.results.get(ci_type+'_low')[index_val]) bcahighs.append(current_plot_data.results.get(ci_type+'_high')[index_val]) + unexpanded.append(unexpanded_limits(current_plot_data.results, ci_type, index_val)) else: if contrast_type == 'delta': contrast_plot_data = [getattr(contrast, effect_attr) for contrast in data] @@ -95,6 +104,8 @@ def load_plot_data( differences = [element for innerList in differences_nested for element in innerList] bcalows = [element for innerList in bcalows_nested for element in innerList] bcahighs = [element for innerList in bcahighs_nested for element in innerList] + unexpanded = [unexpanded_limits(result.results, ci_type, i) + for result in contrast_plot_data for i in range(len(result.results))] else: # contrast_type == 'delta2' or 'mini_meta' contrast_plot_data = [getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in data] @@ -104,7 +115,10 @@ def load_plot_data( differences = [result.difference for result in contrast_plot_data] bcalows = [result.results.get(ci_type+'_low')[0] for result in contrast_plot_data] bcahighs = [result.results.get(ci_type+'_high')[0] for result in contrast_plot_data] + unexpanded = [unexpanded_limits(result.results, ci_type, 0) for result in contrast_plot_data] + if include_unexpanded: + return bootstraps, differences, bcalows, bcahighs, unexpanded return bootstraps, differences, bcalows, bcahighs def check_for_errors(**kwargs): @@ -457,6 +471,7 @@ def forest_plot( zeroline_kwargs: Optional[dict] = None, marker_kwargs: Optional[dict] = None, errorbar_kwargs: Optional[dict] = None, + expanded_errorbar_kwargs: Optional[dict] = None, )-> plt.Figure: """ Custom function that generates a forest plot from given contrast objects, suitable for a range of data analysis types, including those from packages like DABEST-python. @@ -530,25 +545,33 @@ def forest_plot( Additional arguments for the effect size marker customization. errorbar_kwargs : Optional[dict], default=None Additional arguments for the effect size error bar customization. + expanded_errorbar_kwargs : Optional[dict], default=None + For intervals expanded for a small number of clusters (see + `dabest.load`'s `cluster_ci_expansion`), the unexpanded interval (the + nominal interval of the plotted bootstrap distribution) is drawn as the + usual error bar, and the expansion beyond it as a thinner line. Additional + arguments here style the thinner line; by default it takes the error + bar's arguments at 40% of its line width. Returns ------- plt.Figure The matplotlib figure object with the generated forest plot. """ - from .plot_tools import halfviolin + from .plot_tools import halfviolin, plot_ci_whisker, expanded_errorbar_kwargs_from # Check for errors in the input arguments all_kwargs = locals() contrast_type = check_for_errors(**all_kwargs) # Load plot data and extract info - bootstraps, differences, bcalows, bcahighs = load_plot_data( + bootstraps, differences, bcalows, bcahighs, unexpanded = load_plot_data( data = data, effect_size = effect_size, contrast_type = contrast_type, ci_type = ci_type, - idx = idx + idx = idx, + include_unexpanded = True, ) # Adjust figure size based on orientation number_of_curves_to_plot = len(bootstraps) @@ -585,13 +608,14 @@ def forest_plot( ) ## Plotting the effect sizes and confidence intervals + expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs, expanded_errorbar_kwargs) for k in range(1, number_of_curves_to_plot + 1): if horizontal: ax.plot(differences[k - 1], k, **marker_kwargs) - ax.plot([bcalows[k - 1], bcahighs[k - 1]], [k, k], **errorbar_kwargs) else: ax.plot(k, differences[k - 1], **marker_kwargs) - ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], **errorbar_kwargs) + plot_ci_whisker(ax, k, bcalows[k - 1], bcahighs[k - 1], horizontal, errorbar_kwargs, + unexpanded[k - 1][0], unexpanded[k - 1][1], expanded_errorbar_kwargs) # Aesthetic Adjustments ## Handle the custom color palette diff --git a/dabest/plot_tools.py b/dabest/plot_tools.py index 9fa023f1..be244540 100644 --- a/dabest/plot_tools.py +++ b/dabest/plot_tools.py @@ -10,8 +10,9 @@ # %% auto #0 __all__ = ['halfviolin', 'get_swarm_spans', 'error_bar', 'check_data_matches_labels', 'normalize_dict', 'width_determine', 'single_sankey', 'sankeydiag', 'add_bars_to_plot', 'delta_text_plotter', 'delta_dots_plotter', - 'slopegraph_plotter', 'plot_minimeta_or_deltadelta_violins', 'effect_size_curve_plotter', 'gridkey_plotter', - 'barplotter', 'table_for_horizontal_plots', 'add_counts_to_prop_plots', 'swarmplot', 'SwarmPlot'] + 'slopegraph_plotter', 'plot_minimeta_or_deltadelta_violins', 'unexpanded_limits', 'plot_ci_whisker', + 'expanded_errorbar_kwargs_from', 'effect_size_curve_plotter', 'gridkey_plotter', 'barplotter', + 'table_for_horizontal_plots', 'add_counts_to_prop_plots', 'swarmplot', 'SwarmPlot'] # %% ../nbs/API/plot_tools.ipynb #b070950d import math @@ -1248,8 +1249,9 @@ def plot_minimeta_or_deltadelta_violins( plot_kwargs: dict, horizontal: bool, show_pairs: bool, - contrast_marker_kwargs: dict, + contrast_marker_kwargs: dict, contrast_errorbar_kwargs: dict, + contrast_expanded_errorbar_kwargs: dict = None, ): """ Add mini meta-analysis or delta-delta violin plots to the contrast plot. @@ -1282,6 +1284,9 @@ def plot_minimeta_or_deltadelta_violins( Keyword arguments for the effectsize marker. contrast_errorbar_kwargs: dict Keyword arguments for the effectsize errorbar. + contrast_expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thin line showing how far the interval was + expanded for a small number of clusters (see `plot_ci_whisker`). """ # Plot the curve @@ -1304,12 +1309,10 @@ def extract_curve_data(dabest_object): position = max(rawdata_axes.get_yticks()) + 1 half = "bottom" effsize_x, effsize_y = difference, [position] - ci_x, ci_y = [ci_low, ci_high], [position, position] else: position = max(rawdata_axes.get_xticks()) + 1 half = "right" effsize_x, effsize_y = [position], difference - ci_x, ci_y = [position, position], [ci_low, ci_high] v = contrast_axes.violinplot( data[~np.isinf(data)], positions=[position], **contrast_kwargs @@ -1324,11 +1327,9 @@ def extract_curve_data(dabest_object): **contrast_marker_kwargs ) # Plot the confidence interval. - contrast_axes.plot( - ci_x, - ci_y, - **contrast_errorbar_kwargs - ) + unexpanded_low, unexpanded_high = unexpanded_limits(dabest_obj.results, ci_type, 0) + plot_ci_whisker(contrast_axes, position, ci_low, ci_high, horizontal, contrast_errorbar_kwargs, + unexpanded_low, unexpanded_high, contrast_expanded_errorbar_kwargs) # Add labels and ticks if horizontal: @@ -1373,23 +1374,109 @@ def extract_curve_data(dabest_object): return delta2_axes, contrast_xtick_labels +def unexpanded_limits(results: pd.DataFrame, prefix: str, index: int): + """ + The unexpanded interval limits stored in `results` for row `index`, e.g. + `bca_low_unexpanded` and `bca_high_unexpanded` for `prefix="bca"`, or + `(None, None)` if the interval was not expanded for a small number of clusters. + """ + low = results.get(prefix + "_low_unexpanded") + high = results.get(prefix + "_high_unexpanded") + if low is None or high is None: + return None, None + low, high = low[index], high[index] + if pd.isna(low) or pd.isna(high): + return None, None + return low, high + + +def plot_ci_whisker( + ax: axes.Axes, + position: float, + ci_low: float, + ci_high: float, + horizontal: bool, + errorbar_kwargs: dict, + unexpanded_low: float = None, + unexpanded_high: float = None, + expanded_errorbar_kwargs: dict = None, + ): + """ + Draw a confidence interval at `position` on `ax`. + + When the interval has been expanded for a small number of clusters, the + unexpanded limits are given too. The unexpanded interval, which the plotted + bootstrap distribution itself spans, is then drawn as the usual thick bar, + and the expansion beyond it as a thinner line (styled by + `expanded_errorbar_kwargs`), so that the plot shows which part of the + interval comes from resampling and which is the small-sample allowance. + + Parameters + ---------- + ax : axes.Axes + Matplotlib axis object to plot on. + position : float + The tick at which to draw the interval. + ci_low, ci_high : float + The limits of the reported interval. + horizontal : bool + If the plot is horizontal. + errorbar_kwargs : dict + Keyword arguments for the interval line. + unexpanded_low, unexpanded_high : float, default None + The limits before expansion, if the interval was expanded. + expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thinner line showing the expansion. + """ + def segment(low, high, kwargs): + if horizontal: + ax.plot([low, high], [position, position], **kwargs) + else: + ax.plot([position, position], [low, high], **kwargs) + + if unexpanded_low is None or unexpanded_high is None: + segment(ci_low, ci_high, errorbar_kwargs) + return + if expanded_errorbar_kwargs is None: + expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs) + segment(ci_low, ci_high, expanded_errorbar_kwargs) + segment(unexpanded_low, unexpanded_high, errorbar_kwargs) + + +def expanded_errorbar_kwargs_from(errorbar_kwargs: dict, custom_kwargs: dict = None) -> dict: + """ + Keyword arguments for the thin line that shows the expansion of an + interval for a small number of clusters: those of the interval line, at + 40% of its width (at least 0.75 points), updated with `custom_kwargs`. + """ + kwargs = dict(errorbar_kwargs) + width = kwargs.pop("linewidth", kwargs.pop("lw", 2)) + kwargs["lw"] = max(0.75, 0.4 * width) + if custom_kwargs: + if "linewidth" in custom_kwargs: + kwargs.pop("lw") + kwargs.update(custom_kwargs) + return kwargs + + def effect_size_curve_plotter( - ticks_to_plot: list, - ticks_for_baseline_ec: list, - results: pd.DataFrame, - ci_type: str, - contrast_axes: axes.Axes, - contrast_kwargs: dict, - bootstraps_color_by_group: bool, + ticks_to_plot: list, + ticks_for_baseline_ec: list, + results: pd.DataFrame, + ci_type: str, + contrast_axes: axes.Axes, + contrast_kwargs: dict, + bootstraps_color_by_group: bool, plot_palette_contrast: dict, - horizontal: bool, - contrast_marker_kwargs: dict, + horizontal: bool, + contrast_marker_kwargs: dict, contrast_errorbar_kwargs: dict, - idx: list, - is_paired: bool, - contrast_paired_lines: bool, + idx: list, + is_paired: bool, + contrast_paired_lines: bool, contrast_paired_lines_kwargs: dict, - show_baseline_ec: bool = False + show_baseline_ec: bool = False, + contrast_expanded_errorbar_kwargs: dict = None, ): """ Add effect size curves to the contrast plot. @@ -1428,9 +1515,13 @@ def effect_size_curve_plotter( Keyword arguments for the repeated measures lines. show_baseline_ec : bool Whether to show the baseline effect curve. + contrast_expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thin line showing how far an interval was + expanded for a small number of clusters (see `plot_ci_whisker`). """ - def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): + def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high, + unexpanded=(None, None)): # Create the violinplot if horizontal: contrast_kwargs.update({'orientation': 'horizontal', 'widths': 1}) @@ -1447,13 +1538,9 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): halfviolin(v, fill_color=fc, alpha=contrast_alpha, half=half) # Plot the confidence interval - if horizontal: - ci_x, ci_y = [ci_low, ci_high], [tick, tick] - else: - ci_x, ci_y = [tick, tick], [ci_low, ci_high] - - contrast_axes.plot(ci_x, ci_y, **contrast_errorbar_kwargs) - + plot_ci_whisker(contrast_axes, tick, ci_low, ci_high, horizontal, contrast_errorbar_kwargs, + unexpanded[0], unexpanded[1], contrast_expanded_errorbar_kwargs) + return "{}\nminus\n{}".format(group, control) if contrast_kwargs.get('alpha') is not None: @@ -1482,7 +1569,8 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): ) label = plot_effect_size(tick, current_group, current_control, current_bootstrap, - current_effsize, current_ci_low, current_ci_high) + current_effsize, current_ci_low, current_ci_high, + unexpanded_limits(results, ci_type, int(j))) contrast_xtick_labels.append(label) # Add baseline effect curve plotting @@ -1504,8 +1592,9 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): contrast_axes.plot(effsize_x, effsize_y, **contrast_marker_kwargs) if show_baseline_ec: - _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, - bec_effsize, bec_ci_low, bec_ci_high) + _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, + bec_effsize, bec_ci_low, bec_ci_high, + unexpanded_limits(bec_results, 'bec_' + ci_type, j)) # Baseline Curve doesn't need tick text # Add lines for repeated measures data diff --git a/dabest/plotter.py b/dabest/plotter.py index 0dfe1039..620f1351 100644 --- a/dabest/plotter.py +++ b/dabest/plotter.py @@ -77,6 +77,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi gridkey_delimiters=[';', '>', '_'], gridkey_kwargs=None, contrast_marker_kwargs=None, contrast_errorbar_kwargs=None, + contrast_expanded_errorbar_kwargs=None, prop_sample_counts=False, prop_sample_counts_kwargs=None, contrast_paired_lines=True, contrast_paired_lines show_baseline_ec=False, @@ -112,7 +113,8 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi barplotter, table_for_horizontal_plots, add_counts_to_prop_plots, - add_bars_to_plot + add_bars_to_plot, + expanded_errorbar_kwargs_from, ) warnings.filterwarnings( @@ -380,6 +382,11 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi ticks_to_plot = [x+0.25 for x in ticks_to_plot] ## Plot the bootstraps, then the effect sizes and CIs. + # Intervals expanded for a small number of clusters are drawn as a thick bar + # over the unexpanded interval and a thinner line over the expansion. + contrast_expanded_errorbar_kwargs = expanded_errorbar_kwargs_from( + contrast_errorbar_kwargs, plot_kwargs.get("contrast_expanded_errorbar_kwargs") + ) contrast_paired_lines = False if float_contrast or not sankey_kwargs["flow"] else plot_kwargs["contrast_paired_lines"] (current_group, current_control, current_effsize, contrast_xtick_labels) = effect_size_curve_plotter( @@ -399,6 +406,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi contrast_paired_lines = contrast_paired_lines, contrast_paired_lines_kwargs = contrast_paired_lines_kwargs, show_baseline_ec = show_baseline_ec, + contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs, ) ## Plot mini-meta or delta-delta violin @@ -418,6 +426,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi show_pairs = show_pairs, contrast_marker_kwargs = contrast_marker_kwargs, contrast_errorbar_kwargs = contrast_errorbar_kwargs, + contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs, ) ## Contrast bars contrast_bars = plot_kwargs["contrast_bars"] diff --git a/nbs/API/confint_2group_diff.ipynb b/nbs/API/confint_2group_diff.ipynb index df221657..adb13a47 100644 --- a/nbs/API/confint_2group_diff.ipynb +++ b/nbs/API/confint_2group_diff.ipynb @@ -414,10 +414,39 @@ "# bootstrap resamples for any practical number of resamples.\n", "_MIN_EXPANDED_ALPHA = 1e-6\n", "\n", - "# Strata carrying less than this share of the variance do not set the degrees\n", - "# of freedom, so that a stray handful of clusters (say, two participants seen in\n", - "# only one condition) cannot inflate the expansion.\n", - "_MIN_VARIANCE_SHARE_FOR_DF = 0.1\n", + "# Strata carrying less than this share of the variance are not counted when\n", + "# judging whether the smallest group of clusters is too small for a reliable\n", + "# interval (see `smallest_cluster_group`), so that a stray handful of clusters\n", + "# (say, two participants seen in only one condition) does not trigger a warning.\n", + "_MIN_VARIANCE_SHARE = 0.1\n", + "\n", + "\n", + "def _usable_components(components):\n", + " \"\"\"Strata with at least 2 clusters, as arrays of variances and sizes.\"\"\"\n", + " components = [(v, n) for v, n in components if n >= 2]\n", + " if not components:\n", + " return None, None\n", + " variances = np.array([v for v, _ in components], dtype=float)\n", + " n = np.array([n for _, n in components], dtype=float)\n", + " if not np.all(np.isfinite(variances)) or variances.sum() <= 0:\n", + " # No usable variance information: weight the strata equally.\n", + " variances = np.ones_like(n)\n", + " return variances, n\n", + "\n", + "\n", + "def smallest_cluster_group(components):\n", + " \"\"\"\n", + " The number of clusters in the smallest stratum that carries at least 10%\n", + " of the variance (see `cluster_variance_components`); None if no stratum\n", + " has at least 2 clusters.\n", + " \"\"\"\n", + " variances, n = _usable_components(components)\n", + " if n is None:\n", + " return None\n", + " shares = variances / variances.sum()\n", + " # Never let the threshold exclude every stratum (e.g. many equal strata).\n", + " threshold = min(_MIN_VARIANCE_SHARE, shares.max())\n", + " return int(n[shares >= threshold].min())\n", "\n", "\n", "def expanded_ci_level(ci, components):\n", @@ -438,33 +467,26 @@ " clusters nested within groups), `components` holds each stratum's\n", " `(variance, n)` (see `cluster_variance_components`). The narrowness\n", " correction is then applied stratum by stratum, weighted by each stratum's\n", - " share of the variance, and the degrees of freedom are those of the\n", - " smallest stratum carrying at least 10% of the variance. This is the\n", - " conservative (Hsu) alternative to the Welch-Satterthwaite approximation,\n", - " which in simulations under-covered for unbalanced and mixed designs. Both\n", - " reduce to the single-sample correction above for one stratum.\n", + " share of the variance, and the degrees of freedom come from the\n", + " Welch-Satterthwaite approximation. Both reduce to the single-sample\n", + " correction above for one stratum. In simulations of unbalanced or mixed\n", + " designs whose smallest group held only 4 to 6 clusters, Welch-Satterthwaite\n", + " intervals covered 1 to 3 points below nominal; the more conservative\n", + " alternative of the smallest stratum's degrees of freedom over-covered by\n", + " similar amounts, with intervals about 10% wider.\n", "\n", " Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least\n", " 2 clusters, in which case no expansion is possible.\n", " \"\"\"\n", " from scipy.stats import t as student_t\n", "\n", - " components = [(v, n) for v, n in components if n >= 2]\n", - " if not components:\n", + " variances, n = _usable_components(components)\n", + " if n is None:\n", " return ci, None\n", "\n", - " variances = np.array([v for v, _ in components], dtype=float)\n", - " n = np.array([n for _, n in components], dtype=float)\n", - " if not np.all(np.isfinite(variances)) or variances.sum() <= 0:\n", - " # No usable variance information: weight the strata equally.\n", - " variances = np.ones_like(n)\n", - "\n", " total = variances.sum()\n", " narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n))\n", - " shares = variances / total\n", - " # Never let the threshold exclude every stratum (e.g. many equal strata).\n", - " threshold = min(_MIN_VARIANCE_SHARE_FOR_DF, shares.max())\n", - " df = float(n[shares >= threshold].min() - 1)\n", + " df = float(total ** 2 / np.sum(variances ** 2 / (n - 1)))\n", "\n", " alpha = _compute_alpha_from_ci(ci)\n", " z = narrowness * student_t.ppf(1 - alpha / 2, df)\n", @@ -483,6 +505,26 @@ " return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", "\n", "\n", + "def unexpanded_interval_limits(sorted_bootstraps, bias, acceleration, ci):\n", + " \"\"\"\n", + " The BCa and percentile limits at the nominal level `ci`, as\n", + " `(bca_low, bca_high, pct_low, pct_high)`, for an interval that has been\n", + " expanded for a small number of clusters. Plots show this unexpanded\n", + " interval, which the bootstrap distribution itself spans, as the thick part\n", + " of the interval, and the expansion beyond it as a thinner line. If the BCa\n", + " limits cannot be computed, the percentile limits are used for both.\n", + " \"\"\"\n", + " n_boots = len(sorted_bootstraps)\n", + " pct_low, pct_high = percentile_interval_idx(ci, n_boots)\n", + " low, high = compute_interval_limits(bias, acceleration, n_boots, ci)\n", + " if isnan(low) or isnan(high):\n", + " low, high = pct_low, pct_high\n", + " else:\n", + " low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + " return (sorted_bootstraps[low], sorted_bootstraps[high],\n", + " sorted_bootstraps[pct_low], sorted_bootstraps[pct_high])\n", + "\n", + "\n", "def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded):\n", " \"\"\"\n", " Indexes of the BCa interval limits at the expanded level `ci_expanded`\n", diff --git a/nbs/API/delta_objects.ipynb b/nbs/API/delta_objects.ipynb index 14b72fb1..05e95235 100644 --- a/nbs/API/delta_objects.ipynb +++ b/nbs/API/delta_objects.ipynb @@ -266,6 +266,14 @@ " self.__pct_low = sorted_delta_delta[pct_idx_low]\n", " self.__pct_high = sorted_delta_delta[pct_idx_high]\n", "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " self.__unexpanded = (None, None, None, None)\n", + " if self.__ci_expanded is not None:\n", + " self.__unexpanded = ci2g.unexpanded_interval_limits(\n", + " sorted_delta_delta, self.__bias_correction, self.__acceleration_value, ci\n", + " )\n", + "\n", " def __permutation_test(self):\n", " \"\"\"\n", " Perform a permutation test and obtain the permutation p-value\n", @@ -365,6 +373,9 @@ " ]\n", " if self.__ci_expanded is not None:\n", " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", + " position = column_index.index('pct_interval_idx') + 1\n", + " column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded',\n", + " 'pct_low_unexpanded', 'pct_high_unexpanded']\n", " delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]]\n", " delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]]\n", " delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]]\n", @@ -391,6 +402,38 @@ " return self.__ci_expanded\n", "\n", " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[0]\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[1]\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[2]\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[3]\n", + "\n", + " @property\n", " def alpha(self):\n", " \"\"\"\n", " Returns the significance level of the statistical test as a float\n", @@ -774,6 +817,14 @@ " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_weighted_deltas[pct_idx_low]\n", " self.__pct_high = sorted_weighted_deltas[pct_idx_high]\n", + "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " self.__unexpanded = (None, None, None, None)\n", + " if self.__ci_expanded is not None:\n", + " self.__unexpanded = ci2g.unexpanded_interval_limits(\n", + " sorted_weighted_deltas, self.__bias_correction, self.__acceleration_value, ci\n", + " )\n", " \n", " \n", "\n", @@ -897,6 +948,9 @@ " 'permutation_count', 'bias_correction', 'jackknives']\n", " if self.__ci_expanded is not None:\n", " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", + " position = column_index.index('pct_interval_idx') + 1\n", + " column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded',\n", + " 'pct_low_unexpanded', 'pct_high_unexpanded']\n", " mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index)\n", " mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True)\n", "\n", @@ -920,6 +974,38 @@ " \"\"\"\n", " return self.__ci_expanded\n", "\n", + " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[0]\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[1]\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[2]\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[3]\n", + "\n", "\n", " @property\n", " def alpha(self):\n", diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 8007c144..09d3647c 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -352,6 +352,17 @@ " self.__pct_low = sorted_bootstraps[pct_idx_low]\n", " self.__pct_high = sorted_bootstraps[pct_idx_high]\n", "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " if self.__ci_expanded is not None:\n", + " (self.__bca_low_unexpanded, self.__bca_high_unexpanded,\n", + " self.__pct_low_unexpanded, self.__pct_high_unexpanded) = ci2g.unexpanded_interval_limits(\n", + " sorted_bootstraps, self.__bias_correction, self.__acceleration_value, self.__ci\n", + " )\n", + " else:\n", + " self.__bca_low_unexpanded = self.__bca_high_unexpanded = None\n", + " self.__pct_low_unexpanded = self.__pct_high_unexpanded = None\n", + "\n", " self._get_bootstrap_baseline_ec()\n", "\n", " self._perform_statistical_test()\n", @@ -501,15 +512,16 @@ " return None, None\n", " # In simulations, expanded intervals came close to nominal coverage once\n", " # there were at least 6 clusters in all, and at least 4 in the smallest\n", - " # group of clusters that sets the degrees of freedom.\n", + " # independently resampled group of clusters.\n", " n_total = sum(n for _, n in components if n >= 2)\n", - " if n_total < 6 or df + 1 < 4:\n", + " n_smallest = ci2g.smallest_cluster_group(components)\n", + " if n_total < 6 or n_smallest < 4:\n", " warnings.warn(\n", " \"Only {} clusters are available to resample ({} in the smallest group of \"\n", " \"clusters); even after expansion for the small number of clusters, the \"\n", " \"confidence interval is unreliable and likely too narrow. At least 6 \"\n", " \"clusters, and at least 4 in every group of clusters, are \"\n", - " \"recommended.\".format(int(n_total), int(df + 1))\n", + " \"recommended.\".format(int(n_total), int(n_smallest))\n", " )\n", " return ci_expanded, df\n", "\n", @@ -830,6 +842,15 @@ " self.__bec_pct_low = sorted_bootstraps[pct_idx_low]\n", " self.__bec_pct_high = sorted_bootstraps[pct_idx_high]\n", "\n", + " if bec_ci_expanded is not None:\n", + " (self.__bec_bca_low_unexpanded, self.__bec_bca_high_unexpanded,\n", + " self.__bec_pct_low_unexpanded, self.__bec_pct_high_unexpanded) = ci2g.unexpanded_interval_limits(\n", + " sorted_bootstraps, bias_correction, acceleration_value, self.__ci\n", + " )\n", + " else:\n", + " self.__bec_bca_low_unexpanded = self.__bec_bca_high_unexpanded = None\n", + " self.__bec_pct_low_unexpanded = self.__bec_pct_high_unexpanded = None\n", + "\n", " @property\n", " def difference(self):\n", " \"\"\"\n", @@ -976,6 +997,38 @@ " return self.__pct_high\n", "\n", " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__bca_low_unexpanded\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__bca_high_unexpanded\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__pct_low_unexpanded\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__pct_high_unexpanded\n", + "\n", + " @property\n", " def pvalue_brunner_munzel(self):\n", " try:\n", " return self.__pvalue_brunner_munzel\n", @@ -1162,6 +1215,38 @@ " The percentile confidence interval lower limit for baseline error.\n", " \"\"\"\n", " return self.__bec_pct_high\n", + "\n", + " @property\n", + " def bec_bca_low_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's BCa lower limit before expansion for a\n", + " small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_bca_low_unexpanded\n", + "\n", + " @property\n", + " def bec_bca_high_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's BCa upper limit before expansion for a\n", + " small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_bca_high_unexpanded\n", + "\n", + " @property\n", + " def bec_pct_low_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's percentile lower limit before expansion for\n", + " a small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_pct_low_unexpanded\n", + "\n", + " @property\n", + " def bec_pct_high_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's percentile upper limit before expansion for\n", + " a small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_pct_high_unexpanded\n", " " ] }, @@ -1463,6 +1548,10 @@ " \"pct_low\",\n", " \"pct_high\",\n", " \"pct_interval_idx\",\n", + " \"bca_low_unexpanded\",\n", + " \"bca_high_unexpanded\",\n", + " \"pct_low_unexpanded\",\n", + " \"pct_high_unexpanded\",\n", " \"bootstraps\",\n", " \"resamples\",\n", " \"random_seed\",\n", @@ -1495,6 +1584,10 @@ " \"bec_pct_interval_idx\",\n", " \"bec_pct_low\",\n", " \"bec_pct_high\",\n", + " \"bec_bca_low_unexpanded\",\n", + " \"bec_bca_high_unexpanded\",\n", + " \"bec_pct_low_unexpanded\",\n", + " \"bec_pct_high_unexpanded\",\n", " ]\n", " self.__results = out_.reindex(columns=columns_in_order)\n", " self.__results.dropna(axis=\"columns\", how=\"all\", inplace=True)\n", @@ -1702,6 +1795,7 @@ "\n", " contrast_marker_kwargs=None, # es_marker_kwargs=None, OLD\n", " contrast_errorbar_kwargs=None, # es_errorbar_kwargs=None, OLD\n", + " contrast_expanded_errorbar_kwargs=None,\n", "\n", " prop_sample_counts=False,\n", " prop_sample_counts_kwargs=None,\n", @@ -1938,6 +2032,16 @@ " contrast_errorbar_kwargs: dict, default None\n", " Pass relevant keyword arguments to the effectsize errorbar plotting. If none, the following keywords are passed:\n", " {'color': 'black', 'lw': 2, 'linestyle': '-', 'alpha': 1,'zorder': 1,}\n", + " contrast_expanded_errorbar_kwargs: dict, default None\n", + " When `cluster_col` is set, intervals are expanded for the number of\n", + " clusters (see `dabest.load`'s `cluster_ci_expansion`). The plotted\n", + " bootstrap distribution does not change, so the expanded interval\n", + " reaches further into its tails than its nominal `ci`% interval. To\n", + " show this, the unexpanded interval (the nominal `ci`% interval of\n", + " the plotted distribution) is drawn as the usual errorbar, and the\n", + " expansion beyond it as a thinner line. Pass keyword arguments here\n", + " to style the thinner line; by default it takes the errorbar's\n", + " keywords at 40% of its line width.\n", "\n", " prop_sample_counts: bool, default False\n", " Show the sample counts for each group in proportional plots\n", diff --git a/nbs/API/forest_plot.ipynb b/nbs/API/forest_plot.ipynb index 6fd10835..a1933bea 100644 --- a/nbs/API/forest_plot.ipynb +++ b/nbs/API/forest_plot.ipynb @@ -87,7 +87,8 @@ " effect_size: str = \"mean_diff\", \n", " contrast_type: str = None,\n", " ci_type: str = \"bca\",\n", - " idx: Optional[List[int]] = None\n", + " idx: Optional[List[int]] = None,\n", + " include_unexpanded: bool = False,\n", ") -> List:\n", " \"\"\"\n", " Loads plot data based on specified effect size and contrast type.\n", @@ -105,11 +106,17 @@ " idx: Optional[List[int]], default=None\n", " List of indices to select from the contrast objects if delta-delta experiment. \n", " If None, only the delta-delta objects are plotted.\n", + " include_unexpanded: bool, default False\n", + " If True, also return, for each curve, the `(low, high)` limits of its\n", + " interval before expansion for a small number of clusters, or\n", + " `(None, None)` if the interval was not expanded.\n", "\n", " Returns\n", " -------\n", " List: Contrast plot data based on specified parameters.\n", " \"\"\"\n", + " from .plot_tools import unexpanded_limits\n", + "\n", " # Effect size and contrast types\n", " effect_attr = \"hedges_g\" if effect_size == 'delta_g' else effect_size\n", " contrast_attr = {\"delta2\": \"delta_delta\", \"mini_meta\": \"mini_meta\"}.get(contrast_type)\n", @@ -117,6 +124,7 @@ " # Testing\n", " if idx is not None:\n", " bootstraps, differences, bcalows, bcahighs = [], [], [], []\n", + " unexpanded = []\n", " for current_idx, index_group in enumerate(idx):\n", " current_contrast = data[current_idx]\n", " if len(index_group)>0:\n", @@ -148,6 +156,7 @@ " differences.append(current_plot_data.results.difference[index_val])\n", " bcalows.append(current_plot_data.results.get(ci_type+'_low')[index_val])\n", " bcahighs.append(current_plot_data.results.get(ci_type+'_high')[index_val]) \n", + " unexpanded.append(unexpanded_limits(current_plot_data.results, ci_type, index_val))\n", " else:\n", " if contrast_type == 'delta':\n", " contrast_plot_data = [getattr(contrast, effect_attr) for contrast in data]\n", @@ -160,6 +169,8 @@ " differences = [element for innerList in differences_nested for element in innerList]\n", " bcalows = [element for innerList in bcalows_nested for element in innerList]\n", " bcahighs = [element for innerList in bcahighs_nested for element in innerList]\n", + " unexpanded = [unexpanded_limits(result.results, ci_type, i)\n", + " for result in contrast_plot_data for i in range(len(result.results))]\n", "\n", " else: # contrast_type == 'delta2' or 'mini_meta'\n", " contrast_plot_data = [getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in data]\n", @@ -169,7 +180,10 @@ " differences = [result.difference for result in contrast_plot_data]\n", " bcalows = [result.results.get(ci_type+'_low')[0] for result in contrast_plot_data]\n", " bcahighs = [result.results.get(ci_type+'_high')[0] for result in contrast_plot_data]\n", + " unexpanded = [unexpanded_limits(result.results, ci_type, 0) for result in contrast_plot_data]\n", "\n", + " if include_unexpanded:\n", + " return bootstraps, differences, bcalows, bcahighs, unexpanded\n", " return bootstraps, differences, bcalows, bcahighs\n", "\n", "def check_for_errors(**kwargs):\n", @@ -522,6 +536,7 @@ " zeroline_kwargs: Optional[dict] = None,\n", " marker_kwargs: Optional[dict] = None,\n", " errorbar_kwargs: Optional[dict] = None,\n", + " expanded_errorbar_kwargs: Optional[dict] = None,\n", ")-> plt.Figure:\n", " \"\"\" \n", " Custom function that generates a forest plot from given contrast objects, suitable for a range of data analysis types, including those from packages like DABEST-python.\n", @@ -595,25 +610,33 @@ " Additional arguments for the effect size marker customization.\n", " errorbar_kwargs : Optional[dict], default=None\n", " Additional arguments for the effect size error bar customization.\n", + " expanded_errorbar_kwargs : Optional[dict], default=None\n", + " For intervals expanded for a small number of clusters (see\n", + " `dabest.load`'s `cluster_ci_expansion`), the unexpanded interval (the\n", + " nominal interval of the plotted bootstrap distribution) is drawn as the\n", + " usual error bar, and the expansion beyond it as a thinner line. Additional\n", + " arguments here style the thinner line; by default it takes the error\n", + " bar's arguments at 40% of its line width.\n", "\n", " Returns\n", " -------\n", " plt.Figure\n", " The matplotlib figure object with the generated forest plot.\n", " \"\"\"\n", - " from .plot_tools import halfviolin\n", + " from .plot_tools import halfviolin, plot_ci_whisker, expanded_errorbar_kwargs_from\n", "\n", " # Check for errors in the input arguments\n", " all_kwargs = locals()\n", " contrast_type = check_for_errors(**all_kwargs)\n", "\n", " # Load plot data and extract info\n", - " bootstraps, differences, bcalows, bcahighs = load_plot_data(\n", + " bootstraps, differences, bcalows, bcahighs, unexpanded = load_plot_data(\n", " data = data, \n", " effect_size = effect_size, \n", " contrast_type = contrast_type,\n", " ci_type = ci_type,\n", - " idx = idx\n", + " idx = idx,\n", + " include_unexpanded = True,\n", " )\n", " # Adjust figure size based on orientation\n", " number_of_curves_to_plot = len(bootstraps)\n", @@ -650,13 +673,14 @@ " )\n", " \n", " ## Plotting the effect sizes and confidence intervals\n", + " expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs, expanded_errorbar_kwargs)\n", " for k in range(1, number_of_curves_to_plot + 1):\n", " if horizontal:\n", " ax.plot(differences[k - 1], k, **marker_kwargs) \n", - " ax.plot([bcalows[k - 1], bcahighs[k - 1]], [k, k], **errorbar_kwargs) \n", " else:\n", " ax.plot(k, differences[k - 1], **marker_kwargs)\n", - " ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], **errorbar_kwargs)\n", + " plot_ci_whisker(ax, k, bcalows[k - 1], bcahighs[k - 1], horizontal, errorbar_kwargs,\n", + " unexpanded[k - 1][0], unexpanded[k - 1][1], expanded_errorbar_kwargs)\n", " \n", " # Aesthetic Adjustments\n", " ## Handle the custom color palette\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index 2f7f84b8..8f1a9631 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -169,16 +169,22 @@ " bootstrap distribution, at a level derived from a t distribution with\n", " degrees of freedom based on the number of clusters. When clusters are\n", " nested within groups, or some clusters appear in only some groups, the\n", - " conservative choice of the smallest group of clusters' degrees of\n", - " freedom is used. The reported confidence level (`ci`) is unchanged; the\n", - " level actually read is reported as `ci_expanded` in the results. The\n", + " groups of clusters are resampled independently, and their degrees of\n", + " freedom are combined with the Welch-Satterthwaite approximation. The\n", + " reported confidence level (`ci`) is unchanged; the level actually read\n", + " is reported as `ci_expanded` in the results, alongside the unexpanded\n", + " limits (`bca_low_unexpanded` and so on). Plots draw the unexpanded\n", + " interval (the nominal `ci`% interval of the plotted bootstrap\n", + " distribution) as the usual thick bar, and the expansion beyond it as a\n", + " thinner line (see `contrast_expanded_errorbar_kwargs` in `plot()`). The\n", " correction fades as the number of clusters grows. In simulations the\n", - " expanded intervals came close to nominal coverage for every effect size\n", - " once there were at least 6 clusters in all and at least 4 in each\n", - " independently resampled group of clusters (for example 6 participants\n", - " who each take part in every condition, or 8 participants split between\n", - " two conditions); with fewer, no bootstrap interval is reliable, and a\n", - " warning is given. Because expanded intervals are read further into the\n", + " expanded intervals came within about 3 percentage points of nominal\n", + " coverage for every effect size once there were at least 6 clusters in\n", + " all and at least 4 in each independently resampled group of clusters\n", + " (for example 6 participants who each take part in every condition, or\n", + " 8 participants split between two conditions); with fewer, no bootstrap\n", + " interval is reliable, and a warning is given. Because expanded\n", + " intervals are read further into the\n", " tails of the bootstrap distribution, consider increasing `resamples`\n", " (to 20000, say) when there are few clusters. Set to False to report\n", " unexpanded cluster-bootstrap intervals.\n", diff --git a/nbs/API/plot_tools.ipynb b/nbs/API/plot_tools.ipynb index 3e876553..533613c0 100644 --- a/nbs/API/plot_tools.ipynb +++ b/nbs/API/plot_tools.ipynb @@ -1297,8 +1297,9 @@ " plot_kwargs: dict, \n", " horizontal: bool, \n", " show_pairs: bool,\n", - " contrast_marker_kwargs: dict, \n", + " contrast_marker_kwargs: dict,\n", " contrast_errorbar_kwargs: dict,\n", + " contrast_expanded_errorbar_kwargs: dict = None,\n", " ):\n", " \"\"\"\n", " Add mini meta-analysis or delta-delta violin plots to the contrast plot.\n", @@ -1331,6 +1332,9 @@ " Keyword arguments for the effectsize marker.\n", " contrast_errorbar_kwargs: dict\n", " Keyword arguments for the effectsize errorbar.\n", + " contrast_expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thin line showing how far the interval was\n", + " expanded for a small number of clusters (see `plot_ci_whisker`).\n", " \"\"\"\n", "\n", " # Plot the curve\n", @@ -1353,12 +1357,10 @@ " position = max(rawdata_axes.get_yticks()) + 1\n", " half = \"bottom\"\n", " effsize_x, effsize_y = difference, [position]\n", - " ci_x, ci_y = [ci_low, ci_high], [position, position]\n", " else:\n", " position = max(rawdata_axes.get_xticks()) + 1\n", " half = \"right\"\n", " effsize_x, effsize_y = [position], difference\n", - " ci_x, ci_y = [position, position], [ci_low, ci_high]\n", "\n", " v = contrast_axes.violinplot(\n", " data[~np.isinf(data)], positions=[position], **contrast_kwargs\n", @@ -1373,11 +1375,9 @@ " **contrast_marker_kwargs\n", " )\n", " # Plot the confidence interval.\n", - " contrast_axes.plot(\n", - " ci_x,\n", - " ci_y,\n", - " **contrast_errorbar_kwargs\n", - " )\n", + " unexpanded_low, unexpanded_high = unexpanded_limits(dabest_obj.results, ci_type, 0)\n", + " plot_ci_whisker(contrast_axes, position, ci_low, ci_high, horizontal, contrast_errorbar_kwargs,\n", + " unexpanded_low, unexpanded_high, contrast_expanded_errorbar_kwargs)\n", "\n", " # Add labels and ticks\n", " if horizontal:\n", @@ -1422,23 +1422,109 @@ " return delta2_axes, contrast_xtick_labels\n", "\n", "\n", + "def unexpanded_limits(results: pd.DataFrame, prefix: str, index: int):\n", + " \"\"\"\n", + " The unexpanded interval limits stored in `results` for row `index`, e.g.\n", + " `bca_low_unexpanded` and `bca_high_unexpanded` for `prefix=\"bca\"`, or\n", + " `(None, None)` if the interval was not expanded for a small number of clusters.\n", + " \"\"\"\n", + " low = results.get(prefix + \"_low_unexpanded\")\n", + " high = results.get(prefix + \"_high_unexpanded\")\n", + " if low is None or high is None:\n", + " return None, None\n", + " low, high = low[index], high[index]\n", + " if pd.isna(low) or pd.isna(high):\n", + " return None, None\n", + " return low, high\n", + "\n", + "\n", + "def plot_ci_whisker(\n", + " ax: axes.Axes,\n", + " position: float,\n", + " ci_low: float,\n", + " ci_high: float,\n", + " horizontal: bool,\n", + " errorbar_kwargs: dict,\n", + " unexpanded_low: float = None,\n", + " unexpanded_high: float = None,\n", + " expanded_errorbar_kwargs: dict = None,\n", + " ):\n", + " \"\"\"\n", + " Draw a confidence interval at `position` on `ax`.\n", + "\n", + " When the interval has been expanded for a small number of clusters, the\n", + " unexpanded limits are given too. The unexpanded interval, which the plotted\n", + " bootstrap distribution itself spans, is then drawn as the usual thick bar,\n", + " and the expansion beyond it as a thinner line (styled by\n", + " `expanded_errorbar_kwargs`), so that the plot shows which part of the\n", + " interval comes from resampling and which is the small-sample allowance.\n", + "\n", + " Parameters\n", + " ----------\n", + " ax : axes.Axes\n", + " Matplotlib axis object to plot on.\n", + " position : float\n", + " The tick at which to draw the interval.\n", + " ci_low, ci_high : float\n", + " The limits of the reported interval.\n", + " horizontal : bool\n", + " If the plot is horizontal.\n", + " errorbar_kwargs : dict\n", + " Keyword arguments for the interval line.\n", + " unexpanded_low, unexpanded_high : float, default None\n", + " The limits before expansion, if the interval was expanded.\n", + " expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thinner line showing the expansion.\n", + " \"\"\"\n", + " def segment(low, high, kwargs):\n", + " if horizontal:\n", + " ax.plot([low, high], [position, position], **kwargs)\n", + " else:\n", + " ax.plot([position, position], [low, high], **kwargs)\n", + "\n", + " if unexpanded_low is None or unexpanded_high is None:\n", + " segment(ci_low, ci_high, errorbar_kwargs)\n", + " return\n", + " if expanded_errorbar_kwargs is None:\n", + " expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs)\n", + " segment(ci_low, ci_high, expanded_errorbar_kwargs)\n", + " segment(unexpanded_low, unexpanded_high, errorbar_kwargs)\n", + "\n", + "\n", + "def expanded_errorbar_kwargs_from(errorbar_kwargs: dict, custom_kwargs: dict = None) -> dict:\n", + " \"\"\"\n", + " Keyword arguments for the thin line that shows the expansion of an\n", + " interval for a small number of clusters: those of the interval line, at\n", + " 40% of its width (at least 0.75 points), updated with `custom_kwargs`.\n", + " \"\"\"\n", + " kwargs = dict(errorbar_kwargs)\n", + " width = kwargs.pop(\"linewidth\", kwargs.pop(\"lw\", 2))\n", + " kwargs[\"lw\"] = max(0.75, 0.4 * width)\n", + " if custom_kwargs:\n", + " if \"linewidth\" in custom_kwargs:\n", + " kwargs.pop(\"lw\")\n", + " kwargs.update(custom_kwargs)\n", + " return kwargs\n", + "\n", + "\n", "def effect_size_curve_plotter(\n", - " ticks_to_plot: list, \n", - " ticks_for_baseline_ec: list, \n", - " results: pd.DataFrame, \n", - " ci_type: str, \n", - " contrast_axes: axes.Axes, \n", - " contrast_kwargs: dict, \n", - " bootstraps_color_by_group: bool, \n", + " ticks_to_plot: list,\n", + " ticks_for_baseline_ec: list,\n", + " results: pd.DataFrame,\n", + " ci_type: str,\n", + " contrast_axes: axes.Axes,\n", + " contrast_kwargs: dict,\n", + " bootstraps_color_by_group: bool,\n", " plot_palette_contrast: dict,\n", - " horizontal: bool, \n", - " contrast_marker_kwargs: dict, \n", + " horizontal: bool,\n", + " contrast_marker_kwargs: dict,\n", " contrast_errorbar_kwargs: dict,\n", - " idx: list, \n", - " is_paired: bool, \n", - " contrast_paired_lines: bool, \n", + " idx: list,\n", + " is_paired: bool,\n", + " contrast_paired_lines: bool,\n", " contrast_paired_lines_kwargs: dict,\n", - " show_baseline_ec: bool = False\n", + " show_baseline_ec: bool = False,\n", + " contrast_expanded_errorbar_kwargs: dict = None,\n", " ):\n", " \"\"\"\n", " Add effect size curves to the contrast plot.\n", @@ -1477,9 +1563,13 @@ " Keyword arguments for the repeated measures lines.\n", " show_baseline_ec : bool\n", " Whether to show the baseline effect curve.\n", + " contrast_expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thin line showing how far an interval was\n", + " expanded for a small number of clusters (see `plot_ci_whisker`).\n", " \"\"\"\n", "\n", - " def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high):\n", + " def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high,\n", + " unexpanded=(None, None)):\n", " # Create the violinplot\n", " if horizontal: \n", " contrast_kwargs.update({'orientation': 'horizontal', 'widths': 1})\n", @@ -1496,13 +1586,9 @@ " halfviolin(v, fill_color=fc, alpha=contrast_alpha, half=half)\n", "\n", " # Plot the confidence interval\n", - " if horizontal:\n", - " ci_x, ci_y = [ci_low, ci_high], [tick, tick]\n", - " else:\n", - " ci_x, ci_y = [tick, tick], [ci_low, ci_high]\n", - " \n", - " contrast_axes.plot(ci_x, ci_y, **contrast_errorbar_kwargs)\n", - " \n", + " plot_ci_whisker(contrast_axes, tick, ci_low, ci_high, horizontal, contrast_errorbar_kwargs,\n", + " unexpanded[0], unexpanded[1], contrast_expanded_errorbar_kwargs)\n", + "\n", " return \"{}\\nminus\\n{}\".format(group, control)\n", " \n", " if contrast_kwargs.get('alpha') is not None:\n", @@ -1531,7 +1617,8 @@ " )\n", "\n", " label = plot_effect_size(tick, current_group, current_control, current_bootstrap,\n", - " current_effsize, current_ci_low, current_ci_high)\n", + " current_effsize, current_ci_low, current_ci_high,\n", + " unexpanded_limits(results, ci_type, int(j)))\n", " contrast_xtick_labels.append(label)\n", "\n", " # Add baseline effect curve plotting\n", @@ -1553,8 +1640,9 @@ " contrast_axes.plot(effsize_x, effsize_y, **contrast_marker_kwargs)\n", " \n", " if show_baseline_ec:\n", - " _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, \n", - " bec_effsize, bec_ci_low, bec_ci_high)\n", + " _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap,\n", + " bec_effsize, bec_ci_low, bec_ci_high,\n", + " unexpanded_limits(bec_results, 'bec_' + ci_type, j))\n", " # Baseline Curve doesn't need tick text\n", "\n", " # Add lines for repeated measures data\n", diff --git a/nbs/API/plotter.ipynb b/nbs/API/plotter.ipynb index ad955b3b..b16c44c6 100644 --- a/nbs/API/plotter.ipynb +++ b/nbs/API/plotter.ipynb @@ -132,6 +132,7 @@ " gridkey_delimiters=[';', '>', '_'],\n", " gridkey_kwargs=None,\n", " contrast_marker_kwargs=None, contrast_errorbar_kwargs=None,\n", + " contrast_expanded_errorbar_kwargs=None,\n", " prop_sample_counts=False, prop_sample_counts_kwargs=None, \n", " contrast_paired_lines=True, contrast_paired_lines\n", "\t\tshow_baseline_ec=False,\n", @@ -167,7 +168,8 @@ " barplotter,\n", " table_for_horizontal_plots,\n", " add_counts_to_prop_plots,\n", - " add_bars_to_plot\n", + " add_bars_to_plot,\n", + " expanded_errorbar_kwargs_from,\n", " )\n", "\n", " warnings.filterwarnings(\n", @@ -435,6 +437,11 @@ " ticks_to_plot = [x+0.25 for x in ticks_to_plot]\n", "\n", " ## Plot the bootstraps, then the effect sizes and CIs.\n", + " # Intervals expanded for a small number of clusters are drawn as a thick bar\n", + " # over the unexpanded interval and a thinner line over the expansion.\n", + " contrast_expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(\n", + " contrast_errorbar_kwargs, plot_kwargs.get(\"contrast_expanded_errorbar_kwargs\")\n", + " )\n", " contrast_paired_lines = False if float_contrast or not sankey_kwargs[\"flow\"] else plot_kwargs[\"contrast_paired_lines\"]\n", " (current_group, current_control,\n", " current_effsize, contrast_xtick_labels) = effect_size_curve_plotter(\n", @@ -454,6 +461,7 @@ " contrast_paired_lines = contrast_paired_lines,\n", "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tcontrast_paired_lines_kwargs = contrast_paired_lines_kwargs,\n", "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tshow_baseline_ec = show_baseline_ec,\n", + " contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs,\n", " )\n", "\n", " ## Plot mini-meta or delta-delta violin\n", @@ -473,6 +481,7 @@ " show_pairs = show_pairs,\n", " contrast_marker_kwargs = contrast_marker_kwargs,\n", " contrast_errorbar_kwargs = contrast_errorbar_kwargs,\n", + " contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs,\n", " )\n", " ## Contrast bars\n", " contrast_bars = plot_kwargs[\"contrast_bars\"]\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py index 77f463c6..bf297bd1 100644 --- a/nbs/tests/test_cluster_bootstrap.py +++ b/nbs/tests/test_cluster_bootstrap.py @@ -456,12 +456,15 @@ def test_cluster_permutation_test(): # --------------------------------------------------------------------------- # Small-sample expansion of cluster-bootstrap intervals (`cluster_ci_expansion`) # --------------------------------------------------------------------------- -def _hesterberg_level(n, ci=95): - """Hesterberg's (2015) expanded percentile level for a single sample of n units.""" +def _hesterberg_level(n, ci=95, df=None): + """ + Hesterberg's (2015) expanded percentile level for a single sample of n units; + `df` replaces the n - 1 degrees of freedom of the t quantile. + """ from scipy import stats alpha = (100 - ci) / 100 - z = np.sqrt(n / (n - 1)) * stats.t.ppf(1 - alpha / 2, n - 1) + z = np.sqrt(n / (n - 1)) * stats.t.ppf(1 - alpha / 2, n - 1 if df is None else df) return 100 * (1 - 2 * stats.norm.sf(z)) @@ -480,26 +483,36 @@ def test_expanded_level_behaviour(): assert all(a > b for a, b in zip(levels, levels[1:])) # fewer clusters, more expansion assert levels[-1] > 95 and levels[-1] == pytest.approx(95, abs=0.05) - # Two equal, independently resampled strata: the conservative (Hsu) degrees of - # freedom are those of the smaller stratum, so the result equals one stratum's. + # Two equal, independently resampled strata: the Welch-Satterthwaite degrees + # of freedom pool both strata, so the expansion is smaller than for either alone. level, df = ci2g.expanded_ci_level(95, [(1.0, 8), (1.0, 8)]) - assert df == 7 - assert level == pytest.approx(_hesterberg_level(8)) + assert df == pytest.approx(14) + assert level == pytest.approx(_hesterberg_level(8, df=14)) + assert 95 < level < _hesterberg_level(8) - # Unequal strata: the smallest stratum that carries real variance sets the df. + # Unequal strata: the degrees of freedom are weighted by the variance shares. _, df = ci2g.expanded_ci_level(95, [(1.0, 5), (3.0, 20)]) - assert df == 4 - # A stratum carrying a negligible share of the variance does not set the df ... + assert df == pytest.approx(4 ** 2 / (1 / 4 + 3 ** 2 / 19)) + # A stratum carrying a negligible share of the variance barely counts ... level_dominated, df = ci2g.expanded_ci_level(95, [(1.0, 40), (1e-9, 3)]) - assert df == 39 + assert df == pytest.approx(39) assert level_dominated == pytest.approx(_hesterberg_level(40), rel=1e-4) - # ... and the narrowness correction follows the variance shares. + # ... and a small stratum carrying most of it sets both corrections. level_dominated, df = ci2g.expanded_ci_level(95, [(1e-9, 40), (1.0, 6)]) - assert df == 5 + assert df == pytest.approx(5) assert level_dominated == pytest.approx(_hesterberg_level(6), rel=1e-4) - # Many equal strata, each below the 10% share threshold: still well defined. + # Many equal strata. level, df = ci2g.expanded_ci_level(95, [(1.0, 10)] * 12) - assert df == 9 and level == pytest.approx(_hesterberg_level(10)) + assert df == pytest.approx(12 * 9) and level == pytest.approx(_hesterberg_level(10, df=108)) + + # Whatever the variances, the degrees of freedom lie between those of the + # smallest stratum and the pooled total. + rng = np.random.default_rng(3) + for _ in range(50): + sizes = rng.integers(2, 30, size=rng.integers(2, 5)) + components = list(zip(rng.exponential(1, sizes.size), sizes)) + _, df = ci2g.expanded_ci_level(95, components) + assert sizes.min() - 1 - 1e-9 <= df <= np.sum(sizes - 1) + 1e-9 # Strata of a single cluster carry no information and are ignored. assert ci2g.expanded_ci_level(95, [(1.0, 1), (1.0, 10)])[0] == pytest.approx(_hesterberg_level(10)) @@ -507,7 +520,14 @@ def test_expanded_level_behaviour(): assert ci2g.expanded_ci_level(95, []) == (95, None) # No usable variance information: strata are weighted equally. - assert ci2g.expanded_ci_level(95, [(0.0, 8), (0.0, 6)])[1] == 5 + assert ci2g.expanded_ci_level(95, [(0.0, 8), (0.0, 6)])[1] == pytest.approx(4 / (1 / 7 + 1 / 5)) + + # The smallest group of clusters that carries a real share of the variance, + # used to warn about designs with too few clusters. + assert ci2g.smallest_cluster_group([(1.0, 5), (3.0, 20)]) == 5 + assert ci2g.smallest_cluster_group([(1.0, 40), (1e-9, 3)]) == 40 + assert ci2g.smallest_cluster_group([(1.0, 10)] * 12) == 10 + assert ci2g.smallest_cluster_group([(1.0, 1)]) is None # Extreme expansion is floored so that quantile functions stay finite. level, _ = ci2g.expanded_ci_level(95, [(1.0, 2)]) @@ -613,8 +633,9 @@ def test_expansion_for_unpaired_nested_and_mixed_designs(): first_half = df["ID"] < "P06" nested = df[(first_half & (df["Level"] == "L1")) | (~first_half & (df["Level"] == "L3"))] result = load(nested, idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] - # Two strata of 6: the expansion of a single sample of 6 clusters. - assert result["ci_expanded"] == pytest.approx(_hesterberg_level(6)) + # Two strata of 6: the narrowness correction of 6 clusters, with between 5 and + # 10 degrees of freedom depending on how the variance divides between them. + assert _hesterberg_level(6, df=10) < result["ci_expanded"] < _hesterberg_level(6) # Mixed: a participant measured only in the test group adds a stratum of one, # which cannot be resampled and so does not change the expansion. @@ -740,3 +761,128 @@ def test_expansion_for_every_effect_size_and_plot(clustered): assert clustered.mean_diff.plot(show_baseline_ec=True) is not None plt.close("all") + + +def test_unexpanded_limits_are_reported_alongside_the_expanded_ones(clustered, naive): + expanded = clustered.mean_diff.results + unexpanded = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + + # The unexpanded limits are the limits the interval would have without + # expansion, and lie inside the expanded interval. + for kind in ("bca", "pct", "bec_bca", "bec_pct"): + for side in ("low", "high"): + assert expanded[f"{kind}_{side}_unexpanded"].to_numpy() == pytest.approx( + unexpanded[f"{kind}_{side}"].to_numpy()), (kind, side) + assert (expanded[f"{kind}_low"] <= expanded[f"{kind}_low_unexpanded"]).all() + assert (expanded[f"{kind}_high_unexpanded"] <= expanded[f"{kind}_high"]).all() + + # The same values are available on the effect size object. + control, test = DF["Level"] == "L1", DF["Level"] == "L2" + two_groups = TwoGroupsEffectSize( + DF.loc[control, "Y"].to_numpy(), DF.loc[test, "Y"].to_numpy(), "mean_diff", + is_paired="sequential", resamples=PAIRED_KWARGS["resamples"], permutation_count=10, + control_clusters=DF.loc[control, "ID"].to_numpy(), test_clusters=DF.loc[test, "ID"].to_numpy()) + assert two_groups.bca_low <= two_groups.bca_low_unexpanded < two_groups.bca_high_unexpanded <= two_groups.bca_high + assert two_groups.pct_low <= two_groups.pct_low_unexpanded < two_groups.pct_high_unexpanded <= two_groups.pct_high + + # Nothing to report when the interval is not expanded. + for results in (unexpanded, naive.mean_diff.results): + assert not any("unexpanded" in c for c in results.columns) + + # Delta-delta and mini-meta. + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2_kwargs = dict(x=["Level", "Env"], y="Y", delta2=True, experiment="Env", paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + mini_meta = load(df, idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + for obj in (load(df, **delta2_kwargs).mean_diff.delta_delta, mini_meta.mean_diff.mini_meta): + assert obj.bca_low <= obj.bca_low_unexpanded < obj.bca_high_unexpanded <= obj.bca_high + assert obj.pct_low <= obj.pct_low_unexpanded < obj.pct_high_unexpanded <= obj.pct_high + assert {"bca_low_unexpanded", "pct_high_unexpanded"} <= set(obj.results.columns) + off = load(df, cluster_ci_expansion=False, **delta2_kwargs).mean_diff.delta_delta + assert off.bca_low_unexpanded is None + assert not any("unexpanded" in c for c in off.results.columns) + + +def _ci_segments(ax, horizontal=False): + """(position, low, high, linewidth) of every straight line drawn along the effect size axis.""" + segments = [] + for line in ax.get_lines(): + x = np.asarray(line.get_xdata(), dtype=float) + y = np.asarray(line.get_ydata(), dtype=float) + along, across = (y, x) if horizontal else (x, y) + if len(along) == 2 and along[0] == along[1] and across[0] != across[1]: + segments.append((along[0], across.min(), across.max(), line.get_linewidth())) + return sorted(segments) + + +def test_plots_draw_the_expansion_as_a_thinner_line(clustered, naive): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + results = clustered.mean_diff.results + + # At each contrast a thin line spans the expanded interval, and a thick bar + # the unexpanded interval, which the bootstrap distribution spans. + fig = clustered.mean_diff.plot() + segments = _ci_segments(fig.axes[1]) + for j, row in enumerate(results.itertuples(), start=1): + at_j = [s for s in segments if s[0] == j] + assert len(at_j) == 2 + thin, thick = sorted(at_j, key=lambda s: s[3]) + assert thin[3] < thick[3] + assert (thin[1], thin[2]) == pytest.approx((row.bca_low, row.bca_high)) + assert (thick[1], thick[2]) == pytest.approx((row.bca_low_unexpanded, row.bca_high_unexpanded)) + plt.close("all") + + # The percentile interval, horizontal plots and custom styling of the thin line. + fig = clustered.mean_diff.plot(ci_type="pct", horizontal=True, + contrast_expanded_errorbar_kwargs={"color": "red", "lw": 1.5}) + ax = fig.axes[1] + thin = [line for line in ax.get_lines() if line.get_color() == "red"] + assert thin and all(line.get_linewidth() == 1.5 for line in thin) + thin = sorted(s for s in _ci_segments(ax, horizontal=True) if s[3] == 1.5) + assert [(lo, hi) for _, lo, hi, _ in thin] == pytest.approx(list(zip(results.pct_low, results.pct_high))) + plt.close("all") + + # One whisker per contrast when the interval is not expanded. + opted_out = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS) + for obj in (naive, opted_out): + segments = _ci_segments(obj.mean_diff.plot().axes[1]) + assert len({s[3] for s in segments}) == 1 + assert sorted(s[0] for s in segments) == [1.0, 2.0] + plt.close("all") + + # The baseline error curve and delta-delta are drawn the same way. + fig = clustered.mean_diff.plot(show_baseline_ec=True) + assert len([s for s in _ci_segments(fig.axes[1]) if s[0] == 0]) == 2 + plt.close("all") + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2 = load(df, x=["Level", "Env"], y="Y", delta2=True, experiment="Env", paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + dd = delta2.mean_diff.delta_delta + drawn = [(lo, hi) for _, lo, hi, _ in _ci_segments(delta2.mean_diff.plot().axes[1])] + assert any((lo, hi) == pytest.approx((dd.bca_low, dd.bca_high)) for lo, hi in drawn) + assert any((lo, hi) == pytest.approx((dd.bca_low_unexpanded, dd.bca_high_unexpanded)) for lo, hi in drawn) + plt.close("all") + + +def test_forest_plot_draws_the_expansion_as_a_thinner_line(clustered, naive): + import matplotlib + import matplotlib.pyplot as plt + from dabest import forest_plot + + matplotlib.use("Agg") + results = clustered.mean_diff.results.iloc[0] + for horizontal in (False, True): + fig = forest_plot([clustered, naive], idx=[[0], [0]], labels=["clustered", "naive"], horizontal=horizontal) + segments = _ci_segments(fig.axes[0], horizontal=horizontal) + at_1 = sorted((s for s in segments if s[0] == 1), key=lambda s: s[3]) + assert len(at_1) == 2 + assert (at_1[0][1], at_1[0][2]) == pytest.approx((results.bca_low, results.bca_high)) + assert (at_1[1][1], at_1[1][2]) == pytest.approx((results.bca_low_unexpanded, results.bca_high_unexpanded)) + assert len([s for s in segments if s[0] == 2]) == 1 + plt.close("all") diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index 4e018805..a3921c99 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -827,7 +827,7 @@ "==================\n", " \n", "Good evening!\n", - "The current time is Sun Sep 27 21:38:55 2026.\n", + "The current time is Sun Sep 27 22:55:50 2026.\n", "\n", "The paired mean difference for repeated measures against baseline \n", "between Control and Test 1 is 0.589 [95%CI 0.432, 0.764].\n", @@ -880,7 +880,8 @@ "gives the level at which the bootstrap distribution is read, also reported in\n", "the `ci_expanded` column; see the\n", "[Cluster-Robust Bootstrap tutorial](11-cluster_robust_bootstrap.html#few-clusters-the-small-sample-expansion),\n", - "and pass `cluster_ci_expansion=False` to turn this off). The number of clusters resampled is reported in the\n", + "and pass `cluster_ci_expansion=False` to turn this off). In the plot below, this expansion is the thin\n", + "line that extends each interval beyond its usual thick bar. The number of clusters resampled is reported in the\n", "`n_clusters` column of the results:" ] }, @@ -1019,7 +1020,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index 7af0cc5a..f730c00c 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2210,7 +2210,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB50AAAPdCAYAAAC5rX+kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzsvQfYXFW1/79DL+kFBEIvghQNEKWHoiBN5YooCATEBohyUUGvlwsKiigKgle8XoqiICqKggoiSItUaUoJgqElISGVhNDh/T/r/P7rvWtW9mkzZ/rn8zz7OWfOnDlz6sxe+7vKkIGBgYEAAAAAAAAAAAAAAAAAAABQB8vU8yEAAAAAAAAAAAAAAAAAAABEZwAAAAAAAAAAAAAAAAAAaAginQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAAAAAAAAAAAAAAAAAoG4QnQEAoKfYddddw5AhQwbbTTfd1NTv+/GPf1zzfUcccURTv6+fsOdVGpTnySefrDmH6623HqcRAAAAADoO7LjeATuuMzn11FNrro28BoD/g/E9gGpAdAYAAAAAAAAAAAAAAAAAgLpZrv6PAgAAAAAAAAAAAAAAdC7nnHNOWLhw4eDr448/PowcObKt+wQA0IsgOgMAAAAAAAAAAAAAQM+Kzk899dTgaymNhugMAFA9pNcGAAAAAAAAAAAAAAAAAIC6IdIZAAB6iptuuqnduwAAAAAAAAAlwI4DAAAA6H6IdAYAAAAAAAAAAACAnma99dYLQ4YMSdquu+7a7t0BAADoORCdAQAAAAAAAAAAAAAAAACgbhCdAQAAAAAAAAAAAAAAAACgbqjpDAAAEOHee+8NDz/8cJg5c2by+i1veUvYeuutwxZbbNGV5+uxxx4Lf//738PcuXPD/Pnzw3LLLRdGjRoVNtlkk7DVVluFkSNH1r3t119/Pdx1113hiSeeCM8991x45ZVXwrhx48Iaa6wRdthhh4a23U5eeOGFcNttt4UZM2aEOXPmhGWXXTasttpqYd111w3bbbddWGGFFZryvbNmzUq+V86nnMvRo0cnaeB23nnnsOqqqzblOwEAAAAAegHsuOL0qh3Xa7zxxhvJff2vf/0rseeff/75sMoqq4SxY8eGzTbbLGy55ZZhxRVXDL3Ga6+9Fh555JHw4IMPJse9ePHiZBxDbGK5R9dff/3wtre9Lay00kqhE1iwYEG4/fbbw+zZs5PxA9lXeZ423njjMHHixGQ8oWpeffXVcOedd4apU6eGefPmhTfffDMZszjkkEOSe6SdyL7J78vTTz89eP3k2snYmlw3aXKO6kXGteR8y/iJnG+5D+R8b7TRRmHbbbdtyvkGgIIMAAAA9BCTJk0akL83bTfeeGPhz77xxhsD55133sCGG25Ysw3bNt5444GLL7548DMyb9+fPHnyQKfw9NNPD3zmM58ZWHvttVOPR9oyyywzMHHixIEzzzxzYPbs2YW3/89//nPg0EMPHRgxYkTqtpdddtmBnXfeeeB3v/td6f3322oV119//cC73/3ugRVWWCH1uIYOHTpw4IEHDvz9738vte1TTjmlZjvyWrnrrrsG9tprr4EhQ4ZEv1P258gjjxyYPn164e974oknarax7rrrRtf7+te/XrOePEf18u1vf7tmW9ttt13d2wIAAACA/gA77v/AjmseYg9VYfO0gjvuuCOxObPsbWkrr7xyYkdecsklAy+99FJdtmgMGduw69txkCLIWEw9NuaTTz458KlPfWpg1KhRmcctbfnllx945zvfOXD66adH7WR7vcu2Isf7+uuvJ+uJzStjH2nbGj169MCnP/3pgZkzZ1Ziy8t2jj766GRcIvZ98tl2ce211w7svffeA6usskrm+R0+fPjAAQccMHDllVcOvPbaa4W3/6tf/Wpg++23T8axss63jJ2UPQ+dPL4H0E2QXhsAACCExLN7p512Cscdd1ziQZwVMXzkkUeG97///eHFF1/syHMnHusnnnhi4uH5/e9/PzzzzDOZ64s37N133x1OOumk8OEPfzh3+6IH/8d//Efimfqzn/0s8bTO8sq+9dZbk/O12267Jee5U5Hj2H///cO73/3ucP311yeeuVlR0FdccUV4xzveET7zmc8k57wRzjzzzLD99tuHP/3pT8n5jSH7c/HFFyff+be//S1Uycc//vEa7/ibb7458Sovi+z7//zP/9QsO/rooyvZRwAAAAAAD3YcdlyvIVGbYpdKdi2xObPsbeGll15K7MjDDz88sSu7mQsvvDCJ3habUiKHi0RDSzTtf/7nf4Zf/epXoZWITS5Z42R86I477kjGPrKicn/4wx8mYzRi0zfCH/7wh7DpppuG888/PxmX6BSmTZsWdtxxx/De9743XHPNNbnjZYsWLQpXXnllOOCAA8Kll16au/3p06cnYyYf+tCHkghnGcfKOt9ynt/61reG008/va7jAYD6QXQGAIC+R4y63XffPem4xhgxYsRSqZSvuuqq8JGPfCRVIGwXYpjttdde4dvf/naqaDp8+PAwbNiw6Ht5xyPiqqRqOuOMM6JCqwiXsv0YN910U5KmTYyRTuPZZ59N0lf//ve/j74/dOjQsPLKKy+1XAyd//7v/05EdTH26+FrX/ta+NKXvlRjpEqaKUmrHUsJJampxJCTtF1VISm4xHiziFFcFhHrH3/88cHXcgwHHXRQJfsIAAAAAGDBjvs/+tWO6zWkJJakYk6zS5dZZpnExorZpkKnjU+U4bLLLkucoWN2tdjFku5djn355ZcP7ea3v/1tmDRpUlKSzTNkyJBkDClWGkuE2I997GPhm9/8Zl3fK/a2iLQi2Frk2W1nmvEbb7wxuW+lTFgMuX5y7dLSwOfdt+IQL79BIu7HkOOPlT+TMbGTTz45HHXUUZkiNQBUC6IzAAD0PZMnTw4PPfRQzXnYZpttEk9ZqTuzcOHC8PLLLydimgiEIkAKV1999VJRne1ERMsDDzww/OUvf6lZLgbPV77ylaSDLnW6xFNajBSZl9pQEg0tUchiwObxX//1X+Hyyy+vWSbGn3hUSy0wOU+6/V/+8pfJebRIFPkHPvCB5Ls76byJMPqPf/yjZrl4D19yySWJl6zcB2IgSn3n8847L6lDZPnjH/8YPve5z5X+bvFIP/XUU5N5qbEtXrhiuIpxJDWZ5DzdcsstYc8996z5nLz3hS98IVTJscceW/Najr1sNL94W1uOOOKIjqmxBQAAAAC9BXZcf9txvYY4QosD+VNPPVWzXKJjzz333PDoo48O2olip8m1kgxVX/3qV8MWW2wRuhmJ2P3sZz9bs0xs7m9961vJWI0I0eJgL8cu50AyHIjQKccuYmcaX//61xMbVZqInhaxvfW9WJOo2hgirIrDtrWVxZYXR3KpryzPiIwhyTGJw7iI6W9/+9trtiGZ4yQauOw5OvTQQ5PobkGeR40olmdXzpHUN5bxHR2zagVyfSQyX8ZNLBMmTAgXXHBBePLJJ5N9lmsnvzMy/fOf/5xk55O63HksWbIkcfL3Gfze9a53JZkAZKxGjl+2Lb9T3/jGN5ZyoLnooovqFvoBoA7and8bAACgnbXApO6Rr/8itXakNk8a06ZNS60N1M6aL1/5yleW2p/3vve9A/PmzStco/n8889PfX/KlClL1c3ZYostMusSyXmUutJ+v0444YSOqel8xhlnLPVdhxxyyMDLL7+c+pn58+cP7LDDDkt97qqrrsr8Ll9HS5vU1J41a1bq5958882BI444Yqkaz88991wlNZ2VbbbZpmb9Cy+8cKAoM2bMGFhuueUGPyu1qeWeAgAAAADIAzsOO66fazqLvbfTTjstZSf+x3/8R+F6t3/5y18y7dFOrul8+eWX16y7wQYb5Nq6lvvvv3/gzjvvzFzHj+HUU/dYxlbWXnvtmu3ssccemba8INfwmGOOqfncaqutNrBkyZLCtrytY/3zn/98oBOQ/d94441r9k9qW3//+99P7uk8ZB2p6XzrrbemriP1vf05+OIXvzjwxhtvpH7m6aefXmq/ZKzi3nvvzdwfajoDVAORzgAA0NeI56tFPIt/8IMfRNMaK+KNKRGqnRTBKR6tZ511Vs0yScEs0djeozeNjTfeOHz605/OPFc2JdHYsWMTD9U11lgj9TNyHsUrW1JAWcRzWLx+2414A/vzJmmyfvKTn6SmflJPZoluXm+99WqWn3baaaX3Ye211w7XXnttWH311VPXkRRd4rFs1xEP79/97nehmdHOZVJsixezTdW3xx57JPcUAAAAAEDVYMf1tx3Xa0i65ilTpiwViSvXTkovFUGi3iXitBuRDGwWiYIdN25c4c9LJPE73/nO0Gy++93v1kTcSjS0pELPsuUFuYZiz7/vfe8bXCbR2hKBW5azzz47KfXWCUjmv8cee6xmmYylyLiCjGHkIetIxPZOO+0UfV8yzUmdb4tEe0sEfFaGBxljkVTkNuJZxiokChoAmg+iMwAA9C2SjklSVHlDoEjn+K1vfWvl6Y0bQQwPm+pMRFHp7Bc1UPOQ1OIijFokPZFPM50lmK6yyio1Yu///u//hnYjqa4kvZMdXBHDqch5k7Tl55xzTs2yu+++O7U2eBqS0q6IY4DUhProRz9as+yee+4JVXLwwQeHMWPG1BxPke+QFOX+eh599NGV7hsAAAAAgIAdV5xeteN6DZ/6V0S4L3/5y6FfkNTZliJpl1uNpLeWAAU7diCO10WDEeR5+s53vlMT4PCjH/2o1D5sueWW4ZhjjgmdgKTMluOxSN14P2bRCOIEbx3bpSSAH4NJY5111knK41muvPLKpdJ0A0D1IDoDAEDfctVVV9W8lrq5Ui+pKOJNXqR+ViuQWjaWT3ziE2G11VarbPtSK+j/Zbz+f4hIKh6mRVlzzTWTukcWiRRuN34fJNJdHAqKIp7KPtq5zHGJwOvPSxY77rhjzeupU6eGKhGD+aijjsqs0xxDvLunT59ec72tFzcAAAAAQFVgxxWnV+24XkJEsLvuumupmr+dMtbQCkRMtPztb38LnYZku7PiuGT2etvb3lZqGzLetO222w6+fvDBB5eqhZyFjPMUCZJoBXfccUcSiWz5yle+Uul3+N8aEbWtk3weMrYhzvvWWf66666rdB8BYGmqCX8CAADoQu68886a1+9///tLfX6ttdYKEydOXGo77TBSp02bVrOszEBCEW677baa1/vuu29m+ukYBx54YBJ9bQ1JSRG9wgorhHbhj+uDH/xgqc+LwSefsR6+fpt5InKZaPQNNtig5vXChQtD1UiEsqQc1xR8l19+eXJ8EtmdhhemP/7xj1cWZQ8AAAAAYMGOK06v2nH1lAMSFi9ePDg/c+bMUp8fNmxYpVGcyk033VTzWkQ1KZXVT/jU2JJWfJNNNknuvU7h5ptvrnm9995717WdrbfeevA3TBxCRLzdZ599CqdQ7xT8fSvHVVaEz2LJkiXh73//e0PjNUOHDk2epV//+tc1v4ne0R4AqoXRQAAA6FseeOCBpTrJjRgMnVL/SOrWbL755pV+h+/sW+/covjPvPzyy0n9n6r3tShz5sxJamFXfVz+XGXho6SLDHRYFi1aFKpG9kkGo6QeuBp7l1xySTjuuOOi6z/xxBM13sKSLkw8sAEAAAAAmgF2XH/bcVWV9JFjKPP5ddddtymis7fnpU5wp0Sztor99tsvcerXyNkXX3wxibAXEfPDH/5wIhzK2Es7HZtFHPb3T1mnB7WfLc8++2yhz8mxb7bZZqFT8PftDjvsUOn2H3744ZrU2vJMbLPNNnX9flnRucx4DQDUB6IzAAD0JWIoiyHjjciylBUNmyWe+vpHVafi8imf6qmxJHXDJH2znPu07baS2HfXc1z+M5JySzyWiwwU+DRiedj6T5oeqhkce+yxg6KzIHWu00Rnec+m7JMBg/HjxzdlvwAAAACgv8GOK0cv2nG9hrfnN9xww9BvyP3105/+NIkefuWVV2qEx1NOOSVpkiZZBESpd73rrruGXXbZpaXR9rNnz655bes7N0LRZ0kyj/nxgF6+b/15GTVqVGb2tTT8bx6/XQDNp3+KQwAAAOSkJZYI4bLU0+mtmnnz5jUkZBbB1i6q91zFzlc7O/z+mESol/RLjR6TCMFFI5A71YNd6ptLOjPloYceCrfccstS60lavYsuuqiyaAMAAAAAgCyw48rRi3Zcr9EKe74bkNTRf/3rX8OECROi70sGLklxLam33/Oe94TVV189fOpTnwr/+te/WrJ/zbrnfTBEGvWMVXTzfctvF0D3gugMAAAAAEuJ4cccc0xm3WZB0lRZD2fxbhbBGgAAAAAAoNlIxqUyzWY3mzRpUqnPPvnkk1zQJiPpk++5555w7bXXhkMPPTQRlrMcUH70ox+FTTfdNJx++uk12beagThcN4Nm7zcAQKtBdAYAgL4k5oVZT33c559/PrSbMWPG5Hr/N4qkMqqilrA/X6NHjw7twh/Tm2++GV544YWGj0lSXtUbQdBJHHHEEUkKM+U3v/nNUim0fA0r8TTv1OhtAAAAAOh+sOPK0Yt2XK/RCnu+HYh9XQ9iT+61115Juu1Zs2aFRx55JBGXDz/88Gh6eKn7e/LJJyetmfh7/o9//GNpp4dYO/XUU0M30uz7lt8ugO4F0RkAAPoSqRm0yiqr1Cx76qmnSm+nE7ydx40bV/P6iSeeqNvAK2pQ1HPcYjDaOmDtHqzwx1Tvccn59sZRLwivkkJPvMutZ/eFF15YU1/LptxeccUVw5FHHtny/QQAAACA/gE7rhy9aMf1Gt6ef/zxx0Mn4OsHSxmpMlQlQkok8yc+8Ynwk5/8JEybNi2xQ0866aQaB2nhm9/8Znj00UdDq66TTy/dbzT7vvW/XZJuu56gDz9ew28XQPNBdAYAgL7l7W9/e83re++9t/Q26vlMM1JQee/1Bx98sNLv2HLLLWte/+1vfyu9Df8ZGTCydYNbzdixY8Maa6xR+XFttdVWoVc49thja16Lh7k6NPgo5wMPPDA5pwAAAAAAzQQ7rr/tuF7D2/N33HFHR6Rc9jWEy2YFq8epvwibbbZZIjDLWIzNfCCi+OWXXx6axTve8Y6a1/fdd1/oZ/x9e9ttt1V+nZdbbrnB1/JM1DP+1svjNQCdCqIzAAD0Le9617tqXv/ud78r9fkZM2aEu+++O7Sb8ePHJ7V0LT/72c8q/Y4ddtih5vUf/vCH0jWNpP6vZdtttw3LL798aCfbb799zesrr7yy1OfF8JG001nnqpuRQapddtmlxkv4T3/6U3jxxRfDJZdcUrPu0Ucf3YY9BAAAAIB+AzuuOL1qx/USu+6661IRtNdcc03otFT2PmI0j5tvvjk0E3F8kPJOlr///e+p61sBs57I7fe85z01r+UadYJzQKfctyLCSxR6VUgkuxeIy47XLFmyJBm/6NXxGoBOBdEZAAD6lv3337/m9XXXXVcqJZBEeladxrpeDjrooJrXF1xwQXjuuecq2/7ee+9dkzJaDOGf//znhT//7LPPhl/96lc1y/bdd9/Qbvw+iOH4r3/9q/Dnf//73y9lfHfCcVXJZz7zmZrX559/fnLtbWorEad33HHHNuwdAAAAAPQb2HHF6VU7rpcQJ3LvDH3GGWe0XdCUtNaWv/71r4U/O3369KTmcbPxNZ5FZExj2LBhNa/LpmqWZ8mWaJNa07/97W9Dv7LddtuFtddeu2bZ17/+9Uq/w//WXHrppUma7aJcdNFFNRH6kjJe6oUDQHNBdAYAgL5lt912CxtvvPHg69dffz0R2IoYd//85z/DWWedFTqFz33uc0maM0U64pMnT06OqQo22mijxMiySB2luXPnFvr8Zz/72RoDcOWVV07qMrWbgw8+uKZWkJwvidgt4kwgaczlvFsmTpyYGF+9xAEHHBDWXHPNwdcyeHDmmWfWrPPpT3+6DXsGAAAAAP0IdlxxetWO6zW+9KUv1byeMmVK+MY3vhHayTvf+c6l0hQ/8MADhT57zDHHhNdee63wd9U7biHCr+Utb3lL6rr+Pf/ZPKSUlByXRcYOGkkj3m7HgkaQyPEvfOELNcsuu+yyRBiuChlnsFkV5s+fv9R3Zjk+/Nd//VfNsn/7t39LnDwAoLkgOgMAQN8iHt9f+cpXapZJ6h2pY5uVakkiW8U78uWXXw6dwuqrrx6++MUv1iy79tprw/ve977CnqCPPfbYUnV6LXKullnm/7oOs2fPDnvuuWeYM2dO6mfkPB5//PHhiiuuqFkuxpoVe9uFDJp4o+XPf/5z+PjHP55pJC9cuDDxuvVRzt6o6QXEmLRpy+Sayr1ia30ddthhbdo7AAAAAOg3sONq6Uc7rhej9ydNmlSz7D//8z/DySefXFiQvemmm8LVV19d2T5JCS9fx1js5MWLF6d+RvZVbMey+yGpq0888cRSAq6I4P/7v/+7lENKGhMmTKh5/aMf/aiUMK4OG9YhW56lnXfeOdx6662ltiNpqEWw9s4G3YY4oLz1rW+tWSbBDz/4wQ8KCeqyjpS5EyeLGHKuP/axjy0VvSzjLlnbl1J4ck/JuI0d1/jyl79c4KgAoFEQnQEAoK+RDrGvzSPpg6VOmNSusl7d06ZNC6effnpSV+bJJ59MlnVSVOspp5wSdt9996XSRW+wwQaJsSr1p61RJfP3339/YhDsscceSfqsyy+/PHX7UvtGjCxft2ezzTYL3/nOd8LTTz89uFxSGMn5kzRh3/ve92o+I6mYq0671Agi1u+00041yy6++OKw9dZbJ1661lCR9HJyvt72trctZRh98pOfDPvtt1/oReTY0uq2ffSjH10qVRkAAAAAQDPBjsOO6zVHCrHFfTSujD+I7fn9738/cS6wGblE/BWx82tf+1piY4vges8991S6X8cdd9xSQq+MgfzmN78JL7744uDyWbNmJTa0jJWImFu2dq44yn/7299O0mXLWIxEeV9//fVLReSL4/9dd90VPv/5z4dddtmlZh/WWmut8MEPfjD1O8Qh33LLLbck5/bf//3fwznnnJM4btj26KOPRqOdpa6wzTL3zDPPJA4DklFAUtfLuIgVROWaiZguQvx//Md/hM033zxp8h1Z6cC7AXHil3Efqb9sHVYkkENqv4tALOfHng+JVr7hhhsSwV0yMXzgAx/ILHMnY002Q6Fw2mmnJWK/pDe394AEBXzzm99Mzu/UqVNrPiPPiXc8AIAmMQAAANBDTJo0SXqzg+3GG2/M/czs2bMHNttss5rP2TZixIiBFVdccanl73//+wcuuuiimmWTJ08eaCfz588f2HXXXVOPRY9n+PDh0ffk/GXx2muvDXz4wx9O3bacJ9l+2vsbbLDBwOOPP17oWPxnm8nMmTMHtthii9T9HjZs2MDKK6+c+v7ee+898OKLL+Z+zymnnFLzOXldhieeeKLm8+uuu26l62fxkY98JHrs9913X93bBAAAAAAQsOOw41qB2ENFbd928MADDwysvfbaqXbnMsssMzB69OiBVVZZJfp+ln1Zjy365ptvpo4vDBkyZGDUqFFRO3nPPfcc+POf/1x4rOHtb3976jEvt9xyA2PGjBkYOXJkcvyxdVZaaaWBG264Ifd49thjj8yxEtsuvvji1O386U9/So497bPLLrtscp1kHEHOU9p6xx57bEts+WYj516uT941lOtU9lwLDz/88MD48eNLj9lp+9jHPjbwxhtv5B6H7Ecnje8BdCtEOgMAQN+z2mqrhRtvvHGpmkXK888/H1555ZWaZe9///uTejXikdxJjBo1Klx33XVJ7S1JH5R2PFKPOIZNuxZDtineu5KWKLZ9OU+y/Rji/Xv77bcnabo6jTXWWCOJXE6LVBYv8pdeeil6viTF3FVXXZV4+fYyUu/cI17uPuUaAAAAAEArwI77P/rVjus1JFJYInl9NjYbNSuRoja6s8x9UBYZ75AU67GxEvETlwhlbydL3VyJBk4bj0j7nqyU3fPmzUsykNlIb2WdddZJSmT5rG8xZAxHIqQbRdLTS1R52rYk2leuk4wjpKWBlmhpyTbXC8i5v/POO5Po5qxrmFaiLu++lex68huUlmkwNmYnrLDCCkmE84UXXlj5swEA6fC0AQAA/P81kaUTe+655yYpndKQtD6SNkrS+Kyyyiodee4kDbKktH7kkUfCUUcdFcaNG5e5/rLLLpukvpLPSJqsIgahpLt66KGHwqGHHhpGjBiRuW1JXS3nS2pMycBQpyLHISmvJI2XpBtPSyetdYwPPPDAJL34f//3f5cyqLsVSZU+fPjwmmVShwoAAAAAoF1gx2HH9RqSYlscycUxft99980dd5DUxlIT+pe//GVTatZKDW+x5WUMIKuet9T2/elPf5qkWy47ViLHKoLwYYcdFtZbb71Cn3n729+epF6WNNi+XFaeo4qcX6k9PXHixGS8xKbLLoqMG918883JuZEU0d5WTgsSOOCAA5Ja1JKSPObY3a1ssskmSUk3GVPaddddE8E371x8+MMfTkrCyXXPY/z48cmYndznMjaRJSLLto888sgkxbaUmgOA1jJEwp1b/J0AAAAdj3itiqgqNXw1ElZq/G6xxRah25C/+gceeCAxxubMmZN4CEtUrnTExTCQ+k9ZwnEe4rUq3thS8/q5554Lr776alLraM0110zE7JEjR4ZuROpS//Wvfw0zZsxIzpsI6GKkrrvuuomRk2dE9RrXXnttUqdKGT16dHJu6jHQAQAAAACaAXZccXrVjus1JIJTokilLrDUOJY6wOIELQ4XIvTKGEWrbFOJ4BVh8cEHH0wiV2WsQURyiXCtcqxE7kcRDKVGr3yPRHavuOKKibArorQIzr7+dbuRcyNO6VKfWCOzZZ+HDRuWCKYS1SxCdb9E3Mp9KiKxjqfI74vctzK2JpHL0mSMpV4kkvy2225LxHt5LuRciwOB1IkWZ4JGtg0AjYHoDAAAAAC5iPf27373u8HXJ5xwQuJZDgAAAAAAAAAAAIDoDAAAAACZPPnkk4nHsHhva4r1f/7zn8kyAAAAAAAAAAAAgP7I5wAAAAAAdfO1r31tUHAW9tlnHwRnAAAAAAAAAAAAGIRIZwAAAABI5de//nX40Ic+lNTrUqZMmRJ23HFHzhoAAAAAAAAAAAAkLPf/JgAAAADQ7/ztb39LmjBnzpxw++23h2uuuaZmnf333x/BGQAAAAAAAAAAAGpAdAYAAACAhN///vfhq1/9aurZGDFiRPjv//5vzhYAAAAAAAAAAADUgOgMAADQRK666qowc+bMpmx7t912C29961ubsm0Az6hRo5L7ee211+bkAAAAAEBPgx0HAN3I4sWLw6WXXtq07X/6059u2rYBoDdAdAYAAGgi3/3ud8PNN9/clG1ffPHFiM7QVIYOHRo22mijsM8++4TjjjsuvOUtb+GMAwAAAEDPgx0HAN3IvHnzwtFHH9207SM6A0AeiM4AAAAAkHDqqacmDQAAAAAAAAAAAKAMy5RaGwAAAAAAAAAAAAAAAAAAwDBkYGBgwC4AAAAAAAAAAAAAAAAAAAAoCpHOAAAAAAAAAABdwKuvvhouuOCCsNdee4U11lgjrLjiimHo0KHhrW99azjyyCPDbbfd1u5dBAAAAACAPoVIZ2iLkXzJJZeEX/3qV+Hvf/97mD9/flh++eXDWmutFXbYYYfwiU98IpkCAAAAAAAAwP/jqaeeCvvuu2946KGHMk/JcccdF773ve+FIUOGcOoAAAAAAKBlIDpDS8FIBgAAAAAAACjHa6+9FiZMmDAoOG+11VbhhBNOSCKcFy9eHKZMmRK+853vhCVLliTvn3HGGeFLX/oSpxkAAAAAAFoGojO0DIxkAAAAAAAAgPJcccUV4UMf+lAyv/3224dbb701LLvssjXr3HPPPcl7YnuPHDkyzJkzJyy33HKcbgAAAAAAaAmIztBXRvJ3v/vdsGjRojB8+PDEKxwAAAAAAACg0xH79eyzz07mr7rqqrD//vtH1/u3f/u3cOWVVybzUs5qyy23rGwfsKcBAAAAACALXF6hZdx2222D81/+8peXEpyFbbbZJuy3336Jkbxw4cLwyCOPVG4kz5gxI6kfjegMAAAAAAAA3cCrr746OL/BBhukrrfhhhtGP1MF2NMAAAAAAJDFMpnvAvSYkQwAAAAAAADQbUjtZmXatGmp6/3rX/9KpkOGDAkbb7xxS/YNAAAAAABAQHSGloGRDAAAAAAAAFCegw8+OCkTJZx55pnhjTfeWGqd++67L/zhD39I5g855JDB9QEAAAAAAFoBNZ2hZcydOzeJYpaayjvuuGO4+eabl0qxLUbydtttl0Q4f/SjHw0/+9nPCm9/+vTpuetMnDgxzJo1K0mvXWR9AAAAAAAAgE5AajmL+Pziiy+GCRMmhOOPPz5ssskm4YUXXgh//etfw3e+852wePHisPXWW4c//vGPYfXVVy+8bexpAAAAAABoFERn6BkjWdKHFQXRGQAAAAAAALqNqVOnJnbzhRdeGAYGBmreE/v5y1/+cvjEJz4RVllllVLbxZ4GAAAAAIBGWa7hLQCU4H3ve1+45557Bo3kyZMnL2Ukn3baaXUZyQAAAAAAAAC9imQEu+SSS8Lvfve7pQRnYfbs2Um2sPXXXz+xvQEAAAAAAFoJojP0jJH8zDPPFE6vDQAAAAAAANAtLFmyJOy9997h1ltvTcpUnXjiieHII48MG2ywQXj55ZfDnXfeGb72ta+FKVOmhA984APhrLPOCieccELh7WNPAwAAAABAo5BeG9pmJH/+859PNZIltVdZI7kI48ePDzNmzCC9NgAAAAAAAHQNX/ziFxMbWfjxj3+8VNYw4fXXXw977rlnuPHGG8MyyywT7r333vD2t7+9sn3AngYAAAAAgCyWyXwXoEJOPfXURHAWJLX2mWeeGTbddNOwwgorhOHDh4f3vOc9iXG82267JVHQYlQ/8MADXAMAAAAAAADoW8Q+vuiii5L5TTbZJCo4C8stt1xSrkp48803E3EaAAAAAACgVSA6Q0vASAYAAAAAAAAoj5Shmj9/fjI/YcKEzHW32WabwfmpU6dyugEAAAAAoGUgOkNLwEgGAAAAAAAAKI9EMNsU2lm89tpr0c8BAAAAAAA0GywQaAkYyQAAAAAAAADlGT16dFKSatGiReH2229PhOc0Qfnmm28enF9//fU53QAAAND2DKjSd/FtzJgxYZlliIkE6DUQnaElYCQDAABALyG1MsV4XnbZZdu9KwAA0OPIgOy+++4bfv7zn4eZM2eGr3/96+GUU05Zar0FCxaEk046afD1fvvt1+I9BQAAgF63g2MC8htvvBFdLk0+E0Mc6lZcccWWHwMANBdEZ2gJGMkAAADQDcazpCW1BnLaa1lfPLPXW2+9du86AAD0Af/1X/8Vfve734UXX3wxnHrqqeGee+4JkydPDhtssEF4+eWXwx133BHOOeec8PTTTyfr77HHHmHPPfds924DAABAhxITirPEY2nieF0Vsj1EZ4DeY8hAlb8UABlMnTo1bLPNNomRLOy///65RvL1119f6TkdP358mDFjRlhrrbXC9OnTuV4AAAA9iojCRQXkLO/rLMQze+ONN27K/gMAAHjEPj744IPD3LlzM0/O7rvvHq644oowatSoSk8i9jQAAEDnIfKOFYvzhGN9v5my0JAhQ5KsYFIOJNbkvZEjR6aWCwGA7gXRGVoKRjIAAADUgzec8wTlekTkIqiRvPzyy4dVV101cWQDAABoFfPmzQsXXnhhuOaaa8JDDz0UFi5cmPwvveUtbwkTJ04MhxxySHjf+96XDPZWDaIzAABA6+ofFxWPpTUT6VNkicdpywGgP0F0hpaDkQwAAADWQC4SkdwsL2wVkK2BnPZaDOdmDOIDAAB0A4jOAAAAxRFH6DLCsb5udgnMosKxNvkMAEBREJ2hr8BIBgAAaA5qLBdNad0METnmgZ0nKAMAAEAxsKcBAKCfBeQy4nEzs28pXizOE4/lfQRkAGg2jLQBAAAAwFKI0VymJnIrROQ8ARkRGQAAAAAAALJIiz7OikpuZv1joYxwrPNk4QKATgTRGQAAAKAP8EZznqDcbBG5SEpr6kABAAAAAABADLFZY0Jxlngs7zVTQFabt4x4TBknAOglEJ0BAAAAupAyAnKzReQyNZEBAAAAAAAALGKvFhWO7fvNJFa+KS+dNTYvAPQ7iM4AAAAAHeShXSSldbO8s8WoLiogY1ADAAAAAABAVv3jouKxTJuJ1DIuIx5Lo/4xAEB5EJ0BAAAAmiQil6mJ3ArDOk9QxisbAAAAAAAAFLFriwrH2kR0biZpEcZZojICMgBAa0B0BgAAACiZ6qtIRHKzReQiEckY1gAAAAAAACCUFY+bVabJUlQ4pv4xAEB3gOgMAAAAod9F5CI1kZspIucJyIjIAAAAAAAAoPZsmoCcJSy3qv5xnnhs3wcAgN6CX3YAAADoKRG5aE3kZonIaYJx7DWRyAAAAAAAAP1LLKtWnnjcivrHRaOOKdUEAAAWRGcAAADoWMO7aE3kVorIWa8RkQEAAAAAAPoTqWVcVDjW91shIBcVjrFrAQCgURCdAQAAoCUiclEBuZkisjeo8wRlRGQAAAAAAID+wwrGRWshi+jcTNKij7OikiXtNQAAQKtAdAYAAICGPbjzBOVWiMhFIpIxuAEAAAAAAPqLMsKxNnGcbiZlxWN5D3sWAAA6HURnAAAAqBGRi0QkN8uDW43soimtMboBAAAAAAD6AxGCy4rH0pqJ2KRFhWP7PgAAQC/CPxwAAEAPi8hFU1o3U0QuUxMZERkAAAAAAKA/BOQywnEzM2jF6h8XFY9lCgAAAP8PRGcAAIAuQEThMjWRmyUie0M7T1BGRAYAAAAAAOiv8ktFaiG3ov5xUeFYm4jOAAAAUD+IzgAAAG3AG995gnIrROQ8ARkRGQAAAAAAoL9s1SLprFshIJcRj7FdAQAA2gOiMwAAQAVYQ7xIRLKkEmsGRQVkeS2GOZHIAAAAAAAAvUlZ8VimzbJVBbE/0wTkrOXYrQAAAN0BojMAAEAENbjzBORWiMhFayJjjAMAAAAAAPRu/eOiwrG2ZiJCcBnxmPrHAAAAvQ+iMwAA9AVifKcJxrHXzRCRY0Z5nqAMAAAAAAAAvYOkos4Sj2PvybJmIrWMiwrH+r40AAAAAAuj2QAA0JXEjPOsqORWiMhFaiIDAAAAAABA7wjIZcRjaa2sf1y0FrKIzgAAAACNwug3AAB0BGUE5FaIyEVrIgMAAAAAAED3kxZhnJXOupn1j4UywrE26h8DAABAu0B0BgCAplBGQG62iFymJjIAAAAAAAB0L2JberG4SC3kZgrIYpuWFY/lNQIyAAAAdBOIzgAAUMpozxOQ9XUzEIO7qICMiAwAAAAAAND9tmgZ4Vjnm4kvs1SkFjIOzgAAANAPIDoDAPSxiFxUQG6ViByrgYyIDAAAAAAA0Dv1j8uIxzLfTKSWcRnxmPrHAAAAAOkgOgMA9Jj3d9GU1q0w2POikvH2BgAAAAAA6H2eeuqpMHfu3KZ+Ryw9dV46a7FhAQAAAKAaEJ0BALpARC5SE7nZInKRtNYY7AAAAAAAAOAp63BcVjyWKfWPAQAAANoLojMAQItF5CIprZuVQkxF5KJ1kRGRAQAAAAAAoFFWWmmlMHTo0EK1kGUeARkAAACg+0B0BgBoQEQuWhO5mSJyUQEZERkAAAAAAADawdixY5MGAAAAAL0LojMAQEFEPJ46dWpTRWSfNixPUCYSGQAAAAAAAAAAAAAA2g2iMwBAQUTgfeWVV+oWkfMEZERkAAAAAAAAAAAAAADoRhCdAQBKiM4rrLBCUluqaEpr6lABAAAAAAAAAABAL5chlPbmm2/WNL/Mvh4zZkwSrAMAvQWiMwBACbbcckvOFwAAAAAAAAAAAHQkeYJv1ctkvizDhw9HdAboQRCdAQAAAAAAAAAAAAAA2hQFXOWyIvujrewyKzI3sq2NNtoorLTSStxvAD0GojMAAAAAAAAAAAAAAPQ89Qi5b7zxxmDzr+2y2FS3U4VQ2+iyRtEyglKCUJq81qmd98ti65BaG6A3QXQGAAAAAAAAAAAAAIBK8KJnWvMirRdyY4KvXSbbiAm/aeKvzMf2L2tZJxMTe6UVEYbr/VxVIDoD9CaIzgAAAADQd+R5tBdpq6yySlh99dXbfSgAAAAAANBHQm0zW5q4myfk+mXWzrICs1/W6aJuGVSczYr4LRoFXFQYjn13pzc9nuWWQ5oC6EV4sgEAAACgY0gTeOsVhtNaVfuK6AwAAAAA0D7aLdJW2WLHlifa+vTNeWKv2kJpwnAvUUS0lWhbP19kmV+u03oF2EYaAEAngegMAAAAALnkibhVicJFiA3OlKmTpd+TtU7WQJDOv/TSS2HDDTfk7gEAAACArqKXhdpmUkS0rUIYbtfxFUFFzpjwmbVMBduYcGtfFxF305b51wi1AACtB9EZAAAAoIspKuZ6UdjXy/J1sHzLE3P1O1oh+Fbh3Z6XsqzIslGjRlV4JQEAAACgk2m3uNqtQm2zyBJtiwrDZT9XL0VFWV1m7ZS8z9W7zAqzWYKvX+5to6LLiMgFAOgPEJ0BAAAAGsAO3tgBiTRRN635z8TE31i9rHrF3HaTJvbGBiyEMmJwqwY3ZPAFAAAAAPLxkZ7d2KDcNW40Clib9Oe9bVNF1G0zBd2yqY9jdky94m7RZQAAAM0A0RkAAADaTt4AT9EBqiLriVj7+uuvLyXsps17UdgLvzHv+G4elKo38rcKMbie2lbtWo/BGgAAAIDiTJ8+PcyZM4dT1kS80BkTba2dkrcs5sAaW0eXVy3ytpNmC75+WSccMwAAQBUgOgMAAPQQVQu0zVgvtm5aCrMyy2Ke8v0qBsdqXOl7yy23XGo9LJ1vl5gLAAAAAL1Jp/b1ijobNtryhFy/zK9XpJSNL61jt2uPNzbfycRsn2aLwAAAAFAfiM4AAACOThNpy4i5zaBRMTgrnVoni8Fpomhsua91lSbqpom+sdpZup4Xg/PEXAAAAACATmPllVcOI0aMaJnIm+foGLNPvGhbdJlmQcpap5doluBLFDAAAED3g+gMAABNod6I105Yr1uoSgxOE4WrGCDJEmpVYE1bR/DpxtJE4Fi6Ni/i+pb1nhWB8YQHAAAAAGiMsWPHJi1GGcFXBd5GhOJeoqhwSxQwAAAAtAJEZwCADqfZkbHNEnP7marFYB0Y0fNqz28RL/7YMomirVfMjX1O1ktbxxMbCKmq+dRrAAAAAADQfmbNmhXmzZu3lAjca7Zjs9M++9fYPAAAANBJIDoDABREjOG5c+e2XMiFavCCrT23/nz7ayCGfFERv0gqZhF8i4q5rRxIaKYYzMAIAAAAAED/8tprr4WXX365pd9ZdYRvEREYAAAAoJ9BdAYAKIgIik8//XTfn68iNbKs13Xeevb8pom/sffTBPo0Id+Kud0GYjAAAAAAAHQzsfI1zawHTBQwAAAAQOtBdAYAKEjVYmW9Im2r1lO86OvrYTXaujmaO20AhMhgAAAAAACA/2PNNddMGgAAAAD0LojOAAAFEXFxvfXWq0z0rZdY/d+s9sYbb/SlGJznGV9FAwAAAAAAAAAAAAAARGcAgFKMGTMm9T0vAsvregXffhGDmyUKAwAAAAAAAAAAAABA6yDSGQCgICIg/+tf/+orMbhqYRgAAAAAAAAAAAAAAHoPRGcAgIKI6Lp48eKWnq8ygm4jojAAAAAAAAAAAAAAAEC9IDoDABTEirP1irtlhWEAAAAAAAAAAAAAAIBOB9EZAKAEEyZMQAwGAAAAAAAAAAAAAAAwEEYHAFACoo8BAAAAAAAAAAAAAABqQXQGAAAAAAAAAAAAAAAAAIC6Ib02AAAAAAAAAEAX8fTTT4cLL7ww/OEPfwhPPfVUWLx4cRg3blxYb731wm677RYOOuigsMUWW7R7NwEAAAAAoI9AdAYAAAAAAAAA6BLOO++88OUvfzksWbKkZvn06dOTNmXKlLBo0aJwzjnntG0fAQAAAACg/0B0BgAAAAAAAADoAk4//fRw8sknJ/ObbLJJ+MQnPhEmTpwYRowYEebNmxfuu+++cOWVV4ZllqGaGgAAAAAAtJYhAwMDAy3+ToC2MX78+DBjxoyw1lprJR7gAAAAAAAAAN3ADTfcEN797ncn84cffni44IILwvLLLx9d99VXXw0rrLBCpd+PPQ0AAAAAAFkQ6QwAAAAAAAAA0MG8+eab4eijj07m3/72tyf1nJdbLn1Ip2rBGQAAAAAAIA/yLQEAAAAAAAAAdDDXXXddeOyxx5L5k046KVNwBgAAAAAAaAeIzgAAAAAAAAAAHcyvfvWrZDpkyJCw3377DS6fP39+IkbLFAAAAAAAoJ0gOgMAAAAAAAAAdDB33HFHMl1vvfXCsGHDwmWXXRa23HLLMGbMmLDJJpsk07e+9a3hrLPOCq+88kq7dxcAAAAAAPoQ8jFB23j66aeTOlR/+MMfwlNPPRUWL14cxo0blxjRu+22WzjooIPCFltswRUCAAAAAACAvq7nPHXq1GR+7Nix4XOf+1w499xzl1rvn//8Z/jiF78YrrzyysTOHjlyZOHvmD59eu46b7zxRsk9BwAAAACAfmLIwMDAQLt3AvqP8847L3z5y18OS5YsSV1HDOlzzjmn0u8dP358mDFjRlhrrbUKGdUAAAAAAAAA7WTBggVh9OjRyfxKK60UXn755bDGGmuEb3/722GfffZJlt19991JrWeNiD7ggAPCb37zm8LfIWm7i4I9DQAAAAAAMYh0hpZz+umnh5NPPjmZlzRgn/jEJ8LEiRPDiBEjwrx588J9992XeGYvswzZ3wEAAAAAAKC/sc7aIjivssoq4cYbb0zSaSu77LJL+Mtf/hK233778MADDyQ29Z133hne9a53tWmvAQAAAACg30B0hpZyww03DArOhx9+eLjgggvC8ssvX7POHnvsEb7whS+EV199lasDAAAAAAAAfY1EMls+/vGP1wjOysorrxy+/vWvh/322y95/Ytf/KKw6PzMM8/kriPO4rNmzSq83wAAAAAA0F8gOkNL61AdffTRyfzb3/72pJ7zcsul34IrrLACVwcAAAAAAAD6mmHDhtW83nPPPVPXFSdusbNff/31JOV2mVJUeSy77LKFtwcAAAAAAP0H+YuhZVx33XXhscceS+al1lSW4AwAAAAAAAAAIay44oph3Lhxg6di7bXXzoyKHjt2bDI/Z84cTh8AAAAAALQMRGdoGb/61a+S6ZAhQwbTfQnz589PxGiZAgAAAAAAAEAtm2+++eD8G2+8kXl69H0cvQEAAAAAoJUgOkPLuOOOO5Lpeuutl6QHu+yyy8KWW24ZxowZEzbZZJNkKnWpzjrrrPDKK69wZQAAAAAAAABCCLvsssvgeZg2bVrqOVm0aFGYO3duMr/WWmtx7gAAAAAAoGUgOkPL6jlPnTo1mZdUX5/73OfCRz/60fDggw/WrPfPf/4zfPGLXwy77757WLhwYanvmD59em7L8wgHAAAAAAAA6DQ++MEPDs5feeWVqevJewMDA8n8zjvv3JJ9AwAAAAAAEIYMqDUC0EQWLFgQRo8ePVhj6uWXXw5rrLFG+Pa3vx322WefZNndd9+d1HrWiOgDDjgg/OY3vyn8HZK2uyji8S0iNAAAAAAAAEA3ILbzNddcE5ZZZplw3XXXhT322KPm/VmzZoWJEycmtu4KK6yQRERXGe08fvz4MGPGDOxpAAAAAACIgugMLUGM3rXXXnvw9SqrrBLuvffeJJ225aWXXgrbb799eOCBB5LXIkC/613vKvQdiM4AAAAAAADQq0hmMLGPJSuYOG4ff/zxiRC98sorh7vuuiucccYZg87VZ555ZjjxxBMr/X5EZwAAAAAAyGK5zHcBKkIMYsvHP/7xpQRnQYzlr3/962G//fZLXv/iF78oLDo/88wzueuI17d4fwMAAAAAAAB0E5tsskm4+uqrw4EHHhhmz54dvvnNbybNO2N/5StfqVxwBgAAAAAAyAPRGVrCsGHDal7vueeeqetKirDlllsuvP7660nK7TJe13ksu+yyhbcHAAAAAAAA0EnstNNO4aGHHgrnnXde+O1vfxueeOKJ8Oqrryblq3bddddw3HHHhQkTJrR7NwEAAAAAoA9BdIaWsOKKK4Zx48aFOXPmJK9tqu1YVPTYsWOTiGRdHwAAAAAAAABCGDNmTDj11FOTBgAAAAAA0Cks0+4dgP5h8803H5x/4403MtfV9yXiGQAAAAAAAAAAAAAAAAA6F0RnaBm77LLL4Py0adNS11u0aFGYO3duMr/WWmu1ZN8AAAAAAAAAAAAAAAAAoD4QnaFlfPCDHxycv/LKK1PXk/cGBgaS+Z133rkl+wYAAAAAAAAAAAAAAAAA9YHoDC1jq622CnvvvXcy//Of/zzccMMNS60jdZz/8z//M5lfYYUVwpFHHskVAgAAAAAAAAAAAAAAAOhgEJ2hpZxzzjlh5MiR4c033wz77bdf+PKXvxxuvfXW8Le//S384Ac/CBMnTgzTp09P1j3ttNNIrw0AAAAAAAAAAAAAAADQ4QwZ0DzGAC1iypQp4cADDwyzZ8+O35RDhoSvfOUriehcNePHjw8zZsxIxGwVtwEAAAAAAAAAexoAAAAAAOpnuQY+C1AXO+20U3jooYfCeeedF37729+GJ554Irz66qthjTXWCLvuums47rjjwoQJEzi7AAAAAAAAAAAAAAAAAF0Akc7QVxDpDAAAAAAAAIA9DQAAAAAA1UJNZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqBtEZwAAAAAAAAAAAAAAAAAAqJvl6v8oAAAAAAAAAEBv8fLLL4drr702TJkyJTzzzDNhwYIF4Y033gg33HBDzXoDAwPhpZdeSuaXX375pAEAAAAAAPQriM4AAAAAAAAAACGEs846K3zrW98K8+bNqxGXhwwZstT5mT9/flhnnXUSkfpd73pXuO222ziHAAAAAADQt5BeGwAAAAAAAAD6mtdeey3su+++4aSTTkoEZxGataUxZsyYMHny5GSdO++8Mzz++OMt3WcAAAAAAIBOAtEZAAAAAAAAAPqao48+OlxzzTWJgLziiiuGT33qU+EXv/hFeP/735/5uUMPPXRw/o9//GML9hQAAAAAAKAzQXQGAAAAAAAAgL7lnnvuCRdffHGSQnv8+PHh3nvvDeeff3740Ic+lLzOYocddggjRoxI5m+99dYW7TEAAAAAAEDngegMAAAAAAAAAH2LCM6aRvunP/1p2HTTTUt9/h3veEfy+UceeaRJewgAAAAAAND5IDoDAAAAAAAAQN9y4403JtMtttgiTJo0qfTnNRp6xowZle8bAAAAAABAt4DoDAAAAAAAAAB9y8yZM5PU2hMmTKjr80OHDk2mS5YsqXjPAAAAAAAAugdEZwAAAAAAAADoW15++eVkutJKK9X1+RdeeKFGfAYAAAAAAOhHEJ0BAAAAAAAAoG8ZN25cMp01a1Zdn586dWrNdgAAAAAAAPqR5dq9AwAAAAAAAAAA7WLTTTcN06dPD7fffnt44403wrLLLlv4s88880y4//77k/TcEydObOp+AgAAAHQrZ555Zpg2bVrNsg022CCcdNJJbdsnAKgeIp0BAAAAAAAAoG9573vfm0znzp0bLrnkklKfPfnkkxOhWthrr72asn8AAAAAAADdAKIzAAAAAAAAAPQtRxxxRBgxYkQyf8IJJ4S//e1vhT73ta99LRGpJcp5zTXXDB/5yEeavKcAAAAAAACdC6IzAAAAAAAAAPQto0ePDqeffnoYGBgIixYtCjvvvHP4whe+EO65557wyiuvDK4n7z366KPhoosuSlJpf/WrXx187+yzzw7LL798m44AAAAAoDuQ/pZkiZEpAPQe1HQGAAAAAAAAgL7m2GOPDY899lg499xzw6uvvpqIyNIUGRgdNWpUzWd0sFRSbB944IEt32cAAACAdvL6668nTURknfdN33v22WeTUibafxKnPwDoPRCde5SXX345XHvttWHKlCnhmWeeCQsWLEh+4G+44Yaa9eRH/qWXXkrmxSsbz2wAAAAAAADoR84555yw1VZbJVHOCxcuTJZJ6mxpgo/IGTlyZCJMT548uS37CwAAAFAF0sfJE49j75fBRzcT6QzQmyA69yBnnXVW+Na3vhXmzZtX8yOuhrJl/vz5YZ111klE6ne9613htttua/HeAgAAAAAAAHQGH/vYx8JBBx2UpND+4x//GG6//fawePHiwfdXXHHF8M53vjPst99+4VOf+lQYPnx4W/cXAAAAwPLmm2+WFo/ldTOQ7arYLFPZNwDobRCde4jXXnstfOADH0ginIt6C40ZMybxyv7hD38Y7rzzzvD444+HjTbaqAV7CwAAAAAAANB5DB06NHz2s59NmrBkyZLw/PPPh1VXXTWMGDGi3bsHAAAAfYKKtkXFY2nNEHZVNNboZh/cZl9r8Jvsx7LLLhuWW265sMwyyyTzMo19BgB6B0TnHuLoo48O11xzTTK/0korJWLy7rvvHi677LLwu9/9LvVzhx56aCI6C+LJrYY1AAAAAAAAQL8jYrM0AAAAgHopG30sreoU1Coe26hjEX9jWVJ1ub4n4rFkfKlKLCbqGaA3QXTuEe65555w8cUXJz/6a621VrjuuuvCpptumrx3yy23ZH52hx12SLy1Fy1aFG699VZEZwAAAAAAAAAAAACAjKjfouJx2frHRVDhWEXkrOhj3W9BIo6lrbDCCoUEZBWe5btUCFfBWKb6vi6XbWpks8z7CGedt8sAoHdAdO4RRHBWr6Of/vSng4JzUd7xjneEm2++OTzyyCNN20cAAAAAAAAAAAAAgG6ofxx7r+r6x1bE1m1bIVdfq8AryLoq6op4a6OS80ThousJsm0VkCXSWQVk/1rm9XWekE2EM0Bvg+jcI9x4443JdIsttgiTJk0q/fnx48cn0xkzZlS+bwAAAAAAAAAAAAAAzUIjcctEH8cE0LLirI8Ett9nhWK7HZ334q4KtlWn1S4iHMdeN5OqjxEAOgNE5x5h5syZyZ/ShAkT6vr80KFDk+mSJUsq3jMAAACA3uDMM88M06ZNq1m2wQYbhJNOOqlt+wQAAI1T1aCq2OTNSJ8J0O3QhwKAIlgR97XXXkvaq6++OjiV/1id6vu2pYnFZcVjQUTjtPrHWah4LOKtFZGz1vXnIAutrVxGOC4SfWwjpotMy6yr0eTDhw8PCxYsGDzXzRa1AaA9IDr3CC+//HIyXWmller6/AsvvFAjPgMAAAAAAAD0A1qqiogbAADoR6zoWvVUI36tOKyv/dQKvFX9J/taxFkCsr6W91WwlemKK66YKyCXRWsdS1t++eUToVim+lqbLtd5aWUF4iLTssh5tNdO51955ZWlluu1XLRoUXjxxRcHt7HqqqtWdj4BoHNAdO4Rxo0bl6TGnjVrVl2fnzp16uB2AAAAAAAAAPqJega3m5UCEwAA+oNmir1lpvXWHs5quk6V9Xt1exo5q9HISpp4quKuCroa+WtFV/taiC1PW0+2t8IKKySCsEz1tRWL9bWuJ/NVithVIOfVOwbEXqelJa/n+wCg90B07hE23XTTMH369HD77bcnf7hl0lM888wz4f7770/+6CZOnNjU/QQAAADoBRAYAAB6h6KDnvLb//zzz4d//OMf4Re/+EW44IILksHm//mf/wmHHXZY0/cTAACqodvE3mZghVsrImtUcExErsIGsg5bKiDbNNcqCHvxV/ARv5pGuh7xOIamxdYU1fY70l4XSV3dCUKyF41j81XfkzZKW9qwYcOSLKt6DeR9AOg9eLJ7hPe+973h+uuvD3Pnzg2XXHJJOPLIIwt/9uSTT046D/Jjv9deezV1PwEAAAA6ER1c0aYGuG3PPfdcmD9//uAASb1lTQAAoDsRm3nkyJFh5513TtpRRx2V2NBHHHFEki7yU5/6VLt3EaBjUWGp6hS10F20W+TtBLG3GcQEYi8qa5SyTouIsz4i2K8n6PYEG4Vs0zcLui1530Ye2xrEVf02aOrqosKxrYHcTbZrnoiszgPNEJJ92m+fElzTgFtGjBgR5s2bV+n+AEDngejcI4iRe9pppyW1EU444YSw5ZZbhm233Tb3c1/72tcSkVr+BNZcc83wkY98pCX7CwAAANAqEdkLyLHXRQafXn311RqjvRcHrAAAoDgTJkwIP/nJT8K+++4bjj/++DBp0qQkCxkALM0LL7wQFi9ePChWiSBx7733Dqab1ZSzXhDyEYVQH+0WeXtV7C1Cmdq6gheH7fnT13aq0ce6HXmWpAZxkcheS0yo9pHIKhpb5NmU7/NCclUCsv8NKCIkd+NvhZzfLAHZ176ukrw60nYepyEAyAPRuUcYPXp0OP3008Nxxx2XCM/idX3ssceGgw8+OLzyyiuD68l7zz77bPjrX/8azj///KSDr5x99tnJHwgAAABAJ3tz5wnIVdWYiqGDQda7HwAA+pe99947EZofffTRxMb+3ve+1+5dAuhIXn755SQjgCLRbg8//HDNOiqQZTUVP1SkFrFLX1sBW5e3O/1tu0VexN4hbZtKU/FWm3/tWxExMS8tsQrHuk0rJGuEs9+eprW2oq3WJq5KwO3F1NV5yHktGpEsrRlCcl5EcqtrS6szhTT5nQaA3gPRuYcQkfmxxx4L5557bhKJIyKyNPujPmrUqJrPqDecpNg+8MADW77PAAAA0J/4AZc8MblZIrIOoqihHUupZuuL6byAsx4AAAiSZWzq1Knhuuuu44QAZPS5pO+kfSkVkW0fz4oRjWIjM1WkU9Fa9yUmdvn3ta9o+4iIvdm0S+T102aW4pEmY69Z4nGj97F9HmJN9smnuRY0LbY2Kx5XkT6611NXFxWSi0QkN0NIzopCtvOdcL7lGXnppZcG2+zZsxOHI71Xx4wZ0+5dBIAmgOjcY5xzzjlhq622Cl/4whfCwoULk2WxDogi9ahEmJ48eXJb9hcAAAB6T0QuEo3s+yStiERWL35BBzjLDAbZ9HV2GwAA0N+stNJKyXT69Ont3hWAjmXo0KGJ+KXpeldfffXwtre9LekbSoY+ESdkKv1EmaqoZ/uYPnpTheVYqwpb29ZGW9t0tCqsWeFHRZ8irSraLfJ2S73ueqKPG+33Z4nHMXtE7RYVbLX5e6tR+iV1dRGKRiTLtEr0NyUtCtnOd4KQHEPuYSsua/P3th8HqDpNOAB0BojOPcjHPvaxcNBBB4WLLroo/PGPfwy33357UjdHkdQV73znO8N+++0XPvWpT4Xhw4e3dX8BAACg8xAD0IvFWYJyM0RkG50i+KldR1MHNksIth79OqDWqwMuAABQDolyFjp1MBigE5Byb88///ygOCnOGk8//XRN/0pE6ZVXXjkalWlr3OrU9kVj01h/VsXqohSJvtb+qm0qCnrBzgpMepyaClymmjZcBUYrcqdFY9uo7G4RfqvA3gdFBGR9rxG7xaeqzhKQ7XVQxwV7DeUZqKr+sd1+GRG51+8VH5GcJiJXbc/qs58XkdzJQnIMOUdSKsGLy+IglIZ99jQ7gP4+9vr9B9CvIDr3sAfpZz/72aQJS5YsSTr3q666ahgxYkS7dw8AAABaTFHxWFszRWRLmqFp19V98fvkI1zs67x5OxhoI1d08EWn1iC2A1sCNagAAOCvf/1r0uR/Yv311+eEAKSg/U0VZUW4ECG6CD5dsI36FOHORxj7Ws42EjcmVFpR0orVfr1YdHW9qLOkfI+cC4v2TVWk9sdta+Pa962Dpn2vimkrUxYXFY8bSV2cl7o6rf6xvx56v9llVaauLiokd5Nw2Sj6fGZFJDdDSJZrUzQiuReck31qbGnyW+Vrhttn0k61rIE40ojdbJ1qFERngN4E0blPELFZGgAAAPQGZQTkZojIXswVg1EjT2wKa11HDc+y4nDWvB+c8QNAWdOiBq6NnvaRMc1KEQ4AAJ3Piy++GC699NLwpS99afB/cP/992/3bgF0NDYjjaTQFtHZijQx8dinls1L4yzfIduWFusXelE6ljo4TcCzYouNtJYmAo00nx5c3/dR2mlTG0lbNo2vFURt5GuWcF00TXMZkVrQfrueN9uPj53HRtLsFhGPY/12n7paXmv0sT2Weonde3mve0GsrAf/PGUJylULyUUjknv12si5f+GFF5IsqdJ03o8p6DXymcXkWRFBWZ4dyVShAnOR80W5KoDeBNEZAAAAoM3oIFMR8ViXWcqKtbH3/IBMkc83yzPZp4fzg0F+WbMGAHxkjA4+aISO9dIGAIDuZffddy+8rvwHz5s3Lzz++OM1/8djx44NJ5xwQpP2EKA3MvLZvtMaa6wRJkyYkCkUSmSdCCA2yjirzqztI8q8bicr9WvRvmiaSK3iSla0qY+u9oKrX6ZitUzVAbJsU/G7SDrxmAOnTdWtn7fzOrU1j8ukr7YZhbzwbR1Y9bWPLveZimIpy/2x1Aupq+tD78MiEclVi49FI5J71Z6T82kdX9QpRgVlmWrT6GX/bNupOtdJpLKcN5nqvDRdV79LHIqsLa1O3/KbpM40RDkD9C69+csKAFAxZ555Zpg2bVrNsg022CCcdNJJnGsASPCe+z7iQefV+LORDz5dX70RvxYVkK0x59NVe8qIt0WNxKwo5DQx2e+zFX4bmS+7ru6HXjMpUSJCgw7m9aq3OwBAv3HTTTeVHvy0/6VrrrlmuPrqq8OoUaOasHcAvYPNgiN9KxE/rOBkn0Pr6GfTRqvAqUKubEf7xtpsP9g7EMYiqq3AajPzlI00VqfEIoK11q7Oi24tI1bbZT47jxyP2h+6nn0tUxH57fsyb6+ZnerxxlJ522tm98EflxUafS1sH7Httx8TKb2IHWteMNN5+9qmAe631NV56HORJiLb+aqF5DIRybH/dO+4IFONnI45NsSWV/F+vZ8tUsden10Rd3XMwWdcsNvXa+qzEliHa9tkH0SkTrOhhazsCSJGSwlQZfTo0ZXdHwDQOSA6AwAAQM9gB0KqmrcDWj5NnjWudYBHW9XHpU0NaG/I+YGlKiOA/SCQNeqzmg7e1CsIxwasqsSnRPTX1Rvnc+fOTQZHFWo6AwD0DmXTdcr/06abbhoOOeSQcNxxx4Xhw4c3bd8AegHb1xMkFeuYMWMG37d96TQx1UbVFkH78YJ8RtLi6+dVnLZ9f7ufVrSOicZWCPfieNnlsUhamwo8JgDp56zwayO8bYpvbda2sedRt69TS+x8xa6RfJ8VpHW7dmqPOasOtRWe/bw/Z2WbR/v7Vgiz+19lXexOFa/VIcE7S6v9a20lW07J258x4dS/51+rqJ+Wzcou08/qfSfiZxnxthPJ+r3TZ9iON/jsY/qMW5HZZjiI1aG350KzAmh6bGnqdFFPGv6ydOp1AYDGQHTuEaocVPYpOwEAAMqQJ+BWLQj7gaIiWGM1NsDl36vaS9unsvYGnA6m2IEg+a8X488OLtl5/7rovBWI1aPfe/7bAa5OHSyx+JRtaaJyo0YuNagAAHqDG2+8sfC68v8oAvO6664bhg0b1tT9AugnrJiah4otWRG/dqqReyqg1Ov8Kf1JFboELzwrPgI4q/8cE8B9befYOkpMoI0JtrpfVoyz36Pb1fTYNrW1fk9MaFfh0EamW9LEd33Pi7Pe2TXmoGqjWe16fr/sNdLjTduXtHusKnFVX8eOyaYf9jZbbOqvR+z7YqmtYxHJzUht7UXkmDNFLMOVpxnO3FWRNi6hGc+yalPL74iulyUOK3o/+0hn/X3zvz0xZwstBSCi8iqrrDLY1InaZ5Sw91aeoG+/W/DPozrwSJPvlH2w+woAvQeic4+gP+B4CAEAgFCFgFvvNtqBHZTxg0xVishpYq+NQvairn8tWEO7qDhc1sC3KQOzWjcRE5NjonJV96EV4FVkeP7555cawAMAgO5m0qRJ7d4FgJ5n1VVXTZr206Sm85ZbblkoQrHIe1mfsVmLYtmKvBhUr8ioIqWNxLQpqm3UdZbjbJYQZ4/JTu02bbPbtAKn2iLWXpB5EaE06tmL1zYK3J8jm3Lbj1GmnTtBz4meM7vN2DnOui5p58gK6DaKXffXnm8blW2Px+6T/VxZkd2Le/692D7ZeXtc1kFA99M26/jgRfo8UdsTi/iP1VZX54NmE3OA8Pa5vTfss+bHLrzoa9fX8+1/M1Sst84asWfO76Om1o/tuxITrmW7vn68fZ71GsUyk4k9K0Jv3u9K7P2YY0Ts/imK/Aeo6GzPEQD0Ft010giZ1DPA6r3iAACgGqyHcSMCbjcJv80Ukb2AbFPD2QGONOFWB1Bi3uN+3p5TbyBa7ICKrTlWJWkp9tIE5G6IQo5ha2BnicpVisk+BXiseSNYRGcdJAAAAACA4nihTbP4dBoq5kl9Y0lTq1MRkKXpvPRPZWpFKBvpp/1JsUGs6Gnnra0jr62oFROSrTAUE3tUkNJ5e0wxkS0tLbYQE/J8SutYGvBYSuwi0d42E5SNvPbNrlePbVA2ctbagmnR3oIVs71jcpat769zLOrcZ8kqut9pU3s9bfpqXxtZHRC0qX2s59Aeo3xe560InXUfWHHcLvPvp71n7wMfKZwlZqodn5UdwT7XWefdjgV47HNlr786P/hrbiOf9dypYBw7B/K+2KaaFlvmNTV2vaJwM7G/HWmOGQDQGyA69whFI7bkz0kidP7xj3+EX/ziF+GCCy5I/oD+53/+Jxx22GFN30+AbmfBggWDHSOZnz59eqaXJx2o7hd+6xWEe0H4zSLm4Zo1b89RWuo4O4hgv0O9cstE/CremPTHEFtf6xrlpfsqi49CzhOSq/7+duC9tNNE5Xojzz1+oCRNVO728woAAADQbfioVOkDiqDr34tFsDbyvorIPsWwrxPtl8UEr9j3+pS32t+NRVVbO8g7t1pRzqfJtiJNlugVi9q1zrEqSNvoXV3PioNl+8r+vPjlGsHsaxxbIdsftz0v/pzr1AqEVqj1Wa9idqieB7+/9rz6Zfa9mGjmBWdBznnsvCj+XrDb80KqdxqwDgz2fe8Y4J0F8hymY2KpOmDYffLzQkwI9ufaO36npVEvE41txXnvrO6dGey5snZo7PfE73NsXqd6XjX9u2bN0rFBey/b1Nj6OVk39pzLa19zWVtV4q0/72mOI2Xft1H2muFCf/cBoHdBdO4z5Ed+5MiRYeedd07aUUcdFfbaa69wxBFHhBdffDF86lOfavcuAnQs0jGcO3duMq8dpzvuuKOmE+U7XCp4qIeoeh3qtB+EamtwVB3Rm7eNXhd+00TesoJw3nxsmff+9YM0OuBiU08VOR59btLwRqTHDw7oc6k1jKp8vvLSVnshuVujkGPEUn7FROVmiskxUbnXfj8BAADyOOmkk8K3vvWtmvrUu+66KycOOo4lS5bUiA0Slffwww+X2oYXFn0pHZ8tqWxZHbUj05xkVSzy0bdeZBFhyIsyVnixApgXyOxxeGHYi7Z5y2L2h02trX1stZms/afNnwt7DoS0yN/Y8jSBNu8zup92n73dFXPiTRPQ9Vjy6oL7ZSK8+lTLvr5uWp3kmHDs39N5K7rr8cccaTWi1R6zXp+0Ws722Ox7aUJ9VfZcPdhnwY4rxPbPnje95va1v6/12dAxOFv33J5/GwnuBfuYgK/nU+xiGWdfuHBhqfJPKj7r9dZxQ0HuP9mW/JbGxmnsuKTfT7tc7xn/W+Gfu7Rn2wcUFPmcNjkn1nlB0m0DQO+B6NznTJgwIfzkJz8J++67bzj++OOTWlabbrppu3cLoCNRD1RriEo6rUaICdbWgPDNitcqXEvLqytaRPhtliDcr8JvK0TgKvHGpxg0aYJyVTVzfRSyjXCOravHrd7DeXWJyiDbKVL/WNfphSjkGPLc5qW4rlJM1muZleJaU/W1G7kH5fhtGsVOTAkJAAD9w/333x+++93vtns3AOruW8XErrSWl+bWkyUcp0XACjHBRkU/K9hY0aaMuOqjIe3UC6r6GTsGERNFvS2VFpFZNipSjzW2b7bus+IjjdPm67Ul9J6RVgSbAtyL7dam07ELPV79Lj3nemx23EXm5T1NO22vg97X1o62x6DNOyuk2f56D4gtounQY8SERZ2X+1ccPdLE0yzSoof9GIE9di9ge+E45iTiz2Ms4teOCfj304R9febtOdfrKcvt+bbPYuxa+Ohv/xza59wK11bYts4pmhJb02RrtHPad1eFvScbxV7DWHpy+/rRRx8Nzz333OBn11133cr2AwA6B0RnCHvvvXciNMsP//nnnx++973vcVYAIkhHb+zYsYMd1jFjxiQdJO9J7Q1jn8LHN+uZaVMYpa0fayqYWaPYG1RqJKu4k+YJ3Y1CWhWRu/XOdyqxFHFpAnLZAZys7/T3vx/U0PtVp2rsVp3O2hqLRYTkThA1m4n8puSluNYBgirPf17d5E4973K+xAvbNhGbxUBevHjx4Hqduv8AALA0u+++e9NPi/Rjbrjhhpb9V33yk59M+lurrbZazSAuQCci0W2LFi0afC0iy8yZM6ORdmrHCtap2be01MkqLlk7w9rIag/b5WUzE2kEqre78143y4bMSyPulxURftUhVVoRvKOujdS0y+R8WAfkIlHGsXJJ9Ypg3v7xqaKFtMjYmHiv61rhWo5T7nHvQKDb0PObJrjGot3L3AN+zCk21qTzenxWpLaR4j5Ftz6ven1jgQs+kt9ePx/gUCaTnV+m5zMvjbgVkn00sx/j8ddXs7ipHa1TzdBmHQN8Sm7ZphWVbfPfb++lmOOBnjudxlrZ99JQx4AsJxJ7r9VLOyPpAaB5IDpDwrbbbhumTp0arrvuOs4IQAbW4Bg6dGhYa621oh58GgnojTxf0ymWjskay83ECs7WcPAGofdq9t642km26a6s0d4KQbgfKCoeV9HxT4tCjt2TalwJ1lDV+6UK7IBOUSG5X+4LKyZnicrNEpPTROVuEmPlHpdBUC8wFwEjGQCge7jpppua2j/QgftWce6554a77747cSA/4IADwhlnnNGy7waoBxttKE36X7Nnz64R12IRitZG9U2EHNsXtalwyzyPZYXjTiydoza5npc87HhFEZG6CPrZIn1pGzHuxxw0bbTNCKeZ5rTfLlNpukymEnkq01ja6EYyscVETHuv2WOx4qONlLZCrn5Ol+v18A4Wdht26kVq63ihTf+T/DiL7qMXMy2yLTmPfpv2+6zjgg9k8GXn0tLBW+wYj32mdapZ/2wWQHVo0HNofzfsOEXaefRTe3/p/RSLLNd98Mi+2HrLGrmc9luhTgJFiZ1Df19lTTWq315XP4ag4rpmerTjO7rPXsC287HfcGl6z48aNSo5p/Z+BIDegycbEuSPUJg+fTpnBCADH0EgNZ19nRdvgEhnc5VVVslNyesNDNsBtB3BmIhthW7t3MW8cq1IG/Pi1KadbtmmXR6roaTzsg9pKci8gWb3wQvfsVRPnWbQV0EZAbkKEdl7GVsj0Xpc2++xgytyH1dlEPgBmzwhOS/dV7+IyTFRuSoxWZ6xrBTX+l63P4tyznwEc1rkhvXulib3oh1Y0YE9AADoHqrI7NIJPP300+Hkk09O5n/4wx8mdZwBOh2pbTpnzpwaweuZZ56psTmseGcjkfUzNiW3FS4UG11rRSsVqLREj12mkdC9anemoRGY0oo6DKgNIudeUz3ra7VTtO5xVpSqHfOwYxuxCGebttiPN/gxBBUsdYzT4sVZf+/YcQorHOu8PxZtKhrKsdv19X7151GJicFpKdd9BHKRtNh6rHoe9drYiF1ND20Fx7SxBzt+ZK+BHWvKis71zst678lYmUb+6jIb0OCzFFTxjMp5UacFbSou675kZVgQfCk8tZWzhO0q9luvaSy6PRaFbN/zDtOxVOBlptYBwJb/iwWx6L0gY6g4bgP0PojOkCBRzkI/dbAByiKdORUn5FnRTrp0uGxNId/J9uJumpd2ltgTS/kTi/i1xqA1BL1BaA0NNdpjBmCaJ7B2XIvgjULbvMGUJsxbwyZPoM573YwIFHve88TjMp7ied8XS+2e5q1sz4et51RlFHJRIblfopBj6EBZXt3kKsXkvBTXatT3GvJbp8KyeqzHnslYyjB9TnTQQTJb6G+toIZyo88yAAC0jl4SZo899tjwwgsvhMmTJ4dJkyb11LFB7yL9KZv2d9iwYWHcuHFL2aFqu1r7zWfn8vad2h/qQK02b1E72kbVptnrabasb+0mTdxNE9CKrmPLhqWh9oace4kU1Wuh0cd2LEIFz6J2j02nrK99mmh7Ha3wZQUxFcjs9VO8narCcaz5SGQffVyPk5MVEPOwor4PONBzocfgM4fJWICNRPbPgT3X/h6wx2e/Q7AisX9G8o5bxd88/NiRz0Rgl6kIrPecFZjz0PtIRHFpcs60ad3lshSJttbza58Z+9xYhwENPKkXey8r1vFH3tPAg9i51ntF9lWzG6RFY+tUnI+WLFkyeL8WcXoBgO4D0RnCX//616TJj/3666/PGQHIQDqb2jFTg0U7aEUjNtM6p7ZzmRcZmtdEJCmSUsunUY61mGCtnVsrTqcJ1zZquyhVCNVZ286LrrbGZcw724q+ZQT4olHI1miNCfDa+dfjl+td1SBH1r0Wu787YWClk8TkvLrJVYmUVkzOEpX74fqoofv8888ndQKlSd1lmxkiLWuAPE8qLK+66qqDHvZFfk/62XkCAKAbEXG2F/jlL38Zfv/734fRo0eHs846q927A1AY6WeJPa1ig9Qi33LLLZeK4NTXaemDvUCqdpNdLv3uqjMbFBWvfVawWMkqL6bbZT4VcFmhuBkZHfLGDGLZtGxEsJ2X49Roc93X2DX1kZmaGtja795GtdfCRzIrKuJZ7P0XEzF95G0R/P1rz0na+VF70Y872KmeIx+larEZzFTU93aoj1bW7GbqeGsdcDVVtDS9n2O2UKz2r5/GlpW5Z/X4/fiSpnXX6+tTY8cCGexvjxyv2IPiDGOnacfaaKBCLHOhdZC26D0pv5+xbeZN7e+UfUasU04syt+L0vZ3QM6tj/pPc87Qz8r8zJkzk4wXel3WXHPNhs8tAHQeiM59jET8XHrppeFLX/rSoGfc/vvv3+7dAuh472xl7Nix4a1vfWs08tQKiDa9lLyOpauONWsg6faKeGTWK1SrIVGF0ZlmiHqBuohgbY1O23kuI1RL87VlBOuV7NN3FcGn+NLXtmOtU13mPT/tfuu+27TkzYhCzhKREdKyxeQ0UbmZYnJMVO4HMVnwZQbkN1BEZRWYJcpLmqazU6yhq6/12fIpwGxqPNmWeF77QU/9ze6VtKwAANCdSITQ5z73uWT+zDPPTOwRgG5BHCWkCdKnkqCHXXbZJVdYrafF7MyYOB1736ejTXNGjgmqsXViwkwaVoj2tq13/LXzPi1zljie1s9Oc5q15zNmK9o+shX4YpnfrLhrxfiYY7N1NrdYGz5P5CwacexFOi0z5s+j2u5ptYZtyna1O6wTvs18FqujrfdHbGzJ3rM+qjqWOlmvQ9p5jU2LRB/7+zEr6lgCIYqMM/jnLuvayn0q9ppms1KhOW8Mx/4e6HXUMTBbSkwzZYkwao85drxqk6cJrGnZ7tLWjzkkpDXBPiNp8zpOlfablPZ7VtVvsX/+NKAFAHobROceYffddy+8rvzRzZs3Lzz++OM1f3pisJ5wwglN2kOA7kcNQNsBkw6u7Uyqx6ldXzuv1vCyHszaNBWsNW69gWNr/eRFT/eKUB1DPVt9mnBN46Ude33PewVrE3zUs39tr781Au02bK0iQZ0GYhHUaXgh2u6LTRFmjVtbQ8iKaEQhF7sf09Jb23unKjFZrmFWimtdXoWYnGeg2kGhZrWs7evzG/Py9gKzDiLYjAtpA0c2gkBrTNnfS3mt25ABiiwP7zQHl7lz5yYD/or3NgcAAGgmJ554Ypg1a1bYcccdw1FHHVXptqdPn567TlXlPwC07yX9s7JkOSv75Wklj7KELWs3eudku40iondZh0V1hLR9Xmt3pvW7BduPjQlaWYKkj+a1UcNWNBb8MjteoXZNlkDuHeyL4G1kby9nva/Hn5bO2F/nPOy9IDaFZFjy94YVhr2TeUy4tMvsdYnhHcjt2JAfcyoq0JdBj19LzxXFR5PH7gud10xuOp4l51mFe3kt6w0fPjwJCrEOI16kj2XL05Tb9hkSm9M+N14s1gyAsd8Ua/v65zSt9F7svtV91fGdrOcn7xmKRUuXuU5ln08lbTzAXh+JIJdnxp4jAOg9EJ17hJtuuqn0D7XtnEo6i6uvvjqMGjWqCXsH0DtYI0Q6Yl5wjXlophm5ZQ1QwRpMVhRJ8yS23sRWoPZ1f71xUmaZGjpqqOprP2+XqUiq2/TevFaI0rRIWntHBahYVLmeD+2wxwTxmJewHzzwHp/2+GMRkPqeNxzUGEjzCPdp5GJR2t7ot/earZ1jt+vF7th83uu0/e507EBNVt1k9a4tIpZmLRNiUeqxAQW/DRVVqxByYwNPrUZ///KcSzQq2Xo/a1YILzLr8ehvr382pakThpYV0Dpb/llKu5/9wFwZ2nm+AQCgv7j11lvDBRdckPQrfvjDH1beT1t77bUr3R6Ax9pr0kR4kFSrWcJtbHmVDqHS6sEL0zG7NBZ569e1kcQ20to6ogt50YjeKbqK8xPLzJaWOlwdaNW51I4XxOyYPFHaf5cX6fx4RiOoLWLtEY2g9U3rUJcZ09HrkhbdaccY9FxqKmvbxMax6a3rEe/TyBKks5al3Z9pjsd6vv29LdvT82tTZFsn/1jqdDumoudInIJ13p4fGyltAxisc7MNWrDPVNbz5ccG7D1hhedYoIOdynfIVI7ffiY2zhRrNp28/53w59wGVNjn1C73x2fx58Gv48ca7f0zf/78JGOZ7tPqq69e+D4FgO4B0bmHKDvwKT/8m266aTjkkEPCcccdl3iJAUBjqLd2EY/ttMjemAhqn9uyaZflt0E6z2I4eYHaCqZ26ufLYjvnXuRV8cim4fLpqmKia0wk998V8+S1xrg/l9ZbW66ZN2Bj58gut8usUBvzWvXCuzcS/Xy9598azY1ir4ePuPeGXyyNm31dVFhNE1FtdGwsyt22MoJxGj4VWVaz2AGLbsYaptYAj2UXsJ7fMcPWisvSfHo5Nez9M2kjIURUlqkOJEiTGluasq1epxnB7pt+d2x9aSNGjEgyUihFMz0AAAA0gvzPfvKTn0z+q/793/89bLHFFpxQ6DpUzFOkXMqzzz7blO+K9UVtnzSW9tUKMGnbFGIRv7bfalsWadGx3oHdZgjS/radj4nZXjTT/dZj9E7HVvD19YvThD67zJ4j3ZeYuOaFtqz388gS44QsRwY/jdm3OtXxndiYaZqDQczWtOKyn6Yh+6bpnmN2sj2Hev95J3kr2qcJkWXn/fHrvRobj1E7Xqaamc6KvGpHpom2dqrnUMdV7H1or4PPNmDHwbx4reffLos5OttzoLarzMccIPTa+HEQL/D6MTH7nNpl9h7y7/lt+Wtvx9XsM+OfnXrHn2KONv73zF5TcTaygRNVZZYDgM4C0blHuPHGGwuvK3/M0llad911k7QWAFAM6YRJDSrtMK222mpJTec0kawRgc2+VoEmLQWwNUZjn/ed6SJYI8Z2lLXj7tMXWeGo3ihuIZaSTA1BIWaYqtGhkY1qFIoYVLTjbI0HnaaJ8PbcpqXOjhmb9vr6bcb2xwpd3nPVC+HWo9Ub1LFrkWbE+HXsZ2NiXWxZGlmeutaAswNBPrqhiujresXkdhMTQP09KWRFRPjzrGKxDmL53xP7LNh90HmdyvW0aabte+pNbr3G5fmU/kfMwcQ+2xq9bOtsqXEfOz96LrLm7e+iHXSzz1kWmupMKfO7CgAA3YOIYVOmTAn3339/UlpBBkmLRBDK/8iFF15Y+f584xvfCFOnTg3rrLNOOOWUU0IzeOaZZ3LXmThxYpLeG6AeYsKM9jljtoDt4+bZLbH3vSisjsBWeKoatQO1X50lKNtj8zafNnGwFEfLLFFU+8+27JKd98esNnZapjFfBsfaZEXFfLtMsxyVHSPwwljMto7ZOI3ajX5sRrejQqe9l6yTvE2JHBMJ7f2uGd3sufcO1Xb8RbCRwn6aNe5g5/14SpYzgN/3NDE4bV6PUaYiMtrj0ntDnwM79qPnxH6PtQHTghnSrrcXd+01tZ/TZySWwU+vbaycmc8cl7YfaRkc7BhaLLq6nrE1ey6LEgsCsefN33/23kwbI7LZJHQdzYrgPwcAvUVnjahC3UyaNImzB9ACrMAgnSWpIdNJWGPRG44+fZD1SLQpwGNGZ5YxoUKvF0S9uKWerTZttjUctMNvt2M9c63HqW5fjyvNyLIDDNZ4UIPBRiCr8WANhZiIbzvd9lzForqtEZGWjqlKYoZjLJraitWxAZ6013l4QdIbTr6pkRkzNrJE7pg3u01HZgdbVLCUpmmXrZHovfRjLU3wTROB88ThIl7kftAmZoBahwxFz2teyzJAy2ZT0OdMBw6siK0ivwyWpaW4lmU2dZxeOz8YoNfCZz5oJ/U62AAAQGeyYMGCcNJJJ4VLL710qRImRaladBax+YwzzkjmzzvvvOQ/tRmMHz8+dx2craAR1Hazr8Um9P35ZorC9eD75DHBVW0+LwbHjsnbHVlima/dGyth1WyHWbXpvC3hy4jlRTpaG1PX1bI6OkahNoQ27xCrYqS1h6xoaW0oxQuo1hbW8QZrY/j6yllleuo9n3acIc+hXI8vzUnfHq/flp+PCdZZ05jTf0yY1P3xtY69Y75O9RzoM2MdJ/T+9uNC1oFYbWD/PHoB257ftOh6e839OYuNR9iscv69tEhze3ze2TpWki02huAjt/1x+9dKbLxDt2vHGGJlAvT8xc6HF5dj2QpluaaF14xl4sgnZRVi41UA0DsgOgMAdAkxb15t1hizkYs+GlqjDmOGor5vRSOb3tuLqj6ll/dGF7QT741uEZVEsLcGnO9ke7HWzscMn6yWdS71mDX9eNo2vQerHUyIidJpy3y6qVg6LivUlxGqrcFQBOvN69Op+bRf9lx4xwR7D9lp2v2qhp0Ojvh7wBt3vr5XWv2v2LXWfXzhhReixx+Lvk7bF2sM+nlv8Hvjz28rS6SOLfP3iXV6sM+mHXCICff6nr8nY+vIcdmBLGtA20EkTZOmafR0HTEs/XblfV+fzArMzSY22FBmXjJcSHq7tHMLAADdy5NPPpk4c0+fPr2QU5H9P7XLqubss89O/ms32GCD5D/o8ssvX2qdBx98cHD+L3/5y2A08v777980kRqgLBoNWrUTt7Vp8uxCazN4W9Nm9bI2b6z/L8RsPT+NOS2ruOWjJGN2mN+ONBVo8+xOL0RZodIKTjERPeaMnNasU3iaU7vYCjbLkrUXsyLdvYjmp7Flet7S7Cud18/oeVCneH9cfn2/HWs/xr4zts9593PM1khbrt/vhVh7Hv19aJ0f9Hz59MsxJ2x9JvwYkz0vXgDXedmu2H7yzGsEvmaz8ue5yPhAVvMlzbxg7c9NWhSyt+PL2vBFl3m72zqXWCeT2BhNDHXokDEurU8u/Qdbn9xmMVA7XueL3qdpDjGx7HFyv0gtZ8kcI1NbvgoAeg9EZwCAgkhnVDpn2omWjtKMGTMG36uyxYRg70FsBaeiBow9Fi9seiHLRiHHDD3t7NrlRQbaNOJZvdytYWO9PTXaUaNUbfSq7azbQYJYLau0mkpl0fMTMxh8FLXvbMfmvaERa3pevSidNm+POe9axAYm7D1nnRTEQLHvCV6sVe9VO6AT86bVe0AFfm/M2uhjnfpBEnuc+p5NzecHKGLGZdq03nslLWoh67W9DjHPf2/IW3FYDeci19kb/9772EdJWBFfB2DEOLQp0nRbSuze1YEF2zTSQ6+rGsL+897z2xrYsebrVcVE4yq8qH16bQAA6A3kf/KAAw4YTDG91VZbhY9+9KPhuuuuCzfccEPy33TRRRcl/4dPPfVUuOWWW8Ldd9+drCsD6JLyeuzYsU3ZN/nvFaZNmxYOPvjg3PVPO+20wfknnngC0Rk6BnECldT1ivSpHnrooZp+vxV4Bfuedw61Dsy2P22dYGN2lHWOtfhlMbsg1vf2/Vfbh/WCtxXmvG3k98GKnlbYja3j7Tpv22RNY8u8SBfL6GXHIrwDrLdByojGfhtpjr9pgmSaqOivV1rzQqv9Xj8OkEVsezE72dvMdprmFJ12/N4+88drsddVr50+N1p/Xesvq8jsxVi7v/Y82RJo2mz0so5XqE2oYz1iL0o0rDQZW5Am/7GasUzFavss+WsXO960a1VkeZExmNiyesYVbAaArHV8RLn9/dMxKx80ofaynOM8ZzTZXpYTj54ffw7KHHMjYy8A0PkwagYAUAIbLSmic9GaZmlicUwwrKeDGvPS9kKy9VjUDrmvoWq9q70ndx5WFFNBMW09752ZZhj45eolbZeph6yKQWrQ+Kl+Pk2c9s17MTeCNx7UEItF7Ka1MukMrVDtjUbfZJ+0xe47NRLLEBMv9drotVLxUbD3ij3n3gnCG3F+cMkOeGQ9B7HlscGevEEZe76saGxrVfl98x7UMewz4SPt/SCEHeSKeRjHBNo0VGCW3zkdXFCBOYZ9PuWaymCApjHXCOY0I9UPtvjlsX2z6RiLkDegFPuNSXtPr+Ps2bPD/PnzB6912WcDAAA6kyuuuCI88MADyW/+XnvtFa666qrkf/Tpp59ORGdh8uTJNZ+55557wic/+clw3333he9973uJQL3pppu26QgAOh/vBBhzxFTUdvX9e++M7R2zi/Tl8/rz9jMx0TstkraIwNvKaRppTrl6ru25sOchRp7Y6c+hnj+1a1SI9OMD1p6MCcJ2u2kOCrG+vj02H8ltBXRruxVxTs4TgovM22X2u2ICtZ/6aGv/bFk72jpkaNS8Zq7SKHSLXptYZLxeT2/X2f1R+1ij/NW2lWV6rfPGXbwTcsxxOhbd7M+RXZYm/ueN/xQRqtV+jGVOsGMEfozCZgGwv2+6fhFhV79br72d2mtqx2dsyTnrIBA7V7o93wQbvBAbd5PXkk1mzpw5g58bNmxY5vEAQHeC6AwdgdTN+ta3vjX4+sYbbwy77rprW/cJIAvtuGsEqDeCYwKmJ83zVDp0NqozZhRZD0b9jHbAtVZxTNCMfV+W8GLFwlj9KN+K1lq1HWrffNrmsmgU9ZIlS5Y6335/RRyLHZN21P3ARl5LExE9anhlCXoeL1TrufYDBX4Awde8FuS6qgexouv682/n9Z6z35VmpPm0b/UQi3C1gxLWUUKX5d1/ac+QvuefOTvooCKsrzOmUz1Hso/+uLMGuGLv69RG68amMeNYj0GvnXUq0Xlr7NrfLL2e6mmu59n+Jsh76n2uEcxlnCJaRRHv6bRn3Neo0+1I/al58+YNft4+QwAA0L1ceeWVyVT+684///xCWS222WabMGXKlPCe97wn3HbbbeGggw4Kd911V/K/WCU//vGPk5bFqaeeGr761a8m89jS0KlI/0ocYQXph0oNdYng1352mrCcJxbrvLXFYv1q6/DqHR9j0clWALTRsirM6nsx4dDiX6c53Pr1i25Xp3b/rOgVE5itgOT3IzY2EFuuy6yDrB+H8C0tcrfMGEW7lllh3p9THwQQc3xuxC726Pda8TjNmV6PwS/Xz1o7T2272D2n19Zmo7PipDZ7z/lz4IXWouMnNrtZHiqS2nsu9jpWS1k/nyZYx+6L2HxsmRXf7diCbf5e8qW1/LmL3V+xY/ZZxPT79Pe4DNYpPjZvv1uvhTqY2IARe74BoPdAdO4idt9996Z/h/zYqyd3q7j//vvDd7/73ZZ+J0A9SCdOI53lWRHBWV5rh0o6T5Kmxhsq1js7LepSO99WZMoy2spGvir6WZ9Kt4ro2rL7oal9stCOuRU/01oRj26b1juLWOphbbLP9hxavIhXr1DtP+vrJquBYr2N07zVY57f3gDyBoAX5a3I7c9pzLDNiyQvgj4jWltLDVg/uOPxRqQ3uux11VTtWdfKvmfRbaShx+k95vV6ey9w+9rve1Z0cGzAzH9Go91tK+LQIZ/3ac6k6b1Q5LtjTgkxz+g0b+mi6/qmThS+1n3MsG9kAKjKwSMAAGgfIhbLf9TWW28d1l133cKfk76SCMKbbbZZkib4sssuCx/72Meauq8A3Yr2Q7X/JP0zFT2sg60VvfQ9ixd3Yo6q3gHbC55lsd9phapYRG3M/kpb19tmdv1YRGRM6LTCot3fImKqfc+v553LvRO6Zhqz5XPyvjcmZub1q8ssr2IbzdoXH3Eci3LV8QqNPvbzPqrfI/ePjdy2NlAMLypLk+uqpbPU0VjGuWx2Oe8MHRM5rf3qI8qtk7fuo0ZaazknnffH7oVZa8+prW3TU9vxEbvMjpd4cTnNvk0bg/DCemx8xN8XsWcj9huh66pwq2K/H6/yor+QJVRbB/si97M9Vv1dSiP2/Os9IsEhcn10WVHHAwDoLhCdu4ibbrqpqR5AWYP4zUL+XCQlmfxZrbbaauG5555r6fcDlEGeD1szRWq6Sco935ETrPewdgitmKcdRa1xagWwMvuTVkM4rXWbF6Hsb9H0zrHo6ZhYXURss2mp8/YvZozbNOVipOl5V2NKjSeZykCLODBobVtpNnLWis5qsBQVunxUsHdasAah3MOagjtvfR9ZbMVQubetIWXPlfd6tqmivIHmBfSyyLktIoKroB3zyI0Z097ItsaoPsdqkNt59Qa3dai8Z3Da4EvMWPTHoPNyL4khp01eFxFX5bt9/WXZV79PZSP0Y99jz3Wa53naa8HeP7HnW54fK+7rec8iJnLr5+1vqKRe9RExAADQ/UiqR0HEY4sVqKSPFHOY3GijjcIOO+wQbr311nD55ZcjOgOkYLNvCdIn9lljtO/pxWNv82p/Oqu+qxU70prtz9s+ue+rZ22/aJP+ZVp5rdhyPR9egKoXPV/+PMamnZjFqFvx2cM00tSnXZZ5HT+Qlif4aaSq2vBi92kpMr2Gsh0f0W7tWhWWrf2qwqW1H21ktY5H+Petg7V/7QVVn0lLl2mpJm8LWkcM/6zYzGM2c5vfzzQn/bSscXbcQs6rnns9Pnuc/ndG7eiiz6y9ZjGHGftMlvnNiTkDxCKgLfaYvDO4vQftdfT75bdnefLJJ2v+B7CnAXoTRsq6jF6LqDn33HPD3XffndS+OuCAA8IZZ5zR7l0CSEU6m3Pnzq3pwEmqVRs96Y1j24nWbajHqe+MyXra0demdVF1qvMqonjhsJ8pEz1tDT9b09h7FKuhYqNUYy2WHsmnXU+LYvdRuPb+ScMbaHaZ7eh7b2p7DCo0W6Mi9j0xD239rDda/TOQJlSrJ25R7HHY6yTGn14vn/bapwqLeSxrFEXsPWsQW8cQO+9F2jzHj3qeUTVAY+dEBxds0+sydOjQpFnstdffEP1tke/wKbqyxO16sdHxft+y0lvHMgPY62WdBWKv/eCiRtHoefA14K3HuGXs2LFh0aJFdR8/AAB0Jupo6P877ev58+eHNddcM/r5jTfeOBGdH3300SbvKUD3Mnz48GSq/bO111477L333jWCly3rVIXQ22wb2fdds6ZFI/rS+v9p6xURkTUaGarBjidYe9RG6eoyL2p6J1f7fuy1Zv9SG9gKv94Wkvq4sahc6wxtneTVvrJZxmKpm210bDvwdp53GpfjUoHdO3TruUwTq+WYpQ8Qc4KX1yqGe/FViS23TvgagOKd0nWf1QbNy4TQit+zIth7w6YETxs38NkaZs+enZRW0HM0YsSIdh8SADQBROcuQmoz9RISIXryyScn8z/84Q977vig95DO5siRI5N56SCJ0SwChO2U2yg77+3oBUbraWyjJ+WzaqyI12pW+lq/fWuke6/ImKdkN3kx+1RAsbRKae9lzcfQ86fRzjY9sY1S1lYkelrQjnkaNmLWprtWcdCKhNaYskaNNVBjQrH12M1LiV3G0Unv27KGo4+W9l7Q3jPbGm7yDKY9E3q8acdpt6fzQkwszkLOkXqY5xHzXC6SnUCj0K24LK+LXB+NINEmhm1e1G8RsgRp+1qj+/0z41Ol1TOAYQVsfa58ZLK/b7TJehoZLq1o9LWUVNAIAr3XAACg+5E+hYjK8p9gGTNmzOD8448/nio6P//888mUzF0A6YwaNSppiqSy33bbbTvqlEn/soiAbIW/KrHOvEWmvUyRSNSi6xR5bUtZ6biOz6ak8/Vm48qLcvVZwdTWUXskLwucjiH4VqVYGUtxHROn/ViNPWe6P14gjznWl3ktWEd767gcE/3lXIqNbIM4fESvrhtLly2f8RnvYlkIi2Ajk/34YcyJOi0owmYE8yXD7DiPHRvy1yjtdaP3vA+YiY1dAUBv0Ns9lB5j0qRJoZc49thjk8HbyZMnJ8eG6AzdgI2MFIN5k002qRGRfBrYrLS4MZFGPQUb7dB58c2mDfOvrWDtazTZiD9bOyZLsG5EAM4Sk6vER1WmRVbGhDCNkJVzIdEveq20Ix/z6rTpibwRETMmvPGUJmx6gS1LyKz3PFnDSs+HNb68MSbofZFmsKihoxHiRe91a5Db82ifOxXlNTWX3re+xcRCex3z6jvbVhQ9l1nivKbv0qb3ZVpUvG1yvDJoLjW3VGTOqjvdKHZwxjdbd1yR/ffp4uw9EhuYsPdO7Dmxzgr2t7cIPu1b2mCUfW/WrFlh3rx5g+vkZVYAAIDuYMMNN0xEZ/mdt2y++eaD83/5y1/CLrvsstRn5T/i3nvvTeZ9quBWceqppyYNAJbGizBZ06rtTqFMNHKrHBqrEmqbIf5WKUT5yNas+SrFL7VNYna62i/Wzlbndjv+YB3SPZrCWWsva+Ytn20v5tRdz+tGt2GJOYbnOcPHmh2/iZVXa/R6ekFZzrPNdqbPa9ozYMeJvDN9EYHXL9Nt6Wt7jr0g7ccLrLNCbLv1LLPn26c391n/7Lxki9RIZ2myTIN7AKB3QHSGtvDLX/4y/P73vw+jR48OZ511FlcBugLpzK2//vqDnSOZF4eJNJG0nteWsoK1TY1kPTHTyOpM+nndTkwM96lsNVWTN65jNaS8x2YzxGSbctnW9tHjUENBr7FgRWKLfs56oaalVbbL7LHZDneesFnkePXYLN7wUGPV1xpWQdZ6Qduo+5jIp84RaXWzNT2VRojHjEg9D0U9rn2UalrT+1Cuke6DF+aLiPRlhMRGhGobQW9F5hh+uTV49ThkXyTSShy66omo1uOxonGaoFzvgJwXegX5fi0XYH8/rFOBZoGIGfL2d0wHC3Wq10AdeuzymLgd+y22LF68uCYKjkhnAIDe4B3veEe46667wsMPP1yzfLvttkv+o+S/T7JzHXPMMWG11VarWeecc84JTzzxRPJfusUWW7R4zwH6D+1/F41Izurb1YPaJjHR2GcV075ilsiqGYGaIdymLetmvM2fJiI3KiTbaFq1r2NO+rosrUyPz/SkWe3sfSQOS7FUytZpV9ZR5+KyNYM7iSwxXVDHdF9CS+f1edbrYcehvE0Xi8DWz+dFKOu4gh9j0xJXWQJxzOle70/vWOGfVTve5NOFx663HftLE3pVrPbfF7On/f76IAQ/VlU2BfiSJUtqnPDF4W/hwoV13UsA0LkgOkPLkT+Tz33uc8n8mWeemaQnroLp06fnrtMMr1XoP2xUXdVRbjHxIy2VV1p0rjQ1ZNSwUbHIijGx72q1EWrFTD2ntuaqN9i1A67ip91/7UircWcjIdVoUMOu7EBClmhZFutt6j1S7bxNh512vbTz771cixqfasBJx98a5laIt+j5LxI9XeTZsPWd045BjT1/jxe9T9OE+SyyhOo04TrveOX7NZWznG8RL+X6qZe6bsPez2rY6b2o3uzSssROH1GtRmQsElmbvb+8w0IsO0KaV7eeczsw46PSY8+Q/e2qEv2esinF7bNmn0Gpkyaivh2sAACA7mfXXXcNP/rRjxKbctq0aWGDDTYYrDX4wQ9+MFx22WVhzpw5SSrg448/Pmy55ZbJf/pVV10VfvKTnwxu5yMf+UgbjwKge0mze72Tq+3Xx8SaepvNmuOzKllbTafWUTPmVAnZ+GhY29+OOdfbZfp5neo2fG1c/37aa/2cisa2/q4VJW1a4BhyL2h2MmlalsfarVnpsbXGr22aaa9XyBOUraichT6Hsj2Z907Jsehy+zwL3rFaf2fEVvdCtRev08Yi/P0bS20dE3NjEfkaNWz3L7a+2u+x8RRvvwsxgdjP+/EAH1Gt4xE+grsIsXE0fjsBeg9EZ2g5J554YpK2bMcddwxHHXVUZdtde+21K9sWQD1YYTArsrnsfBHUMM4SVtK8MNXAs8JUWtRmrGNu99VHCsfmFWvk221YL0srJnt8Z9i+js2rwKkCX8wb2Xore0HYRjDra7tuWnRw2nwZcTgPLyjaJgOiYuyK4avRx7FW1tnApwyz0ewqjNoawrEU140cfz3Rxa0SqtW5Q7ehgw1Z115ex+p36zOtxxS7xnJtRazVqa0/rsdelSFnB+T8oIymNtfUY3bQzkaiF8FHYsQ8s9OW++vsjWn72k/TtqvXzf42qIEPAADdzz777JP8d8n/6hVXXJHYrIo4Sl9zzTWJ8/SMGTPCF7/4xeg2tt566/Dxj3+8hXsN0F1oxhi19aSPevXVV9dE4mmf1Qu59ThG+6jjmO1iBaksbDRhp9PsVMlFtylYu8xHKHsHWKGog3MePgLdz/uI1jLIMVlxWVvRe0PLIvlWj0N7pwvKapOqfWqDHewznxUlbJtgM2L5CGXNnqXbl+8W8T9t3KBIYEdsfCyrtFSaXertzCwbNTav40k6PmDv21jEsn1tHdptkIb/fisiZ4nUlpi4nTU+l3bvAEBvgegMLeXWW28NF1xwQdIZkPRkveSxB72PdNgWLVo02HkT54kHHniglDjcKmKCso1e1Y64TUcspInDdh1fH1rQc2A9RK3wpU1f25TXanzG0vyUMfxtRLMVxXzEsqDL7DHYDrntLKvIrM0eq9ZY9mJy2ddp66T9RmYJkN4pQFEBM0ustYKtv6ftAEBeU9QA1/OY1uw1Kvq/kOZo4R0qrMGVFuUba2o0x6J47TJ7X+s9XyRjgEY4qzAvU63DZSP77b1pB2rU89katrquv94+WkC347229TnX+y/tvtXvkabPtn6vnh/dVmyq97Zeb/999n0bTWLvDWuIW4cX/77dVz+IGTtv9j6KOTE89dRTYe7cuYPrSw1tAADoHi655JJw4IEHLlV7WX7Pf/7zn4fnnnsurLXWWjXvyevrr78+iXh+8skno9uVWs9SQooMGADpiOAs9rQiEYVSGqYo1h5JE5TrcXYs8/2tFm7r2UYzUZvK26I+IrMZ9bHVvo+JyH6+ivMgx6rO27YVdUyWfdCay7alRTq3Ay/s+uAJXabjOzZFuLzWeWn+s9bOikX4+qjd2Jiat9n8WIbN5ueXl3FUSRNYYwKwb+p8nbZO3rn3tqkfb8h63+9/0Wue9j32WqSNaaSdh6JN/gfkftHX6rQPAL0FonOPIh33KVOmhPvvvz8ZHBWP0iKimPzgX3jhhU3ZJ+mMfPKTn0z+tP793/+98npXzzzzTO46EydOTIRCgHqxBoavZVIPvoMnWHHGzuv6dh27HS/AqKEtneCqjE/5nqy03jb62aL1glWgiXlCpkUY+ho23pPSemOmRXPHXvvzp0ZyHlYgsyJZLAWbfz+PmAAcS/Or+xHzHI299ss0ilbwHt82fViRaGovfKqBFxNpY4aTFQJl3p+/WIo77+xgz09MSCyyPPY8yXmwoqymxpbBBo0g96nfYt8j++s96mV9+W+WqKm0+ktpkR16v+s18tfai7k+skMj/n0NZXsdfPqwWDYGn6GgWQNdMeHbP18+EjlvP/wgRyxlWQwfMY+BDADQXRxxxBHhM5/5TCI8H3744UlabeWAAw5I/dyECRPC1KlTw69//etwww03hJkzZyb/N5KGe//99w/vec97WnQEAN1LTBix2YJigqLNRGX7ec0UbtO22atYGz9PUG6WkJx2/e18MwV1nxpbs4QVFS6bmRrbj3FkicN5y9R5WQVjLcmmYro6Uev7OvXOuEVTRdsgAW+z+nGKrHNVRgSW+0WF/aIicjvQMbt6yRpjKSpeFyG2ndjYWtHtqegsyHXXlPgA0FsgOvcYCxYsCCeddFK49NJLk85BPTRLdP7GN76RGOrrrLNOOOWUUyrf/vjx43PX6fZ0NdBeVNBVNF1Pmjjs57WjZgUz29GuUhwui/VqtIJyTHCy+2wjEm39pFj9V29Y+JTWvml63iLEjJ60mje+To4XpmPpnrLW0fvAfsYap1miqO/8x85VWro3L+z6NEqxGtF+XoVGe9/Z+9UaZF5MteuoEGfTpum5sfdTTOyPCcFp79l5vc98+mbf9Pn0Ua5p3+G9uW2KsLR9sq/tPa7nT7cnxryeK3s/WIcTS8wQto4lep1tRHBMgPXPnv287o8+23aArygxoTrmLKFTfc8b/PYY/XJ/buy95D/r79fY/urvlqZhGzp06FIDjfb+0fbYY4/VnOuytaIBAKD9iAOZ1GGWJrapiM+HHXZY2GijjTI/J/+NBx98cNIAoDwjR45M+lzal5JnTp6ndtnAvYx3Fs+KSG7Ukd5jS1HlRSS3WmxqVmpsuYe9wCtpndOEYFuOyUYNWyFYXzeSBtpvM7Y/VeCdg9XGssvTBOA8EVnfg1rs+alnrNuOfwiaCdA6rPugCj/eYJ1GrFNQLHJc+cMf/pBkldH311133bDppptyeQF6DETnHkJSfU2aNClMnz69kDeeDsr6Zc1AxOYzzjgjmT/vvPPCqquu2pTvAWgmPpKvkwSHWOdPO3wxQSg2r51DMZp0O2WxYnKWqNxojSaPCozyXTFRMRbpqi2WmskK8D6Fk9bJFcNQBda0mj42BXKaEJcVTerFZB/NmlafzIuNjZAVIeyX6VSfEf/daowLVnS1QqwXptMERf9ebF2d2nTr/pypCKvfLddM5r0Qr9H49pr4500NtTy88az7YB1TYl7fXsz25yXvvbTzaZ0odNDJ3lO+hrmf6jMeq1lu99nvf0yojkVT26aft8+qf2b1firrua5CtGYC0LTndkDpH//4R01qfgZAAAC6C/kNt5ltpGzC6aefnrTtt98+iYQ+6KCDKJ8A0KTnz6agL5KdBv4P7a8XiUiuWkhWWydPRC5qD7XiXGkEr0RWasYqFV69XSfLvU2vx+3tFx0P0M9YYbiMKFw0ijrrGNMc5NMEZW8XWif0mOOvzzBlBUjr+MxzXB06buHH0WLjannrxF5b+11flylHYMdt0sqX6TPif59kPbGp5bvV3ufeAehNEJ17BPnRl3RgmmJ6q622Ch/96EfDddddl6T/kh/xiy66KEnlKYb1LbfcEu6+++5kXfE0lcjjsWPHNm3/zj777OTPRdKPSWfv8ssvX2qdBx98cHD+L3/5y2AabElXhkgNnUKjHaI0cbjsvApv1kvWd/jUCIqJroJ97UWg2Ppe1LQ1lazR4QVJW1MnTxCOvedF2bQISm9cZaUQ8u9ZY817hPt019rs5/KiomNisr0Oek3VALBRlj5yNva99jzHUh3pNY6JtVYktvepndr7P88j2W4jLWLVNnUW0Pfs/W2P1V4/f129yJn22qYUs89MLHrZHosXIjVdmj0/ecKvHahJa2r85XmCW+E1dn95oda+X/Q6Zh1PDB04sQ4PebW/04xb2Y6t+64RADKVPoTWUpfPyvfKd8nx6UBXLJ2bvRZpKeW1+X3SOmWSCl1KlkhWGaWTarIBAEA+YmNK7eaf/vSn4c4776z5/7/99tuT9tnPfjZ84AMfSCKg99prLwZEAaCp5EUk29dVYrMc5aW4boWQrLaaTfFss09pn9xGAUsTMVmaCstaDinmWB7LiqbnwmfMagde4E4bM/F2nWBLJqWJyP67vNOwj2jtd0GwUTG3rCjcjGctzdFbmkTjZzmCx6ZlnCXkWLTUnjJs2LBEh1D6/R4D6FUQnXuEK664IjzwwAPJj7UYxldddVXyB/f0008norMwefLkms/cc889SY3l++67L3zve99LBOpmpbTQeg3Tpk0rlI7stNNOG5x/4oknEJ2ho+qla6dIRCe5PwUvElnRLiakCTEBWA0I7y1ro21tLaUsITlNQPPLfGpi7ej62qle9POGkOKXpQmFfht52/XbsCKqPwf+XKgY58Uob3jGzmfaNtPWsfMxo80aEjpVAVmxwnbs+9PSFqmRqUayFV31ta0D7O/Z2H3ixW+7zN/rPirX3y/2Pfvaz+fhxVDrgKEetzLQIAMO4myladNsKml/Hb0IrnWPpdn0b/r8yeCHvicitDhH2SYRsiNGjEjm1ZvXGv7tQM9TzBM/9lujrSg23XwW1ivaOkdYp4yslOlyfdLEXrlG+r42P5iSdw7KHDNGMgBAdzFq1KhwzDHHJE1KJkiKbSlNJY7Z2jeQ//hf/OIXSXvLW94SDj300ESA3nzzzdu9+wDQJXjH8KwU12VEnDzU3iwSkZwlrFqnZhV/tcavir42LbRd5h1HNSrYpnr2mcF0mpfuOWbHlzl/NlJX6zCX7c8XcdbNc+T1Dusxh3u7nbL0mqCsDtxVibtFooY1K1o77PUsobisSNxp2LGnbroHAaAciM49wpVXXplM5Qf7/PPPL5S6dptttglTpkwJ73nPe8Jtt92WpBG76667EiENAJYmJpaWqZ1uPWrTvGyt0Zkm6Np98ftll3njQg0Pec+KkjHhR7fhp7FlzVzXz+s+W7ExLY2UTdUci/BNEwC9AOvF2Vi0t60rbN/zTgdeLPZGoD2+rA54rD6uNS50kCC2TtrxZxnL/jzJdvQ9nY95W1vRUI/dithWzPbLYs4KPgJdByvUE16EZR0U8feNCsQ2Kl331z4f9r7TwQ87OOFrJuddK91uXnRtWnrqIsv8NfXfn7Zfecv0eP3vlXfg0Hm9B9NSzFlhu959EmRAQB0CpNnXXmS2Ayr+t8ZHD9jlNnOAvec00lnXs17aAADQXWy88caDqbVvvvnmRID+9a9/nTis6f/Cs88+G84666ykTZgwIUm/LU7UY8aMaffuA0CbhOS8tNYxW6RRvD2rNpiPfFWB14vAfmrrCfv0uCoUpzmNt4K07E1FiZWgso7TRQXiMja64O3vtDJbjdBuQdnata1KAd0JKdvrEYmLTu090mn4e6vR6fXXX5/rpA4A3Q+ic48gYrF0Krbeeuuw7rrrFv6cePX9+Mc/Dptttll46KGHwmWXXRY+9rGPVb5/8h3Ssjj11FPDV7/61WT+xhtvDLvuumvl+wHQCD5SWQwySeFkUzZpPVgrulgPZh/N6kXeIgKtT7ntX8dEOyu66HHkCYtZr2NGV2x7fhsxoVOnVkCzglAsfbZPG+33KbYvsVTI1oj09Wttx9iKp1nHHPvumKGaZ+BmraPHkreOF8+tSGwjg9XAUTHRzntv2qqIPQux9OWxQQ7vpKH7pxGuIjzaz+jxyrGrx7I4V0mTde0zo9dc98nvVyxaPm/QQB0ANFVcFipk+7pZsWhfixfz0wR+v47/zbCvtflrYFOUZ0Ur5GUWiA0i6XWKGaf2N07Ta5chZvT6bftpbLBG99H/ZgEAQHczadKkpP3gBz8Iv/nNb5L02zIwav/rJUOYtC984Qth7733TjKJ7bfffoUcvgGgM9H+fl5EsnXUjpVhyqvnG0uh7fvC3vawtk5W9rCYM3enY22NWLkgu47a4zEb3zr3WoG5GaKr2nWx/W2HoKz2batTQDdT0G42jYrDjaSabhVZtnTZaZpNDACQB9ZRjzBnzpxkKuKxxQ6GymB3LIp5o402CjvssEO49dZbk1rLzRCdAXoB6Vhq5IMKD5IyXomJkWoA5Ym6KnrGImZtq7LTZ4UTKzJZkTTtvdg0TfC0gneaQe2Fz5iIarfrj8Gvoy0WXaqGlTe4igrI/vssMaMjzRApum4zPl/vNq3YmyYq2mUiQIpAaAddbISAvo59r01JZz3vs/ZTRVpNdy1RqLZpNKw1vrwRFtsPa1T6AQbdL42wtvusAqwdqLJCuN13G52g6Z3ten4wyQ5C2LTqXkD2n/OOLn5en1N7ne3xyzTPWSLm7GCfSU03HssM4M9xLDqgHk/wejzHrcGt+6n3sx5jJw40AABA/Yi9fMghhyRN6j//7Gc/SwTof/zjH4O/+fL/LuWspI0ePTpZV9JvSyYxAGgNKgB6W0H75VpeR+bFUVxTQet7mio6lqHHbssK0LJumshrxwjSbEmd7wYhp4ijdNZ7fh3B9+/VMV+F1qx033a8xNsPVRCLUC4jKKsDtE1d7sdy5H11fBZ7SJq81nkpzySviwrA3ZYiuywxh4SYjVhm2mmkOVwXncZEYgCATgDRuUfQ6Cmf5tG+nj9/flhzzTVTU4uJ6Pzoo482eU8BuhdvPElHX4StPKxgEWtqnNiIwzShNybu6HtpnrBZEdFpwnOemGTPg4869d7ZNm14lrBbBi8ip6UrptPdHGxkf2xQRt/zgnXMSNQBHBkM0sEhaTIwpCKoGObyrMXq/FqBWSOY0yKOrKBpo2vtgJGNCvYRwtYpxKdP1+wCPsLaTn1UsE9vp9O87aS9F6tLrr8/3jC1A2OCHVQR9PepDHqO9LOxARcVav1vihXMY84A9tzroJN1kPGDfj4y3WZN0M+kDYrFshMojzzySM0xp9WWBgCA7kfqOUtUs7T7778/Sb8tTtqzZ88e/D+ZN29e+P73v580cQCX9NuyPgD8H9InmzFjRnjuuedq+pzS7/3tb38btSn8Mk0ZbVuac6LtF1oHS53mCcce22f1U59ZqJWUEYGFtAxcaZ+vB5sZSaO5s8rrxPDZx3RalJjTuc/wZPv8+p1ZTe0aXxPbOtJah3Y/ryWAehkfZECq6XzRuJedBgCgv0F07hGGDx+eiMoyaG+xtaYef/zxVNH5+eefT6ZiBABAHOkYWpFZnq9NN9100IiI1RaVqRVP8kTcMoJvo8JtFjaC0xv7flkRiohXcnxFhORmpcuC9Ohi3/IiRtMialUYlf8qjQxWcVoFZBGPvUCqRqu8VoNdBx/kszqgIduV/zM9Dp+mu5lY8dkObHjBV49JfhvEmz0WYe0dNrxTR1Zt5LRnV8+3rRtvp3b/05xVZKre99bLXn8DrfOMH3wr8ltXr5OIFZL1u9TpxB+LFaityG4FfB/VEItMt58BAIDe5x3veEfSpLbzn/70p0SAvvrqq5P/V/0vePjhh8NJJ52E6AwQ4c4770z66bbvJDXTbZrptKjGWHrpRrH9TxV/bH+4KiG5ShE49l47sQ6esSxWsn/SJxe7x4q3VqSV8RWxibTJay/aZqWAtpmddJ985qmy2Y7Soph7TVDu11TTaVHCpJoGAKgOROceYcMNN0xEZ0kBZtl8880H5//yl7+EXXbZZanPSgfh3nvvTealkwcA2c+aGqAy/6EPfairTlcsXVhsWZWph6yBmdW60VDrBLIiYK2nuRjc6jSg87YmrxckfRSwb1Zw8+uqKGxTNevURgzbARObrlpea8SyOnFoWuyyxNK32/lYBLa+LoMeqwrelpiw6h1JYl700kSItwM0+l36ffJdGhmuqQJtCns7COAHtjwq1trUcPa1XlMb0ewFdTt4Zx0G0lLVpQm79aDbs1HNNi26b0XW88+ROOctXLhw8Ds7MU0bAAA0D/l/22effZK2aNGicOKJJ4Yf/ehHg05NALA02udVW0SfFelbzZw5s7JT5h0ffVaimKNjEYG3jAjcTMfwRohF4xat5yu/e77/rCV30qKCfSY3TSFtW55jupZrshmhdP6FF17oK0E5L9V0PSmnOw21MUk1DQDQ/SA69wjidX3XXXcl3tWW7bbbLhmol87YD3/4w3DMMceE1VZbrWadc845JzzxxBPJH/wWW2wR2sWpp56aNIBOpmy62VagkZ5ZIrK2qgbD1MDME5JtPetuJy/FcZH5qj8Xi4a1tchsavMqUFFSxWBbT0uNVx0QkMgfHQSwAxKxbcq2NDW21rmq577xQm7efN77MQHSi6U2jZheE5m32yuDfX4lctu+9inL7THbqGq5RnIerSAs+BRwMq/bEFRYzTvHgg5q5K3rsxdopHQsrZit96319ewyncbqgmsEfuw6NRoRYx0lrPiv5xQAAPoLSROstZ6l7EKv9HUBmon2mcr2ydKy8aTNFxWIrTNmq8mr1Vuknm/a65iwXLTslFwbdWT1ZY+KYmsUaxPbziP9d3WY9YJyMyOU/etm9eVJNV1ePOa/FACgd+g89QTqYtddd008rKdPnx6mTZsWNthgg2T5iBEjwgc/+MFw2WWXhTlz5oRtt902HH/88WHLLbdMBrOvuuqqJDWY8pGPfIQrANCBqY6zhOQ8kagMNsV1Vmum+N5sobbez7USFf+ssBYTlasUk2Mpz3zTusU2Ulr+S3Qgwg7myICDjSTQ77Dp06TJQEQjwnBVqe+qxkd461QGV0SQ1xTj+lpbWa9zG20g2JrXPlW9H2yS/VFD337ORq3b6G0V1b1DQyyKOC+yOOsetM4MafdibPCqyHmyA1k++t/+pnpBW19LNI5EOusxyT7KZyXSrdPuQQAAqA75377iiisSofmmm26qEUP0f036NQcccACnHSCCFZcEtRdGjhy5VKpbL0Q1q49ls/zUI+bWIwp3irimJY+suGydhvPQjEy2qdOrjVBevHhxmDdvXscLyqSaJtU0AABUB6JzjyDpvaRTJZ04MYZl8FM588wzwzXXXJMMkopX9he/+MXoNrbeeuvw8Y9/vIV7DdCfFBGSi9TNLUMsKjkm7ghpgqyKZkuWLGmqwNvLqJgci0a2zUYI69TXx9Vo4FjTdbUGshrf8hlvmOugSUzIlf1QMVQHI2SQQCOSs5DtqqisArMs62VUkPeipvXct/e4PovDhw8fXGafN58SPDYIZyOZdV2fNtpGnteTXjqGTyPq06/rtvS8+NrK/nhtZHNaLWudxvbJOof41H/2OdN9z4p8yUJFakW2KfUJZaqR4wAA0BvIf8n111+fCM1XXnllItDockX+O6SE1eTJk5OyO0OHDm3jHgN0LmqXWHtAnpdx48Yl8yriViHuFhWA6ynd022oPSd2nBWZizquyzkSu0/tOptuW0VkEZal3F+rBGXNppYmFMt4hZQ/6OdU096Box/udQAA6BwQnbuMSy65JBx44IFL1V6WAeuf//znSa3BtdZaq+Y9eS3GskQ8P/nkk9HtiqH8y1/+kgFTgAoiU2NNhScVk60g4wVXK8SmCTm6rorFtqaqr7OqBoZNz1uloN0rlImo9ZG4Nq1yTDiz4qF+Xo1m/91FRDBb8zdrMKWMcWm93WWqkbhFEDHbRzB3Yir6RrFe+15Q1ue7KF7cFTTttJxPG+Wrz7Oth+wHS+y9pdtLq+8Ve+1/E/y97O/pMsu98GuX+0Ee/2zZVIl2vghpn8+q61cvcv0RnQEAeoOHHnoosbslW5jWm/UOT5JZ7PDDD0/aeuut16Y9Bege3vnOd4Znnnmmpi+24YYbhi996UuDDrBQP/IbJf1RG7lsM1IVwTqkW1tS+u1SQ1mE5XrGEayDqzTr9G5LBOn4hdwLap9oum9v+3QajYrDpJoGAIBeovdGhHucI444InzmM59JhGcxcCWttpKVymvChAlh6tSp4de//nW44YYbEuNZOjViLO+///7hPe95T4uOAKB7EeNm7ty5NVG/v//97xPjzhpRXhguG70bSzMbS3ucly5KhdBOo6yoW2+q5bKfi6Ee3LFm0/GmeUeruCwUSQdsvbqzROVGRTKtF2ybHE8emgbPp8fulbq2WkvYCsoy1egAjVTOiw6ONT+QYK+zr3etoqwfJPLOLT5q3qfd9+vGpnZe72kVhD3+N81ObV08X0cvdo9nRb3n1WbWZlO3Z0Uv5zlx2N+DvJaGnLtVV1019X0AAOhsxHlbRGYRmx944IFoH14cvSWaWaKad9pppzbtKUB3Mnr06CT7nkX7w1AOLdnjW5YYa51A5bfNOq1rP9c6TNfThJiIasczbG1vddgtI4xXRZHo4KLTTiz1BAAA0E4QnbsQSRUjdZilrbPOOon4fNhhh4WNNtoo83PSoT/44IOTBgDlEcNI0qjaZ9Ebzlmk1Sb1QnJVqY/qEWdbIfB2AmrkipiYJSpXlWpL64WlpX/T1gzxVox4LzAXcUaQa+XTY8t8J6fmsoMesUhgmypczot6zuu8XTcvvbSi4rMQEzb18+qoEhOEs0Rh/xklJqZaETa2TlbTgaB6SMvGUDTVvqdoCjj/Xf662QEwf97KCNZ2XzRixJ/7MlHuAADQGcjv+W9/+9tEaP7zn/88+H9u//vlP+Dd7353IjSLk3deeREAgGakxrbN9jvVrlVnWZtlzdoOGlmsDsx54nGaM7Ut26Xpz72gXDXy3aSaBgAA6B4QnbsM6cjZDuZTTz0VTj/99KRtv/32SST0QQcdVFMfEgCqIWZEqVjjawzZeX0/S5RthsDbj6jRHYtG9gJf1WJylqDcikhgOfaYwFxEOJfj8OmxZVC1mU4CacJwvcs09bUddNEU4TI4I9OstNCxlNA2BbQXMu183vNWRvz1ArJNM1ckarcdNLI/jQrWRZ8tf93s1EasZyG/5VoiQX9v5fkeO3Zs3/7mAgB0I7fccksiNEsWMKn7KXgns8022ywRmg899NCw5pprtmlPAaDX0L6nt2PEXhGndrFfdKrOwiomq51jbR7NxKRjDrb+sdY+FtSmiUUVa5/W27L1Csqkmgbob9S2jpX2kt83zcwg65EtDKA3QXTuMmbNmpXUbv7pT38a7rzzzhoD+fbbb0/aZz/72fCBD3wgiYDea6+9OmpgGqDbGT9+/GAUnmQXOOSQQ3jG2iAmpwnKzRKT00TldqWVlvNhay9rLeYi9a1k4MALzFmpv63B0IgwrCndbHR5LNo3LQJYP6tRyTLv6ypbobietPY2pZpvNiK4rIDM/3DzBOtYOQJf616vmU7tchutofXk7DXT/dPn4De/+U3SF9P7S4xkSbEqwjMAAHQ+Ul5KHLcF+S3X33hN/ytZwURs3nbbbdu8pwDQCaQ5u9Y71UhkdZAVAUZamiOst2lsqRoJNskrvxSLUPaCsjrIV5FyupOymwFA42KxH9MpujyNBQsWJDXiFcmmBwC9B6JzlzFq1KhwzDHHJO2xxx5LUmxfeumlieGsnVEZiP/FL36RtLe85S2Jd7YI0Jtvvnm7dx+g67EdIhWioFoxOSYqVyUmy/UqUjO5k2oUS4fdi8vSYqKqjeaUzr56vEvUsjRNgaaGwOLFi8P8+fMHRVwdALFNU7PVUzvYr58lBOfVRo591gu72jRNtI38jwnJVpjstOjhbkafMx9tEZuPvfaZI7K2U++zqs+Ij2i3db1tJIn+JqmThn6+k34rAAAgnyeffLJGaJa+wN57750Izfvttx/1ZQG6GGtPFBGAi6xTL9KnFGHFRi9Ls7ZVlm1ko4+13yt9UHWSVMdLeU+WSxN7T+elydiF9pfTRGSy9QD0n1ic9l6RIIZm7DsA9B6Izl3MxhtvPJha++abb04EaEkRJiKC/mg/++yz4ayzzkrahAkTkvTb4r09ZsyYdu8+APQw8huk4k2WqFylmJxXL1ne6ySBKDawIedEBifkd1zqhUvKR5nXlGpeALOvNVrHpleXbeZFE7fCsNDB3bRUytqscGwjVGPCclaUsn+NmBwfuKpC+I2t245zbkXkmBFdxAjPGlzUaBB14NB7Vo4ZAAC6C/n9FttYhGbJWkS2CoD2PYtil1QZTdwKNGJZ7apYWmxrn9nSWJpRy5bfknkRiLWfKfPaVEzW5bb/3Um2LQBUJxaXjS5uh1js8RkRfNPlI0eOTMa61EGI3zGA3gTRuUeYNGlS0n7wgx8kqR8l/fb1119fk2L0vvvuS9oXvvCFGm9uGUQFACgzMJBXM9nWnq9CKMurmdzM3zE1BLSelkQEa1Swnfdpn6VpKmkbNaxN15WoZfs5HXjJIi39cxWUrT+szdfa9XWP7bbLkiUod3sKt6JCcKMisQr4nYRP3V6vSFxPOvVG8Q4eAADQHXz+859P7OAtttii3bsC0HeIKCt2j3Xee+CBB0Kn4csF6WvZd7Hd1AZWJ2vbL5TSK8OGDRu0UWz/W2wXjUCWdYYOHZpMVUy2fXiEGIDuFIvLCMbdJBbnvRc7RzpepuNeMn3++eeT/wJFfgcBoPdAbewxxPtRvLWlSc3Bn/3sZ4kA/Y9//GNwQFY6xVdddVXSpG6VrCvpt7fZZpt27z4AdIiYnCUoN0NMThOV88Rk3W9NVWaFYCsM2/esABwTg2NNvdjrpRFv1FgqaD2HPvJXBTBbl7ZsSzvPfuDFRxXUK/rZ9NedUhdMU9WVFX7LisSdKAQXIXYvFBGOO9HIFmLGdNpr6TdJNoK8ZwYAADqTb3/72+3eBYC+RTPTVIVmRypSa1im+v02ulrn1d6TeVlf7F7vXGztQWvP+n2Sfr4KytKk9rJMRZBGUAZoH/ob0Gh0cSfYsUWE4SLLG0XOhZaAswKzOhh5/LIq/xMAoHNAdO5hpJ6zRDVLu//++5P025dffnmYPXv24I/8vHnzwve///2kbbbZZkn6bVkfAHqHIjWTqxSTtc6UoCnF1JvdClaaNtoKxCoEa5SwFYY1YtjXWtUOv/2OdqKDFtYo8amjrZhqm5w7Fdt1miUgN8tTN+bZ36zBoKLHIus2Q/j10cEy7cXo1Zg3dr2vO+E50/sqTyQu8roMUtOZlNoAAAAA5fE2kET9jhgxorBoHLMjFOmjWhvRZpfS+ZhNY8VlnWpqbI8KzWqrSdPIZmlyLCI2y3HhmAjQnFJKjQjG3SIWFxGMW42cOx+1rOKyX882vXY2g6DM6/9BL469AACic9/wjne8I2lS2/lPf/pTIkBfffXVyZ+EdqYffvjhcNJJJyE6A3QJRWsm6zOuntyaCszW+I3V+/VptG2H3YqqOq/rq0Efq+FrW6dSJiI4lhpY0IEI3Z5HOtZaI1ZbMyN6rYgcm9ZrfMk+iwDna43JaxHntDZZFbWD+9UY8UZyvaJxJxjYQhUiMXW6AQAAALoPsQ+kKePGjQsbbbRR7ufSBGU7n9fXlW3Yckg6b8sAqZAsNozNvCVNbBoRlNXGUTuHNNgAjYnFRQTjTrBl64ki7gSxOA2fzU7n5XdV69OLqKx16uV3M01Its1mfJBxIW0+21vVmS8AoLMg0rnPkD+4ffbZJ2mLFi0KJ554YvjRj340+IMPAK1FOmXeYPadO5236Wo0CtgKxSpCWyPcNu3QxYRfH4Wry4ROrZnb6vTS9jzr+fS/mzEjIiYwV21seEPBp6a23vg+kjptmU5lMEU8+GWARaY62CJTGWzpJMOp09N21fO6E/6bfR3tekRiXQYAAAAAUKWgbJG+s02Jrc1HKYsdo7aZvLYljNSRVpqKzD6NNkC/iMWNRBd3olhcr2DcTqyo6zPTlVlm5/U31pefK5MFUTNWyG+mFZjl97LoGGInjHcAQPUgOvchM2bMGKz1/Mgjj3SkmATQaYjgK44aXti76aabaoxiaxx7g9mmn7Ee1rHUtV4YLvraooKjndpUZK0Uk+sRfosIyM3AC8xl6jnLuY1FMAv1poXWDrser07tPWCF4rJRoHYfrAdqP0YYV5V+uhOMa6EKkZioYgAAAACoAhU21J6eOXNmUgquXtTO9tGUaodJLWUrKHvE1lFx2UYvM0YGvSIW1ysYd4I9261icZ7YW8+yRoRZzfLgS9gVHeOyzjg6RqTzMn5kyx6kzesYm+yL1rXXKOl+Gm8C6CcQnfsEiZK84oorEqFZRDLbgdA/L/HgPOCAA9q4lwCdy5NPPpkYxFbcffrpp5NnKy2VrXSqbMexqtTSaWKyn6+XeqKD8wTkTjXcfV1lrS0jEb150cHym6n1u6TJoIYMVMQEZU0hlBXtbputPZZWU6wINq2RF5PLeqB2Y8qusq87AV+rrogoHHuN8QYAAAAAnYSKHkqesKWlfKRva/vu6hSsdlse8nkvLpOxCXpNLI5lYmsHMfG3rGDcClvWZicrEyGct6xdaOZDm+FBS+4JPhBFxoLs+KEGUNgMD5rxTua9kKzO6TZbRSyLozoGKVq6T+mEexYAqgfRuYeRH+7rr78+EZqvvPLK5MdelyvyB7HLLruEyZMnhw996ENJulQAWBr1xJPaJvocSUdJhOeqyBKQY2JyK9NLt/pcF4kGzooOjr0WbBryohHMck60461NO91FkPtEPUq9oKyd8nqRffCCsn3dyWngqhCJO8Ww1me0EZFYX3fCMwgAAAAAUDU24ljTXWs0stoutp8vtpKWmLLoZz0+NbY2tQUBWiEW1yMYt9umjdmzeWJxmj3bDKpMK63Tdp/zLOy59WKvTY2tpfRkjEkDKGQ8SH73VEiOZTlURxz9vdSp/12132XHtKy4XNR5314H/Qx1nQF6F0TnHuShhx4Kl1xySbjsssuSdEWC/zPdYIMNwuGHH5609dZbr017CtA9aGctliUgD+3s+bqo3kvQRt22M710lpd5o8JvkXUbNVS0jpfWxJY2b968Qp1h+W4rLOs061zbWtpeUNb06fUinqZZ6a/l/U6q7VREJNZlnUDseawnJTVRxQAAAAAA2agtI/1nsQlGjBiRZIwSYXnhwoWJqFHUxiY1NrRSLO5UB2g71tRIdHFV9qymTG5EII4t61T8+Y9FAxdZ5ucFEXXV6UanEgRjAyc0s12aY41GLouobAVmGXuTa2XF6/nz5w+WAdQmy209aRXr9d6PvbZNz49GVsv+aCY/ew8CQO+B6NwjPPfcc4nILGLzAw88kCzznR/xIJVoZolq3mmnndq0pwDdiXaErAAsnSbJDmA76lrD13bgmyUQ2w5m1cKvX9apHUH5nZMOuAjLOpVWxDCRY7LRy9JkIMRfK/UcTUt/3YgRpOc7Lf11FcafN/yKisKx1+02qgVruJStU+xFZqKKAQAAAABag3XKFRtDBJAZM2ZkfobU2JAVLVlvdHG77dosm7bM8kbGC/RcWmGxUYG43ec1izyxt55lVYwnaBSxF5izHPW9AKwl4LSEmgZz6FiWBGHYtNs6nuXF4jLXT47dlqTTsUNZpstj44gietvgiU6+ZwCgfhCduxj5k/jtb3+bCM1//vOfa9JTKPIn8+53vzsRmqVes/y4A0B5tLOkNaOkgyWOHGusscZS66YJt1VHB6ug3S9IJ9gKyyo0F+mkag1m2+QcymdVPBav0QULFiwlMDdST1k7/mnRylnXT+uCNyISd5JncKMisff8BQAAAACA7kFsm7TSQqTG7l+xuIxg3M1icb2ZsqwoqOckJhSXFYg7lVimwCIRwnnLWo2P/PXjWDovv4tW9M2KLJbjUGHXHqveE9pkm408KyooWwHZNl2e9Xl77u21kLE40SY6qcQfAFQPonMXcssttyRC869//euwaNGiZJn/M9lss80SofnQQw8Na665Zpv2FKB3GDNmTPJc2Y7T+uuvH44//vgaIVg6XnSaGkc61bZTLs3X8kpDa9hoZ1auiabcFhFZhOXZs2cPispVpBz3Ka/1PokZ1y+88EIh0bjdBrU3qhsVjQEAAAAAoH9RkULtA0mtLTa1pnzFju480jJmdbNY3Eh0cZ54acVCex40Q1qWKJz2fqc4kceoN4V01rJW/w6oqBu7HlnXKvaeNBl3ElFZmo5Bac3lovujdZi16W+nBmI0ek9oumsZv5LfXhscIa9l3jv+Z11XvWay7yqc+wAKfW3Hu2Qqv/8A0HsgOncZUov5qaeeqvkj0j+u0aNHh4MPPjgRm7fddts27ylAbyEC5rhx42qWSQ2q1VZbrW371CtorRorMEunvAjqaSkdXhV7taMv4q6td5OFTwklU2uY6rZ9x1sNSNn/TosqriKymIEfAAAAAACoAq0rqjaG2NMyjgXVY0WwRgTjbhGL8wRjLxb7iFIv9saE4iKicbvPVxoqYjaSVjr2fispKwAXfa+ea2Yz5vmU1Vnbs4KsNI301bEXvU4y1f2TeVlX19GMefraisIqUFshWURdmervrwZm+Ovnfwe8aCzjdpr2O/a+vU76nh6nnX/22WeTdN86diYZJAGg90B07jKefPLJGqFZ/ij23nvvRGjeb7/9EvEFAKBTkU64j2BOS7FmU7BpJ9vWzJbfQhWrveGQZ2ho51075T5lkHTEfXSu70xXjTXk6hWJ22H8AQAAAAAA5IFDa3PF4k7KmuXF4nqji6XZSNSsCGEbSVlEIO5Uqq473EpnchVVmyEOtwObMU9rL6eVYdOx+lhAgw1m0FJvVvy1zQvJ9tqp6Bwrx6eBEkJMFLbBErH388TymIDsW5FADE0nLmh2QADoPRCduxD5sZ8wYUIiNB9yyCFh7Nix7d4lAIClkA65r1tj69XIfMw71EYnS8dZ61fbWjZFDGmtNWOFZCssVyXOViESE1UMAAAAAADQnaSVTCobXdyJYnEZwdim2c1LIS3O5WL/5wnE7T4nWXiRt5G00jGRsVk0KgB3W6S3YgVdnx5ax6fkvtSpNP2MjiHJuJIVbK3Tg6wjUcWaqlqnRcae5NylPVt2P/V7ZbxtyZIlNftRBn1G08Rj+zq2bVu3WaY6bmf319eelialC2WbPnU4APQWPNldxuc///lEbN5iiy3avSsA0EdohzTNUJbOrqSzlqk2NSJ1qgKz7chaT03tkEtH3RpasbrL8r4VkNWz0y7LMta8kVePSExUMUDvEas/Zdvzzz+f/NbpoAoZZgAAAAB6XyzOE4y7TSzWVL76WZ3mRRX7uqz+/U4lVpe2kbTSsZTdVeOjZqsUhzudInWE817H3pNzKmKtNAmKsFMVmW22PV0mTc+bHcPSqGUdz4o5Vsi29bP2ufQpz21K7axsgHlkicc+5XXMaUIjsrWuc+z92P0vy33gh38t8zfffHPhMngA0L0gOncZ3/72t9u9CwDQRcSM47Kvrce1vCcCskYxi/iitZNj3pG+E6q1ZGwqoBhWVFZBWTvy8nmZ2lTbZaONSe0G0NvOMb5lCclF04oJixcvTgYmFH5LAAAAAFpPzGatJ7q43WJxrMRSLCOWF4b9spjQKFN1APfiY7uPO4tG0kqnvd/MPnsVqaO7LcJb8GmgqxKHq7hecv7EZpNgCBm7WrRoUWLHaXCEispWYNbP2cx6WorNirDS9DrJNnXcywdGqNiq416NOCmkice6v7bFflM02tr/tuShEd5FxOSix4f9DNAfIDoDAHS4cFKPSKzLGkEijKUTrRHMMhWhOSvFjqK1alQkVqFZO8DSMV155ZVr3pcmy1RU9h3iZnsSA0B7sb9lRURiv047vPY7fTAIAAAAoJOw4ojYmyIG1SMYt5uYsKNimRWFbbP9Rl0WE4rlvHRD9LBNr1uPQJwmPDY7arhqcbjT8YJuleJwu5FrIONUmo1Kfk90Xsu36fNkHS7sdVRx2QqssQx8KrJ7sVWmRQTc2L7r/WPFY/9a1tPzrd9nHVLKkiaOx4TlTrjGANCdIDoDAFRoxDQqErfS69imCxIvUJ8e29ZZsR6nIgiLOGxfi8Asy2QqovHQoUMHhWRb00ZbPZ1yAOjOKOOiQnI7BNy0VISaVswvGzduXOJ8o7/5GOIAAAAAxRCHZok6VMR+fOyxx1p6+myEnxeFLbH00yom67wViTs9erjeCOGsZc2IWLQCb5XicCdfG6Vsquii63ZbZKm1D+XZ0rGqhQsXJoKy/I5oE7vMjqdlXWdNi611l1VYld+hrEjevJrD1ma0ziU+CtmK3LKvKv5WgWwrLxJZ51s5FmdT8mvwiow1Wntaxg4BoPdAdAYAKIh0iqRjq53G2bNnh7///e8d5eFqjQwrZNt56bRLJ09rLKvnpxolw4cPDyNHjlxq2yowSxs2bFiy3ogRI5JOuhWUNaIZALqHmDNMmWjjdv0G2giTmEicJyTn/VbJcWmtL/n9V+95PV5xrAEAAACAfOoRv1SYsJ/3QrGNJI4JyH57jdRLbTa+zmujaaWbkTHMRw1XKQ53Oj66u4w4nCcc90P2Kvta5rWespZw0wAIGa+S96TJ81rm3tCIZRmXElvNBkjEhFlvH8ZsSr1H9fisgKyBHJrGvghFhd+8SOSiwnij2GsXqw2dtizmBLBgwYLkGityXQCg90B0BgAogXQkFe1cVh1pF0vTFUvb5TvuMrVCsnTwNKWQdOC1+Y6w965UD1AVllVcliaddp9mCADaiw781JOSulOjjIsKyVX+FqknvTrm6CCIRX5PrcDeDYNjAAAAAJ2A9K9EcFBhWGzLadOm1di5KgJZUU5sU1nm+33af21XFGvVaaWr7ttqRKWWxqpKHO4Uh/ssGhGAs97rh3EQm8EqSzROe63Po82s5+fV5hL7S5drMERR5LqIYLnqqqsmY1c6fiWRs1q2TQVZb1/KtbQ2tN8/u19V23tWKM4Sk2O/eVVe16IicrPHCrrh9wQAyoPoDABQEF+LSQ3gIiJx1utYR1JTCWkToUM75doBtqjAbMVlabHOoU0rpKmFVFTWJsv6waAC6ATSatUVjTZul/Dpf8vKRhu3y6NfzrcOdFiBueh5tANQVaVEAwAAAOh1xDa1/T/pk1mn7jxidrUVqNNanrBYr2hcFb6Wc1XicKenlPZR3VWKw/1OVnRxnmhcRASUdb2YbEVbFZ/1/SxxWcfZ9Hm2zibSRFi2wRCjRo1KMvOJ2OyfRb8/+lrsPS8sV4nahVkprvV1o+Nsel7LRh23aszAOg/58QGZl2snGcT0ujc7ShsA2gNPNgBACUaPHj3YOVpzzTXDlltuWdf5U+9JMbKtuKzLsjqEapyrsKzzalRqh1c8PKUDZwVm8faUzrp03LWJwAwA9VOPSGzXa9eAUFmRuJlRxs1Cfh9lkEFSeGndLxWY1dtbpz5NoCzX1Gz6G2rTCVY9WAEAAADQy6gQkSWIqvgUa5olx07T1rNClM2u48UQL4zYZXYbvoZzleJwp9OoAJz2XjfYEt2Qojr2XqPf7QVkKxirMG2fYRsxbOdlHRUVVYCVcSqxr7SuskzlnpDoZIlWlvc1WlnHqmz0sRyflLqLRVErdt9iGRHSfn/schVEizR7L9tIb2k+GMTWfM4SimPXWs9po8eXtq6dt8483ukmNq9is0057rctxzF37twwf/78weNYffXVo/sKAN0NojMAQAmKes1qTRcvJtsaykWQTpmPYJbPWo9J8fYcO3bsoMCs+6heobYRlQdQPMq4qJjcDrIiOooIydI6GTsYZ6dp8/Kbq/W/VGQWcTmtlpRHBzykaTo2+Q31g2FpaR0BAAAAIBuxW0VMUifu9ddfPxxwwAGDgm6Z9K9pfTAv7Eof0TsV6udjDof2PUUFUitG2zS9scjqVmMF+DwBOEvYt6K9dzLNE6qy3repvst8rt7vq+pz9X5HTDSOlUOyIq193wuLlkYER70OVqxVe0n3UTMSxFrMRvaOuDbSNebMIbaWd/aQz8h25syZE5599tncusD14oVku2/+dew5jh2vt0990/f0Grfa8TyWWjzv9yvLwdw6YKsTTuz47PHb6yglFl544YWa8wcAvQeiMwBASdQIFTF43rx50YjlejqQ0hHTKGfbMVMxRAz0tHrKIpCosCydeJmSpgb6gXpEYrtOO6OM60lJ3alRxjb6I00YLrMsa7BEf3NtzXpfciANrR+oArPOZ4nwdrBOo571/PM7CwAAAFAMLW2iJavEbv373/8++L72AW3T5doP1HkvdNi+v24nJoBULeSlbcOLdb5f75tmK7Oir87byO7YezZq2DrFlt1/qKWI42va+60+33of2GdF98M7Wdj7UZ1sfVS/jSy2qbEFe9+KLWXtVEU+H4uEVeG6yoxR+nxkCd12Pg37O6G/L2mCsf+taTZ6jEUEY/+e345inXz03tAgl6z73EeD+3n7W+SjuTXyW2x4+zsNAL0HojMAQEGko/T8888PGnFiJD/55JOlzp+KFro9LzCLWJwlJqlgYqOXZT86PWoRIIaPZigiEvtl7SCvblwRIbkTaEQY9u83w1hURxwvMOcZ9joA538rpe6XDowUSRem+2AzV8h7NhKAmnEAAAAAxZCUquK0rUhmmuuvv76pp0/7hdqsKKeChyxXu0KFEBXGdRuCTe3tBWUfCZ0Wdazbsilo7b4WFZKKRiX2MzYi00a/F7VzWk2aTWLTFluhzjtXyHHqfRC7L2IZmzTSWTNE6XZVpJWxJmm6TdmGj9zWZ0jHujRtdprNmyVU2nndB1sb2Wb8U9FcnYD1mfXjbFkRx3Y+tp96HnUML+t8FjkmW7c6K+LaN5+O3ovHPq152rwdU5HP1TM24aPlbcS8Xab3hZb502OXms5iW9vzCwC9B6IzAEBB1CszC+2QamdbptoJ1E6YpH71np2xaDn5Po1a1qadNYBOoB6R2HsGt4NGUlK3K2WeYMXOeoRhv6xTsAMe6k2vZQjs4Itke5Ca9D5yRK6dvCeisrYizjjqxW6zVdisFTEPfB2QUfDMBgAAACje56sSH+nr6zn76OAiUx/1qfhU3Nbx0vavfb3nWFSg/z7/vdrH9evaY9L1bCS0inFq18hYhC63Ap5dx36P388i8838nOBtx5iIHBOV9dz771MRLO376jkmxdqLGrUei7j1y3R/vC1k5xup1SznQWwcFajt9+j9o/ioVGvr2DEuzRply7sVISYe23l7b9rxhFiKfXVQFucVO+6Qh7UhtWZ0WXzWgrRrG0sjnkZMHBbbM+v4q87cJvsQE5DV/lVHB+/0IveBjFUWGTeRut2LFi2qsecBoPdAdAYAKIh6LwvSgZLO0tprr13jzamisjbx5C7S8ZXt2dTYKjDjsQzNwnoB1xtt3A50UKWoUBxbp5WUEYHzhONOSovnU3ylzftlcgwSrezFXnXWyUN+a/W3UlvaYIGWQfBiss4XTetmBxj1/k8bkAQAAACAOKNHjx7st0lfas011wx77LFHVICNCcC2H6/9yqym/Tid2vc0Cq8qwbGIcOr7k1mpe+txbNQyNNLqqW+r0aNepI4JhCp+x9J826medz0mn+45yyYteg6qEq6y7Mwir9PGbtTB1orJIpTa8myNppu2Ucje5lFx2Z7brHOg5d3E2dcKzWnn2Ds8ePHYPsf+GtsSc3ZZqxx7iwrGflnWOJ0/RrF9s0RjnW+2re+fq1jkvLXxrYhc5vmyJamk6bxO11hjjcFIZwDoXRCdAQBKMGrUqGSqNaikQyVeeiIwixdikc6xdFRt9LK0ej0soX/x6aLKRht3UpRxmYjjZgt9sYiFRiKKO4miwnARMTnPSFRxWX8btRWtvWwdcWyz119FZSl7YOs8y3fqfKyeWd5UtmvvOU3bZiMWFIxlAAAAgGKIiCVNWW+99cIOO+zQttNnBWg7jS2rZ52y2/P7FrM50uy6rDTBWcfvU3x7dP9UFLNpnb3Q7pcJsRTjMdIivrOiwf1yFcysWB5Lz+z79zLVqHAf+VsEjUi1IrKPVq4XPe/2WAW7bbG51Km3KLIddfoVcdGKy3o+rXjsswj4VPE65iD7ZKNzW1nvuEzUcV59Z8GOp6iYH0tT3Wrx2KfpVgec2O+NdfbQzzSCjUj3YrLO553XImMJAND9IDoDABREOmyaGlvmpVP+1FNPZX5GOl1eYLbpnKA/iXl0l4k2blfUq/X+rifa2NciqgJbx6qRVNOdGE3sa8GVFYZjNYqbgWZ4sOJykdrLgqwj94cf7JBlsl3ZjmSMEAFZtmun8r5PdVj0+lmDWTNVqKGcFangz2Mn3S8AAAAAUJysdNrtoCrxW4VkbdKf9tl/1EHTp3C2AnZMDG8UW8c1VvfapwH30dVZNk+arannQWyIovtoI7W9jS7bsmKjYL87TRDXZsVAjS5V+0MFO5laO9det6JOvHosNh22zRQVS0mv+6/fK/dOq2xkG3lfRkQuIh5bUTgmHsfmWy0ex47dC8ixFOl5jiZFft+sk4EXk62ojFgMAEVBdAYAKIh0sKTTnZf21bZGPQmhM7GiZT3Rxu2KgLVGTT3RxlUNyPiaW41EFHdiNHFVEcWdZtSp483ixYuTlHDS5LWtXZfVrEe9Tcsn2507d+6gx74OBpSJ1PDYqAXvkZ0lKvuBMD+V2tHy295pg5QAAAAA0N3YWtQWa0/qax/97O1Nm0pXMwhJy8Ju19ZzjQlzVnj1Kc3TxFY9Ll+n2q4nWDFdhVZf2kejb2P2qnV4zhIkrXjn69jqsqK2Zlo0uj0fOu9tbk2Lrt9pbSL7eSta63lS1M7RIAcVmNUm0s9a0Tp2jYpEmedhnQfKRB3nbd+LxyqIZ92nrRaPswRk74yvEeL+2mvUuryuYt+9TRwTkxm3BICqQQ0BACiIGi1quK266qpJTWdNAZvnYQmdH2VcVEjulCjjMtHGjaQxskZ/FRHFnRQdmiYw1hNR3GkCZFoEeJGpRiyLsCxTTVldBBWXbVo7NaytIV2FqKwR0uqxL69lageiykz1Gto0cXaqBrnexxjoAADQKv72t7+FP/7xj2HKlCnh4YcfDnPmzEn+D6Uu7o477hiOOuqosNNOO3FBALqgLFKZ161CbRyt5Vq0rrEXi7MEQLusqKAbq9dtI7H1ta4rNou8VuE2ZpfaNMh6DD7yVwVhK0Tb62PTiXshVdMMW/tQxfxY9LmPWI+J1Tq1UctqC3mbRLYhdlwjxER9aWmpy+U9rf0cq/Wt94aeR58C2jcdd9H305wUqsTe23miuZ23+2KjkK2QHHMoaARrc2dFKHeaIzsA9AeIzgAAJRgxYsRgJ1fqO6+22mqcvxYT8yIuE23czijjMiKxX6esoGkFRC8WFxGG7bJOiia2gwD1CMN+WacYYVlpwuudFkHW1fR6Wg9MB2qKfFbw96hM5XnzIrWNctBBCX3tpyog26YDK+rkU+T62UE+O5V988vsQJgduLLLZ82aFebPnz84SCL7AgAA0Gx22WWXcOutty61XPp4jz32WNJ+/OMfh8MPPzz87//+b/IfCwDVYPuD9YjGrXa4tdHARURjH4HZKvvIpq7Oq5Pr++k6nxapnFZb16Ynjo0XWDtYxTwVdocNG1aTtUmaOtbqd6mwLA67Wn5IbSwVGq1YLZ+X7VtbSK+BrZGr36dBEGVSn8eiwfOixfMc1q0YLHaVHKsX9a1dWk/N8TysEO8js/V+tufNp2uPzftr4NOP670lx2zvURupXFV0cqxesp12q/PzSSed1O5dAIAW0J2/UAAAbYJo5uqEtXrSUndilHFRITnPeLeGmx5rWbG4rODYKhoVhu2yTokmrlogbsV9beu36eBHXk0w62Fuvdqt4a7XpUhTdMDG1nHWqYrRfj/090AHbbJEYxuBkIYdrIo19cK325DU4rbMQrca+wAA0F3MnDkzmUpU84c+9KGw8847h3XWWSf5n7r99tvDd77znTBjxoxwySWXJP9fl112Wbt3GaBjSBMai4rIrXbAVduzjGgcizzudNQ+EHvCoiKe1pq2TY5NpvY8qQCrNrBNm23rVtt02bGoVWvX6HbUVnvhhRfCokWLlnLsVjHV2nR6TFbQlCx51p7VeXlPnFgle57aQiJCexvDCql23/02vSOv1mdOqwtuz5UtcWQjcq2Qb1/HosybcY9kjbFoWmu/Xt4zoCKxv+dix2ntwiyKpCmX19YO1lTo6tzgy0HFxG+9/2SfsgRyAIB2wkgZAAAUJq1WUZZI7Fs7iBkrZaKN0zruaSKwpswqk366k1JO+5pZjUYU92sUcSuJpYHzgzWCGuFSm1hazCNdBzU0fbUOgJQZwFID2ovJdvDDCsSyfxIJkBbVUIY8MTkt+sHf95pa0NaGkwgH8eTXgQMiyQAAoBVsuumm4Rvf+Eb44Ac/uFTfarvttguHHXZYkmL7n//8Z/j5z38ePv3pTyfR0QC9QiOicTv67o2Ixr0sGmm5HW0xcVmvl3cqTXMytbaCRhGriCeZ6nw9ZCu0qnCsgrTa5TZ9s4qzmh5aBW6ZesHcY53J1R5SgVntLL3+gu6jTDXCWm2pvPrA3n6ydbfTzlvas2HF0TLE0p6rEG8FYRtR7IV4uzyWTj1LRI8J4V5E9mJynqNyUfS+s2nH/XzMYdk+E1URSxfvI8LT3mvGOgDQfyA6AwD0EfWIxO1MDaaUFYnTooxtPeeYCGzT7haJKO4kGhWGvSHYTqy3eBXTTrtWgjeu65nKddJ7VtOaiXCrXtvyPKjhrVEB6u2vgxA62CFt+PDhgwMfWcj5tF7lsfrJ+jyJ84VEBlQx4GcHSLwnum167N7ZxEYOpKWSs2hkgk1jtsYaayTfodev3c8KAAD0B7///e8z3x87dmwS7bz//vsnr6+44gpEZ+g4bHSlzEvfVWqTFxGROyFFdRkRuR9RgS8WoawCs89YlCaEWsHUZgQTvLDlo0mleRvQOtVKv16ii60QqI67NspabSxrU1oHZBVTLWpzaPSqlgeSViRrl+6DnCdNWe3Tfvtma1MXjQSu17khJnznzTdrfMFeq7SpXD8bJV60LrhPYe6f8djvQuyzZVOhV4U/pnaTJUivv/76yfMBAL0FojMAQJcZcWVEYt/aQVZKpDwhWTujRUTgIqmoOzGauF5h2M+3i36IIhbSrkU903rESnmuRVDWpgKzGNLqoa8Gtq1rpqi3vwyASLSuRvHaKGfrdBETxe09q/skNOqV7QedtPmBAMF69Mu8jQ6w5zcLHWyyorIXlzWlmUdS4xHdDAAAnchuu+02OP+vf/2rrfsCEEMcEW2Zkvnz54enn366bSmqs97DsXBprKBsI5RVILVZi2w2I7VX1D7xzsF2Xu0ML/Bp/9z289NSTnsx2YqCgt1vmcq+y35ZW0ftDJvxyNrfGqlsRWWZt+KjHJeWNbIitv1u6xSs56jecYsy2aHscWSVPVLnZG3+XDYDm7UrJibrfBFBNW9f5f1YvWQ/X8UxFY3Uriequ+w6rUavVWysp5PG6ACgOhCdAQBaRD0isV2nnVHGRUViNdCtMRirVWwji/PE4k6iUWHYC3jtgCji+kTiViHPiwxCqLAstcMWLlw4GMFsjW39XbBOFZrmzdcms1HRKirbOmNaO0q98qs4Zr9f1sjVeXnfDvDIYE29z4g9Hj9QYBuDiAAA0IvIf7zSbFEAoB7K9i/zhOEsEbmXU1Q3A61RbIXQJUuWDNokOh+LYPZ1jW1UsB3DiAnCVsjU1MNZ4rF/7R0M7D3gU03rVNYXm0NKDeXh7Qi1N2w6a7HXFixYUCO25zlSy/2pYnXa9fBjQjbFvHXW1pTc/lxkOf9nIduVay4tRux8p4n/fplGJ2eJybbWciPkickybdXvhE0z3Qn/z50ifmsGNQDoPRCdAQDqTAcmRtfcuXMLC8ntwHr/pjUrqlkxRufToozVC9e/30meijZas4xInLas26OIO+36KGVF4Lxpt4iKYlQ///zzgwMVIi7LaxGd1fvdCrc+vZwa8Wo466CN9dpOa2XvZ5tiUObVIcRO7b5ZAbxRvAd6mrDcLdcdAACgGdx8882D85ttthknGToO6UeKyKYCjNTbXW+99VJFZKgGrRkrQvLixYsHm0SeSxNB2UbeWiHZOpBmoQ6taptYgdjaK1listozfr0sUVO+VzNCqQ2l83afbaph64irTbepwrLegyqGNhMflV80fXXsGbHO/Wm1nGPLyjj72zrJdpmOEWXVUNYAhVj0eGycygY2KLLci8leVE7LWgW19xwAQLNAdAYAKIh0pCUFmDJv3rzw1FNPNfX8ZXXA00Ri37mORRfbZZ0UTaxGSFURxa02NIgi7uwo4lZgHU+kqZe4/HaIqCwCszYZECnirKGGtTYxpldZZZVBkTkmxqadVzugF6tJZT2PdZBJfztiabvzPLmziAnjZY6l2di049p0YE4H31TkBwAAaCfyn/XNb35z8PVBBx1UehvTp0/PXadTy6BAd6ApehUp+TJmzJi27lO3l92Svrn0T62YLH1VjU7WtNcqJNeD9OttJiUr0Gq0rn1f0zJraR+ZpqW8tsuy+vw2G5TYVXJsenxpmePs+IfaWjZltMxr6Zwq7I20COAi0cBVofZ1Wcdfe095QVruHRXyRazXEk/qqKDrF3Vu1/s2hnVAsPeMXC+JTvdpvu29oxHfNpMWwjMAQHtgpAwAoCBlO6w2ZawaEirG5InFsShjTUPdaYM9VaSabocASRRxb0cRN4Iaq1me4WosqwEuAx5ifMtUBntkuQyEqFBbxAjXAR1pYlTLIIiIyzKNibOxAYy0CADBppezKcxk/4uIyUXRgY68usmtfN5jArIfWInVlPaI44BNNWcHTgEAANrF2WefHe66665k/t/+7d/CNttsU3oba6+9dhP2DADSSItKlalG7Yo9oU6P2lT00/rAjWSy8lG2KiRLH1dsELVHvIisom3MDiliL9pjl+O0dooVlK1wXlTYVJtK9lFSaNv6xEX2zdeKLhp93I2Ro1m1k22NaUXsN70vvN1sr6lPDy7raYCBjXb2AnPe9dH7vig+g0IRJwCipAEAGgfRGQCgBBKdqKKxCEvPPffcUkaaTUNrO9mdghqW9QrD7RIhiSImirgsWR7beYKyft4a4tYgl6aisk1FVzRzgPxWyCDI8OHDkybpBaWJAS+CswyMpAnKOqChx+f3Tes/21almJwXndzsAZeYgJwlHpdNGVd2XwAAANqdVvtLX/pSMr/aaquF888/nwsC0EJ8ia00G0MFM20qLOu8jR5Vh9BGxxGkXy4isXdolSaR5irK6jpqgxSNEk0Tj9POhY+gtWm91RG2KLJ/mglK9l+FZZnqmE09Kau7UTyOXZe0esl2WaP3l5xjPfdZ6a79OS3i5J22rAz6HXLMZbApwMsI1r2WxQ0AoF4QnQEACmLrAAliFEmK7bIRz96giS3zndV6hOG091shEtv611XVI+4k4V4pGyVMFHHjImNMIE57L08QVNHWGt626UCPDhJZgdkOiGiUvhqamg5bB3BkQGfUqFGJqDx69OgkjaAM+GQZpSome4HbDhRUMRDlI6yzopObMQDjBeQ88biZArKgg1Nptebk+km0iXroM7AAAADt5KGHHgoHHHBA8v8ofY5f/epXifBcD88880zuOhMnTgyzZs2qa/sAnU49Api1G/xyLyZr1Gg9fVrb91S7UkRiFZOliYAsTWwPbfJ+kT689slVoCvquJt3DLo9G5mtdlVR5HjFdpImxyPHqK/T6j/3sgDo7ddYhHIV2fGsw3GamCzTesaXrM1VNnNU0WfTLytjN8t9XVao9sdVNFK+VxwdAAAsiM4AACWQzqAXn4sYhd5AVOy21NtTO53akdeaNXmtEaOqH6KI0yK8G5lCcbw3c9GI40aEVS8qewPdb1vukdg+CXrdZZBDDURbw0yeVRkE8RHL8r41xHUQSoRLP1Bgmz9mfW2Xx5bZ92L112xqbh+ZnLZtPRd5+xATkPU85wnIeceSNZ91/Naxx3qsZzW7Pd1PGRyT5ZriT7+Dms4AANAunnjiibDnnnuGBQsWJP9fl19+edhll13q3t748eNz12FgHLrF5qhHlMpLe22bRimnrZMm+tl01nZ8wDqu6hiA2B0akawRyiq2pjmwemddydRWJPq4UUdWLy6rwGzFZds3FzvJ1uPV8Q85Lj1uFdG9PdWraHRyXoRyFU7H1i5ME5U71c6pV6QtmpGgkWfDZkqroh54EcEaAKAT6cx/EACADkSMobe85S2DqZrWW2+98N73vncwCldFF2vo+lbWQNAoR4v/Hp3qPto6ObaGtBqldpndVqdBFHG+wFbFsrKfUUPKG2e6LGtQo+j+FN0vK4iquClTHSiS99McP2KiqBqH8jlr1KlRrss0hZuta6YGn4iSUvfX75POW4eMLNE0a7ng9y3NGaVew1edR/Q82Za2rJm/I3aQyovHMU/xooMRtgRC1rHpvER3SYYLvY5azwwAAKCVzJw5M7z73e9OpvIfedFFF4X3v//9XAToGWw/v4xQlCb2ZtnoacJy2joytU7mmk3MCkL2PRXzrKCnzqkqIKvDqtgWWrIrzaYSW2Pu3LnR89Fsu97aTXq+VQjV45ZjUFHcO4DalN+a0tum9u5V9JxlicnW8aFe/j/27gTeqnH/4/ijQaWBJqVRJaVUQqlIIWOXiitjEZnHi1u4hri4GTOPpbhC1zxFUSFTSaSEEmmURqUSpf/r+9z/s+86qz2stc+e9+f9eq3XnvdZZ+1z9lrP+j2/38+VHE+UoVwMQXw/93cY9u/MOyYOE7AOk4jh/b4LK2hw2t9/vBj/BgBkDkFnAAjzpfn/sz3doFKDQ3+Q19/n2JtF7DLmvGWl/GV7vbe92ZjxsojDBBjjZf/6B4XR7nPBau97Rxt0u+d6B93eoLh7nvf53iXR7+INimUiOJuKgG1pPqtUc3+T3sVtz3iPZWr93N+Gt1S7u+6ChLru/nbc35l/EOlKY7k+x+7/LFoZZVd+zjtr2AU4/aWvtA6//PJLyrIDHHdiyr9u3vvCDhJzMYDs/X5J1G4g7Gx2932p79Igv2uQ0oCi57jvbzfpIVczAAAAhUvBpkMPPdR8//339vZ9991n+vfvn+3VAhJyx13uOF7H0j/++GPU4E2QY7NYgeRYQaFoASRv5TG3bv6xqZtg6h87RwvyuGpILpjsKgz5q575j0WVkbxq1aqMBY+j9a31XvcGwVy5bY2l3PbQkojLaPYHmAspuOwm+Ebrl+y9nopKcN5KVbEylBmbpF60cwxBeM8BpmLiTCzutRqnhhEmmzrZ8xAAihdnygAgxEGjyti5AYNK2Y0cObJElpw/QOYGre7AzHvpzTwW723vde9A2Pve4n6m9+e6QFw80QLlQe9zQTE3qPEHw/yBI++6IfX8QWF33R9c8z7P/d1kgjczNdpsd2/Wvn+ChveEizdjP9pg2pvR64KN7m/O/X3qxI/K0+m63st7ssdfscD9PBe09lYciPb/5S1v5/9/966D9//G+7/jPSEV733ErW+0IGqsz9z/Pt739gd1Yz0v1uP+E23xFm8573jv7Z+44x+QJ+rz7Xh/t3g/z/0NerPT/Vn0LnPe9S7TdZ08AwAgUxSkO/zww83s2bPt7aFDh5oLLriADwB5QZNAVZLaWbdunZ1E4RcveOy/Ld6xqzue91b08o41vEEk/3GcP5jsXdwxo7dVjX9StTsuduumCkhqqZPN4HG8QJJep+NcfSbus3GXsTIuo5X0doF2f4BZ2yqf6XOMF0x2wfjSci2REmUo094rv7jvhrD/B/7JNPEC1rHGwEEkE+CWaBPDg5xX9J+zdEujRo3y/rsCwLYIOgNAQK6fp6PrKrOabt5gm/8Azg0+/Ad1ogO4aAMTF0jzBvv8P8sbKHe/u3tPbxZhovLd0Qbwifqp5vIMyqBBsrD3SbTAsDe72B9Qdpf+94n286KVUEr0Gu99LivY+xn5JxrEOqnhHZDrb8ZdensXh10vb5aEd7KH+7lOrLJ4bvDnSmPrUkvQz8rLlehyJwO8i/f+aK/3ZhAEXfyTN7wZ26UVNoDszQgPKlo2Sry+z2EmSLjvxGiDVn9A2Zt14L7X/N9FmqTgv2/nnXcuUaqcATIAIFM2bNhgevbsaaZPn25v/+Mf/zCDBw/mA0Be0N+qJnAvXLiwxPHg0qVLSxz3iRv3eoOj3mpA/gpI3l64ft6qRd7gsbc6mXfs6q/C5Z306g/8pXpitb/CUqKMQ//vFI/GYwom6xyG60etAHOYoJOrDOUvi51v2bXeycrxgsqp+Gz9Y8VoGcr5tv2QXsmO7925ETfujfW37aoXeMfE0arLRQsS+yfzJPN7+RMRatWqZXbccceQWwlArmPPBgAhDpJcYEoHWBpk6eDIe8DlLt1gNFog1l962h18ibcUtffxRMFL/2OxnhfvNd4gnjdTNlbWbLTgl/9nROsvHW0WpP9+t03cIMw/SNN9rt+VCx66A3N/8D1VAeLS9PuJN1M12gxTb4lxbzA01bPgg57MiDer2mUWu9LwutRJUZcdHG0w4gYY8cqyuQG694SSTo7oZ7iBTrTgpffv0vUU089RKXxXzi1IoNSb0e8PIHsXbyl4//poO4QJIKdSJgLILgs8TNA8HRn27sRRtEGyN3M9WjA56P+468PnSiX6SyQCAJBO2t/26dPHfPjhh/b2JZdcYm666SY2OvKKC3i642wdp3urY7nxkXeioL/lVLSxtRv76f38Y2f/5ENv5Z1olbtSwT+ZOmj2cSomXbu2Qt6sZS1hgsventPeAHM+BEcTBdxiTU4IyzvZNV5Qmexk+EXL9k31kmjM7b57XLWHeNXz3HmLaOcDw4zt3ZjdLxX/jwByT+4fMQBAjtCAoVmzZpGBbJMmTczAgQNLzL4OMqjwl/uKNZswyH1hnx/2wDARb9A0aM/YaNtCkint4+fPqI5WBtw7o9gNBP0z2f0H7P7yz96Mb3+5Nm/gPF2CBI1TdSJDgwAXRHZBZe/1ZP+eXFBZi9bLlS/T+2rRz1Q5OneCKNHfh97HBZZd9nK0LFSX5RwvO9llUEQLmrps7UwGkCVM8DiZALIbBJYm6zqVvJke3u9M8f4fuv/BWNnkQbgJLt6TRN7F+941atQwa9asSenvCgBAIieddJIZP368vX7wwQebM88808yaNSvm87X/2n333dmwyCmuN7KOIxUQdZNX3fF1tGCyRKvC5R+DxGpl45ZkKmklqugUaxyW7opd+t1d5rI/wBzm+FzfE9HKYufipEo3wTdRuetUZScnCiZn4nNG5gUN6vrPDYVZcpG/3Zafm8DtPXfmb2fgz4KOd05S3Huo/RmAwkPQGQBC8GZmKqiljLew/OWosyFTwW3/pZt5nCgw7V+Ccj/bWyIoWga3d7DgPg/vzHlvFqP/Mswg3J/F7c/ojhcY9wbIXYA2XqA8Whm4ILyZyt5gcmmDyt5t6F0fd5JEJ0aWL19ue7m5HsxB6P1cOWx3csSfEe8PIHtPXPkzkvX7a128meipmACRTwHkdP/O3hJh/sV9Jv7BuDuppM8m3t9gom2j9/cHkf0LGQgAgFz34osvRq5PnDjRtG3bNu7zGzdubObPn5+BNQOCW7Rokfnuu+/sdW85azcBMFYQz00a9Y6b/Mf+8QKAYas8uevZDirqGFjjJG85bHc9bHDZXxbbTQDIBe4cQaIM5VSI1S/Zex9jg9wTqx9wqpd85A8EJ7tECyp7z2OlkjdhRf9zAAoPQWcAKELeUrPZECaorYNRDaxdtq0G297Bt5vl7Q2UuoCbeLMj/WXQk+XvQxNr0OrKxrnZ9W5JVJbX22dKv3eyXAZxtD66bnHP8w4oYgXK3eKdneoCh96/J126vt/us3KXbkJAkHV3s++rVKliF82CdSek/OvmDSa7Et9BMqRLK2zwOGxZumT6PmcrgBzt9/VmJXgXZbHrsrTrGi0z2bvkQxlAAACAYqCqRFqiHVv6J496J+J6xxhhS1bnQvA4aHA5WlnsMONWjTujlcXOVhDVjQMSBZNTVfEsUTCZ7OT08J7LKU0GcLwlHS2aMiFWIDeVSz5y/68AChdn4gAAGeEPfgbte+yfcep6ssbLMneZzbEyqr1Zrm5mtXgDmd6DeH+fbXefO4ERrfSv7nMnDXTd26PbG4D29/zyLkFE63fmHcyHGaD5t7s/2Ox+X62rd4Cj53pPJPj7OfuDxO4+t11d3zC3eEu76XGtj4KUa9eu3eZzSRQoDyNM4NgtYcWbABBvYkAuZl3HCyanIiPBW4I92lKaktoAAOSTfD3hDnhVr17d1KlTp0RQVIHSICWr8yF4nIgbH/rLYivgHPR/XNvAVXzyBpgzHVx21cX8wWTvODTsWDSWIL2TcyVrO9ekMvAbK6Ccj/znfJLNAo635Pv3FQCUBkFnAEBg3mBurOBxrIByJk6WuYBuopJp0S4lSAZpqjJKvf1uopUgd79PrAC6WxdvaTqXhazXuIGRGyC6gb8LUrugsvs53m2nExmxBu6uHHW0ALPe2wXY3ft6B1zeUsf6Gd6eWKLXKkO5NNndjjcL3Zs94cr3eUubuxMWsUqVu+3q/Rtw2zZayXZvWXf/31A6/w/8AfEgAeRYg2E3kcBVF/B+1qnomRar7LU3c5mTRwAAAIWjWbNmdin0YIyOkV1w2RtgTia4HK0sdrq3nzdoHCtDOVXZyYnKXRfqJFPKRceW7sxgAsIAkH4EnZEx06ZNM2PHjjUffPCBmT17tu3lqQPIevXqmf3339+ceeaZ5oADDuATATLAGwwLmnGciVLF0Ur4Bgkae7OES8MNbNNZ+thbmlq8WdcawIfJVI7V/9q9xs36drPhd9xxR3vpAr4uuBqvpLlbXODRGygXPd/bZ9oFyl3JJG+/ZV0mU+I8UUZ4tCXIyQmtuysB7gLFsXqMR7svaJnwWJnYEitzO1qZQX+vav8JGu9nEK//kivf7srSR8tSL22GtTd4HK0Edpj/s1wyePDgbK8CAABAXiq04KELLvvLYmtsEWab+MthuwzwdPRRjRVMTrZSVizRxir+AHOuTjANGxBOpqR0vlavSEUGcCGWiwYAlETQGRlx4IEHmsmTJ29zvw5s586da5dRo0aZ/v37m8cee4zeDkBA0cpGBylhnakySP5AYazgsf++fBls6ERAokC1trfrNe36GuuEhAvkuhLf/tLW7rae7/08vZ+hd9u5oK6/n67LWNX7eAfG3p8jLtjs5T0poH7K3kGldxu4oLYu3RKr9LR/koAbrLpAqfc+7yzkoD3A3eICp96Z+t5Mb//2TNfA371v0JLq8TKQg/b5TpSl7/7/E/XvjlW+3E1k8C/ub8CV92MWOQAAAPKdjqOjlcXWeCMoHRf7g8vu2DkVwWX/xOVoweRUtO1x1YoSZSina4JBOvoFF0JAOGy56GTKShfapBEAQPoQdEZGLFmyxF4qq/n44483Xbt2NY0aNbIH7x9//LG58847zeLFi82TTz5pD4affvppPhkUbcnqMH2PMzUgCptxXCh9t4LwBpVdYNl76Q3wu8Cuf3EnAbxBQW07nZBQdrIb7PkDrN7sVHd9/fr1JUqeeQObrky0+9txf0+x6GSKFv+MdRdYrFKlil282dPRApBa3Gz2sH8T0bLJvYH3aD2SvRn52m5uneKVOI9V7tx/3b2nN1juDZD7B+ZuBn+0AHky3N+QP4ieqt5p3ioD/gxrd5/3d/L/jUQTLQM7WhnzRPcl+3wAAAAgEY0hXFDZG2BOJrjsL4vtqkyFpeP6eMFkd5mq7OREweRYE4u94ybXyimZDOBESz6iXDQAoNgQdEZGtGzZ0txyyy3muOOO26aETqdOnUy/fv1sie05c+aYZ555xpx77rk2OxrIJy44FiZonO2S1UH7HhczN2vcH0z2BpW9gVF/ANl7vxsou0G5+0y8A1GXJSr629DPcQN2R4+7z0vPj5blrJ/pAoIKROvSlZF2j7ugnPsbdOug99AJErdUrlzZXrrAcbwS1nqvaH2Z3ftKrJLP/uveTOxc6IHsPqtUiZax7bLSXdlvd6LL3fb+HbnXuYx7l4EcL2juguWxAsvpmCyS7ZNE6Qxua5vtsMMOWfvdAAAAEI6rJuUPMOs4OygdM0cri63xUpj1iNYv2XuZiuxkt76xxvruur9ylBsHBykpnY/ZwZKqLOBYS6x2RwAAFDKCzsiI119/Pe7jtWrVstnORx99tL39/PPPE3RGztFASoE0N6hSX3L1J890yWpvwDFo0DjVwbJiCCq74J8r0xwrO9mdIPCWq3aD72gDTpf96oL53l7M3l6+LqvYGxyMFvh0mdZa119//dVe131uIKylWrVqpnr16lFLOitgpmxlBZYVsHSBxyD9qd3PCtMLOQy3PYKWpfb2kA6yZHpChX5/b99k/xIvS8H9bvHoM/f3Tvb3VPb+7XiD0kHLl6fy+Zk6OeWtJpFq+t9q3rx5yt8XAAAApeMm4frLYocJ5Gq84M9adpnL8Y49EwWT3UTSMMfV0e7zBkC9i//+dB0L51u5aP8CAABSj6AzcsZBBx0UuT5v3rysrgsQizd7UwG3RGVl4wmbcVxMJavTGVR2wWR9lsoA9pcp9gegXSDZG0x2172Zwd7Sw/6ext4s82hB5HhBUG+A1QVx/aWU9ZgCx64Ud7S/EXfCRIsCze66G2zHKv0db3EnMry8wXW3Ht7bQcvCezNygwSdtbhM4aDl2dx2T8X/lCt95w8ie2+X9kRPrECyN9gehrdXczb4M7FLc8It2fcoLU5WAQAAZJeOuaOVxQ4TXHYVpPxZy26M4Rb9rNWrV0fGi96qRO62CyiX5lg01vjR2/YmWxPLgwSEg2QBJ8oQBgAA+YmgM3KGDtKdYi/ni9zkAjTewaE3EzNs32OkNqjsBvsKJivjVwFlXeq2tzyxN5gcLaDs/2y9iwsme4OV8TJp3QkB93kHLefsnR3vSmRr8fYUjtWnWKL139JrXLB47dq1ZtWqVSUCyMkG4LxZ2/Ge499ubht7uXXw9pt2l0HXzwWew/Rei/Z/G+0z8Z4o8geUw5Tji7UO0bKUvUHmQjv5ku2gt5Q2uB3rfxAAAACp5Z087F3cRNwgx3E65vZO3nRjJh2TavzoDSj7q1uVZswUrTqRf8zon5Sc7Huneym0MQkAAEgtgs7IGe+9917k+h577JHVdQFiUSapC5TUr1/f7L333mysNFPQUScX1q1bZ3755RcbMFUw2V262eUumBwtgByNN2DsL8msAb9muMcLDCvYlOg5/ixm/wBd6+hm4+uEiQsue2fl+wOw/lLV3lnvLgAcNugahjezO+iSihMT3n7oQZegdBLJnbDyZ5LHOsEUJhNbt5Utob+ZWEFlMmazw1/uHgAAAOmh422NfRJVI3LjI+/iMpddpZxE3HjNjfPcJFy91vV09gaTU9E7OdaEZG/rJNfOiHLRAACgUBF0Rk7QwGLo0KGR23379g39HosWLUr4nHzqYYPcpAGiwwzf5HiDqFp08mHNmjU2qKxFgWTvokByvF63iYJJ/hnjrg+XgoDeoLP3/kTB5GTKnCsI7LKw3e+p2247xOqFrO9H/Sx3ksIFu6tWrZr0DHjvNgobQM5WcNQFBsNklmr7uXJ73qC+/wSWK30dZh/hLbHnPZkk3pJy3okArqdzaSYqAAAAAPloxYoVZvny5fa6t7KTt0S1lqDjPj3PX87ZHT+743SNARK9n7dcdLTrunTZ0d5JpG5s5hZXjjtaaWmO6QEAQLEg6IycMGzYMDN16lR7/dhjjzX77LNP6Pdo2LBhGtYMQJgAsnfRCQOdQPAGWb2BZD3mMpOT4Q8qKxCrwb76FSsgqx7H/kCyFn8QujSBvWi/t06YuN/TlfjWpes1HHRWvn4HF2DWZaJ1DBJA9peOLoTsTm959WhLtLLXrge2lmh/z97FezLLeyIrWu/qRNx7ettJJBKv5DeBagAAAOQLVa1avHhxJMAcLxiscZOO8/1lsV3VJW91oXjB4iD3+Uttu+ve+wph3AQAAJAJBJ2RE2W1r7zySnt95513Ng899FC2VwkoSvECyP6gqgLGbnEBZGWNup7KLjvZnShIhptRXrlyZRtI1qULJuuyWrVqNiCrx1wwuTQB5GTKN3tn5LvtEbS3r9bTPzveZVhL2AzkQjwR4u3P7A8ku+vJ/n2JyyD3nmjyl71OtF2D/t94lzATLbyTOIIKO/mgtBnzAAAAQCI6htexuwvkOq66ky7dcaprd6Ql2VY0LqAcK5jsSm+ThQwAmePaHOg7P0iCBYD8w1lGZNVXX31l+vTpY3c2Gkw899xzNvCcjIULFyZ8TocOHcxPP/2U1PsD+SRoIMz7HAXw/I/rxIA3oOqCqt7eV0GDft5MUTdTXYFkbzBZgWQtLqic7AGomxkfZok3095lp3oDzLoM+rvr93C/qxb9rrr0Z10XU1llb0k9bxDZu5S2t5ornR5r8Z7sSpY3wzyoTAWqw2CSAwAAANJp2bJlZtasWZFjT2/JalWm0qV3HOTa02js5W9d46pBxQsqF+KkXADIFd62cGEuvefR2rRpY7+zARQWgs7Imh9++MEcdthhZvXq1XYw8Oyzz5oDDzww6fdr0KBBwucw6EA+ChKgiva49/XeIHK0bF1lKbvgn+uDGy+o7ALIbjDvDSh7Tx64EsYKILuMZRdwDRpQTnUAOdG29mYvuwCzN3vZ/Z7upIj7/d2JExdUdhnZWlIR3Mw3rn9xvLLXyX5O4i2FFyugnK3+0+kKVAf9389EoNqVty/2bHwAAAAEo3HRLrvsYo/Vo40D3RjBjat0qWNgb0lsd/yp41yNYfV8b6ntoJeFPsEXAIJwVSaCBIv996WC3ougM1B4CDojK5YsWWJ69OhhL3Ww//jjj5tevXrxaaDgJQogx3os1ntFe64/sOy9HS2oLN5Z4y6A6oKqboDv7tPiZpNrRrorfe0W3eeCfv7BvHed1es4SAC5NOWT44kVhPcGBPW7Vq9ePeoJCv2O+t31+7qlWEoD6TOJlZ2cqrLX0Updhyl7XWjcNgkzgSHWd0Qq/t+87x3mdwha7ptANQAAQGFRwFljUX9/ZV26JcwxvqucFLS9kVe03tBBLwEgF88zBg0Wey9LkwgQhnfSkPeS71SgMBF0RsatWLHCHHrooeb777+3t++77z7Tv39/PgnkpbDB4yABGn9gOlpg1AWP/ZnAus8dNLrrWrzBZAXsFBzWdW9A2S1uVrkLKrsMZS0ug9n1v4qWhRwvmJyq2ZBhA1re7eYW/d76/RJxz/MHmAv54DhRQDlMoDFs2WsXWC2G4H0xBqrDnhiM9X8db8nVDHcAAIBi1qxZM7vEEy9wEu8y7DhTx68a1yQj2WA1x6gAEn0vhQ0aJ/P9Vxp8/wEIgqAzMuqXX34xhx9+uJk9e7a9PXToUHPBBRfwKSBvDgDXrl1rAye6rgDZjBkzQr1HrKCNP7DsnQmoS/08F0B2wWRduvtdkNgbqEsUrNH6u2Cqyxz1li3T670HuevXr7f/w5kKICdTulfrtWHDBltqTYvWWZfRZm9GG/QroB4te7kYyl57A82pLHsdLWOZEy6FFaj2T3wphkC11t/9DmHKpAMAACA2l/kWttyqd+J22MuwYx93PKtWTKnI9Et0STlwIH/4k0jCfB9lMuuYSg8A0omzZMgYBYJ69uxppk+fbm//4x//MIMHD+YTQF7Q36oCDJ9//nnUx4MEWFzGcbQ+wK4vlXuem63ogoHRgkJBAijuZ/iDya6MmeuFtW7durRuv7ABoERZxNpG6rXsDTC7nl5B6P2jZS/nezDU9aSOFkh2S2knCyQqe00Arvh4JxoEFaZXu2sJEHQQ7gLVOhHovlNdkDjabS3eso7Ryj1GK/2o+1R+v2nTpqXYegAAACgt76TDVGUXBrkM+3Ncm6Kw3DmEZALWAMJLdhJLutrDxUvUCHtJVTkA6UbQGRmhQEefPn3Mhx9+aG9fcskl5qabbmLrI68oULFq1aoSZatd8MI7U9AFNL0HdP7SztGCgN6DRgX2KlasaKpUqbJNsENcUNoFk92ix7U+/oNJN8AtbVlkSSYDuTQHtdpeCih7A8wKOAcNQGk7+gPMYWfO5wp9fvHKXidzAsPLZRXEK33NAAWpDFS7Mv1a3MSbWLddRon7Do126V3SPVtc/wt169Yl6AwAAFAAx6W5HJjyTkoPg8AUipkbUyZTrj9TWcdMKAFQiAg6IyNOOukkM378eHv94IMPNmeeeaaZNWtWzOfrgH/33Xfn00FO0UGnstr8QTc3W9ktCoi6vrcuqOzNQHZZcy5jVPzBZL1OwVU3Y9vb69b1Wk5FANDfzznIkq6go7ajtp0/wBw0UK51c0FlF2BWwDlfspddX7F4S2kGPvrcEgWUmQmPWH+bQYLCyTyntNzfr3rPR+N+lv8kgr9foHfx/5+572zv97db9B0DAACA4pRsNrGON5PNrg4zJnQ/J5nJ55QDRy7wVgIM+7+SyazjZMtVM6kfQCEi6IyMePHFFyPXJ06caNq2bRv3+Y0bNzbz58/PwJoBwelgUD2NvVmlWlxpVheQ8D7fBWr1HGXo+QeIrky2C/q5YLJbwhyAhg0gu/Kw2eCC6v7s5SC0TaJlL4fpQZtprtxvvIByOsteh+3Ri/yTbFA4yOvygb/qg7dHfaz7Yj3HX37b36fae7tq1arZ/tUBAACQZ1zLrGTGaMkG4DJdDjyZIFy+TBiHydky9qXB3y0ApAZBZwAISIOtxYsX24CEv9y1C1L4uaByhQoVtslWjhdU9gasgy65OEDTNnFBZW+AOejAwQXi/dnLuTYbNFbZa2+gOZVlr6MFmHNtm6CkaH2EUxUUzsfAcJCgcNBAsX/CDwAAAFDo2dVhS4JnMmM0mSC3kDGa29zfUDLB40yVqyZDHwCyj6AzMiJTBxdAOmlQ57LgHNd/2QUB/ZnLLjCdTB/kfKNMbn+AWfcFoW3kgsveALO2Ra6VvY6WsVyaoJ8rex0vUzkf/x4KNTCcbFA43wLDqQwKZ7OqAgAAAICSE9s1KT4TvXHDlvV2FcKSya52ld+SyVYtNpnKli+NZD9Lxp0AkH3ZP5sPAHlCB68NGjSwB7MuKOqCzIUWQI5HAw0XXPYGmIMG1RRE9QeYNejNRqaid1Abq+x1Mv2vvNwkhFhLOvtkF6JopY9T1Wc4XyZIJRPwDfocAAAAAIg2/sj1cuDJVhjLxwBnpvqCl4Z3IoB/cdX6Yj3ufkfv7xvrPnHndcK8pjSPp+M9i+Vneu9r3bq1rWYIoLAQdAaAEA488MCiCRDqQDBa9nLQgZwGEN7gslsymb2sAVW8Psr+QUlY+h3jBZQ1KC/GQJ43MJzKoLAu8ykwnExQOMjrAAAAACDXxApAuUBimKCUK+WsMbsLmLrFG0B1j3ufE2tCfNBAWNDXuKp2brzmgqkuq9zd532Ou1/PiVau2vXR9l5Ge9xtoyDrGeQzircdvL+f93dyv2e07aClNBMBUBzy5fwOgHAIOgNACIUacNbgxZ+9/NtvvwXOXlamsj97Od19ht1gK15QubRlr+OVvHZZ7vkeGE4mKJzodfkycEhFZnCs5wAAAAD4Hxcwy5cMPH5m+O2QTd4J4W586pZot93fo//+ZLi/a9e7ONH42ZvFHXSMWdrqVN5gcLxguD/jmLFt8fCev4t2Peh9YR7n7wsoTPl7thwAEJoGQAom+wPMQXsm6YDQlRb3LukoIR4voJxsn6d4Za/9AWbXkzubog1YUxEUzpfAsLZ/uoLCDG4AAACAzFm6dKn5+eef2eTIyXLg3sxqd87BtdvynoNwt3Xpbrtgc7p5M4r1u7nFndvwX3ftvJQk4MbEpQ0SpiPwWMw/M5d+DwBIFYLOAFCgNADyBpfdEnQwpIGJP8Cs+9JR9jpagDkVZa/jZSqnKujoD/amsqR0PgaGU1lSmgEQAAAAACQ3TvNeJrov3Y9n6md6s5fddRcUdmWq/RnO/ixnVzbaW9ksSMDO/37+sb7rp6zF+37ectzeftHeHtJunBxtjBx023hLgIe5ZGwOAAiDoDMA5DkNWKIFl4NmAmsAES17OdmgrNYnViDZLd5yUsmIF0x2s3m9/MFcbZ9U9RnOB97AcKpLShMYBgAAAJCIxpzVq1cv6kzCTP3MfBet13HQy0QTt73ZwqURL4CbKIjr5+/bHOYyDHceI5mqcckEq12wHABQXAg6A0Ae0eBA5bC9wWWVyw6SEavBVbTsZQVpw3DlpOKVvk6GGwB5B2/eAZt38OItO62ft2nTpriB4nwKDKejz3AhnYAAAAAAkH9q1qxpFxQPl/UbJpDqei1ngjcAHSZorMtUjrFdpbaw3HmRZILVYbex+znJbuNkAtacxwCA/ETQGQBykAYACib7A8waIAShA3QFlL0B5ooVKyacZaqfGy+grOCuGwS68s/+ctDRSkR7L70DCRccdT2J3ExYPTcVfZtTzQ2YUhEUJjAMAAAAAMhl3rLUQYPGLkCZqXZRrhR1MmWj85m3DHjYVmje0uNhL5P5+wn7OvGXGA9zCQDIHoLOAJBlCuZGy14OOshQMNkbYNZgQwfn/ozfX375xQaN9d7eS7e4wHK84HEiOsB3wWNd+hd/2et08Ad2U5k9zExbAAAAAEC+CRosLm1GbGkDqMkEGBmnh+fOceg8TVjJZlcnUw5c56iSkezfEuXAAaD0CDoDQIa4XsLr16+PLAo2K5vXlUXyZgV7b7sMYdfLWIFl17tYz1u7dq1ZsWJFpLy1W3Rw770sDQ3k3M/0BpG9QeWgg710BYUJDAMAAAAAClG87NRU9v4tDXr/Fj6XJR62JHg6e3X7uf8JJViEweQHACg9gs4AEJAOctetW7dNv+BoPYRdaWwXWFaw2fUdTnSw7Hova3FZzAroupLTLjPaG1x2getUlGVyAWQX2HbroftSERQmMAwAAAAAKEb+PrzpDLyl4vxA2HLVZB0jyN9VWDqXlkywOuyEi9K0eovWH7wYyrwDgB9BZwAIcZA7d+7cEvfpANaVp/aWrQ46GHSZy95SPjoQd4NPlcTWwW6sA2U91/W58QZ0/QFeb/DYG9B2ix739limpBAAAAAAALHPD4QNGidTYrg0KDGMQqFzVGEzq51ks6vDlpZ3/99hS4LrnF2yAWvO3QHIRQSdASAgBZJVxtobYA4y+9EFoL39jt3iyme7A00XMFYg2B14uvv8wWR3cOkOvmMtLkMZAAAAAAD8b6yebPZkprKO3STzZAJSAP6XgZyr3w/u5yRTDtwljlCVAEAuIegMAAEpOKwDQAV/K1eubKpWrWqvu9mM7gDTG1TW4gK/yZaZihZE9t5OpjQRAAAAAACFIFOZjMlyE8qTCR5TrhrIDv3vufZzuVoO3LX6oxw4gFxCpAIAQswgnDdvXqSXkjsAVc9lt+ywww6RUtWu1E28oLA3KB0rS5lBJgBkjnemubfXnn/RY1WqVDH169fn4wEAACglBU6SDR5nCj1bAaSzHLi/53uYy0yXA2cSDYBYCDoDQIiDP1f6Wj2RvcFkHeStW7fOLt4DMVdSW69xgWm9VsFpXXeZyt6DNbcQbAaA1PXaCxJEDju7nLKFAAAAwaxZs8b8+uuvKQuYJMuN05MJmjBGB5CJ7yctOneYiYk7pSkHXtp2AQ0bNrTnRgEUFoLOABDi4G/nnXe2ZWt0UKaDJNej2ZXccYs7SIx1IKjBtpags6j9S6z76d0MoFBFCxgnCiKn++Rlpnr5AQAA5Lu1a9ea5cuXp+z9ks20Y8wMoBDpu01LMuXAk82uTqYceNjMagD5h6AzAAT9wixXzhxxxBGRwLJ3dl+iAEgyGXTJlLrxzopMFKD23g8AmeJKhiXKOPbfl+4Ab9jvTSpSAAAAmFJViFGAJJngMVnHAJA67ns1bElw79g+7KVeS+UwoDARaQCAECpXrlwiwOt6L6eyV2i0+8O8vzKxtYQRNtBCsAWAt3x1mCBy2NnQYYWZfON9DAAAAOlTq1Yts+OOO5YIHpN1DAD5yzv2TuZcAvsAoDBxhg0AMnxA5jKlwwgToE6mrGwy/VhcL5YwmdXMYgRyl/f7JGgQOd3lq8N+z1AyEQAAIDepP2nYHqUAgMJEwBkoXASdASAPuIBtmEG6y0AMk1kdJgPR9WJJtvx3kMxDd12vA1C68tWJvgMyUb46bJ96/vcBAAAAAACA/EDQGQAKeNZgsuW/w2RWh+m1mmz577CBKkq1oVBE6x0fJIicTkEmj/jvZ/IIAAAAAAAAUNgIOgMA0lL+O1HgOkxZXr1Gy6ZNm5IuyxskOEb5b6ST+zsOE0TOdPnqIBUI+D8BAAAAAAAA4EfQGQCQ9fLfQTOrM1X+O0xmNRmcxSls7+NMlK+O9fcZL4hMHyUAAAAAAAAAqUDQGQCQV+W/w5T+zmb570SBa4J9uVu+OsjfWDpp8kMyJeXpfwwAAAAAAAAgWwg6AwDyhreXbBjeYGHQoHUmy3+H6YuLYNnzQYPI6e5/7D7nIGWr+ZwBAAAAAAAA5CuCzgCAgpds+e9ksqrTXf67WDJgw/Y+znT56qBB5ELJaHfb1ruNg9xX6M+vWLGiqV27dsztBgAAAAAAABQLgs4AAEShYKGW8uXLl6r8d5DAdZjy38mUd46WSZuKYGmQwFy07GOVL/dvC3efLl3wPmjgL8z6eLeJ+31db2N3PdZj/vd0191nmauB0dI+H7HtuOOOBJ0BAAAAAAAAgs4AgFQrxIBbqn6mtzy49/nRAtGJriuYW9rAa7znu6C7C7q6Sz2m30M/35tB7V6v9XOBZnc9nVz2tz9Y7NbZGzz2LtFkotw2AAAAAAAAABQiMp0BICAF1ZYvXx657r0/0X3F8nxkriS4N8PWBUtjLS5I7Q2ouoCwu9972wWNvbf1eKLPWQFgbxDYG6yOFsB2113w2hsojpVx7A8iF0r56mR4g/7uerz7wj4/Fe+R789P9B5h+8sDAAAAAAAAhYozZQAQkAJuCxcuZHshJ7isaQVevQFmb5axK8ft7U+t8tVa9Jh3EV26DGoXQBYXIHY/N9q6+B/zBo1jZR27stVa1Bs3Xvlv3adS5973KPYgKAAAAJBv7rrrLrsAAIrXZZddZhcAhYegMwAElM+BnlwIlpFlmXi7eIPE/nLa/sxl730uMJsOLvjsFheQ9j7uDVr7A9mlFavktbdUeZh+1QAAAEiOTg6vXbvWVKtWjU2I0BYtWmQaNmzIlgMAmMsvv9z07dvXNGjQgK0BFBjOvgJAQApyNWnSJHLdexn0vmw8H9nhDQ7HWvzPSab/cZjP2ZtZHDRQG6v/cSIugB7v9412f5j3d1nbYYQJULuF/yUAAID/Bp2BVKhbt27S4wwAQP7S+Z+ffvop26sBII0IOgNACDVq1GB7FRlv7+REwVPvY3CVSZYAAQAASURBVOnucx0rYBovmJrJ4Kl+lsphawkjTIDaLWG2ddjgtnhLgwfd1sXcaxoAAACI59NPPyW7DQCKEFUvgMJH0BkAUDSiZd8GCSJnqjdz0CCybhdq9m0ypcK95ciDZlaH+Vzd83///ffAr4lW/jtI4BoAAAAAAAAA8hFnNwEAecnf3zhIsDGZ8tVheMtXBw0iU1YuNdt9++23t0syExDC/B1lqvx3mMzqQp2AAAAAAAAAACB/EHQGAGRdmLLVyZRUTka04F6iQCAllfNHsuW/w050yET570z26gYAAAAAAACAaAg6AwDSVr46aBA53cHFsP14C7l8NUrHBWwrVKiQdPnvIIHrMOW/9f4q/V2a8t9B/kf4vwAAAAAAAAAQC0FnAEDgPrmJgsjp7n+sjM4wvY8pX418L/8dJrNa9wXNqi5N+e8wkzh0HxUAAAAAAAAAgMJH0BkAikC6SwInw59BGSSIRfAKxSKV5b8T/f+H6XXuXrtp06ZSlf9O9D9P+W8AAAAAAAAgvxB0BoA8kij7MdZj6RY2oKSF8tVA7pX/DjpBJVPlv8NmVfO9AgAAAAAAAGQHQWcAyJIggZ7S9HlNhr/Pa9AgMoDiK/8dtoJCJsp/xwpGx/v+ooICAABA+jVo0CDt1bQAALmNfQFQ+IgUAEAKRMsCTBREDlPSNhnRStomCsIQfAEQdoJKOr4rvfeH+a50veWTLf8dNLOa8t8AAAAAAABASQSdASAgBTIWLVpUquy9ZIUNiFC+GkChlf8Ok1mdifLf+j2qVatmmjRpEvh1AAAAAAAAQKEi6AwAIaxYsSKl5auDBJHpUwqgmLny32HEKv+dKHAdpvx3JloeAAAAAAAAAPmCoDMABOSCvy4oEa18dawgsnuMkqwAkPvlv4NmVYcNhgMAAAAAAACFiqAzAITQqlWrSPCY/scAUFiYHAQAAAAAAAAkh6AzAIRQsWJFthcAAAAAAAAAAIBHGe8NAAAAAAAAAAAAAADCIOgMAAAAAAAAAAAAAEgaQWcAAAAAAAAAAAAAQNIIOgMAAAAAAABAEoYMGWK22247u+g6AABAsSLoDAAAAAAAAOSgtWvXmjFjxpiBAweavfbay9SvX99UqFDBVK1a1TRq1Mj06NHDXHXVVebjjz/O9qoCAPLA/PnzIxNlUrUw4QaAQ9AZAAAAAAAAyCEbNmwwt9xyi9l1113NiSeeaEaMGGFmzJhhlixZYn7//Xfz66+/moULF5oJEyaYoUOHmi5dupgWLVqYZ555xmzdutXkI28AAwCAsN59993IfqR79+5sQCALymXjhwIAAAAAAADY1oIFC8zRRx9tvvzyyxL3K7O5bdu2pnbt2mbLli3mp59+soHoZcuW2cfnzJljTj75ZBuMHjRoEJsWALCNatWqmQsuuCDulpk6dar59NNP7fV69eqZPn36xH1+x44d2dIALILOAAAAAAAAQI6UPe3cubMNKIuytU466SRz9dVXm9atW2/zfGU1T5s2zdx3331m9OjR5s8//7RZ0gAARFOjRg1z//33x904Kpftgs7NmzdP+HwAcCivDQAAAAAAAGSZymYff/zxkYBzxYoVzYsvvmiDydECzi4o3aFDB/Pkk0/arOc999wzw2sNAAAA/BeZzgAAAAAAAECW3XbbbTZr2XniiSdM7969A79eAedPPvnEfPHFF2laQwAAACA2Mp0BAAAAAACALNq4caO59957I7ePPfZY07dv39DvU7lyZbP//vvHfPzHH3801113nenUqZOpU6eO2X777e2lbl9//fW2H3Qi7777rs2w1tK9e/fI/RMnTjQnnniiadq0qc3SrlmzpjnwwANtWdY//vgj4Xt5ufv8i8qPO7ru7t91110j93/wwQdm4MCBpmXLlmbHHXe0j1966aVRf/64cePMGWecYXbffXfb57RSpUqmcePGtn/pqFGjYq43AOB/vv76a9sGQr2d3b6ldu3aZr/99rP7nCVLlgTaXL/++qt5+OGHTc+ePU2jRo3MDjvsYMqXL2+/y/WdfvTRR5tbbrnFzJo1a5ty4PquP+iggyL3vffee1H3I979BYDUI9MZAEK666677AIAKF6XXXaZXQAAAFLh+eefN8uXLy9xrJFqN998s7npppvMb7/9VuL+n3/+2S5Tpkyx2dY6eT948OBQZcEvvPBC89hjj5W4f9OmTWby5Ml2GTlypA3w1qpVK2W/T7T1uPjii80jjzyS8Ln6fU8++WQzYcKEbR5bsGCBXV5++WUb3Hj66afNvvvum6a1BoD8pe/5Sy65xAwfPtxs2bKlxGMrVqywy9SpU80dd9xh9y/aV8Ty8ccf2xYTixcv3uaxtWvX2uXbb781r7/+uvnHP/5hJwWVK0d4C8g1/FeiqGjQph2UZq8CYS1atMg0bNiQDQcAMJdffrnNPmrQoAFbAwAAlJqyhB1ld8XLVk6GTvQ/8MADkdtVqlSxGWF169a1PaQnTZpkM8wUkL7yyivtfcOGDQv03meffbYtBV6mTBmb1aZstD///NOW+laAQKZPn2769+9vxo4dW+K19evXNxdccIG97l0/d59fvPM5f/vb3yIB5zZt2ph27drZDLk5c+bYdXOWLVtmt++8efMi9zVr1syue4UKFczs2bNtAF7mzp1rt9Nbb72V8s8EAPLZ+vXrzeGHH24+/PDDEt+l++yzj6levbpZtWqVfUxZzqrmcdFFF9nz8sqI9lOVDb3XunXr7G19d3fo0MHstttuNttZP0vVLWbMmGHfw08Z1tpvKGCtCUNSr149W7XCT1U4AKQPQWcUFTKSkCoamJctW5YNCgBFRrO3dRIWAAAglZQN7Cj4mUr/+c9/SgR0Tz/9dHPPPfeUCODqJL5O2D/11FP29t133226du1qy3zHo8CySpgqOPDkk0/agLOzdetWWzLclbZ+8803zfvvv29LbjvNmze35bfFu47uvjCTxB988EE7UXz06NF23f3ZeM6AAQMiAWeVI1eGnsqCe6m39gknnGC+//57G4w/6aSTzJdffml22mmnUOsFAIXq/PPPjwSc1aJAk368LRfc+PnRRx+1k4L0PaxS25rI07lz5xLPU0VJF3DW9/ezzz5rg8Z+mzdvtj9TlTW8bRmOOuoou6hlgws6e/cvADKHoDMAJOHTTz8luw0AihBVLwAAQDqo17LTunXrlL2vMo6VueyodOnjjz++TQ9lBaAVNNZJ/1deecXeN2jQINO7d+8SWcJ+CiLoxL4ytZU97aWfobKr6rGs8uHyzDPPlAg6p4oCG8qGe+edd2zww08ZzKKMbgW/nTFjxtjeoX4qp63S23vttZf55ZdfbBaeAugKmABAsdNEKe0zXHazAsHR2icoYee8884zlSpVshN+9F194403lvgedu/naB8VLeAsKqfdrVs3uwDITbGPGgEAAAAAAACklbKMlb3lpDKbdvz48eaHH36w17fffnsbOPUHnB3dr2xjlTUVZQO//fbbCX/G0KFDtwk4e51xxhmR6+rtmS4qIR4t4Ozl7fd8zDHHRA04O7vuumuJMrAPP/ywzd4GgGKnzGTnzjvvjBpw9lKFDVcJY9y4cWblypUlHveWzK5du3bK1xdA5hB0BgAAAAAAALLElRR14gVwS9MrWqVH1SoqHvVYPuKIIyK3lRkcT8WKFc3RRx8d9znt27ePXFdPznTxl8iOxvv7eIPhsSgzz2V6L126NNKjGgCKlSZJuQlJqpLxl7/8JdDrVFZbNHnH2wda1BrBO8EHQP6ivDYAAAAAAACQJVWrVi1xWz2EU+Xzzz+PXO/SpUug1+y///7mtddes9enT58e97ktWrSIZEbHUrNmzajZbKmkdWjTpk3c5yxevNj8/PPPobaHMu6UPf3NN99Etoe3bzUAFBv1t1+/fn3ku1dtFIK2KnTUssCrb9++kUlSagmhoPYpp5xiDj30UNobAnmGoDMAAAAAAACQJcoUU59KV2J7zZo1KXvv5cuXR643btw40GtUVtpZsWJF3OfuuOOOCd/PG5T2lhFPperVq9ttGHRbqL9o0BKu2h4u6JxoewBAoVuyZEnkuspkqy1DWKtXry5xe+DAgeatt94yL7/8sr09YcIEu0ijRo1M165dbaZ0r169EpbyBpBdlNcGAAAAAAAAssgbEJ49e3bK3tebNV25cuVAr/E+z1/62y9Wf+hMUxA5Hdsi7PYAgEL3yy+/lPo9/BOQypYta1588UUzfPhw06pVqxKPLViwwIwePdoGpuvVq2cvV61aVep1AJAeBJ0BAAAAAACALDrggAMi16dMmZKy9/X2h3blUBPxPs9f+jufJbMtCnl7AEAyvBNx2rZta3s0h12GDBkSdRLTmWeeab766ivz7bffmkcffdScdtpppmnTppHn/PHHH2bEiBGmY8eOJapXAMgdBJ0BAAAAAACALDr44IMj13/88Ufz0UcfpeR9vSWklS0WxPz58yPXC6mMqXdbbNy4MXCp7ELdHgCQjDp16kSu//TTT2nZiLvvvrs566yzzKhRo8y8efNsEPqyyy6zGdGi+2644Ya0/GwApUPQGQACatCgQWRGnq4DAIoP+wIAAJAOxx9/fImA5l133ZWS923fvn3ketBAtvd5e++9tykU9evXNzvvvHOo7aHA9Jw5cwpyewBAMvbaay9ToUIFe/3nn3823333Xdo3pILQd955Z4lA86uvvpqzLR+AYkbQGQAAAAAAAMhyT+KLL744cvuFF16wS1gqBe0NpnozqMeOHWsDBPEsWbLEvPnmm1Ffn24VK1YsUUI1HQ466KDIdWXQJaLn/Pnnn/a6eom2aNEiLesFAPm0v/LuGx588MGM/exjjjkmcn3ZsmVZ2Y8AiI+gMwAAAAAAAJBlgwYNKpFJ269fP/Paa68Ffv2sWbNMp06dzPjx4yP3HXbYYaZJkyb2+qZNm8yll14a8/Wq6nXRRRdFTtQ3a9bM9OjRw2RKzZo1I9cXL16clp9xzjnnRK6/9NJLZty4cTGfqzLnN998c4nXkkUHAMYMHjw4shnuu+8+88477wTeLNFKcgdtd7Bw4cLIdW/likzuRwDER9AZAAAAAAAAyDKVK33uueciJ9LVd7h3796mf//+5uuvv44ZKP7000/NaaedZtq1a2cDz15lypQxQ4cOjdx+5plnbJ/MX3/9tcTz1q1bZwYMGGBefPHFyH233XabfX2m7LnnnpHr2g7pynQ+8sgjI7f/+te/Rv1Zn332mQ24r1mzxt5u2LBhiUx0AChm3bp1s/sd2bx5s+nZs6f517/+tc2+xfntt9/Myy+/bHr16lUiW9lp1KiRndjz3nvvRapL+E2bNs1OjHK83+WOJlntsMMOkYlD2j8CyKxyGf55AAAAAAAAAKJo2rSpmTJlijn66KNtAFkn3//973/bZddddzVt27a1vZ+3bNlis8W++OKLbUqMVq1atcTtvn37mvfff9888MAD9vbw4cPNmDFjbAC2Tp06tuT2hAkTSgQLlBF97LHHZvQzOu644yKZx8qiU5nv1q1bR3qHyj/+8Q9TvXr1Uv2ckSNHmv3339/MmzfP/s7aPs2bNzf77bef2X777c3s2bPtZ6CAvlSuXNkG63faaadS/oYAUDgeeeQRs3TpUltd4/fffzdXX321uemmm+x3qYLI+u7WxB1912p/pmobss8++2zzXppk9eijj9pF+zD1jW7cuLH9/lUW9DfffGO++uqryPNr165thgwZss37lC1b1k7Wevrpp+3t7t27myOOOMKujx6TGjVq2HUFkB4EnQEAAAAAAIAcoeDyxx9/bIYNG2buuuuuSLbt/Pnz7RKLMp11El4n3P3uv/9+U7duXRsQ0Il/ZTa/+uqrUfthXnfddeaqq64ymXb66aebp556ygbIFfCdNGmSXbwuvPDCUgedFWj/8MMPzcknn2wmTpxo75s7d65d/HbbbTcbvOjQoUOpfiYAFBoFlceOHWtuuOEGc+edd5oNGzbYxf+97VW+fHnbBsKvSpUqkYlP2j9NnjzZLrH2dc8++6ypV69e1MdvueUW+92uiVlaH28FD1Ewm6AzkD4EnQEAAAAAAIAcohPw1157rS3prJP6b7/9ti35rKzkVatW2YxcZWu1bNnSZpUp0OztBx3NNddcY/tEK9NZGcU//PCDDWgrg1cZ1ocffrgZOHCgzQjLBgUj1Bd0xIgR5oUXXrCZcfpdlUGXago8K7v7rbfeslnfH3zwgQ1QqJ+1ypu3b9/ebtNTTz3VrhcAYFvKHr7xxhtt2esnn3zSfoerWoSyk/V9Wq1aNRvkbdOmja2ucdRRR9ksZb+VK1faCUcqr62S2JoEpCoeKsutctkNGjSwGdKqiKHy3PFaP+jnzZgxw062Uhb2nDlzbCBbZcABpN92W12tGAAAAAAAAAAAAAAAQoo9JQQAAAAAAAAAAAAAgAQIOgMAAAAAAAAAAAAAkkbQGQBgDRkyxGy33XZ20XUAAAAAAAAAAIAgCDoDyIi1a9eaMWPGmIEDB5q99trL1K9f31SoUMFUrVrVNGrUyPTo0cNcddVV5uOPP+YTAQDENX/+/MgkmVQtTLYBAAAAAAAAkkfQGUBabdiwwdxyyy1m1113NSeeeKIZMWKEmTFjhlmyZIn5/fffza+//moWLlxoJkyYYIYOHWq6dOliWrRoYZ555hmzdevWvPx0vEEMAADCePfddyP7kO7du7PxAAAAAAAAkBfKZXsFABSuBQsWmKOPPtp8+eWXJe5XZnPbtm1N7dq1zZYtW8xPP/1kA9HLli2zj8+ZM8ecfPLJNhg9aNCgLK09ACBXVatWzVxwwQVxnzN16lTz6aef2uv16tUzffr0ifv8jh07pnQdAQAAAAAAgGJC0BlA2kqfdu7c2QaURRlbJ510krn66qtN69att3m+spqnTZtm7rvvPjN69Gjz559/2ixpAAD8atSoYe6///64G0blsl3QuXnz5gmfDwAAAAAAACB5lNcGkHIqm3388cdHAs4VK1Y0L774og0mRws4u6B0hw4dzJNPPmmznvfcc08+GQAAAAAAAAAAgDxApjOAlLvtttts1rLzxBNPmN69ewd+vQLOn3zyifniiy/4dAAAAAAAAAAAAHIcmc4AUmrjxo3m3nvvjdw+9thjTd++fUO/T+XKlc3+++8f8/Eff/zRXHfddaZTp06mTp06Zvvtt7eXun399dfbftCJvPvuuzbDWkv37t0j90+cONGceOKJpmnTpjZLu2bNmubAAw+0pVn/+OOPhO/l5e7zLyo/7ui6u3/XXXeN3P/BBx+YgQMHmpYtW5odd9zRPn7ppZdG/fnjxo0zZ5xxhtl9991tr9NKlSqZxo0b2x6mo0aNirneAID/+vrrr20LCPV2dvuV2rVrm/3228/ub5YsWRJoU/3666/m4YcfNj179jSNGjUyO+ywgylfvrz9Htf3+dFHH21uueUWM2vWrG3Kget7/qCDDorc995770Xdh3j3FQAAAAAAAEAuINMZQEo9//zzZvny5ZHbl112Wcq38M0332xuuukm89tvv5W4/+eff7bLlClTbLa1TuAPHjw4VFnwCy+80Dz22GMl7t+0aZOZPHmyXUaOHGkDvLVq1UrZ7xNtPS6++GLzyCOPJHyuft+TTz7ZTJgwYZvHFixYYJeXX37ZBjiefvpps++++6ZprQEgP+k7/pJLLjHDhw83W7ZsKfHYihUr7DJ16lRzxx132H2L9hOxfPzxx7a9xOLFi7d5bO3atXb59ttvzeuvv27+8Y9/2AlB5cpxOA4AAAAAAID8x1kuACmlLGFHGV7xspWToZP9DzzwQOR2lSpVbFZY3bp1bQ/pSZMm2SwzBaSvvPJKe9+wYcMCvffZZ59tS4GXKVPGZrYpI+3PP/+0pb4VJJDp06eb/v37m7Fjx5Z4bf369c0FF1xgr3vXz93np2zkWP72t79FAs5t2rQx7dq1s1lyc+bMsevmLFu2zG7fefPmRe5r1qyZXfcKFSqY2bNn2wC8zJ07126nt956K+WfCQDkq/Xr15vDDz/cfPjhhyW+R/fZZx9TvXp1s2rVKvuYspxVyeOiiy6ygWNlRPupwobea926dfa2vrc7dOhgdtttN5vtrJ+lyhYzZsyw7+GnDGvtMxSw1mQhqVevnq1Y4acKHAAAoDio2tU999xjq1lpTNigQYNsrxIAIMPYFwDIG1sBIIWaNWu2VV8tWo4//viUbtsxY8ZE3lvL6aefvvWXX34p8RzdPvXUU0s874UXXoj6fpMmTYo8p0KFCvayQ4cOW7/++usSz/vzzz+33n333SXe87333ou5nt7nBfHDDz9Enl+2bFl72bBhw63vv//+Ns/97bffItePPPLIyOsqV6689Zlnntnm+Z9++unWpk2bRp6n9129enXU9bj++usjz9N1AMhn3u+0bt26RX1O//79I8/Zfffd7X7Bb/PmzVsffPDByH5C39MfffTRNs+79NJLI+/VtWvXrYsXL476M//444+t77777tZTTjnFvne8fVOs9QYAAMVh5syZW8uVK2ePC6688sqoz9HxgncMqjGfd9wY9HjphBNO2Jov+vTpU+J3DnLM5D3GCroccsghGfl9ACAe9gXRsS8AchM9nQGklHotO61bt07Z+yrjWJnLjsqXPv7449tkDOv2k08+aXr16hW5b9CgQfb1icqrNm/e3GZqK8PZS/0zVXr1r3/9a+S+Z555xqSDSrsqI+6dd94xXbt23eZxZTCLMrrffPPNyP1jxoyxfaj9VE5bpbfVS9Rl4nl7bgNAsVLLBO0vXHazMpq7d+++zfPKli1rzjvvPNun2X1P33jjjVHfz9H+SVnK0aicdrdu3cxTTz1l3xsAACAWjWU3b95sKleubK644opAG0pjviCtmvLVCy+8YF566aVsrwYAZAz7gm2xLwByF+W1AaSMyoVqQOzstNNOKXvv8ePHmx9++MFe33777W3gVMHgaHS/SlyrBLb6Zar89Ntvv23LnsYzdOhQW647ljPOOMP2rBb190wXlRDffffd4z7HexLhmGOOMT179oz53F133dWWgnX9rRU4ufbaa2NuPwAoBnfddVfk+p133mlq1aoV9/mnn366ufXWW80333xjxo0bZ1auXFmizLW3ZHbt2rXTtNYAAKBYaEKcm2h81llnhWqvccstt5iBAwfaCc2FZM2aNXa8XFqxWpj4+SekA0CmsS/YFvsCILcRdAaQMq6PpRMvgFuaXtFHHXWU7eEcj3osH3HEEea1116LZAbHCzpXrFjRHH300XHfs3379pHr6suZLtEylv30+3iD4YkMGDDAXHXVVTbje+nSpbZHNQNoAMVKE6Q0GclVyPjLX/4S6HUHHXSQDTqrk4IG/5r04zRs2NDMnTs3MrnHTfQBAABIhiZFiyYLn3/++aFeu2zZMjtR21strBAo2/unn34y5cuXN7179zbPPfdcUu+jKmf3339/ytcPAFKNfcG22BcAuY2gM4CUqVq1aonbv/76a8re+/PPP49c79KlS6DX7L///pGg8/Tp0+M+t0WLFnbgGk+sjLZU0jq0adMm7nMWL15sfv7551DbQ1l3yp5WsMRtD4LOAIrVl19+adavXx/53lULhSA+/fTTEqUrvfr27RuZIKUTvApqn3LKKebQQw81DRo0SOn6AwCAwqaJbG+88Ya9fuCBB9ogaRCdOnUyn3zyib1+++2322C1vyVVvtJx1ogRIyKlZtWyBAAKGfuCbbEvAHIfR2gAUkaDWQ38XIltlTtJleXLl0euN27cONBrVFbaWbFiRdznup7H8XiD0t4y4qlUvXr1hINn77aoVKlS4DKu2h4u6JxoewBAIVuyZEnkuspkqyVDWKtXry5xWyUs33rrLfPyyy/b2xMmTLCLNGrUyHTt2tVmSvfq1SthKW8AAFDcRo4caSuryAknnBD4daeeeqo9RlFlq1WrVtkWIjfccIPJdxs3bjRnn322vb7bbruZa665JpL9BwCFin1BSewLgPxQJtsrAKCweAPCs2fPTtn7erOmK1euHOg13uf5S3/75Up/YwWR07Etwm4PAChkv/zyS6nfwz/5qGzZsubFF180w4cPN61atSrx2IIFC8zo0aNtYFo9BHWpE8EAAADR6LjBURnpoHQ84g0yDxs2zE6wy3fXX3+9mTdvnr3+0EMP2fZYAFDo2BeUxL4AyA8EnQGk1AEHHBC5PmXKlJS9r7c/tCuJmoj3ef7S3/ksmW1RyNsDAMLyTsJp27atzSQKuwwZMiTqBKYzzzzTfPXVVzbD6NFHHzWnnXaaadq0aeQ5f/zxhy0N2bFjxxKVKwAAAFwbEE1YE7VE2mWXXUJtGLX8aNeuXWSy8a233prXG/azzz4zd911VySTu0ePHtleJQBIO/YFJbEvAPIHQWcAKXXwwQdHrv/444/mo48+Ssn7ektIuwF4IvPnz49cL6RSpt5todIyQUtlF+r2AICw6tSpE7n+008/pWUD7r777uass84yo0aNspk5CkJfdtllNgNJdF8hlLsEAACp9fbbb0euqz1HWJoE989//jNy+/777zdLly41+UiVZVQhZsuWLaZGjRqR4HNpaRz92muvmZtuusken1177bV2O3366adpa6UFAGGwL/gf9gVAfqGnM4CUOv74483ll18eCYRqUNilS5dSv2/79u3NO++8Y68HDWR7n7f33nubQlG/fn2z8847m59//jnyex5zzDFxX6PPY86cOQW5PQAgrL322stUqFDBbNq0yX6Xfvfdd7Y/YDopCK2+ijphqj6E8uqrr9oTnLnY7gEAAGSHt2KYKrIk4+ijjzb77beffS8FWG+++eZtjjnCGDt2rF1SqV+/fnYd47njjjvMF198Ya/ffvvtJSZgl8bUqVNjjqHVCuVvf/ubueSSS0z58uVT8vMAICz2Bf/DvgDILwSdAaS8J/HFF19srrvuOnv7hRdesMtxxx0X6n1UCnrGjBmRgLUyqDXIFA12FSRQ4DWWJUuWmDfffDNqBna6qb/Ub7/9Fimjmo6B6kEHHWTGjBljryuLLlHQWc/5888/I4PoFi1apHydACCf9lXaL7j9xIMPPpiyzJlE9H3tgs7Lli3b5nFvj0LtQwAAQPGVVHVUXjtZyuI99NBD7fXHHnvM/P3vfzeNGzdOOkj7wAMPmFTad9994wad586dG6kK061bNzNgwACTCTqXoG2l8xgvv/xyiQo5AJAp7Av+i30BkH8orw0g5QYNGlQik1YzmFW6KqhZs2aZTp06mfHjx0fuO+yww0yTJk3sdWWmXXrppTFfr16bF110UeRkfbNmzTLa96lmzZqR64sXL07LzzjnnHMi11966SUzbty4mM9VmXPNbPe+lkw6AMVu8ODBkev33XdfpJpGENFKcgdtdbBw4cLI9WiTpzKxDwEAALlJY1mN35wGDRok/V4aA3fv3t1e//33382NN95o8mk7qE2JJnNvv/325pFHHknJGFaZ0ueff74dQ3///fdmw4YN9mfo+hNPPGE6dOgQee4nn3xiM8aVKQ4AmcS+4H/bgX0BkH8IOgNIOZUsfe655yIn0zVI6927t+nfv7/5+uuvYx5IqH/SaaedZtq1a2cDzyW+rMqUMUOHDo3cfuaZZ+yBx6+//lrieevWrbMzoF988cXIfbfddpt9fabsueeekevaDumgTOcjjzwycvuvf/1r1J/12Wef2ZMNa9assbcbNmxoM9EBoNgpY0b7HNcjqmfPnuZf//rXNvsVRyckle3Sq1evqNUlGjVqZCf1vPfee5HKEn7Tpk2zk6Ic7/e4owlWO+ywg72uk87aNwIAgOLwyy+/RKpm+SejJZvt7CioqoyxZAwZMsSO2VO5nH766TF/njKzdUwlV111VUoqdSmzetGiRTZjW+cndMyl6jc6f6HrOl+hcrbq7+zoOEztUQAgk9gX/Bf7AiA/UV4bQFo0bdrUDtg0M1gBZJ2A//e//22XXXfd1famqlWrltmyZYvNGFOfJn+Z0apVq5a43bdvX/P+++9HynoNHz7clphWAFYlr1Rye8KECSUCBsqIPvbYYzP6KauUuMs8Viadyre2bt3aDmadf/zjH6Z69eql+jkjR440+++/v5k3b579nbV9mjdvbkuUaTb47Nmz7WegAb1UrlzZBut32mmnUv6GAFAYlDWzdOlSW1lDGUBXX321PTmr71EFkfW9rUk7+p7VvkyVNmSfffbZ5r00werRRx+1i/Zf6hutEpb67lUW9DfffGO++uqrEpk2OoHrV7ZsWXsi9Omnn7a3laF0xBFH2PXRY6K+0FpXAABQWNRmystNREuWxoua5KYxqcbe119/feQYI1epvLWqp4mCzQo6p0KVKlUSPkfZ1MoI17Gf205qwXLllVeacuU4hQogM9gXsC8A8hlHTADSRsHljz/+2AwbNswO1Fy27fz58+0SizKddSJeJ9397r//flO3bl0bFNDJf2U2v/rqq1F7YqqvdKoGqGFoxvZTTz1lA+QK+E6aNMkuXhdeeGGpg84KtH/44Yfm5JNPNhMnTrT3aeZ6tNnru+22mx00e8uFAUCxU1B57Nixtl+gslhUYlGL/zvbq3z58rYFRLQTmW7Sk/ZNkydPtkus/dyzzz5r6tWrF/XxW265xX6va1KW1sdbvUMUzCboDABA4XMTiEtDY+e33nrLvpcmbWuM3KZNG5OrLrjgApvlJw8//HCJyduZosCzCzqvXr3alto+4IADMr4eACDsC9gXAPmE8toA0kon4VWeSkFmDdpU+lpZzgocKxtXjyt7Sz2b9TyVg1bWc7SAs3PNNdeYb7/91l4qiKqMac061mXHjh3t++jxbAScXUBCvUEfeughW9ra/a7poMCzsrs1c13BbgWXtU01MFcpbZWAffzxx23WMwFnANiWsod1YlH7qTvuuCOSVazMIn2fq6zl3nvvbUtxjxo1yvZZ1gQov5UrV5q3337b7psOP/xwW/FDWc56f2U+77HHHubUU0+1PQSnT59uWrZsGfPjUFB5xowZdn+mrGtNUiK7BgCAwqdjB69U9BPWcUyfPn3sdVUg85aPzjWvvPKKbWciGt+6ntSZ1qxZMzuJ3onVJgwA0oF9AfsCIJ9ttzUVU2UAAAAAAAAAJE2n6DTxzfV11uRhTVyLR4FZ1/9YE5/PPffcbZ6jFh+a/K2gs0ydOtVOSlaFMVV8kRNOOMFWYolGlWG0pFK/fv3s5Dov7/q0atVqm5ZbXurPrMmAoufp+c6DDz5og+2l0aVLF1u5zVWhydakdgDFh30B+wIgn1FeGwAAAAAAAMgy9RRWhu0333wTCawmCjoH0bp1a9uWSW2gRJVZxo0bF/j1ClI/8MADJpX23XffbYLOXgq4B6XWJlOmTIncXrt2bUp7qvqzDgEgndgX/A/7AiD/UF4bAAAAAAAAyAHKSHbUNipVlEXs2nWMHz/evP/++yl770KzYcOGEtu+Xr16WV0fAMWHfUH2sS8AkkPQGQAAAAAAAMgBHTt2jFyfMWNGSvsUDxgwIHJb2c5hAtYq95rKRT2bS/Nzrr/++sjrunXrVuKx0vaCfvrpp82mTZsiGYcHHnhgqd4PAMJiX8C+AMhXBJ0BAAAAAACAHHDooYdGrn/wwQcpfe9rr73WVKhQwV6fPHlyqBLb+Z6t5vpZJzJ37lxz5ZVXRm4fdthhZuedd07j2gHAttgXpB77AiAzCDoDAAAAAAAAOVJStVGjRva6ejsvXbo0Ze/dsGFDc84550Ruf/LJJ6YYqCe1+lo/9NBD5ueff476nC1bttie1507dzYrV660922//fbm1ltvjfveyqpWNrSW0mZYA4DDviD12BcAmUHQGQAAAAAAAMgRp5xySuT6yy+/nNL3vvrqq80OO+xgio0C+Oeff77ZZZddTIsWLcyxxx5rBg4caM4++2xzzDHHmLp165p+/fpFAs5ly5Y1Tz75pGnXrl22Vx1AkWJfkHrsC4D0I+gMAAAAAAAA5Aj1XlbmrIwZMyal712nTh1z8cUXm2KlMttz5swxL730khkxYoR57LHHzGuvvWZWrFgReY6C0u+//7454YQTEr6fekg7ClQDQKqwL0gf9gVA+hB0BgAAAAAAAHJE8+bNTc+ePe319957z/YZTqVBgwaZHXfc0RSLrl27mmnTppn77rvPnHTSSWbvvfc2jRs3NlWqVDHly5c3tWrVMu3btzfnnnuuGTt2rPn6669Nly5dAgWcZ82aFbl96qmnpvk3AVBM2BekFvsCIDO22+qdkgcAAAAAAAAgqz766COz//772+uXXHKJufvuu/lEcsznn39uA9guO/qrr74i2xlASrEvyH3sC4CSyHQGAAAAAAAAcogybY888kh7ffjw4ZFew8gdEydOjFy/8cYbCTgDSDn2BbmPfQFQEkFnAAAAAAAAIMfcdtttply5cmb9+vXmjjvuyPbqIEagQaW5jz/+eLYPgLRgX5Db2BcAJRF0BpB2l156qdluu+3MDjvsYBYtWsQWzyEnnnii/Wx23nlns2bNmmyvDoACxX4gd7EfAAAgd+25557mggsusNfvueces3jx4myvEv7f5s2bzeTJk+31m266yY6rASAd2BfkLvYFwLYIOgNIq1mzZpkHHngg0oeqQYMG2zyne/fudoDmlkaNGplNmzYFev8hQ4ZEXqcT5/ni2GOPLfE7axsk8u6775Z4TZClR48ecd9Tg2PNnF++fLm57rrrUvgbAsB/sR+Ijv0AAAAIQr2ct27dajZs2GDq16/PRssRGkevXbvWfjZHHXVUtlcHQIFjX5Cb2BcA2yLoDCCtBg0aZGd9Va5c2VxxxRWBXrNw4ULzyCOPFOwn88ILL5iXXnrJ5ILddtvNnHzyyfb6Qw89ZObNm5ftVQJQYNgPbIv9AAAAAAAAAApNuWyvAIDC9eGHH5o333zTXj/rrLNMzZo1A7/2lltuMQMHDrQluQuJSlhfeOGFpX6fevXqmT59+iR8XsuWLRM+Z/DgwebJJ5+0kwOuv/5689RTT5V6/QBA2A9si/0AAAAAAAAAChFBZwBpM3ToUHupMs/nn39+qNcuW7bM3HvvvebKK680hUTZ3j/99JMpX7686d27t3nuueeSep/mzZub+++/PyXr1KpVK9OtWzfz3nvvmWeffdbcfPPNpnHjxil5bwDFjf3AttgPAAAAAAAAoBBRXhtAWsydO9e88cYb9vqBBx5og6RBdOrUKXL99ttvtz2SCsXEiRPNiBEjIuVmFezNFcoqly1btqQsmA2guLEf2Bb7AQAAAAAAABQqgs4A0mLkyJFm69at9voJJ5wQ+HWnnnqqadGihb2+atUqc+eddxbEJ7Rx40Zz9tlnR/ooX3PNNSaX9OrVy1SoUMFed6W2AaA02A+UxH4AAAAAAAAAhYygM4C0GD16dOS6ykgHVbZsWXPDDTdEbg8bNsysXLnS5Dv1Sp43b569/tBDD5mKFSuaXFK1alVzyCGH2Os///yzefvtt7O9SgDyHPuBktgPAAAAAAAAoJARdAaQcl9++aVZsGCBvd6yZUuzyy67hHp93759Tbt27ez1devWmVtvvTWvP6XPPvvM3HXXXZFM7h49ephcdPDBB0euv/7661ldFwD5jf1ASewHAAAAAAAAUOjKZXsFABQeb5Zs165dQ79+u+22M//85z/NMcccY2+rx/Df/va30MHrXKAy1eqXrF7JNWrUiASfU1Gm9bXXXjMzZsywZcgrV65s6tSpY/bbbz/Tvn17U65c+K9372dFpjOA0mA/8D/sBwAAAPLfpk2bbCuwH3/80U4kZ8wMAMWHfQGQGEFnACk3ZcqUyPW2bdsm9R5HH320DaDqvRRgvfnmm23wOVljx461Syr169fPrmM8d9xxh/niiy/s9dtvv93Url07JT976tSpkaC8X7169WyQ/pJLLjHly5cP/J5t2rSx5c0VIJ87d65ZvXq1qV69ekrWF0BxYT/wP+wHAAAAEvvll19sdZhPP/3UTJs2zV4qwOuMHDnSnH766YE35ZAhQ0q07gpCk9+vueaaqI9VqFDBvp/W4Z133jEvvviiOfbYY0O9PwAgPvYFQP4j6AwgLWVVHZXXTtZNN91kDj30UHv9scceM3//+99N48aNkw7SPvDAAyaV9t1337hBZwVu3SC3W7duZsCAASYTlixZYrfVCy+8YF5++WWbAR1EpUqV7Pb9/vvvI5+j1hsAwmI/8F/sBwAAABI76aSTzJgxY8zWrVtzenOpXdaNN95ox8yDBw+2E8GTqTIGANgW+wKgMHBkBCClNEj0zkZu0KBB0u+lklXdu3c37777rvn999/t4G7EiBEmX7bDWWedZX777Tez/fbbm0ceecSWDS8tZUoff/zxNhivvtd169Y1ZcqUsYHmyZMn22xwzQiXTz75xGaMv/feezagHET9+vUjQef58+cTdAYQGvuB/20H9gMAAACJLV26NK0B5w4dOpiOHTsGel48qgx2xRVXmPPPP9989913ZtSoUbadFgCg9NgXAIWBoDOAlJdBUaDVqVmzZqneT9nOBxxwgL3+xBNPmCuvvNI0b9489PuotJaWTFFmtoK9ctVVV9neT6nIrF60aJENYvs1adLELir5ff3119uyYKIA9J133hmzRJhfrVq1Itd/+umnUq8zgOLDfuC/2A8AAAAEp8nUe+yxhw38uuW4444zCxcuLPVmPOqoo1J2PkBj7kGDBplff/3VttA688wzUzLBHADAvgAoBGWyvQIACsv69etL3N5hhx1K9X7777+/OfLII+119RpWQDXXKetYg1BRsFlB51SoUqVK1ICzlwa7ygg/+eSTI/fdddddZvPmzYF+hvfz8n+WABAE+wH2AwAAAGE8+OCDduLirFmzbO9mZRIr6KxAdK7RuPyEE06w1+fMmWPGjh2b7VUCgILAvgAoDLl39AagoKSiRJaynd3MYfV5mjlzpsllF1xwgR0wy8MPP2wqVKiQ8XVQ4NlZvXq1LbUdRK730AKQf9gPsB8AAACIp1WrVjaYmy/69u0buf74449ndV0AoFCwLwAKA0FnAClVuXLlErc3btxY6vfce++9TZ8+fez1P//801x77bUmV73yyivm5ZdfttdPP/1025M6G5o1a2Z23XXXyO2vv/460Ou8n5f/swSAINgPsB8AAACZoZ7CmqCtReNP56WXXjJHH320adSokZ0EvfPOO5vDDjvMPPXUU0w0ToGDDz7Y7Ljjjvb666+/btasWZOKtwWApLAvyA72BUB09HQGkFIaeFWsWDHS13nFihWmdu3aKcncVTBXQWcFdtWrWOW2glLJq1SXvVIvp/3226/EfZ9//nnk+tSpU02nTp1ivl79mZ3p06eXeK5KyijYXhq77LKLmT9/fuRzCGL58uWR63Xr1i3VzwdQnNgPsB8AAADZoYpb/fv3N6+++uo247y3337bLqNHjzYvvviiqVSpEh9TksqVK2e6du1qA86///673a7HH3882xNATmBfkBnsC4DoCDoDSCnNsFaG7TfffBMJrO6xxx6lft/WrVvbPsWamS3XXHONGTduXODXKwD8wAMPmFTad999twk6e82ePTvwe61bt85MmTIlcnvt2rUp7asaNGt58eLFkeveTGkACIr9wP+wHwAAAJmyefNmc9xxx5kJEyaY7bff3nTp0sVWwNKE8MmTJ5sFCxbY57311lvmsssuMw899FDRfDjLli2z5xLUg/nXX381O+20k2nQoIE54IADzO67757Ue7qgsxB0BpAr2BfExr4AyAyCzgBSrm3btpGg87fffmsOPfTQlLzvkCFDzLPPPmsPoMaPH2/ef//9lLxvIdqwYYPd9k69evUCvebHH3+M3G7Xrl3a1g9AYWM/kH3sBwAAKC7PP/+82bRpkznyyCPNY489ZurXrx95TGPoq666ytxxxx329iOPPGIGDx4cc6LxPffcY+bOnZvS9VP1sho1aphsePjhh+0SjSqMqYVX7969Q73nXnvtVWKSOwDkAvYFsbEvADKDoDOAlOvYsaP5z3/+Y6/PmDEjZe+rWdoDBgywA2iX7az+GUED1lrSLczP0fNuuOEGe71bt27m3XffTdl6PP300/aEg8s6PPDAAxO+ZtasWbZ8uTRv3tzO/gaAZLAfYD8AAAAyS+M/Zd+qtLZKfnrp9m233Wbee+8926pq69atZsyYMTbwHI16Quu5qXTFFVdkLegcj1pd9enTxwwcONAGJMqWLRvodd6Kbl999ZUN7Pu3OwBkGvuC5LAvAFKnTArfCwAsb2bzBx98kNKtohnIFSpUsNdVIixMie18z1hzAeFENCP9yiuvjNw+7LDDzM4775zwddqeTqqy0wEUJ/YDqcd+AAAAJHL33XfHDHxqMrImcRdTdm7Lli3tZHWVHF+6dKntv6zWVjNnzjS33367LbHtDB8+3FxyySWB33uXXXYxZcr897SqAs7eVlUAkE3sC0piXwBkFkFnAGkpq9qoUSN7XWW2NbhLlYYNG5pzzjkncvuTTz4xxUAnBNTXWn23fv7556jP2bJli+1T1blzZ7Ny5Up7n3p53XrrrYF+xsSJEyPX//KXv6RozQEUI/YDqcd+AAAAxNO0aVNbKjqe9u3bR67Pnz8/5vNUhUvZ0KlcYpXyTpeLLrrIfP311+af//ynrZBWt25dU758eVOlShWz55572sxrZSirHLnzwAMPBJ44r+D+jjvuGLn9008/peX3AIAw2BeUxL4AyDyCzgDS4pRTTolcf/nll1P63ldffbXZYYcdTLFRAP/888+3M6pbtGhhjj32WFsC7OyzzzbHHHOMHUT369cvEnBWWbAnn3wyUG9mzfbW7G9RVjSZzgBKi/1A6rEfAAAAsbRp0ybhxqlZs2bk+tq1awt6Y3p/11iqVatm+5+qvZQTdNK2eM9LrF+/Pom1BIDUYl9QEvsCIPMIOgNIC5XtUvkuUa+oVKpTp465+OKLTbFSme05c+bYPlsjRoywPa5fe+01s2LFishzFJR+//33zQknnBDoPdX3y/WAVuCaXlQASov9QPqwHwAAAH7erNtYlOnr/PHHH2zE/w8ce3tbqwKYynAHoQxuAMgl7AuSw74ASB2CzgDSQjOFe/bsaa+/9957ts9wKg0aNCjQgVSh6Nq1q5k2bZq57777zEknnWTLpjVu3NiWBtOJg1q1atlSaeeee64ZO3asLSPWpUuXwO+v/lUuO/rCCy9M428CoFiwH0gt9gMAACAeN+kb4fXo0SNyfcOGDebHH38M9LqNGzdGrleuXJlNDyDr2Bckj30BkBrlUvQ+ALCNq666yrz++uuR3kh33313zH5RYVWvXt2sWbMmr7f6kCFD7BKEgsH77LOPXVIdFJ49e7adGCDKjM50ry0AhYv9QHzsBwAAQC665557Uj5x/MYbbzQ1atQwuUgtrLxURcxbcjsaZYp7z0mo3RUAFBL2BewLgGQQdAaQNsq0PfLII82bb75pM2mvvfbaQL00kFm33XabLQumkto33HADmx9AyrAfyA/sBwAAgJdaObmJyalyxRVX5GzQ2d+POUjW8tKlSyPltTWWrl+/ftrWDwCygX0B+wIgGZTXBpD2E9kagGkQd8cdd7C1c8y8efPM008/ba+rNPduu+2W7VUCUGDYD+Q29gMAAKDYff755yVu16tXL+Fr1NLKad26tT3vAQDIX+wLgNQg6Awgrfbcc09zwQUXRMqyLF68mC2eQ6655hpbFqx27drmn//8Z7ZXB0ABYj+Q29gPAACAaC2wlMWbyiWX2zg9/vjjJQLItWrVSviaGTNmRK537NgxbesGANnCvoB9AZAMgs4A0k69nDXI3LBhAyWncswzzzxjP5uff/7Z7LTTTtleHQAFiv1A7mI/AAAACs2vv/4a+LnPP/98pPqXnHrqqYFeN3ny5Mj1Qw89NOQaAgDSjX0BkB0EnQEAAAAAAAAUhDvvvNMGgl944QWzcePGqM/55ZdfzPXXX29OPPHESG/mJk2amEsuuSTh+2/evDkSdN5+++0JOgNADmJfAGQHDUcAAAAAAAAAZMW0adPMwIEDt7l/yZIlkevXXXedrZ7jte+++5rhw4dv8zoFkd955x27VKhQwZbM3m233Wx1r99//93Mnz/fTJkypURAWiW1x44daypVqpRwfSdOnGiD1tKzZ0+qhgFACrAvAAoDQWfYsrpTp061y6effmqXlStX2i1z2mmnmVGjRqVkKw0ZMsTccMMNgZ47adIk0717dz4dAAAAAACAAi+B6u2RHM3ChQvt4hWkRdSmTZvM9OnT7RLLEUccYYPX9evXD7S+zz33XOT6GWecEeg1AID42BcAhYGgM0ydOnXYCgAAAAAAAMh7f//73023bt3MRx99ZD755BPz448/2uQKLdttt50NVjdv3tx06dLFnHTSSaZdu3ahgiLPPvusva73UKYzACD3sC8AsmO7ra5xCYqWDridRo0amZYtW5rx48enNdN55syZcZ+rPjqVK1dOyc8FAAAAAAAASuuhhx4y559/vr3+6KOPmrPOOouNCgBFhn0BEBuZzrB9cTp06GAXZT2rt42Cvum05557suUBAAAAAACQF7Zs2WLuuOMOe71Zs2ZmwIAB2V4lAECGsS8A4iPojMB9lgEAAAAAAIBiNHr0aPP999/b67feeqspV47TqgBQbNgXAPGVSfA4AAAAAAAAABStTZs22UqB0qNHD3Pcccdle5UAABnGvgBIjCl5AAAAAAAAABBDhQoVbDs6AEDxYl8AJEbQGVlx2GGHmS+++MKsWbPG7LTTTqZVq1bmiCOOMOecc46pXr16Uu+5aNGiQM9r0KBBUu8PAAAAAAAAAAAAYFsEnZEVb7/9duT68uXLzXvvvWcX9cQZNWqU6dWrV+j3bNiwYaDnbd26NfR7AwAAAAAAAAAAAIiOoDMyqk2bNqZ3796mY8eOpl69euaPP/4w3377rRk9erQZP368zXxWX5zXXnvNHHnkkWlZhyFDhphq1aqZyy67LC3vDwAAAAAAAAAAABST7baS9gkf9ahp0qSJvX7aaafZzONUcKW0Y3nkkUfMueeea68rID1v3jxTsWLFlJbX7tChg/npp59M/fr1A5fjBgAAAAAAAAAAABAbmc7ImHgBZ1E/508//dSMGDHCLFmyxLzwwgvmlFNOCfz+QXo1ly1bNvD7AQAAAAAAAAAAAEisTIDnABmjwLOjHs8AAAAAAAAAAAAAchtBZ+SUVq1aRa4vXrw4q+sCAAAAAAAAAAAAIDGCzsgp2223XbZXAQAAAAAAAAAAAEAIBJ2RU2bPnh25Xq9evayuCwAAAAAAAAAAAIDECDojpzzyyCOR6926dcvqugAAAAAAAAAAAABIjKAzUmLUqFG2NLaWIUOGbPP4zJkzzXfffRf3PR599FEzfPhwe71u3bqmT58+fDoAAAAAAAAAAABAjiuX7RVA9n3wwQclAsIrVqyIXNf9Cih7nX766aF/xmeffWYGDhxoDjroIHPkkUeaNm3amJo1a5rNmzebb775xowePdqMHz/ePrds2bI2AF25cuVS/V4AAAAAAAAAAAAA0o+gM2x28RNPPBF1S3z44Yd2KW3QWbZs2WLeeecdu8SiQPSIESPM0UcfzScDAAAAAAAAAAAA5AGCzsiIo446ygaTP/74Y/P555+bZcuWmZUrV5qtW7eaGjVqmHbt2pkjjjjCBrSrVavGpwIAAAAAAAAAAADkie22KuoHFIkGDRqYxYsXm/r165tFixZle3UAAAAAAAAAAACAvFcm2ysAAAAAAAAAAAAAAMhfBJ0BAAAAAAAAAAAAAEkj6AwAAAAAAAAAAAAASBpBZwAAAAAAAAAAAABA0gg6AwAAAAAAAAAAAACSRtAZAAAAAAAAAAAAAJA0gs4AAAAAAAAAAAAAgKQRdAYAAAAAAAAAAAAAJI2gMwAAAAAAAAAAAAAgaQSdAQAAAAAAAAAAAABJI+gMAAAAAAAAAAAAAEgaQWcAAAAAAAAAAAAAQNIIOgMAAAAAAAAAAAAAkkbQGQAAAAAAAAAAAACQNILOAAAAAAAAAAAAAICkEXQGAAAAAAAAAAAAACSNoDMAAAAAAAAAAAAAIGnlkn8pAAAAAAAAisFdd91l1q5da6pVq2Yuu+yybK8O8tTbb79tqlatajp16pTtVQEAAECKEXQGAAAAAABAwqDz4sWLTf369Qk6o1Q2bdrEFgQAAChAlNcGAAAAAAAAkBEEnQEAAAoTQWcAAAAAAAAAGbFx40a2NAAAQAGivHYUq1evNh9++KFZuHChvb5582Zz3XXXZf7TAQAAAAAAAAoIQWcAAIDCRNDZY8qUKebGG28048aNM1u3bi2xofxB52XLlplevXqZP//803Tu3Nncc889mfnEAAAAkDfU+/Kzzz4z++67r6lXr162VwcAACDrCDoDAAAUJspr/7+hQ4earl27mrfeessGkhV0dks0derUMXXr1jXTpk0zjzzyiFm5cmUmPzcAAADkuN9//92MHj3afPrpp/ZStwEAAIrdH3/8YRcAAAAUFoLOxpgHHnjAXH311baMtoLMLVu2NOedd57NSIlnwIAB9lIHymPHjs3MJwYAAIC8oGDzr7/+ar788kuzbt06exsAAADGHiMBAACgsBR90Hnp0qVm0KBBdmNUrFjRjBw50syePdsGovfbb7+4G++II44wFSpUsNcnTZqUkQ8MAAAAuU9ZzR9++KH56aefzC+//GIvdZtsZwAAAGMn5AEAAKCwFH3Q+eGHH7a9ZLbbbjszbNgwc9pppwXeeAo477nnnjY7eubMmWn9oAAAAJA7fZpfffVVs2TJkoRZzj/++KM9ztSlbpPtDAAAQNAZAACgEBV90HncuHF2Q9SrV8+cffbZoTdgs2bN7KVOJAIAAKCwBenT7M1y3rRpk2nVqpW9JNsZAADgv9auXcumAAAAKDBFH3T+/vvvbfbJ/vvvby/D2mmnnewlB8sAAACFL0ifZm+W884772xq165tL8l2BgAA+K81a9awKQAAAApM0Qed1WNPatSokdQGVNaKlC9fPqUfDAAAAPKvT7M/y3nXXXe19zdu3JhsZwAAgP+3evVqtgUAAECBKfqgc/Xq1Ut1sLtgwQJ7WatWrZR+MAAAAMgtQfo0+7Ocd9hhB3t/5cqVyXYGAAD4fzpe+uOPP9geAAAABaTog87KOtm6dav57LPPQm+89evXmylTptiTjurVBwAAgMIUpE+z/zn16tWzJ1Pdotv0dgYAAPgvsp0BAAAKSzlT5Hr06GEzUubNm2cmT55sunbtGvi19913n9mwYYMNOut9AAAAUJi8GcxVq1Y1q1atspe6XbduXft4mTJlIs+RL774Iup7uddo0mPnzp0z/JsAAADkhpUrV9pKMAAAACgMRR907tevn7ntttvMn3/+ac455xzzwQcfBOrvPGHCBDNkyBB7XWUT+/fvn4GPCwAAAJnmzWD+7bff7KKezpp4KC7bebfddjNbtmwxzZs3T/ieet6KFSsysPYAAAC5afny5WaPPfbI9moAAAAgRYo+6NyyZUtz5plnmkcffdR8++23plOnTuauu+4yPXv2jLrBvv/+e/Pggw/aLGeVSdTJxssvv9zUrFnT5Kuff/7ZTJ061S7K0tGi2aZy2mmnmVGjRqX8Zz7zzDNm5MiR5ssvvzRr1qwxderUsVnmF1xwARk/AAAgZ7Ocy5YtawPGy5Yts9nKuu0ylytVqmQ6duxoW7Akoh7PBxxwQEbWHwAAIBcxAQ8AAKCwFH3QWe69914za9Ys89FHH9ky27169TLVqlUz5cuXj2yo9u3b2ywWBWhFfaDlsMMOM9dff73JZwr4ZsrGjRvNX//6VzN27NgS9y9YsMCMHj3aBqOvu+66vN+mAACg8LKcdRyj6jgKKuv62rVrbfB48+bN9vGZM2eaSy+91Gy//fbZXm0AAICcp3YlmsynSXwAAADIf2WyvQK5QCcGx48fb0ttK5isRSUTle3ryiYqI1cZLe5xlwX8yiuvRJ5TCBo1amQD6elyxhlnRALOBx10kHn55ZdthvWIESNMs2bN7IlclS1X5jmQywEI9z0AAChs6rvsspzXrVtnFi5caObPn28DzrrUbd2vx/U8PR8AkH6rV682r7/+unnooYfMLbfcYm688UY2O5BndA6IbGcAAIDCQabz/1Nf5ieeeMIMHDjQltd+5513opZGrFChgjn44IPN4MGDzYEHHmgKgTKLO3ToYBdlPesEapMmTVL+cyZOnGieffZZe/3oo482L730UmQ2q372McccY/bZZx+b9azte/zxx5vq1aunfD2A0lIvT/3tMhsbAAqfToQqA6dp06Y2uFylShWb2VyjRg2bnaPbKqutx+nTDADpN2XKFBtgHjdu3DYTQTW29dLEcVUyU2Crc+fO5p577uEjAnKM/k8zWYEPAAAA6UPQ2Ud9hbXopKGym5csWWKznlU6UQfBe+21l6lYsaIpJDfccENGfs4dd9xhL8uVK2f7YvsDdrVq1TK33nqrOemkk2yf5+HDh5u///3vGVk3ICwynQGgOKjvsoIV06dPt8eCymZu2LChqV+/vlm8eLHZsGGDvX/nnXc2e++9N32aASCNhg4dagPLGq/7j8ejVSDT93PdunXNq6++asf3em3NmjX5jIAcohYlbdu2zfZqAAAAIAUorx2DAqLq49yzZ09z8skn29nRnTp1KriAc6YoM2jChAn2eo8ePUyDBg2iPu/YY4+1/bRFmdBArtKJLgBA4VPVlSOPPNJOQKxdu7bNcFa1mzZt2tiJirqt+/W4nkeVFgBIjwceeMBcffXVttqEAs4tW7Y05513ntl3333jvm7AgAH28o8//oi0egKQO1wrOwAAAOQ/gs7IiE8//dT2wZVu3brF7a+t4L57jU4MALlIWW8AgOKgYxLX11kZzWrLIgo067br56znAQBSb+nSpWbQoEH2uiaCjxw50syePdsGovfbb7+4rz3iiCNsmyyZNGkSHw+QYzZu3GjWrl2b7dUAAABAChB0RkbohICjGenxuMc1g33u3LmBf8aiRYsSLmSnIlX09wkAKHyaNPfhhx/a0o+bNm0y9erVs5Pi3KLbul+P63lukh0AIHUefvhhG5hSCe1hw4aZ0047LfBrFXDec889bSblzJkz+ViAHKTWdgAAAMh/Rd/TWUHIfv36md9++800b97c9hQOavDgwTYoWrVqVfPEE0+k9YPKdwr4OrFKazvqk+gsXLjQtGrVKtDP8L4OSDeCzgBQHD777LNIlrN88cUXUZ+nx9U3VM/v3LlzhtcSAArbuHHj7KUm+px99tmhX9+sWTP7/ey+ywHkXtB5jz32yPZqAAAAoJSKPuisnk7PPvusnTGt2dNh7Lbbbub222+3r1Xf58MPP7y0n0dB93R2qlSpEve5KlXp6CQvkIsIOgNAcVixYoWdpKjJiYnoeXo+ACC1vv/+ezvu3n///e1lWDvttJO9pIQvkLtBZ1UjSOb/GwAAALmj6IPOb7zxht0Q5cuXN3379g218fT8Cy+80AafXnvtNYLOcSiT3Nu3OR7Xb0tUQi0oZUUn0qFDB1v+Eigt+o0DQHE44IADzJ9//mnWr1+f8LmaOKfnAwBS65dffrGXNWrUSOr1aoPgxv0Aco/O/axatcrUrFkz26sCAACAUij6oPOnn35qN0S7du3MjjvuGGrj6fl77bWXfY+pU6eW5nMoeBUrVoxcT9Tr0J0QkEqVKgX+GYnKdkvZsmUDvx8Q9O8UAFC4qlevbnr16pXt1QAAU+zfxcuXLzerV69O6vULFiywl7Vq1UrxmgFIFf2fEnQGAADIb2VMkXNlulq0aJHU63fffffI+yA29b0OWjLbm0mUqBQ3kC0EnQEAAIDMaNy4sS29q77MYWl8OWXKFDvub9WqVVrWD0DpBaleBwAAgNxW9EFnF+D09hEOwwVF6Q0VPAt50aJFgQcaDRs2TOpzATJZMh4AAL/FixebV1991fYoTPfrkv1ZAJAvevToYS/nzZtnJk+eHOq19913n9mwYUOJ9wGQe5YtW8bkbgAAgDxX9EHnatWq2Q2h3jHJcK9LNmhdLLwzyr/55pu4z3WPlytXzjRv3jzt6wYkI0y/cQBAcVErkdGjR9sWLLpM1FqkNK9L9mcBQD7p169fpFXSOeecE3j8PmHCBDNkyBB7fYcddjD9+/dP63oCSJ6qGfz4449sQgCAxeRqID8VfdB5l112sQe2yfZkdq+rU6dOij+awtKhQwez/fbb2+vvvfdezOfpROknn3wSeU358uUzto5AGC5bAgAAPwWA1U7kyy+/NOvWrbO30/W6ZH8WAOSTli1bmjPPPNOO3b/99lvTqVMn8/rrr9vb0aj91RVXXGGOOuooO8ZUae3LL7+cfrFAjlM1AwAAmFwN5K+iDzrvv//+dkMsWLDAvP3226E23vjx4+0sTA1gO3funKaPqHB6Oh9yyCH2+jvvvBOzxPaLL74YKVXep0+fjK4jEAZBZwBArMHxhx9+aH766Sfzyy+/2EvdTpSBnMzrkv1ZAJCP7r33XtOlSxcbaFZgqlevXqZGjRpmzJgxkee0b9/eTixXxaxhw4aZP/74w95/2GGHmeuvvz6Law8gaFYbrawAAEyuBvJX0Qede/fuHdkY5513nlmxYkWgDffzzz/b50d7n2I0atQoG3zX4sqX+WmmuWzevNlccMEFZsuWLSUe17YfPHiwvb7TTjuZgQMHZmDNgdL1gwcAINrg2E1M1KVuJ8pATuZ1yf4sAMhHqpylid8qta3AsxZNuFm5cqX9DhRVfVBfWPe4nHbaaeaVV16JPAdA7vrzzz/NDz/8kO3VAABksWw2k6uB/Fb0QecjjjjC7LPPPnZj6MC2Y8eOCTOe9bjKeen5Gri2a9fOzrLOVx988IENGrvl+eefjzz23XfflXhMS7IOPvhgc+KJJ9rr2rEceuih9nLatGlm5MiRdpsq41xuvfVWU7169RT8dkB66KR+rHJ+AIDiHCR7B8ebNm0yrVq1speJMpCTeV2yPwsA8pn6Mj/xxBO2ZZPG4JUrV44EmL2B5goVKpgjjzzSvPvuu3as6Vo9Ach9c+bMyfYqAACyWDabydVAfiuX7RXIBQqkqkyXgkjz58+3gWiV4+revbtp2rSpqVKlin1MQeZJkyaZuXPnRl6rxzTozWfDhw+P+TvopKUWr9NPPz3pn/X444/b8tljx46121KLV5kyZcy1115rzj777KR/BpCpGdgqsa0TXQCA4hskq3+y+opecsklkWCGd3C88847m9q1a9tL3a5bt6593LV28Urmdcn+LAAoBF27drWLqmcpu1mTgJT1rGPzOnXqmL322stUrFgx26sJIAmqVrBq1SpbPh8AULhls5XI5x+3+idXt27d2nz11VeRydUdOnRgMiGQ4wg6G2O/vFRuq2/fvrbEs2ZHK7DsDS57udnTOgD+z3/+Y9q0aZPZTy2PVapUybzxxhvm6aeftsH+GTNmmDVr1tgTAzppcOGFF9IfG3lDEygIOgNAcYk1SPYPjnfddVf7/MaNG9vnxBokJ/O6ZH8WABSasmXL2j7OWgAUjtmzZ5sDDjgg26sBAEihWGWzveNWJlcD+a/oy2s7ymqePn26Ofnkk025cuW2KdHlXfT4KaecYr744gtbMjrfKfgb7/eNVq7MT9nP7vFYPZ29tJ3Vj0szWHWyVGW1lTXUuXPnNPyGQPqCzgCA4hGvt5R/cKwSsKLJSS4DOVq/5WRel+zPAgAAyAdKAvnjjz+yvRoAgBRKVDY73uRqWkkB+YOgs0eDBg3MU089ZUtsKxB77rnnmj59+pgePXrYS93W/fpC/Pe//22fD6B4KeAAACgesQbJH330UYnBcb169eyJUrfodrRBsn9QHeR1ybwGAAAg2zZv3mwWLVpkli9fbkvjx6NjmljVBwEA+cc/jm3VqtU241YmVwOFgfLaUehkXf/+/e0CALGoNDwAoDjE6y313HPPmZ122skGoUXVcKJx/ZY/++wzW91Fly6IHfR1EvY1VJIBkO8UoOrXr5/57bffTPPmzc2tt94a+LWDBw+2wauqVauaJ554Iq3rCSA2HTM1bNjQXh86dKipXr163M01c+ZMs8cee9iJfgCA/OYNKOuYbNWqVfbSjVs1kXvq1KnbTK52dPvnn3+mlRSQBwg6A0CSVq9ezbYDgCIRr7eUTprqMQVCggROVqxYYa/rUrfDvi6Z1wBAPhs7dqx59tlnbfDp4YcfDvXa3Xbbzdx+++32tWrzdPjhh5t8pBOtOhmrRfskLStXrrSPnXbaabYqG1BolcV0nOXKqwIA8n8CtyYQatF3vJtUVJqJ3AByD0FnAChFT2fNuitfvjzbEAAKWLzeUjrpX6FCBXu7Y8eOply5+IfX6rt8wAEH2Ou6/PPPP8369esTroP3dcm8BgDy2RtvvGEvddzdt2/fUK/V8y+88EJb2ve1117L26BznTp1sr0KQMZ9+eWXBJ0BoIAmcJctW9ZOjl62bJkNHut2aSZyA8g9BJ0BIElbt2615WA4AQQAhS1RbykFo/fbbz/TrFkzs//++wd+Xw2se/XqFXp9knkNAOT797C0a9fO7LjjjqFeq+fvtdde9j2UJVwIGjVqZFq2bGnGjx+f7VUB0krHWApMMOYGgPyfwL1x48bIBGpdVzKPxtSaGKgAdDITuQHkHoLOPjqYnTZtmpk/f34kizGo6667LtWfD4Act3z5cgbAAFBEWc70lgKAzPv+++9tCcYWLVok9frdd9/dBp31PvlK5xs6dOhgFwXgdM6iSZMm2V4tIO1mzJhhDjvsMLY0AOQhlcF2E7jXrVtnk3cUc1Eij25Xq1bN1KhRIzKRW5nOlM0G8htB5/+nGc9XX321effdd+2XXjIIOgPFR73VAADFMUgWeksBQOa5lgLKbElGlSpV7KVOcuarG264IdurACTtrLPOMtOnT4/cfvDBB23Gfr9+/RK+VhMsVq9ebSvEAADyi8pgqxx206ZNbZBZx2TKbFagWQFo3a5UqZJ9nLLZQGEg6GyMGT58uDnvvPNseYdkA86u8T2A4kLQGQCKY5BMbykAyB5lwSjopJOTyXCvSzZoDaB0Zs2aVSLovGDBAtvHM0xv527duvExAECeURlsxVy0D1ClFk3obtiwoalfv75ZvHix2bBhg71fbav23ntvymYDBaDog85fffWVDTjrZKILHqtcVfv27U3NmjVN+fLls/0ZAchhypZQ5gUnsACgsAfJLssuHnpLAUB67LLLLjZwnGxPZvc6+sIC+Wnu3Llm3333ZdwNAHlGVSqOPPJI8+2335ratWvbSYTq27zDDjvY7Ga1P9H9Gkvredtvv322VxlAKRV90HnYsGE24Kxgc+vWrc0zzzxjLwEgKPUdadasGRsMAAp0kNyrV68S92lGtspu6+SnejwHlezrAKDY7b///nbCuLIj3377bXPooYcGfu348eNtiwSN+ekRCOQnTQCcOXOm6dSpU7ZXBQAQkgLLrmWVMpoVcBYFmnVb99etW9c+T8d8APJbGVPkJk2aZC/VO+DNN98k4AwgtCVLlrDVAKBI/P7772b06NF2QKxL3U7n6wAAxvTu3TuyGVSpTK0PgrbC0fOjvQ9KWrRoUcLFVYgDsuHrr782mzZtYuMDQB7RuPfDDz+0CTv6Dtfk6z/++COy6Lbu1+N6HuNkIP8VfdB56dKldsbzwQcfbHsJAEBYBJ0BoPhmaau34Lp16+ztdL4OAGDMEUccYfbZZx+7KX744QdbllEZz/HocWVF6vka87dr126byhX4H/VXTLTohDCQLQpOzJ49mw8AAPKIKn25LGf54osvbHDZLbotelzP0/MB5LeiL6+tMg6aTUPAGUCyfvnlF3tgVKVKFTYiABTJLG1997vZ2B06dIjbeyrZ16UCJb0BFIpRo0aZLl262OPu+fPn20B08+bNTffu3W1PQB2L6zEFmVXRTD1gHT32xBNPZHX9AZTerFmzTNu2bU3ZsmXZnACQB1SdRpVSdMyWiJ4XtJoNgNxV9EHnJk2amFWrVpmVK1dm+7MAkMd0Ur9FixbZXg0AQIZ6USlrLmjvqWRfV1qupLcyq7/99ltzySWXpD3IDQDp0rp1a/PKK6+Yvn372hOSW7dutYFlb3DZS49LjRo1zH/+8x/Tpk0bPpw4Fi5cmHD7aLIU2c7Ipo0bN9pjmlatWvFBAEAeOOCAA8yff/5p1q9fHyg5UM8HkN+KPuh83HHHmWnTppnJkyfbL8AyZYq+4jiAJBB0BoDi6kWl4MdXX32VMGs52delInPZW9JbZWXTHeQGgHRTVvP06dPNlVdeaQPJmzdvjvnccuXKmRNOOMH861//Mg0aNODDSSDINiK7FLlgxowZpmXLlpy/A4A8UL169Zxvb0J1MCC1ij7CevbZZ9sTdj///LO57777Urx5ARQLHaC4bAoAQOHxZivvvPPOpnbt2vbS9Z6K1aM51uvmzJljg8dvvvlm6MxlvacudTtsSe94rwGAfAmOPvXUU7bEtkpun3vuuaZPnz6mR48e9lK3db++d//9738TcAYKjCq4zJs3L9urAQBI83nWV1991SxZsiStrwkzxgYQTNEHnTXbZsyYMbZ8w9///nczYsSIgJsOAEqW+aJMPwAUJn+28q677mrvb9y4sb0dK6Ab63UKmKiMqQLPjz76qA1KB+HNXNYJ11iB7lglveMFxwEg32jyeP/+/c2DDz5oXnjhBTN+/Hh7qdu6f5dddsn2KgJIky+++IJJ3wBQoJIJBCcbPA4zxgYQTNEHnd9//33bpF4lt1QqSpnPe+21l7n55pvtzJj33nvPPifIAqC4BemDBgDIP/5s5R122MHer0mL8bKWY71uzZo1pkKFCnYmtga2ysRLJEzmsj/Yrb6H8YLjAAAA+WT16tVkOwNAgUomEJzMa6gOBqRH0fd0Vk8oZX84Ko87c+ZMu4Sh94jXTwpA4VuwYIFp3759tlcDAJBC/gCuMuv++OOPyON16tQx06ZNs4FgZS0fcsghpkqVKjFfp8mOKglbpkwZ+xy1eHnttddMv3797OvCZC7XrVs3ap/meKXAY70GAAAgn+j4q0mTJvQaB4ACEisQ3KFDB7P99tun7DVhx9gAgiv6TGcXaHaL/3aYBUBxU+Bgw4YN2V4NAEAKKYPZDURdOUcNYN3ywQcf2ECyy1pWKa94rxs3bpzNzNHzZcWKFfZ57nXRhMlcTrYUOAAAQD5Zu3at+eabb7K9GgCAkOL1Xk6mTVQyr6E6GJA+RZ/pfOCBB5bIdAaAZGnyyQ8//GBat27NRgSAAqGgsILKzZs33+Yx3T9jxgyboayKNwo6f/zxx2bAgAFRX+d/fo0aNcyqVatKvC7aTOwwmcuJSoEzextAIVi2bJnNclTlCAWevBUoErnuuutMPtIkp++++y5yW/sZR/ePGjWqxPNPP/30jK4fkA3Tp083u+++uylfvjwfAADkAdd7WWPgb7/91lxyySWRMbA/EKzzq1999VXczOVkXiNUBwPSp+iDzu+++24aNy+AYqMTPgSdAaBwHHDAAebPP/8069ev3+YxDZJVXltB3h133NHep4CwBrDRXud9fsOGDU39+vXtLG8Njt3r/GW84mUu6/newbTEKwWu26rKEbTcGADkmqlTp5qrr77ajuOTrTaWr0Hn4cOHmyeeeCLqY676hhdBZxSDjRs32sDzfvvtl+1VAQAE4O293K5du7gTqIO0iUrmNWHG2IyXgfCKPugMAKnOuli9erWpXr06GxYACoC+z3v16lXiPgWKP/nkE5u5rEGtvvfdjGr1kHIDVO/rNLC9++67I8/v2LGjzUJu2rSpHdh6X+cd2IbJXFafaH9J72jca1QCvHPnzmnacgCQ+qDreeedZyf0JBtwpsoZUHgUuNhtt91MzZo1s70qAIA44vVelrCB4GSDx1QHA9KLoDMApNjs2bO3mUUHACiscmD6rl+0aJENYASZUZ3MwNY/iE6UuawTrrFKgfvped7SrACQyzSpRwFnfXeJvnt1ArF9+/Y20FQMpXVVPttfQhvAf9tcvf/++6Z3795MLAGAHBat97IbA0vY8XImxthkOwPhEXQGgBSbM2eO2WeffUzFihXZtgBQYFxWsjKdNajViU4FPeLNqE52YKtM5DCZyxpcK4M6WilwPz1XJcABIB8MGzbMBpx1glKVJZ555hla2gCIWL58uZ2csueee7JVACAHxeu9/N5779nnhBkvSybG2FQHA8Ij6ByFSh7qy2jhwoX2+ubNm/O27xOAzNNBzqxZs8y+++7L5geAAhwoz5w50wZ2NVitUaOGqVChQtwZ1ckObJWJHCZzWevnLwUOAIVg0qRJ9rJSpUrmzTffNPXr18/2KgHIMTruatCggdlpp52yvSoAAJ94vZcVe9Fk7iVLlgQeL0smxthUBwPCI+jsMWXKFHPjjTeacePGbdMjyh90Vt9WndRTPyl9Yd1zzz1JbH4AhUpBZ82yJtsZAAovy/mbb76xAV4tCnxoINuwYcOYM6qTHdgqE1nHmmQuAyh2S5cutVnOBx98MAFnADEnf0+cONGeqytbtixbCQByRKLey4sXL7bf4S1atEj4/e0dLzPGBnITQef/N3ToUBtY1peVP+Cswa1fnTp17CyZV1991Xz55Zf2teolBQDugOrzzz+3k1IAAIUzUNakIg2Uy5UrZ3777TezYMECW9JRmTVlypSJOqM62eBx9erVyVwGgP//btR3LxnOAOJRIEIJJV26dGFDAUCOSNR7Wd/dLvNZgeeg42XG2EBuIuhsjHnggQfM1VdfHdkoLVu2NAcddJD9Qpw2bVrMjTdgwAAbdNZMnLFjx5p+/fpl5lMDkBfUm0Q9SqpVq5btVQEApGigrCCzBsmqZKGy2ioFpomHGiTvsssuUWdhEzwGgNJp0qSJWbVqlVm5ciWbEkBcmiCoCSrKoAMA5FaWc6zeyzvuuKMNKP/1r3+1vZeDoLUUkJuKPuisMl2DBg2yG0MnDx966CFz2mmn2dsXXXRR3KDzEUccYU826stTPaYIOgPw0oy7jz/+2Bx++OFsGAAokIGyAs4qB6aBsoLJOpasWrWqHRh37NjRZkBHm4UNAEjecccdZ8fmkydPtsfY3soSAOD37rvvmmOPPdYeowEAskeVv5LpvQwgfxV90Pnhhx82GzdutCW0hw0bFgk4B6GAs3q26stw5syZaf2gAGTXWWedZWdMezPXNHs60WQTHTQpK65Ro0YZWlMAQDrLgem7v1WrVmbDhg12X1CrVi3b51n9mps1a2b2339/PgAASLGzzz7b3HfffXaijy4vueQStjGAmJRNN378eHPMMceY8uXLs6UAIEs0Zk6m9zKA/FX0Qedx48ZFSjloIBuWTi4q6Oxm6wAoTAo4f/LJJ0m9VtlxKrnKYBcACqMcmMq76thPPZ3VlkXlwPS4ntehQ4fA5cAAAMGossSYMWPMkUceaf7+97+bKlWqmDPPPJPNByAmHa+9//775uCDD7aJJgCAzFPlL3/vZbVM+eGHH0zTpk3tMV6QSmGLFy+2MZh9993XjskB5K6iDzp///339uBTWSnJHITutNNO9nLt2rVp+HgAFIJ169bZcoCUhwGA/C8HNn36dLNo0SIbjFbQWSc0VbqRcmAAkD4KHMm//vUvc8UVV0Qyn48//njTpk0b2wcw6Hj+wAMP5KMCisS8efNsVZp27dple1UAoCgpqOztvaxx9N13323bVql6mCpLJpq0rdeMHj3anl/99ttvbcUbJnoDuavog84qhyg1atRIagMq40UKIYNRJ0vvvfde88Ybb5iFCxfa8uHK5O7bt6+54IIL7M4gWaNGjTIDBgwI9NyRI0ea008/PemfBeRqpnSTJk1sfxIAQP6WA1NpV7VmWbZsmc2027p1q9ltt91MxYoVKQcGAGnSvXv3EkFlffeqxVXYNld6j82bN6dhDQHkqqlTp9qgBy2vACB3Wld9+eWXdkKQbidqUZXMa1KB7GogOWVMkXMlHFavXp3U69WrVTRzMp+99tprpm3btuauu+6yM4Y000jbRNmZgwYNMu3btzffffddtlcTyFs6MTZx4sTIRBUAQH5Qea+OHTuaLl262EvNqFZms4LMmqBXrlw5O/lw7733to/HKgcGACj98bRb/LfDLACKi/7vJ0yYYMu5AgByo3WVEgFdiyrdn8rXpGpdlV2tALcu0/3zgEJS9JnOjRs3tn34VDoxLPUimDJlip0t3apVK5OvPv/8c3PCCSfYrB1l7Fx11VXmoIMOsrefffZZ89hjj5k5c+aYnj172iC0TrSWto92vN4LDRo0KNX7A7lKs/ImTZpkDj/8cHpKAUCe8JYD0+BWGc86abnzzjvbCXq61LGR+k/16NHDXgIAUkslsenJCiBZf/zxh3nrrbdMnz59TKVKldiQAJAFLmNZ1VZ1XOdaVMXLXE7mNalc10xnVwOFoOiDzjo5qC8N9XmZPHmy6dq1a+CNpx5SygjWF57eJ1+pD4ICzMrUGT9+fIm+swcffLA9uapsZwWe77zzTjNkyJBS/bzdd9/d7LrrrilYcyD/qDqCynvtt99+2V4VAEAI3hnWqlrRokUL88EHH9jZ1jqO1LHNq6++aifpVatWjW0LACn07rvvsj0BlIqCB0qC+Mtf/mLPfwEAsjeebt26tfnqq68imcsdOnTYpk9zvNeMHTvWXiqOES+5LZly2bGyq6OtI4BtFX157X79+pmyZcvajXHOOecELrej0jwu+Kpex/379zf5SMEvBdvlzDPPLBFwdi6//HKzxx572Ov33HOPnSEKIHkzZsywM+UAAPnDO8Na2c01a9a0Gc46dtQAeP78+WbdunU28Lxy5cpsry4AAAB8VOlQk1gotQ8A2R1P165d217qtu7X40Ff88MPP9jqs2oXGrT0dZhy2dGyq2OtI4BtFX3QuWXLljbYqgNO9TLu1KmTef3112MegH7//ffmiiuuMEcddZT9ctIXj4KyOvGYj15++eXI9QEDBkR9TpkyZSJB9TVr1tjywABK55NPPjFff/01mxEA8oCb6fyf//zHfPzxx3bC3lNPPWXmzp1rFi1aFMl23rx5s62Co8CzbpeGZmHrfZYsWZKy3wMAAKDY6byexuMAgMzwZyy7Cqhqe6rbGjurvacmcgd5zYoVK+zkbyXTKVYRJBjsLZetyeKxXuP/uWqpqstM9ZIGCkHRB53l3nvvNV26dLGBZn3JqW9fjRo1zJgxYyIbqn379maXXXaxpaaHDRsWyfY97LDDzPXXX2/ylcpCivoP7rPPPjGf161bt8h1fcECKD0FLVTWhVnWAJDb3ABVA00NUHW5dOlSs3btWhto9mY7i44TVRVHJRw1CA4rzCxsAAAAhDNz5kyqjwFAhvgzllU11sUjatWqFWl9evvtt0fGvrFeU7FiRbNlyxZbuWL9+vX2+zxRMDhWuexor0kmIxtASQSdjbG1+NXLWKW2FfzRoi8glUZUJrNoFsyyZcsij8tpp51mXnnllchz8pHLtNxtt93i9rRRRrj/NclSRrX6Jmi7a8ei7PJrrrnGZvQAxUZBZwWf//zzz2yvCgAgwQA12ne1jp8UZPZmOzsamD733HM2+Lxw4cLA3/VBZ2EDQDFbvXq1rVL20EMPmVtuucXceOON2V4lAHlE2c7fffddtlcDAAqaP3NYMQGNn92iCqu6f8GCBbYK7UcffRT3NRpjV6pUyQac9bxvvvnGjsXjjZmDlstOlJFNtjMQTOwoY5HRbJknnnjCDBw40Nx1113mnXfesV9efhUqVDAHH3ywGTx4sDnwwANNPvvtt99sOQpp0KBB3OdWr17dzj7SNtFJ09JQ/xxHgX0t6sNw5513mrvvvtv21k6GylsmoplQQK7RAZJOmh1yyCGmSpUq2V4dAIBvcpAboEajwaco23nHHXe0z2vWrFnkcU1W1H1ffPGFHaSqeoyqy2jgXLZs2cCzsDt06GAn7AFAsdPYUQFmTejxVwy67rrrStzWxHFVMtOkn86dO5t77rknw2sLIJfp/JSy5hKdEwMApGY8rXGxo+Mznc/XGFjjao2pNWlbgehor3HP37hxoz0GLF++vH3drFmz7Fg82pjZH0hu3bq1+eqrr6KOs+NlZLts57p169rn7b///vxJADEQdPbp2rWrXRScVHaJ+ujphJ++XOrUqWP22msve0BaCJQ54wQJdLmgs758k9G0aVNz7LHH2sF+w4YNI710XnjhBfP888/bIPi5555rZxydffbZod/fvSeQj3RCTP8LBx10kGnUqFG2VwcA8P80QU/HhWqxMmPGjBLHT6IBav369SOD4GjHScp+Vr8pHetoBreOLzU7W4FnneTU6zVI1jFQtFnYDGwB4L+GDh1qA8v6XvYHnKNVINMYXt+hr776qh3f67U1a9ZkcwKIHLup8uGRRx5pW+oBANI3nvZTyyoFkHVOVIFmtaZSctrHH38c9TXe5ytOofaoGp9rjN2uXbuoweB45bK94+xY2dWObqukN5PCgcSKPuisfs5ugKqAp2bIiDJP1MdZS6HSiU8nSOaMsrxFX+5h9enTx5Yj958I0GyiE044wZZFU0BaX+Z/+9vfzDHHHGO/+IFiooOat956y+y5556mY8eOcUveAwAy44ADDrAnJDXxTll1GuB6aTKiy2zW8ZRalvip17O+4zUrW5PkdFvP00DXzd7WLGq1HVG1neXLlyechQ0AxeaBBx4wV199dYkWUJqwqZOF06ZNi9veSUFnjTXHjh1r22oBgHdyoMbhRx11lJ2oAgBIz3jaUUaz2hsosFy1alUbFNZkbAWVFX9Q7EExGW/PZX1Xv/nmm5Hnawyu5+q9YwWD45XL1vGj9zXxMrK9XLBaz1diHYBtFX1E49JLL7WB0L333ttcdNFFpph4M7a9X+KxuPKRyswJS9k78fzlL3+xs86vvfZas2HDBjNixAjzj3/8I9TPCFL2WzsR7VCAXKayMPp77t69O4NeAMgytRhRaVa57777tun9pxnWmigUiwbH6vWsyjkaPLvezxrweicX6fhn4sSJtuXCDz/8YN9XM701IVK9rTQjmzJeAIqVTkIOGjQoMo5VH2dNahaN4+MFnY844gh7UlJj3kmTJhF0BrANTUpRMKNnz572mAsAkPrxtOh4TO01NdZVkFeJf23atDGtWrUys2fPtuftFRRW9Qlv1rKCw8p8VsDaPd/R66JVCAtTLlvvGysj20/Pcy1LAWyr6IPO+pLRST5lFhYbzQxygpTMdjOS0tVzViW1FXhWmbT33nsvdNA5SA+eaL0TgVykoIQyMnQgte+++5L1DAA5yk3Ki8VlOWsQq4mOrvezy3aOFpzWdQ3O165da1+jgff7779vX6NjNg3AdUJUJWLDZD4vXrzYzsjWfkXlwQAgXzz88MN24o6+E4cNGxYJOAehgLPG+/r+mzlzZlrXE0D+UiBE1RCUFEEZfgBIDwV4NeZV+ylNJFQcwFWajZaBrPFuMqWvJcxrdGzpz8iOF09SBjeA6Io+6KyTdjrBF63/U6HTF7sOpNUrQeUe41m9enXkSzddvZM1w0jro5lCOikKFDsdeKn3nIIM6jXveoYCALJDg9Bo7UoUJI7WEsEfSNZxp7L1omU7e4PTmhjogskKlui2C1ZPmDChRLC6WrVq9vjJLSrRrRnc/mNbDdRHjx5te14pc/qSSy6hVDeAvKH2Bu4EoSYrh6USjAo6u5KJABCNjsVee+012+OZUtsAkFoueKxJgIozaJK1+jK7lp7RMpCVtZxM6WsJ85rvv/++REY2gOQVfdBZmR4qk6gyDMVIpSgmT55st0GsE6aiUo/OHnvskbb1KcbgP5CIDsLeeOMNs/vuu5tOnTqVKI0PAMgcBWyjDZznzp0b9fjIH0h2/ae82c4KFKuc9oIFC+z7a/a1Br0q2eXoudoXeIPVeq5eo9ngekzv4Z9Y6ILQyorWwF4/W5OZ2rVrR6luAHlFJwI1VtSJx2TGjDvttJO91PclAMSjYzuNvw877LBAFfUAAOGynBVn0HetJnArwUaBX5fkFi1rWQlqyZS+plw2kB1FH3Tu16+fefbZZ20PKAWevf0AioFKQSjorNlFmgW03377RX2eyl073n4KqbR8+fLIToGSj8C25syZY3s9d+7c2WZrMEkDANJPg+J///vf5vHHHzdff/31No/rGEo9qTRI1jGSJgdVqlRpmyxnV6ZRM7k1qNb9ClZrWbZsma0q477X9V0fjQtWK/iiILMG6RqMH3LIISUmDup+VY1xlWP089999137M3W8pRnkCky7cmUAkOv0/eW+Q0vTCqF8+fIpXS8AhUnHTm+99ZY9xmrSpEm2VwcACibLedasWfa4TMdkap2iidQao2qST5kyZaJmLSt+kUzpa8plA9lR9EFnlczp3bu3efnll80pp5xiJk6caHvoFQv97v/617/s9ZEjR0YNOusL+sknn4zMED/ooIPSsi6PPvqoLScs3bp1S8vPAPKdDsj0PaUghQ6ivL3ZAQCpPdl42223mVtuuSXQ4FaBYk1kfP755+0JSvUPTVQu22Uzq+R22bJl7f2JSjnquExBZw3a1R5FwW5/f2g/Pb5hwwb7fP1eM2bMsNl+d9xxhzn00EPtAF8/1zvIR+HQZz58+HBbXl1ZBcp41wTPHj16mIsvvti0bt26VO+vvyX1wFTmgibyarKDThzpmEVjB03qPeqoo8yZZ56ZVI9M/c1rQscnn3wSuc+NGVA8NEbX35Um6CRDJzRF1R8AIOj+55133jEHHnigadGiBRsNAEpBYwWNQ3RMpnZQboysca3GCKrOpXZU0bKWdRyYTOlrymUD2VH0QWcZNWqUOfXUU83rr79uTxBef/31pm/fvpESXIWsY8eOtlessp1HjBhhTjvtNJtF6XXnnXdGMnvU/88/O1yZMy4Qrddre/pPdOrkQPv27WOuh7b9jTfeaK8rO2jAgAEp+x2BQqTgxnPPPWez1PS9RdYzAKSOAnM6NnS9oMIG+NR7dMqUKaZp06Yxy2Ura0/BZtF3uAbcOsZS6WwFoGPRY0uWLLGvV1AvWn/ooH2l9fvpePfzzz+3wfBGjRrZRUFo11cL+U0naRTw1UkeL01c0ITPJ554wtx///1m4MCBSf+MqVOnmpNOOinqYwoSqmKSlttvv9089dRT5vDDDw/1/g8++GCJgDOKk1oJqNRiMt/Lmjik72R91xZbZTMApaNJTtqHqa3JPvvsw7gbAEqR5awqXQo4a+yqCc/q36yxqgtAK07hHdN6s5YB5I+iDzoffPDBkQNJfanpJNx5551nF5XQ0SwbBUET0QB2woQJJh/dc889NntAJy7Vs+bqq6+2QWTdVsaOTkiJ+slefvnlod9fQWe9n4LZRx99tO0jqJ2KO+GljCAtLmNBWTfq5wAgPgUPPv74Y/t/pOoAxTBRBgDSTZmaCoopE7k01qxZYzOKlVEarVy2SmBrER1r6lhSx0c69oyXtfzdd9/ZTFKtn17j7Q8d7XVB+krrdXqOK/et91WgXMdjClJrveIFwpGbNNGhT58+kYDzsccea8466yxbnlgBuJtuuskG8c455xz7WasCVLKUca/jfZ2Q13X93ShDTNn1Os5/8cUXbQD8mGOOsUFqjQeC0N+6xib6m1QGhGvFg+KjzHz9LevEpCZMa+J0UPfdd5+t9qC/I70PAIQ1ffp0G3hW1jPHRACQXJazSmZr3KFJzorBKPisILQmRKtfs1oJpqutJ4DMKfqgs7J0vRmC7roCoOqVpyURPTefswyVgTxmzBib0aPyeDqx46eA8xtvvFGqUr4KjmmJRTuZYcOGmbPPPjvpnwEUI/UCfeGFF8zee+9tT+JSHhUAks9wTkXA2Rv002Bax1qape24YJwmDynYW61aNZsRXZqs5WivC9JXOtrrdGyr93WZ2Dq5qpK03kUlztjfpNeQIUPMDTfcYCeWacwSlrKYP/jgA3v9/PPPNw888EDkMWURKMisILGO/1VmW5WNov3dJaJgsytdHI0qSKmVkQLgynLQ76QgdBAXXnihPcl/xhln2L9VZZuhOPXr18+2PND3pyZK6G87SH9nTQzX/5Ibb/bv3z8DawugEGlinoImStagIgwAhM9y1thXbZ2++OILOwbR+Uy1+tFEWD2u56mio2tNBSA/0bjt/0+s+ZdY98d6br5TBvKXX35p/va3v9kAswbkyprcd999za233mrLLsbLuolHJ7NUSu+CCy6wPaNVtlHvrx2IdjTKNr/55pttgJ+AM5B8YEMzB1955ZWke90BQDFT0FcT8FIVcHYU7NUxjiroaOa2Fk3iU6BZwVwFTTTb2/V51kBc2cfRRMtajvc6//Oj9ZWO9/O8+xidEPjqq69s0E8TnR5//HGbwaqAjo4TFcTWiYNCOTYuBKoeJPobU2lrPx3bX3XVVZEM+pdeeimpnxMk46t3796RfpjKUg1CgWkFqzXJQcFGFLeWLVvavuD6jvn2229Np06dbIumWN85qgR0xRVX2PLyOtmpSeKq2pVMX3EAcDQhT2NuHfMAABJTaxSX5SyaOKjJpHPmzLGTedwkWT2u5yXTSgVAbin6TOdJkyZl+zPIqT5Zd911l13C6N69e9wTjDqpecopp9gFQHqpd6JO0mrCSNu2bfO6CgMAZJKCcuka4KoksAK8Cn4oCK1AbZUqVWy5V2UZKxicKPs4bNay9/mx+krrhGmi7OpYlG2o30mLXu8NQGriojKhvYuC7OyTMkcncZS57DKNNeEzmtNPPz0SeFbQ+fjjj0/bOrmKSa6sfDz627zooosi/5sECiH33nuvmTVrlvnoo4/s906vXr3sd0v58uUjG0iVJZQpo4wZceNUZSZef/31bEgApaYWKpoUdeihh9qqMwCA+GNhjUNVPluXakGlsbACzJoMrVZTe+yxhx1H6nHa6QD5r+iDzipXBwCFRAdp6tXo+qnrZBwAIDYFXm+55Za0bqK33nrLfierR22i7ONoPZqDZC17X6dAtHu+ROsrLe51er6ysFOxD1q5cqVdvFwwWkFy76JgKMHo1HMZA4nGO5qMoCpHClKrnF26KDNVZfRcxmoiV155pVmyZIntnanAOCD63hs/frw577zzzL///e/I97e+Q9z3iKp3+SdEn3baaeaRRx7huwZAymgClVrQqfeogiUAgOgOOOAAO2F5/fr1dkygqqcKOKv9lI7ZdHvnnXe2VZF0n54PIL+lLegcpMxaaWlgqSwOAEDsXs8qa6+BMCf1ASA6BS80CE4nBYCVnadj17DZx8lkLWsgr8G9BvCJ6Hl6fjrFCkZXrFjRZrF6+0WTFV16s2fPjlxPFOTV4wo6a2KC/g+8/cdLQ5n8mmTx2muv2fLYbtx26aWXxn3dxx9/bB5++GGbvfrQQw+lZF1QODRRRf3KBw4caCt0vfPOO1G/vzUhR22cBg8ebCcvAECq6fhJLSPU3kol/8uUoYMhAPip6pWq06jdyd13321q165tvzfVflNjV01E1vjjr3/9K72cgQKRtqCzZqoowEFfNwDIHgUnlO2kzDdlOqXqRDIAFJKRI0dm5OeoH7LaH4TNPk4ma1nZzjoO1+A+SPagN6s605lCCkxq8QaidTJCAXMF2DX7PUzpbxizaNGiyGZo0KBB3E3SsGFDe6m/F73O9V5OxqhRo8yAAQPiZjCffPLJcY9bzjrrLLsu6sfbqlWrpNcFha1r16520YQWZTcrM14Tb3Ssq++Mvfbay36XAEC6qey/Sm4fcsghdsILAGBbn376aaS3s8Z5mmCq4zZVQ6pXr559XNUjAOS/tJ69CRJwdpl3qX4uAOB/dBL5ueeeM507d7ZlNMl6BoD/UoacK/ubbuoxqqBa2OzjZLKWNYBX0CUfKRCtwLoLrquCkn73xo0bm6ZNm9oeYIhv3bp1keuJtpd3Qlq6Mt71t/joo4+aDh06xH3erbfear766ivTpEkTc+2116ZlXZC//ZxFx7DnnntupI+zvh/Ux1kLAGRzvP3KK6+Yww8/3E4ABAD8jyZCq5XPTz/9ZMd6GtPputovacyngLMmC2qs4NpIlYYmNH/22Wd2wrcC2gAKJOisE16J3H///XYGu754unTpYnstKSCi8go6+aGTgPriUYm1J5980mbradbgHXfcYS644IK0rLe+5EaPHm1/ln62yj3od/GX8dYsRpVIdNkDbdu2Tcv6AECq6LtWWXbff/+9LTNI1jOAYqTJiyr7q4w4laRWWcQgx62p+tn67nWZpUGzj/MlazldlMm4dOlSu3zyySf22FsnJJQNjeh0MsdJdOLGm5W1cePGUm3S3r1725M77r1UMu8///mPeemll8xJJ51kS+r95S9/ifrauXPnmptvvjkyTqxUqVKp1gWFRWXZFXDee++9zUUXXZTt1QGAbeg84csvv2wOPfRQghwAECPLWa2U1EpHVCGiatWqNgajIPHbb79tevbsWaptpzGzYjuahKse0pdccgllu4EMy1qduptuuslcf/319iTHU089FbXMmr6EWrdubRf1bHr22WfNGWecYS6++GJbPjCVs9+XL19uS8G9+eabkftcRnW0jECdMFTpN83K0Uz87777LmXrAgDppIM5ZT2r75RKaJL1DOSfr7/+2mbM4n8UOFagTQFlTVzUpX/R/QqEefshq5dtJukYsk2bNoGfr/VVj8CwJY9LGzzMZQpO6ti7Xbt2NgN6jz32MPkqyD5YE8biPU/l4U8//fQS93nLCuvES7wywyrd7pQ20KtsBS2OJgeceOKJtm+6Jhirn9uIESO2WV8555xz7P/wcccdZ4466qhSrQcKj7479T2+5557ZntVACDuPnXs2LHmgAMOMC1btmRLASh63ixntUTxjsWnTp1qqzJpUWxGrXqaN29uKzQmm7nsAtz6WRovUrYbKJKg8/Tp082QIUPsdZVZi9fXy0snLPTF1K9fP3PjjTeaI488MjKTvjTU/0mZ1grEBC3drXJeKuulwPkPP/xgsy4UwAGAfDnoe//99+1Je/XDowQYkF8UcFY2hU7AFzod++kEnoJR/kv/fcm+fyZpPZkwkBrLli0z1atXT9G7FRZlDDg66RIv6KzJGE66Spdr/Pb666/brOcLL7zQHHPMMaZGjRqRxx9//HEzadIku9733HNPWtYB+W2XXXaxmfNMlgSQDxMhNdZW5USdJ+R7C0AxU7DYZTlr3OFtA6TrOj+pMYgSDHVuUuMCTUJVdRu1UQmTuewNcKuymS51O1VluwHkcNBZJRR0EKbSf6eeemqo155yyinmhhtusANOBaxTEXT+61//ahYsWGCvt2rVymZQH3zwwfbnPPjgg3GD4Ao6y7hx4wg6A8g7mnTz/PPP2+9SZd4pmw5AflDAecWKFaZcuawVrikVtS7RoDDR4m9xkmoayGaSTjym+3cqBgqiFkKbiJkzZ8Z8TOOQhx56yO6jlc0ci8qNx7tPfSZr1aoV8/Wud7b+NqO9V6ooy1lBZ51seuutt0pMPFYvZ+nWrZsteR+rJ7qjCliiv4Gjjz46beuM3KH/A02WnD17drZXBQAC7+PVykXnF10fegAoNjpnoYneymCeMWNGiaCzKBhcv359e13xIj3++eef2+O+vfbay44BgmYue8t4a2yjy7p165LtDGRYVs5Sasaf/vGTzQzW6/TFo1JzpaV+K8pS1vqo/I3Ka++www72sUSzEfVlqS9FBW2mTJlS6nUBgGzQwZ++wzSZR72e452YBpBbFHDW8UiuUMUYZfK6ctYq8ey99F7PlcCr2rlkOlsvXtYp4lPpZh1/6+RFpicMpEO8UsEqHe4Cq2FLCmsirfPNN9/YEzax6HFRr/F0BvK9Pbh1AsjLVSpQNrSWRNQfWho3bkzQuUgoW16TDaZNm2YDz96/cQDIVdrfvfHGG+bwww8vdQsLAMhHircomKyJp0raU7UqL7VebdasWSQArSRFUfBZlZDeffdd+1qN/3S+MlbmsjfLWWMLtWv96quvyHYGiiXorDr8kmxZA/c6BXtLS7Pt3UnbJ554IhJwDqpt27b291F5BwDIZzqAe+mll2zG8z777MNsbAARGiQqWBwteOwPLuu5+aRmzZp2omHQFiuloZ9TCNm5maYya/qcdJJBJyVk5cqV2V6tnD+542iirio0RaOTMq6veayMgVSPAdNZxhuFS621evfubSeNq/rZxIkTKa8PIC8oS+/VV181RxxxBG2tABQdtUNSxSO57777bCKhlypBdOzYMepr58+fb88z6FKT1pU4qEzmf//73+aoo46yk3TdRGRvlrPu14RXXaYq2zlMX2mg2GUl6OzKysQrJxfPrFmzSrxPabgs586dO5tdd9019OtdBoKa3QNAvlPQRSVrdECnrGcOpIDCpoFbokCyFvVMzmfKLNGiyYXu0ntdQbm5c+emfT0UaNPxr75f87UseiboGF8nJ9TzV5dsq/B23313s8cee5ivv/7aTrK98847o06uHTVqVOR6nz59TDo999xzkeua4Oal445EunfvHql0lYlJIsg9+ntVey5lwyv7X62u+vbtaysgAEAuU29RBZ6V8ezOIwJAsfnjjz+2uU+BYp1z8I9VdK5CFRn1/anrqhi2dOlSm4Q4duxYm82sCckuwKzqtS7L2cV4VBVJwebS9nYO01caQJaCziqToLJYWqZOnRpzNks0er4WBYpd6YXScL3BdGImGa48oisJBwCFQL2ndEJPpQv3228/sp6BPKJgjAZziTKSdanBU75SD/p4gWR3XUuifvXKnrv99tvTvs7KctYx44IFC0zTpk3T/vPyiQLyLshctWrVhG1ukNgVV1xhzjzzTLNq1SozaNAgc//995d4XCdx/vWvf0XGZ7GCzjpp48phRwv2KhCoTOp4ZeOHDRtmTw5JkyZNTNeuXfkIEYp6orq/QU1E0UnH8847zy76m9LJxiCla/XdMmHCBLY+gIzT8bfG2Ao8u/6lAFDoFDRWZvLIkSPN9OnTt3lcgdzLLrvMtvrp0qWLbauqYzpNStXYWWMZjQ+1KECt26qEpcc1hlHbFbUM1HlMHR9qMqKqYmnivMbf0bKdw2YtuyzqIH2lAWQp6KwTGgo4a8Comclvv/12oH6EKr+g5zvHHntsqdfFnYRMthSkvuiE2dUACpEO3hQc6datGwNjIMtcHyQN2vR/qRm+a9assaXx/cFl9WrPVwomJAok61KzmlMVmOzZs6cNyGkbpjtIrsHwDz/8YBo1alTUGbwKUKqftoLMOo5mpnjqnXbaaebxxx+3s/ofeOABO8P/rLPOsttck3j/+c9/2r9H/W3ee++9Sf89DhkyxFx++eXmuOOOs2W9NTFYkwh0AkmZ/coK0DqIPudHH320IPpxI7PUz8/7ne+u65yCvlO1JKLnMqEFQDYpW++tt94yhx12mA2wAEAhf9/ddttt5pZbbrHnMRIdo+kch5bnn3/eHHTQQTZg7LKc1WpJNElZAWTdrwm0DRo0sFVsVd1JAWqNZzTOVPDZux46d/LFF1/YcyUKPo8ZM8aO/YNkLXt7RevnljZrGvlHf0PDhw+349pvvvnGTkDQZIUePXqYiy++2PYPL421a9faCdqazKCYqSZFqKqy/kZ1rkQJYSonrwnl7n8h7LlETZLQ/4qT7sphWTnTdcEFF9gTe/on1ZfJXnvtZT+gfv362Y3opy8OzYjRyRB3MlBfEHqf0tKMaH3xBSnpFo2boUMJWgCFSjvTN954w5bC1EFVMQdJgHRQgFiDFx1oatF1d9t7XUu+9Uv2UpA4USBZl9kYuClANmDAAPPggw+m7WdogKzg3urVq22wtZiynbXf0DbWiQPNUNfv73ozI30U2FX/Ww1QNYB94YUX7OKlz0HjMvXLLQ1NxH3sscfsEotOCikIrsE5kIxYJ0cotw4g3479x48fbw499FA7CREACo0Cc2qJomziZAJ8SlDUmFFxG+8EZY1dNJ502c4KoqmKrcbYOleigPPChQujvq+C1HrOddddZ8+xKDCtyrcjRoywVZj0flo0bvVWSvP2itbkxVT1iEZ+UJKHG097ff/993Yy9RNPPGHH0wMHDkz6Z2hC+EknnRT1MQWf1WJKi6rzPfXUU7ZiShg6z+UNOGdCViIH+tLQjBJ9YAr4KpCsmS9a9MWh2X468ajZJ4sWLbInWb2DSZ2w0uv1PqWlMgqaFa0Nr58T5j31B6EvLH3h8CUDoNApW0nfyZpxWKtWrWyvDpDzNCM2VgDZe10DmHylY6Bo/ZKjBZRzPbOxf//+ZtKkSXayY6rp2FXHmBqcatJloWY7u2xu/b7u89f1VGalIxztrz/66CMbDH766aft37fGX5owe8ghh9iZ/aWdmT1u3Dg7OU0z/lWZatmyZbaknf4WVM5OE4z/8pe/2IpV0fpKA0Ho+xkACjHwrJ6jAFAolKmpoJirDpssd65k7733LlHJTYFhPaZAswLAClKrvZjGnApOq/dzrPZaeq7G4To3oapMOsf5zjvvRNq3iF7rJkprPPPKK6/YMbzGUErG0XiKbOfioL87VWx2AWdVXVblMCUUqKT7TTfdZCc9nHPOObY6aGkmcjds2NCeb99nn33sdf0da5KE/kaV/f/iiy/aAPgxxxxjY5Iq8x6Esqavvvpqez5GWdJ6j0zYbmsWpwVrtouymzX7pcRKeU5K+VevRYsWNutZweJU0OwAnWTUz/z73/9uhg4dGnnsoosusqXo9Ji/TKW+zA488ED7B6bHdbKFWfu5TxkW+mfTF4H+aYGgOnfuvM2sIPWPu/LKK4tuI+oArGPHjvZgiyACio2OSzRZzgWNvUFk/6V6COUrDcKCBJI1kzhRv+R8oso3Klmkzy9Vypcvb48/vEFn/W3oBKOOa/Mx2zlWCXT9PWRqvzB37lw7613B07Zt22bkZwKFKBMTgvS9oJN8yH+Mp5EsxtPR6ThawRlKbQMoBIrxKDGvtAFn//ekviP9FdEUm9G4VGW1FbfR8aYyo3XOX+PuaDQx1iU56thUr9e5XVXeVX9oP02oVdtBBao13lUgUBNs9bP33HNPGxtSeyFlRytQrctCmlSe79QG6oYbbrAtI9WqJyxV6dL5ITn//PNtnND/96Egsc4B6u9HExKS+fy3bNmScEymCmYKgIsuFYQOQs/Va8844wybPKuM6YItr+3oQ5kxY4YZNWqULWWgmTCK4Pt/aX25KMisNHUFiFNZdvHEE0+0f4D68rjjjjvsiSuV+o5Hae0KlruAs34PAs4AioW+pxWAV8kazcIiawmF8netma7RSlr7g8v5fOJcAdBYgWTvbR1rFeOkkl133dWWRrrwwgtTEnjW9lZgWRMVNBtWdKnS2omyndWvW4NhDbA1mzuIZF4TjwY+ylT2Zi5r0e9VjH8fQCFyfY4pUQ0A2RmDKMtOmUvJ9GkEgFyhQKxKaqcy4Oy+J/We7du3j0x4dxmgmsyt682bN7flshX0VcazsqP9Y2ydx5kwYYINOuu6Ash6jesPrXMB3tfoObrf31daE5+VYa0J63ovF/x2dE5FAWgXhHbXNQldt3O9Ahz+R7FCdw5Hpa39FGi+6qqr7KIA9EsvvWSOP/740JswyN9E79697bkl9SGfPHlyoPdVYFoBZ1U/+7/27gRu6nn9//ilRfuuRfuiTZu0UylCIlEk2YoSQsdy4nAo+0HoED+SSrQ4ji1rSCVbRSoqlYg22hcJbf/H+/P7fec/9zRz3zNzzz6v5+Mxj9m+M/Nt7rvv/f18rs91XQ899JD16dPHEiXpSy80aaW0dF1UMmHJkiUuqKvb+o+oFSrKXtDteNBBQY3AtbJQB5AbbrjBZVIrGK3a7J7p06e7A5HKxukH5vWW1sSbAuYAkG1UNUAlPrSyTydnQCrSAMA/eBx47d1WwDmd+yUrwzScfsk670LuGjdu7M7t7rjjjnyV2lZZYQ1+Vb5I57Heokld635uvZ11TqqKQFq1rXJNOs7mtWI2mtcE/g4puKx98/ovZ+viAyDbhBNw9o4Fsd4WALKdxivvvfee9erVK25znwAQbwrKRdPDORyar1F5a7XtEVUP01hamcuKHSmoq1iS1+tZAeHAzGU9prGytvECwbm9JnD7UH2lA1+nmJEuGpMHO0fWOFuv93pI69/h3SYgnTpWrlzpmw/KrU3UgAEDXNBZog06h0u/NxJOVUXNc6qKs/d/M9EL25IedPank6sTTjgh4Z/bpUsXV2ZbvyQ6KCxcuNBd/AfMXvq6/+BZ+zt16lRXYhYAspH+0KkXVaNGjVzJNAJaSOTvXm59kr1rDUzSlVbxagDiPwjxbitgqX+bBkEqBcXgJLa0kGbChAk2adIkd+0tNgyHBqMnn3yy+/lpIKpgsH5mgX2oNMANle2sQLR6gm/YsMGVBwsWmA4UyWt0rPYG2t4KbI7fQHYKZ8GVKkDcfPPN7hij8fpll13mzvt07NLEmf4eqQLO559/7o6bn3zyiZuQU3bA0KFDE/LvAIB0puOoAs/KeI5ldUcASATNv9x///1x/Yxvv/3WVZ7VuFUZyxrDKtO4cuXKvmxUZSAHy1wOlbUc6jX+22thkMp1B+srHSpLOhTFlDQPoIuSG/0pBqV/kzKpddG+lStXzl0YqyeexjMelecORb8bDRo0cEFqJavGy4oVK2zRokXutubg86J2oJobUjKCYp6JllJB52TSKgRN2qq09qxZs3I8F6zcmALVTzzxhDVp0iTBewoAqdm3RSdMKret7D4gGvpbqwmXcILJCramKw0YAoPIgde6aCI/VL9kVYbRCaTKKRNwjg8NGtX3Rqtax44dazNmzHArqUNR8FZlvLp37+5WXmtVrBYHeJUhNHDV760CMd6A1Mt2Vmkwr2KEtlMgWr/n3uKK3Mpwh/Marcr1FjDoksjeywDS27333msjRoxwxy4t1O7fv/9h2+i4onGxLmqJNW3aNHf81Nhai29UOSLWFixYYJMnT3YTQgp463iqAHpgCwz9nfzss898/YjpAQ8gVel4qVLbZ5xxBudpANKKqsbGe8G/xtJq9adWUpFmIEeataxAtLe96FwzGO912r5evXr5ng9TRrcu/p+ncbvOtVUiWVndCrLrNvNA8aVe3p68grx6XkFn/dz0/6BEiRIx2QctqtBc0ptvvunKY3vjnL/97W+5vk4LgZ9++mk39/g///M/lgwEnf1okKyVMprIfeedd9wPSBO6muDWL4v+U7dr187OOussa9OmTVJ+YACQqnSsfOONN9xkXuvWrTkBgo9WhAbrlxx4rUs690tW+epQAWT/2wT80osGoloJ3alTJxd4Dsx6VkBX54i6aMCqIK9WLiv4ocGgN4DUYMELGmtbL+ir7bR9YMayF7DOrQx3sNfoffX/TcEVfZ6yESMpsw0AHlX/GjlypLutxTfBAs7BqFWV/vYrG+Xuu+92ARSdG8aCWnENHDjQ3n33Xd9j3gLxYItpNI5XKy8tBqpTp47rtwYAqUoLETUn2aJFi2TvCgCETdXBEkGZpIrJRJKBLJFmLXvj+XCSagLH87Gm81xvHk37Jwo469+hMX+tWrXcv4FF5bH/e+zR95wbLYTwflZ6XcOGDaP+3IkTJ7qxTm4ZzLmNyfQ7rrGP9kWVqpRkmwwpMQOVaquU9b6sgAaAyOmP2uLFi90qP5Uf8crcIDPpZMY/iBwqqKwAWLr2dfRKHOUVTNY1pfAykzKWFWhWwCLYQE4DVmWk+2ctKzis33kFgkX9nPScVkLrWr9T3gBWvzdeMNk/Y1m3NZDU54bKdtbnKiiuDGztmxY+aGX2Dz/84F6v6/bt2yfsuwKQWbRCXuNyHVcuvvjiiF570UUX2V133eUmxxSwjkXQWQvCVd5bcwbhnldohf9VV13lsrV1HFWGDMdFAKlMc6RHH300FcQApAVldnplf+NNY20lDUaSgSyRZi3r3Nd/PJ8bjecD+0fHm+YgtKhdl3nz5rn9VqxMwU/NITA3lX+ax/Ro/iY3/pnN8VqAcNxxx7kxVV6JsA8++KAtXbrULbaNR7WptAg6J2qVsjeRp95TGmwGZoaIJgBVLx8AkH9aJDR9+nR3Mqg/iPQfSR/6OxxOv2RdIulzm2q0MjSvjGTdVuYqZYuym45nGtRpAKeSSSpx5E/HNw3s/Fc5a3V0s2bN3GMK/s6ZM8edx+q1utYgUBksgRnI/hnLGth4Fy+grXPnli1busf0u6ksa2XD6FoBZmVWq+eT+j/pfFn3NeDQAAUAIvXxxx+7cXm0QVq9TmN2HQNj4bzzzvON37VqXxMpJ598sgtuP/XUU7lmXnvzAKpYQdAZQCrT+eRHH31kvXv3JnAAIGWOS14rNK8EtHf7q6++cs8nar5K4/NIM5AjzVrWmD2dxtDeHJ3G/jp31zyA/r1eRTbNH5AJHRnNi3ryCuIrEcCT33nSc845x7dYV++lBbz/+c9/7LXXXrMLL7zQRo8e7aowB7Nq1Sq777773O0xY8a4pISsCzoncpWy6vHrP1awPnyaFNRzQ4cOtccffzyqfwsA4HA6tn/77bfuGNyxY0eXoYfkDxJy65PsXYezmjNV6WQvVDDZ/76CdKH6JQP+NNjU/x8NOnTu6a2Q9uj3SIshA7OWIy2XHZjlrJLeKsWuclk6jmrAoEGHzl29hTyqNqDqElu2bHGfoawYURBcPYj0uJ7XAiAW/wCIlLInvGNbNLzXaeyfX6+//ro7BmvsrvNKLVzX33LJaxKtfv36Vq1aNbcfygYBgFSn80GVke3atWuydwXIyEpWGkdlOy2s1vjSu2iBdKj7GguHit9oYXai53y8csZ5nYd6ZZGV6Rxu1rJek84JFqK5Bm+hpvfv0jyYt0DdPxipeYLGjRtbugonmK4FsLltp/LwAwYMyPGY5mI8+t3xvx9Iv1+e/AZ6y5YtmyMxVolcWkCrvulKqO3Vq5c999xzh+2vDBkyxP1f7dOnj/Xo0cOSKWlBZ1YpA0B20CrB9957z+rVq+cWGyVzpVWmDhQCA8ehyl0navVpPGilqX8wObd+yUAs6ferS5cu7vbUqVMPe15B52BZy5GWy9agUP+fNbhXcEQBaW9gpMd+/fVXq1ixYo7MZd32Sn9r8Oj9/us4S7YzgPzyFqt88803Ub1eiw/93yc/tMJfdMx8/vnnfQHncKl9loLoK1asyPe+AEAiKGNJJVvDCa4ACJ8CzsqWDaxglQk05lQALPCioFngY7EKvPv3R04EZfBG2ha1UaNGEW2faYsS9O9REoq3EFTn0cqA1vwClX+DU2U5/3nt3OYa9d2GW4o7Wpdccom99dZbbkx07bXX2tlnn+3mfDzjx4+3WbNmuf3+97//bcmWlKBzolcp65dCB1NNugMAkkMlQdR/pUOHDu5YTmmX3GlQkFs2svecTm7SuV+yTojyKnGtC1maSAXBVjxrMUdg1nK45bK913mlt7VqWwGVqlWr5hi8qzyWMqz9M5fFP8tZ22iSIbfX8P8IQCQU7Pjyyy/dZf78+da2bduwX6vtddHfei08zC9v/kDnkar4ECmvpKLaFABAuvjkk0/s/PPPD7q4EUD0NPbSOCnV/29prkdjPAUNNebL6zoZiQaJbkem80H/cS8ipzlFBVIVj0v3oHNui2PVfud//ud/XLlqZTOH4mXEh3pMc9maXwnF6xOu381g7xUrynJW0FnzwEru6t+/f45eznLSSSfZ3Llzg75+06ZNvtvTpk1z15qL6tmzp8VaUo6siV6lrAGmfvhff/11VPsLAIgNLQCaPXu2W7XduXPnHCvHsoEGDApa5dYn2bvt3z8k3ejve7j9kilxjXShgXyw1fAKDgdmLQfLcvZWoepawWY9vnHjRjvzzDPdYkoNUJSxnFuJMq9Ps0rCiZflHO5rIl0RDiC7nXvuuS7grPOXvn372gcffOAWDuZFfZy1vUd9SfPLmyRp0KBBVK/3shP8y98BQKrz+qW2a9cu2bsCZByN3cI5r4k1BYZ1PuJfylrzP6Hup3rFOs3tJJJaSlHhLn+LBFRmW79XmZAM1LRp0zwXnSqwmtt2wRx77LG+2999912uPb71vKgyiT4rXpSZ7vnpp59yPOeNcZQNrUte1B9a1M4tY4LOiV6lrJMzTe6pBKFqm6vmuQ5Q/hPdOpHzr3UfDfqVAkB4tHDov//9ryu3rcnDdD/R0cmaVgnmFUzWJZ3L9OjEPlgQOfBai8nS/WcKBNJ5ZLDSYXpMq8oDs50Ds5y93qa6VuBZxwL9f9GqWR0b9D7hlE/UdioH592O9DUAEK6hQ4famDFj3OIVHdM02XL99de78m7+EzEeLW5Rv7HHH3/cVxlCbQX0Pvnljd2jnXhV5QdJ92wOANlnyZIlrvJEhQoVkr0rAHIZbwUGjkMFlBUcStdqdaHiNJr/SdS/yYsLITxqvaVAqJI+NC+heTudVysZCKGpOrN/T2j1VQ5G4yQvAeDEE0+M+1x6vMt4p3XQOdGrlAcNGmQvv/yyuz1u3Dh38aeD4qRJk9wlWpR2AIDIKOCiP9xandWpU6eU7PWs7MRgQeTAay1cSvXVp7nxTjwDS1oHBpdV+hfI1uOVSlQHK+Ol88jAHs2BWc76/6NjhBZk6P+bVhZrYLJ161b3vmeddZZ7PpwKBzoP9lbZRvMaAAiX/v6/9NJL1qNHD1fGTROlDz30kLto4kqLXnRcUxUIbwGNd1wUTXDp9bHIgNHKfu3DmjVronr9woUL3bXaFwBAOtExVWW21b+Rhb1AYseA4WQi66LFxplEC6U1R6dxpK79L4GPqYWT5va8bM940vmngnzBWltlM/0MAn9O3oXqgtFR3LJx48ZuUa2qNj/yyCNBqzVPnDgxR5WoeHr5/+Kb0qxZsxzPhTNG6tKli/u/KvFeJJKUoHOiVymfeuqpdsstt/hqmweTSSuMACCd6A+jFiN169bNZcMkggYIufVJ9m5rcjNd6W+tFzzOq19yqvcxAlIhy1mTCV7peA20dR6riQiVpwrs0azgi5flrOd17qqBYOBEoVf6WitWNQCIVDSvAYBIV/nPmjXLZTdrMtEbN+tcadmyZSHH0w0bNnRZz+qhFgt6Hy3mUdU0fXYkgWz1ll69erU7Bsc7AwEA4uHXX391LQYbNWrEFwzks92Zxmha/Ksxmn9gOTCgnGl9g71gcTiB5Ej7NKs8byKCzqr4EKy1VTbQvzfUzy3bvotEufnmm+2KK65wx4rhw4e7ClD+NL544IEH3G1VJAkVdK5du7avHHawGKQC18qkzq1s/GOPPWbvvPOOu12nTh2XvJXKkvIbmYxVyvoF0AFQA1+9Xn9g9IdFP3ANPpV14vXaA4BAwUqq6kRUQQWvZCqipwwZ9ZxQ2wWVa4xmBbf+cOt9wumXnM79/BS4yi2I7N1WdhErGoHYZTlv2bLFZfVpxasCzpr8098G/T9T0Ng/21nl9lUZQBOD/n8jNHmhAYvOOb3qDpS+BpDqWrVq5Y6DmhB57rnnXJ9nHQcDJ010PFRwWJXGLr300pieI2ssr9X9Oo7ef//99q9//SvsY/iwYcN8988555yY7RMAJNK8efPcxDW9TIHDW52p+pwuGpMF3vautV0mBZJ13hUYLA4VUNYlnvNDZ555pgvIee1V4kHzhAquBmttlSkU7A/2M/QyypFYl112mY0fP94+/fRTe/LJJ13SwODBg13lOi1qveeee9zxRf+31F4o2uD/yJEj7aabbrI+ffq4Bb/16tVzsUodt7755hubPHmy2wfR+Grs2LERLwzJiqBzslYpq3eoLv68A65+ifTLAQAeBSe1UGXChAm+xS7+Nm7c6PraKQihY0v79u1TskR0Og0W9Ed08+bNbsWW9wdUj+sPbW5BZK9fcjoPIPS7E04wWSeglFUDEkfllDR41gBDlGWigLOON7qo8o7+T3rZzjqGqfyheiT5l77Wtp999pkbJCgIovNhDUoofQ0gHWiiS5MsumjSVj1GdbzTbU2KaGF58+bN49ZfTKv/NSGjeYRRo0a5Beg6D8+N9k8Z2grU6Dit4Lkq6wBAOtLCaR3PTjrppGTvChBXGit5QeLcgsjeNplUvdTLZg0nmKxxZarMDen8b+DAgfbUU0/F7TM09xqstVW60c/NWwjgXbyfcbDqaEgezUu//vrrrtXQggUL7JVXXnEXf0o20IKLM844I1+ftW3bNnv22WfdJZTq1au7IHg6jGeS8j+TVcoAUpkCA+pVpyyKvMor64RHK+x0ee2116x79+52+umnp/yKo1Sg704ZfoGXzz//3A2mddsbTKTrIMKrpOEfOA4WTNY1GfNAatqxY4c7HmmQK8p4VjBZgwJVFNDFW0CpAUelSpWsWrVq7uJv0aJFbmCsXs56Lw0Y6LMMIB3p3CZwMXe8aVJx3Lhx7jxb5+o33HCDWxyqYPQPP/zg22769OluYagWMr766qu+jBv1YFOWNgCkMy1+rF+/Pv3pkXY0fvKCyP5B42DZyfHMlk2H/sjpSlVu1JJFi7ZjTd+NWreoNV9ga6tU/HlrXsALKHu3vWsqEqYXtUNT8oCCwVOmTHG/34oVaAHsKaec4ioqNWnSJF+fMWPGDHv77bfd+OX77793SQ5qAaDfe80vad7orLPOsr59+wbtK52KkhJ0TvQqZR2ERAekwD7Q3gpBnbQBgHqQXHzxxfbVV19FtfL4jTfesK+//tr1fEhUf+JUo8xkXRSk0aSgdzvwosdzo9emasBZiwoCg8jBgsqlSpViAQKQ5nSCr+OVJkq8bGWd6GugoQGlAiG1atVy/9/Vx+f444/PtUS3Jlt0rfsanKTzxAIAJJL62L/44os2YMAANyGtSkReNSIvK8S/l5p3Dqkg+dSpU61Zs2b8wACkvY8//tiV4OQcEqnQHzmcILKuVRI5k/gHi/PKSs6WpBSNi1VuWPOhqkgYKwrSqpqOrtWmSnGevLKdtXB83bp1brG35ubCFc7rvBLYwS4KLGfLzzsdKP6oS37pd+zqq692l2isyaPFsBZU6HLjjTdaPM2ePdsyOuic6FXK6nmiQejQoUMPK6GtAauea9y4sWU79bfW96OVFWvXrnUHStWQ1yoKfXexWknx7rvvutrzKkugxQQqxdamTRu78sor812KAMgP9afTcUnZa/mhEyBlSmu1kwIRmSJU8DjwEqsgsf5WKIijk8lE0XFPQePcspJ10fGQ1YlAdtD/fQU6/LOVdVzSgFfnpjqP0SKj888/P+Tk39KlS30lunXeqWutmNXjZDsDQPh0rD322GPdonVl0/jT8TXwPFTH7yeeeCLfGQgAkCp0Hqq5iw4dOiR7V5Ch/ZHDCSLrovmfbOuPrIvmjZgPCh2DUanha6+9NiaBZ33Pik14SYRa9K3FhLllOyvWpEQiJQYpM7pz585hleH2f50WiWt+WJ8RuMCAEthA3gpl+ypl9RvwAtIKfGarN99802V3+gd3fv/9d3ciq4sWCSgYrQye/Jy8KLAcuGBg/fr17qIa+YMGDbJnnnmGP95ISoZzLALOHmXA/fvf/7bhw4enfMZzOIHkZA0mvMCzBjT5oSBxXiWuvX7JABCMf7ayVuprUdG3337rzp006A33dRoUa5El2c4A0o0WDU+ePNk++eQTt0hZxz6N8TRJF5gloqoQolYCyk6JJQWQZ86c6fpKv/POO641y4YNG9zkploeVK5c2dq1a+fK0GXzGB9A5tI5qM4pdbwDwumPnFcQWdeax0rFSnPRUoBS80m6aN7Hu9a/VVWs9N2o8mmq9UdOd0rs09z/HXfcka9S2zqn00Lvo48+2v1u6vdUP0PN3XmLI4JlOysQrXG3zg3V8iq3MtxeQFlzhnovBbeVlar31O9Eo0aNot5/IJsVyqZVypn0hzOWVAr4ggsucMF/BfX/8Y9/WNeuXd39adOmuZr16j945plnugC0DvDRuP32230B55YtW7pgnFYrrV692mWFaj8U3FbGkHrpAomiE00tuohVwNmjk6Lx48fbLbfckvDyKqH6JfuXtvZKX6c6rSLUyWZgf239nfBOOEMFkb2sZUqPAcgv/2xlDX41INV5k4IcWoEdKms58HXlypVz12Q7A0gXqk6lxdqqWBU4tg42QavztsGDB7vjXJ06dVxvsnhQMDvWAW0ASAc6BmselTLb2UkB02AB5MAgsq4zrT+yAoSBQWQvsBx4P1RSgRatKSCpRXKBbTgRu4znCRMm2KRJk9x1JL+Hmr/TAm+NsTV/qXLX+llp/lKP6Wem808v21nP6/NE85wKHnsLC3Styq6KP2lbL8DsZS57GeuaF547d64LZisJT/10aYcFpGnQOVGrlDUhqGCFBss4nEoA6+CvVUHvv/9+jhI9J598slv1pQCxAs+PPPJIVLXw9Vr175bWrVu7HjQ6uIt+rmeffbbrr62g9sMPP2yXX355vrKqgUjody6aHs7h0MnNjBkzrEePHjF5v9z6I0fSLzmV6eRRJ346JulaAXsFkLVIRccj/37JlDQCkAiB2cpabS0KHuv8MtSgNNTrVAFj2bJlZDsDSHkam59wwgkuszncRdw6Dl511VU2YsQIN/H3xRdfWPv27fN8nZeFctlll7nX+lOWimjCkAliAPjfMttqR+i1gUH60t9XBboCg8b+pa79g8uZ1B9Z8z+atw8WNA4MKOtCQkH60Jye5vd79+7tej2rVVVuJbcVB9JixRYtWtivv/7qC1Trd1/jav1/0Da66HfDvyS8R+W09bkKOGs7zY8quU2/N+qZGwrtsIAMCzonYpWymr+rnIPKgOkPs8oj4H/Nnz/freSRK664ImhPmJtuusmtStJ3qHLByliO9I/86NGjfWXXlK3uBZw9WmWkx/X52u6xxx6zJ598kh8T4k4nPPHOrH/vvfdc9YDA3/tk9ktO1mBCAeS8LqECycpE10KkSpUqJXzfAWS3wGxlrZrXOaWudVwKlbUc7HWivwdkOwNIB+edd54v4KssEZVK1MLku+66y5566qmQr+vXr58vcKwFmOEEnVXOUOeLWsgTSBksXlusxx9/PF//JgDIFErw0JynFmgjtfsj5xZEzrT+yJrXyS2IrGsFmr1rkgkym84jlUCiXslakB2Y9awgsY5jitdUrVrV/U6ob7bG2/p/pHiE7uv1utb2yoTWmFoLEZXcpkXder0qtop+p5TMprZWeWUt0w4LyJCgsybZRAeGFStWxH2Vklb96QC1ceNGdyC68MILXaaJ/x819XNVyYf8uPTSSy3dqI+yRyXTgtH3pH+bym6rnIVK+Jx22mlhf4aCZG+88Ya7rV4IoSYc9LhWHel3QtuPGTOGfhqIuxdeeOGwss2xphMjLe5Qlkgq9UuOFS8bOa9Lfvvj6GRTVRK0SpJBCYBECRyEKrisBXK6KIisygsq7RXYoznU6zy6r8U09HYGkMpjRWUp6xyuY8eOrry2FgtLXud1mlxUHz1lSs+bNy9BewwA2UdzDVqYHW0rPETXHzm3IHIm90fOK4jslTCmPzI8iiVo3lOBZS2UCQw6a+ysYLN4rQCbNWvm7itorExlVQJQmyqNv7UIsnPnztaqVasc76NM6mjaWtEOC8iQoLP++OoPr4LBiSiLcd1117m+qprw04Hkn//8Z47ntS8q8a1LtPTHNB2Dzsr+FpWcCDxY+1Ppa4/K90QSdFZJNU02BL5PqM9R0Hn9+vVupbvKagDxpCz+RND/Gy26SCfhZiUncjChAI1K0jZt2jRhnwkgu2nhojd4FQ2Uxas+oZXW4g1mtb2q94R6XaDA1wFAqvjPf/7jrnWce/75530B53DpmKZxncZ34dBEohZr5lZ6EQCQk+Y6P/roI+vZsyeLs/PRHzlUb+RM74+cWzlrL4isgHKo/shAXhToVTBZ/9dWr17tW7zhLWbQ+aXXw1n3vXYrCj4rgVC0jSo6KAitBR3ffvutO8/04krRtrWiHRaQQUFnrVBRjf1ElUhVoOell15ymbzKRAkmk1afRUITnKKSE96kaTD+wTLvNeHSwT3Y+4TzOQSdEU86UdFKuERQPxKdzCS7/0w4Ja69zOVUtXDhQreykWxnAIleme3RhJN6OStY7B+E0XbaPtTrQvF/HQCkCi/LWS2QVN46Ut54X8fLcLdX7+ivv/464s8CgGym+Qa1zwunlUG29EcOFjQOdj8b+iMHCyxru2TPTyE76HfO6z2vIPBnn33mzvX0/1BzjzrHrFChgi/Y7J0TKoajKrnr1q1zz+eWuRxtWyvaYQEZFHSuWbOmCzprlUminH322a6HwFtvveUCFjpwKQCkFdv6o6yyzu3atbNsohVG3s+gevXquW6rA7uyoRWk00RAJPTHwZPX5/hPzObnc0LxyhjrJDTeJZWRHhNpWm2XCPqd0++oygwmosS1dz/Y47nR9+GVs0lVyoDR6kZv5SKQjTSRor/jumTaivtUo3NEfcc69oiOj/r7oWOqvv8WLVr4Fu6px5S3feDrcuP/OoTH+/3X/wXO6ZJH4wNkLo3ZpUGDBlG93pvwC+c4KBqPa8yuCcAhQ4bYgAEDDmuLpQCB12M6P/MRAJBplixZ4o6ZyhjMNJrLUynrwKBxqBLXiZrnSZX+yN5j9EdGKvOyilXBULEYHat++ukn9/9WVVJ1fqZgs4LPGl9PmTIlrMxliaatFe2wgAwLOvfq1csWLFjgenPqxCFRGXWaFLngggvcxaOgs3Tr1s0ef/xxyyZeKQvRiUlevKCzTuji9Tn+E1eRfk44mUQelfsO598MxJJOmAAAmSU/7VmAdJet1aKyhRfsjXbyXhN8oiyVcAwaNMhefvlld3vcuHHuEvj7NmnSJHeJliY5U3lxJQDkx+zZs61Pnz5pMd8V2B85tyAy/ZET19IMiJfArGLFAHSs8jKadd7pBZED+zPnlrms10XT1op2WECGBZ0vv/xyGzVqlG3dutUeeugh+8c//pGM3ch6yg7xqGdCOFk4EmkWTiSf431GNJ8DAAAAAIhdWyxN9K9Zsyaq16vCmFStWjWs7U899VS75ZZb7MEHHwy5DQsdgPTkVZ0LnCtSVlo481EIjypLaEFkMvo76/iszw8niJzp/ZFD9Un2bvvPfQLZIFjvZB0PFEBWVUhlHut884QTTog4c1lJaNG0taIdFpBhQWeVQpgwYYL17dvX7rjjDrfaePjw4UnpzzlixAh33bZtW8s23iohCaeHiVcWTSdS8foc/9JrkX5OOOW427Rp41Y2aeIj1MonZI+pU6fa4MGDE/Z5/fv3d8caehHn3/HHH5+jDwuQbb777js3cEPiyxaqtLZWVGuiVOc4Wo2t/nlaLY3E0wRFo0aN+OqBOGjdurUrd6jjniYGNVkeLvUWXb16tRvrn3jiiWG/7oEHHnDBkhdeeCFHWyyVX/R6VWqCEkDq27lzp/u/rPk/bxGKv40bN9r111/vAgUKNOh8KtJ5IATv7/zVV1+5+a9Y90fOrTeybmfS+MS/P3JeQWRdvHY7APLOclbwV7c1nlYbws2bN1vlypVzzVxWTEHHI2VIawzoZS7r74bG5P5Jb6Ho87y5RF2rmk+krwOQt6T8RVRZbfUIHjlypAv63n777fbkk0/aeeedZ61atXIrqsM90ezcuXNMgs7ZSCdFkZSy9vrlRVqmJ5LP8e/JF+nn5NUvWrxS7jp5pAcdjj322IR+CfodZRAdG+otyP9hZDOdLyGxNMjVOawmlHQs189A/aR0X6uktRiGTB0AmUTBX5W71sTf/fffb//617/Cep2CDsOGDfPdP+eccyL6XAWfvEwXj7do87LLLsu6tlhAulFGmqoa6rjhP8cTKqipPu26vPbaa9a9e3c7/fTTE9aGL1OpNK2SLRTMya0/cmDQOFhAOdP7I4fqk6z5BhIGgNhnOSvovGLFCrcwSePnpk2b2vfff59r5rKOQwo+e1UC6tSp4/5/aju9f5cuXSLeL/0/j+Z1AFI06Kz/0Ar6+Z9krl+/PuLBI/2Y8kerdCpUqODKnKuURW60wtwbLETSOzkwGJzX5/hnK0f6OUCktEpNJymJGETpeMXvdGzUqlXLLU4CgERasGCBm6BTtl2lSpXcRQNj3VcVHz0fSTYfAKS6fv36uYXiynZWeywFMJSVmBtlqlxyySU2b948d/6rBTrdunVL2D4DSH41nosvvthl2kZKle/eeOMN+/rrr+2KK65w51cIj+ZVNa+hAIx30aIhfYfKDMzk/sgKQnlB47yykrVw1H8+GkD8BfZO1qIY73ikxR26r8Sz3DKXNeZWDEPb6FqBa80NkoEMpKak1f4IdoKTSSc96ZTpOXfuXLeiSKtRQ5WD0cDB07hx44g/I9j7xPpzgEgVL17cBZ6DlfqKNQWcyYDLP32H2dgOAUByaUX2p59+6ga5mhCtXbu2e1wDXQWb9bieVxlDjvUAMoXGhuPGjXNZhxor3nDDDa5UroLRP/zwg2+76dOnuzK5Og6++uqrvj6dOtd+7rnnwv48ZTqKAgNly5bN8dxJJ53kruvXrx+jfx2AWPvyyy/d8UK9NvNDxwJlSqtigs61spXmSP2DyP5B5cAAc6j51A0bNoRV2TDV6O9HbkFk/8fojwykNv/eyV7GsgLLCior6Kz/w7llLuv+lClT3LmhgtW6VrD5lFNOcWW2AaSepASdVRI7kSvLLr/8ct9tfa7/wNf/ufwIfN900bFjRxd01kpHrURt165d0O3mzJnjux1pFo/+cGhVvE52/d8nGJWtFJUA8iZ0gXgaOHBgQoLOgSUCEd3Ep8qtqT0DACQzy1kTYaJBsu6T7QwgU2nS78UXX7QBAwa4YLLOm71zZ29Mf+655/q29wIfyliZOnWqNWvWLOzP0vhP7zl06NDDqqDp8/UcC5P/N9tH38/bb7/tKoVpsrZevXrWt29f9915f6OARFICQSwCzh7NUf373/+24cOHZ1TGsxcsDgwaB7sfi8QcLYbURQsoU7k/sv9j9EcGMot/72QvY1nnlPq/rpL3eWUu+/eD1rHEy4jW4/RZBlJTUoLOs2fPTujnTZw4MUeQ2z84HPhcfqRj0Fn9tR544AF3e8KECUGDzvrDMGnSJHdbq4m6du0a0Wfo++3Vq5f9z//8jxuIfPHFF9a+ffvDttPjXqaztqfkDRJB5f9uvfXWPHtN5YcmgoL9ziN8OhE99dRTM2rCAUB6ZjlrIZ1WW3t0f9OmTWQ7A8hY559/vqtepdLas2bNyvGcxmyBgREFqp944glXGjGWC0W9gLSqSmSrN99805UuVqaPR6VzlWGqizLTFYw+5phjkrqfyC46L9LvZawCzh6N0cePH2+33HJLSvd4ziuI7H87GbQQRT+jWFeX9Poj51bOmv7IALzeyYEZy2rHqTacuWUuB/aDrlu3rqu24/V/1rkm2c5A6klaee1E806uggUyY3Hila4BUpWp7dSpk8t2VtD8sssusw4dOuTY5pFHHnH9F0TljQIP5lpE4AWi9XoF8gP97W9/s7Fjx7qT7Ouuu85lNKuUhkcrlvS4l82o7YFEKFOmjN122212++23x+0zlJ3r//uOyGigqoCzVjICQKKpEoyX5SzqORWMl+2s7QPPpQAg3WlSb+bMmbZkyRJ755137PPPP3eVrHbu3OmqPlSuXNktYD7rrLPyHRSm7VZw6nN7wQUXuLGzMgb/8Y9/uHG47k+bNs2effZZV7LyzDPPdAFonUMDifDwww9H1cM5HDq/mjFjhvXo0cOS2R85VBBZt1OdStYq8BzOQvtQ/ZGDBZPpjwwgEv4Zy8psVoazFs7llrkc+BpVPtQ12c5AasuKoLMyeKN5LluoZJFKZusgftppp7kAnP/gVcFiadCggd10001RfYZe+/e//93+9a9/uQGwPk+rVVUGbPXq1fbggw+6QbRoO3p1IZFUskv95+IxUFZ5GJUZQ/Tfn1ZE0qcJQLJoFbUmFcM5N9F22h4AMlXz5s3dJR4USFVQZPPmzXF5/3SnBeAao2uR9vvvv59jgdPJJ5/s/k5pXKPAsxaOjxw5Mqn7i+yghSf3339/XD/jvffec3NU+VnIHYv+yOlKQWcdX9USRgGb3LKTGXcDiIfAjOWjjz7anc9o0fayZcuCZi4He43k9hoAqSErgs7Kvo3muWzRsmVLe+mll3xluhR0DhY0Vpmu/KyWvu+++1z5SZVHUoC5X79+h21zxRVX2L333hv1ZwDR0ImOetVpMUQsS4Ip60N941O5FFgq/0yUJdO0adO0rSQBIDN07NjRTUaGkx2i4762B4BMoEwSUdnDFStWxH1Cr0aNGq7C1ieffOImF9WHFP9r/vz5rjqZN2YOVlFDC8S1qF7foRaWq5ITk7CItxdeeCGurapE7U3Uji2w1Vtu2cfx6I+caoFkzTN4l1D3de2Np3WMPeOMM5K96wCyUGDGssppixYThcpcjuY1AFJDVgSdkbeePXu6UmkanCq4rJ4KGuSrF5R6eF177bWuHE9+6GRXJbz79OnjsqcXLFjgViXpD4SCS0OGDOEEGEnTqFEjlzGgbP9YBJ4VeFA2Aj2II6fv7KSTTnKlzwEg2ZQR0qtXr2TvBgAknBYkK1CjqjOJCF7qcxQw3bhxo7Vu3douvPBCl9WicaTnu+++s0mTJuXrcy699FJLN6+//nqO/tbB6HvSv01lt3fs2OH6b2tsA8RToqoHqkWbstmS3R85XhQY9g8ch7rt3Y/G2rVrXSWJihUrxnz/ASCUwIxlxQH279/ve173NQ/rn7kskb6GhXZA6jjiUJyW+/3888857tesWTPkc/nh/75AXqpXr27r16+3atWqucA6EEgTWcr6z0+pbZWEVoYzAefI6ARRC1B0skh2MwAAQHIp4KtKVYMHD7ann346IefhqsKlycVA3rRFfs8R9Xr/Sct00blzZ5fprIWtCiirKlAw6rV9wgknuNt33nmn3XXXXTHdD8bT8KcMZ5VmTkRfY/3fVSu2dAoqaJ/DDSJHG0iOVO3atVmMgqynpKsNGza4v6e0d0zM9/3ZZ5/Zt99+G/Qcz6PkN1U79M5jIn1NvNq/ZKpVq1a5akZVq1blu0PMFYrniYw3IAwc2Pk/l40DRgCpnfGs0l0PPfSQ600VSakw9T/q3r276+FMSe3IqNRXp06dXK8pAEh1WsCmxUnKxNMgDQAykRZ4K+icqF71Og9X2ydl8m7fvj3oNplWIjdcygAXVSILFXD2vsPA14QrnEXZXnapfg7xLqmM1KdxcyICzt7vnH5HlUCQTP5lqwODxoFB5XDmPROdta1WCQrM5Kd1HpDufv/9d/vjjz/cReWbEV+//vqr+669nsyi713neqoqpnLZHm2n7b3b/q8JxXsNP8vIeP8H9P+Bc7rkKFGihGWquGU6e31D9Pa69j+J8n8uPwLfF8gLK7MRaUlB9ahSH/KFCxeGPA4pYKpVde3bt89xsoS86fvSd1e3bl2ymwGkBa20Hj16tO3evdtl96iVAn1HAWQiLcD85z//6UoYquR1ohZVauLrrbfecuffmpBUWcbnn3/enSs2bNjQ2rVrlxblgGNFE4LeGOPMM890301utIhT36HGJsp8DheVhgAAAIDEOJTBi2njFnQOzGb+8ccfQz6XH/7vG8rdd99tiaDyVUhtBJ0RrbZt27o+5P604u62224j2BAllTHq0KGDFS1alF9MAGnj008/tRkzZrjeUS1atHDVLU488cRk7xYAxNwvv/xixx57rO3cudPuvfde1ys4WbyF60OHDrXHH3/csol6sFaqVMndvuCCC2zatGm5bl+5cmWXoa5yk998803Yn0PQGQAAAEiMQxkcdI5bee01a9ZE9Vw8jBw5MiEDKILOQOYKltmhYCnZbZFT9oVKaStDHADSLctZQWcFYhSE0bXuqx89fw8AZJoqVaq4rOC+ffvaHXfc4cbUw4cPT1jvUfz/TGdPOH9r1PJHIi0zuXbt2jy30d87/e1Ta4mVK1fyI8pyU6dOdT3fE6Vnz55uwZ9/KWv/vsmJ7o+crtTDs3fv3sneDSBpvvvuO1dFBYmnNqlaPKdzjp9//tm1ctHcYL9+/XJtH4L4KVy4cI72LEAsZM3/5khWDuRV+jvY86wKBoC8NW7c2JVEJDgDIB2p4sVvv/1mP/30kzv307WCMnqcbGcAmebjjz92vfa0iHvEiBF2++2325NPPmnnnXeetWrVyipWrBh2a5nOnTvna1/0+V71oWzjXxVIi5/y8ueff7rrSNv+qCpYuAtx9Tcwk/vQITyqhJDosSQLl/NPC1K0OIUAD7KVzmGQHFqwXb58eVu1apVbAKOFdbqv8wq1BQGQGbIi6OwNUHOjbJWnnnrKrXRSQLlatWouMKIVNxpMqSeSVuHMmzfP1q1b516jk7RrrrnG9fMDAISm46gmG5kkAJAJWc6a0G/SpIktXbqUbGcAGatLly45FldrnLx+/fqIy1vrPZTZEu8xfaYqVaqU77YWPuVFcxdedSEgno477jiXVXzw4MG4f9E6jjCWjN13GaySGwDEE+NpIHsQdDZzZaF69OjhDn7Nmze3UaNGWbdu3UJ+aTNnzrSbbrrJlixZYm+88Ya988471qBBg0T+3AAgbdSrV886duzoK/UHAOme5azemsrw0zXZzgAyWbAKYJncfyxVM50rVKhgW7du9S2AD2X79u2+oDMBOsRb8eLFXeB54cKFcf8s/T5TLSs29D1SrRFAojGeBrJHVgSd8yoro14mP/74o51yyin25ptv5ihfFYy2U8bzWWed5QLQev38+fPdCTcA4P8PZhVsPuaYY/hKAGTUquzatWu7x2vVquUGz/R2BpCJVKWGwETqlDGeO3euff/99y5rPFRZXPWp9C9FDMTbwIEDExJ0PuGEE+L+GdkirzlPAIg1xtNAdsn6oPPEiRNt2bJlLgPvxRdfDPvkS9u/8MILVqdOHVu+fLlNmDDBhg4dGvcfGACkg6OPPtq6du1KWT8AGbkq21toqNYBZDsDyFSzZ89O6OddfvnlvtsKdj/33HNBn8uPwPdNF1rIqaCzspi/+uor1wosmDlz5vhun3jiiQncQ2SrSy65xG699VZfhn08aP6NXp+xQ9AZQKIxngayS9KDzr///rsL3n744Ye2aNEi27Jli+3evTuskl2x6A01depUX7+qypUrR/TaKlWquKDKe++9Zy+99BJBZwBZTz29WrdubS1atCAzBkBGrsquWrWq7du3z/e87m/atIlsZwCIwYJw/8xq/+Bw4HP5kY5B53POOcceeOABd1sL3oMFndVXd9KkSe522bJl3VwFEG9lypSx2267zW6//fa4fUb37t2tWLFicXv/bONV7AGARGA8DWSfpAadX375Zbvqqqtsx44dSesNpfJUGrzWrFkzqtd7fZL0PgCQ7RMOJ598sutzCgCZQhllXpazaJFkMF5vZ23foUOHBO8lAGQGb04gWIA5FvMF6VouvG3bttapUyeX7ayg+WWXXXbY35pHHnnEVWGTYcOGWeHChZO0t8g2w4cPt1dffdWdA8WaWpmcfvrpMX/fbKVjIO2vACQS42kg+yQt6Dx58mS79NJLDxs8eoPAwAFlqMfza/v27e5669atUb3ee533PgCQjdQzTiXPmNwCkGlUhefAgQNWv379PLfVdtoeABA5ZfBG81y2+Pe//+1KZu/du9dOO+00l12qbGbdnzZtmo0dO9Zt16BBA7vpppuSvbvIIuoxrnZ1+v3ctm1bzN5XbUxUWr9gwYIxe89spwo9+l4BIFEYTwPZJylBZwVqleGsALICFPfee68NGDDA7r77bnvyySddgFmlobysko8//tgNoBYvXuz6g+p2v379YrIvKqn9888/26xZs1zJRPWKCZe21+tE/fwAIBv7QXXu3JkSXQAylvpo6rw0nF6FmsTT9gCAyCl7N5rnskXLli1dW6+LL77Ydu3a5YLOgRRwfvvtt61UqVJJ2Udkr0aNGtn777/vFkTEIvCscypl7KuKDGJHxwgASCTG00D2SUrQ+ZlnnnETdwou33///SFX4SrA3KRJE3dRkPqhhx6yf/zjH3bRRRe5gPSgQYPyvS9aiamgs0p833LLLTZ69OiwX3vrrbe6DGf9O/Q+AJBNqlWrZl26dGGlNICMVq5cOevVq1eOx9avX+/KhKmHvTJGACBdaSzsz7/tVOBz+RFtOyvk1LNnT1uyZInLelZwed26dXbkkUe6crnnn3++XXvttVa8eHG+NiRFq1at7NNPP3ULI/JTalsltZXhTMA5tipUqEBpbQAJx3gayD5JCTrPnDnTXZcuXdquv/76sF6jwK6CwgpWKzNaKx5VSqpevXr52hcFrqdOnepuP/HEEy6Y/fDDD7sDYigKUKtnjXopea688sp87QcApIsCBQpYmzZtrHnz5mnbFw8AovXXX3+5NjG7d++2FStWuHNSTfgDQDqqXbu273xO1/v37w/6XH4Evi/yRwG5Rx991F2AVMx4/uKLL1zSiJJMwqkU41Hlwe7du7sezpTUjr0TTjiB8TuApGM8DWS+Asn40OXLl7sTndz6f6onXjD//Oc/XUD4jz/+sPHjx+d7XxS4HjhwoK9XtHpF1ahRw/r27WuPPfaYvfLKK/buu++6a92/4IIL3PMKOOs1+neo1Jey/QAg06lU39lnn20tWrRgwAogKy1YsMAtUlSmmQLPug8A6U5jW29MHOq5/FwAZFePZ5V/37Bhg40ZM8aOP/74kNtqTk2VENRC78EHH7QePXoQcI4DJewcffTR8XhrAIgI42kg8yUl09nr71K9evUcj/sHoPfu3evKawdSJokCvK+99poLBt9333353h/1iNbnTZs2zZ3w/v777y7IrEsw/oNmlbB69tln870PAJDq6tSpYyeddBIZfQCyelW2ykb+8ssvtnPnTnet+6r+QLYzgHSkYE+obObcngOAvKi64dChQ92lbdu2hy3UUxBUwWnOoeK/CKBdu3Zx/hQAyBvjaSA7JCXorDI5+/btOyzLWSekHq2IbNCgQcg+JKL+RbHanylTptgZZ5zhMqnXrl2b52psZTvfc889dumll8ZkHwAgVWmyUYPUZs2aMfEIIKt5q7J/+ukndzzUtfoN6vETTzwx2bsHABFbs2ZNVM/Fw913352Qz7nzzjsT8jkA/r9g5bKLFi1KwDkBVGUyWFIPACQa42kgOyQl6HzUUUe5gPGuXbtyPO6f+fzNN9+EDDprgk9U0jCWLrnkErv44ottxowZNmvWLPv6669t8+bNbnJRJ2gVK1a0li1bupLcp512mutrCgCZrFixYtatWzdKcQHIev6rsv/8809r0qSJLV26lGxnAIiRkSNHJmSBI0FnANnUA75x48bJ3g0AYDwNZJGkBJ0bNWrksol/+OGHHI8fd9xxvtuvvvqq9enT57DXbty40T777DN3W0HgWNMgt3v37u4CANlMC4ROP/10K1GiRLJ3BQBSalV2pUqV3Hmorsl2BoDYiaT/s8buuW0f7HnKhQPIpgXknTt35rgHICUwngayR6FklXb54IMPXHbIgQMHfGV2WrVq5bKdlQX90ksvWY8ePeyiiy7yvU6ZzQMGDLA9e/a4k6aOHTsmY/cBICv6N3fp0uWwNggAkI0Cs5xr167tyx7R4JnezgCQfyNGjMhzm507d9pTTz3l2nUpoFytWjXXBkb9p7VQUnMFWuA+b948XzuuIkWK2DXXXJOjnRcAZDqN5xV4BoBkYzwNZJekBJ1PPfVU1w9Z2SLKWu7UqZN7XIHkv/3tb3bzzTe7AaT6JT/44IOuj+jvv/9uc+bMcYNMz7XXXpuM3QeAjKaqE23atGFFNACEWJVdvHhx97gCHGQ7A0Bigs4rV650C9M1cdm8eXMbNWqUawMTysyZM+2mm26yJUuW2BtvvGHvvPNOyBZeAJBJWrRoYTVq1Ej2bgCAw3gayC5JaUp84oknWtWqVV1g+fnnn8/x3LBhw1xQ2iuDpWzoadOm2fTp013A2Xv8tttusxNOOCEZuw8AGUkLf7QIqG3btgScASDEqmydwyrDzrvovh73sp21PQAgtvbu3Wu9e/e2H3/80U455RT74osvcg04i7ZTxrOu1dpLr9didgDIZFWqVHGLyAEgFTCeBrJPoWQFNtasWeNKaxcokDPurVLbb775po0cOdLGjBnjskr8qXyWsqRVZhsAEBsqo60JOZUmBAD8f1999ZUvy1kWLVoU9Ovxejtr+w4dOvAVAsgoCta+8MIL9uGHH7rj4JYtW1z7q3B6MGv8v3///nx9/sSJE23ZsmWuVPaLL75oRYsWDet12l77rdYxy5cvtwkTJtjQoUPztS8AkKpUTlsLcgLnWgEgWRhPA9mnUNI+uFAhdwnmyCOPtPvvv98FnufPn28bNmxwJ0x169a1li1bkoEHADGk8rDdu3e3ChUq8L0CQAAFVrRQsn79+nl+N9pO2wNAJnn55Zftqquush07drj74QSaY23q1Km+HqWVK1eO6LVaENS1a1d777337KWXXiLoDCAjaYGPFpJ7bWAAIBUwngayT8KCzgocP/XUU25ltEpb7dq1y8qUKeNWHGsV3tVXX+2ymAODzx07dkzULgJA1jnqqKPs9NNPd4FnAMDhdC568OBB27NnT55fj46lnLsCyCSTJ0+2Sy+99LBgs4IbgY/l9nh+ff/99+69o63K4/U21fsAQCZSmyy1fQGAVB9Pb9u2zbVMUYJhuXLlfI8zngYyQ0KCzuPGjbPrr7/e9bvzH4Bu3rzZrXZRM/lHH33UHnvsMRsyZEgidgkAst4xxxzjejirtDYAIDgNgnv16pXjsfXr17syYa1bt2ZyD0DG2rp1q8tw1vhd54v33nuva3N1991325NPPumCwJpE9FoQfPzxxzZ27FhbvHixlSxZ0t3u169fTPZl+/btvn2K9t/i/z4AkGlj++bNmyd7NwAgz/G0ejyPHj3aVWVQ+5bBgwe7xEMAmSPuTT7UP+nKK6+0P/74I+iKZ+++nr/mmmts0qRJ8d4lAMhqaldw4oknujKDBJwBIDIaJCvzT4smda37AJCJnnnmGZeVouCy2l/9/e9/t4oVKx62nQLMTZo0cdXLFi5caA888IALRF900UVuAXosqKS25g5mzZrlW8weLm2v10mlSpVisj8AkCp0XO7cuTOtCAGkBY2jdZ64ZMkS2717t7sPILPENeisEtrXXXedu62BqgaJLVq0cIPR2267zV1rJZ4e955XRrReBwCIvdKlS1vPnj3dxKBX/hAAED4GyQCyxcyZM33njxqnh0Pnl7fccov985//dOP7YcOG2erVq/O9L1owKeorrfePxK233uoynLVv3vsAQCYoVqyYnXbaaVaoUMK6JwJA1LRg+9NPP7VffvnFdu7c6a51n4XcQGaJa9BZWcsKIGtwp/7Nb731ln399deuFJdKc+l60aJF9uabb7rnRStcyHYGgNhr3Lix9enTx2WKAAAixyAZQDZZvny5G8u3b98+ZHWcAwcOBH1cQWeVU1RFs/Hjx+d7XwYNGuS7/cQTT7j7eZXKVoBaVdcef/xx32O6DwCZQIFmBZzVAxUA0mkBt9qy6BxT17pPtjOQWeIadP7www99tydMmGA9evQIut2ZZ56ZYyDq/zoAQP5oEHrGGWfQvxkA8olBMoBssm3bNnddvXr1HI/7B6D37t0b9LXqzdelSxeX7fzuu+/me1/UFmbgwIG+9lyaX6hRo4b17dvXHnvsMXvllVfc5+ha9y+44AL3/HPPPeerrHbZZZe5fQKAdKdj2sknn8yCcgBpuYBbrU+OPfZYd022M5B54lp/ZfHixe66fv36ORrGB3POOee47VatWuVq+gMA8j8QVRnt1q1bu4k/AEDsBsk6vi5dutQ3SG7Tpg3HWgAZpWDBgrZv377DspxVbtuzYcMGa9CgQdDXV6hQwV2vW7cuJvszduxYF+SeNm2aO8/9/fffXZBZl2C8ALWcf/759uyzz8ZkPwAg2Tp06GC1a9dO9m4AQFQLuCtVquT60eta96tUqeKepw0KkBnimum8detWNxjUJFw42rZt63sdACB6OnE799xz7YQTTiAIAgBxHiRTEgxAJjrqqKPctVpm+fPPfP7mm29Cvl7HR6+FVqyC4FOmTLHnn3/etw8KLIe6iLKdJ06c6ALVej0ApLvmzZtb06ZNk70bABD1Am5v0UytWrXIdgYyUFwznTUBp6Bz2bJlw9re206vAwBErlixYi6zuVGjRu74CwCI7yBZwWiynQFkIp1Prl271n744Yccjx933HG+26+++qr16dPnsNdu3LjRPvvsM3dbi3Ri6ZJLLrGLL77YZsyYYbNmzbKvv/7aNm/e7OYRSpYs6T6vZcuWriS3+p0WKBDXtfYAkDDHHHOMtWvXjm8cQFov4C5evLivHSDZzkDmiWvQ2ZMugQ+V6nrrrbds/vz5tmbNGreiW+XEwv03zpw509KVSpONGTPGXn75ZVu9erWbUNWqcPXbvv76692kan7o+6xTp05Y26rXllajAwifJtNU6vX444+3IkWK8NUBQAwxSAaQjdq3b28ffPCBayVw4MABX6Zwq1atXKaxyma/9NJL1qNHD7vooot8r1Nm84ABA2zPnj1unNyxY8eY75vet3v37u4CANlAix7Vlz5d5lgBINgC7qpVq+aIt+j+pk2bWMgNZJCEBJ3TwcMPP2z33ntvVFnWKt2Vzid933//vZsoUD9tfytWrHCXcePG2eTJk+2ss85K2j4CCE0LRNTTKdyqEgCA8DFIBpCtTj31VLvnnnvcGFlZy506dXKPa+z7t7/9zW6++WY3Fr700kvtwQcftGbNmrnFzHPmzLGdO3f63ufaa69N4r8CANKfFvqccsopVG4AkHa++uorX5azLFq0KOh2Xm9nba85TgDpi6CzmQ0aNMgmTJjg6/uUTbQKXdnMXsB58ODB1q9fP1eiV6XKHnjgAZfxfcEFF7hVSf6l1KKl4H6vXr1CPl+uXLl8fwaQDcqUKeN6NivoDABI3CBZK7R1DlWqVClfdQkGyQAyzYknnuiyTzZs2OD6KHtBZxk2bJgrb61MaAWhlQ2ti8cbW992223ufBUAEB0FYdQqgL70ANLRli1bXMWc+vXr57mtttP2ANJbQoLOKld99913h7WdJ5zt5c4778zXvr399ts2fvx4X6aygjcXXnih6wFVoUIFK1y4sGV6hvfKlSvd7Yceesj+/ve/+57TqiKV7jnppJPcinWtZp89e3a+P7NatWrWtGnTfL8PkK2OPPJIV0Zb5bQZeAJAYgfJur148WIrWrSoO39s3Lix71jMIBlAJtExTm2SdGwL7Ius496bb75pI0eOdG2aAiuGacynLGmV2QYAREc96tVGoFAhcoYApCe1WTl48KBru+LZtm2b/fjjj1a3bt0cyWfq8RyPtiwAEqtQovrg6RIOL/h71113JSTorNLRnv79+9tzzz2XNf1Q1T/h8ccfd7c1YXrTTTcdto1WpV9xxRX2zDPPuDJp+jm2adMmCXsLQI455hjXX6948eJ8IQCQhEGyWo9UrlzZfv75Z3ddqVIla9iwoXuOQTKATKNAR6hghxZC3n///S7wrAXkyohWcFoTiFrEnc4tqAAgFQLOaoWnYy0ApCsFlf0rnqp91ejRo928ppLcVHWV4xyQWRISdI5X2epYDGLnzZvnrjVhqAB0tgScReWzvV5bl112WcjeMFqdrqCzvPbaawSdgSSV0laJQ/VyAgAkZ5DsDZA1Cbh9+3Z3rUDzeeedx0AZQEZQ4Pipp56yDz/80H744QfXaknnoXXq1LFu3brZ1Vdf7bKY/WmikKwUAIido446ygWcs2mOEkB2UEKbKuQsWbLEWrRo4e5rvhNA5ohr0Llz584pv7pZ5Ry0j127dnVlErPJJ5984rutEtqhtG7d2rf6SH2dASSOjk/qpa5y2pTSBoDUGCCrf7OOz14fZwbKADKBFmFff/31rm+9/+LxzZs3u1YDOtY9+uij9thjj9mQIUOSvLcAkJnU6o+AM4BMpEXcii388ssvLhFO17qvqqpkOwOZI65B51j0/03E6sGNGzdaqVKlLNssW7bMd7tRo0Yht1M5NZX01Qqk5cuX5/tzn3jiCbv33ntt3bp1btWmMjc7depkV155pQusAfhfOi6dfPLJrnwrACB1BsgKyDRp0sSWLl3KQBlARnjhhRfceEy0qCawWpnu6/E//vjDrrnmGitWrJhdeumlSdpbAMjcCjsKOGdbUgyA7MAibiA7JKS8dipTL2MFndeuXWvZRkFfUVnIsmXL5rptjRo1XNBZq9w10ZqfEj8LFy703dZ7Kfiti0p4a8X8v//976je3/v35ObAgQMRvy+QDPXr13flZVjpBwCpN0BWWxaV1tY12c4A0p1KaF933XU5As4qd3jCCSe4AIjaCWjRjcaD3vPKiD7nnHOsdOnSyd59AMgIamVw1llnuUU9AJBpWMQNZI+sDzpfcsklNnPmTJs7d67t2LEjz+BrJtm9e7e7LlmyZJ7bKjDt0YRrNEFhfbfnnnuudenSxQXUtHJTAf/333/fnnvuOfe+CjxrvyZPnhzx+yswDqQ7TeQp2Hzssccme1cAACEGyLVr13aP16pVywWjKQsGIJ1NmjTJBZ51Hqqgx4svvugy7QK9/fbbbvyscbPGbHrdtddem5R9BoBMq3JGwBlAJmMRN5A9CliWu+iii6xDhw6uX/FNN91k2USl0SScTEr/IPPevXsj/qyqVava+vXrbfz48a4Mm77zli1busmM0aNHu+znmjVrum2nTJli06dPj/gzgHSn/4tnnHEGAWcASPEBcvHixX2L8rxsZz2v7QAg3Xz44Ye+2xMmTAgacJYzzzzTjeeCvQ4AEB0lgijg7J/sAQDZsohb971F3NoOQPrL+qBzwYIF7eWXX3Z9+SZOnOhWbm/atMlSiVac5/eif1sgr0dMOAd0/QHwRFPqR8E0b4I2GGU+a0W9f9/nSKlEel6XKlWqRPy+QCLo/0evXr1cj3MAQOoOkLWQbt++fb6L7jNQBpDOFi9e7BuT6Xw0Nyqpre1UYlvltgEA+ZsH0IIeZToDQKZiETeQXbK+vPbdd9/tvojTTz/dVq1a5bJs//vf/1rHjh2tWbNmrryYgrbhuPPOOy2deCe1yszJy549e3y3wynHHY1OnTq5DE/1d/7kk0/s4MGDVqBA+OsiwgnWaZEBkIoDTa1szqby/gCQLr766itflrMsWrQo6HZeb2dtr4ouAJAutm7d6sa8bdq0CWv7tm3burGzXgcAyF+lM807AkA2LeLWOaTuH3300e6+EgBpWQVkjqwPOo8cOfKwoLIOgB999JG7RCJeQefly5fn+z10EA8WpJ03b54LKOfVz1pZwlKxYsWo+jmHyws6q/S3/gDp84BMpsoBWtlMwBkAUtOWLVvswIEDLrMvL9pO2wNAOtHCGo2Jwz0f9bYLZ/EyACB4QoSSXypUqMDXAyCrFnGrxea6devc2FnHQsUnlHTGIm4gc2R90FlUGiycx3ITbjZ0NBo1ahS3AO8rr7zibn/33XfWvn37oNvt37/fVq9e7W43btzY4ime3yOQqgPNcuXKJXtXAAAhqPqNqq/4V30JRb34tD0ApCPGYgCQmGNtt27dgiaHAECmL+LeuHGj7d271z2uhTdKOPOOhyziBjJD1gedR4wYYdnKf1J0zpw5IYPOX375pW+i9cQTT4zrPinLWZRNzYpPZLquXbtapUqVkr0bAIBcaGFQYI/T9evXuxXbrVu3duXAAACJo4nKt956y+bPn29r1qyxXbt22b59+8IO9sycOTPu+wgAoXTu3Nlq1arFFwQg6xZxK7Ht3XffdS0/lf2sa7UaUOuWQoUKsYgbyBAEnbM46NylSxfXO2bnzp32/PPP2/Dhw4Oubp84caLv9rnnnhu3/VF/h6VLl/r+IEXSzxlIN61atbK6desmezcAAFH0pJo8ebLt3r3bVqxYYcOGDXMDZQBA/D388MN27733RlXaW9XMyOYGkExasNiwYUN+CACychG35v6V8bxt2zarUqWKFS5c2N2vV69e3BPdACRO1geds5kmSK+//nq75557XN/oUaNG2d///vcc23z++ef23HPPudsnnXSStWnTJuh7eYN3rdbUavNAr7/+uvsDE2qQ//3331v//v1996+55pp8/duAVFajRg07/vjjk70bAIAoLFiwwAU7lixZYi1atHD3GSADyATKHL777rvD2s4TzvZy5513Wn4NGjTIJkyYEHErLABIBWpX17Jly2TvBgAkbfG2gs6//PKL/fnnn9akSROXfKb7elwxBxZzA5mBoHOWU5D5pZdespUrV7pMZwV/+/XrZ8WKFbNZs2bZ/fff70pf6P7o0aOj/hxlSB9zzDHWu3dvVzKjevXqroS2+jjMmDHDBba91ep9+/Z12wGZqGTJkq6sNlkWAJDeA2VVimGADCCTaBGNLuHwzmXvuuuuhASd3377bRs/frzvc7WI88ILL3QBHLVlUqYMAKQqJWhokSLzAACyffH2Tz/95FoNqpezrnVfWc8s5gYyB0HnLKfeCRrA9+jRw1atWmVjx451F3+lS5d2ZSSPO+64fH2WAtoPPfRQrttcffXV9thjj+Xrc4BUpQHmySefbEWLFk32rgAA8jlQ1jGdATKATBKvDOJYBFnGjRvnu60KWVq0rEXMAJDqFFTRPAAt5ABkq8As59q1a/sW5GiMzWJuILMQdIbLQP7666/tySeftJdfftkFh/XHQKvHFYxWr0L9EciP6dOnu1Ld8+bNcxO0W7ZssT179riAtvradurUyS6//HJr2rQpPxFkLJXU1uo9AED6oRwYgEzVuXPnlM++0zjSC94oAE3AGUA6KFu2rHXv3p1qDACyWmCWc/Hixd3jJUqUINsZyEAEnYOs7l62bJktWrTIBUZ3795tBw8eTFifqmTRQV7ltXWJx6r4nj17uguQrVQ2hv5NAJC+KAcGIFPNnj3bUt22bdtcYFxtaqgaBCBdWmspkYNjFoBsFrh4u2rVqrZv3z7f87q/adMmsp2BDELQ+f/oYPfwww/bU0895foMRyOdg84AcuefhX/gwAG3KKVatWphfW0FCxa0Ll26UE4LANIU5cAAILmOOuooN05XeygASHUKNCvgrMAzAGSzr776ypflLEr0C8ZrXaXtO3TokOC9BBBLBJ3/b9X0qaee6g564fSx0grrwO1SvRwZgPx59tlnfbd37dpl06ZNC/u1ynAuV64cPwIASFPpVg5s/fr1brDeunVrt3IcANJd48aNXdB57dq1yd4VAMhV4cKFXUltldYGgGynpB0l79SvXz/Pbb0kHwDpjaCzmfXt29f1NBZNGJ577rn25ZdfuolDBZOVwawy25pQ9MpB6HFNNA4dOpRSOQBCKlOmjLVo0YJvCADSVLqVA9P+Tp482Z27rlixwoYNG5bU/QGAWLjkkkts5syZNnfuXNuxYwfBHAApHXDWokQAgFnHjh1d69I9e/bkSAD88ccfrW7dujmSdBRr0fYA0lvWB53ff/99++ijj1wQWdkgH3zwgZUuXdquu+46F3SWESNG+L4wHSRfe+01u/HGG23dunU2Y8YMe/vtt+3oo49O4o8RQKpSSRiV1wYApKdUKAcWSeayl5W9ZMkSt+gpVbKvASA/LrroInvmmWfsiy++sJtuusmee+45vlAAKRdwPuOMM9z5IADgfymo3KtXrxyLpEePHu2qh/3+++82ePBgFkkDGaaAZTn/ErkauCrgnJsCBQpYnz59XCZ0w4YNbfHixdavX7+wynIDyC4KDNSsWTPZuwEAiFE5sKZNm7pL7dq13SrsOnXq+B7T83mVA1PwePr06bZhw4aIM5cVPNa17oeTlb1z505f9nVurwGAdKBFnC+//LI1adLEJk6c6DKfVWUCAFIBAWcACI//ImlV5/KS/gBkjqzPdP7888/dF6HBqyYMw1WxYkV78cUXXcbJJ5984gbAKtMNAJ62bdvyZQBAhpUD279/v7377rtuNbbKbXft2tUKFSqUZzmwaMteR5K57N97WlV8Uq3XNABE6+6773bXp59+uq1atcqmTJli//3vf90xt1mzZq6ljY574VD7LACIZcC5R48eVrlyZb5UAMhFqEXSyW5RBSC2sj7o7PVn1kDVn/+AVROKRYoUOezLO/74413QWeUONYlI0BmAp1atWvRxAoAMLAemQbGymlXt5phjjrF69eqFFdCNpux1JIPywN7TWlC5dOlSBvIAMsLIkSMPCyrrWKdWWbpEgqAzgFgpWrSoK6mtxBQAQO5YJA1kh6wvr+1lrZQtWzbHF6NMFc+OHTtCfoHKjlZp7W+++SaOPyYA6UaLUgAAmSXa8tXRvi7YoFz3g5Ug89+2UqVKbvJT17m9BgDSicbd/pdgj+V1AYBYKVWqlFuYSMAZAPIWuEj62GOPdde0hAIyT9ZnOuskUUHlP/7447CsFs8PP/wQskyO9zodIAFAqlevzsATADJQtCuzo3ldJJnLgduq57RXdUOfQdkyAOluxIgRyd4FAPApX768y3D2T1gBAISW2yJpWkIBmSXrg86ajFPQefPmzTm+mMaNG/tuz5071zp06BD0C1RpRaHvAABPy5Yt+TIAIMNEW7462tdFMigP3LZ48eLucU2EMpAHkAkIOgNIFToPU3/5YG34AACHS7dF0uvXr3ftVNVWtWrVqsneHSDtZH157ebNm7syW8uXL8/xxbRv394KFizobj/99NNuIi+Q+jjrdcpYadiwYcJ+aABSewB69NFHJ3s3AAAxFm356mhel9ugPLAEWeC2GhTv27fPd9F9ypYBAADkX506daxHjx4EnAEgAuEskk6VllAaXyvmo33RdV4tsQAcLuuDzl26dPGV0N64caPvi9GEYPfu3V1AWge+zp0726uvvmqrVq1y2c333HOPDR482Ld97969g3y9ALINWc4AkHkiCQLH4nWRDMq1AtvbVhYtWuTe07vovniv0fYAAACITNOmTa1bt25WqFDWF40EgLAle5G0spanT59uGzZsCGt7byy+ZMkS2717d0oEwoF0k/VnSmeeeabLaD548KC99tprds011/i+nAcffNA+/PBDd7BToPn8888P+iXWrVvXhg4dmsAfG4BUpMUq6ucMAMgs0ZavjuZ1oQblHt3ftGmTb1B+zDHH2IEDB6x+/fp5/ju03ZYtW+LwDQEAAGQuVUNs1qyZq3QIAAhfsEXSGucqoFuqVClf5QhvbKztg7U5jabktZe1rM9asWKFDRs2LNfy3f5j8Z07d6Zc2W8gXWR90FlBokcffdStdvEmAj3HHnusvf7669avXz93oAmmQYMG9uabb1rJkiUT9CMDkKqOO+44BqEAkGEiDQJ7A9JoXxdsUB6MNyhXALtt27a2Z8+ePP8t2rZjx44x+V4AAAAynZJUVCGxXr16yd4VAEhLWvTsv0hat5XcV7RoUTeH2rhxY1+L01CLpCMNHgfLWm7RosVhi8RDba+xtvYt1OJyALnL+qCzXHfddSG/oNNPP92V1H722Wdt5syZLjhdoEABl93cs2dPu+yyy1jpAsDKlSvnK5sKAMgckQaBvZXZ0b4ucFCeG22nAXivXr3y9W8EgHSjNljLli1zx1YdNzUJqepl4bjzzjvjvn8A0l/hwoXdnGC4GXUAgMNp0bPO0bxF0goaV65c2X7++Wd3rQpgDRs2zHWRdKTB42iylgMXjTdp0sSWLl1KtjMQBYLOYTjqqKPsH//4h7sAQDA66aHUFgBknkiDwN7K7GhfFzgozw2ZywCyjSpGPPzww/bUU0/Zxo0bo3oPgs4A8lKsWDE744wz3HwgACB/STreImkFdkePHu0qz27fvt1da0x73nnnhUzqi7bkdaRZy4GtsbRvubXSAhAaQWcAiMGAlHJbAJCZog0CR/s6/0E5AOD/27Ztm5166qkuu1mZznnRBGPgdiwSBZAX9Rjt0aOHlSlThi8LAGIomvLV0bwm0qzlwO29Spa1atVyn0NvZyAyBJ0BIJ/8+48AADJLtEFggscAEFt9+/a1r7/+2t3WZOO5555rX375pZsM1CSkMphVZluTkd7EoR7Xwp6hQ4e63oEAkNf5mwLOOm4AAGInmvLV0Za8jjRrOXD74sWLu8f1t4BsZyByBJ1D+Pbbb23t2rWu1MP+/fvt0ksvjeLrBZANGjVqlOxdAAAAADLW+++/bx999JELIrdu3do++OADK126tF133XVuolBGjBjh216VJl577TW78cYbbd26dTZjxgx7++237eijj07ivwJAKlNQQgHnIkWKJHtXACDjRFO+OprXRJq1HLh91apVXTsXj+5v2rSJbGcgAgUi2TjT6YClFdDly5d3/VnPOussu+SSS2zgwIGHbfvrr7/aBRdc4FZbP/TQQ0nZXwDJp5OckiVLJns3AAAAgIw1bdo03+3nnnvOBZxzU6BAAevTp4/LhG7YsKEtXrzY+vXrF1ZZbgDZR72bCTgDQHzkFgjWfS8QrO3y85pws5b1vLdo8auvvvJtL2rjovf1Lrov3uu0PYDcken8f6ZOnWpDhgxxfffC6ftUuXJlt8plzpw59s4779g111xD4AnIQvRyBgAAAOLr888/d9cqq9i0adOwX6eMmBdffNFlR3/yySf28ssvu4XjAOCpUKECAWcAiKNoyldH85pospa3bNliBw4csPr16+f579B22h5A7gg6m9krr7xiF198sftCFHAuW7asdejQwVavXm0rV64M+eUNGjTIBZ337t1r7733np133nl5fN0AMk21atWSvQsAAABARvP6Mzdr1izkAnFNLgYri3v88ce7oLMyUyZPnkzQGYCPKh2eeeaZ9HwHgDiJJhAs0ZS8Dpa1HIwXsNb2HTt2dG1ZlIiYFwW8tT2A3GV90HnHjh02ePBgF2xWCa4777zTbr31VjdYVX+o3ILOZ599thUqVMitcpk5cyZBZyDLaJVdmTJlkr0bAIAEW79+vRugKoihAS8AIL68iUAtEA+c/PMf26siWTDKjlap7W+++SbOewogXeh4QsAZAOIrmkCwRPoaJRBGk7Vcrlw569WrVz7+hQACZX3QeezYsW5wqhXSI0aMsDvuuMPCVapUKWvcuLEbuKpHFIDsonJ9wcrvAwAye6W2MuV2795tK1assGHDhrlV1QCA+NHYW+P2P/74I8fjmij0/PDDDyGDzt7rlBEDAFpAfsYZZ1ixYsX4MgAgjqItXx3Na8haBlJD1ged1Y/Z6+Fyyy23RPwFNmzY0AWdNcAFkF38J7kAANnB6y21ZMkSa9GiRY4eUgCA+KhVq5YLOm/evDnH41oE7pk7d67LcgnGWyTOIiEAhQsXtu7du7vFLACA+Io2EBzNa8haBlJD1gedlaGiTMVOnTpFNQD1gk47d+6Mw48HQCoLLO8HAMieflQ69wvsIQUAiI/mzZu70orLly/P8Xj79u2tYMGCbmLy6aeftmuuucZKliyZYxtVp9DrNO7XonEA2Utt9U499VQ76qijkr0rAJAVog0EU/IaSF8FLMtt27bNXVeqVCmq16uEg3fiCiC7+PeQAwBkT5azekcpeKFr3dfjAID46dKli7tWhbGNGzfmaHejjMVDhw65Y3Lnzp3t1VdftVWrVrns5nvuuccGDx7s27537978mIAspmNE9erVk70bAAAAGSvrI6VlypRxX4QmDKOxfv16X3luANnXBwoAkH1Zzn/++acde+yx7trLdtbzAID4OPPMM11Gs7z22ms5nnvwwQetSJEi7rYCzeeff741atTIjj/+eBs5cqQ7VkvdunVt6NCh/IiALKW2KA0aNEj2bgAAAGS0rA86V6tWza2K9no8RWLfvn32+eefu0wXTlyB7FOsWLFk7wIAIAlZzqqQo+w6XZPtDADxp2Puo48+asOHDz9s4acWAb3++utWunRpN7YPdtF4/Z133jms9DaA7FCjRg1r27ZtsncDAPB/SXzTp0+3DRs28H0AGSjrezp37drVBZyXLl1qS5Yscb2iwjVhwgTbtWuXCzqffPLJcf1BAUg99O8EgOzMcq5du7Z7vFatWi4YTW9nAIi/6667LuRzp59+uiup/eyzz9rMmTPdJKZaYCm7uWfPnnbZZZdx7g5kqbJly9opp5zi5u4AAMkfW0+ePNl2795tK1assGHDhnGOBmSYrM907t+/v+/LuOqqq3ylt/Ly7bffulXWUqhQIbv44ovj9kMCkHr0/55e7gCQnVnOXpZdiRIlyHYGgBRx1FFH2T/+8Q/78MMPbdmyZW7Mriwa9XRmsSiQnfR/X4tSOAYAQGqNrZX8p8Cz7gPILFkfdG7durX17t3bldyaN2+eW/2owWkoe/futTFjxljHjh19Wc6DBg2ymjVrJvQHByC5ChcuzI8AALIwy7lq1aquxYp30X16OwMAAKRmdcMyZcokezcAAAFj6507d/oqhulxAJkj68try7hx49xK6O+++871aG7RooXrC6UAs+fcc891B8JFixa5A6GC1NKyZUvXWwpA9mU6AwAy31dffeXLchadCwaj56tUqeK279ChQ4L3EgAAAP40X6dWKACA1KsgpkQ+bwytx0888cRk7x6AGCFq8n/9XWbNmmUXXnihzZ49230xCkKL1/NFZbnECzaL+jj/5z//sSJFisTq5wEgTRQsWDDZuwAASIAtW7bYgQMHrH79+nluq+20PQAgMVSlbO3atbZ9+3bbv3+/XXrppXz1AKxatWqusiEAIDUriDVp0sSWLl3qy3Zu06YNrRCADEHQ+f9UrlzZZs6caS+++KI99thjIbNYpHHjxnbLLbe4Ps7p3tNVq4sWLlxo8+fPdxetLFqzZo17TitCvdux9Nlnn9lTTz1lc+fOtV9//dUF/ZVdPmDAABf4B9IBQWcAyA5qqXLw4EHbs2dPntuqx7O2BwDEj7JiHnroIZs6daorzegvMOis8eb111/vFo8rADV8+HB+NECG0/mYWud5SSQAgNTKcq5UqZJVrFjRXZPtDGQegs5+dEJ6ySWXuItW2ajU9oYNG9xAVietCky3a9fO6tSpY5miZ8+evuzuRBg5cqTdc889bvLWfyLg/fffd5fJkyfbf//7XytatGjC9gmIRrovOAEAhKdcuXLWq1cvvi4ASAEKNA8ZMsQtBPKvQibBAkwaw2/atMnmzJlj77zzjl1zzTVWsmTJBO4xgETScUABZ+aUACB1s5xr167tS3hTMJpsZyCzEHQOQf0E1Mc50/kP1MuXL+9WfysTWSuPYu2ZZ56xu+66y92uV6+e3XbbbdasWTMX2P/3v//tSpy//fbbdvnll9uUKVNi/vlALBF0BgAAABLnlVdecdXGvHGsKmZ16NDBVq9ebStXrgz5ukGDBrmg8969e+29996z8847L4F7DSCRNKel+TwAQOpmORcvXtw9riQ/sp2BzEOqXpbr37+/C/CuWrXKtm7dajNmzLAKFSrE/HO2bdvmSpJLzZo17YsvvnDBZfVrUPbQBx984LKuvdXricy+BqJB0BkAAABIjB07dtjgwYNdsFmZjCNGjLCNGze6Rcunnnpqrq89++yzrVCh/11vr5ZaADK3j/Nxxx2X7N0AAOSS5Vy1alXbt2+f76L7etzLdtb2ANIbmc5Z7sorr0zI54wbN87Xb+vBBx+0o4466rD+uOrzrJJnBw4csIcffti6dOmSkH0DokHQGQAAAEiMsWPHusCzF3C+4447wn5tqVKlrHHjxvbNN9/Y4sWL47qfAJKjWLFi1rVrV/o4A0CK+eqrr3xZzrJo0aKg23m9nbW9KtkASF8EnZEQr7/+ursuXbq09e7dO+g21atXt27durlsa61A3717t5sgAFIRQWcAAAAgMbQ4WVSVy6ugFYmGDRu6oPMPP/xg6UiTtQsXLrT58+e7i8pUrlmzxtcP0bsNZKvOnTv7yrUCAFLHli1bXIJZ/fr189xW22l7AOmNoLMf9XhSeS4N4n788UfbtWuXK/MQDq24plRXcCqLoe9UtFLpyCOPDPk9nnTSSS7orLIaX375pVupCqQigs4AAABAYqxYscKNuTt16pTreDKUcuXKuWuv+la6USsqWlABoReVaPEFACD1dOzY0Q4ePGh79uzJc1v1eNb2ANIbQWcz1xdK5Zzvu+8+t4I4Ul5fKQS3cuVKt1JJGjVqlOvX5P/88uXLIwo6r1u3Ls9tvP0A8ksl4QEAAADE37Zt29x1pUqVonq9Nw5M14WjmnPwlC9f3lq3bm2fffZZVPMXQCZRdTzKsAJA6tLCv169eiV7NwAkEEFnM7v44ott2rRpOQZyiB3/YLBKaOemRo0avttr166N6HP8XwvEW7pOWAEAAADppkyZMrZ169aog6zr16/3ledOR/3797chQ4ZYmzZt7JhjjnGP1a5dm6Azsp6q5UVT/QAAAADxkfVB5ylTptjUqVN9mcoqy9O3b19r2rSpW0FcqFDWf0X5pt7MnpIlS+ZZRsPDqm2kMjKdAQAAgMSoVq2a6/G3ePHiiF+rllmff/65G/M3aNDA0tGVV16Z7F0AUk6TJk2satWqyd4NAAAA+Mn6iOq4ceN8X8YNN9zgymyTwRhbf/zxh+92XitQixQpkqPHdiTCyYzWyvBffvklovcFgiHoDAAAACSG2i4p4Lx06VJbsmSJNW/ePOzXTpgwwXbt2uWCzieffHJc9xNAYihhQfM7AAAASC1ZXx9WA1YNPuvUqWOjRo1KyYCz9i+/l4kTJyZt/4sWLeq7/ddff+W67Z9//um7XaxYsYg+R6W787oQKESs8LsEAAAAJK68tOeqq67KMW7MzbfffmvDhw93t1XFTK21AKS/jh07UlYbAAAgBaVehDVJWbidOnXyldhGbJUqVSrsktl79uwJuxQ3kEyU3gcAAAASo3Xr1ta7d287dOiQzZs3z0455RQXUA5FVbPGjBnjAlNelvOgQYOsZs2a/MhCWLduXZ6XAwcO8P0h6ZQ0UqtWrWTvBgAAAILI+vLaGnSuWLEiJTOcPcuXL8/3exx99NGWLMow9migGm6J7Bo1asR1v4D8IOgMAAAAJLY11rJly+y7775zPZpbtGhhxx57bI62TOeee65rp7Ro0SJXZUtBamnZsqU9+uij/Lhywfgb6aBw4cJ2wgknJHs3AAAAEELWB53btWvnBq2xCOzGS6NGjSydNWjQwJUi1qpofde58X++cePGCdg7IDoEnQEAAIDEKVu2rM2aNcsuvPBCmz17tntMQWjxqpZNnz7dXXvBZlEf5//85z9WpEgRflxAkjRt2tQtBFm4cKEvAaRatWoRv8/xxx/v+jkDAAAgNaVuem+CXHvtte56wYIFuZbnQvSOPPJIa9u2rbutFem59XWeM2eOu9aEgEqoAam8whoAAABA4lSuXNlmzpxpzz//vB133HEuuBzs4i1injhxor3//vtWvnx5fkx5UNWxvC5VqlThe0RUnn32WXvjjTd896+55hq75JJLInqPMmXKuOA1AAAAUlfWZzq3atXKrrrqKnv66ad9K6YrVKiQ7J9LxjnnnHNcwFn9tF599VXr16/fYduo9PaHH37obqtHl38vaCDVEHQGAAAAEk9ZzQpW6aJS2hpnbtiwwXbu3OkyIBWYVkUz9X1N9H7l14QJE2zAgAGW7LZYoaiCGZAsKqvN7yAAAEBqy/qgs4wZM8aVftbKS62avP32261Pnz5J7YOcTtasWeMb0J900km+Umf+Bg0aZPfff7+bCLj11lvt1FNPzRHc1/evla66lr///e8J/BcAkU8oKYMfAAAAQPIo81Z9nAFkNpXjpu84AABA6iPorBrjBQrYM88848pv3XjjjTZs2DB3UekeXcJZsaxtVq9ebenm+++/t08++STHY7/99pvvWuXI/HXv3j2qkloqZ/bggw+6rPKffvrJrTxXcL9Zs2ZuVfro0aNdfy5RxnmXLl3y9e8C4klZ+GTiAwAAAPAsX748318GC9+B4PNtXss2AAAApDaCzma2b98+u/766238+PHuZNbrAbVjxw6XmZsXbR+LUlrJoIDzwIEDgz63devWw55TYDjaPk5DhgxxAeZ77rnHBegvv/zyw7bp0aOH+zkAAAAAAJAuGjVqlOxdADJS/fr16csOAACQJgpYllM55169etnYsWNt//79voCzR/fzuiB8d911lwt09+/f35VGUoniSpUquXLbU6ZMsbffftuKFi3KVwoAAAAAAJDF1MO5devWyd4NAAAAhCnrM50VbH7vvfd8Gc7dunVz5Z1V9rlcuXJWqFBmf0UDBgxwl/yoXbt2RMH3E044wV0AAAAAAIjE3r173WLl+fPn248//mi7du1y1cvCoXH/zJkz+cKBJFDVvLVr19rHH38cVlVBURu8kiVLxn3fAAAAEBuZHVENw/PPP++7PWrUKNfTGQAAAAAApA4tdH744Yftvvvus99++y2q16drWywgEyipo3r16laxYsWw/g8XKFDAWrRokZB9AwAAQGxkfdB56dKlbuB57LHHEnAGAAAAACAFXXzxxTZt2rSsbHH1/fffuzZV/rygna4nTpyY47nu3bu7rFIg3Xs5lyhRItm7AQAAgAhkfdDZ065du0i+NwAAAAAAkABTpkyxqVOn+jKVGzZsaH379rWmTZta+fLlM74tlgLOAwcODPrc1q1bD3tu1qxZBJ2R1vR/vXnz5sneDQAAAEQos0dmYahWrZqtWrXKDhw4kOxdAQAAAAAAAcaNG+e7fcMNN7gy2yq9CyAz1axZ08qVK5fs3QAAAECEsn6UdvLJJ7vyXIsWLYr0uwMAAAAAAHG2ZMkSl/lYp04dGzVqVNYFnAcMGODmLcK9dOnSJdm7DORLo0aN+AYBAADSUHaN1IIYMmSIFSxY0A1i586dm+zdAQAAAAAAfv744w933alTJ1+JbQCZqXjx4lajRo1k7wYAAACikPVB5xYtWth9993nVgP369fPvvvuu2i+RwAAAAAAEKdSu5JtGc5ANmrQoAH/1wEAANIUIzYzGz58uD399NO2bds2a9Wqld1000322Wef2a5du5L98wEAAAAAIKu1a9fOLRRfvnx5sncFQJw1bNiQ7xgAACBNZX3QWaW1dbn66qvtr7/+sr1799ro0aNd2a5y5cr5ns/rUqhQoWT/LAEAAAAAyDjXXnutu16wYIF9++23yd4dAHFSvnx5K1OmDN8vAABAmsr6oLNWS/vz7w+l5yK5AAAAAACA2FJFsquuusoOHDhgF154oW3dupWvGMhAtWrVSvYuAAAAIB+yPugsBJEBAAAAAEhdY8aMscGDB9vSpUutadOm7v7GjRuTvVsA4tC/HQAAAOkp62tCHzx4MNk/AwAAAAAAkIsCBQrYM888Y40bN7Ybb7zRhg0b5i4qxauLf9WyULTN6tWr+Z6BFFSsWDGrVKlSsncDAAAA+ZD1QWcAAAAAAJDa9u3bZ9dff72NHz/eBY+9Flc7duywnTt35vl6bR9OYBpAchx99NH8HwUAAEhzBJ0BAAAAAEDKUi/nXr162YwZM9x9L+DsCbwPID2DzgAAAEhvBJ0BAAAAAEDKGjt2rL333nu+DOdu3brZhRdeaM2aNbNy5cpZoUJMbQDprkqVKsneBQAAAOQTIzMAAAAAAJCynn/+ed/tUaNGuZ7OADJHkSJFrHz58sneDQAAAORTgfy+AQAAAAAAQLwsXbrUZTkfe+yxBJyBDFSxYkX6OQMAAGQAgs4AAAAAACDltWvXLtm7ACBOQWcAAACkP4LOAAAAAAAgZVWrVs1dHzhwINm7AiAOCDoDAABkBoLOAAAAAAAgZZ188sl26NAhW7RoUbJ3BUAcHHXUUXyvAAAAGYCgMwAAAAAASFlDhgyxggUL2pIlS2zu3LnJ3h0AMVSsWDErUaIE3ykAAEAGIOgMAAAAAABSVosWLey+++5z2c79+vWz7777Ltm7BCBGypcvb0cccQTfJwAAQAYg6AwAAAAAAFLa8OHD7emnn7Zt27ZZq1at7KabbrLPPvvMdu3alexdA5APFSpU4PsDAADIEIWSvQMAAAAAAAChqLS2P2U8jx492l0ioWzK/fv380UDKYSgMwAAQOYg6AwAAAAAAFKWgsz+5Xf9b+s5AOmLoDMAAEDmIOgMAAAAAABSGsFlIPMUKFDAypQpk+zdAAAAQIwQdAYAAAAAACnr4MGDyd4FAHGggHNg+XwAAACkrwLJ3gEAAAAAAAAA2aV8+fLJ3gUAAADEEEFnAAAAAAAAAAlVtmxZvnEAAIAMQtAZAAAAAAAAQEKVK1eObxwAACCDEHQGAAAAAAAAkFBkOgMAAGQWgs4AAAAAAAAAEuaII46wMmXK8I0DAABkEILOAAAAAAAAABKmZMmSVrBgQb5xAACADELQGQAAAAAAAEDClCpVim8bAAAgwxB0znK//fabffzxxzZq1Cjr27ev1alTx5U40qV27dox+5zZs2f73jevy8iRI2P2uQAAAAAAAEgtpUuXTvYuAAAAIMYKxfoNkV569uzpAsIAAAAAAABAIpDpDAAAkHkIOme5Q4cO+W6XL1/eWrdubZ999pnLgI6X8ePHW5s2bUI+X6lSpbh9NgAAAAAAAJKLoDMAAEDmIeic5fr3729DhgxxQeBjjjnGPaay2vEMOquEd9OmTeP2/gAAAAAAAEhdJUqUSPYuAAAAIMYIOme5K6+8Mtm7AAAAAAAAgCxSvHjxZO8CAAAAYqxArN8QAAAAAAAAAEIh6AwAAJB5CDoDAAAAAAAASIjChQu7CwAAADIL5bWRcLfffrutW7fOfvnlF7eyVT2ku3TpYldffbU1aNAg6vfVe+blwIEDUb8/AAAAAAAA8qdo0aJ8hQAAABmIoDMS7rPPPvPd/uuvv2zRokXu8vjjj9sdd9xhI0aMsCOOOCLi961Ro0aM9xQI7tFHH3UXAED2uvHGG90FAAAA4fvvf//rLn//+9/52gAgSzGeBjIXQWckzNFHH229e/e2jh07Wt26da1QoUL2888/21tvvWWTJk2yffv22V133eUC0ffff3/c9kNB7dKlS8ft/ZG5lE3P4gYAgNx0003Wt29fq169Ol8IACBrJoh37drFeBpRYTwNAPAwngYy1xGHDh06lOydQGpRueuffvrJatWqZWvWrInJe+7Zs8eOPPLIkD175s+fb6eddprt3LnTZTl//fXX1qJFi5iX1xYmhxGLQXKVKlWsYMGCfJkAkGXUqkMtQmTt2rWcVwAAAISB8TQAgPE0kPnIdE4D0ZSaDjRhwgQbMGCAJUu/NBlNAAAgHElEQVSJEiVyfb5t27Y2ZswYu+SSS0zrIHT72WefjegzCCYjkRYsWMDvHABkIbJ0AAAA8ofxNABkJ8bTQOYrkOwdADz9+vXzlemaM2cOXwwAAAAAAAAAAACQBsh0TgPLly+PST/lVKcezw0aNLAvv/zS1q9fn+zdAQAAAAAAAAAAABAGgs5poFGjRpYtYlFKHAAAAAAAAAAAAEDiUF4bKWP//v22cuVKd7tq1arJ3h0AAAAAAAAAAAAAYSDojJTx0ksv2c6dO93tk046Kdm7AwAAAAAAAAAAACAMBJ2Rb2vWrHFlsXXp0qXLYc9v377dZs+enet7zJ8/36699lp3W+9z9dVX85MBAAAAAAAAAAAA0gA9nbPc999/b5988kmOx3777Tff9cSJE3M81717d6tSpUpEn6Hs5a5du1rz5s3tnHPOsVatWtnRRx9tBQsWtJ9//tneeuste+GFF+yvv/5y2998881uGwAAAAAAAAAAAACpj6BzllPAeeDAgUGf27p162HPzZo1K+Kgs2fJkiXuEoqC0HfccYfdeeedUb0/EG/Vq1e3Q4cO8UUDQBbjbwEAAADnUAAA/hYAOBxBZ8Rd1apV7eWXX7bPP//cldFev369bdmyxf744w8rU6aMNWzY0JXlHjRokNWuXZufCAAAAAAAAAAAAJBGjjhE2h4AAAAAAAAAAAAAIEoFon0hAAAAAAAAAAAAAAAEnQEAAAAAAAAAAAAAUSPoDAAAAAAAAAAAAACIGkFnAAAAAAAAAAAAAEDUCDoDAAAAAAAAAAAAAKJG0BkAAAAAAAAAAAAAEDWCzgAAAAAAAAAAAACAqBF0BgAAAAAAAAAAAABEjaAzAAAA0sqaNWvsiCOOiOll5MiRyf5nAQAAAAAQV4ynAcQTQWcAAAAgRcyePdsXCO/SpUuydwcAAAAAgLTAeBpIvkLJ3gEAAAAgEqVLl7ahQ4fmus38+fNtwYIF7nbVqlXt3HPPzXX7tm3b8kMAAAAAAGQ0xtMA4omgMwAAANJK+fLlbcyYMbluo3LZXtC5fv36eW4PAAAAAECmYzwNIJ4orw0AAAAAAAAAAAAAiBpBZwAAAAAAAAAAAABA1Ag6AwAAIOstX77cbrvtNtfbuXLlynbkkUdaxYoVrV27dnbnnXfahg0bwvqOfvvtN3v66aftzDPPtJo1a1rx4sWtcOHCVqZMGWvUqJH17NnT7r//fvv2228PKwd+xBFHWNeuXX2PzZkzxz0WeKldu3bW/7wAAAAAAKmB8TQADz2dAQAAkLX+/PNPGzZsmI0bN84OHDiQ47ktW7a4y/z5823UqFH20EMP2bXXXhvyvT7//HM7//zzbf369Yc9t2vXLndZsWKFvfXWW3b77bfbvn37rFAhTscBAAAAAOmH8TSAQMxyAQAAICvt2bPHTj/9dPv00099j9WrV89atWpl5cqVs23btrnnlOW8d+9eu+6661zgWBnRgdauXevea/fu3e6+spvbtGljxxxzjMt21metWbPGFi9e7N4jkDKshw4d6gLWr7/+unusatWqdu655x62bYUKFWL8TQAAAAAAED7G0wCCIegMAACArHTNNdf4As4NGjSwZ555xrp06ZJjG2U/jx071m644Qa3ilultlUCu0OHDjm2e/TRR30B506dOtm0adNc0DjQ/v373Wc+++yzrlS2p0ePHu4ye/ZsX9C5fv36NmbMmLj82wEAAAAAiBbjaQDBEHQGAABA1pk7d65NmjTJl92sQPBRRx112HYFCxa0q6++2ooVK2YDBw50Qei7777b3n333cPezzN+/PigAWdROe2TTjrJXQAAAAAASDeMpwGEUiDkMwAAAECGUmay55FHHgkacPY3YMAAa9Sokbs9Y8YM27p1a47n/UtmV6xYMeb7CwAAAABAKmA8DSAUgs4AAADIKipx/cEHH7jbpUuXtrPOOius16msthw6dChHH2ipUaOG7/bTTz8d0/0FAAAAACAVMJ4GkBvKawMAACCrLFmyxPbs2eNuFy5c2IYNGxbW6xYsWOC7vXbt2hzP9e3b1z766CN3+9Zbb3VB7YsuushOPfVUq169ekz3HwAAAACAZGA8DSA3BJ0BAACQVTZs2OC7rTLZTz75ZMTvsX379hz3Bw0aZO+99569/vrr7v7MmTPdRWrWrGmdOnVymdK9evXKs5Q3AAAAAACpiPE0gNxQXhsAAABZZefOnTEpKeavYMGC9uqrr9q4cePs2GOPzfHczz//bJMnT3aB6apVq7rrbdu25XsfAAAAAABIJMbTAHJD0BkAAABZpUSJEr7bzZs3dz2aI72MHDnysPc94ogj7IorrrClS5faihUrbOzYsXbZZZdZ3bp1fdvs27fPnnvuOWvbtq1t3rw5Yf9mAAAAAADyi/E0gNwQdAYAAEBWqVy5su/2L7/8EpfPaNCggQ0ePNgmTpxoq1evdkHoG2+80WVEix6766674vLZAAAAAADEA+NpALkh6AwAAICsctxxx1mRIkXc7U2bNtn3338f989UEPqRRx7JEWiePn160GxpAAAAAABSEeNpALkh6AwAAICsUqxYMTv55JN995966qmEffbZZ5/tu/3rr78e9nzRokVzlOIGAAAAACBVMJ4GkBuCzgAAAMg6t9xyi+/2E088YR9++GHYrw1WknvLli1hvXbt2rW+25UqVTrs+QoVKvhur1+/Pux9AgAAAAAgERhPAwiFoDMAAACyzkknnWSXXXaZu71//34788wz7YEHHrDffvst6PZ//PGHvf7669arV68c2cqemjVr2pAhQ2zOnDl28ODBoO/x5Zdf2nXXXee7f8YZZxy2TZ06dax48eLu9k8//WQLFiyI+t8IAAAAAECsMZ4GEMoRhw4dOhTyWQAAACANjRw50tc/WQPi2bNnH7bNn3/+6QLI77//vu8xBXzbtWvngsjq+7xjxw5bvXq1ffvtt257adWqlQsgh+rFXKpUKdfnqlatWlaiRAmXBf3dd9/Z0qVLfdtUrFjRFi1aZFWrVj1svy666CKbMmWKb3+6d+/u9qdgwYLusfLly9ttt90Wg28JAAAAAICcGE8DiBZBZwAAAGTlIFkOHDjgtnvkkUfs999/z/N9CxcubFdeeaWNGTMmx+MKNIfKkg7UokULmzZtmjVq1Cjo88pwbt++fdAy3qJg9po1a8L6LAAAAAAAIsF4GkC0CkX9SgAAACDNKXv47rvvdmWvJ02a5Ho7L1u2zGUn79u3z0qXLu2CvM2aNbOuXbtajx49XJZyoK1bt9rHH3/symurJPaqVavs119/dWW5la1cvXp1lyHdp08fl11doEDoLjf6vMWLF7vAtrKwV65cabt373ZlwAEAAAAASAWMpwEEItMZAAAAAAAAAAAAABC10CkWAAAAAAAAAAAAAADkgaAzAAAAAAAAAAAAACBqBJ0BAAAAAAAAAAAAAFEj6AwAAAAAAAAAAAAAiBpBZwAAAAAAAAAAAABA1Ag6AwAAAAAAAAAAAACiRtAZAAAAAAAAAAAAABA1gs4AAAAAAAAAAAAAgKgRdAYAAAAAAAAAAAAARI2gMwAAAAAAAAAAAAAgagSdAQAAAAAAAAAAAABRI+gMAACArDR79mw74ogj3KVLly7J3h0AAAAAAFIeY2kAoRB0BgAAAAAAAAAAAABEjaAzAAAAAAAAAAAAACBqBJ0BAAAAAAAAAAAAAFE74tChQ4eifzkAAAAAAAAAAAAAIJuR6QwAAAAAAAAAAAAAiBpBZwAAAAAAAAAAAABA1Ag6AwAAICmOOOII38WzaNEiu/rqq61hw4ZWsmRJd2nXrp099dRTtn///sPe48svv7QBAwZY48aNrUSJElahQgXr2rWrTZ48Oc/Pnz17tu/zu3TpEnSbNWvW+LapXbt2js8dNGiQNWjQwIoXL27lypWztm3b2v3332979uzJ9XNDvWdutJ33Gr0+lC1bttioUaOsW7duVrVqVStatKgVLlzYypYta02aNLHzzjvPHn30Ufvxxx/D+lwAAAAAQGphLM1YGkhV9HQGAABAUvgHmw8dOmQPPfSQ3XbbbXbgwIGg259++un2xhtvWJEiRdw21113nf3P//xPyPfv16+fvfjii1awYMGQQWcFqOWkk05y9wMpwFunTh13u1atWi5YO3LkSLv33nvt4MGDQd9X23/44YdWt27doM8HvmduQWT/oPNPP/3kbmsfggWr9d0MHDjQtm/fnuf7VatWzdatW5fndgAAAACA1MJYmrE0kKoKJXsHAAAAgGeeecZuueUW90U0b97cjjvuOBcsnjdvni1btsw9PmPGDLv++uvdttdcc42NHTvWChQoYG3atHGZzgoCz50715fFO23aNGvRooXdeuutMfuC77rrLrv77rvdbe1js2bNXCaxMrQXLlzoHtfnn3POOe5+oUKJOd1W5rWymL1s8GLFiln79u1dcFpB+l27dtnq1avtm2++sd9//z0h+wQAAAAAiC/G0vnDWBqILYLOAAAASLphw4ZZlSpVbOrUqYeVun7kkUfs5ptvdrfHjx9vjRo1cgFnBZq1vQLLHmVAa9vRo0e7+/fdd5/LiFbp7fzauHGjCzjXq1fPpkyZ4spp+3v55Zftoosusn379rngrra59NJLLRH07/QCzn369LFnn33WlfwO9Mcff9hHH31k06dPT8h+AQAAAADih7F0/jCWBmKLns4AAABIifJgKkkdrLfyTTfd5HoUiwKrN954o1WqVMmVw/YPOIuyo9XTWD2h5bfffrO33347Jvv4119/Wfny5e3jjz8+LOAs559/vhvwexQQTxRleIuymidOnBg04Czq8dyjRw97+umnE7ZvAAAAAID4YCydP4ylgdgi6AwAAICkGzJkiDVp0iTk8xdeeGGO++r9rMBzMAo89+3b13d//vz5MdtPfW7VqlVDPn/55Zf7bi9YsMASReWzpXjx4layZMmEfS4AAAAAIHkYS+cPY2kgtgg6AwAAIOnUjzg36p0cyfZNmzb13fZ6PMeCsplzo9Lf6qcsW7dutd27d1si1KhRw11v377dXnrppYR8JgAAAAAguRhL5w9jaSC2CDoDAAAg6fyDxMH4l4suU6aMVatWLdftVQY7cOVyfulzvQFpbqXN/Pc1Vp+dF//MbmWF9+7d2wWfN23alJDPBwAAAAAkHmPp/GEsDcQWQWcAAAAknQK6uSlUqFDY2wZuv2/fvnzuXfifK4ULF475Z+fln//8p7Vv397dPnTokL322mvWr18/q1y5sjVo0MCuuOIKmzJlSsIyrwEAAAAA8cdYOn8YSwOxRdAZAAAASacM4XhsG0vJ+txwlChRwubMmWMPP/yw1a5dO8dzq1atsvHjx9tFF11kVapUseHDh9vevXuTtq8AAAAAgNhgLJ0/jKWB2CLoDAAAAKS4gwcP5rnNkUceaTfffLP98MMPtmjRInv88cddtrN/KfLff//dBaa7du1K4BkAAAAAkNEYSwOJRdAZAAAASCD/8tv79+8P6zU7d+6MaKV7ixYt7LrrrrOpU6faunXrbOHChTZw4EDfNvPmzbMnn3wywj0HAAAAACA5GEsDqY+gMwAAAJBApUuX9t3evn2768Gcm59//tl27dqVr89s2bKlK7E9aNAg32PTp0/P13sCAAAAAJAojKWB1EfQGQAAAEigUqVKWfny5X3lrleuXJnr9v/5z39i9tlnn3227/avv/4as/cFAAAAACCeGEsDqY+gMwAAAJBg7dq1892eOHFiyO1UGvuBBx7I9b3+/PNP++2338L63LVr1/puV6pUKazXAAAAAACQChhLA6mNoDMAAACQYP379/fdfvTRR+2VV145bJsvvvjCTjrpJFeC+8gjjwz5Xhs3brQaNWrYzTffbF9++WXI7T744AMbMWKE7/4ZZ5yRr38DAAAAAACJxFgaSG2Fkr0DAAAAQLbp16+fjRo1yhYvXmx//fWXnXfeeXb88cfbcccdZwcOHLAlS5bY119/7bYdOXKkTZgwwX766aeQ77djxw575JFH3EWlu9XDuVq1ala0aFHbtGmTe78ffvjBt32DBg1s2LBhCfm3AgAAAAAQC4ylgdRG0BkAAABIsEKFCtlrr71m3bp18wWDFy5c6C6eI444wm677Ta78847XdA5lMKFC1uRIkVcmW3Ztm2bzZw5M+T2Xbp0salTp1qJEiVi+m8CAAAAACCeGEsDqY2gMwAAAJAEderUcRnITzzxhL366qu2cuVKFziuWrWqderUya6++uoc/apCUUbz1q1b7aOPPrK5c+faV199Zd9//71t3rzZZVGXKlXKatWqZW3atLELLrjABboBAAAAAEhHjKWB1HXEoUOHDiV7JwAAAAAAAAAAAAAA6alAsncAAAAAAAAAAAAAAJC+CDoDAAAAAAAAAAAAAKJG0BkAAAAAAAAAAAAAEDWCzgAAAAAAAAAAAACAqBF0BgAAAAAAAAAAAABEjaAzAAAAAAAAAAAAACBqBJ0BAAAAAAAAAAAAAFEj6AwAAAAAAAAAAAAAiBpBZwAAAAAAAAAAAABA1Ag6AwAAAAAAAAAAAACiRtAZAAAAAAAAAAAAABA1gs4AAAAAAAAAAAAAgKgRdAYAAADgjBw50o444gh30W0AAAAAAJA7xtLA/yr0f9cAAABAXO3atcveffdd++CDD+zLL7+0zZs325YtW+zII4+0cuXKWYMGDaxNmzZ29tlnW4cOHfhpAAAAAACyHmNpAOmCoDMAAADi6vfff7fRo0fbqFGjbPv27Yc9/9dff9lvv/1ma9eutZkzZ9q//vUvF4DWSuF+/fq5rNt047/Phw4dSuq+AAAAAADSD2NpxtJAuiHoDAAAgLj5+eefrWfPnrZkyZIcj9esWdOaN29uFStWtAMHDtgvv/xiixcvtl9//dU9v3LlSuvfv78LRA8fPpyfEAAAAAAgazCWBpCOCDoDAAAgLtasWePKZCug7GX/XnjhhXbbbbdZkyZNDtteGcEqu/3EE0/Y5MmT7eDBg25lNwAAAAAA2YKxNIB0VSDZOwAAAIDMo5LZ559/vi/gXLRoUXv11VddMDlYwNkLSqun86RJk1zWc9OmTRO81wAAAAAAJA9jaQDpjExnAAAAxNxDDz3kspY9zz//vJ1zzjlhv14B5y+++MIWLVrETwcAAAAAkBUYSwNIZ2Q6AwAAIKb27t1rjz/+uO9+7969rW/fvhG/T4kSJezEE08M+fxPP/1kd955p7Vv394qV65sRx55pLvW/REjRrh+0HmZPXu2y7DWpUuXLr7HP/roI+vXr5/VrVvXZWlXqFDBOnfubGPGjLF9+/bl+V7+vMcCLyqZ5tFt7/HatWv7Hv/kk09s0KBB1qhRIytTpox7/m9/+1vQz58xY4Zdfvnl1qBBAytdurQVK1bMatWqZeeee65NnDgx5H4DAAAAAJKPsTRjaSDdkekMAACAmPrvf/9rmzdv9t2/8cYbY/4N33fffXbvvffaH3/8kePxTZs2ucu8efPcCvGRI0faLbfcElEps2uvvdaeffbZHI//+eefNnfuXHeZMGGCC/AeddRRMfv3BNuP66+/3p555pk8t9W/t3///jZz5szDnvv555/d5fXXX7f777/fpkyZYq1bt47TXgMAAAAAosVYOv8YSwPJRdAZAAAAMaUsYU/NmjVzzVaOhoLCTz75pO9+yZIlrWvXrlalShXXQ3rWrFn222+/uYD0rbfe6h577LHHwnrvK6+80pUCL1CggLVr185lGB88eNCV+l6xYoXbZuHChXbppZfaO++8k+O11apVs6FDh7rb/vvnPRZI2cih3HDDDb6Ac7NmzaxFixZWuHBhW7lypds3z6+//uq+39WrV/seq1evntv3IkWK2LJly1wAXlatWuW+p/feey/mPxMAAAAAQP4wlmYsDaS9QwAAAEAM1atX75BOM3U5//zzY/rdvvTSS7731mXAgAGHdu7cmWMb3b/44otzbPfKK68Efb9Zs2b5tilSpIi7btOmzaHly5fn2O7gwYOHRo8eneM958yZE3I//bcLx48//ujbvmDBgu66Ro0ahz7++OPDtv3jjz98t8844wzf60qUKHFo6tSph22/YMGCQ3Xr1vVtp/fdvn170P0YMWKEbzvdBgAAAAAkBmNpxtJAuqOnMwAAAGJKvZY9TZo0idn7KuNYmcue888/38aPH39YxrDuT5o0yXr16uV7bPjw4e71uVEJ7fr167vV5cpw9qdeysOGDbPzzjvP99jUqVMtHg4cOGDFixe3Dz/80Dp16nTY88pgFmV0v/vuu77HX3rpJdeHOpDKaav0tnpCi3pd+/fcBgAAAAAkH2Pp/GEsDSQfQWcAAADEzK5du2z//v2++2XLlo3Ze7///vv2448/uttHHnmkC5wqGByMHleJa5WkFpWf/uCDD/L8jH/961+uXHcol19+ue/2/PnzLV5UQrxBgwa5buPf7/nss8+2M888M+S2tWvXtttuu813/+mnn1YKdoz2FgAAAACQH4ylY4OxNJBcBJ0BAAAQM7t3785xP7cAbn76W/Xo0cP1cM6Neix3797dd1+ZwbkpWrSo9ezZM9dtWrZs6bu9Zs0ai5dgGcuB/P89/sHwUAYOHOjrB71x40Zfj2oAAAAAQHIxlo4NxtJAchF0BgAAQMyUKlUqx/3ffvstZu/99ddf+26fcMIJYb3mxBNP9N1euHBhrts2bNjQlxkdSoUKFXKsRI8H7UOzZs1y3Wb9+vW2adOmiL6PihUr5siezuv7AAAAAAAkBmPp/GMsDSQfQWcAAADEjPopFypUyHd/x44dMXvvzZs3+27XqlUrrNeorLRny5YtuW7r9TzOjX9Q2r+MeCyVK1cux3eY13dRrFgxF1CO9fcBAAAAAEgMxtL5x1gaSD6CzgAAAIgp/4DwsmXLYva+/lnTJUqUCOs1/tsFlisLFKo/dKIpiByP7yLS7wMAAAAAkDiMpfOHsTSQfASdAQAAEFMdO3b03Z43b17M3te/P/SePXvCeo3/doHlytJZNN9FJn8fAAAAAJDuGEvHH2NpIL4IOgMAACCmTj75ZN/tn376yT777LOYvK9/Cemff/45rNesWbPGd/uoo46yTOH/XezduzfsUtmZ+n0AAAAAQLpjLB1/jKWB+CLoDAAAgJg6//zzcwQ0H3300Zi8b8uWLX23ww1k+293/PHHW6aoVq2aVapUKaLvQ4HplStXZuT3AQAAAADpjrF0/DGWBuKLoDMAAABi3kfp+uuv991/5ZVX3CVSKgXtH0z1X/X9zjvv2KZNm3J9/YYNG+zdd98N+vp4K1q0qO/2vn374vIZXbt29d2eOHFinttrm4MHD7rbVatWtYYNG8ZlvwAAAAAAkWMszVgaSHcEnQEAABBzw4cPz5FJe8kll9ibb74Z9uu//fZba9++vb3//vu+x0477TSrU6eOu/3nn3/a3/72t5CvP3TokF133XW+gG+9evWsW7duligVKlTw3V6/fn1cPmPIkCG+26+99prNmDEj5LYqc37ffffleO0RRxwRl/0CAAAAAESHsTRjaSCdEXQGAABAzBUpUsRefvllXwlo9R0+55xz7NJLL7Xly5eHDBQvWLDALrvsMmvRooULPOc4cS1QwP71r3/57k+dOtUGDx5sv/32W47tdu/ebQMHDrRXX33V99hDDz3kXp8oTZs29d3W9xCvTOczzjjDd/+8884L+llfffWVC7jv2LHD3a9Ro0aOTHQAAAAAQGpgLM1YGkhnhZK9AwAAAMhMdevWtXnz5lnPnj1dAFmlnV944QV3qV27tjVv3tz1fj5w4ID98ssvtmjRIvv1119zvEepUqVy3O/bt699/PHH9uSTT7r748aNs5deeskFYCtXruxKbs+cOTNHIFoZ0b1797ZE6tOnjy/z+JZbbnFlvps0aeImEDy33367lStXLl+fM2HCBDvxxBNt9erV7t+s76d+/frWrl07O/LII23ZsmXuZ6CAvpQoUcIF68uWLZvPfyEAAAAAIB4YSzOWBtIVQWcAAADEjYLLn3/+uT322GP26KOP+rJt16xZ4y6hKNN55MiRLjs60JgxY6xKlSp27733ujLbymyePn160L7Kd955p/3jH/+wRBswYIC9+OKLLkCugO+sWbPcxd+1116b76CzAu2ffvqp9e/f3z766CP32KpVq9wl0DHHHGNTpkyxNm3a5OszAQAAAADxxViasTSQjgg6AwAAIK5Klixpd9xxhyvp/M4779gHH3zgSj4rK3nbtm0uI7d8+fLWqFEjl6GrQLN/P+hg/vnPf7o+0cp0Vkbxjz/+6ALayuDVqvDTTz/dBg0aZDVr1kzKT7dw4cL24Ycf2nPPPWevvPKKy/TWv/Wvv/6K+Wcp8Kzs7vfee89lfX/yyScuc1z9rFXevGXLlu47vfjii91+AQAAAABSH2NpxtJAujnikFdrDwAAAAAAAAAAAACACBWI9AUAAAAAAAAAAAAAAHgIOgMAAAAAAAAAAAAAokbQGQAAAAAAAAAAAAAQNYLOAAAAAAAAAAAAAICoEXQGAAAAAAAAAAAAAESNoDMAAAAAAAAAAAAAIGoEnQEAAAAAAAAAAAAAUSPoDAAAAAAAAAAAAACIGkFnAAAAAAAAAAAAAEDUCDoDAAAAAAAAAAAAAKJG0BkAAAAAAAAAAAAAQNAZAAAAAAAAAAAAAJB4ZDoDAAAAAAAAAAAAAKJG0BkAAAAAAAAAAAAAEDWCzgAAAAAAAAAAAACAqBF0BgAAAAAAAAAAAABEjaAzAAAAAAAAAAAAACBqBJ0BAAAAAAAAAAAAAFEj6AwAAAAAAAAAAAAAiBpBZwAAAAAAAAAAAABA1Ag6AwAAAAAAAAAAAACiRtAZAAAAAAAAAAAAABA1gs4AAAAAAAAAAAAAgKgRdAYAAAAAAAAAAAAARI2gMwAAAAAAAAAAAADAovX/ACDzqwDkP41TAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -2241,7 +2241,9 @@ "identical between the two plots. The baseline error curve at the \"Control\" position, however, is visibly wider\n", "once `cluster_col` accounts for the fact that these 15 participants (not 45 independent pairs) are the real\n", "resampling unit — and at higher between-participant variance, or with a stronger effect of participant count, it\n", - "can extend beyond a `contrast_ylim` that comfortably fits the real contrasts." + "can extend beyond a `contrast_ylim` that comfortably fits the real contrasts. (The thin lines extending the\n", + "intervals in the right-hand plot are the small-sample expansion that `cluster_col` applies by default; see the\n", + "[Cluster-Robust Bootstrap tutorial](11-cluster_robust_bootstrap.html#few-clusters-the-small-sample-expansion).)" ] } ], diff --git a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb index 266bcd3a..bc603643 100644 --- a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb +++ b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb @@ -78,17 +78,17 @@ "text": [ "\r", "Compiling numba functions: 0%| | 0/13 [00:00" ] @@ -716,14 +716,21 @@ "method of Hesterberg (2015, *The American Statistician*, 69(4), 371-386). The bootstrap distribution\n", "itself is unchanged, and so is the half-violin in the plot, but each interval is read slightly further\n", "into its tails. The reading uses a t distribution whose degrees of freedom come from the number of\n", - "clusters. When clusters are nested within groups, or appear in only some groups, the degrees of\n", - "freedom of the smallest group of clusters are used, which errs on the side of caution. The bottom\n", - "row shows that this restores close to nominal coverage. Both the percentile and the\n", - "bias-corrected and accelerated intervals are expanded, as are those of the baseline error curve,\n", - "delta-delta and mini-meta analyses.\n", + "clusters. When clusters are nested within groups, or appear in only some groups, those groups of\n", + "clusters are resampled independently, and their degrees of freedom are combined with the\n", + "Welch-Satterthwaite approximation. The bottom row shows that this restores close to nominal\n", + "coverage. Both the percentile and the bias-corrected and accelerated intervals are expanded, as are\n", + "those of the baseline error curve, delta-delta and mini-meta analyses.\n", + "\n", + "Because the half-violin still shows the same bootstrap distribution, plots draw an expanded interval\n", + "in two parts, as in the right-hand panel of the figure above. The thick bar spans the unexpanded 95%\n", + "interval of the plotted distribution, and a thinner line continues it out to the expanded limits\n", + "(the bracketed values). The thin extension is the allowance for having few participants; its style\n", + "can be changed with `contrast_expanded_errorbar_kwargs` in `.plot()`.\n", "\n", "The reported confidence level stays at 95%. The level at which the bootstrap distribution was\n", - "actually read is reported alongside it, in the `ci_expanded` column of the results:" + "actually read is reported alongside it, in the `ci_expanded` column of the results, together with\n", + "the unexpanded limits drawn as the thick bar:" ] }, { @@ -758,6 +765,8 @@ " n_clusters\n", " ci\n", " ci_expanded\n", + " bca_low_unexpanded\n", + " bca_high_unexpanded\n", " bca_low\n", " bca_high\n", " \n", @@ -770,6 +779,8 @@ " 15\n", " 95\n", " 97.358565\n", + " -0.108557\n", + " 0.639317\n", " -0.184306\n", " 0.675824\n", " \n", @@ -778,8 +789,10 @@ "" ], "text/plain": [ - " control test n_clusters ci ci_expanded bca_low bca_high\n", - "0 Baseline Treatment 15 95 97.358565 -0.184306 0.675824" + " control test n_clusters ... bca_high_unexpanded bca_low bca_high\n", + "0 Baseline Treatment 15 ... 0.639317 -0.184306 0.675824\n", + "\n", + "[1 rows x 9 columns]" ] }, "execution_count": null, @@ -788,7 +801,8 @@ } ], "source": [ - "clustered.mean_diff.results[[\"control\", \"test\", \"n_clusters\", \"ci\", \"ci_expanded\", \"bca_low\", \"bca_high\"]]" + "clustered.mean_diff.results[[\"control\", \"test\", \"n_clusters\", \"ci\", \"ci_expanded\",\n", + " \"bca_low_unexpanded\", \"bca_high_unexpanded\", \"bca_low\", \"bca_high\"]]" ] }, { @@ -798,10 +812,10 @@ "source": [ "The expansion fades as the number of clusters grows: with 15 participants the interval is read at\n", "about the 97.4% level, with 30 at about 96.2%, and with 100 at about 95.4%. In simulations covering\n", - "paired and between-subject designs and every effect size DABEST offers, expanded intervals came close\n", - "to nominal coverage once there were at least 6 clusters in all and at least 4 in each\n", - "independently resampled group of clusters: for example 6 participants who each take part in every\n", - "condition, or 8 participants split between two conditions. With fewer, no bootstrap interval is\n", + "paired and between-subject designs and every effect size DABEST offers, expanded intervals came within\n", + "about 3 percentage points of nominal coverage once there were at least 6 clusters in all and at\n", + "least 4 in each independently resampled group of clusters: for example 6 participants who each take\n", + "part in every condition, or 8 participants split between two conditions. With fewer, no bootstrap interval is\n", "reliable: DABEST warns you, and the results are best treated as indicative. Because the expanded\n", "interval is read further into the tails of the bootstrap distribution, it is also worth increasing\n", "`resamples` (to 20000, say) when there are few clusters.\n", @@ -823,7 +837,8 @@ "- Ignoring clustering can lead to confidence intervals being estimated as too narrow.\n", "- With `cluster_col` set, intervals are also expanded for the number of clusters by default, which\n", " keeps their coverage close to nominal when there are few participants; the level actually read\n", - " is reported as `ci_expanded`, and `cluster_ci_expansion=False` turns this off.\n", + " is reported as `ci_expanded`, and `cluster_ci_expansion=False` turns this off. Plots draw the\n", + " expansion as a thinner line beyond the usual thick bar.\n", "- The point estimate (the mean difference itself) is unaffected; only the bootstrap confidence intervals change, because they are the parts of the analysis that depend on which observations are treated as independent.\n", "- The interval widens to reflect real between-participant variability that a cluster-naive bootstrap cannot account for. The example simulation above shows the naive interval can give a false sense of precision.\n", "- Permutation tests are similarly reshuffled at the cluster-level, yielding larger values than the cluster-naive approach.\n", From 3c146df854968f628040882df83cd6473cf734a3 Mon Sep 17 00:00:00 2001 From: Mike Lotinga Date: Mon, 28 Sep 2026 00:16:31 +0100 Subject: [PATCH 8/8] fix: extra gap between vertical plots Extra gap added to accommodate cluster sample size in plots needed to be rationalised. --- dabest/_modidx.py | 2 ++ dabest/misc_tools.py | 51 +++++++++++++++++++++-------- nbs/API/misc_tools.ipynb | 51 +++++++++++++++++++++-------- nbs/tests/test_cluster_bootstrap.py | 36 +++++++++++++++++--- 4 files changed, 110 insertions(+), 30 deletions(-) diff --git a/dabest/_modidx.py b/dabest/_modidx.py index ad68a511..58e1d9ac 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -117,6 +117,8 @@ 'dabest.forest_plot.load_plot_data': ('API/forest_plot.html#load_plot_data', 'dabest/forest_plot.py')}, 'dabest.misc_tools': { 'dabest.misc_tools._hspace_for_tick_labels': ( 'API/misc_tools.html#_hspace_for_tick_labels', 'dabest/misc_tools.py'), + 'dabest.misc_tools._tick_label_gap_inches': ( 'API/misc_tools.html#_tick_label_gap_inches', + 'dabest/misc_tools.py'), 'dabest.misc_tools.add_counts_to_ticks': ( 'API/misc_tools.html#add_counts_to_ticks', 'dabest/misc_tools.py'), 'dabest.misc_tools.color_picker': ('API/misc_tools.html#color_picker', 'dabest/misc_tools.py'), diff --git a/dabest/misc_tools.py b/dabest/misc_tools.py index d64001a1..deec82e1 100644 --- a/dabest/misc_tools.py +++ b/dabest/misc_tools.py @@ -700,6 +700,18 @@ def get_color_palette( return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors, plot_palette_raw, plot_palette_contrast, plot_palette_sankey) +def _tick_label_gap_inches(n_lines: int, fontsize) -> float: + """ + Vertical gap, in inches, that keeps `n_lines` of tick labels at `fontsize` + on the upper (raw data) axes clear of the lower (contrast) axes: the text, + plus room for the tick marks and a small margin. + """ + from matplotlib.font_manager import FontProperties + + size_pt = FontProperties(size=fontsize).get_size_in_points() + return (n_lines * 1.2 * size_pt + 14) / 72 + + def _hspace_for_tick_labels( n_lines: int, fontsize, @@ -711,13 +723,9 @@ def _hspace_for_tick_labels( tick labels on the upper (raw data) axes clear of the lower (contrast) axes. `available_height` is the height in inches shared by both axes and the gap - between them. The gap needed is `n_lines` of text at `fontsize`, plus room - for the tick marks and a small margin. Never returns less than `minimum`. + between them (see `_tick_label_gap_inches`). Never returns less than `minimum`. """ - from matplotlib.font_manager import FontProperties - - size_pt = FontProperties(size=fontsize).get_size_in_points() - needed = (n_lines * 1.2 * size_pt + 14) / 72 # inches + needed = _tick_label_gap_inches(n_lines, fontsize) # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h. remaining = max(available_height - needed, 0.25 * available_height) return max(minimum, 2 * needed / remaining) @@ -874,14 +882,31 @@ def initialize_fig( ) contrast_axes = axins + elif size_gap_to_labels: + # The contrast axes hangs a fixed distance below the raw data + # axes, sized to the tick labels, rather than a fraction of the + # axes' height: a layout engine that later resizes the raw data + # axes (e.g. with `figure.autolayout`) would otherwise stretch + # the gap along with it. + fig_height = fig.get_figheight() + available = (ax_position.y1 - ax_position.y0) * fig_height # inches + gap = max(min(_tick_label_gap_inches(n_label_lines, fontsize_rawxlabel), 0.75 * available), + h_space_cummings * available / (2 + h_space_cummings)) + plot_height = (available - gap) / 2 + axins = rawdata_axes.inset_axes( + [0, -1, 1, 1], + transform=rawdata_axes.transAxes + + matplotlib.transforms.ScaledTranslation(0, -gap, fig.dpi_scale_trans), + ) + rawdata_axes.set_position( + [ + ax_position.x0, + ax_position.y0 + (plot_height + gap) / fig_height, + (ax_position.x1 - ax_position.x0), + plot_height / fig_height, + ] + ) else: - if size_gap_to_labels: - h_space_cummings = _hspace_for_tick_labels( - n_label_lines, - fontsize_rawxlabel, - (ax_position.y1 - ax_position.y0) * fig.get_figheight(), - h_space_cummings, - ) axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1]) plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings) rawdata_axes.set_position( diff --git a/nbs/API/misc_tools.ipynb b/nbs/API/misc_tools.ipynb index 874a486c..99ce36bf 100644 --- a/nbs/API/misc_tools.ipynb +++ b/nbs/API/misc_tools.ipynb @@ -751,6 +751,18 @@ " return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors,\n", " plot_palette_raw, plot_palette_contrast, plot_palette_sankey)\n", "\n", + "def _tick_label_gap_inches(n_lines: int, fontsize) -> float:\n", + " \"\"\"\n", + " Vertical gap, in inches, that keeps `n_lines` of tick labels at `fontsize`\n", + " on the upper (raw data) axes clear of the lower (contrast) axes: the text,\n", + " plus room for the tick marks and a small margin.\n", + " \"\"\"\n", + " from matplotlib.font_manager import FontProperties\n", + "\n", + " size_pt = FontProperties(size=fontsize).get_size_in_points()\n", + " return (n_lines * 1.2 * size_pt + 14) / 72\n", + "\n", + "\n", "def _hspace_for_tick_labels(\n", " n_lines: int,\n", " fontsize,\n", @@ -762,13 +774,9 @@ " tick labels on the upper (raw data) axes clear of the lower (contrast) axes.\n", "\n", " `available_height` is the height in inches shared by both axes and the gap\n", - " between them. The gap needed is `n_lines` of text at `fontsize`, plus room\n", - " for the tick marks and a small margin. Never returns less than `minimum`.\n", + " between them (see `_tick_label_gap_inches`). Never returns less than `minimum`.\n", " \"\"\"\n", - " from matplotlib.font_manager import FontProperties\n", - "\n", - " size_pt = FontProperties(size=fontsize).get_size_in_points()\n", - " needed = (n_lines * 1.2 * size_pt + 14) / 72 # inches\n", + " needed = _tick_label_gap_inches(n_lines, fontsize)\n", " # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h.\n", " remaining = max(available_height - needed, 0.25 * available_height)\n", " return max(minimum, 2 * needed / remaining)\n", @@ -925,14 +933,31 @@ " )\n", "\n", " contrast_axes = axins\n", + " elif size_gap_to_labels:\n", + " # The contrast axes hangs a fixed distance below the raw data\n", + " # axes, sized to the tick labels, rather than a fraction of the\n", + " # axes' height: a layout engine that later resizes the raw data\n", + " # axes (e.g. with `figure.autolayout`) would otherwise stretch\n", + " # the gap along with it.\n", + " fig_height = fig.get_figheight()\n", + " available = (ax_position.y1 - ax_position.y0) * fig_height # inches\n", + " gap = max(min(_tick_label_gap_inches(n_label_lines, fontsize_rawxlabel), 0.75 * available),\n", + " h_space_cummings * available / (2 + h_space_cummings))\n", + " plot_height = (available - gap) / 2\n", + " axins = rawdata_axes.inset_axes(\n", + " [0, -1, 1, 1],\n", + " transform=rawdata_axes.transAxes\n", + " + matplotlib.transforms.ScaledTranslation(0, -gap, fig.dpi_scale_trans),\n", + " )\n", + " rawdata_axes.set_position(\n", + " [\n", + " ax_position.x0,\n", + " ax_position.y0 + (plot_height + gap) / fig_height,\n", + " (ax_position.x1 - ax_position.x0),\n", + " plot_height / fig_height,\n", + " ]\n", + " )\n", " else:\n", - " if size_gap_to_labels:\n", - " h_space_cummings = _hspace_for_tick_labels(\n", - " n_label_lines,\n", - " fontsize_rawxlabel,\n", - " (ax_position.y1 - ax_position.y0) * fig.get_figheight(),\n", - " h_space_cummings,\n", - " )\n", " axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1])\n", " plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings)\n", " rawdata_axes.set_position(\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py index bf297bd1..f03168d8 100644 --- a/nbs/tests/test_cluster_bootstrap.py +++ b/nbs/tests/test_cluster_bootstrap.py @@ -291,13 +291,14 @@ def gap(fig): clustered_gap = gap(clustered.mean_diff.plot(float_contrast=False)) assert clustered_gap > naive_gap - # Figures drawn into a user-supplied axes (the contrast axes is an inset). + # Figures drawn into a user-supplied axes (the contrast axes is an inset, + # placed when the figure is drawn). def inset_gap(dabest_obj): f, ax = plt.subplots() dabest_obj.mean_diff.plot(ax=ax, float_contrast=False) - raw = ax.get_position() - contrast = ax.contrast_axes.get_position() - return raw.y0 - contrast.y1 + f.canvas.draw() + renderer = f.canvas.get_renderer() + return ax.get_window_extent(renderer).y0 - ax.contrast_axes.get_window_extent(renderer).y1 assert inset_gap(clustered) > inset_gap(naive) @@ -345,6 +346,33 @@ def test_cluster_labels_clear_the_contrast_axes(): plt.close("all") +def test_gap_for_cluster_labels_survives_autolayout(naive, clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + + def gap_points(dabest_obj): + """Points between the raw data axes and the contrast axes, and below the tick labels.""" + f, ax = plt.subplots(figsize=(6.5, 3.5)) + dabest_obj.mean_diff.plot(ax=ax, float_contrast=False) + clearance = _label_clearance(ax, ax.contrast_axes) + renderer = f.canvas.get_renderer() + gap = ax.get_window_extent(renderer).y0 - ax.contrast_axes.get_window_extent(renderer).y1 + plt.close("all") + return gap * 72 / f.dpi, clearance * 72 / f.dpi + + # `figure.autolayout` resizes the user's axes after dabest has laid it out; + # the gap for the cluster labels must not be stretched along with it. + plain_gap, plain_clearance = gap_points(clustered) + with matplotlib.rc_context({"figure.autolayout": True}): + auto_gap, auto_clearance = gap_points(clustered) + naive_gap, _ = gap_points(naive) + assert auto_gap == pytest.approx(plain_gap, abs=1) + assert 0 < auto_clearance < 20 and 0 < plain_clearance < 20 + assert auto_gap < 1.5 * naive_gap + + # --------------------------------------------------------------------------- # Validation # ---------------------------------------------------------------------------