From 0fa0b6f270ee33ca118c53dcbc2834222435d4c7 Mon Sep 17 00:00:00 2001 From: Gabriel Stechschulte <63432018+GStechschulte@users.noreply.github.com> Date: Sun, 9 Jul 2023 14:54:21 +0200 Subject: [PATCH] Add comparisons and plot comparisons (#684) --- bambi/models.py | 3 +- bambi/plots/__init__.py | 6 +- bambi/plots/create_data.py | 129 ++++++++++ bambi/plots/effects.py | 449 ++++++++++++++++++++++++++++++++++ bambi/plots/plot_cap.py | 425 -------------------------------- bambi/plots/plot_types.py | 201 +++++++++++++++ bambi/plots/plotting.py | 306 +++++++++++++++++++++++ bambi/plots/utils.py | 322 +++++++++++++++++++++++- docs/notebooks/plot_cap.ipynb | 270 ++++++++++++++------ tests/test_plots.py | 395 ++++++++++++++++++------------ 10 files changed, 1838 insertions(+), 668 deletions(-) create mode 100644 bambi/plots/create_data.py create mode 100644 bambi/plots/effects.py delete mode 100644 bambi/plots/plot_cap.py create mode 100644 bambi/plots/plot_types.py create mode 100644 bambi/plots/plotting.py diff --git a/bambi/models.py b/bambi/models.py index 2299adab4..2d184ef99 100644 --- a/bambi/models.py +++ b/bambi/models.py @@ -542,7 +542,6 @@ def set_alias(self, aliases): assert component_name in self.distributional_components component = self.distributional_components[component_name] for name, alias in component_aliases.items(): - is_used = False if name in component.terms: @@ -661,7 +660,7 @@ def plot_priors( unobserved_rvs_names = [] flat_rvs = [] for unobserved in self.backend.model.unobserved_RVs: - if "Flat" in unobserved.__str__(): + if "Flat" in str(unobserved): flat_rvs.append(unobserved.name) else: unobserved_rvs_names.append(unobserved.name) diff --git a/bambi/plots/__init__.py b/bambi/plots/__init__.py index 92da1d8f1..fa53374db 100644 --- a/bambi/plots/__init__.py +++ b/bambi/plots/__init__.py @@ -1,3 +1,5 @@ -from .plot_cap import create_cap_data, plot_cap +from bambi.plots.effects import comparisons, predictions +from bambi.plots.plotting import plot_cap, plot_comparison -__all__ = ["create_cap_data", "plot_cap"] + +__all__ = ["comparisons", "predictions", "plot_cap", "plot_comparison"] diff --git a/bambi/plots/create_data.py b/bambi/plots/create_data.py new file mode 100644 index 000000000..0d6e6899d --- /dev/null +++ b/bambi/plots/create_data.py @@ -0,0 +1,129 @@ +import itertools + +import numpy as np +import pandas as pd + +from bambi.models import Model +from bambi.plots.utils import ( + ConditionalInfo, + ContrastInfo, + enforce_dtypes, + get_covariates, + get_model_covariates, + make_group_panel_values, + make_main_values, + set_default_values, +) + + +def create_cap_data(model: Model, covariates: dict) -> pd.DataFrame: + """Create data for a Conditional Adjusted Predictions + + Parameters + ---------- + model : bambi.Model + An instance of a Bambi model + covariates : dict + A dictionary of length between one and three. + Keys must be taken from ("horizontal", "color", "panel"). + The values indicate the names of variables. + + Returns + ------- + pandas.DataFrame + The data for the Conditional Adjusted Predictions dataframe and or + plotting. + """ + data = model.data + covariates = get_covariates(covariates) + main, group, panel = covariates.main, covariates.group, covariates.panel + + # Obtain data for main variable + main_values = make_main_values(data[main]) + data_dict = {main: main_values} + + # Obtain data for group and panel variables if not None + data_dict = make_group_panel_values(data, data_dict, main, group, panel, kind="predictions") + data_dict = set_default_values(model, data_dict, kind="predictions") + return enforce_dtypes(data, pd.DataFrame(data_dict)) + + +def create_comparisons_data( + condition: ConditionalInfo, contrast: ContrastInfo, user_passed: bool = False +) -> pd.DataFrame: + """Create data for a Conditional Adjusted Comparisons + + Parameters + ---------- + condition: ConditionalInfo + A dataclass instance containing the model, contrast, and conditional + covariates to be used in the comparisons. + contrast: ContrastInfo + A dataclass instance containing the model, and contrast name and values. + user_passed: bool, optional + Whether the user passed their own 'conditional' data. Defaults to False. + + Returns + ------- + pd.DataFrame + The data for the Conditional Adjusted Comparisons dataframe and or + plotting. + """ + + def _grid_level(condition: ConditionalInfo, contrast: ContrastInfo): + """ + Creates the data for grid-level contrasts by using the covariates passed + into the `conditional` arg. Values for the grid are either: (1) computed + using a equally spaced grid, mean, and or mode (depending on the covariate + dtype), and (2) a user specified value or range of values. + """ + covariates = get_covariates(condition.covariates) + + if user_passed: + data_dict = {**condition.conditional} + else: + main_values = make_main_values(condition.model.data[covariates.main]) + data_dict = {covariates.main: main_values} + data_dict = make_group_panel_values( + condition.model.data, + data_dict, + covariates.main, + covariates.group, + covariates.panel, + kind="comparison", + ) + + data_dict[contrast.name] = contrast.values + comparison_data = set_default_values(condition.model, data_dict, kind="comparison") + # use cartesian product (cross join) to create contrasts + keys, values = zip(*comparison_data.items()) + contrast_dict = [dict(zip(keys, v)) for v in itertools.product(*values)] + + return enforce_dtypes(condition.model.data, pd.DataFrame(contrast_dict)) + + def _unit_level(contrast: ContrastInfo): + """ + Creates the data for unit-level contrasts by using the observed (empirical) + data. All covariates in the model are included in the data, except for the + contrast predictor. The contrast predictor is replaced with either: (1) the + default contrast value, or (2) the user specified contrast value. + """ + covariates = get_model_covariates(contrast.model) + df = contrast.model.data[covariates].drop(labels=contrast.name, axis=1) + + contrast_vals = np.array(contrast.values)[..., None] + contrast_vals = np.repeat(contrast_vals, contrast.model.data.shape[0], axis=1) + + contrast_df_dict = {} + for idx, value in enumerate(contrast_vals): + contrast_df_dict[f"contrast_{idx}"] = df.copy() + contrast_df_dict[f"contrast_{idx}"][contrast.name] = value + + return pd.concat(contrast_df_dict.values()) + + if not condition.conditional: + df = _unit_level(contrast) + else: + df = _grid_level(condition, contrast) + + return df diff --git a/bambi/plots/effects.py b/bambi/plots/effects.py new file mode 100644 index 000000000..e6005814a --- /dev/null +++ b/bambi/plots/effects.py @@ -0,0 +1,449 @@ +# pylint: disable = protected-access +# pylint: disable = too-many-function-args +# pylint: disable = too-many-nested-blocks +from dataclasses import dataclass, field +import itertools +from typing import Dict, Union + +import arviz as az +import numpy as np +import pandas as pd +import xarray as xr + +from bambi.models import Model +from bambi.plots.create_data import create_cap_data, create_comparisons_data +from bambi.plots.utils import average_over, ConditionalInfo, ContrastInfo, enforce_dtypes, identity +from bambi.utils import get_aliased_name, listify + + +@dataclass +class ResponseInfo: + name: str + target: Union[str, None] = None + lower_bound: float = 0.03 + upper_bound: float = 0.97 + name_target: str = field(init=False) + name_obs: str = field(init=False) + lower_bound_name: str = field(init=False) + upper_bound_name: str = field(init=False) + + def __post_init__(self): + """ + Assigns commonly used f-strings for indexing and column names as attributes. + """ + if self.target is None: + self.name_target = self.name + else: + self.name_target = f"{self.name}_{self.target}" + + self.name_obs = f"{self.name}_obs" + self.lower_bound_name = f"lower_{self.lower_bound * 100}%" + self.upper_bound_name = f"upper_{self.upper_bound * 100}%" + + +def predictions( + model: Model, + idata: az.InferenceData, + covariates: Union[str, dict, list], + target: str = "mean", + pps: bool = False, + use_hdi: bool = True, + prob=None, + transforms=None, +) -> pd.DataFrame: + """Compute Conditional Adjusted Predictions + + Parameters + ---------- + model : bambi.Model + The model for which we want to plot the predictions. + idata : arviz.InferenceData + The InferenceData object that contains the samples from the posterior distribution of + the model. + covariates : list or dict + A sequence of between one and three names of variables or a dict of length between one + and three. + If a sequence, the first variable is taken as the main variable and is mapped to the + horizontal axis. If present, the second name is a coloring/grouping variable, + and the third is mapped to different plot panels. + If a dictionary, keys must be taken from ("main", "group", "panel") and the values + are the names of the variables. + target : str + Which model parameter to plot. Defaults to 'mean'. Passing a parameter into target only + works when pps is False as the target may not be available in the posterior predictive + distribution. + pps: bool, optional + Whether to plot the posterior predictive samples. Defaults to ``False``. + use_hdi : bool, optional + Whether to compute the highest density interval (defaults to True) or the quantiles. + prob : float, optional + The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94. + Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default. + transforms : dict, optional + Transformations that are applied to each of the variables being plotted. The keys are the + name of the variables, and the values are functions to be applied. Defaults to ``None``. + + Returns + ------- + cap_data : pandas.DataFrame + A DataFrame with the ``create_cap_data`` and model predictions. + + Raises + ------ + ValueError + If ``pps`` is ``True`` and ``target`` is not ``"mean"``. + If passed ``covariates`` is not in correct key, value format. + If length of ``covariates`` is not between 1 and 3. + """ + + if pps and target != "mean": + raise ValueError("When passing 'pps=True', target must be 'mean'") + + covariate_kinds = ("main", "group", "panel") + if not isinstance(covariates, dict): + covariates = listify(covariates) + covariates = dict(zip(covariate_kinds, covariates)) + else: + assert covariate_kinds[0] in covariates + assert set(covariates).issubset(set(covariate_kinds)) + + assert 1 <= len(covariates) <= 3 + + if transforms is None: + transforms = {} + + if prob is None: + prob = az.rcParams["stats.hdi_prob"] + + if not 0 < prob < 1: + raise ValueError(f"'prob' must be greater than 0 and smaller than 1. It is {prob}.") + + cap_data = create_cap_data(model, covariates) + + if target != "mean": + component = model.components[target] + if component.alias: + # use only the aliased name (without appended target) + response_name = get_aliased_name(component) + target = None + else: + # use the default response "y" and append target + response_name = get_aliased_name(model.response_component.response_term) + else: + response_name = get_aliased_name(model.response_component.response_term) + + response = ResponseInfo(response_name, target) + response_transform = transforms.get(response_name, identity) + + if pps: + idata = model.predict(idata, data=cap_data, inplace=False, kind="pps") + y_hat = response_transform(idata.posterior_predictive[response.name]) + y_hat_mean = y_hat.mean(("chain", "draw")) + else: + idata = model.predict(idata, data=cap_data, inplace=False) + y_hat = response_transform(idata.posterior[response.name_target]) + y_hat_mean = y_hat.mean(("chain", "draw")) + + if use_hdi and pps: + y_hat_bounds = az.hdi(y_hat, prob)[response.name].T + elif use_hdi: + y_hat_bounds = az.hdi(y_hat, prob)[response.name_target].T + else: + lower_bound = round((1 - prob) / 2, 4) + upper_bound = 1 - lower_bound + y_hat_bounds = y_hat.quantile(q=(lower_bound, upper_bound), dim=("chain", "draw")) + + lower_bound = round((1 - prob) / 2, 4) + upper_bound = 1 - lower_bound + response.lower_bound, response.upper_bound = lower_bound, upper_bound + + cap_data["estimate"] = y_hat_mean + cap_data[response.lower_bound_name] = y_hat_bounds[0] + cap_data[response.upper_bound_name] = y_hat_bounds[1] + + return cap_data + + +@dataclass +class ContrastEstimate: + comparison: Dict[str, xr.DataArray] + hdi: Dict[str, xr.Dataset] + + +def comparisons( + model: Model, + idata: az.InferenceData, + contrast: Union[str, dict, list], + conditional: Union[str, dict, list, None] = None, + average_by: Union[str, list, bool, None] = None, + comparison_type: str = "diff", + use_hdi: bool = True, + prob=None, + transforms=None, +) -> pd.DataFrame: + """Compute Conditional Adjusted Comparisons + + Parameters + ---------- + model : bambi.Model + The model for which we want to plot the predictions. + idata : arviz.InferenceData + The InferenceData object that contains the samples from the posterior distribution of + the model. + contrast : str, dict, list + The predictor name whose contrast we would like to compare. + conditional : str, dict, list + The covariates we would like to condition on. + average_by: str, list, bool, optional + The covariates we would like to average by. The passed covariate(s) will marginalize + over the other covariates in the model. If True, it averages over all covariates + in the model to obtain the average estimate. Defaults to ``None``. + comparison_type : str, optional + The type of comparison to plot. Defaults to 'diff'. + use_hdi : bool, optional + Whether to compute the highest density interval (defaults to True) or the quantiles. + prob : float, optional + The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94. + Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default. + transforms : dict, optional + Transformations that are applied to each of the variables being plotted. The keys are the + name of the variables, and the values are functions to be applied. Defaults to ``None``. + + Returns + ------- + pandas.DataFrame + A dataframe with the comparison values, highest density interval, contrast name, + contrast value, and conditional values. + + Raises + ------ + ValueError + If length of ``contrast`` is greater than 1. + If ``contrast`` is not a string, dictionary, or list. + If ``comparison_type`` is not 'diff' or 'ratio'. + If ``prob`` is not > 0 and < 1. + """ + + if not isinstance(contrast, (dict, list, str)): + raise ValueError("'contrast' must be a string, dictionary, or list.") + if isinstance(contrast, (dict, list)): + if len(contrast) > 1: + raise ValueError( + f"Only one contrast predictor can be passed. {len(contrast)} were passed." + ) + + if comparison_type not in ("diff", "ratio"): + raise ValueError("'comparison_type' must be 'diff' or 'ratio'") + + if prob is None: + prob = az.rcParams["stats.hdi_prob"] + if not 0 < prob < 1: + raise ValueError(f"'prob' must be greater than 0 and smaller than 1. It is {prob}.") + + comparison_functions = {"diff": lambda x, y: x - y, "ratio": lambda x, y: x / y} + lower_bound = round((1 - prob) / 2, 4) + upper_bound = 1 - lower_bound + + contrast_info = ContrastInfo(model, contrast) + conditional_info = ConditionalInfo(model, conditional) + + # 'comparisons' should not be restricted to ("main", "group", "panel") + comparisons_df = create_comparisons_data( + conditional_info, contrast_info, user_passed=conditional_info.user_passed + ) + + if transforms is None: + transforms = {} + + response_name = get_aliased_name(model.response_component.response_term) + response = ResponseInfo( + response_name, target="mean", lower_bound=lower_bound, upper_bound=upper_bound + ) + + # perform predictions on new data + idata = model.predict(idata, data=comparisons_df, inplace=False) + + def _compute_contrast_estimate( + contrast: ContrastInfo, + response: ResponseInfo, + comparisons_df: pd.DataFrame, + idata: az.InferenceData, + ) -> ContrastEstimate: + """ + Computes the contrast comparison estimate and highest density interval + for a given contrast and response by first subsetting posterior draws + using a contrast mask. Then, pairwise comparisons are computed for the + contrast values. Finally, the mean comparison and lower/upper bounds + are computed for each pairwise comparison. + """ + function = comparison_functions[comparison_type] + + draws = {} + for idx, val in enumerate(contrast.values): + mask = np.array(comparisons_df[contrast.name] == contrast.values[idx]) + select_draw = idata.posterior[response.name_target].sel({response.name_obs: mask}) + select_draw = select_draw.assign_coords( + {response.name_obs: np.arange(len(select_draw.coords[response.name_obs]))} + ) + draws[val] = select_draw + + pairwise_contrasts = list(itertools.combinations(contrast.values, 2)) + + comparison_mean = {} + comparison_bounds = {} + for idx, pair in enumerate(pairwise_contrasts): + comparison_estimate = function(draws[pair[1]], draws[pair[0]]) + comparison_mean[pair] = comparison_estimate.mean(("chain", "draw")) + if use_hdi: + comparison_bounds[pair] = az.hdi(comparison_estimate, prob) + else: + comparison_bounds[pair] = comparison_estimate.quantile( + q=(response.lower_bound, response.upper_bound), dim=("chain", "draw") + ) + + return ContrastEstimate(comparison_mean, comparison_bounds) + + def _build_contrasts_df( + contrast: ContrastInfo, + condition: ConditionalInfo, + response: ResponseInfo, + comparisons_df: pd.DataFrame, + idata: az.InferenceData, + average_by, + ) -> pd.DataFrame: + """ + Builds a dataframe with the comparison values and lower / upper bounds from + ``_compute_contrast_estimate`` along with the contrast name, contrast value, + and conditional values. + """ + contrast_estimate = _compute_contrast_estimate(contrast, response, comparisons_df, idata) + + # if two contrast values, then can drop duplicates to build contrast_df + if len(contrast.values) < 3: + if not any(condition.covariates.values()): + contrast_df = model.data[comparisons_df.columns].drop(columns=contrast.name) + num_rows = contrast_df.shape[0] + contrast_df.insert(0, "term", contrast.name) + contrast_df.insert( + 1, "contrast", list(np.tile(contrast.values, num_rows).reshape(num_rows, 2)) + ) + contrast_df["estimate"] = contrast_estimate.comparison[ + tuple(contrast.values) + ].to_numpy() + else: + contrast_df = comparisons_df.drop_duplicates( + list(condition.covariates.values()) + ).reset_index(drop=True) + contrast_df = contrast_df.drop(columns=contrast.name) + num_rows = contrast_df.shape[0] + contrast_df.insert(0, "term", contrast.name) + contrast_df.insert( + 1, "contrast", list(np.tile(contrast.values, num_rows).reshape(num_rows, 2)) + ) + contrast_df["estimate"] = contrast_estimate.comparison[ + tuple(contrast.values) + ].to_numpy() + + if use_hdi: + contrast_df[response.lower_bound_name] = ( + contrast_estimate.hdi[tuple(contrast.values)][response.name_target] + .sel(hdi="lower") + .values + ) + contrast_df[response.upper_bound_name] = ( + contrast_estimate.hdi[tuple(contrast.values)][response.name_target] + .sel(hdi="higher") + .values + ) + else: + contrast_df[response.lower_bound_name] = contrast_estimate.hdi[ + tuple(contrast.values) + ].sel(quantile=lower_bound) + contrast_df[response.upper_bound_name] = contrast_estimate.hdi[ + tuple(contrast.values) + ].sel(quantile=upper_bound) + + # if > 2 contrast values, then need the full dataframe to build contrast_df + elif len(contrast.values) >= 3: + contrast_keys = [list(elem) for elem in list(contrast_estimate.comparison.keys())] + covariate_cols = comparisons_df.drop(columns=contrast.name).columns + covariate_vals = ( + comparisons_df.drop(columns=contrast.name).drop_duplicates().reset_index(drop=True) + ).values + covariate_vals = np.tile(np.transpose(covariate_vals), len(contrast.values)) + + contrast_df = ( + pd.DataFrame(contrast_estimate.comparison) + .unstack() + .reset_index() + .rename(columns={0: "estimate"}) + ) + + # this hardcoded subset will not work for cross-contrasts + contrast_df.insert(0, "term", contrast.name) + contrast_df.insert( + 1, "contrast", tuple(zip(contrast_df["level_0"], contrast_df["level_1"])) + ) + contrast_df = contrast_df.drop(["level_0", "level_1", "level_2"], axis=1) + + lower = [] + upper = [] + for pair in contrast_keys: + if use_hdi: + lower.append( + ( + contrast_estimate.hdi[tuple(pair)][response.name_target] + .sel(hdi="lower") + .values + ) + ) + upper.append( + ( + contrast_estimate.hdi[tuple(pair)][response.name_target] + .sel(hdi="higher") + .values + ) + ) + else: + lower.append(contrast_estimate.hdi[tuple(pair)].sel(quantile=lower_bound)) + upper.append(contrast_estimate.hdi[tuple(pair)].sel(quantile=upper_bound)) + + contrast_df[covariate_cols] = np.transpose(covariate_vals) + contrast_df[response.lower_bound_name] = np.array(lower).flatten() + contrast_df[response.upper_bound_name] = np.array(upper).flatten() + contrast_df.insert( + len(contrast_df.columns) - 3, "estimate", contrast_df.pop("estimate") + ) + contrast_df = enforce_dtypes(model.data, contrast_df) + + contrast_df["contrast"] = contrast_df["contrast"].apply(tuple) + + if average_by: + if average_by is True: + contrast_df_avg = average_over(contrast_df, None) + contrast_df_avg.insert(0, "term", contrast.name) + contrast_df_avg.insert( + 1, + "contrast", + np.tile(contrast_df["contrast"].drop_duplicates(), len(contrast_df_avg)), + ) + else: + contrast_df_avg = average_over(contrast_df, average_by) + contrast_df_avg.insert(0, "term", contrast.name) + contrast_df_avg.insert( + 1, + "contrast", + np.tile(contrast_df["contrast"].drop_duplicates(), len(contrast_df_avg)), + ) + return contrast_df_avg.reset_index(drop=True) + else: + return contrast_df.reset_index(drop=True) + + return _build_contrasts_df( + contrast_info, + conditional_info, + response, + comparisons_df, + idata, + average_by, + ) diff --git a/bambi/plots/plot_cap.py b/bambi/plots/plot_cap.py deleted file mode 100644 index afa515a2c..000000000 --- a/bambi/plots/plot_cap.py +++ /dev/null @@ -1,425 +0,0 @@ -# pylint: disable = protected-access -# pylint: disable = too-many-function-args -# pylint: disable = too-many-nested-blocks -from statistics import mode - -import arviz as az -import numpy as np -import pandas as pd - -from arviz.plots.backends.matplotlib import create_axes_grid -from arviz.plots.plot_utils import default_grid -from formulae.terms.call import Call -from matplotlib.lines import Line2D -from matplotlib.patches import Patch -from pandas.api.types import is_categorical_dtype, is_numeric_dtype, is_string_dtype - -from bambi.utils import listify, get_aliased_name -from bambi.plots.utils import get_group_offset, get_unique_levels - - -def create_cap_data(model, covariates, grid_n=200, groups_n=5): - """Create data for a Conditional Adjusted Predictions plot - - Parameters - ---------- - model : bambi.Model - An instance of a Bambi model - covariates : dict - A dictionary of length between one and three. - Keys must be taken from ("horizontal", "color", "panel"). - The values indicate the names of variables. - grid_n : int, optional - The number of points used to evaluate the main covariate. Defaults to 200. - groups_n : int, optional - The number of groups to create when the grouping variable is numeric. Groups are based on - equally spaced points. Defaults to 5. - - Returns - ------- - pandas.DataFrame - The data for the Conditional Adjusted Predictions plot. - - Raises - ------ - ValueError - When the number of covariates is larger than 2. - When either the main or the group covariates are not numeric or categoric. - """ - data = model.data - - main = covariates.get("horizontal") - group = covariates.get("color", None) - panel = covariates.get("panel", None) - - # Obtain data for main variable - main_values = make_main_values(data[main], grid_n) - main_n = len(main_values) - - # If available, obtain groups for grouping variable - if group: - group_values = make_group_values(data[group], groups_n) - group_n = len(group_values) - - # If available, obtain groups for panel variable. Same logic than grouping applies - if panel: - panel_values = make_group_values(data[panel], groups_n) - panel_n = len(panel_values) - - data_dict = {main: main_values} - - if group and not panel: - main_values = np.tile(main_values, group_n) - group_values = np.repeat(group_values, main_n) - data_dict.update({main: main_values, group: group_values}) - elif not group and panel: - main_values = np.tile(main_values, panel_n) - panel_values = np.repeat(panel_values, main_n) - data_dict.update({main: main_values, panel: panel_values}) - elif group and panel: - if group == panel: - main_values = np.tile(main_values, group_n) - group_values = np.repeat(group_values, main_n) - data_dict.update({main: main_values, group: group_values}) - else: - main_values = np.tile(np.tile(main_values, group_n), panel_n) - group_values = np.tile(np.repeat(group_values, main_n), panel_n) - panel_values = np.repeat(panel_values, main_n * group_n) - data_dict.update({main: main_values, group: group_values, panel: panel_values}) - - # Construct dictionary of terms that are in the model. - # See it includes the terms for _all_ the distributional components, not just the response - terms = {} - for component in model.distributional_components.values(): - if component.design.common: - terms.update(component.design.common.terms) - - if component.design.group: - terms.update(component.design.group.terms) - - # Get default values for each variable in the model - for term in terms.values(): - if hasattr(term, "components"): - for component in term.components: - # If the component is a function call, use the argument names - if isinstance(component, Call): - names = [arg.name for arg in component.call.args] - else: - names = [component.name] - - for name in names: - if name not in data_dict: - # For numeric predictors, select the mean. - if component.kind == "numeric": - data_dict[name] = np.mean(data[name]) - # For categoric predictors, select the most frequent level. - elif component.kind == "categoric": - data_dict[name] = mode(data[name]) - - cap_data = pd.DataFrame(data_dict) - - # Make sure new types are same types than the original columns - for column in cap_data: - cap_data[column] = cap_data[column].astype(data[column].dtype) - return cap_data - - -def plot_cap( - model, - idata, - covariates, - target="mean", - pps=False, - use_hdi=True, - hdi_prob=None, - transforms=None, - legend=True, - ax=None, - fig_kwargs=None, -): - """Plot Conditional Adjusted Predictions - - Parameters - ---------- - model : bambi.Model - The model for which we want to plot the predictions. - idata : arviz.InferenceData - The InferenceData object that contains the samples from the posterior distribution of - the model. - covariates : list or dict - A sequence of between one and three names of variables or a dict of length between one - and three. - If a sequence, the first variable is taken as the main variable, - mapped to the horizontal axis. If present, the second name is a coloring/grouping variable, - and the third is mapped to different plot panels. - If a dictionary, keys must be taken from ("horizontal", "color", "panel") and the values - are the names of the variables. - target : str - Which model parameter to plot. Defaults to 'mean'. Passing a parameter into target only - works when pps is False as the target may not be available in the posterior predictive - distribution. - pps: bool, optional - Whether to plot the posterior predictive samples. Defaults to ``False``. - use_hdi : bool, optional - Whether to compute the highest density interval (defaults to True) or the quantiles. - hdi_prob : float, optional - The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94. - Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default. - legend : bool, optional - Whether to automatically include a legend in the plot. Defaults to ``True``. - transforms : dict, optional - Transformations that are applied to each of the variables being plotted. The keys are the - name of the variables, and the values are functions to be applied. Defaults to ``None``. - ax : matplotlib.axes._subplots.AxesSubplot, optional - A matplotlib axes object or a sequence of them. If None, this function instantiates a - new axes object. Defaults to ``None``. - - Returns - ------- - matplotlib.figure.Figure, matplotlib.axes._subplots.AxesSubplot - A tuple with the figure and the axes. - - Raises - ------ - ValueError - When ``level`` is not within 0 and 1. - When the main covariate is not numeric or categoric. - """ - - covariate_kinds = ("horizontal", "color", "panel") - if not isinstance(covariates, dict): - covariates = listify(covariates) - covariates = dict(zip(covariate_kinds, covariates)) - else: - assert covariate_kinds[0] in covariates - assert set(covariates).issubset(set(covariate_kinds)) - - assert 1 <= len(covariates) <= 3 - - if hdi_prob is None: - hdi_prob = az.rcParams["stats.hdi_prob"] - - if not 0 < hdi_prob < 1: - raise ValueError(f"'hdi_prob' must be greater than 0 and smaller than 1. It is {hdi_prob}.") - - cap_data = create_cap_data(model, covariates) - - if transforms is None: - transforms = {} - - response_name = get_aliased_name(model.response_component.response_term) - response_transform = transforms.get(response_name, identity) - - if pps: - idata = model.predict(idata, data=cap_data, inplace=False, kind="pps") - y_hat = response_transform(idata.posterior_predictive[response_name]) - y_hat_mean = y_hat.mean(("chain", "draw")) - else: - idata = model.predict(idata, data=cap_data, inplace=False) - y_hat = response_transform(idata.posterior[f"{response_name}_{target}"]) - y_hat_mean = y_hat.mean(("chain", "draw")) - - if use_hdi and pps: - y_hat_bounds = az.hdi(y_hat, hdi_prob)[response_name].T - elif use_hdi: - y_hat_bounds = az.hdi(y_hat, hdi_prob)[f"{response_name}_{target}"].T - else: - lower_bound = round((1 - hdi_prob) / 2, 4) - upper_bound = 1 - lower_bound - y_hat_bounds = y_hat.quantile(q=(lower_bound, upper_bound), dim=("chain", "draw")) - - if ax is None: - fig_kwargs = {} if fig_kwargs is None else fig_kwargs - panel = covariates.get("panel", None) - panels_n = len(np.unique(cap_data[panel])) if panel else 1 - rows, cols = default_grid(panels_n) - fig, axes = create_axes_grid(panels_n, rows, cols, backend_kwargs=fig_kwargs) - axes = np.atleast_1d(axes) - else: - axes = np.atleast_1d(ax) - if isinstance(axes[0], np.ndarray): - fig = axes[0][0].get_figure() - else: - fig = axes[0].get_figure() - - main = covariates.get("horizontal") - if is_numeric_dtype(cap_data[main]): - axes = _plot_cap_numeric( - covariates, cap_data, y_hat_mean, y_hat_bounds, transforms, legend, axes - ) - elif is_categorical_dtype(cap_data[main]) or is_string_dtype(cap_data[main]): - axes = _plot_cap_categoric(covariates, cap_data, y_hat_mean, y_hat_bounds, legend, axes) - else: - raise ValueError("Main covariate must be numeric or categoric.") - - ylabel = response_name if target == "mean" else target - for ax in axes.ravel(): # pylint: disable = redefined-argument-from-local - ax.set(xlabel=main, ylabel=ylabel) - - return fig, axes - - -def _plot_cap_numeric(covariates, cap_data, y_hat_mean, y_hat_bounds, transforms, legend, axes): - main = covariates.get("horizontal") - transform_main = transforms.get(main, identity) - - if len(covariates) == 1: - ax = axes[0] - values_main = transform_main(cap_data[main]) - ax.plot(values_main, y_hat_mean, solid_capstyle="butt") - ax.fill_between(values_main, y_hat_bounds[0], y_hat_bounds[1], alpha=0.4) - elif "color" in covariates and not "panel" in covariates: - ax = axes[0] - color = covariates.get("color") - colors = get_unique_levels(cap_data[color]) - for i, clr in enumerate(colors): - idx = (cap_data[color] == clr).to_numpy() - values_main = transform_main(cap_data.loc[idx, main]) - ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") - ax.fill_between( - values_main, - y_hat_bounds[0][idx], - y_hat_bounds[1][idx], - alpha=0.4, - color=f"C{i}", - ) - elif not "color" in covariates and "panel" in covariates: - panel = covariates.get("panel") - panels = get_unique_levels(cap_data[panel]) - for ax, pnl in zip(axes.ravel(), panels): - idx = (cap_data[panel] == pnl).to_numpy() - values_main = transform_main(cap_data.loc[idx, main]) - ax.plot(values_main, y_hat_mean[idx], solid_capstyle="butt") - ax.fill_between(values_main, y_hat_bounds[0][idx], y_hat_bounds[1][idx], alpha=0.4) - ax.set(title=f"{panel} = {pnl}") - elif "color" in covariates and "panel" in covariates: - color = covariates.get("color") - panel = covariates.get("panel") - colors = get_unique_levels(cap_data[color]) - panels = get_unique_levels(cap_data[panel]) - if color == panel: - for i, (ax, pnl) in enumerate(zip(axes.ravel(), panels)): - idx = (cap_data[panel] == pnl).to_numpy() - values_main = transform_main(cap_data.loc[idx, main]) - ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") - ax.fill_between( - values_main, - y_hat_bounds[0][idx], - y_hat_bounds[1][idx], - alpha=0.4, - color=f"C{i}", - ) - ax.set(title=f"{panel} = {pnl}") - else: - for ax, pnl in zip(axes.ravel(), panels): - for i, clr in enumerate(colors): - idx = ((cap_data[panel] == pnl) & (cap_data[color] == clr)).to_numpy() - values_main = transform_main(cap_data.loc[idx, main]) - ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") - ax.fill_between( - values_main, - y_hat_bounds[0][idx], - y_hat_bounds[1][idx], - alpha=0.4, - color=f"C{i}", - ) - ax.set(title=f"{panel} = {pnl}") - - if "color" in covariates and legend: - handles = [ - ( - Line2D([], [], color=f"C{i}", solid_capstyle="butt"), - Patch(color=f"C{i}", alpha=0.4, lw=1), - ) - for i in range(len(colors)) - ] - for ax in axes.ravel(): - ax.legend( - handles, tuple(colors), title=color, handlelength=1.3, handleheight=1, loc="best" - ) - return axes - - -def _plot_cap_categoric(covariates, cap_data, y_hat_mean, y_hat_bounds, legend, axes): - main = covariates.get("horizontal") - main_levels = get_unique_levels(cap_data[main]) - main_levels_n = len(main_levels) - idxs_main = np.arange(main_levels_n) - - if "color" in covariates: - color = covariates.get("color") - colors = get_unique_levels(cap_data[color]) - colors_n = len(colors) - offset_bounds = get_group_offset(colors_n) - colors_offset = np.linspace(-offset_bounds, offset_bounds, colors_n) - - if "panel" in covariates: - panel = covariates.get("panel") - panels = get_unique_levels(cap_data[panel]) - - if len(covariates) == 1: - ax = axes[0] - ax.scatter(idxs_main, y_hat_mean) - ax.vlines(idxs_main, y_hat_bounds[0], y_hat_bounds[1]) - elif "color" in covariates and not "panel" in covariates: - ax = axes[0] - for i, clr in enumerate(colors): - idx = (cap_data[color] == clr).to_numpy() - idxs = idxs_main + colors_offset[i] - ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") - ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") - elif not "color" in covariates and "panel" in covariates: - for ax, pnl in zip(axes.ravel(), panels): - idx = (cap_data[panel] == pnl).to_numpy() - ax.scatter(idxs_main, y_hat_mean[idx]) - ax.vlines(idxs_main, y_hat_bounds[0][idx], y_hat_bounds[1][idx]) - ax.set(title=f"{panel} = {pnl}") - elif "color" in covariates and "panel" in covariates: - if color == panel: - for i, (ax, pnl) in enumerate(zip(axes.ravel(), panels)): - idx = (cap_data[panel] == pnl).to_numpy() - idxs = idxs_main + colors_offset[i] - ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") - ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") - ax.set(title=f"{panel} = {pnl}") - else: - for ax, pnl in zip(axes.ravel(), panels): - for i, clr in enumerate(colors): - idx = ((cap_data[panel] == pnl) & (cap_data[color] == clr)).to_numpy() - idxs = idxs_main + colors_offset[i] - ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") - ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") - ax.set(title=f"{panel} = {pnl}") - - if "color" in covariates and legend: - handles = [ - Line2D([], [], c=f"C{i}", marker="o", label=level) for i, level in enumerate(colors) - ] - for ax in axes.ravel(): - ax.legend(handles=handles, title=color, loc="best") - - for ax in axes.ravel(): - ax.set_xticks(idxs_main) - ax.set_xticklabels(main_levels) - - return axes - - -def identity(x): - return x - - -def make_main_values(x, grid_n): - if is_numeric_dtype(x): - return np.linspace(np.min(x), np.max(x), grid_n) - elif is_string_dtype(x) or is_categorical_dtype(x): - return np.unique(x) - raise ValueError("Main covariate must be numeric or categoric.") - - -def make_group_values(x, groups_n): - if is_string_dtype(x) or is_categorical_dtype(x): - return np.unique(x) - elif is_numeric_dtype(x): - return np.quantile(x, np.linspace(0, 1, groups_n)) - raise ValueError("Group covariate must be numeric or categoric.") diff --git a/bambi/plots/plot_types.py b/bambi/plots/plot_types.py new file mode 100644 index 000000000..11526b2d1 --- /dev/null +++ b/bambi/plots/plot_types.py @@ -0,0 +1,201 @@ +from matplotlib.lines import Line2D +from matplotlib.patches import Patch +import numpy as np +import pandas as pd + +from bambi.plots.utils import Covariates, get_unique_levels, get_group_offset, identity + + +def plot_numeric( + covariates: Covariates, + plot_data: pd.DataFrame, + transforms: dict, + legend: bool = True, + axes=None, +): + """Plotting of numeric data types. + + Parameters + ---------- + covariates : Covariates + Covariates callable with attributes main, group, panel. + plot_data : pd.DataFrame + The data created by the `create_cap_data` or `create_comparisons_data` + function. + transforms : dict + Transformations that are applied to each of the variables being plotted. The keys are the + name of the variables, and the values are functions to be applied. Defaults to `None`. + legend : bool, optional + Whether to include a legend in the plot. Default to `True`. + axes : np.ndarray, optional + Array of axes. Defaults to `None`. + + Returns + ------- + axes : np.ndarray + Array of axes. + """ + + main, color, panel = covariates.main, covariates.group, covariates.panel + covariates = {k: v for k, v in vars(covariates).items() if v is not None} + transform_main = transforms.get(main, identity) + y_hat_mean = plot_data["estimate"] + y_hat_bounds = np.transpose(plot_data[plot_data.columns[-2:]].values) + + if len(covariates) == 1: + ax = axes[0] + values_main = transform_main(plot_data[main]) + ax.plot(values_main, y_hat_mean, solid_capstyle="butt") + ax.fill_between(values_main, y_hat_bounds[0], y_hat_bounds[1], alpha=0.4) + elif "group" in covariates and not "panel" in covariates: + ax = axes[0] + colors = get_unique_levels(plot_data[color]) + for i, clr in enumerate(colors): + idx = (plot_data[color] == clr).to_numpy() + values_main = transform_main(plot_data.loc[idx, main]) + ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") + ax.fill_between( + values_main, + y_hat_bounds[0][idx], + y_hat_bounds[1][idx], + alpha=0.4, + color=f"C{i}", + ) + elif not "group" in covariates and "panel" in covariates: + panels = get_unique_levels(plot_data[panel]) + for ax, pnl in zip(axes.ravel(), panels): + idx = (plot_data[panel] == pnl).to_numpy() + values_main = transform_main(plot_data.loc[idx, main]) + ax.plot(values_main, y_hat_mean[idx], solid_capstyle="butt") + ax.fill_between(values_main, y_hat_bounds[0][idx], y_hat_bounds[1][idx], alpha=0.4) + ax.set(title=f"{panel} = {pnl}") + elif "group" in covariates and "panel" in covariates: + colors = get_unique_levels(plot_data[color]) + panels = get_unique_levels(plot_data[panel]) + if color == panel: + for i, (ax, pnl) in enumerate(zip(axes.ravel(), panels)): + idx = (plot_data[panel] == pnl).to_numpy() + values_main = transform_main(plot_data.loc[idx, main]) + ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") + ax.fill_between( + values_main, + y_hat_bounds[0][idx], + y_hat_bounds[1][idx], + alpha=0.4, + color=f"C{i}", + ) + ax.set(title=f"{panel} = {pnl}") + else: + for ax, pnl in zip(axes.ravel(), panels): + for i, clr in enumerate(colors): + idx = ((plot_data[panel] == pnl) & (plot_data[color] == clr)).to_numpy() + values_main = transform_main(plot_data.loc[idx, main]) + ax.plot(values_main, y_hat_mean[idx], color=f"C{i}", solid_capstyle="butt") + ax.fill_between( + values_main, + y_hat_bounds[0][idx], + y_hat_bounds[1][idx], + alpha=0.4, + color=f"C{i}", + ) + ax.set(title=f"{panel} = {pnl}") + + if "group" in covariates and legend: + handles = [ + ( + Line2D([], [], color=f"C{i}", solid_capstyle="butt"), + Patch(color=f"C{i}", alpha=0.4, lw=1), + ) + for i in range(len(colors)) + ] + for ax in axes.ravel(): + ax.legend( + handles, tuple(colors), title=color, handlelength=1.3, handleheight=1, loc="best" + ) + return axes + + +def plot_categoric(covariates: Covariates, plot_data: pd.DataFrame, legend: bool = True, axes=None): + """Plotting of categorical data types. + + Parameters + ---------- + covariates : Covariates + Covariates callable with attributes main, gro up, panel. + plot_data : pd.DataFrame + The data created by the `create_cap_data` or `create_comparisons_data` + function. + legend : bool, optional + Whether to include a legend in the plot. Default to `True`. + axes : np.ndarray, optional + Array of axes. Defaults to `None`. + + Returns + ------- + axes : np.ndarray + Array of axes. + """ + + main, color, panel = covariates.main, covariates.group, covariates.panel + covariates = {k: v for k, v in vars(covariates).items() if v is not None} + main_levels = get_unique_levels(plot_data[main]) + main_levels_n = len(main_levels) + idxs_main = np.arange(main_levels_n) + y_hat_mean = plot_data["estimate"] + y_hat_bounds = np.transpose(plot_data[plot_data.columns[-2:]].values) + + if "group" in covariates: + colors = get_unique_levels(plot_data[color]) + colors_n = len(colors) + offset_bounds = get_group_offset(colors_n) + colors_offset = np.linspace(-offset_bounds, offset_bounds, colors_n) + + if "panel" in covariates: + panels = get_unique_levels(plot_data[panel]) + + if len(covariates) == 1: + ax = axes[0] + ax.scatter(idxs_main, y_hat_mean) + ax.vlines(idxs_main, y_hat_bounds[0], y_hat_bounds[1]) + elif "group" in covariates and not "panel" in covariates: + ax = axes[0] + for i, clr in enumerate(colors): + idx = (plot_data[color] == clr).to_numpy() + idxs = idxs_main + colors_offset[i] + ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") + ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") + elif not "group" in covariates and "panel" in covariates: + for ax, pnl in zip(axes.ravel(), panels): + idx = (plot_data[panel] == pnl).to_numpy() + ax.scatter(idxs_main, y_hat_mean[idx]) + ax.vlines(idxs_main, y_hat_bounds[0][idx], y_hat_bounds[1][idx]) + ax.set(title=f"{panel} = {pnl}") + elif "group" in covariates and "panel" in covariates: + if color == panel: + for i, (ax, pnl) in enumerate(zip(axes.ravel(), panels)): + idx = (plot_data[panel] == pnl).to_numpy() + idxs = idxs_main + colors_offset[i] + ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") + ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") + ax.set(title=f"{panel} = {pnl}") + else: + for ax, pnl in zip(axes.ravel(), panels): + for i, clr in enumerate(colors): + idx = ((plot_data[panel] == pnl) & (plot_data[color] == clr)).to_numpy() + idxs = idxs_main + colors_offset[i] + ax.scatter(idxs, y_hat_mean[idx], color=f"C{i}") + ax.vlines(idxs, y_hat_bounds[0][idx], y_hat_bounds[1][idx], color=f"C{i}") + ax.set(title=f"{panel} = {pnl}") + + if "group" in covariates and legend: + handles = [ + Line2D([], [], c=f"C{i}", marker="o", label=level) for i, level in enumerate(colors) + ] + for ax in axes.ravel(): + ax.legend(handles=handles, title=color, loc="best") + + for ax in axes.ravel(): + ax.set_xticks(idxs_main) + ax.set_xticklabels(main_levels) + + return axes diff --git a/bambi/plots/plotting.py b/bambi/plots/plotting.py new file mode 100644 index 000000000..a5f9376e6 --- /dev/null +++ b/bambi/plots/plotting.py @@ -0,0 +1,306 @@ +# pylint: disable = protected-access +# pylint: disable = too-many-function-args +# pylint: disable = too-many-nested-blocks +from typing import Union + +import arviz as az +from arviz.plots.backends.matplotlib import create_axes_grid +from arviz.plots.plot_utils import default_grid +import numpy as np +from pandas.api.types import is_categorical_dtype, is_numeric_dtype, is_string_dtype + +from bambi.models import Model +from bambi.plots.effects import comparisons, predictions +from bambi.plots.plot_types import plot_categoric, plot_numeric +from bambi.plots.utils import get_covariates, ConditionalInfo +from bambi.utils import get_aliased_name, listify + + +def plot_cap( + model: Model, + idata: az.InferenceData, + covariates: Union[str, list], + target: str = "mean", + pps: bool = False, + use_hdi: bool = True, + prob=None, + transforms=None, + legend: bool = True, + ax=None, + fig_kwargs=None, + subplot_kwargs=None, +): + """Plot Conditional Adjusted Predictions + + Parameters + ---------- + model : bambi.Model + The model for which we want to plot the predictions. + idata : arviz.InferenceData + The InferenceData object that contains the samples from the posterior distribution of + the model. + covariates : list or dict + A sequence of between one and three names of variables in the model. + target : str + Which model parameter to plot. Defaults to 'mean'. Passing a parameter into target only + works when pps is False as the target may not be available in the posterior predictive + distribution. + pps: bool, optional + Whether to plot the posterior predictive samples. Defaults to ``False``. + use_hdi : bool, optional + Whether to compute the highest density interval (defaults to True) or the quantiles. + prob : float, optional + The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94. + Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default. + legend : bool, optional + Whether to automatically include a legend in the plot. Defaults to ``True``. + transforms : dict, optional + Transformations that are applied to each of the variables being plotted. The keys are the + name of the variables, and the values are functions to be applied. Defaults to ``None``. + ax : matplotlib.axes._subplots.AxesSubplot, optional + A matplotlib axes object or a sequence of them. If None, this function instantiates a + new axes object. Defaults to ``None``. + fig_kwargs : optional + Keyword arguments passed to the matplotlib figure function as a dict. For example, + ``fig_kwargs=dict(figsize=(11, 8)), sharey=True`` would make the figure 11 inches wide + by 8 inches high and would share the y-axis values. + subplot_kwargs : optional + Keyword arguments used to determine the covariates used for the horizontal, group, + and panel axes. For example, ``subplot_kwargs=dict(main="x", group="y", panel="z")`` would + plot the horizontal axis as ``x``, the color (hue) as ``y``, and the panel axis as ``z``. + + Returns + ------- + matplotlib.figure.Figure, matplotlib.axes._subplots.AxesSubplot + A tuple with the figure and the axes. + + Raises + ------ + ValueError + When ``level`` is not within 0 and 1. + When the main covariate is not numeric or categoric. + + TypeError + When ``covariates`` is not a string or a list of strings. + """ + + covariate_kinds = ("main", "group", "panel") + if isinstance(covariates, dict): + raise TypeError("covariates must be a string or a list of strings.") + + if not isinstance(covariates, dict): + covariates = listify(covariates) + covariates = dict(zip(covariate_kinds, covariates)) + else: + assert covariate_kinds[0] in covariates + assert set(covariates).issubset(set(covariate_kinds)) + + assert 1 <= len(covariates) <= 3 + + if transforms is None: + transforms = {} + + cap_data = predictions( + model, + idata, + covariates, + target=target, + pps=pps, + use_hdi=use_hdi, + prob=prob, + transforms=transforms, + ) + + response_name = get_aliased_name(model.response_component.response_term) + covariates = get_covariates(covariates) + + if subplot_kwargs: + for key, value in subplot_kwargs.items(): + setattr(covariates, key, value) + + if ax is None: + fig_kwargs = {} if fig_kwargs is None else fig_kwargs + panels_n = len(np.unique(cap_data[covariates.panel])) if covariates.panel else 1 + rows, cols = default_grid(panels_n) + fig, axes = create_axes_grid(panels_n, rows, cols, backend_kwargs=fig_kwargs) + axes = np.atleast_1d(axes) + else: + axes = np.atleast_1d(ax) + if isinstance(axes[0], np.ndarray): + fig = axes[0][0].get_figure() + else: + fig = axes[0].get_figure() + + if is_numeric_dtype(cap_data[covariates.main]): + axes = plot_numeric(covariates, cap_data, transforms, legend, axes) + elif is_categorical_dtype(cap_data[covariates.main]) or is_string_dtype( + cap_data[covariates.main] + ): + axes = plot_categoric(covariates, cap_data, legend, axes) + else: + raise ValueError("Main covariate must be numeric or categoric.") + + ylabel = response_name if target == "mean" else target + for ax in axes.ravel(): # pylint: disable = redefined-argument-from-local + ax.set(xlabel=covariates.main, ylabel=ylabel) + + return fig, axes + + +def plot_comparison( + model: Model, + idata: az.InferenceData, + contrast: Union[str, dict, list], + conditional: Union[str, dict, list, None] = None, + average_by: Union[str, list] = None, + comparison_type: str = "diff", + use_hdi: bool = True, + prob=None, + legend: bool = True, + transforms=None, + ax=None, + fig_kwargs=None, + subplot_kwargs=None, +): + """Plot Conditional Adjusted Comparisons + + Parameters + ---------- + model : bambi.Model + The model for which we want to plot the predictions. + idata : arviz.InferenceData + The InferenceData object that contains the samples from the posterior distribution of + the model. + contrast : str, dict, list + The predictor name whose contrast we would like to compare. + conditional : str, dict, list + The covariates we would like to condition on. + average_by: str, list, optional + The covariates we would like to average by. The passed covariate(s) will marginalize + over the other covariates in the model. Defaults to ``None``. + comparison_type : str, optional + The type of comparison to plot. Defaults to 'diff'. + use_hdi : bool, optional + Whether to compute the highest density interval (defaults to True) or the quantiles. + prob : float, optional + The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94. + Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default. + legend : bool, optional + Whether to automatically include a legend in the plot. Defaults to ``True``. + transforms : dict, optional + Transformations that are applied to each of the variables being plotted. The keys are the + name of the variables, and the values are functions to be applied. Defaults to ``None``. + ax : matplotlib.axes._subplots.AxesSubplot, optional + A matplotlib axes object or a sequence of them. If None, this function instantiates a + new axes object. Defaults to ``None``. + fig_kwargs : optional + Keyword arguments passed to the matplotlib figure function as a dict. For example, + ``fig_kwargs=dict(figsize=(11, 8)), sharey=True`` would make the figure 11 inches wide + by 8 inches high and would share the y-axis values. + subplot_kwargs : optional + Keyword arguments used to determine the covariates used for the horizontal, group, + and panel axes. For example, ``subplot_kwargs=dict(main="x", group="y", panel="z")`` would + plot the horizontal axis as ``x``, the color (hue) as ``y``, and the panel axis as ``z``. + + Returns + ------- + matplotlib.figure.Figure, matplotlib.axes._subplots.AxesSubplot + A tuple with the figure and the axes. + + Raises + ------ + ValueError + If ``conditional`` and ``average_by`` are both ``None``. + If length of ``conditional`` is greater than 3 and ``average_by`` is ``None``. + + Warning + If length of ``contrast`` is greater than 2. + """ + if conditional is None and average_by is None: + raise ValueError("Must specify at least one of 'conditional' or 'average_by'.") + if conditional is not None: + if not isinstance(conditional, str): + if len(conditional) > 3 and average_by is None: + raise ValueError( + "Must specify a covariate to 'average_by' when number of covariates" + "passed to 'conditional' is greater than 3." + ) + if average_by is True: + raise ValueError( + "Plotting when 'average_by = True' is not possible as 'True' marginalizes " + "over all covariates resulting in a single comparison estimate. " + "Please specify a covariate(s) to 'average_by'." + ) + + if isinstance(contrast, dict): + contrast_name, contrast_level = next(iter(contrast.items())) + if len(contrast_level) > 2: + raise ValueError( + f"Plotting when 'contrast' has > 2 values is not supported. " + f"{contrast_name} has {len(contrast_level)} values." + ) + + contrast_df = comparisons( + model=model, + idata=idata, + contrast=contrast, + conditional=conditional, + average_by=average_by, + comparison_type=comparison_type, + use_hdi=use_hdi, + prob=prob, + transforms=transforms, + ) + + conditional_info = ConditionalInfo(model, conditional) + + if (subplot_kwargs and not average_by) or (subplot_kwargs and average_by): + for key, value in subplot_kwargs.items(): + conditional_info.covariates.update({key: value}) + covariates = get_covariates(conditional_info.covariates) + elif average_by and not subplot_kwargs: + if not isinstance(average_by, list): + average_by = listify(average_by) + covariate_kinds = ("main", "group", "panel") + average_by = dict(zip(covariate_kinds, average_by)) + covariates = get_covariates(average_by) + else: + covariates = get_covariates(conditional_info.covariates) + + if transforms is None: + transforms = {} + + response_name = get_aliased_name(model.response_component.response_term) + + if ax is None: + fig_kwargs = {} if fig_kwargs is None else fig_kwargs + panels_n = len(np.unique(contrast_df[covariates.panel])) if covariates.panel else 1 + rows, cols = default_grid(panels_n) + fig, axes = create_axes_grid(panels_n, rows, cols, backend_kwargs=fig_kwargs) + axes = np.atleast_1d(axes) + else: + axes = np.atleast_1d(ax) + if isinstance(axes[0], np.ndarray): + fig = axes[0][0].get_figure() + else: + fig = axes[0].get_figure() + + if is_numeric_dtype(contrast_df[covariates.main]): + # main condition variable can be numeric but at the same time only + # a few values, so it is treated as categoric + if np.unique(contrast_df[covariates.main]).shape[0] <= 5: + axes = plot_categoric(covariates, contrast_df, legend, axes) + else: + axes = plot_numeric(covariates, contrast_df, transforms, legend, axes) + elif is_categorical_dtype(contrast_df[covariates.main]) or is_string_dtype( + contrast_df[covariates.main] + ): + axes = plot_categoric(covariates, contrast_df, legend, axes) + else: + raise TypeError("Main covariate must be numeric or categoric.") + + response_name = get_aliased_name(model.response_component.response_term) + for ax in axes.ravel(): # pylint: disable = redefined-argument-from-local + ax.set(xlabel=covariates.main, ylabel=response_name) + + return fig, axes diff --git a/bambi/plots/utils.py b/bambi/plots/utils.py index 9f54039ed..0d5deb8fa 100644 --- a/bambi/plots/utils.py +++ b/bambi/plots/utils.py @@ -1,7 +1,321 @@ +from dataclasses import dataclass, field +from statistics import mode +from typing import Union + import numpy as np +from formulae.terms.call import Call +import pandas as pd +from pandas.api.types import is_categorical_dtype, is_numeric_dtype, is_string_dtype + +from bambi import Model +from bambi.utils import listify + + +@dataclass +class ContrastInfo: + model: Model + contrast: Union[str, dict, list] + name: str = field(init=False) + values: Union[int, float] = field(init=False) + + def __post_init__(self): + """ """ + if isinstance(self.contrast, dict): + self.values = list(self.contrast.values())[0] + self.name = list(self.contrast.keys())[0] + elif isinstance(self.contrast, (list, str)): + if isinstance(self.contrast, list): + self.name = " ".join(self.contrast) + else: + self.name = self.contrast + self.values = set_default_contrast_values(self.model, self.name) + elif not isinstance(self.contrast, (list, dict, str)): + raise TypeError("`contrast` must be a list, dict, or string") + + +@dataclass +class ConditionalInfo: + model: Model + conditional: Union[str, dict, list] + covariates: dict = field(init=False) + user_passed: bool = field(init=False) + + def __post_init__(self): + """ + Sets the covariates attributes based on if the user passed a dictionary + or not. + """ + covariate_kinds = ("main", "group", "panel") + + if not isinstance(self.conditional, dict): + self.covariates = listify(self.conditional) + self.covariates = dict(zip(covariate_kinds, self.covariates)) + self.user_passed = False + elif isinstance(self.conditional, dict): + self.covariates = {k: listify(v) for k, v in self.conditional.items()} + self.covariates = dict(zip(covariate_kinds, self.conditional)) + self.user_passed = True + + +@dataclass +class Covariates: + main: str + group: Union[str, None] + panel: Union[str, None] + + +def average_over(data: pd.DataFrame, covariate: Union[str, list, None]) -> pd.DataFrame: + """ + Average estimates by specified covariate in the model. data.columns[-3:] are + the columns: 'estimate', 'lower', and 'upper'. + """ + if covariate is None: + return pd.DataFrame(data[data.columns[-3:]].mean()).T + else: + return data.groupby(covariate, as_index=False)[data.columns[-3:]].mean() + + +def get_model_terms(model: Model) -> dict: + """ + Loops through the distributional components of a bambi model and + returns a dictionary of terms. + """ + terms = {} + for component in model.distributional_components.values(): + if component.design.common: + terms.update(component.design.common.terms) + + if component.design.group: + terms.update(component.design.group.terms) + + return terms + + +def get_model_covariates(model: Model): + """ + Return covariates specified in the model. + """ + + terms = get_model_terms(model) + names = [] + for term in terms.values(): + if hasattr(term, "components"): + for component in term.components: + # If the component is a function call, use the argument names + if isinstance(component, Call): + names.append([arg.name for arg in component.call.args]) + else: + names.append([component.name]) + + return np.unique(names) + + +def get_covariates(covariates: dict) -> Covariates: + """ + Obtain the main, group, and panel covariates from the user's + conditional dict. + """ + covariate_kinds = ("main", "group", "panel") + if any(key in covariate_kinds for key in covariates.keys()): + # default if user did not pass their own conditional dict + main = covariates.get("main") + group = covariates.get("group", None) + panel = covariates.get("panel", None) + else: + # assign main, group, panel based on the number of variables + # passed by the user in their conditional dict + length = len(covariates.keys()) + if length == 1: + main = covariates.keys() + group = None + panel = None + elif length == 2: + main, group = covariates.keys() + panel = None + elif length == 3: + main, group, panel = covariates.keys() + + return Covariates(main, group, panel) + +def enforce_dtypes(data: pd.DataFrame, df: pd.DataFrame) -> pd.DataFrame: + """ + Enforce dtypes of the original data to the new data. + """ + observed_dtypes = data.dtypes + for col in df.columns: + if col in observed_dtypes.index: + df[col] = df[col].astype(observed_dtypes[col]) + return df -def get_unique_levels(x): + +def make_group_panel_values( + data: pd.DataFrame, + data_dict: dict, + main: str, + group: Union[str, None], + panel: Union[str, None], + kind: str, + groups_n: int = 5, +) -> dict: + """ + Compute group and panel values based on original data. + """ + + # If available, obtain groups for grouping variable + if group: + group_values = make_group_values(data[group], groups_n) + group_n = len(group_values) + + # If available, obtain groups for panel variable. Same logic than grouping applies + if panel: + panel_values = make_group_values(data[panel], groups_n) + panel_n = len(panel_values) + + main_values = data_dict[main] + main_n = len(main_values) + + if kind == "predictions": + if group and not panel: + main_values = np.tile(main_values, group_n) + group_values = np.repeat(group_values, main_n) + data_dict.update({main: main_values, group: group_values}) + elif not group and panel: + main_values = np.tile(main_values, panel_n) + panel_values = np.repeat(panel_values, main_n) + data_dict.update({main: main_values, panel: panel_values}) + elif group and panel: + if group == panel: + main_values = np.tile(main_values, group_n) + group_values = np.repeat(group_values, main_n) + data_dict.update({main: main_values, group: group_values}) + else: + main_values = np.tile(np.tile(main_values, group_n), panel_n) + group_values = np.tile(np.repeat(group_values, main_n), panel_n) + panel_values = np.repeat(panel_values, main_n * group_n) + data_dict.update({main: main_values, group: group_values, panel: panel_values}) + elif kind == "comparison": + # for comparisons, we need unique values for numeric and categorical + # group/panel covariates since we iterate over pairwise combinations of values + if group and not panel: + data_dict.update({group: np.unique(group_values)}) + elif group and panel: + data_dict.update({group: np.unique(group_values), panel: np.unique(panel_values)}) + + return data_dict + + +def set_default_values(model: Model, data_dict: dict, kind: str): + """ + Set default values for each variable in the model if the user did not + pass them in the data_dict. + """ + assert kind in [ + "comparison", + "predictions", + ], "kind must be either 'comparison' or 'predictions'" + + terms = get_model_terms(model) + + # Get default values for each variable in the model + # pylint: disable=R1702 + for term in terms.values(): + if hasattr(term, "components"): + for component in term.components: + # If the component is a function call, use the argument names + if isinstance(component, Call): + names = [arg.name for arg in component.call.args] + else: + names = [component.name] + for name in names: + if name not in data_dict: + # For numeric predictors, select the mean. + if component.kind == "numeric": + data_dict[name] = np.mean(model.data[name]) + # For categoric predictors, select the most frequent level. + elif component.kind == "categoric": + data_dict[name] = mode(model.data[name]) + + if kind == "comparison": + # if value in dict is not a list then convert to a list + for key, value in data_dict.items(): + if not isinstance(value, (list, np.ndarray)): + data_dict[key] = [value] + return data_dict + elif kind == "predictions": + return data_dict + else: + return None + + +def set_default_contrast_values(model: Model, contrast_predictor: str) -> Union[list, np.ndarray]: + """ + Set the default contrast value for the contrast predictor based on the + contrast predictor dtype. + """ + + def _numeric_difference(x): + """ + Centered difference for numeric predictors results in a default contrast + of a 1 unit increase + """ + return np.array([x - 0.5, x + 0.5]) + + terms = get_model_terms(model) + contrast_dtype = model.data[contrast_predictor].dtype + + # Get default values for each variable in the model + # pylint: disable=R1702 + for term in terms.values(): + if hasattr(term, "components"): + for component in term.components: + # If the component is a function call, use the argument names + if isinstance(component, Call): + names = [arg.name for arg in component.call.args] + else: + names = [component.name] + for name in names: + if name == contrast_predictor: + # For numeric predictors, select the mean. + if component.kind == "numeric": + contrast = _numeric_difference(np.mean(model.data[name])).astype( + contrast_dtype + ) + # For categoric predictors, select the most frequent level. + elif component.kind == "categoric": + contrast = get_unique_levels(model.data[name]) + + return contrast + + +def make_main_values(x: np.ndarray, grid_n: int = 50) -> np.ndarray: + """ + Compuet main values based on original data using a grid of evenly spaced + values for numeric predictors and unique levels for categoric predictors. + """ + if is_numeric_dtype(x): + return np.linspace(np.min(x), np.max(x), grid_n) + elif is_string_dtype(x) or is_categorical_dtype(x): + return np.unique(x) + raise ValueError("Main covariate must be numeric or categoric.") + + +def make_group_values(x: np.ndarray, groups_n: int = 5) -> np.ndarray: + """ + Compute group values based on original data using unique levels for + categoric predictors and quantiles for numeric predictors. + """ + if is_string_dtype(x) or is_categorical_dtype(x): + return np.unique(x) + elif is_numeric_dtype(x): + return np.quantile(x, np.linspace(0, 1, groups_n)) + raise ValueError("Group covariate must be numeric or categoric.") + + +def get_unique_levels(x: np.ndarray) -> Union[list, np.ndarray]: + """ + Get unique levels of a categoric variable. + """ if hasattr(x, "dtype") and hasattr(x.dtype, "categories"): levels = list(x.dtype.categories) else: @@ -9,7 +323,7 @@ def get_unique_levels(x): return levels -def get_group_offset(n, lower=0.05, upper=0.4): +def get_group_offset(n, lower: float = 0.05, upper: float = 0.4) -> np.ndarray: # Complementary log log function, scaled. # See following code to have an idea of how this function looks like # lower, upper = 0.05, 0.4 @@ -22,3 +336,7 @@ def get_group_offset(n, lower=0.05, upper=0.4): # ax.axhline(upper, color="k", ls="--") intercept, slope = 3.25, 1 return lower + np.exp(-np.exp(intercept - slope * n)) * (upper - lower) + + +def identity(x): + return x diff --git a/docs/notebooks/plot_cap.ipynb b/docs/notebooks/plot_cap.ipynb index 403d9b3f3..2a44fbb64 100644 --- a/docs/notebooks/plot_cap.ipynb +++ b/docs/notebooks/plot_cap.ipynb @@ -58,17 +58,29 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "import arviz as az\n", "import bambi as bmb\n", - "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import pandas as pd\n", "\n", - "from bambi.plots import plot_cap" + "from bambi.plots import plot_cap\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" ] }, { @@ -94,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -103,11 +115,54 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 4 jobs)\n", - "NUTS: [mpg_sigma, hp, wt, hp:wt, cyl, gear]\n" + "NUTS: [response_sigma, hp, wt, hp:wt, cyl, gear]\n" ] }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:17<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", @@ -136,43 +191,6 @@ "We can print the Bambi model object to obtain the model components. Below, we see that the Gaussian linear model uses an identity link function that results in no transformation of the linear predictor to the mean of the outcome variable, and the distrbution of the likelihood is Gaussian." ] }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " Formula: mpg ~ 0 + hp * wt + cyl + gear\n", - " Family: gaussian\n", - " Link: mu = identity\n", - " Observations: 32\n", - " Priors: \n", - " target = mu\n", - " Common-level effects\n", - " hp ~ Normal(mu: 0.0, sigma: 0.2198)\n", - " wt ~ Normal(mu: 0.0, sigma: 15.3991)\n", - " hp:wt ~ Normal(mu: 0.0, sigma: 0.0441)\n", - " cyl ~ Normal(mu: [0. 0. 0.], sigma: [31.2239 35.8735 29.8946])\n", - " gear ~ Normal(mu: [0. 0.], sigma: [30.6329 40.8438])\n", - " \n", - " Auxiliary parameters\n", - " mpg_sigma ~ HalfStudentT(nu: 4.0, sigma: 5.932)\n", - "------\n", - "* To see a plot of the priors call the .plot_priors() method.\n", - "* To see a summary or plot of the posterior pass the object returned by .fit() to az.summary() or az.plot_trace()" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model" - ] - }, { "attachments": {}, "cell_type": "markdown", @@ -185,12 +203,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtkAAAFdCAYAAADWhHHNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAABJ0AAASdAHeZh94AABX40lEQVR4nO3deXAc5Z038G/39Bw994yk0S1f8oFlbAwEvLzLQmAhvIGAuV422eyGsGFTMVQolg1JIME211ayQJZNgDewxR5vsvsSU0AtLCEVwCb1vm8Ih0MwNsbIh6xbo7mP7jn7/aNnejT4RiPNSPp+qlySulszj2iP+eqZ5/d7BE3TNBARERERUc2I9R4AEREREdF8w5BNRERERFRjDNlERERERDXGkE1EREREVGMM2URERERENcaQTURERERUYwzZREREREQ1xpBNRERERFRjDNlERERERDUm1XsAjSIajeKNN95Ad3c3rFZrvYdDRERERA0kk8lgcHAQF1xwAbxe7wmvZ8gueeONN7Bx48Z6D4OIiIiIGtgLL7yAq6666oTXMWSXdHd3A9D/w/X29tZ5NERERETUSPr7+7Fx40YjM54IQ3ZJeYlIb28v+vr66jwaIiIiImpEJ7usmIWPREREREQ1xpBNRERERFRjDNlERERERDXGkE1EREREVGMM2URERERENcaQTURERERUYwzZREREREQ1xpBNRERERFRjDNlERERERDXGkE1EREREVGPcVr3O/m//JNw2M7r9Mrx2S72HQ0REREQ1wJBdZzElh4FQGruGY3DLErp9dnT77fA7GLiJiIiI5iqG7AYSV/LYrcSxeyQOp01Ct09Gt9+OZqe13kMjIiIiolPAkN2gkmoeH44m8OFoAg6rCd1+O5Y1O+Gxm+s9NCIiIiI6AYbsOSCVKWDvaAJ7RxNocVnRG3Cix2+HSRTqPTQiIiIiOgqG7DkmmMggmMjg3YEIljTb0RtwwSNzdpuIiIiokTBkz1HZfBEfjSXx0ViSs9tEREREDYYhex6ont12oDfg5Ow2ERERUR0xZM8j+ux2Ah+NVdZud/tkSCbuOUREREQ0mxiy56ny7PbbJgE9fjuWtjgQcNnqPSwiIiKiBaGhpjhff/113HTTTVi1ahUcDgc6Oztx1VVX4d1336267sYbb4QgCEf8WbVqVZ1G3rjyBQ0Hgim8umcC//mHEXwwHEMqk6/3sIiIiIjmtYaayX7iiScQCoVw2223YfXq1QgGg3j44YexYcMG/OpXv8JFF11kXCvLMl5//fWq75dlebaHPKck1TzeH4rh/aEYWt1WLG3hchIiIiKimdBQIfuxxx5DIBCoOnbZZZeht7cXDz74YFXIFkURGzZsmO0hzhvj8QzG4xm8U1pOsoTLSYiIiIhqpqFC9icDNgA4nU6sXr0ag4ODdRjR/JcraNgfTGF/MAWXTcKyFieWtjhgM5vqPTQiIiKiOauhQvbRxGIx7Ny5s2oWGwAURUFbWxuCwSDa29uxceNG3HvvvfD7/Sd8zImJCQSDwapj/f39NR33XJRQ83hvMIpdw1F0++zobXVydpuIiIjoU2j4kH3LLbcglUrh7rvvNo6tW7cO69atw5o1awAAb7zxBn70ox/htddew9tvvw2n03ncx3z88cexdevWGR33XFYoAodCaRwKpeG1m9EbcGJxkwMWiWu3iYiIiE5GQ4fs73//+/j5z3+OH//4xzjrrLOM47fffnvVdZdccgnWr1+P6667Dk899dQR5z9p06ZNuP7666uO9ff3Y+PGjTUb+3wRTefwzqEI3jscxaImO5a3uuB3WOo9LCIiIqKG1rAhe+vWrbj//vvxwAMP4NZbbz3h9VdffTUcDgfefPPNE14bCASOuv6bji1frKzd9jssWN7qxCK/nZ1JiIiIiI6iIUP21q1bsWXLFmzZsgV33XXXSX+fpmkQRYa+mRZOZfG7A2HsHIhgaYsTq9pccFgb8q8SERERUV00XDK67777sGXLFnzve9/D5s2bT/r7nn32WaTTabb1m0W5goaPxhL4eDyBbr8dp7W7uZSEiIiICA0Wsh9++GHcc889uOyyy3D55ZcfsfRjw4YNGBgYwJe+9CX82Z/9GXp7eyEIAt544w38wz/8A/r6+vC1r32tTqNfuIoaMBBKYyCURqvbilXtbnR6uTEQERERLVwNFbJffPFFAMArr7yCV1555YjzmqbB7XajtbUVjzzyCMbHx1EoFLBo0SJ885vfxF133QWHwzHbw6Yp9E1ugvDIZqxqd2FJkwOiKNR7WERERESzqqFC9o4dO054jc/nw3PPPTfzg6FpiSk5/O5AGO8PRbE84MLyViesEje4ISIiooWhoUI2zT9Ktoj3h2LYMxLHsoADK9vccLJIkoiIiOY5ph2aFfmiho/Gktg3nkS3z47T2l1oclrrPSwiIiKiGcGQTbNK04DD4TQOh9NocVlxWrsLXT57vYdFREREVFMM2VQ3wUQGwUQGblnCqjYXljQ7YWKRJBEREc0DDNlUd3Elj7cORvD+UAwrWl3oDThhM7NIkoiIiOYuhmxqGGquUiS5pMWBFQEXPHZzvYdFREREdMoYsqnh5IsaPh5P4uPxJNyyhC6fHV0+Gc0slCQiIqI5giGbGlpcyWOPEseekTjsFhO6fDK6/XYEXFYIAtdvExERUWNiyKY5I50tYN+43gbQKono8Mro9sto98gsmCQiIqKGwpBNc1ImX8TByRQOTqYgmQR0eGR0+WR0+mSYTWK9h0dEREQLHEM2zXn5gmb03pZEAZ0+GYua7OjwyBA5w01ERER1wJBN80q+qGEglMZAKA2LJKLbJ2NJswMBt63eQyMiIqIFhCGb5q1svoj9wRT2B1OwW0zoabJjcZMDfoel3kMjIiKieY4hmxaEdLaAvaMJ7B1NwC1LWNzkwKImO1w29uEmIiKi2mPIpgUnruTx/lAM7w/F4HdY0O3X2wK6GbiJiIioRhiyaUELp7IIp7L4w2AMHtmsB26fHT4uKSEiIqJpYMgmKokpOcSGc/hgOA6nTdI3vvHZ0eLiTpNERER0ahiyiY4iqeaNNdyyRUSXz45FTXYEXOxSQkRERCfGkE10Akq2iI/Hk/h4PAmnTcLSZgcWNzvgtPLlQ0REREfHlEB0CpJqpWgy4LJiSYsDPX47d5kkIiKiKgzZRJ/SRCKDiUQG7x6KoMsnY0mLA21uGwSBu0wSEREtdAzZRNOUL2o4FErjUCgNu8WERU12LG12wmNnS0AiIqKFiiGbqIbS2QI+HE3gw9KmN06rBIdVgsOif263muCwSJAtpnoPlYiIiGYQQzbRDIkrecSV/FHPmUTAXg7eFpMexK0S2j022MwM4ERERHMdQzZRHRSKQELNI6FWh3BRAHr8dixvdbE/NxER0RzGkE3UQIoajPXdfocZvQEXFjfZIbF7CRER0ZzCkE3UoMKpHN46GMZ7g1EsbXFgecAJl43FlERERHMBQzZRg8vmi9g7msBHYwm0e2xY0epCh1eu97CIiIjoOBiyieYITQNGoipGoiqcNgkrWp1Y2uyEReJSEiIiokbDkE00ByXVPHYORPH+UAwrW11Y1e6CVWJXEiIiokbBkE00h+ULGnaPxLFvPIGVbS6sanNzZpuIiKgBMGQTzQO5goYPhuP4aCyBVW1urGxzMWwTERHVEUN2nb2+dwKhZBZdPhldPpndI2hacgUNu4Zj2DsWx2ntbqxoZdgmIiKqB4bsOvu//ZMYjanG1x7ZrAdur4xOnx1dPpk7ANIpyxU0vD8Uw96xBFa1uRi2iYiIZhlDdh3lCkUAgABAKx2LKTnElBx2j8SN65qdVmOmu8sro90rw8zNSegkZPPFqrC9ss3FvztERESzgCG7jswmEd+/YjXGYiqGowqGIgqGImkMRxRElZxx3WQyg8lkBu8NRgHoW2+3uW3GTHeXT0bAZYNJFOr0k1CjK4ftj8YSWNxsR6fXjoDLCpF/Z4iIiGYEQ3YDsJlNWNbixLIWp3EsoeYwHFEwFNWD91BEQTpbAKBvvT0SUzESU/H2If16s0lAh0cP3J0+O7p9MvwOCwSBIYoqMvkiPhpL4qOxpP53xiuj0yujwytzOQkREVENMWQ3KJfNjFXtZqxqdwMANE1DJJ0zZroHIwpGogqypSUnuYKGgXAaA+E0gBAAQDab0GksM9Fnvd0yCytJlytoGAilMRBKQxSAgNuKztLfE4eV/zQQERFNB/9POkcIggC/wwK/w4K1XV4AQFHTEExkjGUmQxEFYzEVBU1f4a3kCuifSKJ/Imk8jtsmoau0zKSzFL5lCwsrF7qiBozFMhiLZfDuQAReuxkdXhke2QyPbIbbJkHiWm4iIqKTxpA9h4mCgFa3Da1uG85a5AMA5AtFjMZUDEUVDJeCdzCRMQor42oee0bj2DNaKaxsclhKa7v18N3BwsoFL5rOIZrOVR1zWE1w28xwyxLctlL4ls3sfkNERHQUDNnzjGQS0e23o9tvB9AEAMjkChiOKRgKK0b4jkwJUKFUFqFUFn8YigHQCytb3TZ0eivBu9XNwsqFLpUpIJUpYDRWfdwiiXDbJLhlMwIuKzp9Mrd4JyKiBY8hewGwmk1Y2uzE0uZKYWUyk9cLK0uz3UNRBalMHoC+dGA0pmI0puKdgQgAQBJLRXKlNoJdPjuanBaILKxc8LL5IiaTWUwmszgQTBm/pHX72eediIgWLobsBcpplbCy1DcZ0AsrY0quan33cFRBJq8XVuaLGg6H0zgcThuPYTOLxmx3p1dGt98Ot01iR5MFbuovaW8fAgIuK3r8dnT5uP6fiIgWDoZsAqAXVnrtFnjtFqzp9ADQCysnk+XCSn2ZyWhMRb6or/BWc0XsD6awP5gyHsdllSodTXx2dHll2NmpYsHSNGA8nsF4PIN3BiJodlrR7ZfR7bOzgwkREc1r/L8cHZMoCAi4bAi4bDizp1RYWSxiPJbBUDRtzHpPxCuFlYlMHnvHEtg7ljAex++w6DPdpR7enezJvCBpGhBMZBBMZLBzIIompwU9fjuWNDu4pISIiOYdhmw6JZIoorPU/u/cJfqxbL6I4XI3k9LOleFU1viecCqLcCqLXcN6xZwAvSdzuaiyy2tHq8cKSWTwXkhCySxCySz+MBhFt9+O3oATrW5bvYdFRERUEwzZNG0WScSSZgeWNDuMY+lMvmq3yqGIgmSpsFJDZQnBu1MKK9s8tinBW0azy8rCygWgqMHYFMctS1jW4uTsNhERzXkM2TQj7FYJK1pdWNFaKayMq3kMhtMYLoXv4agCNVcprCyH8TKrVC6srGwV75HNLKycx+JKHr8/HMX7Q1F0++zobXUi4OLsNhERzT0M2TQrBEHQdw/s9FQVVoaSWX22O6pguLRVfLmwMpMv4sBkCgcmK4WVDqtUaiFY6eHNArr5p1AEDoXSOBRKwyOb0RtwYnGznf23iYhozmA6oboRBQEtLitaXFasLxVWFooaxuOqUVQ5HFUwHldRyt1IZfL4aDyBj8YrhZU+uxmdpU4mXX4ZnR4ZVi41mDdiSg7vDkSMtdtLWxwIuKx8R4OIiBpaQ4Xs119/HT/72c/w//7f/8Pg4CC8Xi/OPvts3HPPPTjrrLOqrt25cyfuvPNOvPnmm5AkCRdddBEeeughLF26tE6jp1owlTa96fDKOGeJH4BeWDka05eSDEbSGI4oCE0prIykc4ikY/hgSmFli8taNdvd5rZB4lbxc1q+qOHgZAoHJ1OwmUV0+ezo9stoddkgcjdSIiJqMA0Vsp944gmEQiHcdtttWL16NYLBIB5++GFs2LABv/rVr3DRRRcBAPbu3YsLL7wQZ5xxBn7xi19AVVXcc889OP/88/Hee++hpaWlzj8J1ZJFErGoyYFFTZXCSiVbmNJGUO9sElcrhZUTiQwmEhnsPBwFoIf3NretKni3sLByzlJzRfRPJNE/kYRVEtHlk9HTZGfgJiKihiFomqad+LLZMTExgUAgUHUsmUyit7cXa9aswauvvgoA+B//439g+/bt2L9/P9xuNwBgYGAAy5cvx+23344f/OAHp/zcu3fvxpo1a/DBBx+gr69v+j/MSXp51yii6dysPd98FlNyla3iS8WV5cLKo7FIIjo85f7devj22VlYOZdZSsWyPU12tLsZuImIqHZONSs21Ez2JwM2ADidTqxevRqDg4MAgHw+j5deegl/+Zd/aQRsAFi0aBE++9nP4vnnn/9UIZvmPo9shkc2Y3WH/vdC0zSEU1kMlma6hyIKRmIKcgX998psvohDoRQOhSqFlXaLqWq3yk6fDJfNXJefh05dNl80lpSYTYK+CZLfjnYPlwsREdHsaqiQfTSxWAw7d+40lors378fiqJg7dq1R1y7du1a/PrXv4aqqrDZjt32a2JiAsFgsOpYf39/bQdOdScIApqcVjQ5rTij2wtAL6ycSKjGMpOhSLqqsDKdLWDfeBL7xpPG43hkc9Uyk06vzB7Oc0CuoBkdSip92PVfnNilhIiIZlrDh+xbbrkFqVQKd999NwAgFAoBAPx+/xHX+v1+aJqGSCSC9vb2Yz7m448/jq1bt87MgKmhmUQB7R4Z7R4Zn1msH8sVihiNKsZulUORNCaTlcLKmJJDTMlh90jcONbitBqBrdtnR5vHBjNnShvW1D7solDZcbTbZ4dsYeAmIqLaa+iQ/f3vfx8///nP8eMf//iI7iLHWzd7ojW1mzZtwvXXX191rL+/Hxs3bvzUY6W5y2wS0dPkQM8nCis/uVV8TKmsnQ8mMwgmM/j9YBQAIArQZ0q9dmPWO+BmYWUjKmrAWCyDsVgG7xyKoMlpQZdPX1bi5tIgIiKqkYYN2Vu3bsX999+PBx54ALfeeqtxvKmpCUBlRnuqcDgMQRDg9XqP+9iBQOCo67+JymSLCb0BJ3oDTuNYQs1VLTMZiihQcgUAenAbiaoYiap465B+fXlNcJfPrhdWemX4HRYWVjaYUDKLUDKLPwzG4LCa4JHN8Not8MpmeO1muG1mFlASEdEpa8iQvXXrVmzZsgVbtmzBXXfdVXVu2bJlkGUZu3btOuL7du3ahd7e3uOuxyb6tFw2M05rN+O09kphZSSdMwL3UCSNkaiKbEHvaDJ1TXCZbC4XVlbCN2dPG0cqU0AqU8BIVDWOiQLgls3wymZ47JUAzp1GiYjoeBru/xL33XcftmzZgu9973vYvHnzEeclScIXvvAFPPfcc/jhD38Il8sFADh8+DC2b9+O22+/fbaHTAuUIAjwOyzwOyxY2+UFoG8VP5HIGN1MhiIKxmIqCqVOmUqugI8nkvh4orqwsvMTW8WzsLJxFDUgms7prTanvIFmNgnw2i3wO8zwO6zwOyxw2yS+U0FERAAaLGQ//PDDuOeee3DZZZfh8ssvx5tvvll1fsOGDQD0me7PfOYzuOKKK/Cd73zH2IymubkZd9xxRz2GTgRA3yq+zW1Dm9uGsxbpx/KFIkZjKoZKa7wHIwomExmUG9SXCyv3jFYKK5udFiNwd3lltHtlFlY2mFxBQzCRQTCRAaD/0iSZBPjsFuOXLwZvIqKFq6FC9osvvggAeOWVV/DKK68ccb68b86qVauwY8cOfPvb38Z1111Xta06d3ukRiOZRHT77ej22wHoNQVqroCRKd1MhqJK1aZEk8ksJpNZvDelsLL1EztWBlw2mLhWuKHkq4K3bmrwbnJY0OKycqkJEdEC0FD/0u/YseOkrz3rrLOMHSCJ5hqb2YSlLU4sbakUViYzeWOmu7xzZSpbKawcjakYjal4+1AEgL5cod3YsVIP3k0srGw4RwvefocF3X52NCEims8aKmQTLWROq4SVbW6sbKsUVkaVXFU3k5Gogky+Ulh5OJzG4XAa5cXCNrNo7FbZVQrfHpkhrtGEU1mEU3pHE6/djG6fHd1+GV67pd5DIyKiGmHIJmpQgqAvM/DZLTi90wNAL6ycTGT04B3Vg/doTEWhtGWlmiuifyKJ/imFlW6bZMx0d5VaCnIDlsahF1XGsGs4BpdN0pcW+WQ0Oa31HhoREU0DQzbRHCIKAgJuGwJuG85c5AMA5ItFjMX0reKHIwoGI2kEpxRWxtU84qNxfDilsLLJYdF7d5dmvTu8MiwSCyvrLaHmsWckjj0jcTisJn1XSr8Mn93CwlciojmGIZtojpPE0hIRn904lsnrvZ6n9vCOTCmsDKWyCKWyeH8oBkAvrAy4bFVbxbe6WVhZT6lMAR+NJfDRWAKAvhTIaZXgtElwWc1w2iQ4rRJcNoktH4mIGhBDNtE8ZJVMWNLswJLmylbxqUzeWGaiz3grSGXyAEpbjcdVjMVVvDOgF1ZKooB2j63SStBnR5PTwq3i60TNFaHm9K4znySZBLisEtyyWe9i4rTAb7dA4uw3EVHdMGQTLRAOq4SVbS6sbNM3cNI0DTGleqv44SmFlfmihsFSGC+zmUV0ePWZ7vIGOh7ZzI4mdZYv6LuPRtI5DJR2GBUFfaMjPXRb0ey08F4REc2imoTsYDCIRx55BDt27EAoFMLzzz+Pvr4+/PSnP8U555yD9evX1+JpiKiGBEHfsdBrt2DN1MLKZMaY6R6OpDEaU5GfUlh5IJjCgWDKeBynVaraKr7LK8POPtB1V9RgBO/9pfsliQJ8pZnuZocVfqcFTt4rIqIZMe1/XQ8ePIj/9t/+G2KxGNatW4f9+/cjk9H7wb7//vt488038c///M/THigRzTxREBBw2RBw2bC+p1JYOR7PGOu7hyMKxuOqUViZzOSxdyyBvaW1wwDgs5urlpl0eG2wSlw3XG/54tSe3fr9kkQBjvJab5sEV+lzp1WCwyJB5Lp8IqJPZdoh+84774TX68U777yDQCAAi6XS5/WP//iPsXnz5uk+BRHVkSSK6PTK6PTKOHeJfiybL5Z2rNR3qxyKKAinKmuF9RlUvS0dAAgAWlxWfZlJada7zWODJHLNcL3li/qyoZiSO+KcKAB2a3XwdpbWfrusDOBERMcz7ZD92muv4YknnkBHRwcKhULVufb2doyMjEz3KYiowVgkEYubHVg8pbAync1XLTMZiipIqHphpQZgIpHBRCKDdw/rhZUmo7BSRpdXD98tLisLKxtIUQOSah5JNQ/Eqs+JAuC0SXDbzPDIZrhlM9w2PYCz3SARUQ1Ctqqq8Pv9Rz2XSqUgcqaKaEGwWyQsb3VheavLOKYXVlaWmQxF01BzemFloagZRZdAGABglfTCyqnru712Fus1oqIGxJU84kq+dA8r7BYT3LKkh2+bGS0uK3ezJKIFZ9ohe+XKlXj11VdxySWXHHHuN7/5DdasWTPdpyCiOcojm+GRPejrqBRWhpNZY7fK8lbx5cLKTL6Ig5MpHJysFFY6LPqmLJ1TiitZrNfY0tkC0tkCxmIZ45jDakK7R0a7x4Y2j23as93FooZEJm+sKSciajTT/pfp5ptvxt/8zd+go6MDf/7nfw4AyGazePbZZ/H444/jJz/5ybQHSUTzgygIaHZZ0eyy4oxuvbCyUNQwHleNme6hUmFlKXcjlS3go/EEPhqvFFZ67WZji/gun75e3MoNWRpaKlNA/0QS/RNJiIK+Rr/DK6PDI8NjNx/1ezRNQypbQELNIaHmkVBziKt5JNQ8Upk8tNLfEZMIOK1mvXDTJsFlq3xutzCAE1F9TPtfn02bNuG9997D7bffjjvuuAOAXvCoaRpuvvlmfOUrX5n2IIlo/jKJgh62vDI+A33pWTZfxGhMn+kejioYDKcRmlJYGU3nEE3n8MGIvlW8AKDZZUW3T0ZnaZlJu8fGzVgaVFEDxuMZjMcz+D2ixiy3z25GMpMvBeo8kpkcCsUTP16hiGMWb0qiUOmcYtPXjTe7rHDbjh7siYhqpSa/4j/55JO46aab8F//9V8YHx9Hc3MzrrjiCpx33nm1eHgiWmAskohFTQ4saqoUVirZAobLHU1Km+fEpxRWllvT7TwcBQCYBAFt5cLK0jITFlY2pvIs90zIFzXjlzKgemOlZqcVLS79j99uYbcUIqqpmr2PtmHDBmzYsKFWD0dEVEW2mNAbcKI34DSOxdWcvswkUlnjreT0LkcFTcNwVJ8J/91B/XqLJKLDI1cFbx8LKxckNVecUnirz3j7HRa0lJYztTitsEh8J4SIPr1ph+yRkREkEgmsXLkSAFAoFPDwww9j586duPTSS3HTTTdNe5BEREfjtpnhbjfjtHY3AH0NbziVxVBUKbUTTGMkqiBX0BfvZvNFHAqlcChUKay0W0yldd320nITGS4uJVhw8kXNaDNZ5rWb0ey0wmWTYDObYDOLsEr6R5tk4sw3ER3XtEP217/+dfT09OCxxx4DANx3332499574fV6sW3bNlgsFnz5y1+e9kCJiE5EEAQ0Oa1oclqxrssLQC+sDCYqO1YORdMYi1UKK9PZAvaNJ7FvvLJcwSObK20ES4WVNhZWLjiVZSZHZzYJpfBtglUSjSAum03wOSxcgkK0wE07ZO/cubOquPGpp57C7bffjocffhjf+MY38NhjjzFkE1HdmER9bXabx4azF+vHcoUiRmMqhiJpYwOdyWRlBrNcRLe7VFgJAM1OqzHT3eWzo70GbehobssVNOQKeWPTpU8SBcDnsKDZaUGTw4omp+WU3iUpFjUouQJS2TzUbBGpbB7ZfBEe2QyfwwKPzHdciBrZtEN2KBRCW1sbAODDDz/E6OgobrzxRgDAtddei2eeeWa6T0FEVFNmk4gevx09frtxTM2VCysra7yndquYTGYwmczg94NRAHqAanPbKrPdPhkBlw0mzlxSSVEDQsksQsksAP2dEoskoslpQXMpdEuigHRWD9JKqb94OluAkstDzRWNNoVHI5kE+O0W+J0W4yO7phA1jmmHbI/Hg4mJCQD65jN+vx+nn346AP2t22w2e7xvJyJqCDazCctanFjWUimsTJQKKwcjCoZLPbzTWb2wsqgBIzEVIzEVbx3Srzeb9HaEU3t4+x0WFlaSIZsvYjSqYjSqTvux8oUj15GbTXoBp89hQVPpo8sq1ezvYLGoIZMvIpMvQM0VIQqAwyrBbjHx7znRJ0w7ZJ9zzjn4wQ9+ALPZjEcffRSXXnqpce7AgQPo6OiY7lMQEdWFy2bGqnYzVk0prIykc1XdTEaiCrKlZs65goaBUBoDoTSAEABANpuMme7u0s6VnG2kmZIraEYP8qlMIiCJIiSTALNJhEkUYDYJ+jFRgGQqnRP1c7lCEWquUArU+udqrmAUEX+SSQTsFknvSW6V4LBKcFr1/uROq8Se9bQgTTtk33fffbjkkktw1VVXwefz4e677zbOvfDCCzjnnHOm+xRERA1BEPRZQr/DgrWlwsqips8mDk8J3mMxFYXS+/xKroCPJ5L4eEofaLdNMma6u3x2dHplyBYWVtLMKRSBQrGITB4ACjPy+OVNhEaPct5mFuEsBW8IADS9v72mARq00kf9F1kN+nlAf33JZhPaSxtMsQCZ5pJph+wzzjgDAwMD2Lt3L3p7e+F2u41zmzZtwvLly6f7FEREDUsUBLS5bWhz23DWIv1YvlxYGVWM8B1MZMq5AXE1jz2jcewZrRRWNjksVR1N2j0y+zTTvKHmilBzWUwmP90S0kOhNAQB8Nkt6PDa0OGV0cSlWNTgarIZjd1ux5lnnnnE8csvv7wWD09ENKdIJhHdfju6/XYATQCAzNTCylL4jkxpDxdKZRFKZfGHoRgAvbCy1W1D55T13a1uFlbSwqVpQDiVRTiVxQfDcVglEe0eG2e5qWHVJGRrmoa3334bAwMDUBTliPN/+Zd/WYunISKas6xmE5a2OLF0SmFlMpOvWmYyFEkjNaWwcjSmYjSm4p2BCAB9V8IO75QdK712+J0WbhVPC1ImX8ShUBqHQmkAgN+hz3K3eWzwyha+E0R1N+2QvW/fPlx55ZX4+OOPoR2l15AgCAzZRERH4bRKWNnmxsq2SmFlVMlhKKLPdA+WCiszeb2wMl/UcDicxuFw2ngMm1msmu3u8tnhttWumwTRXDF1lhsArJKoF2LaJLisZr0Is1SIyVlvmg3TDtm33HILVFXFM888g7Vr18JqtdZiXEREC44gCPDZLfDZLTi90wNAL/yaTGQwFK307x6NqSiUtqxUc0XsD6awP1jZKt5llUodTezGrLfdUpM3LonmjEy+iIzRp7ya2STo4dtmhtMqwWE1wWIywSzp3VfMJhFWSTQ6sRB9GtP+V/ett97CU089heuuu64W41lwljQ7kCsUIQoCJJMAkyDAJOp/ph4TRQFFTUOhqCFf0D8Wpnxd1DTkixoKxaJ+vnSuUNRK34cpn1c+Tj1PRI1HFAQE3DYE3Dac2eMDAOSLRYzHMhgs7Vg5FE1jIl4prExk8vhwLIEPxxLG4/jLhZVePXx3ellYSQtXrqAhnMohnMqd8FqTCCN4WyQRZlMliFd/Xv21pdQW0VIK67TwTDtkO53Oqo4idGpOa2+c/3aFooZcoWhsNJDJFZEtFJEt9UnN5ArVX5euKR5nRzIiqj1JFNFZ6r1dlskXMBJVjdnu4aiCcKoyg1d+K/39UmGlgFJh5ZT13a0eKySRYYBoqnL7QzX36WejRAGwmkVYJROsUumjWax8LolV5zUAhdKEWb5YrJpgyxfLH4vGZJkGwGISYTPr328z649vk0z8ZbqOph2yv/rVr+Lf//3fcdlll9ViPFRH+gy6qbRW7eQ3y1CyBSQzeaQyeaSyeaQyhdLHPNKZAvJM4UQzziqZsKTZgSXNDuNYKpMvdTSpFFcm9UbJ0ACMxVWMxVW8O6Wwst1jQ6fPju5SiG92WllYSTRNRQ1QskUo2dl/23hqwLeZRUiiCFEQIIow3ikXhfI76JjyuQB9Al4wQn2+oIf8fKFoBP6q46V31AUIxsZH5U2P9HcCBGNTJH2mv3K++nH0z3OFYun5qp+nUCzisjXts/7f8lRNO2SvWbMG//Ef/4Err7wSX/jCF9DU1HTENddcc810n4YamGwxQbaY0OI6+np8NVfQA3e2UPpT/bmSLXA2HIDDqm9LnM7k+d+DasJhlbCi1YUVrS4AemFlrFxYWQrfw1HFmKHLFzUMlraRf7P0GFapXFhZKa70yGYWVhLNEfUM+AvdtEP2l770JQDAwYMH8dJLLx1xXhAEFAq1312K5g6bWZ8dP/LXrwo1p4fuVCYPpfR5JleAIAgQBP2t7U9+LgqAgNKx0uflncMAvWCsvItY+XNAQ1Er7TKmlT+vrGHXtMra9WLpfPnrbL54zC2FT5Yg6B0lPLIZbtkMT+mP21a97bCS1d8NSJfeFSj/QpLK6B+n87YlLVyCIMBrt8Brt2DNlMLKUDKrz3ZHFQyXOpqU34HK5Is4MJnCgclKYaXDKhkz3V1ePXg7rCysJCKaatr/Km7fvr0W46AFrhzE/Q5LvYdyXMWihmyhiEyutCa9tDZdzenr1LP5yvFCUYPbZoZbloww7bKZT6pSvfzuAJxHP18oakhn80hm8gin9Or5UCrDmQo6ZaIgoMVlRYvLivWlwspCUcN4XDV6dw9HFYzHVeMdllQmj71jCeydUljps5uNme5On4xOrwyrxDZpRLRwTTtkX3DBBbUYB9GcIIoCbJ9i3XqtmUQBLpse2ts9leK3VCaPUDKLyVQGoWQWkVSWa+LplJlKm950eGWcs8QPAMjmixiNVTbNGYooCE0prIykc4ikY9g1XCmsbHFZp/TvltHmtlW9Y0NENJ/V7P29RCKB3/72twiFQmhubsaGDRvgcrlq9fBEdBIcVgkOq4SeJjsAfeY9quQQSmYwWZrtTqrTX/MtmQSjh6zFaGslQtM0JEvr75VcAUfZn4rmKIskYlGTA4uaKoWVSraAoajeRnCwtIFOXK0UVk4kMphIZLDzsF5YaSoXVnpldPvs6PTJaHGxsJKI5qeahOyHHnoIW7duRTqdNnZ9dDgc2Lp1K/7mb/6mFk9BRJ+CKArwOyzwOyxY3lo5XpxaFT6lcrtgfK6vUTdP6fFqkUqB2iRCPIklL8WiZqwnT5Y6zegBXF/mwoLXuU+2mLA84MLyQGVCJV4qrCyv8R6KpI0agkJRM7qc/O5gGIAe3ju95f7devj22llYSURz37RD9r/927/hzjvvxH//7/8dN954Izo6OjAyMoJ//dd/xbe+9S20tLTgL/7iL2oxViKqEVEUYBEFWDBzb92LU5a0tB7lvKZpSGcL+pryVBbh0hKX6RaXUn25ZTNWy2as7qhsFR9OZY2Z7qGIgpGYYtznbL6Ig5MpHJxSWGm3mKq6mXT57HCysJKI5hhB06b3hu769evR19eHn/3sZ0ec+/KXv4w9e/Zg586d03mKWbF7926sWbMGH3zwAfr6+uo9HKIFK6bkShun6EtcouksdySdZwpFDRMJ1ZjVHo6kMTalsPJovLLZmOkuF1bqtRFEtBB96dyeWX/OU82K054a2Lt3L/7u7/7uqOe+/OUv4+qrr57uUxDRAlLuxFLeVGXquvJQSg/dcTWPPGe85yx9bbaMdo+MzyzWj+UKRYxGldISE/3PZDJjfE9UySGq5LB7JA5AL6xsdlqNosounx1tHhu3ryaihjHtkC3LMsLh8FHPhcNhyLJ81HNERCejal35lONKtoCEmkNczSOu5pCc8pFrveces0lET5MDPZ8orByOlpaZlMJ3TMkB0Asrg8kMgskMfj8YBaDvXtfqKXU08erBO+BmYSUR1ce0Q/b555+PLVu24MILL0RHR4dxfGxsDPfeey/+5E/+ZLpPQUR0hHIv8YC7+ni5w0miFLpj6Rxiih7Gs3muO5lLZIsJvQEnegOVhvEJNWfMdJdbCSo5fcOzgqZhJKpiJKrirdL1ZpPejrC8zKTLK8PvsLCwkohm3LRD9oMPPojzzjsPvb29uPjii9He3o7R0VG8/vrrMJvNeO6552oxTiKikyIIlYLLDlS/k6ZkC3rwVkrBu/SRO2jOHS6bGae1m3Fae6WwMpLOGYG7vHlOubAyV9AwEEpjIJQ2HkM2m6qWmXT6ZLht9et7T0Tz07RDdl9fH95++21s3rwZ27dvRygUQlNTEzZu3IjNmzdjxYoVtRgnEdG0lWe/W922quOZfAExJYdUpgA1V9rJs/RRnfKRnU8ajyBUlhOt7fIC0LeKn0hkMBSubBU/GlOMZURKroCPJ5L4eCJpPI5HNuutBKd0NWFhJRFNR016Iq1YsQL/8R//UYuHIiKadVbJhIDLBJxg/6xiUdMDeL4SvJVcAelsAWpW/5jO6Z9zp836EQUBbW4b2tw2nF06lisUMRZTjZnuwYiCyUQG5btUfndjz2jceJxmp6XSRtAro90rs7CSiE5aTRuPjoyMGDPZU9dnExHNB6IoGLPhJ5LNF6FkC0jn9I130ll9ljyu5hBMZNiWcJaZTSK6/XZ0++3GMTVXLqysrO+OlgorAWAymcVkMov3SoWVogC0um1VW8UHXDaYTmJzJiJaeGoSsp977jl897vfRX9/v3Fs2bJlePDBB3HdddfV4imIiOYUi6TvkunBkWt984UixhMZjMUUjERVJEpbkdPssplNWNbixLKWSmFlMpM3Anc5fKeyemFlUQNGYypGYyrePqRfbzbp7Qi7fTI6S+G7iYWVRIQahOxnnnkGX/ziF7Fq1Srcc889aGtrw+joKJ555hnccMMN+Pd//3fccMMNtRgrEdG8IJn0rcQ7vTLOWqQHu3LgHo+rXPtdR06rhFVtbqxqqxRWRtM5Y4v4oYiC4ahidKrJFTQcDqdxOJwGEAIA2MwiuryV2e5Onx0emYWVRAvNtHd87Ovrw+LFi/Hiiy9CFCtr1YrFIi6//HIcPnwYu3fvnvZAZxp3fCSiRlAsaphMZTAa1WdMw6lsvYdEn1DUNAQTGX2mO6oH79GYisJx1uG7bFLV+u5Onwy7hVvFE31aC2LHx/379+OHP/xhVcAGAFEUsWnTJlx//fWn9HiJRAL33Xcf3nvvPfz+97/H5OQkNm/ejC1btlRdd+ONN+Jf//Vfj/j+lStXYu/evaf8cxARNQJRFBBw2RBw2bCuW183HFdySJR6fyfVPJKZHBJqnjPedSIKAlrdNrS6bThzkQ8AkC+WCysrPbyDUworE2oeH47G8eGUwkq/w1LpZuKV0eGVYZFYWEk0X0w7ZC9atAjpdPqo59LpNLq7u0/p8UKhEJ588kmsW7cOGzduxD/90z8d81pZlvH6668fcYyIaL6wmU2wmU0IHOVcJl+YErzziKZzGI+ryHDTnVkniWJpprpSWJnJFzASVat6eEfSlcLKcCqLcCqL94diAPTCyoDLVlpiom+g0+pmYSXRXDXtkH3HHXfg3nvvxWc/+1k0NzcbxycmJnD//ffjb//2b0/p8RYtWoRIJAJBEDA5OXnckC2KIjZs2PCpx05ENJdZJROsThOanVbjmKZpCKeyGI2pGIupmExmuM18nVglE5Y0O7CkubJVfCqT1wN3NF0qrFSQzOiFr0UNGIurGIureGcgAgCQRAHtnqkdTexoclq4VTzRHDDtkP3BBx8gHo9j8eLFuPjii9HW1oaxsTG89tpraG5uxu7du/HNb34TgL5pwKOPPnrcx2NFNhHRpycIApqcVjQ5rVjT6UGuUMREqZPJaExFXGEnk3pyWCWsbHNhZZvelF3TNMSUKVvFl8J3+d2IfFHDYETv611mM4uVreJLG+h4ZDP//0nUYKYdsn/yk58Yn7/44otV5w4fPlx1/mRC9qlQFAVtbW0IBoNob2/Hxo0bce+998Lv99fsOYiI5jLzlE4mgD6TOhbXZ7nHYlxaUm+CIMBrt8Brt2BNpweAXlg5mdQLKwcjCoYjaYzGVGODIzVXxIFgCgeCKeNxnFapaqv4Lq8Mu5WFlUT1NO1XYLFYn3+g161bh3Xr1mHNmjUAgDfeeAM/+tGP8Nprr+Htt9+G0+k85vdOTEwgGAxWHZva45uIaL5yWKWq3tCxdA7BZAbBRAaTyQx7djcAUagUv67vqRRWjsczVT28x+OqUViZzOSxdyyBvWMJ43H8DkvVVvGdLKwkmlVz9tfc22+/verrSy65BOvXr8d1112Hp5566ojzUz3++OPYunXrTA+RiKjheexmeOxm9Ab00K3mCphMZjCZzCKYyCCSynKL+AYgiZV3JM5doh/L5oulHSvTpT7eSlXLx3Jh5a5hvbBSABBwW/Ue3n4ZXV47Wj1WSCKDN9FMmHbIHhkZQSKRwMqVKwEA+XwejzzyCHbu3IlLL70UN91007QHebKuvvpqOBwOvPnmm8e97mitBfv7+7Fx48YZHB0RUeOzmU1VXTKKRQ3hdFYP3oksgkkVSpZLTBqBRRKPKKxMZ/JG4B4uzXonSoWVGoDxeAbj8QzePVwprGybWljpldHssrKwkqgGph2yv/71r6OnpwePPfYYAOD+++/HvffeC6/Xi23btsFiseDLX/7ytAd6sjRNO6Jn9ycFAgEEAkdriEVERFOJooBmp1XvYNKmH4speqvAsRh3qGw0dquEFa0urGitFFbG1XxVG8HhqAI1VymsLBddllkl0VhmUt4q3svCSqJTNu2QvXPnTnzlK18xvi4v1Xj44YfxjW98A4899tishexnn30W6XSabf2IiGaQRzbDI5uxotUFTdMQSmUxHtcDdzCRQYET3Q1DEITS/fKgr6NSWBlOZjEUTZcKKxWMRBVjWVAmX8SByRQOTFYKKx1WCV3G+m49fDtZWEl0XNN+hYRCIbS16dMbH374IUZHR3HjjTcCAK699lo888wzp/yYv/zlL5FKpZBI6AUce/bswbPPPgsA+PznP49gMIgvfelL+LM/+zP09vZCEAS88cYb+Id/+Af09fXha1/72nR/LCIiOgmCUJnp7uvwoFDUO2OMlma5w6ksNE50NxRRENDssqLZZcUZ3XphZaGoYTyuVs12j8dVo8d6KpPHR+MJfDReKaz02c36TLdXRpdfRqdHhtVsqsePRNSQph2yPR4PJiYmAAC/+c1v4Pf7cfrppwPQ//HNZrPH+/aj+sY3voGBgQHj623btmHbtm0AgIMHD8Lj8aC1tRWPPPIIxsfHUSgUsGjRInzzm9/EXXfdBYfDcayHJiKiGWQSK1uOA3px3sHJFPaOxZHKFOo8OjoWkyigo7S1+zlL9Da42XwRo7HKNvFDEQWhKYWVkXQOkXQMH0wprGxxWY2Z7m6fjDa3DZKJhZW0ME07ZJ9zzjn4wQ9+ALPZjEcffRSXXnqpce7AgQPo6Og45cc8dOjQCa957rnnTvlxiYhodlkkESvbXFgecOJwOI29Y3GEU7kTfyPVnUUSsajJgUVNlYkrJVuo2q1yKJJGXK0UVk4kMphIZLDzcBQAYBLKhZWVZSYBFlbSAjHtkH3ffffhkksuwVVXXQWfz4e7777bOPfCCy/gnHPOme5TEBHRHCeKAhY3O7C42YGxmIoPx+IYjar1HhadItliwvKAC8sDLuNYvLxj5ZTwreT0dy0Kmqa3GYwq+N1B/XqLSd+xcurmOT47Cytp/pl2yD7jjDMwMDCAvXv3ore3F2632zi3adMmLF++fLpPQURE80ibx4Y2jw3RdBYfjiYwEEqBrbjnLrdsxmrZjNUd+v//NU1DOJWtWmYyElOMLjTZQhGHQikcClUKK+0Wkz7T7bUb4dtlM9fl5yGqlZqUBtvtdpx55plHHL/88str8fBERDQPee0W/NGyJqzr9mDvmB62s/kiu5PMcYIgoMlpRZPTinXdXgB6YeVEQq1aZjI2pbAynS1g33gS+8aTxuN4ZLPRu7vLr+9YaWNhJc0hNQnZwWAQjzzyCHbs2IFQKITnn38efX19+OlPf4pzzjkH69evr8XTEBHRPGS3SDizx4czS1uIF4sa8kUN+WJR/1gofV6Y8nlRQ65QxEQig7GYyg4mDc4kCmj3yGj3yDh7sX4sVyhiNKZO6eGtYDKZMb4npuQQU3LYPRI3jjU7rej2yegsLTNp99hgZmElNahph+yDBw/ivPPOQzwex7p167B//35kMvqL5P3338ebb76Jf/7nf572QImIaGEQRQEWUYAFJw5PfdCL8Q6FUjg0mUIkzaLKucJsEtHjt6PHbzeOqbkChqMKhsKVreJjSuWeTiYzmExm8PvBKABAFPTlR13GMhM7WlxWmESu76b6m3bIvvPOO+Hz+fDuu+8iEAjAYrEY5/74j/8Ymzdvnu5TEBERHZNsMeG0djdOa3cjms7iwGQKA6EUt3+fg2xmE5a1OLGsxWkcS6g5Y6Z7OKrPeqezemFlUQNGoipGoireOqRfbzbp7QjLy0y6vDL8DgsLK2nWTTtkv/baa3jiiSfQ0dGBQqG6B2p7eztGRkam+xREREQnxWu34MweC9Z3ezEWV3EwmMJQpLKbIc09LpsZp7WbcVp7pbAyks5VLTMZiSrIlhbz5woaBkJpDITSwP4QAEA2lworfTK6fXZ0+mS4WVhJM2zaIVtVVfj9/qOeS6VSEEWulSIiotklCJU1wLlCEYPhNA5OpjCRyHD99hwnCAL8Dgv8DgvWdnkB6FvFTyQyGJ4SvMdiKgqlm63kCvh4IomPJyqFlW6bhC6f3QjfXV47ZAsLK6l2ph2yV65ciVdffRWXXHLJEed+85vfYM2aNdN9CiIiok/NbBKxtMWJpS1OJDN57B2N40AwxdnteUQUBLS5bWhz23DWIv1YvlxYGVWM8B1MZFC+63E1jz2jcewZrRRWNjksxtruLp++AyYLK+nTmnbIvvnmm3H77bejo6MDf/7nfw4AyGazePbZZ/H444/jJz/5ybQHSUREVAtOq4SzF/uxptODfeMJ7BtPIpvn2u35SDKJ6Pbb0e23A2gCAGTKhZURxQjfU4tlQ6ksQqks/jCkbxUvCkCr24ZOb2WZSavbxsJKOinTDtmbNm3Ce++9h9tvvx133HEHAL3gUdM03HzzzfjKV74y7UESERHVks1swtouL1a3u9EfTOKjsQRSmcKJv5HmNKvZZLyrUZbM5KuWmQxF0khNKawcjakYjal4ZyACAJBEoXrHSq8dfqeFW8XTEaYVshVFQW9vL/7n//yf+Ku/+iu8+OKLmJiYQHNzM6644gqcd955tRonERFRzUkmEava3FgRcOFQKIUPRxNVLeNo/nNaJaxsc2NlW6WwMlraKn44ksZgqbAyU3rHI1/UcDicxuFw2ngMm1lEl9de6t+tLzfxyCysXOimFbJlWYaiKHA4HDj33HNx7rnn1mpcREREs0YUBWOGcziqYM9IHMFE5sTfSPOOIAjw2S3w2S04vdMDQC+snExkSstM9Fnv0ZiKQmldv5oroj+YRH+wUljpskno8sro9FW2irdbarIHIM0R077bF198MV599VVcdNFFtRgPERFRXXV6ZXR6ZQQTGewZjWMkqrAjyQInCgICbhsCbhvOXKTvTJovFjEWU0sz3nr4nohXCisTah4fjiXw4VjCeBx/ubDSq892d3hlWCQWVs5X0w7Zd911F6699lrYbDZcc801aG9vP6Lh+7Fa/BERETWqFpcVF7haoGQLGAinMBBKI5TM1ntY1CAkUSx1IansWJnJFzASnbpVfHVhZTiVRTiVxfulwkoBpcLKKctM2lhYOW8Imja938+n9sE+1m5Kn9ykphHt3r0ba9aswQcffIC+vr56D4eIiBpQMpPHQEgP3FFu4U4nIZXJlzqaVIork5n8Ma+XRAHtHhs6fXZ0l3p4NzutLKz8hC+d2zPrz3mqWXHaM9n33HMPtyolIqIFwWmV0NfhQV+HBzElZwTuhHrs0EQLm8MqYUWrCytaXQD0wsqYUtkqfiiaxnCkurByMKJgMKLgzdJjWCURnd5K/+4unwyPbGb+anDTDtlbtmypwTCIiIjmFo9sxtouL9Z2eRFOZTEQSuFwOM1WgHRcgiDAa7fAa7dgzZTCylAyW7XMZDSmGhsmZfJFHJhM4cBkyngch1UyZrq7vHr4dlhZWNlIeDeIiIimqbzN9/oeHybiKj4cS2A4otR7WDRHiIKAFpcVLS4r1vfohZWFooaxuL6+e7g06z0eV43CylQmj71jCeydUljps5urtorv9MqwStwqvl4YsomIiGqo3IUils5h92gMh0NpcAd3OlUmUTA63WCJfiybL2Ikqu9WWQ7foVSlGDeSziGSjmHXcKWwssVlrVpm0uaxQRLZ0WQ2MGQTERHNAI/djPOWNWNdVx57x+LYP5Ey3v4n+jQskojFzQ4sbnYYx9LZfKmFYGXHynKNgAZgIpHBRCKDnYf1HStN5cLKKWu8W1wsrJwJDNlEREQzyGGVcNYiP/o6PNg3nsC+8SSypSI3oumyWyQsb3VheamwEgBiSq56q/hoGmpO/ztXKGrG8d8dDAPQw3unt9JGsMsrw2tnYeV0MWQTERHNApvZhLVdXqxud6M/mMTe0QTSWRZJUu15ZDM8sgerOyqFleFUtqqN4GhMQa6gv7OSzRdxcDKFg1MLKy0mdPmqt4p3srDylPC/FhER0SySTCJWtbmxIuBCKJVFNK1vUBJJ5xBTsihwkptqTBQENDutaHZacUZ3pbByIqEaS0zKhZXlFU2pbAEfjSfw0XilsNJrNxu7VZYLK21mFlYeC0M2ERFRHYhipaNEWbGoIa7mEEnnEC4F8Eg6x+UlVHP62mwZ7R4Zn1ms78ydKxQxGq1e3z05ZZfTaDqHaDqHD0biAPTCymaXtRS8SztWemwwm1hYCTBkExERNQxRrPRQXjKluC2ZySOSymIymcH+YIqhm2aE2SSip8mBnqbK3z0lW6jasXI4qiCm6LudagCCiQyCiQx+PxgFAJgEAW0efat4vY+3HYEFWljJkE1ERNTgnFYJTquEbr8dazr1AsqPxhJGMRvRTJEtJvQGnOgNOI1jcTVX6t1dWeOt5PT6goKmYTiqh/G3DurXW0wiOry2Ka0E7fAtgMJKhmwiIqI5xGwS0dfhwcpWF/YHU/hwNM4CSppVbpsZ7nYzTmt3A9C3ig+nshiKKkb4Ho5OKawsFHEolMahUNp4DLvFpG+a46308HbZzHX5eWYKQzYREdEcJJlErGxzYXnAiQOTKewZjSNZ6o9MNJsEQUCT04ompxXrurwA9MLKYCKjz3aXlpuMxSqFlelsAfvGk9g3njQexyOb9cDt1ZeZdPnmdmElQzYREdEcJooCegNOLGtxYCCUxu6RuLFmlqheTKK+NrvNY8PZpWO5QhFjMbVqmclkMmNsFR9TcogpOewuFVYCQLPTasx0d3lltHvlOVNYyZBNREQ0DwiCYOwGOBhOY/dIDOEUwzY1DrNJRLffjm6/3Tim5vTCyuGIgsHSVvHRKb8kTiYzmExm8F6psFIUgFa3Decvb656nEbEkE1ERDTPlIPMSFTBR+MJjMVUaNzRnRqQzWzCshYnlrVUCisTaq7U0aRSXFmuOyhqwHhcrWp92agYsomIiOapDq+MDq8MJVvAQDiFg8EUImnOblNjc9nMWNVmxqq2SmFlJJ3TCyojCtR8YU6s1WbIJiIimudkiwmr2txY1eZGNJ3FwckUDoVSULJsAUiNTxAE+B0W+B0WrC0VVs4FDNlEREQLiNduwfoeC87o9mIsruLgZApDYQX5IteTENUSQzYREdECJAiVbbVzi4sYDKdxKJTCeDzD9dtENcCQTUREtMCZTSKWtjixtMUJJVvAeFxFMJnBRDzDdoBEnxJDNhERERlki8loBQjoLdaCiQyCyQyCiQwiqSy4soToxBiyiYiI6JhsZlNVb+N8oYjJZBYTCRWHw2nEFe4ySXQ0DNlERER00iSTaOzkt7bLW9r4Jo5wKlvvoRE1FIZsIiIi+tTKs9xjMRV7RmMYi2XqPSSihsCQTURERNNWnt0OJTPYMxrHUERhlxJa0BiyiYiIqGaanFacv7wFMSWHD0fjODSZYqEkLUhivQdARERE849HNmPD0iZceUYHVra5IIlCvYdENKs4k01EREQzxm6RcNYiH/o63OifSOLgZAoJlR1JaP5jyCYiIqIZZzObsKbTgzWdHoRTWQyEUjgcTiOVKdR7aEQzgiGbiIiIZpXfYYHfYcH6Hh+CiQwOh/XArWSL9R4aUc0wZBMREVHdtLisaHFZcWaPDxOJDAZCaQyG08jkGbhpbmPIJiIioroTBAGtbhta3TacvciHsbhqBO4825PQHMSQTURERA1FFAV0eGV0eGWs7fLg7UNhjETVeg+L6JQ0XAu/RCKBO++8E5deeilaWlogCAK2bNly1Gt37tyJP/3TP4XT6YTX68U111yDAwcOzO6AiYiIaMY4rBIuXBnAecuaYJUaLrYQHVPD/W0NhUJ48sknkclksHHjxmNet3fvXlx44YXIZrP4xS9+gaeffhr79u3D+eefj2AwOHsDJiIiohm3uNmBy9e2Y0mzo95DITopDbdcZNGiRYhEIhAEAZOTk/inf/qno153zz33wGq14qWXXoLb7QYAnHXWWVi+fDkeeugh/OAHP5jNYRMREdEMs5lN+KNlTVjcbMdbB8Ns/0cNreFmsgVBgCAcf1eofD6Pl156Cddee60RsAE9oH/2s5/F888/P9PDJCIiojpp98i4/PR2rGp34QSRgahuGm4m+2Ts378fiqJg7dq1R5xbu3Ytfv3rX0NVVdhstqN+/8TExBFLSvr7+2dkrERERFR7kknEmT0+LG5y4HcHQoikc/UeElGVORmyQ6EQAMDv9x9xzu/3Q9M0RCIRtLe3H/X7H3/8cWzdunVGx0hEREQzz++w4HN9bfhwLI4PhmMosL02NYg5GbLLjres5HjnNm3ahOuvv77qWH9//3ELLYmIiKgxiaKAvg4Pevz6Wu3xeKbeQyKamyG7qakJQGVGe6pwOAxBEOD1eo/5/YFAAIFAYKaGR0RERHXgsplx8WmtmIir2D0axyh7a1MdzcmQvWzZMsiyjF27dh1xbteuXejt7T3memwiIiKa3wJuGwJuG6LpLPaMxHE4nAY3jaTZ1nDdRU6GJEn4whe+gOeeew6JRMI4fvjwYWzfvh3XXHNNHUdHREREjcBrt+C83mZcsa4DK1qdkES2IqHZ05Az2b/85S+RSqWMAL1nzx48++yzAIDPf/7zsNvt2Lp1Kz7zmc/giiuuwHe+8x2oqop77rkHzc3NuOOOO+o5fCIiImogTquEsxf7sabTg33jCewbTyKbZ4UkzayGDNnf+MY3MDAwYHy9bds2bNu2DQBw8OBBLF68GKtWrcKOHTvw7W9/G9dddx0kScJFF12Ehx56CC0tLfUaOhERETUom9mEtV1erG53oz+YxEdjCW5oQzOmIUP2oUOHTuq6s846C6+++urMDoaIiIjmFckkYlWbGysCLhwKpbB3LIEo+2xTjTVkyCYiIiKaaaIoYGmLE0tbnAgmMuifSOJwOMVe21QTDNlERES04LW4rGhxWXHmIi8OTqbQP5FEXMnXe1g0hzFkExEREZVYJRNWtbmxqs2NibiKjyeSGGQLQPoUGLKJiIiIjqLcb1vNFXAgmEJ/MImkytltOjkM2URERETHYTObsLrDjdUdbozGFPRPJDEcUTi7TcfFkE1ERER0kto9Mto9MpRsAfuDSewPJtkGkI6KIZuIiIjoFMkWE9Z0etDX4cZITMXH4wmMxlRonN2mEoZsIiIiok9JEAR0emV0emWkMnljdlvJsg/gQseQTURERFQDDquEtV1erOnwYDiqr90ejan1HhbVCUM2ERERUQ2JooBuvx3dfjsSag79E0kcCKaQyXN2eyFhyCYiIiKaIS6bGet7fFjb5cVgOI2PJ5IIJjL1HhbNAoZsIiIiohlmEgUsbnZgcbMD0XQWH08kcWgyhVyBlZLzFUM2ERER0Szy2i34zGI/zuj2YiCkb+EeTuXqPSyqMYZsIiIiojowm0T0BlzoDbgwmczg43F9C/c8d7mZFxiyiYiIiOqs2WlFs9OKMxd5MRhWcDicwng8w77bcxhDNhEREVGDsEom9Aac6A04oeYKGAynMRBKI5hk4J5rGLKJiIiIGpDNbMLyVheWt7qgZAs4HE5jIJTCZDJb76HRSWDIJiIiImpwssWElW0urGxzIZXJlwJ3GuEUA3ejYsgmIiIimkMcVgmntbtxWrsbyUwehyZT+Hgiwa3cGwxDNhEREdEc5bRKWNPpwep2NwYjaXw0luBykgbBkE1EREQ0x4migEVNDixqciCUzOCj8QQOh9JgN8D6YcgmIiIimkeanFac57TizJ4CPh5Poj/IpST1wJBNRERENA/ZzCac3uVBX4cbA2F9KQkLJWcPQzYRERHRPCaKApY0O7Ck2YFwKov9wSQOTaaQK3AtyUxiyCYiIiJaIPwOC/wOP9Z3e3E4nMb+YArBRKbew5qXGLKJiIiIFhjJJGJpixNLW5yIKTnsDyZxMJhCJs+127XCkE1ERES0gHlkM87s8eGMLi+GIgr6gwmMxTi7PV0M2UREREQEURTQ02RHT5MdyUwe+yeSODiZQjpbqPfQ5iSGbCIiIiKq4rRKWNftxbpuLyKpLIajCoajCsKpLDTWS54UhmwiIiIiOiafwwKfw4I1nR6ouQJGYypGogpGogo7lBwHQzYRERERnRSb2WS0AywWNUwmMxiOKhiJqogpuXoPr6EwZBMRERHRKRNFAQG3DQG3Det7gGQmj5GoggPBJMIpBm6GbCIiIiKaNqdVwopWF1a0ujCRULFvLInBSHrBruFmyCYiIiKimgq4bAi4bEhl8tg3nsD+YArZBdaDmyGbiIiIiGaEwyphfY8Pp3d6cHAyhY/GE4gr+XoPa1YwZBMRERHRjJJMIpa3urC81YXRmIK9YwmMRtV6D2tGMWQTERER0axp98ho98iIKTnsG0/gYDCFfHH+LdxmyCYiIiKiWeeRzfjMYj/O6PZiNKricDiNkZiC/Dzpvc2QTURERER1YzaJxnbuhaKGkaiCwUgaw5G5vdkNQzYRERERNQSTKKDbb0e3345iUcNYXMVgOI2hiILMHOtOwpBNRERERA1HFAV0eGV0eGWco2mYSGSMwD0XMGQTERERUUMTBAGtbhta3Tacvbjeozk5Yr0HQEREREQ03zBkExERERHVGEM2EREREVGNMWQTEREREdUYQzYRERERUY0xZBMRERER1RhDNhERERFRjTFkExERERHVGEM2EREREVGNMWQTEREREdUYQzYRERERUY1J9R5Ao8hkMgCA/v7+Oo+EiIiIiBpNOSOWM+OJMGSXDA4OAgA2btxY34EQERERUcMaHBzEmWeeecLrBE3TtFkYT8OLRqN444030N3dDavVOiPP0d/fj40bN+KFF15Ab2/vjDwHTQ/vUWPj/Wl8vEeNjfen8fEeNa5MJoPBwUFccMEF8Hq9J7yeM9klXq8XV1111aw8V29vL/r6+mbluejT4T1qbLw/jY/3qLHx/jQ+3qPGdDIz2GUsfCQiIiIiqjGGbCIiIiKiGmPIJiIiIiKqMYbsWdTS0oLNmzejpaWl3kOhY+A9amy8P42P96ix8f40Pt6j+YPdRYiIiIiIaowz2URERERENcaQTURERERUYwzZREREREQ1xpBNRERERFRjDNk1tGPHDgiCcNQ/b775ZtW1O3fuxJ/+6Z/C6XTC6/XimmuuwYEDB+o08vknkUjgzjvvxKWXXoqWlhYIgoAtW7Yc9dpTuRc//vGPsWrVKlitVixZsgRbt25FLpebwZ9k/jrZe3TjjTce9TW1atWqoz4u71FtvP7667jpppuwatUqOBwOdHZ24qqrrsK77757xLV8DdXHyd4jvobq47333sPll1+Onp4eyLIMv9+PP/qjP8LPfvazI67la2h+YsieAQ8++CB++9vfVv1Zs2aNcX7v3r248MILkc1m8Ytf/AJPP/009u3bh/PPPx/BYLCOI58/QqEQnnzySWQyGWzcuPGY153KvXjggQdw22234ZprrsGvfvUrbNq0CQ8++CBuueWWGf5p5qeTvUcAIMvyEa+pZ5555ojreI9q54knnsChQ4dw22234eWXX8ajjz6KiYkJbNiwAa+//rpxHV9D9XOy9wjga6geotEouru78eCDD+Lll1/Gv/3bv2Hx4sX4i7/4C9x///3GdXwNzWMa1cz27ds1ANq2bduOe93111+vNTc3a7FYzDh26NAhzWw2a3feeedMD3NBKBaLWrFY1DRN04LBoAZA27x58xHXney9mJyc1Gw2m/bXf/3XVd//wAMPaIIgaLt3756ZH2QeO9l79JWvfEVzOBwnfDzeo9oaHx8/4lgikdBaW1u1iy++2DjG11D9nOw94muosZx77rlad3e38TVfQ/MXZ7JnWT6fx0svvYRrr70WbrfbOL5o0SJ89rOfxfPPP1/H0c0f5bdDj+dU7sUrr7wCVVXx1a9+teoxvvrVr0LTNLzwwgs1Hf9CcDL36FTwHtVWIBA44pjT6cTq1asxODgIgK+hejuZe3QqeI9mR3NzMyRJAsDX0HzHkD0DbrnlFkiSBLfbjc997nP4P//n/xjn9u/fD0VRsHbt2iO+b+3atejv74eqqrM53AXrVO7FBx98AAA4/fTTq65rb29Hc3OzcZ5mhqIoaGtrg8lkQldXF2699VaEw+Gqa3iPZl4sFsPOnTvR19cHgK+hRvTJe1TG11D9FItF5PN5BINBPP744/jVr36Fb3/72wD4GprvpHoPYD7xeDy47bbbcOGFF6KpqQn9/f34+7//e1x44YX4r//6L3zuc59DKBQCAPj9/iO+3+/3Q9M0RCIRtLe3z/bwF5xTuRehUAhWqxUOh+Oo15Yfi2pv3bp1WLdunVHX8MYbb+BHP/oRXnvtNbz99ttwOp0AwHs0C2655RakUincfffdAPgaakSfvEcAX0P1tmnTJvz0pz8FAFgsFvzjP/4jvv71rwPga2i+Y8iuofXr12P9+vXG1+effz6uvvpqnH766bjzzjvxuc99zjh3vLfJa/kWOp3Yyd4L3rP6uP3226u+vuSSS7B+/Xpcd911eOqpp6rO8x7NnO9///v4+c9/jh//+Mc466yzqs7xNdQYjnWP+Bqqr7vuugtf+9rXMDExgRdffBG33norUqkU/vZv/9a4hq+h+YnLRWaY1+vFFVdcgffffx+KoqCpqQkAjvobZzgchiAI8Hq9szzKhelU7kVTUxNUVUU6nT7qtUebhaCZc/XVV8PhcFS1xuQ9mjlbt27F/fffjwceeAC33nqrcZyvocZxrHt0LHwNzZ6enh6cffbZ+PznP48nnngCf/3Xf43vfve7CAaDfA3NcwzZs0DTNAD6b5nLli2DLMvYtWvXEdft2rULvb29sNlssz3EBelU7kV5Ddwnrx0bG8Pk5GRVi0aaHZqmQRQr/4TxHs2MrVu3YsuWLdiyZQvuuuuuqnN8DTWG492j4+FrqD7OOecc5PN5HDhwgK+heY4he4ZFIhG89NJLOOOMM2Cz2SBJEr7whS/gueeeQyKRMK47fPgwtm/fjmuuuaaOo11YTuVeXHbZZbDZbPiXf/mXqsf4l3/5FwiCcMI+z1Rbzz77LNLpNDZs2GAc4z2qvfvuuw9btmzB9773PWzevPmI83wN1d+J7tGx8DVUP9u3b4coili6dClfQ/NdfToHzk9f/OIXtW9/+9vatm3btO3bt2tPPvmktnLlSk2SJO3Xv/61cd2HH36oOZ1O7U/+5E+0l19+WXvuuee0NWvWaB0dHdrExEQdf4L55eWXX9a2bdumPf300xoA7frrr9e2bdumbdu2TUulUpqmndq9uP/++zVBELS77rpL27Fjh/b3f//3mtVq1W6++eZ6/Hjzwonu0aFDh7TzzjtP+8d//Eft5Zdf1n75y19q3/nOdzSbzab19fVpyWSy6vF4j2rnoYce0gBol112mfbb3/72iD9lfA3Vz8ncI76G6ufmm2/W7rjjDu2ZZ57RduzYoT377LPaDTfcoAHQvvWtbxnX8TU0fzFk19Df/d3faWeccYbm8Xg0k8mktbS0aFdffbX21ltvHXHtO++8o1188cWa3W7X3G63tnHjRq2/v78Oo56/Fi1apAE46p+DBw8a153KvXj00Ue1FStWaBaLRevp6dE2b96sZbPZWfqJ5p8T3aNwOKxdffXV2uLFizVZljWLxaItX75cu/POO7VoNHrUx+Q9qo0LLrjgmPfmk/MzfA3Vx8ncI76G6ufpp5/Wzj//fK25uVmTJEnzer3aBRdcoP2v//W/jriWr6H5SdC00oJhIiIiIiKqCa7JJiIiIiKqMYZsIiIiIqIaY8gmIiIiIqoxhmwiIiIiohpjyCYiIiIiqjGGbCIiIiKiGmPIJiIiIiKqMYZsIiIiIqIaY8gmIiIiIqoxhmwiogVoy5YtEAQBk5OT9R4KEdG8xJBNRERERFRjDNlERERERDXGkE1EtICNj4/ji1/8IjweD1pbW3HTTTchFosZ5wVBwK233oqf/vSnWLFiBaxWK1avXo3//b//dx1HTUTU+KR6D4CIiOrn2muvxQ033IC/+qu/wq5du/Dd734XAPD0008b1/znf/4ntm/fjnvvvRcOhwOPP/44vvjFL0KSJFx33XX1GjoRUUMTNE3T6j0IIiKaXVu2bMHWrVvxwx/+EN/61reM47fccguefvpppNNpCIIAQRAgyzIOHjyI1tZWAEChUMCaNWuQz+fx8ccf1+tHICJqaFwuQkS0gF155ZVVX69duxaqqmJiYsI4dvHFFxsBGwBMJhNuuOEG9Pf3Y2hoaNbGSkQ0lzBkExEtYE1NTVVfW61WAICiKMaxtra2I76vfCwUCs3g6IiI5i6GbCIiOq6xsbFjHvtkSCciIh1DNhERHddrr72G8fFx4+tCoYBnnnkGy5YtQ1dXVx1HRkTUuNhdhIiIjqu5uRkXXXQRvv/97xvdRfbu3cs2fkREx8GQTUREx3XllVeir68P3/ve93D48GEsW7YMP//5z3HDDTfUe2hERA2LLfyIiOiYBEHALbfcgp/85Cf1HgoR0ZzCNdlERERERDXGkE1EREREVGNck01ERMfEFYVERJ8OZ7KJiIiIiGqMIZuIiIiIqMYYsomIiIiIaowhm4iIiIioxhiyiYiIiIhqjCGbiIiIiKjGGLKJiIiIiGqMIZuIiIiIqMYYsomIiIiIaowhm4iIiIioxv4/FUIfS/1XVG8AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -218,12 +236,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -244,17 +262,17 @@ "source": [ "Here, we notice that the uncertainty in the conditional adjusted predictions is much larger than the uncertainty when `pps=False`. This is because the posterior predictive distribution accounts for the uncertainty in the model parameters and the uncertainty in the data. Whereas, the posterior distribution only accounts for the uncertainty in the model parameters.\n", "\n", - "A dictionary of covariates (between one and three) can also be specified where the key is taken from (\"horizontal\", \"color\", \"panel\") and the values are the names of the variables." + "`plot_cap` allows up to three covariates to be plotted simultaneously where the first element in the list represents the main (x-axis) covariate, the second element the group (hue / color), and the third element the facet (panel). However, when plotting more than one covariate, it can be useful to pass specific `group` and `panel` arguments to aid in the interpretation of the plot. Therefore, `subplot_kwargs` allows the user to manipulate the plotting by passing a dictionary where the keys are `{\"main\": ..., \"group\": ..., \"panel\": ...}` and the values are the names of the covariates to be plotted. For example, passing two covariates `hp` and `wt` and specifying `subplot_kwargs={\"main\": \"hp\", \"group\": \"wt\", \"panel\": \"wt\"}`. " ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -264,12 +282,13 @@ } ], "source": [ - "fig, axes = plot_cap(\n", + "plot_cap(\n", " model=model, \n", " idata=idata, \n", - " covariates={\"horizontal\": \"hp\", \"color\": \"wt\", \"panel\": \"wt\"},\n", + " covariates=[\"hp\", \"wt\"],\n", " pps=False,\n", " legend=False,\n", + " subplot_kwargs={\"main\": \"hp\", \"group\": \"wt\", \"panel\": \"wt\"},\n", " fig_kwargs={\"figsize\": (20, 8), \"sharey\": True}\n", ")\n", "plt.tight_layout();" @@ -285,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -320,7 +339,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -329,11 +348,54 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 4 jobs)\n", "NUTS: [daysabs_alpha, prog, scale(math), prog:scale(math)]\n" ] }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:01<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", @@ -385,7 +447,7 @@ " prog:scale(math) ~ Normal(mu: [0. 0.], sigma: [6.1735 4.847 ])\n", " \n", " Auxiliary parameters\n", - " daysabs_alpha ~ HalfCauchy(beta: 1.0)\n", + " alpha ~ HalfCauchy(beta: 1.0)\n", "------\n", "* To see a plot of the priors call the .plot_priors() method.\n", "* To see a summary or plot of the posterior pass the object returned by .fit() to az.summary() or az.plot_trace()" @@ -407,7 +469,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -418,13 +480,13 @@ ], "source": [ "fig, ax = plt.subplots(figsize=(7, 3), dpi=120)\n", - "fig, ax = plot_cap(\n", + "plot_cap(\n", " model_interaction, \n", " idata_interaction, \n", " \"math\", \n", " ax=ax, \n", " pps=False\n", - ")" + ");" ] }, { @@ -437,12 +499,12 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -453,13 +515,13 @@ ], "source": [ "fig, ax = plt.subplots(figsize=(7, 3), dpi=120)\n", - "fig, ax = plot_cap(\n", + "plot_cap(\n", " model_interaction, \n", " idata_interaction, \n", " [\"math\", \"prog\"], \n", " ax=ax, \n", " pps=False\n", - ")" + ");" ] }, { @@ -467,17 +529,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Passing the covariates as a dictionary can allow for a more interpretable plot. Especially when the posterior predictive distribution plot results in overlapping credible intervals." + "Passing specific `subplot_kwargs` can allow for a more interpretable plot. Especially when the posterior predictive distribution plot results in overlapping credible intervals." ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 47, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRsAAAHUCAYAAAC6Sv/CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACRbklEQVR4nOzdd3zddd3//+fn7J09m7ZJB4VCW4YMEaWMooCI4PgKegmKl1sv3HjhqH4Vvg746VcRvbwQ4UL08vJr2atQKGIpdK90phlNmr33WZ/fH58mbUjSnqSnORmP+43P7eR81nmd09J38sx7GKZpmgIAAAAAAACAk2RLdQEAAAAAAAAApgfCRgAAAAAAAABJQdgIAAAAAAAAICkIGwEAAAAAAAAkBWEjAAAAAAAAgKQgbAQAAAAAAACQFISNAAAAAAAAAJKCsBEAAAAAAABAUhA2AgAAAAAAAEgKwkZgCnjiiSdkGIaysrLU39+fsjqKi4t16623puS1ly9fruXLl6fktQEAE6O8vFxf/vKXdcYZZ8jv98vj8ai4uFgf+9jH9PLLL8s0zVSXmDSvvPKKDMPQK6+8kupSAAAn8JWvfEWGYWjPnj2jnnPnnXfKMAxt3rx5Ais76tFHH9UvfvGLEY8ZhqGVK1dOaD2j+eMf/yjDMFRRUZHqUnAKETYCU8ADDzwgSWppadFjjz2W2mJS5De/+Y1+85vfpLoMAMAp8sQTT2jJkiV64okndMstt2jVqlV6/vnn9d3vflfNzc26/PLLtWbNmlSXCQCYgW677TZJ0h/+8IcRj8fjcT388MM6++yzde65505kaYOOFza+/vrr+tSnPjWxBWFGI2zEtNfb25vqEk5KXV2dnnnmGV1++eXyeDyDweNMs3jxYi1evDjVZQDApDZV27yysjLddNNNWrx4sbZv36477rhDV111lS699FLddtttevbZZ/Xyyy8rOzs71aWOqqenJ9UlAMCUMBXbqrPOOksXXHCB/uu//kvRaHTY8RdeeEHV1dWDoeRkc9FFF6moqCjVZWAGIWzEpLdy5UoZhqEtW7boxhtvVCgUUlpamj72sY+psbFxyLnFxcV673vfq7///e8655xz5PF49IMf/ECStHPnTl1//fXKyMiQx+PR2WefrYceemjY6+3atUtXXXWVfD6fcnJy9IUvfEFPP/10yoY6PfTQQ4pGo/rKV76iG2+8US+99JIqKyuHndfW1qavfe1rmjdvntxut3Jzc3XNNdcM6er/gx/8QBdeeKEyMzMVCoV07rnn6oEHHhg2LC0Sieib3/ym8vPz5fP5dMkll+jNN98csb66ujp95jOfUVFRkVwul0pKSvSDH/xgSCNcUVEhwzD0s5/9TD/5yU9UXFwsr9er5cuXa9++fYpEIrrjjjtUWFiotLQ03XDDDWpoaBjyOiMNo+7v79cPf/hDnXHGGfJ4PMrKytJll12mdevWjfVjBoBJYaa2effee696enr0m9/8RqFQaMRzli9frmXLlg3Zt3//ft18883Kzc2V2+3WGWecofvuu2/IOQPDlf/85z/rzjvvVGFhoUKhkK688krt3bt32Ou8+OKLuuKKKxQKheTz+fSOd7xDL7300pBzBv6cNm/erA9+8IPKyMjQ/PnzJUkbN27URz7ykcG2rri4WDfddNOIbTcATEUzta267bbbVFdXp2effXbYsQcffFBut1sf/ehHJUlVVVX62Mc+NqR9uueeexSPx4dcl8jPM/fdd5/e9a53KTc3V36/X0uWLNFPf/pTRSKRwXOWL1+up59+WpWVlTIMY3AbMNIw6kQ+/7G0oatXr9b111+voqIieTweLViwQJ/5zGfU1NQ0tg8a04Ij1QUAibrhhhv04Q9/WJ/97Ge1a9cuffe731VpaaneeOMNOZ3OwfM2b96s3bt36zvf+Y5KSkrk9/u1d+9eXXzxxcrNzdX//b//V1lZWXrkkUd06623qr6+Xt/85jclSbW1tbr00kvl9/t1//33Kzc3V3/+85/1xS9+MaEaTdNULBZL6FyHI7H//f7whz+ooKBAV199tbxerx599FH98Y9/1Pe///3Bczo7O3XJJZeooqJC3/rWt3ThhReqq6tLr776qmpra3X66adLskK/z3zmM5ozZ44kaf369frSl76kmpoafe973xu837/+67/q4Ycf1te//nWtWLFCO3fu1I033qjOzs4htdXV1emCCy6QzWbT9773Pc2fP1+vv/66fvSjH6miokIPPvjgkPPvu+8+LV26VPfdd99gOHrdddfpwgsvlNPp1B/+8AdVVlbq61//uj71qU/piSeeGPVziUajuvrqq/WPf/xDt99+uy6//HJFo1GtX79eVVVVuvjiixP6fAFgMpppbd7q1atVUFCgt73tbQndT5JKS0t18cUXa86cObrnnnuUn5+v559/Xl/+8pfV1NQ0pJ2UpH//93/XO97xDv3nf/6nOjo69K1vfUvXXXeddu/eLbvdLkl65JFH9PGPf1zXX3+9HnroITmdTv3ud7/Tu9/9bj3//PO64oorhtzzxhtv1Ec+8hF99rOfVXd3tySrrV20aJE+8pGPKDMzU7W1tbr//vt1/vnnq7S0dFL3zgSAsZhpbdVNN92kr3zlK/rDH/6g6667bnB/a2urHn/8cd1www3KyMhQY2OjLr74YoXDYf3v//2/VVxcrKeeekpf//rXVVZWNjg1VKI/z5SVlenmm29WSUmJXC6Xtm3bph//+Mfas2fP4LDu3/zmN/r0pz+tsrIyrVq16oTvNdHPf0AibWhZWZne/va361Of+pTS0tJUUVGhe++9V5dccol27Ngx5O8EZgATmOS+//3vm5LMr3zlK0P2/+lPfzIlmY888sjgvrlz55p2u93cu3fvkHM/8pGPmG6326yqqhqy/+qrrzZ9Pp/Z1tZmmqZpfuMb3zANwzB37do15Lx3v/vdpiTz5ZdfPm6tL7/8sikpoa28vPyE7/3VV181JZl33HGHaZqmGY/HzZKSEnPu3LlmPB4fPO+HP/yhKclcvXr1Ce85IBaLmZFIxPzhD39oZmVlDd5v9+7dx/28b7nllsF9n/nMZ8xAIGBWVlYOOffnP/+5KWnwcywvLzclmcuWLTNjsdjgeb/4xS9MSeb73ve+IdfffvvtpiSzvb19cN+ll15qXnrppYPPH374YVOS+fvf/z7h9wwAk91MbfM8Ho950UUXDds/0FYNbMe2Ie9+97vNoqKiIW2FaZrmF7/4RdPj8ZgtLS1D6rzmmmuGnPfXv/7VlGS+/vrrpmmaZnd3t5mZmWled911w2pYtmyZecEFFwzuG/hz+t73vnfc92WaphmNRs2uri7T7/ebv/zlLwf3D9R1os8ZACabmdpWmaZp3nLLLabT6TTr6+sH9/3qV78a8rPYHXfcYUoy33jjjSHXfu5znzMNwxj8LMbz88xAu/jwww+bdrt9sK0zTdO89tprzblz5454nSTz+9///uDzRD//RNvQt4rH42YkEjErKytNSebjjz8+eOzBBx9M+PPG1MUwakwZA13SB3z4wx+Ww+HQyy+/PGT/0qVLddpppw3Zt2bNGl1xxRWaPXv2kP233nqrenp69Prrr0uS1q5dq7POOmvY3IA33XRTQjWed9552rBhQ0JbYWHhCe83MD/jJz/5SUlW9/dbb71VlZWVQ4Z0PfvsszrttNN05ZVXHvd+a9as0ZVXXqm0tDTZ7XY5nU5973vfU3Nz8+Cw5YHPc7TP+1hPPfWULrvsMhUWFioajQ5uV199tSTr8zzWNddcI5vt6D87Z5xxhiTp2muvHXLewP6qqqpR38uzzz4rj8cz+NkAwHQyE9u8kdx4441yOp2D25e//GVJUl9fn1566SXdcMMN8vl8Q9qga665Rn19fVq/fv2Qe73vfe8b8nzp0qWSNDi8ed26dWppadEtt9wy5H7xeFzvec97tGHDhsHeiwM+8IEPDKu5q6tL3/rWt7RgwQI5HA45HA4FAgF1d3dr9+7d4/ocAGAymolt1W233aZIJKL/+q//Gtz34IMPau7cuYO939esWaPFixfrggsuGPbeTNMcXOws0Z9ntmzZove9733Kysoa/Bnu4x//uGKxmPbt25fQ5/BWiX7+A07UhkpSQ0ODPvvZz2r27NlyOBxyOp2aO3euJNH+zUAMo8aUkZ+fP+S5w+FQVlaWmpubh+wvKCgYdm1zc/OI+wcalIF7NDc3q6SkZNh5eXl5CdUYCAR09tlnJ3Tuibrpd3Z26n/+5390wQUXKCcnR21tbZKs4QorV67UAw88MBguNjY2Dg6NHs2bb76pq666SsuXL9fvf//7wTkWH3vsMf34xz8enKh54LMY7fM+Vn19vZ588slRu8S/dX6OzMzMIc9dLtdx9/f19Y36fhobG1VYWDgkvASA6WKmtXlz5swZcU7De+65R9/5znckSeeff/7g/ubmZkWjUf3qV7/Sr371qxHv+dY26K1tmNvtlnR0oYL6+npJ0gc/+MFR62xpaZHf7x98PtLnfPPNN+ull17Sd7/7XZ1//vkKhUIyDEPXXHPNlFwUAQBGM9PaKkl65zvfqdNOO00PPvigvva1r2n79u3avHnz4DyWAzUXFxcPu/at7y2Rn2eqqqr0zne+U4sWLdIvf/lLFRcXy+Px6M0339QXvvCFcbcriX7+A07UhsbjcV111VU6fPiwvvvd72rJkiXy+/2Kx+O66KKLaP9mIMJGTBl1dXWaNWvW4PNoNKrm5uZh//AdOxHugKysLNXW1g7bf/jwYUkanD8pKytr8IeNt752ItauXavLLrssoXPLy8tHbIQG/PnPf1ZPT4/efPNNZWRkDDu+atUqtba2KiMjQzk5Oaqurj7u6/3lL3+R0+nUU089JY/HM7j/scceG3LewOc52ud9rOzsbC1dulQ//vGPR3zN8fZkSUROTo5ee+01xeNxAkcA085Ma/NWrFih++67Txs3bhwyb+PAoitvlZGRIbvdrn/5l3/RF77whRHPGemH0+MZ+Fx+9atf6aKLLhrxnLf+cPvWz7+9vV1PPfWUvv/97+uOO+4Y3N/f36+WlpYx1QMAk91Ma6sGfPKTn9Qdd9yhN998U48++qhsNptuvfXWweOJvrdEfp557LHH1N3drb///e+DvQQlaevWrQm9p9EkWmOidu7cqW3btumPf/yjbrnllsH9Bw4cOKk6MXURNmLK+NOf/qTzzjtv8Plf//pXRaPRYSsUj+SKK67QqlWrdPjw4SEB2MMPPyyfzzf4Q8Wll16qn//85yotLR3SVf8vf/lLQjUOdNNPxImCuAceeEDBYFCPPfbYsMZn48aN+sY3vqE//elP+uIXv6irr75a3/ve97RmzRpdfvnlI97PMAw5HI7BCXwl6zdRxw4BkDT4eY72eR/rve99r5555hnNnz9/xED0VLr66qv15z//WX/84x8ZSg1g2plpbd5XvvIVPfjgg/rCF76gF198UcFg8Ljn+3w+XXbZZdqyZYuWLl062CP+ZLzjHe9Qenq6SktLE1544K0Mw5BpmoM9Pgb853/+Z8ILFADAVDHT2qoBt9xyi77zne/od7/7nZ544gldccUVQ4LAK664Qnfffbc2b96sc889d3D/ww8/LMMwBsPPRH6eGQhqj21XTNPU73//+2Hnut3uhHsQJvr5J2qkOiXpd7/73Zjug+mDsBFTxt///nc5HA6tWLFicLWzZcuW6cMf/vAJr/3+978/OL/g9773PWVmZupPf/qTnn76af30pz9VWlqaJOn222/XH/7wB1199dX64Q9/qLy8PD366KPas2ePJJ2wB10wGBzTSpqj2blzp95880197nOfGzE8fMc73qF77rlHDzzwgL74xS/q9ttv13//93/r+uuv1x133KELLrhAvb29Wrt2rd773vfqsssu07XXXqt7771XN998sz796U+rublZP//5z4c1CGeccYY+9rGP6Re/+IWcTqeuvPJK7dy5Uz//+c8VCoWGnPvDH/5Qq1ev1sUXX6wvf/nLWrRokfr6+lRRUaFnnnlGv/3tb1VUVHTSn8dIbrrpJj344IP67Gc/q7179+qyyy5TPB7XG2+8oTPOOEMf+chHTsnrAsBEmEltnmT1YPzzn/+sm266SUuWLNHnPvc5nXvuuXK73WpoaNALL7wgSUPaoV/+8pe65JJL9M53vlOf+9znVFxcrM7OTh04cEBPPvnk4JxYiQoEAvrVr36lW265RS0tLfrgBz+o3NxcNTY2atu2bWpsbNT9999/3HuEQiG9613v0s9+9jNlZ2eruLhYa9eu1QMPPKD09PQxfy4AMJnNtLZqQH5+vq655ho9+OCDMk1Tt91225DjX/nKV/Twww/r2muv1Q9/+EPNnTtXTz/9tH7zm9/oc5/73OD8lYn8PLNixQq5XC7ddNNN+uY3v6m+vj7df//9am1tHVbXkiVL9Pe//13333+/zjvvPNlstlHfe6Kff6JOP/10zZ8/X3fccYdM01RmZqaefPJJrV69ekz3wTSS0uVpgAQMrHa2adMm87rrrjMDgYAZDAbNm266acgqYKZprXZ27bXXjnifHTt2mNddd52ZlpZmulwuc9myZeaDDz447LydO3eaV155penxeMzMzEzztttuMx966CFTkrlt27ZT8RaHGViNeevWraOeM7DK2aZNm0zTNM3W1lbz3/7t38w5c+aYTqfTzM3NNa+99lpzz549g9f84Q9/MBctWmS63W5z3rx55t13320+8MADw1YD6+/vN7/2ta+Zubm5gyuEvv766+bcuXOHrEZtmqbZ2NhofvnLXzZLSkpMp9NpZmZmmuedd5555513ml1dXaZpHl2N+mc/+9mQawdWN/uf//mfIfsHVijbsGHD4L63rkZtmqbZ29trfu973zMXLlxoulwuMysry7z88svNdevWnfAzBoDJaCa2eccqKyszv/SlL5mLFi0yvV6v6Xa7zblz55of+tCHzFWrVpnxeHzI+eXl5eYnP/lJc9asWabT6TRzcnLMiy++2PzRj340eM5obc1A2/TWz2Xt2rXmtddea2ZmZppOp9OcNWuWee211w65fuDPqbGxcdh7qK6uNj/wgQ+YGRkZZjAYNN/znveYO3fuHNaGsho1gKlqprdVpmmajz/+uCnJzMzMNPv6+oYdr6ysNG+++WYzKyvLdDqd5qJFi8yf/exnZiwWG3JeIj/PPPnkk+ayZctMj8djzpo1y/zGN75hPvvss8PakJaWFvODH/ygmZ6ebhqGYR4b9+gtq1GbZmKf/1ja0NLSUnPFihVmMBg0MzIyzA996ENmVVXVsNdmNeqZwTBN05y4aBMYu5UrV+oHP/iBGhsbxzx3RLJ8+tOf1p///Gc1NzcnZagWAAAjoc0DAEx2tFUAToRh1MBb/PCHP1RhYaHmzZunrq4uPfXUU/rP//xPfec736EhAwBMK7R5AIDJjrYKmHoIG4G3cDqd+tnPfqbq6mpFo1EtXLhQ9957r/7t3/4t1aUBAJBUtHkAgMmOtgqYehhGDQAAAAAAACApjr90EwAAAAAAAAAkiLARAAAAAAAAQFIQNgIAAAAAAABIimm/QEw8Htfhw4cVDAZlGEaqywEAHIdpmurs7FRhYaFsNn4fNhLaNQCYGmjTTow2DQCmjrG0a9M+bDx8+LBmz56d6jIAAGNw6NAhFRUVpbqMSYl2DQCmFtq00dGmAcDUk0i7Nu3DxmAwKMn6MEKhUIqrAQAcT0dHh2bPnj34bzeGo10DgKmBNu3EaNMAYOoYS7s27cPGge74oVCIBgwApgiGUo2Odg0AphbatNHRpgHA1JNIu8bkIQAAAAAAAACSgrARAAAAAAAAQFIQNgIAAAAAAABICsJGAAAAAAAAAElB2AgAAAAAAAAgKQgbAQAAAAAAACQFYSMAAAAAAACApCBsBAAAAAAAAJAUhI0AAAAAAAAAkoKwEQAAAAAAAEBSEDYCAAAAAAAASArCRgAAAAAAAABJQdgIAAAAAAAAICkIGwEAAAAAAAAkBWEjAACw9LVL2/8q9bamuhIAAAAAUxRhIwAAsNSXSjWbpLodqa4EAAAAwBRF2AgAAKRIn1S9QQr3SNUbrUcAAAAAGCPCRgAAIDXtlToOS7mLpa56qXFPqisCAAAAMAURNgIAMNPFY9bwaZtDcnoku1uq3iTFoqmuDAAAAMAUQ9gIAMBM11IuNR+UQgXW82CB1FoutZSlti4AAAAAUw5hIwAAM13tVsmMSk6f9dzpkWRKNZsl00xlZQAAAACmGMJGAABmso5aqaFU8ucN3R8skJr2Se3VqakLAAAAwJRE2AgAwExWt13q75S86UP3u4NSuFuq25GSsgAAAABMTYSNAADMVL1t0uGtki975OP+HKl2m9TTMpFVAQAAAJjCCBsBAJipGkqlnibJP0rY6MuUeluk+p0TWxcAAACAKYuwEQCAmSjSJ1VvtIZLG6N8O2DYJE+6dV64Z0LLAwAAADA1ETYCADATNe2VOmqkQP7xzwvkSl31UuPuiakLAAAAwJRG2AgAwEwTj0k1mySbU7I7j3+uzSHZ3VL1JikWnZj6AAAAAExZhI0AAMw0LeVS80EpVJDY+cECqbVCaj5wSssCAAAAMPURNgIAMNPUbpPMqOT0JXa+0yPJlA5vlkzzlJYGAAAAYGojbAQAYKbpqpdcwbFdEyyQmvZL7dWnpiYAAAAA0wJhIwAAODF3UAp3S7XbU10JAAAAgEmMsBEAACTGnyPVbZd6WlJdCQAAAIBJirARAAAkxpcp9TRL9TtTXQkAAACASYqwEQAAJMawSd4MqXqjFO5JdTUAAAAAJiHCRgAAkLhArrXATOPuVFcCAAAAYBIibAQAAImzOSSHW6reJMWiqa4GAAAAwCRD2AgAAMYmWCC1VkjNB1JdCQAAAIBJhrARAACMjcNjPR7eLJlmamsBAAAAMKkQNgIAgLEL5ktN+6T26lRXAgAAAGASIWwEAABj5w5K4W6pdnuqKwEAAAAwiRA2AgCA8fHnSnXbpZ6WVFcCAAAAYJIgbAQAAOPjy5R6mqX6namuBAAAAMAkQdgIAADGx7BJ3gypeqMU7kl1NQAAAAAmAUeqCwAAAFNYIFdq2i9VvGb1dBwLwyblnSU5XKemNgAAAAATjrARAACMn80hedKkspfGfq3dJTl9Uu7pya8LAAAAQEoQNgIAgJMTKpRUOPbrGnZLbZWEjQAAAMA0wpyNAAAgNTxpUuNeKRZNdSUAAAAAkoSwEQAApIY3XepukjprU10JAAAAgCQhbAQAAKnh9EnRXqn9UKorAQAAAJAkhI0AACB1nF5rKDUAAACAaYGwEQAApI4nQ2qvkXpaUl0JAAAAgCQgbAQAAKnjCUn9HVJbVaorAQAAAJAEhI0AACB1DJtks0ut5amuBAAAAEASEDYCAIDU8qRLTfulSG+qKwEAAABwkggbAQBAannTpd5Wa+5GAAAAAFPapAkb7777bhmGodtvv31wn2maWrlypQoLC+X1erV8+XLt2rUrdUUCAIDks7ukeExqP5TqSgAAAACcpEkRNm7YsEH/8R//oaVLlw7Z/9Of/lT33nuvfv3rX2vDhg3Kz8/XihUr1NnZmaJKAQDAKeEOSA2lUjye6koAAAAAnISUh41dXV366Ec/qt///vfKyMgY3G+apn7xi1/ozjvv1I033qizzjpLDz30kHp6evToo4+msGIAAJB03kypu1Hqqkt1JQAAAABOQsrDxi984Qu69tprdeWVVw7ZX15errq6Ol111VWD+9xuty699FKtW7du1Pv19/ero6NjyAYAwFQ1Y9o1l18Kd0vt1cc/L9In9bVPTE0AgKSaMW0aAMxwKQ0b//KXv2jz5s26++67hx2rq7N6NuTl5Q3Zn5eXN3hsJHfffbfS0tIGt9mzZye3aAAAJtCMatfsbqlx7+jHI33Srr9Lmx+Rupsmri4AQFLMqDYNAGawlIWNhw4d0r/927/pkUcekcfjGfU8wzCGPDdNc9i+Y337299We3v74HboEJPNAwCmrhnVrvkyrUViRuq5GItK+56TDm+RWiukXaukPnrEAMBUMqPaNACYwRypeuFNmzapoaFB55133uC+WCymV199Vb/+9a+1d6/Vs6Gurk4FBQWD5zQ0NAzr7Xgst9stt9t96goHAGACzah2zR2SuuqltkNSftrR/fG4VPayVPm6lDZHcrilpn3S7ielsz4gOUf/pSUAYPKYUW0aAMxgKevZeMUVV2jHjh3aunXr4Pa2t71NH/3oR7V161bNmzdP+fn5Wr169eA14XBYa9eu1cUXX5yqsgEAwKlis0uGYfVcPNah9dLBl6VgnrVqtd0pZcyTardYvR1j0ZSUCwAAAGC4lPVsDAaDOuuss4bs8/v9ysrKGtx/++2366677tLChQu1cOFC3XXXXfL5fLr55ptTUTIAADjV3GlWr8VoWHK4pMNbpX3PS56Q5M04ep7TI6XPlapel5xeacEKyZbyde8AAACAGS9lYWMivvnNb6q3t1ef//zn1draqgsvvFAvvPCCgsFgqksDAACngjfDmrexo0aKR6W9T1s9HgMjTKHiCkiBfOngWuvr4ndMfL0AAAAAhphUYeMrr7wy5LlhGFq5cqVWrlyZknoAAMAEc7ilWESq3SY1H5DCvVLW/NHP96ZLsbC0/wXJ5ZcKz56oSgEAAACMYFKFjQAAAHL5pfpdUrhLylpw4vMDuVJ7tbTnaamjVjJGGE5ts0tFb7PCSQAAAACnDGEjAACYXAJ5UmetlDl/5OBwJGlF1tDr8rUjH4+FJbtDmrc8aWUCAAAAGI6wEQAATC4Ot5RRPPbrQrNGP9ZxWKrZLBWdb/WcBAAAAHBKsGwjAACY/gK5Ume91LAn1ZUAAAAA0xphIwAAmP5sDsnpkao3WAvQAAAAADglCBsBAMDMECyQ2qqsVa4BAAAAnBKEjQAAYGZwuK3Hms2Saaa2FgAAAGCaImwEAAAzRzBfatpn9XBMRDx+ausBAAAAphnCRgAAMHO4g1KkV6rbfvzzTFMqe0Xa8VcCRwAAAGAMCBsBAMDMEsiV6nZI3c2jn1O9QTqwWqrfJbVVTFhpAAAAwFRH2AgAAGYWb6bU2yrV7xj5eN1Oae+zkisgxcLS4a0TWh4AAAAwlRE2AgCAmcUwJE+6tVBMuHvosZaD0u4nrWHUwXwpkGf1buysT0mpAAAAwFRD2AgAAGaeQK4VIDbsObqvo1ba9ZgU7pIy5lr7POlSX4c17BoAAADACRE2AgCAmcfmkJwea27GWETqaZFKH5O6GqTMeUfPMwzJlykd3myFjgAAAACOi7ARAADMTMECqa1Kqt0u7X5CaimXshZIxlu+PfLnSN1NUsPu1NQJAAAATCGEjQAAYGZyuK3HynXWvIxZ8yWbffh5Nrvk8lu9IKPhia0RAAAAmGIIGwEAwMwVKpTaKqWMYsnuGv28YL7UXi017Z2w0gAAAICpiLARAADMXC6/lHem5PQd/zy7yxpeXbNJiscnpjYAAABgCiJsBAAASESoUGouk1rLU10JAAAAMGkRNgIAACTC5ZdiYal2W6orAQAAACYtwkYAAIBEBfKsxWQ661NdCQAAADApETYCAAAkypMu9XVIdTtSXQkAAAAwKRE2AgAAJMowJF+mdHizFToCAAAAGIKwEQAAYCz8OVJ3oxU4AgAAABiCsBEAAGAsbHbJlyMdWCMd3prqagAAAIBJhbARAABgrAI5kt0p7Xlaatqf6moAAACASYOwEQAAYDzSiqRon1T6uNR2KNXVAAAAAJMCYSMAAMB4ZZRI3U1W4NjdlOpqAAAAgJQjbAQAABgvw5CyFkhtldKuVaxQDQAAgBmPsBEAAOBk2OxS1kKpaZ+0+0kp0pvqigAAAICUcaS6AAAAgCnP7pQy50m1WySnT5p9viRjbPdw+SRvxtiu6euwXs/Ot3QAAACYHPjOFAAAIBkcHil9rlT5T+nw5rFfHyyQ3vZJyelJ7Pxov7T9v6X8pdKcC8f+egAAAMApQNgIAACQLK6AlHO6FI+O7TozJrVVSY17pMKzE7umca/UtN9aEbvwbMnhHmu1AAAAQNIRNgIAACSTzW5tY2V3SjUbpfwlJ74+HpdqNllft9dYwWPB0rG/JgAAAJBkLBADAAAwGQTzpZZyqeXgic9tPXJe+hwrmKzZZAWQAAAAQIoRNgIAAEwGTp81nPrwlhOfe3irFItILr8112NLmRVAAgAAAClG2AgAADBZBPKlht1Sx+HRz+mskxpKpUCu9dzll2JRK4AEAAAAUoywEQAAYLLwpEn9XVLt9tHPqdsp9XdI3oyj+wJ5UsMuK4gEAAAAUoiwEQAAYDLxZ0u1W6Xe1uHH+jqkms2SL2vofm+61N9pBZEAAABAChE2AgAATCb+bKmnWaovHX6soVTqaZR82cOP+bKsILKv/dTXCAAAAIyCsBEAAGAyMWySOyTVbJQifUf3R/ul6o2SK2itQP1WvmwriGzYPXG1AgAAAG9B2AgAADDZBPKsRWIa9xzd17hXaq+WgnkjX2OzW0Fk9QYrmAQAAABSgLARAABgsrE7JbvL6t0Yj0nxuFSzyQoU7a7RrwvmSe01VjAJAAAApABhIwAAwGQUzJdayqWWg1LrkcdgwfGvsbusQLJmoxVQAgAAABPMkeoCAAAAMAKnTzJj0uEtkmGXYhHJ5T/xdcGCowFl1vxTXycAAABwDMJGAACAySqQby34YtiseRwT4fJLsah0eCthIwAAACYcw6gBAAAmK0+aFO6W+jskb3ri1wXypPqdUtOBU1YaAAAAMBLCRgAAgMksc56UOcYeit50a9j17iesBWMAAACACULYCAAAMJk53NY2VpklUle9VPq41N2c/LoAAACAERA2AgAATEeGTcpaaC0Us/txqb8z1RUBAABgBiBsBAAAmK5sdilrgVS/W9r9tBTpS3VFAAAAmOYIGwEAAKYzu8saUn14k7TveWulagAAAOAUIWwEAACY7pxeKW22VLlOOviKZJqprggAAADTFGEjAADATOAOSsE8qWyNVLV+7Nd31Erh7rFdE4tKrZWEmwAAADMIYSMAAMBM4c2QPCFp//NS7fbEr2utkLY+Ih18dWyvV79D2vYXqWbT2K4DAADAlEXYCAAAMJME8iTZpD1PSc1lJz6/s17a9ZjUXi3VbZN6WhJ7nXhMqt4oddRIe5+R6ktPpmoAAABMEYSNAAAAM036bCnSI5U+LrXXjH5eb6tUukrqOCzlLZG6m6SG3Ym9RnOZ1SMy53QreNz9hPUcAAAA0xphIwAAwEyUUSJ1N1iBY3fz8OPhbqn0CanpgJS9ULLZJU+aVL1BivSe+P6Ht1gho9Mrpc+V+jqsHpKd9Ul/KwAAAJg8CBsBAABmIsMmZS6wehvuflzq7zx6LBqW9jwj1e2QshZINoe1P5AvddZKjXuOf+/2GuucYP6R1zKkrPlWD8nSVVaPSQAAAExLhI0AAAAzlc1uhYD1u6XdT0uRPikel/avlqrftHo/OtxHz7c7JLvLmosxHhv9vrXbrZ6RnrSj+wyb1UOyuczqMTnWla0BAAAwJThSXQAAAABSyO6SMudJNRutIc/ukFTxDylUJLl8w88PFli9IZvLpJzThh/vaZFqt0r+7OHHbA4pc77VY9LpkxZfLzlcyX5HAAAASCF6NgIAAMx0To+UPkeqXCeVvSj5siRPaJRzvVavxsNbRj7esFvqbbHuMRKH2+oxWf2mdPCVpJQPAACAyYOwEQAAAJI7KKXNkrwZI/dKPFYw35qT8a0rWUd6rQVk3CFr2PRoXD7Jn2v1phxpcRoAAABMWYSNAAAAsLiDo/dIPJYnzZpzsXb70P2Ne6SOWmshmRPxZVoLxdTvHF+tAAAAmJQIGwEAADB2/mxrbsaeFut5PGYtHONwWQvJnIhhkzzpUs0mFosBAACYRlIaNt5///1aunSpQqGQQqGQ3v72t+vZZ58dPG6aplauXKnCwkJ5vV4tX75cu3btSmHFAAAAkGT1gOxptuZolKwFY1orpGBh4vcI5EqddVLDnlNSIgAAACZeSsPGoqIi/Z//83+0ceNGbdy4UZdffrmuv/76wUDxpz/9qe699179+te/1oYNG5Sfn68VK1aos7MzlWUDAADAsFnDqas3SOEea8GYeMxabCZRNoe14EzNRikWPXW1AgAAYMKkNGy87rrrdM011+i0007Taaedph//+McKBAJav369TNPUL37xC91555268cYbddZZZ+mhhx5ST0+PHn300VSWDQAAAMmam7GjVipfa83XGExgrsa3ChZIrZVS84Hk1wcAAIAJN2nmbIzFYvrLX/6i7u5uvf3tb1d5ebnq6up01VVXDZ7jdrt16aWXat26daPep7+/Xx0dHUM2AACmKto1TGp2hzVHY9N+a95FT9rY7+FwW481myTTPPH5/V2JnXeseNxaKRtAStGmAcDMkPKwcceOHQoEAnK73frsZz+rVatWafHixaqrq5Mk5eXlDTk/Ly9v8NhI7r77bqWlpQ1us2fPPqX1AwBwKtGuYdILFkhN+yR/zkncI9+6R/uh45/XViVt/INU/mri947HpX3PSVv+JMUi468RwEmjTQOAmSHlYeOiRYu0detWrV+/Xp/73Od0yy23qLS0dPC4YRhDzjdNc9i+Y337299We3v74Hbo0Am+aQUAYBKjXcOk5/RK+cus1anHyx20eh7Wbh/9nK5Gaddj1iI0B1ZL1ZtOfF/TlCpetcLJljKrByaAlKFNA4CZwZHqAlwulxYsWCBJetvb3qYNGzbol7/8pb71rW9Jkurq6lRQUDB4fkNDw7Dejsdyu91yu92ntmgAACYI7RqmBHsSvqX050h126U5b5f8WUOP9bVbQWN7tZR3prWC9d6nJZdPyj1j9HvWbJL2v2itnN3Xaj3PPUM6zi+uAZw6tGkAMDOkvGfjW5mmqf7+fpWUlCg/P1+rV68ePBYOh7V27VpdfPHFKawQAAAASefLlHpbpfqdQ/dHeqXSJ6xh1lkLrVWwQ4VSPGrtb60Y+X71pdLeZySnz+p1GSiwFqFpqzrlbwUAAGAmS2nY+O///u/6xz/+oYqKCu3YsUN33nmnXnnlFX30ox+VYRi6/fbbddddd2nVqlXauXOnbr31Vvl8Pt18882pLBsAAADJZtgkT7rV+zDcbe2LRaQ9z0i126Ss+UN7UKYXWz0eSx+XOuuH3qu1Qtr9pBSPSaEjI2TcgSNDtbdNwJsBAACYuVI6jLq+vl7/8i//otraWqWlpWnp0qV67rnntGLFCknSN7/5TfX29urzn/+8WltbdeGFF+qFF15QMBhMZdkAAAA4FQK5UtMBqWGPVHiONQT60Hopo/joqtUDDMMKIBv3SqWPSUv/l+RNt4LH0setIDJrwfD71+2whmoHTmJBGwAAAIwqpWHjAw88cNzjhmFo5cqVWrly5cQUBAAAgNSxOSSnR6reIIU7pfK1UrBQcvlHPt+wSdkLrSHWpY9LC1dYPRrba6ScRcPnZvRmSg27pfpdUmD5KX87AAAAM1HKF4gBAAAABgULrHkVO2qseRy96cc/3+aQMudL9Tukvg6pvUrKPs0KIt/KMCRvhlSzUSp6mzW0GgAAAEk16RaIAQAAwAzmcEtOr9Wb0Z/gUGeHW0ovkToPW8Gj7Ti/Tw/kSl31Vg9HAAAAJB1hIwAAACaXtCIpkDe2a1w+q0fjW+d2fCub3VqhumajtQANAAAAkoqwEQAAADPLwFDtpv2prgQAAGDaIWwEAADAzOJwW/M31mySTDPV1QAAAEwrhI0AAACYeQIFVs/GtspUVwIAADCtEDYCAABg5nEHpGifVLs91ZUAAABMK4SNAAAAmJkCuVLdDqmrUYrHx7Yx/BoAAGBEjlQXMBWUHu5QRVOXrlycL5eDfBYAAGBa8GZKDbulzQ+N/VqXXzr9vVL67OTXBQAAMIWRnCWgOxzVhopWvbK3QbE4v8UGAACYFgxDyiyW4rGxb60VUunjVq9IAAAADKJnY4L6ojG9frBZPpdd71iQLcMwUl0SAAAATpbTZ21j5cuSmvZJpY9JS/+X5AklvTQAAICpiJ6NCfI4bcryu7V2X6O2HGpLdTkAAABIJZtdylogNe6Tdj8pRXpTXREAAMCkQNg4Bpl+l7wuh14qbdDeus5UlwMAAIBUsjulrHlS7VZp77NSLJLqigAAAFKOsHGM8kMexU1Tz+6sVVVzT6rLAQAAQCo5PFL6HKlqvXTgJWulagAAgBmMsHEcijK86uqL6umdtWro6Et1OQAAAEglV0AKFkjlr0qV/0x1NQAAACnFAjHjYBiGirP9Kmvo0tM7anXDObOU7nMlfH00Fld9Z79mpXtPYZUAAACYMN50axj1/tXWfI7ezOTd2+aQMoolO9+6AwCAyY/vWMbJZhgqybECx2d31un6swvlc53444zHTb26v0nbDrXpstNzdfbs9FNfLAAAAE69QI7UEZF2rZKMJA4gsjmleculBVdIhpG8+wIAAJwChI0nwWGzqSQ7oN21HfI67bpmSYFcjuN/Y7mhokX/PNAkQ9KLpfXyu+xamBecmIIBAABwaoUKrS2ZelulsjWSyy/NfXty7w0AAJBkzNl4klwOm+Zm+rW5qlWv7G1QLG6Oeu6O6nat2dugNI9T83ICisbienZnrQ61sNAMAAAARuHNkDwhaf/zUu32VFcDAABwXISNSeB12TUr3avXDzZr3YEmmebwwPFAQ5deKK2T02ZTdtAtSZqd6VN7b1TP7KhVY2f/RJcNAACAqSKQJ8km7XlKajqQ6moAAABGRdiYJEGPU1l+t9bub9SWQ21DjtW09eq5nbXqj8RVeMyiMIZhqCTbr9r2Pj2zo1btvZEJrhoAAABTRvpsKdIj7X5Caq9JdTUAAAAjGlfY+Nxzz+m1114bfH7ffffp7LPP1s0336zW1takFTfVZPpd8rkcerG0XnvqOiRJTV39emZHrVq6w5qb5Rt2jc0wNC/br7LGLj23s1a94dhElw0AOEVoLwEkXUaJ1N0glT4udTenuhrMMLRrAIBEjCts/MY3vqGODitM27Fjh772ta/pmmuu0cGDB/XVr341qQVONfkhj0xTem5nnXbXdujZHbWqbu1RSXZAxiirBzrsNpVk+7XrcIdeKK1TOBqf4KoBAKcC7SWApDNsUuYCqbVC2v241N+Z6oowg9CuAQASMa7VqMvLy7V48WJJ0v/7f/9P733ve3XXXXdp8+bNuuaaa5Ja4FRUlOFVeVO3nt9Zp5aesObnBGS3jRw0DnA77JqT6dPmqlb5nHZdcUaebCe4ZkA4Gtc/DzSqoy86yr1tWr4oVx6nPeH3MNAz8/T8UMLXAACGor0EcErY7FLWfKl+t2T+t+ROG/m80Cxr9epRfuE9Jl2NUt12ac5F1qrYmJFo1wAAiRhX2OhyudTTY62g/OKLL+rjH/+4JCkzM3PwN10zmWEYKs72q669TyXZfjntiXUg9bkcKgh5te5gs/xuhy5ekH3Ca2JxU6/sbdBrB5rkdtg10reSkXhcs9J9WlI0yjeib9EXiekf+5pkylRxln9MISUA4CjaSwCnjN0lZc6TWqskDV+cUGZcqt0q2WxWQHgy+tql0sek+l1ST4u0+HrJ4Tq5e2JKol0DACRiXGHjJZdcoq9+9at6xzveoTfffFP//d//LUnat2+fioqKklrgVGUzjCGLwSQq5HUqEovrlb2N8rkdOnt2+qjnmqapdQea9PrBZs1K9yrocY54XmVzt7YeatXiwtAJe1hKUlljlw639w5+fWZhYiElAGAo2ksAp5TTI2WWjH68s07a97zVEzF/yfheI9IrlT4pNe6z5ousflNy+qRF77F6WGJGoV0DACRiXHM2/vrXv5bD4dDf/vY33X///Zo1a5Yk6dlnn9V73vOepBY4E2UF3HI7bXqxtF776kefh2fLoTat3d+oLL971KBRkvJCHlU296i8qfuErx2Pm9p6qE0Om00Om01bq9oUj4/w23IAwAnRXgJIqWC+9bj7Kam5bOzXxyLS3mesHpJZ8yVPyBqaXfEPazP5HnGmoV0DACTCMM3p/V1CR0eH0tLS1N7erlBofPMPbqho0TM7Dmth7sTOX1jV3C2f264bzinS7MyhK1nvqevQE1sPy2G3KT/kOeG9DjR0asmsdN1w7qzjnlfe1K1H36hUfsjqlVnX0aubL5yrkmzm5gFw6iXj3+zpLimf0eu/kXpbpVBhcosDMDk1l0m+TGnZRxL//z4el/a/IJWtkdLnDJ2nsbvJGlp95vuloredkpKnA9q0E+MzAoCpYyz/Zo9rGLUkxWIxrVq1Srt375ZhGDr99NP1/ve/Xw7HuG+Jt5id6dPBpm49s6NWN5w7S7lBK1Ssau7RczvrZJpKKGiUpNyQR/sbOlXb3quCtNGHd2+vblM0bsrrsobFROOmtle3ETYCwDjRXgJIucwSqWmftOsxK3D0ZZ74msrXpIOvSMGC4QvC+LOP9np0+qS8xaeiakxStGsAgBMZV4uwc+dOve9971N9fb0WLVokyZqnIycnR0888YSWLBnnnDAYwjAMlWT7daC+S8/uqNP7z5ml/khMT++sVVdfdEwBYMjjVG1br3bVtI8aNtZ39Gl/fddgqClJuUGP9td3qb6jT3kJBpsAAAvtJYBJwbBJWQulpr3WQi9LPiy5A6OfX7NZ2v+iFUp600c+J1QgtVZIu5+QnN7jzx2JaYN2DQCQiHHN2fipT31KZ511lqqrq7V582Zt3rxZhw4d0tKlS/XpT3862TXOaDbD0Lxcv8oau/Tsjlo9vaNWDe19Ks72yzBOvNjLsbIDbu083KG2nvCIx0sPd6izL6I079H5H9O8TnX2RVR6mNXlAGCsaC8BTBo2u5S1QKrfbc3h2NUodTcP3+p2SnuesVab9ucc/57pc6X+Tqn0cSt4HOl+3c1SPJa892GaUqRv7NdFw8wxmQS0awCARIyrZ+O2bdu0ceNGZWRkDO7LyMjQj3/8Y51//vlJKw4Wh82medkB7artkCFpQW5AtjEGjZKU4Xdpf32n9tZ16sJ5WUOOdfRFtL2mTZl+97DrMv1uba9p03nFGQodZyEaAMBQtJcAJhW7y+qBWLNRat438jmxqCRTypx34vsZhnVe415p00PW85HkLpbOeJ8VYJ4M05QOvCQ175eWfMgazp2I7iZp59+luW8f/6rckES7BgBIzLh6Ni5atEj19fXD9jc0NGjBggUnXRSGczlsWpgb0MLcoBy2cf2xyWYYCnqc2nKoTX2Rob9h3lvXqZausLICw78JzAq41NIV1t660VfGBgAMR3sJYNJxeqXsRZI3Y+QtkJtY0DjAsEk5i44MuR7hfq6gdOgN6cCL1qIzJ6NqvbVgTdN+adcqqS+BkTd9Hda5tVukxv0n9/qgXQMAJCTh1Kqjo2Nwu+uuu/TlL39Zf/vb31RdXa3q6mr97W9/0+23366f/OQnp7LeGc1hs8luG3uPxmPlBt2qa7fmZhzQF4lpS1WrAh7niD0mbYahgMepLVWtw0JKAMBQtJcAJj27Q3IFRtnGsSigYRv9ft50KTRLKn9Vqnh1/EOZa7dL+5+XPCEp53SrN+XuJ6VI7+jXRPqsc5r2SaEiqeWAFO4Z3+vPYLRrAICxSngYdXp6+pA5Ak3T1Ic//OHBfeaRbxyuu+46xWIEUpOVw26T22HTlqpWLS4MyW4zdKChS7XtfSrOGv2by9ygWxXN3TrQ0KWzZqVNYMUAMLXQXgLAW3jSrNWrD7xo9XQsOm9s1zeXSXuekmRIgTxrX9Z8q7ei02sN0ba/5ceaWFTa95x1TsZ8a87K1nKpo0bKXpiUtzVT0K4BAMYq4bDx5ZdfPpV1YALlhTyqaulReVO35mX7te1Qmxw2m5z20Tu6Ou02OWw2bTvUpsUFIdlOsoclAExXtJcAMAJ/thQLS3ufllw+KfeMxK5rr7EWoAn3WAHjAIfHWqCmar3VG3PBCmlgqqF4XCp7Sap63TrH6TmyPya1VhI2jhHtGgBgrBIOGy+99NJTWQcmkMdpV9w0taO6XTZDqmjuVn7Ie8Lr8kMeVTR3q7KlRyXZ4xhiAwAzAO0lAIwiVGitWl36hNUjMaP4+Od3N1tBY1e9lH3a8OOugBQskA6utQLH4kus/VWvW/sC+dY5A9xBqWmvNP8yq6cjEkK7BgAYq3GtRj2gp6dHVVVVCofDQ/YvXbr0pIrCqZcb8mh/Q6f6ojFF46a8rhN/w+V12RWNm9pe3UbYCABjQHsJAEekz5WaD1gh4tKPSMG8kc/r75R2P26Fk9mnWfNCjsSbbvWY3PfCkfkmDWnf89bQbW/6W87NkLoapM46KW1W8t7TDES7BgA4nnGFjY2NjfrEJz6hZ599dsTjzNUx+YU8TtW29aqqpUe5QU/C1+UGPdpX16V1ZU0jDrt22AydURCSx8lviwGA9hIA3sIwrOHQjXul0sek/FHCqZZyqX63lL3gxL0QA7lSe7W052lJhmR3WvveyuWX2iqtcwkbx4V2DQCQiHGFjbfffrtaW1u1fv16XXbZZVq1apXq6+v1ox/9SPfcc0+ya8Qpkp/mVXNXv9K8zoSvSfM61dLdr9W76kc8bkqqbe/TVYvz5DjOHJAAMBPQXgLACAybNW9iS7nUcnC0k6TMeZLdldg904qktirr6/Q5o5/n8FhDqedcOKaSYaFdAwAkYlxh45o1a/T444/r/PPPl81m09y5c7VixQqFQiHdfffduvbaa5NdJ06BNK9zTEHjgJLswKjHuvqjerO8RX6XXe86LWfIynUAMNPQXgLAKGyO5C/UcryQcYA3w+rZ2Ns2fJg1Toh2DQCQiHF1Pevu7lZurjU0ITMzU42NjZKkJUuWaPPmzcmrDlNOwO1QbtCtf+xv0sbK1lSXAwApRXsJAJOMOyT1tUvth1JdyZREuwYASMS4wsZFixZp7969kqSzzz5bv/vd71RTU6Pf/va3KigoSGqBmHrSfS4FPA69tLteO2vaU10OAKQM7SUATDI2uyTDWngGY0a7BgBIxLjnbKytrZUkff/739e73/1u/elPf5LL5dIf//jHZNaHKSo36FFNa69Wl9bL57JrXs7oQ68BYLqivQSASciTJjXtk6L9ksOd6mqmFNo1AEAixhU2fvSjHx38+pxzzlFFRYX27NmjOXPmKDs7O2nFYWqbleFVRXO3nttZpxvOnaWCNG+qSwKACUV7CQCTkDfDGkbdUWMtQoOE0a4BABKRlOWC3W63bDab7HZ7Mm6HaWROpk9NXf16enutWrrDqS4HAFKK9hIAJgGHW4pFpDbmbTxZtGsAgJGMexj1kiVLdNtttykWi+ld73qXXn/9dfl8Pj311FNavnx5ksvEVGUzDJVkB7S/oVOPvlElp31sq1MbhqELSjJ19uz0U1MgAJxCtJcAMEm5/FLDHqn4nZJtlP4XDXukxt3SmTdMbG2TGO0aACAR4+rZ+Le//U3Lli2TJD355JOD3edvv/123XnnnUktEFOf3WZoQU5A0VhcPeHYmLaW7rCe31Wn3bUdqX4bADBmtJcAMEl5M6SuOqm7ceTjLeVS6WNSy8EJLWuyo10DACRiXGFjU1OT8vPzJUnPPPOMPvShD+m0007Tbbfdph07diS1QEwPDrtNuSGP8sa4zcn0yZD0/M46VTR1p/ptAMCY0F4CwCTlCkjhbqm9evixzjqp9HGGWY+Adg0AkIhxhY15eXkqLS1VLBbTc889pyuvvFKS1NPTw3wdSLqiDJ+6w1E9s6NW9R19qS4HABJGewkAk5RhSDaH1Lx/6P7eVmnXY1LHYSmtKCWlTWa0awCARIwrbPzEJz6hD3/4wzrrrLNkGIZWrFghSXrjjTd0+umnJ7VAQJLmZvnV2GktNNPKQjMApgjaSwCYxHyZUmuF1N9pPQ93S6VPSM0HpOyFViCJIWjXAACJGNcCMStXrtRZZ52lQ4cO6UMf+pDcbrckyW6364477khqgYBkLTQzLyegAw2demZnrd5/9iz53eP66wsAE4b2EgAmMU+a1FxmDaXOnC/teVqq22EFjTa+zxwJ7RoAIBHjakXLy8v1wQ9+cNj+W2655aQLAkZjt1krW++t69Tzu+p07dICuR0M1wAwedFeAsAkZnNIMq3FYJoPStUbpIwSye5KdWWTFu0aACAR4xpGvWDBAl122WV65JFH1NfHHHqYOC6HTXMz/dpe3aaX9zSovKl7xK22vTfVpQIA7SUATHbukNS4W6r4hxQqkly+VFc0qdGuAQASMa6wcdu2bTrnnHP0ta99Tfn5+frMZz6jN998M9m1ASPyuuwqTPfpnwea9V+vV464/fnNKu2u7Uh1qQBmONpLAJjkfFnWqtP+bMkTSnU1kx7tGgAgEeMKG8866yzde++9qqmp0YMPPqi6ujpdcsklOvPMM3XvvfeqsbEx2XUCQwTcDp2eH9S8HP+IWyRq6vlddaps7k51qQBmMNpLAJjkHG6pYJkVOuKEaNcAAIkYV9g4wOFw6IYbbtBf//pX/eQnP1FZWZm+/vWvq6ioSB//+MdVW1ubrDqBYQzDkG2UbXamT139UT2zo1b1HQzxAJBatJcAgOmEdg0AcDwnFTZu3LhRn//851VQUKB7771XX//611VWVqY1a9aopqZG119/fbLqBMasOMuvho5+PbOjVm094VSXA2AGo70EAEwntGsAgOMZ12rU9957rx588EHt3btX11xzjR5++GFdc801stms7LKkpES/+93vdPrppye1WGAsbIaheTkBHWjo1LM76/S+ZYXyu8f1Vx4AxoX2EgAwndCuAQASMa7k5f7779cnP/lJfeITn1B+fv6I58yZM0cPPPDASRUHnCy7zVBJdkClhzvkddp19ZJ8uR32VJcFYIagvQQATCe0awCARIwrbNy/f/8Jz3G5XLrlllvGc3sgqVwOm4qz/NpS1SqP06YVi/NltxmpLgvADEB7CQCYTmjXAACJOKkxpT09PaqqqlI4PHQ+vKVLl55UUUCyeV12FaZ79cbBFvVGYvI6k9e70eu064KSLHld9JgEMDLaSwDAdEK7BgA4nnGFjY2Njbr11lv13HPPjXg8FoudVFHAqRD0OBU3pV01HTKTeN9INK623oiuPqtALsdJrbkEYJqhvQQATCe0awCARIwrbLz99tvV1tam9evX67LLLtOqVatUX1+vH/3oR7rnnnuSXSOQNGlep9K8zqTesycc1eaqVvmcdl1xRp5sDNEGcATtJQBgOqFdAwAkYlxh45o1a/T444/r/PPPl81m09y5c7VixQqFQiHdfffduvbaa5NdJzBp+VwOFYS8WnewWX63QxcvyE51SQAmCdpLAMB0QrsGAEjEuMZ8dnd3Kzc3V5KUmZmpxsZGSdKSJUu0efPmhO9z99136/zzz1cwGFRubq7e//73a+/evUPOMU1TK1euVGFhobxer5YvX65du3aNp2zglAl5ncr0ufTK3kZtPdSW6nIATBLJai8BAJgMaNcAAIkYV9i4aNGiwVDw7LPP1u9+9zvV1NTot7/9rQoKChK+z9q1a/WFL3xB69ev1+rVqxWNRnXVVVepu7t78Jyf/vSnuvfee/XrX/9aGzZsUH5+vlasWKHOzs7xlA6cMlkBt9xOm14srde+ev5+AkheewkAwGRAuwYASMS452ysra2VJH3/+9/Xu9/9bj3yyCNyuVx66KGHEr7PWycWfvDBB5Wbm6tNmzbpXe96l0zT1C9+8QvdeeeduvHGGyVJDz30kPLy8vToo4/qM5/5zHjKB06ZgjSvqpq79dzOWnmdds3O9KW6JAAplKz2EgCAyYB2DQCQiHGFjR/96EcHvz7nnHNUUVGhPXv2aM6cOcrOHv98de3t7ZKsLvmSVF5errq6Ol111VWD57jdbl166aVat27diGFjf3+/+vv7B593dHSMux5gPGZn+nSwqVvP7KjVe5cVKugZ+X+zgMvBYjLANJeM9pJ2DQAwWZxsu0abBgAzQ8Jh41e/+tWEb3rvvfeOuRDTNPXVr35Vl1xyic466yxJUl1dnSQpLy9vyLl5eXmqrKwc8T533323fvCDH4z59YFkMQxDJdl+Hajv0p/frNJoceLC3ICuXlIgp31csxkAmKSS3V7SrgEAUimZ7RptGgDMDAmHjVu2bBnyfNOmTYrFYlq0aJEkad++fbLb7TrvvPPGVcgXv/hFbd++Xa+99tqwY4YxNK4xTXPYvgHf/va3hzSIHR0dmj179rhqAsbLZhhakBdQd39U5gjHYzFTm6ta5XPZdfnpefRwBKaRZLeXtGsAgFRKZrtGmwYAM0PCYePLL788+PW9996rYDCohx56SBkZGZKk1tZWfeITn9A73/nOMRfxpS99SU888YReffVVFRUVDe7Pz8+XZPVwPHbC4YaGhmG9HQe43W653e4x1wAkm80wFPQ4Rz1utxlaV9Ysv9uht88f//QDACaXZLeXtGsAgFRKZrtGmwYAM8O4xm/ec889uvvuuwcbGEnKyMjQj370I91zzz0J38c0TX3xi1/U3//+d61Zs0YlJSVDjpeUlCg/P1+rV68e3BcOh7V27VpdfPHF4ykdmDRCXqcyfC69vLdR2w61pbocAKdAstpLAAAmA9o1AEAixhU2dnR0qL6+ftj+hoYGdXZ2JnyfL3zhC3rkkUf06KOPKhgMqq6uTnV1dert7ZVkDZ++/fbbddddd2nVqlXauXOnbr31Vvl8Pt18883jKR2YVLICbrkdNq0urdf++sT/3wEwNSSrvQQAYDKgXQMAJGJcq1HfcMMN+sQnPqF77rlHF110kSRp/fr1+sY3vqEbb7wx4fvcf//9kqTly5cP2f/ggw/q1ltvlSR985vfVG9vrz7/+c+rtbVVF154oV544QUFg8HxlA5MOgVpXlU2d+vZnXXyOO2anelLdUkAkiRZ7SUAAJMB7RoAIBHjCht/+9vf6utf/7o+9rGPKRKJWDdyOHTbbbfpZz/7WcL3Mc2Rls4YyjAMrVy5UitXrhxPqcCUMCfTp4NN3XpmZ61uPKdIOUHmsgGmg2S1lwAATAa0awCARBhmIonfKLq7u1VWVibTNLVgwQL5/f5k1pYUHR0dSktLU3t7u0Kh0LjusaGiRc/sOKyFueO7HkhE3DS1v6FT87IDWlKUpolYn9owDJVk+ZXmG30hG2AiJePf7Mkome1lUj6j138j9bZKocJx1wEA015XvWR3Su/82rgun65tmpS8dm06f0YAMN2M5d/scfVsHOD3+7V06dKTuQWAI2yGofnZAZU3d6uiuXtCXjMWN3VaXlDvP2eWAu6T+ucAwHHQXgIAphPaNQDA8ZAuAJOIw27TwtyJm480Eotrf32nnt9Zq2uXFsrjtE/YawMAAAAAgOlnXKtRA5genHab5mb5ta26XWv2NCgai6e6JAAAAAAAMIURNgIznMdpV1GGT2+Wt+i1/U2Kx8c9jSsAAAAAAJjhCBsBKOB2KDfo1msHmrSpqjXV5QAAAAAAgCmKsBGAJCnd51LA49BLu+u1s6Y91eUAAAAAAIApiLARwKDcoEd2w6bVpfU62NiV6nIAAAAAAMAUw2rUAIaYleFVRXO3nth6WCGfM2n3NSSdOydDy2anJ+2eAAAAAABgciFsBDDMnEyfmrr61dodTto9w9G4nt9VJ5fDpjMKQkm7LwAAAAAAmDwIGwEMYzMM5QY9Sb/voZYePb+rTj6XXXOz/Em/PwAAAAAASC3mbAQwYWZn+tTVH9UzO2pV39GX6nIAAAAAAECSETYCmFDFWX41dPTrmR21autJ3jBtAAAAAACQeoSNACaUzTBUkuNXRVO3nt1Zp+7+aKpLAgAAAAAASULYCGDCOWw2lWQHVHq4Q6tL69UfjaW6JAAAAAAAkAQsEAMgJVwOm4qz/NpS1SqP06YzC9PGfI+Q16k0r/MUVAcAAAAAAMaDsBFAynhddhWme7WurFkbK1rHfH1OyK0bzpl1SlbOBgAAAAAAY0fYCCClgh6nFuY6ZJrmmK4zJZU3deuZ7bW64dwiejgCAAAAADAJMGcjgJSz2ww57LYxbU67TfNy/Cpv6tazO2rVG2beRwAAAAAAUo2wEcCUNbDQzK7aDj2/q07haDzVJQEAAAAAMKMRNgKY0lwOm4oz/dpyqFVr9zYoHh/bcGwAAAAAAJA8hI0Apjyvy66CNK/WHWzW6webxjz/IwAAAAAASA4WiAEwLYQ8TkVjpl7Z2yify6Fz5mSkuiQAAAAAAGYcwkYA00am36VwLK6XdjeoqatfdsMY0/Uep13nzMmQ12U/6VricVNbq9s0K92rvJDnpO8HAAAAAMBUQNgIYFrJD3lU19GndWXNY742FjfV1NWvq5cUyGk/uVkm1h9s1ou7G1SY7tGN5xYp0+86qfsBAAAAADAVEDYCmHbyQx7lj6M3YU84qs1VrfK57Lr89DzZbGPrGTlg66E2vbK3UWlepw619OiZHbV6/zmzFHDzTy4AAAAAYHpjgRgAOMLncig/5NW6sma9UT72npGStL++Uy+W1svttCkn6Na8nID21Xfq+Z216ovEklwxAAAAAACTC2EjABwj5HUqw+fSy3sbte1Q25iuPdTSo2d31ioai6sgzStJctptKs7ya3t1u17a3aBoLH4KqgYAAAAAYHJgTB8AvEVWwK1wLK7VpfXyuexamBc84TWNnf16Zket2nujmpftH3LM47RrVoZPGypa5HfZ9a7TcsY9RBtIip1/lzqqpYxiKVgohQqlYIHk8qW6MgAAAABTHGEjAIygIM2ryuZuPbuzTh6nXbMzRw9h2nsjemZHrWrb+7QgNyBjhFWwA26HcoNu/eNAk3xuhy4oyTyV5QPH11YpdTdInbVD93vSpcwSqeh8KXuRZDv5ldkBAAAAzCyEjQAwijmZPh1s6tYzO2t1/bJZSvM6h50TjsX13M5alTV2aUFOQLYRgsYB6T6XIjFTa/bUy+u0a0FuIKn1el0EQ0jQ2R+VWsqkSK/UeVjqOCz1tkp9bdLhLdbmDkmz3ibNvkAK5qe6YgAAAABTBGEjAIzCMAyVZPu1v6FTj75ZKZtGDhJbesIqyfbLYT/xNLg5Qbdq2uJ6asdheR1JDAcN6bw5GbpkYfaIPSuBIQK5kt1pDZ8eEOmxQse67VLNJqm/Qzq4xtrS5lih46xzJSdDrQEAAACMjrARAI7DZhhakBNUV39UpmmOeM78nICcCQSNA2ale9XZF1EsPvL9xqM/Gtfa/Y3yue06by5DtDEOTp+UtcDaznif1FAqHXrTemyvsrbdT0hzLpJKLpV8WamuGAAAAMAkRNgIACdgtxkjDqE+GUFPcu8nSfUdfXppd4N8LofOKAgl/f6YQWwOKX+ptfV3Wj0dD71hzfFY/qpU/g+p8Gxp3mVS+pxUVwsAAABgEiFsBIBpIi/kUXVrj57fWSev067it6yKDYyLOyjNW271ZmzaK5W9bD0OzO2YOd8KHYP5ksMt2V3WEG0j8d6+AAAAAKYPwkYAmEaKMnwqb+rSMztq9YHzipQX8qS6JEwXhiHlnG5tHTVW6Hh4s7XQTEvZ8PNtTsnhkhxeyZdpDbv2ZUm+bMl/5GvmfwQAAACmHcJGAJhm5mb5VdbQpae31+rGc2cp3edKdUmYbkKzpHM+Jp3+XmtY9eHN1gIzsYikI3ORxiNSOCKFu6WeppHvE8iVFr9fyl08UZUDAAAAOMUIGwFgmrEZhublBHSgoVNP76jV+8+eJb+bf+5xCnjTpcXvszZJMk0rZIyGpVi/FAtL4R6pp/nI1mQ9djdJ4S6pq0F68z+k/GXSmTdY9wMAAAAwpfHTJwBMQ3aboZLsgPbWder5XXU6LS+Y1PsXZXjpMYnhDOPInI0uSYGj+7PmDz833CMdWC2Vr5XqtkmNu6XTrpZK3iXZ7BNWMgAAAIDkImwEgGnK5bBpbqZf26rbtKO6LWn3jZnSvGy/bji3KOmrdGMGcfmkxddLRedLO/5Hai2Xdj8uVb8pLfmQlDlvbPfra5f6OqS0Iiv0BAAAAJAShI0AMI15XXYtygsl9Z7ReFxlDV16dketrj97lrwueqHhJIQKpYu/JB16U9r9pNRZK637v9Yq18E8yZ9nze0YyJW8GdYq17GI1FEttVZKrRVSW6XU22rdb/aF0pIP0zsSAAAASBHCRgDAmDhsNpVkB1Ra2yGvy66rzyqQy2FLdVmYygybNOciKX+JFTgeWj/yKtc2pzWvY0+LZMbeehPr4dAb1qI05378yHBuAAAAABOJsBEAMGYuh01zMn3aXNUqn9OuK87Ik83G0FWcJJdfWvYRad5yqb1K6mqUuuqthWR6Gq3FZ7obj5wbkDKKpYy5UnqxlD5batonbX5Yqt8pvfFb6fxPSU5fCt8QAAAAMPMQNgIAxsXncqgg5NW6g83yue26eH62DObKQzIE863tWPGY1Nti9Wr0Z0vezOFzM+YvlS78nLTh91LLQWndr6QLPyt50iaudgAAAGCGY9wbAGDcQl6nMn0urd3bpG3V7akuB9OZzS75c6ScRZIva/RFYLLmW3NAukPW/I///KXVQxIAAADAhCBsBACclKyAWx6nXS+W1mtffWeqywGk0Czp4i9LvmyrN+S6X1qLyZhmqisDAAAApj2GUQMATlp+mkdVLT16bmedsvwuZQXcqS4JM50/W3rHv0lv/M5aufqf/5+1YIwnTfKkW4/edOvrQJ419yMLygAAAAAnjbARAJAUs9K9qmjuVmdflLARk4M7KL39i9LW/5Lqd0mxsLXATPcIw6oNu5RWJGXOl7LmSRkl1oI1AAAAAMaEsBEAAExfTo90/r9aQWNfu9TbZj32HXnsbZXaD1lft1Va28E11rXB/CMrXc+1ej4G8qy5IwEAAACMirARAABMf3aXtcCMP2f4MdO05nZsKZOaD1orWXc3SJ111nZo/dF7pBVZ4WP6HCl7oeQKTOz7AAAAACY5wkYAADCzGYa1wrUvSyq6wNrX3ym1lB/p7VgltVdJ0X4riGw5OHChlDZbyj1dyjndCiHp+QgAAIAZjrARAADgrdxBqWCptUmSGZe6Go6Gjy0Hpc5aK4Rsr5L2vyA5PFLOIilrgRVcejMkT4Y1lBsAAACYIQgbAQAATsSwWXM4BvOl2Rda+/rapcY9R7a9UqRHqt1mbcdyeKzg0ZtxZCXs0DGPadbm9Fs9LAEAAIApjrARAABgPDxpVvA4+0Kr52NblRU8th+yFp7pbbMCyGif1Quys3b0e9nsUtZCqfgSKXexFW4eTzxqBZw9zdbrO1gBHgAAAJMDYSMAAMDJMmxSRrG1HSvafyR4PBI+DqyC3d9xZFXsdincJcVjR3tJejOkue+QZl8kuY9ZgMaMW/NI1mySardaQaYklb8qnX2zlDlvQt4qAAAAcDyEjQAAAKeKw310+PVo4lGpu0k69Ka18nVvq7TnKWnfc1LB2VLhOdYckYc3W8cGuEOSDKmnSVr3K2neZdKiqyW781S/KwAAAGBUhI0AAACpZHNYYeTi90mL3iMd3iJVvGYNx67ZaG0DHB5r0ZrC86TshdYQ7V2PSdVvSgfXSA2l0tkfldJnp+ztAAAAYGYjbAQAAJgs7C5rDsaiC6yVryv/KTXtk9LnSrPOk3LPsM4Z4PRZQ6jzl0o7/lvqqpP++f9JC1ZIC6+y5oIEAAAAJhBhIwAAwGRjGCPPATma/LOkzGJpx9+s+Rz3Py9Vvia5/FZvSIdHsrsl55GvcxZJuWeyAjYAAACSjrARAABgOnAFpPNuteZ23PE3KdxtbSOp+IcVOJ55oxTIm9AyAQAAML0RNgIAAEwnhedavRa7Gqw5HWP9UuTIY7Rf6mmxFqJp3Cut/ak071JryLXDk+rKAQAAMA0QNgIAAEw3DvfxF4mZt1wqXSXV75LK1kjVm6wFagrPZWg1AAAATgphIwAAwEzjz5bO/1crbNy1Suppkrb8l7UgTfZp1vyODtfRuR4dLsnhlXwZktOfeCAZi0o2m2TYTu37AQAAwKRB2AgAADBT5Z1phYsHX5H2vyC1HLS247G7JV+mtXkzJV+WZHdKfR1SX7vU13b060i3ZHNa80IG8qRgnhTItx592ayWDQAAMA0RNgIAAMxkdqe0cIVU9Dap6nUp3CVFw9b8jgPzPMb6pXCP1N9hfd1Za22JiEekjmprO5bNIeUvk067ikVqAAAAppGUho2vvvqqfvazn2nTpk2qra3VqlWr9P73v3/wuGma+sEPfqD/+I//UGtrqy688ELdd999OvPMM1NXNAAAwHTkzZAWXXP8c2IRqbfFWmSmt0Xqaba+jkckd5rkGWGL9Eid9VJXndRZJ3XVW1ssLB3eZK2ePes8a5GaQO7xXz/cbV3nzUje+wYAAEBSpTRs7O7u1rJly/SJT3xCH/jAB4Yd/+lPf6p7771Xf/zjH3XaaafpRz/6kVasWKG9e/cqGAymoGIAAIAZzH7MkOhEufySP0fSWUf3mXGpvdoaul2/U6rZKNVssnpXLrzqyPmS+jul5jKp+YDUUna0N2WwUCo8Wyo4+8QBJQAAACZUSsPGq6++WldfffWIx0zT1C9+8QvdeeeduvHGGyVJDz30kPLy8vToo4/qM5/5zESWCgAAgGQxbFL6HOn8T0lth6R9z0kNu6TqDVbomHO6tWhNV8PI13YelvYelvY+I4UKrdCR4BEAAGBSmLRzNpaXl6uurk5XXXXV4D63261LL71U69atGzVs7O/vV39//+Dzjo6OU14rAACnCu0apr302dIF/yq1VR0JHUutTZJkSMECKWu+lLVAypxnhY11O6TarVLTPqnjsLXtfUZyB63Vsl2+4Y/uoOQKSp4jj+4gC9QAE4w2DQBmhkkbNtbV1UmS8vKGDtPJy8tTZWXlqNfdfffd+sEPfnBKawMAYKLQrmHGSJ8jXfBpqbVCat4vBQqkzBJrGPZbzbnI2sLdQ4PH/k5rS5TTb80rmXuGNW9kqDBZ7wbACGjTAGBmmLRh4wDDMIY8N01z2L5jffvb39ZXv/rVwecdHR2aPXv2SdVgmqZM0zypewAAMB6nol0DJrWMYmtLhMt/NHiM9FiL1UR6rJWzI93HPHZL/V1Hw8hwpzVvZKTb2joPS2UvWb0oZ51nbSxCAyQdbRoAzAyTNmzMz8+XZPVwLCgoGNzf0NAwrLfjsdxut9xud1Jr2Xm4Q3/bdFjLirq1uDBNc7N8sh0n8AQAIFlORbsGTEtOn5TmS+xcM24Fkf2dUletVLPFGrrdWSvtecraMudLhedYQ7eD+dbwbQAnhTYNAGaGSRs2lpSUKD8/X6tXr9Y555wjSQqHw1q7dq1+8pOfTGgtG8pb1NUf1T/LmvXPsmb5XXadXhDSmQUhzc8NyGnnm08AAIApw7BJ7oC1hQqkwnOt8LF2m7UydkvZ0U2S7G5rmPdAr8v0uda1AAAAGCalYWNXV5cOHDgw+Ly8vFxbt25VZmam5syZo9tvv1133XWXFi5cqIULF+quu+6Sz+fTzTffPKF13nzhHPVFY2rrjmhPXae6wzFtqmzVpspWOe2G5mb6VZztU0l2QEUZ3lHDx/5oTE2dYTV29cvvtqsk2y+HjaASAAAg5Vw+ae7bra23VTq8RWrYbS1cE+u35pFs3n/M+UfCSqff+trlP7qFCqWMeZJ90v5eHwAA4JRJ6XdAGzdu1GWXXTb4fGD+jltuuUV//OMf9c1vflO9vb36/Oc/r9bWVl144YV64YUXFAwGJ7ROj9Ou4iyfFp4RUixuqqK5W7sOd2h3bYfaeyM60NilA41dkhpktxmaneFVcbZfIY9TTV39auzsV0Nnv9p7I0Pu63bYdFpeUIsLQlqUH5THyYqIAAAAKefNkOZfbm1mXOqssxauaauQWiulrnop3GVto7E5rVW0c06XchZJgXyJaXgAAMAMkNKwcfny5cddeMUwDK1cuVIrV66cuKJOwG4zND8noPk5AV23tED1nf2qaOpWeVO3Kpq61dkfVUVzjyqae0a83u92KCfgUnNXWJ39Ue2oadeOmnbZDGleTkBnFIS0rChNPhe/CQcAAEg5w2b1VAwVSnMvtvZFeqzej+HuY7auIwvRdEgt5dZj4x5rkyR3mpS9UPJlHukN6bd6Uw587fRKNodk2CWbjTkiAQDAlEWidRIMw1B+yKP8kEcXzcuSaZpq7g4Pho894Zhygm7lBN3KPfI4ECLGTVPVrb3aXduh0toONXb260BDlw40dOnF0npdcUauLizJkt3Gb8ABAAAmFafP2kZjmlZvyKY9UuNeqblM6m+35oNMlGE7Ejwe2QybJNvRIHJgCxZIs94m5Z5uhZXADBONR1XRXqGYGUvaPW2GTXNCc+S2J76YTU+kR9Vd1cftTDMZFAWL5Hf6Ez4/EouosqNyXJ9vQaBAIVdozNeNpCfSo45wh/L9+WO67nDXYWV6MuVxeJJSR1tfm+p76kc8ZhiGigJF8h2vfRiDjnCHartqx3yd3bBrbmiunHZnUupItvH+WdZ01ajreCMKkJB8f77S3Gmn/HX4jiSJDMNQdsCt7IBbbyvOPO65NsPQnEyf5mT69O4z89XU2a/S2g5trmpVQ2e/ntpeq/UHW3TNknwtygvKGGXYTU84qr11nWrvjSgrYIWaWQEXc0ECAACkimFYC8+ECqR5l0mxiNRaLrUctFbADndbvSMHekVGeqRYeOg9zLi1xSMjv8aArnqpdqsVfhaebQWPGSUM2caM0dTbpOcqnlNnuFOGkvT33pCW5izVijkrEgps+mP9Wl25WqXNpcmr4RQwZeq0jNN0dcnVCQVi0XhUaw+t1eaGzYqb8TG/Vklaid47770KuE5uQa3eaK+er3hedT11urbkWs0JzUnoun2t+/RixYuamzZXV8296qTDt9a+Vj118ClVd1aP/OdsSKdnnK73lLznpMPNjnCHni57WhUdFWP+O2UzbDo371xdNvsy2W2Ta6q2vmifXqh4QbU9tXpP8XtUklaS0HVlbWV6tvxZwsaTZMrUFXOu0AUFF5zy1yJsnCSyg269K5ijSxZma2NFq1aX1qmpq18Pv16pBbkBXbOkQPkh6x+spq5+7ant0O66TlU2dyv+ll+e2Qwp03+0N2VOwAogM/0uBdyOUYNLAAAAnAJ2p5R9mrWNJh6TzJj1OPh19OjXpnk0gBzYYhGpcbdUs9katl25ztq8mdKscyVP+pHQ0Rj6aHdLeYslu+vk35tpSjKPeQ1gYpmmqb5oX1J7cvVGerW1Yau8Dq8uLbpUtuNMazAQyO1q3qU5wTlyOxLvDTnRwrGw9rbulcfhOWH4Zpqm1teu18aGjcr354+pN6RkfS5lbWV6sfLFkwrfIvGIXjn0ikqbS+W0OfVCxQu6bv51yvPnHfe6Q52H9FLVS+qOdmtb4za57e6TCt+6I91aXbla1Z3VKkkrGfE+/bF+7WrZJY/DoyvmXiGnbXx/H3ujvXqp8iUdbD+oeenz5Bhjr/WucJc21m+Uz+HT2wvfPml+/o/Go9afZUupHDaHXqx4Ue+d/14VBAqOe11NV41erHxR4XhY8zPmT0yx01RZa5lMTUzva8LGScZmGLqgJFNLi9L0yt4G/bOsWQcauvSrl/ZrcWFIDR39auzqH3JNfsij/DSPmrushWj6o3E1dfWrqatfekuva5fdpky/FTxm+V1yO22yGYYMw5DNsF7fZkhOu7V4Tcg7ObteAwAATCs2uyS7NNafg3MWSWe8T2rabw3Trt0u9bZIB148/nUuv1T8TmtzHSdECHdJ1RukQ29KfW1HelvGJQ08HvmhxbBZi+LYnVaIaXdZXzu9Us4ZUuE5kjd9jG8OSA2v06t8f77erH1TPodPFxZcOOJ5cTOu1w+/rk31m1QYKJzUQaMkuewuFQWLtK1h22CQOlr4trVxq14//LqyvdljDholyWFzaG7aXJW2lMrj8OjKuVeOOTSLm3G9VvOatjRs0ezgbHkcHpW3l+uFyhd03bzrlO5JH/G6xp5Gra5Yra5wl+aG5qo70q2N9Rvld/p1UcFFYw7f+mP9eqnqJR1oPaDitOJRPzO33a2iQJG2NGyR1+HVO4veedygeiSD4WpLqYrTisf8mUlSwBVQNB7VusPr5HP6dHbu2WO+R7LFzbjW1azT1oatmhWYJa/De/TPcv51yvSMPDK0qbdJL1S8oPb+dhWnFU9s0TgphI2TlMdp13vOKtAFJVl6dmetdh3u0K7DHZKsnovzsgM6vSCo0/NDyvQf/a20aZrq6IseWQG7Tw2d/Wru6ldLd1htPRGFY3HVdfSprqPvhDXYDOmMgpAuLMnS/Bz/pPmNCAAAAI5h2KzQMWeRtORDUv1Oqb7UGpo92PPQPJILHplPsrdF2vecVLZGmnORNdzbm2HdzzSl5gNS1etS3Tard+WJmHEp1m9tb9W0T9r9hJQ5z+pxWXD28QNOYBIIuoKKxCN6reY1+Rw+LclZMuycLQ1b9Prh15XjyxlXIJcKXodXBYECbajbIK/DO2L4tqdlj9YeWquAK3BSc7u57W7NCszSloYt8jl8uqTokjGFbxvrNurN2jeV78+X1+mVJM0NzdXB9oNaXbla1867dthw8Pb+dj1f8bwaeho0L32eDMNQwBU4+mfp9GlZzrKEa4jGo3r10Kva2bhTc0JzTth71uf0KdeXqzdq35DP4dP5Becn/FoD4erWhq2aHZgt10n0Pk/3pCsSj2ht9Vp5HV4tylw07nslw6b6TVpfu145vpzBP7PitGKVtZXphYoXRhxu3xHu0AsVL6iuu27wzxJTB2HjJJfpd+mjF85VeVO39tZ1qDDdq9PygvI4R/5timEYSvM6leZ1akHu0P9Zo/G42rojau7uV3N3WK3dYYVjpuKmKdM0FTd15GuprSesQ629gyFndsClC0qydO6cdFbKBgAAmKzsLqnwXGsbTTwm1W6Tyl6SOmqk8lelitesa4IF0qH1Unfj0fNDRdLct0tZC4YuTjO4GdY9Y2FraPfgY0TqaZZqt1jzVbaUWdvO/yflnC7NOk/KX5Kc4dzAKZDpyVQkZvU08zl9mp9+dAhnaXOp1h5aq5A7NCGLLSTTQPj2z5p/yu/0a2nO0sFjlR2VeqnyJWs9Am/2Sb/WQPi2vna9vE6vzs9PLHzb2bRT/6j5h9I96Qq6goP77Ta7ikPF2t+6Xy9Wvaj3FL9nMJTrifToxcoXVdVZpXlpQ8OpDE/GYK9Br8Or0zKOM63FEQNDyTfVb1JhMPGeqyF3SJF4RP+o+Yd8Tp/OzD4zoes21m3UhtoNyvPnDYarJyPHl6Oazhq9VPWSfA6fZodmn/Q9x6O0uVT/qP6HQu6QQu6jCwbZDJtK0kp0sP2gXqx8UVfPu3pwUaaBoeQVHRUqSSsZcw9RpB6p0RRRku1XSfbJ/bbMYbMpO+hWdjCxfyTrOvr0ZnmztlS1qakrrGd21OqFXXVaXBhSUbpXuSGPcoNupXmd/JYBAABgqrDZrR6GhedITXulAy9JzfuHrpZtd1vnzLlYSj/JH1BL3in1tkqHt0g1m6yAs6HU2hweK3ScfaGUNvv48z5G+6XOw9aclJ4Ew514zAo4wz1S3lmSnR9/MDZ5/jwd6jyk1ZWr5XF4NCswS+Xt5VpTtUYOm0NZ3qxUlzguA+Hby4deltfh1cKMharrrtPqitXqjfZqbtrcpL3WYPhWfSR8yzp++FbWVqY1VWvktrtHHF7rtDs1OzRbO5t2ymf3afmc5TJNUy8fell7W/eqODTyUOdcX64VvlW+JK/de8LwbaDnarZv7EPJs7xZisQjWnNojbwOr+alzzvu+QPhapo7bUi4erJmBWepsr1Sz1c+r/fNf59yfblJu3ciDrYf1JqqNXLanSP+v+KwOTQnOEelLaXyOX26fM7lMmUeHUoeGt9QcqQef2oYVX7Io/ctm6V3n5mvbYfa9UZ5s2rb+7S9ul3bq9sHz3M5bMoNupUb9Cg74FLoSM/KNI9TIa9TLge/hQAAAJh0DMPqYZhzutRWJR18xVotu/BcadY5VhCYLN4Maf7l1tZZJx3ebM0F2dsqVf7T2oIFVug4622Syyd1NUhtlVJrhdRaKXXWanCOyLQiKfdMKe9M6+tje73EolaIWrdNqttprfYtSYF8adlHpIzi5L0vzAhFgSJVtFfohYoXdFHBRXqt+jX1xaxFaaayXF+uqjur9WLVi4rEI9pUv0nNfc0JrxA8FgPh28tVVrg5L23k8K2mq0arK1crakY1OzB6GOhxeFQYKNTGho3yOD0Kx8La3rhds4OzjzvUuTBQqMqOysG5AkcL3/a07NHa6pMbSp7vz1dVR5VWV67WdY7rVBgoHPG8srYyvVz1shWuekeeu/BkzAnNseZHPLK4zkT1xK3tqtWLFS+qP9Z/3BXE3Q5ruP3m+s3y2D2KKZaUoeRILcJGnJDbYdcFJZk6vzhDh1p7ta++Uw0d1nyQTV39Ckfjqm7tVXVr74jXe512pXmdcjttctgMOWw22W2GHHZDDpshp92mogyvFuQGlcaCNAAAABMvfY507scn5rWC+dKia6TT3nNkbsg3rGCws1YqfUza/aTkcEmREb63dAWkcLfUXm1t+5+X3CEpd7GUPte6X8MuKXrM/OQD80N21Un//KU071Lr9fkhFgkyDENz0+bqYJvVS6sr0nVKArlUmBWYpcqOSq2pWqPOcKdK0kpO2ai1gfDthYoXlO/PH/Gcxp5GdfR3JLQYiN/pV7Y3W68ffl0xM6Z8f/4JV702DMOa97HtoJ45+Myoi8xUd1bLZthOeij57OBslbeX69nyZ0ftBVvbVauIGTluuHoyBt5zeXu5nix7ctjciKdKc2+zWvtbE/p/xef0KceXo/W16yUpaUPJkTqEjUiYYRiak+nTnMyjk/DG4qaajqyC3dDRp9aeiDp6I2o/soVjcfVGYuqNHH9i8TfKrcecoFsLcwNakBtQSbZfbsdYl2QEAADAlGDYpOzTrC38Aau346E3pPZDVtBoc1ohaMZcKb3YevSkWb0vG0qtRXAa90j9HdY8k4fWH723OyTlL5UKllkL00T7pF2rrKHiB1+xejwu/V9S9sJUvXtMMQPzyzX3Nas4rXjaTCM1EEQ19jYed6XlZJkdnK2GngaVt5ePeHxgFetEP9+BXno2w5ZwiGYYhorTitXQ06DW/tYRz3Hb3crz5yV0v0Req76nXh3tHSOe47Q5VRQoOunXOh67za65oblq6G1QY2/jiS9I0muO5f+VY+dzTOZQcqQGYSNOit1mKC/kUV7II80a2h3bNE31R+Nq77UCyP5oXNG4qVjceozGTMXipnrCUZU3dau6tVeNnf1q7OzXurJm2Q1DszN9KsrwqiDNo4J0r3ICbtltw/+xisTig6FnU1e/0jxOLS4IyefmrzgAAMCk5/JJxZdYW1e9tbhMsMCaX/Kt3EFruPXsC60h0y1lUv0uK6TMmCvlL7Mejx1a7fJL53zMGiK+469ST5O0/j5p7sXSvMutwLKnSeputlbq7mmWnD7prBsn7jPApGe32Sd8zruJYBjGhL0vwzCSEuIdazzDgu02uwoCBUmtYzQ2w6YC/8S81vE47U7NCsxKdRnHdWzgiKmNJAanjGEY8jjt8jjtVhh5Ar3hmMoau7S/oUsHGjrV2hNRRXO3Kpq7B89x2Azlp3lUkOaVx2FTQ2e/Grv61dodHpjBZ9BjW2u0IDegJbPStLggTV4XvSQBAAAmvcAYggi7Q8pZZG2JyFssZd4h7X5CqlonVR7ZRuLNSLwOAAAwiLARk4bXZddZs9J01qw0maaplu6wypu6dbi9T7Vtvart6Dvu/JBep105QbeyAy7Vtveptr1P++q7tK++S48ZhweDxwV5AYU8zA0JAAAwIzk90tIPW6tx7/wfqbvJChZ9WdZK1/4syZs1tGckAABIGGEjJiXDMJQVcCsr4B7cFz8SQB5u61Vte5/CsbhyAm7lBt3KCboVcDuGzAfR1NmvHYfbtaO6XXUdfdpb36m99Z2SpAyf05p/MsuvuZk+5YU8Iw7PBgAAwDSVvVBa/u+SGR85WOyqn/iaAACYBggbMWXYDEPZAbeyA24tTWD+3OygW5ctytVli3LV0NGnHYfbtftwh2rbrYVsWnvata26XZLksttUmO6Rx2mXw26T02ZYj3ZrtWy3w6aA26Ggx6GAx6mg2yG/20FACQAAMNXRgxEAgKQibMSMkBvy6IqQR1ecnqe+SEzVrb2qbOlWVXOPqlp61B+Nq6K5Z0z3NCT53A5lB1yam+nTnEy/5mT5FGBRGgAAAAAAMEORimDG8TjtWpAb0ILcgCRreHZDR7/qOvoUicUVjcUViZmKxo88xuLqi8TV1R9VZ19Enf1RdfVFZUrq7o+quz+qyuYeSU2SpCy/68gQbZ+y/G753XYF3A75XPSEBAAAAAAA0xthI2Y8m2GtcJ2fduIVswfETVM94Zg6eiOqa+9TZUu3Kpt71NDZr+busJq7w9pyqG3YdT6XXX63Qz6XXYYMSaZMUzIlmaa1nrbTblNeyKOCIzXlhTxy2hneAwAAAAAAJj/CRmAcbIahgNuhgNuhwnSvzp2bIUnqDcd0qLVHlc09qm7tUUdfRF39MfX0Wz0he8Ix9YRjJ7z/wabuwa8NWfNPFqR5lBt0K8PnUqbfpQyfSwGPQzaD3pIAAAAAAGByIGwEksjrsuu0vKBOywsO2T/QE7K7P6qu/uhg4DgQE1qjqw0ZhhVY1nX0qbbdWnW7JxxTY2e/Gjv7h72ew2Yo3edSpt+pdK9L6T6n0rxOpfms5yGvQw4bvSIBAAAAAMDEIGwEJsCxPSHzxnCdaZrq7Iuqtr1Pde29auoKq6UnrNaesNp7IorGTTV19aupa3gQKVlhZsDtUMDjkN/lkO/I/JF+t/U8zevQnEy/vC57Ut4nAAAAAACY2QgbgUnMMAyFvE6FvE4tyh/aWzIWN9XeG1FLtxU+tvVE1N4bUVuvFUS291phZGd/VJ390dFfQ1Jhulfzsv2al+NXcZZfbufJhY+xuKm+SEx9kZh6j2ySVJzlZ/5JAAAAAACmMcJGYIqy2wxl+q35G0dimqa6jyxi03Vk1ezu/qi6w7HB51avyLBq2npV09arfxxoks2QZqV7lRfyaGA6yCNr1wyKxk2Fo3FFYnGFY3FFotZjOBpXX9R6HInXadfSojSdNzdDs9K9MphvEgAAAACAaYWwEZimjGOGbh9PR29EB5u6dLCxWwebutXSHdah1l4dau096RpcDpu8Tru8Trt6wlF19EX1RnmL3ihvUV7IrfPmZOjsORknrBEAAAAAAEwN/IQPzHAhr1Nnz87Q2bOtFbVbe8I62Nit9t6IRut46LAZctptcjls1uPg18ZguOh22mW3Hb1B3DRV1tilTZWtKj3cofqOfj2zs07P7arTvOyAsoMuZR5ZaTvT71aG3ym3g7kkAQAAAACYSggbAQyR4XPpvLkjD80+GTbD0MLcoBbmBtUbjmlbdZs2V7WqurVXBxq7dKBx+DUBt0M+l11Ou012myGHzZDDbshhs8lhNxR0O5Thdw2uxJ3hc8njtDE8GwAAAACAFCFsBDDhvC67LpqXpYvmZam+o09VLT1q6Q4P2Xoj1tySXcdZ3GYkbodN6T6nQh6ngh6ngh6HQh6Hgh6nQh6H3E67onFT0VhckZipSMyaezIaM5Xuc6o42y8bYSUAAAAAAONC2AggpfJCHuWFPMP294ZjaukJqy8SUzRmKhqPHwkJra8j0bg6+qKDK3G39YTVHY6pPxpXfUe/6jv6x1VP0OPQ0llpWjY7nUVsAAAAAAAYI8JGAJOS12XXLJd3TNeEo3G19YTV1htRZ19UnX0RdRx5HHjeF4nLabfmnHTareHYA8O0a1p71dkX1T/LmvXPsmZl+V1aNjtdy4rSlR04OrScABIAAAAAgJERNgKYNlwOm3JDHuWO0FMyEdFYXPsburStuk27azvU3B3Wmj0NWrOnYdRrDElup00eh10ep10ep+3Io7X5XNbmddrlczkGn9tthqIxU5G4NYQ7cmRYdzQel80YCEOPhqJOuyG3wy6vi0VzAAAAAACTF2EjABzhsNt0RkFIZxSE1B+NaXdth7Ydatf+hk7FzZGvMSX1ReLqi8Sl3sgprzHL79LCvIAW5gY1L9svt5PwEQAAAAAweRA2AsAI3A67zp6dobNnZygctRaRGSlvjJum+iNx9UVi6ovGjgSPMfVFYuqNxNQbjqknHFNPOHrM1zHFTNPquXhkZW2H3SanzXqMm0d7Og4sYBOJmYrFTTV3h9V8sEXrD7bIbhiak+XTwtyA5mb5ZTOkuGnVFI+b1qMpOeyGMrwupfmcctptE/5ZAgAAAABmDsJGADgBl8Mml+M4Id34Rm2PWV8kpoONXdrfYG0t3WGVN3WrvKk74XsEPQ5l+FxK9zmV4XPJ5bDJNCXJlGlqSKA6cO7A+QSVAAAAAIATIWwEgCnC47RrcWGaFhemSZKau/oHg8e69l4ZhiGbYchuk2xHvrYZUn80rraeiMKx+JGFcqKqahn764eOhI+ZfpeKs/2anxNQhs/JgjkAAAAAgEGEjQAwRWUF3MoKuHXRvKwTnmuapnrDMbX2RNTaE1ZbT1itPRFFYnEZhmTI0JH/ZBwZjt3Ra53b2m0FlR19UXX0RVXZ0qMth9okSek+p+ZnBzQvx6/iLP+pfcMAAAAAgEmPsBEAZgDDMORzO+RzOzQrwzuma03TVE84ptaesFq6w6rv6NfBpi4daulRW09Em6patamqVZJ01eK8U1E+AAAAAGCKIGwEAByXYRjyux3yux0qyvAd2Zun/mhMlc09OtjYpbLGbtW29yon6E5prQAAAACA1CJsBACMi9th12l5QZ2WF5Qk9fRHVdvRl+KqAAAAAACpxNKiAICkcDvtqS4BAAAAAJBihI0AAAAAAAAAkoKwEQAAAAAAAEBSEDYCAAAAAAAASArCRgAAAAAAAABJQdgIAAAAAAAAICkIGwEAAAAAAAAkBWEjAAAAAAAAgKRwpLoAAAAAAADGIxwLq7KjUj3RHnkcHjlsDjkMhxw2h+w2uyKxiPpifeqLHtmOfN0f65cpU9Z/piQNPnfancrz5Snfn68sb5ZsxvH76Jimqe5It3qjveqP9as/1q9wLKz+WL/6Yn2KxCKyGTarJsM+5NFm2GQYxoj3ddqcCjgDCjgD8jg8o56XCNM0FY1H5bA5Tuo+JxKOhdUT6VE4Hpbf6ZfP4Rv360ViEXVFutQZ7lRPtEdprjTl+nJlt9kTur470q2ucJe8Dq98Tp8ctvHHH3Ezrvb+drX1t8lpc8rj8Mjr8Mpj9yRcz0wWi8fU2Nuo2u5aNfQ0KN2drvnp85XlyUra38eBv+OReETheFjhWFiReEROm1M+h08+p2/U/5fjZlxdYevv2sDfN8MwZJP1/6fNsMmQ9eh2uJXtyVbQFUyodtM01RfrU3+0f7Cu/li/IjGrzrgZV6YnU7m+XHkcnnG9775onzrCHeqMdKo73C23w62gK6iQKyS/03/Cf8NOBcJGAAAAAMD/397dB1lV13Ec/5z7fPcRlo194MlFTUyUbOlBosRqMKMahxkjJhGVmkGEQMaSkUpzIvjLsWYSB2ocyxqkJDPHyrWUMJwwYBOlIJEHg102Hvb5Pp9ff1zv2T3s8rTc3bt77/vFnLm755579ne+99z7Gb77O3dHpM5Ep17976uDtn+fx+c0HquLq+Xz+NQabVVbrE1t8bb0baxNKZMatDFIksfyqMRfomJ/sYr9xQr7wgp4Awp4Aunb9xe/x6+uRJfa4+3qjHemGxDvN1BSJiWP5XGaZE7DzBdS0BuU1/LK6/G6GqJej9dp4iTtpJImqZSdcpo6kWRE3YludSW71J3oVsJOuMbttbwqCZQ4jY9Sf6mCvmB6H732lTTp/UeSEXXGO9WZ6FQsFetTB6/lVXVxtWpLatNLca0qQhU6HTut413H1dzVrOPd6dvORKfrsX6PX0X+IhX5itINyPdvQ76Qwv6wwr70EvQG1Rnv1InICWc5GTmppEn2+9wEPAGnoVkeLNeo4Kj0EhrlfO33+BVPxRVJRRRNRtON6WRMkVREKTslIyNjjJx/Jr2cWaPM17axnec86A06t0FvUJZlKZaMOc3uTPM7mozKsizX9s6tJ+BqfFvqdWupZ2xn3GbOzUwjLrMPjzxqi7epqbPJaTD29xopD5br8vLLdcWoK3RZ+WVOsy1pJ9Uaa9Xp6Gmdip7S6ehpdcQ7lLATzpJMJZ2v43ZciVTCGdPZZJ73In+RQt6QupPdzmvlfI89k9/jV2W4UmPCYzQmNEaV4UrZxlZrrFXt8Xa1xlqd94czXxdnUxYo09iisc5SEihJnyfJiLNkzp/ORKfTID3buSn1vHeUBco0oXSCbtJNF3WcA0WzEQAAAAAwYo0Nj5XH8ihl3I2rpJ1UwBtwGmvOrS+kgDcgjzxK91LcDZZIMqLm7mYd7zquhJ3Q0c6jOtp59LzjCHlDCvqCCnlDThMn5A3J7/XLNraSdrJnjO9/nbLP3qSM23F1xjsVTUVlG1vt8Xa1x9svqVa2sdWV6FJXouuS9nMuXsurgDegSDKilEk5DZeB8Hl8KvWXKuwL61T0lKKp6AU/H5JU5CtSJBmRkVHCTlzSWLyWV6OCo5Q0SWd2rJR+nuLxeLq51tXU72MtWRfdzMo3IW9I1cXVGls0Vv+L/E9H2o+oLdamXS27tKtllyxZqi6uVneye8DPUYbP8jnN97gdVyQZkSSnYXcyerLPYyxZKg2UqjRQqiJ/kWQkW7aMMbKNLaP0bXeiW6eip5SwE2rqajrrc362MbkWT0CSdCJywnl9t8fb9U7rOxd9zGFf2JnJGEvFnCZq7/eOqqKqi97vQNFsBAAAAACMSBWhCt1Sd4tqS2rl9/qzum/b2DoVPaXjXcfV1NWk413HZctWeaDcmcFWHkx/XRYoG7TLaZN2Mn1JcKLTuTS496XaCTvhfJ+wEyryFfXMJHy/eVIaSDfsYqmYMzsqmow6M+3iqbjTCLWN7XydslOyLMu5PN3rSc96zHyfmdFX7C9O3/qKFfAGZFmWUnZKnQn37MqOeIdiqVi/+/J6vAr7wulLxwPpy8czM/Wk9Oy609HTOtZ1TEc7j+pY5zE1dzUrYSdcM1CriqpUVVylqqIqBbwBGWMUS8XUnexWd6Jb3cluRRIR12yx3jPGoqmoivxFqgxVqrKoUpXhSlWGKjUqNMp1Oapt7J7HJKPqTHQ6l1q3xlrVGk3fRlNRp9HotbzObMpM89vn8cmSJcuy+tw6HwmQmW36fs088ihux51Lc3tfvm8b22l0B31BZ8Zj0BuUkXG2y5w/mdvMjEWp70cL9De2THM+04TLLJnmXJG/SDXFNaopqVFNcY1GBUe5LjvOfATCgdYDOtB6QCejJ12NO7/Hr4pQhUaHRmt0aLTKA+VOA9Hn8cnv9cvv6VkyzTu/19/nsmHb2IokI+pKdDnnQDQZTb9Wghd/uXHKTul07LRORk72zH6NnnQa0mWBsj7vD+d7f4okI/pf9//U0t3iLJFkxJmB7MzCfX9mcrG/2PX67u9jAjKXh2deg9Fk9IKOLxtoNgIAAAAAcAaP5Uk3msKVuqbympyNw+fxOU2LSxXyhbKynwvh9XizNm4p3fCqCFeoIlyhqZVTJfU0U0oCJWdtFFmW5cxorQhVZGUsUvr8KPKnL8k9l0gyoqSddGa5Ii3gDejK0VfqytFXSpJao61q6mpSsb9YFaEKFfuLs/Z5jh7L43wEQTZ4PV7nveEqXZWVfYZ9YU0sm6iJZROzsj8pfdxlwTKVBcskSQdOH8javs+HZiMAAAAAABhxMs2U4SzsC+d6CCPCqFD6cy6RH4b+T9IAAAAAAAAAyEs0GwEAAAAAAABkBc1GAAAAAAAAAFlBsxEAAAAAAABAVtBsBAAAAAAAAJAVNBsBAAAAAAAAZAXNRgAAAAAAAABZQbMRAAAAAAAAQFbQbAQAAAAAAACQFTQbAQAAAAAAAGQFzUYAAAAAAAAAWUGzEQAAAAAAAEBW0GwEAAAAAAAAkBUjotn4+OOPq66uTqFQSPX19dq2bVuuhwQAAAAAAADgDMO+2fjMM89oxYoVWr16tXbv3q1PfepTuuWWW3TkyJFcDw0AAAAAAABAL8O+2fjoo49q0aJF+vrXv66rr75ajz32mCZMmKD169fnemgAAAAAAAAAevHlegDnEo/HtXPnTq1atcq1fvbs2dq+fXu/j4nFYorFYs737e3tgzpGAAAGE7kGAMgXZBoAFIZh3Ww8ceKEUqmUqqqqXOurqqrU3Nzc72PWrl2r73//+1kdhyXJY3m0/3hHVvcLAPmmJOSTx7JyPYy8Mhi5Jq9firZJUf6TBwBnZ6RRE3M9iLwyKP9XsyyFfWEdbj+c1f0CQL6xZMljDc0FzpYxxgzJTxqAY8eOady4cdq+fbtuuOEGZ/2aNWv0i1/8Qv/+97/7PKa/35ZNmDBBbW1tKisrG9A4OmNJHWuNDOixAFBIPJalSWOK5PcOLMTa29tVXl5+Se/Z+WYwck1tR6UYjUYAOK9AiTRqwoAeSqb1NRiZlrJTOtxxWLZtZ2uYAJC3qoqrVBooHdBjLybXhvXMxsrKSnm93j6zGFtaWvrMdswIBoMKBoNZHUdJ0KcPVg3syQAA4FIMRq6pfJykcdndJwAA5zEYmeb1eDW5fHJW9wkAuDTD+g/EBAIB1dfXq6GhwbW+oaFBM2bMyNGoAAAAAAAAAPRnWM9slKSVK1dqwYIFmj59um644QZt2LBBR44c0eLFi3M9NAAAAAAAAAC9DPtm47x583Ty5Ek98sgjampq0tSpU/Xiiy9q0qRJuR4aAAAAAAAAgF6GfbNRkpYsWaIlS5bkehgAAAAAAAAAzmFYf2YjAAAAAAAAgJGDZiMAAAAAAACArKDZCAAAAAAAACAraDYCAAAAAAAAyAqajQAAAAAAAACygmYjAAAAAAAAgKyg2QgAAAAAAAAgK2g2AgAAAAAAAMgKmo0AAAAAAAAAsoJmIwAAAAAAAICs8OV6AIPNGCNJam9vz/FIAADnk3mvzrx3oy9yDQBGBjLt/Mg0ABg5LibX8r7Z2NHRIUmaMGFCjkcCALhQHR0dKi8vz/UwhiVyDQBGFjLt7Mg0ABh5LiTXLJPnv2qzbVvHjh1TaWmpLMu6oMe0t7drwoQJeu+991RWVjbIIxz+qIcb9ehBLdyoh9tA6mGMUUdHh2pra+Xx8Ekf/SHXLh316EEt3KiHG/XoQaYNjoFkmsS52Ru1cKMebtSjB7VwG+xcy/uZjR6PR+PHjx/QY8vKyjgJe6EebtSjB7Vwox5uF1sPZn+cG7mWPdSjB7Vwox5u1KMHmZZdl5JpEudmb9TCjXq4UY8e1MJtsHKNX7EBAAAAAAAAyAqajQAAAAAAAACygmZjP4LBoB566CEFg8FcD2VYoB5u1KMHtXCjHm7UY/jguXCjHj2ohRv1cKMePajF8MLz0YNauFEPN+rRg1q4DXY98v4PxAAAAAAAAAAYGsxsBAAAAAAAAJAVNBsBAAAAAAAAZAXNRgAAAAAAAABZQbMRAAAAAAAAQFbQbOzH448/rrq6OoVCIdXX12vbtm25HtKgW7t2rT760Y+qtLRUY8eO1a233qp9+/a5tjHG6OGHH1Ztba3C4bBmzZqlt99+O0cjHjpr166VZVlasWKFs67QanH06FHdfvvtGjNmjIqKivThD39YO3fudO4vpHokk0l95zvfUV1dncLhsCZPnqxHHnlEtm072+RzPf7617/qS1/6kmpra2VZlp577jnX/Rdy7LFYTMuWLVNlZaWKi4v15S9/Wf/973+H8CgKSyFmmkSunQu5Rq71Vsi5RqaNTIWYa2TauZFr5FpGIWeaNMxyzcBl06ZNxu/3m40bN5q9e/ea5cuXm+LiYnP48OFcD21Q3XzzzebJJ580b731lmlsbDRz5swxEydONJ2dnc4269atM6WlpebZZ581e/bsMfPmzTM1NTWmvb09hyMfXDt27DCXXXaZue6668zy5cud9YVUi1OnTplJkyaZO++80/z97383Bw8eNC+//LJ55513nG0KqR4/+MEPzJgxY8wLL7xgDh48aH7961+bkpIS89hjjznb5HM9XnzxRbN69Wrz7LPPGknmt7/9rev+Czn2xYsXm3HjxpmGhgaza9cuc9NNN5lp06aZZDI5xEeT/wo104wh186GXCPXzlTIuUamjTyFmmtk2tmRa+Rab4WcacYMr1yj2XiGj33sY2bx4sWudVOmTDGrVq3K0Yhyo6WlxUgyW7duNcYYY9u2qa6uNuvWrXO2iUajpry83DzxxBO5Guag6ujoMFdeeaVpaGgwN954oxNehVaLBx54wMycOfOs9xdaPebMmWPuvvtu17q5c+ea22+/3RhTWPU4M8Au5NhbW1uN3+83mzZtcrY5evSo8Xg85o9//OOQjb1QkGk9yDVyLYNccyPX0si0kYFcSyPT0si1NHKtB5nWI9e5xmXUvcTjce3cuVOzZ892rZ89e7a2b9+eo1HlRltbmySpoqJCknTw4EE1Nze7ahMMBnXjjTfmbW3uvfdezZkzR5/73Odc6wutFs8//7ymT5+u2267TWPHjtX111+vjRs3OvcXWj1mzpypP//5z9q/f78k6Z///Kdee+01feELX5BUePXo7UKOfefOnUokEq5tamtrNXXq1Lyvz1Aj09zINXItg1xzI9f6R6YNP+RaDzItjVxLI9d6kGlnN9S55svOsPPDiRMnlEqlVFVV5VpfVVWl5ubmHI1q6BljtHLlSs2cOVNTp06VJOf4+6vN4cOHh3yMg23Tpk3atWuX3njjjT73FVot3n33Xa1fv14rV67Ugw8+qB07duib3/ymgsGg7rjjjoKrxwMPPKC2tjZNmTJFXq9XqVRKa9as0fz58yUV3vnR24Uce3NzswKBgEaPHt1nm0J6nx0KZFoPco1c641ccyPX+kemDT/kWhqZlkau9SDXepBpZzfUuUazsR+WZbm+N8b0WZfPli5dqjfffFOvvfZan/sKoTbvvfeeli9frpdeekmhUOis2xVCLSTJtm1Nnz5dP/zhDyVJ119/vd5++22tX79ed9xxh7NdodTjmWee0dNPP61f/epXuuaaa9TY2KgVK1aotrZWCxcudLYrlHr0ZyDHXkj1GWqFfC5mkGvkWm/kmhu5dm5k2vBTqOdiRqFnmkSunYlc60Gmnd9Q5RqXUfdSWVkpr9fbp2Pb0tLSp/ubr5YtW6bnn39er7zyisaPH++sr66ulqSCqM3OnTvV0tKi+vp6+Xw++Xw+bd26VT/+8Y/l8/mc4y2EWkhSTU2NPvShD7nWXX311Tpy5Iikwjo3JOlb3/qWVq1apa9+9au69tprtWDBAt13331au3atpMKrR28XcuzV1dWKx+M6ffr0WbdBdpBpaeQauXYmcs2NXOsfmTb8kGtkWga55kau9SDTzm6oc41mYy+BQED19fVqaGhwrW9oaNCMGTNyNKqhYYzR0qVLtWXLFv3lL39RXV2d6/66ujpVV1e7ahOPx7V169a8q81nP/tZ7dmzR42Njc4yffp0fe1rX1NjY6MmT55cMLWQpE9+8pPat2+fa93+/fs1adIkSYV1bkhSd3e3PB73W6fX65Vt25IKrx69Xcix19fXy+/3u7ZpamrSW2+9lff1GWqFnGkSudYbueZGrrmRa/0j04afQs41Ms2NXHMj13qQaWc35Ll2UX9OpgBs2rTJ+P1+87Of/czs3bvXrFixwhQXF5tDhw7lemiD6p577jHl5eXm1VdfNU1NTc7S3d3tbLNu3TpTXl5utmzZYvbs2WPmz5+fN38i/nx6/3UzYwqrFjt27DA+n8+sWbPG/Oc//zG//OUvTVFRkXn66aedbQqpHgsXLjTjxo0zL7zwgjl48KDZsmWLqaysNN/+9redbfK5Hh0dHWb37t1m9+7dRpJ59NFHze7du83hw4eNMRd27IsXLzbjx483L7/8stm1a5f5zGc+Y6ZNm2aSyWSuDitvFWqmGUOunQ+5Rq5lFHKukWkjT6HmGpl2fuQauWZMYWeaMcMr12g29uMnP/mJmTRpkgkEAuYjH/mI2bp1a66HNOgk9bs8+eSTzja2bZuHHnrIVFdXm2AwaD796U+bPXv25G7QQ+jM8Cq0Wvz+9783U6dONcFg0EyZMsVs2LDBdX8h1aO9vd0sX77cTJw40YRCITN58mSzevVqE4vFnG3yuR6vvPJKv+8VCxcuNMZc2LFHIhGzdOlSU1FRYcLhsPniF79ojhw5koOjKQyFmGnGkGvnQ66RaxmFnGtk2shUiLlGpp0fuUauGVPYmWbM8Mo1yxhjLm4uJAAAAAAAAAD0xWc2AgAAAAAAAMgKmo0AAAAAAAAAsoJmIwAAAAAAAICsoNkIAAAAAAAAICtoNgIAAAAAAADICpqNAAAAAAAAALKCZiMAAAAAAACArKDZCAAAAAAAACAraDYCeezQoUOyLEuNjY25HgoAAJeMXAMA5BNyDfmKZiOQJ+68807deuutuR4GAABZQa4BAPIJuYZCQrMRAAAAAAAAQFbQbARyYNasWVq2bJlWrFih0aNHq6qqShs2bFBXV5fuuusulZaW6vLLL9cf/vAHSVIqldKiRYtUV1encDisq666Sj/60Y+c/T388MN66qmn9Lvf/U6WZcmyLL366qvO/e+++65uuukmFRUVadq0aXr99deH+pABAHmMXAMA5BNyDbg0NBuBHHnqqadUWVmpHTt2aNmyZbrnnnt02223acaMGdq1a5duvvlmLViwQN3d3bJtW+PHj9fmzZu1d+9efe9739ODDz6ozZs3S5Luv/9+feUrX9HnP/95NTU1qampSTNmzHB+1urVq3X//fersbFRH/zgBzV//nwlk8lcHToAIA+RawCAfEKuAQNnGWNMrgcBFJpZs2YplUpp27ZtktK/CSsvL9fcuXP185//XJLU3Nysmpoavf766/rEJz7RZx/33nuvjh8/rt/85jeS0p8B0traqueee87Z5tChQ6qrq9NPf/pTLVq0SJK0d+9eXXPNNfrXv/6lKVOmDPKRAgAKAbkGAMgn5BpwaZjZCOTIdddd53zt9Xo1ZswYXXvttc66qqoqSVJLS4sk6YknntD06dP1gQ98QCUlJdq4caOOHDly0T+rpqbGtV8AALKBXAMA5BNyDRg4mo1Ajvj9ftf3lmW51lmWJUmybVubN2/Wfffdp7vvvlsvvfSSGhsbdddddykej1/0z+q9XwAAsoVcAwDkE3INGDhfrgcA4Py2bdumGTNmaMmSJc66AwcOuLYJBAJKpVJDPTQAAC4auQYAyCfkGuDGzEZgBLjiiiv0j3/8Q3/605+0f/9+ffe739Ubb7zh2uayyy7Tm2++qX379unEiRNKJBI5Gi0AAOdGrgEA8gm5BrjRbARGgMWLF2vu3LmaN2+ePv7xj+vkyZOu35pJ0je+8Q1dddVVzueE/O1vf8vRaAEAODdyDQCQT8g1wI2/Rg0AAAAAAAAgK5jZCAAAAAAAACAraDYCAAAAAAAAyAqajQAAAAAAAACygmYjAAAAAAAAgKyg2QgAAAAAAAAgK2g2AgAAAAAAAMgKmo0AAAAAAAAAsoJmIwAAAAAAAICsoNkIAAAAAAAAICtoNgIAAAAAAADICpqNAAAAAAAAALLi/1Uu0ietVfGDAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -487,11 +549,12 @@ } ], "source": [ - "fig, axes = plot_cap(\n", + "plot_cap(\n", " model_interaction, \n", " idata_interaction, \n", - " covariates={\"horizontal\": \"math\", \"color\": \"prog\", \"panel\": \"prog\"},\n", + " covariates=[\"math\", \"prog\"],\n", " pps=True,\n", + " subplot_kwargs={\"main\": \"math\", \"group\": \"prog\", \"panel\": \"prog\"},\n", " legend=False,\n", " fig_kwargs={\"figsize\": (16, 5), \"sharey\": True}\n", ");" @@ -665,7 +728,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 51, "metadata": {}, "outputs": [ { @@ -674,11 +737,54 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 4 jobs)\n", "NUTS: [Intercept, x, alpha_Intercept, alpha_x]\n" ] }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [8000/8000 00:02<00:00 Sampling 4 chains, 25 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", @@ -704,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -730,7 +836,7 @@ "* To see a summary or plot of the posterior pass the object returned by .fit() to az.summary() or az.plot_trace()" ] }, - "execution_count": 57, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -749,12 +855,12 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 53, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -779,12 +885,12 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -801,24 +907,26 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Last updated: Wed May 10 2023\n", + "The watermark extension is already loaded. To reload it, use:\n", + " %reload_ext watermark\n", + "Last updated: Sat Jun 24 2023\n", "\n", "Python implementation: CPython\n", "Python version : 3.11.0\n", - "IPython version : 8.11.0\n", + "IPython version : 8.13.2\n", "\n", - "arviz : 0.15.1\n", "numpy : 1.24.2\n", "bambi : 0.10.0.dev0\n", "pandas : 2.0.1\n", "matplotlib: 3.7.1\n", + "arviz : 0.15.1\n", "\n", "Watermark: 2.3.1\n", "\n" diff --git a/tests/test_plots.py b/tests/test_plots.py index 5758879da..4e68d5745 100644 --- a/tests/test_plots.py +++ b/tests/test_plots.py @@ -6,16 +6,18 @@ import pytest import bambi as bmb -from bambi.plots import plot_cap +from bambi.plots import plot_cap, plot_comparison @pytest.fixture(scope="module") def mtcars(): - data = pd.read_csv(join(dirname(__file__), "data", "mtcars.csv")) + data = bmb.load_data('mtcars') data["cyl"] = data["cyl"].replace({4: "low", 6: "medium", 8: "high"}) - data["cyl"] = pd.Categorical(data["cyl"], categories=["low", "medium", "high"], ordered=True) data["gear"] = data["gear"].replace({3: "A", 4: "B", 5: "C"}) - model = bmb.Model("mpg ~ 0 + hp * wt + cyl + gear", data) + data["gear"] = pd.Categorical(data["gear"], ordered=False) + data["cyl"] = pd.Categorical(data["cyl"], categories=["low", "medium", "high"], ordered=True) + data["am"] = pd.Categorical(data["am"], categories=[0, 1], ordered=True) + model = bmb.Model("mpg ~ hp * drat * am", data) idata = model.fit(tune=500, draws=500, random_seed=1234) return model, idata @@ -25,175 +27,256 @@ def mtcars(): # * Test using the dictionary and the list gives the same plot -@pytest.mark.parametrize("pps", [False, True]) -def test_basic(mtcars, pps): - model, idata = mtcars - - # Using dictionary - # Horizontal variable is numeric - plot_cap(model, idata, {"horizontal": "hp"}, pps=pps) - - # Horizontal variable is categorical - plot_cap(model, idata, {"horizontal": "gear"}, pps=pps) - - # Using list - plot_cap(model, idata, ["hp"], pps=pps) - plot_cap(model, idata, ["gear"], pps=pps) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_with_groups(mtcars, pps): - model, idata = mtcars - - # Dictionary - # Horizontal: numeric. Group: numeric - plot_cap(model, idata, {"horizontal": "hp", "color": "wt"}, pps=pps) - - # Horizontal: numeric. Group: categorical - plot_cap(model, idata, {"horizontal": "hp", "color": "cyl"}, pps=pps) - - # Horizontal: categorical. Group: numeric - plot_cap(model, idata, {"horizontal": "gear", "color": "wt"}, pps=pps) - - # Horizontal: categorical. Group: categorical - plot_cap(model, idata, {"horizontal": "gear", "color": "cyl"}, pps=pps) - - # List - plot_cap(model, idata, ["hp", "wt"], pps=pps) - plot_cap(model, idata, ["hp", "cyl"], pps=pps) - plot_cap(model, idata, ["gear", "wt"], pps=pps) - plot_cap(model, idata, ["gear", "cyl"], pps=pps) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_with_panel(mtcars, pps): - model, idata = mtcars - - # Dictionary is the only possibility - # Horizontal: numeric. Group: numeric - plot_cap(model, idata, {"horizontal": "hp", "panel": "wt"}, pps=pps) - - # Horizontal: numeric. Group: categorical - plot_cap(model, idata, {"horizontal": "hp", "panel": "cyl"}, pps=pps) - - # Horizontal: categorical. Group: numeric - plot_cap(model, idata, {"horizontal": "gear", "panel": "wt"}, pps=pps) - - # Horizontal: categorical. Group: categorical - plot_cap(model, idata, {"horizontal": "gear", "panel": "cyl"}, pps=pps) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_with_group_and_panel(mtcars, pps): - model, idata = mtcars - - # Dictionary - plot_cap(model, idata, {"horizontal": "hp", "color": "cyl", "panel": "gear"}, pps=pps) - plot_cap(model, idata, {"horizontal": "cyl", "color": "hp", "panel": "gear"}, pps=pps) - plot_cap(model, idata, {"horizontal": "cyl", "color": "gear", "panel": "hp"}, pps=pps) - - # List - plot_cap(model, idata, ["hp", "cyl", "gear"], pps=pps) - plot_cap(model, idata, ["cyl", "hp", "gear"], pps=pps) - plot_cap(model, idata, ["cyl", "gear", "hp"], pps=pps) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_ax(mtcars, pps): - model, idata = mtcars - fig, ax = plt.subplots() - fig_r, ax_r = plot_cap(model, idata, ["hp"], pps=pps, ax=ax) - - assert isinstance(ax_r, np.ndarray) - assert fig is fig_r - assert ax is ax_r[0] - +class TestCommon: + """ + Tests argments that are common to both plot_cap and plot_comparison such + as figure object and uncertainty arguments. + """ + @pytest.mark.parametrize("pps", [False, True]) + def test_use_hdi(self, mtcars, pps): + model, idata = mtcars + plot_comparison(model, idata, "hp", "am", use_hdi=False) + plot_cap( + model, + idata, + ["hp", "cyl", "gear"], + pps=pps, + use_hdi=False + ) + + @pytest.mark.parametrize("pps", [False, True]) + def test_hdi_prob(self, mtcars, pps): + model, idata = mtcars + plot_comparison(model, idata, "am", "hp", prob=0.8) + plot_cap( + model, + idata, + ["hp", "cyl", "gear"], + pps=pps, + prob=0.9 + ) -@pytest.mark.parametrize("pps", [False, True]) -def test_fig_kwargs(mtcars, pps): - model, idata = mtcars - plot_cap( - model, - idata, - {"horizontal": "hp", "color": "cyl", "panel": "gear"}, - pps=pps, - fig_kwargs={"figsize": (15, 5), "dpi": 120, "sharey": True}, + with pytest.raises( + ValueError, match="'prob' must be greater than 0 and smaller than 1. It is 1.1." + ): + plot_comparison(model, idata, "am", "hp", prob=1.1) + plot_cap( + model, + idata, + ["hp", "cyl", "gear"], + pps=pps, + prob=1.1) + + with pytest.raises( + ValueError, match="'prob' must be greater than 0 and smaller than 1. It is -0.1." + ): + plot_comparison(model, idata, "am", "hp", prob=-0.1) + plot_cap( + model, + idata, + ["hp", "cyl", "gear"], + pps=pps, + prob=-0.1) + + + @pytest.mark.parametrize("pps", [False, True]) + def test_legend(self, mtcars, pps): + model, idata = mtcars + plot_comparison(model, idata, "am", "hp", legend=False) + plot_cap(model, idata, ["hp"], pps=pps,legend=False) + + + @pytest.mark.parametrize("pps", [False, True]) + def test_ax(self, mtcars, pps): + model, idata = mtcars + fig, ax = plt.subplots() + fig_r, ax_r = plot_comparison(model, idata, "am", "hp", ax=ax) + + assert isinstance(ax_r, np.ndarray) + assert fig is fig_r + assert ax is ax_r[0] + + fig, ax = plt.subplots() + fig_r, ax_r = plot_cap(model, idata, ["hp"], pps=pps, ax=ax) + + assert isinstance(ax_r, np.ndarray) + assert fig is fig_r + assert ax is ax_r[0] + + +class TestCap: + """ + Tests the plot_cap function for different combinations of main, group, + and panel variables. + """ + @pytest.mark.parametrize("pps", [False, True]) + @pytest.mark.parametrize( + "covariates", ( + "hp", # Main variable is numeric + "gear", # Main variable is categorical + ["hp"], # Using list + ["gear"] # Using list + ) ) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_use_hdi(mtcars, pps): - model, idata = mtcars - plot_cap( - model, idata, {"horizontal": "hp", "color": "cyl", "panel": "gear"}, pps=pps, use_hdi=False + def test_basic(self, mtcars, covariates, pps): + model, idata = mtcars + plot_cap(model, idata, covariates, pps=pps) + + + @pytest.mark.parametrize("pps", [False, True]) + @pytest.mark.parametrize( + "covariates", ( + ["hp", "wt"], # Main: numeric. Group: numeric + ["hp", "cyl"], # Main: numeric. Group: categorical + ["gear", "wt"], # Main: categorical. Group: numeric + ["gear", "cyl"] # Main: categorical. Group: categorical + ) ) + def test_with_groups(self, mtcars, covariates, pps): + model, idata = mtcars + plot_cap(model, idata, covariates, pps=pps) -@pytest.mark.parametrize("pps", [False, True]) -def test_hdi_prob(mtcars, pps): - model, idata = mtcars - plot_cap( - model, idata, {"horizontal": "hp", "color": "cyl", "panel": "gear"}, pps=pps, hdi_prob=0.9 + @pytest.mark.parametrize("pps", [False, True]) + @pytest.mark.parametrize( + "covariates", ( + ["hp", "cyl", "gear"], + ["cyl", "hp", "gear"], + ["cyl", "gear", "hp"] + ) ) + def test_with_group_and_panel(self, mtcars, covariates, pps): + model, idata = mtcars + plot_cap(model, idata, covariates, pps=pps) - with pytest.raises( - ValueError, match="'hdi_prob' must be greater than 0 and smaller than 1. It is 1.1." - ): + + @pytest.mark.parametrize("pps", [False, True]) + def test_fig_kwargs(self, mtcars, pps): + model, idata = mtcars plot_cap( model, idata, - {"horizontal": "hp", "color": "cyl", "panel": "gear"}, + [ "hp", "cyl", "gear"], pps=pps, - hdi_prob=1.1, + fig_kwargs={"figsize": (15, 5), "dpi": 120, "sharey": True}, ) + - with pytest.raises( - ValueError, match="'hdi_prob' must be greater than 0 and smaller than 1. It is -0.1." - ): + @pytest.mark.parametrize("pps", [False, True]) + def test_subplot_kwargs(self, mtcars, pps): + model, idata = mtcars plot_cap( model, idata, - {"horizontal": "hp", "color": "cyl", "panel": "gear"}, + ["hp", "drat"], pps=pps, - hdi_prob=-0.1, + subplot_kwargs={"main": "hp", "group": "drat", "panel": "drat"}, ) -@pytest.mark.parametrize("pps", [False, True]) -def test_legend(mtcars, pps): - model, idata = mtcars - plot_cap(model, idata, ["hp"], pps=pps, legend=False) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_transforms(mtcars, pps): - model, idata = mtcars - - transforms = {"mpg": np.log} - plot_cap(model, idata, ["hp"], pps=pps, transforms=transforms) - - transforms = {"hp": np.log} - plot_cap(model, idata, ["hp"], pps=pps, transforms=transforms) - - transforms = {"mpg": np.log, "hp": np.log} - plot_cap(model, idata, ["hp"], pps=pps, transforms=transforms) - - -@pytest.mark.parametrize("pps", [False, True]) -def test_multiple_outputs(pps): - """Test plot cap default and specified values for target argument""" - rng = np.random.default_rng(121195) - N = 200 - a, b = 0.5, 1.1 - x = rng.uniform(-1.5, 1.5, N) - shape = np.exp(0.3 + x * 0.5 + rng.normal(scale=0.1, size=N)) - y = rng.gamma(shape, np.exp(a + b * x) / shape, N) - data_gamma = pd.DataFrame({"x": x, "y": y}) - - formula = bmb.Formula("y ~ x", "alpha ~ x") - model = bmb.Model(formula, data_gamma, family="gamma") - idata = model.fit(tune=100, draws=100, random_seed=1234) - # Test default target - plot_cap(model, idata, "x", pps=pps) - # Test user supplied target argument - plot_cap(model, idata, "x", "alpha", pps=pps) + @pytest.mark.parametrize("pps", [False, True]) + @pytest.mark.parametrize( + "transforms", ( + {"mpg": np.log}, + {"hp": np.log}, + {"mpg": np.log, "hp": np.log}, + ) + ) + def test_transforms(self, mtcars, transforms, pps): + model, idata = mtcars + plot_cap(model, idata, ["hp"], pps=pps, transforms=transforms) + + + @pytest.mark.parametrize("pps", [False, True]) + def test_multiple_outputs_with_alias(self, pps): + """Test plot cap default and specified values for target argument""" + rng = np.random.default_rng(121195) + N = 200 + a, b = 0.5, 1.1 + x = rng.uniform(-1.5, 1.5, N) + shape = np.exp(0.3 + x * 0.5 + rng.normal(scale=0.1, size=N)) + y = rng.gamma(shape, np.exp(a + b * x) / shape, N) + data_gamma = pd.DataFrame({"x": x, "y": y}) + + formula = bmb.Formula("y ~ x", "alpha ~ x") + model = bmb.Model(formula, data_gamma, family="gamma") + # Without alias + idata = model.fit(tune=100, draws=100, random_seed=1234) + # Test default target + plot_cap(model, idata, "x", pps=pps) + # Test user supplied target argument + plot_cap(model, idata, "x", "alpha", pps=False) + + # With alias + alias = {"alpha": {"Intercept": "sd_intercept", "x": "sd_x", "alpha": "sd_alpha"}} + model.set_alias(alias) + idata = model.fit(tune=100, draws=100, random_seed=1234) + + # Test user supplied target argument + plot_cap(model, idata, "x", "alpha", pps=False) + + +class TestComparison: + """ + Tests the plot_comparison function for different combinations of + contrast and conditional variables, and user inputs. + """ + @pytest.mark.parametrize( + "contrast, conditional", [ + ("hp", "am"), # numeric & categorical + ("am", "hp"), # categorical & numeric + ] + ) + def test_basic(self, mtcars, contrast, conditional): + model, idata = mtcars + plot_comparison(model, idata, contrast, conditional) + + + @pytest.mark.parametrize( + "contrast, conditional", [ + ("hp", ["am", "drat"]), # numeric & [categorical, numeric] + ("hp", ["drat", "am"]), # numeric & [numeric, categorical] + ] + ) + def test_with_groups(self, mtcars, contrast, conditional): + model, idata = mtcars + plot_comparison(model, idata, contrast, conditional) + + + @pytest.mark.parametrize( + "contrast, conditional", [ + ({"hp": [110, 175]}, ["am", "drat"]), # user provided values + ({"hp": [110, 175]}, {"am": [0, 1], "drat": [3, 4, 5]}) # user provided values + ] + ) + def test_with_user_values(self, mtcars, contrast, conditional): + model, idata = mtcars + plot_comparison(model, idata, contrast, conditional) + + + @pytest.mark.parametrize( + "contrast, conditional, subplot_kwargs", [ + ("drat", ["hp", "am"], {"main": "hp", "group": "am", "panel": "am"}) + ] + ) + def test_subplot_kwargs(self, mtcars, contrast, conditional, subplot_kwargs): + model, idata = mtcars + plot_comparison(model, idata, contrast, conditional, subplot_kwargs=subplot_kwargs) + + + @pytest.mark.parametrize( + "contrast, conditional, transforms", [ + ("drat", ["hp", "am"], {"hp": np.log}), # transform main numeric + ("drat", ["hp", "am"], {"mpg": np.log}), # transform response + ] + ) + def test_transforms(self, mtcars, contrast, conditional, transforms): + model, idata = mtcars + plot_comparison(model, idata, contrast, conditional, transforms=transforms) + + + @pytest.mark.parametrize("average_by", ["am", "drat", ["am", "drat"]]) + def test_average_by(self, mtcars, average_by): + model, idata = mtcars + plot_comparison(model, idata, "hp", ["am", "drat"], average_by=average_by) + \ No newline at end of file