diff --git a/climada/test/test_trajectories.py b/climada/test/test_trajectories.py
new file mode 100644
index 000000000..266929aa4
--- /dev/null
+++ b/climada/test/test_trajectories.py
@@ -0,0 +1,643 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see `_
+
+ Notes
+ -----
+
+ Changing its value resets the corresponding metric.
+ """
+ return self._risk_metrics_calculators[0].time_resolution
+
+ @time_resolution.setter
+ def time_resolution(self, value, /):
+ if not isinstance(value, str):
+ raise ValueError(
+ 'time_resolution should be a valid pandas Period frequency string (e.g., `"Y"`, `"M"`, `"D"`).'
+ )
+ self._reset_metrics()
+ for rmcalc in self._risk_metrics_calculators:
+ rmcalc.time_resolution = value
+
+ @staticmethod
+ def _reset_risk_metrics_calculators(
+ snapshots: list[Snapshot],
+ time_resolution,
+ interpolation_strategy,
+ impact_computation_strategy,
+ ) -> list[CalcRiskMetricsPeriod]:
+ """Initialize or reset the internal risk metrics calculators.
+
+ Notes
+ -----
+
+ This methods sorts the snapshots per date.
+ """
+
+ def pairwise(container: list):
+ """
+ Generate pairs of successive elements from an iterable.
+
+ Parameters
+ ----------
+ iterable : iterable
+ An iterable sequence from which successive pairs of elements are generated.
+
+ Returns
+ -------
+ zip
+ A zip object containing tuples of successive pairs from the input iterable.
+
+ Example
+ -------
+ >>> list(pairwise([1, 2, 3, 4]))
+ [(1, 2), (2, 3), (3, 4)]
+ """
+ a, b = itertools.tee(container)
+ next(b, None)
+ return zip(a, b)
+
+ return [
+ CalcRiskMetricsPeriod(
+ start_snapshot,
+ end_snapshot,
+ time_resolution=time_resolution,
+ interpolation_strategy=interpolation_strategy,
+ impact_computation_strategy=impact_computation_strategy,
+ )
+ for start_snapshot, end_snapshot in pairwise(
+ sorted(snapshots, key=lambda snap: snap.date)
+ )
+ ]
+
+ def _generic_metrics(
+ self,
+ metric_name: str | None = None,
+ metric_meth: str | None = None,
+ **kwargs,
+ ) -> pd.DataFrame:
+ """Generic method to compute metrics based on the provided metric name and method.
+
+ This method calls the appropriate method from the calculator to return
+ the results for the given metric, in a tidy formatted dataframe.
+
+ It first checks whether the requested metric is a valid one.
+ Then looks for a possible cached value and otherwised asks the
+ calculators (`self._risk_metric_calculators`) to run the computations.
+ The results are then regrouped in a nice and tidy DataFrame.
+ If a `risk_disc_rates` was set, values are converted to net present values.
+ Results are then cached within `self.__metrics` and returned.
+
+ Parameters
+ ----------
+ metric_name : str, optional
+ The name of the metric to return results for.
+ metric_meth : str, optional
+ The name of the specific method of the calculator to call.
+
+ Returns
+ -------
+ pd.DataFrame
+ A tidy formatted dataframe of the risk metric computed for the
+ different snapshots.
+
+ Raises
+ ------
+ NotImplementedError
+ If the requested metric is not part of `POSSIBLE_METRICS`.
+ ValueError
+ If either of the arguments are not provided.
+
+ """
+
+ if metric_name is None or metric_meth is None:
+ raise ValueError("Both metric_name and metric_meth must be provided.")
+
+ if metric_name not in self.POSSIBLE_METRICS:
+ raise NotImplementedError(
+ f"{metric_name} not implemented ({self.POSSIBLE_METRICS})."
+ )
+
+ # Construct the attribute name for storing the metric results
+ attr_name = f"_{metric_name}_metrics"
+
+ if getattr(self, attr_name) is not None:
+ LOGGER.debug(f"Returning cached {attr_name}")
+ return getattr(self, attr_name)
+
+ LOGGER.debug(f"Computing {attr_name}")
+ with log_level(level="WARNING", name_prefix="climada"):
+ tmp = [
+ getattr(calc_period, metric_meth)(**kwargs)
+ for calc_period in self._risk_metrics_calculators
+ ]
+
+ # Notably for per_group_aai being None:
+ try:
+ tmp = pd.concat(tmp)
+ if len(tmp) == 0:
+ return pd.DataFrame()
+ except ValueError as e:
+ if str(e) == "All objects passed were None":
+ return pd.DataFrame()
+ else:
+ raise e
+
+ else:
+ tmp = tmp.set_index(INDEXING_COLUMNS)
+ if COORD_ID_COL_NAME in tmp.columns:
+ tmp = tmp.set_index([COORD_ID_COL_NAME], append=True)
+
+ # When more than 2 snapshots, there are duplicated rows, we need to remove them.
+ tmp = tmp[~tmp.index.duplicated(keep="first")]
+ tmp = tmp.reset_index()
+ if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories:
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories(
+ [self._all_groups_name]
+ )
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name)
+
+ if metric_name == CONTRIBUTIONS_METRIC_NAME and len(self._snapshots) > 2:
+ # If there is more than one Snapshot, we need to update the
+ # contributions from previous periods for continuity
+ # and to set the base risk from the first period
+ # This is not elegant, but we need the concatenated metrics from each period,
+ # so we can't do it in the calculators, and we need
+ # to do it before caching in the private attribute
+ tmp = self._risk_contributions_post_treatment(tmp)
+
+ if self._risk_disc_rates:
+ LOGGER.debug("Found risk discount rate. Computing NPV.")
+ tmp = self.npv_transform(tmp, self._risk_disc_rates)
+
+ tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY)
+ LOGGER.debug("All computing done, caching value.")
+ setattr(self, attr_name, tmp)
+ return getattr(self, attr_name)
+
+ def _compute_period_metrics(
+ self, metric_name: str, metric_meth: str, **kwargs
+ ) -> pd.DataFrame:
+ """Helper method to compute total metrics per period (i.e. whole ranges between pairs of consecutive snapshots)."""
+ df = self._generic_metrics(
+ metric_name=metric_name, metric_meth=metric_meth, **kwargs
+ )
+ return self._date_to_period_agg(df, grouper=self._grouper)
+
+ def eai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated annual impacts at each exposure point for each date.
+
+ This method computes and return a `DataFrame` with eai metric
+ (for each exposure point) for each date.
+
+ Notes
+ -----
+
+ This computation may become quite expensive for big areas with high resolution.
+
+ """
+ df = self._compute_metrics(
+ metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs
+ )
+ return df
+
+ def aai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each date.
+
+ This method computes and return a `DataFrame` with aai metric for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs
+ )
+
+ def return_periods_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated impacts for different return periods.
+
+ Return periods to estimate impacts for are defined by `self.return_periods`.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=RETURN_PERIOD_METRIC_NAME,
+ metric_meth="calc_return_periods_metric",
+ return_periods=self.return_periods,
+ **kwargs,
+ )
+
+ def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each exposure group ID.
+
+ This method computes and return a `DataFrame` with aai metric for each
+ of the exposure group defined by a group id, for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_PER_GROUP_METRIC_NAME,
+ metric_meth="calc_aai_per_group_metric",
+ **kwargs,
+ )
+
+ def risk_contributions_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the "contributions" of change in future risk (Exposure and Hazard)
+
+ This method returns the contributions of the change in risk at each date:
+
+ - The 'base risk', i.e., the risk without change in hazard or exposure, compared to trajectory's earliest date.
+ - The 'exposure contribution', i.e., the additional risks due to change in exposure (only)
+ - The 'hazard contribution', i.e., the additional risks due to change in hazard (only)
+ - The 'vulnerability contribution', i.e., the additional risks due to change in vulnerability (only)
+ - The 'interaction contribution', i.e., the additional risks due to the interaction term
+
+
+ """
+
+ return self._compute_metrics(
+ metric_name=CONTRIBUTIONS_METRIC_NAME,
+ metric_meth="calc_risk_contributions_metric",
+ **kwargs,
+ )
+
+ def _risk_contributions_post_treatment(self, df) -> pd.DataFrame:
+ """Post treat the risk contributions metrics.
+
+ When more than two snapshots are provided, the total risk of the previous pair
+ (period) becomes the base risk for the subsequent one.
+ This method straightens this by resetting the base risk to the risk from
+ the first snapshot of the list and correcting the different contributions
+ by cumulating the contributions from the previous periods.
+
+ """
+
+ df.set_index(INDEXING_COLUMNS, inplace=True)
+ start_dates = [snap.date for snap in self._snapshots[:-1]]
+ end_dates = [snap.date for snap in self._snapshots[1:]]
+ periods_dates = list(zip(start_dates, end_dates))
+ df.loc[pd.IndexSlice[:, :, :, CONTRIBUTION_BASE_RISK_NAME]] = df.loc[
+ pd.IndexSlice[
+ pd.to_datetime(self.start_date).to_period(self.time_resolution),
+ :,
+ :,
+ CONTRIBUTION_BASE_RISK_NAME,
+ ] # type: ignore
+ ].values
+ for p2 in periods_dates[1:]:
+ for metric in [
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ]:
+ mask_last_previous = (
+ df.index.get_level_values(0)
+ == pd.to_datetime(p2[0]).to_period(self.time_resolution)
+ ) & (df.index.get_level_values(3) == metric)
+ mask_to_update = (
+ (
+ df.index.get_level_values(0)
+ > pd.to_datetime(p2[0]).to_period(self.time_resolution)
+ )
+ & (
+ df.index.get_level_values(0)
+ <= pd.to_datetime(p2[1]).to_period(self.time_resolution)
+ )
+ & (df.index.get_level_values(3) == metric)
+ )
+
+ df.loc[mask_to_update, RISK_COL_NAME] += df.loc[
+ mask_last_previous, RISK_COL_NAME
+ ].iloc[0]
+
+ return df.reset_index()
+
+ def per_date_risk_metrics(
+ self,
+ metrics: list[str] | None = None,
+ ) -> pd.DataFrame:
+ """Returns a DataFrame of risk metrics for each dates
+
+ This methods collects (and if needed computes) the `metrics`
+ (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME).
+
+ Parameters
+ ----------
+ metrics : list[str], optional
+ The list of metrics to return (defaults to
+ [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME])
+ return_periods : list[int], optional
+ The return periods to consider for the return periods metric
+ (default to the value of the `.default_rp` attribute)
+
+ Returns
+ -------
+ pd.DataFrame | pd.Series
+ A tidy DataFrame with metrics value for all possible dates.
+
+ """
+
+ metrics = self._DEFAULT_ALL_METRICS if metrics is None else metrics
+ return pd.concat(
+ [getattr(self, f"{metric}_metrics")() for metric in metrics],
+ ignore_index=True,
+ )
+
+ @staticmethod
+ def _get_risk_periods(
+ risk_periods: list[CalcRiskMetricsPeriod],
+ start_date: datetime.date,
+ end_date: datetime.date,
+ strict: bool = True,
+ ):
+ """Returns risk periods from the given list that are within `start_date` and `end_date`.
+
+ Either using a strict inclusion (period is stricly within start and end) or extending
+ to overlap inclusion, i.e., start or end is within the period.
+
+ Parameters
+ ----------
+ risk_periods : list[CalcRiskPeriod]
+ The list of risk periods to look through
+ start_date : datetime.date
+ end_date : datetime.date
+ strict: bool, default True
+ If true, only returns periods stricly within start and end dates. Else,
+ additionaly returns periods that have an overlap within start and end.
+ """
+ if strict:
+ return [
+ period
+ for period in risk_periods
+ if (
+ start_date <= period.snapshot_start.date
+ and end_date >= period.snapshot_end.date
+ )
+ ]
+ else:
+ return [
+ period
+ for period in risk_periods
+ if not (
+ start_date >= period.snapshot_end.date
+ or end_date <= period.snapshot_start.date
+ )
+ ]
+
+ @staticmethod
+ def _identify_continuous_periods(group, time_unit):
+ """Calculate the difference between consecutive dates."""
+
+ if time_unit == "year":
+ group["date_diff"] = group[DATE_COL_NAME].dt.year.diff()
+ if time_unit == "month":
+ group["date_diff"] = group[DATE_COL_NAME].dt.month.diff()
+ if time_unit == "day":
+ group["date_diff"] = group[DATE_COL_NAME].dt.day.diff()
+ if time_unit == "hour":
+ group["date_diff"] = group[DATE_COL_NAME].dt.hour.diff()
+ # Identify breaks in continuity
+ group["period_id"] = (group["date_diff"] != 1).cumsum()
+ return group
+
+ @classmethod
+ def _date_to_period_agg(
+ cls,
+ df: pd.DataFrame,
+ grouper: list[str],
+ time_unit: str = "year",
+ colname: str | list[str] = RISK_COL_NAME,
+ ) -> pd.DataFrame:
+ """Group per date risk metric to periods."""
+
+ def conditional_agg(group):
+ try:
+ if "rp" in group.name[2]:
+ return group.mean()
+ else:
+ return group.sum()
+ except IndexError:
+ return group.sum()
+
+ df_sorted = df.sort_values(by=grouper + [DATE_COL_NAME])
+
+ if GROUP_COL_NAME in df.columns and GROUP_COL_NAME not in grouper:
+ grouper = [GROUP_COL_NAME] + grouper
+
+ # Apply the function to identify continuous periods
+ df_periods = df_sorted.groupby(
+ grouper, dropna=False, group_keys=False, observed=True
+ )[df_sorted.columns].apply(cls._identify_continuous_periods, time_unit)
+
+ if isinstance(colname, str):
+ colname = [colname]
+ agg_dict = {
+ "start_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="min"),
+ "end_date": pd.NamedAgg(column=DATE_COL_NAME, aggfunc="max"),
+ }
+ df_periods_dates = (
+ df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)
+ .agg(func=None, **agg_dict) # type: ignore
+ .reset_index()
+ )
+
+ df_periods_dates[PERIOD_COL_NAME] = (
+ df_periods_dates["start_date"].astype(str)
+ + " to "
+ + df_periods_dates["end_date"].astype(str)
+ )
+ df_periods = (
+ df_periods.groupby(grouper + ["period_id"], dropna=False, observed=True)[
+ colname
+ ]
+ .apply("mean")
+ .reset_index()
+ )
+ df_periods = pd.merge(
+ df_periods_dates[grouper + [PERIOD_COL_NAME, "period_id"]],
+ df_periods,
+ on=grouper + ["period_id"],
+ )
+ df_periods = df_periods.drop(["period_id"], axis=1)
+ return df_periods[
+ [PERIOD_COL_NAME]
+ + [col for col in df_periods.columns if col != PERIOD_COL_NAME]
+ ]
+
+ def per_period_risk_metrics(
+ self,
+ metrics: list[str] = [
+ AAI_METRIC_NAME,
+ RETURN_PERIOD_METRIC_NAME,
+ AAI_PER_GROUP_METRIC_NAME,
+ ],
+ **kwargs,
+ ) -> pd.DataFrame:
+ """Return a tidy dataframe of the risk metrics with the total for each different period (pair of snapshots)."""
+
+ df = self.per_date_risk_metrics(metrics=metrics, **kwargs)
+ return self._date_to_period_agg(
+ df, grouper=self._grouper + [UNIT_COL_NAME], **kwargs
+ )
+
+ def _calc_waterfall_plot_data(
+ self,
+ start_date: datetime.date | None = None,
+ end_date: datetime.date | None = None,
+ ):
+ """Compute the required data for the waterfall plot between `start_date` and `end_date`."""
+ start_date = self.start_date if start_date is None else start_date
+ end_date = self.end_date if end_date is None else end_date
+ risk_contributions = self.risk_contributions_metrics()
+ risk_contributions = risk_contributions.loc[
+ (risk_contributions[DATE_COL_NAME] >= str(start_date))
+ & (risk_contributions[DATE_COL_NAME] <= str(end_date))
+ ]
+ risk_contributions = risk_contributions.set_index(
+ [DATE_COL_NAME, METRIC_COL_NAME]
+ )[RISK_COL_NAME].unstack()
+ return risk_contributions
+
+ def plot_time_waterfall(
+ self,
+ ax=None,
+ figsize=(12, 6),
+ ):
+ """Plot a waterfall chart of risk contributions over a specified date range.
+
+ This method generates a stacked bar chart to visualize the
+ risk contributions.
+
+ Parameters
+ ----------
+ ax : matplotlib.axes.Axes, optional
+ The matplotlib axes on which to plot. If None, a new figure and axes are created.
+
+ Returns
+ -------
+ matplotlib.axes.Axes
+ The matplotlib axes with the plotted waterfall chart.
+
+ """
+ if ax is None:
+ fig, ax = plt.subplots(figsize=figsize)
+ else:
+ fig = ax.figure # get parent figure from the axis
+
+ risk_contribution = self._calc_waterfall_plot_data(
+ start_date=self.start_date, end_date=self.end_date
+ )
+ risk_contribution = risk_contribution[
+ [
+ CONTRIBUTION_BASE_RISK_NAME,
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ]
+ ]
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME] = risk_contribution.iloc[0][
+ CONTRIBUTION_BASE_RISK_NAME
+ ]
+ # risk_contribution.plot(x=DATE_COL_NAME, ax=ax, kind="bar", stacked=True)
+ ax.stackplot(
+ risk_contribution.index.to_timestamp(), # type: ignore
+ [risk_contribution[col] for col in risk_contribution.columns],
+ labels=risk_contribution.columns,
+ )
+ ax.legend()
+ # bottom = [0] * len(risk_contribution)
+ # for col in risk_contribution.columns:
+ # bottom = [b + v for b, v in zip(bottom, risk_contribution[col])]
+ # Construct y-axis label and title based on parameters
+ value_label = "USD"
+ title_label = (
+ f"Risk between {self.start_date} and {self.end_date} (Average impact)"
+ )
+
+ locator = mdates.AutoDateLocator()
+ formatter = mdates.ConciseDateFormatter(locator)
+
+ ax.xaxis.set_major_locator(locator)
+ ax.xaxis.set_major_formatter(formatter)
+ ax.yaxis.set_major_formatter(mticker.EngFormatter())
+ ax.set_title(title_label)
+ ax.set_ylabel(value_label)
+ ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1])
+ return fig, ax
+
+ def plot_waterfall(
+ self,
+ ax=None,
+ ):
+ """Plot a waterfall chart of risk contributions between two dates.
+
+ This method generates a waterfall plot to visualize the changes in risk contributions.
+
+ Parameters
+ ----------
+ ax : matplotlib.axes.Axes, optional
+ The matplotlib axes on which to plot. If None, a new figure and axes are created.
+
+ Returns
+ -------
+ matplotlib.axes.Axes
+ The matplotlib axes with the plotted waterfall chart.
+
+ """
+ start_date_p = pd.to_datetime(self.start_date).to_period(self.time_resolution)
+ end_date_p = pd.to_datetime(self.end_date).to_period(self.time_resolution)
+ risk_contribution = self._calc_waterfall_plot_data(
+ start_date=self.start_date, end_date=self.end_date
+ )
+ if ax is None:
+ _, ax = plt.subplots(figsize=(8, 5))
+
+ risk_contribution = risk_contribution.loc[
+ (risk_contribution.index == str(self.end_date))
+ ].squeeze()
+ risk_contribution = cast(pd.Series, risk_contribution)
+
+ labels = [
+ f"Risk {start_date_p}",
+ f"Exposure contribution {end_date_p}",
+ f"Hazard contribution {end_date_p}",
+ f"Vulnerability contribution {end_date_p}",
+ f"Interaction contribution {end_date_p}",
+ f"Total Risk {end_date_p}",
+ ]
+ values = [
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME],
+ risk_contribution[CONTRIBUTION_EXPOSURE_NAME],
+ risk_contribution[CONTRIBUTION_HAZARD_NAME],
+ risk_contribution[CONTRIBUTION_VULNERABILITY_NAME],
+ risk_contribution[CONTRIBUTION_INTERACTION_TERM_NAME],
+ risk_contribution.sum(),
+ ]
+ bottoms = [
+ 0.0,
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME]
+ + risk_contribution[CONTRIBUTION_HAZARD_NAME],
+ risk_contribution[CONTRIBUTION_BASE_RISK_NAME]
+ + risk_contribution[CONTRIBUTION_EXPOSURE_NAME]
+ + risk_contribution[CONTRIBUTION_HAZARD_NAME]
+ + risk_contribution[CONTRIBUTION_VULNERABILITY_NAME],
+ 0.0,
+ ]
+
+ ax.bar(
+ labels,
+ values,
+ bottom=bottoms,
+ edgecolor="black",
+ color=[
+ "tab:cyan",
+ "tab:orange",
+ "tab:green",
+ "tab:red",
+ "tab:purple",
+ "tab:blue",
+ ],
+ )
+ for i in range(len(values)):
+ ax.text(
+ labels[i], # type: ignore
+ values[i] + bottoms[i],
+ f"{values[i]:.0e}",
+ ha="center",
+ va="bottom",
+ color="black",
+ )
+
+ # Construct y-axis label and title based on parameters
+ value_label = "USD"
+ title_label = f"Evolution of the contributions of risk between {start_date_p} and {end_date_p} (Average impact)"
+ ax.yaxis.set_major_formatter(mticker.EngFormatter())
+ ax.set_title(title_label)
+ ax.set_ylabel(value_label)
+ ax.set_ylim(0.0, 1.1 * ax.get_ylim()[1])
+ ax.tick_params(
+ axis="x",
+ labelrotation=90,
+ )
+
+ return ax
diff --git a/climada/trajectories/interpolation.py b/climada/trajectories/interpolation.py
new file mode 100644
index 000000000..9f6687e44
--- /dev/null
+++ b/climada/trajectories/interpolation.py
@@ -0,0 +1,439 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see `_.
+ name : str, optional
+ Name of the resulting period range index.
+
+ Returns
+ -------
+ pd.PeriodIndex
+ A PeriodIndex representing the date range.
+
+ Raises
+ ------
+ ValueError
+ If the number of periods and frequency given to period_range are inconsistent.
+ """
+ ret = pd.period_range(
+ date1,
+ date2,
+ freq=freq, # type: ignore
+ name=name,
+ )
+ return ret
+
+ @property
+ def snapshot_start(self) -> Snapshot:
+ """The `Snapshot` at the start of the risk period."""
+ return self._snapshot0
+
+ @property
+ def snapshot_end(self) -> Snapshot:
+ """The `Snapshot` at the end of the risk period."""
+ return self._snapshot1
+
+ @property
+ def date_idx(self) -> pd.PeriodIndex:
+ """The pandas PeriodIndex representing the time dimension of the risk period."""
+ return self._date_idx
+
+ @date_idx.setter
+ def date_idx(self, value, /):
+ if not isinstance(value, pd.PeriodIndex):
+ raise ValueError("Not a PeriodIndex")
+
+ self._date_idx = value # Avoids weird hourly data
+ self._time_points = len(self.date_idx)
+ self._time_resolution = self.date_idx.freq
+ self._reset_impact_data()
+
+ @property
+ def time_points(self) -> int:
+ """The numbers of different time points (periods) in the risk period."""
+ return self._time_points
+
+ @property
+ def time_resolution(self) -> str:
+ """The time resolution of the risk periods, expressed as a pandas period frequency string."""
+ return self._time_resolution # type: ignore
+
+ @time_resolution.setter
+ def time_resolution(self, value, /):
+ self.date_idx = pd.period_range(
+ self.snapshot_start.date,
+ self.snapshot_end.date,
+ freq=value,
+ name=DEFAULT_PERIOD_INDEX_NAME,
+ )
+
+ @property
+ def interpolation_strategy(self) -> InterpolationStrategyBase:
+ """The approach used to interpolate impact matrices in between the two snapshots."""
+ return self._interpolation_strategy
+
+ @interpolation_strategy.setter
+ def interpolation_strategy(self, value, /):
+ if not isinstance(value, InterpolationStrategyBase):
+ raise ValueError("Not an interpolation strategy")
+
+ self._interpolation_strategy = value
+ self._reset_impact_data()
+
+ @property
+ def impact_computation_strategy(self) -> ImpactComputationStrategy:
+ """The method used to calculate the impact from the (Haz,Exp,Vul) of the two snapshots."""
+ return self._impact_computation_strategy
+
+ @impact_computation_strategy.setter
+ def impact_computation_strategy(self, value, /):
+ if not isinstance(value, ImpactComputationStrategy):
+ raise ValueError("Not an impact computation strategy")
+
+ self._impact_computation_strategy = value
+ self._reset_impact_data()
+
+ ##### Impact objects cube / Risk Cube #####
+
+ @lazy_property
+ def E0H0V0(self) -> Impact:
+ """Impact object corresponding to starting exposure, starting hazard and starting vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E1H0V0(self) -> Impact:
+ """Impact object corresponding to future exposure, starting hazard and starting vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E0H1V0(self) -> Impact:
+ """Impact object corresponding to starting exposure, future hazard and starting vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E1H1V0(self) -> Impact:
+ """Impact object corresponding to future exposure, future hazard and starting vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_start.impfset,
+ )
+
+ @lazy_property
+ def E0H0V1(self) -> Impact:
+ """Impact object corresponding to starting exposure, starting hazard and future vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E1H0V1(self) -> Impact:
+ """Impact object corresponding to future exposure, starting hazard and future vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_start.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E0H1V1(self) -> Impact:
+ """Impact object corresponding to starting exposure, future hazard and future vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_start.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ @lazy_property
+ def E1H1V1(self) -> Impact:
+ """Impact object corresponding to future exposure, future hazard and future vulnerability."""
+ return self.impact_computation_strategy.compute_impacts(
+ self.snapshot_end.exposure,
+ self.snapshot_end.hazard,
+ self.snapshot_end.impfset,
+ )
+
+ ###############################
+
+ ### Impact Matrices arrays ####
+
+ def _interp_mats(self, start_attr, end_attr) -> list:
+ """Helper to reduce repetition in impact matrix interpolation."""
+ start = getattr(self, start_attr).imp_mat
+ end = getattr(self, end_attr).imp_mat
+ return self.interpolation_strategy.interp_over_exposure_dim(
+ start, end, self.time_points
+ )
+
+ @property
+ def imp_mats_H0V0(self) -> list:
+ """List of `time_points` impact matrices with changing exposure, starting hazard and starting vulnerability."""
+ return self._interp_mats("E0H0V0", "E1H0V0")
+
+ @property
+ def imp_mats_H1V0(self) -> list:
+ """List of `time_points` impact matrices with changing exposure, future hazard and starting vulnerability."""
+ return self._interp_mats("E0H1V0", "E1H1V0")
+
+ @property
+ def imp_mats_H0V1(self) -> list:
+ """List of `time_points` impact matrices with changing exposure, starting hazard and future vulnerability."""
+ return self._interp_mats("E0H0V1", "E1H0V1")
+
+ @property
+ def imp_mats_H1V1(self) -> list:
+ """List of `time_points` impact matrices with changing exposure, future hazard and future vulnerability."""
+ return self._interp_mats("E0H1V1", "E1H1V1")
+
+ @property
+ def imp_mats_E0H0V0(self) -> list:
+ """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability."""
+ return self._interp_mats("E0H0V0", "E0H0V0")
+
+ @property
+ def imp_mats_E0H1V0(self) -> list:
+ """List of `time_points` impact matrices with base exposure, future hazard and base vulnerability."""
+ return self._interp_mats("E0H1V0", "E0H1V0")
+
+ @property
+ def imp_mats_E0H0V1(self) -> list:
+ """List of `time_points` impact matrices with base exposure, base hazard and base vulnerability."""
+ return self._interp_mats("E0H0V1", "E0H0V1")
+
+ ###############################
+
+ ########## Core EAI ###########
+
+ @property
+ def per_date_eai_H0V0(self) -> np.ndarray:
+ """Expected annual impacts for changing exposure, starting hazard and starting vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_H0V0, self.snapshot_start.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_H1V0(self) -> np.ndarray:
+ """Expected annual impacts for changing exposure, future hazard and starting vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_H1V0, self.snapshot_end.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_H0V1(self) -> np.ndarray:
+ """Expected annual impacts for changing exposure, starting hazard and future vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_H0V1, self.snapshot_start.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_H1V1(self) -> np.ndarray:
+ """Expected annual impacts for changing exposure, future hazard and future vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_H1V1, self.snapshot_end.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_E0H0V0(self) -> np.ndarray:
+ """Expected annual impacts for base exposure, base hazard and base vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_E0H0V0, self.snapshot_start.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_E0H1V0(self) -> np.ndarray:
+ """Expected annual impacts for base exposure, future hazard and base vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_E0H1V0, self.snapshot_end.hazard.frequency
+ )
+
+ @property
+ def per_date_eai_E0H0V1(self) -> np.ndarray:
+ """Expected annual impacts for base exposure, future hazard and base vulnerability."""
+ return calc_per_date_eais(
+ self.imp_mats_E0H0V1, self.snapshot_start.hazard.frequency
+ )
+
+ ##################################
+
+ ######### Core AAIs ##########
+
+ @property
+ def per_date_aai_H0V0(self) -> np.ndarray:
+ """Average annual impacts for changing exposure, starting hazard and starting vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_H0V0)
+
+ @property
+ def per_date_aai_H1V0(self) -> np.ndarray:
+ """Average annual impacts for changing exposure, future hazard and starting vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_H1V0)
+
+ @property
+ def per_date_aai_H0V1(self) -> np.ndarray:
+ """Average annual impacts for changing exposure, starting hazard and future vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_H0V1)
+
+ @property
+ def per_date_aai_H1V1(self) -> np.ndarray:
+ """Average annual impacts for changing exposure, future hazard and future vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_H1V1)
+
+ @property
+ def per_date_aai_E0H0V0(self) -> np.ndarray:
+ """Average annual impacts for base exposure, base hazard and base vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_E0H0V0)
+
+ @property
+ def per_date_aai_E0H1V0(self) -> np.ndarray:
+ """Average annual impacts for base exposure, base hazard and base vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_E0H1V0)
+
+ @property
+ def per_date_aai_E0H0V1(self) -> np.ndarray:
+ """Average annual impacts for base exposure, base hazard and base vulnerability."""
+ return calc_per_date_aais(self.per_date_eai_E0H0V1)
+
+ #################################
+
+ ######### Core RPs #########
+
+ def per_date_return_periods_H0V0(self, return_periods: list[int]) -> np.ndarray:
+ """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and starting vulnerability."""
+ return calc_per_date_rps(
+ self.imp_mats_H0V0,
+ self.snapshot_start.hazard.frequency,
+ self.date_idx.freqstr[0],
+ return_periods,
+ )
+
+ def per_date_return_periods_H1V0(self, return_periods: list[int]) -> np.ndarray:
+ """Estimated impacts per dates for given return periods, with changing exposure, future hazard and starting vulnerability."""
+ return calc_per_date_rps(
+ self.imp_mats_H1V0,
+ self.snapshot_end.hazard.frequency,
+ self.date_idx.freqstr[0],
+ return_periods,
+ )
+
+ def per_date_return_periods_H0V1(self, return_periods: list[int]) -> np.ndarray:
+ """Estimated impacts per dates for given return periods, with changing exposure, starting hazard and future vulnerability."""
+ return calc_per_date_rps(
+ self.imp_mats_H0V1,
+ self.snapshot_start.hazard.frequency,
+ self.date_idx.freqstr[0],
+ return_periods,
+ )
+
+ def per_date_return_periods_H1V1(self, return_periods: list[int]) -> np.ndarray:
+ """Estimated impacts per dates for given return periods, with changing exposure, future hazard and future vulnerability."""
+ return calc_per_date_rps(
+ self.imp_mats_H1V1,
+ self.snapshot_end.hazard.frequency,
+ self.date_idx.freqstr[0],
+ return_periods,
+ )
+
+ ##################################
+
+ ##### Interpolation of metrics #####
+
+ def calc_eai(self) -> np.ndarray:
+ """Compute the EAIs at each date of the risk period (including changes in exposure, hazard and vulnerability)."""
+ per_date_eai_H0V0, per_date_eai_H1V0, per_date_eai_H0V1, per_date_eai_H1V1 = (
+ self.per_date_eai_H0V0,
+ self.per_date_eai_H1V0,
+ self.per_date_eai_H0V1,
+ self.per_date_eai_H1V1,
+ )
+ per_date_eai_V0 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_eai_H0V0, per_date_eai_H1V0
+ )
+ per_date_eai_V1 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_eai_H0V1, per_date_eai_H1V1
+ )
+ per_date_eai = self.interpolation_strategy.interp_over_vulnerability_dim(
+ per_date_eai_V0, per_date_eai_V1
+ )
+ return per_date_eai
+
+ ### Fully interpolated metrics ###
+
+ @lazy_property
+ def per_date_eai(self) -> np.ndarray:
+ """Expected annual impacts per date with changing exposure, changing hazard and changing vulnerability"""
+ return self.calc_eai()
+
+ @lazy_property
+ def per_date_aai(self) -> np.ndarray:
+ """Average annual impacts per date with changing exposure, changing hazard and changing vulnerability."""
+ return calc_per_date_aais(self.per_date_eai)
+
+ @lazy_property
+ def eai_gdf(self) -> pd.DataFrame:
+ """Convenience function returning a DataFrame (with both datetime and coordinates ids) from `per_date_eai`.
+
+ This dataframe can easily be merged with one of the snapshot exposure geodataframe.
+
+ Notes
+ -----
+
+ The DataFrame from the starting snapshot is used as a basis (notably for `value` and `group_id`).
+
+ """
+ return self.calc_eai_gdf()
+
+ ####################################
+
+ ### Metrics from impact matrices ###
+
+ # These methods might go in a utils file instead, to be reused
+ # for a no interpolation case (and maybe the timeseries?)
+
+ ####################################
+
+ def calc_eai_gdf(self) -> pd.DataFrame:
+ """Merge the per date EAIs of the risk period with the GeoDataframe of the exposure of the starting snapshot."""
+ df = pd.DataFrame(self.per_date_eai, index=self.date_idx)
+ df = df.reset_index().melt(
+ id_vars=DEFAULT_PERIOD_INDEX_NAME,
+ var_name=COORD_ID_COL_NAME,
+ value_name=RISK_COL_NAME,
+ )
+ if GROUP_ID_COL_NAME in self.snapshot_start.exposure.gdf:
+ eai_gdf = self.snapshot_start.exposure.gdf[[GROUP_ID_COL_NAME]]
+ eai_gdf[COORD_ID_COL_NAME] = eai_gdf.index
+ eai_gdf = eai_gdf.merge(df, on=COORD_ID_COL_NAME)
+ eai_gdf = eai_gdf.rename(columns={GROUP_ID_COL_NAME: GROUP_COL_NAME})
+ else:
+ eai_gdf = df
+ eai_gdf[GROUP_COL_NAME] = pd.NA
+
+ eai_gdf[GROUP_COL_NAME] = pd.Categorical(
+ eai_gdf[GROUP_COL_NAME], categories=self._groups_id
+ )
+ eai_gdf[METRIC_COL_NAME] = EAI_METRIC_NAME
+ eai_gdf[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ eai_gdf[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return eai_gdf
+
+ def calc_aai_metric(self) -> pd.DataFrame:
+ """Compute a DataFrame of the AAI at each dates of the risk period (including changes in exposure, hazard and vulnerability)."""
+ aai_df = pd.DataFrame(
+ index=self.date_idx, columns=[RISK_COL_NAME], data=self.per_date_aai
+ )
+ aai_df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(aai_df), categories=self._groups_id
+ )
+ aai_df[METRIC_COL_NAME] = AAI_METRIC_NAME
+ aai_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ aai_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ aai_df.reset_index(inplace=True)
+ return aai_df
+
+ def calc_aai_per_group_metric(self) -> pd.DataFrame | None:
+ """Compute a DataFrame of the AAI distinguised per group id in the exposures, at each dates of the risk period (including changes in exposure, hazard and vulnerability).
+
+ Notes
+ -----
+
+ If group ids changes between starting and ending snapshots of the risk period, the AAIs are linearly interpolated (with a warning for transparency).
+
+ """
+ if len(self._group_id_E0) < 1 or len(self._group_id_E1) < 1:
+ LOGGER.warning(
+ "No group id defined in at least one of the Exposures object. Per group aai will be empty."
+ )
+ return None
+
+ eai_pres_groups = self.eai_gdf[
+ [
+ DEFAULT_PERIOD_INDEX_NAME,
+ COORD_ID_COL_NAME,
+ GROUP_COL_NAME,
+ RISK_COL_NAME,
+ ]
+ ].copy()
+ aai_per_group_df = eai_pres_groups.groupby(
+ [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False, observed=True
+ )[RISK_COL_NAME].sum()
+ if not np.array_equal(self._group_id_E0, self._group_id_E1):
+ LOGGER.warning(
+ "Group id are changing between present and future snapshot. Per group AAI will be linearly interpolated."
+ )
+ eai_fut_groups = self.eai_gdf.copy()
+ eai_fut_groups[GROUP_COL_NAME] = pd.Categorical(
+ np.tile(self._group_id_E1, len(self.date_idx)),
+ categories=self._groups_id,
+ )
+ aai_fut_groups = eai_fut_groups.groupby(
+ [DEFAULT_PERIOD_INDEX_NAME, GROUP_COL_NAME], as_index=False
+ )[RISK_COL_NAME].sum()
+ aai_per_group_df[RISK_COL_NAME] = linear_interp_arrays(
+ aai_per_group_df[RISK_COL_NAME].values,
+ aai_fut_groups[RISK_COL_NAME].values,
+ )
+
+ aai_per_group_df[METRIC_COL_NAME] = AAI_METRIC_NAME
+ aai_per_group_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ aai_per_group_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return aai_per_group_df
+
+ def calc_return_periods_metric(self, return_periods: list[int]) -> pd.DataFrame:
+ """Compute a DataFrame of the estimated impacts for a list of return
+ periods, at each dates of the risk period (including changes in exposure,
+ hazard and vulnerability).
+
+ Parameters
+ ----------
+
+ return_periods : list of int
+ The return periods to estimate impacts for.
+
+ """
+
+ # currently mathematicaly wrong, but approximatively correct, to be reworked when concatenating the impact matrices for the interpolation
+ per_date_rp_H0V0, per_date_rp_H1V0, per_date_rp_H0V1, per_date_rp_H1V1 = (
+ self.per_date_return_periods_H0V0(return_periods),
+ self.per_date_return_periods_H1V0(return_periods),
+ self.per_date_return_periods_H0V1(return_periods),
+ self.per_date_return_periods_H1V1(return_periods),
+ )
+ per_date_rp_V0 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_rp_H0V0, per_date_rp_H1V0
+ )
+ per_date_rp_V1 = self.interpolation_strategy.interp_over_hazard_dim(
+ per_date_rp_H0V1, per_date_rp_H1V1
+ )
+ per_date_rp = self.interpolation_strategy.interp_over_vulnerability_dim(
+ per_date_rp_V0, per_date_rp_V1
+ )
+ rp_df = pd.DataFrame(
+ index=self.date_idx, columns=return_periods, data=per_date_rp
+ ).melt(value_name=RISK_COL_NAME, var_name="rp", ignore_index=False)
+ rp_df.reset_index(inplace=True)
+ rp_df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(rp_df), categories=self._groups_id
+ )
+ rp_df[METRIC_COL_NAME] = RP_VALUE_PREFIX + "_" + rp_df["rp"].astype(str)
+ rp_df = rp_df.drop("rp", axis=1)
+ rp_df[MEASURE_COL_NAME] = (
+ self.measure.name if self.measure else NO_MEASURE_VALUE
+ )
+ rp_df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return rp_df
+
+ def calc_risk_contributions_metric(self) -> pd.DataFrame:
+ """Compute a DataFrame of the individual contributions of risk (impact),
+ at each dates of the risk period (including changes in exposure,
+ hazard and vulnerability).
+
+ """
+ per_date_aai_E0V0 = self.interpolation_strategy.interp_over_hazard_dim(
+ self.per_date_aai_E0H0V0, self.per_date_aai_E0H1V0
+ )
+ per_date_aai_E0H0 = self.interpolation_strategy.interp_over_vulnerability_dim(
+ self.per_date_aai_E0H0V0, self.per_date_aai_E0H0V1
+ )
+ df = pd.DataFrame(
+ {
+ CONTRIBUTION_TOTAL_RISK_NAME: self.per_date_aai,
+ CONTRIBUTION_BASE_RISK_NAME: self.per_date_aai[0],
+ CONTRIBUTION_EXPOSURE_NAME: self.per_date_aai_H0V0
+ - self.per_date_aai[0],
+ CONTRIBUTION_HAZARD_NAME: per_date_aai_E0V0
+ # - (self.per_date_aai_H0V0 - self.per_date_aai[0])
+ - self.per_date_aai[0],
+ CONTRIBUTION_VULNERABILITY_NAME: per_date_aai_E0H0
+ - self.per_date_aai[0],
+ # - (self.per_date_aai_H0V0 - self.per_date_aai[0]),
+ },
+ index=self.date_idx,
+ )
+ df[CONTRIBUTION_INTERACTION_TERM_NAME] = df[CONTRIBUTION_TOTAL_RISK_NAME] - (
+ df[CONTRIBUTION_BASE_RISK_NAME]
+ + df[CONTRIBUTION_EXPOSURE_NAME]
+ + df[CONTRIBUTION_HAZARD_NAME]
+ + df[CONTRIBUTION_VULNERABILITY_NAME]
+ )
+ df = df.melt(
+ value_vars=[
+ CONTRIBUTION_BASE_RISK_NAME,
+ CONTRIBUTION_EXPOSURE_NAME,
+ CONTRIBUTION_HAZARD_NAME,
+ CONTRIBUTION_VULNERABILITY_NAME,
+ CONTRIBUTION_INTERACTION_TERM_NAME,
+ ],
+ var_name=METRIC_COL_NAME,
+ value_name=RISK_COL_NAME,
+ ignore_index=False,
+ )
+ df.reset_index(inplace=True)
+ df[GROUP_COL_NAME] = pd.Categorical(
+ [pd.NA] * len(df), categories=self._groups_id
+ )
+ df[MEASURE_COL_NAME] = self.measure.name if self.measure else NO_MEASURE_VALUE
+ df[UNIT_COL_NAME] = self.snapshot_start.exposure.value_unit
+ return df
+
+ def apply_measure(self, measure: Measure) -> "CalcRiskMetricsPeriod":
+ """Creates a new `CalcRiskMetricsPeriod` object with a measure.
+
+ The given measure is applied to both snapshot of the risk period.
+
+ Parameters
+ ----------
+ measure : Measure
+ The measure to apply.
+
+ Returns
+ -------
+
+ CalcRiskPeriod
+ The risk period with given measure applied.
+
+ """
+ snap0 = self.snapshot_start.apply_measure(measure)
+ snap1 = self.snapshot_end.apply_measure(measure)
+
+ risk_period = CalcRiskMetricsPeriod(
+ snap0,
+ snap1,
+ self.time_resolution,
+ self.interpolation_strategy,
+ self.impact_computation_strategy,
+ )
+
+ risk_period.measure = measure
+ return risk_period
+
+
+def calc_per_date_eais(imp_mats: list[csr_matrix], frequency: np.ndarray) -> np.ndarray:
+ """Calculate expected average impact (EAI) values from a list of impact matrices
+ corresponding to impacts at different dates (with possible changes along
+ exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ imp_mats : list of np.ndarray
+ List of impact matrices.
+ frequency : np.ndarray
+ Hazard frequency values.
+
+ Returns
+ -------
+ np.ndarray
+ 2D array of EAI (1D) for each dates.
+
+ """
+ per_date_eai_exp = np.array(
+ [ImpactCalc.eai_exp_from_mat(imp_mat, frequency) for imp_mat in imp_mats]
+ )
+ return per_date_eai_exp
+
+
+def calc_per_date_aais(per_date_eai_exp: np.ndarray) -> np.ndarray:
+ """Calculate per_date aggregate annual impact (AAI) values
+ resulting from a list arrays corresponding to EAI at different
+ dates (with possible changes along exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ per_date_eai_exp: np.ndarray
+ EAIs arrays.
+
+ Returns
+ -------
+ np.ndarray
+ 1D array of AAI (0D) for each dates.
+ """
+ per_date_aai = np.array(
+ [ImpactCalc.aai_agg_from_eai_exp(eai_exp) for eai_exp in per_date_eai_exp]
+ )
+ return per_date_aai
+
+
+def calc_per_date_rps(
+ imp_mats: list[csr_matrix],
+ frequency: np.ndarray,
+ frequency_unit: str,
+ return_periods: list[int],
+) -> np.ndarray:
+ """Calculate per date return period impact values from a
+ list of impact matrices corresponding to impacts at different
+ dates (with possible changes along exposure, hazard and vulnerability).
+
+ Parameters
+ ----------
+ imp_mats: list of scipy.crs_matrix
+ List of impact matrices.
+ frequency: np.ndarray
+ Frequency values.
+ return_periods : list of int
+ Return periods to calculate impact values for.
+
+ Returns
+ -------
+ np.ndarray
+ 2D array of impacts per return periods (1D) for each dates.
+
+ """
+ rp = np.array(
+ [
+ calc_freq_curve(imp_mat, frequency, frequency_unit, return_periods).impact
+ for imp_mat in imp_mats
+ ]
+ )
+ return rp
+
+
+def calc_freq_curve(
+ imp_mat_intrpl, frequency, frequency_unit, return_per=None
+) -> ImpactFreqCurve:
+ """Calculate the estimated impacts for given return periods.
+
+ Parameters
+ ----------
+
+ imp_mat_intrpl: scipy.csr_matrix
+ An impact matrix.
+ frequency: np.ndarray
+ The frequency of the hazard.
+ return_per: np.ndarray
+ The return periods to compute impacts for.
+
+ Returns
+ -------
+ np.ndarray
+ The estimated impacts for the different return periods.
+
+ """
+
+ at_event = np.sum(imp_mat_intrpl, axis=1).A1
+
+ # Sort descendingly the impacts per events
+ sort_idxs = np.argsort(at_event)[::-1]
+ # Calculate exceedence frequency
+ exceed_freq = np.cumsum(frequency[sort_idxs])
+ # Set return period and impact exceeding frequency
+ ifc_return_per = 1 / exceed_freq[::-1]
+ ifc_impact = at_event[sort_idxs][::-1]
+
+ if return_per is not None:
+ interp_imp = np.interp(return_per, ifc_return_per, ifc_impact)
+ ifc_return_per = return_per
+ ifc_impact = interp_imp
+
+ return ImpactFreqCurve(
+ return_per=ifc_return_per,
+ impact=ifc_impact,
+ frequency_unit=frequency_unit,
+ label="Exceedance frequency curve",
+ )
diff --git a/climada/trajectories/snapshot.py b/climada/trajectories/snapshot.py
new file mode 100644
index 000000000..d8c78c0c2
--- /dev/null
+++ b/climada/trajectories/snapshot.py
@@ -0,0 +1,163 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see _metrics` and returned.
+
+ Parameters
+ ----------
+ metric_name : str, optional
+ The name of the metric to return results for.
+ metric_meth : str, optional
+ The name of the specific method of the calculator to call.
+
+ Returns
+ -------
+ pd.DataFrame
+ A tidy formatted dataframe of the risk metric computed for the
+ different snapshots.
+
+ Raises
+ ------
+ NotImplementedError
+ If the requested metric is not part of `POSSIBLE_METRICS`.
+ ValueError
+ If either of the arguments are not provided.
+
+ """
+ if metric_name is None or metric_meth is None:
+ raise ValueError("Both metric_name and metric_meth must be provided.")
+
+ if metric_name not in self.POSSIBLE_METRICS:
+ raise NotImplementedError(
+ f"{metric_name} not implemented ({self.POSSIBLE_METRICS})."
+ )
+
+ # Construct the attribute name for storing the metric results
+ attr_name = f"_{metric_name}_metrics"
+
+ if getattr(self, attr_name) is not None:
+ LOGGER.debug(f"Returning cached {attr_name}")
+ return getattr(self, attr_name)
+
+ with log_level(level="WARNING", name_prefix="climada"):
+ tmp = getattr(self._risk_metrics_calculators, metric_meth)(**kwargs)
+ if tmp is None:
+ return tmp
+
+ tmp = tmp.set_index(
+ [DATE_COL_NAME, GROUP_COL_NAME, MEASURE_COL_NAME, METRIC_COL_NAME]
+ )
+ if COORD_ID_COL_NAME in tmp.columns:
+ tmp = tmp.set_index([COORD_ID_COL_NAME], append=True)
+
+ # When more than 2 snapshots, there might be duplicated rows, we need to remove them.
+ # Should not be the case in static trajectory, but in any case we really don't want
+ # duplicated rows, which would mess up some dataframe manipulation down the road.
+ tmp = tmp[~tmp.index.duplicated(keep="first")]
+ tmp = tmp.reset_index()
+ if self._all_groups_name not in tmp[GROUP_COL_NAME].cat.categories:
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].cat.add_categories(
+ [self._all_groups_name]
+ )
+ tmp[GROUP_COL_NAME] = tmp[GROUP_COL_NAME].fillna(self._all_groups_name)
+
+ if self._risk_disc_rates:
+ tmp = self.npv_transform(tmp, self._risk_disc_rates)
+
+ tmp = reorder_dataframe_columns(tmp, DEFAULT_DF_COLUMN_PRIORITY)
+
+ setattr(self, attr_name, tmp)
+ return getattr(self, attr_name)
+
+ def eai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated annual impacts at each exposure point for each date.
+
+ This method computes and return a `DataFrame` with eai metric
+ (for each exposure point) for each date.
+
+ Notes
+ -----
+
+ This computation may become quite expensive for big areas with high resolution.
+
+ """
+ df = self._compute_metrics(
+ metric_name=EAI_METRIC_NAME, metric_meth="calc_eai_gdf", **kwargs
+ )
+ return df
+
+ def aai_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each date.
+
+ This method computes and return a `DataFrame` with aai metric for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_METRIC_NAME, metric_meth="calc_aai_metric", **kwargs
+ )
+
+ def return_periods_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the estimated impacts for different return periods.
+
+ Return periods to estimate impacts for are defined by `self.return_periods`.
+
+ """
+ return self._compute_metrics(
+ metric_name=RETURN_PERIOD_METRIC_NAME,
+ metric_meth="calc_return_periods_metric",
+ return_periods=self.return_periods,
+ **kwargs,
+ )
+
+ def aai_per_group_metrics(self, **kwargs) -> pd.DataFrame:
+ """Return the average annual impacts for each exposure group ID.
+
+ This method computes and return a `DataFrame` with aai metric for each
+ of the exposure group defined by a group id, for each date.
+
+ """
+
+ return self._compute_metrics(
+ metric_name=AAI_PER_GROUP_METRIC_NAME,
+ metric_meth="calc_aai_per_group_metric",
+ **kwargs,
+ )
+
+ def per_date_risk_metrics(
+ self,
+ metrics: list[str] | None = None,
+ ) -> pd.DataFrame | pd.Series:
+ """Returns a DataFrame of risk metrics for each dates.
+
+ This methods collects (and if needed computes) the `metrics`
+ (Defaulting to AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME and AAI_PER_GROUP_METRIC_NAME).
+
+ Parameters
+ ----------
+ metrics : list[str], optional
+ The list of metrics to return (defaults to
+ [AAI_METRIC_NAME,RETURN_PERIOD_METRIC_NAME,AAI_PER_GROUP_METRIC_NAME])
+
+ Returns
+ -------
+ pd.DataFrame | pd.Series
+ A tidy DataFrame with metric values for all possible dates.
+
+ """
+
+ metrics = (
+ [AAI_METRIC_NAME, RETURN_PERIOD_METRIC_NAME, AAI_PER_GROUP_METRIC_NAME]
+ if metrics is None
+ else metrics
+ )
+ return pd.concat(
+ [getattr(self, f"{metric}_metrics")() for metric in metrics],
+ ignore_index=True,
+ )
diff --git a/climada/trajectories/test/test_impact_calc_strat.py b/climada/trajectories/test/test_impact_calc_strat.py
new file mode 100644
index 000000000..a828ec51e
--- /dev/null
+++ b/climada/trajectories/test/test_impact_calc_strat.py
@@ -0,0 +1,84 @@
+"""
+This file is part of CLIMADA.
+
+Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.
+
+CLIMADA is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free
+Software Foundation, version 3.
+
+CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with CLIMADA. If not, see "
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAImCAYAAAAFaPhAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYJFXVhr+q7p6enGdzIi1hyRnJUUAyKDmpgFnhB0SRIEmSoiggKEkBFRVBBUQlCUiWnHaBzWF2cp6O9T/ndlfNre5bocPM9Mycl+fSNRVu3QrdW6e+EzTDMAwwDMMwDMMwDMMwkwZ9vAfAMAzDMAzDMAzDFBc29BiGYRiGYRiGYSYZbOgxDMMwDMMwDMNMMtjQYxiGYRiGYRiGmWSwoccwDMMwDMMwDDPJYEOPYRiGYRiGYRhmksGGHsMwDMMwDMMwzCSDDT2GYRiGYRiGYZhJBht6DMMwDMMwDMMwkww29BiGYXLkmWeegaZpotE0UzjLli2zzuk999zDp3SKsmDBAnEPnHHGGZgK8H3PMMxowoYew4zTP+qFtEyeeuopfPvb38Z2222HGTNmoKysDPX19dhiiy1w2mmn4cEHH0QkEuFrzTAMwzAMM0VgQ49hJjBvv/029txzT+y///64+eab8eabb6K1tRWxWAw9PT344IMP8Nvf/hbHH3885s6di1tvvXW8h8zkgGnYX3755VP+vJHKZ54PemEyGaDr6vTyhmGKyVRTShmGSRFMfzIMMwbMnj0b77zzjuPyrbbaSnzuuOOOuPvuu137evzxx/GFL3wB/f394u8tt9xSGHQ77bQTmpubxXx6IKb1/vrXv6KtrQ1f//rX8bWvfa3IRzX12GeffWAYxngPY9I9iPI5ZaYafN8zDDOasKHHMGNIKBQSBpkXVVVVruu99957OO644zA4OIhgMCjUvHPOOQe6bhfp9957b5x++ulYu3YtfvCDH+Cuu+4qynEwDMMwDMMwpQ0begwzwSDV4+STTxZGnunSRn+7MXPmTNx5553Ya6+9xmiUDMMwDMMwzHjCMXoMM8F49NFH8dZbb4npww8/3NPIkyF1r9AMk8lkEr/61a/wmc98Bo2NjSLpyx577IGHH37Yth3FCF5zzTXYeuutUVNTg4aGBhx22GF49dVXXff36aef4sYbbxTrzp8/H+Xl5aisrMSGG26IU045Bc8//7zjtg888IA1VnJTdWLJkiWorq4W61ECm2g0WtA5yYTiYGgZuWURHR0duPjii7H55puLY6FzccABBwiXWrd4GpMf/vCHWQl5nGJtPv74Y5x77rnCDbiurg4VFRXi3NH6r732Wk7HROeT3FSbmprEuBctWiTiygYGBlzPz+uvv44vfelLWLhwoVCn6RpSjOgOO+wgrgsdd6abplP2QXNcZ555pjVvgw02yDoftF5nZ6fYF/39zW9+E1788Y9/tLZ/7LHHkCvkhn3llVfiwAMPFG7ZlASJ7vVNN90UZ599tqObthlvSNfVRJV0Kd9YRPru/ehHP8Luu++OlpYWMS562UO/F3/6059cXWTp2v7+97/HF7/4RfHdra2tFZ4I06ZNE/csxfn6TexE7uJXXHGFGAdtHw6HxX1Af9P8jz76yLMP8l6gaz9v3jyxPR3HiSeeiHfffReFkPkdXblypUhotfHGG4vvzPTp03H00Ufjueee89Uf/S6deuqpoj+6B+l3cfvtt8cll1yC9vb2vLNuZsZxDg0N4dprr8U222wjfsPoO07nk7ZVXVf6/tK2y5cvF3/fe++9WfcZrcMwzCTFYBimZKCvJLW9997bcZ1jjjnGWu/JJ58c9TE9/fTT1v7++c9/Gp/73OesvzPbtddeK7ZZunSpsdlmmynXKSsrE/2o+PTTTx37ltv555/vON4TTzzRWu/RRx/NWh6LxYydd95ZLC8vLzfee++9gs4JTWdy+umni2Xz588X/c+dO9fxWK655pqs7Wk7r3NA+8jkhhtuMEKhkOM2mqYZl1xyiecx/fvf/zaOP/54x3522GEHo6+vT9nPT37yE0PXdc/xZ25P94y57O6771aOy62Z1+GEE04Qfzc2NhrDw8Ou1/HQQw8V686aNcuIx+Ou67qdL6dG5+FnP/tZ1rZ0fH6Oic5JrtC1a2pqcu2Xjtvp+tFvj9e4tt56a2P16tWu47jvvvuMqqoq137oPne69+n+fvDBB42KigrltvTdLeT3T/6Ovvzyy47njL4z5u+aikQiYXz96193Pc76+nrHsTrd9yaXXXaZtXzNmjXGlltu6bifs88+O6/r6fbvDcMwExs29BimhPDzD29LS4tYhx6i6CFjtJEfaMlAogef0047zXj88ceN119/3bjnnnuMOXPmWA+2b731lrHddtuJ8f3gBz8w/vOf/xivvPKKcfXVV4uHM1qPDB/VQ/iSJUuEIXjEEUcYP//5z42nnnrK+N///icMQ3pg3mijjayx/PrXv1aOt7u725g3b55YZ/r06cb69ettyy+99FKrD9VDeDENPbpWG2+8sVFXV2dcfvnl4ly8+uqrYr9kiNA6gUDAePvtt23bf/TRR8Y777xj7eOrX/2q+Ftuq1atsm1z/fXX267THXfcYbz44oviGj3wwAPG7rvvbi2/+eabXY9pt912E5/HHXec8cgjj4g+6HPPPfe01rnggguy+qBrbxp5G2ywgfHjH/9YPOC+8cYbxnPPPWfcddddxqmnnmpUV1f7NvT6+/vF8V511VXW8ieeeCLrfNB6xL/+9S9rPTIUnKCHZjr3tN5FF11k5Arth46DDEs6188++6y4Vx977DFhvM+YMcMyFDJfbHR1dYkx03U1x5p5PNSi0WhOY3r++ectQ5++YzQOuq50/v/+97+L7625P3phpILuEzLk6IXAww8/LL67//3vf8U9RN9Lc3u6F5LJpLKPe++911qPDLVvf/vb4rzQ+aHvwC9+8QvjoIMOEveIk6FHvyH0e0Hfn1/+8pfCGKPjo5c85j3m9DviB/k7SvukcdLvFe3jpZdeMq677jphoJnH8Yc//EHZD30PzHU23HBD4/bbbxfnjH67zj33XOt6hMPhrO95roYefS+pn/POO098r1577TXxnTJ/71Qvt+jlGd1L9DKDlh955JFZ9xmtwzDM5IQNPYaZQIYevUU31/nMZz4zJmPKVC5uueWWrHXeffdd66G5ublZPKCRQZMJPbCZ/fz5z3/OWk4P6/QA7gQ9+JoqDD3cOKkwzzzzjPUwSA+nJmT4mOOkB02nB9ViGXrUGhoajA8++CBrHXp4JiOA1vnGN76h3I/ZBz3suUHnPxgMinXp4VJ1XPRSwBxXTU2NMDacjomaSsWIRCLCCKDlZKhmGiJkHJgvIdatW+c4XjLGM19SeD3wyiqYm9JFx04GBK13yCGHOK5Hx2f2R4Z1rrS1tWWdQ5ne3l5j++23F/2T8aRCfogvFLo2ppFERhjtX8Wdd95p7ZPUv0wWL17sup/777/f2p6MXdVvVGVlpVhOxq6bYr5ixQpXNXunnXZSHsePfvQja50//elPRj7I31F6uUQGXib0vaWXNOax0DmWIcPN/J3ZaqutxH2dCb0QM9fZddddCzL0aJxkKGdChpqpfB522GHK45WVUoZhpg4co8cwEwg51oNiSMYaistTlWeg2C2q52eO8bzzzhMlIlQxghS/QqhiXyiei2JwnKBYIYpPIVasWIE33nhDuR5lG73gggvENMWD3X777SL2iGL8EomEiDkz46RGG4rh2myzzbLm77bbbth1113FtFvcoR9+/OMfIx6PixjAG264QXlclJH1pz/9qYhz6uvrE7FaTlCJju9+97tZ8ynWy4x9pHi4999/37Z83bp14pNi1NzuT4oryswQWyzkeL5//vOfWL16tXI9Mx6K4psoljBXqIQJxWE5QbF6Zv3DF154wTVOqxhQXB3FYVEW3vvuu0/sXwXF3u2yyy5iWlXCZZNNNnHdz0knnSRiz4jMuFzi5z//uZUoir53W2yxhWNfFK/nBmUJVh0H3YN0Lxbju0PQbxrdB5nQ95Zi7Mx7O/N4b7vtNhGzTNxxxx3ivs7k4IMPFueceOmll1zjZL341re+Zf3OylDM6lFHHWXdawzDMCZs6DHMBIIe0GWjaKyhun1OUOIGr/XIyDMfJJcuXeq5P0qSQkkSqPA7JV+gRoaaiZmUxsnAokQrxP/93/+JB9RPPvnEeihzMyiLaXSccMIJjsvNB2Y/58KNv/3tb+LzmGOOQSAQcFyPDBOzVuOLL77ouB4lu/Aas2rc5jmlBBqFPNAWChl6ZEjSvfLb3/42azkd+4cffmitWwwoSQYZWmT8mveqfC3c7tViYCb2ISOOEpe4YRoLbveAyfr167F48WLrmKiZ11l1TJQsiqAEQEcccQTyhX5PnErMkPGXy+9IIUmqaJn54uTJJ5+0Lfv3v/8tPsmYNV/aqDjrrLOytskH+g3z+l52dXWhu7s7730wDDO54PIKDDOBkN9ue2U+HA3clA/5bbbbeqYKIhutmcYdvSknVYIeJGOxmGNflM3STf27//77RaZHOlfmgzA92JNBNBaQ6kPqoROUtdTtXPiBjAtTLbr66qtF84OpvqkgRc5rzKpxk4FI2R4pKyMplocccgg+97nPiays9DA8FgoqMWfOHHz2s5/F448/LlSriy66yLbcVLLoZcnxxx+f937o+Ekl/cMf/iBeRpjqTq73ajGgTKemouP3PDvdA88++6yozfnUU0+5Gg2Zx0TfVTMbJl3zQnC7B4v13SFI4TZffjh9h0kxo2zAcqZPuscpey9hKqRO0Asn+j2i8+OUidUPuXwv3dRmhmGmDqzoMcwEgh465DftYw2lHXdCdsXzs56szMkPjvRm/Dvf+Y5QhNyMPFNFcYNcGcmN1ISUiJ/97GcYK6gkgRvmuXAzELzI9z4w3etyHbd8nTOvIbm6/e53vxPlI8iVlJTGr3zlK0KZofT6lH7eb7r6Qvnyl78sPkmN+u9//2u7Z8gwIz7/+c+LFPX5QA/+ZCBceumlQsH0uoZe92qh5HMfqO4BOh5Kt//QQw95KkOZx0TuvGaK/0IVc7/fHdXvSC6QgeSmghN075rHZ0LKmV83ejLyzBc+ch+5ku/3kmGYqQsregwzgZg1a5aoi0X1qUjtoofL0Yp1Gg+ojpUZd3fssccK9Y0eps0aXKRU0IOkecxu9cDMemKy6x49DL/99tvKeJyJivxQR3XZ/KqVo+X6S9eN6sqRMfWPf/xDGHZ0v5LqSCotNXKHo/ir0bx3qWYc3Td0zUnBo/hS4s9//jN6e3sLdts87bTThJpK9yTVDCQXXTJ06WUM3aumWyG5MPq5V4t1H1D9SVJV84HcCsnlmaB6cueff75Q5iiWju4X0yCi6/eb3/zG9ZjGSr0tBfwc62hff4ZhGBVs6DHMBIPia+hte39/v3Cx2nfffTEZoIfvBx98UExT0hRVbFXmm3Q/SRYoaYvp9kouTaQqkZHslKxioiG7hpLbq1Nc01hCRbYpLsmMTSK3xkceeUQk6lizZo0o2kzubGTYjxakopAxduONNwqjk5RcUkRMt82NNtoIe+21V159U3yfmfTi4osvtoyjQu7VYtwHdG5pn/neA7/+9a/FJymypILSS6VcjovUMTLe6QUUjWUiQAobGcluqp6plsrukXSO/LhBE6Rum0qe3AfDMMxoM3mkAIaZIsgqxFi6IY42FO9iumq6JX3xm+SDshA+8MADYprcB0mBMFWW0TQwxhpSjMz4yH/9618oRciFluLkKOugqSSaRr1f8lGISGkjyMAnJY8UuKeffrpgNY9cNU0KuVeLqXqZiYdeeeUVoWQXclz08sjJyCNl6n//+5+jcW0amcXIhjkWUKydW9wcKdFmwhfZgCbV1kwI8/LLL7vug7wUzN82t3jA0WQqKawMw4zAhh7DTDAouYWZ4ZJUEjJo/OKkkpUCcjyeWzwTZcz0YtWqVfjqV79qJYah8gOUftxMc06qzl/+8heUOmYpCnoYdYKUiEMPPdR6yCeVt1QhF0AzUU+u5QbMc+F1PmTIldJ006VrTiUVTNdft0yLxbhXaT+/+tWvXPvJ55icMDNc0tgoQUwhx+X2/aOsmk4lK0yXWTOG0cwGW+qYL4Gclplul/vvv79tGbkoE5RplV5ieCml8jal+FvCMMzkgw09hplg0JtZinMyE56QexoZP24xIK2trSI5Ba1bqlBMkPnW2ckgpQcmUmbcoPNAD/GUSMKsKWYmMSAF1IyZOvvssz1drsYbM6GFWRbCie9973uW6xm5pn700UeO65JbHSmdZAwXG6oz5pbAg0plmGUNKJNhLsjJPbzOh0rVe+aZZ3DrrbdaD9uUmTNf5FpzTkYC1V/zUvTyPSYVdM+bdemuuuoq8RLIDXLN/M9//qM8LoqrXLZsWdY2NM98geLEN77xDUu1pe8Yue06MRr3YD7QfaEy1CiRD51LYsaMGVatOhM6F2acKR2rSkmlWo533nmnmKZEU5QFuJR/SxiGmVxwjB7DTEDI/Ydc3ygBBJUOOOecc3DLLbeIVPFUqJwSQlAMH7mqPfHEE+IBfDzKMeQCjZmKC1NK/L///e9CuaSHJ3p4pXgfKpVA6iWl7Xer//WTn/xEpIUnLrvsMlH824QyLJIRSbFZpCiRwvfYY4+hVKEEIuQ2ZhZ9J3XKfDNPcXBmNkC6HygW7dxzzxXGFNXUIgOHSgxQAh96i0/3Ap03KpROigy5qxVi7KggJenkk08W126//fYTLpvkVkoxXWT0UIyeqRZ5GQwq10Q69uHhYWFEkZvg/PnzrQft2bNnK7O9kmslueqS+6YZa2Uqu/lC55fKRZCSQ987esCn0hJkDJCSRQ/2lIiGrp+c8TMTM0EMQdeO4v3ogdx84bFgwQLxssIP5EpIvwmUMZOu99FHHy0aZRaleETqk15sUBkGUrMpTpWuhxynSC8J6LtHvx00n14g0HmnGDMylG+66SbxO0LH7+S+SeeAyqPQSyXaH/0eUawmfbdpGfVNZQronqYXEuNteJCLKt03pNZRvU0aJ700IWOXktqY8Yj0ksgs0m5Crpy0zQ033CC+T3Revvvd74pPs6QLnWOKAaTr48cbYbSge43cll999VVce+21ovSJaZDT8dP3h2GYSYjBMEzJQF9Janvvvbev9d944w1jt912s7Zza9OnTzfuuOOOnMf09NNPW33QtBOXXXaZtZ4bdGxOx7hs2TJjzpw5jsewxRZbGKtWrbL+pn3KvPXWW0Y4HBbLPvOZzxjxeFw5hosvvtjq45ZbbjGKfU5OP/10sWz+/Pmu/XidM7q+5vFkNtpHJnR9KysrPe+FsrIyY8mSJTkdk8nSpUut9e6++27ltXVrgUDAuOaaa3Lq1+TCCy907NdtzGeddZa1XmNjozE8PGwUymuvvWbU19c7jmePPfYw3n77bc9j+sIXvuDYB52TXHnxxReNuXPn+vpNuPfee7O2P+200xzXLy8vN373u9/5ur/vueceo6KiwnX/qu1pntP97fd3xA/yMbz00kvivlCNUdM040c/+pFjP4lEwvja177mepx0n/z73/9Wbu913/v9XaVt3e4b+t10OsZ8zyHDMKUPu24yzARm2223FYoBJeEgl6ltttlGqDykApCSQooKvaWnN/2UfdLMgliqkEJDSgGpG6RC0Bt0ym5H7k70FpreRju9eSYVg7J10qep3Dll0iOlz3ShohTypjthKV5fUuFIuZ03b16WopAJXV9SAKnMAql/pJLSvUBv7ik2jkof/PKXvxSKHrnKFhu6z0h5PeOMM8TYScGh/dP1IPXj61//ukhMQUpRPtA9QHFvlHnWT/0zE/oOmJx00klW+YNCoPuHjoVcokl1JoWRzjedd1L5SD3xk9mVXIuvv/567LzzzuI7W2jSDHIPpMRGdJ1JWSVFl+4bUkNpnAcddBCuvvpqcc+rXLkpI6pZjoKuG21H7s50nPT9o3vRryspqXWkUtK5ogLeNA66j6lkA43BTIwz3lDBc/rdoSy9dKx0f9C1PPLII0XMKyUScoIUZbre5AZLajYdH21Pijt9B+j46XpkxveNNfS7STG8pPTTb6scH8owzORFI2tvvAfBMAzDMKMFuRLSQzxBD/Rmhkpm6kIvI8iopZdLqnhEhmGYyQAregzDMMykhrJtEqSwsJHHMAzDTBXY0GMYhmEmLeRSRy5r+SSAYRiGYZiJDBt6DMMwzKSCMoxSanzKLmnWy6NYtVIuL8IwDMP4JxqNigzHlCmXshVTbCzFFW+66aYis7JbbUsZypB8zDHHiCzU1Ad90t80fzLAMXoMwzDMpILKEpCxZ0IJTqj+IpUbYBiCY/QYZuJCZYQo2RSVNXHj3HPPxY9//GNlkitKUfKVr3zFtewJlXiixFaFJskaT1jRYxiGYSYllPmQskc++uijbOQxDMNMAqiup2zkbb311iIOmzJU//Of/8Sll15q1Yi86aabRI1ZFT/4wQ8sI49it3/3u98JN3/6NGO5aTnVbZ3IsKI3CaACwiRhMwzDMAzDMJMXs1zKZHg29HssMuSdcdxxx4np3XbbDc8991xWqZ3XX39dLIvFYqJE0/r160WpH5OPP/5YlJ8io3HHHXcUsdwVFRXW8sHBQey999547bXXxHZUjobKkkxIxruQH1MYQ0NDxowZM3wVx+XG54DvAb4H+B7ge4DvAb4H+B6YuPcAPfPRs5/ns+G0wKQ4lkzOPfdca/u//vWvjusdffTR1nrvvPOObdnXvvY1a9mLL76o3J7mm+t84xvfMCYqI+YtMyGhtzXr1q0T/srkpiT7Hnd3d4vCyKtWrRLLabq3t1cspzcXFHDa1NSEZDIp3npQo7cb8ie1RCIhilAPDAyIbVtaWsSbDWpUXJbeluQCje3f//43Hn/8cSGPH3/88Z6FoCcydLw9PT1FKYbMjB98HScHhV5H2r61tVW4Db399tvid5XeJm+yySZYtGiRKBL/7UseRjxJb5g1GOYuPPZlrSfPC4zM/Ndvvin2TW+i6Q32u+++KxLMHHHEEVi4cCGmGvx9nBzwdcwNeoabO3euePZzU8LEs+H6BJa/vgC1NaUZpdXbl8T8HZZ5HksmskpJz6BOyApcJBKx3XOPPPKImN5ss82w6667Kren+ZTY5aOPPsLDDz+Mm2++eUI+w7GhN0kgw+yTTz7BihUrhFFHn/39/WIZZSGaN2+ekKHpk34kyMDL9YYlw5EeMpYsWSI+qfAw0dzcjI033lg86FASBPrCktQtN3NfZDjed999ePXVV0VWo0MOOWRCfnFygX5UqJEhPtmPdTLD13HqXkd6GUbJXd566y28+eabwg2IsrORYXf44YeLT9ntB4F/I5j2JCqWoWe+yNthhx1EW7p0qXBhuuuuu8T+KdEMGX5TBf4+Tg74Oo4u1TWaaKVIEvmNi541TT799FPx+6eCnokJ+p2Xt6HfTnpBR9BzsRu0nAw9EkyWLVuGDTbYABMNNvQmCVdddZVQxegtNRlye+21l/ikRopbMQyM+vp64ctMjejr67MZfi+//LL40VZhGnwEKYRf+tKXxMMKwzBMqUIGHgX3P/vss0IFpJdmFPh/7LHHijfBoVDItv5eR94gPg1dczXgVM83yvUkPnP8j1Njkv7VfvG+/xOGJ71tvvrqq7HLLruI5DP0JptfKjEMMxk58cQTRSIVEjOuu+46HHrooVkxem+88YZIwkWcfPLJNo+3Dz74wJqm33E35OW0HRt6zLhBhtMWW2whDL2xoqamRrhemtmJKHiV3nrIbqCqtuWWWwq3UYZhmFKEjDp6e0tZ3MhFc4899hAvpsiAynygGE/ImKPf36222kokE3jqqadE7SjysiCjjxpNMwwzNUkYSSTU799LYmz5MG3aNNx999049dRT8cILL2CnnXbCd77zHeHCTsYfzaOSCuTiuf3224tpGfJ6M/F6FiWxRLXdRIIVvUkCSdfyG4vxoLKyckrGijAMM7mg+GEynAiqs0Qqnszeh6eUO0KE4mW6WkrqnFrRU9R08ul0oUkPbbuc+pPUGKx/yRtw//dOE94VFAdNb7TJrZ5iTcggtLmXMgzDlABm7ggTcoun5gZl3aSsmWTEkdF3+umn25ZPnz4dV1xxhaiDR8+mMuSNZkJeGm6YZRoIMxxqolGaEZoMwzAMM05QghN6a0yUenpyO5p42UZvuq+99lrx8EMu8/fffz8uuugi8UBE7kfkksowzOQnCaOkm6makTea2X70ox95Hhf9Lj/wwAP4+9//rlxOCbNo+dNPP60sO2HilQhQNjiHhoYwEWFFj2EYhmEk6A3wxRdfLBJHUbKTtrY2HHDAAdj/uJ+K5UZQisGTXpeqEq/4jtHz+dpV7s9U9zTJbtvpi6bKJ2XsvPZKUQiYlD5KhEXx1jvvvLNw7Zw5cyZfe4Zhxo3MrPFeah5lgKe4PPK6IFf6Cy+8EGeeeabIwElGHP3OkZr3/PPPi2RZVDT929/+trW9nOHT60WenK1zonpEsKHHMAzDMBlQopUzzjhDxLjRW2N6qGiqDqBroAYJlE6cnh8aGxtx8MEH47Of/azIHkpxfPQQRIlm5s+fL1w7KQbRy42JYZiJRVL8V5qYIyMjL5fQo8suu8xyrb/zzjttbpuk0B144IHYd999cdBBBwlF77zzzhN/my74lF/CrzumWVaMmKi/j2zoMQzDMEwGe3/uevGZDGkoC8xGS383ZtT2oKWmG+2DdegYrEXCCKgzbGoeSl0eWTfl2DzXbSyVb2SD7b9yU2qRZJ++8tMfiVp8ZPT98Y9/xJ/+9CeR1IWMPor5LqWkMwzD5EfCMEQrRfIZF2V2Jxd0gtzUM2PzTMhl/corrxSJtMhVnbYhZS8zAQslEHRDTsAiJ2aZSLChxzAMwzAuRBMhrO5pwfr+RjRXd2NaVar1RSrQE61Cb7RKGH25oiOJoJ5AVGRT0cZcsTSzJlNyAnLpJKPvl7/8pXhzTZnsyOijhyIu1cAwTClAsXednZ1i2sz47oRcwuvDDz+0pilDvWq+Cnk5JX+ZiLChxzAMwzCZ2TRDKcNLVuwiWhCrB5rROtSAhvI+1IUHMLemDUAb+mPl6IlWoy9WgUgylG24iT8N1AYHUV/Wj6pABGE9JsL5BhNlWB+pQ1esGoamNhhN9c6m4ikURGtaflluZM/b5lupt9uCtOr41k+/L95wm7F85PZERdjJ7ZMemtjgY5iJhZz0pNTIZ1xmPWaCynW5QWW+VNtRLTz6XVuzZo2okeqG6SI6e/ZsLFiwABMRNvQYhmEYJgfiRhBtQw2iBfU4assGhNE3q6odZBcmDQ1D8TIMJcIYSpYhqCVQHoiiOjiEkJ7EcCKE3nglhhJlSBg6msr6sKCyDbOTHeiM1aI/UY6BRLnYz1hDCh61o446SmTofO6550RCGorp+8IXviAekBiGYcYr3pji+agkA9U5JWNPNuJkZCNugw02sKbphdWRRx6J2267TSh25MlA3guZ0HxT0aP1J+qLLs0gh1dmwkI3O6WjpQK/411Hj1FDXzG6PnSdJuoPBcPXcbJ9H48+6Q6Y//pZ6p1ZB0+KrZMVPWuZw9dY15OoDERQHoqIz4pgFOV6FHEjIIy7wUS5UO0Gk5TS295JOBBDS6gHDaF+hPSEmEcunQOJsDD6BpLlGEyEkdR0xRiRPU/+rTHVQEksHKm9Z58/skLq462bz8X777+PBx98EO3t7SKpAWW8G+8MdPy7Ojng6zg6z3zmeks/nImamtKspNbXl8QGm63N+fn1pJNOwu9+9zsxffnll4vkLJl0dXWJ+Lz3339f/P3EE0+I5CwmixcvFrHIZCjuuOOOQrmTf9OolMJee+2F1157TRiS1M8mm2yCiQgregzDMMyUIxHWLEPPNOZsiVPShpLSVdKBpKGjP16BvmRFRhYVzbNweiRZhlWRFqyINyOkxVGtR1ClD6MqMIyZwU4ENEOMd8goSxt+YfShAsNGma1vy8BzSdTiNG0z+DS7i6dm1GC2kUDsyaeEW+fRRx8tSjTwyyuGYcaSSy+9FI888ggGBweFoff666+LpCxmeQVS4n76059ixYoVYv3999/fZuSZiVzOP/98UW+UjLndd98d3/3ud7HRRhvhk08+wXXXXYc33nhDrHvBBRdMWCOPYEOPYRiGYUaNXFV8DTEjhK4EtWpAhJkYqNCiwuirShuAzcHeVHxfsgztyRq0J2oQH8V/0g1Nx2qtEW2owdkbN+Lee+/FCy+8INw55Sx2DMOUDpMtRo/YbLPNhKF34oknCi+Dv/3tb6Kp2G+//URWYRVXX3011q9fL1zTyag74YQTstb50pe+hKuuugoTGTb0GIZhmCkHqXgjip5LoXMPO81voXMbChdu9/1pGEJYxPy1JUcydtYEh9Cs92JOoBNzAx3oNirRZtSiC1XCMHMdgvSMZQVwGN5lISII4Rdv9qFOm43Bj5djyTXXYB3q8cCPLxl3d06GYaYGBxxwgIifozp6jz/+ON577z10d3cLN8sZM2aIrMHk4nnEEUc4eh3oui62P/bYY3HHHXcITwUyHKl2Km1/zjnn4JBDDsFEhw09hmEYhplgJKGjO1klGsUGNul9aNH6sDCwDnFDRwdq0GbUoB/lo1K6oUerxFuYj1lGF+ajA//617/EQxXDMKXDZKujJ9PU1IQLL7xQtEI49NBDRZussKHHMAzDTDko8Yql6Cnj53wqdvK25nOLLWbOZQx5FE63F2NP/ZHQAlhv1IsWRhQtWi+a0Yfpeg8iRhBDWhkiCGIYIaHIiU8jhLioq6CNqHsKlc8et5gxVmiIxINiu+v/8R4u+8cnqdWkfv5327keB8QwDMOMFmzoMQzDMMwkYRhlWGk0Y6XWhFpjCPUYQBgxVCGCJvQjaKbTpDIR0FMGYCKEiJYyAIe1IIa1EIaMkC3DpxLDwByjC12oxIBQDhmGKSXo2z7yjS8tSnVckw029BiGYZhJxx7H3GhNyzF4FK4xrSEslDPDj3qXg2InK1nZ/XhIdYoYPTelUZ5WlVeg/fWgUjSZgJFAOWIo02IoRxzlRkwYgvXGAMoTZPqNHEQUAQzrZPyNGICdgSrEA6lHh6ZEPyoRxcfBaSNxfkSqOoRg+69IhdnT/O+XrPIxzFiQgCFaKVKq45pssKHHMAzDMFMEcvMcQAD9WvmIsWgZjAbKkECYjD8yBA2zxVGXHEKZEYcRAzr0aqwL1GFuvAvdWgX69ApoknHHMAzDlAZs6DEMwzATmj2Pzlbv7CqXvXi4UMpssW4jy1wxDSKbqpYt6TkuN/fnNzeKMobPIzOocox+96chiiCiWhA9ejqDpnQeg8kEpiV6MTPeg61iq8W8d0Kzs5RQed/p2u9sCDLMOJAwUq0UKdVxTTbY0GMYhmEYxpO4FsCaYAPW6vUi/q8iGRsxCBmGYZiSgw09hmEYpuTZ55DrxWcyNCIXJYPpaYV6p1K0hPJEip6ebhkxd/6VNoWqJvWjwiveTpmBU1YiVSjVS3/7s+/IfTdZq1P8n1aJHh3Qk4rt9eyEC2/dwnF5DDPWcDIWJp9SrwzDMAzDMAzDMEwJw4oewzAMUzLsd+C11nQiNPIuMhnWslQuOcOkNU+VvVKOwZNb1jYqWU2Sq9LLHVU8v/F4PpU/vyqgTdFzidsbDcx925KxcOwNw5QESWhIjOYPQIFjY0YfNvQYhmGYcWffz14nPpNlknEnTatcEi2jT+n2KP0hu2amG7kfZhpSXqUSlEaUYrmyzIJXcXS/hdIVBqytnwJcN13LQ3ihKkNBs7lYFsMwzLjBhh7DMAzDMAzDTDKSRqqVIqU6rskGG3oMwzDMmLLf/tdmJ1YJ6/YEK4SWQ5IVxTZurpm2gulu6pzcoUfSFnO21/OLa9IXB5VPWQLCrci6PM9jPOZpKdpzl2KM230tu3C6ijdu5aQtDFMsEiXsulmq45pscDIWhmEYhmEYhmGYSQYregzDMMzYJllJq3eGolSCU7HxzKLctnmeCUzsfWcWTFdiuCRHcYrRc1+sGFfqQ0cSIT2OMi2GMvEZRxipzzLExGoJ6KlmaNZ0PBlARAuiF+Xo18IwNN19jE7jNnIcdw5YyqimiNtTSIjbf2VE+fvfL1ndY5hCYEWPYUOPYRiGKTqxWAzBYBCaKpPlFCeIOGoCQ6gJDIvPCj1qM7qiCCJqBBFBCH0oR9LQENCSCGCkhRBD0IggbMQQSBqiXtaAFkavXoE+vRy9erkwApWZRBmGYZgpARt6DMMwTFE56ICrMH9BK4aHy7CqrUVoRapsmqqyALYi4aoYNRlVzJyqBEJmfyLrZrag5JktM48YPeozgARqg4OoFsYdGXYxsWw4GUJfsgLrYvUYRihl3AVCMNI9GYGRfpIq9TJA/Ruo0CKoTQ6jJjmMxuQAZie6xfIoAugNpIy+3kCFUP2SmlkPIVthMwoqom4/5qzl8vUzsjNyqrbZ4eyUuvf6HazsMUw+0EsiaqVIqY5rssGGHsMwDFM0kskkZs7qgB5IorpmCNOSXVjf0TgpzrAGAyEtjqCWsBoZalEjpFjbQK0+hOZgL+qD/SD7dYgMu0QF1sYaxXYxY+SfYMvQzdGBkspEDOjloq1N9xMy4sLoo0YG4PxYJwKxtOqnk+pXjj4yAAPlGNZo7PzAxTAMMxlhQ49hGIYpWjbNpqYeNDdFsGLdNJQF45jZ0okoQmgbrs+/0Lk03y0Gz6mfzGVZMXqKeDxzMqDHMTPUhcZgH0IOReH6kuXoTFSjM14NXTPQrPcJAy+sxzGULMPqaBM6EzUjhp1SiVQdl+L4VSpoxjkj18+OYDU6UJ2eaaAqGUVNcgi1iWE0JAYxO94jFkW1gGX49Wnlwu3TUv1GC3O88m7SBdc1Rc71Hc4aidt7/Ves7jGMXzhGj2FDj2EYhikKlZVDaG7qQVtXHQaGKjBAbxPLE5hR14nqiiH0DFdhKBZGIBhHmZ5AKBBHKJAQiUiCelwkF4kmQ4gkQhiMlwsDarzUpiASmF7WhZZQj1DZ2mK1GKLUKEYAcQTFZxIa6vRBNAX6MDfYjnnBdrEtzSfDrj1ag4HE+B2DBal+gTD6g2Gh+hFBIyGMvlQbwtxoF4JICpuXYv3I4OsOVKA9UM1xfgzDMBMUNvQYhmGYnDhg72uy4u2CwTgWzOtA/3A51g81AOGUcbN2sBERI4S68gHMrm0fqdlmALFkEDFh3AUxFK9ESE+gIhhFfXhAJB+hZV2xanRHq9GfDKcMJkVyEWVtPc1ApR4RiU5EFks9Joy3BAKoCdVAC0aEIdlPxmRGIbnGQB/mh9eL6dZ4PVpj9WI7U02TFcEOowYd8RrRd4PeLxaQspdMy1XW0LwygyrW81yuUi99qoVxPYDOQBU6UUWWaUr1S0SFqycZf3WJIcxM9KBPC+PTshYR4+c6rBxi+pSqq6LWoanuURwiwzC5Y2boLUXSIj4zyrChxzAMwxSIgVkz2mEYGlZT8pWA/Qm+c6gWHcO1CGgJlAViiBkhod7JiVfsyVYMVAYiaCjrR31ZP6aFe4Qx2BWrQm+8CpFkKnGJbCloSKJcj6ImSJksKfHJMIJpV0tS3yJJynUZQBgx1OjD0EPdmK0lRb/kdtkWrxMGKfUzN9yG3kQllkemIa5JGVFcoL7bE3UT907SNAwGwqKtC9WJRCk1iSFsFGvDNpFVaA3UYFmoGVHK5MkwDMNMCPgXm2EYhvHF/vv+SHwmwyPGT6A8gVnN7agIR/FpxyzEQiHH4nIJI4CheCBLQbMhFmkYTJZjIFKOVZEmYbSR0dcY6sf0cCq2jMSeuBEUCVI0zRAlB6hbyuRGKh2pcJT4ZDA5kmmSlCTqfnq0DK3DDajSh9EY6EdTsFfE1H0SmYFyofwlsTLWLIw81+ydmbhl7TTcN7dOU8KwJVrJyoxZpJfztnhEU6nMGD+VangjMBcz4r1YEO1Ac2IZVgQbsTpQL2r22QaeD/KJMI9L0Z9DaCTDMB7Qy7dSzW5JY2NGHzb0GIZhmDwwUFczgOktnUgmdSxfP10YZ8VHQ3+iAv3DlVgJQ7hhknJHrpgBPSHi56jFjYAoVzBghGH4clUig7BCNEqWslF4LTYJrxEuml2JaodMmlMQTRMKX1uwGgsinVgQ78DMeA/WBOuxLlArqvoxDFOacDIWhg09hmEYxpH990upeEQinI47Kzcwu6EdtRWD6BqsxtruRiSNgDC5srNXpv9IKgK65Jp5pmLlajdooog4uW7a+4N79s7MeRlZNymGZUl0FhaE1ovEKmvj9SPKWYHhYea+bTFsKtXK/JQDV6SNKMGLmKXKSqroW5FUVB0TZxdds/o21bSEFsAn5S1Yk6zDPGHwtWNevFMYe2sC9YihMMNYGbeXvj/kGL2dT/+Jtdr0+jK0dkfx8r3nFbRvhmGYyQobegzDMIxjkhXZTZMe/msqBjGrKZVdcsX6FvRFUin8bU44mrtRZxkWtlT6Cjceyehzc6H09ADKWM/ILJgupjV8mpiGlYkmxKQ4tLycizzcPVWuiCp7Uo8r1pBLScjJYcy+DZd5TkKn6jyqBmQAg3oZPtJnYGmyGbPi3ZgZ6xEF2ru1SnTpVejUq4QxnjeKwuq2cen246K2y6kp4494+bds9DGMScLQRStFJC91ZhRhQ49hGIbxRNeSmN7UiYbqfvQOVmBNRzMSyYD9wXzCo4Ei9BhvonoQy8qasVJvxPREL5oSA1iQaMOGiTYMIiSMvi6tCr2osMUaMgzDMGMH/4vGMAwzxVElWTGszJkGaioHhZEX0JNY3daE7gFS8bTs17Kmm6KXeqdIpa92IJSWmrKUl9GgKiLu4bo5sp5qpjRujzfQKmVRpbBZ5ymp8NJ0UNVMdU/uR09ku7tam8jDVih/fss42DRXRUKYRFAX8XprE/UIGEnUJweF0deS7MNsdCMOPaX2oUp8ymqpF9Z4pftJduM0ldlC3WsZZqKwdq1ZCdMf5PJtlnopNVJVO5nRhg09hmEYJgtdTwj1rqGuF2XBBPqHyrG2vQmxeGjc638zpUlC09ERqEaXVp2qy2dE0JAcQGNyEBujVRhk/QgLpY8Mv0EjzMXYGSYHXnjhBT5fTE6woccwDDOFOGCvq8WnERx5y5sMjUyXhWJorO8VGTVJZurtq8KqnlpEomVphcWwJxaxZQdJf0iqi7VYTrxiZeaXZSepknrmPJv6JSk6Zp9eJRAslc9cXxPbZr5PVsb62aRBuBfwVpRSUCZjUW1qnjun5enj1+PZx6/LCps5BjmpjVuCGg/MKgry2ORjcZ6noR/lGEiUY1WgCWWJOOqNQTRgALOMbsxDJ4YQwvvGbEQ1j5g+h3ELRU+373vXk38sPl+6///8HSDDTCDKy3PLbMxZNxk29BiGYaY8Bqoqh9FY14vqqmHE4zo6umvR1VuDRILT5zOFQy6bbVot2lAr3HhrMISNjVZshjV415hbsu5lDFNK1NTUjPcQmAkGG3oMwzBTKZtmaMRw07Qk6uoG0FDfh3A4jqHhMqxZ14S+/sqRYraK7I321PzZGpRVUkFWqGwxeum0+fJG1nKn1I+a82JVGJ2qnEGmGpQ98CxUeUEpQ6cKS+lT9eNlx5iKpYPSVvTawpo/1dF2/KYSK8cWmmqpIlumQFUCQtPQi0p8aMzClliFhViLDzEr++BVCqmsDKdjLe1ZOVN/7HbSj0dWs2UvzY3/PsjKIFM6bLjhhpMo6ybH6I0FbOgxDMNMMULBOOob+lBf1w9dN9DXV4l1rU0YipTlW1CAYXJmSAtjsTEDm2MNFqAdy9DCZ5FhXJg7d24eyVhK8ze9VMc12WBDj2EYZhJx4O5Xic9kWSBD5TBQURlBQ0M/qmuGkEzq6O6uRndXNeLx1D8FqX92M96yKmqYyYqWV1ibCrdab0olTpq2vQRO/6ElM1Qeh/0ltfTIM98k5/q84aS6uXWkqi2ojCN037Utw2Yge56eVtuSPgure+5bnpfu25acVLGt8hAcrnUPqrAULdgQbRhGCK2oh1+srJsZtfWyjiWgqEvoU03Y/fMjyqDJC39klY9hmIkBG3oMwzCTGE0zUFM7gIbGfpSXxxCJBNG6rgG9veSeWZouPczUgoy7csSwAG2i2Ho3qsZ7SAxTknR1deW0PsW+Jko0/pXLK4wNbOgxDMNMcA7cI5VJU65/F9TjqG/sR13DAILBJPr7yrGytQ6DA2F18JMD9qSa6dg6Xcr8aJNqzJnZ8XhKlAFw6qyblnpnpZVUd2TFjEnbUl1322qGvYadpYh5qWmZY81A7jNrI2mbZDqOTD41ZJBnd6joTq5R6KLU2fr2yOhp4RRnlzkeVXyfU40+N5EzXQeQWKE1o1yLYROsxXuYg0H4yC5o1kPU/NXeUynIymtm20f2idjj2But6ef/fL73OBmmQJLJJN577z3cfffdfC6ZnMjLzG9tbcVf//pXXHzxxTjggANQV1cHTdNEu/zyy3Pq65NPPsG3v/1tLFq0SGQTqqqqwmabbSbmLV68GMWC0n3/8Y9/xFFHHSV8nClFbWVlpQhsPeGEE/DEE0/46ue+++7DtttuK7anfs4//3z09vY6rn/GGWdY54baP/7xD899mOvStgzDMLkQrohixpxObLhwrVDx+noq8OnH07F6ZTMGB+jhmeMimFJEw8fGDAyhDFtiJWajQ0QXMcxUJRqNCuOOnrevvPJK3HbbbWhubs4rGUupNqZEFb0ZM2YUZee33347vvnNbyIWi9nmf/TRR6L96le/wq233lqwwdPT0yMMvGeeeSZr2dKlS0X7wx/+gOOPPx6/+c1vUFZGCQmyueKKK3DZZZdZf69atQo//vGP8dRTT+G5554TRqoXl156KQ4++OCCjodhmKnLQbtdqawjV103hPrmAVRURRGNBtC2rg69XZUiFi+1SobU4xWjlF5PzqppKUNSAJhN3VOod8qYKZ/YxBRFDJ+ZTdFQxozJ404raMm0AESf0vGrMowqMWMUVfFmDgqbJVSq1DlbrTt/J8j2bKRlK2Mj8YjSPL/2kuJYbMenUPRUw1Ydq+ahAtIxGNDxvjYHs/UuzNY60aT149PkNAygwn3YijhS5bil823eEzY1WJEZ1ofozTBFZdmyZfjvf/+L119/HUNDQ0IE2XTTTXHKKacIQ49EFoYZM9dNUsTmzJmD//znPzlt9/vf/x5f+cpXxHR9fb1Qxvbdd1+EQiG89tpruO6667B8+XJ8+ctfxvTp03HIIYfkPcYTTzzRMvI22GADXHDBBdhqq62EgUlfJNpXe3u7MPaamppwyy23ZPXx/vvv44c//KFQ8kwlc8WKFcJwe+ONN8TblmuvvdZzLK+++qp4O3PEEUfkfTwMwzCEHkiirmkAdU2DCJUlMNhfhtXLGzHQx8odMzEhY29VsgkdqMYGgfVYpK9Cq1En5iVsVeAZZvK5Z9Lz4T//+U/xXLz33ntjp512EuIKeXkRbh5kyj6hl2yNSo7RK2FDj4ybXXbZRTQyjMiIIiPNL4ODg8I1k6A3FS+88AK22GILaznd2J///Oex6667CtfOr3/96/jwww8dlTY3yJB7/PHHLaP0zTfftBWcpHF/4QtfwDbbbIPu7m788pe/FO6nLS32NM/k9klfwuuvv16okASNb/fdd8fChQvx4IMPehp69CaGDEo6f4cffrj1xWUYZupCb2zb2trE7w/9I06f8XhceAhUV1eLRtPfOfsu6AED1Y2GMPDCFXHUNAyKPvq6KtHdXoXocEgoEe6/LKpiadnzRuLWbEF6qVlwiNFTlcJT7dZUTgKqvuVZ2bKMlsiWy2zbmPFvcgyepPJYIV1yN4qMnpZy5hFvZngoZ0pBSBXrptqfh6JnKnnK8D5Z5Qtkz1PF4ylVR5V6pzonecTo2cZrxWCm/o6gDB8kZmN6oAdzAh1oDPRjVaIJnah2MfgM1AcGEDOCGDTKs+8dWcVVqa/SwdrUPRf2OvIG8fmfRy7wd6AMo7pzDQP3338/XnrpJRxzzDHYb7/9oOulaaAxU8DQI2WrEMjwWr9+vZj+zne+YzPyZKOIDCcy+EzXylNPPTXnfZERaUL7ko08k3nz5uHMM8/ETTfdJIy5l19+GYcddphtndWrV4vPTIN29uzZIqbw3Xff9RzLhRdeKNpbb72Fhx56CMcee2zOx8MwzOT5h53+UaeXRJFIRMyjlz+1tbUIBoMYGBjA8PCwtf6chSPbJpNAIhZAZ2sNetsrkbCyjfh3yfSbXt6+bXpTyfizuWu6GQo29zqVb1/G+vJY88FniQfPU6FK9OGxrueoVcda5Gc62eg0p23Gr5dbrOHsKqpylXUy7jSfBqN5H8nGmJ7U0JaoR7dehfmhNmwYXI8FRht6kpXoSlRDNxqtMVdoESwItqFGT31nehKVWB1rxIBRLhV1VyT3kXxcDckN2exXl41jF/Y+PGXwFRPVd8ec99zDbFhOJih/w4svvojTTz9diCjFImFoopUipTquyca4ZN0k90UTt3g1edmf//znvAw9CmY1IUXPiY022siaNh+6ZKZNmyY+n332WWy55ZbW/HXr1ol4Qj9xi6RMUkwfJbOhWL+jjz6a39gwzBSEvBoeeOAB/O9//8Nuu+0mXHQoqRW9iJLf4h602w8RCCQRCCZFHFkyoSGZDFgxZZaRxf9eMpOYqBHCkugslGkxoexR27CsFVWhIVQGk4ghgGl6D4aNED6MzkIQCcwOdmGL8lXoTlSiNdKA/iS7MzOlCT0T/+1vfxMCQzGNvMnIPvvsI57Dc+Hpp58W25ncc889QtzxA2U5neiJEcfF0Ovs7MwyoFSQyxJlxqSHolxjAE022WQTa/rTTz91XI9cRE3IFTMTSuZy9dVXi/g+cq8iZY+SsZDBRm/ezXhDN+hYLrroIpx77rkikxKplBQ/yDDM1GHlypXCRZzqIVHmXnJ/z/QI+M3tT4vPhmkjCSF6OiqRTOg2lctKG6+SUBwYUWg8HDytRC/Z6p1ZwiGzG0OlnCjS3ZtjUKl3SrVIHpdq2NIYk0EfZQicFDyVoqXcn3obS/FSrOp5XKpzotq1P8/bjBUU2yqO1eYpq+pGkUTFS9FzS+ri6RZqZBt8rbEG0agUw0YVCZRr61GnxbAq3oTWeL11j3ZFqoVBOCvYiU0rV2M4GURnrEa0iFEmqXwO58S8HyWVT4v7rVNRHKxTofg6yQris39jdW8iQMID5XRYs2aN+Js8NygXxQcffCBCgQrJReFEooTr6CXG4Iuk67rNDpiKjIuhJ2enpIyYbl8Kil8h6KGI1LNcM36SKkiumZQ45Wc/+xm++MUvZmXHJIONLHxijz32EIlaMtlxxx1FXCH18f3vf9+2jBQ+irvzAxmEN954o3AFJRdYig8MBDjAnGGmCvQPO7mIk4JHL40oY28mtS2p3z2TYFkS8XgAfZ3u2QcZZqoQMULoSFShdbgcSWFFZlrIGjoTNehMVKNGG0ZTsA/Ty7oxK9yF/kQ5OiPV6I5VI8kJXpgxgIw7yjRP8dj0co8MkEQiIZKunHTSScLQG428DUlDF60USeYRPkAKG4krblDyRMqiT+y///4ixMoJKq02a9Ysx+WUbHKiMy6GHsW0mdBDzg477KBc7/nnnxdxLCZkrOVq6IXDYVH77sgjjxSqHSVdIVWOjDMz6yYlWCFDkjJy3nXXXY59/fSnPxUpbn/xi19gyZIl4stKMYRUdoHiavxAWTvJUCQ3TnL5pODb0047LadjYhhm4kIvk6i58dmdUnHQ9O9zdcMwZmxIL8QUGUOUIohPd06vhwpL0ZDWUyQMsSlnqpgiU/3zqfx5xeh5KWyWMpbHs40ybk8lzznsW5WMRqVeZY7Vto2XIuv4h/MYVOt7HquKAgqm206jSz8q5VOlYtqGJdeSyBqDhn6jAv3RCqxMNqM+OCCMvrkV7ZhT0Y7+eEW6lWN4OCyyftqUPCP1jaL/a+b9KiUE8pu0pSBU31Vpv/sccr01/czjF47+eJicIJGCRAJyzScvMMokz+QHPad78dvf/taaPs3j+Zo8+BYsWDCpL8e4GHqHHnqokKwpsxzFrNGFaGxstK1DRlimStbX15fX/vbcc08RC3PzzTfj5z//eZabJbmIkrH2ta99TRhvbnz1q18VrRCoZASVdCDDlfZLb3PofDAMwxCUVZNUvdrpVDYhicHeMgz1hfnkMEwBkBHXFa8RLWTE0RDqR60+iGnhbsyqSCJZDQzGyzEQLUcsEURVaBg1ZYNCEfloPb3Z52BYJjdIwSMjj54zyStMlRBwNJlqrpvkLUMCCkHn/JhjjsFUZ1yuPsWlmMYWuU1SiQIKRCVDjrLMkZJ34IEHioyZVFfPxHTjzBVSBSmZCzUyLjPp7+/H7373O/z973/HWEBlIn7wgx+IaVIZTbdRhmGmLp/d8XIctscPcPKx/4f527ShcXY/hnrDWPFeE9YsbkQ8EqDCQ+pGkozZfELKidV0zbGJfyXSzZovbys1s3YBqXhms+Yp9mfVOrD1oVnNvk26BTyaYoxekCojlBk6fekmiqqLwuojLadz6nBuIB2L/dy6t2S62eZbx+zv/MjHp2zyOH0ep/L6ehy/ahvVcuV6yguYPW7r+klN7ieGINbH6vHp4Ey807sAH/bOwZrBZsSTATRW9GFObTvCwSh6hqtRFoyjtmJw5Lr53F/xmuG77fvZ60Rjxp+Ojg5h5JFn2be+9a0xN/KmIk8++aSVJf+4444TuTGmOuMmI1GcGiVHeeyxx0SNPFUB8c0331wkPbn11lvF3/l8Sci6P+GEE0QdPOJLX/qScJukvsk/murqkesmFamkzDpvv/22UBlHG8r4Q+Uj6BxcddVVQtXMp06gbMzKbq5M6WBeG74+E5vRuo7U3+LFizFjYTcq66JIxjX0tFahd30F4onUT7Rn6IZXcgzVuh7JQVzX83DTK/o8p+WK9fycKh+2jOO2441Wov2M5i3htD+36+j3K5P6bmkYNsKIRMLoiNQJqzeQTAolj8orlIciaKzsQ/9QKr7fVlFE5bpabPLoe6L8ezNZ/30k0YI8yCjujow8Cu8pxjHm2keyhMsYKMqOFsxvfvMba5rDosbZ0KM3HKTiUWDlLbfcIgwu8wYm90kyuihZiVlYnWhoaMh5P2QkmkYeFUIn/2gZUhMfeeQRcUOQX+9PfvITUajyc5/7HEYTctUk11Q6TkrOcOeddxbkEkpJbSbbD+Vkga4LqcbEaARbMxPzOpJ3wffOuw01jcMoK0+gaVol+tsbMdhThgB0NDRl1KhLI9cZs8Ymr5eOI3LK8mjGxdnj48ynVWkbaz1p24w+nPpW9mM7iOx+ihbDpvBTsWV3BNBYE0opO1njkfenOP70tFy20DeqcSvObV6Wi8/YOlvSTcVxyU8E1jH6jPWzFYuXi7Uns+vRWYXepXnmcltR93QcmqbaH13H6pTHj+e/fC5ZR23zkorxkFIWno7Z1d2I6QHEk0HlGHUpZk7Ldhwac5+rE0/+mTX9y1tLNz38ZP33kepFk5hAL/Up8Ypb4sFcoARejBq6j/7yl7+IaUrCKJdUcIKewSnrKeXpIGN84403xgEHHCCex92SuEwkxjUwjG5+Utiokdsm1ZerqKjAzJkzrVpS77zzTmqgwWBeKVLJgDLVQCpt4MQ111xjBXD++te/HnVDjzjllFPEfultPpVuoB8EStaSD5TBz29CGGZsMQ1wukaT6R+yqUah15H+0Sd3dPoHn972UiKoUHUfOtrD6FlfieGuYPpJc1gqNZCHoZdOfuJUyNxMjuJl6KnWcy2f4JR4xcXw9Ezk4lWsW2GF+DH0iNbeqKuhN1JKQj6+Ihl6qv2p1nPaPl9Dz+HcmsdlyIZeMEdDT2HIydN63H2eOS0bSZrK0DOLv6f/bu2WrmOBhp6cWMUaT9JAG3QEmwZRrS3F8t4ZiEUk75t0YhY9oSjDUCLBNfSbVapMxn8f6bmVEg1S+Sw/yUNyIddzlIQuWilijivTeCUhiFquUHiWmZGT6m77OVfPSjX5yNWW2ssvvyw8+ygB4znnnIOJTslkACFDLNM1k6zzt956S0xTyQMyAnOFLHViiy22cL1xKIUqZUIiY5NcSccCKqtACuPJJ58sfIop9a6sYOYC3dCT5UdyMmJeH75GU/c6vvLKK6J2JiWeohdX2267Le7/xbuIDad/hlV9qow6Rd+2eemHVZsxpujS1rWl+EiGV3ravj+VOidvkz0et/G61WrLnq8w6lTGoebP4DHD0mz9qWq9qZbL6/l9hlIYWSqV08mgUx2rXzwzlaqOtYB9qG69pGK5LVmmptjWnFZcFy0jvNAVxfEpulZmDk196FjSNQsb1q3Dhk1rsaJjGgaiqecRcxNZ0DSzc+pxaW4+tp9p1GoGmpp6EQzFxXQqhNVALBpEW1sdDI+b8ID9r3VcZvcGUOxbziqqOW/j9GJpZD/SH+l1zQyhk+nfR3pufeCBB7Bo0SKRXbnYxzQZzpEqb4cMPReTB95oum1uuOGGIlHLbrvtZu2fQqnIWPzTn/4kXsZSLhE632effTYmMiVj6Kl46KGHEIlExDTVm8sHeqCiPlRJWDKhTJ/mNmMFxQ+SqkcF1Clm76yzzhqzfTMMMzZQrPC//vUvbL311rasv/fcaHclZximNCGXzU87ZmFeQyvmN6/D6q4W9AxVj/p+NS2JWbM7UFkZwfBwWTrnkiZaXf0AKiojWLO6GbFYST/OTRlIKCCFioyIUjDKEoYuWilijmvlypU2j7R81DxK7PjMM8+IaapJSGUTnDj66KNx+umnZ12fnXbaSdTfo8SMdP3IJjj33HNFDpFcS7uVEiX7y0DG2ZVXXimmSckjP9p8INn83XffFa27u1sUp1RByzs7O61txgpyUaU3F1SPj2qtmIlnGIaZPFB5F/IWMN8yHrTzFeLT8THAlI5ktcztoUERW2bDb/aIPJ4HxjrOX+kC6jUvsw9pPfG3T1XCy43RTW0r+Dyp4ghz3VY+PJ8Kk9c2yjp6in3bznf2LId9m51LbpGyuieps36Q96cag82VOGBK35rtwXRZ9wzMqWnD3MY2BHvi6Owlt0gyvKT9pP+Q7yfZ5dp37T3dwOw57aiojGL1yiYMDthDO8rCMcye04H5C9Zhzars5X7Q5LMnS6wK92rLlTaZzNqGFEYT67ile9V2ntN/UHZQWrWlOYy29og4h08/8V1MZDbaaCPLeKEwpPEmCU20UsQcFxl5hYYeUb1seqFKkBFXiCvzYYcdJlRFyo4/ODgoQsAuvvhiTFTGzdBrb29HVVWV0h2TjDzyr/3444/F32QIOVnTFGxp+tguXbo0q/Dh4YcfLow46vO8884TFyzTiieJlrIiyRd5LDn22GNFIXdyU6X6egzDTB7IlYcSQtF33HyJpEfj9pg28Yf8pKg5z/OLUzyW0t1RZRwWx1gxn/9U29oe2v32rXLT9JiXucwqRWDNt/npee8vhzEWgi2mTivueJRuoyjAYpJnedjLyoV+jdHMbUwfTh87tJ0vhRuunFDGMnCCRsaDqYaVfS2IJoOYWdeFUCCBtb2N0JOK/Ujfb1VsrSbF9Y3sd2Sa3DVJsVu9rBlDg2G7UUZeSENBrPikBXM2aMf0mV1YtrhQ1UExRtvLJmumu9FqXjiF4Zg5LdxQ4+l+DGDfg7KfgZ7+58Qx/ihpID2Hkps+eXGQOkW5F8y4M8o1Qe6CTHExc2zQOSZVrlDOOussXHLJJSKGlGyMKWfoUZ070wgj5Jg2yp6ZWRdOpcaRxEonkhKSUIYb8pEly/m1117DbbfdJhKUEEcddZQw0PLFNO7Wr18vMnwuWbJEuE5tttlmIjnCG2+8IQqpv//++2J9KruQr3qYL/RDShlG6VjJAGYYZvJARh791pCbNsMwkwENrQONiCWDmF3TjlAgjtVtzZ6xcrkQCCbQ0NSP7o5qYeQ5kUxqCASSGOjP3d2NGR0o1IiehUlgMBsJCiRG0DPoWBp6E8F1s1DIbjCf4UmoySdDfybTpk1Dc3OzKHhv1uWbUoYeZaW89957lcuoVAE1GSfDiVwpf/GLX4imMn4o2w0ZYYXEzNGFeuKJJ4S/LX3JyEilpoKSIzz88MMF1bPLlyOPPBI77rijuGEZhpkcUF3OV199VbiSfOGAn2a/0JYzOOjurpuWO5isAloLFS6eKnfNzOmMfbu6h44Debk7urhzyn+Louo+9q1SmApSw3LBp5uqX/XVyV1Tdaw5j9FhW5USmfNtpnD7NPvO2yXWPGZ5nvK5U9pB2p3TdDlrj9Yh1h3E/PpWLJjRiuUd05GwpWQ10FzfjfqafiQTOrq6atDTWzWSccbIztRpXqOmGb1icVdrtVL5MymviiBUlkBfZ4XrevkjjdEqOZLtaWBLxpM+FtV6qemR3zcx2zBSx2+oXUD3k5PJpK/RU/9yzqI+3pCil+ldRtCzMT/jFR85CYuX22YuTJaSZePmurnnnnvihhtuEFXsSREkxY3i1ahuBdWx++IXvygMn2JABhyluyXjlL5o9PBF8Xj0o0VW+3bbbSdi5EjuDYVSdXnGgyuuuAKHHnrouO2fYZjiQR4Kv/vd77Dlllti5513BvAPPr0MM8noi1bik85Z2KB+LTZsWYPl7TMQi488WgX0JMpCCfRFyjBzZqdwx2xvq8XAQDkMUWZCs6l41fXDqKodRmVNBO1ra4WB6EZN/RBi0QCGB8b+BTWTuxs/hSyNJQnoopUixRgXJUz5/e9/L6ZbWlpwyCGHFGFkEDYJlVogZs2ahSln6JFrZqZ7Zq5QKYPzzz9ftEIws+x4QV+ur33ta6KNJbmcK7pBJ8sbBIaZ6lCKZnLZ+dsf2vCX+65GIB2X5yhpyOqeieqNuJMKaK3nEpcn4aXeqeJxRvZbIsqfmxKlikGUjskziYfPQ8xMDpK979z6U8blydv7VflUfTutluMYPSkg3lJV4kAu+2HTYdMxegX9qynvz1YjQaW0Z29O2S8Hk+X4uHM2NmhYlzL2OmZgKJZypewarEFTfR+6+quxvrse0xq6MWt2KvEb/XOfiOuIxwNid+GKmJg31F+G9lW16GmvzIrLy9i7MPR6OyrT8YXFf36w/U6kn0/kWEZzn/brln0DaFKpCVkZFDF6iaQVo2ffKNuzwVxn//1+pBzjU0+WrtJHXmylXNNwohamJ/dK4qSTTipa1vw77rjDeh7fe++9MZEp2aybDMMwExUql/LSSy+JGpmXv/T0eA+HYZhRorG8FzVlg+gfrsCKnhbMqunABs1r8UnbLETjIURiZRgYDmN6Uxc+WTkLK1unoVyLoKwsjpAeF/F1pOTpMNDVVo3B7jJPFc+ksiaKQNBAZGj8PJEY/1BmyY8++kjEbFMd5bEgaWiilSLFGFcutfOIZcuWoaurS3jyOUHlFcys/5RI58wzz8REhg09hmGYIjI0NIT7779fJHz6zGc+Az36r+J0rIjbsxaNQmydW7ZMsyi7WE9OSW/Ok8eG7I60zGXScptaoFK3VFW9VWP0mYnRa3lemUGRx3g8xBi/GUaVCqJ56zjsTrlNjsfqmGnTRW21baM6Ft1tsKYym1Jns3aRj3eMat82BT37JgwG4qgPD4hGxBIB6LqB8nBUGHmiW91AmIqdB1IPt5FEGJHhsBWXJ7pOK16akbRURFK6Up+K0gUAooM6IoNBzFjQjb6aYXSsqkE85mFAaAZC4QTKKuIoK4+LT4qLiwyG0N9Vjtiw/bGQxp4v9oyd2XefyLYpFD2K0UumZstxyebaHjGBsuq5/75ppU9a/uRT30MpsO++++LFF1/E66+/nnbnZwqBDDYyyggKkdh+++19GXr77ruvSIhDWfkptItCuEi9o4Lp5IlDzVTzbrzxRhFSNpFhQ49hGKaI/OUvfxHGHql5pVAwl2GY0aNjuBbTK7rQNliPwVgYteFBNFX0IZZIPV5Vlg2jsixquXkWk3g0iJXvN6G2eQiNs/sxb8s2kZQlFgkgEQ0gHtOhBw3LoBMtHIeWNiRpeWw4ACOpoX76ABpn9qNrXRU611aPfYHMKcCcOXOwxRZb4N///rcozj0W/z4kSzhGj8ZWCFTCgsIj/Kp5MmRwU3OisrISN910E84++2xMdNjQYxiGKRKUWIqy+q5fWYsTD7tVzNMjsdRCvcB/bL0KofvFjLORlSqz6LH85tythpn8pl7OHGjFNSneyksqoKmW2N74W0Wm5bFmZzy0PxuozolqkSJjqUdcn2oInvhUBpVKpDntoGia823CoEoFMwUdVaybagw5YMXRFRgKporHU2Y5VW2b0Y9cD1G5k8yN3FAVZleofJrUd0wLoitag4byfqwdakRPvBqre1tS6+kGGmt6xfRwtAxbLFiOVR0t6O2pTC/PHq7t4d+qpzlyU+ixRJZC1tcaRn97CA0zB1HVGEV1A7mDjhxLIqYhOhTEcG8IvUPlYppaMi5XNDfE9g2zBkSsYOvHdSnDtFgytnxc5m4p62b6XAv1MkPRM4/RrvKbMYHSevJvgmK4++9zTdYYnnx6fFS+Aw88ED/72c/wwQcfCKOPKbx2HrnB0otVP+ywww6iuDoZeZQBde3ataKsWTweF2UZFi1ahP333x9f/vKXhdI3GWBDj2EYpghQnSRy2aSCuB+/0cfnlGGmCG2ROjSF+1BXNoCeaLVtWfdgtTCYGir7xd/x5OioK0ZCR+eqanSuSv1NbqKBUBLJhGY36Bw70NC1pgrDA0HM2KQHMxZ2Y92S+qKrkLmg60mEK2PSGKUXAoaO6HCwqLULx4KFCxeKutGk6o2FoZc0dNFKkULH9cILL+S8TU1NjTAK/RqGkwE29BiGYYoAlW7p6+vDt771LfzjvuzaoDnh9u9fsf7NtiUvNGzKnow9y6FC0lFl25PVO02xWlpZMxQpK1UqX2o6NT9p+1dLIbu4ZEt0DNtSqEl+yes5OOmSYVIWWSQlQ6WmqbJ8umbilC9bCSR49ozRy55l/0N3/j6o1EvPY1adR8Vi27nVgUEjjP5YOVoqetATq7apc33RKlSUpdzLVnc2oz9SaSnnklBnxbra4tFMpV2lciVSyp5AivWzTmRcQyJi5ixN+I7vHeosw9oP6jBzs17MXNiFdUvq/BmKHtj2Yg49XUdPiydScYiSIVdRE8H0DXoQLFOlI06RTALD/WUY6CvHYF9YGH4jv1HusX4H7J1W+ST+/ez3MdrQtSRV76677sKKFSswb968Ud1fQlz90nTDLdVxTTbY0GMYhimQTz75BM8++yyOO+44UcuHYZipRdtwHTaoaUVFIILhxEhNu4aKXkyv6ca6ngZRamEiMNxbhjXv12Hm5j1YsH0HhvtCiAy4Py5SXOBQT0jE/BVUp0MzRKxgw8wBDPWVYc2SGqFKikX0kbY59QBQXh0V9QabZvahZXaviDkkg2+gL4zB/nIkE2OT2TJXKONjU1OTUPWoZjTDjCZs6DEMwxTI8uXLxZva6y5+Dtcaz0MflmrmFfIy3G8Mnsdq+WSOtLIWSsKBUi1TZNOz9aNSmFRCnLleQK1oJdPzdWmjEXXPIRbIXOoV7JVrvF6xXkSrVCdZ0ZIPy4zRU4iXCiFWjSImrlQwlUxDpcQq1qfhkxekuC9U51G1D3l7VU08WxxZds04axNbaFtqm+54FSKJIOZUt+HTnplIGJTkxEBVeFhk4mzvr8uOH7Vdj2z1zhykPC4rrk++6FJWTi0ez6516aLkyXGCMtEeHater0NlUxSVjTFU1pE86HzThMoToq/edeVo/5SKgvu5wVJ19Gj8WiyBYFkC0xb2IVwdR+fKSnSvpVhGkvxUsbgaon0V6F1bIa6HMPrqIqisi6K2cUh8dyiTqGn4iRIUGTGJmefmgL2uztrNv/9zMYoNxZRRHBhldzzyyCOF0TdaTGbXTcYfbOgxDMMUyEYbbSTcDCmeZHhg5G0+wzBTBQ3LBqZjo+q12LJxmVD1BqNhYRyGAglUh4eE2+ZEIhHT0beuXDSvF08UE1gzbRjNGw4gHtHRvdrfsQbDCdTNGkR4WhfCVQnEhnWsfrcekf6Q75dk5NY91BcWrWMNxSYmUFmbUvvqmgfQOCMdH0nF6SMBxKLUguKTlL94TH4UNlDXOID6xgEkkxp+8YtfCC+NBQsWiEbTeqGJtQCR3v/RRx/F008/LTxBGGa0YEOPYRimAFJvgQ1stLmGivIIIp0O7kI2eSZ3OcXwWz/Pb9+2IKb0232VdmKL68qWWJTbKMaozjCYPc9JaTPDa2xlzaCI2zNVEFnRkMYv5tKnrHKa04rnt1FRvszjV4UfOWXdNMcoq5yqf8FdVMdcjmW8YviUsYVO61LGTbpmqmyiHjF61jV3CDdN3ykjN558vVT3rQ4MGOX4sH8O6vQhVAaprEIE5YFUaYUkfVO0zHg8ad9m3J6csdb8gsjZYv3KtzHJq2Ckw+xjVWX5lFF8j1SZMY040LuyDIFAAg1zB6HrCfSsKUciqvhSpbehZDEztuhFZX01epcH0LOqHAOdZTASlI0zMXKsqnp88nWR+05S8hkN/cPl6F9PBqqBsqoEQuVxoTqGyhLCuCyvGkIwlICR7EXbqlr0dVaK79a0OT2oax5EXze5fup45cVPURb+CGXlz4ruE3ENi7bcVBh9dXV1Qp0LBoOimdPyPCq4PX369KwC6eFwGFtvvTWWLFmC0SRRwrFwsrMIM3qwoccwDFMA+nDqnyuKTQmFYqKcgt8C5nJR59Eoeq7ep7k/aaY1DpV14FZnwc/+FP53ri6gTgZx2pVOkUpdS8fwiLUC2UaUuY3t4V5lCChcRe0Hg1FD6ZqpchvM9uyzm9pKl8Tsbb18G5WG91iQg6GXys3vkDDF5zwZ9TaKtw2qWzQ9EUUZ2mMhIFYLPU63eDLVB/1MmPehmaxI6bqZXYZENu5M48+QVCVNT2YbZrJBaLpzql42OfluZvZnO1h5lt0Y6/4kBC2ZRM2cCOpmR9C9PCxaVuYdzcD0rfvF8bZ9WImOZboYXmq1DCtcNoithE/qcY3sZuRYo306on1lWUatHkhi2oa9mD6/R5SeoJqDZOS1raxBT1uVrW9alzw2wlUxvPbyUrz7zmIxz4+4RwYfZdqcP3++aFtttZWo00aJWF555RWR2p/WYZjRgO8shmGYIpCI6wi4ZIhjGGbqYRaF9lK+Jw1UpuHTcmHc1S2Ion5+BJVNcbR9UIHY4Mjbk/r5wwhXJ7D2zWrUVI9PrBYpdmRwRoaCIplMTc2wmN/bUaFcl9w8qdlIG+Z/e/ICJBIJYbSZnwMDA/jJT34iarOVlZXh/fffxzPPPCNUvr322gsbbLCBWJdquZEhOCrHyDF6Ux429BiGYfLgwN2vEp+BdEH05LCGUIXhT5kzi4PLr4P9Puuo+ldIOpr0xtuWst3sxrd6Jy32mbREva2sjCjmebkaKlzIlAW8LX+gkZlWAhcqzEx/J6gZI7qBVX5BkfRC3p9qrEVW+Whs1v6k47LEHXlllQtsQcl/PBLmJPNw9TRc1vWwfXy5mmo+rpGLO6dNnVMoqLbuVUXUFWqpKgGRqpSGuiyGwnVTGqSl/MnjUrlf5uMhkJRuPnN7WzImM+WlfAIUWYSEagl0f1yGwfUBtCwaxqwd+zHYFkSkJ4DyhgQqW+LoXhpGtFsHKknKS5VXkL0cVGMYcZVVK/+ZCmNqLNnunrQ/Uueq6qJo/bgWWtJAMJgQGT6NuOrmGXGvtX/hUh9kvKnYbLPNMDg4iHPOOUf83dPTg6eeekpkaaasm8SqVatGzdBjGE55wzAMUwQSMQ2B0BR5a88wDOODaG8Aa16uRM+yMgQrkmjcJIJQVRIdH5aje+k4Ja7SDNROH8LMzXoQHQqgvzMsZg/2lEEPGKiqT9U9LAbbbrstPv74Y1FjlaC4vqOPPhpXXnklDj74YFRVVQlVb7RIGHpJN2b0YUWPYRjGJ185+y60tw2Ll8/BaGKkai+FwUS0lOsmyRWFZvDw+VbefPttU8YMxZto21t5M8YnD6PUYzyuaqYtGYt5fPI8xT48lo/EqEnHaiXeGFmPoqRSQ9BGFL24lN8k4FICQsJcTGn9i42lTsqxhYrnP10hwNhOmXkshmIj1fl0UuUKuYXdVDwHXJc7jSWdjMUmAqliFN0StDglv1FsMvK9lO43hTrnmmxIXi4pY0a6T6+kRda1tN0Imofip9SD0xvIgamKE2RT7xIKqdLsW5afTXnSGFH3Pi0TLfX7mB6hGY9H6yWS2feNKibQ6lsVlwdUNEZRP3d4ZPdG2mmW/qcBoYpkqhSEBvS0lqNzZVV6vwai/QEM9wXRPKcX0QHK0BlUK4O2Y019HLTrFdasf750qTVNCVceeOABvP3229h9992t+dXV1TjssMPwuc99zl5So8hQfCglAipFbPGvzKjB5jTDMEwRiPQGU0V8axXZ7hiGYZi0VTZ6D/iUybOiPi6UuWRcT9mxaSOPGOoKiTp/K99qQPunVIzd/hjc+kmtcOGes0UXmub2idp8lHQlX2pqarDxxhvjzTffVC4fTSOPYQhW9BiGYXyix5LQo0nxplhLx+aZRPoDwn2zojGO4b5Q8c+p9eI8OzbFFteizKCYLVWpVD4VOXnXuKyrisezp9JPK41OQ1Ftk528UFomxeilY25E/kOaJOGV1Asr5Cb7PMqK4MgxOI9rNFDHHkrLFTGKI4rmyDwrBlGRsTS1IP3hdSyqmEiPeDulUud63bK3talhGaua4pA1T9Wp6pwoSiXYsjuqnu01vzF62aq5UlW3KYMKtchN2fcyEPwaEKSkmaS9E2woAw1lRUsRt5ZQBbo6KH5a+mLQvoVB5hH/l1RcK2kv/a1lItsnbbn+Q/eC66R12ZVBDfGhgKjj1zR/ANWNEdTPTBVfjw4GMdRbhs7VlTDM1L7Sscq/bwftnFL3/vnKpZb75kMPPYTh4WHHWL7RopRdJEt1XJMNNvQYhmGKgoahriAqGmLoWp6dtY1hGIYZbTR0fFKBWdv2o3paFP3rww6rGQhXx1M19ioSKKtIIB4NoH1ZlVAC2z6pEcYpxRVW1EZRURND3fRBxGM6elrTpRd8summm4o4vBUrVmDhwoXFOUyG8QkbegzDMC7sv8814pNe2M6oCkCPxjNqjY+8yR3sLkNLy4B4OIgPOxROd6qj5yUNKd5k+8VzPypFUMtfslIXcpeWmwWjbYqeoiNl0XPF/jzGI9Q7ocimLpceN1KKTabSY7ifb2U9OoxNkXVVvJ4Zj6fMJqmoI6iskydWcNmxV0G6HFW8gtHc6+gp9+ciiNlEBUW8nk34VMWJWhJq9nr2TJuKeDzFNvasm2Z2XrkbReeKjLa+lTxZxZOTgpgZgZW192T1Tp11M9WHw0W3qYTpsVgKu3Osn5+UphTDF+kKoH99CI0LqCh6EvGIjniU3Dg1lNfFUVEfE5/kak9dx4Z1xIYCqG6KoLwmhtYPaxAbTj0ek8LXN1SBvtYK6MEeVNZG0LO2wt2rIuNcUMH0UCiElStXjrmhlzQ00UqRUh3XZIMNPYZhmCIx2BlCIqpjzrY96Fxeid619DaZ/zFjGIYZSzo/qcC0LQZQNzdiy4ZMCYyGe4PoWlGBoZ4QogNk7aV+o0OVSUzfrA+zt+7B+iXVGOyS1UADZZVxDHXnnik0EAiI8gnLly8vyrExTC6woccwDONCIJIYeUkbBrRoOl2j9WZZeoiI61j5v1o0LRhC80aDqG6JCoOPHixGxeBzqGHlhiqeT63A+evTq26gpUbYFA1znrSiX5XP8FcTUBnLRyFBFLIjYvSy48uUauE4qHdKTDFFVp2SikydSecYPUdFz3u3tj9sYopHjN5oQuMQ95dq34rrr7ovnbJuWvetfG59x+hlLHMQoJSilG2btFpk++6k58nHIita2Yc6oozFVYGbqhtFUvdsaqGLyqesf+ekcmVk9KRtyQIzfMT6eSmW6X0mBjWsfS3lYqkFgUA4CT0ExAYCQtmzzpnoL7VNbEDD6jdrMG3hAGZs3oeulTF0r6SYPA0V9VGEwkmsbw1Dk45rpK6ffHip5Z/d8XJr1pcu3AIffPABxpoEdNFKkVId12SDDT2GYZgiYiR0tH9ajf72MJo3HMCsrXpFopaOZVUY7hmFJC0MwzCM829yMpVkBcPebzeMhIbWD6tRP2cYDfOGUN2cellXO3NYqH+R/vwem4PBIJKqZDcMM8qwoccwDKPggL2uFp8BUvDMF81aKPVW24d6Mdwbwqo360Q8SP2cIczYvBfrPqgT8/2qYZ5Y2fsyYl6kZWJ5IS9OVbFANiVuZNIchz27o4tSZ6sjlrHMIStnPlkwM/dtqUAuSp5KqVIKRx73gnkulKFuistmO37FNrYQJjPjnxwOaj5LFlK3TkJ13eyxZ4pxexyXpQwqDlCZqNEpo2f6OGx1DV3CTZXXwOG7YSp9tvg4L+XQ7FPxNVHG8Cm6U547RT++VTxZGZPr5JknXzY+vJQ6c12XeLTUvk25VD5oB7lcS4/LrKPnFes3UoRQfayq7a1DNDzq8Y1Mdy8vx0BbCE0bD2L6Zv1IxDWs/6gqNVabou2cslaeNTQ0hIqKsU/SxTF6DBt6DMMwo4YmYjooFmTGFn3C2Fv7Xi0i/RNN2TNQXTOM/sEK4cbEMAwz2YkNBrDu3WqEaxKID+tIxL0TbDlBhl5lJZV7YJixhQ09hmEYBXo0HZuXjsdIKXqpt77ixXNO8XHkDlSLmVv0CGNvzXt1iA16//wWrPgph6JS2Jz3o2lJzJrdIQy9oaEyrF7VjHhyZOyeamKO8XhO4/JU/Hwci1mrmbJ+kgqWJTL4VMFU4kTm2FyXGc7zlPFvTufRvAWTCpVPSqBIMUqu41YwEnukUlMUG6hUPqcYNtUOzevv0KVflAqdGbcor6f4+qq2lc+t67F43IvKmnqqbJlyXJupBnudO4WCDk+VT3Ezy4qf6jwqVTlVHT1FfJ9tHFKsn1D0SM1LZ930G+unui/Fct1Z5VPV41OpfPJ1S2qI9AQzYgv9xSjKRz9uih500UqRUh3XZIMNPYZhGAX/fClV7PazO1wG619t+ncp7fZHDwC5QErY2g/rMGtRN2ZukTb20im8s1C6LxXnMqlSxKvcwWh/up7EnFntKA9Hsa6tAU0NvZi/oBUr105DJJrOPmd7UM7NTdO3i6eHUefbhVMfcd0UzdnrytVtUGmASevKx6W06cznSQ8byq/LrVx6wSy5oEraAg9BwnYs6YdZ5fXwO8/hVlZ53ymNUIXPpWp3ym3gkVhFkVfE1k2OCVPki+n5fkZReHykJIPqjYBiW/neUJTecCy/4HeQstFnjsaqMi93o6jd4VYWQYxXvmHThh7NMyQjUN7e1R0z87cxvcBWoN6n8acoFWEZf/J8qW9lMhYFb7y6RBRdP+ssjCkJQxOtFCnVcU022JxmGIYZI5IJHWvfr0cyoWHO1l2onzWIcHUMwbKE/6CpMSIQSGDenFaEy2JYvno6unpqsWzlDMQTASyYsw5NDT1C7WMYhmHc0QMGknE2bJixhxU9hmEYF554/Yfi0zAM9PT0oK6uTrx1/+x2aaUvx1doiaSO1e/Uo2HuIBrnDVgviUV9p/4QhvrKMExtgOL43N/Eu5VFUKll/jAQDscwe1Y7NN3AstXTEU2rdzEjiGVrp2NaYzdaGrvRWNeLtu56dPfViELsft00/ZZcULlxepVfGOnbqZ/U9REuuBnKomehb6/lur/EIyplSLkL1eX1ci81veYSCndO6V98VSIUL5fLfBQ9t+VKN015DC6JVawOpKQ6tk4V30Hbd0Kh2KrcNFVFzZXJaBQ41PRWL1dur/lT+eDzu+5VCkWh2KmUPfnCmMXf7cs1F+VPwlZeIZ2MJa9EL4oTLStxuap8Mkq3UUnxU7gFWJOSgh4IJkVCl7GGk7EwbOgxDMOMg7LXsawaXasqESxLIlCWRLgqjvLaGOpnDCIwZyBdWkoTLqJJata0bv1tTov5ifR8Qxd/k1uMta6Yp1vPUKFQQqiIoVBcTIfK0p+hOILBhHieiUaDWLFyOqIJe+IYw9DR2tmEzt5atNR3Y0ZTJ5rqeoTB1zNQLQw+vwT1OJqrelAejCKWDCCWDGI4XoaBWLktDpBhGGbiYqQVPXaiY8Ye/peUYRgmH/TCt6V/+KP0j/8gMNQXBtbRXANlVQmEq2LQA+TykxTKGj0oUKNpejscKjOg0TxapidTyzxsLFXISywWQDwWQCwWxOBQWHzS34PRcmEgOtltsXgIa9pb0N5bJwy+2S0dmN7Yhe7+anQN1iAaL7OXF8hQ58oCMWzYtAaaZoh9hYMxVAeGUBZIvXaPxIMYiFdgMBYWBmA0GcRQokxdNkKpRGUP3FLwzDg9l37MN/VKwzWfjCGqWD6VouMh3vgudJ5QqHwOnrYj58wjGC693JbaXzUeDxXMOt8qJc7IXeXzxOUS2hb5VO+8Sk4ot4ViuWLfniqfJWh5KFG2vn3eNKryC7blLq7acmydItbNkOU0UxGjWfRdJHcG2rfhEOtnS6KSdN+3W3ClSuVT1eZwUvlUQb2KmElzqZkQiX6zSUBMxjDm0Is58TtegtDYmNGHDT2GYZiSQkN0MCRaZnIUR9dN63loxPjTgiNGICXoEMagbgjDhYw7YdDFg6lyCdazkdR3wN/DYSRWhlVt09DWHUVDTT/qq/vRXNeLgeFydA1Uoy9aiUTSngWkqmwQc+vbkDB0fNI+CwlKgZneXSAQR1Vo2GoN4T7rkKOJALqj1eiK1KSMvrzyMjIMw4wd9LvMMOMFG3oMwzD5UIzSB3KabuXy3PZHRptBLpyUwM4Wj6KIH7HelksGXgEvWMngW9fViNauetRUD6Ghqg9zmtpH1LlouTDLKkIRlIdi6ItUYEXPNCQokEWMIdVP3AihJ0qtJj3PQFBLCMWvPtwvDL9pFT0YToTQRUZfrBrDRlnWsbqVbjCzb2adP5sq41c6U2+fK3m93M71+VFWyzwKwftVojzLJ8jn3G2HqgL1pjDkFCdJfRf4NXQsmK7KyKpQIq31pCy85oO9/X6StlGppW7kcYyeBdU9s24qiqObfUuqmmaqabZMmubvicPJlUU5WlVUV0hm7Uqz1LYcVD6nfWbu11pNkYrVqcyEMtBSqQ3bd5vQEY/oCFfGMdYkoIlWipTquCYbbOgxDMMwRcOAjp6hatEoBq+qfBiVZRFUlg2L5WTwtfXXo3u42irH4I6GuJFSH8mVc9VQM2qCQ2go68e08m7MrOjCQDwsDD5qMUy0YvQMw0x2Iv0BlFWPvaHHMGzoMQzD5METr10uPj+7UyorZ054FFt3U5PyKaLutzh6fv1J0xmGGyVUMY0+e9bNEXdRV1RxXZqGvkQl+oYqsWK4GXXBQWH0zSrvxOzyDvQny9EZq0FnojqlFqYJanFx6GQ0mgqi4RqPppinOmb4zJypUtD87s+pc5d1vTJMFhL/Z0MxbnUdRWmWeyLHkfVUopJc35vingI5SJI+4wm9Qr2U28jl38wC7Y7fO5cBO323xgJbQfVs9U6p7imKo1sqn1NMX6bqJjJPpWP05Hqbqrp9psrnJNyZ+wwoikbaisObY7FtbB6Aum/lTaplq4AKt/dIXwB1syMie7M9i+roQsOizJuliCqhK1N82NBjGIZhJqx62B2vRneiBjoSqA8NoDHUh3nhNsxFG3oTlehJVKE2MIj6QKqURSQZxIA2j8vIMgwzZkT6ggiEhtHe3o6WlhY+88yYwYYewzBMATzx6kg9PZW6Z9XC8qoPlU86QVU3iqQthVBsNTCn/Xktl+LxSL3riNeiI1Er1LuGUD8aA/2YH27DUDKE5bEWxBDA9EAP5pe1oz9UhnWJOttJtCWjGc1DdVOGctmv4U/R84r/sxQ2WXVUZEu1JlXilKPKqxiqkaNi6aREUt+UPdWnUmlTEt0UOzm7peERj+iiBjvF6KnOrTITZz4U+ztqU8GsgERpf9kKm6kCWsqek+omL6f9UPcuiT3Fanq6bzlbpp6j+mYbiyoeTxqEbT+av77Ty+W9RXpTCuPixYvH1NBLlnDWzVId12SDDT2GYRhmUkHumevj9aIFkEBcPIym3EV7klUoTwxhXnANKrQIlsVbhDLIMAwzWlApnYGOEJ555hl85jOfGTP3zSQ00UqRUh3XZIMNPYZhmCKrewftfIWv2DpPlc9je7/b+sW2j2L/G1ysWl8eZCpxcpxeapmGdcl6xOMJLAisR0UoiiWJmYhSEheveLxChuih3nkqeqr5btkrZdtVUScw54yd8vaSzJVZ4iNrWlfs2u++kx7ZQs16iA7LfceWwl/snTkOzSMez1LxlUUBc7+PCs6gaa0nH4ycltfnOOTMmlaXinp0pmLpEKNni+HT0ieRpkWMnsdLFzNu09yvk7rnNxNnLr87pvqnSiKliv/LiNXrWRXG6qbV+Oijj7DZZpv53y/DFAAbegzDMMyUoyNZg0EjhE2C67AouFIYe/2oGO9hMQwzSRnuDmLOnDl48sknx8zQSxiaaKVIqY5rssGGHsMwTJH55yuXui43FT85vk+53m5XWtP/+u8PspYfuPtVqWXPX+zaz/77XGNNP/n09xzX2/eg61AIqn+3i/ZvuVs/ee5j0CjHe7E52Di4DpsHVmGZMQ3rjTrPOCtHZchnFkyloqcXcFyG+7ZmvXrHkBgrRi87zsgr9kwZo6ZQvNRxVA7jydifsrZeuk+h6CmPxV/ftmupEth9Hn9edfJUCrrtPsmO9RqJS/VQ+UYBLa1kJWNymYCAXdkTK7hnxsyK4RPxeWaMnkeQnqUGSv0p1T1FPz7VQmUmztSA3evsWespYvnEPA3/e6ob0xauwuG7fg9/e+lH7uNhmCLAhh7DMEyJGYLWei9e4rr8Xy9kG38qnnzm+77We/qf382at8/BCuPP9lCvjV7ilWKFzrnsJ44gPkzOwXy9DRvq61GVHMYKo9nm8pnVncLwSP3hvT+/43LCd2IVxby8spkX6u7pt2+3+8PJdZOMvIDDNVAVNfc0vLKn/ZZXsLtuZm/r9cJANS+fb5blNupV6NvPssy+Vfnw05a8IblPqt05s18iCIOPZsv9evn1qhK5yDad6mubT6Ir5baK8gvm2GU3TUURddNNv399EI3zNdTNHMJYwMlYGI5AZxiGYaY0BjQsS07DJ8lpaNH6sL2+FAu09QgjOt5DYxhmMmFo6F0TRvX0KPr6+sZ7NMwUgBU9hmEYxpl8Sg7kopwUgNt48nEZbTPq0G1UYbrWY7UeVKIHFehDBQaSYSQ1fXRLLzhgpeT3ej3rVovboQyBcpOcE4aot7VuH5UY5PdYHFRFoejpDq6dSX8uxaqSC7blDqpczq6btmnVzhWY6+mGx7jycOMsehkGhawmz3NS96zNk1nCm2N5BrdhpPepqaQ9vwla5ENRKJFKd05VYi1VEfUkhKFXP28Y//nPf/C5z30Oo551s0Rj4Tjr5tjAih7DMAzDpIkhiFVGE/5nLMCnxjRhRcxBJ7bEKuyET7ClsRKNRn9h7mAMw0zpUgt968J49tlnEYvFxns4zCSHFT2GYRjGkWcev9Ca3vvQ60f/TOWSwKIASAVxr9utow11WA9KzmKgElHUYAiNGMBmybXoRgWW6i0YRHhkaAoFyrIHHZSjLLwSvXgkf7F2M1Z2qO8AONW2uS+32dep/BaOCVWy5inW81Qi/V4DZXyfrIZnq3I2RdMl/s+m2FlqoLSispSGvNxUBt1PuCbFnrnePpJSZ8bmmYlaUvPSSWSc9meVKZD2ZiZjkc+ZIjGLrTSDSUCl3ikSpuTz22HrR5FkZaSWgkJWzv4hMOf0ripD/Zx+vPLKK9h9990xmm7ppaqc0diY0YcVPYZhGIZxRRMGXatWjw+02fhAn4Uw4tg2uQIbJNoQMHKvScYwzNQlPhTAVlttJUotGKPoHUBum6XccmWfffYRLztyac8884xjf//4xz9wzDHHiLIX4XBYfNLfNH9KG3qtra3461//iosvvhgHHHAA6urqrBN6+eWX59TXJ598gm9/+9tYtGgRampqUFVVJeqL0LzFixejGCxYsMDXzUDreXHfffdh2223RXl5OebOnYvzzz8fvb29juufccYZtn34uXnMdWlbhmGYUuHZxy4UTUYUrTZVFbMpsK2X5oU/nW+1zGV54zIGa1mB++nSqvCmPg8rtCZMT/Zg+/hy8Vlsd04zBs2xmedUtSwgtcz1Cz3PBZ5H1Rh8HafqWAMO96Dc9HTTcm+2fSv2oVruOhaHc5fz9oVC6pRo+kizLVfMIyXPFovnQHo9UvbMZm1ri9szRpq1rZHdPPcnrZvZn+N6ZpF2xf6c9u3Wt9exKNh///2xbt06vP/++97HyOSFruvYZJNNsuaTcX3OOefgkEMOwV/+8hesXr0a0WhUfNLfNJ+Wj6YRXtKumzNmzCjKzm+//XZ885vfzPJR/uijj0T71a9+hVtvvbVkDJ4rrrgCl102Uvdq1apV+PGPf4ynnnoKzz33nDBSvbj00ktx8MEHj/JIGYZhmNHE0HSs1hqxXqvF/EQ7Nk6sx4xkDz4NtKBX58LrDMO4s/HGG2PevHlC1SOxYzSYbOUV7r77bgwMDLiuQ4bz8ccfbxnTs2fPzlrnBz/4Ae644w4xvd122+HCCy/ERhttJMSn66+/Hm+88YZY3tLSgquuStWrnbIxehtuuKGQOil7UC78/ve/x1e+8hUxXV9fL5SxfffdF6FQCK+99hquu+46LF++HF/+8pcxffp0YV0XypFHHul6wcrKylxvnB/+8IdCyTOVzBUrVgjDjW6IK6+8Etdee63nGF599VWhhh5xxBF5HwfDMMx48uyjdlUvk72OvGHkj3ScyvMPne+6zX8f/L+sebud+GNr2lSAXrrvvKz1dj79JygKHvFvKqJaEEuCM7AuWYcNk23YOr4K65M1WBpqRkzL/Z9YZWF1eTwe41KqdR5JHguqs1dkbM9+HnUJrayb8jxV0WszZEoVJ5nLQeeYYdOrjp46E6c0T45hy0A+bituz9aPx7x8sGL4Eq419lSxefblDvXoMg9TEROXVWzdI/umWNfM+CnXunPfWD1flU3Tiv9TbC+f76y4xNR1I0OEjBcSDuhZmnFngw028DxFv/3tb63p0047LWv5xx9/LIw5YscddxT2S0VF6uXcTjvtJJ7P9957b8sWOfPMM4UROKUMPTJudtllF9GampqE/ysZaX4ZHBwUrpkEuWu+8MIL2GKLLazldKI///nPY9dddxXW9de//nV8+OGHroaYH8ig3HLLLfPa9o9//COSyaS4OUiFJGh8FES7cOFCPPjgg56GXnNzM9rb28X5O/zww+0/zgzDMMyEpU+vwFv6XExP9mJ+ogONkWVYGWzE6mC9UP8YhmEy2X777YWrID1Hn3LKKUU/QfnGwo0FozEuek6///77xXR1dbWIt8vkpptuQjweF9M///nPLSPPpLKyUszfbbfdxHo//elPxd9TytAjZasQHn/8caxfv15Mf+c737EZebJRRIYTGXxLly7FH/7wB5x66qkYL8hvl8g0aEkSppjCd99917MPkoapvfXWW3jooYdw7LHHjtp4GYZhxov/PHJBUfp58XfZKp+KV+7NVvl2OnNE5fN6nijoeUN++a9raA3UoS1YjfnxTiyId2B6olcYfDTPMvhMBU2hMHnWussne6diU9t8S5XIzgw5GlgKolyOLJ/9pmP2Mmbl1LdjvT2VCOZyTvM5XU6Kn/t6qT+KdnlU2Tmdlrt1o9rWdhF0h+V0EV3i3jJRqXLK+niq8Rj+tnU6ZjelTlPVEVTU1ssgEAhg6623xpIlS9T7ZHKC3GDN5/XjjjtOGG32S2jgkUceEdP07E6CjQqav+mmm4owsocffhg333zzhBVnxuU1I7kvmrjFq8nL/vznP2M8mTaN6ilB1D2RoUBauhH8xC2SMkluqATF+tGbB4ZhGGZykdAC+DTUgjfK5mFYC2HTWCt2HlqGedEOhIzUm2SGYRiCngvb2tpG5ZlQFEwv4VZsfvOb37i6bS5dutQyBMk90w1zObnVLlu2DBOVcamj19nZmWVAqSDZlaxxcvXMNQaw2Bx11FG4+uqrccEFF4gsm6Ts0cUng40CQ814QzfoWC666CKce+65eO+994RKeeKJJ47J+BmGYaYSr949ovLt+KUixfDlyKAexntls1GRjGJWshtz4l2YG+9EW7AGq0P16NPKs1UuB0XPijNTLfYby+eSEVV8+n31m0tcm0LwMPenPBYvbMdqiGYo1CRVyJRteSHP1B7n1jq+PGI+fSuathp9HnX2PLYfEzxq77lm2JTVwPQ6co09zaOOnpGOCbRi9WRlUN6n2adT/J95zlRKna0fI1t9NJdL990hW3xffFY0xDBjm7h4NiZvNiY/+vv7hRssQUluqBRDJh988IE1TYqeG/Jy2s5PfGApMi6Knpydsqenx3E9SnU6NDQkpru6uoR6VghkLJJETvsno4suGmXmIVnWK4UqBWxSXCGN5/vf/77w3SW3UkrSQnF/FHfnBzIIzQxA5AKbSHD9JYZhmNHktTvPE81GMVPVezCkl+GTsml4uWIDLAs1oy4xhO2HVmLbgZVoifVBk//9MUZa2o5JGYGKZi1THJdb2v/MMgXQjVQr0jmRx60aPxlZWYaWuVzZoXRcuiE18xhU83Io2eCzHIKyNEU+58vqUxtpCkbG5b6eF2QICmMwl35y3J9cSkHVHMsvGFJzLIsglWZQlTjwKpug7DOP0g1+yzCotnVZHhvUrdJlxWYi1NEj8URukUgkr2Mlzz8zIyeFeqlcLVeuXGlNeyW/oRJqqu0mGuNi6MlWMpUlcOL555+3GWCU5bIQSLJ95513hEJIBhtJsZRE5eijj8aee+5pyblOUEAmlXugmELKDkrumpSYhY6htrbW1xgoaycZigS5fJpBowzDMMzkd+lcHWrAK5UL8F75TCQ1DVsMr8MuA8swb7gToSS7dTLMVCM+rIlnytEw9CYCZFBRPW6z/ehHPxoVt02ir68PstegX1GK1MKJyri4bh566KEIBoMimw3VoaML0tjYaFuHautlqmTyBcoFytZJ6VIPOuggob7RjdTd3Y0XX3wRt912m7DUKfPngQceKObRcie++tWvilYIVDKCUraS4Uq1+U466SRxPhiGYZjR47VfnydeHpInyQEX3j2Op1pDR6Aa7aFqVCUimB3rxrxIJ+ZHOtFaVoNV4XoMBMLeJRDc0virclF4uG7mRXpjpyQybq6bvpE7Vylq8u5ImcxcoMqXUQC28gqqeYprILtXKqVLN5dbmXFM4Gq6WnpmkVUUVTfdNeV+UiqdluHW6a6yaaaXpqLkgpcbp+nCKdYzx6M6FGVyF4dkLBn7SHeengj42xaaCGMaTUWvFDHHRc/gslgSDtt/+/xAoVSUudRMpELZ8FUMDw9b016Z/OVxmN6FExF9vKx3M6aNLg6VKPjb3/4mDDm6CKTkkdFFxhe95Sj0RL/yyisiyw4lQ6Hgym233Vb47n7ve98TsXJkAJo+uIVmFPUD3VxUrJGg8hH33HPPqO+TYRiGKT3IoFtcPh0v1WyAZeFGNMYGsVPfCmzbtwqNUffCwAzDTJ6ELFPVdZOMPLnlY+jdd999VjKb008/3dWrTg4Pc0N2Ic0swTCRGDcZ6cYbb8Snn36Kxx57TNTIUxUQ33zzzUXSE3KXNGvu5Vs/zwnqk9w3qRhiR0cH7rjjDlHWodCafV5QAUbaD50DKuJOqmYh+zR93JnSQ45BYCYufB0n13V85Zffzorh2PGrPx3bwWh2t85V5Y1YVd6A5lg/5kS6sXX/Gqwvq8GSyhbETCnDZ9IPZakA276NouYgsYlucj3pHIuVW4KclBzGliQmc5qaSkyROtKS2SUJVAKa/fxkz1TVNFfOK6RveZ4i2781LRfethXhzt7GtVSEnBBFnlYehOazlIJiuWIe9UPfQREOaAad2lfI3saSZxVjlZfL49Gzvztuhe7tmXxU6p5KkVUotvK/+dY5U9VMSSUmpBf/Xs8J/BzhXiSdjETKveFEjWRHeLljmvF+ftw8S5lxM/ToYpCKd/fdd+OWW27Bm2++ad3AVIT9jDPOEOqaWVidaGhoGJWxkKvmCSecIMZBF/a1117DZz7zGYwm5KpJrql0nMuXL8edd95ZkEsouSLxD0BpQtfF/EGZqHVYGL6OU+H7OKO2zN1gMvuQvbmUD8/ScjjPM2QvM3N/4v9hrEMjYvFBLBjuwrxkJ5aVN6I3VGF30zTLdcl9B/xaaIqaeR4uoJYRZTOs0ivIz/lSjjHTW06eZ2X5DCiMOtU5CWSPlT5a0h4/tiSIRm5jtBmossehykBN+js+c1pXzBPTcSNruR4zt5EM1PS0HhuZZy2PjwxWl6dj6WlpHuKpHWnpz9S8dDxoQl5vJEbUiKWnY+mBiXVT2yel9UY28Hhx4GLo1c+ih28t+xlGZeiZ/QTkZQpj1VYfMH1T2QxiFyva6Z9plcuquY3NSDbnBdzHJU1T+BIdP9WYdlO0KFnJZHPdLBR6ZqfEiMRhhx3maivMkRKwkEehG3ICFjkxy0RjXAPDdF3Hl770JdHIbZNka5JHZ86cKZYRlDxFDDQYxCabbDJqY5GLtnslZSkWp5xyCq655hosXrxYlG4glU+WlXM1Vv0mhGHGFvMfL7pGbOhNXPg6Tv7r+Pfrvua67fbf/KmzQUSYxopqucI4VClV8ry1WghL9AZsOrAeM3o/RTJci8U1LVaMlJuhpyyVoOVg6CnqTluGkGwwmWqZg6FnGT1xheAhG3rp6WRQMQZJnTPnib1qwOpo1NPQs4y2xMjBmEaWbayyoWcacLZjTX9Kx6LqxzxW+Zht25iGnjQvkDbmzGW29aLyvHSpgJjCuJPm61Gp81ja0DONN8I0+mRDTpo2orFs4y89z0gmfMfUqZAVwdR30ED7MpeX1ZKBpSwfIRl9mqrouXJe+r6VjTcPYyyrP6d55nhsYww4jwsQ2djJiKPwJbeyY/wM4Z6Exc1tM/NZn7wJ3ZCXk4fhRKVkMoCQnJrpmklvXd966y0xvdVWW42qj+x4qGGBQEDU4Tv55JOFcXn77bfbFMxcSLk/lOZbG2bk+vA1mtjwdZza19HIY57bcj/9DeshvFU9CzOjvdhkoE24pn1QM108MLrYNPmUuvOcVwh+z5Pfc2dOu1VlyHU8+ZDr9XVabj6C2CptuMyzeQAqTpqyHmMOJ1y9n3RSE7lGXR6Gng3drDLgUl7B5gtszVSOO68vqds8FPlL7zCPsrgTpOjNnz/fcdf5/GaNRmHyYlCM7yAlbvz9738vpltaWnDIIYe4rr/BBhtg1qxZWLNmDZ599lnXdc363WSEL1iwABOVcczf5M1DDz1kBUN+4QtfGNV9mbIvQTfBWEEuo4sWLRLTFLNHpR8YhmEYxkLTsKa8Dh9UT8fMSB8WDHY616szN3FZRtjq6LkhW1Mqq0o1T8tutv2l55n19IRSlu5HnmctI9XQbKr9qIat2J/TeFS19QqhGH2UJKR+ZTTKcikauWG6NXM9UrYU/RSEVK+OMnCKLJyq2npemDX6vGrlmf059amq9edR/4+EDPLKmqolFvLl8ccfR1tbm5j2k8Fe0zQceeSRlmL30ksvKdej+aaiR+sX6yU9XV8SsP773//i1VdfxZIlS2yZQCe1opcJGXhXXnmlmKYvAMWyjRYU3/aHP/xBTFMhdSqOPlaQi+rll18uiq9TQXgz8QzDMAzDyKwP16A8GcNGgx0YCoTQWsnu+gwzmTJv0nNgMZnsMXp+audl8p3vfAe/+tWvRIk3qoVNyp3sMUgZ/mk+QYYjrZ8vZNCRMUrq4RtvvOEo5pDSuMsuu4gqABRnSLlKJryi197e7lgugYw8qmr/8ccfi7/JEDJl7UyoTILpgkMF0DP5xz/+4VqWgdxDSS2kjJsExQvmk9q1EI499lhss802Yprq6zEMwzClx5u/OFe0cSGtRC2vbMCa8lps3teKmlj2m2BLvVMpcDaJT1K4zOyVqn5UQ1GphA6Kn6VuyWqaQvFSKXlWk/cn95VxbmSlTq3eGSNNMS5lc7kWJeoRN3pQDFueip1qGxtuyp6ot5duXmSqb6plQuVLNcNIWs1zG1XfprKnWu53nmTokesm44+uri78/e9/F9NUI3v77bf3td3ChQtx/vnnW4lcqMQbiT00TZ/0N00TF1xwQc75QUi1oxrZZLztueeeIhcHlYujZI9y9m65UQZ+ckH94he/KLwKSUV84oknxk/Rozp3phGWGbBI2TMz68Kp1DgqbHjWWWeJhCQHHHCAyGhDli6dXCpiTglKiKOOOgrnnXce8oXcISkG7phjjsEee+whyihQmlRS8cjS/uUvfykKlxObbrqpMCrHGjJSKcMoHSsZwAzDMAzj8A8GPqqehpp4BJv3tuLVxnkwppzFwTCTDzL0Xn75ZVEPzkxIWCiTWdEjo8wM7/Kr5plQAkQyqu+66y6htFEYVSYk/FD5M79Q3B8ZdZRFn2r0mTGtlI+DQrR22GEHkWiHMqxSZlASoTo7O4XBSjYP2T9kA1DcIVUlICOWksdQLo/jjjsOY2ro/frXv8a9996rXEaFyanJOLlddnd34xe/+IVoKuPnnHPOwc033+zpc+sFnUgaMzUn9tprLzzwwAPiAowHZL2Ty6j5FoFhGIYpTd78+Yiqt823bhrzzASGpomELDt2rcD8gU4srW3KzjAprZ90ywYq4fuxS9rYsxyfIsOoVVFMkdFSNQhlyQjFPuzz5JgqM9293Gk6sYh8IlSl4ErzGXnsUJYfcDdCNLPmhH3myHT6wo/U0dNc11MiLzNvcCKtFIo4PavL9HI5ps6aJ3WZHrem6C+1guJmN8euzJgjb2vuSE41O7LNIQu/i4qmOGZsFxPPxsV6Fp3Mhp5ZO48MKRJ0ckHXdWGQkUcd1c+meDkyspqbm7HTTjsJ+8MrsYsMKXg33HCDEKzIwCMvRPIWJJGJ+vObTHLp0qV46qmnhD1C7p7vvfeeqAtIbp00TlIuJ0yMHsmZdFKefPJJoQiSZU0nnrLb7LfffkK+LEasHBVmp328+OKL+Oijj8SFpC8RxeKRPEon78QTTxR+seOdEZFulEMPPXRcx8AwDMOUPv3BMJZXNWLBQCeGg0GsrahVp4JnGGZCEBvULde/8RIdJhLkDlkohx56aFGeu01vwIMPPlh4IZIdk48qS+6eZtk5itckD8mf/OQnIjkMJajMx9DTDK6yPaGhuitUD4pcUbmOXmlCXzG6PlxHb2LD13FyMBbXcetzb8q9jp5LbT15vvwSXNMMbNq7HrOGe9EWrsKHddMQSXvAqGrU2QqPq1Qyr5rXZs04KfulVVtOUWxcnlYpf8ptZGEk/So6IdWxN0KpFWgEsyrLsDoase9OpVSaKyQU45Zr68UVx6qqmWeriZd9LObyQCyHOnrREqujpyqoni6YbqQ/HfFbcsFIiu9g84J6tC/rdi6xYJN+U1+ErBi/jOWyEifiBvOtrSej2qdVwD2gKJiuqq3noBaKdQ1s/Nkh4aa39957F/TMZ663x1+/jmDV2Oad8Et8IILnj7hlUjy/Hnnkkbj00kuFe2axIRdPCmmrqqoSSuOkybrJMAzDMBORt29yT9iy5QXO7p6yQWT4cOH8sG462iqqsHnPeuzWthyDwRDimo54QE996gHEaFrXEQumP6mFdKEERuXQCPk5VrVzF7vYZqBmlHkQs1R1xhTb2I7fpWC6/Tw4j0tebrPrLddMqW9pBWtKc+/HzQXWbpRj9LCdb/9GVuqz2BUTHQwiFeQiKZLaUK2NVHYbldunIblSWgZeoSUZTDdO2RgzT4k0BpvRZxqhKndO2S3UNPqU7pzy8WW7cVKoUsLLkGZKjkcyQtaKCbl9FpKrhA09hmEYhpnAtJdX46VQOeYM9qAsmUDQSCBgJFGZiCGYjCBoJBEU8+0P9fTIubquFh83NiIS4scBhhlvyMijmLNiQTGotjjUEqJUxzXZ4F92hmEYhhlD3r0hpfgt+m4eiVwcno1igSCW1jSNuIWqXDd1MviSCCWTCCCJpqFBbNjRhVm9fXhlzmz0VJR77ie1TFbYVNlTHKYz58nLTKHDULmcuowla2wu+1MpcZq7q6xNLUv6VOqK9fzqIrZ5JsHJa38+O9V8JijxIkBKXlpVo/tIdBXIUtC0QB6qoWoM8ljN5T4TtNi6ViVrUal38hhMNTCgmCfNL2bGTYYh2NBjGIZhmKmApiEeCIhGxlNfeRgra+uwy6pV2LS9XRh7nNCFYcYLo+iGXhKaaKVIqY5rrKHkO1RKgZJFUjKWww8/3HeWTj+woccwDMMwpchoqDYZJAI6Fjc3YcfVa9E8MIj26ir7Coq4NnucnBmEl0OcoSmJJVWBbdJq6eQxjh5eokC7lhFnl73aSLydQtGRj0U1Hp8xeqOq7JUyigO3yhn43TxdcJ2up1wWwXZtXPbnpUTa+swco5f6KKtuZukGKTmMpe7ZlDoz049C+rWNVZYOR+7jYrpuMuPLBx98IOrgUdKh22+/HfX19bblf/3rX3HSSSeJhCsmVFec5m+99dZFGQPrwwzDMAwzhWmvrERnRTkWdnSMTnIOhmE8GUnWWURFL11Hr1TbZOfhhx/Gn/70J6HaZRp5VFbulFNOsWrvmW3FihVC1RsYGCjKGNjQYxiGYZhx4L3rzrWaJ0K9ym8/gWQSc3u7UT80JKaz0DSh6tVGopjZ35/OhJitSJGS59QgNXILdW+GoqWWJaVmzssLUkfSjZ4nM5t5fPZ52dvY+3RpqvUcx+ay3PC41nT5Mi4hZdo0GxRNucwLUrL8lklIK2RmG5mp5dzkfkjlE0qfYnmhkMonlD75nNDfmfP8nhPVNqrrYfaR2U9yZFuO0Zs8PPnkk0LNO+yww7KW3Xrrrejv7xeZVqlW3ltvvYXrr79eXP9Vq1bh17/+dVHGwK6bDMMwDDOJKY/HsHlnm/X3UDCIropyLGluwlAoJOZ1V1RgfVUlNmnvwLqaalupAYZhJqaix1k3xxdS54htttkmaxkVQCcj8LTTTsN3vvMdMW+rrbbCkiVL8Ktf/UqUbPj2t79d8BhY0WMYhmGYcea9a88VzRMvxUfBQFkYXeFyYeC9PW061lZXo3FoCLsvW4HpfSMK3uKWJlTE4pjT3WtTt6ymp1tAar5VPKmZSqBC5bP2QS19nPIQfB+/TXEzO3Cf5634Keap9lcIqn5yUeL8olKbZCgeLTOzpUp1MxU2lUInsmm6NFLrqOmB7HmSkqdUC/M5Pq/zmKnsOal7kipH8XoiZk9W6lT7cJsn2ohUy66bk4f169eLz5aWFtt8Srzy3nvviWmK0ZM54ogjxKe5vFBY0WMYhmGYSc5QMCSMh7U1NQBq8ElzI7ZsXY/t1q7DisFafNLUiP5wGGtqa7BRRyfW1FcjwWneGWbMMMtIsOvm5GEonWRleHjYNv+FF14Q8XjhcBh77LGHbdnMmTPFZ3d3d1HGwIYewzAMw5Q4ZsJIW4m6HNSjaCCA2ujIwwYZcW/NmI7u8nJh2M3p7RVJWajOXnkigbndvVjaVO89rvSIchmLlYAwKaevtDrMnlco5v4UGURtHqr5ZNhUJYFU7M/r/NgzmWaOfzROSv7IWSyLES/nnJUyY5k8S9qvLatmsZMJqersKevjIXsMqm1tyqC0TUBDzeyEiNeaP39+0YbPrpvjS2Njo1D1yIVz1113tcXuETvttBPKysps28TjcfFZVZWRATlP2HWTYRiGYSY5MT0gCqXb0DQsb6jHsxstwJKmJmGzJDVNZOAcCvF7YIYZK7SggdoFcey+++6oq6vjEz9J2CYdm/fAAw9Y80jd++Mf/yji8/bdd9+sbZYvXy4+Z8yYUZQx8C85wzAMw0wQ5FJwVgk7H2paTNcRSiRSikKGQpIIaFjaXI9PNW8FLxPlvr3UK3M1isPL6EgWPDRFglDf+BXBVLX15O3zUO+Uh69S97yum+bv9bycOIceHtMTKAhVdkk3tcx24YqUyMdNLXRQFS11Lx9lT6Uq2tS7dN+ZmUUza+uZ8p5qDA59185PQA8Cv/3RG7jnh2+JeY+/f03ux5C1u9ItY0Bjm+yccMIJ+Oc//4m//e1vYnrPPffEgw8+KMotkIvuiSeemLXNyy+/LD433HDDooyBFT2GYRiGmeREgkHxD35lLDbeQ2EYRkILGKhbEEffygASUX4sn0ycdtppIgaP4vFIxfvWt76F559/Xiw788wzsdlmmzlm49xvv/2KMga+oxiGYRhmIpJD9s2O8kpEdR3zenrsmStFUxWNyz+bpK1mnW4oWjrrpmo9RW29nMZjpedUbSOn8MzOoKmqqafKsOmZddOrzp5y3M4ZPX2PwQFS/PIulyFnoHSrR5fHtp641dyTs3fKdfYUtfeUTXkwHpkxVcflt96eSxbPug2TQs3r/jRU9Ayrho8EpOPWMPnRdR2PP/44zjvvPMyZM0fEYM6dOxeXXHIJbrvttqz1SflbtmyZmD7wwAOLMgZ23WQYhmGYcWbRRTelJnJ8HqdC2Nt1rEJ7uAorqhvVK9Fzp6ajtSpVVsFfxy7zVE9oNqPHcH+dnH6ItRkp6T/kTcnwy+rcKMB1U5VYRe7P77n3cOfM3IfTNp4JWswx2ualz5PTeNywuabm7uKpdIssdr1FVX9ymQfTgJLXI8POGmRquaa63zySyDgarJnbqNw5pXmGnpqn+bDCq2YlUL8wgZ6lQSQiOhCaCubP1KKqqgo33nijaF6Q+rd06VIxXaykPGzoMQzDMMwEpT42hIbosGiUMfPT2ialekMGYUU8jjiXTGCYkkAvM9C8TQIDq3V0LQ6Nyj6S0MR/pQiNbTLx3nvvYdGiRQX10dDQIFoxYUOPYRiGYSYiBjB9uA+DgRDWVNRio/4ONEYHsbi2BT3l5ZbKUBGLYqv2daiNRvB+c0tuu5BFoEJKICgSr9i3Tasu8jyr/MLITE0uyeAXNyXSAdfyCoq+bW6VGbv1HJctQYvi5ObkNqtQ/MYApVqWj9qXWaQ91+XmMOQXGumx+VbxHBRLQ9WPsixEep7svhnIvqFq5qX66/iAHsVdyksUAJdXGDu23nprLFiwAJ/73Odw+OGHY5999kEoNDoGfC6woccwDMMwE5TmyADWVNZieXUjusoqsXlvK3bqWIWIHkBfWRjl8Tgq41FRMP3lWXNSBiDDMOOMgZp5CQys1ZGMUczheI+HKRRKuEJul7fccoto1dXVIs6OjL5DDz0ULS25vWQrFmzoMQzDMMwEhNwxy4wEBgNlQm3rC5XjleZ5qIsOoTk6gKp4FJ3lFVhRVoc1VbVIBrURVU4W2HLdcaGigzkIRYxeRnBV+v9qCXEkiYu02Jy2Bfu5qEA5xNFZk3kIVfZEKnlIjJkUOzbOSTlL+FtdWTjdyU3YHDvtgyb19LSo/OHP4pHLGSjHnVSMQ1FY3bHwesZ68riV6qW8rbleOlZPzMqw5CqmGwhVAuvfCNjHXeTrSqUV/MQKjgelWvYhX6j+HSVTofbMM8+gr69PZND8y1/+IrJo7rzzzjjssMOE4bfVVlthrOB3CAzDMAwzAQkZCatGnmxEdIcrsaS+BW82z8bi+mlYVVOPJMfmMUzJULvAQKRbQ7SHH8MnC3PnzsXXvvY1kWWzo6NDGHlf/OIXMW3aNCSTSbz00ksi2+a2224rXDy/8Y1v4IknnkA0Gh3VcbGixzAMwzATkFAybehpmTUI7GKRKW4VHP2j6EDZt0olU728t4U1qeLRFMpXpsQmFCE5y6eqH0WmRmvgOagKuWblnAyChfSCgBRkP9kplapUINugIfUuVe2APnWfMXhpJU5S/pTqni1TZ/axWAqcpNiZ6pzt+GRFz5xWxe2pMn/K30tpm2ClgYppBtrfGf1H8CJWaig6pTquYlBZWYmjjjpKNOKVV17B3//+d6H2vfXWW1ixYoUor0CN1jVdPCm+jwzDYsKvEhiGYRhmAhJKP2TGdYWhxzBMSVKzIIlkDBhYw4/gU4Wdd94ZV1xxBd544w1h5N166604+OCDEQ6HMTAwgIcffhhf/vKXMWvWLOy666646qqrhEFYDPguYxiGYZhx5r1rzxUtFzQ5U6Vb8fQcCqv72m9Ss5qyarfXeFRDNIuoS4XVYTUzjgv2gurWeiPLcy3uXjRyKY7uu0+X4t4+i6TnXSjdZTxmUXLRdF0dn+faTVrBI9VNxOlp9mnXQunppuhPbjZUfSuKrXtiFkJXFTWX52WO1RqvgbqFSdRtZKBvuQ6DbvgCrnEuWTdLtU1F5syZg6985St49NFHhYunaeTNmDFDuHiS+nfZZZdh++23x7x58/D1r38d77zzTt77Y9dNhmEYhpmA9AfLxGdNPIKh9DTDMKVHqMZA09ZAeUsS3Ut0dC/WARbipzwVFRU44ogjRCNee+01y8WT1L9Vq1bhl7/8JaZPn553Ahc29BiGYRhmnFl00U2pCa+X3JKIENODGNaDwtBbjxr78rGKfzGy69vZsmC6DMSeLdOMa5K3TM+zbSX9RdsHMmL0JjhjLnLY4hYVO5fnmXFoquAqr7g9GTnDpFBB0wpbLpdRvnfkenVplDF8fuP27B1l71Pen+5+fIEKoGFzoHo+EB8E1r0UwHC77p6JtIiUsnJWquMaT3bccUfRLr/8cqxZs0YYfGT4URxfvrChxzAMwzATlL5gGDWx4fEeBsMwEnoIqN8CqN0YMOJA5zsaepeRYcsRU4w/KF7vnHPOEa0Q2NBjGIZhmAlKb7Ac84c6URsbRm9opBi6rYycVydGkTNxykkLLeVEmme+yJeUOE2RLVNL/2EqexmLR2L4VMNSJNj0rJMnnzSfcVPK8n+jyRjtyFLEbMkk0xdTJd6p4vSkc6isj2cpeunt/dyHKtUtB3XPxKpxl1Cs71Vbzzae9PbBkRuhblMd9ZtrwqbrWQz0LKFzp+d8/Q7e5hLx+Y+3rvS/UdbwuI7eVIcNPYZhGIaZoKypqEVztB/bd63E0qomLKtuEA/QOXlFFcN4cEsEk7nczdVSU7hzSjNlow9mLhjb9qq+TavOx3j9Lh8vxmpcChdCLZmj8eeE5aZIyUiEZZUy4OjYvBK7qAqU25a7bKswAu2umemNEwl3o0+1D3Jr1YBpuwZQNU9D36dA90dAIpLuP6AoiO6l7hWh/gCXVygd3nzzTTz33HNYunSpKKaekO4zFVRk/c477yx4v2zoMQzDMMwEheL0/tcwFxsMdGDDgQ7MHexCNBBEVA8gGgggogexuqYWA6HweA+VYSY1DYt0VM3VsP4lYHBN8ePtmInJu+++K7Jqvvrqq763MQyDDT2GYRiGmTSo3Av9bqpp+LS6Ge3hKjTEhlCWjCNkJFCWSKAhMoR5A91YW1mDJU1NiART73eLlQdBKaDZss5nq2mma6cojTByEOkJSamxXDzlWamZmrlzJ3XQVozd5/jzOCnW9kVS2uzjyb9Ts7i5J/J6qsQs8nJTlZKLjLuofDaXSV3RNylkNEnrC+nJrqapC68H/CVRUSHfR+lxWy6coh/Ffj0KqluKX7p8QzIKDK5Nu6TmkmzFXF7kUgspRa80Dc7JXDDdZMmSJdhzzz3R29srjDeitrYWdXV10HMsS5IvrOgxDMMwzCSgN1SBnnCFmDYCIw/8swZ7sFFvJyrWx/DqzNmjWreLYaYqQ22GUPVCtUCsd7xHw5QCl1xyCXp6eoRR993vflfUz6PaeGMJG3oMwzAMM868d12qWPqi76XLLOSLlplsRMOq2noMhULYvm0NmocG0V5ZhVFFUhBMZcn29t5SwWSVJ62SKG1Qh3T2upGtXKX7HBW1wG+fCpXPlucl18EpVdMiHaCTquC3hIKbyierV6r9mNvQh6noeWFuo4qtcxpjrufKqb90P1QoPhNSL6OdpPYZKG/WUoZegYrNP96+CoXC5RXGl6efflq4YJ5//vm45pprxmUMnOeVYRiGYSY5HeWV6CyvwCadHVPDZ4phxhgjAUQ6gIpmPvVMiv7+fvF59NFHY7xgRY9hGIZhxplF372pqK9fZbEsldldw+LGJuy6ZhVmDPRhTX2tR6BdITtXTMtCi6XG2DNophaNzLNii2wqX8Y2eo7ZNP1i+ItBLMY+HPeTB77VQjN+Thkn6YBKoXIrd+DkImwpeRmfoj/FxZSVQTOGT1bVnNS9zG0U2Aqrm/F68iF5qXIZsXeDrakC6WX1QLRfEZdoG6v7+T546x8UrOwJsRSlSamOq5jMnz8fH330EcYTVvQYhmEYZgrQU16O1soqbNzVCU2Vap5hmMK+Y0uAaC8wbWdAC/J3bKpzxBFHiM/nn39+3MbAhh7DMAzDTBJIvdO0JGpiw5g10IMFfZ3YqLsdCzvbsFlHG6LBACrjcczt7RkpVp3zTjyachuz6F1GJXOzWfNGGql7mU1ePjKYAsjlGFy2Vx1KAWkSHd1rSbHLjkt0H7dyG1KT0pkilY2ULFHnzmUdp/VU8+TjMlsy3aRpytiZ1RIJq41smxxptoNN768QzHPjdH4C+kgz1zNJAutfBQJhoHkbGptbzcjsvg2pFeNYzBi9Um2TnXPPPRfTp0/H9ddfjxUrVozLGNjQYxiGYZgJTjCZwIKBDuzauhz7rPkEu65biS0612N+bxdm9fWheWgAjYNDYpqY2ZeKHWEYprjEBzS0/Q+onm2gZsE4q3pGibdJzvTp0/Hoo4+irKwMu+yyC+666y6RhXMs4Rg9hmEYhhlv8n25bRjpQund4s91lTVYWV2PnvIw+kNlSOo6jIAZ65RavyIeR4zUCKsPM35o9J685K4Nv8evmKelt07V0VOsY+6oWCUkVHF0hs/Ep06xg27xf3I/bmKQ16VSKYKqOnm2WneqTJuK7VV9yzFz5nK/9e2cYubS9fhy7CB7jKp7wdyN5MJsq/tnEshxv6JvHYPrgJ6lBpoWJRHp1kfi9VT7YCY12223HZ599lnsuuuuOOuss3D22WejpaUFFRWpUjhOULbOTz75pOD9s6HHMAzDMBOUWcM9WDDYhWWVDVhZWY9Ieeqf9aTTA6qmiVILqQQtDMOMFp3v6yhvSGLajnGse0lHfHgcXBVL2UWySONavXo17rzzTvztb3/DsmXL0NfXJwwpSoSy77774vjjj8eWW25p2+aee+7BmWee6av/u+++G2eccUbe4/vDH/4gjDvKwElF06m1trZ6bkeGXjFgQ49hGIZhJiCV8Sg26W/Hqoo6fFrT7PjsZKo/XgkZVaqb3J1S0fLISmntW7Xc4zlGzsA5sqlUoy8dt2c7rvTDkfIZyTZurThZMN3OicN5csvkqVIBbfMUIpct/s531k17tsjUti7Kl4xfoc2rvp1uqrLpOLeMoWsqOc3s0ynrpmrffuoA+lFB3VCppUkNra8FMXO3OGbuFsXaV8oQjyjWE+MtUWOsxPn1r3+N8847Txh3MqtWrRLthRdeEMt++tOfjsv4/vOf/+Dkk09GMn3vLViwAFtvvTXq6upEEfWxgA09hmEYhpmAbDTQjogexMdpI49hmNIiMaRh7X+DmLFbAjN3iWLdawHEBsdOTnfJ6zPuFDouMt4o2Qkxb948fOUrXxHukbW1tULlW7x4MR5++GFPg+qJJ57ArFmzHJfPmTMn7zFeffXVwshraGjA7373Oxx00EEYa9jQYxiGYZjxrJ1HeClQGcsr4xG0RAfwQc00JOR4Ozds8pzPQSpUMFuSTA9Fz0hmK2yGS2kHm4qnOS9PCUGk78ka38j+vLBC+ZyORXGsKoXNrR/vODppG1NsUp5PI/enZC+VT1XXTRk/5lInz2FxTuqeqeipxqMav9lPLm5tbg/6trHkUUfQjXR/iYiGdS8HMGPnKGbsNIx1r5cj1q87KKzZ8z674+XWrD8+dV5uY5ikvPzyy/i///s/MX3YYYfhwQcftMW87bDDDuLz/PPPRywWc+1r4cKFQmkbDd544w3hgnnllVeOi5FHsKHHMAzDMBOM+UNdGNaDWBeWCp87uUp64ddPUemS6P5gbhowtqoKaWPMbpS5GX+KefKEsqC65vNYZAtUtVzaZx5umlnbSsu1XLax5nkYfW4GoJdrosp9MOlh/OXj2mkaTGRkWeUyNH/GlGq5X6NP3tY8F7ILqF98729kvUQsgLWvlGPGThHM3HEI6/5XgehAHvvOkVIuY1DIuL761a8KpYzi8H7/+9+7JjYJhUIYLyKRiPjcbbfdxm0MHI7NMAzDMBOI8kQM06J9WFHZkKq3xTBMyZOMaVj3egXiQzpm7DCEstrEeA9pQvLiiy8KpYy44IILUFVVhVJl4403Fp9jXVJBhhU9hmEYhhlDtrww7bKZp402b6gLcS2ANeUpNc/rxbi53Laeh4pnKYNeY1SJRElF5QZFzgt5Pd8SpDRu13rv0nqG7wQtis19qnNeSWn8JnpRq3iKeV6qmazeubjK2jv1m4xFmmluIpdCsEoXeOyP1DTaXg+kpo0cEp3kQ6EvRZTnJ7c+k3ENa1+vwIzthjBzuwGse7sKkZ7gyAubYr+4oS9giSp6+Y7rj3/8ozX9+c9/3pru6OhAZ2enyLhZX1+PUuDEE08URulf//pX7LPPPuMyBlb0GIZhGGaCMHO4BzMjPVhZUY8k1+RimAmHkdCw7o0KRPoCmLHNAMrr4+M9pAkXn0dsuOGGwqi7/fbbsemmm6K5uVnE21Hiky222EIka4lGo579UekEKmxORc2pD0ro8oMf/EAkdCmUb33rW9hxxx1x66234vHHH8eEMfSo/gNZpxdffDEOOOAAkSaUgg2pXX75SNCoH6gY4Le//W0sWrQINTU1QoLdbLPNxDzKmFMMPvroI9x000046qijsMEGGwhf3srKSjF9wgkn4LHHHvPd13333Ydtt90W5eXlmDt3rgj07O3tdb2BzHND7R//+IfnPsx1C6nbwTAMw0wiDAPzhzqw2cB6rA3XYUV5gyVpkeJjtmK8/JebrW9VS2Nbj2Lv0o3i8URMnrSNar3M/nyR7sgssyAStbjKfPK2eSiqLsevWk8+JxRbZ7aslIhivuL6kRKXqcap9ptUNOW4DPemwkyUkhnLZzZrPV1q6fXl9bQiNRXyfvw2SmBUjGYda8Cj2c+DkdTR+nYVhnuCmL71AOrmDEML0E0grZNuheB1yce7EfQMLTczrs2J999/X3xSfB6VLqBsm5n2wgcffCAych5wwAGebpNUzHz9+vUiaQupgmRIUrZMcrskI7IQ1q1bJ0pAkN1w+OGH47TTThP1/sguWbFihWcbN9fNGTNmFGXndAK/+c1vZmXEoRNA7Ve/+pWwggsxeE4//XT85je/US6jworUqJjhwQcfLFKfusm9V1xxBS677DLrb6rR8eMf/xhPPfUUnnvuOV9+wpdeeqnYF8MwDMP4pToRwQZDnVha0YhlFY3Fd/FiGGZMoWRErW9XommTYTRuMIT6+cPoXRdG75oKJGJFcrjL5wXKWJEeF4kmMvSc7SQaUQIW03D773//K4xCskluuOEGfO5znxMizKuvvorvfve7eOmll8Sz+Ze//GWbu6cJKYLHHHOMSJRijuHTTz/Fn//8Z/zpT3/C8PCwMCJJeKGC5/lA2TzNwudUKP3+++8XzQ+0XTweH/8YPTpRVGOCigLmAmXJoRNIkHFFyhhVsKfsOK+99hquu+46LF++XFwgklQPOeSQvMZnSq+NjY047rjjhI8snfhgMCj8Zn/yk58Io5KUNrK2ybJX1dygNwg//OEPxU1kKplkbZPhRv1Q6tRrr73Wczx0A5IaesQRR+R1PAzDMMzEY8sLPEopeFCVSLkgrSmvk1LRF2t06e5ksclv31aMlkM/LvO8C6Znb6wqr+CellOud+C1HsYGtwdvZVZNn+vl0mc+mOfPVu7ALA4u3wCKID1VSQa/Bcq94uAKitvLw6DKZzzmPLkUipinoWNJJbpWVaBu1jDqZkZQP2sYfW1hdK+pRGw4OOlf6qxcuVLUvjMJh8OO6w4ODgqDiSAjj7zznnnmGeG6abLXXnsJAYYMuLfeeksYba+88gp23nlna52jjz5aCEGmEWay00474fjjj8ff//53YQSSEEXKID2z5ytymePNnB4r8jL0yLjZZZddRGtqahInmYw0v9CFItdMgtw1qXI9+dPKJ5oCLMlPllw7v/71r+PDDz8U/rO5QkYoKYd0QTNvHtrPKaecgs9+9rN4/vnnRSPXTJJWM6G3AfQm4frrrxcqJEHj23333YVPMNXw8DL0yPe3vb1dnD8yKjNvMIZhGIbJJJyMYc5wd8m+mGcYpjASUR2dyyrRtboStTMiqJs1hNrpEQx0lqGrtQqR/tyffydKeQUy8mRDzw0SW2RIDJKNPBMK0SL3y8MOO8wSl2RDj0LO3KDtSFmkWD2yWe68804h8uTK3XffjfEmL0OPlK1CoIBE8oclvvOd79iMPNkoIsOJDL6lS5cK98pTTz01533dc889rsvpbcBtt92GrbbaSvxNlr/K0DOVwUyDdvbs2SKm8N133/Ucy4UXXigavWF46KGHcOyxx+Z4NAzDMMxkxp4ZM/Wx5cBahJNxvFUzG1E96G/7QhMM+sz+aM40JJVDmRFSWa/On+kqF1H3EjPNdW2xTapSf1aSQ3kMWvZyXyNUC4heh2fP3pm/kifH/VnTfguZ54MqhapyPYfK6rLgl1VHz6daVmgiIr/ZMt3UuVy2Se/PkD3GFMXRKXavZ00letZWoHp6BPUzhzBn8y4M9YXQva5SCA5TGfLGI2OP3CoJEmqc2H///cX65P5InoK5ctZZZ+GSSy4RKhx5++Vj6JHINN6MS9ZNcl80cYtXk5eRz+xoseWWWwrDkiAFUcW0adPEJ13szEBLcv30I+mSMkluqAS9KZjqX1iGYRjGm55g6i12T9C5KDDDMJMIQ0NfWwVWvt2AtYtTuSNmbtIjwppy76tEW57IMX3ktecEGYTN6Wd7U1zKBXruN7cvRgbOKWXoUZ2LTANKRXV1tVDciFxjAHPFTMEaoFouCihjp1mc8Uc/+pEI8iT1j94YDAwM2Gp5OEHHctFFF4np9957T6iUDMMwDOOWBZKybJYZCTTF+pXL5SyZRUfVuaXCkEJhNkNqI/NdM3bm8dCXmWEzKymjdR5HOh9ZlpUKM6Pz3LNx+s52qso66tKfvFydsTOPB2a/mTbzwSvLpVtWTnlaRpl5M91HoZk2rTHoubc8snOSkifUvIAmtcBIS/dtZto0pOMd6C3H6o+asOqDRkssmMrIXoCJhHvR+UR6OSl7+TAeMXWTwtCTs1O6pT0l42toaEhMd3V1CfVsNKBkKmaJhM0331y5DtXBoLhCGs/3v/99EeRJxh0laSFFkOLu/EAJaMjd03SB9bpJGYZhmKnNQCAsVL1Zw86lfBiGmdwMD5Thi1/8Yl4xeqXa8oGSrZhQlkwn6Lm+vb1dTJvP3blAKiCVWyBmzZqFicq4GHoU02ZCqU+doOQosjVdrJoSmVxzzTXWtJsyR8UXqdwDvU2g7KDkrkmJWegYcgkkJUORIJdPv2lWGYZhmMmBJZDloCCtDtehMT6I+vig+zZWn7JyVZyMkrJSZzbbMSj2nWs9PmU/boeaodBl1dPLjHnMmDeqaqgXHqqcUnT0qSDaVEA39a5Qdc9v/Tuluue1nawCZih5XmNQKXGq5fI8lRqnUgTlWndppc7WTFUuMNIsFU8aj7zcCOqiQWqWCsjYoIyZZjLDv/zlL45nh5YZ6ft6zz33zPks3nHHHdb2e++9t+u6lKGT8m+MBhSPSPYHjScfxuUOOvTQQy0ZlerQya6cJpTSNFMl6+vrK/pYzHoZxA477OCZIOWrX/2qcLsktXHt2rW4+eabXWvvqaAsQfPmzbNq8xWjTgbDMAwzeVlfVoOeQDk26W+zu/AxDMM4Md5xeKMQp7fBBhtYogzVv37yySez1iEPQMqYSVDG/jPPPBMmVD+bPPncoPIKVDbNFGjk7VU8/PDD2H777XHkkUcWLdSMFEWqD0jH+3//9395ezWOi6FHgZRmDT0qOk4lCqhSPBlyZLmSknfggQeKsguknJmYbpzFgko2mBePUrFSYfWxKHlAN515A1LyF6/MoAzDMMwEJ4/4L/v2GpZUtYh6erOHu/NTBvMZg0oZ1EeaSuWzKX66IVohypkyBk9qtrg9l2OwjaFIKmex8B3rN5qxd6MRu+eGSrFTqXc2NdBLOVQodSrFziVuT6nSZSpwmUqdqilURdu2KmXQo+8jD7g+15Nc4i0/qNRZS0uLSGpIpRC+973vCe86yq5JnndUPo3sC4IMNtl1kww9Mso+85nPiJwbVAng9ddfF9tSqbQvfOELom6embvjxhtv9HT9pIycVMKNbBnKzk9iDmXZp3weZj9+oKQvZItQMkpKNEN5PVpbW7HHHnvknam/4ILp+UInjnxrH3vsMWFwqQqIU7wcnTC6aGbNvWKxZs0aUYSdjEsy7u666y5lmYfRggxMKh9B5+Cqq64SJR3yqRNoQvLyZAganYyY14avz8SGr+PkYLyuYzFsioFguSiYvsFgJ9aX1yCi+CdcVV5B+f5SsrgogYovFJbISCkBzfe2WsCwfcqvnTM9Ld3mKb0zzez7Xofi0reffec7z7ZccY3ymieXtlAsz+/mU9wTxXoRbnaja6kuA4BG7opGniUOVKUSFNvYSm5Y26o21YpSasG2P/P+lubJbpnKahFadj/K0iVTkPnz5+PRRx8VbpxkHNHzdGYtazrX3//+94XBpeLFF18UzS2B4k033YSzzz7bczxkTNJ69HnvvfcKI5M8FqmRYEUl3LbbbjuRgLKhoUE0Eq8o/wi1JUuWiIoEZnZQ89+nRYsWCWPUrAc4oQw90/KlYoK33HIL3nzzTevAqAj7GWecIZKVmIXVCToxxYBcRQ866CBh1RM///nPccIJJ2AsIddVck2l41y+fLkoxkhuoflCSW3YkChN6Lr096ey5Y2FYsyMDnwdJwfjdR1nVpW517ozH+rkjRTLh6pmoaZnDXbCED6taEptIz0kGunE0YZsRJl92+p2SdsUcBqsTeWBJ91ryhlpR51kUK6tlprWpSdZU6Gz1dGTPlsQTvUjjT+ZfmJOKmObsk+AfA/oCuNJkxJx6+ncadqIoxH0uH2ZWG7Ok6IytPjIMQTi9vXEvFj6WBMj6+npebo0T4ulzo8WHzlPujSNWGogWlwakDVd6MuNQr4v0r7N4ZKIRsWrWyqggZJzFNHQU43Ap6HnbLzlZujZVrf2ozb01P51Wtb3MxZDbhRYymBUKXBcpNpRDetf/OIXIh6PPOTIK5ASp1BM3Te+8Q0RkpUJzbvvvvuEkUcqHoVhUdIWCqMiO4OMK8qoT2FWbpUBVN6KFEd3+eWXC7uGDD4SlUjRI8Xwf//7n+v25jM8GYYkfpHhSN6NhTJuhh6h6zq+9KUviUbKGsmT5EI5c+ZMsYx45513UgMNBrHJJpsUvE/aD0miFGdHkPVN9e3Gg1NOOUUkglm8eDGuvvpqofKRL3A+1NXV+U4Iw4wt5peXrhEbehMXvo6Tg/G6jmsHov4MPQclxjTS6DORDGPTjnUYQBA9ZRWWcUckVYaetK2StKLnafAplUHFajbLKz3P9pxvZBl6WjJljAQkK1FLT9tKDZjGX/rvNRhCQhp4Mn2QckY/KkItPuOSghJLG3JxSS2RpvX0cj2qMOqkh21zWjbqrHm29SRDz9pGmhc1subp1jzJqIsmbQZfqu8Ro04zDb2oNKBYerpYKnY+3xvVvrWUokcGWOfawdQqXn17qHc5G3M5qHTKvt32YVuuZ/dB7pg+kLeJJ1KFwpkUlCODQqHMcCg/1NTU4OSTTxZtNCBDk57pyVuPQtGefvpp4VZKbpxUjk0F2TeUMIYa5TEht9RiMa6GXuaJz3TNpLeuZhYbkj3JCCwEkkkPP/xwq2A71cTL5eYoNlSzjwqn081G0vPtt99uUzBzgR5Y2IgoXczrw9doYsPXcXIwHtdRfsx1e9x2WiYLY6vLazFzuAcLe9bjleZ5VClOuZ7fvv0uLxaFjDFz3UzBQtW32/5yGWMx5tmWyyqnkds8m0I6Gieg2Hjc9L5DA408FhfpuF278fnlMvIYl+1S5nosk1jRK3U0TbOMNxNy02xraxOehSTskEFHrZDQrQlj6Kl46KGHEIlExDQFRxYCZfGkQMZnn31W/E3JYCiYc7whl1FS9UhhJP/is846a7yHxDAMw5QCKjtUBKVp+KhmGnbsWok5gz1YWStlflaphaoHqzzUO6XiZwojsuEhxfyZtrQhqXyW2ugz+4jNdVNS9DRh4hr5Gex+NxmjdwHFLu9gi+sqbtd2ayOvcy+paen72ZqXT7ydzSPXp0Ln1qeXOpdjrJ6t70AeaiEzaWhIx+eNJSVboIMMPDO1KSl5FMuWL1SU/KSTThKZdYhTTz3VSvAy3pCLKvnzEpQ6tVTGxTAMw5QufaFyrKmoxYZ9HQgluEQPwzAK5FSzpdiYyWvoUeCjU7kEMvLIGPv444/F32QIUXFyFfvss4/lgmMmV8mMxyCVzKyVR6oeJYApJRc6GtM222wjpq+77rrxHg7DMAwzxniWSlDM+6S2WYh0i7pahVyX03OTrZ6V80OX8plMLrlglk+QmnwM1vYBw2ruGdfl4ufFS/RYFFTXZSIwmifSr8+l34LqqpIDZgFyqQi5YxkDVcF0VdkEt1IJHoXX/ZZeUPVtOxapjZwnj8YwY+G6ScGFphFGUHkEE8qemVkXTqXGPfPMM8IAo4QkBxxwgMhWMzg4KDLg3HbbbSJBCXHUUUfhvPPOQ76cf/75wrAjttxyS5Fq9YMPPnBcn/xkFy5ciLGEjE7KMErHSgYwwzAMw3gR0wN4t2Emtu1cjYXdbfiowX+GOIZhJj9jWRYxV0p1XJONvAy9X//61yJtqIpHHnlENBknt8vu7m6RFpWayvg555xzcPPNN4uMm/ny5z//2ZqmNKyqVKuZtTlUyuBoc+SRR2LHHXcUhi7DMAwzuXj3+nOt6UXfvSk14fGG3i0mzqQrXImPGlqweVcbhoIhLK+vy1ZvzJA4j75tcXbmhKrGniozqK1cg5xiM53d0iM+UFVKwW19J6yYQP+bMKOFqgCgHIdnxuiZSp5T7J1TP4p5rnF2Hv0UUn7BM8YuHzUuj1hAhimZZCyUheaGG27Ak08+KRRBKhJI8WpUfX6//fbDF7/4RWH4TCWuuOIKkVaVYRiGYfyyqroelbEYNu1ux7ShfixubEZ3ZX6lehiGmURw1s0pj2Zwle0JTW9vr6gHRQXTuY5eaUJfMbo+XEdvYsPXcXJQCtdx0UXZip6lsMnFzxV19OTlVs289CvbxuFB4cJZE41ibXU1Pm5oxKCctlu1P3m+pN6Zy22198zlSkVPlgOlFcxyb7LEFkz/USbVgitL1X/Tpdp6enp/mpzFU/qciYpUHb3EyCAT6Vp5RkJSedLLjVgOdfSiWnYtvGLX0YsVv44ekuby7Np6SEiF1fPBoRaer3m2avQj6h1NNs2sREeroo6eotadp+rmUh/PMVOny7iV+1Mq7R5ZN/1mxPDoJx4fxrP/vdLzmc98Npxz8xXQK0rzpU9yaBirvnUpP7+OMiVdXoFhGIZhGH90llfixVlzMau/Dxt3dWDP/hXoDoextqYGa6trEAtKldUZhmGYSQ8begzDMAwzhrx3bSpeb9H30soe4SMej/DKrGnoGlbX1mJtTTVaBgcxq68Xm7a3i7aupgYfNjcjFnAw+OTOzZg5VdxeZgbOrLEa2UqOrc5eehObEpP+UKmFeQhNhk0O9dePz7J+DoNQTOfTn2obhRCnOWWyUClaVg03hayUzGGQXkqdy3qOsXc028ycaRQeb+eq+Hmt51OpU6pznnX0XBf770d1vt26SyexLUVKdVyTDTb0GIZhGGaSkdR1tFZXixZKJDCzrw8bdXVi98FBvN/Sgtaa6vEeIsMwDDPKsKHHMAzDMOOA6i2/45t/n4qfCnLZXNFQj3U11diirQ3brVuH1QM1eGf6NLuCYGS/bTe8XsWbgl1GKTDXjqxYv+ze5aybygycXrhsYuuuELUtj35U+9aSo5B/Pr0N1XazCKTj9qRQvpFlxYlT9R07J0+bip6WrkVnuGyTMc8x3s5NTfRQ7PwqdepsuMXJumkUWdHjZCwMG3oMwzAMM4ZYLpsebop+3b38lGEgosEg3pwxA3N6e7GorQ2r6mrRVVHh3qnKd1PaoSiQnrGeodi57VAVJRus51sv11R52tCU+8oFJ+PP8kgtNfeyfIw/0zjKJ0TTyxh1M4683CtpW+G6mTY4Mw/NZ8mFrILjDuPxMuR8G3DK76rHfagXydDz7QPKlAInnHCCqCJw4IEHjlvyL795gBiGYRiGmehoGlbV1mI4EMD0/v7xHg3DMKMJGYal3CY5Dz74IA455BBRo/uSSy7BJ598MuZjYEOPYRiGYcYD4bamUPYy52XO13ysp8B6vtI1rK+uwvT+AU+FyEzmIJQtqwOFS5htTEZWI+XPbNYmmmG1omeNkMfoNu4CURyqsnnuu5Bx0TU0mzUuw2opF8k8W8CjkYuoU5P6MaQmnjyFmmcWSpfWIxdOswU00eT9jSzXrAa5mf0EFE13b1A05bqBPJrut8G1PfpwKpETMzFoaGgQJX1WrVqFa665BgsXLsTee++N3/zmNxgcHByTMbChxzAMwzBTjNaqalTE46iJRMd7KAzDjBZGibdJztq1ay1VTxdxqAaef/55nHnmmZg5cybOOuss/Pe//x3VMXCMHsMwDMOMVZF0h1ghv3F2Srzi2pTxeqmArepYFH3l4dz2lw+qeERlrg1F/J5Td2aeFzlm0JqW56Xn2EouKLLIeCRZKVbcnrW9R0ygcj9eBcrNZCzSPGtqFGOE8knGIrYRCnNavXMqr6B5xNt5JUxxScbiVUTdbxkGTy/EIpVf6Ovr87ei1XEJG1SlOq4iUlZWhuOOO040Mvruvfde0T766CNxLe+66y7RNtlkExHLd+qppwoDsJiwoscwDMMwUwnDwBbr2zAQCqG1qmq8R8MwjA9qKgZxww038LmaoMycORMXXXQRPvjgA7zwwgv40pe+hJqaGqHyLV68GN/73vdELN9hhx2Gv/zlL4jH40XZLyt6DMMwDDPa+FTsnN7s51SKwWPZ3N5eNAwP4+XZs0W9vVFFU2Ta9CirkLGpjUzRTSh4KlXOo4C5m6rmtNxv3677E/MNZ8XOZwFzpWIn/jAzWrpnQS06Hkqja8F0EZuWLq/gU71zLkOSrd65FV73ytjpNxOnt6LnsdylbIKuJTCzoRP1Vf2YO3cjj44yB1bCylmpjmsM2G233US7+eab8ac//Ql33303nn32WWHcPf7446I1NTXhlFNOEW6eW221Vd77YkWPYRiGYSY5ejKJlv4BbLmuFZu2tWNVbQ26Kh1KKzAMUxJUhQex8YzVqKkYwOqOZnz5y18e7yExRaSiokK4az711FOizZgxw1rW3t6On/3sZ9h2222x55574rHHHstrH6zoMQzDMMxY4jceLwchhrIrBpNJBJPx1KeRRDCRRFkigaahQTQPDCJoGOgPhbC8vh6fNjbkvB/XIuoO47aUPEWMnrKeno/aeVnL5VJ/VuydvIJqnqrzbGUwH5VvJN5OHpiiH6eDyBqD4V/dswISi6TiKeL/VMtzidGzxd6JGL20omX4UO88YuZU6p1bwXSvvn3HzioUuZyqB2Ssq2tJTK/tRFN1H/qHy7G6uwWxRDD3WmylXMagVMc1hgwPD+Ohhx4Sit7TTz8t3DipERtuuCFWr16NSCQiXD0PP/xwHHXUUXjggQcQDqfjqn3Ahh7DMAzDTCDoYb4pMoCZQ72ojUUQTCaEEaeC5vaGw8Kwa62uxkBZ2ZiPl2EY/4SDUcxrakVIT2BNdxM6B2pGOVMSM9a8/PLLwrj7wx/+gN7eXsu4q66uxhe+8AURv0eunT09PcKwI2WP4vgefvhhXHfddbj00kt974sNPYZhGIYZZXzH2DnGHgFVsQhmDPVi5lAfwskEekJhrKmsQSykI6YHENd1xII6YoEAYgGap4t5XiqIesA+11MNVZlhU6rxllbyFIkYvclQ08TzkVJhk1UuxbbZw/Ide2dT+dz68ZI+XVQ8T5xiOUcz5tJLtctYzzH+TY69S9d1NLNuemXL9FIOVerdSCJWr+ycBSh1RcrEWR0exLz6VkQTISxpnyk+CwmyKnZ5ymJSquMaLdatW4ff/va3wsCjrJuEaeDtsssuwi33hBNOQJWUIKuurg5f/epXcfbZZ+PEE08U8Xz3338/G3oMwzAMMxkIJBOYPtz//+x9B7gkR3X16Z48L+f3Nudd7a7CKiEJhEACTA4GYwz+yUkkAxIZgxBZKAEGiSxsbDA5mmQwCIRy1mqDtHlfznly/9+t6eqpnqkOM29e3Dr79U6/6q7q6ty3zr3noisxgYZ0AildR1+sHj3xeistghEUhDfyWROUV5SCwjJDc3wcq+qHMZmM48RYO3KyPCwKywqZTAY///nPmXH329/+Ftls1jLuWltbmdgKGXg7d+50bScQCODKK69kht7Ro0fL6oNi9BQUFBQUFBYSPkb/G1Kz6EqMoyM5Bd0wMByJ4+HGTgzEamBoPj4A5+rpVWZ9GzkhUdgU4/EsRk/PlZYJw/w586DI8+Tl5/lU3HGRLNN8snxVV90Ue1VBjj4r3k6i2GkrCyyeW59rnjkxLs8p9o4zejQZc1fLlLF3rgycwNjNiamboxJne80oOmtHMThdj96ploIi6VyhVDcXPaXCyMgImycDj5KmP/3pT2eumRRvFwqFfLdFKpyEctMuKENPQUFBQUFhCQmw1Kdmcc7YScwEQjha04zeWB2SgZCzKIrti1JmRXj0jdtb0mYkhZW4XEncNG2K++ZOyYw6IyeWCb3JmYaesFxqeJnLNVlZzr+B5pbU3KvMZlDm3Nw9fR5c2y57nGAvhRu/deDTwBHTJ/AyJ5dMzTS2NOc0DDKjzklEpWDoCctNY87LkKvIgHM5Tn7bqwvNoKNmFH3TTeifaVZ6+CsIw8PD7HfdunUsTQJNNF8Jmpub8dGPfrTsesrQU1BQUFBQWEKgeDvCgfo2jERUQnMFhZWKoJ7Buvp+TKZj6J8RlHAVVgRe8pKXMNdMYvHKVkwtQlNTkzL0FBQUFBQUljq8mIXZQAgZTUNdKonRUI2NBRJd4DQej2drXNa2B33DP0A8xUM8lkvb5psQXTdzJe6cUu0XQ8bi6e6uaRZT587yWUye6M6Zk7BuIuNn1fEp2iK25zMlgydkqQIq+X6soI40ZMyN8XJ0rywuF8VY/LF3jqyajL2TtSPpf0Wum+W6bBZd4Ovr+5mL8rGpDua+KjveWhYVQ1vCoieL53C8cPj+97+PxYaK9FRQUFBQUFhK0DRMBSOozSQXuycKCgrzhK7YCGqCCWbkZbmKksKKwmtf+1oWj9fb2+u7zuDgoFWvGlCumwoKCgoKCvMNL2agiAWaCkTQlJ61RvMLDJTQJB/pl30jShKBG5IE5awd3g9pIm9pFUkjkpwDApMn6scUYvRKG7frjvAYPd0xOTqLzxPj+mTxb7IYPQnr5j8RulCWK1NExSmGL+dyoGVxZIsgwOI35swt3q6knE5fwBRkMcpg75xEVPyygMXtVZPxc6NQzPXrg9PoiI+he7YZU0bMuodl27Bdo+VCJUxfVNxyyy3MZfOKK65gwix+QHn1eL1vfOMbc+6DYvQUFBQUFBSWGIjRi2dT0LnloqCgsCIQ0jJYHx/AeDqOgWTjYndHYYVDMXoKCgoKCgoLCc5oSWPG8j8TepSttnlqGIeirVYlcXTfMN/gtrKK4ug4xVQar+YpES9FaSoFWcJ0e1oEny2LCpwU28UYC3EFc7mwnrVpsUzGkLqcD9u83xg9pxg88yRpbiyeE3gMmgNbWNigtkCsdPkpEArLTUZPc2L0XNg7JybOhQWcK2Mnj1F02C/H7RjYEO9HDjqOJiguT/es68TE+4JKr7DskEgk2G84HK5Ke4rRU1BQUFBQWGKYCURwMNqGNakxbEoMV2jBKSgoLCWsigyjJpDAkVkVl6cgx2233cZ+Ozs7HdYoD4rRU1BQUFBguPDl11lH4vb/ukIdlSpCHKm32CKZKqNgz/UFG6GHDWxJDeWV+cKUSFmoY+bNFUkBzvKJ7XAbUWSVRHbCUryUsCS2Om47KPbLljCd99GjIRmTIVHdLKlblEdPdmzlrFspQ+qpnCmNx5Os58b8Cctt1wRnrXKyeDz3nIfzoaooTYTuxtpVqk5pJUw3z7Nf9s4xR5/ztn0zdg5k6JwSpWtAY2AKnZExnEy25OPybHGL8m269ccXFKO3oLj66qul5V/+8pfR3t7uWjeZTOLQoUP4+c9/zuLzLrrooqr0SRl6CgoKCgoKSxQ94Sb2PbgpNcS+2Y5HWha7SwoKCmWiLjCDjdE+jKRr0Z9WcXkrFVdddVVJvjzDMHDTTTf5boPWj0ajeO9731uVPilDT0FBQeEUwgX/fD371dOG60i2yO4VVjRXE1mHQOmo9B3/qdjAYoi5sAoxY6VlMoapO9AEPWRgQ3oYOU3DiUiz8wnmSpUSFUwn1sAI8I0LhfyaMCTrBYV4u2CpWIwYe6f5le202DtRQVMvjcsT8+PRLG1eLJPk0ePzMnZOmlvPK0bPgy2UMn8V5EKz7ksb9cfbFnMQagvD6PmMdSu0UVrXBmLvqFwv5NHzzd5VEqPnEWMnzf8n2x+/cXkmavVZbI72YiIXx5F0ab48r/qVxckWrsElm0dvifZrriBDjYMbfWKZE8i4I2VOYvKuvPJKnHnmmagGlKGnoKCgoKCwxHEi1Mw+7jel8sZed7hpsbukoKDggbiewNZoD6ZzURxKds6LUe4K5bq5oMjl7ANfuq4zY++RRx7Bzp07sRhQhp6CgoLCCsf5r86zeOJgtWuuJw941eWsIeGO77y78g2tVEZPluvNI26NRvWPhZtZ/NuW5BBjXLpDEhcwWTyeZ+eKGDuCyYLZ6gZLGb1CnJH7VuwD2ibDJnSSM3k5G3vHfx3oGzM+z8aCypi4nM94OwlTJ4u9k+bRExU0rbqlufO8YCfvJOyUFbg4vwaDG2vnmU/OL2NlxeiZE2P0qhSjp/uL25P20StGzyejF9OT2BbuwawRwWPpLuR8KGyKsK6Z+VBQVVgQrFu3jhl61VLQrATK0FNQUFBQUFgO0DQcibQwd8itiUHkdA290YbF7pWCgkIRIloK28M9SBpBHEx1sXQKiwLF6C0qjh49urgdUIaegoKCwsrEua8vZfFs8zaWYP768YT/l+/Hnf9xajN7uhijJcuB7hl7ZJYFNByKtTJjb/vMACiMrScsMfYqOacioydTWDSZPLuqplkmiQn06ocYj8eZPGk8nnggbDF6Wv5vaTyeTIlTbKdomRPj51EmzZknYxU9YKmcBsT9N5xXnOf4JlfWzoux8xvDpgkxevocYvR8sne+++h0D/qpS/nPkGZGXgY6DmRWI6MH3GMfnWCe/3kmbxVWOBSjp6CgoLCCcM4bbyhNfi26yEk+hPis7IOikoB52QfV+a8qGJ53ffvUM/psAjZWobgCXD9GrY9Z9qvh8Zo2ZnDtmBpANqihP1afr8I9+8SNu9gLTjC4yIoorCJLfs4NPUlKBVt7dv/DkjLDzdATj51oZJGdkCsqkwnd5EqNbZkgjqyOzL3W0yCs5J6RiN/we1jWns0I9Lu9cgwGN2PO0xAq03VTK8N1U69SwvQqGXrFhlsIGewI9rBTsi+7Bmnd/pldjtHGz3tuDl/qp4IYS3d3N77xjW/gF7/4BWPQJicn0dbWhvXr1+OpT30q/vEf/xG7d+92rP+b3/wGX/3qV3HXXXdhcHCQ1T3//PPxxje+Ec985jOx3KEMPQUFBQUFheUGTcOBunb2zblrrJ+JPAzE6ha7VwoKpyyCyGJHsBs6DDyaWYO0pj6x5xtf//rX8e53v5sZdyJOnjzJpttuu40tu/HGG0vqkhLmm9/8ZmbkFRuOP/nJT9hExt7NN99ckjKhGJdeein7pfX+8Ic/lJRXguK2KoW6ChUUFBRWECwXMEkZK5e4QxUpZVS0vZI2FWx46Pp3WfOnX8FZV/9sAmcybInOAxr2NbQzVm3XWB9T4xwI1ZoLxZPkcTJcTpstfYK5bZG94/Oa7n/YnjN5MvZOJrxiT4huslzsPw3IkhiLzHVT2KCEGXRzzfRcbnPTlFCokvtJyqALrJksiXpBeKWkOTtjP1fWXQYZCybZthvj5bgNmy85T5gucd3Uq5Uw3WdZ0bL8cpmbQ2l/Ashiu97NjL1HjTVIBEKOdfyCX/f3fKvw7JiYmCizEZMyXYqYY7/IeHvXu95liZ6Q0XbBBRegvr6eGWsHDx7ET3/6U6Z8KcOHP/xhy8jbs2cPy1u3efNmlrT8mmuuwf3338+WE8P3iU98wrUvf/rTn9hvsUFI5VTmJ70CB1/fy7j0C2XoKSgoKCgoLFdoGh5t7GCpF04f7cWDwS4MxUxjT0FBYd6RN/J6EEUaj+bWIKEtnsLiqYI777wTV1yRz9f63Oc+F9///vcRi8Ws5eeccw77vfLKK5FOp0vqP/7448yYI5x77rm49dZbrfrnnXcenv/85+OSSy7BPffcg89+9rN4zWtew4xAJzz5yU+WGmZO5QsJZegpKCgoLHOc/WaTIfJi8Txi9BY63YOMsXIcTZeNwJt17rupMOK9LFAm68Cgu9QJaNjb0gl9pBdnDvbh/o4uDIXjJXXtfZAkVBfWc2ToHBKiiwPWtu8ai2I25k9RUJJKwSuBuSzeznc7HonuC0ydwHzKlosHTXZ4ZMIrvE5pyGNF8GLdvBkv+/r+2rbPM9IpwGP05powvdwyf4xdSb/zS9GuTWAthtl9sB+rMaNHfAu4wOM2qYp9sEJVNy+//HKWs47i8L73ve/ZjLxihEJF7CqAG264AZlMhs1/8YtfLKkfj8dZ+YUXXsjWI/aQ/vZi9PyWLyQWSe9VQUFBQUFBoVqgD9aHm4nNi+OsgV40z8yog6ugUHUYiCGJToxht3YCm7QBjCGOB7EeU4iq470AuP3225lbJeE973kPampqyqpvGAZ+9rOfsfkdO3Ywd08ZqHz79u1snlxAy3G/XEpQjJ6CgoLCMsXZl5cyeXI1OYGBMYeMbbFeMrl/GapN/ZXRnluy4j1vEY6Dufz+Ly1dlu/ha/N92/3eQr99MyfieSti4kiQ5YHOTuzp68XZvb24Z9UqjMZjMMw4OpsMvW3e/ICRpE3wYo44u8eZPYfVoAtt2xU4y4RNldLeVXHeFrcnZctK27MxdbIyWSJ0vlxynMQYPFsyeqtQPMGyPsri/2Q3OKoCbxbMhbWTdcsxbtM+z9i8shOml9Nvnx4C0nvQYC6Z9ZhBvTaLBswihCxy0DCBKB7GGkzpdjaokpQMhUKP5WViJapu/uAHP7Dm/+Ef/sGaHx4exsjICIupa2xsdKx/5MgRFsNHIPdMN9DyAwcOMGEXUvTcuHEjlhsUo6egoKCgoLBCQB+zD3R0YjQaxTk9PWicnV3sLikoLCtEkEYbxrFZ68PZOIKztGPYiEFEkEE/6rEXq3E3NmEfGXmas8vgkoCxxKcK4/MImzZtYkbdV77yFca8tba2Ytu2bWhqasLOnTuZu2UqlSqpv2/fPmueGD03iMvFetUGCcDQfvX391e9bcXoKSgoKKxAFs9puRUL4jFSPxclTr99KKeOXyxVgTkZPPN66e6qm1bcXlHC6FxAx31runDuyR6c09OLu9d1YTwWtTN2IsPGlTNl/ZEeT4F14YyWGN8nxqbN53CyTFFQwtS5sXcyNlBc7hW3J3bFqlu83SJ2r0D5Sdr2GaMn9tWLGSrtmEddpxg9SSynrO1ycutRKWPzSGlQK4O982T0fLJ35m8QGazRRtCIaUSRYYdvGhEMoQ7jiGNCiyHL1Rv9HscynstWO8J1cN9Xlq5XQjVRrCQaiUTY5IRHH32U/VJ83ite8Qp897vfLVmHjDJS5Pzxj3/M8us1NDRYy06cOGHNr1mzxrVva9euldbzC8rLxxlI6qvYDy4KQ3n+HnjgAfY3Cbe88IUvZGkj3FjJcqAYPQUFBQUFAQbCWhq1gVm0hCbQFR3G+ng/1sYG0RkZQXN4AnXBGUT1FDTp16nCUkBO13HvmlWYioRx3vFe1M8mF7tLCgpLEAZaMYEzcQwtmMQoarEfXYyxe1hbh2NaG8a0GuTmdcRiHmG6bi7FiQ9GkDFFBhCfPv3pTzvuDgmwjI+Ps/m//e1vzMjr7OzEf/zHfzC3zZmZGfz5z3+24u7+8pe/4PWvf72tDTHnXm2tu0KxGP83NTVV9uH/0Y9+hLe97W1MyKXYyEsmk3jWs57FjDyK/6OJ9o/y95GxVy0oRk9BQUFhGcGLsZLFPcgUOG3hQZqBuJ5ES3ASTaFJhPScRR6kjSBSuSBLAhwKZRDSs1a9rKFhNF2LoVQ9ZrI0AluG8p7j/lVAyUmqnPX2AvP5wBeX5sj43s+W9mvXB4S4PRl7J2U3RHauUJYNaLjHZPbOO9GDOzd3YTIWcVbYrCghW9Eva6f8Znxtw4k6k1xkUoVNGXtny7cnqSOL0ZOwabJQRluZrYv8JhQ7VLILhYZyHiyfrY4ktrJcVU2xi0Vs8Vxz69m6KmyDxek5LPdm9Mpj7/hyctHchAE0YgaDqMMRrRUZSnLucEzc4hGrxfI9dOPSfFbNJ4gpo9x3HG5sHhlyXBSFDCVSxyRlSy6awlMa/PGPf2SKmQ8++CB++MMf4q677sL555/PlicSCWvdcNg9FYbYl9kK3OB/97vfMZbuxS9+ccmyW265hbls0nJK53DZZZfhf//3fxkDSQYqMYFiDGKlUIaegoKCwikKyv/UFpxAa3gSsUAK6VwAI+l6TGZjSGbJwAuVfK2QW15QyyCsZ1AbnEVLZJLVn8mGMZRqwEi6FlkEFm2fFOzIBnTcvb4LTzjag/MP9eLOLaswFVV5vhQUdqKbPc/2YRVj7ZaT2/dKSq9ARp5o6LkhGrUrmxJbJxp5HJQu4ZOf/CTLsUegFAzc0BPbkMXwiSBjUmyzXJCQC4FvWwR3Ob300kuZqifh7W9/O57xjGcwg4+WK0NPQUFB4RTBnreaTE8FSm32PHosKgYtgUmsCw0hgBzGMjU4mWrBZDpeyjaIg+VGXtkxbYSQzoYwnY2hL9WE+uAMM/bWRgexOjqE0UwtBtMNmMnJWT5pXyuI23P7MBOXnfkv+WP34OeX/mi5LC6PzctYCYcYPdv6ADJBHXdt7MITjvTiCYd6cceWTkzVhtwVNmWBZigvt96cYbGF4k4XZllIVwkNJFnPhb2TpBPMz8uWm2qbXvF41jkQi2zxei77JWP5ZHShk9e0X2vFhbFzbM4lbk9ax4sZE/5mrJ4PFsxi7zxi9PzE9WVyOqa1CEb1Gsf1wsigOTeFsJFBgFzryGFdI6d1DRktgIFAXYlbp+vV73BMHr5u6T+blgKCwSAz1Dgr93d/93eO6xJDFgwGWR48SnzOUVdX59sdc3p62rebp1OMHmHVqlW2cmIHKU0EsXlvfOMbbcte+9rXMkPv3nvvRTWgGD0FBQWFUwhhpLEhMIAmfQYj2RocT7chm8m/Ciob0NYwkalhUzCQZXF9rWzKs3yDmXqMZOoUy7fISAcDuGtLJ57wOBl7fbh9eydmoqWJhBUUThXMIIy4UcroRIw0WnJTaDGmUG8kmE2dJrkWTYduGMyNnaYgsujKjmF/qAuz+hJlyZcBo1cuKKbvscce8xRTIYOwtbUVfX19GBgYsMrFOpQ2wQ2iAIsozOIXY2Nj7FfnQj4mSGEznU6z8qc97Wm2ZTyFg9jnBTf0SP6TOsmnu+++21LN+ehHP4qrrrrKd1vHjh3DTTfdhN///vfMV5WsZ7K2SdKUghTf/OY3M/nUuSKbzeK//uu/GBV63333YXR0FM3Nzdi1axdTwnnVq15VciJk+M53voNrr70W+/fvZ/0itZyPfOQjjrTzq1/9anz729+2/v71r3+NZz7zma7bIAufQH0iH14FBQUFKxbIp5qejGFoxiQ2B/uZ0XUw3YmxXC1bZgkCio9Anh9NxhbaWIfCximery/VjL50E+oDM8zgWxcewprwMEaztczom85F5SqfXqiA8bOKTPbjrLfdwBZ31oXRN5UqJYwkbJmtzPx9+Pr5G31/9JOFtndcVZof0B63J2HiZDnzzOXJUAB3bO3ChQd7ccHBvLE3GxHcc71i9FzOAc/P6Lxc/Iv3u4guZksquDbm8iErU+d0WG4pZ9rUMg3JvePCxHlt2ytPniwGz+/++2TsnJc7l82J0dNFRk92A3u07YO9k5WRodeem2TPxZiRRtRIocZIotZIIQsNY3ocB4IdGNFrkNUCJYc7nkvitHQvzkwdx0ORtZjWI+XF6ylUBEqdwA09+rZ3Q9ZcTsyeWJ+DvuXdIC4/7bTTyu4rsYAkHkPGpgiKKySQDULpIESEQqGSPs8FFbVCCjfVABleb3jDG1hwpQgywojSpOnzn/88vv/97zMf1krR29uLF73oRVbuDQ468DT94Q9/wDe+8Q38/Oc/Z8afE66++mpmyIojAddddx0L+qTASVGdxwlkFHoZegoKCgrFgiJli7EUGSgkG74FfRjN1eKw0Q6DvqyKjQcPSXpZJ+Tf9xomsjVsCuoZtAQn8rGA0UnM5MIYzNZjOFuHjEcsn9+PI9l6gmZM6Yeeqcpv+HBjs+2eWXb6lfJE5498rroGoFd6heKE6bb+aPJUCilm7HXiwsd6ceGBPuxf3YTelpqyjG8vo64SWK6fEuEVmbCK098ywZTiZU7Lpe16GRkyYRUvow7l3m/ivOw4VXA+PNww3VwoPY0/aXsuBpyuMSPaj+uml7EpS/1grVu0jNImIDeMHdk+pKFjVgszY+2E3syMO+aS6WLUzugR3B9chz2zx7E+M4S90dXS9Ur6K8Hu9+afKY9cU91nyEpMmE5iKz/72c/Y/OHDh7Fnzx7pekRADQ0NsfnVq1fbGDNypezp6WEKnW649dZbrfobNmwou69EWpHt8Zvf/AbPfvazbWqcROrIErZzo7CjowPVwJz1YilhIR30ckFG3Ctf+Upm5BGT9prXvIYFI5IyDinkPO95z7My3ZMaDWWkrwTkB/uc5zzHMvIoyJHyahCrRweeWDPCbbfdxuRMnUYHKG/Hxz72MUYFf/zjH2f9/+///m8WBHr//fezMj8g9pMMSgUFBYWFQh1msR29GEMNHjM6F9SNkrF86WY8lFyPA8lVSBghrA0O4azIUWwM9qNWIyWzJfolskKRDAdxx/ZOTEbD2HNkCJc83I01g5NWDJqCwqmAKT2KO8MbcUd4E+6MbGas3GOhTgxJ4u6ckNV0HAs3oyU7g9psQc1RYf5AxA33fKNUBE6gZYY5CHLxxRdb5VT3BS94gcXY3XHHHdL6VM4ZPVqfb7MckP1BffjqV7/KvBf37t2L9773veyX70sxyD7xk+NvXg09YqV+9atfMUuZ3C3JACoXn/rUpyyjivJLfPOb32QH8rzzzmMypGQMvfvd72bLyZ3z+uuvr6Sr+NKXvsQMMcLrXvc6/Pa3v2UHlkYAKIiTXCNvuCE/kkKsHPVDBpI5pfwW11xzDT784Q+zHB0vfelLGRtI8q7EOnqBfIX58eMXn4KCgoIvaJLJJYc0nyJIYQd6MIEoDqIzP5Kv8QTF5sRdp+Y48X6J2y/0VcNELo5DqS48mNyA7kwz6vRZ7Ax3Y3foBNoD49DJx9Jj/2THxJafiZrIyfsg7ZdW2n9Wxs1PyXF3aqfaOPCRd1mTrI/sDc4mozCVLJO3nQgHcfe2DvzltC5MxsM44+gwnvJgN7YdH0XDZLJ8lkh2fS6Uuxo/WY4pByQT77aY10tW1elcF107jJFynYR1eZtVuu+8t+3RH7cpUJhy5uTZh4A5VbA9SKaKjklAMgnLc+aU0oNI6wH7eS5z2wOhOszoIazPDNu3I2xbtl+y7Zz+7husSUEOYuS4GiWFY9F3uIwVo291nkKByCQR73znOy3XSFK6LE6dQH9TOYHWo/UrAeXQ6+rqYuqeNH/GGWcwT0ACpX946lOfWlKH0iuQUSkapwtu6JFhRxRkS0tLxRsmBo1AbbzlLW+RrkMGEQclRqwEPD6O3CqdjEU6geQnS/jMZz4jXae7u5v9Fp8UonOJmuXL3UBWPIHyehCrqKCgoDDfaDPyyWEPYBWMJZL0N4Mg+rJNeCi1HvtTqzBrhLFOH8TZwSPYpPehForlWyhM1ERw35Z23LprFYbqo1g3OIUnPtqHy+47id2HhxFPpBesLwoKyxKahmORZrRkZlC31Fg9Y4lPFYJIF9LJIAKGUih84AMfYGQNqWt++ctfZqQRF1r5+Mc/bnPdJGzbtg1XXnklm6c6T3ziE5mXHs3TL/3NlTrf8573YOvWrRX1k5Kkk4Lm2WefbSVFp4mMOBlBRPYBef4Rnv70p2NZq27y3BVcXcbpABELRsyhmMvCL8gif+SRR9j8RRdd5Jqng+LmiEolf1/KUn/WWWfZlre3t7Nf8ufdvXu3bdSA8mT4iVt861vfyix5ErOhWD9iFv0IwCgoKJyakKZKkIisyCvnf5oxhRHUIGs+a6yE6brPOCO/sUUO67qLI2iYQBwT2TgCuSza9Am06xTPN8mMv36jHoNGvc3V1HZMfMZRSWP0TPEH2+6LHXdpx0mSnic73/vp6ou1PPaBfJubr72+NG7PFqMkC06TNFh0HU3Fw3h4UyseNgw0TSXRPjaLVUPTWD04hUOrG3B4VT1yAec4K8e4PZdAHBtpWHwyhOWOMXrS/ZKdTNl67l2VxXrJ1pPdOl5xrfLlZqEkjlB6zXttzwtesW7S65+fbEn3XWLZHNuGe8J0t7Y9Y/Rkh7ui2EJJuaROf7gO65MjWJ8cxsO1zrF6TuCCUWKdM99hpoX5gkq9UIz169czz0L6jiaihUiaYqKGWLEPfvCDFslSDMqzR8qW5MlHnn8ve9nLStYhT8BPfOITmAtIxIWMxiNHjjCbgRg+t3i/b33rW5bdUg0smpXBrWPacSeIgZRkfZcLEnUpNtScIAY9yoIzKX6PW/af/vSnme8uxRJSng5yLfWT1JBcPN///vezeTIqadRAQUFBYb6gGTnUIIVJzZ5kdimCWL7eXDMezK7HvuxqzBDLpw3hHP0INmt9LM5QxfItADQNo3VRHFjXhFvPXIUjXfXY0j2Oix/sRduo3b1JQUGhcN8cjZqsXmbpsHo2t/YlOM0FxNoRmUOMHTFmRA5FIhFGIJHiPTFjn3Ax0ohoISFGMhgpdIwEWsjNk37p7//5n//B17/+9aoRMtQvctd0M/LOPPNMph1C06KqblYDpLZJDBeJrdx8880sjUIxRIGTyy+/vOxtiCqYJG/qBnH5vn37Spafe+65+Jd/+RemAkojBCKI4RPdTN1A+0npGWgEglxgKc4vEFg4YQQFBYXljXJUN8lVczobRh0S6C9io2QkgWcC55IK8nnPF7g1mq5Jy0gNb9yIU+YqtGES7do42jRi+ULoRwMGUZ9X7PSrAljMxGmVjfjL2ALZqP3ODxbiax79VHVH4w9dmY9dJ2z6vMnuebASUrl/cTE/b0XLswEdB9c1obutFruOjuC8/YPoa47hkc1NSIeK3lviqbTNz388uqsqp9f1KLJ4sn3wurYkx1a2Pd+Mn+HB8kn66sXoSZlBT0avlL1zTZvgdz0Zo1fMsDusZ2tTdl+Ww9557L+szGv/ByJ1WJccxWkzfbi/fg2L/3NrT/oc9eqPgg2NjY0sFo/H41WCZz/72TZFzJWGRWP0KBM8p0nJ4CPDjwIQid6k+LW///u/ZwYR4UMf+lBJQkE/IOueKFICMXCUnNBLQpVw/Phx6To33ngj8/2lHByU54LcNSlYk/yC3dxCRZBqJzcUyeXzP//zP8vcKwUFBQX/GNNq0GjMQFuGAlCM5UMTHjTW41FjNaYRwToM4RwcYakiGo1pxloqzC+mYyHctaMd921tQfNEEk98sB/1U6WJphUUTmloGh6pXYWgkcPpkz0ILJVn0wqLz1NYJoweUZKUR4/oUfKrJXqUJhEkfEIBlnMJSKTUDF/5yleYCyipa8p8dYmeJWONY3IyL14gAzGLlbCLIl7/+tfjs5/9LDMoKTffy1/+8qpRtAoKCisIXiO6bjFxJgb0OqzKjmIVRnFSa5YP7/E6OZf8ZiJTIWMdxHIZS2IbgdfKZCo1jGtxxvRxlq8D4+yXEhuPGjUsDnFUq0GGJzZ2Y+JEVc2icl/xeF5MhbB854du8IxRIuz7ePnMn+94PL7Igb2SFhbTUpqGvpYajNVGcPZjQ7jw4X48urEJJzrNHHwOsXP8+hGZPVnOPHkePUm/xOuRd9MjjtTKBy9ZzfG8+B0GN8ovc2X8jPJZPr/PCTmjVcqq29atgAXzzejx9rhSZfGKPtv2zeh7xNt59dvP/s/qITzQsApnj59kxt7D9V3I6AFPRo/H6Ek9CBSWPdLpNH75y1/ir3/9KwtZIzvDK9k7xRjKFEXLxaJaF8RokTQqF0wpBuWqI9VMco3kzFy5eN/73scMSjqoFB9HgZfkPkmBnIODg/je977HKF9ynyQlHFLwKZZZrTbIB5i2SawmpaegFA9k/CkoKChUGzNaBCe1JqzNjWBYq0ECkWV9kDNanuXrNRoR1VJoxjSajSlsQz8oDdyEEcOwVssSHqe00GJ3d8UhEQnizt3t2HFkFLsPj6JxKom9m5pgBJWfmYICYSoUxYMNq3HGeA/OGTvB5hOBRXoWLWX2bKn2q8r405/+xGIGT5w4YZW5pVgjA4+WV5K3b0kZesSgEds2NjbGjC4KmCTmrrm5malSUh49MobItZHEUX73u98x5ZpKgh9J9IRi4aamppjqJc9hwUEHk9wyeZ6Muro6zDcopwcxmaTySftOyePJAKwUXLJVYelBlNRVWL5YjPMofc57qg6WLjsZIJGAKezI9uHh4BpktXzeKDfFN1dWQsbEiLFAMlVCzWfslNNoeXE7moaEFkEPIujWmhE2MszgazamsTE3iM25QUxpEWbwkeE3o4VhCA3ajq2sj7rP9cTFLoyA7XhLRux3fDzP/O37sP98TYfflo/X2/TlghKn5vs6KWXvbKu5xPVRMulHN7VgrC6K3YdHUDubwb27WpEJchlQcdP8oBUKNXPb3myxyQZK2DDO5rG2hOW6eS3rDnWsMhnLJztO+hzuQacy2b7y/nit51dV1CsI04WxE1f1VJ10uyec2ubd4vtMv7L4Vzc4sa8ufdQ82DvpPsu26cFoUjsTkRjubV6LM8Z6cC4Ze02rMBmyi2LZrmtJH/l+ie8c9R2xvLB3714W/0eZA+jc0Xc+iVGSrbNQqvuLYujRDv/TP/0TM/Iozo3i58T0BJQNnnLrXXLJJUwEhXJhkCHEc0uUi2c961lMOpWkVH/2s5/Z1Dif9KQnMVEUUvUksRVCU1MT5hvkqkkCLmTlHzt2jCn/zMUllMRk1ANgaYLOCw0yEKo1QqNwapzHztoKBn8cPtDHjI3Yku3HEzCFI4FWu9Fjfhx76WbIP8Yly2Xd8jD03FzFxOXOLll0rOIY0YBxI8cEaBpyM9hhJBDEGJIIYFyPYUKPIRoLWu6btnbgT3jFcTfdXL88jD8j6E84TIbVIYGllblz8jJHI9rwV1ZctyOK4/W12HV4FM1HEnh0c2PB2Cv5gC34BfN8jjnBhdcy+mzbKz0J/N6j/9s4SyJsUjNTQOiCV5R1fYtl5ryeETYnua49DS8JpPeBz/vEa3sVads4qe24uSG6GD2ebpGy9uC8vCUekouoSCBbryI3Tdn23O5fsW1JmWw9eib11mzG1qkhPCU9jkOREMYiscJq4nnll3Ko9LoVnwmkRl8OqqFuOV9Yqv2qJsjuSCQSzGuQSB3SJKmtrcVCYlEMvd/85jdWgnESM3HKQUdJzP/5n/+Zxe6RSAslEiTp0UqwZcsWlpuCXDMpjwWlRKDtcvbu17/+tbUuia0sBGjfPvWpT+HgwYPsYiCWj8RaKgEJz/gVhFFYWHADnM6RMvSWLxbjPPb5FbzwGa8zmqvFaZlutGiT2BfqZG6Qtg9hmXaA10emJM5E2h8ZW+ixnpfipbVcVN2z2qF9q4dm1KI+N4uW3DSas/1oRxbxTAMS0wa6Q42Y1iO+4/HKYS1K+yNZJoTu5EyD4/yb8jmUCAfe74/d+8sb3mrNb7r5Oud+CUag/UPYZPRs+2+ua7PbSo0/LWqgZ30M5+0dxKqpSdyzqw3pcKGS1Sb51fJWciajlxUMvZy5olCGjGb/pfbMecboBYDuVAqaoLOmpzVHo04s4waelvG4vnMS29frA9XDIJQOmMj64NPY9Iy9lHZiAWLdZNsTYPBiDeidTuV3yaOu1PD0e9/OZf/K6E9xnRPhBuyc6UdHz2GM17ehu6bRrFxYRzevYV3yyKd3jtV0ue8e5bq56G6bdM7e/e53s1CyxcCiGHpi+gLKfeGGc845xxJp2b9/f8WGHgdRpZQjoxgUIMlx/vnnYyFAFj4lTn/FK17BDF8SjeGsYrmgC0kZEUsX/Pyoc7S8sdDn8YEbCwIdZ7zrhtL+8AB+iQeI7GN0TI/jkdAa7Ej3Yk/qOA6F2jEcqLUMDttuuRh1TnL2Vn2ZAWdz53OGVwLnsj9GNR2jeg1GQel22lCXS2JbIIf6XD/aExMYDsRxPNKMiUDM94egDT4ZD9lymyy8WcbtHcKW6wvn/NAVhbQKbjhy+ZXsd8PN10o27NBHN9jOJe+4YLSRUE48gjt3t+H8vYM4Z+8g7jiz3RLcscgk4UDwspwknYfo9utmEOUbyE+iC6i1qofBZNqa3por4jniAyKyY+flhimuWgVDz2bceblAy/ogM4ikAybubUrbkW3QpR3abs4lYbpfo81r+XwarSKK+5CDjoeaO7FtfAjbJwaRCAYxGKu1DazJnm97P1Mq0KS+IZYXRkZGbLm4FwOLoukjKkxmMqLfRCnElAjzpUxJLB9PXk45Oeai8lkuKMUEMZcEitmbmZlZsG0rKCiceiDXxfvD6zCpR3FauhfbUn0IGu7qXysGmoapQBS9oUbcHduA/ZEORHMZ7Jk5iTNmTqIxM+Pw1azghamaMO7Z2Ya6mTQ2nyjPvUxBYcVD03CwoRX90VrsGu1DTTq5MJtdwQnTlwM6OjrYL6VkO6UMPRJI4RDTGshAQiyyetUEqV6S+iWB3CdjsYIP9XyDGMarrrqKzZNLKeXpU1BQUHCC+JJkkuQ692MrHYmWTbROWg/i0VAX9oc60JSbxp7kMcRzScYm8YlJnnPZcz4F3CcalWcj8+IkbLe4jyJk++LUf7fJ8lQSy/SiicoCGvrD9binZh32xrpY7qszZ7qZ0UfCNQb9c+p3GX10XS7bf3Kv5JPHMXPD0TdfaU1+QTYunwod9un+RYqnNWE8vqYem05Mon4ilWfazLpi21QuLnOeSg9eyUeiQ13pR6Vkude5sp03dn6817Mm3X2CODldq5VOPvuRE+9bSd+kdcTnhNtxEp8DXn2VlUvquvXLz3K3cyBdLnuOyI6tsK+O7QU07G3uQCoQxIbJUe/nm8Kyx6WXXsp+H3jggVPL0LvssssQj8fZ/E033YSHH35Yuh7Fzf3kJz9h86tXr8ZZZ51Vss5TnvIUy5Xq6NGj0nacEqDzROnveMc72DylcCCBlIXGi1/8YssllfLrKSgoKMw7NA2DgXrcF1nPcs+dnjqJSE4IdjpVoGkYCtXivpq1eCi+itkBu2d6ce7kcbSlJhXDVyYOr67HZE0IZzw2Al2Iy1NQUCDjWEdfrA6tiWloC+E9YCzxaYXjyiuvZNob1157LdMGWQxU5AtJ8WyPP/649TfFznGQ1UoMmQhSlhRB7pGU046MKspvd9FFFzFRFnKZJMVLSq9A6phf+9rXmFsld2usVIr0Oc95DhMqocTkZFCRkUn5LGgb//7v/86SFlIZ5dSjvi00yEgl5U/y4aXE7goKCgpOsMXRSJ8n7sfOqmOul9KCeDCyBnuSx3FaphcPRtayJMrSd7AsjkrWuOFRxyWGSRon5LQvFcTPOELTMBqqYVNDZhbrkiPYNdOHmUQIx2NNjP3jyaW95Ne9+sX30bavvGweRvKPvskfq7f+m9e4r8DPl02nPl/IVVzpGD20rQUXPdCHrcfGcXCTKSQhjessDYbSePAcQSYSJC73Sn1gb1p6b4jH2+vQW+t6xdbx1bw+ZCUxsbZ2SkMiXe8xX9vhVXiZ0/3Gty1rx2dcqtd9Yq3HWTC3Nl36MKfYO5/74rmuVztWITAYr8GmyRE0pBMFFU6vY6awLLFr1y6WD5wyBzztaU/DN7/5zYpSxS24oUfiKNRxGch4osnN0CNQjjwKUvz85z/PJMs//elPs6kY5NdKypSkUDkXtby//e1vbJKBXELJ4KNUC4uFF7zgBSyVBKmLKigoKCwkKK/e/nAXzkyewIb0EI6E207pEzAejOGh8GrUZRJYlxjBjukBbJgdwYloE3oj9cja5CkVijEVD+GxdQ3YfmwcA61RjNUL6R8UFE5xTIQjSOoBxuqJ6RbmBUuZOVuq/aoiXvva17JfMu7uvPNO7N69G2eccQa2b99ueTa6kUCUem3ZJkynHbjhhhus9AnEElI+ORIjoRwTlA6B8ui96U1vYjnu5oLPfe5z+MUvfsEMvZ6eHpa/r7W1lR14cpskQ9TrgC8Err76apZYUUFBQaEYD92QV2A7/Yob3NUUvQ6dwyg5iZQcDrdiS2oIY4EYRkK1pYyHB2shTZhuqS4K4GqhMlbCQ01vIQP4J4NR7K1bhXgmifWJUWyZGcS62RGcjDWiO9qIbJGXidvovlQFUCYL74BNN15fkiLh8DuuQFUhuY5EtcxyDv6R1XXoGJnF6QdHcduZHcjoQi4J3oyoOijL5SjbnHi95fKT317ZjrfkuvRk4GTXqN++ejF1Rcuc+ijdnBcL5HI9OnoI+GTBKmLdivvAY92c+ooy+lAN9s6rbY/+FNYvPcF5hVgNw7E4mpIzpdtUjN6Kwi233FLI/UmeMoaBhx56iE1uoPUW1dCjjhe7Z1YKSp9A01xyVPhJmE7TYqCcY0V9VEnPFRQUFgs9wUY0ZmexPdmP+wI06rx4SmFLCTPBCPbVduJwrhnrZ0excWYY62ZHcTLaiO5YI9KiEaOQB7lwbm3Gkx7ox7Zj43h0Y7M6MgoKJuiZEViAGL2lrG65VPtVTaxbt27RU2IsGqOnoKCgoFA+Hr6ukFvp9Csl7J4XXEelNRyMduDsmeM4LdGHB+OrYQhuirJ8fbZ2JPFDMpavkERb0i0J81FcXDGE/tnykEm2J0MiGMaBug4cjTdj7ewYM/bI8BuI1KAn2oCxMOXiK2pE85f8fSng2Ove6x6v58G6WquZSc+nw2HsX9eIXUdH0d8Ux3BDrOg8FCpbsXm50jIxbo/H67ES3VTiFGP4XGBjZ3zG93l+mPLrW8LEydg5p+1J2XBrYWmdcj6Svdg02XZcmTO/8Xh+2TCuSum1no+2q8LelcHo8RPhO17YPMGkWEqR0CX585bYM0FhbnASiVxIqEADBQUFBQULpMC5L9qF2lwS504fR1NmcZTCljKSgRAer23D7c0bcaimBXWZJM4e78YFI8ewdmYUoZx7fthTCcc66jBUH8EZh4YRzPi0yBQUVjhymgZdqW4qLAAUo6egoKCwTPHwte8qZfbc4oh8ju5PBKMsv9zWxADOmOlBf6gWh6JtSOnmK8NplNunIiD/vhGZGMMnU8FjucRNe4oOylgXL7gcR95OKhDAiZomnIg3ojGdwKrZcWyaGsbmqSEMRmrRE2/ACGf5vJiBCrDxi9ex3yNvv6L6Btpr8+zehm9d4067yg5q0fl/eGMrLn64BzuOjuKRja0F1kpk6tyuHafriZjZnEssnAs4qyqLnXPaFycVxbIVON0YvzmwfCXlzl20hvnLYfT8KlqWtOGx3DNGbw5tO/XRP2NplB2P6LY+f+ZZhl5R/aqrbioxllMeytBTUFBQUCjBbCCMh+Kr0Z6ZxObEEM6fPIbDsRb0hBu8czicatA05rZJUzCXRWdiAqtnx7FntBszgRC6Y/XojdcjHTg1X7mzkSD2rWvG6UeHmQvnQMPii58pKCwmKA2JfirITiqUgLQ4KOsAiU+uWrUKgcD8xnifmm8dBQUFhRXI7InsnmcOK/gYvdc09EfqMRyqYcbettlBrE2OYjQUx1gwjtFQrMDywSEXlgtTZ4vbc1PiFOuLfcz5i3/idZgwQTUINRc2IUMsX20TTtSILN8INk8NYzBai+6aBoxEJbF8VWD25oPdO/qaQtzehm9/VhJwiJIy2Tk83kQqnDPM2Lt1RxSZYMB+jmQxehLm14rb423TNAePUK+400ri9mSxqlLxUhlbaMyB5SvajluZNG9jBexd2Uqcsv4Qm1d0OXj1fz7Zu2rl0XNjV7O6xhKmlxyrKo+hKTGWpQHK101p3L71rW/h7rvvRiqVYiItpL65c+dOa71f/vKXuPXWW9HQ0IAPfehDVdm2MvQUFBQUFFxB0vgH4h0sh1xHahKN6VmsSk6wZVOBMMZCsbzxF4rZZfRPZXCWLxLDwfosOmcnsHpmAmcPmyxfTT166uqROlVYPvqoWdeKS/Z1Y9fJYTy4oX2xe6SgsPJj9BQWHQMDA3jhC1/I8uh5KetTXu/nP//5zAh8znOeg7POOmvO2z9F3jAKCgoKpwa81Nuko+26v3YmQjE20bJwLoPG9Aya0rNoSU1jTWKcjVZPBiMYDefZPjJ0cgHdlakrUVN0Wk/G3klYEIv9cYsJKtl46bpStcxK2AvTUOYsX0Mqwdw6N02MYPPEME7UNeJgY6v/oXyvxIbziKOvel+pIqdMQVPKSmlIBULYu6oFZ50YRF/DDPrrawrr8fOf8zhhleyyy6F1ZL5dYjQ1LyZOYJClTbswdbK+2WJZZd3yGR8GD+XX6jFjHv0pWs76UsE+yMqqwt55HRPZtmU586TXTr4wp5PrJluLDYKUqG9WCypGb9GZvOc973mMxSMXzZe85CW4+OKL8ba3vU26/q5du3DhhRfijjvuwE9+8hNl6CkoKCgo2PHI5/JunLve55B6we+HENzXIyZqIFCP/lg9K4pm02giwy81y2LU1s+Msm/3iVAUI2T4RWIYD0dt6RpsrmsB2Ye+0A03ARexTla+22L/mfADCUCUKzIx148wTcM4HYdYDAcbs1g9PY6t48Msp9bhpvLzzFUkMlMFaGb6hPzG+a/TyIL9t6ehFp1j09h9YhCjW2JIkQuneH6N8t3SbEm/JYZ+RYdHVsnteHu5D3sYgq6pSSSJ3r3atnVDds/LUnzMwajzNIhk/RG6b4mxyFDmwErJMSvXqPM07jwEWmR1eRW9kF6BEEAOWXomclfuBb6XFeYX3/72t5mRFwqFmFvm05/+dFbuZOgRiNG7/fbb8de//rUqfVCMnoKCgoLCnJEIhNAbbEBvrIF91cTJ8EvlDb+1M2PYND2CLPLujGT0EetH7B+JEpyKIJbvaEMzE2TYMj6MmVAIfbV1WPHQNDyyuhVPfuwkdvUO4v41HUrcR+GUw0w4xH5r0ilMRKLzth0Vo7e4+O53v8vcMC+//HLLyPPCnj172O+BAweq0gdl6CkoKCisRDjZTz7Zq7ITD9va1jCthzEdCuNkbSOjK2ozSTQnZ5nxt2FqBFuMYWQ0HcPROB6vb2Eqn279lrJ3MrEOibtbCWgdkQXi25SUlcNUuC53WHa4vhmxdBq7hvoxGwxirMbho88jbQbHhi/lhVmOvrX6KRc4jr7hPYXt3XytvX8l81oJe5XWQtjb2YY93f3oG59GX31tYbkgxjInN00vFsgvPNgyqUiQjPmTMXW2hspk+cpg9NzueTvzVR32riIxliozejbWzc1NVfoclPfEN5soa4ffB6bHwUQkwjwe6pNJjEejrmkaFJYvHnroIfZL7pt+0dbWxn6Hh4er0gdl6CkoKCgozC80DVOhKJuOo4l9mdanE4ztWzU9jgv7j+NobROO1jXBkAUMrmRoGh5taUc0m8GegV7csWYNZkP50f6VDDLuBsYmsXloFH11FKunvnAVTh0YuobJcAQNyQROoGEeN1ThgMlCYKn2q4oYGxuzGW9+kE6n2W+10i4oQ09BQUFhBWLvZwopF3Z94IaKR+r9Jkd2bLt4mRirFo3heG0jNk6OYMPkCDoTk9jf2IbhWI2zqIeMJZH1UWT5si4JmivY13IYImk+8eIYJU3Hgx2dOL/nJM7u7cGdq9ewNA2+2xbbM2OAFgpH33wl+934b9f5TyJudvxocyPOP9GD1qkEhuPxUiZWJtDjBRlT5bO+dDt+4828xFg0n0ydx6YrEmNxYTmdGL2y2btyWL7i678MRs/rYnB9vsn21W+8ndiOV39cGEZDYKwnohE0JhJsfen5qAaUobeoaG5uZqqbQ0NDvuvs27evbOPQDafY0KmCgoKCwlJCTtdxqKEVt3euRyIQxNlDPTh9qBeRTAanEtKBAO7v7EI4m8VZ/X0sx9ZKx0gsholIGOtH86PeCgqnEsYjEdSmUgjk5pAIUmFJY9euXeyXcuP5xXe+8x0W13feeedVpQ+K0VNQUFBY4dj76QK7x7HzwzcsrMKeRzsz4TDubV+NjtlJbB8ZwkV9R/F4YwtO1DfmBVukybMl/dbtLJ40bk/z3lffrF0lMUoO682Ewnigowvn9nZj5+AA9ra3l6jxGSJj51K20JCmRRAhYWdJav5YQyNOHxhA7WwK0+FwUaoMvoNCGa/r2aFy98DHOXdjKr3ObwWqm74TpstoQL/XtyxW1Wt/vJ4JkjZcl2vuTLTvuDyn/kj7bZTfb7eLz+uZKNm9iWiUrVqXSmIiELepD1cLRY+6JYWl2q9qgvLn/fGPf8SXvvQlvOUtb0E7PdNdcPPNN+MPf/gDM/Re/OIXV6UPitFTUFBQUFga0DT01dbjttXr0VNbj+2jQ3hC7wk0JGZxqmA0FsPetnasmZxE59QUVjp66+qYCM2Z/X0IZV1yYygorDBMhcPIahoaksnF7orCPOENb3gD1q1bh5GREVx66aUsaboMpLD5ute9Dm9961uZkbd792689KUvrUofFKOnoKCgcAri0U+Usnwidlx1gz+WT4K5JV42kAnq2N/ahu66OuwcGsT5fSdxsq4ejzW3IBMQXluy/sgSpmeLygKV5dGrKBm9pG1XFUCdcs3VY/XkBFZNTqK3wUy5wBkPWztmmVOc1ULCQS3TYq2kjB77H/d1rMJ5vSdxTk8P7ula5Ss+sU3CGXMAAOLuSURBVCrsT6XxerKE6bZOSNrwIDk1n7F8Mmbb/71VWseJxauK6qZHLFshLs0o3I8VsuFVZe/EvnoxdbI6svUt5rdQSEnTSX2zPpmAkQ9Lrjqjp2L0FheRSAQ/+9nP8JSnPAWPPvooLrroIqxevdpa/spXvpLF8HV3d7O/DcNAS0sLfvSjHzGDrxpQjJ6CgoKCwpIEuTbdsXoN9re0MnbriSeOY9XURJHf2splulpmZhA+BWIVyWXz3s7ViGfSuPjEMayZGD8lzrGCAhl6dcmUOhArGGeeeSZLmn7BBRcwQ+7kyZPWsvvvv5/9TeU0nX/++Yz127JlS9W2rxg9BQUFBYUS7L8qz/htv/qGquTMMiot0zQcb2xEX10tdgwNYfdQP1ZNjePR1jbMhCJmnUIla1amb6B5qPzNhb1wWq47K/7J4+0K6QdOGxxE5/QUjjc1yPP68Tad4rUWEGJMpBe7JVMYnIhF8Ne167BtZBi7hgaxdmIc+1vamCurPZatcACofi4wP/ssVdPk0PyJQHrl0ZOySR7hlobHMH3V8t9JzpHfeDxXBk1c1xaj59K203ZcyyRqmn7ZO89+u58k2T5Yp1e8djQqz7OZ1rENVPdiVgnTlwbIcPvb3/6Gv/zlL/j5z3+Oe++9lzF52WyWMXiUJP35z3++76Tq5UAZegoKCgoKSx6pYBAPdXbi5NQMdg4P4qKTJ5iQx+HGZmTJF3MFqnAO1cTRNZE39E6Vc/xIRwdONDRgx+Agzu/tRm9NLXPZTQRXfm5BhVMPoWwOqSrlS1NY+rj44ovZtJBQhp6CgoKCgiMOfKQQy7f94zf4U92sKGZIomgniWsbqY3jtpp12Dg6ik2jo4zx2t/chsGafJCL4SMgi7F5FKfnpt7pMrrvuP9u8XgCe+eqeCis19tQizN7BhDKZpAMB0vZBN5vYYNl5ZyrJpy265e9FZaNxaO4Y90arBqfxLbhYTzx5HEcaWzEkcYmlo6D5OijmQzqtSyM6SlMBcMsJ6NrPyqFjJ0xKsijBw/2TsbyOXfBO+fcHOL2yqsjYe88mLHSPJI+GPai7TnBb5ys6/PGKbbQ7VngEaPHPZE1W3sawrls3tAzyw9d8W5UFSqP3ikPZegpKCgoKCwrkKvm4eZm9NbU4bShQewZ6MVAvAb7m1uRCISxUkAJlQk1qXTB0DtVoGnora/HQG0tNo3kjfp14+Ps2zlk5h2rr6/HxMQE+5Y93NDM2F0/hr6CwlJBOJNl6psKKxO6rrPpoYcews6dO33VOXToELZu3crqZaoQo32KvTkUFBQUFCrFgX/Ns3vbPllG3J5bfJBHHI0Nkpih2UgI963qQsfkNHaQO2f3cRxpaMJATS2myeArykHnGKPnwspI98uDBbHFNZkMnSy2ziv+aTqSf0XH02mMIGbPLVfc38Vm9LyYIZTBnFh1NWQCOg62teBEQz3WTEwgq+tIBINIBoNoqqnB0ZZWrBsbw9bRETQlZ/BwWydbJg+U8jg4PpMnSluRxO0ZZcT1ucXoyWL9bG0Y7oquJdsQlsuuwbmyd37jdi3oFeTRc0I12DvPfXFn+WRiiSXPGhL/NbKoSaVwoqm+vH0sF0rXaFFBIisLWa8YytBTUFBQUCgLBz9UcOfc+mnB6KvCB6PTBw8XLrG5zeXVWtBfX4uh2ji2jIxg89gIto6NIKXrGItGMRaJYSwcw3gkAkPXCx+3otukTLK+uP/iPjh8CPp205SlV5ClTzB0zAYDiCfTVt+ktsq8fiX6g+hytunG6wsLXFzbvIU3zHMODbPREB6LthQMHQCxUBBZI4cjLc0Yi8dwRl8fLuw+jofbOzAUN/Xqy4Gkj65pFhx2QvZR7+XuKTX+ZMv4feLUH5mR4ZbOQ3b9Vsuo8zTkC7+2dCdu8DJgZdvTq2vUSVXvvdIrZIsGnQA0zc6yrg3WxJwHuOYIJcayfFGt9ArK0FNQUFBQWPYgpudAayseb2pGQyKBptkEmhKz2DQ2gqBhIIt8zqpkIIT6ujpEZxNI6QGkadJ09jsTCCOnLa2sQzPhEOLplZ9iYa4gdc6/rVuH0/v7cXZfLx5s70R/be1id0tBwREt07OYDQbZPa6n1YFSyGNoaIj91phx53OFMvQUFhS73ndD6eh2oHQ0UVrG3Z0EgarH3u+e9FlBQWF+8dgH/N2DWz53vT8XSC92QmRJuFuksGIWOkZq4hiJx/PrGAbqEkk0JRJoSCbyIh7pBALT40zxThd4BCLNpkMRjIcimAhFMR6OYjpU6gLqKUYDn0ylG41jLp4JhVCfTAmJx938wpYIZIymDB5siuUCKbRnO2QmM8sZWTLc713VhTP6+nH6YD+SoQDGYjF5qg2f8GIdSR5fUlhS2ZMYlJRZ144sYbpXfz3cNL2SmpedpsGLsa8WUyfpq7QdaR8l6Uw8WD5P9s7LTbW4Hc1u6A0zNo/lWZgfKDGWZcXOTU9P44tf/CKb37x5c1W2rQw9BQUFBYUVC4rzmoxE2URfdfS6XR0Jo6e2hcVABAyDCSKQ+l1dKon6VAINqQRWz0ywdTNU3zT6JsIR9ksxYvIvwOqD4s0i0zMLsq0VAU3Dwx0diHZ3Y09vL+5cswYzQSV2obC0UJtIsQGcQ61Ni92VFWs0XXLJJfjTn/5UUn7LLbfgNa95ja82vvWtb+HVr361775t2rRJWv6MZzwDoZB7iphkMsly6+VyObaPz3ve81ANKENPYeFYPIKElZMxdbIkw7KyzdcKsSBm+aF3V1meWEFBYc6oJNZHZHL4fW+P0TPLxPWkQUzmermCkkVejEVDBhpz+5xFCBPhKLqRz1kXyOZQl06gPp1khl/H7CQ2TI2yZclAgBl84xHTAIxEkNHFB5gt0M6x33Z6snQ9Wh7OmvLrhvN+LTVG7/A7rrDmN/7bdc7MiQjZ+bdiJ+XMWF6W3ygpNHQN96/uwhOOn8TZprFHeQmrlVi+IsEbGX0nWe7F/Lk1YVtZEnvnKYjklRy9zNg7RxS1ze5FWYye24F22oZbH6Uxih4xeBWwd/KHj729tcMTSAZ09NfXsGXzFWarYvQWFkePHi0powHF7u7ustq54IIL8N73vrcqfVKGnoKCgoKCQhHI+BuLxDEay7uAEsK5DHP/JNavPpXEhvFRhIy8X+B0MJQ3/MxpMhyGUYV4v2g6k2cQFcoCGXb3rl6FC06cZMzePatWLbn4S4VTE3ouhzWjUzjeSGqbiy+ktFxx+eWX4y1veYvjcj8xbr/97W+xatUqx+Vr1qwpq0+vetWrbH9/+9vfZuzc85//fDQ2NjrWo3Wi0Si6urpw0UUX4dJLL1ViLApLG7s+UMrilcPUyWTKC+tJ1LQERnDTF/IjyMUjywoKCouHQ1cWmPbN119fdpJlWdwPZ3psooT8+SCyQEXf9+xvG5PhEvcmLEqGghgI1WJAMz8gDIOlPiDjryGVZCIwndOT7LFE5t9sKIQME3rRWZoAYv1mQ0GMxGIYj0aREz7ypDF4BlhMIamHWv1ZSikVfECmJup5rq3K/EcmWWnWL2aCBGZ0NhrEfWs6cd7xHpzf3Y37uzqRMN2nLIXV+Tx2UqlNOXsnS5hu7X9pVZdt+ovHcz0vnnG0HjGYfuPtLKbN8M3y+i+TMJWVKGh6xuOW2W8NWDU2zeKDTzQX0irMm723gmP02tvbsXv37jm1sW3bNmzYsAHVArl6Fht6hE9+8pO+8+hVG2qYUEFBQUFBoRJoGmbCYTb18iISfzGNvlg2g2A2h2Aui2Auh1gmg47pKWwdGcFoNIr7V3Ui5cHWMUavVr2qK8V4LIo7163B2d29uPDESWbsMYEWBYVFQDCTxbaeUfQ1xJnapsLKxkc/+lHLKF0sqLeHwvxAHMj0G3uneSlxGs75qCpV+lJQUFhw8Dhaab41EV5xfeaDRhbDJcbtcXZPfNbYEqZbsoZ2Nq20D+YzxsUDkOL+iK2jSb6CgebELM4Y6MeFx0/intWrMB0OS2Pw9GwO4Vwu77opkB9WU25xVEsER99yJfvd8JVr3RNYyyBLSCdIUBIrxSbhAMiSlU/GwvjbhjXY092H809249GONpysz8di2oikOahzekJ24iSXm62KpEyWg09WyXZNcHVar/tJr4C9k3S27CTjJjMrXeayHbe2fatplhWD54+906Rxi/kVd/SMIJDL4ZG1Lfb25onSUzF6S8PQW0woh3UFBQUFBYWFgqax1A93rFnDXDd3Dgw6rto1OcV+JyMRdX7miHQwgLvXrsbJxnrs7h/E6X39aJ2eZvFSCgoLgZbxWawbnsL+1c1IhheIZzGW+KQw71CMnkJVsfODkjx5PvPjSetI4vFso46yfE3CwBhXfDvyNhWrp6Cw1HD4nYW4PTG2lsMpHre4TIzhco3b4w8J3c7o8XgtWb62suIIi9dzAcWKHWxpwZ6+PjTNzGI0bncnDGaz2DY8jJ66WpuhJ2VdbNteml9PR9+UZ/ZErP/GNe6VzINvY0gE9pbtv17E8sliHbktpwOPdrZhIhrB5qFRrJ6cZOkzEqEgsprODG9iXrJs0jEdDmEqFGbiOhRvWbVDK7u4XMJEpU04lFtNerwbC3FrDo26ecj4Ze+8lDEroR082i5bTVO6/w5H3id7J1s/kM1i9+ERDNdGcLyt1qTatCV/3y5l/OAHP8B3v/tdHD9+HMFgEJ2dnUzIhNIhPPWpT/XVxqtf/Wrs27cPo6OjqK+vx5YtW/C0pz2NCb2sXr26qv3NZrN49NFHceTIEUxOTrK/vfDKV75yzttVhp6CgoKCgsIiYKCmhqlzbhkZwd1x+0fF1uG8i9eB1lZ1bqoMYvVO1tejNpVC69QME7zRDQN6Lp9XkeZDuSxWT8wian6MDcTjONrQhLGoiu9TKA81M2ns2T+MSDqLu7d0LFgOToalzJyZ/ZqYmLAVRyIRNnmBjCYRjz/+OJv+/d//HS984QtZvryGhryLthP+/Oc/W/PDw8NsuvPOO3HdddfhxhtvxJve9CbMFTMzM7j66qvxjW98AyMjI77rkRKnMvQUlgR2fkhQ2HSJy7PN2+IHStezYgo8WD7ZaLvMN3/DTWJ8iGQnPPz1eZvHXv8erGRs+ewNEhXAwnJ7ji9/bR780Luq1DuFlYxqK+Ru+NJ1JYyOZgW6FXkQyMKoBBbIKvPL6HnB2qCGx1uasae3D02zsxglkRANqE0msW58HAfaWgouXpXkK1viOPY6f3miRObPtsv0LmB59CTBbjxnInt3mMtFL81APnZvSvyglDzfQuks2qensXFsDOf3dmM0EmUG32A8PvcPdhmL4yWxKWOa4RGP55pHT94fNybPK/7Ntf+OMXo+XyhufXDYhnWaRA8BaV/c2UIpe+dxCXQMz+CMx0aQCAdw2+mdmBaTZnsxo6cI1q5dWxLXdtVVVzmuH4/HWbqCyy67DDt27EBtbS0GBweZ0XbzzTczY+2nP/0pXvCCF+D3v/+9NFE5JTb/+7//e1x44YXW9g8fPowf/ehH+OEPf4hEIoE3v/nNzNh64xvfOCcj7ylPeQruvfdelk9vMaAYPQUFBQUFhUVCf00NxiIR7OnpxUOdHYxlWj82ztwGjzU5511SWBhkAgH01Nejp64O7dMz2DA2ij0DvZgKhZjB11tbp3KhKZQgnM5i27FxrO2fRm9LDA9tbkE2oAPphT1Yy0GM5cSJE8xtksOLzaPk47KcdE9/+tPx9re/Hc961rNw//33M8Pvpptuwjve8Q7bei960YtYvjsy4kScd955+Md//Ef88pe/ZEZgOp3Gu971LmZUkltoJfjc5z6He+65h82fccYZeOtb34qzzz4bzc3N0PWFkUlRhp7C3GF4sXOS0TiZ6iZX1RTLZCyfQ0yBm2++Vy4g6SihCHPd9d8URpbNdY++xt+o9FLD5muvl+RwkqgXCnVscU9ujQsrbvtkniVUzJ7CgkKWJ4/H4hUth7lcHHC1xA0lzIjjl5PfYXnbahruXbsKe7p7cW5PLwtB66urxaGWJuSYZ4R3DNBKZwPEPOe2nHpmrKXtxLkodZIiqrXUcI7LzC8ojvXUmKstTU0zCWwYH8XuoQFsGR3GsfomnKyrR1YXXFmqCa8Pda94PJ/vQd/xeF6WQyXXo6VE6s6aub7nxSplMH7VBKVXWdc7ha3Hx9k29m5uxImuGhg5Le9R4BgTiVMWZOSJhp4X3BKPd3R0MEbutNNOQyqVwhe/+MUSQ8/LnfO5z30uYxU//OEPM0aOXC4/9KEPodI4QjIoL774Ykd2cb6hGYvFJSpUBeTbTBft+Ph4WTdKVV02JQHeXq6b0pQLEkPPLtBS6s7pWxrZw9XE6+XhmlRVeDvKjD66xej80HkqHkFaDPBk1aIbk1OyZtsyocwJfkcOD35w+blzLrXzqOAfG75sum4b9LEFrA5F0JNMllzOdql9/uFZusJ8GFYUH9YyPYOxWJQpRJb1kS35YDz65lLxk5WADd/KD7ax86hHcDKbtNl5loCL6KbJD56tDCWpOaRu6mLqhgz/zZfVpJLYMDGGrukJJt5yoq6BsXwZbvBV6zqRPVdt713JoKU0VUIZ13K5LpKV7KtmnsdgBN2Z0vtRms7ELVWCpK53H73cPv0ZtbRe81gCpx0eQ+1MBic7a/DYhnqkw/lrIZc1Bw7Sws6khHnzOvS6b/1+8/H1znzlpxAIO6R6WWRkUwk8+O8fnJfvVzLWfvWrX1kM4KpVq8qqPzAwwFg8eu8TU/i73/2uon7U1NQwN9Cf/exnrE+LAZVeQUFBQUFBYZGR0zUM1tUUjDyFJY/pcAR7Wzvwl9Ub0F1Xj3WTY7io5ziaZ6cXu2sKC4hoMoMz9w/j/EeGmHvm7We1Y+/WJsvIU1h47Ny505rv7u4uuz4lOG81hbAqqc8Ro7hrAGvWrMFiQbluKpSFnR+WCK/4TZ/g4JIpZeqs9SQsnxOL55O9s9rzWM9TinkZceGbbhDcNEtmRDfNUudMR3dNDx0Bq45kvW2fumHZMnsKyw9W0m4uysQSbUvSK4j3v8xV3FpYQSd8Pi88PRa8+rNUA3KqBO41QSPtF3/n88xVTjxJhsxNkwuzcBfe/Armj+j2qTkL+LA/NOkhTgVCeKyxDSdqG7FzuB/nDvTggdYuDNTU+t8xrTwmT8bi2ebn001zPl0Opde8z1QJnn2s0r2hFVj4jScnsPnkJDIBDQ9ta0JPexyanvccEPvF++sYehKcn/uW7g92jyxBzGe/quGsaFShjd27d+Mvf/kLTp48ibPOOguLAcXoKSgoKCgoKCjMEYlgCPe1r8ZwJIZN4yP22EGFFYVgJocLHurHlhMTON5Vg1vP7URPR83Cpk5Q8JV6YVWZbpvcdZPUOyutz0GKnWQwfuc738FiQTF6ChXDjb2zhXpJl+fYYBa9Bo0AHx7zYvl8jtp5iazMo48/jx9ZcgItMvZurt8gbu8zySC57XCaeUJ3fKzAEO//qGL3FOYXRy+/0oq13PPdrwuXaylTI9X0kD1jKhJgMYty7ulj/D7fRBx9w8pOASPil897NYtD2vjvgkiWxdRBcn79ibaIdWyxzHyZ+O4Q4/7MtY7WN+GcwR40J2YxGo372hfXx7GXd4nsfes3Hk92fTttZyHg1J9y63u5n7i07RiXZ9YJ5LI4d98Q4okM7jirHRO1YfYNUfCWMUraMfhHhsP+aYJGQVXBPrKwNDFP/aI0CSR8wtMorK4g8flXv/pVi9G75JJLKu7Ly1/+cvz85z9noiznnnsurrxy4WOnlaGnMP8wDDQnZ9CSmEFzcpYlpw3mssyuo3dkRtfzU0BH1pxPs3mN/dLfVJ4OakgFA5iIRpAIBdTImYKCgoLCksNoJIaspqE5MePb0FNYHiB3zT37hlE3lcbdu1uZkbeUsRzSK5SDX/ziFyx9QjAoN1/6+/vxkpe8hKVGILz1rW+1LT969ChGR0exZ88ex21QeoWPf/zjbD4ajeI1r3kNKsWtt97KWD1KIfG+972PKYL+0z/9E7Zv387yAXrhyU9+MuYKZegp+MJp/+qisClJKCyqam4bG8L6yTEkAgEMx+Loq6mxjLqAYSBg5BDM5RAwsuw3mDMQzmYRTOUQpGXZnFXOkQwGMB6LYDwexlicfiNIkfFX3MdyffyrFHtgS8NgAGsCEZzMpKwBrIVKvL7p84XYvBLI4hZtiwuRe7Ll1noeinB8xJuzeGKZTQXPA9s/LokP5dsRrkEV96fgB4fffEXV1VOtGEC/sA3p8zgyYblf74RTHEdf9b7yE69ztU2RQbUd3FJVZcs7QXLaRKyemmDvtv5YnTT+s1C5tB35ej7TJ4jlc0l+7oW5MG2Oy2Wsm4v3jVesfpksXr5tbwXO0x8fRst4EvfsasV4Q8SK5RXryh4rhTKZtCujCd07p8BAefLIiHvxi1/Mkp1v2LCBCZ4MDQ3hT3/6E77yla+wecKTnvQkqaH31Kc+ldV93vOex+LmSHiF2DtiAskQo4mzeddee21FjCAHJUsX3zN33303m/yA6mUyptTvHKAMPYV5RcvsNDPy9je14nhdIwx+xXnk0bNeQjZ3BgORTBYNs0k0zCTZ7/qhCWzN5h+Qs6EAM/hGayLoaa5FMqQubwUFBQWFhUNzYhrbx4bQE6/DdMg98bPC8kL78CxWDc7iwe3NGGlamikLTgXXzZ6eHpYfjyYnkCH49a9/3TH5+u23384mJxDbdsMNNzA2bq5Y7Cx26ktYwTcovqE2l0BNJoWabH6KZdOYDoYxFo5iLBzDZDSCnKYz443W3z42iOFoDMcpQaUmMH2ae+ydpShmG6nTkAwHMRAJYKCRU94GYqkMGmZSlgG4rXcM23tH0dtYg2MddczwE4fYXEcEnfz6reAMe39KYY7uyYLiBGz42udKlh994zywfIVM6K798d+eMO8yAi3GrXAmz57XqtTg3371De5so4uanNiHrZ8ptPPY+1Xcn8LCxgASNnzlWvf7TXbvSGL0/MYWL7mY4OWUeF3Mkyd4jfCDayNdPWI061IJnDnci5FIDPsaO6SvkOI23TssWd9DvdF1G17eLjJ4vS+0CpYVb5P5Fxb1S1y8QHGCBs/BKNyDnKkLZHMsR95gUxR9HVGrvPAr9tcfO4mFiNFbYfj2t7+NP//5z8xIIwaO2DvKGVhbW4u1a9fioosuwqte9SrG2MlwzjnnMGEUqn/PPfegt7eXtUHMWVNTE3bt2oXLLrsMr3/96xnTN1f83//9HxYbytBT8ATdCJunB9GZnETYyLLn/mwgxAy8oUgNM/g2To0gaBggiZWJcASpQADhXBY1mTQeau+Yvye1pmE2EmJTb3NN/qLOZrB2eArrByexev80c+882l6HnuYa5HQlNKugoKCgUH1sHR9i78aHWroK4hsKKwKbj08gnM5i35a2ZaUPsNJi9EgYZS7iKHV1dXjFK17BpoXAXPq6qIYeBTveeeed1kT+pmRREz760Y/iqquu8t3WsWPHcNNNNzGFnEOHDmF6epqdiB07drCAyze/+c1oa2tDtUBBmN/85jfx05/+FI899hj7u6WlhSUzpKBH7vfrBBoJIJ/d/fv3s3794z/+Iz7ykY+gvr5euv6rX/1qNgLB8etf/xrPfOYzXfvI/XlpVOKWW27BYiCRSODZH/kMuhITaMgk0KXp6IvWoy9Wh6lQmLF2BfdKk+1LJ1GfTqAxOYsAckgEA9hX14qJuMTFQTJqbc8fVbqe35iCTCiAI50NONJRj/aJWawfmMSZR4dx2slRnGirZSxfIhL0VNCsmtqYxieJopuwmQ1fLbB888LuFW3QHo9XigIX6BDDIht5zbrE48FDGa4C9s5rdHvL564vWX7oynfLN6qgUC14KGOCx4eJ61lKw/K6nrFJCp4QmU+ukCy6Vdmfy2a5+PySsHy8StPsDJpTs3iguQs5omeNKrBgfmPH5xK3KYsTLS4vXu4Rly2FW/wbefvQVLyeR7xi2fCoKo2304Ha6TQ29Ezh8fX1mI0HpPF49jrmvSyyxRIlTnH/jrziAxXvloJC1Q29zs5OVAP/9V//hTe84Q2YmZmxlZPxxf1nP//5z+P73/8+Lr300jlvjyROyd+WDNVixoomMlgff/xxZgTKcPXVVzNDloMSIF533XX44x//yBIi1tTkGSU3kFHoZegtFuiFR8Y2Hff77rsP25NJjITieKSuE4ORGhjkkhlwqKtpmAxHMR6L4gQoFm8JDCFpGgYb42yKJ1NY3z+JdQOT2NQ7gf6mGI511mG4PrqsRucUFBQUFJYeNk8MYzwUYV4uCisIhoGdj41iJhbE0bW1WHZYgTF6Cgvsukk5KogNIwnRckDGxCtf+Upks1nous7Yqxe84AUsMeHx48cZC0YyqpSw8PnPfz4eeeQRpq5TKbikKfnhEoN3+eWXMwaP5vv6+piBQ5KqoVDIMfnixz72MSa1+qEPfQhPe9rTWD/JcLv//vuZFOtnPvMZz36QMUkGJ+3TUsHU1BT+9re/sYmSRM7qQfRGG9Db3IVkwDweEgaGG3054SqyxFOcbCe3PHviSLZsex4j2m4j3jOxEPZtaMbBtY1YPTyN9X2TeMK+AUzGgozh626vQTagO+fP4X2Q5VySGYpzfIDxGJ+jb5pbzhVZDrtKEcpmsXZiHGsmx1l76UAAaUp7odNvACk9gIwWwFQwzAYIio9LWXEm5bJ3Tgpz0thLBYX5hcjIr//650rvQRfGWowj84ojPvpKf2qTCs7s3oZbPmuVGdKHp+R8CM82Wi2Qy6ExncDeho58fLbkeesVlyd7v8nqyL0dPBQ2/cJ3J+Xb9g2fjKb0ne6njUr7IrkHV/dNo2kihbvObAXIe4m+AjQPFtCaEZk/l+tJQWGpGXpk3DzhCU9gExlKJGlKcqXl4FOf+hQz8giknPOWt7zFWnbeeecxF8orrrgC119/PXPnpN8vfOELlXSXyamSCyUZedQ2uU9Sv51kW2WgZIe5XA7XXHMNW49wwQUX4IlPfCK2bdvGWEcvQ6+1tZUFfdLxI1nXakt7l4tUKsUCRX/729+yc0Eys79NhDAWirEnrMjecWPMZtSZrJ3U5RJOCdMlhiAvkyRHl7kxSdMiiG26uGRmgxqOd9bieEcNmieS2NA3iV1HR7H9xBgz9o511TKj0KG6f9ge+mYmVVu/St2FtDlt0H9/ZAdIItliIZZKYcP4GFZNTbK/e2rrkQgEEc5kEcplWSqM2kwSoVyOxWVSSgwa2T5U24rRSNx+ffDtSc6V7DrybdQ5GIyy5ZtuyLtzHn6XcuFUmH/wVCrc4GOXo8xg4B+MTgnTzbv06CvfP78dPsVw9NXvK3HntJ2PIqMuXyY0oAHxbIrNUtx6xXBzyfQYvPI07mTP0wogTQHh5sbpER9gez77FTCRdgwVr6AJsQWF+zL/G0plse3wOHo6YxhvDkOXCiJxAbbSMpvQjzSJOuYdKy1Gbynj6quvrnqbZC8siqFHzNZccdttt7FfMrhEI694B8nAIxDbVCne/e53M2OR4ujILVNm5HE4MXrd3d3st9igpfwaFE9IjKMX3vve97LpwQcfxI9//GNmzC4GyGDlzOL4+DhjNp/97Gcz1aJrPlKaq2xFQtMw0hBlUzSZYW6da/unsaF3CoONUWbwkbrWKe3WaRg4Y6AfXVNTSAYCONzYhJO1jYzJc4vHa0rOYPPUEM4e7cZwOI7H61sxpWTGFRQUVihimfwA8WxQ/v2gsDwTo5+xf5QZcAc3yzUYlgWU6+aCgfRJqk3gLJqhVy02ibBx40bHdRoaGiwWLJlMVrQdiqMjg4ZA8XnkGloJuMwqybru3r3bKie3zwMHDviKW6TEjRTTRzGCFOv3ohe9iLmtLiQOHjyIH/3oRzhx4gT27NnD3GVp33Z81DTwBBYvJzJ65pWSE2PvXK5nT+ln2ai1B1NTrUSpxe6ZyWgABzc04vF1Degamsb63imcu28IM9EAY/9OdtYUjBsJE2e5cDrt7BwglWk3JHLuX7qu0IMq5V1tm5lmRt7eljb01NWzOEwtqxUSoPPfot0fjcZxT2Qt2hNT2DQ5jCcMHUdfrBYHG9qQCgR9uW7KGT9nYQIvF1BP5RkFhQVi9lYadvz46pLn6r4XFWLZd/2sVJyNMyMPP/9jruvxR+ujL7yqdHukF2DE0YNZ2yM4ZwrdGLnCu5UvP/xPH7TKNn7n0+Z6wgNBlzyE3Jioonlqiv6WMl+ezy2jYs+GhWZQbJot0ocsX9FvQ4X0Cr6/k+fA4tm2bXPDzP/qRg5n7R1B03gKD5zZhExEz7/7rT6WumnaBVqMkvtA4dSAUcWcedUyGhfN0Nu6dSseeOABHDlyxHEdUvLkGe7JPbISEHPGXUT/4R/+wSofGxvD4OAgy5tBxqQXXvjCF+KTn/wk3vOe97B+EbNHRiQZbMQWkjqoFygB4/vf/368613vwt69e/Hf//3fLG5wIUBiM8RmPvzwwyzWkdxiN2/evCDbXi7I6Rp6OmrQ0x5Hw1QK63umse3YOLYen0B3WxzHu2oxGZ+Da84yA39vDdTUli8VrmkYiNVhMFqLztkJbJsYQiIwiscbqqegq6CgoLAUkDOfj7phQHBwUKgWDAPRVJYd30Q4MK9pkiiX4pn7RtA8msT9p7dgrGn5v/NXmovkUsX/LYGceUvK0CO1TWK4SGzl5ptvlhpKJHDCQeIplYDSPxAikQhjsEiU5dOf/jRTleQgw4eEYciII/dFGc4991z8y7/8C1MB/eAHC6OCBGL4/NKrtJ+UnoFcQckF9qUvfSkCJls0X6B9pZQSZNS+7nWvw9lnn106UuCXYZHBg4mZkxy4OHJoBZKJfu+y7YhDdJImpTtjjqaaDY7GYxjbGsW+9Y1Y2z+Fdf3TbBqpj+BYZy36m2Ny48e56XnBhi9f677Pc9h2KpS/LkNGlgmtlLQnYRiL959Ge3vqGrBmZhwBwyhJq+A84m04L5fF9XkGuJeemE2fz7uFEw7/i4rXU1Dwwmk/+VgJeyF7fZ3+8wKTERC9N/jdaNY/85f/KqwniR02HwAi28e/8TXTvU6HYWWrYMvN35yYF8FsZ9N3P1Xogyx2WGhIKyNmzjL0aL+EzApS0TGhvsyzRRbT7Pls9EKV30H2fXFJAVHJ94RhIJLOomE6hYaZJBqmaUohksmfT9radDSIyVgYk/EQG3yl3xmWMsn/QRFFVCg9VNN4Ep0js+gYmkUoncODZzRhrCUs9QayYvVssXe+N62wQnHJEsiZt6QMPXKjpJQE3/ve95jBd++99zIlyq6uLqZmSfnqfvKTn7B1ucplJSC1TAIpg/7rv/4rPvvZgsKWKNZCQZRkBJIwCa0rw4033ojt27fj3/7t31gOPor1I5aQ6jrl0SsGqXaSoUj7TC6f//mf/8mMzPkC7RspmJJx9//+3/9zjEFUkCMVDuDQ2gYcXlOPjpFZ5ta55+AwG1U81lGLEx21SAXn11BfLFDSe662OVeQUUwfZAoKCgorDZahp55xlcEwsLFvHM2TCTROJy2jLhnUMV4TxvH2Ovab1TXEkxnUzaZRO0spkxLWurRsMkaGXwhTphE4EQsjFdKlVhgxdy3jCXSNzKB9OIFwJofZSAC9bTH0rYphqm6FfCvRCHkV3QmriqXarxWGRTP0gsEgy6NHMWKkVvn1r3+dTSLIPfIDH/gAnv70p1e8nZGREfZLbpZk5JFBRoqfZKBRDCCJqJD75a9+9StmFFL5X//6V0eWjZjFStlFjte//vWsL2TQkpH48pe/nB2P+fAVpmNKhqvMyNtxlUR4xSO2Trodj/Wc4hkKhaULaYTNqYK9PXFEVPIwd2UiJVSUre3CH7Rmb1MteptrUDedYukZtnRPYMvJcfS1xHG0sw7jtRHn7dCoobZ4zzd7nnNnjU1xpDZlFBg9q1zsuNmoGBMoy7NIq+UHyksZvXLSIrgqbDq0UyB5K9A7V1A4hbHzp3kWTXxucTZNxmiIkCWUFiHW58jJblHzeaMJ9ypn+dhjVafU5DnbvcxD80TSiT+2bOHLZh17iLVX7Li57SKGzQoHpHnxGSgwdr69E2TweIcuicdbhXGE8UQaZw5OIDs4iqG6GE605Y268XgEiYhppAk7M2wLEDQQTudQP5tC3UwadbMp1E+nsWpohnmQcGMxbwDmjT9qiRS328dmEMoajB082VWD/tYYJuspf4IGnaeJcmTvSq9vcT0x9lRB4ZQ19AjEaH33u991VKykXHvERpFrJDF9lYDi5wgk5kLuiiTMItKr55xzDit77nOfy9Iu3HHHHUyshFwq5wvhcBgf/vCHGatJ+ftuueUWZvzNl+gNqYIqJq96mKwJ45HNLTiwrhFrBvM5+VYPzWA6EkQmqCOja2x0kfLy0S/F/jXW1CGenGF557IBDRktvywRCmCsJoaliEwgPz4dyVSB0csnmVBQUFBY0TF6Cj5hGFgzPIldJ0YQaGrEX3d0Yawm4pw+SQZNY143Q+EYhhqE96hhoCZBzB83ANNoH5vFhv7JvOtnLISjq+rQ3xLDdF3B5VNMtbBSoNIrKCyaoUdum+SqSaIo69evxyc+8QnG3DU3NzNVSjK+yBgi10ZSuvzd736H0047reztkKskB+Wuk/nQkvLl5z73OWboEciddD4NPcJrXvMaxmQePnyY7Tu5b5IBWClo5FOm9rNlyxY8/vjjtmU7r76xbJ9y6ap+YxjExZyoszm+Sx7mPFZCNlpsKyqNTfPOKeSSNc7mjy+rW5jNBIM42tXA2Dx6ibSMJxHIGfkpm0Mom0M0RX/n0JINITwxxeZpuRiacbijHvtXN4GcG6sBz92XlFmJ7m2FwGQ0gtMGB1GXTuHx5mZkeKyeyLqKsTXCyDYhmM1i8+gIGpOzOBFtBPh2ZIfeg72Tqa5KR7e9dtZaJLTj4wON32PVVNVSWHio8+gPQSl7IWPvnFk6pzoyF0duLNnOlXkDi5/fhlmXlgRhsCkrPifMlQXRTRhcIVgss7xGStU52bxLgmtx2IoUqXNmB/RADnBSpvZ4n/j3PnEsKmt5JZC+Wyvw/KHZ3SeGsW5oEt0ttRjb2IYJpPLp9CrqhNgfono1zETDbOpvKizSkRd0yQQD0INZIVbPsMWTOjHWsng8fi0/+LxCHOl8viPU+0dhWRh6xK6R2iQZeZSWgFg0MT0BuRpSbj0yykgEhdwuyRCi3G/loq6uzpr/u7/7O8f1du3axXLikUjKPffcg/kGuWqSgAslcj927Bi+8Y1vzMkllPLhyR4ApFZKcYekbkpGNGFVzNmgtCc3L523GQRamS53TnVksvnW+mU8MD2MTKFH3m346Y+4vCWGCYf0jFRlVg9jINte2LJpEHaOzeCsgUk0jqVxskWI85RG8/t1e5Usl+1WqRdmyXont2xE18QUdoxPYsfwMEuz0FtXxz7KrMHPoMTQg4GO6SmsnRxn891r1mK6pharuVHo193X69pC5dCK7h8v0P01NTWVr6si75ct1Hn0hy7EJLeqxOAwf53i06wBIVud0jLb4F9RWU40rITttiA/kJu1LZfVMd00Jc+dnGD9GcKgldWfYKmKii7e/zkgquksLKQrEkFtJFyZkeRq6Ant+Fh9vmC9bsRDIhHbkbpuFo1jdoZjiDQHMLKpHe3BCLLW4K7YjnMIhyPc6gh91fVciSHHr2HxWrZfq4VBhuI6ft4h1QCpvpeFgh279LBU+7XCsCiG3m9+8xsrAfnb3/52xxx0ZHz98z//M4szI+OLEo2feeaZZW1r7dq12L9/P5t3ElkR16V+DQwMYCFA+0bxgpTbjlI3EMsnMpDlgOINZYIwF154ITP0KO6Q4vQIPbMpx+eg/QFemOVxBzZDjxt/9qeer9grWf6gSuIDbSgjLsCzDac+Stbl6l3F9YurdmdThRelOXOsMYSRaR1bD/dgf8jAWE3UVB3L5aWkQ8HSDtmHt8s39GTvQSnNl/85EY8gFA5i8/Ao1p48iWgggKPNTUhqdFFQAF5+iJO9T3QDoVwOG8ZGUZNO42B9PR5raUaKYlBz6ULf/Y4MO11HdIwy+dhB1rak3+XeP17gAym0rjL0li/UeXTGnl8K6tFc3VIcx3GJx3M09DwYP46cLB6bx9Zp8hg9ep70Y8Zm1GXNQEKeT4/NmwacqLjM5ynKzyoT+2O+9IxsYbmW0Wy/vB/RbBpbJiYwWFeDIdEw9BrQEt4dbodHGnc8V/g0nqTKoF4DtZIyzqpyjDWEcHHPAII1Oga62tCdS7LjLxtDK4cgc6uvhQqdCJgvI014ofJrNCC4cMri8cTlDzxvYePx1LtHYVkYevv27bPmSQ3SDRRDx0VayGAr19DbuXMnfv/737N5nk/PCXz5fAijyECCLyQE84pXvIIZmF/5yldYCodKb37ZA4DSShAzSsb1y172MuYeatkGknacnqeV1HFbvhwGcqrZRz6oJjuOB7sasHZokk01iTQ2942jNplmywbrYnisszFvAC7i/pGy6L6OVhxtbMTWoWFsHxxy/YYZjsXwUGcnJiORqogCRDIZNE/PonV6Bg2JJGLpjBVsPx0OYTQexUg8ytJizND9Wybj5vflye8z9bJd3lDnERWxTm7LHZ8nMuNAtm2XMqexK2qzmLCwPDJ9tuPYtku/ipHlzw/D3/qy7VVjvflAtd7fxXUoPcLJllps6h3D4x2trsSTsUD74Pec2wzvBfbuKHd7ZJMu1dDDpdqvlYZFMfREQyqTybium06npfX84slPfjLLfUegeDg38OXkwrlQIOOLWD1KoE4xe5RfsNo466yzWMzjU6/6LIaitb5dHOdFtUsy+Fdw2RF9Cc3fcvpgVa+g4zImzmd8hZh7iY9klhtQ3t8Qw/qhKawdnkJfQxwHu5oYo7e5fwwXPdaLodooHutoxmht1GH3BOZLWEHmpmmpwnn0SzP3S1xrNhLEQ6s78EiuDXpGY25Zmjl+ogmMcCosSFpLtuN1bem5HJpmE8ywa52aRX0yz0KPR8MYqo1jOhzEbDjEYh6bZhJonk5g9dgk60MiGMBojIy+KBthnwmHPN/cG794Hfs98vYrSpZt+kJ+GbW9OhxBdyo/8nz4HVe45uYrztG36cbrS+8DoV+H3l3I5bf5uutLGPbD73q3Y79FyPZBQcEPxJx3brF1Xkqa0roez5uAhNmzsXeyGD09h6CWQ8bmipKTuKTwukKR5ZFR+No0bO1IblLODApxePT8z1gunTl5vLMP+H3f8vXKYvbcGndqx9WV1MVdswwcXNWIVSPT2NQ3hmMdsZILy2LyvPZVHIxwWdd2XXImWnLN2/JESpY/9LyrsWygXDdPeSyKobdx40abKAspXjqBhFhk9fzimc98JuLxOGZmZlheviuuuMJxO5S8nXDxxRdjoUBCMFdddRVL69DX14cvf/nLVd8GucZOB0JoS07nDT2FJYf9a5rR3VyH2XAQiXDQeo/2NNagc3wGW/pGceGhHgzVxvBYRyNGF1mpM6frVjyLzWiXJTCXwfKl4daygdpUGq1TM8y4a55JMMaOjLahmjgOtzYyA0+Ws7C3oc4SfuFGH/3uGBjGhpFx/Hnr+irssYKCgoIcSnWzMtC77uH1Lbh4JIEzZ6fx4IZWlXlcQWElGHqXXXaZZXzddNNNLFbt9NNPL1mPVDB50nRi2YiZKsZTnvIUyxgkwZENGzbYltN23va2t+Gaa67BbbfdxlIZkACKCBJYeOc732n9/aY3vQkLiRe/+MXMJZViEGUJ3auBsXAMdemktxtOady5WW6UjqzK2DkJq2ZPV5f/Q1I0P+HlErKwZJmfgU8XFlRUcpPGoFGjwfxYuOGSyoCxdSWNa+hrrGEsX8fYLLb2k8HXi9F4BD2Nteirr0FSjONz2h8xzkIm7snXE3Pi8XMuMJa2/lu59cQ69rpi27WJFDYPjaJ9apoJ0dAa6WA+UiKYy8f2kQsUuWAe7Ghiht1kNFT04i/yjbL6rSETCDAGjybCpsFRbBoeY8fA88oynBmyYiEE7i7GmT7pusKFZLF8sutNmN98/fWu1xtvx3ZsJX3c8KXrSm68o2+5srSOgoKJc379IfYbcFHVFFk5L8auEkbPqitl9OQsn06iVpoBw+YDxh9MpWWiYJlhloltS704xPvfZOuK1+MKnyTPL7J9zjtpdcIfDI8ipxjt4rW9nEsWwUe0p6UWB6I5dO0/zvpHxp4limMxep4jh/42ZnO5LP2AsWL0HJht2XW91KHSKyhUZOiRsAdJ9nNwsRPCAw88wIwpEcWGVWNjI97//vcz1cnJyUlcdNFFTJSF0is0NTWx9Ao/+9nP8LWvfQ25XP5hTW6NxH5Vgg9+8IPMYHzsscdYvrq77roLL3nJS6yE6WRc8bhBUr4877zzsNA+1x/72Mfwwhe+EENDQ/OyDXJf60hMmh+JMmtFIvKoe7iLyNwrPZ3hzZe0X5tuHt1H5bLZwmq2bbscs5xHf1lDOjRR71tw77FcfQwP987GGvSTwTc+g7Ujkzitdxg7e4YxEw6yEWUSISBDiYQHrF+9kMsvTYljo2FMxMJsJFUKMVUCd3cSX3oSN1VR4KAgxiPsfsBA40wCTzjSyxi5Q22N7JdWCWeyzP2T+kn9GqmNMrZQCjd3XtFdyuw35Sskg5JVlZ0+mcEo254D3L49ZKqCXh8r3gmVnQ08L3GjDTdda80fvVwZfQp2cAPPTWxFXC4rEyETZvH7kawLFy5nyhwNPZChl7O7XFqumKUjcFnhGWzdYuJ9JWRtt/prEyAznyfic5CMR0q7YrZlhIyKxCJlcD1ksndx8fvIrY5VVvrMd6wuG/B0C2vwuf9D9TH0bW7DWYcHmfF+/8Y2mwKqrWmp0eu+IS0guW6tMAt3101x/sHnftzfDikoLHdDj8RRKJG5DGSg0eRm6BEoR97IyAiLnyNG7dOf/jSbikGJvimGjVi/SkEGHbGDlEePDDpiEWkqBqle8ni+hcYLXvAClkpivlI7ZDUdQcNg7nBW4LjC8gOL5yODrwbBTJa5ddYkU2ZuPjOHn5FjL8tQhpQ7M1ZZOJ1jrBlhLB7GsdZ69DbWOBtWVUIslcY5x/oxHgvjro1d+e25fBxUC/SRyARbaFLXvILC4iBnGj6LlrV3/kE5U+nxJXMtV/CHvqYa3LtZw9mHBnDO4QHct6ndUktVmAP4O3ApYqn2a4Vh0R69xGLdcMMNVvoEYgkpnxy5c9bW1rJE36QWSW6UlAturti8eTPuu+8+pmz5/e9/HwcOHGBsYnt7O2MUaTuXXnopFhNXX301nv3sZ1e1zc3XXo/GxCzOmhzBQKwGGVH62fBi9IRRLYkLBWctxHtV5pFiG4GTuTaW68ZSybPf03XTDLIXXTu8tslZThk1VORKQ+8rTcjqK466WiyZcLwtBlW6E/nSTCiAky2FPJHSvvIRaCozDETTWTROJ7F2eBJnHh/C9p4R3L+pDSO1cbMv4ui15ujOKXbSloSYb8/8DWZzOPdYHzK6hvs2dSDHcu6R4eVTQlzCBnsiALRNzGDL4BiL8WMj8j5HgT1ZPp+Q5yUso3Fr5NzdTbMwwi65CR02seEreXbv6JsUs6eQR0AQJPHD3tnyjBX584emDcRHc4iOmNOYAT0LZENANqIhGzF/o/nfDP0d1axl6YiOLKWi00nsSXNh+ejWzrG+274XOWune7humsv1FHDao+NoGE9jojaMxzbVYbomJDB9olgLf+bZn4OxVF5ULhnVoQUFaX5U8Dzxeg+afbDtsz3Tuz9FQytdj+jO6uUCOr8YaIzj3s3tOOfQIM45NIB7mbGnzz05PL+WJaEptk8RyTtdsXgKp6ShR66Zxe6ZlYLSJ9BUKf70pz/5Xpdy1FH6gkpTGMz3sXrWs54lTXpeKUixdNvwEDaMj2EsEsX+praqta2wDKFpzGWzj6amGsSTKZx+fBhPONiPvWtbcLytNA/jnGAYOOtEP6KpLP62dZVttDuczqJjfBp1iTSiqQwzQKPpDDMMKXfgTIRUNYPM5ZjcOYkN5K/kmkQKhqax5fQrglxBT+sexuqxKQzWxvDIGjO4Xw0cKijMDwwDTYezqO3NMsMumBfIRapGQ6JZw/AaMtw0BJIGAkkgSL8JIDJKf+fYfLGdSbcrGXt5Q1CzfsWJykIRA4GwgUywctZ+zckZtA4lcXJNHK2DKZx3/zAe2tWEoTr/gleRVF56OBlWjN5cMdgQx91b2nHe4wM471A/7t7cAcNmoSmUAxWjp7CCnSlObUxMTOALX/gC1o+P4WBLC47VNZovQmI3XFQhnBK48joyhkVinNq2IJIN1iCphL6pVkCD2/45ddIzRs+lvviBwcOjRMbO0KBrGvRsgdMRYzyMrMmCCd8ILBc5QRaXJeuDyAZ6JXA3y2bjIdy9vQM7jo/g9BPDqE8ksXd1IRDeYvckcXv57RTttLC9+mQSp58YREMihXs3tmM6HkIwl0Hn2Ay6RqbRMplgq05FQ5gNBzARC2GgPsZEaWh0PJ7MoHkqgdWpKSbUMhsKoK+hBgMNcZx7uI+RdNSVmUgI05EgpiMhFoO4cWCCbf/Bda3obiaFWc4gyvbBKDvWgy0uXqVaRqTkepTF7XnF43mmTzHrbPjq56yio298zxw6rrDcUS57J8blNR9Io+2hLGY6NUxs1ZFs1pFo0ZCLaEXrOlyQlKIlA2YEBhIGtITGfulvPUHlNG8gPJXLG4mkKWY2WV8fRvPENLsnMuG8AZhmvzpS5i/9TSxhOqwzhp/+zgY15LQggqkcM/QG26M4tK0eh9cB5zwwjHMfHMa+LQ04sabGnmSdP7dtJKaGaC7P6KViGkvXYDF/TlRTmTHBtjho832rFatEFS23xxFKumA9B21vveJm5JA+b+b4IBS8hobr4rhrSwcz9M5/vB/3bOxANjAHY0/SR+taFkYZOLOtWDyFlQRl6K1Q3H333RgcHMTf1q3FVCQC3T1docIpCmLE9q1vYclrdx8fRu1sGvdt7EAqZB+ZbphOYMPQBGqSaWZUkahLd31dqeKnYTCly62DI5iMhHH7pi6MNkSxuW8MW3tH2ft2uC6Kvetb0NdYlC5BohxHQi1k8HWMTaNrfBobh/KG3KH2BsboUX9o6piYYQYiKZQ+urql0H/F5CkozBtqT2bR+lAWI6cFMHpGhWyWpsEIkSs6kKnVbHn0+LytLAfoaSCUNNCaDGM8EYGWyDOFnC0MJXOIjRsIpvJTsV1F3p2U6zOczLFn4NGN+bRDmZCOO89txbZDEzjt8XFkghp6OvIqvm6IJTJIBXUVU1ZFjNTFcNfmTpx3qA/nHe7DPZs62UCgQpkwlvB7cKn2a4VBGXorFAcPHsSmTZvwC+RdSux5YJ3vLimLx+ZLl1vjtJIyGzyYQZuSo2tDXnCJufJg9CwXQIcYPVeFRYn6mY3RMxk6PS0weoKSWz5ureg4WoqXQtsBF/ZO7LeH/L4MJ9vrMB0L4ezHB3Dx/m7sX9OEwdo4Y8k6x6Zx5rFBZliNxSOIM8NqGlv7R9DdVIcTDfXI6DpqUmlsGh5F00wSh9sbcLCzibGD1MfJeJCpYFJ8TX9zDN2ttfmPIltXZbEiNLobY9Oja0i9M8kMv+OtdSw1gw0y0RV+WmWBpOJ1Z8WOyoL5hBF96nJRtz15aAnRXLgSZIGJcnU73/F4XiPsLh1e//UCy3fs9aUs3/pvXlNSduy17y0p23BLIU3M0Ve/z3F7m/7rU9b84Zd/EJXi/N8U6t71zEKbxTjzl//KDksn4vj1c9/v2ub2H+eTIh/4+49gpYMzGV7sncXyaQYiIzl03ZXB9FoN42doLHG5DH7TKnDkZU3MeU1i6FFZAMhRPF9Gw7SuIyMobHJlTUthkxhDZvwZQEJDKJVjhiAZhcTy9bdHkYro0GnLZl8Pb69hAiu7DowhF9Yw2Ba138vizZw1sGZgGkPNEegh/uCWuVJU8FKz4vHcX7I2DxFJ7LRVx5Yqp9SLpSSXTIXw9oZxfs6Ki8ZqorhrcxfOP9yH8w/14a6Nncj4FbyRPCdtapr8V3wEL8P0CV5QrpsKytBbgaCUFJT+4mlPexpwMJ82QkHBC6N1Ufx15yrsPDGCs47Y03xQHr8H1rchZ/qUUnLydYOT2Dg8jnUjk9Z649Ew7tzQhZFGe05ASg1x6+lhbD8xhp3HRrGpZwKHVjXgeEudo4x2CTSNvfil+QbN5QoKCvOPwIyBzr9kkGrQMPSEQCEsYClC43F9QLq2YCTkTKMnk5WwROTpcFo9ApkcTn94FPef1YzR5oi0+VX9M4gls7h3nUQYS2HOGK+J4M5NZOz14gmHe3HXpq7SQT4FBQVHaEY11T8UFiUWj9JHjI+Po74+L6ZB6qWUG/CKK67A0/7np6WsmeyMG/6YKimVITYtSaJtG+i1GC+P+AGfV6VUqVG6oqRM89+e3/BBvq+2wUQDWEWujumUlNETY/OsMl2yHj+2krxOfvOt2Ypk65k7WjuTQjyRQSibxWwoxBg1cf/4unouh/rpFGPMiNWbjIfzH31iH3kCYfOg1MymsaVnDKuGZ5i700gdGW8RJroyEQ/n2VUhXqO04+Uzll75oyxFVBkpIRzi1aEIutPJfJHLRSG9Fj2uc894PMm5Ll7f1qhTSJS0fnnH1J4wWsIwOnkGcJjKhAHOgNB8MGvLb8XKAoXle19wlS25NyFkMlHiSDxncsQ3G2eJiO3gjF6PMVsQHpR89NtYGxfse9FHsdzx1D9e4creiWVa2sCqP2SYWmXvMwLQ4/nlQSHWSWQG/TJ6ImtXfN5k7pzUbEO6AcOBSaQFRi9TzOiRMFkuICnTS855TlhO26E45V33jaNhLI0Hz2nCeH3Y7s2SM3DB7UOYrA3h4dObPGKjy//Usq7BopjA/K9kPfaHuVyMp7bKJC4C4nqCMrRfTxvrveThDeH0rKPZNUHxuSqpbwB1s0lm7FG4ABl7nqksxHdQNP9sCcfSVlHQfN4EJM+bB57z8WX1zee23gXPvhrBkMPg6CIjk07gjv/5iOe+KMwNitFboW6b4XAY69evX+yuKCxTTMXDLG6PQfbCN0HS12Nx4SXi49uYXEQf3NyGQ6tSWD04g6apBLafHGXv5e7mGjywSanDKigsSeQMtN+eRXAK6HtaALmoJk2OvlJA3gaPnNmIM+8bxZ67R9C9Js6mmsk0mkdTaBpJIT6btRt5CvOCyVgEd25elWf2DvUwY68kRlxBQaEE6i5ZgfjKH34DLRLAlm/dQMPjPgPpyo+tc40FEmMBBM8Yzgh55eirRIDTdbckTJ2MQbGNnM6jJ6CtbQkLKGO0NHOE0qYCxwc1/TKbIlsoWWaPV+BdEFlFccTXLBddL4vy6BV1zYapWBgH1uWNSUrwvvPYCNrGZ4uyIUjYIof+ukI2OG0OievZHGKZDGKpLGMxKdUDIaUHWIwi+w3oyAQCCAbokcljAZ0PtN98VNJrUCyXKag6sWlF6zlev3Nh72Rt+D4HpfFftjLdWQWPcPb/fJj9BsVry6wvywMnsjcBnvPTPDM6z7/Gj5V5U4ij+1l+X0qvncL8DjOWj7B/GcXzXfZ/77bm+TGVMnrCdd6wP4tYr4GRpwBaSw5090YDeZZEjNGTsXi6R2K3nC0gmZeZjJ5wkWVMdo42QWqX8WBayuhlhPYC5snkzB4rM9dLWxLHVFc8/+a2NR17z2vA6qMzWHN4FmtPzLDy6ZoARlvDONgWwUxDAEEt/9xwumbmwmzK2Dvbe0BcN1e6nDPWtlg+XiZ01hbXZ+6OyAxKYcW/iX1weafJQoppmY/DM0WhASxmj4y9XubSWWLsSZ5/1rGXvN+cnjcrBSpGT0EZeisM2WyWiVU83tG42F1RUPANEmahVAnBbP4jaj5QN5NCy8QsM+hIoTOaJOMug0hGSIgMIBEKsO+BUCaHQJFnO7mX7JiYYIZfOhBgrqf0S3+n+C9JuOuF+YweQCqgsw9GBYXlCnLZrNtnYGqLhtSqxe7NwiIX0HBicw1j88iNc6I+iFQkUJaLr0J1MB0J485Nq1i83gWHe3DnxlUsP6yCgoIc6u5YYTh+/DjLOzbcEGWsimbGR9m+V33GD9lc9mShnLL3Gx84E5kICbsnDu5aa0pGPL3i5OxVXFaQsYXSEdY5qo7JYpSE7RZiO/zFKFqsmfhBIYYm8N2TKazJ+iWwILZ4DV4mYWxF+8QQ+8Pz7Yn8Gz+/Fdg0gVyOtaQRxckb8PqG8hol14BwKstcQ9cMTjODkvL2zUaCmKgJo78pxuYToRBmIwHMBoMF1jJLfTIQTucQymQRyeawJhDBaF0YwUwW4UyOxTCSOh8pjjZmkuzvcFbkHwrIaprNIGSGovnLjcaCsagzNpEMxhJFWAmb5jvurhJm1IsB9PzO5cwvJOydfxU8mQqkpRYp9lEyKm/dO1p+d4gcJ5bPYvSsfoh1dcfYKpEtFJdv+1E+tufgi/8VSxFP/9O7rHmRGZWxd8UxejVHDJbWILHLQC3Pik7JwgP53D0ioyVjrzir6oSs5ELi7FZGCGTO8lxBxOgZacSCKYRsjF6ghNHjbGOKcjOYSGVNZlBkMc0yQtp8BoneCVldw3gsyK6noHmt8PridSvbf78xejLDUWT5+DPaxugJ81kZoyeJ0eMsX06MS7WpcprPdxtV5+8d6+kOU3woGKPnEhNYtP5MOIQ7NnUVjL1NXZgNh+zrSrwhZHkibefNrHzh7wqKvLc/4zNY1vDJli4Klmq/VhiUobfCcODAAaTpZUSiGAoKywj9TXFs6RnH2oEpHG+fe2A2uYNu6J/A5u5xZrw9ur4ZxztqC4aTxDXZbuhqLCVEQtPZiPEUuanpUXRHzU9WpwETw0Awl7MMwfwv/Z03CsOmcUjLGtJ5wRv2t/ARKiJtsp0UC0npLcZqwiyXoVIZVVgwZPNsXmIjkMunnFNQWFSQYXcHMXtHCswePScVFBTsUIbeChRiIZl8OrPEtBh8hNpB/cqCLE5OHBGTjaxJ2CvOVNlWk7B7trg9h1G7ou5IYe9OaQPu7J2kD1VCsaoYZxIsiHn23PbbNprKf4UKAX/BhaJ6Jz8HtvPCDR2xqjVQ6xSPZbKAshg9sYrVRfdAQmLYTrbWYBfF6o3N4lhHPYYaIkXHwEAkk4+lq0lmEMzk0NsSR9LmumOgY3QWpx0bZe6Zxzrr8PiahlJJbtu+mqO7hg/lS75zfPRbtM80U85dC7CYPkD48JDcg/brxGQIMzmEjTyLyI3CukQKLVOzWD+cTxhPTOCJ1jqWr5Alhy8j7m5O7J20TPZQkEEywi6yShJ2TjbaLhuVD4jxYbxxkYkuOvYUo6cbBUaP1+fpQ8T+yCD20VgGebj+7s/vLGXxXNg7cZ7YsOghQJ8FjDPSqA0aiAUERs9k2LgCajEoP11x227xaLbl5knkCpn5OjzIWEMsl0I6mLQxfkkt6Mjo0QCMG8uXFq6jgMkMpgWWjz9uRc6eH0cxvtPrOij3WEjZOfGRLvSHs82csbOV2eLxtBJWPSuye5osrk/iquHy/nZkbIr3tTg5qZ+2mZt9EHds7MITjnJjr4u5dpZ4Bpj7aHuUuzxvys39uJShYvQUlKG3QkDCErfddhvLnze8utb64C58ZHsYAjIjQmYcSlgQmzxzkZdZcRXrw87mIsIXuu+jp8iItFK5FXzW9VO/uLmswzevrB3L0BOKcpIPAsuPx/ZFXFgsOd6CA2lJJ+R9kbi9iitX8aW4d0MLRusi2NA/ifMP9mMqGsRQQwzRVAY1iQziyQxzp+QgNfDtJ0Zxsq0Wh1fVI5jNsTx9LRNJDDRGcfeONqbyad9v2T6W7qtl/InXNDuepjGblRhOPiXJC9sVDQYNKT2IVAiYlkmWa5S/MIf6mSTaJ2awfnACGwYmcKytDoc764uMXR+EX0VGnWSnJAazbOOiUWd9eMk+shzEEfiHtFjGP7JFaX8uxsFd60o+cMnQy+WYcVe4ns0PYaGOmwud/UNeaLvIhXOpuHFyo0ZmyInzYhmvE9XSiD0aRnZ9DvHWBCuLmwIshIiWnw/p4gMOpYaQRIwlKxFgEZE2DbiIcP6yEAy9bBq5QApJwdALmv3gLpyi8ScKwlj7nJUfE80sl6XusBsHBYO4GE4G35wMPUnKCdGV2DDvBe7CKR5nsSxjGrB248+wKSqzXzH9hClqI0vTYBvckxptkkFL8W+fA9DFSAZDuGPDKtPYywu0kGiLXfyp9NnCy8Trkj9bVqIoi8KpC2XorRB87Wtfw+HDh3HhhRfil5kTi90dBYWKQDF0J9vqmOHWNJlkBl/r+CyLoxuuj+JENIiZSBAz9BsNsnCs9f2T2NA7wVw+6d09HQ3i7u1tGGzK5/5bScgEdAzXx9j0eGcjNgyOY+PABDP6TrbW4VBnPWaV+5JCFRE4qkOf1JB8SlZ9MCgsSaSCQWbsnX+sx2L2JmPq85aBBkaFwdElhaXarxUGdSesEPT09ODyyy/H6aefjo/856cLbozmMJs9oWrpzaVZfmpCoYTds1XlEsrioCz3FJUkSc8v5/RIBTe4bHTPbzMyQsu2r/x3Dv1y6CM9y2hAlQadpYOWLsSYVH7fq0xczNuUsK6eSa1lrrk2hsllBNrzFHlcB5qGkZoYRjbFnDdH7y/dwKGuBhzpqMOaoWm23ZOttXl30nJOpeZ3PUqtYDZspanwcIsWO8znLMZOWCwRD5AzqPmfdFjH42uacLSzIc/u9U1g7dAkelpq2TGZjoaqz965rucBkXR2kfOXuWvmy0vr8JF3kdHjEBkPTZCkpzk6/GJ6Bb5uQGRvJH3gJ93urinOl7qIbf3BJ/LbEFiQgJkwPmQmbSZEQnkXyHCgUBYNFpizkFnulQJBxha5pU8Q63M2jG2bWDsSPHk4DKxJo7Zj1nLZjAuumyHTVUFky0ThFVlaBb5cJsAiY/TE1AsWC2hoiATSMAIphITlSSN/3acFFwq+X6Fc4ZOH2HH2a7J9flw7OVvsJ7E8+0V1GD3RNdNKOSGsz/tlZ+9Ed9dcSXJ4zpDLWD5WLn3m6yWJ1QtiUWI8hsd3AF+Nl1FogeWdAo+XlRwkXnXX5i6cd7iPxe3dVtOJWf4MdBHMkZWtqNyQTmzpUsBS7dcKgzL0Vgje8573oKura7G7oaCwKMgFdBzvqDslj34mqOPQqgYc7ajD2sEpbOqdwOqhKfQ2xTHYGGfCTNPxoC1fVlkwjLxSZc5gAjfs1zAY+5oK6UyJUAnDrEwEjgSA0QD0J84udlcUFDxBcdh3be7Ekw5248zDw7jjtA71bFI45aEMvRWCmpoabPthPi5ED4pBWnwkW2TnSutbjJ+4moQFtJg/gXa3+evz2BuxzJZeQTZq52sXrf5oHvtSEebCFkr3xd5HI2ggFyRxHBf2TmQgSjV0CqOkugczZGu0lDkrCOZ4MDVWZyXtuW2zLMKnNE7QabE8hYCkmXLYOZftScFEA3icFi+Sxau5MKTivBijJzLjxTG24roOxyGr6zi6qh7HO+uwZmCKMXyrRmes1A4TNSFMxsMsJocba3njLWcz4vi8+LfbYSFDj6WGCOlIhgJMHIb9HQxgrDaMkfq8oI4tRs8aTS9DjMUtBYBQxtk9kfEQWRAWowd7jB4ZrSWQCE8UBJ80d2EW8V6WMAcydlKW/F08Pny/vERUZP3yYv444xUTYu/i6RQyd9UjuDGB+Jr8dRTX80xelPIsuDJ67snT/ULK6Al0d0hLQ9NTtoTpITN4NqEVGO2QSS3ZmEZz3n6cShk9keVLmXF/suTwC83oiSyeeP1yERoby2fOB/TSMhnLJyaSF5fzbohxfVyghcfvsTIrNYm4Fy4uKwGDfaOUrlH+tZMOaXhwYysuONCH9QOTTIxL5kHg9x5c7qAjvFS1ZSocelQoE8rQWyHYt2/fYndBQUFhCYA++sjYo4lUSetnUqifzk+NU0nT5VVjBhpNNJ8xmTn+t+yXz7MpoDFDMJzOsjyDlEKCz5MiamM6i0iaFEMNlreQlFF7O2OYrFFpIZYLsnfEmP9e9EmUWERBYflgpC6KwcYo2kdnmaGnoHAqQxl6KwS//OUvoe8JOWYjtydXdWP0xPUM93bM4TpZjJ5N+VEMuLVYOXHj3vtn70MFdQVW0TUWrpIYPVtDsjItH58XdA8FFJlKHtsg9tU6RWKWAJloneEeClcgHTWPuhL2VaziNugpYwY9oZXP1EnWk8a1STcnsi4+1ndsR9g2z/MuXvMucZS2FCbivvJyGQvopHjJi8Q4szAwGg5jtLE0r6adsffXnnS7Mi8AFhdioHEqhdVD01g9OI1NvZOYigfR0x7H4OowErFgkSS9swqeOC+WWSyXJN7MxoJodkYvSOkVtEJ6BYuhkanHS56dzkndzeebWF9zYSfF/ZOwnGLsoZtyppTRkzJ/pe2JTF5NMMl+cydCSD8WR/wp42ioz7N5IqMX0jIljJ49xUVpf2Sqm34ZPVGdU1TdDOhpBPQk0giU1OH9IiRyIVuqBzZvHc9CWUgXlDqzwZK4xaAZ42dn9JyvQSc2Uxa3KLKWpcuEa9m8ukRVUVu8noTRk5XxtBEiyyfG6BWY6ECJEmlWeOkX3u9Cf8zj7Okuzm8o3YAWdHv2lvNc1qx0PfTcYamNXO432/NEci55ahLCby+5EcsOdIzn+l0zX1iq/VphcNc2Vlg2uOiiixa7CwoKCgoFaBrG6iLYu6kZfzxnNe7d3YLJ2hA2HZ/EE28bwjl3D6OtJ7E4L3sDCE3mUNudRf3RDMITOfXRwQ9NCkj/JY7g6iTC21VsnsLyxFQshFgqy7waFFYWaEDNz/SUpzzFs63f/OY3+Pu//3usWbMGkUiE/dLfVL5SoBi9FWTohf58R4mKFh+Nto1KFy2zlcpG54WBFzFhKmcjbAlVrcClQjs2xk+S9833d56krpQZtLFOpZSW6/bmSuhJWDKWmJmpbkqj4gqwxTry9gpF1i54sXjSjgnHjK8se/85xeO5ti2pX61vdxlTJ1P+lLFhxQt4O9bxE64Ja23/UQPS68iKo9M8+l2ymlR1U8Yw2lXwJGXFbTigEG8mZ+zdWL5ywM6HDgy3RtgUyOTQOTqLrt5Z7HhoEquPzeLI9hrMtAccmS/HmCpJHj0by0FxiNNAYExDaNxAcAwIjxtoRgb1YwXlSCCDbAiYaQlgpkXHdEsA040BGEHNpl7ID4ZTwnQpy1cyI4/bExOUy/bfjb0UIWPvZG2LSc9rg/n5mJ7C9D31FOCGtr8fRDCUQZ2ez50nsmQiW8bZPVGxVASP15OxWDKIzBbfTtbGaBUYPWhphIpi9DijlyYXCmv/TTbYI7YuY1PdzG87KSp1Shgfnj/QzqA6J4ln/ZCcNzcFUjtjZ7KcZqL6/HIZexdwZfRS5vWUElg8ex7BgET51mQBBY8FWwyfsIcl8csO0EymTTNj/MrxIHCEYaCJ3NTpnBnZwmeA5H6zM/Kl14R4zzzvL29nv7+4+ItYLhCFopcaFrNfhmHgzW9+M7761a/ayru7u/GTn/yETW984xtx8803W54ayxXK0FshWO4XooKCwqmBbFBHf1eMTa2Ts9i4fxpn3DWOkY4QTmyPId1YgaOJYUCfBTPkQuP53yAZduNA/nuYxJCAVAOQbNYw2aKhLx5EskFj5aEhIDZkIDqUQ+uBNDoyaWZHzDbqmGoOYro5gKmWAItlXMlI94aQeCSO+BMnEKwvGBIKCssFtdNpbD86jrbRBPZuakIyEkQI6lpeiaCUYm95y1tcRQqd8OEPf9gy8vbs2YP3vve92Lx5Mw4dOoRrrrkG999/P1ve1taGT3winyJnuUIZeisIPCeT7sHo8dFB11g9hzoQ4hV4XiiWs4zX4WUiOyWN4RFHvLUyY94kgWtisSxGzZbPR5u/oSfpMTXZvJDA6HkxkZwYcmBY3bYnXe53l405HhLrHMjPv//GJRuRUiOlm5MyjGKVnDPrJlfQtLfNzqdHv+l8u8cW8tiUosZdYvSskWevuMXibZQBO8sneU7Irm8xj6C5gq2MK94JjCWPlZlqDeLhJ9ajpTeFDftncOatE5hu1DGyNoyxNUEW12q1Q/tjGAglc4yVI4YuNpFjv2TccSFIOvaZBiDTqCG5HmyeDLxcPM8GUTOhLKkK5tsk7iHVpSPVpWGQaD3DQGScjD4D8eEsGnrSaD+UZ7yScTL8AphoCmGyOYjZOpaRr7Bf5jG3X49m3J6w/zw2URaDaIvR82DlCstyHkqkpaqatYE848Hz4mVGghj/QzMinUm0nTmCukCeyavRC+vxGLewwOhZbJngIiCye7yO3xg9MR6Ps3cioyfG6Bl6CoaeRMrG6OUvmrSpvsn64KK6KfabK00SgiZzJrI7OZNFszF6luqocH6tc5CriuomZynz62WclUgFJi8txN6lTFYyI+yf7HoScwby85US8gzy501Gkuja9u0QMJVvPQag6VpnjJ6WQ0DPljxeyh2/js5mcNEDA0hEA7h/VxMG22II0NFxUdiUseZOrPpcFGQXDdTlpdrtOfarvb0du3fvLrve448/zow5wrnnnotbb70VsVg+Z+95552H5z//+bjkkktwzz334LOf/Sxe85rXMCNwuUIZegoKCgoKiwdNw/CqCCa7AmjsT6O1O4U1jySw5uG8mEw2pLGJ7KnwZA6mlyHLfpCpB9INGlJrDGSZcQcYtXljOCf7iPbzYaFpSDZqmGnQMbI5xEQrQrM51IxkmeFXO5JFc/cMMxgzQQ2TjUFMNAUx2RTCeH0YueDy865IHo5i4g9NjMVre8ag3d1eQWGZoHNgloWP3HFuGzIBdRFzkTdbSqolhMXq1w033IBMJj9g8sUvftEy8jji8Tgrv/DCC9l6N954I/t7uUIZeisEl/3howiaF6voxslH2cTRQj6m58XoibEpVvo7MdZLL2Xv+AieyPJJlTy9mCproXsfpcygWIfno5PFCZYD34yYQ9uBHMtbZxFsEpbEkPVbJJj4l6tH92VKnfYVnOt6kZ3Stt1i1dyLKu+ItR5vXFJm27h7MwWB0XKDQcqAF1tYAetq7b6UfRSpv0queTOGReiY/NAK8WrmujZmUFZHRk4HNIyuCmNybRCBZA4NfRlEUlkQCRVIUT6/HGY6g8yYS9VrSNcC4aA5Ai8wYwli5Tzy6EVzIUwjbB2itMmC2OPxCkxbNq5hIh5k/WN9TQE1Yxlm9JEBuPpIAsHH6CMTOLY1jmMba4XjUwrGMFES+myO9YeeT5xhEPdFFiskqkC6KWzy2DFCzKQ7bXF5gSR7vkzdXY/xe+pRs2UK655+EoGwUcLkWcdCch1xRkzG4lUCm+oqj+8TGLsCK6chS2waixEUpYhd4PHtH6J8ErBfE2I8okzR0zreQpmMvRTPEV8uspcycIVNG8tpXrQWsynE7bE+mv3gjGS+b7kSlo8riKZMdVFxX4rnS1gwIa7PDfwbwZPRg4Eg6B0p3145ht5QWwSI0MdtaT5KsT1LxddnTkRx/kW3vdUq+8kTv1RWHxUWF4Zh4Gc/+xmb37FjBy644ALpelS+fft2HDhwAD/96U/xhS98YdmGSClDb4UgFMhCC3DXzdKXgpctwl8oohElulrxOjlJ26J7hsz4s2+71B3M3dCT9d/wcAsVq/MPzwpcCedyTxd/0wfohZbzcDkVjNacZF9khp7EVdK2e26B7RXsn9SOlZbNwc2U4PcFX6VzJGtOmiZcdIOZx2c+v5alRpQkV4btvMjEQSrpbAXnwM11U9YFJ1eobETHyPowe65xcMNFJrySED5WZ9Mhmzw+60+RoRc3wphE1rpMuYFnG1iR9NcynoLAZGuITewj3DAQn8ji9L9OsPyCIvj5is1m0NafQHtfEnWT9pgh+m6eWBvA6KYgtPbS9BH5Y+WWMF1IEWDOi0Ydd9nk7piESCaN/t91YPpIDTov7Ef7eUMIS43IQtvchTIgHJuCK6VwXgRKkNcXjRWZocPLRFfK4mXi9tg1ZipNZEW3UXN5QCu4qQZ438SmzU2Lx87mDmm+y5Jmagaxv2J/5AnjS8+LTIDFC9wlU+ammRZEYsRUItz9VHT3TJtpI0RhGW6Yi26KQUHARTcHTEToZnoFvy6MojCcDOTCzFypkUVYy5S8Nso19ELZHLIRIByy31/8/rcNRrgYdTJ3Tidwo2/JGnzU/aUqPLoI/Tpy5AgTXCGQe6YbaDkZeidPnsTRo0exceNGLEcoQ09BQUFBQWEu0DSEUvmP1pHOQs7CyGwWrb1JtPcnUD+RAQkUDrdF0L8hwrweyJClT8rITA5tx1JoOppEsglItOlI12tAUz7e0IhUd1QhMxbE4P90IjMVRNdze9G+ebSq7SsoLAZGOsIs3vfwThoAWJ7si4J//OAHP8B3v/tdHD9+HMFgEJ2dnUyB/tWvfjWe+tSnSuvs27fPmidGzw3icqqnDD2FRQWNNGvmaKwY4F8QXil96MnZvlJ3J3EkV0zwzEfrcsLoLS8TE6XK0jjYSKk5uG5KmUFxuTm6bqsjGWWsSJ6eCy94sFcaZzUEgQ7fLqeSEWhpSglZmbgPXm6DvKqMDXIaVHVl8gxXN1RZGgaLxXRqu7huGR6e8j5KFxY2U9QHVosYIUuEyJmpqgiS42NzlZawZTLI3CblqSAkRbZb1d+O2epY59VwdZuSS5u7b0f2vEqZDIQoEc9d7jizR8gKEvC0ySSCmMmFHVLN2Ptt257JlnDhK0LQFJ5o7ksxZq55IIU147OomcwgNpNjxt1IawT7NsYw0hZhMXyccYgK8XyTu4Ga3hyajmcQ780h+FjhGsxFcsg16sg1GADFITYayDXmEKihD9pCKgCRvePJzbnBmeoPY2agDom+KBL9EYTq0tj8siOINKcKbJot6XmpS6Z1PAW3QS83TS6oYmcG/cVPydJH8AdK/j4odd2UMoJ8TFvcbK50fTEROIeX6yZn6sQk8vz6lvXFS5hGdmzE4837kBO2J4qxFNi7kKsbapKnjxDEVnRhXgavRPAl6zswevxep28VxugZWdY3ug3t6RxQFiZWB7HqaAItk0mmllvMeHqlaym4R4v3gce+mn1cqu6cyyFGb2JiwlZO+exo8sKjjz5aIrJC07//+7/jhS98IW655RY0NDTY1jlx4oQ1Tznz3LB27VppveUGxegpKCgoKCjMETXjGZCnadeRBKbrgoy5I6GWoZYISynBlTYdoWmYXhVAdq25XtZA3WyGpYgIjAPhCQOBQQ36oRC0rDnYQEq+DTlojTkYjTmgMYtccxaY1ZEYDCIzEEamPwRjOv+hH6xNI9qRRMsFI2g7fRiByFL16VJQKB+kiJuKaGjuTtkMPYWlDdGgInz0ox/FVVdd5bg+iaWQMuZll13GWLfa2loMDg7iz3/+M8t7Nzw8zOLqXvCCF+D3v/89QqHCoMfk5KQ1T/XcIKZnmJqawnKFuhNWCML0hWHGs8hGvsUyKbtnxQLI1wtImMGsOdyWFWXTOcsnETVw6pvbYJOsr7Lk72K5LYG77pzoXYQ1cugxUikb5XdlJFmTGhs1pHgNo9zYQpuojcnoyJgvp267MJWy0VJtzjF6JlMj9tFieSSti2GLwnmx1S/enGxRObEcrqt6HAExRo93ZD4kt2VMtoT5db0evRhpGfMnW6+S8D7x9Eu6Y4k6eIyW20SkzFkx6TOPreOMBSGVMWOUzF82nzYTOBMja7IYqYxwP5bJMGYEBpF7UDxwZjOLM0pFmbJKYR9yep7Vl7AJMpbTYhMo9C9qIN0EEEenm3KjIaL5pzRoYzozAOlXH9eQOxYC0hGkEc/3MZhDqD2Fmm3TqOucRrQzgZr6Qowe9bUkzsxn0IwTU8UhpkPgjKCV6HyOYi28r3Q/GOzNlbMdRxJoLemvFWQuFOpF8XsObJrIgvHrUWSB+HG0CbRI4wwN1+MnsnbFEOPteB/FuLyUkIdExjrKWD4v4RFZma6FbLF6XuDfCG7Jymk2aOQQ1fMxerJ7ohyMrQ+i42AK8eksendGMNsspqYQrkueSkEifiSLg3UEX7xUPUXFd9ZSg1Fgy+rr661iLzaPYuwaGxtLyp/+9Kfj7W9/O571rGexPHhk+N100014xzveYa2TSAjPwHDBzV4GsR+zs7NYrlCGnoKCgoKCwhyRDuvkxzn/x5G+8+sNGPVZK69pNJDO53ec0REez0GL5lDTOmtpoohunAoKKxl9u8KYaQ6gY28K2/48g/HOIMZXBTHdEkAibh+EUVgaICNPNPS8IDPyODo6OvDDH/4Qp512GlKpFEuLIBp60WjUmqflbkgmC8rDxSkYlhOUobdCQKOFoQBPpCqMJkuGmUSpcadlxfPWKKIYM2R+RYjhBlx+VmRn/KZ2qITRszOQZpkQZ2GRL4ISnqVoOIe4vHL6S1VohJdGEAsxQT5jC0V20kq8LG5Q1qBIp0jiyObwnrNVlcYH8hhNw3W9wmLNk90rv2MSOMUwuq0nA50P85xIY+bK7bctLk+2E5LjaFvqvOOOKQ5k8X+F/BKuXfSEmyS7MHIuu4+8GAbe36TA3nFGT0yLwOP1xLi8rMnuZdN5di2jB5HNZYT0FOU9C8T1syZbIm4zYMbt5feb77/A6OgSxUPz+NgV/0TJ/nx5xEzazebNZ36MG3J1QLShNEaPx4+JTJKNtXBhoLzYO2vfbSkQZEqdldMKTjFtdPx0rZAQ29YfiaKnSJrxJOoJgeWyP450xzbFeDy+X7ayKqWccEsYLypxpkSFTSthfKEsYYRKWD4+HzJZuuL+8tjDWdm96vOpIN6XonaAyGhT85FcJj9YoXmzil6gb4L0OuD4mhDqj+fQdDCDtfdl2KlNR4GZ1gBmW3Uk24FUg+agYiu/B+VJ7bnbUKHkxX97C/v90UVfxqKDjQAtUUpvnvq1adMmxu796le/YjF7PT09WLVqFVtWV1fn2x1zenrat5vnUoYy9BQUFBQUFBQUFFYONA0T6wNs0lMGYsM5RAcNxAdzqH8wzQxMyiCRbNOQ6NAwuVXznY5RYelj586dzNDjrp7c0BMFWChtghtEAZbiOMLlBGXorRB8/6LP4VUPf8Afe2fOShk9YUhTXJ4xGSaxTDb6xWP5xJE8v4M2MvZRhCz5u0igGC7KoDIVUNkosBNj59fbQx7DprERXooFkZJgkhi9HO+3eBwlCqKFPGqlsXz5jkv2q1qeKy7bluYtFPplMZWSWK78Cn4PuKTMq+pc9p+uLfP6sgbUPVg8vtv2XHZ+KW2PQEqX/Zep3TpvRsJEu7Bcuqgg6xNesaxekCU1T0sYPWt70k4IvzayVPJMcIm9cbrfZM8oztrpsmTNEpZDZPnsrBt/3pYqY4rgy0VGx4sl4yyQiJzZNmeDvNpxUtKUJw8vZbys5OiShOkyZoyOdcTQYRjE0rpfj7L4N86IhQWWy85KZkvYtKiZeN4vo+fEfLmpbtr6zT1phPuT91E83iEbo5ctYfl4HKIYyyfN9We7tpzjl7wYPX6ti/G0stx01A4VR7MZxIOljF4lMXrSb54gYMSB6TUapqFDy2gIDGuIkeE3lEXTAwbiPcDUkw0YETuLZ9tX6SOMHzPhGjOr/MPfLi9RCP7Zk/4NCwkz1eSSxHz2y5ZvucgA5Ni/fz/cIC4nV9DlCmXoKSgoKCgoKCgonBIwghoS7ToS7cBswEC430DLXww0/hYYeyb5QmPl4BR03SxOvbDKZPMIlAuP/iZ3ThJrccOtt97KflevXo0NGzZguUIZeisI4khwCXvnwNT5LeMjazKWTxzxypijjOJInNyvvXzIRsvF5wTfR3G0nauA2nPvLSyjx1TFkEUol88T5LQPtpgpU21TjC20WD5p3j75MZH2v4z9dtyebZsiowFHZVD7/pkzYuykrY5zfzzz7YmLqx13T0qINLF5k7200cr8vHmE40lpImFWRv0WKrtCeq36PQ62Q1vKuvIO2cQLg7mKY1nF55IVTirG4Arqlpy1s6tuaiUqmFa/RAVNzpzxC4/U/WRMrI1hNipQGC31cuBlIlsiW08WoyeLFbI9W12YKjF4OmsyOWK+NVnImK1t89iKbJ/I/jhut4hNlNWRsklmhzhrxpZLbgBruUE8XoiyySOqFUQTZOwcZ79Elosvt+W/Ew4K35+QwLpy9k+sEzKZP/H88jLbPtv2VRJTKE1sae8/6xdn9IQLTzzeKZPRE1k+rjpK+eoKfTCvN9nDqgxIY2tNVc6coBrtyuhBZPRKVTArY/Rk94bw/SIsz3QCQ38HtP4GqLsbSD3ZgVV0fR5LJF3FkqVKq61AHD58mKVV4PF6q1evtulIUNoFUuMkxu6OO+7ABRdcUNIGlXNGj9bn+hPLEf6yliooKCgoKCgoKCisQGTrNUyfbyByREPw8Mr5NCa7eSlP5eIXv/gFMpnCQEsx+vv78ZKXvATpdH5A6K1vLSSy53jnO9+JYDA/gEXpGIpTJ9DfVE6g9Wj95QzF6K0g8NFxUq9yHd2Sxeh5MH+6OSIoY/ky4ui1JI5MFnvnmT/LRS3UiWHiy21KX7IRUUkuJK+8XuUO5tjC5Iz8SGo4kM8TVNxHGaPHl4uxGRbLJ2X0xG0LdVzz6FUpzkoWJymWmfsi+sxz9k6MDZOqiYrgdewJB0vX84hHlJ1L3x4kugGNx6dxRsiLdcs5M59O8XYWa1kBoyfPM+hex209Oxtc2i1DGLWXsmR8PQmrbs+JaZTcG1nZPSEwupmsc4yerdv8mqfzx/tpUwt2Z/d8M+Q8hlHMLWrOiwnTufeFmMOLz9vigyQskCxezctrIp0LligSS4d5hV3hLBGv6wXxmS3mNZTFxxXi8YwSpm4mV7r/tlx21kWoQc+FkctFbPyZuG7xvojvQZkSqa2PWinDyJk6Ma6PnwNbmUSxVMbi+YXI3vHjmRb3RTgCfP/TEkZPZDQt9tKBiPLb3yDPwWhj4vh1Kcbo5eRxq4zRSyMVTLL7x359V37MxOuRP0fE/nBGLyNcq5lNOaS6gegdAcy2Z2HUFTPSkptGGssri51dOcbjYoIMMDLiXvziF+PCCy9kLpWU+mBoaAh/+tOf8JWvfIXNE570pCdJDb1t27bhyiuvxGc+8xncc889eOITn4j3ve992Lx5Mw4dOoTPfvazLA8f4T3veQ+2bt2K5Qxl6K0QOAWeKigoKCgoKCgoeEADZi7Iof4XAUT+EkLimenlr8S5AmP0KL6O8uPR5AQyBL/+9a87Jl//5Cc/iYGBAXzzm99kRt3LXvayknVe97rX4ROf+ASWO5Sht0Lw2GOPWTlb/umON1rlYXN0OCf44bupW9rz6JWyYGJdXRKjJ4vlk7GAlUCmpiVjDkUlOz7Sz0c0PRk9xxi98vptY9UYo5dDGIUYvawtP5i9/6wfXOVUYC/4vsiejTK2ROy3PB6xrF0qa9s2xkfG8lqqokJdj7g+q9/CceIDHF4xiJ5xbe6LC+sQK1OQ0ZSAd1xky80+ivtaSvLZ3VjmwOjNKUZPUsd2CiRhe0bWg9HzySBbMba2a168ZswReCE/nvVMEMqs0yOJnWN5u/hvBcyv7NqysXecyRGeQTKFTT4flLEcwkkPSVgSMY6Mszfic8tJ/bKY5RHzDHL2ypZ7zcwvl/FQ7yxsV2BaBZYkKWEEC0xdriQnYEQTYvTM/YoHSmPw6MIM5kLI5OjJWgBn4Gy5/EwmRhYTaGcLC8ckqqVKc89JGD2+XGTAxP0qbE+8TlAWhFBmK5YvLcYgSuL1EhS/yLdnbjukCSyfLHei8J3gN3+ibp5fm6qsOS8yuyGBqS6wgHlGL2akkCNPJM2Yc4ye27eMGAfJr9G0rtvLIkD2kgyCv44ger+O7Hni1ZXzlUdP9jyZCzupUMC3v/1tJqJy++23s1g8Yu8mJiZYnjtKgXDRRRfhVa96FWP73KDrOr7xjW8wg/CrX/0q7r77btZWa2srzjvvPLzpTW/Cs571rBVx6JWht0Jw/PhxnHvuuZIg5GyJO5AMhQB+sazUOLQZbeZQly0IW5KGQQavB7hbfSf3Uj4vijXwjydZHVu/hQSufvsoM2pl/WKGXi6LiFZw3cwILxeZyAw3BLNiMLtlMPlPKC8z9NwMPNk+O50LmcupVDBHt3+o28VmSo2//AL+AV+6PdF7xuquxBgxa0n7XrqeBE5VpRstWkXcFWfbT3DrLPqG4EnZjUrcNGXGVgWWnmWglZbZtiBey6YIgx7y91Fju07MfRavE9v9bS4X3TRz2VJDT+ZKZe2Dw3Xi16jzEnDiSeFtydElxl/BTbPUkBOf1eI8FwURDQ/LsJQYFnYBD/PY2QRTSt0BRaPM+hC2DfjpZbtucll50fjj+8UHIgmUNDu/rGCgxIUwhBIYGsJGCCnmuikO+OX7GLUZjLlSV0rJsQujEPsTNV07ReEVXiYz6kKSZOPi0eJhBPnl/u7HLHdnFsp4kh5xe6IhmOIDAsKLImSeN1saDcmpFAdEC30QDErJdcSvQRrMLOxfviysC6I1onFsibHk2HmMZdMAc900bOeoWoZeIcm8cI3qpdclN/pynTpy56UQuCsCxHMwdpn7UWZ6hSUhxkKbXao2ZgX9uuSSS9hULTz72c9m00qGMvRWCMbGxha7CwoKCgoKCgoKyx7G7gxysxoCd0bYb+4sMkYXu1cKCuVDXbYrBKOjo9b8f194szX//+58PfsNiUnEJTSAXDbbfZTckvsWRgG9EqXOlUUqXiabl6V28FqPz4sj7LY++hx6krnFUtPhbJaNaPJuiC4yloiMZJSUJ6Bny80yWUoJL0ZP7L+MvfA72uiU2qIkwa9kvZww7Mxd8kRxCM7ysToW0yWwRZxBFdkba5+83PA89k/iSilbxebyZzgnsLdvu3QZP/32rtocIsVNeMPLXbO0af9tyo6tE2vKGT/302FdH6I7K3fJtLn4Shg/0eWQu42K14R1fiSnxbZMPB+SPspSYFh9k6VuEM61LDm6zMVd9gyyJxF3Z1gKeTxEmjvnKIgiHs/ZbLiEqZG5XIoy9G7PZdEN1SZdb7bJmT3Wjk9GK22yQEHB5dBiFQ2NuZWSq2JIkkohKzxbQiZTJx5bmRiLPUE9ZwElTJ3kHFUitiI+yWRvHov5k0r8i6yx2CZvSUzgrjv2UWSaPTIESJE0XXzTOeE4Bkr3RsZEszJi9AIpBAOJEtfNOQnY2Lx4SpPMW2JDJrMnuimneZjEE1JIhQxoD4QROBqE9sQkjK6ifdP8HTxRJG8hoRmUwmJpUnpLtV8rDcrQWyEYHx9f7C4oKCgoKCgoKKwIsIGbPSkYGzPQ/hpB4Ncx5LamkTs/xWL5lgVWoBiLQnlQht4KAakHTU5Ooq6uzlZeiM0oHd2SQSaRbP6V/zEkMWriaKNZRYxRkW/HJ8MiwGLnBEpKytRJhFe8Ujy4jbB77YNXPCIxEZReIaoXYvRkiVvFmMiMORotY/lEyLYtZfTKEJ5xg5MQDkdWEqPJT0dWFK2w4rFKWT5Wbu6/yMRZMXxSxk78o3RfZSg3zYJmjpZTHBZbzUoRUDrabotb5BsS1rNiFLMeMWOywD6tSnF7XpCwVxbBwFNMFM3LRvKlx8SQpFLgo+gOcZs8TQePy2Nlwnyh7dLrhF8HBbEgjW2n5Ki4sYDiag76JPyeksX6erHKXl4D/Bmu23aMP5cLxz2ZC5cIq/D7USwbTcVL+ijetynO6ElSV4jrRU0RFZHEsEnWS1h+Wdof8flX3C8nYRA6Zk6sj6yOKGQjtmHV8UjsxVki2bkSYx4LzgnyODoee1dJ3F6h307l/DlRPjOWFeJt+aGypXYwrzdZmg6biJAZVeh0bDm7xxm9sJ5C2GT0pOdtju+qQkqKUmZYLLNYPuEGZ/GErYDxggQSj8ag3xWDdiIA44IksImu/VJ9Axk/GxHiFRUUFhIqsccKASkIUQ4RBQUFBQUFBQWF6oHsXX1HGvpLJoHOLPQ/xaD9LgZMlWegLzgM0+5cipMi9BYEitFbIbjggguY5OzTn/50RKNRj5FTWYye4ZrgtDBfOjZgG93kCosOLFc1lKfKSQEhG42W9cWK0XMY0ZXHMLr1UYwZAsIsYXohRk/ch6A5km1j+cyRVbH/nOVzShhvbVtM0+CiJjrXUVLZOeYjwjLmj7N94iixjOVj9c11RSl9zoLJmDinGD1XRs9xidlvyfrEFtOIc57Rs+9ffl5SJkmVYJWJI+PC8SnUkbBpHoydtXiu3x8yetMKnRRZPKHfUobZ/BXZDfO6Fs+PFYOXKYymiyQPX86ZPbNR5z4azv1yZPQk7eQTMphF5n6LzwMbmSyNiZV4C7hs2WmZxcoJib04U5MU1BSt2DpJTNx4KmaVTaQjrs+/glpm6TNUluhdJDFkKsdShWThOVmIGJwbOHNki/WSKGxy5sheJlyj1rsu6zsWzIJ57dmexbbVrJuiAJdnlSlma7ZpticsF5nB4j7k2y701q3/UXFf9NKYUH5MbHGiZodCAffjFJKmpMirbgb1FDTdZPQ0f0ysE6w+eqjOylg+WdweKWZzBLUQUA8kn5FB9mgImdtqEPhxDMZZKWBrBogVfU8JxzO2SDF6CgoVMXr9/f34+c9/jg996EN42tOehoaGBmiaxqarrrqqrLaOHTuG97///TjnnHPQ2NiIUCiE5uZmlgvj4x//OAYHB+d0lmZmZvCDH/yAZbd/6lOfii1btrDthMNhtLW1MZnWz372syx/hh985zvfwVlnncWMKcrZceWVV7IcHk549atfbR0bmn7zm994boOvS3X94slPfjISiQTLLaKgoKCgoKCgoDA/CGxII/wPY8C2NLR7wwh8Lw79dxFohwI0GrNkwMVYluqksEQZvc7Ozqps/L/+67/whje8gRljxQqSZLDQ9PnPfx7f//73cemll1a0jUcffRQvfelLpcvIuLv11lvZdM011+A//uM/XPNpXH311fjoRz9q/X3y5Elcd911+OMf/4i//OUvqKmp8ezPRz7yETzzmc9EtUHGMeXR++lPf8ri9YjZo7LvXvBVtvwVd77BdeRYpkTpBRnLFTbLxNFk71i3XFksmS3eTqjLy235mmQxQ5LtWiyXJG6vnL4WmDwhCS/F6OlZprolY/R4HXF02y0ZvRdkCeplbMJcGT230XuRBbBURfXSeCwZy0dIW+yVGMPHR5NLYc8TKM6XrlvuflsKkeyBmWXxJ0Y5eQQ5E2Vj9Hi8Wa40lk8k+mwj/taapZ0sg+V0haRpGUtni8WTHU9bHTM+TpIwXlyLx+OJLJ49Px6/eXzugy2ZYdE6WlEOQykjUrpMM+9/p7SEhbyV8BX/6xWXJ+aw47F5PP5JvM7E/HcyRm/GVNgcSxa8PaZTkZJ+iwqMvI/pbOmzPBpMu8ZOy+5/maeFk8qxGwrPYI3N02RXznRmhGQKm7ZE5pK6IuPFM/zZnt88bk98Vpllttg4MXbcqlNYnDOXy0bfZXqOXvF99uWy68yDqTRK8xHy2DxR0ZRfMzaWz9puzleMns4YvXwePVlSe1Et1Qs8ltXGRFoJ00V1Vh63Wrh3Ekao5PzKmMgQMXuEGBC82IBxnobE4zEYj4eAP0dhBA1gQwba5iyMriw7aXE95XsfFBSWlOvmpk2bsGbNGmYslQMy4l75ylcim82y+DLKZP+CF7wAq1atYsm/v/3tb+MXv/gFhoeH8fznPx+PPPIINmzYUFEfKdP9xRdfjCc96Umsja6uLstQ+9GPfsSmkZERvOhFL8Kdd97JGDuZwfixj32MMXmcyaR+kuF2//33M/bxM5/5jGdf7r77bsaG0j5VGy972cvQ3t6O//u//8Nf//pXPOEJT8AznvEMVqagoKCgoKCgoFBdaFED+mkp4LQUjAkNmceJ2Qsi8HgIRiwHY1MWmR1BBFoXQZBFHJVcalii3VppqMjQI+OGjAiaWlpamAgIuUWWg0996lPMyCN88YtfxFve8hZr2XnnnYcXv/jFuOKKK3D99ddjenqa/X7hC18ou6979uxhDBe5QsrwD//wD8zwIiMzlUox1u7HP/5xyXrk/pnL5Rjz9/a3v92Ki3viE5+Ibdu2MdbRy9Ajg5NYRDp+z3ve8xz7VCnICCVGkthPMvT+93//lxnU5BaLLg25Jmf/cdnIsixeT8ZoSUfbzBx7Tsv95qWzwdy22G+ZmqjI4rkpYtpH2PN1QvMQo0fdjeQy+Tw6ZnfEHFdcbS4ojnibql88Vo/NcxbII0bP3u/K2QTpfklGjqWxN8KIb4FpLY03lLF8BD6ImhWGvDUzUEXGyHkxel4sXrEqo3QdIx9PyRg9zZ3RkymIij0wOJMpHCcb4yWJ6yvE6LkzdV4xfL7hoioqhhbKZT5LmTqxX9a8SLpJVDdF1k2msFkxNHmMnvTY2dhLWVMeHgsSBt3tvrTdYzaF5FxJjB5XxkxmgyVlCaFswmTvppIFFm8mFS7tj0dOQIozLokn9lDllKluut2P5T5rCbK4LielzuI6Iosnb0dk6vi+Spg/Yf+sOpqcGbSW2+LorOBSq0h3iccTWTyvGBxLqVXzz+yJrB1HTi9lxkKGP+MlbGPG8nVYblk6bnoSgcAsu5ekrGsZ14SVy1X8TpDE7VnxeIL0Md8XkeUjxWwpE1lUNqOZ91MzMHtOFsbZQGogDO1QCNrhICb3tiLYlMave37NvnHpe1BBYcnG6BGzRQYFGXmV4rbbbmO/1IZo5Ikgg4jjb3/7W0XbCQQCngYVsWs7duxg807MZHd3N/stNmhXr17N6vLlbnjve9/Lfh988EGpMVlNg48YR2IZyW318OHDaPhFEDX/pyPgLxRRQUFBQUFBQUGhArDPzrYcS8NgvGwaLc8bQKgthd/97ncsBOi///u/MTs7u3B59JbqpLByVTeJPSNs3LjRcR0SeeEsWDKZnNf+1NbWsl+n7XD3R1K23L17t1Xe19eHAwcO+IpbfOtb38pi+kjMhm50chUlt9X5AgnbkNgMsY7kMvrb3/4WA/8zgJlzskjuIl/40pgBZ5JHdxxttY1kWupm8oZkLFLZI7gOueVs+fx8wB7/xhlLw3fuIVm/LSZPXMbyBGURpjw6fJTcpu7GFcFKGVbdFqMT8JUT0N7HUpXAajF6MmaRxwWJsTdWPI7QB85UpsT4H4lSYUayXFTqLF6/tB34YgFlKGb3aHVSYKORaZHRE48JryNTELUxn7xjNkZLrMPvR5EG4/Ffpfsn3Rcbg1a63Eu91S1er5z3s9t2PPuwmJDkLXQ93mUwyDJY8XYCEyfzOhC9BRLZkE0hk82b98xMhkeUFZi86WSBxcsI6qbWc0ncnnkPB4T7jTMrIjNixRY7qG7KPBHCwdI8a+4sn/P7pJi5k717RGXFEmjy9fjzX9TV0CW5/mRsE2eEvNhC0YMkYLZtixm08ggK54DH8gn9jlZBzbp4O5yBExlkvv9RTYg3c7mFxXMhHotwEaOX01IIaSl2X8mOmd88gGJ/RAaVX69ifjyrTNg/ft5SwnWQyIUk50imSC7st7ncum4DQMOGSTa9fdNXmcfVL3/5SzzwwANsMJ7Chart4aWgsOh59LZu3cp+jxw54rgOqVlyNUxyj5wvkKFGNxyBM3vFeOELX8h+Sb3z05/+NO644w788Ic/xGWXXcZcS8kF1AvxeJwpjBL27t3LRnQWAsFgEBdeeCFjSKm/sft0BPsXZNMKCgoKCgoKCgqUOD0SYd9h//qv/4r169fja1/7GlNzz2TmKX4vt8QnhZXL6JHaJjFcJLZy8803481vfnPJOuR6yHH55ZdXdfuk9EnuljSqQnF3/Cb7l3/5F+n6pGhJy0gF9IMf/KBtGTF8opupG2g/r732WrZtcoGl0RxyL10IEHtIBiuJyPTf3o/jzxiBES9ayWlQyfA7NuBx58oYLXNkzYvZK4zqijF4IuNVyl75hWzkVNaOt4JoabwD5QyjttjoraVuV6rQJqrkBczcZLpEvdQrRs9LYZPvVzlKZjJwBlI8B5y1ExVEg5o/VVExHlEzWQmx31z9j49oi5DlCRTLpQqqHqPExcwpY/SyeWY2z+jx/ZfE6Amjs5yBtDF6PG5NSJDFY/lYue4vRk/ziFEslKFsuMUgesGuOlq6XM5AcgatlMVks26PHlm/nFg3+k/3Ie3Nj7fIIEtZvuqwKfx6S5XB6E2lwyWMHr9PZsxlhEQ6z0qk04W2ZeFhthSFnIkTzl/IZOLEeForRs+WErKU0ePxfeJ+ecVJy/Pfud/LnE2RqS6KsVec3RHjrQq58+QKnNIYPskFnjK3w1UcxX6J+8Vj1di8GSsn21cZyxUV6qYl7x0RUSnryFUn5R4yVnyccKFwJk6ErEwGW1ybua/MOwIaMloaYVLeLIrRC1RJIdrK2yqc37TkmkiZ/QoJzJ+tP5YyqnCcJM8R2XUiqpcSSBX9TW96ExMAJAV6IjXe+MY3+lJvLwdLOY3BUu3XSsOiGXp0QVNKgu9973vM4Lv33ntZrBwpYpIhQiMcP/nJT9i6XOVyriAGzo15o5x4r3jFKxyX33jjjdi+fTv+7d/+DY899hiLL6T2SMClvr7ed/wcGYq0z8Qk/ud//idTH10okFH52te+lgnHnHbbWrzzne9EXV2dtfyf7nijvCL/EJC4F9ohSajOH3rkjn4kCKPGQG5N1rr69IQB/Y4IjDUZGJuzbFsyV8pCe2KZuzHm1+VD6rrpKbLgz6Ck7xwygELkCmW2mRUecLp5TEXjz3r5lmoxSI1xWXLgfHVn100Rfo9T1st103R5Cdo+9AKOYjMp4YXKjT+xjzLXTpvB6JKg2rbc8zoqRfH+MUMPWURMQ48vF40fyw1X+BDmKSRsAi1W8nfB0BNTTVgpGTRf0v0yQ2+unkAyQ6+wTHNPRWETozH3xSOdgdVv4T6w1ZEZetaq7q6r0mVS0ZrSxr2M6LlAJmQkDjDYrn/JQA8XXEkIbprc0EsIRl0yFbS7BBNEY9y6j0r7pgvnI2Omu8gG5CJKsv1yE54JSkS7bM8q6fO98CCkdmgSP6xlwhsy10zunieKhIjwShdQ2h9xO/njPZMLlxh/Yjui8VND6QWKn+WS9ALcOKwR3CfTghFRGLR0N475O8brfSmeA/6cFY07S6BETPvBQz1s7poyUZMce5ak9AxiWto09MTrxLlfXhAH2/ijVXx/pc0+psS0DxLjT0w5wg09u/HnLuDDEdVLk+uRuyaJ+lGI0pe//GV89atfZd9kyo1TYUUYeuROSKMYpHZJRsfXv/51Nokg4ZMPfOADLCfcfOKMM87AV77yFXbDeYGYxbmyi69//etZknYyaMlIfPnLX86Ox0KBYh/pYXLDDTcwhvJ1r3udlXKi6jAAvVdH4EAAgWP5F6tmaDBCBnLrsshtzCLwYBAY0aEfDsLYm0VuZwbYmCokLVJQUFBQUFBQWIHYvHkz2tramIcbqRxX1dBbyqInS7VfKwyLZugRiNH67ne/y3LkyUCpASifHrlGVsMQoZxyDz/8MJtPJBI4dOgQS5tAefSIySOj57nPfS7mG+FwGB/+8IcZq0l9uOWWW5jxt5Do6Ohgrqg33XQTPvGJT7BUGc95znOsBOuEf7xddKeV+V9JGub3LUnRP64j8nAA+qSGXEMOqfOyyG1JQ5vVEDgSYFPoUJAlF808JwEaJNTvDyPwlwiM28MwNmSQ25oGujjL587K8FFkmfulF3sjTwFRvuumDDqybMQ5SKOY1sh5KbshjjbzoHfRLYSPpsrSYjgxdgGX5ZW4boqCMRy25LJmv0V3IO6KZU/+XNovzvKJrmgy186AwCC4sQX27VSH0YsYlPjeZPTM8+CVXoKnkLCzfHzEW2DxBOZE98no8dFmmQBNOfsqQ4GxFMokN73YR4uJFJQiOAskusVZzJ+NLeNlhbZt7J6MeHH7IJKwc/blfl03SzcnE8QpB9Z1IrJO5q3glbpArMOFW2b/f3vvAS5JVeb/f6s63r55wp2ch5lhZmASM8CgZEGCKIggJlB0Ydmf+OO/LriyumAAAz6G3Z+iorCLLqKii4qIgSRxGGZggElMYhKTb+7bqar+z3u6TvWp7tPh5vR+nqdv162ufCq95/uGtKLouUlWkoqiZ7ltoC3hoeyjqjp7FQCUTUi7pSbSrgsnEdQkY1GRSV10iVfUceL+mHeuSuWnaLIp+Iulq/dR9f5ta1Q+6VZZzO0xlyRLKQ5eIixA3Ua5DXE7V86i3coVq9epPO1mtMDFL1cCwilQ/pQcIv7SDe4Fqy5HVa0qRR5XVYnzjqOviHzODVNiuoqf2jY+l1x3f0KGI1w36WSLGXZW0VPvb7KwfEl5Xo+6x5bGkyYt3WcVRU6n8pmK77L3PFFUPm2CHs3FUKpgOmVi37Nnj3gn7M8EfczoZNAMPXLbJFfNlpYWEZBKxgYpd+S3TFkpqbYdGUPk2kiZLikl7fHHH9+rdZJ7pZoxk+LurrzySqEsfuQjHxHqIqmKH//4x9Hf0DpIyaTSB7Tv5L5JBmBPoV4gX72rCqBMoRQQTBmg/vSnP2Ht2rWisDwZxHSsypTrKnrrNQ8biK4JIHDURHqGjeRpadhNjmusAU7YQWZpBpklGRgtRtY1qIFu9w7sdydgtxui7oy5LQiDCo5W28DcNDAlAzRZvgec/yDotqw3PWN91KsmArry4oh0rm+639Um7VHnlxfFhT6hN9utGec7xzTDZcflfRcb7s75q9se739H2Y7ebHeF+49y+5q3LcX2qyetX2obfPRku7s5ri+RXpuVLrs729ir9s/7LX9YN67ksotso45yXq6VbGOxZZQ817X3Cd39pMg49VPJlmvvwUW3vHCeSs+aUtutm67o9hSfxxc7q2b+1Y0r4X5d7BGTy7BbuBz/+nTjdNul+z27TPkp3J7CcZWiPbUczbLL7Z/u9+6co3nj8t/TSHQgwYHeTcm7rNx7XHff81jRYwbF0KMSBldddZUw8sjYoAyWanmCqVOnitp6VBqAjLG9e/cKQ4hKBPQH5DpJhiVlwaRi6JSwpLHRrS7eT5CrJiVwueaaa/DWW2/hJz/5Sa9cQltbW7t/A1CKyi9cuFAYehQYvG7dOsydOxefXfJJUf6C4vr+v1e+LqalMgHFYhOMJBDdbCK014RVayN9vo3AWHebMnkxRbLHq8aLgs715EUBY6EDkF3fbMDcE4SxNwBjpwGHkihU2Vm3zqnk4pkuMPz8xWVlgLvSA68t8VCZouefB5XhANFMbTZRiTuPEo7loSoeshdZ7b2XCQXUrTI1baHun9xvQ9ubrlMsS++Kut3q9uZvt6r8WW7vtro2Gbenqpi6lO1qnIzsRfbFzjiFPe0+dUuO0yVwQTfLK4jTNYqISCCQe3nwlZyQ26gqerpx7oFWE7BQ0p7cPHL3FNVFJkdQD7tG0ZTT9TaeTPfSo4vLVOO+cuKOWZgIQVMc3hff6E4n4xfz1+3IWD/fy1OFO2P4B5vMsBiQs5cqT+FP7lOosKi991LVUFWCsJ29+QUtJUbJVQl88T+e6pDb2LSSZEWOV0uOhDPZR3jM/SZS7rBtVfaCLvbLvT50x1a9ToJWtjMykokUqFK6eLvsvmbHB5XjFMlkx0WV4gVV9BCgce7xEtNRSRqxjpwaEnbnpRfnQCabuMLR3P90d29K3i8x3WGZlCSfnGKv3Je0U6LQO8G9r6WUGD3HLYWRXad7T1TmSbsqWEo5jjIWTpTmcQm4sXmGckwyyu/ymDpqkhRNfFhQcy7rjCxV0jWkWuqLk3a31+c1Ype8x+buUdmL0EhOEOWRxCXuOwWz/wR7kCDe9u1XYc9CrgNCeTZ668sRVffV3f+AGsPnKsPquKDb7kElGc+Fkx/03tVUHn/8cXEcqDY1ZZovRyXTMMygG3qkHskC42RYFatBt2jRIqG0kcpGRgjJ20uWLOmXbSI1jww9KpXw6KOPCuOvv6F9u+OOO7B161Z89atfFSofJWvpadxdpQlhikE3mjPPPFMYe2R8//SnPxXLpdjFNrMNmTogqrjsiJt5CggeMBDaayC820CnASSX2cgcZ2mTJ+jqupVKIoIJ7odi/ZqpcGEAZtwAOkzg+SBwOA2cnvAvRxmWLx/F6vnkb5d/OZVmAS2D+yIRDzd7TxfdC7NqwMgXhbTy8i9fOCzNvhZ13dQYdbpg/Ur3yZfJTNPAcrvVl1Vp1KnbLcclbcW9TH2hcn9XDV3pxqa6RUrUun06N059/cbK95WgyWm/WgJtvmQsWtdN3XZrDHmfO6dqCEqjR+Om6+u00Bl6JRLQdIdSyWZUfAacHKfsv5dVVrky5XJ8RqTGVU7naqg39HQv63opUg7usxPdNvQ8l2rl2vEZMK4poLqxSUMopL7Au8PqeSuHVXdNNVmRHK92jsSN7AtllxLQnHQf677jKNuymOumUZmhF3L3TzXQZFIQdf/UjheZbVPtJCT3Z6IqqCQUCWZdEjPub2IfpDETUOrbSgPGMYQBmIkchqN2QJaw/uX9SSzbvR6LZTHO/V6ZkaHeg2UbdSnumnHXSFbveyJBl0vEdbW0FKPNkQaaYqhFzOzzzpEunHm/G9TjKtogNy6kcRuUrpS+Gn2+TrLsfhvqtewUnlvS5daXVVOzbHLT9Ia9pC5SyTMQi+11XTfVe152ONRLQy/bNecfl3YNvJTqzumuTzX+VaPWdvc/oxhwcNx2Vert2a7LbkZx3aV3qXz2798vDD169yLPtkrodvwex+iNegbF0Nu0aZM3vHz58pLTrlixwkvSsnnz5n4z9CjrkYQUtoGAlDIqnE7xgWT4UkKYYuUdKrn4+yKAl1L7nn322eJDyWIoTvLpp59GU5cjXEunTp2F6dOnC6Py12seRuhQNsNept5BYh6QXGTBEc82fcpmia3Go3m/q5nTDP9LLb1YjwUwlrQC90V2rQNjW9D3spidVvXPcLdDjcNwj5M/hkND2eNZ2Yu02D/xLFP8/jSoqbY9HxNfgVe74KItZcip+Au8SoOhjCGriQlUjWj1Aej97gZSqUagVC188X0aLyU1hs+LR1PjY2SMnma9vlgfn+qsU2qLG30lS1dQjB4yiATTeYZeoRJpKNKn3H91u2U2RZ+BocboaYxIr91Uo9ZT+Uob7ZUafVrFTmPIqgaBatR6sYe+wL7CGC6pAsr4PfXFUj2XfZ0JRmEPfM6AUSYrYbTRb+JSNCkeSJ2pcBZvHRqfw6KZOGUbqrGFRvGMfz5XMndYLdaslk2Qx1btHEm455GanTOTzg77RGx3WLe+7LDmRVrOoxwmGcPn68hwh+ULf35spRzWjVNjnXJZNxWDUV7L6rksx1G2RgSQQhABzXmri9/2p9eXnU25F3TVgNF1PEijXVvCR2k3eU9IKCpPUvm9y11nWun+kpeCep+MuypgLZTOTO9epa5bc46q90R3PWpJBu+pq7ktq/Or9385LqLLuqka917BcBQYd+J399kaEmVqgLTpIGzSO0wuLk/M770HoECJLYet3kfcVautJrdBbqvf+MuNSyrD8t6j3oO8ccr55nXUKe8Q+e9n5IFF4gIlYaGwpUrf3zgjJzMsDD01w2S5IpHpdK5Xqj8zU0qFkaipkf6E/c8HP/hBoepRAXWK2aP6gkMFMujoc+mll2LXrl3C8KPPxo0bhdstxgEdK4DMFBt2bTfdGfsAZ5wNc4MJh2TE6t6pFwzDMAzDMAMBeU5t27YNN954I0KhfkwxTnbqAL6XdYvu5whihouhR3FfalKWUpkuKRGLbr6+hmrsSdSELf0NZVi67bbbRD2+AwcOiFoqQw1S8ubNmyc+Oi599p+8C9Z03bh0GdZU/LWSZNdxYVZGu9S8TQ6iAQf21jDspbkOA1VNkGN1RWF7Wxy94oydjoGgHXB7kIsvU6md7SlwPlc5jcuiXE+xbZXL8btzava1xHb5itur6p7W/bZ4TJwvc5quU1ZZnCwYr6vHp1MSZbxJoZJVWIdKt186CtwUKZOslUGIXKuEoiddu9QMbPL8VxQWXVZC92dbUTRCZYqR69Q26e5XbP9LjSuH1jVVk2lUzYIq4+tUFcRw1SaZ+U4Ma+oIytArX4+1MqjGnEk8ZbFMwXQ1Y6nhnhdU/6q7R8VTp3wKU6EqpVNYdfXmdHUyO5VC5+o8sj6ez7XTzayZyfQkU5/mmOkOiNocGndWXWi4LvOt//fK3vB0tfA8Bd0xhCsm3Vc7FBc575r3ue4Vqu9S0WtOxwrGZaeVqlNuWxtC8aI10VS8GDyfGl6hEqXM06W4exZOp1+ep1qqCV1d2c5Sau9FXRdRtQ6cekWQWprdl0KXc3EPdJHHua/q3/Un6jNIuohK7wkx7MUtquenug/FC9Orin050ZFChH7zm9+IHBQLFixAf8IF05lByeN6zjnnIBbL3lwpvb8seZAPxcrJoulTpkzB0qVLC6ahmDLptkiqUz7333+/uKhK8b3vfQ+PPPKIGCY/aco8OZC8//3v91xSqb4eUyFVgD0vg8AbIQpMYRiGYRiGGdI8/PDDwpuN3v0YZkgqepSOnyRnCcXOSV555RVRF06FMkuqNDQ04HOf+5zIOtne3o7Vq1eLpCzkp0zZLqm8Al0IP/7xj2G72cnIrbEn9UW+9a1viWXTBUUGHGWTrK2tFeul+n1UWoFURYLk8x/96EcDWrycICP19ttvF9k+jxw5guHGb0/7fwXj3vvM/ymdHKNMTIXX46uGv2jmtRY5qN4OBH9bheQ70rAnO/pEL0pvm4wzUXtqy/Uw6+MM3R5BNcjciy9RM0MaCDsBNxFAYUydzFCojpPKmBrgni7Rc14scUwpJaecoiUVO7VXvdw8ufUW9nzqEnmoMQwBJYZH9iKr8RhS5TOVuCWJmgjCryYXVzwr7W32emope2ogg1QgLVQOqTD6EqZI1VE9l91xqupW6pj4fq9Q5VPX52XT66NkLL6sohqVT02OI6dVVSfZHrIOYrE6gvJUkDXfKolNySl6uhnUeWXcUvZDbU/XjJytVIZSXS1D9Vz1D1fWxrbmHJbXgqriJZRsmjKeUdbJE+PcYUenFpbZF/8PKBnX6I3S3Qc1Kq8O7TXYg3PUi3ujZCyOKdSzhJoIQ3NNyHGqYteWySZKaU1XeePkNa3u19hwrqNYjY+UqPdoibxn6jITq+iOmdwuVdFT1SIv3tCXfrdM5mMpsWkUZDVxkKq6y3twWokzlLX5dPXxuqPeyeQodOmQIqzLQp3dROnto4z0VLfK3wc99U4zjxpuIt8T1PcFv4rnlFX2iiWqkuzcuRPPPvssLr/8cm2Clj6Hk7GMenpk0VByFCpkroMMNPqUMvQIqpF37NgxUaS8o6MDd955p/jkQ8YXxbBRhsqeQulsKYMkfYoxefJkUeKAasgNBpT1k2R8yi7KVI5TDXRekkb0mSCq/hxGeq4F6/g0HCrrMFT90hmGYRiGGVVYloVf/OIXooTY6aefPtibw4wSBq1gOvXOfvvb3/bKJ5BKSNku4/G4SIZCyhvV0bvuuuuKxoZVAhmdf/3rX0UKW0p4QmohqWZUxqCpqUm4g1500UWicDplnBxMvvSlL4k0uyOBh9/xn97we/7+6YLfy6XAL6X4FahvMSD9LhvRLQ4ir5sIbYvCGmMjM82B3eDArqePXVBvr0vpvS1V9qEcaq+0TCHvWw5la7QDSFpBpe5ZYUyVpakEr/YWl8qmWU69KZdhs9R06jhV3evuMtXedK9DWOnwVH+XaexlHIqTAuywUZFiFyiSgVOHkzBgRCmldwW90Y6BUMZChJZpOF7b+PbLJaT2+JICmJ91tFzMjeN+pARVRjHRqUb+uL3K2krdBm0GTk+xU5QPpUtcxiOqKp+MI1QzQ8qeblPJKitP9UwRBUkb41YiTkwVAL36nZR108m2TxgZfZ3tChQxf1xe4bH1l6Qojlonz1PQ1bg8Rb2Tw6riabmxeeUS9mmVvDIqqFJfoQC7TBHpnqh73rwa1UXNjJmL6TZgOkHxm3oNdin16vLptHKxfK2prJLXkopqtzsWTBcsryqgeWUyC88DT3XrxgnW6dYmVNenlmQohXr9+2LF8vDVJXUV9mq3fqFaPkNV8nQZnVVvGHm/9Stj8pmujCtzKEi9y6+751fW3O32MlKrcf6l1T35uy9OXDudex4Zheqj3Mos6jPIvXGp2Wk1tVMJymBOdaE/+9nPiqzrAwLJpb307ug3ikm5TJ9iOD2tss0MCah4Jsn/pFr2to7eQHD+U/+3aLC+1vgrkyK+IOkL1VLfD0S3GQgeAsyk+xJiOLBrkDX6GhykJztwJioFzCuU/3QvMLp98RkYDlCfrnfr6KGwuLC3/4o7jJdkQ52uwvp/3Uy2UmweHT0xhCW6RAiq4ai+rMl6V2TvJR+thb03jPAHW2DU2WXbQDXa1OOnYrUEkHy+Bpm3IggviSO2qk2tZKGHXMVSY9Hp1kPMuTaasNtN2PtCsPaGYB8OIltlwq3ILTfHUT+Ky6H6cdeT2wEHiNlAzIFRnf12YrlxcMepXXbljk+l6MpH5FLOFybJ8Rl6mnG+EgCacdLoUQuCq3Uk1VIMlVDK0JvoxHDI6KzI0NPdG1SjRtaJ86+79H1L5wIpp+tM5V7uEymlyLZbNkGWT/Avr3C7feUTZA1CNaGNNoGNOuweM8U1NRh2U+mHcgZBOJQdVxVSar0ptfDkeGk4EVG386PK/RbDboITdV55/erKw4jrMTlG3Fdl7UC1JEFKcbOU51ZbOmfUtSSzwx3JnPEXDOTWUxfJljRoCOdKG9SHutztThUUdZff/tINSnkFZVjn9t2ZybZ7QjH0EtQ5mHfsYu66q926g0SNUo+wJpDwfYt53Dp61UrtvZg7rI6Trpnqc0kdJzu3or6aeZpkLHIZRa4vacCZ7rUUj09DbXW2jp7OGNOXXDC6YejJecyK5lFLMySd3P6n3Q7ItPJ7wh0XV+pUdLpGcqdbOJ04sfFlEaJDnlu9qdNc6TufnO7cOf8XwUDuHB9KZKwk/rr9O8Pm/XW4MmiKHsP0CyaQnkof9+GTtGC2AsE2INBqwGw1ENppIvK6IVS/1GIbmRl22SxZzMBDxpIw8va5D8sav5HptJtwDgRhTE1njZ1Kl7mmGqnXYjBiNsInxpF6rQpOi4maC1q6tX3W20Gk34zC2heG0xYQL8bm+AwCM1Pwwlq8Gor+2oFia/PGyWnp/cV7AUwZQNykythw6Puw+38m72UorBqE2WFnsgXQh2EYhhlUHnroIZH/gcJ0BhSO0Rv1sKHHDCiPnfGdsmpfUXfOciqfO+gLwid3v/FAcnxuMlpm6ICDqjeAqqeDsGocdC2zkZ7llHVd06FLIiPTWRNB4ZRCSQPUfNfKoDtPSOOe4k8HXbhuXeIBnXtl+aQfgYpUQF2680CvUqXr3b3IXSjxTI1n5IVO7hTVJchQs9ZGYb8VBlrcJCdndSAwL9crXUoFTW6tQurVGKpWdaBqSQeMIJCcmETHnxthHQgiNKl02nRyhzTbgPgLdUjtjMKszyA8LYHg1BSCk1MwI5pjVqrnuJw7p2ZecWp0GbBbArA6A3C6ssYfGYJOlwnjqAFnVxjGWzZCH2hDj/FcRhV3L115BVVBdcdnlHNCqnfqOSqVPN+1o9YX0VBpIiBdCQCpoNE4Ggw7lkhCUerwy3nKuSTqkrVUquKp6IrR+4uaF65b67LpJZ5RluP9VmzthW6a2kLnSpkKidzXooleSuBLGKJRi6W/vXSJF+uT5QAcA44dRocV8Rcjd90d465CprpntrsqnpjOLU1RE0kVqHjEmEi8QHWUnhjS46JYEhWp3umSt4i90pwLuiRK8pyX6qPYr0CowK2zy8rd/+JB9/dAuEAF9Kt8WZUnrlH5VKVPdQWNovD+aLn3WFXR07puKr+nld/pHE86DkzbFueX+pzTuW6GNGUR/MlhdPdbWZJDaTcvP42ubJHieq6ce14SGWW7Qu6wVDaz42xfCYv9u8aK/Asf+9jHBj1EiBl9sKHHjD4MID0JsCbbCBy1EX3NRM3fA0jtsdGxCnCGppfDqCK9MYrM5ioY9RacDhPBBUnx6LS3RGC/GoUxPwU0ZeBsjcAsY5yppLZWITQ1hdiKDm9ceHYCgcY0utbXIDSpuei8dtJA14YYWtaHYMZs1JzTjPBxCRFZMhCI7HRvB5HZEoG1I1Ko6uWjvKAzDMMwAw/F0b7w50Ui78TJJ588CFvgpjYdkgzV7RpZsKHHDEm1711P3lTwu1bR647ilzcP9QhmGoHk6UBkl4OaNQbq/wB0rHaQmeSfp6Qi5luF7Aks7DkstjyzVHyU0juZ1ChiXqC8sg3qPusSheSvI7s9xVUnf/FYVJQwRqd8+IoRUyskDWQOhmA0WiLWTKoE9oEg0s/WwFyQgL03BGNOCpmwIR6Y9qtVMGalYb4zAfvxKmCsBStm+jpqfbuibIbdZiLzdhhVZ7cWHJfIsk7EH29A6kgIwbG5WBvP3XNTDIm1NaitiiK6ohnREzthh0yf0tBbpU5Fl8Qh/WgN7D1hoM6CuSQBY6ylPMdz8YBSWTEarJJFmiuNt/QlDtJsvy6NvapYaEtOuCdsSlNmoBiGtqe+cBt0qppcn5eMxbYQNnPJWEomBymj4unuDTr1sZyiJxVvfzkDZX7XcDeVODKvrTXzuJWJ3HnlDOpGapLeqOtzhw018Yy77qASl1huv8qp9/moKphUgVRVyYu9o3In6RhanDTa3UQmRKurfqmxjjWRrDo1qSancNeFEgWxdeqwXKca69fuxvjJxCnF0Jb4KRNjLpVDVUFMh7INF1fWJ+P24pmQtgxHi1nlS4JULq5PVfnkMN1Pgx0OUs1hhCyr4PiEDSVG08xg7ORW1NfElX0tVPmKJROjc5gSv3TZoYJzKRe/nhsf1iQgU9cTck+VqC8ez70v+ZQ4s0Cx05FREmvJ2DwZq5fdV6kwFm4PefG89uJstLXE8OkbPqgtEcMw/Q0begxDLxczgfR4oO55oP6vJrqOd9Cx1PMcYvoYcjfs+kUDkHIfxlU2zGlpmOMyyKyJwZiQEf/bm6MILMrWsXJ2hIB2E8a5SfEi4pARuCj34lKO1JYqesNHcFbhPOE5CSTWWOh6rhbVZ7XCrLFhx01k9ofRtbZGuEmGF3ShZqmNrvr4gJfusI8EhJEXfGcnMD9V4LKnGnT8KsEwTCU4GSDTHESmOSS+O1vqkW4OId0SgtON5EfUGTBp1lHMWrQfU+YeRiDU86RdI4mOliq8/vwcHH/SLlHCa1DgGL1RDxt6zJAk7cbwlMteVzZTZ4mMngXLiQHHznEQ2wTUvGIg+DbQdhqE6leyJ1od5cUJVrqnuZd0tVitqVF29L3ghfFPaq+9rhdZLlNdnlS4upMW3eu1VDOIatYnMyf6VDRyO0yZME7tglFjwzkUgL0pAntrBJiShnFuHNaLUaDeQmYsbVgAeDUCTE0jM0bk9BfnBmURJCXEl6lNo+4Zto301iiCs5NwgkaBJ4ttBhA+rQOJJ2vR+j/jYURtOPHs9gYmp1B9bhsCpB4mI+5+OBUrdaVSrJcviO4WXt4YFQlW7OMyMOisdlfvKR20zyJWz03Wog7Td9qAUWuL42k00LcNq05ReiokV86iUOXLbkbh+ZhT0AuLqHcnG6iu+LBEd58odm8QMXqWhVgg3e3yCtri574MpLqCzMXvW+r0MgG2zktBLcauqgIym6YPL/ZI3W73J52KVwRTE6Mns1Kq2SnLUbIsiHJOqMpZfrZMNRNlWzqrbtHmRxN1OGQEUBvNqVKTqrOqXbi2UIlS1UKpJssYUqJTiXvTqbKlztdKVbxiy9YtJ+IOV0XSBRk71W1Vj4+Mf1WPe1dXGMFWIN4WFEnJAq1AextgdgBdMjY06gANNpzxNpy5aUTHJsW9oroq4d3uagLZTrKYkessi1gWWnbUoXlTPZ793RIEIhlMmn8EkxcexpgprV6nlBrL7ZUFgiMUPceqgmFVFz0n1XllFlB/iYfCcg8x5bkU1bRN1L1CImpsoUZxU9U7OezP+Cm9GAq9Jdf8ZSEiVWksXL0Tg1vCYIi6SHJ5hQGBDT2GUaF344VAahJQ9yww5lEIZS9+PEslfUoVvaXZwggxFmVgzMjAWZiC82YYxglJ8ZZKih2muy84u4NAcwA4zX2ho2f0zAywMwSclPIZ206zCYcMmzrKQpkdl9kagdMeQGhxV/Gb4cwUqj90DOlNUeFWGqQMmuPSwkASz/UeJJvoKxzaTzomL0XhBBw3+YoBdLmGHBl2Pr87Or7UeZHNwCkM12OmOF50bLxp6BjV2zCozmSD5X7T9EP0xYAZudBl/HYAzgSL3sL7hzRgthnkj4cgvbM7RjbZrXwXFuOyH5HsQxmfnY7e4N17gZzPnYc6YNT5s8vIX647n6htlp91N/sx8jP1Khl56UOGBS0mQgaqHEfLdofDwt0BCHc6wrgTGae9254Jq9qBVQ9kptmw6h1hzFHZITrmquuqGcwOm3S/yXPdlZ0ORNhMo2nJUcxath/xY1Ec3DQWhzaNwd4NE1FV34VpJxzE9GVvI0D3+1HEzjcnYv+O8XjH+15ByC1LwjCDARt6zJDkyXPuKhh35t8+WzDO7onKVyKjpyRVByTOt1H3qoPadUB4H9ByKmDHKlO8elK3TNfTnS6j6OVqSkEbr+CPNiueOVHWrRNF3Uug7lfI7TENl1E5CuLEqJrFyyGYCRNWo5PLxklG2RIy7Eyg04DZYcKeZGfVqPURYIIFqymXIdSYZSO0xYT1RgRYmMwajS9EkHnL7d0OOnAWJxA4IYH0umoEZiVhjHNKx8eFgeCSZJ6CE/Be0ijxSnZ+p0+UumIUFD0+PQHsDAr3VUcaylROYbyVrasn/xeGXdbIU1/QHHWADMNWk4J5st+tgawh2RHOJZaJZA1AYfT1QAVUz0G454mXLbGE0lEKtZB6qetNm70wT9GLIoNosLBguk5pKafi+YZdKV9ViUot05ct1/1WRYVQsDAWTq0n6LgTa883pZ0C2hi80m0gJ1WLw6vb011094SMVDHJIPlrGGaHAfopORlIzAEOjo+IA1ITymXGbAhnrRba/DGBNsSC/phbsWy6bTSbCDQDgRYDdmsIgWYDsQ5/NtLu4uiMMDM3LH4n+0v5zck34MT07jYoRmHB/6oBqtTklMajuLzdT5T+yHBt95ha1RAGXXIukKw1kKmnQoC5mptBGfMpN1YYpLn7v+0me1ILuLcYsYI6sFLlq6X4vhrAXJnErFW7EN9Xhc4ttXjz+enY/tJUTF5+CBOXHUIwYnvno1DiyNi2q+BYNRUV9o669RZDSpxgSImjo2y6REopBF/tqoC+zJ/ufUL1pIlqYjXUmnlePF6ZWn/tyTCe+suJWLRoEa561/8b3Ng8YfgPUSN7qG7XCIMNPYYpRsBA23IDyckOGp93MP6PQMtJDrpmchRUj+k0EHgyAhwyYa1MwZitM0XJ4nSPcRowfh8TBol1fs49i6CC99bcDIIvhuFsDGZVLaond2YcaLSBHSFYr0dhbYhSjwBC57cP33N9Rib76WEaew+alersVWtq7NHiheFn5gzBY1kjkFVApj8J7jZhdAIdF2VgHwyiagfQ8BQQrU/h6KIgMIOsHs15T+/o7UCoGQi2ZI26AH23kWrmGsFVDqwGID2dvknNcuCQQE6GDtk3iqFGhre4vJRx6ke6s/Y28YoO3XJ0xrivE0XTMSTdONUELinXRTjYyw7ISqGmqp7ahfHTWzH51AM4sLYJe9dMxP51TZi0/BCmksEXHbkq15ZXpyPeEcEVV1zBCViYQYcNPWbYqXyn/+1fvHG2EuOSq+ek6yWvPIbHG+cuJ9MEdF3gYMxaG2Oec9C5D2g+yYBDNfr6QL3z9kWTyc9X10/XEy1jAsuoeLp5VUVKxsfI+A8xrFGdpFqibq8/jlAXo+QqLPtNhJ8Ki5eo1AUp2BOopzHo7YP6cmSks5WMjL9HgToHmfcksrGSjulbR/odFsyFNsKvm8KAsZamYYZcP6YVGUQXd4lyDGQACvVQc75UDGVpdcxszGGReUspdQUqXR+rgAW1HLtrEFLTjyGZhK4ay68W90IFNMk11MjLxKlR1fX7kvs95fa2+9Q7V20qH5ebm45GR5wMqigTYZ/H6AUKpvMy6Gpi+XTZQkNKRksd6r1M3v8sJVZPdgSoR9ariVcko2fJeEJNzbhy6Pbf97s7rs2tb1cVc1Dl2OiKBGEvALoWAKGDQPVrDqY8l0Z6k4P4CRAGWrAlIIw5Muyq7QDs5qxhY9M13pC9XyfmOXAaLfG/Wi7HlyFWjlOOlO5s1MdYVh6PVwrdcvTZKZ2KMx9L1bUumCioLajG9aVc7w1VnVPbTcZH6tNC5wY7ECmIfzSN6tx2UfOcmsakpfvQtr4e+8jge3kCGpc1o2nZUQTCDkJ2DOkKFb2wnX3CRVyVToxT999V+hL0bHFJGG7WUTNVUOtO1gHM7pZbJ1G5OGRNW1XR09X3S7jT0dcb62ZixvwDGD9eKeA7WHAyllEPG3oMUwFUeP3I6gASUyw0rnUQedTBsVNMJCewulf+4AHBDUEE1wdhT7aROj0FVJWfR3zNtmCtTmVfFooYLvYYB9aZuQe4ihFzEDi1eFwe0wcqYJtiAOpUQCqdMTMNY3ESRi3H/jGFpBuy32S8pdy42vQEoGVC1uCr2QDUP+0asAFHuCGSEdc1DmitcWA3OrDpnqLcIrqTEIvpfwI1FhrfeQx1y1tFzdJja8egeX0j6uZ0oGl2CMEZhttJN7zZtbMJ7c3VOPXC1wZ7UxhGwIYeM+x4+pxvVjztO/56c0GvraVRwbS1tzTDbTMMdI5zMP4FC+Mft9G6wET7iUKukAvNfinKGM1LPdh+RcYuVHpU9U5mW+xBvS61hzZ/eeoy1eVJJUJV8WT2Nt9xUFyX5LS2LvOfi5EAwn8PIbjfQGqJhdSJFKAX8GfGlMtT92u8g/R7U3AayL0qO71uu3M7VSRrXQkVTE34VaqmnHfs3DbM/u90W6m7e8X96A2fXHtNwTht/FeFyp9vOZr9r0gRpFOk0QEai6iAzSawO5SNLdwcBpYmgRNTXtkSXQ0zVRnwZUkMuOdo3rWVv/1ynKo+y9+F6kKKnk2KHvkFl9/F7ijjGammlrm2lAXmBj3LJHdMfJ4I7vWYVoIkHRlnpVyDUuXzq3dS0UO3FW3fNujuN26CjkhAaUs3kQcRdcer65PHwqv1VueAwuyEoadkoaf1WROA1ncBgWYKTANI+BFxcCJ7qgOLYnGN7qtk5egLJa+YYt0X21jsnqVbjqwZKL+JuOviqcbgqdk7g1LxUg5u1s9CeNRDI40WxMyp10HSdpddBURWd2Lc0i4k34ihY3sM9r5xaP9zFFWz4qiaE0d0eldRo0+qm6qKGXHj9tQafwlHyUpqZuMIE04u/rraHZdWYv3S7jJjviyfmmte064J95x+ee0cNDa1YfyUFgwJOOvmqKf7bwQMM8qxqg0cOCuA5iUm6rfamPBnG6GW4d8T2dcEDhqo+X0QgWMGOt9lIbWUjLwKZ6bYGTIguFd+eKuAUy1gdQK4ogNYmALWRYDfVAN7uUAlo54vBjINWUOvGFYjRDIgfmsZGQRiNupPbsGkq97G2HcfQu3yNqSPhXH00Sbs/8k0HHl0POJvxmCnhs9DoCsexq5tEzBv2W6tazTT/9x8880iLlJ+nnzySe109913n2+6Uh+adjjDih4zosmUqMfny9gpVb4ivdc6xe/ofAftTTYmvZhB02M2jp0YQOu8YPalxVTiyIwAIlYISTPk9TzrFRSzUC0rW0evcLujpFS4hF11r1ScjDqsjpO97aoyolMLVYVFQFngNgKx9QYy44GOdzqwY2Y2W1yF6JWqwrhFZYbcNiqj0+605XrLLbXGXwkyjuFmQi3iRtoDNa1S7jnpvgJlT6tu9uAY92a71XO56DkaBMyTk8C8NPBsFPhTNYxZKTinJGCQQagspzqo9LojWaCcqAqDVPzUGmwytkjdLllzK6fsWdlz2SgeA1XuGtUpujpFT2b3UxW9DKnU9K3cJ0zX1SDl/lYM9V4mY07VGl62q7D5719yn8pk2tTcJ9VU+lK1kyqdT5UrQqVKVabBQbC5vB0nl2f0UiGrtE5eKbW/e8vu/jZWel72RLGU2TLld76CLuP6VMVPNo4yxstaKcpRuKQ12StV9VpmbBbXk2PArLUx5qQWYGUzrNYAOrdVo3N7NY4+1iTSi4amJRGZk0BoRgJmxCmaiVMs21XlOpVxcTO7LzEzF7AZd9W9qBu/lx3Onte1Zk75bFCX7baHPkYviINHKLWpgfFTmzFkGEUxeq+++iq+/e1v9+kyRwJs6DEjmhfOv1N8r/rT571x0lTRJUIQ6bHzplN/zzcE03UB7DgngKbX0hj3ioWq/Q4OrAwhUa28eMJBzAoibuQMPd3LkfqSnHAD5Ss19NQXr3KF5XXoDAZp4PmC9cu4gAaPAjWvApH9QOfCbA1CESxDqy+Tcl6HL3mCZn1yOT5jU3lTzG1vz9M451w3s8P5L/vljC1poPUVpco6VII0mHpiJJZzFS37EkrZUC+Kw9gWhLMmCufXtTBPTMBoysCpMuDQaZwBHErtTmU16H8SdmM2rGobZrWNYJXllXhQXQS9/XPbWk25L19gs9tqiOyDwvjLu659CWNKnDNqiQ61PeRLpnpMgu44WcJEbJt7nGTR7uz6yriPu4YgdRx5++reR9RMrLp7Vbm2lMtR7yNhTVKYSg2KHl3fpOjtMrJJsMwKMlK64+njVFrUvBtF0EsZeJVm1eyJkdhXxp1+G0svR7gz5w2r563O3bOk66biZuxzd1TncQwEYbrrcRCqt1C3ok180G6gY3sN2rfVoONvDaK2RHBqEuHZSRgz0l69T38iGKfA+MsZeqmCcWpSF+nOmVL22UIuxrvBnV/XRnS/OXasxt2HDBKUOWgoIJ69Q9XQ67tF2baNT33qU8hkMmhqasKhQ4cqnvexxx7D5MmKz3geU6dOxXCGDT2G6SVOwMDBpWF0TLIw6aUUZv45iUMnBdExbZS4p9lAZB8Q2wSED2XrNzWfCaSG972R6S8oTf1xaTjT08DLEdjrs+UvJD7zQtYeU+NAKXMmFYEXhp8ljD85TN+ozohhfroNIBZA78hml/vtkEJHdUeLit+Fi2gEDMuA2e7AJmGEGfWE6jJoXNaCmqXtyHQEEN9ejbZttYg/SQU9gcDkNIKzkwjMTMKk+qGDDCVhqa5LIBDk+nADzfe+9z289NJLWLBgAS699FLceWe2k78S5s2bh5kzZ2KkwoYeMypY8+47vOGVj37e59an9sYWS1Yge8ktnQuR+90yPoDOdwUxeV0Sk57PoGWfgwNLw6DOT3Ini2f0ip7nSqq6pGWCBQXMdfXTghX2uusSU+jc0KSrp0qxkgtG2kHVdqB6CxDsAJLjgKPvMJCY6qp4FTzruqM66NxLdWn61cLcuTIVgW6rDjrFK1swvbCsRD73rrwX/YW67KvXXFt0umJqQncVQVUZ8Ap9d6MsgrcctY1o2yiz/mldMCkraocJgzrTyfOZkjDQJ+ggEHTnoRqJnQacThNO3IRN3x0BMZzZF8yOT/nPZyPsGoI1NgJk/NVYCND/MQfVVSmEartgxixxzUtFwFJkCakMqvsSkEWWNcq2Or+qggTd3zO2rVHv7AK3z6KKnkbxk+sudx3J+0055d+D7Os0QB5sgYQjvvM/hvp/QRyVe92FsiUPUlMdpGYBdnXxc9Opze5lqNVBmpIwldnGrKLnlsyoVGnsZSmcvlLyKi2h0CNFsAdKnnY57jzynCeq3ML1djDX3h1WYXkFz3VTXa16eUpXYuFWmE1ylVXg9dtESnmo1kLV0hTGLzuKTGcAR7c1omt7DMlnaoBnaxBa3IXwiji6gsEC1THknv9xVdELhH3ummIfAl0F9wEdsgB7Pm3NMdQ2dvq8CQadUeC6uWfPHnzhC18Qwz/4wQ+KxuWNVtjQY5g+xAob2HNyBB27M5j4SgpVxxLY+45w+XICw4hAh4PYViC2DcK1rms6cGy1gfQ4jj5nuo/w7qojF7zCh77X8RJzhFGGvLJUnsslbFHOgQxAuzMgvuENB5A5FoK9Jwo7no0Jcurq0NZGgYMOAnUZBCamEZqSgjGZ1MDh3RsfancQ6nBASQ4pzMoOGTAijvCcNlM5o41CIX3GW1eeIecdBresARUTjwB21P3EgMwYd7iKAnOzJQ4cMuBtINBKBczJndtAbIOB2HogPRFIznGQmZ4X6JUBYs+ZcMgwpCRMDFOCYLWF6sUd4mN1mTj2WiNS62PIbIvAPLkLxpz0oCRDoQzUfVVXl6mcG264AR0dHbj66qtx5plnsqGXBxt6zKjjpQuy6t6KR2/1xnk99E7ptOLqw6NUrN+RaQG0NYYw+7k4pj+RQsdpVCsq4Cl6auFuLz5QVfRcJU+WOCAyllmwDVFdYWlFOShM3U6qnTvO0cS66WLw3O/QEQf1m4GqPdk65x1zDXQcZyAdkwtErygXW1hS0VOLaKtxISXUq3tWFsbOffyljxffQHJHEwXTAz53NHV77j/5Hgwk/7XqJwXjpMrXV2UWfL+XUR26W+xZO32ZOLliL1KkBAYaLIQaNXF77jYatiMMv0h7GmZXG6y4Cas5hNT+MDo3Zwu4BRvSiExJIDQlIb5JBSyFepzlfUTt0ZfnhxpbJ49ZUJlOp+j15DoZv9ZG+DAqgmrSkXEmjTdpuJGx5iiGmxhHwo3RDeW4DrCmUaF7IJ4CIruB8HYTtc+acF40kJ5Bap8jDEoqvxI4aqDzXAtmvRoBWRpqV9G2ZV7qK1XGAn0cg9gfKl65aya3jT2JD6zsepPJVIhGM17we4cVLfBISRdT9xxD3Fez147j986Qx0K5TmT/QH3AXW8NUHtKAumFQRx5Zhw6nqhBaEtSZPs1x2S3sy2d3Z64metd6LKzil5NIFGQWMmn2Ac0Z2NAf8zqx3Zi58bJOH/WRgwZxPvAEO280ryrdJdf/vKX+MMf/oAxY8bgm9+svPTWaIINPYbpJ1I1JradEcOs57owdX0SrYssdEwYQi4dlWA7qNoN1Gx2ED4KpGuBluUGOmcZcEKy/t9gbyTDVAb1AQRqbITCGUTDJFvJJCy2MPrSb4eR2BtFcl8UnW8IX0IEG1OomtmF6gUdCI3Vu2wNJZLTIAy9Y+crLphkbdE7b8RxFbis8VbqDaBPC46HgfRxDtLHWTDaLYR3mAjRZ7ch3uEpb0Xn2RasCfSizzA9i+ebdOEBHNrZgI5n6mE9VIfAoiQCJ5FUPTBHdOyENrz+whwcPnwY48fnuR8wfU5LSws+85nPiOGvf/3rPT7m11xzDTZt2oTm5mbU1dVh7ty5OPfcc/GP//iPmDJlCoY7bOgxo5aXL/iqN7z8j/9WoM44SgIIXXrynBKnLtXwTZ8OBvDm6gBq3ghgxrMJvLW8Cs3TQkWWYxSod/JbLCsjS0UUjxPMj6mQ+xN2rIJxapxgvlpmpBzhmlmzFQjGHSSaDBx6p4HOyVSpuLiBV1GR7e70kpdZhxe3pDSCql7K+EL1eOtUsEpi6xzHQWtrK+rr60VtnaFKqf3rD65/+aPdVioqVSXKKyLFVTD1OtCRVYKU6yZmIzQ3jtjcrFJAcX+JfVFh+HVuqkH7+npEmhKoWdCO2HFxBKpkKYXSyHgfv8pnFsS/5kpF6GNi5T6q2TBDbZQKFiIOTpKmGNl1BgIpB6kpJVTAXihf3XFPK7iua4H0Ekt88pcZ7Mb5PVyux5HOba+/t6Cd69xYNzUpSdwt1yCGXTXNFAVTKUbP0Mfoedk5ldhSL044dwaHlDi7aXMOw55xBPvWTUDbS/VwdoRQc0oHQsclEXfjCYmOTG57SqHeR3LlWXLjat1MnaQGTppzGKFwGi+++CIuvvhiDAmGQYxeW1ubb3QkEhGfSmrmHThwAKtXr8a11xaPVy/HU0895Q0fPXpUfKgNv/Wtb+E73/kOrrvuOgxn2NBjmH6GAtf3Lo4iaocwY10XuupMpBqGZr+1kXRQ95qD2I5sjE58hoFD80ykG+WLFL9QMaMnDqhmXqf4OGccRfytmDD4jj4zDkefAWIz46g5vh3BaSmUKX3X92SAmteAmOshFj8B6FoAOGHAqgWsmIPQAXiGHsOMJsygg7oVrYjN60DLs2PQ9Xg9rANdcE5JeaVZ+oNgyMaM4w/ghRdewIUXXghTqZPJFGfatGm+///93/8dt912W8lD9swzz+Cee+5BMBjE3Xff3aPOntmzZ+Oyyy7Dqaee6m3Djh078NBDD+HXv/41EokErr/+erHsf/iHfxi2TciGHsNQB/iFXyk4Dkv+kM3iJIOsxbdi6EgVTauw5WWLzMDEzhNiqD7ShjE709hzYqxwHp/K5/9Wh+W2+FU+faY+y81AqapgYX8Ce+93s8vB+CdsUOhD23wDbXMDsKqyva2Vqne9UfQqVQzKxej54gxleymL++iLnyxY5kDH1o0k7l5xvzf86XUf7oN6ZOVi/ipQ6gqWmXPRpKuT/pcxQarapp5bcpyXTXAKkJ5sAV0dsLaF0flmFPFHqmFHHaTn2UgtspAKFqpypfZFhy9GSXPhhfcCNS9lk6d0nZjNWhgjo+81wK4BSCwJxA1R7qRrRTZ+rSdxX+W2rU+W18exc8zAc9vih8X3l16/pOQ1GAvkMl7WBLNxcUnKGOQYiAbS6NTUSbXdh15ayeiplaLVZ7D7fKsnVbEBGHtRB4680YgDj09AuN1Aw/lHYYYdtFlVvjqXah1M+d0d0hS4DmDG4gPY9uo0vPnmm5g/fz4GnWGg6FHWTHKZlJRT81KplDC8SNW/6aabcMIJJ3R71ZdeeqlI3pJvIK5cuRJXXnmliPsjIzCdTot1XHLJJZg4cSKGI9zdwDADhGMaaB8bRP2hDAKpoRUcHeh00PRXW8TyHHhXAK0nZI08hmHyqHLgLMrAel8Cmfd2ITPLRvgNE9W/DSGypbQvJ+WtiL0B1D0P1KwHqjYDkV1A6GA2S6VB78JF3snMTqDuKaD+SUMkOjn2HjL0gK4lDlre56DzZAepadl6dOmJDhKzh+jLHcMMMPUL2zD1vXuRPhjGsd+Mh9XefxL82MmtomA3qXpMZZCRp37KGXp33HGHiKmbPn26UP96Qn0Zl29yvZXLjsfj+MlPBjYkoi9hRY9hivDqxV/2hk/8/RcL4uhk5kxfZkiNOme6cTr02TsnhkUH23D80x3YNzeKo1MisNyaRD3J5KZV9JTlBFzXETtQeEOT0wXbHDQ9YYn06/vOCSFTnVXwdFkuVXTjdbX+vOmVbteyNexK9OCr65DT6eIN1WFdTTy13a56IeuW8cApPyq5XQx6rNT469F1P0tgKSVPreElczamlcy28ndR384B6tMNOJSmon3Z31Oa+LiKqAHMFQ7MBUDNq0D1GgPRTUDHcgdJipUzsslQInuAqp0OQm9nbwhUTFwUFqd8MJb/3KRNlAlTnCr32wSi27JJSzpOt0TGSl+yFIp7o08PYt4GQ6nrbnbLH530XxVNzwweX1z8O2/4q29cXNE5EaOeRcdAxEhjXKhDxMyqsawyrk/N8injW23lnNWlSFJVuaiRRnR6GrVXdmH7wzPR/NA4THjPAUSaUmjNxApj8FSvAs21oWbllKSU7T7llFPwpz/9SShD0ajMjT1I2LT9Q7TTR2xb99i8ebNXDP0//uM/UF3tFufsBz71qU+J+nykHFIc36235jK1DyfY0GOYASRRG8Abp9Vh+qY4Zm+IY/qmLuw6MYZjkysLDO9rqDjxhMctUIz6gbOCyERZxWOY7kKFwNtWA/HjgZp1QMNTQGo8YNVkjTzKJZFqAjpOAZLTs7F0ApEV0xFumIFk9jv7MbIFybuA4GGKnQUSc7PqHdXEYxim+1SNTWL+ldux/XczsP+hKWg6/yBANR37mFWrVuH3v/89XnnlFWH0DSaOY4vPUKQn2/Xtb39buG5SfB0pbb/4xS8Kpnn99de94ccff1wkbCHe8573dMswJGV23LhxIovqvn37MFxhQ49hKmDDe74kvk/4XaGbgKXEzOVn3ZQZCElRyhimqKPXUWVi04o6ROIWZm6JY+7LnXg9HED7mFyNn+4WXZXKXnbdinKi8c0Pur2WGRiY+DwZeQb2nBWCHTF88X9SDSum0ulUsvx5yylxRXGKH4eyWTd9ip7Zrc7EDzz3j97wr1b/oPQ2MgX8x/Kfi+/PrL+q2+eyVN3UNlOVurQ7XqpvYtiqTInzZbmlQSuKzkDaq2vZ3W0tpoDZjUDbOUBoP1D9ChA6CiQWOUjOzsbPifWrIUU0EMnWqLMNu2wGT6OSOnvDII6u0m1kJW94U+zcKZqV13AQUeaJmOmCe4LM2KmSe3LmlD6fyudecKTUhaozmHf5Dux6bBoOPjIRE04/hLFLm8XvCZLM89RANaOnzqtAPm/kvATVdKO0/Nu2bRt0Q2+kkUwmvaQpV12Ve84U48tfznlm7dy5s9sKIKl5wx029BhmkEjGAtiypAaLk22Yt74Dr76zHhlZzXwAaNhiI9zqYN+5QWHkMQzTN6QnAy2T+6EeHcMwvcYMOZh10W7se2YiDj49AWbIRuOi1j49sjNnzhTGyKBDhkoPXCQHhCFuRB06dEiUWiAmT3Zv6MMQNvQYphu8dsntBeMW/u9tBaqVqow5hiPi84Si545TFb/NJ9Rh+XPNmLOhE5uW1YofpdJQKuZNxZctUFH3nEBh3R/KShnusNH4uoXmuQF0NgS97fWpbm43aLlMmrptLDuPGz+lqo/a6cr8brnryd+//OGyMYEadfL9z90gvh9a/f2S8zKFfHfZA97w1WuuLWgXnRInz5lu1WjTZF0tNZ2qqNG4AkWvzHnS1ypYr+rRDbE4ut6uT5fFlRme3LroDwXjvrHxgm4vRyp/AUVhawx29kDls301LbPLtDH1nQdgJ00ceHIC6sd1YsykzoLngXodlLom3jN7g+9/ytDICVn6nvvuu098SkGlGW6/Pfuu9sQTT+DMM8/s0bp+9KMfeYreGWecgeEKG3oM00s2vi9n6B3/20JDkF5g6cFBAdyeoaf8Hg+HsHlhHU54tRVNu5LYPz3mMwS72/mVsVQ3zsLgccsyMGV9UsTjvb0wIgrDl3LTLGe0PX/e1wrGrfrT50vOk9uXwqL0KlaFL7CWUq9Il4xF52Vabr/6qlTEaGegC7iXQ1do+8rnrx9QA24ouFfec1LplyWG6UtuXviodnxPC99/d/O53nA91QTKI26XL7hNTD9rPxLHotj+hxk4/qo3Ea7J+Fw3/YlZCjtO1SQsKpZlIRRSzc1BQjxsh6hyNkiK3q5du9Dc3Ixly5YVnYbKK0i3T0qo8/GPfxzDFTb0GGYIcKQpin3TUpi7tQOtjWHE6/rv0hyzJ43awxZ2nRaB42b8ZBiGYZjRhhlwMOeit7DxgbnC2Jt/+Q4E+sA+o/pr4fDgJFljyht6Z511liiUTglali5dKhKvUKcDudtSsXT6SDXvrrvuEjGXwxU29BimD9l0aTZZy4LfZJO3qJBaJvuvfP1YrnK0dW4d6prTWLihFS+tGgs7YPpcGyt141SRLpkyYUwoaWPKa0kcnRJCa1PYq/lVLvGKt7wyv6989PMVuUVq16McFJ1LZ6nOP62Kp5ZX6IELLDN6KKWIDWX3ykrdLLlMATPSKFZuRV5bNYFEwbRqwhTfpRpzMPOiPdj261nY/cQUzH7Xbs/DRFXsQu6wWgJCdQdVocyQQ8LQsynJzdDMuolBzgb6/PPPi08xYrGYyPJJxdmHM2zoMcwQgWrdvX5CA1a9eATztrRj88L6Pl9H/ZE0gmlHFG5nGIZhGAaITUxgxtn7sOsv01AzoRMTlmSTcPSGkZCxcSSyYsUK/OxnPxNG3tq1a/H222/jyJEjyGQyaGxsxKJFi3DOOefgk5/8pFD6hjv8tscw/cDmy7IF1tUYhJP/9h+5CRyNumUAnVUhbJlXj4WbW3G0MYKDE6t6pQzkksNkex0PTYxi7JEUZrzWhZ2RGFomh0qUQ+heSYVihWTzlz1uXxITdifQWR/EntlVyERMxNoymLatCx31Qbw9Iwo7ZFaUmEUqf74kMkWGy21XsWP7nr9/OrsuB/jvE3OpmpmRwwOn/Eh8f/jFTxX8NtAJWrhMAcOU5/8seNwb/v6WsypS/Khweu46y/6ecnKvwWMWtaDzcBXeenIqImNSqJ3a6YvvTrgFMNWyRWr5BRVK49/ZmU3uMqiMwhg9SsZCn2LU1tbiwx/+sPiMBgYulzvDMBWxf1IVDjRFcfzmVkS79A+RHmMY2L40hqOTQpi1No76t33VhvqdxoMpzHulQxhN4/cmsfjFNkzfGseSZ1tR05oRwwvWtQ/5tMsMwzDMyGPqO99GzeRObH9kBpJtPQ/Wq6mpQVdXl0jKwjCDCSt6DDNAbL7s37ysYvN+XagM5UoyGNg4rwGnrj2Mxa+14KVl4+CYhjYrpSvU+VFtJJl1Uyn3kDED2HJiLY532jHrpTi2raxG84TCWIJKM3AufeQLJedRxzXtTqK9PogNJ9ejqtPCCS+2Yur2LuyZFcPuuTE0Hklh0bo2jH8rhQNTozDMQjXRVxDeLNwuyy5dXqGUKumbrgfp/pnhzc9P/nFBWYiBjqPrq/XxecuMFm6Y/4Q3/MMtxdPgq9kydSpfdiJg5oW7seWBudj2h5lYfOVWmEHHV85HjduT4/KRhblJ1aurq8Ng4dg2nCEao+cMcozeaIENPYYZgmSCJjYc34iV649gzq52bJvdxw8K08CO5THMeTmOuWs7sXWlgdam/k0FbWYcNBxJYc/cmFAWu2qCWL+6EYGMI4aJY+PDODAliuPe6MD4/UkkY4WWLD1W6dlqBQzYIcAKGUDUQVd9AIk6UzyoGYZhGKYnhGIWZr/nLWz55Rzs+Ms0zHl3LjlLpQwVQ280um4yftjQY5hBYOvlORXsuF99RauCtdRFsG1mHY7b1Yaj9VEcG1NYF0iaQcUKj+vGyni9TDCArctrcNzLHZj3Ugc2nVSL1vHhiu/B5dS7fCwbSEVMTHorgSNjI+isCyETNgFapdexZ2DzojocGR/BlN1xRDs1PX6GI5KIBSxHGInBTPab1ky7lqwz0dVgonV6EPYko6iKV07xkPNkZHF3fiaNyvp/H3/p4wMSR9dXSt33l/+souUwzEjkuvlPie97tr6z29egVPyor7B+QifmnLcb2/44E9VNXZi04jBs94mbVuL6ZDF2nesm0dHR0Yu9YZjew4Yewwxhdk6rxZiWJE7ccgzPrWhCKty3chW5hL65vAbz1nZgwdp2bFpZh7Zx/aPs2UET609uxAnrWrF0TQveWFaP5jH69NNHmiLio+tFVV90TTP7kK1CBlVtFmKtFura0qg+YmHMrgw6phg4ujSITA2XTWAYhmEqZ+z8FnQeOojdf5+M2Lgu1M+o3Gij1PzEoCdksZ2h20vJit6AwIYewwwyb37g3wrGzXnwq9kBw8Br88dg9bqDWLy5GS8vGifGSWRfomoQmWZlN3Uvbs8wsHFZHRaua8PxL7XhjZPq0TY2VFalK5W1Unf/puUkQ0GsX9GIRRtaccLLLdi8sA4HJ1cVXY+2np4yWUDavUGga2xAfDqpCLzjoG6vhQmvpTDt0TSOLA2idW7AZyjqtl9V/uR08ptNxdHJvSvvHexNYBimm+hUPF2Mnn7e3HS3XvMrfD/+fbz1WA0+dMstGDduXEXLOHz4sPgeM2ZMxdvMMP0BZ91kmCFOKhLA6/PHYHxzEjP39Y8biBMwsGl5HdoaQ1j0civqjvVfNk4raOK1pQ04MCmKhW+0YcbOzr7v2TMMtE0L4q0LwuhqMlC/nTOfMQzDMN3DNE184hOfEArd3XffjUQiV4i9FG+99RaCwSAmT548uIecnq2U9GRIfoao0jjCYEWPYYYg26+8VXzP+cUd4vvImCh2TqnBvF2tOFYXQVtt1uXRUVQ5XcyA7MmRsQXyP/+vWSzTwMbl9cLQW7i2DRtWNqC93u/G2ZO4Pd1vjmFg8/H1SEYDmL2tA9F4Btvm1wojkAgGstsYDuXKS0SD2eGA666pUiwGI2UEkay2EeiykLYCJeMZC5aZN91Q9X5hGIZh/Hxi3jN9dkjIyLvuuuvwzW9+E/fff78opC0zaBdj165dmDp1qjD2GGYwYUWPYYYJW2fWo706hCVbjiKQ6Z+0xHbAwBvL65GImZj5Zj8HkRsGds2pwaaFdZhwIIGTnz2Kifu6+r6Xjw00hmEYpheQMnf11Vdj/fr1eOyxx0o/chwHO3bswIwZMwb9mDu2M6Q/TP/DXQ0MM4TZ/sHPe8OzH7gDry4Yi9XrD2LR9hZsmNcIx60TBzUuT6kjJ+vnqPdTw1XWdPdYsrFI2dszI4bjX29HtDODrliwx5k2VWTiFCIcsjyVrus4Axun1mLKxgSO39iG6fs6cXRmCJ0NQSTChigFkd1e99tV5nzL1shtVM5hwqYkGndm0Do5iLTNih7DMAzTM5YuXYoLL7wQv//97zFlyhSccMIJ2um2bduGo0ePiukZZrBhQ49hhgk7rsoafWvWrMF9992Hz11wOa7a/oTfhZNQjB7bdS9R08FLw4x6HfPHSQ41VWFusAOT9iSw7bjKawBJV0vpelmOtGuUpiMm3lxWg5oZGUzb1IVpGxJiN+jneH0AqagJK2jADrr184KG+N8KZlVI+j+YdhBM2gglHfGpO5xGIO1g34IoDs6OwLG6VwA938WTXTcZhmFGN2To7d27F/feey9uueUWTJgwoWCaZ555BuPHj8e8efMw6Iii5EO0MDkXTB8Q2NBjmGHGqlWrsHnzZjz44IOILWpEvKrvyyGQ8XRgchUm7u/Ctrm1/rSe/UjHmCA2nVYr1LhYm4XaljSqWywEkw7CCVuMp5p5ZiZbRy8/XI/EvkzERDpioG18CPvnR5CKcQV1hmEYpm+Ss5AL5ze+8Q2RnOXmm29GVVU2c7Qsp0DunRdffHHZOL6BQLhIDtFeSrWzmek/2NBjmGHIFVdcIYy9L9bOx5VXXolZP7vT+y1bOtzF9it7Apm/RU2OonG/PNQUxbTdcdR3ptDhJmUpp4bJ5WQss0K1rMiD0ABS9QG0Nujr7HmT2W7RdNtGJmQKZa+APGOw4mQsbnDfSxfc4T2UWltbK5qXYRiGGZmQYXf99dfj61//On7605+K5CyRSMTzuLFtG6eccspgbybDCDgZC8MMQ6LRKBYvXiyMvf6irS6ETMBA47EUhipU8D0TNpGqCuiNPIZhGIbpY8hl89prr8XWrVvxla98RTyLqTPw2WefxZIlS1BXV3nIQ78y6CUUynyYfocVvRFCW1vbYG8CUwS6+VP7kBtHX7pyUDD4448/jt27d+PVS/5JO82Jv7wruw0BJR7PjZ9b+75byq7jhzt/iOPSwHVnXYfRfm31VzsyAwu348iA23FkMJzbcdq0abjxxhvxy1/+EnfddRcWLlwoyiqcd955/fZO1t3lZpAespmnxbYx/Y7hsJPssIaKd86aNQsHDhwY7E1hGIZhGIZh+pGJEydi586dwrNnuL8bVrIvTO9gQ28EQBd0KjV03esYhmEYhmGY3hMOhysyjIbDu2Gl+8L0HDb0GIZhGIZhGIZhRhicjIVhGIZhGIZhGGaEwYYewzAMwzAMwzDMCIMNPYZhGIZhGIZhmBEGG3oMwzAMwzAMwzAjDDb0GIZhGIZhGIZhRhhs6DEMwzAMwzAMw4ww2NBjRiRnnnkmDMPo1ufJJ5+saNnxeByzZ8/25ps5c2bZefbv349rrrkG48ePRywWwxlnnIG//vWv2mkXLlwoljthwoSyyz3uuOO87fjGN75RctqHH37Ym/auu+7CcGyTDRs24Dvf+Q4+9KEPYcmSJZg8eTIikQhqamowb948fOxjH8Pf/va3PtleatdKtrGS9v/Zz36GpUuXinpB06ZNw2c/+1m0tbUVTPfLX/7SW+73v//9ksv8+c9/7k1bV1cHy7JKTr9s2TIxbX19fdlpR3rb8/XYN21CdbrovvLpT38aJ598MsaMGYNQKISxY8fi1FNPxW233dZnBZv5ehy5bc/XI8P0Iw7DjEDOOOMMh07vSj+maTp79+6taNn//M//7Jt3xowZJafft2+fM3XqVO0677///oLpr7vuOm+azZs3F13ugQMHfMu7+OKLK97uF154wRmObXLRRRdVNO9ll13mxOPxXm0vtWsl6yrX/rfffrt2vmXLljkdHR2+ad9++23v9w9+8IMll3v99df7lrd27dqi07a2torjSdO9+93vdkZz2/P12Ddt8uqrrzq1tbVl56urq3MefPDBXp9DfD2OzLbn65Fh+pdgfxqRDDNY3Hvvvejs7Cw5zcaNG3HllVeK4XPOOQdTpkwpu9z169cLVYGUGeq9bG9vLzvPTTfdhL1794pezs9//vNobGzEQw89JJZz/fXX44ILLhC9oJLTTz8dP/zhD8Xw3//+d8yfP1+7XPqNCAQCQqF59tlnqeNG9L6Wmr66uhorVqzAcGyTYDCI5cuXC0WUFLJJkyaJY3f48GGh+Nx9993YsWMHfvOb3+Dqq68WCllvee9734uvfOUrRX8Ph8Ml9+f2228X58utt96Kc889F7t378YXv/hFcS59+ctfxte+9jVv+okTJwqV9s033/Taqxj57U//F2tXOjds2/bOr9Hc9nw99k2bkCIt73+nnXYaLr74Ypx00klem1A73HPPPWI6UmFra2vFva638PU4stqer0eG6Wf62ZBkmCHLzTff7PU86pS1fDKZjLNixQox/Ze+9CWvh7mUopNIJJxIJOJMmzatQL35zGc+I+b/r//6L9/43bt3e9v10Y9+tOiyb7zxRjHNpZdeKtZBwxs2bNBO29nZ6QSDQTHNueee6wzXNkmn0yXn7+rqclavXu0tg3qee4ps36uvvrrHy7jtttvEMr73ve/5xlPveCwWc2bNmlUwzyc+8Qlv+7dv365d7tGjRx3DMMQ0V155padkFeNf//VfvWU+88wzzmhte74e+65Nnn32WeeKK65w3njjjaLz/+///q93ns6ZM8exbdvpKXw9jry25+uRYfofjtFjRiWkblCME0ExPpdddlnZeb773e/i5ZdfFgrbLbfcUtF6jh49imQyiVWrVgklTYV6SYl9+/b5xlMMl4z7KqXqyN9oOVLJKTb9888/j0wmI4bf+c53Yri2Cak6pSDl7MYbb/T+f/rppzGYyLY966yzfOOpd3zBggUFbZ+vuBVrz2eeeUaotxTzee2113rjiiGXQ8dn5cqVGK1tz9dj37XJ6tWr8eCDD4qY4lLqm5xv+/btQsUeTPh6HFptz9cjw/Q/bOgxoxJK2iAf+pdffrlIkFKKt956S7jbET/4wQ9KuuupkJsmvaCuXbtWJHFRkcHt5K6XjzTGdu3aJdw+8yGXGHJXk9O+4x3vKGkYqOMHw3WvP9qkGPRiIiEjezBpamoS30899ZRvPCUp2LJlS8m2r6Q9qd3JJZjcNw8dOiSWmQ8dg5deekkMU9KESs/dkdj2fD0OfJuonRz0wj+Y8PU4tNqer0eG6X/Y0GNGJf/93//tDVO2vnLccMMNIqbhox/9aIE6U4qqqiqcf/75wlA877zz8Mgjj+C5557DzTffLGL06AF64YUXFsynGmM6ZYKWQXFZlEFx8eLFIk6iEsOAXvLpZX8ktEkxfvGLX3jDpJoNJu973/vE97/8y7/gzjvvxAsvvIBf//rXQoWl8+kDH/hAwTyU0VXGwxRTJFVDj4ybE0880TdeZc2aNZ7RM1SN/IFqe74eB75NVIObOiQGE74eh1bb8/XIMAPAALiHMsyQor293amurhaxA9OnTy8bN/LAAw+IaRsbG52DBw964yuJ0SPefPNNZ+zYsQUZySh+4Z577tHOQ9k25XSUXTGfW2+9Vfx2wQUXiP+PHDnixUPs2LGjILaJ4sHot9NOO80ZCW2iQtNSBtLHH39cxKnJ4zZ//vyycV2lkO1LcXQnnHCCOIZVVVXOzJkzRXzKb3/724q2U8Zi5n8WL14ssmHqoIybcjraNxXKKBkKhcRvL774ohj36U9/Wvz/sY99rGBZX/3qV71l/eUvf3FGe9vz9di/bZLPJZdc4rXLxo0be7wcvh5HZtvz9cgw/Qsbesyo47777vMePmQwleLYsWPOhAkTxLQ//OEPfb9VaugRlFSDjIOGhgYnGo06p556qvPII4+UnEeud9GiRQW/nX766eK3O+64wxt3/PHHa5O7UCkFub+f+9znnOHeJhI6LsXSelObvP766/2ezp0M50rKcnz/+993Fi5cKAy0iRMnCsOsubm55PRyHb/61a98v5FRQ+PpZUwaM5TCXBql+VA5BfqNkvHkJwQarW3P12Pft4mOV155xQkEAkXvY92Br8eR2/Z8PTJM/8GGHjPqOPvss70H2ZYtW0pOe+2114rpyDDL79nsjqHXE97//vd7yh8pdpJkMimMRfrt6aef9sZ/8pOfFOPoW+Wb3/ymt79//OMfneHeJqVe9unFgjJdFlPKusNxxx0neqT/8z//03nyySed9evXO0888YQwrimLqlwnGdgtLS1OX/Laa695y6fsqrq6fHTM1FpUcnrV8LQsS9SyovGrVq1yhiJDse118PXYPSij4kknneS1z8MPP9yr48/X49C9Hvu77Uf79cgwvYENPWZUsWfPHq9w9CmnnFJy2qeeeko8REgJ0aVq729D77vf/a73AKJU1RJKj0/jwuGwSCmf3xNLbms69xna7/56CR6oNsl3+SGDiNqGDDByUZwyZYpQzT7ykY8IF6TeUEpxa2trc8477zyvfW666SanL6FOhTFjxohlL1261Pcblceg8V/84hd948mllMaTq7Fk3bp13jZ+9rOf7dNtHMltr4Ovx+4hX6x7W6JEwtfj0L0e+7vtR/P1yDC9hQ09ZlRx5513eg+HH/zgByV7JOmBQNP98z//s3aa/jb01Jd0dRvkPuTH223bts2bXsYSksEg4wOXLVvmDOc2qfRl8OSTTxbLOvHEE4VB1l+QiiePLblRUk9yX6K+gEjFkFw1a2pqtPF2ZODQ+BtuuEH7MtQfveqjqe35eqwcUr1lu65cuXJAXIb5ehxdbT9arkeG6S1s6DGjCoqTops6FRin+LtifOELXxDTkYteMXWgvw09crurr68vcLu78MILxbhbbrmlYB6K/6LfHnroIfE/xSrJhxslBRnObVIpmzZt8vaZCoX3J//0T//krYuKCPcld911V4FL0Zo1azw3xfzzkl7M6DdKHCO5/PLLPfcmKrI+1BhObc/XY2XcfffdXhssWLDAOXz4sDNQ8PU4etp+tFyPDNNbuLwCM2qgWnYbN24UwxdffLGo4VOMr3/96+L73HPPxR/+8AeRtj3/Q+nxCfqW4x5//PE+217TNEVhWmLdunViPVTIlkorELJ2nkp+mYWhXj+vO21SKZRWf968eWKYShn0J2rBYF3x896g1tOTZRZkUfSlS5f6asap58Prr7+O5uZmX/tTCY4xY8ZgKDHc2p6vx/I88MADohQNMWPGDPzlL3/BuHHjMFDw9Th62n40XI8M0xcE+2QpDDMMUGsDXX311SWnTaVS4vvee+8Vn1IcOXIEV111lRg+44wzcPbZZ6OvoIfPo48+ikwmg+eff14U/G1paYFhGN5DS4Uebg899JBnGKh12FTDYTi2SXegF4ytW7eK+oX9CXlF9BfLly9HdXW1eIHJfzHRteWiRYvEyxkZeWQQzp8/HwcPHhyyLzHDse35eizO7373O1FzjV62J02aJIpuT506FQMJX4+jq+1H+vXIMH0BK3rMqCCdTnvFlMePH48LLrgAwwH14UMv+fJFX77U5yMfbq+++ira29s9BYiUDtrv0dImUl3LV736GtkDTkyePLlPlx0MBnHqqaeK4ZdeegldXV1ee+p6q+nlRk6vnitD8SVmuLY9X4966MX+iiuuEC/cY8eOFWrOnDlzMNDw9Ti62n4kX48M01ewoceMCqjX7/Dhw2L4Qx/6kHiJLoUbv1ryQ+4pBH3LcU8++WSfbvfKlStRVVXl9T7KB5nuRZ9YtmyZUIEsy8LPf/5z7NmzZ8gqOt1tk+64IEk1h1wW+4vW1lY8+OCDYjgWi+Gkk07q83XIdiOFmXrc5fEq1v5yfL6hN9Taf7i2PV+PhZCr3Hvf+14kk0nU1dXhscceEy/aAw1fj6Ov7Ufy9cgwfUavo/wYZhgga+7Q5+WXX+6TZfZ3MhbJGWecIdZTVVXlBZP//Oc/L1sHafbs2d4+/+xnP3OGe5tQKv3nnnuu5DT79+/3EgrQ58c//nHJY0qfnTt3Fvz+6KOPOvF4vOh6KBGKWl6BCqD3B1Q6QK5DtifVEysG1Y2iaajMwNSpU8Xw3LlznaHGYLZ9b+HrMQfVlmxoaPAyz1Jq+94cU74eR1/b95aRej0yTF/BMXrMiIdiliihiuzlp9in4QT1Nj711FPCdY8+pXospXsKJYXZsWPHkHXd60mb0P5ceumlWLVqFS655BLROzthwgTx2/79+4Wa+tOf/lTEaBBnnXUWPvGJT/Ro+772ta/hwx/+MC677DJxrMkViVwBSTWgXuy7774bu3fvFtNSLNxtt92G/uCUU05BOBwWip5sz1JtTz3ccvq9e/eKcdz2fQtfj1m2b9+O888/37vevvKVr6C+vl4kAyoGxW01NDR0+5jz9Th62340Xo8M05ewoceMeMi9jlxLCAoYH27kP4SmTZuG6dOnF50+/yFHrqWlph9ubbJmzRrxKcVHPvIRYYxRZraecuzYMdxzzz3iU+ol43/+53/6LaNlNBoVLqEyk1y5lxiafsWKFSIxgbqNQ4nh0Pal4OsxC7nJHTp0yDsuN910U9ljR4mtrrnmmh4dd74eR2/bj7brkWH6Ejb0mBHP/fffL74DgYBQaYYblEKaYiYo2L3ciz5BCTloXykOYSi+6Pe0TShBAAX+U28sBdGTYkVZJeklhXqT586dK47VRz/6UVF+oDfcddddYl1kMG3ZskVkVqXea4rFo6QrJ598ssi0et5554kkKP0JtV+lhp78fSgbekO97cvB1+PAw9dj/8HPx6F1f2SYvsYg/80+XyrDMAzDMAzDMAwzaHDWTYZhGIZhGIZhmBEGG3oMwzAMwzAMwzAjDDb0GIZhGIZhGIZhRhhs6DEMwzAMwzAMw4ww2NBjGIZhGIZhGIYZYbChxzAMwzAMwzAMM8JgQ49hGIZhGIZhGGaEwYYewzAMwzAMwzDMCIMNPYZhGIZhGIZhmBEGG3oMwzAMwzAMwzAjDDb0GIZhGIZhGIZhRhhs6DEMwzAMwzAMw4ww2NBjGIZhGIZhGIYZYbChxzAMwzAMwzAMg5HF/w9TRBCzrjrAKQAAAABJRU5ErkJggg==",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "snap.exposure.plot_raster()\n",
+ "snap.hazard.plot_intensity(0)\n",
+ "snap.impfset.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2e6daae-6345-41ac-a560-71040942db39",
+ "metadata": {},
+ "source": [
+ "## Evaluating risk from multiple snapshots using trajectories"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8e8458c3-a3f9-4210-9de0-15293167f2f9",
+ "metadata": {},
+ "source": [
+ "Trajectories facilitate the evaluation of risk of multiple snapshot. There are two kinds of trajectories:\n",
+ "\n",
+ "- `StaticRiskTrajectory`: which estimate the risk at each snaphot only, and regroups the results nicely.\n",
+ "- `InterpolatedRiskTrajectory`: which also includes the evolution of risk in between the snapshots through interpolation.\n",
+ "\n",
+ "So first, let us define `Snapshot` for a future point in time. We will increase the value of the exposure following a certain growth rate, and use future tropical cyclone data:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "c516c861-c5c1-475b-82e2-c867c5c08ec9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-03 18:28:58,942 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n",
+ "2025-11-03 18:28:58,967 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+ "2025-11-03 18:28:58,968 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2025-11-03 18:28:58,970 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n"
+ ]
+ }
+ ],
+ "source": [
+ "import copy\n",
+ "\n",
+ "future_year = 2040\n",
+ "exp_future = copy.deepcopy(exp_present)\n",
+ "exp_future.ref_year = future_year\n",
+ "n_years = exp_future.ref_year - exp_present.ref_year + 1\n",
+ "growth_rate = 1.02\n",
+ "growth = growth_rate**n_years\n",
+ "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ "haz_future = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"rcp60\",\n",
+ " \"ref_year\": str(future_year),\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ ")\n",
+ "exp_future.assign_centroids(haz_future, distance=\"approx\")\n",
+ "impf_set = ImpactFuncSet(\n",
+ " [\n",
+ " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n",
+ " ]\n",
+ ")\n",
+ "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_future.gdf[\"impf_TC\"] = 1\n",
+ "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2040)\n",
+ "\n",
+ "# Now we can define a list of two snapshots, present and future:\n",
+ "snapcol = [snap, snap2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27ca72b1-b1fa-4cd2-8f74-a69dc6eb3c9c",
+ "metadata": {},
+ "source": [
+ "Based on such a list of snapshots, we can then evaluate a risk trajectory using a `StaticRiskTrajectory` or a `InterpolatedRiskTrajectory` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e782ab8b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n",
+ "\n",
+ "static_risk_traj = StaticRiskTrajectory(snapcol)\n",
+ "interpolated_risk_traj = InterpolatedRiskTrajectory(snapcol)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d7e8653-4ef9-40f5-8f8a-ef0e8b3b8a8c",
+ "metadata": {},
+ "source": [
+ "### Tidy format\n",
+ "\n",
+ "We use the \"tidy\" format to output most of the results.\n",
+ "\n",
+ "A **tidy data** format is a standardized way to structure datasets, making them easier to analyze and visualize. It's based on three main principles:\n",
+ "\n",
+ "1. **Each variable forms a column.**\n",
+ "2. **Each observation forms a row.**\n",
+ "3. **Each type of observational unit forms a table.**\n",
+ "\n",
+ "Example:\n",
+ "\n",
+ "| group | date | metric | risk |\n",
+ "| :---: | :---: | :---: | :---: |\n",
+ "| All | 2018-01-01 | aai | $1.840432 \\times 10^{8}$ |\n",
+ "| All | 2040-01-01 | aai | $6.946753 \\times 10^{8}$ |\n",
+ "| All | 2018-01-01 | rp\\_20 | $1.420589 \\times 10^{8}$ |\n",
+ "\n",
+ "In this example, every descriptive quality (variable) of the risk evaluation is placed in its own column:\n",
+ "\n",
+ "* **`group`**: The exposure subgroup for the risk evalution point.\n",
+ "* **`date`**: The date for the risk evalution point.\n",
+ "* **`metric`**: The specific risk measure (e.g., 'aai', 'rp\\_20', 'rp\\_100').\n",
+ "* **`unit`**: The unit of the risk evaluation.\n",
+ "* **`risk`**: The actual value being measured.\n",
+ "\n",
+ "Each row represents a single, complete observation. For example, the very first row is a measurement of the **'aai' metric** for **group 'All'** on **'2018-01-01'**, with the resulting **risk** value of **$1.840432 \\times 10^{8}$ USD**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca8951cc-4a0a-4f3d-9c21-96dd6a835810",
+ "metadata": {},
+ "source": [
+ "### Static and Interpolated trajectories"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dc76cb91",
+ "metadata": {},
+ "source": [
+ "`StaticRiskTrajectory` will compute and hold risk metrics for all the given snapshots without interpolation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "14453563",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.946753e+08 \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 1.420589e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " USD \n",
+ " 8.253342e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 3.059112e+09 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " USD \n",
+ " 1.368563e+10 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 5.719050e+09 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " All \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " USD \n",
+ " 2.330623e+10 \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 0 \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.721881e+05 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 1 \n",
+ " 2018-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.837711e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 0 \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.040877e+06 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 1 \n",
+ " 2040-01-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.936344e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " period \n",
+ " group \n",
+ " measure \n",
+ " metric \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2018 to 2040 \n",
+ " 0 \n",
+ " no_measure \n",
+ " aai \n",
+ " 1.414905e+07 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2018 to 2040 \n",
+ " 1 \n",
+ " no_measure \n",
+ " aai \n",
+ " 9.465607e+09 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " aai \n",
+ " 9.479757e+09 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_100 \n",
+ " 1.355590e+10 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_20 \n",
+ " 4.334959e+08 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 2018 to 2040 \n",
+ " All \n",
+ " no_measure \n",
+ " rp_50 \n",
+ " 7.748316e+09 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2019 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.000396e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2020 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.166844e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2021 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.339834e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2022 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.519424e+08 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 41 \n",
+ " 1 \n",
+ " 2038 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.328297e+08 \n",
+ " \n",
+ " \n",
+ " 42 \n",
+ " 0 \n",
+ " 2039 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 9.943382e+05 \n",
+ " \n",
+ " \n",
+ " 43 \n",
+ " 1 \n",
+ " 2039 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.628505e+08 \n",
+ " \n",
+ " \n",
+ " 44 \n",
+ " 0 \n",
+ " 2040 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.040877e+06 \n",
+ " \n",
+ " \n",
+ " 45 \n",
+ " 1 \n",
+ " 2040 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.936344e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
138 rows × 6 columns
\n",
+ "
"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "interpolated_risk_traj.plot_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7896af66-b0aa-4418-b22e-c64fd4d2cfe1",
+ "metadata": {},
+ "source": [
+ "And as well on a per date basis (keep in mind this is an interpolation, thus should be interpreted with caution):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "cf40380a-5814-4164-a592-7ab181776b5a",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(,\n",
+ " )"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "interpolated_risk_traj.plot_time_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "501e455b-e7c6-4672-9191-d5fefe38d424",
+ "metadata": {},
+ "source": [
+ "### DiscRates"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0dba0218-55fe-423d-a520-61d3cb2a991c",
+ "metadata": {},
+ "source": [
+ "To correctly assess the future risk, you may also want to apply a discount rate, in order to express future costs in net present value.\n",
+ "\n",
+ "This can easily be done providing an instance of the already existing `DiscRates` class when instantiating the trajectory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "651e31cb-5a55-4a22-a7c3-b5f79b3a20ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from climada.entity import DiscRates\n",
+ "import numpy as np\n",
+ "\n",
+ "year_range = np.arange(exp_present.ref_year, exp_future.ref_year + 1)\n",
+ "annual_discount_stern = np.ones(n_years) * 0.014\n",
+ "discount_stern = DiscRates(year_range, annual_discount_stern)\n",
+ "discounted_risk_traj = InterpolatedRiskTrajectory(\n",
+ " snapcol, risk_disc_rates=discount_stern\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d86bedbb-6c0a-4f7d-a63e-5012510339d3",
+ "metadata": {},
+ "source": [
+ "You can easily notice the difference with the previously defined trajectory without discount rate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "ee3b0217-fe14-44a9-98f5-e1fc7f45e613",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "ax = interpolated_risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"No discount rate\"\n",
+ ")\n",
+ "discounted_risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Stern discount rate\", ax=ax\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0152e9fa-55fa-4cf2-b187-59e6228af563",
+ "metadata": {},
+ "source": [
+ "# Advanced usage\n",
+ "\n",
+ "In this section we present some more advanced features and use of this module."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42c9daed-6488-488b-b01a-fd6dfc5d0274",
+ "metadata": {},
+ "source": [
+ "## Higher number of snapshots"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6db14802-fa35-4e33-91ef-7dddd4d43da7",
+ "metadata": {},
+ "source": [
+ "You can of course use the module to evaluate more that two snapshots. With the `StaticRiskTrajectory` you will get a collection of results for each snapshot.\n",
+ "\n",
+ "For the `InterpolatedRiskTrajectory` the interpolation will be done between each pair of consecutive snapshots and all results will be collected together, this is usefull if you want to explore a trajectory for which you have clear \"intermediate points\", for instance if you are evaluating the risk in an area for which you know some specific development projects will start at a certain date.\n",
+ "\n",
+ "Below is an example featuring three snapshots:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "d93eb82b-65d2-48fe-a195-6cb12f23bf47",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2025-11-03 15:17:54,936 - climada.entity.exposures.base - INFO - Reading /home/sjuhel/climada/data/exposures/litpop/LitPop_150arcsec_HTI/v3/LitPop_150arcsec_HTI.hdf5\n",
+ "2025-11-03 15:18:00,684 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020/v2/tropical_cyclone_10synth_tracks_150arcsec_HTI_1980_2020.hdf5\n",
+ "2025-11-03 15:18:00,714 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2025-11-03 15:18:00,718 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n",
+ "2025-11-03 15:18:06,229 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2040.hdf5\n",
+ "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+ "2025-11-03 15:18:06,255 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2025-11-03 15:18:06,257 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n",
+ "2025-11-03 15:18:11,586 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2060.hdf5\n",
+ "2025-11-03 15:18:11,615 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+ "2025-11-03 15:18:11,616 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2025-11-03 15:18:11,619 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n",
+ "2025-11-03 15:18:16,770 - climada.hazard.io - INFO - Reading /home/sjuhel/climada/data/hazard/tropical_cyclone/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080/v2/tropical_cyclone_10synth_tracks_150arcsec_rcp60_HTI_2080.hdf5\n",
+ "2025-11-03 15:18:16,799 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n",
+ "2025-11-03 15:18:16,800 - climada.entity.exposures.base - INFO - Matching 1329 exposures with 1332 centroids.\n",
+ "2025-11-03 15:18:16,802 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 0.08333333333331439 degree\n"
+ ]
+ }
+ ],
+ "source": [
+ "from climada.engine.impact_calc import ImpactCalc\n",
+ "from climada.util.api_client import Client\n",
+ "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n",
+ "from climada.trajectories.snapshot import Snapshot\n",
+ "from climada.trajectories import InterpolatedRiskTrajectory\n",
+ "import copy\n",
+ "\n",
+ "client = Client()\n",
+ "\n",
+ "\n",
+ "future_years = [2040, 2060, 2080]\n",
+ "\n",
+ "exp_present = client.get_litpop(country=\"Haiti\")\n",
+ "haz_present = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"historical\",\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ ")\n",
+ "exp_present.assign_centroids(haz_present, distance=\"approx\")\n",
+ "\n",
+ "impf_set = ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa()])\n",
+ "exp_present.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_present.gdf[\"impf_TC\"] = 1\n",
+ "exp_present.gdf[\"group_id\"] = (exp_present.gdf[\"value\"] > 500000) * 1\n",
+ "\n",
+ "snapcol = [\n",
+ " Snapshot(exposure=exp_present, hazard=haz_present, impfset=impf_set, date=2018)\n",
+ "]\n",
+ "\n",
+ "for year in future_years:\n",
+ " exp_future = copy.deepcopy(exp_present)\n",
+ " exp_future.ref_year = year\n",
+ " n_years = exp_future.ref_year - exp_present.ref_year + 1\n",
+ " growth_rate = 1.02\n",
+ " growth = growth_rate**n_years\n",
+ " exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ " haz_future = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"rcp60\",\n",
+ " \"ref_year\": str(year),\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ " )\n",
+ " exp_future.assign_centroids(haz_future, distance=\"approx\")\n",
+ " impf_set = ImpactFuncSet(\n",
+ " [\n",
+ " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n",
+ " ]\n",
+ " )\n",
+ " exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ " exp_future.gdf[\"impf_TC\"] = 1\n",
+ " snapcol.append(\n",
+ " Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=year)\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "b85d5b95-4316-481a-9eed-86977647b791",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "risk_traj = InterpolatedRiskTrajectory(snapcol)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "537a9dd8-96e9-4ef4-a137-358990c658d2",
+ "metadata": {},
+ "source": [
+ "By default the \"static\" waterfall plot shows the evolution of risk between the earliest and latest snapshot."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "1c5aeb4b-6320-479d-82a6-9b2c3901868e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "risk_traj.plot_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "16faf81c-8760-4c02-a575-ae033bcb637d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(,\n",
+ " )"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "risk_traj.plot_time_waterfall()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fed22016-ab8f-4761-892a-c893d18357b7",
+ "metadata": {},
+ "source": [
+ "## Non-default return periods"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcaed625-82a8-4cc4-82de-e36b67601dcb",
+ "metadata": {},
+ "source": [
+ "You can easily change the default return periods computed, either at initialisation time, or via the property `return_periods`.\n",
+ "Note that estimates of impacts for specific return periods are highly dependant on the quality of the data you provided."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "0ade93f9-c43a-4e8a-8225-9343bbbb3615",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018 \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.489354e+07 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2019 \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.678277e+07 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2020 \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 1.879207e+07 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2021 \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 2.092467e+07 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2022 \n",
+ " no_measure \n",
+ " rp_10 \n",
+ " USD \n",
+ " 2.318382e+07 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 87 \n",
+ " All \n",
+ " 2036 \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 2.607961e+09 \n",
+ " \n",
+ " \n",
+ " 88 \n",
+ " All \n",
+ " 2037 \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 2.766248e+09 \n",
+ " \n",
+ " \n",
+ " 89 \n",
+ " All \n",
+ " 2038 \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 2.929978e+09 \n",
+ " \n",
+ " \n",
+ " 90 \n",
+ " All \n",
+ " 2039 \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 3.099231e+09 \n",
+ " \n",
+ " \n",
+ " 91 \n",
+ " All \n",
+ " 2040 \n",
+ " no_measure \n",
+ " rp_30 \n",
+ " USD \n",
+ " 3.274085e+09 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
92 rows × 6 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018 \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 9.900032e+09 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2019 \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 1.072504e+10 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2020 \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 1.158105e+10 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2021 \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 1.246823e+10 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2022 \n",
+ " no_measure \n",
+ " rp_150 \n",
+ " USD \n",
+ " 1.338673e+10 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 64 \n",
+ " All \n",
+ " 2036 \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 4.618632e+10 \n",
+ " \n",
+ " \n",
+ " 65 \n",
+ " All \n",
+ " 2037 \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 4.801525e+10 \n",
+ " \n",
+ " \n",
+ " 66 \n",
+ " All \n",
+ " 2038 \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 4.987944e+10 \n",
+ " \n",
+ " \n",
+ " 67 \n",
+ " All \n",
+ " 2039 \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 5.177889e+10 \n",
+ " \n",
+ " \n",
+ " 68 \n",
+ " All \n",
+ " 2040 \n",
+ " no_measure \n",
+ " rp_500 \n",
+ " USD \n",
+ " 5.371361e+10 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
69 rows × 6 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2023 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 2.801311e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2028 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 3.966228e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2033 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 5.344827e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2038 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 6.946753e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " All \n",
+ " 2018-01 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.840432e+08 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " All \n",
+ " 2018-02 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.853516e+08 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " All \n",
+ " 2018-03 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.866645e+08 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " All \n",
+ " 2018-04 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.879819e+08 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " All \n",
+ " 2018-05 \n",
+ " no_measure \n",
+ " aai \n",
+ " USD \n",
+ " 1.893037e+08 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from climada.trajectories import StaticRiskTrajectory, InterpolatedRiskTrajectory\n",
+ "from climada.trajectories import ExponentialExposureStrategy\n",
+ "import seaborn as sns\n",
+ "\n",
+ "future_year = 2100\n",
+ "exp_future = copy.deepcopy(exp_present)\n",
+ "exp_future.ref_year = future_year\n",
+ "n_years = exp_future.ref_year - exp_present.ref_year + 1\n",
+ "growth_rate = 1.04\n",
+ "growth = growth_rate**n_years\n",
+ "exp_future.gdf[\"value\"] = exp_future.gdf[\"value\"] * growth\n",
+ "\n",
+ "haz_future = client.get_hazard(\n",
+ " \"tropical_cyclone\",\n",
+ " properties={\n",
+ " \"country_name\": \"Haiti\",\n",
+ " \"climate_scenario\": \"rcp60\",\n",
+ " \"ref_year\": \"2080\",\n",
+ " \"nb_synth_tracks\": \"10\",\n",
+ " },\n",
+ ")\n",
+ "exp_future.assign_centroids(haz_future, distance=\"approx\")\n",
+ "impf_set = ImpactFuncSet(\n",
+ " [\n",
+ " ImpfTropCyclone.from_emanuel_usa(v_half=60.0),\n",
+ " ]\n",
+ ")\n",
+ "exp_future.gdf.rename(columns={\"impf_\": \"impf_TC\"}, inplace=True)\n",
+ "exp_future.gdf[\"impf_TC\"] = 1\n",
+ "\n",
+ "snap2 = Snapshot(exposure=exp_future, hazard=haz_future, impfset=impf_set, date=2100)\n",
+ "snapcol = [snap, snap2]\n",
+ "\n",
+ "exp_interp = ExponentialExposureStrategy()\n",
+ "risk_traj = InterpolatedRiskTrajectory(snapcol)\n",
+ "risk_traj_exp = InterpolatedRiskTrajectory(snapcol, interpolation_strategy=exp_interp)\n",
+ "ax = risk_traj.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Linear interpolation for exposure\"\n",
+ ")\n",
+ "risk_traj_exp.aai_metrics().plot(\n",
+ " x=\"date\", y=\"risk\", label=\"Exponential interpolation for exposure\", ax=ax\n",
+ ")\n",
+ "\n",
+ "ax.set_title(\n",
+ " \"Comparison of average annual impact estimate for different interpolation approaches\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a5991b8-659e-4b0a-81cc-bc0d085ff1e7",
+ "metadata": {},
+ "source": [
+ "## Spatial mapping"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d47bcc7e-defe-4058-b7a3-4dafd4374f35",
+ "metadata": {},
+ "source": [
+ "You can access a DataFrame with the estimated annual impacts at each coordinates through \"eai_metrics\" which can easily be merged to the exposure GeoDataFrame:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "431d26f1-c19f-4654-814b-20e8a243848e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " group \n",
+ " date \n",
+ " measure \n",
+ " metric \n",
+ " coord_id \n",
+ " unit \n",
+ " risk \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 1 \n",
+ " 2018 \n",
+ " no_measure \n",
+ " eai \n",
+ " 0 \n",
+ " USD \n",
+ " 3515.056865 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 1 \n",
+ " 2019 \n",
+ " no_measure \n",
+ " eai \n",
+ " 0 \n",
+ " USD \n",
+ " 4668.296006 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 1 \n",
+ " 2020 \n",
+ " no_measure \n",
+ " eai \n",
+ " 0 \n",
+ " USD \n",
+ " 5861.455974 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 1 \n",
+ " 2021 \n",
+ " no_measure \n",
+ " eai \n",
+ " 0 \n",
+ " USD \n",
+ " 7094.788880 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 1 \n",
+ " 2022 \n",
+ " no_measure \n",
+ " eai \n",
+ " 0 \n",
+ " USD \n",
+ " 8368.546832 \n",
+ " \n",
+ " \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " ... \n",
+ " \n",
+ " \n",
+ " 110302 \n",
+ " 1 \n",
+ " 2096 \n",
+ " no_measure \n",
+ " eai \n",
+ " 1328 \n",
+ " USD \n",
+ " 100317.858444 \n",
+ " \n",
+ " \n",
+ " 110303 \n",
+ " 1 \n",
+ " 2097 \n",
+ " no_measure \n",
+ " eai \n",
+ " 1328 \n",
+ " USD \n",
+ " 102579.412184 \n",
+ " \n",
+ " \n",
+ " 110304 \n",
+ " 1 \n",
+ " 2098 \n",
+ " no_measure \n",
+ " eai \n",
+ " 1328 \n",
+ " USD \n",
+ " 104869.907377 \n",
+ " \n",
+ " \n",
+ " 110305 \n",
+ " 1 \n",
+ " 2099 \n",
+ " no_measure \n",
+ " eai \n",
+ " 1328 \n",
+ " USD \n",
+ " 107189.486993 \n",
+ " \n",
+ " \n",
+ " 110306 \n",
+ " 1 \n",
+ " 2100 \n",
+ " no_measure \n",
+ " eai \n",
+ " 1328 \n",
+ " USD \n",
+ " 109538.294005 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
110307 rows × 7 columns
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "gdf = snap.exposure.gdf\n",
+ "gdf[\"coord_id\"] = gdf.index\n",
+ "gdf = gdf.merge(df, on=\"coord_id\")\n",
+ "\n",
+ "fig, axs = plt.subplots(1, 3, figsize=(20, 4))\n",
+ "\n",
+ "gdf.loc[gdf[\"date\"] == \"2018-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[0],\n",
+ ")\n",
+ "gdf.loc[gdf[\"date\"] == \"2050-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[1],\n",
+ ")\n",
+ "gdf.loc[gdf[\"date\"] == \"2100-01-01\"].plot(\n",
+ " column=\"risk\",\n",
+ " legend=True,\n",
+ " vmin=gdf[\"risk\"].min(),\n",
+ " vmax=gdf[\"risk\"].max(),\n",
+ " ax=axs[2],\n",
+ ")\n",
+ "\n",
+ "axs[0].set_title(\"Average Annual Risk in 2018\")\n",
+ "axs[1].set_title(\"Average Annual Risk in 2050\")\n",
+ "axs[2].set_title(\"Average Annual Risk in 2100\")\n",
+ "\n",
+ "plt.show()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "cb_refactoring",
+ "language": "python",
+ "name": "cb_refactoring"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}