diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 582d9deb..dfb271e6 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -22,7 +22,7 @@ repos: exclude_types: [svg] - id: check-yaml - id: check-added-large-files - exclude: &exclude_pattern 'iv_weak_instruments.ipynb' + exclude: &exclude_pattern '(iv_weak_instruments\.ipynb|cp_covid\.ipynb)' args: ["--maxkb=1500"] - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.14.0 diff --git a/0.14.0 b/0.14.0 new file mode 100644 index 00000000..e69de29b diff --git a/causalpy/__init__.py b/causalpy/__init__.py index 66031185..df397759 100644 --- a/causalpy/__init__.py +++ b/causalpy/__init__.py @@ -19,6 +19,7 @@ from causalpy.version import __version__ from .data import load_data +from .experiments.change_point_detection import ChangePointDetection from .experiments.diff_in_diff import DifferenceInDifferences from .experiments.instrumental_variable import InstrumentalVariable from .experiments.interrupted_time_series import InterruptedTimeSeries @@ -33,6 +34,7 @@ __all__ = [ "__version__", "DifferenceInDifferences", + "ChangePointDetection", "create_causalpy_compatible_class", "InstrumentalVariable", "InterruptedTimeSeries", diff --git a/causalpy/custom_exceptions.py b/causalpy/custom_exceptions.py index 89e74c8f..a45c4f81 100644 --- a/causalpy/custom_exceptions.py +++ b/causalpy/custom_exceptions.py @@ -37,3 +37,10 @@ class DataException(Exception): def __init__(self, message: str): self.message = message + + +class ModelException(Exception): + """Exception raised given when there is some error in user-provided model""" + + def __init__(self, message: str): + self.message = message diff --git a/causalpy/experiments/change_point_detection.py b/causalpy/experiments/change_point_detection.py new file mode 100644 index 00000000..043d909a --- /dev/null +++ b/causalpy/experiments/change_point_detection.py @@ -0,0 +1,542 @@ +# Copyright 2022 - 2025 The PyMC Labs Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Interrupted Time Series Analysis + +This module implements interrupted time series (ITS) analysis for causal inference, +supporting both traditional scenarios where the intervention time is known and +advanced scenarios where the intervention time must be inferred from the data. + +Overview +-------- +Interrupted time series analysis is a quasi-experimental design used to evaluate +the impact of an intervention by comparing time series data before and after the +intervention occurs. This module provides a flexible framework that can handle: + +1. **Known intervention times**: Traditional ITS where you specify exactly when + the treatment occurred (e.g., policy implementation date) +2. **Unknown intervention times**: Advanced ITS where the model infers when an + intervention likely occurred based on observed changes in the data + +Treatment Time Handler Architecture +---------------------------------- +The core design pattern in this module is the Strategy pattern implemented through +the `TreatmentTimeHandler` hierarchy. This architecture was necessary because known +and unknown treatment times require fundamentally different approaches: + +**Why the Handler Architecture?** + +- **Data Processing**: Known times require splitting data at a specific point; + unknown times need the full dataset for inference +- **Model Training**: Known times train only on pre-intervention data; unknown + times train on all available data to detect the changepoint +- **Uncertainty Handling**: Known times have deterministic splits; unknown times + have probabilistic splits with confidence intervals +- **Visualization**: Different plotting strategies for certain vs. uncertain + intervention times + +**Handler Classes:** + +1. **TreatmentTimeHandler (Abstract Base Class)** + + - Defines the interface that all concrete handlers must implement + - Ensures consistent API regardless of whether treatment time is known/unknown + - Abstract methods: data_preprocessing, data_postprocessing, plot_intervention_line, + plot_impact_cumulative + - Optional method: plot_treated_counterfactual (only needed for unknown times) + +2. **KnownTreatmentTimeHandler** + + - Handles traditional ITS scenarios with predetermined intervention times + - **Data Preprocessing**: Filters data to pre-intervention period only for training + - **Data Postprocessing**: Creates clean pre/post splits at the known time point + - **Plotting**: Draws single vertical line at the intervention time + - **Use Case**: Policy evaluations, clinical trials, A/B tests with known start dates + +3. **UnknownTreatmentTimeHandler** + + - Handles advanced ITS scenarios where intervention time is inferred + - **Data Preprocessing**: Uses full dataset and constrains model's search window + - **Data Postprocessing**: Extracts inferred treatment time from posterior samples, + creates probabilistic pre/post splits, handles uncertainty propagation + - **Plotting**: Draws intervention line with uncertainty bands (HDI), shows + "treated counterfactual" predictions + - **Use Case**: Exploratory analysis, natural experiments, detecting unknown + structural breaks + +The handler pattern ensures that: + +- The main `InterruptedTimeSeries` class maintains a clean, unified API +- Different treatment time scenarios are handled with appropriate algorithms +- New handler types can be easily added (e.g., multiple intervention times) +- Code is maintainable and testable with clear separation of concerns + +The module automatically selects the appropriate handler based on the treatment_time +parameter and model type, providing a seamless user experience while maintaining +the flexibility to handle diverse analytical scenarios. +""" + +from typing import Iterable, List, Union + +import arviz as az +import numpy as np +import pandas as pd +import xarray as xr +from matplotlib import pyplot as plt +from patsy import dmatrices + +from causalpy.custom_exceptions import BadIndexException, DataException, ModelException +from causalpy.experiments.base import BaseExperiment +from causalpy.plot_utils import get_hdi_to_df, plot_xY +from causalpy.pymc_models import PyMCModel +from causalpy.utils import round_num + +LEGEND_FONT_SIZE = 12 + + +class ChangePointDetection(BaseExperiment): + """ + The class for detecting turning point in time series. + + :param data: + A pandas dataframe + :param formula: + A statistical model formula + :param treatment_time_range: + The time range when treatment could've occurred, + should be in reference to the data index + :param model: + A PyMC model + + Example + -------- + >>> import causalpy as cp + >>> df = ( + ... cp.load_data("its") + ... .assign(date=lambda x: pd.to_datetime(x["date"])) + ... .set_index("date") + ... ) + >>> seed = 42 + >>> result = cp.ChangePointDetection( + ... df, + ... time_range=None, + ... formula="y ~ 1 + t + C(month)", + ... model=cp.pymc_models.LinearChangePointDetection( + ... cp_effect_type="level", + ... sample_kwargs={ + ... "target_accept": 0.95, + ... "random_seed": seed, + ... "progressbar": False, + ... }, + ... ), + ... ) + """ + + expt_type = "Change Point Detection" + supports_ols = False + supports_bayes = True + + def __init__( + self, + data: pd.DataFrame, + formula: str, + time_range: Union[Iterable, None] = None, + model=None, + **kwargs, + ) -> None: + super().__init__(model=model) + + # rename the index to "obs_ind" + data.index.name = "obs_ind" + self.input_validation(data, time_range, model) + + # set experiment type - usually done in subclasses + self.expt_type = "Pre-Post Fit" + + self.time_range = time_range + self.formula = formula + + # Define the time interval over which the model will perform inference + model.set_time_range(self.time_range, data) + + # Preprocess the data according to the given formula + y, X = dmatrices(formula, data) + + self.outcome_variable_name = y.design_info.column_names[0] + 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) + + # turn into xarray.DataArray's + self.X = xr.DataArray( + self.X, + dims=["obs_ind", "coeffs"], + coords={ + "obs_ind": data.index, + "coeffs": self.labels, + }, + ) + self.y = xr.DataArray( + self.y, # Keep 2D shape + dims=["obs_ind", "treated_units"], + coords={"obs_ind": data.index, "treated_units": ["unit_0"]}, + ) + + # fit the model to the observed data + if isinstance(self.model, PyMCModel): + COORDS = { + "coeffs": self.labels, + "obs_ind": np.arange(self.X.shape[0]), + "treated_units": ["unit_0"], + } + idata = self.model.fit(X=self.X, y=self.y, coords=COORDS) + else: + raise ValueError("Model type not recognized") + + # score the goodness of fit to the pre-intervention data + self.score = self.model.score(X=self.X, y=self.y) + + # Getting inferred change point values + cp_samples = idata.posterior["change_point"].values + cp_mean = int(cp_samples.mean().item()) + + # Actual timestamp (index) corresponding to inferred change point + self.changepoint = data.index[cp_mean] + + # --- Slice data into pre/post change point --- + self.datapre = data.head(cp_mean) + self.datapost = data.iloc[cp_mean:] + + # --- Slice covariates into pre/post change point --- + self.pre_y = self.y.isel(obs_ind=slice(0, cp_mean)) + self.pre_X = self.X.isel(obs_ind=slice(0, cp_mean)) + self.post_y = self.y.isel(obs_ind=slice(cp_mean, None)) + self.post_X = self.X.isel(obs_ind=slice(cp_mean, None)) + + # --- Predict outcomes using the model --- + pred = model.predict(X=self.X) + self.pre_pred = pred.isel(obs_ind=slice(0, cp_mean)) + self.post_pred = pred.isel(obs_ind=slice(cp_mean, None)) + + # --- Estimate causal impact --- + impact = model.calculate_impact(y, pred) + self.pre_impact = impact.isel(obs_ind=slice(0, cp_mean)) + self.post_impact = impact.isel(obs_ind=slice(cp_mean, None)) + + # --- Create a mask to isolate post-change point period --- + # Timeline reshaped to match broadcasting with change point + # (Probably could be better implemented though) + timeline = [ + [[i for i in range(len(data))] for _ in range(len(cp_samples[0]))] + for _ in range(len(cp_samples)) + ] + timeline_broadcast = np.array(timeline) + tt_broadcast = cp_samples[:, :, None].astype(int) + mask = (timeline_broadcast >= tt_broadcast).astype(int) + mask = mask[:, :, np.newaxis, :] + post_impact_masked = impact * mask + + # --- Compute cumulative post-change point impact --- + post_impact_masked = impact * mask + self.post_impact_cumulative = model.calculate_cumulative_impact( + post_impact_masked + ) + + def input_validation(self, data, time_range, model): + """Validate the input data and model formula for correctness""" + if not hasattr(model, "set_time_range"): + raise ModelException("Provided model must have a 'set_time_range' method") + if time_range is not None and len(time_range) != 2: + raise DataException( + "Provided time_range must be of length 2 : (start, end)" + ) + if isinstance(data.index, pd.DatetimeIndex) and not ( + time_range is None + or ( + isinstance(time_range, Iterable) + and all(isinstance(t, pd.Timestamp) for t in time_range) + ) + ): + raise BadIndexException( + "If data.index is DatetimeIndex, time_range must " + "be of type Iterable[pd.Timestamp]." + ) + if not isinstance(data.index, pd.DatetimeIndex) and ( + isinstance(time_range, Iterable) + and all(isinstance(t, pd.Timestamp) for t in time_range) + ): + raise BadIndexException( + "If data.index is not DatetimeIndex, time_range must" + "not be of type Iterable[pd.Timestamp]." # noqa: E501 + ) + + def summary(self, round_to=None) -> None: + """Print summary of main results and model coefficients. + + :param round_to: + Number of decimals used to round results. Defaults to 2. Use "None" to return raw numbers + """ + print(f"{self.expt_type:=^80}") + print(f"Formula: {self.formula}") + self.print_coefficients(round_to) + + def _bayesian_plot( + self, round_to=None, **kwargs + ) -> tuple[plt.Figure, List[plt.Axes]]: + """ + Plot the results + + :param round_to: + Number of decimals used to round results. Defaults to 2. Use "None" to return raw numbers. + """ + counterfactual_label = "Counterfactual" + + fig, ax = plt.subplots(3, 1, sharex=True, figsize=(7, 8)) + # TOP PLOT -------------------------------------------------- + handles = [] + labels = [] + + # Treated counterfactual + # Plot predicted values after change point (with HDI) + h_line, h_patch = plot_xY( + self.datapre.index, + self.pre_pred["posterior_predictive"].mu.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "yellowgreen"}, + ) + + h_line, h_patch = plot_xY( + self.datapost.index, + self.post_pred["posterior_predictive"].mu.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "yellowgreen"}, + ) + + handles.append((h_line, h_patch)) + labels.append("Treated counterfactual") + + # pre-intervention period + h_line, h_patch = plot_xY( + self.datapre.index, + self.pre_pred["posterior_predictive"].mu_ts.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "C0"}, + ) + handles.append((h_line, h_patch)) + labels.append("Pre-intervention period") + + (h,) = ax[0].plot( + self.datapre.index, + self.pre_y.isel(treated_units=0) + if hasattr(self.pre_y, "isel") + else self.pre_y[:, 0], + "k.", + label="Observations", + ) + handles.append(h) + labels.append("Observations") + + # post intervention period + h_line, h_patch = plot_xY( + self.datapost.index, + self.post_pred["posterior_predictive"].mu_ts.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "C1"}, + ) + handles.append((h_line, h_patch)) + labels.append(counterfactual_label) + + ax[0].plot( + self.datapost.index, + self.post_y.isel(treated_units=0) + if hasattr(self.post_y, "isel") + else self.post_y[:, 0], + "k.", + ) + # Shaded causal effect + post_pred_mu = ( + az.extract(self.post_pred, group="posterior_predictive", var_names="mu_ts") + .isel(treated_units=0) + .mean("sample") + ) # Add .mean("sample") to get 1D array + h = ax[0].fill_between( + self.datapost.index, + y1=post_pred_mu, + y2=self.post_y.isel(treated_units=0) + if hasattr(self.post_y, "isel") + else self.post_y[:, 0], + color="C0", + alpha=0.25, + ) + handles.append(h) + labels.append("Causal impact") + + ax[0].set( + title=f""" + Pre-intervention Bayesian $R^2$: {round_num(self.score["unit_0_r2"], round_to)} + (std = {round_num(self.score["unit_0_r2_std"], round_to)}) + """ + ) + + # MIDDLE PLOT ----------------------------------------------- + plot_xY( + self.datapre.index, + self.pre_impact.isel(treated_units=0), + ax=ax[1], + plot_hdi_kwargs={"color": "C0"}, + ) + plot_xY( + self.datapost.index, + self.post_impact.isel(treated_units=0), + ax=ax[1], + plot_hdi_kwargs={"color": "C1"}, + ) + ax[1].axhline(y=0, c="k") + ax[1].fill_between( + self.datapost.index, + y1=self.post_impact.mean(["chain", "draw"]).isel(treated_units=0), + color="C0", + alpha=0.25, + label="Causal impact", + ) + ax[1].set(title="Causal Impact") + + # BOTTOM PLOT ----------------------------------------------- + # Concatenate the time indices + full_index = self.datapre.index.append(self.datapost.index) + ax[2].set(title="Cumulative Causal Impact") + plot_xY( + full_index, + self.post_impact_cumulative.isel(treated_units=0), + ax=ax[2], + plot_hdi_kwargs={"color": "C1"}, + ) + ax[2].axhline(y=0, c="k") + + # Plot vertical line marking change point (with HDI if it's inferred) + data = pd.concat([self.datapre, self.datapost]) + # Extract the HDI (uncertainty interval) of the change point + hdi = az.hdi(self.idata, var_names=["change_point"])["change_point"].values + x1 = data.index[int(hdi[0])] + x2 = data.index[int(hdi[1])] + + for i in [0, 1, 2]: + ymin, ymax = ax[i].get_ylim() + + # Vertical line for inferred change point + ax[i].plot( + [self.changepoint, self.changepoint], + [ymin, ymax], + ls="-", + lw=3, + color="r", + solid_capstyle="butt", + ) + + # Shaded region for HDI of change point + ax[i].fill_betweenx( + y=[ymin, ymax], + x1=x1, + x2=x2, + alpha=0.1, + color="r", + ) + + ax[0].legend( + handles=(h_tuple for h_tuple in handles), + labels=labels, + fontsize=LEGEND_FONT_SIZE, + ) + + return fig, ax + + def get_plot_data_bayesian(self, hdi_prob: float = 0.94) -> pd.DataFrame: + """ + Recover the data of the experiment along with the prediction and causal impact information. + + :param hdi_prob: + Prob for which the highest density interval will be computed. The default value is defined as the default from the :func:`arviz.hdi` function. + """ + if isinstance(self.model, PyMCModel): + hdi_pct = int(round(hdi_prob * 100)) + + pred_lower_col = f"pred_hdi_lower_{hdi_pct}" + pred_upper_col = f"pred_hdi_upper_{hdi_pct}" + impact_lower_col = f"impact_hdi_lower_{hdi_pct}" + impact_upper_col = f"impact_hdi_upper_{hdi_pct}" + + pre_data = self.datapre.copy() + post_data = self.datapost.copy() + + pre_data["prediction"] = ( + az.extract(self.pre_pred, group="posterior_predictive", var_names="mu") + .mean("sample") + .isel(treated_units=0) + .values + ) + post_data["prediction"] = ( + az.extract(self.post_pred, group="posterior_predictive", var_names="mu") + .mean("sample") + .isel(treated_units=0) + .values + ) + hdi_pre_pred = get_hdi_to_df( + self.pre_pred["posterior_predictive"].mu, hdi_prob=hdi_prob + ) + hdi_post_pred = get_hdi_to_df( + self.post_pred["posterior_predictive"].mu, hdi_prob=hdi_prob + ) + # Select the single unit from the MultiIndex results + pre_data[[pred_lower_col, pred_upper_col]] = hdi_pre_pred.xs( + "unit_0", level="treated_units" + ).set_index(pre_data.index) + post_data[[pred_lower_col, pred_upper_col]] = hdi_post_pred.xs( + "unit_0", level="treated_units" + ).set_index(post_data.index) + + pre_data["impact"] = ( + self.pre_impact.mean(dim=["chain", "draw"]).isel(treated_units=0).values + ) + post_data["impact"] = ( + self.post_impact.mean(dim=["chain", "draw"]) + .isel(treated_units=0) + .values + ) + hdi_pre_impact = get_hdi_to_df(self.pre_impact, hdi_prob=hdi_prob) + hdi_post_impact = get_hdi_to_df(self.post_impact, hdi_prob=hdi_prob) + # Select the single unit from the MultiIndex results + pre_data[[impact_lower_col, impact_upper_col]] = hdi_pre_impact.xs( + "unit_0", level="treated_units" + ).set_index(pre_data.index) + post_data[[impact_lower_col, impact_upper_col]] = hdi_post_impact.xs( + "unit_0", level="treated_units" + ).set_index(post_data.index) + + self.plot_data = pd.concat([pre_data, post_data]) + + return self.plot_data + else: + raise ValueError("Unsupported model type") + + def plot_change_point(self): + """ + display the posterior estimates of the change point + """ + if "change_point" not in self.idata.posterior.data_vars: + raise ValueError( + "Variable 'change_point' not found in inference data (idata)." + ) + + az.plot_trace(self.idata, var_names="change_point") diff --git a/causalpy/pymc_models.py b/causalpy/pymc_models.py index 2596ca4c..7cf9affe 100644 --- a/causalpy/pymc_models.py +++ b/causalpy/pymc_models.py @@ -886,3 +886,309 @@ class initialisation. idata_outcome.extend(pm.sample(**self.sample_kwargs)) return idata_outcome, model_outcome + + +class LinearChangePointDetection(PyMCModel): + r""" + Custom PyMC model to estimate one ChangePoint in time series. + + This model implements three types of changepoints: level shift, trend change, and impulse response. + While the underlying mathematical framework could theoretically be applied to other changepoint + detection problems, it has been specifically designed and tested for use in interrupted time + series causal inference settings. + + In words: + - `beta` represents the regression coefficients for the baseline signal `μ`. + - `tau` is the changepoint time, and `w` is a sigmoid function to smooth the transition. + - `level` and `trend` model a linear shift after the changepoint. + - `A` and `lambda` define an impulse response at the changepoint. + - `mu_in` combines the level, trend, and impulse contributions. + - `mu_ts` is the total mean, including baseline and intervention. + - `sigma` is the observation noise. + - Finally, `y` is drawn from a Normal distribution with mean `mu_ts` and standard deviation `sigma`. + + .. math:: + \beta &\sim \mathrm{Normal}(0, 5) \\ + \mu &= \beta \cdot X\\ + \\ + \tau &\sim \mathrm{Uniform}(\text{lower_bound}, \text{upper_bound}) \\ + w &= sigmoid(t-\tau) \\ + \\ + \text{level} &\sim \mathrm{Normal}(0, 5) \\ + \text{trend} &\sim \mathrm{Normal}(0, 0.5) \\ + A &\sim \mathrm{Normal}(0, 5) \\ + \lambda &\sim \mathrm{HalfNormal}(0, 5) \\ + \text{impulse} &= A \cdot exp(-\lambda \cdot |t-\tau|) \\ + \mu_{in} &= \text{level} + \text{trend} \cdot (t-\tau) + \text{impulse}\\ + \\ + \sigma &\sim \mathrm{HalfNormal}(0, 1) \\ + \mu_{ts} &= \mu + \mu_{in} \\ + \\ + y &\sim \mathrm{Normal}(\mu_{ts}, \sigma) + + Example + -------- + >>> import causalpy as cp + >>> import numpy as np + >>> from patsy import build_design_matrices, dmatrices + >>> from causalpy.pymc_models import LinearChangePointDetection + >>> data = cp.load_data("its") + >>> formula="y ~ 1 + t + C(month)" + >>> y, X = dmatrices(formula, data) + >>> outcome_variable_name = y.design_info.column_names[0] + >>> labels = X.design_info.column_names + >>> _y, _X = np.asarray(y), np.asarray(X) + >>> _X = xr.DataArray( + ... _X, + ... dims=["obs_ind", "coeffs"], + ... coords={ + ... "obs_ind": data.index, + ... "coeffs": labels, + ... }, + ... ) + >>> _y = xr.DataArray( + ... _y, + ... dims=["obs_ind", "treated_units"], + ... coords={ + ... "obs_ind": data.index, + ... "treated_units": ["unit_0"] + ... }, + ... ) + >>> COORDS = { + ... "coeffs": labels, + ... "obs_ind": np.arange(X.shape[0]), + ... "treated_units": ["unit_0"], + ... } + >>> model = LinearChangePointDetection(cp_effect_type="level", sample_kwargs={"draws" : 10, "tune":10, "progressbar":False}) + >>> model.set_time_range(None, data) + >>> model.fit(X=_X, y=_y, coords=COORDS) + Inference ... + """ + + default_priors = { + "beta": Prior("Normal", mu=0, sigma=5, dims=["treated_units", "coeffs"]), + "level": Prior("Normal", mu=0, sigma=5), + "trend": Prior("Normal", mu=0, sigma=5), + "impulse_amplitude": Prior("Normal", mu=0, sigma=5), + "impulse_decay_rate": Prior("HalfNormal", sigma=5), + "y_hat": Prior( + "Normal", + sigma=Prior("HalfNormal", sigma=5), + dims=["obs_ind", "treated_units"], + ), + } + + def __init__( + self, + cp_effect_type: str | list[str], + cp_effect_param=None, + sample_kwargs=None, + ): + """ + Initializes the InterventionTimeEstimator model. + + :param cp_effect_type: Optional dictionary that specifies prior parameters for the + intervention effects. Expected keys are: + - "level": [mu, sigma] + - "trend": [mu, sigma] + - "impulse": [mu, sigma1, sigma2] + If a key is missing, the corresponding effect is ignored. + If the associated list is incomplete, default values will be used. + :param sample_kwargs: Optional dictionary of arguments passed to pm.sample(). + """ + + super().__init__(sample_kwargs, cp_effect_param) + + # Make sure we get a list of all expected effects + if isinstance(cp_effect_type, str): + self.cp_effect_type = [cp_effect_type] + else: + self.cp_effect_type = cp_effect_type + + def build_model(self, X, y, coords): + """ + Defines the PyMC model + + :param X: An array of the covariates + :param y: An array of values representing our outcome y + :param coords: Dictionary of named coordinates for PyMC variables (e.g., {"obs_ind": range(n_obs), "coeffs": range(n_covariates)}). + + Assumes the following attributes are already defined in self: + - self.timeline: the index of the column in X representing time. + - self.time_range: a tuple (lower_bound, upper_bound) for the intervention time. + - self.cp_effect_type: a dictionary specifying which intervention effects to include and their priors. + """ + + with self: + self.add_coords(coords) + + t = pm.Data("t", np.arange(len(X)), dims="obs_ind") + X = pm.Data("X", X, dims=["obs_ind", "coeffs"]) + y = pm.Data("y", y, dims=["obs_ind", "treated_units"]) + + lower_bound = pm.Data("lower_bound", self.time_range[0]) + upper_bound = pm.Data("upper_bound", self.time_range[1]) + + # --- Priors --- + # --- change_point unconstrained mapping --- + tau_un = pm.Normal("tau_un", 0, 1) + change_point = pm.Deterministic( + "change_point", + lower_bound + (upper_bound - 1 - lower_bound) * pm.math.sigmoid(tau_un), + ) + + delta_t = pm.Deterministic( + name="delta_t", + var=(t - change_point), + dims=["obs_ind"], + ) + beta = self.priors["beta"].create_variable("beta") + + # --- Intervention effect --- + mu_in_components = [] + + if "level" in self.cp_effect_type: + level = self.priors["level"].create_variable("level") + mu_in_components.append(level) + + if "trend" in self.cp_effect_type: + trend = self.priors["trend"].create_variable("trend") + mu_in_components.append(trend * delta_t) + + if "impulse" in self.cp_effect_type: + impulse_amplitude = self.priors["impulse_amplitude"].create_variable( + "impulse_amplitude" + ) + decay_rate = self.priors["impulse_decay_rate"].create_variable( + "impulse_decay_rate" + ) + impulse = pm.Deterministic( + "impulse", + impulse_amplitude * pm.math.exp(-decay_rate * pm.math.abs(delta_t)), + ) + mu_in_components.append(impulse) + + # --- Parameterization --- + weight = pm.math.sigmoid(delta_t) + # Compute and store the base time series + mu_ts = pm.Deterministic( + name="mu_ts", var=pt.dot(X, beta.T), dims=["obs_ind", "treated_units"] + ) + # Compute and store the modelled intervention effect + mu_in = ( + pm.Deterministic( + name="mu_in", + var=sum(mu_in_components), + ) + if len(mu_in_components) > 0 + else pm.Data( + name="mu_in", + vars=0, + ) + ) + + mu = pm.Deterministic( + "mu", + mu_ts + (weight * mu_in)[:, None], + dims=["obs_ind", "treated_units"], + ) + + # --- Likelihood --- + + # Likelihodd of the base time series and the intervention's effect + self.priors["y_hat"].create_likelihood_variable("y_hat", mu=mu, observed=y) + + def predict(self, X): + """ + Predict data given input data `X` + + .. caution:: + Results in KeyError if model hasn't been fit. + """ + + # Ensure random_seed is used in sample_prior_predictive() and + # sample_posterior_predictive() if provided in sample_kwargs. + random_seed = self.sample_kwargs.get("random_seed", None) + self._data_setter(X) + with self: # sample with new input data + pp = pm.sample_posterior_predictive( + self.idata, + var_names=["y_hat", "mu", "mu_ts", "mu_in"], + progressbar=False, + random_seed=random_seed, + ) + + # TODO: This is a bit of a hack. Maybe it could be done properly in _data_setter? + if isinstance(X, xr.DataArray) and "obs_ind" in X.coords: + pp["posterior_predictive"] = pp["posterior_predictive"].assign_coords( + obs_ind=X.obs_ind + ) + + return pp + + def _data_setter(self, X) -> None: + """ + Set data for the model. + + This method is used internally to register new data for the model for + prediction. + """ + n_obs = X.shape[0] + with self: + treated_units_coord = getattr(self, "coords", {}).get( + "treated_units", ["unit_0"] + ) + n_treated_unit = len(treated_units_coord) + pm.set_data( + { + "X": X, + "t": np.arange(n_obs), + "y": np.zeros((n_obs, n_treated_unit)), + }, + coords={"obs_ind": np.arange(n_obs)}, + ) + + def score(self, X, y) -> pd.Series: + """ + Score the Bayesian :math:`R^2` given inputs ``X`` and outputs ``y``. + """ + mu = self.predict(X) + mu_data = az.extract(mu, group="posterior_predictive", var_names="mu") + + scores = {} + + # Always iterate over treated_units dimension - no branching needed! + for i, unit in enumerate(mu_data.coords["treated_units"].values): + unit_mu = mu_data.sel(treated_units=unit).T # (sample, obs_ind) + unit_y = y.sel(treated_units=unit).data + unit_score = r2_score(unit_y, unit_mu.data) + scores[f"unit_{i}_r2"] = unit_score["r2"] + scores[f"unit_{i}_r2_std"] = unit_score["r2_std"] + + return pd.Series(scores) + + def calculate_impact( + self, y_true: xr.DataArray, y_pred: az.InferenceData + ) -> xr.DataArray: + impact = y_true - y_pred["posterior_predictive"]["mu_ts"] + return impact.transpose(..., "obs_ind") + + def set_time_range(self, time_range, data): + """ + Set time_range. + + :param time_range: tuple or None + If not None, a tuple of two values (start_label, end_label) that correspond + to index labels in the 't' column of the `data` DataFrame + :param data: pandas.DataFrame. + """ + if time_range is None: + self.time_range = ( + 0, + len(data), + ) + else: + self.time_range = ( + data.index.get_loc(time_range[0]), + data.index.get_loc(time_range[1]), + ) diff --git a/causalpy/tests/test_integration_pymc_examples.py b/causalpy/tests/test_integration_pymc_examples.py index e7795522..f5d8e34c 100644 --- a/causalpy/tests/test_integration_pymc_examples.py +++ b/causalpy/tests/test_integration_pymc_examples.py @@ -403,6 +403,110 @@ def test_its(mock_pymc_sample): ) +@pytest.mark.integration +def test_cp_covid(): + """ + Test ChangePoint experiment on COVID data. + + Loads data and checks: + 1. data is a dataframe + 2. causalpy.ChangePoint 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 + 5. the method get_plot_data returns a DataFrame with expected columns + """ + + df = ( + cp.load_data("covid") + .assign(date=lambda x: pd.to_datetime(x["date"])) + .set_index("date") + ) + time_range = (pd.to_datetime("2014-01-01"), pd.to_datetime("2022-01-01")) + + # Assert that we correctfully raise a ModelException if the given model can't predict InterventionTime + with pytest.raises(cp.custom_exceptions.ModelException) as exc_info: + cp.ChangePointDetection( + df, + time_range=time_range, + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + ) + assert "Provided model must have a 'set_time_range' method" in str(exc_info.value) + + # Assert that we correctfully raise a DataException if + # - time_range is not None + # - and len(time_range) is not 2 + with pytest.raises(cp.custom_exceptions.DataException) as exc_info: + cp.ChangePointDetection( + df, + time_range=[0, 0, 0], + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert "Provided time_range must be of length 2 : (start, end)" in str( + exc_info.value + ) + + # Assert that we correctfully raise a BadIndexException if + # - time_range is not None + # - time_range is not of type Iterable[pd.TimeStamp] + # - DataIndex is of type pd.DatetimeIndex + with pytest.raises(cp.custom_exceptions.BadIndexException) as exc_info: + cp.ChangePointDetection( + df, + time_range=[0, 0], + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert ( + "If data.index is DatetimeIndex, time_range must be of type Iterable[pd.Timestamp]." + in str(exc_info.value) + ) + + result = cp.ChangePointDetection( + df, + time_range=time_range, + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert isinstance(df, pd.DataFrame) + assert isinstance(result, cp.ChangePointDetection) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + result.summary() + fig, ax = result.plot() + assert isinstance(fig, plt.Figure) + # For multi-panel plots, ax should be an array of axes + assert isinstance(ax, np.ndarray) and all( + isinstance(item, plt.Axes) for item in ax + ), "ax must be a numpy.ndarray of plt.Axes" + # Test get_plot_data with default parameters + plot_data = result.get_plot_data() + assert isinstance(plot_data, pd.DataFrame), ( + "The returned object is not a pandas DataFrame" + ) + expected_columns = [ + "prediction", + "pred_hdi_lower_94", + "pred_hdi_upper_94", + "impact", + "impact_hdi_lower_94", + "impact_hdi_upper_94", + ] + assert set(expected_columns).issubset(set(plot_data.columns)), ( + f"DataFrame is missing expected columns {expected_columns}" + ) + + @pytest.mark.integration def test_its_covid(mock_pymc_sample): """ diff --git a/docs/source/_static/classes.png b/docs/source/_static/classes.png index 2dda20e6..50592de7 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 8734d55d..a00d0758 100644 --- a/docs/source/_static/interrogate_badge.svg +++ b/docs/source/_static/interrogate_badge.svg @@ -1,5 +1,5 @@ - interrogate: 95.8% + interrogate: 95.7% @@ -12,8 +12,8 @@ interrogate interrogate - 95.8% - 95.8% + 95.7% + 95.7% diff --git a/docs/source/_static/packages.png b/docs/source/_static/packages.png index 5a537cd0..0dd5a658 100644 Binary files a/docs/source/_static/packages.png and b/docs/source/_static/packages.png differ diff --git a/docs/source/notebooks/cp_covid.ipynb b/docs/source/notebooks/cp_covid.ipynb new file mode 100644 index 00000000..5e422a3c --- /dev/null +++ b/docs/source/notebooks/cp_covid.ipynb @@ -0,0 +1,1268 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bayesian Change Point Detection\n", + "\n", + "This notebook showcases a new experiment, the ``ChangePointDetection`` class in CausalPy : it supports some models that can infer the treatment time directly from the data.\n", + "\n", + "We illustrate this using a built-in model from the CausalPy library, which only requires specifying the effect of the intervention. From this, the model estimates when the intervention likely occurred." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\pymc_extras\\model\\marginal\\graph_analysis.py:10: FutureWarning: `pytensor.graph.basic.io_toposort` was moved to `pytensor.graph.traversal.io_toposort`. Calling it from the old location will fail in a future release.\n", + " from pytensor.graph.basic import io_toposort\n" + ] + } + ], + "source": [ + "# Imports ...\n", + "\n", + "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\n", + "\n", + "seed = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using the `InterventionTimeEstimator` PyMC model\n", + "\n", + "The `InterventionTimeEstimator` is designed to infer *when* an intervention likely occurred, based on the **type of effect** you expect it to have produced. \n", + "\n", + "Instead of specifying the exact time of change, you describe the expected *form* of the intervention: a sudden jump (`level`), a gradual shift (`trend`), or a short-lived anomaly (`impulse`). Optionally, you can narrow the search by providing a plausible time window. \n", + "\n", + "Under the hood, the model evaluates candidate intervention points and estimates how well each one explains the observed data through Bayesian inference. At its core, it relies on a linear regression, to which the intervention effects are added: \n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\beta &\\sim \\mathcal{N}(0, 5) \\\\\n", + "\\sigma &\\sim \\text{HalfNormal}(1) \\\\\n", + "\\mu &= X \\cdot \\beta \\\\\n", + "y &\\sim \\mathcal{N}(\\mu, \\sigma)\n", + "\\end{align}\n", + "$$\n", + "\n", + "Also, in the next example, the intervention time will not be implicit. Instead, it is treated as a parameter to be inferred within a plausible window. The model then learns which value of $t$ within this range best explains the observed data :\n", + "\n", + "$$\n", + "t \\sim \\mathcal{U}(\\text{time range})\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 1: Level Change\n", + "\n", + "In this example, we apply the `InterventionTimeEstimator` model to an Interrupted Time Series in its simplest form: a **level change**. \n", + "\n", + "A level change corresponds to a sudden shift in the mean level of the series, occurring at the time of the intervention. In this case, the model can be expressed as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\text{level} &\\sim \\mathcal{N}(0, 5) \\\\\n", + "\\mu_{\\text{level}} &= \\sigma(t) \\cdot \\text{level} \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{level}}, \\sigma)\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $\\sigma(t) = \\frac{1}{1 + e^{-t}}$ is the logistic sigmoid function that encodes the timing of the intervention.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate the Data ...\n", + "np.random.seed(seed)\n", + "\n", + "n = 100\n", + "tau_true = 40\n", + "x = np.arange(n)\n", + "y = np.where(x >= tau_true, 2, 0.0) + np.random.normal(1, 0.4, size=n)\n", + "df = pd.DataFrame({\"t\": x, \"y\": y})\n", + "\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(x, y)\n", + "plt.axvline(tau_true, color=\"red\", linestyle=\"--\", label=\"True treatment time\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, when initializing the InterventionTimeEstimator model, we only need to Ensure that InterruptedTimeSeries ``treatment_effect_type`` includes the key ``\"level\"``. After that, the model can be used as is with the ``InterruptedTimeSeries`` class by setting the ``treatment_time`` parameter to ``None``." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from causalpy.experiments.change_point_detection import ChangePointDetection\n", + "from causalpy.pymc_models import LinearChangePointDetection" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"level\", sample_kwargs={\"sample_seed\": seed, \"progressbar\": False}\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, this example produces two plots.\n", + "\n", + "The first displays three graphs: \n", + "- the **model’s predictions**, showing both the fitted curve *with* and *without* the inferred causal effect, \n", + "- the **estimated causal impact** which isolates the effect by removing it from the predictions,\n", + "- and the **cumulative impact over time**.\n", + "\n", + "The second plot shows the posterior distribution of the inferred treatment time.\n", + "\n", + ":::{note} that the R² score is computed using the full predictions, that is, including the causal effect. In contrast, the causal impact is calculated by subtracting the estimated effect from the predictions.:::" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABLsAAADTCAYAAABp7hHfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4HNW9/t+zvaj3Ytlykxs2NpjeIQkhNxBCbn73ppCbTuASCAklBEIIgZAQQnogJEACpJDCpSQhEDBgwLgXuUqyei+rlbTavjvn98c7s7OrYsu2jAvn8zx6JG2ZOXPmnDPzfedbhJRSQqFQKBQKhUKhUCgUCoVCoTgOsBzpBigUCoVCoVAoFAqFQqFQKBTThRK7FAqFQqFQKBQKhUKhUCgUxw1K7FIoFAqFQqFQKBQKhUKhUBw3KLFLoVAoFAqFQqFQKBQKhUJx3KDELoVCoVAoFAqFQqFQKBQKxXGDErsUCoVCoVAoFAqFQqFQKBTHDUrsUigUCoVCoVAoFAqFQqFQHDcosUuhUCgUCoVCoVAoFAqFQnHcoMQuhUKhUCgUCoVCoVAoFArFcYMSuxSKdylXXnklrrzyyiPdjGOOCy+8EF//+tcP+Hu7d+/Gz372M4yMjByGVikUCoVCoTiWUfdlB4e6L1MoFJNhO9INUCgUimOJn//858jKyjrg7+3evRs///nP8eEPfxg5OTmHoWUKhUKhUCgU7y7UfZlCoZgMJXYpFArFAbB48eIj3QSFQqFQKBQKBdR9mUKhmBwVxqhQHMfs3r0bV199NU499VSceOKJ+MAHPoDHH3884zOrV6/GZZddhhNPPBGXX3451q1bl/F+bW0trr32WpxzzjlYtmwZPvCBD+Dhhx9GIpHI+JzhRv7MM8/g4osvxooVK/Cxj30MdXV1GZ+Lx+P4/ve/jzPOOAMrVqzAl770JWzatAkLFizA008/nfHZdevW4VOf+hRWrFiBFStW4POf/zz27t17QH1ghAW8+OKLuOSSS3DCCSfg0ksvxVtvvTXus88++ywuu+wyLF26FKeddhpuvvlm9PX1TXicBk8//TQWLFiAbdu24frrr8eKFStw3nnn4cc//jGSyWTqM7feeisA4KKLLsKCBQuwYMGCAzoOhUKhUCgUxzbqvkzdlykUincO5dmlUByn1NbW4sorr8ScOXNw2223oaSkBE1NTejo6Eh9prm5GT/4wQ/wpS99CVlZWfjpT3+Ka665BqtWrUJubi4AoLu7G4sXL8ZHPvIReL1eNDQ04MEHH8TQ0BBuvvnmjH2uW7cOLS0tuPHGGyGlxH333YdrrrkGL774Imw2LjcPPPAAfvvb3+KLX/wiTjnlFGzYsAE33XTTuPa/9tpruOaaa/Ce97wH999/P6SUePjhh/GJT3wCzz77LMrKyqbcF83Nzbjvvvvw5S9/GdnZ2Xjsscdw1VVX4dlnn8XcuXMBAE899RTuuOMOXHbZZfja176G3t5e/OhHP8K2bdvwf//3f/B4PPvcx80334wPfehD+K//+i+sXr0aDz74ICorK/HRj34U559/Pq6++mo8+OCD+PnPf47i4uIpt12hUCgUCsWxj7ovM1H3ZQqF4h1BKhSK45KPf/zj8oILLpCRSGTC9z/5yU/KJUuWyPb29tRrO3bskDU1NfK5556b8Duapsl4PC6feeYZefLJJ0tN01LvXXDBBfLUU0+VgUAg9dqLL74oa2pq5KZNm6SUUvr9frls2TJ5zz33ZGz37rvvljU1NfJvf/tb6rWLLrpIfvazn8343PDwsDz11FPlvffeO8Ve4HHW1NTIHTt2pF4LhULy9NNPl1/96lellFImEgl5xhlnyM985jMZ392wYYOsqamRTz75ZMZx3nLLLan///a3v8mamhr54IMPZnz3gx/8YMb2jM+l97dCoVAoFIp3B+q+zDxOdV+mUCjeCVQYo0JxHBIOh7F582ZcdtllcDqdk35uzpw5mDFjRur/+fPnA+BTQ4ORkRF8//vfx0UXXYSlS5diyZIluPnmmxEIBDAwMJCxvZNOOikjSei8efMytldfX49IJIL3ve99Gd+7+OKLM/5vaWlBe3s7Lr30UiQSidSPx+PBihUrsHHjxgPpDlRVVWHJkiWp/91uN84//3xs27YNAJ8w+nw+XHrppRnfW7lyJSorK7Fhw4b97uPcc8/N+H/+/Pno6uo6oHYqFAqFQqE4/lD3ZZmo+zKFQvFOoMIYFYrjkJGREWiahtLS0n1+znCJN3A4HACAaDSaeu3WW2/F2rVrcd1112HRokVwu92ora3FXXfdlfG5qWyvv78fAFBQUJDxubH/+3w+AMAtt9yCW265ZVy7028Ep0JhYeG414qKilJ5H4aGhlKvTfS54eHh/e5jbCUfh8OBWCx2QO1UKBQKhUJx/KHuyzJR92UKheKdQIldCsVxSE5ODiwWC3p7ew9pO9FoFK+++iquvfZa/M///E/q9fr6+oPanpETYXBwEHPmzEm9Pjg4mPG5vLw8AMBNN92E0047bdx2jJu1qWLcpKUzMDCAkpISAEB+fn7qtYk+V1FRcUD7UygUCoVCoTBQ92WZqPsyhULxTqDCGBWK4xC3242TTz4Zzz333LinfAdCLBZDMplMJTE1eOaZZw5qezU1NXC5XHjppZcyXn/xxRcz/p8zZw4qKyvR2NiIpUuXjvs50Io57e3t2LlzZ+r/cDiM1157DcuXLwcAzJ49G8XFxXj++eczvrd582Z0dnbi1FNPPaD9TcRET2cVCoVCoVAc/6j7skzUfZlCoXgnUJ5dCsVxys0334wrr7wS//3f/41Pf/rTKC0tRWtrK1pbW8dV65mM7OxsLF++HI899hhKSkqQn5+Pp59+Gj09PQfVpry8PHziE5/AY489Bo/Hk6r688orrwAALBbq70IIfOtb38I111yDaDSK97///cjLy8PAwAA2b96MqqqqjCea+6O4uBjXXXcdrrvuOmRnZ+PRRx9FIBDA1Vdfndrv9ddfj9tvvx033XQTLr300lTVn9mzZ+PDH/7wQR1vOkZ1oT/84Q+49NJLYbVasXTp0kPerkKhUCgUiqMfdV9mou7LFArFO4ESuxSK45Rly5bhD3/4A37yk5/grrvuQiKRwIwZM/Cxj33sgLbzwx/+EHfeeSe+/e1vw+Vy4ZJLLsFtt92Gq6666qDadcMNN0BKiT/96U/47W9/i1NPPRXf/OY3U2W2Dc477zw8+eSTeOihh3DbbbchEomguLgYy5cvxwc/+MED2ufs2bNx5ZVX4oEHHkBHRwdmz56Nhx56KHWjAwAf/ehH4XQ68Zvf/AYvvPACvF4vzjvvPNx0001wu90HdazpLFq0CFdffTX+8pe/4Pe//z2klKirqzvk7SoUCoVCoTj6UfdlJuq+TKFQvBMIKaU80o1QKBTvbh555BHcd999WLVqFSorK6d121deeSUA4IknnpjW7SoUCoVCoVAcj6j7MoVCcTygPLsUCsU7ypYtW7BmzRosXboUVqsVGzduxCOPPIKLL7542m+oFAqFQqFQKBSTo+7LFArF8YoSuxQKxTuK2+3GmjVr8Nvf/hahUAjFxcX4+Mc/jq985SsHtB0pJZLJ5KTvCyFgtVoPsbUKhUKhUCgUxy/qvkyhUByvqDBGhUJxTPL000/j1ltvnfT9yspKrFq16h1skUKhUCgUCsW7E3VfplAojjaU2KVQKI5J/H4/Ojo6Jn3f4XAccClshUKhUCgUCsWBo+7LFArF0YYSuxQKhUKhUCgUCoVCoVAoFMcNliPdAIVCoVAoFAqFQqFQKBQKhWK6UGKXQqFQKBQKhUKhUCgUCoXiuGHK1Rj9fv/hbMdBkZubi+Hh4SPdDMU0o87r8Yk6r8cv6twen6jzOp78/Pwj3QQAgKZp6twcR6i5dnyhzufxhTqfxw/qXB5fTOWe7Jj27LJYjunmKyZBndfjE3Vej1/UuT0+Uef16EWdm+MLdT6PL9T5PL5Q5/P4QZ3Ldx/qjCsUCoVCoVAoFAqFQqFQKI4blNilUCgUCoVCoVAoFAqFQqE4blBil0KhUCgUCoVCoVAoFAqF4rhBiV0KheKoIpmUGBqSSCQkAEBKuc/PSykRjfJH0/b9WYVCoVAoFAqFQqFQHP9MuRqjQqFQHA46OiSefkbiY/8lUFws8NLLwD33Sjz1e4HKSuCf/wIe/o2Gx34tkJsLrH5TorYW6OwCWlqBgX4gFue2rFYgP19iRiUwbx6wYrnAKScDHo84sgepUCgUCoVCcZwjpUQ8zvsxq1XdeykUiiOLErsUCsU7SiwmsfoNYP48YNYsgdEg8OzzwAXnA8XFwJLFwFe/ImBUk60oB5aeADz8iMSbbwJDesXgOXP42ZJiICeHN1ShkITPB7S2Af98Afjr3yRsNmDFconLPihwztmAzaZuvhQKhUKhUCimm1gMWP0msHghUFl5pFujUCje7SixS6FQvCMY4YixGPDd70v89/8Dvvh5gZr5wAvPCzgcFKFmVgnMrOJ3du+R+NOfJd5aA7hdwLnnAosWALm5wHvfwyjsr96kYe4cif+92gLAFLISCYmdu4C16yReeRX45p0SJcXAf34E+MiHAadTiV4KhUKhUCgU00XDXv7OyzuizVAoFAoASuxSKBTvAM88K7F95yi++Q0gK0vgsV8DVbqgZbEIOByZnx/wSTz4K4kXX+IN0+c/K3DF5aYHl0EyKTF3DlBZydc1TWLjJuCUlfTgOnEZcOIygS98TmLtOuCvT0v88iGJv/wV+NxngUsuVm72CoVCoVAoFNNBTjbgdgNer7q3UigURx4ldikUisNOLMbwxXhcwm4XmDVr8pugV1ZJ/PDHEpEI8D9XAp/4mJg055bVKvC/V5vvvbUGuPV2iR98T+CM083PWSwCZ54BnHmGQO12Cmnfu0/i2eeA224FqvfRHoVCoVAoFIrjBZ9PwuEAsrOn/96nqgoIh+ldr9JGKBSKI42qxqhQKKad0VGJ2+7Q8OYahi5+9D+Bn/8kB3b75Dc+gYDEt+7S8K27JGZWAb97VOALn7McUHL5M04HvnOnwGmn8v8310hs35FZoXHZUoFf/kzgrjsFunuAz35e4g9/kkgmVSVHhUKhUCimSiKhqiAfi2zeCqxdf3i2HY8Db70N9PQcnu0rFArFgaDELoVCMe04ncDgIH8AQIh9C1YNeyU+f5XE66uBq74g8IufClTNOPAngjabwAXnC1gsAlJKPPZbiYcelql8YQZCCFx4vsATvxU480zglw9JfP02iUBA3bQrFAqFQjEVXn0d2LT5SLdCcTSxew9/FxQc2XYoFAoFoMQuhUIxTSQSTCYfiTBU8Rc/Fbjsg/sXrF54UeKqa1iq+hc/FbjyE2Ja8mgJQQ+ub90uIITASEDit49LhMOmoJWfJ3D3ty24+UaBDRuBL1wt0dyiBC+FQqFQKKaCUSFZoQAoctXMwwF55SsUCsXhQoldCoViWqirp4fU66v5v8Wy7xsdKSUe/o2Ge+6VWLYUeOTXAksWT//NkcUCNLdIvPRvicd+J9HeLtHWlil6XfZBgZ/9WCAcAq66RmLzFiV4KRSK6edXv/oVFixYgHvuuQcAEI/H8YMf/ACXXnopli9fjrPPPhs333wzent7j3BLFQrF8c7adRIjI9N7vzOjEsgvAKJRdR+lUCiOPCpBvUKhOCRiMQmHg0LV7x4FZlfvX7CKx5kg/sV/A5d/CPjKl8VBJzLVNIktW4H2dqC9U6K9HejoAHp6mRjf4JMfB576vYDdDnzoIxIXnA986pOAywX86mGJefMEbr4ReOhh4Gs3S9x5B3DeOerJpEKhmB5qa2vx1FNPYcGCBanXIpEIdu3ahauvvhoLFy7EyMgIvvvd7+Lqq6/G008/fQRbq1AojncCo0B9A7Dy5OnbZiIBrFsPLKgBZlZN33YVCsW7i4EBicLC/afC2R9K7FIoFAdNY5PETV+XuOM2YPmJYkpCVyAgcdsdEpu3AFdfJfDx/z7whezPf5GQAP7rowJCsAJjKAS4XcCMGcC8ecA5ZwM5OQLZ2UBWFjC7GigrE4hGJb5xC/Dgw0BRocQF5ws0twCvvyEhJZCbC2RnAbffIfH1m4H/uEQJXgqF4tAIBoO46aabcPfdd+PBBx9MvZ6dnY3HHnss47O33347PvrRj6KrqwsVFRXvdFMViikxNhemQgEA23fwd1HhkW2HQqE4dhkdldiyDVix/NDXEiV2KRSKg6a4GJg/b2oL0dCQhhf+peHR3wEDA8Cd3xTYvUfipz+n2/vMmcCihUBWVqa41N4h8cabwN69Enfczsjr2h0Upih2Cfz0AaCoCFN6AuB0CnzgEoFzzpawWplX4s47gKYmlsles5ahmFIC936fIY9XX6UivhUKxcFz11134bzzzsOZZ56ZIXZNxOjoKIQQyMnJeYdap1AcOMnkkW6B4miktBQoKVY5uxQKxcFjXF+0abjOKLFLoVAcMK2tEjNmADnZAt//7uQ3NF3dEqtepdfU7t1+AMyh9aP7BU4+SeD3f5To7AJCIZl675Mfl/jgfwj88wWKTs0t3Nb8efycxyNw17dERk6whQsP/KYqO9v8zl/+JrFuHfDHJ4GLLrTgK1+WeO7vEo88Bvz+j8DmLRoeflAcsiutQqF49/GPf/wDu3btwl//+tf9fjYajeL+++/HBz/4QWRlZe3zs/n5+dPVRMVRwLF2PmMxCa+XuQLy851HuDVHH0fz+fR6o6m/s7MtyM+3T9u28/IkBgclXC4Bt/v4uWc6ms+n4sBQ5/LoR0oNXm8cObk25OdbD2lbSuxSKBQHxIBP4gtXS3zkw8BVXxh/IyOlTIlCv3xQ4rXVFKqyswUSCYl77wZOPonvP/YbC6SUGBqm59bf/wms3wg88XsJIYDiIuALnwPef7FAaYm5r/0lvz9Qbv6aQFc3n0RqmsTeRuATH7Pg0v/Q8LmrmHx/4ybglJWZx6dQKBT7oru7G/fccw8effRROJ37FgTi8ThuuOEGSClx55137nfbfr9/mlqpONLk5+cfc+czEpEIBvn34GBQXRfTONrPZzBohqA6HYDfP33nLh7nfd+C+cDMmcfHmDjaz6di6qhzeWzg9/P6MjQEuJyTryNTES5VbI5CoTggigoFvnyNwEeuGL/4bN4i8cVrJJqaeSN19ZcEfvIAMOgH7Dbglz8VWHly5rIjhEAyAdz/APDKKmBwEPjcZwSu+19gwAf87nHgueclIpHDlx/EZhOYWcXjeeVV4MtfYUXGnBwLHvu1wJzZwO3fknji9xpuvlWmPNEUCoViX+zcuRM+nw9XXHEFFi9ejMWLF2P9+vV44oknsHjxYiR1X/14PI6vfOUr6OjowKOPPrpfry6F4kijaebficSRa4fi0JhujXLrNkAAKCmZ3u0qFIp3D0ZKSKnt+3NTQXl2KRSKKdHdLRFPADOrBC79YObdUXOLxIMPSaxZC5SVAoEAXx8dBe64E3A4gEcfy0V+3kjqO8mkREMDQxALC4Hly4FrrxE48wzAahUABM4+W+I3j0r87gnghRclrvtf4PzzDu+TwgvOA6QUWLGc/ycSwH33CnzxGok/PQXMnw/sx0FDoVAoAACnn346nn/++YzXbr31VsyZMwdf+MIXYLVaU0JXa2srHn/8cRVicRTgH5JobAROWjH9nsTHC+k5uxIJwD59kXCKY5iqGfxxudS8USgUB0dK7JqGbSnPLoVCMSW++32JW74hkUhkLj2/fVzi05+T2L6TYtXvHxc4cZnA9h0S190g4fECv/iZwJzZmTHXv/qNxLVfkRgeZljgrTdbcM7ZQhe6SFmpwO23WvDgzwXy8oDtOw6/R5XNJvC+9zA/l98v8cn/kXjlVeD73xWIxoBQiDf2Pp/Ezl3Kw0uhUExOVlYWampqMn48Hg/y8vJQU1ODRCKB6667Djt27MD999+PZDKJ/v5+9Pf3IxaLHenmv2vZvRvwDwGRyJFuydGL8uxSTERpKfOvhkISUkp0dEhomrpXUigUU8e4vkxH0V/l2aVQKKbErbcIDA5SDErHYgEuuRi4+iqB3Fy+t3GTxNdvkygtAX78Q4HiYr4+PCwRDgNlZQJXfEhg8UJgKgXHlp4g8OsHzRvqzVsk2tqBD126/+qLh0JWFnDZpcBZZ9Kj7Vu3A7feLvGTn0sER4E33gK+/13glJXqCaZCoThwenp6sGrVKgDAhz70oYz3Hn/8cZx22mlHolkKxX5JF7uUlKEwiMWAbduZq9XrAXbXAcICVFYc6ZYpFIpjhZQ+rsQuhUJxONE0ibfWAGefBVSUC1SU82ndz34hsfJkgYsuFLjyE4AQppPom29JfPNOiepZwAM/EMjPpxD00stR3HW3xOxq4Kc/EigrEygrm3pbrFYBq+4c9u+XJZ7/B/D6auCWm+gBdjiw2wW++Hlz2zt2Slx0IfDc88BXvwK0dwBfv03igR8AJy5TgpdCodg/TzzxROrvGTNmoK6u7gi2RqE4OJLpuVSU2qXQqd3O1BXlZUgVMPB4jmybFArFsYWcRs8uFcaoUCgm5eVV9GTavIX/79kj8dkvSvzjBaC3j6+le1a99LLEbd+UWFBDQSs/X2BkROKbd2q44WujKC0BvvLlQxeFbr5R4JYbBXbuAq78tMTf/u/wu8lHoxIbNwGlJcDJJwG/fAi4/lqgvBy46esSe/aou32FQqE4HlCFBfePltz/ZxTvPmbNBBYvBJxOkfL+syprU6FQHADaNObsUp5dCoViUt5zIeD1MFn7k3+Q+PUjEkVFwM9+LDI8maSUePIPwK9+LXHyScC9dwt4PAI7dkp86y6JwUHghus9+NCl4XFhkAeDEAKXfhA49VTg/gckfvQTibJSgbPOPORNT4rTKfCLn/KJ5dAQ8D+fk/jeD4D77gVuvAX42s0SDz8IVFYqK0mhUCiOB6bjqfLxyqDf/Fv107HLdAu7xcVATw8QCEgM6zWJBv1TS1mhUCgOjr4+CbcbyM4+PmwQ5dmlUCgOK23tEoODEhaLwFlnCmzfATz0sMT55wK//U2m0JVISHz/BxK/+rXExe8D7v++gMsF/OFPEv97nYTNCjz0C4HPf9Y9LUJXOqUlAvfdK/Cj+1nFEQB27hqfRH+6cLkELBYen8UCdHQAv3kMeOAHvGG86esSIwF1169QKBTHNMeHvXDY0DSJ9g7zfyV2HbtMt9gVjQI7dgH9A6b3nypoqlAcXrZtB9auP9KtmD5SKbu08e+1d0j09k39oqPELoVCkYGUEnfcyQTz/f1cZU5cJvDQLwTuvENkPDUYHZW46esSf/8n8NlPC9x+q0A4zDxWv3xI4rxzgUceFlhQc/judIQQOGUlqycODrIC5Kc/L/H6alYCOhx4PAJXfkLgwx8GXlkF7NgpcO89Aj09wO13SMTj6s5foVAojnWUiDMx2gQGyJEkHpf49yt8SKc4stRuZ2L6qhlAYSFfs9uPbJsUh4fRUYlYTM05xfST8uya4L09dVxnpooSuxQKRQZCCHzj68DChcB/fRzYvoNLzQlLREZ+rp5eiWu+LLFlK3DbrQKf/TTf37AR2LgRuPEGgW/fIZCV9c490isoEPjOndzfbXdIfOFLEm+tOTz5vP7zCoHrrxVYfiJw3w8lsrMlbv26wOYtwEsvT/vuFAqFQvEOcaw5omha5sOdaFQimXznjNAjbe6O6onQO7umZ3vh8OHPA3qkOFwPAQ3mzAEWLmCBH6eTr4lpsjaHhiT2Nh6f5+VY5O11wNp1R7oViuORVM4uFcaoUCimk55eiVBI4ndPAE//H3DuucC8ueM/t2OnxFXXSPT1s+LiJRczET0AXHShwFN/ELj8Q5ni2DvFmWcI/O4Rgdu/ITA8Anzjm8wZBvAGdjqxWgU+/xm67d94C3DRBcCvfinwgfdP624UCoVCcQQ42jy7IpGJG/TKq3zabbD6TaQKyxwODme/JBIH7pXtdvG34Ul0KPj9Em+uAdrbD31bRyNju3a6b9OKCgWCIWB4WKZEyOlSQzdsAppbpmdbUh6/guY7STR2pFsw/fj9Ek1NamwcSbRpzNmlEtQrFAoAQMNeekIVFAA+H/CV6wQ+8uHMaotSSjz7HPDjn0mUlgA/eUCgepbAuvUSt39L4kf30wOsuPjIPhe3WgXe/z4m2N9TBxQVsT033CgRDEosXQosXihQXQ3MrAJycjLbm0xKxONALA7YbYDbLRCPS3R26bknBOCw88Z6+XILPvVJDY8/Cfz5r8B//z9uq7lFwmFXCesVCoXiWONorMbY0irRsBc46wwJj2d8Azs6gUULzf+Hhg9fWwwDpLREr8w8TXahlBKvvg4sqOG1+WDbdSg4ncCypUBhwaFvazqJRiVsNt7fHM0EgxJ76oC5s4GYLoR4vEe2TRPR3gHU1QPnnythtx/dfap4Z/H7gcZmeikqjgyptVyJXQqFYrqYNRM4ZSXjoH94n8DKkzMv/tGoxA9/JPHPfwFnngF88xtm/q7Fi4CL3wtUzzoSLZ8cm03ghCX8W0qJ975HYM3bEq+9Djz3PFfQSz8I3HKjQCIhcckHJWJxIJlWUv2qLwhc+Qmguwf45P9krrpCAN+8DfjC5wT21Ek89LBER4fEl/+Xnl6zq5mwX6FQKBRTJ5GQaGoG5s6Z3LgfGZEIBoHy8sO3xm7YJCElcNEFR34dLywAkrMnz3/kGPN6ednha4thiBwuUTCRMP+ORvmgac7syXcWjvC3zwdUVhzavj0eAY/n0LZxOHj9DYnsLOCM0w+t0w+3V17tdom8XIFZs4DGJsBmBXKmqUJcTjYwEpiWTSEvl5ELVuv0bO9YY3BQIpnEIT2cXr4MqVDV44meXv7WNBbqUrzzGOvUdCxXSuxSKN7lSCnh80kUFVlw372Ab5Bu6Ol0d0vc9i2Jhgbg858V+NQngXgceOQxDZ/4GEWvG796dF8QhKCn2kc+LCClRFc30NYGZGfz/WQS+PDlgMPBXBN2O/82xLKiQuCuOwWkZOLEaAzo6+PNkhACZ5wusX4D8MxzwN5G4APvB/7jA0fscBUKheKYpa0NaG0DXK7JPXzWbeDv8vLp378h4owGAPdRInxkZ4vU9SodI+SvKq2fLJb9G6F9fRLNLcCK5YDDcXDXb6OfpktAoSe5zLBwarfTS62kWE6aA9SqJ2WZDuEiEJCoq+fDqkL9Xqitna+dezbgdE6tr4JBCSEwoRfeweBy0ggPhSb27Nsf0ShTOuTkShyurHSvvs4KjKefRpE6mZTQtOkTDYqLKXZJKQ85TUY4AnR2AhXlx65g09YmISxA1YwD74tNepjzey86+P0f6SiOw0U4zN9HWxj7dFLfwLm5cMHReQ73Fcb43osOrM1K7FIo3uXc+R2JV18DfvqAhuXLLSgak/Ni/QaJO7/Dp9v3fU/gjNME/EMS37hdYsdOoGY+cM7ZR6TpB40QApUVmU+AnU6Ba740+QLq8QhceP7k2/zwhwT6+yX+8CeGk+zYCTz3PPDEbzUMDQnMnHl0XlAUCoXiaCURn/y9xQvNxOTTzXSLONOBf0iip4cPWNLDribyssrPG+/pNZadu4BEkqFmDseBteVweXYZuT+bW4CyMoo6hpfXvvZliBW5OYfehtY2wD8E5A+bOcC69MT3sdjUhZE9dTTYTll56G0CgPx8gWiMDxoPhsAosGMXsHTJ9LRnMixWgUE/Ba5wmImmu3sO3eMOAGJR/pby0Mee1QpkZR2dIctTpa6Bv6tmTO92B3wSAqbYOxmvr5YoLwdq5h9YJ3Z0SDQ2AWedyQiM45FkUiIQALxeHJVhskNDTNVytJLy7Jqg8m8yyQcJUxXQVYJ6heJdipQSv35Ewyur+LSspibzfU2TePxJia/dLFFSDPzmVxS6WluZnL6+Abj72wLnnH30LeJHAptN4OqrBE4+iTfEn/gYcNIK4OcPAtdeL/GvFzUkEkeR5aRQKBTTTH+/xODgoa9zhodOekj5WCorBRbUTP/1R0qJxkaJ4WF5xKsMptPczAcpo6MTv9/SYv4dDALB0L63t2wpw5AOpWKyZZqtCEPI0STw1tv8eyrCWkqcnIY2zJ0DnH4qMHeOucOcHI6HAwlvHPRPb960kQDbYDtINwWXLtId7oTi4bDE3kZGCaTm7xRPTDIp93mf1N6pb24aTvTwMDAwcPBejcczW7YCm7fu/3OxOMXhA6WrG6mUIQMDEjt2Hk0rrcmhjLNQiAUV/P7JP9PZKfHvV8aP+WhUIhA4vH2yYjlw2imHto2RgEQsNnE7NY05kg8WQ+SaaAurXmNRlqmixC6F4l2IlBI//yWrLn7oUuDPfxDweMzlYHRU4rZvSjz8G4n3vRd46BcClRUCm7dIXPW/EpEw8POfCJx3rrpJSEcIgZtvFEgmgX/8k4l7P/oRut3ffS/wmc8fvRd1hUKhOFQam5j4+VBJ6je6eXmTf2Z4WKKl9cAr902FsbkbjwYWLaQ3W1ZW5uvG4dvTvLNCYYnOrn33S2HhwReTMUJMROp/ifoGCb//0M5FPC1XV4UenqpNQewK6h5+/f2HtHsALEiTPSbHVFc30NHBystHgrp6DevWA23t5tw4UFwuYOkJ9PpLZ6qeTT6fRDI58fn1+czKhh2dQHERRcMFCw6sjWvXMRRyMoyiAdMx5YuLgIUH2D7F9LD0BCN8ml6c3T1HukWZzJ936Nswcivuy/u4Ta/4GovxemZUgFz9JrB2/aG3YV9090z+4GSqrFvPn4mobwDWrKVwdzAY6/5kc93jnvq2lNilULwLWfUq8NRfgOUnAjd+VWQkAG5rk/ji1RJr1gI3XC9w+60CLpfAP1+QuOFGenk9/KDAooVK6JqIygqBL35eYGgYuOxSYP48C774efbV4CBw9bUSv3hQm/RpiEKhULzTBINTf5KcSEzufbF48fQYkIkEvbv2Jcas3wg07N23KDUywifnRnjcVBBCIBajsFFViXGh/UcKt1ugslJMGBLjsLPIjEF3D7B9B/Z5TgMBiTfelOjtO4Rrkd4UTaOHx6EKnck0scvw7tOmIDoaHmbTca4GBjS8vTazX3JzmDtOWI7MdbutjeLfvDlmhcMDJRRiWPDB5KcKBCQ2b2U+0rH4h/heUzP/n1Fp5jJ16gLsVMWpUHjf769Yznw90xH6Fo3yeA7F+0RxcLjdAkWFAkII5OayiMHRhMPJAgaHgt3O60d+HhCLScTj+x5n6zeyAuQ7xbZaie07Dn07kUkeABgebQf70Gh/ObvOOnPqa4ASuxSKdyHnniOxRDdK0pN8vrlG4gtXS4yOAj/9kdCTuQO/+o2G735f4uSTgF/+TKCsTAld++I/rwAWLQJ+8SDQ368hFJI4YQmfyF78PuCPTwFfvenweCQoFArFgVLfAOzaPbXPbtnKpOFjGR2VWLeeXjCHSiIBWAT2GdK0dAmwoGbfOV8CeuW23XsObP9C8Ca7ulpgxfKj43o3MCCxddt4odFqpZd1epLqyBQSLO/YRUNloqPbvEViw0bzy1JOfL0ybh8Mb6MB35QOZVLSqzB26+MoVYF+H8ditONQqygGAhLP/R3o6JSorWV15ZGARDQmkJ0jEIlMbSxM5gF10AiBwkIBt0ccdKxmbx+wu268WDYVzy5DhIpExr9nbC+kh8263QI9vcz71KN77EylyaHQ/j/l94//XCIh0XoQHp4WC5Cfj4MOC1UcPG1tfAgRi0nEYswdeFSl+ZBATs6h5ROLx5kiJicHeP0N4LXV+9idNNfhqfZDW7uEf2j8Z6cyD9raOTcjkX1/NhLhGngwpLx/D7ILU4cxwe6DQXlAHmNK7FIo3iUkkxI/+ZmGjg4Ju92Ch37BHFMAQxB++7jE178hMXMm83OduIzv/etF4IkngcsvA+67VxxSfo93C1arwK03CYyMAPc/wP675BI+tfb5gPu+B/znFeKQqwkpFArFdDDgY7j1VKARMP51ozriRAllD5QFNUzsu3HT5J8pKxOYWZW5ho4EJNZvMMOtDO+gA/GGoecaDet+3yF6Pk0jbe1A/wATjY9lw0aJnbvMdqZC3fZxiVkwH1h5MlBSMv5DvsHMfFPrNwCvrDL/NwwRS5pnV/r/B4s3LUQzoXsETGU8GfsPTyDGHAijo0B5GUPwIAS21lLA7eyQ2L5DTirIDA1lvicEkJ014UcPiM1bJPY2SlTPkmhvZ+Xsg71tMBLEDwwc+Hejer/uq5BBqoLpKKt8Dg+bwvdUvGTsdo7J5csm/8ymLczlli4INDYB9XuBvgMMYe3v5xifanXNdxM52QzzPFz09pl/Dw3xd3g/Xn0TEYtxTkw3Q0NICbUHi8/HvGfpAv6+MK6pU/WEamjgPsYyle8PDdETeOnSfX9uyzYK5PvzSpuIfXlmTYVUgvoJ3luzlqGeU0Xp2QrFuwApJe7/kcTzfwd6eiS++hWGh1itjKf+zj0Sr60GPvB+4Gs3CDidIlXa+X3vZSXC886FEmcOgDlzBP7roxJ/fAq4+9vAeedaICBx3/0S55wtcMXl7Mu/Pi0RDAKf+qTqX4VCMT10d0vsqQPOPGP6jblkkobsWAryKZpNlJTbuJ5MBSkpNlXP2veNu39Ior8fmF1tVruqqwOGR+jRlZdn5v04EIybdE0Cu3YB2dnAey868O1MN0sWs2+9Y7yXEgmJoWFgZISfkZIl5UuK9y0UFRRMfj4KCzL7fqwQmjJgDM8uo2LiIT5Cj0bpwVZUJFIhiVM5h8Y56+8/9Mp0NrtIhfrF9bA/I+/OZP25YRPgdgFnn8X/LRaBqhmHnovIN8ifmVVIneODNR6dToYB2m0Amg7su/sqdjC2Pd3d7Ie5c1ihuqQY43KgTYTdLjBz5uTva2kDQUs7D8Y4PdB+qagACgomf39wUMLl4v3v0cDeRoniIiA39/C3x2KZWvGJ0049uBDEpSfQS9DhELDbJcKRqYtC6eypo3D2ngvN68vIiITVKmGzCdhsyEjTMlW6eyi2x+PyoCspFuliYWdn5uvbaiVycoDZ1ZnbNfp7qv0ws8osOpGONoWHA9GoRF///iu7GtWQJ9rm/jzIDubam7n9zN+HgvLsUijeBTz8GwpdH/kwn5QbCUADAYmv3iSx+k3g+i8L3HoLha6WVolrr5fo6+MF4/zzlBfSwfDpTwkUFwO/fZwGyby5DB/95UMSnZ10u2/YK/HrRyTu+d6+qxApFArFVHG7gZKSqVfLm1k1daNlZhUrzY5l6Qk0fpaekPm6lBIvrwIaGqa2vtXVA3/7P4nhEd6QTxSqAfBa1tq2b6+tg7lRltL0Ulm0kGLa0YDTKVBaIiatHpduXFitPPf7ys80MiLxyqu8Fo3FCOOcjJRnlz6+DGPIeohWxc5dEgM+YKDf9GCSU/AQMNpRXjb5Z0KhyROspxMISGzbxqqiRhsqyoE5syfvz+XLgBOWmP/HYhI2+/i5MBWiUZ4XI8+clBKtrcz/M28u9umtty/6+oB4bLz4PZVbOyN8cd/GsUQkwugAI8G3prF4wFRylEajEg0NEm3tE3/WEAEWLsisoFhSzN8HkrAa4LGsWy/x7HPahLntDC+yydAO1Zo/QJpbmNfpcBONSmRlTe3akZMtEI1mrtFGnsTdeybvH5dLIC+P53DxIr62P+FlImZXAycsznxQvG4DQwZXv8kxfzAkDlJATcfpFKielVlkJRTSr2kTVGg0vJDXrJ3a9oeGJ04wPxWxy2GnJ+T+KmkaY2Cih07724+xbk+lPROhHeL301Fil0JxnPPHpySe+D1wxeXAV64TeOJ3Av95BfMpXPsViV27gbu+JfDRj5iClpR0c53o6b1i6ng8Al/5skDDXhpv9/+IhpnNRsFRCIGv3yRw1RcE/vUi8I3b5X5j6BUKhWJ/JBIMIZpqaIjNZt7gG/T3S7RPkK9jx87xiaoTCYlXX2dlprEV6wyDwag8tT8GfPTMamsHWtvkpOEkJy7lj9c7ubUuNcOrbGr7HkthgcC8uUfHg57ubol168cnOrbZBHJzMpOzz5tLccTlGt/20VGJ7m6JbbX0ALPZx+9rwEcPudQ+xgihYxy74PUKOByHniC+s5NGb3cvUuGjYzWFREJOKjRMJkZpmsRbb3PsTvSeIYIJCw3ReDJTRLXZBbxeASknHgvFxabxDlAwq91u5rE6ECIRGnhGnqxkEhAWgbx8AadLIC+XY2F/1TbH0twi8cc/S/T0HPg9hmHsTihI6JtraWXBCLudc7e3TyKZpFdY9xTy+I2MAC1tDMl9e+34HFxGG6xjRflDmJ42O9vbf4ChnV3dEq+8CoTDR8/9WjLJ9fpQc8GufpMVNR0Oerdt2DjxNjWNotbGzZnh5oZAsq+Q1+YWfjcalamqhfED8OyKx/lwODtboLx8/AAw2nAg25yIQ+nK4WGJvNzxHrSVFUDNfP0fwetTdzedC6ZKMilRUEDvxPHv7f/7M2YI5Oftv7qsZR8PwPbXN/urprg/pjOlsRK7FIrjmGSSF6qLLqRbuRACZaUC3d3ANV+W6OoC7v8+PbcAYOs2XtRmVws8/pjA/PlHx03+scw5ZzOU6JHHgK9dz8T/T/5W4JMfZ98KIXDlJwRuuVFg7Xrgxlsmv5FXKBSKqeDxMO/VVCuvGZXU0r1Lt9YyTGQsJSW8oU5fp4Rg6BsADI55ai0ltzuZh9ZYBBgGnuVlWFrhJKFGJSViXL6p/Hz+No5bgqGNu+umvqame3a1ttH7NhRizqb9eQaNBCRaWg/P+t3Xz3DCdBHKoL/fzBklBPvO5R6fKH1PncQzz0ns2EWvtdNPBUonyNk1luLiTM+ZeJz90dZheB8Bp50CzJ27/+MYHZ08z076q2Of6BvGz6uvA1u3TfzeZHnnjPcnyle1aTOw6jX+7fHQEP3AxcwJZ+TR8bh5vJNV7nvtdYkdO8e/t3HzgSfezs0VeO9FvFcDKGbOrpZoaZHo6+UY3LGLBSUO5F6hSg8R3LHrgJoDwPSq2pf3TVkZPesMoTo4uu+8O2MxDiUYZNjo2POfSEiEQxJbt2Ympx7o33/bJqKzi6KI3SGQk5353v7meb++z4k8a44UAz6u19P1kNrlpDg8NDyx9+xkYkRWFsfv3DmTryvp89Dwvtq1e2oegADn7M5dTMuSXm03keA6aLEw3Ptgiw9MR3XIjk4WRkmfox6PwOJFmbmPR0eZF2uynHNvvqXhV7/W0NOblpMxCTQ3UyAey1Q8oZJJCl4nn7TvtT/lNTlBKO/+xKiUR+7+mzMhh5rzKx0ldikUxzFWq8D37hE4+STgqzcBO3YyZOHa6yVCQeBnP+Jip2kSDz2s4drrGW5ifFdx6AghcMN1Askk8NRfmbsiPx+o3S5Rn+ayf+kHBe7+tsAl7xewHGqWX4VC8a6moxNoapo4X1cyOV540jSJtrbJE3Cn47Azj1C6cWm1Cpy0QqAgf3zoiBD0lpESB1RByW4H5s0dL2gZ+P0UGNLbvHsPn5Ib3h9S8ul+bD9PsNNJv7lubaPHyrZaXjsHfMydM1k/rVtP75bDwZLFwMkrMM4wj8cl6hpMwVJKif4BYO06JjCOREwvoPYOMyF0VpaYNJdSSTGQlZZgfWRkjJegfviG51JgVKK+YWr5Ztrambh5QtK6NeX9MAGBSUStwcGJX9c0PsibSBsycsxJKZGTLXDO2RYUF1v01wCpyZSoMVFoV3OLpLdcmgdi+m4O1FhLJHhfkC6sVZQDdgfnXfp+pprMGmCurrlzppYsHmDutLY2mbGfsd6fBvG4RCwKFBUJ9PYBZaUUrM88g+9PpQ80fdvl5RRLjHvQzk6JN99ibtO9TRSp0o/7YG3h6lnA/Lls3FjPT6uVbXjPhRN/1/j84XgumUhIDAxI7N2r4d+vZHpy2vch3mRnMazP5ZqedkSiDIefjEMRIZYtBc44jdcnIx8eQLGrvmH/D0aqqzknmlv5vzEv6xtYsCCRAE5cBuTnTR4WG41O/t6+1p6pMm8uEI2N94Leuk1mhPQ7nQz7XX7ixNtJahTtenvN1xwOgblzJxEhp9C22u0SXV0Syf0I8XYbH3JomsSePZki8/5EtZRn10GGIaqcXQqFYp90dEh89SYNAwMSDofAB94v8O1vCeTlSXz5Bol4nB5GCxcKRKMS37pL4sk/MNTxgvOOdOuPP8rLBT79KYFVrwLrN0j8/o/AtddJfO1miQd/Za7k554j8B+X8C5q4yaJ4WHl4aVQHE/86le/woIFC3DPPfekXnvppZfwuc99DqeddhoWLFiA3bt3H9I+YjEJISTKyib2UKirZ9hJumAzMkyPoakINbm5wFljEt8zKbrEyScJrDx5bOJdgepZDPOainEuJb2junuAxqbJDZ+Nm2n4R9Nu+BsbgS1b6T3Eje1/f+P3n/4PfzXspZgUCLDSXGcXQ3wGBzN3YDwJN4hGpdmWQ8RmEygoGJ+zS9NYOc3r5f/JJA0+CSbXf/kVib/8TSKe0DKOz++nV8RUPNGCIbMrIxFTTMzNNl5jouipJGTv7OLviTyeJEyvirHPfIx226xAeXnme4Yn32ShU1u30UslHpfYvGXi/JixGN9/6WUNzz6nob+fHiK769jH8+cynHFoyPTwi8Uk9jZSmD3tlPFtBQ4858zAAOeoUbEuEpFYvwGoLKcB7Uw7xgPZdnsHBWqbbWoP0/bUAXUN/DsVxjiJh09dHT3uenslqmdRLBgcpBg9Vc82wziORjNDulwuemwax5rlzfxeaQl/7yvkyqC+gWO+t48hvFu20bNmMhFvsly1hrgyHZVnx9LTw3Y1Nhlt4G+PGyjcR5iww8G+MMICD5XhYcDuoNi2v3GWPvYHBjQ8+LCGtesm/5LTOXFl93icDxgMQX4y/H6OzyWLgZUnIbWtuXM4R5JJ5r7aU8+5FInwAUVHWlj+tlrzvbG43RRsp5rzcrJjXDA/M7S7uYUPItI9rh0OgcoKMWHIOQAsWSwwc6YYJ/qEQmbhiIww0ylMtxkz6MXaP5C5z2Qyc74WFfEa0t4u0a57qqV2M8XL2sGKVcqzS6FQTEogIHHzrXzKGgpJhMNMMr9kMXD9V1lC+ic/EpgzR2BwUOLLX5F47XXgumsFbrheTPlGSHFg/Pf/Y6nfB34s8cEPSNz5LYF77xb4xi3j+zsQkLj9DomvfE0JXgrF8UJtbS2eeuopLFiwIOP1UCiEFStW4MYbb5yW/WzawpvS9g7APzT+faOCU/qNvF03oLPHeA3t2iXR3JK5Bm3fMf5p9ego8MqrmDTviN/PtWxqYhc9d6JRhqVNlu9nxYk0dPL1XEnJJD13cnJMLyRNUgiaLBRyX3i9aQKLjZ4OkQgTIleUs583bcn8jsORKUZ0dgFvrxtfuSqRkFMO2TFoa6eHy1jvOCmZ9yY9ZKe8jIUE3G6B7GwaDmPDSoz8VRN5b/T1Z4ZozZ0DzJ0NtLRKvPGWWZ3QqL5oGCY+39SPZ8KxIM32GcZ+2lvclxyfpsnjERCY+FgSCZkKe+zsBN5eK/Gvl8w+NMS1UAjo7pGoq6MRmUyyT91u5j5zuQWiEYkNmxhyBZjejdnZAjk5LO4Ti8kMg/NAjbWI7oVo9I+mAfGEAISA3SEyEl4fiGdXny5GhqfoXRmOmH8n0toyEVIC4RDHjcVCYbi9Qz+HcvI+MMLPAHN8dnQC27abXqAOB3+kBJaeIFBUnGn4CwvP4VTuXI1Kpm4XvX/KSgGHk/+nMzpKUWz7jokbnkrcfRjELmPezZoFLF5oipMu1749u3yDwNr1B5cnbiLicYZr2mwThwOmnwOP3q+NTQyxDYe5Dk9GYxP7NxSSGdsxHlyMFTTHEg5znuRkC+Tnm2fe6RRwu0VK9LYIVme12fjAYneduRbvS8AbGmZuuH1VYjS8RRubJvb0HfBJuN2ZObtyc4DqmcDMmSJjO/0+ida28fkYU/vRJCrSBP5oVMJmm7h4ylQE8IULLFi6RIwLeW1qBl5/w/xfSoYVp69FIwGJt9dJDE0xLcF05+w6mJx0SuxSKI4jEgmJO77NJ+Lf/Y7ACy8Bn/6cRE+vhhtvoRv4jx9gLH1zi8RV10g0NQP33i3w//5TVVw8nNjtAl+7QaCjE/i/Z4ELzxc4YYlALAZEo1qGkZidLXD3XQKtbcCNX59aaJFCoTh6CQaDuOmmm3D33XcjNzczjujyyy/HtddeizPOOGNa9hUK8kZ9QY2c0GgwhK10sctqpSGVIXZJiaQGNOzNXH+qq2kopq9LDgdDMYZHkAp9MojFJDo6Gb5mGM3d3ZOva8aNtcdNo2cyb4aiIhr+hmiUTPI7c2abHj7xuERpaaZxsT+Me+nCAlOzMF6bUUkPknFJsnWGhjM9zUpLWJFv7LW1vQN4c83EYZ2aNnHexqEhChBDYwyUZJLFCNLFKaPPolGJigpgySLA4TBD8wBg2TLg7DMnztnlsGeGu82ZzQdkRhUxw/PCp4cNGud1Kp4QRt9NJNTk5e0nGTpocLWMqSImpYTExAZSXz8Q0PtmeASoqsoUDVy6QBYKAy0t9Ga49D+Ys0sInnO3i8LHrj0UgHt6gTfelClhYfsOiTff0mhQ7wHy8gSqZ5rtTaepad9J4sdWtpQS0JISe/cy9Ch9e5N5JE3EySvYp8NDma/vN/eONEXqiT4rAeTmcV2YXc2Q145OChKdnRQaDO+rdLq7JdZtAHbt1rCtlvN05UksrMCiAfxcMMS1IxoDQkHm7UpvR2CEQlB6gYDJqKxkeGJODu+vIhG9suOYrxpieXpItqZJNDZp8Pm0lChxODy7Yvq4z8sVqKw0hXy/3xSV0onHJUb0apLd3RJbtx3a/aIx74MhfT7LiUWf9CXNqPDe1Ay0twNnnSGweNHki4GxjoxdR11OYMVyPV/kPqo5GuuOz8dQz6Zmfra/38itB+Tnsb8M0S07y2g3G16mV26dyBNudHT/uc9eeRV49XXaUNtqzde3bqOQV19PgS3dU6qgYHwu5JERYMd2PigYGwYeDktsqxUQlsxw/liMD4EMYfwAHbvQ0yPR28+8jekMDmauV4N+eqHl5gGtrRJOp4TU2D/pyf/3lTvwQLQpKSV27mII92RhjAcjnimxS6E4jnjwVxIbNgI33yiwbKnA6acKvOci4O7v8qbj+98VmD9PYMNGiS/9r0Q8AfzipwJnn6VErneCk1YIXPw+4Mk/AO0dzBfwiU9JfPaLwNdvy3QfXnmywD13CdTXA9/45oF7ASgUiqOHu+66C+eddx7OPPPMw74vYaFHUVfXxNX4Ojok6uolQmmVxIQAsnOAeFxg/QbmFKmsxIRVDLOyaKyE0nI4scy6QDg8PtFuesL3pH6DvGMXPZ4mwvCWcDiA6moxaQL1wUGJ5/4u8cKLUq/QR2+wrm7zhnjzZnowTRRKFYmwH8Y+KbZa0/JVjbnhFgKo3c59TITh1WVsc2iYnnBjQ2XychmCM1FOtdVvmMZjOksWM1yoID/zdatV0GjUd8Fk9TTk+/qB7i7+NkLvDOEhO4teEBPhcJihNskkvRfSBRrjHBnfNgykqTwvM0SciYSanByR6vuxXobG8bmc9FxLx8jVNZGBKiVQoHv2xeP0brek5SQ1hK94nB5UMyrNEKtIhKGxb68DEnEao8axR6LmWLfZmCAcoFhntwsUF9NzaKxB39gMbJ+gKqRBLCaxa7cpBktJAcRmo2jX0mJ+9kA8uywWgfnzxo+fiWhoYI669H3YrBMb0sb8djoZTtY/wPNzwhIWs6iomLhiqnH+e3vZj3Y7vRBb2oCODnPODQ3R86q4CBgaYZ6mDG+gaKYX2r6QkmuFlBLz51PY1DQJf1qut+YWia26eJEu3ra101Pt3y+bRTgONER1IsJhidffMM+3IfJ29ZjeT0IAs2dzjR5LXR2wdp2Ex01vn4mSlh8Ip6w0z5U5v8efeZtN4NyzM19770UCSxYzD1dj0+T3rCcuA845i+uf8WDC7eYYNwTG9s79t3X7Dl2M1dd3o0BFSytQWSHhdDCRfSxmzlspDQ8qCYdj4jWrt4/eq+nVNte8Pb4IxURedIZ36YnLOC7rG8z3pGQY9a7d3I4ABbmFC4CTT8K49VgIIMsrkeXNzOGXnS0wZ46Zx2ui0Pt9sWatRFOTHPfhsQU+LIJzQNMY+hiNss8B81oOAG+8Nfm+DkScCod5bd3baM6tsXOMfcK///3K1DZ+kHUKFArF0UY0KrFlK/BfHwUuuZgL5rKlwDPPMV/Ft+8QOHGZwJtrJG77psTsauC+eydP/qs4PFx7tcBbayQe+LHED+8DPvxhliL+3n3A756Q+NxnzPNxxukCt30duOseiVWvAe9/35Frt0KhODj+8Y9/YNeuXfjrX/86rdvNz8/HyIgGTQJ5uaZVlp0dRWWlhpkzbfBm2eAY81S+uycMIZKwCBfy83kb6PVG0NWVhNPpRCKZRL8PKCmywOGIIivLjvx8M8mIEBoueb/IMGCTSXpinHvOeC+mSETC4wkjntDg9bqRn2+F1xvVjyGzXGRraxKNTWFIKeFy21Ffn8RIwImeHolTVtowOiqRlcUiHmvWRtHfn0BlpQVZWS64XIAQQcRiGuwOD/LzbbA7QnA6NXR2WZCfn+kWsXZdHL5BDULYkZ+f+ey3uCiCpuYkysos8HotcLmScDo1CIsLXm8SNpsFXq827hhmzUogEk0iL88Bi0UgFkti7hwNhUWZ5yE3V2Ltujiys6yorLSmzicALD0hAU0idW7SKSoa9xLCYYnZsyJYtsyKrCw76vdG0dmVQFWlFdnZDgwHYhgJJOF2e+D1xmGzSZx2ih1JTWLN2iTmzLZi7lwrBvo1FBRY4HIJSEQxGuSxhUISvX0xvV8sCEc02O0CTmcMWdk2OBwCeTnM/5mba0F+/r6TBp10UhLbdySQnTW+3+32CGy2JJxOCY+H484YK7l5duTlWpCdHUNOjsjYj9MpUdcQQ0nx+P0HRpOomZ/Azl0JBEaSiMRsKCq0YnjYhupqK3Jy4ojFNXg8Vpy0HPjXSzE8/w8ayMXFFni9SQRGNfR1aVi82AGnMwmvl/twuzkOcnOSmFllRSQKZGVZEAxJQOTi9NMs43KsTTb2DeLxKGy2OIZHrPB6LUgkNWR7mddnNCjhzbKmxt5EfTgRmiaxrTYGh0NDbq6V7dPJysrss57eJFrb4wiGEvB67cjOdsDrjSE4KtHckkR2ths2G/e5rTaOxqYkigqT6OoG/EMCS0+w4IzTnfD5NCQSUcTiVtjtdmRlWdDTm4SUQHmZFVarhvaOOHJyDNHAjuaWBMLhKHq6Jdo73TjjNDtmzUqiqFCiqMiKspII8vOA3DwncnP04xZxuFwarFY7cnL23RfbdyTQ1p7EySfZkJ8n8EpzFC4X4PbYkJNjg9XKdcXIf+d0mOfJ7c6Bw5GA060hP8+KUBjIyrZOOE8PhFgsCbs9AYvVhvx8K5zOGLxeiWiUodTFxQ44HAL9AwmEw8Cc2eb+vN4oHM44hoYt2LLVguIiwO0B8vP3n6V+7DgMhSQiEQ1vr0ukjn/btjgqKq0AHMjPn9id1diON8sBLQkkkzHsqYujr8+ClSdP4Io2hlNP4Q/Atax2Rwxz51iwoMaKrKzM8ymlhBACXm8Ufr+G7CwLFiywoLlFw4wqG7KzJZzOCKJRYGutFTnZFni9QE6OHXUNCXi9EqEw0N6Rje5uDWWlFmRl2cY9dDDXHAe8eiXCxYuTev44a+ozFotkqHiOQH4+VbvTT+MPAJwhknC5BIaGqWD29VsRiSYxdw7PdVZ2DJqUqKmxo7UtidFgprJTXu5EV3cM22oTKC214+STzHnq8yUQj0vk59uRTEp4vVyjc3LNNSEcZn7Bsf3o9UQQi2kIhhyorjbH09IlCbR1JJGf74SmSbjdEkPDCUSjAi5XEm63BZGohNcLZGVZkUxy/p+wxDZuzBl9mJMztTUKALxZPI7qWTY0tSQhLHLc+gQAH7gE+McLU686o8QuheI4wekUePDnfIr4m0c1/WmvxL9fBq6+SuCiC7lgL10CXHYpcPUXxYTlZBWHl/x8gS99Abj/RxKrXhW46vM8B7W1Gh5/Ejj7LIkFNeZ5ed97BWbOBBbUHKkWKxSKg6W7uxv33HMPHn30UTidExu3B4vf70892XzvReaaEQoxSc6WrQAgUFGeuc7b7RqiUSAajcLv12+KQxpGg0B3dwTBID+/s19i0AeMjkbh95uPsN9cI5Gfx8S5Bv399IY47VTmUUknEmGeqWgU8PlicLmYB4THkPloPBSScNjoyRCLxuAbBP71YgT5+QL5+RJbtwlUlHPfC2uMp90CQ0NhuFwCDoeGeBzo7RkGIBAMcr+BAOD3Z94cj4ww3GVoiN5fM6voWQQALpeGggI9CXBQwOFgHqadu2JYMJ9eLHX144+hu5vb9PuDsFiYw6mzk2GAaUXHEApJDA4y8bbHL5Cfnw+/HttjhCAaoT4GTU0SrW3s4/RrdyCgITBKLySfT2B0lMfsHwL8/jAqyiUa9gL9/VEEgwLDwxJ+v8DuPXyuLwTQ0818PycuBUpKRMqLwO8PYXSUxzRrJvuxv1+isZFP+SPhKOJxAW81YBlgeIvfb3hFSTQ0SnR0MCT01FM41hx2iaoZFJOMzxo0NGipkMPu7ig6O4OpsbJ7F2CzA/0DPGczqzK/Gw5LRKLjtzk8JNHeLhEIAE4XUFgQR18fMOATyM0VqeMbHGTb+vro2edw6F5DYXo3CQswOJiApgHBIA3LwUGO5VBYoq2dHkwuJxAI5GLDxmFYT8W4ipfxuERpMft23XqJslJg1izzM9Eo56fTxWMJBSVsVp6TQIDVOI056hucWsL5RIJ90NHF4xBpcXsjI5l9tnYtq3fmZAOBQBQ+n0AwCHR0Sq4RPRFkeXku6+qlno8PaG3lfMnyAm+vDSEWY+6r3h5g9x6BeXMFVr9hrlehkITPJ7FhA/NTNTYJ7G2U6OvnNmQyjj//VWDxQolAQCCRlKisFOjuAYb8YWhJtnloiOfP5wOSyYn7oqNDYiTA4hrBIL30uoaA7GzOlS1bgG21DHFM96DRkjxP+fn5GB4eQTgskZdDj5xgUGDIP3687YvmFhY0uOgCpKpuh0Jsf1CfO1JKJOLAkiUSiYRAMMg52NdnVLY19xcM0lOtrw+AZPjo/HmAzxfKqOrtH5JwuzI9fdPnOEAvGU2TGd+LRDjXe3tDsIyJUY5GJVa/af5fWxtEUzPQ1cUQtPnzx6+5Bg0NEi1twIoTJTwe0xbp7GJfVJTTyzh9DUwkJF5fDZx4Is9hXT0f2peW8FzU1TEnWzRKL9/RUfZpbh5zU4WC9EbWknb09gUQiUi0tQtUzcA4W8jomyF/ELEo32vSPdVcujAWDNLrTtME7Lbx46CnR0JYuG1je3Ybjy03l8c2GmAuy5ZWFlaRMnO98PtDeHudhuZmoGpGJLWPQICh1HNmc7+9vRq2bOW5H/ILWPVzuG495+xFF2S2zeWWKLRKdHZGMu4PhkckQkHud/MWif4BjoeREYnNWxjSbeRI8w9xPYrHjHuEcMY+Un04tO/cZ+kkEjz/w8MMT47GKDin962UvHZGIobX6f7vq1QYo0JxjBONSvz8lxpGAhJOJ8MZ+geAnbskfv0IcPF7gSsul3jkMU1/8irwta9YlNB1BLnsUmDxIuBnv2ClrkRCIhShAXX3d8eHLC5cwHxqdfUST/xehTMqFMcKO3fuhM/nwxVXXIHFixdj8eLFWL9+PZ544gksXrwYyQOJQxpDV3dmaIOBAG+aF8yfOGTJsFkMB6xttRKJBHOaeDx8YJKTLdHUxHCd9Dwi0aiE1cKb/JERrl1NTRIej8SiBawkNzZ8JT2MMZHcd1hDWZlAiR5m5/Uw3C9HD2czusrIF1VQkBmGFwpJxGJsbzjMipNGeNu+9hkMMnG3kbB9JECDNOWgpt9cz5kDnLhUYtAv0d4x8QaNaoTG/iorgMWLx4cB7amjmFJWOv463NvHanFjCUfYf2OLDiSTDLvZsoXGgbHvSIQ5hUpK+JDL5aKws7cR2LUHOO1UifPOYc6usTm33C4gEZd4+RWZOv9eL4WFaBSp6JdUVTpJEe7EZebxbN4CrHqVOaw6Ooy2Msn+yIicMIQzHQngrbfN/9s7kcrN4xvMDPs3wlgnm05GBUiHncn23W6G6NBwknp4G8Nxuro45srKRCqEpqmR48TlypxTIwEeS3OLKeAmEhKhoISWlFjztllkxshHMzIiU/FhXu/4CpKpkNm0ENpkQuKll4H1mzJzs+1r+RgeNiuB2mwCp50qEAoBI0OTfwegMS4AlJZy/CaSHL8xPRdddKx+ITkmZ1bR+B4e5jzQNIZfxmITz7/OLu5H05jrqbGJgrIABTgjjK2lFejtZyqOpiaJkeHMnF1er1l0Y+y8kZJFmnbXcX8WAZy6kqJkUxPXPIdDZIRvpVdUTX8+ISX70eEE2vXxpElWH6yr19DXp2HLVjMccXBQors7sz1OJ9c1o/39/RKrXudY2bwVWLdeQ1kpK3MX5AsUFRphd0BPL8W6dLq7Jew2isnGOIqEmU8qPXfixk3AuvXjz8FYLBaRESJsbGFfifiHh3lOiov1nIaC53BfIuCwHmq5YSPn+Jq3JTZuknA5JVaezHm4YaOGV1bJVM7IUIiVY/v1czxnNsNld9dRzIxEeD6sFv7kZGfm45ql59Bb/WYc/kHm2pos2bnTQVE6vZpxUeH4aruGHZVeNGLzFoaf7qnjuE7Py1hQwHD/dEZGuE62tmbO56Ehbqe1lUJuelPjcT4MMT4fi3NexmKZgYkVFcDsWeOPj3NZYPbszNf7+5mLS0qJwgIzhNBIWRCNmlVybTbmyVuyZHyF4HT2kc4LHR1cEw2M/fT2mcdr/pap/IGbt/LYxxaWmAwldikUxzg//pnEU38B6vWnzEIIfOoTAtt3UOW/6WsCO3YKPP4k9Cf9iiONxSJw41cF/EPAbx5ltcycbODC84HmFuCRxya+Orz8isSvfi3x7PNK8FIojgVOP/10PP/883jmmWdSPyeccAIuvfRSPPPMM7BOlul8CuzcReHHSLxrYLHyJntoeOKcXbEof3z6U/O+fmA4wKfOsZjAhefzoUmqoqHGp9RSStTVUwDr7gWGhpkM+e11FINmzBCIRum90NJqrlE2/Wn2vLkUoibKc2OI/gCTtweDQHEJ8IFLzGpbAvTeMYQjn49CW2DEMIaYZyWZNEuyu/UomnRDIZmU2LTZFAoDuqFr3JQbifpb25CqJDfop3ERiwMv/ItCzr4w9heLMceXkUtqYEBi9RsS1bPYH0Z7arfHEQ6zY2q382csixYCZ55OT4Z4nB41AI11r4dGzp49aQZKiMe0ZSvFh2hUoqVFz/OihwM5HAL+IYn16yUqymVGAuyePm7T2N6u3cxZJIRpUBnVGDs75bj7C6OiYXrf+odoyP7+jxMn509/pWbeRD3L7/X1UZQyMDxADMEJMCu+JdOsraQGvP02EI0JaJL90tjE7ycSPM8SZrVJw4CORGlYLV4EFKcZvDt26GNBmknwfT7grbUx1DcAO3ebx65pzEcTCHCMS8mk4+m5yzRNon+Afxvbk1IvTDAEDPRn5srZl9i1fuP4vHgLF0wcCpuOUWDB7+c4TCbYN8ZSZYhdo6MSJcUUnuIJCp8uF9DQCJSVSixeBHzog4KC0QS3LBYLi2Xk5dPrJhX+rOfkMXK2dXVzjZs/j/OvfyAzD5qmmXkKjftgg5ZWFoIw2L6DAmQyKTF3ji6QpAkamiZx4jJ6eL33IpGRv8pIRr9nN1Bfx8+uXSfxt2eATZuBLduYt+2tt4E//VnDqtdYmTAQMCuoVpQLnHmGgFXPGdfYxCqWhpG/aQuTs3d0sCDBqte4dqQE0DF92N3DcbFsKQW/RQvMJPaGKB6Lca0zEt9PhqZJdHQy/9WuXRKxqExdW9LHXKo/9Db5fDxup4NJ4efP53zpnOSBAMAk9GefyTZpSYlgiO21WEVKGO/s4txpaeX/wRBQWWkKbx43Pdm8XoFFi5iXz3iwYrEwMX1+gdlWo18oYpki7ER6V00Nc7M9+rj5WkurOScHBpgIP5mUmFGZWXnSECRPP42egXvqjDZI7NipYfUbLMhg4PXyGpmVlVlkwZjbublAebnxoIHfKyhgzq7de/iZokKgZr4ueKYdT9UMFhYZy6BPoqNDQhuzfhi576Skt2llBb37jDVKSnrXVlWygEIyKREIyHE5MdMf7kgJbNjItTj9QX40KrFzt8zIf2nkT3S7x4tdb68FXnudc39GZWZ794cSuxSKY5hXVkk8/3fgf65kQvMX/iWxt1HDrbdL2KzAN2+jsXPKSoE/PSlw+mnKm+tooWa+wEc+DDz9DLCnTuKmrwp8/WYLLr8M+ONTGJcIEwC+9EWBs84EHviRxLr1SvBSKI52srKyUFNTk/Hj8XiQl5eHmhrGJg8NDWH37t1obGwEADQ3N2P37t3o7+/f16Zx/rk0Xg2PCwMBPvF2uSYWFGJxPjndsIH/O+xANEzvCSM0IxJhiB1A76ht27nm5OZKxKKsmgYp8PZaGlxdXXzyvnABIKVAw15zf3a7QEUFjd6JSqsDFFJY1UqivZ2GTiIBNDebSYLjcSaubWvnd7Zuo4Hg8dLASWoMTzKM7gvOY7VBekeY+woEKGq060ZVW7tEXx9DhwBklK6X0vSY6OkF+vu4/YkSEwM00rOyTGNc0+gNYCQtHtFDMzweiX+8IFFbq6GpGXjp5Rj+8jd+ZkENsHjh+G1bLMyTZrMxBHHjZhoVViuNs5Unm20GaPNITRdJfDQmJSjWaJIC1b9fkXjpJYkdO01xE6ARYQhIyTGP5tOjmSorzM/7BhmetGGjnHDcQW+P1cZt9I6pdBcMygxDbaItSMlE6aeekunlYhzznDnA3kYacoaRnO6ZGA5TTDCqHxuFA+J68vnsLLatvoFhe0ZDsrJ5bm02c74lkwy5C+lGeEEeX29qBpx2kUo0bogkRhuNfpWSIavp3glNzRyX0ajpWRiP85jz8/RqlRnC7QSdNAHhsMTuPfQQMubq2L4zaG6mt1B3N8d8LM7PGOfdOP516zkXNQloCXrv7dhJESInhyJNTy/7bKJzGQxK7N0LVM1ARtVYAWA0xLkGMDF9eRm9qirKBS6/zCwgAFCACIcBl0siJyezGMXYUODOLnoCDQ5yDdi0xfQyAvadcF6TFK5a201jPCuL54dVtc311uczk9ivXSfRplcPHRiQaE17EODzMTS5vgEYGTbH/+46U+Rxu83iErvrMttkt7Oa6Mgw237KSoEzTud7ff0MTfz9H3Uvpn252IBrjt1G0S4vj+e7opzvJSboF2PcJDXghBOAjZskNm2hgDsyAtTvndxzymrlw97GpkxPwZERhufNqNSvMQBOWMzfQlDMNjx/w2FgYQ1w0nKJxYsE5s3V2yTYFzt2pVXV7JepxOqJJLt5djXX1Ima6PXQMywepfAIsEBAkR5i3tzC334/x2t+Hv8PhSTmzqFQ6nIJLKgBZuoeZYkERdHa7fTEM44pkeAcGZso3+UCigolSkr4fmMzsGGT+b5F8DojpX7N7OTx1243vQtrt2v4+z/Gn7ykxuvBnvpJ1mkJNDVrWPUaH6rF9TkvNbY9K4uf6e3lOE1/yABkziMtyWqZwSA9TQ1v09Vv8tpUPcv8rOFJ6fWO9wgLhnjuhBBYtPDAbFkldikUxyi9fRI/eEBi6QnAZ/6H+Q9+/qDEbXfQHfYznwauuwF4ey1XjPJyJXQdbXz+swIFBcD9D5jlxM85mwv93ffKjBtSgDcI37pdYO484Jt3SuxtVIKXQnGss2rVKlx++eX44he/CAC44YYbcPnll+NPf/rTPr9ntwsERkXKE8PAeKrdsBfo0cPq/EPmenLB+TQejSTEDEegwebx0DMhHBGpEJCYXsFubyOfJLd3ssJfdg6wdCm9CjQJvLbarDKVjqZJ9PRK7NxF42YigzKoe2QVF9N4y8mmodLdI2GxMA+MIXIZ1cZOPgl4//sE3v8+C5xOgWSS7Sgs5LaGhtluj8c0RtramCcIMA3wPXUUXuIJtlVKmQoVs9pMg6+wAOjoFAyfKednQyGZIeAJQWPf8FLp7WN7DQ+7OXME3nMhX+vsYiW1llaKLobRNbNKoLJy/PW6rp7i1NCQhvZ2ibw8tlXTmAMqJ8esnGWQ1CiE2azcZ1ERPUA0DahroCFNY5o5yNIrufX20RMmMcarw+EwDV2PLuJFohQCWtrY74YHhEG64GOxcMylCzWDg8CatZkVPnft5m8jRC21LVBg3TPG8Ad4nM0tFAVys9k3TU3m+24PNzA6CgRGKOoaxBMUfmN6mKbNECyl7lEj6NGja9IZRroh8AA0Xju7tZQ3hG+Q48ToM2O+WiyCueSGzO1UzwJOOQnIzQHKyigItbRxLtjsFOMMb4xwmF5KkwmL6SSTFOWamihQGeG9AMWadE+Mxib2ofFSJCxTHjNWiyncappEt175VJNcJ4Z00WVPHdDSyiqeY8cPAHR2ati0md6Dr70OaDDClNjPXg+Qo4uZubkUUjs6JGZWMbw0nWhEoqtLIhzmcY0V/9PJ8vJcZWdzjBYVch00vH40je1uaGDesg0bzX6JxShaOR0UIjSNXkUXnse+2dtI0Wp4WKKggCIdwDFteK/U7qAIZJyz/gHTa0rTKIwYRzdrJnDyCp6711YDQ/7Jz3N9Iyvp/fsV5mgyPGQAM5RvovOQTnGxQF4e2+EbNCuAVpYDWSkPWdM7JyWqazyGljauIV3dFGKysyYPH9+zR+KZZ/m59FDRnh7OwUULRSrMOVUZFwI5OQKRCDPOtbVT8N+9m3nm4nHTs8vj4Vj16RVSd+5CyrNNavycXX+IYZlACWlrB6qrOfa6e7i2DQ+blRWNtSuRMEPuRgISb73NhydSstp6Ignkp3lrZWdT3M3N5TYBriOtbRw/Q0NmhyWTukewpKhVkM+w10CA17DePmDpCZyvTc1cg3t6KMAZD5s2bgba9Ic6xnVKSoniYoGyUl4fua/MEyUlj3XAx/lkPAjSJD2MG5uA9k4mqnc6zHsJg/RrUChMT7TSUoHmFpGxbhcUCMyfl56PyzxHWpLr99i2JZPsW6Py8VRQYpdCcYzy0MMUSL55G12iPR6BKz9Bdf997wUe/BUvNrOrj3RLFZPh9Qpcdy0X/2ef52vrN/JmrLs70/3ewOMRuO+7LM/+938osUuhONZ44okncNttt6X+v+KKK1BXVzfu58tf/vI+t/PvVyYWvIXgDfSCGubdAZizxXiybbcJ2Ozmk+RQmDfbkXC6N4kZ9qJpDOdyOmlMzqqiYdXawuTrAMUpmxXYvh1oackU6kMhPoABmNNrrAE0MiL1vEAM8zlxqWHoU5SoqKBxaSQZNoztvDwB3yBSBmlSzwdmEXxivGUrj1tKoKKCB1bXwHxVgBn+mR5GBtBYMDy3urqB19+gETESoCgVDNFAikZ5058eThcYpUdFJMq7/epZPA+Gx1x3t4bWVonde2i85BWIlPeDBNDdrWHnbi3lTZBOdxe30T8AOJwCQ0MCa95mvpdXXgPe0JNFpxuPXV0SPh9zafX0MkTIP0yD+ozTgKoZEhUVNNoslszvxnQxZ6IQJgMj3G/jRmBtWsjc0LApKobDpveMJnkO4/FMscsYa4Y3FGB6E5Sl5RACOC527KBxaWD8NeCjsWy30fju6so8P/EYhcqSYqCji8Z5ykMlAfQNUOCsrqaoIgQNr3CYRm1glPuKx3keqmZQKG5sNj1xpARKigSqq/n/tlp6dEhJwSKZYD40gN6T6V5NNptAdbXA/PkCiQS/43JSsBRgnxmGZDTK87Y/EQMAsrIETlohMDzCdqZ7PA0Ns40GlRUU5Ky6hRgK6yKCBaiqMo13m43Cp0VwTp6whOM9FOL8czrp2ZWdzXxe6bzxFkU+p4P9a4Q3Lz0BOO0UzntjDiYSbG9nF7C1VuK557UMUaCrm+LM4CDz402Uj1ZKiZ07JWw24ILz6XWzp87w3DQ/r+mekL5B9u/QsOmdFE8wVK6khAKApvE9w6OG+6FQ0tyc5gkXNc/RWE88KRl2DhiePALnncv/nS6KCL5Bbnw0zXsmHGZev64uoL2dYoTbTWFmzdtsq4HR97b9lKTbUyfhH2S78/M4j3bXcVuGWN/YJPGHpyTa2rXU9jSNYlJJEVBWyvl15plAuR4CNzYHrXEsoRCvO+kCd9UMeqj++xWZim4wHnKMjko0Nkp0dfM8nrSCYuXb67md9Rv0kFZBYTg3l//39srUww6jzwHeY8eiEnb7eA/oUIhzfmYVz/W27ewTI3zOyP/VP0Cv5w0bZerc1tVJvLyKawuLNshUP3k9QGGRwP89K/G3ZyjkDA8DfX18SJN+bTQStbd3cI7k5ws0t7CQSDxh9lswqOeC8+rjFWZuseqZSOVge201H14Y60dxscDSEwRaWxkuG4vJlMcZwJxoLifzZhpibdUMjo9YnGMuN1egpkaMK5IxNr9YLCYhNXreGuH7AMfxxk2mt5eRO2/Qz+PbuSvT8xLgXKqr5xrl2Hfh3xRK7FIojlFuuF7ge/fQrbulVaK1VcNvHuXNxkv/ZhLWX/5MjHsKpji6uOA8hmQ8/GsaB1/8nMDvHxf4wxMC73vPxOeuqEjgV7+gUKZQKN59tHfwztrtMsUfAymZhDwUNo2UpSfQYAaAnbsZ9pDu1VJQQGPL8OyJ6jmKCgspYnV186Y7meSNdUL3nAqFKaL5hykOxBMUBBqbxraJv7O848UuI5xNSj619Q2yilZ2FnD5ZQJ2m8CJywROPYVGkhF+2NfH0Mq6etNzRtO4f+OmWVhoOG/ZJjGgiy8uF8NM0pPDG0l3x+ZwMUKU4nEaLpEoje705MC+NC+ZinKGJr36mp7rJCGx6lWJx5+U2LxF4p//Al56mR4cBQX0jkl5CEmGuLz40vhwJQCIJSgulJcBvgEm9rXZgNmzBTxuJheW0gzdmVEJtLbTQ6qlVSISZnVNt5OiU1Kjwd/RqedVqzDHUlWl6dmULkCN/d8YL8kkXzfyoDU00IDLyTY9x4xjNLwv0vvZ8PyqmmGG+Nh0Q8ZMgq8bjUme372N4/vI7wecTgkhmFA9FMr0MgiM6O0XFMSMcDgpaURFInoIqt62RJxjP5mk+GPkxOnq5rHbrJwPwVE935eUiMaAQb9ElpfePS4XBRJNk2jvpBgajdHA7uwEEknTe6G/X+LlVayc2N+fKUgnkjQyjePJzQVWnIiMPGvpzJ9nnBtTTGUlTxrLyaRM9emAz/ye1cY2M0SK3jEuF3DKyTSok3p7E0mB005lzi2ng33jsNP4Li1hDqEZFTz2sbkDDVHV4+GcMsKgNGkIc0CpbrA3NLAfrTZ6nA34AKvVHDyGWNjXR+EnHSk5D43ca4FRhhImEhJVlRTiEnGZEv80zRyfhtiXPnaLi9lWQ7RvbGRo2eCgGZIGCQwOUTSTUiKpAbOrpV4lMNMryvhbgGOiqVmivsEYCwz16u3VPZHSDPueXq4V+fkUfIqLmU/u3LPH53CMRICKMoba7ov+fiAQpEdP7XbuT9OF3kiED1bqG3Qx0GeKhB0dRkgnxeFkgg8HgqN8UPD66vFi18qTKeo57Dz29nau4R6PSM1rI3edIbR0denzIA4sWQxUVgo4XQJzqtkPsRjno83KMTFvHsfXwADf8/kk6ut170HJfXu8wOur2c/JpCnQ9w+wgm1dA/e1bCm9pSL6Wl1eTg9fgGNzZASpNaNEf8B0zllcu/bUUUhsbeP8rauTGPBxLdpWyzFYUsKHIkZ+SgOHk+97s0zPLKOwybw5wBtvScyskjjtVIrURkigzUYhKanxwXhUf/jS1U1P5N5eei4aobiGF6IRpglQsHU4OP6cLmDpCQJFRQKr3+D7msY1bXh4vHdpMsn+3rVb4pVXgef/DmzcLPHCv8zw8vIyjhv/UFrIov7b6aQIWV6W+QAGyJw7jikWuFZil0JxjNHTyyclOdl8UtfeIfGZz0tc/zW+39IKnHIK8JMHREayQ8XRiRACX71eIBYDfv4gK1S5XAIlxcBbayS21cpx1c0APpWxWAQ6OiQe/JU2aW4EhUJx/FFfn8R7LuQNsiFuJBJ8Gi4lnzwLmOJDWalArh5mNaAbEaGQKSAkEhQQMpNl01goKKAAEQ7z5n00yKfqFosAdIGpro7GQlkZPbPOPtPcjiEgDQzQKBwbxji7mgaKlMDrb0js2cP8HJEIsHWbRN+ARFubxNAQRbhwmO3ephtkhYU0zGdWCTgdNGwK8oH3XMjXO7tpBHd1mWtkPJ6ZVNduZ18FQzLlJTS7mtWMl5/I950OPSeXh0+bDSEimWTVtZERiixdemhXOMKwz621NNJyc/XtOCm0bNzECop2O8UAI4ny4kVM4Jze1n+/woTyNhvX/QG9HzVJkaWwkF4Vs6vN/p0/j8ZLIqF7qsQoGCxdyu0PDDC0tKmJ/aRpaUKWQMpC8A+xCl4kLOF207gtyOcDNUNQcel5p5qa2d6yUnr6lJVR+CgsZOECKWmUpVekA9KKA9hNg9IQwIx+bmzik/5Ekh6Ls9K8hYxtLahhOOS27TTICwvNbdusFGWDQRrs4QjPnXHsiYTpudHRSYFQkzSuZ1bxeO16CKcxFlvbaQxWVADz59Iwd7kAr0dgYIAihM1KMdVuF1i4gEa208Htt3dIbN7ManSRCL1Wurq5nWCQ+eVGRoBt28z+MUTScJjC79AwJsS4+4vFAL+fCbWl5Lmz2ymCpgve7EeJk1YIrDyJxzE4SOFD09j+unqKIVYr8xF1dArMrubYrqunYFJaCqxYLtDXT8FicBCpYgrjkBzvK0+iN0pXF9Cwl2K8Udm0QhfMIOk99KFLBaIxFlYw3geYU8nhGL+vhr2mMNrXB6zbYAhmvF8eHjHHjyF2WSymx5Uxn+obKE50dQEzZnDOerycf0mNa4Pdxo4vLeE4lrowum4DRZ+BfoprGzcDb6+Tel5F3caXFLGMOWgIkIYHVbpnVnkZMHc2vWTmzuV4Ki4CZlQKnH12ZhcPDQFnnQ0sXiSwZ4/Ea69n9o9xDYhEgdEAHxBQIOH7gVGO8eYWoK2N42l2NVIh1LAY651EKESBaFst14m2doq7AM/Lv15kgvbRUQ2jo0BpGY9lZhVwwhJWP+3rp0eSkbOL50CisJBzvrxcwO1mLrLAiMTMWfQwkhJYuFBg7lwBmw3o6xOpYiPxOMd6NMbwOI9XwO1mcQCjNxr2ssrf6KhMrT052fSsswj2tVGJtbdPwj/EByl76oAFC8x0AoX5Zs6u+fOAWTMZYumwsx+tNq4zC/W8U1ZdMB8a4jU85emrXzc9bq4DLS18cGBcx202bm/rNgp2KQ9DyTFNzzDmKjPClru6WAGzehbgHwR27pIoLBRYfiJFxs1bWRnUGLfd3RyHxpjs6jI9vpNJzqe2dsMT0yxMwwdXerGYINfw0QA98Nrb+ZkTljD31oL5QE62yJhrdhvP1+AgPc4nQ3l2KRTHIdGoxE23SHzjm+bFqqKcN5UDA1wc3vce4Hv3ZJZkVxzdzJghcOUnBf79MpN8AsBfnwZu+YbEHd+W+PUjkwtZ69azstWTf3inWqtQKI40u/fEMTAgMRrkOh8ISHT3SCaL7wZycgSam6ELLxRLjNLzRlLxdC8mj4c30em5lXp6KaC43TR+GMZHzyYjNCw7m0++HQ5g1Wt8TZMC8TjblUhQsI/F6RUy0Upmswm4XIYXBn9brcxv09bOG+5XXgX+/g9+3sgPcvqpzNl14jLgtdelmfdKv9Hu79cFOiC147VrJbZskXhttRl2ZrWy/U3NrPhkfNZqpafQkB72l9AACIGKCl1M1C+xRjLkjk7mOzMQoCEyOEiPpeJieiOceYbA0JDuTSZ47c7JofhotQKFBQJFheb1O6CHeHR0UrAYHpaonkmDs78f2LWLidLtDoo7Hg+NKSlpkM+s0r0dPPTw8/tpeKzfSC8Qt4vH0ttrVo00QmcAelLZ7DSgwrqHUWEhBRMjEb/DSS8JY+wUFtLrJxCgkdzSQsEhFqeYWF1t5kIDzH21tZtePoboZeRRy81hX48M8/xmZ6fd48jMP2xWMyzTMKASST1XXRZg19vd08NvzKiksZ5I6F6NbvaLpvG8jwQoaGh6cusBH/veCC0zqhUODPD1kRGKVrEYj2NvE6tnWq16mHEMCAYFgkGKJaNBhvZt3UZhuXoWH1pqGvs2vRpiUaFAaxvFv96+8UnYDer3mkmsNT2v0o6dFC+ys9gXdnumh5eUwJatDH2dO4fnuWoGjd22NnrLdXcbxyzR3CzR0sy509tLAbGo0BSskkmmY9i0OXPmG+e4t49jxOVmQn+fj0Z7MGiKlDk5HBfhCAWCwkKBvXuRSvpuYIQvGwLeyIjEoJ/HaBQBsNq4puXlcsyVFFPQMEhqpvdVXZ2Eb8DMteb386e4hH0DMOy6ShddvV4zbLx6FgUv47ttbXpY5JCRIF8iOMqQVoedw9YIPezuoYfWWWfQE0/TMpOoa5qEy8UwWbud52brNt4zPv8Pnrt0b9+BQeCllzi3122QqN0+Vuxitd1duyjK26wUL1xus/Ko8RBkJGDMVY5di+B4lRLo0IWtAd0j0cjnZKyTRuGFvn4mwd+yjQLhngbTM669g9ea+fPTQuMk13aXSyAnl95je+rMvIfhkC4SwRTunE7A5ZSo3aFfA6z0cPK49WqCMziPjaq9AMcEwHXD4RR4z0UUt/79MvCvFyUiUbNK7t69HAvxONsRDpsFTgKj9J5q2MvvSF12LioCLv0P4JKLM72K3W6ex7oGVtPt7eWc7OmlV+PoKDA8xPkQDvM60dkl0dzCKA9DyLVYuPYY4Y1SmtfpRILCVyAARKICK08WqCjX87P56B3d0clCBjv1XImGZx1Awb+tXaKrJ20cJnmtYRVJjsGGvYBvUMOgX6ZyEfI6BLz/Yp4XY/R1d2vo7ZUoKeH9yeYtPIdaUmJPHcXz0SDX0MFB03ssvWBKet7EfbGfCF6FQnE08fBvuMAZ4WuaJrFug1ny+9L/AG78qlnWWHHs8ImPMbzl/h9J/O4R4IrLgXlzBQoLxucsSeeKDzMHzcO/kZg3FzjjdHXuFYrjndFR4LePs6rfeecKrF1venLwSarE/Pl8Ym6E4RiGebpIk56/JBqjUVlWZgpPbe00QOlNwhv7efMohLW3M4xOSoaRRCK8cfYN8ub4rDMFk0b7eZMuQK8BhhOa61R/P5MqezzAuWczh0hYDzvSNLbf46HosGypYeRIlJYItLQCr75GY6F2O0U1CRrQW2slRkYYgiFBQWt4hF5FgNkvixfRk/a112VKJALoDbVrF0Uk42l2NCIxPJLZH9EojaiRERptRqJkgE/fc7IpOtIwk2huZjuSGkOl+vrNNb6xiSFaxcU8d8PDwJo1FInsNhqXg37A6RJwgk/ajfNKjyUJh4PVJA0vcIeD7a3by7YNDfF8VVbwp6WFHlNSAsGQGVZphHGVl9NA7O6hB18iTkPEP8Q8Ntt38GALC+hdo2lAe5vEps38js9HQ/K9Fwl0dtLDwzCUABqoRk4jY6wBFFI1TWLjRhrZ5eWApZeGd08P93vO2ZnXOyO/T34+vY2ikUxPQpeLQk9uHtDno0GX7aWn9OurOV5ycoDly+nJNDjIEDipUbCYO5vnJRg0Q9YSkkUbjLxAkQjgcNH43NvIKo05uRRSt++kCOD1MvS0qIjndGYVx0hzC/t90UJdVBDMm1NYSGPS4WAFNaOAAjC5wbdwAeD1SrS2CRQVAcuWCrz0b4lQmGtBIsFz0Nhkhr5ZLAIOu8TmLcDMWcCJS1lFtbdPYmSYBv6OncDKlRr27OF21qzjfCsu5jzcu5dCZlc3DXOHk2M9nfSw5kQS2LlToqaG8zQvVxfxhnj+WfCBYt3AgMQfn5IM+dIjF3brOfgGBoHly3guAXpTART7hD6WZ1YB77mQXjd9/WyE3SFgszE08+WXoXsIsVIjPZokysrYX7EYz3lTM5CXJ1FQIJDUw187OvnAIBLhHCsvN4/T7gDOPEOgWfd86e3leR4JcN21O8yQYI8HcDpZICQSgZnzKs37bFSvbLdjJ9tUXMixMeBj7ryTlnNMAhQlhkeAt95maCwEkEzqg0s/FwUFFD8TureORQBvv00hpqLCDCW22bgmNeyVWLiA3nvd3Tzfc2azicWFXC8GBzkPQyF6/RgVcwGGONqtHEtZWczT1dEhMW8ez+u/X5GIRSUcTsG8iasBh0OipYV9vKeO7fJ6OS+cTnrbNTWzaIIQ3G9RIde8/DwJAYHcXMDjsaC4SGL1G1wjZs00i0sY/ZGVxbaVFHNutHUAZ53J9Y15tkxxGAA2bwb+8yP8u6GBYwHgmuhy8UPDIxTonU7gj1voNerWc1HG4xRIRwNmiPegn/seCejFFHThMRjiA46CAnPty8ujWGpUK3a5JKpnCZSVUZi1WAXa2ulhVl4m0dcvUFAosHgRva18g1zT8vPMeTdnNsdkXi63HR828oEyAsWbDeSERarvSkok3nyLgmD1zMxrYHGJKUIb6/Ef/8zjNwpKxGJI5e8zvMmsFh7v9h28TtptMqMScrpYuS+UZ5dCcYywfYfEn/8K/OcVLC/c0SHxsU9K3HkXL0wfugy46WtK6DpWcTgEbvoqEwj/5lFeTE5ZKTBnDp94hkISr7423i9CCIGbvyZQMx/49ndYpUShUBzfSEkjI5HkU2XAfKLb3Q28+ZaZfHtsUmQjrCRd7CoqYuiAlEDNPL3KnuSNb2DUDJGQQMpzysiftXMXDaT8PG6zrBSYNYvbdbuZcHrBfOac6ugA/vgnpBLSRqMylfNK6hvv62c+E+hGRzBIo2TuHLPk+SurmHB3y1aKPQsX0Og1Qi2HRvjZyso0Lwdpej4Z/3O/9OYwqu4ZfWIICk6HmfspEqXQZ3giDA9TxJo/j+0bHTUrgBnbGBpm/pM33qD409xK4ySkC4HlZcBogCFNsRi3/6+XmPDYSA4+PGLmdVm8SKCygk/Ce3qZFyk7i6LV7j00jkdHWYWwr5+GYVcXDcy+Pooj0ahuJBexjULQqGlqZghSaYlE5QzmaQmFAb+fnha9fcBwwDRYjHM3OEjhyAKKEt26V8LYMDlNsi/7B+hpEI9L/O5JibfWyPRTAsD0noEw+3p0lIaXzUbDWUpugzm3ZKrvR0Z4rAM+YOkSc7yHI3zNCP3VNG5naEhi1kx6/sysYiJ7w0vEYTPHRG4eDeP8PB6npuu2UjPD1mJxYHttIhV2ltCAJYvY9r4+M1n58IhM5Z+zWmhg+v0Mu924mWPc6eBcM3KfWaxmsQdjzkyWoN7wnGtskilvrNlzaGCODLMvjO8a1TOllKmKnl1dDHPavpNipLDweP3Deh4kXQA2ckkZVT47uylUVlYAZ53FuWl4k6a3GwBOOon9ksoZJilOLVrIKntvvkXRoayMk7N+L0W0vY3mOmaIoz09pjdKUzNzEgEU4nbsoABF7xeKwCuWc52L6R4jmzfTM6WoiCFWoRCPo72D99TJtDHf2AiEIkBzs0RnF0UKgKGh/f0UEILBtFBdyTFmVNIsKeEa1dene7npa6pFUHxhfixW9/MPcbybVTC5ju7cydfLy1h9vbyMgkluDs+nEXKXTLL/HQ6uVZ2dwMuvZFbgdDgEyivoreUb5Dl2u9n+oiKB/gGBjk6ZEiA0CUhI1NZyDRMWioZlZcxBKyy8NsXjejVDfY3RNL6uST6EEILnpK6OoquASImXwSAgNQrQo0Gum4FRCsL5+ZwTIyMUPE49ld6Z8TjPk8fLa47NxvMeCvEhS109w9eHh82iCIUFDPM3Qv0SCaAwX6JBz11WUMht/fmvErt3S2yrBfbUZ45jV1ruzKJiXkvPPpPHVq9/trsbePEl5m/UJFIhlg4n1++ZVcCyZQIlJXpoo4PHVFpCIc8idHlSSuTkCMyby6qWJcUMG3a7BWbMoKfgzp30xMzPY1L4LC8b6vVQJHxllURfH4VkMycir5kOB/ultIRewUbuPiE4vwZ87I8iXWzz+5lvTdN4XTHOs7GYWyxAbw/wl79RLE9fr5pbOJ+XLwNOP00wbDyZWQlXQs+HF+f+jbXsQFBil0JxDBCNSnzvPubB+OLnucBEopKu9Unghz8AbryBuTwUxy4nrRC44nLgqb8gVYlm+w6J//wviR/+SOKbd0qsfmO8mOV0Cnz3blZYe/IPSuxSKI53NClx4YXA4oVmlUW3W2DRAt5o5ufzd0+vzBC79jbKlACRHsYYDpu5f3yDuheYYCWxUIhGWTJBI7+/n+JOSTENZymNqmX0qlgwHzh1JbcVjwPRKJ/+JuNGvi0acKGQxOo3gQHdw0LTGI7d1s4n44ODNBTCEaClmUbLxs00pEqKaTwODNAosNtpgBvCTWkJcMZprDZleK3E4npuEV3ooIjHnCZbt9G4evHf5tPi2dX0uKqsZLvjMXoS5OdT0LJa+X5rG48lFGZVyZwcGo8SbLuxIpeU0JBYtIChN2E9LxmrhwkEAqaxXlmhV7uzmzmEenuBhka2ZWCAYaoCQH6BSFXpC4fZT80tupFUqZewH+HxhsP0OOnupmH/p7+wv202nudolOds42bTKOnoAHbtNitmOdJiQozkwUmNuVUa9nLcrDyJ3h2GKCYB/PtlDeGQhMfDY25r5768HlM4SVe7pO7Zt2I5UF0t0NNLYyk4qucqmk0R8bXVFEPb2oCXV3FsBfVqarEYj90QcpMJM98WwHxRLjdFgHUbgP4+Cn5r1lKczMmh8TUywkTs27ZTjIzGKLJIjeegvJxtsNnoTeJ2i9T8SiY4DuxOHnc4Atjt9HQpLWYfNjZxrsVjeqGIAD2VpDTDtUpLaeCXlNDwM5L9jxW7jLDP7m6JNWs4d+rrJbbWsnOtNj0kF5nf3bFTw+o3KT7n53OutLZxnBpCTJaX+9XS1o5srx42PMAxmptN43x4hLnycrLH35dKSYNWCGDZMvazlAAsnJ9d3TxPySS3ta2W57qo0BQ5CgvZgDI9dHDZUo6XDZs0NLdwPm/fIVPi7sAAx+cLL7GtmmTFzr5+7iccYTvmzWV7jTx0RjXDZILnZ3iYa0IywXmUk8sxJCUFj6Iivu/3m30UCjNXUkAXxWy6qGqE/iaSZsigxcKqe0aRj+ws5kibobcjFKIQvGQJ21hWxmvAwADbNzrKhwCzZrGjkxrXxywvx6jbbXrMGueirl7CaZfIyma/C+jC8AAwMiwRDEr09nI7Xi9QM0/QCyfJY6HQT6+b/3uO6/bgINdxt5vrY1GhPv/89P7r7OL8NIRsLUlByjdohtD6h7j+eNzAshOAExZzzbDb+f14gmtjYQFF1fnzBGZUCmhJoKePHoLFJUA0xry4sRgw6NOwtdaYK1wrN24yvUs1aXjX8VozPMywxvIyrtcNe82KhkbxEgkzNLe0ROD88yg+zZvLCqHgtEFXN68BVXrOLo+bfRIY5VjavVti3TqOU2PtNtZYqf8YlXOZ65Ei+6pXJVpaZMqreCTA6pSjo8A//sntr1jO49q9h39XVnA/6Z7eTif3a7cL9PbxXPT0UkgWguuoAMdAIskcgx2dvP6/+hq3s2gh4PYwXByg+BqPm+kC0nG5OF+KivQ8mnHer+Tk6ses8YcFPYzFQ+/7qMxIqL8vVBijQnEMEBjlk+DP/I+Ax8NS5T/7BS+cX7sBOGWl0q2PF770RYG310p893sSj/2GFY0+cAnw3/+PF/fv3CPxsx+byS0NSksEfvETM1mrQqE4vjGetA4O0pOhopyJ40eD0EOPaGwY1e3iMYnmFoHsbIHZ1RJz52bmgjFyr/h0IxvSDMXJy6M40drGJ/uDg7xRzc2lEd7Syie+SU3qxiBzWwUCwK49rAJo7Co726ze5nJKeLOAcJSeCbm5FNQCARpdLjcTqGtggmhDEPB4aJRUVZlePB4PDbryMt5cd3axLbEYjYORERrsRhhjcyvgcdEwFYLiiFMPJzL6ZXiE7cjO1isO6t5QBXrYZjzO7xohUzYrb8q7uiTkCoEsL40DQxgsLhY460zg93+SsDsoKtQ3ADZbEsFRVmksKmSuLSEEhIWfCwbpZZCdxVxCgQD7amgY2L2H4UnZWWxLfr6eH03SaKmoYGJswMx3Zhi6ublA1EVPuoFBCgkWC4+5pwcAJFaexPCdIn0cGeGliQS9RMCPpdA0oKREYO5sicZmCoOG8BOLsx/icbbB5QIu+6BAcwu9nNLH49atvPfx+ylsVJTT0He5aGBbbRwfebmAxyP0ogO6N5xGMSo/j55tfbrRa7ez/UY+sKZmjod5c2mgBwKAFtI9tzS+l5/H+WS1AjYLPZ4suueK4XFVkM8+TCSMPD4aii18LxoDamvpwVGqtyEvl0m0A6MM2S0v4/zyZvNvI9+VUdUuGOT49HrZB6NBhmj6/cDiRbp7GfhgdPWbwLw5Es88xzkWCgPxDnoF9vVRCDSEnPT+3tvIH4tFF7nDNJaDulejRc931d0DaLpXjNule/cJcwzk5QP/fIHzY3SUgntONuB0mDszPEXeWkMhw+1hZclkEti4UR8bTrYzHGYxh6wshgJu3sLx3t1NQbq31/Q+GRiggZ6Tw32PjupCj+4h2tdnrjENDTTEu7p5LIaAtXGzRDDEc9rVbYpp3iz2gdele7NpNNKTGtsAcD8F+RRIauabVVvdbgozRr8PD/M8V1bQM8rwSFy0iB65TU0S555DL6+duwQLZ+heSBYrH3A67OxPv59ecHaHmcPLbge2bDXF5pZWjr2zzuQ4OeM04O11xrmgF1MoxPNqd3ANC+ihw23tPFd+P3DiMm67u1siHBGoKKfwY+SeSyTYx+V6LuHhEeabWrUKqKik8GZ4fXV1m+GzQ8P0COzu1is/7uW4E4KCYF4eryksJiBT4dHFRRTZ128A/uMSczy73WnVZPUwuZwc9ntrWxIXXmBWrzVyS524TKK3T8AigK5ugVNPoXcsPXwlsrJ0L7UAX8vJ0edlhNvt6eU11u/nmG1s4viomW9BZYWGzi7gA+/nGPENAq1tHKulpRzre+r0a1cSCAU5JwqzuWYaCdstFu5/cJDh6qEQ17CiIh7vcMBc25wuPSy1n/MjHGJ76xuAj/+XgN+vC/dR5uLTNPZJJMocbkE9eb/dpoel+imyB4OsLhkOm5VQy0rpndfRaXpx5uXyOuLU1z16SeprZ0KDluR5dTn5kAKg4NneARTqXonCoouJmkzltAuHmaN0Tx3TJlx4AfaLspAVimOAokKBn/+ESQWHh+nls3kLLygfuvRIt04xnXg8Al+/WaCtHXjkMYYz3nC9BeXlFnz3OwL5BcBNt0p0do734Jo1S8BuF/D7JV58SXl4KRTHK8kkDco1b/MGPBTiE9vHn6DxFQzSc6C8DGjvYFL2PXVASK/OaDzNTc9PlZtj5o6SkiFb8QSFLaeDN6VS0tPCP0RPmkAAqeqPJcU01DZsYiL4REIiN5c36Y3N3JaUpjeAzSYQiQo4nayiWF7OPDXVs2jU5ebyJtnrNfN9ATSCurpp4DU2MqnvW2+zfbNm0VPE76ex9/obvHm367lmbIbYEZb0mLDxO6efKlJGcTLJfRhPxiMRigZuN8XE4KgpDPh8FAZGRihMJBMMEevt437OOpPHYrUBgSANuQ0bJbq6KMhoGtvq9QpUVtLoi0Ro7IbDGooKBU47RSAS4TEkEvQ6CkfYhyMjNAYsFh6n1cqcN0Ylq64uPu2fM4fCUCJh5hUrKgQqKwS8Hj0pu5MGiRHW4vbw+D1u4LxzBObMMfNShXWhpbfPFEYBHk9glMZQPJGWL0sPR4nG+L6m0Rtl5y6Ood5eoKFBoqiIBhDA8RII0JjbsJFGW5ZuHO/azbZVlDPcPxKhwVZabObUMuZJJEoD3mhfSTEFCa+XXiMtreyP0SANwtxcVqx0udg+o7y91aKLhZLn3QLOEUMQ2L2HxqLVCuTkWLB4EQ29RBzw6YalzU5R2Odj6KzXwz4/8USGtTnsaSGWSc7TeNL01PT52N6hIXquDPrNYwXMczc6yjnd18c+8HoZ/hoIZHpzWSym55Kmse0V5eyLhgYa2kZOHYfu1ePxANE4z0duDseO1cIHbStP5vaHhnVvSx/Hf042vaiM0LnCQvZbUSHHQzTKtmRnC1TN0EPYwP7r7uZcSSY5f/x+ft4YW2+u4XHWbue6VFwkUmtaays9iQQ4dnJzaYTbbPRqierzyuPmGHA4KGb29jK5vW8A2LZdor9fg9fL43A4uZYMDXNd9PtNQSWZZKLxQR/7ra+f5yI3h577y0/k+Pb5TBEpP5f91z+AVHSG08n+SyToddXURDGkagY95Xw+id4+pCpyhsNcgwEKJS59zFqsAgtrKNrWNwC1tRIbN3ENikaZp2xoiOGhbe0U0vLzeM4CI5yXZ5wOnH0Wf/f0sk9ffZ1jz6gM2NZO4bEgn/OmvJQeQmWlnPM7dnOuJZPcdnY259HwMK9dxcVsY00Nz82atUwM39jE81Yzn/3Z1kahs76e1zanCxgZ5Rrx5B8k1q3nvXEwyLGwaAG3HwlLePUKjDa7SFXFdaZ5GhnXwr5+5g8bGNCrbGaZ3rXlpdzv4kX8bFYWBbtQiOeqYS/XqjfXAG+8KfHCixI+n0wVlxCC/dPeIVIJ7v1DvIYZofEuJz2z2jvMOS9hrrGBUc5Tux3Iyubf2VlcWxIx80FGTjbDDatnAYODAnvq2YcOO8Mf//WSRE4OK/Lu3Kmv3QF68z35B17f21q5xuXlcs4VFnLtN+ZfTo5ARTmjigIBfr9+r76WOdhXbjcwb77ZLp8P+PcrfHjvcpmh8ACPJR43hX2Pm4edqhIMzrtohGut4f24P5TYpVAcxSQSEj/7hYb+fpYdB4BXX5N49jkubg/9ArBY1DQ+3jj5JIHLPwT86c9mOONIQOIHD0h8+kre+H3tZpkqvT2W3/9R4u57eUOjUCiOP4TQbwAlb7Sz9fxU1dWA086bTt5cCtisZmWzWIxhg03NSOW0GR2VKC+jIJPuL5rl1QUZye8ZlZdCIYYVudw0ePY20kCMJ+g5ZWGzWEnOwZAJt0uvPihpyI6OMrdUT4/E0BCFkc5ODU1N9BZy6Em5EwnT0DC8AAKjTB7d2sYbb4uFwkD9Xhqaa97m69XV3Fd/P3D66cC559ATIBqhkeR0GGGWQCgi4XabuatcTr6eTPCmO5lkW3yDNIaMcCSA+/L5dKPfSqEgmdRDCv30TIhFWa2srY1CzRmn0dg3qh8aYSlZXrNPX3kV8A9JNDUzPMhm4znOyWV/9/Xxu5UVuodWlG3Z2yjR1s7/d++hALlzF42fcIj9OmsWz2U0IlG/l148FTO4j4EBM0m938/QvZ27kMofNDLC/UtJw0mIzFxbiThFsOFhGrDFxWxfKMTwpViUfRjWRcLHfy/x2us8focdqJrBggFCsI3xGM9hezuFxEiEn51ZJeAf4nWuvQOAYKigNe2WaHSUY3BmFY/NMDANL5+AnhB6eET3JHJTUEjEKZJFoqbXjdVKoddqY7uEhW3x+/UQsgSFjECAbbHZKNaWFNPwr5rB+RQK0UgbHgY2b+WxuZycG6x6aBY5mDWLfWiEGNF7yQw1czhMgctoI0APj2CQ7TfCniRopOfl0QCdP5fGpBFaZISN5mTzR1i4j0iU4/mUldxmMkkBw+ejyGAIBqEIsGkzxRank+tFUSH7welimJmR4Nrv5/l0utiHbhfnTW+fPgfzTEO5oYGfW7SQwv6QLpB0dNDLx+fj//4hM0waoBCTnc3zFYnx77xcjidNA5YsFgzpTJjzFzBFtJERzou1a4H1G+OQGvsrEaeIZxRt6Orm57KzOXelpouQukdcLEbR0O+XeiVAkfJI3bLF8Ijlee3ppgtkZQXFj3UbOJ4sVnrm5eTQLmht47ibP4/9VFXFts2ZTdGxooJrXSIhsaeefUtvV4775/9priFr1/GYNEnBbTTA48rN53iKRvkQ1uk0x3tuLuBx0yvXEGOcTv5kZXF/22r5Xb+fa25nF/uDRTgoqpYUc/0KjnJM2awUeQxPo9Eg14qXVwFbt0nUzGdfGKH4QvfUzcvh2mwI+fE4z7PTxWMaCfB619bO61AgwDWhotKcO516/rzOTq7RtdsptJ55BnDF5QJ76rhO5OdzfC5ayPXUCA8PhSQsVnqU2m0SM2dyTj/zLIXJ4ChDrv/0Z177Zlcz9NZuA2DhdWLpCWb+r8J8nouCfK5pFiv7JxIBCosE5sxm+6qreS3Jz+P6ZLdzbYlGgcAoz1s0KlOebjYb8MhjnGuDfp6P9PxyUhfz+/q4LZuNc76kRPfI6zILrEjJKrPDwxIWmyloLaxh2PFIgALpmrcpiPr9nCvJJNeGrm6OhdwcifdeJHDKSia3X7hQr2BcxD7e24iMas3z5+OAUFayQnEU8/s/Mn9TXQP/f+lliQcf5oXlm7cJFBaoKXy8cs1VvOG/9/t8Audy8qYYELjvewIDPuCrN5pVYdL5/Gd5Ifz23RL9/UrwUiiON4Rg+ENJKY05m41Gq8NOQWTRQhq4ff0SeXki5W0hLBREAN7wOxz8LquO0WBIJPhkfN48ii8OXSQwPD86OnnzXZCvJ9jVRSO/n6E+FRVMyG3XRTefT09I7GSuIC3JbUQiNER27ASSCYlt22kQ+YfN5PD1Dfx+ImGGZ5SVmk98IxE+eS4somBgtdDwrZpBoUEIfre2lgJBZze3E9ZvuAsLedy1tRQrQiEaa9XVNC4qK4GzzqBxFxgF1q2ncTo6yn3l5VGEy9KfrNv18MzcXHofvPASDbB584CLLqIhVFhIo9UI0QN0QUJ/6p+TQ4OquQXYvIWeFD4fX+/tZW6Uvn72p0V/qp+TTSGjuJh9mkhwXCSTutGjh2ba7Pzc4kX0EKrfC0Aa3mQ8ro5O9s+ILsSNjADrN5gCmOEVODpqnhMjdMVIcrxsqcDsah6Pw8Ekz4EAx9riJbo3i2D7Bcx8Y6NBIBiUqTxwVhsNv6TuBaeB4uOppwA5ORKvvSbRsJdehH4/j2HzVnOezJ8HQOO2UsmxkxyPIyO6seyl4dfTx/bVN1Dgg6a3TRc6jcpvoRD/tlp0Ea6Tc6GwUA/x00WR1laOg5ISijk5ORRXpMb9aBrfj8XoRViie7dIsH0WC8WkiB5OaLNxThUV0otn8WL2b3q1ScMLa9DHNpaWmKLk1m0MI6so15O6C4owhlenw0EPmtmzBWbN5Ljyes18cRarkfOI4ZwzKvndsjLOt6ZGGrdCnxc9PUY+OwoYDjsf2tY3cGwHQ1yL8vLpOdTcItCwlyFq6Z5pwqJ7HrrZR9XV9JKEPrdzcjjO8/OMqoi858nNoYdebi77MBLhmO/sNpPb9/QCfQNctzxujoOyMiA3V9D7CGxjT28Se/dyzg4PAyedyLYEg+yHykqulTk5DJd1OnUBNM6/BwcpoGzYADQ2SjNsUvfslPoY7eji9t94i2ILQNEwHmebdu6iHbBtGz2yUkVJeigm7N1LgeC0UwT6B3jc/kGO1exsCitut54HKWoKnL19QFennsw9wocNFvAcOp1Abq5EXT3njKbpHnkBbqO8AnA5zFx40Sjbs2s3PZZycxlmp2kMhx70UVDSQHG5shJwujmm/UMUX7xeeopVVXIO5uXy/GTrYb6JhJ5XUvKaVFrKYhoeL+d0JML+e+ZZzimPh8JRPAHk51vQ0cHiCJGw+XjHuC7OrGIf2mx82EFhWmJmFdfZnTt5XIEA1xOLoLjc28fzNOAD4glut7QUyC/g/K+upidyfz/XupoaejXH4jw/yQSwtVa/9ulrdb+Pn43q89rtNqoW0lssmaBQuXu3WUQmHtfDSQeAvj6et64uimmBAP926NepV19lP+fm8fxkZel58XLYv5EoBbXhYY4d4/w3NnLf7e28XgwNAcN+9vvH/h/nWXsHx184xPHmdPK8Dg0BJy5lyL4A58mgnw/2u7sF7A5+v7GJa0Q0Zo7T/n6elxOWsI1Gzrv9oSxlheIopblF4rePS7znIuDsMwXeWqPhO/fQCPnQpcAZp4v9b0RxzOLxCNx6i0BrG/Dwbxif//CDAh+4RGDxIoHv3cP3vvK18YKXyyXwnTsFolHgW3fREFAoFMcPxUUCiSRvIosKaSgNDJjGbmEhb0x372boj0N/Qmux6KKHjYbkP16QKY+SokLdOyjE7TU2cltuDw2IQIA3rwP9ulELGtMLFwCnn2ZWoxKC4TNGcu2WVt2byqlXWQTb6fWahsugn8ZOXj4N82iMN9MA9zs8TGMsFqNhnZdLQcgIo7FYePPs9Zpeb93d3G80Su+QZ/8OQNKQ2dsI9PazfYB+M62LINEYvwfwxnz7Dj6Bz8/n570eGi5GaOOgnyGTkQjbk5ujCzPsWmRnUVyYNVNgdrVA9SyBXbuBaNisDJlIsIJhTy89e8J6PjBjOwBFg95eGjfGU/wsL7B9J9sQjQFC6nmSehiCVVKiJxx2sO9yc2mEBIM8jtnVDCuqmkHxqbmFBlpWlpmXKxo1Q1CzvBwnyST7YnCQxrQh3EjJvvMNMNFwPE4jrLvLFMmcDop/l10KnHIyRZu8PBqOQ34avH4/x6fNxm3k5dLQzMsxvaee+zvb29PLc2Sc92SCBnAiwb4LR9kXmsZz73Ca3hlG8udETM93lOCPx02BTpN6pTk7PdIMTyi3yxT6SkuQ8gqUGo3Uzk5Nz4cDtHXoubeC9ObIyuY5cTn54/EYniccJxUV3H52NvshHOHYCgZ18TZJz4ZIhIZwfQOwt5GKl5HoP6aLLOEIxa28fG5z1y62JRzi/E3EObfcbj0Erx6o3c4QvpISjt8sD/tq1y4KXlnZbEtPL/c1qHs7Wiz0ponH6cVoJPLfuQvYto3iQyTCPHrJJPdbV0ePF/+QQCxGESgc4vkzii6UlICVGOu5rjnsXIeMYgpGjrrOLq41e/cC5WUyFeospek9pGl6kYk8JsQ2PLX6BzjWPIaYoHtXlZfzPBhrg90GrFwJlFeyD7JzgHlzOI+sVlaVE+Dcmllles0ZSeH7B9jH/f3cr+H1BvCYfD5+bu4c4LxzgHPPptdWRTk9LouL9RDIDoY1trbqDwiGKE50dvF8NDRy0YjropCRV6uigsJTdTXHmuGBKjV+1mrlODGuAU4n14sdu/T8j4WcF6NBwGoT6O7mfJbg5/x+zuFwmOtKcQnXrUCA43XzFgrYxroejdIDyKV7hb25hmM3GmXfzp7N859Mco0aGuLxx+P821g76ZkkU6G/+fns+0iEY7CpiUJlLKJXFdUF4mhMYjTAYg5WG8fnjl0SsTjPvdPF9r28iteO+gb2Q/8Af2uSc6KizMyNydBMid17eE3euk0XwhJcGywWnk+fT+qFP8z5Z7VQKOzpM6/l4TCF32SSx+73U9D/7RMyVVzD4eBxjY5yrDqdgNcN7K7jNrxe81oXDJuezUMjFOcMTzpDaJ85k2PdamF/Wq08hqEh/hhVbHNzeQ2fNUvQ88xGby2fjx6eLW1mDtGSYvZpby/w578Cre2cm9tqWXX1pZclGpsktmw1Cxy0tnLNrqlhvxXk88HWnjqOZaMS7P6wTe1jCoXinSSZZPVFrwe4/ssCDQ0St93BhaGsDPjy/yqh693AyScJfPQjEk/9BThlpcTpp/G8v72OLsnf/67ALd+Q+OvTEp/7TOaYmDlT4Os3Uez605+BT378SByBQqE4HEgpMDDAp8p2PZQpGmUi53CEN/sf/hBvyHfoeZHmzkPK0EwkaIzu2EHj12rjDenwMA2nokLecBpPz5O68BEKsbR6JALs2sMb70CAHkVFRfTkCASAWFxiQQ3gsHNdCkcArx4WNarn4xFCzwESZniGIXRZrTQWbQ4an4Z3ksXCm/pgiDfC0RiAPBq4ySRSCcwhKZS43dxvrov7MzzQAH7eYeONvVFNKxRmovKODoYPSY37SibZV+VlzH21YyefKtttZgVLl4viWlkZjQkjzDE3h8YExTBW4BMAWlrolRePm5/t6WbfeL00RoywzfZ2Ghhu3Sh2u00hY2REz7MlKDC4nRR7jETsRjn44iL2VyTC6nyjAYo0JywRKCpkLqXWVm6/v599aLPx77JSGnKzZtGrwWrndu32NEEmyv7P8jI/W0sbUuGzAjzHe/bQq6upmYb+xk006gEzDFLCzM8mJQXXkO4B5HJSaBkZ5rEY27ZYaWDNmUNRa9DP83PB+RRojKT2xvYddhpxAwNmAnGHgyKdzcbzaiSCt9vMZN1ZWRQwSku5v4QutEiN4yMnxwy31ZL8u3+A58XpYp6rRILCXTgKyBGKDl6PbojHOFYMQ3xPnZ5Hysnj7e/nXI9EmBfISFgtJZiUfi73C7AtkPzO0BD3e/F7dWEDFBSEvnYUFXKdmF2th0RKCpR2ff5pknNMCD3/UZTH5fOx34zwtxxdeA4GaUgXF9P4NhK0r9vAv9vaOU48Ho7BeAzYtEliwQJd5NLYZovQczIN09h32E1vL4+H89SYz4UFZkXYs8/kdgd8umdJmOPG7eE4slqZB2t42BzDRgW7mB76GwyaFQu7u4GklqT3lwuwW/kZw3Ovs5tJ2I3Kcl3d5jy1WU3xsma+QFWVRO12s88gzSTfDgfnkNdLD69giAJpfQPHmH8QyM+TyM5m/xhFKuwOii1LFvN8jwQo8pWVSsR0QTYQMCsYOh3Aqafyoej2HRJOXSix2ygs5eZwjsZiHJujoxQLi4v0MO1RCopZ2QxjHB7hOVyyhH8bCdFdbn6no924ZpnrcnY2RST/IBAuZG4pl4vjrUj3to1EOG4b93KuFRWxoMGgn9soLkaqMMKeeo6JEr3/CwrYLy4X+9fp4titng30dCcRiwODf+W8y/JQWBv0sZ/8fgrKRvVhr5dr14wZbEMwZBaAKSmiiJXKXQheQxsb+Xt4iOOosJAeVTZdENq4mX3T1mYmYS8p0QtvWLk+h3L5fzDIcSk1Hls4xPDL3h6zmMyc2VynhIX9kEhynjqiwH98QE8hAKCsHAgMAzEr38/P5ZgAeH0LBDjX3U6O275+9mEoxPFpeES7XEbRFm44kZDIz+Oc/Ps/uZYmNSAZ5kMKIz9lJML1MRjkmmOEvMbiPE+hEPvNYuGcDQW5ra4urm2Dfs7HoSGO0YJ8TAkldikURyHP/51Pw+78Jsvl3nSrTD3p+u53BFwuJXa9W7j6KoEtWyXu+Z7E7x7hzc1DD7Pk7g/vs+DhB3mTOhEXXcjxc96572iTFQrFYaavX4PNqodRWGhAFxeZVcuM6nwAUJDHJ6NG5T8jB1FBPkMsLBbexG/Zyhvmc8+hERAM09gZCdC4cDn5pD6o50EqLQXW9fNJbXERt2mx6GJanIZJYaGE20VRo6uLN7BOB0NlWO2PN7ixGPDPf1LYicd5Mz3o040U3QPKoodgbttGg8uoLBiP6eEWPawm5vHQSFi0gOFhUg8ZuvAChkYM+s3QEwkel+GNUZDPtlbNoFGuabypb2gE8iIUqQyBpKxUF9egV5h0sv0hXSCTUqa+7xsEVr1KcSMri/0dCpvnwjC2AYZmJOL8AXTxRKOx7nJz/zYbPSmcTibN371bN6B93G5lpZmvrH+AxvCsWRQAZJKGTUGhQHaWxPObaJAYyfnb2vl7zhy2JRLl96yNNOzdbiMsj+dIk0auL7Y1kWC/Dg+bYpThrRGL0gAcHqFQ19vLENK+fuDkk/Rj1sM5DeOxoICfCwYpcg4MsA0rT9YFA30M5WRzTNr36OFpvTz+ynJAWPVQm2GGtPT107D2geMlN4eCiVHJT0JPLJ7LPo/F2K75NTS2AgFuY+ZMnjfDo6y8XM+xpCds7u3lmC8v45zZuYtCW2MjhbOubmDZCTT8Bgd1D7KYWYzBItie9ATo0kbxy+WiV2X1LHrHAaZoWFLCORaL8/z06Z4i2dlmDjoAqTWkr4/rA2DuPxZnn8fjFBby89jf/X1AfynPT2kpj83IlQRwvuXmsr8McTcwyv6JJ3juWEiBQl5/nznnjfxiQuiCp8Z5nZPN/nrtNY77RJKiQywu0dzCeWsk4pfQk7/DzO/kcHDOxWK60N8DLD9RoKVVIsvL8VhfzzFQUmrm2zIYDUg9TxU/GwxSSAuFeM4GBzkWtm7jcRqea9EYQ8SKioChEXqSGfnMEnFuy6bn6hPC9ISzWpnEu6yU4gbAeb9zN4/LqCzr8fD8V89ihcbLPsj8fq3tTJZuVO3UsvVKoxpfq90OVFawEmgiYfZ3bw/bEAxy/judFD7LynicRiJ2IShEdHcDg0Oml43DzjHR1kZhpGqGGY4cCnFtysvlOMzN1b0vkxS3hKBA0tXFsdDbq3vxRXked+2iV088oRcb0UOgFyzkuqJpnJMR/SFAMMjtOJ3MA9XdxW1nZ0uORQ/XMWGhcOnWPV0tgteItjbuf0GNLnjVUVRyuzleY1F6sdntDMurqBBwOiW8Xh6fy83+MYT6cJjndXiEa7EA13+XRxc8Jb346hvYN/PnU+h1OM0wW9EFwMLteDz0WK6ayT73+fQcd/X6uLKalR4Nb1e3E6jv5QMtYxteD0Uwo0pkIgYENSN0lsKbzcb5nJfH/i8q0j21A/RM27Zd95rVxXijOqqRb3NohAJ/OMR9GsVghkd43DarGf5fUsLXvFnM/dXVxTFQNUMPIx7i2Nyw0bxm7g8ldikURyHvey8AIXDaqRL/e73p7nv1VQI185XQ9W7C4RC48w7gc19k0vn7vy9w370i9URj3lyOh55eiXu/L3HrzQJlZeYYueT9/DsS4U1QQYEaPwrFsU5gVKKqiuJCRydvyiEoDFRW8sa4f4A3hAtqePO5fTvFo1SiWt2Dyumk4RaL0djo6OC2yktpnBi5lrKyuJ2REd70FheDOVN0T5jGJhp9lZU0YIaHaXDZbbzBzcnl+1Yr92dUNHO76Imxpw6pROzhMN8bGtI9tML67xAQBg3IinLmGOroMKveJZK8wS8ooPFUUqInNY8CW7cyr4jLbXr65OXq4ZdpnkxFRfzp6WHfVc0A1q7njfnwML87MkJDdOXJTDrscvG4h4fM/RuVFjWN/VWYz+9Ijd5PIwEae1UzzPaUVzDcwzASABphBQV6fjUrjZpR3XsmN4fCSnY2x0NjE48jEacxZXjVBENsv9VCzzwjfHLXbho123eY+Z/cLvZdTw+Fls6O/8/ef4dJlpxV4vCJe296X5lVleV9V3vf4/1oQAIJIwmPACGMQAghhAD9BPIIhFuMQKuFFbsIWJwWzwdIAnnNTI+fae9N+SyT3t/4/jgRGZnV1T09QnbJ93n6qa6svPeGv/GeOO952Z+1KhAJAZEYQcVwmPWNxziOVjJkfPj8ZGfo8JxQyIjp15WjPDHOOmoH16v6zx9QzC71mqpUgKkJXu9Kw7CKxw0oAnCcrKxwTDgeAC5ZhuGwEshW7eFTzMDFpU42i8fDz4VQemV51q03ZUCPUJB6aVJyPNVVCKDjqFC6IMsbDgGNpqBwt8t6LS/TwdXZM+M1OqGua4Alv5/lcRSbzB8gyJXL0qHt7eW1YQVATk6w3ssrwJ1xNkS1KvHkk2TiFPIGiFrPAk8+zbLbNue31oJaXuY6kkqazHLNpslW11DhVXkFbgAEOTVgdvYc26tUNEwpVxL4rVbZV65idngcllvPIwjWM92vABfVn4069f2SPZzrkRDHf1I52efPM+y5ViNoVq7wHrUaRd9jMdYvEFRtmFd6aJJttrQMFIoUDs/lyXCJxfj9kWHWU4fxxmNAesBiCF2J4+q2W41eWECNWVuNJx1m++xzSnvvPAGUpWXOiXyeANS+vWwDzYSDYL0iEZbZ60MLvZxfIKC3vm4ANJ09b32DdYrFJPbsAWp10p0GB6j3WyiqtRp8L9g2AeNTp1i3vl4TMlqtsW/icZZtY4MMqbk5jotCgX2skya4kmNteopgYaXC67W208lTnI9BP1BSYaRCcK0oFs1Y1zqLzx3n34cGgI0Ay97Xx88CAcCjAM1KhetZsod1On9egdYxJbJfZBk8HtYxX+C6xNBo2WJdJuL87Nx5Xrt9lnM2qtblK1d5YNLTw3/5PPtRr9cNFTZZbwCf/azEhfOc56MjBBwjYfZhocA66vk3O8NrIUxCg2aTmm5er2E3h0MmEU0qRVCwXOF1zSbHqw6BbLp8TrWmQmRtjqO/+Eu+m6YmyMZeWzMsrXyeIeVTk9ovkPD6VfbUi+z7ek0dUvkUY9g1hxtHH2M71ar8fr2hgD6/yqyo5kgwyLBKIdTBQhKws0oPscnQ2Mwq7xuPEeC6cJHjKhY1717bZn+NjrWKe1PW1ezqWte+ikxKipEHgwIv+0bg7e/iAlKrUZDvO7/9K13Crn0lbHxM4A2vF3j0KGPd+/sEPB6BapUx7gBPmBYXuWHfbFJK/OQbJX7xHUw13bWude1r2xp1CoaXyypjUYWnvNqEIFNLn+bnckYDZHycJ8jVGh2yU0r7xXEMK8eVdFJCQZ7a2xadvIsX0Up5/x+f4Olrby8301ovyBK8Vut8ZVaBs8rhK5TIJhseBmZnlZbVGFlk1RodG82S0mUOR7ihz+WVAHQvEA2jJWIejRrB/mSS5ZWSzIBclpvpfJ5MM3+Az4zFzMn62hrrVKsRhDp+QukKucCqYlPEokrousLNv8dDILBSpSPn89GBHRykvtfMtIAQbPtSmQ5aKsVy9fWT9eNXoJBmtkUi/N0SvNf2WWDbjGR4lirrpcsmocCICqt59jlmpCsU6OTkcmTDNJp0RHdsV/1TI/gjQYB0NSNRKhM0aCpWRCDAvqnV6ehdusT71Bt0Dv0BOi1eLx1hr4/O6tKKCQft6SHTJBpRCQzadFW0BkwsSt2q228jYNmTYDhNqQRAGMZEJEKQZWSYjmkyxTbu6eH32zOI2bZi7VksV7HE3y9cJDijw/m8XqMHpzXeymWTTa6uHEWvCust5BXAVGEb1uuGRWbbLGejbpzNXJ5SFIEA67u0TGetVFKMvqIJtbIUqyQapWPs87HPBhVgLSVZLYk422hokIytXJ7Mk4uXGA721FNsiFKJ/fTMMZZVgyMBv8mkurZGsHJmhv185qwayxXebyOr9OKaXAduOcKy1ioErEMhoyNXLKpwsxrbUYfOXp0jCNNosH6ZDNcKn59l0s7/xYss7/GTnaHKtofjLBLmWKo3CKqFg3TsNQhfq/H5+TyBzoACSKo1XpPPE4Dq7W27Rq1Tjx5VYZpN1rusgJrlZc6FnoQCgCUQCglm9/ORJRsOc5zWGwTqQ2ECAzqDZSBoQOtqTYWK23x+qcz7F4qcl/6ACn9VjKBEnIzKQJDPdxQgCyi9K2lYTQD7U7fj3/8DsLjIzonFCQDajkkc0d9PFqBlsa0SCc4FrXdXKatDDYdrSEDNdz2uJ8ZN5lfLZhv5fGSjLas1YCXDtuhJsg2EKnc6DcQinC86o6fWg4pEOX8EeE/9nUiUZU4lWea5Oa5v2Szntt/PebC8zDkYj3OsZbNcx/x+vn/OXzDZgS1LtMJ/azWjvef3M6zyX/4NOPq40XCrVDlmoxGOacdW+lauAoLCvM/Z8+w3DfQsLbIdHIfrNsB39YF9nEPnz6n3SZ0/KxWOtWaT68HCAtdIrQeodS2DAeDSRc6xQMAwVnNZ9oFOlBCPmzUwFjPrmhBKK87H67NZ+gh9fRw3lsXEHlqDz7L5ThLg+zUc5ng4cUIdPMSAFz0oWozNSkVp4wUVc1kBookE27BYNFlBLdWWK8sch8vL/N3v5/jN5Xi4MjGuNM1sJjZ4+OFOMPj5rAt2da1rX0X29/8IfP8PSqyuSvzPP5J49Kg+uQXe9guAbXdZOf9V7WXfCNx3D0MYnzvGFf6975P46TcTIN2+XeBP/1hgalJASom5OfMWEELg214p8PQzwIf/9CtVg651rWtfLFtddXHxIoGYq1cVE6LBzeW5cwSwenoYkreaIZOlp4fXasfJcbgxzaxyw9to0Cn2ONwwl8t0pOIxOiI+H7+TSqqU8Mt0Arwebuq1ttLFS2R1lMtMpV6rETBwJZDu42a3N8UNrwYP8nme/m7bBtx3LwGjcJj3DgcJzvWm+C7U4X2ra3Qi5xdYzlKZG/nLl+nwXJ2jQO/6OsuuM+8Vi2yTyQnulTc26LQWiyz/o0cJAKxv0KnI57gpjylQrVAyGa8uXAD609yEnzjJa/7jExQftiyBsTG25cIC9a7OXwCeeUaiXidzTofZuC7LcPKkCkuNK4ZNg5k011aVgw3F6IqxHKdOsXyVCsvcUCGKfh8dr6bLZ/t9rHu1xrZaXKJzZltkRwT8dDYiETo1Wp9HO8XpNIGaQoHgkc74GI3SodKJB3Q4ps70tr7O/4+M8J9fOUTPPEPH/MJFikoXFEPFdQ3TpKzCnjIZMjPqdY7NbJb9srioADbJsugsnZEwnaSVFbaVZbHusRiBiVKZTK9Cgf09rxwvLagPsK+1SHwwyPGezXFMexzF/ogwhLSnh2N7bU0BJjlgdMTBnbcD8SSBy0KBn1sWyMpQbL/BAZbb5+W1WmvHYxMk8/roYPan6bSurbNdikX2QbVKrbsrcwTYehKilUDA62G/FFSY5dCA0iarsf7HjjHsudFQWVrLvGZAsaxWVljOcpnPrdWZhbFaU2FNUMyrGOsUi5kwLykJ3mhW49Cgeg64NuRyBCP6ehWjqKJ14AQOHVRhxWGCm5Wymfd5BRT29jKT6NHHWI5mg1p6Gki1LGoTNRq8pqrAzHCY/dpoGGHviAKypUswb32D91xb5xzM5YCNDRfbt1MwPZUyWVQBMy5cl+N0aZnt7rSBvP39BHX7+1UW3T6u1dkcx1ckQsbl4ADn7caGAcGvzrEPJZSzL9kW9Zr63QUsh20sJecLwHUwXwQOH2RbS/XZCbXGBIM8SNBs4OERAsnNJudQPm/WdI+XWmiVCj+7OkeQ0HYIEM3Pc+75A7xHup/36O9XiSzWOe8CIY6d3hTbwJUcy+k+ln9mhv13/LjJUpnLEnh/5lkysNY3uG4OpDkOLl9he80vsB9ac8rHvspmFaNMzWuP0uwLhxUL0eUci0TYd8WiAVF37eaYDoZ4IBOLsX633crx2dfHMXTmrNLFnGIZzp0nWAnJtjt00AjnZ3MUZT92gm2pDwDGxznfV9c4t/V6KCXfDWurBI7zBaM/KcH+cV2+o2zLZEQWgnWammCdT51WSQf8Jnvz4CD757ljXA8A1vvYcbZPMMSkIB6PEsEHP/f5zFoYTwAnTjKDbqNOQPL8BX6/N2V0GD0ezjt9qCOlEsG3uc4EggQFMxmOi5Fhfj+7wbpWq2gd6iwtc07f7NF9F+zqWte+Smx5WeL3PiAxMMCXTzQqMDPDBe8dvwgMDnSn639lE0Lg594s0N8H/OLbJdbWJL7/VQJv/wWmLwYAx+HPv/6/wKteLfHJT5tXwUMPCrz464E/+l8GLOta17r2tWm5PDeXWkTdsunQJJPc5OrMbZEIcOgQwyaiMX721NN0OHXK9mrFZOsTFje7hTydaq0F1Jsym3LN3tCZ+tbWKHouXX7HlSrko8CypVIsX7MJeP10BOcXqS2ytsYNrG1z81wsklFQLPEevQqY0+FbrDvfi329JqNZLM5rs1n+3e+jI+b1ciPd30c9JY+HTnwgoDbKQgFhUCf9VRUqF1KfuXSoLEENKFc5/8USN+UbG3TKSiWePjeadB4uX+ZpeaNh+mw9y883smRtJZNG/6bRYPtYNuu2kqHD8fFPSCR76PSn+wl6NFw6fzo0cMcOE3564QKQWWO7jQwZnRqtCVUssC3Saf48dhx4/EnWa3CQTsjKKp1Tr9Lg0RkLmw06VuWyCWdaXydbIBLhd7wePqNR51iwHdarUmnLeOkClRrBk//7N2RRZLN0Xnfu4HvM6wVg8drpKZWJq4djdHGBp/tDgyZbo2Zs+f0sn7DMeO3vJ2Dr97GdIBWDpIf93Jtie4WCdCpjMZVJU7VzuUSnz+s1meFW18hmW14m+GMp/RuvmkeFoouz54D1Vf5t7x4DKGvtp2efMyLNKxmOoVCYz7x8he09O0Nw5soVw9rTiR36+ylKvmOWTIxiiQdfmVUFtnhZDy0wDQv4+q9TwFOdYIzb5FiQrsrmqsIp02kgGAYqJTIiLYtC19E4nUzNkolE2Af9fSabpWOzTaMxtsnQIOfZxYtsK6+HoEghbxgnOhwM4P0GB1iOes2IpXu8HMs61FMzYiwV/iilGWeNBuBTDEQdxug4/F6lojTrEhwPtmWA/6Bi41FzrzPjn22z7JqF0mjw/8eOca0LhThWwhGzBmvm4UCafScly3PoANsus2IyFa6vc+7X65w3hQLHgYRipxZ4f73mu5JjIJEAZqe5zt51B7B9O8f3pcvAlcus49AQ525TsZHyOYInmRXWsVplO+r17PIVls/jJdDbUODw2rpJvtCbMkAooLS1FLCsM2U2GoYlGI1yfV3JECSdnaGeZCDAul2+zDXqylX2h84guZwhsJ3Nci7EFeAUUmCqzuIrhALdgnxuUIWne73UqtKMv0BAtJhsXq8Jsa1WWOdIxLyHjh8z4Y0L8/zOgf0sx9gYATy9Fq6tMeT7uWM8tBgfY7+trKgkLI7Rgms0OIctm2thsoftMKjWKg3cP/Ms79tscL3SIcX6kGRjg3qM8bjKqCg515dXDFhp2QzzrFaVUHyTAJIOVZ6cAL7h69mHbpPlXF83+nm1Bue1z88DC49D0LBU5j1dl3UsFDlePF5GImUyKgtkFjh/kYcumYzRFtu1k2ULBBj2uXMHyzMywrrW68B3fBv7PpNBK4v04iKf1XRvfr/U9Z671rWvApNS4td/U0K6wJt/msCGsCTOnGFGrfvv607VrgGRiMB73yOQLwBve6fE6Ahw8AB3iNVqO7BFrZlfeBszNWr76TcI9KeBd75bolDoAl5d69rXso2P09nRguyOQ5HkgQE6A67LU+RUiuyg48e44VxeNiwUfXobjShgSIX8adbIwACwsKRYT2XDUgmF6Jj39HDjLQQBCK+XG/d0GkzVfprX9CToEJeVk5ZZoXNULNLBKxboTJ45yw3+2bOGGbSqwKSFJROKWVNO80aWjsGBferU3jEsHu3AeD28R7GoBNVVyN7SEsGdUAiAMGnk1zcUkysGHDhAbR3HoVPXaBAgqVXpoPp8KhthmaCY1ha7Oscw0gsX6Aj19gLbphVAoE7G5xfIslhcUqyTkAqJagut21jnxv6eu4BveAnbtNFgO9ZqRnulpT0mCDbUVIiQBIHActmE7k1OAt/0UjqfmVW2w9oaHWQdElPIs70aTf4tFCRLb2KM9UklGWIjBIE4zRSpVPmZZdGZGxtRujwVgnGLS7xu106Ga2kQYXBQiaqXgEJBYnCQGmeQ/F4+R+fG4zHhTjoLpc7glc2xvs0m28B26JiWK2zr5WWGFoWCij2gQIBIhA7kRo73LRZN+KtlMaROAzCXLhHoikQ4Bs6dZ9mCfs6FtVWVbbFE9oFlcy7ojJCWxb6W4Bi0LDqSzQb7Lx41Qu7JHpbr1GnOB51JcCBNBzcRZ5116OEjjwr8zd+xPzXrIplUGkshJnbQGf/qdY6t3l4FWtcMqwWC+4dUDwEr12U712rMjOf1EvyIRshQ0Rp/Kxlgfo5soqEhtnFmlSDv6qoBdPr62QdX5zge44oRViwyq9vjjxOwrdfZ1skk16FQiMDnoUMG/A4GmWEvHud4ti32dbFAtlyLeQaOzWyWfXH2PK/VrNdqTa0DkmNRhwq7LsOuPR6BY8cIIJ0+yzGYSjJULxZjn4SCKjx7huXc2FD6aGBbXL7CdlhaJqsnFCSgUa/pzItcn5eWVMhslX2ngYVgkGuz18tx7feZeT63QJZnJsOxL8HvNxuKySWA7/8ejsFAEPT+LT5zfoFA06VLXGv8AY5Ft8n+CgcJdDz1NEGpSFQJqZ8lgBdUIHGpqMDJ84ZZe+w47xUOq/dHjX10+TKZdY6H10vJNlxZUZl1BzmfAgG2Q6KHzLe4eo9o7btqVYWPwrAiV9cIVM0vECjbPgtMThnwKRS20Gxyzhx9nPdYX+f4Dfh5v3CI86RQZMbilQzncUCB1I8cVczSGvtAa49pbTXb4XskFmN9zp7l+JyfN/XrUwC7UGNz7ioTobguvwfBe2rGp9fHOWfZBhgOBhTLUprw/40Nrrd+xdZd3+D4kpJjvVbjoUm9xrr1JIDt2y1Y6qBKs95KJb4HCgo002AsBLUe19bZ1vPzKvFIlmvO+ChB4FCI93Ylx2o0zvv6/QRoNUsypNh+Z8+z3yIRrp+5LMdQvsj36No653VeMVVTSTO/ns+6HnTXuvZVYB/9GPC5h4HXvBp493uBf/7/ufjvH+QC8MOv+UqXrmtfTTY1KfDzbxZ46mng9z5AwOrfPirxXd8rsb7B3+Nxgd/6DYF77wZ+63ck3v/7LlyXWnDv+EVBvZ7qV7IWXeta1/4z1pPg9q1ep3OSzxt9DGHRSa3VuDms1SS8PiV4XTeZklYzKvU5uKGOxRgy1NunRG9dsmj27AZ6VDiCzuQ2NMRyeNuclahi9+Ry3JzqkLhag4BJpWqy6QF0mIaGCP6sqY10fx83xh4PgQDHoROVyRBIcBxqfUWj3BhXqyzD+gbBv1iMbWB7uMHXeifr60oTSgFDHhVipHWcdszyPm6T99Q6NplV4ImnVKZC14ApiYRiikCnYOeJfrlMhyndz/trfSC9wY/Hed3Rx1jmwbQKA3UEojHWuVCgIzY5SYevVDRslWyO/adZSa5Lp7NUUSfkoyz30hJBkolxAlQ9CQKj4TD7/JlnyBbqSSjwZMgIFvt8ptweL0HNgTQQDAkMDrLtLZvPGEgTuKzXTQhbs0mdld27TeatlQzbVLOfJiZUhr8ENcVGRuisnzrNMui2K5dZTgiOzXQ/+9jjIQMkX+Bn8QQdrfU1JWYd5P2PneAcKJfZdo0GHWwNrF2+zOf0JDju/AG26fQMmSv1On+PhgnwuC7rP6ScVT2XdOgmwL5b33Bb4LEOta1W2Ub1Oss/OkKH8+QpllnrB4VDHKOpXuDUWfaHZqdJKIaPCpe8coX3Xs0AblOiWuO9dT2iUdYtqcKG/vWjdFABzr3+PoJeRcUaunSJAu/FIh1Rv4/9IyXw8CMcx34FqjZdrjmhIJ1dIVjfYAB49FFeGwkbcXOouVMomvFVLnMsb2QJJNVqnKP1ugqh9RM40sDL4CDrv77Otci2+YxaTYVFednHuTzbYVWNh+FhlkEIk5xhZYX/9/nMOnJ13pTV4xBgWF/jgfTyCh37mSkV0iUIOPr9LG9Jjc9KhYDQzDTb1bKAy1eVMH2NfX7mNEGA6WnOGccxbNyeBPtmZob3CwWB/XupdzU5qeqngN1CnmvQmgJ4nniK7e31mGx8ttDMIoFy2YT69fep9qob/bhyWYWwl1RG1nGub6US6zg4oID4ksr456jshIqp6fGybXx+3ifZY8LcheD/I2GuHzpJgWbVutIwNB2njWEYNEykfJ59n8mwrPU6weZcjmXc2OBn6+ssdzjEZ1+8RACoXAIsIbFjB/u4UTe6YRMTKpHHBtmze9T6lc2RIaczg16+Qpbv+jrHfSxGlnEgYIBjgIBQKGg0rnw+jt9kihkXV1bUeAwBQ8OGiby+rhjSLgH6xUUC47kcD1+0XmKpxP9fvsJxns+x72s1AqR9fSqRiY/jVEqWMRrlYcOBAwQR63Xgox93Ua6wD+uKRaazHXu8hvV6/jzLE4tz7U+nTZh1LMK1NV8AFpe5Ruh6er0Max4cZHscfQz45Cc5blaWlexBke339DMKfA7TL242uBbWqgAsvuMiEc4xnXjh+cy5ua91rWtd+1LaZz8nsXcP8KIHgU9+GviLv+Li+yvvBaLRLibdtU570YMCJ09J/PlfAttnJWZnedJnCfMdn0/gXe8gIPbnfwksLUv8wluAnTsEfvPXxHXu3LWude1rwQoFiZUV/l+nOnclAQDLAhphYOd2OqynzxiR2lyOm1Sd8luHxrguN8XRKDU+ImGeRp86Y4TZBeik9Pcpp6IG1JsmW104RCe8WqHzOD5GHZjLCqyoVfmMQtGcTKdSJjQrEuZGOBSiXkdGhbs0mnT6FpcIFq2smDAZx6aGlJQMFavVFcPHJTjSbNIpikaMZpLtGD0drSNkKe2QaIQOz6q6NptjOODaKrBnl9GHEYIOnccBRvrJSCsUef9ShY5TKEQwoF4n+0VnXisV6fxEInRoQ0EyENym0lZTjKZqlU7P3AJBt0IBkE1A2NzwLy4qp9el09to8h2gBaS9KoytUGS/alHxS5cILGjBaa+HzwfY/vMLSsDYr8JabDpugKRGV5Hf9fmM0HRSAXnbZoBPfoohP1fnWOZmkz9HRoCHHgD+/C8JQtVq7FdX8pS+0WQ9kz10rDIZjs3lFQWqhAxzDGCfTEyR9VMo0PHS4JRUfeuoMMpEXAFKKvTN6zUi20vLDHPy+xSLJEHHLZdl32xsqPAj8N67dnK8nb/AcuhxkuhhCJtmVfQk6FyeP2+ycl6+QgCnp4dOnM9PcKha5ZhsKjCuXqf2XjikEi/0cAwViyw7wPEjJa+5cJn97vWY7GeWZfTO+hp0yEtFoBJmHZdXgIeP8ll9fay7VeY9jz7GuRBVc7/pEtSs1ZX+jsOx6nFY75UV1iMc5v+jUTqrtqP0fnwE1RpNw+7cfSfb4TOf5Vyd3ca6aYaW12eSaywumVCxM2f4/0qVAPbKCvu7ogBfr4c/FxY4Nl01L6IRIDbMcRcKqpDBpgnH9DhANUs2aiRC8CocAvI14MplF40m+yYQ5HgoFLiWlstKbFuNr8tXCJTOTLOMQ0NoCaLr8Nhm0+iBxaImcQck262R5fPX1xV4HFFM3SyflVfzHeC9/QoQXVriHNo+y3V/cZHzzraBf/4XifU1jqGZGcPeSfez3ANpExqdzfF5GuTvSSiGn6U0zLIsq3Q5L4JB3rNRp57V2XMsezZPZk4yBRQqKmFHhW1SKrEP1taBpMXxqLNb6tB2j4cMPZ1wo9kw/exRoLXO+Oc22VbhMNtDz+tLFwmMXLjIOl696iIW5XitKTbt0CDbfWmZz3Us9nEkwjlTLPEdlkqx7ZsSsCUQS3C+zy8aDb5z51UIoG2SqgSCbLdEgqCUZg36fGRzhkNM1nHpMv9p9qpf1XNjg+vwM8+y3dNpjj8NEF69yrHm9XLe9PTwXez3Uw9tZVWxtmwzZmIxgRc/JPHEkwR5iwUyKnNZtmV/P9ePQID9qw+Pcjm279Qk+7uvV+D8BYlYnP25rt6PAb9KrqEOhnIFIw3QaAC5GnDwIMfr8rJiIirGXbNBkHthwWT1FRbfc3odW1L7gZuxrhfdta59Fdg73ibwvvcKpFIWJie4WP7cmwUOH+xO0a5tba/9EQq5vu/XJHI54BffaiEW6wSxLEvg9a+z8JOvE/jEJ4E3/oxELkePZ2VF4mff4nYI2Xeta1370toHP/hBzM7O4pd+6Zdan0kp8bu/+7u46667sHfvXrzqVa/CmfbUiluY3rQKcGOZTvMkemxMbXRL3Jw6NjfSjmJATE/RYYxGuAkPh+kYDQyYzFEeL5k4lSqZR5WKycKlHd9cTjlCDW7EdTiWdngjETrykAyHGh1WmRATdNyFAK5e4QZ7bY0bYID3X5in41OucIMbDBjwIJfnBjifN+nWPSrM7IoCojTA4PObcJGJCYYRBgN83kqGbKBUiu305JMsfzjCTTzAOlkWn50v8Ltxxb5qNlk32zIhQxHVptIlk0CHGLGPlTg56GBHI3SIdYbERp3ruM70ODREdtyTT7O9ts0oTRYYhtTiIlkB+/fRedhYZxusrPCeq6t0StbXjQh7oUCR6N4UnftclmUtFRhels+zbwt5PjeR4DjIrPLf5StGMDkW5XMbdV63tMR+sGx+XijQWSoocIwaW6IVKlkus6ynTtGZ7e+jY+v1EpzyeMgobGVzFGQurK2zT/v76ZQ2myrEpahYdi7LMTbC/pkYp7NbrRldp0aDgOpAmvWMxshOCIY4Vk+eZpmyOTMuvR6yGOp19sFKhvdMpfiMpHLqdLKIM2eNQH9fn8oIWCIA5PcRDMyscnytLBPwqVY5xjc2WK89u9lP+YJiEloqSUSKfZxK8d+9dxH4yWRUNtUmv1dTYWMbWc6f6WneY2GBGlolBZ719BCU0IkSgkFeOz9P0E1KOuxaj0kIjnNh0/m87RYVuiyUIx1l/wwMKOFtj9Hmmd3G71AjSVAfz1IZUhX754H7Wd5Gg8w3naXukUfZZpoZ5DY5zssq/DIY5LyWCphxbPbX2jpa4AwkyzY6wvrXagT61tdNpjodLl0o8rnLGRcCZOZBGmBFMy3LZTM/tLZaZtXMf8ti31fLvH8qxTF14SKBZq1rNTjAMN9QUOnBVQnC6LVwfQMoVwkiabALQgG0UfaF18exKV2lj1c1zDGvj3155TJBb83OyqwS5Na6XBZYRh0KbtsGnPN4AKh1d22d6874GJ8vQRaaY6vw3DpBDwG1Rm0Q7Kk3jI6ezuK3tMTqbGT5bM3a0kyvgJ/rQ71BcFwDuuNjTGqybz/XkFiM48PrUYkXqgTzalW2n35Ws2lYoJZFna2hQfax7QBHjyrQzQP097IvtEako9a4agVY2+Cz4nGTgTQS5vjd2FBjRLCfSiWjITmj3keFotLRUmBYuo9/r9ZUKKzF8RqLc11MxBlaPzrCca/ZnCUFwPq8fMctLysZg162l2YgNhrs11iEepDRKLB3N4E3S/D3QsFoa3m9rFc2yzVsZIRrz/o63x3BAN9dlQrr7fVy3xAOK3akh+t8qcjDOJ152a+eFwxwjxKL8t/oMMFRrf1p2yxPOERmYyZjMt9evnTDbVLLup5017r2FbSnnpaYX5B45lngHe+W+Nu/c/F3/8DF5oH7vtKl69pXszmOwLvfKZBOA295q8TVqxKZVYmff6uLq1c7Aaxv/zaBd79D4OQp4LWvk1hclHAltQfe+R6JRqMLeHWta19qe+aZZ/AXf/EXmJ2d7fj8D/7gD/BHf/RHeNvb3oa//uu/RiqVwqtf/WoUCoXr3isUFnjoRcCePcqx7COAsXOHwPQUGQiTE9xkNhpkRiwuKZFepa8BFTLjVxta7cAdPUqwDIJOw+qq2SDXG3RAGg06vuEwwx4PHaQDEQoDr3w52S/ZDTrguTzBpr276VS4yskIR7j5Xl6mrk9JOYylMk+qNzb4t3qddTx9lppLU1O8n84I5/EYhpAEv+u6fE4sCuzaoZxor9E3gWQd43Hl8ChtmPl5w2DQGmPzC7x2cZHhGT6fCUeSIOOlqdgjkMCLX0zQ6dGjdDp0WIulgMfxMTqdg4P83mOPKzH7ptKvGuDzPR6WLarCNWybz/Z6VcgqFBsuxL7yB+ik63CaUJDAQixGEeRqVWlpJVQoosXPXZehpsUCQUbtBGYyiolWojNvWQRLQiE+U4uyWxad3hMnqVMWDrEPtXC4z0uQaGEROHtOYnSUZQsFWc7xcTqT4bAKXQsSHJKS18cThrFTLismW4EO6eIyHXAtlJ1ZVVn9HIKYOtyrotiGGjBqNunAeTwEvTQA0GiQdbayzHZOp1n+SpltVi4Bjz+hyqXCKf1+BYKAbRiLA5YQZDMqMNO2CSyurvJZ5YoCVhRQksubjGWhIB37VIr1Pn2WLMueHs7X9IDJzAmpAVmBcoXtks+bENBAgGNcugwR1eGS5YoZS64CgIaHjOB8JGyYiwD70h9gHXr7WN5AiHPm5CmCcRrEDAR4n/PnCajNXeV1ELzf7CzrvbTM0EvN5pqbV9lkzzOjqR7Lvb0q2YHN+kcjhgnq87H/YgnA7+XYW82QyWI7BNvSadah3uDnq+ss2+oqHXCtRRiPmSyBPUkT6uxxgGSPhXCEYOviIudVup+O+fZZ9pVOGDI6yv45ccIkM8hucC3I5lUYZ1vd3CafLyy24fkLZGU1Guy7gJ/AFGDGTCrJz7W5knO3VOJ4mJsn+8jxsI65PIHc4WGCLE2Xc7RYMNl4S0WybwCVZdCjQs4F17B8XukDxqmBJaGAHw/bcmGRz/78IwSXKxWCblpXqljmvb0+Zls8f57327GDY34gzfVG9+/EBNtUhxjedx/HnADvDyjwTIXwOzbwrd/CgwIN9BYKBJDOneM6uLEBLK+4OH+BZavVCNpcnVdreYbrW2+KYX46UUFPD9ftQpH9aNsmqQikCsO9xHZ0bJNR03UN4CpA8CkWpRh7sodsvlKZoOfjj3HMxGKGHRWN8PApEVdafipU1KPAY19ACfG3WanE+ZjPK9bXHLXTehJKcL7Gsfb0s8zOHotS11Mnt9FM8axi77kuAc1U25zQTLtQiKB+va6yQjbJVKs3qF2XSvFeySSBqkSc77dYlGWYmeF66fNz/BZLSiqhQeA4FGQ76TB0IVgGj4ftebMi9V2wq2td+wpZLi/x9ndKvPPdEr/4donLl4Hffj9fom94PWDb4vlv0rX/0haNCPza+wSEBbz5LRLZrMTZsypsaJPdd6/Ab/+mQCzGl2R/n8DP/YzA8RPAh/5XF+zqWte+lFYsFvHmN78Z73nPexDTiskgyPHHf/zHeO1rX4uv+7qvw7Zt2/C+970PlUoF//iP/3jd+40M26hWVSZGiw7nseNMVCEsAJIO79oGAQGPYitUytzUR6NKGLlIp+PcObUp7WF2K53NrlrjqXI2x82zPr2PhMn+cV1uyFMpAcehs7e2RuDB4+HfV1fpJM7N8/Nanc+643aeTnu8dKYjYbSyZzUadBIsi38fG2NIigaBRoY722Ntg+ya225VzBGbjkgsRhBuaYlOhevSUQoG+awLF/n76IjJKLixAWpEKUaA1geq13lP26aj2VThg5ZNx66vD9i1iyFwzSbbe3xcZQkMsD0B9oV0Cb7EYjo0ScLjoWOmw9T6+wlAeBzD9PF5Ca44jtFh+tzDBGd6k7xGO221Gts8FFJhhmrtr9XoUDebxrkP+Omg9abofESi/J7ORhcM0llJ9hBsLJUJJOlwUm2Ow/EQCrGcfQqELVfYRsWSSnvvY/9u3w687BvYpucvsN/XVgko5fMEl4QgqBEKsX16elTGvEZnZkiA4zuVYvnDIQIqWrC9UFCMHeVA15XzmM3ynakZOtUKAIuOGSRZX0PDRtsnHOK8SCSUJhPYzoAZI1nFoF5bNwL6GrxoukakOhIhwNrfr7IjuqpsKnTt5CkzJwJ+XucqACWfJ3iTLwBHH5PYNk2QJhCgQxlR4YqQBJZdSaCm0WDdtOA2hAKB1jjvpeS/aoX3jsf53MuXTYhYNMq2DgZNFrxavS2EcJHzRotYV2oc84tLBHgDQWDbNqPzpDN2Li2zbbM5pVcVUmGQHvZ5KGzYea5k+TSA35PktcGQyeantdKSSZU5Lw9AhY/NzbFvwyGyfyIRgu7FEtcwy+I6k+oFpqdtZni1eU0kotaBgMnw2GySkaJDsRM9akzUTAIKv/qp2bV33sHvRqNAX0qF4iqmTjhkmDJ9varOrmHgOJ7OsDSt4edVYKXfp/T6ejhXCkUzJ3fuMAcdlgXccRuzdwoo4A48KBkZZf0WF3htb4rtGVXzKxbj5/MLirVoEVQdHACOHCKwWSwpNmKSQFQ0orI0NlRGQmGE6mNRtkE0ajLEjo0BQwPUzRPgeGzUDVCVy/Eds7xiwtKFIHg2Psb2XF3lWAyFgOEhC9/4ErJCdTZBSzB8f22doYIbWdOmvSmG942NK10+obLSqv5IJk2CimjUJEKoK8bgthkVQm/zAGXbDO+dz3NO1Wuca65q+1rdgMfxOMtWqbJ+PQlq6J08xTrFomrNqnIc6GQpsRjbWrPnymWuUV6f6vs41xGA6+LCgsTaqlnPPY55D6eSBGU1UF6tmnEfVf0/PcUxJ8G5EQoSQFxc5DiCNO8uzdR1Xf49HDTsX5+PYHepwvmfzXHeJpP8eybD8dGbJOgf2AT0Xc+cm/ta17rWtS+2/fbvSqxvGGQfghvJX/9VgUS8C3R17eZsaFDgV34J+Mk3SvzqrwMf+gMgGt16/OzZLfD7v8tsn9WqRDwOvOylPN05cljiwP7uuOta174U9q53vQv33nsv7rjjDnzgAx9ofX716lWsrKzgrrvuan3m9Xpx5MgRPPnkk/jO7/zOLe936lSjJeQdj3NDO1ckE+rAfn5+6RI3/job18gIAQUp6ZDpdPNa90NnbetJciOfyZiwwEaDjpzj0AG5Oqe0cBw6XAsL3OSeO0/wxbbpJExPsRylEgGZpgqv8vsZ0pBK8nsD/XwXFpSuh+1wY7+0bDKW1RsmHEdnFgRY1lIRWE9ys7y2znqtr9O5Tvcrpx8MU5mbV7osHqBRJFNNi3YDvIfbVKLfiuXVaNLhHBkGzl1QwE2RJ9I7d5Cp4POxzI8epeO2aycBuKefZf1dl07IwiJQrdP593rJPnEci5n+Vo3T2HRZ9pUMAZu+Pj0+6IzYKhSsVldhkjbgt40OWiTCPs7n2Yd+P52KXI5tFAwQcAIME8yKsC3cBp+3vMz7+P2819U59rVlsQwN1Z/RCAHDWp3tq8PgPA6dIt1/pSLrn8vyucUimVSjY/y8Xud4XMkYQEEoZy8UNqwzIejsBIMEcmyLTtT99xHwuHgJ3FMl+SwpleOowJxkD++ZyxF80WyBWo39kcuxbwtFozsWjRKYWVsDrEscI5EIn5PJAFk1fywbiMcEImH2c06F3KYHeO36ugEp4jECT7k8gTOPh21SVfNPZ/Ls61PMGxU2p4XgAwr4vHSZ86jZoNMeCpNxEVBhu4kEnUot/H7v3YbduX+v0d/STL5Gg+NTSrbJ2hod26ZyUPv7+Xk8znuXShw/Q4Oc14W80kCrExytVZVeVxk4cYr12rmDwPq8AgpnpnmfYpFzT8Lo3PX1seyVCr8zNMD7ZTfMWK5WyCSrVOjU51VblYocI4k420onYqg3WD8NRGm23vIyyz0xrsI+BZDLWVj1Gp26i5fY5oACSSu8v9Zli4TZFrmsGTuOBxj3c8w+/QzHyfmzBGZ1iOxA2hxg1Gosi842WKtzLPj9LL+UBD4GB/nM6Ungs59nOOrMNOfqRpZahsEQ51khzzbTrMGaYu8Mpk2SBgEjql5UAFnvMPvszFl+VlGAV62mwvYUG6vR5H127gCuzglIKXHiBMu7cwfX84VFgmw+xehbW1MMtDIwMKj0Is+pg5Y+lvP4caUHWWX/Xr7C91FNrRfRKNeMR48SdJrdxnES8AOf/qxZ20NBIBa1MDkpMDIikc0p4Aa89+qaYYKurbGc8Rj7dWkJ2LmThxnnLnKshYPmnWapcP9cjmX3+gkeh0KcL5Zg3zcaZGvWFfvS51NAowr/XV8jS7HRMNlqHVsl4MgSeOvvI4hUq5tDFIBjynVVRkMFRid6OEdrNa4PDcVWyxdZ988/YgDaWt1ks/X61D8v577jqPm6wLIE/ARow2GBtXXqOWYyXMsiYa4DgwOKmetXGnoqlDQYAoQC4dODQPw8y1UosB3qNRX2XeZ40+tQo2FCdFMBzpebsS7Y1bWufQXsU5+W+Nd/48J5/DgXhKVl4CUv5sLata69ENu9i2L0b/0Fibe/C3jfeyU+8zm+OA8d7ASwhBKR+PCfSvzJnwH/6w+ZkvzDf9oFu7rWtS+F/dM//ROOHz+Ov/7rv77mbytKZT6pjy6VpVIpzGsvcAurNwDbsSAA+HwWfD6BbeMWPI5AT1IgGGxCCBvBIJBKNhX7QKBQaMDr4f+FxfuEQvwXCPA+gYADKRsAXHzbK/14/PE6hodt1GsSZ881kc1K+L0uXACjwxYGBzy4dEWgp6eBWtVFLu8iX5DoFTbicQuOI9F0gVBIIBBswG0SRFtdAzyOg3qtiVJDYmDAQaMhkcm4cByB/Xs9WF1vkCmTdyCsKvw+MsjqDWBgQGAl4yIogGrVxUbWwuqaRDRqIdkj4EqJcIjOy/S0AykFbFtida2OjaxEFBbCYYlmU8J1bQWGSASCFm6/zcLDj9TgbTBEzOMAobCDaMRGZq2BzEoD2byE32dhYMCPfKGBWFQgEBCoVGtk59RtrK0JjIwIZLMucjmJRNxCZq2BPbtsTE05eOqZBuo1F/UacGC/D6fPNNF0LcRjFhYWm7hy1cWLH/KpcFIX4+MuMhkJj9dCodTA6LCFUNiC4zQpvl6W6O+3EYkIuK5EtSpQKjdQKAj09wl4vcDIqINKpY5k0kZPQuDZ4w30poC77/bjuefqEFYD5apEOGJhfFzA4yETfWNdoFCUyKy6iEUFQmEL0agF267D57fQ2+tgdY3xo7WaxWyELjAwYKHRdBEOC/j8Nspl0qu8XoFz5yXKJQuHDnuwZ7cFcbyBVNKCJZrw+vg+CocFYrGG0siRyBckhocc7N/nRbEksbzUhD/QVJnEHESjFg4dBDwegY1sA0ODDF3K5SQqVQm/T2Bw0EEsBjz1dAMeD5BKWVhactHT42JgwEG+0EQi7mB9vYlavYlozEIqZSERt/HEk3UEAhbm5prw+yxEIzYSPS6qVYneXsbS2g6QK3jQ2yuwZzcwu82GbVuo1xsoFFyUShLpfhu9KQupXhuPP15FMslDKCFc+Hws/9iojatzTQT8Fhk0iw0EgzbSaaEYbRLRiAWfVyKXE/D5JcbGbCwsuoBotPS3iiVgfsHCwUMOtX2KAovLLhyniWTShitdbGxIJBLA6prE+JgNKYGTpxrIFySSSRu33+bBI4/WURQSyR4LKxkXtgV4PDb27RH41GcacF0L0aiEZUkynXoFbj3i4DOfq2Ogz0Y4LHDhQhO5nMTVeQ8qVRs7dkhcuNhEXx9d0rW1GjweCdt2UKu5yBfquOduH5YzEqdPN2DZEo5jobdPIJORaDRdjA/aKoOri1SSY7bZcGFZAqWyhOMRGBmxsLLMftq/z4ez55vqfgJDQxbyeQkIIBIhKy8UsnDlqkA8LvDoozX09Hgws8eDE6caWMmosDDbQqMpUa3W0dfr4OLlJmIxgVBQoFYjYFqvA70pB1fmXNQVMDI6CliWjaXlOqQrUchLnL9gweOxAUj097tYWXHV+LdQr0v091uwHYI4lXIT6QELY2Okyfh9TaxkBCJhF/19FlIpG8PDdTz3XAOFogO/z0K1Wmf4dUOgUBDIrLpM5FGxUK56sL5Rw/qaRDBEMCEQFCjkLUSiAuGwg4uXGmp8StQqQMMGhJCoNyQOHfSgWJKoVSV8foHlZRtPP9OAzycQizXh9Qokk16sbTTQaDQRixFQCQVtjI/ZmJtr4vIVF+m0pca1CwhgdV1AQMDrdeHzc10+dbqBtTUXPq8Nn1ojvD6B3bu4/i4tuYhGBTKZJkZGbPT1N5BMAhsbzDgYDltYXQ1iZsbF2rqL1VUXrgQuX6EuWzBIRunZcwKWJbB/n4NiETh+ooF0v4Vv+iY//s9fVFEpN5HLuUqrUmBk2EI+DwSDEom4wK5dDo4da+CppyXffSEB2waCQQ98vjpGRyzMzddQqwLDwzZWMnyHSbiwFftpcQnweQW2b/cgFLTw8KM1TIzbiEQsVKoNuK6LmRmB3j4LhROsJyTQk7BxOsMYS9n0IhxuIp22cPSxOgoFC16fB+l+F/PzLqanBKIRgfSAhYuXqi1NsmIR8PssNa7r8Pt4ELd3j4VCQaJUbiAcsTE05OD4ySo2sk2EQwKOI3D7bR7Mzbtkcakw2GqtiXyBpxXRiMD0tA3ABuAiGm0gkRBYW+P7q1aVCAZs7N8LPP5kA6urLjweiYMHHDz1dB0+r0A06rQ0iJ/PumBX17r2ZbaNDYlf+02JdJpA19AgEe9bbuGpgwYjuta1F2J33SHw//088O73SrzjXRJX5ijQuxns0va93y2wfTswPi7wa78iscnX7lrXuvZFsIWFBfzSL/0SPvShD8Hn8133e5vXfSlvvIlzHCAUpDMUjbqo13lQEovxNP3ee8jw+m+/YwSjK1X+1BnaIhGeuMZiPHn3+3jyWixww+v1A81GHcsrdNriMYF8QWJpmb/7fQwpsO0asjmBZlPC6wNSPqXFtdTEVcXeSqcZHlcs8FRXgqEomUwDyxmeOAvRaOmGVMpAPl/D5Uus6/h4FY06YAV4Eg4ooXuwLtR3cqmR4jSxvMITZMciy2Fpsd7SMKlUeP9crolEgifZA+kmLl4yLKRgkPcMhcgS2MgCly43UKuxPsUST+olXDzySAF+pZ1CxxZ46hng7LkGLlwEbr2F4Yi1XhUmlAT8/gZKpSr7Ig94vA7GxhoIBMgYqtXocNVrwOJiCYNDAhPjBBCaTX4+OgLYdpOsmQaQiimmV62JRp3CyjEVprW8bITLw8E6duwAXLeBfJH9ULeA8+cLOHuO9242gELBRTym9H78ZAvVG2QSMPNvk85hAAiFXDQaDcwvcGzUGk0EfGRGLa8o1kCVbIjDh4DnjpEpsrpGgGJkqIGCYvToPg1JAgoeh/3lOEq0PsExl8vVcPYc90/xGEPxTp+uIxoDpiYJNsSiksLtq2TZTIyrkLZSHVfnyC7pSXAuXLnCMj75ZBN+P3D4EPvP6wFKRQKSTz9NJtLwMNs1m28il6cjGAyYLHKQHuTzdfi8ZAc5jsDSkmQmvRzH5MRYA+UymVK7dirttBrw9//IfmMGyQbm5zkW+vq1iLNLXa8AcFyF/ekspD0JMlCqVRP6Fggo5lm2iUKhTk0kC637Xrlax5pii1ydo5PrOA1YNhkzQgBu00W5VMfSMhNO5HImTNR2Ggj4yTQpKi01xyFzrFoDPv4fnHuVSoOhfH6y25aXGgj4CcoypFpgfp7Z4aIRwLHrSCZ5GBwIlNETB2amyE7N5po4cpjjNBIBFuabCIYMM03r16X7TajmxoZi/AE4caqEYoHsF9dl6OzYKMeQE+E4zOW4Dly6BIQiDoRVxzPPsq327+c8yOXJbhsaBPz+GrweE4p39aqax2Xgmefq8Hh533qdbJv1df5fC4s7ThOZTB0LC0pI3WL7x6JNnDtvQslKJWD3bqBSbeLYccYQZzKKWaXCzrJZoyVYq9SQyZDxlEhQw7BQ5L/1dd6nVqsDLq+HJDOnUlX3tYC5+SpOnOAYt5QGVXYDkIJzqNlsolrl/CkU2c6nT6sQzD5g+zbg/MU6GUNegjj9fcDSUgOz2zhvBtIcf6mkyv4oyTAdSFPvsVZnX/n9aszXmgiH2b61Gsdeup9jYGmZCT7CYZZZgGNlPQvkCy4ef6IMn499ND7GcHa3ybUrHDRMqnIFmJ+vo1gk+3hkBPirv67i5AmGt1bKXD9tm0yzhXm+b4UFVKu1VnhzuayyAkeBer2KsRGylnp7gQvngY11rtnVimF0aTZWtQZA1uH1Gh3DWo37+9MqnNLnZTkAjptYjMzvag24fKWM1YxiGuYIlG6s11EqkoV7951KpiDH/YDXQ420Eyc5Ni5cqmN9DThyGJCygWJR4ORJiVye7TQ6wveB10Ptx2QSeOzxGu65m/PnM5/leEzEgcHb2TelEuD31jG7TeAf/lFifR2td2G6v47MKt+x42NGYzTdD+zc0cSTT5PtGIs2cfbsDbdJLetqdnWta19mCwSoK7K2Rirx3Dzwpp8W+PX3WfiJH+8CXV37wu3rv07gp35S4FOfYSjD2992/e/6/QJ33cHxduky8I//DBSLEs8+19Xv6lrXvlh27NgxrK6u4uUvfzl27tyJnTt34tFHH8WHP/xh7Ny5E6lUCgCQyWQ6rltdXW39bStL91mt7HJa84XZ9jh/9Sy2hMn+pUXaQyFet7FunBtII/iuM5816sDRx+h8XL0K/Pt/SJRLBBwswXv0poDREa4jszNoZTyToNNjOwQ0Ll9mSGM4RDDF69BxmJmmI+L10kkEWL6BAcDnFwgoACmVBA4fJigQCJgMdaMjBAaky810RGn6JOLA5Dg3xZk1OjNXrjIEQ2fgisfoNORyrHu9bjRLVld5+JTP8dpEnJttx6aDkh5gm48M00HSoVFCoCVJ0N/Pf5GICqkJCPSpcJawqqPfr0XcRUt83XHMP4+HAFOjLuH3EyRaW+MztHbXydMmK5wO+ylXmO3So5zvSFhlohPcc5w+S4eaQB/7Ihrh/8MR/u5TYWjDwxQS9vtZ54EBOnO1qkp376NTMpAGhgdZZ51VMRxmG+vMg4tLfGZPgg7/+Ch/Li1Rc259nd/b2CAIpDVZfF4660ODqh88dDQvX2GZ9uxmv+fyBHm0LSxynNdqdIKFMFk2dcgkwNCY4SGG0hRLHLdLS0ZfRodSwlJhnT6OrVyWIE+hwLb3q7CfWl1CSvbLI0eBM2ckCkU19wQd5f5+o1vTbPL/uQLL1tvL+6yts18iUZY3GNAsLRPqFw6yPaemOE/KFZa5r5ft1GwylC2eoNbPpUtKiFuFNebzBCTuuF2NtQbrqkN1JcjQy+Y4Z0Ih9mO1SuBrZlqF1UFldLVN1rlGw2S0zOWAs+cZSnfrLcDtt6o1yhLI5YFsVrbCOz1easQNDwvs2M5nnTnHcblvL8fFzAyd6VSKekp+P/stmeR4cRzqBtk222hx0STGuHiR5QqHCb6vZ8162WhwTFsCuP02Ab+foW/1Ou+/fTufOTLCMMJwiIDXpSsM1atUGIZ26y1kUnq9bMdlpR2Xy3E9XF7meunzMUwMgv+PxTjOb72FAJwEcOQI+ysaoeMfDJpQ2LBi5joO162r8xS4b2o9qSDnqw497usDjhwW2L2L7ejYwIP3C0RjfH5vr3kXaO27hQWV/KDAn36fCU+bnuIcIPjPsNHeFJM29Paa9Soe41qUSPCZtsV6nz5NAE2/z/ScD6qw2KQKT280OJ9tm/2r11mA1xVLXK8qVZYxElHzvKZCZQX3xSPDNmamCW6tZLiO7ZhlXXqTXBOEMBlC3SbrF4+znMsrfLctLRHgmp4huNmTYFkLBYJe//4fnE8A14Z43GSArVa5duhkLz0prgfbZtg+vb2se1ix7BYXgWPHOB6qFc7jFQUOZRSAqkNCozGjJ6fbUSc9iUeB8Qk+Q+sOLi3zulOnVbIKcP4ODnIPQMYkv+84AisrkuM0yrUlp8D7O25TYvZZzpMTJwl0zS+Y0Nx0WrTG8OWrwJNPEejK59huEiyH42E7zS+wfcJhtl+lwveAx8NxNzSEm7Iu2NW1rn0ZTUqJWg145hkuRpkMtRMO7OPfu6yurv1n7ZUvF3jNqwU+9u/A+3+Pp/Of+dyNAayP/7vEb/2OxBt+WuLNPyexuNQFvLrWtS+G3XbbbfiHf/gH/O3f/m3r3+7du/Gyl70Mf/u3f4uRkRH09vbis581wiK1Wg1Hjx7FgQMHrnvf1TWJQp6b1Lk5ghn1BnDmDDe+jx4F/ubvDGtLZ1VrNIyIuGVxU7+6avRwAIJPI8PcbC8ucaOt9XnSaf4rFHivuXlAKmhtz26BYpHAhs50ODlBZ08IAiLBIJ9jO3yO32+yl9mqjH29dCKnpwhmpdN0XPp6BRIJgVyOztfCPO+9skJQoF43mkI6fKs3ZTJ1AXzvSiWWaztGDH51lZv0nh46NMdPKEc4SEf19Flg3x46ugA3+sEQnYWZaYFggOXUgvyJODA1CezexXKdOUsR8Y0NJfzbVFnfesg2isUE5uZYtkiEwMXIqNrwzxP8WVhkv2iHpFFnP1hCZcpUzAet1dLXx9+1OLLHY8CNpUUyM0aGyRLp7QN8PkG2mMXvJpN0BAXo4Gmx+NbbQZifS8usxw+/RmB1laDV3Dwds4kxOpK20hN75BHg4mU6/3UFtl6Z489imW3gOATVXJdOYaFogJOlFTqw8QQBr4lxlaY+TmcwEjH7KFvprQX9SrcqbIT3pcv6La+wLYJBMwZTPUoLDQagKCsWhx6PtTr70rJZ3/l5BQw16VBPjLN9CwVqEF04Twe5v4+JC1YydEiPHAYgBCTo9Fk2gZSpKeVsKj2fnNKWq9cNwObzAS96kV43jFB1b5JtNT9HYOXYMX7u83C+9aUEanWO7WSSzmoqJVosmJWM0tQJ0VEUau4EQ7xvIsH5kk4Dg4MCHi+Bh8EBxcoLsu4ehwDdvffwGgHO1atXqfcHMJthMskx198vMJA2Qv3FIlnne3dz/F26xIQaHg/wyKNKC3BF6R45fN727eyXQpHjpNFQ2kY210OfAtb9fv4bSBNo0Jk1A0oTy5VAsyEV21RieJh10My0htKPyyrdt4Cf8/nKFYJ6ep3Yv59t0Ghy/E9NcW2NxcxcchSAE4mYNXJNPePCRfaT1lAcGVYZbNe5vhw+xPVGJ9mwLN5Pj1mtGVYu816PPKpALgXkerwEjVMpgjexmAJ2wbVlY0MBhmHDqoUC7G2bgEM4xLkjJUGSiQne3+slg+npp9kPSytsp7Rq84Bf6XgpRmFviu3baKjMq5L/Ll0mCLK+zvVdLz+WQjG2zbD+IVWmgTTHg2XxvnrtT6WAhYUmIFQ2VofX3HKEbeK6/BkIsA80MzOVAi5cUnpk2xWLqWZ0/qQkcJ9SERJNl+uZpZai0VFg106GxC4sEhgtljhGhwa5bnm9Zv3x+1TmYiig0ubYki4wt8B2KhTU4Ypan111mCEl3xWlMgHGZJLtDsl3ik60UK+zHqfPqIOCnAHnIDgv+9UBTyRCLTFAaWcq9hdAjeBUSiV0qXJP4nGM+H80yn8LC5Tw0euUz8fDEZ2ERlimD4QkcNx+sJZZ5TtFj+WHHzH9/3zWBbu61rUvk62uSrzmRyT+5x9JLCxysr7yFRTr/MM/6oILXfvi2Q98H/A93wV85G+AN/w08LZ3SGRWrz/G3vJzAvfew9OiegN4z3upY9O1rnXtP2fhcBjbtm3r+BcMBhGPx7Ft2zYIIfB93/d9+OAHP4iPfvSjOH36NN7ylrfA7/fjpS996XXvG4up7FUxbkTDYW62R4bNCX+xSEdnz27gnru5cayU6fiFQmRGeDx0FAgS8N7bZ1WmpSgwOqzSw28HDh7gzjq7YdKJ5/J08hsNifMX6BhGInRE+nrp/D5wP/Cq76UDCUEmVDBIR+/qHDfu2pkHyMS6dJmgQCyqxHADBsCoqNANYXHT7lUCzpZtMhzaSog8neaGP63YS7EYN8irq2pTre7ZaACREJ3+e+8GDh00jpNlsc4XLpKNEgjQAdSsAgCYmhKYmhCwLDoTjofPv3KFbavFsQHWfc8ulqtapXNXq0lks4apl+6nvsv8Aq+LxdgnU1Ns94lxOn2Ow36cnODaXdOhLDadCY/D9trYMOyvWFRlufPypL1aJQiyY7tEZpWO9Noax0Y6bcTmq3X+v6lANZ0B0bYMI8txJAX9G3TmlpZYxv5+AjyOzTFTrZABsrzM8ZPJAMMjHIsaJN2zW6C3V2BsnE7/0jL7ILPCLG/JHrZFJsPn6Axhmt0IsJ57dpOh4ldAjmbNTU2RwTM2RhZRpWIyjm6bYVtpABjguE6lCCCdP88x5PezvDr8NhZjWVfXXBQKZCJGI5wLPj/7p9Gg4+fzGcbNsWMSuSz71LL4954egfvuVSCDRzngVfbb6CjLPTLM8uryazHrFz0ocPAAQfCeHgNsJBWDZG1dol5XZQCZ3pbF+kCFqTZUWJewzJiSLsdZtcKwsNFRAkLjY4rRpwAkDRgMDbGMS0u83u8nyyyV4nwDCCgMDggEg5yNfgVSF/Lsj9VVgmCWIOBRKPG6XI7z4+w5k30UUG3rJ8Dk85sMfn19Kvw7RGZnNGqyTgowuUazyfXE8XDOelXZts14UKsS7MjnCSZkMoYNo8PUnnxKsWXBDHeBoMqK2aMSgihm4G23qsy2aqhKaVh14RD/nT8HZNfZzhcvck0sV7iGCotlLRYJOroux8nIiBKwLxAI1GOjVGKYX71O0HBslIylQp7PPnNW4sJFzsfMKusSjvBeGvjK59mHw8O8dkEB5hcvEXi2BADJde38eZZ/bg6QTV5/6TLbWrMqbZvPikbY3j4fGY/ZLNcWxyHAlM1yPGh2bb1u2liDPVIa9nI8TqCyoFiS8bjK1KlYu6GQgGMbVq0G1CAUq9PmNaUSATFXCgwPcQyfOME5nErpUEV+3pNge125yvW/r48ZXDX7rlIFmk2J5WXZCm2MRtiOwmLylmxWJZVR7OBm07yfgkGuxZUKGai3HFasJvUFhp3zfVsqcf2uqrXL4+FBk06YsLJi9gaOw/H4g69mcg/NZAV4D1eaeaWfNZA22tI9Pfx7KMR7e72cV/fdx3dpMMjkB3619i0vc9y4TbLMJiYEvvPbuU4ODbKPt81w3q5kjAB9ucx2OXiA7LyJcfal3jM8nzk397Wuda1r/xmTkjpdFy/xRe+6wLd8M/CGnxD4/leZFLBd69oXw4QQeO2P0AH9i78CHnqw0zHbbI4j8La3Am/OSzz1NPDU08Cf/yUBs651rWtfWvvhH/5hVKtVvPOd70Q2m8W+ffvwoQ99COFw+LrXDA7auPuuJqQrcfY8GR+9KTr1zaaA3yfh2IBUG914XCDZI2FbdE6qNSAi6KAMDKhQI+V4HT+pMhK63KRvZI1TRrFybm7HVYhNsofskf/4JIGyV75c4I//RCLRA6SSAuUKQZcLFyUzA/rpEESiwPZtAvv3Sfzmb9N5jMVMJqqTp0xo3sS4wNlzLERUhXQNDjDM6elnJZIpOihaG8Sy6Yh7vQJer2xlLxuYJrMa4He1VmG6n47XU0+zrD09AnPzspXZqlrld0MhAcuSraxg01MmTIvAm8Dtt0n8y7+x3EXlmCeTPMX3+wXGxuionDnL+0vwXtGYCueMAevrEpevsP39fsDjFehJSKytCwghGfqSNMBNsocObrHQOU4CAQItpZIKabUVQ0fp0rhNiSefMuF95y6ojJclw3KYm6ezkYijJeAsLJV9ThqWW7VKRmGjQUCmXlOApALcFheVBlGMjnmih8BVPMYx6HWMAx8OAfW6hMcjkExyzNQbClyK0il0HDrguRwBk1CYwIiweH+ADlYuR+DG47APEl5+Tr0wpU9UphMmXTqNq2tAOMKxEw6bDJnZEtu52QSiYd7P62GbeL2KVRcAgkEBv4+hmaEQy1NWANHaKkO3VlbIBHFsFarlZx0k+KxgAHBdalpJ0LEMBFTGPMWsyeaAf/0o6xPwc9wDwNKyxMY6s7zpMGWpmCanTrHtJsYUY7JPjV+L9W/UFfjSBioABK1OnSbwpteElRWygnoS7N+hQQKI5QqwuMxx6XEIZhSLZLxEo1yPmmrfW6kAritVlk2BxQWOH68XePUPANGIQKNBPcDelAqRzhMQXV5hOwFkk62vq2yvKgQ3GiHAB9D5l1Jlu6zSwV5bZV8Hg1wDpqfY1/MLXOf8foFsDujrs1Auc+1cWuJ4rVZUSHSAczcU4ho2MkIw++JlAnEn1XparxGIA4AnnuT3dKgWQ7zYjmfPk9UlAcQSDHs9f0GN3wLn77QCvS9c5PxZXFIi4Gq9qCtWjT/A+WkJltEFsHsP23lkWMLjZbuVKwrIrPHnzAz7pVbn+JyaZN0KBfaBq8aHZRtQ33a45q6tGU0wgEDYvfcADz9qsuotLnL9qDeUtlyN745HHmU/NJtKfyvMsXroIJmPxaKEx2OYfPoAYSUDjAwLTI5LnLtAFpIeX5EIEHTZP02Xa9ulK+ZwZGGRa79HhbIXixxTY2PqkCDLsbdnN7CRA1bXee34GOeVvo9mpi0sctyXShxjy8tc53I51v3QAc7VZBKYX+R7KJsz4fSDgyZse2NDsSotYHpKIJenlIBlKwBIT071H501N5WkZplXhTEfOigwNSnx9//E+ut3TmaV7Qxp9PkAXq8PETb7DpppNz7Gsbe6xv7YyCqw3QEuXxa4926g3pBYUuuCfkY8prK3hvi8oSELu3e5+Od/YZl0OPrJk6yXUMxln4+HXrEYx0GzqTLK3oR1mV1d69qXwf7uHxi7vH0W+Ov/C3zDSwyQkIgLJJPixjfoWtdeoAkh8BM/LvDKVwAf/TjwG/9N4tnnmIloK/P5BH75PQJTU3xh/Y8/lDh1usvu6lrXvtj24Q9/GG9961tbvwsh8PrXvx6f+cxn8Oyzz+JP/uRPsG3bthveo17jKbFmFeRyTC1fV6ew5QpQqtBp9PmA546RtROJcOP5kq8zJ8NnzqpQPx3qWAcglZB7hU7Y2bPA2XOypUtkCTpCQgAjI1bLKWaSFUm9nKt0Yo+fkPj8IxKTkxSYjkR46vsDrxK4/TaBQMBqscrGRskQEYKb6HRaoK+/8/04OEBgKxAEVlbYBkKwnv39FMLvSbAs1YrE+obRGLpyhW0Ti/E7jsN2SKVUmFyWzrvrSlTLdBZyOToRQ4Omv/buYQiR32/KpYGGQECdVA/RIZ+fp+Pn8/Ee9ZrE6TMS8Ti/X6sy9C4UpKNZLpPJEQnzFN92eM2hgxbuv5eO0JWrdNAjEQIoQ0N0tAIBA/T4vAQnIxE6x6EgQR/tGNkOWlo646PKWUsqTbI+lndmmvfVGlvlCh3GkWHjGNUbhqkRiwn85E9QBDsao0MfjzMsJRAgGOE4ClwD8JM/ARw5IpDNMnR0bk4xHC4T7CwWJVaWFRNrko57b5/S1FF97vOpsLoN42DrsN2lRTqSjTrbub2fKhW28aoOj4kYnRv907FZv7ByzDSY6vMpEE/d07aMQwdQh8rnZX0uXzFhRl4vAYd6XQnllxkiS601gUKezqnHq5xHi6B1LMrrR0ZY1kKBUQErKyx/KmnChWwbePQxjgOvw7pINR6yOfb5yDCwYwfHJ4XaJYRFoNBRGj35PMEgzeK4OsdkDVNTHAvxOJ33vXu4FoyOcP5ZguXz2GyzuXnWKRjgWNXyhDpkqlIlY+a5Y0C1KjEwwDDSHdsB2xKwbYGrcwIrywRvoJrZdekYN5qch1ofSwi2V8BP0KhUYl2aam719LAPS2Wl32YTkKg3gFNnTNna10SAQM74KOsPEMR52TdyjbAEv99UjMcjR4CdOwS8HgPIRqMEUMIh9q3WwBOCc27XDj5jYpxtHo9z7jUb/N3v55jV4WE6NFsIBeQ0OL9KZRNqOzHOvwVD/H9fL4E6gH05Pc2148hB0QpFdF22T6XMMgwOcnwPDvIeOoQ9neYY7utlWw+k+U+A6/joqNEC9HiotZZKsQ9th8Duix7g+AwGDIAVCBgh9ttvBQ4fFlhdlSiXJeYXCM561XstGBRkm6qxNDysdB4bXONjUb5HtAZgKgmMj1nYvo111OGzhw+xXD6vYnMKjstUkmXQSR/GR5XGpId9Y9mc96Uy37233cZ72uqwJZXiXI/FKVdz5+1k2uULKpxQsdw0q7JW5Zzq7xfweAQSCZbFsoHHnuA4WFs3hwrRqFl/9Prk86mEMnE+v1RSQHyF8zCZ4DvUqwA12wb+7WNccwMBliUcNuHyeg7o9T6b5Wdkw/HDK1fJHq/X2daDA/xOtaqYvAqETcQM89MfEGp9kC2mq+1wP+LYTLDjccz4jkaATEaiWpXI5tjOd9yOm7Iu2NW1rn2J7eIlid95P4U3n3kWeOk3AK97LfDaHwd+7wNdMKFrXzoTQuANPyHwqu8F/vbvgR9/PfDHf3L9MRcKCfzG+wT6+6BCUbrjs2td+2q0M2ebePpZ4OlnyRawVNjD6bP8uxDceI6PC6yvCywtc3MspRH9Daqwr3nljOqwNM028vnUKbBkCNo3vJgp3nv7lB7QAp3tUsnF4hKvzWZ5gr+g/raxgVYGwXBIoFSmQ2ark2kAePwJCUsQUNEb4ZlpHg7ddivw0IPcUGsGRyqptDokYNmCmcGyPD3P56mN5PWwjCdP8ZQ/rsI+p2fo3MVjhjVmWdxMa8f44H4+pynZZlrvSoNqUG2Tz5Mlo02vmf/6UToSw0MMzRIWdaxmpumAnD1PZzcSFipUj2uvDmkLBOh8QbJ8WigcIAtXgzW1Gp2w5QydiXjcgAEA8KIHWWbd98IyIudSap0ggT17BHqS/Ht/n3KglHdw7gKZOlNTJiQym6Vzl8urB0kTfuf1ApcuCUTCAAT7qloFDh6i5tk3vIQgZTarGGOK+RZSzLBAgG2tw3+00+t4TB/MzSv9oySdsphi1YyNKlF25SgBfBZApkp/Gti1i2xCAYIBvb10hotFOlPVqtGmAshg8ThAw6WzWKvRIdu5g470uGJHNV2CWioaCgAwMUmHVwjDanIclWFSgZD9fQTx9Ju2p0cxPGzTjzMz1McpFgnWAgbQjMcUOAz2TbJHgRmSzuS+ffy77fAZ0Sh1cjweOtM+H9cCx1Ghi3UCB7ZtBKO1sx0KMqxLj6FsjoDUix6wWve5+04VBugQgJRgO22fBV7xrXT2dUZEnZAiGjXaO40G7zkzwz5eXJK4eEmit5dM0HKZ7bB7N+9TKplQU9dlf44MsyyplMmoV1UhiH19HGPT0wQiHQ+Ftaem2Le9KbMOMLyNPTMxbuPO2y3s2ycwpMAisiRFCwzo7+fzFheB557jeN+9i323bYaAx/go2yLdz7Gq11fH5lo2PCQQDgtUawQhSyWybypqreztVSGzMGuRsLgepVXIl20RSBocVJqGGa5F8TjXVw0M+fxcfwbSAo0mtcViESN6vpFlGVYyHA8P3Afs3SvgD/A+e3axHQMBPs/rZcjf9u3swx4FiEoJfOJTKuGDl4DZjlngFd8qMD7G5xWLZIRFIhw7yyt8lwVDTIBy4qQJV11aNpmE9RqhJ52UHEtTkwRyY3HRCjHVAHhvykY0KpDsUXNPAn19ArUq56jPx3Kvr3GdGxhgObNZjpfv+16uYxUFOpKZCMU85PP8fq5L9TqBrWgE2D4rcOstFtbXCBznC6bcHo9iWAqGNLIuDDUeHmJdS0VGB2VWOcYlDHPYdvjMYJBAuSV4z3hca1xJPPyIWjcE2zgYMuCesNhGqSQPKebm2I79fSaEcvusWZN8CqgD1FqgDokCAY5PJgER2DEr8KIHqevlulw/qhVAn+UJwT5dW+falYjz86YKyx0Y4Dzu7eNavrjEfxsb/BeP3xxRpAt2da1rX2L7p3/my7LZBL71W4Cfe7NAJCLwA98v8PVf12V0de1La0II/OgPWfjx1wpIyTCE67G7AIbv/LffIMvgl98H5HLul7G0Xeta127GImEB2+ImOKr0iCYnjAMp1IZ2IM3wi34VqnTxMvD4E8BnPnOtuKvOkKXFdYNB4MH76ABGowJjoxbm5yUiYTpxAtxs/9vHDMMlFGLoTzCoTm+VQ9JU7J/REZZldRX4/CP8WzhMAEqHoc3NUT8nEScQoe22W4H776UTAbD8fb3cbPf20iHPq1CQxWUyy4QgcDQwwLZIJpRI9gY3+ZrBMzJMxyCRAIRipPh93Pgn4nTcTp5SbAK1uX/scW7wtdltDvu5c8DTz0isrJi1VgiBVFLggfsEDuwT8Hg69aVSSToUD97P0D0JkwlyZITfyeVlS0NlY8NkUGwHjgoqlNHnpRNWrRKYXFhsO2GPU//EsoCNDYKN+/eRGZXLGrDF66ETosMcW4LIy0aLqh1g6+sFLl2WKBQIBI2OUAMtGgYOHKBDawvgnnvoFH3ofwMnT0rEosChQ8B997Jc+/dRsyscFtixw4y1eIyyD5bg+Ny7h2Neh5M5HsP6AljPndvZl1p8fMd2yeQEKvxwapJsC9vh76Eg4Ki+9PvpNA6kgdtuYT/oEKSNLJ3EvXsEJifY1m47c04YcGvbDJ/n96MVhpTNso9HR9ie5ZJErmC0mwCOdY/HaDk5Nsfqnt3UHUr0qOQKOY6VZ59TzBOfGnOqDXpTBAh6EpxvxaLEseMSQgj09NBJj8U4zvv6CMyGQibBhdb30QDn8BDHVzgClEoSqaTSw7PVs8J0pkNBAuVX54BwWGB0zIh49/YK3HMXx5cGN0MhgUiE42B8zGTyjEYIzGUUaDw2ynpo4NsS7L9o1IQmA+wfDXIAdOjX1zl3/CrsU4dUaVA+GFR6f/1tGWrVNmh6yqyblSrw6c/KVnIMslpZtr17ON90uPCO7QS6bJvP6u/vDBHN5oFnn5NYWpK4coWH440mn7VzB9DX36mnpDM36j4O+Ll2DQzwc0vwUMNxTNtaFsuoM9idOSvx3DGJep16i9ks53+lagBJ21aHIhb3jrmcxPZZrreZVY5lvQYGAsCVKxLLyzzYX9/goYcQrGuhyP45fBD4nu8GKhWJ9Q2Bu+/kGJlfMGHEUHV67DGG5Pb1cVzZNgHZyQmu19WqJACqrjl3nutsocCy1WoESoMB9n0mw7lRKEjs28c2bTSAq1clmi7HUJ9iL+tkHppBWCzyu8mkhUhY4J67BMZU2ObaGgHJf/+ERLpP6cOpgxidxKBaJcu5WlMM5rRZp3T/SLcT6C+VlZD7sGgB4ZMTvL7ZYNmSSTJyy2WOmbU1vke0NqVet3t7+Z1qVYUp1/iuf8XLgW9/heABgeC81m+lvGJlMWEJCxuNch3R4zedZt1PnuK8nxg3WltjYwLhkEYi+T4PBIEX3c/3stfLubJ/H8dAup9ZSENBrjU+n5IfUKGWhw9xvEvJd8HIMG7KumBX17r2JbRMxsWnPs0X9k++TuBNP8UpZ1kC3/rNAjPTXbCra18e++7vFPjZnxF45FHgTT8r8fgT1wexhgYFfundAqtrZIN9/pEuw6trXftqsm//Nj/uvw/47u8yLI9ImE41oDaJLsGRxSW0xJ/7UnRmKhVuNFMq5EKfLFuWYXZpQeV83jy32eSJ9MgwN6ejI4YRBtC5e+hBgaEhOobaIZMgIGPZvGcuzw07AMxuE9zMgg5Uo8kynDhJ510bWRSitcl2bDryMzN00rXzqlk51ZpK9z6iRL8XqZVUKtMRKpZ4ogywDjPTSnB4kZ+5LgX6Dx9SQt6C7+4772DGOC1krU07FfE4753P04HbbLt3CfT1CVy5ShaIZm0ND5NFICUdfO3E9vcZR6NUZB9PjNMx0G2v9WjYTvyZy5OJl+43bBvNANy/nyGkgMSx48DRxygqvbhEAXCt0yIEtV905jId0hYK0rEWQjEsBMGOZNIwJG6/VeCB+wUyGTo5Z8/S2ZyZAb75pQL79rBce3YDDz0kMDhIbaL1DROec+/d7KNCgUBSNGKyrNXrJtGA45hQJc1GAlimUpkZx1ZW6LAffZwsg9U1A27YNkPxPB6O73CE4/iuO0wmvd5eOre9fcBAWhDIlQx59XqVHlHdOLDnLjAcNRggCCgEnetQmNfNL7CumQxwx+0CL3mxQDhowk8Bk/FU6yN5fWyboNKJKip9sSXFrAyqkEXtbApBYGV6mr+vrQLFEvWyRkeBkSFgdkbgyGEylLQYfSJBJ9bno5McjZqEDjpjYCgEXLkMfPbzdLDPnQeeeoqhegODBJUA/iwWCIosLXKuavP5RAtI1fb5h4F//TcgkxHYuUPgrjsE6nWJiXHgyCEKVEOyzW65hZn0LFuH7QlYloDXSzBxfIx18SpWYC7HuXl1TiWgsMgUKuR5fTrNcX34ILB3LxlwXAukak/R0ugLBDgP4jElGO8SeGVmR4HlFY7ny1eAx59kHZeVxtmpU9QHBAiwlMtcSwslgqiNOsewZZEZFg4Zjb5SiX2SSIhWH69v8J6ra5ynPj+/o4XeATJrX/NqHloA/N7GOusvBH/6/YphkzBl0xn5fF7Ol1oNrTD3VvZPFYa7kWU48voG27RSZdtE1DuqUqaI/1/8FfCxj6tQUY9oAYJLK1wTBtLsu74+PnffXoF0WiAa4XujUua7Qpvqnlbf5PPAwhJZyw/cxzUnlWI75nISG1mBZkPg9Bm2z7PPEURKqnpbFtl+vb3A2pqEZQvceSfXhI993MXDj0iMDPM9aClGbijM9xG1KIF77xGtQ6ZcjgDi3DxB32/5JoFQQAHTXoaNz88b9qfuV9fl+jo0KDE9RYaZz8f3Tq1mElLYDp9rCd5v104VAttkH4XDAj1xguq1msqSWeLv8RjHtT6YCgSAFysiRqlM8N3rpcD+zu1ci65cVckSVN08HsUuVUDa0cdxjbmS7XXkMPt8aYnvUyH4Xq9W+ZyIYhceP64yQdfVe0eY9+vkJJAeEN1sjF3r2lfa/v4fXXz393Fxe+UrgG//NoFCQeJHfkzisce74EHXvvz2TS8VeMcvCjz9DPBTbwIuXLg+4LVvr8Cf/wlfor/8KxLrG90x27WufbXYkSNezM4IeBwCVlIy3EQzle64jRv8eo1OX7XC+evx0MFNpoy+TTDIjaoruXluNpWotEPHUGvUACZDYjZPBzIWE/B6yWzRujlray6qVTpwySSv0Zv+SoUb5ZVMpx6ODjcbHOB3HYdO387t19ZdCw/bDjV2zpylsz08ROeo0aDjOD7GUJ6VFbJeLl4Crsyx3Ok0nYFSiY6V30+gIBQ2m3+vlxttzYhqt717RSt8TJsGCrwesjHamRvtVihIPP6ERKkkMT0tWuBIJMy+KJVYZii2Ur1OcX8+hKGM4TD1XFYydAwcx4CXOpwl4OeNEwmCPl4PdYbCYWqdnT/PzIlR5aBXKgTRJsc7T+1nZ3n67lEgjGUrcWjFihEWMDRgwqiErcLGeiTOX2A40rkLdLIuXeFzTp+RyBeAb3wJcN+9Fuo1gmrPPUfg5sIF1ZZegWefRQtMW8+q0FKL/bWyAtx1JzAyIrCxoUAhoTLDQWW3VNpmoSDH5EDaMHUaDTqZUjIsKxZTIX8SeOJJasmsrvN+jz0msbIC7N7JcZXuo/P82ONkNUxNEjBlBlGGcoYjwMoqwQ6tPSMEwS+AIT2PPQE4NgXa+9U9NdgQj9OB1vMaIGCyuCSRz5myCZDJIyzqv1mWwLZpArWWJVpO/NqGmTvpPoFIFHj2GFk2mg0qBEGIUIh9prPsFQqGAXnxEoHHXJ4ggc4CGg6z7dbW6JSPjbJNp6boHC8ssW4veqBzTuj6bmzIVl/deQfLDhCEXVjk9yYmBVIpgekpgZFhgXhctMKatfl8AgE/mUX5HP/UUGLoWoNOSn4WDHL8p/sIhpZKCji3RIut2X5v7WALAPffR5BQugRlPV6zDh86QEDadjhHdeKGbJbzo1Zl26b76YzHYtQlm5mmz/Bt38rwukKBAPfePSrEVzGALMscKFgW23xlxSR5AFR4pJoLnLdmxZoYF9i/n2vl4YOsh0cxOXXikl07WA+vV+CWI+x722bb2Tb7o7+XSUWCAeDV30dmjtbv6kmwDKEQ9Rq13pjW9IpE6A/5vCrBh8ewqnw+HoS0+hd8T8zMEBRr1E1fbAY9qlWCZMkky16pqmQGIWDPbhv79kpsZCWGhtjed97JdWSHCk+2LGYRHB3mmL56VWJJHRpduUqg7fOPAPmCwMiwyXh6yxGBREIgm2M733WnwG23skzRKDA7w7rPzas5I9jee3bzsMPrIVAJ8B3kugQPFxaA545z7M7Ncc2ZmUYrC6qURpMwlSRo1tdHQHxmiuOkVmd/hcN8pn5fPHeM13m9pv1CIfZfb4r/DwXZJkNDPGxybM79w+IAAHBUSURBVLOGZVYJwu/eRbArk+F7XJt+vzVdPsPjEZif5z7AgMhKlytKVmCzyXbKF/icnqRAIk5wbnYbDwUgZQfz+0bWBbu61rUvgf3N37r41V/nS3P/PrK6AEUBF+Ykvmtd+3Lbgw8IvP0XuLF469uYHvt6FotZeNtbuTl788/Jln5F17rWta+shYIEYz7/CB2UsREyW3RISSRCTZ5KhYBVVTmjUvIUPh6jMxePc6M9MABUqwK2zRPw225VuloVAwwAZAqNjgqUS0bMGeCGNBxiGR5+1IRo2TZZTJZtWAgAN/U6M9mnPi2xklH6OmXjJO/eybJstnicm3ztiOqNu9ermBuK/aT1m+bmuVlnuxAQSKVY7x3bgVTKtFUyAUzPqPd1jmyVc+fMu1vb6IhoCcJrs1X4Y7lsBJy1tXTGwD7TjDKvF/imlwF7djkIRwj01GpsKH3KffmqCe2x2soQCJChpnW06nX2b7lkNLqaDYm5OfU30HnxeHjg8anPsH8AjhGGujCcTYdNXrkCpPsJLHg8yllt8sS/UjWMJcummDhAR9zjBU6eEi2ds2aTbTg7w/r9xyeBp59hOzzyqIsLlyQuKEBsbZ3317awQJZIvdYmMm+R2bJrl0BfL587PcVxrPtBt6/XSyDIVuBqMECnynE41nRont/H8RsJc++2usakD5Uyx1GjyTo7DsGkW24F7rrDsBcvXuTebmJCIBQS8PmBB+8nmOG6fK4OS9IObbKHzmjTJYBk2XTodahqMCgwPCxaTC+/jyBTNEoHvq40xBJxOov33UvdrNltSizeErh8WeK5Y2yH3hQQjUgyKhRgODLUBjxLjqvLV6hZFPCRLbO6xudcvMSx1Wio/twGTE0KBJVWz/Q054x0ObcGBhiC9aIHBO6/l0w9jhkzkIUgI3DndtZ7dIRz0nUJMly8JJHsUdlNi2Qg1mrAv37UxdHHJPJ5CSiA7cxZ7lECfmZo7UmQ4em6BChf8mKjK7S2ximd7gcmJwVCYf7u85o9utbHc7cAu6TUY0FlFO1nf2hgvKeHfXfLYYKErgvMTHPMDg0DtgKOQyEAAjhxguDL0CDvuZ7lfUolI0g/M03tr/UNYCMrEQgQVPV6yQCbmjSi3hsbvH/rcGCTxy8lGT+2LbCywn5xJfu1XOGaUSgSlEinJfx+9lskIjA9bcBCj5f93NcHJBIW7rtPYGqS4E9/nxHWv3QZyBfJ6jlyiGzCdL9ALCYQCBJgHRzgOmVZBJBLJdnR5pkM+18DM3oYDaQ76zY2pjKbSuDRRyXm5tl+/gBw/ryLpSWBxUWBeIxg7KEDFhyHDKOBAT6vVuOc93oJ8Hi9BIWHhwiQXr4s0WxIFEsmRNRxKKKuw9N9Pgr/AxxTo6OMmDh1mmtZfz9BzKEhvk8gOpOe2Db7ta8PWF2VqDc4jrfNcH75vCr8Uc1bHdK5usqw354EMDvLep04yfeI38/xFFLl0nqbqaTAjGKAHj8BpHoFwopJOzwssHO7aPVFMEggfVYxyQ/u5z5kdJh6XO17BtE27lZXgUePSiyr8H79Peo9CvQkWCe/HwgoNnp/P0HnfJ5rkWVxHT595sZZ5tutC3Z1rWtfRGs2JT74By5+47f4e28v8MvvEa3TqcEBgf/x+wLbZ8X1b9K1rn2J7UUPWnj/b5Ny/kM/KvHY49dneI2NCvSnufH4h3/6Mhaya13r2g0tHAbiMYH776MQ78AARZE7TAgT+gNuFp95hg6gtnhctMRnLYvvKUDA72fYVnsYo9dDRtDkROfpLUDn0eul6LnfT6bExDhDPx56UACSjr7O0Kcz57lKIywc5mZ8bo5srVCoM1RF2/QU7x9VIXWTkwJ330XAp1Bg2MfH/p0bZi0u3N9PBkoqaTCr0VEFDpVl62Q5kYBSPAYiMYILHsXciEY6y5FOC4yPi9b94jE66kcO0ylbyfDzgTTwvd9NZx8gkLdvDx1NSCCVtHD3XV5EwwKuNM7B7DaKHUcjZK2p7mSdJ+g4TExwnwFV7NU1smhSSQN+NV1+9+oc6wHQYe7t5d+1JsuO7XTgdHgMwJ/TUyYDmaWAJNsCdu1kpkxdf102KTlm+ntl6z6ASXogBLPtbd/OcLVHjhLEi0TY/rOzrN+dt/O6HsX6yeaAunLc9+w24NXTz5AR1ArVbNMWCwQE7r5btMoxMMB+iaiQo5Fhjv0jh9j/vb0KCFbX+xWQtbRCtuSe3UIPD1QrTD6wfZZOYiymHU+JjayrgFvBLHyjBFhtmxnJ9Fjq6aGzeeYM59PoiAJtFXNSZym1bTKVvD46rw89KFqZ3DwegliFAseq3y8wNEgWxNKy0ngTHIc7dxggzbY4JlbXCNpoPSmh+j2bJ2BRLNK51fpn+/aaMMtgkEzF++9V4YQWgZ3t2wkoHTnEsgaDdLh37RS45Ujn/lf3le0wvDIc5hg4f4FlW1sj6Ndscm3o7+M4OXeOv1+8xPo5nrbsdGqcxmJ0nr1e1kMoBtj6BtedWo3MPrcpUa0QuNEgKGBAlnbnvf2zjQ0JVzKEzOcnGzURZ5t8/mGJSkW2NNjKFWBpiYPH66h2bvPCG02uCQcPCCwucj1zXepVDQ9zXgshMKqAaLuNseVxCHboOapZWpYlOjS72u3iJYljxyTqDYnjJyXyecUSFBxXlTLbJxDgWNKgGecF50G5wjGU7ue8+ejHJU6dknjmWYasVmtKDD1AIK2/D4CUSKe5Jp0+o5g9Sl8qX2gDegOmzLoO5RLD6sZHDTN5c/8ABO8nx4Fv/WauE5bgdWurwNx8ExcvSdTqEpev8jAkm+1cq2ybYcZaL+/l3yIwNEjQ6+ABgfFxrg21OstBjUqBWo3tUK/rckmcPcf/S8lkLCsr/D0eZxufOQc89bTE1TnWWWf9BUwoo20LFIscE/ffKzC7jSAlBA9IpCS42ZtSayxU8pJl0zYjw7x/wE+Wm04goA82gE5JAoBtODGuyq8+CwYFxsYEkkmrpQ0oJRmi0Shw952iQ0tLz/ZggPPDdc3hU3s9m02JRAJ41fco/ciCxOwMQ4qZ9Zlg78iwYaDerHXBrq517Ytka2sSP/1miQ//KX/3OMCv/QpPQYpFiT/8kKs21V2gq2tfedu9S+C3fp2bizf9LF/CW5njCHzoD+jA/eu/ddldXevaV4tFIgK33SqQ7rdw953Ay75RoKdHsWskN4lHDhHMCgR4cpxI0DHTm/HRETp62sHgibrEufOc58UiGU7a+voEiiXq8GgdKYCixyPD3JTffx+z3h08QMe73XzqRD4eo66ILquUBKTCYbPhPn6C/zabzydwcL85RALINpKSDmdIsTJWV3VWROM0tC9fAwrEP3uOf1/JUEdHs+MswRNkr5estWDbBn1tTSISljh8SHZorOzYbuHuu8jEKZWM6LxlmfJumxGt8KRaHVjfkOjpsXDuPO/T7gBrQX99rd4+VKts83ZGg/6b3y+QTJId4jgEWpJJFZqkHCm/j05Lo8FwoHIZOHbSaN7oe9XrZKJlMhKxGPW/YtFOUfrW81W5NZCTzbEu+l5rq2RcDA/zu9OTwC2HCWqFwyxvs0nQJhQ0OnPBEMMBhWA/Ox6lC6RCWCSAA/sFHe8rncwu3Y8tQMUmkNTTQw0gn49MN8ch0JjPE3zS7bBzB5kUnrZ76jE0M4OWML3fLzA0xJDe1hiTvCbdT6BC61wNDRuAMhjkGJmcZH0PHqDOj8+rnHTNlpMS5UpnaOzYGFlZOqnEwgLf182mxPo6mZeNhmIzQglWrzGkl+OE4N/4GH93HIHbbkFLK8rvQ8tTHRnhoLjjDoHREdFKAnDiJMfHRlbg6lWBxx7n/F1bAz73eQIq2hYXJS5fIYOjY9y0/dp0qdn1L/8qsbrK9j94gJpdA2lgcopzslAADhxg+LQeYxq8BEzm1sFBss28Xs6Zzz/MtSmXN1n8mor1FY+TISthQGFrU58DKhw4xrWqVDbOvO6bkRHOu0KR8+rhhwnM9fVyHuayshU+zkx5LP/EOGAJibPnZCsDLNuZQueVCnDpEpM/CBg2niVYn5OneThgKbBKs049as3dDHaFIwRgLcHvVsoElkeG2e7hCOfybbdauP8+qyPzXVOtpTojYrli2G+PP8Hfhc0x2Wgw0+NrfoAhftUq8MlPc53VrEpLsJ8ETFKIsTGu9Rwj/JlMEahuNk24IUAQqN28HgL6lmVxfEsCQY0GsLDoYnmZ4312huPi3z4mW+uu4zBb5Hd9B9eJcoXvunvuZvh4swmMjRDo9/lUFkqX71GAzLVm06zXuozlMlmrtg0FALON8wWCQKUSWZ3t70wtT7C8wvdMRNU5mwWqNdnKyimlCqV0lI6kYvblC/wJADt3CIyOkiU2MU7g8MJFM8bX1+U179uBAaNbp+2eu4D77jFtBbS9My0mhnn6GfN9Pb97e/kuvuUIcOst1GxsD6stFIBjxziOMhmGLXt9HDM8ZBHweuhTx6Ks4816012wq2td+yLYk09JvPqHeJqh7S0/T+o/ADx6FPiTPzMZTrrWta8G27bNwi+9i87Hm35W4uP/vjWQFQ5ZeOfbBN74k8AHPtgFvLrWta8GazappVevS/j9dNh1eIcWMNYOyto6N83xGFlF7eF3S8smrM62+b3VNWayKhQZFrVbAVOjI3QqN5/ZjI4I3HqLwPi4RGZVQrpkZuTyEv/xCYmPflw5Ag5Dn2Jt7Bmp/nk8Aju2M7QyFOJGvT3debtpBoe2tTUyre68XWlugQ7ZygqZB5cv09GplI3zUSyxACPDyikRvFZv4KsVOnujo3RM23W7yhXqtZw7J1rhINpqNTofkTDZUu0beoDg1sOPSKyvK5aHAve8Wzilmj2hWRW63nPzZBJophRAx1Vn3gMUQ0Bl2wsGGb6qWQOlErODVWtk4Xzdg0xeMDHOZ7TChCyGiqRSBFZvvxVwvMZJ1+GVgHE8BtUzHMeEgWmLRgQCAe2sCwwOMuTPshhqWyoBC/NoAX8AgS+flyFaUqqMh5tMurKVoCAS2QR2tbWnBm610D4AnL8g8fCjzAhpO+w/DcrOzir2wyjDc0+dMu++RJwhWJtZJS3QMWBCQ+MxlQlyliFI0QjH2+qaQDgi0N/PizweA4SW20I5NZBSKjFr30c/LvHq7xd42csExsY4V6Rq82oVePJpfn9yQmBq0jje0YjSkbIJXOfzwPGTRjunrp4jJeDxGZCnUqaDnu4XLS0hKU1ih1iU40Rn7pybZ1l27jB1WN9gvy4udu4f2g+Atai9JYDbbzOO9to6K/DAvRQpD4f5HY+HfTYyTDDJtnhvDUxfuGD0fzTgu28PMDxoQr/SfQzhnpjgmlGtMPlGPGaYdT09ZhC1xrUQHcBqKMixHwhQf+uhB0VL2D8QJGgdjwvUlNaUzo4JcF39lm8SKBQFLlw0bFohBKpVicwqgax6Q2U4tExWWsfh4XqzgZbummZ1AmZe2pvmYm+S4y4RZ3bYHTu5Fnh9BqxrD6lrn1OuS1DC66W2VShk1vNmkyzF7/se4O67uAYmk5znQOfa3dL5U9f2q8Qf5XInwKgtHOL4zRc0s0t06FxpS6UExkZ406bL+bO8wnfP7l0OdqlxOTIikOwh0KbbRwiBqSmhQsMlggEeAD3xJAu0vmESj2hdt1IJrX4F2tpekAUGcHzs3M6+Pn9BolRSCTWU/trYGAHmctlUXAvJr60pBqYFPPEkdf4G0tQDG1Rjuf09pLUYY1HD7KpWJaSktlY8biGZ5BjvV8lhNo8PgIc/y8udHeHzida81Fl78wWyXkdHCUxpML/dpAL/PQ4PBfr6Ot+LoRCB2f/4BNfgsRGzTuuxJQQZX6trNw90AV2wq2td+0+Z60p8+E8l3vDTFNX8ge/j59/+SuDrXmSm4v33Cfz5n3Ij37WufTXZ3XdZ+ODvCezeBbz9XRJ//CdbhzRGowJPPCnwZ38OvOe9XbCra137SpsWqr140Xzm9Qrcdw8ZJ+2mwRIhgGDIOOhr61Cnw3w3bT79d5vU6xgY4N9DIYHv+S6BF3+9aGVThLp+eJgn2k8/I1p6Jxsb/AnoLHnc6Fq2wKnT6nPZ6ZB5PHRc9+0xIribbTPAoG9w9hydEanqWirz1Nnvp+P99V9PRzUeN88Mh1l+j4cn5zp0rVhUTowKA2tnD+jNdz7PsK6dOwwL4dOfRStLYSBw7Tv/scfpHGjnJNDGQgEMQ2p0hP2TyTCsY3O9KxUyQPpSFJL2eq7tP8CwgxybdZOSrJlcjhpD8ThZTT6fwKDKcOX1Cvi81MrSoWVnztLpLhXZT5udI/1sn4+gh/4ZU86tBv+g+qZQpIPYEip26cB7PCaUCSCI19OjWHtKxFhYdIwOH+R3nj1mtN5sW1wDdmnwTjuhBw+QoSCEyqgXV0ycEtmPgQDb6/hxA3IODbIcm99+7qYP9FzSGUYBgg/+ALWJrlwVWFxmvQ7up/Me3gSYNjYBehqADYUMm0YI9pXHIeuHIt+ddYdQWRQto3M2MWHYZ5EI2WF6jExMEBwVApDNa8OaWnVuhUYJjI9xfdDhXZcuG500v98MyB3bCSxcubr1PbV5PAZoO3+eml3xGEOxN7Kcz3PzwJNPS2RzbJtQSGAlw3YeGSIjZTANbJvl35NJgQP7ga97CEinLQwOEhROxIG+fuDwIYFIWLSyF/YkqCkVDgvcfScwMW4Ge71B8KFUknT22xrcsU2/ACosfJDgz+FDzFB63z3US3ObZK/ceoQ6R//2UQmfjx0TCHQyCS1BQG56SrRYlUND/MK2GQGvj3Nrz27g4EHWXwO7OmR989oQiQjs3yuxbRvHuG2TdbWxwQOCQr5zrG8+4NizW2B2G/8fDJp1a3wM2D4rsHOHhQP7RMcaOD5Gjbcds2yPqQm1Njksr1eFDa6vG8Zvu9VqPETp7xctkEYR9K419eGVKybE1efjWPEoduHVqxILi0BP3BwUsa4Sly5z7RWCZVpdI2A0u42srGxWIh4j067RIMOwFeLaVm5dB5+PfbaRJehbrpDVqed2SYX1tx+qaOCw2SQrqqeH61S6n9f5A0xUUlGZEWdnCagLMBnJkcMCvUrT8Kln0JojAK+NxYBKhX9PpfhTA7wA+0Oz72JtIKW2cJhrV2usukY/0rQlf87NcVx97uFr/Qetf9fXy3Hg9wO33co5CLSNXcE5037fmzHn+b/Sta51bSvLZiXe88sSn3+YlM6HHgLe+W7g0EHgx1/LWbi4JJHL8WWU7u8CXV376rRwWOD1Py7xw68F/scfAoWCi9f+SGeYEAB82yuBv/l74F8/CmybcfEd3949L+la175SlkiQGdC/SZx3c9gBoETbp6m/dGXOOKvbZ7m5LBQJhNhtTprjCPT38xRVZ0s7f57aIvfcLbBtBrh0mRvXSkXi2eeAvl6KJmu0qT0kT4NI2nQGN0hz6mvbLE8uR4BnaRktjZp205vfg/uBJ56iM5jNSly8RE2kWNx8d2yUG+RaHchu8GRbCAMKaHaS3oJrNpLHyxA67QQlk+ae2rGTIDDUrrMCqI242Bp8mp6igxCLUZPLaqe4AR3hNIk4mSsaSGvXTysWgd6UQJ9y+mZmJCRESytMh+IBBABuPUJ9s7PnJUIhshw2NoBiUVJs3y/xiU8RUHFdsr4G0/xesShx8ZJQ4avU3PL7gVC9zelQP69e1Vo/QoXaAsmkpF6aYBY4LTytbWKcDvPICHDqlGEbAKx7KCTh9dCZv3RZheUJ48j39xGAoD6S7AiVYyiRgMeR2LeX/W/bZOVEwhL9/QJ795Ax0N+vnE3BMNtHjtKh2z4LTE+TlbPZAd82DZw41QnQASybZhj5/UAsJluhTM0mnfVkUnSMK21Tk52ZSIUQ8PkkPA4wMqE08FTdhGKWaPC0fcwJwbkr9HeFyYi3ukrQc3GJjB6AzLupSYY112poiVyn2/oDIJurXAKCAWo9RSIsj20T5Boe4v8zqxKptnDnA/s7tZ+03XGbyQrn9zO754mTBBF8Po6BWk3iyhzXg2iUYcoeDx39XI5C4YGAwPbtKtlEiiC0Ds0aGxVYXuH4EELA6yOIdu4cULpDtvTohKDmk7bNodi6fWvVTsA3lyPIEfAbwJPrjEQ0SmbW0pLsyOIqBBk6n/4s19mg6kMdwqj/v7QEjI9J1OoCE+MEt4eHOe7rdaMJlk4TgMysAo7DgRoJEyTcvBbNzUkcPylw+CDDTVNJAkOlEplVkQgQbUumtRW40GwCyZRozUeA6+knPy2xskISANdP/nFmWjAkt2zYm7ffyns/e4xtevgQ67s53BXgWK5WOstTr3NODQ11flf/XY/9Wo3srnvvsZHPcR0+cYr9ks3JlgSAvqqiGHW1mmKT5c3cTySA23oJDP/VR5jVVv8DOoGhS5f405XAZz8nEQ4TFI2EeehRVO+fVIpjSDP2AKXh5wEaDYJaqZTEfWmOO8sSEJC4csWMV8dmGOXoKMHKR49K3HLEiL+7TWY7PHhAoich0dtr2HU+n8COWROWDwAHDvAw4Oz5TpafNscRSMQlSmWuKdEomdAdc1w1azB47RrZbs2mbIn0r2aoh6elEtozoGrWmm0byYLns66n0rWufQF27LjEq39Y4vHHgTe9kSfJv/t7wDe9FHjn20QrbOED/506XpVKlwnTta9um5218OH/Bbzi5Wixt+r1a8MNfu+3ufl6/weAc+evL2zfta517UtrkYjAoYMC0cjzH6TEooDPL9Cf5nc1U2h8jCe/AsDddwncfTedfA3AbA5VazTpxOdyXBs8jtFQ2cgCFy4K3HUHGREAN6QH9xMQ0KEmI8op0SEQUpqTcNvmpjoYpDOk2V+bLRikw683w/4Arw0ECFK1hxfF4nzG/LwOz6TDqwXOr2qmSSv0BK26r6/z98EBdIrutp1kb2VCmI35ZpsYZ5t7vQyD03b+gmoXx/wei5u2BDo1m2JR4LZbzRrt2XR83c4QiCcEkj1CCQGTITA8TMe50QBKJYHjJ+k0NZsmhK5UJuCjdV+0cLfd1nehEMdA62xEMSGMQy+wbcZCT4+FzCqdxlCwU4jZcQiknT5DcC8Sbv+beWZ/P/+mM9hpu/UW0cHeag+NoxYYhcItS3SAF6kUQ1/7VUjNxgZFnfv7GOYXDPIxi4udmTDbra9P4N67r/3j4pIZJ7bNsbq23vbsLUAubcGgaDF39uwCRkckqtVrgSKtV1VvmL5pNwECU7PbjKC3HscSHNftoYa6rH4/mZV+P9vV3hSKGwySBXniFPDkU/ysWpV4+BEVquQxySa0raxQE2hzWC/Aa3QGxFwOuHCJYO6unUyEUK9LxONcSyYnBVIpgcOHBGamBO69h6C42zTt7Tisb6DNQb9ylVIirsvwtEaDwHa5wnIm4gTGLatznm22WJQAYCBoxN8TcaONtW2m8/uNhsqSV+RBw7nzBEcya3zW5KRosbD0IUS7HpUGZjeyPGyoVgGPl+GkoZBAZpUhcXNzZPnabfMFMGLgm9mw0SgBH66bDHft6yOw05Mg29HraweNr+03zeDR2V8BYFWxspaWCUhuXgNrNeCzn+f8yOd52BoIUKuuXCH78Pbbtm77nh6BWZXgqz1Ms52NZMprfgoYjcOBtK2yzgo4SuX/5Cl0MLsA835yJdeJ22/j2rGq2jsYkmg0JDwezgeKpjP75r695j7jY5zrfj/X00Sc0T7hMNui6SomVlxg317R0c6RiIDPL1rt7DhkTa+qxC2WArpNpc336nUyufTYikYMMO66RkNM13N9XcLxiA5UM9nDMeb3bT0npCQzznV5TTDAMXjy5DVFQiol8NCDwCtfvtV9CFofO8F1NrPK8dO6h+j8v2Vx3dLafM9nXWZX17r2AkxKiY/8DfD+35fo7wM+8HvAR/4vxfje9Q6BB+7rfBm86acFLly49mSoa137arSxMQs/9XoJv0/iT/8PsLAk8RvvM0LBALUr3vl2F//fLwA/8Qbg7z7SBby61rWvdhsYEIjHybp66EEAEC0nVwgJCQJAwaAJwWk0JPKFTobJ0CA3yjq86b57NShGzyOV5Gk4gXI6aZq9UipJTE/RwfZ4qacDKIxJOS6WReenv08ilzepzW9k991DgOLpZ1VIBajDs3M7Rbrn5vgvGgEgBE6eJItDZ0fUcFE4zIMrvYH2qKxsGjhr1zlrOZDXOccSFp2frXRQTp5ku+oQDW0+H0GLra7Rlk7TQTp7jsDjseNkJ+ULhqmmy+Zsus+jRwnwNZt0gBYWJfbvtTA5KXDpkoTHI3Bgn8RKxmTBdGw6vpptsHsny6eZDqUyATLLMs5uOCxQq0s0mhwDzabE0ccIJFRrBBzvvov1nZvnNfm8xNPPUFtteLhTgycS4f0DAYHpKbKJVteYnTAaBWJ3MHQmFtNhsNcycTRI1J5sQZt+v3k8An6/7AgxtQSvsR1Tv82g4lbm8woVHsvftcOt7Z67tmY4bWXptEA4LFtt8exz/P9DDzIcTj9DZ03T83dqguCg61KHqelybmvQw7boTG8GCqpViWyWoZ7CYp80G53BYidPEgC8+07j2Ns2w+euXuV8TCRMEgqAQMb8AjCQ3syiIfihTdfn1lsM6F4skvlzYD+gi2uiJQQgXRw/aeruOAL33q3vaHS8tM6XbvtQkACI10tm4LPPdQKtW9mttwhUazpLHj/z+YBhFS62WYtIh+Fum6HYuZ4vHvtaIKhSJgA3OSEwMsL5DTBsr1qRLeZZu/OvQX7pmoyfgAGDdMa8dg04oLPvzeEHI1J0V28F1rfbrp1kzAYC5v4CDBHdtVMfFnS2RztzKBiU+OjHuVZbFsOePR7er1SWHaL42hIJhtY5KqPl/v2dYXPaxKb/eBxqQBUKLtY3JIoq82MyCWzfdm3IbiBAZlXAT4ByYQG4606yBtfWyIKzHYHBAbJgW4crsc4yJ5MCjgqP1YxMwPRPo8EEFYtLW+uU6UySuu0+9RmOvYceVOHG6nt7dpP9GY2gpQeZ7GljJAu+v48oplexKFsg3PXsueNAPC5RqYpWVtaONhYCjSZ1fMdGGRbZaHb2scleynHlONcOKikNOF0scn4eOmjaqn1M67DSRuPGZe9ow5v7Wte61rViUeJt75T4rd+RuP024A8/KPD4EwL//C/qhPUW890LFyWaTYlohEh917r2tWJCCHzdQwKpJDOj/MRPSaytdb6B77nLwsu+kc7OW37hK1TQrnWtay/IttKPAgzD5PEnrk0J7tmU4jsUEtg+a3RYqlWJalW2NrSlMpke+lS2HbipVAjSzM2RtSRBxg1AJw0gmwDgBvnwwc5wtuuZxyPgeAj2rK8rdlIbBr+xzo10Xx9/n5lhmNjmQ6h4XGDPbsO2SiZVmFSVoMzikvl+OExW1PVCLNP9QDTWGcap7cocWRqb7eABsnh8PuoEPXAfnZV2MXUhmPY9kWAWxcyqYTUUlOZLscR/m503V9IJaTYJDl25Yv6mBZ/Hx61WdkLb4jWVimkrxxEIBgWKJdHhmFUqm3RzZKeDki+QtaXF5efnOxkMtbpAXYW4pJLA7p3mb329JutkwM8wrVAQSpyfY/GJp7YGsoBrw/quZ5mMxMYGAT6toVUoMhzU4xhm1/V0rNrN49VMD/Pc9nL4fKLjEOn5rH0etet7Weq+vQpQ0d/dt4fAqGUJPHdMZTlTyKwGGK/XFkJw/i4sqPDgXOd8Avh7OAzs3SNa4WaOIzA6TAZVOEywo53FNTjAtm1nimqbUSHWvA8QUsDyiZMSly8z9GtqspPFUipJnDwpUShIzMxYGBoUN+zfyQmBBx8QHSHMtg3ccsTMqcMHqe/UPuc2W6nEMtVqstUvi0sERPR61m7bZwW+9ZvZ37ffKnD3nQJ33sGskO1gIGAAVV22dvP5qbcWCIgOlmFviocKQ0PAS79BtEBuHTKmgaBypfN+rss6lEqm3ONjzHpZLHKuzUx3XhPwm7ZJJYHeXra7x2PadHycocKbZTBMvQR27ySYOazYi0vLfGajybC+5RUyhLcKZZyZpr/l9xPs9fvENYAaAAPYqTmyfZbsoueONfHUU2QlnjkrsbQETE1ZHeUVguGAvSnWrV5j+9VqEkNDBI2XltmGfj/XzuutC62ibRoaun8H0iaL6NY3aL8X9TaTbXM9HDKsztFhzrN8ntcxWQdvsL7O8TWpdNIsW2BhwawH11N8X1MHH+I6iJHH4TMvq3DKcnnrcMUrV1UW3Y2tT4g8HrI1fT4ytdvbU7dh02V/NhoU6r8RA7PdumBX17p2E3b+gsQPvVbiU58CXvdjAu99t8Bzx4Hf/+8SRw4D3/Wd5nRwfUPix14n8fsf7IYudu1r06YmBT7ylwK/+ssCVy4DP/jDsiOFOAD87M8I7NgOHH0MeOrpLY7Vuta1rn1NWCwmWnpK7SeljsOT/3Zh9suXmQmu0eB68KnP8J/euHs8DNOYGFOOUdxcGwrxBL9doFpnSpsYZ1iiCUtgined9er5TPspgQCFuheXTMjIzAyBrsFBgQfu47tav68nxo2T3Xqyuhf1bwyYdOly5/empwRmt13rIczOmCxrm7MRAhQQPrDv2s99PoG0CjP1+wVsm22wFbuir5ftuXc39VwAEwamrf10PRAAXvqNWlibn+k+azQY0pWIs28XFuj8JpPA3j10yEuKubewaFgxmjGQiNPZ0eXM5SSdEqsz3Kj9mZvBk94UWVrbtxN8aGfHSMmsmpUKQdXeXoE7bhfXgJXCEvA4ZDQBJly2HdyY3uS8t9v6hgkH1HpyGqxsz0Da3q7t1h4yVyhIZDfMNZZ1Y6Dt+Uy37fIKReRbml0W65dOM0yV3yXD4spVMuZ0hkPNitD9fz3WzqGDdKYXFkxo7WbcYnyM4Xo+X+cfLItzJhajc72yYjrfcQTuv48Z2zbb+JjAxLjAgMrsNzrKTHD5PPvEcahvd7ltDh59nMBxpUqh8fWN52ciaWvvF83U8/kYXmxZ4oaA5slTCgDcxGDpCCdTdvgQAXHbFljfkHjscYYh+lVGO81cSqe5ZrS3TDvYtbxEgG1z+fl/CbdpQER9nQ7L05ppm8Nm19aAT36arLp//wQz587NM0zOcYCdO69lSd51Jxlnm8sHmLZfXwc++WnRYiBuLq+UEqEwtflOnDTfqdUIeAmLoOhWQBfvRS1AITg/rzcfO7QEBYGuYJDX6QQQPT1cGzOZzZId/Fy/G3TmQm2DgwSZdLszYceNJ/hm1pZeH5tuZzt0fodzz+s1z3/RA8DBA7zWtvmO0fNzaVm9p7Yoiha6f+IJru/BADW7NHB2PdOZmivlrf+ux8Hhgwz/3rdXYP++9gHKH9Kl/tj17gPo96VAOATMzZs2aWW5dDlXfD7WpbjFnNvyvjf3ta517b+ufeZzEj/644zR/p3fEviu7+ApwvCgxA+/hoDA9363mUqJuMAbflLg217eZXR17WvXbJup5l/zg2QP/NCPSjz5VPvmReC3fkNgcAD4mZ8t4MKFbjhj17r2tWjVqmyxYoQQHULy9XrnKa0GAYqKRdSTYGiE3oxmVnk6e/iwhbvu7Exy4fNRh2jnDiPg67oM79ksROtKiZOnyQS7GdPhXMkeA05VKgSL/P620C1b4L57GEYGGL2YjnupX4MBhg9pEKM3dXNlSSbpDOfzckvne3hYtDJfXc8ePUrgKZffmjHgSoI7fX2sYzwGDKQt3HWHCbdsf/bQIOA2qRmlBeyNJhCZWbqftShzwE8H/ujjaBsfwIP3M3ytXzHlUkmG6rQLQgPGudPO0MiwAf80YKaBBssS+MZvYLr5q3OyAyRxXSP+fKMQTwB47Y8ITE6yBLOzLOvNmm3Rec3nDbDpUckHUr2mv64HhNx5x7WfdYQx3uSW8Mgh/mu3doFmKWWLpdXOHGxvm/kFMi1KZZOZVANumgVyPZAgGBQYHBQQljBklE1lj0TMnNVWqzFhU7NJvbiLlzp1d9Y3JJ5+hkzQ69n+fQTSmk3+27uHh28A15pdu9qfx5/RiAHQXyjYpVlsrc9v4vpqVbSutW2BFz2gQqQB3HF7Z5sk4gYQtwQB1YUFA0Q11Ho6OcG1UYfP6mQd2vbuYb89+xzZWO1jqVYjIHj2HPC5z5vr9E/HA9x7N+/Rbpot5/cRhHBsHjxMTRFEn57cuv567m6ei3o8aX2/64WYNZvAI4+S3VpqAz60hlUwSNbXzZiwOsPLO/7WxuzqSWwNVkejzED5eZUhcHKCDDDLErj9ViPe3tvLzIBer2B4f970UTjMd8Pzze/NYJcQZBJHIwTztzLHJjBXqxltvVxOhZqC4z2XM6y9gQEmh3Acrq1TbX2YSvG9oVnFe/YQ3NXvxvbi79wOHDqgC97ZnputUgUWFgUSCXEN+N1+X8fD+aszO29llmA5V1eZpKD1uZqXTZf7iGiE77TNWWyve9+b+1rXuvZfz6SU+PCfSrzlrRLj48D//CBDEi9clHjiSRc/+MM8idQnH64rsbjIVeElX29OaLvWta9le+XLBX7oBxmW88afkfi3j5k3digk8K53CKR6BX72Lcye0rWude1ryxZVpkK96T10kD+bTXlNdqiBNNlQ2pE5dFBg5w4DajUafA8ur7g4dfraJBcAHYdhLZIt6STrMJr2kI9yuXOzfiNrF0cPh7nhL5ep7XLxEp1/k91s6015614tzTLzU2BrEeStTANU7Zo+L9R0JsXxsa1DOc+rTGZCADu2m3CoQEC0GE3RKNsBYKjKyVPm+mCgDUARAqmUyWw4PGTurRkNrdClFB1ByxKt9mkHDgBg+3aBA/tM31kWmUiTk4Yx086e86rPQiEL999HGsbFS21tkaVD5fWK5wUzOkORrs0ovLh4/WvHx5kh0bY7WTDaOdb1vX64UuezfD7j6L0QZlc8Lq7RKtL3TqWYtfDj/6E+b2uPdideg8QCZBel04bhpvtyK0F7oFPrLRxmaPONxPS12TYwNsZ6ZjIELdrD9KpVqGyI179HNELWzugIwYV29t7xE0aYGzCMFK9XtBp6qza+83aCs+3WGvuWGff6+fv2mJDQrWzHDoIne3frZxpNphslC4lGCYr5/EbMXh8eHDrIORIKmevb+2FqSqC/34Bs7fX0+QieDQ4yxE+Hjur1vKrmzmbmkd8vMDkhcPddAvfeQ9aT3y8gXQGvb+sQQuD6YJcOv967h+3z3d8hWu+SdmufwxowB9h++vfLl3FNSOiRQ9Rs06aZXbPbrg2/B8zcszdpo7WXe9sMMwDuUEDS1KRohRQ+/QxD5VgeiY8pRrNtm5BLYQnccoSh7zcKCwauiWIEwLE5Orr1dYEA13Ztuj8ffYzacsC14G5/n8DAgFD6lJ2i+/U6UK8ZDcpQkKBWO8CqTUrDFL6eLqW2eOzG60MrZNgCPFskp9DPAzgfV9eYDbadHabHRTxG33xtHbg6v8WNrmNdgfqudW0Lq1YlfuXXJD76MeDrH2LIls8nsLgo8fqfkigW+aI1ApjAH/8J8Od/KfHHH7pWoLJrXftaNccR+IHvE3jFt0r8/Fsl3vUeibPnJH7sR4TKsiXwC28J41U/kMXPv1Xi/b+9dbalrnWta1+dtnmT3g5eRCLGMQPowI6PGYdhdZVi74m4YV88ewxoNijqPT527fPOn5c4p8KjGg3gM59j6N/oaPvmXeDWWxiSeFN1aAMTcjn+nlDss0rl+gDFyNC1Wbi0VapAMEQnQcKw2Z7PnnmW7XNgH8MNvxCbmgDOXTCsls2WSBA4sG2CQUvLwM4d8poshDPTwNU5OiNra3Tsd+2g8HX7dysVo+2jHQ8p2ZalEhCJWLjnLtnRVqfP8OdmsKuvj07/5hAowDBg9M9q1Tj8AB3m2W2yA1hMp804ulnmzmbTQFDoBkyAaFQi3U9nfXrKlD2ZNAwL4OY0u6YmbAwNGWaUx/OfC2NsvzYaNQBhO5a3FVNLCPbF8BATA7QDJVuJYQOdYMDoCDN1bgaoLHGtE2zbAgMDEp/8NEHxPbs7x1h/H+A/hA5AZ7N5PARitYbfk09JpFLUNJrcBHzv34drWClbtfFW2mi2LSCEhGWJa4Tbn2//Ll1gaEigt21ur63d8BJVNtFiLDUaErEomUQAgZ1KhQk+llcICrf3QzAocM9dTCQiIDpClm1bYM9uzn2dwXN2huP13Pnrl8d1JcplavdJADu2CywtSxx9XKp1a+t20HNzK4DD7zeZFG1bIJe/9juWJbBvj0QoxCx+KxmuwdUqDygyKkHG5pDjzQCw18Px4vEITE1JPPNs5/c146vR4P2MTpu5z9w8geH9+zvvLaXEalufOh7DkBSCdUyc5DtuapLhjtfTKLvRvNcJYVIpho2PjvB9CAB33cELmVDGWDhk5rplkZlXqXZ+JxQCIMnu1Hb2HNu4VGKZmk3g+EmChaPBzvXjxClqwPX38fDj6tz1187NiVauV3/XJQNtdVVewwrtCHW3uMa1+xHJpOhoh3pdQqAz4/CNrAt2da1rm2x9Q+Jn3yJx8iTwYz8q8N3fycVtbU3ip97Ek26fD/jVXxEdGWVe8mJu1LpAV9f+X7RIRODV3y/xs28B/uz/APmcxJveyBfS7l0OvuWbgb/8K+Dt75L4pXd150DXuvY1Y2q6akaPBhTI4GHIhnZsFhYJlNx5O4GvJ57i5w89qDNNCeTyEkcfE9dlNmmgy68yHW6fbWOPtTnipSLDO26G3bVZCD7f5mTNznCjvVW4y/btnWtVJGzq35MAxkcZzvHvn+gMd3o+KxTIDOjtuzlwZLO58nqupinn8gr76PIVOmY6zOX0Wf7UYVYapPrUZ/j5yIjA4KA0WboA7N7FcJ5PfYYaLbrMlsVsZ82mvIYN198PXLiIVkaw9rChE6eoJaSdb21eL/s7qsJYl7cI3xkd6bxGs/O2zcjrOpTPZ2Q1yeuG7gFALkdAZWK8M5Q1nabWVKPB/Z/OeriVTYwDly4BoZiFQsGwI9rBLg1wvLDyM/R3YwP4ppcaUONGgub6us0/NWh3PfP5BO64TeJzD/P7rnstkHbo4LUi1FJKSMlQuECAYUjRqER/n2YkiQ4Nv62sr08gFmOo49PP0DHXwFehwHltsk5ey/S7mYQW/1lrZ0h+oeY4ArccMb8/9jjHeUtnbouQXZ9P4PZb+Hk760oIrpdrawx7jka0LppAb0oich22WaHIcEJtY6MSc3NcWwSuz2RNxAXuu0deA2bX6xKf+BSTeU1PCezetfX1APv5sce5Lt1/L+ugs/DZSoPq+Q5Np6cNy2zzN/fsNqClniN6DoyNWvD7WL/TZzhH19Ykhgav/7zBAYGBdOdhQvu743qhlEDbWnqd2z9wXycL9d675Q0Bsttva+97An0tZpQwnw+kJZy2d4/u13KZf5eS4L7OPtrBFvTyO3v3MLPq1bkvnKW8mdlWrV33qxAADuxnVsmlZbN2bLZ9e8luXt+4uTJ0wxi71rU2y2QkXv8GiQsXgF/5JYHv+S6yV7JZiZ98o8T8PCfue98tWhktzp9n2tX+Pup5da1r/6/a4UMW/unvgFd/P/AP/wT82E9IFIs8Wn3NDwjs2gl88lPA3/5dN5yxa137WrF2Rs71/qZNb+pvtPGNRkQrVOpG37vzDp5sjwyLVviP1bYxPnPWCGQ/n20O7Qn4TRhQNE4x7ecDze69Gzhy2NzH6xOYmRHo6bGuSSd/w7KA7bR9Ozr0z16IXbq0ddiLtlqLhcWwmkjYsGh0eJeuh09lK9PghBDAnt0WBq+jnaKFtqV6zmOP4xr2C2CSD2wGVLQDmlm95hI4Dvtbs3sOH+wMTWo0GC7ULsZdamPUfaEOl+vKFlPteqZDoS5cRIvVEQ4bwMpxBHbt3Jqxpm16ihn/tLWHPmqnO3odEOH5bHRUYHqaoZa12rWaXVsCeZv6xhIqK+H9NwYTAgGGjaWSBHu3z3b+PR6/9mC32QQefZQgWKlExtD6TTCeNtunP0PGjeMA+/aZTHXp/muTSbSqKaibdD3neLMNpK/PbHs+q6s+bQfaBgduDII+n2kGlNaw0qDPZotErs3iaVmsy+JiJ3ilv38905kV+3p50GHbzKJ4+CDgD9w4s+VWc0CXd36+U28J2JrdtL7BceI4DLHcPisQjQr09QF33Xnt9zeb45hw9Pb7+32djNrbb6U2lv5ONGohleK1rssP2xlQvN+1Bd4y4+NN2I7t+kBn6+ttuzPc2uvtXGM++anOpDCZVSOZAxD01Wy19iIODIgOZrDH05mRs15nIhcNPrWD4BNtgLxmc1+PAX2zpqfLVq2gsxoHAmR+NprihiHntk1NwZu1LrOra11TNr9A5lY2C/zmrwns3WMm0u+8X7YES9/5i6JF27x4SeI1PyrxYz8q8O2v/EqUumtd+/JaIGDhNa8GhHDxof8FfO/3A3/xZ02EQgIfeD/wP/9I4tBBqTI/dcHfrnXtq930LKW2S1vmI6WNkYib7ybi4pqwiq1s3146bjdaAyxLwHUlCgWo9O1tTA1JRsnI8M3VwVJZ6RxbAjZ1ilIphm5cvLC1ftNm02yJllZMmzM8uw3Py0rR5vMBEtQlu57uzfPZ8+mkaEBKh3G1WzAIJaDc+eyAX4WRrHG/cz2wS4uZA3SGHXtrsekWACYAyE7Be+D6WjTtlkh0lsG22eztQIIW1P/PvFM0sHEjsKu3V+DwIYnHHjega2Z16zZ+PvuGF3uxvl7EY4/zd49jnPDm8zCrtrL2av/HJ/nzoQc7P28Pz/L7GH6pM/G1vqdBr+eZC+fOM2wpHhc31K9qN8uiuPmx4xxj6f5rmZPPZ7kcQ/WiUYEdm669cpVtdz1QvlwmCHgzc273LoHpKeDTnzWZU1+otbf92Jj4gu/Tbjq7XLPxwoBd2xZI90vs2X3z13g8AkcOX/u5zpRaLl9f120rsyyBB++XSMRvDkjs6wUsIfHRj5PtODzEdbZW40HHrp3ypue7BpIDARP+p61clkp3kZ8XixLHT0jFtmTI5uEttMW+WObxiJt+j21lrcywajycPMW+0eL517Mjh68N+45GzFoeDAL33dOWvbONBdbef+GwwMwNstg+n7W68Ab0qoEBgYEB/n9pmQnh9u25/vdfqHWZXV3rGoBLlyRe93qJYgH47d/sBLqkZBptKYE3vZF0dm1jo8BP/LjAS77+K1HqrnXtK2ev/n6B7/1ubs6+63tzOHnShWUJvPIVAm/+eeDP/pzaXl3r2n91+7M/+zO87GUvw8GDB3Hw4EF8x3d8Bz75yU+2/p7JZPDzP//zuOuuu7Bv3z685jWvwcWLF79s5dPhbDqjWXsoRG+Km+IXao4jbijWDACPPCqxsQE8ctRko2rXE7rlyM0L1LeHSni8XJf0hn1yEtfo/dzUvdqWr9GR56+PtnCYIWc3+/0vxPbuAW49Qid3eQXIF8zfSqVOHSxt2nEtl4ELWzDmdHr7yQnTBiUl8r+VVpbus82i863MWV8QqEOh7uHhL03bOc8TUhoMkIWhgc0vBOgCdNikMDpfXgKf5fILC4dtvx9ARtKdt5tsjdfTMNu/rzNccjP77vlsfp6gVal08+9wy2J25oVFAuQHD3wBfSjITIxFuff+/CMSc/Msw+5dnSzAjssEw/JulgkKUF/K69la3PyF2u23mqyL/xnbMcs6xuM3D+xqsOL22wTS/S+8DIuLEp/7vEkSonWQbpRI4HrWaFBYvKXjdIPhs3cPWuG42SwZqKMjDKdeuAGrZytr4SlbVP+xJ4ATJ82XMhkXc/MMjc5uAGfP4xoNKW1fjLHxn7XxMXOYA1AL8pYtQEqgc357vaKDvVmro6WPxu+SQaaBb79f4P57+bdTp7945dfvUesm16BggEyvG4G9rUyjNwkId8Gurv2XtzNnJF73BglXAr/726TSAkClIvHBP3TxR/9b4mMfB37oBwW+5Zv4tyeeJI1UCIFXfKu4IVW4a137f9GEEHjtj1j4wPsFICR++MeA9/6Ki3gM2LYN+O//A/iRH5M4eaoLeHXtv7al02n8zM/8DD7ykY/gIx/5CG677Ta87nWvw5kzZyClxOte9zpcuXIFv//7v4+/+Zu/wdDQEF796lejpOk7X2LTYIXe2LdvRkslwyK6nr3Q0LLZGf70+TqzMAHtrDKKPt8s5tcOsBQLzKI1OgLcdQeQ7rduOrwJeH4B7+eziXFgZuYLu1bbnt1Gv2crcxyG/Gxlq9cJHdMp5/t60RLKbjch6KTGYirkUfLf9VgPoRAZS17PtSE0AJDZQo/rS2WDAzdOBqDLdqM2BTiO2sfz1IQJsflCrKFAR49DxuD4WGeI0Asxj8PQvmDQZGvU436z02dZdFgLhc4spzcLdmmwdCuB8euZlBKWRec8EgEuXpRYXHphkygaEZic4JrE8pvwzM3O+1Y2OPCCHofeXmZHfCGmnfYvNFnCjczvF0gln7+e7aYB4qaLF9zeAAGqYskAu1qf8Qs55Pjkp4HPfPbmvvvwI8DxE9eWd0zpJL4QFmdrfG/RJ3r8tMD4trmSSBBcWV+/9rqeBLOLfqWt2eyc36GQeEFh9dricfbpjZpV66V9oaHWW5l+j8bi6oPnKXokIuA4N9bjGh5i8pWRm1ybu2BX1/5L23PHJF7/Rgm/D/j93zE6XKWSxM/8nMSf/hkwPEyh+u9/Fa+pViXe+R6J3/m9rhPfta5NTQr87w/FEI8B//wvwAf/QOLNb+KGpV4H3vgmifPnu3Ola/917YEHHsC9996LiYkJTExM4I1vfCOCwSCeeuopXLx4EU899RTe8Y53YO/evZicnMTb3/52lEol/NM//dOXpXxZBYI4mxg6AEMebsSGufN2AkovxEZH6Zzt3ydaGmCbT+QlGEp18fLN3VMDFPE4HWWfl4BQIPDCnYLNgrov1KQEnnoKyGa/8HUv3S9ecAiYNi04fD3bt/f5nelQiP9iUTIj6lswxVyX+kVSbg2otLPN/jMWU2L2NwIXdu0U2Lf3+nW6WUC2XCajaWODv0/+/9u787io6/yB468Pw32DgATeImjihaaZrpra7lq5WuaqlZbb2mHHZpmZlaVpVqZ22GHZpZZbv22XDs2sbDssz808UztMzQuQG4Fh5vP748OAEOBwDgzv5+PBA2bmOzOf4TPf6/19f96fDrXL2Dm7ZldBgZmpNLeG/xdrUWm7HAICTCbagHLr4JGjpvi/o9+qG+xyDF2uTmaL3Q5bt5uZPXNyTHZOTjU/q9aardtNza6gQBM4czZQ3SKcSgPAlcnNrTjQUZXzzjPDRKuq3VZdUZEm46b8cOHgoIpntK3ITz+benPV1aqVYvjQ0s9T2+oTViczwnJyK64F6O1ddvIvZ5xdk668Nq3N/zayeKKDMrXtimsZ7j/w+231+V0qnnGyoR05WnGmbnWFBCvata06iKmUmemzOsNXz8WRSRZfjaGQJ05UPcOph4eiXdtzlyZwkJpdotna/j/NzFmayEh4alFpsc3cXM3dMzR79sLsB+CSYeYIy8w0Y2YkWvSEqUcghIDWrSz8+/8UzzynWfUWfPMt/PmP8OZqMwzmjrs0zz1t6loI0ZzZbDbWrVtHXl4evXr1orC4arjPWUeXFosFLy8vtm/fztixY+u9TY5hVaUZC8VFmIDu3aq+Jlq+WHJ1lWRPlc+W0CbIFuZkHRxHMKN1K8Xhw7rGw8+g9pldWVnnnvGuPkVGVhxk6NjetOvwYZOBU9VQQQ8PRfdECA83w1wrmlEytbiWVmGh6T5HJoYju6I2fXC2+Hgzw2RVtZhSU025icoCIwP6mxPrvApOrs8WEACxMc5/786lSxczZNTTU5XUBzpXPbaqlA8gKlVxPSDHkOTyWRTOBjK6JZqMkuqs3x4e0LWL4ouvzPDktm1Nwf7qcGSRpqVROhTOCb2TzMlxXp6uVpszMqs/iYRStevDilQWqO3X1/nPMmRQzbPNzs6icgSr6mr9hYqTeWJjTG2yEzUY1lvZG1T0+QsKFAnxlATQPItr23l7Q6tYTdu2Fc+QunOXCfr07FEH7Wsg58raat2q6tqTWpsZPX0K6q5NXl6K4UM1GRmKI0fPvQ06c0aTk1u3WXUS7BLN0sZvNA8+pGnTBpY8qUqKpObkmEDXD/vNgW5hobnfatUsXKTp1Ekxdkz1d+BCuDsvL8XddyriOtp5cjG8vhLu+gc8ttBcPX1wjub15ecujCuEO9q/fz/jx4+noKAAf39/nnvuOeLi4rBarcTGxrJo0SLmzp2Ln58fr7/+OikpKaSkVD0OLKyOzsh7J2mCgoro3NmzZP0MCCgofo86vMR7lvR0O9u2W4nv5ElAQBFhYZ6EhVkoKtIEBBTi5QVDBns7NQW9g6PNvn5FnDkDYWEBNW5f925FnHeeByHB1T97/H5nIQEBmrBwr2o9v6b9Wb6vAvyL8A+w/a7veveGQ4ds7NlXRGSEB2FhFafshQRbycq2ExLiSXR05SlRsbFWTpy0E+BP8f/bvF9oqCYjo4iOHSwEBtbNAJKIiKq/j99sMo93Tqj48bAw+MtIO4EB585qi4ioRUPLvGcYYWFmNjYHm60QrT0IC6v+6VdwUAFt21icem7JdyLUi7Awj5I+DQ1x7vk15eOree/DXNq2sXDpn30ICqpe/3t52QkIsOLnp/D39+Kbb60kJFiIOa/q1DytNZu2FBIfZyE21vnPV53tnGP9zM4pwMsLQkO962wSntw8TV6eJqKFcvnEPqGhmtgYTYsW1V93y/8/MzJtBAQUERT8++/dgIsgJ8fOF19ZiY6u3fdSa/O9CQ7+/XbN4llAgGdpm9LS7AQEBBAcpLBaFUeOFvCHgX6EhZX9jtnsBeSdqb99oLPO9R11PG6W8S4zUcXZ0tPtnEo5Q1i4Z6WvZbeb/W9V71dTP/5kJSDA7FfK/6/PFhSkSeppIyrKg+Aa7H8rIsEu0ex8tkEzd74mIR6efKJs0dmsbDNOeP4jCl8fSOpl7rdYzCxG+fkVv6YQwhg10oO2bew88BA89SwMHwbrP4H4ThLoEs1X+/btSU5OJisri/Xr13PvvfeyatUq4uLieOaZZ7j//vvp27cvFouF/v37M2jQoHO+Znp1x99UoXWr0uGMYDKczXvUT92wjAxNegacTjfB8KxM8PFW2Gya3FxTn2jvnlzyC3B6GJmjzSmnNB4WSE8vrHH7WkaB3Vb9IU5gsktyc03xY7vNubaHhYXVuD/L99XR33Tx8Kzf992Jk+axAH9IT6+4bdk5ZpmMzKoze2w2zZkzpp5M3pmy79emtRlCV1df0XN9H3v3cu77ml2NGlS1UVF/2u26pJ5aZf/7quTmabKznXtuXq6Z1dAMe1QlfZrl5PNrKitLE3OextMTtv8vj5Ytq1c03bHuoOHnn01B7fBw8POt+jUO/Wqel51Tvc/n7Hbu7P7MP6MpKIT09Nw6C0x98plpx9AhVBqsaEgeHjVbd8v/PzMzivslq/J+uehCip9To6YWP9e8j6/P79+nfJtCQkLpnpiLry+mpqyG1JQCwkI9qnyeq3TsYGY3r6wdjnaC+U5W9v2x2TQtwk3WZVWfyW7TBAbW/ecODtYc+hXycs+9jqad1litYHNi/+nMRSIJdolm5cM1msef1PTsAY8/qkoO5DIzNb5+mrdWw4y7oU9vc/+3mzRxHTWRkYo5s+VkXQhn9OzhwWsva2bN1qz/xKQtr/sY4jraycqCi/orErvKuiSaD29vb9oW5+V369aNXbt2sWLFCubOnUtiYiLvvfce2dnZWK1WwsPDGTt2LImJ1ZhHvolxnCPai4f7OYa+WSyK9u00LaPgux1QUGimo6+Ozp1rX3emNlycmEHPHmZoYUUS4hWpqbrKGlYdO5ghTC2jqn6fwkKznNYada6qw/XMx6fx708cs1NWVXj5nM938mN6eZv+Kd/P9fnd1FqzeasZimi1mnXZUfvLWY5haHYNwcHQrk1praWqpKWZ35YGqETdsaMZwlsfGViNIdBVG+d3MQXff6eSj6W1CWp4etbu/MoxrNSZLvH0VAQGmgXP5Jv3r2x72Rg4W7Ouc0LV3x+LReHtRLKWxVI/ky+0jFJcMsy5ZdNO120bpEC9aDbe+ZfmsYWaC/vBk4+XBrqOHdf8/SbNxOsg+X04cLA0ADZ7jmblm2YrKoEuIZwXGal47mnFVWPMkOCgQDOd+UfrTNH6rdukaL1ovrTWJfW6HIKCgggPD+fQoUPs3r2bYcOcPDJsghzBLVtxXZizd69xHc0Mx35+puh0dVk8XLu/DiwuEF/dWSprqlW5GQY9PVWVGVl2e9UnEj4+5mLEuU68HQGGoqL6OTlyN7WNjQwaWHFtoYqEh5nsvfIzhdfnaqGUIvF88/3KyobQEDMZRXV4e5tMwbiOJquwUyfnJpno3s3RiOq12dNS/W1MbEzVkyE0Z7ExpWVhnJGZaWZw3H+gdu+rHfuRam6HwsMUXbsqoqNr9/6u5Jg5sXUVNRgdzu9sLmZUJSe36uLwNZWXp0lNc+64v38/VaflgiSzS7g9rTVvrITlr2ouHgKz71cls4789LPmH3dpsrLMCfk9dysSu5rnhYQonl5sdrpCiOrz9lbcebuibx/N/AWaD9eaK2gRETDjPs0Ds2DYxXLQKNzb4sWLGTRoENHR0eTm5rJ27Vq2bNnC8uXLAfjoo48IDw8nJiaG/fv38+ijjzJ8+HAGDhzo4pbXH8da7yiCXFEgoHdSDQMELk6tCgkxM9F5NtARtodH2anpq5KerskvqOOSDIpqBxmao+rOiFhedbLXunQuO8GCrkbmS22EhJgZ7DonQPv21X8zDw/FxUOq/772CoLmzvDxqXjyBdEwHN/LimZlrA7HxRPHzH/Ocsx+GRBQ8RfHMRNsY3ZBH+cnE4iNdW4FcXZGzeo4+KOZIbZPb01YaMPuMCTYJdya1poXXjLDEy8dAfdOL71auXuPZtp0TX4++PnBvDnm/uv+pln4uIksn99FjuCEqK2L+iveeBXmzNN8t8PUEYmNgYfmaH77TTPpWkkLEO4rNTWVGTNmcOrUKYKCgkhISGD58uUMGDAAgJSUFB577DHS0tKIjIxk1KhRTJ061cWtrl+Ok+4Af+jRzcyCV94vh0xw/OwC301ByyiT1dJQwa7sbOdnf7QUt+lcsxI6o2VLOHzE/F3fiXTxcdU/kW1sHFknbVrX/3tlZ5uTy8Su5WYnrOd+ys+HCy9UBPjDdzs0rVtBRET9H0c76j1Vdzhat8SGy8AU9adFOCR0gpiYmj3fVsH2s1Ws2Y43dh4eqs4zawP86/b1oHQ9a4ihxuVJsEu4Lbtds/hpTfJ7cNWVcMdtqmRoQ36+nbtnmKsJMTFwz11mmuOiIs1tUxVJPV3bdiHcTUSE4qlFsGKV5rXXzRAYXx/4/L8w6VpXt06I+vPoo49W+fikSZOYNGlSA7WmcXAEuzy9IKqSmiQZGWZimJqoj4N1Z3l7qwYNzAQHQ4GTU8U7/i+OoS+14XgtDwW6nk9g2rZt+hcelXK+Zk1tHT8BmVm/z/io78yu/30H7dubdTc1rebBh+pyBCvynVwPHMoP83SVNq3NRB3uxtliFbqWVS2UUrRpU/FjgQEVX0wBU18OzGQc5ZeJjjYTpTQ3CnMho675+5nXDg5u+HVOLqcLt1RUZIZNJb8HE6+Ff9xeGujKyNA8/IjZsVzQx4xffmIRWK0aT0/F+L+qJlHsVIimxmJRTL7OgxWvK1q3MQemRTZIz9CsWWvnfzuczMUWQjRpjpPugnxISdEUFf3+bCexKzW68BQYUFo3qzmI76QYcJFzxywWi2JAf1NIurZyi08UlZJRjI3N6eJMp/LBrfrOwOvezdRwy8kxdcOcLa5dWxHFRezPa6K1lxLiFUm93G8tchSrryzY1CBU5cG0iBbmd0VF9ffsgV8P11+zGiuNWYfr67VdoRnGLIW7KyjQPPiw5ptv4aYpionXmB2I3a55+VUzPe22bXDrLTD+r4qdu0zqtaOOlxCifrVrq3jhWZj1oFlPx4zVWIvMAckjD9u5eIhchxHCnTlOwjMy4cCP0L/f7wNUNb3olJNb84yw5qCq4vXVceKk+a2Uy8ukiXIqDWrVcz8FBMD3u8zwwOiWDfel8PFpuKw54byoKMUFvTWhldRo8imeHTC8BhOROCsnx/xUpCQIVkHzzuTDmePQ9fx6a1qjdfhI9WdBPpesbPP79GlNeHjD7jDkjEK4lZwczV33aDZthhnTSwNdKSl2ptysWbkKMtJNRomfr0IpM6tKv75ypCZEQ/L0VCyYpxg2FAqt5qDDwwPmzIMP12i+36kpKJAZG4VwR56epm5fbCz062vqZtZWl4TS4XkV1WARdSvmPPNbqdIC0aJxcPRH+YyW+s7sysuDvn3Merh1myY9XfbhzV1lgS4wgfdLhinat6u/L2ZYKERFVvxYRqb5neeGQ0hroz5qlTm2RbUdsloTktkl3Mbp05q7Z2gO/QpzH1IMGVw6bPGGG01a9zUT4OYbFWOuNFeehBCuY7EoHn4QevbQPPV0afr0Yws1FguMGgl33SmBaCHcjZeXqpOhdGdr1UrRqhV89bUumWVL1B/v4lnsZBhj4+Pna7JZHBl3DXWCuXO3qT+ldXEgQb4YwsX69K78SxgWZn4HVTDrYlRk/WacNVYWS9MozF8dEuwSbuHoUc30ezVpafDEAsUFfRTbtmuyszXLX4X0DDM2+8a/O7K5XN1iIQSYwqJXjFJ0itM88JDm9GlzoGy3g80OWdmavFw4eQp6dJcjZyHchdaanBwzk1pMjMn2rAu9k2RYXUPIOSsboq5nAxO1E9EC0k6Dl1fZ++t7vejZHU6lmH14ZASEVZHVI4SrhYVWPvy1uR5v2mx1M1tvYyLBLtHk/e87zf2zTSbI00vMxum2f9jZ8T10ioO/TTbT0iZ2VVgszXPjJURjl9hV8cYrsPhpzWcbzJWl9z+AdR9rwsPh9GlI/lfjmT1JCFFzVqvmv1+aOl05OWb2J886OiKtq5pUomrt25nhpwUFSoaNNjKOLMeG5u0NR3+DHt0qn2VVCNG4udvFCwl2iSYt+X3Nkqc1bdvA+L/Ccy9ovt9pdrgBAXDTFLiwn5uttUK4qZAQxZzZisGDNIuf0lw2Ar7ZBMePm9Tq1W9rJoyDdethyCCIjJSDaSGaIosF4jrCmTOVFw8WjZu/v6JDe1e3QjQmuXmmBp+2w7ebNYnnywUqIZqS4UPNiIu61rIlpKa5JpAmwS7RJBUWapY+r/l3ssnestnh0cdNynZMDBw7BqP+IoEuIZqioUMUF/Q2J8QzpsO9szTfboIVq+Cf72iKiiA3F66fJAfRQjRFHh6K9u3g8BFdfNu17RFC1N6+fWbSicJCE8S2WFzdIiFEddRHoAvAx9vx+vXy8lWSYJdocn77TTN7jmb/ARPcOvgjdGgPfS+A73dCRgY89KCZ4UMI0TSdfTU4Lk5z+LA5gE5NM/VA3lgBx47b6dQRUtLgb9cpfH1lnReiqcjL0xQWmr+lxpYQTV/PnvDbb2ZIcssoGVIshDByi2s8umJ+Vgl2iSZDa82iJZo1H5k6ETdNgWUvww2T4ZLhcM1E6NQJ5sxWxMbKDlYId3HT3z24fqLGZoNNmzVPLILQUPjkU1j7Efj6Qud4zaA/mJNmqc0nROOmtWbjt+BZnPkhwS4hmj5PC6SkQLduENFCVmohhJF22vy2u6C+owS7RKOWm6v58mvo2UPzzLPw1Ubw8YHlL0F0lMJWpPnrWIW/v+KJxzRJvcyU5kII9+LjY9brpF5w+aWa9z8Eq9UEury8YPYciIzUFBTAhHGaidfIuCghamrgRSaDsr6YoRIau93clmGMQjR9Wdkmu6uwEL7eqOnTG8m4FkLQob3Zz/v5Nfx7S7BLNDo5OXY++UzzxZeab741O00/P7DboVWsuQIcHATPPqd59z/mClLvJOjXV3aoQri70FDFbVMV10ywM3sOfLcD8vPNY3l5JlV62cuwc5edoUMgMhJ6J6l6q0MghDvy86v/9UUB9uKAmqyfQjSAel7NfvzRFKIuKIAz+VKzSwhhhIQoenR3zXtLsEs0Cunpmq83wpdfa7ZtT8dqhdAQ8PM1wa5OcTDrXoVda/bug8k3wImTMOZK6NLZ1a0XQjS0sDAPnn0Ktv9P8/hCzbHj4FW8R/P0hB9/gm83mdujRmquGA3t28kQRyEaC+VhZm2TNVII99CrJ/x6GPz9IeY8GWkhhDAyMjQnT0HHDuDp2bDbBQl2CZcqKtLcPUPz3Y7SzK3LLvXml0OFfP89hIeZGgDjxkKrVop5CzTrPjYnrc8/q+iWKDtSIZqz3kmKN1fAP9+BNq2hfXvYs0fTvz/s3AVz58H7H8J7H2gCAyGihebJJxTRLWXbIYQrOZK5lAxhFMI9KDNJVGJXCAuTfawQwvjlkJlgKqIFtGjRsO8twS7R4N7/ULNvn+beezzw9FTExmp69lB0aK/5dAMkv1eIlxfc+HfF2DHw66+adu3MTrP/hYounWHUyIaPDAshGicvL8XEa0pvb/gcxl+juXo83HgDBAdDQaFixSrNoV/hqnGamBiNjzdcORquGC1n20I0NIW5wNWhvatbIoSoC5mZ0KULZGfD9zs1fxgo2dRCCAgMNMEub++Gf28Jdol6VVCg2f4/2PiN5tZbTCH59HQ4dtxkdYGptfXPtzWvvAYBAdCjhyfRLYsYOkTz1LOwbh1MvcVkdw27WHaaQoiqDRoI+/fDS8uhRThMGK8YeRkMuEix/BUzC9yxY2bZRU/Bayvs9OgOhw/D7bdCn94S/BKivnl4mOwux+QTQoj64ZgAwqOeV7VffjF1MvPywFokE08IIQx/f/Pby6vh31uCXaLOHT+u2bodvt2k2brNFI8OCIBLR0DX82HStTB8qOKNlZq16+DkSfO8sVfB5OsUR4/68cbKbCZMNBHgsVfBJcNc+5mEEE1Hhw6KBfMVu/doXn5Fs/R5zY8/wQP3eTBzhjnaP3nKztqP4LPP4cgR+Py/5rl33QOTrrXTpTM8sxQenAWJiR4UFmo8PcGjvs8WhGguFJw6Bd7emg7tZb0Sor7EdwJfHxOIqk9JveCnnyEs1Bz3y8QTQggAm838dszA3JAk2CVqrbBQs3kLbNlmgltHj5r7z4uGyy812RQ9e5iZWZLf16z7WLN7j7mi2/cCmHozbNkCV49TBAcp3lydzw8/wPWT4IpRivBw2VkKIaovsavi6cWK/Qc0vj7mvh/2a55/UXPZCMWEcSbArrVmyzbNe++Z2R1fX2GW9faG26fB22/Z+eYbxdLnNXdP0yTEK3x9NSEhioAA2T4JURMKKCg0md4ylFGI+uPpqejQof7fx65NVlfbNmbmZCGEADh92vzOO1Oa5dVQJNglamTbdk1REVzYT2GzwYMPa7y9zVWdsWMUF/SB1q1MxsTGb2HFKs3335sdYYf2poZOmzaQ1Eux+p+aH/ZTUnNnzkOBaHuGzOIihKgTCfGl25KsLDiVAo88qln0FFzUX/OHAYrBgxT9LjDLHfpV898v4KN1mt+OwZi/Qvt2GqVg/mMAZgi2UpqePTTnRZvXjoqCXj0VvZPM66Smavz9wd9ftmVClBcfb7JN5KRYCPdw+jR06CDrtBCi8ZBgl6iS1prjJ2DvXjh+AiZeY3Zgr6/Q2Gwm2OXnp1i+DNq1hewckxnxf++WzfJq0QL8A+CpJ8HXTzHtbs3u3bB7t6ZLZ7jjVkVwsFk2MsKD9HTZUQoh6l7fCxSrV5qZGj/+RPP11yZ4P2Sw2eZ8/l8za+O4sXD9JA8OH9Z8/gV8/Y3mTL55jaAgCAsz9UisVtj2P0hJAa3hp581vZMU3+/U3Huf5tIRcMdtiuxszZVjNT6+4Odr6hZ4e8Prr0hRE9E8yYyoQriXY8fMvrFllKtbIoRoTCJaQEoq+Ps1/HtLsEuU0Fpz4gTsPwD7D5hsq/0HTCYEmBO8cWPB21tx/0xFWBikZ2h27oLvvtP87zv4+RezrLe3+UL36AZ4wE8/mVmXWrVSKAXnnw/9+yku7AcREXLAK4RoOEopenSHHt0V06dpTpwsnTHqxZdMNpeHB7Rpo4mPgz8MVLz8ggfp6ZpNW8yw7c1bzIxTFovJUEnqBTExcPFgsFo10+/VdO0Cw4aaYZK/HNKMHgUFBZBfAIWF5rnC/b311lusXr2a3377DYBOnToxdepUBg8eDEBubi6LFi3i008/JSMjg9jYWCZOnMjVV1/tymbXu6wszeEj4OsLcR3lOECIpq5bIhz8EbKzNUFBsk4LIYxWrRTR0RpPz4bfLkiwy0398IPmv1+aYTcoUxsDYHxxXaxvN9n57HOIjDAzIR08qPl2szkBA3MSFh5mAlSRPc1VmvBwk7W1/4Dmq42aw4chN9cs76EgKBj+OtYUn595v+b0acj9AeI6wpBBMHiwIjDQtGT+XNkJCiFcz8NDEXNe6e3XX1Hs3gO7dsPBg5rvd0FYmObiIQofH3j6GWjVCvr2MSfp2TmQlgYbPjfbz1dfg7ZtNb17Qcc4k+114KBm6u1w372Ky0Yo8vM1hYUQHCzbweYgOjqa6dOn06ZNGwCSk5O59dZb+c9//kOnTp1YsGABmzdvZuHChcTGxrJx40bmzJlDVFQUw4cPd3Hr68/uPZCbZ441hBBNn8YUotaubogQotFxRaALJNjltn7+Bd7+P0CbOlm6+KdNa82f/6T47xew7mPH0qW7pbunQWwM/PMd2LLVpByy7+xXNgE0H29TWNbHx8y6EhkJP+yHwgI4v4vikYfB31/TsYOS2cuEEE2Gn5+pOXhBH3BcJrDZzDayqAhG/BmOHDXbu+MnzMwyM2co/nQJrFuveXEZZKTD8ePw9Tfwxgrz3IgW8NkGzaFDmuwcWLMWljypSeqlKCw02bCyrXRPQ4cOLXN72rRprF69mh07dtCpUyd27NjB6NGj6devHwDjxo3j7bffZvfu3W4d7ErsCpu3umYqciFE3UtNgdhYCJasLiFEIyHBriZOa41SCqtV8/4HcOSoGRZw5Ki5unL2FJ8REWb4TEqK5tI/Q3RL8PQyWQknTsLJk/DiMnOl1cHPzxSab9MaQkIhOAjG/1Xh5QV3TNN4eMDzz5qaMz/s17Rra57Xo3txSpkQQjRxjiGOwcGKf9xeul2zWjXHjkFoKHh5Kbp0hr59NadOme3pqRSzDR71F8jIgD17zEUEhzvvNkXufX3AWgSJXTUB/hAcYordR7QwP8HBiqAgs/0NCjKBsYae0r2oSJOba/YPuTnFv3MpvS8XcnPNMmfOmNl384t/zpwxwzfP5JvsN5sN7MXTUN9/n+IPA5vPvsJms7Fu3Try8vLo1asXAElJSWzYsIGrrrqKqKgoNm/ezC+//MKsWbNc3Nr6FRys8PYyk9sIIZq+tNMQFEiZbGkhhHAlpbV2Kts0PT29vtsCwFPP2tm1CzwsZmich4fJUgoLhZYtQSkzw9+tUxVjrgjnoTlpHPwRbrlJmWnmn7Xz2zEz7C401Dxf280QOz9fha+vmRK3UydTR+XIUZNC7xheVx2Of53jP1j+d9llq16mssfPnNGkpkFqKpw8ZcJHw4Yp8vJg5ixNRISZ/TA7RzPvUfN5g4MhIMDMcuTlafK28vIgPQMyM3//3gEBEB1tgl+RkWa2xLZtFCdPajZtgTmzFUopFj9lZ/0nsPYDk6114KAp5BxzXt2eqISFhTXY9000HOlX9yV9WzGbzQzndgTD9uzVfL3RBMhOnITUNFMT8fwupsB9ZpbZRjvDw8P8eHubbbePr8m4tVjA09P8lPxtMX9rztr+OzJ+MUX2CwvNT0FB6d9FRR7k5trJzTP3n4uXFwT4g5+/KcLv62sumPg6/vY17bVYzD7eyxNGjVScd9Y+pKDAzPQbEGDu+/QzTUyMyRi2WjXzHzNDSgf/QZGbq7lnpmb6NEWHDg0TMAsLq9mYu/379zN+/HgKCgrw9/dn0aJFJTW7CgsLefDBB0lOTsbT0xOlFPPmzWP06NF12PLGJyPDzsZvrcTHWejUSa69CtHUZWTa2bu3iMSungQHy+QrQgjXa3RHF6EhiogIjbab4Xd2e+nBsc1mfvILIP+MWT4l1Vwt/+lnkxL/1UY4ccIcdJfPbHIM1/Pzg2eWmKDO1RM1HTvA4wugIB8mTzHZSmGhJgjk4WGGrsTGmtvaDj16mOfe/g9zNb6hLXqqNFr140+waXPZ6FVamrmSHuBvPmtgILRpA4mJgDZtj4lRWIs0mzfD9dcpWkYpPlpnTiT+/Y4iKkrx4Ro4fNhcqQ8MNDMx/u360qE28Z2az9V4IYSoLotFERlZervr+Yqu51e+3Txxwsx++/VGTVa2CWKdOQMfrTPTuYcEm6zd4yfMftHT0wwlDwkx+0i73eyv8vPN/q+oCIpspX+r4vqNJUlhyvzt5Wlez8fHBKVCQsztoCAvlCogMMAEn/z9Kf4b/P3N78AAM9NugL+ZvKS8tDRN3hlo3ap0tssiG1wyzNx+/Ek7oaGam/5uTowmTNT07WOGhgIsflrzp0tMsMvTE37+GXp0d/x/TTubQn2Y9u3bk5ycTFZWFuvXr+fee+9l1apVxMXFsXLlSnbs2MELL7xATEwM27ZtK6nZddFFF1X6mk09wLx3nzm+yDtDs5+BWS4YuJfm2p9Z2ZozZ8xFG5vNfdbp5tqf7kj60r04cwGy0QW7rp9UveFv8+eaA2RHltVbKxSHj0BUpEmRT0218/kX0KsnhAQrDvyoWf+JyX7y8ICJ18Dn/zVBrIAASOoJm7ZA587mBOGXX8zJBZgg2+nT8MmnsOZ9xR8v0az5yJwoXH+dYu9ezcZvz93mjh3gj5cotm7TbNsOvZOgX1/Fxm/MDIg+PiYzLSDAnNS0aAGd480Qlo3fmucn9VL4+GhWvglDBsPFgxU2m+ahuXDdJBg+1IPDRzTXXqd56AHFsKGKfT9optysWfi4on8/xY7v4auvNSMvN+/XpYvJkHMMKbj8MsXll5X2RWSk++y4hBCisYmOVkRHQ6+eZbe1w4eZoV4d2pvsphtu1PxlpOKqKxVZ2ZpLR2ruvMPcTknRTJ5isp2GDFYcPap5bKHmpimKbomKXw5pVqzSXD9R0bat4uCPmvc+0Ey6xlzk2LVbs2at5pabFO3aBbLu40LWrtPMvMfUM/vsc80HazSPzTcZv//3rubLrzTPPmX2xU89Y2fzVli90txe8rTJoH7jVfOZPlhjAhyOYJeHKrvH//tkRdRZ09a/skwREmL+Vkqx4rXSpX19FU8tahr7JW9vb9q2NeP8u3Xrxq5du1ixYgWzZs1iyZIlLF26lCFDhgDQuXNn9u3bxyuvvFJlsKupcxxrFLngoqEQou4FBymSerm6FUIIUarRBbtqylG/xNtbEdex9P6ICA/Gjim9HRmpGNC/9PZNUxQ3TSm9/eQTqiRwppQiL0+TmWmG+SmlOH7cXHkPClJMvwuGDNZkZMKIPylSUyHxY01aGgy4SGGzwaZNmuxc+ONwU+dq3XpNeBhcM0Hxl8vNiUBEBFw9XnH1eMUDs+20bw83TDYnCrffaadPb8V1E83n27zNTkKC4tIR5vWT39fExpqTlrw8aNtGE1Q8JDMsFK6bCO3amc/Wtg0seVIR38nc7tlD8eF7pScK7dqqkppbQgghGofOCaXbaS+vcgEfH7Ndb93K3FYeMHSIGfYPJtvLMeQRTG2t/fvNxRswmcBffQVXXWlup6bClm3wt+vN7cxM+Oknc/EH4EyeeY7WJivM35+SYBSY/Up4eOnt8eMUZ86U3p43x8xq6XDP3WWHulw6omzw6rw6HibfWGitKSwspKioCKvV+rsabBaLBSerTDRZMeeZshQto869rBBCCCFEdTW6ml3VIamI7kn61T1Jv7ov6Vv3JP36ezWp2bV48WIGDRpEdHQ0ubm5rF27lpdeeonly5czYMAAJk6cSHp6Og8++CAxMTFs3bqVhx9+mJkzZ3L11VdX+rrSN+5D1jX3Iv3pXqQ/3Yf0pXtpksMYhRBCCCHcRWpqKjNmzODUqVMEBQWRkJBQEugCEwxbvHgx06dPJzMzk5iYGKZNm8aECRNc3HIhhBBCiKZLgl1CCCGEEPXk0UcfrfLxyMhIFixY0ECtEUIIIYRoHmReWCGEEEIIIYQQQgjhNiTYJYQQQgghhBBCCCHchgS7hBBCCCGEEEIIIYTbcHo2RiGEEEIIIYQQQgghGjvJ7BJCCCGEEEIIIYQQbkOCXUIIIYQQQgghhBDCbUiwSwghhBBCCCGEEEK4DQl2CSGEEEIIIYQQQgi3IcEuIYQQQgghhBBCCOE2JNglhBBCCCGEEEIIIdxGow52vfXWW4wcOZKkpCSSkpIYN24cX3zxRcnjubm5zJ07l0GDBtG9e3dGjBjBW2+95cIWC2ecq19TU1OZOXMmAwcOpEePHtxwww0cOnTIdQ0WNbJs2TISEhKYP39+yX1aa5599lkGDhxI9+7dmThxIgcPHnRhK0V1VdSv69ev54YbbqBfv34kJCSwb98+F7ZQ1FT5vrVarSxcuJCRI0fSs2dPBg4cyIwZMzh58qSLW9q8vfnmmwwdOpRu3bpx5ZVXsm3bNlc3SZSzbNkyxowZQ69evejfvz9Tp07l559/LrOMM/vDwsJCHnnkEfr160fPnj25+eabOXHiREN+FFFOTY9tpC8bj5MnTzJ9+nT69etHjx49GDVqFLt37y55XPqz6SgqKmLJkiUMHTqU7t27M2zYMJYuXYrdbi9ZRvqzeWvUwa7o6GimT5/Ou+++y7vvvsuFF17IrbfeWvIFXbBgAV999RULFy5k7dq1XH/99cybN49PP/3UxS0XVamqX7XW3HrrrRw5coTnn3+e//znP8TGxjJ58mTy8vJc3XThpJ07d/L222+TkJBQ5v6XX36Z1157jdmzZ/Ovf/2LiIgIJk+eTE5OjotaKqqjsn7Ny8ujV69eTJ8+3UUtE7VVUd/m5+ezd+9ebrnlFv7973+zdOlSDh06xC233OLCljZva9euZcGCBdxyyy0kJyfTu3dvpkyZwrFjx1zdNHGWLVu2cM011/DOO+/w2muvYbPZuOGGG8ocxzizP5w/fz6ffPIJS5Ys4a233iIvL4+bbroJm83mio/V7NXm2Eb6snHIzMxkwoQJeHl58fLLL7NmzRpmzpxJcHBwyTLSn03Hyy+/zD//+U9mz57N2rVrueeee3jllVdYuXJlmWWkP5sx3cRccMEF+p133tFaa33ZZZfppUuXlnn8iiuu0EuWLHFBy0RtOPr1559/1vHx8frAgQMljxUVFem+ffuW9Lto3HJycvQf//hHvXHjRn3ttdfqefPmaa21ttvtesCAAXrZsmUlyxYUFOjevXvr1atXu6q5wkmV9evZjhw5ouPj4/XevXtd0EJRU870rcP333+v4+Pj9W+//daALRQOV111lZ49e3aZ+/785z/rJ5980kUtEs5IS0vT8fHxesuWLVpr5/aHWVlZumvXrnrNmjUly5w4cUJ37txZf/nllw37AUStjm2kLxuPhQsX6gkTJlT6uPRn03LjjTfq++67r8x9t912m54+fbrWWvpTaN2oM7vOZrPZWLNmTUkGAUBSUhIbNmzg5MmTaK3ZtGkTv/zyCwMHDnRxa4WzyvdrYWEhAD4+PiXLWCwWvLy82L59u6uaKaph7ty5DB48mIsuuqjM/UePHiUlJaXM+unt7c0FF1zAd99919DNFNVUWb+Kpq86fZuTk4NSqsxVcNEwCgsL2bNnz++OcQYMGCDb0EYuOzsbgJCQEMC5/eHu3buxWq0MGDCgZJmWLVvSqVMn6W8XqM2xjfRl47FhwwYSExO544476N+/P6NHj+add94peVz6s2np3bt3yfk/wA8//MD27dsZPHgwIP0pwNPVDTiX/fv3M378eAoKCvD39+e5554jLi4OgAceeIAHH3yQQYMG4enpiVKKefPm0adPHxe3WpxLZf1qtVqJjY1l0aJFzJ07Fz8/P15//XVSUlJISUlxdbPFOaxZs4a9e/fyr3/963ePOfqvRYsWZe6PiIiQITiNXFX9Kpq26vRtQUEBTz75JJdffjmBgYEN0DpxtvT0dGw2W4XbUNk/Nl5aaxYsWEDv3r2Jj48HnNsfpqam4uXlVRIgO3uZ1NTUBmi5cKjtsY30ZeNx5MgRVq9ezeTJk7n55pvZuXMn8+bNw9vbm9GjR0t/NjFTpkwhOzubESNGYLFYsNlsTJs2jcsvvxyQ9VM0gWBX+/btSU5OJisri/Xr13PvvfeyatUq4uLiWLlyJTt27OCFF14gJiaGbdu2MWfOHKKioiT7oJGrql+feeYZ7r//fvr27YvFYqF///4MGjTI1U0W53D8+HHmz5/Pq6++WiYzrzylVJnbWuv6bpqoBWf7VTQ91elbq9XKtGnT0Frz8MMPN0wDRYUq2oaWv080HnPnzuXAgQMVTqBUk/2h7DMbVn0e20hfNjytNYmJidx1110AnH/++fz444+sXr2a0aNHlywn/dk0rF27lvfff59FixYRFxfHvn37WLBgAVFRUVxxxRUly0l/Nl+NPtjl7e1N27ZtAejWrRu7du1ixYoVzJo1iyVLlrB06VKGDBkCQOfOndm3bx+vvPKKBLsaucr6de7cuSQmJvLee++RnZ2N1WolPDycsWPHkpiY6OJWi6rs2bOHtLQ0rrzyypL7bDYbW7du5c0332TdunWAuYISFRVVskxaWhoREREN3l7hnHP1665du7BYLC5soagpZ/vWarVy5513cvToUd544w3J6nKRsLAwLBbL7640yza08XrkkUfYsGEDq1atIjo6uuT+yMhIoOr9YUREBFarlczMzDIZB2lpaSXlPET9q4tjG+nLxiMyMpKOHTuWua9Dhw58/PHHJY+D9GdT8cQTT3DjjTdy2WWXAZCQkMCxY8dYtmwZV1xxhfSnaNyzMVZEa01hYSFFRUVYrdbfRWotFotEYpsgR7+eLSgoiPDwcA4dOsTu3bsZNmyYi1onnHHhhRfywQcfkJycXPKTmJjIyJEjSU5OpnXr1kRGRrJx48aS5xQWFrJ161bZmTRi5+pXCXQ1Xc70rSPQ9euvv/L6668TFhbm6mY3W97e3nTt2rXMNhTgm2++kW1oI6O1Zu7cuaxfv5433niD1q1bl3m8VatW59wfJiYm4uXlVWaZU6dOcfDgQenvBlQXxzbSl41HUlJSSX0nh0OHDhEbGwvIutnU5OfnVxkLkP4UjTqza/HixQwaNIjo6Ghyc3NZu3YtW7ZsYfny5QQGBtK3b18WLlyIr68vMTExbN26leTkZGbOnOnqposqVNWvAB999BHh4eHExMSwf/9+Hn30UYYPHy4TDzRygYGBJfVIHPz9/QkNDS25f9KkSSxbtox27drRtm1bli1bhq+vb8nYetH4ONOvGRkZHD9+nFOnTgGUHEhGRESUXFUTjc+5+raoqIg77riDvXv3smzZMmw2W0n9i5CQELy9vV3R7GZt8uTJzJgxg8TERHr16sXbb7/N8ePHGT9+vKubJs4yZ84cPvzwQ55//nkCAgJK1pugoCB8fX1RSp1zfxgUFMSYMWN4/PHHCQsLIyQkhMcff5z4+HgZvdCA6uLYRvqy8bjuuuuYMGECL774IiNGjGDnzp288847zJ07F0DWzSbm4osv5sUXXyQmJqZkGONrr73GmDFjAOlP0ciDXampqcyYMYNTp04RFBREQkICy5cvL5ktYfHixSxevJjp06eTmZlJTEwM06ZNY8KECS5uuajKufo1JSWFxx57jLS0NCIjIxk1ahRTp051catFXZgyZQoFBQXMmTOHzMxMevTowauvvirDopq4DRs2cN9995XcnjZtGgC33XYbt99+u6uaJWrpxIkTbNiwAYBRo0aVeWzFihX069fPFc1q1i699FLS09N5/vnnOXXqFPHx8bz00kslWQmicVi9ejUAEydOLHP/ggULSobDObM/nDVrFp6entx5553k5+fTv39/HnvsMcmobWSkL5uO7t27s3TpUhYvXsxzzz1Hq1atmDVrFn/5y19KlpH+bDoeeOABnn76aebMmUNaWhpRUVGMGzeOW2+9tWQZ6c/mTWkZ8yeEEEIIIYQQQggh3ESTq9klhBBCCCGEEEIIIURlJNglhBBCCCGEEEIIIdyGBLuEEEIIIYQQQgghhNuQYJcQQgghhBBCCCGEcBsS7BJCCCGEEEIIIYQQbkOCXUIIIYQQQgghhBDCbUiwSwghhBBCCCGEEEK4DQl2CSGEEEIIIYQQQgi3IcEuIYQQQgghhBBCCOE2JNglhBBCCCGEEEIIIdyGBLuEEEIIIYQQQgghhNv4fxIrtE2CjehVAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 2 : Trend Change\n", + "\n", + "In this example, we illustrate how to use the `InterventionTimeEstimator` when the time series exhibits a **trend change**. \n", + "\n", + "A trend change corresponds to a gradual shift in the slope of the series starting at the intervention time. The model can be expressed as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\text{trend} &\\sim \\mathcal{N}(0, 0.5) \\\\\n", + "\\mu_{\\text{trend}} &= \\sigma(t) \\cdot \\text{trend} \\cdot (\\text{time} - t) \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{trend}}, \\sigma)\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAAE3CAYAAADmGhEoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAb5pJREFUeJzt3XmcTeUDx/HPmZUxg7FlyZYoS7ZsWUryoyikFJJkyS5KRaUiJbTIvoYUiZBS0U7KTgiRfScGw5j9+f3xmBnTzJgZZubey/f9enk595xzz3nuncc13/tsjjHGICIiIiIiIiIew8vVBRARERERERGR9FGYFxEREREREfEwCvMiIiIiIiIiHkZhXkRERERERMTDKMyLiIiIiIiIeBiFeREREREREREPozAvIiIiIiIi4mEU5kVEREREREQ8jMK8iIiIiIiIiIdRmBcRERERERHxMD7pfcKXX37J+vXr2bp1Kzt37iQqKophw4bRsmXLJOeOGTOGsWPHJnsdPz8/tmzZkuyxr776ipkzZ/LPP//g6+tL5cqV6dOnD3fccUd6iysiIiIiIiJy3Ul3mP/www85fPgwwcHBFChQgMOHD6f6nIcffpgiRYok2uft7Z3suRMnTuSDDz6gcOHCtG7dmrCwMJYsWUKbNm2YNm0aNWvWvOK9QkJC0v5iXCxXrlycPXvW1cUQSTfVXfFEqrfiiVRvxVOp7ooncqd6GxwcnOo56Q7zQ4cOpXjx4hQpUoTJkyfz3nvvpfqchx9+ONUQDrBv3z7GjBlDiRIlmD9/PkFBQQA8+eSTtGrVildffZVvv/0WH590F9steXlplIN4JtVd8USqt+KJVG/FU6nuiifytHqb7tLWrl07SSt7RlmwYAHR0dF07949PsgDlC5dmubNm3PgwAFWrVqVKfcWERERERER8RRZ8tXDunXrmDJlCh999BG//PILkZGRyZ63Zs0aAOrUqZPkWL169QBYu3Zt5hVURERExB2Eh5OjQwdo1QrCw11dGhERcUNZ0l999OjRiR7nz5+f4cOHJwnt+/btIyAggPz58ye5RvHixePPEREREbmuxcTgt3ix3f7gA9eWRURE3FKmhvmyZcsyfPhwqlevTr58+Th27BhLlixh0qRJdO/enc8//5zbb789/vzz58+TJ0+eZK8VGBgYf86V5MqVy6PGOqRlYgMRd6S6K55I9VY8hp9f/GZwcDDkyOHCwohcHX3miifypHqbqWG+YcOGiR4XL16cHj16kC9fPgYNGsT48eOTtNpfK3eZfTAtgoODPWr2fZE4qrviiVRvxaNcuEDcr5MhISGQwhBFEXelz1zxRO5Ub9PypYJLmrBbtGiBj48PGzZsSLQ/MDCQ0NDQZJ8T1yIf10IvIiIiIiIicqNySZj38/MjR44chP9nQpcSJUoQFhbGyZMnkzxn//798eeIiIiIiIiI3MhcEub37dvH2bNnkyxxV716dQBWrlyZ5DkrVqxIdI6IiIiIiIjIjSrTwvz58+fZsWNHkv1nz57llVdeAaBp06aJjrVs2RIfHx8mTJiQqLv9rl27+PLLLylWrBi1atXKrCKLiIiIiIjIdWb/fsP3PxoiIoyri5Kh0j0B3rx581i/fj0AO3fujN8Xt0Z8w4YNadiwIWfOnKF58+ZUqFCBMmXKkDdvXo4fP87y5cs5c+YMderUoUOHDomuXbJkSXr16sWoUaNo1qwZjRs3JiwsjCVLlhAdHc2bb76Jj0+WrKYnIiIi4joBAYQcPGgnQIqIcHVpREQ8zoGDhp9+hp9/MezeY/f16eXw2KOuLVdGSncyXr9+PQsXLky0b8OGDfGT2RUpUoSGDRuSO3dunnjiCTZt2sTPP/9MaGgo2bNnp0yZMjRr1oxWrVrh7e2d5Prdu3enSJEizJw5kzlz5uDr60uVKlXo06cPFStWvMqXKSIiIuJBHMcuR5cjh2ayFxFJo4OHDD//Aj/9bPhnd8J+b2+oWR3urueyomUKxxhzXfU1cJelBNLCnZY+EEkP1V3xRKq34olUb8VTqe5KVjlwwPDrChvgd/2TsN/bG6rdCQ3udahXB3LmdFK9ljvV27QsTac+6yIiIiLuJiKCgOeeAz8/eOcd8Pd3dYlERNyCMTa0/7rchvh9+xKOeXvBnXdCg/oO9epCrlypB3hPpjAvIiIi4m6io/GfM8duDx2qMC8iN7SYGMPWv2D5CsPyFXD0WMIxb2+4syrUv8fh7rqQO/f1HeAvpzAvIiIiIiIibickxPDpHMOy7+H0Zb3f/f2hVk24p57DXbUgKOjGCfCXU5gXERERERERt3H+vGHOXMPn8+BiuN0XmAPq1Ia773aoWR2yZbsxA/zlFOZFJMscOXKEli1b0qRJE1577TVXF0dERERE3Eh4uOGLhfDJbENoqN1X9nbo0N6hRnXw9VWAv5zC/A2mVq1a6Tp/1apVmVSSqzdkyBC++eYbFixYQOHChV1dnES+/vprhg4dyquvvsqDDz7o6uJck6t9n1u0aAHAokWLMqdgIiIiInJdiYoyfP0NzPjYcOqU3VeiBHTpZMfBO45CfHIU5m8wnTp1SrJv2rRpBAYG8vjjj7ugRHIjKVCgAJ999hmBgYGuLoqIiIiIuFhMjOGHH2HaDMORI3ZfoYLQ8WmHRg3B21sh/koU5m8wXbp0SbIvLswnd0wkI/n4+FCiRAlXF0NERERE3MCYcYb5C+x2nmB46kmHhx4EPz+F+LRwjDHG1YXISCEhIamf5CaCg4Pdory1atWiYMGCibpFXz62uX379kyYMIFNmzZx9uxZFiyw/+KuNPa5Vq1aVKlShQkTJiTaf+HCBWbPns1PP/3EkSNH8PX1pUKFCnTo0IHKlSunWtYWLVpw7NixJPsvv1fcvQcPHszEiRNZtWoVISEhjB07ljvvvBOAjRs38sknn7B161bCwsK46aabaNiwIR06dCBbtmzx142KimLhwoWsXLmSvXv3EhISQmBgIBUrVqRjx47cdttt8efGdUtPTtxwhe7du7Nx40aWL1/OtGnT+O677zhz5gwlSpSgZ8+e1KhRgwsXLjBx4kR++eUXzp49S5kyZXj++ecpW7ZskuuePn2ajz/+mN9++43jx48TEBBAlSpV6NKlC6VKlUry3gHMmTOHSZMm8eOPP3LmzBmKFStGp06daNCgQZrf5+TqblydSU6nTp3o0qVLimPmXfm+yI3DXT5zRdLEGJxTp8idOzch3t6gLqbiYfSZK6k5edLQqo0hOho6d3R4vBVkz+7azzp3qrfBwcGpnqOW+eRcuJDyMW9vuCzsXfFcLy/Inj3lc/38Evb999ywMEjue5YcOVK+XyY4dOgQnTt3pmTJkjRp0oRz587h6+tLVFRUuq919uxZunfvzp49e6hcuTI1a9bkwoULLF++nJ49e/L2229zzz33XPEarVu3ZsmSJezatYvHH388vrt2oUKFEp137tw5unTpQs6cOWnYsCFRUVHkuPTeLViwgJEjRxIUFETdunUJDg5m27ZtzJgxg/Xr1zN+/Hh8fX3jrzNq1CgqVapE7dq1CQoK4siRI6xYsYJVq1YxYcIEypUrB8A999zD+fPnWb58OXfffTelS5dO8XW8+uqr7N69m3r16hEREcHSpUvp378/kydPZvjw4URGRnLvvfdy5swZfvjhB5599lkWLlwY/xrifjY9evTg5MmT1KxZk7vvvpuQkBB+/vlnVq9ezZgxY6hQoUKi+8bExNCnTx/OnTvHPffcQ0REBN9//z2vvPIKo0aNombNmul6ny8XFBREp06dmDt3LkCiYRtVq1a9wk/V9e+LiIjbcRxMvnwQHAxu8ouliEhGmrfABvnKlewEd5J+CvPJCC5aNMVjUf/7H+cvhRWA3LfdhhMWlvy5depw/quv4h/nqlwZr7gZHeLudenv6CpVCP3xx/j9Oe+6C++DB5NcM+T06bS8hAyzefNmOnbsyDPPPJNo/5G4QS3p8N5777Fnz54kk8N169aNjh078s4771CrVi38/f1TvEbr1q3ZuXNnfMhMaWK23bt38+CDDzJw4EC8vb3j9+/du5f33nuP0qVLM2bMGHLlyhV/7OOPP2b8+PF8/vnnPPHEE4ANqIsWLaJAgQKJrr9nzx46d+7MhAkTGDNmDGDDfGhoaHyYv9IEeGfOnOGTTz4h+6UvcGrUqMGgQYPo3bs3NWrUYPDgwfj42H+epUuXZty4cSxevJg2bdrEX2Pw4MGcOnUqUQgHePrpp+nQoQPDhg3j008/TXTfkydPUrZs2URfWDRq1IjevXszZ86cRGE+Le/z5YKCgujSpQtLliwBkh/SkRpXvS8iIiIiknUuXDB8udhut35cQf5qebm6AOLe8ubNy9NPP33N1zlz5gw//vgj1apVSxJy8+bNyxNPPEFISAhr16695nsB+Pr60qtXr0RBHmDhwoXExMTw3HPPJQryAO3atSM4OJjvv/8+fp+fn1+SIA9wyy23ULVqVTZt2kR0dHS6y9etW7f4wArQoEEDfHx8CA0NpXfv3vGBFWzYBti1a1f8vr///pstW7bQpEmTRIEVoFixYjRv3pzdu3eze/fuJPfu27dvfJAHqF69OgULFmTbtm3pfh0ZzZXvi4iIW4mIIPsLL0DPnhAR4erSiIhkqMVf2w7KxYtB7fQttiWXUct8MkKSaRGP959weObvv1M+1yvxdyVnN21K9DjRmIz/nHvujz+S72afxUqXLp0o+F2tbdu2ERMTQ2RkJFOmTEly/OCl93z//v3UrVv3mu9XuHBhcufOnWT/1q1bATuGPbkvDnx8fNi/f3+ifTt37uSTTz7hzz//5NSpU0nC+5kzZ8iXL1+6ynf5WHsAb29vgoODCQ8Pp2DBgomO5c2bF7Ct6v99HadPn072/Yx7Dfv37080RjwoKCjZVvYCBQrEX9OVXPW+iIi4nehosk2bZrcHDoQr9FoTEfEk0dGGefNtzmnzuIOXl1rmr5bCfHLSMy79Ws7NkQMiI5M/NyAg7dfNRHny5MmQ65w7dw6w3fY3b96c4nkXL17MkPulVO64csyYMSNN19m8eTO9evUCbJfvBg0aEHDpZ7N8+XJ27dpFZEo/wyvIkUy98fb2TnZ/XGv05V8ixL2OlStXsnLlyhTv89/3M7nrx907NjY29YJnMle9LyIiIiKSNX78CU6ctLPXN/qfq0vj2RTm5ap4XepJEBMTk+TY+fPnk+yLC2Nt27alT58+mVu4K4grx48//phisL3cjBkziIyMZNKkSVSqVCnRsb/++itRF++sFFf2559/nlatWrmkDO5I74uIiIiI+zLGMHuubZV/9BFHS9BdI42Zl6sSFBQEJO7iHOfvZIYelCtXDsdx2LJlyzXfO24c/NW0JJcvXx4gzV3KDx8+TM6cOZME+fDw8GRf57WULT3iXkdGvJ8pudrX4spW/qx4X0RERETk6qxdB7t3Q/Zs0KK5q0vj+RTm5arkyJGDYsWK8eeff8aPdwe7jvx/15YHO775vvvuY8uWLXzyySeYZOYD2Lp1K+Hh4aneO2fOnACcOHEi3eV+5JFH8Pb25v333+f48eNJjoeGhiYK6QULFiQ0NJQ9e/bE74uJiWH06NHJrkF5LWVLj/Lly1O+fHm+//77RBP2xYmNjWXDhg3XdI+rfS05c+bk7NmzRLhgwqaseF9ERERE5OrMudQq/2BTyBmkVvlrpW72ctXatGnD8OHD6dKlCw0aNMAYwx9//MHtt9+e7PkvvPACBw4cYOzYsXz77bfccccd5MiRgxMnTrBjxw4OHjzIkiVLyJYt2xXve+edd/Lpp58yfPhwGjRoQPbs2bnpppto3LhxqmUuVaoUL7zwAiNHjuSxxx6jdu3aFClShAsXLnDkyBE2btxI06ZNeemllwBo1aoVq1evpmvXrtx33334+fmxYcMGTp48SdWqVZMEwwoVKuDv78/cuXO5cOECwcF28cH27dun5S1NlzfffJMePXowaNAg5s6dy+23346fnx/Hjx9ny5YtnDlzhuXLl1/19a/2fb7zzjvZvn07/fv3p3Llyvj6+lKxYkUqV6581WVJj8x+X0REREQk/XbtMqxdB95e8NijCvIZQWFertrDDz9MdHQ0c+fOZfHixeTLl4+mTZvy9NNPJzsjfa5cuZg8eTLz58/nhx9+YOnSpcTGxpI3b15Kly5Nx44dkywXl5zatWvTq1cvvvzyS2bNmkV0dDRVqlRJU5gHaNGiBWXKlGHOnDls2rSJFStWEBgYyE033UTr1q1p0qRJ/Ll169bl7bffZubMmXz33Xdky5aNO++8k+HDhzMtbpbh/7zGYcOGMXXqVBYsWBDfOp0ZYb5w4cJ8/PHHzJkzh+XLl/PVV1/h7e1N3rx5qVy5Mg0aNLim61/t+9yxY0dCQ0NZuXIl69evJzY2lk6dOmVZmM/s90VERERE0i+uVb5+fShUSGE+Izgmuf7OHiy5rs/uKtHSdCIeRHVXPJHqrXiU2Fi8Dh0iV65chAQFJVnCVsTd6TNXLnfsuOHxNoaYWJg22eG2Mu4Z5t2p3sb18L0S/c8gIiIi4m68vIgtVgxKlFCQFxGPN+8LG+TvrIrbBnlPpP8dREREREREJFOEhhoWf2W3Wz+uIJ+RNGZeRERExN1ERpJ96FDIlg369wc/P1eXSEQEsGvFb9wEXyw0ZPOHh1s4VCifckj/8iu4eBFuKQm1amRdOW8ECvMiIiIi7iYqimxjx9rtZ59VmBcRlzPGsGEjfDTD8OfmhP1LvzeUK2t47FGH+veAj09CsI+KMsz7wk7R1uZxB8dRy3xGUpgXERERERGRZBljWLceps80bN5i9/n62rXiI8Lh+x9h23Z4401DgYnQ8mFo9iDkzOnw/Q9w6hTkywcN73Pt67geKcyLiIiIiIhcJw4fMeTPB35+19YKHhfiP5ph2LLV7vPzhWYPwRNtHPLnt9fv9oxh0WJY+KXhxEmYONkwfSY80Nh2xwdo9YiDr69a5TOawryIiIiIiMh1YNkPhjffMhQrCh9+APnyXl2A3rLVMH7if0J8M2jXxiFfvsTXzJPHoWMHaNcWfvwJPp9v2PUPLFpsjwcEQPOHruFFSYoU5kVERERERDzcwUOGke8ZjIH9B6BPX8PoUekP9D/8aBg6zBAdbafraH6pJf6/If6//PwcHrgf7m8Mm/60oX7l79C+nUNgoFrlM4PCvIiIiIiIiAeLijK8McRw8SKULwcn/4UDB9Mf6Od9YfhwjJ2wrv7d0PdZJ91fBjiOQ5XKUKWygzFGk95lIq0zLyIiIiIi4sEmTjH8vRNy5oQ333AYM8rhpptsoO/d1/Dvv+aKzzfGMGlKbHyQf+RhGPJG+oP8fynIZy6FeRERERF3kz07Z1euhK1bIXt2V5dGRNzYH6sNcz+32wNfdChQwKFI4YRAf/Ag9O6XcqCPjja8M9Iw61P7uEsnh759HLy8FMTdncK8iIiIiLvx8iK2bFkoXx689OuaiCTv31OGt4YltKbXq5sQwAsXsoG+4KVA36uv4eTJxIE+PNzwymuGJd/Yj5qX+js89aTWg/cU+t9BRERERETEw8TG2pnrz5yBW0tBj25JA/jlgf7QIdtCHxfoz50z9OtvJ6nz84O333R46EGFeE+iMC8iIiLibiIjyfbOO/DGGxAZ6erSiIgb+nQOrN8A2bLB4Ncc/P2TD+KFLgX6QgUvBfq+hq1/GXr0sUvPBQbCB+861K2jIO9pFOZFRERE3E1UFNlHjIDBgyEqytWlERE3s/Uvw9RptoW937MOxYtfOYgnCvSHoVtPw759kD8fjB/tUKmigrwnUpgXERERERHxEKGhdhm6mFhoeB80uT9tzytY8FKgL2QfFysKE8Y53HKLgryn0jrzIiIiIiIiHsAYw4j3DMeOQ+HC8MJz6ZusrmBBh4ljYcVKaFAfcuZUkPdkCvMiIiIiIiJuzBhDSAh8uxR+/gW8veGNQQ45cqQ/jOfN69CiWcaXUbKewryIiIiIiIibOHfOsHcf7NkLe/eaS3/D2XMJ53Tt4lCurFrVb3QK8yIiIiIiIi727XeGSVMN//6b/HHHgSKF4Z67ofVjWVs2cU8K8yIiIiIiIi60e4/hnZGGmBj7uOBNULKk/XNLSYeSJaB4MciWTa3xkkBhXkRERMTdZMvGuR9+IGfOnHYRaRG5bkVHG4YNt0G+bh0Y9PLVjYWXG4/CvIiIiIi78fYmpmpVCA6GkBBXl0ZEMtHcebDjbwgMhP7PKchL2mmdeRERERERERc4cMAw7SMDQJ+eDvnyKshL2qllXkRERMTdREbiP3EiBARA+/bg5+fqEolIBouNNQwbYYiMghrV4YH7XV0i8TQK8yIiIiLuJiqKgDfesNtt2ijMi1yHFiyCLVshe3Z4sb+D46hVXtJH3exFRERERESy0JGjhkmTbff6Ht0cCt6kIC/ppzAvIiIiIiKSRYwxDB9puBgOlStB84dcXSLxVArzIiIiIiIiWeTrJbB+A/j7w4AXHLy81CovV0dhXkREREREJAucPGkYO8F2r+/SyeHmmxXk5eppAjwREREREZEU/LnZsGatISYGYmIgNhZiYiE2bjsGYg0UvMmhUkUoXw78/ZOGdGMMI983XLgA5cpCq0dc8GLkuqIwLyIiIiIikoyQEEP/lwwXL6blbNvi7uMDZW83VLwDKldyqFAegoIcvv8Bfv8DfH1hwIsO3t5qlZdrozAvIiIi4m6yZSN08WKCgoIgWzZXl0bkhjVzlg3yxYpCrZrg7Q1eXuDlDd5e4OXl4OUFjgN79hr+3Az//muXnNuyFT6dY3AcKHWL4dhxe82nnnS4paSCvFw7hXkRERERd+PtTXTduhAcDCEhri6NyA3pyFHDosV2+/l+DndWTS2AOxhjOHIU/vwT/txi+PNPOHQY/tltzyh9K7Rrm6nFlhuIwryIiIiIiMh/TPvIEB0N1auRhiBvOY5DkcJQpDA0ecA+599TtsV+715D0wccfHzUKi8ZQ2FeRERExN1EReE/cyYEBECrVnaQrYhkmX92G5b9YLe7drm28J0vr8N99wL3KsRLxlKYFxEREXE3kZEEvPii3W7eXGFeJItNnmowBhrcC7ffphAu7knrzIuIiIiIiFzy52bD73/YCe66dFKQF/elMC8iIiIiIoJdC37iZLvE3INNoejNCvPivhTmRUREREREgJV/2CXl/P3h6acU5MW9KcyLiIiIiMgNLybGMHmKbZVv9Qjky6cwL+5NYV5ERERERG54y36APXshMBDatlGQF/enMC8iIiIiIje0yEjDtI9sq/yTTzjkDFKYF/enpelERERE3I2/P6GffUZQYKAdvCsimWrRYjh2HPLlg0cednVpRNJGYV5ERETE3fj4EN2oEQQHQ0iIq0sjcl0LCzN8PMu2ynfs4JAtm1rlxTOom72IiIiIiLiVTX8aps80RESYTL/XnLmGM2ehaFFocn+m304kw6S7Zf7LL79k/fr1bN26lZ07dxIVFcWwYcNo2bJlsuefP3+eMWPGsGzZMk6ePEn+/Plp1KgRvXv3JjAwMNnnfPXVV8ycOZN//vkHX19fKleuTJ8+fbjjjjvSW1wRERERzxMVhd+8eZAjBzRpAr6+ri6RSJY5dcow4BXD+fNw9Bi8/FLmtZSHhBg++9xuP9PJwcdHrfLiOdLdMv/hhx8yd+5cjhw5QoECBa54blhYGO3atWPGjBmULFmSDh06UKpUKWbMmEG7du0ICwtL8pyJEyfSv39/Tp06RevWrXnggQfYsGEDbdq0YfXq1ektroiIiIjniYwkR69e8PTTEBnp6tKIZKkx422QB/jmW/h6Sea0zoeFGYYOM1y8CLffBvXvyZTbiGSadIf5oUOH8tNPP7Fq1Spat259xXOnTp3K9u3b6dy5Mx999BH9+/dn6tSp9OzZk+3btzN16tRE5+/bt48xY8ZQokQJFi9ezIABAxgyZAifffYZPj4+vPrqq0RHR6e3yCIiIiIi4gFWrzH88CN4ecEDje2+90cZdu7K2EB/7Lihey/D6jXg5wd9ejk4jlrlxbOkO8zXrl2bIkWKpHqeMYZ58+YREBBAz549Ex3r2rUruXLlYv78+RiT8A9zwYIFREdH0717d4KCguL3ly5dmubNm3PgwAFWrVqV3iKLiIiIiIibCw83vPuBzQatHoGBLznUvgsio+DV1w2hoRkT6P/aZnimm2H3HsgTDGNGOVS8Q0FePE+mTYC3b98+Tpw4QdWqVQkICEh0zN/fn2rVqnH8+HH2798fv3/NmjUA1KlTJ8n16tWrB8DatWszq8giIiIiIuIiM2cZjh6FAgWg09MOXl4Or77sUKggHDkCb71jiI29tkD/w4+G3s8aTodAqVIweaJD+XIK8uKZMi3Mx4X0EiVKJHu8ePHiic4D+wVAQEAA+fPnT/H8ffv2ZWxBRURERETEpfbsMcz+zG4/96xDQIAN2DmDHN4c7ODrC7+tJP6c9DLG8NEMwxtvGiKjoE5tmDDGoeBNCvLiuTJtnfnQ0FCAFGesj9sfdx7Yme/z5MlzxfPPx82GkYJcuXLh5eU5K+4FBwe7uggiV0V1VzyR6q14DD+/+M3g4GA7q72Ih0nrZ25srOH90eeIiYmmYQM/HnowKNHxu2rBywPCGfzmBSZPNdSoHkTNGmlf4SEiwvDq6+f55ls7mWSH9tl4rm8A3t4K8pKUJ/2ukGlh3lXOnj3r6iKkWXBwMCEhIa4uhki6qe6KJ1K9FY9y4QJxv06GhIRoRnvxOOn5zP3yK8OmTYbs2aFHt6hkn9ewgWHNGvh2KTz/4jmmT3HIly/1MH76tGHgq4a/toG3Nzzfz6HZg5GcO6d/U5KUO/2ukJYvFTItzMdNYJdSS3rc/ssnugsMDEzUUp/c+Sm19IuIiIhcN/z9Of/RR/b3Hn9/V5dGJNOcOmWYMMmOg3+ms0OBAskHdMdxeL4f7PzHsHs3vDbYMPoDkl0XPibGsONvWLXasOQbOHESgoLgrSEOVauoNV6uH5kW5lMb4x43Vj7uPLDj6zdu3MjJkyeTjJtPbQy+iIiIyHXDx4eoFi0gOBjcpJVIJDPErSl/Wxlo2eLK52bL5jB0MHTuati8BSZONvTqYcP52bOG1Wth1Sq73NzZcwnPu/lmGDHMoVhRBXm5vmRamC9RogQFChRgw4YNhIWFJZrRPiIignXr1lGgQIFEYb569eps3LiRlStX0qJFi0TXW7FiRfw5IiIiIiLi2S5fU/7F/k6axrAXvdnh5ZfgldcMn30O4eGx7PoHtm2Hy1a8JjAHVK8OtWo63HsP8RPqiVxPMm2mOMdxaNWqFWFhYYwbNy7RsUmTJnH27FlatWqF4yT8w2rZsiU+Pj5MmDAhUXf7Xbt28eWXX1KsWDFq1aqVWUUWERERcQ/R0fguWgTz5kF0tKtLI5Lh/rum/G1l0h6277nbofVjdnvRYvhrmw3ypUrBE21g7IcOX3/p8OYbXjR9wFGQl+tWulvm582bx/r16wHYuXNn/L64NeIbNmxIw4YNAejcuTM//fQTU6dOZfv27ZQvX54dO3awfPlyypYtS+fOnRNdu2TJkvTq1YtRo0bRrFkzGjduTFhYGEuWLCE6Opo333wTH5/rbs4+ERERkcQiIgjs2NFuHzwI+v1HrjP/XVM+vbo943DxouHMWahZw6FWDVIcby9yvUr3/wzr169n4cKFifZt2LCBDRs2AFCkSJH4MB8QEMCsWbMYO3YsS5cuZc2aNeTLl48OHTrQq1evRF3v43Tv3p0iRYowc+ZM5syZg6+vL1WqVKFPnz5UrFjxal6jiIiIiIi4iX92J7+mfHr4+Di88LzCu9zYHGMuH13i+dxlKYG0cKelD0TSQ3VXPJHqrXiUCxcILloUgJCDB7XOvHiclD5zT5wwdOtlOHEC6tWFYUMzbdSvSLq50+8KaVmaTv96REREREQk0509a3juBRvkixWFl/qrZV3kWijMi4iIiIhIprp40fDiQMO+/ZA/H7z/rkPu3ArzItdCYV5ERERERDJNdLTh1dcNf22DoCAb5AvepCAvcq0U5kVEREREJFPExhrefseweg1kywYj33EoWUJBXiQjaJ0TEREREXfj58eFsWPJkSMH+Pm5ujQiV8UYw5hxhmU/gLc3vDnYoUJ5BXmRjKIwLyIiIuJufH2JbNuWHMHB4CYzK4uk1yezYd4XdvuVAQ531VSQF8lI6mYvIiIiIiIZav6CcCZNsStg9+nl0Oh/CvIiGU0t8yIiIiLuJjoan59+gsBAqFEDfPQrm3iOX1cYBr95AYAn28FjjyrIi2QG/c8gIiIi4m4iIghq3dpuHzyoMC8e4+Ahw+AhhthYeKgpPNNJQV4ks6ibvYiIiIiIZIg5cw2RUVCzhg/P93NwHIV5kcyiMC8iIiIiItfs9GnDd9/Z7Z7dA/DxUZAXyUwK8yIiIiIics0WLLKt8uXKQtUqGhoiktkU5kVERERE5JqEhxsWLLLbbR5X93qRrKAwLyIiIiIi12TJt3DuHBQuDHfXc3VpRG4MCvMiIiIiInLVYmIMc+fZNeUfb+Xg7a1WeZGsoMEsIiIiIu7Gz4+wESMICAgAPz9Xl0ZuAMYY5syFn38xPN/P4fbb0h7IV/wGR45AzpzQ5P5MLKSIJKIwLyIiIuJufH2J6NyZgOBgCAlxdWnkOhcbaxg91jB/gX086A3D9CkQGJh6oDfGMPsz2yr/cHPInl2t8iJZRd3sRURERERuUNHRhjffTgjyuXLC0aPw7gcGY0yqz9+8BbZtBz9feORhBXmRrKQwLyIiIuJuYmLw+e03+OUXiIlxdWnkOhUebhjwiuH7H8DbG157xWH4MAdvL/jhR/huaerX+GyuDfyNG0OePArzIllJYV5ERETE3YSHE9SsGdx7L4SHu7o0ch06F2ro19+wajX4+8M7bzk0+p9DhfIOnTraUP7+KMOBgym3zh84YPjtd7vdupWCvEhWU5gXEREREbmB/PuvoVcfw5atEBgIH7zrcFethDD+RBuoWgUuhsMbQwyRkckH+s/mGYyBOrWheHGFeZGspjAvIiIiInKDOHTI0L23Yc9eyJsXxo12qHhH4iDu7e0w6GWHXDlh5y6YNCVpmA8JMXz3nd1u21pBXsQVFOZFRERERG4Au3YZevQ2HD0KRQrD+DEOpW5JPojnz+8wcIA9Nnce/LEqcaD/YqEhMgrKloWKd2R60UUkGVqaTkRERETEjV28aDh0CPLlh9y5wHHS1hJ+5ozh751c+mNYsxYuXoRbS8F7Ixzy5r3yderWdnj0EcP8L+CtdwwzpkG+vA7h4YYFi+w5bR530lweEclYCvMiIiIiIm5s4KuGdevtdrZsULCgoVBBKFgQChV0KFgQCt4E584lBPe/d8Lx40mvVaminewuKChtAbz7Mw6bNhn+2Q1D3za8PxK++c7eq1AhuLtuBr5QEUkXhXkRERERETd19qxh/Qa77Th2cYN9++wf68prwd98M9xWBm4r43D7bTbMe3unvSXd399h8GvQqav9QuHTOfD1EnvP1q0cfHzUKi/iKgrzIiIiIu7G15ewN94gICAAfH1dXRpxoQ0bwRgoWQKmTXY4fgKOHYOjx+DoMcOxYwmPs2dPCO63lYEypSEw8NrDdvHiDn17wzsjTfxkeEFB0OSBa760iFwDhXkRERERd+PnR0SfPgQEB0NIiKtLI1cpNtbwzXdQ7na4JYWJ5lKzbr0Nz9XuBD8/h6I3Q9Gb445mXat40yawZh389LN9/HBzyJ5drfIirqTZ7EVEREREMsHX38A7IwyvDblyV/griRsrX+1O1wZnx3F44TmHokUhV0545GEFeRFXU8u8iIiIiLuJicH7zz8hZ04oWRK8vV1dIkmn6GjDrE9siN+3Dw4eMhS9OX0B+MhRw+Ej4O0FVSpnfBnTKyjIYfoUiImBHDkU5kVcTS3zIiIiIu4mPJycDRtCjRp2xjPxOMu+t+PY4/z+R/qvEdcqX64cBAS4R3jOls1RkBdxEwrzIiIiIiIZKCbG8PGntlW+WFG7b+Xv6e9qf/l4eRGR/1KYFxERERHJQD/+DIcO2VESg1+3rdh/bobQ0LQH+thYw/pLLfPVq6klXESSUpgXEREREckgsbGGjy+NlX/sUYfStzqUKG7Hma9ek/br/LMbzp6zy82VK5tJhRURj6YwLyIiIiKSQX5dbie8C8wBj7a0+2rXtn+v/CPtLfNx4+WrVAYfH7XMi0hSCvMiIiIiIhnAGMPMWTawt3oUAgNtCK9zl/171Wo7y31aJIyXV5AXkeQpzIuIiIiIZICVv9vu8dmzQ6tHEkJ4hfJ2bfbQUNj6V+rXiYgw/LnZbmvyOxFJicK8iIiIiLvx9eXiiy/C66+Dr6+rS3ND2r/f8Okck+ZJ64wxzPjYnvvIw5AzZ0KY9/Z2qFXLbqdlVvu/tkFEBOTNAyVLpLvoInKDUJgXERERcTd+foQPGABvvAF+fq4uzQ3n4kVDvxcMEyYZej1r+Pff1AP46jWw42/Ilg0efyxp1/jal7rar/w99fuvXZewJJ3jqJu9iCRPYV5ERERE5DIzPjacOGG3d++Bbj0NBw6kHOgvb5Vv3gyCcycN4DWrg7c3HDgIBw9d+cuBuMnvqmlJOhG5AoV5EREREXcTG4vX9u3w118QG+vq0txQ9u03fPa53e7bx+Hmm+HYcejey7Bte/IhfP0GOxbezxfaPJ58AA8MdKhcyW5fqXX+XKhhx992u1rVq30VInIjUJgXERERcTcXL5KrTh2oUAEuXnR1aW4YxhjeH2WIiYHad8GjLR0mjHW4/Ta75vuz/Qyr1yQN9HGt8g89CPnyptyaXqd2XFf7lFvmN24EY6BEccifXy3zIpIyhXkREREREeDHn2DDRjtNQd8+NkgH53YY/YFD9WpwMRxeHGhYuiwhjP+52bDpT/DxgbZtrhy+61xab37zZlKcWG/t+oTx8iIiV6IwLyIiIiI3vAsXDGPG2yDdvp1D4UIJwTwgwGHEMIf/NYSYGHjzbcOcufbcuFb5pg/ATQWuHOaLFHYoUQJiYu2EecmJHy+v9eVFJBUK8yIiIiJyw/tohuHUKbi5CLR5POlxX1+HQS87PPaofTxugmHQG7GsXWcntmvXNm3hu/Zd9u+VfyRtmT92zHDoEHh7ET++XkQkJQrzIiIiInJD273HMP8Lu93vWQd//+SDuZeXQ++eDt272uM//2L3N24EhQqlLczXubRE3arVEB2dONCv22D/LlvWTpgnInIlCvMiIiIicsMyxvDeB4aYWKh/N9SsceUQ7TgOT7RxePklB28v8PWFJ59Ie/CuUB5y5YTQUNiyNfGxdRovLyLp4OPqAoiIiIiIuMp3S2HzFsieDXr3Snsob/KAQ/lyEB0DRW9O+/O8vR1q1TIsXQa//2GoUtk+NzbWxI+Xr6715UUkDdQyLyIiIuJufH0J79UL+ve3Tb+SKc6FGsZNtK3hHZ5yUp3A7r+KF3codUv6g3fCEnUJ+3bvgTNn7JcK5cqm+5IicgNSy7yIiIiIu/Hz4+KQIWQLDoaQEFeX5ro1ZZrhzBm7pnvcxHZZoWZ1O2negYNw8JCh6M1OfKt85cp2sj0RkdSoZV5EREREbjg7/jYs+tJuP9fXydIAnSOHEz9bfVzrfMJ4eQV5EUkbhXkRERERdxMbi9eBA7BvH8TGuro0153YWMN7owzGwP8aQtUqWR+gE7raGyIjDX9utvs1+Z2IpJXCvIiIiIi7uXiRXJUrQ8mScPGiq0tz3Vm0GLZvhxw5oGd317SE16lt/9682S5TFx4OwcFwS0mXFEdEPJDCvIiIiIjcMI4cNUy4NOndM50c8uV1TZgvUtihRAmIiYVJUxKWpHMcdbMXkbRRmBcRERGRG0JsrGHYcMPFcKhcCR5u4dry1LnL/r3/gP27usbLi0g6KMyLiIiIyA1h4SLYuMku/zbwJQcvL9eG57hx83Hu1Hh5EUkHhXkRERERue4dPmyYMNl2Z+/W1aFIYde3gpcvB7ly2u1iRUn3OvcicmNTmBcRERGR61psrGHYCEN4OFSpDA83d3WJLG9vh9qXutpXr+basoiI5/FxdQFERERERDLTFwth05/u073+ct2ecciX3/D4o+5TJhHxDArzIiIiIu7Gx4fwTp3I5u8PPvp17VocOmSYeKl7fY/uDoULuVdozpvXoWtn9yqTiHgG/e8gIiIi4m78/bk4ciTZgoMhJMTVpfFYsbGGt4cbIiLgzqrQ/CFXl0hEJOMozIuIiIiIW9iw0TD1I4OXF2TLBtn8wf/S39mygb8/ZMvmkD8/1KsDgYFXbtGe/wVs3gLZs8OAF9yre72IyLVSmBcRERFxN8bgnDoF0dHg7Q3O9R9CQ0MNg4caTp1K7UzbZd7fH+6pZ2jygEPVKiQJ6gcOGiZOsef27O5QyM2614uIXCuFeRERERF3ExZG7jJl7PbBg5Ajh2vLkwXGT7JBvmhR6NzRISIcwiMgPBwiIiA83HaXvxgOf/0F+/bDsh9g2Q+GgjfBA/cbHrjfjomPiTEMG26IjIRqd6p7vYhcnxTmRURERMSlNmw0fPW13R7wgkOlism1oifsM8awbTt8863hx5/g2HGYPhOmzzRUqWwoVAi2bIWAAHs95wbo2SAiNx6FeRERERFxmYgIw4h3bXf4Fs1IIcgn5jgO5ctB+XIOfXoZfl1hg/36DbBxk/0D0KuHQ8GCCvIicn3KkjDfoEEDDh8+nOyxxx9/nCFDhiTad/78ecaMGcOyZcs4efIk+fPnp1GjRvTu3ZvAwMCsKLKIiIiIZIHpMw2HDkO+fHbN9fTy93do1BAaNXQ4dtzw3VL4+RfDbbfBQ00zocAiIm4iy1rmg4KCeOqpp5Lsr1ChQqLHYWFhtGvXju3bt1OnTh2aNm3Kjh07mDFjBqtXr2b27NkEBARkVbFFREREJJPs3GWY85nd7t/PSXV2+tQUvMmhQ3vo0F6t8SJy/cuyMJ8zZ0569+6d6nlTp05l+/btdO7cmRdeeCF+/+jRoxk3bhxTp06lT58+mVlUEREREUmHCxfsTPSxsdD/OYeCN6UepqOjDe+MNMTEwr31oW4dBXARkfTwcnUBLmeMYd68eQQEBNCzZ89Ex7p27UquXLmYP38+xhgXlVBERERELhcebnhxoOH3P2DVaujUxbB6Teq/q30+H3buhKAg6NtbQV5EJL2yrGU+MjKShQsXcvz4cXLmzEnVqlW5/fbbE52zb98+Tpw4Qd26dZN0pff396datWr8+OOP7N+/nxIlSmRV0UVERESylo8PEW3a4O/nBz7uO19xVJTh1dcNf262q+cVLgS7/oH+Lxmefgo6tE+6/jvA4cOGadNt4O/VwyFvXoV5EZH0yrL/HU6ePMmAAQMS7atXrx4jRowgT548AOzfvx8gxaBevHjx+PMU5kVEROS65e9P2Lhx+AcHQ0iIq0uTrJgYw5C3DKtWg78/jBjmcPttMHqs4cuv4KMZhq1/wWuvQO7ciZeVG/GeXTP+zqrQ5H4XvggREQ+WJWG+ZcuW1KhRg1tvvRU/Pz92797N2LFjWb58OT169GDOnDk4jkNoaChAijPWx+2POy85uXLlwsvLrUYPXFFwcLCriyByVVR3xROp3ooncsd6a4zh9cEX+PmXCHx8YPQHQdSt4wfA20OhZs0Ihgw9z5q10LmbwwfvBlLxDl8AFi4KZ/2GC/j7w9AhucmTx9uVL0UykTvWXZHUeFK9zZIw36tXr0SPK1WqxKRJk2jXrh3r16/n119/pX79+hlyr7Nnz2bIdbJCcHAwIW76bbvIlajuiidSvRWPYgyEhdl6GxEBjvt0QzfGMHa84YuF4OUFbwxyKF/uAiEhF+LPubsuTBrv8MprhkOHYnmywzn69HK4px68M9J2r+/0tENQ4Dl37Xgg10ifueKJ3KnepuVLBZc1YXt5edGyZUsANmzYANjl68CuM5+cuP1x54mIiIhcl8LCCC5aFAIDISzM1aVJZMbHMHee3R7wgkP9e5L/oqHULQ5TJzrcczdER8P7owwduxjOn4cyZeCxR7Ow0CIi1yGX9keP+7bh4sWLQMKY+H379iV7ftyY+rjzRERERCTrfD4/YeK6Z3s7NHngyj0GAgMdhg526NXDwdsLTp0Gby/7JYCPj/v0NhAR8UQunR518+bNABQpUgSwE98VKFCADRs2EBYWlmhG+4iICNatW0eBAgUU5kVERESy2NffGEaPtUG+c0eHVo+kLYw7jkPrx6Ds7TBpiuF/DR3KlFaQFxG5VpneMv/PP/9w7ty5JPvXrVvH9OnT8fPzo1GjRoD9sG/VqhVhYWGMGzcu0fmTJk3i7NmztGrVCseNxo2JiIiIXO+WrzCMeNcG+daPwVNPpv8alSo6jB/jxcPN9XuciEhGyPSW+W+//ZapU6dy1113UaRIEfz8/Ni5cycrV67Ey8uLwYMHU7hw4fjzO3fuzE8//cTUqVPZvn075cuXZ8eOHSxfvpyyZcvSuXPnzC6yiIiIiFwSHW0YNcYQGwsPNYWe3R01rIiIuIFMD/M1a9Zk9+7dbNu2jTVr1hAZGUnevHlp0qQJHTp0oGLFionODwgIYNasWYwdO5alS5eyZs0a8uXLR4cOHejVq1eirvciIiIikrn+WAUnTkDuXNC3j4K8iIi7yPQwX6NGDWrUqJGu5wQFBTFw4EAGDhyYSaUSERERkbRY+KXtXt+kCfj7K8iLiLgLl06AJyIiIiLJ8PYmslkz/Pz8wNvbZcU4dMiwZq1d5r75QwryIiLuRGFeRERExN1ky8aFGTPwCw6GkBCXFWPRYtsqX7MGFCmsMC8i4k5cus68iIiIiLiniAjDN9/Zbc1ALyLifhTmRURERCSJn36Gc+eg4E1Qq6arSyMiIv+lMC8iIiLibi5cIDhPHjtY/cIFlxQhbuK75s0cvL3VMi8i4m4U5kVEREQkkb93GrZtBx8feLCJq0sjIiLJUZgXERERkUQWXWqVr38PBAerVV5ExB0pzIuIiIhIvNBQw7If7LYmvhMRcV8K8yIiIiIS77tlEBEBt5SEine4ujQiIpIShXkRERERAcAYE9/F/uEWDo6jlnkREXelMC8iIiIiAGzcBPsPQPbs0Ph/ri6NiIhciY+rCyAiIiIi/+HtTdT//oevry94e2fZbRcssq3yjRtBQIBa5UVE3JnCvIiIiIi7yZaN83PnEhwcDCEhWXLLf/81rPjNbmviOxER96du9iIiIiLCV0sgJsZOelfqFoV5ERF3pzAvIiIicoOLjjYs/sp2sW+hVnkREY+gMC8iIiKSxfbvN4x4L5YNG03yJ1y4QO6bb4YcOeDChUwvz8o/4OS/kDs31L87028nIiIZQGPmRURERLJIbKxhwSIYP9EQGQnff2+YNB5uSaZbuxMWlmXlWnhp4rsHm4Cfn1rmRUQ8gVrmRURERLLAyZOG5180jBptg3xgDrgYDi8PMoSGptBCnwV27TKsWw+OA80fUpAXEfEUapkXERGR60J0tOHs2Suf4zgQHAyOk7Wh9fsfDe99YDh/Hvz8oEc3h/saQJeuhkOHYchbhuFvg5dX1pVr7z7DJ7MNP/xgH99VEwoVUpgXEfEUCvMiIiLi0cLCDIsWw9zPDadOp37+XbVgxLCsCfTnztkQ/+PP9vHtt8Gglx2KF7f3fnsodOtp+GMVTJ9p6PR02st09qzhrWGGvfuhZnWofZfDnVXB3//K19i23TDr04Rl6ACqV4Pn+inIi4h4EoV5ERER8UihoYYvFsLn8w3nziXs97rCIMLYWPhjFSz51o4Pz0yr1xiGjTD8+y94e0H7J+GpJx18fBJCc5nSDi/2h6FvG6bPhDKlDfXqph6q9+03vDTQcPiIfbxoMSxabPD3h2p3Gmrf5VDnLsiXz17LGMP6DTDrU/s32F4K99SDdk843H6bgryIiKdRmBcRERGPEnLG8Pk8O5Fc3ETvNxeBJ9s5NGoIvr4pB9PZnxnGTzSMHW+oVRPy5c34EBsebu+xYJF9XLSobY0vVzb5e93fyGHH34b5X8CbbxumToRieVO+/qrVhteHGC5cgEIFoUsnhy1/GVb+DidOwMrfYeXvhpFAmTKGGtVg/UbYvt0+39sbGv8PnmiT0ENAREQ8j2OMcd2MK5kgJCTE1UVIs+DgYI8qr0gc1V3xRKq3nu/ffw1z5hq+/ArCw+2+W0raEN+gPnh7px5Mo6MNXXsY/t5pl2AbOiRj5wLe+pdh6DDDoUP28SMPQ/euDtmyXbls0dGGvs8bNv0JxYvB5PfDuenpx/H18SFk9mzInh1jDPPmw9gJhthYqFQRhg5xCM6d0Pq+e48N87//Ydi2HS7/Lc/PD5o9CK0fdyh4k0K8ZC595ooncqd6GxwcnOo5CvMu5E6VRSQ9VHfFE6neerZFXxo+HGuIirKPbytju6zXrZP+SeN2/WPo3NUQEwNvvelwT71rD7ZRUYYZHxtmfWq78ufPBwNfcqhRPe3XPn3a0OkZw8l/4e56MHSwQ968eQgJCSEqyo69//obe+6DTeD5fs4VeyGEhNix+Os3GgoVhEcedggOVoiXrKHPXPFE7lRvFebdnDtVFpH0UN0VT3Sj1dsl39qZ3Vs0g4AAzw5wGzbaVuvYWKh4hw3xNapf2wR2k6bGMusTyJsXPpnhEBR09dfas9e2xu/caR83agh9n3XIeRXX/Gubodez9kuLZzo7PNs7D3v2nubV1wx/brbzAfTs7vDYo1k/I79Ietxon7lyfXCnepuWMK8x8yIiIteZ3/8wDBtuv6ufOw+6dob7G2ftsmcZ5d9/7fjw2Fj7Gl4Z4GRIiO3wpMMvvxoOHoTxkwwv9U//NWNjDZ/Ph8lTDJFRkDMn9H/OoUH9qy9f+XIOzz0Lw981TJlmyJvnIjM+Nhw9BjlywBuvOdxV0/N+jiIikvEydqCYiIiIuFRoqGHEezbIZ88Gp07B28MNXboZ/tzsWZ3xoqMNg94whIRAqVLQv1/GBHmwy7fFBfivvrat/+lx9KihTz87kV5klF3u7uPp1xbk4zz0oMMjjS+wfOttNHmqKGeOXKBwYZg4TkFeREQSKMyLiIhcR8aMt0uh3XwzLJjn0KObQ44c8PdO6NnHMOiNWI4ezbhQHxNjiI7OnC8Jxk80bNlqW6TfGpz6JHLpVbmSQ4tmdnvEu4aIiNRfR0yMYdFiw1Od7GR12bPBi/0dRgxzMnRm/J7dHPLEnCJPzCkq3QFTJjiULKEgLyIiCRTmRURErhN/rDZ8861dP/zll+w48LatHT77xKH5Q3a89c+/wBPtDZOmxhIWdm0h3BjDy4MMjR4wTJgUy4ULGRfqf/zZdmEHeHWgw803Z06Q7d7VIX8+OHQYPppx5fJv3mJ7OLz7viEszI7fn/GRQ7MHM67HQBw/v4TrvfO2Q65cCvIiIpKYwryIiMh14Px5w4iRNow+9ihUvCMh/AUHO7zwvBcfTXG4sypERsGsT6BNO8Mfq68+gK/fYJdBi4yCT+dA63aGL78yxMRcW6jft9/wzgh7jSfaQL26mRdkc+RweL6fvf5nc+HvnUnLfvKkYcjQWHr0NuzcBYE54NneDmNGORQpnPkh28dHQV5ERJJSmBcR8SCRkZ415lmyzpjxdkmzm4tAl07Jh79bSzmMes/hnbccbi4Cp07DkKGG0NCrq1czPrbPq1kDihaFkBAY+Z6hYxfD2nVXd82wMMOrrxkuXoSqVVJ+LRmpbh2HBvdCTCwMH5kwbCAy0jDrU0PbJw3LfrA9Hh56EOZ86tDqESdN69qLiIhkFoV5EREPseRbw32NbcunyOVWrTYs+caGzYEvXXlsueM41K3j8PF0hxIlIDQUZn+W/jq1cZMdM+7rCy/1d/j4I4c+vRyCgmD3HujX3/DiwFgOHEj7tY0xDB9p2Lcf8uWDNwY5WdYq3be3LfvOXfDZ57Dyd8OTHQyTphguhkOF8jBlosNL/b0Izq0QLyIirqcwLyLiAWJiDDM+NhgDY8cbTp5UoE+Pv7YZ/twchTHX3/t2/rxhxLv2dT3aEipVTFvQ9PNz6NrZnvv5fLsEXHrEtco3bQIFCjj4+jo89qjD3E8dHn0EvL3h9z/gyacNo8bEpun68xfAjz/b5w553SFPnqwLzXnyOPTpae83aYrhpZcNh4/Ydehfe8VhwliH229TiBcREfehdeZFRDzA6jVw9KjdvnjRdqke8rqCRWqOn7BLh/38C8A5ypSGVo/AfQ0STzDmycZNMJw4CUUKwzOd0/ea6taBOyrAlq3w0UzDi8+n7fmbtxjWbwAfH2jXNvFzcuZ06NvboWVzw7iJhpW/w/wvYP4XhuBgQ6lbuPTHoVQpKFHcLhO3Zav9WQH07O4kGvOfVe5vDMt+gLXr7Gtr/Ri0b+cQEOCCuuLlRXSVKvh4e9uZC0VERP7DMddZM0VISIiri5BmwcHBHlVekTiqu1nv+RdjWb0GateCVWsgNhbeH+lQo/r1EUgzWmSkYe48mDnLEB5us5CvL0RE2OPBwdCiGbRo5pA3A5cTy2pr1hqee8H+Nz72Q4fKldL/Wv7cbOjZx+DtBbNmOBQrlvo1nnshljVr7fjxl/pfOWiuXWeYPM2wYwck9xuHlxcUvRnOnoUzZ+G+e+GN1zJ+dvi0OnfO8O1SqH0XFM2kGfTTQ5+34qlUd8UTuVO9DQ4OTvUchXkXcqfKIpIeqrtZ6+AhQ5t2BseBzz51+GKBXbLr5iIw8yMHf3/XBw53snqNYdQYw8GD9nHFO6Dfsw5lSufm40/OsHCRbckG2/p6XwNo9YjndaE+f97QvqPhxAnbvb5vn6tvvX1xYCy//wH174Ghg698nb+2Gbr2sOF/9idpn809PNywd58dT797t7n0N5w9l3BOieIweYKLWsLdlD5vxVOp7ooncqd6m5Ywr272IiJubuEi+53rXTWhSGGHTk/bNbgPHYY5c6FD+4y/56lThty58ajZuo8dM4weZ1i+wj7OEww9ujs0/p+d9C13bi+efMKhzePw6wqYN9+w9S9YugyWLjNUvMNQt45DyZJwS0kokB+XtQ6nxbiJNsgXLgxdu1xbObt2cfhjleGXX2H7DkPZ21O+3sxLY+UbNyJdy7Jly+ZQ9nYoezuAfZ4xhlOnbag/fATq1UFBXkREJI0U5kVE3FhYmOGbb+12y4dtyMmRw6FPT3h9iOHjWYb/3QdFimRcAFrxm+HlQYYmD8DAF90/WEVEGObMhVmfGiIiwNsLHmkJHTs4BAYmLb+Pj8N998J99zps32GYN9/w48+weYsdCx4nMAeULGnHeJcs6VDqFttynCuXa0N+ZKRdJu2rr+3jgS86ZM9+beUpdYtD40aG75bCxMmGUe8l/xp3/G34fZXtGv9ku2t/DxzHIV9eyJf3mi91/QkLI+ddd9k3e+VKCAhwdYlERMTNKMyLiLixZT/A+Qu2S32N6gn7G9wLXy2Bdeth1BjDiGEZEzCjogxjxttZ85d8Ay2aXbmV1tViYw0DXzWsWWsfV64Ezz3rcMstaStz2dsdXnvVoUc3w3fLYNcuw+69cPCAfd+3bLV/ICHke3tDrpyGXLkgd27i/86dC3LndihTmgyfvC0y0rBmHfz8i+G3lXDhgt3/yMNQpXLG3Kvz0w4//mQntlu7LnF9ixPXKv+/+9xjPPl1zRi848aKXF8jIkVEJIMozIuIuCljTHwX+5YtHLy8EsKT4zg81xee6mj4YxUs/w3uqXft9/zyKzhyJOHxuAmGMaPct7v54q9gzVrw94cBLzo0bHB1Zc2Xz6FdW4jr/h0ZaThwEPbshT17zKW/4dhxiImB0yH2T1L259WrB7R+7Nres8hIw9p18NN/ArwtLzT6H3TqkHE/l4IFHR5ubudjmDDJUO1OEtW5Xf8YVqy0a9m3z4BWeREREbk2CvMiIm7qz812srBs2eCB+5MeL1bUoW1rw8xZ8OEYQ/U7r2288YULhhkzbRht3w4++xw2/Qm/rYR6ddN3LWMMEyYbTp603cAzYxm4Y8fs0mcA3Z5x+N99GXcPPz+HW0vBraUgLuCD7dJ/7hycOWNnXj9z1s7CfvasIeSMXT5w9RoYO95OWPh4q/SX6fgJw7SP7Nj/8/8J8PfeA/fWd6hQPnHQzijt2zl8/Y1h1z92vff/3ZdwbOYs+143uBeKF1eYFxERcTWFeRERN/XFQhueGv0PgoKSD0/t2zks+8Fw9CjMmGXo0fXqQ9bszwxnzkLRona8ucEw6xPbSntXLTvWPK2++Q5mz7HbFcrb7uAZyRjD8HcNFy/a2eoz+vop8fd3yJ8f8uf/75GECd2mTTfM+BjGjLM/v/QE+g0bDa8NNpw5Yx/ny2dnmG+QiQH+crlzO7RtDVM/MkyZZqh/N/j6OuzZYyfHA3jqSQV5ERERd3D169iIyA3pOlvN0m2dPGlYvtxut2yRcnjy93fo29sen/s57Nl7dT+ff0/ZddkBunVx8PFxaNfGIXduOHAQFn+d9msdPmwYNTqhHB/PMoSHZ2y9+XqJHdft5wcDX3IyPeSmleM4dHraiV9hYMw4w9x5qb92Ywyfzzf0e94G+dK3wrjRDgs+d+jb24uKd2Tda3y8lV0J4MiRhJ/7zE/sa6h/N9xS0j3eaxERkRudwryIpNmatYb7Ghs+/uSiq4ty3fvyK0NMrJ3Q7dZSVw5PdWo71Ktjx3K/P8pc1RcuH80whIfbVvS7L429z5HDoeOlMdkfzTBcuJD6daOjDW++bVvMK1WEQoXg1Gn4YmG6i5Si4yfsJH0Az3R23G4itrhA/9ST9vGYcYbPrxDoIyIMQ4cZRo+1P/NGDWHCWIdKFV3zJUX27A4dnrL3nfGxYccOw08/22NqlRcREXEfCvMikmZz5hoiI+G9D8LYuUst9JklKsqw+Cu7HbccXWqe7e3g72/HuC/7Pn3327/fsGSJ3e7e1Uk0gVyzB6FYUTtG/JM5qf/MP5kNW/+CHDlg0MsJXwZ8Osdw/vy11xljDCPeNYSF2S8eWj1yzZfMFI7j0LljQqAfnUKgP3bM0L23Yekyu6Ren14Og15xyJbNtaG52YNQpDCEhEC/F+zqBvXqQOnSCvNZxnGIue02KFfOzjooIiLyHwrzIpIm//5rl6wCiI6Gt4YZIiMV6DPDL8vtTOn58sHdaZx4rmBBhw7t7S/8YycYjp9I+89m4hTbIly3DlSqmDg0+Pg4dO+a0I3/Stf9a5th+gx7/Pm+DgULOjRqaNdmP3eONHU3T80339kJ5vx87cR63t7uG3KSDfTzE96DDRsNnbsadu60y9p98J7DY486brFygI+PQ5dOthyhoXbfU+1dX64bSkAA5/74A/76S2vMi4hIshTmRSRNvv8RYmPt7N55gh1274HpH1//YX7XLkP3XrF89vnVdV+/GgsuTXzX/CEnXZPOtX4MSpSwrandehj+2Z16eTdvMaz4Dby8oGuX5O9Vt47t7h8ZCVOmJX/NsDDDm2/ZLwXuawD/a2j3e3vbLucAc+fZWd+v1smThjFj7fM7dXQ8Ykb1uEDfvp19PHqsDfSfz7s0Pv4slCkDUyc7VK3iXq+nwb22bAC1a8Htt7lX+URERG50CvMikibLvrchqkUzh0Gv5gDg09mwbfv1G+gjIgxvvGnYstUuNTZ4aMZP5PZff++09/PxsV2d08PX1+Hd4Q4lSsDJf6FHb8PadSmX1xjD+EtLuzV9AEqWSD6sOY5Dz+722NJlJDvEYsx4w6HDUCA/PN8vcevyPXdDmdIQFma7218NYwwj3zOcvwBly9pJ2jyF49hW7ssD/ehx9ouP+xvDhDEOBW9yv6Ds5eUw6GWHJg9A32fdr3wiIiI3OoV5EUnVnj123WkfH7i3PjRq6E/D+2xL/VvDDBER12eg/2iGYf8BCAoCb2/44Ufo0Sd9XdjTa8GiS7OG3wN586Y/QBW8yWH8GIfKlWx47v+S4dvvki/v8t/s+HZ/f+Jbz1NS9naHhveBMTBuQuJeCit+M3z1tR3W++rLDjn/s4yel1dCl+35C+yQjfRa+j38vgp8feHll9LXY8Ed/DfQe3vZeQ5eGeDg7+++r6VkCYeXX/KicCH3LeN1KyyMnHfdBeXL23/MIiIi/6EwLyKpWnqpVf6uWpArl/2l/rlnHfLmgf0HUu567WrGXP0XDdt3GObMtdsvv+TwwbsOuXPBzp3Quath85b0XTc6OvWynD1r+P4Hu/1IGie+S07OIIf3R9rwHRMDb71jmPFx4gAeHW2YNNk+fqwV5MuX+v26dnbw9YX1G2DVarvv1CnD8JH2Oq0fI8Wu4rVqwh0VbFf9uGXO0urfUwlL3XXs4KTYg8DdxQX6EcMcpk52aPWIe4yPFzdlDN5//w3bttlv0URERP5DYV5Erig2NiFgNv5fQvDImdPhxf4JY6H/3Oxev2zu2GFo95SheUuT7rJFRhrefscQGwsN74N6de145ikTHUqVsmPS+/QzfPX1la9rjGHH34b3RsXyYAtDw/sN7Z6KZchQOwZ/w8bEM7wv+daG3dK32pnar4Wfn8Nrrzi0a2sfT/3Ihu7oaHu/r7+x68fnyglPtE5boCxUyImfPX7cRHutYSPsuO9SpYhvfU9OXJAF+OprOHo0bT8TYwzvvm84fx5uKwNtHk/T09yW4zjUvsuh9K0K8SIiInJtfFxdABFxb5v+hBMnITDQtsxfrk5thyb3G775Dt5+xzBjml2j2pViYgyfzLZd5GNi7L4XBxrGjkr7slozZxn27oPgYOjbO+E5hQo5TBxrW7p/+RWGv2vY9Y+hT6/E3b5DzhiWfQ/ffGvYvSfxtfftt3+W/ZAQZosUNpQpA1u22sePPJwxLbZeXg7dnnG46SbDBx8avv4GTv5rePkl4medf6q9Q2Bg2u/15BMOX39j2LcPnn/RrnDg5wuvv+Lg53fl61St4lDtTsO69TB9puHlAVc+PyrKMG264beVdojHywM8r3u9iIiISGZRy7yIXNF3y2zou7c+yY7t7dPLoUB+OHwEJk5OvbU1rrX6wIGMb8k/ctTQ61nDlGk2yNe/ByreARcu2OB56FDq9/x7p+GTT+32830dcudO/JqzZ3d48w07QznAgkXw3AuGU6cMv/1ueHlQLC0eMYwZZ4O8n69t3f/gXYdFXziMHG5bqO+uBwVvstc8fAR+/gX+/deOz294Xwa+KcDDzR3eHuqQLZtd1q1te8Op01CoELRolr5rBQUlLIEXt1Rht64Ot9yStpD9TGd73nfL7Pr2Kdm9x9C1h/1iBqBzR4dSabyHiIiIyI1ALfOSIY6fMCxabGjYQL9wX08iImwLNMD9jZL/uQYGOgx40QbaLxbC3fUMd1ZNeu6Ro7a1+rtlhkOHbMgdPzZjlrsyxvDdUvhgtCEszC7J3O9Zh/sbwfnz0Luv4Z/d0K+/YfwYyJ8/+XtGRRneHm5nGb+3PtS/J+XZ3Tu0h1K3wJC3DBs2QotHTaJhrWVvh6YPONzXwAbgOPnywl01Aey+s2cNO3fBzl2wd5+h/j0O2bJl/L+hurUdxoyyvRRCQuy+Zzqn3pqenIebwxcL7JcQ1avBoy3T/txyZR3q1rGt7VOnG958I/H9Y2LsXAXTphuioiBnTvulyn0N9LkiIiIicjnHZNXCyVkkJO63VA8QHBzsUeVNiTGGnn0Mm7fYrrAd2ttxuuoOm3ViYgwHDkKJ4mTohFo//mx4fbCh4E3w+RwHLy977eTq7sj3YvnyK9vaPPMjhxw5HM6fN/z8i51Ab9OfSa9fqCBMm+yQM+fVl/nsWcPI9xO+dLijAgx6xUk0+/bp04Yeve3SaSVLwLjRyd/zoxmGj2YYcueCWTMcgoNTL9eevYaBrxgOH4HcuaFxI2h6f9pbqrPa4SOGYcMN+fPDoJcTfqbp9fdOw3dLDe3bpe19utw/uw1Pd7Zffnw0xaHMpeEPBw4a3hpm+GubPa/2XfBSf+eqZvVPzvXymSs3iAsXCC5aFICQgwchRw4XF0gkffSZK57IneptcHBwqucozLuQO1WWa/HLr4ZXXzc4TsKEu6VvtTOAp3WMsly92FjDK4MMK1baLtP/XeP7Wrw4MJbf/4D27eCZzgmjcpKru2Fhhqc6Go4eg3p1bcv7ipV2Qjewy5ZVrQL3N3aoWgV6PWs4ehRq14J33r66ULl2neGtdwz//muXjuvc0aFta/D2Tnqto0cN3Xvbc8uVhVHvOQQEJJy36x9D5662e/7g19LXEhwWZpfuK19OX2Kl1etDYvnxp4Sf/4JFMGGSISLCZpZnezk8cH/Gfjl1vXzmyg3i0tJ03l5ehKxcabsciXgQfeaKJ3Kneqsw7+ayorL8utyweq2hSyeH4NwZHzIiIw3tOhiOHIEO7aFYMYdRow3nztlw1b4dtG/n4OurgJNZZn9mGD8x4Z/x462gV49rD/QhZwwtHrHh9tOZDsWLJ1wvpbq7YaOhT7/EHyklStgu+o0aQoECCdfYucvQrYchMsrOgv7Uk2kvrzGG6TNtSzpAsaLw2qtOql329+y1Y+rPnbPdw4e/bbuZR0cbnuluu7vfXQ/eGqIlwzLbgYOGJ5+yQxpuvw12/G3331kVBr7kUPCmjH//3ek/aJG0Ur0VT6W6K57IneptWsK8JsC7js3+zPDKa4bFX8G772fOdzZfLIQjRyBvXmjb2qFRQ4dPZjjcc7dd33r6TOjczfD3zuvqOyO3sXlLwlrh99a3++bOs8uQXauffrI/w9tvI1GQv5KqVezkbjcXgccetV3oZ013aNfWSRTkAcqUdniun9039SPD2nVpK3NMjOG9D0x8kG/R3HbVTsvY+1tKOox8xyF7Nli7Dt582xATY/h0jh2zHjc+W0E+8xUralvewQb5bNngub4OH7ybOUFeRERE5HqjMH8dio01jB0fm6i19tfltjt8RjpzxjDzY3vNZzondFnOk8dh6GCHwa875M4Fu3fDM90Mk6fGEhmpUJ9Rzpyx49ljYuF/DWHI6w79nrU/g5mzYNan1/ZeL/3ePr/R/9IXrJ560uGzT73o08uL28pcORg/2MThwSZ2eMbgNw3HT1y5zJGRhteHGBYttt32n+/n0L+fV7omjCtfzs7s7uNjZ5Af9IZhxqV63Ld3xo3PltQ93cHh5ptta/yMqQ4tW1z9GH4RERGRG43C/HUmOtqOIf7sc/u4Rzc76zbA+6MM585lXJie8bHh/AU7Pv7+RomPOY7Dffc6zJrp0OBeiImFjz+Bzl0NJ09efRlOnTKMnxjLn5sz90uB0FDb8rtuvXt++RAba3jzbcPJf20X8xees6H5kYcdenSzYWjSFMPn86+u/AcOGrZtB28vaNggI0ueVL9nHUrfCmfOwmtvGKKiki/zhQuG/i/Zie58fWHw6w4PN7+64Fe9msPrrzp4ecHyFRAVBXVq2y9FJOvcVMDhs0+8+PB9L26+WSFeJJGLFwm67z6oXh0uXnR1aURExA0pzF9HLl40DHjFsHSZDWGvDHRo29qhfTuHEsXhdAiMHZ8x4XT/fsPCRXa7Vw8n2QnHAIJzOwx53Yuhgx2Cg2HPXuj7vCHkTPrLEXLG8OzzhtmfQZ9+hi+/ypygvWOHoeMzNswPfNVw5irKmtk+nWPXC/fzgyFvJJ7IrW1rh6efstujxxoWf53+8n//g31O9eq2p0Vm8vd3GDrEITAQ/toG4yYkLe/p04befe0ScNmzw7vDHRrUv7Zy3Vvfof9z9hqBgQlfiIiIuIXYWHw2boR16yA21tWlERERN6Qwf504c8bw7HOGVavB39/ODv1AYxtM/PwcBrzo4DjwzXewes21h9Pxk2z37rp1SHZN8f+qf4/DlAkOBfLD/gPw/AuG0NC0l+PcOUO/5w379tlZ0mNiYOR7hjHjYomJyZiwbYxh/gJDt152lnWwjSGfzHavML/pT8OUabZMzz3rcGuppO9/xw4ObR632yPfMyxdlvbXYIxh6fd2u3EKa8tntCKFHV592d5r/gL4/seE8h45apeV27nLLv02ZpSTpjqXFs0edJg22WHGNId8+RTkRURERMRzKMxfB44ds2Fn23Y7gdeH7zvcVStxMKlQ3qHVI3Z7xHuGsLCrD6jr1htW/m5nq+/RNe0BqGBBh1Hv2xb6nbvgxYGGixdTL8f584bnXjD8sxvyBMOMaQ6dO9r7zp0HA1+5ttcTd49BrxtGjTZER9sZzd8YZO+xYCGcSGUsd1YJCbFjxmNjL61n3iT58xzHdrd/uIUdj/72OybNcyZs/ctOapg9O9Srk3FlT03d2g5PtrPbw0ca9uw17PrH0L2nXR++UEGYMDZtE92lx21lNOGaiIiIiHgehXkPt2ePoXsvw4GDUKAAjB/jUKF88sGkSyeHQgXh+HGYPPXqwmlMjInvqv9wC7sUXXoUK+rw/kjbpXrLVhj4qiEiIuWyhIUZXhhg2PE35M4Fo953KFbMoUN7O8Genx/8vgq69zIcO3Z1r2nH37Zb/S/LwccH+vRyeGuIw30NoFJFiIyCmbMyL8wv+97wxYLUJ3+LiTEMectw6hSUKA79U1lP3nEc+vVxaHK/nbPgjTcNv/+R+uuIm/iu/t2ka2K5jND5aYc7q0J4OAx4xS4jd+o0lCoFE8Y5FNW4ahERERERQGHeo23YaOjRx06CVqIETBzrUOIKS4hlz+7wYn97/IuFdlmz9Pp2Kfyz244xfrr91QWr0rc6vDvcLg+2bj28McQQHZ20LOHhhpdeNmzZau/3wbsOt5RMuOd99zqM/dAhbx7YvQe6dDds/St93cm/WGC/DDlyxLb8jh/j8NijNiQ7jsMzne39vv4GDh3K+ED/xUIb0D8YbXjkMcMz3WOZ/ZnhyNGk95r1qV1OLVs2O04+e/bU338vL4eXXnC4716Ijra9IZ59LpbvliXfKyIqyvDTz3Y7vbPYZwRvb4c3Bjnkz2d7B1y4YL9QGTvKIZ9mmRcRERERiacw76EWfWno199w/jzcUQHGj066jndyqldzaHppKbDhI6/cKv5fYWGGKZda9Du0d8iV6+rDVYXyDu+87eDnCytWwlvvGGJjE8oSEWF4eZBh4yYICLBBvnTppPcrV9Zh8kSHW0tBSAj06Wv44cfUX9PZs4ZBb9gQHRUF9erCtCkO5comvkelig61atox+nHrmmeUVasNH46x1yxZwi61tm07jJ9oeKyNoeMzsXz8ieHAAcOGjQnrqj/fN/GXGqnx9nYY9IpD40srDqzfAEPfNjR/xPDOCLsygDHmUpng3DnIlw+qVsnQl5tmwcEObw52yJsXGt4H7490CApSkBcRERERuZxj4n6LdzObN29mzJgxbNq0iaioKG699VaeeuopHnrooSs+LyQkJItKeO2Cg4PTXd7oaMOHYxNmkv9fQxjwgoO/f9rDzrlQw5NP2e7LT7aDrp3T9p3O1I9imfExFCkMs2Y4+Plde8Ba+bsN7TEx0Pwh6P+cQ3Q0vPq6HZefPRu8N9Kh4h1XvldYmG3h/m2lfdzmcTup2qnThpAQO5P/6dP275DTcDHcnufjY5fva/UIKXZZ/3unodMzBsex4/VL3XLtr3v3peERYWHQ5AEY+KLDqdOw4jf45Vf7Jcblkxf7+NiW9SYPwMsvXf13cEeP2sntvvnO9kaIc3MRuL+xw+YthjVr7fvXs3vK97mauptexhjNLi8ZKivqrUiGuXCBXJUr4+U4hGzcCDlyuLpEIumiz1zxRO5Ub4ODg1M9xy3D/OrVq+nUqRO+vr40bdqUoKAgli1bxqFDh+jXrx/dunVL8bnu8uanZtSYWNat86J5M0OzB0lTGI9rTd6w0bbiPtPZoV3blEPolfy6wvDKIIO3F0ydlHyr9+VOnDC0edIQEQFvDXG45+6MC1k//mR4402DMdD6MTh2DH5Zbpdde3e4Q9UqabtXTIxh0hS7dF1aFCsKr76ctDU+OYPeiOXnX+yEcMPeurYOLadOGZ7pYTh+HKpUti3Pvr6JyxByxvDbb/Dzr4b1G2zPgFtKwuQJToaMYzfG8OdmG+p//jnhy40406c6lL415fu40wedSFqp3oonUr0VT6W6K57IneqtR4b56OhoHnjgAY4dO8bcuXMpV64cAOfPn6d169bs3buXJUuWUKJEiWSf7y5vfmpefS2WX5bb7bx54Im2Ds0fSjnU79lr15CPm2X89UEOdWtfW6h79fVYfvkVypS2IdHHJ/nrxcYa3nrHrl9fqSKM/TDj1+P+eonhnZEJVdHXF4YNdahVM/33WbrM8M13hoDskCeP/RMcbMfWBwfbGfHz5LHvY1pfx/79hieftrPITxrvUL7c1b3+8HBD736G7duhaFGYNM4hZ84rX+tcqGHzZjuc4lqGNqQkLMzw6wr45lvbI6ByJRj74ZW/sHCnDzqRtFK9FU+keiueSnVXPJE71VuPDPO//fYbnTp1omXLlgwbNizRsW+++YZ+/frRtWtXnnvuuWSf7y5vfmoiIw2/Lg9g4pQLHD9u9+XNA23b2FB/eevryt8Ng4faLtmFC8M7b6VvzHRKTp82PPGUITQUWjSzM82fDjGcPg2nTid0Sz8TYmdDB5g60eH22zOn6/Pn8wyjxxm8vW3rf9067tXF+u3hsXzzLdxZFT58P/2t87GxhtcGG3751S4hOHm8w81uNjv72bOGbNlS7yniTh90ImmleiueSPVWPJXqrngid6q3aQnzPllQjnRZs2YNAHXr1k1yrE6dOonO8WR+fg6PtcpG/XvC+OY7mPWJ4dhxGDPO8OlsaNvGjiH/YiFMmmK7oFepDG++4ZA7d8YEwDx5HPr0greGGRYtBkj5ex3HgcceJdOCPMBjrRxKlrRB97Yy7hVyATo+5bDse9vtfd16Q7U701fGyVNtkPfxsb0O3C3IQ+a0/IuIyFW4eJHAxx6z/2nMnm27k4mIiFzG7cL8vn37AChevHiSY7ly5SI4OJj9+/dncakyj6+vbYlvcj98txQ+/sRw9BiMHW+Y9lHCWOYWzaBvn5S7wl+t+xvBnj2wfYftGWC7pTvx3dPz5rHd0nPnJsPvnZzq1dw3TBYs6NCimWH+AhvM76ya9m76X39j+GS23R7wokOliu77OkVExA3ExuK7cmX8toiIyH+5XZg/f/48AEFBQckeDwwM5NixYyk+P1euXHh5ec6Ke5d3n2j/JLRpbVj8VQSTp17k0OFYvL3h5QE5aP1Ytkwrw6svZ9qlrzu9esay5JsQtm2HTZsDaVDfL9XnrF4TxbvvnwOg2zPZafN4QGYXM0ukpeuPiLtRvRWP4Zfw/0twcLBmsxePpM9c8USeVG/dLsxfq7Nnz7q6CGmW0piMBvfC3fUMv610KFgQbr/tIiEhF11QQvkvH2949BGY9Sl8MCqUSnc4eHkl38pujGHH39CvvyE62q6Z/kSbcEJCIrK41BnPncYTiaSV6q14lAsXiPt1MiQkBCIjXVockfTSZ654Ineqtx45Zj4wMBCA0NDQZI+fP38+xVb764mPj0P9e1xdCklOm9YOCxcZ9uyFH36CRg0TjoWEGNauh3XrDOvWw4mTdn+F8nYtea2bLiIiIiIiGcHtwnzcknP79++nQoUKiY6dPXuWkJAQqlSp4oKSiVg5gxzatrHj5qd9ZMgZZCfEW7sedu9OfK6vL9SoDgNecFKdIV5ERERERCSt3C7MV69enUmTJvHbb7/RtGnTRMdWXpoIpkaNGq4omki8R1vCvC/g8BHo/1LiVQBK3wrV7rST+VW8I/EygyIiIiIiIhnB7cL8XXfdRdGiRfn6669p3749ZcuWBWz3+vHjx+Pj48PDDz/s4lLKjS4gwKHbMzBsuKFAAaheDard6VCtKgQHK7yLiMi1MwEB6H8UERFJiduFeR8fH4YOHUrnzp1p27YtDz74IIGBgSxbtoxDhw7Rt29fSpYs6epiitD0AYcG9SFbtrQvUSciIpImOXJw5tAhOwGSm0zGJCIi7sXtwjxArVq1mD17NqNHj+bbb78lKiqKW2+9lWeffZZmzZq5ungi8bJnV4gXEREREZGs55ZhHqBixYpMnTrV1cUQERERERERcTteri6AiIiIiPxHeDiBjz8OTZtCeLirSyMiIm7IbVvmRURERG5YMTH4fv99/LaIiMh/qWVeRERERERExMMozIuIiIiIiIh4GIV5EREREREREQ+jMC8iIiIiIiLiYRTmRURERERERDyMwryIiIiIiIiIh3GMMcbVhRARERERERGRtFPLvIiIiIiIiIiHUZgXERERERER8TAK8yIiIiIiIiIeRmFeRERERERExMMozIuIiIiIiIh4GIV5EREREREREQ/j4+oC3Gg2b97MmDFj2LRpE1FRUdx666089dRTPPTQQ64umtzgjh8/zrfffsvy5cvZs2cP//77L7ly5aJq1ap07tyZSpUqJXnO+fPnGTNmDMuWLePkyZPkz5+fRo0a0bt3bwIDA13wKkRgypQpvPvuuwDMnTuXypUrJzlHdVfcxffff8/s2bPZtm0bFy9eJF++fFSuXJkXXniBQoUKxZ+nOivuwhjD999/z6xZs9i7dy+hoaEULFiQmjVr0qVLF4oWLZrofNVdyUpffvkl69evZ+vWrezcuZOoqCiGDRtGy5Ytkz3/aurnV199xcyZM/nnn3/w9fWlcuXK9OnThzvuuCMzX1qytM58Flq9ejWdOnXC19eXpk2bEhQUxLJlyzh06BD9+vWjW7duri6i3MDeffddpkyZQrFixahevTp58+Zl//79/PDDDxhjeO+992jSpEn8+WFhYbRt25bt27dTp04dypUrx44dO1ixYgVly5Zl9uzZBAQEuPAVyY1o9+7dtGjRAh8fH8LCwpIN86q74g6MMbz++uvMnTuXYsWKUbduXXLkyMGJEydYu3YtI0eOpFq1aoDqrLiXd955h+nTp5M/f37uu+8+AgMD2bFjBytXriQgIIDPPvuMMmXKAKq7kvUaNGjA4cOHCQ4OJiAggMOHD6cY5q+mfk6cOJEPPviAwoUL07hxY8LCwliyZAkRERFMmzaNmjVrZtVLtYxkiaioKNOwYUNToUIF89dff8XvDw0NNU2bNjXlypUze/fudV0B5Ya3dOlSs3bt2iT7165da8qXL29q1KhhIiIi4vd/+OGHpkyZMmbEiBGJzo/b/+GHH2Z6mUUuFx0dbR555BHz6KOPmv79+5syZcqYjRs3JjlPdVfcwcyZM02ZMmXM4MGDTXR0dJLjUVFR8duqs+IuTpw4YW6//XZz7733mtDQ0ETHpk+fbsqUKWMGDBgQv091V7LaypUrzaFDh4wxxkyaNMmUKVPGfPHFF8mem976uXfvXlOuXDnTqFEjc+7cufj9O3fuNJUqVTINGzZM9NmdFTRmPousWrWKAwcO8OCDD1KuXLn4/YGBgfTo0YPo6GgWLFjgwhLKja5Ro0bxrUCXq1atGjVr1uTMmTP8/fffgG1RmjdvHgEBAfTs2TPR+V27diVXrlzMnz8fo44/koWmTJnCjh07ePvtt/H29k72HNVdcQfh4eGMGzeOokWL8vLLLydbX3187EhI1VlxJ4cPHyY2NpaqVasm6YJcv359AE6fPg2o7opr1K5dmyJFiqR63tXUzwULFhAdHU337t0JCgqK31+6dGmaN2/OgQMHWLVqVca9mDRQmM8ia9asAaBu3bpJjtWpUyfROSLuJu6Xyri/9+3bx4kTJ6hatWqS7kf+/v5Uq1aN48ePs3///iwvq9yYdu7cydixY+nevTulS5dO8TzVXXEHK1eu5MyZMzRs2JDY2FiWLVvG5MmTmTNnTpK6pzor7qR48eL4+vqyYcMGzp8/n+jYr7/+CkCtWrUA1V1xb1dTP+OyWlx2u1y9evUAWLt2bSaWOilNgJdF9u3bB9gPwf/KlSsXwcHB+jATt3TkyBF+//138ufPHz8GLq6ulihRItnnxNXz/fv3p3iOSEaJjo5mwIABlCpVimeeeeaK56ruijvYunUrAN7e3jRr1oy9e/fGH/Py8qJDhw689NJLgOqsuJfg4GD69evHiBEjaNKkCQ0aNCBHjhzs3LmTP/74g8cff5x27doBqrvi3q6mfu7bt4+AgADy58+f4vlxmS+rKMxnkbhvLy/vknG5wMBAjh07lpVFEklVVFQUL774IpGRkfTv3z++K2hoaChAirN8xu2PO08kM02cOJG///6bzz//HF9f3yueq7or7uDUqVMATJ8+nXLlyjFv3jxKlSrF9u3bGTRoEB999BFFixalbdu2qrPidjp16kSBAgV47bXXmDNnTvz+KlWq0KxZs/jPYdVdcWdXUz/Pnz9Pnjx5rnj+f3usZDZ1sxeRZMXGxvLyyy+zdu1aHnvsMVq0aOHqIokksWPHDiZOnEjHjh0pX768q4sjkiZxYzB9fX0ZN24cFStWJEeOHFSrVo3Ro0fj5eXF9OnTXVxKkeSNHz+egQMH0rVrV3799Vc2btzI7NmziYmJoX379ixbtszVRRS5YSjMZ5HUvn08f/58iq32IlnNGMOrr77K4sWLadasGYMHD050PK6upvTtY2o9UUQyyksvvUTRokXp3bt3ms5X3RV3EPc7QYUKFbjpppsSHStdujRFixblwIEDnDt3TnVW3Moff/zBhx9+yBNPPEG3bt0oWLAgAQEB3HnnnUyaNAl/f3+GDRsG6PNW3NvV1M/AwMArZrm4c7KSutlnkbixFvv376dChQqJjp09e5aQkBCqVKnigpKJJBYbG8srr7zCggULePDBB3nnnXfw8kr8vV9q44LixiElN0eESEbasWMHAHfccUeyxx9//HEAxo0bR8OGDVV3xS3ccsstQMohJm5/eHi46qy4lbhJ7pJbSztPnjzcdtttbNy4kdOnT6vuilu7mvpZokQJNm7cyMmTJ5OMm09tDH5mUZjPItWrV2fSpEn89ttvNG3aNNGxlStXAlCjRg1XFE0k3uVBvkmTJowYMSLZJZNKlChBgQIF2LBhA2FhYYlmAY2IiGDdunUUKFBA/0FLpnv00UeT3b9u3Tr27dtHgwYNyJMnT/wyNaq74g7igtCePXuSHIuKiuLAgQMEBASQJ08e8ufPrzorbiMqKgpIWH7uv+L2+/n56fNW3NrV1M/q1auzceNGVq5cmWT46YoVK+LPyUrqZp9F7rrrLooWLcrXX3/N9u3b4/efP3+e8ePH4+Pjw8MPP+zCEsqN7vIgf//99zNy5MgU1+p2HIdWrVoRFhbGuHHjEh2bNGkSZ8+epVWrVjiOkxVFlxvYW2+9leyfuJ5OXbt25a233qJs2bKA6q64h2LFilG3bl3279/PvHnzEh2bPHky586do2HDhvj4+KjOilupWrUqADNmzEjS3XjhwoXs37+f8uXLExgYqLorbu1q6mfLli3x8fFhwoQJier/rl27+PLLLylWrFj80oxZxTFxs7BIplu1ahWdO3fG19eXBx98kMDAQJYtW8ahQ4fo27cv3bt3d3UR5QY2ZswYxo4dS0BAAO3bt49fU/5yDRs2jA9FYWFhtG3blu3bt1OnTh3Kly/Pjh07WL58OWXLlmX27NlJ1u0UySoDBgxg4cKFzJ07l8qVKyc6pror7uDAgQO0bt2aU6dOUb9+fW655Ra2bdvGqlWrKFKkCHPnzo3vxqk6K+4iJiaGDh06sGbNGvLkyUODBg3ImTMnf//9NytXrsTPz4/p06dTrVo1QHVXst68efNYv349ADt37uSvv/6iatWq8S3sDRs2pGHDhsDV1c8JEyYwatQoChcuTOPGjQkLC2PJkiVEREQwdepUhfnr3ebNmxk9ejSbNm0iKiqKW2+9laeeeopmzZq5umhyg4sLP1cybNgwWrZsGf84NDSUsWPHsnTpUv7991/y5ctH48aN6dWrlya0EZe6UpgH1V1xD0ePHmX06NGsWLGCM2fOkC9fPho0aEDPnj3JmzdvonNVZ8VdREZGMnPmTL799lv27NlDVFQUefPmpXr16nTt2pUyZcokOl91V7JSar/P9urVK9GkuVdTPxcvXszMmTP5559/8PX1pXLlyvTp04eKFStm+OtJjcK8iIiIiIiIiIfRmHkRERERERERD6MwLyIiIiIiIuJhFOZFREREREREPIzCvIiIiIiIiIiHUZgXERERERER8TAK8yIiIiIiIiIeRmFeRERERERExMMozIuIiIiIiIh4GIV5EREREREREQ+jMC8iIiIiIiLiYRTmRURERERERDyMwryIiIiIiIiIh/k/MtdeWGZJJPgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate the data ...\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "n = 100\n", + "intervention_point = 60\n", + "time = np.arange(n)\n", + "\n", + "pre_trend = 0.5 * time[:intervention_point] + np.random.normal(\n", + " scale=5, size=intervention_point\n", + ")\n", + "post_trend = (\n", + " 0.5 * time[intervention_point]\n", + " + 3.0 * (time[intervention_point:] - time[intervention_point])\n", + " + np.random.normal(scale=5, size=n - intervention_point)\n", + ")\n", + "\n", + "synthetic_series = np.concatenate([pre_trend, post_trend])\n", + "\n", + "# Create DataFrame\n", + "df = pd.DataFrame({\"time\": time, \"y\": synthetic_series})\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(df[\"time\"], df[\"y\"])\n", + "plt.axvline(\n", + " x=intervention_point, color=\"red\", linestyle=\"--\", label=\"True treatment time\"\n", + ")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compared to the previous example, the only change is that we use ``\"trend\"`` instead of ``\"level\"`` for the ``treatment_effect_type``, to model a change in slope rather than a level shift." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, trend, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, tau_un, trend, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"trend\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + time\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 3 : Impulse\n", + "\n", + "In this final example, we'll demonstrate how to apply the InterventionTimeEstimator model to data that display an impulse-like effect. Here how it works under the hood :\n", + "\n", + "$$\n", + "\\begin{align}\n", + "A &\\sim \\mathcal{N}(0, 5) \\\\\n", + "\\lambda &\\sim \\text{HalfNormal}(0, 5) \\\\\n", + "\\mu_{\\text{impulse}} &= \\sigma(t) \\cdot A e^{- \\lambda (\\text{time} - t)} \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{impulse}}, \\sigma)\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate data ...\n", + "\n", + "np.random.seed(42)\n", + "n = 100\n", + "t = np.arange(n)\n", + "\n", + "intercept = 2\n", + "trend = intercept\n", + "\n", + "# Impulse parameters\n", + "t0 = 50\n", + "A = 5\n", + "decay_rate = 0.1\n", + "impulse = np.zeros(n)\n", + "impulse[t0:] = A * np.exp(-decay_rate * (t[t0:] - t0))\n", + "\n", + "# Bruit\n", + "noise = np.random.normal(0, 0.5, size=n)\n", + "\n", + "# Série finale\n", + "y = trend + impulse + noise\n", + "\n", + "df = pd.DataFrame({\"y\": y, \"time\": t})\n", + "\n", + "# Plot ...\n", + "\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(t, y, color=\"royalblue\")\n", + "plt.axvline(t0, color=\"red\", linestyle=\":\", label=\"True treatment time\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember to set ``treatment_effect_type`` to ``\"impulse\"``." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, impulse_amplitude, impulse_decay_rate, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, impulse_amplitude, impulse_decay_rate, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"impulse\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + time\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Narrowing the Inference Window\n", + "\n", + "Instead of specifying a treatment_time, you can constrain the inference window by passing a time_range=(start, end) argument, where start and end correspond to the row indices or timestamps of your dataframe:\n", + "\n", + "- `time_range=(80,100)`\n", + "\n", + "or\n", + "\n", + "- `time_range=(pd.to_datetime(\"2016-01-31\"),pd.to_datetime(\"2018-01-31\"))`\n", + "\n", + "This can significantly improve inference speed and robustness, especially when dealing with long or noisy time series.\n", + "\n", + ":::{tip}\n", + "If you’re unsure about the intervention period, try starting with ``time_range=None`` and inspect the posterior.\n", + ":::\n", + "\n", + "Keeping the same example, if we now increase the noise in the data and reduce the level change, the advantage of using a restricted time_range becomes evident:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Making the example\n", + "\n", + "n = 100\n", + "tau_true = 40\n", + "x = np.arange(n)\n", + "y = np.where(x >= tau_true, 1.60, 0.0) + np.random.normal(1, 1.30, size=n)\n", + "df = pd.DataFrame({\"t\": x, \"y\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "The rhat statistic is larger than 1.01 for some parameters. This indicates problems during sampling. See https://arxiv.org/abs/1903.08008 for details\n", + "The effective sample size per chain is smaller than 100 for some parameters. A higher number is needed for reliable rhat and ess computation. See https://arxiv.org/abs/1903.08008 for details\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "# First run: unconstrained treatment time — the model scans the entire time axis.\n", + "# With noisy data, this leads to a wide posterior and uncertain inference.\n", + "\n", + "model1 = LinearChangePointDetection(\n", + " cp_effect_type=\"level\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result1 = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model1,\n", + ")\n", + "\n", + "# Second run: constrain the treatment time to a plausible window (t in [20, 60]).\n", + "# This narrows the posterior, improves inference stability, and speeds up sampling.\n", + "\n", + "model2 = LinearChangePointDetection(\n", + " cp_effect_type=\"level\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result2 = ChangePointDetection(\n", + " data=df,\n", + " time_range=(20, 60),\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model2,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we’ve increased the noise, we can already observe issues with sampling. The warning “_The rhat statistic is larger than 1.01 for some parameters_” indicates convergence problems: the model struggles to infer from the data, and the parameters fail to stabilize around their true values. In contrast, the model with a fixed time range does not trigger such warnings.\n", + "\n", + "Looking at the forest plot, the difference becomes even clearer. The model with a given time range not only recovers the true treatment time more reliably, but it also does so with substantially less uncertainty. While the unconstrained model isn't even centered near the correct value, its wide intervals and convergence issues mean that we cannot trust its estimates." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_forest(\n", + " [result1.idata, result2.idata],\n", + " var_names=[\"change_point\"],\n", + " model_names=[\"Model without time range\", \"Model with time range\"],\n", + " combined=True,\n", + " hdi_prob=0.95,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Specifying the effect\n", + "\n", + "The effects also can be specified using a dictionary passed to the `treatment_effect_param` arguments :\n", + "\n", + "```\n", + "model = InterventionTimeEstimator(\n", + " treatment_effect_type=[\"level\", \"impulse\"],\n", + " treatment_effect_param={\"impulse\":[mu, sigma1, sigma2]}\n", + " )\n", + "```\n", + "\n", + ":::{note}\n", + "You must provide all parameters if you choose to set them manually. If you leave the list empty or not fully furnished, default priors will be used.\n", + ":::\n", + "\n", + "| Effect type | Description | Parameters required |\n", + "|-------------|-------------|---------------------|\n", + "|`level`| Permanent jump in the time series level | `[mu, sigma]` for N(mu, sigma) |\n", + "|`trend`| Change in the trend slope | `[mu, sigma]` for N(mu, sigma) |\n", + "|`impulse`| Sudden change with decay | `[mu, sigma1, sigma2]` where:

- Amplitude ~ N(mu, sigma1)
- decay ~ HalfNormal(sigma2) |\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Summary: How to use ``InterventionTimeEstimator``\n", + "\n", + "1. **Specify the time variable**\n", + " \n", + " Indicate which variable in the formula represents time using the time_variable_name argument.\n", + "\n", + "2. **Select the intervention effect type**\n", + "\n", + " Choose the expected effect(s) of the intervention: \"impulse\", \"level\", or \"trend\".\n", + "\n", + "3. **Configure priors for each effect**\n", + " \n", + " Either:\n", + "\n", + " - use default priors or\n", + "\n", + " - specify custom priors (e.g. ``treatment_effect_param={\"impulse\": [mu, sigma1, sigma2]}``).\n", + "\n", + "4. **(Optional) Limit the inference window**\n", + "\n", + " Use ``time_range=(start, end)`` to restrict inference to a specific time interval.\n", + "\n", + "5. **Pass the model to InterruptedTimeSeries**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Interrupted Time Series (InterruptedTimeSeries) : Real Data Example" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tempdeathsyearmonthtpre
date
2006-01-013.849124200610True
2006-02-013.442664200621True
2006-03-013.949207200632True
2006-04-017.440645200643True
2006-05-0110.742425200654True
\n", + "
" + ], + "text/plain": [ + " temp deaths year month t pre\n", + "date \n", + "2006-01-01 3.8 49124 2006 1 0 True\n", + "2006-02-01 3.4 42664 2006 2 1 True\n", + "2006-03-01 3.9 49207 2006 3 2 True\n", + "2006-04-01 7.4 40645 2006 4 3 True\n", + "2006-05-01 10.7 42425 2006 5 4 True" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load Data ...\n", + "\n", + "df = (\n", + " cp.load_data(\"covid\")\n", + " .assign(date=lambda x: pd.to_datetime(x[\"date\"]))\n", + " .set_index(\"date\")\n", + ")\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the data ...\n", + "\n", + "plt.plot(df.index, df[\"deaths\"]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at the data, we observe a noticeable increase in the number of deaths between years 2017 and 2019. After this period, the values seem to return to their previous level.\n", + "\n", + "In this example, we will build a model using the \"impulse\" effect to represent this transient deviation. We won’t specify the exact location of the intervention, instead we will give a time range and hope the model will infer it from the data." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"impulse\",\n", + " sample_kwargs={\"random_seed\": seed, \"progressbar\": False},\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the analysis\n", + "\n", + "Optionally, instead of providing a fixed `treatment_time`, we can guide the inference by specifying a time_range as a tuple, for example, restricting the intervention to occur between years 2014 and 2022. Leaving `treatment_time=None` allows the model to search freely over all possible timestamps, but adding a constraint typically speeds up inference and focuses the posterior on plausible regions.\n", + "\n", + ":::{note}\n", + "The `random_seed` keyword argument for the PyMC sampler is not necessary. We use it here so that the results are reproducible.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, impulse_amplitude, impulse_decay_rate, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 88 seconds.\n", + "Sampling: [beta, impulse_amplitude, impulse_decay_rate, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "result = ChangePointDetection(\n", + " df,\n", + " time_range=(pd.to_datetime(\"2014-01-01\"), pd.to_datetime(\"2022-01-01\")),\n", + " formula=\"standardize(deaths) ~ 0 + t + C(month) + standardize(temp)\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the results\n", + "\n", + ":::{note}\n", + "\n", + "The model estimates the latent time series mu_hat by combining two components:\n", + "\n", + "- `mu`: the part inferred from the user-defined formula (e.g. time + month),\n", + "\n", + "- `mu_in`: the contribution from the intervention effect.\n", + "\n", + "In the plots, we display only `mu` — the baseline prediction based on the formula — to better highlight the causal impact of the intervention. This makes it easier to see how the observed data diverge from what would be expected without the effect.\n", + "\n", + "In contrast, evaluation metrics like R² and standard deviation are computed using `mu_hat`, which includes both the formula and the intervention effect.\n", + "As a result, R² may appear higher than what the plots suggest.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also possible to plot the posterior distribution of the changepoint :" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point();" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================Pre-Post Fit==================================\n", + "Formula: standardize(deaths) ~ 0 + t + C(month) + standardize(temp)\n", + "Model coefficients:\n" + ] + }, + { + "ename": "KeyError", + "evalue": "\"'treated_units' is not a valid dimension or coordinate for Dataset with dimensions FrozenMappingWarningOnValuesAccess({'sample': 4000})\"", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[33]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mresult\u001b[49m\u001b[43m.\u001b[49m\u001b[43msummary\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\Documents\\Stage PYMC\\CausalPy\\causalpy\\experiments\\change_point_detection.py:293\u001b[39m, in \u001b[36mChangePointDetection.summary\u001b[39m\u001b[34m(self, round_to)\u001b[39m\n\u001b[32m 291\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.expt_type\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m=^80\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 292\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mFormula: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.formula\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m293\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mprint_coefficients\u001b[49m\u001b[43m(\u001b[49m\u001b[43mround_to\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\Documents\\Stage PYMC\\CausalPy\\causalpy\\experiments\\base.py:58\u001b[39m, in \u001b[36mBaseExperiment.print_coefficients\u001b[39m\u001b[34m(self, round_to)\u001b[39m\n\u001b[32m 56\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mprint_coefficients\u001b[39m(\u001b[38;5;28mself\u001b[39m, round_to=\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[32m 57\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Ask the model to print its coefficients.\"\"\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m58\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprint_coefficients\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mround_to\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\Documents\\Stage PYMC\\CausalPy\\causalpy\\pymc_models.py:360\u001b[39m, in \u001b[36mPyMCModel.print_coefficients\u001b[39m\u001b[34m(self, labels, round_to)\u001b[39m\n\u001b[32m 357\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33mTreated unit: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00munit\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 359\u001b[39m unit_coeffs = coeffs.sel(treated_units=unit)\n\u001b[32m--> \u001b[39m\u001b[32m360\u001b[39m unit_sigma = \u001b[43maz\u001b[49m\u001b[43m.\u001b[49m\u001b[43mextract\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43midata\u001b[49m\u001b[43m.\u001b[49m\u001b[43mposterior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvar_names\u001b[49m\u001b[43m=\u001b[49m\u001b[43msigma_var_name\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43msel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 361\u001b[39m \u001b[43m \u001b[49m\u001b[43mtreated_units\u001b[49m\u001b[43m=\u001b[49m\u001b[43munit\u001b[49m\n\u001b[32m 362\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 363\u001b[39m print_coefficients_for_unit(unit_coeffs, unit_sigma, labels, round_to \u001b[38;5;129;01mor\u001b[39;00m \u001b[32m2\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\xarray\\core\\dataarray.py:1716\u001b[39m, in \u001b[36mDataArray.sel\u001b[39m\u001b[34m(self, indexers, method, tolerance, drop, **indexers_kwargs)\u001b[39m\n\u001b[32m 1600\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34msel\u001b[39m(\n\u001b[32m 1601\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 1602\u001b[39m indexers: Mapping[Any, Any] | \u001b[38;5;28;01mNone\u001b[39;00m = \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m (...)\u001b[39m\u001b[32m 1606\u001b[39m **indexers_kwargs: Any,\n\u001b[32m 1607\u001b[39m ) -> Self:\n\u001b[32m 1608\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Return a new DataArray whose data is given by selecting index\u001b[39;00m\n\u001b[32m 1609\u001b[39m \u001b[33;03m labels along the specified dimension(s).\u001b[39;00m\n\u001b[32m 1610\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1714\u001b[39m \u001b[33;03m Dimensions without coordinates: points\u001b[39;00m\n\u001b[32m 1715\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1716\u001b[39m ds = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_to_temp_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43msel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1717\u001b[39m \u001b[43m \u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m=\u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1718\u001b[39m \u001b[43m \u001b[49m\u001b[43mdrop\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdrop\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1719\u001b[39m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1720\u001b[39m \u001b[43m \u001b[49m\u001b[43mtolerance\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtolerance\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1721\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mindexers_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1722\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1723\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._from_temp_dataset(ds)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\xarray\\core\\dataset.py:2982\u001b[39m, in \u001b[36mDataset.sel\u001b[39m\u001b[34m(self, indexers, method, tolerance, drop, **indexers_kwargs)\u001b[39m\n\u001b[32m 2914\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Returns a new dataset with each array indexed by tick labels\u001b[39;00m\n\u001b[32m 2915\u001b[39m \u001b[33;03malong the specified dimension(s).\u001b[39;00m\n\u001b[32m 2916\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 2979\u001b[39m \n\u001b[32m 2980\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 2981\u001b[39m indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \u001b[33m\"\u001b[39m\u001b[33msel\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m2982\u001b[39m query_results = \u001b[43mmap_index_queries\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2983\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m=\u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtolerance\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtolerance\u001b[49m\n\u001b[32m 2984\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2986\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m drop:\n\u001b[32m 2987\u001b[39m no_scalar_variables = {}\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\xarray\\core\\indexing.py:193\u001b[39m, in \u001b[36mmap_index_queries\u001b[39m\u001b[34m(obj, indexers, method, tolerance, **indexers_kwargs)\u001b[39m\n\u001b[32m 190\u001b[39m options = {\u001b[33m\"\u001b[39m\u001b[33mmethod\u001b[39m\u001b[33m\"\u001b[39m: method, \u001b[33m\"\u001b[39m\u001b[33mtolerance\u001b[39m\u001b[33m\"\u001b[39m: tolerance}\n\u001b[32m 192\u001b[39m indexers = either_dict_or_kwargs(indexers, indexers_kwargs, \u001b[33m\"\u001b[39m\u001b[33mmap_index_queries\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m193\u001b[39m grouped_indexers = \u001b[43mgroup_indexers_by_index\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 195\u001b[39m results = []\n\u001b[32m 196\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m index, labels \u001b[38;5;129;01min\u001b[39;00m grouped_indexers:\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\xarray\\core\\indexing.py:154\u001b[39m, in \u001b[36mgroup_indexers_by_index\u001b[39m\u001b[34m(obj, indexers, options)\u001b[39m\n\u001b[32m 152\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mno index found for coordinate \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 153\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m key \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m obj.dims:\n\u001b[32m--> \u001b[39m\u001b[32m154\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\n\u001b[32m 155\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m is not a valid dimension or coordinate for \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 156\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj.\u001b[34m__class__\u001b[39m.\u001b[34m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m with dimensions \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj.dims\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 157\u001b[39m )\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(options):\n\u001b[32m 159\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 160\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mcannot supply selection options \u001b[39m\u001b[38;5;132;01m{\u001b[39;00moptions\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m for dimension \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 161\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mthat has no associated coordinate or index\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 162\u001b[39m )\n", + "\u001b[31mKeyError\u001b[39m: \"'treated_units' is not a valid dimension or coordinate for Dataset with dimensions FrozenMappingWarningOnValuesAccess({'sample': 4000})\"" + ] + } + ], + "source": [ + "result.summary()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As well as the model coefficients, we might be interested in the average causal impact and average cumulative causal impact.\n", + "\n", + ":::{note}\n", + "Better output for the summary statistics are in progress!\n", + ":::" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we ask for summary statistics of the causal impact over the entire post-intervention period." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
mu_ts[unit_0]0.5420.0670.4150.6660.0010.0013201.03012.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "mu_ts[unit_0] 0.542 0.067 0.415 0.666 0.001 0.001 3201.0 \n", + "\n", + " ess_tail r_hat \n", + "mu_ts[unit_0] 3012.0 1.0 " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "az.summary(result.post_impact.mean(\"obs_ind\"))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{warning}\n", + "Care must be taken with the mean impact statistic. It only makes sense to use this statistic if it looks like the intervention had a lasting (and roughly constant) effect on the outcome variable. If the effect is transient, then clearly there will be a lot of post-intervention period where the impact of the intervention has 'worn off'. If so, then it will be hard to interpret the mean impacts real meaning.\n", + ":::" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also ask for the summary statistics of the _cumulative_ causal impact." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
mu_ts[unit_0]14.5351.77911.45318.1090.0320.0233161.03136.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "mu_ts[unit_0] 14.535 1.779 11.453 18.109 0.032 0.023 3161.0 \n", + "\n", + " ess_tail r_hat \n", + "mu_ts[unit_0] 3136.0 1.0 " + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get index of the final time point\n", + "index = result.post_impact_cumulative.obs_ind.max()\n", + "# grab the posterior distribution of the cumulative impact at this final time point\n", + "last_cumulative_estimate = result.post_impact_cumulative.sel({\"obs_ind\": index})\n", + "# get summary stats\n", + "az.summary(last_cumulative_estimate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References\n", + "\n", + "- Kay H. Brodersen. Fabian Gallusser. Jim Koehler. Nicolas Remy. Steven L. Scott. \"Inferring causal impact using Bayesian structural time-series models.\" Ann. Appl. Stat. 9 (1) 247 - 274, March 2015. https://doi.org/10.1214/14-AOAS788\n", + "- Davis Berlind, Lorenzo Cappello, Oscar Hernan Madrid Padilla. \"A Bayesian framework for change-point detection with uncertainty quantification\", https://doi.org/10.48550/arXiv.2507.01558" + ] + } + ], + "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.13.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/notebooks/index.md b/docs/source/notebooks/index.md index 17eaa40c..4987a06a 100644 --- a/docs/source/notebooks/index.md +++ b/docs/source/notebooks/index.md @@ -40,6 +40,7 @@ did_pymc_banks.ipynb its_skl.ipynb its_pymc.ipynb its_covid.ipynb +its_no_treatment_time.ipynb ::: :::{toctree}