diff --git a/causalpy/pymc_experiments.py b/causalpy/pymc_experiments.py index 1c07e189..15271505 100644 --- a/causalpy/pymc_experiments.py +++ b/causalpy/pymc_experiments.py @@ -12,7 +12,7 @@ """ import warnings # noqa: I001 -from typing import Union +from typing import Union, Dict import arviz as az import matplotlib.pyplot as plt @@ -26,7 +26,7 @@ from causalpy.custom_exceptions import BadIndexException from causalpy.custom_exceptions import DataException, FormulaException from causalpy.plot_utils import plot_xY -from causalpy.utils import _is_variable_dummy_coded +from causalpy.utils import _is_variable_dummy_coded, compute_bayesian_tail_probability LEGEND_FONT_SIZE = 12 az.style.use("arviz-darkgrid") @@ -330,15 +330,290 @@ def plot(self, counterfactual_label="Counterfactual", **kwargs): return fig, ax - def summary(self) -> None: + def _summary_intervention(self, alpha: float = 0.05, **kwargs) -> pd.DataFrame: + """ + Calculate and summarize the intervention analysis results in a DataFrame format. + + This function performs cumulative and mean calculations on the posterior predictive distributions, + computes Bayesian tail probabilities, posterior estimations, causal effects, and confidence intervals. + It optionally applies corrections to the cumulative and mean calculations. + + Parameters: + - alpha (float, optional): The significance level for confidence interval calculations. Default is 0.05. + - kwargs (Dict[str, Any], optional): Additional keyword arguments. + - "correction" (bool or Dict[str, float]): If True, applies predefined corrections to cumulative and mean results. + If a dictionary, the corrections for 'cumulative' and 'mean' should be provided. Default is False. + + Returns: + - pd.DataFrame: A DataFrame where each row represents different statistical measures such as + Bayesian tail probability, posterior estimation, causal effect, and confidence intervals for cumulative and mean results. + """ + correction = kwargs.get("correction", False) + + results = {} + ci = (alpha * 100) / 2 + + # Cumulative calculations + cumulative_results = self.post_y.sum() + _mu_samples_cumulative = ( + self.post_pred["posterior_predictive"] + .mu.stack(sample=("chain", "draw")) + .sum("obs_ind") + ) + + # Mean calculations + mean_results = self.post_y.mean() + _mu_samples_mean = ( + self.post_pred["posterior_predictive"] + .mu.stack(sample=("chain", "draw")) + .mean("obs_ind") + ) + + if not isinstance(correction, bool): + _mu_samples_cumulative += correction["cumulative"] + _mu_samples_mean += correction["mean"] + + # Bayesian Tail Probability + results["bayesian_tail_probability"] = { + "cumulative": compute_bayesian_tail_probability( + posterior=_mu_samples_cumulative, x=cumulative_results + ), + "mean": compute_bayesian_tail_probability( + posterior=_mu_samples_mean, x=mean_results + ), + } + + # Posterior Mean + results["posterior_estimation"] = { + "cumulative": np.mean(_mu_samples_cumulative.values), + "mean": np.mean(_mu_samples_mean.values), + } + + results["results"] = {"cumulative": cumulative_results, "mean": mean_results} + + # Causal Effect + results["causal_effect"] = { + "cumulative": cumulative_results + - results["posterior_estimation"]["cumulative"], + "mean": mean_results - results["posterior_estimation"]["mean"], + } + + # Confidence Intervals + results["ci"] = { + "cumulative": [ + np.percentile(_mu_samples_cumulative, ci), + np.percentile(_mu_samples_cumulative, 100 - ci), + ], + "mean": [ + np.percentile(_mu_samples_mean, ci), + np.percentile(_mu_samples_mean, 100 - ci), + ], + } + + # Convert to DataFrame + results_df = pd.DataFrame(results) + + return results_df + + def summary(self, version="coefficients", **kwargs) -> Union[None, pd.DataFrame]: """ Print text output summarising the results """ + if version == "coefficients": + print(f"{self.expt_type:=^80}") + print(f"Formula: {self.formula}") + # TODO: extra experiment specific outputs here + self.print_coefficients() + elif version == "intervention": + return self._summary_intervention(**kwargs) + + def _power_estimation(self, alpha: float = 0.05, correction: bool = False) -> Dict: + """ + Estimate the statistical power of an intervention based on cumulative and mean results. - print(f"{self.expt_type:=^80}") - print(f"Formula: {self.formula}") - # TODO: extra experiment specific outputs here - self.print_coefficients() + This function calculates posterior estimates, systematic differences, confidence intervals, and + minimum detectable effects (MDE) for both cumulative and mean measures. It can apply corrections to + account for systematic differences in the data. + + Parameters: + - alpha (float, optional): The significance level for confidence interval calculations. Default is 0.05. + - correction (bool, optional): If True, applies corrections to account for systematic differences in + cumulative and mean calculations. Default is False. + + Returns: + - Dict: A dictionary containing key statistical measures such as posterior estimation, + systematic differences, confidence intervals, and posterior MDE for both cumulative and mean results. + """ + results = {} + ci = (alpha * 100) / 2 + + # Cumulative calculations + cumulative_results = self.post_y.sum() + _mu_samples_cumulative = ( + self.post_pred["posterior_predictive"] + .mu.stack(sample=("chain", "draw")) + .sum("obs_ind") + ) + + # Mean calculations + mean_results = self.post_y.mean() + _mu_samples_mean = ( + self.post_pred["posterior_predictive"] + .mu.stack(sample=("chain", "draw")) + .mean("obs_ind") + ) + + # Posterior Mean + results["posterior_estimation"] = { + "cumulative": np.mean(_mu_samples_cumulative.values), + "mean": np.mean(_mu_samples_mean.values), + } + + results["results"] = {"cumulative": cumulative_results, "mean": mean_results} + + results["_systematic_differences"] = { + "cumulative": results["results"]["cumulative"] + - results["posterior_estimation"]["cumulative"], + "mean": results["results"]["mean"] + - results["posterior_estimation"]["mean"], + } + + if correction: + _mu_samples_cumulative += results["_systematic_differences"]["cumulative"] + _mu_samples_mean += results["_systematic_differences"]["mean"] + + results["ci"] = { + "cumulative": [ + np.percentile(_mu_samples_cumulative, ci), + np.percentile(_mu_samples_cumulative, 100 - ci), + ], + "mean": [ + np.percentile(_mu_samples_mean, ci), + np.percentile(_mu_samples_mean, 100 - ci), + ], + } + + cumulative_upper_mde = ( + results["ci"]["cumulative"][1] + - results["posterior_estimation"]["cumulative"] + ) + cumulative_lower_mde = ( + results["posterior_estimation"]["cumulative"] + - results["ci"]["cumulative"][0] + ) + + mean_upper_mde = ( + results["ci"]["mean"][1] - results["posterior_estimation"]["mean"] + ) + mean_lower_mde = ( + results["posterior_estimation"]["mean"] - results["ci"]["mean"][0] + ) + + results["posterior_mde"] = { + "cumulative": (cumulative_upper_mde + cumulative_lower_mde) / 2, + "mean": (mean_upper_mde + mean_lower_mde) / 2, + } + return results + + def power_summary( + self, alpha: float = 0.05, correction: bool = False + ) -> pd.DataFrame: + """ + Summarize the power estimation results in a DataFrame format. + + This function calls '_power_estimation' to perform power estimation calculations and then + converts the resulting dictionary into a pandas DataFrame for easier analysis and visualization. + + Parameters: + - alpha (float, optional): The significance level for confidence interval calculations used in power estimation. Default is 0.05. + - correction (bool, optional): Indicates whether to apply corrections in the power estimation process. Default is False. + + Returns: + - pd.DataFrame: A DataFrame representing the power estimation results, including posterior estimations, + systematic differences, confidence intervals, and posterior MDE for cumulative and mean results. + """ + return pd.DataFrame(self._power_estimation(alpha=alpha, correction=correction)) + + def power_plot(self, alpha: float = 0.05, correction: bool = False) -> plt.Figure: + """ + Generate and return a figure containing plots that visualize power estimation results. + + This function creates a two-panel plot (for mean and cumulative measures) to visualize the posterior distributions + along with the confidence intervals, real mean, and posterior mean values. It allows for adjustments based on + systematic differences if the correction is applied. + + Parameters: + - alpha (float, optional): The significance level for confidence interval calculations used in power estimation. Default is 0.05. + - correction (bool, optional): Indicates whether to apply corrections for systematic differences in the plotting process. Default is False. + + Returns: + - plt.Figure: A matplotlib figure object containing the plots. + """ + _estimates = self._power_estimation(alpha=alpha, correction=correction) + + fig, axs = plt.subplots(1, 2, figsize=(20, 6)) # Two subplots side by side + + # Adjustments for Mean and Cumulative plots + for i, key in enumerate(["mean", "cumulative"]): + _mu_samples = self.post_pred["posterior_predictive"].mu.stack( + sample=("chain", "draw") + ) + if key == "mean": + _mu_samples = _mu_samples.mean("obs_ind") + elif key == "cumulative": + _mu_samples = _mu_samples.sum("obs_ind") + + if correction: + _mu_samples += _estimates["_systematic_differences"][key] + + # Histogram and KDE + sns.histplot( + _mu_samples, + bins=30, + kde=True, + ax=axs[i], + color="C0", + stat="density", + alpha=0.6, + ) + kde_x, kde_y = ( + sns.kdeplot(_mu_samples, color="C1", fill=True, ax=axs[i]) + .get_lines()[0] + .get_data() + ) + + # Adjust y-limits based on max density + max_density = max(kde_y) + axs[i].set_ylim(0, max_density + 0.05 * max_density) # Adding 5% buffer + + # Fill between for the percentile interval + axs[i].fill_betweenx( + y=np.linspace(0, max_density + 0.05 * max_density, 100), + x1=_estimates["ci"][key][0], + x2=_estimates["ci"][key][1], + color="C0", + alpha=0.3, + label="C.I", + ) + + # Vertical lines for the means + axs[i].axvline( + _estimates["results"][key], color="C3", linestyle="-", label="Real Mean" + ) + if not correction: + axs[i].axvline( + _estimates["posterior_estimation"][key], + color="C4", + linestyle="--", + label="Posterior Mean", + ) + + axs[i].set_title(f"Posterior of mu ({key.capitalize()})") + axs[i].set_xlabel("mu") + axs[i].set_ylabel("Density") + axs[i].legend() + + return fig class InterruptedTimeSeries(PrePostFit): diff --git a/causalpy/utils.py b/causalpy/utils.py index 850cc0ab..b255980a 100644 --- a/causalpy/utils.py +++ b/causalpy/utils.py @@ -1,7 +1,9 @@ """ Utility functions """ +import numpy as np import pandas as pd +from scipy.stats import norm def _is_variable_dummy_coded(series: pd.Series) -> bool: @@ -13,3 +15,29 @@ def _is_variable_dummy_coded(series: pd.Series) -> bool: def _series_has_2_levels(series: pd.Series) -> bool: """Check that the variable in the provided Series has 2 levels""" return len(pd.Categorical(series).categories) == 2 + + +def compute_bayesian_tail_probability(posterior, x) -> float: + """ + Calculate the probability of a given value being in a distribution defined by the posterior, + + Args: + - data: a list or array-like object containing the data to define the distribution + - x: a numeric value for which to calculate the probability of being in the distribution + + Returns: + - prob: a numeric value representing the probability of x being in the distribution + """ + lower_bound, upper_bound = min(posterior), max(posterior) + mean, std = np.mean(posterior), np.std(posterior) + + cdf_lower = norm.cdf(lower_bound, mean, std) + cdf_upper = 1 - norm.cdf(upper_bound, mean, std) + cdf_x = norm.cdf(x, mean, std) + + if cdf_x <= 0.5: + probability = 2 * (cdf_x - cdf_lower) / (1 - cdf_lower - cdf_upper) + else: + probability = 2 * (1 - cdf_x + cdf_lower) / (1 - cdf_lower - cdf_upper) + + return abs(round(probability, 2)) diff --git a/docs/source/_static/interrogate_badge.svg b/docs/source/_static/interrogate_badge.svg index cc0bc3d6..2cf9af2b 100644 --- a/docs/source/_static/interrogate_badge.svg +++ b/docs/source/_static/interrogate_badge.svg @@ -1,5 +1,5 @@ - interrogate: 96.9% + interrogate: 97.0% @@ -12,8 +12,8 @@ interrogate interrogate - 96.9% - 96.9% + 97.0% + 97.0% diff --git a/docs/source/notebooks/Power Analysis.ipynb b/docs/source/notebooks/Power Analysis.ipynb new file mode 100644 index 00000000..fc01dbf6 --- /dev/null +++ b/docs/source/notebooks/Power Analysis.ipynb @@ -0,0 +1,1410 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e57b43b7", + "metadata": {}, + "source": [ + "# Introduction to Bayesian Power Analysis\n", + "\n", + "This notebook is dedicated to exploring and implementing Bayesian Power Analysis in the context of `causalpy`.\n", + "\n", + "The aim here is to examine the subtleties of how Bayesian Power Analysis can provide a more robust framework for experimenters, particularly when dealing with the inherent uncertainties of quasi-experiments. We will explore practical applications, comprehend the underlying principles, and discuss how this approach can improve our decision-making process in selecting models and designing experiments." + ] + }, + { + "cell_type": "markdown", + "id": "0d26c308", + "metadata": {}, + "source": [ + "## Getting Started\n", + "\n", + "Before diving into the implementation, let's set up our working environment. This setup ensures we have all the necessary tools at our disposal for conducting Bayesian Power Analysis using `causalpy`. \n", + "\n", + "1. **Installation**: First, we'll install the `causalpy` package, which is essential for our analysis. Simply run `%pip install causalpy` in your Jupyter notebook.\n", + "\n", + "2. **Importing Libraries**: Next, we import key libraries:\n", + " - `arviz` and `causalpy` for statistical modeling and analysis.\n", + " - `matplotlib.pyplot` and `seaborn` for data visualization.\n", + "\n", + "3. **Environment Setup**:\n", + " - We use `%load_ext autoreload` and `%autoreload 2` for automatic reloading of modules before executing a new line of code, which is helpful during development.\n", + " - The `seed` variable is set to ensure reproducibility of our results.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc05e9db", + "metadata": {}, + "outputs": [], + "source": [ + "%pip install causalpy" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "873a3578", + "metadata": {}, + "outputs": [], + "source": [ + "import arviz as az\n", + "import causalpy as cp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6c59e926", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6adee44a", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "622415d4", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import norm" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bf91ea16", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "# %config InlineBackend.figure_format = 'svg'\n", + "seed = 42" + ] + }, + { + "cell_type": "markdown", + "id": "d3151407", + "metadata": {}, + "source": [ + "## Loading Data\n", + "\n", + "The dataset is loaded using `causalpy`'s built-in data loading functionality, which provides a suitable dataset for our quasi-experimental design.\n", + "\n", + "Once we've loaded the data, our first step is to identify the point in time where the treatment or intervention is expected to occur. In this case, we've set a specific time (`treatment_time`) to represent when the intervention is expected to take place. Following this, we filter the dataset to exclude any data beyond this treatment time to reflect the pre-intervention period, which aligns with the realistic scenario of not having post-intervention data available during the planning phase of an experiment.\n", + "\n", + "By focusing on the pre-intervention period, we aim to understand the dataset's characteristics and establish a baseline to measure the expected effects of our intervention. This baseline is crucial for determining the magnitude of effect required to be detectable in our framework." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a4508a65", + "metadata": {}, + "outputs": [], + "source": [ + "df = cp.load_data(\"sc\")\n", + "treatment_time = 70" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5a687a4c", + "metadata": {}, + "outputs": [], + "source": [ + "power_df = df[:70].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cc5be440", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 70 entries, 0 to 69\n", + "Data columns (total 10 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 a 70 non-null float64\n", + " 1 b 70 non-null float64\n", + " 2 c 70 non-null float64\n", + " 3 d 70 non-null float64\n", + " 4 e 70 non-null float64\n", + " 5 f 70 non-null float64\n", + " 6 g 70 non-null float64\n", + " 7 counterfactual 70 non-null float64\n", + " 8 causal effect 70 non-null float64\n", + " 9 actual 70 non-null float64\n", + "dtypes: float64(10)\n", + "memory usage: 5.6 KB\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
abcdefgcounterfactualcausal effectactual
00.7932341.277264-0.055407-0.7915351.0751700.817384-2.6075280.144888-0.00.398287
11.8418981.185068-0.221424-1.4307721.0783030.890110-3.1080990.601862-0.00.491644
22.8671021.922957-0.153303-1.4290271.4320571.455499-3.1491041.060285-0.01.232330
32.8162552.4245580.252894-1.2605271.9389602.088586-3.5632011.520801-0.01.672995
43.8652082.3586500.311572-2.3934381.9777162.752152-3.5159911.983661-0.01.775940
\n", + "
" + ], + "text/plain": [ + " a b c d e f g \\\n", + "0 0.793234 1.277264 -0.055407 -0.791535 1.075170 0.817384 -2.607528 \n", + "1 1.841898 1.185068 -0.221424 -1.430772 1.078303 0.890110 -3.108099 \n", + "2 2.867102 1.922957 -0.153303 -1.429027 1.432057 1.455499 -3.149104 \n", + "3 2.816255 2.424558 0.252894 -1.260527 1.938960 2.088586 -3.563201 \n", + "4 3.865208 2.358650 0.311572 -2.393438 1.977716 2.752152 -3.515991 \n", + "\n", + " counterfactual causal effect actual \n", + "0 0.144888 -0.0 0.398287 \n", + "1 0.601862 -0.0 0.491644 \n", + "2 1.060285 -0.0 1.232330 \n", + "3 1.520801 -0.0 1.672995 \n", + "4 1.983661 -0.0 1.775940 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "power_df.info()\n", + "power_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "9983a6a8", + "metadata": {}, + "source": [ + "## Creating the Model for Power Analysis\n", + "\n", + "Let's move on to creating our model using the `causalpy` library. Our goal is to predict the period right before the intervention occurs, and to do so, we use a specific time point as a reference for our predictions. The idea is to capture the true nature of the data before any intervention effects come into play.\n", + "\n", + "For our purposes, the Synthetic Control method from `causalpy` fits the bill perfectly. If our model is well-calibrated, we should see this difference approach zero, indicating that we have accurately captured the pre-intervention scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "58bf5b47", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [beta, sigma]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:01<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 1 seconds.\n", + "Sampling: [beta, sigma, y_hat]\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "result = cp.pymc_experiments.SyntheticControl(\n", + " power_df,\n", + " 60,\n", + " formula=\"actual ~ 0 + a + b + c\",\n", + " model=cp.pymc_models.WeightedSumFitter(\n", + " sample_kwargs={\"target_accept\": 0.95, \"random_seed\": seed}\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "95aa16e7", + "metadata": {}, + "source": [ + "## Evaluating the model\n", + "\n", + "Essentially, if the model accurately represents our reality, and we'll base our decision on the model intervals. By grasping these intervals, we can ascertain how significant an effect must be. In turn, this will allow us to determine the size of the effect that will be considered significant.\n", + "\n", + "In order to ensure that our model isn't overestimating the positive or negative effects, it's important to expect that the errors will be symmetrically distributed around zero. This means that the true and predicted means are aligned. If the model is failing systematically towards either the positive or negative sides, it indicates that it's not accurately capturing the full range of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "df967213", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = result.plot(plot_predictors=True)" + ] + }, + { + "cell_type": "markdown", + "id": "f19a0ae1", + "metadata": {}, + "source": [ + "In this case, we can see that the model based on these regressors is systematically failing and although there is still no intervention, it is capturing an effect. But how big is this effect? It seems relevant from the perspective of the images but how to quantify it?" + ] + }, + { + "cell_type": "markdown", + "id": "a655a236", + "metadata": {}, + "source": [ + "## Power Analysis\n", + "\n", + "We can employ the `power_summary` function to observe the actual cumulative value during the test period and compare it with the projected cumulative outcomes for that same period. Ideally, we should expect errors to be near zero; if they are significantly negative or positive, our model will tend to err consistently in one direction.\n", + "\n", + "Furthermore, we can view the quantiles and determine the minimum detectable effect (MDE) required for the effect to be within those quantiles. Essentially, if your action produces an incremental value that is equal to or greater than the MDE, then your effect will be outside the quantile range and could be considered substantial.\n", + "\n", + "The alpha parameter plays a crucial role in deciding the cumulative confidence interval (CCI). In simple words, the alpha value determines the width of the confidence interval. For instance, if you set an alpha value of `0.1`, it implies that the interval is **90%**. Similarly, an alpha value of `0.05` corresponds to a **95%** interval, and so forth." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5fd7b620", + "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", + "
posterior_estimationresults_systematic_differencesciposterior_mde
cumulative105.092116102.671567-2.42055[103.4161045391502, 106.72158776225118]1.652742
mean11.67690211.407952-0.26895[11.4906782821278, 11.857954195805686]0.183638
\n", + "
" + ], + "text/plain": [ + " posterior_estimation results _systematic_differences \\\n", + "cumulative 105.092116 102.671567 -2.42055 \n", + "mean 11.676902 11.407952 -0.26895 \n", + "\n", + " ci posterior_mde \n", + "cumulative [103.4161045391502, 106.72158776225118] 1.652742 \n", + "mean [11.4906782821278, 11.857954195805686] 0.183638 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.power_summary(alpha=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "f044d6b9", + "metadata": {}, + "source": [ + "We could appreciate this better in an image, and for that we can use the `power_plot` function. This would visually display the information presented by `power_summary`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "db112259", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = result.power_plot(alpha=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "068bb8d2", + "metadata": {}, + "source": [ + "It's evident that the model fails to accurately represent reality. Even during periods without direct actions affecting the target, the actual values significantly deviate from the model's predicted distribution.\n", + "\n", + "By using the `summary` function and specifying the version, we can generate an output that treats the data as if it were subjected to an intervention. This approach allows for a more comprehensive analysis of the results. In this scenario, the likelihood of our observed value falling within the model's posterior distribution is extremely low. These findings indicate that our model erroneously attributes significance to this particular time frame." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1307b896", + "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", + "
bayesian_tail_probabilityposterior_estimationresultscausal_effectci
cumulative0.01105.092116102.671567-2.42055[103.4161045391502, 106.72158776225118]
mean0.0111.67690211.407952-0.26895[11.4906782821278, 11.857954195805686]
\n", + "
" + ], + "text/plain": [ + " bayesian_tail_probability posterior_estimation results \\\n", + "cumulative 0.01 105.092116 102.671567 \n", + "mean 0.01 11.676902 11.407952 \n", + "\n", + " causal_effect ci \n", + "cumulative -2.42055 [103.4161045391502, 106.72158776225118] \n", + "mean -0.26895 [11.4906782821278, 11.857954195805686] " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.summary(version=\"intervention\", alpha=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "215fd3bc", + "metadata": {}, + "source": [ + "---\n", + "**note:** The `summary` function provides insights into both cumulative and average results. Under normal circumstances, it helps in understanding the absolute cumulative and average estimations and effects, along with their respective confidence intervals.\n", + "\n", + "---\n", + "\n", + "## Update the model\n", + "\n", + "Following the shortcomings of our previous model, we have incorporated new regressors to improve its efficacy. These additional features are instrumental in assessing whether the updated model achieves greater accuracy and precision in mirroring reality. This enhancement is crucial for more accurately estimating experimental outcomes." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a7ff64e4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [beta, sigma]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:12<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 12 seconds.\n", + "Sampling: [beta, sigma, y_hat]\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "result = cp.pymc_experiments.SyntheticControl(\n", + " power_df,\n", + " 60,\n", + " formula=\"actual ~ 0 + a + b + c + d + e + f + g\",\n", + " model=cp.pymc_models.WeightedSumFitter(\n", + " sample_kwargs={\"target_accept\": 0.95, \"random_seed\": seed}\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a71d97a0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = result.plot(plot_predictors=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c0911b46", + "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", + "
posterior_estimationresults_systematic_differencesciposterior_mde
cumulative102.183179102.6715670.488388[100.86512281884075, 103.53391799343954]1.334398
mean11.35368711.4079520.054265[11.207235868760083, 11.503768665937729]0.148266
\n", + "
" + ], + "text/plain": [ + " posterior_estimation results _systematic_differences \\\n", + "cumulative 102.183179 102.671567 0.488388 \n", + "mean 11.353687 11.407952 0.054265 \n", + "\n", + " ci posterior_mde \n", + "cumulative [100.86512281884075, 103.53391799343954] 1.334398 \n", + "mean [11.207235868760083, 11.503768665937729] 0.148266 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.power_summary(alpha=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0a82fb59", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = result.power_plot(alpha=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "293aab40", + "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", + "
bayesian_tail_probabilityposterior_estimationresultscausal_effectci
cumulative0.55102.183179102.6715670.488388[100.86512281884075, 103.53391799343954]
mean0.5511.35368711.4079520.054265[11.207235868760083, 11.503768665937729]
\n", + "
" + ], + "text/plain": [ + " bayesian_tail_probability posterior_estimation results \\\n", + "cumulative 0.55 102.183179 102.671567 \n", + "mean 0.55 11.353687 11.407952 \n", + "\n", + " causal_effect ci \n", + "cumulative 0.488388 [100.86512281884075, 103.53391799343954] \n", + "mean 0.054265 [11.207235868760083, 11.503768665937729] " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.summary(version=\"intervention\", alpha=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "5124e0d3", + "metadata": {}, + "source": [ + "This model is outperforming its predecessor significantly. We now observe that the actual value falls within the range estimated by our model. However, there's still a noticeable discrepancy between the estimated total value and the actual one. As previously mentioned, this suggests that we might be overestimating or underestimating certain effects on one side of the distributions.\n", + "\n", + "This becomes apparent when we examine the Bayesian Tail Probability using the `summary` function once more. We now observe a significantly higher value, which is logical. If the actual value is equal to the mean, the probability should be 1. This implies that obtaining that specific value is the most probable outcome according to the posterior distribution.\n", + "\n", + "### Estimation Bias\n", + "\n", + "**Consider this scenario**: If our model exhibits a positive or negative bias, we can recenter our data within the distribution to gauge what the Minimum Detectable Effect (MDE) would be in the absence of this bias. You can apply this bias correction using either the `power_summary` or `power_plot` functions. This adjustment will allow you to observe how the interval of estimation changes.\n", + "\n", + "Essentially, we're implementing a correction to shift our posterior distribution, envisioning a scenario where our model predicts reality with perfect accuracy. This **approach assumes that the same estimation bias present during the model's development will persist throughout the intervention**. While not guaranteed, this is a reasonable assumption, especially considering that the **power test period should closely mirror the actual intervention**, ideally occurring just a few days prior." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1f58a2c4", + "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", + "
posterior_estimationresults_systematic_differencesciposterior_mde
cumulative102.183179102.6715670.488388[101.35351034448509, 104.02230551908389]1.334398
mean11.35368711.4079520.054265[11.261501149387234, 11.55803394656488]0.148266
\n", + "
" + ], + "text/plain": [ + " posterior_estimation results _systematic_differences \\\n", + "cumulative 102.183179 102.671567 0.488388 \n", + "mean 11.353687 11.407952 0.054265 \n", + "\n", + " ci posterior_mde \n", + "cumulative [101.35351034448509, 104.02230551908389] 1.334398 \n", + "mean [11.261501149387234, 11.55803394656488] 0.148266 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "power_correction=result.power_summary(alpha=0.1, correction=True)\n", + "power_correction" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "122ed5f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = result.power_plot(alpha=0.1, correction=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e88e304b", + "metadata": {}, + "source": [ + "With the recent adjustments, our intervals have shifted to the right, aligning the mean estimation with the actual value. This alignment is why the estimation is not visible on the plot. However, it's crucial to acknowledge the real uncertainty that we should account for. The intervals have moved from a range of (100 - 103) to (101 - 104) at the cumulative distribution, indicating the need for an additional unit on each side.\n", + "\n", + "The MDE remains unchanged because the sigma (standard deviation) is the same for our posterior. However, since the absolute value has shifted, we understand the uncertanty on a model without biases. We should apply this correction during the experimentation period. This adjustment will enable us to observe the probable effect more accurately, devoid of any biases from the model's estimation.\n", + "\n", + "## Running our experiment\n", + "\n", + "Having identified which model is most appropriate, we can now proceed with our experiment using the best-suited model. Therefore, we will conduct the experiment during the treatment period, utilizing the complete dataset, now that we have access to all the necessary data." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7d8ae5fb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [beta, sigma]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:10<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 10 seconds.\n", + "Sampling: [beta, sigma, y_hat]\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n", + "/opt/homebrew/anaconda3/lib/python3.10/site-packages/pymc/model/core.py:568: FutureWarning: Model.model property is deprecated. Just use Model.\n", + " warnings.warn(\"Model.model property is deprecated. Just use Model.\", FutureWarning)\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "result = cp.pymc_experiments.SyntheticControl(\n", + " df,\n", + " treatment_time,\n", + " formula=\"actual ~ 0 + a + b + c + d + e + f + g\",\n", + " model=cp.pymc_models.WeightedSumFitter(\n", + " sample_kwargs={\"target_accept\": 0.95, \"random_seed\": seed}\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5bd105fb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAscAAAMrCAYAAAClBz9jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU5fbA8e/2bEk2PfROKNKLoGBDEFRUwC4CCihgQSzYr3q9/hD0KihiI6AXbKCABRQEvaJYUJpSxEIngfRets7vj2TmZpNNSEIacD7Ps4+4OzP7zsxm98w75z2vTlEUBSGEEEIIIQT6hm6AEEIIIYQQjYUEx0IIIYQQQpSQ4FgIIYQQQogSEhwLIYQQQghRQoJjIYQQQgghSkhwLIQQQgghRAkJjoUQQgghhCghwbEQQgghhBAlJDgWQgghhBCihATHQgghhBBClJDgWAghhBBCiBISHAshhBBCCFFCgmMhhBBCCCFKSHAshBBCCCFECQmOhRBCCCGEKCHBsRBCCCGEECUkOBZCCCGEEKKEBMdCCCGEEEKUkOBYCCGEEEKIEhIcCyGEEEIIUUKCYyGEEEIIIUpIcCyEEEIIIUQJCY6FEEIIIYQoIcGxEEIIIYQQJSQ4FkIIIYQQooQEx0IIIYQQQpSQ4FgIIYQQQogSEhwLIYQQQghRQoJjIYQQQgghSkhwLIQQQgghRAkJjoUQQgghhCghwbEQQgghhBAlJDgWQgghhBCihATHQgghhBBClJDgWAghhBBCiBISHAshhBBCCFFCgmMhhBBCCCFKSHAshBBCCCFECWNDN0AIIYQQp6e1a9fy2WefsXv3bjIzM2nRogVXX30148aNw2QyNXTzhAhKpyiK0tCNEEIIIcTp57rrrqNJkyYMGzaMmJgYtm/fzmuvvcall17KnDlzGrp5QgQlwbEQQggh6kRGRgaRkZEBz7366qu89NJLfP/990RHRzdQy4SomOQcCyGqbciQIXTq1ImjR482dFNEKXJeTi1nwvkqGxgDnHXWWQCkpKTUd3OEqBLJORaiERgyZAiJiYkBz1ksFmJjY+nfvz8TJ06kY8eODdS6+vH222+Tm5vLhAkTCAsLa+jmNDqny/EJ9lkHsNlstGjRggsvvJCJEycSERHRAK0TwaxZs4b77ruv3PMOh4POnTtzww03cMUVV1R5e1u3bsVkMtGqVavabCYAGzdu5K233mLPnj243W7atm3LmDFjGDt2LHp99fsDU1NTWbhwId988w3Hjh3DZrPRrVs3brnlFs4777xK101PTychIYFvv/2Wo0eP4vf7iYuL45xzzmHy5Mm0bt26Sm2YO3cur7/+OgD33HMPd9xxR7X3Q1SPBMdCNCJt2rTRelpyc3M5ePAgK1euZPXq1bz00ksMGTKkgVtYrGXLlpjN5lodULNkyRISExMZPXr0KR381ZWqHJ+6OC91pfRnXVEUUlJS+PPPP/nzzz/55JNPeO+992jRokUDt7JunSrn6/fffwcgJiaGli1bAuByuTh48CBbtmxhy5YtHDhwgOnTp59wW/v27WPJkiVcf/31OByOWm3nm2++yQsvvAAUH1ubzcbevXt55pln+OGHH1iwYEG1AuQ//viDiRMnkpaWhtlspmPHjuTl5bFp0yY2bdrE/fffz+233x503f3793PzzTeTnp6OyWSiRYsWmEwmDh06xPLly/nss8948803Ofvssyttw759+1i0aFHVD4KoHYoQosFddNFFSnx8vLJixYqA51NTU5VbbrlFiY+PV84++2wlLy+vgVpY99RjcOTIkYZuSqN0uhyfij7riqIou3fvVgYPHqzEx8cr06dPb4DWiWAmTZqkxMfHK2+++WbA87m5ucrUqVOV+Ph45ayzzlLS09Mr3U5GRoYyfPhwZeTIkUp+fn6ttnHbtm1Kp06dlM6dOyufffaZ9vzvv/+unHvuuUp8fLySkJBQ5e15PB7lkksuUeLj45Wbb745YN9++OEHpXfv3kqnTp2Un3/+Oej6EyZMUOLj45UbbrhBOXbsmPZ8RkaGdsyGDBmi+P3+Ctvg9/uVm266SenVq5cyfvx4JT4+XlmwYEGV90HUnOQcC9GIRUdH89xzz2E2m8nKyuKHH35o6CYJUWe6du3K1KlTAfjxxx8buDVCtXfvXgDi4+MDnnc4HDz66KMAeDwedu7cWeE28vPzuf3223G73SQkJGCz2Wq1ja+99hqKonDttdcycuRI7fnOnTvz8MMPA8U9yx6Pp0rb++abbzh48CBms5nZs2cH5E6fc845TJ06FUVReOWVV8qtW1hYyObNmwF46qmnaNKkifZaREQEs2fPRqfTcfToUfbv319hGz766CO2bNnCHXfcQdOmTavUblE7JDgWopGLiYmhTZs2ABw8eDDgtU6dOtGpUycA1q1bx9ixY+nXr1+5QT5er5f333+fG2+8kX79+tG9e3dGjBjB3LlzycvLq3abKhtIVLpNGzduZOzYsfTu3Zu+ffsyefJk9uzZE7D8ypUr6dSpk5aHevHFF2vb6NSpk/YjU9P9qOwY/fXXX3Tq1Imzzz4bt9td4f6OGTOGTp068dVXXwU8f7Ltqe3jU9l5yczM5LnnnmP48OH06NGD/v37M27cOD799FOUCooWVbettaF58+YAQYOYP//8k5dffpnrr7+ewYMH061bNwYPHsxdd93Ftm3byi2/f/9+OnXqxIABAyo9v1dccQWdOnXim2++CXi+Juc3MTGRJ554gosvvphu3brRu3dvLr74Yu68807WrFkTsGxF56u6+6mqi/OVnp5Oamqqtv2yWrRooaUqVBR4ut1u7rrrLo4cOUJCQgJxcXHVbkdl8vLytI6Da665ptzrI0aMwOFwkJWVFfD3Uhn1OHfv3l37TJY2fPhwAH7++WfS09MDXvN4PPj9fgAtDaU0p9OJ0+kEij9jwWRkZPDvf/+bDh06cMstt1SpzaL2SHAsxCmgouBF9eabbzJ9+nQOHjwYkMsJxT8ct9xyC0899RQ7duwgLCyMNm3acPToUV5//XWuu+66cl/uteH9999nypQpHDp0iLZt2+L3+/nuu+8YO3Ys+/bt05aLioqiT58+mM1mALp160afPn20R2hoaK3sR7BjZLVaiY+PJzs7m02bNgVd78CBA+zevRun0xkwAOdk21Pbx6cyhw4dYvTo0SxatIjExEQ6dOiA0+nk559/ZubMmTz88MOVfsaq2tbasGvXLgDatm1b7rVZs2axYMEC9u/fT1hYGPHx8Xi9XtavX8/NN9/MZ599FrB8u3bt6N27N1lZWeUC39Lv9+effxITE3PS5/fo0aNcffXVLFu2jPT0dNq2bUvr1q3Jy8tjw4YNvPnmm1U6BtXdz7Jq83yp+cZhYWEBPaCl91kNBNu3b1/udZ/Px3333ceOHTt48803adeuXaXvp14MVmd8xZ49e/B4PFgsFrp27VrudZPJRPfu3QH49ddfq7TNnJwcgAoDefV5v99frsc8LCxM6+ndvn17uXX3799PVlaW9pkKZtasWWRlZfHkk082+pz001KDJnUIIRRFqTwPMyUlRenWrZsSHx+vrFu3LuC1+Ph4Ld9v2bJlWv6ax+NRPB6PoiiKcu+99yrx8fHKhAkTlMOHD2vrZmVlKXfddZcSHx+v3H333TVqb7D8V7VNPXv2DNif3NxcLQ9vxowZ1drmyezHiY7RG2+8ocTHxyv33Xdf0PedP3++Eh8frzz22GO12p7aPj4VLeP3+5UxY8ZouZOpqanaaxs3blR69eqlxMfHK++++26ttbUywT7rPp9POX78uPLuu+8qPXr0UDp16qSsXbu23LpffPGFsnfv3oDn/H6/sn79eqVXr15Knz59lNzc3IDXly9frsTHxytTp04N2p5//etfSnx8vDJ79uyA52tyfp9++mklPj5eeeihh8qND/j777+VDz74IOixKHtOa7KfilI352vhwoVKfHy8ctNNNwV9/fHHH9c+W8H84x//0HJlt2/fHvAIlqO8YsUKJT4+Xrnooouq3Eb1HF9yySUVLqO2c+bMmVXa5uzZs5X4+HjlxhtvDPr6wYMHteO9ePHicq+vWrVKiY+PV84//3xl7dq1SkZGhpKTk6N8++23yogRI5ROnTopy5YtC7rtH374QYmPj1ceeOAB7bmHHnpIco7rkfQcC9GIpaen8+CDD+J2u3E6nZx77rlBl7vhhhu47rrr0Ol0ABiNRoxGI3v37mXNmjU0b96cV155JeAWn9Pp5LnnnqNp06Z8+eWXQctrnYxrrrmGMWPGaP/vcDh45JFHAPjuu++qta3a2I+KjtHll1+OTqfj66+/prCwsNx66q3wyy+/vFbbU5vHpzI//vgju3btwmw28+KLLwZMunD++edz5513ApCQkFBh73FdtPWRRx7R0gC6dOnC+eefzz//+U86duxIQkKCdtu6tBEjRpS7ta/T6Rg6dCgTJkwgLy+P//73vwGvX3rppdhsNr777jsyMjICXvN4PKxevRogYP9qen7VtKdbbrkFu90e8F7t27fn+uuvr9Kxqcl+llab50vtOS5dSrKoqIhdu3Yxffp0li9fTqtWrXj22WeDrq/ekXnppZe4/vrrAx7BevOtVitxcXHExMRUuY3Z2dkAWqpCMGqFF7VH+ETUnuZdu3Zx7Nixcq9/+eWX5d6/tFGjRjF//nwiIiKYPn06AwcOpF+/fkyePBmTycSbb77JddddV249l8vFk08+SWhoKA899FCV2ipqn5RyE6IReeONN/jwww+B/5Vy83g8mEwm/vWvf1VY+uiqq64K+vyGDRuA/+XclWW1WjnnnHNYuXIlW7ZsCZpbV1PBcv86deqExWIhNzeXzMzMKteyrY39qOgYNW/enN69e7Nt2za+/vrrgCB4z5497N+/n5iYGAYMGFCr7anN41MZNTgZMWJE0IDjhhtu4KWXXiIxMZH9+/cHvTVeF20tm/6TmZlJYmIiu3fv5r333qN79+5Bg52kpCRWr17N7t27yczM1PJc1cB37969ATV3HQ4Hw4cPZ9WqVXz22WdMmDBBe23jxo1kZmbSrVu3gOCvpudXvZW+bt06OnXqpF2I1UR197O02jxff/zxB1CcqvH+++8HvBYaGsq0adMYP3580Mk+AL7++usqvY/q0ksv5dJLL63WOi6XC6DS9AM1LamoqKhK27z44ouJjY0lJSWF+++/n3nz5hEbGwsUD9ZT6w6Xfv/SFEXhyJEjZGVlYTAYAkq5/fXXXyxfvpwePXoQHh4esN6rr77KoUOHeOKJJ2T2wAYkwbEQjcjBgwe13ieTyURMTAz9+vVj4sSJdOnSpcL1ggU0UDywB4p/7IPlvkHxjzBAcnLySbS8vIoK/EdGRnLs2DEKCgqq/ANdG/tR0TECGDlyJNu2bWP16tUBwbHaq3jZZZcF1EetjfbU5vGpjPp56tChQ9DXHQ4HTZs25dChQxw8eDDocaqLtk6ZMiWgdxOKe/X+7//+j48//piJEyfy0UcfBQSYq1at4sknnwwajKiC9eJdffXVrFq1io8//jggOF61ahVAuXbU9PyOHTuWjz/+mFdffZVPPvmEwYMH069fPwYMGFCtQWg13U9VbZ0vl8vFgQMHgOJcd7PZjN/vJzExkdTUVHJzc8nLy6swMK4vFosFqHhAIKANyAwJCanyNufOncvtt9/O1q1bueiii2jbti3Z2dmkpKTQrFkzunTpwi+//BK08saTTz7JsmXL6N27N++8845Wszs9PZ3HHnuM9evXc/jwYVatWoXBYAD+V9P4rLPO4sYbb6zWMRC1S4JjIRqRZ599ttwPdVVUVBYpNzcXKB6QdejQoUq3of4QT58+XRudXlrZXqOatkkNMiu6hR9MTfajqu2B4t6qWbNm8d1335GdnY3T6URRFL744guAgNJQdd2emhyfyhQUFADBp/FVRUVFcejQIfLz84O+Xl9tDQsL41//+peWCvLVV18xdOhQAA4fPsw//vEPPB4PEydO5Morr6Rly5bY7XZ0Oh0ffvghjz/+eNDR//3796dNmzbs2bOHP/74g06dOpGRkcHGjRsxmUwBF0RQ8/PbpUsX3nnnHebPn89PP/3EsmXLWLZsGTqdjkGDBvHoo49WepF2svupqq3z9ddff+H1ejGZTLz//vta76uiKLz33ns8/fTTLF26lNGjR2tTQjcE9Q5DZRcMajpFdSYY6tevH6tWreKNN97g+++/5+DBg0RERHDDDTdwzz33aClJZXt49+7dy/LlyzGZTMydOzegDFtUVBT//ve/GTp0KH/88QdffPGF9v3y1FNP4fP5eOqpp2o0m5+oPRIcC3EaU38kn3nmGa699toqrbNr165azz8+WTXZj+qIjIzknHPO4bvvvuPLL7/k2muvZevWrSQlJdG6dWt69OhRr+2pTWpby+bblqZWXSibJ9sQzGYzXbt2JTk5md9++00Ljr/44gs8Hg+XX3550FzMYHmhpY0ePZq5c+fy8ccf89BDD7FmzRo8Hg/Dhw8vd2v7ZM5vr169WLRoEfn5+Wzbto3NmzezevVqNm3axK233srq1asrDdBOdj9rk5pv3K5dOy0whuL857Fjx/L555+zZcsWVq1a1aDBsToN87Fjx/B6vRiN5UObI0eOBCxbnW3PmjWr3PNer1er/1x237du3YqiKLRp0yZofWKHw0GPHj3YuHEju3bt0oLj33//HZ1Ox7Rp08qto16wLVy4kHfffZcmTZqwYsWKau2LqDq5NBHiNKbeSldvE1fF119/zR9//FHu0ZBqsh/Vpf5AqakU6n/L9irWV3tqi1oq6u+//w76el5enhZwVVRWqr6pPZtZWVnac+oFW+/evYOuowYqFRk9ejQGg4HPPvsMr9dbYUoF1M75tdvtnHfeeTzwwAN88cUXtGrViuTkZL799ttK1zvZ/axN6t99RSldV155JUC5+t/1rWvXrphMJlwuV9BazqUnKOnZs2etvOemTZsoKCggNja2XHBc0R2Y0tTPeNk7Sz6fj7S0tHIPdbmCggLS0tLIzMyslf0QwUlwLMRpTO11+/TTTxv9l6maCxgsDaE+9mPYsGGEhITw888/c+zYMdatWweUT6mor/aUVdnxqYxau3ft2rVB02WWLVuG2+2mefPmJ6xBWx9KBzilq0SoeaVpaWnl1tm3b1+l1RuguC7toEGDSE1NZfHixezevbtcbWNVbZ9ftZ42QEpKSqXLnux+1ia157hz585BX7/wwguB4vzr+gzay3I4HJxzzjlA8axyZa1du5a8vDzCw8M5++yzT/r93G43L7/8MgA33nijljOsKj1pU7Ce/ry8PC1YL31BumXLlqAdE3/88QejR48G4J577uGPP/6o9kBHUT0SHAtxGuvevTuXXnopWVlZTJw4sVyvis/nY/Pmzdx///2VziBWH9RA6Oeffy73Wn3sh91u56KLLsLv9/OPf/yDjIwMunTpEjRHtCGOa2XHpzIDBw6ke/fuuN1u7rvvvoCJKzZt2qRNf3vbbbedVHWF2pCdnc3jjz9OSkoKJpMpoGpB3759geLcdzVog+JJWmbMmFGliRKuvvpqoLisGBTPjFc2sIGan98nn3ySzz//vFxJwF9++UWbDjvYJBWl1cZ+1ha157ii4DguLk7rVa6toH3t2rUMGTKk2gPSpk6dquVkq3d9oLinffbs2QBMnjw5ID0EYM6cOQwZMoQ5c+aU2+bGjRvLTRpy7Ngx7rzzTnbv3k2HDh2YPHlyufUGDRpEREQEHo+He++9N2AGxPT0dB544AEyMzOxWCyMGDGiWvsp6ofkHAtxmvu///s/cnJy+P777xk9ejTNmjUjJiaGwsJCDh8+rJU2CpZXV58uvfRSvvnmG5566inee+89LQ/00UcfpUuXLvWyHyNHjuSLL77QasEGS6lQ1fdxPdHxqYhOp+OFF15g/Pjx/Pzzz1x44YV07NiRvLw8bbDZVVddxQ033FAr7ayq0mULoTiF4ujRo7jdboxGI08//bQ2wh+Ke3N79erFjh07uPrqq2nTpg0Gg4G//vqL6Ohopk2bxrx58yp9zyFDhhAREaH1Blc2+LUm53fHjh188MEHGI1GWrdujd1uJz09XUuVuPLKKxk4cGClbayN/awNR44c0fJcKwqOAS644AJ+//13/vvf/wbNla2ugoKCGo156Nu3L/fccw/z5s3TSq/ZbDb++usv/H4/F154IRMnTiy3nlpCMNgdgk2bNrFkyRKcTifNmzfH5XKxf/9+FEWhQ4cOLF68uFywDcUX2nPmzOHuu+9m+/btXHLJJbRs2RKj0cihQ4fweDwYjUb++c9/1vpU2qJ2SHAsxGnObreTkJDAmjVr+Pjjj9m9ezd79uwhPDycTp06cfbZZ3PJJZdot3MbyqhRo8jJyeGjjz7i0KFDWr6nOsq8Pvbj/PPPx+l0kp2djU6nqzQ4ru/jeqLjU5nWrVuzatUqFi5cyNdff81ff/2F2Wymf//+XHvttVx55ZX13mtcumwhFA/Ei4uLo3///kyYMKFcQGY0Glm0aBHz5s1j3bp1HD58mKioKK655hqmT59e4fTfpZnNZkaOHMnSpUvL1TYuqybn95FHHuGrr75i69atHDt2jMOHDxMbG8vgwYMZO3YsF1100QnbWBv7WRvUXuMmTZpUWvbtwgsv5PXXX+e3334jLS2tQWvzTps2jc6dO/P222+ze/du0tLSiI+PZ8yYMdx8881B7xJUZujQoaSmpvLbb7+xb98+zGYz3bt357LLLmPs2LFBA2PVBRdcwCeffMJbb73FTz/9RFJSEoqiEBsbS79+/ZgwYUKDDmIUldMptVWDRwghhGjk7r33Xj7//HOeeOIJxo4d29DNEUI0QhIcCyGEOCNkZmZywQUXoCgK3333XbkSbkIIATIgTwghxBnilVdeweVycfnll0tgLISokOQcCyGEOG39/vvvzJo1i5SUFA4ePEhISAh33HFHQzdLCNGISXAshBDitJWTk8PPP/+sDaaaOXMmrVq1auhmCSEaMck5FkIIIYQQooTkHAshhBBCCFFCgmMhhBBCCCFKSHAshBBCCCFECQmOhRBCCCGEKCHBsRBCCCGEECUkOBZCCCGEEKKEBMdCCNEI3HPPPXTr1o2kpKQGbcfKlSvp1KkTDz/8cIO2QwTKy8ujf//+3HjjjQ3dFCFOezIJiBBCNLDffvuNtWvXct1119GsWbMabycnJ4f//Oc/hIaGcsstt9ReAxuZnJwcXnvtNdavX09ycjJOp5MBAwZwxx130L59+xpt0+VysXDhQj7//HOOHj2KzWajd+/eTJkyhV69elW4nt/v55133mHlypUcPHgQs9lM165dufXWW7nggguCrrNy5Up++eUXdu/eTWpqKjk5OTgcDjp16sSoUaMYNWoUen1g35XD4WDcuHEsWLCADRs2MHTo0BrtpxDixGQSECGEaGATJkxg8+bNrF+/npYtW9Z4O0ePHuXiiy+mefPmfP311zXaxsqVK3nkkUcYPXo0s2fPrnFb6kpqairXX389iYmJWK1W2rVrx7Fjx8jIyCAkJISEhAT69+9frW0WFBRw8803s3v3bkwmEx07diQ9PZ3k5GQMBgPPP/88l19+ebn1fD4fd9xxB9988w16vZ6OHTuSn5/P0aNHAXjwwQeZNGlSufXOP/98kpOTsVqtxMXFYbfbOX78OOnp6drrCxYswGw2B6yXnZ3NBRdcQLNmzVizZg06na5a+ymEqBpJqxBCiAa0b98+fvrpJ/r3739SgfGZ4uGHHyYxMZG+ffvy3//+l5UrV/Ltt98ybtw4ioqKmDFjBgUFBdXa5uzZs9m9ezft2rVj3bp1rFq1im+++YYHHngAn8/Ho48+yrFjx8qtt2jRIr755huio6NZtWoVn376KV999RX//ve/0ev1PP/88/z222/l1psyZQrLly9n27ZtrFu3jpUrV/LDDz/w5ptvYrfb+fbbb1myZEm59ZxOJxdddJH2mRFC1A0JjoUQogEtW7YMIGjPpAi0c+dONm3ahNFo5N///jcREREAmEwmHnnkEdq3b09aWhrLly+v8jZTUlJYsWIFALNmzaJ58+YA6PV6brvtNgYNGkRRURGLFi0KWM/tdpOQkADAI488QufOnbXXrrjiCq655hoUReG1114r955jx46lZ8+e5VInLrjgAu644w4ANmzYELS96ufkww8/rPI+CiGqR4JjIYRoQF988QUAF154YdDXMzMzmTNnDiNGjKB79+706tWLIUOGMGnSJN59911tuYcffpiLL74YgMTERDp16hTwKE1RFD788EOuuuoqevTowTnnnMO9997LoUOH6mYna8mXX34JwLnnnlsuN9tgMDBq1CgA1q5dW+Vtfv3113i9Xtq3b0/v3r3LvX7NNdcAsG7duoDnN2/eTHZ2Ng6Hg+HDh1e43qZNm8jLy6tye9q1awdAUVFR0NcHDx6M0Whkw4YNuN3uKm9XCFF1MiBPCCEayKFDh0hJSSEmJoYmTZqUez03N5frrruOw4cPYzKZaN26NRaLhePHj/P999/z66+/MnbsWADatGlDt27d2LVrF2azmW7dulX4vv/85z95//33AWjevDnh4eFs2LCBTZs2cdNNN9XNztaCHTt2ANCnT5+gr6vP79q1C5/Ph8FgOOE2f/311yptMyUlhWPHjtG0adOA9Xr06IHJZCq33llnnYXFYsHlcrF371769et3wrbA//axa9euQV8PCQkhPj6ePXv28Ntvv1V5u0KIqpPgWAghGsj27dsBKgxkP/zwQw4fPszgwYN54YUXCA8P115LSkrSelIBpk6dysiRI7n44ouJiYnRgt+yvvrqK95//33MZjMvvPACl1xyCQAZGRncc8895dIHqmr69OmkpqZWe72K2hmM2rNdUW62+rzH4yEpKalKOdwHDx6sdJtxcXGYTCY8Hg8HDx7UguMTrWc0GmnatCkHDx7k4MGDlQaxHo+H48ePs2bNGhYtWkRUVJSWXhFM9+7d2bNnD9u2bZPgWIg6IMGxEEI0kMTERABiYmKCvq4GYDfddFNAYAzQrFmzGpVrU4PfcePGaYExQGRkJC+++CIXXXRRtbcJxb216v7UlZycHADCwsKCvu50OrV/Z2dnVyk4PtE2dTodYWFhpKena8tWZb3Sr5Ver7T/+7//Cxh4p9PpGD16NHfddZeW+xyM+nmp6+MtxJlKgmMhhGggmZmZQGBQV5raS7lhwwYuuOACjMaT+8rOz8/XequDTSYRExPDJZdcwpo1a6q97ZqWjqsOl8sFEDSNAQgofVZRzm51t1l6u6W3WdP1SmvZsiV9+vTB7XaTmJhIZmYm3377LZ07d2bChAkVblf9vKifHyFE7ZIBeUII0UDUAVVl69mqxowZQ2hoKCtXruSCCy7g4Ycf5sMPP+TIkSM1er/Dhw/j9/uxWCwV9qqqA8IaI4vFAhSnIQRTeoBaSEhIrWyz9HZLb7Om65U2fvx43n//fVasWMFPP/3EwoULsVgszJo1izfffLPC7arbq+oFgBCieiQ4FkKIBqL2AFZ02z0uLo5ly5YxfPhwcnNzWbVqFY8//jhDhw7l+uuv13qBqyo/Px9AK4EWTHR0dLW2WZ9OlKaQnZ2t/bui3vjqblNRlKApFCdar/RrlaVelHb++efz8ssvA/Daa69VGPxmZWUBlZ9HIUTNSVqFEEI0kKioKCAwqCurffv2vPzyy7jdbrZv384vv/zCmjVr2LFjBxMnTuSzzz6jRYsWVXo/u90OVH47Xp2lrbrqY0Be69atSU5OrrDnXH3eZDJVeRruNm3asG3btgq3mZycrPUOt2nTJmC90u9ZltfrJSkpqdx6J9KtWzeio6NJS0vj4MGDAfWTVernJTIyssrbFUJUnQTHQgjRQNTAZ9++fSdc1mw2M2DAAAYMGMC0adO4+eab2bZtG2vWrGHKlCkAJ5xOuFWrVuj1elwuF0ePHg0aVO/fv78Ge1I/A/J69uzJzz//zLZt24K+rj7frVu3KpVxg+JSbCtXrjzhNmNjY7UccHU9gN9++w2Px1Mu93j37t243W5MJlPQALcyPp8v4L9lqZ+Xisq9CSFOjqRVCCFEA+nZsycmk4k///yzWhM6GAwGunfvDhTX31WdKBfVbrfTq1cvAD744INyr6elpQWUh6uOr7/+mj/++KPaj+pQq2v88MMPWq+syufz8fHHHwMEnZSjIkOGDMFoNLJv376gaSofffRR0G0OHDgQp9NJXl5euQlCSq83ePBgHA5HlduzZcsWMjMzsVgstG3bNugyO3fuBJAybkLUEQmOhRCigVitVnr37o3H4+G3334r9/rcuXP58MMPy+W1/vnnn9rMeqV7DyMjI7Hb7aSnp1fYGz1p0iQAlixZEjBFcUZGBg888ACKopz0ftWVHj16MGjQILxeLw888ICWHuLxeHj22WfZt28fUVFRXHfddeXWHTJkCEOGDNEm2VDFxcUxZswYAB599FGt91tRFBISEvj++++xWCxMnDgxYD2z2aw9N3v2bPbu3au99tlnn/HRRx+h0+mYNm1awHobN25k8eLFARc1AH6/n88//5wZM2YAcPXVV2Oz2crtx6FDh0hLS6Ndu3YBPdlCiNojaRVCCNGArrnmGn7++We++OKLcj2Bf/31F6+//jpPPPEELVu2xOl0kp2drU2GMWDAAK666ipteZ1Ox4gRI1ixYgWjR4+mY8eOWoC1dOlSAG0w37Jly7jzzjtp0aIFTqeTv//+G4vFwqRJk3j99dfrae+r79lnn+XGG29k69atXHTRRbRr145jx46RkZGBxWJh7ty5Wm51aWrQq5ZgK+2hhx5i165d7Nmzh+HDh9OxY0fS09NJTk7GYDDwzDPPBM1hnjx5Mlu2bOG7777TjndBQYGWh3z//ffTs2fPgHXS09OZM2cOc+bMoWnTpkRHR1NYWEhSUhIFBQUAXHDBBTz00ENB9//zzz8HioNnIUTd0CmNuZtACCFOcy6Xi/POOw+j0ci3334bUMt4586dfPnll2zevJmkpCSysrKIjIykdevWXH311YwcObJc7eP8/HzmzZvHV199RUpKijaYrHQKg6IoLF++nHfffZcDBw7gcDgYMGAA9957L1u3buWRRx5h9OjRzJ49u34OQjVlZ2fz6quvsmHDBpKTkwkLC2PgwIHccccddOjQIeg6nTp1Aop7zAcMGFDu9aKiIhISEli9ejWJiYnYbDZ69+7NlClT6N27d4Vt8fl8vPPOO6xcuZJDhw5hNBo566yzuPXWW7nwwgvLLZ+cnMwnn3zC5s2bOXDgAOnp6fj9fqKjo+nWrRtXXnklw4YNq/D9Ro4cycGDB9m4caM2oFMIUbskOBZCiAb2+uuvM3fuXJ577rmAnmAhSvvpp5+YMGECN910E08++WRDN0eI05YEx0II0cAKCwu55JJLcDgcrFmzBr1ehoOI8saNG8euXbtYv359o65HLcSpTnKOhRCigVmtVp577jm2bNlCSkoKTZo0aegmiUYmLy+PAQMGMH78eAmMhahj0nMshBBCCCFECbl3J4QQQgghRAkJjoUQQgghhCghwbEQQgghhBAlJDgWQgghhBCihATHQgghhBBClJDgWAghhBBCiBISHAshhBBCCFFCgmMhhBBCCCFKSHAshBBCCCFECQmOhRBCCCGEKCHBsRBCCCGEECUkOBZCCCGEEKKEBMdCCCGEEEKUkOBYCCGEEEKIEhIcCyGEEEIIUUKCYyGEEEIIIUpIcCyEEEIIIUQJCY6FEEIIIYQoIcGxEEIIIYQQJSQ4FkIIIYQQooQEx0IIIYQQQpSQ4FgIIYQQQogSEhwLIYQQQghRQoJjIYQQQgghSkhwLIQQQgghRAkJjoUQQgghhCghwbEQQgghhBAlJDgWQgghhBCihATHQgghhBBClJDgWAghhBBCiBLGhm5AQ8nMzKz393Q6nWRnZ9f7+4q6Jef19CPn9PR0Op9XXVoa4fHxAc9l/fknSnR0A7WofpzO5/RMVdfnNCIi4oTLSM9xPdLr5XCfjuS8nn7knJ6e5LyefuScnn4awzlt+BYIIYQQQgjRSEhwLIQQQgghRAkJjoUQQgghhCghwbEQQgghhBAlJDgWQgghhBCihATHQgghhBCniaKiIjIyMigsLERRlIZuzinpjK1zLIQQQgjRWPh8PtxuN4qioNfrMRgM6PV69Ho9Op3uhOu7XC4tKAbIysrCbDbjdDpxOBxV2oYoJsGxEEIIIUQ9URQFr9eL2+3G5XJp//X5fBWuo9frMZvNhISEEBISgsViwWAwAOB2u8nMzCQ/P19b3mq1UlRUhNvtJjU1lYyMDJxOJ2FhYVWuI6z2Op+JQbUEx0IIIYQQtUBRFC2oVP+tBsKlg+GK0h2MRiN6vR6fz4ff79eW8/v9FBUVUVRUpC1rNpsxGo0UFBRoz9ntdiIjIzGZTPh8PnJycsjJycHn85GRkUFmZiYWiyXgYTQa0el0+Hw+XC4XRUVF2n8VRUGn02EwGLSebIPBgNFoLBekn04kOBZCCCGEqAG/309+fj65ubkBgeuJ6HQ6TCYTFosFs9ms/bdsr66iKFqg7HK5KCwsxOVy4fF4tIAbwGazERERgcVi0dY1GAxEREQQHh5Obm4u2dnZeDyeckG2mrrh9XqDtlUN8Ct63Wg0YrFYCAkJwWQyaYG0wWCosNfZ5XKRk5NDWFhYQJsbCwmOhRBCCCGqweVykZubS15eHn6/v9JlDQYDZrM5IAg2mUxVSlfQ6XQYjcWhmtlsJjQ0FACv10tRUREejwer1UpISEil2wgLCyM0NBSPx4PL5Qp4+P1+bR/UgF3tFTYajfj9fnw+nxakq7nRapCuBs6l0zpK73vZ3Gmfz6cF5zqdToJjIYQQQohTkaIo5Ofnk52djcvl0p43Go2EhobicDi0AFANfOsqX9doNOJwOKq1jk6n04J0NchWFAW3243P56swRcJgMGAymYJuU03FUB9er1cLpNXXK8ulbqwkOK4Bl0uhJufabFYoKKidsioGA1gsZ16SvBBCCFGf1KA4MzMTj8ejPW+32wkNDcVqtZ6yg9ZOtufWYDBgs9mw2WwBz6vpIOrD7XaTnZ2tBcpqkB4WFnZS7a8rEhxXk8ulsG27QpC7Bydkt7vIz6+d4Nhuhz69axYgr169mmeeeUb7f4PBQGRkJGeffTZTpkwhNja2VtpYmaeffppt27bx8ccfV3vd3377jc2bN3PDDTdoV7+ng6KiIpYuXUqfPn3o27dvwGvqOVu5ciXNmjVroBbWj4EDBzJp0iRuu+22Wtne1q1bufPOO1mwYEG54yqEEBUJFhTr9Xqt6sPpOBCttqjpIAaDgdzcXDIzM1EUBYPBQGxsLFartaGbWCkJjqvJ54P8fDCawBz8LkOF7A49tVGP2+0pbsPJ3ql4/PHHadOmDS6Xi+3bt7NkyRK2b9/Ou+++W+cf3IkTJ3L99dfXaN2dO3eyaNEiLr/88tMuOF60aBFAuSBu0KBBJCQkEB0d3RBNq1cJCQn1coEmhBBQfOvf4/Hg8/kC0gLUnF6QoLg6FEWhsLCQ/Px88vPztXxmq9VKbGzsKXH8JDiuIbMJQkKq12trDdHh9dTGrRcFr+fES51I+/bt6dKlC1AcjPn9fhYvXszGjRsZMWJE0HWKiooqTfyvqhYtWpz0Nmpbbe1bXYiIiCAiIqKhm1FnFEXB5XIREhJCt27dGro5QogzgKIoZGVlkZmZWeEyOp0Op9OJ0+k8JYK6hqIoCkVFReTl5QUExFB8YREeHo7T6Txl0k8kOBYaNSg5fvw4UJz68N///peFCxfy8ssvs2vXLtq1a0dCQgIej4elS5eybt06kpKSsNvtDBo0iLvuuqtKQVywtIqBAwdyzTXXcNZZZ/H2229z/PhxWrZsydSpUxk8eDAACxcu1HpXx4wZo61b+pb5+vXrWbZsGX///Tc6nY4ePXpwxx130KlTp4D3D7ZvZ511Fp988glr1qzBbrcHtPmxxx5j27ZtfPbZZ9ro4fXr17NixQr27t17wvdasmQJL774Ijt27CA0NJSLL76YadOmYTabSUpK0vZn0aJF2j5edtllPPHEExWmVXz22WcsW7aMw4cPExISQu/evZk6dSpt27at1vtXZtSoUbRv354rrriChQsXcuTIEaKjo7n++uvL9f7n5+ezaNEi/vvf/5KamkpERARDhgxh6tSpAXcj1HPdrl07li1bRmJiIvfddx9jxowJmlaxb98+Xn/9dXbs2IHL5aJ169bccMMNXH755QHvf/DgQebNm8f27dsJCQlhyJAhnHvuuZXunxDizOP3+0lNTdUqLKgpAGoNX/W/NptNguJK+P1+cnNzycnJCcjH1uv12O127Hb7KZmTLcFxNRWP7CxOq9Drq5cj4XIpuN0nn1fh9kBdzJZ+5MgRAMLDw7XnPB4PM2fOZPTo0YwfP14r5TJz5kx+/fVXbr75Zrp3787x48dZuHAhd9xxB2+99VaNe2C///579uzZw+23347VauWdd97hoYceYvny5TRv3pyrrrqKnJwcPvzwQ2bPnq2lGajB4Ntvv80bb7zByJEjufXWW/F4PLz77rtMnTqVxYsXBwSNwfYtMjKSZcuWsWHDBq666ipt2dzcXL777juuvvpqLTBW32vMmDGMGzeu0vfyer3MnDmTK664gptuuokdO3awePFiHA4HkyZNIjo6mnnz5jFjxgyuuOIK7b1Ln4uy/vOf//Daa69xySWXcMcdd5CdnU1CQgK33XYbixcvplWrVlV+/xP5888/mTdvHpMnTyYyMpJ169Yxd+5cvF4vY8eOBYp73qdNm0ZKSgoTJkygQ4cO7N+/n4ULF7Jv3z7mz58f8AW5ceNGduzYwaRJk4iKiqrwourQoUPcdtttREZGct999+F0Olm7di3/+te/yMjIYNy4cQCkp6czbdo0jEYjM2fO1Nr5wgsvnHD/hBBnDq/XS3JyslZxIjo6utEODKsPasUKRVG0iUfUf5eeAKR07WK3201OTg65ubkBM+k5HI5TNiAuTYLjalAUhXsfgD2/13QLubXWlpYt4NyBClDzD5+aX+V2u9m+fTtvv/02NpuN8847T1vG6/UyadIkRo4cqT23fv16fvrpJ5599lkuuugi7fmOHTty6623smbNGq6++uoatcnlcjF//nyt17ZTp05cccUVfPXVV4wfP57Y2FiaNGkCQHx8fEAvanJyMgsXLuSaa67h/vvv154/++yzufbaa0lISOD//u//Kt039T1Xr14dEBx/+eWXuN1ubdnS7/XMM89ot+Uqei+Px8Ntt93GxRdfDED//v35/fff+fLLL5k0aRJms5nOnTsDEBsbe8LUgtzcXBYvXsy5557L008/rT3fp08f7f1LP3+i9z+RtLQ0lixZQseOHQE499xzyczMZPHixVx99dWEhISwfPly/v77bxYtWqSl6/Tv35+YmBgeffRRfvzxx4Be3MLCQt59990T/iglJCTg9XpZsGABcXFx2vvn5uayaNEiRo8ejcPh4IMPPiArK6tcO6dPn67dDRFCnNncbjfHjx/H6/Wi1+uJi4tr9IPD6pLL5SI5ObnCCT6CMRgMAeXZTCaTVke5qlNTN3anx16IGpk8eTKDBw9myJAh3H///URGRjJ37lyioqIClisdAANs2rSJ0NBQzjvvPK34t9frpWPHjkRFRbFt2zag+HZL6derUuuwb9++AekMao/isWPHTrjuTz/9hM/n47LLLgt4X7PZTO/evbV2VbZvACNHjmTnzp0cOnRIe27NmjV07dqV9u3b1+i9dDqdlhqi6tChQ42Dtp07d+JyucqlFcTFxdG3b1+2bNlSq+/frl07LeBUXXLJJeTn57N3716g+HOhLlf6mAwcOBCdTlfumPTt27dKvTVbtmyhX79+WmCsuvzyyykqKmLnzp1AcVWKitophBAFBQUkJibi9XoxGo00a9bsjA2M1Xxr9XioM/apE5VYrVZsNhtWqxWz2RyQWqL+lttsNpo0aUKLFi1wOp2nTWAM0nNcLTqdjrn/Vtj4LdjsEFLN0oAORyh5eSffe1zkAo/n5IuLP/nkk7Rp00Yr5RasEkJISEi53NuMjAxyc3PLBVuq7OxsIDB3FqBJkyYnLN3mdDrLPWcymQIKrlckIyMDgFtvvTXo62X/cIPtG8Dw4cOZP38+a9as4Y477uDAgQPs2bOHmTNnntR7la0lWdX9CkY9xmUvZKD4FuHPP/9cq+8fGRlZ7jn1vXNycoDiY3L06NETfi5Kt7MqcnJyKtzP0tvNycmhadOmFbZTCHHmysvLIyUlBSj+PoyLizutc4n9fn+FwarX6yU1NZXCwkKgOMiNiYk54fEoXbtYzck+XZ2+e1ZHimeYUTCbwGyuXnBqsehwu08+B8fvr51qFW3atNFuf1ckWACujjqdN29e0HXUYuCjRo0KCJQqmmGntqj5ubNmzQoaJJVV0cVFWFgY5513Hl988QVTpkxh9erVWCyWgB7I0u8VHx9Pbm7tpcxUhXoRkZ6eXu61tLS0SnOVa0K9GChNfW+19zc8PByLxcLjjz8edBtlL3yqenEXFhZW4X6q76suV1k7hRBnptKBscPhICYm5pTOh62I3+8nPz+fnJwcXC4XBoNBm67aYrFgsVhwu92kpqbi8/nQ6XRERUURGhparamsT+egWHX676GodYMGDWL9+vX4fL5Kc2NjYmKIiYmp9fdXg+yyvZ4DBgzAYDCQmJjIkCFDTuo9Ro4cyVdffcUPP/zA2rVrueCCCwJqKpd+r6uvvrrSUkBVVdF+BdO9e3csFgtr167V8ogBUlJS2Lp1a9B0kZOxf/9+/vrrr4CUhS+//BKbzablSg8aNIj//Oc/OJ3OWp2opH///mzcuJHU1NSAz9MXX3wRUPqtb9++vPPOO0HbKYQ4M5UOjENDQ4mOjj7tAmOXy0Vubi55eXkBJdR8Ph8FBQUUFBSUW8dkMhEXF3fCakVnKgmORbUNGzaMdevWcd9993H99dfTtWtXjEajFpidf/75XHjhhXX2/mre7/Lly7nsssswGo20atWKZs2acfvtt/P666+TlJTEwIEDCQ0NJSMjgz179mC1Wqs869qAAQOIjY3l+eefJz09vVxub+n3SktLo0+fPjV+L5XdbqdJkyZ899139O/fn7CwsAoDzdDQUCZOnMhrr73GP//5T4YNG0Z2djaLFi3CbDZXaZBddURHRzNz5kwmT55MVFQUa9eu5eeff+bOO+/UKpPccMMN/Pe//2Xq1KnccMMNdOjQAUVROH78OD///DM33nhjjWoYT5o0iU2bNnHnnXcyceJEwsLCWLduHd9//z133XUXDodDe//Vq1dz3333MWXKFK1aRenccSHEmeN0Doz9fj95eXnk5uYGdKgYjUZCQ0NxOBz4fD5cLpf2UEuthYaGEhUVdVrlCNc2CY5ryO2B6hZUM5oUiopqp5RbQzIYDDz//PMsW7aMtWvXsmTJEgwGAzExMfTp00cLXutK3759mTBhAp9//jmffPIJfr9fq3M8YcIE2rZty7Jly/jyyy/xeDxERkbStWtXRo8eXeX30Ov1XHrppfznP/8hLi6O/v37l1tGfa8VK1awevXqGr9XaY899hjz589n5syZuN1urc5xMBMmTCAiIoLly5ezYcMGLBYLffr0Ydq0aQFl3GpDfHw8l19+OQkJCVqd43vuuYcbb7xRW8ZqtfLGG2+wZMkSPvnkE5KSkrBYLNrxq0qqSzCtW7dm4cKFvPbaa/z73//G5XLRpk0bHn/88YBKI1FRUbz66qvMnTuX559/HovFwgUXXMD999/Pgw8+eNLHQAhx6iibSnG6BMZqCbWyvcR2u53Q0NCAEmomkymgrKpapu10zrWuLTpFqY0JjU89Nb0N7nIpbNuuUFI3vFrsdrtWcPxk2e3Qp7cOi+XU/2M/1UVERNRKWkVjpU4CcibVCz7dz+mZ6nQ+r7q0NMLj4wOey/rzT5TTdMp5dVCZWpJNzYU1Go0oiqKNPzjVc4wVRcHr9VJUVERubi5FRUXaa0ajUSuhdjoFvHX9d1qVicqk57iaLBYdfXpDFaqSlRMebiErq3zuT00YDEhgLIQQ4oxTulaxKthYjVMxMPb7/bjdboqKiigqKsLlcpUrg2qz2QgLCzvlJ9pozCQ4roGaBqV2e+1UqxBCCCHOREVFRRw/fhy/34/RaKRt27bk5OSUq6kfEhJCRETEKRM8KopCTk4OmZmZAekSKovFgs1mIzQ09JSrFqGWgPP7/QEPKA70G2Pu86l1hIUQ9e5EtamFEKI+5Ofnk5KSgqIoWCwWmjRpQlhYWJUmmGrMioqKSEtLw+12A2gl2NT69BaL5aQDSEVR8Hg82gQoRqOxwm2q00d7vV6tXrJOp0On02n/hhOX41QUhezsbDIzM6kogzc8PDxoHf2GJsGxEEIIIRq17OxsrWa5zWYjNja2wXocy/aEqv+G4glGqlrT3+fzaZNqQfFA8IiICMLCwioMPH0+Hx6PB7fbjcfjwePxoNfrtbxrvV6PwWBAr9fjdrsDHmUD1NK52nq9Hp/Pp/W+n2g4mtFoxOl0VjhldFFREampqVqFDEALrtWHwWAIOhFXYyDBsRBCCCEaHb/fT2FhIXl5edpg9oYqyaYoCoWFhWRnZ2szy1XEZDJhtVqxWq2EhISUGyynlmHLyMjQgmqHw0FkZCRGoxG/368FvmUfJ9NLrk7iUTqwVwPnYNQgVlEUrdKFyuv1kp6eTmZmJqGhoTidTm3bZQP+qKgoHA7HKZPiAhIcCyGEEKKR8Hq92sQVhYWFAQFZZGQkTqezXoMsv99Pbm4uOTk5Ab2gQEAPqF6vx+/3a/WEPR4POTk5AJjNZq13Vu31VffLaDRqs8qmpqbidrtPGAAbDAbMZjMmkwmTyRQwrbP6UBQFk8mE2WzWZsgzGo3asfP7/Xi9Xi3VQs3hNhqN2tTQZXuE1TarM/FlZ2fj8XjIzs4mOzsbm81GUVGRFvCHhoYSGRl5SlbSkOBYCCGEEPVOURTcbjcul0urzFA2AFWDR4fDEVCzt655vV6ys7PJzc3Vgj2dTkdYWBhhYWEBgWZpam+3+lCD4Yp6Z71erxZEl6bX6zGZTBiNRi0IVoPd2kgn0ev1WuBcVer+GgwGrYRcQUEB2dnZFBUVaTPxmUwmoqOjsVqtJ93OhiLBsRBCCCHqTX5+PllZWUHLr8H/KjPY7XZMJlO99xRnZWWRnZ2t9ZSaTCYtGDxRYKrX67Hb7djtdgoKCkhJSQmoPmEwGLQ0BUALftWeYPW/pQe+NVY6nU7bV5fLRU5ODiaTqd579+uCBMdCCCGEqHOKopCZmUlWVpb2nF6v1yoyqI+GKFUWrJSaxWIhIiKi2vWE1SoN6kQkZrMZp9OJ3W7Xgmv1PRpjGbOasFgsxMTEVGlZRVG0qa/Dw8O1tJLGRIJjIYQQQtQpv99PSkqKdus9LCxMG8TVUL2Maq5uUVERGRkZ2qQiJpOJyMhIbDZbtdvm9/tJTU094QDC0yUori63201aWpo205/L5ZLgWAghhBBnFo/Hw/Hjx/F4POh0OqKjowkNDa3XNvh8PvLy8rTBcupgtNIMBgMRERGEhobWKGD3eDwkJydr+cVRUVGVlmWrTx6Ph9zcXNxuNyEhIVitVsxmc721TU1XUe8a6HQ6IiIicDqd9fL+1SXB8Rlu165dvPfee/z6669kZ2cTFhZGz549uemmm+jevbu23MKFC1m0aBFr164lPDy84Rpchz766CNCQkIYOXJkwPNJSUmMGTOGxx9/vNxrQgghKlY679ZgMBAXF1evA+vcbjfZ2dnk5eVVWLvXaDTicDgIDw+vUY9u2ckuDAYDsbGxDT4gTa0qkZubq/XUAlrvvcFgwGazYbVasVgsWgWL0lUvgICqF8EqT6g51GqVjLLH2efzkZ6ervXMW61WoqOjq1wPuiFIcHwGW758OfPmzaNr167cddddNGnShOPHj7NixQqmTJnCvffey7XXXtvQzaw3K1euxOl0lguAo6OjSUhIoHnz5g3UMiGEOLV4PB6ysrK0ercWi4W4uLh6ySeuqCax2WzGZrNpg+DU0mXBek/dbje5ubla2TSLxRIQGCqKQlFREXl5eUED7/z8fBRFISQkpF5SKEpP4OH1enG73eXapdZddrlcFBYW4vP5yM3N1c5RVajHQ6fTae9Z1drLBoOBqKgo7HZ7o+hNr4wExw0gMTGR/fv3065duwYLuH799VfmzZvHOeecw5w5cwK+sIYNG8ZDDz3E3LlziY+Pp2fPng3SxooUFRXVa8+D2WymW7du9fZ+QghxqnK73WRlZZGXl6c9V9cTdyiKgsvl0krCFRUVBQRsNpsNp9NJSEhIldqQl5dHampquYDXaDRqUzkXFBSUCwrVWsc+n4+cnBxycnLQ6XRaD2npXlVFUTAajdjtdhwOR5UvGtRaymoJPHWmvMp6xUNDQ3E4HAE9tX6/Xyu/ppacMxgMWo1j9d/qtNNut1sLhCuaBEWt+xyMzWYjMjLylMm1luC4ni1dupR7771Xm6987ty5jBs3rt7bsWTJEnQ6HQ899FC5P0qj0ciDDz7ImDFjWLJkCS+88IL2WnJyMs8++yy//PILOp2OwYMHM2PGDCIiIrRltmzZwqJFi9i3bx8ul4vw8HC6dOnCU089pQW1Ho+HpUuXsm7dOpKSkrDb7QwaNIi77rorYFujRo2iffv2jBw5krfeeouDBw9y/fXXs3nzZqxWK2+88UZA230+H6NGjaJr167MmTMHgISEBH744QeOHj2K1+ulRYsWXHPNNVxxxRXaF+WoUaM4fvw4AAMHDgSgSZMmfPzxxxWmVezYsYOEhAT27NmDz+cjPj6eW265hUGDBmnLrF69mmeeeYYFCxawYcMGvv76axRFoXfv3jzwwAMBo3urctyEEKIhqRNGlOXz+cjOztZu2UNxT2VERESdfH+pObQpKSlaL21per2e0NBQwsLCqnz7XlEUMjIyyM7OBtBmt3O5XAG9smWVzqNW6xyrE5n4fL4Kaxz7fD5cLhcZGRmEhITgcDi0meSCzZKnBsIVKT0dtMlkwmazVXhBoNfrsdls2mA4RVFOeOFQdka9ssF0Y+8Nrg4JjuvR0aNHtcAYij9o9913H0OGDKnXHmSfz8fWrVvp3LkzsbGxQZeJi4ujU6dObN26NeDq+KGHHuLiiy9mzJgx7N+/nzfffJMDBw6wePFijEYjSUlJ3H///fTs2ZPHH38ch8NBamoqP/30Ex6Ph5CQEPx+PzNnzuTXX3/l5ptvpnv37hw/fpyFCxdyxx138NZbbwV8mf7xxx8cPHiQW2+9laZNm2r5SnPnzuXw4cO0atVKW3bz5s2kpqYGBLHHjh1j9OjRxMXFAcV51i+88AKpqalMmjQJgDlz5vDoo49it9t58MEHASr9Qt22bRvTp0+nQ4cO/N///R8ej4cVK1bwwAMP8PTTTzNs2LCA5WfNmsW5557L008/TXJyMq+88gpPPfUUCxYsAKjScRNCiIbicrnIysrSqjBUxm63Ex4ejsViqdU2qNMu5+XlBeTQwv9KwoWEhGj/rU4vpc/nIyUlResVdTqdREZGagGfGuSqqRRqkGqxWIiNjdV+L0rXOVZ7XdWBiKUfgLat0j3e6enpWnBcEYPBoJW9U+siB5vRrjqqEtjq9XpCQkLOiN8jCY7r0V9//VXuA+/z+Thw4EC9BsdZWVkUFRXRrFmzSpdr1qwZe/bs0a6iAS688ELuvvtuAAYMGEBkZCRPPvkkGzZsYMSIEezduxeXy8Xdd99Nx44dtfWGDx+u/furr77ip59+4tlnn+Wiiy7Snu/YsSO33nora9as4eqrr9aez8zM5P333w8Igps3b84rr7zCmjVrmDZtmvb8mjVriIyM5JxzztGe+8c//qH92+/306dPHwCWLVvGxIkT0el0dOrUCYvFgt1ur1IKxauvvkpoaCivvvoqzZs3JzMzk0GDBjF+/Hjmz5/P0KFDA75sBg4cyP3336/9f05ODq+88grp6elERUVV6bgJIUR9c7lcZGZmBvQIq7m3pXtrdTodVquV8PDwas26diJq/nBeXl65HmKr1UpsbCw+n++kJgtxuVwkJyfj9XrR6XTExMTgcDgCllH3uXRgHB4eTkRERIXvq9PpKp2FzmKx4HQ68Xg8WtBfOkXCYDCUmx2vbO6zqBsSHNejjh07ajlJKoPBQNu2bRuwVRVT/0BL/+GPGDEiYJmLL76Yp59+mq1btzJixAji4+MxmUw8++yzXH311fTq1atc4L9p0yZCQ0M577zzAm5RdezYkaioKLZt2xYQHLdv3z4gMIbiq/rBgwfz+eefM2XKFPR6PTk5OXz33Xdce+21AakiW7Zs4e233+b3338v1+uRkZFBVFRUtY5LYWEhu3fvZsyYMQH1GQ0GAyNGjGDBggUcOnSINm3aaK+dd955Advo0KEDUNyrHRUVVaXjJoQ49am3y/V6PQaDodHkYKoVB9SHmjdbOii22+1ERETUavAbjM/n09ISCgoKAgJik8mk5dAajUYiIiLIzMys0fuoE39kZGRoOcBxcXHlerz9fj/p6enawDWDwUBMTEyt1ec1mUxEREQQHh6uBd4n2xMsTo4Ex/WoRYsWzJ07l/vuuw+fz4fBYODFF1+s9yAoPDyckJAQkpKSKl3u2LFjhISEEBYWpj0XGRkZsIzRaMTpdGpzw7do0YL58+ezdOlS/v3vf1NYWEjz5s257rrruP7664HigDQ3N5fBgwcHfd/SPdVQXC0imCuuuIL//ve//PzzzwwcOJAvv/wSt9sdkFKxe/du7rnnHnr37s0jjzyi3f7auHEjb7/9doXTl1YmNzcXRVGCBtVqW8vuQ9lajuotOPX9q3LchBCnBkVR8Hq92kAnta5usHxdNWdTfQT7/9rO5VQrLZQejFXRgC5AK3NWl0Gxoijk5+eTk5NTLmVCLTkWGhqKxWKpleNRdjIKtRe6bK9sfn4+aWlpWnphaGgoUVFRdRK4qj3NouFJcFzPxo0bx5AhQzhw4ABt27ZtkN5Bg8FA3759+emnn0hJSQmad5ySksIff/zBwIEDA74sMjIyApb3er1afWRVr1696NWrFz6fj99//50PP/yQuXPnEhkZybBhwwgPD8fpdDJv3ryg7St7NV7RF+GAAQOIiYlh9erVDBw4kDVr1nDWWWcF9MSvX78eo9HICy+8ENAbsHHjxsoPUiVCQ0PR6/Wkp6eXey0tLQ2gRrWgT3TchBCNk5pbWlhYGLRaQll6vV6rXKDWk63sQr10wFy6BJler9cGavmSkwmvpI3qJBiFhYUUFhZWGAzrdDqt6oDFYqnzoBjQcm1LHwOTyYTdbsdms9VaQAzF50qdjEIdhBYZGalN1lF6IFx+fr52t9FkMhEdHd3gtYtPK55CQAemxpfDLMFxA2jevHmD3zIfP348P/74I8899xxz5swJCIB9Ph9z5sxBURQmTJgQsN7atWvp3Lmz9v9fffUVPp9Py+MtzWAw0K1bN9q0acO6devYu3cvw4YNY9CgQaxfvx6fz3dSJdLUNIZly5axY8cOfv/9dx5++OGAZXQ6nTaiVlVUVMTatWvLbc9kMlWpJ9lqtXLWWWfxzTffaPnXUHzrbe3atcTGxpZLA6nufgU7bkKIxsXr9Wp1YstWMdDpdNqgqbKBrRocq5MuBHuoNWSBKgXQxjK9rWUlJycH9MgaDAasVqs2AYSa4lGfFQc8Hg8ZGRlaAKrT6XA6nYSGhtbJBBEul4vU1FSt2oLVasXpdJKfn09SUhIejyfoQLjw8PAaTxAiyvB50BVkoMs9TtK+Xfyd4aVtv6ENHhOVJcHxGapnz57MmDGDefPmMWXKFK655pqASUB2797NjBkz6NGjR8B633zzDQaDgbPPPpsDBw7w5ptv0rFjR4YOHQoUT6SxdetWzj33XJo0aYLL5WL16tUAnH322UBxHeV169Zx3333cf3119O1a1eMRiMpKSls3bqV888/nwsvvLBK+3HFFVewdOlSnnjiCSwWi9YO1aBBg3j//fd54oknuOqqq8jJyeHdd98N+sXbvn17NmzYwPr162nevDlms1nLDS5r2rRpTJ8+nTvvvJPbb78dl8vFypUr2b9/P08//XS1f2CqctyEEHVPDXhdLlfAzGAmk0kLagsKCsjJyQmo96rT6bSR/GrFhMqCqdIX7hVVdVB7lisLoNU2hpzgO8dut2vVBup76uCyfD4fWVlZAelnoaGhRERE1PokIcFmidPr9URGRuLz+UhOTi7Xi6721JtMJpxOZ61X3ThdVTSHQ+LRo+zf+xsd4sJobnVhSN7N0o8+5a4l2/ArNGhZ24pIcHwGu+666+jatSvvvfceL7/8csD00W+88UbA9NGq2bNnk5CQwKpVqwC0OsdqsBkfH8/mzZtZuHAhGRkZWK1W2rVrx/PPP8+AAQOA4i+e559/nmXLlrF27VqWLFmiDXDo06cP7du3r/I+tGrViu7du7Nz506GDx9eboRxv379ePzxx1m6dCkzZ84kJiaGq666ioiICP7v//4vYNnbbruN9PR0nn32WQoKCrQ6x8H06dOHV155hYSEBB555BF8Ph8dO3bk+eefrzCXujJVOW5CiMqpubSKomi9oOpDDWwrWy8nJ6fSUmUmk0kbrKZSx2XYbLZa71nU6XRar/MJlz3B606ns9zYh/pU0TG2Wq1ERUXVeoWLoqIicnNzy1W4UCfdyMzMDOhBVnur1YsgUT3l5nD49xzGX30ZS5cuZcYTc/D7FfQ6WDC6KcNbeLhrSRr+ktPSUGVtK6NTKsvCP43VdHTryTiZUbWi8ZLzevqRc3pqUXt7c3JyKs31LR1sqikOUDzItvTkCmpZR3UaXrfbXa7KUGhoaJ3d/q8JXVoa4fHxAc9l/fknSgUDmutL6SmKyx7jiIiIk6r44Pf7MZvNZGRkaL3par5w6fOlzhJns9nIy8vTeqz1ej1RUVHaxBsiCJ8H9AbQ/e+CoWwPceKRg/Ts3S/wb0SvZ/UTN3L5P9/VgmAAgw7eGh3F+JXlx+x8+umnDB48uM6/f0tPNFYR6TkWQghxyqmoJ1KdJczv92uD3ko/1OCp7BS4Op0Oh8NBWFhYudvoanpD6Z5GCaYqpygK2dnZZGZmBpQFregYV5fH4yEpKanCiyH1vdQKF263W6tlDMUVOKKioqRmcFleFzpXDrhySdq/h/1//UX7lk1p1rwZGG0s+fQrZjz5vNZDPO/xO2kRFV5+Dge/n12bPgkIjAF8ChxsOQ29bhZ+pfGWtZXgWAghxClBURTcbrdWRaBsT2RYWJiWWxtsXbvdTnp6ulZaTe1hVG+1V3Q7vTrpDaK4tzg1NVWrkWw2mwkLC6v0GFeH3+/n+PHj+Hy+gLsApSt5mM1m7b0KCws5fvw4iqLUeo3iU5rfB54Ckg7tY/9ff9A+zk6LMBO6nCTe+ehT7lq4sTgnWAevjOvD0F6tmfHEx/hLLnb8fj/3/ms+X9/aDL2Ocj3EPdu2QK/7Q1seinuUrz0vlIiQCcx4/j/4/P4GK2tbGflLF0II0WhVFhDrdDotveFEPZFq9Qi1QoOoG6Vnm4Pi2u+hoaG1WootOTkZj8eDwWCgS5culeaJ5+bmkpqaChTnh8fFxZ0ZvcWKH7yu4v/6veD3ofN7QfGBpwhdYRYUZbJ05RfcM2dxqZzgZgxv4eauhaVyghW4e+k2luT+HRDoQnFPsNtdyILLnNz1eTY+BQx6HbPumULvGy7npdjPmPFsQnEQrNcz97E7aNJzCDcPHMOFY+/hwMHDDVbWtjISHAshhGiUCgsLSU9P19IZ4H/TFDscjjoZBCdqRlEUcnNztVrvFc02d7LS09MpLCxEp9PRpEkTzGZz0OBYrWes5q7a7XZiY2NP/3QYTwG6vBR0WUfRuXNLgmMf+H0kHT/OvgOH6Bjup6U5n8TDB7ln9o8BQfBdq5L4z6jwoOkQaSG90Ou+Dewh1utwDHmUKzp0YdCUFA4fPUj7Jk6aR4WieNIYf+XFDLloCPtTcmkT343mbeNRSs5Bc1sUzVvUvOxpXZLgWAghRKPi9XrJyMggLy8PkIC4MVHrM/t8Pu2/Pp+PwsJCLUi12WzExMTUeg9tTk6ONhtrTExMpSXw0tLStOmenU4nkZGRp2VgnJiYyP59f9O+WRQtHKBL/5vkrV+wf+9OOkRQ/JzXxVu/ZHDHmmwtTeK1y8JoG2EIGgTviburfE6wXs8Fo69hXptO3DtnkdYT/NLM8ZzV3gkcIzTKTOu4s1BsUfhskSghTjA7aGow0TRI29VJWBojCY6FEELUG7fbHVBDuHSgqygKOTk5ZGZmagN8wsLCiIiIODNuhTdi6gC7rKysoBNlqCIjI3E6nbUe9BQWFmq90hEREdjtdgoLC/F6veTl5eH3+7WHx+PRJkyJiopq0BJ2tSUxMZH9f/9Ju9YtaR4Xhc7rYul7y5jx2L9KBsfpeOXmXuizDnHHZxkBQfCw9mYtMIbiHuJpn+fy9vRb0eveKpcTPO7iUJqGT2DGc//5XzrEkzNo07E9bdq1ZOg5fdh/9Bht27SheZv2+CwOMNpQTFYwWcFQcQUXdSBtdnY2BQUFREdHB8yw21hIcCyEEKLO+Xw+MjIytN48VemJNgoKCrSgxmw2Ex0dTUhI45ta9kyiKAr5+flauTRV6UlM1EdoaGitny815zw5ORlAqzxx6NChSoN0nU5HbGwsdru9VttTrxQ/uHJ55z9vMeOxZ7Qg+KWZtzC0X2dmPPY0fr86OE7hriXbodTAuOIgOI97x96LX3khYNN+RSG0dRwvzRzHjH+/878g+B/TadJnKGPPvYYLbwrMCVaPdpO2fpooftAbqfgMlNmVks9RdnZ2wEyP0nN8AsnJyXzxxRd8++237N+/n7S0NJxOJ3369GHy5Mn07Nmz3Dp5eXnMnz+fL7/8ktTUVGJiYrjkkku4++67y00GIYQQov4F6w22WCxapQi1tFrpKYQjIyMJCwtrtD+cpxN1Bj41wC19zIuKikhPT9eCGYPBQGRkZJ3VBXa5XOTn55ebCbDsMmp79Ho9oaGh+Hw+9Hp9wCMkJKRWJxapc34v+Lzg96DzFqEryIS8ZJIO/MmMR/9VqkKEwozn3uLtURFaYKxtAqBMmoRf8dOqqQu9Tleuhzi+e3cuuvwqLrrqZg4cPUab+K40b91e20TzFhHBc4J1+oC6x5Xx+XxabWn1XKpl9pxOZ6M9R40mOF66dCkLFy6kVatWnHvuuURFRXHo0CE2bNjAhg0beOGFF7jsssu05QsKCrj55pv5/fffGTRoEJdffjl79+7l7bffZvPmzbz33ntSqkUIIRpQ2QF1pXuDS9cOVlMtDAYD4eHhUjKtHqgD6NLT0wNmkFN7hPV6vXbedDod4eHhOJ3OOsn39nq9ZGZmlrurEIzRaMRut2O327FYLERGRp56E/a489EVZKArSAdPIXgL0fl94PeSeDyVffv+It6SRSuOceTn34JWiDDgL1c+TV9ywRIQBBv0XHz1GObFNuHeh5/A5/tf6bSmfUfgB5rFQLMutbd76sVuQUGBNmU3FF/MhIWFERYW1uj/xhtN63r06MG7775Lv379Ap7fsmULt9xyC//85z8ZOnSodpWRkJDA77//zuTJk5k5c6a2/Msvv8yCBQtISEhg+vTpddNYr6v4Kq+aFJcJ3BWXnKkWvRGMMt+7EKLx8fl8pKenawPq9Ho9kZGRASW9StcOlo6M+uX1eklNTdUmQtHr9VqvvqIoAb21oaGhRERE1EkwE2yiEDXoVWfWU9vldDq1GQlPuTsKilIcEBdmoMs9ji4nCcPxXcX/7y0qDo49hbz93X7uXPZ3uXzhcjWE9Xo6XPssz3Xay0PPvaKlRMx7cAJKSDj3/uulgCC4WXwvbo7vxUUjruLAgQNVKp3mdrvJyMjA4/FoaU/qw2g0otPp8Pv9AT386uQ6pavLQPFFsVpy8VQZTHtKTB89adIkNm3axEcffUT37t1RFIXzzz+fvLw8vv/++4AvVpfLxXnnnUdISAgbN26s8I+oxleaXhf6wz+hc+dVe1W73V5pPcbqUMwO/K0G1jhA3rVrF0uXLmXv3r1kZGTgcDho3rw53bt355577qmVNgbz22+/sXnzZm644QZCQ0MDXhs1ahTt27fnhRdeqGDt6ikqKmLp0qX06dOHvn37Bry2evVqnnnmGVauXEmzZs1O6n0aaqrhH374gd27d3PbbbfV+ra3bt3KnXfeyYIFC8oduzOBTB9dc/n5+aSlpWkzlzWmAXWn83mt6vTReXl5pKWl4ff70el0REREaAPWylahUPPB60JBQYE2IQsUp9pERUVhNptJT0/XepFNJhMxMTEV5jI3qnPqdReXUvO5wecunm3OUwCu3OKA+NivGFL3ok/9g8SsIv7O8NEh0kCLMANHc3x0mJ9Wrif443/P48/UAzz03Mv/qxDxwDjGjTwPnaKQmJrBvmNZtO3Sk2ad+6JYI0lMSqpyEFyWz+cjKytLm2I7GL1ej06nq3Sq9pCQEK2Hv7oXVjJ9dBWpB1b978GDB0lJSWHw4MHlehwsFgv9+vXjq6++4tChQ7Rp06Z2G+P3FgfGBnPxozpCHOCphSten7u4DX4vUP3g+Pvvv2fmzJn06dOHu+66i6ioKNLT0/n9999Zv359nQbHO3fuZNGiRVx++eXlguPaVlRUxKJFiwDKBXiDBg0iISGB6DI/HKeSH374gY8++qhOgmMhqqtsb/GJghpRv8qeH7PZTGxsbEDwq+Yd16WyZdbUPGa73U5BQQHJycla0OV0OomIiGjcvY2eouIe4LxUdHnHi//flVOcNlGUia4wC33WQfRpf6NTivfrre2FTPs8p6SHWMdjo4cR5WyGX3k7YNN+RUFvPMLtl3XnsnNeYl9KHu3atqN5i5b4jWbQG2nS2kicyQbW8P/lCjdvXu2gWE2zycjI0HrrbTYboaGheDweLf3J7XYHDITU6XQBMxNaLBZsNlujuBg+GY0+OE5KSuKHH34gJiaG+JKr4kOHDgFUGPi2bt1aW67Wg2OVwVxcsqQadCYrmCq+0qoWn/vEy1TgnXfeoVmzZsybNy/gim7YsGHcddddtdG6Ri8iIqJKV4+nC0VRcLlcEqiIOlFQUEBqauqpFdScYVJSUrQ0ivDwcCIiIuo9PUFRFFJSUrQ7qGqqRH5+PkeOHNE+P0ajkdjY2Mb5faUoxb3DRVnFk23kHkefvAdD8k702UfQFaSj8/6vGsPRHJ/WQxwW2YYthT2Y9vlbpSpKKPzfqg08d/+LQQfNte15Lr7WnWnSKZwmpuLjUdUKEVVVdmyAyWQiKioqaLqToih4PB4URcFoNGq9yKebRh0cezweHnzwQdxuNw888IB2JaJecVZUkUJ9vrLk/poOLFBcJvx2O4Q4ioPdanKEnnwVDcVjgCIFfXg4Okv1t5eXl0dUVBQxMTGVLvfoo4+yYcMGNm7cWG661fHjx5Oens6aNWsA6NSpE2PHjqVHjx688cYbJCUl0bp1a+69914uuugiAObPn88rr7wCwJgxY7RtLVmyhAEDBmAwGDCZTOzcuZO5c+eyb98+mjVrxuTJk7nmmmsC3j81NZX58+fzzTffkJGRQWxsLGPGjGHq1KkYjUaOHj3KiBEjAFi0aJHWgzx69Ghmz57NypUreeSRR/jqq69o0aKFtt1vv/2WRYsWsWvXLrxeL82aNWPUqFFMmTKl0mPldrt55ZVX+Pbbb0lPTyc8PJw+ffrwxBNPaL3TSUlJvPjii3z//ffk5ubSsmVLrr32Wm655Rbts3j06FEuvvhiHnzwQfR6PUuXLiUzM5P4+HgeeeQRevXqBcDDDz/MqlWrABg4cKDWDnV/1PPRsWNHlixZwpEjR3jssce48cYb2bJlC/Pnz+e3337D7/fTpUsXpk6dyoUXXqhtR+3VV/MNz0Rn6n5XRK06UVRUpA2gU3uS1KDGYrHQpk2bRl0t6LQ9r97y42DCw8OhZH8LCwsxGAy0aNGiQcqb+Xw+9u/frwXGTZs2pbCwkKNHj2rLGI1GYmJiqj3Fc12dU6UkVxh3PrjyUAqzIT8NvzsfXfJe/Ik7IOlXKMwqt26RIYqFv/qZ+clerYf4vttuJzosptwAO7/ip3uvEF5//gmmPfQvLV/49ddeo+sFo+tk36D4M5GYmKilUBgMBpo1a0ZMTEyDB7wN/XfaaINjv9/Po48+yi+//MJ1113HqFGjanX7leXTVMqVhyEnEwrdYKreVa3d4SA/r/q5yuV4isDnwZeVBWZPtVfv0qULn376KY8//jjDhw+nc+fOQXOCRo0axYoVK1i2bBlXXXWV9vyBAwfYvHkzDzzwQEBe0Ndff8327duZNGkSVquVd955hzvvvJPly5fTvHlzLrnkEpKTk/nwww+ZPXu2FjQ2b96czMxMfD4fe/bsYdasWYwfP57IyEg+/fRTHnvsMSIjI+nduzdQPH3oxIkT0el03HrrrTRv3pydO3fyxhtvsH//fv7xj39gMpmYN28eM2bM4IorrtDaHx4eTmZmpvYFnZ2drf1QfPrppzz77LP07t2bBx98kIiICA4fPsz+/fsrzX9yu92MGTMGr9fLhAkT6NChA9nZ2WzevJkjR45gMBjIzMxk/PjxeL1ebr/9dpo2bcqmTZuYM2cOf/31Fw8++KDWHiiu3tK6dWstxeWNN97gtttuY+XKlTgcDsaOHUt2djZff/01CQkJWltMJpPW1i+//JLNmzdzyy23EBUVRUREBF999RXTp0+nQ4cOPProo5jNZlasWMHUqVN5+umnGTZsGPC/C8vc3NzGk89XjxpVHmMj4Pf7SUlJoaCgoMJl1N5ij8fTaI/d6XxedVlZhJd5LisrC6Xku91qtWK1WrULmvqg3rFyuVxkZWUF5KgeO3ZM+3dISAhhYWHY7XZ0Op02C15V1Mk59XnQ5aegyzpckh6Rgy4nCX3ecXR5yejT96EvzNAW9+jsHDUP5LhtAO6QJvgskaRnpzPzk5sCeohfXDibOQ+/jl6nD5x9zmCgWc9B9L+sOecMvyYgX7guPq/BqoOUHhuQlZVV6+9ZHZJzXAFFUXj88cf59NNPufLKK/nnP/8Z8Lraq5VXQaCpPl/rOa2KgnXFJAzHf6vR6n6g+n3NwfnC21DY7oIarXvnnXdy6NAhPvzwQz788EOMRiNdunThvPPO45prrtFupXTs2JHevXuzYsWKgOD4ww8/xG63B5TWg+LBkPPnz9eCzU6dOnHFFVfw1VdfMX78eGJjY2nSpAkA8fHxQQfCZWdn8+abb2rL9erVi19++YUvv/xSC44TEhLIzc3lvffe05br378/FouF+fPnc/PNN9O2bVs6d+4MQGxsLN26dav0mBQUFPDSSy/Ro0cPFixYoF019+/f/4TH86WXXiIrK4ulS5fStm1b7fmhQ4dq/37//fdJTU1l0aJFnHXWWUBxj6/f72fVqlXccMMNtGr1v3qSNpuNF154Qes9iY6OZuLEifz4448MGzaMFi1aEBkZCVDhvhUWFvLuu+8GzD40efJkQkNDefXVV7XzPGjQIMaPH8/8+fMZOnRog/cYiMbF5/Nx/PhxXC4XOp0Om82G0WgMyDNUb6+KM5s6+1npR0Vj/tVat2FhYRVOA13vPAXocpPRpe/DeOQnDMm70eUeK06fKFNA2KsLIdE8gCTbeeSHdSE36wiJx47QIs5OjM1GcsrBgAAYinuI2/eLZe68udx33334fD6tooSaI1yTfOGq8vv92mA79bzYbDYiIyMbbb3hhtLogmO/389jjz3GypUrGTlyJLNnzy73pavmFB88eDDoNtScZHW52nXqBw5Op5M33niD33//nV9++YW9e/eybds2Xn31VVatWsVbb71VfDsOuP7663n44Yf59ddf6dmzJ/n5+axdu5bLL7+8XD5S3759A27Xqb2VpXsITqRjx45awAvFt2lbtWoVsI1NmzbRp08foqOjA0oOnXvuucyfP59t27YFBKlVsXPnTvLz87n66qurHRx+++239O3bt9L33LJlC23bttUCY9Xll1/OypUr2bJlS0BwPGjQoIDbih06dACo1rHs27dvQGBcWFjI7t27GTNmTMC5MxgMjBgxggULFtRtnr445Xi9Xo4dO4bH40Gv19OkSZPGmQd6hlGD0MLCQiwWC1arlYYa/uR2uykoKNBmN6wsGA4LC8NqtWI2m8tNONJgFAWKstDnHkd37DdM+7/BcGw7uqLAu8sF+mgyje3JNLUn19KePEdnQoxu9P5Cvv7+U158+xX8ih+9Ts9dd86hXfth6HSPopTpIe4Y354LLzqfIUOG1LiiRE2UrSKjVgeRv+fgGlVwXDowvuyyy3juueeC5h21adOG2NhYtm3bRkFBQblSblu2bCE2Nrb2g2OdjsKrEzD8vR5M9gZPq+Akv1i6dOlCly7Flb+9Xi+vvPIKH3zwAUuXLuXuu+8G4Pzzz6dp06asWLGCnj17snr1agoLC8vlAANB5683mUwBU0WeSFW2kZGRwaZNmxg8eHDQbdQkZUa9hRMbG1ujdU+0Xk5OTkDQr1Lzvsu2uexxUK/qq3Msy1biyM3NRVEUoqKiKly2xulG4pTj8/koKChAp9MREhJSLrXK7XZz7NgxrXeradOm0rvUwNQpeLOysgJSI3Q6HfaCgnJpFSfD6/Xi8/nQ6XTaoCv1UVRUpAXEaik2lTp2xOfzaa8ZjUaaNm2KyWSqxRaeJJ8bXX4auqzDGA5uwnjoe/Spf2g9xC59GAcsQ8mw9aTI3hqd2YpZ7you1+b3YtPlo5hDSS4waoExFPcOv/Lqw3zwwXZmzZrL44/Xfw9xaV6vl7S0NC0lymg0atVBGsXFSSPVaILj0oHxiBEjeP755ytMyNfpdFx77bUsWLCABQsWBEwC8sYbb5Cdnc2dd95ZNydepyuuVGG0gLF6wbHOFALG6k8eUo6igL/6ucaVMRqNTJ48mQ8++ID9+/drz+v1eq655hpee+01pk+fzsqVK+nXr18d9cpXTXh4OB06dGDq1KlBX69JeTY1ByklJaVG655ovbCwMNLT08s9n5qaCqD11Nemsp9/tQB7sHakpaXVWTtE46HmgObk5JCfnx/Qy2cymbBarYSEhKDX60lJScHv92MymWjatGmjn9HqdOb3+8nNzS03Ba+aQ+z1egNmIqsptUc6Ozu70vzysqxWKzabDb1eT25ubkBbHA4HkZGRjefzU5RTnDd8bAemfd9gSNqGrihLeznV1I19tkvJi+hNiL4Ind+FhSJQfIAZxRaFYgkFsx3FEsrRHd+XT5/w+7BYDjBlyjhGjqy7HmJ10g29Xo/JZMJkMml32tUBtBkZGdrfeXh4OOHh4ZICVQWN5NMKCxYsYOXKldhsNtq0acNrr71WbpmhQ4dqPZ2TJ0/WBiP9/vvvnHXWWezdu5dvv/2WLl26MHny5PrehVNGWlpa0ABSTVMp+9qVV15JQkICTz75JIcOHeLOO++s8XurPQfV6QEta9CgQfz44480b948IG3gZN6re/fuOBwOVq1axbBhw6p1YXX++efzySefcOjQoQovGvr3789//vMf9u7dq+VCA3zxxRfodLoaTbSh7l9RUVGVbo1ZrVbOOussvvnmG+6++25tHb/fz9q1a4mNjQ1I7RCnD5/PR15eHjk5OQE9fepsY263G4/Hg8fjCRgMZbFYaNKkySlfs/RUpc4gl5WVpdWW1ev1OJ1OwsLCMBgMWmmtopOYz8vv95Ofn092dnZAj7S6/dJ1bdU2WCwWTCYTBoNBW79sUBwREdE4eovV6Zqzj2DY/w3Gwz+iT9+n9RK7dXYOWi7maNgw9PZwTEo+Vl0+iiUUv60lmEJQDFYwhZCadozEffto3qIdMSFOnOHt0On05dIn2rVrB9R+D7H6t5yXlxf0t03tuff7/dq5tFgsxMTENJo7P2rgnpubS0RERINUTzmRRhMcJyYmAsUDo15//fWgyzRv3lwLjm02G0uXLuWVV15h3bp1/Pzzz0RHR3PLLbdw11131f10pDWoM6x4DMXzqDfAe5d2zz33EBsby+DBg2nTpg1+v58///yT999/H5vNxvXXXx+wfGhoKJdeeikrV66kSZMmFaYzVEX79u0BWL58OZdddhlGo5FWrVpV64/j9ttv5+eff+a2227juuuuo3Xr1rjdbpKSkvjxxx956KGHiI2NxW6306RJE7777jv69+9PWFgYTqcz6EBAm83G9OnTmTVrFnfffTdXXXUVkZGRHDlyhL///psHHnigwvbcc889bNy4kalTp3LLLbfQvn17cnNz+emnn7jxxhtp06YNN9xwA59//jn3338/t912G02bNuX7779nxYoVjBkzpkZBqXosly5dyjnnnIPBYKBDhw6V/hhNmzaN6dOnc+eddzJ27FiMRiMrV65k//79PP3003Kb7TTj8/nIzs4OGICj0+mw2+3aQCh1pis1h7WwsBCPx4PNZiM2NlZ6mRqAoigUFBRo0/dC8d298PBwHA5HwDnR6XSYzWYsQVLSKqIGTuojPz9fy0XV6XSEhoYSFhYWEEwpikJeXh7p6en4/X7ts1JWaGgo4eHhDRsUq7WICzLQ5SRiOPQjhqStGFJ+L56xrkSyqQcHrMPIC+tJiLEICwqYQLG3RrFGFPcQlxpn9MXn7zB37r0lswvqmTjxRYZfejOPPvYis5+9P2j6RO3sjqIFxGWPuTqY0ePxaDMbqucy2LTtDUlRFK2msvq5LpuW01g0muB49uzZzJ49u1rrhIaG8sgjj/DII4/UUauC0BtRzI7iGeqqG6QWldRMrAWK2QH6mp2+W2+9lW+//ZYPPvhAK/wdHR1N//79GT9+fNCBZUOHDmXlypWMGTPmpH4s+/bty4QJE/j888/55JNP8Pv91Z6iODo6mrfffpvFixfz7rvvkpKSgs1mo1mzZgwcODCgSsljjz3G/PnzmTlzJm63m8suu4wnnngi6HavvPJKoqOjWbp0KbNmzUJRFJo2bVquKkdZcXFxLF68mIULF7JkyRKys7OJiIigR48eWs92REQECxcu5NVXX+W1114jPz+f5s2bc9ddd3HjjTdWed9LGz58OL/99hsrV65k8eLFKIpywumw+/TpwyuvvEJCQgL/+te/8Pv9dOzYkeeff/6kLnpE4xIsKDaZTISFheFwOMr1BBsMBm2qV0CbWrgx/KCeadxuN+np6VoQZDAYiIiIOOkAJz8/n5ycnIC61KUZDAZtUo6ynw9FUcjIyAgYk2AwGAKqlRiNRmw2W70HxYqigKewOOh156MryoX8FAyJ2zAkbSsOiL3/CyiL9JHsDxnK8dALMFitGHFhNfhQrLH47VEoFicYyv+2pqYmaoFx8fv6eeut+5l82xCGDhnPDddfXCfpE16vl5SUlIBeeYvFgt1ux+FwBKSrqHnear54TaZuritlP9elA/fGSKdUNLT0NHdSNfS8rpKpm6snPDy89uoH6o3Fec/15KWXXmLlypV8+umnQQfNnclO59qpZ6pT7ZwqioKiKNot1+zsbO1H3Gw2ExERgc1mO+OD3cZ8Xn0+H5mZmQFpLdWZaVCXlkZ4ySyyqqw//0QpSZNLTEwMuA1vMBgwm82YTCZCQkIqHKDl9XpJTk7W1nU6nURGRjb8Z0lR0OWlEFp0jIJDv6LP3Ic+6wi63CT0OcfQlRqX49I7OWI+l+O2gbjsrQkxFBV3dIWEodijiwPiE0zqtWP7dzzwwKhyz3/66ad11rGQl5dHWlqadrGq3jloFKkqVeT3+8nIyKjW51rqHJ+qjBag+oGpzuKo0aQdDWnXrl0cPnyYlStXMmrUKAmMhWhgXq+X7OxsCgsL8fv92qMsk8mk5fM1eCAjKhQsr9hmsxEVFVWrQVBMTAwul0sbuFWVPPKCggJtYKZerycmJqZx5Id6CjAc+h7z5jfxp/1JSJC7uEX6cI6YB5FsHUiRvSUhhkJ0ej0WswnF3gy/1QlmB1Utz9q8RfDc4uqWDa0Kv99PWlqaNmeDxWIhNjb2lAqKofy08nXxua4rEhyLSk2ePJmQkBAGDRp0wimUhRB1Rw2Kc3JyKqwlC8U9xeHh4RIUN3JqWbaMjAytAoXZbCYqKgqrtfrTRQW7QCrNbDZXeUCW3+8nMzNTS6NoNMGZ4keXeRDTT69h+nMtupI7uF6dpbgGsbED2eb25Fta47M4CTEUodMZCDGbwN4EvzkMxVKzlESHoxkTJ7/IW4vux++vu9zioqIiUlNTtc9EeHg4ERERp9Tfss/nIz09XQvujUYj0dHRdT8WrBZJcCwq9dNPPzV0E4Q4owULii0WC06nU5uZrvRDNH5FRUWkp6drqQoGg4HIyEgcDke1gyC/309OTg55iYlE1kLbCgsLSUtL0wZKhYWFERUV1bDBmd8LrlyMez7F/EsC+oLi0pPJph78HT2RQmMkFqMbveIFdJgMJowmC4qtOYoltDgg1lW/4kpqaiKJR/cTG9sORdeMSRNv5p67h3Dw4MFayy32er3a4MbCwkKtl9VoNBIbG3tKTdKhXvCpqSBQvdSgxkSCYyGEaECl84W9Xq82oEZ9lJ51zGKxEBERgdVqPaV6kkQxRVHIzMzUxp6oeaROp7PC4MHn81FYWBhQbUT9r9vt1vLLjSfoOT4Rn89HRkYGubm5QHHAHh0dXf9pFEU56Dz54ClC5y6AwnT0mQcx/vEFxmM7ihfRR7DdfiuFYZ1xOm3gVVAs0fgtoWAMQTFZS9Ifa/43UrYyxcyZL3Lp8HEYjS1o0aLFSe2imkqTl5cXUDoP/jetdlRU1CkVUJadbMRkMhETE3NKBfelSXAshBD1QC3Yr/YOlS27VBkJik99ZasOVDY5ht/vp6CggLy8vCpNxqHOelaZwsJCCgoKylWY0Ov15Ofnk56ern0WQ0NDiYyMrN/61oWZ6I/vxnhwI/rsRMhPRZ+fgi4/HZ1S3C4FPX+FXMahsJHYbDrM9ih0zeLxeXSgq71AMlhlihdeuJ9x4y4+6d5in89HcnJyQPUJs9mMzWbTJuE5lf7G1UA/MzNTu4CLiIggPDz8lNqPsiQ4FkKIOlC6FmxBQYGWQ1gRnU4XELSYTCbtv2az+ZT+oTnTFRYWkpKSok3HHBMTg8PhKLdcUVERubm55OfnB+QQm81mLVBVAxBFUdDr9TgcjuLax0FmviwtIyMj6KQROp0uoNxfvfb2KQoUZWE4sgXTzmUYjvwcUGVC5dWFkGbszB77DRjDnFitofidLVBsUeisTvDm1mqzEo/uL5fD7fP5OHDgwEkFx0VFRSQnJ2ufg6ioKOx2+yk7yU5RURFpaWmNdrKRkyHBsRB1TB1kkZubi9vtxm63V3obVZzavF4vWVlZ5Obmlhs4FxISgtVq1aZ5NRgMGAwG9Hq91BU+DSmKQlZWllaWymQyERcXVy54qKiOcGhoKA6Ho1aCjejoaPLy8rR0HXXSCEVRtPSOeuvtU/zoCjPRH/gO02/LMBz/DV1JFYhsYyvSjZ3INbakwNSMInMsfpMNs8GDxRSCEtYcvyMODHU3ODA2rnYrUyiKQm5uLmlpxbnSFX0OThVlyw42tslGaoMEx0LUEY/HQ25urvaDpHK73WRlZeF0OnE6nQ3Sa6DWw22Iov2nq2BBsdFoxGq1ardM5YLozKDOcJedna3dPg8NDQ2aR+r3+0lNTSU/v3iCKIfDQWhoqHZ7XZ2aWa/Xa3cVahKAWCwWbTa10u/t9Xq1i7Q6585Hl3sMwx/rMP39JYa0P7WXjpt68adtFD5Hc8wmL6AHgwmzwYhitoM5FJ81Asy1nwOtDrxr3qIdDkczFJpx//0vMnfuyc96V7Ysm91uJyYm5pT7LlDvhOXn55Ofn699x6n50adq73dFJDgWohZ5PB4KCgrIz88PyCnT6/XY7XYsFgvZ2dl4PB6ysrLIzs7WpmqF4h9VtW5t6VudRqOxwi8fdTCXz+erdDlV6dqTWVlZNG3a9JTtwahP6kA5oFwvb05OjjaQCYp7iMPDwyVH+AyiKAput1u7IFZvy+t0OqKjo4POBObz+Th+/LiW7hAbG6ulW6i9jRkZGeXy0tXZ6QwGg/adoU9PJ7yabdbr9XX/t+/zoMtPQ3/oB0x/rcOQuK14wB3FOcRHzIPYZ78MnT0Ck8WI3hqJ3xoOhhAUowWM5hpVmqiqclNCT36RibfezKXDxzFhwsnNeldQUBAwVXJkZCROp/OU+U5QL/LKBsRQ/LsUHR1do7KDpwKZIa8GXC6FKoyhKSc8PIKsrNqZ9cVgAIvl1PgDO50pioLJZCI5OZmCgoJy88RbrVZCQ0Ox2WxaT4H6hZOVlRU0B7Aier1eC5R1Ol1ARQOVOtI5PDy8XI+w3+8nPT09IIiD4h9aCZADlZ6hye/3k5WVVaXZLUNCQoiIiDjlBtWcKepi5i23260NnitdecBgMOBwOAgLCwt6d8bj8XDs2DG8Xi96vZ64uDgt0CgsLCQ9PV3bnpp64/V6K6xxbczMpOewYQHPlZ4hr94pCrr0vzFt/Q/Gg9+hz0/RXnLpnRwwX0ii7QJMDisGiw3FHoPfHlWtiTmguEe+7HdaVaWmJjL2pl4B+cV6vYEdO7afVEUKj8dDenq6NpjSYDAQGxt7SgWSRUVFpKSkBPy+qJ9ptaOnrr7jZIa8U5DLpbBtu0LJHbBqsdtd5OfXzrWI3Q59ep9cgPzXX3/xwQcfsG3bNtLT0zEYDLRs2ZJhw4Zx5ZVXnjKz4Q0cOJBJkyZx22231cpyZak9QqVLbJX+d7C8UpvNVm7ee5VOp8Nut2Oz2SgsLCQrK4uioiIt71StV6sOlPF6vVp1A5fLRU5ODp999hldu3ala9eu2nb1ej1+v5/c3Fxyc3Ox2+2Eh4djsVjKfdGFhYURHh7O8ePHcbvdHDt2TALkIMrWfFWDHLX8mvpvtZrEqVq2SFSdoii4XC7y8/PLXRDrdDpsNps2yMrtdmspEWqOuV6vx+fzaTPPGY1GmjRpgtlsLhdU6XQ6IiIiCAsLQ6/Xa73E6nePOrBLr9djaEzpUbnJmDe/hmnPJ+i8xXfQfJhItJzNEfN5FNnbEBKiwxISihIah88aCYbqzzp7soINvPP7fRw8eLDC4NjtdlNYWBgwaFbt+Ah2IR0WFkZERMQpk3agVp/IyMgA6i8gbmwkOK4mnw/y88FoAnM1v4vsDj210U/v9hS3oSa916qPP/6Y559/ntatWzN27Fjatm2L1+tl7969rFq1il27djFnzpyTb2wjkpCQQGxsbJWX9/v95OXlkZOTU64WZWlGo1ELiEv3EJ+I+kNalVmD/H6/FpCnpaWxcuVK7HY7Q4cODUilKCoqIisrKyA3zGKxaD3URqORmJgYrQejadOmHDt2TALkMnw+H6mpqQ1f81U0CLWUmpqupKY6+Xw+3G53uTQHi8WiXQh7PB5SUlKCbbYcs9lMbGwsbreb9PR0CgsLtdeCBVU6nU7LDy6bP6wrtW6DceVh/iUB06/voXMV/+3kGFvxp3kEWbbuWOxm9BYbFlsU/pDwGs9WV1uqMyW0x+MhMzNTyx0uzWAwYDKZ8Hg82mfDarUSFRV1Sn2fqt976sXZqZofXRskOK4hswlCQqp3BWUN0eH11MZVl4K3fLWbKtu5cyfPP/88/fv357nnngv44x0wYAA33XQTP/74Yy20s3Hp1q1blZbzeDxaDmnpvEH1B7DsIzY2tkq33E+GXq/XBtSoPVVms7lcT6XVasVqteJyucjKyiI/P18LjB0OB9HR0QFfdGpKxZkWIJfO01bzu0sHQEeOHNGOc4PUfBUNxufzkZSUVC5FqjS9Xq8NtFQn4iibIqUGsOodndJBtt/v115LTEwMuPvUqIMqvx/d8d/Q5yQVz1rn9xZP4ez3o8tPxrTzI232unxDLLvM15Dr7IE1zEaINRrFGo6vgQPi0sLCmjFx0ou8tbjiKaHLVmaA4ruDiqJoFT9K1ys3Go1ERUVhs9lOqV7WsuUGo6KiTrr6hNvtJicnR7t7ov6GqY/GfHwaxydU1Ku3334bgEceeSToF7DJZOL888/X/n/9+vV89tln7Nu3j7y8PJo0acL555/PxIkTA3Kopk2bBsBrr70WsL2nn36abdu28fHHH2vPrVixglWrVpGYmKjV/bzwwgu1bWRmZrJw4UK2bdtGcnIyISEhtGvXjttuu41evXrVaL/LplWsXr2aZ555hldeeYV169bxzTff4PV66du3LxMnTqSoqIglS5awc+dOQkJCGD58OHfccYfWQ5SUlMSYMWN44IEHyM3N5eOPPyYzM5N27dpx55130r9/f+29jxw5wttvv82vv/5KamoqYWFhxMfHM23aNDp06BDQztzcXBYvXszGjRtJTU3F4XDQuXNn7rnnHsxmM2PGjAFg0aJFLFq0CIDLLruMJ554QtuGxWIhLi5Oq5ih9mwHEyxAjoiIwGazBU0LOZWo+d1qnWH1R6wqE2+U7WUXpz+/38/x48fxeDwYDAZCQkIC0iHUgXAhISFajVc1iLZYLFitVu2Hv6K/HZfLxfHjxwMG7BqNRq1ecWMJihMTE9m/fz/t2rWjhdWNaddHGP9cWxwYV6JIH85u8xgynf0JcYZicTbDZ40GQ+P6LvH7FdLSYPz4m5l+9xAOHQqcEtrn85GdnU12drZ28RISEkJkZGRAp4TP58Pj8WifA7vdfsr0tCqKot1lVO+SmUwmYmNjy92ZqCq1ukpOTk7ABaN6nEr3vFssFqKiohplOlrj+rSKOufz+di6dSudO3cmLi6uSuscOXKEc889lxtuuIGQkBAOHTrE0qVL2bNnDwsWLKh2G9avX8/zzz/Ptddey913341er+fo0aMcOHBAW0a9Sp80aRJRUVEUFhbyzTffcMcddzB//nz69u1b7fctS+0V/te//kW/fv246667OHjwIMuWLUOn03H8+HGGDBnCTTfdxC+//MLSpUuJjo7mpptuCtjOu+++S2xsLDNmzEBRFN555x3uvfdeXnvtNbp37w5AWloaTqeTO+64g4iICHJycvj888+ZNGkSS5YsoXXr1gDk5+czZcoUjh07xrhx4zjrrLMoKChgx44dpKen0717d+bNm8eMGTO44ooruOqqqwAIDw8Puo8mk+mEM2dB+QC5dD1ONfUjJCREm+K4dM6joiha/d7G0ruqBsWZmZmVpsSoQU/ZfG+n06nVIhZnBkVRSE5OxuVyaRUm1OC4dA+Xz+cjLS0tIOVGnczhRD1hRUVFHDt2DEVRMBgM2O12HA5Hg/ailQ6C1cBw6dKl3HtvcQUHvQ5evSyMib2LLxJ9mCgwxOBHj4IB0OPX6fFjJMnYh5SwQVidoVhCm+J3xIKhcQT7ZaWkQkw0dOygIySkBS1bFucYBwuKK5uhUk1zaYwBXjClS7IVFBQE5FwHu7tYGfUOnDomR82xL71Nm81GWFiYlquvPtQxNAUFBY3y2ElwfIZRB381a9asyutMnDhR+7eiKPTo0YM2bdowbdo0/vrrLzp27FitNvz666+EhoZy//33a8+V7mUFaN26NQ8++KD2/z6fjwEDBnDs2DGWL19+UsGxmt+XXjKjVK9evRg7dixms5nzzz+fo0eP8t1333HPPfdw4403AnD22WezefNm1q1bVy449vl8vPzyy9qV9oABAxg9ejRvvvkm8+fPB6B379707t07YJ1BgwZx4403smrVKmbMmAHAsmXL2L9/Py+//DJnn322tvxFF12k/btz585AcdmnqqaKVIXBYKBZs2ZkZ2dTUFCAy+XC4/FoPxSVUS9m1N4zm83WID/4iqKQn59PVlaWFhTrdDpCQ0Mxm81afrb6qKh9dT1aWjQO6mBbNQ1JHbCqBsrwv5kL1V5jdfpvqF7KTWFhIcePH9cuJps0adLgF18BQbBez9y5cxly0UXce+8M/P7iwNCvwJ2f59Avvivu6IvJsvfEEmpFrwNQQAEoCYb0JkJCm+ALbQLGxhfwqPWMQ8PaERnVjE6ddVp6pNfrJTs7m5ycnIAympGRkadcikQw6oQ0WVlZAWk8BoNBG0Be+i6ZOljc7XZrHQdqCUu1/rbb7Q5aPcVoNBIaGkpoaGjAHRR1zIY60Nzr9da4h7quSXAsTigxMZE33niDLVu2BMyfDnDw4MFqB8dnnXUWH330Ef/4xz8YNmwYPXr0CNrzuXLlSj7++GMOHjwY0Pun9rLWRGFhIUePHg147vzzz6dly5ZaJYJ27drx3XffMWjQoIDl2rRpw+bNm8tt85JLLgn4A7fb7QwePJj169drBeS9Xi/vvPMOa9eu5ejRowHlcQ4ePKj9+8cff6RVq1YBgXF90uv1REREEBERgc/n06Y+Lt3DoAYJ6kO9NefxeLRegaysrHovX1S2pqhOp2vQiVZE4+bxeEhNTQ1IbyhNrRaj5paWzkGubo3XgoICkpOTURQFq9VKXFxcgwfGiYmJWmAMxT2K9957Lwtv6KQFxiqfAt8YRtGn3SAstigUsx0fOtSgWKcooCgoehOYTzzAuCGUrWf85JNzufiicVpOcenJe8xms5ZadqoHxVB8blNSUrSBdkajEbvdXq4ChfpdrnaiVZXJZNIe6riXyo6bTqfTlm+sJDg+w4SHhxMSEkJSUuV5Y6qCggKmTp2K2WxmypQptGrVipCQEJKTk3n44YerVadXdemll+Lz+fjkk0945JFH8Pv9dOnShSlTpjBgwAAA3nvvPV5++WVGjx7NlClTtADnjTfeCAgmq0r9UlD/4K1Wq5Zu0KxZs4A/UvVKV52Yo/TzwW7RRwepIxoVFYXH46GwsBCHw8FLL73EihUrGDduHL179yY0NBS9Xs+sWbMCjmFmZiZNmjSp9v7VBbWEj8Ph0G6fVdbb6vV6KSgooLCwUOtdU/OX63JaWp/PR3p6upbLptfrCQsLk6D4DKYGtaUn1FFTbdRSXBkZGeV6vdTeLrPZHDCQTk0hUmsSOxyOKge3+fn5Wi+0zWYjNja2QQLjxMRE9v+xh3bt2tK8RUv2//13kDJmfqyFSeh1xT3GKr1ej6PNEHwx7UhLSyLxr+00b9GOmJjiNIzGPllCamqiFhgDKIqff/3rPi6//FyMRqN2J6Cy9IlTlcfjITk5WfvtiomJweFwBOxfRbX3w8LCtElpSv8dqVOOm81mTCbTaXOsSpPg+AxjMBjo168fP/74IykpKScsbbZlyxZSU1N59dVX6dOnj/Z8sKLrFoslaJmbYLfkR44cyciRIyksLGT79u0kJCTwwAMPsHz5cpo2bcratWvp06cPDz30UMB6apBbVR6Ph4yMDG1qVr1eT2xsrFaHtDao+bmlpaena1fRAOvWrePSSy/VBhyqsrKytC8fKL6dX9UyUPVJvbVcGaPRSFhYGGFhYQFTpmZmZlJUVERMTEytD/DLz88nLS1N+3E71WqKitqjKAo5OTlkZWVVOOCysk6BqKiocrXd1Rz0mvZw5eXlaX/Pdrud2NjYBgkkli5dyr0zZuBXFPQ6WDCmFed1aVkuCDbooEPHvvzflCY8/uYH+Px+DAYD//jHi8Q2b8f777/DW4vvQ1GK0zDuvXcul152c73vT3UFq2esjr/p16+fdifgdJm8x+VykZ2djV6v12ZrNBgMxMXFlRtMqJYrLX3HLTQ0lPDw8FN+QPbJkNEmZ6AJEyYAMGvWrKDlirxeL9999x2A9kVRdgR16coTqqZNm3L48OGA3tXs7Gx27txZYVusVivnnnsut9xyCx6PRxuUp16VlvbXX3+xa9euSvdNTfrPzMzk6NGjHDlyRAuM4X9XwrX5Bfjll18GXG3n5+ezadMmevbsGRCkld2f77//ntTU1IDnzjnnHA4fPsyWLVsqfD/1h7omvfb1Rb0IiYmJQafTUVhYSGJiYkAd15Ph9XpJTk4mOTkZn8+HyWSiWbNmREdHS2B8BnK5XCQmJpKenl4uMC5dbaIi4eHhtTbpkZr3npSUpAXGDoejwQJjLX1C+V8O8V0rD2PL+YPXLgvDUNIkgw6evnkkbUbextT7ZrBj+1Y+/fRTduzYwfTp42jRPIm337pPqwns9/uZO/c+UlMT632fqqtps+J6xqXp9XpatmyJw+GgefPmp01vcWFhIUlJSVrQW5xGUpxipv4GuVwuUlNTOXz4sJaKpi7TqlUroqOjz+jAGKTn+IzUvXt3Zs6cyfPPP88tt9zC6NGjadeuHV6vlz///JOPP/6Y9u3bc95559GjRw/CwsKYM2cOkyZNwmg0sm7dOv76669y2x0xYgSrVq3iqaee4qqrriI7O5t33nmnXAmxWbNmYbFY6NGjB9HR0aSnp7NkyRIcDgddunQBYPDgwSxevJiFCxfSu3dvDh06xOLFi2nWrFlAvq5KHUGuluwqrXQKRV18+RkMBqZPn86NN96I3+/nnXfeIT8/P2AmvsGDB7NmzRpat25Nhw4d2Lt3r1blorTrr7+eDRs28OCDDzJu3Di6du2Ky+Vi+/btDB48mL59+2K322nSpAnfffcd/fv311IIqjPIsr6EhoZisVhITk7WpsstPZFG6ZnmQkJCTph+oZamU7/0oTiwCQ8Pb/AcTlH//H4/GRkZ2oBQvV5PZGRkQDktt9tNZmamdtfJZDIRExODyWTSarrWRu6joijk5eWRlZUV0OngdDqJjIw8qe+eYBUlquLDDz8krlu38r2mCvxiuIArLg2jX78U/sw00K73YDr16Yk/uiOKNZzmQPOW/xvfcezYgaCzySUmHiAmprk22K10ukXDUdDp/BQnfPgxmaO5Z8YcXn7pYfx+H3q9nscee4zu3bsH3Lk71RUUFHD8+PFyzyuKQkZGBpmZmRiNxnL582FhYVqqnygmwXENuT1Q3Uwro0mhqOjks7PcJzEBiGrUqFGcddZZvP/++7zzzjukp6djNBpp2bIlw4cP55prrgGKv9hfeOEFXn75ZZ566imsVivnnXcezzzzjNYDrerZsydPPPEES5Ys4cEHH6RZs2ZMmjSJH374gW3btmnL9erVizVr1vDVV1+Rm5tLeHg4PXr04IknntDmPL/lllsoKiri008/5Z133qFNmzY89NBDfPPNNwHbUnOIc3JytB9InU6nVUyozfSJiowdO5bs7GxefPFFMjMzadu2LS+++CI9e/bUlrn33nsxGAz85z//obCwkE6dOvHss8/yxhtvBGzLbrfzxhtvkJCQwCeffMKiRYsIDQ2la9euAbnNjz32GPPnz2fmzJm43e5ydY4bE7PZTPPmzUlPTyc3NzegJ780tbxQTExMwABHNR8uJycnoOfZbDaXW1acmtRpz9W7IaXrUasBWdnJd3Q6HdnZ2VpPscPhIDIyUuvxKioqIjMzM+AzExMTExA418Z3Q7B0Dp1Op120nmwPXNmKEi+8MJcLLxrLL78ksePXfXi87cnJbUbWn0msLbPuP/7xD95Zt07Ln1YZDHrOGjMJW1Qo7V3ZtPe6UCLb4Xe2AH3wY9KuXbty29HrDRiMbfnkk6UseOU+rY0NkW6h03kxGQswmQpJTz/I0aOHadmyJXFxcTjDoF2bixg29FOOHDlC+/bt6dGjR6MeEFZdubm55e5ERkZGYrVatdlSSw8sdTgchIWFNfrJOBqKTglWh+MMUNMyTS6XwrbtChX8vlfKbrdXGBhUf1vQp7cOi+XM+1ArihIwTbJKrRlqtVrr5QpYnQTkwQcf1CbmEJVTB0SpX8alywJlZmZqP7zql7bb7SYvLy/gVrnVaiU0NLRKdWVrSkq51Q91Bq3SlQKqS52GPSQkRBswWvZCyuFwEB4eTlxcXK2eV/X2tJpKZjAYcDqdhIWF1eg7qGwP8Z9/HuWcc3oFTG8MBmKb/IOU409TXC1CT9MWL9LEEM62Q7cEbC8GWPzppxw4cID77rtPG1T74osvMm7cuP8tqChQhb+lpUuXBmxn1qwXad/+Iq69NrCNer2Bd9/bXks9yAo6/KDzo9Mp6FAC/m21KSj+bAyG4nPw8ccfM2vWLC1Qf+SRxxgzZgwGQ/F3jd1uJyIi4pQJCBVFITc3l9zcXK02ts1m0y7s/H4/qampAbGFzWYjMjIyIJVPLVvo8XgaVU36YOr6+1fthKuM9BxXk8Wio09vqMIEW+WEh1vIyqregLKKGAyckYGxy+UiPT09oMyMOnjgdOoFOF2pE4qU5vV6yc3NxWw243K5tJ640gwGg1ZJQM5zw/F4PAG9uupDLVFms9lOGBSqObk5OTknLBelTkIDxT3BweqqqtsL1vFQV98N6sWcOthYLYEYFhZW46CrdA+xTqenZ+8XycpuXSYwBvCRcvyf/O/OpZ/jifczYdL7kBC4pEGvp23btgwePJghQ4Zw4P/ZO+/wOKqz7d8zs0Xbd6VVWxXLki33CsY23aYYXkqAEEISAwmkv/AmQBISviQkQICQYBJII5QUeu+YapppBhcwuHf1tr2XOd8fR2c026SVLKv5/K5rkdkyO21n7vOc+3mevXvTusApFLjOF110UdZy3nnnnax1VNstBoNGE4JeF4QgpCAIsurvAB+UqL5va/Mowpiuh4ybb74JF154waDsKGMBJorV9beBvqR01oUxEoko28tyPXJ1QxUEQeneyBkYLo6HwFBFqckkIB4//ATtcKGuFQpAmbbkYml8Eo/H4fP5clY+UaPX65WWreMl2jPRiEQiStWRfLDjyAZAbLqWlUCMRCKIRqOIRqM5o8RGoxFOpxPhcBihUEipnZ1Z7UYURaUjoyAIaSI9mUxClmXFv34org3hcBjd3d2KYDGZTCgpKTko+8QXXzTjxz++UhGZhMjYtOFq1DWsBs2b7xOfgiBmiVFCUliyJJoljm+44QZFFFZVVQ2LQMxcTkNDQ067RVXV5EEtV6fzw1DUk1cIEyKAEAGAAEJEEAgAESBKBkQiWiSTBuzY0ZzTF713795xI45ziWI2I8FaM6tryjPGSmOZiQIXx5xxgbokUlFREcrKykY9m9blcuHDDz/kU/CDgFliWBc+hk6ng8FgUBouqAVULBZDW1sbACqU2RS6Xq8f8EaQSqWUCCVrXqLVapW//dVtHsuw+rvMe5sPdRttQogSfS9kSpUdq0xRrNFolG5ZrJZwZmRroJKLrDwau7lbrVaUlJQoXl2r1YpUKpUWEWbNBXQ63YgdMzYVzbroqQWJRqOB0+nMGaUbCGafsFgn47XXXXjs8d05I8QXnB9GKrUKt6+6GrJMrQzXXvtr/O53v83wEEtonJrdHOkrX/nKIa9BXFVVhdtvv12xW4iihG9dehuMxsIThPU6LwwGeg2Nxc1IJoyQiQhCJCqEiQQg9zG3WCxIJOjArKo62xctSRImTx6cUB8J2GAxcxYmmUwq1z5JkmC322GxWCAIgjJwzET9++EMD1wcc8Y8Pp9PafU8mrVCOUOHZUurW7OqYQJEjSiKSma1WigzcSIIgtKkJDOqzCKOhXpZM9ujdnZ2QpIkZRpyIBGaua1MTDERqNVqhyWiw6JKbrcbsizn7XQF9LVJV3tv3W433G43TCYTrFZrWs1TJrhZ0k4gEEjLai8qKoJOp8savAwGrVYLs9mMeDyu3OSLi4ths9my9q8kSYpQHklkWYbf70coFMrbHtdms8HhcAzpmKrtE8wvbDYvR2aEWJQkfO3CekyadDy+eclJaVYGp9Oe5SGurKwc+kYfJGq7RV1dHSJRF3buBGRCEI209lPFgqBI70FREZ0diEZtiMYcyCeEB6K0tAqXfXsV7r2nbzCxatWqMRU1TiaTSmWlfKhFsSiKStMadu0TRVHp/skjxYcGnpA3gvAI4+AghMDj8cDr9QIYu6Njflzzk0ql4Ha7B7ROAFSgsunyzAghS8DMd0NhXcsMBgMCgUBWVNpisSgRzmQyiUQikbMkYD5EUYRer1dELquby/6qpznz1Z9WC2Wz2TzoiGMkEkFPT0/OLo0AlGQdnU6n2BIYzIIQi8XyNsgYLJIkKcerqKhIaZihPmaxWAyyLCt2ikzKyspGtJRWf79VNsvg8/nSIo9qr6ZOp0NRUdGQ7Rq7djVj8eLsBLtfXLsRRF6DP/zh6vxJcxm0tLSkCWahuxv2xsa093h37ADJ0cHzUEMIwd59BHfd9QDuuTtf0xACQ5Ebej3NL4hEHIjF7YP+LovFolxfYjECrw9wVbYi4N+X2189SmQObAGaKKrRaCBJUtqDdZ2Lx+Nwu93K9YzVIp7o3T/HQkIeF8cjCBdRhUMIQVdXl9Jx71C3ID4YDufjykRhLnIlSTH/sNoSw45pIRYHVvIrEAjkFYkMg8GgtEvPtVxmCVC3RGX/r9frlUjNUJqtMDHNBHkuQcrqbw+UIJOryyO7qbKI+0D7YiiwyL1a9IqiqFhgBts2NpFIIBgMKtVHysvLlQ6SI0Wu32oqlYLP54PP51OixFqtFjabDQaDYVCzBvkghOCttwl+c/272Lzp3KzXH374WaxYcVyW4B0MY0kcA0BzczPmz5+f5UV+5JGP4CytQpHeB50uCEKASLQE8fjQZgiYOCaEoLUNqJsEzJ4ljKl7RTweR3d3tzJA1Ov1cDqdeX/7yWQSHo8nLahwOHX/HAvimNsqOGMKlnnudruVyJ7T6RzxqVVOftgxCgQCBXe80+v1KC0tzeoSOFjU04mpVArRaFTxuGYKUOZtjsfjSiRajSAIeW806ilztU2CCV1ZlpUHi/Tp9XrFC50pqGRZVuwK0WhUKTXW0tICs9kMh8OhRCPZ97FoazgcVkQb81NmVvPIhDW2YIMQZhdRR6kEQVBsE2ovtjr6O5xotVo4HA44HA4QQkZVvDA/Nau7zfavTqeD3W4ftjKBLS0tWLduN15+rR5fbHEhEW9Apn1CkiTMnl0PYPiS5sYCu3fvzpkc53Z/gnq6uSAECEdKkUgc/OyB3w+YTUDdpNEXxuprRiwWQzAYVM754uLivFVN2OyF1+tVzslcZdk4hx4ujjljhnA4DLfbnVYz1Ol0pnVU4xxa2EUdQJoHVxRFJJNJ+P3+rLrDWq1WEYqZE1EDRUgOBmYjYOdHMplEJBJRHqlUKi05TK/Xw2q1pjWBKIThKIHEIsl6vR5msxk2m02JBrNoqsViUQR/pqhgqBtiMNuJ+gH02UhGWyD0x6FcN3YO5vqOaDQKt9uNYDCYZqvR6/Ww2+0wGo1DWrfM+sSyTPDH2x7A729hFShEVNWuwumnr8TpK1bhL3eOXU/scBCPx5WyfumRYxFVVXWQZREEIiKRYiSTB399T6UIgkFg9mzAYhnZ814thFm5wVwzOQaDAU6nM6clJxaLwefzpQ3U2CzbSM+ucCjcVjGCHM7T7/0Ri8XgdruVKKQgCLDb7eMm2WCiHNeBPK1qJEmCwWBANBrN8u7q9Xql5q064WskYTcstVhmMFuC1WrNG40ZqWOaq243AKUSBEOr1Sre3qKiolGv1DIWSaVS8Hq9StKn2goiimLawA/oS+hkLc6Hqz7xspNWweNdjo2fzEdagp0o4dXXNmLe3Cq0t7cO2T6Rj7Fiq1CX3Hz++edx4403KrMrP/zf27Bo0UqIYiva2w6+1XRXVwvc7nak5ApMneLCwgUCtNpDO/BKpVKKEGaR4Vwyig2ImQ2J+f7VywqFQvD5fGnWLb1eD5vNdkibHI11uK2Cc1iTmXAHHF6+qrFCIpFAT09PWtIHi/hkXvRZdzoW6QDoTcBkMik3gLFw7NTRXrvdjmQyiWAwCL/fr0TA/X4/9Hq90nFqsB7a4UCv16OyshKRSAThcBiCICASiSgibrjsKBOZTFHMYBHLTLsNO4cLaVgyEC0tLarKE7Q+8ZrXr0ZVzV1QC2O6PimEQ/sgSdUTyj7BIITA5/PB7XYDoNVNLr/8cpx//vnKQMBud2HVqvvxpz/lS9IrnNUvPYDbb+8blNxww+1YfFT+BMahkEwm0xJt4/F4zvwB9cwQE8S5vOqyLCuzWeFwOC2qzts5jy24OOaMCqlUCh0dHUrELNN3yTn0ZHb5AnIPTliyGkBvFp2dnYp4M5vNKCkpGROCuD80Go0yGxGJROD3+xEOh5WbntvthkajURpY2Gy2EVkvFoliPmDmNRzIm3g4oT7/Mp/PTKTT6/VwOBzQ6XTK4E5t+amoqFCSfIdCpn3isSeyfbVACiefDNz/n/FRb/dgIYQgmUzC6/UqCWQWiwVOpxOCIKQNBFpaWvDnP1+lVOuQZRm3334Vjly0rN8IcldXS1o5uK6uFkUY03WQcd11V+FLX1qOqqqqvOeMum19JrIsK9cDFhXOV9lFp9Ol5RhkDqzZ75rlJMRiMYTD4awZItb502q18tmgMQY/GpwRJxqNoqOjA6lUCoIgoLS0dETLOR1OxONxpdOSuioDu3izG4jBYEBJSUnOCCW76Pt8PqWZhCiKcDqd4+64CYKgCOBkMolQKKTctNQR5Y6ODqVsF3sczAAgmUwqCXbspqve/2r68yYeTrA24l6vd8DyczqdDg6HY0DPcOY+zRS7/aG2T4gitU8caMquTyxJEq6+8igsnH97Vi3iiRItzuXvZ+SrWw0Ae/bsyZmk11+raXWEmEWai0tqs5aTSqWwdetWaLXaNO9uLnJ59fOVdtTpdIoYZlFhZtNhwjcYDCIWiynt1fv7btYSndnODvfB71iFi2POiMFudqyhh1arRXl5OZ8yzgGriRmPx5UL80CdwdQ3epfLBa/XO6BvS6vVoqSkJM0Pxy746jJhTU1NaGpqQk1NDerq6lBaWjruIx0ajUapfCHLsmJtYJUvWBSJRdZZZNlutw+47YQQBINBpQvWQDWVWeTYZrPBbDZP2Bsmq9rByuXlK7HHknPVTUhywSpgDMWfmSl2b7/99rx1hTPtE7Is443XrkbjjI044cRVePed9AS76urqtMYYY6ne7mBJpVJKwhn7m+u4sJbd/dXvrq/P7mAnihKKDJNBCEF3d2u/EWIWab7hd6tzJvuZTKaCZgbyRZZZ7W61RUJtvWHtm0OhUEE1w1ktdPWs1OE+6B0vjO+7G2fcEIvF4PV6lVqtJpMJpaWl4yLhbqSJx+Po6urKqq+r9tGyKT0m0jJv9L/61a9w1llnAejzWGZGSwRBKKjRxjPPPIObbrqpIBHByBeRG0ykbiRhN1aTyQRCCIxGIzo7O5VoL2sa4vf7EQgE+i3Ez6wn/SXZSZKkeAyHo47uYCGEIBaLIRAIKM1XBtMJkE2ls/3CRII6Ese2l5Wwy2y8ws5nlmio1+uVrn7s3JckCQ6HI+8Mhfr7BkMusXvVVVdh+XI6Ld/S0oLdu3fD4ahHMlWF117NbZ84bcUeXP7DixCLnZRTBI9Xb3EikVDahvcXUWV5BqwJzEBktpqWJAm//e0qVFe58MgjD+Bf912VFiGurJyUM9I8uS6Mm266Cddee63y/muvvRaVlZUwmUwwm815gwm56psTQtJKH+baH+y3n7k+6siyTqdTBrqHqiQiZ2Tg1SpGkIlS1aBQUqkUAoEAgsFgWpZ4SUnJhPJSDtdxZR5KZl3o7OxEd3c3qqqqYLfbc0Y6tFotvF4vli1blhVFeemllzBz5sysqJrbTbDmTYI1a1qRTO7G/AWTMHe2Cc7SIDzudjQ1NaG+vh41NTXo6enB8ccfn+Wd3LBhI1JyFd5/vwXbd+zG3DkNWLSoCq5K4OGHH8gZkRtMpG60yTymrMSa1+tNa+Fqt9thtVqVKJbP50urUVoI6lbOhf4mWERfo9EotYsLFbXBYFCp/5yJumW2IAhp9ZzZg3UZHCpMROUrVwf0dQKz2+3DOoBmx/Xdd9/Fl770pazX777nWbz99j488MCVAElv77xz23xkVp9Yt24j6uurh239DobhqFaRSqXg8Xiy6mirxR4hRGlgM9Rjk9nsZPuOZhxzdHbDkOuvfxa//vXZWde2559/HuXl5ejo6EBzczMaGxvR0NAAURTTOmQya1RmMIEJZDawUw/u1CUs2T1MHTDQaDSwWCxK7XQe4Bl+eLUKzoQkHA4rCU9qTCYTbDbbqJX3GstkRotfeukl/OY3v0kTkl/96lcRi8Wwf/9+7NixA5WVlSgvL8fWrVtzRFdoy16z2YyWlhZ8+ulutLXXY/1GFzZ/Drh7HkBb81UAZDzxOBUAokjQcuBqADT7+5xzV6HSlR25SaVS+PIFexAKrVGWwUSE1boc27dcCSYiZFnGlVdehRkzZuSM1J1wwjIQUoWPP2mB17sbJ5/UgLq6gcXGSEegU6kUQqEQNBoN9Ho9wuEwkskk3G43fD4fJEnKWwJP7Vdk0dlQKAS/3494PK5M02o0GpjNZiXqlQkhBJFIBD6fL6v5CmvwoW7kkdnimv0u2TEQBEGp+cwsJJm1ofuDfSd7sHVkAwN1tzmtVgudTgetVgtJkpSIcjQaVawnTKBYLBY4HI5DatvJNb0PSPjdzQbs2913/gIy2pqvxvJTNsJZsgofvn81CElBFKl9YiwIY7YvU+Ew7P28z+v1IhKJwOFwZF2DWWMZr9er7BP1/lELSIBGUkOhEEpKSoZkaVFH1OPxOHbt/DRnhNjpbMa1116bNnN17bXXory8HKIoYtq0aTjxxBPR1taW1jiKkdnhkg0ihzK4MxgMsFqtQ66FzRlfcHHMGVb8fj+6u7uV/9fr9bBYLDCZTGO+ogGAtBtDIbBSP6lUKmsaTT31nGtaWR1djEajSpWCeDyuCGO2TldeeRWmz1iGd95+Ezff3Fe+6KJLbsWkScdBEEQlAxwABEHCQ4/W4+Zb/ouPPkwXsGbzcpWoBagAuEr5N103GU8/dTXqGlYjM+EIkJBMGnMs42qIeUpYffu7H+UU2ed9ZQ8ikXSRfcSiVTjnnJVYdCRQVtqKpqa9aSJ4JCPQbHo5l49Ro9Eo2ehq4aDRaJRIcD5frdVqhdVqVawNgUBAyfj3er3Q6XSKUJYkKWe0V6/XI5VKKcmW7BwbCEmSlO9X/yZlWU7r6gVAqRGsfgw2Wp0LZunR6XSwWq3Kb4UJ7kNNIunCWWevwrPPXA0gBUBCZfVtAELIPH+BFC5ZuRfHH38RenqWo7l5LxoaRtcWxHISfD5fX5dDjweufj7DfLKRSESxRLDjp26KwkSxehDFBjZscMOSfDs7O3MmkLLBeTgcRiQSUc4b5r+VJEkR5IlEQolCZ0aIa2pqcOSRR2Lp0qVKzkNFRYUS+WW/F/Vn1L8bdRJsrjJszALBfgeZbeQB2qGuv5ronIkJt1WMIBPdVhEKhdDR0QGAlviy2+3j5oKinhJnTUjYdHkuotEoPB5PzgieKIro7OzE3r17UVNTg/Ly8n6/u6Ojg1oZGqbCbJ6Dxx5/D39adW7W+6pq70HLge8iU6hOnb4RweAatDWn3+hzTQULgohrfn4zbrn5moL2y/KTn4HXuw8b19OImSBIOOOs2zB75iTcckv2Ol7z83tw6++/mybUAQl1Dauxb/dpWeue7/m+baKiWRBEnP4/q7Bk6XJc96v5acuXJAmbNm0CgGGLJptMJuzbt08pTcWe02q1CIfDOaPEB1N5hSX6sCQ+NWrRIAgCLBYLbDZbWrtptf83mUwqol39l4n2w7W5wK5dzXjppVZ89IkL+w9QGZmIt0IQ9mDG9HosWuTC5EmtuOii9Ol9dn6NFe9wMplEV1dX2nkiCAKKAgHMPPHEtPeqbRXNzc39NvhhFRiYJGAR/FyDoFzC1G63A6DNhDLzJQohM7fhhhtuwCWXXKIM2tg6aTSatHKMQGG1q1mpNnUb9cPxdzAe4LYKzoQhEokowlhd43KswzLje3p6lMgJIQRutxterzdLJMdiMXg8nrRpZ3WiFSEETz75ZNpF/tLLroeraiU2burBvr37YbHSYvhFRUBL84NY9+FPlBazLLKbK1pLA2rZUa3ysj044oiVSCaWIxLZA6ezHsXFLrS1vYud29LfT4gMZ4kmZ5QGQJYouOnGepSXH4eWluXYu28vGuono76+Cl1drbj11uw6riu/sRiuyr6EG1GUcM01t6G+YSGeeGIVXn2lT2R/6ZzbMLUxhD/8Pnub7LZ12LmtLzJNiIyXXrwan352V4bwphHob6z8BzZ/9ncQQoX0b36zCj/4wUXQaAZ3DhJCsGXLFnzxxRfKwIb5K1n76OLiYiSTScV+EIlElGYdQ81EF0URFotFaSHNWkrHYjHIsqxUsrBYLFkzMIIgKFE9Tp/lZvLkyYgnqrDuY4IHHngA76/tm51wVa/CkYtW4qijXDj+OBcqygRYrYBOV52VMHaoS7Cxa1AgEEAkEoFWq4XVaoXZbM4SeqFQCF1dXb0zR4KSrChJEsTeKkD5KCkpQSgUQiqVQiQSSZslY/5agNqAnE5nv/Y3URRRXFwMi8WC7u5uRCKRNKGshonRfC3mAWq9+drXvoZTTz0VLS0tmDlzJmpqavJ+v7oco91uL6hChSiKvBUzp2B45HgEmaiR41gshtbWViXLv7y8fFwI40QioVzYASruSkpKlM59TCwzYRKLxZRqGwCNjkciEXg8HjidTlRWVuLzL5qxfNkRWZHTsopfobP9emTaGzIju4CEE0/aCJA1ePvNPn/jNT+/DUcfvRxfOjs7aeWNNRtR5aqCKAKiCEgSfezZsw0nnnhczijYmjVrsgQAgKzn+rMr3H///Xnfn5lwAwDxOMHu3S3YuXMvGhomY/LkKvT0tGDBguxI3R//eBeuvPLbWd+58Mh7sOGTzOg5ExDp+3HazI0oL3fBbGmFXrsb8+c14OijXZg+HTAZxSzfciqVwt/+9jf89re/VQY2t956Ky699NK8+wCAYoc5FLBoMK+HWhh3330/fv7zK7MGm7mS6V55dSNmz6qCXp+9X3Odv7lQl51LpVIoKipSWqcPVPkjHo8rCcu5SoKx9tZWqxVarRbd3d2KCNTpdCgrK0ubmRtMQh4rq+l2uxWxysR2vhrFzLoTi8WUxE3mH2ceelEUEY/HlWtnrqpEbKYjmUwqFp2DObcn6n31cGYsRI65OB5BJuKPOB6Po7W1FbIso6ioCBUVFWM6e5clNbHkJIbdbk/LjGeePuatY9aHmpoaNDQ0wG6349FHH1W8r4IgYvrMVQhHJmH/nmy7ASAA6PupCYKE8758F558IlsA3n33s1i27Fj4/S1obt6XdoPuT5Cqt5G15VZPVRYiYAsVBYzBvj8XubZp+fLlmDdvXtZA4JVXN+Kdd97E7268CrJMBw5Llnwf77//16zlTqp/BvH4vqykweKSlUglHsD2rVcpkeaf/uwPOPaYOTjnnNPyTqmP1TJ0hyvseJSWTsbOXS48+3wrnnp8PjIHSfMX3oVNG7J/Z8899xyOPfbYIX9/LBZDT09PVsk+hkajgcFgSIuasgerHcxgMwcmkwnRaBSBQCDNP66enbLZbCguLs4SlEOpVpFMJpXqOMXFxWl+b+YbZp5dNouRuY3qesBut1uJarMmQYd6UDcR76uHO1wcjyJcHB88yWQSLS0tSKVS0Ov1qKysHJPCOJFIKNPfkUgkbVqvv85wABWa99xzD37xi1+obBKrQLAc9949H4V4aDOT5Rj/+Me9+OEPvzNof2N/gpQQgp6eHkX4OxwOhEIh7Nu3b0w3Isi1TYVEpuvq6pBMAkcemR1Rv/nm1fj5z08r2P9cVXMXWpqyRdSq259BKLQf1/06dxIgF83DQ679SAhBcwvQ3Q1EY0A8BkSjBK+++gD+/a+r0iLEOl3ugekf/3gvfvaz7N/Zxo0b4XK5lE5n7MHKe7Hat6zSBvOoplIpuN1uxY/Oys4ZjUblGpNPMGdiNBoVr2xmMi8TySxarNFoUFpamtcaQDo7UTx9etpzgy3lxgiHw+js7MwSwyw5jzVzyYVer0dZWdmI2Xwm2n2Vw8XxqMLF8cERj8fR3t6OZDIJrVYLl8s1pqpRsAixx+PJSg6RJAkGgwFmszktYzvXMj75pAWnnTY/S2DlE1LX/YZGK39/S1/HrF//+tfKVL16HfLZG4ZaeYHVRmbWj5KSEthstiEta6xQaGQ6l5Cuq6vLWcv229+5Affc/aus5/MlPOYS0+rjl69yxlhqhDJc3zmY5Qxm+zMrkHxj5SoYTCux+XOgt0GhQiLemtOO9OULVuOpx9MHQ5Ik4aOPPsLq1atx3XXXpZUDO+eccwa17czbzTr8AdQ2UFxcnCUEWdSVeXtzVf1gZf0GgtXYNhgMOYMPSu3qXbsw56ST0l4bijgOBALo6uoCQAU5a5+e2aVT3UWSdc0zmUxwOBwjagGaSPdVDoWL41GEi+OhEwgE0N3dDUIINBoNXC7XiLUSZn61/nxq0WgUbrc7LXpTVFQEo9GoFG7P9dlYjOCdd1vw9tu70dndgANNLnS0v5szGnXCsnvwzlvfzboRb9y4EdXV1VmibrD+3MGS6Z8uKysbUtWE8UzmfmxpacmyZkiShMceewxf+cpXshIS779/I1559U3c/9++pMFZc28DkSfhi83Z58DXvn4PHn3ku3kHPWOlEUp/3zkYsZtvOYWI3Xzbf8k3V6GsfDluvSV7ADp1+kZodS7IqVZI0m5YrA2wmF3w+97FRx9kH4+HHnoWHR378JOf9P3Ofv3rX+OMM84AgDRrVGYFGXUFA1ZujJVVzFUiT6fTKW3XR5NoNIru7m7aEMbjwbxTTkl7fTDiWG3HAmhORWlp6Zj3uk+U+yqnDy6ORxEujgePLMtpSSEGgwFlZWUjFjFm3l8WCWZdj9hfWZbhdrvTKkmwShRTpkzJil5t3bobiWQ9mppd2LAReP/9B9C8P92farMtx7Yv5iMzmWfNmo34+OM38fOfFx71HQ4RnEkikYDX602b4i0vL4fRaByW5Y8nWEtkluyTTCbx6KOP5owY9ufFbm5uRmtrN+x2J0pLq9DU1ILly+dnTDHnnz1YvPQefPRBrpJ7q7FzW+4IdL7z4WAjvvkGCIONeudbjnpWRBRFrFp1O2bNWoZTT00Xu4IgYd7C1di0vnA7yznnPoOion147NG+lsLXX387jj9+GU48MXe5NZfLhd27d+Pzzz9HeXm5IoJZ+buysrK0azC7/Q1kB1PXkRYEod8Zp0MFIUSpQ818wEy0C4KAElnGpEWL0j6jFsesNbzBYFDKErJtIISgq6tLubbb7fYRjwAPlfF+X+Vkw8XxKMLFcTbMm8s6bakvnvF4HB0dHcrF2OFwwG63j9jFMxqNoqOjI2dWdy4sFgteeuklXH311Vk3/1tvvR+///3AGe2CKOGBBzZi+7Y3cWNvAliuqG93dzecTuewTpGzAvnxeFzxPOp0OiWixRpGqJMKM0uOHS7EYjGl9Fmu80MdMaytrVU61vX09KCpqQkNDQ1Zxy7zt6qO/IuihK9ccBta2pZj7dvzUajYK6+8AR1t2XaO0894BmecUY/Skj2YObOh3+jrypUrEQgCPT1ALArYbIDdDhgMuX+H+dok33nnvfi///tOmoAVRQmPPrYRn3/+Jm64vu97v/u9VdDrJ+HPfxo40XQo27/itL/g1Vf+L2tdnn56Nc49N3eCZC470te//nV0dXUpg2NWE9putyszW2P9GpwLViaNNQrKxGKx0GQ6j6ffhLy2tra02sharVYpiebxeJSZNqfTCavVegi3aHgZj8eU0z9cHI8iXBynk0ql0NLSktVWkwlldmGWJAllZWUjOp2otnFotVqlVByLnkSjUTQ1NaGpqQnTpk3DjBkz0NXVlbPawVlfWo1nn85MmJNw1tl34bln82e09xf1Hc7jmqvusppcvkeDwZCzJexEJplMKoI4M+uftVDOfOSz0+Qi1zHNPAdCIRk33PgA7v5nnw3j5FNuw9x5y7Hqj/OzxN7vb12Nn/00O0Ews8zf9Jmr4KpajjWvzUem8J4xZyMEwYVEvBXx+G7odA3Q6lzQaQGLFdBqWyGQ3aisbOhNNmvFH28t3DM/GN91di1uSm3dPTiwL30Zoiji+hsewK9+uTJjv4hYvfp1fPTRh/jNb37VW4GERvgbGxtx8cUXZy0/12+yuLgYnZ2dyuDIbrfDZrNlzWqN5WtwJrIso6enJ60RjSAIymyZJEnK9hJCIHR3o2Hp0rRlqMWxLMsIBoN524OP11mn8XRMOYUxFsQxbwLCAQBFjDHPHRNfbHoaoCKstLR0RP3F6soLRqMRZWVlyhSoVquFxWLJGWGrq6vLyrSW5RQ+/PAjZN7QCUnh9NMEvPB8dlOLyZMnAwCqqqoOefJUPB5HT09PWt1li8WCZDKJeDyOeDyuTK0C1EftcDhG3fc4ksTjcXi93qyi/yaTCWazOSvrfzjJPAdMJhG33Hwxvv+95diyhdZurq2tglYL1FZnN5K46KIjodOmP3/Rxb/Cf/7NhDEAyNi25WoEAtltuIEUwqE9iMfXZJWncxSvxK6dD+R8vqJqVVb3RKPpKORqNGM0kpzfO3lyAHWTfo+33/y5MhBYdtLP8OYbv88Su3+9sxIffXStqhGOhN/97iZ84xvHQq/7PX7+85+n7ZdFi+Zj0aL5OPfcs7Bnzx44HA4YjUZ0dHRkNavJ/E26XC643W60tbUBoNeEsrKycT97EgqF0N3drYhfZguRJEkpQ5mZaKwZoBGGKIpK23BZlhEOhxEKhRAOhyGKIioqKsb9fuNwhgseOR5BxuoIV52d7HK5UFRUpJQ3Yj47URQPSdvZaDQKv98PQojSqYk9WI1NIL8HLp8X8o+3rcZVV2ZH6U5cthpvv5Wd0X4wlSMO9rjKsgyPxwOfKi0/s+4y0Od7DIfDIIQo5aXUGfBs3000colivV6v1IYdbt/7cPxW8802qJ/fs2dP7ooa3/477r33f7OE56pV/8VVV12clUy4atV/ceWVF2f4fEV89WvrkExNQk9PG5KJPZgytQ6LjnBgxgwv3nj98bROjtdeey2WLl2Ks846K2v5zz//PMrLy7OS2jJb/l533XW45JJLYDKZ0N7ePuD25xtwslJiTz31VJo3/Oabb8Y3vvEN5XfR3d2tiESLxYKSkpJ+/cNj9RoM0Nk7VrqNDYAlSYLD4YBOp1NeyyxFyexvGo8HdUcdlbbMQhLy1E1AxiNj+ZhyhgaPHHNGHVblAEDa1DzL3maF7IebaDQKj8eT5oHLhSAIKCsrg8lkAkCTpT78cA9s9nro9FX48INdWRHiVCqFP90RTouYCYKEr3/jNlzzsyPw+uu346c/zW4Pe9FFF2H58uXDnjSXiSzLSmJNKBTKqqqRqw0xs1t4vd6siJEaZitgHmX2KFQ8EkKUgUp/qNsnp1IpJXLb36xCPB5HKBRSZiLUN2Mm6tVin62z3+9PE8VGoxEOh2PMR7nyzTZkPp+rlfe559aiouLaLPFaVBTMMSMio6Xl06xa2oTIOPH4T7BokQidzgpCZiGRCIAQOhA+77zzsGLFCjQ3N6OyshIOhwOJRALXXpv+vf/v//0/1NbWQq/Xw+l0Yvbs2cp3fOc738EZZ5yB/fv3Y/r06aitrR309ufCaDSiuroaF154IZYuXZomyFmUWL2/SktLlWvEeIBZwlgAgiWSZpJKpZTrM0Oj0SjtpdW/N2GIca7xKoo5nEMJjxyPIGNthEsIQVtbG6LRKPR6PVwu1yG/UOYSxWazGXq9HrIsK+KMEIL29nZ0dnZi2rRpqKqqwh/+cD9uvvlKFNKC+YjFGzG5zgW7vRUW0x6sOLUe8+b1tYodzsoR6uPKRGwgEFC2gz0PoN/i+QxWg5nd7IPBIHw+X9rn9Ho9CCFpXbf6g4lm5sdlf9WzA+zBRJFOp1OEtlarhSiKiiBW+3zVZDY1YII4GAwOuN0DMZKi+FD/Vpk9JhKJ4MEHH8yqqPHlL38ZZrMZfr8fLS0tmDx5MiorK3HgwAEceeSRWTMlL7/8MlasWJH1/EsvvYSSkpK079ZqtbDZbDCbzVmDIFa7dv/+/WhqakJjYyMmTZo0agKKdapkQpJ1l2N/B2v1GgvXYK/XC7fbnfd11mgDgPLbJoTAYDDAarXmbSU+lA55E4GxcEw5w8tYiBxzcTyCjLUfscfjgcfjgSAIqK6uPiQdjVh5rWg0inA4nBYlZZnknZ2dA9ZJPf6EX+OtN9XeTACQcNKKjfB71+CTdX1JUZdfcRu++c2LYDICRiNgMACSdOhu7uy4DtRONheCIMBkMqGoqAjBYDDts4IgQBRFxXeo9gxmigEmxJnAZR7leDyeMyI1HOj1ehiNRkiSpAgYhiiK0Gg0WSLaaDQq4lZ96ckU+moRxLzVIxkpPpjfKjvnWVSdPcf+su5naiHb0dGBlpYWTJs2DVOmTMkrgID8nQNzPb9y5UqEQiH4/X4IggCr1XpIfdkjCSFk0Nsx2tdgv9+fFQkGaDSYeeb1ev2Qjg8Xx5yJAhfHo8jhLo6j0ShaW1sBAKWlpbBYLMO6bCaEY7FYVvkhJoq1Wm3OZLrly5dn+YjzZcb/+z/P4uijj0VXZwuam/di2rTJqK2tHrZtKQSTyYS9e/emTf3bbDYl+qPuJKW2FNhstixfcSKRQDAYRCAQUN4rSRJsNhusVuuQ2nPLsoxkMpkVIWYJmCyirI4ssyRAtdhmQpWVf8q0asTjccUXqS6pxiLhuT4zVhnKbzUejysVNAoZkLDKAwaDod/mNLkoxM/MW1lnM5rXYHVuB4MN/PobDBUKF8eciQIXx6PI4SyOqUexRWn3WVZWNiyRpFylhwAaRWQtSFnxeSB3Mp0oSvjZz+7CLbdkl5kSBCFNaA/UQOFQk0ql4PP54Pf7lW1g7VNlWUYoFErz2DIsFgscDke/U8EsusimU8dTpI+17k6lUuNKEKvJ9Vtlg4zMyHYqlcqymgiCAKPRqAyQ2PFjf/V6/ZAjhJyhM1rX4GAwiM7OTuX/NRoNysrKhrX8IhfHnInCWBDHPCHvMCMej6OrqwuJRAKSJMHpdA7LDToajaKzs1MRgiaTCQaDAUVFRWnNRNTs3r07Z7m1+x8CMiPFoijhF7/4FW655YasRLqRhAm/QCCAUCikPK/T6WAymZBIJNDa2pq2XayjltFoLLiyAvvMWCWVSiESiSjWARZRZtHP8VYrtT+Y79Xtdg/o7TYajUqUfChRfs7EI9NKYTab4XQ6+fnB4YxhuDg+TCCEwOv1KqMxVgXiYKN6hBC43W6lDJlGo0FpaWlOYcda0prNk7HxUxeefa4euWqtulxHobxsFTaupz5iUZRw++3UV3nhhV8e1mljliDHbAYsaUzdPEKSJBBCEAqFEAgE0iwDzJYQjUazmlEw+8FEEEpsP4XDYUQikSxfdSQSgcfjgSRJykDAYDD0e36xpLRgMIhQKKTYDNjjUHjgB0s8Hkd3d7eyveqKGurKGnq9/pCUlOOMT5j/3+fzpc2klZWVwWw2j+KacTicQuDi+DAgFouhq6tLEW9GoxFOp/OgmnmwpKPu7m5luSwi0tbWhl27dqO0rB4GQxU8HoInHn8Ad911VVrLZkfxSlTVrkJrU58IvuL/bsNFK10wGi+C17scHR17MWVKX6JeIWWg1BUvWKIXa2bCBDD7d6HtqPORSqWUZajbsQ6Hh/BQwOwaTOQCfYl/6jrJzC6QSqWQTCZztq1l26vRaBCJRBQrBfPdAnSQwTp66fV66HS6tPdkVrBIJBKKmJAkCUVFRRBFMeuYsmSszIcoikr1k4NBlmW43W54vV5lHzkcDthstjF5XDmjC5tRYrkWmYmooiiiqqpqTAz4OBzOwHBxPIHJjOqKogin0znoZh6sUx6rOhGLxZRubWy5rM7oqlX348Ybc5VbY527AEBGW8vVOPec5VhxykoYDMvR496LGdPTk+kqKqoxfXq1sg6s+kIikVD8nmrvp7oU3GBgwqrQz7IugixyWFxcDABj9sYnyzIikYjSDWsga0A+1PYQ1nyAYbPZ0oR3OBxWBiFqsZxrmcyKAEBp/MJKd6mtK4Xi8/lgNBpht9vzejpZrWlmA8oU3i0tLUr1jeEYTHImJrIsK5abfNcOnU6HyspKPqvA4Ywj+NV+gpJMJtHR0aHc4E0mE5xO56CaQbAmFbmSyoA+60BxcTE0Gg0eeLBZJYwBQEZb89VonJ6jFS5J4dij9+KYY6ogitUA+kSxuvwbE+IHUyOXTYVndo9jyVWZophVbWANNFhdYBaZzGS0EkJYF0N1VJxFezMfatSWDxaVVQ8uWDcy9UOj0QzYfY+JZ4PBgJKSkrQqHex4MmGuruWs3qestrMsy8pncnVPVA9m1A9WV5kJdIPBAIvFkja4isfjBc0YME/+RCl9xhkeWC1zdm3MFMVstoSVaOSimMMZf3BxPAGJxWJob29HKpUaVPcoNjXIxEWmgGBT4+zR2dmJ7du3o7p6Mh57woVHHt2N7HJrKVxyMfCrX6Z3AZMkCXPm1EMUBSUyrZ6WzBXdzKxWUShs+fnQ6/VKSS29Xj9mb2bM88sqIwzGEqLRaJSEwJGyfEiSpIhwoO84qLvf5UMURUVoD5Z4PA63261YR/J1YWR+cXUlCfZvq9UKvV4/7r3inOEjHo/D5/NltXAG+mbP+ECKw5kYcHE8wQgGg+jq6gIhBFqtFhUVFQVN92f6koG+CCOrPKEWCur6xGr7hCCIaW1sJUnCccc24le/+hVuuOEGpZ7xL37xC8RiMezbtw8AssQwK/+m0+mQTCbTIjTMzqCOdGaSGWVk0U91NFSr1Y5pAZTLppALdeJg5jaqH6N90xYEIWdb7FAoBK/XC0JIVttrFrFWw3zj6oYh6qi5OrGyPzQaDXQ6nZIAqLZN8PJQHKAvYODz+dIGWZIkKdcfjUYDl8vFbTcczgSC/5onCIQQeDweJYHIYDCgvLx8QOGXWcVCFEWYTCZFEAuCgJaWFmzYsEHpYNfc3KwSxgCzT/zy1x8A8o246aZfpolgo9GIs846C0cddRSamppQU1OD8vJy+kmVsFU3RACg3JTYe7RaLex2O8xmc5ZgUidpARh1ITgUZFlO89wyS4EaVjKNibmREL3Mby7LcpYNYqiwqWmPx5M2IEskElk+Y/Z9g/WTazQapZU1S5JiD2bdicVi8Pv9yvuZUDYYDEPqwMaZGDAvsd/vTxtosZkQ5jHWarWorKzkwpjDmWDwX/QEQJZldHZ2IhwOA6DJUcXFxQPe2OPxODo7O/utYvGf/9yPq6+mQlgQRCw9ZhW8vkk5orUpVLs24MgjT8XSpfOyRDAAlJeXp/0/i9yx2rhMGGVG7PoTxYyB/LBjDeaBZZ7qXBnuQLo/eKDSaMO1XpFIJM0rrLZveDwexYc7VCKRCNxut+KHF0URNpsNer0e0WgUkUhEiQwD2bMK+WAimr0/mUwqbb1ZVQ0mrtXLZ6iTB7u7uyFJEvR6vZKEmCuKzZlYEEIQDAbhdruV85613bZarZBlGe3t7ZBlGVqtFi6Xa8zasDgcztDh4nick0wm0d7ejng8DkEQ4HQ6B2wFTQiBz+eD2+0GQEVFSUkJPvjQh6eefg8puQHRqAtt7a3YsK4vwY4QGe+vvRp1DauR3aRDRE1NDQAqgisqKpRENvVUfyKRQCQSUSoFJJNJRdSrEUUROp0OFoulX1E81mE+W3Xb5sxqH2rU0cv+GqgUAuvSFw6HodFo+i1xJssy/H4/fD5fTi+zVqtV7Avt7e0wm80oKSnJEgayLCvtr1nELTOar26hbbVaUVRUhEgkgp6enpx2CHVSpDo5UG0jUe8jdam4WCym2FIGC+t8Fw6H0dPTozyvtrGoq5Yw1Ns7Vuo1cwYmGo2ip6dHGbRpNBrYbDZoNBpEo1G0t7cr5yevQMHhTGy4OB7HRKNRdHR0KB3jysvL00pXybKMcDisTMHH43EEAgEEg0FFABmNRlgsTnz/Bw/gxRd+AnUJNp1uEnIl2F309WYkEv8Pt976O6WywW233YalS5cWvO6pVEqJEsZiMSVKp9PplKS48SaIWeF/llTISpnlswIIgpCW4Jjpex3qOsTjcfj9foRCobToqM/nSxtwSJKEZDKptMBWe7pZciI7Jszj7Xa74ff7EQwGEYlEUFJSApPJhFgsppxbhVgfmIc9EAgopQYZLFrL1mGwNg5JkmCz2WCz2ZRzPh6PKz5z9UMQhKzBSyKRUPZjLisHG9QVisVigd1u5yJ5lFF71dlMUzKZVLpdqmdu2DUoV4k2o9GI0tJSLow5nAmMQIaS/j8BGI1km+FM8lEn3ul0OpSXl6fdfDNLuakrPXR0dKC5uRnz5s1DKFyD667vwNq3jkRmJPjmm+/HL35xUZrAEkURb731DmbNmoHW1tZh7VY3HmHVF7q7u5UmGLlQCzImOAcTFVZX9IhGo0ilUkppOXWJORaVZ7CIcS4vr16vV84Pto4D2VcAOihjLcgBKkYzuwYCSBMhattL5oBBnfg5VkpfZf5WmeWCzbYIggCLxQJRFJU62wy2bayUHcNiscDhcHB/6gihLu0XCoWGXA5yvHS7FLq7YW9sTHvOu2MHiNM5Sms0MvDk2YnHoT6mDodjwPfwq/Q4IzOBzmg0oqysLO2CHQqF0NnZmSZA2L+feeYZ3HTTTYqHuLL6Nmi1dciMEMuyDJstgGuvvVZ5vyRJWLVqFWbPngmgsG51EwkmUFnEOxqNZkUQ2VS6wWBQBPBQvKqZ39Wf8M6ENdZglgX23Zl2AybcioqKYLfblQTMgSgqKkJ1dbWSAMrWS6PRZNVVzjf2liRJSfwcq90E1Wg0GtjtdhiNRsWn7/f74XA44HQ6865/NBqFx+NBJBJBIBBAIBCAxWJR/ONqW8ZY3wfjAZZoGQwGEQ6HC47wsxbg6nrerJygXq/nx4bDOczgkeMRpNDRUCqVUvyX6uYHoigq0UOA1mItKSkBgLwNOzo6OtDS0oJJkyYhmUzirLPOykhEknDWl57Ci8+fmxUhfuONN9DY2Iienh7s27fvsIwQqwv+5xOoRqMROp0OBoNhyEKPWTLUwjvXd6m9yKyMnfqvVqtVLBP9EY/HEYlEFDtHf8iyDJ/Pp/h21RFrFp1Tn3NarVapEsE+r27lrdFoxrzg6O+3Kssyenp6lDbXBoMBpaWl/UaEo9Eo3G43otFo3vew6ho2m23MRifHMvF4HD09PWkl11hjGlEUs36/bLZCnRQ8nuGRY85EgUeOOVnE43G0t7cPGPFwOp2wWq1ZSSQMQRDw/PPP47e/vR6E0Cixq/p7OatMnHF6JxbM+yVuvPFGJUL8xz/+EfPmzQMAVFdXo7q6GhMJdem3XGXhmIc207cL9HlimVAtKSkZ8g+ZNRbI9T25vmu4RBMTBP3Byll5PJ6CKkaYTKasaPVEhDV8KCoqUuw0Bw4cgFarVWYNMv3jRUVFcLlcSgRZXZc5s7qGz+dTPNOZx5udm6wNuMPhGBM2lNFElmVlvzHMZjOMRqPiqVfPbpjNZlitVm5v4XA4eeFXhzFEOBxGR0eHUli+uLgYAJRGB6xGqyiKCIfD8Hq9OUW0TqfD+vXt+M1vroe60kRL013IrjIh4ZhjlqCq6sv4yle+MuE9xKzpRE9Pj3LDzJzejsViaftVkiTlZjscTUPyNRZglgz2GK0GJYQQRRSzfaTVamGz2SBJUlqkmg0wColWTzQsFgv0ej26uroQi8WUZD4WUVa3IGcPJp7VsN83s2AkEok0kWyxWNKawagHKuFwGOXl5XmrkExkcpVdMxqNcDgcSvUT9W/cbrejtrY2KwGUw+FwMuHieAyQWVqtqKgI5eXlSqIT8yr2l1DS0dGBpqYmFJfU4521U/DCCyFkV5qQcc45/4vnnvsHZDmleIiZEB4OD3E8HkdXVxeAvoL5wzVlKcuyIkJYVYvBLDeRSCiRPjWZPlmAClWTyQSz2VywF7eQ9Q8Gg/D5fFmNBWw224hHXGVZVjrKqR+s0gZARYXD4YDFYpnQ0eChotPpUFVVlVZ9hdWsZmJZnQjJugTSKjEWaLVaiKIIURRhNpthMpmUWt9MJGfOSjAvLBvEtba2FlTCcbzBKkmwSLvaXsYsPWwQq9FoYDAYkEql0NbWpgwgmFecnb/crsLhcAqBi+NRhhCC7u5uJdpksVjgdDoRi8XQ09OT1jYZ6BPBNTU1Sp3Np556SmnNrG7lnBklliQJ11//Pdxww/cPSYRYXUEDoD5oj8cDSZIUocwaMagfQLqPlYkFtgwmOHJZR9Rl0JjtIJdNwufzwePxKN9nt9ths9kUgcj+plIpaDSaYctKZ3WcmWdZve7MXzrSJb5kWYbX64XP58ubMCeKIux2O6xWKxcUBaBOMAT6KlWou/KpS8TF43F4vV4UFRXBYrEonQdZFD5TJDNBzbojCoKAVCqFrq4uhMNhJXpdUlKSdv6rm82w3+FYHuSwWRW/359Vm1rtW1ejLsnG0Gg0cDgc47pGOofDGT24OB5FUqkUOjo6lCSdkpISGI1GdHV1IRgMKu9jNWbVlSZEUcS1116LKVOPw/XX3wBC0ls5/+rXGyHLq3DLzVcrdZBXrVqleIeHUxQTQtDT06O04S0qKoLZbEY4HFaSYFgE6GCRJAk6nU5pZ8zaLbOpUkEQlAYNrFlDOBxWypsVFRXB6XQqfltW+3Y4YTfqcDicJehZstpoic5IJIKurq60RhxsP6kfw9Um+nBFPSBkqCuQsDrR7Pzt7u6GyWSCRqNJGyQ6HA4lUpwp8lhtc1a9xu/3IxaLobi4WEm4jEajaWJSq9WiuLi4X5HMBHUqlUoTpOzfbDZouGADCbZfBlNDmq2v2pLEK0xwOJyDhYvjUUKdeCcIAsrKypBIJNDc3AxCiFJloqqqCuXl5ejo6FCEMUCjf7/73c1wVdephDEjhTmz9+Lkky/GhV89achRYnUFBVmWFd+kOpEls56y3W6Hw+FQup+xSBATyupIsToZLlflBaBvupTd+FipJbZu7KbKrADs+UwLCusCeCgjSUyk56onbDKZYDQaD6rj3cHAKqCwQZckSUobaC4iRgZmqWADpEzbgHpAnInBYIDT6cwayAmCAIfDAZ1Op0SP29rast6j1+uV6HVHRwf0ej2Ki4sV/7Msy8rvNBwO91s20O12w2QywW63D9rrzBIKWfOfzEonuWDR8swZJ1adhfnz+XnM4XCGCy6ORwjmN2VTnN3d3Urind1uh9vtVgRdZoT4Rz/6JURpStZ0IiEpCCKQyz4xY0Y9gMH5iFnESO2dzFWlgHWz02q1Src9lsHPppUZrOauOoJW6LoQQvJGLwVBUMQ681rm89CyjmmHImGMEAKPx4OWlpa0KDGLnjMryWiRSqUQCoXgdruVY2m1WlFcXMwjw6MMm/q32+1pFSjYgw0UWRS4ubkZDocDNpstSwiykmSsBrO6agYTjqlUCj6fDz6fTxHRLCKtHrgCfUI+0+fLRDQrG2k0GmG32/OWA2SD41AolOZlHwhRFJUZFt5ZkMPhjDRcHI8Q7e3tOWucyrKM7u5u5f9zRYhvv/13qGtYjUwRLAgSrvv1UWhtvh3XX39Vmn2iqqoqLRql9vKyGx6LsLKIUq4IDos6SZKkvC+VSqX5AXN16DtYcpVYGwi2fYf6ZsqiX7nqSpvNZthstlGpHsCEFPNnZ1bd0Gq1SgkyzthBbQnIRTweR3d3t1IrORgMorS0NO0cYwNJVvc8VyRVkiQUFxfDarXC6/XC7/en+eCZb9poNPabhBqLxeD1ehEKhZRIs7qzIRP17Fox0Lazv8ziw9qb88Ebh8MZLca9OP7ss89w5513YtOmTUgkEpgyZQouueQSnHXWWaO9amnkmzpUR2Z379Hh/gd8OWsR22xhLF66Cus+vBqEpCCKEm65ZRXOO6cKgnARzjtvuWKfcLlc8Pv9adHCQmGdojKjTur1ZdHvWCymRL4n+o2MEIJoNKoIYvVNf7Rrp7ImHT5frnOnz+ecK+LIGfvodDpUVlYiEAjA7XYjHo+jpaUFJpMJsiwrMySZkd9MDy5AZxJYtReLxaKIY+Y1FwRBqbbBRG6m3Umv18Nms8Fut8Pn8yEYDPbb3IStD2uUYzabR81exOFwOIUwrsXxRx99hMsuuwxarRZnnHEGLBYLXn31VfzkJz9BS0sLvv/974/2Kiq0t7dj3759qKmpQXl5ufJ8c3MnXn2tE9t2zEJ7hwuJOJCrFvFtf6jH5MnHwetZjpaW7G51zD6RSCTQ3t6u3PSY9SDzRscsHazFMXtIktTvTUsUxX6jXBORSCSCzs7ONEHM7CImkwlVVVWjUjs1lyhmlhdWwWO0aiVzhhfm4TcajUoVm0xvO4C0OtSs7bjH40nz9udiMElwkUgEXq9XSRQsLi5WOneqbRM6nU4ph8itERwOZzwxbsVxMpnEL3/5SwiCgAcffBAzZ84EAPzv//4vLrzwQtx555047bTTUFdXN7orCuD+++/HlVdeCVmmneou+OoNKKtYibfefAKbP/0pqBAWUVW7CsceuxKLF63CQw9enVaLeOECWmXCYa/G5MnZ3eoIIUq0mGVv5/MncgrH7/crthdRFGE0GmE2m9O61R0q8cn805lTzwAtm+f1ehVRrNVq4XA4YDKZ+PGewGg0GpSXlyMcDiMajSoRX61Wm5asyuw17JE508EGw6zqRK4ocb7yikx0y7KcU6SbTCYlSZDD4XDGIwLJF0oY46xduxaXXXYZzjvvPNx8881pr7300ku48sor8b3vfQ9XXXVVzs+PVC/2lpYWzJs3L2O6W0Jdw2rs230aMiPE77yzEdOnV6GtrTWryoQsy0omufomxvx9LCEss1wZZ/BklqczmUwoLS3NKYSHsw88S2BirasHgtdzPTQM5zEdbVgJOVbdYTjOE3Ub63A4jEQioVSwGMvXnYl0XDMRurthb2xMe867YweI0zlKazQyTORjerhyqI+pw+EY8D3jNnK8bt06AMCxxx6b9doxxxyT9p7RZM+ePTk9xOVlH2Hf7vTnZTkFt3sfRLFasUmwGsEs+aU/BEFQEm64UBo6qVQKnZ2dijWFVRQ4lPuUtR0OBAJpUT51kpO6aUpm5y8OJx+s8sRwL5PZq4qLi5XZKg6Hw5kIjFtxvG/fPgDApEmTsl6z2WxwOBzYv3//CK9VNvX19UoTD4Yoirj6ypm48KP051lRf7/fn+YZVMOmQjOnO9mU/2iWDZsI5Ko/nVmerhBYtI5VBGFVQdSJU+q/6gkc1krYYrHkrHqhrhXN4YwF+LnI4XAmEuNWSbESZazGbSZmsxnt7e15P2+z2UYkUcnhcOCf//wnvvvd76Z1tquvn4Rrr702rZ7xL37xC0iSlFbaDaA2CYfDAYfDobSO5Qwv0WgUHR0d6OnpASEEOp0ODQ0NBddndjgcIIQgFAqhq6srzQ9cKFarFSUlJYdF9Y/xQCFTb5zxx4Q9rjmSKu12OzBRt1fFhD2mhzGjfUzHrTg+WEayusB5552Ho446Cs3NzSgpKYHT6UQymcSFF16I4447Dvv378ekSZNQWVmZFgnWarVKcX8ASnINZ3hg5dl8Pl+aZaWoqAjl5eVKubqBsFqtaGpqQiAQUNpUM9SJTyxpiglfdaKdKIqKhWI0Kl9w0uE+xonJRD6ugtcLe8ZzXq8XZILPJk7kY3q4wj3HB4HZbAYABAKBnK8Hg8G8UeXRoLy8HDU1NUoWOMPlcmHRokWjuGaHHyzC6/V608Ss0WiEzWbLis6z9zNLhNoOkUqlsG/fPiVKLAgCTCYTrFYrb2nL4XA4HM44ZNyKY1aibf/+/Zg9e3baaz6fDx6PBwsWLBiFNctNZ2en0jSDVxcYPVKpFLq6upRIsSAISpvaXFn20WgU3d3dWRHhTLRaLaxWK8xm8yFpU83hcDgcDmdkGLfGRhZtXbt2bdZr7733HgDgqKOOGtF16g+73Q6NRoNkMomuri40NzcjGAzmLcqfC9adbpxW3xt1QqEQmpqaFGFst9tRW1ubs+wda+vd2tqKeDyeliRntVphtVqVLmGNjY2orq6GzWbjwpjD4XA4nHHOuI0cL126FDU1NXjhhRdw8cUXY8aMGQConeJvf/sbNBoNzj333FFeyz5MJhNcLhf2798Pr9eLRCKBzs5OpY1rrg5WrAkEq3agbvhQUVHBu04VSCqVQk9Pj5LEqdVqUVZWlrMSBEBFdHd3t1JSzWw2o6SkJK/wtVgs3PPG4XA4HM4EYdyKY41GgxtvvBHf/va38fWvfx1nnnkmzGYzXn31VTQ3N+PHP/4xJk+ePNqrmYYoirDb7bBarfD5fIrntaenZ1DLSSQSaG1tRUVFRV6Bx6EDjXA4nCZ0bTYbiouL0ywtyWQS8XgcsVgM0WhUKZ+n0WjgdDoLrljB4XA4HA5n/DNuxTEALFmyBA899BDuuOMOrF69GolEAlOmTMGPfvQjnH322aO9enkRRREOh0MRyWo/q1q0sYoV6navsiyjvb0d8XgcbW1tKC8vh8FgGI3NGLPIsoxAIACfz4dkb3kjjUaDsrIyFBUVKa22w+EwYrFYWtMNht1u5yXVOBwOh8M5DBnX4hgA5s6di3vuuWe0V2NISJKE4uLiQX1GFEVUVlaivb0dsVgM7e3tQ25UMdFIJBLw+XwIBAKKPUUURVitVkXoxmIxdHV15Sy5ptfrodPpYDQax3QLXA6Hw+FwOIeOcS+OD0ckSUJlZSU6OzsRDofR0dGB0tLSMVW6bqRIpVIIhUIIhUJp3QS1Wi1sNhvMZrPSobCnp0epISyKolK2Ta/X8wgxh8PhcDgcAFwcj1tEUUR5eTm6uroQDAbR1dWFQCCg2C/UVoyDFX7MdjBWKjHIsqwIYnXzDgAwGAyw2WwwGAyKRYX5jpnFwmQyoaSkhLfa5nA4HA6HkwVXByOEz+dDd3c39Ho9TCbTsEQqBUFAaWkpJEmCz+fL20GPWQZYlFSn0/VbY5kQgng8jnA4rPhyAVqVweFw5BWVhBBEIhElOmsymWAymYZFVLPkumAwiHA4nFbVQ6fTwWQywWw2Q6vVKusfiUQQDoeVfcIT7DgcDofD4QwEF8cjRDgcVqb9e3p6YDab8zaeGAyCIKCkpARmsxnxeByJRCKr/Bv7NytlJggCdDqd0qZaEASlhXEqlUIkEsmZpBYIBBAMBmG322Gz2RSBz0Sxx+NJa7cciUTQ3d0Ng8EwJKFMCEEsFkMgEEAoFFJK2QFQWmszQZxMJhGLxeDxeHKuv81mg8Ph4PYJDofD4XA4/cLF8QhRVlam1DZOJpPw+/3w+/0oKiqC0WhME6nsodPpCp761+v1Ocu6pVIppURZLBZDLBaDLMtpIjYXgiDAYDDAaDTCaDQimUyip6dHEaB+vx/FxcWQJClNFAuCAKvVCkmSEAwGlQguE8psPdlDq9UqUWy2rvF4HPF4HNFoVLFCANTWYTQaodFoQAhBIpFAR0cHEolE3vVn28BrQnM4HA6HwykELo5HCEmS4HQ6odfrEYlElFJi+awQDGbDMJlMQxJ4TFAyKwETlazTnizLIIQo/2aisqioKM16odFo4HK5EAqF4Ha7lU5/DCaKbTabIujtdrsSsQ6FQkotYbUwZ4OAZDKZM1otCAJMJhP0ej3i8XjeroKCIECr1SpiOHP9ORwOh8PhcAqBi+MRRhCEtGhsIBBQhKr6wewQTEy63W5FKLN6x5mfKSoqGlAUMjE6FDuHIAgwm80wGo3w+/1KVziLxaK0x85Eq9XC4XDA4XAgkUgoEWwmlJl1gqHRaBRfNPMPMzsHQ6fTKVFn9j6NRsPFMIfD4XA4nIOGi+NRRKPRwOFw5H09mUwqSWhqW0R/6PV62O12GI3GQyYW1Z3+CCEF+4hZ9QxWco4JY7/fD4CKbzYwYNF1dTTZZDLBZrNBr9dzIczhcDgcDueQwMXxGEaj0cBqtcJqtSKZTCqly2RZzvIos2oOsVgMHR0dWXV+DwUHs1xCCEKhEHp6enLaKdTfwfYBL73G4XA4HA7nUMPVxjhBo9HAZrPBZrPlfY860S+RSKC7uxsejwcWi6VfcUkIQTQahc/nQywWU2okq2sla7XaYatzzNaNVe/QaDRKUmLmo6ioiFeY4HA4HA6HM2JwcTyB0Gg0KC4uht1uRyAQgNfrRSqVgtfrhdfrhdFoVLrCCYIAWZYRDAbh9/vT2imzqhFqBEGAzWZT2jAPBUIIfD4fPB6PklRnt9sPapkcDofD4XA4wwkXxxMQ1hrZarUiFArB7/cjGo0qTT1YVYdgMKjUDhYEARaLBSaTCalUKq1WciKRUER2IBBAcXExzGZzQb5fFpWORCIIhUJK2bWioiI4nc6DrvPM4XA4HA6HM5xwcTyBYdUlWIMQv9+PQCCgCF6gz9dssVjy2iaYn7mnp0cp4eb3+1FSUoKioiLlfbIsI5VKKZFnVqpOXXpNFEWlaQlPquNwOBwOhzPW4OL4MEGn08HpdKK4uFipfmE0GmEymQYUqazWsMFgUEq4xWIxtLa2QqfTKaI4V/1hgNZaVjfkGC7vMofD4XA4HM5ww8XxYYa6+sNQPmu322E2m+F2u5UOeJlIkgSdTpfWnY5HiTkcDofD4YwHuDjmDBqNRoOysjKlA54kScqDlZbjcDgcDofDGY9wccwZMkPttMfhcDgcDoczVuH1szgcDofD4XA4nF64OOZwOBwOh8PhcHrh4pjD4XA4HA6Hw+mFi2MOh8PhcDgcDqcXLo45HA6Hw+FwOJxeuDjmcDgcDofD4XB6EUi+tmYcDofD4XA4HM5hBo8cczgcDofD4XA4vXBxzOFwOBwOh8Ph9MLFMYfD4XA4HA6H0wsXxxwOh8PhcDgcTi9cHHM4HA6Hw+FwOL1wcczhcDgcDofD4fTCxTGHw+FwOBwOh9MLF8ccDofD4XA4HE4vXBxzOBzOBOLOO+/EtGnTcOedd472qnA4HM64RDPaK8DhcDjDxfr16/HMM8/g448/RldXF2KxGBwOB2bOnImTTz4ZZ5xxBoxG42iv5pijubkZJ510EgDgjTfeQHV19Siv0ejDBhdXXHHFKK8Jh8MZabg45nA4455IJIJf/OIXWL16NQBAr9ejtrYWer0eHR0deOutt/DWW2/hz3/+M+69915MmzZtlNeYM9b5y1/+AoCLYw7ncISLYw6HM65JJBK49NJLsWHDBpSWluInP/kJTjvtNBQVFSnv2bVrF/773//iySefRFNTExfHHA6Hw8kLF8ccDmdc85e//AUbNmyA0+nEI488ktMSMGXKFFx//fU4++yzIYo81YLD4XA4+eHimMPhjFsCgQDuv/9+AMC11147oFf2yCOPTPv/aDSK119/HW+88Qa2bNmCzs5OAEBtbS1WrFiBb37zmzk9yizyvH379pzfs3z5crS0tGT5dz0eD/75z3/izTffREtLCyRJQnFxMSZPnozly5fjG9/4Rtpy3nvvPbzxxhv45JNP0N7ejkgkgvLychxzzDH43ve+B5fLNcAeOnguuugirFu3Dv/9739hs9nw5z//GRs2bEAikcDcuXNx9dVXY86cOQCATz75BH//+9+xefNmJBIJLFq0CNdccw0aGhrSlsk8zlVVVXjjjTfwwAMP4LHHHsOBAwdgNBpx7LHH4sorr8y5fTt27MDLL7+M9957Dy0tLfB6vbDb7Zg/fz4uvfRSLFy4MO+2dHR04L777sO7776L1tZWSJIEl8uFY489Fl/96ldRV1eHO++8U7FUAMiaZeCebA5n4sPFMYfDGbe89dZbCIVCKC4uxooVKwb9+c8//xxXX301NBoNnE4n6uvrEQwGsWvXLmzbtg2vv/46HnrooTSLxlAJBAK44IILcODAAWi1WkyaNAl6vR7t7e1477338Omnn2aJ4+985zuQZRnFxcVwuVxIpVJobm7GI488gpdffhkPPvggpkyZctDrVgiffvop/vrXv0Kn06GmpgYHDhzABx98gEsuuQSPPvoodu3ahZ/85Cew2Wyorq7Gnj178Pbbb2Pz5s14/vnn4XQ6cy73t7/9LR5++GG4XC40NDRg165deO6557B27Vo8+OCDqK+vT3v/TTfdhA8++ABWqxWlpaUoKytDa2srXnvtNaxZswa///3vcdZZZ2V9zwcffIDLL78cwWAQWq0W9fX1IISgqakJ9913H4xGI6644gpUVlZi4cKF2LBhAwBkiW29Xj9Me5TD4YxZCIfD4YxTfvvb35LGxkbywx/+cEifb25uJi+99BIJBoNpz3d2dpIrrriCNDY2kjvvvDPrc42NjaSxsTHvcpctW0YaGxtJU1OT8ty9995LGhsbyaWXXko8Hk/a+1taWsi//vWvrOU88sgjpL29Pe25SCRC/v73v5PGxkaycuXKrM/ccccdpLGxkdxxxx151y+TpqYmZZvU60wIIStXriSNjY1k1qxZ5OabbyaxWIwQQkgsFiM/+MEPlPU48sgjyX333UdSqRQhhBCfz0fOP/980tjYSG699dac3zdz5kwya9Ys8sILLyivud1u8s1vfpM0NjaS888/n8iynPbZ1atXk23btqU9J8syee2118j8+fPJwoULSSAQSHu9paWFHHHEEaSxsZH87Gc/S9v/qVSKvPnmm+SNN95I+8xAx5jD4UxcuPmOw+GMWzo6OgBgyNPcVVVVOP3002EymdKeLy0txa233gqtVovnn3/+oNcTAPbt2wcA+PrXvw673Z72msvlwje/+c2sz3z1q19FeXl52nNFRUX4/ve/jyOOOALr1q1T9sGhZurUqbjmmmug0+kAADqdDj/96U8BAOvWrcOiRYvwrW99S/F0W61W/N///R8A4N133825zGQyiQsvvBBnnHGG8pzD4cAf//hH6PV6fPbZZ/joo4/SPnPaaadlWR0EQcDJJ5+MSy65BMFgEG+++Wba63fffTcCgQCWLl2KW265JW3/i6KIE088EcuXLx/CXuFwOBMRbqvgcDjjllAoBAAwGAxDXoYsy1izZg3ee+89NDU1IRwOgxACgIquffv2IRKJHNR3AEBlZSUA4PXXX8cJJ5wAjaawy+/mzZvxyiuvYNeuXQgGg0ilUgCA/fv3AwC2bduWJaAPBeeddx4EQUh7bvLkyTAYDIhEIjj//POzPjNz5kwAQFNTU97lZlpJAKCkpAQrVqxQ7BVLlixJe721tRUvvPACvvjiC3g8HiQSCQCA2+0GQPeJ2lrxxhtvAAAuu+yyrG3gcDicTLg45nA44xYW8Y1EIkP6vN/vx3e/+11s3LhxwPcdrDg+77zzcO+99+Kpp57CO++8g+OOOw5HHHEElixZgpqamqz3E0Jw/fXX46GHHup3uT6f76DWq1Bqa2tzPu9wOBCJRHK+XlxcDAAIh8M5P8u817lgSXws4s54+umncd111yEWi+VdV/U+CQaDSnR9/vz5eT/D4XA4DG6r4HA44xYWMW1ubh7S52+++WZs3LgRkydPxp133ol33nkHmzdvxvbt27F9+3Zl+SwyebDr+uijj2LFihUIBAJ4+umn8ctf/hInn3wyvvrVr2YJ9GeffRYPPfQQjEYjrrvuOrz66qv49NNPlXVjkdFkMnnQ61YI+ZISWSQ21+sDRWntdnve0nolJSUA+mYHAODAgQP41a9+hVgshksvvRTPPPMM1q9fj23btmH79u248cYbAaTvE/XnLRZLv+vD4XA4AI8cczicccyCBQvw4IMPYuPGjUgmkwVbFQAqoF5++WUAwN/+9resqgjJZBLd3d39LoMQklMA5ouUNjQ04I477kA8HsfGjRvx8ccf48UXX8SmTZtw6aWX4vnnn1f808zrfM011+DCCy/MWlZ7e/vAGznG8Xq9kGU5p0BmFgm1H3z16tVIJBI444wzcM0112R9pq2tLes59ecDgQAXyBwOZ0B45JjD4YxbTjjhBBiNRvT09OCVV14Z1GfdbjfC4TDsdnuWMAaAnTt3Kv7eTFjtYybg1AQCAXg8nn6/W6fTYfHixbj88svxwgsvYOHChQiHw3jxxReV97Bo+IIFC7I+n0gksHv37n6/YzyQSCRw4MCBnK+x7aurq1Oea2lpAZB7nwDUa5yJ2WxGRUUFAGDTpk0HsbYcDudwgYtjDoczbrFarbjooosA0Pq3A9kr1q9fr9SvZTaAYDCIaDSa9d577rkn73JYdHfz5s1Zrz3++OOFrXwvkiQpTTRYExL1+vX09GR95qmnnsopzMcjuTzVbrdbieofc8wxyvOsxnCuiP7u3buzqlQwTj75ZADAv/71r4LXi+3/XOcGh8OZ2HBxzOFwxjWXX345FixYgO7ublx44YV45plnspK19u7di9/+9re4+OKLFVFptVoxdepUJJNJ3HTTTYjH4wCAVCqFf/7zn3jppZeg1Wpzfufxxx8PAPjTn/6UJtTeeecd/PWvf81p77j99tvx+OOPw+/3pz2/Y8cOrF69GkBfdQcAOOKII5TvUAvhd955B7feeuuEaEah0Wjw0EMPKdsPUKvFT3/6U8RiMcyePTutUgXbJw8//DC2bt2qPL937178+Mc/znu8LrvsMlgsFrz33nu49tpr0xL2ZFnG22+/nSWsWZLkunXrDn5DORzOuIJ7jjkczrhGp9Ph3nvvxS9+8Qu88soruOaaa3DdddehtrYWer0enZ2dSrWCioqKtKoKV111FX74wx/i0UcfxSuvvILq6mq0tLTA4/Hghz/8IZ599lllKl/NZZddhmeffRZbt27FsmXL0NDQAL/fj5aWFnz3u9/Fiy++mPW5nTt34h//+Ad+/etfo6amBjabDT6fTynJtnjxYnzpS19S3v/tb38bL774Ij799FMsW7YMkydPVr5j8eLFKCsrG7YazKNFeXk5jj/+ePz4xz/GH/7wBzgcDuzatQvRaBR2ux233nprmqf75JNPxvz587Fp0yZ8+ctfRl1dHSRJws6dO+F0OvGDH/wAf/rTn7K+x+Vy4Y477sDll1+OJ598Es899xwaGhogyzKam5sRDodx+eWXY9myZcpnTj/9dOzcuRPf//73MW3aNJjNZgDAqlWrUFpaesj3DYfDGT145JjD4Yx7TCYT7rjjDjz44IM4//zzUVFRgebmZmzbtg2EEJx44on43e9+h1deeQWNjY3K55YvX467774bCxYsQDQaxd69ezFp0iT84Q9/wI9+9KO831dcXIyHH34Yp512GgwGA/bu3QubzYabb74ZV199dc7P/OAHP8B3v/tdzJkzB+FwGFu3bkU0GsVRRx2F3//+97jvvvvSIs4ulwuPPPIITj31VGi1WuzZswd6vR5XXHEF7rnnnkElH45lrrvuOvy///f/YDKZsHPnThgMBpx11ll46qmnlHJuDI1Gg3vvvRcXXXQRSkpKcODAAfj9fpx//vl46qmn+q33fPTRR+OFF17AypUr4XK5sGfPHrS3t6OmpgaXXXZZ2sAEAL773e/i8ssvR21tLXbt2oV169Zh3bp1/ZaQ43A4EwOBsGr3HA6Hw+GMAM3NzTjppJNQVVWFNWvWjPbqcDgcTho8cszhcDgcDofD4fTCxTGHw+FwOBwOh9MLF8ccDofD4XA4HE4vXBxzOBwOh8PhcDi98IQ8DofD4XA4HA6nFx455nA4HA6Hw+FweuHimMPhcDgcDofD6WViVJEfAh6PZ8S/k3XE4kws+HGdePBjOjGZyMdV6O6GXdXgBgC8O3aAOJ2jtEYjw0Q+pocrh/qYOhyOAd/DI8cjiCjy3T0R4cd14sGP6cSEH9eJBz+mE4+xcExHfw04HA6Hw+FwOJwxAhfHHA6Hw+FwOBxOL1wcczgcDofD4XA4vXBxzOFwOBwOh8Ph9MLFMYfD4XA4HA6H0wsXxxwOh8PhcDgcTi9cHHM4HA6Hw+FwDo54CIJ7L5BKjPaaHDRcHHM4HA6Hc7gip3oFTXy014QznklEILZtgtT8McSOL8a9QObimMPhcDicwxQh4obYtR2Cv3W0V4UzXknGIbZvhuhvAzGXQezZNe4FMhfHHA6HwzlsSSYJkkky2qsxaghhD4RwNwT3HiAZG+3V4QwGQugxG00RKichdnwO0bsfxFIJaI0g5nIqkNs/H7cCWTPaK8DhcDgczmixbTuB0QjUTxZGe1VGHjkF+FsAgwNi2A3iawYpaRjtteLkgshAxAshGQESUQixABD1QUhEQIwlkKuPAIQRjncSGWLndojuPSDmCkDS0uc1eiqQ3bsBEMgVswFJN7LrdpDwyDFnQhOJELS2EcTjh29kiMNJJunv4HCOkOZiw0YZf74T+GILDs99E/VBiPlBimwgejNE9x4gERntteJkQmSInVsh7XsX0v4PIbZtgujdDzERBkQJgr8ZQrBjhNeJQOzeBbF7G4jJCWj06a8zgdyzuzeCPL487TxyzJmQ+P0EHR0EzS1AOALMmS2gtma01+rQEgwStLQSNNQL0GiGPwoWjRJoNDgky+YcWppbCbZsASZPAhobAUnixxAA/n4XsHUboNcDxywFiotHe41GFiHUA+2WZwFRi8QRl0Dwt0L0NkEubRztVeOoENx7IXbtADHYQXQmAIB6KCckIhDce0BMpYA4MrJO8O6D0LkFpMgBaI2536TRg1gqIPbsBkhvBDlTRI9RuDjmTBhkmcDtAdraCFrbgM82Axs2AokE8L3vELgqJ66wI4Rg336C/QcAqwWorBze5SeTBJ9/QVBcfJhOP49jQiGCH14OgAArvw5oNARTpgCCcHgfx+5ugm3b6b+3bQc6OgmKiw+jfUJkiC2fQHPgAwBAxDoVmtq5EDx7AVsV0CvCOKOL4GuB2PEFiN6c95gQkxNioB3E3wZiP/RRIMHfSqPBWiOgN/f/Zo0exFpJZyXkBOTKufnF9BiCi2POmCOVIgiHacTXYACsloFvWIQQfLGFYN8+4NPNwMefAD09fa+/+RYwZzZQUX7IVntU2X+A4MabaOTLWUJQWjq8A4FHHiN49DHgkouA2hoyYQcZE5FXXyPw++m/n3ga0BcBGi1B3aTDWyC/+joB6Q2/RaPAu2uBqVMOo3M76odm/1rlf/Vbn0Kq/igIoQ6IvibIpdNHceU4ACCEuiC2fwZB0oIU2fK/UdQAGj2Enl0g5nJAM0h/bzwE0b0XxFQKYun/JimEeyC2fQZBEEEM9sKWL+lAbFUQfc2AnKICWW8Z3DqOMNxzPM6gwnFieeOSSYLOThr5/PRTGe+9T/DBhwTr1hFs30aQSg28va2tBI89Afz1H8DLr1BhbDQC8+bS19dvAPbvJ5Dl8bPvZJn6RGOx/tc5lSK4+16guYVGyz/ZAHR3D996eL0y/v1fwOMFXl8DuN1DXxYhE+/8BVDQOTpavPIa/SsIQGcn8MyzwOefAy0to7teo80bb9K/RgP9u34D4PX1/xk6gyKjvX3sHu9CESJuSK0bAQApaKBLeJD8/DWQIgetexwLjPIaHuZEvBDaPoOQSoAYSwZ8OzEUQwz3QPAP4odNCI0CN30EseMLiC3rIfj6+XwsAKHtUyAZpRYONak4NJufgLT/vdyfFTUg1ioIgXaIzZ8AEU/h6zkKcHE8jgiHCT7/nOCT9QRe7/i/OANULO3cRfDxejptv3c/sH0H8MFHVIht2Z4eAc7H9b+j0eFgEHDYgfPOAa77JXDulwCzGQiFgLfeAbzeQ7s9w0lbO7B5M8G27f0nUm38lODdvgAQ3l0LHDhQ2KCiEP7zAI2sAXT6ed/+oS03mSTYtZuev909Y/f8JYTA7ZYLStCidhYZH39CEAiMvW3q7JTxxRb67/PPo97avfuAF1cDX2whE0LkDYXOToLtvZaKs8+if3fspIPs/vj4E4IXXgLWbyTYs0ce04OifiEE0v4PIEY8SAp6bHV+HwBg3PMCiJyCEA9B9BwY5ZU8jImHaMQ46qOR4EIQJRCdGWLPLiARHvj9yTjEji0Qmz6GGA+DOCZBEASIrRsgePZBmVZhJKJ0ncIewFKR/pqcgu7Dv0O77Xno1v0T2Ppy3nWErQpCxAOp+RMIwc7Ctm0U4LaKcUJ3D8HrrxO8sBqorQG0WoL58wCDYWhTgLJMIAgHN62aTBIEAoDNBoji0JbT3U3w0mqgqRlobgY6OtN/k52dwJxZ1CaQb13Xb6QCQBSBr18ILJhPRbLbQ4XxshOA518EPvwIOOP08eErDAYJ/v0fgrZ2YNmJgNGQ2ycaixHc9U9AloGGeuBAE92PH30M1E46eBuJ1yfj+Rfov7Va6t9e8xYwexaB0Vj4fozFCLbvINi9m67rnj0ENiug1Y6tY5FMEuzdR9DVFYfJRDCtESgqyr2OqRTdpscep3YWSSSYOxfQ68fONr24mv6eqquBuXPpvemJJ4HPvwAsFmqvkCSgtLSwdU4miTJQUp+KggDodOPH0//a6/Qi43IBxx8HvPoavV68uxaYMZ3kPC+9Xhm//i0QidDI+1n/A4QjBFOnjK1jXhDxIKR97wIAWnVHwVO2DL7gK7BFdyK16XkIR5wHwbsPsFcD/U3nc4af3oYaQrCLer8Hc4822CF4m3qTKqflf1/YDbFzK8RAK4jR2ZfkZywBIh6IrZsgp5K0rJ8gAKkErWXsbwWxVqeXjCMytOvvg9S6ATJEiJBh+PxhRAQJmH5K9ncLImCtghDsgNiyHrJrAUim2B4DjJo4/uyzz3DnnXdi06ZNSCQSmDJlCi655BKcddZZBS9DlmU89NBDePTRR7F//34YjUYsXrwYV155Jerq6g7dyo8gqRSNtt37L+CDD+mNbt8+oKgIKCoimDN78DekcJhg2zaC4hKgbtLgL+rxOEFnJ9DUTBAKAbNmCkNKAIvHCf7xz75pX4bTCUyqBTZ9SkXz+g30/0vyzCw99DD9O38e0NAAdHZRwT6nAagoFzC5juDlV4GuLuC994G6SQRm89i9maVSBE8/S7D6Ffr/8Tj1XhuNQFVV+ntfeY1g6zY6MDjnS8A771K/9TvvAosXEZQ6D64ywf29UeOyMmDubBrNX78B6O4BagvMqfD7CbZuI3hnLfDKK0CRAbjo69QbXV8/tHVr76CR2soKYdiOJRPwL7wIEJLAtOn0tzJ9OuCwp39HMkmw7hOCP98BtLTS/Q8B0OkJZs0cPpEoy3TmoKREQHnZ4Jf52hv076wZQLVLgNlIEA7RweIHHwIWM0Bkgkm1BFVVQt4BTypFf/P79xP4g33Ps/u2ADoQra0FyobZ734oYJaKmTOAslIBxx5L8NzzNIHX6wVKS7M/88BDVBgDwL79wL8fAM48A4iECWbMwCG7poRCBJ1dBDotUFU1PJO9QrgHml5LRYvheIipKA5UXIw5+34Fc8ubCM84CaKQgujZB7ly3rB8J6cAWEMNXzOI1TX4usWCCGLotcVYXdm+3lgAor8NQs9OIBkDsVZlV7cwOABBgtT+GWSShFwyBWLXNoiefbTJhyj1vZcQaD57FJp9ayFDxPu2a1EtbUOd+wkYNj+AiKQBpi7LsZ4CiKUCgq8ZQqCdi2PGRx99hMsuuwxarRZnnHEGLBYLXn31VfzkJz9BS0sLvv/97xe0nOuuuw6PPfYYpkyZgpUrV6KnpwcvvfQS3nvvPTzyyCOYMmXKId6SQ0skQvDqawT3/rvP51lTTQXj628AJQ7AYKDRrUIjwB4vwZatBB0dQDAEVFaQgqMe0WjvDfIAgc8HSBKQSgF79hI4HPkjbPn44EOC19fQfx97DDBjOlA3CbBYBFqXmADrN1JBu/goWikhczv375fx8cf037NnUwE5fZqAstK+aE5tDbBkMbUevPc+cPJJgxfHXi9BWxtBebkAhyP//iaEwOsDWpoJjCagfvLgb2bbdxA88FDf/2/ZSgcMOh2BwQAl8u33y/j3f+h7jjsW0GiAFafQQUVbO/D+h8CkOqC8bNCrAADw+WQ81xs1XroEOOpIGjVuawM2bCCocg0svDs6Cb74guC5F4BP1tPnojFg7ft0sFNcTGC3D/5YbN1K4PMDB5oIaqv7F3aFEAgQbNlC8MDDwMZNABDHh+vo/gxHCKY30iijINBz8+VXCf72DzpDIQg0Gv7cc4DZBOj1BI1Thz6bouaDD+m+O+N0gpLiwYnOHTtlHDhAhfvcuUB5OeByCUimCAJB4K23qXg2mWnya3MrQd0kAleloPx2ZJmgpwfYvYfgldeAzz4DNNrewVrvgM1goCK7oQHo6SZwlACTauiAaqzNDAB0YLVjJ/33gnmA3Q6cdgrw3PPArt1AUxPJiqT7/TKee57+++TlNPLe3gE8+hjQ0QGEowSzZgBO5/ANijweuq5t7UA4BBiM9Nwaju+Q9q2FEPMjIRgRskyDIeqFX1uDLvNilAY/AjY8ARx7GW0p7Zw6LqoLjHvSGmqU5y/JRmQg6oUYdkMI9wDxIFJVRwBFdvq63gLB1wTRsxdyxVxATkIIUS+yEGiDEA+DGGxApmdYTZEVRBQhdmwBon6IvibqMc5o5KHZ/iK0O6iF4mPLjyBXLUSLsAAiSaLW8wwMm/6NqCCBTDk+9/eMUNm5oTDia5ZMJvHLX/4SgiDgwQcfxMyZMwEA//u//4sLL7wQd955J0477bQBI78ffvghHnvsMRx55JH417/+BZ2OHrRzzjkH3/rWt/Cb3/wGDzzwwKHenENGW4eMO+8E3un1klotwAVfoRHURx6jReuffR6wOwCTiYrmgWhvpxUdXnqZ1vY84zSgrg4D1v9VyoTtBwIBGln57HMaQTQagIu+ATidBNMaC79o9/TI+MfdVFzPmkk9wpEIvUn7AwRaLXDC8VQc79oNfPoZXU+7PX05DzwMyASonww0TgEWzheyrCaiKOCC86k43rMX2LABqK4qfFCQTBLs3kNw4ACwv4mgvIzu7+LiPgHERHFzM0FbG422WixARfng7Ac+H8Ff/kY90uVlVPQ+8RSNBJcUA4YiaqcxmQQ8+BCNkhuNwJLFgM0K1NYKWHQEwfsf0s8cvZRGj4ci1O5/kB6T0lJa6WPuXAGzZxF8thl49z26bvmi+YQQ7D9AsO5juv6trfT5o44EPl5PBei0RqDYQa0IhYq+WIx60z9aRwdDGon6oJtbCGpqqLAbrEju7iHY9CnBgw8DO3dSsWuzCvB4CB55jM5ILDuRRoSrXMCDDxM8/Cg9d8vLgW9eBDz2JLB3L/D0MzSCWlREhjQro6a1VcYNN1EBTggwdcrgSvS9+BL921APuCrp+SgIAmbNBOIJWsFiw0a6zpUV9Hj6/UBLC61kYTDQwceaN6mQ9nj7/z6tlg5yj1gAuHvogLm2lp7HOt3YEcmvvkYtFdVVdN8UFQmYPZv+rjs6gbffBWbPJmnrfP+D9NpU6gQWHUl/D2veotelNW/SAePZZxFMn0ZQWyMM2WYRjRL0uIHWFoLuHjroslppHkVXFx04G404qIEg4iFo9rwNAGjRLUGRFAUMpUCkB03lX0NJ8GOY3BsQ7DkFGpMNQiwIwsXxIUfo2QOxe0fuhhoRN3Qb7ofg3Q8h4oVAUmkvx/Z8CPnka9HrlQQxlkDwHIAoFQGBNtr9EAQw2EGMzsKsGjoziCDRiLGxBNAa0l6W9rwJ7ebHAQAbTZchWn0cNCIACGhyXQQBSdR4XoB+432IihJQf8xB7J2RZ8TF8YcffogDBw7gvPPOU4QxAJjNZvzwhz/ElVdeiaeeegpXXXVVv8t5/HF6UH784x8rwhgAli5dimOPPRbvvvsu9u7di8mTJx+aDRkCra0pxOMENlv/J+bHn8j43c106hqggmLFqUC8t0X5hRcAf/sHjQ4++RRgs9GIorMk93JlmQqVzz8Hnn4WStTkrXeBefMIKiv6j/B0d9OI0fYdwIZN1NPKiMdphNJRDJSVEjgcA//okkmC+x8CmppogtApp9DvMBrpTby4WIDFTD2Mr75O8PkX1At4xML0KKPbI2NN7/TowgXUV5nPgz17loBZMwm+2EIT85Yuoe8vhB07CO74C70xHn8c3e9t7fRmWl1N7T1fbKGiOBSm+2n3buCoRUB1NcHUKYWL8KeeoeJTEGgCldlMhe+HHwEvvERvlEVFBMUOgqeepZ9bcSogCrT+cGUlnepdv5EK53fW0mh82SCjx+pI2dLFVEjYbcBpK2hFjM2fA20ddLo/F61twHMvAM+/QAW20Qh842t0IKTRAu9/ALz2OhWbztKBB2gAndrfsZPgvw/QaPoLL9Fp8eXLALMF2LqVWn0apwJVrsL2eUsLTRB86BFqj9Bo6GBv0ZEmPPp4EO+8SyPxu3YDJy0HenoI1vYmY8+eBXztq1RQnn0m8MCDQI8beOoZOmgs0hNUVAxNxKRSMn53CxXGABWxO3cVXqJPlgnepPoHM2cClRWCMtthtQqYMwtIJgjMZuCjdfScfuwJep4csxRwuwna24HX1lDhB1BxveJUOkgLh1WPCE3yO3CAJsW+9z79nSxcALg9BMUOOqgvL89/nUkmaaTU6yWorR26uCyENSpLBYvCiqKI446T8cSTwMZPaQCA/Wb8fhnP9v4WliwGJk2i1y2jiV6vXn2dBhs6u4BTTgYWzCOon0y3d6BBqSwTBIP0HOruIXC76f4kMuDxAPsOALt20Sj1WWfQYMb2HUOz0zGEUA+ktl5LhfE4CCCQzaUQQBCJBdDuOBUuz8uQNj0OHP1NIB4a0vdwCkfwNkHs/AJEb8mO0sdD0L9zG0R/341XhoiIVIKwUApHcjf03h0I7v4Q0pSl9A06ExDxQmz/FNCaQMxlfa2dB4PWAOKoy3pabP4Y2vV02nKL4QL4as6EVlIlCwkCDri+BUFOotr3MorW34OoKAJ1Swe/DqPEiIvjdevWAQCOPfbYrNeOOeaYtPf0x0cffQSj0YiFCxdmvcbE8ccff5xXHIdCI/uD/+BDGW++HcXs2QnMnQVUVQlZNwpZJnjxJYJ/3E1Fp9VKb7rlpTQRqroKqK4SEIsBXz6P4L5/9U3taTXA3DkC9L0DTkL6EtsONBFs/pxO+7Z1UAEA0FJOH30EVFQIqMxzE08mCe6+l06pJnrFuSQCc+bQaO1Tz1CP65QGwFBE12Ggi/amT2U8/QyNiiw/kZZMaWigVgh1tIYQ4OyzZHy2GfjiCxqpLinu85g+8KBMI5tOoL4BsJgFhEL5v/uM02Vs/pwK/Y2bqH1joHWNRgnu+AvBzl3Azl3UpzlnNr35x2LA/v2A1UbQ3h7Cli00EY75Et099OZptxUWzdz8uYwHH6L75cTjaSSurIx+V0cHsHsP8NTTVFxu+aIvulxXQ88Vi0VANCqgro5g4XyC9z6gEb/FR9JBw2Cix/f+W0YwBDhLaEe1YoeAcFjA0UtkGAxUtL32OlBVKWRFBb0+gjv/SvAOzfdBdTUVnBYz9csfuZBG3Lq6gbXvUf+8Xjewd/hAk4wne5PJ2Ds//4I+qquBE48DqqqpmBUgDDgI7ekhePNtWgLQ46GR0m9dQj2z+w8ARywMoXEKHVB2dtEIK+Pk5cDRS4HuLqDSRff/WWcCDz9CReJTz9ABzowZAiSRDmwTCSAaIQiF6WzP5Lrsfcd49DEZGzfRQY/JTGdsXn4Ff+KRjwAAk6NJREFUqK4uzHu8YYOM7m46wJwyhUZH1b8NvR5oqCeIRAiOmE8HO++8B7S3A08+TQcz4d6Ed60WWHY8cPzx9JyPxWkkU5LQ2zGRWjd27gRefo3OErz6Gj33jjsWmD8XaG8DHCVATbWQ5kmOxQi6ummVCHcP3U8yEVBdNXjhJ8s0QdjjIUjJQG1N9jW2u1vCjp0hCKA2Lp2ub7+ceLyMxx4H9uwGtm4HTCZqibrv3zKCQToomD6dXoMsFrr9kkhgtdLEx64umv/wxefAcccBk+voMbZY+maXEgk6qxSJUj97Vxc9tvE4Fcjbd1I/c0sznRFT8+hjwGWXArEovQbX1wtp9i4xHIY9Y5+Ew2HIGfc6zZZXgGAQcdEMj9aFIiIgBT0EvQOirwM7LafD2PkmtJ7dCO7aDLGoErJ+iN6sEUCn0434/Xw4EUJdtISaIIJIOiAc7XsxFYNu7Z8gu5sQlez4xPojyOZyyDorJI0IjQS4up7BpK7HkNzwMKJl0wFNb4RXq5rWi6UApEebh4rYswu6tX9DUpaxp+hkNJV+CbpkGMlk9nu3Ob+BSDwGl28N5PfuQiwlAZVz+7Y9EoOsi2Sdo4f6mDocjoHfREaYK664gjQ2NpLNmzfnfH3x4sVkyZIl/S4jFAqRxsZGcuaZZ+Z8/c033ySNjY3k97//fd5lgHZf5A/+4A/+4A/+GPcPJ5SYiPJwjoH14g/+GGuPQhjxOsfB3nlCiyV3dxSz2YxAoP/i4+x1szl320L2PPsuDofD4XA4HA6nEMZuquAhpqmpaUS/jxCCL7YYsXp1CGs/6JuynNYIBPxAazudQl2xApgxjXrLGurzT7sCvXVWt9MM+48/6f/76+tp4lAiQaf9a2qAe++jiXX19cAPvkMTrtRT7488JuPef9Fp059eRf+GQ3Rav7iY2jESCeDRRwleW0OncC+5GJg9E5gxvW/KLxqlGe979xL84Xa67Scto93rZs4EJtX2P0YLBGRc/iPqYz1yIfCdbwO/vYH+/7HHAOecTe0chVTs8HhkfPt7gD8AnHoy8KWzaTm7zP2cShH8+S8Eq1+mU+BXXA4kYtTbajLS6iFvv0uno2tqJBx/bAoN9TThKZmk1UD+8ncgmaQl1k45CWicmr2d8TjBxx8T/P42elyWnUgz6Gtr6T5kxyOZpBUa1n4APPMM/ey3vw24KoAjFgo5K4V89pmMX/6GLvfk5cD8+ehNJqQVN9THOh6niUD79hLcdCud+l1xKnDm/wDTp6WvdypF8J3vEzQ1AyeeAFzxQzrN/PF62sI6EqFl3847l04Vl5cDUxoEWK193+f3E7z9LsFdd9Op+pOXA0ceQa0NJlNv1YciAUV6mmx337+pr9NqBX58BbV16IuAeIyWhrOa6ZT8n+6kTWNmzQROPw2YN0fI8v3u2CnjdzfR35yrEvjfH9DzQRKB6dOpxcjhcMDj8Sj7vqMD2HeAIOCnSXFTp+S2ysTjNOn1yaepl5dBkzOBigq6b9nvtaYGOO9LwIL5Alwu4O77CB5/ove3tJJWgJgzW8Df/kHw4mqg2AH87Cf0/flsMm+skXHLH6hf/UdXAEcv6f86oj4mzS3UO59IAJIGkFN0nSfVCgVVFQkECZqbCVrbgESvNWzz57RcI4t5uCrodq/fCGUq1lUBVNcA6z6myce/uhaYN6//3/Rrb8h47XWaCJmrs53NRm1pUxrobykSBS65lEAAcOWPgOXLsr3Nzc0yvvUd+u9rrwH+dAf1AJ/W+1uYNi33tYoQWsln1x7qG/78c+Dtd4CUPOAug9EILD6K+pmLVTkbcoraQ2SZJn8GQ8Bf/06vnwsX0PrtpaV0Ow80AWJ3D3Blus3w002bIPdmzaZSBLueehpHtP8OUdGG3TNugMGqgVx1BCD0lecSPXshdO1A5a5/oCjUhLWaH8BTd17hrYJHGLPJjGBoDAfCCIEYaAOifgjJOECSoJ5HgVZr0JuzEuSm+R/ElMCzkCFgW/WV0NfNQb+uOEJQuvl2mH2b0SwtxKcVP+93lTRyGJNCL2Ny8EXo5fRg5B7jCmyzfxNEdU6AyDjCfRsqoh8jKtrwRcMNKK7IEeAkMpCK9Vk7VAhyAiWfroIluA1RwYIPS69HV8iOyY0GTD92atp71dff0WLExTGL6uaLDgeDwbxRZQZ7PV9kmD2fL7IMACaTacB1HW6WLLGhSA/MmQu8+y69OezcRV8zm2kC1qRaYOpUKtgK8YjOnUvwDULQ0ECFq9tDxUGPmwo4WaYX3gvOBy2/pgGOPFJAdRVNfvliK/WB7tpDhQFLsOrolPHk09RLeMrJ9LtMJupfLHUKsNn6hODppxNs3U7F6vr1QEUZEAwK0GhpJ6qODipmXn2dCoPKCuCoo+j7GqcO7Ps1mYDzzpXxt3/QKh3vvEu91no9TXqb0lB4rVujkeCUUwiefob6XmfNApIJoLEx3aP62Waa7CeKtMseCDB5Mk3U8XipiLvgfOAbXxNgsVjg8/kRCgGBIP1MVRUVe+s+pslUC+bT9WT+Q6CvY9zDj1GBWNXbkECno7WjTab0bZo/n84KWS20aofJAMycIeRNipszh2DZCbTG85q3AJ8fOOZoKlgrKoCaGio+O7sImluAHduBN9+m/sfSUnqznjolez0A4H9Ok3H3fdTvGwpTD+Vf/kq3o7YG+PKXqcCaN4+ey5neT5MJOGqRjJ27gFdepaXdFi2iA7BAkO5j5pn/9FOa5ChJwKXfBCBQgTp9mgCfj6CllW6TKNKkv7/9gwrpKVOoZ7qsrG+/d3YSPPQIQXsnFSXfuYyWlrNa6D4v6/XzmkwmxONxZX1tNmDSJAKPly4z3zlrMgELFxBIIkFDPfWMV5RT3244Qs9/QuixfvlV6vv/9/1U3NVNoq2dRZEmX02aRAd9druAr18o48236Ps+2UDFXr7GHW+9I0MUqTe+vg5wOAqbIDSZgIoKWnWlqYnWQ66rE1BWVni1E5OJbq/HS3DgAC1DNmM6PbbvvQ+88QbQ3kkfAM1bOPUUOpgJhejvOxgCPtkIzJmTPqBSs/Z9Gbfd3neOFBXR75k7l3rG73+A+sQff5LuS0miSZyiSIX5tGlAcXH2fpk2DZg6RcbuPcA9/6LnRmkpsHgxMGVq7t8Cw2ym+2/XbgKLhV5b3nqbrkcyCaSSQDLV++8UXY/jjqHVULRaei11u3sHDAJdV0lUebsl4JsXA/+8h/rqJ9fRa4XPBySSwLtrIliZsU5GoxGk916XSsqoj66FSSfAV3wM5tb5IVfMhVxqS/9QYgrE/Z3QhWqgOdCMev1+dJSkINvz309HE4vFggEmm0cVIdwDMd4BmPSAxgiI2vRawRm4up/D5NhzgE7A3pofYPqi+dDkf3vf9xRfBP0r12Ia2YiY7jMEHEdkvUeTDKCy50W4PC9CI4cADRCSKtFdfQ7sOg+sOx/DnOSrcIU6sLPuJ0hJ9Nyp7XgQNfInSOm06Jj9UyyaYc9eASID/nZA0ECQorTqRhoSUHUlpDW3wuTfg2X+m/C2+ZcwFBVn6bHM6+9oMOLimJVo279/P2bPnp32ms/ng8fjwYIFC/pdhtFoRGlpKZqbm5FKpSBJ6WfOvn370r5rrGC3iZgzR0B5BeCqJJg1iwo9QoDTV9A6qjOmZ0e6+kOvFzBzJhCL07qvFgtNjNNoBKRSBPEEoNfRTnMGIzBrRp8AWLiAdoPaspXeuBbMp7WECaFRZb+fRqrmzaE3vLlzsyMtGo2AKQ3A6afR6N6mT+lNoaiIIBKlkaeuHmDtWipwACo2dVpgcv3Awphx2qn0RtfVe8MD6E2luopGsQtFEAScfy6NCHd108L+55wNBEO005XLRUXdX/9O/zbU05uQw07FUypFBx4tzTTSSghBKJSCz0eFQcNkKsbMZlo7d8NGWt1j61ag2kUwYwbdXlmmN9EHH6YDJEkCvvoVIBmngjfXTbioSMCMGUAkRm+i5RVU5ObDbBZw/pcJ2jvoQGD9Bio+VpxCb84dHQQaLU3+ef9DKG2GJYkmBNZWI684Oe00Kurcbpqk+O5aWgbLYgYuWklF8swZNCEpX/SvplrAKScRbN1KI19330MTnibXUdHkdNIqCqwW9hmn04FVOEwHVSUl9FFTQ49FezvdnhNPoBUJXnmVRq3NZoK5c+g6Pf0cwQcf0uV97at0P5gtwOyZwoCdE/V6oaCOg0ajgFmzgESSimmfn/4GTSYqim1W2pimvBx45jl6Tj/4MBXrqRStgjFtGt1GFq2tqRFwzDEEb6yh+/uEYwlKSrJFa2enjPUb6L/nzBp83V1BEOCw08ok7P+HgsMuwG6jg8R9++gA+ciFtPLJmrfoNh9/HC1Pl0jQ6xNAK/O8/S6tzvI/K0jO80+WZfz9LnqdmjKFnqvTp/Ul8yaSBP93Of1tb9tOEwy7e6C0i549gw7w83HiCTT5tbub/v/SxXTAZ7UMvC+MRgGzZ9Hr5s5dBGedSROG+6sGJMsEbg9BNEIHU1VVAnRaKoilXlEsisC27QRoptHwZ56jpTy/cxkNbry+BrDGBli5RBQVEVoUXq5aCCLpIJtz1LrVGkCcUyFbaN1Ae3IPOqI+ULvm0M6HwxYiQwi0UTFcZB3w7aWetzC5/d8AgP3l30DJkUuhUVeB6O+rLBVITF0B3Y6XMLn9Pmy2zQURaYUKbdILV/fzqHCvhkamCX8BTTXcNefAOH0RynrHPdHiCug+/gdKIp9Cv/Pn2D75WlgiO1DTRW+6ByZ9H+XTanN8OQH8rSCGYhDHJIgdXwARD20ookZrQOrEq5B442YYQy04JnALdiVuKWj7RpoRF8eLFi3CXXfdhbVr1+KMM85Ie+2992iNpKOOOmrA5Rx11FF48cUXsWHDBixatCjttbVr1yrfNdYQRXqDLSkGKisJpjRQEVpWRoXxYBsiAFQEzZ4F7NtPoz49PUAyRaDRUKHs7gFKnMDMjOUXF9ML7ZatNNK2ZSu9CTS1ELz6On3P6afRCG19ff7ySiUlNIK7cRONkr72OhWJbW30Rrh/P32fINBSYDY7tQ2UDELUOhwCzjid4N//pZEVQQAWzqcCa7AljaqrBfzwe7S5Sk8P8N8HgLPPok1XfH66H1g76rPOpH+nTOnbflZyzuOlAlOnk1BfL6CkOL0RyuxZdMDx8SfABx/RyFZVFb3h7z9A8PyLtKQZQMvzGYxAZTkVgPmw2QTMmA7s3k1QP3ngba+bRGs8L1pEu9MdaKI31Y/XAytOptv68Xo6wyAINNq97ITebnzV+ZddXiZiwXwZ6z6mIiQUoqL6kovpgKihgX53f+JKqxUwdQpw5hkE//oPnfV4/4O+fWLunW1MJKj4OfEEKqqmT09vd6zV0t9UeRkduBDQmty79wAvvUTrP1vMBPsPAI8/QT9zwnF0lkajodaLgSpbDBarlf4mu7oJLBY6WDKb+sRseTlgNhE4ncCzz9HjEAzSwe2yE+gAweXqW55GQ4/j2+/Q39W6j2lk2emkAzS/n5YXfP4FKrBLS+kxKCQpOxcH01ZevQxnCRXaHR3A7r0EXi8tvWcx00hpVzc9X8rLqXWjopJ2Umxqok1jamuz65E/9zy9puh0wNe/2hc9TaYICKHHNJUELrgAeOcdGr19+x36WVGksxmZ9dLVnL4CuO/f9H5fUgIsWIhBVc8QRQHV1YDVBuzaRaPnhBDo9XTGqUjfdx4EAgT+AJ2ZmN4ooKIi/6zEtEZa7USc3tc59K67+16fOgXAlvzrpdm/FhoSQUQshqHEQRtB5GkNTawupFwLgC+eQnFqLxANAKk4IOlzvp+TGyHigRD2AAVYUhz+jzG15S8AgObiM2FdfCq0msKEMSM182yk9r8PS6wNzvYX4Cs9HlXdz6Lc/SokQiOxfm0dPJPOgWnaApRllq+uXYi4+f9Bs/bPMMdaMGfXNdCAjrqaS85B8YKjIIrZ6yQEO0D0Fsiu+YDBAVmQILZuAgRf9jmmtyB54k+AN34Ha7QdFZ3PA1g8qO0cCUZcHC9duhQ1NTV44YUXcPHFF2PGjBkAqBXib3/7GzQaDc4991zl/W63Gx6PBw6HA8WqEOEFF1yAF198EX/605/SmoB88MEHWLt2LRYtWjSmahxnotUKqJskoNRJ0N1Nb2YHU9jd4RDgcNDuXWx63+ulNyMWkc5cviAIWLKElnTavYdGd2fPIvjHXVSATmmgkZ+amv6js4IgoG4ScNqpBNt30CjQbX+igoluK7V2LD+RdsPU6wcWTrm+40tnETz9LL0RzphOu7/lavM6EJIkYPFi6sF7+VUa0X7yKeDYo4EjI8B/7qfvO6HX4jBpUnazC0miN35niQCHQwuPJ3tbystplHbjJnqz37qdimNbkNoXWJOG5ctolDWRoIOQgQRvRTmNyhXSkbCoSEBdHfWCXvYtKsKef5GW2/rXf/veN2smrY9stVD/bXX1wJGyM06nIo0d5wvOp9HR6ipqxyhkKr6kRMCRR9CBXDBIy1jt3UtFPHNNWa3Ayq/T6J/LRaPRuWBibNoUgv9ZAdz3X2r1ef8DGrn913+oraG2lk7lhyN0NmC4hTGjuDh/NFoUBUyaJMBkJrBZaUR4244+0T6lIXv/TWmg++rDj2ikf8kSepNqaaWR2bZ2WkoQoOdTf0JrJNFoBFRV0d9QUzMduLS0EAgitUDU1gpKm3OLhV6DNn9Oa3Qfd2x6PfJIRMa//kP/fczRtNyZKNLggs1KSxYaDPSc3LGTYOkS+tqTT9FBQ0O9hEmTUv3+dioqRMyZTUtIHr2UdvuzFBA1zsRqETB3Dr2G+v007yIYotcvWSYAobWSZ0yn4nug37PBQGeONmwiWHEKHXA0t1Bhfd45wKJJAJ7L/3ntztUAALdtMUq0EaTsM/O3JxY1kOuOhawxQEpGoA0cQDw+C8TAxXHBqKPGA9QYtoa2YFrTbRAgo916AgxHfwVFQ9nVWgNS8y6AtO6fqHc/CtHzMERCjf1e3VT4Jp8L89TZKDP0I7qLJyF56q8hv30n9H7q++wyLkLRknOh0+YQxqFuEElL24z3RoqJvRaynITU9hn1LuszLDnGYqSWXYPIJ88gXnP0EDb00DPi4lij0eDGG2/Et7/9bXz961/HmWeeCbPZjFdffRXNzc348Y9/nCZqH3zwQfzlL3/B5ZdfjiuuuEJ5fsmSJfjKV76Cxx9/HOeeey5OOOEEpX202WzGb37zm5HetCFhMgkYTvuzTidAp6MRo9oaGp0RxfyewWIHjY7+6Q5g8xe0neynn9GI3Skn0ahPIULWZBIwcybBicfTmp+hEI1aH3csrY9qtQiIRGhke9bM7C52heB0CvjG12iHv6OPpl3qhtp5q6yUJiKedSZQtYFGuNe+D3y6mSYO2Wy0E5bT2b81oD+0Who9nDePYP16mqA1fRqwbQdNukomqYg5/TRaL3fWTBQ8czCYVt1VLmoH272H2hWu+Rnwyss0mj1pEvClM2kCaHc3TWqbNYMKloE49hgqeHp6aFS3rq63Fuy0bI9xf0yqFdDdQ6Of8+ZSkZtIEjQ30wjZtEYqbExGYGoBHvXqagHTpxOcfhrwxJPUhsDEo8FAE918fhpp68+WMhI4SwQsXACYTAQLmmjEvrEx9yyNXi/gK1+m3QH37qORw7Z2guYmmr+wZSuNdmq11HubrynQaFFUJGDqFAHlZQRt7TSirq55DNBt/NLZVBxv2UqtBJWVfW3KH3yEzg5YLDRxdeZ0Krwz25jb7YDFCuzaSSDLtD7whx8CSxZr4SwZOEvuZz+htZrr6wcXNc5EoxFQXgaUlwmY0kAQiaA3eEFrHrsqhUEJbzZz9OmnBN+8mP4+Zs2k+1bu6f+zkr8FBAJI5WwQrYF2SusHYqRT5OjaBmNkL+LJCJBVSZmTDyFaWNTYGNmLGftvgkTi6DIeCemYb8GYnc9WMKnao5HY+Sa0np0AAdz6GQg0nAtrw3SUFbFqZgNQZId88jUIrX8cEW8IySO/BXuuJokRDwhJQXYtpI1GGIIAUlwPWU5C7PgCRBBoYxIVxFwG3RFno8zuQgF5qyPOqFSrWLJkCR566CHccccdWL16NRKJBKZMmYIf/ehHOPvsswtezvXXX49p06bh0Ucfxf333w+j0Yhly5bhyiuvHNNR45FkICEhigJOPB548ilafeCpp+nzSxZTgTh5cuHteKtcApadSBCPUx/nksWAoUhALEbQ3k4gSTTpqBDfZi4EQegV7ARFRSioGUI+tFoBc2ZTb7RWQxO8nniqL6P+zP/pbaDQj52kEMrKgNNOATZtolPB27cB775Pv6eiHLh4JRXG1dWFCdKhIEk0SulwEOzaRSsJ/M/pwLnn0G2MRKlwLC+jEd+BvLcMvV7Elf8n4/0PqVAxmahferADH71ewJR64PMv6LrpdTShaXKdgMl1tNqJ1wvMmysU5PuUJAFTpgA+P0FTEx2U7NlLX1v5dSq0K8tpNZjhsA8cLEYjPRctFoIiPfrd/7NnCZgzm3ZRfPNt6gDdt7/v9VkzgaVLmV/80K/7ULBa8yfaAbRDn6uSRv3XvEVzC5xO2hHzMdoYFccfR3+zauGc9T0WAXPnAnY7wa491NJVUS4VZDWprqKt0ktKUHCy70AIgtDb+hl5kykLoaJcQKSRYMuWPmEcCBLEuvr/XPR//oDA+tfhsOtBTKWAvv/Ed0g6yKXTIHVtgzW+D75YEGSAj3B6ITIEf3tvVmX+qHFRrB2z9t8AjRyGWz8TqWN+CFu+8y0RhhB2Z34R/a/WBBh7p3cFAamjf4Dw5jfhsy2Epb4BZboCRbEaSQfxqG8gb+wu5geSUciV80CsVdmvCwJk51RATkLs2goiiFktqMcyo1bKbe7cubjnnnsGfN8VV1yRFjFWI4oiLrroIlx00UXDvXqHFcXFdIr8H3fTyJPBQG0QFRX9+18z0WoF1E8GjlpEYLPR60J7B4Eo0Onw2hpaQuxgBElxMbVSWCwHZ0MBaNR5xnQatdPqgMu+BbyxhkaVq1x0ensoto3M75g9G5g/j2D9BuCJp6k4MxppSbpAgG7TtMbBe6cHi9VKxYKjmGD3bprYJmloVLlxKhWjgx0IzJsrIBoj0EhUGPcnevqjrEzAIgP1cbe1UTEcT9C26JEIjXhXVha+PJOJ+plPPIEO+lpbqa2npneKfurUwsqbjRQ0sXXg9TGZBJzzJSqOmZdfkugsx7IT6YCrtZVGJPOJxrGOxSJixanUPrFhI7ViOJ0C7r6HnrNlZdTPn6sKSiYajYD6egE2G209XlYuFTTrotEImDmDXgvHIpNq6Uzc7j2AKBLodfQ33B/EVg3bpFoIEQ9SVlf/b+4lVTkf2i3PwpHajeaYHyCptLJvnNzQqLG736ixNuHGrH2/hS7phU87GZGlP0axPc++TUYhhLohl0xRCcze85ikIHTvBOJBQEftC8RYAt3i80FvX4MUxYWQiECI+pGqmANin5T/fYIIuXQ6QFIQu3aAWCoASTf863MIOGzrHHP6EEUBp55C8MxztETaySfRqgOT6wYv2EpLqQDZuZt6iyvKaES0pGR4knwkiVoVpGG6Posi9X4bDQTbthOcdy4tn2Sx0Kj5cKxzeRmtqbzpUyqMRZEKcY0GgIaKyoMV+oWi0QiYXCfAYSfYuZMgFqdCsax0aMfHZqNRWKdTGHRlhEwsFuo5ra6ig4YeN01mMptolHcw7a8BOribUk+90PEYtZB4fTQBbyiJr2OFRUcKOGIhwY6ddHbm+GNplDgQoMLYZsv2yI83zvwfmjwZDAJvvgXodTJWv0JfO+E4OmgvG0RH45ISAUdYAIdDg0K70o7lc0QU6eAvGqXe5fp6AY5kYSX7SJENxFjYCZJyLQAAWOU2kJAbSESzpsc5GRAZQiA9aqxJ+mCMNcMYa4Yh1gxjtAmm6F5oUwGEpAr4F/8UztI8JuNUAkKwE3LJFMgVc3KWgROJDLFzK4jWmN9HPlzISQihLsiljSAlDVk1mrNXToJcOgNIxCB69oHYaw79Og4DXBxzAFBx8/3vEXzxBc2Ur61F3vq5/SEIAqijhaCsTIDTWXiN1EIZil95IMrKaCLPtm0EHh/Q0DBwgkyh6HQC5swBFh1B8NHHwAVfoZHpQBCYO5smUo40druABQuoWD8Y24go0mj0cNoTRJHW0bbZBEyqJUilhuYtFwQB9fWAz0fg9tJqGJlVIMYjdhvwrUuo7aC8rE8Um820qU5lxcgNtg4VZWUCjjuWYPUr1Bvf3Ew9+vWTaYS0btLgI+M0H0MoWByPdbRamvCn5JR0F/AhQaTe0AKnt4m1CiljKaRwF4qCexBJLgDh4rhfhKiXRo2L7AAhaGz+E0p97+Z8b0RyovuIn6OsMs8+lVMQAm2Q7ZMgl8/MWx9ZLpkChLohBjtpdPZQQQjgb4Nsq4LsnF64yJW0kCtmAckITVK0uAYW1aMMF8ccAL0iZzYQixFYzHTabqiYTAJmzx7bJ34uLL0eRZ/v4O0UmZSX0XJxJy4DnMW0xvL0xtEVahqNQKPXB8mh9O1KknBQswR6vYCpU2mGv8NeeBWNsYwgCKhyAa1tRBHFM2ZQK8V4F8UMQRDw5fNoScm2NvoAaIKvyzX+I+PDxaBm9gQBRGcEMQ9CPOmMIMWTgXAXzLF9iMZDAybyHd4QKv4gAJIWxf6PFGEc1pQjoq9GwuQCsboAWyVEZy3KrHkucEQG/K2QrZWQK2b3b0fQ6EFKp4M0fQjEQ4OL7sspIOoD4iEI2iJ6fPNc04VQJ4jBBrlsFqAZpD1Ca4RcMQdS0zoI4W7qex/DcHHMUSgpAapdgLN04txkB4teLwxqunYwy62ro1nmnV20nvRw2TY4/VNSImD2TOrzPpgo+ViiuJjOPphME0sUq5nSIChefQCYO4dWRJlUy383Q0IQIVfOBzRFg/tM+SygeR3syb3ojvrBm4Hkh9Y1ZlHjFCZ1PAgAaCo9D9ZjzoExRym0nBACBNpAjMWQK+YWFOkn5jKQ4gaIXdtAtIaBo7qpOISIB0jFIBc5gPKZgK8Z8DcDlkra2lpNzA9CCD0fCmhokhODA3LFHIjNn1BBPobh4pijIEl0+n+8R9bGKuVltMSURjMyCXicPiorJ9a+liQB8+ZOrG3KRKOh0eP1G2iOwZLFdPA+lr3AY54hVAtIuRYA6/+F4tQeIBbizUDykYpD8LeCRY3LPG/AGGtGXLBAmn16zhrB+RBCnSBaI60dPFBVEeVDAuSSBiDUBTHUBWLOUxYqEQbCbjrwMZWC2GvpezU6wOqC2LkFoq+Ftn/W9tZvS8YgRL1IVcwDsQwiMzoHxOqCXDYTUvtngJw4qGUdSrg45qTBhfGhQ68XMGsmrUN7KHzTHM5EY/EiWttclmmi5qEqd8jJj1w+B0TUQCcHIQVbQBLTQbg4TicVh9izC0K4GzCWQpDjqO18FADQXnkunCWFWxCEcA8Ii/Kz8myFojWAlE0HOfARkIj0DYaIDMQCQNRPLRj2SSD2GpqYqfYxF9kgu44AdBaI3TtBtFGgyAYh2A65uB6kuH5w65MHUlIPORmG2P7FsCzvUMDFMYczghRaQ5jD4dAB5cknEWzdRmukm0z89zPSEIMdsq0GkmcvDOG9CPBmIOmk4hB7dkMIdQLGUkCUUNn9IvSJbkQkJ3SzTiw89yzsBpGTkF0LQCxDawhAzBUgJfUQu7aDWFwQev3EpMgKUjYdstVFbR/5Vkqjg1w+C6TICrFjCwTPXsi2ashl+RMCBw0r8RaP0IzSMQgXxxwOh8MZs7gqBUSjBC4XF8ajgrYIsnMqJM9eWOL7EYwGQcwDf+ywQBHGHYowllIhVHc9AQDorDkfZflqF2cS8QCpOGTXfBBb9cDvz4cg9FWvCLRBNpaAlM2gYpvZJApYBrHXIqW3QOzZTe0aw93AQ9JBds0H5OTwLneY4OKYw+FwOGMWk0nAnHFY/WYiIVfOB3a+iuLUHrTzZiAUtTA2OJWoalX3s9CmgghoqmGauaSwZUV9QCIK2TUPxF578OumNYJUzkMqGaNVIfrp0tcvBgfk6iMPfn3yodEDGJsWHS6OORwOh8Ph5CXlmg8AsKX2g8T8vBlIKgHRvadPGEtUSmkTHri6nwcAuCdfiLJCbEAxPxAPQa6Y23+3uUFSaKMXTm7GptmDw+FwOBzOmEB2TIass0KEDF1gP4RkZLRXaVQRfQcgBNvThDEA1HQ9DonE4NVPg2Xa3IEXFAvg/7d33/FVlvf/x1/3mTkje5Awwx4uQAEHdVLrwIHF0X4ttmqtrdpvrVonP0e/ra3aVqu1SmutaLWIW6mK1jqwCigqyhDZK0AI2Wef+/r9cZJISNhJThLez8fDR3LudT7nXIm8c53rvi4rUovd4+DUfNKaorDTUM+xiIiI7Jw3mApvmz4jEF5NLB5mzycm62ZMEitcBe5gs2CcES2jx7Y3AKgadAE9fNu9Q8kYJKKppaCTMYwdxwKMw526+W1PlmGWDqVwLCIiIjvncJEsGoZz02dkJ1ZTGa6C7N4ckIuBxMOpoOvd7q5Ek6T/pr/hIMlW/2hyBg2Exj8fElGs+s0YTybG7cMEC8ETxHZlpKZeC+x8RTpJH4VjERER2aVkz9GwcAZ5yRWsidZCrA48e7hARTdixcOpGRYal3M2hgFlfyOv9mOSuKgfdj5Fnu16jUNbsbP7Yfc8bNdLQEunojHHIiIiskt2yWEYHPjtCqzQVhyhbekuKS2saD3b95j3Ln+Wkm2vYrBY3f8q8vsXf31wPAyWMzUkRcG4S1E4FhERkV0ygQLshqWDM6KbsOrLIdl5l/9tHwai1amlloGiyn/Tb8uTAKzu+QOKRo7CuX2qCm3FZPfWzBFdkMKxiIiI7Jrbn1oMAsiMrYZYCCtSldaSOlwimhpW4cogt/YjBm34MwDrCs4hd8zxuFzbDaeI1YPTi61ZKLokhWMRERHZNcvCLj4EgNzoEnC4UksmH0DzVljxECTjBKOrGLr2HixsyrJOIHDk2Xg9O7wPoQpMTh/w5aanWNkvCsciIiKyW8l+x2CwKEh8icuuxwpXp27MO0BYsRAZ8U2MWHsnThNjq380zqMvwufbIRhHa8Htw84tTUudsv8UjkVERGS37LxSkvmDAcjd9l+w4wfWjXmRavpVvYQ7WUuVZzDxo64gM3OHIRPGYIUrMTmlkJGdljJl/ykci4iIyO65A9j9jgSgV91b4PIdODfmJWNY0TqyIl8BUDv8QnLyWpkNN1qD8QSxc9tuKWjpeArHIiIisnsuD4l+47FdPgJ2Ob7Q6gPmxjwrHiYjug5PsoYkbjzFfVseZAxWpDo1ddv2i4RIl6NwLCIiInsm2INkw415BZVvHzg35iVCZIWXA1DjHUQg2Ep8ilRhvJnY2b07uDhpawrHIiIiskdMRhZ2r9EA9Ax/gOV0HBA35lmROjJjqwCIZA9pPp8xQDKOFa3FzhsInkDHFyhtSuFYRERE9ojx5WIXDCUZKMZFlKxtH3f/G/NMEitaTVZ0JQB24eAd9ttYtWXY2X0wOa0Mt5AuR+FYRERE9ozLi8nuhd3zMACKa94Cd6B735gXD+GKbsMf2wCAo3Dg1/uMgZqN2MEi7OKDm1bPk65N4VhERET2mAn2INlzFMZyUBBfgitR1a1vzLPiETLDqVkq6lw98ed8PWzCqt8C3kzs4kM1nKIbUTgWERGRPWZ8udg5fUgWDAMgb+s7qRvzuunQCitaT2Z0BQD1wWF43A03H4a2YSwHdslh4MtJX4HS5hSORUREZM853ZDVm2RJamhFr/r/gMMJ8RDdb9YKA9EqsqKpm/EaF0EhWguJCHbxIZhgURrrk/agcCwiIiJ7xQ4UYBcfhO0O4re34a9ZipWMQTKW7tLaVjyCI1ZHsOFmPFM4COJhrEgVpmgEJrtPmguU9qBwLCIiInvHl4MJFGH3HAlAQfX7kEx0u3BsJUIEwitwmjgxRyYZBT2wQlux8wdh5w8Ey9r9RaTLUTgWERGRvWM5MNm9mxYE6RmdiyNek+o97kasWJisSGq8cbVvKD5PHGM5MFm9UkNJpFtSOBYREZG9Zvz52HkDSGT2xkmcrKoF3a7nmEh10+If8dwhWIkIuHwYj5aH7s4UjkVERGTveTMxgQJMw5zHeZHPsWLRNBfVhpIxrGhdU88xBYOx4iFMRha4M9Jbm7QrhWMRERHZe5aFyeqFHewBQKa9GeL1aS6q7VjxEN7oBjzJKmxcOHv0wySi4C9Id2nSzhSORUREZJ+YQD52w5LJAXsLJlIDxk5zVW0kHiYrshyAGu9AAgELywKTkZnmwqS9KRyLiIjIvnH7MQWDMU4vFgZn/ZbuMe7YTmDVbSEzthqAcNYQnHYU48rAeBSOuzuFYxEREdlnJqsEu2GogSeysVvMWGGFq7AiNWQ1zm/cON7YEwCPP83VSXtTOBYREZF9Znz5mKxiAHyxzV2/59jYWLWbcBLFH10HgFU0CBMPg78QLEWn7s7VUU8UCoV44403eOutt1i6dCllZWV4PB6GDRvGBRdcwMSJE/fqekOHDt3pvmuuuYbLLrtsf0sWERGR3XF5sPMHwYaP8SU2QaJrh2MrUokVriQzuQkLQ72rGF9OECu0DTsjK93lSQfosHD80Ucf8Ytf/IKcnByOOuooTj75ZCoqKnjjjTe45ppr+OSTT5g6depeXbNXr15MmjSpxfbRo0e3VdkiIiKyG3b+ICA1Y4UVD2HSXM++M1i1m8DhIKt+GQB1gWFkOaMYpxvj1fzGB4IOC8dFRUXcc889nHLKKbjd7qbtP//5zznvvPN44oknOOusszj00EP3+Jq9evXiqquuao9yRUREZA/ZeQMAyLTLMLFQmqvZd1a4GitUCRnZZG7+EoBk/mCIh8HtAy3+cUDosIEzw4YN44wzzmgWjAEKCgo4//zzAZg/f35HlSMiIiJtpLHnOMPUQH0l2Ik0V7QvDFbdJsCAw0Fm+KvU5sLBWPEwxp8HTvcuryDdQ4f1HO+Ky5Uqw+ncu3XKa2pqmDlzJhUVFeTl5TF27FhKS0vboUIRERHZKX8+tjcbR7Qad6SMWDIGjk4RMfaYFanBClVARjaByGqcdoSYFcBT0ANiazG+vHSXKB0k7T+5yWSSF154AcuyOProo/fq3KVLl3LLLbc0PbYsizPOOIM77rgDn8/X1qWKiIhIaxxOTGYxRKvxhsuIJ2IYd1ea8sxg1W0G2wanh6z6xQDU+Ibi9yYxCSdovPEBI+3h+L777mPZsmV8+9vfZsiQIXt83sUXX8ypp55Kv379sCyLxYsX84c//IGXXnqJZDLJ73//+12en52djcPR8dOx5ObmdvhzSvtTu3Y/atPuqdu2a6LlMIacnBzowNebKByI2folQXsrxufByuyYxTIy2+B5TKQGY9dDbhGW003PytcBsEtGE/Q5wF2Io0cfLLc63jpCun9P9zocjxs3jqqqqj0+fvr06YwbN67VfTNmzODhhx9mxIgR3HzzzXtVx/XXX9/s8ZFHHsnf//53zjrrLGbNmsWPf/xjBg8evNPzq6ur9+r52kJubi6VlZUd/rzSvtSu3Y/atHvqzu1qVVWRs8O2qqoqjKvj+sDcgZ54AW9sI5urt2HT/j3HmZmZ1NbW7vd1HBUrseprwfJRtOVVMqIbiTqySJYeRahyK7YvF7suAkT2v2jZpfb+Pd2T4L3XvzUTJ06kvr5+j48vKChodfuzzz7LrbfeypAhQ/jb3/5GIBDY21Ja8Pl8nH766Tz44IMsWLBgl+FYRERE2o7J7QdApr0J4l1oxopYPVZ9OXgzsew4fbbMBGBL8Vnk57ow1RHIbz3LSPe01+F4b+cibs0zzzzD1KlTGTRoEI899libdp83XiscDrfZNUVERGTXkgWpDqlMexN2uA4wgJXWmvaEFamGZBR8ORRte52M+BYijlxcB52AhcGywM7omCEi0jl0+KDbZ555hltuuYUBAwbw2GOPkZfXtnd/fvbZZwD07t27Ta8rIiIiO2dySzGWAxdRHKGtkOwa07lZ0WpwurHsGH22PAPAlpKzyclxQiKCcWVgPArHB5IODcczZ85sFozz8/N3eXw4HGbFihVs3Lix2fbFixe32jP86quvMmvWLHJzcznqqKPatHYRERHZBW8mxp8afuAJb0z1xnZ2yQRWtA6cXoor38CbqCDszMdz0DdS++Ph1Kwbnq4084bsrw4bqf/BBx8wdepUjDEcccQRPPXUUy2OGT58OBMmTGh6vHDhQqZMmcLYsWN5/PHHm7ZPnz6dN998k6OOOoqSkhKMMSxevJiPPvoIr9fLb3/72zYZwywiIiJ7yHJgMkugfgve6CaiyXinX0baSoQgEcXh9dO7/FkAtvScRFF2w7oL8RBk9wKr42e3kvTpsHBcVlaGMalfkxkzZrR6zKRJk5qF45056aSTqKmpYdGiRbz33nskEgl69OjB5MmTufjiixk4cGCb1i4iIiK7Z+f0xbnpM/yJTdR0hZ7jeAhMkuKqN/Ekqgg5i8g4aHzTbssY7Iyc9NUnadFh4ficc87hnHPO2atzxo0bx5dfftli+ze/+U2++c1vtlVpIiIi0gbsvFIAAsnNWIlo5+85jtbiMHF6lT8HQHnvcyjKbLiJMBnDOF0YLf5xwNHnBCIiItIm7Nz+AGSazZ1/OjeTxIrUUFL3Hp5kDfWuYnzDj/x6fzwMbj94FI4PNArHIiIi0ibs/NSwxoC9BROqgc7cdxwP44xV0avyVQDK+0wmM/PrqeeseBjjywWnO10VSpooHIuIiEibMFm9ME4vDmyc9ZshGUt3STtlxcMU1vwXt11HnasXwRFjvt6ZjIMdxwR7pK9ASRuFYxEREWkbbh92sAgAT2Rj5w7H0XqyI8sAqCkaT2D72dpCW7EzizFZJekpTtJK4VhERETahuXAZPUEwBfbhJXorOHYQHgbmdEVqUeFQ77elYiAMZi8QeDosHkLpBNROBYREZE2Y3L6AeBLdOJhFfEIvsg6vMkqkrhwFff/el99OSa7D6ahB1wOPArHIiIi0maSualwnGlvxoq3XM22M7ASIbLqlwBQ4x1MINiw6EesDlwZ2PkDwLJ2cQXpzhSORUREpM2YvAEAZNplmGjnnM7NioXJin4FQCRnGE4HYAxWaBsmpxR8uWmtT9JL4VhERETaTDJ/EAAZphoilWCSaa5oRwbCVWRFUuON7cbxxpEqjDezaSETOXApHIuIiEjb8edje7IAcNeXQWe7KS8Zwxtejy+xBYMDZ49BYCexorXYeQPBE0h3hZJmCsciIiLSdlxeTGZqfmBveCNWJ7spz4qFyapfDECNp5RAlhcrvA3bn4/J6Zvm6qQzUDgWERGRtrPddG4Z8U44Y0UiTFYkNd44lDUclxWDRBRTMBhcnjQXJ52BwrGIiIi0KbthxopAclOnC8dWpJqs6HIA7IIhqV7jzB6YTC34ISkKxyIiItKm7NzUvMGZ9masWH2aq9lOMoE7VEYgtgEAR4/BqV7jzJ7gcKa5OOksFI5FRESkTdnbTedmR+oAk96CGiXCZDaMN65z9cKfnYFxOMEbTHNh0pkoHIuIiEibsnNLMThwEcVRXw6JaLpLAsCKh8gOfwlAXeZwPITA7cd4s9JcmXQmCsciIiLStryZGH8+AJ7QRqxEJM0FpVjRWrKiqfmNkwVDseIhjC8HXN70FiadisKxiIiItC1XxtfTucU2d46eY2PjCG0hEF0LgNVjCCYZw/gL0lyYdDYKxyIiItK2LAs7qxcA/sRmrHg4zQUB8TBZ9UtwkCTsLMCXm4WFA7yZ6a5MOhmFYxEREWlzdsMy0lnJDRCtS3M1YMXqyQotAaAmMIIMK4Rx+zTeWFpQOBYREZE2ZxcMBiDbXgfxMCQTaa0nNb9xarxxIn8IVrwek5EN7oy01iWdj8KxiIiItDm7cCgGiwxTDeFtkEzjTXnJGI7wVjKjK1OPewzFJGKYYGH6apJOS+FYRERE2pzJyMFumLHCW78OK4035VmxOoJ1X+I0caKOLDLyC7EsCzSkQlqhcCwiIiJtz5UBWT0B8MU2Qhqnc0tN4fYVADX+4fic9Q3jjXUznrSkcCwiIiJtz+Ulmd0bgGB8Y/qWkTZJCG0jq2FIRTxvKI5EGJORBW5femqSTk3hWERERNqeZWHyBgKQZa+HWD1pWUY6FsKK1ZEVSfUcm6KhmEQE/BpvLK1TOBYREZF2YReNACA7uR4TDadlMRArVoc/uhaXHSJh+fAWlmDhSM1UIdIKhWMRERFpF3ZeKcbhxkkMZ/2mNCwjbbBCFeRGlgJQ5RuBzxXBuLwYb7CDa5GuQuFYRERE2ocniB1MLSOdEd3Q8T3H8QhWtI688OcARApH4UyGUgt/uP0dW4t0GQrHIiIi0i6M24dpmLHCH93Y4ctIW7E6XLEKMsOp8caOvodh4hEIFoFldWgt0nUoHIuIiEj7cPuwc/oCkJmGZaStcBW54UVYGKo9/QnkZWJZYDI0hZvsnMKxiIiItA/L0WwZaSvRgctIJ+NYkSryIosAqM87HI8VxrgyUsMqRHZC4VhERETaTbLHQQAE7c3YkboOW0baitVhxerICX0BgOk5EisWSi38ofHGsgsKxyIiItJ+MouxPalhDJ4OXEbaitaQFfkSlx0m4sjFW9IHkwhDoFDjjWWXFI5FRESk3Ri3H5NZDIAvWtYxy0gbG0LbyIssBqAy63ACPoMFmt9YdkvhWERERNqPy4ed1QsAf7ysY5aRjtdjxerJC30GQLJkJCQiGm8se0ThWERERNqPy4udWwpAVrJjlpG2oqlV8TLi5STx4Oo9HCsewniC4Am063NL16dwLCIiIu3HsrALhwKQba+FWKSdFwMxWKFt5DYOqfAfQmaWCxMPQWaJxhvLbikci4iISLuyC4djcOA1dRCuaN9lpBNRrGgteaHUqnjRHqNwkADLgfHntt/zSrfh6sgnu+GGG3j++edb3de/f39ee+21vbree++9x7Rp01i0aBHGGA4++GAuu+wyvvGNb7RFuSIiItIWfNkYfz5WqJyM8EbC7dhzbMUjuGMVZEaWpx73PgxideAJ6mY82SMdGo4bTZkyhays5gPic3P37q+5l156ieuuu47c3FwmTZqEZVm8+uqrXHrppdx9992ceeaZbVmyiIiI7CPj9mNn98QRKscX20gkFm6/UcfJKLmhzxtWxRtAsCAb6tdhCgaD09NezyrdSFrC8UUXXUTv3r33+fzq6mp++ctfkpuby/PPP09JSQkAl112Geeccw6//OUvOe6448jO1l+IIiIiaef2YbJ6Q9lnBBMbqYy13zLSViJCbjg1pKI+73BynUksDLY/v92eU7qXLjnm+LXXXqOmpoYLL7ywKRgDFBUVMWXKFGpqavZ6iIaIiIi0E6cbO28AAFn2+nZdRtqK1pATTt2MZ/c6DGIhjDuA8eW0y/NJ95OWcPzOO+8wbdo0/v73v/PBBx+QTCb36vx58+YBMH78+Bb7GscbNx4jIiIi6Wf3GAFAdnI9dizcTstIG7JrFuAyUSKOPHwlfbBidRh/vpaMlj2WlmEVd9xxR7PHpaWl/P73v+eggw7ao/NXr14NQL9+/Vrsa9y2Zs2a/StSRERE2oyd2x/j9OJIRnHVbyKRiKbmHW5LyRj5NfMBqMo+nOwMA9VxTLCobZ9HurUODcdjxozhxBNP5NBDDyU3N5f169czY8YMnnjiCS6++GJeeuklevTosdvr1NWlxiplZma22Of3+3E6ndTW1u7yGtnZ2TgcHd9xvrc3HkrXoHbtftSm3VO3bddEyyEKOTk50Iler3HFSWSVQOVqgsly4l4nViv/ju+t7bOACSebVsVzlo4j4HMBeThK+mP5dB9SV5Hu39O9Dsfjxo2jqqpqj4+fPn0648aNA+Db3/52s30DBw7kpptuwufz8dBDD/H3v/+d66+/fm9L2ifV1dUd8jzby83NpbKyssOfV9qX2rX7UZt2T925Xa2qKnJ22FZVVYVxpeUD4tbFYmQEi3FVrsYTXkt15RZsZ85+XTIzM7NZZ5hv20K8iQqSeEgW9idUsQnbm40dTkKke7Z9d9Pev6d7Erz3+rdm4sSJ1Nfv+broBQUFuz1m8uTJPPTQQ3zyySd7dM1gMPUxTG1tbYsXGQqFSCaTrfYqi4iISJq4fdi5/WDdh2QmNlDetIx0261Y569bAUCdpw/BTBfURjAFQ7UqnuyVvQ7HU6dObfMiGgNuOBzeo+NLS0v54osvWLNmTYtw3DjWuLXxyCIiIpImlgM7bzCQWkbaSsRSy0i7MtrsKfyhVDiOZpSQaWIYywVaFU/2UqeYyu2zz1Ljg3r16rVHx48ZMwaAOXPmtNj33nvvATB27Ng2qk5ERETagl00HICAvRU7Uo3Vxivl+UOpDjI72BNidZiMTK2KJ3utw8JxeXk5a9eubbF98+bN/N///R+QGrKxvXA4zIoVK9i4cWOz7aeeeiqZmZk88cQTlJWVNW3fsmUL06dPJysri1NOOaUdXoWIiIjsK5PZA9ubCqueUFmq57it2Al80fWpb7OKIVYPwR7g6ETjrqVL6LCfmJUrV3LRRRdx+OGHM2DAALKzs9mwYQNvv/02oVCISZMmceqppzY7Z+HChUyZMoWxY8fy+OOPN23Pzs5m6tSp/OIXv2DSpEmcfvrpTctHb926lbvuukur44mIiHQyxu3DZBZDtBpfbCPxRBsuI52I4YttSn0fLMLC0qp4sk86LBz37duXyZMns3DhQl5//XXq6+sJBoOMGjWKyZMnc9ppp+3V9c466yxyc3OZNm0azz33HAAHHXQQv/nNb5oWAhEREZFOxO3Hzu6Fc+uX+OObqIm23TLS7kg5bjt1PWcwiPGA8Wm8sey9DgvHJSUlTcMn9tS4ceP48ssvd7r/2GOP5dhjj93f0kRERKQjuLzYOX0ByLbXszkRBjvRJkMffPWpm/HCzgJ8jigm0Btc3v2+rhx4OsUNeSIiInIAsCzsgmEAZCXXYeIxSMTa5NL+8EoAQp6eeJxaFU/2ncKxiIiIdBi7cCgGB15TB+FtWMm2uSnPV78KgISvB8adgcnIaZPryoFH4VhEREQ6ji8H03CjnDdcBolIG1zU4I+sA8D252PcPvAE2uC6ciBSOBYREZEO0zRjBeCLlWHFQ/t/0WQMX7Rh2ld/LniztCqe7DOFYxEREek4bh92dmrRr2CyDKJ1sL8TuiVCZMQ3A2AFc1LhWGQfKRyLiIhIx3F6sPP6A5CVXJ9aJS8Z369L+urX4iBJwvLgDmSmhlWI7COFYxEREelQdkFqGems5DrsWBT286Y8X33DTBWunmR4Dbgz9rtGOXApHIuIiEiHsvMHYCwXLmI4I1tTvcf7wR9KheNoRg8cHi/GpXAs+07hWERERDqWNxM7WJj6NrIRK75/M1b4QmsASPqKwOkGhWPZDwrHIiIi0qGM24fJ6gmAL74JYvX7fjE7gT+6PnVdfz7GHUgFZJF9pHAsIiIiHcvtw2T1BiCYKIN4iH2esSIZwxcrA8Dy50KGZqqQ/aNwLCIiIh3L4SLZMGNFtr0uNeZ4H8cduyKVeJLVAFiZORgt/iH7SeFYREREOpwpSs1YkZnciB0LYe3jSnm++hUARBy5ZPhdGm8s+03hWERERDqcnd0X25mBgySucDkkYvt0ncaZKsKeEtxup+Y4lv2mcCwiIiIdz+PHBIsAyIhuwkqE9+kyvoZwHMvogeX2qOdY9pvCsYiIiHQ44/Y3zVjhjzcuI72X1zAGf3ht6vtAIcblBZe3TeuUA4/CsYiIiHQ8dwZ2dsOMFckNqZ5jO7F310hG8cU2AmD8eeAJgqVoI/tHP0EiIiLS8Rwu7LyBAGQn10MytvMZK5IJWp3qLR4hI7459X0gGzKy26dWOaAoHIuIiEha2A0zVgTtzdjheqxky3BshatwbvocR/U6MMlm+zz1a3GaOElceALZuhlP2oTCsYiIiKSFySrB9gQB8EQ2t+g5tsJVOCq+glgd1rZVOCpWpnqYG3hrvgIg5C7Bm4FuxpM2oXAsIiIi6eH2YYI9AMiIlWFtt4x0UzBOxiFYCL5crNoNOLYug1godU7dcgAinmKcHhdG4VjagMKxiIiIpEXzGSs2QawOMM2DsT8vdbDTA/5CrNA2HOVLscJVZNSvAiAZKErtdyscy/5TOBYREZH0cGVgZ/cBIDO5HisRw6orbxmMGzmcECjESkRwlC/F2ziNmy8f4/anArLIflI4FhERkfRwOLELBgGQnVyHScRwVK5uPRg3sqzUPoeTjMj61DZ/LnizOqZm6fYUjkVERCRt7MLUjBU+UwXRGjCJZsE4GF5OfvV/wTSfys3hduNJVKa+D+ZgvMEOq1m6N1e6CxAREZEDl/HnY2fk4ohU4iFC3Pd1MM6pXcDwNb/BQYIN2SezuvcPwXIC4IumFv+IOrLw+r0abyxtRj3HIiIikj5uHyYzNWOFr2EMMUBW3RcMW3sXDlKr5vWqns3AtfdjmdTjxnAccvfE47UwLs1xLG1D4VhERETSxrh92Fm9AAhEU+E4GPqSEWt/jdPEKPcfQdWhP8bGSXHtuwxafQ+WHcMX2wBALKMHlssDLm/aXoN0LxpWISIiIunj9mEaZqzISqyhJryKg1b/H047wlbfYSTH/4RgtpNoMAPvBw9QVD8P56o7wZWamcL2FzRM46aeY2kb6jkWERGR9LEcJBtnrEis4qDVt+Oy66n0Did+9E/Jzk6NMabXSKLjryHp8JIf/oz82vmp7f58TEYmWIo00jb0kyQiIiJpZQqGYSwHbhPBnayhyjOI8NE/Jydvhw+4i4cTP+4XJJ2Br7cFcjSNm7QphWMRERFJK+PLTg2PAGrc/ag/6jpyC1pf0MMUDCJ2wg3EPbmEPSV4srIxGlIhbUhjjkVERCS93D4SQ75Fzbq11A8/n/yi3UzLltuXxMS7sFyZBKqWk9RMFdKGFI5FREQkrYwrA7tkJBn9jibD7W95QLQG3IHU8tGNnB78GTb1DjdGcxxLG9KwChEREUkvty8VcBPRFrus+nKIh6FmA9jJ5jsTsdQUbuo5ljakcCwiIiLpZTnAk4W1YzgOb8MAdvEhmGBxKiAb++v9iSjGlQFOd4eWK92bwrGIiIikX0YWxo5//ThaC/EIdo+DMbml2D0PwwQKmwfkZDQ1U4Vlpadm6ZYUjkVERCTtjCdAU8SNh7Ai1ZiiEZicvqlt3kzsniMxvjyoLQNjIJlIzXEs0oYUjkVERCT93BkYy5kKxvVbsQuGYhcMat4rnJGdCsjeLKjdmArTGm8sbazDZqtYv349J5100i6PcTgcLFmyZI+uN3To0J3uu+aaa7jsssv2qj4RERFJH+P2gdODVbsJu2AIdtHQ1le98+Vi9xyFc8PHGMukbsgTaUMdFo6zsrK48sorW933xRdf8PbbbzN+/Pi9umavXr2YNGlSi+2jR4/epxpFREQkTVwZGE8A48/H7nEwOHYRUfx52D1HYcU2YzzBjqtRDggdGo6vuuqqVvddfvnlAJx77rl7dc1evXrt9JoiIiLShVgOTI+DMJ4AuFpfHW97JlCA1WsQVFW1f21yQEn7IiCbN2/m3XffJT8/nxNOOCHd5YiIiEiamEDBXh1vaZYKaQdpD8fPP/88yWSSs846C7d77+YprKmpYebMmVRUVJCXl8fYsWMpLS1tn0JFREREpNtLazg2xvDss88CMHny5L0+f+nSpdxyyy1Njy3L4owzzuCOO+7A59PdqyIiIiKyd9IajufNm8fatWs5/PDDGThw4F6de/HFF3PqqafSr18/LMti8eLF/OEPf+Cll14imUzy+9//fpfnZ2dn43B0/Ex2ubm5Hf6c0v7Urt2P2rR76rbtmki02JSTkwPd9fVup9u26QEs3W1qGWPM3pwwbtw4qvZi8Pv06dMZN25cq/uuu+46XnrpJe68807OOeecvSmjVeFwmLPOOos1a9bwyiuvMHjw4J0eW1lZud/Pt7dyc3PT8rzSvtSu3Y/atHvqzu1qbd1KzpAhzbZVLVuGKdi7MbxdTXdu0wNVe7fpngTvve45njhxIvX19Xt8fMFOfjFramqYPXs2wWCQU089dW/LaJXP5+P000/nwQcfZMGCBbsMxyIiIiIiO9rrcDx16tQ2eeKXX36ZSCTC+eef36bjgxv/IgiHw212TRERERE5MKRtzHHjjXh7O7fx7nz22WcA9O7de5fHpWs8S7rH0Uj7ULt2P2rT7qnbtmtuLuwwSjInPZV0uG7bpgewdLdpx9+RBixZsoRFixYxdOhQDjnkkJ0eFw6HWbFiBRs3bmy2ffHixa32DL/66qvMmjWL3NxcjjrqqDavW0RERES6t7T0HD/zzDPA7nuNFy5cyJQpUxg7diyPP/540/bp06fz5ptvctRRR1FSUoIxhsWLF/PRRx/h9Xr57W9/SyAQaNfXICIiIiLdT4eH42g0yssvv4zH4+HMM8/cp2ucdNJJ1NTUsGjRIt577z0SiQQ9evRg8uTJXHzxxXs9LZyIiIiICOzDVG4iIiIiIt1VWsYci4iIiIh0RgrHIiIiIiINFI5FRERERBooHIuIiIiINFA4FhERERFpoHAsIiIiItJA4VhEREREpIHCsYiIiIhIA4VjEREREZEGCsciIiIiIg0UjkVEREREGigci0iX9L3vfY+hQ4cyd+7cDnm+9evXM3ToUE488cQOeT7ZfzfccANDhw7lueeeS3cpItKFuNJdgIjsn48//pgXXniB+fPnU15eTjQaJTc3lxEjRjBhwgROP/10/H5/usvs9P7+979TW1vLRRddRFZWVrrL2W/vvPMOs2bNYsGCBVRUVJBMJikoKOCggw7ilFNO4eSTT8btdqe7zE5n7ty5TJkyBYAvv/wyzdWkX01NDY899hiZmZl8//vfT3c5Ih1C4VikiwqHw9x44428+uqrAHi9Xvr27YvX62Xz5s28/fbbvP3229x333088sgjDB06NM0Vd27Tp09nw4YNTJo0qdVw7Ha76d+/Pz169EhDdXtu27Zt/OxnP2vqUQ8EAvTu3Ru3283GjRuZPXs2s2fPprS0lMcff5yioqI0VyydWU1NDQ888AC9evVSOJYDhsKxSBcUj8e5+OKLWbBgAYWFhVx77bWccsopZGRkNB2zfPlypk+fzrPPPsu6desUjvdTjx49eO2119Jdxi7V1tbyne98h9WrV1NaWsp1113Hcccd16yH+PPPP+eRRx7htddeo6KiQuFYRGQHCsciXdADDzzAggULKCgo4J///Ce9e/duccygQYO44447OPPMM3E4dHvBgeD2229n9erVDBo0iCeeeILc3NwWxxxyyCHce++9vPHGG/h8vjRUKSLSuSkci3QxtbW1PP744wDcdNNNrQbj7R1xxBHNHt9www08//zz3HnnnZxzzjktjr///vt54IEHuPLKK7nqqqta3X7hhRdy33338dZbb1FVVUVpaSk/+tGPOP300wHYsGEDDzzwAO+99x41NTUMGjSIn/70pxx//PEtnq+xR3tn4ztPPPFENmzYwL///e/dvlZIfQz8+uuv89Zbb7F8+XI2b96M2+1mwIABnHHGGXz3u9/F5fr6f33PPfccN954Y9Pjk046qdn1pk+fzrhx41i/fj0nnXQSvXr14q233gLgq6++YuLEiWRnZzNnzhw8Hk+rNZ1zzjksWrSIBx98sNn1jTH861//4plnnmHx4sXU19fTo0cPTjjhBH70ox9RWFi429fbaM2aNcyaNQuAX/3qV60G4+1985vfbPZ4b983oNX3ZEc7a98NGzbw8MMP8/777zc9V15eHsOGDeO0005r+lkCSCaT/Oc//+Hf//43CxcuZNOmTSQSCXr27MkJJ5zApZdeSl5e3p69Ufth+5/FjRs38uCDD/LFF1/gcDgYM2YM1113HaWlpQD8+9//5pFHHmHp0qU4nU6+8Y1vcP3117cYltM4xnns2LH87W9/4+GHH+bll19m48aN5OTkMGHCBP73f/+XnJycFvV8+umnzJ49mw8//JCysjJqa2vJz89n7NixXHbZZQwePHinr2XlypU8+uijfPjhh2zevBmfz0evXr04/vjjueCCCygqKmr6fwWk2mvHT580Jlu6K4VjkS7m7bffpr6+nry8PL71rW91+PNXV1dz/vnns3HjRoYMGQKk/pH8+c9/Tjwe59BDD+XCCy8kFAoxYMAAEokEixYt4ic/+Ql//etfOfroo9u1vv/85z/ccsstuN1uioqKGDJkCFVVVXzxxRcsXLiQ999/nz//+c9Nven5+fmMHj2aL774glgsxsEHH9ws5GZmZu70uQYPHsyQIUNYtmwZc+bMaXUmi1WrVrFo0SKys7P5xje+0bQ9Ho9z7bXXNg3VKCoqori4mDVr1vD444/z2muv8fjjj9O/f/89et2vvvoqtm0zYsQIRo4cuUfnbG9v37f9sX79eiZPnkxlZSU+n4/+/fvjdDopKyvjzTffZP369c3CcXl5OVdccQUOh4P8/Hz69etHOBxmw4YNTUNEnn76aQoKCva7tj3x5ptvctddd5GTk0Pfvn1ZtWoVb775Jp999hnPP/88s2bN4s4776S4uJg+ffqwcuVKZs2axeLFi3nxxRfxer0trmmM4corr+Ttt9+mtLSUgQMH8tVXX/Hkk0/y/vvv89RTT5Gfn9/snOuuu461a9eSk5NDUVERRUVFbNiwgZdeeonZs2czbdo0xo0b1+K5XnrpJW666Sbi8TgZGRkMGjSIcDjMV199xaJFi+jduzfnnHMOpaWlHHzwwXzxxRd4PB4OPvjgdntPRToThWORLuaTTz4BYPTo0S168jrCP//5T0aPHt3sH+tp06bxu9/9jnvuuYeSkhKOPPJI7rjjDoLBILZtc9tttzFjxgz+8Ic/tHs4Hjp0KA8//DBHH310s5C7bt06brzxRt5++21efPFFJk2aBMBxxx3Hcccd19QreN999+1RD3WjM844g9/97nfMmjWr1XDc2Jt78sknN6vnj3/8I6+99hojRozg17/+NcOHDwcgEonw29/+lieffJJrr72WZ599do/qaPy5GDNmzB7Xvr29fd/2x6OPPkplZSWTJk1i6tSpBAKBpn0rVqzgo48+anZ8IBDgN7/5DSeccEKzHtSamhruu+8+nnjiCX73u99x55137ndte+Kee+7huuuu46KLLsLhcFBTU8MPf/hDPv30U2655Rbmzp3LPffcwxlnnAFAWVkZ3/ve91i1ahXPPvss3/3ud1tc85NPPiEjI4PHHnuMI488EoCNGzfy4x//mKVLl3L77bfzxz/+sdk5V1xxBYcffjh9+vRp2pZIJHj++ee57bbbuPnmm5k9e3azP2g+//zzpmB86aWXcsUVVzTNZhOPx5k9e3ZT7/bll1/OxIkTOemkkygsLOSpp55q2zdSpJPSQESRLmbz5s0AexXg2pLT6eTuu+9u1ot1ySWXUFxcTHl5OWVlZfzqV78iGAwC4HA4uPbaa/F6vSxcuJCqqqp2rW/YsGEcf/zxLYY49OnTh1//+tcAvPzyy232fKeffjqWZfHWW28RDodb7G8Mx9v3hG7bto2///3vBINB/vznPzcFY4CMjAymTp3KIYccwhdffNEiKO7M/v5cdOT7tnr1agC+//3vNwvGAAMHDuT8889vti0zM5NJkya1GFqQlZXF1KlTKSkp4dVXXyWRSLRJfbtz7LHH8oMf/KApdGZlZTUNQXr77bc599xzm4IxQElJCZdeeikA7733XqvXTCQSXHXVVU3BGKBnz5789re/BWD27NmsW7eu2Tlnn312s2AM4HK5OPfccznttNNYt24dn376abP9999/P/F4nG9/+9tcd911zaZ5dLvdnH766S2GYokcaNRzLNLF1NfXA6TtZqpjjz22xbhJp9PJkCFD2LRpExMnTmxRW1ZWFr1792bFihWsX7++1fGTbSkWi/H6668zd+5cysrKCIfDGGOa9i9durTNnqtXr16MGjWKBQsW8NZbbzULwYsXL2blypUUFhY2+3j7nXfeIRaLceKJJ1JcXNzimg6Hg+OPP57PP/+cefPm7VFYaYufi45630pKSgB4/fXXGTp0KJZl7dF5H3zwAf/5z39YvXo19fX12LYNpMbhh8Nh1qxZw8CBA9ukxl2ZPHlyi23b/4HT2v4RI0YAqSElrXG73a2eN2zYMA4//HA+/vhj5syZw3e+851m+1esWMGsWbNYtmwZ1dXVTX8glJWVAak2Gz16NJD6VOK///0vQFNYF5GWFI5FupjGnrbWeik7wo49VY0ab4ja1f4VK1YQCoXarTZIfRR98cUXs2rVqp0eU11d3abPOXHiRBYsWMArr7zSLBy/8sorAJx22mnNPtpetmwZAJ999lmLsNOooqIC+LpHeHf29+eiI9+3//mf/+GFF17gwQcf5MUXX2T8+PEcccQRjBs3rtV5pGOxGFdffTVvvvnmLq/b3p9KNOrbt2+LbdvfENja/sYbJBv/iNlRcXFx06ctOxo4cCAff/xxU497o4cffph777236Y+E1mzfZmvWrCEej5OVlcWAAQN2eo7IgU7hWKSLaQwPO+uBam8765ls7P3b3f7teyLbww033MCqVas47LDDuOqqqxg+fDjZ2dm43W4SiQQHHXRQm3/8fuqpp/LrX/+a9957j+rqarKzszHGNC3QMnHixGbH19bWAqnevcYevp2JRqN7VEOPHj1YsmTJPv9cdOT7Nnz4cJ544gnuv/9+PvzwQ2bMmMGMGTOwLItjjjmGm266qVkP8LRp03jzzTeb5vQeM2YMhYWFTUNAvvOd77BgwYIOG1ax/Xzijbbv/W7td2B3veM73mzX2r7tg/X8+fP5/e9/j9Pp5JprruHEE0+kZ8+e+Hw+LMviD3/4Aw899FCz96Surg7Y9U2mIqJwLNLljBo1in/84x988sknJBKJvb4pb3chtb17dnfGGNNqgNibejZv3szcuXPx+XxMmzatxfCN3QXRfZWXl8dRRx3Fe++9x+zZszn33HP5+OOP2bhxI/369ePQQw9tdnzjOM/LL7+cq6++uk1qGDVqFG+//Tbz58/f63P39X3bn5+lkSNH8sgjj1BfX8+CBQuYO3cur7zyCnPmzOEHP/gBr7zyStNKhY1jne+8885mM3402rRp025fY2e3bdu23e7bfnx243tyySWXcNlll7U4p7X3pPH8xj/ORKR1uiFPpIs57rjj8Pv9VFRU8Prrr+/1+Y29Wjv7x3jt2rX7Vd/eagyKrdVTW1tLZWXlHl9r48aNAAwYMKDVcc3tOS9rY+9w41CKxq/bD7NoNGjQICA1T3JbOeWUU3A4HCxevLjFTVi7s6/vW1v8LAUCAb7xjW9w7bXX8uqrr9K3b182b97Mu+++23TMhg0bgNQfADuqrKzc46EnnVlZWdlOh1ysWLECoGkOZdj1ewKtjw8vLS3F7XZTU1PDypUr96iuPR0PLtKdKByLdDFZWVl873vfA+DXv/71bj9G//jjj1mwYEHT48YxwZ9//nmLYzdt2sScOXPasNrda5xdobV6Zs6cuVfXavy4u6KiotXezL/+9a+7PXdPhzHs6Jvf/CYZGRnMmzePsrKypj9cdhxSATQt6fzuu++2GEe6r0pLSznttNMAuPnmm3c7/vbNN99seu59fd9yc3PJzMwkEom0GvT3tv18Pl/T3Nlbtmxp2r59fTt69NFHSSaTe/U8nVE8HueZZ55psX3ZsmV89NFHTUNOGjXOldzaezJnzpxWw3FGRgbjx48H4G9/+9se1dX43kcikT06XqQ7UDgW6YKuvPJKRo0axdatW7ngggt44YUXWoS6VatWcfvttzNlypRmPXvHHnsskFrB65133mnavmXLFq699toODxqN9dx7771s3bq1afu7777Ln/70p70aNjJo0CCys7PZtGkTf/7zn5uCXjQa5f/+7/9YvHjxTs9t/KNh3rx5+/IyCAQCnHDCCdi2zdSpU9m2bRvDhw9vdfaEHj16cNFFFxGPx7nkkkuYO3dus/3GGBYuXMitt97aYvquXfl//+//0bdvX5YvX87555/Pv//9b+LxeLNjlixZwjXXXMOVV17ZdPPevr5vlmU1ha3f/OY3zXo+n3/++Z3O0Xzrrbfyr3/9q8XNg/Pnz+eDDz4Avp7dAeDwww9v8RzGGF544QX+9re/tbqoRlfjcrm4//77m/38bdq0ieuvvx5IzZO9/Y1+je/JtGnTmv2MLFy4kJtuummn78kVV1yB2+1m5syZ/P73v2/WBvF4nH/961/Npg/My8sjEAhQUVHR1IMt0t1pzLFIF+TxeHjkkUe48cYbef3117n++uu59dZb6du3L16vly1btjR91FxcXNzsH9WBAwcyefJknnnmGS677DJ69+5NZmYmX331FX379uU73/kO06dP77DXcskll/Diiy+yZMkSTjjhBAYOHEhNTQ0bNmzgsssuY9asWU0fIe+O2+3mf//3f7njjju47777ePLJJ+nRo0fT1F+//OUvueWWW1o999RTT+Xtt9/mtttu48knn2waXnDTTTc1m6ZrVyZOnMirr77aNJdta0MqGl199dVs2bKFl156iSlTplBYWEhJSQmxWIx169Y1hcApU6bs0XMDZGdn89RTT/Gzn/2M+fPn85Of/IRAIECfPn1wOp1s2rSpqadxwIABTTd67c/7dtVVV/HOO+8wZ84cxo8fT//+/dmyZQvl5eXcdttt3HbbbS3O+fTTT/nnP/+Jy+WiX79+TeGrsZ3PPPPMZvP9XnXVVfz3v//lrbfe4thjj6Vfv36Ul5ezZcsWzjrrLMrKyvb5j5rOYtSoUQQCAb73ve9RWlqK3+9n2bJlJBIJ+vTpw9SpU5sdf/755/PUU0+xdu1aTj31VPr37088HmfVqlUMGjSI0047jUcffbTF8xxyyCH86le/4uabb+bhhx9m+vTpDBgwgEgkwvr164lGo9x5551N0wdalsUpp5zCs88+y6RJkxg8eHDTUKjGZexFuhv1HIt0UYFAgD/+8Y/84x//YPLkyRQXF7N+/XqWLl2KMYbjjz+eX/3qV7z++utNH1U3uv322/npT3/aNL5z27ZtnH/++cyYMaPpJqiOkpeXx1NPPcUpp5yCz+dj1apVZGdnc+edd3LNNdfs9fX+53/+h7vvvpvhw4dTVVXF2rVrOfjgg5k2bRrnnnvuTs87++yzufnmmxk6dChr165l3rx5zJs3j5qamj1+7mOPPZbs7GwgFSp2FY5dLhd3330306ZNY8KECUCqV7e8vJzS0lIuvPDCvVo+ulFBQQFPPPEEDz30EGeccQa5ubmsWbOGr776ioyMDL71rW/xhz/8gZdffpmioqKm8/b1fRs4cCD/+Mc/+MY3voFlWaxatYrevXvz0EMP7XSauhtvvJEpU6YwdOhQKisrWbJkCQDjx4/nz3/+M3fddVez4w8++GD+8Y9/cMwxx2DbNqtWrSI/P59bbrmlaZGMrs6yLB544AGuuuoqjDEsX76c3NxcvvOd7/D0009TWFjY7PhgMMiTTz7J2WefTTAYZNWqVcTjcX7wgx8wY8aMFourbO+ss87ihRde4JxzziE3N5dly5axbds2Bg0axFVXXdXipsebb76ZKVOmUFBQwJdfftn0uyHSXVmmvedVEhERkVbNnTuXKVOmMHbsWPXEinQS6jkWEREREWmgcCwiIiIi0kDhWERERESkgcKxiIiIiEgD3ZAnIiIiItJAPcciIiIiIg0UjkVEREREGhywK+RVVlZ2+HNmZ2dTXV3d4c8r7Uvt2v2oTbun7tyu1tat5Oyw2E/VsmWYgoI0VdQxunObHqjau01zc3N3e4x6jjuQw6G3uztSu3Y/atPuSe3a/ahNu5/O0Kbpr0BEREREpJNQOBYRERERaaBwLCIiIiLSoMuH44ULF/LDH/6QMWPGMHLkSCZPnszLL7+c7rJEREREpAvq0rNVzJ07l0suuQS3283pp59OZmYms2fP5tprr2XDhg1cfvnl6S5RRERERLqQLhuOE4kEt9xyC5Zl8Y9//IMRI0YAcMUVV3DBBRdw//33c8opp1BaWpreQkVERESky+iywyo+/PBD1q5dy8SJE5uCMUAwGOQnP/kJiUSC5557Lo0VioiIdBHJGETrILQNq7YMq3I11raVEKlJd2UiHa7L9hzPmzcPgPHjx7fYd8wxxzQ7pjX19fXtU9gueDyetDyvtC+1a/ejNu2eunO7OkIhcnbYFgqFsHf2em0ba+syXGv/i7VtFZYdAzsJdhLLJMEY7MwSkj1HY7J6YXJ6YTJywbLa+6Xsle7cpgeq9m7TPVkEpMuG49WrVwPQr1+/Fvuys7PJzc1lzZo1Oz2/T58+7VWaiIhIhyoAynfYdtjIkWxNRzEinZgxZrfHdNlhFXV1dQBkZma2uj8YDFJbW9uRJYmIiIhIF9dle47317p16zr8OXNzc6msrOzw55X2pXbtftSm3VN3bldHRQWMHNls22effoqdnw+A941bcX31OnawByZvAHZuP5LZ/cDjA4cL7ERqqIUdbzrfRGtxr34X1/qPU4/dPuJDTyNZMAwCudhFwzHB4g57ja3pzm16oOoMbdplw3EwGATYae9wXV3dTnuVAQKBQLvUtSuBQIBYLNbhzyvtS+3a/ahNu6fu3K5WONxim9/vxzT+W3fW3TjKL8VhWRiXF1xejDP1FYcb7Dgk41jJGCTjYMew6rbiyCnEGnQM7sUv4ahaA8ueI1kxiPioCzEVi7CdNiZvADicHfyKU7pzmx6oOkObdtlw3DhF25o1azj44IOb7auurqayspJRo0aloTIREZFOxrKwi4bt4gAPANuPxjTZfTHBAhxbviQ65hKcW7/C/cWzOCuWY83/K9Fxl+PctBA7WotdNBzcvnZ9CSIdpcuOOR4zZgwAc+bMabHv/fffB2Ds2LEdWpOIiEi34XBicvuT7HskJrsvdsEQokdfhcnIxlG9Hu/79wEWjm0rcKz/GMIa3iDdQ5cNx0cddRR9+vThlVdeYcmSJU3b6+rqePDBB3G5XEyaNCmNFYqIiHQDvhzs3oeTLBmJCRQRHfND7EAhjvpyvO/eBQas+s04yj6DRDTd1Yrsty4bjl0uF//3f/+HMYbvfve7TJ06ld/+9recddZZfPXVV1x55ZX0798/3WWKiIh0fQ4XpmAQyb5HYucNIDrmEuzs3liRarzv/AZHLISjvhxH5ap0Vyqy37psOAY48sgjefLJJzn88MN59dVXefLJJ8nJyeHuu+/mxz/+cbrLExER6V78edg9R2KyehM9/GKSeYOw4iE8792DVV+OVbFCwyuky+uyN+Q1OvTQQ/nrX/+a7jJEREQODL5cTM+RWBs+Jj76Ivj8aZybP8f96VNEj7oSR/ky7N5HpG0GC5H91aV7jkVERKTjGX8+dslIjDdIfOR3sH15OEJbcW1aiKNmA1bNhnSXKLLPFI5FRERkr5lgEXbPwzBOD4kh3wLA9eWrkEzg2LoM4qE0VyiybxSORUREZJ+YzBLsksNIlhyWukEvEca1+h2scCWOipVgzO4vItLJKByLiIjIPjPZvbFLDiUx+GQAnCvfTq22t20lVmhreosT2QcKxyIiIrJfTHYfEn2PJlk0AsvYuJe8BMbG2rostRy1SBeicCwiIiL7x+HC5PUnMfhbGMuJs+wzHKGtOGrKsGrWp7s6kb2icCwiIiL7zQR7kCw5hGSfsQC4F84EVwbWttXqPZYuReFYRERE9p/DicntT3zgSRi3D0f1WhxbFuMIV2KFKtJdncgeUzgWERGRNmGCRZj8QST6Hw+Ae9HzmGQcq3q9Zq6QLkPhWERERNqG5UiNPe53DLa/ACtShavsE6y6zRCtSXd1IntE4VhERETajAkUYnL7kRhwPADO1e9jxepx1G5Ob2Eie0jhWERERNqOZWFyS0mWjMS4/ThCW7FqNmJVr4VELN3VieyWwrGIiIi0KePPx+T1J1lyGACuDR9hRaqx6svTXJnI7ikci4iISNuyLOy8/iT6Hg2AY+OnEI+keo91Y550cgrHIiIi0vZ8udi9x5DM6Ytlkjg3L8KqK4dwZborE9klhWMRERFpFyarhGTvMQA418yBZBRHTVmaqxLZNYVjERERaRfGn0ei3zcwrgwc9eU4ajenlpOOh9NdmshOKRyLiIhI+3C4MPkDmm7Mc66fhxWtxarbkubCRHZO4VhERETajQkUkuh7FADODQsgmcCqWgt2Ms2VibRO4VhERETaT0Y2dvEh2Nl9UjfmbVmEFdqKFapId2UirVI4FhERkfZjWZisXiR7HQ6Ac/V7YCdTM1eIdEIKxyIiItKuTKCARJ9xGKcXR93m1I15dWWQjKe7NJEWFI5FRESkfXkCmJy+X9+Yt2E+VqQWS3MeSyekcCwiIiLtzmQWk+x9BADODR9jonUadyydksKxiIiItDvjL8AuHIad3RvLTuDcuhRqy8BOpLs0kWYUjkVERKT9uTyYrJ4kexwCgLN8CVakWkMrpNNROBYREZEOYYJFJItGAOAoXwbROqyQwrF0LgrHIiIi0iGMLw+7YDB2sEdqzuPqdVCzQQuCSKeicCwiIiIdw+HEZPXCLhiSelj+JVakBitSld66RLajcCwiIiIdxgQKSBYfCoBz8xeQiGLVa9YK6TwUjkVERKTjZGST7DUK4wlixUM4azemZq0wdrorEwEUjkVERKQjWVZq1oqCoQA4Kr7CilRDpDrNhYmkKByLiIhIhzIZOSSLDwbAUbYQKxHFCm1Lc1UiKQrHIiIi0rG8WSRLRmEcbhyhrViRKqwaDa2QzkHhWERERDqWwwm5fbHzB6YeVizHilRCpCbNhYkoHIuIiEgaGF8udmFqQRDnps9TQyu0Wp50AgrHIiIi0uFMRg6JniMxWDgqV6WmdKvdCMakuzQ5wCkci4iISMdzZ2Dy+mNy+gDg2LYSK1wF0dr01iUHPIVjERERSQsTKGya0s25+QuseBgrrAVBJL0UjkVERCQtjC+nabU8x5bFgGmYtUJDKyR9FI5FREQkPbyZ2PmDsP0FWHYCq2p9ar7jqGatkPRxpbuAUCjEG2+8wVtvvcXSpUspKyvD4/EwbNgwLrjgAiZOnNjqebZt8+STTzJjxgzWrFmD3+9n3LhxXH311ZSWlnbsixAREZG9ZzkgqyfJwqE41mzFuWURJqcPVngbJiM73dXJASrtPccfffQRv/jFL/jwww8ZPnw4F110ESeffDJffvkl11xzDb/85S9bPe/WW2/ll7/8JbZtc+GFF3Lcccfx1ltvMXnyZJYvX97Br0JERET2hfHlYBcOB8BZ9ik43Fg1mrVC0iftPcdFRUXcc889nHLKKbjd7qbtP//5zznvvPN44oknOOusszj00EOb9n344Yc8/fTTHHHEETz66KN4PB4Azj77bH7wgx9w22238cQTT3T4axEREZG9YzJysIuGY9x+rFg9Vv0WLIcTItXgy0l3eXIASnvP8bBhwzjjjDOaBWOAgoICzj//fADmz5/fbN/MmTMB+NnPftYUjAGOOuooxo8fz/z581m1alU7Vy4iIiL7zeXBZJVgF243a0UiogVBJG3SHo53xeVKdWw7nc5m2+fOnYvf72f06NEtzhk/fjzQMlCLiIhI52T8BSQbVstzbPgYXBlY1RvA2GmuTA5EnTYcJ5NJXnjhBSzL4uijj27aHgqFKC8vp3fv3i1CM9B0M97q1as7qFIRERHZH6kp3Q7GOD04QhUQrsSKVEJEs1ZIx0v7mOOdue+++1i2bBnf/va3GTJkSNP22trUyjnBYLDV8xq319XV7fL62dnZOBwd/7dBbm5uhz+ntD+1a/ejNu2eum27JhItNuXk5EAXeb3G5GBqS0mWHAzrF+DbthSr/zE43Ams3byGbtumB7B0t2mbheNx48ZRVVW1x8dPnz6dcePGtbpvxowZPPzww4wYMYKbb765jSpsrrq6ul2uuyu5ublUVmoMVXejdu1+1KbdU3duV6uqipwdtlVVVWFcnbYPrAWLAO6cgXjWLyC56gNivY/GXrcE25mXmvKtFd25TQ9U7d2mexK82+y3ZuLEidTX1+/x8QUFBa1uf/bZZ7n11lsZMmQIf/vb3wgEAs32Z2ZmAjvvGW7cvrOeZREREemEfDkki4ZjLCeO2jKI1mPZyYZZK9Q7LB2nzcLx1KlT9/sazzzzDFOnTmXQoEE89thjraZ7v99PYWEh69evJ5lMthh33DjWWAuBiIiIdB0mIxsCBdiFQ3BuWYJz8+ckSw7DCm3DKBxLB+o0N+Q988wz3HLLLQwYMIDHHnuMvLy8nR47duxYQqEQCxYsaLFvzpw5AIwZM6bdahUREZE25vRgMnuQLGiY0m3DR+D2YdVo1grpWJ0iHM+cObNZMM7Pz9/l8eeddx4A9957L7FYrGn7Bx98wJw5cxgzZgz9+/dv15pFRESkbRl/PnbhMAwWjsrVkIxjhatSQytEOkjaR+p/8MEHTJ06FWMMRxxxBE899VSLY4YPH86ECROaHh955JGce+65zJw5k0mTJnHcccdRUVHBv/71L4LBILfddlsHvgIRERFpC8aXiwkWYecPxFmxHMemz7F7jMCq36qhFdJh0h6Oy8rKMA3rp8+YMaPVYyZNmtQsHAPccccdDB06lBkzZvD444/j9/s54YQTuPrqq9VrLCIi0hW5/Q29x8NxVizHueEj7F6HY9VsxOQNAEfL9Q1E2lraw/E555zDOeecs9fnORwOvve97/G9732vHaoSERGRdDDBIpIFQ3ADjq1fYQArUpUaWuHf+f1IIm2lU4w5FhEREYGGoRWZPbBz+mFhcG7+AstOYIUq0l2aHCAUjkVERKTz8GZiMrJJFh0ENMxa4fJh1ZZp1grpEArHIiIi0nlYDggWkywYDIBj82KM5dSsFdJhFI5FRESkUzH+vNTQiswSLJPEWb4EKxnFCmupaGl/CsciIiLSqZiMbIw3i2SPQwBwbvgY3H6s6o3QMMOVSHtROBYREZHOxeluGFoxCADHpoUYhyc1a0W0Jr21SbencCwiIiKdjgnkQWYJtj8fKxnDUbkCKxHBCm9Ld2nSzSkci4iISKdjMnIwniB2j4MBcG74BFxerJoyDa2QdqVwLCIiIp2P24cJFGA3zFrhLPsE4wmmbsqL1aW5OOnOFI5FRESkUzLBIuysPhi3Dytai6N6A1Y8ghXS0AppPwrHIiIi0imZjByMN0CyYWiFo+wTcLpTC4KItBOFYxEREemcvJkYbzZ2wVAAnBs/wXgzU0tJRzW0QtqHwrGIiIh0TpaFySrBzi3FWE4ctWVYkerU0AotCCLtROFYREREOi9fw6wVhQ29x2WfgtOFVbc5vXVJt6VwLCIiIp2WycjGZGSSLBoOgGPDgtTQivpyTLQ+zdVJd6RwLCIiIp2XwwWBHth5A1IPK5ZDMoEVq4dQRZqLk+5I4VhEREQ6NRPIg4xs7Jx+WBicmxaCw4Wp2ZTu0qQbUjgWERGRTs1kZGPcAZI9DgK+nrXC1G6GeCjN1Ul3o3AsIiIinZvbj/HnYuenVstzbP4iNdwiUqMb86TNKRyLiIhIp2eCRRh/PrY/HysZw1G+FLx+rG2rIRlPd3nSjSgci4iISKdnMnIwLi928aEAODcuAH8ejvA2rPotaa5OuhOFYxEREen8vFkYbybJxvmON34KWOBwY1WtBWOntTzpPhSORUREpPNzOCGzGDuzBOP2Y0VrYOtyjC8Xq3YzVv3WdFco3YTCsYiIiHQJxpeH5XCRLD4k9XjNPHB5wdhY1evTXJ10FwrHIiIi0iWkpnTzYzeslmfWzk/t8OVi1ZZBuCp9xUm3oXAsIiIiXYM7AxMowM4pxThcUL0Ba9sq8AQgHsFRW5buCqUbUDgWERGRLsMECsHhJNl7DACuFf9O7cjISt2Yp0VBZD8pHIuIiEiXYXypKd2SpccC4Fz7IcTqwJuFFa3FqtWiILJ/FI5FRESk6/BmYrxZmGAR5PXHsuO4Vr0HlgWeAFblKkjG0l2ldGEKxyIiItJ1WA7ILMHEw1jDvwWAc8VbYGxMRg6OcCVWnRYFkX2ncCwiIiJdivHlYFkWlB6Ncftx1G/BsXlRai5kpwerag3YyXSXKV2UwrGIiIh0KSYjG+MJYNkJkqXjAXAtfzO1z5eLo3YLVu2mdJYoXZjCsYiIiHQtLm9q1opoLYmBJwLgKPsMq74cnB5wurEqvoKExh7L3lM4FhERkS7HBArBTmKCxSSLDsLC4Fz5n9Q+fz6O+nKs6nVprlK6IoVjERER6XJMRja4MyARITEo1XvsWvkuJOPgcGK8WTgqlkOsPs2VSlejcCwiIiJdjzcTK1iEFanGLhmF7cvDitXiXD8vtT8jBytai2Pb6rSWKV2PwrGIiIh0PZaFldsH7BhYFskBxwMN07o17Df+PKyq1RCuTFuZ0vUoHIuIiEjXFOyB8WZBtIbEgOMwlhNnxXKsyjWp/Z4gJCI4KlaAsdNbq3QZCsciIiLSJVnuDExWL4jUQkYOyd5HAOBa8e+vDwoUYVWv18IgsscUjkVERKTLMsEe4HBBMkZy4EkAONf8F8JVqQNcXizLgbV1eepmPZHdUDgWERGRLsv48zD+fKxwFXbBEJL5g7DsOO6lr3x9TKAAR/0mrJoNaaxUuopOGY4//fRThg8fztChQ5k2bVqrx9i2zRNPPMEZZ5zBoYceypFHHsn//u//snr16o4tVkRERNLHcmByekMiCkDioHMAcK58G8LbUsc4XOAO4Nj6FUSq01SodBWdLhxHIhFuuOEGMjIydnncrbfeyi9/+Uts2+bCCy/kuOOO46233mLy5MksX768g6oVERGRdDOBQozHD7F67KIRJAuGpHqPl2zXe+zLg2gNjs1fNAVpkdZ0unD8hz/8gfLycn74wx/u9JgPP/yQp59+miOOOILnn3+eX/ziF/z2t79l2rRp1NXVcdttt3VcwSIiIpJengAmsxgiVWBZX/cer3oHK1SROsayILMER00Zji1LwE6mr17p1DpVOP7444+ZPn06119/PcXFxTs9bubMmQD87Gc/w+PxNG0/6qijGD9+PPPnz2fVqlXtXq+IiIh0DiazJxaAncAuGk6ycDiWncC15OWvD3K4MMEeOLatwNq2Ml2lSifXacJxOBzmxhtvZOzYsZx33nm7PHbu3Ln4/X5Gjx7dYt/48eMBmD9/frvUKSIiIp2P8edh+3KwGsYUJw6aBIBz1btY9eVfH+jyYrzZOLYswaotS0ep0sm50l1Ao9/97neUl5fzyCOP7PK4UChEeXk5Q4YMwel0tthfWloKsNsb87Kzs3E4Ov5vg9zc3A5/Tml/atfuR23aPXXbdk0kWmzKycmB7vp6t7N9m9rJgzDrF2BlBiHzcJLLDsXauBDf8tdwjP/x1ydlBjE1m7DqVmMV9sTy5XR84bJT6f497RTheN68eTzxxBPcdNNN9OnTZ5fH1tbWAhAMBlvd37i9rq5ul9epru74u1Vzc3OprNQSlt2N2rX7UZt2T925Xa2qKnJ22FZVVYVxdYp/5ttNizZNenFGk7CtHNw+HEPPxLtxIfZX/yE88FuYYNF2ZwegYj0mNge71xHg8nZ4/d1aMpbqxQ9XYUVrUjOGOFzgdGMsB1hOjC8HfM2DcHv/nu5J8G6z35px48ZRVVW1x8dPnz6dcePGEQqFuOmmmxg5ciQXXnhhW5UjIiIiB5qMbEywCEdtGcbtwy4YTLLHITg3f45ryUvEx1z69bGNN+hVbwDXIuzig8Hp2fm1ZdeMgVgdVqQaq74Cq34LxOrAtrGcbsCAsTHGxjJg2XHswuHYvs736UabheOJEydSX1+/x8cXFBQAqdkptmzZwrRp0/ZomENmZiaw857hxu0761kWERGRbsqyUstJV68DY4PlIH7QJJybP8e55n0Sw89IrajXyOHCZBbjaLg5TwF5HyTjWPXlWDUbseo2Y8Uj4HBiPAFoWL3QtHZe7SZofU/atVk4njp16j6dt3TpUqLRKKeeemqr+3/3u9/xu9/9jilTpnDzzTfj9/spLCxk/fr1JJPJFuOOG8caN449FhERkQOHCRRiZ+TgCFdi/PmY/IEkiw/DuekzXF88R/zIHzc/weVtmMFiJRiDXXwIuBSQdytai1W7Gat6LY5wNcaywJeD8RekeuW7sLQPRjruuOPo27dvi+1r1qxh/vz5HHLIIQwdOpRRo0Y17Rs7diyzZs1iwYIFjBkzptl5c+bMAWixXURERA4ALg8mtxQ2fpIaz2o5iB88CcemhbjWfUiyz5jUGONm53hTPciVKwGDXXyoAvKOkjGI1mFFa7FCFVi1ZVjxcMMc06ke4u4i7a/k0ksvbXX7c889x/z58zn55JO57LLLmu0777zzmDVrFvfeey+PPvpo01zHH3zwAXPmzGHMmDH079+/3WsXERGRzsdklWAqlkO0BjJyMLn9SQw7DffSWXg++juR/EGQkdP8JKcHk1mCY9uqVA9yyaEHxk16yXgq+NrJ1FAUDJaxU9/bSYjVY4W2pm6ui4Wx7HhqqERGdrfoJW5N2sPxvjjyyCM599xzmTlzJpMmTeK4446joqKCf/3rXwSDQa2QJyIiciBz+zG5/XBs+hzjzW5aNc9Z9jmO6rV45v+N2PirWwY7pweTVYKjag1NPcjujLS8hN2yE6nAGo+QWv3Eang9FlgN93AZQ+ONcKmvgB3DSsRSN8tF67CS0VRANnbqeGMAOxWQGy5huTwYtw8CBRinOx2vtkN1yXAMcMcddzB06FBmzJjB448/jt/v54QTTuDqq69Wr7GIiMgBzs7qhVWxMhUCvZngcBEb9yO8b96Gc9NnOFe+TXLgCS1PbOxBrloD0VrI7oOdWQwZWR3/InZkJ7DCVaklsWs2YEVqsOzk1+F4Vze4mYZDGr91uFPTqjnd4AmmArXlSAVsy4FpCtud9ba59mMZYw601wyQlrkuu/McmwcytWv3ozbtnrpzu1pbt5IzZEizbVXLlmEaZobqrnbXpo5Nn2NtXQbZX6+h4Fz2Gp7PnsI4PUS/+UtMZnHrJ9tJiFZjRWsxbj8mswST1QsTKABHy0XI2k08kpoeLVIJNRtTvcV2EssTwHgzu+zsGlbtJuycvtg9Rzbb3q3mORYRERHpTOzs3jgr10A8BG4/AMnBJ5Pc+CnO8iV45k0jesLNrYddhxN8eRhfXmrcbeVqHJVrsP15mOzeqTmVM7LaPpwm46mZIKLVWHXlWKFtWPEQxhjwBiBQlOrxbdtnle0oHIuIiEj3lJGDyeqJVbkaslPhGMtBfOwPccy+Bce2FbiWvkxixNm7vo4nkJqVIRnHEamCsk9Tq7x5gphAESaQj/FmgSsDHKnV33Z7o5oxkIhAPIwVD2PF6iFSjRWpglgodeOb04PxBFMryVm7XwtC2obCsYiIiHRPloXJ6YNVtQ4S0abZJ4w/n/joKXjmPoRr8Yskiw/B5A3c/fWcbkygMPW9nYBYPY7KVVCxHOPOSE1n1jB21zic4HCD0/X1jW6NN8bZSTDJ1I1xiQiWSabGATs9GJcXAvmYLjpcojtQOBYREZFuy/jzMZnFWLVlkNWzaXuyz5EkNn6Ca91cPP99gOiEW1tO77YrDlfD0IrsVPBNRlOB2dgNwTeOZcINgbjRdje5WVYqrGdkYRrmCNZQic5B4VhERES6L8uRmtatZiMmGft6jLBlER99EY7KNTjqNuF9/z6ix9+4b2OILSs1pGIHCrtdkwawiIiISLdmAoXYwSKs8A6zIHgCxMZfjfEEcGxbiXveX3bo6ZUDkcKxiIiIdG8OJya339erwW3HZBYTO/qnGMuJa/08XItfSE+N0mkoHIuIiEi3ZzKLsbN6Qn15i3124TDih38fAPfiF3Gu+W8HVyedicKxiIiIdH8OF6ZgcGpMcbSuxe5k/2OJDz0dAPdHj+DYuqyjK5ROQuFYREREDgjGn4/JG5BafrmVscWJQyaT7Dkay07g+e8fsarXp6FKSTeFYxERETlg2Ln9sQP5qYC8I8tBbNzl2Dn9sKK1eN/4f7i+eK7FOGXp3hSORURE5MDhzsAUDE0tCpKIttzv8hL9xjUkSw7DMkncS17EO/sWHJsXdXytkhYKxyIiInJAMVkl2Dl9oX5L6wdkZBM75mqiR12JycjBUbcZ77t34Z77EESqO7ZY6XAKxyIiInJgsRzY+YPA5YNIzU6OsbB7jyFyym9IDPomBgvX2g/IeO0GXItfhFh9x9YsHUbhWERERA48vhxM/iCsSBXYyZ0f5/YRH3Uh0ZNuTY1FjodwL3qOjFk/x7XwafUkd0MKxyIiInJAsnNLsQOFWK3Mfbwjk9ef6ITbiB35E+zsPliJCO4vZ5Ex6xrcC6bv0TWka3CluwARERGRtHB5MIVDMevmpoZJeAK7Pt5ykOwzjmTvsTjKPsO95CUc21bgWvFvXCv+jZ1Zgl0wpOk/EygEy+qY1yJtRuFYREREDlgm2AOTPwjHliUYlxccexCNLAu750iiJYfhKF+Ka8nLOLcswlFbhqO2DFa9k7p2Rg7JgsGYvIHY+QOxc0tTi5BIp6ZwLCIiIgcuy8LOHwzhKqzaTZDde+/OLRpOrGg4ROtwVHyFY+uy1H/bVmFFqnCtnw/r5wNgLCcmu3cqKGf1BE8Q4wlivJmp771BsJNY8RDE6rFi9amv8XqsaC1WtBYavlrR2lRvd0Y2drAIEyzCBFJf7UAReDPB4WynN60ViWiqpmQs9X2yYaq8ZAzcPkxGNiYjBzzBTt+brnAsIiIiBzaXB7toOM5INUSqICNn76/hDWL3HIXdc1TqcSKKY9tKHBXLU1+3rcCKVGNVrcFRtabtag9txbFtRau7jNuP8QTBG8R4MjEeP1hOsBypgGo5wOHEOD0Yfx7GX5BaRTBQAG5/Kxe0IRnDqt+Ko3o9VvV6HNXrsGo24NjDMdfGcmIyssEbJHbEJdg9R+7Hi28fCsciIiIi/jzswqE4yz7FuP37P/zB5cUuGo5dNDz12Bis8DasihU4tq3AEaqAaB1WrBYrWpfqIbbjqUOdHnD7MZ4AxhNIfe/NTPUwezMx3qzU924/RKpw1G3BqtuMVV+e+hrahoXBiodSvdA7m895F4zbj3H7sZLxVO9vMoZldjGrB2Ac7tQ4bqcXXF5wejBOD1Y8jBWpworVYZkkVngbhLfhLPuMxKHn7XVt7U3hWERERAQwuaXY4UqsytWQ3adtP/63rFSvrD8fu8/YVp7cpEKo5QCne68ubbfYkGwYllGHFatrCOF1qaBsJ1M9wNv9ZyUiWKEKrPqtqa8Nx1rxUKvPZ1wZ2Nm9U0NEsntjsvtgZ/UGb3A3hSawItUQqcZRU0ai9Ji9ep0dReFYREREBMDhxC4chjNciRXampptoqNYVqq3tS04nJCRhcnIwuzL+Q1hmXg41YPu9IDTnerRbvxvX/5wcLgw/nzw52O3Re98O1E4FhEREWnkDWIXjcCxfj7EQ62Pve3uXBmYrF7priJttAiIiIiIyHZMVk9M/gCs+q1aJvoApJ5jERERke1ZFnbRCHC4cGz5EpOMgy8n3VVJB1HPsYiIiMiOHC7swuEke40CO45Vtzl105x0ewrHIiIiIq2xrNQMFr2OwLgyoGZDaoYH6dYUjkVERER2wWT2INl7DCZQiFW1LjXlmnRbCsciIiIiu+PLwe59OHZuaWqZ6UhVuiuSdqJwLCIiIrIn3H7sXqNIloyEZAKq14OdSHdV0sY0W4WIiIjInnK4MAWDSPrzcJQvwVGzEePL2/3qcNJlqOdYREREZG/587B7j8EuPhji9VBbllqaWbo89RyLiIiI7AunB7twGJYvD6t8KY7aDeD0ppZIdihidVVqOREREZH9YIJFGF8OpnYzVuVqHLWbweHE+PPA6Ul3ebKXFI5FRERE9pfTg8npg8kqwdRtwapag1W7GTDgywW3P90Vyh5SOBYRERFpKw4XJqsnJrMYq34rVtVarLrNWPVbMZ4gZGSDw5nuKmUXFI5FRERE2prlSA23CBRCtCY11KJ6HY7astQ+Xw64fGBZ6a5UdqBwLCIiItJeLAsysrEzsiGvFFO/Fat6A1b9FqzQVgwWlsuHcfvA7QNLE4mlm8KxiIiISEdwehqGXJRArA4rWoMVqUkF5mgtVrgKY2wshxOcbozDDc6G/xwuBecO0qnC8dKlS/nLX/7CvHnzqKysJCcnh2HDhnHppZdy5JFHNjvWtm2efPJJZsyYwZo1a/D7/YwbN46rr76a0tLS9LwAERERkd2xLPBmYryZmKxeYAzEQ1jROojXY8VCEKtLbUtEIVqLZccBMICFlQrLTjfG5QV3QMMz2lCnCccvvPACN910E5mZmRx//PH06NGDyspKvvjiCz755JMW4fjWW2/l6aefZtCgQVx44YVUVFTwr3/9i/fff59//vOfDBo0KE2vRERERGQvWBZ4AhhPAEgF4NQ3BpIxSESxktGG72OpwByvh1gIK1aHFdoGbh8mI1tTx7WBThGOv/jiC26++WYOPfRQHn74YbKzs5vtTySar1v+4Ycf8vTTT3PEEUfw6KOP4vGkfhDOPvtsfvCDH3DbbbfxxBNPdFj9IiIiIm3OssDlBZf368AMzb4nVp8av1y1Hqt+K5gkeLPAm6lhGPuoU7xr9957L8lkkt/+9rctgjGAy9U8w8+cOROAn/3sZ03BGOCoo45i/PjxzJ8/n1WrVrVv0SIiIiLp5glgcvtj9zsau/QYTMEwMDZWzQasmo2p4RnG7P460iTtPcc1NTW8//77jBgxgn79+jFv3jwWLlyIy+Xi0EMPZfTo0S3OmTt3Ln6/v9V948eP57333mP+/Pn079+/I16CiIiISHo5nJhAYWrquPwBWKFtWLVlWPXlWKHK1PjkjCxNH7cH0h6OFy1ahG3bFBcXc/nll/Of//yn2f5jjjmG++67j8zMTABCoRDl5eUMGTIEp7PlJNqNN+OtXr26vUsXERER6XzcPkx2L0x2r9Swi1AFVs3G1Nf6rRjLgeVumD7OlaHhFztIezjetm0bAG+//Ta5ubn86U9/4sgjj2Tz5s3cc889vPXWW0ydOpV7770XgNraWgCCwWCr12vcXldXt8vnzc7OxuHo+B+G3NzcDn9OaX9q1+5Hbdo9ddt23eHeHICcnBzorq93O922TdtMLtAbYw6FaC1EqjGhaqjbjInWYsWqMBjw+CAjG8vl7ZCqjO3HyszE0Ur7pbtN2ywcjxs3jqqqqj0+fvr06YwbNw7btgFIJpPcfvvtTJgwAUiF3Pvuu49vfetbvPbaa5SVlVFSUtJW5VJdXd1m19pTubm5VFZWdvjzSvtSu3Y/atPuqTu3q1VVRc4O26qqqjCutPeBtavu3KbtJwi+IGT0bJo+zopUQ20ZVs1aSCawPH6MN7NdZ76w6kPY7lrsHdqvvdt0T4J3m/3WTJw4kfr6+j0+vqCgAKBpuITT6eS4445rdozH4+GYY45h5syZLFq0iJKSkqbjd9Yz3Lh9Zz3LIiIiIge87aaPM5k9IH8gVqQKq74CU7MhNfOFncByelLjlRu+4vSkhmEYk5oZw06CnUj9Z2ywnOBwNHx1po61nF1qnHObheOpU6fu03mNN81lZGTgdrtb7G8Mw5FIBAC/309hYSHr168nmUy2GHfcONZYC4GIiIiI7CGHE+PPx/jzU0E5XIkV2oaJ1UO0BisRgUQEkjEsYwMWxnKC09UUhI3TjWUnIRH7OjgbG8tOpFYHzMhOLZHdyaX985a+ffvSs2dPNm7cyKZNmyguLm62f8WKFQD06tWradvYsWOZNWsWCxYsYMyYMc2OnzNnDkCL7SIiIiKyBxxOTKAAEyj4elvTAiSpgIzDhXG6weFuWq0Ph7OhJzkJdrypV9mK1aemlqvfilVfDp5Aqqe5k0r77YmWZXHBBRcA8Pvf/75pDDLAvHnzePfdd+nVqxeHHHJI0/bzzjsPSM2PHIvFmrZ/8MEHzJkzhzFjxmgaNxEREZG24vSAN5gKzVk9McEi8OWCNwjujFQwhtRXlycVgDOywJ+HyemD3WccydLxJEsOw2666a9zDrVIe88xwA9+8AP+85//8OKLL7J8+XLGjBlDeXk5s2fPxuPx8Otf/7rZQiBHHnkk5557LjNnzmTSpEkcd9xxTctHB4NBbrvttvS9GBERERFpzrLAl4Px5WDy+mNC21I9z51QpwjHHo+HRx99lGnTpjFr1iz+8Y9/EAgEOP7447nyyisZNmxYi3PuuOMOhg4dyowZM3j88cfx+/2ccMIJXH311eo1FhEREemsHK5Uz3MnZRlzYK4pmI6pXzTlTPekdu1+1KbdU3duV2vrVnKGDGm2rWrZMkxBwU7O6B66c5seqDrDVG5pH3MsIiIiItJZKByLiIiIiDRQOBYRERERaaBwLCIiIiLSQOFYRERERKTBATtbhYiIiIjIjtRzLCIiIiLSQOFYRERERKSBwrGIiIiISAOFYxERERGRBgrHIiIiIiINFI5FRERERBq40l1Ad7dw4ULuv/9+Pv30U+LxOIMGDeKiiy7ijDPOSHdpsgubN2/m1Vdf5d1332XlypVs3bqV7OxsRo8ezaWXXsphhx3W4py6ujruv/9+Zs+eTXl5OYWFhZx88slcddVVBIPBNLwK2Z2//OUv3HPPPQDMmDGDkSNHtjhG7dp1vPHGGzz55JMsXryYcDhMQUEBI0eO5LrrrqOkpKTpOLVp52eM4Y033uDxxx9n1apV1NbWUlxczLhx4/jhD39Inz59mh2vNu08XnzxRT7++GO++OILli1bRjwe58477+Scc85p9fh9abuXX36Zxx57jOXLl+N2uxk5ciQ//elPOeSQQ9rkNWie43Y0d+5cLrnkEtxuN6effjqZmZnMnj2b9evXc/XVV3P55Zenu0TZiXvuuYe//OUv9O3blzFjxpCfn8+aNWt48803Mcbwu9/9jtNOO63p+FAoxHe/+12WLFnCMcccw4gRI1i6dCnvvfcew4cP58knn8Tv96fxFcmOVqxYwdlnn43L5SIUCrUajtWuXYMxhltvvZUZM2bQt29fxo8fTyAQYMuWLcyfP5+7776bI444AlCbdhW/+c1vePTRRyksLOSkk04iGAyydOlS3n//ffx+P//85z8ZMmQIoDbtbE488UQ2bNhAbm4ufr+fDRs27DQc70vbPfTQQ/zhD3+gZ8+efOtb3yIUCjFr1iyi0SiPPPII48aN2/8XYaRdxONxM2HCBHPwwQebRYsWNW2vra01p59+uhkxYoRZtWpV+gqUXXr99dfN/PnzW2yfP3++Oeigg8zYsWNNNBpt2n7fffeZIUOGmLvuuqvZ8Y3b77vvvnavWfZcIpEw3/72t83kyZPNtddea4YMGWI++eSTFsepXbuGxx57zAwZMsTcfvvtJpFItNgfj8ebvlebdn5btmwxw4YNMyeccIKpra1ttu/RRx81Q4YMMTfccEPTNrVp5/L++++b9evXG2OMefjhh82QIUPMs88+2+qxe9t2q1atMiNGjDAnn3yyqampadq+bNkyc9hhh5kJEyY0+33fVxpz3E4+/PBD1q5dy8SJExkxYkTT9mAwyE9+8hMSiQTPPfdcGiuUXTn55JObepq2d8QRRzBu3Diqqqr48ssvgVSv1cyZM/H7/VxxxRXNjv/Rj35EdnY2zzzzDEYf0nQaf/nLX1i6dCm//vWvcTqdrR6jdu0aIpEIf/rTn+jTpw833XRTq+3pcqVGEKpNu4YNGzZg2zajR49u8bH68ccfD8C2bdsAtWlndPTRR9OrV6/dHrcvbffcc8+RSCT48Y9/TGZmZtP2wYMHc9ZZZ7F27Vo+/PDD/X4NCsftZN68eQCMHz++xb5jjjmm2THStTT+Q9v4dfXq1WzZsoXRo0e3+PjH6/VyxBFHsHnzZtasWdPhtUpLy5Yt44EHHuDHP/4xgwcP3ulxateu4f3336eqqooJEyZg2zazZ89m2rRpPPXUUy3aRm3aNfTr1w+3282CBQuoq6trtu+dd94B4MgjjwTUpl3ZvrRdY25qzFHb+8Y3vgHA/Pnz97s23ZDXTlavXg2kfsl3lJ2dTW5urn5Zu6CNGzfy3//+l8LCwqbxbo3tWFpa2uo5jT8Da9as2ekx0jESiQQ33HADAwcO5LLLLtvlsWrXruGLL74AwOl0cuaZZ7Jq1aqmfQ6Hg+9///tcf/31gNq0q8jNzeXqq6/mrrvu4rTTTuPEE08kEAiwbNkyPvjgA84//3wuvPBCQG3ale1L261evRq/309hYeFOj2/MX/tD4bidNP61u323//aCwSCbNm3qyJJkP8XjcX7xi18Qi8W49tprmz6+ra2tBdjpXbWN2xuPk/R56KGH+PLLL3n66adxu927PFbt2jVUVFQA8OijjzJixAhmzpzJwIEDWbJkCVOnTuVvf/sbffr04bvf/a7atAu55JJLKCoq4v/9v//HU0891bR91KhRnHnmmU2/v2rTrmtf2q6uro68vLxdHr/jpw37QsMqRPaAbdvcdNNNzJ8/n/POO4+zzz473SXJXlq6dCkPPfQQF198MQcddFC6y5E20jge0e1286c//YlDDz2UQCDAEUccwR//+EccDgePPvpomquUvfXggw9y44038qMf/Yh33nmHTz75hCeffJJkMsmUKVOYPXt2ukuUbkzhuJ3s7q/Vurq6nfYqS+dijOGWW27hpZde4swzz+T2229vtr+xHXf21+ruPkWQjnH99dfTp08frrrqqj06Xu3aNTT+v/bggw+mR48ezfYNHjyYPn36sHbtWmpqatSmXcQHH3zAfffdx//8z/9w+eWXU1xcjN/v5/DDD+fhhx/G6/Vy5513Avo97cr2pe2CweAuc1XjMftLwyraSeP4mDVr1nDwwQc321ddXU1lZSWjRo1KQ2WyN2zb5uabb+a5555j4sSJ/OY3v8HhaP435e7GOTWOq2pt/Ll0nKVLlwLsdJL4888/H4A//elPTJgwQe3aRQwYMADYefhp3B6JRNSmXUTjTXetzVebl5fH0KFD+eSTT9i2bZvatAvbl7YrLS3lk08+aVospLXj22JsucJxOxkzZgwPP/wwc+bM4fTTT2+27/333wdg7Nix6ShN9tD2wfi0007jrrvuanWaqNLSUoqKiliwYAGhUKjZXbfRaJSPPvqIoqIi/c85zSZPntzq9o8++ojVq1dz4oknkpeX1zQFkdq1a2gMUCtXrmyxLx6Ps3btWvx+P3l5eRQWFqpNu4B4PA58PV3bjhq3ezwe/Z52YfvSdmPGjOGTTz7h/fffbzG88b333ms6Zn9pWEU7Oeqoo+jTpw+vvPIKS5YsadpeV1fHgw8+iMvlYtKkSWmsUHZl+2B8yimncPfdd+90PlzLsjj33HMJhUL86U9/arbv4Ycfprq6mnPPPRfLsjqidNmJX/3qV63+1/gJzo9+9CN+9atfMXz4cEDt2lU0roi3Zs0aZs6c2WzftGnTqKmpYcKECbhcLrVpFzF69GgA/v73v7f4CP35559nzZo1HHTQQQSDQbVpF7YvbXfOOefgcrn485//3Oxn46uvvuLFF1+kb9++TdP87VdtRjNjt5sPP/yQSy+9FLfbzcSJEwkGg03LR//sZz/jxz/+cbpLlJ24//77eeCBB/D7/UyZMqVpTuPtTZgwoSlI7bgE5kEHHcTSpUt59913tXxpJ3fDDTfw/PPP79Hy0WrXzmnt2rVccMEFVFRUcPzxxzNgwAAWL17Mhx9+SK9evZgxY0bTR7Bq084vmUzy/e9/n3nz5pGXl8eJJ55IVlYWX375Je+//z4ej4dHH310p0uCq03Ta+bMmXz88cdAal75RYsWMXr06KYe4AkTJjBhwgRg39ruz3/+M/fee2+ry0f/9a9/VTjuChYuXMgf//hHPv30U+LxOIMGDeKiiy7izDPPTHdpsguNgWlXdlwrvra2lgceeIDXX3+drVu3UlBQwLe+9S2uvPJK3QzSie0qHIPatasoKyvjj3/8I++99x5VVVUUFBRw4okncsUVV5Cfn9/sWLVp5xeLxXjsscd49dVXWblyJfF4nPz8fMaMGcOPfvSjpnnmG6lNO4/d/ft55ZVXNrsxel/a7qWXXuKxxx5j+fLluN1uRo4cyU9/+lMOPfTQNnkNCsciIiIiIg005lhEREREpIHCsYiIiIhIA4VjEREREZEGCsciIiIiIg0UjkVEREREGigci4iIiIg0UDgWEREREWmgcCwiIiIi0kDhWERERESkgcKxiIiIiEgDhWMRERERkQYKxyIiIiIiDf4/3iQ4xKa6w0gAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = result.plot(plot_predictors=True)" + ] + }, + { + "cell_type": "markdown", + "id": "7df80b1f", + "metadata": {}, + "source": [ + "Excellent, the effect is clearly visible, almost unmistakable to the naked eye. While we might not necessarily need statistical analysis to confirm it, it's still prudent to examine the mean and cumulative effect for thoroughness.\n", + "\n", + "We can utilize the summary function once again to gauge the extent to which our actions have influenced the behavior of the target variable." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "1518b433", + "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", + "
bayesian_tail_probabilityposterior_estimationresultscausal_effectci
cumulative0.01549.695960498.961312-50.734647[540.6408744028813, 559.9896436959569]
mean0.0118.95503317.205562-1.749471[18.64278877251315, 19.309987713653683]
\n", + "
" + ], + "text/plain": [ + " bayesian_tail_probability posterior_estimation results \\\n", + "cumulative 0.01 549.695960 498.961312 \n", + "mean 0.01 18.955033 17.205562 \n", + "\n", + " causal_effect ci \n", + "cumulative -50.734647 [540.6408744028813, 559.9896436959569] \n", + "mean -1.749471 [18.64278877251315, 19.309987713653683] " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.summary(version=\"intervention\", alpha=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "64d3e41e", + "metadata": {}, + "source": [ + "As anticipated, the total causal effect of our actions during the intervention is approximately `-50` units. This indicates a significant impact on our target variable, with a decrease of about `50` units over the entire period.\n", + "\n", + "When broken down to a daily scale, which matches the granularity of our data, it becomes evident that we're experiencing a loss of approximately `-1.7` units daily on our target variable on average due to this action. This result is significant, especially considering how it deviates from the intervals of our posterior distribution.\n", + "\n", + "The minimum expected value was `540` cumulatively and `18` on average, and we get `498` and `17` respectively. This discrepancy is why our tail probability is very low, suggesting that these results are unlikely to be a part of our posterior distribution.\n", + "\n", + "**Wait a moment!** This could be a biased result, based on our previous power analysis. If the posterior was shifted to the left relative to the real mean in our power analysis, it implies that **we might be UNDERESTIMATING the decrease**. If our actions are indeed reducing the variable, the actual impact could be even more pronounced than we currently estimate.\n", + "\n", + "To address this, let's reapply the parameter correction, this time incorporating the value needed to adjust for the systematic differences observed in the power analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f728c4db", + "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", + "
bayesian_tail_probabilityposterior_estimationresultscausal_effectci
cumulative0.01550.184347498.961312-51.223035[541.1292619285257, 560.4780312216013]
mean0.0119.00929817.205562-1.803736[18.6970540531403, 19.364252994280832]
\n", + "
" + ], + "text/plain": [ + " bayesian_tail_probability posterior_estimation results \\\n", + "cumulative 0.01 550.184347 498.961312 \n", + "mean 0.01 19.009298 17.205562 \n", + "\n", + " causal_effect ci \n", + "cumulative -51.223035 [541.1292619285257, 560.4780312216013] \n", + "mean -1.803736 [18.6970540531403, 19.364252994280832] " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.summary(version=\"intervention\", alpha=0.1, correction=power_correction['_systematic_differences'])" + ] + }, + { + "cell_type": "markdown", + "id": "a3b02433", + "metadata": {}, + "source": [ + "It appears that the potential causal effect was 51, not 50 as we initially thought. We also notice differences in the intervals, yet this additional value doesn't significantly alter our Bayesian Tail Probability (BTP).\n", + "\n", + "## Conclusion\n", + "Power analysis proves to be an invaluable tool in determining the feasibility of an experiment. As we model reality, it guides us in selecting appropriate models and experimenting with those that better interpret reality. Consequently, this enhances our ability to measure the impact of our actions.\n", + "\n", + "However, the application of power analysis still relies on several assumptions, such as:\n", + "\n", + "1. The model's accuracy before the intervention is presumed to remain consistent afterward. Essentially, we assume stable model behavior both pre- and post-intervention.\n", + "2. When applying corrections, we assume that systematic errors will persist throughout the intervention period.\n", + "\n", + "Netherless, if we can uphold these assumptions, then we are positioned to:\n", + "\n", + "1. Determine the likely impact of our actions and potentially discard those that may not produce significant changes, addressing them with other types of tests.\n", + "2. Choose models based on factors other than R-squared (R2) or Mean Absolute Percentage Error (MAPE).\n", + "3. Correct inherent biases in the model, leading to more accurate estimations of effects." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1270b2c0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}