diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8e593702..2a6a75eb 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,6 +10,7 @@ repos: exclude_types: [svg] - id: check-yaml - id: check-added-large-files + args: ['--maxkb=1500'] - repo: https://github.com/charliermarsh/ruff-pre-commit rev: v0.1.4 hooks: diff --git a/README.md b/README.md index c7745c9f..3342cdae 100644 --- a/README.md +++ b/README.md @@ -144,6 +144,25 @@ Regression discontinuity designs are used when treatment is applied to units acc > The data, model fit, and counterfactual are plotted (top). Frequentist analysis shows the causal impact with the blue shaded region, but this is not shown in the Bayesian analysis to avoid a cluttered chart. Instead, the Bayesian analysis shows shaded Bayesian credible regions of the model fits. The Frequentist analysis visualises the point estimate of the causal impact, but the Bayesian analysis also plots the posterior distribution of the regression discontinuity effect (bottom). +### Regression kink designs + +Regression discontinuity designs are used when treatment is applied to units according to a cutoff on a running variable, which is typically not time. By looking for the presence of a discontinuity at the precise point of the treatment cutoff then we can make causal claims about the potential impact of the treatment. + +| Running variable | Outcome | +|-----------|-----------| +| $x_0$ | $y_0$ | +| $x_1$ | $y_0$ | +| $\ldots$ | $\ldots$ | +| $x_{N-1}$ | $y_{N-1}$ | +| $x_N$ | $y_N$ | + + +| Frequentist | Bayesian | +|--|--| +| coming soon | ![](docs/source/_static/regression_kink_pymc.svg) | + +> The data and model fit. The Bayesian analysis shows the posterior mean with credible intervals (shaded regions). We also report the Bayesian $R^2$ on the data along with the posterior mean and credible intervals of the change in gradient at the kink point. + ### Interrupted time series Interrupted time series analysis is appropriate when you have a time series of observations which undergo treatment at a particular point in time. This kind of analysis has no control group and looks for the presence of a change in the outcome measure at or soon after the treatment time. Multiple predictors can be included. diff --git a/causalpy/pymc_experiments.py b/causalpy/pymc_experiments.py index c32b62d9..518095cd 100644 --- a/causalpy/pymc_experiments.py +++ b/causalpy/pymc_experiments.py @@ -12,7 +12,7 @@ """ import warnings -from typing import Optional, Union +from typing import Union import arviz as az import matplotlib.pyplot as plt @@ -328,7 +328,7 @@ def plot(self, counterfactual_label="Counterfactual", **kwargs): fontsize=LEGEND_FONT_SIZE, ) - return (fig, ax) + return fig, ax def summary(self) -> None: """ @@ -424,7 +424,7 @@ def plot(self, plot_predictors=False, **kwargs): ax[0].plot( self.datapost.index, self.post_X, "-", c=[0.8, 0.8, 0.8], zorder=1 ) - return (fig, ax) + return fig, ax class DifferenceInDifferences(ExperimentalDesign): @@ -794,7 +794,7 @@ def __init__( model=None, running_variable_name: str = "x", epsilon: float = 0.001, - bandwidth: Optional[float] = None, + bandwidth: float = np.inf, **kwargs, ): super().__init__(model=model, **kwargs) @@ -807,7 +807,7 @@ def __init__( self.bandwidth = bandwidth self._input_validation() - if self.bandwidth is not None: + if self.bandwidth is not np.inf: fmin = self.treatment_threshold - self.bandwidth fmax = self.treatment_threshold + self.bandwidth filtered_data = self.data.query(f"{fmin} <= x <= {fmax}") @@ -836,7 +836,7 @@ def __init__( self.score = self.model.score(X=self.X, y=self.y) # get the model predictions of the observed data - if self.bandwidth is not None: + if self.bandwidth is not np.inf: xi = np.linspace(fmin, fmax, 200) else: xi = np.linspace( @@ -903,7 +903,7 @@ def plot(self): self.data, x=self.running_variable_name, y=self.outcome_variable_name, - c="k", # hue="treated", + c="k", ax=ax, ) @@ -939,7 +939,7 @@ def plot(self): labels=labels, fontsize=LEGEND_FONT_SIZE, ) - return (fig, ax) + return fig, ax def summary(self) -> None: """ @@ -957,6 +957,220 @@ def summary(self) -> None: self.print_coefficients() +class RegressionKink(ExperimentalDesign): + """ + A class to analyse sharp regression kink experiments. + + :param data: + A pandas dataframe + :param formula: + A statistical model formula + :param kink_point: + A scalar threshold value at which there is a change in the first derivative of + the assignment function + :param model: + A PyMC model + :param running_variable_name: + The name of the predictor variable that the kink_point is based upon + :param epsilon: + A small scalar value which determines how far above and below the kink point to + evaluate the causal impact. + :param bandwidth: + Data outside of the bandwidth (relative to the discontinuity) is not used to fit + the model. + """ + + def __init__( + self, + data: pd.DataFrame, + formula: str, + kink_point: float, + model=None, + running_variable_name: str = "x", + epsilon: float = 0.001, + bandwidth: float = np.inf, + **kwargs, + ): + super().__init__(model=model, **kwargs) + self.expt_type = "Regression Kink" + self.data = data + self.formula = formula + self.running_variable_name = running_variable_name + self.kink_point = kink_point + self.epsilon = epsilon + self.bandwidth = bandwidth + self._input_validation() + + if self.bandwidth is not np.inf: + fmin = self.kink_point - self.bandwidth + fmax = self.kink_point + self.bandwidth + filtered_data = self.data.query(f"{fmin} <= x <= {fmax}") + if len(filtered_data) <= 10: + warnings.warn( + f"Choice of bandwidth parameter has lead to only {len(filtered_data)} remaining datapoints. Consider increasing the bandwidth parameter.", # noqa: E501 + UserWarning, + ) + y, X = dmatrices(formula, filtered_data) + else: + y, X = dmatrices(formula, self.data) + + self._y_design_info = y.design_info + self._x_design_info = X.design_info + self.labels = X.design_info.column_names + self.y, self.X = np.asarray(y), np.asarray(X) + self.outcome_variable_name = y.design_info.column_names[0] + + COORDS = {"coeffs": self.labels, "obs_indx": np.arange(self.X.shape[0])} + self.model.fit(X=self.X, y=self.y, coords=COORDS) + + # score the goodness of fit to all data + self.score = self.model.score(X=self.X, y=self.y) + + # get the model predictions of the observed data + if self.bandwidth is not np.inf: + xi = np.linspace(fmin, fmax, 200) + else: + xi = np.linspace( + np.min(self.data[self.running_variable_name]), + np.max(self.data[self.running_variable_name]), + 200, + ) + self.x_pred = pd.DataFrame( + {self.running_variable_name: xi, "treated": self._is_treated(xi)} + ) + (new_x,) = build_design_matrices([self._x_design_info], self.x_pred) + self.pred = self.model.predict(X=np.asarray(new_x)) + + # evaluate gradient change around kink point + mu_kink_left, mu_kink, mu_kink_right = self._probe_kink_point() + self.gradient_change = self._eval_gradient_change( + mu_kink_left, mu_kink, mu_kink_right, epsilon + ) + + @staticmethod + def _eval_gradient_change(mu_kink_left, mu_kink, mu_kink_right, epsilon): + """Evaluate the gradient change at the kink point. + It works by evaluating the model below the kink point, at the kink point, + and above the kink point. + This is a static method for ease of testing. + """ + gradient_left = (mu_kink - mu_kink_left) / epsilon + gradient_right = (mu_kink_right - mu_kink) / epsilon + gradient_change = gradient_right - gradient_left + return gradient_change + + def _probe_kink_point(self): + # Create a dataframe to evaluate predicted outcome at the kink point and either + # side + x_predict = pd.DataFrame( + { + self.running_variable_name: np.array( + [ + self.kink_point - self.epsilon, + self.kink_point, + self.kink_point + self.epsilon, + ] + ), + "treated": np.array([0, 1, 1]), + } + ) + (new_x,) = build_design_matrices([self._x_design_info], x_predict) + predicted = self.model.predict(X=np.asarray(new_x)) + # extract predicted mu values + mu_kink_left = predicted["posterior_predictive"].sel(obs_ind=0)["mu"] + mu_kink = predicted["posterior_predictive"].sel(obs_ind=1)["mu"] + mu_kink_right = predicted["posterior_predictive"].sel(obs_ind=2)["mu"] + return mu_kink_left, mu_kink, mu_kink_right + + def _input_validation(self): + """Validate the input data and model formula for correctness""" + if "treated" not in self.formula: + raise FormulaException( + "A predictor called `treated` should be in the formula" + ) + + if _is_variable_dummy_coded(self.data["treated"]) is False: + raise DataException( + """The treated variable should be dummy coded. Consisting of 0's and 1's only.""" # noqa: E501 + ) + + if self.bandwidth <= 0: + raise ValueError("The bandwidth must be greater than zero.") + + if self.epsilon <= 0: + raise ValueError("Epsilon must be greater than zero.") + + def _is_treated(self, x): + """Returns ``True`` if `x` is greater than or equal to the treatment threshold.""" # noqa: E501 + return np.greater_equal(x, self.kink_point) + + def plot(self): + """ + Plot the results + """ + fig, ax = plt.subplots() + # Plot raw data + sns.scatterplot( + self.data, + x=self.running_variable_name, + y=self.outcome_variable_name, + c="k", # hue="treated", + ax=ax, + ) + + # Plot model fit to data + h_line, h_patch = plot_xY( + self.x_pred[self.running_variable_name], + self.pred["posterior_predictive"].mu, + ax=ax, + plot_hdi_kwargs={"color": "C1"}, + ) + handles = [(h_line, h_patch)] + labels = ["Posterior mean"] + + # create strings to compose title + title_info = f"{self.score.r2:.3f} (std = {self.score.r2_std:.3f})" + r2 = f"Bayesian $R^2$ on all data = {title_info}" + percentiles = self.gradient_change.quantile([0.03, 1 - 0.03]).values + ci = r"$CI_{94\%}$" + f"[{percentiles[0]:.2f}, {percentiles[1]:.2f}]" + grad_change = f""" + Change in gradient = {self.gradient_change.mean():.2f}, + """ + ax.set(title=r2 + "\n" + grad_change + ci) + # Intervention line + ax.axvline( + x=self.kink_point, + ls="-", + lw=3, + color="r", + label="treatment threshold", + ) + ax.legend( + handles=(h_tuple for h_tuple in handles), + labels=labels, + fontsize=LEGEND_FONT_SIZE, + ) + return fig, ax + + def summary(self) -> None: + """ + Print text output summarising the results + """ + + print( + f""" + {self.expt_type:=^80} + Formula: {self.formula} + Running variable: {self.running_variable_name} + Kink point on running variable: {self.kink_point} + + Results: + Change in slope at kink point = {self.gradient_change.mean():.2f} + """ + ) + self.print_coefficients() + + class PrePostNEGD(ExperimentalDesign): """ A class to analyse data from pretest/posttest designs diff --git a/causalpy/tests/test_input_validation.py b/causalpy/tests/test_input_validation.py index 9442c8bc..1e07520e 100644 --- a/causalpy/tests/test_input_validation.py +++ b/causalpy/tests/test_input_validation.py @@ -1,5 +1,6 @@ """Input validation tests""" +import numpy as np import pandas as pd import pytest @@ -223,3 +224,82 @@ def test_iv_treatment_var_is_present(): sample_kwargs=sample_kwargs ), ) + + +# Regression kink design + + +def setup_regression_kink_data(kink): + """Set up data for regression kink design tests""" + # define parameters for data generation + seed = 42 + rng = np.random.default_rng(seed) + N = 50 + beta = [0, -1, 0, 2, 0] + sigma = 0.05 + # generate data + x = rng.uniform(-1, 1, N) + y = reg_kink_function(x, beta, kink) + rng.normal(0, sigma, N) + return pd.DataFrame({"x": x, "y": y, "treated": x >= kink}) + + +def reg_kink_function(x, beta, kink): + """Utility function for regression kink design. Returns a piecewise linear function + evaluated at x with a kink at kink and parameters beta""" + return ( + beta[0] + + beta[1] * x + + beta[2] * x**2 + + beta[3] * (x - kink) * (x >= kink) + + beta[4] * (x - kink) ** 2 * (x >= kink) + ) + + +def test_rkink_bandwidth_check(): + """Test that we get exceptions when bandwidth parameter is <= 0""" + with pytest.raises(ValueError): + kink = 0.5 + df = setup_regression_kink_data(kink) + _ = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + bandwidth=0, + ) + + with pytest.raises(ValueError): + kink = 0.5 + df = setup_regression_kink_data(kink) + _ = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + bandwidth=-1, + ) + + +def test_rkink_epsilon_check(): + """Test that we get exceptions when epsilon parameter is <= 0""" + with pytest.raises(ValueError): + kink = 0.5 + df = setup_regression_kink_data(kink) + _ = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + epsilon=0, + ) + + with pytest.raises(ValueError): + kink = 0.5 + df = setup_regression_kink_data(kink) + _ = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + epsilon=-1, + ) diff --git a/causalpy/tests/test_integration_pymc_examples.py b/causalpy/tests/test_integration_pymc_examples.py index 59911a0e..bf4ae992 100644 --- a/causalpy/tests/test_integration_pymc_examples.py +++ b/causalpy/tests/test_integration_pymc_examples.py @@ -1,3 +1,4 @@ +import numpy as np import pandas as pd import pytest @@ -217,6 +218,84 @@ def test_rd_drinking(): assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] +def setup_regression_kink_data(kink): + """Set up data for regression kink design tests""" + # define parameters for data generation + seed = 42 + rng = np.random.default_rng(seed) + N = 50 + kink = 0.5 + beta = [0, -1, 0, 2, 0] + sigma = 0.05 + # generate data + x = rng.uniform(-1, 1, N) + y = reg_kink_function(x, beta, kink) + rng.normal(0, sigma, N) + return pd.DataFrame({"x": x, "y": y, "treated": x >= kink}) + + +def reg_kink_function(x, beta, kink): + """Utility function for regression kink design. Returns a piecewise linear function + evaluated at x with a kink at kink and parameters beta""" + return ( + beta[0] + + beta[1] * x + + beta[2] * x**2 + + beta[3] * (x - kink) * (x >= kink) + + beta[4] * (x - kink) ** 2 * (x >= kink) + ) + + +@pytest.mark.integration +def test_rkink(): + """ + Test Regression Kink design. + + Loads data and checks: + 1. data is a dataframe + 2. pymc_experiments.RegressionKink returns correct type + 3. the correct number of MCMC chains exists in the posterior inference data + 4. the correct number of MCMC draws exists in the posterior inference data + """ + kink = 0.5 + df = setup_regression_kink_data(kink) + result = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + ) + assert isinstance(df, pd.DataFrame) + assert isinstance(result, cp.pymc_experiments.RegressionKink) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + + +@pytest.mark.integration +def test_rkink_bandwidth(): + """ + Test Regression Kink experiment with bandwidth parameter. + + Generates synthetic data and checks: + 1. data is a dataframe + 2. pymc_experiments.RegressionKink returns correct type + 3. the correct number of MCMC chains exists in the posterior inference data + 4. the correct number of MCMC draws exists in the posterior inference data + """ + kink = 0.5 + df = setup_regression_kink_data(kink) + result = cp.pymc_experiments.RegressionKink( + df, + formula=f"y ~ 1 + x + I((x-{kink})*treated)", + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + kink_point=kink, + bandwidth=0.3, + ) + assert isinstance(df, pd.DataFrame) + assert isinstance(result, cp.pymc_experiments.RegressionKink) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + + @pytest.mark.integration def test_its(): """ diff --git a/causalpy/tests/test_pymc_experiments.py b/causalpy/tests/test_pymc_experiments.py index 51a6b5f7..622815f5 100644 --- a/causalpy/tests/test_pymc_experiments.py +++ b/causalpy/tests/test_pymc_experiments.py @@ -19,3 +19,24 @@ def test_did_summary(): ) print(type(result._causal_impact_summary_stat())) assert isinstance(result._causal_impact_summary_stat(), str) + + +def test_regression_kink_gradient_change(): + """Test function to numerically calculate the change in gradient around the kink + point in regression kink designs""" + # test no change in gradient + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(-1, 0, 1, 1) == 0.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(1, 0, -1, 1) == 0.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(0, 0, 0, 1) == 0.0 + # test positive change in gradient + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(0, 0, 1, 1) == 1.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(0, 0, 2, 1) == 2.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(-1, -1, 2, 1) == 3.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(-1, 0, 2, 1) == 1.0 + # test negative change in gradient + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(0, 0, -1, 1) == -1.0 + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(0, 0, -2, 1) == -2.0 + assert ( + cp.pymc_experiments.RegressionKink._eval_gradient_change(-1, -1, -2, 1) == -1.0 + ) + assert cp.pymc_experiments.RegressionKink._eval_gradient_change(1, 0, -2, 1) == -1.0 diff --git a/docs/source/_static/classes.png b/docs/source/_static/classes.png index cfd4b8f3..35af55d7 100644 Binary files a/docs/source/_static/classes.png and b/docs/source/_static/classes.png differ diff --git a/docs/source/_static/interrogate_badge.svg b/docs/source/_static/interrogate_badge.svg index 915a4635..cc0bc3d6 100644 --- a/docs/source/_static/interrogate_badge.svg +++ b/docs/source/_static/interrogate_badge.svg @@ -1,5 +1,5 @@ - interrogate: 97.3% + interrogate: 96.9% @@ -12,8 +12,8 @@ interrogate interrogate - 97.3% - 97.3% + 96.9% + 96.9% diff --git a/docs/source/_static/packages.png b/docs/source/_static/packages.png index c6e1e6bd..5de25ef3 100644 Binary files a/docs/source/_static/packages.png and b/docs/source/_static/packages.png differ diff --git a/docs/source/_static/regression_kink_pymc.svg b/docs/source/_static/regression_kink_pymc.svg new file mode 100644 index 00000000..79c6653b --- /dev/null +++ b/docs/source/_static/regression_kink_pymc.svg @@ -0,0 +1,1913 @@ + + + + + + + + 2023-11-06T11:40:01.467891 + image/svg+xml + + + Matplotlib v3.8.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/source/examples.rst b/docs/source/examples.rst index b70a6300..e4850d58 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -52,6 +52,14 @@ Regression Discontinuity notebooks/rd_pymc_drinking.ipynb notebooks/rd_skl_drinking.ipynb +Regression Kink Design +====================== + +.. toctree:: + :titlesonly: + + notebooks/rkink_pymc.ipynb + Instrumental Variables Regression ================================= diff --git a/docs/source/glossary.rst b/docs/source/glossary.rst index d6edce95..2251d2ce 100644 --- a/docs/source/glossary.rst +++ b/docs/source/glossary.rst @@ -69,6 +69,9 @@ Glossary Regression discontinuity design A quasi–experimental comparison to estimate a treatment effect where units are assigned to treatment conditions based on a cut-off score on a quantitative assignment variable (aka running variable). + Regression kink design + A quasi-experimental research design that estimates treatment effects by analyzing the impact of a treatment or intervention precisely at a defined threshold or "kink" point in a quantitative assignment variable (running variable). Unlike traditional regression discontinuity designs, regression kink design looks for a change in the slope of an outcome variable at the kink, instead of a discontinuity. This is useful when the assignment variable is not discrete, jumping from 0 to 1 at a threshold. Instead, regression kink designs are appropriate when there is a change in the first derivative of the assignment function at the kink point. + Sharp regression discontinuity design A Regression discontinuity design where allocation to treatment or control is determined by a sharp threshold / step function. diff --git a/docs/source/index.rst b/docs/source/index.rst index bba56599..b69b3f4a 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -103,6 +103,13 @@ Regression discontinuity designs are used when treatment is applied to units acc .. image:: _static/regression_discontinuity_pymc.svg +Regression kink designs +""""""""""""""""""""""" + +Regression kink designs are used when there is a change in the level of treatment at a "kink point" on a running variable, which is typically not time. By looking for the presence of a discontinuity in the gradient at the kink point then we can make causal claims about the potential impact of changes in the treatment. + +.. image:: _static/regression_kink_pymc.svg + Interrupted time series """"""""""""""""""""""" Interrupted time series analysis is appropriate when you have a time series of observations which undergo treatment at a particular point in time. This kind of analysis has no control group and looks for the presence of a change in the outcome measure at or soon after the treatment time. diff --git a/docs/source/notebooks/generate_plots.ipynb b/docs/source/notebooks/generate_plots.ipynb index 0ffc645f..7cdf74d2 100644 --- a/docs/source/notebooks/generate_plots.ipynb +++ b/docs/source/notebooks/generate_plots.ipynb @@ -10,11 +10,20 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" + ] + } + ], "source": [ "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import pandas as pd\n", "\n", "import causalpy as cp" @@ -22,11 +31,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "seed = 42\n", + "rng = np.random.default_rng(seed)\n", "image_path = \"../_static/\"" ] }, @@ -383,6 +393,144 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Regression kink design" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x, beta, kink):\n", + " return (\n", + " beta[0]\n", + " + beta[1] * x\n", + " + beta[2] * x**2\n", + " + beta[3] * (x - kink) * (x >= kink)\n", + " + beta[4] * (x - kink) ** 2 * (x >= kink)\n", + " )\n", + "\n", + "\n", + "def generate_data(beta, kink, sigma=0.05, N=50):\n", + " if beta is None:\n", + " beta = rng.random(5)\n", + " x = rng.uniform(-1, 1, N)\n", + " y = f(x, beta, kink) + rng.normal(0, sigma, N)\n", + " df = pd.DataFrame({\"x\": x, \"y\": y, \"treated\": x >= kink})\n", + " return df\n", + "\n", + "\n", + "kink = 0.5\n", + "# linear function with gradient change of 2 at kink point\n", + "beta = [0, -1, 0, 2, 0]\n", + "sigma = 0.05\n", + "df = generate_data(beta, kink, sigma=sigma)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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:00<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", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result = cp.pymc_experiments.RegressionKink(\n", + " df,\n", + " formula=f\"y ~ 1 + x + I((x-{kink})*treated)\",\n", + " model=cp.pymc_models.LinearRegression(sample_kwargs={\"random_seed\": seed}),\n", + " kink_point=kink,\n", + " epsilon=0.1,\n", + ")\n", + "\n", + "fig, ax = result.plot()\n", + "plt.savefig(\n", + " image_path + \"regression_kink_pymc.svg\",\n", + " bbox_inches=\"tight\",\n", + " pad_inches=0.1,\n", + ")" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -643,7 +791,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.11.6" }, "orig_nbformat": 4, "vscode": { diff --git a/docs/source/notebooks/rkink_pymc.ipynb b/docs/source/notebooks/rkink_pymc.ipynb new file mode 100644 index 00000000..554f0b52 --- /dev/null +++ b/docs/source/notebooks/rkink_pymc.ipynb @@ -0,0 +1,896 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Regression kink design with `pymc` models" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" + ] + } + ], + "source": [ + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import causalpy as cp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%config InlineBackend.figure_format = 'retina'\n", + "seed = 42\n", + "rng = np.random.default_rng(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The {term}`Regression kink design` should be analysed by a piecewise continuous function. That is:\n", + "* We want a function which can capture the data to the left and to the right of the kink point.\n", + "* We want a piecewise function with one breakpoint or kink point\n", + "* The function should be continuous at the kink point\n", + "\n", + "An example of such a function would be a piecewise continuous polynomial:\n", + "\n", + "$$\n", + "\\mu = \\beta_0 + \\beta_1 \\cdot x + \\beta_2 \\cdot x^2 + \\beta_3 \\cdot (x-k) \\cdot t + \\beta_4 \\cdot (x-k)^2 \\cdot t\n", + "$$\n", + "\n", + "Where:\n", + "* $\\beta$'s are the unknown parameters,\n", + "* $x$ is the running variable,\n", + "* $t$ is an indicator variable which is $1$ if $x \\geq k$, and $0$ otherwise,\n", + "* $k$ is the value of $x$ at the kink point.\n", + "\n", + "We can visualise what these functions look like by plotting a number of them with randomly chosen $\\beta$ coefficients, but all with a kink point at $0.5$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 511, + "width": 1511 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "def f(x, beta, kink):\n", + " return (\n", + " beta[0]\n", + " + beta[1] * x\n", + " + beta[2] * x**2\n", + " + beta[3] * (x - kink) * (x >= kink)\n", + " + beta[4] * (x - kink) ** 2 * (x >= kink)\n", + " )\n", + "\n", + "\n", + "def gradient_change(beta, kink, epsilon=0.01):\n", + " gradient_left = (f(kink, beta, kink) - f(kink - epsilon, beta, kink)) / epsilon\n", + " gradient_right = (f(kink + epsilon, beta, kink) - f(kink, beta, kink)) / epsilon\n", + " gradient_change = gradient_right - gradient_left\n", + " return gradient_change\n", + "\n", + "\n", + "x = np.linspace(-1, 1, 1000)\n", + "kink = 0.5\n", + "cols = 5\n", + "\n", + "fig, ax = plt.subplots(2, cols, sharex=True, sharey=True, figsize=(15, 5))\n", + "\n", + "for col in range(cols):\n", + " beta = rng.random(5)\n", + " ax[0, col].plot(x, f(x, beta, kink), lw=3)\n", + " ax[1, col].plot(x, np.gradient(f(x, beta, kink), x), lw=3)\n", + " ax[0, col].set(title=f\"Random {col+1}\")\n", + " ax[1, col].set(xlabel=\"x\")\n", + "\n", + "ax[0, 0].set(ylabel=\"$y = f(x)$\")\n", + "ax[1, 0].set(ylabel=r\"$\\frac{dy}{dx}$\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The idea of regression kink analysis is to fit a suitable function to data and to estimate whether there is a change in the gradient of the function at the kink point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we will generate a number of datasets and run through how to conduct the regression kink analysis. We will use a function to generate simulated datasets with the properties we want." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_data(beta, kink, sigma=0.05, N=50):\n", + " if beta is None:\n", + " beta = rng.random(5)\n", + " x = rng.uniform(-1, 1, N)\n", + " y = f(x, beta, kink) + rng.normal(0, sigma, N)\n", + " df = pd.DataFrame({\"x\": x, \"y\": y, \"treated\": x >= kink})\n", + " return df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 - continuous piecewise linear function\n", + "In this example we'll stick to a simple continuous piecewise function." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kink = 0.5\n", + "# linear function with gradient change of 2 at kink point\n", + "beta = [0, -1, 0, 2, 0]\n", + "sigma = 0.05\n", + "df = generate_data(beta, kink, sigma=sigma)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(df[\"x\"], df[\"y\"], alpha=0.5)\n", + "ax.axvline(kink, color=\"red\", linestyle=\"--\")\n", + "ax.set(title=f\"Change in gradient at kink point: {gradient_change(beta, kink):.2f}\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the regular `cp.pymc_models.LinearRegression` model and enforce the continuous piecewise nature by cleverly specifying a design matrix via the `formula` input.\n", + "\n", + "In this example, setting the formula to `\"y ~ 1 + x + I((x-0.5)*treated)\"` (where the 0.5 is the kink point) equates to the following model:\n", + "\n", + "$$\n", + "\\mu = \\beta_0 + \\beta_1 \\cdot x + \\beta_3 \\cdot (x-k) \\cdot t\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{note}\n", + "The change in gradient either side of the kink point is evaluated numerically. The `epsilon` parameter determines the distance either side of the kink point that is used in this change in gradient calculation.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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:00<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", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "result1 = cp.pymc_experiments.RegressionKink(\n", + " df,\n", + " formula=f\"y ~ 1 + x + I((x-{kink})*treated)\",\n", + " model=cp.pymc_models.LinearRegression(sample_kwargs={\"random_seed\": seed}),\n", + " kink_point=kink,\n", + " epsilon=0.1,\n", + ")\n", + "\n", + "fig, ax = result1.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to plot the posterior distribution of the inferred gradient change, you can do it as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = az.plot_posterior(result1.gradient_change, ref_val=gradient_change(beta, kink))\n", + "ax.set(title=\"Gradient change\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We know that the correct gradient change is 2, and that we have correctly recovered it as the posterior distribution is centred around 2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also ask for summary information:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================Regression Kink=================================\n", + "Formula: y ~ 1 + x + I((x-0.5)*treated)\n", + "Running variable: x\n", + "Kink point on running variable: 0.5\n", + "\n", + "Results:\n", + "Change in slope at kink point = 1.93\n", + "Model coefficients:\n", + "Intercept -0.01, 94% HDI [-0.02, 0.01]\n", + "x -0.99, 94% HDI [-1.01, -0.96]\n", + "I((x - 0.5) * treated) 1.93, 94% HDI [1.77, 2.10]\n", + "sigma 0.04, 94% HDI [0.03, 0.05]\n" + ] + } + ], + "source": [ + "result1.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 - continuous piecewise polynomial function\n", + "\n", + "Now we'll introduce some nonlinearity into the mix.\n", + "\n", + "In this example, we're going to have a 2nd order polynomial on either side of the kink point. So the model can be defined as:\n", + "\n", + "$$\n", + "\\mu = \\beta_0 + \\beta_1 \\cdot x + \\beta_2 \\cdot x^2 + \\beta_3 \\cdot (x-k) \\cdot t + \\beta_4 \\cdot (x-k)^2 \\cdot t\n", + "$$\n", + "\n", + "While it's a bit verbose, we can implement this in a [patsy](https://patsy.readthedocs.io/en/latest/index.html) formula as so:\n", + "\n", + "> `y ~ 1 + x + np.power(x, 2) + I((x-0.5)*treated) + I(np.power((x-0.5), 2)*treated)` \n", + "\n", + "where the 0.5 is the kink point." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kink = 0.5\n", + "# quadratic function going from 1*x^2 on the left of the kink point, to 1*x^2 -\n", + "# 1*(x-kink) - 5*(x-kink)^2 to the right of the kink point\n", + "beta = [0, 0, 1, -1, -5]\n", + "df = generate_data(beta, kink, N=200, sigma=sigma)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(df[\"x\"], df[\"y\"], alpha=0.5)\n", + "ax.axvline(kink, color=\"red\", linestyle=\"--\")\n", + "ax.set(title=f\"Change in gradient at kink point: {gradient_change(beta, kink):.2f}\");" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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:02<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 3 seconds.\n", + "Sampling: [beta, sigma, y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "formula = f\"y ~ 1 + x + np.power(x, 2) + I((x-{kink})*treated) + I(np.power(x-{kink}, 2)*treated)\"\n", + "\n", + "result2 = cp.pymc_experiments.RegressionKink(\n", + " df,\n", + " formula=formula,\n", + " model=cp.pymc_models.LinearRegression(sample_kwargs={\"random_seed\": seed}),\n", + " kink_point=kink,\n", + " epsilon=0.01,\n", + ")\n", + "\n", + "fig, ax = result2.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also evaluate the posterior distribution of the parameters and see how they match up with the true values." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 1115, + "width": 2495 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = az.plot_posterior(\n", + " result2.idata, var_names=[\"beta\", \"sigma\"], ref_val=beta + [sigma]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can see that we have also done a good job at recovering the true gradient change." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = az.plot_posterior(result2.gradient_change, ref_val=gradient_change(beta, kink))\n", + "ax.set(title=\"Gradient change\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 - basis spline model\n", + "\n", + "As a final example to demonstrate that we need not be constrained to polynomial functions, we can use a basis spline model. This takes advantage of the capability of `patsy` to generate design matricies with basis splines. Note that we will use the same simulated dataset as the previous example." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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:03<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 4 seconds.\n", + "Sampling: [beta, sigma, y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABbcAAAPXCAYAAAAYJXYaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd1QU19sH8O9SpYMKFkRBImCPqNhiNLbYYtRYo6ixK5YY84sajS0xJjEm9hgVxd41GqNRg2CLil1ERQWxC0qVpcO+f/AyYXYX2IUtLHw/5+Qc792ZuQ/D7GR59s5zJTKZTAYiIiIiIiIiIiIiIgNipO8AiIiIiIiIiIiIiIjUxeQ2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcEx0XcARERERJoglUpx4cIFXLp0CWFhYYiKikJSUhJMTU1RsWJF1K9fH506dULXrl1hZmam73CJiIiIiIiohCQymUym7yCIiIiISmLTpk349ddfkZ6eXuS2NWvWxI8//ghvb28dREZERERERETawpnbREREZPAePXokJLYdHR3RqlUrNGzYEJUrV0ZGRgbCwsJw+PBhJCQk4MmTJxg5ciQ2bdqEJk2a6DlyIiIiIiIiKi7O3CYiIiKDN2/ePDx58gSfffYZ2rRpA2NjY4Vt4uLiMGHCBNy4cQMA4ObmhqNHj8LIiEuQEBERERERGSImt4mIiMjgJSQkwN7evsjtoqOj0aVLF6SlpQEAtm7dCh8fHy1HR0RERERERNrAsiRERFSu+fr6IiQkRGhv2bIFLVq00GNEVByqJLYBoEqVKmjWrBnOnTsHAAgPD2dyuwwrzvvbUO4JhhInlQ05OTm4ffs27t+/j7i4OMhkMtjb28Pd3R2NGzeGqampvkMEkPsF5s2bNxEbG4uEhASYm5ujatWqqF+/PmrVqqXv8MqV5ORkdO3aFa9fvwYAjBgxArNmzdJzVPrF+7bmGMo9CdB9rIZ0bgpz48YNDBw4UGhv2LABbdu21WNEVJoxuU1E5cbMmTNx8OBBlbaVSCSwsrKCjY0NXFxcUK9ePbRr1w6tWrWCRCLRcqREhm3hwoXYvn17kdsZGRnBxsYGDg4OqFu3Lpo3b45evXrBxsZGq/FZW1sL/05NTdXqWEREhkwqlcLf3x+7du1CbGys0m1sbGzQp08fTJgwARUrVtRxhEBWVhYOHjyILVu24P79+wVu984778DX1xf9+/dXWrqqKJcuXcKwYcNKEiqA3C9V1SWTyfD48WPcunULoaGhCA0NxZ07dxQWUS7OsbVl1apVQmLbxsYG48eP13NEVBYYwj0pj65j1fZ4ur4Hvvvuu+jcuTNOnjwJAFi0aBH+/PNPg0nOk24xuU1EpIRMJkNycjKSk5Px8uVLhISEICAgAM7Ozpg5cya6dOmi7xCJSq07d+6otF1OTg4SExORmJiIqKgoHDt2DEuWLIGfnx9GjRqltVrYDx48EP5do0YNrYxBVN4dOHAAz58/F9p9+vTh+83AhIaGYsqUKXjx4kWh2719+xZbtmzB4cOHsWTJErz//vs6ihCIiIjA5MmTERERUeS2Dx8+xLx587Bnzx6sWLGi1F+PUqkU69atE5LZSUlJ+g5JZREREdi2bZvQHjVqFBwcHPQWD+9HZYMh3JPy6DpWQzo36pg2bRoCAwORk5ODR48eYevWrRg5cqS+w6JSiCsoERGp4fnz55g8eTLmzZsHLllApCgnJ6dEM8dSU1Px888/4/PPP0dOTo4GI8t16dIlIQliamqKNm3aaHwMIgIOHjyIVatWCf/lTyxR6Xfz5k0MGzZMaaLEzMwMFSpUUOhPSEjAhAkTEBgYqIsQcfXqVQwaNEhpYtvIyAh2dnZKZ2iHhYVh8ODBePz4sS7CLLb4+HisXbsW58+fN6jENgAsX74cmZmZAHKflho6dKhe4+H9yPAZwj0pj65jNaRzoy53d3d06tRJaP/+++9ITk7WY0RUWnHmNhGVW66urhgxYoTS17Kzs5GcnIxHjx7h4sWLePXqlej1Xbt2wd7eHtOmTdNBpESGIyoqCikpKaK+SZMmoXLlygrbJicnIyIiAkFBQUhISBC9dvz4caxduxYTJ07UWGypqamYN2+e0Pb19YWdnZ3Gjk9EVBbExcXBz89PdC83MTHBkCFDMHjwYNSqVQsSiQQvXrzAvn37EBAQIGyblZWFL7/8EgcOHICbm5vWYoyOjsaUKVMUkr5dunSBr68vvL29YWJigpycHISFhWHPnj3Yt2+f8KVpTEwMJk6ciL1798LS0rJYMRT2ObI8u3PnDk6cOCG0Bw0apPVyY1S2GcI9SV+x6vPc6OoeOGbMGOGekpCQgE2bNmHy5MlaH5cMC5PbRFRuOTk5YfDgwUVul5OTg0OHDmHhwoWiDw4bNmxAr1694O7urs0wScu2bt2q7xDKlLt374raxsbGGDt2LMzNzQvcJyUlBd9++y0OHDgg6l+/fj0+/fRTlReLLIxMJsNXX32FR48eAcj9QO7n51fi4xIRlTUrV64UaiUDuTP/VqxYgQ8++EC0nbOzM6ZOnYr27dtjzJgxSExMBJB7T//hhx/w+++/ay3GuXPn4s2bN0JbIpFg4cKFGDBggGg7IyMjNGzYEA0bNkSnTp0wefJkoU71w4cPsXHjRkyaNKlYMaj6OVJTLC0tUa9ePeHnefz4MZYvX66z8VW1du1a4elGY2Njvc/aJsNnCPckfcWqz3Ojq3tgo0aN0KRJE1y/fh0AsHnzZowcORJWVlZaH5sMB8uSEBEVwcjICH369MGyZctE/VlZWQrJOKLyTr7etqura6GJbSD3D/bvv/8erVu3FvWnpKTg7NmzGonrhx9+EGZ9WFlZYfny5aKFJYmICHj27Bn27t0r6ps8ebJCoiS/xo0bY+7cuaK+4OBgIRGhaWFhYQgODhb1jRo1SiGxLa9du3aYPXu2qG/jxo2Ii4vTdIgaYWFhgUGDBmHRokU4fPgwrly5gu3bt2PmzJno0aMHqlatqu8QFTx9+lRY/A0A2rZti2rVqukxIjJ0hnBPyqPrWA3p3JRU/vv727dv+Tc4KWBym4hIRe3atUPz5s1FfefOndNTNESlk/zMbS8vL5X2k0gkGDdunEL/zZs3SxzTL7/8goCAAAC5ifR169apHBcRUXkSEBAg1EoGchfdVWXxrp49e6Jp06aivvXr12s8PgDYvXu3qG1vb6/yI+oDBw6Eh4eH0JZKpdiyZYtG49OUSpUqYcGCBejXrx88PT2V1g8vbbZt2yZaL6N///56jIbKAkO4J+XRdayGdG5Kqlu3bqISUlu3buX6VyTC5DYRkRpatmwpasvX4iYq7+RnbquTRPb29oZEIhH1xcbGliieX3/9VXjU0tLSEuvXr0ezZs1KdEwiorJKfnGxfv36wcREtUqW8jOnz58/j9TUVI3FlufSpUuido8ePZQumFaQTz75RNQ+fvy4RuIq77KysnDo0CGhbWVlhffff1+PEVFZYAj3pDy6jtWQzk1JWVhYoH379kL78ePHuHLliv4ColKHNbeJiNTg6OgoakulUrWPIZVKERERgUePHiE+Ph4pKSmwtLSEnZ0dXFxc0LBhwyLLOJRmMpkMd+/eRVRUFOLi4pCcnAw7Ozs4OjqiSZMmqFSpUonHePr0Ke7du4eYmBgkJydDJpPBwsICDg4OcHZ2hru7u0bqNKtKn7/T7OxshIaGIjw8HPHx8TA3N4eDgwMaNWqE2rVra2XMgrx69Qrx8fGiPk9PT5X3NzMzg5WVlWgV9PwzwNT1yy+/CIltKysrrF+/XmGmij7ExMTg1q1biI2NRUJCAiwtLVGxYkXUrl0bXl5eCgl+TSlN10p+Zf2eqI60tDSEhITg5cuXiI+PR4UKFeDi4oImTZqgYsWKGh3LEM+7IcZsSO7cuYMXL16I+rp3767y/h9++CFmz56NrKwsALnX8/nz59GpUyeNxZiYmIioqChRn7pfWHp7e4vakZGRiIiI4BoqJXT27FnRZ4D27dvDzMys2McrbZ/1CqLL+3Z5Ywj3pDy6jtWQzo2mfPjhhzh69KjQPnTokMJT1VR+MblNRKQG+W+0VV3IIjw8HMeOHcO///6L27dvIzs7u8BtTU1N0aZNG4wePVql/2GvXbsWv/76q9D28fEp9iKJ/v7++Omnn4T2u+++q/D4b0GePn2K33//HadOnSpwtq1EIkGDBg0wevRodO3aVa3YpFIpAgICcPDgQTx9+rTQbSUSCWrVqoW2bduiT58+qF+/foHb+vr6IiQkRGhv2bIFLVq0KDIebf5O85NPDoeHhwMAMjIy4O/vj61btxZ4vl1dXTFlyhT06NFDrTGLS37WNqDezO3s7GzRoq0Aiv1lyJIlS7BhwwYAgLW1NdavX6+Q0NCl7Oxs7N+/Hzt27FAo3ZKfo6MjunXrhgkTJqj9R7EhXSu6ev8YitevX+OXX37B33//rfAeAHIXZWvXrh2mTZsmKqmgLm2fd/n7aX7Dhg0rdN9JkyYpLS3Ba0V3Ll68KGpXrlwZtWrVUnl/CwsLeHl54fbt20LfhQsXNJosyb+IZJ6aNWuqdQxXV1eFvn///ZfJ7RI6duyYqN22bVu1j6HJz3rauB/lp6v7dnlmCPekPLqO1ZDOjaa89957MDY2Fj4HnDhxAgsWLDCIkk2kfUxuExGpIS9ZlEeV2Y4///yzWnXMMjMzERwcjODgYPTp0wcLFiwodCZa//79sXr1amRkZAAAQkJCijUDSSaTKSSyVVkBOysrC0uXLsXWrVtFdd8KGiM0NBRTp05Fs2bNsHLlSpUSeLdu3cKkSZMQHR1d5LZ540RFRSEqKgovXrzAmjVrVNpPVdr+nRbl6dOnmDhxIu7fv1/odlFRUfjiiy9w4cIFnXz4k09u29vbo0qVKirv//DhQ4WZ2g0bNlQ7jh9//BEbN24EANjY2MDf3x+NGzdW+zia8uDBA0yZMgWRkZFFbvv69Wts2bIF+/fvx6xZs0pcr7Q0Xiv6fv+UNoGBgZg5cyaSkpIK3CY7OxunTp3C2bNnsWDBAoWyCqowxPNuiDEbsocPH4raxbn/vvvuu6JkSURERInjyi8xMVGhz8bGRq1jKFtM+MGDB8WOiXI/d8mvQ+Pj46PWMUrbZ73C6Oq+Xd4Zwj0pj65jNaRzoynW1taoW7euEHNiYiJu3LhRKp7KJP1jcpuISEXx8fGiFeABoE2bNkXuV9gHX0tLS5iZmUEqlSpNDB88eBAxMTHYsGEDjIyUL5NQqVIldO3aFYcPHxb6du7ciTlz5hQZW37//vsvHj9+LLTt7e3RrVu3QvdJTk7G559/jrNnzyp93czMDJaWlnj79q3CbLsrV65g0KBB2LJlC6pWrVrgGJGRkRgxYkSBJWCsrKyEc5iX4Nc2bf9OC/Pq1Sv4+vri5cuXon4rKyvIZDKls4f27t2LSpUqYdq0aWqPpw75GcnqlCQBgL///lvUNjU1xXvvvafWMb7//nts3rwZAGBrawt/f380atRIrWNo0pUrVzBhwoQCrxlbW1ukpKQIj4XmkUqlmDNnDl69eqXyQmnySuu1os/3T2kTGBiIqVOnKv1ZjY2NYW1tjaSkJGHRpMzMTMyePVvlp4byM8TzbogxGzL5L+BcXFzUPob8Pqp8qacOZWUu1P1/v7LtixtnZmYm7t27h1evXiExMRGWlpZwcHBAjRo1inX+DNXdu3dFTwZVr14dzs7OKu9fGj/rFUSX9+3yzhDuSQUdV9uxlpZzo+t7YPPmzUUJ+bNnzzK5TQCY3CYiUkleEvft27dCn6WlpcJiHIVxdnZG+/bt0bJlS3h4eMDFxUU0O/Lp06e4ePEidu7cibCwMKH//PnzWLt2LSZOnFjgsYcMGSJKbh86dAjTp0+HhYWFyvHt3LlT1O7Tp0+hM95kMhmmT5+ukNj28fHBoEGD0Lx5czg5OQHIrZt8584dHDp0CLt27RL+MHn8+DGmTZuGbdu2FThTdNGiRaI/dszMzDB48GB069YNXl5eop8xJSUFDx8+xK1btxAcHKzwyJ6mafN3WpDPP/9cSFa2bt0avr6+8PHxEWaivX79Gn/99RdWrVolul43bNiAXr16afWxa/nktjolSaKjo7FlyxZR30cffaRQ574wixYtEo5hb2+PjRs3FlqSRtuio6Ph5+enkKBr27Ythg0bhpYtW8LMzAw5OTmIjIzEH3/8gYCAANEfzKtWrYKbmxt69uyp9vil+VoB9PP+KU2ePn2K6dOni37fRkZG6N+/P/r374969erB2NgYmZmZuHr1KrZt24aTJ09CJpNhzpw5qFy5crHG1eZ5HzFihFDzMyAgQFQbecSIEUrLQeRp0KCBXmLWhOjoaJw6dUqrY+Tn5uamsMC1JsjXsq5evbrax5D/sjo6Olqoja4JdnZ2Cn1xcXFqHUPZ9o8ePVI7ltDQUDRr1gxpaWlKX69SpQratGmD4cOHq/X/Q0N048YNUVvdL7e18VlPG/cjfd231cV70n+0fU/Ko+tYS8O50cc9UP448vceKr+Y3CYiUiI7OxvJycmIiorC+fPnsXPnTsTExAivSyQSLFiwQEjeFsbb2xtdunQpcgaqi4sLXFxc8Mknn2DNmjVYuXKl8NqGDRswbNgwpY/SArmPldWvX1/4oz4pKQl//fUX+vXrp8qPi+joaAQFBQltiUSCQYMGFbqPv78/goODhba5uTm+/fZbfPzxxwrbGhkZoUGDBmjQoAF69+6NcePG4fXr1wCAa9euISAgAKNGjVLYLyYmBufPnxfapqam2LJlC5o0aaI0JktLSzRq1AiNGjXC0KFDERMTI0p0aIoufqcFuX79OkxMTDBv3jylX644OjpixIgRaNmyJT799FPhj8WsrCzs3r0bX3/9tVrjqSoxMRHPnz8X9an6x21CQgLGjx8vWkiyUqVK+N///qfy+MuWLRMlx4cOHYqXL18qzFqWV61aNa0lwL/++mskJCSI+ubMmQNfX19Rn5GREd555x18+eWX+Oijj/DZZ5+JZsDNmzcPzZs3V6vEC1B6rxV9vn9Kkzlz5ojWcahQoQJ+++03tG7dWrSdqakpWrZsiZYtW2Lv3r345ptv8PbtW9EXEqrQxXnv2LGj8O+jR4+K/vju0KGDSusZ6DpmTYiKisL8+fO1dnx5ffr00UoiSf6LuOIk4pR9IZmUlKSxRJKTkxNMTU1FycWwsDC1ri1l60MoK3dSFPl1WORFR0fjwIEDOHDgALp06YKFCxfCwcFB7XEMQf6ZlIB6yW1tfdbT9P0I0P19u7h4T/qPtu9J+Y+Zn7ZjLQ3nRh/3QPnk9u3btyGTybS2GDsZDj6jR0TlVkhICDw9PZX+V69ePfj4+GDAgAFYvny5KLHt7OyMtWvXolevXiqN07t3b7VKKxgZGWHSpEno27ev0CeVSnHo0KFC9xsyZIiovWvXLpXH3Lt3r6gsQqtWrQqd0ZKYmIjVq1eL+n755ReliW159evXx+rVq2Fi8t/3qwEBAUofM717967wWCcAdOnSpcA/dpRxcnLCBx98oPL2qtLV77Qg06ZNK/KpAS8vL/j5+Yn65Mt+aFJxF5MMCgpC3759RftbWlpi9erVai2oePXqVVF71apV8PPzK/K/4i6+WpRbt24p1B+dMGGCQmJbnqenJ9atWyd6fyQnJyMgIKBYcZTGa0Xf75/S4Nq1awqzDb/77juFBIm8/v37Y9KkScUa0xDPuyHGbKjS0tIUyoep8/RXngoVKij0FVRqojjMzc0VZtWqO0M1MDBQoS8zM1Or5S5OnDiB3r174969e1obQ5/ka/WqU46gtH7Wk6eP+3Z5Zij3JED3sRrSucmjqXug/L3l7du3ePXqVYmOSWUDk9tERCqysrLClClTcPz4cbRv317r440ePVrUvnTpUqHb9+zZE/b29kI7NDRUYSaNMtnZ2di7d6+or6iFJHfu3Cmq19ujRw+1Vtdu3LgxPvroI6EdExMjmgWeR35WQo0aNVQeozRS93eqTO3atZXOclfmk08+ESVJo6Oj8ebNG7XHVIV8SRIAuHz5Mnbu3Cn6b8eOHVi3bh3mzp2Lzp07Y/z48aIZ366urti6dataf9iWRvJJ85o1a6pcGqFBgwYKX1bt27evyBky8krrtVJcmnj/lBbyi/f6+PiI7omFGTt2rE5r+RrieTfEmPVNWQ1+ZfWti6IsWaLuvaso8l94XL58Gbdu3VJp35cvX+LYsWNKX1M1qWNvb4+ePXti0aJF2LdvHy5cuIDbt2/j2rVr+Oeff/Drr7+iZ8+eonsqkLsOwpgxY4p8osgQyT+5pc6TRobyWc+Q7ttlgSHdk3Qdq77PjT7vgVZWVgpPYsnff6h8YlkSIiIVSaVSrFixAocPH8bkyZOLVQNXHe7u7rC2thZKNRRVU8zc3Bz9+vXDhg0bhL6dO3di0aJFhe4XFBQk+sbbyckJHTp0KHSfv/76S9QuajaqMt27d8fBgweFdkhICLp06SLaxtbWVtRWJVlfmqn7O1Vm4MCBKj96Z29vj9q1a+P+/ftCX2RkpFZqPiqbub148WKV9/fw8MDAgQPRr18/pR+2i6KtGdjFdebMGVF74MCBav3h4evriy1btgiz2ZKSknDjxg20atVK5WOU1muluDTx/ikNZDKZwpd5n376qcr7m5mZYcCAAVi6dKmGI1POEM+7rmNu0aIFwsPDtTqGtqWnpyv0mZqaqn0cZfe5guqxFtegQYPw+++/i2Zaz5w5Ezt37lRakztPRkYGZs6cWWDyRtk5yM/JyQlLly5Fly5dlP6cpqamsLKygouLC7p3746pU6fiiy++QGhoqLBNTEwMvvzyS2zfvr2oH9NgZGZmKnwZqs56GYbwWc/Q7tu8J/1HF/ckXceqr3NTWu6Bjo6OolKGZfELQ1Ifk9tEVG65urpixIgRBb6elpaG+Ph4hIeH49KlS8IfQ1FRUZg+fTpOnz6NxYsXK3wrrYqMjAxERkbi5cuXkEqlSElJUXi8DIDo2DExMcjJyYGRUcEP3QwePBgbN25ETk4OgNwagzNnzoSNjU2B+8gvJNm/f/9Cf6b4+Hg8ePBAaNvY2BRrlq18nWNlyYeGDRtCIpEICb7z589j2bJlmDhxYrFmKGiTtn6n8nx8fNSKy8XFRZSwlJ8hpSnKZm6rysvLC7NmzdJKvUZ9iIyMVKi1/eGHH6p1DBcXF9SrV09UR/TatWtqJbdL67WijK7eP6VBVFSU6PowNjZW+2mgjh07aiRJYojn3RBjNgTKFpDOX9daVcpKexS2OHVxVK5cGb6+vvD39xf6IiIiMGzYMPz4449KS2I9f/4cs2fPLnSh6aLqzLq5ucHNzU3lOGvWrIkdO3Zg+PDhuHbtmtB/5coVBAUF6aSUhi6kpKSIyooA6pVIMITPeqXpvl1eGNI9Sdex6uvclJZ7oPy9On+im8ovJreJqNxycnIqsvxGnrdv32L9+vVYv369kDg+fPgwTE1N8f3336t0jISEBPzxxx84evQowsLCRDWuVSGTyfD27dtCZyXVqFED7dq1ExaHTElJwR9//FHgzOqnT5+KFvExNjYusj7vrVu3RH/E2NjYKCTIVZF3HvPkLTCZX8WKFdGlSxccP35c6Pvtt9+wZ88edO/eHe3atYO3tzesrKzUHl8TdPE7lefs7KzWGPLnRhsfANPS0vDo0aNi73/v3j2MGjUKy5cvV6u8TWklP1vKzs6uWI8jN2jQQJTcVncWVmm8VvLTx/unNJCvN1m7dm21a2W6ubnB0tJS6aPJRTHE826IMRsaZYnd4tSgVjbrT9MLtwHA559/jpCQENGMwHv37qFv375o3rw5mjZtCgcHByQlJSE0NBTnz58Xfh6JRIK2bduKnrCRSCRaWXTUzMwMy5cvx4cffih6v+7YsaPMJLeV/c7VeQKrtH/WA/R/3y6PDOmepOtYDencaOMeKJ+A1/RMfDJMTG4TEanAxsYGX3zxBSpXriwq87F//358+OGHaNeuXaH779u3D0uWLFGYzakuqVRa5B/nQ4YMEZLbQG6NwIKS27t37xYlqtu3b4+qVasWenz5R09fvHihkRXZExMTlfZ/8803uH37tqieWmxsLLZu3YqtW7fCxMQEHh4e8Pb2RvPmzdGyZUtR7XFt0eXvND/5x3eLYmxsLGrLf6mgCeHh4QozJw8dOqQwey4zMxNxcXG4efMmtm7dipCQEOG1rKwszJ49Gz4+Pmr/jKWN/LVc3Pqh8vsV9B4pSGm8VvLo6/1TGsj/zNWrV1f7GEZGRqhWrZrCIm5FMcTzbogxG6IKFSrA2NhYdC8vTl1aZUkGbSQlzczMsG7dOkycOBHXr18X+rOzs3Hx4sVCZ2h/9dVXAMTlo6ytrbU2s9/JyQkDBgwQLQx8+fJlZGRklJqZyZomP5O7KKX1s14efd63yytDuifpOlZDOjeA5u+B6t5fqHzgs3lERGrw9fWFh4eHqG/9+vWF7rN69WrMnj27xH+YA6olm9577z24uroK7QcPHuDy5csK22VkZGD//v2iPlVmsqubYFNVQR/KHB0dsXfv3gLLOmRlZeHOnTvYtm0bpk6divfeew/jx48XJU41Tde/0/xUraGsS/L1tk1NTeHu7q6wnampKapUqYIuXbpg69atGDRokOj1hISEYj0FUNrIl/Mo7h8K8uWE1H3vlcZrBdDv+6c0ePv2rahd3NmihZWbUsYQz7shxmzI5K+p4iwqq+wpLHWvVVVVrFgRmzdvxrhx41SaRevo6Ih169Zh5MiRCotHVqtWTSsx5pGfoZiamioqA2XIlM3SLqp+ubzS+FkvP33dt8s7Q7on6TpWQzo3gGbvgfL3F3WfoqCyiTO3iYjUIJFI8OGHH4r+Z3zlyhUkJCQonUFy+fJlrFixQtRnZmaGzp07o0WLFvD09ESVKlVgY2MDc3NzhcVAOnTooPYK0BKJBJ9++qmoXMrOnTvRvHlz0XYnTpxAXFyc0K5Zsybee++9Io9fnJpuJVWpUiWsWLEC4eHhOHDgAIKDgxEVFaV028zMTAQFBSEoKAhdu3bFokWLNPqosT5+p6WdfL1tDw8PlRa2+frrr3H+/Hk8ffpU6NuzZw/Gjh1bahOzVDJ8/+iHIZ53Q4o5Ojoap06d0slYQG55A22sUeDm5iaaBf3ixQu1j5F/gWogd8aeNstJmJub44svvsCwYcPw999/49y5c4iIiEBcXByysrLg5OSE2rVro1u3bujSpYvwyL38z9agQQOtxQgA77zzjkJfbGysVsfUFSsrK1HNbADFKr1Rmj7rGTrek/6jq3uSrmM1pHMDaPYeKH9/4XufACa3iYjUVqdOHVFbJpPh7t27Shd6W7Zsmajt5eWFNWvWqFwLV35mkar69u2LZcuWCf/zz0tkV6xYUdhm165don0GDhyoUkJR/rHuRo0aYe/evcWKU12enp6YNWsWZs2ahZiYGFy5cgXXrl3D1atXcffuXYXH1P7++2/ExcUhICBAoeRCcenrd1qayc/crlu3rkr7mZubY+TIkViwYIHQ9+zZM1y9ehXNmjXTaIy6JF8OpLi/c/mZYmWhpALfP4qzoopb21z++iiMIZ53Q4o5KipKI+W5VNWnTx+dJJLyf/GoqmfPnonatWvXLnFcqqhcuTKGDh2KoUOHqrS9/BoG2k5uK7t/63LRXm0yMTGBo6MjYmJihL6YmBiVPwvIKw2f9eTp475dErwn/UdX9yRdx2pI5wbQ7D1Qfsa5tp+8IcPAsiRERGpS9u1w/hnQeWJjY0UrQxsbG2PlypUq/2GelZVV7A/BNjY2+Oijj4R2ZmYm9u3bJ7QfPnwoKlViZmaGvn37qnTs/AlyQLEOoa44OTmhe/fumDNnDg4ePIhz585hzpw5Cuc3JCQEBw4c0MiY+vydllZZWVkKjxXWq1dP5f179eqlUG/v77//1khs+iL/FEdxZ4/K/9Fh6Mltvn9yyV8fxZltlZOTg5cvX6q0rSGed0OMuSyQn1mXf7FGVd24cUPUVlaiSt9SU1Px8OFDUV/Tpk21Oqay67EslaiQf2/mT3SXhD4+6ymj6/s25TKke5KuYzWkcwNo7h6YnJys8OW1uguoU9nE5DYRkZqUzdZQVoLh/v37ohqf7777LmrWrKnyOHfu3FFYpE8dQ4YMEbV3794txCM/a/vDDz9USFoXRH4mzvPnz0tFEqFy5crw9fXFkSNH0KhRI9Frhw8f1sgY+v6dlkaRkZEKte/Uma1lbW2tUA7n5MmTGolNX+Tr8ickJBRrRs3t27dFbU9PzxLFpW98/+SSX2g1MjJS7YWgHj16pPJj/4Z43g0x5rJAfublmzdv8PjxY5X3T01Nxb1790R9yp5q07dTp06J/r/l5eWl8L7UNGXlNVT93GUI5J9qVOe6UYcuPuspo+v7NuUypHuSrmM1pHMDaO4e+OTJE1Hb1tYWVatWLW5YVIawLAkRkZqULX5RuXJlhT752dzqPjIVFBSkXmByPD090bx5c2GG9rNnz3D27Fn4+Pjgjz/+EG2rykKSeVxcXODi4iIk67Kzs3HmzBn06NGjRPFqiqWlJSZPnowxY8YIfZpatEnfv9PSSL4kiZGRkdpJ2A4dOohqQ7569QphYWGoX7++RmLUtdq1a8Pe3l70VMM///yDzz77TOVjPHv2TOHcent7aypEveD7J5erq6vo+sjOzkZwcDC6deum8jECAwNV3lZf512+PIA6Czoa2rXSokULhTIXhqh+/fqoVq2aaHbp0aNHMWHCBJX2P3HihGhdDnNzc7Rp00bjcZaUfCm1AQMGaH3M06dPi9qmpqY6K9miCw0aNMCePXuEtrYXy1T3s15J7keA7u/bJcV7Ui5d3pN0HashnRtAc/dAXZeUIsPBmdtERGqQyWQ4fvy4qM/U1FRhpmZef37q1BVLTk5WmF1dHPKzt3fu3IkjR46IZlp7eHio/Tiu/Gr269evV6iBqE81atQQtTU1U6Y0/E5LG/nFJGvWrKn2YjTt27dXqPeuy4WQtKFdu3ai9q5du9RajHXbtm2i95SdnR2aNGmisfj0ge+fXBKJROH62LFjh8r7Z2RkqLXOgb7Ou/x9QJ0nfHit6E+nTp1E7X379iErK0ulffMnNwGgdevWwgKOpcXJkydx4cIFoe3g4IBevXppdcykpCTs3LlT1NekSZMytQha48aNRW35zwbaoM5nvZLcjwDd37fpP4Z0T9J1rIZybjR5D5SfbS5/76Hyi8ltIiI1bN68GQ8ePBD1tWrVSun/nOUfkbp69arKH6YXLlyotI63ujp37gwnJyehfebMGWzYsEG0zaBBg9Q+7siRI0UfgO7evYulS5cWP9ACqPoBTV5kZKSo7ejoqIlwSsXvtLSRn12sTr3tPI6OjgozLww9uS2/qFlUVBTWrVun0r537tzB1q1bRX39+vVDhQoVNBafPvD985+BAweK2iEhIfjzzz9V2nfdunUKj+UWRl/nXf6JpoiICJX35bWiP8OHDxd9ufDs2TNs3LixyP3++usvXLlyRdSXf1ZtQS5dugRPT0/Rf9qqnRwREaGwyN7MmTNVqvta3C/ws7Oz8dVXXyExMVHUr+o6J4bC09NT9FkrJiZG5fuULj7rleR+lEeX9236j67vSUDx70u6jlWX45WWe2D+NaMAoG3btsU6DpU9TG4TEang7du3+Pnnn/Hjjz+K+iUSCSZPnqx0n3r16omS3lKpFAsWLCj0UcisrCzMnz8fhw4d0kjcJiYmog/j2dnZoppnlpaW+Pjjj9U+bqVKlTBu3DhR3/r16zFv3jykpaWpfJz09HQcPHgQffr0UZqMWLp0KaZPn46bN2+qfMy4uDj8+uuvor4WLVqovH9hSsPvtLSRn0GhTr3t/D744ANR+86dO3j16lWx49K3Ro0aKdQSX7lypcJMGXkPHjzA2LFjRX/s29jYYPjw4VqJU5f4/vlP06ZN4ePjI+qbM2eOaEapMvv27cOqVavUGktf513+i64//vhD6ZoVBe3La0U/XFxc8Mknn4j6Vq1aheDg4AL3uXXrFhYuXCjqe//997W6SOPr16+LfL/kd+HCBQwfPhxv3rwR+tq0aYPevXurtP+iRYvw888/4/Xr1yqPGRcXh/HjxyuUyfHw8CjWZ6/STCKRKCSZLl26pNK+uvisV5L7UR5d3rfpP4ZyTwJ0H6suxysN98C3b9+Kngqxs7PDu+++q/ZxqGxizW0iKrdiYmIUHpHKLz09HfHx8bh37x4uXryoNGk7btw4hQVt8piYmKBfv34ICAgQ+v7880+8fPkS48aNg4+PjzAT8/Xr1zh9+jQ2bNiAR48eAcit7yeVStX6EKHMwIEDsXbtWqUlET766KNiPxY7btw43LlzR1SmZdeuXTh58iQGDhyItm3bol69eqLZplKpFBEREbh79y7OnTuHc+fOFfoYaVZWFo4cOYIjR47AxcUFnTt3RtOmTVG3bl1Uq1YNRka539FmZ2fj8ePHCA4OxqZNmxATEyMcw9jYGJ9++mmxfkZ5peV3Wlo8ffpUoVxAcWZuA7nJ7RUrVoj6AgMDFUrrGJLvv/8evXr1Emp0ymQyfPPNNzh16hR8fX3RvHlzmJmZQSaTITIyEocOHcKmTZuQkZEhOs78+fNRpUoVPfwEmsX3j9h3332HXr16Cf9vSUtLw8iRI9G/f38MHDgQdevWhZGRETIzM3Ht2jVs27YNJ06cAJC7gFKlSpWEc1MYfZ33du3awdjYWFjYMSoqCt26dUPHjh1Rq1YthScRGjRogIYNG+o1Zso1ZcoUBAYGCucvPT0dfn5+GDJkCD799FPUqlULEokEL168wL59+7Bp0ybR/8stLS0xc+ZMrcb45s0bjBgxAq6urujYsSNat26NunXrolKlSgBy77dxcXG4cOECjhw5opBcqVmzJn7++WeVx0tOTsbWrVuxceNGNG/eHB06dED9+vXh4eEBW1tbYbu0tDTcvn0bgYGB2LNnj0IC1cbGBkuWLBE+vxQlNDRUYXHhPDdu3FDoK+xzbUk+86miW7duotmtZ86cQf/+/YvcTxef9UpyP8pPV/dtEjOEe5K+YtXVePq6B+Z37tw50ZfcXbp0UainT+UXk9tEVG5FRUUpPJ6qKolEgjFjxmDatGmFbjd+/HicPHkSz58/F/quXLmCK1euwMjICLa2tkhNTUV6erpoP2trayxfvhwTJ04sVnz5OTo6okuXLvjrr78UXlNnIUl5EokEP/74IyQSCf7++2+hPzY2FmvWrMGaNWsA5H5oMjMzg1QqVavmsLynT59i48aNwuN2EokE1tbWMDY2LvTYU6dOVfoHSnGVht9paaGspmZxk9v16tVD1apVRbO1T506ZdDJ7SpVqmD16tWYMGGC6EuAoKAgBAUFQSKRwNbWFlKptMDHsidNmoSePXvqKmSt4/vnP7Vq1cLPP/+Mzz//XPj95+TkYPfu3di9ezeMjY1hbW2NpKQk0ePAEokE3377LbZv365ykkQf571q1aro06cP9u3bJ/QV9qXypEmTRPdqXiv6U6lSJaxcuRIjR44UkiBZWVnYvHkzNm/eDDMzMxgZGSn90t/Y2Bg//fQT3N3ddRJrVFQU/P394e/vDyC3XruVlRWSk5MLvK+6u7vD398fFStWVHu87OxsXLx4ERcvXhT6TExMYG1tjYyMjEK/sLe1tcXq1avh5eWl8njBwcFqzfot7HNt27ZttZrcbtOmDRwdHYUk29mzZ5GWlqZWSS1tfdYr6f0ojy7v2/QfQ7on6TpWXY+n63tgfnlfFOUpa0/AUMmwLAkRkZreffddbN++HdOnTy9yWwcHB/z+++9wdnZWeC0nJwcJCQkKf5g7Ojpi06ZNxf4fvzLKEoTvvvtusUtI5LGwsMDy5csxa9asAv9gSklJQUJCQqGJ7dq1a8Pc3FyhX36RwfxkMhnevn1b4LEtLS0xb948hfIpJVVafqelgXy97SpVqhQrWZCnffv2onZISAikUmmxj1caNGvWDNu3b1e6IrxMJkNiYqLSBIyVlRW+++67AsseGSq+f8Q6d+6M5cuXK635m52djcTERFGCxNTUFN9//z26du2q1jj6Ou9z5sxBly5dirUvrxX9atKkCTZv3qxQ/xzIXRxPWaLEzs4Oa9asQefOnXURolKZmZlISEhQel+VSCT45JNPsHfvXlSrVk1jY2ZlZSEhIaHQpE7Lli1x+PBhhbIWZYmxsbFocc7U1NRCyyPk0dVnvZLcj/LT1X2bxAzpnqTrWPV9bnRxD5S/n9SsWRPNmjUr1rGobGJym4ioAKampnBwcICrqyu6dOmCL774AkePHsXu3bvVqtlWp04dHDhwAMOGDSt0FWp7e3uMGjUKR48eLbDUSXEpW5G6JLO25Y0YMQJBQUGYOnUq6tSpU+T2EokEXl5eGDlyJPbs2YNjx44prGQPAF9++SX8/f3h6+sLLy8vlR49q1KlCkaOHIm///5bY+VI5JWG32lpID9zu6RflnTo0EHUzsjIwNmzZ0t0zNLAw8MDR44cwcKFC4tMujk6OmLYsGE4efKkSo9zGyK+f8Q6deqEo0ePok+fPgWeDyMjI3zwwQc4cOBAsRdh0sd5t7CwwMqVK7Fr1y4MGzYM3t7eqFy5ssozOXmt6FejRo3w119/YcKECYV+cWltbQ1fX18cO3ZM4UtKbalRowb8/PzQsGFDmJgU/jCypaUlevXqhQMHDuD7779X+nmjKCNGjICfnx98fHxU3t/e3h49e/bEzp07sXnzZo0m1EuroUOHij6r5Z8pXRBdfdYr6f0oP13dt0msNN+T5Ok6Vm2Pp+974LFjx0TJc19f30K/GKPyRyIr7rKnRESktvT0dFy/fh2RkZFISkqCkZERKlasiDp16qBBgwZaqxt25swZ0SrY9vb2OHPmjNLZ0poQGxuL0NBQxMbGIj4+HllZWbC0tISdnR1cXV3h7u5erEdj82p2P336FG/evEFqaqrwyKqjoyM8PT1Rs2ZNnX7Y0dfvlAxXTEwMbt26hTdv3iAhIQGWlpaoWLEi3N3d4eXlVa4+rPP9I5aamoqQkBC8fPkS8fHxsLCwQI0aNeDt7V2ipyLkGeJ5N8SYy5Ls7GyEhYUhPDwccXFxkMlksLe3xzvvvINGjRrBzMxMb7GlpqYiPDwcjx8/RlxcHFJSUmBqaopKlSrB3d0d9evXh6mpqcbGk8lkePr0KZ48eYLo6GgkJiYiLS0NJiYmsLOzg52dHTw8PODm5lau7ud5pk2bhqNHjwLITfD+888/Sp/AKEhp/KxXGF3dt0msNN+T5Ok6Vm2Pp4974KBBg3D9+nUAuXW7g4ODtVpmiQwPk9tEROXAxIkTERgYKLQ/++wznS2sQkRERETlw71799C7d2+hNMfIkSMxY8YMPUdFRIYqNDQU/fr1E9p+fn6YMmWKHiOi0ohlSYiIyrhnz56JapRJJBKNliQhIiIiIgIALy8vUX3p3bt3ixZVJiJSx/r164V/29vb47PPPtNjNFRaMblNRFTGrV69GtnZ2UK7Xbt2qFWrlh4jIiIiIqKyaurUqUIpGKlUim3btuk5IiIyRBERETh58qTQHjNmjNLFXImY3CYiKsOOHz+OgwcPivrGjh2rp2iIiIiIqKxzc3ODr6+v0N64cSPi4+P1GBERGaJff/0VOTk5AABXV1cMGzZMzxFRacWa20REZURoaChu374NAIiLi8ONGzdw5swZ0TYffPAB1q5dq4/wiIiIiKicSE5ORteuXfH69WsAwIgRIzBr1iw9R0VEhuLmzZsYMGCA0N6wYQPatm2rx4ioNGNym4iojFi5ciVWrVpV4Os2Njb4888/Ua1aNR1GRURERERERESkHSxLQkRUDtjZ2WHt2rVMbBMRERERERFRmWGi7wCIiEg7LC0tUatWLbRr1w5Dhw6Fo6OjvkMiIiIiIiIiItIYliUhIiIiIiIiIiIiIoPDsiREREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcFhcpuIiIiIiIiIiIiIDA6T20RERERERERERERkcJjcJiIiIiIiIiIiIiKDw+Q2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcFhcpuIiIiIiIiIiIiIDA6T20RERERERERERERkcJjcJiIiIiIiIiIiIiKDw+Q2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoNjou8AiIiIiMqrtLQ03L17F0+fPkVcXBxSU1NhamoKOzs72NnZwcPDA7Vq1YJEIlH5mAcOHMCsWbOEdp8+ffDDDz9oI3wqxzw9PUXt8PBwPUVChmjmzJk4ePCg0F68eDH69u1b4Pa8rxEREVFBmNwmIiIi0qGkpCQcPHgQx48fx82bN5GVlVXo9ra2tmjatCk++ugjdOzYERUqVNBRpERERKSO5ORkhIWFITQ0FLdu3cLt27fx/Plz0TaTJk3C5MmT9RRhrpycHDx8+FCIMzQ0FPfv30dmZqawjbOzM06dOqWTeObOnYvdu3cr9G/ZsgUtWrTQSQxEZLiY3CYiIiLSgbS0NKxbtw6bNm1CSkqKyvslJSUhKCgIQUFBsLKywogRIzBy5EhYW1trMVoiIiqtLl26hJCQEKHt4+PDBKAenTlzBseOHcOtW7cQGRmJnJwcfYekVHR0NAICAhAaGoqwsDC1Poto09WrV7Fnzx59h0FEBozJbSIiIiItu3//PqZMmYJHjx4Vup2FhQXMzc0hlUpFs6fySKVSrF69Gjt37sT+/ftRvXp1bYVMRESlVEhICFatWiW0J02axOS2Hh09elRUZqe0ioqKwsaNG/UdhkhmZibmzp0LmUym71CIyIAxuU1ERESkRSEhIRg3bpzCDCkjIyO0a9cO77//Plq1aoWqVavCwsICACCTyfDy5UvcunULZ86cwYkTJ/D27Vth37i4OCQmJjK5TURERAZr/fr1ePjwob7DICIDx+Q2ERERkZbcvXtXaWK7TZs2mDFjhsKifHkkEgmqV6+O6tWro2vXrpg9ezZ27NiB33//XZTkJtIXLiBJutS3b99CF5wkKk1cXFzQsGFDNGrUCA0bNsT06dPx6tUrfYelwNbWFvXr1xfivHDhArZv366z8aOiorB27Vqh3blzZ5w8eVJn4xNR2cHkNhEREZEWJCcnw8/PTyGxPXLkSMyYMUOtY1lZWWHMmDHo06cPZs6cibNnz2oyVCIiIiqmxo0bo2bNmmjYsCEaNmwIe3t70evGxsb6CUyOg4MDhg0bJsTp6uoKiUQivH7v3j2dxjN37lykp6cDAKpUqYLJkyczuU1ExcLkNhEREZEWLF26FM+fPxf1FSexnV/lypWxfv16LFu2TPQHKREREenH4MGD9R2CSjw8PDB79mx9hwEAOHDgAC5duiS0v/76a1hZWekxIiIyZExuExEREWnY48ePsWfPHlGfh4cHpk2bVuJjSyQSTJs2DTk5OSU+FhEREZEuxcXF4ccffxTa77//Prp27Ypnz57pMSoiMmRMbhMRERFp2JYtW5CVlSXqmzdvHszMzDQ2hpGRUbH3TUxMxNWrV/HkyROkpqbC1tYWVatWRfPmzWFra1vi2OLi4vDw4UM8fvwYb9++RXp6OmxsbGBrawsPDw94eHiUKP7CZGRk4Pr163j48CGSkpJgaWmJSpUqwdvbW2MLcEqlUly+fBmvXr1CfHw8LCwsULNmTTRp0gQODg4aGUOZZ8+e4e7du4iNjUVCQgKsrKxQqVIleHl5oXbt2lobVxdkMhnu3r2LO3fuIDY2FsbGxqhYsSLq1q0LLy8vvT6pIJPJEBoaisjISLx+/RoA4OjoiPr166NOnTpaHz8pKQnXr1/H06dP8fbtW5iYmKBWrVro0qVLoftJpVJERETg0aNHiI+PR0pKCiwtLWFnZyfUBDY3N9dYnJmZmbh69SqePXuGN2/ewMzMDNWrV0eTJk1QpUoVjY1TUhkZGbhx4wZevnyJ+Ph4ZGRkoGLFiqhatSqaNm0qLOyrSaX5+ibStR9++AEJCQkAAHNzc8ydO1e/ARGRwWNym4iIiEiDsrKy8Oeff4r66tSpg2bNmukpov88evQIy5Ytwz///KOQfAdy64J26NABX3zxhVrJ0uzsbISEhOD48eO4ePEiHj16VOj2NjY26N69O0aPHo2aNWuqPM6zZ8/QsWNHoe3s7IxTp04BAN6+fYs1a9Zgz549SE5OVrp//fr18cUXX+C9995Tecz8nj59iqVLl+LUqVNCndD8jI2N0b59e0ybNk1Ievr6+iIkJETYZsuWLWjRooXKYyYnJyMgIAB//vknoqKiCtyuRo0aGDhwIIYNG4YKFSqo/kMVk/xiqEUtMNmhQwdRmZ7AwEDUqFEDOTk52LlzJ/z9/RXK+OSpUqUKxo0bh4EDB8LERHd/vmRkZGDTpk3YsWNHgYvBubm5Yfz48ejduzeA3EftZ82aJbzep08f/PDDDwWOUdj2oaGhWL16Nc6cOYPs7GzRfs7OzkqT2+Hh4Th27Bj+/fdf3L59W2G//ExNTdGmTRuMHj0azZs3L3C7oiQnJ2PFihU4dOiQkLCS5+Pjg6lTpxb7PqjueVXm8uXL8Pf3x8WLF5Gamqp0GzMzM7Rp0waTJk1CgwYNVD62Lq7vlStXYtWqVUpfW7VqVYGvAbnnf+vWrSr+NETac+HCBRw6dEhojx8/Hi4uLnqMiIjKAu1MmSEiIiIqp65evYrExERRX79+/fQUzX/++OMPfPzxx/j777+VJraB3CT1yZMn0bdvX5w+fVrlYw8ePBgjRozAzp07i0xsA7mJ6N27d6Nbt24aSbjcuXMHH330ETZu3FhgYhsAwsLCMGrUqEKTQAXZu3cvevbsiWPHjilNbAO55y8wMBB9+vTB/v371R5D3h9//IGOHTti5cqVhSa2gdzE/9KlS9G1a1fcvn27xGPrQnx8PIYNG4aFCxcWmPgDgOjoaCxcuBATJ05EWlqaTmJ78uQJevfujV9++aXAxDaQ+4XRjBkzMHHixAITpsWxevVqDBgwAEFBQYUmqPP7+eef0atXL/z222+4efNmkftlZmYiODgYQ4cOxcyZMwu8rgtz48YNdO/eHZs3by4wsQ0AISEhGDp0KFavXq32GCUVFxeHsWPHYujQoQgKCir095SRkYGgoCD069cPCxcuVPncK1Oar28ifUhPT8e8efOEtpubG0aPHq3HiIiorGBym4iIiEiDLl++rNBXklmRmnDw4EGF5JWRkRHs7OxgamqqsH1qair8/Pzw4MEDlY6flJSktN/IyAi2trawtbVVWoYkKysL3333XYkSXvfu3cPw4cPx8uVLUb+NjU2BM5hXrlyJvXv3qjzGrl278M033yhNPBkbG8POzk5UViAzMxOzZ8/GsWPHVB4jP5lMhl9//RUzZsxQmjA0NjaGvb290t/dy5cv4evriwsXLhRrbF1JTk7GZ599pvB+sbCwgLW1tdJ9Tp8+jTlz5mg9tidPnsDX1xcRERFKX7exsVE494GBgZg2bRpkMlmJx1+1ahVWrFghqqsvkUhgZ2cHY2PjAvcr6H0IAJaWlgVeM0DuPWLChAlq1fK/efMmRo0ahejoaIXX8uLN/76XyWRYsWIFNm7cqPIYJRUZGYkBAwYU+GWdpaWl0lJMMpkM27dvh5+fX4FfBhamNF/fRPqyevVqPH78WGhrulwbEZVfLEtCREREpEF3794Vtc3MzODh4aGnaID79+/jr7/+gkwmg4WFBT799FP06NEDdevWhZGREWQyGcLCwrBp0yYcOXJE2C8zMxPz5s3Djh07VB6rfv36aN++PZo0aQIPDw84OTkJSd+srCw8fPgQQUFB2L59u1C7GMhN5jVv3hw+Pj5q/WxpaWmYPHkykpKSIJFI0LVrVwwYMABNmzYVagk/ffoUBw8exIYNG0TJ/R9++AGdO3eGvb19oWOEhoZi4cKFoqSliYkJhgwZgj59+sDT0xNGRkbIysrCzZs3sXfvXvzxxx+QyWT45ptvULlyZbV+JgDw9/fH2rVrRX2urq4YMmQI3nvvPbi5uQnn9enTpzh58iT8/f3x5s0bAEBKSgo+//xzHD58uFTVOs5v/vz5wnulYcOGGDlyJFq3bi38PhITE3Hy5EksW7ZMdK38+eef+OSTT9CqVSutxJWVlYXPP/9cYbZ206ZNhRgtLS0BAM+fP8eJEyewdu1aJCQkICgoCHFxcSUa/9atW8Ij+2ZmZsL7tX79+jA2NkZ2djYeP36M8+fPF3gMZ2dntG/fHi1btoSHhwdcXFxESfGnT5/i4sWL2LlzJ8LCwoT+8+fPY+3atZg4cWKRcSYlJcHPz0/hSYmuXbtiyJAhaNKkCUxNTZGdnY2wsDDs3r0b+/fvh0wmwy+//KKTe2J8fDxGjhwp+uLLxMQE3bt3R+/evdG4cWMh0Zyeno6rV69i27ZtCAwMFLYPCgrCsmXL8OWXX6o1tjau7/bt2wv3k+DgYAQHB4tea9++fYHxODk5qRV/UaKjo4WSULrg5uaGli1b6mw80rz79++Lvtj66KOPtHYfJ6Lyh8ltIiIiIg168uSJqF27du0CZ0vqQl7yqlatWli3bh1cXV1Fr0skEjRo0ABLly6Fq6urqGTH1atXce/ePXh5eRU6Ru/evdGxY8dCF9czMTGBl5cXvLy84Ovriy+//BJBQUEAgJycHKxcuVLtEiWxsbGIjY2FpaUlfvnlF3zwwQcK27i4uGDKlClo1qwZRo8eLZQZSE5OxqFDhzB8+PACj5+dnY2vv/5aVJrA1tYW/v7+aNSokcLP17RpUzRt2hRdunTBlClT8PbtW7x9+1atn+n69ev49ddfRX0jRozA9OnTlc5wc3FxwciRI9G7d2/4+fnh2rVrAICEhATMnTsXv//+u1rj68r169cBAH5+fpgyZYrC63Z2dujXrx/atGmDQYMGiZLN27Zt01pSZNOmTaKEL5BbE/bzzz9XWPTP2dkZn332GT7++GN89tlnuHfvHm7evFmi8fNmizs5OcHf318hCWxsbIzatWsrrYnv7e2NLl26FFlT3sXFBS4uLvjkk0+wZs0arFy5Unhtw4YNGDZsWIGzi/P88MMPoqSskZERFi9eLNQezx9vo0aN0KhRI3Tp0gWTJk1CRkaGwjnWhpkzZ4oS287Ozli+fDkaNmyosK25uTlat26N1q1b448//sDs2bOFGdsbNmxAly5dFN7zhdHG9d2wYUMh9jdv3oiS2w0aNMDgwYNVjq+koqKiMH/+fJ2N16dPHya3DZhMJsPcuXORmZkJIPfpl5kzZ+o5KiIqS1iWhIiIiEiDYmJiRG07Ozs9RfIfa2trbNiwQSGxLc/Pz09hoUBVSmuMHz++0MS2snhWrFgBNzc3oS8kJETlMijyvv/+e6WJ7fxat26NQYMGifr+/vvvQvcJDg7G/fv3RX3Lly8vMsnVoUMHUV1Rdfz000+iMgjDhg3DrFmzinx0u2LFivjtt9/g7Ows9CmLvzT59NNPlSb+8qtWrZpoIUEg9+cqTn3oomRmZiIgIEDU99FHH2HatGkKie38KlasCH9//yKfAlCViYkJ1q1bp/bs5t69e6u1WKqRkREmTZqEvn37Cn1SqVS02JsyL1++xB9//CHqmzp1qkJiW167du3w7bffqhxfSfz777+i5K+9vT0CAgKUJrbl9e7dWzRTWyaTYcOGDWrHUNqubyJ92blzp/CFDwBMmzatWE81EREVhMltIiIiIg1KSUkRtZXVc9W1sWPHombNmkVuZ2RkhP79+4v6tDXD0szMDMOGDRP1Xbp0Se3jvPfee+jWrZtK2w4cOFDUvnfvXqE1hvfs2SNqd+3aFa1bt1ZprH79+qFBgwYqbZvn2rVrwsxrIHemqTrlEOzt7TFp0iRRn/zPUFrY29vjf//7n0rbdu7cGZUqVRLaWVlZuHfvnsZjCgwMFEq7ALn1kb/++muV9q1cuTImT56skTgGDRqEunXrauRYqpBf0K2o9+HevXtFTzO4urpi1KhRKo3Vu3dvNG3aVP0g1SSfjJ42bZpK98A8vr6+cHFxEdonT55Uq+RMaby+ifQhOjoav/zyi9DW9VMGRFQ+sCwJERERkQblPXabx8LCQk+R5DIyMsKAAQNU3t7b21vUjoyM1HRIgnfffVfUvnHjBoYOHarWMdT5I9nDwwPW1tZCneCUlBS8fPlSNNs5T1ZWFi5evCjqk0+OF0YikWDgwIG4ffu2yvv89ddfCuPl1Q5XVZcuXfDNN98Is79DQkLU2l9XevXqJdSuLkpeaYu8MjZA7nXZuHFjjcZ07tw5UbtTp06oWLGiyvv37t0bS5YsUbrwqDrUeb9qgru7u+h9cePGjUK3l6+13L9/f7VKLw0ZMgRXr15VO05VxcXF4d9//xXaNjY26NOnj1rHMDExQdeuXbF+/XoAuaWTrl69is6dO6u0f2m8vjWpRYsWCA8P13cYZAAWLVoklOcyNjbGggULlC4wTURUEkxuExEREWmQqakpMjIyhHZqaqoeowHq1KkDBwcHlbfPP1sRgNo1o/Pv9+DBA8TFxSE5ORlpaWmiRRmB3LrQ+ckv4qeKZs2aqbytRCJBjRo1RLMiC/r57t27J0pSmpubq73g5fvvv6/W9vKJaHX3B3JLvtSqVUuo3fzgwQNIpVJYWVmpfSxtUvdcyl+XSUlJmgwHABTqZat7/q2trdGkSRNcuHCh2DHY29srlAYqiYyMDERGRuLly5eQSqVISUkRzbrOY2Ly35+FMTExyMnJUZqASk1NVSgf1LFjR7Vi+uCDD2BkZFToUxMlceXKFdG9xsfHR+0viQCgXr16ovb169dVTm6XxuubSNdOnTqF48ePC+1PP/1U7SeaiIhUweQ2ERERkQZZWlqKktvFTQ5rirJZyYWRT4LmzeZUxaNHj3DgwAEcP34cjx8/VmtcQP2EjrW1tdp1jlX9+eRnrHt4eIgSgKqoWrUqHBwcEB8fX+S2KSkpCknDkJCQImfRKpP/+svJyUFsbGypS27r8rpU1aNHj0Rt+eSmKurWrVui5La6dbaVSUhIwB9//IGjR48iLCxMVMNdFTKZDG/fvlW6XsCDBw9Ex7O0tCyylr88S0tLuLm5CV/AaJr8eyY1NRU7d+5U+zjy8eVfQLMopfH6JtIlqVSKhQsXCm1HR0d8/vnn+guIiMo0JreJiIiINMjJyUk0IzkxMVF/wUD9mt/GxsaitiqzKzMyMrB06VJs27ZN7URaflKpVK3ti1PPXP7nUzaLFVBMtDs6Oqo9Vt5+qiS3Y2NjFWa2f//998UaU15CQoJa9YZ1wcbGRq3ti3NdqkMqlSqUFCrO77y410kedZ6yUGbfvn1YsmSJwlMR6pJKpUqT2/LHrV69eqGLbRbE2dlZa8nt2NhYUfvff/8VlSkpLnXu5aXt+iZFkZGRaq3z0KJFC9SuXVuLEZUty5cvx8uXL4X2rFmzYG1trceIiKgsY3KbiIiISINcXFxw//59oR0ZGYnMzEy1atJqUnEST+rIyMiAn58fzpw5U+JjySd3i6LNn01+xn1xZz6rup82vwQpaQ1obdD2dakuZTNli/M7L2nyRtU6zcqsXr0aK1asKNH4eQpKrsq/L4r786qb/FWHtt5L6pSYKm3XNym6ceMG5s+fr/L2ixcvZnJbRaGhodi2bZvQbt26NXr06KHHiIiorGNym4iIiEiD6tWrh8DAQKGdnp6OBw8eFKvEgSFYt26dQmLbwcEBPXr0QNOmTVGrVi1UqVIFlpaWMDc3F81QfPbsmdr1enXFzMxM1Jaf1asqVfcr7vFVoe6XBuWRsi+fMjMz1S5Fo83fY2EuX76skNg2MzND586d0aJFC3h6eqJKlSqwsbGBubm5ws/boUMHPH/+XJcha42+fgflSXR0tMLCotrk5uaGli1b6mw8KpnVq1cLT0WZmZlh3rx5eo6IiMo6JreJiIiINEjZAochISFlMrktlUqxfv16UV/Pnj3x3XffwcLCosj9U1JStBVaicmXPCluDVxV91NWAuLmzZuoUKFCscYl9SgrcfP27VuVrmP5ffRh2bJloraXlxfWrFmjcu1nVUsCyc+4Lu77QpvnSf69NHr0aPzvf//T2njlUVRUlFqznkuqT58+TG4bkPz3k4yMDHz44YfFPtawYcNEbWdnZ51+sUJEhoHJbSIiIiINatq0Kezs7ESPxu/fvx8jRozQX1BacvbsWVHJC1dXVyxevFhh1nNBVKlFrS+VK1cWteUXmFRFRkYGnj17ptK2FStWVOhLSEhA1apV1R6X1GdiYgJ7e3tRTenIyEg4OTmpdZziXCclFRsbi2vXrgltY2NjrFy5UuXEdlZWlsrJZvkFXF++fAmZTKZ2GQ5tzhKXfy+VtP44lU19+/ZF37599R0GERFpgJG+AyAiIiIqS0xNTdGzZ09R3/3793HlyhU9RaQ94eHhona3bt1UTmwDuXU5S6sGDRqI2i9evEBMTIxaxwgLC1N5gU17e3tUq1ZN1Hfnzh21xqOSkf+d37x5U+1jFGefkrp//76oRva7776r1gKid+7cKXBhVXl16tQRlRaSSqWIiopSeSwg94kNdfdRh5eXl6h99+5drY1FRERE+seZ20REREQaNmzYMOzevVuU2FywYAH279+vVvK3MDk5OTAy0u88hdjYWFFbPjlblKCgIE2Go1GOjo6oUaOGaOb1X3/9hc8++0zlYxw5ckStMVu3bo39+/cL7eDgYHTo0EGtY1DxNWnSBOfOnRPaf/31F8aNG6fy/rdv39Zq0rYgcXFxorY234cWFhbw8PAQJYwDAwMxevRotcZTNZleHG3atBG17969i+joaFSpUkVrY+pa/i8YAGj1fCrTokULhS83ifKMGDEC3bt3V3u/hIQEhRJLI0aMgKurq9Au7uLORFS2MblNREREpGGurq7o378/du7cKfTdv38fv/76K2bMmFGiY8tkMixbtgzdunVTmKGoa/KJ+qSkJJX3vXnzZqmfzd6zZ0+sXbtWaAcEBGDAgAEq/XH98uVLHDhwQK3xPvzwQ1Fy+48//oCfn1+ZSsqVZj179sSqVauEBTjDw8Pxzz//oFOnTirtv3r1am2GVyD5xSHVeR8mJydj165dao33wQcfiJLbe/fuxfDhw5UuyqnMjh071BpPXdWqVUOjRo1w69YtALlfBK5fvx5z5szR6ri6JH8PKm7tcyJtKO5C0c+ePVNIbnfo0AEtWrTQQFREVJaxLAkRERGRFnz55ZeoXr26qG/jxo348ccfi33MN2/eYNy4cVi7dq2QgNMn+aRrcHCwSvulpKRg5syZWohIswYOHCiaIfnq1SvMnz+/yHOfnp6OGTNmqL1gZrt27dCwYUPRcaZPn46MjAz1As+nNFwnhsLV1RWtW7cW9S1YsECluum7d+/W2yJn8nXZr169qnIN7YULFyrM/C5K//79RU+NREVFwd/fX6V9//jjD518qeXn5ydq79ixQ+X7kzKl7X3k6OgoakdEROgpEtKHlStXwtPTU/Sfqus7lHUHDhxQODeXLl3Sd1hEpGVMbhMRERFpgbW1NdasWQNLS0tR/8aNGzFq1Ci1HumWSqXw9/dH165dcfr0aU2HWmzys6muXLmC3bt3F7pPXFwcRo4cqZeF99RVvXp1jBw5UtR3+PBhTJ06FW/evFG6z5MnTzB69Gjhj2lzc3O1xpwxY4YooX758mV89tlnePnypcrHkMlkuHDhAsaPH4+TJ0+qNX5599VXX4lmIMfExMDX1xcXLlxQun1GRgZWrVqF+fPnA1D/960J9erVg7W1tdCWSqVYsGCBqA63vKysLMyfPx+HDh1Se7zq1aujd+/eor7ly5cXeawzZ87gm2++UXu84mjfvj3ee+89oZ2dnY0pU6aInqZRRVxcHH777Te1yq7oQt26dUXty5cv4/79+3qKhoiISL9YloSIiIhIS+rWrYvff/8d48aNE83iPXfuHP7991+0a9cO7dq1Q6tWrVClShVYWFgAyE1Ovnr1CqGhoTh9+jSOHz+u8kxMXWrYsCHq16+PsLAwoW/u3Lm4ceMGhgwZgrp168LY2BgymQyRkZE4ceIENm3ahMTERACAj48PQkJC9BW+SqZMmYIzZ86Ivow4fvw4Tp8+jbZt28LLywt2dnaIj4/HzZs3cenSJWRmZgLInYmdmpoq+hklEkmh4zVv3hyzZs3Cd999J/RduXIFH374IXr16oXOnTujcePGsLe3F17PyMjA48ePER4ejpCQEJw6dQqvX78GAIUkJBXOy8sLkydPxi+//CL0vXjxAiNGjED9+vXRqlUrODk5IT09HY8ePUJwcLAw89nS0hIjRozAmjVrhH2L+n1rgomJCfr164eAgACh788//8TLly8xbtw4+Pj4oEKFCgCA169f4/Tp09iwYQMePXoEIHfGulQqFa4ZVcyYMQNnzpwRvuTJycnBV199haCgIAwdOhTvvvsuTExMkJ2djbCwMOzZswf79u2DTCaDqakpPDw8RPcNbVi6dCkGDBiAx48fA8h9EmL+/PnYsWMHBg4cCB8fH7i7u4u+TIqLi0N4eDjCwsIQHByMa9euITs7G3Xq1NFqrOpyc3ND7dq1hS8JMzMzMWDAAHTs2BGenp6wsrISza53cnIqdqkIUk1hX5xIpVJR+/bt2wVu7+bmhpYtW2o0tvwuXrwovPfl3b59W9SWSqWF/lyDBw/WaGxERMXF5DYRERGRFvn4+GDnzp2YOnWqaLG5nJwcBAUFiRZzs7S0hJmZGaRSqZAgVaZq1apwcHDQZtgqkUgkmDNnDoYNGyaK98CBAzhw4ABMTU1hZWWF5ORk0eKaAODh4YHZs2fj448/1nXYajEzM8OmTZswfPhwPHjwQOhPS0vDyZMnC5wZ7eHhgSVLliiUR1BlZq+vry9SU1Px66+/CrNv09PTsXfvXuzdu1eIy8rKCqmpqUhLSyvuj0dKjBs3DomJiQqlNsLCwgpMyJqZmWHZsmUKM/o1tYBsUfJm6T9//lzou3LlCq5cuQIjIyPY2toiNTUV6enpov2sra2xfPlyTJw4Ua3x7O3tsXLlSowePVqUuDt27BiOHTsGIyMj2NjYIDk5WWGxw+nTpwsJZG2yt7eHv78/Jk6cKJrVfP/+fXz77bcAcu9h1tbWkEgkkEqlOl+YsSTGjx+Pr776SminpqbiyJEjShey9fHxYXJby/Ke3lBFcHBwgWVy+vTpo9Xk9h9//IGDBw+qtG1CQkKhP5ehJLf1vfg2EWkf3+VEREREWubl5YVDhw5h4sSJCmVK8ktJSUFCQkKBiW17e3tMnz4dJ06cUKizqy/e3t5YsmSJMDM0v8zMTCQkJCgktps0aYKAgABRKYXSrFKlSti+fTv69++v0kzc7t27Y8eOHbCzs1NY6M3GxkalMceOHQt/f3/UqFFD6esZGRmIj48vNLFdsWJFLkZZTF999RV++OEHVKxYschtXVxcEBAQgHbt2in8vm1tbbUVooiDgwN+//13ODs7K7yWk5ODhIQEhcS2o6MjNm3aVOyFab29vbFhwwaF+s95YyYmJoqSxRKJBFOnTsVnn31WrPGKw8XFBXv27EG/fv1EM7TzyGQyvH37FklJSQUmtiUSCTw9PbUdqto+/vhjfP755zAx4Xw1ojwPHz4UtatWrYrGjRvrKRoi0hX+n5CIiIhIBypUqCAkdg4cOIC///4bt27dKnKmoJ2dHZo1a4aPP/4YH3zwgc5mgqqjW7duqFOnDpYtW4bAwMACa/3WqlULw4cPx6BBg2BsbGxQC2DZ2dnhu+++w7Bhw3DkyBGcO3cO0dHRSEhIQIUKFeDi4oJmzZqhd+/eaNCggbBfbGyswnFU1bp1axw/fhxHjhzBnj17cOvWrUJn9AOAs7MzWrZsiY4dO6Jdu3ZMfJVAnz590LFjRxw7dgwnT55EZGSkMDPb0dER9erVQ6dOndCtWzfhfSm/OKOuktsAUKdOHRw4cACrV6/Gvn37ClzQ1N7eHp988gnGjx9f4vi8vb1x7NgxrFixAocOHRJKDsnz8fHB1KlT0axZsxKNVxwWFhZYtGgRxo0bB39/fwQFBSE6OrrQfczMzPDuu++ibdu26N69e4FfMunbhAkT0LNnTxw+fBjXrl1DZGQkEhISkJaWVmjNdaKySr7U2dixY0vl5yYi0iyJrLQt/UxERERUTqSkpODevXt48uQJ4uPjkZqaCjMzM9ja2sLBwQEeHh6oVauWvsNUS0JCAq5cuYIXL14gOTkZ5ubmqFKlCurWrQt3d3d9h6dT0dHReP/994W2vb29sNBkcaSmpuLmzZt49eoVEhISkJKSAktLS1hbW6NGjRpwd3dXOouWdGfkyJE4f/680P7tt9/QoUMHnceRnp6O69evIzIyEklJSTAyMkLFihVRp04dNGjQQOks5pLKzMzElStX8OzZM8TGxsLMzAzVqlWDt7d3qXuCICoqCuHh4UhISEBCQgIkEgmsrKxQqVIluLm5wc3NjQkxIgOTnJwMHx8fYdJA1apVcfLkSb6XicoBTuUgIiIi0hNLS0t4e3vD29tb36FojL29PTp16qTvMEqFwMBAUbthw4YlOp6FhYVWa7FSySQkJODq1auivkaNGuklFnNzc7Rs2VKn14upqSlatWqls/FKwtXVFa6urvoOg4g06OrVq6Kn4caNG8fENlE5wZrbREREREQalpaWhoCAAFFf69at9RMM6cSmTZtENdA9PDxQuXJlPUZERFR+5C9JUq1aNfTr10+P0RCRLjG5TURERERUiIyMDLW2z87Oxpw5c/D48WOhz9zcHH369NF0aKQFmZmZULdyY3BwMNatWyfqGzRokCbDIiKiQuRPbnPWNlH5wuQ2EREREVEhfvnlF0yZMgXnz58vckHH27dvY8SIEfjzzz9F/YMGDYKDg4M2wyQNefjwIXr06IGdO3cqLBApLyEhAb/++ismTpwoWsCvWrVq6N27t5YjJSIiAJBKpbhz5w4AoHr16vjkk0/0HBER6RIXlCQiIiIiKsSiRYuwZcsWAICtrS0aN26MOnXqoFKlSrCwsEBycjJevHiBa9eu4f79+wr716lTB/v374e5ubmuQ6diuHv3rpCYNjIyQv369VG3bl1Ur14dNjY2yMjIQHx8PG7fvo1r166JSpHk7bN582b4+PjoIXoiIiKi8oULShIRERERqSgpKQlnz57F2bNnVdq+bt26+O2335jYNlA5OTkIDQ1FaGioSttXqFABixcvZmKbiIiISEdYloSIiIiIqBAuLi5q1+60srLCmDFjsGPHDlSrVk1LkZE2WFtbw8nJSe392rZti927d6N79+5aiIqIiIiIlGFZEiIiIiKiIiQnJ+Ps2bNC6ZHnz58jPj4eaWlpMDY2hq2tLRwcHNCgQQM0b94cHTt2hJ2dnb7DpmLKycnB9evXcfnyZYSGhuLp06eIjo5GSkoKsrOzYWNjAzs7O9SqVQvNmjVDu3bt4OXlpe+wiYiIiModJreJiIiIiIiIiIiIyOCwLAkRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcFhcpuIiIiIiIiIiIiIDA6T20RERERERERERERkcJjcJiIiIiIiIiIiIiKDY6LvAIiIiIiIDI1UKkVERASePHmC+Ph4pKSkQCKRwN7eHg4ODvDy8oKLi4u+wyx3nj17ho4dOxa53eXLl2Fra6uDiAxXdHQ0bt68idjYWCQkJMDc3BxVq1ZF/fr1UatWLX2HVy7l5OTg9u3buH//PuLi4iCTyWBvbw93d3c0btwYpqameo0vPj4eUVFRePnyJWJjY5GamoqcnBzY2NjAwcEBnp6eqF27NiQSiV7jVMfEiRMRGBhY6DaTJk3C5MmTdRQRERHJY3KbiIiIiEgFr1+/xsGDB3Hq1CmEhoYiKyur0O0rV66M1q1bo3///vDx8VFpjIULF2L79u1Cu3bt2jh27FiJ4ib9kslkePz4MW7duoXQ0FCEhobizp07SE9PF20XHh6upwj/k5WVhYMHD2LLli24f/9+gdu988478PX1Rf/+/WFsbKy1eEaNGoVz584p9AcGBqJGjRpaG7e0kUql8Pf3x65duxAbG6t0GxsbG/Tp0wcTJkxAxYoVdRLXvXv3EBwcjGvXruHOnTt4/fp1kfvY2tqie/fuGDx4MLy8vNQa79KlSxg2bFhxwxWUhvcaERFpDpPbRERERESFiImJwapVq7B///4iE9r5vXnzBocPH8bhw4fh7u6OGTNmoF27doXuc+fOHVG7Xr16xYqZ9EsqlWLdunVCMjspKUnfIRUpIiICkydPRkRERJHbPnz4EPPmzcOePXuwYsUKrSSa//zzT6WJ7fImNDQUU6ZMwYsXLwrd7u3bt9iyZQsOHz6MJUuW4P3339d6bBs2bMCff/6p1j5JSUnYtWsX9uzZgyFDhuDLL79EhQoVtBQhERGVB0xuExEREREV4NChQ1i4cCGSk5ML3MbU1BRWVlbIyMhASkqK0m0iIiIwduxY9OrVC0uWLFG6TU5OjsKMQia3S8be3h6ff/65Qr+2k2nx8fFYu3atVsfQpKtXr2L8+PFKk/BGRkawsbFBcnIysrOzRa+FhYVh8ODB2LZtm0ZLlSQmJmLx4sUaO56hunnzJkaMGKH0vmJmZgYjIyOkpaWJ+hMSEjBhwgSsWLFCpRI92pL/vpiamgqZTCZ6PScnB1u3bkV4eDjWrl0LKysrPUVauMGDB6Nt27aivuDgYAQHB+snICIiUsDkNhERERGRHJlMhkWLFmHr1q0Krzk4OKBnz55o164d6tevLyoBkJiYiDt37uDMmTP4888/FR7Tj4mJKXDMqKgohSQWk9slY2VlhcGDB+s7jFItOjoaU6ZMUUhsd+nSBb6+vvD29oaJiQlycnIQFhaGPXv2YN++fcjJyQGQe01PnDgRe/fuhaWlpUZi+umnnwosv1FexMXFwc/PT3RPMDExwZAhQzB48GDUqlULEokEL168wL59+xAQECBsm5WVhS+//BIHDhyAm5ub1mN1dHSEj48Pmjdvjrp168LNzQ12dnbC66mpqbh79y6OHTuGPXv2iBLyISEhmDt3LpYuXar2uK6urhgxYoQmfoQCySe2gdyncpjcJiIqPZjcJiIiIiLKRyaTYcaMGTh06JCov0KFCpgwYQJGjBhR4MxfOzs7tGrVCq1atcK0adOwd+9eLF++HImJiQAKT1bfvXtXoa9u3bol+EmotLC0tES9evXQsGFDNGzYEI8fP8by5cv1HRYAYO7cuXjz5o3QlkgkWLhwIQYMGCDazsjISIi/U6dOmDx5slA3/OHDh9i4cSMmTZpU4nguX76M/fv3C+3OnTvj5MmTJT6uoVm5cqXoyzEzMzOsWLECH3zwgWg7Z2dnTJ06Fe3bt8eYMWOEe01KSgp++OEH/P7771qLsWvXrhg8eDC8vb0LXSTSwsIC3t7e8Pb2hq+vL0aPHo3Hjx8Lrx85cgSDBw9Gs2bN1BrfycmJX14RERGM9B0AEREREVFpsmTJEoXEdq1atbBnzx6MHz9e5ZIWZmZmGDJkCP766y9hQcnCktvy9barV68Oe3t79YKnUsHCwgKDBg3CokWLcPjwYVy5cgXbt2/HzJkz0aNHD1StWlXfIQLILSsiPwN11KhRColtee3atcPs2bNFfRs3bkRcXFyJ4snIyMDcuXOFEhb16tXDkCFDSnRMQ/Ts2TPs3btX1Dd58mSFxHZ+jRs3xty5c0V9wcHBuH79ulZiBIBOnTqhadOmhSa25dWsWRNr166FqampqF/+nktERKQqJreJiIiIiP7f0aNH4e/vL+pzc3PDtm3b4OnpWaxjOjo6YtOmTfjoo4/UmrnNWduGq1KlSliwYAH69esHT09PGBsb6zskpXbv3i1q29vbY/LkySrtO3DgQHh4eAhtqVSKLVu2lCie33//HZGRkQByZ4ovWLAARkbl70/WgIAAZGZmCu0aNWpg5MiRRe7Xs2dPNG3aVNS3fv16jcdXUrVr10aHDh1EfSEhIXqKhoiIDF35+6RARERERKTE8+fP8c0334j67O3tsWHDBjg5OZXo2CYmJvjpp59Qu3btAreRn7nNetukbZcuXRK1e/ToodZim5988omoffz48WLHEhERISqhMXDgQDRq1KjYxzNkgYGBona/fv1gYqJaRVH5Wffnz59HamqqxmLTlHfffVfULmw9AiIiosIwuU1EREREBODbb79FcnKyqO+HH35AjRo1NHJ8IyOjAh/ff/XqFeLj40V9nLlN2pSYmIioqChRn7o1j729vUXtyMhIREREqB2LTCbDvHnzhNnKlSpVwhdffKH2ccqCO3fu4MWLF6K+7t27q7z/hx9+KEqEp6Wl4fz58xqLT1OsrKxE7bxSNEREROpicpuIiIiIyr0zZ84gKChI1Ne9e/dCa9xqkvysbYAzt0m78i8imadmzZpqHcPV1VWh799//1U7ln379uHy5ctCe8aMGbC1tVX7OGXBxYsXRe3KlSujVq1aKu9vYWEBLy8vUd+FCxc0EpsmRUdHi9qlpQ49EREZHia3iYiIiKjcW7lypahtamqKmTNn6mx8+eS2vb09qlWrprPxqfxJTExU6LOxsVHrGNbW1gp9Dx48UOsYsbGxWLJkidBu0aIFPv74Y7WOUZY8fPhQ1G7YsKHax5Av+VGc2fTaJr+QacuWLfUTCBERGTzVCncREREREZVRISEhuHXrlqivd+/eqFKlis5ikF9MkrO2SdvMzMwU+jIyMtQ6hrLt8xaEVNX3338vJNpNTU0xb948tfYva+TPn4uLi9rHkN9H3d+Jtu3YsQNhYWFC29jYGEOHDi3WsTIzM3Hv3j28evUKiYmJsLS0hIODA2rUqFGsc0dERIaHyW0iIiIiKtd2794takskEowaNUqnMTC5TbpmZ2en0BcXF6fWMZRt/+jRI5X3P3v2LI4cOSK0R40aBXd3d7ViKGvk66BXr15d7WPIl/iIjo5GSkoKLC0tSxJaiUmlUqxfv160cCgA+Pn54Z133lH7eKGhoWjWrBnS0tKUvl6lShW0adMGw4cPVyjVQkREZQeT20RERERUbqWnp+PUqVOivsaNG8PNzU1nMSQmJuL58+eiPia3SducnJxgamoqLOIIAGFhYWjRooXKx1BWK15ZuRNlUlNTMX/+fKFdo0YNTJgwQeWxy6qkpCRRu3Llymofw9HRUelxtZ3clslk2LVrl6gvIyMDCQkJCA8Px4ULF5CSkiK8ZmRkhPHjx8PPz69Y46Wmphb6enR0NA4cOIADBw6gS5cuWLhwIRwcHIo1FhERlV5MbhMRERFRuSWfbAGAzp076zQGZQnCunXr6jQGKn/Mzc3RoEEDXL9+Xeg7deoURo4cqfIxAgMDFfoyMzORkZGhtOxJfqtWrcKzZ8+E9ty5c1GhQgWVxy6L0tLSkJ2dLeqzsLBQ+zjKzqNUKi12XKrKzs4WfWFREBMTE7Rt2xYTJ05Eo0aNtB4XAJw4cQK3bt3C77//zlncRERlDJPbRERERFRuhYSEKPR98MEHOo1BviSJpaUlXF1ddRoDlU/vvfeeKLl9+fJl3Lp1S6WE48uXL3Hs2DGlr0ml0kKT2/fu3UNAQIDQ7tKlC9q1a6d64GWU/BdtgPLa6EVRltwuapazLnl7e+PDDz8sdpLZ3t4e7733Hlq1agVPT084OzvDxsYGGRkZiIuLQ2hoKAIDA/H3338jKytL2O/Vq1cYM2YM9uzZwwV7iYjKECN9B0BEREREpC+hoaGitqWlpU5LkgCKM7c9PT1hZMSP6aR9gwYNUkiezpw5s8jSIhkZGZg5c2aBCdP09PQC983JycE333wjJB0tLS0xe/ZsNSMvm5SdN1NTU7WPoywhXlBdan0ICQnBzJkz0aFDB/zzzz8q7+fk5ISlS5fi7NmzWLp0Kfr164eGDRuiYsWKMDU1hZWVFVxcXNC9e3csXboUx44dQ8OGDUXHiImJwZdffqnpH4mIiPSIn5qJiIiIqNySX/xOH4llLiZJ+lK5cmX4+vqK+iIiIjBs2DDcu3dP6T7Pnz/H2LFjcfHixQKPW1ht5+3bt+PWrVtCe8qUKQoLIJZX5ubmCn35a6KrKiMjQ6Vja5qJiQnCw8NF/127dg3//PMPli9fjp49e4qS9a9fv4afnx82bNig0vHd3NzQs2dPlWez16xZEzt27IC3t7eo/8qVKwgKClL9ByMiolKNZUmIiIiIqFzKyMjAmzdvRH01atTQaQxpaWkKCXZV622/fv0au3btwvnz5xEVFYXk5GTY2dnBxcUFHTt2RP/+/WFvb1+i+Hbv3o25c+cKbR8fH2zdurXQfTIzM7F9+3YcPnwYkZGRkEgkqF27Nvr06YNBgwbBxKToP0EmTZqEkydPomHDhti9ezeMjY1L9HNQwT7//HOEhISInmK4d+8e+vbti+bNm6Np06ZwcHBAUlISQkNDcf78eSF5KpFI0LZtW5w5c0bYVyKRwNraWulYr169wq+//iq0PT09FZLr5ZmyLwWUJaqLomyWtrYXkyyIlZWVMKO6a9eumDhxIqZPny76Um/JkiWoXbs2OnTooPHxzczMsHz5cnz44Yeisi87duzQeQkqIiLSDia3iYiIiKhcSk5OhkwmE/XZ2trqNIbw8HCFBeRUmbm9a9cufP/99wplDN68eYM3b97g+vXr2LRpExYvXlzsWsYvXrzAjz/+qNY+GRkZGDNmjMKs3tu3b+P27ds4ffo0fvvtt0IT3MePH8fJkydhamqK7777TqeJ7cOHD6u88J6VlRV69eql5Yi0z8zMDOvWrcPEiRNF9bezs7Nx8eLFQmdof/XVVwAgSm5bW1sX+PTDt99+K5xfiUSC+fPnq/Rlh6Eo6fVToUIFGBsbi+4JxamVrSy5bWVlpfZxtMHd3R2bN2/GwIEDRV/sfffdd2jXrp1W3u9OTk4YMGCAqM775cuXVVr4lIiISr+y80mCiIiIiEgNymZE2tjY6DQG+XrbpqamqFOnTqH7BAQEYPHixUI7b3E2JycnJCUl4ezZswgMDERsbCwmTZqEdevWoVWrVmrHNnv2bEilUlhaWipd6E6ZtWvXCsnQ5s2bo0ePHgByk37Xrl3DmTNnhESqMklJSfj2228BAKNGjSr2gnPFtWzZMjx//lylbZ2dnctEchsAKlasiM2bN2P16tXYsmVLkQlVR0dHLFq0CO3atcPKlStFrxW0UN/JkydF9ZX79eunUC7C0Gni+rGxsUFCQoLQln+6RBWvX79WetzSws7ODt988w1Gjhwp9D1//hynT5/WyuxtIHeh4PzJ7dTUVNy/fx8NGjTQynhERKQ7TG4TERERUbmkrHRCcUoAlIR8vW13d/dCZxI+evQIS5YsEdr/+9//MHr0aNE2gwYNQnBwMCZNmiQs/Pf333/DwsJC5bh27dqFf//9FyYmJpg6daoomV6QnJwc7NixAwDQqlUrbNy4UZjBO2DAAAwfPhyXL1/G1q1bMWHCBEgkEoVj/Pjjj3j9+jXc3Nzg5+encrxUcubm5vjiiy8wbNgw/P333zh37hwiIiIQFxeHrKwsODk5oXbt2ujWrRu6dOkilLl48eKF6DgFJQtXrFgh/NvBwYGL+hXAzc1NNINe/vyq4tWrV6K2k5NTqZm5nad169ZwcnJCTEyM0Hfp0iWtJbffeecdhb7Y2FitjEVERLrF5DYRERERlUvW1tYwNTUVLdiWlJSk0xjkZ24XVZJk69atyMrKApA7E1E+sZ2nffv2GDt2LFavXo1Xr15h69atGDt2rEoxPX/+HD/99BOA3NnTqtYAj4qKQnx8PABg+PDhotIUxsbGGDlyJC5fvoy4uDhERUXBzc1NtP+lS5ewf/9+SCQSfPfddywXoCeVK1fG0KFDMXToUJW2Dw8PF7ULSm7nL9cRHx+PFi1aFDvGjh07itqq1II3FPLJ7adPn6p9jGfPnonatWvXLnFcmiaRSFC3bl1Rcls+bk2ys7NT6NP1/Z6IiLSDyW0iIiIiKrecnJxEZQQiIiJ0NnZWVhbu378v6isquf3vv/8K//7kk08K3bZfv35YvXo1AODQoUMqJbdlMhm+/vprSKVS1K5dG5MmTRIl2gqTl9gGgJo1ayq8nr8vPj5elNxOS0vDN998A5lMhkGDBqFZs2Yqjalpp06d0su4hio1NRUPHz4U9TVt2lRP0eifJq4f+RnG+Rf6VNWNGzdEbXd395KEpDXypVKU1QrXlLdv3xY5PhERGSblK30QEREREZUD8knUsLAwhUUatSUyMlJhrKJmSecvN1DUbMzq1aujQoUKAICHDx/iyZMnRca0c+dOXLx4EUZGRmrPns4rUwGIE93K+vJvCwArV67E48ePUaVKFfzvf/9TeUzSr1OnTomuYS8vL53XSS9rWrZsKWq/efMGjx8/Vnn/1NRU3Lt3T9RXnJr7upC/tjiQW65GW6KiohT6KlasqLXxiIhIdzhzm4iIiIjKrVatWuHQoUNCOyMjA3/++Sf69eun9bHlS5JIJJIiE4MymazY44WHhyudUZ3n2bNnQj3vIUOGqD0D19XVVSjz8s8//yh8cXDy5EkAuYtmurq6Cv137twRFnqbO3eu0lroVDrt3btX1B4wYECB237++eei0iSqioqKEi0EmHcse3t7oe3k5KT2cUur+vXro1q1anj58qXQd/ToUUyYMEGl/U+cOCEqtWRubo42bdpoPM6SysnJQVhYmKhPm7/H06dPi9qmpqalslwLERGpj8ltIiIiIiq3OnXqBFtbW1Ht1fXr16Nnz57CrOfievHiBa5fv44ePXoofV1+MclatWoVmdh1dHQUavA+evSo0HIDL1++FD3mHxERgc6dOyvdNq8cSUpKCpydnfHFF18UGocyFhYW6NChA44fP45t27ahatWq6NmzJ4Dcsih5i0127NhROLfZ2dmYM2cOsrKy0LVrV3Tq1EntcUk/Tp48iQsXLghtBwcH9OrVq8DtC3utMJcuXVJIbn/00UeoUaNGsY5nCDp16iSqIb5v3z6MGTMGJiZF//m+Z88eUbt169YKT0qUBkFBQQpPeLRu3VorYyUlJWHnzp2iviZNmvCLNCKiMoJlSYiIiIio3LKxsYGvr6+oLyoqCvPnzy/2LOmsrCxs3rwZH330EVJTUwvcTn7mtioLNzZv3lz494EDBwrddv/+/aJ2YmJigdvu2LEDly5dAgB8++23xU6G/e9//4O9vT0yMzOxePFitGnTBm3atMFPP/2EzMxMODg44KuvvhK237hxI8LCwmBnZ4dvvvmmWGNSrkuXLsHT01P0X1HXSHFFRERg/vz5or6ZM2eW2hrGvr6+ovPSoUMHfYdUqOHDh8PU1FRoP3v2DBs3bixyv7/++gtXrlwR9Y0ZM6bI/Ypz7WRkZBR53ILExcVh8eLFoj57e3v4+PgUuE9x78fZ2dn46quvFO5/ffv2LdbxiIio9GFym4iIiIjKtZEjR4rKZADAwYMH4efnp7R2dEFSUlKwe/dudO3aFd9//z2Sk5NRv379AreXr4tb1GKSADBo0CDh34GBgQozWvOcOXMGa9euFfUVVBLi6dOn+PnnnwHkLlJZkhIGLi4u2LFjh9KSJj4+Pti5cyecnZ0BAE+ePMGqVasAAF999RUqV64MILfG8HfffYcOHTqgQYMGaNWqFSZPnqxQwoA04/Xr16IZ2EW5cOEChg8fjjdv3gh9bdq0Qe/evbUQXfnk4uKisGDsqlWrEBwcXOA+t27dwsKFC0V977//vtYW+Pz222+xYMECvHjxQq397t69C19fX+EJlDxTpkwptMb/okWL8PPPP+P169cqjxUXF4fx48cjKChI1O/h4YGPP/5YrbiJiKj0YlkSIiIiIirXrK2tsWbNGgwYMADJyclCf2BgIC5cuIB+/fqhXbt2aNy4sTAzVSaTISEhAa9evUJISAguXryIixcvIiUlRdjfzMwM77zzjtIxnz59KiqFAqg2c7tx48bw9fUVShYsXrwYJ06cQJcuXVClShUkJSXh3LlzOHnyJGQyGWrWrCksJCmRSBSOl78ciaOjI2bOnFlkDEVxd3fHjh078Pz5czx69AgSiQS1a9dGtWrVRNt98803SEtLQ6tWrYQa51FRUfD19UVMTAyA3FIXSUlJOHHiBIKCgrBs2TKDKV0SGhqK27dvK33txo0bCn3yZRPy++ijj7RWQuHNmzcYMWIEXF1d0bFjR7Ru3Rp169ZFpUqVAOReI3Fxcbhw4QKOHDmikCisWbOm8OUIac6UKVMQGBgoJHPT09Ph5+eHIUOG4NNPP0WtWrUgkUjw4sUL7Nu3D5s2bRLdfywtLTXyfi5IZmYm9uzZg507d8Lb2xsdO3ZE/fr14enpKVoYUiaT4dmzZwgNDcWxY8cQGBiI7Oxs0bFatmwp+uJOmeTkZGzduhUbN25E8+bN0aFDB9SvXx8eHh6wtbUVtktLS8Pt27cRGBiIPXv2iO7pQO7TOkuWLIGREef5ERGVFUxuExEREVG55+7ujoCAAEyZMkU0EzElJQVbtmzBli1bAOQuQmZlZYW3b98qJGjkeXh4iEoL5CdfbxtQbeY2AMyaNQumpqbYtGkTZDIZrl69iqtXr4q2MTY2xpQpUxAXF4fNmzcDgGgBvjzbtm1DSEgIAGD+/PmiJFFJOTs7C7O05e3duxcXL15EhQoVRLNNv/zyS8TExOCdd97BihUr4O7ujsTERMyePRsnT57EjBkzcPz4cWGWd2kWHBwszExXhXyZj/zatm2r9frAUVFR8Pf3h7+/P4D/rvXk5GRkZWUp3cfd3R3+/v6oWLGiVmPTNGVf9JQ2lSpVwsqVKzFy5EghaZ1X8mjz5s0wMzODkZGRqK5+HmNjY/z000+F1uTXFGX3IGNjY1hbWyMnJwdSqRQ5OTkF7t+iRQusXbsWxsbGKo2XnZ0tfJmYx8TEBNbW1sjIyBAl+OXZ2tpi9erVRS7cS0REhoVfVxIRERERAWjYsCEOHDiA7t27FzirLzMzEwkJCYUmto2NjfH+++/jyy+/LHAb+XrbTk5OwkzZohgbG2PGjBk4fPgwhgwZAg8PD1hZWcHU1BTOzs7o27cv9uzZg/HjxyMhIUHYTz4h/OTJEyxduhQA0K1bN53NiH79+jWWLFkCIHd2as2aNQEAV65cQWhoKIDcRG9eYs7Ozg6LFy+GtbU1kpOTsXfvXp3EWd7lXevKEtsSiQSffPIJ9u7dqzAjvzSKiIgQtbt06aKnSNTTpEkTbN68GVWrVlV4LSMjQ2li287ODmvWrClw8VhdyM7ORmJiIt6+fVtgYtvCwgJfffUVNm3aBAsLixKNl5WVhYSEhEIT2y1btsThw4cLretNRESGiTO3iYiIiIj+n4ODA3799VdMnjwZmzdvxtmzZ/H8+XOV9vPx8UHr1q3RoUMHODk5Fbq9/MxtVWdt5+fh4YG5c+cWus2DBw+Efzdu3Fj02uHDh4UFLytXrow1a9YoPcazZ8+Efz9//ly03ejRowutk6vMt99+i8TERNSvXx8jRowQ+vMWtHR0dBQtnAnklhJ4//33cfToUYSEhGDChAlqjUkFq1GjBvz8/HDmzBncvXu3wFnaQG6pi06dOuGzzz4r1jWrDw8fPkRsbKzQtrS0VGmRxdKiUaNG+Ouvv7Bhwwbs3r0bcXFxSreztrZGnz59MGHCBJW/KCuJWbNmoW3btjh79iyuXbuGx48fF7mPsbExvLy80KtXL/Tq1UutGf8jRoxA9erVcfnyZYSFhRW4hkB+9vb2eO+99zBkyBB4e3urPBYRERkWJreJiIiIiOTUrl0bCxYsAJCb0L179y7i4+ORmJiIzMxMWFlZwdraGtWrV0ft2rWLTGbL+/3337URtkhcXBzu378PIDfxJV/TWyaTCf/Oq+FdlOfPn2P58uVCe+jQoWolt//55x8cP34cJiYmWLRokagUQXR0NAAUOBM4r//Vq1cqj6dPkydPxuTJk3U2XosWLRAeHq72fjY2NpgyZQqmTJmC1NRUhIeH4/Hjx4iLi0NKSgpMTU1RqVIluLu7o379+gWW2tGW4v5cefK+NMkzePBggyujYm1tjc8//1xYWDU8PBxxcXGQyWSwt7fHO++8g0aNGqn9RVOe4pxjOzs79OjRAz169AAAJCYmIiIiAi9evEBsbCxSU1MhkUhgbW0Na2tr1KxZE15eXsWepe3l5SWUE5HJZHj69CmePHmC6OhoJCYmIi0tDSYmJrCzs4OdnR08PDzg5uZmECVoiIioZJjcJiIiIiIqRGG1o0uzgwcPCrNw+/Tpo/OkpLy3b98KXxiMHDmywAU0CyotUFjJAdIMCwsLvPvuu3j33Xf1HYrGXL58Wfi3paUlRo8ercdoSsbY2BiNGjVCo0aN9B2KAjs7O3h7e+tkhrREIkHNmjWFkkZERFS+MblNRERERFTG5C8fUqFCBQwfPlxhG1VnFl+6dAnDhg0DAPj4+Kg8y1vekiVLEBMTA1dXV0yaNEnh9SpVqgDILYMilUphZWUlej1vFrqy+sNEBcmf3P70008NbtY2ERERFY7JbSIiIiIiA3Lv3j1UrVoV9vb2Sl+/e/cuJk+ejOTkZADA9OnT4eLiosMIFV2+fBl79uyBRCLBwoULYW5urrBN3kJvaWlp2L59O8aOHSu8dv36dVy9ehUAFOpxF+b58+fw9PRUGo+tra26PwYZmIiICLx58wZA7qztUaNG6TkiMjQTJ05EYGCgvsMgIqJCMLlNRERERGRAjh07ho0bN6Jly5Zo0qQJatSoARMTE8TExODixYs4ffo0cnJyAADDhg2Dr6+vXuNNT0/HnDlzIJPJMGDAALRo0ULpds2bN0f9+vURFhaGZcuWISYmBt7e3nj27Bn8/f0BAFZWVujfv78uwycDFhISIvx7yJAhnLVNRERUBjG5TURERERkYDIyMnDmzBmcOXNG6es2NjaYOnWq3hPbALB69WpERUXB0dERX331VaHbLlmyBMOGDcObN2+wdetWUQkUU1NTLF68GI6OjtoOmcqIwYMHY/DgwfoOg4iIiLSIyW0iIiIiIgPSr18/ODg4ICQkBBEREYiLi0NqaioqVqwIV1dXfPDBB/j4449LxSzVe/fuCbOu586dCxsbm0K3d3d3x4EDB7B27VoEBwfj9evXsLKygo+PD8aNG4cGDRoUur+9vT3mz59fZFwVKlRQ+WcgovJr8ODBaNu2baHbFHVfIiIi7ZLIZDKZvoMgIiIiIiIiIiIiIlKHkb4DICIiIiIiIiIiIiJSF5PbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcEx0XcARIYgPj5e3yEoJZFIYG9vDwBISEiATCbTb0BkcHgNUUnw+qGS4PVDJcHrh0qC1w+py+juXdi1aVPoNonnzyOnbl0dRUSGjPcgKomycP04ODho9HicuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMjom+A6CyKyMjA1evXsXz588RFxcHe3t7VK1aFc2aNYOlpaVGxkhISMC1a9fw6tUrJCcnw8nJCTVq1IC3tzeMjPjdDRERERERERERUVnF5LaBk0qluHPnDm7duoVbt24hNDQUz58/F153dnbGqVOndBpTcnIyli9fjsOHDyMhIUHhdUtLS3Tt2hXTp09H5cqVizVGVFQUli5diqCgIGRmZiq87uTkhIEDB2Ls2LEwMzMr1hhERERERERERERUejG5baA2bdqEAwcO4OHDh8jJydF3OII7d+5g8uTJePbsWYHbpKSk4MCBAzh9+jSWLl2KVq1aqTXG4cOHMW/ePKSkpBS4TUxMDFauXIlTp05h5cqVcHZ2VmsMIiIiIiIiIiIiKt2Y3DZQly9fxv379/UdhsjLly8xduxYvH79Wuizs7PDBx98gKpVq+L169c4c+aM8HpsbCwmTpyIXbt2wdPTU6Uxzpw5g5kzZyI7O1voc3V1RYsWLWBvb48nT54gKCgIaWlpAICwsDCMHz8eO3fuhLW1tQZ/WiIiIiIiIiIiItInJrfLEEtLS9SvXx9hYWGFzmrWBplMhqlTp4oS2z179sTChQthZWUl9GVkZGDp0qUICAgAkDuL28/PD0ePHi2yfMjr16/xxRdfCIltiUSCGTNmYPjw4aL62nFxcZg6dSpCQkIAAPfv38e8efOwdOlSTf24REREREREREREpGdccc9AmZubo1GjRhgyZAh++OEHHDlyBFevXsW2bdvg4OCg83hOnDiBmzdvCu3WrVvj559/FiW2AcDMzAyzZs1C3759hb6nT59i165dRY6xdu1avH37VmhPnjwZn332mcLCkRUrVsSGDRvg7u4u9P3111+4d++e2j8XERERERERERERlU5MbhuoX3/9FXv37sXcuXPRp08f1KlTRyHJq0u//fab8G8jIyPMnz8fEomkwO1nzpwpKhOybt06ZGVlFbh9bGws9uzZI7Rr1qyJsWPHFri9ubk5vvnmG6Etk8mwZs2aIn8OIiIiIiIiIiIiMgxMblOJPX78GHfv3hXa7733HmrVqlXoPnZ2dujRo4fQfv36Na5cuVLg9oGBgcjIyBDaAwYMgKmpaaFjtGrVCm5ubkL79OnTSE1NLXQfIiIiIiIiIiIiMgxMblOJBQYGitoffvihSvt169at0OPkd+rUKVG7a9euKo2Rf7u0tDScP39epf2IiIiIiIiIiIiodGNym0pMfsZ1kyZNVNqvYcOGMDY2LvA4BY1RuXJluLi4qDSGfCyXL19WaT8iIiIiIiIiIiIq3ZjcphKLiIgQ/l2hQgXUrl1bpf2sra1Rs2ZNof3o0SPIZDKF7WJiYkQLSdatW1fl2OrVq1dgrERERERERERERGS4mNymEsnMzMSzZ8+EdtWqVQtdSFJe9erVhX+npqbixYsXCttERkYWuE9RKleuLKrNLX8sIiIiIiIiIiIiMkxMblOJxMbGIisrS2hXrVpVrf2rVKkiar969Uphm+jo6EL3KYxEIhFtL38sIiIiIiIiIiIiMkxMblOJSKVSUdvKykqt/eW3T0lJ0eoYWVlZyMjIUGt/IiIiIiIiIiIiKn1M9B0AGTb5ZLS5ubla+8tvryy5nZqaqtExpFIpzMzM1DqGOqVWdCl/XCWKMfP/z7upZQkjIkOjsWuIyiVeP1QSvH6oJHj9UEnw+iF1qXKdSCQSXk+kEt6DqCR4/ShicptKJD09XdRWN2ksv31aWprCNvJ9JR1DPmZV2Nvbq72PrtnZ2RVrP1l6MmTxUQBkkDh6QGLtqNG4yHAU9xoiAnj9UMnw+qGS4PVDJcHrh1Ria6vCJraAAfzdSKUL70FUErx+crEsCZWIfOI4MzNTrf3lS4Qom5Ut31fSMdRNjpd5GVIAMshSEyF78xCydGmRuxAREREREREREekbZ25TicjXv1Y287ow8rOoLS0Vy2LI95V0DHVrdgNAQkKC2vvogkQiEb6pS0xMhEwmU/8YyYkwSpbCNC4KkspGMI25h1iz6khOTYe1tTUqV66M9PR05OTkICMjo1hjUOmliWuIyi9eP1QSvH6oJHj9UEnw+iF1GSUloai520lJScgppX83UunCexCVRFm4fjRdHYHJbSoR+cSzsprZhZFfLFKV5HZJxjAxMVG7ZjcAg7hZyGSyYsVpZGQEc3NzZGVn4dyhbdh29DxuPHiG0JgsAECdOnUwfvx4jBkzBhYWFkhLS0N2dramw6dSoLjXEBHA64dKhtcPlQSvHyoJXj+kClWuEV5LVBy8bqgkeP3kYlkSKpFKlSrBxOS/70hevnyp1v7R0dGidtWqVRW2qVKliqj96tUrlY8vk8lEY8gfq7wzNjaGhYUFrl69irnz5+HIoQMwSX4FBwsJXO1zbw8PHjzA9OnTUb16dfzzzz+wtLSEsbGxniMnIiIiIiIiIqLyjsltKhEzMzPUqFFDaL969Uqtb41evHgh/LtChQpwdnZW2KZ27doF7lOUN2/eiGp0u7m5qbxvWSeRSFChQgWcPn0aX8+ejYz0dMSn5sDKTILq1saoaWeMypb/rbybnJyMXr164eTJk6hQoQJX5SUiIiIiIiIiIr1icptKLH/yOS0tDZGRkSrtl5ycjCdPnghtNzc3pQnTKlWqwMbGRmjfvXtX5dju3Lkjaru7u6u8b1lnbm6O9PR0jB83Hjk5uWVGkjNleJGcDUcrCezNJfCsZAJL0//2yc7OxoABA5Cens6FOYmIiIiIiIiISK+Y3KYSa9asmah9/fp1lfa7deuWqHaz/HHya9q0qfDvN2/e4OnTpyqNce3aNVG7efPmKu1XHhgZGWH9+vWQpojrnr9JkSE+NQc1bI1hZQrUdzSBSb47RXJyMjZs2MDSJEREREREREREpFdMblOJdejQQdT++++/VdpPfruOHTuqPMaxY8dUGuP48ePCv83NzdGmTRuV9ivr8hbWDFj/G1Z0tcH+/vYY0tACVqa5M+efvc1BRrYMrvbGsDaToL6jCfLPqV+7di3Mzc1F9daJiIiIiIiIiIh0icltKjE3Nzd4enoK7fPnz+Px48eF7pOYmIijR48K7cqVKxc6q7pjx44wNf2vPsbevXtFtbSVuXDhAh49eiS027VrB0tLy0L3KS+MjY3x5s0btLB8jt5eFWBXwQje1UzxZWsrmBoBOTLgUUI2jIwkcLM3hn0FCTwr/TdT+/79+4iNjeXsbSIiIiIiIiIi0hsmt0kpT09P0X9FmTBhgvDvnJwczJ8/v9CFJX/44Qe8fftWaI8ZM6bQWcCVK1dG//79hfaTJ0+wbt26ArdPT0/Hd999J7QlEokoxvJOIpEgOTkZ1qbiGuf1HU0xvZUVACAzB4hKyIKFqQQ17YzhZG2EWnb/3TKkUilMTU25uCQREREREREREekFk9ukEV27dkXDhg2F9r///osvv/wSUqm4nnNGRgYWL16MAwcOCH3Ozs4YPHhwkWOMHz8eVlZWQnvlypUICAhATk6OaLu4uDiMHj0aDx8+FPq6d++OevXqqf1zlVUymQzW1tbYcisV0cnZotc61TbHZ+9aAABSMoEnidmwryBBVWsj1LI3hpNV7m3DzMwM586dQ1ZWFiwtLTmLm4iIiIiIiIiIdEoiK2x6LZVaz58/R+fOnZW+ln+RRgAFJh0DAgLg4+Oj9DX52drh4eEqxdS/f3/ExsYKfXZ2dujQoQOqVKmCN2/e4PTp03j9+rXwuqWlJXbu3AkvL68ijw8AwcHBmDBhgiih7erqipYtW8Le3h6PHz9GUFAQ0tLShNffeecd7N69G9bW1iqNoUx8fHyx99UmiUQCe3t7AEBCQkKhs+XzMzExgY2NDTw8PFAz6zEODLCHhdws7qUXpDj2MB0A4GhphOo2RniSmIPY1Byk2rjiyu376NatG86dO4fdu3ejS5cuSElJ+T/27jw+qvLeH/jnnDMzZ2Yyk30jrAEyEVBkU0TrUpa4tAZpLVHbXqUlGrCb5l61v9ra3i5qe+W2VTCVWO21VUGrCFUxxLUuuCGiLElYwhaSMFnnZGbOzFl+f2BGJutkYUn4vF8vX3Jmnuec54SHSfKZZ75Pp/lHp7f+ziEigPOHBobzhwaC84cGgvOH+krcuRMJvezf1PLOOzAmTTpJI6KhjK9BNBDDYf4kJSUN6vm4G9wQZZpmzCFid+0G+x/AyJEj8cgjj+BHP/oRDh8+DOBYbe3nn3++y/ZJSUl44IEHYg62AeCyyy7Dvffei1/+8pcIBAIAgOrqalRXV3fZftKkSXjooYcGFGwPR5qmQVVVFBUV4Q/3/Bd+/ZaCX3/VBUn8MuD+yWwnjrYZ+OhIGEf9BmwSMDpeRNgwsfw/rsb+3btQVlYGwzCQn5+PDRs2YN68efD7/UPyxZWIiIiIiIiIiIYWliWhQXX22WfjhRdewHe/+10kJCR02cbhcOCaa67Bhg0bcFEv73535ZprrsFzzz2H+fPnR20yeby0tDTceuutWLt2LUaNGtXna5wJDMNAYWEh4pxx+KAmjOd2BqOel0QBv7jUhQlJx1b+H/YZ8IVMeNKd+NqCy7D+0T9AMI+toNd1HYsXL4aqqrDZbCdszBaLBbIsw263Q5blHuu0ExERERERERHR8MZkaIgaNWpUTKVC+msg53a73bj77rtxxx134KOPPsLhw4fR2NiIhIQEjBgxArNmzYqqnd0f48ePx8qVK9HU1IQtW7agtrYWbW1tSE1NxejRozFjxgzWgO6FqqpwOp0o+UsJfnv797H5cBgWCVh0liPSxmkV8Nu5bvzw5VYc9Rs46ANu/3EhZH8tEuwWzMlJxduVXgCAoigoLS3F8uXLB3WcgiBAlmWIoghZluH1eo9thulyITU1FcFgEKZpQlVVrhgnIiIiIiIiIjqDsOY2UQyGW83tdpIkwaH78NHGNfjnw7/G3qN+3DLTibnZclS7vU0afvpmGMU//TlmTj0H2954AZOmTofmHonvF/8Cz7/+MQDA4/GgoqICPp8PmqYN+P4kSYLdboeqqli9ejVKSkpQVVUVeT4nJwdFRUUoLCyELMsIBoOs+d1Hw6FeF506nD80EJw/NBCcPzQQnD/UV6y5TYOJr0E0EMNh/gx2zW2WJSE6g+m6jlAohFmzZuG/f/kr3HjjEjxZnYhtdeGoduOTLHjyllmYnOvBbXfciV/9+VH86md3YPfWd/Dkqj/giovPAwBUVlaioaFhUFbNS5IEp9OJ8vJyZGVlobi4OCrYBoCqqioUFxcjKysL5eXlcDqdXLFPRERERERERHSGYLhNdAYSBAF2ux1OpxNOpxNtbW0wDAOXX56Hx574OyYsLYEWlxHVR6rbjvf/vBQ7duyAEjKxr8GPv//lT9j2wVt48sH/xpjMVADHypMIgtDVZfs8vrKyMuTn50NRlB7bK4qC/Px8bNq0CXa7fcDXJyIiIiIiIiKi0x/DbaIzTPuKaE3TsHLlSlx00UVYeM1C3PnT/4fl3/sO/vCH32PvoXoI834KU46P6jtvjIhvn2MHAHj9Jhr8Gtas/iMkPYj/uulqWEXA5XIN+GMxsixDVVUUFBTEXGbkZG1qSUREREREREREpweG20RnkK5KfXy0fQ90A9jfosNpBT5/+xXcdvttuOY/bsGOzKthStFB8ZJpTszPPvbYoVYDzW1BfLDxWXzja1fgqvMmIjkpacB1r0VRxOrVq3tdsd1R+6aWLE1CRERERERERDT8MdwmOkN0V+ojbACf12toUU0cbNGRaBeR5RYRCARw2+9WoWrEVTARXeajeE4cpmVaYALY36zj7bffRoYcwu3LvofQkZ0D2kzSYrFAlmWUlJT0q39JSQlkWYbFYun3GIiIiIiIiIiI6PTHcJvoDNFTqY8W1cQur4amoIkan4E0p4h0pwjD0FH8x6cQnv7tqPZWScCvLnUhO1FC2ADer6pBa2Mdzj9rNIzWOggth/o9TkmS4PV6O20eGavB3NSSiIiIiIiIiIhOXwy3ic4QvZX68PpNVDXq8AYM1CoGRrhFJDsEBAIBvLhbh3/c3Kj2cTYR985zI90pwh8GgnIKpLAPWvNhiK01EJT6fo1TEIQ+lyPpaDA2tSQiIiIiIiIiotMbw22iM0CspT5qFQP7mnTUtRnwtpkY5ZaQIAtYv349XF9dhs99cVHtU53HAm63TYAjMQO6Mw1CWwPgb4TQVA0Emvo8VtM04XK5+tzveIOxqSUREREREREREZ3eGG4TnQH6UurjYKuBQ60GDis6moMmxiZIaKk/hKamZrwrzcS2unBU+7GJEu6/PAXuODt0ORGmMxmCUgdB9UFs2AOE2iJt20N2u93ebV1sXdeRmpqKnJycft2rx+NBSkrKgDe1JCIiIiIiIiKi0xvDbaIzQF9Lfext0lGnGDjQqqNVNTE2UUKw2QvZ6cYv3lBQ3Ry9YaQn0YD+xv9C18Iw49IB2Q2h9TCEUBskbyXsFgFOpxNutxt+vx91dXXw+/1wu91wOByw2+2RMiKapkFVVRQVFfXrXouKiqCq6oA2tSQiIiIiIiIiotMfw22iM0B/Sn1UNOg42magukWHTzURpzVC97dACZn4f68q8PqNqPbCgQ9g3fqPY9eLzwIsDkith2EXdOhHPseqhx6Ex+NBWloasrOzkZaWBo/Hg1WrVkHTNDidzsgmkIZhoLCwsM9jdrlcWLp0KVdtExERERERERGdARhuE50B+lvqY6f3WMCtu0cgPjULRkM1Lr1gJi656ht413kpQqYU1d6yuxyWipcAQYSQNBo2uwM733sFixd+DY/9/qedyqJUVVWhuLgYo0aNwqeffoq4uDg4HA6Ypgm73Y41a9ZEAu/eSJKEtWvXQpZlhEKhPt0nERERERERERENPQy3ic4AAyn1sdOr4+sFN6HNkohv3nAj7vnxElz/jXyct+Ba6JfcDojRdbOtn62FdOAd2OxOfLz3KB55pASZcghJDgETkqKD6tTUVNx1113Ytm0bzjvvPDQ2NqK2thZ+vx9WqxWXX375sc0se1nB7XK5sGHDBixYsADBYJCbSRIRERERERERnQE67+ZGRMNSe6mPe+65p0/1t+fNm4dv3Hwngoc+w+svb8SW119AW1M99jbpaAub+OaMTCybEt3H+sGj0BxJ+OVvfgdRC2NCkoSRrmPBdlvYRK1iYM6cOVi/fj0kScJjjz2GkpKSqJXdOTk5+NWvfoVrr70WNTU1KC0txcMPPxzVxuPxoKioCEuXLoUsy/D7/SxJQkRERERERER0hhBMLnEk6lVTU9OpHkKXBEFAYmIiAKC5ubnHFcuCcGxTx/LycuTn58cUAn/lK1/Ba6+9hk2bNuG6ggKMcQSQ6hQxPlGCwyZgT6OGgAZcO8mOolnOqL5hWPCDfzVgT5OOZIeA0fESDrUa8PoNyGNmYH3Z6ygvL8cNN9zQY9g+btw4vPzyyxg/fjxsNhsaGhqgKApcLhdSUlKgqip0XUcoFOKK7X7oyxwi6ojzhwaC84cGgvOHBoLzh/pK3LkTCRdd1GOblnfegTFp0kkaEQ1lfA2igRgO8ycpKWlQz8eyJERnCNM0EQwGkZeXF1Opj3HjxqGsrAybNm1Cfn4+fIqCHUd1NPhN7GvWEdRMjE+yQJaAZ3cG8c+dwaj+Vmj43Vw3MuJENAZMeP0GRrpFjExNwNqV/43Xyl7GokWLel1FXl1djbPPPhuvvvoqwuEwnE4n0tPT4XA44PP54Pf7oarqkHxBJyIiIiIiIiKi/mO4TXQG0XUdfr8f8+fPR01NDVasWNFpk0mPx4MVK1Zg165d0DQNpaWl+OEPf4i7774bP/7JTzB65jy0hATsa9KhGSbGJ0mwikDJR368Ua1GnSvFKeLeeW7E2wQc9hlQwiYKLr8QkqbivtuXwDRiKyGi6zoWL14cqacdDAahqio0TRu0rw0REREREREREQ0trLlNdIZpD7htNhuWLVuG2267rctSH5IkQdM0PPfcczhy5Ah8Ph/cbjdGjBiB6r27sWH1fXjj5ReQZmnD+CQJVY067n+nDUl2EedmWiPXG5Mg4b+/6sKd5T4caDFx0cWX4L2Na2HRA5iUKmH70dgCbkVRUFpaiuXLl5+oLw0REREREREREQ0hXLlNdAYyTROqqiIQCMDn88HhcERKfbS1tUEURQQCATz22GPweDzIyspCbm4usrKy4PF48Ny69fhO8W9R+sTTsGXkwCIKGJ8oQTeBX7yh4JAiRF3v7HQr7r7EhVmzZiJ54nS89/ZbGJsgIcUpIjtRinncJSUlkGUZFgvflyMiIiIiIiIiOtMx3CY6w2maBlVVEQwGoWkaZFnGpk2bkJWVheLiYlRVVUW1r6qqQnFxMcZkT8S7e5tx/x9XwpaRA7tFwNgECW1hE//1ShMMe2JUvzmjbPjOhDY0NSv4cHct3LKALJeE0QkiMuJieymqrKxEQ0MDJCn2QJyIiIiIiIiIiIYnhttEBODYjrt2ux1lZWXIz8/vdaNHRVGw8JsFeGNHLe757R/QaMTBZRMwLlGC12+gedatUDtUPjrLUgtp2xooIROHfTrS4gQkO0R4UiTEy0I3V+p8XUGIrS0REREREREREQ1fDLeJCAAgyzJUVUVBQQF0vQ8bPX5nCYSMs3BJ3tewv1mH2yZgbKIEOX08NmkzoGpmVB9X9av45iQZDQETXr+BUW4RLpuAKWkW2GOoNuJyuWCaZu8NiYiIiIiIiIhoWGO4TUQAAFEUsXr16l5XbHekKAoee+qfuOqm29EaElDdrGPCyAy4zVacdXE+fvu2H7oRHUYvmxWHedk2HPYZUMImxiVKiLMBU9IskHpYlO3xeJCSkhJz+E5ERERERERERMMXw20igsVigSzLKCkp6Vf/kpISjM2dirSzL0aLauKci6+CpjRjYpod+ct+iQc/Dnfq818XxuG8LCuqm3VohonsRAlum4DJad0v3y4qKoKqqtA0rV/jJCIiIiIiIiKi4YPhNhFBkiR4vd5Om0fGqrKyErW1tRg1cQr2tclYkP9NGPEjEfI1YeaEdCz/n6fxue3cqD4WUcAvLnXBkyJhX7MOiyggO1FCkkNATnLnDSNdLheWLl3KVdtERERERERERASA4TYR4dhmkn0tR9KRz+dDQkICVj+xFraR5yBscUB3ZyHU1gTRV4NJ194BYcrXo/o4LAJ+N9eNzDgR1c064mwCRrsljHCLGB3/5cuTJElYu3YtZFlGKBQa0DiJiIiIiIiIiGh4YLhNRDBNEy6Xa0DncLvduO6667BgwQIEBTv0FA9MuxuGeyQ0fwvCDQegTvkWjHEXRfWLl0XcN98NhxU40Koj2SkgI05EdpKETLeERYsW4bPPPkNeXh4Mw4AkdV7VTUREREREREREZx6G20QEXdeRmpqKnJycfvX3eDzIzMzExIkT4ff7j5UOscfDSM2FaXfDdI8Agi0wfHVQZ34PesY5Uf3T4yQ8cHkydAM4ohiYkOHGbbfchF1vv4h//uOvSEtLw8GDB6EoCtxuNxwOB+x2OwShh90niYiIiIiIiIhoWGO4TUTQNA2qqqKoqKhf/ds3emxra4uuiW2Ph5EyEaY9AaY7E4K/EUKgGaELfwAjeXzUOUa6TDy7/Dw8/Ne/41e//zMWzD4br760DtfPm4GxWWnIzs5GWloaPB4PVq1aBU3T4HQ6uZKbiIiIiIiIiOgMxXCbiAAAhmGgsLCwz+VJjt/o0TTNzg0cSTCTswFHEoy4VAhtR4FwAOpXbofhHhHVVGrYjYStf8WWioO4/ae/wKv//Bua6g7jnHQrbF9k2FVVVSguLkZWVhbKy8sZcBMRERERERERnaEYbhMRAEBVVciyjDVr1sQcFse60aMZlwYjcTQQlwbDkQTRVwvAROiS/4LpSIpufGgLGl+6D1X1fqi6ifHJElw24Ox0C6TjqpAoioL8/Hxs2rSJJUqIiIiIiIiIiM5ADLeJCMCxTSWDwSDy8vKwfv36Xldwu1wubNiw4dgGksFg16u2jz+/e8SxldruTBj2eIitNTAtdqgX/ydMa1xU2wXjbSia5cS+5mOrwbMTJcTbBExJs0S103UdixcvhqqqsNls/btxIiIiIiIiIiIakhhuE1GEruvw+/2YP38+ampqsGLFik6bTHo8HqxYsQI1NTWYN2/elxtIxsBMHA0jLg1wZ8G0xkFsOQTTmYzQV26DKUWH04vOsuP6s+3Y26TDKgnITpKQ5BCQmxK9qlxRFJSWlrI0CRERERERERHRGYbhNhFFaQ+4JUnCsmXLUFlZCa/Xi+rqani9XlRUVGD58uWQJKlPwXY7M2kcTGcSzISRMC12iC2HICSPgzT3v6AZ0W1vPNeJK3NkVDfrcFoFjI6XkOESMTYh+qWrpKQEsizDYole2U1ERERERERERMMXkyAi6sQ0TaiqCgAIh8NwOBxwOp0wTRM+nw+apvX/5IIAI2UiRLMSME2g5QCk1oNodY7CH99R8P++EgfxuPrZPzgvDopq4sOaMMYlSggZx4LtoAbUtR1LwysrK9HQ0ACHwzGwsRERERERERER0ZDBldtE1CNN06CqKoLBIFRVHZzwWBBhpOTAdCTATBgNQbQgXL8b7xwI4c/v+zs1/68L4zA5zYIan4GMOBHJDhGeFAmJ9i9DcEVRuKkkEREREREREdEZhOE2EZ0aogQj1QPTngAzaQzsdgcmJEt4ZY+KRz+JDrglUcDPL3Ehyy3C6zcwyi0iXhYwOc0Cp/VYG5fL1eumlkRERERERERENHww3CaiU0e0wEj1QLfGIW70FGSkp2N8koS124NYuz0Q1dQmCfjvy9yIswrwhUyMTZDgsgqYmmHFOZNykJKSAkmSuHqbiIiIiIiIiOgMwXCbiE4tyYpwUg400Y5zLrkakihgQpKERz8J4OXdalTTOJuAe+e5YZgmVN3E+GQJbhtw15KFaKyvRSgUgtPphCRJp+hmiIiIiIiIiIjoZGG4TUSnnsUGI+0sXHnNYtQErLBIxwLuP7/fhn/vD0U1TbCLuHeeG0rIhG6YmJQZh68vuAz/+N+7MWZUFsrLyxEXFweLpev9ci0WC2RZht1uhyzL3bYjIiIiIiIiIqLTG8NtIjotqIYA2+hpuOPnv0Z1iwmrJGBcooT73lGw5Ug4qm16nIR757nRFBSw5HtLYDbsw+svv4BxziCuWZiPsrIy2O32SHAtCALsdjucTifcbjf8fj/q6urg9/vhdrvhcDhgt9tZ0oSIiIiIiIiIaAhhuE1EpwXTNBHUgfPzl+DuX9+PmoAVNknAmAQJv3zTh51Htaj2o+IlrL5+Is6afjH+UrIKKaKCRFnA5BQBBYsXIxAIwOl0wmazwel0QtM0rFy5Eh6PB2lpacjOzkZaWho8Hg9WrVoFTdNY0oSIiIiIiIiIaAhhuE1Epw1d1xEImzjv6zfi78+ux7xrv4dRmenIcku4+3Uf9jVHB9xxaj2qn/gR3t62GzZJwPgkCUl2AWMcATxaWgq/3w+bzYa33noLWVlZKC4uRlVVVdQ5qqqqUFxcjKysYyVNGHATEREREREREQ0NLDZLRKcVXdfhNwQ4Rk7F1ddacM0116C1+jMENQO2+FTg3QcApT7SfoIrjJ9+xY173/ZhdIIF4xIlGAA2PrkKt91+O/x+P1577TUoitLjdRVFQX5+PjZs2IB58+bB7/fDNM0TfLdERERERERERNRfXLlNRKcd0zShSzJanaPxX3f/CmvK3sOHm9/GxheewQPb7GgIGFHtZ2VZcfscFw626IizCRgTLyHoPYD6yo/xwQcf4Oabb4Yo9v5yp+s6Fi9eDFVVYbPZTtTtERERERERERHRIGC4TUSnJUEQoKgGHnnhHTzxzDqUPP0S3n3zNeza/hnuKvehVY0OuC8abcPy85w43KojySFghEuCWrcHVZ+8g3HjxiEvLy+m6yqKgtLSUpYmISIiIiIiIiI6zTHcJqLTkmmacLlcaAub2FanoUU1sa9Zh8smAAB+Wu5DWyi6bMi8bBk3TXPgsE9HepyAOCGIwKHtqKvehdzc3JivXVJSAlmWYbGwchMRERERERER0emK4TYRnZZ0XUdqaipycnKghEx8Xq+hVTVR/UXAHdSBn73uQ1CLDrivyrHj2kkOSO50JIhBNNTsg3roc6S45ZivXVlZiYaGBq7eJiIiIiIiIiI6jTHcJqLThsVigSzLsNvtkCQJqqqiqKgIANCqHgu4W1QT+5t1JMgCWoMGfvmGgpAeHXBfO9mOJZdMgFcJoWnvZ4iTDLj9h2Dvw0JsRVEgCMJg3h4REREREREREQ0ihttEdEoJggC73Q6n0wm32w2/34+6ujr4/X7IsozCwkK4XC4AQItqYvsXAfeBFh2JdhF1bTp+828FuhEdcE8Kb8fuN9YgLikVifCh/lA1zkm3wBbjYmyXywXTNHtv2EfHB/gsfUJERERERERE1H8Mt4eR5uZmvPbaa3jyySfxyCOPYN26dfjoo49gGEbvnYlOAUmS4HQ6oWkaVq5cCY/Hg7S0NGRnZyMtLQ2zZ8+GIAhYs2ZNpERIU9DEjqMamoImDrYaSLKLONSq4/5322B0CKPPl6rwja9MQUNzC5r2bkW8LOCcdAssvbzyeTwepKSkQNf1QbnPngJ8t9sNh8MBu93OleJERERERERERH3AJYPDQHV1NR544AG8/vrrCIfDnZ5PT09HQUEBbr75ZthstkG//l133YXnn39+wOdZtGgR7rvvvm6fnzt3Lg4fPtyvc5eVlWHs2LH9HRqdAO3BdllZGQoKCqAoSqc2H3zwARYsWIA333wT69evj7RrCJjY6dUwKdUCwzQxNkHCnkYdD28J49aZ0XN8mvox3vp3EKZpYHzSsXZTMyz4tFaD3s3C7KKiIqiqCk3TBuU+7XY7VFXF6tWrUVJSgqqqqsjzOTk5KCoqQmFhIZxOJ4LB4KCF6kREREREREREwxlXbg9x69evx6JFi1BWVtZlsA0A9fX1ePDBB3Hdddf1Oxw+GZxO56keAp0k7SuZy8rKkJ+f32Ww3W7z5s1YuHAh5s+fj8OHD2PFihXIycmB129i+xcruENxGbix4Bv4/k9/D/XsxZ3OcZH4OTLiRIiCgPFJEhJkAedkWCB2sVDa5XJh6dKlgxIwtwf45eXlyMrKQnFxcVSwDQBVVVUoLi5GVlYWysvL4XQ6uZElEREREREREVEMGG4PYW+99Rbuuusu+P3+yGPjxo1DQUEBbrnlFlx55ZWw2+2R57Zv346ioqIeg8T+EEURkiT1+b+O8vLyYr6mIAh9uhbLPZxeZFmGqqooKCiIKUTeuHEjFi5cCIfDgaVLl6KyshJHjhzB5k8r8Oybn+Hhx57E5Isux6svv4CfPvQUntwe/UaPJAi48yIXkuwCrNKxgDvxixIlx88MSZKwdu1ayLKMUCg0oHvsS4APHNvAMj8/H5s2bWKJEiIiIiIiIiKiGLAsyRB19OhR3H777ZFgUBAE3Hnnnbjxxhshil++Z9HY2Igf//jH+OCDDwAAlZWVuOeee/DAAw8M2lh+97vf4Xe/+12f+uzYsQOLFi2KHI8cORKzZ8+Ouf8111zTYwkTOr2JoojVq1f36Y2WjRs34pJLLsGmTZvg9/uxa9cubN26FdXV1Ti0ezvqP/83csdloeDKPFx48VdhHnwPws4XI/2tkoCfXezCr97yQQgdC7j3NumYkmbB9qMa4lwurF27FgsWLIDf7x/wZpJ9DfABQNd1LF68GDU1NbDZbFBVdUBjICIiIiIiIiIazhhuD1ElJSXw+XyR4x/+8IdYsmRJp3bJyckoLS3FokWLsGfPHgDAiy++iMLCQpx11lknbbwdPffcc1HH11xzDVeqniEsFgtkWUZJSUmf+27evBnz58/H5s2bMWfOHFx22WVoaGiAoihwWU0khWoR9jXCbNwHddRsWFQ/LHtfj/SXLQLuuTQe97zRCggCshMljBw1Av/5X9fhG7fcBdluh9/vH5SSJP0J8IFjK7hLS0uxfPnyAY+BiIiIiIiIiGg4Y7g9BDU0NGDt2rWR4zFjxuDmm2/utr0sy/j5z3+Om266CQBgmiZWrVqFP//5zyd6qF0Kh8P417/+FTkWBCFqFTcNb5Ikwev1dqo9Hav3338fDQ0NcDgc8Pl8cDgccDqdME0TbX4bDEWB4MqC0HwQ2oSvAloQlgPvRfrLEnDv5elonV4ImyMOcckZ0FyZ0Jur4XePxsDWax8zkAAfOPbm1W233YZQKDQom1oSEREREREREQ1HrLk9BL366qtR9YAXL14Mq9XaY585c+YgOzs7cvzmm28iEAicsDH25M0330RTU1PkeNasWRg9evQpGQudfIIgDLjuu6IoEAQBmqZBVVUEg0GoqgpNcsBIzYVpc8FMGAmEA9A8V0IfOSt6DFoQ8VsfhdUiQW1tQKh+L7SmGqBx34DG1W6gAX5lZSUaGhq4sSQRERERERERUQ8Ybg9Br732WtTxFVdcEVO/49sFg0G88847gzquWD3//PNRx1y1fWYxTRMul2tA53C5XN3XxJZdMFI9MGU3zPhRgBZAePJC6COmRzUTwn5I//4jdF2DEFIAXw3EtqMQmqoHNDZgcAN8IiIiIiIiIiLqGsPtIeijjz6K/Dk1NTXmVc/Tp0eHex9++OGgjisWjY2NePPNNyPHDocDl19++UkfB506uq4jNTUVOTk5/erv8XiQkpLSc11se/yxgNvuhhk/Egi1IXz2N6BnTo1qJoTbIL+3EiYEiKoP8B2BqNRDaD7Yr7G1O+EBPhERERERERERMdweaurr66M2kpw0aVLMfSdPnhx13L7B5Mn04osvIhwOR47z8vIGHALS0NJeSqSoqKhf/YuKio6VIOmtFrU9AUbKxC9WcGcdC7jPWQw9fUpUMyHkOxZwCyLEQDPgq4XoOwKh5XC/xgecpACfiIiIiIiIiOgMx3B7iNm7d2/UcVZWVsx9U1NTo2pzdzzXyTBYJUl27dqF2267DXl5eZg5cyZmzpyJefPm4cYbb8RDDz2EXbt2DcZw6QQxDAOFhYV9fmPD5XJh6dKlsYe+jiQYqTkw7Qkw40cAIQXhqYuhp+ZGNRPUFsibV8EULRADTYBSD7H1MARfbZ/G1+6kBfhERERERERERGcwhttDTF1dXdRxRkZGzH0FQYhq3/FcJ1plZSW2b98eOR45ciQuuOCCfp1r586deOmll7B//34oigJFUXDo0CFs3rwZDz74IBYuXIjCwkLs379/sIZPg0hVVciyjDVr1sS8aaIkSVi7di1kWY7aULVXjiSYKRNg2hOPreAOBxA+9zroyROjmgmBJtjefximaIXobwDavBCbD0DwN/Tl1iJOWoBPRERERERERHSGYrg9xLS1tUUdx8XF9an/8e01TetbSDhAHVdtL1y48IRumPfWW2/hm9/8Jt54440Tdg3qH9M0EQwGkZeXh/Xr1/caALtcLmzYsAELFixAMBjscy1q05lyrESJPeFYDW49hPC518NIyo5qJ/obYPug5NgK7rajQLAFQuNeINjS53s8qQE+EREREREREdEZyHKqB0B9EwgEoo5lWe5T/47t29raYLPZBjyu3ui6jg0bNkSOBUHoV0mSjIwMzJs3DxdeeCFyc3ORkpICm82G5uZm7Ny5E+Xl5Xj++ecjwaDP58OPfvQjPPHEEzj33HP7Pf4TGcIPxPHjOl3H2B3DMBAIBDB//nzU1NSgtLQUDz/8MKqqqiJtPB4PioqKsHTpUsiyjEAgAMMw+nevcSkwRRFCw26Yogix9TBC026A7ZMnIDYfiDQT247C9lEpQjO/B9F3BIYoQWrYDSN9EmDr25tJqqri8ssvx/r161FQUABFUbpt63K5sHbtWuTl5cHv9wM4OX+nQ3kO0anH+UMDwflDA8H5QwPB+UN9Fcs8EQSB84liwtcgGgjOn84Es69LIOmUWrlyJf785z9Hjn/3u9/hm9/8Zsz9v/3tb+Ojjz6KHL/55pvIzMwc1DF25c0338TNN98cOZ41axb+8Y9/9Okc7733Hs477zxYLD2/J7N//3784Ac/QGVlZeSxkSNHYuPGjSclyKf+CYVCsNlsaGhoQFtbG+Li4pCSkhJ5fLCYgWaYdTthBluBpgMwDQPm5lKg+WB0w8RREOYUQhBEIDkbgiMBwohzIFjtfb5mOBxGMBjsMcAvLCyELMtRdfGJiIiIiOg0sH07cPbZPbf5/HNgypSe2xAR0aBjWZIhpuPK63A43Kf+HUsdnKywdzA2kpwzZ06vwTYAjB07Fo8//njUZpuHDx/GM8880+dr0snTPhdTUlIwZswYpKSkRD0+WARHIoSMyRDsCUDyOAiiCGH2EiC+w+aszYdgvlcKU9eOheCqArNuB0y9b//mAMBqtcLtduPWW29FZWUlvF4v9u/fD6/Xi4qKCtx6661wuVwMtomIiIiIiIiI+oBlSYYYp9MZdRwMBvvUX1XVqOO+1uzuj9bWVrz66quRY4fDgSuuuOKEXjMlJQX/+Z//idtvvz3y2EsvvYRvf/vb/Tpfc3PzII1scAmCgISEBABAS0tLn2tRn9EcoyAqFYAtDWLLQZhTr4Ptk79DbKv/sk3zQeibH0VoagGEYBBG4ligLQAjLRcQ+/fyGQqF4HQ6I/+WFUWBpmmRUiQnG+cQDQTnDw0E5w8NBOcPDQTnD/WV2NqK+F7atLa2wjhNf2+k0wtfg2gghsP8SUxMHNTzMdweYjqG230NxI7fkNJisfS5Znd/vPjii1ErxvPy8nrdQHAwXH755XC5XJE6x1u3bkUgEIDD4ejzuYbCi4VpmkNinKcNWxz0tFyIRytgJIyG0HLoixrcf4fo90aaiS2HYPv0aYTPKYDQfBAmBAj1u/odcIfD4S4/cWGxWCBJEgRBgGma0HUdmqYN6Bb7inOIBoLzhwaC84cGgvOHBoLzh2IRyxzhXKL+4LyhgeD8OYZlSYaYjIyMqOPa2tqY+5qmibq6um7PdaKsW7cu6rg/JUn6w2Kx4Jxzzokca5qG+vr6HnrQGccWByP9LJj2eJiJYwCbC6Fzb4DhTIlqJrYehvWztRDUFggtByAEWyEerQCMgYXPgiDAbrfD6XTC7XbD7/ejrq4Ofr8fbrcbDocDdrudm0QQEREREREREXWB4fYQM378+KjjmpqamPt6vd6oFaPZ2dmDNq7u7N27F1u3bo0cZ2Vl4YILLjjh123XXre5XVNT00m7Ng0RVieMtEkwZTfMpLGAPQHhLgPuQ7B+9gyE4OAE3JIkwel0QtM0rFy5Eh6PB2lpacjOzkZaWho8Hg9WrVoFTdPgdDohSdJg3C0RERERERER0bDBcHuIycjIgNvtjhzv3Lkz5r47duyIOp4wYcKgjas7HVdtL1y48KSuQg0EAlHHJ6MMCw1BVjuM9C8DbtORhPDU62E4kqOaiS2HYP3s2QEH3O3Bdnl5ObKyslBcXIyqqqqoNlVVVSguLkZWVhbKy8sZcBMRERERERERdcBwewiaOXNm5M9erxcHDx6Mqd+WLVuijs8777xBHVdHhmHghRdeiHrsG9/4xgm9ZkcdvzbJycndtKQznkU+FnDb42EmjYEZl4LwtBu6CLgPfhFwt/Yr4G4vRVJWVob8/PxITfjuKIqC/Px8bNq0iSVKiIiIiIiIiIiOw3B7CJo7d27U8csvvxxTv1deeSXyZ1mWcdFFFw3quDp67733omqCz5w5E2PGjDmh1zzekSNHolbDpqSkID09/aRdn4YgyQYj7SyYcgLMxNHHVnB3F3B/3r+AW5ZlqKqKgoIC6Loe07B0XcfixYuhqipsNlu/bo2IiIiIiIiIaLhhuD0EzZs3D1arNXL8zDPPRNXS7sp7772Hffv2RY4vvfRSOJ3OEzZGAHj++eejjk/WRpLtVq1aFbVr7EUXXcRVr9Q7yQojLRemzQ0zcSxMexLC07/dOeBuPtCvgFsURaxevbrXFdsdKYqC0tJSSJIEi8UCWZZht9shyzIsFkufb5OIiIiIiIiIaKhjuD0Epaam4lvf+lbk+MCBA3jkkUe6ba+qKn7zm99EjgVBwLJly7ptf+jQIeTm5kb+67hSPBaKoqC8vDxy7HA4cOWVV/b5PAAQCoWwd+/ePvV59tlnsXbt2sixIAi48cYb+3V9OgNJ1i9WcLtgJo6BKScgPO3bMBxJUc3E5gOwbX8OVi0Aq1IDS7itx4C7PZQuKSnp17BKSkogyzLcbjf8fj/q6urg9/vhdrvhcDhYtoSIiIiIiIiIzigMt4eooqIixMXFRY4ffPBBPP744zAMI6pdY2Mjli5dit27d0ceu+qqqzB58uQTOr6XX345ajPHBQsWwOVy9etcwWAQX//613H77bfj7bffhqZ1vzL26NGj+NWvfoWf/exnUY9fc801OPvss/t1fTpDWWzRAbc9AeHp34HZIeAWmqphbHkSIaUB9kAdZDMIe2s1BLNzyRFJkuD1ejttHhmryspKHD16FL/97W+RlpaG7OxspKWlwePxYNWqVdA0jRtPEhEREREREdEZg59lH6IyMjKwYsUKLFu2DIZhwDRN3HvvvXjqqadwwQUXIDExEfv378frr7+OYDAY6Tdx4kT893//9wkf37p166KOB7qRpK7rePHFF/Hiiy/C5XJh0qRJGD9+PBISEmC1WtHS0oJdu3bh008/7VSiZdasWSflnmkYssgw0s6CeHQnkDAKYqsAnP89mB/8FUKgKdLM2noQ+9b/AesPOjFjzmX4ytXfhlMUEUzIhm5+uZJaEIQ+lyPpqLm5OerfNABUVVWhuLgY99xzD9asWYO8vDz4/f6Ya3oTEREREREREQ1FDLeHsMsuuwz33nsvfvnLX0ZWSVdXV6O6urrL9pMmTcJDDz3U7xXUsTp48CA+/vjjyHFWVhYuuOCCQTu/oij48MMP8eGHH/ba9oYbbsCdd97JTfio/6x2GGm5sHorYXM4sPO9V/Dcq7W4ZZoVqc4vP/ziSbHgGsGPR//1T6zfsAHf/eHPMPNiEQH32EjAbZrmgP/9ud1u+Hy+Lp9TFAX5+fnYsGED5s2bB7/fH1V3noiIiIiIiIhoOGFZkiHummuuwXPPPYf58+dHbTJ5vLS0NNx6661Yu3YtRo0adcLHtG7duqhAbeHChQOqA2y321FUVITp06fHFFI7nU7k5+fj2WefxT333AO73d7vaxMBgGCLg23MNHywbRfuvP9h1LaoWPlhG7z+6DJAE5MtuHmGA04hhL+uuAcfv/0q7C37IiVKdF1HamoqcnJy+jUOj8eDzMxMVFRUdNtG13UsXrwYqqryTR0iIiIiIiIiGtYEk8v6ho2mpiZs2bIFtbW1aGtrQ2pqKkaPHo0ZM2YMmxq8mqZh3759OHDgQOQ+NU2D2+1GfHw8cnJykJubO+j329TU1HujU0AQBCQmJgI4Vq6C/5xPDLvdDk3TMGFMFsbHqXDZgAlJEtLjJCyb5UBaXPR829+sYfWWABTDht8/8jSEuCSoCdmAaIHT6cTKlStRXFzc53GsWLECixYtwoQJEzrV1++q7fLly+H3+3tsxzlEA8H5QwPB+UMDwflDA8H5Q30l7tyJhIsu6rFNyzvvwJg06SSNiIYyvgbRQAyH+ZOUlNR7oz5gWZJhJCkpCfPmzTvVwzihLBYLcnJy+r3ylag/RFHE6tWrcbRZQasPOCfDgt2NOgwTePgjP4pmOZF+XMA9NtGCW2Y68cgWP97+15O4bNF/QDxaASMtF4ZhoLCwEPfcc0+f6m+7XC4sWbIE9913X6/BNgCUlJTgtttuQygU6nETViIiIiIiIiKioYplSYiIemCxWCDLMkpKSgAAqg58WquhWTWxp0lHjWKg5CM/6pTozRtHJ0i4ZaYTn7//Biyth2EJt0E8WgE10AZZlrFmzZqYP2EgSRKeeuophMNhPProozH1qaysRENDw7D51AYRERERERERUUcMt4mIeiBJErxeL6qqqiKPhY1jAXdTwMTeRh2HWw2UfOzHEV90wD0qXsK14/zw1++H2HIQQrAVQv0uBP0K8vLysH79+l43mHS5XFi3bh3mzZuH/Px8eL3emMeuKMqA6t0TEREREREREZ3OGG4TEfVAEIQuy4foJrCtXkNDwMTeZh2HWgw88rEfNR0C7iy3BOunT0FoOwqh5QCEYCvM2h3wK62YP38+ampqsGLFik6ldjweD1asWIGDBw9i9uzZmDt3LjZv3tynsbtcriFZf4uIiIiIiIiIKBYMt4mIemCaZrerqw0T+Lxew9E2A/tadBxoNfCXj/w41BodcEvBRohb/g5Bqe8UcEuShGXLlqGyshJerxfV1dU4cuQIKioqcOutt6K0tBSTJ0/uc7Dt8XiQkpICXdd7b0xERERERERENAQx3CYi6oGu60hNTe12E1MTwA6vjjrFwP4WHQdaDKze4sfBluhQWfA3wLb1SYi+ui8C7hYI9bugBtoQCATg8/ngdrsRHx+P++67D1/72tdw5MgRiKLYp1Ik7YqKiqCqKjeTJCIiIiIiIqJhi+E2EVEPNE2DqqooKirqsV1Fg46aVgMHfTr2NR0LuA90DLiDzbB++iTE1iMQmg9CCLZArN8F6GFomgZN06DrOv70pz/hpZdeQklJCZYsWdJrXe6OXC4Xli5dylXbRERERERERDSsMdwmIuqFYRgoLCzsNWTe3aTjYIuBGkXHniYdf/tcgxE/MqqNEGz5IuCugdB8AILaCvFoBaCHO60SLy0tha7rePLJJyFJUkxjlSQJa9euhSzLCIVC/bthIiIiIiIiIqIhgOE2EVEvVFWFLMtYs2ZNryHzvmYd+5p0HA0IWLjkxxBm3NA54FZ9sG79B8Tmg18E3C0Qj+6CpvqjVol7vV5cffXVmD9/Pp5//vlew3WXy4UNGzZgwYIFCAaD3EySiIiIiIiIiIY1httERL0wTRPBYBB5eXlYv359ryFzk+HEz1c8iqlz5iIUPxqhc74FI2F0VBsh3HZsBXfTfghNX67gNsJq1CrxzZs3Y+7cuZgzZw4OHDiAFStWdKr/7fF4sGLFCtTU1GD+/Pnw+/0sSUJEREREREREwx7DbSKiGOi6Dr/fj/nz56OmpqbXkPkrV12LgHMkdDkBZvJ4hM6+FkbSuKj2ghY8FnA37o0E3OFDn0K2iFGrxDdv3oxJkybh/vvvx6JFi1BZWYkjR45E/l9RUYGlS5fC4XDA7/dDEATIsgy73Q5ZlmGxWE7Wl4mIiIiIiIiI6KQRTH5unahXTU1Np3oIXRIEAYmJiQCA5uZmlqE4CQRBgM1mgyiKsNvtaGhogKIocLlcSElJgaqq0HUdoVDo2N+HvxFiw24Iqg9C0z5Yd6yD1LAn6pymaIF29rXQUz0wk8ZAcCbBPnYGNr36OgoKCqAoSqStKIrIy8tDbm4u3G43QqEQrr32WkyfPh2apkWCba/XGxlXampqpEyJqqpR84RziAaC84cGgvOHBoLzhwaC84f6Sty5EwkXXdRjm5Z33oExadJJGhENZXwNooEYDvMnKSlpUM/HldtERH3QHhAHAgH4fD44HA6kp6fD4XDA5/PB7/dHB8jOZBipOTDt8TCTxiM8+ZvQU3OjzikYGiyfPQOpfgeEpgMw/U0I7t+C+V+9tNMqccMwsHHjRrz88stITk7G3XffjWnTpsEwDITDYaxcuRIejwdpaWnIzs5GWloaPB4PVq1aBU3T4HQ6Y96ckoiIiIiIiIjodMaV20Qx4MptGrBgK0RvJYSQAqGpGtad/4JUvz2qiQkB2qR86FnTYCaOBuwJsIycCtEqd7tK3DRNWK1WvPLKK51WeXfkcrmwZs0a5OXlRepycw7RQHD+0EBw/tBAcP7QQHD+UF9x5TYNJr4G0UAMh/nDldtEREORPR5G2lkwZTfMpGyEJ+VDH3FuVBMBJiw710M69CGE5oOQwgqE+p0wtRCCwSDi4uKiVokHAgGIoohXXnkF+fn5PQbbAKAoCvLz87Fp0ybY7XYIgnAi75iIiIiIiIiI6IRiuE1EdLLIrmMBtz0eZvI4hHO/Dm3krKgmAkxYK16C7dD7sAfqEWw+isadb0NpbowE0oIgQNd1yLIMVVVRUFAAXddjGoKu61i8eDFUVYXNZjsRd0lEREREREREdFJYTvUAiIjOKLY4GGmTIB7dBSSNg5ZzBSBaYDm4OaqZWLERr762Cf/8tBF7mnT4QoDfPRZLCpehsLAQTqcTpmli9erVva7Y7khRFJSWlmL58uWDeWdERERERERERCcVV24TEZ1sVjuM9Ekw7W6YyeOg5eRBz764U7OvjtRxda6MickWJMiAS9mPX9z1n8jKysKnn34KWZZRUlLSryGUlJRAlmVYLHyPk4iIiIiIiIiGJobbRESngkX+IuBOgJk0DuKkK1GfNK1Ts8sn2PHNSTJyki1IkAWcm2mBGG7D008/jaNHj6Kqqqpfl6+srERDQwMkSRrgjRARERERERERnRoMt4mIThXJBiP9LFgT0hB2jcTv1r6PZ3cEOjW7bJyM6862IydZQpJdQuHVF+GKS2ajtbV1QJfvazkTIiIiIiIiIqLTCT+PTkR0KokWiJlT8MyDv8KO2jYEVQlhAyiYYocoCJFmF4yyYezITDhnfxtJE2YgYFqhWrUBXdrlcg109EREREREREREpwxXbhMRnUIWiwWyw4nfPfocGgMm9jbpeGNfCP/3aQBh3YxqO0JohP7RP/CHO2/BA7+5G0m6FxeeM6Ff1/V4PEhJSRmMWyAiIiIiIiIiOiUYbhMRnUKSJMHr9aKicjc+q9fQEDCxt1nHuwfD+OtWP0JGdPtkoxGLxvoRPPQ5jlbvwo++/XWMSej7S3lRURGCwSAcDgdCoRAAQDhupTgRERERERER0emO4TYR0SkkCEKk9rUJ4PN6DV6/gX3NOna12mFM/zZ00RbVZ3ySBTfPcOCTTWtx5SWzMGmEC+OTYt8Y0uVyYcmSJfjlL38Jj8eDhx56CD6fDw6HgxtMEhEREREREdGQwXCbiOgUMk0zqva1CWDHUR1H2wycc8lVMDOnYOWHClqC0Uu4R8VLODe0FcLRCvzmjlsxJtEKT3LvwbQkSXjqqacQDofx6KOPoqqqCsXFxcjKykJ5eTmcTicDbiIiIiIiIiIaEhhuExGdQrquIzU1FTk5OZHHTAC7Gk18veB7ePmdbfjoQAAPf+SH1x8dcKc6BITffRRnp1vwP3f/BNnpcZicKqG74iIulwvr1q3DvHnzkJ+fD6/XG3lOURTk5+dj06ZNsNvtLFFCRERERERERKc9httERKeQpmlQVRVFRUVRj+fl5WHkuZfiL0//CzWKjk/rNDz8URuOKHpUO7fVgPr2angSwnjmkQdwz3/+AFfOGh8VcHs8HqxYsQIHDx7E7NmzMXfuXGzevLnTWHRdx+LFi6GqKmw2W6fniYiIiIiIiIhOJwy3iYhOMcMwUFhYGFWe5KyzzsKRI0fw+tY92N2o46jfwLY6HQ9/6MeBluiA22kxgY+ewNaX/w+Xnjse659+HA0738be3VU4cuQIKioqsGjRItx3332YPHlyl8F2O0VRUFpaytIkRERERERERHTaY7hNRHSKqaoKWZaxZs2aSKjscrng8/kAADU+AzuOamgIGNhWr+HhD9tQ1ahFncNuETATFXjhoZ/jhcf/hHiLjneeL8Xv7/sdrrzySkyYMAH3339/VCmS7pSUlECWZVgslsG/WSIiIiIiIiKiQcJwm4joFDNNE8FgEHl5eVi/fj1cLhcURYHb7Y608fpNfFanoTlo4rN6HSUf+bG9Phx1Hqsk4D/OtWNU+ABa9n2Kv65cgTfWPIzyso0wDKPjZbtVWVmJhoYGrt4mIiIiIiIiotMaw20iotOAruvw+/2YP38+ampqcMkll2DEiBFRG022qCY+rdXQGjKx06th9ZYAPq6JDrglUcB06wFIe17DhCQJSXYB52ZYYOtjTq0oCjeVJCIiIiIiIqLTGsNtIqLTRHvALUkSrrzySoRCoU4bTbaFTXxyJIyWoImKBg1//cSPdw6EOp3Lefg9FExxYGKyhES7gOmZVjitsY/F5XLBNM2B3hIRERERERER0QnDcJuI6DRimiZ0XYdhGBBFEcuXL8eiRYsgil++XKs6sLVWQ1PQRFWjjie2BfDKHrXTuS4dZ8OSaQ6clWpBgixgWqYVCXLvq7E9Hg9SUlIAALIsw263swY3EREREREREZ12GG4TEZ0GBEGA3W6H0+mE2+2G3+/HoUOHoCgKnnvuOezZswd33XUXUlNTAQBhA/j0i4B7T5OOZ7cH8dzOAIwOq61nZtlw8wwHpqQdW8F9ToYFac6eA+6ioiKEQiE4nU74/X7U1dXB7/fD7XbD4XDAbrezZAkRERERERERnXJchkdEdIpJkgS73Q5VVbF69WqUlJSgqqoq8nxOTg6Kiopwxx13oLi4GFdffTU2b94M3QS21WmYnCbBBFC+X8AFl1yELO/7gKlH+k9Ks2LZeQIe3RLArgYdk9IskJt0HGrtvMmky+XC0qVL8f777+Nvf/sb3G53ZINLn8+HKVOmYOnSpXA6nQgGg9B1vdM5iIiIiIiIiIhOBobbRESnkCRJcDqdKCsrQ0FBARRF6dSmqqoKxcXFuOeee/D000/jtddew9y5c7F582aYAMJJ43FT4WIsvvIyWANehKvHwvL5PyHoX9biHpdowa3nO1G6xY8dR489JksC9jR9GU5LkoTnn38egiBg3LhxKC0txZEjR+Dz+eB2uzFixAg0Njbiww8/xKhRozBhwgS0tbUx4CYiIiIiIiKiU4JlSYiITpH2UiRlZWXIz8/vMtg+nqIoWLhwId544w28+eabOHDgALxeLyoqKnHDD+6GkJCFoJwELWsGwudeD9MWF9U/0yXh1vPiMH2EBaPcEkbGizgrRQJwbMX2W2+9hUsvvRThcBjPPPMMPB4Ppk6disceewyh0LGgXNM0jB8/HsnJyZEV5yxTQkRERERERESnAsNtIqJTRJZlqKqKgoKCmFc/67qOxYsXQ1VVZGZmwuFwwOfzwR8IQI0bAcM9EnClQ8+civC0bwOO5Kj+SQ4Ry2Y5MXOEBeMSJMw8awz+9vuforbmMM4//3y88sorGDNmDIqLi5GamoqdO3fijjvuwD//+U94PB5kZGQgOzsbaWlp8Hg8eOihh6BpGpxOJyRJOhFfJiIiIiIiIiKiLrEsCRHRKSKKIlavXt3riu2OFEVBaWkpli9fDlVVo54zE0bCECWIACTZjpBFRsOmBzHiuEXcLpuIH8xJQDD3asR5voKwMwNoqMTGbYdwzTeuha7rmDNnDl599VWUl5fjhhtu6LVcypo1a5CXlwe/388yJURERERERER0UnDlNhHRKWCxWCDLMkpKSvrVv6SkBLIsw2Lp/B6l6c6EkZwNwZWKTZ8exIObW1HVoEW1EQwN8o7nse2FlbAqNQg11+H3t98I0dSRmpqK9evXo7y8HIsWLYqpXEp+fj42bdrUqURJ+33a7fZux0tERERERERE1B9MGYiITgFJkuD1elFVVdWv/pWVlWhoaIDD4YCmaZ2elxJGwJaUjLUbytDi1fHIx358Z6oD52ZaI21EATgbe2HseBFVwUzIporpI6zI++5NkCQJN9xwQ5/LpdTU1ECW5WPnF0XIsgyv1wtFUeByuZCamopgMAjTNKGqKkzT7Nf9ExERERERERFx5TYR0SkgCEKfy5F0pChKtxs5SpKEhgDw0sfVaA6a2OnVsbZKxAEjrXPjPW9iqlCFJ//4K9zyH9fh1m9cir//taTf5VIkSYKmaVi5ciU8Hg/S0tKi6nSvWrVqwHW6uSKciIiIiIiIiBhuExGdAqZpwuVyDegcPfVvD89bVBNba8MYnTMFP33gUaTPX479lnGdOxzaAv2j/0PB3GlIi5fxzj9XI9nRdXDek5KSEthsNtx4440oLi7utDK9vU53VlYWysvL+xRwC4IAu90Op9MJt9sNv9+Puro6+P1+uN1uOByOTmVRiIiIiIiIiGj4YrhNRHQK6Pqx2tY5OTn96u/xeJCSkgKLxdJlOHx8eH7urDl48NnXsa3qAAqW34XfPv8pntkegN6hJEiK0YC2N1ZC2b0Zbd7DmJJmQaarb98mKisrUVtbizFjxvTYrqc63V2RJAlOp/OErwgnIiIiIiIioqGD4TYR0SmgaRpUVUVRUVG/+hcVFWH//v3YtGlTl2Fue3h+/vnnH9sc8vW3sOC7P8HBBj/2Nut4qSqEx7cGoGrRAXeS0Ab5k7/jvCwr0pwiPCkSxiX27VuFz+eD2+3utV17nW5VVWGz2bpt1x5sl5eXIysra9BXhBMRERERERHR0MRwm4joFDEMA4WFhX0uT+JyubBkyRI8/PDD3a5+bg/P/+d//ieyOWRY0/H5UQ1HfAYO+nS8Xh1Cycd+tKpG1PkltQU/mO3ERaOtGOGSMCZBQm5K7EGx2+2Gz+eLqe3xdbq70l6KpKysDPn5+b3WAe/rinAiIiIiIiIiGroYbhMRnSKqqkKWZaxZsybmVcaSJOGpp55COBzGo48+2uPqZ8MwcP755+Oxxx6LCoWrGnVUN+uoVQy8dzCMhz7wo07Ro/q6bSJumeXE3GwrxsRLyHSJmJpugdRLVuzxeJCZmYmKiorYvgg4Vqe7u00hZVmGqqooKCiArutd9O4s1hXhRERERERERDS0MdwmIjpFTNNEMBhEXl4e1q9f3+sKbpfLhXXr1mHevHnIz8+H1+sF0P3qZ13XIcsySkpKOp3rQIuBygYdR/0GPj4SxkMf+rGvSYtqY5ME3HiuA1fl2DA+SUKyQ8C5mRbYesjhi4qKUF1djbKyshi/CsfqdDc0NHQZ8IuiiNWrV/e6Yruj3laEExEREREREdHQx3CbiOgU0nUdfr8fCxYsQE1NDVasWNFpk0mPx4MVK1bg4MGDmD17NubOnYvNmzdHtWlf/SzLcuQxURTh9Xo71aduV6sY2HFUQ1PQxGf1Gh7+yI9tdeGoNqIg4NrJDnxrsh05yRKS7AKmZ1oRZ+28hLu9XEpJSQkMw+j0fE8URelUQsRisXQbzseipxXhRERERERERDT08Td+IqJTTNd1hMNhiKKIRYsW4bbbbkNtbW1kY8bMzExUV1fjvvvuw6OPPhpZsX28yspKeL1eJCUlQdM06LoOQRB6XfHcEDCxrU7D2ekW7Diq469bA7h+qoTZI6Lf+5w/XkaiXcCTnwdR1aBjWqYlEowD0eVSqqur8ZOf/AQulwuKomDXrl0oKyvrMfB2uVwwzejNLSVJ6jGc7037inCHwwFN03rvQERERERERERDCsNtIqLTgCAIqK+vx4QJE5CXl4fc3NzIxowVFRW9hsMA0NTUhMbGRowbNw5+vx+maca0WWWramJrbRhTM6yobNDwf5/4oFsycWFaIKrdrCwbEu0iHvskgJ3eY4F4VaMOBU6sXbsW8+bNQ0NDA55++mkcOXIkEs6PGDEC1dXV+Mtf/oLS0tJO4bzH40FKSkqnTShjCed7oygKnE7ngM5BRERERERERKcnhtvDSHNzM7Zs2YLa2looioL09HSMGjUKM2bMgCgOzwo0Bw4cwI4dO1BbWwvDMJCRkYGcnBx4PJ5TPTSiPmkPog3DwMaNG7Fx48Y+n8PtduN///d/cffdd8Nms0HXdaSmpiInJ6fX1c/+MPDJkTDOTrdAN3T83/u1MC+ZiIsSGgDzy1B9YrIFP5rtxKOfBFAvpuEHt16Dq64vhJwxEWoohKeeegolJSVR18vJyUFRURHuuOMOFBcX4+qrr44qq1JUVARVVTutro41nO9JVyvCiYiIiIiIiGh4YLg9DFRXV+OBBx7A66+/jnA43On59PR0FBQU4Oabb4bNZjshY/jud7+LDz74oF99H3vsMVx44YV96vPWW29h1apV+OSTT7p8Pjc3F4WFhbj66qv7NSaik60vQXRXPB4PMjMzsW3bNpSWlmL58uVQVRWqqqKoqAjFxcW9nkPVga21x1ZkG6aOQOYsGGclQ9z2T0ALRtpluCT8dG46xBnXQc88F5LagA9e/hBXfOcH8HWx0rqqqgrFxcW455578OSTT+K1116L1A13uVxYunQpdF0/IV+TrlaEExEREREREdHwMDyX855B1q9fj0WLFqGsrKzLYBsA6uvr8eCDD+K6667D4cOHT/IIB5dpmrj33ntx8803dxtsA0BFRQX+8z//E8XFxQiFQidxhET9o2laJIjuj6KiIlRXV6OsrCxqI0XDMFBYWBjzCmjdBLbVaVBMOy65+gYYI2cidO4NMO0JUe2EsB/Gh3+DsPdNfPb2y7j7tiJMiAvC0sN3FUVRsGjRIrz66qvYsGEDMjIysHbtWsiy3OW/08H4mnS1IpyIiIiIiIiIhgeG20PYW2+9hbvuugt+vz/y2Lhx41BQUIBbbrkFV155Jex2e+S57du3o6ioaMA1bGMhSVLM/wmCEPN5//jHP+Lxxx+PKjMwY8YM3Hjjjfje976HCy+8MOp8//rXv/CLX/xiUO+N6ETpaxDdzuVyYcmSJSgpKYFhGJGNFCVJgqqqkGUZa9asgSRJMZ1PlCT8+uGnYU0bh7AjBXrmOVCnfQeGOyuqnWDoED57Doc2PYLsRCDZIWB6pgWOHj4TpOs6rr/+elgsFrz55ptYsGABgsFgt6VDBvI16W5FOBERERERERENDyxLMkQdPXoUt99+eyS4EQQBd955J2688cao+tqNjY348Y9/HCkZUllZiXvuuQcPPPDACRvb+eefjyeeeGLQz/vmm2+ipKQkchwfH48///nPmDNnTlS7HTt2YNmyZaitrQUAPP/885gxYwYWL1486GMiGkyqqsLpdGLNmjXIz8+PKZiVJAlPPfUUwuEwHn300cjj7RspmqaJYDCIvLw8rF+/HgUFBT2+weVyubB27VosWLAAfr8fRoIOwQQgnoXQudfDumsDJG9lVJ8rxluQYHXg6e1B7GnUMH2EFdvrNbSoXQfWiqLgsccew6233gq/39/jffb3a9K+Ivz4N/+IiIiIiIiIaHjhyu0hqqSkJKqO7A9/+EMsWbKk08aRycnJKC0txYQJEyKPvfjii9i1a9dJG+tgME0zKpAXBAGrVq3qFGwDwOTJk/H4449DluXIYw8++CBUVT0pYyXqr/Yg+vLLL8f69et7Xa3scrmwbt06zJs3D/n5+fB6vVHPta+G1nUdfr8f8+fPR01NDVasWIGcnJyoc3k8HqxYsQI1NTWYN29eJHQ23RkwUnNgOhJhpuZAP+dbwNgLOo1lzmgbls1y4px0CxLtAqZmWJAe1/23mJKSEthstl4/udExnI/la7Jhw4ZeV4QTERERERER0dDHcHsIamhowNq1ayPHY8aMwc0339xte1mW8fOf/zxybJomVq1adULHONheffVVVFRURI4XLlyI8847r9v22dnZ+P73vx85rq+vxzPPPHNCx0g0GHRdRzAYxIIFC3DgwIEeg+iDBw9i9uzZkc0Zj38+JSUlapVze8AtSRKWLVuGyspKeL1eVFdXw+v1oqKiAsuXL4ckSZ1XUzuSYKRPAuzxsGaehR2YgM+00TARHUyflWrBXXMzsPgruUhzSjgrVcLYhK6/zRxfOiWWr0l/w3kiIiIiIiIiGr4Ybg9Br776atTma4sXL4bVau2xz5w5c5CdnR05fvPNNxEIBE7YGAfbyy+/HHX87W9/u9c+1113XVRwtnHjxkEfF9GJEAqFYBgGPv/8cyxatAiVlZU4cuRI5P8VFRVYtGgR7rvvPkyePDkq2Aa630jRNE2oqopAIACfzweHw4H09HSkpKQAAAKBAFRV7Xq1sy0O1jEzELI48P9WlKLGkYPQ5GtgitGvPQliADeMD2D1PTfjlhuuwdSxyTgrRUJX67MVRYm55v7x4fzy5cv7Fs4TERERERER0bDEmttD0GuvvRZ1fMUVV8TU74orrsDDDz8MAAgGg3jnnXcwf/78QR/fYNM0Df/+978jxyNGjMDUqVN77ZeRkYFp06bh448/BgBs2bIFTU1NSEpKOmFjJRoshmFg2rRpGDVqFC688ELk5ubC7XbD5/OhoqICZWVlMAyjU79YN1LUNA2apkEQBDgcjpjGJNocKNmwGSmjJuKr37gJaKnBJ7sPYKLyMeJtxzVUfXBufwbXnJOPr11+L356/4OQt+zA9qMatOOGfHzplN4IggBZliGKImRZRktLCwRBQGpqKuLi4iJvCIRCIZYiISIiIiIiIjpDcOX2EPTRRx9F/pyamorRo0fH1G/69OlRxx9++OGgjutEqaqqQktLS+S44330ZNq0aZE/67qOLVu2DObQiE4YVVUhyzKeeuopbNq0CX/605/wm9/8Bn/605+wcePGLoPt4zdSPP7THYPBYrFAlmVs/uBD/GXdW/hg5358c+mPsWLNq/jzZh8Ot0aH6RIMWHesQ9uHT2PFz36Ei2ZMxrRMC+xfvKXaVemU7kiSBKfTCU3TsHLlSng8HiQmJiIlJQUulwsejwcPPfQQNE2D0+mMqdQJEREREREREQ19DLeHmPr6+qiNJCdNmhRz38mTJ0cd79mzZ9DGdSJ1HGdf7nnKlCk9novodHW6baQoSRIaGhqwcuVKlL/6GhZcvwy7jiioVQxsq9ex8sM27DiqdeqX1vI5lLcewb23LcG4jETMGGFFgiygqKgoEsC3B+d2ux2yLMNisURd1+l0ory8HFlZWSguLkZVVVXUNaqqqlBcXIysrCyUl5cz4CYiIiIiIiI6QzDcHmL27t0bdZyVlRVz39TU1Kja3B3PNVhqampw55134qqrrsJ5552H6dOnY+7cubj++uvxwAMPRMqExGog9zxixIio43379vXp2kSn0um0kaIgCBBFEZIk4YYbboCu69jfYmCXV0eD38AOr47SLX78e7/aqW+Cfz/krU9gyRUzkWgXMHucG99f/DUAgM1mg9vtht/vR11dHfx+P9xuNxwOB+x2O+x2O8rKypCfnw9FUXoco6IoyM/Px6ZNm2C322Ou501EREREREREQxNrbg8xdXV1UccZGRkx9xUEARkZGTh06FCX5xoshw4dilyjnd/vx+HDh7FlyxY88sgjmD59On72s5/hnHPO6fV8HceZmZkZ81g6tq2trY25L9HpoD3gttlsWLZsGW677TY0NDRAURS4XC6kpKRAVdVIuxNVb9o0TTgcDqxatSoqZK5vM6BqJqakW1DZoGHtDqDeb+KaXBmS+GW4LLYexlynD5+NlXH1LXfD3nYEqqZi9bNlKPnLX6JWY+fk5KCoqAiFhYWwWCx44IEHYg7sdV3H4sWLUVNTA6fT2eXGmkREREREREQ0PHDl9hDT1tYWdRwXF9en/se31zRt0OvyxuqTTz7B9ddfj2eeeabXtgO5545t/X5/zH2JThemaUJVVQQCAfh8PjgcDqSnp8PhcMDn88Hv90NV1RO+kaLdbkdJSUmnx1tUE58cCaMpaKKqQcOmvSpKPwnAH44ej6S24icXJiBHrMFn75bhW1d8BY///i7s3d19mZGysjL861//wgUXXBDzOBVFQWlpKQzDiFoFzpXcRERERERERMMLV24PMYFAIOpYluU+9e/Yvq2tDTabbcDjAoDExETMnTsXF198MXJzc5GRkQG73Y7W1lZUVVXhjTfewNq1ayOrPsPhMH7xi18gKSkJ8+fP7/a8He+5L+PteL/9DbdP11Ds+HGdrmOkwaXreqdVzAP5u491DgmCAK/X26nedbuABnxSq+HsNAt0U4emAy1BAzdNcyA97sv616IRhvnJU6iuVJElh6A6BEwfYcH2eg2BDgusFUXBwoULsW7dOmzYsAGTJk2C1+uN6b5KSkpw2223YenSpZg8eTIKCwsjK7lPRNmWMxVfg2ggOH9oIDh/aCA4f6ivYpkngiBwPlFM+BpEA8H50xnD7SEmGAxGHfc1mO7YXlU718ftjx/96EeYOnVql2F7cnIyZs+ejdmzZ+P73/8+brvtNnzwwQcAAMMwcOedd6K8vBxJSUldnnsg99yxbcdzxSoxMbFf/U6mhISEUz0EGuJ6m0P19fU9Pq8ZwKd1Gs5KlWACCOnAyg/9+PY5DnhSvvx2IwDI98hIcwh46vMA9jTpmD7CigqvhoZA9GpvXddx/fXX4+DBg/j+97+P+++/P6Z7qaysRG1tLVwuF4qLi3HPPfdgzZo1uPzyy7nZ5AnC1yAaCM4fGgjOHxoIzh+KSXx8DE3igSHweyOdXvgaRAPB+XMMy5IMMR3D43A43Kf+HcuQDNaq7fPOOy+mVeSpqal45JFHMHny5MhjiqJg9erV3fYZyD13vN++rnQnoi/FUhLIBLDTq+Ngi4EaRceuLzaafO9Q5xJIc0bb8IPz43BuhhXJdgFT0i0Ym9D525KiKHjsscdQVFQEUYz925bP54Pb7Y6cIz8/H2VlZX1+3SQiIiIiIiKi0xNXbg8xTqcz6rivK5E7rtTua83uweBwOHDPPfegoKAg8thLL72EO+64o8v2He+5L6vNO7bteK5YNTc396vfiSYIQuSdupaWlhNec5mGn1jnkMViQWpqKnJycrotTXK8fc06ApqJnGQgrJt4vd6NC+d/FeaujVHtPCkW/PgCJ/62NYDP6o+VC3HbROz0atCPG0p7mZG8vDxs3Bh9ju643W74fL7I8fGbTWqaNmifXDmT8TWIBoLzhwaC84cGgvOH+kpsbUVva7dbW1thnKa/N9Lpha9BNBDDYf4MdnUEhttDTMdwtq81pI/fnNFisZyylczTpk3DxIkTsXv3bgDAkSNHUF1djXHjxnVq2/GeO24w2ZOObfsbbg+FFwvTNIfEOOn01dMcCofDUFUVRUVFKC4ujul8tYqBoGZicpoFZ19yNbSx5+BvTz2PG86xw275sjZYRpyEH54fhyc/C+D9w4Ak6HBYLdh+VIP/i0XW7WVGcnNzYwq3PR4PMjMzUVFREfV4+2aTy5cv57+XQcbXIBoIzh8aCM4fGgjOH4pFLHOEc4n6g/OGBoLz5xiWJRliMjIyoo5ra2tj7muaJurq6ro918k2bdq0qOOampou2w3knju2zczMjLkvEUUzDAOFhYVwuVwx92kOmtjtk3H5NYsRihuJD2tCeOiDNjT4jah2DquAJdMdyM+V4UmxIMkuYnqmFanOL0Pw48uM9KaoqAjV1dUoKyvr9FxJSQlkWYbFwvd3iYiIiIiIiIYyhttDzPjx46OOuwuEu+L1eqNqzWZnZw/auPojJSUl6ripqanLdgO55yNHjvR4LiKKnaqqkGUZa9asiXlTRkmS8PiTa2EbMwNhqwt7Go/V4X7owzbsbtSi2oqCgK977LjpXDsmp0lIcQiYnGbBuMRj36o6lhnpjsvlwpIlS1BSUgLDMDo9X1lZiYaGBm4sSURERERERDTEMdweYjIyMqJWLu7cuTPmvjt27Ig6njBhwqCNqz8CgUDUcXclUjqOsy/3vH379qhjhttE/WeaJoLBIPLy8rB+/fpeV3C7XC688MIL+OpXv4qf3n0PkidfAnvqaFS36NjdaGD1Fj/eOdh5o8mZWTbcep4T0zItGOGSMCZBwlWzJiAjLbVTmZGOJEnCU089hXA4jEcffbTbdoqiQBCEbp8nIiIiIiIiotMfw+0haObMmZE/e71eHDx4MKZ+W7ZsiTo+77zzBnVcfdVx3MnJyV2283g8iI//cvuOTz75JOZrHN9WkiTMmDGjj6MkouPpug6/34/58+ejpqYGK1asQE5OTlQbj8eDFStW4ODBgzj//PPx1a9+FX/84x9x4OBBLLh+OfY36zii6NjbZOCfO4J4ZkcAuhFdJ2xsogU/PD8O52dZkJ0g4cZrv4YjW8rw1mudy4y0c7lcWLduHebNm4f8/Hx4vd4e27I2GREREREREdHQxnB7CJo7d27U8csvvxxTv1deeSXyZ1mWcdFFFw3quPoiEAjgww8/jBxbLBZ4PJ4u21osFlxyySWR4yNHjuDTTz/t9Rp1dXXYunVr5Hj69OndBuhEFLv2gFuSJCxfvhyVlZU4cuRI5P8VFRVYtGgR7rvvPkyePBmbN2+GYRgoKSnBku99Dw26E7u8OhoCBvY06Xj7QBh/+dgPJRRdQiTBLmLZeU5cmevE1+dMRkqchEd//RPMmjIxqt3xYfrs2bMxd+5cbN68udvxezwepKSkQNf1E/L1ISIiIiIiIqKTg+H2EDRv3jxYrdbI8TPPPBNVS7sr7733Hvbt2xc5vvTSS+F0Ok/YGHvzt7/9DYqiRI7PPffcHkscXHHFFVHHTz75ZK/XePrpp6Pq7XY8BxH1n2maUFUVgUAA4XAYjY2N+Pvf/4777rsPV155JSZMmID7778/avV0aWkpdF3Hk08+iYaggG11GpqCJiobNHxWr+HP7/txuDU6cLaIAr6Ra4Wl4kWYdZW45vLL8P6Gx9Gwdxv27t3bbZjek6KiIqiqCk3TemxHRERERERERKc3httDUGpqKr71rW9Fjg8cOIBHHnmk2/aqquI3v/lN5FgQBCxbtqzb9ocOHUJubm7kv44rxTvqrQZuR2+//TYeeuihqMduuummHvvMmzcvamX3Cy+8ELXyu6N9+/ZF1dtNS0uL+poR0eAwTROBQAAejwezZ8/Go48+io0bN3a5kaPX60VBQQGuuOIKrF+/HoY1DluOhNEQMLG7UcfuRh2rPmrDp7Wd36wTDnwA4ZN/QDv8GQJHD8AVbkSWVcEf//eBbsP0rrhcLixdupSrtomIiIiIiIiGAYbbQ1RRURHi4uIixw8++CAef/zxToFSY2Mjli5dit27d0ceu+qqqzB58uRBG8t3vvMd3Hzzzdi0aRNUVe22XWtrK/785z/jlltuiVppfv755yMvL6/Ha4iiiNtvvz1ybJomli9fjvfee69T2x07duCmm26KGssPfvAD2O32vtwWEcWoL3W4161bBwCRtvf9YQX87nE44jNwoFXHnkYDG4+4UG3J7nQdsakatq1PAIc/hVq/G0KbF1+fOQ7/fn1Tl2F6R5IkYe3atZBlGaFQ540siYiIiIiIiGhoEUzuqDVkvfHGG1i2bFlUqDNu3DhccMEFSExMxP79+/H6668jGAxGnp84cSLWrFnTYwmQQ4cOYd68eZHjkSNH4rXXXuu2/axZs+Dz+QAADocDubm5mDhxIhITE2G329Ha2oo9e/Zgy5YtCAQCUX2zs7Px9NNPIzExMaZ7/p//+R+sXr066rGZM2finHPOgSiKqKiowLvvvhu1UVx+fj7+8Ic/xHT+7jQ1NQ2o/4kiCELka9fc3MwN8qjPBnMOCYIAm80GURRht9vR0NAARVHgcrmQkpICVVWh63okWO7Y1l+3F+5wA9yyCM27F2bNZxC3r4dgRK/kNkUrtNwrYY6cAVvGRHy49XMU/ODnONSgdDUsAMdWbK9duxYLFiyA3+/nyu1BwtcgGgjOHxoIzh8aCM4f6itx504k9LJnVcs778CYNOkkjYiGMr4G0UAMh/mTlJQ0qOezDOrZ6KS67LLLcO+99+KXv/xlJDSurq5GdXV1l+0nTZqEhx56qMdge6ACgQC2bt0atZFjdy6//HL8+te/RkJCQsznv/322xEMBvHEE09EHvv444/x8ccfd9n+qquuiirJQkQnTnsdbgAIh8NwOBxwOp0wTRM+n69TjetObbPPhhloQaC+AkbcSAjpgGiNh3XH8xCCzZF+ghGGded6aL5ahLR5mDVlIna9+Tyeevlt/P6Rf6Cq6stPqng8HhQVFWHp0qWQZZnBNhEREREREdEwwnB7iLvmmmswdepUPPDAA3jzzTe73FgyLS0NixcvRlFREWw226CP4ZZbbsHbb7+Nbdu2we/399jWZrPh4osvxne/+13MmTOnz9cSRRF33303Lr74YqxatarbEN3j8WDp0qVYuHBhn69BRAOnaVrMGzZGtRVkIOUsiA1VgCBBt9hgTv8OrLv+BbGpOqqf5dAHMNrqEZp0NaTUCfjO1y/F97+zGI1iMpSA2mnFuN/vH5LvahMRERERERFR11iWZBhpamrCli1bUFtbi7a2NqSmpmL06NGYMWMGJEk64dc3DAP79+/H/v37UVtbC5/Ph3A4DKfTiYSEBGRnZ2Py5MmDGrDv378f27dvR319PXRdR0ZGBnJycpCbmzto1wBYloSGr9N2DpkGhMZ9EP0NQJsXgq8Wln1vwnLog85N5XiEJ18DIzUHYtJoiHY3kOaBaYuDrusxh+zUd6ft/KEhgfOHBoLzhwaC84f6imVJaDDxNYgGYjjMH5YloW4lJSVF1co+2URRRHZ2NrKzO28Ed6KMHTsWY8eOPWnXI6KTRBBhpkyAYXNCAACLDM0yH6Y7E5aKlyAYXwbWgtoK66dPQstZAF2bBT1hJMxgG8zEsTBd6afsFoiIiIiIiIjoxGK4TUREpy3TPQKmxQGxcQ8g2aALEkxnCiw71kEMfPmJCsHQYK14GYKvDtrEeUD8SAimCSOkQEqbCMlihSAIME2Tq7mJiIiIiIiIhgmG20REdHpzJMJInwzRWwWIFhiSDeHp/wFLxYuQGnZHNbXUbIHYdhThSVfDkjoegs0Kq28fGqVUKEENLpcLqampCAaDkQ0wh+LHuIiIiIiIiIgIEE/1AIiIiHpldcDImAzTmQIzYTSMhJHQpnwD2rhLOjUVWw7C9skTMA9/ijeeewzfv34Rrjl/PM6bMh5paWnweDxYtWoVNE2D0+k8KXsSEBEREREREdHgY7hNRERDg2iBkZoDIz4LcGXASBgFbdxFCJ39LZhS9Ea1guqD8PH/ofHj9XAG6pDiEDA5zYIJSRJ2V1WhuLgYWVlZKC8vZ8BNRERERERENEQx3CYioqFDEGAmjoaRMgGmIxFm4lgYabkIz7wJRlxaVFNJFHDtZAe+M9UOT4qEkS4Jo+JFnJtpgSwBiqIgPz8fmzZtgt1uhyAIp+imiIiIiIiIiKg/GG4TEdGQYzpTYKRPhmmPh5k8Dkb8SJizboSRMblT21lZNvzg/DhMSZcwMVlCikPAjBFWJNkF6LqOxYsXQ1VV2Gy2Lq5ERERERERERKcrhttERDQgFosFsizDbrdDlmVYLCdpr2JbHIyMKTAdyTATx0JIHIW3m9PxQkWwU9Mst4Qfz47DhaOsyE2xIMUh4JwMC8YlilAUBaWlpSxNQkRERERERDTEMNwmIqI+EwQBdrsdTqcTbrcbfr8fdXV18Pv9cLvdcDgcMZX6GHAwLtlgpJ0FMWkUrCmj8eyrm/H6vhAe+qANraoR1VS2CPjuuU4smiQjJ0XCCJeEMQkSzs2woPSRh09uME9EREREREREA8Zwm4iI+kSSJDidTmiahpUrV8Lj8SAtLQ3Z2dlIS0uDx+PBqlWroGlal5s1DlYwftwJIaaOR5OUis/21GB3o45dXg3/+14bqhq1Ts0vHSvjlplO5KaImJB0rExJvFKNhsP7uHqbiIiIiIiIaAhhuE1ERDFrD7bLy8uRlZWF4uJiVFVVRbWpqqpCcXExsrKyUF5eHhVwDzQY744gCPAZMj6pDaMpaKCyQcehVgOrP/Zj0161U/vxSRb85II4TM+0wpNqQbJDQOjgVgithwHTHPgXioiIiIiIiIhOOIbbREQUk/YV12VlZcjPz4eiKD22VxQF+fn52LRpE+x2OywWy4CC8Z6YpgmXywV/GNhyRMNRv4F9LToO+wy8XKWi9BM/glp0aO2yiSia5cQVE2yYmCTBqStA4wGI3gpAD/Xpa3PK6o4TERERERERncEYbhMRUUxkWYaqqigoKICu6zH10XUdixcvRigUGlAw3luJEl3XkZqaipycHOgmsP2ojn1NOmoVA3ubdWyr07DivTYcau087qty7CianYi40FEYjfsg+Bsg1m0Hgi09XnPQy6sQERERERERUZ8w3CYiopiIoojVq1f3Gkx3pCgKtm7dimAw2K9gXFVV2Gy2HttqmgZVVVFUVBR57GCrgW11GhoDJqoaNBxo0bHygza8d6jzquyJCQaMd/8C1FdAaKyG4G+CdLQCQsuhLsuUnKjyKkREREREREQUO4bbRETUq/ayGyUlJX3uK4oixo0b1+9gvLS0NKZw2DAMFBYWwuVyRR5rUU18XBOG129id5OOwz4Tz+4I4qnPAtCM6NBaCLbA+snfIe1/F2LzfkCph9hyGOLRnUA4GGk30LrjRERERERERDQ4GG4TEVGvJEmC1+vtFOLGIi8vD6NGjepXMA4AJSUlMdWxVlUVsixjzZo1UUFy2AA+rdNwsMVAjXKsXMn7h8P40/tt8PqNqHMIMGHd+xos25+H2HwAQvN+CG2NEOs+h6DUD7juOEuUEBEREREREQ0ehttERNQrQRD6vOq63VlnnYUjR470KxgHgMrKSjQ0NPS68tk0TQSDQeTl5WH9+vVRK7gBYF+zju31GhqDJiobNRxqs6I591ogY3Knc0kNVbBteRyitwpC0xd1uJuqIbfsg+r3nbDyKkREREREREQUO4bbRETUK9M0O4XFsXK5XPD5fAO6vqIoMa161nUdfr8f8+fPR01NDVasWIGcnJzI8w0BE61x43Bj0W24f/UaTJh+MUKTFiKcczlMIfpboqD6YN36D1gObobYWgOh+SBEfwP+9chvIettfR5/rOVViIiIiIiIiCg2DLeJiKhXuq4jNTU1KiiOlaIocLvdA7q+y+WC2cXGjl1pD7glScKyZctQWVkJr9eL6upqeL1efLazEt/64S8hJGQhaE+G7s6EPnIGQjNuhGlPjDqXABOWPa/Bsv05SH4vLC0H8MZLz2FKugUTkvoWVMdaXoWIiIiIiIiIYsNwm4iIeqVpGlRVRVFRUZ/77tq1CyNGjOhXMA4AHo8HKSkpMZcBAY6tNFdVFYFAAD6fDw6HA+np6XA4HPD5fPAHglBdI2EkjYfpSIaZNA5mwmiEZtwEPWNKp/NJDbth+ehR+A/vhByox0iXhJHxIs7NsMAa43fSWMurEBEREREREVFsGG4TEVFMDMNAYWFhn8uTvPvuu/0OxgGgqKgIqqpC07R+9W8P5oPBYKfzmHGpMDImw7QnwkwaB8OdDi336wjnfg2mEB1CC6oP9q1P4OIxNqTFCZiYJCHFIWDGCCvcttg2ioy1vAoRERERERER9Y7hNhERxURVVciyjDVr1sS8+liSJDz99NOQJKlfwbjL5cLSpUv7tGq7z6xOGBlTYLjSgPiRMNyZ0EdMRWjWEhjOlE7NrznLju9PdyA9TkROigVJdgHnZlqQ6er9W2pfyqsQERERERERUc8YbhMRUUxM00QwGEReXh7Wr1/fa1DtcrmwYcMGLFiwAIFAoF/B+Nq1ayHLMkKh0GDcQpcsFgtkhxPyyLNhyfBAjE+HmTgWpmsEwjNuhJ45tVOfSWlW3HFRHKamWzAhWUKaU4QnRYInWYLYzcLs/pRXISIiIiIiIqLuMdwmIqKYtW/WOH/+fNTU1GDFihWdaml7PB6sWLECNTU1mDdvHvx+PzRN63cwHgwGB321syAIsNvtcDqdcLvd8Pv9qKurg19yI27CbNgS02HNzIUZlwLNcyXCZ13dqUyJyyaicKYT15wlY3ySiNHxErLcIqZnWhBn7ZxwD7S8ymCwWCyQZRl2u52bWxIREREREdGQx99qiYioT9oDbpvNhmXLluG2225DQ0MDFEWBy+VCSkoKVFWNtGsPpjsG46WlpXj44YdRVVUVObfH40FRURGWLl0KWZbh9/sHfaWzJEmw2+1QVRWrV69GSUlJ1BhycnKw7JabUbjoq5DTrQi11EEXRRjuTNh2rIPQdjTqfJeOlTEx2YKnPwvAaQUOtpq47KILEDd6Moy4dCiKgv3795/48irdEAQBsixDFEXIsgyv1xv5u0pNTY28eaCqKkumEBERERER0ZAimPxNlqhXTU1Np3oIXRIEAYmJiQCA5uZmBlPUZ4MxhywWCyRJgiAIME0Tuq73uDpZEATYbDaIogi73d5tMB4KhQZ9TkuSBKfTibKyMhQUFEBRlG7bulwurHuiBJecMxaqrwlm82EIoRbYqt+GcPDDTu01w8QujMPoOYuQNHYymlQBPt0C+8gpGDFqDEKhEHRdP6khcixBflFREQoLCyHLMoLBYJ8CeL4G0UBw/tBAcP7QQHD+UF+JO3ci4aKLemzT8s47MCZNOkkjoqGMr0E0EMNh/iQlJQ3q+RhuE8WA4TYNV6d6DvU1GB8IURThdDqxadMm5OfnxxTiSpKEF9c9i6+ePRLB1gZAqYcUbIataQ/0bc9BMsKd+njFNDy5tQWfVR/FgVYdAQ3QEsbi+u8t63eI3B99DfLXrFmDvLy8Pq2WP9Xzh4Y2zh8aCM4fGgjOH+orhts0mPgaRAMxHObPYIfbrLlNRESnjKZpUFUVwWDwhNajliQJcXFxCAaDKCgoiDm81XUd117/XajJHlhSxgKuDOjxIxFK8UC86FYYSeM69Uk1juI/PEHMyLIgN9WCFIcAp7IfD//mDowamYXy8nI4nc6YN9bsj/aa4mVlZcjPz+8x2AYARVGQn5+PTZs2wW63QxC62RWTiIiIiIiI6DTCcJuIiIa19hXMgUAAq1ev7jXo7UhRFJQ++ldIqeOhp+XCdCRBTxiLkJwEY/oNQO4V6PheeaJdxLJZcbjaIyMnWcJIl4RR8SJy3UF851sLT3iILMsyVFXtc5C/ePFiqKoKm812QsZFRERERERENJgYbhMR0bDVvoL5k08+gdvtRklJSb/OU1JSAlmWYXGlwMiYAtOZBCNxDIS4ZISzZuB/PwjB6zc69VswXsayWU6clSbBkyIh1Sni7FQB/7W0AGowcMJCZFEU+x/kl5ae0FXlRERERERERIOF4TYREQ1b7SuY//nPf+LIkSNRmyn2RWVlJRoaGo6FvpINRtpZMNwZEBJGYdMHn+NQUxC/+7eC9w6FOvXNTrLg9gvi8JUxNkxIkpDllpBqDWL9X34LSQ8O9BY7sVgskGV54EG+xTLIIyMiIiIiIiIaXAy3iYho2GpfwWy1WuHz+QZ0LkVRviwjIoiQ0nJgy5qENRvKsadJh2YCT34WxF8+8iOkRxcqkS0CrjvbgZumOTAhSUROsoRXNzwLa0MFLAHvgMbVkSRJ8Hq9gxPkExEREREREZ3GGG4TEdGwdPwKZkVR4Ha7B3Q+l8sVtRO1JEloUCX866NqNAVNVDVoCOkmKho0/OJ1H/Y1d94cc2qGFbfPicP0TAucwVr4juyFpeUgxKOVgN551Xd/CILQ53IkHUUF+URERERERESnKYbbREQ0LB2/gnnXrl0YMWIEcnJy+nUuj8eDlJSUqM0Z20NkX8jEliNheP0m9jTpqGszENKBB95tw7pdncuOxMsiCmfG4ZuT7AjX7YbQfBCC/yjEuu1AoLm/txthmiZcLteAztExyCciIiIiIiI6HTHcJiKiYen4FcxlZWXYv38/ioqK+nWuoqIiqKoKTftyNfbxIXJIBz6t01DdrKNWMbCnSYcgCHi9OoRfvenrcrPJr4yxwb1jDcz6nRAaqyH4myB5KyE07QcMvVP7WOm6jtTU1EEN8omIiIiIiIhORwy3iYhoWDo+fDYMAyUlJViyZEmfVzW7XC4sXbq0U9jbVYh8oMXAp3UaGgImKrwa2kImWlUTv3jdhzeq1U7nFgONkD76Gyx734DYtA/w1UJsrYFYuw2Cv6Efdw1omgZVVQc1yCciIiIiIiI6HTHcJiKiYalj+FxaWgpd1/Hkk0/GvFmiJElYu3YtZFlGKBRdE7u7ELlVNfFxTRj1bQaqW3QcajVgkwQ8uzOIFe8paAtFr+IWYMKy/21YP30SkrcKQuM+CG0NEBv2QDy6CwgH+nzvhmGgsLBw0IJ8IiIiIiIiotMRw20iIhqWOobPXq8XV199NebPn4/nn3++1+DX5XJhw4YNWLBgAYLBYJc1qLsLkXUT2OHVUdWgo77NQGWjBs0ADrUa+H+v+bCtvnN4LLbWwLrlcUiHP4LYchBC8wEIihdi7WcQmg/GXKqkfSNIu92ONWvWDEqQT0RERERERHQ6YrhNRETDVsfwefPmzZg7dy7mzJmDAwcOYMWKFZ1qU3s8HqxYsQI1NTWYP38+/H5/tyuZVVWFLMvdhshHFAMff7HZ5O7GY5tNWiQJ1tk3wZxWAFO0RLUXDA3Wypdh+fyfEHy1EJr2Qmg7CrH1MMTaz4Bga4/3K0kSnE4nNE3Ds88+i69+9auDFuQTERERnYksFgtsNtupHgYREXWD4TYREQ1bXYXPmzdvxqRJk3D//fdj0aJFqKysxJEjRyL/r6iowNKlS+FwOHoMtoFjdb2DwSDy8vKwfv36LkPkoAZsrT222WSLLuM7P/o5Jk2ahHDSRKgX3QYjYVSnPlLjHtg+XA2pfifENi+Exr0Qgs2Qju46tuGk2XmDyvZgu7y8zHBpogABAABJREFUHFlZWbjhhhv6FOTPmzev1/slIiIiOhMIggC73Q6n0wm3241gMHiqh0RERN0QTC7PIupVU1PTqR5ClwRBQGJiIgCgubmZqy2pz86EOdQe+paVlaGgoACKokSeE0UReXl5yM3NhdvtRigUwrXXXovp06f3KeiVJAl2ux2qqqK0tBQPP/wwqqqqIs97PB4UFRVh6X9cD9l3ECFfI4zWWoiBJpiSDdLB92GpKoOAzl9/Pe0saJ4rYVpkmI4kwJUO0+qEkTwekI+F6YIgRILt/Pz8qHGnpqbi+9//PoqKijBu3DjU1tbC5/PB7XYjMzMToVAIuq5DVdU+//2fCfOHThzOHxoIzh8aCM4f6snxP9etXr0aJSUlsFZVYXsv/VreeQfGpEknZYw0tPE1iAZiOMyfpKSkQT0fw22iGDDcpuHqTJlDMYfPS5dClmUEg8E+r2AWBAE2mw2iKMJut6OhoQGKosDlciElJQWqqkLXdYTUINB8EKKvFlAVCL4jEAAgpMC69R8Q2452OrdpsSM86WqYyRNgSjaY8VkwrQ6Y7hEwE0bC7jhWiiQrKysqvD9exyDf5/PhwIED+L//+z9YLBYEAn3fuPJMmT90YnD+0EBw/tBAcP5Qd7pbFDEZYLhNg4avQTQQw2H+DHa4bem9CRER0dCm6zr8fj9sNhuWLVuG2267rdvw2e/39+sHBNM0oaoqACAcDsPhcMDpdMI0Tfh8Pmia9kVLAUgcA12Oh9i0D7DKQOsRCIaG0IU/gmXPa7DsfT3q3IIWhO2zZ6CnT0HYczmEpmrAmQLBNGAGmyGOOhurVz/ebbANHKs/vnHjRmzcuDHq8dWrV+PWW2+FIAhD8gcjIiIiosHQXoqkrKys0yfhYu1PREQnH8NtIiI6I8QePg+cpmm9n8+RCMM2BWLjPkC0wvQ3Qmirh5Z9KfTMqbB+8gTEQGNUF6l+O8SmvdAm5cMAYIbaICWOhNW7Cy/836o+jdFiseCuu+7C2WefDZvNBkmSoKpq5GtEREREdCaRZRmqqqKgoKBfe5BYrVZw5xIiopOP4TYREZ1xYgqfTwbJBiPVA0GpO7bax+qAoNQCVscXq7hfhaX631FdhHAA1m1roGeeg/DEPEgtB9Da1gw0H8D0TAsqGjT4w91fMjc3F3/84x9x6aWXwuFwwOv1orq6Gi6XC6mpqZAkCaIowu/3wzA6b1xJRERENByJoojVq1f3+Em4nrRvXk5ERCeXeKoHQEREdEYTBJjuTBjpk2E6U2AmjoPhygCMEPTsS6CedzNMe2KnblLtZ5DfL4HQsBfhxkPISZaQ5hQwY4QVo+O7/vZeWFiIbdu24aKLLsLDDz8Mj8eDtLQ0ZGdnIy0tDR6PBytXrkQwGITT6YTNZjvBN09ERER06lksFsiyjJKSkn6fw2azwWLh+kEiopON4TYREdHpwBYHI2MKjKSxMONSYSaPh2FzAc5kqLOLoI2e3amLEG6D+Mk/4KrehBSHgJwUCzLiRGQnSZieaUGc9cvaj4WFhXj44YexadMmZGVlobi4OGpTTQCoqqpCcXExsrKyUFZWBrvdfkYG3O2/4NrtdsiyzF9UiYiIhjlJkuD1ejv9bNQXzc3Ng7p6mz+PEBHFhuE2ERHR6aJ9FXfm1GOrt+OzYCSOASwy9AlzEZpxE0w5vlM3S/0O/OySeJybYcFIt/jFKm4RM0ZYkJ0o4axcDx566CFs3LgRCxcu7PXjtoqiYOHChXjllVdgs9kgisP/x4X2TaScTifcbjf8fj/q6urg9/vhdrvhcDhgt9u5WRQREdEwJAhCv8uRtPP7/QP+OYE/jxAR9d3w/22ViIhoqLHYYKZMhJ6We6xUSdI4GM4UGO5MqLNvgTZyVqcuDgtw0zQnbprmQEacCE+KhCy3hDEJIh799Y+gthzFddddF/MGSbquo6CgAMFgEA6HY7Dv8LQiSRKcTic0TcPKlSu7LNeyatUqaJoGp9PJmppERETDjGmacLlcAzpH+0bl/cWfR4iI+ofhNhER0enKngAj82wY8SNhxqXBTBoHWBzQcxYgNHNJl7W4z0634qdfcWFWlhXpcQImpdkwI3csXvrrHzBSDsDSh+/8iqKgtLR00G7ndNT+i2R5eXlM5VrKy8v5CyUREdEwo+s6UlNTkZOT0+9zJCYmxryIoCP+PEJE1H8Mt4mIiE5ngggzcfSxDScdSTCTs2E4kmC4Mo7V4h77lU5dZIuAG85x4JaZTnzjiothVQ7j/U3rMMIl4rwsKzLiYv/2X1JSApvNBlmWB/OuToi+1qZs/+hvWVkZ8vPzYyrXkp+fj02bNvEjwURERMOIpmlQVRVFRUX9PkcoFIKmaX3ux59HiIgGRjAH8rkZOq00Nzdjy5YtqK2thaIoSE9Px6hRozBjxoyTWi9VURRUVVVh7969aG5uRjgcRnx8PDIzMzFt2jQkJyeftLEMlqamplM9hC4JgoDExEQAx/7++c+Z+opzaIgxDQgthyD6aoFwAELrYQiGBgSaYPv8nxDajnbqYkCENnEefrrynwibwBGfgaaggZagiapGDf5w75f1er1wu91oa2uDxWKBJEmRX6TaS5acqvkjCAJkWYYoipBlGV6vF4qiwOVyITU1FcFgEKZpQlXVTuOz2+3QNA1ZWVl9qrPpcrlQU1MDSZKgqupg39IZg68/NBCcPzQQnD/UlZ5+LpgMYHsv/QMffojghAl9uqYgCIiLi0MwGOTPI2cQvgbRQAyH+ZOUlDSo5+N2u8NAdXU1HnjgAbz++usIhzunFOnp6SgoKMDNN98Mm812Qsbw2WefoaysDO+++y527NgBwzC6bTt16lTceOON+NrXvtand5lzc3P7Pb7t27dzd2kiGvoEEWbiGOiOJIiNewHJBrPtKETThHr+zbDXfASzogwCvvwBR4QB2+5N+OFsJ/7+WQBWUUSyXcAhn4542YqDrTr2Nxvo6UciRVGQmJgIp9PZKUB2OBwIhUKQZbnLAPlEkiQJdrsdqqpi9erVKCkpifoIb05ODoqKilBYWAin04lgMBj1cWFRFLF69eo+byDVXq5l+fLlg3YvREREdGqpqgqn04k1a9YgPz+/zyVGuvpdvCftP8cYhsGfR4iIBoArt4e49evX45577oHf7++17ZQpU/Dggw9i5MiRgzqGJUuW4N133+1zvzlz5uD3v/890tPTY2p/KsNtrtym4YpzaAgzdAgtByEq9UCoDULrEYiCCZsZQvj9x2H113fuYpp4ZbeKV6tV6IaAo34DdYoBf9jE7kYdTcGu//69Xi/i4+Px4IMP9hggy7LcKUA+UdprU5aVlaGgoKDHXwhdLhfWrFmDvLw8+P1+6LoOi8UCt9sNj8fTqaZlLDweDyoqKuDz+fr1EWTi6w8NDOcPDQTnD3Wnu58vYlm53fLOOzAmTerTdT755BOcd955/HnkDMPXIBqI4TB/BnvlNsPtIeytt95CUVFRVIgwbtw4zJ49G4mJiThw4ABef/11BIPByPMejwdPPfXUgHeCPt7ChQuxa9euqMeysrIwbdo0pKenw+l0wuv14v+zd95xUtT3/3/OzO7O1uuNo7ejGDV2UGOjiA1FI6iJMUQ0p0ajIVGTWNM05ivGRBADBn8m0YCNgA0EWzRg79IEjnaF67d9d2Y+vz+WO++4tnd7d8D5eT4e94C93Zn5zN57Zj6f1+f9eb3fffddSkpKWnxu5MiR/Otf/0oqsJuL24qidMlq5bPPPkup2IYUtyX9FRlD/YBIPWrNdpR4GAJ70WIN2J1erJL/oW54oUUWdyPVIYt/fhZmR51JzBTs9lsEYoLKoMVXNSbxZotvGgdNv/3tb7njjjvabUZbAnJvoShKU9GlZDOrNE1j5cqVTJo0iVAohMPhIBQKkZub2+12VFVV4XK55FLgbiLvP5JUkPEjSQUZP5KOaL4ybPHixTz88MPYt2zpMXG7eT9m7dq1/PznP6ewsLDb7ZX9kUMPeQ+SpEJ/iB8pbksAqKys5KyzzsLv9wOJ4L7lllu44oorWoi+NTU1/PSnP+Xdd99t+t25557L/fff32NtaRS3c3JyuPDCC7nwwgsZPnx4q88JIVi1ahV33HEH9fX1Tb8/88wz+ctf/tLpcZqL2z/5yU+4/vrre+YEkkCK25L+ioyhfoJloNTtQg1WQtSPGqhAUxUUK4b28VKo2d7mZu/sifHchghxC2rDgj1+k6gJ22tNygIJhXvevHkUFxeTlpbWaUbQ/gJyb8VTT3hlK4pCRUVFm8+rZCkpKSEvL6/FJLIkeeT9R5IKMn4kqSDjR9IZiqLgcDhQVRWn00nd22+TcXLrIt7NSVbcbt6PufHGG7n88stTWqUs+yOHHvIeJEmF/hA/PS1u912VQUmPsnDhwiZhG+D6669n9uzZrbKZs7KyWLx4MSObFbZ44YUXWmVap0JWVha33norr732GnPnzm1XKFAUhWnTprFkyZKmAmQAq1at4tNPP+2x9kgkEsk3DtWGyBqOmTMa4c7CyhxO3ObGMCF+zA/hqEsQmt5qsxMGOrjzVB9H5NlIdyqMzbGR51EZna3x7QIb+Zle5syZw+uvv57UUlfTNJk5cybRaLTXajxA6l7ZmqYhhEh5FZPX6z0kO5MSiUQikUg6prEYdTgcxu/3o+ut+1H7o1ZtQanbCZF6EO3XoGrejwkEAvh8vpTaKvsjEonkm44Utw9BqqurWbZsWdPrIUOGcPXVV7f7eV3Xuf3225teCyFYsGBBj7Vn0aJFzJ49O2kh47DDDuOKK65o8btVq1b1WHskEonkG4srE6vgcKy0AvANwMocimmaRNNHoEz+FXWe1pOPLrvCFd92c+2xbjKdCoPTVEZlahT4bDw3/zfowTLm3nRj0k1oLiD3BjabDV3XWbhwYbe2X7hwYdMANScnh9GjR3drP0VFRWRnZ/eJv7hEIpFIJJIDh2EYxGKxTj+nhCpR63ehVW5C3fMhauVmCNW0ELr378ds3LiRAQMGJN0fUVWVadOmceONN3Lbbbfx+9//XvZHJBLJNx4pbh+CrF27tsXDdebMmdjt9g63mThxYouM6jfeeINwONwj7elOocZzzjmnxWuZuS2RSCQ9hGpDZA7HzB2LcGUisoZjubMwjDgZp8xh24Bp1IRbZ/eMzrZx+yleTh3qINOr86ebizl27GAe/O3N+ALbyXYpSTehUUBOpZBve2iaRlVVVbeKLgFs3ryZ6upqAKLRKMXFxd3aT3FxMdFoVBZvkkgkEonkG4ASruv0M2qgErXqK5Sa7Sj+chR/GVr1V6ilHycyuuPhVv2Y1atXs2PHjk77Izk5Odx6661s27aNl156iZtvvpnLL7+cOXPmAGC323E6nShK8v01iUQi6S9IcfsQ5NVXX23xetq0aUlt1/xzkUiEt99+u0fb1RWGDh3a4nWj0CCRSCSSHsKZti+LeyDCk0s8bTCGBSMOPwHv9N+w3Tay1SaaqjB9jJM/nFXImAE+lj22gK3vrCbXrXBYno3DcjUcSSRkNwrIvZG9rShKl+1I9icQCKAoCpZlcdVVV3XZnsTrTdi1yCwpiUQikUj6OUYUtXITav2uTj9qZQ7FShsINh01Uo9aW4JSsw0lUIFavxut/DOUii8JVWzD51BQFbAsi4ULFzJ79ux2+yMTJ05kw4YN3HzzzTzzzDMUFRVRWFjImDFjyM/Pp6ioiAULFmAYBm63u9dWz0kkEsnBihS3D0Hef//9pv/n5OQwePDgpLY76qijWrx+7733erRdXSEYDLZ43RvZfRKJRPKNR1ERGYOx8g9DuLOJpw0iomdjV2HoGT9AmXxrYhC2/2bhGlj/N4b5PyZNVxiRqTEsXaPAq3JcoZ3BaSqd5QU1Csg9TU96ZUejUXRdZ+nSpUkPBDVNY9myZei6ntQSZYlEIpFIJIcgQqD4K1DLP0MJVqH4yzvfRtHAmYZIK8TKHoWVMSQhdAcrUaq/QqnfDfVl+GKVHDXAxkmD7RxbaOP1pxdj1e1m2eOLse3XH5k4cSJr165l3bp1DBkyhLlz57ZavbZlyxbmzp1LYWEha9askQK3RCL5xiHF7UOMvXv3tigkOS6JasyNjB8/vsXrrVu39li7usqmTZtavC4oKDhALZFIJJJvAA4PVt54rMxhWO4sIt5BRBUHhrChnnQtHHkxaK3trY4f6ODOU72cMNBOulNhTLaNAq/K8EyNYwptZDjbF697q7iRaZo95pUthCASiTB16lRWrFjRqWju9XpZuXIlU6ZMIRKJyOJNEolEIpH0R+Jh1MoNqHU7EsJ2zTYUM961fSgKODyItIFY2aMQnjwwY4ia7aRFSjl5bCFD0jSGpGlk0sAd132f08fl8dr/+yMThqcxLENlZGEOK5Y/x5o1a5gxY0anK9cCgQDTp0/nlVdekRYlEonkG4VMlz3E2LZtW4vXhYWFSW+bk5OD3W4nHo+3ua++ZMWKFS1eT5gwoUvbv/POO2zYsIFNmzZRU1ODzWYjMzOToUOHctxxxzFt2jSGDBnSk02WSCSSQxtFQXjzEK4MlLpdqKoNwwijRWvYWKfx+NoAF41ROWZAS5HboSnMPMzFyUMcPPl5GFWBTKfCHr+F265QGbTYWmsSa+bQ0SggN5+M7SkMw2jyyp47d26Xt9/fK9s0TUKhEJMnT6a0tJTFixfz8MMPt8iKKioqori4mDlz5qDrOqFQSFqSSCQSiUTS3xACJVCOUr8bJR5B8ZehxMMIVyZWesc1rjpEtYE7C+HOwoiH0VSLE089g4qnniTTpaIoIKq2MO/XP+G6m37BqqWPsurVNzGFgr38Y+756fcZ6BXUhhX8sY4n1k3TZObMmZSWluJwOIhGo91vt0QikRwiSHH7EKOioqLF6/z8/KS3VRSF/Px8du/e3ea++oqSkhJWrlzZ9FrTNKZOndqlfbRlqdLQ0MCOHTt48803+fOf/8xZZ53Fr371K7Kzs1Nus0QikfQHbDYbmq6jeA6DcD22+p28v+4rHnzwb+S4YMnHgjdKNK74tptsV8vFXYU+jbkTvazbHeP5zRFcdo3asMCmQJZLZUe9yZ4GC0HvF1ts9Mq+8847u+S/3Z5XdqPA7XA4uOaaa7jpppuorq4mEAjg9XrJzs4mGo02fU5mbEskEolE0s+IR1Brt6FE/BCuQQlWgmpPWIs4PGhVnXtuJ4XdhXA4OG36Zfz18WeIhMPoNnDbFeq2bOU3t/2C75w4gdNOPJH0rDxeeWEpOfYIeoaGlQGGBXVhi7qooC5iEWojoTwQCLB48WKuvfbaLjXNZrOhaRqKoiCEwDRNWThbIpEcEkhx+xBjf69qj8fTpe2bf94wDGKxGA6Ho0falgyWZXHbbbc1ZY8DXHDBBQwaNKhHj2OaJs8//zzvvvsu8+fP54gjjujR/UskEsmhgqIo6LqOqqrouk5VVdXXou3QYxkcNDn93FmsWfU8PivAHr/F7a81cN20Ixiv7UYRVov9TRzk4KgCO+vrM2nwDsOuu6gKq2zYWc6b/3ufPREHc+bMAUDX9V4ZIEWjUdxuN0uXLmX69OlJZVE398oOhUKt3m/04AaIx+O4XC7cbjdCCPx+vxzcSSQSiUTSHxECJbAXpX7Xvmzt0kS2tjsL4c3F4UjYe9ideqe7UvdugIwYQk9D6F6wexL2JPsRi8dw6k7uvONOfvXrXxMxTCKGoCYs2NlQzyc7V/FpSTW/vvkm1r2xlmEZGkJAyBAEYoJ0XSEnLgANw4KGiKA+alEfFfijAgEsXLiQm266iVgs1mEfpqN+Yk5OTpMNWzQalZP7EonkoEWK24cY4XC4xWtd7/wh29Hng8Fgn4rbf/3rX1tkXWdlZfHzn/886e2HDh3KpEmTmDBhAqNGjSIrKwtN06ipqeHzzz/nxRdf5OWXX24SOvbu3cvVV1/NsmXLUrIpOVj9ypq362Bto+TgRsZQ/0bTNHRdJxqNsmjRIhYuXNjCbmP06NEUFxcz+6bfc/EPruTXc3/Czm0bKfSpPPG/7fz61psxP/g3vvCeFvt12hROy67D9JTiHzoJW+ZArsjKZW/4GmLYcDbswJY3imp/qMUAKRqNYlkWsVgs5QFSNBrlzDPPZMWKFcyaNavDDG6v18uyZcuYOnVqk7DdUbybptlKMJfXR88j7z+SVJDxI0kFGT8HN40ZxI30WgaxEUWt2Q7RepRQLUpwL0K1YWUORXP6miw9n3/+eT7499Pc18nu7B//E/Z8LbEIzY5wZSHc2S1/fPnE0wdx7LHH8off/567f3N3i3F+3ILMwmHUGk7+u7EMuwo+XcHrUMh2qeR7wBIQiguCcUHQKQjGFCzAtKA+Iqgp+4rq8t2407PbTQJItp941VVX4Xa7m1axSVJH3oMkqSDjpzWKkNNvhxTz58/nL3/5S9PrP/zhD1x00UVJb/+9732P999/v+n1G2+80WfFHFetWsVPf/rTJkFDURQWLFjAGWeckdT2b731FieddFKnF++nn37KDTfcQFlZWdPvjjrqKP797393v/ESiURyCGKaJqtWrUpK/H3iiSeYPOFIbrj8fLZu+oJCr8ZR44Zx3Q1z2fnxG+TuWYvXZrW5/Vs7Y7xb4+PYCScy4fQzUdMGcM+f7uf//Wctu+oTViXNB0hOpxO7PQXvymbE43EikUiHXtlXXXUVuq732DElEolEIpH0Do0ri6uqqggGg3g8HnJycnp0xbEQAhrKELU7EUYE6vZALADuLPDlo6galmnx3nvvNQnP44Xg4Z0dC+zxH2dDbhfyBx1eSBuA6Stgw54GXnp3I+s3l1MfFVx++eWcOfVMvn/591tt5rKBx6Hgsat4HQo2FYSAsCEIxMAfswjGBP/+91LyBg5BcWWANxfFmdZiP13pJy5dupQzzzyzxaSDRCKRHCxIcfsQY/HixfzpT39qen333XdzySWXJL39xRdfzKefftr0et26dWRlZfVoG9vi/fff50c/+lGLghbXX389P/nJT3rleNu2bWPmzJktipn97W9/49RTT+2V40kkEsnBRjwe55VXXumSbcfy5cuZcNwxnHfyETji9XjsCicfMYobrr0a3ZNGxdtLyan9CK2NScaoIVixKcJHVSrfv/wHjDn6JH52++/58NMNbK8z2RtMCOO9NUBqHPRWV1c3DYazs7P73H5LIpFIJBJJ12mcrO4sgzjVCXIRDUDVVqxoAILVEKgAVYP0gSi6FwDTMHn//ff51a9/jYrJhWOdXD7ATtrfazo+h66K2+1gOjNQsoZjpA3iNw8/wZeVBg3R9mUbXUuI3V67gldXsauJDO57/u/PeLIKwOlDsTnA7kLx5oE3D0MoXe4nrly5ksmTJ8tkAYlEctAhxe1DjCeeeIK777676fUvf/lLfvjDHya9/fTp09m0aVPT608//bTL1iZdZePGjVx++eU0NDQ0/e7SSy/lrrvu6tXj/u1vf+P+++9ven3++edz332dLSZrm7q6uh5qVc+iKArp6ekA1NfXSx80SZeRMdQ/0XUdwzAoLCzscsHFXbt2ce+997Lwz/cxKkujMDeDfyx8gJLP3+dvixZjVy1+9G0349oZvO0Nmjz9ZYzTL7yCYaOKuPaWu9lVWY8/Kthaa9IQFU0DpEmTJhEOh3ss7vpsGbOkR5D3H0kqyPiRpIKMn4MHTdNwu91dziAOhUJds8iwTJT63SiBCoiHUf3lYIQRrkyEJzchcAMOuwPTNLnouxdxRJbBNce6GZSmQaWB/ZHqDg8Rv3EUIiOGYkQ7/Fx32Flv8mWlweeVcb7Ya7Croe3VdABOG4wZOpAH/vg7ooFaLNMAuwfLmQ7ONOwOHdORxmEnnMbu6gBWkuHv9XopLS3FZrO1SFqTdB15D5KkQn+In4yMjB7dn/TcPsRwu90tXrdVFKsjmhektNlsvS5s79y5kzlz5rQQts8++2zuuOOOXj0uwEUXXcS8efOaLvR169Z1e1+Hws1CCHFItFNy8CJjqP+gqiqLFi3qkrANEAgEWLJkCcXFxfzpT3/iwzKD715xCXjzue3PS8iymaQ7FR58J8j4XBtXHOki3am22EeeR+Pa41x8+dGTqAOv57tTJrDypTXs8Vv4dIXqkMXWWpOZM2dSWlqK3W7vsQFSPB5vUbBYcugg7z+SVJDxI0kFGT8HjsZihqtWrUoqgzgQCDB9+vSmCfJQKJTc3y5ci1q7AyUehlAVSqgGYdMRGcPA7kp8RnzdptdXPMFtEzVOGOjq0vmsVSZy+iU/IhLyo0QaUMI1KKEalFD11z/BSpRABYrVtcn3IekaQ9I1po1KjN+rQxYflsf5sCzxUx3++nuIGHDymRdg+AZi2LMg6keJ1KE2lCIC5ahpuby45mmGeaIMddsTHt0Ri+qQRbiDZgUCARYvXsy1117bq9dMY7JCbxQlPxiR9yBJKsj4SSDF7UOM/Pz8Fq/Ly8uT3lYIQUVFRbv76mkqKir44Q9/SGVlZdPvvvOd73DfffehqmoHW/YM2dnZDB48mJ07dwKJ4pLxeFwuo5JIJP2axonLhQsXdmv7hQsXctNNNzF16lRWr17NpcU/57Gnl7K9MkiDW8UXVij0qZTUmdy61s+0UTrnjtbR1JZWJeNzNMT6BZwx5ATedGp4HAq1YYFdhSyXSqk/zN8XPULxddf3xGlLJBKJRCI5xGgsZjhr1qyks7BN8+sJcofD0fEEuRlDqduJGqqBaADFX44iDIQ3D+HKgv1s1jQzgvbR05wReBHbwK5bmr32+mtMvf7HGIYLU3MgPDltf1BYKMEqFH8Zir8M1V+GWrcLpX4XihlL6ljZbpUpI3SmjEiI3TvqTD4oi/PuHgPPyOOYfv50FEXB7tCxbHZMZzrCjKHF/NiMEF/+93nGZmv4o5CuW2S6FEZkakQMqAxalPpNom38SRr7ifB1Ae6eEJ4bJzpUVUXXdaqqqloUJY9EIgghiEajUsiTSCStkOL2IcaIESNavC4tLU1626qqqhYZbcOHD++xdu1PTU0Ns2fPZs+ePU2/O/bYY3nooYf6VFzOzs5uErchYS+Sm5vbZ8eXSCSSvkbTNKqqqlp4VXaFzZs3U15ezpgxYwAYOnQo8x9ZzJZKkyyXxagsG4GYSZ5HJdetsmZbjNdLolx+hJujB7S8vyuAa8873HV6Gks/C/BxhUG600ZVSKApsO6Zh7nhysuIaR4Ms/3ltRKJRCKRSPofqaw0a8wgbhMhEhnS9btQjAgE9qJGGhAOD5ZvCGgthWtNEWhbX0P9/FlE1I+tjTysbTUGYzppV3l5OQ31Dei63rFYr6gJgd2bBwOOpOmTwkqI3bU7UOp2oNaWoNZsRzE7X+E2NENjaIbGheMA+w7irz9AMHs86pBjSM8tJBaLgXCAy0tDOMQ7W8pJ0xXSnAo5Hg1LQDAmaIgK3DYYlKZSHbLY47eob+b3vXnzZqqrq1EUBcuyyMnJIRqNoigKpml2K9Na0zScTifRaLRdz/VrrrmGH//4x3i9XgzDwLKsfp/RLZFIkkeK24cY+fn5+Hy+pkKJGzZsSHrbL7/8ssXrkSNH9mjbGgkEAsyZM4etW7c2/e6www7jkUcewel09sox2yMcDrd43ds2LBKJRHKgURSly4PE/fH7/fh8PsaOHUtZWVnTAKMmLHhvT5wh6SqmgJqwxUCfRrpTYeEHIYamq/zoKDcDvC0LRbo0ix9+283OepMnPw8DFpkuGxU1e6jf/jG6JwPDnQ/u3i9wLJFIJBKJ5MDTUyvNYrFYS4EzHkat3Y4SDUC4NiFyA1ZaITjTv/6cAg6bHaX0I9SP/gX1bSeN1UYEf/sgyFcbozyWRLvC4XD3x7yKikgbiJk2EIaeCICKhR4qZ+f7a9jx/irGZqnkejpZBR0PYd/9Lvbd72J+tIRP6zSiA47hW2dfiSMti3Akgj8m8McEe/yJgpQ+XSFNVyn0qRR4VeoiApcNcjwqwZig1G9RHrAQJBLZHn/8cX73u981FfucM2cOuq4TDofJyMhIOtO60XN99erVbXqu5+TkcNFFF3HhhRfidruprKwkGAzKjG6JRNKC3veGkPQ4xxxzTNP/q6qq2LVrV1Lbffjhhy1eH3fccT3aLoBIJMKPf/xjvvjii6bfjR49mkcffRSv19vjx+sIy7JaZLbb7XbS0tL6tA0SiUTS1wghUr7fNk6ier3epsnUpv0DO+ot3i+NszcoKKk32VZrYlehOiS47VU/Sz4OETZaDzCGpGvccpKXS7/lxOdIZAXFyzehhKrRqr9C3bsB4l2rJXEo0TiQdzqd6LqOzSZzDCQSiUTyzaQnVppVV1d/XUhaWCj1u1HLP0MJVqPU7kgUjXR4sbJGtBC2VVXFGapAWfsH1Nf/1KawbaISH3sO9pkL2OMcRbKyqcvl6lGR1UIl6h3E4KlXc8Iv/s1b+Zdx8zonf14f5L87YoQMpcPtNVXhsCyLo6PvoT7zY8LP34Wv8mNczbogUROqQoJttSZfVhlUhizSnApjcmyMzNAY4FUZna1x3EA7+R4VX7P+4ZYtW5g7dy4DBw5k9erV6LrOzJkzWbBgAYZh4Ha7WxT7bo6iKDidTlavXs306dNbCdsTJ05kw4YN3HLLLTzzzDMUFRWRl5fH8OHDyc3NpaioKKnjSCSS/o8cVR2CnHHGGbz++utNr1966SWuvvrqTrdbtWpV0/91Xeekk07q0XbF43FuuOEG3n///abfDR06lL///e9kZmb26LGS4cMPP2xRyHLs2LF93gaJRCLpa0zTJCcnh9GjR3drwFhUVERBQQGbNm1i7Nix+Hy+Nj8XMeCzvQbZLoWRWTb8MZNct0q+R+XjcoP1u+u5eLyLySNar5g5fqCDYwbYWb01iq5YULsDRdXBm48a9SeW6qYPAvXQ76ZID0mJRCKRSFrTEyvNAoEAbrcbwnWodY0FIxOFG1HtWBlDwOFpsY0abUDf8Bxiy2uo7UjWb+yIsfjDEHXm09x+2zgemPcA9111DZRt6rA9BQUFpKWnEQ4EIR4GYYKitv5BaeX33RGWZRGJRrDb7Ey/4Hy+O/NiGuobiEajuNLT2fC/F3ln+SJOKLQxLrf9vpNNVbBVfwnVX/LMzCze2hnl5a1RPiozmr4Jw4KKoMXeoEW6UyHXbeOsiePIzisk7sxAONLIM8sp39ZyBXkgEGDGjBksX76cBQsWMG7cOO68806WLl3K1KlTCYVCraxaOvJcP+uss1i+fDlr1qxpM6MbvhbWOzuORCLp/8jM7UOQSZMmtfCtfuqpp1p4abfFunXr2L59e9PrU089NdER6CEsy+KWW27hjTfeaPrdgAEDWLJkCXl5eT12nK7w8MMPt3h98sknH5B2SCQSSV9iGAbRaJTi4uJubV9cXExJSQmrV69m48aNDBgwgNGjR7f7+ep9ViUldSYVQYuNVQb+qMDrUHmrOh1l6u3sjrQWuDVV4azRTlzr/4oo+xRiIZSabSiBCtSGMtSyT1ECe+EQFnwbl9oahsH8+fMpKioiNzdXZhxJJBKJ5BtPT6w08zodiL2b0Ko2o4SqUWq2oYaqwZ2NyBreUtg2Y9g2rMTx4i9gy6sobQjbm6oMbny5gd++GaAsYBEOh7nt9tv54MMP+OmNP+20PeedcjRG6ZdQuTHhl123C7V2B2rNdtTqrahVW1ArN6FWbkTduyHxU7nx65+qLSg121HqdqI0lCb6QeGaxKo2yyIejxOLxgiHwui6TlZ2FpYCH+3yEyk6m3/UjOWSZ+qZty7I+t0xYmb7fSiHBmcM17lvchr/nJHOD45wkd/M7iQtPZ2zL7yU387/Bz/+9X1MOescJh8zlvNOOgzh38u8X17Ng7fOYWTh10UzTdPk0ksvxWazceWVVxIIBJg+fTqvvPIKTqcTZT9Bvz3P9ebCdlsZ3fvT2XEkEkn/RxEyTeiQ5O677+aJJ55oen3DDTdw3XXXtfnZaDTKhRdeyFdffQUkZsmfffZZxo8f3+bnd+/ezaRJk5peDxw4kFdffbXD9txxxx0sXbq06XVOTg7/+te/GDZsWLKn1C51dXVEo1Hy8/OT3uYvf/kL8+fPb3rduNypK/toTm1tbbe2620URSEjIwNIfE/ycpZ0FRlD/ROn04lhGBQWFnYpK8rr9VJWVoaiKFRVVeH1evH5fDz00EPMnTu30+0dGozM1Mj1qHjsCj/90SUcffhYbrn9t4zPVbn8CDdZrrbn1S1XJkbRNETGMISqIby54MxA2N1Y6YPAlZH0eRwMdOYh2Ryv1/uNzDiS9x9JKsj4kaSCjJ8Dj81mw+fzUVRU1K2VZqccOYrXlv+DsL8Ws75sX8FIN8JbALZmk+rCQtv1DrbPnkoI322wN2jy6EdhXt0eazOX2+Vy8fQf7sN7YceJA8H/dxe1eTnkDRhIxAQUGwir9Q+i9eS9EIlMb8tAsRL/Nv4oQoCiIGw62F3YXWkoDg92t4dwKEwsHsNus+P2uCkvL2flypW88MILRIP1HF9o5/RhOicMsuPQOhd9PyyL83Eol5k//xOazcFLL73EihUr2L1nNx67wgCvyrDCPI476TROPHMGpubgxptv46W3P6YylDinefPmMWPGDEaOHIllWXi9XkpLS9E0jWg0URyzvb//xIkTeeONNwiHwwwcOLDL/dj9j3OwIu9BklToD/HT0+4OMnP7EKW4uBiP5+uZ6L/+9a889thjWJbV4nM1NTXMmTOnSdgGOPvss9sVtrvDvHnzWgjbGRkZLFmypEeEbYCysjImT57MHXfcwQcffNDhhbtz505++tOfthC2AebMmdNtYVsikUgONaLRKLqus3Tp0qSzgTVNY9myZTgcDhRFIS8vr8k38qqrrkoquypmwoYqk0/KDfyWk4nnXsYLb3+KXRXsqLP41asN/OuzMJE2/LjVcC2OT57E/sm/UAPlqA1lKLXbUUJVaFWbUSs3QizY5e/iQNCZh+T+yIwjiUQikXzT6O5KswynwrGFNq679BzitaVYlVtQY0GstEJExtAWwrZa8QX62rtxvLOwTWE7bAiWfBxi9n/qWduOsA2JIpFv/fftzs/JnceNd/yRmLsAW+4orMxhWJlDsTKHYGUMRqQPRqQPQqQNTPy7/09aIcI3IPH/zGGI7FGInDGJ/XjzUe0udAyUhlLiZV8iKjYSrfiKYMUOIv4ahLDwuD1c8YMrePz/Pc6IovG8uTPO3W8G+O5Ttdz7VoB3dscwrPbH00cPsPOjkXXYV/6Mp+68jH/9/WF279kNQDAu+KrW5N0t5Tz7zDJ+c9Nstn/wOo/86W4uOvUIjh9oZ6BP5W+PPMywYcOYOnUqkOjnLF68uEWftC3P9ZycHFasWEEkEmHx4sVdtq1p6zgSieSbgczcPoR5/fXXueaaa1oI2sOGDWPChAlkZGSwY8cOXnvtNSKRSNP7o0aNYunSpR2KFF3N3B4zZkyL14qioKpdnzf58ssv2/z9hg0buOCCC5peZ2RkMH78eIYNG0ZaWhqqqlJbW8vnn3/OF1980UrgP+uss3jggQdSEgtk5rakvyJjqP/S1czhZcuWMWXKlFaZw4qi4Ha7m5aGJpNVrGkay597jgmHj+L7555CJFBPtksl36uiKGAJhTtmTSS7/os2lwUDmAWHYww/BRw+hMObyOS2ObHcWYi0QWB3dtoOm82GpmkoioIQAtM0MQyj0+1SJZXM+UMl46gnkPcfSSrI+JGkgoyfg4OuPC/1favDcjwqOWkuHn/oT2hWjLjdh/DktKjTodTtwP7pMrSKz9vclyUEq7fGWPJxiOpwcn/7yfm53P5u68KTzfnBkYfzj08+Y968eVx77bWEQt0oki3EvoztOJhxFCMKsQCaEcKpCUzDJBYJs+bllbyx5iX8VRW47AqaCjk5uRx/0mmceMY0HL4sFJvOjTfd2GqcnaYrXDZhCN89Mgtqd3TYnJgpeL0kxvKNETbXtOwDZjgV8r02fvLjKxk2cgw/ueUudlTWY1jw3Jp13LPgcf784F+ARE2XTZs24ff7MQwDp9NJRUUFw4cPb9rfrbfeyq9+9auUMvr3P87BirwHSVKhP8RPT2duS3H7EGf58uXcddddhMPhTj87btw4HnroIQYNGtTh51IVt7vLpk1tF+jYX9xOFk3TuPbaa7nmmmtSnr2V4rakvyJjqH+jaRpOp5NoNMrixYt5+OGHWwwUioqKKC4uZs6cOei6TiQSaVO87qpQ/uSTTzJp0iTOOOMM3lm/nkFpKkPSNewqDMl284trZzNm3HhiIT/alyvRKje0uS+hqJhDTsQYdDzYHAhnOnhyEZo9UXQyrRA0R4ttDoYCjm63m/nz5ydl5bI/KQ2IDzHk/UeSCjJ+JKkg4+fgIJkJdFWBwWkqg9M1dA0Gptn5xfVXUzT+CCJ6JthcX+8vWInt82ew7VzX7jE/Lo+z8P0QX9UmZwGW5VLI86gMjQp+9XnHE8+HAV/S8wKroiiJVduWwZoX/8PPrrsamxEmzalg25dT5tQUvA6FNF0hy+fkissvZ9zhRxHBzpXX3URFTX2r/T7z1NOkmzWYm9dibnkdBx3X8fq4PM7SLyK8V9ryczlpLh6bfz9rX/oPL69eS1XI4oGFj/HCK69y2/2LmyYQqqqqcLlcTSsMQ6EQubm5QMJ/e9u2bWzfvp0xY8ZQWFjY7e+r+XGSpa8TIuQ9SJIK/SF+pC2JpAUXXHABzz77LJMnT25RZLI5ubm5XHfddSxbtqxTYftgpKCggNmzZ3PYYYdhs7Vf/bmR9PR0LrvsMp5//nl+8pOfyGVJEonkG4tpmoRCITRN45prrmHz5s1UVVVRUlJCVVUVmzZt4tprr0XTtA69nhv3M3nyZEpLS5k3b16rIpNFRUXMmzeP0tJSTjvtNK644grWr1+PAHY1WNS6h3H5T25h/uNPU3Ti2cSwI1CJH34x0ROuwfK1HsQowsK24y309Q+h7fkANVSFUrMVJbD366KT9XvASrT7YCjgaLPZ0HWdhQsXdmv7hQsXout6Us87iUQikUgOZYQQRCIRpk6dyooVK1qsLlaAQp/K8QPtDMvQKPCoHFHo4ec3FDPm+NOJeQd+LWxH/dg//hf6y7e2K2yLtELqj7man7/i71TYVkiI2uNyNAanaUTiUFKXfD2MzZs3U11d3WP9DF1PWK28vHoN5138fTaW+fm80uB/u+K8tyfO5mqTkjqTXQ0m2+pMPtwV5I4HFvHZxs3oZoDZ553C6CyNDGfLlcw2ux0jfQjiuNloly5GnPQTatTsdtvx7QI790zy8cg5aZwx3IG6b3dVDWFeWvcFx599GcE4DPCqeKN7UUI1HJZn4/A8Gy5bwjakcTW1aZrk5OQ09SenTZvG0KFDURQFu93OjTfeyLRp07q1Irz5cTqi0UbO7Xbj8/kIhUJUVFQQCoXw+Xy4XC5pFyeRHCLIzO1+RG1tLR9++CHl5eUEg0FycnIYPHgwRx99dL8ReGOxGF999RW7d+9m7969BINBLMsiLS2NjIwMxowZw8iRI3v8ASQztyX9FRlD3yxSzUpRFAWHw4GqqjidTqqrqwkGg3g8HrKzs4lGoyiKgmVZTe83Zk03vm9GAsQrt6GEaiAeRgnsRYmHEDYnavVm7BtWokT9bR5fODwYI07Hyh2PsNkR7mxwZSJsOkrmYFy5w3jllVcOaAHH/TORukN3Mo4OReT9R5IKMn4kqSDjJzV6Osu1xUqzRYt46rEFmDU7cdog06lyxIgCTj35JCaccRb2jEJihpmwojSi2LasxrbxBRSj7ZXMwplB/LAZqKPPIBKPd7oiONOpUOBVcWgK9RFBecAkYkK23+LZmo77C42Z2wAlJSXk5eW1sAjtLj6fj2AwyKBBgzq1b3HbIcetkuVSyc9w8/Syp7AiDdz44x/gtSfqo1SFLNzZhTz2+D8Ih8KYpommabjcLi7//uV4ImWcP8bJacMcHRahLA+YLPsiwktfRSkoHMzj/3icW265heryUhbN+y2P/PV+3v14A3sCJlEDlr/2Ls68EUTjie/R7Xbz97//nZ07dzJ37lxycnKoqKggHA6j6zoDBgygpKSERx55hMWLF1NVVZXU95VMP6p5zC1atIiFCxe2WN04evRoiouLueqqqzpc3dhd5D1Ikgr9IX6kLYlEcgCQ4rakvyJjSNJdbDYbNpsNlyuRNRUIBIjH4y3e73DgG/Wj1u1EiQUh6k+I3FYcYXOi7XoX25bVKFbby2MtVybmyElYWSMRmgO8uejpebz78efMvOomyvydD7A1TWPlypVMmjSJUCjUY7HflodkV+nJAfHBjLz/SFJBxo8kFWT8dJ3etv1SAIcZQG0oxaEY+PfuIVazG92m4MkuwNCzsFQ7cSMOpolW8l/sXzyHEqlrc3/C7sIcey7xUVPAprcQbxsLJDYnw6mQ71Fx2lqK2rVhwY56k5MLhvDCjo79qZuL2z01Ud24Iuyhhx7qst2ZQ4O//vFufnjRWdx+y1w+fn89uZ5EBveMC2Zw8pRziKousLmwOxxEopEW4n+6rnD2aJ3zxzjJcbefQb03aPLk5xF++Lv/xxNLn6Igv4CTv3My187+PgVesKkKtrR87n/kH4RjBoYnH+HNw+3xoqoqgUCAJUuWtCswz549G9M0Oe+881i/fn2H55yMJUxX7fZ6IyFC3oMkqdAf4kfakkgkEolEIjngGIbRYsC2/wCi8f1IJEI0Gm09wNB9WPmHYWaPQnhyEFkjsDx5YEaxCr9N9LRfYgw/BUHrjCE1XIv986exf/Q4as1W7KG9xCs28+Affs3oLIXjCm3kezru4pimycyZM4lGozgcjg4/2xWEEB0WbU4Gr9d7SHZSJRKJRNI/6VXbLyFQglUo5Z9hlH5JrGY34d1foof34svIwp5fRETPJWpCPBZF27EOfdUvcXywpE1hWygaoWGnEzzzXvTjLsHh8eFwODAtk3gszvTp01t8Ps2hUJSlMTRdI26SsPioNykLCD4qM/hsr0FDVDBr1qykT6moqIjs7OweEULtdjsOh6NbdmcxE+7/279wDDuOsaddSKlfsKvBpCRgZ8LkcxHhBtTaHaj7LN8i/pYJXfVRwZOfR7j8uTr+b12AnfVtn0+eR+OnJ3jwvvJrjvHWMG3qZFasWEFtxGRTtUllyOK8M07EKPsSq6EctXYHtr1fokXqeGX1aoYMGcLcuXNbFZDcsmULc+fOZciQIaxbt45XX32VCRMmdHjOxcXFbfc799FoRbJ69WqmT5/eaSZ8IBBg+vTpvPLKK9KiRCI5iJGZ2xJJEsjMbUl/RcaQJBV6LH6EheIvR2koRTFjEKxCCdeCzQGWwL75JbQ977e/edYIPgxk88TzawnHBRVBi/qoIGLArnqT8oBFey3r6QKOuq7jdrv585//zI4dO9i4cSOrV69OLJ9Ogp4uQnUwI+8/klSQ8SNJBRk/ydNrWa7CSoja/jIUI5pYxRWqQolHEHYXwpMLDs++zwrU0g+xf/4sakPrrOtG/leusWBdNeWBxDN30MBBTJ8+nXPPPRe73Y4lLEzD5KLvXoTdipDvUXHbFQIxQXnAIhgXNEQE2+tM6qNfx4TX62XP6tWknXhih99VY+Z2T/YtPB4PDQ0NKdmdVVZW8u6773LOOefg1TVWPrGIE48YRSQcglgIIg04zDCxaIhf/PLX1IQEVWELa7/LQgFOHGznksNcjMttvzaI5c5mwduVrPiiDkuAy+XimX8/iRquwgzUgN2JI2sgH3y+hRt+8Uu+qo5TF+n4GtQ0jeXLlzNhwgTGjRvXpkWJ1+ultLQUTdPazZh3Op0YhkFhYWGnwnZX990V5D1Ikgr9IX5k5rZEIpFIJJL+haKiZQ3BPuw47DlDsWcNRs0ZBaodxYoTHzedyKm3YOaOa3vzmm0cE3uP7x3uYmCaxrAMjaIsjQKPwuhsjeMH2tvN5O6JAo7NCxK53W6qqqo477zzuPnmm3nppZfYunUrt956Kzk5OZ3uq7OMI4lEIpFI+opeyXIVIlEYuuwT1JrtKIFKlJrtqPW7ARUrYzAic1hC2BYCtfwz9LV3o//vL+0K2x+WmxQ/X88dr1Q2CdsAu/fsZsHDC7jouxfxwQcfoKkqdiPEH39xNSMy7VgCttaabK1NTIR/VmHwcYXRQtjWNI0nn3wy6eey1+tlzpw5PerP3BURti2CwSCQaNuy51Zy8vTLieQchpU5AuErRPgKMLNG4hl8GL7MfPK9KuNzbBR4VZpbbgvg7V1xrn+5gZ+tauDj8rbt49RQNT85SmXhOWmcMEjnrjvuxO7yEPfkY2UOw+ZwYlRu5x8P/pYcJxyRb2NMtkYH9t6Ypsmll16KzWbjyiuvbPW+pmksW7YMXdeJxWLt7kdVVRYtWtTl7zQQCLB48eJ+U8tMIulvyMxtiSQJZOa2pL8iY0iSCqnGT7v+nQ6FbBqI+qsgEsCo2wPxCMLhRQlWYv9yOWpd+76X7+yOsWprdF/2tqAiYFEXFQRjiWysmnDLdqbii5lsQaJk/CJ7OivoYEfefySpIONHkgoyfpKjR7NchUAJ16DU70aJRyDakMjcNmMIhydRJLoxUxtQKzdi+/wZtKrN7R4n6CzgNy98xQel7YuZjWS7bdz18+sYN3oE6D4+2ryTO37/RyrrQ+yoM6kOt46Bxkz0008/nSsnTOCJTz/t8BhHqCp/fP75Hq3n4XK5CAQCKReq3rNnD8OHD2+7OKIZRwnX4hIhlj/5/1j0yAJy3RpZLgUUqAlbVAYt4m0sQjsy38YPjnRxZL69/QYUHIZx5KWQPQJFUVAUhReeW8pLyx7DZVeoCQn2+E3CBmypMVr105ozb948ZsyYwciRI5tWxXm9XpYtW8bUqVMJBoPtTizYbDZ8Ph9FRUWtLFCSoSdX18l7kCQV+kP8yMxtiUQikUgkhzwd+ncOHMaY0y7i7yvfxnBl4hgwDjIGgRkFu4vY8VcTO/5qLG9+m/s+YZCDO071ceHYRAGkoRkao7M08jwq38qzcWS+DZ/j6/SgQCDQLQ/FxnNYs2YNhYWFKflFJptxJJFIJBJJX9FjWa7hOtSKL1CrtyYE7drtqA2lYNOxMochMoY0CdtKzVYcb/4J/fV72hW2RcZg4iffxCX/3N6psJ3pVBibozHIBw8tXETMNwgzfSDf/s6ZPPXGZ3z/F/eRNWhUi22KioqYN28epaWlTJkyhY8++igpMXT+/PlMmTKlqbhmTxCPx8nJyWH06NHd2r7R/3vcuHFomta2XYxmR3jzsHLHcvZVv6LGcLLHb7KhyqAyaJHlVBmXY6PQp6Lu1136pMLgtv8axE69hb1ktd2I8i+wrboN8eafCVXuxO6w88zKVWyuMdndYJLuUhiTYyPHrfCtvI6zuBcuXMiwYcOYOnVq099pz549TJ48uVMrHE3TqKqq6pawDbB582aqq6tl9rZEchAiM7clkiSQmduS/oqMIUkqdDd+uurf+dw/HuHUI0cSDdRjBatRQtUowkToadirN6F8/hxqpL7N7S0heGtnnLXbowRiAn9UUOq3iJiCmpBgR73J9tLKLmduK4rSJGxPnz49qeXH7flFNmYcTZkypcOBmc1mQ9M0FEVBCIFpmoe0fYm8/0hSQcaPJBVk/HROT2S5bvz4XYJ7NmKF6iAWRAnuTXhqOzwJT227q+nzSt1O7F88h1b6Ybv7tLwFGIfNwDbqOyz/zwoWPLyg3c9mOBUKvCq6plAfEZQHTCImXHndXGZdfRNh4cDhcKCqKk6nk+rq6sTqMa+X7OxsotEopmlimia6rhP/+GM8J5zQ4TnHP/qI8IgRPWpJAuB2u5k/fz5z587t8rbz5s3juuuua7Im6YjmfZuLZ0yn0AMFPhWbArkelVx3IjeyPGhSHRIIQFU17vnDHzj66KOpranBXbcZ55fPQO3ONo8RFyrmuHO58I7HiO37muwqDErTSNMVasKCPQ2Jv9WWaqPNjPrKykocDgdpaWn4/X7cbjehUKjTPpHT6aSiooLhw4d3+l20R0lJCXl5eUQikW7vA+Q9SJIa/SF+ejpzW4rbEkkSSHFb0l+RMSRJhe7ET3dF4ZUr/sOk48YTqdgGRhTCNSjhGjRFxZGew7//9HOmDYqR7mx7UZppCf67M8brJTH8MUFtWFARNMkbMJh/PL2SgC0DQ3O1uW1bpLJUe9euXdx7770899xzFBcXM2fOnLaXCdOBdYvXS05OTlN2WDQaPeSuX3n/kaSCjB9JKsj46Rxd1wmFQt2yw8hwKgxN13j95RXoqoVRV4oSCyLsToQnr4X9iFK7A/uXyzsWtd05GOPPxxx6Eprdgcvt4vLvX87uPa09uDOcCvkeFaetUdROTGjXhQUl9SYFQ0e3spbobPJYURT0r77CddxxHZ53w//+hzl2bFe/rk5Jpc9RVlaGpmlJi7H7JyBEQwEGpWkMTFNxqFDgTdiVxCxBbdzBz355F8ceeyyGaYAAIQTCNLHvXkfsnX/gMPxtHqc8YLLw/RBv7fratzvLpVDo1TAF7GkwaYgJqkMWW2rMJiEcYNu2bQDk5+djs9na7D+1RSox3UgqVnbNkfcgSSr0h/jpaXG7+9WTJBKJRCKRSLqIrutEo1FmzZqVdGaTaZrMnHUJpaWl2IZlE6ssQdFs4MrECFWjBWrJP/w0bnjyKU4dqvPd8U7S9JYit6YqnDZM5ztDHLyxI8YbO2JkOBXOPucUYtU7EeYuVN2HlVYIzvRO25TKUu0lS5Zw1113ce+99zZlhrXlzZmsn/dVV12F2+1OenAnkUgkEklnKIrS5WdchlNhWLpGmlPBZVOI7f0Kp66CULDSB4Ke9vX+a7YnRO2yj9vdn3BmEB83HXP4KaAlPJ1VVaW+vr6VsJ3pVMjfl6ndEBHsrDcJG1+L2g37ikQ27LOWcLlcTQK2YRgdZv0KIYjFYnQ2Bd5bAlM0GsXtdrN06dIuJQY02p0ZhtEk3HdGY59k8uTJlJaWsnjxYh5++GHe3baFERkahgA9cxAzzzqFU044Gps7jUh9FZbdndiBAk7dyfu1Xu76526mj7Zz2eFOvI6W/bICr8Zdp/n4sCzOQ+8F2VlvURMW+KMGg9I0hmdq1EcENgUynColdSZ7/AmP7bS0NNLT04nFYl3yNjdNs8nipburEbKzs/H72xbsJRLJgUNmbkskSSAztyX9FRlDklToTvykurT22muvJRQKgRFD8e9BCVSia2A2lHPnzTcSCEcJxExOH6Zz0TgnHkfbmdxxU/D2HpOTLvkZqiuNuOZEuHPA7kI4PFi+AeDKhDa8uHuqIFEoFGo386er1i1Lly5l6tSpnfpNHkzI+48kFWT8SFLhUIqfA2VJ1ZUs10ynwtCMhK2E25bInE5zKvzunj9hzygkrrmanqdKzVbsX/wHrfyTdvcnHD6MsedgjDwDbHqL9xwOBzW1NVx66aUoJLJ98zwqjn32IxVBi7AhaIgkikjXR1v/bbtjLaFu2ED6SSd1+Jn6t9/GGjcu6X12BU3T8Hg8rFq1Kql+wbJlyzjjjDN49tlnOffcc9tdIdYeiqK0bdviUMiigVhDFVa4AbO+DOJhhM2JcGfh8OVgWhYXffciwuEwAGkOhSu+7eLc0Tra/qbdgGEJln4R4V+fhZsytDOcCoU+DRUoD1hUhS38UYHIGs5HX2zudlHHHuuHpsihdA+SHHz0h/iRtiQSyQFAituS/oqMIUkqdDV+eqVKfTyM6i/FZQb58L31LLjvN6TrAlNAKCY4fbiDC8Y6cdvbrkwkFBVz4DGYg44DPS3hA+rOAocXYdMRvgEITw4oX4vkPbWs1efzEY1GWw3Oum3dsnIlkyZN6lIW04FE3n8kqSDjR5IKB3v8HAyWVMk8s/cXtQu8Kj5dIWIItLQBPPTo40TCCUFVrf4K25fL0co/a/eYwuHBKJqGMWpKCz/u5tjtdiKREHO+dxG5bg27CvVRQcU+T+36SKKeRl2k/e+lO9YSB1rchpYruhozqpv/bYqKiiguLuZHP/oR8Xic8847j/Xr16c8Cd7mBIu/ErVuF4oRSfiph6pRYkHsTg8v//c9/vy3x7D2+xOMyNT4yXEejshv20BgT4PJg+8E+bA80S9SFRjgVclxqwTjgt31Fj/68bVccMV1hOxZbSYgdEYqFi+lpaVompayJQkc/PcgycFNf4ifnha3205nkkgkEolEIulheqVKvd2FlTWSSNZojjn9HK659beUBO3URwReXeHdPXFuWtXA0i/CRIzWHT9FWNh2v4dj/cNoW1ah1O9JDNZqt6MEKlFrtqOWfYLiLwMrMRjszlLt/QkEAsTjcXw+Hy6XC6fTibJvkNZt65aZM4lGozgcjpTaJpFIJJIDR+PKHcMwmD9/PkVFReTm5jJ8+HByc3MpKipiwYIFGIaB2+1u+UzsQQzDIBqNUlxc3Oq9TKfCtwtsHJ5vo8CjMiJDY3S2hl2DHfUmm6pNTj/rfIy4gajYgOPN+9Bf/W27wrZweIkffjGRs+/HGDe9XWEby8Ty7yUtWsGRwwsIxASbqg121JuUBQQflxt8UmF0KGw3WkscKqucmtNoGWKz2bjuuuvYvHkzFRUVbN26lYqKCjZt2sSMGTO45557GDduHOvXrwcSfY7p06fzyiuvtOhvJEtjLEQika8n5V2ZWAWHY2aPQnjzEBlDUHJGYnP7+OStVYzJtpHhbHmcbbUmP1vdwGvWkViurFbHGZimcd+UNG45yUO6rmAJ2OO3+KrGRFPg8EI35552PFb1DtSqLWB1PXM7Go2i6zpLly5N+tppbvESi8W6fEyJRNL7yMxtiSQJZOa2pL8iY0iSCl2Nn96uUq9pGk7VIla5jRee+gcvrlxOrLacbHdigJSRncflJw5lpLUNxYy3sfcEZsERGEMmgisToTkSmdzOdIRmR3jzcWQPIRSNt8rcVlWVqVOnMnbsWLxeL4FAgI0bN7J69Wosy2rx2bKyMu69915efPHFJt/sxiXDuq4fFEtmext5/5GkgowfSSocrPHTE5ZUPWljsn+Wa4ZTYVg7mdrlAavJAsTlcvHsQ3ejbViJWvFFu/sXug+j6CyMUZPA5my/IZaBEq5FCdcihIUjLY8Va//HQwsfoTpksaPeIhBL7m/Y3efkwZC53Ujj3+WKK65gyJAh+Hw+/H4/mzZtarPP0UhPZx+3INKAHq0iWlfBzIsuoNCrke5UCMQEe/wmkWYhmJ6ezv979G80vPUYeZXrsbVhVdIQtXj4/RCvbEuIyaqqcf9dt/Ct4flEsaNmDEZ1+iCvCGF3dynOu3qdLVu2jClTpvSo9dvBeg+SHBr0h/iRtiQSyQFAituS/oqMIUkqdDV+ertKfaOdx7Zt23DZYEi6RvXOTYQD9XgIk263qK6r57X//g+t5G2mDlVwtWNXAmDmHYYx7CRwZSFUG8KdDc50VIcTT/5wvnXSVL7c9BU5OTnMmTOH4uJihg4dSllZGX6/H5/Px4ABAygpKeGRRx5h8eLFVFVVNdmrnHXWWbz88svA1yLFmWeeiaZpPWvdcpAi7z+SVJDxI0mFgzF+UrWkMk2zx21MGtv0+sv/4ZfXfB+vXXQoaivAd4bqzJ06Ek+kvN39Cj0NY8zZbXpqt8CIoITrUCL1CEA408GdjcPlwdDTGXn0qeyt6xtriYNJ3D5YfKP3x+l0snf3ds47+UgyXQo+h0KhL1HkszpsURawmqxKxo8fzwPzHuDL/61Ce+9Rxue0nUW9bneMhR+b3HDLXRxz7DGYoXqU+lJsDgcNagZhA/TCcWQPHdulOE/W4mXOnDld9itPhoPxHiQ5dOgP8SPFbYnkACDFbUl/RcaQJBUOCs/tZjTPMAuFQkydOpXDxoxksA+UUDXlu3ayZ/NHpOsQMQShuGDyCJ0LxjrxdCRy54zBHHYywpOLUDWEKxM9cwDP/Wclz73yFvP/+R803c2SJUtYuHBhi3MbPXo0xcXFzJ49G9M0Oe+885g5cyYzZsxg5MiRLbKrmosUAwcOpKqqqsvfEXTPS/RAIO8/klSQ8SNJhYMxflLxAi4rK8NutzN//vw2n0PXXHMNP/7xj3E4HBiGgWVZyWW6RhqwBcpwKjE+fOdtlvz1jzhErJWobVNh0nAHl37LzaC09p1PhTOd+JhzMEec1r6oLSyINiRE7Xg4MbnsygBXBkK1J+pgpBXiTs/u09oUB4u43dt9qVRonsSQ5VIYmanhsivkulXyPSoCqAiaVIcEgoTA/Yc//AFNUdi4cgFjAu/htrfer7C7UY7/EWL4ycQNgxdX/oePXl9JQ81edjdY1EYs7FmDOft713LV1VcnLUa3WzTT6yU7O5toNIppmsRisR6/RxyM9yDJoUN/iB8pbkskBwApbkv6KzKGJKnQnfjpzWyjjvbtsSsMz9DIciu4bAoD9mWdRU1BICa4+eKTGUcJSqx9QcHKGIox7GRE+iBsdh3LlYHqzeX9jz7lulvvZkOpn3jbK4Hxer088cQTTJ48GcMw+P3vf88f//jHNj9XWlra7vvJ0JF1y8GEvP9IUkHGjyQVDsb4SfX5eOGFFzJixIgWk6b7ryyqrKwkGAx2ntEdDaA27EaJNEA8jBauwW5FMNBY/b+PeWrly+zeswenDc4epXPJ4V6ynO1/h8KZQXzsuZgjTgWtnboQRgQlUo8SqQfLTBR4dmUmCjyrGsKTg/ANaBLF+9pa4mARt3t7FVxndGR7s7/wrgCD01UGp2noGgzwamS6FOJWQuSuCQvS09M5++yzmT59OvlpOrG3/oZt97ttHrvOO5Ib/v05pbVhFGBgmkq2S6UqKCgNmARigt0RJ3//Z9eLZ/aknU8yHIz3IMmhQ3+In34jbm/bto0RI0YciENLJF1GituS/oqMIUkqdCd+nE4nQgh+85vfYLfbCQQCbN68GUhkE7XnVd3ZUuJkM5nSdIURGRppzoTIne9RSdMVsnLyuP3392Fs/R/qppcSg+t2sDx5mMO+g33AODZs2co9f3mE8gYDQ0Cp32JnvYnRhsitaRorVqxg8uTJHHHEEWzatKnN/c+bN6/NzO5kkZnbkm8CMn4kqdCV+OkL0aunsnGb211NnDiRFStWoGlahyuLmtd8MCN+1PrdKOG6hNgcrESJBhA2B8KTi92ThaKp2EWUyIfPYftqDWo82G67LE8extizMYee1LaobRkQaUiI2kYkkaXtTAdnBtgcCLs7UazQnQ1qa9uKvrSWOFjE7d6uX9IWiqKg63pStjcul6vVJI1Dg5GZGrkeFV2DAq9GhjORYFAesKiLCFRF5e6772biiRMxt7+D+u7iNvtiDVGLB98J8caOhBd3lkthoE8jagh21luEDcEuPyz453ImTZ7crSz9vkA+wySp0B/ip9+I22PHjuW4447j4osvZtq0aTgc7czgSiQHAVLclvRXZAxJUqEr8bP/wKiyspKGhgZyc3NxOp04HA4qKiqor69v5VW9ZMkSlixZ0uFS4q5mMmU4FYakaWS4FHQN8jwaf73vt7z2xpsMK/oWh2fFEV88jxJu//4vdB/LP6vhvd1hQjGoDFlUBq1ERlLAYvd+BZQgIdLv2rWLe++9t93M7LZEimSRntuSbwoyfiSp0Fn8JCPmKYrSNAGZqujdE9m4jYWKH3zwQSZOnMjatWtZs2YNl112WadZzU89+U8mHTuGaNUurFgEQpWJrG3NkbAB0dNAUVBC1WhbVmPb9hqK0f4EqpU+BGPcuZgDj20tSgsBsSBKpA4lFkBAIjvbmb4vS1tFuLMRnjzQvZ2ed19ZSxws4nZfZ243n0BYtGhRp5MklmURj8fbtNdpvorOqSVW0aU5FcJxQVXcwT///QyqqhKPxyEawP7xP7HtXNdmu17+Ksr894KEDXDaYEiahm5T2Bu0qAhaGKqLl9//Cs3pOSgn++UzTJIK/SF+elrcbt8Qqw94//33ueWWW/jOd77D7373u3YzmCQSiUQikRy6NC4dNgyD+fPnU1RUxPnnn096ejqmafLQQw9RVFREQUEBY8aMobCwkKKiIp599lluvvlmtm/fzpQpU5oyg9pCUZQueZTWRQSf7jX4qMyg1G+xq8Ek4CrAsLl5bOFf2FRlwqRfEzvq+1ievLaPGfUzo8jO7d/xMW2Ug6JsjXG5Ngp9KoPTVY4faOewXI10/Ws/70AgwJIlSyguLkZV2+6Gbd68mcrKSsaMGZP0+TRSXFxMNBo96IVtiUQiOVhp65mVm5vL8OHDGTduHPfffz/hcBhd1wkGg1RUVBAKhfD5fLhcLpxOJ4rSfh2HtujqM6wtGgsZ5+TksGLFCtasWcOMGTM63K/TBoWOMPdeP4sPXn0eR6QKtXYbaiyE8BUgskaAMx2lrgT7+ofRX/w59s0vtytsmzljiH5nLtEpv8EcfEJLYdsyIVSDUrMNtX4XmHEsTx4iexQifRDCV4CVNRyr8KjEcZMQtoGmjOFwOIzf78flcpGXl4fL5cLv9xMKhbpcSPNgxjRNcnJyGD16dLe2LyoqIjs7O2mf8sYip4WFhcydO7fVyoItW7Ywd+5cCgsLWbNmDTabDV3XWbp0KZrWcmIjGBd8XmnwcblBRdBie73JlmoTRVX57Y0/wh6uIh7bl02ue4mfUIx1ys+IKK392aeN0ll4TjpjczQiBmypMakKWeR7VEZlariVMC8svgctXN2t70kikRxaHFBxGxIPo/r6ev71r39xwQUXMHPmTJ5++mnC4fCBbppEIpFIJJIUaWtglJOTw9q1a1m3bh1DhgzpcLA0ZMgQXnvttU6FAiEEXm9yA+Hm+GOCLypN3i+N48wdQXlI5fO9Me5b8Hfi4XrUrOHETrqB6PFXY2UOa3MfLrvCtFFOfv0dLzPHOzki38b4XBuDfRoDfSpHFtg4eoCNfI+KAixcuJBhw4YxderUdtsVCoXIzs7u0rl4vV7mzJnT7SXXEolE8k2nIzFv4sSJbNiwgR/96EcsWbKkheidm5tLUVERCxYswDAM3G53K2GvI7r7DGuOz+fD7/czZ84cNE3jsssua/d54LTBmGyN4wrtDEpTGeBRWLbg9xiBGrT0AVjZI8GZjlr2EY7X/oBzzV3Ydq1HEW1bZZkDvk309NuInf4rrIIjoPkz24ii+MtRq79CCVQg7E6szGGIrOEIXz5W+mDMgsOx8g9DePNAtXX7OzAMg2g0SiQS6bcTvY3nWFxc3K3tk50EVxQFp9PJ6tWrmT59eqeTL4FAgOnTp/PKK6+gKApnnnkmK1asaDOuG6KCTyoMPq0wCAgnP5r7W8YcewpxfyVqzXaI+oHE9WgfdRI/f1PltZLWEyoD0zQePDON7x3uRFGgLGCxtdbEpkFRlo3/vvwc9oad2EJ7u/ANSSSSQ5EDZksyY8YMNmzYkGjEvodfY1MURcHtdnPOOedw8cUXc/jhhx+IJkokTUhbEkl/RcaQJBWSWdbdKBJMnz69Kdtow4YNrFu3jhkzZiSdObRy5coObUl6yq90+tln8uX6tRR4VW647lrOn3oKsdoyFCuOsLtRQtXYt7+GWvZph/v7tCLO27vibK0x8EcFlSGLhpggakCp3+TdDTu4977/48EHH2xz+6qqKioqKjjiiCNafEeqqjJ16lTGjh3bwp987dq1/Oc//+nwO+pLkvGolfcfSSrI+JGkQlvx09Yzq5Gu2nwsXdq1gnY99Qw755xzWLBgAc8880ybhSldNhiSrpHnUbGrCUuubLeCEAlrrYt/8GOmn3s2xua12DavQg1UtHtMoaiYg0/AGHsOIn3wfm9aEA2gRGpRYqGEl7YrA1wZoNoRzjQsb37CW7uLWe4HioPFlgQSvtuGYbRp/dERndUv6clj2O12VFXt3A/9yivRozXEKrdiRcMo/vKEXY3uw5Y5iIhhcsEFFwAwabiDG4734HG0jpnPKuL8/q0AVSGBqkChL1Fs8rfzHkHPGYTlHYCSNbRPikUmg3yGSVKhP8RPT9uSdH9aNEWee+45vvjiC5YuXcqLL77YdMNsHAQFg0GeeuopnnrqKcaMGcPMmTOZPn16yjPaEolEIpFI+gZd14lGo8yaNatpcJ9MRtn+mKbJzJkzKS0txeFwtDkga57J1NaAvjOKi4spKSnhhVVrsCyLHfUmD//7Bb57yWUYdh9mqBYlVAN2F+LIWdQOPo0Pl/6J04Y60NTWg6wj8u0ckW9nT4PJmztifLo3TkNUUBkSOG0Q27aeIT4LXYPofl9D45LhjIwMVqxYwaxZs3A6ncyZM4fi4mKGDh1KWVlZ0xL0AQMG4Pf7cbvdB1TY7krBqUOxEy6RSPo3bT2zgFY2H509uxozWDublG1OTz3DAIYOHcrChQtbvJ+uKwxOS3gd25SWovbeoEVlyCLTqVFQ+Rbqcy/i2Jc52xZCc2AOPwWjaBrCs5/vsxFNeGlH6sEyEXY3Vloh6L6EwO3JRnjzwe7u8jlKviYajeJ2u1m6dGmriZj20DSNZcuWNXl2d4aqqixatKjLdjmBQIDFixdz7bXXEgqFcDgcXHPNNdx0003t+qGHrAxE7mGotSWg2RGRBpRABUrNNqKGhgIIYO32GF9UGtx6kodv5dlbHPfwfDuPnJPOvW8Hea80jl/xcdakM9CNBuzhGhrCYYJVe3EWjiMnN1f2SSSSfsYBy9xuTjgc5sUXX+Spp57i448/BtrO5nY6nUybNo2LL76Yo48++kA1V/INRGZuS/orMoYkqdBZ/LjdbubPn980UFdVlW3btrWbUdYZ8+bNaxostUUqWUbtFXms2luBywoQr9qBYsYSBY7iDcSDtfzil79GCJg8QuesUTpOW/vZZ/6oxVs7Y7xXGqcqLPj9/Qt44j8vs+zpZ6kJW5T6LWojosV5RqNRnE4n8XgcIQTxeJwlS5Z0WswpEon0uTVJVwpOOZ1OYrEY8Xhc3n8k3UY+vySp0Fb87P/MauTWW2/l5ptvZsiQIb2WJQs98wyLRqPcfPPNFBYWogC5HpVBaSpeh4JTg1yPRobz60ztypDFtwalU3zKEEbbKlCs9rNZhTMDY/QUjBGngaNZwpkQEPOjhBuztLVEcUhnBth0hM2J8OYlClOmYDlyoDmYMrfhawud1atXM2vWrE5XEyxbtowpU6YktZqgp1YSNC9uncyKLgAlVI1StxMlHsEeqydeX87Nv/wVZQGLun39JFWBy77l5PIjXG0mGKwu83DitX9Gszl47YVn+fStl9m0cy+7/CZ7AxZm1nCKi685oP0m+QyTpEJ/iJ+eztw+KMTt5nz11VcsW7aMFStWUFdXB3ydzd34f4ARI0Ywc+ZMzj///KY/qkTSW0hxW9JfkTEkSYWO4qetgdG0adN46aWXenSwtH972ltS3h6aprF8+XJOOOEExo8fT1VVVYv3S0pKyMvLIxIOo4RrUBrKsFlRnDa49fo5ROv3EjMFobjglKEOpo9xkulsv6SJaQk+q7Fx1PQreeTfL/C/D7+kKmQRMQURA+otJ+99uR3N4SIajWKz2XC73axatSqpwWtXl8L3BF0dYC9dupQzzzwT0zRxOByAvP9Iuo58fklSYf/40TStTTGvtydl929Tqs+w4uJiLv/epUw+4XAKfRq6DXwOhTy3ildXiJlQFbKojVhMHGTne0dnM8oX6/AYdWoG3uNmoY08hZhpYVn7fLctAyVchxKpAzOOsLsQrsx9WdoawpWJ8OSBMy2Zr+qg52ATt6HlxHKH1h9z5nRJxG3M7s7Nze30s+1RVVWFy+VKamKnFZaBUr8HW7gKl0Pjlz+ZTaRuL8GYYI/fJLyvCzgux8avvuNhgLe1v32DaxDXP7WFPbVhMpwKQ9I0GqKCHfWJwpNfVpp4DlC/CeQzTJIa/SF++r243UgsFmP16tU8/fTTvPPOO00+aNAym9tutzNlyhQuvvhiJkyYcCCbLOnHSHFb0l+RMSRJhY7ip62B0Y033tiUUdZdOhssdVVoffLJJ5k0aRJnnHEG69evT+544Trc8VqW//tx/v63BeR7NdJ1hbglqA1bfLvAzoXjnIzI7DhDbXO1wVs7Y2yoMvDHBHUR+MXtv+PoY48jrLgQ3nzcWQVdFjq6shQ+VVIRY0477TSApgH3gfa/lBxayOeXJBX2jx+Hw9GmmNfbk7L7053JwtNPP50zzjiDj99fz23XX8nV35vBxRfNINOlkuNScNkVQvFE7Qch4JzROucW6eR5Oi54+c6eGE9/GeGjcgOXy8Wdd9zJsccdS9RfhwhWo0QbECgIPS3hpW13IWx6IkvbnQOavcP9H2ocjOI2JGLZ4XCgqipOp7Nd649YLJb0fdLpdFJRUcHw4cO73a6m5IBIpNv7IB7CHalk+ZOP8fijD1PoVXHZFfYGLcoCiUkWj13hFyd6OHmIo9XmtRGLe/4b4MNygzRdYWi6RjAm2F5nUh8VfFlpYNK3/aZG5DNMkgr9IX6+MeJ2c3bt2sWyZct47rnnmjKq2srmHjx4MBdffDEXXngh2dnZB6y9kv6HFLcl/RUZQ5JU6Ch+2hoY3XbbbVx++eWMGTOm28dMZrCUbCbT7NmzicfjTJ8+vU1huyNRwul0YgRrmXzcWJwiglOjmcidyIwbnK5y4VgnEwa1HnA1pzpksb7MZMypFzPqW0cTU92YehoOtw9DtXPMqWeztcKPmeTl2dWl8KmQ6jL6Bx54gBNOOIEzzzyTYDDY58uCJYcu8vklSYX940fX9TbFvL6YlN2fLmXjOhxcfN6ZbP34LbLdKhOPP47f3/ZzfnvrjdRUV1IfFVQGLQb6VC4Y6+S0YQ4cWvsWWjFTsGZblKc3RNhZbzX9XgEy3Tbu/sX1jB05lJgFljMjYT2iaghXBpYnD5zph0yByK5ysIrbzUnW+qMzDnjmdjOcTieGv5JzTzwcjDC5bpUBXpWQIdhRZxLfF6YXjtUpPtaLqrR8FpiW4NGPwiz7MoLXoTAsQyNqCHbWCw476jicg4/AnVXAL37xCyBhmdsXyGeYJBX6Q/z0tLjd/rrZg4jBgwczd+5c3njjDR566CFOOeUUVDXR9MYbtxCCnTt3Mm/ePE499VRuuOEG3n777QPccolEIpFIvpkIIVoVgQ4EAvh8vpT26/V6O+3AmaZJKBRC0zSuu+46Nm/eTFlZWdO/mzZtYsaMGdx7772MHz++TWEbEgW6otFomwPDaDSKnpbDnfP/zad7BWWBxFLXTdUGgZigwKsSM+Hh90Nc/Xwd/9kUIWK03e5st8o5I+2M3LMS85NnoOwT1OqtKLU7WPPsPynQI0wcbKcoS8Pr6Fw0aCzmpGkdZ+X1BKkUnFqyZAmzZ8/mggsuYPXq1TidzqaEBYlEIulL2npmQeKZ4/e3X1wxGQKBQNPYNRmaP8OuueYaNm/eTFVVFSUlJVRVVbFxwwau/eGl2Op3wO73uXX2dAZn2Bns0wjt+ISaXVs49juT2VJjMCJD455JPhack87UkXq7wnZN2OLxT8Jc9mwd89aHmoRtuwoFXpVxuTYG+2DBI48Q9w5Ayx+L8OZjpQ/CHHAkVk5RIntb3sMPKI2FSSORSLv9l2QwTZOcnBxGjx7dre0bC2P3xIR1NBpFzyjglgf/xc6GRAHUr2pM7KrCmGwbaXoi5pZvitNw0s8JKS2LlWqqwtXHuLntOx4MS1BpeDh72pk88Zff8n+/u42ffW8al517Og0NDTidTlwul+yPSCSHIIdE5nZbVFRUsGjRIv75z3+2uPHsn809ZMgQfvjDH/Ld734Xu71/LY2S9B0yc1vSX5ExJEmFg81zuy2cTidCCO6++24cDgd+v59NmzaxevXqr31D2yCZ7Of9l48rsSBD0zWy3Ao2JSFaZ7tV7CrEFAdXX3MDh6cFERteQgnXdNhuK60QbdgE7n/8eUrKq6gJW1SHLOIWBGKCMr/F3qDVbjZ3d76rrtJTBaduv/12/vKXv7B79+4+yTbvDXoqW06SPPL5dfBzMF8XyXpu90TmdmVlJZmZmd1endL0PUb9CH8FVrAaKx4DI4oWD+IQETZ9/gmLlvw/SmvDXHDBdGYcnkngw+VkOjsW6L6sNFi+KcKbO2IYzR6JThvkulUynSqWgNqwoCpsEjXh6utu5Ls/uj4hIiqHRK5cj3AoZG73JO0VWE2GrnjNJ0Pz/taV35/FEHcUtw2GpGukOxWqQhaDxh3DvX+8j+Iffp/vDa/nxMGtV82Vhmykz/gdqjeXt198ivfefo1Pt1dQGbLYG7AQ2cO5+sd9U2hSPsMkqdAf4ucbaUuyP+vXr+epp57ilVdeIR6Pt3ivPW/uwsJC7rzzTk455ZQ+b6/k0EeK25L+iowhSSp0Fj/7D4z6sjBX8zZ2xxM6Wf/FtpaP796+hYE+jXyvyrAhg/juuVOZctIx2EUcEw1cGajVX6FsehmlqmNROBQX/G9XjPdL4+wNWvijguqwRUNMYO6zPykLWDREW7exp5YEt0dPLVvOzs6mpKSE3bt3c9xxx/XYYLi3URQFXddRVRVd16mqqmryOc3JySESiSCEIBqNyntrLyCfXwcnPXFd9IUo3lb8tCXm9dSk7HvvvceRRx7ZdU9fISBSh9pQihILghGFaANK1I9iREFRUZxp2L2ZGBWbqPrfv8k3SlE70LQNC+xFp3Hnk+t4a2NZi/e8DoVct0ravuKTlUGLmnBiIrUqZLHHb1EwdHSvT54ejHzTxO1UbMd6wxqteX/r0UV/Y9UTCwhV7SLHpTLApzLtnPM58azvMmPmpSjApd9y8sNvu1D3y8A2VJ3fvtHA2yVBBnhV8jwqdRHBrnqThpjg870GDlfvF5qUzzBJKvSH+PnGitvV1dU888wzPP300+zatQtoLWRrmsbEiRPZtm0bpaWlQGtv7p///OdceeWVB+YkJIcsUtyW9FdkDElSobP4aWtgdOutt3LzzTczZMiQPhssdbVA17Jly5gyZUrSA5p2izm5nWQ5TGLVO7GiIeKhBgjXoEQaUFQN4cyAqB/b9jfQdq5DMWMdHueLyjjrdsXZXG0QMROZdNVhk5gJwZigPGBRHvg6m7tHijl1QE8UnNq8eTMvvPAClmUxe/ZsvF4vsViMWKzj7+JA03yQvWjRIhYuXNhC+Bo9ejTFxcV9kv31TUU+vw4+Urku+nqyqK34aeuZ1ROTsjNmzODII4/s2uoUYaGEqlEaylCMCMSCidexYMLj2uFF6D4wothK/ou2/U3UTlYEVQYtVm6OoI6dyoxLruCi716U+C6AdKdCnjtRrC8cF1SGBLURi7gJZQGTUr9FrNktrLcnTw9Gvmnidm8nB3S3Tc37WzU7NhAt24TLJvBZDdTsLeMnt95FRcBCAMcX2vnVdzx4HS1XGFhCsPjDhA93uq4wOF0jZiQKTfpj8GlFnLjo/XORzzBJd+kP8fON89x+8803uf766zn11FN54IEH2LlzZ4s/nBCC3NxcrrvuOtauXcvixYt59dVXefTRR5kyZUqT+N0oct9///189NFHB+p0JBKJRCL5xhCNRtF1naVLlzb5Py9evBjTNHniiSeS9oTWNI1ly5ah63q3RM9G/9LJkydTWlrKvHnzWvlIFhUVMW/ePEpLS5sGMsmKkY2CSzgcxu/343K5yMvLw+XxEVB9hDKKiKQPQ/jyIW0gInskljMdIrUoVhxj9FQiZ/6B2JGXYnnz2z3OYbl25hzt5teneDl7lIPxORrjcmyMzNAY6FMZmaUxcbCdsdkaabrSoT+5zWZD13WcTie6rmOz2ZL/Qpudd1setV3B5/NRUlLC3LlzGTJkCK+88gpOp7NH/cJ74lyb0zhZsmbNGgoLC5k7d26rjM4tW7Ywd+5cCgsLWbNmDW63u0880CWSA0Uq10XjtoZhMH/+fIqKisjNzWX48OHk5uZSVFTEggULMAyjV6+ltp5ZlmWxcOHCpsm3ruD1epk9ezYLFy6koaEhuVoI8TBK/W7Usk9Qa7ajBCtRarej1u0Ey8BKK8TKGoESrMTx/qM4X/w59i+XdyhsW7ljecd5Ere86+GJzyMornRCoVALP+2h6RqGBVtrTTbXmJQFEr7G7+yJU1LXUtiGhI+49CTu3wghiEQiTJ06lRUrVnQa/16vl5UrVzJlypSmyajeaFPz/pYzdygZ405GzyggnjYEe2YhuW6VomwNj13h3dI4173YQK1o2XZVSfhw/3yih2Bc8FWNgabCqCwb6Tp8u8COU7WYOXMm0WgUh6PjwuASieTAc1BmbpeXl/P000/zzDPPUF5eDrTO0lYUhZNOOolLLrmE008/vd2Owvbt27n77rtZv3590/ZnnXUW8+bN65uTkfQLZOa2pL8iY0iSCsnET1tZ0xMmTODVV19lzZo1XHbZZT2eSd1Re9vMsPZ6yc7OJhqNYpomsVis966FWBAlUJHIwDMNiNSjROpQjChCs4OehtJQir3kTdTSj0C07wsOsLHK4J3dMTZWGwTjX2dz5w8YzOP/fpqg4sHQ00Fz9HhmZE95bp911lm8/PLLQM9lffVWFujBmMn2TUU+vw4eUrkuJk+ejKqqrFq1KqmVNT1lFdBe/LT1zMrJyWHDhg2sX7+eCy64IOnzW758OSeccALjx4+nqqqq/VoIloESqkkI2bEgWGbCeiRUg2LGEA43wpUNVhzb9jfRtr+BGqru8PjC5sQcMhFj1BnYckaiqInnX0N9A4oRhlA1t/38p638tP1Rwe4Gk8pQx9eTzNxum/6Uud1IW/ZrzZ/5RUVFFBcXM2fOnF5bqdSpVZGwsIf24o7XcuUV30P1l+NxJLy4K4Lwr//3dyJr5zHQ3N1q359UxLn7jQDhuGBEpoZNVdhWa+LfZ1Fy1z3396h/eCPyGSZJhf4QP/3WlsQ0TV577TWWLVvG22+/jWVZLexEGv+fnZ3NRRddxMyZMxk0aFBS+7Ysi4suuogNGzYAUFBQwOuvv94r5yHpn0hxW9JfkTEkSYVk46etgVF2djYrV65E0zQee+yxPh8sHchCZzabDQ0TJbAX/BVY8ShmJADh2oSPKgLh8OKwa2xe/Tj5DZ+T6ep4sV0oLli/O8aHZXHKAhZnXzCT08+eQRQHQlFRPVnoWYOIam4WLX60x2w0Ui04NWPGDEaOHNmiuGeqfp29aRlysHmQfpORz6+Dh+5eF8OGDWPz5s288sorfT5Z1FH8tPfMev3111m7dm1SIvyTTz7JpEmTOOOMM1i/fn3Te02icCSSmNwMVaGEa1EsC2IBlEh94l9IWI8401ErN2IreQu1/FOUTiY8rczhGCNOwxwyAWzOZm8YaLEAaqwB1Yxhc3m44da7+HJbaQs/7bbqN+xPXxQsPhj5porbcGCSA7ozSe22wbKH72Hxgj+T41Ip8KoUjRvPT26/jx/88Eq+k1nNlUe5Wx1rT4PJba/5KfVbDM/UcGoK2+tMGqKCaPpQ3vtsS4/Hu3yGSVKhP8RPvxO3d+3axVNPPcWzzz5LdXViBrqtopAnnHACl1xyCVOmTOnWctInn3ySu+++G0gMKj///PMeOgPJNwEpbkv6KzKGJKnQlfhpa2AUCoXIysrCbrfjcDgOTCZ1H9HuIM3jJtutEq3aBeE6YtEwRBpQwnXYFRMLlZ/8/JcM9xpMG6Xz7QJ7p8cqqbcYPOF8yB1DXHOgujJwpOfz/idfcPudd7OjKkh50CIQa/2ddjUzMhWxd9euXdx777388Y9/bPV+d4qHQtf91buaBZqqmN8b2V/fVOTz6+Chu9fFrbfeyq233sqgQYP6fLKos/hp65nlcDhwOByEQqEOJ2Vnz55NPB5n+vTpLYRtgJKvNpHnhljNbhQzDsY+kTvSgGIZCJsTnGkQqcO2Y12iHkOs4++mKUt7xGmIzGHN3hCJ1UKROpRYAAEJn25nOrovm2f+s5Jf3/PnVn7anfFNvZd9k8Xt5vRFckB3J6mdTidGPM6xYwaRa4/gssOcC6cydfIkLr3uFsIGnDzYzi0ne3HZWtrqBGIWv3kzwMflBsMyErYmO+pM6qOC5W99gTN7YI9OTstnmCQV+kP89Btx+4UXXuCpp57i3XffRQjRZpZ2RkYGM2bMYNasWQwbNiyl4/33v//lqquuajpGYxa3RJIMUtyW9FdkDElSobvx09bACDhgmdS9TdKDtNk/QI/VEavZgxWPgBHGaYbZ9Om7LFq0iIaIiUODk4c4OHOkTlYn2dxCtWPlH4ZaeDibK6M89Le/UxU0qA1bGCKR7b03aFERsIg2Eza6khnZXTuC/Zfr7093MgN72zKkp2xYvmnZjr2FfH4dHHT3uuiJQo2pCKxdiZ/GZ5bNZsPv9/OnP/2J4uJihg0bRnl5OX6/H5/PR0FBASUlJSxcuJBHH3206d6mALkelQKPyhurVqA77MT9VQnROR5JFIh0piMUDa30Q2zb/4tav7PTc7AyhmKMPB1z8ASwu75+w4yhROoTWeBmHGFzIpzp4ExPHEv34cgahKGnUziw7ycWDlWkuN03pDJJbVlWUz/g4hnTGZetcO2VlzNtwnh+f/cd7KwzaYgJRmVp/O50Hznulv0o0xI88E6QVV/FGJKuka4r7GqwePixJ8kYeTQRW1qPnad8hklSoT/ET78Rt8eOHds0gN0/S/voo4/mkksuYdq0aT1m3r9u3Tpmz54NSHFb0nWkuC3pr8gYkqSCjJ/O6c4gbcqUKYRrShH15WhxP7rdxsfvvMljCx5As6LELWiIWIzM0pg6QufYQjua2nFhr9qI4J3dUT6tMCgPWARjgpqIoD5iYQENEcHekEVl0CJudU3A6Oo5trdcf3+66una25Yhuq4TCoXIzc1Net/78030qe0t5P3n4KC718W0adN46aWXDthkUXfip7mQv3XrVqZOncqYMWPw+Xz4/X42bdrE6tWrm2yWfA6FAq9KrkfFpkLRsEEsfOBeInV7EZaJcHgQDi9qzXZsO95GLf0IRXQ8KSc0HXPIBIyRpyMyhzd7QyTsTMK1KLEgQlUR+j5B2+5CaHaEOwfhyQW7U9YP6AZS3O59eiIuVVVt6pNcdsksfnXVRfzokhnMnXMJabrCbr9JTViQ7VL4zek+xmS3dgV4/JMwj38aZlCaSrZL5bd/fhRHRj5RTwHCN6DHzlU+wyTdpT/ET0+L26mVi+8hhBD4fD7OP/98LrnkEkaNGtXjx0hLS+O4447r8f1KJBKJRCKRtIWiKDidTlavXp3UIC0QCDB9+vSvB2l6OvF4FBGp5siTpnLf0Sfy8vPLeeuV51HYS11EsOTjMC+W+Zh10mjG2cpQ2ikylulUmDbKybRRsL3W4L3SOF9UGtRHVPwxQa3DIs2pMDJToz4i2BsK8fdFj1B83fWdnqdpmoRCISZPnkxpaWmHBacal+t3Jmw3fh9ud2tvzPZQVZVFixZ1SdhuPM7ixYu59tprO/ycoihd3ndbx+rKOUkkBxv7r7zRNK1b18XYsWMpKyvrlrANsHnzZqqrq3G5XH22EsIwDKLRKMXFxcydO5eXX365qRhuIy4b5HhV8r0qbruCXYUsl0qmU2HW1AkYoXosPQMi9Wglb2HbsQ4lWt/psc2cMZjDv4M56LivvbSFBfEwSiyAEvUnsrTtTixfAehpCFUDVwaWJxecGaB8PQkqhCASiTB16lRWrFiR1MRk8+LOh6KQIjn40XWdaDTKrFmzkq6FYZomM2fOpLS0FIfDQTQabeqT7NpTyppXVpM9dCyGt4Dq+nIGp2nYVYuKoMXPVjVw80leTh3aMqHyB0e6yPWo/Hl9kPz8AXhFAxG/ghqPY1kmIj252m8SiaTvOKCZ2wBHHHEEs2bN4pxzzsHpdHaylURyYJCZ25L+iowhSSrI+OmYnswkVgCHFUYNVeEwAjTU1xGtr8RFBI8dDNPCsnswa3dj27kOdc+HnWYAmpbgkwqDj8ribK4xiBiJDO7aaMKPe9Cgwfzz6ecJCB3D7gWtY7/vRo9aTdPQdZ3q6mpqamo6XK7fEV3Jcu4LyxCZuX1wIe8/fUdnhd2qqqq6fF3cdtttXH755YwZM6bb7SopKSEvL49IJNLlbbsbP23d170OhRy3QrZLxeNQUIF0p0qWU8GrK5gCojh48P7/Qyv7GKXkbVR/WafHslxZmMNOxhx2MsKbn/ilGUtkaMeCKLEQCAuh2hC6NyFg210IzYHw5iaytLWOV0G3VTyzL4s7H0rIzO3epyfrWjT3zVcVhX/85Xc8Pv+P5LlVBvhU6iKCXQ0mQsCVR7m45FuuVvt8d0+M8jGXce7kU4nX7sFyZ4M3D8ubh8gY2mLCqKvIZ5gkFfpD/PSbzO1Zs2ZxySWXME7e/CUSiUQikRzkdKeAUk9mEgsgqrrAO5i4InC4atB9WRALEYlHMIM1KKF6FLub+JizEePOx1GzGbb9F612e5vH0VSFowfYOXqAnUDM4oPSOJ/tNdhRbxI1ob6ulPpdX6J7MrAMA5zpCFcmwpXZptAthGgSbYUQZGdn849//IOSkpJWy/U7o6ioiOzsbPx+f1Kf1zSNqqqqXs0CNU2TnJwcRo8e3W0BvSvnJOkf9EXxtd6ks5oBV155JYsXL+7ydREIBPD5fCm1zev19vmAPhqN4na7eeqJx7nhR7PI0kG3gaZAmq6Sriv4dAVVgUBMUBexOLpQ54rvjMCx+rZO9y9UO+bAYzCHfwcrbzwoaiJDO1KXsByJRxCKAnZ3QmhzeBKCNuzL0s5LWJEkKbo1rrxxOBxcc8013HTTTe0Wd5YZ25LexGazoes6Cxcu7Nb2Cxcu5KabbiIWi2EYRos+idvtZmbxzdw370EgQtQUDE7TKMrW2FFnsvijMHuDFj853o3a7No5fqADy/4+lnIGljcfNVCBJUxUIbCElbAGSkHglkgkPccBE7fvvvvuA3VoiUQikUgkkk7pLFsxEok0DZ72H/D39CCtOYZQMPRs0LMhGkAJVqIodnDnIGLBRJGyWAAyh1L/rcHc+aubOXGwg8nDdXI9bReh9DpUTh2mc+owndqIxXt74ny+18Ao34wzIxNFde7zc61DKCWg+xJCtzMD7K1X3oXDYRRFwbIsHnzwwS6ff3FxMdFotEvFJHvbMmR/S4Ku0tVzkhw8dFWgTuXecTCRjJ/+kiVLuP3227t8XWzcuJEBAwYcWpNFwoJQLdHKKiaNy+bxB3/PQ//3exwiiseuoCgQjAlqwxbjc23MPMzBsQP21UQIl3a865xRiBGnEi08BuyexC/NWELQjtTDPo9uK30Q2N2JwpCaPVEoUk9L/NvJ6pp2j91MBIzH47hcLtxuN0IIWQBX0mf05iR1OBzG7XbzwKP/Zvas8xmVCaG4wdAMjdFZNkoDJis2R6kKW/z6ZC+67WvBWq0tgdV3opzyC6y0Aaj+cixhoUJC4M4aKQVuieQg4IDZkkgkhxLSlkTSX5ExJEmF/hw/nWUrjh49muLiYq666qo2l2r3uYWFZaKEaxJCdzQAloHdDBGv38ttv/wFhgV1EYtBaSqnDdU5eagDl63zwZjlyoLCI4lnjQRXNkKzIRw+0L2JjEFFRdhdCGdGIqPb4Wka5PV2gcfm9NX33ZfnJOmY3r7/dFegTvXecSBoS7w3TTPpwm633norN998M0OGDEn6ulBVle3bt/P000/3iAVBV+lS/MRDKMHqxP3VMiAWRIs2YLciGIbBm+s/4KU1r5EWr+TkIQ4mDk7u/loWMHl1e4wvgpkcO/kCzj33XOyaSixQgwjXoUQDicKQzgxwZoLNgbC7Ee6shJjt8HTr3CXdQ9qS9C5Op5OKigqGDx/e+YfboSOrouaTdT+4bBaDXRHSdIVCr0auR6E+KthVb1KUbeP3Z/hI01tew8KZTvSUXyCc6agNpYmCsGmDsDw5iKwRXRa4+3MfWtL79If46WlbEiluSyRJIMVtSX9FxpAkFfpr/CSTrdiI1+tl6dKlTJ06lVAo1CQA9fYgrUPiYZRgJbZoHW7dxpwrvk+4ppwMV6K4WTguCBuCb+XaOGOEzlEFyWX7Wd58rIIjMLNHgzMNoajgcCN0Hzi8oNoSmYTuHIQnG8XhSVoca0TTtK8LanZhCXxfeG5DIub76pwkHdOb95/uCtQ9ce/oKzoT7xsnYcaOHUtJSUmH+8rJyWHDhg2sW7eOGTNmJH1dfPHFFxQWFh6QyaJO4yceQgnVJH6MCFgmROoTmdRmDGFzIBweHA27UXa/j7rnIzA6v1fXRyxe3xFLiNqViXtNwtJEIT/dxU+ums3YsUXEhA3T4UvYQakawpWV8N3Wvd063/051O1yDgRS3O5d+mKSuoXH/KJFPP+PBRi1O0lzKAxO18jJzePIU89j2inHY3/zTyiBvS22Fw4P5qm/wPLmI2p3Yuk+8BUmPLgzhzUJ3MlcX/21Dy3pG/pD/EhxWyI5AEhxW9JfkTEkSYX+GD89JV4eFMUHhcCtxHhy8V949KH/Q1UgzaGQ5VKbPGH9MYGK4OgBDk4d5mBMdnKOdVbaQKz8wxJCt8O7zwPWhdDTwJmWELrtblRfHs6cQbzy6hvMmjWLUCjE1KlTGTt2LF6vl0AgwMaNG1m9ejVut5tly5YxZcqUbol9PVmIqiO6KmCmck6S9umt+093BepwOIyu64fExEey4v2VV15JPB7nvPPOY/369R3uc8KECbz66qusWbOGyy67LOnrwrKsA/KdtYofy4JGW6fmgnbMjxLxQzyIAgibjlK/G63sU7SyT1DMzu/PpmLjje0h1m6L8n5pHFOAqkC6rpDhVPE5EoJYKC7wxxV+9qu7OfrY44kYFpYnucKQyZ5zf7DLOVBIcbt36ctJ6sZCk06nk5rdW4nu+QKXTcFn1mBEw1hpAzFiEfT//h9K7Y4W2wvNgTb5FuK+QVC3m7jmRvgGINIKcBSMSfr66o99aEnf0R/iR4rbEskBQIrbkv6KjCFJKvTH+Okp24meGqQ1iq3dza5rPJ/BAwtxixD5XpU0XUEFMlwqmU4Fj11BAA1RgcsGxw20c/pwJ0PS2vbn3h/Lk4c54HCs7NHgzEgUNnN4Ec400H2omg2HLwvhyiSETmbeQMrKyvD7/fh8PgYMGEBNTQ0ejwdFUbpt09CXliEtsr8WL+bhhx9u8XcuKiqiuLiYOXPmHDTWE/2N3rj/pDK5NWXKFMLh8EFvWdNV8f6JJ55g8uTJnHHGGUkJ3CtXrkTTNB577LGkrgvggEwWKYpCus8D4ToaKnZAuD5hOWIZifoCkYaE2A0I1YZSvwut4gu08k9RzFin+xeKCgWHYw6dyKW3PEBtIJyYYGwmaCtAMC6ojyQKTxoCogaEcPL2xxvRXOlEY50fKxkORbucgw0pbvc+fTVJ3UhThrUZQ+zdhAjVYdXuRDUi2HOGETctGpb/mhyrqsV2hgUfuE/kqGnfwx7ai2H3YcsaTMyZzd+eXp3U9WVZVr/rQ0v6jv4wBpPitkRyAJDitqS/ImNIkgr9MX56cmDV3X3l5OTw3HPPcfzxx+NwOKivr8c0TXRdx+PxEIvFME0zqey6tsQ6pw3yPSp5HhWXPWFVkuFUyXAquO0KApUri29g/MjBGLveR9v1LmqwMqm2W65MrPxvYWaPAk8uQrOhOtOxe7OIKw6ef/Ellj23go8376Q6ZFEfFT0mqvS1Zcj+2V/V1dVNWVrZ2dlEo1FM0yQWi/WLa+NgozfuP92dIElLS2Pv3r19Ksp0h+5eI8uXL2fChAmMGzeOqqqqDj+fk5PDlVdeyV133ZX0ddFnk0VC7BOu61Gj9Xj3ZUwHaisTxXljAYhHEoI2ArVuB9rejah7v0xO0EbByh2DOeh4zEHHoafnsvy55/jnkoVkOBXSdBVNSQjadWFBfdQibkHEgKqQRWXQwh9LfCc9GROHkl3OwYwUt3ufA1rXwjJRq79Ci9ajR6vZ9PG7/GH+EqoawtxxipcTBrVcPWEJwUMfxDnlspv49vBctpbVcOMdf2RTeYCSOqvddjZf7ePz+YD+04eW9B39YQwmxW2J5AAgxW1Jf0XGkCQV+lv89PSS2O4M0iZOnMiKFStwOp189NFHDB8+nEGDBrXKdI5Go2iaRjgc7jSTuyNhw+dQyPeo5HpU7Bqke1zcdctNHF40lFjIjxAJj0nCNdjKPkPb/S5KpC6pcxG6Dyv/MLT8MWyuCPH3x/9JdUOEhpigfl+Wormv0GV1WBDT3PzjifZFlWQ8LPvKMmT/tjQi/Wvbp6c9fnvj/tPdCalp06bx0ksv9fpy+lRJRTjatWsX9957L3/84x+T2qakpISCggJM00zqb57MZJGiKMRiMeLxeNJtx4iiROoT962oH8UyE9nZ8RAem4BogHCwARQNYiHUmm2oe79Erf6KxJqWjhEoWHnjMAcdhznwGHCmgxBoZgSnEuW3v76ZmupKwnFBfVRQG7GImRAzoTJosbeZoN2cnooJWSeg55Didu9zoONVAdzhMj5442Ueuvc2sp1QEUxMPN18kodJw/VW2/z13TCnfG8uRQO8zL3jHjaX1bOz3mxX4G7eXocjIZj3hz60pG/pD2MwKW5LJAcAKW5L+isyhiSp0N/ip6d9srs6SJs4cSJr167lo48+oqioCE3TWLJkSbvLW+fMmYPL5SIWixHrZOl655mRo/np1bP5wUVn4zD8xCJhrFgYog0o0UDCf1ZREHY3SrAKbe8G1NIPUEPVSX0v4bjgs71xNlYZbK0xCcRFwl82JvBHBcF4InYipsof//IIJ04+l5ChQjc8YnsrC1T61Xad3vzOevr+k8rk1o033sjNN99MYWFht4+fssd+EqS6MmXGjBmMHDkSy2pbtGlOKudjt9ubhG6bzUZ9fT21tbXJxY0QCRE7UpcQtePhxO/ioUSRyMbsbAWcvnQIVBPb/Sla+eeo/tKk2ve1oH38PkE7bZ8/dxAllsgAt6kKMUthzvVzqYtYRM2ElUFV0GJvyKIu0nm89kRMHNBM2H6GFLf7hgNZ16Lxepk4diDZ9gi5bpVCn0p12GJPg8V1x7m5YKyz1XaLPo7x/dvm8+p/nmDpijWUBswOBe7G60tmbku6S38Yg0lxWyI5AEhxW9JfkTEkSYX+Fj9Op5OKigqGDx/e7X2UlJSQl5fX5CWb7CAtJyeHDRs2sHnzZo466qiki7L9+9//Ztq0aYRCoU6z+5K20YhGEOF6lHANSrg2keloxBKF1aINKPF9QrfNBZE6tL0b0Mo+QvWXJ/09bakx+LwizpYak4qghWlBIJbIbIyrOsueegZNd6F6solqHhb9YxkLH3kkaY/YnrYMkX61Xae3v7Oevv+kMrl12223cfnllzNmzJhuH3//e0dP01MrU8466yxefvnlpD7bnazjbsVNJIAS9aNE6hMTcpYJVnyf1UgwUQzSskDVEKodpWE3WtUWbOWfQLguqXYJRcXKHYc5eF+Gtp4GZmzfMfxNIrqwORG6F4c3i5pAmJmzLk1YjoQsasMiiVzwr2keE91d+dDXHsb9GSlu9x0Hqq5F8+tloE9lZJZGplNlcJqKPybYUW9yxZEuvne4q9W2nzuOZMBJF3PPr25kb8DsVOCeN28e1113HQ6Ho1/0oSV9S38Yg0lxWyI5AEhxW9JfkTEkSYX+Fj89nbndSDKDtEcffZRvf/vbRCIR1q1bx4wZM7q0HHfy5MkEg8Gk/wZJCyVCQKQeJVKLEq5DMeNgxhO+tVE/xEOoioLd6cEI1fPV/57HU7OBIb7kY6EqZPFJeZwN1Qa76kziFnzvh3M45qTT+eDzzdz1uz/gD4apj1jURgQ1YYtIs6Z25hGbqh3GN8mvtqesQ/riO+vp+08qk1uHQuZ2T9zfysrKuPfee3nwwQc7/Fx3RdFk40bXYGC2j7/Pn8eJxxxONNiAZZpghL/Ono4nJgmEzYkSCybsRio3oFZtThSOTAKh6VgFh2MWHoU54EjQfSCshIAeqUeJhRCKAnY3QveBwwuaHaGo2NPzCCtucocUdUnQbk5VVRU+nw8hRLdWPvS01dY3HSlu9y19Xdeiresl160wJsdGuq4wNF0jYgq215pc8i0ns7/tbt3mo2Zxz9Prqdz6GZVB0aHA3Xh9Qf/oQ0v6lv4wBpPitkRyAJDitqS/ImNIkgr9LX56UwjobJAWi8V45513+Na3vsWQIUMOzuXjjcXYQvsyus0YqgI6cT7/4H88vvhhzHiUiCGwqwrfyrMxYZCd8bk2VEVJ6hARQ7ClFsacdDa7/QoLHl9GKGbSsL99iQF1YYuaSGJ5v1B6xyP2QPt/9gU9bR3S/Du74IILmDRpEmPHjsXr9RIIBNi4cSOrV69uYW3Rne/sYMrc7kvP7e5OQPTEypTNmzfz+OOP87vf/a7dz3T3ftTRtea07St6qyukOVWctsTvPQ6N395+C4cXjSAWrIOm7GwbSsMetKotqBVfoIY6LoLZHKGnYxZ+G3Pg0Vh540FzJO59RjgxwRf1g7AQDg/CmZ4QtFUNYdMRzgyEKwN0Hza7o0eeJ6FQiIULF3Zr5UNvTdh+U5Hi9oGjp2s2tEV710u6nujPeB0KIzI1DEuwrdZkxlgnVx/TWuD+ID6U+/7zMYPStCaBe1e9xfa61v2HqqoqsrOz+0UfWtK39IcxWE+L27Ye3ZtEIpFIJBLJIYphGESjUYqLi7u1hLu4uJhoNNrmgKtRHASIx+O4XC7cbjdCCEKhEG63m+HDh7NkyZIuCdsAgUCAxYsXc+2113a5zV1CUUD3IXQfInMoihHGKSKsf30Vd/zmASzLJM2hkOlSsTtgQ5XBe6VxTEswJsfG8YV2jh3owGNvX+h22hQOzwU2v8QI4NaT3GyojLO11mRrrZkQuGMJr+50HQpMFYBgTHDLVbN4+4PPcHgyicZ7JmNa13Wi0SizZs1KOqPYNE1mzpxJaWkpDofjoBaFumIB4Xa7k1r6res6sViMd999ly1btjB06NBWBVFLSkp45JFHWLx4MVVVVe1+Z30haDRimiY5OTmMHj26y2Lk6tWr2b17d6/cO6DtCQjTNPF4PPh8PuLxOJZlEQ6H2x3gCiHwer1dbltzfD4ffr+/3fc1TWPZsmVNIlFXaH6t2TDJ9SbE7HSnir5vxOqyKXgdCh574l9NhX/97UF+d8//oWEhqrYksrMrN6GI5O8BVlphIju78GhE1ghQ1CafbiVUk/DpNuMIzY7lzkoUjdQcCQsSTzbClQX2ljYFPfE88fv9DBo0iIaGhlbvb9myhblz53LnnXe2u/JBUZQuP0/2JxAI4Ha3FvAkkr7EMIxeXz3Q3vVSHxV8XG5weL6NLTUGIzI0RmXZWLE5QtwSXHecp8Xnj7Hv4PwxTv6zKcKgNA3Qmt7bX+AOBoNkZ2f3yvlIJN80ZOZ2P6Kuro4PP/yQ8vJyAoEAeXl5DBo0iKOPPhpVVfu8PcFgkPfff5+Kigrq6urIyspi4MCBHHPMMU2VgVOloqKCTz/9lIqKCsLhMPn5+QwfPpzDDz+8R/bfiMzclvRXZAxJUqE/xs+BKL6l6zrxeJz09PRDavl48+8qFg6Q41bJ86ik6QoqkO5UyXQmRChFgVA8IUyPzHXx69nnEdr8X9KUcNLHs0RiOfDGaoNtNSY7G0wiRkLYDsQF/qjF1cXXcf4FFxCxNITDm7AK0H2g2bt1jv3Zr7a3rEM8Hg+xWIx4PN5hQdTZs2djmibnnXce69evB77+zizL6jSTPBaLkZ6eDnTv/tOWcO5wOLr99/7vf//LEUccwcCBA3v03tF8AuKf//wnoVCI7373u02TBoFAgPT0dPLy8ojFYliW1fQd7X++vem5nUxht3YnK4wobtXgX39/mEce/FNTZrbLpuDbJ2Z79onZloBgXODSYGSWjW/l2ThxRDpOkbxXuVA0rJzR2IYdjzLkOIJaGggSRSHjwUQR3VgALBOh2hG6N1E00u5GqBrClYXw5ILe8WRBKs+TPXv2cO+993LPPfd0+vn2Vj7IzO2eRWZu9286u150DY7It+Hbl8Ht0BS215mcPszBjRM8rT7/+Cfh/8/enYdHVZ6NH/+eZdbMZE8IYRcJm3VfcFeWgLbS8msLdamtAjZgW8uL1b7dtJvVWrG2LmlFbfvWBWoVoSoirlWhrtWqQBAJWxaykGQmM3NmzvL7Y8jAQIBsQBLvz3XlSs7Mc855zuSZ7T73uR+e3hhLy+CubLLY2rznqiXJ3BZd1R++g0lZErGfyspK7rjjDl566SUSicR+9xcWFjJr1iyuueaaHgsqH0xdXR2LFi1i5cqV7X6hy87OZvr06Vx33XVdziD54IMPuOuuu3jjjTfanbF92LBhfP3rX+eKK65A6eCl0AcjwW3RX8kYEt3RH8fP0ShD4fV6iUajGIbRq2v27utAgV+vDoUZyUC336WgKZDpSQa9g7sDVNO/9GU+d8oEfv6jGxhfqHH6IBfHFehoasffsyMJhw31Jpt2mWxrttgRssnKK+SmX/2GmKViaZ5kSQGSdXcdbxBcGTjuDHD5k5noB9Gf69UernHudrvxer0888wzHZoQ9ZFHHmHy5MlMnDiRtWvXdroUQ9vn2o6+/hyqBEvbc2fMmDFUVlYecnt7H8v27dtRVZWXX3650zXzD/SY7n0CYtGiRTz22GNomnbQkwYHK1PR3ZM13/zmNznzzDNTdWLh0BO77feY19XRumsnAZdDboYLo6UexUrgcruY840raK6rJuDek5ltOckTWCowMldjXIHOSUUuBmVq7fTywGxfbrJ+9sDjsQvHg9tHRkYGJKJEdtWCEUEx0yeFxB0Aly9ZV9uThePPxfHlgNqxfXfneXbqqacybtw46us7VlKlvZMk/fk17GiQ4Hb/1pHni67C5wqTNbhH5Gj4XAqbd1mcO9TF/5wZYN+PMA/9J8LKTwwGZ2rUttrUhG02NSY/r0jNbdEd/eE7mAS3RZrly5dz0003dSgraPz48fzhD39g0KBBh60/b7zxBgsXLqSxsfGQbYcOHcof/vAHxowZ06l9PPDAAyxatKhDH7LOPvts7rzzzlRmT1dJcFv0VzKGRHf01/HT2YzWQ2UrHorH48FxHHbs2MHo0aO73O/KykoKCwuJxTqewdhVHQ2aBNwK+X6FXJ9KwJ381pfhUhg9fCC//dXN/PGe37Nu3XoiCQfLga+VTuDcUXk0rXuFwozOBa9a4zYbGiyOO/fzaLlDMb15OJoLx+1PBrNdPtA8oCjJYJU7A8eVkfztDoDLm7a9/pz1eDiuUFAUhYyMDJ5//vlOBfKWLVvGhAkTGDt2LPX19dTV1XH77bfzm9/85qD9WLJkCVOnTkXTtA69/nSmBIuu60yZMoXXX3+9w8dwxhlncOWVV/LEE0+wevXqDgX3D/basXdg9Ne//jWrVq3q8HbbHpvW1tb02tXd/L97vV5cLleHJ3bTNA2vDkZLI0v+7wGW//0RdtVuQ1VAAY4dNojpF01m0rln4XLi/OH3v2Nz5RYiCQfTdhiWpTF2dzD72NzOVdNMZmeXYA88HqvoeJzMQckTWlYc4hGURCt+3QHbJBqL47j8yRNf7oxkyRFV211DOydZhqSDAe19deX9ZNKkSZx//vmpKxo6qr2rRfrz1SdHmgS3+7+OPF9UBY4r0Mn17Qlwf7rL5OZvTuPk2Jv7tX/gvQirP41THFSpDtnsjNhUNFjc8PPfcu211+J2u/vVZ2hxZPSH72AS3BYpr776KmVlZWkfWocPH84ZZ5xBdnY2W7du5aWXXkr7kltSUsKjjz7a7Zp77Vm3bh2XXXZZ2gegwsJCzjvvPPLz86muruall15KqxtXWFjI448/zoABAzq0j6VLl/KTn/wk7baxY8dyyimn4PP52LRpE6+++mpa4PvMM89k8eLF6HrXS8xLcFv0VzKGRHf05/GzdyBs8eLF3HfffWmBsENlK3ZGW6C4urq6z2RudyXw69Ygz6eS51PJ9ik8+cQ/WPLI33jhmacI7s7UnDatlFNPm8DCH91MwK0wtkDntIEuji9y4dM7dyWW4/Jj54zAzh6Ck1mM4y/AUTXQPTi6Nxns1n2g787u1lzJQLcniOMO4A3mUltX360J+Dp7wuFI1Zg+HAGv7gROt23bxq233sptt93WoUkLYU+G6+TJk4lEImlX8u37ODqOg8fj6VQJlilTpjBt2jRefPHFg7Z99NFHmTRpUir7fMKECaxYsQJN0/jzn//c5deOtsfz+OOP56233mLNmjXdzgjviYx9TdMOPEbNeLKsR7wVzYziVS3e/vcafvbzn2EaUTJcCn6Xit8FPpeCqiQzsy3Vzby5cxld5Oe15X9lkB7imBytwxPRtnH8+VgDxu/Jznb5wLGTwex4ONk3M44DKC4fvpxC8ARoNZJjJ3mFR1ZyokhvZrL2dg/ozPuJ1+vl8ssv5+9//3un99NepvXRKLXVX0lwu//r6PNFIZnB3Rbgzs7wcvPvH+Kdx3/POdrH+7X/0zsRXtkSpyigsqPFphUPf3/pPwSLkp8v+ttnaHH49YfvYBLcFkCy9MdFF12UmtRFURRuvPFGvvGNb6TV125sbOS6667jzTf3nEX8whe+wB133NGj/TEMg4suuogdO3akbrv66qtZsGBBWimUcDjMT37yE5555pnUbSeffDKPPvroIfexfv16vvKVr6RKr7jdbm655RYuueSStHbbtm1j/vz5VFRUpG4rKytjwYIFXT4+CW6L/krGkOiO/j5+FEXB7Xajqiper7fD2YpdEQgEcLlcfebyca/XS21tbZcDv6oCFR+8zVNL/sKjD96Hf/ckk5d95Ut85ZJSfrTwu7g1sGxoMWzCCYfhWRonD3RxanHnszhhd7A7exh21mCc4ECcjPxUhia6D8flTWZ4615QNVxuNzETzrxgCuHdk1iG4w52J/7VHTnhcKhSGW31kw3D6JHn2OEqVdDdgPmMGTMYOXJkqtbwXXfddcj1AoEA1dXVqQBce49jMBgkMzOz0xnlbYHztisG2wtGXnXVVSQSCaZPn56WZZufn8/s2bMpKytj+PDh1NTUEAqFyMzMZMCAAR167Wh7POvq6rjhhhsYOnRojwQn984kvvTSSznrrLMYM2YMgUCAcDjM+vXrWbVqFbZtHzy73LYgnqxNrRitycCxtbs8om3i1Rz++95b3PO73+LRHFy7v57ELYfWhEPAlaxbOybfxXGF+u6J1zqnOWbzn5oE79aYfOumP+DOHUJidw1v4q3JviUiyVIjmmt3SaK27GyNQGY2ijeLloSK7ckE3dPpPnRUR95PFEUhFAqRn5/f5f3s+5pzNEpt9VcS3O7/OvN8aQtw5wd0Fv34uwwfPJBrfvArTs+L8d0z9q/Bfe9brazZnmBAQOfr197I8RPOx1U8HiVDam6LzusP38F6Orjd9VRWcVSVl5enzVb+ne98h6uuumq/drm5uSxevJgZM2awadMmAJ5++mnmzp3b6XIgB/Pwww+nBba//OUvc+ONN+7XLhAIcMcdd7Br1y7WrFkDwLvvvssLL7zApEmTDrqP3/3ud2k1xX/xi1/sF9gGGDJkCH/5y1/4whe+QENDAwB/+ctfuOKKK7p1abEQQojPlraAIkAikcDn8+H3+3Ecp8eDyKZpYts2ZWVlXQoOlpWVYRjGEauL6jhOt64Csx3IyB/E1pDK21UmHg1yfSrvV9Yzd9h4Qp4i6mt2kO1TyHQr5PhUTBte3hLnnxsNVGB0vs7xA3ROHOBiSNahA2NKIoJWtw6tbl3yGBQVJ3Mwds5Q7GAxTmBAMnMbQPdie/xkBnM4a9wQPt26AwdwnGSt75Dh0BJP/m5NtP+FoqSkhLy8vLTPa/vqTKkMv9/frSsE9t5nfX19lwLbABUVFTQ0NODz+VLjTdd1PB4P5eXlXdpmeXk5CxYs4Oqrr6aoqCitpvPBhMNh7r//fq699lr8fn+7j+MPfvADbrjhBmbNmtXhx86yLGbOnElVVVUqSL1vMLKyspJbb72VBx54YL+6yPX19dx2223cfvvtlJaWMnr0aILBIKFQiJ///Ofoun7QEx5tj+ef/vQnnnvuOR566KFOBbbbHpvFixczf/78/Y4tGo1SWlrKzp078Xg8VFdXEwqFCAaDDBw4kO3bt1NZWcmJJ56I2+0m0hrGiu0OFMeTEy6SiKDA7kkYo2BGUcwYJGK4NAXTsvjbn36Pbdu0JByKAirDszXG5OscV+gi39/5rOio6fBBbYL3qk3eq0nw6S4LBxg+ZDCBvAHEmqtRoi0oVjxZesjlx84oTNbO1t3J57YngOPJAl82SuGgZAZ6U1PyyX0YdeT9xOv1HvT1oiPC4TB+vz9tv7FYjNLSUpYvX97pUlt9MWAiRFd15vniAJVRL3ff81vGnTCGze+8xCCfyfOfGqgqfPu09AD3/NMysJQ4F37tWo4bUUC8pQ7dVQGqnAwRoidI5nYf1NDQwAUXXEA8HgeStaufeeYZXC7XAddZs2YN3/zmN1PLU6dO5fe//32P9CeRSHDeeeel6mwHg0FeeOGFg9a53rJlC9OmTUtdQjp+/HieeOKJA7Zft24dX/rSl1LLp512Gn/7298O2q/HH3+cH/3oR6nlq6++ut2Ae0dI5rbor2QMie6Q8dNzFEUhEAgQiUQYNGhQr798vKeyfy+66CJWrlwJ7CnxMGXSRB685w7+cNvPyPWpaGqypEnArabKl+hqMkDemnAIGw4uzWF0notLJ57AcG8rSqimS8dl+3Kwc0bgZA7CDhTiyizktTfWsuypp4iZDtEEtJoOkbhDzEqOd8tOTnjXEndoMWxaDIe4deh6tZ2txbtkyRJKS0u7XNu9TXez7mH/cis9UZ+8urqa9evXM3z4cEaOHNnuhOHtmTVrFg8//DDPPffcfo+jqqp8+umn/OMf/+hWCZZ4PI6mabhcLkKhEJdffnkqu7mzOlKqpu3x/PrXv86zzz7bo1n2hzqhMrbkWL4995tc+bX/h0exMFqbsGKtpAqEmAYkIpCIoSQiKFby+wiqliz3o3lwOwbvvryC7e+/yth8nWNyNFxa5yd4j1vJSWPfqzF5tybB+noT0wZNgYzdrwUBl8KlX5nB2WefTdwCx5OxeyJIf7JPmhvHl50sNeIJgprM7eqN71+Hs87/kSy11V9J5vZnR6eeLy4ds+pD9ESYxM5PWPuvV3hk5euckNHAvFP9adt1UOCc75AIFuNEm/EVj0bxZdPiG5y8skSIDuqN72GdJWVJxH51p6+//nrmzp17yPWmTZvG5s2bgeQXm7Vr1+Lz+brdn9dff52rr746tXzppZdy8803H3K92bNn89prr6WWV69ezZAhQ9pte+edd6ZlA915551cfPHFB92+YRicc845qRrfgwYNOmjdxIOR4Lbor2QMie6Q8dOzdF3H6/WyatUqvvjFL/b6y8d7qgzFsccem1bi4fHHH+drX/saQ4cOpTUcJsenkOtN1uluK1/i1RSCHoWgO3mbpoLu8vDL2xaheIMkYq1ojZtQ69aj7lyH2lrXtYNUNOzMYl7972Y2N8apCVk0RB0ckkHtmOkQSUBrwiaScEjsjnVqbh/Ln3sJ1RvEsNXkZJW6N1XD90iXCti7BrWmabS0tPRoAK0nAuYVFRUMHjyYn/3sZ9x2220dWic/P59169bx5ptvtvs4Tps2rUeCw/F4PLXt1tbWwz7JaNvjedddd3HDDTf0WC3+1AmV557jsku/hhEN49aSQeJMd/I55dv9HAv4fdz0wxs56XNjiUdasONRMOMojp2clFXzgMuHY1uo4RrUpq2ojZtQGzcn61t3QWvcYVNI54TSWfzxyVd48l//JWGDriYnog24FTJce/oYt8BU3Nx132JUb5CEze7s7OCegLbL3+6+euP71+EqGdTmSJba6o8kuP3Z0qnni2WiNWzEZYZRmrbhUmxCei5sWEXGhmVp23UUjfhZ38EJFODXbMgdTqupYRWMPuDrlRD76o3vYZ0lZUnEfgHaadOmdWi9adOmcd999wEQi8V4/fXXmTx5co/3Z+rUqR3uz97B7RdeeCEtu/xA+3C5XIcsYQLJ7IcLLriA5cuXA7Bjxw7WrVvHWPnAIYQQohcyTZN4PM60adP6xOXjtm0zd+5cbrrppk5nms+ZMwfDMNixYwdFRUVpJR40TeOb3/wmS5YsYfr06TRGLRqjFuxKZnBne1VyvArZXhXP7k+yQY/Gz390HbqmEm+uQrVtnIwCzOxhOONngBlH27UFtWEjasMnKE1bkkG6Q3Es1OZtXDBU54KhyZ3FLYfKJovNTRbbWyxqwhZNMQXbSQbbDEvh2/+zAHdrDbHmGjQ1WTKlrdwJLi/ujGyMmJvZV8zCsTtfKsPtdh8yS/9AtbxzcnLIz89n1KhRXQ6g7VtupbtlaiD5JceyLB544IEOrzNnzhw0TTtgyZExY8ZQXV3drRIsNTU1rFu3jlNPPRWv19vjj1172h7PQCDQ5TIVqpIMCEd2VuLP9KO1NuN1qfz7mTX85n9v5IRcG0he9akAPj15oihj9wkjt5bg4btvwT/3GkrGfQ5DcydLkIQbUEPVqM3bUHZtQY02dql/ALuiNv/dafLfnQn+u9Pk010WtgP/uOpc3PlbKMz4iIBbwbt7MlnDdGiNQ13EJhy3sdD49S034SoYTtRxY7sDadnZfY1lWRiGcdjKUx3JUltC9HWder6oGlbeKJz6DSj+IqzQDjzxGpQTpmProH60LNVUcSzca+4hft7/QFYBNG4BTwFq3QbswnGHtfa/EP1Z33zn/4x7++23U3/n5+cfMNt5XyeddFLa8ltvvdUjwe29+6NpGscff3yX+vP222+3G9xuaWlJmxxy3LhxeDwde9E/8cQTU8FtSB6zBLeFEEL0VvF4HNu2mTJlClVVVR26fLy7ZSq6yjAM/H5/Kgjd0ezjxx57DMdxuP/++6mtrWXDhg37TWDncrmYOnXqfkH+uAU7W212tgJY+HQYlBfkgTsW8bmTxmNEwtjeAjCjkIiixFtRwjtRHAfHn4OZeR6UTMVBRQ1XozZ+ilr/CWrDxmQ94Q5wawoleToleXs+Rhumw7YWi5oIHHvCWRRlxYjv+ABV8yYnrNTcyS+smgc0N2qimWdWPENJpkFJpouYCdGEk/wxnWQJFNMhZpI2geWB6ii39zgfqPSEqqps2bKlRwNolmV1O+ibn5/PggUL9qtffSCqqlJWVnbQetTdCQ63CYVCvPjii0yfPp0lS5YwefLkw14bv+3x9Pl8BIPBg7Z1a+B3JQPSbQFqn0vB23bix6iFRhW3ZZCIx/jT7TcxKKCgqxqamizx4dEVVCU51qJmsrxOlkdhcCZ8+NxfGBU9CU9TZbLWdhc5DtTG3by3LcRHdQn+W2uyI5Q8wdRWZmRgQCXgVnBq1zM4AAG3QmscasMWrbuvjHAcCMcdTM3Honsf4JRplxCNxbH7eAmNtues4zjMnj27yycNO/peYJqmBLOF6KAOPV9UDTt/NGr9BizAbt6KUrcJ+9ipuIxW9E+eTzVV7ATu1+7CmfZTFN2N2rQNO3sYat167MKxyc8MQohOkeB2H7Nz5860D+mdCdSOGzcubbltgsnusG2bysrK1PKwYcPIyOhYvaiRI0fi9XpTNQcP1J99b+/MMY8fP/6g2xJCCCF6G9M0aW1txe12M3/+fBYsWHDAy2GP5oRfXZ2obNKkSVxxxRX8/e9/T93XXsAeYPLkyR0O8kejUayMEIrRghILQTyUzDR1bJxENDkBXiIG0V2otgWKhlU4DmvQKTi6ByXajNq8FdeuzcR2fIgnVo+qdKxOsEdXODZX59hcoOFNaHgTN+B4s7GDRTiBAdj+fPDnoPjz0RM+1r3yJKNyNWJmsryJYTrErWS97r1zyuPWnvtjJvzjz/fyvW99k7hjYqLBPn08VC1v27a55557uOGGG3osgGaaZrczTmtrazs1H0xpaSnDhg076CSW4XD4kMHhQ2mbCDIcDjN9+nQ++uijDl2xoKoqpaWljBkzhkAgQCKR4Fvf+laHgo9tj+eY0SUU5Wdzyrhj2b7lUzx6siSPR1eSf+8OSkMy+9qtgUdLZjp7dYVhgwYQjO7AiEZRNY01r7+OTzEwXWDakLAd/B6FwgyFARkagzM1hmVpDM3W8Ol7javaDzv9uNmeTNQBo4llDKbVX4w+YDSDigah1dSwc8Uy9NUrGayEyHDtn5ntzh/BhbNOJZQxlGVPPcXWT7fRHHNoitkUDTuWud+bt+d53w9qQ+/9nL322mt56623eOSRR5gxY0aHTxouXbo07bVTCHEU7BXghqHQvBW1ZTuJ8TMgEUXfsueqdcWM4Tx/C0y7CUdVUZq2Qs4w1LoK7MIxffYKFCGOFnnG9DGffvpp2nJnavDl5+fjcrlIJBLtbqsrduzYkTYhTmf6oyhK6lJkgG3btmGaJrqePiy7c8wDBw486LaEEEKI3mjvy2Hj8XivvXy8LcDe0SC01+vFtm2WLl1KQ0MDra2tZGRkHDBgH4lEcLvdzJs3r2NBfncGjjsDJzgwmeKZiKAYyYA3Rhjs5OPmWHFIRMHcPSmeEUJxHLTcYZj5o/jO3c8RiUYpztQYmaMzOk9jbIGbgYHOTYqnxJrQYk1Qtz51m6NqmP58JheF2BnwUBe1aYzaNERs4rvjWAkb4qaDYZEKeCd/OySat9BcsRaPx4OdSCRLnejeZIDe5cUbyOTFZ1Yxc+bXiMbbD4wtXryYhQsX9mgArbtlav7zn/90aoLGjpQcWb9+PQMHDuxWRnlRUREbNmwAkuN92rRpVFRUHPCKhfz8fObMmUNZWRnDhg2jurqaUChETk4Ofr8fwzCSWfWxKE7CACuenJRx90/y7wS26jB1TDa176zk+1d+nnvvuxddSV454NJ2/1YVPBp49ORy23kOy4aY5XDW+ZMwPbk4Hg1Ns3lzzeuMK9AZnq0zPEtjaJZGhrvzEz3uy0KDvGOw80ZC/iicvJH888U1LP/zCqqqnsOnJ2tljxhcxJQLzuFrE09l5oUncc8fH+DDDZ+yszVZZiRhw+DBQ8gcMpaE7mf63Bv56vW/pXFXU687uddTFEVJzbXQNp4uueQSXnzxRZ588kkuu+yyXl2eSgixj3YD3DtInHApihlD27HnqneMMM7zv8Y16cfY0Was5m2gqKj1G7ELRqfm6RBCHJoEt/uY2tratOUBAwZ0eF1FURgwYADbt29vd1tHuj9t7duC24lEgoaGhv220Z19FBQUoGla6otHTxyzEEIIcST19svH24JMHQlCt7a24jgO8Xgcv99PXl4ekMywbTv5vrdu1YhVlL2C3UXJ20wjOdldvDX1G8dJZnebMRTF5uXnVuBX42QFNRwHPq4zeac6QSQRRQGGZumcf/wwSnJUCvUwAaKderwU20IJ13LGoP0vO65rtakKWVSHbXa2WtRHbZpjDq3x5CSWyccEEtUf483OQ7GV5OXLmgtFc+P2ZZBo2c6iG2dzSpEKqFh2MjCesCFhOSQsiJuNXP2Vi1jy+BOs+PvDfPPqOTS2hDEPEFvuSACtq2Vqli5ditfr5aSTTiIQCHQ4MN6RkiOrVq3qdgmWyspKVq1albqtsrKSf/zjH3z1q1/d74qFM888k+XLnkTD5JG//plH/voQ1dsqce8ORh8zfChf/fIMvviFi/HrWqoMEZC8ysBOgGWCncC0TTy6il1fxcWnj+LNf2aQiO+ps245yf9n3IJmwyFu2bg1hXy/ysCgyohcDxNz61Be/g2uUA2OafD9EwE6doXlgYTjNp80WnzSaLGx0eSTRottLRYnnjSE39z6Td59cw13/fBbKJaBX1c4rkBHUZIB9/qdtSx+5HH+tGQF3/v+D1nwy7v53oIFfPyfj2gxkpnZM747n3DmMXg8HmKRCInWSK89udcTPB4PhmGk1Y1fu3YtEydOZMWKFWzdupU///nPvbY8lRCiHe0FuENVxE+9Cq8dR6n+YE/bSCPKy7fjvuhmzKZqiNQQVxSUxs04eSOP2iEI0ddIcLuPaW1tTVvuaAmQ9tq3TVzldne9plNP9qe97bV3W2cmLFJVFZ/Pl/rS0dVL9ZQOXpZ8pO3dr97aR9G7yRgS3SHjR+wtHo8Dyc8Xfr8fv98PJAPXewejFEXBsixs28bn8wHJAPmhxpBlWfsFbzo97lzJCR3JyE8Gix0HJ9GKYrSiWxFcms3D/3yV7XUmLrWtlrGKX4dCv4qmQtyyWfHWp0QSDpGEg6ZAcabGycPzufzis7HqN6M070Cx9w/WH0pBhkpBhsoJ+9wet5zdtcaTQW9/w8dg5KO6fODOAHX3xIAhF2tef4Oh/jimVyNhJctPmHYyuG3t/m3aDi2V7/M/V17CLbfcwsZXHmflypUse+opNm/dTsJyMG0oHjKMr866lK/OuhS310+0biu2o6BoevKSaVUDRUtllxmG0W6t9Pa0BcxLS0uJRqO43e5OBcYjkQg5OTkHbWPbNuXl5R0qwaIqydrPqgKaClnBAFdd+mXu+t0i8rwOmqqi7b7v/t/8hFmTT2PKicOo/s+LLHvicT768AN++qMf8u7z/8cvfvkLotEoOnBMjopbU9AUUFp28NRf7mb10sV899vzOW7cGOLRSPJKgrQJThVQdUyXh4KiYixHZdbs7/Lr39xOhm6T61MpylApDmoMylQZFNQYnKkScO+T5bftzUM+jgdTH7HZ1GjyyS6Li6+4lhff38x9S/6Rur+t3nfJwCxu/s6VrHvlSR554AHyXDYxRSGagPqoTSRuE9v9LzVtCBsRvv7dn3Dvg3/jl395jrHjj6N+Vz2BQIBvXj2b3/72t1x//fWpwG+3n/ft6C3vX6qqcv/99+83NteuXcvYsWOZPXs2ZWVlLFiwgJqaGkKhEMFgkKKiInbt2oXP50udNJT34cOrI4+voijyfxBJmo5TMAalbgOOAmrzdryxBhJnzCO0/Cfk2Xvml1BD1Wy8fx4bBl5C6YTP4dUbSOguzFAVTuago3gQorfqLe9hvYkEt/uYaDQ9O6ijEyseqH1bTc/e0p/2gs/77qOz/fV4PKkPjO0FzzsiOzu7S+sdSVlZWUe7C6KPkzEkukPGj+iOozt+9gRI6+vrefzfm8n0KGR6VIJuhYDbQdsdM/Ro4HepZOyewC/Hq6IoyYDdKxvq+NK3pxE4rRBHc6OE63B2bYHGSpzG5G8ijV3qoVtTGJyZrIkMLtjwNABaWwNvFgQKwZ+D/ck7TBjsotlwaIk5hOI2sYSC2s7VzVZdBb+87htMOOscJk6azJdLbyPcGiMWT+D1+Qlk5WDZDlqsFuI6Ge1tpI2iJn92aUwZm0/1O8+x7KmnWPr3x6ncshXLTmafDx02nFlfu5SvzpqFx+NFbdlOhqKCqVA64XM89/e/UDZvHuHW1mRSPaQyxR1AVRSCGRl8/YuTyXcZXHDiSLZuqURTVc4952xGHnMM/gw/0dZWNm/+lNeffBDnyi+wYvFt/M+CBTiOnQpka6qSCljvTVU1fvnLm3CqP+SdZx9mbEHyK5NKMvitNm+hufIDggE/Ptti5pQzUaacwQdrnudPd97BIK+NK0PHpe5XEn33yQaDe/5wF9/+zvcYf/wJqG4vqDoODkSbIdoErXXQWAehOrTwTk4K17Pky1ko9HzZida4TWWTxZZmi8qm5M/mJotdsT37+sKPTqNpTQWFfhW/O1lmRN/9uJ1/wdkoLh+33fsXGkMJoqaz+/8GrQmHkOHQYiQnqozulXT91a/PZtu2bcyenQxoP/rooyQSCe69916ys7O59tprj8hn8KP9/nWguvH19fXcdttt3H777ZSWljJ69OhUDfgNGzZQWVnJunXrjnr/PzMyMzvQJBP6wPdGceQ4WadDzUeYXh8fv/Y0Dz54A1saotw+Jcjw7D3huGOzbOoq/s7VSx7jx9++itGnnovP8qG4ilAy8o7iEYjeTt4DkiS43cfsXd8aOh/o3bd926W+vaU/+26vp/fR3eMVQgghRP/V2tpK3IL6iEN9ZE+2qE+HoEcl060Q9DgE3Mn6xgpt2d3JYF8iVAdqDAVAc6PkDIWCUSi6B3QPjhlHaanGatjKxndeoXHzBwzJ1BgYVDs8eWW7Ys3JH+DCQcAgf9rdpu1QH7Gpj9g0RG0aIw7Nhk0o7tAaj/LOq8/x2ouruOU3vyXg9RBQTbCbYVfzngA64OzOKEZVQWnL3Fb2BLaVZDRXVVR8isrMKWdy6efPJxwKEzPieLw+glmZWKaFFq2FmJqcPFNRgWTG43nHDeHDV5bz0ccf8fzzz7Py2ZXYu7OahwwewvTp0/n8Fz6PW9NI1GxgwZVfoq6uls9ffDEFBQXsamwkGk2WssjJzqZuZy1rn13CxIkTue/XP+R3d95J3Iglg9QqqCho6u6gNeD1efnW3DmMHZbN7351PcWuVoYU6KhKeqDarK2AeDaQPMlgGAn++qffoys2ccshnNgzQaiCQ6ZHJcerkudTyPVr5PtUal74I2NbT0z+76K7knXhD6K7uVlREyqbTLY07QliVzab1EfSA+ZtGdkDA2pyYsriAeQkdmLXf0phhko04dAQtWmNO0RNhf+95EqeffVVKna2EjYcQvHkTzjuYB8kFh8Oh3nooYeYN28e55xzDpMmTWLixInU19dTXl7OggULunnEvV99ff0h68Hbts3KlStZuXLlfvc1NDSkyjsJIXofRdNJ5I3i368/xC9+fQ8jshUKM1R+/GKYRVODFGbseZc9c7Cb5pjBL+76Ez/5nsLo0yeiKRtB96J4uldSSoj+ToLbfcy+mc7t1ac8mLZLhtt0J2v7cPSnvczvntxHZzPL2zQ1NXVpvcNNUZTUmbrm5maZREZ0mowh0R0yfkR39Lbx4/F4DlheLWpC1LTZufsCMAUIuJXdGd4KQY+KVwd94HgSLpV4pAUlEUUxwmA1Jmsp7+ZoLly5xzB86mh+8a15NIXDWDYMykxO8DckU2Xo7sn+BgU1fK7uX26qqwpFAY2igHbQds7qn2N5gjjeTBx3EMcbBHcgWbdc313SRfPiaO5ksF73gO5OBqd31y5Xdv8GGxwHVVXxqBoegGgzRuuOtIkjFRQ0XUcBdJdOtLUVwzA4NuDlhCsu5rqvlZJIJNN9/X4/ZiKBU7eBuGXh9Xq46NSRGMZg/v3Kct544w3q6utS2y7IL+Css87ivDPOwGyoZPygLO7/7c38+823ePW116jduRPbSdavLiwYwHkXXMg5556LZTvc8ts7qdj4KbbD7jbJQK2ugE9XcPkySESjmLFmXHaciv+8yYQiyPJ4U5n/mR6FLK+yf7mQvdV82PV/bDssRyHhzcVTMBzLX4AdGIATLMKVO4RnV/2Lex+9L629qkDG7pMzfnfyRI1rd3fjFsQSDqedN4W6uIenXv+Y2O7C7KYNIcPhxAnnUXTiRG7+5o2sr+p8Ley2IHZ2djYTJ05k7dq1AFRUVNDQ0JCahLOn9YbXn72vLu2qcDh82B4jkU5taeFQudstLS3YvfR7ozg6PB4PpmnxxWt+wLEBi093wbG5OkEP/OjFMItKgwQ9e94jph3roTFq87s/PsRdxxyDhkY88ib2gPHJOTaEoHe8h3VXT1+ZJcHtPqatfmWb9jKdD2bfDz6drZF9uPuz7/bau62zH972bt/e9juiL7xYOI7TJ/opei8ZQ6I7ZPyI7ugN48c0TfLz8xk1atQhMykdSGWn7ggBWIwfM4qsUafR2lCDowdw4q3JQC+7azk7JooVx0nEsM0YLrOVH3/7Ku5fvBjHsTEsh63NyUn6DNMhZiZrbWe4FQYGNAZn6lz+xckM8MPG916n0OeQ7z9I0LQLFBwwWlCMlk6t52juPZN36j5oy1TX3KC5cXb/oLtxVDeK7gbVhaK70d1ezITNW++8x9p//5uddfU4JOuD5+UVcObZ53DWOefgdnsxTBvTVgAdze3B1tx8uOFjysvLMYzY7mNI/n8UBaLVO6latoyVz63kyssvY9Qxw/nPu29z5vFjOf+UEiItLSSMCG4NfC6V1qZ6tj57Nw01O7go1+TL5wTwuZLBX5+eDPxq6u6TDS/9EthTGmY8MH6ctwf+C4cWMx1aLDdRPUhEy6Q+7uKT2jAvvbOBmrCJxxvhH4/fhYqDFQuDaeBYCS457yReXubHShioSrKsSNvhWDZEEw6NUZtI3KE14WA54PP5OO8LX+Ohvz3Gp40m4USyvEhk9/maScccT01TlPUVn3TpWCoqKti5cye///3vU4HtNm2B28P92nC0Xn8cx+nUXELtCQQCveL187OgI4+x/C/Evtrq6jc2h/mgFU4scrGp0eLYXA3bcfjJS2FumxzEo+85kX3Z53zURVp5be3bXHCuBzKKUeoqsAvHpua4EKKNvO4kSXC7j9k3ONvZCRL3rjmt63qXM5nb7Bsc705/2tse7H/Mnambbdt2WsC9q8FtIYQQQvRvpmliGAZlZWUsXLiw0+vPvmYecT1IIqhBcBAKyfIOqmXgVi121e4g2tKI3+MnqyBAIp5g9PklfCM4iNt//SswDTwaBN0K+T41VQLDdkDR3Vx8xbcY+LkTufmXt/DhuiZipoOqwPB8P7/7xQ/Rog1osV2seeFpMohRkKGS71fR1e5nfh+KYsUhGkeJ7urS+i7gLOCsE4C03Mg4xF6E1S+m2rn2Wfc44O5SL3CIwPL2f8B2OAXg36/gAL7dP5AMiPuBEhUoVtrZ05HjuPw4/nyUYAGbakM8v+Y/7Gy1qA3b1LTatBhtX2JrAXCp4NUV3BoMDKh49Dhrlv+Zc886EzWRwAFM3YPbl8E1ZfO5487fETdtLDuZtR5NpE/4GGqrj22pPPTwnzEGHM8vH/ga9bv2n+gzEAgQCoW6dbzNzc3tTojVFrjtryzL6vAJtfaUlJSQl5fX7cdfCHF4tMVb2urqx0z4oDbBiUUuNjdZHJOjEYo7/PJfYW4+P7Dn5Cnw7dP83L32ZSZPPB8zXI2laiiNm3HyRh6twxGiV5Pgdh8zYMCAtOWampoOr+s4DrW1tQfc1pHuD5DWH13X260Z15191NXVYZp7LpEsKirqVP+EEEII8dlh2zZz587lpptu6lS5gEAgwJw5c7CsZPBP0zS8Xi+GYXD/Qw9RXl6eFrwaN/pY5s/5Jlde+lU+d94XeODUc1n+j6WseGoZm3dsB5KTV44YOojPT53CheedjRWP8rvbfkm4ejPH5CTzhW0HjITBK++sZ2LpNCzNTd1mnZ/fvxgzWRWEHJ9CgV+lwK+Sn6FS6E8GvXN8Kjne5KSYWV7JBDsSoqZDY1vd86hNQ9ShIWJz6dXz8OcPJqFn4PhywOVH0zR8fh+/vOIKaqtjuDUFlwZeTSEYVHBryWC2W1NS2de2A4aZrPP9zxde58IvXoYZt7AVHUdRiasqx50znPneAn7805tpCUcwd2dsN+8z4WMgEODRRx/lwr3qYLcnHA4TDAa79bi0TZK4t89C4La7J9TKysowDCPtu44QovfQNG2/uvqRBPy31uT4ATpbmiyGZ2tsa7H43b8jLDxzT6KfpipcMzZGayiMy6Vjt1ShKiq27sXJGtTu/nRdR9M0FEXBcRwsy5LXB/GZIcHtPuaYY45JW66qqurwuvX19Wn1qkeMGNHt/gwaNAiPx5Mq/dGZ/jiOkxaoHjJkCC7X/lky3Tnm6urqtOWeOGYhhBBC9E+GYeD3+1myZAnTp09PBasPRtM0li5disfjIRKJoGkafr+fVatWMWvWrHaD5B9v+IRvf//H/OBnt7JkyRKmTp3Klxecwqz/+TU7d2yhtamBgEejIDtI1bZP+dsTf+fZZ56muTk5aWRbpq5HU/DqCq++8iKlF56DGY4y7fQxvPFMBnHDwLIhYSeDnVubLTbtsjB332bayYkm41ay9MTf/7oYNR7GCjegGC0osRYwWlCNEEo8jJKIoMRbMaMtWJHmtEuoP4scFHD7wRPEdmXw5gfraNkdIE7+3vN3MpC9p5RHGwVwaXD5sNNxdBWMKIoRgkgjquoQqomQZ9aSV7DnK5tpQ8JySFgQNsCwkiVtjN2TV7bZ2LiDFiUTT142tqPjuHxYugfb5eHU/zeBpz4/h8WLF3PfffelBV5KSkooKytj7ty5GIaRVge7PevXr2fgwIHdyj4uKipiw4YNabd/VgK3PXVCTQjR+yiK0u7zOhR3+KjO5HOFOttabIZmqbxXk+D/Pojy9eN9qXY+l4K19h6Y+AOUSDNOeCcqYGsunEBhah8ejyc5v4XHQ319PeFwmEAgQH5+PrFYDMdxMAyjX18JI4QEt/uYAQMGpGU3rFu3rsPrfvzxx2nLI0d2/5IWVVUZPnx46gPpli1biEQiHSr/sWnTprSSIQfqz763d+aYP/roo4NuSwghhBCijeM4xGIxSktLWb58+QGD020CgQBLly5lypQpqdJsXq+XVatWdSg4Hg6HmT59OitWrGDSpElc+vVvUFRUlPqst2HDBlatWoVt23i0ZEDbl6r/TOrv7aEqQt6BeDJd6DjMvOb73PqrX6ApDi41mfHr1pLr6KqCtleitqKozJ07G5fRhGHZ4MvBCRTgcvtQNB3d66Ml3ErUSODzB8nKyaGmpoanVzzFq6ufxY6FCLqTkyYG3AoBdzLo7nOpTJ10PgPysrHiUTANFNMAK45qx2lprKO1uRFd3d0nhWQNaFVBV8CldT94btkOCTtZuzxhJYP6jqIzcPBQtlXVYJg2I0eNpjkU4b/rKwjFTCIJiCScPT+mQzThYKpuvnH1txh34ikYtoat+0BRUxnWf3z862zfnXWvKaQec5eaPJZcn0phRvLYtN3HrKtQUFBIMFGPEdo9R4zqAlVHcfmIxWy2tdgkLCd1DPZex+c4yWzwaMIhau7pdzSRPO4W/xAK8wtx9vq8bTnJMoJut5t58+axYMECGhoaUsGQvLw8DMNA0zT+7//+76CBbYBVq1axZcuWbmUfV1ZWsmrVqtRtbYFbVVVTGYj9VU+cUBNC9E4Hq6vfFHNYX28ytkBHV6E4qPL0xhhFAZUpx+wpHasZzThr7sU+fT5qpAFbcyXnltDcaIG8PVeJ3X//fleJjRo1KnWy0u/3E4vF5ISY6LckuN0HnXLKKbz88stAMht727ZtDBky5JDrvfvuu2nLp512Wo/059RTT00Fty3L4v333+fMM8885Hrvvfdeh/qTlZWVlg3y8ccfYxhGh+qFd3QfQgghhBCQ/CwTiUSYPHkyVVVV7Wa3jhkzhltuuYWLLroIXdcxTTOVPWUYBrNmzerwF0jLspg5cyZVVVUMHz6c2267rd12hgWGlSwfsTcF8OoQ8hXjyQ5ixCKcNOlLLPDk8NMf/gAzHmXfstsqoGsQ9Pv43xu/z+jPHUc8GsZxEmjYuBSLRGs9a177F2veeIO6+rrUunn5BZx59rl8beo5zJx6Dr+76/dUfPIJTTEL20mWxrAcB9uBVVte5qE//xVV00iYNigKmubCleHnuiu/wfYdzQd9bFQlGShuCwarClxx+dcpnTaVyy+/AofkfiAZ6G3723aSNbTtA8RE//GPP/HPRx7hiWX/YPy4XH75y19w6lSF51et4vmn/0l19Q4UFBQFBhcP4qJLpjJl8iRcuoYRN3CsOIoRBsfBdiwSIY2vf/5cnvjHUlxaMlDfxnZIZclbNsQtMBNg2jYJGy6c8XnM7OGYcQtULbWe43Lh9lpUNlnETQfDSk4kaVgOhpn8O2G3c3B7OVDN6rYsPoBEIoHP50tN3BgKhTBNE6/XyxVXXMENN9xw0BM8tm1TXl7ODTfc0KXs46uuuopbb70V204ejKZpPProoyiKkgr89ueATHdPqPXnwL8Qfd2h6urXRRxcjcnXNpeqMCio8cB7EQr9KicU7bmiXWnahvv9h0mceDlKqAZUHVfTp3iyc3l+9eoDvm5s3LiRhQsXctNNN7FkyRJKS0uJRCL99vVUfLZJcLsPmjhxYiq4DfDss89yzTXXHHK95557LvW3x+Ph7LPP7rH+PPzww6nllStXdii4vXLlyrTlSZMmHXQfbW8IiUSCF154gYsvvvig2zcMg1deeSW1XFxczLhx4w7ZLyGEEEJ8trUFuPfNbo1EIuTm5uJyuXC73ftd/huPx3n77bfxer2dCvKFw2EWL15MWVkZt99+eyrQ1xEOEDXBnz8Yx+fDdBtENY0zvjib5dOuYPHixdxffi+Vn36SqtM8ZtRIrrjiMmZ9ZQZuFWLRMLYWRMPG7fXw9ltv87Of/4xoNJrMQlZB15JZxztaavl4y+MsefKfXFv2LW78/kIW/fa3VFZ+iqYqqLBXZniCfz+7hLPPPht1d2k8TddprY2TZ9aSW6gnA+Ikg3y2sztITfK3s99vBy3RQryphsKM5KSbKoCSDPK3xZTb5iZUlLbblNTfCmBu/y8j/FGOH6BDw0Z+c/1szpgwgfPOOosvnfsDWlpCxA0Dn99HRkYGZsLECdcQtywcRQFUUFRQVVA0HEfj3AsnsuSJp2gIxVKlYBKWg9lO7DFZLgY0t48ps2ZjubzYNqC5cTQ3aG4Uj4+czCxagyMO62SDpmm2W/qjMxnFixcvZuHChTzyyCPMmDGjw9nHjz76KIlEggceeADYU+d70u463x9++OFnIiDTkRNqbeVi5syZk8rY7q+PhxD9hWVZxOPxg17ZUhWyce8+r6mpGsUBjdvfaOVXk4IMy9pzwlOr/RCn4lnMY0tRQ1W4/QHeXPEXvnLl/xCNd+4qMTkxJvojmT2mD5o0aVJabeq///3vabW027NmzRo2b96cWj7//PM7VDqkI04//XRycnJSy08//TQtLS0HXWfLli288cYbqeXx48cfNPt82rRpacuPPPLIIfu1YsWKtH5MnTr1kOsIIYQQQsCe7NZoNEooFCIjI4OioiJs2+buu++mpKSEgoICRowYQUFBASUlJdx9990cd9xxrFu3jgkTJnRqf+Xl5QwfPpzS0tJO97UtkNkW7GoLlmmaxrx58/h4w0a21dTz/obNrNtax6v/2cgV3/khamEJkczhmIXjcQafgnvUuaxev4uLZt/IW1tCVDQk63Rv2mWzeZdFZZPNlmaLbc02n9RFWPir3/PO5gbm/eR2aswAH9eZfFhn8n6tyX9rTT7aafLXlWvRB45ByT8GO3sIZA8l4spla7NNVcimttWmIWKzK+YQMqA1DoYJCSsZBHYcUJzdpT4UhXgsitfjwXFIZUIbCYgmkhN1tcYhZCR/mmOwK7a75nXEpq41uT933mBqoxpbm20qmyw+3N7C/Y+v4pv/83Nuuusv/OPl94hnDsU39ATiWcMxskYQzzkWu2AMTv5onPxROHkjcXJG4GQPJR4owpU3nLnX38yOMFQ2JR+vT3ZZbKi3+KDW5J0qk7XbE/xrS4LXtyV4p8bmJ/c8hnvQccQDxTjBgTj+PPAEQfdgWnZqssGu6G7N6n0zig90aT0krySdNWsW06ZNO2RbSAaxly1bxqRJk5g+fTq5ubksWrSIbdu2ccYZZ6TqfLcFZJ5//nm8Xi+K0v1SNb3Vvs/ZiooK6uvrqayspL6+ng0bNjB//nw0TZPAthB9hMfjwXEcrrrqqoO+LlY22VSHbLa1WIQMh/wMld/8O4HjyUxrp29+Fa32Q3RvgET9p9z6858wLi/9aqEDabtKzDAM3G53dw9NiF5Hgtt9UH5+Pl/96ldTy1u3buVPf/rTAdsbhsEvf/nL1LKiKMybN++A7bdv387o0aNTPxMnTjxof9xuN3PmzEkth0Ihbr311gO2t22bm266KS0raf78+Qfdx7hx4zj//PNTy2+99RbLli07YPvGxkYWLVqUWvZ6vVx99dUH3YcQQgghRHscx0HXdZ5//nmKi4tZuHDhftm0bZf/Dh06lDVr1vDiiy92KsBdUVFBXV0do0eP7nT/2gtk7huc9/l8FBYW4vP5CIVCRCKRtAmmPB4PRjzBzEuvoDlq0hh1qAnbbG222bTLYl29xQc7Td6pNlmzPcGrWxK8tiXGl+b/DKX4BE666Ot8uNNkXZ1JRYPFxsZkcPeV/26hWctByTsGO3sYds4Q3ANGsaXJYnOTxZZmiy3Nyf1sbbHYHrLY1mKxtSV5X2WzxeZmi0+bLDY1Wby3ZRfBoeMxAwPZ0pxst233Otv2+ntri8XWZiu53WabLc3JwLyTNYjsEccz4qTzsDMHJQPRTRabd1lYmYMYedokvjbvBwwYewYxXxFGYBB27ojUj5V3LFb+KKzCsVgDxmMNPAFr4EnEBpzI6V/5Nj/94xNsjnipaEzuu7bVpinm0JpIZnM7JIO7K1asYMqUKanJvtrTNtngoYLF++qpyQb3zShetGgRo0aNSmtTUlLCokWLWLZsGYqiMHnyZHbs2HHQttXV1ZSWllJfX8+TTz7Jhg0bmDFjBrfeeivjxo1Lq/P9WQrIdPY5K4To3VRV5cEHH8SyLB555BE0TTtg242NFvWtNpXNFglb4dvXzEa54Prk1Tx70T9YgtLawOuvr2GgN07QrTCuoGMFGdquEjtYP4ToqxRH3h37pNraWi666CJaW1uBZMD6Bz/4AVdeeSWquuecRWNjI9dddx1vvvlm6rbPf/7zaYHffW3fvj2tRMigQYN48cUXD9qfWCzGtGnTqK6uTt129dVXs2DBgrQPouFwmJ/85Cc888wzqdtOOukkHnvssUMe87p16/jKV76S+uLmdrv59a9/zRe+8IW0dtu2bWP+/PlUVFSkbrvmmmu6NMlNm127dnV53cNJURSys7MBaGpqkg+7otNkDInukPEjuuNwjB9d19E0LTUJnWVZXc5c3buffr+f1atXd2rCt2XLljFhwgTGjh1LfX19h/ZVWVnJX//6V3760592uH+BQICqqio0TUvVUe4Kv9/PPffc06XPS4sWLWLGjBmMHDmy3ZIqlZWVFBYWEovFcLlcBAIBSkpKDlpuQyFZcztVTkRJLpeUjOatt9/mnnvLuf773z9gXe2D9XX+/Pk4joPX6213MkXLsrBtO21Cw46MJU3TUpN7daS0xKFqSXd17PX0peeKouB2u1FVtUOPmcvlSk6C6vHs13bXrl08+eSTbNq0CVVV95s49UDa/m89NYGivH+JzlLXrSPrEGU9m19/HXvs2CPUI9Gb6bpOMBhMXVn14osvsnr1ai677LIDli1TgDNHZHL7z3/IycOzcXn8GA1bcb3+h/SGLh83vW7T1FhHLOGwqclie4vNp7sO/R5RUlLChg0bUvMriL6pP7yH7V39oSdIcLsPe/nll5k3b17aB8Hhw4czYcIEsrOz2bJlCy+99BKxvWZIP/bYY1myZMlBM0C6EtwG+Oijj7j88suJRqOp2woLCzn//PPJy8ujpqaGF198Ma1USEFBAY8//jhFRUUdOuZHH32Um2++Oe22sWPHcuqpp+L1etm0aROvvvpq2gv16aefzoMPPphWyqWzJLgt+isZQ6I7ZPyI7uip8dM2kaOqqng8nv3qYLdlxnY149Hr9WKaJsXFxZ2eLG/btm3ceuutB5wkcl/19fXU1tZy/PHHH9FA5t5fwrta33nDhg1cdNFF+82pAsnj8vl8qYkKHcfpViD9O9/5DtFotEv/k71PBOx7MsS2bTRN69ZY6mggOB6Pd+j/pWkafr+fVatWdXqywcNRuqIzJ5D2bqsoCl6vlzFjxqQmou+Mng7IyPuX6CwJbouO0nUdj8dDIpHgxz/+MevXr6elpYWnnnoKTdP485//fMCTn1ddeTn2jvf5xQ+v52fXXYUrmIez5d+4Pnw8bR/VIYsbVoco8Ks0RBx2hJNlsGpbDz1nR9t7cndOiIujqz+8h0lwW6RZtmwZN998c1pA+UDGjh3L3XffzeDBgw/arqvBbYB//etfXH/99TQ1NR2y7eDBg/nDH/7Q6Uke//SnP3HXXXd16IPthAkTuOuuu1JP/K6S4Lbor2QMie6Q8SO6oyfGz96Zsvfffz/l5eVpXxZHjRpFWVkZc+fO7VCmbHsOZ0bz3tqCd5Zl8dxzzx3RQGbbBHUFBQVd3kZ1dTW33nord911V9rtbcfVNkHnqlWrePPNN7nuuusYOnQokUiE0tJSxowZQyAQIBwOs379+nYzefcOTuu63qMZzYdjLPXUlQQ9nRF+NPTEGOvJgIy8f4nOkuC2OJgDnWj3eDwMHDiQyspK/va3v+E4Dl//+tcZPnw4NTU1hEIhgsEgRUVFVFZWUl5ezmN/fYAhrmYe/8ufyFJaibtzcH34d/Sta9L2+UFtgltfCzMwqLGtxaY+YvNBrUmLcfDXs72vphJ9U394D5PgttjPp59+yh133MErr7zS7sSSBQUFzJw5k7Kysg7VqutOcBtg586d3HHHHTz33HPtBt2zsrKYPn063/ve9zpdQ7DN+++/z+9+9zvWrl3b7pfFIUOG8PWvf50rr7yyRyafkeC26K9kDInukPEjuqO746ezGa1LliyhtLS0U4Hgw53RvLe2sguGYRzxQKbX66W2tpYRI0Z0eRsVFRX89a9/TZvnBfYcl6IoqWB0Tk4O69evZ+fOnfj9foYNG0Z1dXXqS35bIOCPf/wjixcvpr6+fr/gdNv/vydOBByJsdRdPZ0RfqT1xBjryYCMvH+JzpLgtjiQjp4cveqqq7Asiy9+8YtkZmYyevRogsFgu+WZCvwKFa8/jSfehBXaiR0YgHft3Sj1n6Tte+UnBo9+GCXPp7Jpl8WumMN71QmMg7w11dfXk5GR0aEESdE79Yf3MAluiwPatWsX7777LjU1NbS2tpKfn8+QIUM4+eSTj8qkAa2trbz99ttUV1fT3NxMbm4ugwYN4tRTT+2xCWFqa2t5//33qa2tJRaLUVhYyIgRIzj++ON7ZPttJLgt+isZQ6I7ZPyI7ujO+DlStYgPZ0bz3vYtl3GkA5mH6zjbjsvr9RKLxVJlRM4880yefvppdF3vUCBg1qxZXH/99WnB6bbxk0gkiMViXT4R0FvqWnfG4agtf7hJ5rbo6yS4LdrT2ZOjjzzyCJMnT2bixIlpk+fuq6SkhPVrVxHZUYHduAUXCSxPFtFlN5Klpyc03vd2hP/UJPDqChUNJrtiDv+pMdudk2Lvq8RaW1t73VU+omP6w3tYTwe3OzatqugTcnJy0jKuj7aMjAzOP//8w7qPAQMGUFpaelj3IYQQQojexePxYBgGs2bN6vAXM8uymDlzJlVVVbjd7g4FyBRF6VRN5/a0ZSMfiKZpLF26NBX8A1J1nQESiQQ+nw+/34/jOIdlEijLssjPz2fUqFFdzlAvKipKq6W893HZts3999+fCmy/8MILB51Ya+PGjSxcuJCbbrqJxx57LJXN1l6mtMvlwjRN5s2bx4IFCw54IuBAQegjNZZ6kmmavT6Yva+eGGN5eXmEQqHD0DshhOi8trkEVq1a1aGTo+FwmBkzZrBs2TJWrFhx0Amny8rKiPsGYHpqUDKLUSLVvP7Cszy+qpG7L8lDseKpttec7ONHL5qEEw4jsjWsRosxeRof1+/fn7KyMiorK1m3bt1RO0ErxOGgHu0OCCGEEEII0RmqqqaCpZ0RDodZvHhxh69ocxynyyXU2rRdctyeQCDAihUrmDJlSmqywn2ZpolhGMRiMQzDOCxBzbZ9lJWVdWn9ti/Lq1atAtKPK5FI4PF4KC8vJz8/n+XLl7N69WpmzJhxyP9fOBzmi1/8Ymq7B6pbbhgG0WiUUCiEz+ejsLAQn89HKBQiEokcdALIIzWWPut6YowdrvEvhBBd0dWTo5deeim6rjN79ux22wQCAebMmYNl29i5I1H9WegFx/DGa69i2jYvxtPnLNNUhR+eGyCacHDrCkOzNPIzVIZmqftt96qrrqK8vJyZM2diGEaPXVEvxNEmwW0hhBBCCNFn6LqeCpZ2RXl5OR6PB10/9AWMe2ebdkVbRvO+gdOSkhIWLVpEVVVVKnPqaF8abNs2c+fO7XQwf+8vy8cee+x+x6UoCvX19WzcuJE5c+agaRqXXXZZp7OkY7HYIb+Ed/ZEwJEcS6J7Y2zOnDlH/TkihBB7687J0YceeoiysjJUNT0kt/dVT/F4HFQNtWgcLVGTNzfW4HcpPPXKOxjjvpS2XqZH5YfnBKgNWWR5FQZkqAzP1sj1KantPvbYYyQSCR544AE5QSv6HQluCyGEEEKIPkPTtFSwtCsqKipoaGjo0Be6nsg2jcfjqUkRKysrqa+vZ8OGDcyfPx9N03pFYBuS2c8ej4clS5Z0+Mtu25dwn8/HDTfc0O5xtZV2UVWVsrIyHnrooV6TJX0kx5Lo3hhLBXqEEKIX6ImTo8OHD08rsXqgq7kUl5cWbzGhuMP2FhuX2cqvH3sNZ/Cpadscmatzzal+qsM2RQGVTLfCmHyd/Kw9250+fXqqFIqcoBX9iQS3hRBCCCFEn9ETdbDD4TCKonSobXezTU3T7FK5jCPNcRxisRilpaUsX778kMfb9iW87Yu51+tt97jaSruUlpYybNiwXpUlfaTH0mddV8fYwcr2CCHE0dATJ0dramoYPXr0Ia/mchyHjNwBrK832RWzqQnbhGo+5WfPbsYODkzb7oXDPVwwzE1TzOHUUQP5n2u/xaa1zzDpwgu499570yaxlBO0oj+R4LYQQgghhOgV2jKhvF7vAQOZPVEHOxAIdDhQ1hPZpkeibnZPaJt4cfLkyVRVVbFo0aL9SrLs+yW8tbU1FdBu77jaSruce+65VFdX96os6SM9lkTXxlhvubpBCCHa9MTJUcMwuOWWWw55NVfb+2jOoGPZvMuittVmV9ShuWozN/xzO4aT/llp7ikZ/P7XP+HHN/2Mc48fzjNPLsXVXMlzz63crw9yglb0F3L9gRBCCCGEOKo8Hg+qquLxeKivryccDhMIBMjPz09lbLZlA+9dB7srgdKSkhLy8vIOOMnjvvbNNp01a9ZBv9AGAgGWLl3KlClTiEQifS7w2RZ8dLvdzJs3jwULFtDQ0JD6n+Tl5WEYRqrdoY6vLbB//vnnd/gxP5BwOIzf7+/WNvZ2pMeSSOrpMSaEEEdaT50c9fv9hMNhEonEAdvtXSJt4cKF+F0KCuDWNNxOK796OcLNFwRQdwepFRz0N+7ljsqBbK34mC/MmEn1px+zfu0LqKpKaWkpY8aMSX3OkuC26A8kc1sIIYQQQhw1iUQC0zS55557KCkpoaCggBEjRlBQUEBJSQn33nsvpmni9/vRNK1H6mB3Nnv6s5Zt2nYyIRqNdqmkyr4Z+ACnnHIKwWCwW/3q6SzpozGWRFJ3x5gQQhxNPTHhdF5eHkCH3kP2LpFW0WDRFHPY3GRh2w71EZs//yea1t6jmFyStZmGuM45p5/AG88t4wfzLmfzx+/x7LPPcsMNN3DllVcSjUbxer34fD68Xq8EukWfpTjyiUGIQ9q1a9fR7kK7FEUhOzsbgKamJvkCIDpNxpDoDhk/ojt0Xcfv9/Pcc891KBt6yZIllJaWEolEcLlcmKZJcXFxpy4LDgQCVFVVoWkahmF0us+KouB2u1FVFa/Xe8Bs03g8/pl7PiiKctAM/Hg8jtvt5owzzuDNN9/s9PZLSkrYsGEDoVAI0zR77PXH6/UelbEkji55/xKdpa5bR9bZZx+0TfPrr2OPHXuEeiSONr/fzz333MPChQs7ve6iRYu49tprcbvdHXoNUhQFv9/P6tWrmT59OopjcVKRTo5X5dhcjWbD5qoT/Zw3zJ22Xl3WcQTPuRonVAvZQ3j6pTf41YMr+GjDJ6k2o0aNoqysjLlz5+LxeIjFYn325PxnRX94D8vJyenR7UnmthBCCCGEOKLaAqHPPfcc06dPP2RQMRwOM336dJ5//nm8Xi/xeLzbdbC7QrJN26dpGn6//6AZ+HfffTehUIgXXniBCRMmdHofhytLuidqqgshhPjs6e6E0263+9CNd9u3RJrXH+CjOpPWhMOOkE2uT2Xxu61saUoPShc0f4i7YT2fbKvlpgVzefCPd+NqrmTv/OyNGzeycOFCiouLWb16depKOSH6EgluCyGEEEKII8rj8WAYBrNmzepwdpBlWcycORPDMHC5XGlf8g71xTIQCLBixQqmTJmSquHdXX1lksjDrS2wvXr1aoqLi1m4cOF+9av3/uL86quv8uKLL3YqwN0WCDgcmWT7BgyOxlgSQgjR93T35Ghn7Vsi7Ze3LcLMGsqumE19q0OeX+PPGzMw951a798P8Md7/0AkFmNYlkaWR2FEzv793TeRQEqUiL5EgttCCCGEEOKIUlWV+++/v1NlICD5xWvx4sVomvaZq4PdGymKgtfrZdWqVZ3KwH/ppZdYsWIF+fn5h9zHkciSlrEkhBCis7pzcrSr5aza3q80TWPevHms/e8nPPnCWhbd/zC/uu0OfvaznxI/+Rtp66iOxY/O8VPfauPTFQYGNAZnquT69g9e751I0JnMciGONqm5LUQHSM1t0V/JGBLdIeNHdIWu6wSDQUpKSvbL8O2I9movSx3so6M79ap37NjBHXfcwc9//vODtlu6dClTpkzZL5h8OF5/ZCx9dsj7l+gsqbktDkTTNLxeL4ZhsHjxYu677760zzclJSWUlZUxZ86cVE1r27a79RrUVt5N13V0XSf66VskmmvRm7fiDWYTef+feCtfSltnzfY4v/93K8VBjc27LBqiDu9UJ4i3c5520aJFzJ8/n0gk0unHQxx+/eE9rKdrbuuHbiKEEEIIIUTP0DSN+vr6LgW2ASoqKmhoaMDn82GaZqoONkAikcDn8+H3+3EcJxUAF4dHdzLwH3jgAX74wx+Sk5PDvffee9BAwKGypD0eD47jYFlWt/7fMpaEEEJ0Vls2tdvtZt68eSxYsOCAJ0cjkQiO43Sr5MfewfT77ruP8vJyKjdt5JRiFzlehQklRUz90ixOLhwNOzek1jtzsJt1dSZvbE8wJEsjapqMzdd5v3b/97by8nIWLFhAPB6X9z7RJ0hwWwghhBBCHDGKonQ6GLqvcDiM3+/f73bTNOVL2BGi6zoej4fy8vIurd/2xXn+/Pl873vfO2QgoE1btpqqJqsr1tfXp9bLz89P1cHu7sSeMpaEEEJ01JE6Odo2z8WqVauYNWtW2uepdXUmxw/Q+e/mWsZv/C+jps7C3HozOd491Yi/cYKPdfUmMROGZWkkbIthWSpbmu20/eybSLA3XdfRNA1FUXrkxLIQPUFqbgshhBBCiCPGcZxD1qU8lEAg0CcvwexPeioD3zRNQqEQPp+PwsJCfD4foVCISCSyX4C67Uu9aZrcc889lJSUUFBQwIgRIygoKKCkpIR7770X0zTx+/0dnuBLCCGE6CmHa8LpQ81z0Ww4bG6y2BmxcTxBjHATv3k9jGXv9T6qKtx4doDmmI3fpVAUUBmWrZHt3T+TPBwOpzLM2/bt9/sJBoNEIhFqa2uJRCIEg8FUMN/r9eL1elMlU4Q4UiS4LYQQQgghjhjLssjPz99vwr6OKikpIS8vTybzO8p6KgNfUZQOBQLaAturV6+muLiYhQsX7hdY37hxIwsXLqS4uJjVq1dLgFsIIUS/4fF4MAyDWbNmHfAz0PYWm/pWm9qohtefQXPM4c/vR9Pa5PtVvntGBrVhm0K/SsCtMCZfx7VPdLAtkeBgJ5bHjh3LHXfcQTQaxePx0Nraul/Q2+v1dqsMixAdIcFtIYQQQghxxLQFMsvKyrq0fllZWY9mQomuOZIZ+IfKVttXOBxm+vTpPP/88/KlWgghRL/Q0XkuNjRYbKjcQebQ4xg8sJDXtsZ5a0c8rc2pxS4mHuMmFHcYmqXh12Fs/p5M67ZEAuCAJ5bPPPNM1q1bx9VXX81DDz0kV1OJo0qC20IIIYQQ4oiybZu5c+d2OjgaCASYM2eOZG33AkcyA78j2Wrt9W/mzJkYhoHb7e5SH4UQQojeoDPzXFgOPPTP19nZFOKEc6eR61MpfydCfSS9rvY3T/CR6Ume/B2WpZHtUxialQwRtiUS6Lre7onlM888kxdeeIE1a9YwdOhQuZpKHHUS3BZCCCGEEEeUYRh4PB6WLFnS4S86mqaxdOlSPB4P8Xj80CuIw+pIZuB3NFttX+FwmMWLF8uXaSGEEH1aZ+e5CBs2Dyx7mYkX/z9abTeZHpXfvrF//e0fnB2gMWKT4VYYkKEyLEtjYG4ykUBV1XZPLOfn57N8+XJWr17NjBkz5Goq0StIcFsIIYQQQhxRjuNgGAZTp05l+fLlh8zgDgQCrFixgilTphCLxWQyyV7iSGTgdyZbrT3l5eUysZUQQog+rSvzXNy1+GFMXx5XX/dD4rZCOOHwt/+m198uyFD5zul+drbaDMhQyfJqPH7fLXh0Fdu22z2xPGfOHDRN47LLLpOrqUSvIcFtIYQQQghxxFmWhaZpTJkyhaqqKhYtWrRfiYuSkhIWLVpEVVUVkyZNIhKJSEmSXuRIZOB3NlttXxUVFTQ0NEj2thBCiD6rK/Nc1NfX84Urv83JZ13AN6/7CX6vl9e2Jni3OpHW7ozBbs4b5sZU3dxy47WcdsJxmDUbcLvd+51YVlWVsrIyHnroIbmaSvQqEtwWQgghhBBHjcvlQtd15s2bR0VFBfX19VRWVlJfX8+GDRuYP38+mqZJYLsXchyHWCxGaWnpYcvA70q22r7C4bBcBi2EEKLP6uo8F2vW/ptpX/8O4088lV/+/kGunDmDJ7YGaIym19+ec0oGd9x6C6NLRhGv+xQl1kRj5Yf7nVguLS1l2LBhcjWV6HUkuC2EEEIIIY4qwzCIRqOEQiF8Ph+FhYX4fD5CoRCRSATDMKQUSS9lWRaRSITJkycflgz8rmSr7SsQCMj4EUII0Wd1Z56LV994kyde/QB3Zh5nTbmEW372I3yTFuCw56SvioP+7z8S0wM4sRBKpB6jZiNBd/qJ4TFjxlBdXS1XU4leR4LbQgghhBCiV2j78haLxTo82aA4+toC3Jqm9XgGflez1dqUlJSQl5cnWf9CCCH6tO7Mc/GVK+eS8OYTd2cTS4ArmI8zfnpaOyVci+ujJ3H8eRCuw6c5jC3Q0ZT0bYVCoW4dh1xNJQ4HCW4LIYQQQgghuqVtktCezsDvTrYaQFlZmZwoEUII0ed1e56LjCIcdwArUIRpRIkPOgM7d2Rae73yNdTGTdiqm0ynhZLhgyjJ27OvcDhMMBjs1nHI1VTicJDgthBCCCGEEKLH9HQGfney1ebMmSNZ20IIIfq8bs9zgYKdNxLH5cMJFKIYLcRPugJH96at53r3r1iKjhk3uPTzF1CQoTIgIxk6XL9+PQMHDpSrqUSvI8FtIYQQQgghRK/V7Wy1ePww91AIIYQ4/Lo9z4XLh5M9FHw5OJ4gim2SOOmKtPWVRATX2w/gZBRywRknUZzt59hcDZ8Oq1atYsuWLXI1leh1JLgthBBCCCGE6LW6na0mlz8LIYToJ7o7z4UTKMTx5eAEB+KgYmcNxRx6VlobreET7A2r0IMF/PA7VxHwaIwt0HFsm/Lycq666iq5mkr0KhLcFkIIIYQQQvRq3c5WE0IIIfqJ7s5zYeeOSJYnySqGRARzzMXYGQVpbfSPnyIRqmfMuM9x2/9+m8IsP8fkaCxevBjLsnjkkUfkairRa0hwWwghhBBCCNHr7Z2tNn/+/E5nqwkhhBD9TZfmuVD13fW3/TgZ+SjxVuKnXo2j7AlWKzjo//4jhhZg7KhjePzBe7jlB99h+IAsLrnkEiZPnsyTTz4pV1OJXkGC20IIIYQQQog+Ye9sNYC8vLxOZasJIYQQAvAEcbIGgT8fR/ehaG7McV9Ma6JG6tH++zgxdzaa0cT0qRP599OP8M+nnqCpqYmpU6fK1VSiV9CPdgeEEEIIIYQQoqskmC2EEEJ0nhMsxom1QGYx7NqMVXwSau2HaPUVqTZ65atYxSeSCAyAhkos1YUPN/7C0ZimidvtZt68eSxYsICGhgbC4TCBQIC8vDwMw0hddSXv0+JwksxtIYQQQgghhBBCCCE+SxQFO3dksv52cCBKvJXE8bNwdG9aM/fbD+G4fCiA1VyF2VxLrLEKwzCIRCJdrv0tRE+R4LYQQgghhBBCCCGEEJ81uhs7dwR4gti+HBTbJHH819KaKPEQ7nf/gp0xADXWArEW1F2VYCVSbbpU+1uIHiLBbSGEEEIIIYQQQgghPot8OdiBQggU4mge7OyhWMUnpzXRqt9Hq3oXxxNECdeimDGUpi1HqcNCpJPgthBCCCGEEEIIIYQQn1FO9lAcdwAnsxhsk8SYz+N4stLauN5/BFBQcCBcixpphOiuo9NhIfYiwW0hhBBCCCGEEEIIIT6rFBU7b3f97UAhipUgfuKl6U2sOO63H8D25yfLkxih/cqTCHE0SHBbCCGEEEIIIYQQQojPMpcPJ3toskyJNxP8eZgjzk9rojZuQt/6Bo4ngBKqQUnEUJq2HqUOC5EkwW0hhBBCCCGEEEIIIT7jnEAhtj8XAkU4qJjDz8UODEhro3/0JFjWXuVJGqQ8iTiqJLgthBBCCCGEEEIIIYTAyRmeLE+SNShZf/tzX8VBSd2v2Cbudx7E9uehxpr3lCexzaPXafGZJsFtIYQQQgghhBBCCCEEqDp23rHJAHdGPrgDmMdOSm/StAW98l847gwpTyKOOgluCyGEEEIIIYQQQgghkjwBnKzB4M/HcfmxB52GHRyY1kT/eDlYiT3lSVrrU+VJdF3H4/Hg9XrxeDzoun40jkJ8RkhwWwghhBBCCCGEEEIIkeIEB+L4snAyi3FUlcS4L+Ioe8KIimPhfuchbH9usjxJPIy3tQq/x0UwGCQSiVBbW0skEiEYDOLz+fB6vSiKcpC9CtF5EtwWQgghhBBCCCGEEELsoSjYuccky5MEB4I3G3PkPuVJmrehf/oKijcTb6wBO9bKI/f8mpKSEgoKChgxYgQFBQWUlJRw7733Ypomfr8fTdOO0kGJ/kiC20IIIYQQQgghhBBCiHSaGzt3BHiC2L4c7OITsTMHpTXR1/8Tt2qxYcN6vnf1LP58z+00bv8krc3GjRtZuHAhxcXFrF69WgLcokdJcFsIIYQQQgghhBBCCLE/Xw52YAAECnF0L4kx03GUPYFpxbGJvngXv7izHJ8aJ9OtMCpPR28n4hgOh5k+fTrPP/+8lCgRPUaC20IIIYQQQgghhBBCiHY5WYP3lCfxZWGOmpx2v8+oZ+oxLloMh8FZGj4dRuW2n5ltWRYzZ87EMAzcbveR6L7o5yS4LYQQQgghhBBCCCGEaJ+qYeeMQPNlogXzUYechpM9NK3JZZ/zoqvJQOOgoEZBhkqer/3M7HA4zOLFi6U0iegREtwWQgghhBBCCCGEEELsR1EUvF4v/twi/ANGEHNlE2qNESu5GJQ9YUVdVfjehAyqwhY5PoVMt8LIXB31AJVHysvL8Xg86Lp+hI5E9FcygoQQQgghhBBCCCGEEGk0TcPr9WIYBvfffz/3//E+slq3UOBXGJGjUToml6lD7VT70Xk6U47xEs0t4ZyiQlq8A/hCq8Yb67azatUqbHtP24qKChoaGvD5fJimCYCu62iahqIoOI6DZVmp+4Q4EAlu9xMVFRVs3LiR2tpaVFWlqKiIcePGMXTo0EOv3MOqqqrYuHEj27dvJxwOo+s6WVlZjBw5kvHjx0tNJSGEEEIIIYQQQoheTNM0/H4/q1atYtasWYTDYQByfQoeXWdX1GHV+kbGZmUwNGtPeZE5p2aiTv8eoboaInhx5w/lx8dPZEtVHX/84x9ZvHgx9fX1QLI8id/vx+v1oqoqHo+H+vp6wuEwgUCA/Px8YrEYjuNgGAaO4xyVx0L0bhLc7uOWL1/O4sWL2bBhQ7v3n3TSSVx77bWce+65h60P0WiUV155hZdeeok1a9ZQW1t7wLYej4eLL76Yq6++mpKSkg7v44knnuB///d/u9S/Sy65hN/+9rddWlcIIYQQQgghhBDis6StFMmqVauYPn06lmWl7muMOtS12mgKBD06f/sgyg/OyUBVkvVHFDvBxv/7ATc/X0dBhkpFg4k3bwgXfO1abrjhBhYuXMgll1zC2rVrCQQCuFwuotEo999/P+Xl5WzcuDG1r1GjRlFWVsbcuXPx+/3EYrG0vggBUnO7zzIMg//5n//h+9///gED2wDvvfcec+fO5bbbbjssZ7g2b97MWWedxXXXXceyZcsOGtiGZL+ffPJJ/t//+3+Ul5f3eH+EEEIIIYQQQgghRNd5PB4Mw2DWrFntBpM3NlrETNjRYtEQtXlmo5F2/7HBBKcPcpGwHQYHNZp3buM3P/0+Q4cOZc2aNbz44ovMnDmTvLw83nvvPYqLi1m4cGFaYBtg48aNLFy4kOLiYlavXo3f75dJKMV+JHO7j/rRj37E008/nVpWFIWzzz6b0aNHk0gk+O9//8t7770HgOM4PPjgg/h8Pr773e/2aD9isRiRSCTtNk3TGDduHKNHjyY/Px/LstiyZQtvvPFG6jKWRCLBnXfeSSgU4vvf/36n99uZFzN54RNCCCGEEEIIIYToGFVVuf/++1MxnH2ZNmzaZeHSNLJjDi9viXPKQBcDg3uVJznZz/dWthD0KGR7FI7J0XirKsyMGTNYtmwZDzzwAOFwmLPPPptEInHQ/oTDYaZPn86KFSuYNGkSkUhESpSIFAlu90GPPPIIK1asSC0PHDiQ++67j7Fjx6a1e/3117nuuusIhUIA3HvvvZx88smcc845h6VfJ554IjNnzmTq1KkEAoH97g+FQtx55508/PDDqdsWL17MqaeeyoUXXtipfa1atYrBgwd3u89CCCGEEEIIIYQQIknXdTwezyGvtt/ZalPoV9EViwy3zsP/jXL9WXtiQX6XwtUn+bj/3SjFmRothsmIbI2NjRaXXnopVVVVrF279pCB7TaWZTFz5kyqqqpwu90YhnHolcRngpQl6WOi0Sj33HNPatnj8fDQQw/tF9gGOPvss7n33ntRdtc9chyHRYsW9XifTjrpJP72t7+xZMkSvvzlL7cb2AYIBoP89Kc/5Zprrkm7XephCyGEEEIIIYQQQhx9mqZRX1+/X4mQ9mxoMImasL3Fojpss/rT9IDzhMFuRuZoqAoMDGgMDKoE3QrhcJjFixczevRoVLXjocm29eQKfbE3CW73MUuXLk3NKgswZ84cRowYccD2p59+OtOnT08tf/TRR7z00ks91p9Ro0bx2GOPcdppp3V4ne9+97tpWdeffPIJmzZt6rE+CSGEEEIIIYQQQojOUxTlgOVI9pWw4ZNGk2bDoSnm8MKnBo1RO61N2al+QoZNnl/BpyuMyksGpsvLyxk6dCilpaWd6l95eTkejwddl2IUIkmC233Ms88+m/pb0zRmzZp1yHUuu+yytOWVK1f2WH+68mLicrn2e/H64IMPeqpLQgghhBBCCCGEEKILHMc54BX57amLONS12mxvsWg1YelH0bT7c30q/2+sl5jpMDhTJeBWKA6qVFRUUFNTw+jRozvVv4qKChoaGiS4LVIkuN2HNDY28v7776eWTzrpJAYMGHDI9U488USKiopSyy+//HK7s90eSUOHDk1b3jsbXQghhBBCCCGEEEIceZZlkZ+fz6hRozq8zsZGK1mepNmiScuF4uPT7v/8KC9ZXhW/SyHPpzI8W8OlJudmCwaDne5jOByW0iQiRYLbfci7776Lbe+5vOOkk07q8Lonnnhi6u+mpqYO1U46nFpbW9OWXS7XUeqJEEIIIYQQQgghhAAwTRPDMCgrK+v4OjZUNJi0xB1OOWcSzQNOI5pw0tqUneqn2bAZGFDxanBsrkYwGCQUCnW6j36/v1O1ukX/JiOhD9m3LvW4ceM6vO748ePTlj/99NMe6VNXbdiwIW25IxnoQgghhBBCCCGEEOLwsm2buXPndqo8SWPUocX2cs5FX+WVtz9kRUUs7f5hWRrnDXXjAAODGiePHsaALO9+8aFDKSkpoaCgAF3XpTSJAEBGQR+yb0B64MCBHV5337ZHM7gdiURYvXp1allVVc4444xObeO+++5j06ZNbN++PXUZS05ODscddxxnnHEG06ZNw+v19nTXhRBCCCGEEEIIIfo1wzDw+/0sWbKE6dOnd6i0raZp/PKe/8NUXDz+3BsU6glOGehiZO6e0OPXjvPxbk0LuT6FC74wjZqP1vD8qlWd6ltZWRmVlZUEg0F8Ph+maXb6+ET/IpnbfUhtbW3a8t51tA9l37Y1NTU90qeuePDBB4lEIqnl008/ndzc3E5t4/HHH+e9996jrq6OWCxGXV0dFRUVPPHEE9x4441MnDiRv/zlLziOc+iNCSGEEEIIIYQQQgggOalkLBajtLSU5cuXHzKDOxAIsGzZMiZOLmXWtT+kqqGZhojDE+tiWPaeuIxbU7j6RD+26mbqWceT5XfxhfM6XnI3EAhw1VVXUV5eTjgcRlGULh+j6D8kc7sP2bdOdUZGRofX3bft3sHlI6miooI//vGPabd9+9vf7vH9NDQ0cMstt7BmzRruvPNOfD5ft7bXW18w9+5Xb+2j6N1kDInukPEjukPGj+gOGT+iO2T8iM7qyDhRFEXGk+iQvvIaZNs20WiUyZMnU1VVxeLFi7nvvvvS5nArKSmhrKyM2bNnYxgGEydOZO3atxidp6ECmV6FVZsMLhq158r64we4+O4JF2HGImx+bw2Plv+WaVffyKtvvHnQ/miaxqOPPkoikeCBBx7g+9//PtC7H8PDoa+MnyNJgtt9SDQaTVv2eDwdXnfftkcjuN3a2sqCBQuIx+Op22bMmMFpp53WofVVVWXChAlccMEFHH/88QwbNoxgMIhhGNTU1PDmm2/y6KOPUlFRkVrnpZde4sYbb+Suu+7q1pM+Ozu7y+seKVlZWUe7C6KPkzEkukPGj+gOGT+iO2T8iO6Q8SM6JDOzA00yoQ98bxS9S195DXK73Vx77bUsWLCAhoYGWltbycjIIC8vj3g8jq7rvPnmm3z44YcAbNplketTqQrZvLo1zskDXQwIaKntDd+1lt/+6V1qtm3lsus8PPnAnYw+94vU19e3u/9AIMCjjz7KpEmTmDhxIrm5ueTl5QF0O5mxL+sr4+dwk7IkfUgsll6M3+12d3jdfdvuu63DzbZtvv/97/PJJ5+kbhsyZAg/+tGPOrT+iSeeyPPPP89DDz3EN77xDU466SRyc3NxuVwEAgGOPfZYLrvsMpYvX87ChQvTAtnPPfccf//733v8mIQQQgghhBBCCCE+C9riSnl5eQwdOjQVXHa73aiqyvnnn09VVRWLFi1ixMhRbG6y2BWzaYw6vFCdPieaYoQZr1eRsG0e/N0teKwIK5b8hVGjRqW1KykpYdGiRWzbto0zzjhjd2b4WsrKytISJ8Vnm2Rud8HEiRPZsWPHYdv+DTfcwOzZs/e7fd/s60Qi0eEA975P+s5kffeEX/3qV7zwwgup5WAwyD333EMwGOzQ+sccc0yH2imKwjXXXAPAHXfckbr9nnvu4Utf+lKnTgjsrampqUvrHW6KoqTO1DU3N0uNcdFpMoZEd8j4Ed0h40d0h4wf0R0yfkRnqS0tHCp3u6WlBbuXfm8UvUt/fQ3y+Xz85z//YcaMGSxYsICa6mqMLe+SocTIsRuJvvkonvqPU+0vHuXl9W1xYmacVSueYNpXrmDD+vXU7txJKBQiGAxSVFREZWUlt956Kw888AD19fUEAgHmzJmDZVm9NlZzOPWH8dPT1REkuN2H+P3+tOVYLNbhYK1hGAfd1uF0991387e//S217PF4uPfeexk9evRh2+ecOXN46qmnUpniNTU1vPPOO5x55pld2l5feLFwHKdP9FP0XjKGRHfI+BHdIeNHdIeMH9EdMn5ER3RkjMhYEl3RX8aNrut4PB5mz57Npk2bKC0tZfTo0eQGvWRHthKu3kRs+0dcf1YGPteeK+2vPtHP7WtaeffVZ5g+83J+e9NCdoQcgsEgoVCIDRs2sGrVKmzbBpJ1t5cuXYrH4yESifSLx647+sv46S4Jbvch+wakI5FIsq5XB+w7GeWRCm4//PDD/OEPf0gt67rOnXfeyemnn35Y96uqKjNmzOD2229P3bZ27douB7eFEEIIIYQQQgghxP40TaO+vj412eTKlStZuXIlACOyNYZmqYzO0/jnxhhfHbenRvbIXJ1TBuqsq9tJS9UmTi8ZyEsVTTSHw/sFtgOBAEuXLmXKlCkS2BZpJLjdBXfdddd+mdA9aciQIe3ePmDAgLTl6upqioqKOrTNmpqatOWOrtcdTz31FL/4xS9Sy4qi8Ktf/YpJkyYd9n1Dsk733g5nKRkhhBBCCCGEEEKIzyJFUQiHw+3et6XZoiBDZUfI5s0dCU4vdjEse0848vLP+fnhCy1YLbWceuIJDBur4Rk0noEDB1JZWck//vEPMjIyuPzyy1MZ25ZlHalDE32ABLe74HOf+9xR2e++daerq6s56aSTOrRudXX1QbfV01544QV++MMfpp1J+/GPf8yXvvSlw7rfvbVNbtBm165dR2zfQgghhBBCCCGEEJ8FjuMQCATavc924JNGE6+usyvq8MR6gwUT9oQj/S6F/zfWh6Zr/OMv9/LA48/yXrVJ0bBjKSsr45prrsHr9WJZlmRsi3apR7sDouNGjhyZtvzxxx8foOX+Pvroo4NuqyetWbOG733ve5immbptwYIFXHHFFYdtn+2JxWJpy0d6Ek0hhBBCCCGEEEKI/s6yLPLz8xk1alS79zdGHRoiNttbLLY0WbyyJb0awnnD3ASVGKG6bXg1hZG5Ghs3bmThwoUUFxfz/PPPo+s6qiphTLE/GRV9yMknn5z2RH7vvfc6vO5//vOf1N/Z2dkce+yxPdm1lPfff5/58+cTj8dTt82dO5eysrLDsr+D2bZtW9ryvpncQgghhBBCCCGEEKJ7TNPEMIyDxn42NloYFtSEbV74NE6LYadv4+1H+HjdBgZlqmR6FAozkvGvcDjM9OnTef755/F6vSiK0t7mxWeYBLf7kLy8PE444YTU8nvvvUdtbe0h13vvvffSam6ff/756HrPV6TZsGEDc+fOJRKJpG67/PLLuf7663t8Xx3xyiuvpC2PGTPmqPRDCCGEEEIIIYQQoj+zbZu5c+cesDxJ3ErW366P2tRHbJ7akH61vRap59SBOgG3QrZHYUS2hro7jm1ZFjNnzsQwDNxu9+E+FNHHSHC7j5k2bVrqb8uyWLJkySHXefTRRw+4jZ6ydetWZs+eTXNzc+q2GTNm8JOf/KTH99UR27ZtY/ny5Wm3nXvuuUelL0IIIYQQQgghhBD9WTwex+v1smTJEjRNa7fN9hab1rjD9hab92tMKhrMtPu/Ms6LpsLAoIZXh6FZe8KW4XCYxYsXH3Db4rNLgtt9zMyZM9PKayxevJjNmzcfsP2bb76ZFuQdN24cF1544UH38Yc//IHRo0enfv7whz8ctH1tbS1XXXUVdXV1qdumTZvGr371qx65XGTTpk0kEokOt29ububb3/52WmmUCy+8kKFDh3a7L0IIIYQQQgghhBBiD03T8Pl8xONxJk+ezJNPPnnADO6NjRYR0yFsu9HHX4zDnriRV1e4pMSLS4XCDJXBmRqevWLZ5eXleDyew1KNQPRdEtzuY/x+P/Pnz08tG4bBVVddxbp16/Zr+/rrrzN//vy0mWQXLFjQo/WJmpqamD17Ntu3b0/ddsEFF/Db3/62x86mPfbYY0ydOpUHH3wwrbzKvhzH4cUXX2TGjBmsX78+dbvP5ztqpVGEEEIIIYQQQggh+itN0/D7/axevZqioiLOP/98zjzzTLZu3cqiRYv2m2SyaNgovvntG7jz/kcoKjmFdxs9afefO9RNYYZKgV/Fo8HInD2xpYqKChoaGiR7W6SRUx190BVXXMG7777L008/DUB1dTUzZszg7LPPZvTo0ZimyQcffLDfhJNlZWWcd955PdqXl156iY0bN6bd9q9//SutNnhHfOlLX+KWW2454P07duzgtttu4ze/+Q3Dhg1j7NixFBYWEgwGicVi1NTU8M4771BdXZ22nqZp3HHHHYdtAk0hhBBCCCGEEEKIzyJFUfB6vaxatYrp06djWRZr165l7NixzJ49m7KyMhYsWEBNTQ2hUIisrCwKCwup/PQT/nb/r/j3C/+kyNXKqLMDZHr25N9e9jkfd65tpTiokbAhK2TTbCQTN8PhMH6//2gdsuiFJLjdR/3617/GsixWrlwJJLOWX3vtNV577bX92iqKwpVXXsn3vve9Hu/H3lnhbSzL6vR2bNs+dKPd+6usrKSysvKQbYuLi7n99ts59dRTO90fIYQQQgghhBBCCHFgHo8HwzCYNWtWWiyovr6e2267jdtvv53S0lJGjx5NMBjk5JNP5vzzz2fU6LHMvOh8Jpw3hUG+OJ8ktnEyW1LrD83SOKlI5/1ak/qIwshcjXerk/W5A4FAu7Eo8dklwe0+yuPxcNddd7Fs2TIeeOABKioq2m134okncu211/Z4xvaRNHnyZBobG3n77bcPWpakTUlJCbNmzWLGjBlkZGQcgR4KIYQQQgghhBBCfLaoqsr9999POBxu937btlm5cmUqMbMtVrN582YGDRpE3X9fwqjfTsCogXWPw66tqXW/Ms7Hx3UhioMqrQmHgQGVYPGx5OXlEQqFjsjxib5BceR0R7+wYcMGNm7cSG1tLZqmUVhYyPjx4xk2bNjR7lqPamxs5JNPPqGqqopdu3YRjUZxuVypS1uOP/54cnNze3y/u3bt6vFt9gRFUcjOzgaS9c/l6Sw6S8aQ6A4ZP6I7ZPyI7pDxI7pDxo/oLHXdOrLOPvugbZpffx177Ngj1CPRl/WX1yBd1wkGg5SUlOxXrrY9Z555JsuXL8ftdrN48WLKy8upqvyEkwfqDApqTBybzzfHJNLWebnSYEWFwbYWm9qwzcwFv2betd8mEokcrsPq9frD+MnJyenR7Unmdj8xevRoRo8efbS7cdjl5uZy+umnH+1uCCGEEEIIIYQQQnxmaZpGfX19hwPbL7zwAqtXr+ayyy5Ly/SuDtloCrxb2cBIn4dzh+2ZYPKC4R7Wbo+TsFUMPMz5ytQulcIV/Zt66CZCCCGEEEIIIYQQQgiRpCjKAcuR7C0/P5/ly5ezevVqZsyYsd86lc0WcRtqwjarN8cJx9PnZJv1uQAuVeWX/3sdbqOReGtTTx6G6AckuC2EEEIIIYQQQgghhOgwx3EIBAKHbDdnzhw0TeOyyy5rN+vatKGyyaIxarOz1ebpjUba/SOyFBZccTGfO6aYeGsIZdeW/bYhPtskuC2EEEIIIYQQQgghhOgwy7LIz89n1KhRB2yjqiplZWU89NBDB83yrgrZtMYdqkI2b1cl2NqcHgQf1Pwf4rEoTks1SqwFor1zXjRxdEhwWwghhBBCCCGEEEII0WGmaWIYBmVlZQdsU1payrBhwygvLz/k9j5ptGhNODREHJZXxNLuU4wWlO1vocTDYIRRm7aCYx9gS+KzRoLbQgghhBBCCCGEEEKITrFtm7lz53x5qScAAIgJSURBVB6wPMmYMWOorq7u0KSTzYZDfatNddjikwaLd6oSaffrn74CiQhK606URAwlvLNHjkH0fRLcFkIIIYQQQgghhBBCdIphGHg8HpYsWYKmafvdHwgECIVCHd7epl0WhgV1EZvnNsVIWE7qPsWx0De9hGIaEGtCaakC2+yR4xB9mwS3hRBCCCGEEEIIIYQQneI4DrFYjNLSUpYvX75fBnc4HCYYDHZ4e4YF21ssdrbaVIcdVn+aPrmkVvtflFANSms9immghGp65DhE3ybBbSGEEEIIIYQQQgghRKdZlkUkEmHy5MlUVVWxaNGi1CST69evZ+DAgQeddHJfW5ttYibsaLFYF8kCb2ba/frGlShWHKKNKKFqMOM9ejyi75HgthBCCCGEEEIIIYQQokvaAtyapjFv3jwqKiqor6+nvLz8kJNO7st24NNdJi1xhxPOvBD72Elp96uhGtS69SiRRhQrgdKyo6cPR/QxEtwWQgghhBBCCCGEEEJ0meM4GIZBNBolFArh8/koLCxEUZSDTjrZnrqIQ0L1ce5FX8EZMB47a3Da/fonz6MkotBaj9JaB4lIh7et6zoejwev14vH40HX9Q6vK3onCW4LIYQQQgghhBBCCCF6hGmaGIZBLBYjEokcdNLJ9miaxs2/fwiXP0jCFcQcmZ69rSSiaNvfQonuQjHjqE3bD7o9RVHwer34/X6CwSCRSITa2loikQjBYBCfz4fX60VRlC4fszh6JLgthBBCCCGEEEIIIYTocYeadHJfgUCAFStWMHHadAxXJk5GPnbWIKyBJ6a107a+gRprRmndiZ4I4bFj7WZja5qG3+/HNE3uueceSkpKKCgoYMSIERQUFFBSUsK9996LaZr4/f4OB+BF7yHBbSGEEEIIIYQQQgghxGFxsEkn25SUlLBo0SKqqqqYNGkSkUgEM1CMo7lx/PmYw87CUV2p9opj49ryGm47hleHWE0FtTU1adnYPp8Pv9/P6tWrKS4uZuHChWzcuDFtvxs3bmThwoUUFxezevVqCXD3QVJYRgghhBBCCCGEEEIIcdi0Bbjdbjfz5s1jwYIFNDQ0EA6HCQQC5OXlYRhGqp3jOKC7cTIHotgWjj8Pa+iZ6JWvprap1PyX/zS6efK123ljQxXr6kzqIg6jRo2irKyMuXPn4jgOt9xyC+Fw+KD9C4fDTJ8+nRUrVqSC647jHO6HRfQAydwWQgghhBBCCCGEEEIcVgeadNLn8xEKhYhEIhiGkRZUdoIDcXQPTmAA1qBTcDzBtG1m1f6bSNNOMt0KI3J0VGX/bOznn3+eCRMmHLJ/lmUxc+ZMDMPA7Xb3+PGLw0OC20IIIYQQQgghhBBCiCNm70knDcPANM32GyoqTvYQ8ATBnwvHTky7+5gcnfEFOsVBFZ8OQzL3hDrD4TAzZszghRdeYMWKFeTn5x+yX+FwmMWLF0tpkj5EgttCCCGEEEIIIYQQQoheyfHn4XgC6DmDSeSPZXvITrt/+mgvAbdCgV9lSJaGZ6+4tGVZXHrppei6zuzZszu0v/Ly8v0mphS9lwS3hRBCCCGEEEIIIYQQvZadPQzF7ePltz7gnxuiaffl+VVOH+SiMEPFo8HInPSs63A4zEMPPURZWRmqeuhQaEVFBQ0NDZK93UdIcFsIIYQQQgghhBBCCNFr6f4s3LmDWPL0S6yvt/igNpF2/8WjvAQ9CgMDGvkZKlkeJe3+8vJyhg8fTmlpaYf2Fw6HURTl0A3FUSfBbSGEEEIIIYQQQgghRK+laRoNlp/N23ZQH7V59hMDy94z8aRXV5g4wk2OTyHDpXBsbnrWdUVFBTU1NYwePbpD+wsEAmkTW4reS4LbQgghhBBCCCGEEEKIXktRFMKxBNUhm51hm+qQzatb4mltzh/mJserUBxUyXAnf+8tFAoRDAYPua+SkhLy8vKwLKtHj0EcHhLcFkIIIYQQQgghhBBC9FqO4xAIBNjabJGwYWerzUuVcSKJPdnVqqIw7VgPfpdCrk9leLaGvlfkMxgMEgqFDrmvsrIyDMPANM3DcSiih0lwWwghhBBCCCGEEEII0WtZlkV+fj7DR45iR8iiPmLTZDis/CSW1u7UYjcDMlQGBlTcKozITpYnKSkpoaioiA0bNhx0P4FAgDlz5kjWdh8iwW0hhBBCCCGEEEIIIUSvZZomhmFQVlbGtmabuA07wzZv7kjQGLXT2s4Y40VVoCigMTCokuFSKCsro76+nnffffeA+9A0jaVLl+LxeIjH4wdsJ3oXCW4LIYQQQgghhBBCCCF6Ndu2mTt3Lr6MANuaLRqiNq0JWFGRnr09Kk/nmGyNfL+CV4PPDQ4ye/Zs/H4/H330ERMmTNhv24FAgBUrVjBlyhRisZhMJtmHSHBbCCGEEEIIIYQQQgjRqxmGgcfjYcmSJdREFAwLasI2H+402dacXkbkK+O92DgMynLx21/+hPiuasaPH8+aNWt48cUXUwHukpISFi1aRFVVFZMmTSISiUhJkj5GP9odEEIIIYQQQgghhBBCiINxHIdYLEZpaSnLnlrO967+Gu5YjMKEwlMbYnz79IxU24EBjZMH+Tjt4isoGVfCtdd8jS2VlcyYMYMVK1bw8ssv09raSm5uLoZhYFkWkUhEMrb7IMncFkIIIYQQQgghhBBC9HptQejJkyfzTsU2vnXtd1EzB7C5yeKjukRa26+fnMOwYSP43S9/wKYNHzEkS8WyLGbOnEk8HicQCBAKhYhEIhiGIYHtPkoyt4UQQgghhBBCCCGEEH1CW4A7EAhw0dfm8rWvzKB503uY9Zvho4dT7ZR4K6sf+jU7tobJ96uYdrKMSTgcZvHixcyfPx/TNI/ikYieIJnbQgghhBBCCCGEEEKIPkPTNHRd58wp07nu+v9l6bOvsPajTVSaeWntpg5XcHAYkKHi0eCYbA2A8vJyPB4Pui55v32d/AeFEEIIIYQQQgghhBB9hqZp1NfXs2FDBXVbN3Jcoc6ILI0hWSo/PDeArioAeHSFaSO9PPOJwcCAhunAjpBNRUUFDQ0N+Hw+yd7u4yRzWwghhBBCCCGEEEII0WcoikI4HAagMerQHHOoDls0xRxe2GyktZ18jBtNccjxKXg1hZG5yeztcDiMoihHvO+iZ0lwWwghhBBCCCGEEEII0Wc4jkMgEEgtb9plEbNgV9ThX1sSRBN7JofUVIUZY3wYlsPgTJVMj8KADJVAICCTSPYDEtwWQgghhBBCCCGEEEL0GZZlkZ+fz6hRowAIxx12hm2qwxbhuMNzm9Kzt88d5sbvUshwK2R7FM4/fji5OdlYlnU0ui96kAS3hRBCCCGEEEIIIYQQfYZpmhiGQVlZWeq2zU0WcRvqIjb/3hGnxbDT1rn0OB/NhsPAoMaXv3gJ8Z2fSr3tfkCC20IIIYQQQgghhBBCiD7Ftm3mzp2bKk9iWFAVsqlrtWlNwLMb07O3Tx7ootCvkOHz8PkLz8Bu2gGJ2NHouuhBEtwWQgghhBBCCCGEEEL0KYZh4PF4WLJkCZqWnCRyS5OFYUFt2ObdmgR1rellR755op/L53wHl9FMIhZGbd56NLouepAEt4UQQgghhBBCCCGEEH2K4zjEYjFKS0tZvnw5gUAAy4GtzRYNUZuQ4fDMJ+nZ2yV5Op8r9pOwLAjvRIk2QbTpqPRf9AwJbgshhBBCCCGEEEIIIfocy7KIRCJMnjyZqqoqFi1aREbRMUQTDjVhmw93mtRElLR17Pcew/LmosZaIN6K2rQVHOcoHYHoLv1od0AIIYQQQgghhBBCCCG6oi3A7Xa7mTdvHgsWLKBxWwXG9g/JMHbib/4E5+2/pdqroRq0mg+wc4ajhHeCy48SrsUJFh3FoxBdJZnbQgghhBBCCCGEEEKIPstxHAzDIBqNEgqF8OYOInvAIFw5g4gHhmBnDUlr7/p4GY4vB8WMQawJpWUHWImj1HvRHRLcFkIIIYQQQgghhBBC9AumaWLE48S8BSQUN5bLj3nMBWltlOgutK1rcLxZKK11KGYcpXn70emw6BYJbgshhBBCCCGEEEIIIfoXXw6OOwMnowAncxBWfkna3a71/8TxZqI4DrTWobbWQbz1KHVWdJUEt4UQQgghhBBCCCGEEP2OnTUYXD4cdwBz2Dlp9ylGCH3TSzgZ+SjRXWDGUJu2HKWeiq6S4LYQQgghhBBCCCGEEKL/8WbheII4GfkQKMQqHJ92t77hGRzNA7obJbwTxQhDpPEodVZ0hQS3hRBCCCGEEEIIIYQQ/VIqe9sTxBx2Ztp9SiKCvnEVTsYAlHgrGCHUpq3g2Eept6KzJLgthBBCCCGEEEIIIYTonzxBHG9Wsva2Px9r4Alpd+sbnwMcHHdGMnvbNFBCNUenr6LTJLgthBBCCCGEEEIIIYTot+yswaB7cLxZWEMm4KCk7lPMWLI8SWAAip2A6C6Uliqw/n979x3eVPX/Afx9k6Zp0r1LS9lQKYJMQRGRpYh+EVBx42APQYaICxy4FUWwICDiRIQfIkOmIAhUUVpBmWUVSgfdO2nG/f1Re+1NV9KmadK+X8/D8/TcnHvPuclJuPnck88pacAek7UY3CYiIiIiIiIiIqLGy90TosYf0AbBrPGHOaK77GG3c3sAQzFEDz8IRekQTCUQcq82UGfJFgxuExERERERERERUaNm9o0A3NwhavxgbH4jROG/sKhgKoHq9FaInkEQIACFGVAUpgMlhQ3YY7KGW0N3gOzj7NmzSEhIQFpaGhQKBcLCwhAdHY0WLVo0dNfqjclkQnx8PK5cuYL09HR4eXkhLCwM3bt3h5+fX0N3j4iIiIiIiIiInIVKC7M2EAqTAaIuF6bmveB25XfpYeWFfTBG3QlRGwih4BpEjT8UOZdhDunYgJ2mmjC47eI2b96MVatW4cyZM5U+3q1bN0ydOhX9+vWrtz4kJSVh0KBBtdo3NDQUBw4csGmfkpISfPrpp1i3bh3S09MrPK5SqTBgwADMmTMHLVu2rFW/iIiIiIiIiIiocRF9wiEWZQIevjA17wXl1aMQzEYAgGA2wu3kjzD0eAJCcQ6EgjTATQ0UZwMa/wbuOVWFaUlclF6vx6xZs/Dss89WGdgGgPj4eIwfPx7vvPMORFF0YA/rR1JSEh544AEsXbq00sA2ABgMBuzatQsjRozAtm3bHNxDIiIiIiIiIiJySioNRG0goA2CqPaGqUUf2cPKSwchFGZA9AqBUFII6AugyLkMiOYG6jDVhDO3XdSLL74oC9wKgoC+ffsiKioKBoMBf//9N+Lj4wEAoihi9erV0Gg0mD59er33TaFQQBCEmisCcHOzfgjm5+djwoQJOH/+vLRNo9FgwIABiIyMRE5ODmJjY3H58mUAQFFREebOnQt/f3/cfPPNtp0EERERERERERE1OqJPOFCUCdHDF6bw7lBeOQLBVAIAEEQT3E5tgaHXWIju2tLZ2+6epWlKvMMauOdUGQa3XdC3336LLVu2SOVmzZph2bJl6NhRngPo0KFDmDFjBvLz8wEAMTEx6N69O2655ZZ67d8bb7yBUaNG2f24L7/8siyw3bt3b3z00UcICAiQtplMJqxZswbvvfceRFGE0WjEjBkzsHPnTlk9IiIiIiIiIiJqglSaf3Nvl5Tm3m5xE9wu7pceViYeBDqPhOAfCWSeh8mQDzE/BaJnMKBQNmDHqTJMS+JiiouL8cknn0hltVqNzz//vEJgGwD69u2LmJgYaRa1KIpYtGiRw/pqT//88w+2b98uldu1a4dVq1ZVCFgrlUqMHTsW06ZNk7bl5eXh008/dVhfiYiIiIiIiIjIeYk+4YDS/d/Z210hKt2lxwTRDPH4/yGroAh6hRoepgKolQI8jLlWZyogx2Fw28V8//33yMjIkMrjxo1D69atq6x/4403Yvjw4VL5xIkT2LdvX732sT4sW7ZMVn755Zfh7u5eRW1g4sSJaNGihVReu3YtsrKy6q1/RERERERERETkIlQamLUBgDYQgrsX0Kaf7GHFxV8xe8IjGP3UVLz52ivYuWktTFlXoPVQQ6nk7G1nwuC2iyk/e1mpVOKBBx6ocZ+HH35YVt6xY4fd+1WfCgsLceDAAanctm1b9OnTp5o9AJVKhfvvv18q6/V6lwzqExERERERERGR/Yk+EVCoPODuG4JzOl/ojKL0mFIh4JHOGuiMwNmkNGzf8DXuH3UPDm7fAK1WywC3E2Fw24VkZWXh2LFjUrlbt24IDQ2tcb+uXbsiLOy/pPe//PILTCZTvfSxPhw8eBAlJSVS+Y477rBqv6FDh8rKP//8s137RURERERERERErklw18LdvxmOnknE8tVfYvd5vezxwa3dEeGtQFqBGSoFoIUeC54Zj927dsLDw4MpSpwEg9suJC4uDmazWSp369bN6n27du0q/Z2Tk4OEhAR7dq1e/fnnn7KytefdokULBAYGVnkcIiIiIiIiIiJqmtRqNfSaELzy+hvILDQhNsmAYkPF2dt6E5CjMyPYUwGlYMascQ9Br9dXmy6XHIfBbRdy/vx5WTk6OtrqfTt16iQrX7hwwS59cgTLvtpy3uUX2szNzZXlKyciIiIiIiIioqZJoVBg5ZqvcTmjEGmFJuiMInZdkM/eHvTv7O3UwtLZ24EaBQLcdPhs5QqmJnESDG67EMsgb7Nmzaze17JufQa3d+7ciXHjxmHAgAHo2rUrevfujTvuuAPTpk3DF198gWvXrtl0vPJ9dXd3l83Grkl4eHiVxyIiIiIiIiIioqbHzc0NarUay5cvR2KuCQYzkF0s4rdKZm8/2kWDEhOQrTMjxEsBlQL48avlUKvVcHNza8CzIIDBbZeSlpYmK5fPo10Ty7qpqal26VNlfvnlF/z6669ITk5GcXExcnJycOnSJezevRtvvvkmBg0ahFdffRWFhYVWHa/8eYeGhtqU08gyJ3l9njcRERERERERETk/pVKJjIwMJCQkoMgAZBSaca3IhBKTiB3ndbK6A1u5o7mPAmmFZrgJQJBWgZLMRGSmp3H2thPg7QUXYhkM9vT0tHpfy7pFRUV26VNtlJSU4Ntvv8Vvv/2G5cuXo2XLllXW1el0ssUvbTlnAPDy8pKVa3vezrpIQPl+OWsfyblxDFFdcPxQXXD8UF1w/FBdcPyQrawZJ4IgcDyRVfgZ5BwEQUBBQYFUvpJnRpCnArk6EbFXDLijrQe0qtLXpyz39juHCpH1b+7tzCIzitMuQNu2q0NfR46fihjcdiHFxcWyslqttnpfy7r1EdyOiorC4MGD0aNHD7Rr1w5+fn4QRREZGRk4duwYNm3ahAMHDkj1L1y4gPHjx2PdunXw9/ev9JiW/bTlnAFUSO5f2/P28/Or1X6O5Ovr29BdIBfHMUR1wfFDdcHxQ3XB8UN1wfFDVvHxsaKKD+AC3xvJufAzqGGVnxCZXyIiTyciXWWGr4cSPyXocF+0Rnp8YCt3fHW8GGkFZgR4KBCkVcDLnA8PlRIajV8D9J7jpwzTkrgQnU7+swhbVmW1rGt5rLrw8/PDd999h82bN2P69Ono27cvQkNDoVar4eHhgebNm+Ouu+7CypUrsWLFCtmbLzExEQsXLqzy2Hq9PJG/rSvR1ud5ExERERERERGRawoKCkL79u2l8pU8EwoNIgoNIg5fqZh7++HrNTCYgcxiMzq1DoO31gPITmyIrlM5nLldCwMHDsTVq1fr7fhz587F2LFjK2y3nLVsMBisDvaWlJRUe6y68PLyQrdu3ayq279/f8TExODxxx+H0WgEAGzbtg0TJ05Ehw4dKtSv7JxtYa/zzsnJqdV+9U0QBOlmQW5uLkRRrGEPIjmOIaoLjh+qC44fqguOH6oLjh+ylSIvDzXN3c7Ly4PZSb83knPhZ5Dz0Gg0mDRpEmbPng0AyCwWUWQQkV5oRis/JbZZzN4e3KZ09nZqgRlj+94CY3YS9MXFMJs9ALW3Q/rcGMaPvbMjMLjtQrRarays0+msDm5bzoC2PJYj9ezZE/feey/WrVsHABBFEdu3b680uF3ZOdvCMrhd2/N2hQ8LURRdop/kvDiGqC44fqguOH6oLjh+qC44fsga1owRjiWqDY6bhmU2mzF+/HgsWLBAyr+dlGeGViVAbxTx6+US3N3BAx5upbmt3RQCHrzeAyuOi+gzZDjEwmuAQgsh6xLMoZ0AB+fA5vgpxbQkLsQyMGtL/mjLxSgbMrgNAPfdd5+sHBsbW2k9Dw8P2cqztubMLr84ANDw501ERERERERERA1Pr9dDrVZj3bp1UuwprcCMEhOQXiRCKQjYfk4+WXRoWzXeeGEWVD4hMAhuEApSIZQUQii41hCnQODM7VpZvHhxhZnQ9hQZGVnp9tDQUFk5JSUFYWFhVh0zNTVVVrZ2v/py/fXXQ6VSSWlGkpOTq6wbEhKClJQUAEBaWhpEUbR6Rdi0tDRZuaHPm4iIiIiIiIiIGp4oitDpdLj99tuxefNmPPDAAygoKEByvglqJRDmpcC+i3rc1V4Nd2VpHEqlFNBFcRF6w80QvUKhyE6EqMuBkJcEURsAKFUNfFZND4PbtdC5c+cGabdNmzayckpKitW5rsuCw1Udy9EUCgX8/PyQnp4OAMjOzq6ybps2baT+6/V6ZGZmIigoyKp2LIPmDX3eRERERERERETkHEwmE4qKijB48GAkJydj1apVWLk8BsbiRGQUmRHsqcCvKSoMam6U9hHP/gxzuzsBjR9ED18IhemA2gdCbhLEgNYNeDZNE9OSuJC2bdvKyidPnrR63xMnTlR7rIZQPn92dQs9WgakbTnvU6dOSX/7+PggODjYhh4SEREREREREZErc3Nzg1qthoeHB9RqNdzc5HN9ywLcSqUSkydPxskzCdiy9zcsXvkV3nrjTQye9CpExX8pcwWzAaozPwEARK8QCABQeA2KwnRAL0+PS/WPwW0X0r17dygU/71k8fHxVu/7119/SX/7+fmhXbt29uyazbKzs5Gfny+VAwMDq6zbs2dPWdna805MTERmZmaVxyEiIiIiIiIiosZHEAR4eHhAq9XC29sbRUVFSEtLQ1FREby9vaHRaODh4SGlvRVFEXq9HsXFxcjPz4c6pDX8AoKg8glCiU4PU6t+suMrL+wDdHmAwg1mbRCE4hzAUAxFTiLARR4disFtFxIYGIgbbrhBKsfHx1fIKV2Z+Ph4Wc7t/v37V7hL5WgHDhyQla+77roq695yyy1Qqf7LWbRjxw6r2rCsN2jQIBt6SERERERERERErkapVEKr1cJoNOKTTz5Bhw4dEBwcjNatWyM4OBgdOnRATEwMjEYjtFqttJhkGaPRCL0J0Lt5waDyhclQAmOrWyEK5WZvm0rgdnZ7aUHjD7ip/1tcsjDdkafb5DG47WKGDh0q/W0ymbBu3boa91m7dm2Vx2gIBoMBK1eulG275ZZbqqzv5eWFfv3+u0N24cIF/PbbbzW2sWHDBqns7u6OgQMH1rLHRERERERERETk7MoC23v27EF4eDhmz56NhIQEWZ2EhATMnj0b4eHh2LNnT6UBbgAQvcIAN3fA3QtQKGBqebPscbdzPwP6fEAQIHqFQjDoAF0OhNwkwGyscDyqHwxuu5jRo0fLUnisWrUKFy9erLL+kSNHsHnzZqkcHR2NAQMGVNvGkiVLEBUVJf1bsmRJlXXT0tKQk5Njdf/NZjPmz58v+2AJDg7GXXfdVe1+kydPlpVff/11lJSUVFn/008/xeXLl6Xygw8+iICAAKv7SURERERERERErqMsFcmuXbswfPhwFBRUn/+6oKAAw4cPx+7du2UpSiRqL4junhA1fhAMOhjbDYGI/+oIJj3czu0uLbh7QvTwgVCQDsGoh5CXYu/ToyowuO1itFotpkyZIpX1ej2efPJJ2cKJZQ4dOoQpU6ZALJfrZ+bMmRXfrHXw999/Y+DAgXjnnXdqXOjx1KlTeOKJJ7Bx40bZ9lmzZkGr1Va7b5cuXXDHHXdI5XPnzmHcuHHIysqS1TObzVi9ejWWLl0qbfP29sbEiROtPSUiIiIiIiIiInIxarUaer0eDzzwAEwmk1X7mEwmjB49Gnq9Hu7u7hUeFz2DAXcviAoV4OYOU4ubZI+7JewGDMVSXUE0AcVZEApSAaO+7idFNWrYxMtUK48++iji4uKwbds2AEBKSgpGjhyJvn37IioqCkajEcePH6+w8OKkSZNw66232r0/hYWFWL16NVavXo3g4GBER0cjMjIS3t7eEEURmZmZOHbsGM6ePVth37Fjx2LUqFFWtbNw4UKcPXtWmqn++++/Y+DAgRg4cCAiIyORnZ2N2NhY2YxtpVKJDz/8EEFBQfY5WSIiIiIiIiIicjoKhQIrV66scca2pYKCAqxatUo2mbSMqA2EmHsF0PhCUZQFY9SdcLt8WHpcMBTB7fxeGK+7C1C6Q9T4QyjKAjR+EHKTIAa2rfN5UfUY3HZRb731Fkwmk7RooiiKOHjwIA4ePFihriAIGDNmDJ555pl671d6ejr2799fYz0PDw/MmzcPDz30kNXH9vHxwcqVKzFt2jScPn0aAFBcXCwF+S1ptVq8+uqrsnzdRERERERERETUuLi5uUGtVmP58uW12n/58uWYOXMmSkpKYDSWy5etUELUBkIw6iAWZkBUe8EU0QPKq0f/a/vsThjbDykNbmuDoNDlQizIgEKhgskrFFB71fX0qBpMS+Ki1Go1Fi9ejHfeeQcdOnSosl7Xrl2xYsUKvPDCC3ZNR1ImKioKDz/8MNq1aweFoubhFBwcjAkTJmDnzp02BbbLREZGYv369ZgyZQqCg4MrraNSqTBkyBBs3LgRw4cPt7kNIiIiIiIiIiJyHUqlEhkZGRUWj7TW2bNnkZmZWcXCkiGAQgWovSEU58Bw3d2yxwV9LpQXfy0tKJQwewZB0OUAhmIoci9XOB7ZlyCWT8hMLuvMmTNISEhAWloalEolQkJC0KlTJ7Rs2dJhfSgqKsK5c+eQlJSEjIwMFBUVQRAEeHt7IyAgAJ06dUJkZKTd2jOZTIiLi8OVK1eQkZEBT09PhIWFoXv37vD397dbOwCQnZ1t1+PZiyAI8PPzAwDk5OSAb2eyFccQ1QXHD9UFxw/VBccP1QXHD9lKceoUfPv2rbZO7qFDMHfs6KAekSvjZ1D98PDwQFpaGlq3bl3rY1y6dAkhISHQ6XQVHlNcOwkhPxWKnCsw+7eEe+xSKNNOSI+btUHQ3/kOoHADRBFC9gVAoYLo1wKmwHaANqDW/SqvMYwfe8fsmJakkYiKikJUVFSD9kGr1aJLly7o0qWLQ9pTKpXo1asXevXq5ZD2iIiIiIiIiIjI+YiiCC+vuqX/8PLyqjJYLHqGQNAXQFS6QyjOgbHjcFlwW1GUAeXl32BqdQsgCBA9Q6DITYKoz4ci9wrMGj9AYAKN+sBnlYiIiIiIiIiIiFyWyWRCUFAQ2rdvX6v9O3TogMDAQJhMpkofF7UBEBVuEDV+EPR5MAe0LZ2RXY7b6a2AaC4tqL0humshFKZDMOggFFyrVb+oZgxuExERERERERERkcsyGo3Q6/WYNGlSrfafNGkS9Hq9fDHJ8gQFRM8gwMMXIgBBnwdjx//JqijyU6Aot9Ck6BkCwagHdDkQ8q4CJkOt+kbVY3CbiIiIiIiIiIiIXJrZbMb48eNtTk/i5eWFcePGVTlru4zoGQIo3CCqfYDiHJhDu8Ds20JWR3VqC1CW2kSlgejhC6EwA4KxBEJ+qk39IuswuE1EREREREREREQuTa/XQ61WY926dVAqlVbto1Qq8f3330OtVqOkpKT6yioPiB4+gMYfgqkEMBbB2PFuWRVFTiIUaX9LZdEzGIJoAoqzIBSkAaYa2iCbMbhNRERERERERERELk0UReh0Otx+++3YvHlzjTO4vby8sGXLFgwZMgQ6na7KxSTLM3uFls7IdvOAUJwDU/NepdvKcTu15b+CUgXRww9CcRYEk4Gzt+sBg9tERERERERERETk8kwmE4qKijB48GAkJydj0aJFFRaZ7NChAxYtWoTk5GQMGjQIRUVFNaYkkXj4QVSqSheWLCkAzCYYr5PP3lZmnIUiI0Eqi55BEESRs7frCYPbRERERERERERE1CiUBbiVSiUmT56Ms2fPIiMjA5cuXUJGRgbOnDmDKVOmQKlU2hbYBgBBKM29rfaBKAgQirNhankzzJoAWTX3hO1QqVSl6VEUbhA1/v/O3jZCyEux8xk3bQxuExERERERERERUaMhiiL0ej2Ki4uRn58PjUaDkJAQaDQa5Ofno6ioCHq93qpUJBWO7RUMUelWmm5ElwMICqDjXbI6QtJRlKSfh0argbvaHSrfZhCA0tnbhdcAI2dv2wuD20RERERERERERNQoGY1G6PV66HQ66PV6GI3Guh1Q6Q5RG1i6sCREeIg6GFv3RwncZdV+XT4Xjz36GH7c9CNMEODuGwalLvvf3NvJdesDSRjcJiIiIiIiIiIiIrKS6BUKhcoD7t6BOB13GPc+9Ai+P54rqzOotTv02cmIWRaDe++7F3FnEuHu7l4a4C64Bhj1DdT7xoXBbSIiIiIiIiIiIqJquLm5Qa1Ww8PDA2rvAKh9gxF/JhGfrVgGN5MOP5zWQWf8L82Jm0LAvR09AADFxcV4/qX5+Pt8MlTGAghmI4Q8zt62Bwa3iYiIiIiIiIiIiCwIggAPDw9otVp4e3ujqKgIaWlpEEUROnd/zH/jHRSWmBCkVSBXL2LHOfls7Lvaq+HtLgAAzGYTXn77IxiNJqhK8iAUpgMGXUOcVqPC4DYRERERERERERFROUqlElqtFkajEZ988gk6dOiA4OBgtG3bFhkZGVj59QZk5xcjo0iEj1qAhxuw4ZQOJvN/s7c1KgHDo9RSuaCoGHt/+wsKXQ4Eszz3tmxmuFoNNzc3h56vq2Jwm4iIiIiIiIiIiOhfZYHtPXv2IDw8HLNnz0ZCQgIA4Pbbb0fLli2x/NNPcTXPhGydGQYzEKhRILXAjF8SS2THGnmdB9TK/8rfb/sZbioVlMU5UBRlwkOJCjPDi4qK4O3tDY1GAw8PDwiC4MjTdykMbhMRERERERERERHhv1Qku3btwvDhw1FQUCB7/LrrrkNKSgoSEhKQWmCGyQxkFpkRoFFAKQDrTshTjfh5KHBH2/9mbydeSUKBWQ2lIQ8ebgqYsi7JZoa3bt0awcHB6NChA2JiYmA0GqHVaqFUKkEVMbhNREREREREREREBECtVkOv1+OBBx6AyWSq8LiXlxfy8/MBACYRSC0wI6PIDKB09vaFbBOOXJXP3r6/kwcU5SZfFwkaKN1U+Of3X3Dfnbfh5Xn/zQwvk5CQgNmzZyM8PBx79uxhgLsKDG4TERERERERERERAVAoFFi5cmWFGdtlCgoK4O3tLZWv5ptgEoGcYhGB2tJQq+Xs7WZeStzW0l0qa7SeSMktwZrlH8GoL0Yr36qD1gUFBRg+fDh2794NtVpdZb2misFtIiIiIiIiIiIiavLKFnVcvnx5lXVOnz6NZs2aoX379gAAnbE0LUl6kQnuSsDPQ8CxNCNOpRtl+90f7QEAiGweCR9fH6z85v9gMJkR5qlEkKcCnqqq82qbTCaMHj0aer3eDmfZuDC4TURERERERERERE2eUqlERkZGhRQh5e3atQuJiYmYNGmStC0pzwydCSjQiwj6d/b2dyeKZfu1D3RDtzA3DB8+HPl5+Th46DCuFZrgrxHgrgRa+VUfpi0oKMCqVatQUlJSbb2mhsFtIiIiIiIiIiIiavIEQagyHUkZs9mM5cuX48knn4SXlxcAIFcvorBERHqRGZ4qAR5uQGySAUl58pzdD3b2xF1334Wftv8Es2hGZpEIgxkI81QiUKuAl3vVs7cBYPny5XB3d6+2TlPD4DYRERERERERERE1eaIoSgHr6qxatQomkwnffvuttMhjSoEZeSUiSkylC0uaRWDDSXnu7R5hSqjyU7B27drS9gBcKzTBz0OAWgm09qt+wcizZ88iMzOzdifXSDG4TURERERERERERE2eyWRCUFCQlE+7KhkZGfjf//6HwYMH44cffoCXlxfSCswwmYGsYjP8NQooBGD3BT1ydGbZvoZjG5GbmyuVs4pFGMwiwryU8NcI8FFXP3u7sLCw9ifYCDG4TURERERERERERE2e0WiEXq+X5dOuym+//YaBAwfipptuwuXLl/HeB4ugCYpEVrEZCgD+HgJCmkUixaeLbD9V0hEEav4LYIsA0grN8PMQ4KEU0Mq3+tnbnp6etTm1RsutoTtARERERERERERE5AzMZjPGjx+PBQsW1Jh/+7fffkPHjh0xduxYTJ48Gc9MmYDcUwdQcu08PNwEeLXuCkNeJsQfpkIwGQAAgmjCmF7B+PDANek4WcUiQjxFhHkpoDOJ8FULyNWLFdrr0KEDAgMD7XvCLo4zt4mIiIiIiIiIiIgA6PV6qNVqrFu3TsqnXZ2MjAy8//77OHnyJIwKd6h9g+AT2hLuChHFOZnQC2qYWt4i22dISwEaiynHqQVm+HoI0LgJaO5Tech20qRJKCkpqfW5NUYMbhMRERERERERERGhdFFJnU6H22+/HZs3b65xgUkvLy9s2bIFQ4YMQXFxMfQqX5QI7jCIAsyFpYs/GjsMhYj/UpG4w4B7ouXHzdGJEEVAqxLgrqyYd9vLywvjxo2Du7u7Hc6y8WBwm4iIiIiIiIiIiOhfJpMJRUVFGDx4MJKTk7Fo0aIKi0x26NABixYtQnJyMgYNGoSioiKYTCaI2kCICjeIGn8I+jzAbIToHQZzeDfZ/o/1DILKipnhAKBUKvH9999DrVbb7RwbCwa3iYiIiIiIiIiIiMopC3ArlUpMnjwZZ8+eRUZGBi5duoSMjAycOXMGU6ZMgVKplALbAABBAdEzCPDwhQhA0OUCAIxRw2THVxvy8Mmzj0Cj0VTbj/Izw/V6fX2cqktjcJuIiIiIiIiIiIjIgiiK0Ov1KC4uRn5+PjQaDUJCQqDRaJCfn4+ioiLo9XqIonzxR9EzBFC4QVR7A8U5gCjCHNQepsB2snqti//B/63fgKlTpqJ5RHPZY1XNDCc5t5qrEBERERERERERETVdRqMRRqPRusoqD4gePhAMRRB0iRANhYC7F4wd7oQydolUTci6BGX6aQy/Zzjuu/8+FJw7gmI3X7iHtoN/9K3Q6/XSDHJRFCEIFXNxN3WcuU1ERC5pxIgR6NOnD/r06YPk5OSG7g4RERERERGRxOwZAqi0EN08IBTnlG6L6A6zV6i84qltKNGXoLioGCqVO3x9faFWq6udGU7/4cxtIqIqTJ48GfHx8VU+rtVq4ePjg/bt26NXr14YNmxYjasoExEREREREVEToPGHqFQBGj8oCtIgmgyAUgVj+9vhHv+VVE2Z8heE/BSYvJtBNBlhNhggGgwwWztLvIljcJvISSnSTgCmkmrrCIIAc553af2C/MZ/J0/pDnNop4buhaSoqAhFRUVITU3Fr7/+ik8//RSzZ8/GsGHDat7ZCSQnJ2PUqFEAgIiICGzcuLGBe0RERERERETUSAgCRM8QCAYdxIJrEHS5ED2DYGrVD+I/GyEYCqWqbgm7YOj+eAN21nUxuE3krEwlpT9bMRRVWUUAIBo9S/8uLKyyXqOg0kLU+DVY89HR0YiOjpbKoigiPz8fp06dwpUrVwAAhYWFeO2111BSUoIRI0Y0UE+JiIiIiIiIyBmInkFA3lWIai8I+lzAMwhwU8PY5jaozmyT6ikvHYSh070N2FPXxeA2kTMzFEFRlAkoqnmrKkpndwu6YjTaZQXMRpi1ABowuH3TTTdh/PjxlT72yy+/YOHChSgoKAAALFq0CDfffDNCQkIc2cUmZ9OmTQ3dBSIiIiIiIqKquakhqr0hqH0h6PIgGooBlQbGdoPhdnYHBNEEABBMJXC7sA/moPYN3GHXw+A2kbNTuMEc2K7yxwRA+DfHs7mgAGikWUkUmecaugvVuu2226BSqTB79mwAQElJCf7v//4PkydPbuCeEREREREREVFDErWBpYFthRsEfR5ElQbQBsAUeSPcLsdK9dzO7UFJQJsG7KlrUjR0B4iIGoO+ffuiffv/7rD+8ccfDdgbIiIiIiIiInIGojYAokJROoNblwf8u16ascMdsnqCLgeKa6caoosujTO3iYjspHPnzkhISAAAXL16tcp6v/32G/bs2YNjx44hMzMTJpMJ/v7+iIqKQr9+/TB06FC4udX88Ww0GrF792788ssvSEhIQHZ2NkpKSqBWqxEQEICIiAh06tQJffv2RadO/y3EuXXrVixcuFB2rKtXr6J3795V9rcqFy9exI4dO/DHH38gJSUF+fn58PLyQnh4OPr06YORI0ciODi42vOYPHky4uPjAQCffPIJevTogYyMDGzduhUHDhxAamoqcnJyoNVqsWfPHmm/ESNGIDU1FQCwceNGhIeHV9tOSkoKtmzZgt9//x3JycnIz8+Ht7e31Nfhw4cjNDS02mMcPXoUU6dOBQB069YNy5YtAwAcPnwY27dvx6lTp5CZmYni4mI888wzePDBB6s9XmUqO68rV65g06ZNiI2NRVpaGoxGIyIjIzF48GA8+OCD8PDwkB0jMTER69evR3x8PFJSUqBQKNCyZUvceeedGDlyJJRKpdX9qek1fuKJJ2p83gCgoKAAhw8fRlxcHM6ePYurV6+isLAQ7u7u8Pf3R3R0NPr374+BAwdCoaj+3nv5MTxs2DDMnz8fQGmKoC1btuDcuXPIysqCl5cX2rdvjzvvvBNDhw6FIDTa5E1EREREROSsFG6Ahy9QUgQUZwOGQsDdC6J/a5iCoqDMOCNVVSYdgbHtwAbsrOthcJuIyE68vb2lvwsrWeAzKysL8+fPx59//lnhsdTUVKSmpmL//v344osv8Nprr6Fjx45VtnX58mXMnTsXly5dqvBYUVERioqKkJSUhN9//x2rV6/G+vXrERkZWbsTq0RJSQk+/PBDbN68GSaTSfZYTk4OcnJycPLkSXzzzTeYNm0a7r//fquPfeDAASxcuBB5eXl26+/nn3+ONWvWQK/Xy7ZnZ2cjOzsbJ06cwNdff42xY8dizJgxVh+3oKAAr7/+Ovbv32+3vlravn073nnnHeh0Otn2c+fO4dy5c9i7dy+WLl0KHx8fAMDq1auxatUqmM1mWf0TJ07gxIkT2Lt3LxYtWlQhIG7J2tf422+/xbPPPou77767ymPt27cPCxYsQElJSYXHjEYjioqKcPXqVezevRvt27fHO++8U+PNivIKCgrw6quv4tdff5Vtz87OxpEjR3DkyBHs3LkTb7/9do3nTUREREREZG9mbRCUxTkQle6lKUrcS1PMGjvcIQtuKwrSoMg8B5Of/b6/N3YMbhMR2Ul+fr70t9e/udDLZGZmYuLEiUhKSpK2NW/eHNHR0XB3d8fFixdx4sQJAMCVK1cwdepUfPjhh7jhhhsqtFNYWIinn34aaWlpAACFQoEOHTqgVatW0Gg00Ov1uHbtGs6dO4ecnJwK+7dq1Qr33XcfioqK8NNPPwEAPD09ceedd1p1nsXFxZgxYwaOHz8uO5eoqCj4+PggLy8Px48fR3p6OvR6PT744AMUFhbiiSeeqPHYf//9N1atWgWj0QhfX1907doVfn5+yM7OxtmzZ63qn6X3338fGzZskMparRbdu3dHYGAgMjMzERcXh6KiIuj1esTExCArKwvPPPOMVcdesGABDh06BEEQ0LFjR7Rq1QoAcP78ebvMEo6NjcUHH3wAs9mMyMhIabycP38eJ0+eBACcPXsWL7/8MhYvXowvvvgCK1asAAC0a9cO7du3h1KpxMmTJ3HhwgUAQFxcHBYvXoznnnuuynZteY11Oh1ef/11ZGRk4PHHH6/0eGW/KgCAkJAQtG7dGoGBgVCr1SguLsalS5dw5swZiKKIhIQETJo0CV999RV8fX1rfI5MJhPmzZuHP//8EyqVCp07d0ZERARKSkpw7NgxaRb8b7/9VuN5ExERERER1QuNH0SFEvDwgaIoC6JoBgQFzOHdYPYMgaLwmlTV7eJ+mNoOaMDOuhYGt4mI7KR8INBy1unChQulwLZGo8ELL7yAIUOGyOqcOnUKL730Eq5evYqioiLMnz8fX3/9tWxGOFCakqEssN26dWu8/fbbaNmyZYX+iKKIU6dOYevWrXB3d5e2X3/99bj++uuRnJwsBbf9/Pzw7LPPQhRrXpX0vffek861RYsWeO6559CjRw9ZHZPJhE2bNmHx4sUoKSnBypUr0aNHD3Tu3LnaY69cuRJmsxkTJkzAmDFjZOlZKpv1W5M9e/bIAtt33XUXZs2aBU9PT2lbYWEh3nvvPezYsQMA8N133+GGG27AgAHVX0wcP34cJpMJbdu2xauvvop27eQLv9amv5YWL14MDw8PvPTSSxg4UP7TtN27d+OVV16ByWTC77//ju+++w4rVqxAcHAwXn31VXTv3l1W/9tvv8XHH38MAPjxxx/x2GOPVTk72trX+Mcff8RHH32EkpISrFixAt27d6/0NQ4ODsaUKVMwYMCAKn9BkJycjHfffRe//fYbrl27hqVLl+LFF1+s8Tnat28fSkpKcNNNN+H5559HSEiI9JjRaMSyZcvwzTffAAA2bdpU7XkTERERERHVC0EBURMAwVAMFGYA+gLAwwcQFDB2uB3u8V9LVRVpJyDkpQChnao5IJXhgpJERHZw6NAhnDt3Tir37NlT+vvo0aOIjf1vBeSFCxdWCGwDQMeOHbFkyRJp1ndaWhq+//77CvX++usv6e+ZM2dWGtgGAEEQEB0djblz51qVE9kaf/31lxQQb968OVasWFEh6AkASqUS9957L+bOnQugNBD62Wef1Xh8k8mECRMm4KmnnqqQd7x8gN4aZrMZMTExUnnQoEF46aWXZIFtoHTW+oIFC3DrrbdK2z755JMKaT0q62tgYCA++eSTCoHt2vS3MgaDAW+//XaFwDYADBkyBHfddZdU/uijj+Dm5oaPP/64QmAbAB5++GH06tULQOlz8/PPP1fapq2v8auvvgqg+te4X79+GDNmTLWpccLDw/H+++9Lz+WuXbusSk1TUlKCrl274r333pMFtgHAzc0N06ZNQ3R0NIDSGz7l87YTERERERE5iqgNBJTuEFUaCPpcabupVT+IKq1UFiDC7cy2huiiS2Jwm8hZmc2ld/L0hYAur4p/+RCLcyEW5wK6/Grqufg/fWHp8+Gk9u/fj1deeUUqu7u7495775XKP/zwg/R3v3790Ldv3yqPFR4eLkvt8MMPP1SYTV0+n7e/v39dum6ztWvXSn9Pnz4dfn5+1da/++67peD777//jtzc3GrrBwcH47HHHqtzP8vaS05OBgCoVCrMmjWrylQhgiBgzpw5UkA9KSkJR44cqbGNp556qsbnoC769euHG2+8scrHb7/9dll55MiRaN26tVX1y9KaWLL1NR41ahTatGkDwLrXuDpubm64447SFcP1ej2OHTtm1X7PPPNMlYuwCoIguwlQ1XkTERERERHVK7U3RKUKotoHQkkhYDaWbnfzgLHNbbKqyuQ4x/fPRTEtCZETUp7dAfXuBVDoa561WBby1dRvlxqcWeUJw43jYA7v1iDtx8bGVgja5efn4+TJk7hy5Yps+/Tp02UzpY8ePSr9/b///a/Gtu6++24sW7YMZrMZGRkZSExMlHI5A5Ade+PGjQ7LIWw0GqWAr6enZ7VB+vJ69OiBxMREiKKIY8eOyWZIWxowYECVQUpblV+48+abb0ZgYGC19UNCQtCnTx8cPHgQQOnr1qdPn2r3GTx4cN07Wo2aUqO0bdvWpvplQWgAUuC/vNq+xr1798aFCxeseo3z8/Pxzz//4MKFC8jLy0NRUZHsBk75RVITEhLQr1+/atuOiIjAddddV22dqKgo6e+UlJQazoaIiIiIiKgeCAJEbRAEQzHEgjRAnwdoAgAAxnZD4JawG4LZUFq33Exuqh6D20ROyGP3fAj6/JorNiEKQyHcj6yEofekBmn/5MmTNc741Gq1mDVrFu6++25p27Vr15CdnS2Va8o5DZTOxo6MjERiYiIA4MyZM7Lg9qBBg7BlyxYApTO7z5w5g2HDhqF3797Vpn2oq3PnzqG4uBhA6QzbDz/80Kr9Tp06Jf197dq1amqixiClLcovQGnN8w4AXbp0kYLbZ86cqbZueHi4VQse1oVl8NqSZT728sHryvj4+Eh/l/8FQJnavMZqtRp///23VK7qNb527Ro++eQTKUe2NSpbENVSTc8RUPN5ExEREREROYLoGQjkpwDuXhB0eRD/DW5DG4CSm6ZC9de3gEqDkgaKfbgiBreJiGpJq9XCx8cH7dq1Q69evTBs2LAKwcbywTm1Wm11GpFmzZpJwW3LAF+fPn1w//33Y/369QDkgfeAgADccMMN6N69O/r3718hB3FdZGRkSH/n5ubKFmq0Vk05lO2Z4qP88xYWFmbVPs2aNat0/8rUZzqSMmX516tiOcu9pvpKpVL622g0Vni8vl7jM2fO4Omnn7Yqh3Z5RUVFNdap6ZwB+fNU2XkTERERERE5hEpbml/bwweKvGSIphJAWbpekzm8GwwqDcxeoRB9mzdwR10Hg9tETkg35DWr05I0FWVpSRrK2LFjMX78eJv3Kx+c02isTx5Tvm5lAb7Zs2ejR48e+PLLL2UzyrOysrBv3z7s27cPixYtwm233YYZM2ZYHdytTkFBQZ2PYTKZqn1crVbXuY0yZTOQAeuf+5qe9/Ls2Vd7qSqnuLXq4zUuKSnB888/LwW2/f39MWLECPTs2RORkZHw8fGBWq2W+r5161YsXLgQAGpc1JOIiIiIiMjViNoACCUFEAUFBF0uRM/ghu6SS2Nwm8gJmToMhU4bDCHzHBS6PJgDqlggThDg6Vmah6mwsAiwWHiwsVBkXYTZOwyin+vdudRq/8uTVT7YWpPydcsfo7zbbrsNt912G1JTUxEXF4e///4bf/31Fy5evAgAEEUR+/btQ1xcHFauXIkWLVrU8ixKlQ/8tmvXDl9//XWdjlffyvfX2ufemue9MbP1NRYEQZrBnpOTU2HxUwDYt2+flN87ODgYn3/+OYKCgqo8pjWztYmIiIiIiFyVqA0CcpMgqr0h6PMABrfrhMFtImelUABqL0A0AR4+ldcRAEHz70/yTUqgcca2AbVn6fPhgsqnrtDr9cjJybEqnUX5Re9qqh8WFoZhw4Zh2LBhAIC0tDRs3boVX331FXQ6HXJzc7F48WJ88MEHtTkFSUBAgPR3ZmZmnY7lCOWft7S0NKv2seV5b4zq4zUuv7Dngw8+WG1gGwBSU1Pt0i4REREREZFTcnMvDWx7+EDIyYVoKAZU1v/Sm+RcM1pEROQiQkJCZHm2jx8/XuM+OTk5uHLlilSOioqyqc3Q0FCMHTsW8+bNk7b9/vvvFRbxszWFRfv27eHuXpoLLDs7W9ZHZ9ShQwfpb2uedwCyhRFtfd4bg/p4jdPT06W/rVn88a+//qpzm0RERERERM5M1AYCKk+ICrfS2dtUawxuNxJnz57Ftm3bsHr1aqxZswY7duzA5cuXG7pbRASgR48e0t/btm2rsf62bdukXMPBwcFo2bJlrdrt16+f9LfRaKywmF9ZEBMADAZDjcfz8PCQncv//d//1apfjtKzZ0/p79jYWGRlZVVbPz09HbGxsZXu31TUx2usKPerC51OV23d06dPy3LIExERERERNUaixh+iIPybmiS/0aaZdQSmJXFxmzdvxqpVq3DmzJlKH+/WrRumTp0qC3LZm71mN3755Zfo3bt3pY/9/vvvGDNmTK2O2717d6xdu7YuXSOqk5EjR2LPnj0AgP379+O3335Dnz59Kq2bkpKCNWvWSOURI0ZUmGFtbWqTa9euSX8rFAr4+vrKHvf29oZCoYDZbEZ2djaMRiOUSmW1x3zsscekAPD69etx880348Ybb6yxL0BpmovAwECr6tpD7969ER4ejuTkZJSUlOCjjz7Ca6+9VmldURTxwQcfwGg0AgCaN2+OXr16OayvzsTer3F4eLj096+//orbbrut0n11Oh3eeuut2nWaiIiIiIjIlShVgIcfYCgCirMBYzGganrrPtkDZ267KL1ej1mzZuHZZ5+tMrANAPHx8Rg/fjzeeeedShf6ciZNcfE2ahp69OiBm266SSq/8MIL+PnnnyvUO336NJ5++mnk5+cDKE0vMnr06Ar1xo0bh/nz5+Pw4cNVzri+fPmyLJDbs2dPqFQqWR13d3dERkYCKJ25vX///hrPpXv37lJub5PJhNmzZ+OLL76ochFAvV6P/fv349lnn8Wzzz5b4/HtSaFQYMqUKVJ5165dePPNNyv0tbCwEK+//jp++eUXadvUqVNlM46bktq8xnv27MGcOXMqfY3L31z96aef8M0338BkMsnqXLlyBdOnT8eZM2dki1oSERERERE1VqI2AFBpS1OT6JiapLY4c9tFvfjii7L0BoIgoG/fvoiKioLBYMDff/+N+Ph4AKUzElevXg2NRoPp06fbvS81zfSsjCiKUtoFAIiIiMD1119v9f4KhcLqfMFubhzm1PBeeuklTJw4EUlJSSgqKsKLL76I5cuXo1OnTlCpVLh48SJOnDgh3YTSaDR47bXX4O3tXeFYRqMRu3btwq5du6BWq9GuXTtERETA09MTeXl5SE5OxqlTp6T6arUaTz/9dKX9GjBggDRTfP78+di6dSuaN28ue99Yfm7MmzcPmZmZ+P3332EwGLBs2TJ8/vnn6NSpE0JDQ+Hu7o78/HxcvXoVFy5ckHJ9X3fddXV6Dmtj8ODB+Ouvv7BhwwYApb922bNnD3r06IGAgABkZ2fjzz//lAVuH3zwQQwYMMDhfXUm9nyNe/fujW7duiE+Ph6iKGLJkiX4v//7P0RFRcHLywtXrlzB33//DZPJhODgYDzwwANYunSpo0+ZiIiIiIjIoUSNH0RBADx8oNDlQfQKbeguuSRG/VzQt99+iy1btkjlZs2aYdmyZejYsaOs3qFDhzBjxgxpFmhMTAy6d++OW265xa79qU1+1IULF+Krr76SypWlXqjOmjVrqkxhQuSMAgMD8emnn2LBggX4888/AZTOVq1swb7mzZvjtddeQ3R0dKXH8vT0lP7W6/U4ceIETpw4UWnd8PBwvPLKK2jfvn2ljz/22GM4cOAALly4AKPRiMOHD1eoYxncdnd3x6JFi/DZZ5/h22+/hU6ng06nw9GjRys/eZTeZLLlBpY9zZkzBwEBAVizZg1KSkpQVFSEX3/9tUI9tVqNp556Co8//ngD9NK52Ps1XrhwIWbNmiX90ig5ORnJycmyOq1bt8abb75Z5VgmIiIiIiJqVBRupalJSoqAoqzSFCVkMwa3XUxxcTE++eQTqaxWq/H555+jdevWFer27dsXMTExGDNmDERRhCiKWLRokd2D27YyGAzYunWrVBYEASNHjmzAHjk5sxGKzHNVPiwWlf6EX1FU7KgeOZ7Z2NA9sIvAwEAsXboUsbGx2LNnD44dO4asrCwYjUb4+/ujQ4cO6N+/P4YOHVrtLw6+/PJL/PPPPzh69ChOnjyJy5cvIyMjAzqdDh4eHggICECHDh3Qr18/DBo0SLZwpCUvLy9s2LAB3377LX7++WdcunQJ+fn5Uu7pqiiVSkyYMAH3338/fvrpJ/zxxx+4dOkScnJyYDQa4enpibCwMLRt2xY9evTAzTffDH9//1o/d3X11FNP4c4778TmzZvx+++/Izk5Gfn5+fD29kZ4eDj69OmD4cOHIywsrMH66GysfY2jo6PRu3dvdO3atcpc8IGBgVi5ciU2b96M3bt348KFC9DpdPD390eLFi0wePBgDB06FB4eHgxuExERERFRk2HWBkJZnA1RqYKgZ2qS2hBEZ0/ETDJffPEF3nzzTak8derUGlONzJ07Fz/++KNUXr58eYP+5H7Pnj2YOnWqVO7Vqxe+/vrravexXFCyusUn60N2drbD2iqjSI6HUJxT7Z07AYD231m8RYWFaNRvZpUWosYP5vBuDd2TRkUQBCkgmZOT4/S5+cm5cPxQXXD8UF1w/FBdcPyQrRSnTsG3b99q6+QeOgSzxa+piSrDzyCSMZtK4z8FaVAUZwOiGWavUIi+zWEO7VShemMYP/ae+MaZ2y5m+/bt0t9KpRIPPPBAjfs8/PDDsuD2jh07GjS4/cMPP8jKnLVdBaU7RI0foPGruo4gQPAqzcksuuW75IeaTZRVz0AmIiIiIiIiInIpCiVEjT8EQxFQmNHQvXFJDG67kKysLBw7dkwqd+vWDaGhNSeb79q1K8LCwpCamgoA+OWXX2AymWq1EGRdZWVlYf/+/VJZq9Vi6NChDu+HK6jsDp0lQRCg+PeOndlF79gRERERERERETVVojYAKMqE6KaGYNQ3dHdcjqKhO0DWi4uLg9lslsrdulmfnqFr167S3zk5OUhISLBn16y2detWGAwGqTxkyBDZ4nhERERERERERERNhocvRIUSotq7oXvikhjcdiHnz5+XlaOjo63et1Mn+SzgCxcu2KVPttq0aZOszJQkRERERERERETUZAkKiJoAQO3b0D1xSUxL4kIsA9LNmjWzel/Lug0R3D5z5gxOnDghlSMiItCnT59aHWvdunVYunQpEhMTkZubC61WC39/f3Ts2BG9evXCsGHD4OPjY6+uExERERERERER1QtRGwAUpkNUeTR0V1wOg9suJC0tTVYOCwuzel/LumX5tx3Jctb2PffcA0EQanWsbdu2yco6nQ5ZWVk4f/48tm7divfeew9jxozBlClToFKpattlIiIiIiIiIiKi+qX2gahwA9ScqGkrBrddSGFhoaxsS65qy7pFRUV26ZO1TCYTtmzZIpUFQajXlCQFBQWIiYlBbGwsYmJiEBAQUKfj1TYIX9/K98tZ+0jOjWOI6oLjh+qC44fqguOH6oLjh2xlzTgRBIHjiazCzyCqlCAAnoGAsRhCSQEgVD4+OH4qYnDbhRQXF8vKarXa6n0t6zo6uP3rr78iPT1dKvfo0QMtWrSw+TjdunXDwIED0bVrV7Rp0wY+Pj4wGAxIT09HXFwc1q9fj7i4OKl+fHw8pkyZgi+++MKm58uSn59frfd1FF9f5maiuuEYorrg+KG64PihuuD4obrg+CGrWJHy0sfHB3CB743kXPgZROWJHm0gohBiiQYKL28INXymcPyUYnDbheh0OlnZ3d3d6n0t61oeq7798MMPsrKts7ZbtWqFrVu3on379hUec3d3h6enJ1q1aoVRo0bhhx9+wIIFC6DX6wGUBrhjYmIwc+bM2p8AERERERERERFRfVF7AyotBABw1zZ0b1wGg9u1MHDgQFy9erXejj937lyMHTu2wnbLmccGg8HqAHdJSUm1x6pPubm52Lt3r1TWaDQYOnSoTccIDQ1FaGioVXVHjhwJd3d3zJo1S9r25Zdf4vHHH691epKcnJxa7VffBEGQ7tTl5uZCFMUG7hG5Go4hqguOH6oLjh+qC44fqguOH7KVIi8PNc3dzsvLg9lJvzeSc+FnEFVLEwEoCgE3X6CSz5TGMH7snR2BwW0XotXK79rodDqrg9tls5irOlZ92rZtmyy4fvvtt8PLy6te27zrrruwceNGHDx4EEBpGpa9e/fivvvuq9XxXOHDQhRFl+gnOS+OIaoLjh+qC44fqguOH6oLjh+yhjVjhGOJaoPjhipQqACNX+nfNYwNjp9SiobuAFnPMiBtS95sy8UoHRnc3rRpk6xcnwtJlmcZyI6NjXVIu0RERERERERERFT/OHO7FhYvXlxhJrQ9RUZGVrrdMi1HSkoKwsLCrDpmamqqrGztfnV14cIFHDt2TCpHRESgT58+Dmm7W7dusnJycrJD2iUiIiIiIiIiIqL6x+B2LXTu3LlB2m3Tpo2snJKSUiGAW5WUlJRqj1VfLBeSHD58OARBcEjblvm1s7OzHdIuERERERERERER1T+mJXEhbdu2lZVPnjxp9b4nTpyo9lj1wWw2Y/PmzbJto0aNqvd2y+h0OlnZkYtoEhERERERERERUf1icNuFdO/eHQrFfy9ZfHy81fv+9ddf0t9+fn5o166dPbtWqdjYWFk6lB49eqBFixb13m6ZK1euyMqBgYEOa5uIiIiIiIiIiIjqF4PbLiQwMBA33HCDVI6Pj0daWlqN+8XHx8uCzP3794ebW/1npNm4caOs7KiFJMvs379fVr7uuusc2j4RERERERERERHVHwa3XczQoUOlv00mE9atW1fjPmvXrq3yGPWloKAAe/bskcoajQZ33nlnvbdbJj8/H1999ZVsW79+/RzWPhEREREREREREdUvBrddzOjRo2XpNVatWoWLFy9WWf/IkSOyvNfR0dEYMGBAtW0sWbIEUVFR0r8lS5bY3M/t27fLcl4PGTIEXl5eNh8HAC5fvozi4mKr6+v1ejzzzDPIysqStl133XXo06dPrdonIiIiIiIiIiIi58PgtovRarWYMmWKVNbr9XjyySdx6tSpCnUPHTqEKVOmQBRFadvMmTMhCEK99/OHH36QleuykOTevXsxaNAgLF26tNpAPgD88ccfeOCBB3Dw4EFpm0KhwLx58xxy3kREREREREREROQY9Z94mezu0UcfRVxcHLZt2wYASElJwciRI9G3b19ERUXBaDTi+PHjFRacnDRpEm699dZ679/ly5dx9OhRqRweHl7nWdOZmZlYsmQJlixZgoiICHTs2BHNmjWDj48PjEYj0tPTERcXh0uXLlXY96WXXsJNN91Up/aJiIiIiIiIiIjIuTC47aLeeustmEwm7NixAwAgiiIOHjwom7FcRhAEjBkzBs8884xD+rZp0yZZ+Z577rHrrOmrV6/i6tWrNdbz8/PDwoULMWTIELu1TURERERERERERM6BwW0XpVarsXjxYmzatAmfffYZzp49W2m9rl27YurUqQ6ZsQ2UBtktg9sjR46s0zF79+6Ne++9F3/88QcuX75cY/3mzZtj9OjRGD16NPz9/evUNhERERERERERETknQSyfkJlc1pkzZ5CQkIC0tDQolUqEhISgU6dOaNmyZUN3za7y8/ORkJCA5ORkZGRkoLi4GEqlEj4+PggKCkLnzp0RGhpq93azs7Ptfkx7EAQBfn5+AICcnBzw7Uy24hiiuuD4obrg+KG64PihuuD4IVspTp2Cb9++1dbJPXQI5o4dHdQjcmX8DKK6aAzjx94TUTlzu5GIiopCVFRUQ3ej3nl7e6N79+7o3r17Q3eFiIiIiIiIiIiIGpCioTtARERERERERERERGQrBreJiIiIiIiIiIiIyOUwuE1ERERERERERERELofBbSIiIiIiIiIiIiJyOQxuExEREREREREREZHLYXCbiIiIiIiIiIiIiFwOg9tERERERERERERE5HIY3CYiIiIiIiIiIiIil8PgNhERERERERERERG5HAa3iYiIiIiIiIiIiMjlMLhNRERERERERERERC5HEEVRbOhOEBERERERERERERHZgjO3iYiIiIiIiIiIiMjlMLhNRERERERERERERC6HwW0iIiIiIiIiIiIicjkMbhMRERERERERERGRy2Fwm4iIiIiIiIiIiIhcDoPbRERERERERERERORyGNwmIiIiIiIiIiIiIpfD4DYRERERERERERERuRwGt4mIiIiIiIiIiIjI5bg1dAeIyLmkpaXh+PHjSEtLQ3FxMUJDQ9G6dWt07tzZbm2cPXsWCQkJSEtLg0KhQFhYGKKjo9GiRQu7tdEU8HmkumiK48dkMiE+Ph5XrlxBeno6vLy8EBYWhu7du8PPz6+hu+dSnGn8JCcnIyEhAUlJSSgoKICbmxt8fX3Rtm1bdOrUCe7u7g7vU1OQk5ODuLg4pKamoqCgACEhIWjevDm6d+8OhcLx82cKCwvx559/Ii0tDTk5OQgICEBERAR69OhhtzHgiGukpsJZxk9BQQESEhJw4cIF5OTkwGAwwMfHB2FhYejatSsCAgIc1heyjbOMIUe6fPkyTp48idTUVJjNZoSGhqJ9+/bo0KFDQ3fN5TTF8UONV0lJCY4ePYqrV68iKysLfn5+CAsLQ8+ePaHVau3ShrO/ZxjcJnKwlJQUHD9+HH///TeOHz+OEydOoKCgQHp82rRpePrppx3er+PHj2Px4sU4fPgwzGZzhcdbtmyJxx57DI8++igEQahVG5s3b8aqVatw5syZSh/v1q0bpk6din79+tXq+E2FMzyPUVFRdjnOl19+id69e1f62O+//44xY8bU6rjdu3fH2rVr69K1RssZxk9SUhIGDRpUq31DQ0Nx4MABm/YpKSnBp59+inXr1iE9Pb3C4yqVCgMGDMCcOXPQsmXLWvWrqXCG8VNcXIz9+/dj3759iI2NRVpaWpV11Wo1hg0bhqeeesqmL/8bN27E888/X6v+/e9//8P7779fq31dwaVLl/DBBx9g3759MBgMFR4PCQnBAw88gAkTJjjkxkJ6ejoWLVqEHTt2oKioqMLjfn5+GD58OGbMmAEvL69ateGIa6SmwhnGz99//41du3bh8OHDOHnyZKWvaZkuXbrg8ccfx1133WXTa1uX66QTJ07AzY1f06viDGPosccew5EjR2q17+eff46bb77Zpn0OHDiAmJgYxMfHV/p4VFQUxo8fj//973+16lNT0tDjZ968efjhhx/qfJyRI0fi7bffrvLxgQMH4urVq7U69q5du3g9XInCwkKcPHkSx48fl+I55Z/jiIgI7N2716F9KigowOLFi7F582bk5ORUeFyr1WLo0KGYPXs2goKCatVGQ79nrCWIoig2WOtETYROp8MzzzyDf/75p9LASnkNEdz+7LPPsGjRIhiNxhrr9u3bFx9++CF8fX2tPr5er8fzzz+Pbdu21VhXEAQ8+eSTmDt3Lr8gWnCm59Fewe0NGzZUOeONwW37cqbx48jgdlJSEp5++mmcPHmyxrparRYLFy7EXXfdVau+NWbOMn4uXryIUaNGVRrErI5KpcK0adMwadIkq+ozuF25zZs3Y8GCBVY9/506dcKSJUsQERFRb/05fPgwZs+ejaysrBrrtmjRAkuWLMF1111nUxv1fY3UlDjD+HnyySdx+PBhm/e76aab8O677yIkJMSq+gxu1w9nGEOA44Lboiji7bffxhdffAFrwjZ333033nrrLf5iqQrOMH7sFdx+5JFHMH/+/CofZ3Dbfj7//HNs3LgR586dq/ZmqKOD2ydPnsTTTz+NpKSkGusGBgbigw8+wE033WRTG87wnrEW/9ckcoCSkhLs27evobtRqe+//x7vvvuubFvHjh3Ro0cPaDQanD9/HgcOHJC+1B06dAgzZszAqlWrrL7wfvHFF2UBEUEQ0LdvX0RFRcFgMODvv/+WZiKIoojVq1dDo9Fg+vTpdjrLxsGZnkelUmnzPqIoyi4IIiIicP3111u9v0KhsDpQxi+FFTnT+LFUX69tfn4+JkyYgPPnz0vbNBoNBgwYgMjISOTk5CA2NhaXL18GABQVFWHu3Lnw9/e3eVZVY+cs40en01W4wFYqlYiOjkZUVBSCgoJgMpmQmJiIw4cPS7+MMhgM+PDDD5Gfn49nn33W5nZt+cyrzeejKzhw4ADmzZsHk8kkbWvVqhV69+4NPz8/XL58Gfv27YNOpwNQGqCbNGkS1q5dW+sZ09U5deoUpk6dKhsPISEhuPXWWxEUFISUlBTs27cPeXl5AEp/zj9+/Hhs2LABoaGhVrXhiGukpsJZxk9lN0LCw8PRtWtXhISEQKvVIiMjA0eOHMGlS5ekOrGxsXjiiSfwzTffwN/f36Y2BUGw6SfbnNxROWcZQ5Wx5XPfltf3o48+wpo1a2Tbunfvjs6dO0OpVOL06dOIjY2VAt9bt26FSqWqdkZvU+Us40ehUNTqOqF8vwHg9ttvt3pffgbVzR9//IGzZ882dDdkUlJSMGHCBNnESV9fXwwYMABhYWFIT0/HgQMHpMczMzMxZcoUfPfdd1bffHWW94y1eNVF1ICaNWuG0NBQ/PXXXw3S/unTp/Haa69JZXd3d7z55psVftJ25coVTJkyRfpQj42NxZIlSzBz5swa2/j222+xZcsWqdysWTMsW7YMHTt2lNUr+0KYn58PAIiJiUH37t1xyy231Pr8GhNnex6tmQVraeHChfjqq6+k8ogRI2y6eFqzZk2VKUyoes42fiy98cYbGDVqlN2P+/LLL8sC271798ZHH30ky6FqMpmwZs0avPfeexBFEUajETNmzMDOnTuZa/Vfzjp+unbtitGjR+OOO+6o9CI6Pz8fH374Ib755htp26pVq9CzZ08MGDDAprZ27dqF5s2b17nPrio9PR2zZs2SvuAIgoDnnnsOjz/+uOwLc1ZWFmbMmCHNaDx79iwWLFiADz74wK790ev1FQLbTz31FGbOnCmbsVhQUICXX34ZP/30EwDg2rVreOaZZ6z6ZY8jrpGaCmcbPwAQFBSEUaNGYdSoUWjdunWFx0VRxM6dOzF//nzk5uYCAM6fP48FCxbg448/tqmtqVOnNkjKwcbEGcdQmRtvvFF2fWsv+/fvx/Lly6Wyj48PPv744wozL0+ePInJkycjNTUVAPDDDz+ge/fuGD16tN375Kqcafy8+eabePPNN23a5+TJkxg5cqRUjoiIsOk70YgRI3jDw860Wi06deqEEydO2PxrwroSRREzZsyQBbbvvvtuvPbaa/D09JS2lZSU4IMPPpBukBUVFWHq1Kn46aefavx1hzO9Z6zV8Fm/iZqIgIAA9O/fH9OmTcPy5ctx6NAh/PLLL5g1a1aD9emjjz6S5U16/fXXK83VFhkZiS+++AKBgYHSti+++KLGFCvFxcX45JNPpLJarcbnn39eISAClP6UNyYmRgp2iqKIRYsW2XxOjVFjeB4NBgO2bt0qlQVBkF2kUf1pDOOnNv755x9s375dKrdr1w6rVq2qELBWKpUYO3Yspk2bJm3Ly8vDp59+6rC+OjNnHD/dunXD119/jXXr1uHee++tcnaIt7c35s+fjwkTJsi2N9aUIfVp+fLl0k0LAHj66afx5JNPVpgJFhAQgFWrVqFt27bStm3btuH06dN27c8333wj+7n1vffei+eee67ClzUvL68KP8ONi4vDzz//XGMb9X2N1JQ40/gJCAjAvHnzsG/fPsyePbvSwDZQep0ydOhQfP7559BoNNL2nTt34vjx43brD1nHmcaQI4iiKAsOCYKAmJiYSlMKREdHY82aNVCr1dK2JUuWQK/XO6SvrsDVx8/GjRtlZVsnCFHdqNVqdOnSBY888gjefvttbN26FUePHsXXX39t8y957GHXrl04duyYVL755pvx/vvvywLbQOlN+eeff142gejKlSv47rvvamzDFd8zDG4TOYCPjw9iY2OxYsUKPP300xgwYECtE/rby6lTp2SpUnr16oURI0ZUWT8gIEAWiC8uLsbq1aurbeP7779HRkaGVB43blyVXyKA0pkPw4cPl8onTpxw2nQujtQYnsf9+/cjOztbKvfs2RORkZEN2KOmozGMn9pYtmyZrPzyyy9XO0th4sSJaNGihVReu3atVXl8GztnGz/t27fHd999h169elm9z/Tp02Wzrs+dOyeb0U/Vy8zMxPfffy+VW7RoUeGGQXlqtRovv/yyVBZFETExMXbrj8FgwMqVK6Wyt7c3nnvuuSrrKxQKvPrqq7IvZOVv2FTGEddITYWzjZ+VK1fiySeftDoncadOnfD444/Ltu3cudNu/aGaOdsYcoSff/5ZtnDzPffcU+3/e61bt8bYsWOl8rVr17B+/fp67aOrcPXxwwlCDe/DDz/E+vXrMX/+fIwcORLt27e3Kc2LvZX/jqNQKPDKK69Ue7Nj3rx5sokgK1asqHYdEVd9zzC4TdRE7dixQ1Z++OGHa9znf//7H3x8fKRyTRf35WdNKpVKPPDAAzW2YdkPy342RY3hebRcOIUXZY7TGMaPrQoLC2WLTrZt2xZ9+vSpdh+VSoX7779fKuv1epcM6tubs42f2uQxVqlUFXJTcual9X7++WeUlJRI5dGjR0OlUlW7z0033SS7CbJ//34UFxfbpT9HjhyR3Xi6++67a1zAsWXLlrI8+idOnMCVK1eqrO+Ia6SmwtnGT20+QywXGebnh2M52xhyhPL/9wKliwfW5MEHH5Tlcna1a7f64urjhxOEqLzExEScOnVKKt9yyy01Lv7p6+sr+38sPT0df/75Z5X1XfU9w+A2URNVfiVflUqFQYMG1biPWq3GbbfdJpWvXr0q+3AtLysrS/ZzmW7dulm1gFPXrl0RFhYmlX/55ZcKC2g0JY3heczKysL+/fulslarxdChQxukL01NYxg/tXHw4EHZRdkdd9xh1X6W49Ka1AWNWWMaP+Vn5QOQzUan6pW/XgAqvk+qUr6eTqfDoUOH6qU/9fH+ru9rpKbE2cZPbVgGDjIzMxuoJ01TYxhDtjAajfj111+lcrNmzdClS5ca9wsNDUXXrl2lclxcnCwo2lS5+vjhBCEqz/LaxdproDvvvLPa45Tnqu8ZBreJmqC8vDzZir/R0dGyPG3VKX/RBJSuHlyZuLg4mM1mqdytWzer+1e+jZycHCQkJFi9b2PTGJ7HrVu3yvKWDhkypEJOMKofjWH81IblbARrz7tFixayvLnVzWpoChrT+CksLJSVa5qBQv8p/z4ICgqyesaY5Xip6nqhLv1RKpVWBX0q609V729HXCM1Jc42fmrD8vOjNrO/qfYawxiyRUJCgrSIKVD7/3tNJhPi4uLs2TWX5Mrjx3KCkEajsTqYSY1Tbb/jdO7cWfbLjuq+47jqe4bBbaImyDLXaGULg1WlU6dO1R6rqu3R0dG1buPChQtW79vYNIbncdOmTbIyZxw4TmMYP7Vh2Vdbzrv852Fubm6TnuHbmMZP+dylAKyagU6leVvLLyhky/WC5XixR55zs9mMS5cuSeWWLVtafbO0bdu28PDwqLE/jrhGaiqcbfzUluXnR/lfplD9aixjyBb8DLIfVx8/27Ztk00Quv3226tcRJuahvLj0MPDA23atLFqPy8vL9mvGC9evAhRFCvUc+X3DG87EzVBlkGG8PBwq/dt1qxZtceqarvlfvZooylw9efxzJkzOHHihFSOiIioMfdxVdatW4elS5ciMTERubm50Gq18Pf3R8eOHdGrVy8MGzZMlu+UXGf87Ny5Ez/99BPOnz+P7OxsqNVq+Pn5oX379ujVqxfuvPNOhISEWH288n11d3eXzcauieXn4YULFxp8AeCG4irjpyZFRUXYs2ePVFYoFOjdu7dNx1i2bBnOnz+PpKQk5Ofnw9vbG/7+/rj++uvRu3dvDB06VBY4bSzqcr0QFBQElUolfTG3xxi4evUqdDpdrfojCALCwsKk4PiVK1dgNBorzMJ1xDVSU+Fs46e2Nm/eLCvbeh3z+++/49SpUzhz5gyysrLg5uYGf39/tGzZEr169cLQoUMrpE6iUq4whpKTk/Hcc8/h77//Rnp6OoxGI/z9/REaGoqePXvitttuQ48ePaw+nj0/gy5evGj1vo2RK4yf6tgrJcnp06cxc+ZMnDhxQkqr5Ofnh+bNm6NXr14YPHgwrrvuujr3l+qXwWBAUlKSVA4LC6t2IUlL4eHh0mdCcXExkpOTERERIavjyu8ZBreJmqC0tDRZ2ZYZbMHBwVAqlVL+VMtjVdWGLbNcLOumpqZavW9j4+rPo+Ws7Xvuucem/4TL27Ztm6ys0+mQlZWF8+fPY+vWrXjvvfcwZswYTJkyhSkH/uUq4+eXX36RlYuLi5GTk4NLly5h9+7deP/993Hfffdhzpw5Vs3SLH/eoaGhNo05y89Dfv78x1nHT01Wr16NoqIiqXzjjTciICDApmNs2LBBVtbpdEhPT8fZs2exceNGvPvuu5g4cSLGjBlT6884Z1SX6wVBEBAaGip9EavqesFR/SmrXxbcNhgMyMzMrHAMR1wjNRXONn5q49KlS9iyZYtUViqVFRaorUllP83Oy8tDYmIiDhw4gI8++gh33nknXnjhBZtuxjYFrjCGkpKSZAEnoPSm6tWrVxEXF4cVK1agW7duePHFF9G5c+caj9dY/u91Bq4wfqpy9uxZu00QOnXqVIU1IAoKCpCUlITffvsNS5Yswa233oqXXnqpxsUJqeFkZmbCaDRKZVt/RVTZdxzL4LYrv2eYloSoCbLMHWjLz5sUCgU0Go1ULh8wqK4NW3IsW9atqo2mwJWfR5PJJPtCKAhCvaYkKSgoQExMDB577DFkZWXVWzuuxJXHT3klJSX49ttvcd999yExMbHaujqdTrZ4oa353S0/D/n58x9XHD9nz57Fp59+Kts2bdo0u7eTmZmJN998E5MnT3b46vD1qS5jwLK+0WiULfTa0P2p7HiVbauPa6SmwtnGj63MZjNeeuklWVqAESNGoHnz5nZtx2QyYevWrRgxYgSOHz9u12O7OlcfQ2Xi4+Px0EMPYf369TXWbQz/9zoLVx4/lrO26zJByBoHDhzAvffeW2HCCTkPe18DVfb54MrvGc7cJmqCLL94u7u727S/Wq1GQUEBgMq/GFbWhrWLMVVWtylfmLny8/jrr78iPT1dKvfo0aNWP7vt1q0bBg4ciK5du6JNmzbw8fGBwWBAeno64uLisH79etmCOfHx8ZgyZQq++OILm56vxsjZx09UVBQGDx6MHj16oF27dvDz84MoisjIyMCxY8ewadMmHDhwQKp/4cIFjB8/HuvWrYO/v3+lx7Tsp61jwPLzkJ8//3G28VOTwsJCzJw5U3ZhPXLkSPTq1cuq/RUKBfr06YPbbrsNXbp0QcuWLeHt7Q29Xo/U1FQcOXIEa9eulS0+uG/fPjz33HNYvHhxo5jBXZcxUFn9wsJCm6856rM/lY1LR1wjNRXONn5stWTJEtms64CAAMyZM8fq/Vu2bIlBgwahT58+aNeuHQICAqBUKpGVlYV//vkHP/30E3bs2CHdkL127RomTJiA77//nmlK/uXMY8jPzw8DBw5Ev379EBUVhdDQUHh4eCAvLw8JCQn45Zdf8P3330ufBwaDAfPnz4e/vz8GDx5c5XHr8hnkDP/3OhNnHj/VsdcEodDQUAwaNAg333wzoqKiEBgYCHd3d+Tk5ODUqVPYs2cPfvjhB+k6KT8/H9OnT8dXX32FG264wW7nQ/ZR1+84tbkGcpX3DMDgNlGTVD5fJWD7F7fy9fV6vd3bsKxreaymxJWfx7rmiWvVqhW2bt2K9u3bV3jM3d0dnp6eaNWqFUaNGoUffvgBCxYskMZjfHw8YmJiMHPmzNqfQCPgrOPHz88P3333XZUrfDdv3hzNmzfHXXfdhf379+PZZ59Fbm4uACAxMRELFy7EBx98UOm+lp9Jdfl8A/j5U56zjB9rmM1mPPvsszh37py0LTIyEi+++KJV+3ft2hW7d++udIamSqVCu3bt0K5dOzz00ENYuXIlFi1aJC3Ms3PnTqxfvx6jR4+2z8k0IHteLwBVXzM0VH8qG5eOuEZqKpxt/Nhi586dWLZsmVQWBAFvvPGG1SmNPvvsM/Tt27fSm1xhYWEICwvD4MGD8cQTT2D69OlISUkBAGRnZ2Pu3Ln47rvv7HMiLs5Zx9D06dPRpUuXSgM/AQEB6N27N3r37o2xY8di5syZOHLkCIDS/5uee+457Nmzp8qb9K78f6+zcdbxU5ODBw/WeYLQG2+8gV69elVYVwIoTaEVHByMW2+9FWPHjsW0adOkG/V6vR4zZ87Ejh07HHozkWrmiO84rvqeARjcpiZk4MCBuHr1ar0df+7cuRg7dmy9Hd+eLC/Eyv/c0hrlZ8FVdTevsjas/XC0/PmKM8y+bajx46rPY25uLvbu3SuVNRoNhg4datMxQkNDrc7zNXLkSLi7u2PWrFnSti+//BKPP/64zbl16wPHj5yXl1eVgW1L/fv3R0xMDB5//HEpz9y2bdswceJEdOjQoUJ9e36+VXa8hsDxY7s33ngDP//8s1T29vbGJ598Am9vb6v2t3b1eUEQMGHCBACQ3XD55JNPMGLECJf/Ymjv91Ndnw9HvL8dcY3UVDjb+LHWn3/+iWeffVa6YQWUpjMaOHCg1ce45ZZbrKrXpUsXrF69GqNHj0Z+fj6A0hv0+/fvR//+/W3reCPkrGPI2l8ABQUFYcWKFXj44Ydx8uRJAKVp9FauXIm5c+dWuk9dzrmh/+91Ns46fmpij4Ukb7rpJqvqtWzZEmvWrMF9992H5ORkAKWLN69fvx6PPPKIze1S/bEcf85+DQQ47j0DMOc2UZOk1WplZVvvqJWvb3msqrbbMnPAsj9VtdEUuOrzuG3bNtl/brfffrtNeUtr46677pJ9mSwqKpIF2JsiVx0/lnr27Il7771XKouiiO3bt1daty7nDFS8KOPnz39cZfwsXboUX3/9tVRWq9WIiYlBVFRUvbU5btw4tGvXTiqnpqbi6NGj9daeo9T1/WQ5DmzN3Vjf/alsXDriGqmpcLbxY43Tp09j8uTJsrYfeuihesnVX6ZNmzbSTbIylotoN1WuOIYsaTQaLFiwQLbtp59+qrJ+XT6DnOnazRm44vjJy8uT3ZyvzQQhWwUGBlZIuVTdGKWGYTn+HHEN5ArvmTIMbhM1QZYfWrbkhDSbzbIPOWuD27bkfLPsT1O+MHPV53HTpk2ycn0uJFnefffdJyvHxsY6pF1n5arjpzLWvrYeHh5QKpVS2dZ8k2W5Mcs09Hk3JFccP9988w2WLFkild3c3PDhhx/ixhtvrNd2FQpFhc+53377rV7bdIS6jAFAPg7c3NzqPIuwroulWbNQkiOukZoKZxs/Nbl8+TLGjRuHvLw8aduwYcMwf/78em0XAO69915ZCpOmfv1SxtXGUFW6du0quwGakpKCS5cuVVq3Lp9Bznbt1tBccfw0xAQhALjjjjtk7fz111+NaoHsxsCe47my49m7DUd/5jItCTUZixcvrtecP5GRkfV2bHuzTPWQmppq9b7p6elSagCgNG+gNW2kpKRUWdeSZX+s3a8+NdT4ccXn8cKFCzh27JhUjoiIQJ8+fRzStmWqi7Kf1zU0jp+6u/7666FSqaSfx1X32oaEhEj5S9PS0iCKotWL+6WlpcnKDX3eAMePtX788Ue8/vrrUrksR+6gQYPqvW2gNHhRXn2mknGUulwviKIoez9Zm2aqvvoDyN/fbm5uCAwMtGsb1l4jNRXONn6qk5aWhieeeEKW57Zfv3549913oVDU/3ywwMBAREZG4vLlywBKF5c0GAxQqVT13rYzc6UxVJOuXbvK1oFITk5Gq1atKtSryzk727VbQ3PF8dNQE4Tc3NzQuXNn6caa0WjEtWvX0LJlS4e0TzULDAyEm5ubdJ1R9l3HWtZ8x3HF90wZBrepyejcuXNDd8FpWOYStSUAaPkh2rp1a6vaSElJsTrHrmUb1uY+rU8NNX5c8Xm0zBM3fPhwqwOLdWWZXzs7O9sh7daE46fuFAoF/Pz8pMBDda9tmzZtpP7r9XpkZmYiKCjIqnYsPw8b+rwBjh9r/Pzzz3jhhRdkOXJfeukljBgxol7bLc8yUOosnz91UZfrhYyMDFmuxqquF2wREREBtVot3eyxpT+iKMq+pEVGRlYaOHTENVJT4WzjpypZWVl48sknZTekevbsiaVLlzo0uBwYGCgFtwEgJycHwcHBDmvfGbnKGLKGtf9H2PMzyBmuYRqSq42fCxcu4K+//pLK4eHhDpsgBFQ+Rhncdh7u7u5o3ry59KuP1NRUmybwlB//Hh4eiIiIqFDH1d4z5TEtCVET1LZtW1n51KlTVu974sSJao9V1fayRVTs2UZT4GrPo9lsxubNm2XbRo0aVe/tlrHMC9bUF9JxtfFTk/Kvb3WvreWFmS3nXf7z0MfHp0kHFlxl/MTGxuKZZ56RzZidOXMmHn300XprszKN8fMnNDRUtginLdcLluPFHmNAoVDIZjomJiZa/ZPZ8+fPy14ja69f6uMaqalwtvFTmYKCAowbNw7nz5+XtnXq1AmffvopPDw86qXNqlimAGgMnyF15QpjyFrWvr72/Axq6sFtVxs/lrO277nnHodNEAL4GeQKyr+ndTodLly4YNV+BQUFspunrVu3rnRsudp7pjwGt4maIF9fX7Rv314qnzx50uqfvMfHx8vKVa0W3r17d9nPOC33q075O9Z+fn6yHHVNjas9j7GxsbKZcT169ECLFi3qvd0yV65ckZUr+8l5U+Jq46c62dnZyM/Pl8rVvbY9e/aUla0978TERGRmZlZ5nKbGFcbPsWPHMGXKFFl+yvHjx2PSpEn10l51GuvnT48ePaS/MzIyKpxnVeLi4mTlqq4XbFX+fWkymWRpsKpj7fWLI66RmhJnGz/l6XQ6TJw4URYQbN++PT777DOH5Lgtz2w2y2bIqVQq+Pj4OLQPzsqZx5AtLPtt+WvDMh06dJC99rb831u+rlKpRPfu3W3sZePjKuPHbDbjxx9/lG1z5AQhwPoxSg2ntt9xjh8/DpPJVOVxynOV94wlBreJmqiBAwdKfxsMBtmqzFXR6/XYv3+/VA4PD0d0dHSldQMDA3HDDTdI5fj4+Ap5nioTHx8vC472798fbm5NN4OSqz2PGzdulJUdlSeuTPnxCQDXXXedQ9t3Nq42fqpz4MABWbm61/aWW26R/ZR8x44dVrVhWc9RuZqdlbOPnzNnzmD8+PGymbuPPPII5syZY/e2rNFYP3/KXy8AwPbt263ab+fOndLfarUaffv2rZf+1Mf7u76vkZoSZxs/ZQwGA6ZPn44///xT2tayZUusXr0a/v7+dm3LGnFxcbKFLBvL54c9OOsYskVxcTH++OMPqezm5oYOHTpUWtfNzQ233nqrVE5JSbHqJl5aWprsxnK3bt0YnITrjJ+GniCUkpKChIQEqRwYGIiQkBCHtU/WcfQ1EOC87xlLDG4TNVFDhw6Vlb/99tsa99myZYvswvuOO+6wug2TyYR169bV2MbatWur7WdT5CrPY0FBAfbs2SOVNRoN7rzzznpvt0x+fj6++uor2bZ+/fo5rH1n5SrjpzoGgwErV66UbbvllluqrO/l5SV77S9cuIDffvutxjY2bNggld3d3Stc3DVFzjp+Ll++jLFjxyI3N1faNnLkSLz88st2b8saV65cqZCSqbF8/gwaNEh2s2j9+vWynIqViY2NxcWLF6Vy//79odVq7dKfG2+8URZ83LZtm+zapDKJiYk4fPiwVO7UqVO1C4E74hqpqXC28QOUzpB87rnnZDcjmjVrhs8//7zBgjnLli2Tlav7P66pccYxZKsvvvgCBQUFUvmGG26o9tcBtfkM+u6772A2m6s8RlPlKuPHcs0iR08QiomJka1b0rdvX4emRCHrtG7dGlFRUVL50KFDSExMrHaf3Nxc/PTTT1I5KCio2lnVrvKescTgNlEjsXHjRkRFRUn/5s2bV2396Oho9O/fXyr/8ccfFfJ8lZeVlYVFixZJZQ8PDzz11FPVtjF69GjZz7JXrVol+9CzdOTIEVlwIDo6GgMGDKi2jabAEc/jkiVLZONnyZIlNvdz+/btsnymQ4YMqfXPei9fvlwh71t19Ho9nnnmGWRlZUnbrrvuOocuwuKsnG38pKWlIScnx+r+m81mzJ8/XzabJDg4GHfddVe1+02ePFlWfv3112WpKyx9+umnslx0Dz74IGc8wfnGD1A6hp588klpcVGg9Ev8G2+8YZcvYufPn6/xIr683NxcTJs2TTa+BgwY4NAZV/UpKCgI999/v1S+fPkyVqxYUWV9vV6PhQsXSmVBECq8H8tLSkqSvf413VRyd3fHuHHjpHJ+fj7efvvtKuubzWYsWLBAFvSZMmVKtW044hqpqXC28QMAr7zyCrZt2ybr45o1aypdXMtWOTk5Vv3CpbyPP/4YBw8elMoeHh546KGH6tyXxsLZxtCZM2ds6D1w8OBBLF26VLbtiSeeqHafQYMGyWZ2//jjj7KZ35YuXryIzz77TCoHBwfLnrOmzNnGT2XsOUGopKTE6jzMZTZs2IDvv/9eKguCgMcff7xW7ZPtyo+f8oHrqpQfj2azGa+88orsxoSlt99+W5bacfz48dX+orK+3zP1hcFtoiZs5syZsg+2l19+GVu3bq1Q78qVK3j88cdluWjHjBlT4+wWrVYr+wKp1+vx5JNPVrowwaFDhzBlyhTZB/PMmTN5xxiu8zxazjioS564vXv3YtCgQVi6dGm1gTSgNOjwwAMPyL4YKhQKzJs3j+MHzjd+/v77bwwcOBDvvPNOjQsUnjp1Ck888USFdDezZs2qcTZAly5dZDMnz507h3HjxslugAClF4WrV6+WffH09vbGxIkTrT2lRs3Zxk9OTg7Gjh2LpKQkadttt92G999/H0ql0i5tfPfdd7jjjjuwevVq2U+ELYmiiL1792LkyJE4ffq0tF2j0TRYapT6MmnSJHh6ekrlJUuWYM2aNbKAMVAa5B03bhzOnTsnbRs2bJjd03M8+uijaNasmVT+v//7P7zzzjsVbmAVFBRg9uzZiI2NlbZ169YNgwcPrrGN+r5GakqcafwsWrRI9gsUPz8/fP7557KFSusiJSUFgwcPxvz583H06NFqAw6XL1/GjBkz8Mknn8i2jxs3DqGhoXbpT2PhTGPo0UcfxYQJE7B79+5q8/Hn5eXh448/xsSJE2U3TG+88Ubcfvvt1bahUCgwa9YsqSyKIqZMmSL7LCtz8uRJPPHEE7K+TJs2zeELojozZxo/ldm+fbtsUk9dJgjpdDrcfffdmDVrFg4ePChbbNtSeno6Xn31Vbz44ouy7SNGjMD1119fq/ap/g0dOhSdO3eWyocPH8acOXNQWFgoq1dSUoK33npL9j0qIiLCqpunzv6eqYwgVvc/LhHZzdKlSxETE1NhuyiKsg8JQRBkC3iViYiIwO7du6s8/saNG/H8889L5ZEjR1Y7k6nM2rVr8corr8i2dezYET179oSHhwfOnz+PAwcOyP5jvPHGG7F69WrZz1WqM2vWLNkMGUEQ0LdvX0RFRcFoNOL48eMVFkOYNGkSZs6cadXxm4r6fB6XLFkiC+5NmzYNTz/9tNV9u3z5MoYMGSKVw8PDsXfv3loHtdasWYO33npLKkdERKBjx45o1qwZfHx8YDQakZ6ejri4OFy6dKnC/vPnz8cjjzxSq7YbK2cZP3v27MHUqVOlcnBwMKKjoxEZGQlvb2+IoojMzEwcO3YMZ8+erbD/2LFjMXfu3Br7BJR+sRw9erTsBolGo8HAgQMRGRmJ7OxsxMbGymZsK5VKfPrpp40mpYS9OMv4+eGHHyr8Mqk2Qe0RI0bgzTffrPSxN954A19++SWA0vNs2bIlOnbsiJCQEHh7e0On0yE1NRVHjx5FSkpKhb4sWbKkUeZr/+WXXzB58mTZNUurVq3Qp08f+Pn5ITExEfv27ZP9gqddu3ZYt25dtV/Sk5KSZM9XREQE9u7dW2N/Tpw4gUceeUQWEAgJCUH//v0RGBiI1NRU7N27V5YqJDg4GBs2bEBYWJhV5+yIa6SmwlnGj+WsuKquu2tS1c3ZU6dOYcSIEVLZz88P0dHRaNWqFXx8fKBQKJCdnY1//vkHJ06cqBAouPPOO/Hhhx/y5nwlnGUM9ezZU5oFqdFoEBUVhXbt2sHPzw8eHh7Iy8vD+fPnERcXV+FXiK1bt8Z3330HPz8/q875/fffr5CWrUePHujcuTMUCgXOnDmDw4cPy26iDB8+HO+9955Vx29KnGX8VOaRRx6R5f9fs2YNbrrpJpuOUSYvL0+WcsLLywsdO3ZEmzZt4OvrC5VKhdzcXJw+fRrHjh2r8Eu1nj174vPPP4e7u3ut2m+Mrl69KvueW175RRqBqq9J16xZgxtvvLHSxyz/X7Lm1yFXr17F/fffL7ux7uvri4EDByI0NBQZGRnYv3+/7FeOWq0Wa9eutXpNh/p6z9SXprtKG5GDiaJY4cPPlnrW7FsbDz30EPLz87F48WLpy9mpU6cqnZUHAH369MHixYtt+tL21ltvwWQySQsZiKKIgwcPymbalhEEAWPGjMEzzzxj+8k0cs78PFr+XPuee+6x6xezq1ev4urVqzXW8/Pzw8KFC6u8AGnKnHX8pKenV1iIrzIeHh6YN2+eTT/V9vHxwcqVKzFt2jRpZm1xcbEsSFueVqvFq6++ysB2JZxl/FQ2J6M2/z9aBpSqa+/SpUuV3kSzFB4ejvfee6/aFehd2W233Ya33noLr7zyihSwqe656dixI5YuXVpvX3A6deqEJUuWYM6cOVKqo2vXrmH9+vWV1m/evDmWLFlidWAbcMw1UlPhbOOnjLXX57WVk5ODw4cPy3K+V0apVGLKlCmYPHkyA9tVcMYxVFxcjL/++ku2kGNV7rjjDrz++uvw9fW1+vizZs2CTqeTrSlz9OhRHD16tNL6w4YNk6UHoP844/gBSn/9U/71DA8Pt2taxYKCAvzxxx/VprUp8/DDD+O5555jYNuCLf9PVFXP3nOKIyIisGLFCkyfPl36jpybm1vhl9Rl/P398cEHH9i0WLGzvmeqwrQkRIQJEybg22+/xc0331zl7JXIyEi88MILWLNmjdWzDcqo1WosXrwY77zzTpUrgwNA165dsWLFCrzwwgu8sK+Esz6PoihWCG7XdRGU3r17495777U6Z23z5s0xa9Ys7Nixg4HtKjjL+ImKisLDDz+Mdu3aWTVbLjg4GBMmTMDOnTtrlYM0MjIS69evx5QpUxAcHFxpHZVKhSFDhmDjxo0YPny4zW00Bc4yfhxh8ODBuPvuu60Ognbo0EFKWdFYA9tlRowYgY0bN2Lw4MFVBnCDg4MxdepUfP/992jevHm99qdfv37YsmULRowYAY1GU2kdX19fPPbYY/jxxx9r9TPZ+r5GakqcbfzUh7CwMDz55JPo1KlTtTlNy/j6+uLhhx/G1q1bMW3aNLulV2qsnGEMTZw4EX369LFqsTR3d3cMGjQIa9aswccff2xTYBsoTU/y0ksvYcWKFejatWuV9Tp06IB3330XH374IdRqtU1tNCXOMH4sbdq0SRb4rOsEIQ8PD0yaNAndunWzKkit1WoxfPhwbNiwAQsWLGA6Gxdy/fXX48cff8Rjjz1W5WeLRqPBiBEjsGXLFvTt29fmNpzxPVMVpiUhIpm0tDQcO3YMaWlp0Ol0CAkJQevWrdGlSxe7tXHmzBkkJCQgLS0NSqUSISEh6NSpE1q2bGm3NpqCpvI85ufnIyEhAcnJycjIyEBxcTGUSiV8fHwQFBSEzp07MzdlLTjD+CkqKsK5c+eQlJSEjIwMFBUVQRAEeHt7IyAgAJ06dUJkZKTd2jOZTIiLi8OVK1eQkZEBT09PhIWFoXv37vD397dbO02BM4wfR8jKysK5c+eQnJyM7OxsFBcXQ6VSwdfXFyEhIejSpUuTXXg0OzsbcXFxSE1NRWFhIYKCghAZGYnu3bs3SICusLAQf/75J1JSUpCbm4uAgABERESgZ8+edpuF5ohrpKbC2cZPfSgpKZH+j7t27RoKCwthNpvh4+MDPz8/REVFoW3bti57I7ChNfQYMpvNSExMRGJiIlJTU5Gfnw+DwQCtVgtfX1+0bt0a0dHRdp0Fm5iYiBMnTuDatWswmUwIDQ1F+/btrVqEjuQaevw4gtFoxMWLF3H58mXpPI1GI7y9veHj4yONncZyvk1ZSUkJ/vzzT1y9ehVZWVnw9fVFs2bN0LNnT1nu7Lpw9vcMg9tERERERERERERE5HKYloSIiIiIiIiIiIiIXA6D20RERERERERERETkchjcJiIiIiIiIiIiIiKXw+A2EREREREREREREbkcBreJiIiIiIiIiIiIyOUwuE1ERERERERERERELofBbSIiIiIiIiIiIiJyOQxuExEREREREREREZHLYXCbiIiIiIiIiIiIiFwOg9tERERERERERERE5HIY3CYiIiIiIiIiIiIil8PgNhERERERERERERG5HAa3iYiIiIiIiIiIiMjlMLhNRERERERERERERC6HwW0iIiIiIiIiIiIicjkMbhMRERERERERERGRy2Fwm4iIiIiIiIiIiIhcDoPbRERERERERERERORyGNwmIiIiIiIiIiIiIpfD4DYRERERERERERERuRwGt4mIiIiIiIiIiIjI5TC4TUREREREREREREQuh8FtIiIiIiIiIiIiInI5DG4TERERERERERERkcthcJuIiIiIiIiIiIiIXA6D20RERERERERERETkchjcJiIiIiIiIiIiIiKXw+A2ERERERE5taeffhpRUVHSv7Fjx0IURav2zc/Px6BBg2T7f/rpp/XcYyIiIiJyBAa3iYiIiIjIqS1cuBARERFS+eDBg1i5cqVV+7744otISkqSyjfffDMmTJhg9z4SERERkeMxuE1ERERERE7N19cXH3zwAdzc3KRtixcvRnx8fLX7rV27Fjt37pTKQUFBeO+99yAIQr31lYiIiIgch8FtIiIiIiJyet26dcOMGTOkstFoxOzZs5GXl1dp/TNnzuCtt96SyoIg4N1330VQUFC995WIiIiIHIPBbSIiIiIicgnjx4/HLbfcIpWvXr2KF198sUK94uJizJw5E3q9XrZv3759HdJPIiIiInIMBreJiIiIiMgllM2+Dg4Olrbt2rUL33zzjaze66+/jvPnz0tly1nfRERERNQ4MLhNREREREQuIzAwEO+99x4Uiv++yrz99ts4ffo0AGDLli34v//7P+kxHx+fCvm6iYiIiKhxYHCbiIiIiIhcyk033YSJEydK5ZKSEsyYMQOnTp3CggULZHXfeOMNREREOLqLREREROQAgiiKYkN3goiIiIiIyBYmkwmPPfYYjh49Km1TqVQwGAxS+aGHHsIrr7zSAL0jIiIiIkdgcJuIiIiIiFxSamoq7rnnHuTk5FR4LCoqCuvXr4darXZ8x4iIiIjIIZiWhIiIiIiIXFJYWBjeeuutCtu1Wi0+/PBDBraJiIiIGjkGt4mIiIiIyGUVFxdX2BYeHo7IyMgG6A0RERERORKD20RERERE5JIuX76M+fPnV9h+7tw5vPvuuw3QIyIiIiJyJAa3iYiIiIjI5RgMBsycORMFBQWVPv7VV1/h559/dnCviIiIiMiRGNwmIiIiIiKX88EHH+Cff/6Rytdddx1eeeUVWZ0XXngBqampDu4ZERERETkKg9tERERERORS9u/fjzVr1kjlsgUkH3roIdx9993S9pycHMyZMwcmk6kBeklERERE9Y3BbSIiIiIichnXrl3DvHnzIIqitO3ll19GmzZtAACvvvoqWrZsKT32xx9/ICYmxuH9JCIiIqL6x+A2ERERERG5BLPZjDlz5iArK0va9r///Q+jRo2Syl5eXli0aBFUKpW0bdmyZfjjjz8c2lciIiIiqn8MbhMRERERkUuIiYnB77//LpVbtmxZIc82AFx//fWYM2eOVDaZTJg9ezays7Md0U0iIiIichAGt4mIiIiIyOn9+eefsvQiKpUKixYtgpeXV6X1H3/8cfTv318qp6Wl4fnnn6/3fhIRERGR4zC4TURERERETi0nJwezZ8+WLQw5Z84cXH/99VXuIwgC3n77bYSEhEjb9u3bhy+//LJe+0pEREREjsPgNhERERERObXnn38eqampUvm2227DE088UeN+AQEBeP/996FQ/Pe157333sPJkyfro5tERERE5GAMbhMRERERkdP68ssvsXfvXqkcEhKCt956y+r9e/fujUmTJknlkpISzJw5E4WFhXbtJxERERE5niCKotjQnSAiIiIiIiIiIiIisgVnbhMRERERERERERGRy2Fwm4iIiIiIiIiIiIhcDoPbRERERERERERERORyGNwmIiIiIiIiIiIiIpfD4DYRERERERERERERuRwGt4mIiIiIiIiIiIjI5TC4TUREREREREREREQuh8FtIiIiIiIiIiIiInI5DG4TERERERERERERkcthcJuIiIiIiIiIiIiIXA6D20RERERERERERETkchjcJiIiIiIiIiIiIiKXw+A2EREREREREREREbkcBreJiIiIiIiIiIiIyOUwuE1ERERERERERERELofBbSIiIiIiIiIiIiJyOQxuExEREREREREREZHLYXCbiIiIiIiIiIiIiFwOg9tERERERERERERE5HIY3CYiIiIiIiIiIiIil8PgNhERERERERERERG5HAa3iYiIiIiIiIiIiMjlMLhNRERERERERERERC6HwW0iIiIiIiIiIiIicjkMbhMRERERERERERGRy2Fwm4iIiIiIiIiIiIhcDoPbRERERERERERERORyGNwmIiIiIiIiIiIiIpfz/8B05+Yrp4BMAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "result3 = cp.pymc_experiments.RegressionKink(\n", + " df,\n", + " formula=f\"y ~ 1 + bs(x, df=3) + bs(I(x-{kink})*treated, df=3)\",\n", + " model=cp.pymc_models.LinearRegression(sample_kwargs={\"random_seed\": seed}),\n", + " kink_point=kink,\n", + ")\n", + "\n", + "result3.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = az.plot_posterior(\n", + " result3.gradient_change, ref_val=gradient_change(beta, kink), round_to=3\n", + ")\n", + "ax.set(title=\"Gradient change\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using a bandwidth\n", + "\n", + "If we don't want to fit on _all_ the data available, we can use the `bandwidth` kwarg. This will only fit the model to data within a certain bandwidth of the kink point. If $x$ is the running variable, then the model will only be fitted to data where $threshold - bandwidth \\le x \\le threshold + bandwidth$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABbcAAAPXCAYAAAAYJXYaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd1QU19sH8O/Sq4ACFkQBI3aNDVuM3agxRhJrFGPU2LDEmESN3Wg0MfYSYiV2LNhiD2I0RsUuYhdRUcFC723fP3iZH7O7wC5she/nHM/hzs7MfXZ2dtx99s5zJVKpVAoiIiIiIiIiIiIiIgNipOsAiIiIiIiIiIiIiIhUxeQ2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcEx0XUAREREROqQnJyMCxcu4NKlSwgLC0NERAQSEhJgamqK8uXLo169eujcuTO6desGMzMzXYdLREREREREJSSRSqVSXQdBREREVBKbN2/GsmXLkJ6eXuS61apVwy+//IImTZpoITIiIiIiIiLSFI7cJiIiIoP35MkTIbHt5OSEVq1aoUGDBnB0dERGRgbCwsJw6NAhxMXF4dmzZxg2bBg2b96Mxo0b6zhyIiIiIiIiKi6O3CYiIiKDN3v2bDx79gxfffUV2rRpA2NjY7l1YmJiMGbMGNy4cQMA4O7ujqNHj8LIiFOQEBERERERGSImt4mIiMjgxcXFwd7evsj1oqOj0bVrV6SlpQEAtm7dCi8vLw1HR0RERERERJrAsiRERFSm+fj4ICQkRGhv2bIFLVq00GFEVBzKJLYBoGLFimjWrBn+/fdfAMD9+/eZ3C7FivP+NpRrgqHESaVDTk4Obt++jQcPHiAmJgZSqRT29vaoUaMGGjVqBFNTU12HiNjYWISGhiIqKgoJCQnIzs6Gra0tHB0dUa9ePbi4uOg6xBIzhOeYlJSEbt264c2bNwCAoUOHYtq0aTqOSrd4vVYvQ7ge5dFWrBkZGQgPD8ejR48QExOD5ORkWFpawt7eHm5ubqhbt65aJ1PXdH83btxA//79hfaGDRvQtm1bdYROpRST20RUZkydOhX79+9Xal2JRAJra2vY2trC1dUVdevWRbt27dCqVStIJBINR0pk2ObNm4ft27cXuZ6RkRFsbW3h4OCAOnXqoHnz5ujVqxdsbW01Gp+NjY3wd2pqqkb7IiIyZMnJydi4cSN27dqFd+/eKVzH1tYW3t7eGDNmDMqXL6/V+DIyMrB//34EBAQgLCys0HWrVKmCPn36YODAgSrHeenSJQwZMqQkoQLI/UFVVdp6juqyevVqIbFta2uL0aNH6yQOKn30/XqUnzZivX37NoKDg3HhwgXcunULmZmZBa5rZmaGDz74AEOGDEGrVq1U7kvb/b3//vvo0qULTp06BQBYsGABDh8+rFc/XJB+YXKbiEgBqVSKpKQkJCUl4dWrVwgJCYG/vz9cXFwwdepUdO3aVdchEumtO3fuKLVeTk4O4uPjER8fj4iICBw7dgyLFy+Gr68vhg8frrFa2A8fPhT+rlq1qkb6ICrrAgMD8eLFC6Ht7e3N95uBCQ0NxYQJE/Dy5ctC10tMTMSWLVtw6NAhLF68GB9++KHW4psyZQoeP36s1PovX77EypUrsXXrVsyePRvdu3fXcIQlZ2jP8fHjx9i2bZvQHj58OBwcHLQagyxei0oHfb8e5afpWE+ePInFixfj2bNnSseUkZGB06dP4/Tp0+jQoQPmz58PR0dHvewvz6RJkxAUFIScnBw8efIEW7duxbBhw1TaB5UdnEGJiEgFL168wPjx4zF79mxwygIieTk5OcUamZYnNTUVv/32G7755hvk5OSoMbJcly5dEpIEpqamaNOmjdr7ICJg//79WL16tfAvf3KJ9N/NmzcxZMgQhckZMzMzWFhYyC2Pi4vDmDFjEBQUpPH4rl69iiFDhhSY9LWyskK5cuUU3m0XGxuLb775Brt379Z0mCViiM9xxYoVwmhOGxsbDB48WKv9K8JrkeHT9+tRftqI9datW4UmmiUSCezs7GBubq7w8eDgYHz22WeIjIzUy/7y1KhRA507dxbaf/zxB5KSklTaB5UdHLlNRGWWm5sbhg4dqvCx7OxsJCUl4cmTJ7h48SKioqJEj+/atQv29vaYNGmSFiIlMhwRERFISUkRLRs3bpzC0RpJSUl4/PgxgoODERcXJ3rsxIkT8PPzw9ixY9UWW2pqKmbPni20fXx8YGdnp7b9ExGVBjExMfD19RVdy01MTDBo0CAMHDgQ1atXh0QiwcuXL7F37174+/sL62ZlZeG7775DYGAg3N3dNRJfQkICxo8fL/d/TYMGDTBixAi0atVKuLanpaXh+vXr2L59u3B7e57Zs2ejTp06aNCggcoxFPYZUh304Tmq6s6dOzh58qTQHjBggMbLjFHpp+/XI32I1crKCl27dkXLli3RrFkzVK5cGSYmuam+ly9fIjg4GBs3bhT9sBMdHY1hw4Zh//79sLa21tv+vv76a+G6EhcXh82bN2P8+PEqxUtlA5PbRFRmOTs7Y+DAgUWul5OTg4MHD2LevHmiDysbNmxAr169UKNGDU2GSRq2detWXYdQqty9e1fUNjY2xsiRIwsczQEAKSkp+OmnnxAYGChavn79enzxxRdKTxZZGKlUih9++AFPnjwBkJuY8PX1LfF+iYhKm1WrVgk1k4Hc0YYrV65Ehw4dROu5uLhg4sSJaN++Pb7++mvEx8cDyL2mL1q0CH/88YdG4vvjjz/katj2798fs2fPhrGxsWi5hYUFWrVqhVatWiEgIACzZs0SHsvJycGiRYuUmiNClrKfIYtLH56jqvz8/IS7Go2NjfVi1DYZPn2/HukyVg8PDwwdOhQ9e/YsMGFcpUoVDBo0CJ9++il++OEH0ejwp0+fws/PD5MnT9bL/gCgYcOGaNy4Ma5fvw4A+PPPPzFs2DCVE/JU+rEsCRFREYyMjODt7Y3ly5eLlmdlZckl44jKOtl6225uboUmtoHcESA///wzWrduLVqekpKCc+fOqSWuRYsWCSM/rK2tsWLFCtHEkkREBERGRmLPnj2iZePHj5dLzuTXqFEjUUIVAM6cOSMkI9Tt6NGjoranp6fCpK+s/v37o2/fvqJlV65ckbs7Tx8Y2nN8/vy5aNR427ZtUblyZY32SaWfIVyP8mgz1sqVK2PBggX466+/0L9/f6USvTY2Nli+fDnq168vWr5161akpaXpVX+y+vXrJ/ydmJjI79+kEJPbRERKateuHZo3by5a9u+//+ooGiL9JDtyu3bt2kptJ5FIMGrUKLnlN2/eLHFMS5cuhb+/P4DcRPq6deuUjouIqCzx9/cXaiYDuZPuKjOBV8+ePdG0aVPRsvXr16s9vqioKLlatgMGDCgy6ZtnyJAhcsuuXLmiltjUxRCf47Zt20TzZMgm2ImKQ9+vR/lpM9ZBgwahT58+Sl8T8piZmeH7778XLUtNTcV///2nV/3J6t69O6ysrIT21q1bOfcVyWFym4hIBS1bthS19XG0D5EuyY7cViWJ3KRJE7mJsWRvy1bVsmXLhNs7rayssH79ejRr1qxE+yQiKq1kJzTr06ePUEu1KPlH1wHA+fPnkZqaqrbYAIhu+c/TsGFDpbf39PQUJUkK2qcuGdpzzMrKwsGDB4W2tbU1PvzwQ431R2WHvl+P8jOUWL28vOTK/d27d08jfamrP0tLS7Rv315oP336VO9+lCTdY81tIiIVODk5idrJyckq7yM5ORmPHz/GkydPEBsbi5SUFFhZWcHOzg6urq5o0KBBkWUc9JlUKsXdu3cRERGBmJgYJCUlwc7ODk5OTmjcuDEqVKhQ4j6eP3+Oe/fu4fXr10hKSoJUKoWlpSUcHBzg4uKCGjVqqKVOs7J0+ZpmZ2cjNDQU9+/fR2xsLMzNzeHg4ICGDRvCw8NDI30WJCoqCrGxsaJltWrVUnp7MzMzWFtbi2ZCzz8STFVLly4VEtvW1tZYv3693OgYXXj9+jVu3bqFd+/eIS4uDlZWVihfvjw8PDxQu3ZtuQS/uujTuZJfab8mqiItLQ0hISF49eoVYmNjYWFhAVdXVzRu3Bjly5dXa1+GeNwNMWZDcufOHbkRwz169FB6+48++gjTp09HVlYWgNzz+fz58+jcubPaYlT0f4Kqkxba2NiI5lDJP9pSHxjaczx37pzo//727dvDzMysRPvUt895imjzel0WGcL1KI8hxWpkZISqVauKJnJ/+/at2vtRd38fffSRqFzTwYMH5e6oprKNyW0iIhXI/oqu7GQW9+/fx7Fjx/Dff//h9u3byM7OLnBdU1NTtGnTBiNGjFDqP20/Pz8sW7ZMaHt5eRV7ksSNGzfi119/Fdrvv/8+AgIClNr2+fPn+OOPP3D69OkCR9tKJBLUr18fI0aMQLdu3VSKLTk5Gf7+/ti/fz+eP39e6LoSiQTVq1dH27Zt4e3tjXr16hW4ro+PD0JCQoT2li1b0KJFiyLj0eRrmp9scvj+/fsAgIyMDGzcuBFbt24t8Hi7ublhwoQJ+Pjjj1Xqs7hkR20Dqo3czs7OFn0ZB1DsH0MWL16MDRs2AMj9kr9+/Xo0adKkWPtSh+zsbOzbtw87duyQK92Sn5OTE7p3744xY8ao/OXYkM4Vbb1/DMWbN2+wdOlSHD9+XO49AOROztauXTtMmjQJnp6exe5H08dd9nqan6JSCfmNGzcO48eP13rM9D8XL14UtR0dHVG9enWlt7e0tETt2rVx+/ZtYdmFCxfUmqCpVKmS3LK8ydiUIZVKkZCQIFrm7Oxc4rjUydCe47Fjx0Tttm3bFms/6vycp4lrUR5tXa/LOkO4HuUxpFgB+R+7NDWoQp39ffDBBzA2NhY+A5w8eRJz585VuVQKlV4sS0JEpIK8ZFEeZUY7/vbbb+jVqxd+//133Lx5s9Av5kDuB4AzZ85g8ODBmDp1KtLT0wtdv2/fvqIRMiEhIXj8+HGRccmSSqVyieyBAwcWuV1WVhZ++eUXdO/eHXv27Cm0jIRUKkVoaCgmTpyIQYMGISYmRqnYbt26he7du2PlypVFfuHJ6yciIgJbt27FmjVrlOpDFZp+TYvy/PlzfP7551i+fHmhxzsiIgLffvstZsyYUWSM6iCb3La3t0fFihWV3v7Ro0dyI9YaNGigchy//PKLkNi2tbXFpk2bdJrYfvjwIXr27ImZM2cWmtgGcr80b9myBZ07d5abmKg49PFc0fX7R98EBQWhR48eCAwMVJgoAXJ/HDl9+jQ+++wz7Nu3r1j9GOJxN8SYDdmjR49E7eJcf99//31RuzifRwpTsWJFuaSRKhPFhYWFyU1mpsv/HxQxpOcolUrl5p/x8vJSeT/69jmvINq6XpNhXI/yGFKsOTk5iIyMFC1zdHTUSF/q7M/GxgZ16tQR2vHx8bhx40ZJw6NShMltIiIlxcbGimaCB4A2bdoUuZ3s6Jn8rKysYG9vD1NTU4WP79+/H2PGjCm0NEOFChXkRkHv3LmzyLhk/ffff3j69KnQtre3R/fu3QvdJikpCaNHj8amTZsU3vJqZmYGe3t7hb+qX7lyBQMGDCiybnl4eDiGDh2K6OhohY9bW1vDwcGhxLfAqkLTr2lhoqKi4OPjgwcPHoiWW1tby9XYzLNnzx6sXLmyWP2pQjZxq0pJEgA4fvy4qG1qaooPPvhApX38/PPP2LRpEwCgXLly2LRpExo1aqTSPtTpypUr+OKLLxAeHq7w8XLlyimsyZicnIwZM2Zg1apVxe5bX88VXb5/9E1QUBAmTpyo8JgYGxvDzs5ONMIpMzMT06dPl3uvKMMQj7shxmzIZK9Trq6uKu9DdpuCrn0lMWDAAFF7+/btyMjIUGrbjRs3itpeXl6oVq1aseLIzMxEaGgoTp06hb179+Lo0aO4cOGCUsnZoujLcyzK3bt3RT+cVqlSBS4uLirtQx8/5ymizes1Gc71SNF+9TnWf//9V66sZmF3uOpTf7J3ZJ07d67YcVHpw7IkRERKSEpKwjfffIPExERhmZWVldwEIIVxcXFB+/bt0bJlS3h6esLV1VWU9H3+/DkuXryInTt3IiwsTFh+/vx5+Pn5YezYsQXue9CgQTh06JDQPnjwICZPngxLS0ul45NNiHt7exdau1QqlWLy5MlyHyy8vLwwYMAANG/eXLgNNicnB3fu3MHBgwexa9cu4Qva06dPMWnSJGzbtq3A28oWLFgg+lBkZmaGgQMHonv37qhdu7boOaakpODRo0e4desWzpw5I3eboLpp8jUtyDfffINXr14BAFq3bg0fHx94eXnBxsYGQO7I3yNHjmD16tWi83XDhg3o1asXatSoUdynWyTZ5LYqJUmio6OxZcsW0bJPPvlErs59YRYsWCDsw97eHps2bdLoB/aiREdHw9fXV+6LcNu2bTFkyBC0bNkSZmZmyMnJQXh4OA4cOAB/f3/RD0WrV6+Gu7s7evbsqXL/+nyuALp5/+iT58+fY/LkyaLX28jICH379kXfvn1Rt25dGBsbIzMzE1evXsW2bdtw6tQpSKVSzJgxo9gjrTR53IcOHSrUGfX390dERIToMTc3twK3rV+/vk5iVofo6GicPn1ao33k5+7uLjfBtTrkf72A3ESlqmRLakRHRwu10dVl8ODBOHTokPB/zrNnz/D999/j119/LfRzi5+fn6hmq6mpKX788cdixRAaGopmzZrJjZDOU7FiRbRp0wZffvmlSv8X5tGH56gM2ZGTqv6oDWjmc566r0W6ul4XB69H/6ON6xFgWLHKft+zsrLSyOunif5kr6UcuU35MblNRKRAdnY2kpKSEBERgfPnz2Pnzp14/fq18LhEIsHcuXOVqmHYpEkTdO3atcgRqK6urnB1dcXnn3+OtWvXikZsbtiwAUOGDBGSUrLef/991KtXT/hSn5CQgCNHjqBPnz7KPF1ER0cjODhYaEskErlRQ7I2btyIM2fOCG1zc3P89NNP+PTTT+XWNTIyQv369VG/fn307t0bo0aNwps3bwAA165dg7+/P4YPHy633evXr3H+/HmhbWpqii1btqBx48YKY7KyskLDhg3RsGFDDB48GK9fvxYlOtRFG69pQa5fvw4TExPMnj1b4Y8rTk5OGDp0KFq2bIkvvvhC+MKYlZWFgIAAjX3JjY+Px4sXL0TLlP2SGxcXh9GjR4smkqxQoQK+//57pftfvny5KDk+ePBgvHr1SkjuFqRy5coaS4D/+OOPogl0AGDGjBnw8fERLTMyMsJ7772H7777Dp988gm++uor0Ui42bNno3nz5iqVeAH091zR5ftHn8yYMUM0j4OFhQV+//13tG7dWrSeqakpWrZsiZYtW2LPnj2YOXMmEhMTRT9IKEMbx71Tp07C30ePHhV94e/YsaNS8xloO2Z1iIiIwJw5czS2f1ne3t4aSUbI/hBXnIScoh8kExIS1JqgMTMzw7p16zBs2DA8fPgQQO6dP/fu3cOQIUPQqlUrVKlSBUZGRnj79i2uX7+OHTt24MqVK8I+TE1NsXjxYtFt7qqQnYNFVnR0NAIDAxEYGIiuXbti3rx5cHBwMKjnqIz8NYIB1ZPbmvqcp+5rkbav1yXB69H/aON6lLfP/PQ11gsXLsj98OHt7a2xuyLU3Z9scvv27duQSqUarxlOhoHJbSIqs0JCQoo1wsTFxQWzZs1C+/btlVq/d+/eKu3fyMgI48aNw4sXLxAYGAggt0TBwYMHMWjQoAK3GzRokCgZtWvXLqWT23v27BFm6AaAVq1aFTqqJT4+Xq7G4dKlS5Wa+KRevXpYs2YNvvjiC6FPf39/+Pj4yH3YuXv3LqRSqdDu2rVrgV94FHF2dtbIJEraek0LMmnSpCLvGqhduzZ8fX1FE4QeP35cYwnL4k4mGRwcjJ9++kmUGLeyssKaNWtUmlDx6tWrovbq1auV2s7b2xuLFi1Suh9l3bp1S64O6ZgxY+QS27Jq1aqFdevWoX///sL7IykpCf7+/pgyZYrKcejjuaLr948+uHbtmtyIw/nz58slSmT17dsX0dHRxSpXY4jH3RBjNlRpaWlyNc1Vufsrj4WFhdwy2VvS1cHZ2Rl79+7FmjVrsG3bNqSkpCAiIgLz5s0rctt69ephzpw5aNiwodrjUuTkyZO4desW/vjjD5VGcRvCc5StC6xqOQZ9/ZyXny6u12WdIV2PDCXWhIQETJ8+XbTM2toaY8aMUVsfmu5P9vqSmJiIqKgoVK5cudj7pNKDNbeJiJRkbW2NCRMm4MSJE0ontktixIgRovalS5cKXb9nz56wt7cX2qGhoXIjahTJzs6Wm7iuqIkkd+7cKZpI5+OPP1ZpRu9GjRrhk08+EdqvX78WjQLPIzsSomrVqkr3oY9UfU0V8fDwUDjKXZHPP/9cVM85Ojoab9++VblPZSiaKPHy5cvYuXOn6N+OHTuwbt06zJo1C126dMHo0aNFiW03Nzds3bpVpS+3+mjr1q2idrVq1ZQujVC/fn25RNzevXuLHCkoS1/PleJSx/tHX8hO3uvl5SW6JhZm5MiRxarnWVyGeNwNMWZdUzQ5XnFG1ylK0Kh67VKlr8mTJ+P333/He++9V+T69vb2WLhwIQIDA4ud9LW3t0fPnj2xYMEC7N27FxcuXMDt27dx7do1/P3331i2bBl69uwpN5dCVFQUvv766yLvJpKli+eoCtk7tlS9w8gQPucZ0vW6tDCk65EhxCqVSjF16lS59+sPP/ygUvk/XfdnbW0tdxeWbB9UdnHkNhGRkpKTk7Fy5UocOnQI48ePL1YNXFXUqFEDNjY2QqmGouqKmZubo0+fPtiwYYOwbOfOnViwYEGh2wUHB4smdXR2dkbHjh0L3ebIkSOidlGjURXp0aMH9u/fL7RDQkLQtWtX0TrlypUTtZVJ1uszVV9TRfr376/07Xf29vbw8PAQTSgYHh6ukdqPikZuL1y4UOntPT090b9/f/Tp00fhB/yiyCaTde3s2bOidv/+/VX6suPj44MtW7YII9oSEhJw48YNtGrVSul96Ou5UlzqeP/oA6lUKvdj3hdffKH09mZmZujXrx+WLFmi5sgUM8Tjru2YW7Rogfv372u0D01LT0+XW1bQZJ2FUXSdK6gudUndvHkTP//8s9Kvb1xcHKZNm4b9+/fjm2++QdOmTZXuy9nZGUuWLEHXrl0VPkdTU1NYW1vD1dUVPXr0wMSJE/Htt98iNDRUWOf169f47rvvsH37dqX71eZzVFVmZqbcj6CqJq70/XOeoV2vAV6P8tPG9cgQYl2xYgWCgoJEyzp27FhkCUp97M/JyUlUxlDVHwyp9GJym4jKLDc3NwwdOrTAx9PS0hAbG4v79+/j0qVLwq/nERERmDx5Mv755x8sXLhQbnSOMjIyMhAeHo5Xr14hOTkZKSkpcre0ARDt+/Xr18jJyYGRUcE33QwcOBCbNm1CTk4OgNw6g1OnToWtrW2B28hO9NG3b99Cn1NsbKxQ/xEAbG1tizXKVrbOsaIvbg0aNIBEIhESfOfPn8fy5csxduxYjdWHKy5NvaayvLy8VIrL1dVVlLCUHSWlLopGbiurdu3amDZtmkYntNGm8PBwuVrbH330kUr7cHV1Rd26dUW1RK9du6ZScltfzxVFtPX+0QcRERGi88PY2Fjlu4E6deqklmSJIR53Q4zZECiapDD/5HnKypswuqh9l9TOnTsxf/58UUk1IPezRd6E1iYmJoiJiUFoaChCQkKE5xMSEoLBgwdjwoQJSt8i7+7uDnd3d6Xjq1atGnbs2IEvv/wS165dE5ZfuXIFwcHB6NChg949R1WlpKSISooAqpdj0PfPefp0vS5LDOl6pO+xBgQE4Pfffxct8/Dw0EhJPm30J1uDPH+im8o2JreJqMxydnYusvxGnsTERKxfvx7r168XEseHDh2Cqakpfv75Z6X2ERcXhwMHDuDo0aMICwuT+7JSFKlUisTERNjZ2RW4TtWqVdGuXTthcsiUlBQcOHCgwJHVz58/F03kY2xsXGR93lu3bom+zNja2solyJWRdxzz5E0wmV/58uXRtWtXnDhxQlj2+++/Y/fu3ejRowfatWuHJk2awNraWuX+1UEbr6ksFxcXlfqQPTaa+BCYlpaGJ0+eFHv7e/fuYfjw4VixYoVK5W30leyIKTs7u2Ldlly/fn1RclvVkVj6eK7kp4v3jz64d++eqO3h4aFyQsjd3R1WVlYKb4cuiiEed0OM2dAomrRMUbKlKIpGGqp78rbjx49j7ty5os8inp6eWLBgQYGlOF69eoWFCxcKnydycnKwfPlymJmZKV2+SVVmZmZYsWIFPvroI9F7dceOHUUmtw3hOSp6rVW980rfP+fp+npdVhnS9UifYz1x4oTc5KKVKlXCpk2bNPL/oTb6k034a+rOIDI8TG4TESnB1tYW3377LRwdHUVlPvbt24ePPvoI7dq1K3T7vXv3YvHixXKjOVWVnJxc5IeDQYMGCcltIPcX9IKS2wEBAaIvTu3bt0elSpUK3b/sLagvX75Uy6zs8fHxCpfPnDkTt2/fFtVUe/fuHbZu3YqtW7fCxMQEnp6eaNKkCZo3b46WLVuKao9rijZf0/xkb+EtirGxsagt+6OCOty/f19u5OTBgwflJs7KzMxETEwMbt68ia1btyIkJER4LCsrC9OnT4eXl5fKz1HfyJ7Lxa0hKrtdQe+RgujjuZJHV+8ffSD7nKtUqaLyPoyMjFC5cmW5ydyKYojH3RBjNkQWFhYwNjYWXcuLU+9VUaJBnYnJxMREzJ49W/TZpV69eti2bVuhiaDKlStj5cqVmD17Nnbt2iUsX7ZsGdq2bQtPT0+1xZifs7Mz+vXrB39/f2HZ5cuXkZGRUeDIZEN7jvnJjuRWhr5+zgN0e70uywzlegTob6z//vsvJk+eLPos5+DggE2bNmlkAkZt9VecawyVDbw3j4hIBT4+PnJfDtavX1/oNmvWrMH06dNL/MUcUC7Z9MEHH8DNzU1oP3z4EJcvX5ZbLyMjA/v27RMtU2Yku6oJNmUV9EHQyckJe/bsKbCsQ1ZWFu7cuYNt27Zh4sSJ+OCDDzB69GhR4lTdtP2a5qdsDWVtkq23bWpqiho1asitZ2pqiooVK6Jr167YunWrXO29uLi4Yt0FoG9ky3kU98uJbDkhVd97+niuALp9/+iDxMREUVt2ciRlFVZuShFDPO6GGLMhkz2nijOprKK7sFQ9Vwuzb98+uTIRv/32m9IjHKdPny66qyUzM7PIz3ElJTtKOzU1VVQCSpahPEdFo7QV1R8uij5+zsujq+s1Gcb1qKB96jrWa9euYfz48aLyKDY2Nti4caPCz+clpc3+ZK8xqt5JQaUXR24TEalAIpHgo48+En0puXLlCuLi4hSOIrl8+TJWrlwpWmZmZoYuXbqgRYsWqFWrFipWrAhbW1uYm5vLTUDSsWNHlWeBlkgk+OKLL0TlUnbu3InmzZuL1jt58iRiYmKEdrVq1fDBBx8Uuf/i1JErqQoVKmDlypW4f/8+AgMDcebMGURERChcNzMzE8HBwQgODka3bt2wYMGCYn8ZUUQXr6m+k6237enpqdRkOj/++CPOnz+P58+fC8t2796NkSNH6m1ilkqG7x/dMMTjbkgxR0dH4/Tp01rpC8gtc6CJOQrc3d1x/fp1of3y5UuV95F/gmogd+SyOkdK5r8zDQBat24NDw8Ppbc3MzPDgAEDRDWQT58+jezsbLm7V9Tlvffek1v27t27Atc3lOdobW0tqpcNoNilN/Tpc56h4/XofzR9PcqjT7HevXsXo0aNEr0XLS0t8ccff8jNd6QO2u5P9hrD9z7lYXKbiEhFNWvWFLWlUinu3r2rcKK35cuXi9q1a9fG2rVrla6Fm5ycXKwYP/vsMyxfvlz4AJCXyC5fvrywTv5bVgGgf//+SiUUZW/rbtiwIfbs2VOsOFVVq1YtTJs2DdOmTcPr169x5coVXLt2DVevXsXdu3flblU7fvw4YmJi4O/vr7YvdLp6TfWZ7MjtOnXqKLWdubk5hg0bhrlz5wrLIiMjcfXqVTRr1kytMWqTbDmQ4r7msiPGSkNJBb5/5EdiFbe2uez5URhDPO6GFHNERIRaynMpy9vbWyvJpPw/PCorMjJS1FYlKasM2RHPTZo0UXkfstskJSXh2bNnKk0YqQpF1+7CJuw1lOdoYmICJycnvH79Wlj2+vVrpT8DKKIPn/Py08X1uqR4PfofTV+P8uhLrI8fP8awYcNE1xdTU1OsWrVKI5+rtd0fID/CXRMlVsgwsSwJEZGKFP1CnH8EdJ53797h2rVrQtvY2BirVq1S+ot5VlZWsT8M29ra4pNPPhHamZmZ2Lt3r9B+9OiRqFSJmZkZPvvsM6X2nT9BDsjXI9QWZ2dn9OjRAzNmzMD+/fvx77//YsaMGXLHNyQkBIGBgWrpU5evqb7KysqS+yJet25dpbfv1auXXN3R48ePqyU2XZG9i6O4o0dlv+gYenKb759csudHcUZ45eTk4NWrV0qta4jH3RBjLg1kRxiHhoaqvI8bN26I2uq+JV02KVyhQgWV96FoG01+llF0LhZWbsCQnqPsezJ/orukdPE5T5a2r9f0P4ZwPcqjD7FGRkbiq6++En0nNTY2xtKlS9G2bVuV49G3/oDcH5dkf7hWdfJ0Kr2Y3CYiUpGiURuKSjA8ePBAVOPz/fffR7Vq1ZTu586dO3KT9Kli0KBBonZAQIAQj+yo7Y8++kguaV0Q2RE5L1680IskgqOjI3x8fPDXX3+hYcOGoscOHTqklj50/Zrqo/DwcLn6d6qM2rKxsZErh3Pq1Cm1xKYrsnX54+LiijWK5/bt26J2rVq1ShSXrvH9k0t2otXw8HCVJ5968uSJ0rf/G+JxN8SYSwPZ0Zdv377F06dPld4+NTUV9+7dEy1TdFdbScjWnVY0CVtRFG2jybqtisprFPaZy5Ceo+zdjKqcL6rSxuc8Wdq+XtP/GML1KI+uY42OjsbQoUMRHR0tLJNIJPj555/RtWtXpfejr/3lefbsmahdrlw5VKpUSWP9kWFhWRIiIhUpmgTI0dFRbpnsaG5Vb5uSrbmoqlq1aqF58+bCCO3IyEicO3cOXl5eOHDggGhdZSaSzOPq6gpXV1chWZednY2zZ8/i448/LlG86mJlZYXx48fj66+/FpYVNnGTKnT9muoj2ZIkRkZGKidhO3bsKKoPGRUVhbCwMI3U6tMGDw8P2Nvbi0bJ/f333/jqq6+U3kdkZKTcsS3Oren6hO+fXG5ubqLzIzs7G2fOnEH37t2V3kdQUJDS6+rquMuWCFBlQkdDO1datGiB+/fva7VPTahXrx4qV64sGmV69OhRjBkzRqntT548KZqXw9zcHG3atFFrjOXLlxeNbC5OMvXJkydyyxwcHEoUV2H++ecfUdvU1LTQkgOG9Bzr16+P3bt3C211fd4qjKqf80pyLdL29VodeD3KpY3rUR5dxhobG4thw4bJDaKYOXMmevfurdQ+VKHt/vKTPa/r16+v0f7IsHDkNhGRCqRSKU6cOCFaZmpqKjdSM295foXVV5SVlJQkN7q6OGRHb+/cuRN//fWXaKS1p6cnmjZtqtJ+ZWe0X79+vVwdRF2qWrWqqK2uETP68JrqG9nJJKtVq6byBDjt27eXq/euzcmQNKFdu3ai9q5du1SajHXbtm2i95SdnR0aN26stvh0ge+fXBKJRO782LFjh9LbZ2RkqDTPga6Ou+x1QJU7fHiu6E7nzp1F7b179yIrK0upbfMnOYHciRBlRyGXlGzZq+DgYKXjyyN7d1CFChXg7Oxc4tgUSUhIwM6dO0XLGjduXOgkaIb0HBs1aiRqy34m0BRVPueV5Fqk7es1ien79Sg/XcSalJSEESNG4NGjR6LlkydPlvsOqA7a7k+W7Oh22esPlW1MbhMRqeDPP//Ew4cPRctatWql8EuK7G1SV69eVfoD9bx58xTW8VZVly5dRF9mzp49iw0bNojWGTBggMr7HTZsmOhD1927d7FkyZLiB1oAVb/M5QkPDxe1nZyc1BGOXrym+kZ2dLEq9bbzODk5yY2+MPTk9uDBg0XtiIgIrFu3Tqlt79y5g61bt4qW9enTBxYWFmqLTxf4/vmf/v37i9ohISE4fPiwUtuuW7dO7tbcwujquMve0fT48WOlt+W5ojtffvml6MeFyMhIbNq0qcjtjhw5gitXroiW5R9ZW5BLly6hVq1aon+F1U+WLWP18uVLbNu2rch+8ty4cUNuXofWrVsXOqF2cX+8z87Oxg8//ID4+HjR8qLmONHFcyyuWrVqiT5jvX79WqXrkzY+55XkWgRo93pNYvp+PdJlrGlpaRg9erRcCbvRo0dj5MiRSsWsCm33p0j++aIAaKy2NxkmJreJiJSQmJiI3377Db/88otouUQiwfjx4xVuU7duXVHSOzk5GXPnzi30dsisrCzMmTMHBw8eVEvcJiYmog/l2dnZotqPVlZW+PTTT1Xeb4UKFTBq1CjRsvXr12P27Nkq1YZMT0/H/v374e3trTAZsWTJEkyePBk3b95Uep8xMTFYtmyZaFmLFi2U3r4w+vCa6hvZURSq1NvOr0OHDqL2nTt3EBUVVey4dK1hw4ZyCYpVq1bJjc6R9fDhQ4wcOVL0hd/W1hZffvmlRuLUJr5//qdp06bw8vISLZsxYwYuXLhQ6HZ79+7F6tWrVepLV8dd9oeuAwcOKJyzoqBtea7ohqurKz7//HPRstWrV+PMmTMFbnPr1i3MmzdPtOzDDz9U+a4wZfTo0UMukbl48WKlko23bt2Cr6+v3Hnk4+NT6HYLFizAb7/9hjdv3igdZ0xMDEaPHi1XIsfT07PIz126eI7FJZFI5BJMly5dUnp7bXzOK8m1CNDu9ZrE9P16lJ82Y83MzMSECRPkkr0+Pj6YNGmSaoErQdv9KZKYmCi6M8TOzg7vv/++Vvomw8Ca20RUZr1+/VruVtH80tPTERsbi3v37uHixYsKk7ajRo2Sm9Qmj4mJCfr06QN/f39h2eHDh/Hq1SuMGjUKXl5ewkjMN2/e4J9//sGGDRuEOolubm5ITk5W6cuUIv3794efn5/CkgiffPJJobfGFmbUqFG4c+eOqEzLrl27cOrUKfTv3x9t27ZF3bp1RaNNk5OT8fjxY9y9exf//vsv/v3330JvJc3KysJff/2Fv/76C66urujSpQuaNm2KOnXqoHLlyjAyyv2NNjs7G0+fPsWZM2ewefNmvH79WtiHsbExvvjii2I9R1n68prqi+fPn8uVCyjOyG0gN7m9cuVK0bKgoCCt3OaoKT///DN69eol1OqUSqWYOXMmTp8+DR8fHzRv3hxmZmaQSqUIDw/HwYMHsXnzZmRkZIj2M2fOHFSsWFEHz0C9+P4Rmz9/Pnr16iX835KWloZhw4ahb9++6N+/P+rUqQMjIyNkZmbi2rVr2LZtG06ePAkgdxKlChUqKKyrK0tXx71du3YwNjYWJnaMiIhA9+7d0alTJ1SvXl3uToT69eujQYMGOo2Zck2YMAFBQUHC8UtPT4evry8GDRqEL774AtWrV4dEIsHLly+xd+9ebN68WfR/uZWVFaZOnaqR2CwtLTFp0iT8+OOPwrKsrCx89913OHLkCAYOHIimTZsKn20yMjIQGhqKgwcPIjAwUO6z0CeffFLkre1JSUnYunUrNm3ahObNm6Njx46oV68ePD09Ua5cOWG9tLQ03L59G0FBQdi9e7dcAtXW1haLFy8WPrvo03Msie7du4tGt549exZ9+/ZValttfM4rybUoj7au1yRPn69Huop1wYIFcrX8K1euDA8Pj0K/2xbE2toavXr10pv+FPn3339FP9p17dpVrp4+lW1MbhNRmRUREYE5c+YUa1uJRIKvv/66yF+rR48ejVOnTuHFixfCsitXruDKlSswMjJCuXLlkJqaivT0dNF2NjY2WLFiBcaOHVus+PJzcnJC165dceTIEbnHVJlIUpZEIsEvv/wCiUQiuv313bt3WLt2LdauXQsg94OamZkZkpOTVao5LOv58+fYtGmTcIufRCKBjY0NjI2NC933xIkT5b6klIQ+vKb6QlFtzeImt+vWrYtKlSqJRmufPn3aoJPbFStWxJo1azBmzBjRjwDBwcEIDg6GRCJBuXLlkJycXOCt2ePGjUPPnj21FbLG8f3zP9WrV8dvv/2Gb775Rnj9c3JyEBAQgICAABgbG8PGxgYJCQmisggSiQQ//fQTtm/frnSyRBfHvVKlSvD29sbevXuFZYX9qDxu3DjRtZrniu5UqFABq1atwrBhw4TES1ZWFv7880/8+eefMDMzg5GRkcIf/Y2NjfHrr7+iRo0aGovv888/x6NHj+Ru+c+7tgK5yRNjY2MkJiYWWFakcePGmD9/vtL9Zmdn4+LFi7h48aKwzMTEBDY2NsjIyCj0x/py5cphzZo1qF27tlJ96eo5FkebNm3g5OQkJPTOnTuHtLQ0lUtpaepzXkmvRYB2r9ckpu/XI13Eqqi0zqtXrzB37txixe3i4lJoslnb/SmS92NRnuLceUylG8uSEBGp6P3338f27dsxefLkItd1cHDAH3/8ARcXF7nHcnJyEBcXJ/fF3MnJCZs3b1b6C5AyFCUI33///WKXkMhjaWmJFStWYNq0aQWOAE9JSUFcXFyhiW0PDw+Ym5vLLS+qBmZiYmKB+7ayssLs2bPlyqeUlL68pvpAtt52xYoVUb58+WLvr3379qJ2SEgIkpOTi70/fdCsWTNs374dHh4eco9JpVLEx8crTGxbW1tj/vz5BZY9MlR8/4h16dIFK1asgK2trdxj2dnZiI+PFyVKTE1N8fPPP6Nbt24q9aOr4z5jxgx07dq1WNvyXNGtxo0b488//5Srfw7kjhRWlJyxs7PD2rVr0aVLF43HN2XKFMyZM6fASdeSk5PlEo35DRgwAJs2bSrxXAZZWVmIi4srNLHdsmVLHDp0SK60RVH05TkWxdjYWJSoSk1NLbQUQ37a+pxXkmtRHm1dr0mevl+P8jOkWA2F7DWlWrVqaNasme4CIr3E5DYRUQFMTU3h4OAANzc3dO3aFd9++y2OHj2KgIAAleq21axZE4GBgRgyZEihM1/b29tj+PDhOHr0aIGlToqrcePGcsnnkozaljV06FAEBwdj4sSJqFmzZpHrSyQS1K5dG8OGDcPu3btx7NgxudnsAeC7777Dxo0b4ePjg9q1ayt1+1nFihUxbNgwHD9+XG3lSGTpw2uqD2RHbpf0x5KOHTuK2hkZGTh37lyJ9qkPPD098ddff2HevHlFJt2cnJwwZMgQnDp1Sunbug0N3z9inTt3xtGjR+Ht7V3g8TAyMkKHDh0QGBhY5GR0BdHFcbe0tMSqVauwa9cuDBkyBE2aNIGjo6PSyTaeK7rVsGFDHDlyBGPGjCn0h0sbGxv4+Pjg2LFjcj9SatLAgQNx/Phx+Pr6KvwRRJaNjQ0+//xzBAYGYu7cuYWeU/kNHToUvr6+8PLyUvhZRRF7e3v07NkTO3fuxJ9//onKlSsrtZ0sbT3Hkho8eLDoM1r+UdKF0dbnvJJei/Jo63pN8vT9epSfIcVqCI4dOyb6AdHHx0cjE+SSYZNIizv9MxERqSw9PR3Xr19HeHg4EhISYGRkhPLly6NmzZqoX7++xmqHnT17VjTztr29Pc6ePatwtLQ6vHv3DqGhoXj37h1iY2ORlZUFKysr2NnZwc3NDTVq1ChWre+8mt3Pnz/H27dvkZqaKty26uTkhFq1aqFatWpa/cCjq9eUDNfr169x69YtvH37FnFxcbCyskL58uVRo0YN1K5du0x9YOf7Ryw1NRUhISF49eoVYmNjYWlpiapVq6JJkyYluitCliEed0OMuTTJzs5GWFgY7t+/j5iYGEilUtjb2+O9995Dw4YNYWZmpusQERUVhdu3b+Pt27dISEhATk4ObG1tYW9vj1q1asHDw6PIetdFkUqleP78OZ49e4bo6GjEx8cjLS0NJiYmsLOzg52dHTw9PeHu7q6Ra7k2nmNxTZo0CUePHgWQm+D9+++/lUrI56ePn/MKoq3rNckzhOtRHkOKVV8NGDAA169fB5A7d8GZM2eKPWcUlV5MbhMRlQFjx45FUFCQ0P7qq6+0NrkKEREREZVu9+7dQ+/evYXSHMOGDcOUKVN0HBURGbLQ0FD06dNHaPv6+mLChAk6jIj0FcuSEBGVcpGRkaI6ZRKJRK0lSYiIiIiobKtdu7aovnRAQIBoMmUiIlWtX79e+Nve3h5fffWVDqMhfcbkNhFRKbdmzRpkZ2cL7Xbt2qF69eo6jIiIiIiISpuJEyfC1NQUQG6JkW3btuk4IiIyVI8fP8apU6eE9tdff61wQlcigMltIqJS7cSJE9i/f79o2ciRI3UUDRERERGVVu7u7vDx8RHamzZtQmxsrA4jIiJDtWzZMuTk5AAA3NzcMGTIEB1HRPqMNbeJiEqJ0NBQ3L59GwAQExODGzdu4OzZs6J1OnToAD8/P12ER0RERESlXFJSErp164Y3b94AAIYOHYpp06bpOCoiMiQ3b95Ev379hPaGDRvQtm1bHUZE+o7JbSKiUmLVqlVYvXp1gY/b2tri8OHDqFy5shajIiIiIiIiIiLSDJYlISIqA+zs7ODn58fENhERERERERGVGia6DoCIiDTDysoK1atXR7t27TB48GA4OTnpOiQiIiIiIiIiIrVhWRIiIiIiIiIiIiIiMjgsS0JEREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcFhcpuIiIiIiIiIiIiIDA6T20RERERERERERERkcJjcJiIiIiIiIiIiIiKDw+Q2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwmNwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRwmt4mIiIiIiIiIiIjI4DC5TUREREREREREREQGh8ltIiIiIiIiIiIiIjI4TG4TERERERERERERkcFhcpuIiIiIiIiIiIiIDA6T20RERERERERERERkcJjcJiIiIiIiIiIiIiKDw+Q2ERERERERERERERkcJreJiIiIiIiIiIiIyOAwuU1EREREREREREREBofJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjgmug6AiIiIqKxKS0vD3bt38fz5c8TExCA1NRWmpqaws7ODnZ0dPD09Ub16dUgkEqX3GRgYiGnTpgltb29vLFq0SBPhUxlWq1YtUfv+/fs6ioQM0dSpU7F//36hvXDhQnz22WcFrs/rGhERERWEyW0iIiIiLUpISMD+/ftx4sQJ3Lx5E1lZWYWuX65cOTRt2hSffPIJOnXqBAsLCy1FSkRERKpISkpCWFgYQkNDcevWLdy+fRsvXrwQrTNu3DiMHz9eRxHmysnJwaNHj4Q4Q0ND8eDBA2RmZgrruLi44PTp01qJZ9asWQgICJBbvmXLFrRo0UIrMRCR4WJym4iIiEgL0tLSsG7dOmzevBkpKSlKb5eQkIDg4GAEBwfD2toaQ4cOxbBhw2BjY6PBaImISF9dunQJISEhQtvLy4sJQB06e/Ysjh07hlu3biE8PBw5OTm6Dkmh6Oho+Pv7IzQ0FGFhYSp9FtGkq1evYvfu3boOg4gMGJPbRERERBr24MEDTJgwAU+ePCl0PUtLS5ibmyM5OVk0eipPcnIy1qxZg507d2Lfvn2oUqWKpkImIiI9FRISgtWrVwvtcePGMbmtQ0ePHhWV2dFXERER2LRpk67DEMnMzMSsWbMglUp1HQoRGTAmt4mIiIg0KCQkBKNGjZIbIWVkZIR27drhww8/RKtWrVCpUiVYWloCAKRSKV69eoVbt27h7NmzOHnyJBITE4VtY2JiEB8fz+Q2ERERGaz169fj0aNHug6DiAwck9tEREREGnL37l2Fie02bdpgypQpcpPy5ZFIJKhSpQqqVKmCbt26Yfr06dixYwf++OMPUZKbSFc4gSRp02effVbohJNE+sTV1RUNGjRAw4YN0aBBA0yePBlRUVG6DktOuXLlUK9ePSHOCxcuYPv27VrrPyIiAn5+fkK7S5cuOHXqlNb6J6LSg8ltIiIiIg1ISkqCr6+vXGJ72LBhmDJlikr7sra2xtdffw1vb29MnToV586dU2eoREREVEyNGjVCtWrV0KBBAzRo0AD29vaix42NjXUTmAwHBwcMGTJEiNPNzQ0SiUR4/N69e1qNZ9asWUhPTwcAVKxYEePHj2dym4iKhcltIiIiIg1YsmQJXrx4IVpWnMR2fo6Ojli/fj2WL18u+kJKREREujFw4EBdh6AUT09PTJ8+XddhAAACAwNx6dIlof3jjz/C2tpahxERkSFjcpuIiIhIzZ4+fYrdu3eLlnl6emLSpEkl3rdEIsGkSZOQk5NT4n0RERERaVNMTAx++eUXof3hhx+iW7duiIyM1GFURGTImNwmIiIiUrMtW7YgKytLtGz27NkwMzNTWx9GRkbF3jY+Ph5Xr17Fs2fPkJqainLlyqFSpUpo3rw5ypUrV+LYYmJi8OjRIzx9+hSJiYlIT0+Hra0typUrB09PT3h6epYo/sJkZGTg+vXrePToERISEmBlZYUKFSqgSZMmapuAMzk5GZcvX0ZUVBRiY2NhaWmJatWqoXHjxnBwcFBLH4pERkbi7t27ePfuHeLi4mBtbY0KFSqgdu3a8PDw0Fi/2iCVSnH37l3cuXMH7969g7GxMcqXL486deqgdu3aOr1TQSqVIjQ0FOHh4Xjz5g0AwMnJCfXq1UPNmjU13n9CQgKuX7+O58+fIzExESYmJqhevTq6du1a6HbJycl4/Pgxnjx5gtjYWKSkpMDKygp2dnZCTWBzc3O1xZmZmYmrV68iMjISb9++hZmZGapUqYLGjRujYsWKauunpDIyMnDjxg28evUKsbGxyMjIQPny5VGpUiU0bdpUmNhXnfT5/CbStkWLFiEuLg4AYG5ujlmzZuk2ICIyeExuExEREalRVlYWDh8+LFpWs2ZNNGvWTEcR/c+TJ0+wfPly/P3333LJdyC3LmjHjh3x7bffqpQszc7ORkhICE6cOIGLFy/iyZMnha5va2uLHj16YMSIEahWrZrS/URGRqJTp05C28XFBadPnwYAJCYmYu3atdi9ezeSkpIUbl+vXj18++23+OCDD5TuM7/nz59jyZIlOH36tFAnND9jY2O0b98ekyZNEpKePj4+CAkJEdbZsmULWrRooXSfSUlJ8Pf3x+HDhxEREVHgelWrVkX//v0xZMgQWFhYKP+kikl2MtSiJpjs2LGjqExPUFAQqlatipycHOzcuRMbN26UK+OTp2LFihg1ahT69+8PExPtfX3JyMjA5s2bsWPHjgIng3N3d8fo0aPRu3dvALm32k+bNk143NvbG4sWLSqwj8LWDw0NxZo1a3D27FlkZ2eLtnNxcVGY3L5//z6OHTuG//77D7dv35bbLj9TU1O0adMGI0aMQPPmzQtcryhJSUlYuXIlDh48KCSsZHl5eWHixInFvg6qelwVuXz5MjZu3IiLFy8iNTVV4TpmZmZo06YNxo0bh/r16yu9b22c36tWrcLq1asVPrZ69eoCHwNyj//WrVuVfDZEmnPhwgUcPHhQaI8ePRqurq46jIiISgPNDJkhIiIiKqOuXr2K+Ph40bI+ffroKJr/OXDgAD799FMcP35cYWIbyE1Snzp1Cp999hn++ecfpfc9cOBADB06FDt37iwysQ3kJqIDAgLQvXt3tSRc7ty5g08++QSbNm0qMLENAGFhYRg+fHihSaCC7NmzBz179sSxY8cUJraB3OMXFBQEb29v7Nu3T+U+ZB04cACdOnXCqlWrCk1sA7mJ/yVLlqBbt264fft2ifvWhtjYWAwZMgTz5s0rMPEHANHR0Zg3bx7Gjh2LtLQ0rcT27Nkz9O7dG0uXLi0wsQ3k/mA0ZcoUjB07tsCEaXGsWbMG/fr1Q3BwcKEJ6vx+++039OrVC7///jtu3rxZ5HaZmZk4c+YMBg8ejKlTpxZ4Xhfmxo0b6NGjB/78888CE9sAEBISgsGDB2PNmjUq91FSMTExGDlyJAYPHozg4OBCX6eMjAwEBwejT58+mDdvntLHXhF9Pr+JdCE9PR2zZ88W2u7u7hgxYoQOIyKi0oLJbSIiIiI1unz5styykoyKVIf9+/fLJa+MjIxgZ2cHU1NTufVTU1Ph6+uLhw8fKrX/hIQEhcuNjIxQrlw5lCtXTmEZkqysLMyfP79ECa979+7hyy+/xKtXr0TLbW1tCxzBvGrVKuzZs0fpPnbt2oWZM2cqTDwZGxvDzs5OVFYgMzMT06dPx7Fjx5TuIz+pVIply5ZhypQpChOGxsbGsLe3V/javXr1Cj4+Prhw4UKx+taWpKQkfPXVV3LvF0tLS9jY2Cjc5p9//sGMGTM0HtuzZ8/g4+ODx48fK3zc1tZW7tgHBQVh0qRJkEqlJe5/9erVWLlypaiuvkQigZ2dHYyNjQvcrqD3IQBYWVkVeM4AudeIMWPGqFTL/+bNmxg+fDiio6PlHsuLN//7XiqVYuXKldi0aZPSfZRUeHg4+vXrV+CPdVZWVgpLMUmlUmzfvh2+vr4F/hhYGH0+v4l0Zc2aNXj69KnQVne5NiIqu1iWhIiIiEiN7t69K2qbmZnB09NTR9EADx48wJEjRyCVSmFpaYkvvvgCH3/8MerUqQMjIyNIpVKEhYVh8+bN+Ouvv4TtMjMzMXv2bOzYsUPpvurVq4f27dujcePG8PT0hLOzs5D0zcrKwqNHjxAcHIzt27cLtYuB3GRe8+bN4eXlpdJzS0tLw/jx45GQkACJRIJu3bqhX79+aNq0qVBL+Pnz59i/fz82bNggSu4vWrQIXbp0gb29faF9hIaGYt68eaKkpYmJCQYNGgRvb2/UqlULRkZGyMrKws2bN7Fnzx4cOHAAUqkUM2fOhKOjo0rPCQA2btwIPz8/0TI3NzcMGjQIH3zwAdzd3YXj+vz5c5w6dQobN27E27dvAQApKSn45ptvcOjQIb2qdZzfnDlzhPdKgwYNMGzYMLRu3Vp4PeLj43Hq1CksX75cdK4cPnwYn3/+OVq1aqWRuLKysvDNN9/IjdZu2rSpEKOVlRUA4MWLFzh58iT8/PwQFxeH4OBgxMTElKj/W7duCbfsm5mZCe/XevXqwdjYGNnZ2Xj69CnOnz9f4D5cXFzQvn17tGzZEp6ennB1dRUlxZ8/f46LFy9i586dCAsLE5afP38efn5+GDt2bJFxJiQkwNfXV+5OiW7dumHQoEFo3LgxTE1NkZ2djbCwMAQEBGDfvn2QSqVYunSpVq6JsbGxGDZsmOiHLxMTE/To0QO9e/dGo0aNhERzeno6rl69im3btiEoKEhYPzg4GMuXL8d3332nUt+aOL/bt28vXE/OnDmDM2fOiB5r3759gfE4OzurFH9RoqOjhZJQ2uDu7o6WLVtqrT9SvwcPHoh+2Prkk080dh0norKHyW0iIiIiNXr27Jmo7eHhUeBoSW3IS15Vr14d69atg5ubm+hxiUSC+vXrY8mSJXBzcxOV7Lh69Sru3buH2rVrF9pH79690alTp0In1zMxMUHt2rVRu3Zt+Pj44LvvvkNwcDAAICcnB6tWrVK5RMm7d+/w7t07WFlZYenSpejQoYPcOq6urpgwYQKaNWuGESNGCGUGkpKScPDgQXz55ZcF7j87Oxs//vijqDRBuXLlsHHjRjRs2FDu+TVt2hRNmzZF165dMWHCBCQmJiIxMVGl53T9+nUsW7ZMtGzo0KGYPHmywhFurq6uGDZsGHr37g1fX19cu3YNABAXF4dZs2bhjz/+UKl/bbl+/ToAwNfXFxMmTJB73M7ODn369EGbNm0wYMAAUbJ527ZtGkuKbN68WZTwBXJrwn7zzTdyk/65uLjgq6++wqeffoqvvvoK9+7dw82bN0vUf95ocWdnZ2zcuFEuCWxsbAwPDw+FNfGbNGmCrl27FllT3tXVFa6urvj888+xdu1arFq1Snhsw4YNGDJkSIGji/MsWrRIlJQ1MjLCwoULhdrj+eNt2LAhGjZsiK5du2LcuHHIyMiQO8aaMHXqVFFi28XFBStWrECDBg3k1jU3N0fr1q3RunVrHDhwANOnTxdGbG/YsAFdu3aVe88XRhPnd4MGDYTY3759K0pu169fHwMHDlQ6vpKKiIjAnDlztNaft7c3k9sGTCqVYtasWcjMzASQe/fL1KlTdRwVEZUmLEtCREREpEavX78Wte3s7HQUyf/Y2Nhgw4YNcoltWb6+vnITBSpTWmP06NGFJrYVxbNy5Uq4u7sLy0JCQpQugyLr559/VpjYzq9169YYMGCAaNnx48cL3ebMmTN48OCBaNmKFSuKTHJ17NhRVFdUFb/++quoDMKQIUMwbdq0Im/dLl++PH7//Xe4uLgIyxTFr0+++OILhYm//CpXriyaSBDIfV7FqQ9dlMzMTPj7+4uWffLJJ5g0aZJcYju/8uXLY+PGjUXeBaAsExMTrFu3TuXRzb1791ZpslQjIyOMGzcOn332mbAsOTlZNNmbIq9evcKBAwdEyyZOnCiX2JbVrl07/PTTT0rHVxL//fefKPlrb28Pf39/hYltWb179xaN1JZKpdiwYYPKMejb+U2kKzt37hR+8AGASZMmFeuuJiKigjC5TURERKRGKSkporaieq7aNnLkSFSrVq3I9YyMjNC3b1/RMk2NsDQzM8OQIUNEyy5duqTyfj744AN0795dqXX79+8vat+7d6/QGsO7d+8Wtbt164bWrVsr1VefPn1Qv359pdbNc+3aNWHkNZA70lSVcgj29vYYN26caJnsc9AX9vb2+P7775Vat0uXLqhQoYLQzsrKwr1799QeU1BQkFDaBcitj/zjjz8qta2joyPGjx+vljgGDBiAOnXqqGVfypCd0K2o9+GePXtEdzO4ublh+PDhSvXVu3dvNG3aVPUgVSSbjJ40aZJS18A8Pj4+cHV1FdqnTp1SqeSMPp7fRLoQHR2NpUuXCm1t32VARGUDy5IQERERqVHebbd5LC0tdRRJLiMjI/Tr10/p9Zs0aSJqh4eHqzskwfvvvy9q37hxA4MHD1ZpH6p8Sfb09ISNjY1QJzglJQWvXr0SjXbOk5WVhYsXL4qWySbHCyORSNC/f3/cvn1b6W2OHDki119e7XBlde3aFTNnzhRGf4eEhKi0vbb06tVLqF1dlLzSFnllbIDc87JRo0Zqjenff/8VtTt37ozy5csrvX3v3r2xePFihROPqkKV96s61KhRQ/S+uHHjRqHry9Za7tu3r0qllwYNGoSrV6+qHKeyYmJi8N9//wltW1tbeHt7q7QPExMTdOvWDevXrweQWzrp6tWr6NKli1Lb6+P5rU4tWrTA/fv3dR0GGYAFCxYI5bmMjY0xd+5chRNMExGVBJPbRERERGpkamqKjIwMoZ2amqrDaICaNWvCwcFB6fXzj1YEoHLN6PzbPXz4EDExMUhKSkJaWppoUkYgty50frKT+CmjWbNmSq8rkUhQtWpV0ajIgp7fvXv3RElKc3NzlSe8/PDDD1VaXzYRrer2QG7Jl+rVqwu1mx8+fIjk5GRYW1urvC9NUvVYyp6XCQkJ6gwHAOTqZat6/G1sbNC4cWNcuHCh2DHY29vLlQYqiYyMDISHh+PVq1dITk5GSkqKaNR1HhOT/30tfP36NXJychQmoFJTU+XKB3Xq1EmlmDp06AAjI6NC75ooiStXroiuNV5eXir/SAQAdevWFbWvX7+udHJbH89vIm07ffo0Tpw4IbS/+OILle9oIiJSBpPbRERERGpkZWUlSm4XNzmsLopGJRdGNgmaN5pTGU+ePEFgYCBOnDiBp0+fqtQvoHpCx8bGRuU6x8o+P9kR656enqIEoDIqVaoEBwcHxMbGFrluSkqKXNIwJCSkyFG0iuQ//3JycvDu3Tu9S25r87xU1pMnT0Rt2eSmMurUqVOi5LaqdbYViYuLw4EDB3D06FGEhYWJargrQyqVIjExUeF8AQ8fPhTtz8rKqsha/rKsrKzg7u4u/ACjbrLvmdTUVOzcuVPl/cjGl38CzaLo4/lNpE3JycmYN2+e0HZycsI333yju4CIqFRjcpuIiIhIjZydnUUjkuPj43UXDFSv+W1sbCxqKzO6MiMjA0uWLMG2bdtUTqTll5ycrNL6xalnLvv8FI1iBeQT7U5OTir3lbedMsntd+/eyY1s//nnn4vVp6y4uDiV6g1rg62trUrrF+e8VEVycrJcSaHivObFPU/yqHKXhSJ79+7F4sWL5e6KUFVycrLC5LbsfqtUqVLoZJsFcXFx0Vhy+927d6L2f//9JypTUlyqXMv17fwmeeHh4SrN89CiRQt4eHhoMKLSZcWKFXj16pXQnjZtGmxsbHQYERGVZkxuExEREamRq6srHjx4ILTDw8ORmZmpUk1adSpO4kkVGRkZ8PX1xdmzZ0u8L9nkblE0+dxkR9wXd+Szsttp8keQktaA1gRNn5eqUjRStjiveUmTN8rWaVZkzZo1WLlyZYn6z1NQclX2fVHc56tq8lcVmnovqVJiSt/Ob5J348YNzJkzR+n1Fy5cyOS2kkJDQ7Ft2zah3bp1a3z88cc6jIiISjsmt4mIiIjUqG7duggKChLa6enpePjwYbFKHBiCdevWySW2HRwc8PHHH6Np06aoXr06KlasCCsrK5ibm4tGKEZGRqpcr1dbzMzMRG3ZUb3KUna74u5fGar+aFAWKfrxKTMzU+VSNJp8HQtz+fJlucS2mZkZunTpghYtWqBWrVqoWLEibG1tYW5uLvd8O3bsiBcvXmgzZI3R1WtQlkRHR8tNLKpJ7u7uaNmypdb6o5JZs2aNcFeUmZkZZs+ereOIiKi0Y3KbiIiISI0UTXAYEhJSKpPbycnJWL9+vWhZz549MX/+fFhaWha5fUpKiqZCKzHZkifFrYGr7HaKSkDcvHkTFhYWxeqXVKOoxE1iYqJS57HsNrqwfPlyUbt27dpYu3at0rWflS0JJDviurjvC00eJ9n30ogRI/D9999rrL+yKCIiQqVRzyXl7e3N5LYByX89ycjIwEcffVTsfQ0ZMkTUdnFx0eoPK0RkGJjcJiIiIlKjpk2bws7OTnRr/L59+zB06FDdBaUh586dE5W8cHNzw8KFC+VGPRdEmVrUuuLo6Chqy04wqYyMjAxERkYqtW758uXllsXFxaFSpUoq90uqMzExgb29vaimdHh4OJydnVXaT3HOk5J69+4drl27JrSNjY2xatUqpRPbWVlZSiebZSdwffXqFaRSqcplODQ5Slz2vVTS+uNUOn322Wf47LPPdB0GERGpgZGuAyAiIiIqTUxNTdGzZ0/RsgcPHuDKlSs6ikhz7t+/L2p3795d6cQ2kFuXU1/Vr19f1H758iVev36t0j7CwsKUnmDT3t4elStXFi27c+eOSv1Ryci+5jdv3lR5H8XZpqQePHggqpH9/vvvqzSB6J07dwqcWFVWzZo1RaWFkpOTERERoXRfQO4dG6puo4ratWuL2nfv3tVYX0RERKR7HLlNREREpGZDhgxBQECAKLE5d+5c7Nu3T6Xkb2FycnJgZKTbcQrv3r0TtWWTs0UJDg5WZzhq5eTkhKpVq4pGXh85cgRfffWV0vv466+/VOqzdevW2Ldvn9A+c+YMOnbsqNI+qPgaN26Mf//9V2gfOXIEo0aNUnr727dvazRpW5CYmBhRW5PvQ0tLS3h6eooSxkFBQRgxYoRK/SmbTC+ONm3aiNp3795FdHQ0KlasqLE+tS3/DwwANHo8FWnRooXcj5tEeYYOHYoePXqovF1cXJxciaWhQ4fCzc1NaBd3cmciKt2Y3CYiIiJSMzc3N/Tt2xc7d+4Ulj148ADLli3DlClTSrRvqVSK5cuXo3v37nIjFLVNNlGfkJCg9LY3b97U+9HsPXv2hJ+fn9D29/dHv379lPpy/erVKwQGBqrU30cffSRKbh84cAC+vr6lKimnz3r27InVq1cLE3Dev38ff//9Nzp37qzU9mvWrNFkeAWSnRxSlfdhUlISdu3apVJ/HTp0ECW39+zZgy+//FLhpJyK7NixQ6X+VFW5cmU0bNgQt27dApD7Q+D69esxY8YMjfarTbLXoOLWPifShOJOFB0ZGSmX3O7YsSNatGihhqiIqDRjWRIiIiIiDfjuu+9QpUoV0bJNmzbhl19+KfY+3759i1GjRsHPz09IwOmSbNL1zJkzSm2XkpKCqVOnaiAi9erfv79ohGRUVBTmzJlT5LFPT0/HlClTVJ4ws127dmjQoIFoP5MnT0ZGRoZqgeejD+eJoXBzc0Pr1q1Fy+bOnatU3fSAgACdTXImW5f96tWrStfQnjdvntzI76L07dtXdNdIREQENm7cqNS2Bw4c0MqPWr6+vqL2jh07lL4+KaJv7yMnJydR+/HjxzqKhHRh1apVqFWrluifsvM7lHaBgYFyx+bSpUu6DouINIzJbSIiIiINsLGxwdq1a2FlZSVavmnTJgwfPlylW7qTk5OxceNGdOvWDf/884+6Qy022dFUV65cQUBAQKHbxMTEYNiwYTqZeE9VVapUwbBhw0TLDh06hIkTJ+Lt27cKt3n27BlGjBghfJk2NzdXqc8pU6aIEuqXL1/GV199hVevXim9D6lUigsXLmD06NE4deqUSv2XdT/88INoBPLr16/h4+ODCxcuKFw/IyMDq1evxpw5cwCo/nqrQ926dWFjYyO0k5OTMXfuXFEdbllZWVmYM2cODh48qHJ/VapUQe/evUXLVqxYUeS+zp49i5kzZ6rcX3G0b98eH3zwgdDOzs7GhAkTRHfTKCMmJga///67SmVXtKFOnTqi9uXLl/HgwQMdRUNERKRbLEtCREREpCF16tTBH3/8gVGjRolG8f7777/477//0K5dO7Rr1w6tWrVCxYoVYWlpCSA3ORkVFYXQ0FD8888/OHHihNIjMbWpQYMGqFevHsLCwoRls2bNwo0bNzBo0CDUqVMHxsbGkEqlCA8Px8mTJ7F582bEx8cDALy8vBASEqKr8JUyYcIEnD17VvRjxIkTJ/DPP/+gbdu2qF27Nuzs7BAbG4ubN2/i0qVLyMzMBJA7Ejs1NVX0HCUSSaH9NW/eHNOmTcP8+fOFZVeuXMFHH32EXr16oUuXLmjUqBHs7e2FxzMyMvD06VPcv38fISEhOH36NN68eQMAcklIKlzt2rUxfvx4LF26VFj28uVLDB06FPXq1UOrVq3g7OyM9PR0PHnyBGfOnBFGPltZWWHo0KFYu3atsG1Rr7c6mJiYoE+fPvD39xeWHT58GK9evcKoUaPg5eUFCwsLAMCbN2/wzz//YMOGDXjy5AmA3BHrycnJwjmjjClTpuDs2bPCjzw5OTn44YcfEBwcjMGDB+P999+HiYkJsrOzERYWht27d2Pv3r2QSqUwNTWFp6en6LqhCUuWLEG/fv3w9OlTALl3QsyZMwc7duxA//794eXlhRo1aoh+TIqJicH9+/cRFhaGM2fO4Nq1a8jOzkbNmjU1Gquq3N3d4eHhIfxImJmZiX79+qFTp06oVasWrK2tRaPrnZ2di10qgpRT2A8nycnJovbt27cLXN/d3R0tW7ZUa2z5Xbx4UXjvy7p9+7aonZycXOjzGjhwoFpjIyIqLia3iYiIiDTIy8sLO3fuxMSJE0WTzeXk5CA4OFg0mZuVlRXMzMyQnJwsJEgVqVSpEhwcHDQZtlIkEglmzJiBIUOGiOINDAxEYGAgTE1NYW1tjaSkJNHkmgDg6emJ6dOn49NPP9V22CoxMzPD5s2b8eWXX+Lhw4fC8rS0NJw6darAkdGenp5YvHixXHkEZUb2+vj4IDU1FcuWLRNG36anp2PPnj3Ys2ePEJe1tTVSU1ORlpZW3KdHCowaNQrx8fFypTbCwsIKTMiamZlh+fLlciP61TWBbFHyRum/ePFCWHblyhVcuXIFRkZGKFeuHFJTU5Geni7azsbGBitWrMDYsWNV6s/e3h6rVq3CiBEjRIm7Y8eO4dixYzAyMoKtrS2SkpLkJjucPHmykEDWJHt7e2zcuBFjx44VjWp+8OABfvrpJwC51zAbGxtIJBIkJydrfWLGkhg9ejR++OEHoZ2amoq//vpL4US2Xl5eTG5rWN7dG8o4c+ZMgWVyvL29NZrcPnDgAPbv36/UunFxcYU+L0NJbut68m0i0jy+y4mIiIg0rHbt2jh48CDGjh0rV6Ykv5SUFMTFxRWY2La3t8fkyZNx8uRJuTq7utKkSRMsXrxYGBmaX2ZmJuLi4uQS240bN4a/v7+olII+q1ChArZv346+ffsqNRK3R48e2LFjB+zs7OQmerO1tVWqz5EjR2Ljxo2oWrWqwsczMjIQGxtbaGK7fPnynIyymH744QcsWrQI5cuXL3JdV1dX+Pv7o127dnKvd7ly5TQVooiDgwP++OMPuLi4yD2Wk5ODuLg4ucS2k5MTNm/eXOyJaZs0aYINGzbI1X/O6zM+Pl6ULJZIJJg4cSK++uqrYvVXHK6urti9ezf69OkjGqGdRyqVIjExEQkJCQUmtiUSCWrVqqXpUFX26aef4ptvvoGJCcerEeV59OiRqF2pUiU0atRIR9EQkbbwf0IiIiIiLbCwsBASO4GBgTh+/Dhu3bpV5EhBOzs7NGvWDJ9++ik6dOigtZGgqujevTtq1qyJ5cuXIygoqMBav9WrV8eXX36JAQMGwNjY2KAmwLKzs8P8+fMxZMgQ/PXXX/j3338RHR2NuLg4WFhYwNXVFc2aNUPv3r1Rv359Ybt3797J7UdZrVu3xokTJ/DXX39h9+7duHXrVqEj+gHAxcUFLVu2RKdOndCuXTsmvkrA29sbnTp1wrFjx3Dq1CmEh4cLI7OdnJxQt25ddO7cGd27dxfel7KTM2oruQ0ANWvWRGBgINasWYO9e/cWOKGpvb09Pv/8c4wePbrE8TVp0gTHjh3DypUrcfDgQaHkkCwvLy9MnDgRzZo1K1F/xWFpaYkFCxZg1KhR2LhxI4KDgxEdHV3oNmZmZnj//ffRtm1b9OjRo8AfmXRtzJgx6NmzJw4dOoRr164hPDwccXFxSEtLK7TmOlFpJVvqbOTIkXr5uYmI1Esi1bepn4mIiIjKiJSUFNy7dw/Pnj1DbGwsUlNTYWZmhnLlysHBwQGenp6oXr26rsNUSVxcHK5cuYKXL18iKSkJ5ubmqFixIurUqYMaNWroOjytio6Oxocffii07e3thYkmiyM1NRU3b95EVFQU4uLikJKSAisrK9jY2KBq1aqoUaOGwlG0pD3Dhg3D+fPnhfbvv/+Ojh07aj2O9PR0XL9+HeHh4UhISICRkRHKly+PmjVron79+gpHMZdUZmYmrly5gsjISLx79w5mZmaoXLkymjRpond3EEREROD+/fuIi4tDXFwcJBIJrK2tUaFCBbi7u8Pd3Z0JMSIDk5SUBC8vL2HQQKVKlXDq1Cm+l4nKAA7lICIiItIRKysrNGnSBE2aNNF1KGpjb2+Pzp076zoMvRAUFCRqN2jQoET7s7S01GgtViqZuLg4XL16VbSsYcOGOonF3NwcLVu21Or5YmpqilatWmmtv5Jwc3ODm5ubrsMgIjW6evWq6G64UaNGMbFNVEaw5jYRERERkZqlpaXB399ftKx169a6CYa0YvPmzaIa6J6ennB0dNRhREREZUf+kiSVK1dGnz59dBgNEWkTk9tERERERIXIyMhQaf3s7GzMmDEDT58+FZaZm5vD29tb3aGRBmRmZkLVyo1nzpzBunXrRMsGDBigzrCIiKgQ+ZPbHLVNVLYwuU1EREREVIilS5diwoQJOH/+fJETOt6+fRtDhw7F4cOHRcsHDBgABwcHTYZJavLo0SN8/PHH2Llzp9wEkbLi4uKwbNkyjB07VjSBX+XKldG7d28NR0pERACQnJyMO3fuAACqVKmCzz//XMcREZE2cUJJIiIiIqJCLFiwAFu2bAEAlCtXDo0aNULNmjVRoUIFWFpaIikpCS9fvsS1a9fw4MEDue1r1qyJffv2wdzcXNuhUzHcvXtXSEwbGRmhXr16qFOnDqpUqQJbW1tkZGQgNjYWt2/fxrVr10SlSPK2+fPPP+Hl5aWD6ImIiIjKFk4oSURERESkpISEBJw7dw7nzp1Tav06derg999/Z2LbQOXk5CA0NBShoaFKrW9hYYGFCxcysU1ERESkJSxLQkRERERUCFdXV5Vrd1pbW+Prr7/Gjh07ULlyZQ1FRppgY2MDZ2dnlbdr27YtAgIC0KNHDw1ERURERESKsCwJEREREVERkpKScO7cOaH0yIsXLxAbG4u0tDQYGxujXLlycHBwQP369dG8eXN06tQJdnZ2ug6biiknJwfXr1/H5cuXERoaiufPnyM6OhopKSnIzs6Gra0t7OzsUL16dTRr1gzt2rVD7dq1dR02ERERUZnD5DYRERERERERERERGRyWJSEiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgMLlNRERERERERERERAaHyW0iIiIiIiIiIiIiMjhMbhMRERERERERERGRwWFym4iIiIiIiIiIiIgMDpPbRERERERERERERGRwTHQdABERERGRoUlOTsbjx4/x7NkzxMbGIiUlBRKJBPb29nBwcEDt2rXh6uqq6zDLnMjISHTq1KnI9S5fvoxy5cppISLDFBsbi9DQUERFRSEhIQHZ2dmwtbWFo6Mj6tWrBxcXF12HWKbk5OTg9u3bePDgAWJiYiCVSmFvb48aNWqgUaNGMDU11XWIOqPJYzN27FgEBQUVus64ceMwfvz4YvdBREQlx+Q2EREREZES3rx5g/379+P06dMIDQ1FVlZWoes7OjqidevW6Nu3L7y8vJTqY968edi+fbvQ9vDwwLFjx0oUN+mWVCrF06dPcevWLYSGhiI0NBR37txBenq6aL379+/rKMJcGRkZ2L9/PwICAhAWFlboulWqVEGfPn0wcOBAlC9fXiPxDB8+HP/++6/c8qCgIFStWlUjfeqb5ORkbNy4Ebt27cK7d+8UrmNrawtvb2+MGTNGY69FSWnitSwtx4aIiEqOyW0iIiIiokK8fv0aq1evxr59+4pMaOf39u1bHDp0CIcOHUKNGjUwZcoUtGvXrtBt7ty5I2rXrVu3WDGTbiUnJ2PdunVCMjshIUHXIRUqNDQUU6ZMwePHj5Va/+XLl1i5ciW2bt2K2bNno3v37mqN5/DhwwqToWVJaGgoJkyYgJcvXxa6XmJiIrZs2YJDhw5h8eLF+PDDD7UUoXI08VqWlmNDRETqweQ2EREREVEBDh48iHnz5iEpKanAdUxNTWFtbY2MjAykpKQoXOfx48cYOXIkevXqhcWLFytcJycnR270LpPbJWNvb49vvvlGbrmFhYVG+42NjYWfn59G+1CXq1evYsSIEQWeu1ZWVjAxMUFiYiKkUqnosdjYWHzzzTdITExEv3791BJPfHw8Fi5cqJZ9GaqbN29i6NChCl8TMzMzGBkZIS0tTbQ8Li4OY8aMwcqVK5UqzaMNmngttXlsBg4ciLZt24qWnTlzBmfOnClW7EREpBlMbhMRERERyZBKpViwYAG2bt0q95iDgwN69uyJdu3aoV69eqLb3ePj43Hnzh2cPXsWhw8fxps3b0Tbvn79usA+IyIi5BI2TG6XjLW1NQYOHKjrMPRWQkICxo8fL3feNWjQACNGjECrVq1gZ2cHAEhLS8P169exfft2nDp1SrT+7NmzUadOHTRo0KDEMf36668FlpkoC2JiYuDr6yt6TUxMTDBo0CAMHDgQ1atXh0QiwcuXL7F37174+/sL62ZlZeG7775DYGAg3N3ddfUUBOp+LbV9bGQT20DuHTlMbhMR6RcjXQdARERERKRPpFIppkyZIpfYtrCwwKRJk3DmzBnMmDEDbdu2lavjamdnh1atWmHKlCk4ffo0Zs2aJSQHgcKT1Xfv3pVbVqdOnRI+G9IHVlZWaNasGb766issXboUEydO1HVIAIA//vhDLvnYv39/BAQEoFu3bqJz18LCAq1atcLq1asxb9480TY5OTlYtGhRieO5fPky9u3bJ7S7dOlS4n0amlWrVol+FDMzM8Pq1avx448/wt3dHUZGRpBIJHBxccHEiRPh7+8vep1SUlLU8lqUlCZey9JybIiISL2Y3CYiIiIiymfx4sU4ePCgaFn16tWxe/dujB49WumSFmZmZhg0aBCOHDkiTChZWHJbtt52lSpVYG9vr1rwpBcsLS0xYMAALFiwAIcOHcKVK1ewfft2TJ06FR9//DEqVaqk6xABAEePHhW1PT09MXv2bBgbGxe6Xf/+/dG3b1/RsitXriAqKqrYsWRkZGDWrFlC6ZO6deti0KBBxd6fIYqMjMSePXtEy8aPH48OHToUuE2jRo0wa9Ys0bIzZ87g+vXrGolRGZp4LUvLsSEiIvVjcpuIiIiI6P8dPXoUGzduFC1zd3fHtm3bUKtWrWLt08nJCZs3b8Ynn3yi0shtjto2XBUqVMDcuXPRp08f1KpVq8hksS5ERUXJTcg3YMAApWMdMmSI3LIrV64UO54//vgD4eHhAAAjIyPMnTsXRkZl6+uqv78/MjMzhXbVqlUxbNiwIrfr2bMnmjZtKlq2fv16tcenLE28lqXl2BARkfqVrU8LREREREQFePHiBWbOnClaZm9vjw0bNsDZ2blE+zYxMcGvv/4KDw+PAteRHbnNetukSbL14AGgYcOGSm/v6ekJKyurIvepjMePH+OPP/4Q2v3791cpltIiKChI1O7Tpw9MTJSbJkt2Qs/z588jNTVVbbEpS1OvZWk4NkREpBlMbhMRERERAfjpp5+QlJQkWrZo0SJUrVpVLfvPqwerSFRUFGJjY0XLOHKbNCknJ0duma2trUr7sLGxEbXzj6xVllQqxezZs4VtK1SogG+//Vbl/Ri6O3fuyI2k79Gjh9Lbf/TRR6Jkb1paGs6fP6+2+JShqdeyNBwbIiLSHCa3iYiIiKjMO3v2LIKDg0XLevToUWg9V3WSHbUNcOQ2aZaiut/x8fFKby+VSpGQkCBaVpw7HPbu3YvLly8L7SlTpqBcuXIq78fQXbx4UdR2dHRE9erVld7e0tIStWvXFi27cOGCWmJTlqZey9JwbIiISHOY3CYiIiKiMm/VqlWitqmpKaZOnaq1/mWT2/b29qhcubLW+qeyp2LFinIJQlUm2gsLC0NaWppoWZMmTVSK4d27d1i8eLHQbtGiBT799FOV9lFaPHr0SNRu0KCByvt4//33Re3Hjx+XJCSVaPK1NPRjQ0REmsXkNhERERGVaSEhIbh165ZoWe/evVGxYkWtxSA7mSRHbZM2DBgwQNTevn07MjIylNpWduJVLy8vVKtWTaX+f/75Z2G0uKmpKWbPnq3S9qVJ3gSMeVxdXVXeh+w2svvUJE2+loZ+bIiISLOY3CYiIiKiMi0gIEDUlkgkGD58uFZjYHKbdGHw4MGi2u7Pnj3D999/j/T09EK38/Pzw9GjR4W2qakpfvzxR5X6PnfuHP766y+hPXz4cNSoUUOlfZQmERERonaVKlVU3odsqZno6GikpKSUJCylaPq1NORjQ0REmsfkNhERERGVWenp6Th9+rRoWaNGjeDu7q61GOLj4/HixQvRMia3SRvMzMywbt061KxZU1h2/Phx9OrVC9u3b0d4eDjS0tKQkZGBly9f4siRIxg0aBCWLVsmrG9qaorFixerNAFqamoq5syZI7SrVq2KMWPGqOU5GSrZ+uWOjo4q78PJyanI/aqbNl5LQz02RESkHSZFr0JEREREVDpduHBBbvRely5dtBqDoskkVUkUEpWEs7Mz9u7dizVr1mDbtm1ISUlBREQE5s2bV+S29erVw5w5c9CwYUOV+ly9ejUiIyOF9qxZs2BhYaFy7KVFWloasrOzRcssLS1V3o+iY5icnFzsuJSh6dfSkI8NERFpB0duExEREVGZFRISIresQ4cOWo1BtiSJlZUV3NzctBoDlW0WFhaYPHkyfv/9d7z33ntFrm9vb4+FCxciMDBQ5cT2vXv34O/vL7S7du2Kdu3aqRpyqaKoPIaZmZnK+1GUwE1NTS1WTMrQxmtpqMeGiIi0h8ltIiIiIiqzQkNDRW0rKyutliQB5Edu16pVC0ZG/JhO2nPz5k30798fX375JR49elTk+nFxcZg2bRp8fHxw9epVpfvJycnBzJkzkZWVBSD3/TZ9+vRix11aKKpxbmpqqvJ+FCV909LSihVTUbT1WhrisSEiIu1iWRIiIiIiKrOePHkiausisczJJEmXdu7cifnz5wtJyjz16tVD8+bN4ezsDBMTE8TExCA0NBQhISHIzMwEkHvnw+DBgzFhwgSl6ixv374dt27dEtoTJkyQm+ivLDI3N5dblneMVZGRkaHUvtVBW6+lIR4bIiLSLia3iYiIiKhMysjIwNu3b0XLqlatqtUY0tLS5BLsytbbfvPmDXbt2oXz588jIiICSUlJsLOzg6urKzp16oS+ffvC3t6+RPEFBARg1qxZQtvLywtbt24tdJvMzExs374dhw4dQnh4OCQSCTw8PODt7Y0BAwbAxKToryDjxo3DqVOn0KBBAwQEBMDY2LhEz4MUO378OObOnQupVCos8/T0xIIFCwosN/Lq1SssXLgQJ06cAJA7gnf58uUwMzPD8OHDC+wrKipKNBFlrVq14OPjo6ZnYtisrKzklilKxhZF0UhkRfsuKW2+loZ2bIiISPuY3CYiIiKiMikpKUmU1AOAcuXKaTWG+/fvy02WpszI7V27duHnn3+Wu2X/7du3ePv2La5fv47Nmzdj4cKFxa6B+/LlS/zyyy8qbZORkYGvv/4aFy9eFC2/ffs2bt++jX/++Qe///57oQnuEydO4NSpUzA1NcX8+fO1mtg+dOiQ0pPMWVtbo1evXhqOSHMSExMxe/Zs0XugXr162LZtW6FJv8qVK2PlypWYPXs2du3aJSxftmwZ2rZtC09PT4Xb/fTTT8KxlUgkmDNnjlI/dBiCkp43FhYWMDY2Fl0LilMPWlEC19raWuX9FEWbr6WhHRsiItK+0vFpgoiIiIhIRYpG/9na2mo1Btl626ampqhZs2ah2/j7+2PhwoVCu0mTJvjoo4/g7OyMhIQEnDt3DkFBQXj37h3GjRuHdevWoVWrVirHNn36dCQnJ8PKykrhpG6K+Pn5CYnt5s2b4+OPPwaQm/y7du0azp49i3Xr1mHs2LEKt09ISMBPP/0EABg+fDhq166tctwlsXz5crx48UKpdV1cXAw6ub1v3z7ExcUJbWNjY/z2229Kj2adPn06zp07JxyvzMxMrF+/HosXL5Zb99SpU/j777+Fdp8+fdCkSZOSPQE9oo7zxtbWVvR6yN5Voow3b94o3K866eK1NJRjQ0REusGZaoiIiIioTLKxsZFbVpzb3UtCtt52jRo1FE58lufJkyei5OH333+PnTt3YujQoejRowcGDBiANWvWwM/PD6ampsjIyMDUqVNVHum4a9cu/PfffzAxMcHEiROV2iYnJwc7duwAALRq1QpbtmzBwIEDMXDgQGzbtg3NmzcHAGzdulVuxHyeX375BW/evIG7uzt8fX1ViplUExwcLGq3bt0aHh4eSm9vZmaGAQMGiJadPn1a7k4EAFi5cqXwt4ODA7777jsVoy39ZCeyffnypcr7iIqKErWdnZ3VPjpZF6+loRwbIiLSDY7cJiIiIqIyycbGBqampqLJyRISErQag+zI7aJKkmzdulWY+K9Dhw4YMWKEwvXat2+PkSNHYs2aNYiKisLWrVsxcuRIpWJ68eIFfv31VwC5o6eVrQEeERGB2NhYAMCXX34pmpjT2NgYw4YNw+XLlxETE4OIiAi5hNWlS5ewb98+SCQSzJ8/v9AkP5XcgwcPRO3ijL6V3SYpKQnPnj2Te23zl+yIjY1FixYtVO4rT6dOnURtZerAGwJ3d3dcv35daD9//lzlfURGRoraqvxYoSxdvJaGcmyIiEg3mNwmIiIiojLL2dlZVE7g8ePHWus7KytLLsFYVHL7v//+E/7+/PPPC123T58+WLNmDQDg4MGDSiW3pVIpfvzxRyQnJ8PDwwPjxo0TJZUKk5fYBoBq1arJPZ5/WWxsrCgBmpaWhpkzZ0IqlWLAgAFo1qyZUn2q2+nTp3XSry7I/pBToUIFlfehaJv85SPKCnWcN++9956oHRoaqvI+bty4IWrXqFGjJCHpDR4bIiIqDMuSEBEREVGZJZtEDQsLk5ukUVPCw8Pl+ipqlHT+W+uLGnlYpUoVWFhYAAAePXqEZ8+eFRnTzp07cfHiRRgZGak8ejp/reb8iW5Fy2TrOq9atQpPnz5FxYoV8f333yvdJxWf7GugaMK9oijaxtLSstgxlWUtW7YUtd++fYunT58qvX1qairu3bsnWlacWvv6iMeGiIgKw5HbRERERFRmtWrVCgcPHhTaGRkZOHz4MPr06aPxvmVLkkgkkiInUCyoVrUy7t+/r3BEdZ7IyEihnvegQYPQtGlTlfbv5uYmlHn5+++/5X44OHXqFIDcSTPd3NyE5Xfu3IG/vz8AYNasWQproZP6lS9fXjR6W5VkYZ4nT57ILXNwcJBb9s0334jKWSgrIiJCODfy78ve3l5oOzs7q7xffVSvXj1UrlwZr169EpYdPXoUY8aMUWr7kydPikosmZubo02bNmqPUxevpaEcGyIi0g0mt4mIiIiozOrcuTPKlSsnSvKtX78ePXv2FEY9F9fLly9x/fp1fPzxxwofl51Msnr16kUmdp2cnIR6s0+ePCn01vpXr16JRtY+fvwYXbp0UbhuXjmSlJQUuLi44Ntvvy00DkUsLS3RsWNHnDhxAtu2bUOlSpXQs2dPALllUfImm+zUqZNwbLOzszFjxgxkZWWhW7du6Ny5s8r9UvHUrVsXERERQjs4OBg//vgjTEyU/4qY94NFngoVKihMUPbq1atYMV66dEkuIfrJJ5+gatWqxdqfvuvcubOo5vTevXvx9ddfK/Wa7N69W9Ru3bq13Oh8ddDVa2kIx4aIiHSDZUmIiIiIqMyytbWFj4+PaFlERATmzJlT7FHSWVlZ+PPPP/HJJ58gNTW1wPVkR24rM3Fj8+bNhb8DAwMLXXffvn2idnx8fIHr7tixA5cuXQIA/PTTT8VO/Hz//fewt7dHZmYmFi5ciDZt2qBNmzb49ddfkZmZCQcHB/zwww/C+ps2bUJYWBjs7Owwc+bMYvVJuS5duoRatWqJ/hV2jnzwwQei9suXL7Ft2zal+7tx4waOHz8uWta6dWtIJBLVAtcwHx8f0THp2LGjrkMq0JdffglTU1OhHRkZiU2bNhW53ZEjR3DlyhXRsq+//lqpPlU9b3RFF8eGiIgMA5PbRERERFSmDRs2TFQmAwD2798PX19fhbWjC5KSkoKAgAB069YNP//8M5KSklCvXr0C15etAVvUZJIAMGDAAOHvoKAguZGQec6ePQs/Pz/RsoJKCTx//hy//fYbgNxJKktyu76rqyt27NihsKSJl5cXdu7cCRcXFwDAs2fPsHr1agDADz/8AEdHRwC59XTnz5+Pjh07on79+mjVqhXGjx+PsLCwYsdF8nr06AEnJyfRssWLF+Pw4cNFbnvr1i34+voiJydHtFz2hyJSjaurq9xEsatXr8aZM2cK3ObWrVuYN2+eaNmHH36oclkhfcdjQ0REBWFZEiIiIiIq02xsbLB27Vr069cPSUlJwvKgoCBcuHABffr0Qbt27dCoUSPY2toCyC3jERcXh6ioKISEhODixYu4ePEiUlJShO3NzMzw3nvvKezz+fPnolIogHIjtxs1agQfHx/h9vyFCxfi5MmT6Nq1KypWrIiEhAT8+++/OHXqFKRSKapVqyZMJKloRG3+ciROTk6YOnVqkTEUpUaNGtixYwdevHiBJ0+eQCKRwMPDA5UrVxatN3PmTKSlpaFVq1ZCjfOIiAj4+Pjg9evXAHLrNyckJODkyZMIDg7G8uXLDaZ0SWhoKG7fvq3wsRs3bsgt27lzZ4H7+uSTT9Rei9zS0hKTJk3Cjz/+KCzLysrCd999hyNHjmDgwIFo2rSp0G9GRgZCQ0Nx8OBBBAYGimoY58XYqFEjtcZYFk2YMAFBQUF48+YNACA9PR2+vr4YNGgQvvjiC1SvXh0SiQQvX77E3r17sXnzZtF1x8rKSi3vY33EY0NERIowuU1EREREZV6NGjXg7++PCRMm4OXLl8LylJQUbNmyBVu2bAGQOxmitbU1EhMTkZ2dXeg+PT09RbfR5ydbbxtQbuQ2AEybNg2mpqbYvHkzpFIprl69iqtXr4rWMTY2xoQJExATE4M///wTAEQTt+XZtm0bQkJCAABz5sxBuXLllIpBGS4uLsIobVl79uzBxYsXYWFhIRpZ+d133+H169d47733sHLlStSoUQPx8fGYPn06Tp06hSlTpuDEiRPCKG99dubMGWFkujLmzJlT4GNt27bVyESbn3/+OR49eiRX3iE4OBjBwcEAAGtraxgbGyMxMbHAUj2NGzfG/Pnz1R6fJuhb2RRZFSpUwKpVqzBs2DAhMZtX6ujPP/+EmZkZjIyMRPX08xgbG+PXX38ttBa/IeOxISIiRViWhIiIiIgIQIMGDRAYGIgePXrAyEjxx+TMzEzExcUVmtg2NjbGhx9+iO+++67AdWTrbTs7O6NChQpKxWlsbIwpU6bg0KFDGDRoEDw9PWFtbQ1TU1O4uLjgs88+w+7duzF69GjExcUJ28kmhJ89e4YlS5YAALp37661EdFv3rzB4sWLAeSOxKxWrRoA4MqVKwgNDQWQm+jNS0LZ2dlh4cKFsLGxQVJSEvbs2aOVOMuKKVOmYM6cOQXWWU9OTkZCQkKBie0BAwZg06ZNJZ6AVVMeP34sanft2lVHkSivcePG+PPPP1GpUiW5xzIyMhQmb+3s7LB27doCJ40tLXhsiIhIFkduExERERH9PwcHByxbtgzjx4/Hn3/+iXPnzuHFixdKbefl5YXWrVujY8eOcHZ2LnR92ZHbyo7azs/T0xOzZs0qdJ2HDx8Kf8uWjDh06JAw4aWjoyPWrl2rcB+RkZHC3y9evBCtN2LECJiZmakU908//YT4+HjUq1cPQ4cOFZbnTWjp5OQkmjgTyJ3488MPP8TRo0cREhKCMWPGqNQnFW7gwIHo2LEjAgICcODAgSLPeRsbG3z00UcYNGhQoXXlde3Ro0d49+6d0LaysjKYyQQbNmyII0eOYMOGDQgICEBMTIzC9WxsbODt7Y0xY8Yo/QOZoeOxISKi/CTS4k4DT0RERERUBrx48QJ3795FbGws4uPjkZmZCWtra9jY2KBKlSrw8PAoMpmtCzExMWjbti2ysrJgY2ODixcvisqkrFq1SqWyGYpcvnxZpVImf//9N3x9fWFiYoK9e/eK6ozPmjULAQEBaNiwocLR2b/++is2btwIDw8PHDt2TOH+IyMj0alTJ6Ht4uKC06dPq/CMCACioqJw+/ZtvH37FgkJCcjJyYGtrS3s7e1Rq1YteHh4FHh3gz7Zvn27qOzN8OHD8cMPP+gwouLJzs5GWFgY7t+/j5iYGEilUtjb2+O9995Dw4YNVf6BqTTR9rGRvW6OGzcO48ePV2sfRESkGo7cJiIiIiIqRGG1o/XZ/v37kZWVBQDw9vYusP63tiQmJmLu3LkAgGHDhhU4gWb+CeCUWU7qV6lSJYVlHwzN5cuXhb+trKwwYsQIHUZTfMbGxmjYsCEaNmyo61D0Do8NERExuU1EREREVMrkLx9iYWGBL7/8Um6d8ePHKzXi8NKlSxgyZAgAwMvLC1u3bi1WTIsXL8br16/h5uaGcePGyT1esWJFALmjr5OTk2FtbS16/MGDBwBQKpKupB35k9tffPEFypcvr8NoiIiISBOY3CYiIiIiMiD37t1DpUqVYG9vr/Dxu3fvYvz48UhKSgIATJ48Ga6urlqMUN7ly5exe/duSCQSzJs3D+bm5nLreHl5AQDS0tKwfft2jBw5Unjs+vXruHr1KgDI1eMuzIsXL1CrVi2F8ahSToUMz+PHj/H27VsAuaO2hw8fruOIyNCMHTsWQUFBug6DiIiKwOQ2EREREZEBOXbsGDZt2oSWLVuicePGqFq1KkxMTPD69WtcvHgR//zzD3JycgAAQ4YMgY+Pj07jTU9Px4wZMyCVStGvXz+0aNFC4XrNmzdHvXr1EBYWhuXLl+P169do0qQJIiMjsXHjRgCAtbU1+vbtq83wyUCFhIQIfw8aNIijtomIiEopJreJiIiIiAxMRkYGzp49i7Nnzyp83NbWFhMnTtR5YhsA1qxZg4iICDg5ORU5md/ixYsxZMgQvH37Flu3bhWVQDE1NcXChQvh5OSk6ZCpFBg4cCAGDhyo6zCIiIhIw5jcJiIiIiIyIH369IGDgwNCQkLw+PFjxMTEIDU1FeXLl4ebmxs6dOiATz/9VC9Gqt67d08YdT1r1izY2toWun6NGjUQGBgIPz8/nDlzBm/evIG1tTW8vLwwatQo1K9fv9Dt7e3tMWfOnCLjsrCwUPo5EFHZNHDgQLRt27bQdYq6JhERkeZJpFKpVNdBEBERERERERERERGpwkjXARARERERERERERERqYrJbSIiIiIiIiIiIiIyOExuExEREREREREREZHBYXKbiIiIiIiIiIiIiAwOk9tEREREREREREREZHCY3CYiIiIiIiIiIiIig8PkNhEREREREREREREZHCa3iYiIiIiIiIiIiMjgmOg6ACJDEBsbq+sQFJJIJLC3twcAxMXFQSqV6jYgMig8f6ikeA5RSfD8oZLg+UMlwfOHVGV09y7s2rQpdJ348+eRU6eOliIiQ8ZrEJVEaTh/HBwc1Lo/jtwmIiIiIiIiIiIiIoPD5DYRERERERERERERGRyWJSGNycjIwNWrV/HixQvExMTA3t4elSpVQrNmzWBlZaWWPuLi4nDt2jVERUUhKSkJzs7OqFq1Kpo0aQIjI/52Q0REREREREREVFoxuW3gkpOTcefOHdy6dQu3bt1CaGgoXrx4ITzu4uKC06dPazWmpKQkrFixAocOHUJcXJzc41ZWVujWrRsmT54MR0fHYvURERGBJUuWIDg4GJmZmXKPOzs7o3///hg5ciTMzMyK1QcRERERERERERHpLya3DdTmzZsRGBiIR48eIScnR9fhCO7cuYPx48cjMjKywHVSUlIQGBiIf/75B0uWLEGrVq1U6uPQoUOYPXs2UlJSClzn9evXWLVqFU6fPo1Vq1bBxcVFpT6IiIiIiIiIiIhIvzG5baAuX76MBw8e6DoMkVevXmHkyJF48+aNsMzOzg4dOnRApUqV8ObNG5w9e1Z4/N27dxg7dix27dqFWrVqKdXH2bNnMXXqVGRnZwvL3Nzc0KJFC9jb2+PZs2cIDg5GWloaACAsLAyjR4/Gzp07YWNjo8ZnS0RERERERERERLrE5HYpYmVlhXr16iEsLKzQUc2aIJVKMXHiRFFiu2fPnpg3bx6sra2FZRkZGViyZAn8/f0B5I7i9vX1xdGjR4ssH/LmzRt8++23QmJbIpFgypQp+PLLL0X1tWNiYjBx4kSEhIQAAB48eIDZs2djyZIl6nq6REREREREREREpGOccc9AmZubo2HDhhg0aBAWLVqEv/76C1evXsW2bdvg4OCg9XhOnjyJmzdvCu3WrVvjt99+EyW2AcDMzAzTpk3DZ599Jix7/vw5du3aVWQffn5+SExMFNrjx4/HV199JTdxZPny5bFhwwbUqFFDWHbkyBHcu3dP5edFRERERERERERE+onJbQO1bNky7NmzB7NmzYK3tzdq1qwpl+TVpt9//13428jICHPmzIFEIilw/alTp4rKhKxbtw5ZWVkFrv/u3Tvs3r1baFerVg0jR44scH1zc3PMnDlTaEulUqxdu7bI50FERERERERERESGgcltKrGnT5/i7t27QvuDDz5A9erVC93Gzs4OH3/8sdB+8+YNrly5UuD6QUFByMjIENr9+vWDqalpoX20atUK7u7uQvuff/5BampqodsQERERERERERGRYWBym0osKChI1P7oo4+U2q579+6F7ie/06dPi9rdunVTqo/866WlpeH8+fNKbUdERERERERERET6jcltKjHZEdeNGzdWarsGDRrA2Ni4wP0U1IejoyNcXV2V6kM2lsuXLyu1HREREREREREREek3JrepxB4/fiz8bWFhAQ8PD6W2s7GxQbVq1YT2kydPIJVK5dZ7/fq1aCLJOnXqKB1b3bp1C4yViIiIiIiIiIiIDBeT21QimZmZiIyMFNqVKlUqdCJJWVWqVBH+Tk1NxcuXL+XWCQ8PL3Cbojg6Oopqc8vui4iIiIiIiIiIiAwTk9tUIu/evUNWVpbQrlSpkkrbV6xYUdSOioqSWyc6OrrQbQojkUhE68vui4iIiIiIiIiIiAyTia4DIMOWnJwsaltbW6u0vez6KSkpGu0jKysLGRkZMDMzU2kfqoxG16b8celrjKS/eP5QSfEcopLg+UMlwfOHSoLnD6lKmfNEIpHwfCKl8BpEJcHzRx6T21Qissloc3NzlbaXXV9Rcjs1NVWtfSQnJ6uc3La3t1dpfV2ws7PTdQhkwHj+UEnxHKKS4PlDJcHzh0qC5w8ppVw5JVYpBxjA90bSL7wGUUnw/MnFsiRUIunp6aK2qklj2fXT0tLk1pFdVtI+ZGMmIiIiIiIiIiIiw8OR21QisonjzMxMlbbPyMgQtRWNypZdVtI+VE2OA0BcXJzK22iDRCIRfqmLj4+HVCrVcURkSHj+UEnxHKKS4PlDJcHzh0qC5w+pyighAUWN3U5ISECOnn5vJP3CaxCVRGk4f9RdHYHJbSoR2frXikZeF0Z2FLWVlZXcOrLLStqHqjW7ARjExUIqlaolThMTExgbG0MikUAqlSI7O1s0aSiVTuo6f6js4jlEJcHzh0qC5w+VBM8fUoYy5wjPJSoOnjdUEjx/cjG5TSUim3hWVDO7MLKTRSqT3C5JHyYmJirX7C4LJBIJzM3NYWRkBHNzc7x9+xZJSUmwsbGBo6Mj0tLSIJVKkZ6ezgsnERERERERERHpBdbcphKpUKECTEz+9xvJq1evVNo+Ojpa1K5UqZLcOhUrVhS1o6KilN6/VCoV9SG7LwKMjY1hZWWFrKwsrFmzBp6ennBycoK7uzucnJzg6emJtWvXIisrC1ZWVjA2NtZ1yERERERERERERExuU8mYmZmhatWqQjsqKkqlkb0vX74U/rawsICLi4vcOh4eHgVuU5S3b9+KanS7u7srvW1ZkJfY/vvvv1GlShVMnjwZDx8+FK3z8OFDTJ48GVWqVMHff//NBDcREREREREREekFJrepxPInn9PS0hAeHq7UdklJSXj27JnQdnd3h0QikVuvYsWKsLW1Fdp3795VOrY7d+6I2jVq1FB629JOIpHAwsICJ0+eRK9evZCUlFTo+klJSejVqxdOnToFCwsLha8VERERERERERGRtjC5TSXWrFkzUfv69etKbXfr1i1kZ2cXuJ/8mjZtKvz99u1bPH/+XKk+rl27Jmo3b95cqe3KAnNzc6Snp6N///6i16Ew2dnZ6NevH9LT02FmZqbhCImIiIiIiIiIiArG5DaVWMeOHUXt48ePK7Wd7HqdOnVSuo9jx44p1ceJEyeEv83NzdGmTRultisLjIyMsH79+iJHbMtKSkrChg0bWJqEiIiIiIiIiIh0isltKjF3d3fUqlVLaJ8/fx5Pnz4tdJv4+HgcPXpUaDs6OhY6qrpTp04wNTUV2nv27BHV0lbkwoULePLkidBu164drKysCt2mrDAxMYG5uTn8/PyKtb2fnx/Mzc1Fk4kSERERERERERFpE5PbpFCtWrVE/4oyZswY4e+cnBzMmTOn0IklFy1ahMTERKH99ddfF5oodXR0RN++fYX2s2fPsG7dugLXT09Px/z584W2RCIRxVjWGRsb4+3bt3KTRyrrwYMHePfuHSwsLFh/m4iIiIiIiIiIdILJbVKLbt26oUGDBkL7v//+w3fffYfk5GTRehkZGVi4cCECAwOFZS4uLhg4cGCRfYwePRrW1tZCe9WqVfD390dOTo5ovZiYGIwYMQKPHj0SlvXo0QN169ZV+XmVVhKJROVyJLJiY2MREhKCrKwsWFlZsUwJERERERERERFpFWsKGKgXL16gS5cuCh/LPzngixcvCkzq+vv7w8vLSy3xSCQSrFixAn379sW7d+8AAH/99RfOnTuHjh07omLFinj79i3++ecfvHnzRtjOysoKa9euhbm5eZF9VKxYEUuXLsWYMWOQk5MDqVSKhQsXYufOnWjZsiXs7e3x9OlTBAcHIy0tTdjuvffew7x589TyPEsLqVQKGxubEu3DxsYGq1evRrdu3RAQEICuXbsiJSVF6ckpiYiIiIiIiIiISoLJbQMllUqVTiIWtF5hZUOKw8XFBevWrcOECRPw4sULALm1tffv369wfQcHByxZsgS1a9dWuo/27dtj4cKFmDNnDlJTUwEAERERiIiIULh+nTp1sHr16hInckub7OxsODo6ombNmsUqTeLp6YlKlSrh/v37SEpKQq9evXD48GF06tQJKSkpaj+3iIiIiIiIiIiIZLEsCalV/fr1cfDgQfj4+MDOzk7hOpaWlujduzcOHz6MNm3aqNxH7969ERgYiM6dO4smmczPyckJvr6+2L17N6pWrapyH6VdVlYW0tPTMXr06GJtP3r0aERERODkyZMAcpPl/fr1Q3p6OszMzNQZKhERERERERERkUISKYdYkoZkZGTgypUrePHiBWJiYmBnZ4fKlSujWbNmotrZJREbG4tr164hKioKycnJcHR0hKurK5o0aaLWGtCxsbFq25c6SSQS2NvbAwDi4uJUGjFtYWGBrKwsVKlSRaX62zY2Nnj+/DkWLVqEX375RfTY0qVLMXbsWKSkpCi9P1WYmJjA2NgYEolEuHshKytLI32VBSU5f4gAnkNUMjx/qCR4/lBJ8PwhVRndvQu7IgZmxZ8/j5w6dbQUERkyXoOoJErD+ePg4KDW/bEsCWmMmZkZWrdurdE+HBwc0KlTJ432UVqlp6fDysoKAQEB6NWrl1JlboyNjbFr1y5kZmZi48aNco/7+flh0qRJyMjIUFvSWSKRwNzcHEZGRjA3N8fbt2+RlJQEGxsbODo6Ii0tDVKpFOnp6QZ5USciIiIiIiIiouJhWRKiMkoqlSItLQ1du3bFoUOHiqxLbmNjg8OHD6Nbt27IysrCiBEj4OjoKFrnwYMHePfundpGzRsbG8PKygpZWVlYs2YNPD094eTkBHd3dzg5OcHT0xNr165FVlYWrKys1Dpan4iIiIiIiIiI9BuT20RlWHZ2NlJSUtC5c2e8fPkSS5cuRc2aNUXreHp6YunSpXj+/DmaNWuGgQMHYufOnfjhhx9w9+5dtGzZUrR+UlISJBJJiWPLS2z//fffqFKlCiZPniw3+eXDhw8xefJkVKlSBX///TcT3EREREREREREZQiT20RlmImJCUxMTJCdnQ1zc3P4+vriwYMHePPmDR48eIBXr17h/v378Pb2xqJFi1C3bl3s2bMHkydPRrVq1XDhwgWcPn1alOC2sbEpcXkQiUQCCwsLnDx5Er169SqyJnhSUhJ69eqFU6dOwcLCQi3JdSIiIiIiIiIi0m+suU1UxhRVwzolJQWXLl3CrVu3EB0djfv37+PkyZPIyckR7ScpKQne3t44cOAADh8+jDp16qB8+fKoUKECEhMTSxSjubk50tPT0b9/f6VqgQO5o9D79euHly9fwszMDOnp6SWKgYiIiIiIiIiI9BtHbhOVIcrUsPbz80Pr1q3x9ddf49KlSzh+/LhcYjtPdnY2Bg4cCBMTEwwfPhyjR49Genp6iSeTNDIywvr164scsS0rKSkJGzZsYGkSIiIiIiIiIqIygMltojJClRrWBZUcUSQpKQmbN2/GmDFjMGLECKVHWhfExMQE5ubm8PPzK9b2fn5+MDc3h4kJb0whIiIiIiIiIirNmNwmKgOKU8Pa29sbQUFBOHz4MBwdHQtd38/PD//H3r3HR1Xf+eN/nXMmc2YmZyCQCZdRgYiZCN3qeqFC3VaXhAi2RqMtEdv+LDXogLUtTVftblvrbreVds1+qxJHCUu73arBqjTxAiFgtbrQYtHWKiRRDBdzgQkBZjKZMzlnzu8PdqZMrnMLyYTX8/HwIWdyLp8DH4aZ13zm/Z49ezYsFgtCoVBKY5UkCV6vd0DwHq/m5mZ0dXVx9TYRERERERER0QTHcJvoHJBsDeszS44MJxIo67qelmaSiZYj6c/v97OpJBERERERERHRBMdwm+gckEoN602bNsHtdkMUh3+68Pv9KQfbAGAYBhRFSekciqKkZSxERERERERERDR+MdwmmuDSUcN6zpw5KCkpGXa/dAXKuq7D4XCgoKAgqeNdLhdyc3NTrv1NRERERERERETjG8NtogkuHTWsOzo6UFhYOOQ+8QTKkZDdYrEM2/BR0zSoqgq3253UeN1uN1RVhaZpSR1PRERERERERESZgeE20QSXjhrWPp8Pdrt9yJ8PFShHGlnabDbY7XYEAgF0dnYiEAjAbrfDarXCYrEMqI8dDoexatWqhMuTKIqCiooKrtomIiIiIiIiIjoHMNwmmuDSUcPabrfD5/MN+rOhAmVJkmCz2aBpGtavXw+Xy4W8vDzk5+cjLy8PLpcL1dXV0DQNNpsNkiRFj1VVFbIso7a2Nubx4UiShM2bN0OWZYRCoeRvloiIiIiIiIiIMgLDbaIJLh01rGfMmIGmpqYBPxsqUI4E242NjXA6naisrBxQFqWlpQWVlZVwOp1obGyMCbgNw0AwGERJSQnq6upGDOcVRUF9fT2WLFmCYDDIZpJEREREREREROcAhttEE1w6ali3traioaEBoihi6dKl+Na3voV//dd/xbvvvouSkpKYQDlSiqShoQGlpaUjlkQJBAKorq5GS0sLbDYbLBYLTCYTdF1HIBBAcXEx2traUFVVNSCgd7lcqKqqQltbG4qKihAIBFiShIiIiIiIiIjoHCEYXOJINKLu7u6xHsKgBEFATk4OAODEiRNDrli2WCzQNA1OpzOh+tuKouDw4cN49NFHEQgE4Ha7MXv2bBw9ehSBQACKosDhcETD7Ug5kXiu5XA4UFFRET1ne3s7VFUdcM5QKISsrCyIogiLxYKuri74/X4oioLc3Fyoqgpd1xEKhbhiO0Hxzh+ioXAOUSo4fygVnD+UCs4fSpS4bx8mX331sPucfPNNhOfNO0sjokzG5yBKxUSYP1OmTEnr+bhym+gckEoNa0VRcN999+G73/0unnvuObhcLkyfPn3Y2tkbNmwYNthetGgR9u3bh3vvvTd6TqfTOeg5rVYrNE1Db28vfD4frFYrpk2bBqvVCp/Ph0AgAFVVM/IJnYiIiIiIiIiIksdwm+gckEoNa0EQ0NjYiPPOOy+u2tmSJGH37t1DnnvRokXYsWMHdu3ahVmzZiVUjztSYiUYDEJVVWialvxvChERERERERERZTSG20TniGRqWIfDYWzbti2u2tl+vx+lpaVoaGhAdXU1HA7HgH0cDgfq6urQ2NiIsrKyuM+5fft2WCwWCIKQ+I0TEREREREREdGEZBrrARDR2RMJuM1mM1avXo21a9cOWcNa13Vomoaamhrcc889UBQFfr8f+/fvR0NDA8Lh8KDnX758OQ4fPow77rgD69ati/l5RUUFJEnCbbfdFnfjx8g529raYDaboapqWn4viIiIiIiIiIgoszHcJjrHRBo/AkBfXx+sVitsNhsMw4DP54OmaRAEAYqiIBgM4vnnn0d7ezt8Ph/sdjtmzpyJ1tZWPPHEE6ipqYHX6405v9/vx6ZNm+B2u/Gzn/0sGoKLogi3241NmzYl1NQycs6amhqsWbMmPb8JRERERERERESU8ViWhOgcNlgNa0mSkJ2djd7eXmzatCna7LGwsBBOpxMulwvPP/887r33Xuzbtw8LFy4ccF6Px4M5c+agpKQk+lhJSQlmz54Nj8eT1Fg9Hg9kWYbJxM/kiIiIiIiIiIiI4TYRnUGSJNhsNmzfvh1Op3PYZo+zZs3Crl27sHPnzgEBd3NzMzo6OlBYWBh97OKLL0Z7e/uA88WrubkZXV1dkCQpqeOJiIiIiIiIiGhiYbhNRAAAQRBgsVjQ0NAQdwPJsrIy7NixA/X19QMaSEbKmEQoigKfz5fSGP1+P5tKEhERERERERERAIbbRPR/ZFmGqqooLy9PqNnjihUrYDKZcMcdd8T8bMqUKejp6Ylu+/3+mLA7GYqiwDCMlM5BREREREREREQTA8NtIgJwuuHjhg0bkmr2GGkgKYqnn1JcLhccDgdWrFgBRVEAAPv378fMmTNRUFCQ1PhcLhdyc3PjDt6JiIiIiIiIiGhiY7hNRDCZTJBlOaVmj2c2kHS73VBVFZdeeina2tpQVVWFjz76CAcPHoTb7U7qGpFzapqW1PFERERERERERDSxMNwmIkiSBK/Xm1Kzx0gDSUVRUFFRAV3XEQgEIEkSVq9ejf3798PhcKCioiK6mjteZ56TiIiIiIiIiIgIYLhNRDjdTDLRciT9+Xw+TJ48GZs3b4YsywiFQjAMA6qqore3Fz6fD4IgwGq1ora2FpIkxXVeSZJizklERERERERERAQw3CYiAIZhJLyauj+73Y5bb70VS5YsQTAYHND4UdO0aNBdUlKCurq6Ea+pKArq6+uHPCcREREREREREZ27GG4TEXRdh8PhSKnZ44wZM3DRRRchEAgMWz4kUq6kuLg4Wo+7/3VdLheqqqrQ1taG4uJiaJqGrKwsyLIMk8mU1BiJiIiIiIiIiGhiYbhNRNFV1ak2e+zp6YmrLnb/etzNzc3wer1obW2F1+tFU1MT7rnnHpjNZmRlZcHv96OzsxOBQAB2ux1WqxUWiwWCICQ1XiIiIiIiIiIiynwMt4kIABAOh7Fq1aqUmj0mUjakfz1uq9WKadOmITs7G319fejt7cX69evhcrmQl5eH/Px85OXlweVyobq6GpqmwWazxV27m4iIiIiIiIiIJhaG20QEAFBVFbIsj0mzx8jK8b6+PphMJmzfvh1OpxOVlZVoaWmJ2belpQWVlZVwOp1obGxkwE1EREREREREdI5iuE1EAE6vpA4Gg2PW7FEQBFgsFjQ0NKC0tBR+v3/Y/f1+P0pLS7F9+3aWKCEiIiIiIiIiOgcx3CaiqESbPRYVFY3YQDJesixDVVWUl5fHfT5d17F8+XKoqgqz2ZzyGIiIiIiIiIiIKHMw3CaiGPE0e1yzZg0kSUpbsA0Aoihiw4YNI67Y7s/v96OmpoalSYiIiIiIiIiIzjEMt4logKGaPVqtVvh8PgQCAaiqmnIpkgiTyQRZluHxeJI63uPxQJZlmEymtIyHiIiIiIiIiIjGPyZBRDQsTdOgadqoXkOSJHi93gHNI+PV3NyMrq4uWK3WUR8rERERERERERGND1y5TURjThCEhMuR9Of3+9lUkoiIiIiIiIjoHMJwm4jGnGEYUBQlpXMoipK2MilERERERERERDT+MdwmojGn6zocDgcKCgqSOt7lciE3NzdtzS2JiIiIiIiIiGj8Y7hNRGNO0zSoqgq3253U8W63G6FQCCaTiaVJiIiIiIiIiIjOEQy3iWhcCIfDWLVqVcLlSRRFwcqVK/GHP/wBmqbBZrNBkqRRGiUREREREREREY0XDLeJaFxQVRWyLKO2tjbucFqSJDz99NPo6+vDzTffDKfTicbGRmRnZ8NkMg16jMlkgizLsFgskGV5yP2IiIiIiIiIiGh8Y7hNROOCYRgIBoMoKSlBXV3diCu4FUXBli1bUFRUhNLSUni9Xvj9fpSWlqKhoQEWiyUaXAuCAIvFApvNBrvdjkAggM7OTgQCAdjtdlitVlgsFpY0ISIiIiIiIiLKIAy3iWjc0HUdgUAAxcXFaGtrQ1VV1YAmky6XC1VVVTh8+DCuuuoqLF68GLt37445x/Lly9Hb2wubzQaz2QybzQZN07B+/Xq4XC7k5eUhPz8feXl5cLlcqK6uZkkTIiIiIiIiIqIMw3CbiMaVSMAtSRLuvvtuNDc3o729Pfr/pqYmlJWV4aGHHsL8+fNjgu0Iv9+PjRs3IhAIwGw24/XXX4fT6URlZSVaWlpi9m1paUFlZWW0pAkDbiIiIiIiIiKizMBis0Q07hiGAV3XYbPZUFFRAUVRYLfb4fP50NTUhIaGBoTD4WHP4fF4sHbtWgQCAezcuRN+v3/Y/SMlTerr61FUVIRAIADDMNJ5W0RERERERERElEYMt4loXJIkCV6vFxs3bkzq+ObmZnR0dGD//v248847sW7duhED8UhJk7a2NpjNZqiqmtS1iYiIiIiIiIho9LEsCRGNS4IgjLjaeiQ+nw9//vOfMWfOHJSUlMR1jN/vR01NDUuTEBERERERERGNcwy3iWhcMgwDiqKkdA673Y6PPvoIHR0dKCwsjPs4j8cDWZZhMvHLLURERERERERE4xXDbSIal3Rdh8PhQEFBQVLHu1wuzJgxA01NTfD5fLDb7XEf29zcjK6uLq7eJiIiIiIiIiIaxxhuE9G4pGkaVFWF2+1O6ni3243W1lY0NDREm1Emwu/3QxCEpK5NRERERERERESjj+E2EY1b4XAYq1atSrg8iaIoWLlyJTweDy666KLoCu5Ez2EYRkLHEBERERERERHR2cNwm4jGDZPJBFmWYbFYIMsydF2HLMuora2Nu0SIJEl4+umn0dfXh40bN8as4I6Xy+VCbm4udF1P9laG1P8eWdebiIiIiIiIiCg5DLeJaEwJggCLxQKbzQa73Y5AIIDOzk4EAoHo6unrrrsOdXV1I67gVhQFW7ZsQVFREUpLSxEMBqMruMPhcNxjcrvdUFUVmqalensAhr9Hu90Oq9UKi8XCMihERERERERERAlguE1EY0aSJNhsNmiahvXr18PlciEvLw/5+fnIy8uDy+XC+vXroaoqlixZgo8//hhVVVUDmky6XC5UVVXh8OHDuOqqq7B48WLs2bMHmzdvjq7gjpeiKKioqEjbqu147rG6uhqapsFms7GJJRERERERERFRnASDRWUnjBMnTmDv3r3o6OiA3+/HtGnTcP755+Pyyy+HKPJzjFR0d3eP9RAGJQgCcnJyAJz+88+kv86R0LehoQHl5eXw+/1D7qsoCnbs2IErr7wSPT09sNvt6OjogM/ng91ux4wZM9Da2gqPx4ONGzciGAxi8+bNKCkpwR/+8Ad89rOfjSusliQJ9fX1KCoqQiAQSPn3M9F7rK2tRUlJCQKBwKiUROkvk+cPjQ+cQ5QKzh9KBecPpYLzhxIl7tuHyVdfPew+J998E+F5887SiCiT8TmIUjER5s+UKVPSej4We50AWltb8fDDD+PVV19FX1/fgJ9PmzYN5eXluPPOO2E2m9N+/fvvvx8vvPBCyucpKyvDQw89NOTPFy9ejI8//jipczc0NGD27NnJDo3SLFKmo6GhAaWlpSMGuX6/H5/+9Kfx+9//HldeeSUCgQD279+Pd955B62trWhqakJDQwMuuugi/PM//zMqKiogyzKCwSA+9alPoa6uLq5wefPmzViyZElagu1k7rG0tDSt4ToRERERERER0UTGcDvD1dXV4YEHHkAgEBhyn6NHj+LRRx/Fzp078eijj+K88847iyOMn81mG+sh0FkiyzJUVUV5eXncK5R1XUdJSQna29thNpuxcOFCXHvttejq6oLf74eiKMjNzYWqqtB1PRoO67qO4uJitLW1oaamBo8//jhaWlqi53W5XHC73dFAPF2rppO9x+XLl6OtrQ1msxmqqqY8DiIiIiIiIiKiiYq1KjLY66+/jvvvvz8m2J4zZw7Ky8tx1113YdmyZbBYLNGfvffee3C73cOuXk2GKIqQJCnh//orKSmJ+5qCICR0LTbqG19EUcSGDRsSnot+vx8bNmyAYRjo7e2Fz+eD1WrFtGnTYLVa4fP5EAgEoKpqdNVzJOiWJAmrV69Gc3MzvF4vWltb4fV60dTUhDVr1kCSpLSWA0nlHmtqalh7m4iIiIiIiIhoBKy5naGOHTuGZcuWwefzATgd9t533324/fbbY+prHz9+HN/85jfxxz/+MfrY5z//eTz88MNnfcxnev/991FWVhbdPu+887Bjx45hQ+gzy5KMVMIk3VhzO31MJhPsdjtcLlfMCup4uVwuNDU1wefzQdO0pK4f+cAjsrI7mfOMdI2xvMd4ZeL8ofGFc4hSwflDqeD8oVRw/lCiWHOb0onPQZSKiTB/0l1zmyu3M5TH44kG2wBwzz33YOXKlQMaR06dOhU1NTWYO3du9LGXXnoJ+/fvP2tjHczzzz8fs33TTTdxdfU5QpIkeL3epEJfAGhubkZXV1fSK5s1TYOqqggGg1BVdVTC47G+RyIiIiIiIiKicwHD7QzU1dWFzZs3R7dnzZqFO++8c8j9ZVnG97///ei2YRiorq4e1TEOp6+vDy+++GJ0WxCEmFXcNLEJgpByaRy/3z+uPww5F+6RiIiIiIiIiGisMdzOQDt27EAoFIpuL1++HFlZWcMes2jRIuTn50e3X3vtNfT29o7aGIfz2muvxZT5uPLKK3HBBReMyVjo7DMMA4qipHQORVHG9VdvzoV7JCIiIiIiIiIaawy3M9DOnTtjtpcuXRrXcWfuFwwG8eabb6Z1XPF64YUXYra5avvcous6HA4HCgoKkjre5XIhNzc3bY0fR8O5cI9ERERERERERGON4XYGeuutt6K/djgcca96vuyyy2K29+zZk9ZxxeP48eN47bXXottWqxXXXXfdWR8HjZ1IzWu3253U8W63e9RqZafLuXCPRERERERERERjjeF2hjl69GhMI8l5CXRjnj9/fsz2hx9+mLZxxeull15CX19fdLukpCTl8g2UecLhMFatWpXwn72iKKioqMiIFc3nwj0SEREREREREY0l01gPgBJz4MCBmG2n0xn3sQ6HA1lZWdFwuf+5zoZ0lSTZv38/1q5di/feew9dXV0AgJycHJx//vlYsGABiouLcfHFF6c8XhodqqrCZrOhtrYWpaWlcQW5kiRh8+bNkGUZgUDgLIwyNefCPRIRERERERERjSWu3M4wnZ2dMdvTp0+P+1hBEGL273+u0dbc3Iz33nsvun3eeedh4cKFSZ1r3759ePnll3Hw4EH4/X74/X4cOXIEu3fvxqOPPoobb7wRq1atwsGDB9M1fEojwzAQDAZRUlKCurq6EVc3K4qC+vp6LFmyBMFgMCMaLZ4L90hERERERERENJa4cjvD9PT0xGxnZ2cndPyZ+2uahlAoBLPZnJaxjaT/qu0bb7wRgiCM2vVef/113HLLLfiP//gPXHvttSmdazTHmYozxzVexziUcDiM3t5eFBcXo62tDTU1NXj88cfR0tIS3cflcsHtdqOiogKyLKO3txfhcDhj7nW832Mmzx8aHziHKBWcP5QKzh9KBecPJSqeeSIIAucTxYXPQZQKzp+BGG5nmN7e3phtWZYTOr7//j09PWcl3NZ1HfX19dFtQRCSKkkyffp0FBUV4dOf/jQKCwuRm5sLs9mMEydOYN++fWhsbMQLL7yAUCgEAPD5fPjGN76BX/3qV7j00kuTHn9OTk7Sx54tkydPHushJM1sNuPuu+/G2rVr0dXVhZ6eHmRnZyM3NzfmA5iz9UHMaBjv95jJ84fGB84hSgXnD6WC84dSwflDcZk0KY5dJgEZ8L6Rxhc+B1EqOH9OY7idYYLBYMx2okFY//1VVU15TPF44403cOzYsej2FVdcgVmzZiV0jn//93/HggULYDINnLZ5eXnIy8vDZz/7Wdxxxx34+te/jubmZgCn73Ht2rXYunVrRoejE13kzyY3Nxe5ubkDHp8IzoV7JCIiIiIiIiI6WxhuZ5j+K68jzSHjFVnRHDFWJUmSWbW9aNGiuPabPXs2fvGLX+ALX/gC2traAAAff/wxnn32WXzpS19K+LoAcOLEiaSOG22CIEQ/qTt58iTrNFNCOH8oVZxDlArOH0oF5w+lgvOHEiWeOoWR1m6fOnUK4XH6vpHGFz4HUSomwvxJd3UEhtsZxmazxWz3X8k9kv4rtROt2Z2MU6dOYceOHdFtq9WKpUuXjuo1c3Nz8Z3vfAff/va3o4+9/PLLSYfbmfBkYRhGRoyTxifOH0oV5xClgvOHUsH5Q6ng/KF4xDNHOJcoGZw3lArOn9PEsR4AJaZ/uB0IBBI6/syGlCaTKeGa3cl46aWXYlaMl5SUQFGUUb/uddddF3Odd955Z0DNciIiIiIiIiIiIspMDLczzPTp02O2Ozo64j7WMAx0dnYOea7RsmXLlpjtZEqSJMNkMuGTn/xkdFvTNBw9evSsXJsoUZEPmywWC2RZHrS2PBERERERERER/Q3D7Qxz4YUXxmxHakrHw+v1xtTozs/PT9u4hnLgwAG888470W2n04mFCxeO+nUjzmzaBwDd3d1n7dpEIxEEARaLBTabDXa7HYFAAJ2dnQgEArDb7bBarbBYLBAEYayHSkREREREREQ07jDczjDTp0+H3W6Pbu/bty/uY99///2Y7blz56ZtXEPpv2r7xhtvPKtBXf8yJGejDAtRPCRJgs1mg6ZpWL9+PVwuF/Ly8pCfn4+8vDy4XC5UV1dD0zTYbDZIkjTWQyYiIiIiIiIiGlcYbmegK664Ivprr9eLw4cPx3Xc3r17Y7YXLFiQ1nH1Fw6H8dvf/jbmsZtvvnlUr9lf/9+bqVOnntXrEw0mEmw3NjbC6XSisrISLS0tMfu0tLSgsrISTqcTjY2NDLiJiIiIiIiIiPphuJ2BFi9eHLP9yiuvxHXctm3bor+WZRlXX311WsfV365du2Jqgl9xxRWYNWvWqF7zTO3t7TGBYW5uLqZNm3bWrk80mEgpkoaGBpSWlsLv9w+7v9/vR2lpKbZv384SJUREREREREREZ2C4nYGKioqQlZUV3X722WdjamkPZteuXfjoo4+i29dccw1sNtuojREAXnjhhZjts9VIMqK6uhqGYUS3r776agaDNOZkWYaqqigvL4eu63Edo+s6li9fDlVVYTabR3mERERERERERESZgeF2BnI4HPjiF78Y3T506BCefPLJIfdXVRU/+tGPotuCIGD16tVD7n/kyBEUFhZG/+u/Ujwefr8fjY2N0W2r1Yply5YlfB4ACIVCOHDgQELH/OY3v8HmzZuj24Ig4Pbbb0/q+kTpJIoiNmzYMOKK7f78fj9qamogSRJMJhNkWYbFYoEsyzCZTKM0WiIiIiIiIiKi8YvhdoZyu93Izs6Obj/66KP4xS9+gXA4HLPf8ePHUVFRgQ8++CD62PXXX4/58+eP6vheeeWVmGaOS5YsgaIoSZ0rGAzi85//PL797W/jjTfegKZpQ+577NgxPPjgg/iXf/mXmMdvuukm/N3f/V1S1ydKl0go7fF4kjre4/FAlmXY7XYEAgF0dnYiEAjAbrfDarWybAkRERERERERnVO43C9DTZ8+HVVVVVi9ejXC4TAMw8BPfvITPP3001i4cCFycnJw8OBBvPrqqwgGg9HjLrroIvzrv/7rqI9vy5YtMdupNpLUdR0vvfQSXnrpJSiKgnnz5uHCCy/E5MmTkZWVhZMnT2L//v3485//PKBEy5VXXnlW7pnOPSaTCZIkQRAEGIYBXdeH/fBFkiR4vd4BzSPj1dzcjGPHjuHJJ5/E9773vejjBQUFcLvdWLVqFWw2G4LBYNwlT4iIiIiIiIiIMhXD7Qx27bXX4ic/+Ql++MMfRldJt7a2orW1ddD9582bh8ceeyzpFdTxOnz4MP70pz9Ft51OJxYuXJi28/v9fuzZswd79uwZcd/bbrsN9913H+sUU9oIggBZliGKImRZhtfrhd/vh6IocDgcCAaDMAwDqqrG1HyPHJtoOZL+Tpw4EfOBFQC0tLSgsrISDzzwAGpra1FSUoJAIMCAm4iIiIiIiIgmNJYlyXA33XQTnn/+eRQXF8c0mTxTXl4e7r77bmzevBnnn3/+qI9py5YtMaHejTfemFKpBIvFArfbjcsuuyyukNpms6G0tBS/+c1v8MADD8BisSR9baIzSZIEm80GTdOwfv16uFwu5OXlIT8/H3l5eXC5XKiuroamabDZbJAkKeZ4wzBS/nDJbrfD5/MN+jO/34/S0lJs376dJUqIiIiIiIiIaMITjP5LCyljdXd3Y+/evejo6EBPTw8cDgcuuOACXH755QNCtkylaRo++ugjHDp0KHqfmqbBbrdj0qRJKCgoQGFhYdrvt7u7O63nSxdBEJCTkwPg9Ipe/nUePZFgu6GhAeXl5cOuwFYUZdAV1CaTCXa7HS6XK6nSJC6XC01NTVi2bBm2bt067PXb2togSRJUVR1yP84fShXnEKWC84dSwflDqeD8oUSJ+/Zh8tVXD7vPyTffRHjevLM0IspkfA6iVEyE+TNlypS0no9lSSaQKVOmoKioaKyHMapMJhMKCgpQUFAw1kOhc4ggCLBYLGhoaEBpaemI5T4iK6jr6+tRVFSEQCAAwzCgaRpUVYXb7UZlZWXC43C73WhtbUVDQ8OI16+pqcGaNWsSvgYRERERERERUaZgWRIiohHIsgxVVVFeXh53HWtd17F8+XKoqhpTTiccDmPVqlUJlydRFAUrV66Ex+NBOBwecX+PxwNZlmEy8TNMIiIiIiIiIpqYGG4TEY1AFEVs2LAh4WaQkRXUZ5bJUVUVsiyjtrY27vI5kiTh6aefRl9fHzZu3BjXMc3Nzejq6powJYmIiIiIiIiIiPpjuE1ENAyTyQRZluHxeJI6vv8KasMwEAwGUVJSgrq6uhFXcCuKgi1btqCoqAilpaXwer1xX9vv97OpJBERERERERFNWAy3iYiGIUkSvF5vUg0ggcFXUOu6jkAggOLiYrS1taGqqmpAHXmXy4WqqiocPnwYV111FRYvXozdu3cndG1FUTKyuQQRERERERERUTxYjJWIaBiCICRcjqQ/v98Pm80W81gk4DabzVi9ejXWrl2Lrq4udHd3Q1EUzJgxA6FQCI888gjWrVuX0Ipt4HQ4npubC5/Pl9LYiYiIiIiIiIjGK4bbRETDMAwj4eaP/Q21gtowDKiqGt2WZRm//OUv4fP50NLSgurqaoiimHCwDQButxuqqkLTtJTGTkREREREREQ0XrEsCRHRMHRdh8PhGFA2JF6RFdS6rg+7n2EY8Hq9+NGPfoSf//znePnll+HxeLBy5cqEw3VFUVBRUTHiNYmIiIiIiIiIMhnDbSKiYWiaBlVV4Xa7kzo+3hXUg60Qr6mpga7reOqpp2Jqdg9HkiRs3rwZsiwjFAolNWYiIiIiIiIiokzAcJuIaAThcBirVq0a1RXUg60Q93q9uOGGG1BcXIwXXnhhxOsrioL6+nosWbIEwWCQzSSJiIiIiIiIaEJjuE1ENAJVVSHLMmpra0dtBfVQK8R3796NxYsXY9GiRTh06BCqqqoGlEhxuVyoqqpCW1sbioqKEAgEWJKEiIiIiIiIiCY8httERCMwDAPBYBAlJSWoq6sbtRXUQ60Q3717N+bNm4d169ahrKwMzc3NaG9vj/6/qakJa9asgSzLDLaJiIiIiIiI6JzBcJuIKA66riMQCKC4uBhtbW2jsoJ6uBXiXq8X69atw9y5c7Fs2TI89NBD+O///m/89Kc/xZ49eyAIAgKBAEuREBEREREREdE5wzTWAyAiyhSRgNtsNmP16tVYu3Yturq64Pf7oSgKcnNzoapqdL9Eg+b+K8TLy8vh9/tj9gmHw9i6dSu2bt0KRVGwefNmXHbZZTHXM5lMkCQJgiDAMAzouj5iQ0siIiIiIiIiokzDldtERAkwDAOqqqK3txc+nw9WqxXTpk2D1WqFz+dDIBCAqqpJr6BOdoV4OByGxWKBzWaD3W5HIBBAZ2cnAoEA7HY7rFYrLBYLBEFIx28DEREREREREdGYY7hNRJSkSBPIYDAIVVXTtjo6EnBLkoTVq1ejubkZXq8Xra2t8Hq90RrbkiQhEAgAAGw2GzRNw/r16+FyuZCXl4f8/Hzk5eXB5XKhuroamqbBZrPF3RSTiIiIiIiIiGg8Y7hNRDQOxbtCXBRF2Gw2NDY2wul0orKyEi0tLTHnamlpQWVlJZxOJxobGxlwExEREREREdGEwHCbiGicG2qFuCAIsFgsaGhoQGlp6YD63P35/X6UlpZi+/btLFFCRERERERERBmP4TYR0ThlMpkgyzIsFgtkWYbJFNsDWJZlqKqK8vJy6Loe1zl1Xcfy5cuhqirMZvNoDJuIiIiIiIiI6KxguE1ENI5EVmPH0xhSFEVs2LBhxBXb/fn9ftTU1EAU+U8AEREREREREWUuJhtEROOEJElxN4bMzs6GLMvweDxJXcvj8UCW5TTfARERERERERHR2cNwm4hoHIgE2/E2hmxpaYHX6x2wT7yam5vR1dWVjqETEREREREREY0JhttERGMsmcaQtbW18Pl8KV030XImRERERERERETjiWnkXYiIaDQl0hhSFEWUlJTgsssuQ3Z2dkrXVRQlpeOJiIiIiIiIiMYSw20iojEWT2NIh8OBiooKuN1uzJ49G8ePH8fUqVNRUFCQVGkSl8uF3NzcVIZNRERERERERDSmWJaEiGgMmUymERtDLlq0CPv27cO9996L5557Ltpo8uDBg3C73Uld1+12Q1XVZIdNRERERERERDTmGG4TEY0hSZKGbQy5aNEi7NixA7t27cKsWbOijSbD4TA8Hg9WrlyZcHkRRVFQUVEBUeQ/AURERERERESUuZhsEBGNIUEQhixH4nA4UFdXh8bGRpSVlQ3Yr6amBrqu46mnnoIkSXFdT5IkbN68GWazGadOnQIAhEIhyLIMQRBSuxkiIiIiIiIiorOI4TYR0RgyDGPIldcVFRWQJAm33XbboI0mvV4vbrjhBhQXF+OFF14YcQW3oijYsmULrr32Wlx77bVwOBxwuVx47LHHoGkabDZb3CE5EREREREREdFYY7hNRDSGdF2Hw+FAQUFBzOOiKMLtdmPTpk3DNprcvXs3Fi9ejEWLFuHQoUOoqqoacC6Xy4WqqiocPnwYV111FRYvXozdu3cDAFpaWlBZWQmn04nGxkYG3ERERERERESUMRhuExGNIU3ToKrqgMaQJSUlmD179rCNJiN2796NefPmYd26dSgrK0NzczM6OjrQ2tqKY8eOoampCWVlZXjooYcwf/78aLB9Jr/fj9LSUmzfvh0Wi4UlSoiIiIiIiIho3GO4TUQ0xsLhMFatWhVTVuTiiy9Ge3v7kI0m+/N6vVi3bh3mzp2LZcuWYc+ePZg+fTp+9rOfYdmyZZg7dy7WrVsHr9c75Dl0Xcfy5cuhqirMZnPK90VERERERERENJoYbhMRjTFVVSHLMmpra6MlQRRFgc/nS/hc4XAYDQ0N+OQnP4nq6mr89Kc/xdatWxEOh+M63u/3o6amhqVJiIiIiIiIiGjcY7hNRDTGDMNAMBhESUkJ6urqoCgK/H4/7HZ7UudLpKTJYDweD2RZhslkSup4IiIiIiIiIqKzgeE2EdE4oOs6AoEAiouL0dbWhs9+9rOYOXPmgOaQ8Ui0pEl/zc3N6Orq4uptIiIiIiIiIhrXGG4TEY0TkYBbkiQsW7YMoVBoQKPJeCiKgkAgkNJY/H4/m0oSERERERER0bjGcJuIaBwxDAOqqqK3txeGYQxoNBmPvr4+TJ48OaVxKIoCwzBSOgcRERERERER0WhiuE1ENM6YTCbIsoxwOAyr1YqdO3ciKysrrmMlScItt9wCh8ORVEkTAHC5XMjNzQUAyLIMi8XCGtxERERERERENO4w3CYiGgcEQYDFYoHNZoPdbkcgEEBnZydOnDiBBQsWoKurCw888AAcDseQ51AUBfX19bjsssugqmpSJU0AwO12IxQKwWazRccRCARgt9thtVphsVhYsoSIiIiIiIiIxhzDbSKiMSZJEmw2GzRNw/r16+FyuZCXl4f8/Hzk5eXB5XJhw4YNqKysxEcffYQvfvGLMce7XC5UVVWhra0NRUVFCAQCCIfDSZU0URQFFRUV+MMf/jDoOKqrq6FpGmw2GxtOEhEREREREdGYEgwWVSUaUXd391gPYVCCICAnJwcAcOLECdZIzkCRYLuhoQHl5eXw+/1D7qsoCmpra3HdddfB7/fjxIkTUBQFubm5UFUVuq4jFArBMAwIggCbzYbGxkaUlpZC1/W4xlJXV4cFCxbgnnvuwcyZM6EoCvx+P/bv34+GhgaEw+HoOEpKShAIBOI6N01MfA6iVHD+UCo4fygVnD+UKHHfPky++uph9zn55psIz5t3lkZEmYzPQZSKiTB/pkyZktbzsYAqEdEYiZQiaWhoiCuA9vv9KC0tRX19PYqLi2E2m2EYBnw+HzRNi9nXMAwEg0Fcd911qKuriys4f+GFF3DNNdfg2LFjeOaZZ9De3g6fzwe73Y6ZM2eis7MTe/bswbvvvosdO3YgLy8Pl156KQKBQEb+g0pEREREREREmY1lSYiIxogsy1BVFeXl5XGvftZ1HcuXL0cwGIRhGFBVdUCwHREOhxEOh/GP//iPOHToEKqqqgY0mYyUNOno6MBnP/tZ+P1+PPPMM3C5XHA6nbj66qvxyCOP4MiRI5g+fToWLlyIFStW4J/+6Z+wYMECGIYBm83GGtxEREREREREdNZx5TYR0RgRRREbNmwYdkX1YPx+P2pqarBmzZph95NlGcFgEJdccgnKy8vhdruxdu1adHR0RFdkz5gxA6qqQhRFbN26Fbfddlt0PIsWLUJdXR0kScKmTZvg8XjQ0tISPX9BQQHcbjdWrVoFm82GYDDIEiVEREREREREdNaw5jZRHFhzm9LNZDLBbrfD5XLFBMbxcrlcaGpqGrQkSYTNZsP69etRWVkJ4HSYXlJSgsLCQtjtdvh8PkyfPh3f+c53sHXrVpSVlUXD6UWLFmHHjh1obGyMCbwHwxrc5y4+B1EqOH8oFZw/lArOH0oUa25TOvE5iFIxEeYPa24TEU0AkiTB6/UmFWwDQHNzM7q6umC1WgcNt00mE2RZhsfjiT4WDoexdetWbN26NfpYfX09ent7cdttt0VDaYfDgbq6OjQ2NsYE3kM5sxZ4UVFRTA1uk8kESZIgCAIMw4Cu60OG8UREREREREREiWDNbSKiMSAIQsLlSPrz+/1D1roeLjwXRRFLly7F2rVrsXjxYuzduxf/8A//AFE8/U9CRUUFJEmKCbxHEqkFrqoqZFmGxWKBzWaD3W5HIBBAZ2cnAoEA7HY7rFYrLBYL63QTERERERERUUoYbhMRjQHDMKAoSkrnUBRlyK8gDRaeOxwO3H///Thw4ABeeeUV3HvvvTh27BgKCwvxyiuv4MMPP8R3v/tdrFmzBps2bUq6FrgkSdA0DevXr4fL5UJeXh7y8/ORl5cHl8uF6upqaJoGm80GSZKSuvfIynSLxQJZlmEy8YtIREREREREROcahttERGNA13U4HA4UFBQkdbzL5UJubu6QK6v7h+eLFi3Cvn37cO+99+K5556Dy+XCzJkzMWfOHDidTrhcLjz//PP47ne/iwsuuCCmnEkiPB4PzGYzbr/9dlRWVg5YOd7S0oLKyko4nU40NjYmFHALgsAV4UREREREREQUxXCbiGgMaJoGVVXhdruTOt7tdkNV1SHD7TPD80hzyF27dmHWrFnDhs7//u//jmPHjqVUC7yjowOzZs0adr9Ine7t27fHFUhLkgSbzTbqK8KJiIiIiIiIKHMw3CYiGiPhcBirVq1KuDyJoii44447AGDIIDcSnq9duzamOeRIpUaysrLQ3d2d0Hj68/l8sNvtI+53Zp1us9k85H6RYLuxsRFOpzPtK8KJiIiIiIiIKDMx3CYiGiOR5ou1tbVxB7GSJOHpp5+Gqqq4+OKLhw1yw+Ewvva1ryXUHNLv98cVTA/HbrfD5/PFte+ZdboHEylF0tDQgNLS0hHD+URXhBMRERERERFR5mK4TUQ0RgzDQDAYRElJCerq6kZcwa0oCrZs2YKioiKUlpaitbV12CBXVVUIgpBQc8j9+/dj5syZKdUCnzFjBpqamuI+xuPxDNkUUpZlqKqK8vLyuMJ5IP4V4URERERERESU2RhuExGNIV3XEQgEUFxcjLa2NlRVVQ0Ill0uF6qqqnD48GFcddVVWLx4MXbv3h09PhLkyrIcc5wkSTCbzQk1h2xoaMDBgwdTqgXe2tqKhoaGuI9pbm5GV1fXoKu3RVHEhg0b4g7nI0ZaEU5EREREREREmY/hNhHRGIsE3FarFbfffjuam5vR3t4e/X9TUxPKysrw0EMPYf78+dFgO+LMIPfMMFeSJHi93oSaQ4bDYXg8HqxcuTKpWuArV66Ex+NBOBxO6Fi/3z9g5bnJZIIsywmF82cabkU4EREREREREWU+vuMnIhoHJEmCyWTCpz/9aeTn56OwsDBau7qpqQkNDQ3DBsYejwdr166FJEno6emBrusQBCHhFc8AUFNTg8rKSjz11FMoKyuLqxxIpBZ4X18fNm7cmPA1FUWBYRgDzploOH+myIpwq9UKTdOSOgcRERERERERjV8Mt4mIxoFIkNvU1ISmpiZs3bo1oeObm5vR0dGB7u5uzJ07F4FAAIZhJLz6GgC8Xi9uuOEG7Ny5E3V1dSgvLx82JFcUBZs3b8a1116L4uJiXHnllbj44ouhKAr8fj/2798/bDjvcrmQm5s7oAllsuH8mfx+P2w2W0rnICIiIiIiIqLxieE2EdE4kI4g1+fz4Te/+Q2+9a1vwWw2Q9d1OBwOFBQUJLz6effu3fjqV7+K//mf/0FbWxtqamrw+OOPx5zH5XLB7XajoqICFosF7733Hp566inMnj0b7e3t8Pl8sNvtmDlzJlpbW/HEE0+gpqYGXq835lputxuqqg5YXZ1sOH+mwVaEExEREREREdHEwJrbRETjQDqCXLvdjq6urmj9bU3ToKpq0s0hFy5ciHA4DFmWsWbNGjQ3N8Pr9aK1tTW6ynzNmjXIysoCAMydOxfPPfccXC4XnE4nCgsL4XQ64XK58Pzzz+Pee+/Fvn37sHDhwug1FEVBRUXFoKVPzgznkxFZER5PWRUiIiIiIiIiyjyCwSVtE8aJEyewd+9edHR0wO/3Y9q0aTj//PNx+eWXQxQn5ucYhw4dwvvvv4+Ojg6Ew2FMnz4dBQUFcLlcab1Od3d3Ws+XLoIgICcnB8DpP3/+dc5cJpMJdrsdLpcrqRrTLpcLTU1NWLZsGQ4cOICmpib4fD6YTCZomgan05nQynBFUdDW1gZJkqCqanSMkiRBEAQYhgFd12EYBmw2GxoaGuIqX/LUU0+huLgYixcvxp49e1BfX4+ioqJoGZX+bDYb1q9fj8rKyoR/T6qqqrBmzRoEAoGEj6X48DmIUsH5Q6ng/KFUcP5QosR9+zD56quH3efkm28iPG/eWRoRZTI+B1EqJsL8mTJlSlrPx7IkE0BraysefvhhvPrqq+jr6xvw82nTpqG8vBx33nknzGbzqIzhK1/5Cv74xz8mdeymTZvw6U9/OqFjXn/9dVRXV+Ptt98e9OeFhYVYtWoVbrjhhqTGRHS2nbnKOpkg1+12o7W1NVrbOtJIUVVV2Gw21NbWorS0NO7mkJs3b4YsyzHBsKZpMaVDBEGIBtvxnNvv96OsrAxbtmxBfX09/vznP+Oaa64ZMtgGgHA4jFWrVuGBBx5IOJwfakU4EREREREREU0ME3M57zmkrq4OZWVlaGhoGDTYBoCjR4/i0Ucfxa233oqPP/74LI8wvQzDwE9+8hPceeedQwbbANDU1ITvfOc7qKysRCgUOosjJEpeJMhNtDyJoihYuXIlPB5PtGmj3++PrrAOBoMoKSlBXV3diOdWFAX19fVYsmQJgsHgkKGzIAjIzs6GqqooLy+PO0TWdR0rVqyALMvRYHu4Y1VVhSzLqK2thSRJcV3jzHCef/+JiIiIiIiIJi6G2xns9ddfx/333x+zsnLOnDkoLy/HXXfdhWXLlsFisUR/9t5778HtdqfctC4ekiTF/Z8gCHGf9//9v/+HX/ziFzGB2+WXX47bb78dX/va1/DpT3865nwvvvgifvCDH6T13ohGS7JB7tNPP42+vj5s3Lgx+viZjRR1XUcgEEBxcTHa2tpQVVU1oI61y+VCVVUV2traomVChgqdJUmCzWZDOBzGhg0bEn5O8fv9qKmpga7rI4bioxXOExEREREREVHmY83tDHXs2DEsW7YMPp8PwOlVlPfddx9uv/32mPrax48fxze/+c2YkiGf//zn8fDDD6d1PGeWJfnUpz6FX/3qV2k9PwC89tpruPPOO6PbkyZNwiOPPIJFixbF7Pf+++9j9erV6OjoiD72b//2b1i+fHnS12bNbTpbJElCdnY2tm3bFlcN66effhpFRUVYvHgxdu/eDeBv9bd9Pt+AMiJmsxmiKMJisaCrqws9PT3Izs5Gbm4uVFWFrusIhUJDzqVIsP32229jwYIFKdcI7z/GoUiSBIvFAlVVUVNTg8cffzzmui6XC263GxUVFZBlGcFgkCVJzgI+B1EqOH8oFZw/lArOH0oUa25TOvE5iFIxEeZPumtuc+V2hvJ4PNFgGwDuuecerFy5ckDjyKlTp6KmpgZz586NPvbSSy9h//79Z22s6WAYRkwgLwgCqqurBwTbADB//nz84he/gCzL0cceffTRaFM8ovFM13X09PRgyZIlOHLkyLCrrA8fPoyrrroqJtgGTtffVlV1QGhsGAZUVUVvby98Ph9sNhtmzZqF3Nxc+P1+BAIBqKo6bCkSi8WChoYGPPPMM2hvb08q2AaA5uZmdHV1xb1CPbL6XJIkrF69Gs3NzfB6vWhtbYXX60VTUxPWrFkDSZJGLHVCRERERERERBMDw+0M1NXVhc2bN0e3Z82aFbOiuT9ZlvH9738/um0YBqqrq0d1jOm2Y8cONDU1RbdvvPFGLFiwYMj98/Pzcccdd0S3jx49imeffXZUx0iULrquQ9M0WCwW3HzzzWhubkZ7e3v0/01NTSgrK8NDDz2E+fPnxwTb8TZSjDSwPHN7JLIsR2ts22w2+Hw+iKKIpUuX4lvf+ha+973v4Vvf+haWLl064IO2wUTqgscrEs739fUhGAzCbrdj5syZyM7Ohs/nGzGcJyIiIiIiIqKJxTTWA6DE7dixI6ZJ2vLly5GVlTXsMYsWLUJ+fj4++ugjAKdLfPT29sJqtY7qWNPllVdeidn+0pe+NOIxt956K5544oloyLd161Z8+ctfHpXxEaWbqqqw2Wx47733cPfdd+Oiiy6C3W6Hz+dDU1MTGhoaos0jI85spHhmLf50EUUxWmPbMAzMmDEDBw4cwOzZs9He3g6fzxcNnFtbW/HEE0+gpqYGXq930POdWRd8JIIgQJZliKIIWZbh9Xrh9/uhKAocDgcAwGQyMdwmIiIiIiIiOodw5XYG2rlzZ8z20qVL4zruzP2CwSDefPPNtI5rtGiaht///vfR7ZkzZ+KSSy4Z8bjp06fj7//+76Pbe/fuHbe1s4n6O7OR4po1a7Bx40b86Ec/ws9//nNs3bp1QLA92o0UTSYTZFmGx+PBokWL8J3vfAeCIOC5556Dy+WC0+lEYWEhnE4nXC4Xnn/+edx7773Yt28fFi5cOOB8LpcLubm5cZUPidT51jQN69evh8vlQl5eHvLz85GXlweXy4Xq6mpomgabzRZ3qRMiIiIiIiIiymwMtzPQW2+9Ff21w+HABRdcENdxl112Wcz2nj170jqu0dLS0oKTJ09Gt/vfx3DODLd1XcfevXvTOTSiURWpM11cXIy2trZh62+3tbWhqKho1OpNS5IEr9cLh8OBHTt24Pe//z2cTicqKysH1N1uaWlBZWUlZs2ahV27dmHnzp0DAm63241QKDRiOZRIsN3Y2Dji9ZxOJxobGxlwExEREREREZ0jGG5nmKNHj8Y0kpyXQDfm+fPnx2x/+OGHaRvXaOo/zkTu+ROf+MSw5yIa78ZLI0VBEBAIBFBXV4fGxkaUlZXB7/cPe4zf70dZWRl27NiB+vr6aPkQRVGwcuVKmM1mmExDV8c6s4FlaWlpXNcrLS3F9u3bYbFYEqrnTURERERERESZhzW3M8yBAwditp1OZ9zHOhwOZGVloa+vb9BzpUtbWxvuu+8+vPvuuzh27Bg0TcOUKVMwffp0XHnllbj22mtxxRVXxH2+VO555syZMduRmuNEmSTSSBEA+vr6YLVaYbPZYBgGfD5fXM0g0zGG3NxchEIh3HbbbXGH6LquY8WKFTh8+DDuuOMO/Md//Aeefvpp9PX14fjx49FV1oIgwDCMaDNNILaBZSLXW758Odra2mA2m2OaZhIRERERERHRxMKV2xmms7MzZnv69OlxHysIQsz+/c+VLkeOHMGWLVvw4Ycf4tSpUwgEAvj444+xd+9ePPnkk7jttttw66234t13343rfP3HOWPGjLjH0n/fjo6OuI8lGo80TYOqqggGg1BV9awE28Dp0DgrKwubNm0acQV1f36/H5s2bcLq1avx29/+FkVFRfjNb34Dq9UKi8WCQCCAzs5OBAIB2O326ONnNrBM9Ho1NTWQJGnYleFERERERERElNn4rj/D9PT0xGxnZ2cndPyZ+2uahlAoBLPZnJaxJeLtt9/GihUr8MADD+CLX/zisPumcs/99w0EAvEP8gzjtbzBmeMar2Ok8SuR+SMIAsxmMzweT1LX8ng8WLt2LaZOnYpgMIhbb70Vjz/+ODweT0wN7YKCArjdbqxatQoWiwW7d+9O6XqR1d/hcBihUCjtjTbPdXwOolRw/lAqOH8oFZw/lKh45okgCJxPFBc+B1EqOH8GYridYXp7e2O2ZVlO6Pj++/f09KQt3M7JycHixYvxmc98BoWFhZg+fTosFgtOnTqFlpYW/O53v8PmzZujqzD7+vrwgx/8AFOmTEFxcfGQ5+1/z4mMt//9Jhtu5+TkJHXc2TR58uSxHgJlsHjmj9frHdDMMV6RWuGTJk3C7373O9x2222DrsiONId84IEHUFtbi1/+8pc4fPhwwiF3c3MzOjo6sHHjRlitVqxatQo2mw1ZWVlJjZ9GxucgSgXnD6WC84dSwflDcZk0KY5dJgEZ8L6Rxhc+B1EqOH9OY1mSDBMMBmO2Ew2m+++frnq03/jGN/D666/jJz/5Ca6//nrMnTsXiqLAZDJh6tSpuOqqq3Dfffdh27Zt+NSnPhU9LhwO47777kN3d/eQ507lnvvv2/9cRBS//t+iSOb4AwcOxN2MsrS0dEAzykT4fD4Eg0FUVlbC6XRi+/bto9Zwk4iIiIiIiIjOPq7czjD9VyJHmkPGKxQKxWyna9X2ggUL4trP4XBE626///77AE6HWBs2bMC999476DGp3HP/+010pXvEiRMnkjputAmCEP2k7uTJkyy5QAlJZP7IspxwGaT+FEVBdXV10s0o161bl9D17HY7fD4fgL+F5fX19SgqKkJvby//vqQBn4MoFZw/lArOH0oF5w8lSjx1CiOt3T516hTC4/R9I40vfA6iVEyE+ZPu6ggMtzOMzWaL2U50JXL/ldqphlXJsFqteOCBB1BeXh597OWXXx4y3O5/z4msNu+/b/9zxSsTniwMw8iIcdL4NNL80TQNDocDBQUFSZUmcblcyM3NxV/+8peEjos0o3S73fjZz36GcDgc9/VmzJiBpqam6GO6rmP58uVoa2tDVlZW2r65QqfxOYhSwflDqeD8oVRw/lA84pkjnEuUDM4bSgXnz2ksS5Jh+oezidaQPrOsgMlkSnolc6r+/u//HhdddFF0u729Ha2trYPu2/+eEymN0H/fZMNtonOdpmlQVRVutzup491uN44cOYKGhoaEj/V4PJgzZw5KSkoSul5ra+uA6/n9ftTU1ECSpITHQURERERERETjC8PtDDN9+vSY7Y6OjriPNQwDnZ2dQ57rbPv7v//7mO22trZB90vlnvvvO2PGjLiPJaJY4XAYq1atgqIoCR2nKAoqKirw2GOPxb3y+kyR5pCFhYVxX2/lypXweDyDXs/j8UCWZZhM/PISERERERERUSZjuJ1hLrzwwpjtoQLhwXi93ph61fn5+WkbVzJyc3NjtodqKpnKPbe3tw97LiKKn6qqkGUZtbW1ca98liQJmzdvhtlsxsaNG5O+ts/ng91uj+t6Tz/9NPr6+oa8XnNzM7q6urh6m4iIiIiIiCjDMdzOMNOnT48JePbt2xf3sZEGjhFz585N27iS0dvbG7M9VImU/uNM5J7fe++9mG2G20TJMwwDwWAQJSUlqKurG3EFt6Io+O1vf4uioiL4fD54vd6krz1lypQBDWIHu96WLVtQVFSE0tLSYa/n9/shCELS4yEiIiIiIiKiscdwOwNdccUV0V97vV4cPnw4ruP27t0bs71gwYK0jitR/cc9derUQfdzuVyYNOlvvanffvvtuK9x5r6SJOHyyy9PcJREdCZd1xEIBFBcXIy2tjZUVVWhoKAgZh+Xy4WqqiocPnwYn/rUp3DfffdFm1Emw+VyweFw4IEHHhjxeldddRUWL16M3bt3D3tORVHYeIOIiIiIiIgowzHczkCLFy+O2X7llVfiOm7btm3RX8uyjKuvvjqt40pEb28v9uzZE902mUxwuVyD7msymfDZz342ut3e3o4///nPI16js7MT77zzTnT7sssuGzJAJ6L4RQJuSZKwZs0aNDc3o729Pfr/pqYmlJWV4aGHHsL8+fPxyCOP4ODBgyk1o1RVFQCwevVqNDc3w+v1oqWlZdDrjRRsu1wu5ObmQtf1pMZDREREREREROMDw+0MVFRUhKysrOj2s88+G1NLezC7du3CRx99FN2+5pprYLPZRm2MI/nlL38Jv98f3b700kuHLXGwdOnSmO2nnnpqxGs888wzMc3k+p+DiJJnGAZUVUVvby/6+vpw/Phx/M///A8eeughLFu2DHPnzsW6devg9XoRDofh8XiwcuXKpJtR6roevZ7P58PkyZPR2dk56PVGEgnLNU1L9vaJiIiIiIiIaBxguJ2BHA4HvvjFL0a3Dx06hCeffHLI/VVVxY9+9KPotiAIWL169ZD7HzlyBIWFhdH/+q8U76+pqSmB0QNvvPEGHnvssZjHvvrVrw57TFFRUczK7t/+9rcxK7/7++ijj2KayeXl5cX8nhFRehiGgd7eXrhcLlx11VXYuHEjtm7dGvPBEgDU1NRA13U89dRTCTejlGU5pt62pmno6+vDJZdcMuT1hnJmWE5EREREREREmY3hdoZyu93Izs6Obj/66KP4xS9+MSDgOX78OCoqKvDBBx9EH7v++usxf/78tI3ly1/+Mu68805s3749WjpgMKdOncIjjzyCu+66K2al+ac+9SmUlJQMew1RFPHtb387um0YBtasWYNdu3YN2Pf999/HV7/61ZixfP3rX4fFYknktogoTvHU4Z46dSoaGxtx/fXXx92Msr6+HkuWLEEwGBxQH1tVVciyjNra2pTDciIiIiIiIiLKTILBjloZ63e/+x1Wr14dE2jPmTMHCxcuRE5ODg4ePIhXX30VwWAw+vOLLroItbW1wwZLR44cQVFRUXT7vPPOw86dO4fc/8orr4TP5wMAWK1WFBYW4qKLLkJOTg4sFgtOnTqFDz/8EHv37kVvb2/Msfn5+XjmmWeQk5MT1z3/x3/8BzZs2BDz2BVXXIFPfvKTEEURTU1N+N///d+YIKy0tBQ/+9nP4jr/ULq7u1M6frQIghD9vTtx4gQb5FFC0j1/BEGA2WyGKIqwWCzo6uqC3++HoijIzc2FqqowDAOiKEJVVdTU1ODxxx9HS0tL9BwulwtutxsVFRWQZRnBYHDIVdaSJMFms6GhoQHl5eUxpY76UxQFmzdvxpIlSxAIBLhyO034HESp4PyhVHD+UCo4fyhR4r59mDxCz6qTb76J8Lx5Z2lElMn4HESpmAjzZ8qUKWk9nymtZ6Oz6tprr8VPfvIT/PCHP4yGxq2trWhtbR10/3nz5uGxxx5LuOZtInp7e/HOO+/ENHIcynXXXYd/+7d/w+TJk+M+/7e//W0Eg0H86le/ij72pz/9CX/6058G3f/666+PKclCRKMnUocbAPr6+mC1WmGz2WAYBnw+X7TGdSQEX716NdauXTtoCB5ZDT7cP9T9V4zHE5Yz2CYiIiIiIiKaOBhuZ7ibbroJl1xyCR5++GG89tprgzaWzMvLw/Lly+F2u2E2m9M+hrvuugtvvPEG/vKXvyAQCAy7r9lsxmc+8xl85StfwaJFixK+liiK+N73vofPfOYzqK6uHjJEd7lcqKiowI033pjwNYgodZqmDdmwMd4QPB6RgDsdYTkRERERERERZRaWJZlAuru7sXfvXnR0dKCnpwcOhwMXXHABLr/88rhr0qYiHA7j4MGDOHjwIDo6OuDz+dDX1webzYbJkycjPz8f8+fPT2vAfvDgQbz33ns4evQodF3H9OnTUVBQgMLCwrRdA2BZEpqYJuL8MZlMkCQJgiDAMAzoup5QWE6JmYhziM4ezh9KBecPpYLzhxLFsiSUTnwOolRMhPnDsiQ0pClTpsTUyj7bRFFEfn4+8vPzz9o1Z8+ejdmzZ5+16xHR+DbcinEiIiIiIiIimljEsR4AEREREREREREREVGiGG4TERERERERERERUcZhuE1EREREREREREREGYc1t4mIaEJjk0kiIiIiIiKiiYnhNhERTTiCIECWZYiiCFmW4fV64ff7oSgKHA4HgsEgDMOAqqoZ2V2aiIiIiIiIiFiWhIiIJhhJkmCz2aBpGtavXw+Xy4W8vDzk5+cjLy8PLpcL1dXV0DQNNpsNkiSN9ZCJiIiIiIiIKAkMt4mIaMKIBNuNjY1wOp2orKxES0tLzD4tLS2orKyE0+lEY2MjA24iIiIiIiKiDMVwm4iIJgRBEGCxWNDQ0IDS0lL4/f5h9/f7/SgtLcX27dthsVggCMJZGikRERERERERpQPDbSIimhBkWYaqqigvL4eu63Edo+s6li9fDlVVYTabR3mERERERERERJRODLeJiCglJpMJsizDYrFAlmWYTGPTq1gURWzYsGHEFdv9+f1+1NTUsDQJERERERERUYZhuE1ERAmLlACx2Wyw2+0IBALo7OxEIBCA3W6H1WqNq9RHuoLxyHk8Hk9Sx3s8njEN5omIiIiIiIgocQy3iYgoIZGmjZqmYf369XC5XMjLy0N+fj7y8vLgcrlQXV0NTdMGbdaYrmC8/5i8Xu+A5pHxam5uRldXF1dvExEREREREWUQhttERBS3SLDd2NgIp9OJysrKAYFyS0sLKisr4XQ60djYGBNwpxqMD0UQhITLkfTn9/vZVJKIiIiIiIgogzDcJiKiuERWXDc0NKC0tHTEMNnv96O0tBTbt2+HxWKByWRKKRgfjmEYUBQlpftTFAWGYaR0DiIiIiIiIiI6exhuExFRXGRZhqqqKC8vh67rcR2j6zqWL1+OUCiUUjA+0opqXdfhcDhQUFAQ9/2cyeVyITc3N+776m+8NNUkIiIiIiIiOpcw3CYioriIoogNGzYkXP7D7/fjnXfeQTAYTCoYV1UVZrN52H01TYOqqnC73QmNLcLtdkNVVWiaFvcxo1E7nIiIiIiIiIjix3CbiIhGFFmZ7PF4Ej5WFEXMmTMn6WC8pqYmrtIk4XAYq1atSrg8iaIoqKioSGjV9mjVDiciIiIiIiKi+DHcJiKiEUmSBK/XO6BGdjxKSkpw/vnnJxWMA4DH44mr1IeqqpBlGbW1tXGHyZIkYfPmzZBlGaFQKO5jRqt2OBERERERERHFj+E2ERGNSBCEhFddR1x88cVob29PKhgHgObmZnR1dY0YDhuGgWAwiJKSEtTV1Y24gltRFNTX12PJkiUIBoNxNZNMtakmS5QQERERERERpQ/DbSIiGpFhGAmX+4hQFAU+ny+l6/v9/riCYV3XEQgEUFxcjLa2NlRVVQ1oMulyuVBVVYW2tjYUFRUhEAjEXZIklaaa8dQOJyIiIiIiIqL4MdwmIqIR6boOh8MxICiOh9/vh91uT+n6iqLEtbIa+FvALUkSVq9ejebmZni9XrS2tsLr9aKpqQlr1qyBJEkJBdtAak01460dTkRERERERETxYbhNREQj0jQNqqrC7XYnfOz+/fsxc+bMpIJx4PRK69zc3IRCaMMwoKoqent74fP5YLVaMW3aNFitVvh8PgQCAaiqGndgDqTWVBOIv3Y4EREREREREcWH4TYREcUlHA5j1apVCZcn+d///d+kg3EAcLvdUFUVmqYldXwkmA8GgymdJ5WmmkD8tcOJiIiIiIiIKD4Mt4mIKC6qqkKWZdTW1sYd0EqShGeeeQaSJCUVjCuKgoqKioRWbY+WVJpqRsRbO5yIiIiIiIiIRsZwm4iI4mIYBoLBIEpKSlBXVzdiUK0oCurr67FkyRL09vYmFYxv3rwZsiwjFAql4xZSkkpTzYhEaocTERERERER0fAYbhMRUdwizRqLi4vR1taGqqqqAbW0XS4Xqqqq0NbWhqKiIgQCAWialnQwHgwGx0UgnEpTTSC52uFERERERERENDSG20RElJBIwC1JElavXo3m5mZ4vV60trbC6/WiqakJa9asgSRJCAQC0TA32WB8tMPgSKNIi8UybMPHVJpqAqnXDiciIiIiIiKiWIIxHpbDEY1z3d3dYz2EQQmCgJycHADAiRMnxsXqVsoc6Zo/JpMJkiRBEAQYhgFd14cNcAVBgNlshiiKsFgs6Orqgt/vh6IoyM3Nhaqq0HUdoVBo1Oa0IAiQZRmiKEKWZXi93ugYHA5HdLW4qqoxY7BYLNA0DU6nM6H624qioK2tDZIkQVXV0biluCT6ZzUSPgdRKjh/KBWcP5QKzh9KlLhvHyZfffWw+5x8802E5807SyOiTMbnIErFRJg/U6ZMSev5Bl+eRkREFCdN0xIKSCOhMQD09fXBarXCZrPBMAz4fL5RX9ksSRIsFgtUVcWGDRvg8XjQ0tIS/XlBQQHcbjdWrVoFm82GYDAYXT2uqipsNhtqa2tRWlo66KpyURRRUlKCiy++GIqiIBAI4NZbb4UsywgEAqN6b4NJNsgnIiIiIiIiGu9YloSIiMZMpNRHMBg8KyU7JEmCzWZDY2MjnE4nKisrY4JtAGhpaUFlZSWcTicaGxths9miTTCHa6rpcDhw//3348CBA3jllVdw77334itf+Qruv/9+LFiwAIZhQJZlCIIwqvc42P1qmob169fD5XIhLy8P+fn5yMvLg8vlQnV1NTRNi7lPIiIiIiIiokzAcJuIiM4JoijCarWioaEBpaWlI5YV8fv9KC0txfbt22GxWKKh9GC1w5cvX459+/bh3nvvxXPPPQeXywWn04nCwkJMmzYNLpcL69evP6shcqpBPhEREREREdF4x5rbRHFgzW2aiM6l+RMJent7e9NWLztSO1ySJJhMJmzbtg3l5eXDnltRFNTW1qKkpGRUm2UKghANtocqn9KfJEmor6+PNvKMZz6cS3OI0o/zh1LB+UOp4PyhRLHmNqUTn4MoFRNh/qS75jZXbhMR0YR2ZrC9YcOGhIJt4PQK7pqamgErmg3DQCgUgiAI2LZtW0qrwdNNlmWoqory8vK4A3Rd17F8+XKoqgqz2Twq4yIiIiIiIiJKJ4bbREQ0YQmCAIvFgrfffht2ux0ejyep83g8HsiyDJMptg/zeA2RRVFMa5BPRERERERENB4x3CYiogkrEj4/99xzaG9vH1BzOl7Nzc3o6uoaEPqOxxDZZDJBluW0B/lERERERERE4w3DbSIimrAi4XNWVhZ8Pl9K5/L7/TFlRMZriCxJErxeb9qDfCIiIiIiIqLxhuE2ERFNSGeGz36/H3a7PaXzKYoS06xjvIbIgiAkvJK8v/5BPhEREREREdF4xHCbiIgmpDPD5/3792PmzJkoKChI6lwulwu5ubkxdbXHa4hsGAYURUnpHP2DfCIiIiIiIqLxiOE2ERFNSGeGzw0NDTh48CDcbndS53K73VBVFZqmRR8bryGyrutwOBxpDfKJiIiIiIiIxiOG20RENCGdGT6Hw2F4PB6sXLky4UBaURRUVFQMCHvHa4isaRpUVU1rkE9EREREREQ0HjHcJiKiCal/+FxTUwNd1/HUU0/FXedakiRs3rwZsiwjFArF/Gw8h8jhcBirVq1KW5BPRERERERENB4x3CYiogmpf/js9Xpxww03oLi4GC+88MKIwa+iKKivr8eSJUsQDAYHLR8yXkNkVVUhyzJqa2vTEuQTERERERERjUcMt4mIaMLqHz7v3r0bixcvxqJFi3Do0CFUVVUNKCvicrlQVVWFtrY2FBcXIxAIDBlCj8cQWRAEyLIMALjuuutQV1eXliCfiIiIiIiIaLxhuE1ERBPWYOHz7t27MW/ePKxbtw5lZWVobm5Ge3t79P9NTU2oqKiA1WodNtgGTtf1DgaDKCkpGRchsiRJsNls0DQNjz32GFasWIFPfepTcQX5RUVFI94vERERERER0XgiGFyeRTSi7u7usR7CoARBQE5ODgDgxIkTXG1JCTlX5k8k8G1oaEB5eTn8fn/0Z6IooqSkBIWFhbDb7QiFQvjCF76Ayy67LKGgV5IkWCwWqKqKmpoaPP7442hpaYn+3OVywe12o6KiArIsIxgMpj1EHuo+HQ4H7rjjDrjdbsyZMwcdHR3w+XyYMmUKHA4HVFWFrusIhUIJz4FzZQ7R6OD8oVRw/lAqOH8oESaTCaamJlgXLBh2v5NvvonwvHlnaVSUyfgcRKmYCPNnypQpaT0fw22iODDcponoXJo/ZyN8FgQBZrMZoijCYrGgq6sLfr8fiqIgNzc3pRA5nmvbbDY0NjaitLR00LH3D/J7enqwYsUKXHrppQgEAkmN6VyaQ5R+nD+UCs4fSgXnD40kUuZNFEXIsozuN97AlM98ZthjGG5TvPgcRKmYCPOH4TbRGGC4TRPRuTZ/zmb4bDKZIEkSBEGAYRjQdR2apqXpTgayWCzQNA1OpzNmZfpIFEVBe3s7TCYTent7E77uuTaHKL04fygVnD+UCs4fGs6ZiyI2bNgAj8eDrJYWvDfCcQy3KV58DqJUTIT5k+5w25TWsxEREY1ThmFAVVUAQF9fH6xWK2w2GwzDgM/nS2v4rGnaqIbZ/YmiiA0bNiQUbAOA3+/Hhg0bcPfdd0eDeCIiIqJz1VBl3uaP8biIiGhoDLeJiOicc7bD59FkMpkgyzI8Hk9Cx0XKlPT29sJsNkMQBASDwQnz+0JERESUCEEQYLFY0NDQMGSZt5GOJyKis4/hNhERUQaTJAlerzemhvhwHA4HKioq4Ha7MXv2bJw6dQrd3d3IysqC3W5HMBiMrnLnSm4iIiI6V8iyDFVVUV5enlTj76ysLKS3XTgREcWD4TYREVEGEwQh7nIkixYtQn19PWw2G4LBIACgp6cHPp8PdrsdiqIgEAggOzs7uk8yb+6IiIiIMk2yZd4iJElK84iIiCge4lgPgIiIiJJnGAYURRlxv0WLFuHVV1+NhtabNm2Cy+WC0+lEYWEhnE4nXC4XfvGLXyAQCEDXddhsNr5RIyIiogkv2TJvZzKbzTCZuH6QiOhsY7hNRESUwXRdh8PhQEFBwZD7OBwOvPzyyxBFEY2NjZg1axYqKysHlDJpaWlBZWUlZs2ahcbGRhiGAavVes7VkIy8wbVYLJBlmW9UiYiIJrhEy7wN5sSJE2ldFMDXI0RE8WG4TURElME0TYOqqnC73UPu881vfhM2mw1bt25FWVnZiF+39fv9KCsrw7Zt2wCcXok00UWaSNlsNtjtdgQCAXR2diIQCMBut8NqtcJisZxzQT8REdG5IJEyb0MJBAIpv07g6xEiosQx3CYiIpoAVq1aNWh5ElEUcffdd6O3txe33XZb3DW0dV3HihUr0NvbO+HDbUmSYLPZoGka1q9fD5fLhby8POTn5yMvLw8ulwvV1dXQNI2lWoiIiCageMu8Dcdms6XUjJuvR4iIksNwm4iIKMP19vbCYrHgmWeeGfBGZ+nSpcjOzsbGjRsTXpHk9/uxceNGhMPhCftV2MgbycbGRjidzmHLtTidTjQ2NvINJRER0QQTT5m3keTk5CTdiJuvR4iIksdwm4iIKMMZhoFwOIylS5fihRdeiFl5VFpaCrPZnHSDJI/HA7PZjKysrHQNd9yIfPW3oaEBpaWlcZVrKS0txfbt2/mVYCIiogkknjJvIwmFQtA0LeHj+HqEiCg1DLeJiIgmgN7eXoTDYRQXF+PQoUOoqqpCQUEBLrjggpQaJDU3N6OrqwuiePolQ//mRuNJoo2XZFmGqqooLy9PqFzL8uXLoarqhC/XQkREdC4Jh8NDlnmLRzKrtgVBQHZ2Nl+PEBGlgOE2ERHRBGAYBnp7e5GVlYXOzk7cfPPNaG5uxuLFi1NukOT3+yGK4oDmRj09PQBOr1SSZXlMVg6l0nhJFEVs2LAhqXItNTU1/CowERHRBKKqKmRZRm1tbVL/xvf19SW0f6QUSTgc5usRIqIUMNyeQE6cOIGdO3fiqaeewpNPPoktW7bgrbfeQjgcPqvj8Pv9ePvtt/Hcc89h48aN8Hg8eOqpp7Bz504cP378rI6FiOhcous6AoEALrzwQkydOhUvvPAC3n///ZQbJCmKgnA4PGRzo8cee2xMmhul0ngpsso7lXIt8awOJyIiosxgGAaCwSBKSkpQV1eX8OunRJpJRl7D/PnPf+brESKiFAlGKu18aVxobW3Fww8/jFdffXXQT4unTZuG8vJy3HnnnaP2laV3330XDQ0N+N///V+8//77wwbql1xyCW6//XZ87nOfS2iVX2FhYdLje++991L6B7+7uzvpY0eTIAjIyckBcPrDDf51pkRw/kxcgiDAbDZDFEVYLBYAgMvlSqo0icvlQlNTE2655RY8//zzQ+6nKApqa2tRUlKCQCCQdEOleEXeFDY0NKC8vHzY1U6DjU2WZQQCAeTl5SU9Bq/XC6vVClVVkz7HuYzPQZQKzh9KBecPDUeSJFgsFqiqipqaGjz++OPIamnBeyMcd/LNNxGeN2/E8wuCEG0euWPHDnznO9+B0+lMerx8PZJ5+BxEqZgI82fKlClpPR9Xbme4uro6lJWVoaGhYcivQR09ehSPPvoobr31Vnz88cdpH8PKlSvxhS98AU8++ST++te/jrhS/C9/+QsqKyuxcuVKHD16NO3jISI61xmGAVVV0dvbC5/Ph1AolHSDJLfbDa/Xiy1btgy739lsbpSOxkuCIKSlXAubOBEREU0skW/CSZKE1atXo7m5GW++8Ubazn9mzw+bzQafz5fS+fh6hIjOdQy3M9jrr7+O+++/H4FAIPrYnDlzUF5ejrvuugvLli2LrtgDTq9edrvdKb+Z72+wUiNOpxPXX389vvrVr2LNmjVYvnw55syZE7PPrl278NWvfjWpVdGCIECSpLj/4z/2RHSu0jQNuq4n1SBJURRUVFTg8ccfj6vE1dlqbpSORpCGYaSlXEsmrpQgIiKi4fVfKBBXE+1wfDW3z+z54ff7YbfbUxorX48Q0bmOhZky1LFjx/Dtb387+qZeEATcd999uP322yGKf/vM4vjx4/jmN7+JP/7xjwCA5uZmPPDAA3j44YfTPiaHw4Gbb74ZN998M/Lz8wf83DAMbNu2DT/4wQ9w8uRJAMCHH36IBx54AI888khC17r77rtxzz33pGXcREQTnaqqsNlsqK2tRWlpaVyBsCRJ2Lx5M/r6+hJ6jo40N1qzZk0qQx5Wqo0g16xZg1AoBIfDgYKCgqTLteTm5qa82oqIiIjGN03TEA6FYB1hP/FYE3DUBCPLCsiTYFgmA2Js5NK/58f+/fsxc+ZMvh4hIkoBV25nKI/HE/MP2D333IOVK1fGBNsAMHXqVNTU1GDu3LnRx1566SXs378/bWOZOnUq7r//frz66quorKwcNNgGTgfwS5cuxaZNm2C1/u2lwbZt2/CXv/wlbeMhIqJYkQZJ1113XVwNkhRFQX19PRYvXozPfe5z8Hq9CV1vNJsbpasRJHA69E+lXIuqqtA0LanjiYiIaGIRerwQTn4M8cRhiF0fQmx7G+KxJgi+DqCvFzAMSJIEr9cbDbIbGhpw8ODBuF+PiKKIpUuX4lvf+ha+973v4YknnkBfXx9fjxDROY3hdgbq6urC5s2bo9uzZs3CnXfeOeT+sizj+9//fnTbMAxUV1enbTwbNmzAypUr4/4K+ic+8QncfvvtMY9t27YtbeMhIqKBdF1HT08PiouL0dbWhqqqKhQUFMTs43K5UFVVhfb2dhQVFeHaa6/F7t27E75Wc3Mzurq6IElSuoYf1f9NYaLOHFs4HE6pXMtoN80kIiKi8UEIjPxBvxgKQDzVBvH4RxC8H0A41Q7h1McQu1shdbwL8eM/Qeh8H73tzVDMp8tmhsNheDwerFy5ctjXIw6HA/fffz8OHDiAV155Bffeey++8pWv4O/+7u+QlZUFq9U66j1PiIjGK4bbGWjHjh0IhULR7eXLlyMrK2vYYxYtWhSzovq1115Db29vWsaTzMq8z33uczHbXLlNRDT6BmuQ5PV60draCq/Xi6amJqxZswYWiwUdHR1JBdsRo9XcKJ2NIFVVhSzLqK2tjTuIj5RrkWU55t9iIiIimpiEk0cgnmofcb9wzgUIO1wI58wCZAViyA/xxGEI3hYIJw5B8LUDJw5DCXXh8pkmXHVeFgpzJWz5dQ30Xh+e+vX/DPp6ZNGiRdi3bx/uvfdePPfcc3C5XHA6nSgsLEReXh5cLheqq6uhaRpsNtuoLC4gIhrPGG5noJ07d8ZsL126NK7jztwvGAzizTffTOu4EjF79uyY7a6urjEaCRHRuaV/gySr1Ypp06bBbrejr68PsiwjGAzCZrOldJ3Ram6UzkaQkXItJSUlCZVrWbJkCYLBIJs3ERERTXBC90GIp9qAQJzvV0UJMGfDsM9AOPcihKdeCGQ7AEGEoPpgdB/GJLUdiwqdOH+SiNmTRUwTT+L7FaVY4pqExl8/ggscf3s9smjRIuzYsQO7du3CrFmzUFlZOeDbay0tLaisrITT6URjYyMDbiI65zDczkBvvfVW9NcOhwMXXHBBXMdddtllMdt79uxJ67gS0dPTE7M9GnVZiYhoeJqmQdM0SJIEVVXx6KOPwuVy4Ytf/GK02WIyIs2NRqNsh67raR1bZDV7POVa2traUFRUhEAgwJIkREREE5lhQOj+CKK/E/C1QwyeTO48JhmGLRfG5PNh5F4EbepcaFYHrrnmWsxQRBQ6TPhEngmhjib85Lv34NL86fjrjt/g1z/9Dj7/mctRt+V5NDY2oqysbMRvrvn9fpSWlmL79u0sUUJE5xSG2xnm6NGjMY0k582bF/ex8+fPj9n+8MMP0zauRDU1NcVsz5gxY4xGQkR07pIkCTabDY2NjXA6ndHVQIk2N+pvNJstapqW9kaQ8ZZrkSSJwTYREdFEp4Ugepsg+o4Cp9ogBk8irOSl59yiCYZ1Cj5745fxoS8LH3brOBYIQ9UMdBz+ED+9341tT3uweMF8bNn0c1iO/RXrvvVl5E8CplhGDqt1Xcfy5cuhqmrcPbGIiDIdw+0Mc+DAgZhtp9MZ97EOhyOmNnf/c51NdXV1MdsLFy5M6Pg//OEPWLNmDYqKinDZZZdhwYIFKCkpwapVq/Dkk0/i0KFD6RwuEdGEIwgCLBYLGhoaUFpaGrMaKN7mRoM5G80WR6MR5FDlWqxWK3w+HwKBAFRVZSkSIiKiCUzo8ULsfBdCTxeEk4chqqcQtjsBsz1t1wj1hZCVlYUf/OABBDQRR3vCOHwqjP1eHX89cgovb92Kh757D059uAe/q3sKjiwVc6aI+OR0Exaen4WCqRKmZ4uwDPHlZ7/fj5qamoRLk5hMJsiyDIvFAlmW+e1qIsoYDLczTGdnZ8z29OnT4z5WEISY/fuf62xpbW1FfX19dFuSJJSUlCR0jj179mDHjh04cuQIAoEATp06hYMHD+L111/Hww8/jKVLl6KyspK1vImIznDmmxabzQZN07BixYpBw96amhrouo6nnnpq3DVbHO1GkJHV4cFgcNRWoBMREdE4EtYhHD8A8fgBCIHjELoPQNBDCE++ALBMgpjOGtYGEAqFcOWCK/Hjf/93WK3W6I9OhQwc6NZhm3UJJk2/ALtf24FZk0XMc5hQMFWCUxExJ0dEoUPCp87LwienmTBZHrii2+PxxBVQRxY72Gw22O12BAIBdHZ2IhAIwG63w2q1ssQJEY17/Cguw/SvVZ2dnZ3Q8Wfur2kaQqHQWf26Ujgcxve+9z309fVFH7vppptw/vnnp/U6uq7jxRdfxB//+EesX78el1xySUrnG6//mJ85rvE6Rhq/OH/ODYIgwGw2QxRFyLIMr9cLv98PRVHgcDjw5z//GU888QRqamrg9Xqjx3m9Xtxwww3YuXMnXnjhBdx2223R1d2iKKKkpAQXX3wxFEWB3+/HwYMHsWrVKpSUlCAQCMBkMsUEz7qupzUkVlUV1113Herq6lBeXj5sHUpFUbB58+bo2CK/LzS2+BxEqeD8oVRw/lAMLQTx2H4g1APB1wlBPQHDMhmGMgNm+XSwm2WRRzyN0HMM6J0EZFkBkwUYZm6FjTBCaghXXHEFnvvNc3jppZfw29/+Fkc+PgIAmHnBHHT3yfj9/naIAqCYBUy1inDaRQiCCD0MnFINWKQwplgF9PYZ6Oo10OkPo6fPQHNzM7q6umCz2Yb8Np0kSZBlGaqqYsOGDfB4PDHNKgsKCuB2u7Fq1SrYbDaoqsrSbGnC5yBKBefPQILB79dmlI0bN+KnP/1pdPuHP/whVqxYEffxX/ziF/GXv/wlur17925MmTIlrWMczs9//nNUV1dHt6dOnYqXXnoJU6dOHfHYwsJCzJ49G0VFRVi4cCEuuugiTJ06FZIk4fjx4/jrX/+Kl19+GVu3bo35R3fKlCnYvHkzZs2aNSr3REQ0nvX19SEYDA77pmXlypXQdR033HADdu/eHXP8woULUV9fD0mSUFtbi56eHnzhC1/A7Nmz0d7eDr/fj8mTJ2PatGnRD0wj//d6vejp6UF2djYcDseofKAaub+amho8/vjjMffncrmib8pkWY4pzUVERERk9AVhdLwHI3gK6D4I6H3AZCcEaw50TUcoFMKLL76IPz3zG/z0nY+HPVffXblA3v+tH5TMgHUyYJkMWCdDsE0FlGmAkgdByQPs0wDrlGgwpfVpMGWZcOrkKQSDQUyePBknTpzArStujbmGKAC2LAG2LAG5VgFmSYBfNXBCNXBKDSOkAx/7wvioW0frwYPDvgfWdR3btm2La5FAbW0trrvuuoRLnRARnQ0MtzPM+vXr8cgjj0S3f/zjH+OWW26J+/gvfelLeOutt6Lbr7322llr5rht2zZ885vfjNYrFQQB1dXVWLx4cVzHv/HGG7j66qtH/GTqL3/5C77xjW+gvb09+thll12GZ555JvnBExFloETetDz11FMoLi7G4sWLBwTcDocDDz74IO644w6EQqERV/cIgoCvfe1rePbZZwf9ucViSXvQHAnOu7q6ooF6bm7uWf+GEhERESXvbH5AboQCMDreh6H6gK6PTq+0njobgklGWA9jz549ePBfH0Rvby/mhAz8sn34b6DFhNvxyLICk8+DkHM+kHM+hJwLAMeFp4NwACdPnsRNN9007ClyLKdXdCtZp98jHwsY6PDrCGrAKzteR07ezNOButkWO9a+Pmzfvh2lpaVxrcaWJAn19fUoLi7mYgEiGncYbmeYmpoa/OxnP4tuP/jgg7j11luHOSJW/5Xbu3btimvVdKreeustfO1rX4OqqtHH7rnnHnz9618flesdOHAAy5cvh8/niz725JNP4pprrknqfCdOnEjTyNJLEARMnjwZwOkXP/zrTIng/Jm4BEGA1WpFY2NjQm9atmzZgoULF2LevHkxJUoWLVqEHTt2oLGxMaY8yWBGCsrPXP0TCATS+vXW0S6FQunF5yBKBecPpYLzZ3xJpDxGZL+UXz8ET0H0tgB9PRC7D8EQRRg5syFIWZBlGX/605/wz//yLwiHdWSJwNfnmHHTqz3DnjLhcHsIhmUyjKn5kKYVoOqXdfjdvg709A0/RyUByLWJmJ4tIqQbMOfMwM8f8yCoGdAhwlCmwZh0HvB/96dpGpxO57Cv6fpTFAVtbW0wmUwx7+spcXwOolRMhPmTk5OT1vOx5naGsdliP3ENBoMJHd//H6FEa3YnY//+/Vi9enXMtVesWDFqwTYAXHjhhbjzzjvx8MMPRx976aWXkg63M+HJwjCMjBgnjU+cPxNL5I1feXl53G/+dF3HihUrcPjwYdxxxx1Yt24dgNOrtuvq6tDY2IiysrIRz+f3+1FWVoYtW7agvr5+QFDu9/tRWlqK+vp6FBUVIRAIpG3u9fX1xfR0oMzB5yBKBecPpYLzZ2xJkgSr1YqGhoYhv2nW0tKCyspKPPDAA6itrY320Egq4DYMCP6jEE4cBEJ+CKc+hiGaYeRcAIgmZGVloa+vDw/+64MIh3W4pkr4p6uzkd8HYIRwO12E4EkIbe/AaHsHay8FvnlJDlpP6PjrUQ1/Parh7Y4+dAdj56xuAEd7wjgZDMNpl1Be9GloRz9AWNNOlz/RNcB/FIYtF2LeHGyo+WVCwTZw+jVcTU0N1qxZw78zacTnIEoF589p4lgPgBLTP9yONMaK15kNKU0mE2R55MYYqTh06BAqKipw6tSp6GPXX389fvCDH4zqdQHglltuiSlhsmvXrlG/JhHReCCKIjZs2JDUm5ZNmzbB7XZDFE+/RKioqIAkSbjtttsSDspNJhPuuOOOQX++fPlyqKrKkiFERETnKEEQYLFY0NDQgNLS0hFft0Q+IN++fTssFkvijdRCPRCPvg/xxEEIvd0QThwGTFYYObMA0RQd04svvghN7cXX/t6KR5dNQn5OfGsCd9qWIrx8I4LLfobg4u9DvfqbCF2xEn2fuBla/jXQp38CYWUGDDGxsh6iIODCKSaUFlrwz59R8OwXp+CJz03CnZdbcflME8xnlMFWdaBDNWNh6VcRnjoXsOVC7D0B4fiHEHydyOrpRFbXfrz6zHpMkhNvROfxeCDLMkym0VsnGckpLBbLqF+LiCYGPktkmOnTp8dsd3R0xH2sYRjo7Owc8lzp1tnZia9+9as4duxY9LHPfOYz+OlPfxoNTUZTbm4uLrjgAhw6dAgAcPToUfT19bFGGBFNaJE3BB6PJ6njPR4P1q5di5KSEjQ0NMDtdmPTpk0pBeU/+9nPEA6HB/w8svqHiIiIzj3JftNs+fLlaGtrg9lsjrs8huA/CqG7FYIWhODrgNDXC8M6BYYy/XStbZxeRZ5lzsJff/cCqj8Xf6gdsfN3r2HJPauhiTJ0fRqGXEtphE+H66faIPjaIZ5qg3DqY4gnDkHQ4vtm9typJsydasLyT1gR1Az8qb0Pbx4K4a0OAz9++D9htsjQNR2mHCfC2bkw/McgBk9A6jsFX7cZoa4j+PsZJpxSDbT5wjjWEx56vGdobm5GV1cX7HY7JElKWwk4QRAgyzJEUYQsy/B6vfD7/VAUBQ6HA8FgEIZhQFVVrlIlogEYbmeYCy+8MGa7ra0t7mO9Xm/M17Xz8/PTNq7+jh8/jpUrV+Ljj//WUfrKK6/EY489dlbD5dzc3Gi4DZyunZ2Xl3fWrk9EdLZJkgSv1xtTqzIRzc3N6OjoQGFhIQBg9uzZaQnKt27dOuTPQ6EQa2MTERGdY1L5plncH5AbYQjdrRB7vEDgOAR/J2AyI5wzCzDHlugU9RB6X/8FvndFEKKQeFTS0dGBUydPQZbl4cN6QYRhy4VhywVmfBLRPY0wBP9RiN0fnR7z8QMQj38EITx8yTWLScDVF5hx9QVmGIIA4cD/QPVfCr/jk5CnzMDkyZMRki2Afh4QPAG18yMUOiScCho41hvGJFnAhVMkdPh1tPvCUEf4nMHv90MURei6npbgWZIkWCyWYWuur169GnfddRcURYGmaQiHw+ytQkRRDLczzPTp02G326ONEvft2xf3se+//37M9ty5c9M6tgi/34+Kigp8+OGH0cc+8YlP4IknnoDFYhmVaw6lt7c3Znu0y7AQEY01QRASfpPYn8/ng91ux8UXX4z29va0BOWDhduR1T9Wq5VvToiIiM4h6fqm2bAfkPcFIHZ9CCHUA/jaIQZPPddASAABAABJREFUwbBNhZGdBwh/+yaxJEmQOt6FtOe/gJ5j0ZXc0dPoBl7a34svxjGu3t7e5N/zCiIM+wzo9hnArEWnH9P7IJ08iKzuD2F07IPe9i6yMPRrJsEwgI73IXe8jyzjKfy5U8M7J7LhuOJzuO6GW2CelIcswYJDJ3Xk2UTMnSIhqBnoChiwSMAFkyR0+sM4eFIfMuSWZRkPPvggfv7zn8c0+8zOzoau6+jr64v7dZ0kSbDZbEPWXHc4HLjllltw8803w2az4dixY+jp6eGKbiKKwZrbGeiKK66I/trr9eLw4cNxHbd3796Y7QULFqR1XMDpBpd33XUX3nvvvehjBQUF2LhxIxRFSfv1hhMOh2NWtmdlZWHSpElndQxERGebYRgpP99GPkRVFCX6YWqyIkH5UPx+f+I1M4mIiCijpeObZl1dXZAkaeAPDQOCrxNi53uny390t0JUfQhPOu//ypCIgACYzWbICEHeswHS79adDrb7OXDCwJqXT+HF5lBc47JarekNWaUs6FMvQvCi6xC+9p8g3rYJ4uf+HaF5pejLyYcxzGsoURBw2YwsrLw4hKWnnsdbD69A2x9exKRJdmTnnofm4zo+OK4jqAFOu4j5eSacZ5dw3iQRC87LQmGuhOys2PO7XC7MmDEDTU1NAP7W7NPpdGL79u0wmUyw2+2wWq0j1kUfqeb6okWLsG/fPtx777147rnn4HK5MG3aNOTn5yMvLw8ulwvV1dXQNA02m23wuUBE5wSG2xlo8eLFMduvvPJKXMdt27Yt+mtZlnH11VendVx9fX34xje+gbfeeiv62OzZs/Ff//VfmDJlSlqvFY+9e/fGNLK8+OKLz/oYiIjOtshXRAsKCpI6/sw3LX6/f9hgOh5nfttoMIqinDMrbdggiYiI6LR0fNNs0A/I+3ohHtt3umlk4DiE7lYAQHhKPmA5vdBJFEVYzDKMA28g9Juvw/jwtQHn1iGh75PLMW3lBlidhXGNZ8aMGZg0edKAPiNpYZx+vx3qCyNonw3xslshfu7HEL5Yg4+c1+ONQ33o1YZ+PZUlCfj0eRKc+/8beu1duP+6OXDaRfT0GTh4Usf7Xg3HAmFMtQqY5zDhfLuE8yeJuMJpwiXTTMixnP59drvdaG1tRUNDQ8z5I80+t27diuPHj2PTpk0jhs7D1VxftGgRduzYgV27dmHWrFmorKwc8EHImcF6Y2MjA26icxjD7QxUVFQUU7f62WefjamlPZhdu3bho48+im5fc801sNlsaRtTOBzGfffdh9de+9sLg5kzZ2LTpk2YNm1a2q6TiMcffzxm+x/+4R/GZBxERGeTpmlQVRVutzup491uN4LBIDweDx588EHMnDkzLUH5UD/Pzc2Nu4lUJoqsSrLZbLDb7QgEAujs7EQgEIh7ZRMREdFEk45vmvX/gFzwH4XY+VcIPV0Qug9C9HUAlhwYU+YAptPlKUVRhKz7cHLLv8C0az0sxsCGlH/u6MPXtnTh5gd+iff3NeM/q/4zrpKe/3jtP6Iv1Dfqr2sipT8AICTK+MYjz+GHr/lwy+ZufO9VH7Z/qCLQN3TQLfR24+K+9/HfN+Xgx4sVXHVeFsIG0NkTxj6vBm/v30LuOTkm3HDtAvzr3bfiiR9+He6v3oadO3cOOa4VK1ZAFEUcPHhwxNB5qJrrDocD9fX12LFjB8rKykb8ECQSrG/fvp2vqYjOUYJxriyXmmAefPBBPPXUU9Htb3zjG7j77rsH3VdVVdx888344IMPAJx+o/38889j/vz5g+5/5MgRFBUVRbfPO++8If8Bi/jBD36A2tra6LbD4cCvf/1rzJkzJ95bGtKJEyegqiqmT58e9zGPPPII1q9fH92OfN0pkXOcqbu7O6njRpsgCMjJyQFw+veJf50pEZw/E5fFYoGmaXA6nQmtilIUBW1tbdFGSIZhQJIkrF+/HpWVlQmPo6qqCmVlZZg7d+6gq5iqqqqwZs0aBAKBhM+dCeJpkBSpUynLMoLB4IQO+vvjcxClgvOHUsH5M/Yi5StcLldSpUlcLheamprg8/mghYKnw+xAF9DbfbpppJgFwz4jtmmkEYbl4OsI/+nXkMIDy4z0hMJ44k+9eOUDFZEZIYoSfvSjf8PfydmY/IXhG1gGXngS5r+7GMFgMPZ1j2EA4T6gLwhBCwJGGIBx+vH/Gxc0FYIeAqQsGJIZkMyAaIIhSn/bTzIBYhYgSoAgwmrLxrvvvYe9e/eit7cXhw4dwlt73kLYCMMsAVedl4XFc2RcdX4WzNLwgW+bT0ddk4qtH6rwhwxMmTwZt3yuCEs/swBTJys42ashaJoM6+SpyHHOxcFTBp7Y+EvU1NTA6/XGnOvM13+CIKC+vh5FRUUIBALRv2vD/flXV1fjS1/6Es4777ykXsdKkgRVHfihxXjC5yBKxUSYP+mu7sBwO0N1dnZi2bJl6OnpAXB6ct9///34//6//w+i+LcF+cePH8c3v/lN/PGPf4w+9rnPfQ5VVVVDnjvRcLuqqgpPPPFEdDsnJwe/+tWv4HK5krq3/vbt24fly5ejrKwMN954Iy6//PIhP409dOgQHn744QGNy77+9a/jnnvuSXoMDLdpIuL8mbgEQYDNZkNjYyNKS0vjCkwlSRr0zUcqQfnhw4fx0EMPYd26dYP+PFPegCRjpAZJZ1IUBbW1tSgpKUEgEDhnAm4+B1EqOH8oFZw/44PNZkvpA/Q1a9YgcLwd4vGPIPT1Av6O000jrVNgKNNimkYK3R9B3vtLCMc/GvR8bxwK4dE/9qCrd+BcsFqt+M2Pfwrl5uG/FXfy6f/ER0YP5l+UDzXYA+gahLAOGHo0oDai4XR0ZKcbSZrk04F2WIOgqafDcF0Dwtr/NbgUIBhhQABMpiwIAExZWQhqAvokM0yyAuvkKeg8dhz1L76Il156CSdPngQAZGcJ+Mc5Ziy7SEahY/iSaL19Bv5wPBsLbv8hRPt0vPLyy3h1ax3Cvg5YTAKO9xqQJs/Ass/fiKW3fBla9nTccPNy7N69O3qOyAcPy5Ytw9atWwd9zSfLMgKBAPLy8mKuf/XVV2PHjh2pz4txvnCCz0GUiokwfxhuU9Tvfvc7rF69OuZT4Tlz5mDhwoXIycnBwYMH8eqrryIYDEZ/ftFFF6G2tnbYr4AlGm4XFsbWIBMEISZgj9f7778/6OP79u3DTTfdFN3OycnB/PnzMWfOHEyaNAmiKKK7uxt//etf8d577w1YHbhs2TL853/+Z0pfT2K4TRMR58/Elmi4unnzZixZsmRAuJpsUL5lyxZcddVVmD9//oAVPUMF6RNFOj9cmMj4HESp4PyhVHD+jA8pfdPsyCFIpz6G1v0xEPJDONUBwdARts+M1tYGAPT1Iuuvz0H6oBECBv45dwXCeGxPD35/aPgyn9+9+VYs/c9fDbvPL0ry8W6gG//6459CNJnRF8bpIFv8vxXXWZbTvx6EIYiAyQLoIQhhbdB9RMGAWQSMsA412Itsq4yTRz+G6u+GxZyFSZPsCAT7kDXFiSAs+O6//POA99j5ORKWXiRjyYVmTJKHfs9uQMDvDvbh6Xd7cKD79OuYXKuAGYoEUQCOBwz4DDPu++fv44prluG65Xfg97v+ED2+vb0dDz30EH7+858DGBg6WywWdHZ2Ij8/P3qMw+HABx98gMmTJ6dnRb82+O/jeMDnIErFRJg/DLcpxpYtW/DDH/4Qvb29I+47b948PPbYYzj//POH3S/VcDtZQ9Vk7R9ux0uSJKxZswarV69OubEEw22aiDh/Jr4zy2LU1NTg8ccfj3mj4HK54Ha7UVFRMWxZjESD8qeffhpFRUVYvHhxzEqeyM+HCtLTzWQyQZIkCIIAwzCg6/pZeaOTalmYibqavT8+B1EqOH8oFZw/40OyHwa/8vzTuObvzkfQdwLwd0LsPQHDnH26DIlkPr2jYUA8sgfmd34NIXhi0HO98oGKJ/4UgD808p//p6dOw0/e/njYfe66wIQmUcCaNXfjxhtvRDAUOh1mS+bT5UaysmGYbaeDbkGIrsiGIJ7eJ7IYS+8D9NAZQbcAUZJgNUvQen1Qg73Y8sLzqH9uM7wdhwEAJgG4cNZ5KFt6LT674FKYzDIE0YSH/9//w5/3f4iuQPh02P5/ZAl45iffgHLk9xC6Dw57X384EsJ//6UXTV06RAFw2ETk2USIAtCtAnf/0wOY98lL8Y83fQV/afXCANDc3Iz//u//xo9+9CMAA0PnwVZu33///fj+97+PkydPwul0jvhnMhSv1wur1TquX0vxOYhSMRHmT7rDbTaUzHA33XQTnn/+eRQXF8c0mTxTXl4e7r77bmzevHnEYHs8mjFjBlauXIlPfOITMJmG/xoVAEyePBm33XYbXnzxRXz9619nx2QiOmfpuo5AIABJkrB69Wo0NzfD6/WitbUVXq8XTU1NWLNmDSRJGjZojpynuLgYbW1tqKqqGtBk0uVyoaqqCm1tbbj22mtx++23D/iKauTnkdXJoxFsj4cGjkM1SBqJ3+9HTU0N/90iIqJzgmEYCAaDKCkpQV1d3YgNJvNyFOx8phrXzp+O0IlOCF0HIAZPIWyfAWPyBdFgW/AfhfmNhyHvXj9osH3whI5vbzuFh3f1xBVs59lEZIe8I+738akwPjiu4ye/fAnmi/4B4pxFCDsvQ3j6JxB2uGBMPg+wTgFk5XQt8CwbkGU93ezyzNclUtbpn1unwMjOA5Q8WB0XAJOcaHz7I1xw2WKsvPchPP+HA9h9pA/vH9PwYbeOP+4/gnVP/Bpf/tYDePdAG0RbDu5Z+0+Yk2fHPIcJsydLmCwLEACoOiC6iqAv/THUf/wXaBdcdXr1+CCuOt+M9ddPxr8vVuDKlXD0/xpPdvaEkWMGnvU8BFNvN9y3Xo8rnSZMtQqw2+3w+XzRczQ3N6Orqyv6GkfXdTgcjujrSVEU4Xa78fbbb8cclwy/38+mkkTnGK7cnkC6u7uxd+9edHR0oKenBw6HAxdccAEuv/zyCfNGORQK4YMPPsCRI0dw9OhR9PT0IBwOY9KkScjJyUFhYWG0cUU6ceU2TUScP+eeVFcyC4IAs9kMURRhsVjQ1dWFnp4eZGdnIzc3F6qqQhAEhMPh6M/9fj8URYn+XNd1hEKhUZlv46GBY1obZI3jr9OmA5+DKBWcP5QKzp/xZeRvmhXgO6u+hBXLroZZNNB3/AiM3pMDV2uHNZiaXoHp/d9CCA8sM2KIWfivP53Es+8HoQ3scz1AdpaA8yeJkCUB1m4dP/1gYBPKM30CQKQISDpXD1ssFphMJmzduhVlZWXDvnaxmwXMmixiksWEn657CJ+68nI8/ev/QV3tf2OKVYAtS4AeBuSc6fhZ9UYEQ+Ho+eS+kzjw0mM4r7cJVtPQ76f3fBzCf73Ti5bjOiQBmK6IqFhxCz552eW441vfw+Q8J371bB3KKtbity9vjx7X2tqKadOmRcumnllzfenSpXjllVfw4x//GCtXrjzrK7fP9rf9+BxEqZgI84dlSYjGAMNtmog4fygVJpMJJpMJVqsVwOlVMn19fTE/P5tvEsZLA8ehGiQlIhO+TpsOfA6iVHD+UCo4f8afwT5A9/v9UGQRU8MnEPJ5EfYdg36qAxAkhLPzAMvk6PFi51+R9fb/QPS1D3r+8MxL0XvJCtz45TuHHYckADkWAVOsIrKzBPT0GThyMowZvWH8sn341zFnhtv9g9xU2O129PT04Pzzz0+43NnHBz9C+FQ7PvfZK2ESDZglINcqoeK2W/CZqxchJJhhWCZDsubAqmTjK1/+Ck4d+xg3FMoou9iCHMvQX/b/XauKTe/04mNfGBfNPh9PPvwgnnj0P3HhxZfi0s+UYMVXVuLjkxpaT+rQwgNf35xZxm3VqlX43ve+h2effRZ33XUXfvzjH+P3v/89GhoaBvTUGk4iiwQEQYAsyxBFEbIsw+v1RhdlOBwOBINBGIYBVVXT/hzB5yBKxUSYPxOmLMmBAwfG6tJERESUIk3TYsLX/m8gIj8PBoNQVXXUV79YLBY0NDSgtLR0xDd+fr8fpaWl2L59e9pLlAiCkHA5kv74dVoiIhrPTCYTZFmGxWKBLMtxlY4cSSRE7O3thc/ng1XUMQ3dsHW3IOA9jFBHM/QTbTAsUxCeemE02BZ6vDD/76OQX//ZoMG2YcmBuvBuaJ/9DiadV4Dzzxu8TGeWCDjtIublmXCeXYL+/7N35uFRlXf7/5xzZs9MErIRwi4QFlt3FG2tlp0qUWoVtdoWwTZCFy190Z9al2ottG9pfSuaChRrWxFURKhbRNwFFbValR0CgSxkss6+nHN+f4wzZs9MZhJCeD7X5SUzOefMc2aes93P/dxfFcoaVPbVqdR4NdzWxJzEdrs9JYKTwWBA0zRWr17drbiz1X//B7aCsWR+fQqfVocpb9SoC5s4v+gHkeKbuo7cVIFct4+mI7uoO3aEpqDOv/7r57pnG/jrh17qfe2LyxePMLO6KINfnGuj7thR6qVMbIPG8o3zz+G9F55gUFrE+T6xwMj5p40mOzu7haEgEAhgNpvZsWMHd9xxB1lZWRQVFVFWVsaCBQt48cUX2b9/P7fddhs5OTlx7XNxcXFc951RU0Q4HGbFihUUFhaSm5vLyJEjyc3NpbCwkIcffphwOIzNZus3M+EFgv7KcRO3v/Od73D99dezadMmgsHOp/cIBAKBQCAQdITZbCYQCDB37ty4XdiqqnLVVVcRCAQwmUwpa4uu611mhnZFqh6IBQKBQCBIFb1W00JTUWv2Ey7/mFDtYUK1h9CO7QEtjDZgOLo9L1KAUQ1i+OI5zC//P5SjO9psRkdCmvAdtKI/Yhj1TVRdIxQMUVRU1GbZbKvEuBwDAywyNR6Nz2vCHGxUOerS2Fur8nFVmMu+d3Xcu1BYWNhGyO0uRqMRk8lESUlJt9YvKSnBZDJRVHQZDX6dfQ3wyz/+E+PAMYSs2egDhqNljUJKyyHoqmdMloFRAxTSjBL+MDz1RUTkfmSHl7p2RG6DLDF7rIW/X5aJ/NlzfHv6LMLpw9m8dTtZNolxuQby0mRu/v6lBA59SNjbGFtXliNyVEFBAX//+98pLCykoKCAkSNHMnDgQAoLC9mwYQNLlixh586dTJo0qdN9tdvtLFiwoMvvPSpsb9myhYKCAhYvXtwmSm7v3r0sXryYgoICtmzZIgRugaCPc1wLSu7YsYNbb72VCy+8kPvvv5/du3cfz+YIBAKBQCA4AelLBRxbF0hKlFQ+EAsEAoFAkAp6zeUacCFX/Re5qQJcVUh1B5BDXnT7QPSsUyIFGHUdueJjzC/fjvHzDUhqW6PcbmeYRc838MOHXue5F15BVVUsZgs6OpdeemksUs0gw4hMhSHpCnVenZ01YSrdGuWNGjsqQnxUGXltt9u5/PLL496NeN3D8SDLMk6ns1t1PIBYMfGhQ4dit9vZvHkzU2fMwm/ORs0/DTVvPFrGYHRHHsaCCRysj+Roj85SGD1AwWGSCKjwzE4/1z/bwMqPvLgCbUVuq1HCse/fDHr/Dzz1x8Xsq2pktzOMO6gxOs/KJRecitZUjVL9OVLdARQtGLfAPGzYMLZt28bWrVs7FLgVRWH9+vWYzeZOzZN9abafQCBIHcctc3vcuHGxHE4gdpL4+te/zlVXXcUll1wSu+gIBMcbkbkt6I+I/iNIlr7Qh/paAcdoDvl7773H008/za5duxLKi1y+fDkLFy7E6/Um3Za+Tl/oP4ITF9F/BMkg+k/89EpNC11HclUgNR5FCnmRGiuQ9DB6Wi66dUDEqQ1IriqM/3kCpeqTdjfT6NdY9bGPl/YFaP6LWq1W7r7rbs6ZeA66pvPhjh386YFfk2sFHShvVGkK6lQ0abF86Ob7v3HjRi7IyCDrW9/qdDdOBQ7b7VRUVKAoSkpqZ6SlpVFRUcHIkSO7vY2ysjI0TSMnJ6fDgtoGWcIuB/netEk4q46QbpLIs3+VO17p0vCEIt+q3SRx9akW5oyzYO6g8OR/q0Os+MDLgUb4/W9+zekj8wj6PWiWDEjLxWKz8/5/PuPaH99CeWPb4p+tif4OkyZNYvz48Tidztjfov1uxowZeDyeTvtd85zvRPPLU/m7inOQIBn6Q//pN5nb48ePbyNs67rOp59+yq9//Wu++c1vctddd/Hf//73eDVRIBAIBAJBL9Hd/E5FUZJ2NNXW1ibl3m49VbuhoYHBgwezZMmShPIi451OKxAIBAJBb9DjLlc1hNRUgVz5CXLDESRPDVL9IVCMaFmnoNuyI8J2yIfhv09hLr2jXWFb1XQ27vLzo+caebGVsA3g8/m4/Y47+Oj97Ujuas4Zkc5dN/8EHyZ21oSp9el8fizMvvqWwrbdbmfTpk1MmTKFn/70p11+X4osx+UeTgRN01ISdzZs2DAURelw0CGs6QRNGXzjykXscqpUeTT21ansr1eRiDi5R2YqmBRwB3VWfezjBxsbeGGvH60dYe3rA42suCSdf/xsMmecdRbB9KHoabnIARemxjJCNft56IHbGZkJpw80YOriNkxVVa655hoMBgPz588HIgaF5cuXU15eztSpUwmFQl3eQ/Wl2X4CgSB1HDfnNsDnn3/OunXreOGFF2Inl/bc3GPHjuWqq66iqKgo6RO7QNAdhHNb0B8R/UeQLMn2oVRUqbdYLFRXVyftaMrLy8Pv9ye8rqIoWCwWAoEAK1eupKSkpIXQPmbMGIqLi5k3bx6qqjJ79my2b9/e7nY2b97MlClT8Hq9J8XxKM5BgmQQ/UeQDKL/xEePuVx1DcldjdRUgaSGINCE5K1HUgPotmx0Ww5IEugaStnbGD97Gsnf2HY7wGfHQvzlfS/76zsWNWUJ8u0ygzOt3Hvf/ShpWchp2YR0mfUvvs7/rlrHF7v3xZYvLCykuLiYBQsWYLFY+OCDD/jF1Kl84PN1ut9vPfII5y9YkJhrvQt6c4Za6987xyYxPEMhzSSRYZYYZJcxKhLHPBo1Xg3ty8NmQr6NP117BkrNrna3q1syCJ1+DerQSaCrmDU/r7/0HM8/9zTuoM7hRhVfGPbWhqnxdn4sLl++nJ/85Cc0NTWRn59PWVkZgUCAkSNHdnn/1Jdm+4lzkCAZ+kP/6TfObYBTTz2V3/zmN7z11lv89re/5YwzzmjXzb1r1y7uu+8+LrzwQv7f//t/fPTRR8ez2QKBQCAQCJIkVfmdx7OAYyIFiTrLi4xmYE6bNi0m6AsEAoFAcLxJuctVU5FcVRGndv1hJHcNUu1+5KZKUAxomcPQ03JBkpBrdmHecg+mHavbFbb9koXfve3m5pddHQrbsgS5NpnxOQayLDKHan08/95epIzB+MxZSAWncc1P7+TzXXtxOp2UlZXhdDrZvXs3CxcuRFEU/H4/55xzDq+//nqX+z1p0qSUCtsA4XCYQCBAcXFxt9ZPJP87EAhgNptZt25dZGacV+fDyjC7nSrHPDq7a1VqvBp5aTLjcgzk2CQUWeGHN9+NPOMeXGf/BM2W22a7kr8R03slmN/6PeawC+OAfB5//m321amYFImx2QZyrBLjcw2Mz1FQOjH8l5SUYLPZeO655/jud7/Lzp07GTVqVFz3T31htp9AIOgZjqtzuz327dvH+vXr2bRpEw0NDUD7bu5TTjmFq666issuuyw2YiEQ9BTCuS3oj4j+I0iW7vahVOZ3Hi8XjiRJMWG7qKgorgfZ1nmRWVlZMWdYRxmYzTEYDCiKErsvUlU1JTnhxwtxDhIkg+g/gmQQ/adrUnp9DQaQXFVI7iokNQyBRiRPLZIaRLdmRuJHFBMAkrsa46frUY7uaHe7uqQgn3oJP1nxCvsOH213GVmCbKtMbpqMQYJ6n06lWyWogSFrOFt3fIHb649dQ7u6vkqShHnfPqwTJ3a6z03vvos6blzC31VXJOOgr6ysjIn08dDRPZoswfAMhSHpMiYF8tMU8jMt/HDefMadezGqMQ100MMB+OLfKJ8/h6S1zdLWFRPBCXOYfesjaHpku0PTFTItEg1+nfJGFW8YvqgJ4w62f1xWVVWxc+dOzj777Ljun6Ic79l+zRHnIEEy9If+k2rndp8Tt6MEg0FKS0t5+umnee+999B1vYWbGyI/qNFoZNq0aVx55ZUdVs4VCJJFiNuC/ojoP4Jk6U4f6q4o3Flkh81mY8WKFSxevDjhfehuAcdkp2rLskxaWhqBQABVVQkGg+1+f6mIbumriHOQIBlE/xEkg+g/XWM2m/F6veTmtnXixovzWDVWtYmQ8xCSGgRfPZK3DkkLo5vtEZe2wRJZOOTFsHMzhr2lSFr7A7dq/mnoZ1+P35LN5Zdf3u4y2VaJgXYlJmpXeVRCGtR4NA7UqwRUcDqdWK3WhAoDyjt3kvGNb3S6TOM776CNHx/3NuOlJ+6dulo3Grm2atUqHnnkkdgAh9UAF58xih9dOZtLZkzF6K8j5KlHM1jR7QPBYAZA9jox/edfSEfbn3W/sybMH7a5OdwYCTnPtEgMcSioOhxqUHGHdA7Uq1S42hbkPnToEAUFBQSDwQ7vn9ojJX26G32nPcQ5SJAM/aH/9KtYks4wmUxceumlPPbYY5SWlnLjjTeSnZ3dQtjWdZ1gMMgLL7zAvHnzmD59OitXrqS2tvY4t14gEAgEAkF7mM1mAoEAc+fOjXvarqqqXHXVVQQCAUwmU5u/a5rGjTfemHA8STIFHJOdqm0wGHC5XHi93g6F6VRFtwgEAoFAkCiSJCV8jYtilGFEpkzwwDbk+kORQpG1+5E9NWBKixSLzBgaEbY1FeXAa1heXIJx9wvtCtuao4DAhYsJXrgYKXMIvnayr21GKMxSGOxQcAV0djrDlLtUKl0aOypC7HRGhG2IXIu7LHbZh9B1Hb/fz4wZM9i0aVOX9zvRuLPp06ej6zpmszmh/VVVFa/Xi6Io3HTTTezZsycW21Je5eSFD/Zx2U2/RkrPx2/LQ3UMBjWIXH8QyVODLIE5Zygfpk/h/ncCVLvb3meNzzVQckkG137NgiJBg19nd22YkKYzOkshzyYzOkthbLZC65anpaURDAYTHthXVZWcnBzGjBkT9zrNKSwsJDs7WxT+Fgj6IH1W3G7O0KFDWbx4MW+88QYPPfQQ3/rWt5DlSNOjIreu6xw+fJjly5dz0UUX8fOf/5x33nnnOLdcIBAIBAJBc3qiSn3rjMh4UBSF9evXYzabCQaDCbXFYDBgNpspKSlJaL0oJSUlmM3mLtsXb553QUEBW7ZsEQK3QCAQCFJGd2pamJSIwHzeECMjMhRsmgtq9iK7qsBki4ja6QURd6+uI1d8hLn0TkwfPoYUcLVtg8lO8MzrCUy/Hy3/tFi7rFZrbBmrAUZkKozJMqADe+tUypu+ErW/cKp4W6VjdLfWxvFEVVU8Hg9Tp06loqKC5cuXtxFpCwsLWb58OUeOHGHixIlcc801rFixoluD4NFZYT6fD5fLhdVqJS8vD6vVGhmcD0sEMk9BzR6DbstCzzoFzZaN5K3F5DrCR9vf4fY77+T1Ax7mb27k2V1tYzxMisQNZ9pY8Z10Rg1QCGmwv07F6dMYnC4zLF1hkF3mzEEGLIav9rG7AnNv5pcLBILepc/GknRFdXU1K1eu5J///GeLUcjW2dzDhg3jRz/6Ed/73vcwGo3Hpa2CEx8RSyLoj4j+I0iWRPtQT+ZjJ5rjvX79+liOd6IPKama1upwONp9SOrt6cfHC3EOEiSD6D+CZDhR+s/xrLWQ6DV7sENmRKaCWYHcNIVxwwfy6ztuxy9ZUM2ZsbgKAKl2H8ZP16E497S7LV1SUEdPJTThMjCltfiboihYbVZu+MF1aE1VZFok/GGdYx6der+GO6izt1bF1UFec3drbRzPWJLmSJKEyWRCUZRYXFlTUxN2u528vDzKysooKSlh9erVOJ1OoOv6JUmjqUhNFUiuSsyShtpwhLvvWMLReh9Vbg3ty5/ia3kGfnV+GkPS24rsYU3n75/4WPe5H03/MqYkXSEY1ilrVPGF4EC9yv/85n+7FScXJdlYOUVRko4kgRPnHCTom/SH/nPSxJJ0xvbt2/n973/P+vXr251e0zyb+9ChQ/zmN79h5syZvPnmm73dVIFAIBAIBF/Sk1Xqo1No43E0lZeXc+GFF+L3+zGbzQm7nZOZqh3F7XYTCoVwOBxYrVYsFkvs/qUnolsEAoFAcGIgSRIWiwWbzYbD4cDr9VJdXY3X6233mtFTxONydZgkRg9QmDTEyKgshYFpMuNyDGRbJSZeOJVw5kjUtK9ymCVXFaZ3/4Jl630dCttqwZkEZjxA6Ixr2wjbAGrAS8h5iOtnnY/NKHG4UWN3rUqVW2NvrcpHleEOhW048d230WhWSZL44IMPeOCBB1izZg0PPPAAs2bNYtSoUSxbtiwmbEPknqOoqIhXXnmlZ/qOrKBnDkUbeCqSI5d/v/MZZU4f2VaZMVkKti89hp8dC/PjfzfyqTYSvVXYiEGWmH+mjT9Mc5Bnk2nw6+yrCyNJUJhlIC9N5rQhdm687Fuooe6Ly709208gEPQOJ4xzu7a2lmeeeYann36a8vJygDZFJhVF4fzzz+fAgQNUVFQAX8WWRP/9q1/9ivnz5x+fnRCcsAjntqA/IvqPIFkS7UO9UaXeYDBgs9liIkBVVRUulwuHw0F+fn4LR5Pf7++WkykVzu3KykqWLl3KCy+8QHFxMTfeeCNmszkmuPd2gczjgTgHCZJB9B9BMvTV/tO8kN/KlSspKSlpMSA8ZsyYNteMnsz/7cjlmmmRGJ6hkGGRMMqQaZEZYJGwGiWcXo1G1cz6p55BlmVCoRD4GzF+sRHlwOtIetsCgQBa5jBCp12NNvDU9hsTDiB5jiEF3BjMETf49374ExrcPg43RmJIuvoVk3Hf9hXnNvQd93FrDAYDdrudi84Yg95wGKsBhmYo2AwSNV6NKnfkN8rIyOAff7oH3nkYW7BtvTR3UOPP2728fiiILMEgu0xumoF5xT9nwvlT8WsG1OxRYLR1q53dme03bdq0lLre++o5SHBi0B/6T6qd231e3H7zzTd56qmneO2111BVtU1BSYC8vDyuvPJKrrzySvLz8wF45513ePLJJ3n11VfRNC22vCzL/Otf/+LMM888bvskOPEQ4ragPyL6jyBZEu1DPV2lvnmcx+WXX86UKVMYO3YsDocDl8vF7t27KS0tRdO+erDuTpxHR1O1ZVlm+vTpjBs3DrvdjtvtZteuXW0+MzoletasWbz00kvAV1OGZ8yYgaIoPRLd0tcQ5yBBMoj+I0iGvth/EhXcOhqcTWWUSeuYLLtBY2SmQrpFwmqQGJgmk2GR0HRwBXWOeVT8qsLvHniAs846C7+7AcPuFzHsfhFJbV9M1Ww5hL92BeqwSSC1M7FcCyN5a5F89eiyAT0tBywZWGxpvP3pAWbOnU8o3PPxXX1J3LbZbH1yELz5fZ7VAGNzDKSbJXJtMvl2maCqc6RJwxPSmTBhAn/6w++peuVh8p3bUNpxk5fuD/CX9z1gtHLfHbdyxsgcgmEN1TEI2WJHzhqBlD4IHRLu580HklatWsUjjzzS4r6rsLCQ4uJiFixY0CMDSX3xHCQ4cegP/eekELerqqp4+umneeaZZ6iqqgLaurQlSeIb3/gGV199Nd/+9rc7nFJy8OBB7r33XrZv3x5bf9asWSxfvrx3dkbQLxDitqA/IvqPIFn6UuY29K6TqfmDZU5ODgsWLKC4uJjhw4dTWVkZc4sPGjSIsrIy/vrXv7Jq1SqcTifLly9nzpw5jBo1qkOhffDgwS2mFCdCZwMAfQlxDhIkg+g/gmToa/0n2VoLPp8Pk8mELMuxHGa3243dbicnJwe/3x8rEJjoviqKgtUks23zEzxw1/9AyE9+mky6RSKg6hzzaDT4dTQdrFYr99x9D2ef8XXCn7+A8sVmpGDbQpEAuimN8PgiwqOmgNJObaywH8lbhxRoQkdCt2WDLQvdYEZ35COn52Ozp/ea+7aviNs9fS+VDO3N0BuaLjM8U4m4uNMV0kwSdb6Ii3vMuAk88MADGOv2E379z6TpnjbbdEt2zFN+hWHQeEI+D4q7AkkLY8gsoEk14A0rmId8nZz8goT7eTS/XJZlLBYLtbW1seMmOzubQCCAqqoEg8GUnyP62jlIcGLRH/pPvxW3VVXltddeY/369bzzzjtomtauSzs7O5srrriCq666iiFDhsS1bU3TuOKKK9i5cycA+fn5vP766z2yH4L+iRC3Bf0R0X8EydKdPtSTbqPedDJFhfQ5c+bw5JNPoigKa9as6XAK+bx581BVlblz5/LMM8+wdOlSli1b1ma7UaH9t7/9bbt/j4euolv6CuIcJEgG0X8EydDX+k+yg7NWqxWfz9dhlMlNN93ET37yE0wmE+FwGE3T4nO6hgNInhoMnmOYZJ1Q/RHee72UrW++w3/LqmjwR763oUOGUlRUxCUzZ2A8/DZ8+gySr/3nJ102Eh4znfC4S9rN1EYLI3mcXzq1jejWTLBmoitGdEcBevqgmMO7N923fUXc7ulZcMnQUdtsRijMjri4s6wyg+wyBhmaAjpBg51vTfsOl82aRu7+59APvNVmu7oko552FcrXLycUDPLav9fx8dtbKKs4xqFGFU8IfI7h/GDBTd2O7Ont4q197RwkOLHoD/2n34nb5eXlPPXUU2zYsIHa2kjeUmuXNsB5553H1VdfzbRp0zAYDAl/ztq1a7n33nuByInrs88+S9EeCE4GhLgt6I+I/iNIlu70oZ5yV6fKyRQIBPD5fF3uiyRJpKVFHspfeuklrr322i5dY0888QQzZ87E7XZTWFjYoTO7I2d3vAjntuBkQPQfQTL0tf6T7ODsggULGDJkCE1NTS3+1npmUU1NDR6Pp2NHt66DvxEp6EYKNCEF3KCp4G9A9jpRDCak9IEY03NxNbnw+XxYrVYcjjTCe15H+uQpJE9Nu+3UkVBHfJPQqd8FW1b7OxNoQnZVoaOj23LBOgBdMaDbctAd+bHClM3pLfdtXxG3e6N+SXfp6l5skF1m5AAFkwyZVpksi0SaKZLTXuWGmd+ZxS/nnIv27qNIIV+b9esdY7jpn5/ibPKRZpQYliEjSRJl9SrukM6BepUm3dateiq9TV87BwlOLPpD/0m1uJ24Spwinn/+eZ566inef/99dF1v4dKGiKidmZnJnDlzmDt3LiNGjEjq85q7vPvqCU4gEAgEgv5OIBDAZos8eESnXneVVd28Sn1HzmpFUXA6nd0StgH27NlDTU0NDocDm80Wl+NH13W2bNnCnDlzulzW7XYzZ84cNm/ezKRJkzpdtqSkhFtuuYXp06fHMrnjpbCwkOzsbFyu9qeBCwQCgSAxetrRaTAYMJvNlJSUdGv96DXjggsuaHHNOP/889m0aVOXM4tuvPHGyHWv0Ylesxcp7ActBEEfBF1IATcSOrp1ACFbDsgKqi9S/NhiNsHh91FfeQq5qaLDNqqDziD09SvRMzqYea2FkTw1SL4GdLMD3TEQXTGjZwxGT8sDuf0IUiAmzgOEQiGsVis2mw1d10+I+hOJous6drs9qW3Y7fZui2GdHQ/hcJhAIEBxcXG7AzWVbg2nV6PAITMwDHU+yLLKDHbIpBl1Thk2BHXo+QSnDcX4XglK7b4W6w9w7eWP3zbxmzeD7K9X2VOrMjJTYVSWQoVLQ5bAE/Rz/ZWX8c+nN3U7X10gEJx4HDdxe/HixbEToiRJsX/rus5ZZ53F1VdfzcyZMzGZTCn5vO64vQUCgUAgEKQWXdcJh8PMmDGD3bt3s3fvXs444wzy8/Pbzap+7LHHuPDCC7nooos6fUCRJCkhJ3h7NDQ0UFJSwtlnn92l48dsNhMIBJg7d27cg+aqqnLVVVdRXl7O/PnzO4wdiQrtY8eOTVjcLi4uJhAI9LuHeYFAIOhNJEnCbDZ3mmEtSVJsdk0yoncqBmerqqpaXDPOP/98Xn31VbZs2dLhzKK9e/fyq8WL+dMDd/OPv/6Zb5w+hkCgEb2pAikUcfTqBhPYstEs6aB89VyuhsPoVZ9g/GwDcsOhDtum5p1K6GvfRc8e3f4CIR+Srw4p4EJHQksfBJZMdGsmWuYIMCSmBYTD4X5//VNVlZycHMaMGdPtmWqJDoLHczxEBxk0TePGG2/k7rvvbrffhTQ41KhxqFEj3y4zOgu8QZ2xA21859yxaN569LRcghffjmHncxi+2ITEV/d+g9MV/jIrnf9738NL+yIid4FDZki6TLZV4qhLw2bUWfjDq/h0fwUmk6nPz2QTCATJ00454t4nOvp43XXX8e9//5snnniCoqKilAnbAOnp6UycOJGJEydyzjnnpGy7AoFAIBAIukaSJCwWCzabDZvNhsvlYsiQIVxwwQU88cQTFBYWUlBQwNixYykoKKCwsJANGzawePFivvWtb8WmFXdEKpxMDoeD2tpaioqKeOWVV7BYLLEZZa2RZZmVK1cmLKi73W7WrFlDcXExstzxbZjX6yU7OzuhbdvtdhYsWCBmqAkEAkESKIqCzWYjHA6zYsUKCgsLyc3NZeTIkYwfP54//vGP+Hw+zGYzHo+H6upqvF4vDocDq9Xa6bWjPVIxOBsdGIZIFMmmTZtiM4va27ZEpNDf+UONnGIP8Lvbfsp/392CyX0UAC19MFr2aPSsUehpOV8J27qOXPER5lfvwfz2nzoUttXs0QQuuo3gRUvaF7a1MFJTBXJ9GYT8aGl56Nmj0K1ZaFkj0XIKExa2Txaau6O7Q6KD4J0dD7m5uRQWFvLwww8TDodjy5nNZtatW4eidOy4B6hya3xUGaIxKHHtz+7EkJaJWncIyVUFkkz41O+iT76NAC37gkmR+NX5dn51fhomBY66NPbWhdGAUQMUsqwyQ60Bnnj0z122QSAQ9A+OW+b2uHHjADjttNOYO3cul1xyCRaL5Xg0RSDoEpG5LeiPiP4jSJZ4+1Dzgk8rV67kvffe47HHHuvUURbFbrfHlZ2YqsztWbNm8dJLL3Wa8Z3qz2oPp9NJdXU1p512WlxitaIobN68+YSagivOQYJkEP1HkAwd9Z+okFdaWsrcuXNbXJ8SiflIpKBdKgoEVlZWsnTpUh588EFuu+02lixZwrBhw9pcXyUg3y4zLEPBbIAcq0yWVcJqlDCYzNz3xxJkew6h1sKnriEf/QjjzueQGw532A4tczihr12Bln8atCfwa2Ekb12kWKQkoaflRpzaihE9LQfdPrDdXO2+QF/J3Iaeq1/Sms6Oh/a2Hb1fCwQCmM3muNdbv+5Jpp55CoHaI2ie2oi4bbIhDxiG1e7gF/O/z4JCNxNy287G318X5u433FS5I7MoIg5umSNNGrbswfzj32/gVjL6nKNfXMMEydAf+k+qM7ePm3N77ty5PPvss6xfv54rrrhCCNsCgUAgEPRDog9GW7ZsoaCggN/97nesWLGiU0dZc9xud1xO6lQ4mcrKyigtLY197qpVq9p1/KRyCnl7RKcMjx07lk2bNrVwpMuyzMyZM7n55pu58847ufnmm2NZ3tOmTYtNDT7eRDNkLRYLZrNZxMMJBII+T3SGUWlpKUVFRW2E7VdffZVt27YxbNgwFi9e3OYasHfvXhYvXkxBQQFbtmzBZrPF5RptHjPRHQoLC8nPz2f37t3IskxxcTFr1qxp0X6jDMMzZCYNMTImW2FgmsS4bIUCh4xf1SlrUPn4iIfnX9+O3LzNuoZc/j7mV36NedtfOhS2NUcBgfN/SmDqPWiDTm8rbGsqkqcGuXY/+OrRrANirnBtwAi0gjPQM4f1WWG7rxEVj+NxR0dpXr8kGAx2uXxnx0N7NL9fMxqN+Hw+pk6dSkVFBcuXL2/TvwsLC1m+fDkVFRVMmToNX9pgwhnD0K0D0AcMh3AQueEQjbXVfHqggl+WNrFhZ9sCmKOyDKyYlc5peZH7jCNNkVzvIekywfqjNJb9F6WhDPTEC3QLBIITh+Pm3BYITiSEc1vQHxH9R5AsXfUhSZJiwna0eGRnjrLOiMdtlIyTqby8nKVLl7bIwY46rFsXpLJYLFRXVzNy5Mi4P6M1e/bs4fHHH+f+++9v87fly5ezcOFCAoFAzPH+r3/9C4/Hw/e+9z2GDx9OZWUlbrebjIwM8vLyCAaDaJp2XMXtRDI5ozVXxDlI0F1E/xEkQ3v9p6NrSE5ODjt37mTbtm1xFRCGxGfT2Gw2VqxY0W4Rvq5Yvnw5c+bMYdSoUUyfPp0XX3wxNrMozSgxJF0mL01GkSLF+3LTZEwKNAV0Kt0q/maG1qFDhvL4Px7H5/bAoW0Ydj7XaaFIzT6Q8Pgi1OEXgNSOb07XwNeA7HWi6xq6NQtsWV86tXPR0weDYkx4n48Hfcm5DYm7qtevX8+0adM6nQXXnFS4w4PBICaTCVmWsVgs1NbWxu4LsrOzY5FzwWDwq2Mk4EKu3YcU9GLyVuFqqOWGX95FUyDy94uGm1h8fho2Y8sBlLCm85f3vTy/N3KPmJcmM8guc+f9fyBj2ARUox0pbyy6bEh5UdjuIK5hgmToD/2n3zi3BQKBQCAQ9G9aF13syFEWD505qaN018m0du1aQqEQq1evbvG3PXv2UFtb22Zbqcr3bq+YU/PcbFVV8Xq9GI1G5s+fz49//GOeeeaZWD55YWEhAwcOpLCwkIceeohQKBS3UzDVJJrJKTIwBQJBX6OjWgoLFixAURSuvfbahAsIBwKBuOpIRYvwJXptsdvtzJs3j5KSEjRNY9y4cVRWVFB3ZB9fzzNwdoGBIekygx0KE3INFDhkPCGN3bVhDja0FLZlSWZIQT6Bz1/G+NJtmN57pENhW3MMInheMYGZS1FHfLOtsK1r4KtHrjuA5K5GMzkiTm17Hlp6AVr+6egDRpwwwnZfJHqPELc7+suBlnj7cDK1RaL3a9EBbZ/Ph8vlwmq1kpeXh9VqxeVy4fV6YwPeMcwOtLxT0a2Z6ANGYLJnMTJTYZA90sfeOBRk0QuNlDW0FKcNssQtk9L46UQbigQBg4Ozp1xGhlnG0HSUQH0VdV+8ibfR2e18fIFA0HcRzm2BIA6Ec1vQHxH9R5AsXfWh1k60mTNntnCUJUpHTurmJOpkWrt2LVOmTGHy5Mls3769zTJlZWXk5eXh9381FbanMrfbc/p1N+8ykQfYZOlOG2fMmBErwAbiHCRIHHENEyRD6/6jKEq753VZljlw4ADPPPNMt13VCxcuxOv1dtme1jOdukJRFDZu3Mh5553HhAkT8DQ4uf+2n3PFjG/xg+uuwWqQyLXJZFokNB1qfZG4hlCrdIaMjAwuu2QG3/1aJvbDr4GntsPP1NIHE55wGeqQiR04tXXwNyB7a9HVELolHWy5YDCh2bLQ04eA8cSMI+1rzu0okiQl7o7uglTd53R2v9Yluoax8RA2fNy84PvormN4wzqHGlRCGtiM8P++aef8IW0Hj/Y0mSj4/v+iWDJ45YVNfPrGv6muqeFgvYo7pON3DOf7829KOB8/lYhrmCAZ+kP/Ec5tgUAgEAgEfZ5o5nJJSUnsvXHjxlFZWZlUVnV7TurmJOJkKi8v57zzzutQ2IaIGNv6hjHV+d7Rz2mdm51M3mVvuZG628bS0lJRb0UgEPQZOqqlMH36dIYPH97iWpYIJSUlcdUd0HUdv9/P9OnT29RaaI/oNWP6tGlcd8UlFMgNTBxsxOw7hl1zU5ilUJitkGaCoy6VL5xhKt1the1zvz6etbfO4XrrNuw7n+5Q2NYyhqJ/6xZCMx9AHXpe+8J22I9UX4bkqkIzWtGzToH0wej2PNSBp6Jnjz5hhe2+TLfc0V2QitoiXd2vdYkkE8ocSSitgAumX86+OhWjLFGYbSDNKOENwd2vu3nyM1+bVQvTgxheuotfLpjL/5Ws5J3dlYQ1ndFZCpkWCZv7EA/c+auE8/EFAkHfRYjbAoFAIBAIUk57D0Z2u73dKI5EcLvdXYq2UYHbZDKxaNEi9uzZQ2VlZez/u3fvZs6cOSxdupQJEyZ0KGxHCzu25+ZJ1RTyzqYMt451iYdEp8InSzJt9Pl8BAIBQqGQeKgUCATHFUmS2h2c641B2SgJxUwcPsjUieMJH/4QqWY3BQ6ZYekK1Owh0xggM3sgB+pVdjpVan06WitdM88mc+f0Ifz27AZMOzchBT3ttmlfXZh7Xndx+eo9fOg0YrZakeVWEkLIi+SqRK4vA4jEjaQPRrcPRM2bgJZbCKa0eL8yQRJEB9/9fj+BQKDbrumOjodEiOd+LR40Rz6XzF+CX7KwpzaMP6xzygCFAV/OSFj1sY8H3nYTVFt2ckuogf/9tomz8g2ENNhfr+IJ6YzMVMiySEzINWDH2+umAIFA0DMIcVsgEAgEAkHKae/ByO12x2Ioukt7Tur20HU9Fu2xYcMGli5dyuOPP87SpUuZNWsWo0aNYtmyZTidzg63UVxc3OHDYXfzvdevX4/NZmPRokU4nU52797NwoULURSlTZRIKvIue5pk2rh69Wqqqqp45ZVXhGtKIBAcVzqqpdBbg7JRogK3oijcdNNN7NmzB6fTSVlZGU6nk12ff8rC703GUPUp/opdGHxOli0ppjDHiM0Eb+z4gmPaAM6ZejmuYNtr5chMhf+5II3H52Rw8UAvktp+geZPq0Pc/qqL4uebeLs8hNfn4/Y77uDDHR9+OXCqg78JqW4/cv0hCHjQbDnoA0ag27K+ErXNydWnEBwfUlFbJN77ta4IBAKY03NY8ud/Uh+Q2F+v0uDTGZahMCwjUih168Egt7zchFc3t1g3zSTzwBQH004xoelwsEGl0a8xLEMhN03hulnnc+fPb2DHjh1omiZmlAkEJzAic1sgiAORuS3oj4j+I0iWzvqQ2WzG6/WSm5sbe683MrdbY7FYCIfDFBQUJCTA2u12KioqUBSFQKD9h/9Es6bXr1/P9OnTCYVC6LqOruuoqtruvvSJvMsuSFUbL730UhYtWtQia1wg6ApxDRMkQ7yZ2zfffDNLliyhoKCg25/ldDpJS0vD52sbn9AVBoMBRVGQdA3dU4tWewDN7wHPMaSAG1kCU1oG/9lTzq8f+AM+n49rr72Wa66+hqvmXhX7zIkFRq4Yb+Gcgs4LOL5bHmTd534+r2n/umG1WnnmiceRPTWofje6yY5uywJTGrokozsGoacPaj+25ASnr2Zu9wR97R4kdr/18svcXnwNGYqfTLPEkHQFVYeyhjABVebJvz2M9Pr/MkCra7ONNf/x8q//+snIyODqSy5m+gVnM2D4OOoDCk2SHfuQCeQNHBiLhks0yiVRxDVMkAz9of+IzG2BQCAQCAR9HlVVycnJaTGlurS0lEOHDiWVVZ3oNNtkHNZms5lgMNjhcglNIf8ydsTj8eDz+bqcMtwn8i67IBVtrKqqYvTo0b0apdITRDPmLRZLXPm6AoGgb9FRLYVdu3YxaNCgNuf2eInGWxmNxsTOx5oK/kbUukOEjnxK8MC7hKt2oblqkOoPIAe9kJaDOmAkgbQCTj/vQp55+hkWLVzExx99jKqp3HX7bVwyxsKq2en8boqjQ2Fb1XRe2R9gweZG7nrd3aGwbZQhzxTkvRfXISsy2oDh6JlD0R0D0bJOQSs4Ez1jcL8Utk82UlFbJJlYlNbE7remTeOtL45yzc/uwpo9mN21YUKazugsA3MumUruiLEs2erjjbK2poR5Z9j4zczB/H3Nai69egHv/nc/D9z2C37+o6uYd8UMvv21wYwtHMPDDz9MOBwWM8oEghMM4dwWCOJAOLcF/RHRfwTJ0lUfstlsrFixgsWLF8feu+2221iyZAnDhg1LuZO6I7rjsJ42bVqbmJCOkCQJk8mELMtYLBZqa2txu93Y7Xays7MJBAKoqkowGIz7OLNYLFRXVzNy5Mi497M1ZWVl5OXl4ff7u72NzkhFG/fv38/bb7/NvHnz+N///V8WLlyI1+tNYSt7DkmSMJvNyLKM2WzG6XTGfvecnJxec3+drIhrWN8n5jqWpE5nqhwP2us/7c30kWWZAwcO8Mwzz7S4lsXL8uXLmTNnDjt37ux6doqug68e2VsL/kYkXYuI3CEfBN1IQTeSGkK3pKPbB4LcbBBNAqPBiCRLGFUvwU82Y9j/KgQ6jlQJqPDCXj9PfeHnmEfrcDmAbKvEIIeCqoHsGMhDf/sn3pBEyD4IrJkJfy8nIieTcxt6duZbd2l+v2U2SDTs/QB/QzVpoXrSDCouzcyc63+MrsOPz7Zy5QRrm200pI3gxn/upN7tI8sqMcSh0BTQOdSo0ujX+e+xMNY0O+vWrWP69Olx3wt2Z1/ENUzQXfpD/xHObYFAIBAIBCcE7RVdXLVqFaqq8sQTT6TcSd0R3XFYJ/IwExUwfT4fLpcLq9VKXl4eVqsVl8uF1+tNWODsS3mXHZGKNmZkZPCDH/yA/fv3o2naCeN6jg6YhMNhVqxYQWFhIbm5uYwcOZLc3FwKCwuF+0twUiJJEhaLBZvNhsPhwOv1Ul1djdfrxeFwYLVauyzcdrxmQrQ300fTNEpKSpg3b15SBYQ7nZ2iBpGaKpAr/4NSuw+pqQLJVYVUdwDZuQe5sRw56AaTHS1zGHr64JbCNoAO4Zr96G8/grruJxi+2NihsO3TjfjHzubaZ+pZ8YG3U2E7wywxOkthSLpCg09ntzPMx/uO0qBkIw8+/aQRtk9GenLmW3dpfr/l9gUxDzuDzCGFGHNPIWzOItRQzdhsBbtJ4q8f+njoAw9aq/ugTE8Zv/2WkQEWiTqfTlmDit0sMSpLYYBV4ox8A0GfWxSaFAhOMIS4LRAIBAKBoEdo78HI6XQye/Zspk6dyrPPPtulWGC329m8eTPTpk2LOWG7Q1dFujor7JgI0am8XcWOxNPe1rEuiRCdCt8TbqMoqWrjggUL2LBhAzfccAPBYBCjsfNM2ONNVNjesmULBQUFLF68uE00y969e1m8eDEFBQVs2bJFCNyCk4JkBn1SIYoni67r+P1+pk+fzqZNm2LXp+4Oyq5du5ZQKMTq1avbFvrVwkieGuSa3cgV/0FuOIzkPhYRtOvLkP0NYLSipRegZY9Cyx6N7sgHU1rLD9LCKIe3Y9p6P5ZXfo2h7E0krYPrTuYQAmfNg+89jGvUTBoDba+nEpBulhjskBmfY2BEpgI67KtTOeJSOerS+OBoCJduRZKFlNCf6eh46IhU3a/FSzgcJhAM4bcPIWDLQ0vLwTBoLIFwpHDqAIvExl0B7n3DTVhv2VcLsw38ZVY6gx0yTUGd/XVhzEpkICfTInFGvhED6gkfmSYQnEyIK5JAIBAIBIIeoaMHo+3btzN58mTOP/98Dh8+nHIndWftSbXDuqfo6bzLVDgjU9HGsrIy1qxZw+LFixk2bBhbtmxJPJu2C1LpAo0KcKWlpRQVFXU5VdvtFu4vwclBMoM+fWkmRHszfQYMGMDs2bOZNm1a3CLfxo0bmTJlCkVFRTidTgBKSkow6UGMDQeRKz5GrjsYcWk3VSLV7kV2VYFiQsschpY9Bt0xCCwZoLQjrPnqMHy+Acvzv8T03iMotR3XPlAHfo3Ahb8iOON3KOOmYbGlY7W2jWuwGKAwW2FkZsT52ujX2e1U2VevUuPV+LQ6zN46FVXv+ZlBgr5BT898SxV6+mDCeaeSWTCGYNog6nw6wzIUsq0S246ouC/4JQFaHkf5doU/z0jnlAEKvjDsrQsjSzA6y0C6GU4bGHFwtxiUEggEfRaRuS0QxIHI3Bb0R0T/ESRLvH1IURQsFguBQIBVq1bxyCOPsHfvXnJycpg/fz4//elPGTJkSEqyqvsTqc677ImM6GTaWF5eztKlS1m2bFnsfUVR2Lx5c9fZtF3QU3nYfTGD9GRFXMP6DpIkxYTtoqKiuISt6LE+depUZFnm5ZdfjqsmQqpycLvqP+3VUjAajVgsFjweD4899ljsWhalsLCQ4uJi5s2bRygUoqioiO3btwOQY4tk+7720ibMCoRcNUj+JiQtjK4YwZKB3pGQHUXXkZ27Mezbgnz0w0gmd0eLygbU4RcQHjMDPWNIi78pioLVZuX6667nyNEjmBTIssrk2WT8YZ3DjRp+VUfTod6ncdSl0eD/6vspLCxk9+7duFyuPpOh3hucbJnbzemJ2iKJEG9+v81m45//dz+Pr1hGgV0hN00if/TXufW+P/I/P76OX3zNQ4GjpVDtDmrcvtXNFzVhDDKMGqAgSxL76sI0BnS86SP5fOeelPd3cQ0TJEN/6D8ic1sgEAgEAsEJRUeRIDt27OB//ud/GDJkCKFQCIfD0Wed1KkkXidxKvMue8oZ2d02Np+u3xxVTX4acE+6QGVZZuXKlQkJ20DbSAKBoB9hNpsJBALMnTs3bsFZVVUWLlwIwMsvv9znZkK0N9PHarVSVVXFsmXLmDNnDnv27KGysjL2/927dzNnzhyWLl3KhAkT+PD97QxNlzl3sJEJuQYGOWSCx/ZFokf8jWB2oA0Yjp49Gj0tt2NhO+RF2fcq5tI7ML/+O5QjH3QobOuWTEITLsd/yXJC58xvI2xD5LsPBUNcMXsmowcojM8xkGOVqfHq7K1Tcfo0PjsW5t3yEJ/XqC2Ebeh6ZpCg/3E8Zr51J6pI0zSuKl6CM2Shwq1S4dIYW5BNY9lnfLy/gp+/1MTu2pb91m6SWTbVwdmDDIQ1OFCvAjqjBiikmyQsjQepPVYlrt8CQR9HOLcFgjgQzm1Bf0T0H0GydLcPxevA6U9010kcFWpLS0vjcjWuX7+eadOmtXA1JrqNRJ2RiW5/7dq1TJkyhcmTJ8dcja1Zvnw5CxcuxOv1dvn5ybQlkX01GAw4HA4KCwvbxC3Ew8nqduwpxDWs72Cz2VixYgWLFy9OaL3bbruN2267jSFDhvT6TIju9B+z2YzX6yU3NxdZlpk+fTpjx47F4XDgcrnYvXs3paWlpBl0hqTL5NhkZAkyLTK5NgmrUeL+3/0BY2Y+IcUGUic+M11Hrt2LcuANlCPvI6mdF+dTcwpRR09FHXx222KTbRYOYgrUo3kb+J/b7+ZIvZemgI6qw5EmjbIGlY6+jZN5FsrJ7NzubZrP+Fu5ciUlJSUtrrtjxoyhuLiYG2+8EbPZjN/vR1XVFrNIbvr+5QxPhxt/MJep54zn1/feR1mDilGB+77t4PSBLet7hFSdB95289bhEEY5Ek+iajr761X++fQmBoz7Bv6gcG4L+gb9of8I57ZAIBAIBIITmlQVXTxRSMZJnGzeZW9kRCfSxvLycs4777xOhW2IZNMmmo/d0/uqKApOp7NbwjbAnj17qK2tFe4vQb8iOhOlpKQkofVkWaa4uDhWbDERjtdMiOZFdDVN46WXXuLBBx/k/vvvZ8VfHuTTd0o5PU/mzEEGBqfLDHYonJprYFiGTEgDvzUf+8gz0MwZHQvbATfKnpcwl96O+bXfYjj0dofCtq6YCJ9yMf5p9xH89h2oQ8/rXNgOB5CajiLXHSDsc2HIHs51v/g11V6J/fUq7x8NcbATYbujmUECQSpJJr+/ea2XR/61kYMeM3VeDePAMRhkiTHZkePj/73qYvuRln3YqEjceaGdmaNMhDTYXx/GoEiMGqBgk0Lo1TuhkygggUBwfBHObYEgDoRzW9AfEf1HkCyiD3VNqpzE3c277M2M6Kg7XVEUTCYTtbW11NXV4XA4yM/Pp6ysjJKSElavXh0rsNYZTqcTq9Ua9+f39L5aLBaqq6sZOXJk3NtuTVlZGXl5efj9/m5vQxBBnH/6Bs3dzIkwc+ZMXnzxxeM2E6K7/ae5S10ikqU9ME1hgFVCkiDdJJFtlUm3SIQ1qPNp1Po0giosWriIyy67rO15RteQa3ahHHgd5eiHSFrn+6PZBxIePRV1+DfAlNZ1o0M+JG8tUsCFLhvR07LBkoFssmLOH8Mr7/6HuVdf3a2ZQScTwrnd8yST39+8Vkdz5/drLz/PpecV8qNrrsDoqcJqlDjUoOIJ6dz6jTQmjzS32eYjOzw8szOAWYELxhbw63t+g9+WT8gyAD17dMr2VVzDBN2lP/SfVDu3u18uXiAQCAQCgUDQIa2dxF09pEWdxO0VVIxGlgCEQiGsVis2mw1d1zsVd5LNiI5m4sZD1DGlKErMUfn444+3mK6vafG7ntxuNzabLe7le3pfdV3HbrcntO3W2O32E/IBRCCI0jpWSlGUhI85gHHjxlFZWZn0TAir1dqrs380VeXG66/in3++Byt+DDLYDBJZVpkMi4RBBm9I53BjJKs6erRbrVYuueSSFudAyVODcugdlLJ3kD3HOv1cXVLQCs4kfMrFaANP7TzSJErIh+R1IgXc6IoJLX0QmDPQFSO6Ix/VnoemmJk6bRoVFRUtCj5HiRbJXLBgQWwg42QUtgW9Q3fz+6+66ioqKiowmUyxwX6v14vJZGL6pZcT1lWmFl3F3x7+E8MzFEZkKpQ3qSx9x4MnqDN7rKXFNm86Jw2TIrH2Mz9fv+hSwgEPWqAcOUNHMxxFzxjcE7svEAiSQDi3BYI4EM5tQX9E9B9Bsog+1Dm96Zpuj+OZEW21WnG73Qm7OZuTiHO7N/ZVZG73LcT5p/foqmaA0+lM+Fi/8847uf766xk7dmy325XMTIiE+o+uQ8CF5KtF9jVgMSp89MF2/rz0XjJMOmaDRFCFBr9GvV/D3+rwlmWF3z3wAGeddRZ+dz1K+QcRUbtmV5ft1OwDUUdeRHjEN8GS0fWO6RoEmpB8jUghL7piQk/LAXM6usGE7hgUKV4pfxXp0t2ZQScbwrnd83Q3vx86r9Vhs9kIBvx8++tDSZP8DHUoZNkkjrpUnF6d+WdaueZr1jbr/eOzEHPvX4ccdKPWlqGl5UBaLtqAEej2vG7tYxRxDRMkQ3/oPyJzWyAQCAQCgeAEIFkncbJ5ssczIzoUCsWyabtDYWEh2dnZcTu3emNfo1nxxcXF3fqM4uLikyJjXtC/6KpmwIIFC7p1rLvdbhwOR1Jt6/GZECEfUsNh5Mr/oNTsQm48Cq4qQlW7OXt4Onf84ieoipl9dSo7nWEq3W2FbavVyu9+ez9nDzKgvfkglk0/x7RjdafCti4bCA+dROCi2wjMXEp43CVdC9tqEMldjVy7D7mpEiQJLX0wetYp6Gm5aFkj0Qadju7IbyFsw1czg3w+Hy6XC6vVSl5eHlarFZfLhdfrbVPsWCBINd3N74/SWa0On8+H2WLlNw+vpcoD5S6VYx6dwQ6FfLvM6o99rPyorSh+/deMGHduImSwotvzkD1O8NYh1ZeBt65b7RQIBD2DELcFAoFAIBAIOiH6wGWxWOIuctiTD2nxIklSt+ICmuN2u+MqKtma3haCe2tfNU3jxhtvTDiexG63s2DBAjGd/ySkO+ePvkI8hd3WrFnDoUOHEj7Wd+3axaBBg3ptACxutDCSpwb52E6Uqv8iNx5BclUj1R9Ert2P7KlBkxQCljzGXljEg2ue5kc3LmTI4CEtNjN0yBD+30+uZeOvr+SsstWw5bcoh97tsDgkgJ4xmOAZ1+K/9EFCk25CyxvfdfxI2B8rEom/Ec2SgZY9Cj1zGLpj4Jei9mkRl2kcUSYnW8FnQd+hJwepY4UmZ8zgT3/fSE3IQqVbpcKlMTBNZrBDZt3nfh76wNNmXemT9Rg+exbdlo1uy0J2VyP5G5Fr94GvoVttFQgEqUfEkggEcSBiSQT9EdF/BMnSn/tQV9Pw/X5/zO3W3n53t8hacxItqNjX2tCbsSy9ta+pKnYlSJ7ePP+0zplWVbVT0S/Z80dfIJG+ftttt7FkyRKGDRsW97EuyzIHDx7k6aefTnkEQTy06D/OY+CrR/I1QKARSdMg5AF/I1LAhQToJju62QFmx1cisQRGgxFJjsR6NDU2Eagpw+78BFPFDmg40mU7mgIaH9SYkMdczDeKfojRZCIYDHZen0ALg78JKdCEFPK1KBKpy0pEhEvLA3NyNQIELRGxJD1LbxRtbl5ocu2jy3ljw9/x1FYwNF3GFdRR7YP4xczxnB74sM26oQmXEZ4wB8lVCf5G9Iwh6JZ0tJyxYElPuK39+R5a0PP0h/6T6lgSIW4LBHEgxG1Bf0T0H0Gy9Nc+1PzhZ+XKlZSUlLRwEo0ZM4bi4mJuvPFGzGYzfr+/jfDTGw9pXXG8M6J7UwjuzX2NullLS0uZO3dup2Ke3W5n/fr1TJs2TRRiSzE9ff7prkCdivNHb9OeeG8wGOIenMrJyWHnzp1s27aNOXPmxH2sf/755xQUFPR+XQJdRwp5yTDr4KnDVVcFmg4hLwTdSP4mJC2MbjCBJRPdkgFyx457yVuL4cj7KIe3R+IKukDVdN47GuKVAwG2HwkR+lLHtlqt3H3X3Zwz8RwC/kD7Are/Cdldha5rYEpDN2eA2fFlkciBEVFbMSb+nQi6RIjbPUtvDlJHM+bNYReN+z/E3+jEFqwlLWMAYXsB+p5XUXasabNuaHzRlwJ3BQTdEYHbnI6WOy7hwaT+eg8t6B36Q/8RmdsCgUAgEAgEPUQ80/D37t3L4sWLKSgoYMuWLdhstjbTYHVdTzi6ojXJ5ske74zo2DTg6dPZtGlTl9+H3W5n8+bNTJs2LSYcxktv7quqqni9XqZOnUpFRQXLly9vE61QWFjI8uXLqaioiAn1x1vAFMRPVznThYWFPPzww4TD4RbHf6rOH72BJElYLBZsNhsOhwOv10t1dTVerxeHw4GiKPznP//BYrF0uS2n08ns2bOZOnUqzz77bNzH+qhRozCbzaxbty7u70BRFNavX4/ZbCYY7Djiow0hP5KrGtm5B/noh8jHPkdzHkRrPIrUWIFUuwe54TCyvwnMjkjBuKxR6Lbs9oVtXwPKvlcwbb0fy/O/xPDJk10K23trwzz8gYe5zzRw1+tu3jr8lbANkVzg2++4gw93fIjJZIJoSpKmRopENh5BbjqKZkpDzx6NnjEU3ZGPNmBEJE87fXDcwvaJHJcj6J+oqtortTqaZ8y7dQumoWeQkT8M48Ax+L1ugtV7CQ77BsGzfthmXePOTZh3PoucOQRMaUiNR5ECLmTnbgh8NUAnji+BoPcRzm2BIA6Ec1vQHxH9R5As/a0PpdJpfLxd01F6MxqkI5o7WVevXs1nn32Gw+HAbrfjdrtxu92ceuqpzJ8/Pykna2/va3P3l8Vioba2Nubszc7OJhAIoKoqwWDwhD82+iI9df5J1Jm/bt06pk+fHilYZjafEJE18brL582bh6qqzJ49m+3bt3e53UmTJrF582YUReGxxx7jkUceabHdwsJCiouLWbBgQexYB3pmJkQ4gBRwQcCF5G+MZF3rGoR8EPIiBz1YjRKg4w3pYLKjm+xgsEAH2fuSpwbl6IfIR3Yg1+5DouvfS7dl8+zHVby4x8vBhvjOazarlaf/9RhyyEvY70IKB0DX0RUTelpOJH7EOgAtYwgYrXFtE/pHXM7xRDi3ex6bzcaKFSt6P6oo5EWu2Y0U8CA1HAYJ9AHDMJe/h/z+qjaLS2fOJTyhCOrLCfua0DKGgjkd45DTkK3pcR1f/e0eWtC79If+I2JJBILjgBC3Bf0R0X8EydLf+lCqxdFUPKQFg8GEsn5b01cyomVZxmqNiDAmk6nNQ1/Ugenz+TrPmu2E47mviWYyC5KnJ84/yfShadOm4fP5jutAUjwkKt4/8cQTTJ06lcmTJ8clcOfk5DB//nzuueeeuAd9movtq1atiksUb/Pb6HokUuTL7Gwp/GWcU9gPQS9S0AMhL5Kugaygm9KwDcgDUxoef5B2dWpdR3JVoBzZgXJ0B3LD4S73H0A3p6MOPRf5lAvZ+M4XPFzySFzr2U0S2VYZh1niissv5xsXfZuAbogI2KY0UEzosiFSLDItJ65tRjkR43L6GkLc7nmO64B8yI9cswsp6EFpOoLRYCDkGMxnmx7mDP8HyK3GvD41ncG4y3+J0VOJGnCjZI8kqFhZ88J7/OWvf+vy+NI0rV/dQwt6l/7wDCbEbYHgOCDEbUF/RPQfQbL0tz6UasdQdx/SRowYwa5duwBS4q473hnRvSmqHO99FfQePXH+6e4xm56ezrFjx46P4zABuiveb9y4kUmTJjF+/HicTmdcn1VWVkZ+fj6qqsY16NPtmRBBD5K3NvKfGgItBAH3V2K2poIkoRttkYxqUxooZpClWHyK2+3+StzWNaT6gyhHP4q4tF2Vce2vbrShDjkHdegktNxxKEYTVpuV66+7niNHOy4saTFAhlkm0yJhMUj4QjoNfh1HTgGr/v4PfF4fYdmEbnagWzIjheukxJJFuzsbQZwXWyLE7Z7nuA/Ih4MY6vZgIcDOt19i5epVfFHlZepIE7+6oG3c0sMfBTn3+7dzzug8Du3bxf88sIKqRh+fVIXwtXOqaz3bx+FwAP3jHlrQu/SHZzAhbgsExwEhbgv6I6L/CJKlP/WhnogR6c5D2je/+U1KS0sJh8OsXLmSRx99lJEjRzJu3DjsdjtWq5Vx48Yxbdq0hITglDgju8HxEFWO174KOifV7vaeOP90d4Br5syZvPjii8c9hqgrknFFlpeXs3TpUpYtWxbXOvEUduuI5n1F+jIiRNf1r/qNz4XkrYsI2mF/RND2uyIxJCFvpI8ZrGCyRURto7WtICzxlbhdX4Nc9RlK5X9QKj9FCjTF1U7dYEEddAbqsEloA7/WIu/aaDTiD/i5/PLL26yXZpTIsEhkmCVMioSqQVNAp9an4QnphFSo9Wps+2Q3lsxcAqHun5+Ou1jYjxDidu9wPAepJUnCZlJ4f/Nj3HfnEkZmSGi6zv56lZmjzNw8Ka3NOr9/18vk+XcxYVAav/3NXXxyuJHGAHxcFSLYTnOaH18mkwk48e+hBb1Pf3gGE+K2QHAcEOK2oD8i+o8gWfpTHzKbzXi9XnJzc7u9jfbEnEQe0qZMmcKLL77IK6+8wqJFi7j66qspLi5m+PDhVFZW4nK5cDgcDBo0iEOHDuH3+xk1alTcD3S9lRHdXJgyGo18/PHHfOMb3yAUCnW5bmcZ5okIoz29ryKGJD56MuM31eefZAa4br75ZpYsWUJBQUG3Pz8ZMThekp2dMmfOHEaNGtVldFCyYn2bflNTg6f+GHYlxACzTtDTAKpKyF0H/saIe/tLd7ZuSQeTvf0ikM0/w12FtW4X+uEd6NVfRBzecaCbHKiDz0QdfA5a3oQOCziaTCbq6uu45pprAJAlGGCRyLHJWAwSQRWa/DpNQQ1XMNJ3G/06FS4Vp1dHJ+J+z8vLi2WTd4e+UHehvyDE7d7jeA1SR4+XkUMLGGUPkG6GUQMMMYH78rEWis+xtVhH1XR+/16Qm//4L0qffJQtr5Syry5MrU/nk6pwu4lH0eNLOLcF3aU/PIOlWtwWZVsFAoFAIBCc9EiSlNCDf3u43W5stlYPPaqK1+tl6tSpVFRUdPiQdssttzB//nxeeeUVfve73/HBBx+gKApr1qzptNhbKBTCarXi8Xi6vLGNiohAbD2bzYau60k7RjsTMSdOnMiePXv461//yqpVqzqNNVBVlauuuoqKigpMJhOSJHVLGO2JfRXF2BIjkTgam8123B30iqLgdDq75by22+24XK6kPr+980cqMRgMmM1mSkpKurV+SUkJt9xyC9OnT+ell17qdNni4mICgUC3jjNFUbAoEGioZN0/17Bx/RPUV5djkEEGxo8s4NLpF3PRpLMxKwohyYTqyEc3OzoXtMMB5JpdKNWfI1d+guyuiolO7ZeP/ArdOgB18Dmog89GyykEWelyP3Rdx2q1YjVAllVmgFVGJuLQPtKk4gnp6HpE0Hb6NJxerY3L0263d3uAL4osy6xcuTLh65vb7WbVqlUsXLgwofUEglQQvXcymUzcdNNN3HLLLR0OUqdydkH0eKltdON2w+n5RvbXhxk1wMCoAQobdvmxGOBHZ3x1rlZkif85z8T7zz/GBZdew6tbXmFEpkJYUxmdpbC3ru11LXp8LVq0KObeFggEySGc2wJBHAjntqA/IvqPIFn6Ux/qKed2lK6cxOFwGJ/Px5w5c9i8eTNbtmzh2muvjavY23e+8x1CoRA+n6/bbU+GeEXMefPmoaoqs2fP7rIw3dq1a7niiivw+/19oviZKMaWGL0RR5Pq84/FYqG6upqRI0cmvG6PO7fDwUhhRKMFlO4JIak4x1VWVrJ06VIefPDBDpdJ2PGrBpG8daAGUSQdixRmx7tvcu9v7kUN+rAoEjaThN0oYTNKSBJ4Qjp+TPxs8R2cfd4kAv5AWze5riHVH0Kp/gy5+nPk2r1IWvxiu+YoQC04E3XI2egDRiaWc62GUEJuLAR44N67qDhWQ61Xo86nEdIiju0Kt0atV0PtoNtG3e/R77A7A2o9Ebd1MiOc28eP3pgt1d7xYlYiAneGGcZkGfCEdA42qNx4lpW5p1pbrB9SwXzJPdz1f4/TePA/NPh0yl0qu50q1Z62s12ixxec+PfQgt6nPzyDiVgSgeA4IMRtQX9E9B9BsvSnPtSbIkB7D2kmk4m//e1vXHnllWzbto05c+bEnY26adMmpk2bFpd7O9UkKmI+8cQTTJ06lcmTJ3cocJ9//vls3bqVrVu39oniZydTMbZUCAi9lfGb6vNPMuJvj2Zua2Hkyk9isRmyyYJssiIppkjms9FGWDJFxFdZ6VCETUa8j7Jnzx4ef/xx7r///nb/3unvqOuR+JBAE6gBQEJSg+BrQNI10MJYTAY++WgHK5YvJc2go3y5K2EN3EEdd1CjKaAT+lInkmWF3z3wAGeddRb+gB/J7UT+UsxWjn2BFIzfrazLBrTccaiDzkAbdDq6PS+xL0cNxfZPCnnRAZMjm+e3vsODJatRNTjm0ahwRXK1u2L58uUsWrQoqQG1nh60PdkQ4nb/pqPjxWKAM/ONDLBKnJKpUOvTOOrS+Nm5Ni4ba2mxrK6Y2OD5Gk9ufpVhGQrlTZFBrE+rwzQG2h73TqeT7OzsE/4eWtD79IdnMBFLIhAIBAKBQJBiwuEwgUCA4uLibuXRJjINPxwOt1guGhfg9XpRFIVrr702blFUVVXmzp1LZWUlVqsVr9ebcNu7iyRJWCwWSktL4xIx3W43c+bMYePGjWzevJnx48e3iSjJyclh06ZNvPLKK3EJ/G63m6Kioh4rftadfezJ9vQEqY5bMZvNBAIB5s6di67rzJw5M1YQ1e12s2vXLkpLS1s4bVvH0RwPIU1VVXJychgzZkzCAnVpaSlHjhzpmfNHyI+kq5g8VUiKgoE0XPV+/MEQZnsmGVnZBINB0CEYCqKb7Oi2nK9iOiQJNBU9qGFPa1sMLREcDgduVxMStMmRjRZ2mzr5Inx1FRDwRAR5LYQU8kUKPeo6aCqowa9W9DciBRoxKgphVWXdyuUoksYxr44vpOMPfyVmt2agTeetx+7jDM8ULDW7kDw1ie2QNRNp6Nn4c09FyzsVDJau12lOOBApYhl0IYX8ke/EaEOzDwRzOrrFyvTv/ZBb//wvDh5zdejSbo3dbufGG2/kwIEDTJw4sd0Btb1797J48WLuvvvuDgfUeipuSyDoj3R0vPjD8EVNmNMGGjji0hiaLhPW4KH3vVgMEjNGmb/ahhrkEst/2WyScHo1hjhkQqrOqXkG/lMVwtuq9IjH4yE7O7und00gOCkQzm2BIA6Ec1vQHxH9R5As/a0PHa/CW1Fh2+Px8Mwzz3S72NvChQt7VdxO5vsqLy9n6dKlLFu2rMXfbrvtNpYsWcKwYcP6RPGz/l6MrSfiVmw2G3/72984fPhwhwVRy8rK2s1gb92PO3OS98T5J5mCi2+99RannXYagwcPTmlfUcI+LPV7CVXt4t233+Ttt96mob6WsWMLGThwIBkDcigYNpKRp4xCMZgIyhY0gzUiajffjqJgTbNTdOX32XPgEKoeMVPrRLKfZSkS+RFdSyJSBDH63siRI/j3s+v5wwP38cILz6PpEFRhYMEw5lx1NVfOuQyTpBL0uiIDF1oYNA10NeLUDvmRwr7I/5s3TDagWzMx2Qew+fkXWfHXR9E6+CmHpMucPtDIaQMNfD3PQF5a19nXzdElBS17FNrAU1EHnY5t6KlIkhz5veLpProGQW/EER50I6khdEkGU1pkMMFkB1lBV4zoabmQlostI6tbsxguuugiTjnlFKqrq+Nep/WAmnBupxbh3O7fdHW8DEyTGZujkGeTGeSQqXRpOH0ad3wzjYtGmFssW+VW+cVLTaSbZdKMEvvqVBoDOh9XhVpk6wvntqC79IdnMBFLIhAcB4S4LeiPiP4jSJb+1od6K06hNRaLhaamJgYOHHhCZaMmIwQuX76cOXPmMGrUqJiDV5ZlDhw40KcE/mT3sbcHHBKhJ+JWovE+dXV1SJLUZUHU1hnsieQMB4NBMjIygO6df9oTzg0GQ7cHM44cOYIsy7z++usJxQp1dv5QFAWrorJj0xqe+Mt9BDBw9sWXUHTpbPJys2g4VonfVYfVZCAjI52Ax4VR1gmqGhqGiNAqSREHta5jsmfy/Cuv8deVf0NHbyEiR0Xsr4RnKSZuA9w4fz6XzJyGQhiPqwlfIITFZseemUVYAy0cJOz3oof9SEFvm3xrXTEhm9OQLXYkoxVd19E0HVUyoBgMWG1Wrr/ueo4cPQKASYHCLAPjcw1MyDEwIddAti2B3Osv0RyDImL2wK+h5Y4DozW6e9jtdoDOxe2Q70sx2xsR53UdXTaim+0RMdtkA0lGN9rQrQPQrZlgtMW+uESPs/Xr1zN9+nSmT5/O1q1b497P9gZJROZ2ahHidv8mnuNlsENmVJbCwDSZfLvMUZdKg1/n/m87OKfA2GLZA/VhFpe6yLfLGGSJfXWRaJJPqsKENJG5LUiO/vAMJsRtQYc0NDTw0UcfUVVVhdvtJi8vjyFDhnDWWWchy4nfDCaLx+Nhx44dVFdX09DQQFZWFoMHD+bss89OWVXg6upqPv30U6qrq/H5fAwcOJCRI0fy9a9/PSXbjyLEbUF/RPQfQbL0xz7UHSFi2rRpSeUrm81mNE3D5XL1XEG6FJMq0WTWrFm89NJLQA/nFneD/iwM9dRAjtVqxWAw8OKLL8ZdELV1BrvT6SQtLY2HH364Syd59H4y3vNPVxEsgUAARVF4/fXXmTlzZtzfy8aNGznvvPP4wQ9+wIYNG+IuCNvZ+SP6G7320maW3nwdM846heKbf4WcXsCLL77Ipk2bYkIwwJDBQygqKuKS6ZMx6wGCfi9a+Mv4D1kBXcdIGC0U4K577iaYwHnCZDbzm3vuRVIUdNmIpBiQdA1dDaGHQ19FzEgyusECRiu60QKSArKCyWJHUhSMJiONjY34fD6sVisZGRkEg0FkJHw1h/jznYuYkGtgfI6BUVkKBlnqvGHtoJscqAMnoA38GtrAU9FtHUz570jc1rVIhErQAwFXxJ0ty2BMQzelgTENDKbI4pZ0dEsmunUAGMztfw4tZ0isWrWKRx55pEW/LiwspLi4mAULFmCxWHj66ae59tprE9739gbU+vMAXW8jxO3+TzzHy7AMmRGZCoPsCnlpEkeaVDwhnce/P5osra7Fsp9Wh7jzNRfDMhTQYV+dSsOXAvcf/hjJ1TeZTP3mHlrQe/SHZzAhbgvaUFZWxh//+Edee+01QqFQm7/n5eUxd+5cfvzjH6dMVO6Mmpoali9fzksvvdTuzVBmZiZFRUX84he/iN1UJsqnn37Kgw8+yLvvvtu2OjowfPhwrr/+eq677jokKfEb49YIcVvQHxH9R5As/bUPJSJExBvV0BlREXXv3r0UFhZ2eztlZWXk5eXh9/u7vY14ScV098rKSpYuXcqDDz4IwM0338ySJUv6jMDfn6f090TciiRJpKWlUVpaymWXXZaQMDxp0qRYBvvBgwf5xz/+wV133dVpO9atW8eMGTNQFCWu808iESwWi4UPPviAGTNmdClQr127lilTpsQE+kmTJrF582YUReGxxx7r9vkj+huNHVHA5eeNZvntC/lsbxl3/v4hfD5fh22yWq3cfdfdTJw4Eb/f3/I+WQKLIvPxRzv4zX2/iQi5kbdjLm79S5U3ElkCkqRw7733cuaZZ+IPqUCr+2otHPlPNkT+a4Ysy5hMJkKhEP/+979jgnyuTWZMlsJZIwZw3ug88g3uSKHJblDv0/i0OsTZ3/kB1pFnE7TmdlhUswVfitu6puKpr4mI2dHoFF1Hlw2RqBGzI+bE1g0WdEs6uiUj8r4cf/kqSZIwmUzIsozFYqG2tjY2sJKdnd1itkIqB9T6e7RSbyLE7f5PvMfL8AyZ4ZkKBXaF3DQJZ9BIyaOrCD53KxlSS/3j7cNBfve2m1MGGFA1nX11Kh4svPrpERzp6UD/uocW9A794Rks1eJ279t5BSll06ZNzJkzh9LS0naFbYBjx47xl7/8hauvvpqjR4/2aHveffddioqK2LBhQ4ej/A0NDTz++OPMmTOHXbt2JfwZq1ev5pprruHtt99uV9gGOHToEPfffz/z58+nsbEx4c8QCAQCwcmLqqqx4o433XQTe/bswel0UlZWhtPpZPfu3SxcuBBFUZJybEeJFpiMRix0F7vd3ms3t6koVBbNYI5it9txuVxJbdPtdqdkUBtSV4wtkfZEi4taLBbMZjMGQ8/UfpdlmZUrVya8f263m1WrVqEobbOOo0Lt1VdfnVBB1GuuuQaDwcD8+fMBYsJfV+0oKiqK3f+2/o5bf48mkynmVC8oKGDx4sVtxMNogb6CggJeeeUVzjvvPKqqqli+fDljxoxpsWxhYSHLly+nvLyc8847r4XzfPv27YwfP55ly5YxZ84c9uzZQ2VlJQcOHEjo/BH9jcxmC7994Lfs3LWLP/3pz50K2wA+n4/b77iDHTt2REwtzb8aHYIanDXpG9x5z29RFQvuoI4rqOMJRf7zhsAbAl8YJKOVe+57gLPOnfRlTmw7fVk2RAoxtiNsm80m/rvtVf74iyvxb1vDorENPHVlJmuvyOQ333Zw+cgwg9SKhIRtp1dj68EAf9ruYd5zDVz5dAP3veVBGj8TPWNI18K2Fo7kZXtq0GvL4Ngu5MZy8LvQFQNaWh5a1inoOWPQHfno6QVoWSNRB52ONug09AEjwDogIWEbiBVl9fl8uFwurFYreXl5WK1WXC5XrC84nc5uCdsAe/bsoba2tsXxGQgEMJvNrFu3rt3jtj0URWH9+vWYzeZIsVKB4CQh3uPlUKPG4UaVCreK0we3L5qHFgxw6xYXTm9LfeKbw0zcdI6NA/VhjIrEyCwj/7f0Xsx+ZwdbFwgE3UE4t09g3nzzTYqLi1vcFI8YMYLzzjuPzMxMDh8+zGuvvdbCwVVYWMjatWu77ZjujJ07d3Lttde2ELXz8vL41re+RU5ODpWVlbz22ms0NTW1+PvTTz/NwIED4/qM9evX8+tf/7rFe+PHj+fss8/GarWyf/9+3nzzzRbTf88//3xWrVqV1AOicG4L+iOi/wiS5WTpQ50VtUsVNpst5Y69nkQ4t1PXnq6iMqIZ04FAICXHWE/FraQig33WrFns3LmzRVxNZ9jtdiorK2Pu0va+R4fDQXp6Oq+88krCESxTp05FVdWY4O7xeDCZTOTn51NWVkZJSQmrV69uURSzObIsM336dMaOHcvIkSP5xS9+gdfr7bJ/Nv+Nrr1iNr+8Zjp3FF+N0+WjwtW+saM1VquVZ55+BlmW2xhgmjuqn3/+eZ577rkWESdDhwyNRJxccglGo5FgMNihoSRGoAm58ShS4xHkpiMorgrU2kMYtO4fi6qmc7BBZaczzBc1YT6vCbe7/0OHDOXxfzyOz+tr+fvq+pfFLH1IIV/k/2o0qsWANSMbTGl4whIokdmtusGMbv7SnW1JT1jETgaLxUJ1dTUjR47s9jbam8FzPOK2+iPCuX1ykMjxMqHAweo/3svZ44Zx+PMd3LP8ERQ1wJ9nOEgztRxo+8enPl44CPf84gbGnv1NgsYMbCPPRrIN6Nf30IKeoT88g4lYEgEQif6YNWtWzOEkSRK33norP/zhD1vka9fV1fGLX/yC999/P/bepZdeyh//+MeUticQCDBr1qwWzvAbbriBW265pUUUitvt5te//jUvvPBC7L2zzjqLtWvXdvkZu3bt4nvf+17sBt1kMvHAAw8we/bsFsuVl5ezcOFC9uzZE3uvuLiYW265pdv7J8RtQX9E9B9Bsog+lDqi+boPPfTQCZGN2hOZ23PmzGHDhg19RuDvjcztRKIyUhGBAz0j2qfqu3r22Wc588wzWxQa7YrlyyO5pUC73+Ntt93GkiVLGDZsWLdjGVRVxWw2EwqFuOOOO9i9ezelpaVxtzFKvIMv0d9o4MCBHNz1Kds2rGTLur/iDulxi9sAixYu4rLLLmv/8yQwGowoioLBaCDgDxAMBiPCTpqNUDCSpR0Kh5rlUevgr0d2VSO5qpCbvhKzpUBysy4AGgM69pFn8nG5h7Wvfsie2jC+OA7l2H76PJG87KiQHfZHIkYAjBZ0gzVSUNJgBaMpYvZRzLjCMpolM1IgUjF28Wk9R08OqPV23FZ/RIjbJw8JHS++GsLOgxj89YQbKnj1/c/4+K2XWXy6H5PScrZLeOIClCFnEGqoQE0fjD13CNKgr9HoDYl7aEFC9IdnMCFuCwC47777+Oc//xl7/fOf/zx2Y9+aQCDAnDlz2L9/PxA5EDZu3Mi4ceNS1p6//e1vLFu2LPb6iiuu4IEHHmh3WU3TuOGGG9i2bVvsvYcffpgpU6Z0+hnFxcW89tprsdfLli3j8ssvb3fZuro6Lr300ti0VqvVyiuvvNLtm0Uhbgv6I6L/CJJF9KHUYrVaCYVCJ0w2aiqcuqNGjWL06NEUFxczb948LBYLDz/8cJ8R+HuyGFuibsp169Yxffr0pN2UPeEOTZWTPyMjg3vvvbfFPWVXzJ07l3/961+8/PLLbb5HWZY5cOAAzzzzTNK/YU+5atsj+lk33XQTLzy7nuumnI7NV5mwuN2ho1kCk9GEJEltijymp6cTdtWiN1aiNhyJiNjuaiRXNZK76ivnc5K4gxp761T21obZVxdxZ1e6NRYtXMQ3L/wm37/2+2h61/ua5bDyz9V/RQ55Uf2uL/OyjeimqIhtAcUMsoIuSWC0oZvsYHGQkTsYyWjpM9evnh5Qiyf3W1VVgsFgn/g++hpC3D65SOR4oakCubEcY6ARyVODMWsI3sOfYt7+MBJfHUu6pBC88JfolkykkAfr4FORbJk02Yaiy8dvYE1w4tEfnsGEuC2gtraWiy++OJaBNmzYMF544QWMxo5PiNu2beNHP/pR7PWMGTP4v//7v5S0JxQK8a1vfYu6ukh1YIfDwauvvtppduihQ4eYOXNmzPFy6qmnsmHDhg6X37lzZwshe+LEiS3E/fZ4+umnueOOO2Kvb7jhBm699dZ4dqkNQtwW9EdE/xEki+hDqSXq3t6yZUvC8QlTpkzB6/X26m+QbKGyQCBAOBxuEfFgt9tZtGhRUi7bVAr8PVWMrbd/6+bROoqi0NTUlFJ3aCqE34MHD5Kbm8uIESM6jPloTU5ODjt37uT9999v93ucOXMmL774YtJiYfSeO9XfW0dEBwt++9vfcuvNC5l70akUZikJi9sAz218LuY6B5AlMKlewo2VfPzWKxz6YgeWsIs8u0x+msJAu4IlxUkcjf4vhey6MHtrw+ytU6l0t78fUUH+1ltvbTHzNIoigcMskW6SSLcauOnHN1I4diwBjOjGtBbua91gQTfZwJQWEbRNabFM7r56/erJAbXm9EbcVn9DiNsnL/EcL5KrErmhHDw1GHx1SJlDkI9+iPz+6hbL6QYrgW/fDrqKzWyCnFPwqEbU3HHxFcMVCOi717BESLW43XshYoKU8eqrr7Yo7nHVVVd1KmxDJHd65MiRHDx4EIA33ngj5tBIlvfffz8mbEMk9qSroljDhw/nggsu4O233wbg888/p7y8nKFDh7a7fOvcxWuvvbbLds2ePZtly5bFMr5ffvnlbovbAoFAIBD0NLqu4/f7mTFjBps2bUo4G7W3b2wDgQA2m41169YlJNA++eST6LrOypUrqa6ubhHxkJOTQ3FxMU8++SSXXXZZ3NuMFj9LpWs7WqTQYrEkvI9dtcdsNhMIBJg7d25CxRevuuoqKioqMJlMXQqkHWV5DxgwgJycHMaMGdNtwTc7O7tF8U9d15Ou5+JwOFi5cmXcwjbAggULUBSlw+9x3LhxVFZWJlWgr6qqip07d3Leeeel/HvrCFVVycnJYfjw4bhc8Q2qyBIMsEhkWeVm/0nIH6xB0X3InjokfyOSvx40FSNwLnDuKABLwvvTHrpshIzBhB2DWPPsq5Q1qJQ1qBzzxi/Ilx8pp7GxkVGnjOL9999HAtJMEg6ThN0kYTNGjktNNnPDTT9n7DnnE1BldF1HN1rRLRnoZgeYHb2al50qNE3jxhtv5O677054QG3BggVxn0+ihYwFAkHXxHO86I5BaLqGDITVMHJ9OaGCiRjGVmHc/XxsOSnsw/TOnwlc/P9ACkLdYTDnItUdRM8e1cN7IhD0X068K76ArVu3tng9c+bMuNabOXMmjzzyCAB+v5933nmHqVOnprw9M2bMiLs9UXEbIqJ9c3d5R59hNBq7jDCByIPjxRdfzKZNmwA4evQoO3fuZLwYTRcIBAJBH0VVVTweD1OnTqWioiKubNTjVfQrKsZPnz49bjF+7dq1TJ48mcmTJ7N9+/Y2y/j9fvbu3cvMmTOPq8DfPG9z48aNXH755Tz77LNce+21KWmPLMusXLkyIfEKIrVLVq1axcKFC+Nuf+sMalmWOXToEMXFxd1yhxYXF8dc91GiYmyywu/LL78c9zqyLFNcXMyaNWs6/B7tdntcYnJnuFwutm7dyuWXX86RI0dS+r11RDgcJhAIcMYZZ+CwGvnGUCNfyzVg/DK/Nd0skW6WYw5mh1nCburA8Xf4TQCk9v/aLXTFhG4fiObIR88YipYxGD19CHL6IIxmMw21Ttb/9vmuN9QOFgME644y7/LJjMrQ2Pb2mzidNYQ08AR1TJkD+faM2Xzn0iKMZjN+yYpqckQKQBrMKdzL3qcnB9QEAkHPo6cPRlODyLqGrvqRm44SPvVyJM8xDEc+iC0ne2sxb3sIfcadSE2VEde3JKMZrejp3S+qLRCczAhx+wRkx44dsX/n5OR06HZuzZlnntni9QcffJAScbt5exRF4bTTTutWe3bs2NGuuN3U1NSiOOSECRMwm+O7eT3jjDNi4jZE9lmI2wKBQCDoy6iqitfrxWQycdNNN3HLLbd0mPV4PBzb7bU1HjH+xhtvxGQysWHDhlhNjNbLNC9mdrwE/vaysCdNmsTmzZs5fPgwjz32WFLtMRgMmM1mSkpKutW+kpISbrnlFoLBYLtCaVdZ3pqmsWLFCpYsWZIyd2hUjE1G+D1y5AilpaVxrzN9+nSGDx/e6ffodrtxOBwJt6c5DocDl8tFU1MTS5cu5dZbb+1xVy1Efqdzz/w6xtXf4d6Lk9uH7hBSdSrcGlUeOOfbsyF9EGFbLlLGIOS0bCRZieRb6xoGWYnld0dnhsqSzDkTz2HYsGFYrVZ8Ph+HDx9mxwc7YlnaBhmyrDIDLBJGRSJae82qeZFkKxdOu5TJs6/CFVDxBbVIJnjuIEKyDdXkwCub0VMq2x8/enpATSAQ9A565nD0oBfSh0B9GVJTJaGJC5B89Si1+2LLyfVl6O/+FS4oRqrai+4xIQOq0QrW1MY1CAQnA0LcPsE4duxYCwdKIkLthAkTWryOFphMBk3TKCsri70ePnw4aWlpca07atQoLBZLrKhOR+1p/X4i+3zqqad2ui2BQCAQCPoiuq7HYidCoRBWqxWbzYau6x0WCztexCvGa5pGOBzm8ssv5+qrr6a2thaPx0NaWlq7gn0oFOp1gV+SJCwWC6WlpS1ck9u3b2f8+PHMnz+f4uJibrnlFqqqqnC5XDgcDvLz8wkGg3G1R1EUnE5nUlEZtbW1WK3WtpmfHbS/NatWrWLx4sU88cQTzJkzJyXu0GTjFP7zn//EarHEQzyRI7t27WLQoEFJOcrz8/PZvXs3AI8++ii33HJLXK5aWZaZPn06EyZM4Cc/+QlWq7XLQpLNCQQC2A6/C/WHEm53PARVnWMejWqPRrVbpdqjRV67I+/VeDW0L7vxorEZXDZxGkZoU4AyIyODUDDErl27eOSRR8gflM9dd93Fk+ueJDc3l7raOrxeLzazgQFpRpxHD/LOG6+x7d138Hs96ECDX8fv01B1yBlYQNop5+D3+QjrEDbZMGWkY7ZG4kY8KH3q/JcKenpATSAQ9CKSjJY9BvnY55AxBKnhMJLHSfCCn2Peeh+yp+arZQ9/AI6B6CO+jeyuQVPMyLX70PImRGoECASCuBHi9gnGgQMHWrwuKIh/2kpOTg5GozFWUKb1trrD0aNHW9yoJ9IeSZJiRaQAysvLCYfDGAwtu2Uy+zxo0KBOtyUQCAQCQV/nRMhGTVSMD4VC2Gw2srOzgYjDNnp/0t1tpoLOsrCdTifLli3jD3/4A9OnT2fs2LExV+/hw4f5+9//jqIoXQrtkiQlHEfSGrfbjc1mS6j9rfdl9uzZbN26NWXu0O5msK9fvx6LxcKZZ56J3W6P+7uJJ3KktLQ06QiWsrKymKM8+r298cYbHcbm5OTksGDBAoqLixk+fDg1NTV4PB4aGhrIycnB7/fH+nZnfUXXdQJp+VgkBfT4RUtV06n369T7YdTXzgZrJrolA0N6Lg/+9e/sOVpDtVujwa8T75DQpk2b+N6V3+OtN9/i0Ucf5cjRI7G/DRk8hKKiImbNmsXv//B70MHrdvP21lK2vvwCDbVVOEwSJkUiOyeXc79xMVNnf4/Jl1zB75b9ng/+uxtVB29IR9Xg8huuRk0fipppRZMMtBjuCOtA3z4XJkpvDKgJBIJexmBCyylEPrYT0gcjNZYjyQrBCxdjfvU+pJAntqj++b8xWbMJ505AclWAYkR27okI3Cd41JJA0JsIcfsEo7q6usXrgQMHxr2uJEkMHDiQI0eOtLut3m5PdPmouB0KhaitrW2zjWQ+Izc3F0VRYjeKqdhngUAgEAgEHROPGB8Oh1FVNVbYOp7le0PgjycLW9M0XnrppTbFri+88MIus7AhNcUX7XZ7u2JWIlne27dvZ/LkySlzh3Yngz0qmPt8Psxmc0LCuNfrZcCAzqdua5pGSUlJtyNY5s2bx9KlS1s4yrdv387111/PP//5zzaxOeeffz6bNm1CURTWrFnTIuscYMyYMbGIHpvNht/v73Rfw1mjCc76HaZP1uKpreCLA0eodqu4gjqugE5TQKMp9m+dxoBGU0AHSeF3DzyAdNZZ+AN+jAYjroCfTZ8si3v/m1N+pJy6ujo++fSTFsI2wJGjR3j4kYfZ/t42fn/fvfz3g7f456qHCYcCyDrYDBKNfnAHVf5bXcnWz9difGwjd917L/f8aSXX3fhTXnjrQ/zhyHd+2Y1LOFhdzciR+SeFaNsbA2oCgeA4YEpDyxmDXLMb0guQmirANgDtol8ib30ASfvqeJd2PI55+u2EbQ7wVBGUlS8d3ONB6qCegkAgaIEQt08wPB5Pi9fxRoC0t3w4HCYYDGIymfpEe9rbXnvvJfJAKMsyVqs19jDT3SIr0QIvfY3m7eqrbRT0XUT/ESSL6EOCZOhr/SdVWdihUKhTIV7TtJQUX3S73S2+t+60v7k79Kc//WmnkTI+nw9d1zv9raLLJZKX7vP5UFWVQCDAjBkz4hbGr776anJzc7v8HrsbwbJ27VpCoRCrV69u8/f169fzyCOP4HA4WLhwIbfccguNjY2kpaV1mHUOsHfvXhYvXszdd9/NunXrmDFjRpdxEqFTJkNGAWlN5ViGHOCvS/8Pn8/X4fJWq5V77r6Hc845JzbzQZKkTteJB5/Xh81mw6yAxRBxYhtkkCUYkOHgnoXXsPOdF1i18m/U+sI0+HQCasQdrungCujU+zWcXg1vKMTr1/+KjRs38tf1LzF+/HhC9fWx73zmzJl8+umnMeG3J+gr559UDKj1hfPnyUA837MkSeL3EHyFNRM9ZwxS7T5kWcLorSFkzuAj40QmBr4qqi2h43n+t7yTPpOLvzkJi7+GkNFC2FWJnjHkOO6AoK/SV65hfQkhbp9gtL4xjbewYkfLezyepMTtVLenPfG59Wck2l6z2Ry7YWxPPI+HzMzMbq3Xm2RkZBzvJghOYET/ESSL6EOCZOgr/ScVWdjRqJXOCAaDSUVlBIPBdgf7u9P+5u7Q+vp6srOzW+xD9F4t6rKPF5PJxKJFi2KCefN89ebmitb3ddOmTYurOKnZbG7xPUYzrseNGxeLN9m1axelpaUJR7CsXbuWKVOmMHnyZJxOZ7vLud1usrKyYq+jmcnxOM/dbjdFRUVs3ryZqVOnYjQaO1xW9yvoXitqo87Xv/Z1nlr/FC+++CLPPfdcCxf10CFDKSoq4pJLL8FkNCErMlbbV79Zor9fcwwy2OQQNl8143Iij4+qBiFNR9fh4m9diJSWwz1/uZtaVxBVg1pvxFXu/tJZ3tpbrKoq11xzDeXl5SxcuJCJEyfGvvOysjJWrVrFokWLeuUe/Hiff5IdUEv0+UvQTdLT41gkHU6A50ZBL5KZiZ7uQK3axX92fsGTK+/gUK2PGaNM/PD0r+LFbEYYV/U8P775WW5dOI9x52Rg1dKQLDKSpeu+Jzh5Od7XsL6CELdPMFoXoklU6G29fLJuiFS3p71CO6n8jJ5yfwgEAoFAIDjx6e4gePP14xG3TSZTt4svzps3j/fee48zzjgDi8XSQhhNpv2aptHQ0BARZ1JE9B6stWDe2b2c0WjEaDTys5/9rEthHODHP/4xTU1NzJs3j+HDh1NZWRnLJR40aBBlZWX89a9/5bvf/S7/+Mc/uoxgmTdvHqFQiMmTJ7N9+/b2mgi0nX3o9/u7zDpvjqqqXHXVVVRWVnYqbgNoqsYXO3ey+h9PMmHSZIqKivjeld+jrq4On9eH1WYlKyuL6qpqampqGDK4rdMvIyODIYOHtIkVaQ9ZgnSzhMMkYTdJDM4fSKbkprKqmrIGFXdQR9Wjy8r8ZvZ1PP/W2+yu8uD06TibFaPsDLfbzZo1a7j99ttpampq8Z1Hhdv+Tm8NqAkEguNH2JzJG58d4bd3LyXXqjPILrNpd4ARGQoXjfhqcGpohsKiMw088H+PcscvJMaePwOlZi8UnIakdH6dEAhOdoS4fYLRemS+dfGlrggGgy1eJ+Pa7on2tOc8SOVndNfZ0NDQ0K31ehpJkmIjdY2NjSJzT5AQov8IkkX0IUEy9LX+YzabE45Xa01aWho+n6/LwXRJkrBarQkXX4zGNnz3u9/F7/e3iLYwGAy91v5UIkkSJpMJWZYxm804nc5YLEpOTg52u5309HTC4TBut5twOIzX6431H7PZzC9/+UtWrVrVYcb1kiVLUFWV66+/njPPPJPbbruNW265herqapqammIF+srKyli6dCmrV6/u0LENLaNhwuEwVqs17qzz5rjdblauXMnChQvbjQ2RJAmrHObDDz7g7488QqM/zNq1a1n35DrOmXgOQ4cOxWaz4fV6KS8vZ8cHO0CS+N0DD3DWWWdFilZ+6Zk2m8wUFRXx8CMPt9sWqwEyLDJ2k4TNICFJ4AvpNPph5jdnUq1l8u93/osroFHj1fCFdIIqTJ4ylfyzZ3L3D29lrzP+wpdRoiL2z372sxaDCVHh1maz9Uh/7Avnn+azS7tLtLisMPD0PHJTE10N/TU1NaH10edGwfHBbDYTDoeZc/2PGSAH0QYoWAwSQzMU/u99DwUOhTHZX8ly5xQYKRqj8vCqNfxhdCEKCsH9H6LljgURPyH4kr5wDUuWVM/MEuL2CYbNZmvxuj2nc2e0vvFJ9iEo1e1pvb323kv05q358u1tPx5OhJOFrusnRDsFfRPRfwTJIvqQIBn6Qv8Jh8MpycJ2uVxt9sVgMKAoCpIkoes6qqomXHyxvaiMaLTFlClTCAaDPdb+nkJRFCwWC4FAgJUrV3ZagNFsNhMKhWJtixYMf+WVV+LKuH7iiSfYsGEDH374IUajkbq6Or744gu2bt2Ky+Vi9+7dlJaWtige2RHFxcUEAgFCoVDKstqDwWCbrHaz2UzA4+He39zLUOtXwrGma7z//vu8//77bTeowz333sMzTz+DwWCImUJ0XefSSy9lzWNrYkJ6mlEi3SyRYZEwKxJhDdxBnSM+DVdAI6SB2WJl8pwf8Miaf/JRZTBSsLIZwwtPpaq2kb1793Vr//fs2UNVVRX5+flt/hYVbnu6Px6v808qi8se7/PnyUA837H4LQStaZ6r7yZy3pWA0VkKBQ4Dv3nTzYMz08myflU48nsTLJQ3utn2zjtcONkG1oHQcBg9c9hx2w9B30WcdyKI0qsnGK3F2UQLJDafrhq9GU+G1uJ4Mu1pb3vQdp8TmXKraVoLwb274rZAIBAIBIL+TTgcJhAIUFxc3K31o4JnVKCUJAmLxYLNZsPhcOD1eqmursbr9eJwODCZTITD4VjxxeXLlzNmzJgW2ywsLGT58uWUl5dz3nnntYnKiEZbBAIBZFlOafvjIXovabFYMJvNGAzx+2YURcFms7FlyxYKCgpYvHhxG1E+Kk4XFBSwZcsWbDZbbJDAbDbz8ssvU1RU1KX71e12M2fOHF5//XXOPfdcvvvd7/KHP/yBM844gz//+c88+OCDvPTSS3EJ23a7nQULFsTc9oqipCRaQlGUNn+TZZnH/v73hItB+nw+nn/+eWT5q0e9YDCAUdb5ze1LGJZh5NRcA6OzFLKsMp4AHKhX+bwmzKFGlfJGlbIGjc+dOj//wz8IZI3hf1c/1UbYhsj34XK5Et/xZkRjZNrbdn9+YFdVNTYg1R2iA1LxRuEIBILepb3Bz921Ko0BnYP1Krquk26W+M0bboJqy3PdT89N44Ptb2HQAiheJ7KrCsnT8YwigeBkR4jbJxgDBw5s8bqqqirudXVdp7q6usNt9XZ7gBbtMRgM7WbGJfMZNTU1LR7S2nOFCAQCgUAgEEBkUPzGG29M2E3ZnuBps9kIh8OsWLGCwsJCcnNzGTlyJLm5uRQWFvLwww/HXLVGo5FFixaxZ88eKisrY//fvXs3c+bMYenSpUyYMKHdDGi3282qVatQFCVl7e+MrkR7q9WKxWJB6mT6dHQb0QKM8YjTRUVFvPLKKzEhPRAIdCvj2uv1cvrpp7Nq1SpUVeWJJ55oV1huD0VRWL9+fayYZXRfUhEt0fr7iooif1v9t25tc9OmTRhNRhQtgNR4BLlmN6HKnZw5Motf/fwmPJqJvbURQbvcpXKkSWNvrcq28hAfVoapDll57MlnmTJ1GkVFRZ0W1mxPmE4Eh8PRRiA/GYTbVA+oCQSCvkV7g5868NmxMK6gzoEGFUWW8Ks6D77X0sBnVCTmF/rw+EMogQbwNyDVH4Rgx0a/ZAacBYITHSFun2CccsopLV5XVFTEva7T6WyRVz1y5Mik2zN48OAW7u9E2qPreguheujQoe0W1ElmnysrK1u8TsU+CwQCgUAg6J8EAgHMZjPr1q3rtuDZHUey0WjEZDKxYMECli5dyuOPP87SpUuZNWsWo0aNYtmyZZ1mQJeUlGA2m1FVNen2d7VsPKJ9OByOuazbIxlxOupS727G9Zo1ayguLqauro7Zs2czdepUnn322S4HBOx2O5s3b2batGn4/f6YoziV0RLNiYoi+/fvj3s7sgQmJTLtPVB/FHfZpygNhyEcQEvLRXUMJuAYzvgLZ7PiHxu4+ieLCaUPY1t5iE+qw1S6NUaOjswWqKys5Pzzz++ysOauXbsYNGhQUu7j/Px8du/e3eL9k0W47Y0BKYFAcHzoaPAzrMGn1WHcQThYr2JRJHY5VZ76ouUsnQFWGeOHa8CUhuSqQgp6kZ17Qf1K00nFgLNA0B8Q4vYJxsCBA1u4I3bu3Bn3ul988UWL16NGjUq6PbIsM2LEiNjrQ4cOxR1Nsn///haRIR21p/X7iezz559/3um2BAKBQCAQCKLout4iCztRwRPoliO5tLSUYDDIc889x4MPPsj999+fUFRGNNpCluWk2t9eBETUCWa1WklLS+OTTz5hyJAhCcWItCYZcXrLli1JZ1yPGDGC6dOns337diZPnsz555/P4cOHO42GqaioYMqUKXi93haCYk9FS8TrCJeATIvE6AEKX88zMD4nEjeSZ5PxhzXIHIqedQq6Ix89cwjh9MF47cOQh5/L3J/dxbuf7qPymJOysjKcTie7d+9m4cKFWCwW1q9f36mwDVBaWsqhQ4eSch+XlZVRWloae+9kEm5TMaAmEAj6Jp0NfgZU+G91GHdQ53CjSoZZYvPuAO8fbXlMG5qOIO18HhQTUuNRpJAXue4A6HrKBpwFgv6AELdPQM4+++zYv51OJ+Xl5XGt99FHH7V4PXHixJS055xzzon9W1VVPvnkk7jW+/jjj+NqT0ZGRosHhi+++CLuopLxfoZAIBAIBAIBRO5lvF5vXFnYrQXPZB3J8+fP73a7o9EWybQ/SntOsKqqKurq6pg4cSKffPIJt912Gzk5OR22pXmMSHPHWLIFGHfu3Jl0xnVVVRVjx44FYPv27YwfP55ly5YxZ86cFtEwNTU1MbFXUZQ23xP0XLREZ6KIzQiD7DKjByh8Lc/A8AwFXYfDjRr761V2O8N8VhPGlHsKuj0PLWsk2qDT0XIK0TOHoVszCQRD+Hw+XC4XVquVvLw8rFYrLpcLr9dLKBTiuuuu63KARNM0SkpKmDdvXrfcx/PmzaOkpCQ2iBMVbqP9pr+7DZMdUOvPmeQCwYlOV4OfnpDOFzVhGgM6FS6N3DSZR3Z4OdzY8jojl72N7NyLhIbUVIHka8DgPdbtuhUCQX9EiNsnIJMnT27x+sUXX4xrvZdffjn2b7PZzDe+8Y0eac9LL70U13qtl5syZUpcnxEKhXj11Ve73H4gEOCNN96IvS4oKGDChAlxtU0gEAgEAsHJS1QgVhSFm266iT179uB0tnS3/vSnP41FgRgMBgwGQ1KO5FWrVlFcXNyiCGAiNI+2iKf9HQm2nTnB8vLyKCwsZMOGDSxZsoSdO3cyadKkDr/DqGhvMplabD8Zcdrn8yWdcd26gKHT6WTZsmWMGjWKWbNm8ac//Qld1xkwYABerxev10sgEOhQSOyJaImoKNJ81qHDJDEuR2FMloEBVpmQBpUujV3OMPsbVI40qRysVzlQr6FmDCfj1G8THvg1dHseSO33q6g47/f7W4jsiTiKu5tfvnbtWkKhEKtXr459Hxs3buTiiy/m6aefPmnchqkYkBIIBH2PeAY/6/06++pUnD6NGo/OAIvM799x4wm2vN4YP10HIT9S0IPkq8XsO8bWFzZ2q25Ffx80FJycCHH7BGTKlCktsqmfeuqpFlna7bFt2zYOHjwYe33RRRdhs9lS0p5zzz2XAQMGxF4///zzNDU1dbrOoUOHePfdd2OvTz31VIYOHdrh8jNnzmzx+oknnuiyXZs3b27RjhkzZnS5jkAgEAgEAgFEHJWBQKCNu9XhcBAIBDAajTQ1NbXItpQkCV3XO3Q0d0bzuIxEaS/aoqP2N3fnthZsE8kLHzZsGNu2bWPr1q0dCtzNi11GSbYAo9vtTjrjOisriylTprQREEePHs306dO58847GTFiBB6PJ67Zgj0RLREVRW6Yf0PsPVmS8ARgf73KFzVhDjWqlDepHG7U+E9VmA8rw+x0quyrV7niRwsJalK3M6sTcRQ7nU7mzp3LzJkz43Yfb9y4kSlTplBUVERWVhbLly+nvLyc8847j8mTJ3PttdeeVG7DZAakBAJB30SSJBRFYcGCBZ2eFyvdGkeaNCrcKk0BHYMi8fDHLa8Lkq5i2rEaXTFhDDQQctez7FfzkfXEZ4k1H3AWCPoLQtw+AcnJyeHKK6+MvT58+DCPPvpoh8sHAgHuv//+2GtJkrjppps6XP7IkSOMHTs29l9rZ3ZrogWQorhcLpYuXdrh8pqmcffdd7fIkFy4cGGnnzFhwgQuuuii2OsPPviAjRs3drh8XV0dy5cvj722WCzccMMNHS4vEAgEAoFA0BHhcJhwOIyiKAQCgQ6zLR966CFuuOGGTh3NHRGNwYjGZSRCV8X3OnLnNicaRZJIXvicOXN49dVX2bx5c4eCfrTYpcFgAJIvwLhr166UZFxfcMEFKRMQeypaQtM0fnTDjVitVg7Uq+x0hil3qRxp1NhTq/JueYgPKsLsro0IIs23n4rM6kQcxRs3bkSSJKZOncrRo0c7XbayspLp06fjdDp59tln2b17N3PmzGHp0qVMmDAhlvN9srkNuzMgJRAI+i5msxm/308wGOxyZsuBepUaj8ahRpWgKjH76vlw6mUtlpH8DRg/eRLJaOXdF5+CkI9xOYa429PegLNA0F8Q4vYJSnFxMWlpabHXf/nLX3jsscfaFB2qq6tjwYIF7Nu3L/bed77znZTHc1x33XUMGjQo9vqZZ55h2bJlbZwobrebxYsXs23btth7Z555JlOnTu3yM2655ZbYgxHAr3/9a/7973+3Wa68vJwf/vCH1NbWxt77wQ9+QF5eXkL7JBAIBAKBQACpdzR3hNfrJTs7O6F1UiVkdjcv/JprrsFgMHSYFx4tdhl9mE62AGNZWRnBYDDpjGuPx5NSAbEnoiUCgQDmtHQWL/0rh1zw+bEw7xwO8emxMFVujXA7tUZTXWwwEUex3+8nHA5jtVpZuHBhh8s+++yz3HvvvTz66KMsXbqUWbNmMWrUKJYtW4bT6Wzz+Sej2zCeASmBQNC3kWWZRx99lNmzZzN16lSeffbZTgc/dzlVgrKVG265i7GFo9FHfhN14KktllFq9yCXvcnbb73F8AyFAVaJYRnxy3qtB5wFgv6CpIuh3xOW119/nZtuuqmFoD1ixAgmTZpEZmYmhw4d4rXXXsPv98f+Pnr0aNatW9fpSfXIkSMt8q8HDx7M1q1bu2zP559/zve//318Pl/svby8PC666CKys7Opqqpi69atLaJCcnNzefrpp8nPz49rn9euXcs999zT4r3x48dzzjnnYLFY2L9/P2+++WaLG8Bzzz2Xv/3tby2iXBKlvr6+2+v2JJIkkZmZCUBDQ4NwcggSQvQfQbKIPiRIhp7oPwaDAUVRYvEgqqomLQpJkhQTtouKiuISfhVFYePGjUyaNInx48e3Eew6wul0Ul1dzWmnnRb352zevDkmlCbzHdpsNlasWMHixYsTXnf58uXMmTOHUaNGtTFaQESQzsvLi92TJvtZP/vZz/D5fBQUFCQUcWK326moqIg58Duju31JkiRMJhOyLGOxWKitrY1FqWRnZxMIBFBVlWAwGNfvFR1YKS0tZe7cuZ3ur91uZ/369UybNq3HoisS+V5aL2s0GnnooYf45S9/mfDnLl++nIULF+L1epPdBUBcvwSJI+/cSUYXNasa33kHbfz4XmqRoC9jMBhwOBwUFhayd+9eJk2axObNm1EUhccee4xHHnmkxSB5YWEhxcXFzLv+WrSj/2HVg8tYvGAufswY3vhfZG/L+4g/bfdwpEmlyq1R5db477EwDf74zmNOpxOr1RpX7Jagb9IfrmHNo41TgRC3T3A2btzIPffc00JQ7ojx48fz0EMPMWTIkE6X6664DfDWW2/xq1/9ioaGhi6XHTJkCH/5y18SdpE/+uijPPjgg3E9YEyaNIkHH3wwduB3FyFuC/ojov8IkkX0IUEypKr/SJKE2WxGlmXMZjNOpzMmJubk5MRiH7o7nd9isRAOh7slpJaXl7N06VKWLVvW5fKFhYXs3r0bVVV5+eWXe1XIbP0QnijRts+aNavdwuLNH6QlSSItLQ2/35+UOG0wGBIecOhqICDVfSlVgy2KomCxWAgEAqxatapDUWTBggWxafB9LZM5VX3M5XKlxMUsrl+CRBHitiARzGYzXq+X3Nzc2Hs5OTnMnz+f4uJiRowYQVVVVazAcX5+PmVlZZSUlLDxX6sZqDSy+R8lGDU/YVXF/MbvkbSv6qz5wzr3vuEiEIaDDSr1fp3/VIXwdl6KDWg74Cw48egP17BUi9siluQE5/LLL2fDhg1MnTq1Q2dybm4uixYtYv369V0K28ly4YUXsnnzZi6//HKsVmu7y2RkZHD99dfz3HPPdSse5cc//jFPPPEEF1xwAbLcfhceOnQot99+O4899ljSwrZAIBAIBIK+SdTVGg6HO8zBfvjhhwmHw90uSifLMitXrky4CKLb7WbNmjUUFxd3eL/SnOZxGamMtogHRVFwOp3dEh0hEj1SVVXVbl5482KX0d8rKnI/8cQTGI1GZs6cyc0338ydd97JzTffzMyZM9t8Z63jNgKBADNmzEhZxnVP9KVURUv0h2KDqehjzeNtBAKBoK9iMBhig5vNr2lOp5Nly5YxatQoZs2axdKlS3n88cfbxDPtPuKkyqXhMWQgGcxIkkzozOtafIbFIPGzc9MIazrDMxTsRvhanhFjHAqf3W4/IcVQgaAzhHO7H1FfX89HH31EVVUVHo+HnJwchg4dyllnnXVcbgQ9Hg87duygsrKSxsZGsrKyGDx4MOecc07KMvP+P3t3Ht9Emf8B/DOZNFeT0rulXCK05VDkFBBROcWrP/AA193VRUALgogouuvBeq6uUmUVqFJBd1UOXXULKJQiggfIKgjI0Zb76EHvJk0zaZL5/dFtbHombdom7ef9evF6dTLPzDyTPOT4zne+T15eHg4ePIi8vDxYLBZERkaid+/eGDRokFf2X42Z29QRcfxQS3EMUUu0dPx4Wq5hw4YNmDx5skfBv9bOaK7Zv5rlMrxd2qIpGo0GeXl56N27d7P3kZmZiX/+858uk5gDv5WTkCTJ5fW69tprkZqaCovFAoPBgJycHGcGW9euXXHmzBm88847SElJgcViqZOlXj1+KisrYbFYWpTR3BZjyZtao/xOa/PGGPNmtiE/v8hTzNymxjR0549ara7zmeZOqTIBQOHR3dA4zLDlZQGiEgGndkE8tdOl3bfnrFh3uAKiQkBWoQ35ZhmHLzX8eVD9vaR6fgnyTx3hM4xlSYjaAYPb1BFx/FBLcQxRS7Rk/DS3Dran9anru63YUzk5OXjllVewfPnyZvWrLQKZrXWe1UH76nOofr2uvvpqpKamQhRFrF27FsnJyS5B6djY2KraozNnIiAgAIIgICAgwCU4XXP8VFRUQBCEZl0IaKux1Nl5Y4x5s04sP7/IUwxuU0Nqlo5avXp1o59pdrsdt912G/bu3dvoPuPi4nD8yGGUn9wLh6kIitJzUGm7oHzncugrsl3arvqpHMcK7KiwyjhdasfxAjsuldcz4zCqLjjPnj0bWq3WZ+/0oaZ1hM8wliUhIiIiok5NrVZDkiTMmDHD7R9mdrsd06dPhyRJbt9BJgiCx+VIaqvORq6PO+UyvFXaojF2ux3h4eF1SqC4Ky4uDtHR0cjIyHA+VrOMCADn63X11Vdjx44d2LNnD3r27InFixfXyYrPysrC4sWL0bNnT+zevdsZNGjotZYkCRUVFTAajdBqtYiMjIRWq4XRaHRmpzX0w6+txlJn540xVl3ehojIV1Tf+ZOeno6YmJgmP9P27NmDr7/+GqNGjWp0v4mJibDaZVSG9IGsCoQytBdsFaVYuuUULLJrOdrZQ3TQKIEgjYBgtYA+ISKU9UT69Ho9Zs6cib/97W/Yvn07NBoNBEFo8XNA5AsY3CYiIiIiv9KSOtgpKSlul2uTZbnJes5NCQ4OhkajcXmsNepmt0R1AD0xMbFZ2ycmJuLMmTNIS0sDUDdoX/16aTQapKamIj09HdOmTWvy9TOZTEhISEBaWhrUanWTP8KbcyGgrcZSZ+eNMdZaF3eIiJqj+o6htLQ0JCQkuPWZNm3aNOzYsQObNm1CeHh4ve30ej1mz55d9b0gQAdHWB8I2i7Y8eNhwGbFip9dSzMFiAIeHRUIyS6jW5AIjRKIC3X9bBJFEevWrUNlZSVWr17NC7TU4TC4TURERER+Q6lUQq1WIzk5uVnbJycnQ61WQ6lUNtnWG9mmEREReOqpp3x+AkCHw4E5c+Z4HMyvzgRLTk5G37596wTtq+uQJicnY/bs2RBFEffcc49PZEm35Viilo0xZ6CHiMhHNPfOn9/97ndQKpWYNWtWnfW1J08GAKUhAqqovli/eQdKLTLOF5ZjR67OZbtovYh7rtBCANAjSER4oAI9u1SF+6ovOE+cOBEJCQnOeuC8QEsdCYPbREREROQ3RFFEQUFBsyZ4BKomPiwsLHTrB523sk2bUy6jrUmSBLVajQ0bNrj9Y7f6R7hWq8WSJUvqDdpXv14nT55EYmIi1q5d6zNZ0m05lqhlY6xmoIeIyBe05M6ftWvXIjExEQrFbyG5hkqViaKIQpsGBzLP4VypHVabjC8O5OCk0bU8yTU9VBgcrUQXjYBovQJjr7gMq15/AefPn8eECROQnJzsUuubF2ipI2Fwm4iIiIj8hjfqYJtMJrfrTHoj27Qt6ma3lCzLsFgsmDx5MlJTU5s83+of4ZMnTwYAaDSaeoP21a/X5MmT0atXL5/Kkm7rsdTZNXeMNVaTnoioPXjjzp/LLrsMkydPbrJUWfVnVUahHWVWGWdL7RAFAav2FqJUcn1fvG+IAU8teRTJr7+ID95ZjoRrBuCNV57HhQsXUFhY6NKWF2ipI2Fwm4iIiIj8hjfqYOv1ercDZZ0p29Rut8NsNmPixInIzs5GUlJSnZIstX+El5eXOwPa9QXtq1+vfv36IScnx6eypNt6LFHzxpivlO4hIqrmrTt/Pv300yZLlVV/Vjlk4Gi+DeWVwLlSO2QZWPXfcjhqfAYJsh2qXz7E1vSdSP77s5h93+/x1b/egk6jgtForNMPXqCljoLBbSIiIiLyG96ogx0WFuZ2sKyzZZtWBx9FUcTcuXORmZnZonrh1a9Xr1696v1h7Qlv/whv67FEVbw9xoiI2po37vwpLy9HYGAgTCZTo6XKan5WWWzAsXwbyqwy8soduFTuwKdHXSeY1MOCboV7sP/wMfQwAP0u74EopRkZGRl19s0LtNRRMLhNRERERD6h+jZfjUbTYAkKb9XB9qQ0SGfLNpVlGZIkoaKiosX1wqtfr8GDB8NgMLSoX97+Ed4eY4mqeHOMERG1NW/c+RMYGAgATX6G1P6sKrbIOFtiR67JgXKrjD0XKnEor9Jlm9HdVbgqSgmlKODuW25AzsnD+OX77S5teIGWOhJB5jcGoiYVFxe3dxfqJQgCgoODAQAlJSX8AUAe4fihluIYopaoOX4qKiqgUCigVqtRUFAAk8kEvV6P8PBwZ/ZzzUCXRqOBzWZDTEyMR5lTer0e2dnZEEURkiQ1q88qlQoKhQIajQaFhYXOvoaFhUGSJNjtdlitVv5/qEGj0UCWZeh0OsTFxTXrNu64uDhkZGTAaDTCZrN57f2nvcYStS9+fpGnFMeOocuYMY22Kf3+ezj692+jHlF7UiqVMBgMLf5MA9x7D6rvs+rKSCXCdQJiQ0UY1AKWXKNHiPa3/FWrXcZz30l4dulf8e/0H/HuR//G/lw7bpgwGf369cNdd92Fq6++GhUVFbxI62c6wmdYSEiIV/fHzG0iIiIiajeVlZWw2WxYsWIF4uLiEBERgd69eyMiIgJxcXFYuXIlbDYbdDqds95ye9XBZrZp0+rLvpckCUqlEkaj0eeypDtTTXUiIvIOb9z548nnR32fVccKbDBaZZwqscNcCfzzYIXLNipRwNOTYmATVDhzaA/+9Ie7cWLvVnz55ZdYsmQJYmJiUFJSAoPBAK1WC41Gw/rb5LeYuU3kBmZuU0fE8UMtxTFELaFUKqHT6bBt2zbMmDGj0axZvV6PDRs2YPLkyc5yH6IoQqfTIS0tza3tN27ciEmTJvl1uRBfJQgC1Gp1o9n3ABAQEIDy8nJ069atxVnS3nz/4VjqfPj5RZ5i5jbV1tI7f6pLdbn7HlTfZ5VaBIZ0DUCwWkCfUBGTLlfh5liNy3aHLZHoM2U2FAFafLnnCN7+eDO+O3TSuT42NhaJiYmYM2cO1Go1LBYLP9t8XEf4DGPmNhERERH5tepg6LZt25CQkNDkj0KTyYSEhARs377dmVnU2epg+6rqH9tNZd9XVlbC4XBAp9P5XJY0xxIREXmqpXf+eKq+z6qel8fi10tVGdzZRgd+Le+CEkWwy3ZXai4hJ+MAnnt6CTa+nwyUnIMu4Lf1WVlZWLx4MWJiYpCenu5ypxyRv2DmNpEbmLlNHRHHD7UUxxA1lzfrHLMOdvvxNON5w4YNuPHGGwHA7Yz9hrKkW+P9h2Op8+DnF3mKmdtUn+be+VNRUeFx5na1+j6rzHmnYbDmw2ArREXeKYh734ESv31mGiUZz35TBkBAVqENBRUyDuTYUPuooihi06ZNzou4fG/0TR3hM4yZ20RERETk1xQKBVavXu1RYBuoyuBOSUlxyShiHez2IQgCNBoN0tLSPMq+T0tLg91u98ksaY4lIiLyRHvc+VP7syowMBBRfa6ELjQajsAoqLpEImDY3S7bGNQCZg7WodIuo2cXEQaVgMuC62Zn2+12TJ8+HZIkQaVSNbuPRG2NmdtEbmDmNnVEHD/UUhxD1BxKpRIGgwFxcXHIysryePu4uDhkZGTAaDR6fXJBcl9Ls++VSiVkWW52ljTff6glOH7IU8zcpsZ4eudPS9+D6p3roqQAXcrPIEishK3gLISMrRAu/OSy3YeHzNifY0O+WUaOyY4DOVUlTWpLSkrCvHnzYDabm/2cUOvpCJ9hzNwmIiIiIr8liiIKCgqaFdgGgMzMTBQWFrIeZDtrafa9QqFgljQREXUIbXnnT4NzXcT2x8Brb8G9Dy7EgRPnoeg3GQUWwWXb312hRZBaQIROgE4pIC5MhFDPMZKTk6FWq6FUKlvcX6K2wOA2EREREbUZQRA8DojWZjKZIAj1/RyjtqBUKqFWq5GcnNys7Wv/aLbZbJAkCRaLBZIkeZyRr1ar+SOciIh8Qks/0xpTHdhOT09HTEwMFi9e7JIskGNyYM/Rc/jv8fMos6vw4S8m2B2/BdRFhYDE4TrIkNE9SIFAlYAeXeqGBRtLJKj+DqDRaPjZSz6DwW0iIiIiajOyLEOv17doH3q9nhm97ag9s++ra31rtVoAQEFBAfLy8mA2m2EwGKDVaqHRaHjxg4iIOhR357o4XWKHQxsKk9gFmYU2fJkluayP1ou4OVYDjVJAVKACPbuI0NYTn66ZSFB9bJ1OB4PBALPZXOezV6fTQaPRMOhN7YLBbSIiIiJqM3a7HeHh4XUmXHJXXFwcwsLC2mSCQapfe2XfN3grdu/eiIiIQFxcHFauXAmbzQadTsfSNURE1GGo1WpIkoQZM2Y0+R3orEkJbXAEzpba8fVpK44XuGaPT7pcjV7BIiIDFdAqgX7hyjrlSaoTCRr77O3fvz+WLVuGiooKqNVqlJeX84IztQsGt4mIiIiozVTfrpuYmNis7RMTE71+my95pj2y75u6FRsAsrKysHjxYsTExCA9PZ0BbiIi6jA8mevi2PEMhPe/BqFR3XHB6MCnRytgrnT9zP3TVVpoRKBnFxEGtYDLgn/7vKxOJADQ4Gfv6NGjcezYMdx///1Yu3YtLzhTu2Jwm4iIiIjalMPhwJw5czwOkOr1esyePZtZ2+2srbPv3b0Vu5rJZEJCQgK2b9/OjDEiIvJ7ns51kZaWhnM5+bjh9j+h2OLA6RIHPj9mcWnTRaPA7f010CoFdNWL6NFFgS7qqs/L6kQCpVJZ72fv6NGjsWPHDuzZswc9e/bkBWdqdwxuExEREVGbkiQJarUaGzZscPuHjiiK2LhxI9RqNaxWayv3kBrT1tn3ntyKXc1ut2P69OmQJAkqlapZ/SQiIvIFns514XA4kJycjBmzFqBc1uBCmR0/Zlfi5+xKl3YjuqkwIEKJCJ0AvUpAv3AlggxViQQKhaLez97w8HCkpqYiPT0d06ZN4wVn8gkMbhMRERFRm5JlGZIk4cYbb0RqamqTGdx6vR6bNm3CpEmTYLFYOJmkD2jL7HtPbsWuyWQyISUlhZliRETk15oz10VKSgrsdjv++o8PYHUocL7Ujv9kWFBc4XBp9/tBWuhUAnoEiQhUi/jP+/+AWq2Gw+Go97N39uzZEEUR99xzDy84k89gcJuIiIiI2pzdbocoipg0aRKys7ORlJRUp8xFXFwckpKSkJ2djQkTJsBsNrMkiY9oq+x7T2/Fri05ORlqtRpKpbJZ2xMREbW35sx1UVBQgNtuuw0TJk/B02++D5uowblSBzYedS1PolUK+MOVWuh1arz27GMYM6gPKo1F9X72KhQKJCYmYu3atbzgTD5FkJn6QtSk4uLi9u5CvQRBQHBwMACgpKSEmWzkEY4faimOIWqJmuOnoqLCWVe5sLAQJpMJer0eYWFhkCQJdrsdVquVY8zHVE/ymJaWhhkzZjT6Q1ev12Pjxo2YNGmSRxcp1Go1zGYzIiIimt3PgoICaLVaSJLU7H1Qx8LPL/KU4tgxdBkzptE2pd9/D0f//m3UI/Jnnr4HKZVKGAwGxMXFuV2apNqoUaOwZcsWqIwX8OX693D4my9wfUQZru+ldmlni78ZYq8RsOq7QTREoLxLH0RERrm0mTJlCr766qtm9QOoSlrIyMiA0WjkxOAt0BE+w0JCQry6P2ZuExEREVG7kiQJFRUVMBqN0Gq1iIyMhFarhdFohNlshiRJfvnFvaOz2+0wm82YOHFiq2XfN+dW7NpMJhNrfBIRkd9qyVwXe/furbprqms8Eu68G3998z1cfc+TsGvDXNqJmVthLc6GXHoRQqUZFTl1g9f9+vVDTk5OswLbAJCZmYnCwkJmb5PXMbhNRERERD6h+sebxWLxaMJBaj/VAW5RFDF37lxkZmaioKAAZ86cQUFBATIyMjBv3jyIotissjLNuRW7Nr1ez4sjRETk11oy18Xvf/97VNrsqAjsjgobEBDWC7ji/yALv4UEBdmBgGOpEKzlkI2XoHeUwaAS6uzLaDS26Dx4wZlaA4PbRERERETUbNUThLZG9r3dbkd4eHidjHB3xcXFISwsjLXaiYjIr3llrgu1HrbAKFSqglEZ1AP2y65zaa8w5UG8+BMcpnwEaQMwaUhvKGrEoU0mEwwGQ4vOgxecqTUwuE1ERERERF7h7ez7ltyKDQCJiYm8C4CIiPyeLMuwWCyYPHkyUlNTm8zg1uv12LRpEyZNmgSLxeIMKMtBMZADtJAN0bB3HwFHlx4u24mndkE2XoKt4AymT70VvYN/C6QfP34cXbt25QVn8jkMbhMRERERkc9qya3Ys2fP5o9oIiLqELwy14WggCPkMiBAB4cuDLb4myArlL+thoyA45sgS+W49YYR6BsViGBNVfp2Wloazp49ywvO5HMY3CYiIiIiIp/llVuxiYiIOgCvzHWhCYIjMALQR8IRGAlbn/EuqxWmPDjO7kGAtQzPP/UEBkSqoFRUXWxOTk7GzJkzecGZfAqD20RERERE5LO8dSs2ERFRR+CNuS7kLt0hB2ggG6Lh6DoYjuBeLuuVp3bBVpKDIZdHYtnfXsTg7lW1tlNSUmC32/Hxxx/zgjP5DAa3iYiIiIjIp3nlVmwiIqIOptlzXYgBVeVJ1AY4tKGwxd5YpzyJeCwVVrMRQ/tG45svP8M7r/8VISEhuO222zBx4kR8/vnnvOBMPoHBbSIiIiIi8nk1b8WeN29e827FJiIioirakN/KkxiiYLt8nMtqhSkPivP7YDUWQGEpwr23Xo+MQz9h8+bNKCkpwY033sgLzuQTlE03ISIiIiIian/Vt2ILggC1Wo2wsDDodDrIsgyj0chJqoiIiDwgB/eELJUBhq5wxAyBozALiuIzzvXiqW9gj+gHmwzICIDtzC/QdrsKOp0ONpsNKpUKc+fOxaJFi1BYWAiTyQS9Xo+wsDBIkuS8MM2MbWpNzNwmIiIiIiK/JUmSZ7diExERURWFWFWeRBUIhza43vIkAUc+A0QlhNKLcFiMqMzNcJZBMZvNLar9TeQNDG4TERERERERERF1RpoucOhCq8qTBIbBFjvZZbXClAfl2b0QIEMw5kKoKIZQXuDSptm1v4m8gMFtIiIiIiIiIiKiTkru0hOyqIasi4Aj6grYQy93WS+e3AFUVkCQjIClFELJWcAmtVNviVwxuE1ERERERERERNRZKVWQu3QHtCGQVTrY4qZAVgQ4VwuQEXBwPWRVIARTLoTKCiiKTwMsOUI+gMFtIiIiIiIiIiKiTkzWR0FW6yEbukLWdIEtrlZ5EmM2xAv/hSCIVeVJLGUQTJfaqbdEv2Fwm4iIiIiIiIiIqDMTBDhCe0NWaiDrwuCIvAKO4J4uTZTHt0CWZQjWcsBcBKH0PFBpaacOE1VhcJuIiIiIiIiIiKizC9BBDuoG6MIhB2hRGX8TZOG30KEg26E6uA6ypguE8nwIlRYoik+xPAm1Kwa3iYiIiIiIiIiICHJQV8gqHWRDNGRNCOyXj3NZryg6CUXuIUChhGDMhmAxQjDltlNviRjcJiIiIiIiIiIiIgAQFHCE9IYcoIWsC4M9Zigc+iiXJgG//hsQAyBUVgDmQgilF4BKczt1mDo7BreJiIiIiIiIiIioiloP2RANBFaXJ7nZZbVgtyLg0HrI2hAI5gIIlRVQFJ1meRJqFwxuExERERERERERkZMc1K0qezsoBrI+Craeo13Wi3lHoCjIBEQVBGMOBMkEwXSpnXpLnRmD20RERERERERERPQbhQhH6OVVAe7AcNh7joasCXZpEnBwPeSAQAiVFsBSAqHsAmC3tk9/qdNicJuIiIiIiIiIiIhcqQ2Qg2IAXThkdRAq46a4rBYqyxHw66eQNV0glOdDsEkQSi9CqVRCrVZDo9FArVZDqVS20wlQZ8DgNhEREREREREREdUhB8VAVgVCDuoKR2hv2LsOdlmvvLAPgikPAgCVtQRaWxn0AYDZbEZeXh7MZjMMBgO0Wi00Gg0EQWiX86COi8FtIiIiIiIiIiIiqktQwBF2OWSlBrIuDLbe10EOCHRpovrlQ6gMEbCbCrH5809w5w2DERkRgd69eyMiIgJxcXFYuXIlbDYbdDodRFFsp5OhjojBbSIiIiIiIiIiIqpfgA6yoSugC4Os6QJb7CSX1UJ5AXK/X4clTz2LbZ+sQWHuefQO+S2AnZWVhcWLFyMmJgbp6ekMcJNXMbhNREREREREREREDZKDYqqytw3RcITHwx7ax2V9RP5eVFolqEQBXfUiugcpEKR2LUFiMpmQkJCA7du3s0QJeQ2D20RERERERERERNQwhQhHyGWASg+HtgvsfSdCVvyWfa1UCJg7XIdLJgfCdQICAwT0C1dCrBW/ttvtmD59OiRJgkqlattzoA6JwW0iIiIiIiIiIiJqnDYYDl0ooI+EIzAM6DPOZfUVkQEYFhMAc6WMnl1E6JRAv/C65UdMJhNSUlJYmoS8gsFtIiIiIiIiIiIiapRSqYQqsi8CdEEICOkORe9RuFThmpo9Z6gWpZIDCgHo1UVEmE6B7kF1w4/JyclQq9VQKpVt1X3qoBjcJiIiIiIiIiIiojoEQYBGo4FOp4PBYIDZakd+pQYVggaCpgu0w+5yaW9QKzBriA7nS+0I0giI1CnQO1iEQeUaBM/MzERhYSGzt6nFeHmEiIiIiIiIiIiIXIiiCI1GA0mSsHr1aiQnJyMrKwsAMCRaicGx3XHPjaMwJmYolNn7ndtNvFyNim4jYVWHIMBSigPnSlD5w8/470Ur7PJv+zeZTNDpdM5lpVIJURQhCAJkWYbdbofNZmuz8yX/xOA2EREREREREREROYmiCJ1Oh7S0NMyYMQMmk8ll/YkiOwznLmLt+i+wO0KDP48NgtIhOdffHJqNS1f/HnpHGaYadJj38CNYv/lr/C3l3ygoKAAA6PV6AIBGo4FCoYBarUZBQQFMJhP0ej3Cw8NhsVggyzIkSYIsyyCqjcHtDiIzMxNZWVnIy8uDQqFAdHQ0BgwYgJ49e7Z5X7Kzs5GVlYULFy7AZDJBqVSiS5cu6NOnDwYOHMjZcImIiIiIiIiIfFR1KZK0tDQkJCTAbrfXaWO0ysgzOSAKQLBGwkcHSnHfVRrnerH8EtKXz8fHhytwbb+uuHrsOMz+3e9wX+IjuPXumSgqKkJYWBgqKythsVjqZIYDQGxsLBITEzFnzhzodDpYLJZ6+0KdG4Pbfi41NRUpKSnIyMiod/2QIUPw0EMPYezYsa3Wh4qKCuzatQs7d+7Enj17kJeX12BbtVqNm2++Gffffz/i4uLcPsZnn32GP//5z83q32233YbXX3+9WdsSEREREREREXUmarUakiRhxowZjQaTTxXbEa5TINfkwOE8KzIKAxAf9lsN7RkDNUg/JeHnk7koKtyI99d/jgVPPIevd6TjP6mbYLVakZ6eXm9mOABkZWVh8eLFWLp0KTZs2IDJkyfDbDYzwE0uOKGkn5IkCY8++igef/zxBgPbAHDgwAHMmTMHr776aqvcvnH69Glcc801WLhwIb744otGA9tAVb8///xz3H777UhOTvZ6f4iIiIiIiIiIqPkUCgVWr15db8C5pkoHcLbUjoIKByw2GR8fNsOB3yaOVIkC5o/QoUySUSbJCFFasfTpP+P7rz7FHXfcgbNnzyIhIaHJ45hMJiQkJGD79u3QaDQQBKHR9tS5MHPbTz311FPYsmWLc1kQBIwZMwbx8fGorKzE4cOHceDAAQCALMtYs2YNtFotHn74Ya/2w2KxwGw2uzwmiiIGDBiA+Ph4hIeHw2634+zZs/jhhx+cb1iVlZV44403YDQa8fjjj3t8XE9m0+XMu0RERERERERETVMqlVCr1W4nJF4sc6CbQUReuQy1UsaO8yIm9fhtEsgR3VQY0yMAP+dUIi5UiRC1A6/+5WGMmngbPvvsM7ezsO12O6ZPn47s7GyoVCpIktT0RtQpMLjthz7++GNs2rTJudy1a1esWrUK/fv3d2n3/fffY+HChTAajQCAlStXYujQobj22mtbpV+DBw/G9OnTceONNzonBajJaDTijTfewEcffeR8LCUlBcOHD8e4ceM8OlZaWhq6d+/e4j4TEREREREREVEVURRRUFDgUvu6MTKAc6V2qJVAhE5A6q+FmBDbCwpLibPNvOE6zNpUisIKB6L1ChQXVODT1cswY8Yc/OUvf4HD4XDrWCaTCSkpKZg3b14zzow6KpYl8TMVFRVYsWKFc1mtVmPt2rV1AtsAMGbMGKxcudJ5u4Ysy0hKSvJ6n4YMGYIPP/wQGzZswB133FFvYBsADAYDnn32WTzwwAMuj7MeNhERERERERFR+xMEockyIbXlmByoqJSRa3JAJQoou/wml/VRehG/u0KLvHIHIADdDCLSv1iPXmE6TJ482aNjJScnQ61WQ6lkvi5VYXDbz2zcuBEFBQXO5dmzZ6N3794Ntr/66quRkJDgXD5y5Ah27tzptf7ExsZi/fr1GDFihNvbPPzwwy5Z1ydOnMDJkye91iciIiIiIiIiIvKcLMsNJi025mypA2VWGeWVMpThvXHRHuyyfvoADaICFbhQZkeIVkB54UUUZv0XV8T38eg4mZmZKCwsZHCbnBjc9jNfffWV829RFDFjxowmt7nnnntclrdu3eq1/jTnzSQgIKDOlblDhw55q0tERERERERERNQMdrsd4eHhiI2N9Wi7S+UOmKwyBENXBAWqseWCDjaH7FwfIApYcHUgSiwyCisc6GZQoKK0CJcbKuHp9JAmk4nzq5ETg9t+pKioCAcPHnQuDxkyBFFRUU1uN3jwYERHRzuXv/nmG7cL9reWnj17uizXzEYnIiIiIiIiIqK2Z7PZIEkSEhMTPd72ZJEdk2/5PxSU23D0WAY+O2ZxWT88JgBjewbgYpkDkk2G3lYMm7kMlwV7FqjW6XRQKBjSpCocCX5k//79LkX2hwwZ4va2gwcPdv5dUlLi9sQAraW8vNxlOSAgoJ16QkRERERERERE1RwOB+bMmeNxeRJ7QCBuvP13SP16LwRBxvZTEvLLXSeLnDtcB7USsOu7IihQA2POKXQPUkCvci9/Oy4uDhEREVAqlSxNQgAY3PYrtetSDxgwwO1tBw4c6LJ86tQpr/SpuTIyMlyW3clAJyIiIiIiIiKi1iVJEtRqNTZs2OB2+Q9RFLFu3TpYA7sidctWXCp3wKBS4L0DZpd2kYEifn+lFlNu/T/kW4DcU0egVQqIDxPdKk+SmJiIM2fOoLCwkKVJCADASxx+pHZAumvXrm5vW7ttewa3zWYz0tPTncsKhQIjR470aB+rVq3CyZMnceHCBRiNRhgMBoSEhOCKK67AyJEjMWXKFGg0Gm93nYiIiIiIiIioQ5NlGRaLBZMnT0ZqaipmzJgBk8nUYHu9Xo9169ZhwoQJGD9+PHLPF6FXFxHBGgFnSuzYn1OJoV1/u2P/zgEayGOH4IsdP6LCakfPLgpY7DK6GhTINjoaPc7MmTPxyiuvYO7cudDpdF49b/JPzNz2I3l5eS7LNetoN6V229zcXK/0qTnWrFkDs/m3K3dXX301QkNDPdrHp59+igMHDiA/Px8WiwX5+fnIzMzEZ599hieeeALjx4/HBx98AFmWm94ZERERERERERE52e12mM1mTJw4EdnZ2UhKSqozyWRcXBySkpJw8eJFjBw5EuPHj8fevXtxtsQBc6WMC2UOBKoE/OuQGZX2GpNLKgQE7P8X7rjjDhi6x0MbICBEo0CPoIazt6szwysrK/Hee+9Br9cz5kMAmLntV2rXqQ4MDHR729ptawaX21JmZibeeecdl8fmz5/v9eMUFhbi5Zdfxp49e/DGG29Aq9W2aH+C4OncvW2jZr98tY/kuzh+qKU4hqglOH6oJTh+qCU4fshT7owTQRA4nsgt/vQe5HA4UFFRAZVKhXnz5mHRokUoLCyEyWSCXq9HWFgYJElCQEAA9u3bh19//RUAIAPIKrJDGyCgyCyji0bAZ8ctmDHwt9iMkHsYp3d/gleX/QNJzzwCS9YxFFuAKL0CuSbX7O3ameGhoaEICwuDyWTy+efQ2/xp/LQVBrf9SEVFhcuyWq12e9vabdsjuF1eXo5FixbBarU6H5s2bRpGjBjh1vYKhQKjRo3CDTfcgEGDBqFXr14wGAyQJAm5ubnYt28f1q1bh8zMTOc2O3fuxBNPPIHly5e36D99cHBws7dtK126dGnvLpAf4/ihluIYopbg+KGW4PihluD4IbcEBbnRJAjwg9+N5Fv88T0oLCwMYWFhzuXqeNP111+P7OxspKSkYNWqVcjKykKeyQFRAPr2iEHk8Osg478QKoqd2+qOfYr9hsux6OmXsPer9fj4y12w2LKdwe24uDgkJiZi5syZqKysdGaGJyUlwWq1ejzhZUfjj+OnNQgyc/j9xsSJE3H+/Hnn8vHjx90O2J4/fx4TJ050Lo8ePRrvv/++t7vYIIfDgfnz52PHjh3Ox3r06IHPP/8cBoOhye1PnToFlUqF7t27N9pOlmWsXr0aSUlJLrenvPDCC5g+fXrzT4CIiIiIiIg6pyNHgCuuaLzNr78CAwe2TX+IfFR18mGvXr2Qm5sLY2kxQsrPIERtR9Hpwzj8w3aMFY+6bPPB4UrMeGEdUHwWOo0KxWIoypTh0EX1RnR0NM6cOYPk5GS89957KCgogF6vR05OTqcPbNNvmLndDOPHj8fFixdbbf9LlizBrFmz6jxeO/u6srISKpXKrX3WzJaub1+t7aWXXnIJbBsMBqxYscKtwDYAXH755W61EwQBDzzwAABg2bJlzsdXrFiBqVOnuv181VZSUtKs7VqbIAjOK3WlpaWsN0Ue4fihluIYopbg+KGW4PihluD4IU8pysrQVO52WVkZHD76u5F8S0d9D9JqtVixYgUef/xxTJ48GfHx8TAYDBBMl1Bx8QiKTxyAQnAgZLgOV0T+Nrnk9H5K7Nzyb4y4Ziw+WvkmxPBekLWhyDRqcCTjBNLS0uBwVGVyi6KIjRs3QqVSdajnzhMdYfx4uzoCg9t+pPYssBaLxe1grSRJje6rNb399tv48MMPnctqtRorV65EfHx8qx1z9uzZ+M9//oMTJ04AqJpA8+eff8bo0aObtT9/eLOQZdkv+km+ieOHWopjiFqC44daguOHWoLjh9zhzhjhWKLm6CjjRqlUQq1WIzk5GQ6HA1u3bsXWrVud6wdHKxGpExAXpsSHhyrw8gQlFP+rRKANENDl5GZEzbgXRpuAM7u+QkahDYVmGb/k2Zz70Ov12LhxIyZNmgSz2ewMeHdmHWX8tJSivTtA7qsdkPakbnbtySjbKrj90Ucf4a233nIuK5VKvPHGG7j66qtb9bgKhQLTpk1zeWzv3r2tekwiIiIiIiIios5GFEUUFBQgKyur3vUniuyw2IESi4zySmDrCdcEzGui7TCd2o8Jt9+LsPAI9AoWEaQRcFmwAnFxcUhKSkJ2djYmTJgAs9kMu93eFqdFfoKZ282wfPnyOpnQ3tSjR496H4+KinJZzsnJQXR0tFv7zM3NdVl2d7uW+M9//oMXXnjBuSwIAl566SVMmDCh1Y8NAIMHD3ZZbs1SMkREREREREREnZEgCDCZTA2uN1llFJllaEQ74rVKfHbcgut6qaBX/ZZzqzzwL1z5f6/hqjdTYM3JgEURCKFLV3Tpdy2sCIDdbofZbGamMtXB4HYzXHnlle1y3Np1p3NycjBkyBC3ts3JyWl0X962Y8cO/OUvf3F503n66acxderUVj1uTTVn7wWA4uLiBloSEREREREREVFzyLLc5ASPZ0vtCNUpUWqRoQkQ8K9DFZg7PNC5PqD0HGzH01EcPhi6gCAECRbYRBnW7GOoCO4LhrSpISxL4kf69Onjsnz06NEGWtZ15MiRRvflTXv27MEjjzwCm+232kiLFi3CH/7wh1Y7Zn0sFovLcltPoklERERERERE1NHZ7XaEh4cjNja2wTZGq4xSi4y8cgfUooBvzlhxttS1vIjlhzWYfe89+L/fz8azz7+Eb1I/hq28BLrKYoii2NqnQX6KwW0/MnToUCgUv71kBw4ccHvbX375xfl3cHAw+vbt682uOR08eBDz5s2D1Wp1PjZnzhwkJia2yvEac/78eZfl2pncRERERERERETUMjabDZIkNRn7OVtqR4VNRplFRkSgAsk/uc4lp1fa8fsrNQCAn0/kYPMX/8aD996Fn77+D7QBAgPcVC8Gt/1IWFgYrrrqKufygQMHkJeX1+R2Bw4ccKm5ff3110Op9H5FmoyMDMyZM8dlosvf//73eOyxx7x+LHfs2rXLZblfv37t0g8iIiIiIiIioo7M4XBgzpw5jZYnKbFUZW9nm+wIUAg4W2rHvmzX7O3b+2vQPUiBChuQb3YgWGnFX5/+C3748hNoNBoIgtDap0J+hsFtPzNlyhTn33a7HRs2bGhym3Xr1jW4D285d+4cZs2ahdLSUudj06ZNwzPPPOP1Y7nj/PnzSE1NdXls7Nix7dIXIiIiIiIiIqKOTJIkqNVqbNiwodEM66wiGyw2oMAso6tBCc2Y+yELv7VXKgTMHaYDAOSVOyDLQJgGePmpRZDKy6BSqVr9XMi/MLjtZ6ZPn+5SXiMlJQWnT59usP2+fftcgrwDBgzAuHHjGj3GW2+9hfj4eOe/t956q9H2eXl5mDlzJvLz852PTZkyBS+99JJXrqidPHkSlZWVbrcvLS3F/PnzXUqjjBs3Dj179mxxX4iIiIiIiIiIqC5ZlnHjjTciNTW1wQxucyVw0ehAmV2FWbMfwMD+A7AjR+PSZmR3FYZ2VcIhV2Vvh+kE2KQKfPremyxNQnUwuO1ndDod5s2b51yWJAkzZ87EsWPH6rT9/vvvMW/ePMjyb3PKLlq0yKu3cJSUlGDWrFm4cOGC87EbbrgBr7/+utfecNavX48bb7wRa9ascSmvUpssy/j6668xbdo0HD9+3Pm4Vqttt9IoREREREREREQdmSiK0Ol0sFqt2LhxI0aNGoVz584hKSmpziSTcXFxWPD0q1j/7y/Qc+DVWPHGK0j57gKKKhwu7eYO00EhVAW3ZQCRgSLSv1gHlUJulVK75L84GvzQH/7wB+zfvx9btmwBAOTk5GDatGkYM2YM4uPjYbPZcOjQoToTTiYmJuK6667zal927tyJrKwsl8e+/fZbl9rg7pg6dSpefvnlBtdfvHgRr776Kv7+97+jV69e6N+/PyIjI2EwGGCxWJCbm4uff/4ZOTk5LtuJoohly5a12gSaRERERERERESdVXVgOy0tDTNmzIDJZEJ4eDhmzZqFxMRELFq0CLm5uTAajejSpQsiIyNx5swZ/CM5Cfu+WocI0YRgrQJrf6nA4tGBzv32DlFiSh81vjwhocDsQLhWgWMXz6Pk5H6oe1wFWzueM/kWBrf91N/+9jfY7XZs3boVQFXW8nfffYfvvvuuTltBEHDvvffikUce8Xo/amaFV7Pb7fW0bJzD4Wi60f+Od+bMGZw5c6bJtjExMXjttdcwfPhwj/tDREREREREREQNEwQBGo0GaWlpSEhIcMaDCgoK8Oqrr+K1117D5MmTER8fD4PBgNGjR2PQoEHo06cPHA4HhnVVwhaoQN9QEXsvWHGySI0+ob+FKmcO1mLnGQn55VXB7cu6iLAU50ATGAQExgCcXJLA4LbfUqvVWL58Ob744gu89957yMzMrLfd4MGD8dBDD3k9Y7stTZw4EUVFRfjpp58aLUtSLS4uDjNmzMC0adMQGBjYZHsiIiIiIiIiIvKMWq2GJEmYMWNGvYmODocDW7dudSZmPvLIIxgyZIgzwfF0iR2BKgFGSUZkoALv/GzG3ycFObcP0Spw9xVarP2lAqdL7Lg8RERgZTFgugTB5oAc3KNtTpR8GoPbfm7q1KmYOnUqMjIykJWVhby8PIiiiMjISAwcOBC9evXyeJ8LFizAggUL3Gp7++234/bbb/f4GJ4YOXIkRo4cCQAoKirCiRMnkJ2djeLiYlRUVCAgIMB5a8ugQYMQGhraqv0hIiIiIiIiIursFAoFVq9eDZPJ5Fb748ePo2vXroiPj0fv3r3Rr18/9NVbIFYUwpF/Atv3HcOeC1aM7q5ybnPXAA22ZEm4VO6APTAagUoHLGW5ECorIQdGAAGaRo5InQGD2x1EfHw84uPj27sbrS40NBRXX311e3eDiIiIiIiIiKjTUiqVUKvVSE5Odnub/fv3o7i4GHv27EFISAhycnJQXpiNYEs2QlCGOwsu4evd38Pu+BaioqrkiEoUMHuIFi9/V45xN/0fbOpgOEpyIKiDIJhyIIf0bq1TJD/B4DYRERERERERERG5TRRFFBQUICsry632o0ePRmpqKhQKBd577z0kJyc7tx3WVYlhcd0wfdJo3HznH2E/pIZ4codz2/G91fjytIxbbrkFDsgQkAvZXAxBVEE2dAOUqoYOS52Aor07QERERERERERERP5DEAS3y5GMHj0aO3bswJ49e9C9e3csXrzYJSiebXTg+JlsfPL5f7Dowfvwq6IfZJXrHGp/veVyBCiVqHQ4IGtDIFQUQ7DbIBhzvHpe5H8Y3CYiIiIiIiIiIiK3ybIMvV7fZLvw8HCkpqYiPT0d06ZNqzcgnlfugN0BFFU4oBWs+MtzL+N88AiXNvqKbNhOfgfIgKwLhQAZqCiCUJ4P2K1eOy/yPwxuExERERERERERkdvsdjvCw8MRGxvbaLvZs2dDFEXcc889sNvt9bZxyECeyYFCswMAEKKWsTD5K8j6SJd24sH1VYFshRKyJvh/2dtWCKUXvHNS5JcY3CYiIiIiIiIiIiK32Ww2SJKExMTEBtsoFAokJiZi7dq1TZYwuWi0wyYDJRYZkYEKlJsrsM8W57o/cwGUWWkAADkwHAIAmPKhKC8ALKUtPSXyUwxuExERERERERERkUccDgfmzJnTYHmSyZMno1evXkhOTm5yXxU2IL/cgRyjHQKAaL0CyV/tB6IHuLRTHtsMSEZAoYQjMAIKSwlQaYai+CwgO7xwVuRvGNwmIiIiIiIiIiIij0iSBLVajQ0bNkAUxTrr+/Xrh5ycHJfJIxtzstgOqwO4VO5AuFaB/NwLqBhwl0sbwVaBgGOpVQuaYMgBOghlORAqzZxcspNicJuIiIiIiIiIiIg8IssyLBYLJk+ejNTU1DoZ3Hq9Hkaj0e39We3AuVI78s0OWO0yYgwiyjVRcFw2xqWdeGIHBNMlQBAgG6IhOCqBimIIZTmAjZNLdjYMbhMREREREREREZHH7HY7zGYzJk6ciOzsbCQlJTknmTSZTDAYDB7t73ypAxU2INvogEElQCs64Bg0HbJC6WwjyHYof/20akGprppc0lxQNblkGSeX7GwY3CYiIiIiIiIiIqJmqQ5wi6KIuXPnIjMzEwUFBXjyySfRtWtXZ7DbHTKA08U2lFll6EMiYRDMcOjCYOs70aWd8vyPEIpOVW0TGA4BAlD+v8klreXePD3ycQxuExERERERERERUbPJsgxJklBRUQGj0QitVougoCBIkoTExESP9pVvllFulTH8hltgMxthN5fA1v82yAE6l3YBhzYAslw1uaQuHEJFCWCzQFHK7O3OhMFtIiIiIiIiIiIi8gqbzQZJkmCxWOBwODBnzpw69bibcqlSgxtvmwZHgA5CeT4QEAhb/9tc2oj5x6HIPVS1oA2GoBABSxkztzsZBreJiIiIiIiIiIjI6yRJglqtxoYNGyCKolvbiKKId/65EQH6EFRqQiDYJMBqhK3vRDh0YS5tq7K3HYCggCw0vX+lUgm1Wg2NRgO1Wg2lUtnkNuTbGNwmIiIiIiIiIiIir5NlGRaLBZMnT0ZqamqTGdx6vR6bNm3CpEmTYNFEAEot5ABtVckRUQXbFXe4tFeUXYR45rtG9ykIAjQaDXQ6HQwGA8xmM/Ly8mA2m2EwGKDVaqHRaCAIQktPl9oBg9tERERERERERETUKqonnJw4cSKys7ORlJRUZ5LJuLg4JCUlITs7GxMmTIDZbIY9QA9ZqYasDYFgLQdsEuw9R8PRpafLtgFHPkOA4EBAQAAClEqXDHFRFKHT6WCz2bBixQrExcUhIiICvXv3RkREBOLi4rBy5UrYbDbodDq3s8vJdzC4TURERERERERERK2mOsAtiiLmzp2LzMxMFBQU4MyZMygoKEBGRgbmzZsHURSrAtt2OyAIkPWRgNoAWSFCsJQAggKVg6a77FuoKIb9yCaUGUshWa3Q6XTQarXQarXQ6XRIT09HTEwMFi9ejKysLJdts7KysHjxYsTExCA9PZ0Bbj/EwjJERERERERERETUqmRZhiRJAIDKykpn8FmWZRiNRthstrrb6MIhl14ANF2gsJRCDowAYq6C3HUQhJxDzna2A//Gq98acbFMhhzUFSPvnI85c+ZAlmW8/PLLMJlMjfbNZDIhISEBmzZtcmaOy7Ls3SeAWgUzt4mIiIiIiIiIiKjN2Gw2SJIEi8UCSZLqDWwDAMQAyNpQQBMCOOxQWE1Qa9Q4qhkCR43gc6BKwJQ+agDA+fMXXLKxt2/fjlGjRjXZJ7vdjunTp0OSJKhUKq+cJ7U+BreJiIiIiIiIiIjIJ8n6SECpgqwxQGUtwU/79mHRi//AjlNWl3bX9lQhQvfbpJAmkwnTpk3Djh07sGnTJoSHhzd5LJPJhJSUFJYm8SMMbhMREREREREREZFvUhsga7ogIKQ7KiuteO/NF+Fw2LH2YAWs9t+yt5UKAXf017hsarfb8bvf/Q5KpRKzZs1y63DJyclQq9VQKlnN2R8wuE1EREREREREREQ+yxHSG4IqENv3HoJOsCJILeBSuQOpGZJLu9E9AtAnxDXr2mQyYe3atUhMTIRC0XQoNDMzE4WFhcze9hMMbhMREREREREREZHPUmp0UEXH4ZNN21FmkdHNUBV4/vjXCpRbHc52CkHA7KHaOtsnJyfjsssuw+TJk906nslkgiAITTekdsfgNhEREREREREREfksURRRKCnw64nzyDE5oBKBILWAMknGhiMWl7YjYgKgrBXxzMzMRG5uLuLj4906nl6vh1xjwkryXQxuExERERERERERkc8SBAEmkwnny+yw2GWUV8oI01aFNT87bsGlcruz7aVyB+qLSxuNRhgMhiaPFRcXh7CwMNjt9ibbUvtjcJuIiIiIiIiIiIh8lizL0Ov1KLbIsNiAQrOMILWAAAVgsQGPbzficF4lDuVV4rldJtjrCW4bDAYYjcYmj5WYmAhJkmCz2VrhTMjbOO0nERERERERERER+Sy73Y7w8HDExsYi99JJ6JSA3aBAmE6BXJMDF40OvLPfjFILcK60bsZ1XFwcoqOjkZGR0ehx9Ho9Zs+ezaxtP8LMbSIiIiIiIiIiIvJZNpsNkiQhMTEROUYH7DJQXCEjVOteaDMxMRFnzpxBWlpag21EUcTGjRuhVqthtVq91XVqZQxuExERERERERERkU9zOByYM2cO1Do9Cs0OFFbYEaAAgjVCo9vp9XrMnDkTycnJcDgcDbbZtGkTJk2aBIvFwskk/QiD20REREREREREROTTJEmCWq3Ghg0bkGsWYLEDZRYZUYENhzers7EDAwMxdepUXH311S7r4+LikJSUhOzsbEyYMAFms5klSfwMg9tERERERERERETk02RZhsViweTJk/GvT/6DSoUWeeUOaJQCuqjrZm/r9Xp88cUXuOGGG/Dpp59i4MCB+O6771BSUoIzZ86goKAAGRkZmDdvHkRRZGDbTzG4TURERERERERERD7PbrfDbDZj4sSJ2Lb3V8x8YB50wZEu2ds9e/RAUlISzp8/j5EjR2L8+PG45557EBMTg+3bt0Ov1yM6OhparRZGoxFmsxmSJLEUiZ9StncHiIiIiIiIiIiIiNxRHeBWG8IxdcbvcUfCTSg7cwhWSUJAcFcEX3YFzsmReOWVV/Dee++hoKAAAGAymZCQkIBNmzZhwoQJsFqtDGh3AAxuExERERERERERkd+oDkpLmgi8+tQTGBCtg0ErorACOHR2LZZ/9kO9k0fa7XZMnz4d2dnZUKlUkCSprbtOXsbgNhEREREREREREfkVhUKB1R9+im07d+NgoAK9Q0RcKpdxrtReb2C7mslkQkpKCubNm9eGvaXWwprbRERERERERERE5DeUSiXUajWS33kHF8ocKLPKkGzulxhJTk6GWq2GUsm8X3/H4DYRERERERERERH5DVEUUVBQgKysLOSZHLDagXxzVXA7QGx6+8zMTBQWFkIU3WhMPo3BbSIiIiIiIiIiIvIbgiDAZDIBAGQA2UY7iiocsDncz942mUwQBKGVekhthcFtIiIiIiIiIiIi8huyLEOv1zuXs40OyMD/Atzu7UOv1zsnpiT/xeA2ERERERERERER+Q273Y7w8HDExsYCAGwOIKPADpNVxulie5Pbx8XFISwsDHZ7023JtzG4TURERERERERERH7DZrNBkiQkJiY6H8srd+C/2TbkmJpO3U5MTIQkSbDZbK3ZTWoDDG4TERERERERERGRX3E4HJgzZ45LeRJ36PV6zJ49m1nbHQSD20RERERERERERORXJEmCWq3Ghg0bIIqiW9uIooiNGzdCrVbDarW2cg+pLTC4TURERERERERERH5FlmVYLBZMnjwZqampTWZw6/V6bNq0CZMmTYLFYuFkkh0Eg9tERERERERERETkd+x2O8xmMyZOnIjs7GwkJSU5J5msFhcXh6SkJGRnZ2PChAkwm80sSdKBKNu7A0RERERERERERETNUR3gVqlUmDt3LhYtWoTCwkKYTCbo9XqEhYVBkiRnO2ZsdywMbhMREREREREREZHfkmUZkiQBACorK6HVaqHT6SDLMoxGI2w2Wzv3kFoLg9tERERERERERETUIdhsNgazOxHW3CYiIiIiIiIiIiIiv8PgNhERERERERERERH5HQa3iYiIiIiIiIiIiMjvMLhNRERERERERERERH6HwW0iIiIiIiIiIiIi8jsMbhMRERERERERERGR32Fwm4iIiIiIiIiIiIj8DoPbREREREREREREROR3GNwmIiIiIiIiIiIiIr/D4DYRERERERERERER+R0Gt4mIiIiIiIiIiIjI7yjbuwPkHZmZmcjKykJeXh4UCgWio6MxYMAA9OzZs7271mrsdjsOHDiA8+fPIz8/H3q9HtHR0Rg6dCiCg4Pbu3tERERERERERETUihjc9nOpqalISUlBRkZGveuHDBmChx56CGPHjm21Ply4cAETJkxo1rZRUVHYvXu3R9tYrVa888472LBhA/Lz8+usDwgIwLhx4/DYY4+hV69ezeoXERERERERERER+TaWJfFTkiTh0UcfxeOPP95gYBsADhw4gDlz5uDVV1+FLMtt2MPWceHCBcyYMQNvv/12vYFtAKisrERaWhqmTp2KLVu2tHEPiYiIiIiIiIiIqC0wc9tPPfXUUy6BW0EQMGbMGMTHx6OyshKHDx/GgQMHAACyLGPNmjXQarV4+OGHW71vCoUCgiC41VapdH8IGo1GPPDAAzh58qTzMa1Wi3HjxqFHjx4oKSnBnj17cO7cOQCA2WzGkiVLEBISgmuuucazkyAiIiIiIiIiIiKfxuC2H/r444+xadMm53LXrl2xatUq9O/f36Xd999/j4ULF8JoNAIAVq5ciaFDh+Laa69t1f699NJLuP32272+32eeecYlsD1y5Ei8+eabCA0NdT5mt9vx/vvv47XXXoMsy7DZbFi4cCG2bdvm0o6IiIiIiIiIiKg2pVIJURQhCAJkWYbdbofNZmvvblEDWJbEz1RUVGDFihXOZbVajbVr19YJbAPAmDFjsHLlSmcWtSzLSEpKarO+etOvv/6Kr776yrnct29fpKSk1AlYi6KIWbNmYf78+c7HysrK8M4777RZX4mIiIiIiIiIyH8IggCNRgOdTgeDwQCz2Yy8vDyYzWYYDAZotVpoNBq3KxVQ22Fw289s3LgRBQUFzuXZs2ejd+/eDba/+uqrkZCQ4Fw+cuQIdu7c2ap9bA2rVq1yWX7mmWegUqkabP/ggw+iZ8+ezuV169ahqKio1fpHRERERERERET+RxRF6HQ62Gw2rFixAnFxcYiIiEDv3r0RERGBuLg4rFy5EjabDTqdDqIotneXqQYGt/1MzexlURQxY8aMJre55557XJa3bt3q9X61pvLycuzevdu53KdPH4waNarRbQICAnDXXXc5lyVJ8sugPhERERERERERtY7qwHZ6ejpiYmKwePFiZGVlubTJysrC4sWLERMTg/T0dAa4fQyD236kqKgIBw8edC4PGTIEUVFRTW43ePBgREdHO5e/+eYb2O32Vulja/juu+9gtVqdyzfeeKNb202ZMsVleceOHV7tFxERERERERER+afqUiRpaWlISEiAyWRqtL3JZEJCQgK2b9/OEiU+hMFtP7J//344HA7n8pAhQ9zedvDgwc6/S0pK6lyF8mU//fSTy7K7592zZ0+EhYU1uB8iIiIiIiIiIuqc1Go1JEnCjBkz3E4CtdvtmD59OiRJarRcLrUdBrf9yMmTJ12WBwwY4Pa2AwcOdFk+deqUV/rUFmr31ZPzrjnRZmlpqUu9ciIiIiIiIiIi6pwUCgVWr17dZMZ2bSaTCSkpKSxN4iOU7d0Bcl/tIG/Xrl3d3rZ229YMbm/btg1ffvklTp48ieLiYqjVagQHByM2NhYjRozATTfdhMjISLf3V7OvKpXKJRu7KTExMXX2FR4e7vb2RERERERERETUsSiVSqjVaiQnJzdr++TkZCxatAhWqxU2m83LvSNPMLjtR/Ly8lyWa9bRbkrttrm5uV7pU32++eYbl+WKigqUlJTgzJkz2L59O15//XXceeedeOyxxxAYGNjk/mqed1RUlEc1jWrXJG/N8yYiIiIiIiIiIt8niiIKCgqaXbY3MzMThYWF0Gq1DG63M5Yl8SPl5eUuy+4EhhtqazabvdKn5rBarfj4449x55134uzZs422tVgsLnWPPDlnANDr9S7L7XneRERERERERETU/gRB8LgcSW0mk4mTSvoAZm77kYqKCpdltVrt9ra127ZGkDc+Ph4TJ07EsGHD0LdvXwQHB0OWZRQUFODgwYP44osvsHv3bmf7U6dOYc6cOdiwYQNCQkLq3WftfnpyzgDqFPdv7nn76ptVzX75ah/Jd3H8UEtxDFFLcPxQS3D8UEtw/JCn3BkngiBwPJFb+B7kO2onRDZ3+7Z8HTl+6mJw249YLBaXZU9mZa3dtva+WiI4OBjr16/HkCFD6l3fvXt3dO/eHbfccgt27dqFxx9/HKWlpQCAs2fP4sUXX8SyZcvq3VaSJJdlT2ei9dZ5BwcHN2u7ttSlS5f27gL5MY4faimOIWoJjh9qCY4fagmOH3JLUJAbTYIAP/jdSL6F70HtS6vVIjY2tlmlSeLi4pxzwmm1Wm93zS0cP1UY3G6G8ePH4+LFi622/yVLlmDWrFl1Hq+dtVxZWel2sNdqtTa6r5bQ6/UNBrZru/7667Fy5Urcd999zppEW7ZswYMPPoi4uLg67es7Z0+05nkTEREREREREZF/slqtSExMxOLFiz3eNjExEVar1eMkTPI+Brf9iE6nc1m2WCxu/yeqnQFde19tafjw4bjjjjuwYcMGAIAsy/jqq6/qDW7Xd86eqB3cbu55l5SUNGu71iYIgvNKXWlpKWRZbucekT/h+KGW4hiiluD4oZbg+KGW4PghTynKytBU7nZZWRkcPvq7kXwL34N8h1qtxpw5c7B06VKP6m/r9XrMnj0bdru9zeNFHWH8eLs6AoPbfqR2YNZsNlfd+uSG2pNRtmdwGwDuvPNOZ3AbAPbs2YOFCxfWaafRaCCKonNSSU9rZtd+c2ruefvDm4Usy37RT/JNHD/UUhxD1BIcP9QSHD/UEhw/5A53xgjHEjUHx037kiQJOp0OGzZsQEJCgjP21BhRFLFx40ao1WqYzeZ2ff04fqowuN0My5cvr5MJ7U09evSo9/GoqCiX5ZycHERHR7u1z9zcXJdld7drLVdccQUCAgKcZUays7MbbBsZGYmcnBwAQF5eHmRZdrtofl5enstye583ERERERERERG1P1mWYbFYMHnyZKSmpmLGjBmNZnDr9Xps3LgRkyZNavfANv2Gwe1muPLKK9vluJdffrnLck5Ojtu1rquDww3tq60pFAoEBwcjPz8fAFBcXNxg28svv9zZf0mSUFhYiPDwcLeOUzto3t7nTUREREREREREvsFut8NsNmPixInIzs5GSkoKVq1a5TLJZFxcHBITEzF79mxnxrY7Wd7UNhTt3QFyX58+fVyWjx496va2R44caXRf7aFm/ezGJnqsHZD25LyPHTvm/DsoKAgREREe9JCIiIiIiIiIiDqy6gC3KIqYO3cuMjMzUVBQgDNnzqCgoAAZGRmYN28eRFFkYNsHMbjtR4YOHQqF4reX7MCBA25v+8svvzj/Dg4ORt++fb3ZNY8VFxfDaDQ6l8PCwhpsO3z4cJdld8/77NmzKCwsbHA/RERERERERETUsSmVSqjVamg0GqjVaiiVdQtZyLIMSZJQUVEBo9EIrVaLyMhIaLVaGI1GmM1mSJLEUiQ+iMFtPxIWFoarrrrKuXzgwIE6NaXrc+DAAZea29dff329/5Hb0u7du12W+/Xr12Dba6+9FgEBAc7lrVu3unWM2u0mTJjgQQ+JyNdNnToVo0aNwqhRoxqt209ERERERESdiyAI0Gg00Ol0MBgMMJvNyMvLg9lshsFggFarhUajqXdON5vNBkmSYLFYIEkSbDZbO5wBuYs1t/3MlClTnJnLdrsdGzZswMMPP9zoNuvWrauzj/ZUWVmJ1atXuzx27bXXNther9dj7Nix+PrrrwEAp06dwt69ezFq1KhGj/Hpp586l1UqFcaPH9/CnlNnM3fu3EbvFNDpdAgKCkJsbCxGjBiBm2++GXq9vg17SEREREREREQ1iaIIjUYDSZKwevVqJCcnu9TQjo2NRWJiIubMmQOdTgeLxcJSI36MwW0/M336dLz77rvOchspKSm47bbb0Lt373rb79u3D6mpqc7lAQMGYNy4cY0e46233sLbb7/tXJ4/fz4WLFhQb9u8vDyo1WoEBwe71X+Hw4Fnn33W5U0lIiICt9xyS6PbzZ071xncBoAXXngBn3/+OVQqVb3t33nnHZw7d865fPfddyM0NNStPvoKRd4RwG5ttI0gCHCUGaram4wd//YYUQVH1MD27oWT2WyG2WxGbm4uvv32W7zzzjtYvHgxbr755vbumluys7MxcuRIAEDXrl3x+eeft3OPiIiIiIiIiJpPFEXodDqkpaVhxowZMJlMddpkZWVh8eLFWLp0KTZs2IDJkyezlrYfY3Dbz+h0OsybNw8vvPACAECSJMycOROrVq1C//79Xdp+//33WLhwoUvAc9GiRfXectFchw8fxpIlSzBjxgzcdtttGDBgQINtjx07hr/97W/48ccfXR5/9NFHodPpGj3OoEGDcOONN2Lbtm0AgBMnTmD27Nl48803XYLWDocD77//vktw3mAw4MEHH2zO6bUvuxVCRQlQaW6wiQBAtgVW/V1e3jb9ai8BOsja4HY7/IABA1zGtyzLMBqNOHbsGM6fPw8AKC8vx/PPPw+r1YqpU6e2U0+JiIiIiIiIOp/qUiRpaWlISEhoMlhtMpmQkJCATZs2YcKECTCbzR0/abADYnDbD/3hD3/A/v37sWXLFgBATk4Opk2bhjFjxiA+Ph42mw2HDh2qU04hMTER1113ndf7U15ejjVr1mDNmjWIiIjAgAED0KNHDxgMBsiyjMLCQhw8eBCZmZl1tp01axZuv/12t47z4osvIjMzE6dPnwYA/Pjjjxg/fjzGjx+PHj16oLi4GHv27HHJ2BZFEW+88QbCw8O9c7JtrdIMhbkQUDTyX1VRld0tWCrgvcsWPsZhg0MHoB2D26NHj8acOXPqXffNN9/gxRdfdF4RTkpKwjXXXIPIyMi27GKn88UXX7R3F4iIiIiIiMhHqNVqSJKEGTNmuJ2FbbfbMX36dGRnZ0OlUkGSpFbuJXkbg9t+6m9/+xvsdrtz0kRZlvHdd9/hu+++q9NWEATce++9eOSRR1q9X/n5+di1a1eT7TQaDZ588kn87ne/c3vfQUFBWL16NebPn4/jx48DACoqKpxB/tp0Oh2ee+45jB071u1j+CSFEo6wvvWvEwDhfzWeHSYT0EEvMCoKT7R3Fxp1ww03ICAgAIsXLwYAWK1W/Pvf/8bcuXPbuWdEREREREREnYNCocDq1avrLUXSGJPJhJSUFMybN6+VekatSdHeHaDmUavVWL58OV599VXExcU12G7w4MF499138Ze//MWr5UiqxcfH45577kHfvn2hUDQ9nCIiIvDAAw9g27ZtHgW2q/Xo0QOffPIJ5s2bh4iIiHrbBAQEYNKkSfjss8+QkJDg8TGImmPMmDGIjY11Lv/3v/9tx94QERERERERdR5KpRJqtRrJycnN2j45ORlqtRpKJfOA/Q1fMT83depUTJ06FRkZGcjKykJeXh5EUURkZCQGDhyIXr16ebzPBQsWNDiBZG09evTA0qVLAVRNrnfixAlcuHABBQUFMJvNEAQBBoMBoaGhGDhwIHr06OFxf2pTqVRYuHAh5s+fj/379+P8+fMoKChAYGAgoqOjMXToUISEhLT4OESeuvLKK52TpV68eLHBdnv37kV6ejoOHjyIwsJC2O12hISEID4+HmPHjsWUKVPc+kC12WzYvn07vvnmG2RlZaG4uBhWqxVqtRqhoaHo1q0bBg4ciDFjxmDgwN8m4ty8eTNefPFFl33l5ORg1KhRDfa3IadPn8bWrVvx3//+Fzk5OTAajdDr9YiJicGoUaMwbdq0Bi9EVZs7d66zjNKKFSswbNgwFBQUYPPmzdi9ezdyc3NRUlICnU6H9PR053ZTp05Fbm4uAOCzzz5DTExMo8fJycnBpk2b8OOPPyI7OxtGoxEGg8HZ14SEBERFRTW6j59//hkPPfQQAGDIkCFYtWoVAOCHH37AV199hWPHjqGwsBAVFRV45JFHcPfddze6v/rUd17nz5/HF198gT179iAvLw82mw09evTAxIkTcffdd0Oj0bjs4+zZs/jkk09w4MAB5OTkQKFQoFevXrjpppswbdo0iKLodn+aeo3/9Kc/Nfm8AVXZED/88AP279+PzMxMXLx4EeXl5VCpVAgJCcGAAQNw/fXXY/z48U1eLK05hm+++WY8++yzAKpKBG3atAknTpxAUVER9Ho9YmNjcdNNN2HKlCmtcpGXiIiIiIjanyiKKCgocP4m91RmZiYKCwuh1Wphs9m83DtqTQxudxDx8fGIj49v1z7odDoMGjQIgwYNapPjiaKIESNGYMSIEW1yPKKmGAwG59/l9UzwWVRUhGeffRY//fRTnXW5ubnIzc3Frl278MEHH+D555+vM0lsTefOncOSJUtw5syZOuvMZjPMZjMuXLiAH3/8EWvWrMEnn3zilYtL1axWK9544w2kpqbWqWVWUlKCkpISHD16FB999BHmz5+Pu+66y+197969Gy+++CLKysq81t+1a9fi/fffr1M/rbi4GMXFxThy5Ag+/PBDzJo1C/fee6/b+zWZTHjhhRfcKsfUXF999RVeffVVWCwWl8dPnDiBEydO4Ouvv8bbb7+NoKAgAMCaNWuQkpICh8Ph0v7IkSM4cuQIvv76ayQlJdUJiNfm7mv88ccf4/HHH8ett97a4L527tyJpUuXwmq11llns9lgNptx8eJFbN++HbGxsXj11VebvFhRk8lkwnPPPYdvv/3W5fHi4mLs27cP+/btw7Zt2/DKK680ed5EREREROR/BEHwuBxJbSaTCTqdzks9orbC4DYRkZcYjUbn3/r/1UKvVlhYiAcffBAXLlxwPta9e3cMGDAAKpUKp0+fxpEjRwAA58+fx0MPPYQ33ngDV111VZ3jlJeXY8GCBcjLywNQVVcsLi4Ol112GbRaLSRJwqVLl3DixAmUlJTU2f6yyy7DnXfeCbPZjC+//BJA1cWpm2++2a3zrKiowMKFC3Ho0CGXc4mPj0dQUBDKyspw6NAh5OfnQ5IkLFu2DOXl5fjTn/7U5L4PHz6MlJQU2Gw2dOnSBYMHD0ZwcDCKi4vrnZTWHa+//jo+/fRT57JOp8PQoUMRFhaGwsJC7N+/H2azGZIkYeXKlSgqKnJ7joKlS5fi+++/hyAI6N+/Py677DIAwMmTJ72SJbxnzx4sW7YMDocDPXr0cI6XkydP4ujRowCqMgyeeeYZLF++HB988AHeffddAEDfvn0RGxsLURRx9OhRnDp1CgCwf/9+LF++HE888USDx/XkNbZYLHjhhRdQUFCA++67r979Vd9VAACRkZHo3bs3wsLCoFarUVFRgTNnziAjIwOyLCMrKwuJiYn417/+hS5dujT5HNntdjz55JP46aefEBAQgCuvvBLdunWD1WrFwYMHnVnwe/fubfK8iYiIiIjIP8myXOd3uKf0ej1kuYNOZtaBMbhNROQlNQOBtbNOX3zxRWdgW6vV4i9/+QsmTZrk0ubYsWN4+umncfHiRZjNZjz77LP48MMPXTLCgaqSDNWB7d69e+OVV16ptwSRLMs4duwYNm/eDJVK5Xz8iiuuwBVXXIGcnBxncLtLly547LHH3DrP1157zXmuPXv2xBNPPIFhw4a5tLHb7fjiiy+wfPlyWK1WrF69GsOGDcOVV17Z6L5Xr14Nh8OBBx54APfee69LeZb6sn6bkp6e7hLYvuWWW/Doo48iMDDQ+Vh5eTlee+015wS969evx1VXXYVx48Y1uu9Dhw7BbrejT58+eO6559C3r+vEr83pb23Lly+HRqPB008/jfHjx7us2759O/7617/Cbrfjxx9/xPr16/Huu+8iIiICzz33HIYOHerS/uOPP8Y//vEPAMB//vMf/PGPf2wwO9rd1/g///kP3nzzTVitVrz77rsYOnRova9xREQE5s2bh3HjxjV4B0F2djb+/ve/Y+/evbh06RLefvttPPXUU00+Rzt37oTVasXo0aPx5z//GZGRkc51NpsNq1atwkcffQQA+OKLLxo9byIiIiIi8k92ux3h4eGIjY1tVmmSuLg4hIWFuSStkX/ghJJERF7w/fff48SJE87l4cOHO//++eefsWfPHufyiy++WCewDQD9+/fHW2+95bzanJeXh40bN9Zp98svvzj/XrRoUYO19QVBwIABA7BkyRK3aiK745dffnEGxLt374533323TtATqCobdMcdd2DJkiUAqr5ovPfee03u326344EHHsD9999fp+54zQC9OxwOB1auXOlcnjBhAp5++mmXwDYABAYGYunSpbjuuuucj61YsaJOWY/6+hoWFoYVK1bUCWw3p7/1qaysxCuvvFInsA0AkyZNwi233OJcfvPNN6FUKvGPf/yjTmAbAO655x5nGSeHw4EdO3bUe0xPX+PnnnsOQOOv8dixY3Hvvfc2WhonJiYGr7/+uvO5TEtLc6s0jdVqxeDBg/Haa6+5BLaBqkll5s+fjwEDBgCouuBTs247ERERERF1DDabDZIkITExsVnbJyYmQpIk1tv2QwxuE/kqhwOQTIBUDljKGvhnhFxRCrmiFLAYG2nn5/+k8qrnw0ft2rULf/3rX53LKpUKd9xxh3P5888/d/49duxYjBkzpsF9xcTEuJR2+Pzzz+vcFlWznndbT566bt06598PP/wwgoODG21/6623OoPvP/74I0pLSxttHxERgT/+8Y8t7mf18bKzswEAAQEBePTRRxssFSIIAh577DFnQP3ChQvYt29fk8e4//77m3wOWmLs2LG4+uqrG1w/efJkl+Vp06ahd+/ebrWvLmtSm6ev8e23347LL78cgHuvcWOUSiVuvPFGAIAkSTh48KBb2z3yyCMNTsIqCILLRYCGzpuIiIiIiPybw+HAnDlzPC5PotfrMXv27DpzDZF/YFkSIh8kZm6FevtSKKSmsxarQ77a1u1Su3MEBKLy6tlwxAxpl+Pv2bOnTtDOaDTi6NGjOH/+vMvjDz/8sEum9M8//+z8+7bbbmvyWLfeeitWrVoFh8OBgoICnD171lnLGYDLvj/77LM2qyFss9mcAd/AwMBGg/Q1DRs2DGfPnoUsyzh48KBLhnRt48aNazBI6amaE3dec801CAsLa7R9ZGQkRo0ahe+++w5A1es2atSoRreZOHFiyzvaiKZKo/Tp08ej9tVBaADOwH9NzX2NR44ciVOnTrn1GhuNRvz66684deoUysrKYDabXS7g1JwkNSsrC2PHjm302N26dUO/fv0abVNzwuWcnJwmzoaIiIiIiPyRJEnQ6XTYsGEDEhIS3ApWi6KIjRs3Qq1Ww2w2t0EvydsY3CbyQZrtz0KQWOepJkVlOVT7VqNyZPNuMWqpo0ePNpnxqdPp8Oijj+LWW291Pnbp0iUUFxc7l5uqOQ1UZWP36NEDZ8+eBQBkZGS4BLcnTJiATZs2AajK7M7IyMDNN9+MkSNHNlr2oaVOnDiBiooKAFUZtm+88YZb2x07dsz596VLlxpt21SQ0hM1J6B053kHgEGDBjmD2xkZGY22jYmJcWvCw5aoHbyurXY99prB6/oEBQU5/655B0C15rzGarUahw8fdi439BpfunQJK1ascNbIdkd9E6LW1tRzBDR93kRERERE5P9kWYbFYsHkyZORmpqKGTNmwGQyNdher9dj48aNmDRpUp2kG/IfDG4TETWTTqdDUFAQ+vbtixEjRuDmm2+uE2ysGZxTq9VulxHp2rWrM7hdO8A3atQo3HXXXfjkk08AuAbeQ0NDcdVVV2Ho0KG4/vrr69QgbomCggLn36WlpS4TNbqrqRrK3izxUfN5i46Odmubrl271rt9fVqzHEm1pm6nq53l3lR7URSdf9dXS661XuOMjAwsWLDArRraNbmTOeHOLYc1nyfW0CMiIiIi6rjsdjvMZjMmTpyI7OxspKSkYNWqVS6TTMbFxSExMRGzZ892ZmyzJIn/YnCbyAdZJj3vdlmSzqK6LEl7mTVrFubMmePxdjWDc1qt+8VjaratL8C3ePFiDBs2DP/85z9dMsqLioqwc+dO7Ny5E0lJSbjhhhuwcOFCt4O7jWnsire7mvrCoFarW3yMatUZyID7z31Tz3tN3uyrtzRUU9xdrfEaW61W/PnPf3YGtkNCQjB16lQMHz4cPXr0QFBQENRqtbPvmzdvxosvvggATU7qSUREREREVFt1gFulUmHu3LlYtGgRCgsLYTKZoNfrERYWBkmSnO2Yse3fGNwm8kH2uCmw6CIgFJ6AwlIGR2gDE8QJAgIDdQCA8nIz0EHfkBVFp+EwREMO7t7eXfGYTqdz/l0z2NqUmm1r7qOmG264ATfccANyc3Oxf/9+HD58GL/88gtOnz4NoOqWrJ07d2L//v1YvXo1evbs2cyzqFIz8Nu3b198+OGHLdpfa6vZX3efe3ee947M09dYEARnBntJSUm9Xwp37tzprO8dERGBtWvXIjw8vMF9ss4dERERERG1lCzLkCQJAFBZWQmtVgudTgdZlmE0GnlHZwfC4DaRr1IoALUekO2AJqj+NgIgaP93S75dBDpmbBtQB1Y9H36oZukKSZJQUlLiVjmLmpPeNdU+OjoaN998M26++WYAQF5eHjZv3ox//etfsFgsKC0txfLly7Fs2bLmnIJTaGio8+/CwsIW7ast1Hze8vLy3NrGk+e9I2qN17jmxJ533313o4FtAMjNzfXKcYmIiIiIiICq0oRtFcxWKpUQRRGCIECWZdjtdgbSW5l/RouIiPxEZGSkS53tQ4cONblNSUkJzp8/71yOj4/36JhRUVGYNWsWnnzySedjP/74Y51J/DwtYREbGwuVSgUAKC4udumjL4qLi3P+7c7zDsBlYkRPn/eOoDVe4/z8fOff7kz++Msvv7T4mERERERERG1FEARoNBrodDoYDAaYzWbk5eXBbDbDYDBAq9VCo9G0uIwk1Y/BbSKiVjZs2DDn31u2bGmy/ZYtW5y1hiMiItCrV69mHXfs2LHOv202W53J/KqDmNXrm6LRaFzO5d///nez+tVWhg8f7vx7z549KCoqarR9fn4+9uzZU+/2nUVrvMaKGnddWCyWRtseP37cpYY8ERERERGRLxNFETqdDjabDStWrEBcXBwiIiLQu3dvREREIC4uDitXroTNZoNOp4Moiu3d5Q6HwW0iolY2bdo059+7du3C3r17G2ybk5OD999/37k8derUOld3S0pK3DrupUuXnH8rFAp06dLFZb3BYHAGHouLi90KcP/xj390/v3JJ59g3759bvUFaPtSJiNHjkRMTAyAqkkN33zzzQbbyrKMZcuWOZ+D7t27Y8SIEW3RTZ/j7de4+jUAgG+//bbBbS0WC/72t7+5fSwiIiIiIqL2VB3YTk9PR0xMDBYvXoysrCyXNllZWVi8eDFiYmKQnp7OAHcrYHCbiKiVDRs2DKNHj3Yu/+Uvf8GOHTvqtDt+/DgWLFgAo9EIoKq8yPTp0+u0mz17Np599ln88MMPqKysrPeY586dw/PPP+9cHj58OAICAlzaqFQqZ1a4zWbDrl27mjyXoUOHOmt72+12LF68GB988EGDkwBKkoRdu3bh8ccfx+OPP97k/r1JoVBg3rx5zuW0tDS8/PLLdfpaXl6OF154Ad98843zsYceesgl47gzac5rnJ6ejscee6ze17jmHQRffvklPvroI9jtdpc258+fx8MPP4yMjAyXSS2JiIiIiIh8UXUpkrS0NCQkJMBkMjXa3mQyISEhAdu3b2eJEi/jhJJERG3g6aefxoMPPogLFy7AbDbjqaeeQnJyMgYOHIiAgACcPn0aR44cgSxXzQqq1Wrx/PPPw2Aw1NmXzWZDWloa0tLSoFar0bdvX3Tr1g2BgYEoKytDdnY2jh075myvVquxYMGCevt14403Ijk5GQCwdOlSbNmyBd27d4dS+dvHw8MPP+yyzZNPPonCwkL8+OOPqKysxKpVq7B27VoMHDgQUVFRUKlUMBqNuHjxIk6dOuWs9d2vX7+WPYnNMHHiRPzyyy/49NNPAQCpqalIT0/HsGHDEBoaiuLiYvz0008ugdu7774b48aNa/O++hJvvsYjR47EkCFDcODAAciyjLfeegv//ve/ER8fD71ej/Pnz+Pw4cOw2+2IiIjAjBkz8Pbbb7f1KRMRERERETWq5mSRoihCkiTMmDGjTvJOQ+x2O6ZPn47s7GyoVCpIktTKPe4cGNwmImoDYWFheOedd7B06VL89NNPAKqyVeubsK979+54/vnnMWDAgHr3FRgY6PxbkiQcOXIER44cqbdtTEwM/vrXvyI2Nrbe9bNnz0ZaWhpOnToFm82GH374oU6b2sFtlUqFpKQkvPfee/j4449hsVhgsVjw888/13/yqPoScMUVVzS4vjU99thjCA0Nxfvvvw+r1Qqz2VxveQy1Wo37778f9913Xzv00rd4+zV+8cUX8eijjyIjIwMAkJ2djezsbJc2vXv3xssvv9zgWCYiIiIiImprgiBArVZDoVBArVajoKAAJpMJ0dHRWL16dZMZ27WZTCakpKS43GVMLcPgNpGvc9igKDzR4GrZXHULv8Jc0VY9anuOpmtB+4OwsDC8/fbb2LNnD9LT03Hw4EEUFRXBZrMhJCQEcXFxuP766zFlyhSXzOna/vnPf+LXX3/Fzz//jKNHj+LcuXMoKCiAxWKBRqNBaGgo4uLiMHbsWEyYMMFl4sjaDAYDPv30U6xZswbff/89zpw5A6PR2GT9bVEU8cADD+Cuu+7Cl19+if/+9784c+YMSkpKYLPZEBgYiOjoaPTp0wfDhg3DNddcg5CQkGY/dy11//3346abbkJqaip+/PFHZGdnw2g0wmAwICYmBqNGjUJCQgKio6PbrY++xt3XeMCAARg5ciQGDx6M4ODgevcVFhaG1atXIzU1Fdu3b8epU6dgsVgQEhKCnj17YuLEiZgyZQo0Gg2D20RERERE5BNEUYRGo4EkSVi9ejWSk5ORlZWFKVOm4KuvvnLeBe2p5ORkLFq0CFar1a25r6hxglx9DzwRNai4uLjNj6nIPgChogSorL/OLQAIAHT/y+I1l5ejQ/9nDtBB1gbDETOkvXvSYQiC4AxGlpSUgB8H5CmOIWoJjh9qCY4fagmOH/KU4tgxdBkzptE2pd9/D0f//m3UI/JnfA/yD9WTRaalpWHGjBkuGdqPPNeCEpkAADzuSURBVPIIlixZgpiYmGbvv6CgAFqt1qU0Sc2yJ7Isw2631wl+d4Tx4+3EN2ZuE/kqUQVZGwxogxtuIwgQ9FU1mWWl0S/f1DwiNpyBTERERERERETUUrUni6xdU1uv18NoNLboGCaTCTqdrsGyJ3q9HuHh4bBYLJBlGZIkdfyYTzMxuE3koxxRA5tsIwgCFP+7Yufw0yt2RERERERERES+Qq1WNzpZpMlkgsFgaNEx9Ho9BEGATqerU/akWmxsLBITEzFnzhzodDpYLBY4HI4WHbcjUrR3B4iIiIiIiIiIiIh8gUKhaHSyyOPHj6Nr166IjY1t1v7j4uIQFhaGgIAApKenIyYmBosXL3YJbANAVlYWFi9ejJiYGKSnp0On00EUxWYdsyNjcJuIiIiIiIiIiIg6PaVSCbVa3ehkkWlpaTh79iwSExObdYzExERYrVZs27YNCQkJDQbRq5lMJiQkJGD79u1Qq9XNOmZHxuA2ERERERERERERdXqiKKKgoKBOFnVNDocDycnJmDlzJvR6vUf71+v1mD17NmRZbrDsSX3sdjumT5/uMgElVWFwm4iIiIiIiIiIiDo9QRCazKQGgJSUFNjtdnz88cdulwoRRREbN26ERqPBmjVr3DpOTSaTCSkpKbBarR5t19ExuE1ERERERERERESdnizLbmVjFxQU4LbbbsPEiRPx+eefN7mNXq/Hpk2bMHnyZAQEBOCNN95oVv+Sk5OhUqmatW1HxeA2ERERERERERERdXp2ux3h4eFuTRa5d+9ejB8/HqNHj8a5c+eQlJRUZ7u4uDgkJSUhOzsbEyZMQGVlZZNlTxqTmZmJwsLCZm3bUTG4TURERERERERERJ2ezWaDJEluTxa5d+9e9O/fH6+++iqmTZuGzMxMFBQU4MyZMygoKEBGRgbmzZsHURRhNpshy7LH5UhqKy8vb9H2HQ2D20RERERERERERESomjByzpw5bk8WWVBQgFdffRVXXXUVzGYzDAYDIiMjodVqYTQaYTabIUkSZFl2u+xJYwIDA1u0fUfD4DYRERERERERERERAEmSoFarsWHDBo8mi1y/fj2USiXMZjMsFgskSYLNZnNp50nZk/rExcUhLCysWdt2VAxuExEREREREREREaFqUkmLxYLJkycjNTXV7ckiJ02aBIvFAlmWG2zradmT2hITE2G1Wpu1bUfF4DYRERERERERERHR/9jtdpjNZkycOBHZ2dluTRZpNptht9ub3LenZU+q6fV6zJ49GyqVyqPtOjoGt4mIiIiIiIiIiIhqqA5wi6KIuXPnNjlZpDuBbaD5ZU82btwItVrdklPqkBjcJiIiIiIiIiIiIqpFlmVIkoSKigoYjUZotdoGJ4v0ZJ/NLXsiSVJLT6nDYXCbiIiIiIiIiIiIqBHV9bIbmizSE61Z9qSzUbZ3B4iIiIiIiIiIiIg6k+oAt0qlwty5c7Fo0SIUFhbCZDJBr9cjLCwMkiQ528myDEEQ2rvbPofBbSIiIiIiIiIiIqI2Vl32BAAqKyuh1Wqh0+kgyzKMRmOLssM7Cwa3iYiIiIiIiIiIiNqRzWZjMLsZWHObiIiIiIiIiIiIiPwOg9tERERERERERERE5HcY3CYiIiIiIiIiIiIiv8PgNhERERERERERERH5HQa3iYiIiIiIiIiIiMjvMLhNRERERERERERERH6HwW0iIiIiIiIiIiIi8jsMbhMRERERERERERGR32Fwm4iIiIiIiIiIiIj8DoPbREREREREREREROR3GNwmIiIiIiIiIiIiIr/D4DYRERERERERERER+R0Gt4mIiIiIiIiIiIjI7zC4TURERERERERERER+h8FtIiIiIiIiIiIiIvI7DG4TERERERERERERkd9hcJuIiIiIiIiIiIiI/I4gy7Lc3p0gIiIiIiIiIiIiIvIEM7eJiIiIiIiIiIiIyO8wuE1EREREREREREREfofBbSIiIiIiIiIiIiLyOwxuExEREREREREREZHfYXCbiIiIiIiIiIiIiPwOg9tERERERERERERE5HcY3CYiIiIiIiIiIiIiv8PgNhERERERERERERH5HQa3iYiIiIiIiIiIiMjvKNu7A0TkW/Ly8nDo0CHk5eWhoqICUVFR6N27N6688kqvHSMzMxNZWVnIy8uDQqFAdHQ0BgwYgJ49e3rtGJ0Bn0dqic44fux2Ow4cOIDz588jPz8fer0e0dHRGDp0KIKDg9u7e37Fl8ZPdnY2srKycOHCBZhMJiiVSnTp0gV9+vTBwIEDoVKp2rxPnUFJSQn279+P3NxcmEwmREZGonv37hg6dCgUirbPnykvL8dPP/2EvLw8lJSUIDQ0FN26dcOwYcO8Ngba4jtSZ+Er48dkMiErKwunTp1CSUkJKisrERQUhOjoaAwePBihoaFt1hfyjK+MobZ07tw5HD16FLm5uXA4HIiKikJsbCzi4uLau2t+pzOOH+q4rFYrfv75Z1y8eBFFRUUIDg5GdHQ0hg8fDp1O55Vj+Pr/GQa3idpYTk4ODh06hMOHD+PQoUM4cuQITCaTc/38+fOxYMGCNu/XoUOHsHz5cvzwww9wOBx11vfq1Qt//OMf8Yc//AGCIDTrGKmpqUhJSUFGRka964cMGYKHHnoIY8eObdb+OwtfeB7j4+O9sp9//vOfGDlyZL3rfvzxR9x7773N2u/QoUOxbt26lnStw/KF8XPhwgVMmDChWdtGRUVh9+7dHm1jtVrxzjvvYMOGDcjPz6+zPiAgAOPGjcNjjz2GXr16NatfnYUvjJ+Kigrs2rULO3fuxJ49e5CXl9dgW7VajZtvvhn333+/Rz/+P/vsM/z5z39uVv9uu+02vP76683a1h+cOXMGy5Ytw86dO1FZWVlnfWRkJGbMmIEHHnigTS4s5OfnIykpCVu3boXZbK6zPjg4GAkJCVi4cCH0en2zjtEW35E6C18YP4cPH0ZaWhp++OEHHD16tN7XtNqgQYNw33334ZZbbvHotW3J96QjR45AqeTP9Ib4whj64x//iH379jVr27Vr1+Kaa67xaJvdu3dj5cqVOHDgQL3r4+PjMWfOHNx2223N6lNn0t7j58knn8Tnn3/e4v1MmzYNr7zySoPrx48fj4sXLzZr32lpafw+XI/y8nIcPXoUhw4dcsZzaj7H3bp1w9dff92mfTKZTFi+fDlSU1NRUlJSZ71Op8OUKVOwePFihIeHN+sY7f1/xl2CLMtyux2dqJOwWCx45JFH8Ouvv9YbWKmpPYLb7733HpKSkmCz2ZpsO2bMGLzxxhvo0qWL2/uXJAl//vOfsWXLlibbCoKAmTNnYsmSJfyBWIsvPY/eCm5/+umnDWa8MbjtXb40ftoyuH3hwgUsWLAAR48ebbKtTqfDiy++iFtuuaVZfevIfGX8nD59Grfffnu9QczGBAQEYP78+UhMTHSrPYPb9UtNTcXSpUvdev4HDhyIt956C926dWu1/vzwww9YvHgxioqKmmzbs2dPvPXWW+jXr59Hx2jt70idiS+Mn5kzZ+KHH37weLvRo0fj73//OyIjI91qz+B26/CFMQS0XXBblmW88sor+OCDD+BO2ObWW2/F3/72N96x1ABfGD/eCm7//ve/x7PPPtvgega3vWft2rX47LPPcOLEiUYvhrZ1cPvo0aNYsGABLly40GTbsLAwLFu2DKNHj/boGL7wf8Zd/NQkagNWqxU7d+5s727Ua+PGjfj73//u8lj//v0xbNgwaLVanDx5Ert373b+qPv++++xcOFCpKSkuP3F+6mnnnIJiAiCgDFjxiA+Ph6VlZU4fPiwMxNBlmWsWbMGWq0WDz/8sJfOsmPwpedRFEWPt5Fl2eULQbdu3XDFFVe4vb1CoXA7UMYfhXX50viprbVeW6PRiAceeAAnT550PqbVajFu3Dj06NEDJSUl2LNnD86dOwcAMJvNWLJkCUJCQjzOqurofGX8WCyWOl+wRVHEgAEDEB8fj/DwcNjtdpw9exY//PCD886oyspKvPHGGzAajXj88cc9Pq4n73nNeX/0B7t378aTTz4Ju93ufOyyyy7DyJEjERwcjHPnzmHnzp2wWCwAqgJ0iYmJWLduXbMzphtz7NgxPPTQQy7jITIyEtdddx3Cw8ORk5ODnTt3oqysDEDV7fxz5szBp59+iqioKLeO0RbfkToLXxk/9V0IiYmJweDBgxEZGQmdToeCggLs27cPZ86ccbbZs2cP/vSnP+Gjjz5CSEiIR8cUBMGjW7aZ3FE/XxlD9fHkfd+T1/fNN9/E+++/7/LY0KFDceWVV0IURRw/fhx79uxxBr43b96MgICARjN6OytfGT8KhaJZ3xNq9hsAJk+e7Pa2fA9qmf/+97/IzMxs7264yMnJwQMPPOCSONmlSxeMGzcO0dHRyM/Px+7du53rCwsLMW/ePKxfv97ti6++8n/GXfzWRdSOunbtiqioKPzyyy/tcvzjx4/j+eefdy6rVCq8/PLLdW5pO3/+PObNm+d8U9+zZw/eeustLFq0qMljfPzxx9i0aZNzuWvXrli1ahX69+/v0q76B6HRaAQArFy5EkOHDsW1117b7PPrSHzteXQnC7a2F198Ef/617+cy1OnTvXoy9P777/fYAkTapyvjZ/aXnrpJdx+++1e3+8zzzzjEtgeOXIk3nzzTZcaqna7He+//z5ee+01yLIMm82GhQsXYtu2bay1+j++On4GDx6M6dOn48Ybb6z3S7TRaMQbb7yBjz76yPlYSkoKhg8fjnHjxnl0rLS0NHTv3r3FffZX+fn5ePTRR50/cARBwBNPPIH77rvP5QdzUVERFi5c6MxozMzMxNKlS7Fs2TKv9keSpDqB7fvvvx+LFi1yyVg0mUx45pln8OWXXwIALl26hEceecStO3va4jtSZ+Fr4wcAwsPDcfvtt+P2229H796966yXZRnbtm3Ds88+i9LSUgDAyZMnsXTpUvzjH//w6FgPPfRQu5Qc7Eh8cQxVu/rqq12+33rLrl27kJyc7FwOCgrCP/7xjzqZl0ePHsXcuXORm5sLAPj8888xdOhQTJ8+3et98le+NH5efvllvPzyyx5tc/ToUUybNs253K1bN49+E02dOpUXPLxMp9Nh4MCBOHLkiMd3E7aULMtYuHChS2D71ltvxfPPP4/AwEDnY1arFcuWLXNeIDObzXjooYfw5ZdfNnl3hy/9n3FX+1f9JuokQkNDcf3112P+/PlITk7G999/j2+++QaPPvpou/XpzTffdKmb9MILL9Rbq61Hjx744IMPEBYW5nzsgw8+aLLESkVFBVasWOFcVqvVWLt2bZ2ACFB1K+/KlSudwU5ZlpGUlOTxOXVEHeF5rKysxObNm53LgiC4fEmj1tMRxk9z/Prrr/jqq6+cy3379kVKSkqdgLUoipg1axbmz5/vfKysrAzvvPNOm/XVl/ni+BkyZAg+/PBDbNiwAXfccUeD2SEGgwHPPvssHnjgAZfHO2rJkNaUnJzsvGgBAAsWLMDMmTPrZIKFhoYiJSUFffr0cT62ZcsWHD9+3Kv9+eijj1xut77jjjvwxBNP1Pmxptfr69yGu3//fuzYsaPJY7T2d6TOxJfGT2hoKJ588kns3LkTixcvrjewDVR9T5kyZQrWrl0LrVbrfHzbtm04dOiQ1/pD7vGlMdQWZFl2CQ4JgoCVK1fWW1JgwIABeP/996FWq52PvfXWW5AkqU366g/8ffx89tlnLsueJghRy6jVagwaNAi///3v8corr2Dz5s34+eef8eGHH3p8J483pKWl4eDBg87la665Bq+//rpLYBuouij/5z//2SWB6Pz581i/fn2Tx/DH/zMMbhO1gaCgIOzZswfvvvsuFixYgHHjxjW7oL+3HDt2zKVUyogRIzB16tQG24eGhroE4isqKrBmzZpGj7Fx40YUFBQ4l2fPnt3gjwigKvMhISHBuXzkyBGfLefSljrC87hr1y4UFxc7l4cPH44ePXq0Y486j44wfppj1apVLsvPPPNMo1kKDz74IHr27OlcXrdunVt1fDs6Xxs/sbGxWL9+PUaMGOH2Ng8//LBL1vWJEydcMvqpcYWFhdi4caNzuWfPnnUuGNSkVqvxzDPPOJdlWcbKlSu91p/KykqsXr3auWwwGPDEE0802F6hUOC5555z+UFW84JNfdriO1Jn4WvjZ/Xq1Zg5c6bbNYkHDhyI++67z+Wxbdu2ea0/1DRfG0NtYceOHS4TN//f//1fo597vXv3xqxZs5zLly5dwieffNKqffQX/j5+mCDU/t544w188sknePbZZzFt2jTExsZ6VObF22r+xlEoFPjrX//a6MWOJ5980iUR5N133210HhF//T/D4DZRJ7V161aX5XvuuafJbW677TYEBQU5l5v6cl8za1IURcyYMaPJY9TuR+1+dkYd4XmsPXEKv5S1nY4wfjxVXl7uMulknz59MGrUqEa3CQgIwF133eVcliTJL4P63uZr46c5dYwDAgLq1KZk5qX7duzYAavV6lyePn06AgICGt1m9OjRLhdBdu3ahYqKCq/0Z9++fS4Xnm699dYmJ3Ds1auXSx39I0eO4Pz58w22b4vvSJ2Fr42f5ryH1J5kmO8fbcvXxlBbqPnZC1RNHtiUu+++26WWs799d2st/j5+mCBENZ09exbHjh1zLl977bVNTv7ZpUsXl8+x/Px8/PTTTw2299f/MwxuE3VSNWfyDQgIwIQJE5rcRq1W44YbbnAuX7x40eXNtaaioiKX22WGDBni1gROgwcPRnR0tHP5m2++qTOBRmfSEZ7HoqIi7Nq1y7ms0+kwZcqUdulLZ9MRxk9zfPfddy5fym688Ua3tqs9Lt0pXdCRdaTxUzMrH4BLNjo1rub3BaDu/5OG1GxnsVjw/ffft0p/WuP/d2t/R+pMfG38NEftwEFhYWE79aRz6ghjyBM2mw3ffvutc7lr164YNGhQk9tFRUVh8ODBzuX9+/e7BEU7K38fP0wQoppqf3dx9zvQTTfd1Oh+avLX/zMMbhN1QmVlZS4z/g4YMMClTltjan5pAqpmD67P/v374XA4nMtDhgxxu381j1FSUoKsrCy3t+1oOsLzuHnzZpe6pZMmTapTE4xaR0cYP81ROxvB3fPu2bOnS93cxrIaOoOONH7Ky8tdlpvKQKHf1Px/EB4e7nbGWO3x0tD3hZb0RxRFt4I+9fWnof/fbfEdqTPxtfHTHLXfP5qT/U3N1xHGkCeysrKck5gCzf/stdvt2L9/vze75pf8efzUThDSarVuBzOpY2rub5wrr7zS5c6Oxn7j+Ov/GQa3iTqh2rVG65sYrCEDBw5sdF8NPT5gwIBmH+PUqVNub9vRdITn8YsvvnBZZsZB2+kI46c5avfVk/Ou+X5YWlraqTN8O9L4qVm7FIBbGehUVbe15oRCnnxfqD1evFHn3OFw4MyZM87lXr16uX2xtE+fPtBoNE32py2+I3UWvjZ+mqv2+0fNO1OodXWUMeQJvgd5j7+Pny1btrgkCE2ePLnBSbSpc6g5DjUaDS6//HK3ttPr9S53MZ4+fRqyLNdp58//Z3jZmagTqh1kiImJcXvbrl27Nrqvhh6vvZ03jtEZ+PvzmJGRgSNHjjiXu3Xr1mTt44Zs2LABb7/9Ns6ePYvS0lLodDqEhISgf//+GDFiBG6++WaXeqfkP+Nn27Zt+PLLL3Hy5EkUFxdDrVYjODgYsbGxGDFiBG666SZERka6vb+afVWpVC7Z2E2p/X546tSpdp8AuL34y/hpitlsRnp6unNZoVBg5MiRHu1j1apVOHnyJC5cuACj0QiDwYCQkBBcccUVGDlyJKZMmeISOO0oWvJ9ITw8HAEBAc4f5t4YAxcvXoTFYmlWfwRBQHR0tDM4fv78edhstjpZuG3xHamz8LXx01ypqakuy55+j/nxxx9x7NgxZGRkoKioCEqlEiEhIejVqxdGjBiBKVOm1CmdRFX8YQxlZ2fjiSeewOHDh5Gfnw+bzYaQkBBERUVh+PDhuOGGGzBs2DC39+fN96DTp0+7vW1H5A/jpzHeKkly/PhxLFq0CEeOHHGWVQoODkb37t0xYsQITJw4Ef369Wtxf6l1VVZW4sKFC87l6OjoRieSrC0mJsb5nlBRUYHs7Gx069bNpY0//59hcJuoE8rLy3NZ9iSDLSIiAqIoOuun1t5XQ8fwJMuldtvc3Fy3t+1o/P15rJ21/X//938efQjXtGXLFpdli8WCoqIinDx5Eps3b8Zrr72Ge++9F/PmzWPJgf/xl/HzzTffuCxXVFSgpKQEZ86cwfbt2/H666/jzjvvxGOPPeZWlmbN846KivJozNV+P+T7z298dfw0Zc2aNTCbzc7lq6++GqGhoR7t49NPP3VZtlgsyM/PR2ZmJj777DP8/e9/x4MPPoh777232e9xvqgl3xcEQUBUVJTzh1hD3xfaqj/V7auD25WVlSgsLKyzj7b4jtRZ+Nr4aY4zZ85g06ZNzmVRFOtMUNuU+m7NLisrw9mzZ7F79268+eabuOmmm/CXv/zFo4uxnYE/jKELFy64BJyAqouqFy9exP79+/Huu+9iyJAheOqpp3DllVc2ub+O8tnrC/xh/DQkMzPTawlCx44dqzMHhMlkwoULF7B371689dZbuO666/D00083OTkhtZ/CwkLYbDbnsqd3EdX3G6d2cNuf/8+wLAlRJ1S7dqAntzcpFApotVrncs2AQWPH8KTGcu22DR2jM/Dn59Fut7v8IBQEoVVLkphMJqxcuRJ//OMfUVRU1GrH8Sf+PH5qslqt+Pjjj3HnnXfi7Nmzjba1WCwukxd6Wt+99vsh339+44/jJzMzE++8847LY/Pnz/f6cQoLC/Hyyy9j7ty5bT47fGtqyRio3d5ms7lM9Nre/alvf/U91hrfkToLXxs/nnI4HHj66addygJMnToV3bt39+px7HY7Nm/ejKlTp+LQoUNe3be/8/cxVO3AgQP43e9+h08++aTJth3hs9dX+PP4qZ213ZIEIXfs3r0bd9xxR52EE/Id3v4OVN/7gz//n2HmNlEnVPuHt0ql8mh7tVoNk8kEoP4fhvUdw93JmOpr25m/mPnz8/jtt98iPz/fuTxs2LBm3XY7ZMgQjB8/HoMHD8bll1+OoKAgVFZWIj8/H/v378cnn3ziMmHOgQMHMG/ePHzwwQcePV8dka+Pn/j4eEycOBHDhg1D3759ERwcDFmWUVBQgIMHD+KLL77A7t27ne1PnTqFOXPmYMOGDQgJCal3n7X76ekYqP1+yPef3/ja+GlKeXk5Fi1a5PLFetq0aRgxYoRb2ysUCowaNQo33HADBg0ahF69esFgMECSJOTm5mLfvn1Yt26dy+SDO3fuxBNPPIHly5d3iAzuloyB+tqXl5d7/J2jNftT37hsi+9InYWvjR9PvfXWWy5Z16GhoXjsscfc3r5Xr16YMGECRo0ahb59+yI0NBSiKKKoqAi//vorvvzyS2zdutV5QfbSpUt44IEHsHHjRpYp+R9fHkPBwcEYP348xo4di/j4eERFRUGj0aCsrAxZWVn45ptvsHHjRuf7QWVlJZ599lmEhIRg4sSJDe63Je9BvvDZ60t8efw0xlsJQlFRUZgwYQKuueYaxMfHIywsDCqVCiUlJTh27BjS09Px+eefO78nGY1GPPzww/jXv/6Fq666ymvnQ97R0t84zfkO5C//ZwAGt4k6pZr1KgHPf7jVbC9JktePUbtt7X11Jv78PLa0Ttxll12GzZs3IzY2ts46lUqFwMBAXHbZZbj99tvx+eefY+nSpc7xeODAAaxcuRKLFi1q/gl0AL46foKDg7F+/foGZ/ju3r07unfvjltuuQW7du3C448/jtLSUgDA2bNn8eKLL2LZsmX1blv7Pakl728A339q8pXx4w6Hw4HHH38cJ06ccD7Wo0cPPPXUU25tP3jwYGzfvr3eDM2AgAD07dsXffv2xe9+9zusXr0aSUlJzol5tm3bhk8++QTTp0/3zsm0I29+XwAa/s7QXv2pb1y2xXekzsLXxo8ntm3bhlWrVjmXBUHASy+95HZJo/feew9jxoyp9yJXdHQ0oqOjMXHiRPzpT3/Cww8/jJycHABAcXExlixZgvXr13vnRPycr46hhx9+GIMGDao38BMaGoqRI0di5MiRmDVrFhYtWoR9+/YBqPpseuKJJ5Cent7gRXp//uz1Nb46fpry3XfftThB6KWXXsKIESPqzCsBVJXQioiIwHXXXYdZs2Zh/vz5zgv1kiRh0aJF2Lp1a5teTKSmtcVvHH/9PwMwuE2dyPjx43Hx4sVW2/+SJUswa9asVtu/N9X+Ilbzdkt31MyCa+hqXn3HcPfNsfbtK76Qfdte48dfn8fS0lJ8/fXXzmWtVospU6Z4tI+oqCi363xNmzYNKpUKjz76qPOxf/7zn7jvvvs8rq3bGjh+XOn1+gYD27Vdf/31WLlyJe677z5nnbktW7bgwQcfRFxcXJ323nx/q29/7YHjx3MvvfQSduzY4Vw2GAxYsWIFDAaDW9u7O/u8IAh44IEHAMDlgsuKFSswdepUv/9h6O3/Ty19Ptri/3dbfEfqLHxt/Ljrp59+wuOPP+68YAVUlTMaP3682/u49tpr3Wo3aNAgrFmzBtOnT4fRaARQdYF+165duP766z3reAfkq2PI3TuAwsPD8e677+Kee+7B0aNHAVSV0Vu9ejWWLFlS7zYtOef2/uz1Nb46fv6/vTuPjqo84zj+ywZJhCSahSWkEUQimwLmIIoWBRS3YlxbxAVKWMUlkFMRleWgDYLCwVA8YMVUq6gglaKiVbF6EGzZxIpABTRhSQJIAgkGCMn0D05ucyczkxmSmdyb+X7O4RzemzvzvjPz3DvvPPe971ufxlhI8sorr/Rqv9TUVOXl5emuu+7SwYMHJZ1dvHn58uUaPny4z/XCf5zjz+p9IClwx4zEnNtAUIqOjjaVfb2iVnt/5+dyt92XkQPO7XFXRzCw6/v4wQcfmL7cbrjhBp/mLT0Xt9xyi+nH5C+//GJKsAcju8aPs/T0dN15551G2eFwaM2aNS73bchrlup2yjj//J9d4mfhwoX661//apRbtmypRYsWKS0tzW91ZmZmqnPnzka5qKhImzdv9lt9gdLQ48k5Dnydu9Hf7XEVl4HoIwULq8WPN3bu3Knx48eb6h42bJhf5uqv0alTJ+MiWQ3nRbSDlR1jyFlUVJSmT59u2vbhhx+63b8h5yAr9d2swI7xc/z4cdPF+XMZIOSr+Pj4OlMueYpRNA3n+AtEH8gOx0wNkttAEHI+afkyJ2R1dbXpJOdtctuXOd+c2xPMHTO7vo/vvfeeqezPhSRru+uuu0zlDRs2BKReq7Jr/Lji7WcbGRmpsLAwo+zrfJM1c2PWaOrX3ZTsGD9vvPGGcnNzjXJ4eLjmz5+vvn37+rXe0NDQOue5r7/+2q91BkJDYkAyx0F4eHiDRxE2dLE0bxZKCkQfKVhYLX7qU1BQoMzMTB0/ftzYdvPNN2vatGl+rVeS7rzzTtMUJsHef6lhtxhyp1evXqYLoIWFhfrpp59c7tuQc5DV+m5NzY7x0xQDhCRpyJAhpnq++eabZrVAdnPQmPHs6vkau45An3OZlgRBY8GCBX6d8yclJcVvz93YnKd6KCoq8vqxhw8fNqYGkM7OG+hNHYWFhW73debcHm8f509NFT92fB/37t2rbdu2GeXk5GT169cvIHU7T3VRc3tdUyN+Gq5Hjx6KiIgwbo/z9NkmJSUZ85cWFxfL4XB4vbhfcXGxqdzUr1sifry1atUqzZo1yyjXzJE7aNAgv9ctnU1e1ObPqWQCpSH9BYfDYTqevJ1myl/tkczHd3h4uOLj4xu1Dm/7SMHCavHjSXFxsUaMGGGa5/aaa67RnDlzFBrq//Fg8fHxSklJUUFBgaSzi0tWVlYqIiLC73VbmZ1iqD69evUyrQNx8OBBXXjhhXX2a8hrtlrfranZMX6aaoBQeHi4evbsaVxYO3PmjA4dOqTU1NSA1I/6xcfHKzw83Ohn1PzW8ZY3v3HseMzUILmNoNGzZ8+mboJlOM8l6ksC0Pkk2rFjR6/qKCws9HqOXec6vJ371J+aKn7s+D46zxM3dOhQrxOLDeU8v3ZJSUlA6q0P8dNwoaGhiouLMxIPnj7bTp06Ge0/deqUfv75ZyUkJHhVj/P5sKlft0T8eOOzzz7T1KlTTXPkPvXUU8rIyPBrvbU5J0qtcv5piIb0F44cOWKaq9Fdf8EXycnJatmypXGxx5f2OBwO04+0lJQUl4nDQPSRgoXV4sedo0ePauTIkaYLUunp6Vq4cGFAk8vx8fFGcluSSktLlZiYGLD6rcguMeQNb78jGvMcZIU+TFOyW/zs3btX33zzjVFu3759wAYISa5jlOS2dbRo0UIdOnQw7vooKiryaQBP7fiPjIxUcnJynX3sdszUxrQkQBC66KKLTOUdO3Z4/djt27d7fC5322sWUWnMOoKB3d7H6upq/f3vfzdtu+OOO/xebw3necGCfSEdu8VPfWp/vp4+W+eOmS+vu/b5MCYmJqgTC3aJnw0bNuixxx4zjZjNysrSfffd57c6XWmO5582bdqYFuH0pb/gHC+NEQOhoaGmkY75+fle3zK7Z88e02fkbf/FH32kYGG1+HGlvLxcmZmZ2rNnj7Gte/fuWrx4sSIjI/1SpzvOUwA0h3NIQ9khhrzl7efbmOegYE9u2y1+nEdt33bbbQEbICRxDrKD2sf0yZMntXfvXq8eV15ebrp42rFjR5exZbdjpjaS20AQio2N1cUXX2yUv//+e69ved+6daup7G618D59+phu43R+nCe1r1jHxcWZ5qgLNnZ7Hzds2GAaGXf55ZfrV7/6ld/rrbFv3z5T2dUt58HEbvHjSUlJicrKyoyyp882PT3dVPb2defn5+vnn392+zzBxg7xs23bNk2YMME0P+Xo0aM1btw4v9TnSXM9/1x++eXG/48cOVLndbqzZcsWU9ldf8FXtY/Lqqoq0zRYnnjbfwlEHymYWC1+ajt58qTGjh1rSghefPHFeuWVVwIyx21t1dXVphFyERERiomJCWgbrMrKMeQL53Y7321Yo0uXLqbP3pfv3tr7hoWFqU+fPj62svmxS/xUV1dr1apVpm2BHCAkeR+jaDrn+hvn22+/VVVVldvnqc0ux4wzkttAkBo4cKDx/8rKStOqzO6cOnVKX3zxhVFu3769unXr5nLf+Ph4XXbZZUZ569atdeZ5cmXr1q2m5OiAAQMUHh68MyjZ7X1cuXKlqRyoeeJq1I5PSbrkkksCWr/V2C1+PPnyyy9NZU+f7dVXX226lfyjjz7yqg7n/QI1V7NVWT1+du3apdGjR5tG7g4fPlzZ2dmNXpc3muv5p3Z/QZLWrFnj1eM+/vhj4/8tW7ZU//79/dIefxzf/u4jBROrxU+NyspKPfLII9q0aZOxLTU1VUuXLtX555/fqHV5Y8uWLaaFLJvL+aMxWDWGfFFRUaGNGzca5fDwcHXp0sXlvuHh4fr1r39tlAsLC726iFdcXGy6sNy7d2+Sk7JP/DT1AKHCwkL98MMPRjk+Pl5JSUkBqx/eCXQfSLLuMeOM5DYQpG688UZT+c0336z3MatXrzZ1vIcMGeJ1HVVVVXr77bfrrWPZsmUe2xmM7PI+lpeX69NPPzXKUVFRuummm/xeb42ysjK9/vrrpm3XXHNNwOq3KrvEjyeVlZV6+eWXTduuvvpqt/u3atXK9Nnv3btXX3/9db11rFixwii3aNGiTucuGFk1fgoKCjRq1CgdO3bM2Hb77bfr6aefbvS6vLFv3746UzI1l/PPoEGDTBeLli9fbppT0ZUNGzboxx9/NMoDBgxQdHR0o7Snb9++puTjBx98YOqbuJKfn6/169cb5e7du3tcCDwQfaRgYbX4kc6OkHz88cdNFyPatWunV199tcmSOS+99JKp7Ok7LthYMYZ89Ze//EXl5eVG+bLLLvN4d8C5nIPeeustVVdXu32OYGWX+HFesyjQA4QWLVpkWrekf//+AZ0SBd7p2LGj0tLSjPJXX32l/Px8j485duyYPvzwQ6OckJDgcVS1XY4ZZyS3gWZi5cqVSktLM/5NmTLF4/7dunXTgAEDjPLGjRvrzPNV29GjRzVv3jyjHBkZqd///vce67jnnntMt2X/+c9/Np30nP373/82JQe6deum6667zmMdwSAQ72Nubq4pfnJzc31u55o1a0zzmV5//fXnfFtvQUFBnXnfPDl16pQee+wxHT161Nh2ySWXBHQRFquyWvwUFxertLTU6/ZXV1dr2rRpptEkiYmJuuWWWzw+bvz48abyrFmzTFNXOFu8eLFpLrrf/e53jHiS9eJHOhtDI0eONBYXlc7+iH/22Wcb5YfYnj176u3E13bs2DFNnDjRFF/XXXddQEdc+VNCQoLuvvtuo1xQUKAlS5a43f/UqVN65plnjHJISEid47G2/fv3mz7/+i4qtWjRQpmZmUa5rKxMs2fPdrt/dXW1pk+fbkr6TJgwwWMdgegjBQurxY8kzZgxQx988IGpjXl5eS4X1/JVaWmpV3e41Pbiiy9q3bp1RjkyMlLDhg1rcFuaC6vF0K5du3xovbRu3TotXLjQtG3EiBEeHzNo0CDTyO5Vq1aZRn47+/HHH/XKK68Y5cTERNN7FsysFj+uNOYAodOnT3s9D3ONFStW6J133jHKISEhevDBB8+pfviudvzUTly7Uzseq6urNWPGDNOFCWezZ882Te04evRoj3dU+vuY8ReS20AQy8rKMp3Ynn76ab3//vt19tu3b58efPBB01y0DzzwQL2jW6Kjo00/IE+dOqWRI0e6XJjgq6++0oQJE0wn5qysLK4Yyz7vo/OIg4bME7d27VoNGjRICxcu9JhIk84mHX7729+afhiGhoZqypQpxI+sFz//+c9/NHDgQD333HP1LlC4Y8cOjRgxos50N5MmTap3NMCll15qGjm5e/duZWZmmi6ASGc7hUuXLjX98GzdurXGjh3r7Utq1qwWP6WlpRo1apT2799vbLv22mv1/PPPKywsrFHqeOuttzRkyBAtXbrUdIuwM4fDobVr1+r222/Xzp07je1RUVFNNjWKv4wbN07nnXeeUc7NzVVeXp4pYSydTfJmZmZq9+7dxrabb7650afnuO+++9SuXTuj/O677+q5556rcwGrvLxckydP1oYNG4xtvXv31uDBg+utw999pGBipfiZN2+e6Q6UuLg4vfrqq6aFShuisLBQgwcP1rRp07R582aPCYeCggI9+uij+tOf/mTanpmZqTZt2jRKe5oLK8XQfffdpzFjxuiTTz7xOB//8ePH9eKLL2rs2LGmC6Z9+/bVDTfc4LGO0NBQTZo0ySg7HA5NmDDBdC6r8f3332vEiBGmtkycODHgC6JamZXix5U1a9aYBvU0ZIDQyZMndeutt2rSpElat26dabFtZ4cPH9bMmTP15JNPmrZnZGSoR48e51Q//O/GG29Uz549jfL69euVnZ2tEydOmPY7ffq0cnJyTL+jkpOTvbp4avVjxpUQh6dvXACNZuHChVq0aFGd7Q6Hw3SSCAkJMS3gVSM5OVmffPKJ2+dfuXKlnnjiCaN8++23exzJVGPZsmWaMWOGaVvXrl2Vnp6uyMhI7dmzR19++aXpi7Fv375aunSp6XYVTyZNmmQaIRMSEqL+/fsrLS1NZ86c0bfffltnMYRx48YpKyvLq+cPFv58H3Nzc03JvYkTJ+rhhx/2um0FBQW6/vrrjXL79u21du3ac05q5eXlKScnxygnJyera9euateunWJiYnTmzBkdPnxYW7Zs0U8//VTn8dOmTdPw4cPPqe7myirx8+mnn+qhhx4yyomJierWrZtSUlLUunVrORwO/fzzz9q2bZv++9//1nn8qFGj9Ic//KHeNklnf1jec889pgskUVFRGjhwoFJSUlRSUqINGzaYRmyHhYVp8eLFzWZKicZilfj529/+VufOpHNJamdkZOiPf/yjy789++yzeu211ySdfZ2pqanq2rWrkpKS1Lp1a508eVJFRUXavHmzCgsL67QlNze3Wc7X/s9//lPjx4839VkuvPBC9evXT3FxccrPz9fnn39uuoOnc+fOevvttz3+SN+/f7/p/UpOTtbatWvrbc/27ds1fPhwU0IgKSlJAwYMUHx8vIqKirR27VrTVCGJiYlasWKF2rZt69VrDkQfKVhYJX6cR8W563fXx93F2R07digjI8Mox8XFqVu3brrwwgsVExOj0NBQlZSU6LvvvtP27dvrJApuuukmzZ8/n4vzLlglhtLT041RkFFRUUpLS1Pnzp0VFxenyMhIHT9+XHv27NGWLVvq3IXYsWNHvfXWW4qLi/PqNT///PN1pmW7/PLL1bNnT4WGhmrXrl1av3696SLK0KFDNXfuXK+eP5hYJX5cGT58uGn+/7y8PF155ZU+PUeN48ePm6acaNWqlbp27apOnTopNjZWEREROnbsmHbu3Klt27bVuVMtPT1dr776qlq0aHFO9TdHBw4cMP3Ora32Io2S+z5pXl6e+vbt6/Jvzt9L3twdcuDAAd19992mC+uxsbEaOHCg2rRpoyNHjuiLL74w3eUYHR2tZcuWeb2mg7+OGX8J3lXagABzOBx1Tn6+7OfNY8/FsGHDVFZWpgULFhg/znbs2OFyVJ4k9evXTwsWLPDpR1tOTo6qqqqMhQwcDofWrVtnGmlbIyQkRA888IAee+wx319MM2fl99H5du3bbrutUX+YHThwQAcOHKh3v7i4OD3zzDNuOyDBzKrxc/jw4ToL8bkSGRmpKVOm+HSrdkxMjF5++WVNnDjRGFlbUVFhStLWFh0drZkzZ5LYdsEq8eNqTMa5fD86J5Q81ffTTz+5vIjmrH379po7d67HFejt7Nprr1VOTo5mzJhhJGw8vTddu3bVwoUL/fYDp3v37srNzVV2drYx1dGhQ4e0fPlyl/t36NBBubm5Xie2pcD0kYKF1eKnhrf983NVWlqq9evXm+Z8dyUsLEwTJkzQ+PHjSWy7YcUYqqio0DfffGNayNGdIUOGaNasWYqNjfX6+SdNmqSTJ0+a1pTZvHmzNm/e7HL/m2++2TQ9AP7PivEjnb37p/bn2b59+0adVrG8vFwbN270OK1NjXvvvVePP/44iW0nvnxPuNuvsccUJycna8mSJXrkkUeM38jHjh2rcyd1jfPPP18vvPCCT4sVW/WYcYdpSQBozJgxevPNN3XVVVe5Hb2SkpKiqVOnKi8vz+vRBjVatmypBQsW6LnnnnO7Mrgk9erVS0uWLNHUqVPp2Ltg1ffR4XDUSW43dBGUK664QnfeeafXc9Z26NBBkyZN0kcffURi2w2rxE9aWpruvfdede7c2avRcomJiRozZow+/vjjc5qDNCUlRcuXL9eECROUmJjocp+IiAhdf/31WrlypYYOHepzHcHAKvETCIMHD9att97qdRK0S5cuxpQVzTWxXSMjI0MrV67U4MGD3SZwExMT9dBDD+mdd95Rhw4d/Nqea665RqtXr1ZGRoaioqJc7hMbG6v7779fq1atOqfbZP3dRwomVosff2jbtq1Gjhyp7t27e5zTtEZsbKzuvfdevf/++5o4cWKjTa/UXFkhhsaOHat+/fp5tVhaixYtNGjQIOXl5enFF1/0KbEtnZ2e5KmnntKSJUvUq1cvt/t16dJFc+bM0fz589WyZUuf6ggmVogfZ++9954p8dnQAUKRkZEaN26cevfu7VWSOjo6WkOHDtWKFSs0ffp0prOxkR49emjVqlW6//773Z5boqKilJGRodWrV6t///4+12HFY8YdpiUBYFJcXKxt27apuLhYJ0+eVFJSkjp27KhLL7200erYtWuXfvjhBxUXFyssLExJSUnq3r27UlNTG62OYBAs72NZWZl++OEHHTx4UEeOHFFFRYXCwsIUExOjhIQE9ezZk7kpz4EV4ueXX37R7t27tX//fh05ckS//PKLQkJC1Lp1a11wwQXq3r27UlJSGq2+qqoqbdmyRfv27dORI0d03nnnqW3bturTp4/OP//8RqsnGFghfgLh6NGj2r17tw4ePKiSkhJVVFQoIiJCsbGxSkpK0qWXXhq0C4+WlJRoy5YtKioq0okTJ5SQkKCUlBT16dOnSRJ0J06c0KZNm1RYWKhjx47pggsuUHJystLT0xttFFog+kjBwmrx4w+nT582vuMOHTqkEydOqLq6WjExMYqLi1NaWpouuugi214IbGpNHUPV1dXKz89Xfn6+ioqKVFZWpsrKSkVHRys2NlYdO3ZUt27dGnUUbH5+vrZv365Dhw6pqqpKbdq00cUXX+zVInQwa+r4CYQzZ87oxx9/VEFBgfE6z5w5o9atWysmJsaInebyeoPZ6dOntWnTJh04cEBHjx5VbGys2rVrp/T0dNPc2Q1h9WOG5DYAAAAAAAAAwHaYlgQAAAAAAAAAYDsktwEAAAAAAAAAtkNyGwAAAAAAAABgOyS3AQAAAAAAAAC2Q3IbAAAAAAAAAGA7JLcBAAAAAAAAALZDchsAAAAAAAAAYDsktwEAAAAAAAAAtkNyGwAAAAAAAABgOyS3AQAAAAAAAAC2Q3IbAAAAAAAAAGA7JLcBAAAAAAAAALZDchsAAAAAAAAAYDsktwEAAAAAAAAAtkNyGwAAAAAAAABgOyS3AQAAAAAAAAC2Q3IbAAAAAAAAAGA7JLcBAAAAAAAAALZDchsAAAAAAAAAYDsktwEAAAAAAAAAtkNyGwAAAAAAAABgOyS3AQAAAAAAAAC2Q3IbAAAAAAAAAGA7JLcBAAAAAAAAALZDchsAAAAAAAAAYDsktwEAAAAAAAAAtkNyGwAAAAAAAABgOyS3AQAAAFjaww8/rLS0NOPfqFGj5HA4vHpsWVmZBg0aZHr84sWL/dxiAAAABALJbQAAAACW9swzzyg5Odkor1u3Ti+//LJXj33yySe1f/9+o3zVVVdpzJgxjd5GAAAABB7JbQAAAACWFhsbqxdeeEHh4eHGtgULFmjr1q0eH7ds2TJ9/PHHRjkhIUFz585VSEiI39oKAACAwCG5DQAAAMDyevfurUcffdQonzlzRpMnT9bx48dd7r9r1y7l5OQY5ZCQEM2ZM0cJCQl+bysAAAACg+Q2AAAAAFsYPXq0rr76aqN84MABPfnkk3X2q6ioUFZWlk6dOmV6bP/+/QPSTgAAAAQGyW0AAAAAtlAz+joxMdHY9o9//ENvvPGGab9Zs2Zpz549Rtl51DcAAACaB5LbAAAAAGwjPj5ec+fOVWjo/3/KzJ49Wzt37pQkrV69Wu+++67xt5iYmDrzdQMAAKB5ILkNAAAAwFauvPJKjR071iifPn1ajz76qHbs2KHp06eb9n322WeVnJwc6CYCAAAgAEIcDoejqRsBAAAAAL6oqqrS/fffr82bNxvbIiIiVFlZaZSHDRumGTNmNEHrAAAAEAgktwEAAADYUlFRkW677TaVlpbW+VtaWpqWL1+uli1bBr5hAAAACAimJQEAAABgS23btlVOTk6d7dHR0Zo/fz6JbQAAgGaO5DYAAAAA26qoqKizrX379kpJSWmC1gAAACCQSG4DAAAAsKWCggJNmzatzvbdu3drzpw5TdAiAAAABBLJbQAAAAC2U1lZqaysLJWXl7v8++uvv67PPvsswK0CAABAIJHcBgAAAGA7L7zwgr777jujfMkll2jGjBmmfaZOnaqioqIAtwwAAACBQnIbAAAAgK188cUXysvLM8o1C0gOGzZMt956q7G9tLRU2dnZqqqqaoJWAgAAwN9IbgMAAACwjUOHDmnKlClyOBzGtqefflqdOnWSJM2cOVOpqanG3zZu3KhFixYFvJ0AAADwP5LbAAAAAGyhurpa2dnZOnr0qLHtN7/5je644w6j3KpVK82bN08RERHGtpdeekkbN24MaFsBAADgfyS3AQAAANjCokWL9K9//csop6am1plnW5J69Oih7Oxso1xVVaXJkyerpKQkEM0EAABAgJDcBgAAAGB5mzZtMk0vEhERoXnz5qlVq1Yu93/wwQc1YMAAo1xcXKwnnnjC7+0EAABA4JDcBgAAAGBppaWlmjx5smlhyOzsbPXo0cPtY0JCQjR79mwlJSUZ2z7//HO99tprfm0rAAAAAofkNgAAAABLe+KJJ1RUVGSUr732Wo0YMaLex11wwQV6/vnnFRr6/589c+fO1ffff++PZgIAACDASG4DAAAAsKzXXntNa9euNcpJSUnKycnx+vFXXHGFxo0bZ5RPnz6trKwsnThxolHbCQAAgMALcTgcjqZuBAAAAAAAAAAAvmDkNgAAAAAAAADAdkhuAwAAAAAAAABsh+Q2AAAAAAAAAMB2SG4DAAAAAAAAAGyH5DYAAAAAAAAAwHZIbgMAAAAAAAAAbIfkNgAAAAAAAADAdkhuAwAAAAAAAABsh+Q2AAAAAAAAAMB2SG4DAAAAAAAAAGyH5DYAAAAAAAAAwHZIbgMAAAAAAAAAbIfkNgAAAAAAAADAdkhuAwAAAAAAAABsh+Q2AAAAAAAAAMB2SG4DAAAAAAAAAGyH5DYAAAAAAAAAwHZIbgMAAAAAAAAAbIfkNgAAAAAAAADAdkhuAwAAAAAAAABsh+Q2AAAAAAAAAMB2SG4DAAAAAAAAAGyH5DYAAAAAAAAAwHZIbgMAAAAAAAAAbIfkNgAAAAAAAADAdkhuAwAAAAAAAABsh+Q2AAAAAAAAAMB2SG4DAAAAAAAAAGznf49rVhUyiypYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 491, + "width": 731 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "formula = f\"y ~ 1 + x + np.power(x, 2) + I((x-{kink})*treated) + I(np.power(x-{kink}, 2)*treated)\"\n", + "\n", + "result4 = cp.pymc_experiments.RegressionKink(\n", + " df,\n", + " formula=formula,\n", + " model=cp.pymc_models.LinearRegression(sample_kwargs={\"random_seed\": seed}),\n", + " kink_point=kink,\n", + " epsilon=0.01,\n", + " bandwidth=0.4,\n", + ")\n", + "\n", + "fig, ax = result4.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice now that the data outside of the bandwidth is ignored in the fit." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "CausalPy", + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}