From 3c1dbd9bfb0fcb4f75094e38e6bdc540696d1985 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 09:41:51 +0200 Subject: [PATCH 01/40] Start to set up python module structure --- bayes_chime/__init__.py | 0 bayes_chime/normal/__init__.py | 0 setup.py | 0 tests/__init__.py | 0 tests/normal/__init__.py | 0 5 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 bayes_chime/__init__.py create mode 100644 bayes_chime/normal/__init__.py create mode 100644 setup.py create mode 100644 tests/__init__.py create mode 100644 tests/normal/__init__.py diff --git a/bayes_chime/__init__.py b/bayes_chime/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/bayes_chime/normal/__init__.py b/bayes_chime/normal/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/normal/__init__.py b/tests/normal/__init__.py new file mode 100644 index 0000000..e69de29 From 03afafb73b530e3f8ea0c64bbf944596f30b2228 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 09:44:27 +0200 Subject: [PATCH 02/40] Updated requirements --- requirements.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/requirements.txt b/requirements.txt index abd3461..f4c6613 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,7 @@ ConfigArgParse gitpython seaborn +numpy +pandas +gvar +lsqfit From f2efc48019c0c4fa90882ef4135d1f07e47ecdc5 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 09:44:43 +0200 Subject: [PATCH 03/40] New submodules --- bayes_chime/normal/models/__init__.py | 0 bayes_chime/normal/models/base.py | 0 bayes_chime/normal/models/sir.py | 0 bayes_chime/normal/utils.py | 0 tests/normal/models/__init__.py | 0 tests/normal/models/sir_test.py | 0 6 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 bayes_chime/normal/models/__init__.py create mode 100644 bayes_chime/normal/models/base.py create mode 100644 bayes_chime/normal/models/sir.py create mode 100644 bayes_chime/normal/utils.py create mode 100644 tests/normal/models/__init__.py create mode 100644 tests/normal/models/sir_test.py diff --git a/bayes_chime/normal/models/__init__.py b/bayes_chime/normal/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py new file mode 100644 index 0000000..e69de29 diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py new file mode 100644 index 0000000..e69de29 diff --git a/bayes_chime/normal/utils.py b/bayes_chime/normal/utils.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/normal/models/__init__.py b/tests/normal/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py new file mode 100644 index 0000000..e69de29 From d78c52e80fe3161be1640c722fcada6828816b1d Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 09:51:54 +0200 Subject: [PATCH 04/40] Added logistic functions --- bayes_chime/normal/utils.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/bayes_chime/normal/utils.py b/bayes_chime/normal/utils.py index e69de29..172fe3b 100644 --- a/bayes_chime/normal/utils.py +++ b/bayes_chime/normal/utils.py @@ -0,0 +1,33 @@ +"""Utilities for the normal CHIME Bayes module +""" +from typing import TypeVar, Union + +from numpy import exp + +FloatLike = TypeVar("FloatLike") # Floats or integers +FloatLikeArray = TypeVar("FloatLikeArray") # Arrays of floats or integers + +NormalDistVar = TypeVar("NormalDistVar") # Normally distributed random var +NormalDistArray = TypeVar("NormalDistArray") # Array of Normally dist random var + + +def logistic_fcn( # pylint: disable=C0103 + x: Union[FloatLikeArray, NormalDistArray], + L: Union[FloatLike, NormalDistVar], + k: Union[FloatLike, NormalDistVar], + x0: Union[FloatLike, NormalDistVar], +) -> Union[FloatLikeArray, NormalDistArray]: + """Computes `L / (1 + exp(-k(x-x0)))`. + """ + return L / (1 + exp(-k * (x - x0))) + + +def one_minus_logistic_fcn( # pylint: disable=C0103 + x: Union[FloatLikeArray, NormalDistArray], + L: Union[FloatLike, NormalDistVar], + k: Union[FloatLike, NormalDistVar], + x0: Union[FloatLike, NormalDistVar], +) -> FloatLikeArray: + """Computes `1 - L / (1 + exp(-k(x-x0)))`. + """ + return 1 - logistic_fcn(x, L, k, x0) From dccd4c5ca5bcf9ee39134fc0a0028d0a29e41bb6 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 09:58:08 +0200 Subject: [PATCH 05/40] renamed utils to utilities --- bayes_chime/normal/{utils.py => utilities.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename bayes_chime/normal/{utils.py => utilities.py} (100%) diff --git a/bayes_chime/normal/utils.py b/bayes_chime/normal/utilities.py similarity index 100% rename from bayes_chime/normal/utils.py rename to bayes_chime/normal/utilities.py From f7c60a3df7b87f65a6c567e00fcc1154a8eb64cd Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 11:11:43 +0200 Subject: [PATCH 06/40] First draft of abstract model class --- bayes_chime/normal/models/base.py | 178 ++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index e69de29..394a424 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -0,0 +1,178 @@ +"""Helper functions to utilize SIR like models +""" +from typing import Dict, Generator, List, Callable + +from abc import ABC + +from numpy import arange +from pandas import DataFrame + +from bayes_chim.normal.utilities import ( + FloatLike, + NormalDistVar, + FloatOrDistVar, + NormalDistArray, +) + + +class CompartmentModel(ABC): + """Abstract implementation of SIR like compartment model + + Attributes: + model_parameters: A list of all parameters needed to run a simmulation + (used by `simulation_step` or `post_process_simulation`). + These parameters must be present after `parse_input` is run. + compartments: These are the compartments needed by the model. + E.g., susceptible, infected and recovered for standard SIR. + """ + + model_parameters: List[str] = [] + compartments: List[str] = [] + + def __init__( + self, + fit_columns: List[str], + update_parameters: Callable[ + [int, Dict[str, FloatOrDistVar]], Dict[str, FloatOrDistVar] + ] = None, + ): + """Initializes the compartment model + update function + + Arguments: + fit_columns: When calling fit_fcn, this will only return specified column. + This should be used when only a subset of the simulation parameters + should be fit. + update_parameters: This function allows to update effective model parameters + based on the number of model iterations. It takes the number of iteration + and all model (initial) parameters as input. It should return updated + parameters and defaults to no parameter updates. This can be used to + implement social distancing. + + Note: + The update_parameters method should not update parameters in place. + """ + self.fit_columns = fit_columns + self.update_parameters = ( + update_parameters + if Dict[str, FloatOrDistVar] is not None + else lambda nn, pars: pars + ) + + def propagate_uncertainties( + self, meta_pars: Dict[str, FloatLike], dist_pars: Dict[str, NormalDistVar] + ) -> DataFrame: + """Propagates uncertainties through simmulation + + Arguments: + meta_pars: Fixed model meta parameters + dist_pars: Variable model prior parameters + + Returns: + DataFrame containing simulation data + """ + pars = self.parse_input(**meta_pars, **dist_pars) + + df = DataFrame(data=self._iterate_simulation(**pars), index=pars["dates"]) + + return self.post_process_simulation(df, **pars) + + def parse_input( # pylint: disable=R0201 + self, **pars: Dict[str, FloatOrDistVar] + ) -> Dict[str, FloatOrDistVar]: + """Parses parameters before fitting. This should include, e.g., type conversions + """ + return pars + + def post_process_simulation( # pylint: disable=R0201 + self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] + ) -> DataFrame: + """Processes the final simulation result. This can add, e.g., new columns + """ + return df + + def _iterate_simulation( + self, n_iter: int, **pars: Dict[str, FloatOrDistVar], + ) -> Generator[Dict[str, NormalDistVar]]: + """Iterates model to build up SIR data + + Initial data is at day zero (no step). + + Arguments: + n_iter: Number of iterations + sir_fcn: The SIR model step function + beta_i_fcn: Function which maps infected growth for given kwargs + kwargs: Parameters to consturct beta_i schedule and sir step + """ + for nn in arange(n_iter): + yield data + inp_pars = self.update_parameters(nn, **pars) + data = self.simulation_step(data, **inp_pars) + + def simulation_step(self, data, **pars): + """ + """ + return data + + def fit_fcn( # pylint: disable=C0103 + self, xx: Dict[str, FloatLike], pp: Dict[str, NormalDistVar] + ) -> NormalDistArray: + """Wrapper for propagate_uncertainties used for lsqfit.nonlinear_fit function + + Arguments: + xx: Fixed model meta parameters + pp: Variable model prior parameters + + Returns: + Array of `fit_columns` columns without first row (inital data). + """ + df = self.propagate_uncertainties(xx, pp).drop(0) + if self.fit_columns: + df = df[self.fit_columns] + return df.values + + def check_call( # pylint: disable=C0103 + self, + xx: Dict[str, FloatLike], + yy: NormalDistArray, + pp: Dict[str, NormalDistVar], + ): + """Checks if model meta parameters and priors are set as expected to use fitter. + + Checks: + * Non-overlapping model parameters + * Data retrun shape + * Data retun types + + Raises: + Specific error messages if not set up correctly + """ + common_pars = xx.keys().intersection(pp.keys()) + if common_pars: + raise KeyError( + "Fixed and variable model paramers have shared variables:" + " {common_pars}. This is not allowed.".format(common_pars=common_pars) + ) + + yy_fit = self.fit_fcn(xx, pp) + if not yy_fit.shape == yy.shape: + raise ValueError( + "Fit function return has different shape as data" + " fit: {fit_shape} data: {data_shape}.".format( + fit_shape=yy_fit.shape, data_shape=yy.shape + ) + ) + + for n_el, (y_fit, y_data) in enumerate(zip(yy_fit, yy)): + if not isinstance(yy_fit, type(yy)): + raise TypeError( + "Element {n_el} of fit has different type as data:".format( + n_el=n_el + ) + + "\t{y_fit} -> {y_fit_type}!= {y_data} -> {y_data_type}".format( + y_fit_type=type(y_fit), + y_fit=y_fit, + y_data_type=type(y_data), + y_data=y_data, + ) + ) From 9a8e91987a0ccdcb1b58d5c26fde0dc5a9633765 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 11:11:58 +0200 Subject: [PATCH 07/40] Doc updates for model class --- bayes_chime/normal/models/base.py | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 394a424..f400929 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -2,12 +2,12 @@ """ from typing import Dict, Generator, List, Callable -from abc import ABC +from abc import ABC, abstractmethod from numpy import arange from pandas import DataFrame -from bayes_chim.normal.utilities import ( +from bayes_chime.normal.utilities import ( FloatLike, NormalDistVar, FloatOrDistVar, @@ -84,7 +84,7 @@ def parse_input( # pylint: disable=R0201 """ return pars - def post_process_simulation( # pylint: disable=R0201 + def post_process_simulation( # pylint: disable=R0201, W0613, C0103 self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] ) -> DataFrame: """Processes the final simulation result. This can add, e.g., new columns @@ -100,17 +100,26 @@ def _iterate_simulation( Arguments: n_iter: Number of iterations - sir_fcn: The SIR model step function - beta_i_fcn: Function which maps infected growth for given kwargs - kwargs: Parameters to consturct beta_i schedule and sir step + pars: Model meta and flexible parameters """ for nn in arange(n_iter): yield data inp_pars = self.update_parameters(nn, **pars) data = self.simulation_step(data, **inp_pars) - def simulation_step(self, data, **pars): - """ + @abstractmethod + def simulation_step( + self, data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] + ): + """This function implements the actual simulation + + Arguments: + data: The compartments for each iteration + pars: Model parameters + + Returns: + Updated compartments and optionally additional information like change + from last iteration. """ return data From af21754d46511ce2dab3a56ff309767f5c9ac89a Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 11:12:15 +0200 Subject: [PATCH 08/40] Shorter notation for typevars --- bayes_chime/normal/utilities.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/bayes_chime/normal/utilities.py b/bayes_chime/normal/utilities.py index 172fe3b..aed34bd 100644 --- a/bayes_chime/normal/utilities.py +++ b/bayes_chime/normal/utilities.py @@ -10,24 +10,21 @@ NormalDistVar = TypeVar("NormalDistVar") # Normally distributed random var NormalDistArray = TypeVar("NormalDistArray") # Array of Normally dist random var +FloatOrDistVar = Union[FloatLike, NormalDistVar] +FloatOrDistArray = Union[FloatLikeArray, NormalDistArray] + def logistic_fcn( # pylint: disable=C0103 - x: Union[FloatLikeArray, NormalDistArray], - L: Union[FloatLike, NormalDistVar], - k: Union[FloatLike, NormalDistVar], - x0: Union[FloatLike, NormalDistVar], -) -> Union[FloatLikeArray, NormalDistArray]: + x: FloatOrDistArray, L: FloatOrDistVar, k: FloatOrDistVar, x0: FloatOrDistVar, +) -> FloatOrDistArray: """Computes `L / (1 + exp(-k(x-x0)))`. """ return L / (1 + exp(-k * (x - x0))) def one_minus_logistic_fcn( # pylint: disable=C0103 - x: Union[FloatLikeArray, NormalDistArray], - L: Union[FloatLike, NormalDistVar], - k: Union[FloatLike, NormalDistVar], - x0: Union[FloatLike, NormalDistVar], -) -> FloatLikeArray: + x: FloatOrDistArray, L: FloatOrDistVar, k: FloatOrDistVar, x0: FloatOrDistVar, +) -> FloatOrDistArray: """Computes `1 - L / (1 + exp(-k(x-x0)))`. """ return 1 - logistic_fcn(x, L, k, x0) From e8e99bbc152d99ec71719ff292f45dfdd5a88d52 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 12:08:21 +0200 Subject: [PATCH 09/40] Reshuffled module to simplify for users --- bayes_chime/normal/models/base.py | 96 ++++++++++++++++++++----------- 1 file changed, 63 insertions(+), 33 deletions(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index f400929..8a64e11 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -5,7 +5,7 @@ from abc import ABC, abstractmethod from numpy import arange -from pandas import DataFrame +from pandas import DataFrame, DatetimeIndex, infer_freq from bayes_chime.normal.utilities import ( FloatLike, @@ -22,13 +22,66 @@ class CompartmentModel(ABC): model_parameters: A list of all parameters needed to run a simmulation (used by `simulation_step` or `post_process_simulation`). These parameters must be present after `parse_input` is run. + optional_parameters: Further parameters which extend model predictions but + are not required. E.g., to do conversions between parameters. compartments: These are the compartments needed by the model. E.g., susceptible, infected and recovered for standard SIR. """ - model_parameters: List[str] = [] + # ---------------------------------------- + # Below you can find methods to overload + # ---------------------------------------- + + model_parameters: List[str] = ["dates"] + optional_parameters: List[str] = [] compartments: List[str] = [] + def parse_input( # pylint: disable=R0201 + self, **pars: Dict[str, FloatOrDistVar] + ) -> Dict[str, FloatOrDistVar]: + """Parses parameters before fitting. This should include, e.g., type conversions + + By default, checks dates and adds frequency. + """ + dates = pars["dates"] + if not isinstance(dates, DatetimeIndex): + raise TypeError("Dates must be of type DatetimeIndex") + + freq = dates.freq or infer_freq(dates) + if "freq" not in pars: + pars["freq"] = freq + elif pars["freq"] != freq: + raise ValueError("Specified frequency does not match dates.") + + return pars + + def post_process_simulation( # pylint: disable=R0201, W0613, C0103 + self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] + ) -> DataFrame: + """Processes the final simulation result. This can add, e.g., new columns + """ + return df + + @abstractmethod + def simulation_step( + self, data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] + ): + """This function implements the actual simulation + + Arguments: + data: The compartments for each iteration + pars: Model parameters + + Returns: + Updated compartments and optionally additional information like change + from last iteration. + """ + return data + + # ---------------------------------------------------------- + # This part should be fixed unless you add functionality + # ---------------------------------------------------------- + def __init__( self, fit_columns: List[str], @@ -73,24 +126,13 @@ def propagate_uncertainties( """ pars = self.parse_input(**meta_pars, **dist_pars) - df = DataFrame(data=self._iterate_simulation(**pars), index=pars["dates"]) + df = DataFrame( + data=self._iterate_simulation(len(pars["dates"]), **pars), + index=pars["dates"], + ) return self.post_process_simulation(df, **pars) - def parse_input( # pylint: disable=R0201 - self, **pars: Dict[str, FloatOrDistVar] - ) -> Dict[str, FloatOrDistVar]: - """Parses parameters before fitting. This should include, e.g., type conversions - """ - return pars - - def post_process_simulation( # pylint: disable=R0201, W0613, C0103 - self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] - ) -> DataFrame: - """Processes the final simulation result. This can add, e.g., new columns - """ - return df - def _iterate_simulation( self, n_iter: int, **pars: Dict[str, FloatOrDistVar], ) -> Generator[Dict[str, NormalDistVar]]: @@ -102,27 +144,15 @@ def _iterate_simulation( n_iter: Number of iterations pars: Model meta and flexible parameters """ + data = { + compartment: pars["initial_{compartment}".format(compartment=compartment)] + for compartment in self.compartments + } for nn in arange(n_iter): yield data inp_pars = self.update_parameters(nn, **pars) data = self.simulation_step(data, **inp_pars) - @abstractmethod - def simulation_step( - self, data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] - ): - """This function implements the actual simulation - - Arguments: - data: The compartments for each iteration - pars: Model parameters - - Returns: - Updated compartments and optionally additional information like change - from last iteration. - """ - return data - def fit_fcn( # pylint: disable=C0103 self, xx: Dict[str, FloatLike], pp: Dict[str, NormalDistVar] ) -> NormalDistArray: From c63a1d01ae519dce7829d86d438aea2a722fafcc Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 12:08:36 +0200 Subject: [PATCH 10/40] First implementation of SIR model --- bayes_chime/normal/models/sir.py | 134 +++++++++++++++++++++++++++++++ 1 file changed, 134 insertions(+) diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index e69de29..717acb6 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -0,0 +1,134 @@ +"""Implementation of SIR model +""" +from typing import Dict, List + +from numpy import log +from pandas import DataFrame + +from bayes_chime.normal.utilities import FloatOrDistVar, NormalDistVar +from bayes_chime.normal.models.base import CompartmentModel + + +class SIRModel(CompartmentModel): + """Basic SIR model + """ + + model_parameters: List[str] = [ + "dates", # DatetimeIndex + "initial_susceptible", + "initial_infected", + "inital_recovered", + "beta", # or inital_doubling_time + "gamma", # or recovery_days + ] + optiona_parameters: List[str] = [ + "recovery_days", + "inital_doubling_time", + # all keywords below are used to compute hospital admissions and census + "initial_hospitalized", + "market_share", + "hospitalization_probability", + "hospital_length_of_stay", + ] + compartments: List[str] = ["susceptible", "infected", "recovered"] + + def parse_input( # pylint: disable=R0201 + self, **pars: Dict[str, FloatOrDistVar] + ) -> Dict[str, FloatOrDistVar]: + """Parses dates, gamma and beta parameters if applicable. + """ + pars = super().parse_input(**pars) + + if "gamma" not in pars: + pars["gamma"] = 1 / (pars["recovery_days"] / pars["freq"]) + + if "beta" not in pars: + total_population = 0 + for comp in self.compartments: + total_population += pars["intial_" + comp] + + beta = log(2) / (pars["inital_doubling_time"] / pars["freq"]) + beta += pars["gamma"] + beta *= total_population / pars["initial_susceptible"] + pars["beta"] = beta + + return pars + + def post_process_simulation( # pylint: disable=R0201, W0613, C0103 + self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] + ) -> DataFrame: + """Compute Census based on exponential LOS distribution if parameters present. + """ + # fill initial hosp admits if present + df = df.fillna(0) + + # Add hosp census + hosp_keys = set(["initial_hospitalized", "hospitalization_length_of_stay"]) + if hosp_keys.issubset(pars.keys()) and "hospital_admits" in df.columns: + + census = [pars["initial_hospitalized"]] + for admits in df.hospital_admits.values[1:]: + census.append( + admits + + (1 - 1 / pars["hospitalization_length_of_stay"]) * census[-1] + ) + df["hospital_census"] = census + + return df + + def simulation_step( + self, data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] + ): + """Executes SIR step and patches results such that each component is larger zero. + + Arguments: + data: + susceptible: Susceptible population + infected: Infected population + recovered: Recovered population + pars: + beta_i: Growth rate for infected + gamma_i: Recovery rate for infected + optional: + hospitalization_probability: Percent of new cases becoming hospitalized + market_share: Market share of hospital + + Returns: + Updated compartments and optionally additional information like change + from last iteration. + """ + susceptible = data["susceptible"] + infected = data["infected"] + recovered = data["recovered"] + + total = susceptible + infected + recovered + + d_is = pars["beta"] * susceptible / total * infected + d_ri = pars["gamma"] * infected + + susceptible -= d_is + infected += d_is - d_ri + recovered += d_ri + + susceptible = max(susceptible, 0) + infected = max(infected, 0) + recovered = max(recovered, 0) + + rescale = total / (susceptible + infected + recovered) + + out = { + "susceptible": susceptible * rescale, + "infected": infected * rescale, + "recovered": recovered * rescale, + "infected_new": d_is * rescale, + "recovered_new": d_ri * rescale, + } + + if "hospitalization_probability" in pars and "market_share" in pars: + out["hospital_admits"] = ( + out["infected_new"] + * pars["hospitalization_probability"] + * pars["market_share"] + ) + + return out From 46cfe66e15794730efcbb595c8cb4feb96f66650 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 12:13:15 +0200 Subject: [PATCH 11/40] Flatten fit array if shape is 1D --- bayes_chime/normal/models/base.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 8a64e11..5a41f51 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -168,7 +168,8 @@ def fit_fcn( # pylint: disable=C0103 df = self.propagate_uncertainties(xx, pp).drop(0) if self.fit_columns: df = df[self.fit_columns] - return df.values + + return df.values if df.values.shape[0] > 1 else df.values.flatten() def check_call( # pylint: disable=C0103 self, From 37bc30b7922c94bb6f85db93ec5bc1033db607ba Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 12:23:53 +0200 Subject: [PATCH 12/40] Iterate over dates instead of numbers --- bayes_chime/normal/models/base.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 5a41f51..e25c50b 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -103,7 +103,8 @@ def __init__( implement social distancing. Note: - The update_parameters method should not update parameters in place. + If the update_parameters method requires additional arguments, they must be + passed to the respective model function calls. """ self.fit_columns = fit_columns self.update_parameters = ( @@ -127,14 +128,13 @@ def propagate_uncertainties( pars = self.parse_input(**meta_pars, **dist_pars) df = DataFrame( - data=self._iterate_simulation(len(pars["dates"]), **pars), - index=pars["dates"], - ) + data=self._iterate_simulation(len(pars["dates"]), **pars) + ).set_index("dates") return self.post_process_simulation(df, **pars) def _iterate_simulation( - self, n_iter: int, **pars: Dict[str, FloatOrDistVar], + self, **pars: Dict[str, FloatOrDistVar], ) -> Generator[Dict[str, NormalDistVar]]: """Iterates model to build up SIR data @@ -148,9 +148,10 @@ def _iterate_simulation( compartment: pars["initial_{compartment}".format(compartment=compartment)] for compartment in self.compartments } - for nn in arange(n_iter): + for date in pars["dates"]: + data["date"] = date yield data - inp_pars = self.update_parameters(nn, **pars) + inp_pars = self.update_parameters(date, **pars) data = self.simulation_step(data, **inp_pars) def fit_fcn( # pylint: disable=C0103 From 15d3ab2259d3efc15124e08262b75001e6093184 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 13:00:59 +0200 Subject: [PATCH 13/40] First unittests for SIR model --- bayes_chime/normal/models/__init__.py | 3 + bayes_chime/normal/models/base.py | 19 ++- pytest.ini | 2 + requirements-dev.txt | 2 + tests/normal/models/sir_test.py | 219 ++++++++++++++++++++++++++ 5 files changed, 235 insertions(+), 10 deletions(-) create mode 100644 pytest.ini create mode 100644 requirements-dev.txt diff --git a/bayes_chime/normal/models/__init__.py b/bayes_chime/normal/models/__init__.py index e69de29..4650db8 100644 --- a/bayes_chime/normal/models/__init__.py +++ b/bayes_chime/normal/models/__init__.py @@ -0,0 +1,3 @@ +"""This module contains implementations of the compartment models +""" +from bayes_chime.normal.models.sir import SIRModel diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index e25c50b..dd704f7 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -1,10 +1,11 @@ """Helper functions to utilize SIR like models """ -from typing import Dict, Generator, List, Callable +from typing import Dict, Generator, List, Callable, Optional from abc import ABC, abstractmethod -from numpy import arange +from datetime import date as Date + from pandas import DataFrame, DatetimeIndex, infer_freq from bayes_chime.normal.utilities import ( @@ -84,9 +85,9 @@ def simulation_step( def __init__( self, - fit_columns: List[str], + fit_columns: Optional[List[str]] = None, update_parameters: Callable[ - [int, Dict[str, FloatOrDistVar]], Dict[str, FloatOrDistVar] + [Date, Dict[str, FloatOrDistVar]], Dict[str, FloatOrDistVar] ] = None, ): """Initializes the compartment model @@ -109,8 +110,8 @@ def __init__( self.fit_columns = fit_columns self.update_parameters = ( update_parameters - if Dict[str, FloatOrDistVar] is not None - else lambda nn, pars: pars + if update_parameters is not None + else lambda date, **pars: pars ) def propagate_uncertainties( @@ -127,15 +128,13 @@ def propagate_uncertainties( """ pars = self.parse_input(**meta_pars, **dist_pars) - df = DataFrame( - data=self._iterate_simulation(len(pars["dates"]), **pars) - ).set_index("dates") + df = DataFrame(data=self._iterate_simulation(**pars)).set_index("date") return self.post_process_simulation(df, **pars) def _iterate_simulation( self, **pars: Dict[str, FloatOrDistVar], - ) -> Generator[Dict[str, NormalDistVar]]: + ) -> Generator[Dict[str, NormalDistVar], None, None]: """Iterates model to build up SIR data Initial data is at day zero (no step). diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..2c2dad0 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,2 @@ +[pytest] +addopts = -v diff --git a/requirements-dev.txt b/requirements-dev.txt new file mode 100644 index 0000000..cec21c3 --- /dev/null +++ b/requirements-dev.txt @@ -0,0 +1,2 @@ +pytest +penn_chime diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index e69de29..b65f2cc 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -0,0 +1,219 @@ +"""Tests for SIR model in this repo +* Compares conserved quantities +* Compares model against Penn CHIME w/wo social policies +* Checks logistic policies in extreme limit +""" +from typing import Tuple +from datetime import date + +from pytest import fixture + +from numpy import zeros +from pandas import DataFrame, Series, DatetimeIndex +from pandas.testing import assert_frame_equal, assert_series_equal + +from penn_chime.model.parameters import Parameters, Disposition +from penn_chime.model.sir import ( + Sir, + sim_sir, + calculate_dispositions, + calculate_admits, + calculate_census, +) + +from bayes_chime.normal.models import SIRModel + +COLS_TO_COMPARE = [ + "susceptible", + "infected", + "recovered", + "hospital_admits", + # Does not compare census as this repo uses the exponential distribution +] +COLUMN_MAP = { + "hospitalized": "hospital_admits", +} + + +@fixture(name="penn_chime_setup") +def fixture_penn_chime_setup() -> Tuple[Parameters, Sir]: + """Initializes penn_chime parameters and SIR model + """ + p = Parameters( + current_hospitalized=69, + date_first_hospitalized=date(2020, 3, 7), + doubling_time=None, + hospitalized=Disposition.create(days=7, rate=0.025), + icu=Disposition.create(days=9, rate=0.0075), + infectious_days=14, + market_share=0.15, + n_days=100, + population=3600000, + recovered=0, + relative_contact_rate=0.3, + ventilated=Disposition.create(days=10, rate=0.005), + ) + return p, Sir(p) + + +@fixture(name="penn_chime_raw_df_no_policy") +def fixture_penn_chime_raw_df_no_policy(penn_chime_setup) -> DataFrame: + """Runs penn_chime SIR model for no social policies + """ + p, simsir = penn_chime_setup + + n_days = simsir.raw_df.day.max() - simsir.raw_df.day.min() + policies = [(simsir.beta, n_days)] + raw = sim_sir( + simsir.susceptible, + simsir.infected, + p.recovered, + simsir.gamma, + -simsir.i_day, + policies, + ) + calculate_dispositions(raw, simsir.rates, market_share=p.market_share) + calculate_admits(raw, simsir.rates) + calculate_census(raw, simsir.days) + + raw_df = DataFrame(raw) + raw_df.index = simsir.raw_df.date + + return raw_df.fillna(0) + + +@fixture(name="sir_data_wo_policy") +def fixture_sir_data_wo_policy(penn_chime_setup, penn_chime_raw_df_no_policy): + """Provides data for local sir module + """ + p, simsir = penn_chime_setup + raw_df = penn_chime_raw_df_no_policy + day0 = raw_df.iloc[0].fillna(0) + + total = day0.susceptible + day0.infected + day0.recovered + + pars = { + "beta": simsir.beta * total, # This repo uses S/total in sir + "gamma": simsir.gamma, + "initial_susceptible": day0.susceptible, + "initial_infected": day0.infected, + "initial_hospitalized": day0.hospitalized, + "initial_recovered": day0.recovered, + "hospitalization_probability": simsir.rates["hospitalized"], + } + x = { + "dates": DatetimeIndex(raw_df.index), + "hospital_length_of_stay": p.dispositions["hospitalized"].days, + "market_share": p.market_share, + } + return x, pars + + +@fixture(name="sir_data_w_policy") +def fixture_sir_data_w_policy(penn_chime_setup): + """Provides data for local sir module with implemented policies + """ + p, simsir = penn_chime_setup + raw_df = simsir.raw_df.set_index("date") + day0 = raw_df.iloc[0].fillna(0) + + total = day0.susceptible + day0.infected + day0.recovered + + pars = { + "beta": simsir.beta * total, # This repo uses S/total in sir + "gamma": simsir.gamma, + "initial_susceptible": day0.susceptible, + "initial_infected": day0.infected, + "initial_hospitalized": day0.hospitalized, + "initial_recovered": day0.recovered, + "hospitalization_probability": simsir.rates["hospitalized"], + } + x = { + "dates": DatetimeIndex(raw_df.index), + "hospital_length_of_stay": p.dispositions["hospitalized"].days, + "market_share": p.market_share, + } + return x, pars + + +def test_conserved_n(sir_data_wo_policy): + """Checks if S + I + R is conserved for local SIR + """ + x, pars = sir_data_wo_policy + sir_model = SIRModel() + + n_total = 0 + for key in sir_model.compartments: + n_total += pars[f"initial_{key}"] + + predictions = sir_model.propagate_uncertainties(x, pars) + + n_computed = predictions[sir_model.compartments].sum(axis=1) + n_expected = Series(data=[n_total] * len(n_computed), index=n_computed.index) + + assert_series_equal(n_expected, n_computed) + + +def test_sir_vs_penn_chime_no_policies(penn_chime_raw_df_no_policy, sir_data_wo_policy): + """Compares local SIR against penn_chime SIR for no social policies + """ + x, pars = sir_data_wo_policy + + sir_model = SIRModel() + predictions = sir_model.propagate_uncertainties(x, pars) + + assert_frame_equal( + penn_chime_raw_df_no_policy.rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], + predictions[COLS_TO_COMPARE], + ) + + +# +# +# def test_sir_vs_penn_chime_w_policies(penn_chime_setup, sir_data_w_policy): +# """Compares local SIR against penn_chime SIR for with social policies +# """ +# p, sir = penn_chime_setup +# x, pars = sir_data_w_policy +# +# policies = sir.gen_policy(p) +# +# def beta_i_fcn(x_iter, **kwargs): # pylint: disable=W0613 +# out = zeros(len(x_iter)) +# ii = 0 +# for beta, n_days in policies: +# for _ in range(n_days): +# out[ii] = beta * p.population +# ii += 1 +# +# return out +# +# f = FitFcn(sir_step, beta_i_fcn=beta_i_fcn) +# y = f(x, pars) +# +# assert_frame_equal( +# sir.raw_df.rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], y[COLS_TO_COMPARE], +# ) +# +# +# def test_sir_logistic_policy(penn_chime_setup, sir_data_w_policy): +# """Compares local SIR against penn_chime SIR for with social policies +# where social distancing policies are no implemented as a logistic function +# """ +# p, sir = penn_chime_setup +# x, pars = sir_data_w_policy +# +# policies = sir.gen_policy(p) +# +# # Set up logistic function to match policies (Sharp decay) +# pars["beta_i"] = policies[0][0] * p.population +# pars["ratio"] = 1 - policies[1][0] / policies[0][0] +# pars["x0"] = policies[0][1] - 0.5 +# pars["decay_width"] = 1.0e7 +# +# f = FitFcn(sir_step, beta_i_fcn=one_minus_logistic_fcn) +# y = f(x, pars) +# +# assert_frame_equal( +# sir.raw_df.rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], y[COLS_TO_COMPARE], +# ) From 0b6697a56249d33ecd086de9cf69ac3162fcfac7 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 13:12:04 +0200 Subject: [PATCH 14/40] Added policy implementation test --- tests/normal/models/sir_test.py | 58 +++++++++++++++++---------------- 1 file changed, 30 insertions(+), 28 deletions(-) diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index b65f2cc..4710e32 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -4,7 +4,7 @@ * Checks logistic policies in extreme limit """ from typing import Tuple -from datetime import date +from datetime import date, timedelta from pytest import fixture @@ -168,33 +168,35 @@ def test_sir_vs_penn_chime_no_policies(penn_chime_raw_df_no_policy, sir_data_wo_ ) -# -# -# def test_sir_vs_penn_chime_w_policies(penn_chime_setup, sir_data_w_policy): -# """Compares local SIR against penn_chime SIR for with social policies -# """ -# p, sir = penn_chime_setup -# x, pars = sir_data_w_policy -# -# policies = sir.gen_policy(p) -# -# def beta_i_fcn(x_iter, **kwargs): # pylint: disable=W0613 -# out = zeros(len(x_iter)) -# ii = 0 -# for beta, n_days in policies: -# for _ in range(n_days): -# out[ii] = beta * p.population -# ii += 1 -# -# return out -# -# f = FitFcn(sir_step, beta_i_fcn=beta_i_fcn) -# y = f(x, pars) -# -# assert_frame_equal( -# sir.raw_df.rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], y[COLS_TO_COMPARE], -# ) -# +def test_sir_vs_penn_chime_w_policies(penn_chime_setup, sir_data_w_policy): + """Compares local SIR against penn_chime SIR for with social policies + """ + p, sir = penn_chime_setup + x, pars = sir_data_w_policy + + policies = sir.gen_policy(p) + new_policy_date = x["dates"][0] + timedelta(days=policies[0][1]) + beta0, beta1 = policies[0][0], policies[1][0] + + n_total = 0 + for key in SIRModel.compartments: + n_total += pars[f"initial_{key}"] + + def update_parameters(ddate, **pars): # pylint: disable=W0613 + pars["beta"] = (beta0 if ddate < new_policy_date else beta1) * n_total + return pars + + sir_model = SIRModel(update_parameters=update_parameters) + predictions = sir_model.propagate_uncertainties(x, pars) + + assert_frame_equal( + sir.raw_df.set_index("date") + .fillna(0) + .rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], + predictions[COLS_TO_COMPARE], + ) + + # # def test_sir_logistic_policy(penn_chime_setup, sir_data_w_policy): # """Compares local SIR against penn_chime SIR for with social policies From eb4d568cadcc24cc8b51be7edd424424a3687b23 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 13:31:43 +0200 Subject: [PATCH 15/40] Added test for logistic function --- tests/normal/models/sir_test.py | 62 +++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 27 deletions(-) diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index 4710e32..2e642a3 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -22,6 +22,7 @@ ) from bayes_chime.normal.models import SIRModel +from bayes_chime.normal.utilities import one_minus_logistic_fcn COLS_TO_COMPARE = [ "susceptible", @@ -178,12 +179,8 @@ def test_sir_vs_penn_chime_w_policies(penn_chime_setup, sir_data_w_policy): new_policy_date = x["dates"][0] + timedelta(days=policies[0][1]) beta0, beta1 = policies[0][0], policies[1][0] - n_total = 0 - for key in SIRModel.compartments: - n_total += pars[f"initial_{key}"] - def update_parameters(ddate, **pars): # pylint: disable=W0613 - pars["beta"] = (beta0 if ddate < new_policy_date else beta1) * n_total + pars["beta"] = (beta0 if ddate < new_policy_date else beta1) * p.population return pars sir_model = SIRModel(update_parameters=update_parameters) @@ -197,25 +194,36 @@ def update_parameters(ddate, **pars): # pylint: disable=W0613 ) -# -# def test_sir_logistic_policy(penn_chime_setup, sir_data_w_policy): -# """Compares local SIR against penn_chime SIR for with social policies -# where social distancing policies are no implemented as a logistic function -# """ -# p, sir = penn_chime_setup -# x, pars = sir_data_w_policy -# -# policies = sir.gen_policy(p) -# -# # Set up logistic function to match policies (Sharp decay) -# pars["beta_i"] = policies[0][0] * p.population -# pars["ratio"] = 1 - policies[1][0] / policies[0][0] -# pars["x0"] = policies[0][1] - 0.5 -# pars["decay_width"] = 1.0e7 -# -# f = FitFcn(sir_step, beta_i_fcn=one_minus_logistic_fcn) -# y = f(x, pars) -# -# assert_frame_equal( -# sir.raw_df.rename(columns=COLUMN_MAP)[COLS_TO_COMPARE], y[COLS_TO_COMPARE], -# ) +def test_sir_logistic_policy(penn_chime_setup, sir_data_w_policy): + """Compares local SIR against penn_chime SIR for implemented social policies + where policies are implemented as a logistic function + """ + p, sir = penn_chime_setup + x, pars = sir_data_w_policy + + policies = sir.gen_policy(p) + + # Set up logistic function to match policies (Sharp decay) + pars["beta"] = policies[0][0] * p.population + ## This are new parameters needed by one_minus_logistic_fcn + pars["L"] = 1 - policies[1][0] / policies[0][0] + pars["x0"] = policies[0][1] - 0.5 + pars["k"] = 1.0e7 + + def update_parameters(ddate, **kwargs): + xx = (ddate - x["dates"][0]).days + ppars = kwargs.copy() + ppars["beta"] = kwargs["beta"] * one_minus_logistic_fcn( + xx, L=kwargs["L"], k=kwargs["k"], x0=kwargs["x0"], + ) + return ppars + + sir_model = SIRModel(update_parameters=update_parameters) + predictions = sir_model.propagate_uncertainties(x, pars) + + assert_frame_equal( + sir.raw_df.set_index("date") + .rename(columns=COLUMN_MAP)[COLS_TO_COMPARE] + .fillna(0), + predictions[COLS_TO_COMPARE], + ) From 2094cec77934d55335b06b8a6a7b00d7d08c87ac Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 13:55:10 +0200 Subject: [PATCH 16/40] Changed freq to days_per_step --- bayes_chime/normal/models/base.py | 11 ++++++----- bayes_chime/normal/models/sir.py | 22 +++++++++++----------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index dd704f7..0eb2c23 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -5,6 +5,7 @@ from abc import ABC, abstractmethod from datetime import date as Date +from datetime import timedelta from pandas import DataFrame, DatetimeIndex, infer_freq @@ -48,11 +49,11 @@ def parse_input( # pylint: disable=R0201 if not isinstance(dates, DatetimeIndex): raise TypeError("Dates must be of type DatetimeIndex") - freq = dates.freq or infer_freq(dates) - if "freq" not in pars: - pars["freq"] = freq - elif pars["freq"] != freq: - raise ValueError("Specified frequency does not match dates.") + if not dates.freq: + dates.freq = infer_freq(dates) + pars["dates"] = dates + + pars["days_per_step"] = pars["dates"].freq / timedelta(days=1) return pars diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index 717acb6..782543b 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -40,14 +40,14 @@ def parse_input( # pylint: disable=R0201 pars = super().parse_input(**pars) if "gamma" not in pars: - pars["gamma"] = 1 / (pars["recovery_days"] / pars["freq"]) + pars["gamma"] = 1 / (pars["recovery_days"] / pars["days_per_step"]) if "beta" not in pars: total_population = 0 for comp in self.compartments: total_population += pars["intial_" + comp] - beta = log(2) / (pars["inital_doubling_time"] / pars["freq"]) + beta = log(2) / (pars["inital_doubling_time"] / pars["days_per_step"]) beta += pars["gamma"] beta *= total_population / pars["initial_susceptible"] pars["beta"] = beta @@ -87,8 +87,8 @@ def simulation_step( infected: Infected population recovered: Recovered population pars: - beta_i: Growth rate for infected - gamma_i: Recovery rate for infected + beta: Growth rate for infected + gamma: Recovery rate for infected optional: hospitalization_probability: Percent of new cases becoming hospitalized market_share: Market share of hospital @@ -103,12 +103,12 @@ def simulation_step( total = susceptible + infected + recovered - d_is = pars["beta"] * susceptible / total * infected - d_ri = pars["gamma"] * infected + d_si = pars["beta"] * susceptible / total * infected + d_ir = pars["gamma"] * infected - susceptible -= d_is - infected += d_is - d_ri - recovered += d_ri + susceptible -= d_si + infected += d_si - d_ir + recovered += d_ir susceptible = max(susceptible, 0) infected = max(infected, 0) @@ -120,8 +120,8 @@ def simulation_step( "susceptible": susceptible * rescale, "infected": infected * rescale, "recovered": recovered * rescale, - "infected_new": d_is * rescale, - "recovered_new": d_ri * rescale, + "infected_new": d_si * rescale, + "recovered_new": d_ir * rescale, } if "hospitalization_probability" in pars and "market_share" in pars: From 9000a0267a2fba5e3f20b1a7cbe9f970f4630b91 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 14:07:19 +0200 Subject: [PATCH 17/40] Added unit conversion test --- tests/normal/models/sir_test.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index 2e642a3..7f69182 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -227,3 +227,19 @@ def update_parameters(ddate, **kwargs): .fillna(0), predictions[COLS_TO_COMPARE], ) + + +def test_sir_type_conversion(sir_data_w_policy): + """Compares local SIR run with set gamma vs set with recovery_days + """ + x, pars = sir_data_w_policy + + sir_model = SIRModel() + predictions = sir_model.propagate_uncertainties(x, pars) + + pars["recovery_days"] = 1 / pars.pop("gamma") + new_predictions = sir_model.propagate_uncertainties(x, pars) + + assert_frame_equal( + predictions, new_predictions, + ) From 8b0c6d33ef70c8535300fb3d3c895376c30895f2 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 15:44:29 +0200 Subject: [PATCH 18/40] Added SEIR model plus test --- bayes_chime/normal/models/__init__.py | 1 + bayes_chime/normal/models/base.py | 3 +- bayes_chime/normal/models/seir.py | 117 ++++++++++++++++++++++++++ tests/normal/models/seir_test.py | 85 +++++++++++++++++++ tests/normal/models/sir_test.py | 1 - 5 files changed, 205 insertions(+), 2 deletions(-) create mode 100644 bayes_chime/normal/models/seir.py create mode 100644 tests/normal/models/seir_test.py diff --git a/bayes_chime/normal/models/__init__.py b/bayes_chime/normal/models/__init__.py index 4650db8..592fa44 100644 --- a/bayes_chime/normal/models/__init__.py +++ b/bayes_chime/normal/models/__init__.py @@ -1,3 +1,4 @@ """This module contains implementations of the compartment models """ from bayes_chime.normal.models.sir import SIRModel +from bayes_chime.normal.models.seir import SEIRModel diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 0eb2c23..442576b 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -64,9 +64,10 @@ def post_process_simulation( # pylint: disable=R0201, W0613, C0103 """ return df + @staticmethod @abstractmethod def simulation_step( - self, data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] + data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] ): """This function implements the actual simulation diff --git a/bayes_chime/normal/models/seir.py b/bayes_chime/normal/models/seir.py new file mode 100644 index 0000000..5ca0c2a --- /dev/null +++ b/bayes_chime/normal/models/seir.py @@ -0,0 +1,117 @@ +"""Implementation of SIR model +""" +from typing import Dict, List + +from bayes_chime.normal.utilities import FloatOrDistVar, NormalDistVar +from bayes_chime.normal.models.sir import SIRModel + + +class SEIRModel(SIRModel): + """Basic SEIR model + """ + + model_parameters: List[str] = [ + "dates", # DatetimeIndex + "initial_susceptible", + "initial_exposed", + "initial_infected", + "inital_recovered", + "beta", # or inital_doubling_time + "gamma", # or recovery_days + "alpha", # or incubation_days + ] + optiona_parameters: List[str] = [ + "recovery_days", + "inital_doubling_time", + "incubation_days", + # all keywords below are used to compute hospital admissions and census + "initial_hospitalized", + "market_share", + "hospitalization_probability", + "hospital_length_of_stay", + ] + compartments: List[str] = [ + "susceptible", + "exposed", + "infected", + "recovered", + ] + + def parse_input( # pylint: disable=R0201 + self, **pars: Dict[str, FloatOrDistVar] + ) -> Dict[str, FloatOrDistVar]: + """Parses dates, gamma and beta parameters if applicable. + """ + pars = super().parse_input(**pars) + + if "alpha" not in pars: + pars["alpha"] = 1 / (pars["incubation_days"] / pars["days_per_step"]) + + return pars + + @staticmethod + def simulation_step( + data: Dict[str, NormalDistVar], **pars: Dict[str, FloatOrDistVar] + ): + """Executes SIR step and patches results such that each component is larger zero. + + Arguments: + data: + susceptible: Susceptible population + exposed: Exposed poplation + infected: Infected population + recovered: Recovered population + pars: + beta: Growth rate for infected + alpha: Incubation rate for infected + gamma: Recovery rate for infected + nu: changes effect of susceptible for exposed to `(S/N) ** nu` + optional: + hospitalization_probability: Percent of new cases becoming hospitalized + market_share: Market share of hospital + + Returns: + Updated compartments and optionally additional information like change + from last iteration. + """ + susceptible = data["susceptible"] + exposed = data["exposed"] + infected = data["infected"] + recovered = data["recovered"] + + total = susceptible + exposed + infected + recovered + + d_se = pars["beta"] * (susceptible / total) ** pars["nu"] * infected + d_ei = pars["alpha"] * exposed + d_ir = pars["gamma"] * infected + + susceptible -= d_se + exposed += d_se - d_ei + infected += d_ei - d_ir + recovered += d_ir + + susceptible = max(susceptible, 0) + exposed = max(exposed, 0) + infected = max(infected, 0) + recovered = max(recovered, 0) + + rescale = total / (susceptible + exposed + infected + recovered) + + out = { + "susceptible": susceptible * rescale, + "exposed": exposed * rescale, + "infected": infected * rescale, + "recovered": recovered * rescale, + "exposed_new": d_se * rescale, + "infected_new": d_ei * rescale, + "recovered_new": d_ir * rescale, + } + + if "hospitalization_probability" in pars and "market_share" in pars: + out["hospital_admits"] = ( + out["infected_new"] + * pars["hospitalization_probability"] + * pars["market_share"] + ) + + return out diff --git a/tests/normal/models/seir_test.py b/tests/normal/models/seir_test.py new file mode 100644 index 0000000..898a4e9 --- /dev/null +++ b/tests/normal/models/seir_test.py @@ -0,0 +1,85 @@ +"""Tests for SEIR model in this repo +* Compares conserved quantities +* Compares model against SEIR wo social policies in limit to SIR +""" +from pytest import fixture + +from pandas import Series +from pandas.testing import assert_frame_equal, assert_series_equal + +from bayes_chime.normal.models import SIRModel, SEIRModel + +from tests.normal.models.sir_test import ( # pylint: disable=W0611 + fixture_sir_data_wo_policy, + fixture_penn_chime_setup, + fixture_penn_chime_raw_df_no_policy, +) + +COLS_TO_COMPARE = [ + "susceptible", + "infected", + "recovered", + # Does not compare census as this repo uses the exponential distribution +] + + +@fixture(name="seir_data") +def fixture_seir_data(sir_data_wo_policy): + """Returns data for the SIHR model + """ + x, p = sir_data_wo_policy + pp = p.copy() + xx = x.copy() + pp["alpha"] = 0.5 + pp["nu"] = 1 + pp["initial_exposed"] = 0 + + return xx, pp + + +def test_conserved_n(seir_data): + """Checks if S + E + I + R is conserved for SEIR + """ + x, pars = seir_data + + n_total = 0 + for key in SEIRModel.compartments: + n_total += pars[f"initial_{key}"] + + seir_model = SEIRModel() + predictions = seir_model.propagate_uncertainties(x, pars) + + n_computed = predictions[SEIRModel.compartments].sum(axis=1) + n_expected = Series(data=[n_total] * len(n_computed), index=n_computed.index) + + assert_series_equal(n_expected, n_computed) + + +def test_compare_sir_vs_seir(sir_data_wo_policy, seir_data, monkeypatch): + """Checks if SEIR and SIR return same results if the code enforces + + * alpha = gamma + * E = 0 + * dI = dE + """ + x_sir, pars_sir = sir_data_wo_policy + x_seir, pars_seir = seir_data + + pars_seir["alpha"] = pars_sir["gamma"] # will be done by hand + + def mocked_seir_step(data, **pars): + data["exposed"] = 0 + new_data = SEIRModel.simulation_step(data, **pars) + new_data["infected"] += new_data["exposed_new"] + return new_data + + seir_model = SEIRModel() + monkeypatch.setattr(seir_model, "simulation_step", mocked_seir_step) + + sir_model = SIRModel() + predictions_sir = sir_model.propagate_uncertainties(x_sir, pars_sir) + predictions_seir = seir_model.propagate_uncertainties(x_seir, pars_seir) + + assert_frame_equal( + predictions_sir[COLS_TO_COMPARE], predictions_seir[COLS_TO_COMPARE], + ) diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index 7f69182..7fa76a0 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -8,7 +8,6 @@ from pytest import fixture -from numpy import zeros from pandas import DataFrame, Series, DatetimeIndex from pandas.testing import assert_frame_equal, assert_series_equal From 77ff9b57e356fa691f6005fe328b5438c2b4f75d Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 16:14:51 +0200 Subject: [PATCH 19/40] Added setup.py --- .gitignore | 1 + setup.py | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/.gitignore b/.gitignore index 5e76d76..3cfaa81 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ __pycache__/ .DS_Store output/* !output/ +*.egg-info diff --git a/setup.py b/setup.py index e69de29..629c531 100644 --- a/setup.py +++ b/setup.py @@ -0,0 +1,36 @@ +"""Setup file for bayes_chime +""" +__version__ = "0.1.0" +__author__ = "Predictive Healthcare @ Penn Medicine" + +from setuptools import setup, find_packages + +with open("requirements.txt", "r") as INP: + REQUIREMENTS = INP.read() + +with open("README.md", "r") as INP: + LONE_DESCRIPTION = INP.read() + +setup( + name="bayes_chime", + version=__version__, + author=__author__, + author_email="", + description="Bayesian fit to SEIR model." + " An extension to Penn Medicine's CHIME tool.", + long_description=LONE_DESCRIPTION, + url="https://github.com/pennsignals/chime_sims", + project_urls={ + "Bug Reports": "https://github.com/pennsignals/chime_sims/issues", + "Source": "https://github.com/pennsignals/chime_sims", + }, + packages=["bayes_chime"], + install_requires=REQUIREMENTS, + classifiers=[ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + ], + python_requires=">=3.7", + keywords=[], +) From 2e92b9646ed84f37aa974a38d6b29db5c7a72356 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 16:15:02 +0200 Subject: [PATCH 20/40] Added comparison commit hash --- tests/normal/models/seir_test.py | 2 ++ tests/normal/models/sir_test.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/tests/normal/models/seir_test.py b/tests/normal/models/seir_test.py index 898a4e9..6ecd038 100644 --- a/tests/normal/models/seir_test.py +++ b/tests/normal/models/seir_test.py @@ -22,6 +22,8 @@ # Does not compare census as this repo uses the exponential distribution ] +PENN_CHIME_COMMIT = "188c35be9561164bedded4a8071a320cbde0d2bc" + @fixture(name="seir_data") def fixture_seir_data(sir_data_wo_policy): diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index 7fa76a0..00a904f 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -23,6 +23,8 @@ from bayes_chime.normal.models import SIRModel from bayes_chime.normal.utilities import one_minus_logistic_fcn +PENN_CHIME_COMMIT = "188c35be9561164bedded4a8071a320cbde0d2bc" + COLS_TO_COMPARE = [ "susceptible", "infected", From 57b7f8d1353c6c5249d5d458ffcc4ae6d2aacaea Mon Sep 17 00:00:00 2001 From: ckoerber Date: Thu, 23 Apr 2020 17:44:34 +0200 Subject: [PATCH 21/40] Started to work on presentation --- bayes_chime/normal/fitting.py | 72 +++++++ bayes_chime/normal/plotting.py | 27 +++ ...-to-use-normal-approximations-module.ipynb | 203 ++++++++++++++++++ 3 files changed, 302 insertions(+) create mode 100644 bayes_chime/normal/fitting.py create mode 100644 bayes_chime/normal/plotting.py create mode 100644 notebooks/How-to-use-normal-approximations-module.ipynb diff --git a/bayes_chime/normal/fitting.py b/bayes_chime/normal/fitting.py new file mode 100644 index 0000000..adcd05a --- /dev/null +++ b/bayes_chime/normal/fitting.py @@ -0,0 +1,72 @@ +"""Fitting routines for approximating distributions with normal distributions +""" +from typing import TypeVar, Dict, Any + +from numpy import linspace, sqrt + +from scipy.optimize import curve_fit +from scipy.stats import norm, beta, gamma + +from pandas import DataFrame + +from gvar import gvar + +from bayes_chime.normal.utilities import FloatLikeArray, NormalDistVar, FloatOrDistVar + +Dist = TypeVar("ScipyContinousDistribution") + + +def fit_norm_dist_to_ens(x: FloatLikeArray) -> NormalDistVar: + """Approximates ensemble (random vector) by normal distribution + """ + return gvar(*norm.fit(x)) + + +def fit_norm_dist_to_dist(dist: Dist) -> NormalDistVar: + """Approximates distribution by normal distribution + """ + x = linspace(dist.ppf(0.01), dist.ppf(0.99), 100) + y = dist.pdf(x) + + mu, var = dist.stats(moments="mv") + mu, std = curve_fit(norm.pdf, xdata=x, ydata=y, p0=(mu, sqrt(var)))[0] + + return gvar(mu, std) + + +def parse_dist(data: Dict[str, Any]) -> Dist: + """Parses prior frame data to distribution + """ + distribution = data["distribution"] + if distribution == "beta": + dist = beta(a=data["p1"], b=data["p2"]) + elif distribution == "gamma": + dist = gamma(a=data["p1"], scale=data["p2"]) + elif distribution == "constant": + dist = data["base"] + else: + raise KeyError( + "Distribution {distribution} not implemented.".format( + distribution=distribution + ) + ) + return dist + + +def gv_to_dist(normal: NormalDistVar) -> Dist: + """Converts gvar to scipy dist + """ + return norm(loc=normal.mean, scale=normal.sdev) + + +def fit_norm_to_prior_df(prior_df: DataFrame) -> Dict[str, FloatOrDistVar]: + """Reads in prior data frame (`params.csv`) and returns fitted normal variables. + """ + priors = {} + for _, row in prior_df.iterrows(): + dist = parse_dist(row) + priors[row["param"]] = ( # account for constant dist + dist if isinstance(dist, float) else fit_norm_dist_to_dist(dist) + ) + + return priors diff --git a/bayes_chime/normal/plotting.py b/bayes_chime/normal/plotting.py new file mode 100644 index 0000000..1764a3b --- /dev/null +++ b/bayes_chime/normal/plotting.py @@ -0,0 +1,27 @@ +"""Plotting routines +""" +from numpy import linspace + +from matplotlib.pylab import gca as get_current_actor + + +from bayes_chime.normal.fitting import fit_norm_dist_to_dist, parse_dist, gv_to_dist + + +def plot_prior_fit(**kwargs): + """Parses distribution from meta parameters and plots exact distribution and + normal fit + """ + data = kwargs["data"].iloc[0].to_dict() + dist = parse_dist(data) + + ax = get_current_actor() + + x = linspace(dist.ppf(0.001), dist.ppf(0.999), 100) + y = dist.pdf(x) + ax.fill_between(x, y, alpha=0.5) + + normal = gv_to_dist(fit_norm_dist_to_dist(dist)) + x = linspace(normal.ppf(0.001), normal.ppf(0.999), 100) + y_fit = normal.pdf(x) + ax.plot(x, y_fit, color="black") diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb new file mode 100644 index 0000000..0fbc1f9 --- /dev/null +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to use the normal approximations module" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from os import getcwd, path\n", + "\n", + "from pandas import read_csv, read_json\n", + "\n", + "from bayes_chime.normal.models import SEIRModel\n", + "from bayes_chime.normal.utilities import one_minus_logistic_fcn\n", + "\n", + "import bayes_chime.normal.fitting as ft\n", + "import bayes_chime.normal.plotting as pl\n", + "\n", + "from seaborn import FacetGrid, distplot\n", + "from matplotlib.pylab import show as show_plot\n", + "\n", + "from importlib import reload" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ROOT = path.dirname(getcwd())\n", + "RUN = \"2020_04_22_09_07_17\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "OUTPUT = path.join(ROOT, \"output\", RUN)\n", + "DATA = path.join(ROOT, OUTPUT, \"parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data_df = (\n", + " read_csv(path.join(DATA, \"census_ts.csv\"), parse_dates=[\"date\"])\n", + " .dropna(how=\"all\", axis=1)\n", + " .fillna(0)\n", + " .set_index(\"date\")\n", + " .astype(int)\n", + ")\n", + "data_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prior_df = read_csv(path.join(DATA, f\"params.csv\"))\n", + "priors = ft.fit_norm_to_prior_df(prior_df)\n", + "prior_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "g = FacetGrid(\n", + " prior_df.query(\"distribution != 'constant'\"),\n", + " col=\"param\",\n", + " col_wrap=5,\n", + " sharex=False,\n", + " sharey=False,\n", + ")\n", + "g.map_dataframe(pl.plot_prior_fit)\n", + "show_plot(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The line below may take a while maybe `HDF5` might be a more suiteable format" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "posterior_df = read_json(\n", + " path.join(OUTPUT, \"output\", \"chains.json.bz2\"), orient=\"records\", lines=True\n", + ")\n", + "drop_cols = [\n", + " col\n", + " for col in posterior_df.columns\n", + " if not col in prior_df.param.values and col != \"offset\"\n", + "]\n", + "posterior_df = posterior_df.drop(columns=drop_cols)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "posterior_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "posteriors = {}\n", + "for col in posterior_df.columns:\n", + " if isinstance(priors.get(col, 0), float):\n", + " continue\n", + " posteriors[col] = ft.fit_norm_dist_to_ens(posterior_df[col].values)\n", + "\n", + "posteriors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def fcn(**kwargs):\n", + " distplot(a=kwargs[\"data\"].x.values)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stacked = posterior_df.stack().reset_index().drop(columns=[\"level_0\"]).rename(\n", + " columns={\"level_1\": \"param\", 0: \"x\"}\n", + ")\n", + "g = FacetGrid(\n", + " stacked,\n", + " col=\"param\",\n", + " col_wrap=5,\n", + " sharex=False,\n", + " sharey=False,\n", + ")\n", + "g.map_dataframe(fcn)\n", + "show_plot(g)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "chime", + "language": "python", + "name": "chime" + }, + "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.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From bf4d8b07dbc1a90257b4a81a4dd4de0f3debb5bf Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 11:21:15 +0200 Subject: [PATCH 22/40] Fixed model parameter typos --- bayes_chime/normal/models/seir.py | 2 +- bayes_chime/normal/models/sir.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/bayes_chime/normal/models/seir.py b/bayes_chime/normal/models/seir.py index 5ca0c2a..265c84b 100644 --- a/bayes_chime/normal/models/seir.py +++ b/bayes_chime/normal/models/seir.py @@ -20,7 +20,7 @@ class SEIRModel(SIRModel): "gamma", # or recovery_days "alpha", # or incubation_days ] - optiona_parameters: List[str] = [ + optional_parameters: List[str] = [ "recovery_days", "inital_doubling_time", "incubation_days", diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index 782543b..50ad3d0 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -20,8 +20,9 @@ class SIRModel(CompartmentModel): "inital_recovered", "beta", # or inital_doubling_time "gamma", # or recovery_days + "nu", ] - optiona_parameters: List[str] = [ + optional_parameters: List[str] = [ "recovery_days", "inital_doubling_time", # all keywords below are used to compute hospital admissions and census @@ -63,14 +64,13 @@ def post_process_simulation( # pylint: disable=R0201, W0613, C0103 df = df.fillna(0) # Add hosp census - hosp_keys = set(["initial_hospitalized", "hospitalization_length_of_stay"]) + hosp_keys = set(["initial_hospitalized", "hospital_length_of_stay"]) if hosp_keys.issubset(pars.keys()) and "hospital_admits" in df.columns: census = [pars["initial_hospitalized"]] for admits in df.hospital_admits.values[1:]: census.append( - admits - + (1 - 1 / pars["hospitalization_length_of_stay"]) * census[-1] + admits + (1 - 1 / pars["hospital_length_of_stay"]) * census[-1] ) df["hospital_census"] = census From a1cf08d127f6ff786c547ae23849764c2676818d Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 11:21:29 +0200 Subject: [PATCH 23/40] Cast dates to index if possible --- bayes_chime/normal/models/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 442576b..72145cc 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -47,7 +47,7 @@ def parse_input( # pylint: disable=R0201 """ dates = pars["dates"] if not isinstance(dates, DatetimeIndex): - raise TypeError("Dates must be of type DatetimeIndex") + dates = DatetimeIndex(dates) if not dates.freq: dates.freq = infer_freq(dates) From 642f90c6aa4f27988e9d565d1790d7ab671aa504 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 11:21:46 +0200 Subject: [PATCH 24/40] Fit to ensemble now allows ignoring outliers --- bayes_chime/normal/fitting.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/bayes_chime/normal/fitting.py b/bayes_chime/normal/fitting.py index adcd05a..d279cd4 100644 --- a/bayes_chime/normal/fitting.py +++ b/bayes_chime/normal/fitting.py @@ -1,8 +1,8 @@ """Fitting routines for approximating distributions with normal distributions """ -from typing import TypeVar, Dict, Any +from typing import TypeVar, Dict, Any, Optional -from numpy import linspace, sqrt +from numpy import linspace, sqrt, median, sum from scipy.optimize import curve_fit from scipy.stats import norm, beta, gamma @@ -16,9 +16,19 @@ Dist = TypeVar("ScipyContinousDistribution") -def fit_norm_dist_to_ens(x: FloatLikeArray) -> NormalDistVar: +def fit_norm_dist_to_ens( + x: FloatLikeArray, thresh: Optional[float] = None +) -> NormalDistVar: """Approximates ensemble (random vector) by normal distribution + + if thresh is specified, inferst how much results deviate from median and cuts out + outliers with modified z_score > thresh. """ + if thresh: + d = sqrt((x - median(x)) ** 2) + mod_z_score = 0.6745 * d / median(d) + x = x[mod_z_score < thresh] + return gvar(*norm.fit(x)) From 01aa00550180f73ca63479c152bf90156039c451 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 11:22:02 +0200 Subject: [PATCH 25/40] Additional tools to plot bands --- bayes_chime/normal/plotting.py | 98 ++++++++++++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 3 deletions(-) diff --git a/bayes_chime/normal/plotting.py b/bayes_chime/normal/plotting.py index 1764a3b..e29c15d 100644 --- a/bayes_chime/normal/plotting.py +++ b/bayes_chime/normal/plotting.py @@ -1,11 +1,24 @@ """Plotting routines """ +from typing import TypeVar, Dict, Any + from numpy import linspace from matplotlib.pylab import gca as get_current_actor +from seaborn import distplot + +from gvar import mean as gv_mean +from gvar import sdev as gv_sdev +from bayes_chime.normal.utilities import NormalDistVar +from bayes_chime.normal.fitting import ( + fit_norm_dist_to_dist, + parse_dist, + gv_to_dist, + fit_norm_dist_to_ens, +) -from bayes_chime.normal.fitting import fit_norm_dist_to_dist, parse_dist, gv_to_dist +Axes = TypeVar("Axes") def plot_prior_fit(**kwargs): @@ -21,7 +34,86 @@ def plot_prior_fit(**kwargs): y = dist.pdf(x) ax.fill_between(x, y, alpha=0.5) - normal = gv_to_dist(fit_norm_dist_to_dist(dist)) + plot_gv_dist(fit_norm_dist_to_dist(dist), color="black") + + +def plot_posterior_fit(**kwargs): + """Fits normal distribution to ensemble and plots normal dist as well as hist + """ + ax = get_current_actor() + x = kwargs["data"].x.values + distplot(a=x, kde=False, ax=ax, hist_kws={"density": True}) + plot_gv_dist( + fit_norm_dist_to_ens(x, thresh=kwargs.get("thresh", None)), ax=ax, color="black" + ) + + +def plot_gv_dist(gvar: NormalDistVar, **kwargs): + """Plots pdf of gvar + """ + ax = kwargs.pop("ax", get_current_actor()) + + normal = gv_to_dist(gvar) x = linspace(normal.ppf(0.001), normal.ppf(0.999), 100) y_fit = normal.pdf(x) - ax.plot(x, y_fit, color="black") + ax.plot(x, y_fit, **kwargs) + + return ax + + +def plot_gvar( + line_kws: Dict[str, Any] = None, fill_kws: Dict[str, Any] = None, **kwargs +) -> Axes: + """Plots gvar as a band. + + Arguments: + line_kws: Kwargs specific for line plot + fill_kws: Kwargs specific for fill between + kwargs: Shared kwargs + Requires: x and y + Optional: z_factor to upadte band with (e.g., 0.674 for 0.5 CI) + """ + y = kwargs.pop("y") + x = kwargs.pop("x") + yy_mean = gv_mean(y) + yy_sdev = gv_sdev(y) + + return plot_band( + x=x, + y1=yy_mean - yy_sdev, + ym=yy_mean, + y2=yy_mean + yy_sdev, + line_kws=line_kws, + fill_kws=fill_kws, + **kwargs, + ) + + +def plot_band( + line_kws: Dict[str, Any] = None, fill_kws: Dict[str, Any] = None, **kwargs +) -> Axes: + """Plots gvar as a band. + + Arguments: + line_kws: Kwargs specific for line plot + fill_kws: Kwargs specific for fill between + kwargs: Shared kwargs + Requires: x and y1, ym, y2 + """ + line_kws = line_kws or {} + fill_kws = fill_kws or {} + + y1 = kwargs.pop("y1") + ym = kwargs.pop("ym") + y2 = kwargs.pop("y2") + x = kwargs.pop("x") + + ax = kwargs.pop("ax", get_current_actor()) + + line_kws.update(kwargs) + fill_kws.update(kwargs) + + ax.plot(x, ym, **line_kws) + ax.fill_between(x, y1, y2, **fill_kws) + + return ax From f89c62c1364c75f88b853da5118718d6fba6df59 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 13:04:32 +0200 Subject: [PATCH 26/40] Module reproduces error propagation --- ...-to-use-normal-approximations-module.ipynb | 878 +++++++++++++++++- 1 file changed, 835 insertions(+), 43 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index 0fbc1f9..940e412 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -9,13 +9,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from os import getcwd, path\n", "\n", - "from pandas import read_csv, read_json\n", + "from datetime import timedelta\n", + "\n", + "from pandas import read_csv, read_json, DataFrame, Series\n", + "\n", + "from gvar import gvar\n", + "from gvar import mean as gv_mean\n", + "from gvar import sdev as gv_sdev\n", + "\n", + "from lsqfit import nonlinear_fit\n", "\n", "from bayes_chime.normal.models import SEIRModel\n", "from bayes_chime.normal.utilities import one_minus_logistic_fcn\n", @@ -23,7 +31,7 @@ "import bayes_chime.normal.fitting as ft\n", "import bayes_chime.normal.plotting as pl\n", "\n", - "from seaborn import FacetGrid, distplot\n", + "from seaborn import FacetGrid, distplot, despine\n", "from matplotlib.pylab import show as show_plot\n", "\n", "from importlib import reload" @@ -31,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -41,19 +49,108 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "OUTPUT = path.join(ROOT, \"output\", RUN)\n", - "DATA = path.join(ROOT, OUTPUT, \"parameters\")" + "DATA = path.join(OUTPUT, \"parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read in data" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hospventmort
date
2020-03-06100
2020-03-07100
2020-03-08100
2020-03-09200
2020-03-10200
\n", + "
" + ], + "text/plain": [ + " hosp vent mort\n", + "date \n", + "2020-03-06 1 0 0\n", + "2020-03-07 1 0 0\n", + "2020-03-08 1 0 0\n", + "2020-03-09 2 0 0\n", + "2020-03-10 2 0 0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "data_df = (\n", " read_csv(path.join(DATA, \"census_ts.csv\"), parse_dates=[\"date\"])\n", @@ -65,22 +162,255 @@ "data_df.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit priors" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
parambasedistributionp1p2description
0n_hosp1.000constantNaNNaNNumber of hospitalized COVID-19 patients on day 1
1hosp_prop0.025gamma6.3268330.004169Prportion of infections requiring hospitalization
2ICU_prop0.450beta52.05931196.867420Proportion of hospitalizations admitted to ICU
3vent_prop0.660beta5.2240293.078885Proportion of ICU patients requiring ventilation
4hosp_LOS12.000gamma195.4976400.059681Hospital Length of Stay
\n", + "
" + ], + "text/plain": [ + " param base distribution p1 p2 \\\n", + "0 n_hosp 1.000 constant NaN NaN \n", + "1 hosp_prop 0.025 gamma 6.326833 0.004169 \n", + "2 ICU_prop 0.450 beta 52.059311 96.867420 \n", + "3 vent_prop 0.660 beta 5.224029 3.078885 \n", + "4 hosp_LOS 12.000 gamma 195.497640 0.059681 \n", + "\n", + " description \n", + "0 Number of hospitalized COVID-19 patients on day 1 \n", + "1 Prportion of infections requiring hospitalization \n", + "2 Proportion of hospitalizations admitted to ICU \n", + "3 Proportion of ICU patients requiring ventilation \n", + "4 Hospital Length of Stay " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "prior_df = read_csv(path.join(DATA, f\"params.csv\"))\n", - "priors = ft.fit_norm_to_prior_df(prior_df)\n", - "prior_df" + "prior_df.head()" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 6, + "metadata": { + "scrolled": false + }, "outputs": [], + "source": [ + "priors = ft.fit_norm_to_prior_df(prior_df.query(\"distribution != 'constant'\"))\n", + "meta_pars = ft.fit_norm_to_prior_df(prior_df.query(\"distribution == 'constant'\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
val
hosp_prop0.024(10)
ICU_prop0.349(39)
vent_prop0.65(17)
hosp_LOS11.64(83)
ICU_LOS13.47(89)
vent_LOS19.5(2.3)
incubation_days4.6(1.5)
recovery_days15.3(5.0)
logistic_k0.78(43)
logistic_x016.7(6.9)
logistic_L0.37(23)
nu2.46(25)
beta0.32(12)
\n", + "
" + ], + "text/plain": [ + " val\n", + "hosp_prop 0.024(10)\n", + "ICU_prop 0.349(39)\n", + "vent_prop 0.65(17)\n", + "hosp_LOS 11.64(83)\n", + "ICU_LOS 13.47(89)\n", + "vent_LOS 19.5(2.3)\n", + "incubation_days 4.6(1.5)\n", + "recovery_days 15.3(5.0)\n", + "logistic_k 0.78(43)\n", + "logistic_x0 16.7(6.9)\n", + "logistic_L 0.37(23)\n", + "nu 2.46(25)\n", + "beta 0.32(12)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "g = FacetGrid(\n", " prior_df.query(\"distribution != 'constant'\"),\n", @@ -90,19 +420,27 @@ " sharey=False,\n", ")\n", "g.map_dataframe(pl.plot_prior_fit)\n", - "show_plot(g)" + "show_plot(g)\n", + "DataFrame(data=priors, index=[\"val\"]).T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The line below may take a while maybe `HDF5` might be a more suiteable format" + "## Fit posteriors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The line below which reads in json may take a while. Maybe exporting to `HDF5` might be faster." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -110,65 +448,519 @@ " path.join(OUTPUT, \"output\", \"chains.json.bz2\"), orient=\"records\", lines=True\n", ")\n", "drop_cols = [\n", - " col\n", - " for col in posterior_df.columns\n", - " if not col in prior_df.param.values and col != \"offset\"\n", + " col for col in posterior_df.columns if col not in priors and col != \"offset\"\n", "]\n", "posterior_df = posterior_df.drop(columns=drop_cols)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The line below may take a while maybe `HDF5` might be a more suiteable format" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hosp_propICU_propvent_prophosp_LOSICU_LOSvent_LOSincubation_daysrecovery_dayslogistic_klogistic_x0logistic_Lnubetaoffset
00.0320080.3529110.66993411.63027813.77975719.2346054.37850220.1403040.86593519.6121350.7208802.1273640.1655254
10.0312390.3498330.67832011.54475513.76887618.9501894.45408120.1256950.90688719.3667680.6971132.1508720.1866184
20.0312390.3498330.67832011.54475513.76887618.9501894.45408120.1256950.90688719.3667680.6971132.1508720.1866184
30.0292040.3466540.67457011.52460313.68285518.8696494.52658819.9842210.89672218.7748970.6969342.1482270.1758104
40.0292040.3466540.67457011.52460313.68285518.8696494.52658819.9842210.89672218.7748970.6969342.1482270.1758104
\n", + "
" + ], + "text/plain": [ + " hosp_prop ICU_prop vent_prop hosp_LOS ICU_LOS vent_LOS \\\n", + "0 0.032008 0.352911 0.669934 11.630278 13.779757 19.234605 \n", + "1 0.031239 0.349833 0.678320 11.544755 13.768876 18.950189 \n", + "2 0.031239 0.349833 0.678320 11.544755 13.768876 18.950189 \n", + "3 0.029204 0.346654 0.674570 11.524603 13.682855 18.869649 \n", + "4 0.029204 0.346654 0.674570 11.524603 13.682855 18.869649 \n", + "\n", + " incubation_days recovery_days logistic_k logistic_x0 logistic_L \\\n", + "0 4.378502 20.140304 0.865935 19.612135 0.720880 \n", + "1 4.454081 20.125695 0.906887 19.366768 0.697113 \n", + "2 4.454081 20.125695 0.906887 19.366768 0.697113 \n", + "3 4.526588 19.984221 0.896722 18.774897 0.696934 \n", + "4 4.526588 19.984221 0.896722 18.774897 0.696934 \n", + "\n", + " nu beta offset \n", + "0 2.127364 0.165525 4 \n", + "1 2.150872 0.186618 4 \n", + "2 2.150872 0.186618 4 \n", + "3 2.148227 0.175810 4 \n", + "4 2.148227 0.175810 4 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "posterior_df.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
val
hosp_prop0.0238(25)
ICU_prop0.367(11)
vent_prop0.760(30)
hosp_LOS11.55(25)
ICU_LOS13.45(27)
vent_LOS19.64(58)
incubation_days3.24(28)
recovery_days16.5(1.6)
logistic_k0.95(12)
logistic_x025.42(37)
logistic_L0.788(17)
nu2.440(72)
beta0.469(24)
\n", + "
" + ], + "text/plain": [ + " val\n", + "hosp_prop 0.0238(25)\n", + "ICU_prop 0.367(11)\n", + "vent_prop 0.760(30)\n", + "hosp_LOS 11.55(25)\n", + "ICU_LOS 13.45(27)\n", + "vent_LOS 19.64(58)\n", + "incubation_days 3.24(28)\n", + "recovery_days 16.5(1.6)\n", + "logistic_k 0.95(12)\n", + "logistic_x0 25.42(37)\n", + "logistic_L 0.788(17)\n", + "nu 2.440(72)\n", + "beta 0.469(24)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "thresh = 3.5 # Threshold for identifiying outliers\n", + "posteriors = {\n", + " col: ft.fit_norm_dist_to_ens(posterior_df[col].values, thresh=thresh)\n", + " for col in priors\n", + "}\n", + "\n", + "stacked = (\n", + " posterior_df.T.loc[priors.keys()]\n", + " .T.stack()\n", + " .reset_index()\n", + " .drop(columns=[\"level_0\"])\n", + " .rename(columns={\"level_1\": \"param\", 0: \"x\"})\n", + ")\n", + "g = FacetGrid(stacked, col=\"param\", col_wrap=5, sharex=False, sharey=False,)\n", + "g.map_dataframe(pl.plot_posterior_fit, thresh=thresh)\n", + "show_plot(g)\n", + "DataFrame(data=posteriors, index=[\"val\"]).T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Propagate normal posteriors to SEIR and compare to original prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "forecast_df = read_csv(\n", + " path.join(OUTPUT, \"output\", \"forecast.csv\"), parse_dates=[\"date\"]\n", + ").set_index(\"date\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['dates', 'initial_susceptible', 'initial_exposed', 'initial_infected', 'inital_recovered', 'beta', 'gamma', 'alpha']\n", + "['recovery_days', 'inital_doubling_time', 'incubation_days', 'initial_hospitalized', 'market_share', 'hospitalization_probability', 'hospital_length_of_stay']\n" + ] + } + ], + "source": [ + "seir = SEIRModel()\n", + "print(seir.model_parameters)\n", + "print(seir.optional_parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "posteriors = {}\n", - "for col in posterior_df.columns:\n", - " if isinstance(priors.get(col, 0), float):\n", - " continue\n", - " posteriors[col] = ft.fit_norm_dist_to_ens(posterior_df[col].values)\n", + "total_infections = (\n", + " meta_pars[\"n_hosp\"] / meta_pars[\"mkt_share\"] / posteriors[\"hosp_prop\"]\n", + ")\n", "\n", - "posteriors" + "## Fixed paramters (no distributions)\n", + "xx = {\n", + " \"dates\": forecast_df.index,\n", + " \"market_share\": meta_pars[\"mkt_share\"],\n", + " \"initial_susceptible\": meta_pars[\"region_pop\"],\n", + " \"initial_infected\": 0,\n", + " \"initial_exposed\": total_infections,\n", + " \"initial_recovered\": 0,\n", + " \"initial_hospitalized\": meta_pars[\"n_hosp\"] / meta_pars[\"mkt_share\"],\n", + "}\n", + "## Variable parameters (distributions)\n", + "pp = {\n", + " \"incubation_days\": posteriors[\"incubation_days\"],\n", + " \"beta\": posteriors[\"beta\"],\n", + " \"recovery_days\": posteriors[\"recovery_days\"],\n", + " \"nu\": posteriors[\"nu\"],\n", + " \"hospitalization_probability\": posteriors[\"hosp_prop\"],\n", + " \"hospital_length_of_stay\": posteriors[\"hosp_LOS\"],\n", + "}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "def fcn(**kwargs):\n", - " distplot(a=kwargs[\"data\"].x.values)" + "def update_parameters(ddate, **kwargs):\n", + " xx = (ddate - kwargs[\"dates\"][0]).days\n", + " ppars = kwargs.copy()\n", + " ppars[\"beta\"] = kwargs[\"beta\"] * one_minus_logistic_fcn(\n", + " xx, L=kwargs[\"L\"], k=kwargs[\"k\"], x0=kwargs[\"x0\"],\n", + " )\n", + " return ppars\n", + "\n", + "\n", + "OFFSET = posterior_df.offset.mean()\n", + "\n", + "pp[\"L\"] = posteriors[\"logistic_L\"]\n", + "pp[\"x0\"] = posteriors[\"logistic_x0\"] + OFFSET\n", + "pp[\"k\"] = posteriors[\"logistic_k\"]\n", + "\n", + "seir.update_parameters = update_parameters" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 ms ± 3.64 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "seir.propagate_uncertainties(xx, pp)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "stacked = posterior_df.stack().reset_index().drop(columns=[\"level_0\"]).rename(\n", - " columns={\"level_1\": \"param\", 0: \"x\"}\n", + "normal_forecast_df = seir.propagate_uncertainties(xx, pp)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(ncols=1, nrows=2, figsize=(6, 9))\n", + "\n", + "gv_kws = dict(color=\"black\", zorder=10, lw=3)\n", + "gv_line_kws = {\"ls\": \"--\", \"label\": \"Normal posteriors\"}\n", + "gv_fill_kws = {\"alpha\": 0.2}\n", + "\n", + "fill_kws = {\"alpha\": 0.3, \"edgecolor\": \"k\", \"lw\": 2}\n", + "line_kws = {\"ls\": \"-\", \"label\": \"General posteriors\", \"lw\": 2}\n", + "\n", + "xx = forecast_df.index - timedelta(days=OFFSET)\n", + "\n", + "# Census\n", + "ax = axs[0]\n", + "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", + "pl.plot_band(\n", + " x=forecast_df.index,\n", + " y1=forecast_df[\"Hospitalized Census 25%\"],\n", + " ym=forecast_df[\"Hospitalized Census Median\"],\n", + " y2=forecast_df[\"Hospitalized Census 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", ")\n", - "g = FacetGrid(\n", - " stacked,\n", - " col=\"param\",\n", - " col_wrap=5,\n", - " sharex=False,\n", - " sharey=False,\n", + "\n", + "yy = normal_forecast_df[\"hospital_census\"].values\n", + "pl.plot_gvar(x=xx, y=yy, ax=ax, **gv_kws, line_kws=gv_line_kws, fill_kws=gv_fill_kws)\n", + "ax.grid(True)\n", + "ax.legend(bbox_to_anchor=(1.0, 1.0))\n", + "\n", + "# Admits\n", + "ax = axs[1]\n", + "ax.set_ylabel(f\"COVID-19 Hospital Admits\", fontsize=12, fontweight=\"bold\")\n", + "pl.plot_band(\n", + " x=forecast_df.index,\n", + " y1=forecast_df[\"Hospitalized Admits 25%\"],\n", + " ym=forecast_df[\"Hospitalized Admits Median\"],\n", + " y2=forecast_df[\"Hospitalized Admits 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", ")\n", - "g.map_dataframe(fcn)\n", - "show_plot(g)" + "\n", + "yy = normal_forecast_df[\"hospital_admits\"].values\n", + "pl.plot_gvar(x=xx, y=yy, ax=ax, **gv_kws, line_kws=gv_line_kws, fill_kws=gv_fill_kws)\n", + "ax.grid(True)\n", + "\n", + "ax.grid(True)\n", + "\n", + "fig.suptitle(\n", + " \"General vs normal posteriors @ 50% C.I.\", y=1.02, fontsize=12, fontweight=\"bold\"\n", + ")\n", + "\n", + "despine()\n", + "\n", + "fig.autofmt_xdate()\n", + "fig.tight_layout()" ] }, { From c01573f7e87dfe46e0e55d4eb2f61b3fbab6b0e3 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 13:04:43 +0200 Subject: [PATCH 27/40] Debbugged fitting --- bayes_chime/normal/models/base.py | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/bayes_chime/normal/models/base.py b/bayes_chime/normal/models/base.py index 72145cc..7d9004c 100644 --- a/bayes_chime/normal/models/base.py +++ b/bayes_chime/normal/models/base.py @@ -91,6 +91,8 @@ def __init__( update_parameters: Callable[ [Date, Dict[str, FloatOrDistVar]], Dict[str, FloatOrDistVar] ] = None, + fit_start_date: Optional[Date] = None, + debug: bool = False, ): """Initializes the compartment model update function @@ -104,6 +106,9 @@ def __init__( and all model (initial) parameters as input. It should return updated parameters and defaults to no parameter updates. This can be used to implement social distancing. + fit_start_date: When calling fit_fcn, this will only return results after + this date. This should be used if only a subset of the dates are fitted. + debug: Print additional messages Note: If the update_parameters method requires additional arguments, they must be @@ -115,6 +120,8 @@ def __init__( if update_parameters is not None else lambda date, **pars: pars ) + self.fit_start_date = fit_start_date + self.debug = debug def propagate_uncertainties( self, meta_pars: Dict[str, FloatLike], dist_pars: Dict[str, NormalDistVar] @@ -167,10 +174,21 @@ def fit_fcn( # pylint: disable=C0103 Returns: Array of `fit_columns` columns without first row (inital data). """ - df = self.propagate_uncertainties(xx, pp).drop(0) + if self.debug: + print("fit_fcn call with") + print("xx:\n", xx) + print("pp:\n", pp) + + df = self.propagate_uncertainties(xx, pp) + if self.fit_start_date: + df = df.loc[self.fit_start_date :] + if self.fit_columns: df = df[self.fit_columns] + if self.debug: + print("result:\n", df) + return df.values if df.values.shape[0] > 1 else df.values.flatten() def check_call( # pylint: disable=C0103 @@ -189,7 +207,7 @@ def check_call( # pylint: disable=C0103 Raises: Specific error messages if not set up correctly """ - common_pars = xx.keys().intersection(pp.keys()) + common_pars = set(xx.keys()).intersection(pp.keys()) if common_pars: raise KeyError( "Fixed and variable model paramers have shared variables:" @@ -218,3 +236,5 @@ def check_call( # pylint: disable=C0103 y_data=y_data, ) ) + + print("Checks passed") From 97e353779ef0cdb67d9e9d3f50cba8f653795ba8 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 13:05:00 +0200 Subject: [PATCH 28/40] Added z-factor back in for plotting gvars --- bayes_chime/normal/plotting.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/bayes_chime/normal/plotting.py b/bayes_chime/normal/plotting.py index e29c15d..425c671 100644 --- a/bayes_chime/normal/plotting.py +++ b/bayes_chime/normal/plotting.py @@ -78,6 +78,9 @@ def plot_gvar( yy_mean = gv_mean(y) yy_sdev = gv_sdev(y) + z_factor = kwargs.pop("z_factor", 1) + yy_sdev *= z_factor + return plot_band( x=x, y1=yy_mean - yy_sdev, From a4c854fe575adb08f99d285ef15add3dbeddf8cf Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 13:37:35 +0200 Subject: [PATCH 29/40] Copy dicts for plotting to not overwrite future styling options --- bayes_chime/normal/plotting.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bayes_chime/normal/plotting.py b/bayes_chime/normal/plotting.py index 425c671..3ae2d5b 100644 --- a/bayes_chime/normal/plotting.py +++ b/bayes_chime/normal/plotting.py @@ -103,8 +103,8 @@ def plot_band( kwargs: Shared kwargs Requires: x and y1, ym, y2 """ - line_kws = line_kws or {} - fill_kws = fill_kws or {} + line_kws = line_kws.copy() or {} + fill_kws = fill_kws.copy() or {} y1 = kwargs.pop("y1") ym = kwargs.pop("ym") From 9e61a2152a8b644a05750a5af085a7741efdc6b0 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 13:49:12 +0200 Subject: [PATCH 30/40] Finalized analysis --- ...-to-use-normal-approximations-module.ipynb | 1071 ++++++----------- 1 file changed, 367 insertions(+), 704 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index 940e412..8323923 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ "\n", "from datetime import timedelta\n", "\n", - "from pandas import read_csv, read_json, DataFrame, Series\n", + "from pandas import read_csv, read_json, DataFrame, Series, date_range, concat\n", "\n", "from gvar import gvar\n", "from gvar import mean as gv_mean\n", @@ -25,21 +25,25 @@ "\n", "from lsqfit import nonlinear_fit\n", "\n", - "from bayes_chime.normal.models import SEIRModel\n", - "from bayes_chime.normal.utilities import one_minus_logistic_fcn\n", - "\n", - "import bayes_chime.normal.fitting as ft\n", - "import bayes_chime.normal.plotting as pl\n", - "\n", "from seaborn import FacetGrid, distplot, despine\n", "from matplotlib.pylab import show as show_plot\n", + "from matplotlib.pylab import subplots\n", "\n", - "from importlib import reload" + "from bayes_chime.normal.models import SEIRModel\n", + "from bayes_chime.normal import models as m\n", + "from bayes_chime.normal.utilities import one_minus_logistic_fcn\n", + "from bayes_chime.normal.fitting import fit_norm_to_prior_df, fit_norm_dist_to_ens\n", + "from bayes_chime.normal.plotting import (\n", + " plot_prior_fit,\n", + " plot_band,\n", + " plot_gvar,\n", + " plot_posterior_fit,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -66,100 +70,18 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
hospventmort
date
2020-03-06100
2020-03-07100
2020-03-08100
2020-03-09200
2020-03-10200
\n", - "
" - ], - "text/plain": [ - " hosp vent mort\n", - "date \n", - "2020-03-06 1 0 0\n", - "2020-03-07 1 0 0\n", - "2020-03-08 1 0 0\n", - "2020-03-09 2 0 0\n", - "2020-03-10 2 0 0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data_df = (\n", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "DATA_DF = (\n", " read_csv(path.join(DATA, \"census_ts.csv\"), parse_dates=[\"date\"])\n", " .dropna(how=\"all\", axis=1)\n", " .fillna(0)\n", " .set_index(\"date\")\n", " .astype(int)\n", ")\n", - "data_df.head()" + "DATA_DF.head()" ] }, { @@ -171,257 +93,42 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
parambasedistributionp1p2description
0n_hosp1.000constantNaNNaNNumber of hospitalized COVID-19 patients on day 1
1hosp_prop0.025gamma6.3268330.004169Prportion of infections requiring hospitalization
2ICU_prop0.450beta52.05931196.867420Proportion of hospitalizations admitted to ICU
3vent_prop0.660beta5.2240293.078885Proportion of ICU patients requiring ventilation
4hosp_LOS12.000gamma195.4976400.059681Hospital Length of Stay
\n", - "
" - ], - "text/plain": [ - " param base distribution p1 p2 \\\n", - "0 n_hosp 1.000 constant NaN NaN \n", - "1 hosp_prop 0.025 gamma 6.326833 0.004169 \n", - "2 ICU_prop 0.450 beta 52.059311 96.867420 \n", - "3 vent_prop 0.660 beta 5.224029 3.078885 \n", - "4 hosp_LOS 12.000 gamma 195.497640 0.059681 \n", - "\n", - " description \n", - "0 Number of hospitalized COVID-19 patients on day 1 \n", - "1 Prportion of infections requiring hospitalization \n", - "2 Proportion of hospitalizations admitted to ICU \n", - "3 Proportion of ICU patients requiring ventilation \n", - "4 Hospital Length of Stay " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "prior_df = read_csv(path.join(DATA, f\"params.csv\"))\n", - "prior_df.head()" + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PRIOR_DF = read_csv(path.join(DATA, f\"params.csv\"))\n", + "PRIOR_DF.head()" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ - "priors = ft.fit_norm_to_prior_df(prior_df.query(\"distribution != 'constant'\"))\n", - "meta_pars = ft.fit_norm_to_prior_df(prior_df.query(\"distribution == 'constant'\"))" + "PRIORS = fit_norm_to_prior_df(PRIOR_DF.query(\"distribution != 'constant'\"))\n", + "META_PARS = fit_norm_to_prior_df(PRIOR_DF.query(\"distribution == 'constant'\"))" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
val
hosp_prop0.024(10)
ICU_prop0.349(39)
vent_prop0.65(17)
hosp_LOS11.64(83)
ICU_LOS13.47(89)
vent_LOS19.5(2.3)
incubation_days4.6(1.5)
recovery_days15.3(5.0)
logistic_k0.78(43)
logistic_x016.7(6.9)
logistic_L0.37(23)
nu2.46(25)
beta0.32(12)
\n", - "
" - ], - "text/plain": [ - " val\n", - "hosp_prop 0.024(10)\n", - "ICU_prop 0.349(39)\n", - "vent_prop 0.65(17)\n", - "hosp_LOS 11.64(83)\n", - "ICU_LOS 13.47(89)\n", - "vent_LOS 19.5(2.3)\n", - "incubation_days 4.6(1.5)\n", - "recovery_days 15.3(5.0)\n", - "logistic_k 0.78(43)\n", - "logistic_x0 16.7(6.9)\n", - "logistic_L 0.37(23)\n", - "nu 2.46(25)\n", - "beta 0.32(12)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "g = FacetGrid(\n", - " prior_df.query(\"distribution != 'constant'\"),\n", + " PRIOR_DF.query(\"distribution != 'constant'\"),\n", " col=\"param\",\n", " col_wrap=5,\n", " sharex=False,\n", " sharey=False,\n", ")\n", - "g.map_dataframe(pl.plot_prior_fit)\n", + "g.map_dataframe(plot_prior_fit)\n", "show_plot(g)\n", - "DataFrame(data=priors, index=[\"val\"]).T" + "DataFrame(data=PRIORS, index=[\"val\"]).T" ] }, { @@ -440,17 +147,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "posterior_df = read_json(\n", + "POSTERIOR_DF = read_json(\n", " path.join(OUTPUT, \"output\", \"chains.json.bz2\"), orient=\"records\", lines=True\n", ")\n", "drop_cols = [\n", - " col for col in posterior_df.columns if col not in priors and col != \"offset\"\n", + " col for col in POSTERIOR_DF.columns if col not in PRIORS and col != \"offset\"\n", "]\n", - "posterior_df = posterior_df.drop(columns=drop_cols)" + "POSTERIOR_DF = POSTERIOR_DF.drop(columns=drop_cols)" ] }, { @@ -462,306 +169,35 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
hosp_propICU_propvent_prophosp_LOSICU_LOSvent_LOSincubation_daysrecovery_dayslogistic_klogistic_x0logistic_Lnubetaoffset
00.0320080.3529110.66993411.63027813.77975719.2346054.37850220.1403040.86593519.6121350.7208802.1273640.1655254
10.0312390.3498330.67832011.54475513.76887618.9501894.45408120.1256950.90688719.3667680.6971132.1508720.1866184
20.0312390.3498330.67832011.54475513.76887618.9501894.45408120.1256950.90688719.3667680.6971132.1508720.1866184
30.0292040.3466540.67457011.52460313.68285518.8696494.52658819.9842210.89672218.7748970.6969342.1482270.1758104
40.0292040.3466540.67457011.52460313.68285518.8696494.52658819.9842210.89672218.7748970.6969342.1482270.1758104
\n", - "
" - ], - "text/plain": [ - " hosp_prop ICU_prop vent_prop hosp_LOS ICU_LOS vent_LOS \\\n", - "0 0.032008 0.352911 0.669934 11.630278 13.779757 19.234605 \n", - "1 0.031239 0.349833 0.678320 11.544755 13.768876 18.950189 \n", - "2 0.031239 0.349833 0.678320 11.544755 13.768876 18.950189 \n", - "3 0.029204 0.346654 0.674570 11.524603 13.682855 18.869649 \n", - "4 0.029204 0.346654 0.674570 11.524603 13.682855 18.869649 \n", - "\n", - " incubation_days recovery_days logistic_k logistic_x0 logistic_L \\\n", - "0 4.378502 20.140304 0.865935 19.612135 0.720880 \n", - "1 4.454081 20.125695 0.906887 19.366768 0.697113 \n", - "2 4.454081 20.125695 0.906887 19.366768 0.697113 \n", - "3 4.526588 19.984221 0.896722 18.774897 0.696934 \n", - "4 4.526588 19.984221 0.896722 18.774897 0.696934 \n", - "\n", - " nu beta offset \n", - "0 2.127364 0.165525 4 \n", - "1 2.150872 0.186618 4 \n", - "2 2.150872 0.186618 4 \n", - "3 2.148227 0.175810 4 \n", - "4 2.148227 0.175810 4 " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "posterior_df.head()" + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "POSTERIOR_DF.head()" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
val
hosp_prop0.0238(25)
ICU_prop0.367(11)
vent_prop0.760(30)
hosp_LOS11.55(25)
ICU_LOS13.45(27)
vent_LOS19.64(58)
incubation_days3.24(28)
recovery_days16.5(1.6)
logistic_k0.95(12)
logistic_x025.42(37)
logistic_L0.788(17)
nu2.440(72)
beta0.469(24)
\n", - "
" - ], - "text/plain": [ - " val\n", - "hosp_prop 0.0238(25)\n", - "ICU_prop 0.367(11)\n", - "vent_prop 0.760(30)\n", - "hosp_LOS 11.55(25)\n", - "ICU_LOS 13.45(27)\n", - "vent_LOS 19.64(58)\n", - "incubation_days 3.24(28)\n", - "recovery_days 16.5(1.6)\n", - "logistic_k 0.95(12)\n", - "logistic_x0 25.42(37)\n", - "logistic_L 0.788(17)\n", - "nu 2.440(72)\n", - "beta 0.469(24)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "thresh = 3.5 # Threshold for identifiying outliers\n", - "posteriors = {\n", - " col: ft.fit_norm_dist_to_ens(posterior_df[col].values, thresh=thresh)\n", - " for col in priors\n", + "POSTERIORS = {\n", + " col: fit_norm_dist_to_ens(POSTERIOR_DF[col].values, thresh=thresh) for col in PRIORS\n", "}\n", "\n", "stacked = (\n", - " posterior_df.T.loc[priors.keys()]\n", + " POSTERIOR_DF.T.loc[PRIORS.keys()]\n", " .T.stack()\n", " .reset_index()\n", " .drop(columns=[\"level_0\"])\n", " .rename(columns={\"level_1\": \"param\", 0: \"x\"})\n", ")\n", "g = FacetGrid(stacked, col=\"param\", col_wrap=5, sharex=False, sharey=False,)\n", - "g.map_dataframe(pl.plot_posterior_fit, thresh=thresh)\n", + "g.map_dataframe(plot_posterior_fit, thresh=thresh)\n", "show_plot(g)\n", - "DataFrame(data=posteriors, index=[\"val\"]).T" + "DataFrame(data=POSTERIORS, index=[\"val\"]).T" ] }, { @@ -773,29 +209,20 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "forecast_df = read_csv(\n", + "FORECAST_DF = read_csv(\n", " path.join(OUTPUT, \"output\", \"forecast.csv\"), parse_dates=[\"date\"]\n", ").set_index(\"date\")" ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['dates', 'initial_susceptible', 'initial_exposed', 'initial_infected', 'inital_recovered', 'beta', 'gamma', 'alpha']\n", - "['recovery_days', 'inital_doubling_time', 'incubation_days', 'initial_hospitalized', 'market_share', 'hospitalization_probability', 'hospital_length_of_stay']\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "seir = SEIRModel()\n", "print(seir.model_parameters)\n", @@ -804,38 +231,38 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "total_infections = (\n", - " meta_pars[\"n_hosp\"] / meta_pars[\"mkt_share\"] / posteriors[\"hosp_prop\"]\n", + " META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"] / POSTERIORS[\"hosp_prop\"]\n", ")\n", "\n", "## Fixed paramters (no distributions)\n", - "xx = {\n", - " \"dates\": forecast_df.index,\n", - " \"market_share\": meta_pars[\"mkt_share\"],\n", - " \"initial_susceptible\": meta_pars[\"region_pop\"],\n", + "XX = {\n", + " \"dates\": FORECAST_DF.index,\n", + " \"market_share\": META_PARS[\"mkt_share\"],\n", + " \"initial_susceptible\": META_PARS[\"region_pop\"],\n", " \"initial_infected\": 0,\n", - " \"initial_exposed\": total_infections,\n", " \"initial_recovered\": 0,\n", - " \"initial_hospitalized\": meta_pars[\"n_hosp\"] / meta_pars[\"mkt_share\"],\n", + " \"initial_hospitalized\": META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"],\n", "}\n", "## Variable parameters (distributions)\n", - "pp = {\n", - " \"incubation_days\": posteriors[\"incubation_days\"],\n", - " \"beta\": posteriors[\"beta\"],\n", - " \"recovery_days\": posteriors[\"recovery_days\"],\n", - " \"nu\": posteriors[\"nu\"],\n", - " \"hospitalization_probability\": posteriors[\"hosp_prop\"],\n", - " \"hospital_length_of_stay\": posteriors[\"hosp_LOS\"],\n", + "PP = {\n", + " \"initial_exposed\": total_infections,\n", + " \"incubation_days\": POSTERIORS[\"incubation_days\"],\n", + " \"beta\": POSTERIORS[\"beta\"],\n", + " \"recovery_days\": POSTERIORS[\"recovery_days\"],\n", + " \"nu\": POSTERIORS[\"nu\"],\n", + " \"hospitalization_probability\": POSTERIORS[\"hosp_prop\"],\n", + " \"hospital_length_of_stay\": POSTERIORS[\"hosp_LOS\"],\n", "}" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -848,119 +275,355 @@ " return ppars\n", "\n", "\n", - "OFFSET = posterior_df.offset.mean()\n", + "OFFSET = POSTERIOR_DF.offset.mean()\n", "\n", - "pp[\"L\"] = posteriors[\"logistic_L\"]\n", - "pp[\"x0\"] = posteriors[\"logistic_x0\"] + OFFSET\n", - "pp[\"k\"] = posteriors[\"logistic_k\"]\n", + "PP[\"L\"] = POSTERIORS[\"logistic_L\"]\n", + "PP[\"x0\"] = POSTERIORS[\"logistic_x0\"] + OFFSET\n", + "PP[\"k\"] = POSTERIORS[\"logistic_k\"]\n", "\n", "seir.update_parameters = update_parameters" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20 ms ± 3.64 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "%%timeit\n", - "seir.propagate_uncertainties(xx, pp)" + "seir.propagate_uncertainties(XX, PP)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "normal_forecast_df = seir.propagate_uncertainties(xx, pp)" + "FORCAST_DF_NORMAL = seir.propagate_uncertainties(XX, PP)" ] }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots(ncols=1, nrows=2, figsize=(6, 9))\n", - "\n", - "gv_kws = dict(color=\"black\", zorder=10, lw=3)\n", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = subplots(ncols=1, nrows=2, figsize=(6, 9))\n", + "\n", + "gv_kws = dict(color=\"black\", zorder=10, lw=3, z_factor=0.674)\n", "gv_line_kws = {\"ls\": \"--\", \"label\": \"Normal posteriors\"}\n", "gv_fill_kws = {\"alpha\": 0.2}\n", "\n", "fill_kws = {\"alpha\": 0.3, \"edgecolor\": \"k\", \"lw\": 2}\n", "line_kws = {\"ls\": \"-\", \"label\": \"General posteriors\", \"lw\": 2}\n", "\n", - "xx = forecast_df.index - timedelta(days=OFFSET)\n", + "t_range_shifted = FORECAST_DF.index - timedelta(days=OFFSET)\n", "\n", "# Census\n", "ax = axs[0]\n", "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", - "pl.plot_band(\n", - " x=forecast_df.index,\n", - " y1=forecast_df[\"Hospitalized Census 25%\"],\n", - " ym=forecast_df[\"Hospitalized Census Median\"],\n", - " y2=forecast_df[\"Hospitalized Census 75%\"],\n", + "ax.grid(True)\n", + "\n", + "## General posteriors\n", + "plot_band(\n", + " x=FORECAST_DF.index,\n", + " y1=FORECAST_DF[\"Hospitalized Census 25%\"],\n", + " ym=FORECAST_DF[\"Hospitalized Census Median\"],\n", + " y2=FORECAST_DF[\"Hospitalized Census 75%\"],\n", " fill_kws=fill_kws,\n", " line_kws=line_kws,\n", " ax=ax,\n", " zorder=20,\n", ")\n", + "## Normal posteriors\n", + "plot_gvar(\n", + " x=t_range_shifted,\n", + " y=FORCAST_DF_NORMAL[\"hospital_census\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", "\n", - "yy = normal_forecast_df[\"hospital_census\"].values\n", - "pl.plot_gvar(x=xx, y=yy, ax=ax, **gv_kws, line_kws=gv_line_kws, fill_kws=gv_fill_kws)\n", - "ax.grid(True)\n", "ax.legend(bbox_to_anchor=(1.0, 1.0))\n", "\n", + "\n", "# Admits\n", "ax = axs[1]\n", "ax.set_ylabel(f\"COVID-19 Hospital Admits\", fontsize=12, fontweight=\"bold\")\n", - "pl.plot_band(\n", - " x=forecast_df.index,\n", - " y1=forecast_df[\"Hospitalized Admits 25%\"],\n", - " ym=forecast_df[\"Hospitalized Admits Median\"],\n", - " y2=forecast_df[\"Hospitalized Admits 75%\"],\n", + "ax.grid(True)\n", + "\n", + "## General posteriors\n", + "plot_band(\n", + " x=FORECAST_DF.index,\n", + " y1=FORECAST_DF[\"Hospitalized Admits 25%\"],\n", + " ym=FORECAST_DF[\"Hospitalized Admits Median\"],\n", + " y2=FORECAST_DF[\"Hospitalized Admits 75%\"],\n", " fill_kws=fill_kws,\n", " line_kws=line_kws,\n", " ax=ax,\n", " zorder=20,\n", ")\n", "\n", - "yy = normal_forecast_df[\"hospital_admits\"].values\n", - "pl.plot_gvar(x=xx, y=yy, ax=ax, **gv_kws, line_kws=gv_line_kws, fill_kws=gv_fill_kws)\n", - "ax.grid(True)\n", + "## Normal posteriors\n", + "plot_gvar(\n", + " x=t_range_shifted,\n", + " y=FORCAST_DF_NORMAL[\"hospital_admits\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", "\n", - "ax.grid(True)\n", "\n", "fig.suptitle(\n", " \"General vs normal posteriors @ 50% C.I.\", y=1.02, fontsize=12, fontweight=\"bold\"\n", ")\n", + "fig.autofmt_xdate()\n", + "fig.tight_layout()\n", "\n", "despine()\n", + "show_plot(fig)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute normal posteriors given normal priors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "extended_range = date_range(\n", + " DATA_DF.index[0] - timedelta(int(OFFSET)), freq=\"D\", periods=OFFSET\n", + ")\n", + "tmp = DataFrame(index=extended_range, columns=DATA_DF.columns).fillna(0)\n", + "extended_data = concat([tmp, DATA_DF])\n", + "extended_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_infections = META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"] / PRIORS[\"hosp_prop\"]\n", + "\n", + "## Fixed paramters (no distributions)\n", + "xx = {\n", + " \"dates\": extended_data.index,\n", + " \"market_share\": META_PARS[\"mkt_share\"],\n", + " \"initial_susceptible\": META_PARS[\"region_pop\"],\n", + " \"initial_infected\": 0,\n", + " \"initial_recovered\": 0,\n", + " \"initial_hospitalized\": META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"],\n", + "}\n", + "## Variable parameters (distributions)\n", + "pp = {\n", + " \"initial_exposed\": total_infections,\n", + " \"incubation_days\": PRIORS[\"incubation_days\"],\n", + " \"beta\": PRIORS[\"beta\"],\n", + " \"recovery_days\": PRIORS[\"recovery_days\"],\n", + " \"nu\": PRIORS[\"nu\"],\n", + " \"hospitalization_probability\": PRIORS[\"hosp_prop\"],\n", + " \"hospital_length_of_stay\": PRIORS[\"hosp_LOS\"],\n", + "}\n", + "\n", + "## It seems like the fit wants to drastically change incubation days and hosp_prob\n", + "## The lines below would fix such values to their mean\n", + "# pp[\"incubation_days\"] = gvar(pp[\"incubation_days\"].mean, pp[\"incubation_days\"].sdev / 2)\n", + "# pp[\"hospitalization_probability\"] = gvar(\n", + "# pp[\"hospitalization_probability\"].mean, pp[\"hospitalization_probability\"].sdev / 5\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pp[\"L\"] = PRIORS[\"logistic_L\"]\n", + "pp[\"x0\"] = PRIORS[\"logistic_x0\"] + OFFSET\n", + "pp[\"k\"] = PRIORS[\"logistic_k\"]\n", + "\n", + "seir.update_parameters = update_parameters\n", + "seir.fit_start_date = \"2020-03-06\"\n", + "seir.fit_columns = \"hospital_census\"\n", + "seir.debug = False\n", + "\n", + "yy = gvar(DATA_DF.hosp.values, DATA_DF.hosp.values * 0.1 + 10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "seir.check_call(xx, yy, pp)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%timeit\n", + "fit = nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "fit = nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_prediction = xx.copy()\n", + "tf = FORECAST_DF.iloc[:100]\n", + "x_prediction[\"dates\"] = tf.index\n", + "df = seir.propagate_uncertainties(x_prediction, fit.p)\n", + "df.index -= timedelta(days=OFFSET)\n", + "\n", + "fig, axs = subplots(ncols=1, nrows=2, figsize=(9, 9), sharex=False)\n", + "\n", + "gv_kws = dict(color=\"black\", zorder=10, lw=3, z_factor=0.674)\n", + "gv_line_kws = {\"ls\": \"--\", \"label\": \"Normal posteriors\"}\n", + "gv_fill_kws = {\"alpha\": 0.2}\n", + "\n", + "fill_kws = {\"alpha\": 0.3, \"edgecolor\": \"k\", \"lw\": 2}\n", + "line_kws = {\"ls\": \"-\", \"label\": \"Data\", \"lw\": 2}\n", + "\n", + "\n", + "# Census\n", + "ax = axs[0]\n", + "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", + "ax.grid(True)\n", + "\n", + "## Fit\n", + "plot_gvar(\n", + " x=df.index,\n", + " y=df[\"hospital_census\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "\n", + "## Original\n", + "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", + "plot_band(\n", + " x=tf.index,\n", + " y1=tf[\"Hospitalized Census 25%\"],\n", + " ym=tf[\"Hospitalized Census Median\"],\n", + " y2=tf[\"Hospitalized Census 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "\n", + "## Data\n", + "plot_gvar(\n", + " x=DATA_DF.index,\n", + " y=yy,\n", + " ax=ax,\n", + " z_factor=0.674,\n", + " color=\"red\",\n", + " line_kws={**line_kws, \"label\": \"Data\"},\n", + " fill_kws={**fill_kws, \"alpha\": 0.5, \"zorder\": 5},\n", + ")\n", + "ax.legend(loc=\"upper left\")\n", + "\n", + "\n", + "# Admits\n", + "ax = axs[1]\n", + "ax.grid(True)\n", + "\n", + "## Prediction\n", + "plot_gvar(\n", + " x=df.index,\n", + " y=df[\"hospital_admits\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "ax.grid(True)\n", + "\n", "\n", + "## Original\n", + "plot_band(\n", + " x=tf.index,\n", + " y1=tf[\"Hospitalized Admits 25%\"],\n", + " ym=tf[\"Hospitalized Admits Median\"],\n", + " y2=tf[\"Hospitalized Admits 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "\n", + "\n", + "fig.suptitle(\n", + " \"General PDF vs normal PDF @ 50% C.I.\", y=1.02, fontsize=12, fontweight=\"bold\"\n", + ")\n", "fig.autofmt_xdate()\n", - "fig.tight_layout()" + "fig.tight_layout()\n", + "\n", + "despine()\n", + "show_plot(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(fit)\n", + "\n", + "name_map = {\n", + " \"L\": \"logistic_L\",\n", + " \"x0\": \"logistic_x0\",\n", + " \"k\": \"logistic_k\",\n", + " \"hospitalization_probability\": \"hosp_prop\",\n", + " \"hospital_length_of_stay\": \"hosp_LOS\",\n", + "}\n", + "\n", + "new_posterior = {name_map.get(key, key): val for key, val in fit.p.items()}\n", + "new_posterior[\"logistic_x0\"] -= OFFSET\n", + "new_prior = {name_map.get(key, key): val for key, val in pp.items()}\n", + "\n", + "comparison = DataFrame(\n", + " [new_prior, new_posterior, POSTERIORS],\n", + " index=[\"Priors\", \"PDF from normal approx\", \"PDF from general dists\",],\n", + ").T.dropna()\n", + "\n", + "comparison[\"diff\"] = (\n", + " comparison[\"PDF from normal approx\"] - comparison[\"PDF from general dists\"]\n", + ")\n", + "comparison[\"z\"] = comparison[\"diff\"].apply(lambda x: abs(x.mean) / x.sdev)\n", + "comparison.sort_values(\"z\", ascending=False)" ] }, { From a6228d5169e0c5aa850658178ddd185d510a2e32 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 14:34:22 +0200 Subject: [PATCH 31/40] Add readme for new module --- README-normal-extension.md | 99 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 README-normal-extension.md diff --git a/README-normal-extension.md b/README-normal-extension.md new file mode 100644 index 0000000..55cf2fd --- /dev/null +++ b/README-normal-extension.md @@ -0,0 +1,99 @@ +# Normal extension of Bayesian analysis + +The folder `bayes_chime/normal` contains an extension of the Bayesian analysis of the SEIR model. +In this extension, it is assumed that all data and model parameters are normally distributed. +This simplifies the propagation of errors and allows to analytically compute approximated posterior distributions. +Particularly, propagating parameter distributions through a 200-day simulation takes `20ms` while the estimation of the posterior distribution is at the order of `1s`. +Tests indicated that, for a given parameter distribution, general Bayesian forecasts agree with their normal approximations within uncertainty. + + +## Install the module +You can locally install this module using pip + +```bash +pip install [--user] [-e] . +``` + +## How to use the module + +### How to propagate uncertainties +```python +from gvar import gvar +from bayes_chime.normal.models import SEIRModel + +# define fixed model parameters +xx = {"market_share": 0.26, "region_pop": 1200000, ...} + +# define model parameter distributions +pp = {"incubation_days": gvar(4.6, 1.5), "recovery_days": gvar(15.3, 3.5)} + +# set up the model +seir = SEIRModel() +df = seir.propagate_uncertainties(xx, pp) +``` +The `gvar` variable represents a Gaussian random number characterized by it's mean and standard deviation. + +### How to compute posteriors +```python +... # after code above + +from lsqfit import nonlinear_fit + +yy = gvar(data_mean, data_sdev) + +fit = nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn) + +print(fit) # Fit statistics +print("Posterior:", fit.p) +``` + +In the `notebooks/How-to-use-normal-approximations-module.ipynb`, the general usage of the module is explained. + +## Technical details + +### Uncertainty propagation and posteriors + +This module makes use of two libraries developed by [Peter Lepage](https://physics.cornell.edu/peter-lepage) + +* [`gvar`](https://gvar.readthedocs.io) and +* [`lsqfit`](https://lsqfit.readthedocs.io) + +The random numbers represented by `gvar`s act like `floats` but automatically compute analytic derivatives in successive computations. +Thus they allow to propagate errors through the whole computation. +Because normal distributions are self-conjugate (if the likelihood is a Gaussian and the prior is Gaussian, so will be the posterior). + +To determine posterior distributions, the `nonlinear_fit` function from `lsqfit` uses the saddle-point approximation for the kernel of the posterior function (evolve the residuals up to the second order and evaluate at the point where the first derivative vanishes). +Thus, computing the posterior effectively boils down to finding the parameters which cause the first derivative of the `chi**2` to vanish. +For this it uses regular minimization routines. +More details are specified in the [appendix A of the linked publication](https://arxiv.org/pdf/1406.2279.pdf). + +### Kernel functions + +To utilize the above modules, kernel operations must be written to utilize the syntax of `gvar`s and `lsqfit`. +Model parameters are either categorized as independent / fixed parameters or distribution / variable parameters. +Variable parameters follow normal distributions, fixed parameters are numbers. + +This module abstracts the compartment models like SIR or SEIR such that future implementations can easily be extended. +E.g., after inheriting from the `bayes_chime.normal.models.base.CompartmentModel`, one only has to provide a `simulation_step` method and can use existing API to run simulations +```python +def simulation_step(data, **pars): + susceptible = data["susceptible"] + exposed = data["exposed"] + infected = data["infected"] + recovered = data["recovered"] + + infected += pars["beta"] * infected * susceptible / pars["total"] + ... + + return oupdated_data +``` + +``` + +## Cross checks + +This module tests against the non-Bayesian `penn_chime` module. These tests can be run in the repo root with +```bash +pytest +``` +Furthermore, the `How-to-use` notebook fits posterior distributions generated with the main module and compares the propagation of uncertainties. From c5643f0ccd6ca1095bfca57ab72697ce41a9c8fb Mon Sep 17 00:00:00 2001 From: ckoerber Date: Fri, 24 Apr 2020 15:16:16 +0200 Subject: [PATCH 32/40] Added notebook which compares normal vs general Bayesian parameter inference --- ...-to-use-normal-approximations-module.ipynb | 977 ++++++++++++++++-- 1 file changed, 904 insertions(+), 73 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index 8323923..0d92c17 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -7,9 +7,28 @@ "# How to use the normal approximations module" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This module explains how to approximate existing priors and posteriors with normal distributions and how to propagate errors.\n", + "It compares the propagation of errors to existing data.\n", + "For this reason, you first must generate a fit as specified in the (original) readme.\n", + "The fits here have been computed for the Downtown area.\n", + "\n", + "Make sure you have installed the module and dependencies before you run this module." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -42,23 +61,28 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "ROOT = path.dirname(getcwd())\n", - "RUN = \"2020_04_22_09_07_17\"" + "**Update the RUN directory to load in your data**" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ + "ROOT = path.dirname(getcwd())\n", + "RUN = \"2020_04_22_09_07_17\"\n", + "\n", "OUTPUT = path.join(ROOT, \"output\", RUN)\n", - "DATA = path.join(OUTPUT, \"parameters\")" + "DATA = path.join(OUTPUT, \"parameters\")\n", + "\n", + "if not path.exists(DATA):\n", + " raise KeyError(\n", + " \"You have to point to an existing run directory to run this notebook.\"\n", + " )" ] }, { @@ -70,9 +94,91 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hospventmort
date
2020-03-06100
2020-03-07100
2020-03-08100
2020-03-09200
2020-03-10200
\n", + "
" + ], + "text/plain": [ + " hosp vent mort\n", + "date \n", + "2020-03-06 1 0 0\n", + "2020-03-07 1 0 0\n", + "2020-03-08 1 0 0\n", + "2020-03-09 2 0 0\n", + "2020-03-10 2 0 0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "DATA_DF = (\n", " read_csv(path.join(DATA, \"census_ts.csv\"), parse_dates=[\"date\"])\n", @@ -91,11 +197,118 @@ "## Fit priors" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, priors are loaded in from file. Because the prior distributions are known (but not normal), they are approximated by normal distributions for later use." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
parambasedistributionp1p2description
0n_hosp1.000constantNaNNaNNumber of hospitalized COVID-19 patients on day 1
1hosp_prop0.025gamma6.3268330.004169Prportion of infections requiring hospitalization
2ICU_prop0.450beta52.05931196.867420Proportion of hospitalizations admitted to ICU
3vent_prop0.660beta5.2240293.078885Proportion of ICU patients requiring ventilation
4hosp_LOS12.000gamma195.4976400.059681Hospital Length of Stay
\n", + "
" + ], + "text/plain": [ + " param base distribution p1 p2 \\\n", + "0 n_hosp 1.000 constant NaN NaN \n", + "1 hosp_prop 0.025 gamma 6.326833 0.004169 \n", + "2 ICU_prop 0.450 beta 52.059311 96.867420 \n", + "3 vent_prop 0.660 beta 5.224029 3.078885 \n", + "4 hosp_LOS 12.000 gamma 195.497640 0.059681 \n", + "\n", + " description \n", + "0 Number of hospitalized COVID-19 patients on day 1 \n", + "1 Prportion of infections requiring hospitalization \n", + "2 Proportion of hospitalizations admitted to ICU \n", + "3 Proportion of ICU patients requiring ventilation \n", + "4 Hospital Length of Stay " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "PRIOR_DF = read_csv(path.join(DATA, f\"params.csv\"))\n", "PRIOR_DF.head()" @@ -103,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "scrolled": false }, @@ -115,9 +328,124 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
val
hosp_prop0.024(10)
ICU_prop0.349(39)
vent_prop0.65(17)
hosp_LOS11.64(83)
ICU_LOS13.47(89)
vent_LOS19.5(2.3)
incubation_days4.6(1.5)
recovery_days15.3(5.0)
logistic_k0.78(43)
logistic_x016.7(6.9)
logistic_L0.37(23)
nu2.46(25)
beta0.32(12)
\n", + "
" + ], + "text/plain": [ + " val\n", + "hosp_prop 0.024(10)\n", + "ICU_prop 0.349(39)\n", + "vent_prop 0.65(17)\n", + "hosp_LOS 11.64(83)\n", + "ICU_LOS 13.47(89)\n", + "vent_LOS 19.5(2.3)\n", + "incubation_days 4.6(1.5)\n", + "recovery_days 15.3(5.0)\n", + "logistic_k 0.78(43)\n", + "logistic_x0 16.7(6.9)\n", + "logistic_L 0.37(23)\n", + "nu 2.46(25)\n", + "beta 0.32(12)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "g = FacetGrid(\n", " PRIOR_DF.query(\"distribution != 'constant'\"),\n", @@ -138,6 +466,13 @@ "## Fit posteriors" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, posterior distributions are fitted using normal distributions as well." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -147,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -164,23 +499,129 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The line below may take a while maybe `HDF5` might be a more suiteable format" + "The below fit removes outliers to stabilize the fit" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], - "source": [ - "POSTERIOR_DF.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAKACAYAAABqjohZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXxcd33v/9dHi/fdki1Zki1Zljd5TRzbASfNShJaCEtaEigNpfxob0M3Ci3cyy0tt70/Si/lXqCQhqVJGgJJAzS5kEAWEmwnsRM73iTLuyVLsi1b8iIvkS1Ln/vHnJHHsnbNPu/n4zEPz5zzPd/z0ZDDnPnM9/v5mrsjIiIiIiIiIpLMshIdgIiIiIiIiIhIf5TAEBEREREREZGkpwSGiIiIiIiIiCQ9JTBEREREREREJOkpgSEiIiIiIiIiSU8JDBERERERERFJekpgiIiISFoxsz83szGJjkNERESiSwmMNGVmN5nZzxIdh0g6M7NSM6uKeL3SzNaa2W4z22Jm3zWzMWb2t2b2mW7H1ppZXvyjFumdmeUkOoYo+XNg2AmMNHo/JIMl4p6wt3OaWaWZ/Sr4nNxrZv/dzCzYN93MfmZm28xsp5k9G8+YRYYjlveEZna2h20TzexRM9tnZvuD5xODfVlm9nUzqzKzHWb2ppmVRfPvTSQlMGJINz5XsxD9dydRkyzXmZlNB/4D+Gt3n+fuy4FfAONjeM7sWPUtqSm4gdplZj8wsxozeyo8EsHM/ia4iakys4civjS8Ymb/28w2AX9mZu8xs43BDdeLwX/bBDddj5jZOjOrM7MPmNlXgpujX5hZ7jBj/5GZ/WbE64fN7B4zyzazfwpi325mfxjsvymI/amIv9nM7E+BGcDLZvZyH+c7a2ZfM7NqM3vJzPJ7eT9uDd6LHWb2fTMbGbSrjfj73zCzOcP5+yW9JctnVSKZ2WjgGeDL7j4PWAq8A/jjoMmXgBfcfam7LwQ+l5hIJVUly3UWp3vC7wEH3H2Ou5cDB4HvBvs+ROhzcIm7LwbeD5yK4rkTSl8k+5DKN4KBcd1v7IJz93Yz9mULZby3m9n/CrY9bGYPmtkmM9tjZr/Vx/v1MTN7OngP9prZFyPex91m9ihQBZQEN6PhrOCHgnY3WShT+fOg/YOmZEfaS4PrLOwB4BF3fz28wd2fcvemwXbUz3tSa2b/aGZvAb9tZvcFf0+Vmf1jRB89fjmTjDAP+Ja7LwBaufzl4Jvufp27LwJGA5H/fz7C3Ve4+1eB9cDq4IbrR8BfRbQrB24B3gs8Brwc3By9Dfwm3ZjZZ81saw+Pr/cQ9xPA7wTHjQBuBX4O/AFw2t2vA64D/j+7/EvSckKjLRYCs4F3uvvXgcPAze5+cx/v01hgk7tXAr8Gvtj9/QD+BXgY+FDwd+YA/yWi3elg+zeB/93HuSTFpcFnVVzvCXvxYeBVd38ewN3PA5/icqKiEGgIN3b37cP7kyXVpMF1Fha1e8KeWChhfi3wPyI2fwlYYWblhK6lI+7eGZy7wd1PRuPcyUBfDvuXqjeC0MONnZmNooebMTObSig7V+nuS4C/j+inFFgZxPRg0EdvVgIfBJYQ+nK1ItheQeh9rARWAMsIZd5vA/7JzAojjv+TIOZy4AN9nEvSRypfZ2GLgM2D/cP70Nt7AtDi7tcAa4F/JPT3LQOuM7P3BW36+nIm6a3e3V8Nnj8GrAme3xzc1O0g9N9MZcQxT0Q8LwZ+GbT7bLd2z7l7O7ADyCb0ixLB69Lugbj7P7n7sh4ef9pD3M8FMY4E7gLWuvvbwLuA3zOzrcBGYCqhzxSAN4Ibs05ga08x9KEz4u+OfJ+I2D4POOjue4LXjwA3RrT7YcS/1w/i3JKaUvmzKhH3hN1V0u1z0t33E0quTCCUMPyemb1sZv/NzGYMom9JH6l8nYVF+56wu4XAVnfvCG8Inm8ldJ09CbwniPWrZrY8hrHEnRIY/UvVG0Ho+caut5ux00AboQ+ODwDnI/p50t073X0vcACY38v5IDT0ryW46fwJl9+vOnffEDxfA/zQ3TuCTOSvCf2qFo75QHAR/pArbyglfaXydTYQPsjt0Pt7Apf/9uuAV9z9uLtfAn7A5S9XfX05k/TW/b8rD75kfAu4J7hZ+w4Q+cXjXMTzbxC6UVwM/GG3dhcAgs+VdncPn6uT0JefKwzm5s/d24BXgDsIDX8N//drwJ9EXItl4V9ww/EEOnqKYRAi37dzvbbq/Zi+rmdJD6n8WZWIe8JBcfdfEkqufCfod4tp9GAmSuXrbCCGck84uBO4NxC6vj9P6PP5JTO7NVr9J5oSGP1LyRvByP4Dfd7YBV9+VgJPEcpo/iJyd/fmvfXTR9uh3Az2dy5JH6l8nYVVExrO15MWYHK3bePpez5iX9fCQK+nvvqT9DXTzMKjAT5M6Neo8DXRbGbjgHv6OH4i0Bg8v384gQzh5u8J4PeBG7j8OfRLQr8K5wKY2VwzG9vPqc/Q/1zjLC6/D+H3qbvdQKldrm/xUUJJ97APRfz7OpLuUvmzKhH3hN3tpNvnpJnNBs66e2tw7hPu/ri7fxR4kytHPElmSOXrLCza94Td7QSWWcRU++D5smAf7n7B3Z9z988C/xN4X489pSAlMPqXyjeCPenxZiz4Oya6+7PAXxCa3hH22xaqZltOKDO+u4/+bzezKRYq1PQ+4NUe2qwDPmShwmz5hD6c3gj2rTSzsuAi/BA931BK+kmH6+ybwP1mtiq8wULzK6cTmurxXjMbH94ObIsc+teDnt6T7t4AfsPM8ixU0PM+Ln+5GsiXM0lPu4EHzKyG0E3St939FKEbvipCCYE3+zj+b4H/MLPNQHOMY+3ueeA3gBfd/WKw7buEbsjeslCF93+l/5EWDwG/sD6KeBK64V0Z9HkLofnDVwhGhfw+ofdjB6Gb3Acjmkw2s+3AnxH67JT0lg6fVZFifU/Y3Q+ANWZ2G3QV9fw68JXg9S12ud7BeELD/Q8Non9JD+lwnUX7nrB7XPuALcAXIjZ/AXjL3feZ2TUWTMEKvlMtAeoG2n+yS4pKrUkufCP4fUI3UN929/NmFr4RPMrAbgRPAr8CErqEjbu3mVn4ZiyHUOwPAlOAp4MMpwGfjjjsEKEvShOAPwpu6HrzBvBjQsO3HnP3TWZW2q3NTwnNFd5GKMv6V+5+1MzmB/F8E5gDvBy0lfSX8teZuzeZ2b3A/zKzaYS+6KwFfhHs+yaw3swcOAZ8op8ur3pPejjnETP7HKFrxYCfu/vTwe7wl7MvBOf7UPfjJW1dcvff7b7R3b/AlTc74e03dXv9NPB0D+3+ttvrcb3tG6pgaO+Ubts6gf8aPCK9EjzC7T4V8fwbhH6F6+98n+5h203dXr9EqH5AT/7J3f+6v/NI2kj5z6pIcbgnvNXMGiJe/zZwN/ANM/sXQkP4/53QfR+EfrH+ppldIpSE/6679/V+SnpK+essBveEY7pdS/9MqMD1N8xsf7Dt9WAbwDTgOxYU5SV0zX6TNGGXR85Id8EX7595qFhMRjKzhwm9B08NoO3HgBWRN5GDPNdNwGfcfbBVrSWF6Tq7WjTeEzM7G/kFUzKDrqeBG+41Yma1hD7z4j1KRRJA19bg7glFhkLXmQyERmCIiIikCXevJVT9XAJmthEY2W3zR4eb4HP30uEcLyIiIoOnERgyaGZ2B6GlGyMddPf3JyIekVRloaXqXuph163u3hLveERERAZD94Qi0aF7woFTAkNEREREREREkl5SrEJy5513OqFijnrokWqPpKZrS48UfSQ1XVd6pOgj6ena0iNFH0lN15UeKfroVVIkMJqbVf9KJBZ0bYlEn64rkdjQtSUSfbquJN0kRQJDRERERERERKQvSmCIiIiIiIiISNJTAkNEREREREREkp4SGCIiIiIiIiKS9JTAEBEREREREZGk128Cw8xKzOxlM9tpZtVm9mfB9ilm9oKZ7Q3+nRxsNzP7upntM7PtZnZNrP8IEZFM8/bbb7N161bc+1xpSkREREQkbQxkBMYl4C/dfSGwGnjAzBYCnwNecvcK4KXgNcBdQEXw+CTw7ahHLSKSwS5cuMA73/lOli9fzuc///lEhyMiIiIiEhc5/TVw9yPAkeD5GTOrAYqAu4GbgmaPAK8Afx1sf9RDPwtuMLNJZlYY9CPD9PjGQ13PP7xqZgIjkVgxs1HAWmAkoWv0KXf/opk9DPwGcDpo+jF335qYKCWRfvzjH7NlyxamTJnC1772NT7zmc+Ql5eX6LASxsy+D/wWcMzdFwXbngDmBU0mAafcfVkPx9YCZ4AO4JK7r4hL0JKR9Bku0aD/jkTiS9dcchlUDQwzKwWWAxuB6RFJiaPA9OB5EVAfcVhDsK17X580s01mtun48eODDFskrV0AbnH3pcAy4E4zWx3s+6y7LwseSl5kqB/84AeUlZXxyiuvcPHiRZ566qlEh5RoDwN3Rm5w9w+FrxXgx8BP+jj+5qCtkhciIiIiSWzACQwzG0foJvDP3b01cl8w2mJQE7Hd/SF3X+HuK/Lz8wdzqEha85Czwcvc4KFCBwKEpo+88sor/OZv/iaLFi1i1qxZPP/884kOK6HcfS1woqd9ZmbA7wA/jGtQIiIig9Bb3cFubVRrUDLegBIYZpZLKHnxA3cP/4rVZGaFwf5C4FiwvREoiTi8ONgmIgNkZtlmtpXQdfWCu28Mdv1D8IH1NTMb2cuxGt2UxjZv3sz58+e5+eabMTNuueUW1q5dq2KevbsBaHL3vb3sd+B5M9tsZp/srRNdVyIiEmO91R2MpFqDkvEGsgqJAd8Datz9nyN2PQPcHzy/H3g6YvvvBRnC1cBp1b8QGRx37wiGvhcDK81sEfB5YD5wHTCFUM2Zno7V6KY0tmnTJgBWrVoFwMqVK2lpaaGuri6RYSWz++h79MUad7+G0E3hA2Z2Y0+NdF2JiEgsufsRd38reH4GCNcdjNRVa9DdNwCTwj8oi2SKgYzAeCfwUeAWM9saPN4NfBm43cz2ArcFrwGeBQ4A+4DvAH8c/bBFMoO7nwJeBu4MPtjc3S8A/wasTGx0kgibNm2ioKCAoqLQPc11113XtV2uZGY5wAeAJ3pr4+6Nwb/HgJ+i60pERBKsW93BSKo1KBlvIKuQrAesl9239tDegQeGGVdGi6x0C6p2m2nMLB9od/dTZjYauB34x/BqPsGoqPcBVQkNVBKiqqqKpUuXdr2urKwkKyuLqqoq7rnnngRGlpRuA3a5e0NPO81sLJAVrLA1FngX8KV4BigiIhKpr7qDA+XuDwEPAaxYsUJzTCWtDGoVEhGJi0LgZTPbDrxJqAbGz4AfmNkOYAeQB/x9AmOUBOjo6KCmpobKysqubaNGjaK8vJzq6uoERpZYZvZD4HVgnpk1mNkfBLvupdv0ETObYWbPBi+nA+vNbBvwBvBzd/9FvOIWERGJ1EvdwUiqNSgZr98RGCISX+6+ndCwwe7bb0lAOJJE6urqaGtrY+HCK2t6VVZWZnQCw93v62X7x3rYdhh4d/D8ALC0exsREZF466PuYKRngE+Z2Y+AVajWoGQgJTBERJJU5HSyD6+ayZ49ewCYN2/eFe3mzp3Ls88+S0dHB9nZ2XGNUUQyj5mVAI8SGsXkwEPu/n+6tTHg/xBKGJ4HPhYuUCgiPQrXHdwRrEQH8F+BmQDu/iChWoPvJlRr8Dzw+wmIUyShlMAQEUkRe/eGVgKtqKi4YvuJ7ClcvHiRbz6zgT97/zsTEZqIZJbwco9vmdl4YLOZveDuOyPaRC73uIrQco+r4h+qSGrop+5guI1qDUrGUwJDRCRF7Nu3j3HjxjFt2rQrRmdMLy4F4Gh9LaEfcEREYicYsn4keH7GzMLLPUYmMLqWewQ2mNmkcDHq+EcsIiLpQkU8RURSxP79+ykvLyc0Mvuy6cWzAGhqrEtEWCKSwbTco4iIxJMSGCIiKaK2tpaysrKrtk/Om052Ti7NR1WIXETiJ1rLPbr7CndfkZ+fH90ARUQk7WgKiYhICnB3amtruf3226/al5WdTV7BDJqPNFxV+FNEJBa03KOIiCSCRmCIiKSAlpYWzp07R2lpaY/78wqKOH6kvsd9IiLRNIjlHn/PQlaj5R5FRCQKNAJDRCQF1NWF6lvMmjWrx/15hcVse+3leIYkIplLyz2KiEhCKIEhIpIC6utDoytKSkp63D912gxOn2jmUvtFcnJHxDM0EckwWu5RREQSRVNIRERSQH8JjCnTCnB3Th5vimdYIiIiIiJxowSGiEgKqK+vZ8SIEfRWpX/q9BkAtBzTFHMRERERSU9KYIiIpID6+nqKi4sJ1c672pTphQC0NB2OZ1giIiIiInGjBIaISApobGykuLi41/1TpoUSGCePH41XSCIiIiIicaUEhkiSMbNRZvaGmW0zs2oz+7tge5mZbTSzfWb2hJmpUmMGOXz4MDNmzOh1/+gx4xg5egwnm4/FMSoRERERkfhRAkMk+VwAbnH3pcAy4E4zWw38I/A1d58DnAT+IIExShy5O42NjRQVFfXaxsyYkl+QkSMwzOz7ZnbMzKoitv2tmTWa2dbg8e5ejr3TzHYHicHPxS9qERERERksJTBEkoyHnA1e5gYPB24Bngq2PwK8LwHhSQKcP9NKW1tbnyMwACblTcvUVUgeBu7sYfvX3H1Z8Hi2+04zywb+BbgLWAjcZ2YLYxqpiIiIiAyZEhgiScjMss1sK3AMeAHYD5xy90tBkwag95/jJa2cbA4lJfpLYGTqCAx3XwucGMKhK4F97n7A3S8CPwLujmpwIiIiIhI1SmCIJCF373D3ZUAxoS9Z8wd6rJl90sw2mdmm48ePxyxGiZ9TQV2LgYzAOHXiOO4ej7BSwafMbHswxWRyD/uLgPqI170mBnVdiYiIiCSeEhgiSczdTwEvA9cDk8wsJ9hVDDT2csxD7r7C3Vfk5+fHKVKJpZMtoQRGYWFhn+0mTZ1G+4ULnD/bGo+wkt23gXJCdWSOAF8dTme6rkREREQSTwkMkSRjZvlmNil4Phq4HaghlMi4J2h2P/B0YiKUeAuPwOgvgTFxav4V7TOZuzcFI5k6ge8QGsnUXSNQEvG618SgiIiIiCSeEhgiyacQeNnMtgNvAi+4+8+AvwY+bWb7gKnA9xIYo8TRqZZjjB07lnHjxvXZblLetK72mc7MIrM97weqemj2JlARLFE8ArgXeCYe8YmIiIjI4OX030RE4sndtwPLe9h+gJ5/RZY0d7rleL+jLwAmTcnMERhm9kPgJiDPzBqALwI3mdkyQiv41AJ/GLSdAXzX3d/t7pfM7FPAL4Fs4PvuXp2AP0FEREREBkAJDBGRJHeq5RgFBQX9tps0NTQC4/SJ5liHlFTc/b4eNvc4QsndDwPvjnj9LHDVEqsiIiIiknw0hUREJMmdbjnO9OnT+203ZvwEcnJHcKpFq2SIiIiISPrRCAwRkSR3+mTzgEZgmBkTp+TRejKzRmCIiGSqxzce6nr+4VUzExiJiEh8KIGRgtydLa/+ioMvHub9738/CxcuTHRIIhIj7RcvcK71NE3tI6+4Ue3NxKn5GTeFRERERGSwut9XRSYBB3LPJYmhKSQp6Ef/8mW++pmP84UvfIHly5fz4osvJjokEYmR1pMtAEwMCnT2Z+LkPE0hEREREZG0pARGitm+cS0/e+xBbnnfh2loaKCiooL77ruPU6dOJTo0EYmB8GiKCVPyBtR+4pQ8Wk8ogSGSLB7feKjrISIiIsOjBEYK6ezs5Il/+TLTimZy/1/+HUVFRfz7v/87zc3NfOwv/rtukETSULiexcTBJDBOnaCzszOWYYmIiIiIxF2/CQwz+76ZHTOzqohtf2tmjWa2NXi8O2Lf581sn5ntNrM7YhV4Jnr55Zep3VPN+37/T8nJHQHA8uXL+eAHP8iLP/l3Lra1JThCEYm28AiMgSYwJkzJp7Ojg3NnTscyLBERERGRuBvICIyHgTt72P41d18WPJ4FMLOFwL1AZXDMt8wsO1rBZrqHHnqIsRMmcv3t77li+x//8R9zrvU0b7z8bIIiE5FYaT0RqoExYfJAR2BMBeC0ppGIJEx7ezuf//zn+dCHPsTR+tpEhyMiIpI2+k1guPta4MQA+7sb+JG7X3D3g8A+YOUw4pPA2bNneeaZZ3jHu+5mxMhRV+y7+eabyZ9RwmvPP52g6EQkVk6fOM7IUaMZNXrMgNpPmBxKYIQTHyISf3/3d3/Hl7/8ZZ588kn+6dMfo/3ihUSHJCIikhaGUwPjU2a2PZhiMjnYVgTUR7RpCLZdxcw+aWabzGzT8eP6pbA/zz77LG1tbay65Tev2mdmrLz5LqrefFXDxkXSTOvJlgEX8ITLq5WEVy8Rkfg6ceIEX/3qV/nwhz/Ms88+y9H6g6x/7ieJDktEklxP0/a77b/JzE5HTOH/m3jHKJIMhprA+DZQDiwDjgBfHWwH7v6Qu69w9xX5+QNbHjCT/ed//if5+fnMW3pdj/uvu+lOOi61s+31V+IbmIjE1OmTLQOePgKXR2BoColIYvzwhz+kra2Nz372s9x5550UlVXwyv99ItFhSQo6f/48H//4xxkzZgzXXnst27ZtS3RIElsP0/O0/UjrIqbwfykOMYkknSElMNy9yd073L0T+A6Xp4k0AiURTYuDbTIMnZ2dvPDCC9x5551kZfdcUqR84TLGTZjE9g1r4xydiMRS68kWJgZJiYEYN2ESlpXFmVMDnfknItH0k5/8hIULF7Js2TLMjHfe8T72VW3h5PGmRIcmKcTd+fjHP87DDz/MPffcw9GjR7njjjtobNRtdboa5LR9kYw1pASGmRVGvHw/EB7q9Axwr5mNNLMyoAJ4Y3ghyltvvUVzczN33NH7oi5Z2dksWnkDO95Yi7vHMToRiaXWk81doyoGIis7m/ETp3BaU0hE4q61tZW1a9fynvdcLra9fM1tAGx7/eVEhSUp6LnnnuOJJ57g7//+73n00Ud5/vnnOXXqFJ/73OcSHZok1vVmts3MnjOzyt4aaap+dFW9sZ5v/s2f8NXPfoJvfetbtGnlx4QayDKqPwReB+aZWYOZ/QHwFTPbYWbbgZuBvwBw92rgSWAn8AvgAXfviFn0GeKll14C4Lbbbuuz3eKVazjVfIydO3fGIyyJETMrMbOXzWynmVWb2Z8F23tdvljSk7tz5uSJQdXAAJgwZSqtwfKrIhI/r732GpcuXbri87qkfB4Tp+Sz860NCYxMUom784UvfIGKigo+85nPAFBZWcmnP/1pHnvsMRoP7k1whJIgbwGz3H0p8A3gP3trqKn60eHuPP6N/8n//6cfofrNVzlcu48HHniAm2++meZm3WclykBWIbnP3QvdPdfdi939e+7+UXdf7O5L3P297n4kov0/uHu5u89z9+diG35m+NEzv2TGrHJequ27ivn85asBWLduXTzCkti5BPyluy8EVgMPBEsUQw/LF0v6On+mlY6OS4MagQEwcfLUjCri2VPhMzP7JzPbFRSb/qmZTerl2NogIb/VzDbFL2pJR2vXriUnJ4frr7++a5uZMX/5SnZt2ZjAyKJLxQZj69VXX2XLli185jOfYcSIEV3b/+Iv/oKRI0fy/FOPJDA6SRR3b3X3s8HzZ4FcMxvcLxwyKD/79wf5+Q/+lds++FG+/vTr/K8nX+bJJ59k69atvP/976e9vT3RIWak4axCInHQ2dHB7m2bmH/N6n7bTi+exeT86axdqzoYqczdj7j7W8HzM0ANvazmI+mt9VQoCTFh0pRBHTd+UmYlMOi58NkLwCJ3XwLsAT7fx/E3B0nBFTGKTzLE66+/zvLlyxk7duwV2+cuWUFL0+F0qoPxMCo2GDPf/e53mThxIh/5yEeu2J6fn8/v/M7vsP65n3LxgoawZxozKzAzC56vJPQ9LqM+7ONpf/VWnnjwK6y69bf42Gf+B7kjRmJm/PZv/zbf+973WL9+Pb/zh3/J4xsP8fjGQ4kON6MogZHkDu3fxdvnzjC/l9VHIpkZ85et0giMNGJmpcByIPzTXU/LF3c/RvMe00TridB9yfhBjsCYMHlqV/IjE/RU+Mzdn3f3S8HLDYSKSovETGdnJ5s3b+a6667+vJ69YAkA+2vSYxUJFRuMnba2Nn7605/ygQ984KpEGMBHP/pR2s6f1apzaainaftm9kdm9kdBk3uAKjPbBnwduNdV+C4mOjs7efirf8PEKXl84r9+mSBv1OXDH/4wv/u7v8vPHvtXmhrqEhRl5lICI8ntq9oCQMWSawfUfs6ia2hoaFCV6jRgZuOAHwN/7u6tDHD5Ys17TB9dIzAGncCYwvkzrVy8eDEWYaWijwO9TWl04Hkz22xmn+ytAyUGpT979uzhzJkzPSYwSucuIis7mwM70yOBMUADKjYoV/rlL39Ja2sr9957b4/7b775ZiZMzmPjSz+Pc2QSa71M23/Q3R8M9n/T3Svdfam7r3b31xIdc7p68sknObBzG/c+8HnGjB3fY5uvfOUr5OTm8sS3vxLn6EQJjCS3v3orEybnkV9Y0n9joGLRcgA2bkyfubaZyMxyCSUvfuDuP4E+ly+WNBWeBjJh0uASGOOD9iowBWb23wjVlflBL03WuPs1wF2E6s3c2FMjJQalP1u3bgVg+fLlV+0bMWoUM2aVc2hvTbzDSpQBFxtUcvBKP/vZz5gwYQI33XRTj/tzcnJYvuYWtm14hUuXNP9eJNo6Ozv5h3/4B2aUzuGdd7yv13aFhYXcfs/9vPGrn3O4bn8cIxQlMJLcvqq3mLNo+VVDl3oza+5CRo4cyeuvvx7jyCRWgvmN3wNq3P2fI7b3tnyxpKmuBMbkwdXACNfMyPQvA2b2MeC3gI/0NszW3RuDf48BP0WJQRmibdu2kZOTw4IFC3rcP3POAg7ty4wExmCKDSo5eJm78+yzz/Kud73riuKd3S1/xy2cP9PKnm2qOywSbc899xxVVVW89/4HyMrq+6vyXR/6ODkjRvDzx/41TtEJKIGR1M6fO8Phuv1dc2cHIid3BMuWLWPTJn2opbB3Ah8Fbum2ZGqPyxdL+jpz6gRjxk0gJ7f3G9mehGtmZHICw/8qu7sAACAASURBVMzuBP4KeK+7n++lzVgzGx9+DrwLJQZliLZv386CBQt6/eI5c84CWpoOc671dJwjiz8VGxyaqqoqDh8+zF133dVnu0UrbyA7O4eqN1TzTCTavvWtb1FYWMj1t7+n37YTp+bzzjvez2vPP82pU6fiEJ2AEhhJrXZX6D56MAkMgGuvvZbNmzfT2dkZi7Akxtx9vbtbsExx15KpfS1fLOmp9WQL4we5AglcHoFx7NixaIeUlHoqfAZ8ExgPvBAkAR8M2s4ws/ASxNOB9UFBtDeAn7v7LxLwJ0gaqK6uZtGiRQBdVekjK9MXl88FoOHgnoTEF00qNhgbv/rVrwC49dZb+2w3euw4Zi9cSvVmlUAQiaba2lqee+45PvGJT5CTkzugY277wO9y8UIbjz76aIyjkzAlMJLYwV3bASibv3hQx61YsYIzZ86wd+/eWIQlInHSerJl0NNH4HLRz0wZgdFL4bM57l4SkQT8o6DtYXd/d/D8QFAMbWlQGO0fEvuXSKo6e/YsdXV1VFb2XquyqKwCgMaD++IVVsyo2GBsvPTSS5SXlzNr1qx+21aueAcHarZz/tyZOEQmkhkeeeQRAD7xiU8M+Jiy+YuZvWAJ//Zv/xarsKQbJTCS2MFdVUwtKBr0CgTXXhtasWTz5s2xCEtE4uTMqRNdBTkHY+yESVhWVsYkMEQSbdeuXQAsXLiw1zZ5BcWMHDWaxjQYgSHR19nZybp163ot3tndgmtW09nRwd7tutcTiQZ357HHHuPmm29m5syZgzp2zV0fYOvWrVRXV8coOomkBEYSq9tTTencwa88tmDBAkaOHNlVEV1EUlPrqZau6SCDkZWVxfiJk5XAEImTmppQcc7eCnhC6LosnDlb1eqlRzt37uTUqVPccMMNA2o/Z9E1ZGVns3vbmzGOTCQzHNi5jX379vGRj3xk0Meuvu09ZGdn89hjj8UgMulOCYwk1fb2eY4cOsCsISQwcnNzWbRoEVu2bIlBZCISD+7OmVMnuwpyDtaEyVOVwBCJk927d5Odnc3s2bP7bFc4q5wjSmBID9avXw/AmjVrBtR+1OgxlM5bpJVIRKLk9Rf/LyNGjOCDH/zgoI+dOCWP2267jSeffBKV+4k9JTCSVP3+Xbg7s+b2Phy1L8uWLWPr1q26iERS1OnTp+m41D6kERgA4ydNUQJDJE727NlDWVlZn0tfAhTOnE3z0UYuXmiLU2SSKl577TWmT5/ebxIs0twlK9i/cyuXLrUDVxaPjSwgKyJ9c3c2vfILbr/9diZOnDikPu655x4OHDjA9u3boxyddKcERpKq27MTgFlzeh+O2pdly5bR3NzM4cOHoxmWiMRJOPmgERgiyW/37t3Mmzev33aFs2bj7jQ11MUhKkklGzduZNWqVQSrzw7InMplXLzQRsP+3TGMTCT91e6u4viRBj7wgQ8MuY+7776brKwsfvzjH0cxMumJEhhJqn5fDaPHjievsHhIxy9ZElp6VVlAkdQUTj5oBIZIcnN39u3bR0VFRb9tC0rKAGhqqI1xVJJKTp48yZ49e1i1atWgjiuvXAbAvmrVPBMZjs1rn8eysnjve9875D7y8/O58cYb+elPfxrFyKQnSmAkqfr9u5k5Z/6gMvGRFi8OLb26Y8eOaIYlInHSlcAY6giMSVM5ceIEly5dimZYItLN0aNHOX/+PHPmzOm37fSi0PKYTQ21GuovXd544w2AQScw8gtLmDB5KvuVwBAZli3rX2LukhXk5eUNq5/3vOc9VFVVUVenUXaxlJPoAORq7k79/t284467h9zH5MmTKSkp0QgMkRTVNYVkqCMwJoeOa2lpYfr06VGLS0SutHfvXoABJTDGTpjIuImTOVpfG+OoJJVs2hQqxLlixYpe2/SU6DIzZi9YwoGabTGLTSTdtRw7Qu2eau594PPD6ufxjYfwkmsA+OI3H+Vd99zfte/Dqwa3LKv0TSMwklBL02HOn22lpHz+sPpZvHgxazds1q88Iino8hSSoY/AiOxHRGJj3759AJSXlw+o/fTiUk0hkSts2rSJioqKIRUPLFuwhMbafbS9fT4GkYmkv62v/gqA5WtuGXZfhTNnU1BSxpb1Lw27L+mdEhhJqH7/LgBKZvdfEKwvixcv5nDd/q7q1CKSOo4fP87I0WMYMWrUkI4Pj8BQAkMktg4cOEB2djazZs0aUPvpRTM51qgfFCTk8Y2HWPf6G+SVLhjSD01l8xbjnZ0c2rszBtGJpL/tG37N1IIiikr7r2M0EMvecTM1WzZwsU2rTcWKEhhJqGH/HgCKy+cOq59FixbRcamdo/UHoxGWiMTR8ePHh1zAEzQCQyRe9u/fz8yZM8nNzR1Q+2lFM2luOqwfFwSA1pMttDQdpmz+IoBBj5otmx+qeXagRjXPRAbr0qV2qt58lSWrbhxy3cHuFq+6gfYLF9i17Y2o9CdXUwIjCTUc3MPk/ALGjh/aOsRhixaFPgwbD+yNRlgiEkfHjx8fcv0LgPGTJnf1IyKxc+DAgQFPHwGYVjQL7+yk5aiWOReo3VMNQOm8RUM6fnL+dCZMzqMu6EdEBm5f1Rbazp9lyaobo9bn/OWryckdwfYNv45an3IlJTCSUMP+3ZSUD2/6CMD8+fOxrCzqD2h9cJFUc/z48SGvQAIwfqKmkIjEw4EDB5g9e/aA208rChVza2pUlXqBut2hxMOsisohHW9mlM6rpG6vEhgig7Vj41osK4vK694ZtT5HjR7DvKXXsWPj2qj1KVdSAiPJdHR00Fi3j6Ky4c/DGjVqFAXFpTTsVwIjlZhZiZm9bGY7zazazP4s2D7FzF4ws73Bv5MTHavETmgExtATGNk5OUyZMiUjEhhm9n0zO2ZmVRHbBnS9mNn9QZu9ZnZ/T21EenPmzBmam5spKysb8DHTZpQAcPxwfazCkhRSt3cneQXFjJs46ap9A51OMmtuJQ0H9nKp/WKswhRJS1Vvrqd84dJhj3rvbvHKG2g4sIdTLcei2q+EKIGRZA4ePEj7hQsUzx5e/YuworIKGg9qCkmKuQT8pbsvBFYDD5jZQuBzwEvuXgG8FLyWNOTuwQiMoU8hAcjPz8+IBAbwMHBnt239Xi9mNgX4IrAKWAl8UYlBGYza2lqAQSUwJudNJzsnVwkMAUJTSGbNXTisPmZVLKTjUjsNB/ZEKSqR9Nfa2sqBmu1Uroje6Iuw8IiO6k2vRb1vUQIj6ezcGaoiXVwWvQTG0YZa2i9eiEp/EnvufsTd3wqenwFqgCLgbuCRoNkjwPsSE6HE2rlz52hraxvWCAzInASGu68FTnTbPJDr5Q7gBXc/4e4ngRe4OhEi0quDB0NFsgeTwMjKziavoIhjSmBkvPPnz3O0/iCzKoaZwAgSIIf27YpGWCJpLTyq6UsPPUVnR0dUp4+Elc6tZMz4CVRvejXqfQvkJDoAuVJ1dWgO44yyOf22HUiF6qKyCjo7OjhaXxuVuhoSX2ZWCiwHNgLT3f1IsOsoML2XYz4JfBJg5syZsQ9Soi6cdIjGCIw9ezL2F7mBXC9FQOS3yIZg21V0XUlPhjICAyB/RgnHjyiBkemqq6vxzk5mzpk/rH4KiksZMXKUllIVGYTqTa+SO3IkFYuuiXrfWdnZLLzmeqrf1AiMWNAIjCSzc+dOpkwrZMzY8VHpLzwVRcMKU4+ZjQN+DPy5u7dG7nN3B7yn49z9IXdf4e4r8vPz4xCpRFs4gaERGNHR1/UyiD50XclVamtrGTNmDHl5eYM6Lr+wmOYjjTGKSlLFtm3bAJg5zBEYWdnZFJfP49C+mmiEJZIRdr61gbmLVzBi5KiY9F+54h00H23QdMEYUAIjyezcuTMqBTzDCmfOxrKyOFy7L2p9SuyZWS6h5MUP3P0nweYmMysM9hcCqgyUprpGYAxjGVUIJTBaWlro7OyMRlipZiDXSyNQEvG6ONgmMiC1tbWUlpZiZoM6Lr+wmNaTzVxoeztGkUkq2L59O6PGjCV/Rkn/jfsxs3w+dXtrCOVrRaQvZ0+fon5fDQuuWR2zcyy45noglCiR6FICI4l0dnZSU1MT1QTGiJGjmDajhMZaFfJMFRa6E/4eUOPu/xyx6xkgvErC/cDT8Y5N4uPYsdB37eEsowqhBEZHRwcnT56MRlipZiDXyy+Bd5nZ5KB457uCbSIDEk5gDFZeYTEAzUcaohyRpJLt27dTPHsuWVnDvx0vmbOAs6dPatUDkQGo2bIBd2fhtdfH7BzFs+cyftIUat56fcArCsnAKIGRRA4dOsTbb79NUWn0EhgARaUVNGoERip5J/BR4BYz2xo83g18GbjdzPYCtwWvJQ1droExvATGtGnTgMsJkXRlZj8EXgfmmVmDmf0BvVwvZrbCzL4L4O4ngP8BvBk8vhRsExmQoSYw8oMExnElMDKWu7Njxw5KyodX/yKsZE6ozln9/t1R6U8kndW8tYERI0dRvnBpzM5hZiy4ZrVGYMSAingmkfAKJEWl/RfwHIwZpXPYtuHXdFy6FNV+JTbcfT3Q23jkW+MZiyTG8ePHGTVqFCNHjxlWP+FaDcePH2fBggXRCC0puft9vey66npx903AJyJefx/4foxCkzTW2trKyZMnmTVr1qCPzS8MTRnQ3OjMdeTIEU6cODHsAp5hM4NESP2+XSxZdWNU+hRJVzVbNjJ3yQpyckfE9DwLrlnNG796luOH66MyVUxCNAIjidTUhIovDWQFksEoKqug41I7TY11Ue1XRKLv8Y2H2LjzIGMnThn0vPruIhMYIhJd4RVIhjICY+LUfHJyR9B8VCVXMtWOHTsAojYCY/ykKUzKm6YRGCL9ONd6mvp9NcxfvjLm55q/bBUAu7a+EfNzZZJ+Exhm9n0zO2ZmVRHbppjZC2a2N/h3crDdzOzrZrbPzLabWfTXpUljO3fuZNq0aYyfODmq/YZHdByu3ac5WCIpoPVkC+OHWcATLk8hUQJDJPrq6kI/CgxlBEZWVhZTpxcqgZHBwgmM4igucV9SPp/6/bui1p9IOtq97U3cnfnLY1fAM6x49lzGTZhEzRZNI4mmgYzAeBi4s9u2zwEvuXsF8FLwGuAuoCJ4fBL4dnTCzAw1NTUxGeZdWFoOoDoYIinizKkTw65/AXQt7agEhkj0hRMYQxmBAZBXUEzzUdXAyFRVVVUUFhZG9Uer4tlzaazdS2dHR9T6FEk3u7ZuJCd3REzrX4RlZWUxb9lKdm3ZGPNzZZJ+ExjuvhboXtTsbuCR4PkjwPsitj/qIRuASeFl7KRv7h6zBMaYseOZnF+gpVRFUsTpky1MnJI37H5yc3OZPHly2hfxFEmEuro6Ro0a1TXSabDyCou0CkkG27FjB4sXL45qnyXl82m/cIFjjRplm4p6GvXebb9GukfBri1vUF65jBEjR8XlfPOXraSpoY6TzU1xOV8mGGoNjOnufiR4fhSYHjwvAiIrUjUE26QfTU1NnDp1KmaF9opK5yiBIZIC3J0zJ1uiMgIDQtNIlMAQib66ujpmzpw55Fo1eQXFnGo5TvvFC1GOTJJdR0cHO3fuZNGiRVHttySYjlJ/QHUwUtTDXD3qPZJGug/TuXPnqN1dxfyl18XtnPOWhWpt7N76ZtzOme6GXcTT3R3wwR5nZp80s01mtknDmy8X8IxVAmNG6RwO1+0n9D+XiCSrC2+f5+KFNsZPik4CIz8/X1NIRGKgrq5uSPUvwvIKQr/vtDQd6aelpJsDBw7Q1tZGZWVlVPudUToHM1MhzxTVy6j3SBrpPkwbNmygo+NSV1IhHkrnVjJy9Bh2q5Bn1Aw1gdEUvmCCf8M/7zUCkWvEFAfbruLuD7n7CndfEa6Un8l27QoVXYrlCIy28+c4cfxoTPoXkehoPdUCoBEYIknu0KFDtI+aMuTC2FMLZgDQ0qRCnpmmqio0QyDaU0hGjR7DtKKZNBzYE9V+JWlopPswrVu3DsvKomLJtXE7Z3ZODhWLrmHXNo3AiJahJjCeAe4Pnt8PPB2x/feCOVqrgdMRU02kDzU1NYwbN46iotj8/9CM8EokBzWNRCSZtZ4IJzCGvwoJKIEhEgttbW0cPXqUvMKhf2bnFxQDpORKJJqrPzzhBEYsfrQqKptLg6aQZDyNdO/ZunXrmDVnAWPGjo/reectW0n9vhrOnTl9xXatDjk0A1lG9YfA68A8M2swsz8AvgzcbmZ7gduC1wDPAgeAfcB3gD+OSdRpqKamhvnz5w95Lm1/ZmglEpGU0HoylMCYOCU6I9OmTZtGc3MzHapKLxI19fWhH0GnTh96AmPKtALMjOYjqZfAQHP1h6W6upqysjLGjRsX9b5LZs/l6KGDXGq/GPW+JeE00n0Y2tvb2bBhQ1ynj4TNW3Yd7s7eHW/F/dzpKKe/Bu5+Xy+7bu2hrQMPDDeoTFRTU8Mtt9wSs/4nTslnzPgJKuQpkuRaTzYD0Z1C4u60tLQMebUEEbnSoUOhX8vCdSyGIid3BJPypqXkFBJ3X2tmpX006ZqrD2wws0lmVqhRuSFVVVVRr38RVjR7Lh0dlzhy6CAwJybnkIR5BviUmf0IWIVGug/Kli1bOH/+PPPiWMAzrHzhMrKzc9i97U0uT2KQoRp2EU8ZvjNnztDY2Mj8+fNjdg4z00okIingdDACY0KUiniGkxaaRiISPXV1dQDDmkICoQRIKk4hGYABz9XPtKHuFy9eZM+ePTFLYJTMDq1EomkkqaenUe9m9kdm9kdBE410H4b169cDMHfpirife9ToMZTOWxQkMGS4+h2BIbEX6wKeYTNK57Bl/a9ieg4RGZ7Wky2MGjOOEaOisz65Ehgi0VdXV4eZMWXa8BYAyCso5kDNtihFlZrc/SHgIYAVK1ak/VJpe/fupb29PepLqIYVzppNVna2CnmmoD5GvYf3a6T7MKxbt47Zs2czOW96r21iWYti3rLreOGpR2lra2NUlO7xMpVGYCSBWC+hGlZUOofWk82cPX0qpucRkaE7feI4E6fkRa2/cAKjqakpan2KZLq6ujpmzJhBTk7usPqZOn0GLU1H6OzsjFJkSWPAc/UzTXV1NUDMEhi5I0ZSUFyqBIZIBHdn/fr13HDDDQmLYd7S62i/eIHNmzcnLIZ0oQRGEqipqSEnJ4fy8vKYnie8Eklj7d6YnkdEhq71REvUViABJTBEYqGuro5Zs2YNu5+8giIutV/k6NG0W+Jcq9L1oqqqiqysrJhOGy6aPVcJDJEIe/bsobm5mTVr1iQshrlLQlNXwlNZZOiUwEgCNTU1VFRUkJs7vF9y+jNjVrCUqupgJLWelqczs781s0Yz2xo83p3IGCV2Tp9sjtoKJACTJ08mOzs7I6eQmNm8iGtmq5m1mtmfd2tzk5mdjmjzN4mKV1LHoUOHopPACGpohIuCpgrN1R+66upqysvLYzqEvGT2PJoaann77bdjdg6RVBJOGiQygTFh8lQKZ5UrgREFSmAkgZqamphPHwHILywmd+RILaWa/B6m5+Xpvubuy4LHs3GOSeKk9UQzE6I4hSQrK4tp06Zl5AgMd98dvmaAa4HzwE97aLou4tr6UnyjlFTT2dlJfX19lEZgFAOXi4KmCne/z90L3T3X3Yvd/Xvu/qC7Pxjsd3d/wN3L3X2xu29KdMzJorq6OmbTR8KKZ8/F3btqrIlkuvXr1zN16lTmzZuX0DjmLVnBq6++mo7TBuNKCYwEu3DhAvv372fhwoVR6/PxjYe6HpGysrMpnFmuERhJzt3XAicSHYfE36VLlzhz6kRUa2AATJ8+PSMTGN3cCux399T6pihJ58iRI7S3t0clgTG1YAaQegkMGZq2tjb27t0blwQGhKariEgogbFmzRrMLKFxzF16HSdPnuyqfyhDowRGgu3du5eOjo64jMAAtJRqavuUmW0PpphM7q1Rpi1Jl06am5txdyZOVgIjBu4FftjLvuvNbJuZPWdmPa5tqOtKwsLJhpkzZw67rzFjxzNm/AQlMDLErl276OzsjHkCY3pJKdk5uUpgiABHjx5l3759CS3gGTZ/2UpAdTCGSwmMBAtn4KI5AqMvRWVzaD7aSNvb5+NyPomabwPlwDLgCPDV3hq6+0PuvsLdV+TnR6+WgsReOMmgERjRZWYjgPcC/9HD7reAWe6+FPgG8J899aHrSsLCyYZojMCA0DQSJTAyQ6xXIAnLycllxqzyrvOJZLJwsuDcpDkxXSZ1IKYVzaSgoIB169YlNI5UpwRGgtXU1GBmcZuTNaN0Du7Okbr9cTmfRIe7N7l7h7t3EiqItjLRMUn0XU5gRPcLckFBAU1NTYSWkM9IdwFvuftVWRx3b3X3s8HzZ4FcM4tuBknSSvQTGEVKYGSIqqoqcnNzqaioiPm5isvnsmPHjpifRyTZrV+/nhEjR1E6P7aJw4EwM2644QaNwBgmJTASbOfOnZSWljJ69Oi4nK+oLPShqWkkqcXMCiNevh/QuNA0FF5KceLU6CYwpk+fzsWLFzl16lRU+00h99HL9BEzK7BgUqyZrST0udgSx9gkxdTV1TFlyhTGjRsXlf7CCYwMTjBmjKqqKubPnx/zVecgtBLJoUOHaG1tjfm5RJLZunXrmLNoOTk5sb/uBmLNmjXU1dVRX1+f6FBSVk6iA8h01dXVVFb2OOU6JgqKS8nOzqHh4N64nVMGJ1ie7iYgz8wagC8CN5nZMsCBWuAPExagxEw4gTEpSgmM8FDJ/WdzuvqfPLnX8ilpyczGArcTcc2El3oMVky4B/gvZnYJeBu41/VNUvpQV1fX4+iLoQ5Nziso4syZM5w6dSrjrs9MU1VVxfXXXx+XcxXPDo3s3blzJ6tXr47LOUWSTWtrK1u3buXu3/+TRIfSJVyLY926dVCeuGVdU5lGYCTQpUuX2L17d9zqXwDk5I5gekkpjUpgJK1elqf7aLAU3RJ3f6+7H0l0nBJ9TU1NjBw1mlFjxka133BCJBPrYLj7OXef6u6nI7ZFLvf4TXevdPel7r7a3V9LXLSSCnpLYAxVfmFqLqUqg3PmzBlqa2tjXv8irKQ8lMBQIU/JZK+//jqdnZ3MX5o8M6+XLFnChAkTVAdjGJTASKD9+/fT3t4e1xEYEFpeSwkMkeRz9OjRqE8fgctTUsIjPERkaNyduro6SktLo9ZnnhIYGWHnzp0AVFZW9rrcfTTlFRYzZswY1cGQjLZu3Tqys7OZs2h5okPpkp2dzTve8Q4lMIZBCYwECleHjtcSqmFFZRU0NdbR1tYW1/OKSN+OHj0a9RVIACZNmQbAkSMauCMyHC0tLZw7dy6qCYzwCIza2tqo9SnJJ5xIWLx4cVzOl5WVRWVlpUZgSEZbt24dy5cvj/rI1uFas2YN1dXVnDl9MtGhpCQlMBIoYQmM0gq8s5Ndu3bF9bwi0rcjR44waeq0qPc7dsJERowYoREYIsMUTjJEM4ExbuJkxo4dqwRGmtuxYwdjx46N6n87/Vm8eLFGYEjGamtrY+PGjV01J5LJjTfeCMCebZsSHElqUgIjgaqrqykrK4taJfOBCs+L1PrgIsnlyJEjTMqLfgLDzCgoKNAIDJFhCicZolkDw8woLS3l4MGDUetTks+OHTuorKwkKyt+t96LFy/m+PHjGVn/SOTNN9/kwoUL/MZv/EaiQ7nKddddx8iRI6nZsiHRoaQkJTASKN4rkIQVlIRWIlECQyR5tLW1cerUqZiMwAAoLCzUCAyRYYrFCIxwf6qBkb7cnR07dsRt+khY+HwahSGZaO3atQBJOQJj1KhRrF69mt1b30h0KClJCYwEaW9vZ/fu3QlJYOTkjqBgZpnmRYokkWgvodqdRmCIDN/BgweZNGkSkyZNimq/GoGR3pqammhubo57AmPJkiUAbN++Pa7nFUkGa9euZfHixUyZMiWq/UarCO+NN97Iwd1VvH3ubJQiyxxKYCTI3r17E7ICSVjx7HkagSGSRMLJhVhMIYHQCAwlMESG5+DBg0yaVhT1FSTKyso4ffo0J0+qoFs6CicQli5dGtfz5ufnU1BQoBEYknHa29t59dVXu2pNJKMbb7wR7+xk97Y3Ex1KylECI0HiXY26u5LyuRw4cICzZ5X1E0kGlxMY02PS/4wZM2hpaeHChQsx6V8kE9TW1nYtexpN4SkpKuSZnsIJjETc8y1ZskQjMCTjbN68mXPnznHTTTclOpReXX/99WTn5LJry8ZEh5JylMBIkKqqKrKzs5k/f35Czl9SHjpveF1yEUmsw4cPAzA5hgkMQHUwRIbI3amtrSV/RknU+y4rKwPQNJI0tX37doqKipg6dWrcz71kyRKqq6u5dOlS3M8tkiivvPIKQFKPwBg7diyzFyxRIc8hUAIjQXbs2EFFRQWjRo1KyPmLZ8/rikNEEq+xsZHc3FzGT4ruXM2wcAKjsbExJv2LpLumpibefvttpimBIYO0bdu2rnoU8bZkyRIuXLjAnj17EnJ+kUT49a9/zcKFC5k2LTbTcqNl4TWrOVCznbbz5xIdSkpRAiNBElGNOtK0opmMGTNGCQyRJHH48GEKCwtjtsReUVFR13lEZPAOHDgAhD4/o23y5MlMmjSp6xySPi5evEhNTQ3Lli1LyPnDdTe2bduWkPOLxFt7ezvr169PyuVTu1twzfV0dnSwZ/umRIeSUpTASIAzZ85w4MCBhGXjAbKysli0aJHmRYokiXACI1Y0AkNkeMKjI/ILoz8CA0KjMDQCI/3U1NTQ3t4e9wKeYfPnzyc3N1cJDMkYmzZt4uzZs9xyyy2JDqVfFUuuJTsnl52bX090KClFCYwECC9fmsgERvj827dvx90TGoeIQENDA8XF0S8OGDZ16lRGjBihBIbIEIVHR8QqgTF79myNwEhDW7duBeK/AgmElnt8astRCksruuIQSXe/+tWvAJK6gGfYqNFjmLNoOdWbX0t0KClFCYwECGfBE5WND1u67Qvf2AAAIABJREFUdCktLS0aUp5kzOz7ZnbMzKoitk0xsxfMbG/w7+RExijR19jY2DXNIxbMjKKiooxLYJhZrZntMLOtZnbVGE0L+bqZ7TOz7WZ2TSLilOS3f/9+ZsyYwYgY1a6aPXs2Bw8epKOjIyb9S2Js3bqV0aNHU1FRkbAYZlUsVAJDMsbLL7/MkiVLyMvLS3QoA7Lw2us5uGsHp0+fTnQoKUMJjATYvn07EyZMYObM6M+jHYzwCBANK0w6DwN3dtv2OeAld68AXgpeS5pobW3lzJkzMR2BAVBcXExDQ0NMz5Gkbnb3Ze6+ood9dwEVweOTwLfjGpmkjP3791NeXh6z/svLy7l48WLGJRnT3ZYtW1iyZAlPbGrk8Y2HeHzjobjHUDqvkqampq7lukXSVVtbG6+++mpKTB8Jq7z2HXhnZ9fKKdI/JTASYOvWrSxduhQz69oW/lCL5webEhjJyd3XAie6bb4beCR4/gjwvrgGJTEV/sISyxEY4f715egqdwOPesgGYJKZxa4YiaSkxzceomrXHmxCQczOEU6O7N+/P2bnkPjq7Oxky5YtXHNNYgd2zZpbCYSSKSLp7LXXXqOtrY3bbrst0aH0qvt3vjmLljNy1GheeumlBEeWOpTAiLOOjg62b9/O8uXLEx0KkyZNoqysTMMKU8N0dw//dHIUmJ7IYCS66uvrAeI2AiPD6t448LyZbTazT/awvwioj3jdEGwT6XKh7W1ONR9jWlFs6l+AEhjp6ODBg7S2tib8nm/W3IUAvPXWWwmNQyTWXnzxRXJycrjxxhsTHcqA5Y4YybxlK3nxxRcTHUrKUAIjzvbv38+5c+cStpxWd8uWLVMCI8V46Ntnr99AzeyTZrbJzDYdP348jpHJUIUTGCUlsftyFO7/woULZNh/F2vc/RpCU0UeMLMh3dXouspsxxpDv5QVlJTF7BwlJSXk5uYqgZFGwiMeEp3AGDN2PHPmzFECQ9LeCy+8wOrVqxk/fnyiQxmURdetoaamJlOn+Q6aEhhxFk4WJFMCY+/evZw9ezbRoUjfmsLD2oN/j/XW0N0fcvcV7r4iPz8/bgHK0NXX13cV2YylcIIknDDJBO7eGPx7DPgpsLJbk0YgMnNUHGzr3o+uqwx2tD60vOn04tKYnSMnJ4eysjL27t0bs3NIfG3evJnc3FwWL16c6FC49tprlcCQtNbS0sLmzZuTevpIbxavvAFAozAGaFgJjJ6qu2u1hL5t3ryZESNGUFlZmehQALjmmmtwd43CSH7PAPcHz+8Hnk5gLBJl9fX1FBQUMGLEiJieJ1w4OFMSGGY21szGh58D7wKqujV7Bvi9YDWS1cDpiOlaIgA0NdQCML14VkzPU1FRwb59+2J6DomfTZs2sXjxYkaOHJnoULj22mupq6ujubk50aGIxMSLL76Iu3PHHXckOpRBK5kzn4KCAn75y18mOpSUEI0RGN2ru2u1hD5s3ryZxYsXx/yLykBde+21QCguSQ7/j737jpOqvv4//jrsUpfee2/SO6h0aSoCChIkdo0Su1ETjX7Vn8ZuDDFiDBqDxoKKChjBBQUUEFj6AkvvVarI0lnO7497B4dl+87MvTN7no/HPPbOnTtz33dmPntnznzu54rIx8A8oImI7BCR24AXgb4ish7o4143MWL79u1hP3wECmQPjCrAHBFZDiQBX6vqNyIySkRGuctMATYBG4C3gbu8iWr8bM/2LZQqW56EUmXCup6GDRuyfv36gjZOTUxSVRYvXnzuc5bX7PNedBCRASKy1j219wXfoUTkZhHZ5/54vExEbvcipx998803lCtXjo4dOwLenCAhr0SE/v37M23aNDuVdg6E4xASO1tCJlSVJUuWeD4adbBq1apRrVo126H5iKpep6rVVLWwqtZU1X+r6gFVvUxVG6lqH1VNf5YSE8VWrt0IJSuGfSdbqVIlihUrxtatW8O6Hr9Q1U2q2tq9NFfV59z5b6nqW+60qurdqtpAVVuq6iJvUxs/2rNtc1jHvwho3Lgxx44dY9euXWFfV37Yl6zsbdq0iUOHDtGhQ0Znb468wGfPRYvsX5xfiUgcMAZnzKZmwHUi0iyDRT9xfzxuo6rvRDSkT6kq06ZNo2/fvsTFxXkdJ0/69+/PwYMH7TtZDuS3gJHR6O45OltCQRwQbfPmzRw6dMg31fiA9u3bW2MxxiOqyv6fdlKpWnjPQAJOhb9OnToFpoBhTKjs3r6JarXrh309jRs3BmDdunVhX1de2ZesnElKSgKgU6f0w+54o2zZsjRp0uRcLuNLnYANbvH9FDAe54dhk43k5GR27dpF2cYdo6bXRXp9+/ZFRJg6darXUXwvvwWMLEd3z+psCQVxQLSFCxcC+K5rU8eOHVm9ejVHjhzxNIcxBdHevXs5ffIkFauGdwDPwP+aImWrWAHDmFw4cuQIP+/fS7U64S9gNGnSBPB3AQP7kpUjSUlJFC9e3DdjnoFTTFmwYIEdouRfOT2t91ARSRaRCSKS4fGnBe2H4q+//hqA1hf39DZIPlSsWJEuXbqc2xaTuXwVMDIZ3T3HZ0soaJKSkihatKgvRqMO1rFjx3PHahpjImvLli0AVKwa/h4YznpqnFunMSZ7a9euBaBaBA4hqVGjBiVKlGDNmjVhX1c+hOxLVqzI6AeppKQk2rVrR+HChT1Mdr5OnTrx008/FaRxkGLRV0BdVW0FTOfXw/bPU9B+KJ4yZQrt27enbIXKXkfJlyuuuIKFCxfy008/eR3F1/JcwMhidHc7W0ImFi5c6LudGfzaIyTQQ8QYEzmbNzunZ6xUPTKf7ytVr8W+ffvs1MnG5FCgmFC9bsOwr6tQoUI0adLE7wWMnMjRlyyIzV+KT506xeLFi31z+EhA586dAViwYIHHSUwmsj2ttzsm2kn36juAv45L98CBAweYN28eV155pddR8i2wDXYYSdby0wMjw9HdsbMlZOjMmTMsXrz4XLHATypWrEj9+vVth2aMB84VMCIwBgZAZbdQYr0wjMmZNWvWUCguLuynUA1o2rSp3wsYIf2SFYu/FC9btoyTJ09y8cUXex3lnI8WbGP1yXIULlqUH3/80es4JmMLgUYiUk9EigAjcH4YPifQy901CFgdwXy+ENzj6aMF2/j66685e/YsV111ldfR8q1NmzbUrFmTyZMnZ79wAZbnAkYWo7vb2RIykJyczLFjx3y1MwvWpUsX5s2bZ8dFGhNhmzZtonS5ihQrkRCR9VWuXvvceo0x2Vu9ejVVatQhvnBkTn/etGlTtm7dyrFjxyKyvjywL1nZmDdvHoDvPvPFFy5C/aatzuUz/qKqZ4B7gEScNvOpqq4SkWdEZJC72H0issr9Afk+4GZv0vrHxIkTqVGjhu9OkpAXIsKgQYNITEzk+PHjXsfxrXCcRtVkwK87s4CLL76YXbt22XGRxkTYpk2bInb4CPx6qIoVMIzJmZSUFGrUaxSx9TVr1gxV9W0vDPuSlb0ff/yRWrVqUbNmZHrW5UbDFu1YsmSJfTnyKVWdoqqN3VN7B34cflJVJ7vTj7k/HLdW1V6q6s9/FBFy6sQJEhMTGTRoECLidZyQGDx4MMeOHePbb7/1OopvWQEjQubNm0fVqlWpXbu211EyFCisWFXemMjauHEjVSPUNR2gVNnylC5dmo0bN0ZsncZEq5MnT7J+/fqIFjACZ61YtWpVxNaZW/YlK3OqyuzZs+natavXUTLUpHVHTp8+beOemZiQnPQDx44dY8iQIV5HCZmePXtSpkwZvvjiC6+j+JYVMCLgowXbSPzue2o3a+fb6mDr1q1JSEhgzpw5XkcxpsA4efIk27Zto0rNuhFbp4jQsGFDNmzYELF1GhOt1q9fT1paGjXrN47YOhs2bEjhwoV9XcAwmdu8eTO7d++mW7duXkfJUOPWHQDs856JCQtnTqVcuXL06tXL6yghU6RIEQYNGsSkSZM4ffq013F8yQoYEXDgp13s37ODJq39NRp1sPj4eC6++GJmz57tdRRjCozNmzejqhEbHDDAChjG5MyKFSsAqFkvcgWMwoUL07RpU1auXBmxdZrQCXyO8msPjFJlytG8eXN++OEHr6MYky9nTp9iyexvGTJkiO/O8Jhfw4YN49ChQ8yYMcPrKL5kBYwIWLvc6abXtI3/zkASrFu3biQnJ/Pzzz97HcWYAmHdunUAVKlVN6LrbdSoEZs3b+bUqVMRXa8x0SY5OZn4+Hiq120Q0fW2bNmS5OTkiK7ThMbMmTOpUKHCuUOB/KhHjx7MmTPHft01US15/g8cS/2FYcOGeR0l5Pr160epUqX49NNPvY7iS1bAiIDVS+ZTomRpaje8yOsoWerevfu5YzeNMeG3du1aAKrXjuyXo8aNG5OWlmYDeRqTjeTkZC666KKInYEkoFWrVmzfvp1Dhw5FdL0m/2bNmkXPnj0pVMi/H7F79erF0aNHWbRokddRjMmzH6dNomSZcvTt29frKCFXrFgxrr76aj7//HNOnjx53mljjRUwIiJl8TyatulEobg4X78Bu3TpQtGiRZk5c6bXUYwpENauXUvlypVJKF0moutt0qTJufUbYzK3bNkyWrVqFfH1tm7dGoDly5dHfN0m7/bu2sbWrVvp2bOn11Gy1KNHDwDrnm6i1onjx1gyezqde18Zc4ePBIwcOZLDhw8zZcoUr6P4jhUwwmzHjh3s2b6ZZu39efrUYMWKFeOSSy6xHZoxEbJmzZpzxYRICqxz9erVEV+3MdFi79697Nq1i7Zt20Z83W3atAFg6dKlEV+3ybuVSc7AmH369PE4SdYqVapE69at7TSNJmotnPUNJ08c55L+g72OEjaXXXYZlStX5oMPPvA6iu9YASPMpk+fDkCzDpd4nCRrgV4hFRu3Z/ny5ezdu/e8+X7sMVIQicgWEVkhIstExPp+RjFVZdWqVZ4cJ122bFmqV69OSkpKxNcdSSJSS0RmikiKiKwSkfszWKaniBx229QyEXnSi6zGfwLFg0gUMNLva6tWrUrVqlWtgBFlkhf8QK1atTwpTOdWv379mDt3LqmpqV5HMSbXfvjfp1SuUZsmrf09vmB+xMfHc/311/PVV19x5OeDXsfxFStghEHwB5G3P55I2QqVfD/+RUDLzt0BrCrvb71UtY2qdvA6iMm7PXv28PPPP3s20Fvz5s1jvoABnAEeUtVmQBfgbhFplsFys9021UZVn4lsRONXixcvBqBdu3aerL99+/bnMhj/SztzhlWL5tK3b19ExOs42erXrx+nT59m1qxZXkcxJlf27dpOyuJ5dL9yWFS0tfy4+eabOX36NHMTJ3odxVesgBFGZ9PSWJE0mxadukVNA6vXpAUVKlTgm2++8TqKMTFt1apVADRrltH36fALFDDS0tI8WX8kqOpuVV3iTh8BVgM1vE1losWX036gaq16TFn7iyfr79ixI6tXr+bIkSOerN/kzvqVSzh25BeuuOIKr6PkSLdu3UhISLDj603UmTl5PFKoEN2uiL2zj6TXsmVLOnTowMxJH6OqXsfxDStghNGGVUtJPXyINpf09jpKjhWKi2PAgAFMnTo1pr/YRDEFponIYhG5I6MFROQOEVkkIov27dsX4XgmpwKD83kxQGBgvcePH2fjxo2erD/SRKQu0BZYkMHNF4vIchGZKiIZdomxdlWwqCobU5ZR/yJv2ic4BQxVtV4YUWLZ3BnExcVzqFzTqDj0tmjRovTp04evv/7avhiZqHH69Gm+/+oT2lzci4pVnd8jYv1w91GjRrFj0zrWLbcjxwOsgBFGS+fOoFBcHK26dPc6Sq4MHDiQ/fv3k5SU5HUUc6GuqtoOuBynO/wFby5VHauqHVS1Q6VKlSKf0OTI8uXLqV69OhUrVvRk/QXpLAciUhL4HHhAVdP/nL4EqKOqrYF/ABn207R2VbBs376dQ/t+omGLyA/gGdC5c2cA5s2b51kGk3OLf5hG07adKZFQyusoOXbVVVexbdu2ArEfMLFh4sSJ/HxgH72v/q3XUSJmxIgRFE8oxfQv3vc6im9YASOMFn2fSJPWHUkoFdlTJOZX//79iY+PZ+JEO97Kb1R1p/t3L/Al0MnbRCavli1bdq6I4IVmzZoRHx/PsmXLPMsQCSJSGKd48aGqfpH+dlX9RVVT3ekpQGER8aaqZHwjUDRo3Mq7oYYqVKhAkyZNrIARBXZt2cCurRvp0LP/efP9+stwINOp6m0pVKgQX375pdeRjMmRv/3tb1SpWYc2F/f0OkrYBdrppJUH6HnVcJK+m8LBvXu8juULVsAIk52b17NrywY69brc6yi5Vq5cOXr37s3nn39u3Qp9REQSRKRUYBroB6z0NpXJi2PHjpGSkkKHDt59OSpWrBgtWrSI6e7p4gw+9G9gtaq+lskyVd3lEJFOOPvFA5FLafxozpw5FC1egloNm3qa49JLL2Xu3LmcPXvW0xwma0kzpwLQvns/j5PkTpnyFenatSsTJkzwOoox2Zo/fz7z5s2j37W3UCguzus4IRdc8Exf9Ow3/GbO6lmmfTbOm3A+YwWMMEma6QyK1KHHAI+T5M2wYcPYuHEjW9et8jqK+VUVYI6ILAeSgK9V1UZbjULLly8nLS2N9u3be5qjffv2LFq0KJYLlZcCNwC9g06TeoWIjBKRUe4yw4CVbrt6HRihMfyEmJz54YcfaNSyPfHxhT3N0b17dw4ePFgQzhgU1eZNn0yT1h2pULma11Fybfjw4aSkpLBypf0eYvztxRdfpFy5cvQYeK3XUSKucvXadOp1Od9+8QE///yz13E8ZwWMMFBV5iZOomnbzpSvXNXrOJnKqmvj1VdfTXx8PD9Om+RBMpMRVd2kqq3dS3NVfc7rTCZv5s+fD0CnTt4eAdS5c2cOHDgQswN5quocVRVVbRV0mtQpqvqWqr7lLvOG255aq2oXVf3R69zGW/v372fFihU0beP9EXrduzvDHM2cOdPjJCYzycnJ7Ni0jov7DvI6Sp5ce+21FCpUiI8++sjrKMZkauXKlUyaNIn77ruP4gklvY7jiUE33sXxo0cYM2aM11E8ZwWMMNi8ZgW7t27k0v5DvI6SJx8t2Ma0jcdo2bkHP06bzFk7G4kxITVv3jzq1KlDtWre/lrXpUsXAH780b6zGxMwY8YMVJUWnbp6sv7gHxfm7Y2jfv36fPvtt55kMRkLfo0efeF14uIL06XPQK9j5UnlypXp378/77//vp19zvjWk08+SalSpbjvvvu8juKZuk1a0PbSy/jrX/9a4HthWAEjDL7/6hMKFy1K595Xeh0lX7pdOZRD+/aQvOAHr6MYEzNUldmzZ3PppZd6HYVmzZpRpkwZ5syZ43UUY3wjMTGRMmXKUL+pd6dQDda3b19mzJjBqVOnvI5i0jlz+hRzEyfSrutllCpb3us4eXbLLbewc+dOpk+f7nUUYy6QlJTEl19+ycMPP0z58tHbzkJh2J0PcejQIV555RWvo3jKChghlpqaytzESXTqdQUJpaPr7CPpte/Wl9LlKjBjonUrNCZU1q1bx549e+jRo4fXUYiLi6Nbt27MmjXL6yjG+MLZs2eZMmUK/fv3Jy4+3us4AFxxxRWkpqYye/Zsr6OYdJJmTuWXQwfoNfg6r6Pky6BBg6hcuTJvvvmm11FMAZTVIe2qyh/+8AcqV67Mgw8+6EE6f6nbuDkjR47ktddeY+vWrV7H8YwVMELsv//9L8ePHqHPNdd7HSXf4gsXoeegESyZ8y37dm33Oo4xMeG7774DoFevXh4ncfTu3Zv169ezbZvzwcGvp/0zJhIWLlzInj17GDjQP4cDXHbZZRQrVoxJk2xMKr+Z9tk4qtSsQ8vO3b2Oki9Fixbl9ttv53//+x+bNm3yOo4x53z88cfMnTuX559/nlKlSnkdxxdefPFFRISHH37Y6yiesQJGCKWlpTF69GjqX9SKRi29PbtAqPQZegMiwjefvOt1FGNiQmJiIvXq1aNhw4ZeRwGgXz/ntH+JiYkeJzHGe8/+4z/ExRfmRNU2Xkc5Z9LKA7To3IMPxn9mp1P1kbXLF7J+xRIGjLiNQoWi/+P03XffTXx8PH/961+9jmIMAAcOHOCBBx6gY8eO3HzzzV7H8Y1atWrx+OOPM2HCBL766iuv43gi+v/j+siECRNYt24dA28YhYh4HSckKlSuxqX9hzBj4kfs3bvX6zjGRLVjx44xffp0rrjiCj5O2u6Lng7NmjWjTp06BXYnaEzA2bNnmTd9Mi07dfXdIaCdL7uSQ/v22GEkPvLlu69Tqmx5egwc7nWUkKhevTo33ngj//73v9m5c6fXcUwBp6oMHHELBw8e4pr7niUuLs7rSL7yyCOP0KJFC+68804OHDgQkseMph64VsAIkTNnzvDUU0/RrFkzOva83Os4ITXoprs5ffoUL7zwgtdRjIlqiYmJHD9+nMGDB3uaI3gn9XHSdgYNGsT06dM5cuSIp7mM8dKMGTM4uHc3XS+/xusoF2jfvR/FSiQwbtw4r6MUWMH/N1cvmc+KBT9w1Q2jKFqsuNfRQubxxx8nLS2NZ5991usopoB7//33mf/tVwz93YPUbnSR13F8p0iRIrz//vvs37+f22+/HVX1OlJEWQEjRP71r3+xdu1ann/++ZjoShisep0G9Bg4nDfffJN169Z5HceYqPXxxx9TqVIl34x/EVCuRQ9OnDjBH199x+soxnjmrbfeomSZcrTv3s/rKBcoWqw4l/QbzCeffMKhQ4e8jlOgnU1L44PRz1ChSnX6DL3R6zghVa9ePUaNGsXbb79NcnKy13FMAbVkyRJGjRrFRe26cNUNv/c6jm+1bduWl156iYkTJ/Liiy96HSeiYuubtkd27drFHx/9My06diW1in+Omw2la+98iGLFinHXXXcVuCqfMaFw4MABJk2axHXXXUe8T85uENCoZXsq16jN9//71Osoxnhi8+bNfPnll/S86jcUKVrM6zgZ6jv0Ro4fP85bb73ldZQCLfHT/7Bl3SpG3vt4TPW+CHj66acpV64cd955J2lpaV7HMQXMtm3bGDhwIJUqVeLev4yhkB06kqUHHniAESNG8Oc//5lPPy04n+GsgJEPHy3YxgfztnD50JGcOX2Kmx95NmbGvkivbIXKDPv9o3z33Xfc8se/RMXxUcb4ydixYzl16hS/+93vvI5ygUKFCtFr8HWsXjKfbRvWeB3HmIj6aME2br3/MQrFxdN/+C1ex8lU7UYX0b9/f1577TU73MsjOzat45O3XqbNpb3pfNmVXscJiwoVKvD3v/+d+fPnF7hfdY23DuzdTadLe3D4yFHufvHflClf0etIvhR8OJuI8O6779K1a1euv/56Jk+e7HW8iLACRj5NGvcPkud/z8h7H6da7fpexwmr3kNG0uaSXnz497+wfsVir+MYEzWOHj3K6NGj6du3Ly1atPA6ToZ6Dx5J0eIlmPzeGK+jGBN2wR8At61fzfdff0afa66nfOWqXkfL0jPPPMP+/fttTCoPHP3lMKMfvZPiJUpxx59fjtkfrABGjhzJiBEjePLJJ5k2bZrXcUwBsGPzOv7fHUM5fHA/fxz9HrUaNPE6UtQoXrw4X331FW3btmXo0KG5GispmgbuDOavfsxRZtbk8UwY+xpdL7+GPkNv8DpO2IkIo576G0/dNpi/PnI7wy5uTPPmzQFy9MYf2bl2uCMa40svv/wye/fu5dLhv/ftTqJkmbIMGH4Lk94bw4Df3ErDFm29jmRMrmXWvjLb/5w5c5q3X/gTJUuX5epb7w9ntJDo1KkTN954I6+88grDhw+nTZvYPGzVLwLvp+NHU3nloVvYu2s7j7/xMWUqVPI4WXiJCG+//TYpKSkMHTqU6dOn06VLF69jmRgS/L963vTJvPPCoxQtVoIn3hxPvaYtPUwWncqWLcv06dMZOnQot9xyC4sXL+bll1+mePHYO8wNrAdGnqgqL730Em8//ydadenB7/78UkxX4oOVKlOOP772HnHx8fTo0cNO6WZMNpYsWcILL7zAyJEjadSyvddxsnTVjXdRrlIVxj73CCdPHPc6jjFhpap8OPpZNqUs55Y//oWSZcp6HSlHXnvtNSpVqsSwYcNCdvq8giD4l8bcFJIP7t3Dc3ePYGPKMu555nWatOkYxpT+UbJkSaZOnUqVKlXo06ePnWrbhNz+PTsZ/dgo3vi/e6nVoAnPjvsq0+JFtPYUiKTSpUszZcoUHnzwQd544w3atm3Ld99953WssLAChiunO7Zt27Zx1VVX8eijj9L5soE8+NJY4gsXiWBS71WtXY8n35pA+fLl6dWrF0899RSnTpzwOpYxvrNlyxaGDBlC1apVef31172Ok63iCSW584m/smvLBsY8eR+nTp06d5t9eDDRLP0+/uzZs4wf8yLTJrzH5SNuo3Pv6BnPoEKFCkyYMIEdO3bQt29f9uzZ43WkmBJ4j3w4fytzEyfy2A0D2L1tEw++9Dadel/hdbywSt9OqlevzuzZs2natCmDBg3i3nvv5fDhw17HNFFuw4YNjHv1/3jo2p4s+3EGw0c9wv/98zMqVK7mdbSoV7hwYV577TUSExM5deoUffr0oW/fvkyfPp2zZ8+GfH1efTYM2yEkIjIA+DsQB7yjqr4bCSinT7aqsmLFCt566y3e+fe7iAg3PPg0/YffXGB6XqRXpWYdFi5cyN13380zzzxDuX+O5fIRt9J1wDWZdq3M6vm2w0tyJhralXFMnTqVW2+9lRMnTjBz5kwqVKgAG456HStbLTt348aH/h/vvfokffr0Ydy4cdSvH73j+2TXZkSkKPA+0B44APxGVbdEOqfJu9x+cNqxeR3v//VpVi2ay2VXX8/I+54IU7LQO7etcTWZOHEiQ4cOpU2bNowePZrhw4dH9DTuXret4Nc9+DNEZvNz+lgnjh1l4feJfPOPEH2eAAAgAElEQVTxO2xZt4r6zVrz+ydfo3rdhiFIHX2qVavG7NmzGXLTXYwZM4Zx73/Ag/ffy6233krdunW9jhdzvG5X4aCqrFmzhsTERL744gtmz55NXHxhul1+DVffdj8Vq9bwOmLUyuz/Xb9+/UhJSWHMmDG88sor9OvXj0rVa9G595U88rvr6Ny5M0WLFvUickhIOE6JKSJxwDqgL7ADWAhcp6opGS3foUMHXbRoUchzZCcnH3pWL13Ax68+xsaNGylSpAgX9x/CNbc9YI0tSMrieXzxzmhWL52PFCpEw+ZtefT1DyhWvESOHyO/Hz48FLEKVm7bFXjXtgqyjxZsY+43X/Lm0w9QvU4D7n/hLWrWb+x1rFyb+82XvPvy46SlnWH0F3MoW6Hyudsya6/pb8uHkLSrnLQZEbkLaKWqo0RkBHC1qv4mq8e1duWNnHxhzcrxo6mMfmwUK5NmUzyhFCPvfZxeg0dE7Q8RIzvXZsWKFdx0000sXbqU+vXr869//Ys+ffpkdpeQbagf2lZ+f/FL/x46euQw/3jiHtYsW8DpkyepVqcBV93we7pdfo2dytG1ec0KvnhnNEvnfoeq0qpVK1566SUGDBjgdTSv2T4rA7t37+bmm29m8eLF5w53a968OSNHjqRM676Uq1gl4pliWWb7xdOnTpI0Ywqzp37BqkVzOZuWRuEiRand8CKG3HIv7bpduM/IS/E3s/vk43tdpu0qXD0wOgEbVHUTgIiMBwYDmX7R8qsKVarRpEkTHn74YYYNG8a0jce8juQ7zdpfTLP2F7Nj8zoWfPs1u7ZuzFXxAjL/IJLbAdlinCftKpQFpXAVp8KVMa869BzADQ8+zWVXj6RwkeiscF864Gouancxy+fNPK94AVk/Rz5rszlpM4OBp93pCcAbIiIajuq+ybXc7huyUqxEAkWKFOWa2x+k37AbKVW2fH7jea5ly5YsXLiQCRMm8M9//pOqVSN2FpWob1vp30MlSpYm7cxpLhvyWzr0HECT1h0j2qMlGtRr2pKHXv03+3ZtZ8GMr1k+bxbztx/jYBgGco/Uj1k++9Es6ttVsGkbUlm/bTctLrmMRi3a0bzjpVSu7vlzHLMy2y8WLlKUSwdczaUDrubokcOsXjKftcsXsnn1ikyLs/ltFzndd+e1zYWrB8YwYICq3u5evwHorKr3BC1zB3CHe7UJsDaHD18R2B/CuF6I9m2I9vwQum3Yr6oR+ekhJ+3KnZ/XthUJfnvvWJ6seZUnJO0qh/uile4yO9zrG91l9qd7LD+1K7+9T8KpIG0rhHd7Q7a/iuG2lVux8P60bcg/22d5x+vX3isFYbszbVeenUZVVccCY3N7PxFZpKodwhApYqJ9G6I9P8TGNmQmr20rEvz2vFuerPktj5f81K4K0utSkLYVCt72gr/aVm7Fwutl2xCborld5UZBfe0L6nYHhKtv3E6gVtD1mu48Y0zeWbsyJndy0mbOLSMi8UAZnIHRjDGZs7ZlTOhZuzImB8JVwFgINBKReiJSBBgBTA7TuowpKKxdGZM7OWkzk4Gb3OlhwAw/HktsjM9Y2zIm9KxdGZMDYTmERFXPiMg9QCLOaYDeVdVVIXr4WOgOFe3bEO35IQq3IcztKlL89rxbnqz5LU+uZNZmROQZYJGqTgb+DfxXRDYAB3E+MPpdVL8uuVSQthWiZHtjuG3lVlS8XtmwbfAJa1d5EhOvfR4U1O0GwjSIpzHGGGOMMcYYY0wo2fmhjDHGGGOMMcYY43tWwDDGGGOMMcYYY4zv+aqAISIDRGStiGwQkUczuL2oiHzi3r5AROq68yuIyEwRSRWRNyKdOyhfXvP3FZHFIrLC/ds70tmDMuZ1GzqJyDL3slxEro50djdHnvIH3V7bfR89HKnMsSAHz/sfRCRFRJJF5DsRqRN0W1rQeyckg5LmIM8ot70tE5E5ItIs6LbH3PutFZH+XuYRkboicjzo+XkrEnmClhsqIioiHYLmhfz5MRfKz2sUjXKyvSIy3P0/skpEPop0xlDKwf+E2u7nmqXu/80rvMhpHCLyrojsFZGVQfOudd+LZ6Oh/WWyDa+IyBr3PfaliJT1MmN2MtmGZ938y0RkmohU9zKjCZ+C+vpntN1Btz3kfgao6EU2z6iqLy44g9VsBOoDRYDlQLN0y9wFvOVOjwA+cacTgK7AKOCNKMzfFqjuTrcAdkbhNpQA4t3pasDewPVoyB90+wTgM+BhL16DaLzk8HnvBZRwp38f/LwDqR7kKR00PQj4xp1u5i5fFKjnPk6ch3nqAisj/fy4y5UCfgDmAx3C9fzYJbSvUTRecthGGgFLgXLu9cpe5w7z9o4Ffu9ONwO2eJ27IF+A7kC74P/HwEVAE2BWNLS/TLahH79+dnsJeMnrnHnYhuD95324n/HsEnuXgvr6Z7Td7vxaOAO+bgUqep0zkhc/9cDoBGxQ1U2qegoYDwxOt8xg4D13egJwmYiIqh5V1TnAicjFvUB+8i9V1V3u/FVAcREpGpHU58vPNhxT1TPu/GKAF6PD5jk/gIgMATbjvAYm57J93lV1pqoec6/Oxzm3uZd5fgm6msCv79fBwHhVPamqm4EN7uN5lSccctJOAJ7F+UAb/H81HM+PuVB+XqNolJPt/R0wRlUPAajq3ghnDKWcbK8Cpd3pMsAujGdU9QecMz4Ez1utqms9ipRrmWzDtKDPbuHeN+dbJtsQyf2n8VBBff0z2m7X34A/EoPbnB0/FTBqANuDru9w52W4jPsP9zBQISLpsheq/EOBJap6Mkw5s5KvbRCRziKyClgBjAraKUZKnvOLSEngT8D/i0DOWJOT5z3YbcDUoOvFRGSRiMx3i0gRySMid4vIRuBlnKp9ju8bwTwA9dxu5N+LSLd8ZslRHhFpB9RS1a9ze18TEvl5jaJRTt5XjYHGIjLX/V8xIGLpQi8n2/s0cL2I7ACmAPdGJpopwG7l/H1z1BCR50RkO/Bb4Emv85jIKoivv4gMxumxv9zrLF7wUwGjwBOR5ji/pt3pdZa8UNUFqtoc6Ag8JiLFvM6UC08Df1PVVK+DxDIRuR7oALwSNLuOqnYARgKjRaRBJLKo6hhVbYBTuHoiEuvMQ57dQG1VbQv8AfhIREpn9hihICKFgNeAh8K5HpN3BfQ1isc5jKQncB3wtt+P18+n64BxqloTuAL4r/u6GxNyIvI4cAb40OsseaGqj6tqLZz893idx0RWQXv9RaQE8GcKSLEmI37aGe7EOZYnoKY7L8NlRCQep1vlgYiky16+8otITeBL4EZV3Rj2tBkLyWugqquBVJzxPCIpP/k7Ay+LyBbgAeDPIhLz/wRDJCfPOyLSB3gcGBTcw0hVd7p/N+EcS9w2EnmCjAcCPT9ye9+w5nEP1TjgTi/GOW6+cZjzlMJpu7Pc9tAFmOwOUheO58dcKD+vUTTKyftqBzBZVU+7hy+twyloRKOcbO9twKcAqjoP59DMgjVIm4kIEbkZGAj8VlWjvSv6hzg9mU3BVFBe/wY445Atdz8D1ASWiEhVT1NFkJ8KGAuBRiJST0SK4AywmP6MBJOBm9zpYcAMH/2zzXN+91ekr4FHVXVuxBJfKD/bUM8tCCDOGSaaAlsiE/ucPOdX1W6qWldV6wKjgedV1bMz2kSZbJ93EWkL/AuneLE3aH65wHgv7gjKlwIpEcgT/MXnSmC9Oz0ZGCHO2Wrq4XxBSvIqj4hUEpE4d7q+m2dTOPOo6mFVrRjUHubjvG6LCM/zYy6Un9coGuXkf/dEnN4Xgf8Vjcl/W/BKTrZ3G3AZgIhchFPA2BfRlCbmuYdi/RHn/8ex7Jb3o3T7z8HAGq+ymMgriK+/qq5Q1cpBnwF2AO1UdY/H0SInJyN9RuqC001yHc6vjI+7857B+ccKzg78M5yB45KA+kH33YIzwEkqzgt5wYjtfs2P0138KLAs6OLJCOv52IYbcAa/XAYsAYZEU/50j/E0dhaSUD/v3wI/Bb2/J7vzL8EZM2W5+/e2COX5e9D7dSbQPOi+j7v3Wwtc7mUenF8SgtvVVZHIk27ZWQSNsB+O58cuoX2NovGSgzYiOIfNpLj/K0Z4nTnM29sMmOv+b1wG9PM6c0G+AB/jHNJ3Gucz5m3A1e70SXf/luh1zjxswwac8VgC+2Zfn8Ehk234HFgJJANfATW8zmkXe/3Dvd3pbt9CATsLibgbbowxxhhjjDHGGONbfjqExBhjjDHGGGOMMSZDVsAwxhhjjDHGGGOM71kBwxhjjDHGGGOMMb5nBQxjjDHGGGOMMcb4nhUwjDHGGGOMMcYY43tWwDDGGGOMMcYYY4zvWQHDGGOMMcYYY4wxvmcFDGOMMcYYY4wxxvieFTCMMcYYY4wxxhjje1bAMMYYY4wxxhhjjO9ZAcMYY4wxxhhjjDG+ZwUMY4wxxhhjjDHG+J4VMIwxxhhjjDHGGON7VsAwuSIiD4hIiWyW2SIiFdPNKyIio0Vkg4isF5FJIlIz6PbHRWSViCSLyDIR6RyubTBGRKqLyIQQP2ZdEVmZy/vcLCLVg66/IyLNQpkr3fpSw/XYxhQEeWnnxvhBft+7IjJFRMpmcft5nw+zWz6TxxgnIsPymtGYSImG9pTFY5cXkenu97HpIlIuFI8bSVbAiBARifc6Q4g8AGRZwMjE80ApoImqNgImAl+I42JgINBOVVsBfYDtoQps/MnLNqGqu1TVDx+SbgbOFTBU9XZVTfEujolFftn/WA5T0EXze09Vr1DVn7NY5LzPhzlY3ph8sfaUZ48C37nfx75zr0cVK2DkkFtpWyMiH4rIahGZEKiMiciTIrJQRFaKyFgREXf+LLfXwSLgfhG5SkQWiMhSEflWRKq4yz0tIu+JyGwR2Soi14jIyyKyQkS+EZHC+cw+XkSuDLo+TkSGiUiciLziZk8WkTvd23u62ScEbbOIyH04X7ZmisjMXKy/BHAL8KCqpgGo6n+Ak0BvoBqwX1VPurftV9Vd+dlmE35R3ibOVc7dXhBfuI+7XkReDlpugIgsEZHlIvJdULaHg5ZZKSJ13avxOX0+xPmVqQPwoTi9joq7z08H9z7Xudu7UkReClpfqog852aaH3jOMtnOeiIyz32cvwTNLyki37nbtkJEBrvznxGRB4KWe05E7heRaiLyg5tzpYh0y8fTb3IpyttaT/exJwMpksl+x132T+56l4vIi+68Nu77PFlEvhSRciLSVESS0j0/K9zp9iLyvYgsFpFEEamWwfPxuIhsDmybiJQOvp7BNrR3My0H7k633tluO1oiIpe4898XkSFBy30oIoNFpLmIJLntKFlEGuXnuTWRF81tMd12FBOR/7iPvVREernzS4jIpyKS4ra3BfLrPmmLiFQUkQQR+dptEytF5DeSwedDCeqNKyI3uu/55SLy3xxmfFacz6txodpu4y/WnsLbnsTp7X6jO32niHzo3jQYeM+dfg8YktH9fU1V7ZKDC1AXUOBS9/q7wMPudPmg5f4LXOVOzwLeDLqtHCDu9O3AX93pp4E5QGGgNXAMuNy97UtgSAZ5HgGWZXB5PYNlrwbec6eL4PRuKA7cATzhzi8KLALqAT2Bw0BNnCLXPKCru9wWoGI2z9V5ywCtgKUZLPc34D6gpJt9HfAm0MPr19suMd8m6gIr3embgU1AGaAYsBWoBVRy20q94G1ysz0c9Fgr3cfL6/PRIei2WThFjerANjdDPDAjsM3uOgL3fxm3DWfyGk0GbnSn7wZS3el4oLQ7XRHYAIi7DUvc+YWAjUAF4CHgcXd+HFDK6/dfQbpEeVvrCRwNakeZ7XcuB34ESgRvF5CMu08AngFGu9PLgh7zT8AT7jb8CFRy5/8GeDeT5+M/QW3qjsDzkcnznwx0d6df4df/HSWAYu50I2CRO90DmOhOlwE2u23uH8Bv3flFgOJev7fsUqDaYt2g9+5DQW2jKc7+phjwMPAvd34L4AzuPgr3sx0wFHg76HHLBN8eND+wfHOcz3cV0z9PGWQcBwxz29lbgefJLrF5sfYU9vZUBefzXTf3PoH96s9By0jw9Wi5WA+M3NmuqnPd6Q+Aru50L7eqtgKnR0HzoPt8EjRdE0h0l3sk3XJTVfU0sALnC8I37vwVOI3kPKr6iqq2yeByXwa5p7oZi+J8SPxBVY8D/YAbRWQZsADni0rgF6EkVd2hqmdxGu8FGUJFVVOB9jgfIvcBn4jIzeFanwmpaG0T6X2nqodV9QSQAtQBuuC0lc3u4x/MwePk5fnISEdglqruU9UzwIdAd/e2U8D/3OnFZN02LwU+dqeDq/QCPC8iycC3QA2giqpuAQ6ISFuc/w9LVfUAsBC4RUSeBlqq6pFs8pvQi+a2lhRoR2S+3+kD/EdVj7nrOCgiZYCyqvq9e9/3+LUdfIpToMD9+wnQBOdD4nT38Z9wtzuj5+MdnJ6BuH//k1FwcY45LquqP7izgttRYeBt9zn9DGjmZv8eaCQilYDrgM/ddjwP+LOI/Amo4+6HTfSJ5rYY0NXNjqquwSncN3bnj3fnr8Qp3qW3AugrIi+JSDdVPZzNunoDn6nqfvdxs9uX/h/Ol7hR6n7DMjHN2lOY2pOq/gQ8CcwEHspoWbeNRV07swJG7qR/gVVEiuH0Ghimqi2Bt3GqbgFHg6b/AbzhLndnuuUCh0+cBU4H/dM+i/PLzXlE5BFxuqGmv7x+QWjnS9ksoD+/ftAD50vMvUENtJ6qTgvO40rLKEMubARqi0ipdPPbA6vcjGmqOktVnwLuwalIGv+LyjaRgdy8389w/v/O4Mx5eT5yK/i5yEnbzGjH9Fuc3h3tVbUN8FNQpndweqXcgvNrCO6Xt+7ATmBcoEuiiahobmvBObLa7+TGJ8BwEWnsRNf17mOvCnrslqraL6Mc7gfmuiLSE4hzP1zm1oM4bac1Ts+pIkG3vQ9cz/nt6CNgEHAcmCIivfOwTuO9aG6L+aaq64B2OF+8/iIiT4Z4FQuB9iJSPsSPa/zJ2lN421NL4ABB460BP8mvh1dWA/aGeJ1hZwWM3KktzoCTACNxuiYFGsp+ESmJ0/UtM2VwvgAA3JSfIHmoEn6C80GqG79WIBOB38uvxwE3FpGEbFZ9BGcwztxkPYrzy9lr4h7L6H4BKgHMEJEmcv6xwG1wqpfG/6K5TWRnPtBdROqBM2qzO38Lzs4GEWmH0/09ILfPR2btKQno4R4fGYfzK+73GSyXnbnACHf6t0HzywB7VfW0OMdq1gm67UtgAE4vkEQAEakD/KSqb+MUONrlIYvJn1hpa5ntd6bj9PIJHP9c3v0l6pD8OubKDbjtQFU34hTw/o9fi/JrgUqB50lECotIVr2d3gc+IpPeF+56fgZ+FpHAr4Lp29Fu98PxDTi/8AWMwxmEDXUH5hWR+sAmVX0dmIRzeKWJPrHQFmfjvpfdImBtnPYzFxjuzm+G8+XnPOKcOeuYqn6Ac6hHYH+Q2f5sBnCtiFRw759dYeIb4EXg6wx++DKxx9pTmNqTiHTC6XnfFng48HkW5/DiwHN1E87+KKpYASN31gJ3i8hqnGOu/ul+uHkb5zj4RJzKcWaeBj4TkcXA/jBnTW8aznG536rqKXfeOzjd5ZeIM6Dhv8j+19yxwDeS/SCeySKyw728BjwGnADWich64FrgarcaWhJ4T5xBbpJxuuE+nftNNB6I5jaRJVXdh3NY0xfiDN4X+JL0OVBeRFbh9BZaF3S33D4f44C33Ap/8aB178YZFXomsBxYrKp52cHc7+ZZgXOYSMCHQAd3/o3AmqB1n3LX+6m6g+7ijGOwXESW4vTi+nsespj8iZW2luF+R1W/wflQtUicwz8CA+XeBLzi7hva4IyDEfAJTi+HT+Hce3cY8JLbZpcBl2SR5UOc5/LjLJYBp/g/xs0lQfPfBG5y19WU83t4/ASs5vziyHBgpfs4LXAKKCb6xEJbfBMo5O4DPgFuVmcg9TdxioApwF9wesmm79LeEkhy38dPuctBJp8PVXUV8BzwvdtWXssunKp+hvN8Tg7eN5qYZO0pDO1JnGED3gZuVefECA8B74qI4BQI+7rfx/q416NKYNATkw1xzjLwP1Vt4XEUY3zB2kRsEpFCwBLgWrdbvvGYtbXwEOdMQINV9YYwPHYJnC7B7TT7Y5pNlIj1tuj2+CusqidEpAHOGElNgn74MiZkrD2ZvIra8+caY4wJLbeL4/+AL614YWKZiPwDp2vtFWF47D7Av4G/WfHCRJkSOKduLIzT2+gu+7JlTJ5ZewoT64Fh8kxEFuCcBi/YDaq6wos8xhRUIvI4zmFZwT5T1ee8yOMFERmAc2hLHPCOqr6Y7vZROKeSTQNSgTtUNcX9BWg1TjdWgPmqOipSuY1/iMgYnDP3BPu7qmY6RoYxJvdsn2VM6BTE9mQFDGOMMVHN7aa5DugL7MA5Xva6wOCJ7jKlVfUXd3oQzi8hA2K9C6sxxhhjTCzxxSCeAwYMCJyD1i52ibaLr1nbskuUXnKrE7BBVTe53TPHA4ODFwgUL1wJeVwPYO3KLlF78T1rW3aJ0ouvWbuyS5ReMuWLMTD27/fVyQeMiRnWtkwBUQPYHnR9B9A5/UIicjfwB6AI0DvopnruGVZ+AZ5Q1dkZ3PcOnLPSULt27dAlN8acY/ssY0LP2pWJNb7ogWGMMcaEm6qOUdUGwJ+AJ9zZu4HaqtoWp7jxkYiUzuC+Y1W1g6p2qFSpUuRCG2OMMcaYc6yAYYwxJtrtBGoFXa/pzsvMeGAIgKqeVNUD7vRiYCPQOEw5jTHGGGNMPlgBwxhjTLRbCDQSkXoiUgQYAUwOXkBEGgVdvRJY786v5A4CiojUBxoBmyKS2hhjjDHG5IovxsAwxhhj8kpVz4jIPUAizmlU31XVVSLyDLBIVScD94hIH+A0cAi4yb17d+AZETkNnAVGqerByG+FMcYYY4zJjhUwjDHGRD1VnQJMSTfvyaDp+zO53+fA5+FNZ4wxxhhjQsEOITHGGGOMMcYYYwypqakcO3bM6xiZynUPDBEZAPwdp5vuO6r6Yrrb/wb0cq+WACqratn8Bo1FHy3Ydm56ZGc7LZ8x6VkbMaZgCW7zYO3eGC/ZPtiYgictLY16jS6ieEJJXvjgG37bpY7XkS6QqwKGO9DZGKAvsANYKCKTVTUlsIyqPhi0/L1A2xBlNcYYY4wxxhhjTBisXLmS/Xt2AHDgp11AlBcwgE7ABlXdBCAi44HBQEomy18HPJX3eAasAm6MMcYYY4wxJrxWrlx5bnr7xjXAxd6FyURux8CoAWwPur7DnXcBEakD1ANmZHL7HSKySEQW7du3L5cxjDHGGGOMMcYYEyqbN28+N71v9w4Pk2QunGchGQFMUNW0jG5U1bHAWIAOHTpoGHPEFOuNYYwxxhhjjDEm1LZt20apsuU5fjSVgz/t9jpOhnJbwNgJ1Aq6XtOdl5ERwN15CWUcixcvZsmSJZyp2Z4y5St6Hcfkk4i8CwwE9qpqiwxufwT4rXs1HrgIqKSqB0VkC3AESAPOqGqHyKQ2xhhjjDHGFAR79uyhXKWqFCl2mJ8P+PMoidwWMBYCjUSkHk7hYgQwMv1CItIUKAfMy3fCAmrSpEkMGzaMM2fOUKFKdZ55dxJlK1T2OpbJn3HAG8D7Gd2oqq8ArwCIyFXAg6p6MGiRXqq6P9whjTHGGGOMMQXPnj17KFO+IvGFC3P4oD8LGLkaA0NVzwD3AInAauBTVV0lIs+IyKCgRUcA41XVDg3JgyNHjjBq1ChatmzJV199xeGD+/n4jRe8jmXySVV/AA5mu6DjOuDjMMYxxhhjjDHGmHP2799P6bLlKV22PL8cOuB1nAzldhBPVHWKqjZW1Qaq+pw770lVnRy0zNOq+mgogxYk77//Pnv27OGNN95g4MCB9B9+M3MTJ7qnsjGxTkRKAAOAz4NmKzBNRBaLyB3Z3N8GyDXGGGOMiSIi8q6I7BWRlZncLiLyuohsEJFkEWkX6Ywm9u3fv59SZctTqmx5Ug//7HWcDOW6gGHCb+zYsbRv355LLrkEgL5DbwRVZk4e73EyEyFXAXPTHT7SVVXbAZcDd4tI98zurKpjVbWDqnaoVKlSuLMaY4wxxpj8G4fzA1ZmLgcauZc7gH9GIJMpQE6fPs2RI0coWaYsJUuX5cjhnHYcjywrYPjMunXrSE5O5qabbjo3r1L1WlzUrgtJM6Z4mMxE0AjSHT6iqjvdv3uBL4FOHuQyxhhjjDFhkINDjQcD76tjPlBWRKpFJp0pCA4dOgRAQumyJJQuy8njxzh16pTHqS5kBQyfmTzZORJn0KBB581v370fOzevZ8/2LR6kMpEiImWAHsCkoHkJIlIqMA30AzLsXmiMMcYYY2JSDWB70PUd7rwL2OHEJi/OFTBKlSGhVGkAfv7Zf4eRWAHDZ6ZOnUrLli2pU6fOefPbde0DwPJ5M72IZUJARD7GOTNPExHZISK3icgoERkVtNjVwDRVPRo0rwowR0SWA0nA16r6TeSSG2OMMcaYaGGHE5u8+LWAUZqEUmXOm+cnuT2NqgmjkydP8uOPPzJq1KgLbqtcozYVq9Zk9dIF9B9+iwfpTH6p6nU5WGYczjGQwfM2Aa3Dk8oYY4wJHxGJAxYBO1V1oNd5jIliO4FaQddruvOMCYlAb4sSJUsTOJmo9cAwWUpKSuLEiRP07Nkzw9svateFNUsXcPbs2cgGM8YYnxORASKy1h2d/YKzYLm9nVaIyDIRmSMizYJue8y931oR6R/Z5MbEvPuB1V6HMCYGTAZudM9G0gU4rKq7vQ5lYsfhw4cBp4BRIsE5hOSXX37xMlKGrIDhI3PmzAGgW7duGd7etG0njvx8kD3bNkUyljHG+Jr7C+8YnBHamwHXBRcoXB+paktVbQO8DLzm3rcZzsC5zXFGf3/TfTxjTD6JSE3gSuAdr7MY43c5OAbaweMAACAASURBVNR4CrAJ2AC8DdzlUVQTowLFiuIlS1E8oSTwa1HDT+wQEh9JSkqicePGlC9fPsPbGzZvC8DGlOVUr9swktGMMcbPOgEb3MOtEJHxOKO1pwQWUNXgnxASAHWnBwPjVfUksFlENriPNy8SwY2JcaOBPwKlMltARO7AOSUktWvXjlAsY/wnu0ON1enTf3eE4pgCKFCsKJ5QkrNpaYD1wDBZUFUWLFhAp06Znx2zep0GFCuRwIZVSyOYzBhjfC9HI7OLyN0ishGnB8Z9ubyvjehuTC6IyEBgr6ouzmo5G2zQGGP84ZdffkFEKFY8gRIJTt3Zjz0wrIDhE7t27WL37t1ZFjAKxcVR/6JWbEpZHsFkxhgTG1R1jKo2AP4EPJHL+9qXLGNy51JgkIhsAcYDvUXkA28jGWOMycwvv/xCyZIlKVSoEMVKJABw5MgRj1NdyAoYPrFs2TIA2rVrl+VydRo3Z/umtaSdOROJWMYYEw1yOzL7eGBIHu9rjMkBVX1MVWuqal2ccWZmqOr1HscyxhiTiSNHjlCqlNPzIi4+niJFi1kBw2QuUMBo1apVlsvVadyc0ydPsnu7DeRpjDGuhUAjEaknIkVwvixNDl5ARBoFXb0SWO9OTwZGiEhREakHNAKSIpDZGGOMMcY3ggsYAMVKlPRlAcMG8fSJZcuW0bBhw/PeNBmp08gZWH/ruhSgTwSSGWOMv6nqGRG5B0gE4oB3VXWViDwDLFLVycA9ItIHOA0cAm5y77tKRD7FGfDzDHC3qqZ5siHGxChVnQXM8jiGMcaYLKSmpp73XbR4QoIvB/G0AoZPLF++nNatW2e7XPW6DYgvXMQtYBhjjAFQ1Sk4p5gLnvdk0PT9Wdz3OeC58KUzxhhjjPG39D0wihZP4OjRox4myliuDyERkQEislZENojIo5ksM1xEUkRklYh8lP+Yse3UiRNs2LCBFi1aZLtsfHxhqtdpwM7N6yKQzBhjjDHGGGNMrEtNTaVkyZLnrhcvkUBqaqqHiTKWqx4YIhIHjAH64pxqbqGITFbVlKBlGgGPAZeq6iERqRzKwLFo19YNqCrNmzfP0fI16jdiffKSMKcyxhhjjDHGGFMQpC9gFC1eIvoLGEAnYIOqbgIQkfHAYJxjhwN+B4xR1UMAqro3FEFj2Y5NTm+KQAHjowXbsly+Zr3GzJs2+YI3mTHGGGOMMcYYk1vpv1sWK5FA6p59HibKWG4LGDWA7UHXdwCd0y3TGEBE5uIMpva0qn6T/oFE5A7gDoDatWvnMkb0yqg4sWPzegoXLkyjRo0yuMeFatZvDEBKSgqdOnUKaT5jjDHGGGOMMQVLamoqCQkJ564XK57Abh+ehSQcp1GNxzkNXU/gOuBtESmbfiFVHauqHVS1Q6VKlcIQI3rs3rqRyjXr8tmS3dn2vgCoUc8pdKxZsybc0UyIici7IrJXRFZmcntPETksIsvcy5NBt2U7/owxxhhjjDHG5IaqcvTo0XSHkBSPiUE8dwK1gq7XdOcF2wFMVtXTqroZWIdT0DCZ2LVlA9Vq18/x8pWq1yIuLt4KGNFpHDAgm2Vmq2ob9/IMnDf+zOVAM+A6EWkW1qTGGGOMMcaYmHf8+HFU9bweGEWLlYiJAsZCoJGI1BORIsAIYHK6ZSbi9L5ARCriHFKyKZ85Y9aZM6f5acdWqtdtmOP7xMcXpkrNOqxduzaMyUw4qOoPwME83PXc+DOqegoIjD9jjDHGGGOMMXkWKFScPwZGCU6ePMmZM2e8ipWhXBUwVPUMcA+QCKwGPlXVVSLyjIgMchdLBA6ISAowE3hEVQ+EMnQs2btzG2lpZ3LVAwOgWp0G1gMjdl0sIstFZKqIBE5Nk9H4MzUyurOI3CEii0Rk0b59/ht4xxhjjDHh99GCbecuxhiTlUABI30PjODb/CK3g3iiqlOAKenmPRk0rcAf3IvJxu6tTueUanVyV8CoXqcBifNnkZaWRlxcXDiiGW8sAeqoaqqIXIHToylXh2Cp6lhgLECHDh009BGNMcYYY4wxsSJwutSEhAQC/S2KFi9x7rYyZcp4lOxC4RjE0+TCnu2bAahWK3cFjKq16nLq1Cm2bbOqeixR1V9UNdWdngIUdg/Fysn4M8YYY4wxxhiTK8eOHQPS98Aoft5tfmEFDI/t2bGFkqXLUrLMBSdqyVKVWvUAWL9+fThiGY+ISFUREXe6E04bPUDOxp8xxhhjjDHGmFzJ8BCS4jFyCIkJrZ+2bz5XjMiNqrXqAk4Bo1+/fiFOZcJFRD7GGeS2oojsAJ4CCgOo6lvAMOD3InIGOA6McA/LOiMigfFn4oB3VXWVB5sQdnasrjHGGGOMMZETKFKUKFEC3APQ/doDwwoYHtu9bTMXteuS6/uVrVCZkiVLsm7dujCkMuGiqtdlc/sbwBuZ3HbB+DPGGGOMMcYYkx/n9cBwhsPw7SCedgiJh06dOMHBvbupmoceGCJCw4YN2bBhQxiSGeOdzWtWsGTOd5w6ccLrKMYYY4wxxsS8DMfAKG49MEw6e3c7XeWr1Kidp/s3aNCAlStXhjKSMZ565JFHePXVVwGoWqsej48ZT/nKVT1OZYwxxhhjTOw67xASnB8R/ToGhvXA8NDeHU4Bo3LNOnm6f4MGDdi0aRNpaWmhjGWMJz744ANeffVVeg2+jvuef5OfD+zl9cfv4uzZs15HM1FARAaIyFoR2SAij2Zw+x9EJEVEkkXkOxGpE3Rbmogscy82OK4xJuZ8tGDbuYvxrxzsy2qLyEwRWeruz67wIqeJPRn1wCji0zEwrIDhoZ92bgX+P3t3Hlb1fSV+/H3YZXFFxAVBEVBEEUTcl8REzWbSbE0yk6XNNJM2mfQ36UybTudp06T9/ZpmnrQz07S1TbO0qTFWGzUxiVEjGheMuwiiIiKCG4or+/L5/XHvNaggF7j3fu+9nNfz8Ajf9ZgneO893/M5BwYM7nwCo6GhgbKyMleGpZTHVVdX84Mf/ICJEyfyze//nIk338Fjz7/Iobwd5K750OrwlJcTkUDgdeA2IBV4WERSrzlsF5BljBkLLAF+2WJfjTFmnP1rvkeCVkoppVpw8rXsP4HFxpgMbBPpfuvZKJW/ciQpetiXjQCEhtq+1woMdcXpsqOEhUcS1btvp85PTEwE4PDhw64MSymPe+eddzh+/Di//OUvCQgMBGD6bfcxJDGFFe/8FtsgFqXalA0UGWOKjTH1wCLg7pYHGGPWGWMcjxBygSEejlEppZS6kXZfy7DNh+hp/74XcNyD8Sk/Vl1dTVhYGAEBX6UHQsLCruzzJprAsNCp8qMMGDIUEenU+ZrAUP7AGMNvf/tbMjMzmT59+pXtAYGBzHvwGxw7XMiBPdssjFD5gMHAsRY/l9m3teVJ4JMWP4eJyHYRyRWRe1o7QUSesh+zvaKiousRK6WUUldz5rXsReAfRaQM22S6f2ntQvqapTqqurr6quUjAMEhoQQEBGgCQ33l9PFjxHRy+QhAXFwcQUFBFBcXuzAqpTxr9+7d7Nu3j6eeeuq6ZN7kOXcTFh7JFx8vtSg65W9E5B+BLODVFpvjjTFZwCPAr0Uk8drzjDF/MMZkGWOy+vfv76FolVLqxrS3RbfzMPC2MWYIcDvwFxG57vOcvmapjqqurrY38PyKiBAeHq5LSJRNc3MzZ06UETOocxNIAAIDA4mPj+fIkSMujEwpz1q8eDGBgYHcf//91+0L6xHO+Om3sD3nUxoaGiyITvmIciCuxc9D7NuuIiK3AD8C5htj6hzbjTHl9j+LgRwgw53BKpvq6mpeeeUVsm+6jYef/Q/eXn/Q6pCU6nZqamooLS3lwoULVoeinHstexJYDGCM2QKEAdEeiU75taqqqqv6XziEh4drBYayOX/mNA31dcQMimv/4DYs3FpKj36D2JZX6MLIlPKspUuXMnv2bPr169fq/uzZd3D54nlycnI8G5jyJduAJBEZJiIh2BqbXTVNREQygAXYkhenW2zvIyKh9u+jgalAgcci76aqq6uZO3cuL7zwAqVF+1n0+v/jlX99jPraWqtDU6pbuHTpEs8++ywDBgwgPj6efv36cffdd+uyZGu1+1oGlAKzAURkFLYEhq4RUV3W2hISsCUwampqLIiobZrAsMjp4/YRqoM7X4EBEDMojorjx9o/UCkvVFRUxKFDh7jrrrvaPGZM9nSCQ0L55JNP2jxGdW/GmEbgWWAVsB9bh/Z8EXlJRBxTRV4FIoG/XTMudRSwXUT2AOuAXxhjNIHRSS3L2W9U0v7973+fTZs28d577/Hakg1856f/zYHdX/Le6//Pg9Eq1T2VlJSQmZnJ7373O+69917eeOMNvve977F+/XoyMjJYs2aN1SF2S06+ln0P+Jb9Nes94Amjnc6VC7S2hARsU0m8rQIjqKMniMg84L+BQOANY8wvrtn/BLY3io6Sp98YY97oYpx+53S5PYHRhSUkjvMvna/k0qVLREVFuSI0pTzGkZS4/fa2x5iHhvVgZMZEPvnkE1577TVPhaZ8jDHmY2wNzVpu+3GL729p47zNwBj3Rqda2rFjB7/97W957rnneOihh1i4tZSpc++hKG8nq5e8w8w7HyAhJc3qMJXySxfPnWXOo1/nzJkz5OTkXNU8+zvf+Q7z58/nnnvuYd26dcAA6wLtppx4LSvAVimolEtVV1e3+lnS55eQODmfGOB9Y8w4+5cmL1pRcfwYIkK/2EFduk5/+xIU7YOhfNHq1asZMWIEw4cPv+Fx6ZNmUlhYyLFjWm2klK97+eWX6d27Ny+99NJV2x94+t/oERHFsrf+16LIlPJvxhgW/OzfOHbsGB999NFVyQuA+Ph4Vq1aRUxMDPfffz/Vly9aFKlSytPaqsDw+QQGzs0nVk6oOHGMPv1jCQ4J7dJ1NIGhfFVTUxMbNmzg5ptvbvfYUeMnA2gfDKV83IEDB1i+fDnPPfccPXv2vGpfeGRP5jzwONtyPuVkqb6mKeVqOSsWsXvT57zyyitMndr6Q/zY2Fjee+89ysvL+cuvXmr1GKWU/6murvbbJp7OzCcGuE9E9orIEhFptUtld59PXHGijP4Dh3T5Oo5rlJSUdPlayr1E5E0ROS0i+9rY/w/235s8EdksIukt9pXYt+8Wke2ei9p9du/ezYULF5g1a1a7xw4dMYo+ffpoAkMpH/fGG28QFBRETPadrfbJuOXeRwkIDCTnw/ctilC5ioiEiciXIrJHRPJF5KdWx9SdVV28wKLXf8GojEn0nTD/hn1qJk6cyPe//302rPwbh/J2eDhSpZQVampqunUTzw+BBGPMWGA18E5rB3X3+cQVx49dqZ7oiqjefQntEa4VGL7hbWDeDfYfAWYaY8YALwN/uGb/TfZlWVluis+jNmzYAMDMmTPbPTYgIICZM2eyfv16d4ellHKTxsZG3nnnHe666y5694tp9Zg+/QcwbsrNbFi5hKbGRg9HqFysDrjZGJMOjAPmicgki2Pqtj5463+ounSBR5//CQEB7b/9/4//+A96R8fwl1+/jPaIVMr/nb90mWMXGq9LbPpDBUa784mNMWeNMXX2H98Axnc+PP/U2FBPZcVJl1RgiAj9Bw7RCgwfYIzZAFTeYP9mY8w5+4+52H6//NamTZsYNmwYgwY51wdm6tSpHD58mFOnTrk5MqWUO6xbt46KigoeffTRGx43/bZ7uVBZQeHurR6KTLmDsbls/zHY/qWfhC1wruIUq5f8mRl3PkB8Umut664XGRnJg0//O4fzd7Fr41o3R6iUslp9bS0hYdcvIfHGKSQdTWC0O59YRAa2+HE+tjFAqoXK0ycxzc0uqcAA6D8wTisw/M+TQMu5oQb4TER2iMhTNzrRF5ZnGWPYtGkTU6ZMcfocx7FbtmxxV1hKKTdavHgxkZGRzJt3o0I0SJ9yE6FhPchdu9JDkSl3EZFAEdkNnAZWG2M0K2WBlQv/QHNzE/c88S8dOm/avHvpP3AIy97+jVZhKOXHmpubaaivIyQ07Lp9Pl+B4eR84ufsax33AM8BT7gyYH9QccLWRiTaBRUYYOuDcfToUZdcS1lPRG7ClsD4QYvN04wxmdgmAD0jIjPaOt8XlmcdPXqUkydPMnnyZKfPyczMJCQkhM2bN7sxMqWUOzQ1NbFs2TLuvPPOVpuEtRQa1oNxU2ezY/1nNDc3eyhC5Q7GmCZjzDhsFYXZInLdfFxfSLr7sssXzvP5soVMvnU+MYOHdujcwKAg7nz02xzO36U9qJTyY44eF61VYPh8AgNs84mNMcnGmERjzM/t235sjFlh//6HxpjRxph0Y8xNxphCVwft6ypOlAG4ZAkJ2CaRXLhwgfPnz7vkeso6IjIW29Kru40xZx3bjTHl9j9PAx9gmwjks7788ksAJk1yfjl0WFgY6enpV85VSvmObdu2cebMGebPn9/+wUDmtNlcqKxgxw5tIOgPjDHngXW00gfKF5Luvmz9R+9TV1PNnf/wz506f8Yd9xPVuy//8z//4+LIlFLewpGgCAm9fjpmeHg4DQ0NNHpRXyp3NPFU7ThzogwJCKBvzMD2D3aCTiLxDyIyFPg78Kgx5mCL7REiEuX4HpgDtDrJxNs5up7/ecVaQkNDGTNmTIfOz87OZseOHTQ1NbkpQqWUO3z00UcEBAQwd+5cp45PnzwLEWHlSl1G4qtEpL+I9LZ/3wO4FdCHWh7U3NTE6qV/YWTGRIYmjerUNUJCw7jp7odZsWKFVvsq5accFRihbfTAaHmMN9AEhgUqTpTRN2YgQUHBLrletCYwfIKIvAdsAVJEpExEnhSRp0XkafshPwb6Ab+9ZlzqAGCjfVnWl8BKY8ynHv8LuNDhgj2MGzeOkJCQDp03YcIELl++TGGhvgdWypesWrWKyZMn07dvX6eOj+rdlxFpGXzyySftH6y81UBgnYjsxdZDbbUx5iOLY+pW9uTmUHH8GHPuf7xL15n9tX8AYMGCBa4ISynlZa5UYLSxhKTlMd5AExgWqDhR5rLlI2Br4gmawPB2xpiHjTEDjTHBxpghxpg/GWN+b4z5vX3/Pxlj+thHpV4Zl2qMKbYvyUq3L8/6ubV/k65pbm6m5MA+JkyY0OFzHeds27bN1WEppdyksrKSHTt2cOutt3bovLQJ09i+fbsuj/RRxpi9xpgMY8xYY0yaMeYlq2PqbnJWvE/PPtGMnzmnS9eJjh3M7bffzjvvvKMVkEr5oRslMLQCQwG2JSTRsYNddr2Inr2IjIzUSSTKJ5w8doTa6irGj+/4hOWUlBTCw8PZtWuXGyJTSrlDTk4OxhhuueWWDp03esI0mpubWb9+vZsiU8p/VVRUsGvjWqbd9jWXVPx+85vf5Pjx43z22WcuiE4p5U2uNPFsYwoJaAVGt9bY2EBlxUmXVmCICAkJCbo2UfmEkgO29h2ZmZkdOm/h1lLe317O4MRR7Ny50x2hKaXcYO3atURGRpKd3bHew0lpGYSHh7N27Vo3RaaU//rrX/9KU1MjM+980CXXu+OOO4iOjubNN990yfWUUt7DkZwIDfWNCowgqwPobipPn8A0N7tshKpDfHy8LiFRPqHkwD6CQ0IZNapzDcWGpaSx+dOlNDc3ExCgOVilvN369euZOnUqwcEdewocFBzClClTtAJDqWss3Fra7jHvvvsuw0aOYcjwZJfcMyQkhEceeYQFCxZw4cIFevXq5ZLrKqWs99USEq3AUK04c6IcwKVLSACtwFA+o+RAPkOGJ3f4w4xDwsg0Ll++zKFDh1wcmVLK1c6cOUN+fj4zZ87s1PkzZ84kLy+PyspKF0emlP86dOgQO3bsYMqcu1163UceeYS6ujqWLVt2ZZtjuti1SZWW251JuCilrHOjJSSOCgxNYHRjFSfKgK8ab7pKfHw858+f58KFCy69rlKuZIzh6KEC4pNSO32NoSNslRt79uxxVVjKD4jIPBE5ICJFIvJCK/ufF5ECEdkrImtFJL7FvsdF5JD9q2vt+tVVNm7cCMCMGTM6df6MGTMwxly5jlKqfe+99x4iwqRb7nLpdbOzsxk+fDgLFy506XWVUtZyZgqJNy0h0QSGh505UYaI0G/AQJdeNyEhAUCrMJRXO1dxissXzhGf3PkExuBhSQQFBWkCQ10hIoHA68BtQCrwsIhc+z/ZLiDLGDMWWAL80n5uX+AnwEQgG/iJiPTxVOz+buPGjYSGhpKVldWp87OzswkODmbTpk0ujkwp/7Vo0SJmzJhB35hYl15XRHjooYdYs2YNp0+fdum1lVLW0Sae6obOnCynd/QAgoJDXHrd+Hjbw0Ttg6G8WWlRAQBDu1CBERIaxsiRIzWBoVrKBorsI4frgUXAVbXTxph1xhjHq28u4GhENBdYbYypNMacA1YD8zwUt9/bvHkzWVlZhIaGdur8sLAwxo8fz+bNm10cmVL+qaCggP379/PAAw+45foPPPAAzc3NLF++3C3XV0p53pUmnjpGVbWm4sQxl/e/gK8SGFqBobzZ0UP7ARg6YmSXrpOenq4JDNXSYOBYi5/L7Nva8iTwSSfPVU6qr6u1rcOfMqVL15kyZQrbtm2jvr7eRZEp5b+WLl2KiPC1r33NLddPT08nMTGRpUuXuuX6SinP0woMdUNnTpa7dISqQ0xMDGFhYZrAUF7tWFEh0bFDCI/s2aXmXmPHjqWsrIxz5865IUrlz0TkH4Es4NUOnveUiGwXke0VFRXuCc7PlBzYR319PVOnTu3SdaZOnUpdXZ2OT1bKCUuXLmXKlCkMGjTILdcXEe677z7Wrl2rr8FK+Ynq6mqCgkMICAy8bp9WYHRzTU1NVJ464fIRqmB7QdFRqsrbHTtcSFxiSpevM2bMGADy8vK6fC3lF8qBlp2Rh9i3XUVEbgF+BMw3xtR15FxjzB+MMVnGmKz+/fu7LHB/dijPlnCYOHEi0Pa0gvZMmjQJgNzcXNcGqJSfKS4uZs+ePdx3331uvc99991HY2MjH330kVvvo5TyjJqamlarL+CrBEZVVZUnQ7qhDicw2uv03uK4+0TEiEjnOnf5oePHj9PU1OiWJSRgW0aiFRjKW9XX13PiaDFxrSwf6egHG01gqGtsA5JEZJiIhAAPAStaHiAiGcACbMmLlt3nVgFzRKSPvXnnHPs21UWHC3YTHx9PbGzXGgkOGjSIIUOGsHXrVhdFppR/cvSluPtu145PvVZWVhaDBg3SPhhu4MznLBF50D5VK19EdCSM6rLq6mpCwlpPYAQEBBAWFua7FRhOdnpHRKKA7wL6bqMFR3LBHUtIwDaJRCswlLcqLCykqanRJRUYgwcPpnfv3prAUAAYYxqBZ7ElHvYDi40x+SLykojMtx/2KhAJ/E1EdovICvu5lcDL2JIg24CX7NtUFxXl775SfdFVEydO1ASGUu34418WMyQxhdyKoE4tz3RWQEAAd911F59++in1dbVuu09348znLBFJAn4ITDXGjAb+j8cDVX7nRhUYYKvC8KYERlAHj7/S6R1ARByd3guuOe5l4BXg37scoR9xJDDcWYFx5swZqqqqiIiIcMs9lOosR7JhyPCuJzBEhDFjxmgCQ11hjPkY+PiabT9u8f0tNzj3TeBN90XX/Zw/e5qzJ8tdmsBYunQpp0+fJiYmxiXXVMqfXDpfSeGeL5n/2Hc6fY2OJD3uvvtuFixYQP72TWRMnd3pe6qrOPM561vA6/apWVxTUahUp9gqMK6fQOIQHh7u00082+3WLiKZQJwxZmUXY/M7juqIfm5KYCQkJAA6icSbicibInJaRPa1sV9E5H/spYN77b9Pjn2Pi8gh+9fjnovaNfbt20dgYBCD4oe75HppaWnk5+djjHHJ9ZRSrlNcsBeA7Oxsl1zPcZ3t27e75HpK+ZvdW3Iwzc2MnzHHI/e7+eabiYyMZOcXazxyv27CmalYyUCyiGwSkVwRaXXstzaeVh1RU1NDaGjbCQxvq8BwaRNPEQkAXgO+58Sx3e4X6+jRo/TsE93qjF1X0FGqPuFtoNUXG7vbgCT711PA7wBEpC/wE2Aitgz9T+zr9X3Gvn37GBg/nKDgEJdcLy0tjQsXLlBefl2/RaWUxYoL9yIBAWRkZLjkepmZmYiIJjCUasOujWvp3a8/w0aO8cj9QkNDufXWW9m9eZ0+SPCsIGzvEWcBDwN/FJHe1x6kjadVR1RXV99wCYmvV2C01609CkgDckSkBJgErGitkWd3/MU6evQo0QPdU30BWoHhC4wxG4Abra+/G/izsckFeovIQGAusNoYU2kvG1zNjRMhXic/P98ly0cc0tLSAFtiRCnlXYoL9jB4WJLLljNGRUUxcuRItm3b5pLrKeVPGhsbyNu6gXFTbiYgwHMDBu+8804qT5+gtGi/x+7p55yZilUGrDDGNBhjjgAHsSU0lOq0mpoagkND29zfo0cPn05g3LDTuzHmgjEm2hiTYIxJAHKxdXzXRybYlpC4q4EnwMCBAwkODtZGnr6trfJBZ8oKAe+sbrp8+TJHjhxhyHDXvcZqAkMp72SM4UhhHomjxrr0uhMmTGDbtm36tFepaxzcs53qyxfJmObZXhS33347YKv+UC7R7kQtYBm26gtEJBrbkpJiTwap/E91dTWhPcLb3B8eHu67S0ic7PSuWmGMobS01G0NPMHWFXro0KFagdHNeWN10/79tqczrqzA6Nu3L7GxseTn57vsmkqprjt76jgXz51l2EjXJjCysrI4deqULhtT6hq7N39OUHAIaROmefS+sbGxDB81lt2bP/foff2Vk5+zVgFnRaQAWAf8uzHmrDURK39xoyUkC7eWcq5eKKs479bpRh3R0Skk7XZ6v2b7rM6F5X9OnTpFbW2tWxMYoKNU/UBb5YPl2DPuLbbneCyqLnIkGYYMT3bpdUePHq0JDKW8zJH9tgaerl6LP378eAB27NjBkCHuq2ZUyhvdseqiBAAAIABJREFU6IPDni05jByXTVi45yfQpU+5iWVv/S+XLpwDhnr8/v7GiYlaBnje/qWUS9TU1NywR2NoWA+vGpnsuYVy3ZyjKqL/oLh2juya+Ph4rcDwbSuAx+zTSCYBF4wxJ7Bl3OeISB9788459m0+IT8/n9DQUGIGufbNzejRoykoKKC5udml11VKdd6RwjwCAgMZOmKUS687btw4AgIC2LFjh0uvq5QvqzhRRlnxQdInz/LYPRduLb3yNW7yTZjmZvK2bvDY/ZVSrtXeGNWQ0DDqa70ngdHhCgzVOY6qiOhY9zw1cmTmLwb15sSJE9TW1hIW1nY3WWUNEXkPWyVFtIiUYZssEgxgjPk9tqz77UARUA18w76vUkRexrY+EuAlY8yNmoF6lfz8fFJSUggMcu0/OampqVRVVVFaWnqlia1SylpHDuxjyLBkQlz8GhQeHs6oUaM0gaFUC3u25AB4NIHR0vBRY4ns1ccex79YEoNSqmvam0ISEtqD+jrv6YGhCQwP+SqB4d4lJNEDbRUepaWlJCe7tlxfdZ0x5uF29hvgmTb2vQm86Y643K2goIApU6a4/LqjR48GbAkSTWAoZT1HA89MNzUTHD9+PKtWrcIYg4i45R5K+ZI9W3KIjh3CoIQRltw/IDCQ9Ekz2Zu7nubmZo9OQVFKdV1DQwONjY2E3GAKSUhYGHW13pPA0H9lPKSkpIR+/frRIyLSrfdxTDnRPhjKW1y+fJmjR49eSTa4UmpqKmBLkCilrFd5+gSXzleSYO9/0bLU3BXGjx/PqVOnOHHihEuup5Qva2yoJ3/7JtInz7I0oTd20kwunjvLrl27LItBKdU5jukioWFtTyFx9MDwlilgmsDwkJKSEo88IXZUeGgCQ3kLxwQSR7LBlRyTSDSBoZR3OHLANtZ4WEqaW66fmZkJwM6dO91yfaV8yYG926mrqWbs5JmWxjFm4gwAPv30U0vjUEp1XHV1NUC7PTBMczONDfWeCuuGNIHhIUeOHCE+Pt7t9+nbP5agoCBNYCiv4UguuKMCw3FdTWAo5R1KDuxDAgIYmuT6hCXYGnmKiCYwlALycjcQGBjE6PGuX6LZEb36RjNs5BhNYCjlgxwJjBtNIXEkN7ylkacmMDzAGMPRo0cZNmyY2+8VEBjI0KFDNYGhvEZ+fj4hISEMHz7cLddPTU3VSSRKeYmSwn0Mik+84RuhroiMjCQlJUUbeSoF7MldT3J6ltuXJztj7KSZbNmyhfPnz1sdilKqA76qwGi7iafjNd1b+mBoAsMDTp06RW1trUcSGAAJCQmawFBeo6CggJSUFIJcOIGk5br60aNHc/nyZcrKylx2faVU55Qc3EeCm5aPOGRkZOhae9XtnTtzitJDBYydZO3yEYexk2bS1NTE2rVrrQ5FKdUBTlVg2CeU1GsCo/s4cuQIgMemJAwbNuzKPZWyWkFBgduWj4A28lTKW5w+fZpzFadISHbf7zvYEhjHjh3j7Nmzbr2PUt4sb+sXAIy195+w2oi0DKKioli1apXVoSilOsDRxDP4BmNUr1RgeMkoVU1geICjGsJTCYyEhAROnjx55X9IpaxSVVXFkSNH3NLA00ETGEp5B0dVhLsrMByNPLUKw7uJSJyIrBORAhHJF5HvWh2TP8nbuoGefaLd1m+mo4KCgpk9ezafffaZ10wqUEq1r6qqCoCwG0wh+aoHhnd8ttQEhgd4OoHhWKpy9OhRj9xPqbYUFhYC7plA4tCvXz9iYmI0gdHNicg8ETkgIkUi8kIr+2eIyE4RaRSR+6/Z1yQiu+1fKzwXtX9xNNaMT3bP77tj2djhpv5X3U95rUbge8aYVGAS8IyIeMenbR/X3NxM3pdfMGbidAICvOet/Ny5czl69CgHDx60OhSllJOcmkKiPTC6nyNHjtC/f38iIiI8cj9HokT7YCirOZIK7kxgOK6fn5/v1nso7yUigcDrwG1AKvBwKx+USoEngIWtXKLGGDPO/jXfrcH6sV27dtF/UBwRUb3cep/IXr0ZOnSoVmB4OWPMCWPMTvv3l4D9wGBro/IPRw/mc+l8pdcsH3GYO3cugC4jUcqHONMDI1SnkHQ/xcXFbpvA0BpHBUZxcbHH7qlUawoKCggODmbEiBFuvY9jEomWrXZb2UCRMabYGFMPLALubnmAMabEGLMX0HE1brJr1y63Lx9xyMzM1ASGDxGRBCAD2NrKvqdEZLuIbK+oqPB0aD5pb+56AMZ4WQJj2LBhJCUlaQJDKR/izBQSxz6twOhGjhw54rEJJACxsbGEhoZqI09lufz8fJKTkwkODnbrfVJTU7l48SLHjx93632U1xoMHGvxcxkde9IbZv8AlSsi97R2gH7IurELFy5QVFTk9gaeDhkZGRw8eJDLly975H6q80QkElgK/B9jzMVr9xtj/mCMyTLGZPXv39/zAfqgvK1fkJA8ml59o60O5Tpz5swhJyeHhvo6q0NRSjnBmSUkofb+GPW+2sTTiXXGT4tInn0t8cbuvt6xqamJ0tJSjyYwAgICdBKJ8goFBQVuXz4CXJlyostIVCfFG2OygEeAX4tI4rUH6IesG9uzZw8ACSmeS2AYY67cV3knEQnGlrz4qzHm71bH4w9qqi5zcO92r6u+cJg7dy7V1dUc3Lvd6lCUUk5wNPEMcWYKSU21R2JqT4cSGE6uM15ojBljjBkH/BJ4zSWR+qiysjIaGxs9uoQEbGV8uoREWammpobi4mKPJDB0Ekm3Vw7Etfh5iH2bU4wx5fY/i4EcbKXuqgMcyzniXVyB4WjcuXBr6VXbHZNItJGn9xIRAf4E7DfGdOv3gq5UsGMLTU2NjJnknQmMWbNmERQUxN7cDVaHopRyQnV1NcHBwQQFtV0t/VUTT9/sgeHMOuOW5YERQLdelO6ogvBkBYbjfprA8D5OVDD9qsU0hIMicr7FPp+alFBYWIgxxiMJjJiYGKKjo1m+bmurH3aU39sGJInIMBEJAR4CnPodEZE+IhJq/z4amApoJqyDdu7cSWxsLH2iB3jkfoMGDaJ///7aB8O7TQUeBW5u8dp1u9VB+bq9W9cTGtaD5DHjrQ6lVVFRUUyZMoW8LzWBoZQvqK6ubnfQhKM6w1vGqAZ18PjW1hlPvPYgEXkGeB4IAW5u7UIi8hTwFMDQoUM7GIbvcCQRPF2BMXz4cC5cuMC5c+fo06ePR++tWteigulWbL8720RkhTHmyoclY8y/tjj+X7j6SXCNvbLJJziWcziWd7iLI1kRHZdI+ZFDbr2X8k7GmEYReRZYBQQCbxpj8kXkJWC7MWaFiEwAPgD6AHeJyE+NMaOBUcACEWnGltT/RcvfSeWcXbt2kZHhucIVESEjI0MTGF7MGLMREKvj8Dd5WzcwavxkgkNCrQ6lTXPnzuVHP/oRF85W0KufLrlTyptVVVURHh5+w2MCAgIICQ2jrtYHl5A4yxjzujEmEfgB8J9tHNMt1hMfPnyYoKAg4uLi2j/YhRITbUu4tQrDq7RbwXSNh4H3PBKZCzkqIP62JpfAwCCSkpI8ct8hw5IoP3JIJ5F0U8aYj40xycaYRGPMz+3bfmyMWWH/fpsxZogxJsIY08+evMAYs9m+7DHd/uefrPx7+KLa2loKCgo8msAAWx+M/Px86uvrPXpfpaxyquwop8qOet341Gs5xqnu/fILiyNRSrXHmQoMsC0j8dUpJB1dZ7wIaLWje3dRXFxMfHw8QUEdLXbpGkfFx+HDhz16X3VDTk9KEJF4YBjweYvN7U5KsJ/rFdMSyooPEjt0GCEhIR653+DhyVRfvsi5ilMeuZ9Symbfvn00NTVd6UvhKZmZmTQ0NGjzXtVt5G21LcsYO2mmxZHcWEZGBj379LsSr1LKezlTgQEQ2iOcuhrfTGC0u85YRFo+br0D6NY13YcPH/b48hH4queGVmD4rIeAJcaYphbb2p2UAN5T3VR+5CBDhid77H5DhiXb79ut/8lRyuMcjTStqMAA2LFjh0fvq5RV9m7dQP+BQ4iNc11ftbYa5XZFQEAAY7Knk7f1C5qbm112XaWU61VVVTlVgRHqq0tIjDGNgGOd8X5gsWOdsYjMtx/2rIjki8hubH0wHndpxD6muLjYkgRGVFQUMTExWoHhXTpSwfQQ1ywf8aVJCXW1NZwuL2VwQpJb3hy1xpEsKSs+4Nb7KKWutnPnTnr16uXxZtWJiYlERUVpHwzVLTQ21JO/fRNjJs3ENuDFu42dNJOL585w9KBWSCnlzZxOYPQI95oxqh1e12CM+Rj4+JptP27x/XddEJdfOH/+PGfPnrUkgQG2ZSRageFVrlQwYUtcPIStmuIqIjISW6PBLS229QGqjTF1LSYl/NIjUXfC8ZIijDEMSfRcBUbPPv3o2acfZcUHPXZPpbqrlgnJnTt3kpmZ6fEPVQEBAWRkZOgoVdUtHMrbSW11FelevnzEYYy9T8ferRsYNnKMxdH4DhGZB/w3tobUbxhjftHGcfcBS4AJxpjtHgxR+Znq6moGDGh/glhoj3DqfXSMquoAR/XDiBEjLLn/iBEjKCoqsuTe6npOVjCBLbGxyFzdjXIUsF1E9gDr8PJJCY4kQtzwFI/ed8jwZMqOaAJDKU9pbGxg7969Hu9/4ZCZmcmePXtobGwE3FMOr5Q32JO7nsDAIFKzplgdilN69Y0mISWNvbnrrQ7FZ7SYVncbkAo8LCLXzaIXkSjgu8BWz0ao/JHTFRhhPbxmCYlnO0t2M1YnMBITE/nrX/9KXV0doaHeO26rO2mvgsn+84utnLcZ8NpHGNd+WCgrPkhQcAgDhiR4NI4hw5LZ8PESnUSilIccP1JEXV2dpQmMmpoaCgsLSUtLsyQGpTwhL3c9yWOzCI+IsuT+nUkKpk+ayUfvLqD68kU3ROSXrkyrAxARx7S6ax9YvQy8Avy7Z8NT/qgjS0gqTpR5IKL2aQWGGzmqHxwjTT1txIgRGGM4cuSIJfdX3VdZ8QEGxScS6OHpO4OHJ1NbXcUZL/kHVil/d+RAHgDjx4+35P6O++oyEuXPTp48ScnBfMZM8u7xqdcaO3kWTU2N5G/bZHUovqLdaXUikgnEGWNW3uhC3jKRTnk/5yswvKcHhiYw3Ojw4cPExsY69T+FOzgSJ9rIU3nascMHPDqBxMGxZEWXkSjlGUcK84iMjCQpKan9g90gJSWF8PBwnUSi/Nqnn34KQPrkWdYG0kEj0jLoERHF7i05VofiF0QkAHgN+F57x3rLRDrl3YwxXL582ckKjB5ek8DQJSRudOjQIUaMGGHZWlzH0pVDh3SspPKc6ssXOXvqOHEjRnr83o6moccO6yQSpTzhSGEeGRkZBARY8zwkMDCQcePGaQJD+bVPPvmE3tExxCdd1w7BqwUFBZOWPY09W3IwxvjE9BSLtTetLgpIA3Ls/y1jgRUiMl8bearOqK2txRhDZGRku8eGhoVTV1vjgajapxUYbnTo0CHLnkoBREdH06tXL01gKI9yJA+GeLiBJ0BEVC/6DRhEmSYwlHK7psZGSg/tt2z5iMP48ePZtWsXTU1NlsahlDs0Njby2Wefke4j41OvNW7yLM5VnGTfvn1Wh+ILrkyrE5EQbE3dVzh2GmMuGGOijTEJxpgEIBfQ5IXqtKqqKgCne2A01Nd5xWutJjDc5NKlS5w8edLSBIaIkJSUpAkM5VGOBEZcoucTGI77agWGUu5XXlJEfV2tVyQwqqurOXBAf++V/8nNzeX8+fOkT77J6lA6ZeykWQB8/PHHNz5QdWRanVIu4UhgOFOBEdYj/KpzrKQJDDdxNPC0MoEBkJycrAkM5VHHDhcSFh5JdOzg9g92g7jEkZSXFNHQ0GDJ/ZXqLo4U7gVgwoQJlsaRlZUFwPbt+hBS+Z+VK1cSGBjImInTrQ6lU/rGxBKfnKoJDCcZYz42xiQbYxKNMT+3b/uxMWZFK8fO0uoL1RUdrcAAuHz5sltjcoYmMNzEkTSwOoGRlJREaWkpdXV1lsahuo9jRYUMHTHSslLXuBEjaWps0KexSrlZ8f69hIVb18DTYeTIkURERGgCQ/mllStXMm3aNMIje1odSqeNm3wTmzZt4ty5c1aHopRqwZGM0AoMBcDBg7YpCI5GmlZJTk6mublZJ5EojzDGUGpPYFhl6IhRAOzdu9eyGJTqDo7sz2PYyDQWbStj4dZSyxpWBwYGkpmZqQkM5XdKS0vJy8vjjjvusDqULhk39Waampr47LPPrA5FKdVChxIY4RFXnWMlTWC4yYEDB4iLi7NshKpDcnLylXiUcrczJ8upqbpEnD2JYIWB8cMJDApmz549lsWglL9rbKintGg/w0eNteT+joSJI2mSlZXFrl27aGzUpWPKfziWXfh6AmPE6Az69evHypUrrQ5FKdVCxyowNIHh9w4cOEBKijVNDFvSBIbypGNFhQCWVmAEBQUzeFiSJjC6GRGZJyIHRKRIRF5oZf8MEdkpIo0icv81+x4XkUP2r8c9F7XvKi0qpKG+jsTUcVaHAkB2dja1tbWUFR+0OhSlXObDDz9k+PDhjBpl3UMBVwgIDOT222/n448/prGx0epwlFJ2jmSEUz0wwnUJiV8zxnhNAqNnz54MHDhQExjKI44eykdEiEu0LoEBEJ+UqgmMbkREAoHXgduAVOBhEUm95rBS4Alg4TXn9gV+AkwEsoGfiEgfd8fs6w7n7wZgeGq6xZHYqjFOhgwBoLhAf++Vf6iqqmL1mrUkT5jFe18eszqcLrvrrrs4e/YsW7ZssToUpZTdpUuXgI5VYDjOsZImMNzg1KlTXLx40SsSGAApKSmawFAecfTQfgYMSaBHRPv/ELpTfHIqJ0+e5NSpU5bGoTwmGygyxhQbY+qBRcDdLQ8wxpQYY/YCzdecOxdYbYypNMacA1YD8zwRtC87XLCHnn2iLZs2dK3+g+KI7NXnSmJFKV+3Zs0aGurryJg22+pQXGLu3LkEBwfz4YcfWh2KUsrOUYERFRXV7rE+3QPDiTLd50WkQET2ishaEYl3Tai+o7DQVkY/cqS1T6EdRo4cSWFhIcYYq0NRfq70UAFDk6wvdXXEoFUY3cZgoOUjyjL7NpedKyJPich2EdleUVHR6UD9xeGC3QxPHWvZtKFriQjDR42lqEATGMo/rFixgh4RUYwcl211KC7Rs2dPZs2axYoV100DVUpZpCNLSBwJDJ+rwHCyTHcXkGWMGQssAX7pikB9SUFBAYDXrFkcNWoU586d06fRXsCJBOATIlIhIrvtX//UYp9Xr9OvrrrEqbKjV6aAWCl+hO2fpV27dlkcifIXxpg/GGOyjDFZ/fv3tzocS50/f57jJUWMGJ1hdShXGZGWSXnxQWqqrH86pFRXNDU18eGHHzJu6k0EBYdYHY7L3H333Rw4cODKgz6llLUuXbpEeHg4gYGB7R7rGKPqcwkMnCvTXWeMqbb/mAsM6XqYvmX//v1ERUUxeLA1pbXXdmdPTU29EpeyjpMJQID3jTHj7F9v2M/1+nX6Rw/aEnfDRqZZHAlE9upNfHw8u3fr09huohyIa/HzEPs2d5/bLX355ZcAJKVlWhzJ1ZLSMjDGULxfK6+Ub9uyZQsVFRVkzZhrdSguNX/+fACWL19ucSRKKbBVYDjT/wIgOCSUwKBgn0xgdLRM90ngk9Z2+HM57v79+xk5cqTXlNY6KkEclSHKMu0mAG/A69fplxzYB0BCivUJDID+CSNZv/nLK4k85de2AUkiMkxEQoCHAGfrlFcBc0Skjz0pOMe+TbUhNzfXtmQj1ZoRqm1xTEQp2qeVV8q3LVu2jJCQENInz7I6lA659gHateLi4sjKymLZsmUejkwp1ZpLly7Rs2dPp4/vER7hmz0wnCUi/whkAa+2tt+fy3H379/vNctHAAYNGkTPnj01gWE9ZxOA99l7yCwREceTYaeTh1YlB0sO7KN3dAy9+8V47J43kpCSxonSYqqrrM8UK/cyxjQCz2JLPOwHFhtj8kXkJRGZDyAiE0SkDHgAWCAi+fZzK4GXsSVBtgEv2bepNuTm5jIoYQThkc6/6fGEiJ69GBSfyMG8HVaHolSnGWP44IMPmD17tuUNsd3hnnvuITc3l/JyLXRTymoXL150qoGnQ1h4JBcvXnRjRM7paALDqVJbEbkF+BEw3xhT1/nwfE9lZSXHjx8nLc07nkKDrbnZ6NGjyc/PtzoU1b4PgQR7D5nVwDsdvYBVycGSA/tISB7tsfu1x7GUxbG0Rfk3Y8zHxphkY0yiMebn9m0/NsassH+/zRgzxBgTYYzpZ4wZ3eLcN40xI+xfb1n1d/AFzc3NbNmyheSxWVaH0qqkseMpyttJc/O1w2aU8g27d++muLiY++67z+pQXMpRmRE6YjIAH3zwgcURKaUuXbrUoQRGj4hIn1xC0m6ZrohkAAuwJS9OuyZM3+FIEnhTAgNg9OjR7Nu3TyeRWKvdBKAx5myLpN8bwHhnz7VSbXUV5SVFDBvlPSXlw1LGAHBk/16LI1HKf+zfv5/z58+TNGZ8+wdbIHnMeC5fPM/J0mKrQ1GqU5YsWUJgYCB33+3sClPfMihhBKmpqSxZsuS6fe0tQVFKuVbHKzAifC+B4UyZLrYlI5HA3+xTFLrVvCRHAqOooY9X/SOclpbG2bNnOX262+WUvIkzCcCBLX6cj+33DLx8nX7JwXxMczPDR6VbHcoVvfr1p9+AQRQXagJDKVfZvHkzACleWoHhqAw5uHe7xZEo1XHGGJYuXcqsWbOIjo62Ohy3uf/++/niiy90Op5SFutMBYYvLiFxpkz3FmPMgBZTFObf+Ir+Zd++ffSIiKJvzMD2D/YgR0VIXl6exZF0X04mAJ8TkXwR2QM8BzxhP9er1+k7qhyGjxpjcSRXGzZyDMUFmsBQylU2btxI//79GRCXYHUorRoYn0hkrz6awFA+KS8vjwMHDnD//fdbHYpb3X///TQ3N/P3v//d6lCU6tZOnz3P6bpApx+494iI8s0EhrqxPXv2EJeY4jUTSBzGjLF9sNy7Vz/MWcmJBOAPjTGjjTHpxpibjDGFLc712nX6h/fvoU//WK9p4OkwPDWdU2UlVFZ6Ta5HKZ+2YcMGpk+f7nWvcQ4iQkr6BAp3f2l1KN2eiLwpIqdFZJ/VsfiKRYsWERgY6Hf9L66VlpZGamoqixYtsjoUpbq1mupLhEd0gwoM1TZjDHv37mVokvdMIHGIiYkhNjaWPXv2WB2K8hMt16oezt/NiNHjrA7pOomptiUt27ZtszgSpXxfWVkZJSUlTJ8+3epQbiglfQKnyo5y4sQJq0Pp7t7Gy8Z9ezNjDIsWLWL27Nn423S+a4kIX//61/niiy90GolSFqmvr6ehrq5D0456RERy4cIFN0blHE1guNDRo0e5ePEi8UmpVofSqvT0dK3AUC538dxZTpeXMiItw+pQrjM8NR0RYevWrVaHopTP++KLLwC8PoExclw2YKsWUdYxxmwAtPzNSdu2bePIkSM89NBDVofiEV//+tcxxrB48WKrQ1GqW3JUUnQsgRFFdXU1jY2N7grLKZrAcCFHdUPciJEWR9K6sWPHkp+fT319vdWhKD9SlL8bgMTR3pfACI+IYvCwJHJzc60ORSmft27dOnr27Mm4cd5XbdVSQkoaYeER5OTkWB2KcoKIPCUi20Vke0VFhdXhWObdd98lNDSUr33ta1aH4hEpKSmMHz+ed9991+pQlOqWzp8/D0B4ZE+nz4mIsh1r9TISTWC40M6dOwkICGDoCO9bQgKQmZlJQ0MDBQUFVoei/EhR3g4CAgMZNtK7Gng6jBidQW5uLs3NzVaHopRPy8nJYcaMGQQGBlodyg0FBgWRkj5BExg+whjzB2NMljEmy9+XTrSloaGBRYsWMX/+fHr37m11OB7z6KOPsnPnTn1fqpQFHEtBekR2pAeG7VhH8sMqmsBwoZ07dzJq1ChCw3pYHUqrMjMzAVucSrnKwb07SEgeTViPcKtDaVVyehbnzp2jsLCw/YOVUq0qLy/n0KFD3HTTTVaH4pTU8ZMpLCzUPhjKJ6xatYqKigoeffRRq0PxqIceeojAwED+8pe/WB2KUt2OI4HRkSae4fZkh9V9MDSB4UI7d+68kiTwFi0bLX55NoTIyMgrCYyW+5TqjMbGBg4X7CZpzHirQ2mTI7ZNmzZZHIlSvmvt2rUAPpPAGJ01FYDPP//c4kiUat/bb79NdHQ0c+fOtToUjxowYABz587lL3/5C01NTVaH4xVEZJ6IHBCRIhF5oZX9z4tIgYjsFZG1IhJvRZzK911ZQhLl/BISx7FageEnTpw4wfHjx70ugdFSQEAAmZmZbN++3epQlJ84eiCf+rpaksdmWR1KmwYOHU50dDQbN260OhSlfNaaNWvo378/6enpVofilPikVPr27cuaNWusDqXbEpH3gC1AioiUiciTVsfkjSoqKlixYgWPPvooISEhVofjcd/85jcpLy/ns88+szoUy4lIIPA6cBuQCjwsItdOBtgFZBljxgJLgF96NkrlLxxJiIioXk6f4zhWExh+4ssvbTPnJ06caHEkN5adnc3u3bu1kadyif27bM0xR2ZkWxxJ20SE6dOn60QCpTrJGMOaNWuYPXs2AQG+8bYhIDCQ2bNns3r1aowxVofTLRljHjbGDDTGBBtjhhhj/mR1TN7o3XffpaGhgW9+85tWh2KJu+66i+joaN58802rQ/EG2UCRMabYGFMPLALubnmAMWadMaba/mMuMMTDMSo/ce7cOeCrxpzOiLA3/HScaxXfeCfiA7788kuCgoK8vjt7dnY2dXV15OXlWR2K8gOFu75k4NDh9O4XY3UoNzRz5kxKSkooLdXlUkp11L59+zhx4gS33HKL1aF0yK233kp5ebk2CFReyxjDH//4R7Kzs0lLS7M6HEuEhITw2GOPsXz5ci6c7b5TaOzrjY7WAAAgAElEQVQGA8da/Fxm39aWJ4FPWtuh031Ue86fP48EBBAW7vwYVccSEk1g+ImtW7cyZswYevTwzgaeDtnZtiflW7dutTgS5euam5o4sGcbIzO8u+oIYMaMGQCsX7/e4kiU8j0ff/wxALfddpvFkXTMvHnzAPjkk1bf3ytluQ0bNrB//36efvrpK9u6Y3+yp556ioaGBnI+fN/qUHyGiPwjkAW82tp+ne6j2lNZWUlEZM8OVVb2iIgiICBAExj+oLGxka1btzJ58mSrQ2nX0KFDiY2NZfPmzVaHonzckQP7qL58kdTx3v///dixY+nbt6829FOqEz755BPS09MZNGiQ1aF0SFxcHGlpaZrAUF7rd7/7Hb179+brX/+61aFYKiUlhZtvvpm1yxbS3L2beZYDcS1+HmLfdhURuQX4ETDfGFPnodiUnzl37hwRPTs2tjkgIIA+ffpoAsMf7Nu3j8uXLzN16lSrQ2mXiDB16lSdyKC6bN82W1PM0eOnWBxJ+wIDA7nppptYu3atrof3U050bg8Vkfft+7eKSIJ9e4KI1IjIbvvX7z0duzc7d+4cGzdu5Pbbb/e5J8MLt5aSMG4a69dv4I21+6wOR6mrlJeXs3TpUp544gnCw71zDLknffvb3+bsyXJ2buzWjXe3AUkiMkxEQoCHgBUtDxCRDGABtuTFaQtiVH6isrKSyA4mMAD69u3L2bNn3RCR8zqcwHDiTeIMEdkpIo0icr9rwvRujmTAlCne/0EObHGWlJRwruKU1aEoH5a/bSNxiSPp1c83ShNvueUWjh07xqFDh6wORbmYk53bnwTOGWNGAL8CXmmx77AxZpz962nUFZ988glNTU3Mnz/f6lA6JXP6LTQ1NbJniy4fU97lt7/9LU1NTTz77LNWh+JxrSVD77nnHvrFDubTRd23macxphF4FlgF7AcWG2PyReQlEXH8I/wqEAn8zZ50X9HG5ZS6obNnzxLR0/kJJA59+/alsrLSDRE5r0MJDCffJJYCTwALXRGgL9iwYQN9Yway6aT4xJOp6dOnA1C4W/tgeFpX5nuLSFOLp8SWvmBdvnyZA3u2M2bidCvD6JA5c+YA8Omnn1ociXKDdju3239+x/79EmC2iIgHY/RJy5cvZ8CAAVf6J/mapLRMevbpx44vdESj8h7V1dX8/ve/55577iExMdHqcLxCUFAQcx94nP27cik50H0rpowxHxtjko0xicaYn9u3/dgYs8L+/S3GmAEtku6+mV1Wljtz5gxRvft2+Lzo6Gifq8BwZrxPiTFmL9Dsohi9mjGGnJwcRmVOwlfeC2dkZBAVFUXBzlyrQ+lWXDDfu8ZbXrDWrVtHY0M96ZNnWRlGhwwfPpzk5GRdD++fnOncfuUY+1OuC0A/+75hIrJLRNaLSKtZue7Y0b2mpoaVK1cyf/58nxmfeq2AwEAyp93Cro2fU1tba3U4SgHw5ptvUllZyfPPP291KF5l1vyHCAuP4KO/LrA6FKX83tmzZzuVwLhoenD0+ClLH9p39B1JR8f7+L39+/dz+vRpUjMnWR2K04KCgpg+fTr7NYHhaX4z33vlypWE9ggnJX2C1aF0yO233866deuoqqqyOhTlPU4AQ40xGcDzwEIRuW4oenfs6L5q1Sqqqqp44IEHrA6lS7Jvvp3a6susXr3a6lCUoqGhgVdffZVp06Yxbdo0q8PxKhFRvbjl3kfJXfMRRUVFVoejlN+qq6vj0qVLneqBEdW7D5fP+9ASElfyl6dZa9bYmg2lZvlG/wuH2bNnc+LoYc6eOm51KN1JV+d7h9l/Z3JF5J62TnL371ZzczMffvghYyfNJDgk1OXXd6e77rqLuro6/SDjf5zp3H7lGBEJAnoBZ40xdcaYswDGmB3AYSDZ7RH7gMWLF9OvXz9mzZpldShdMnrCVCJ69uL993VEo7Leu+++S2lpKT/84Q+tDsUr3fbwkwQFBfOLX/zC6lCU8luOzwe9+kZ3+NyevftRV1tDbU11+we7SUcTGE6N93GGvzzN+uyzz0hKSiJm0FCrQ+kQRz+AvC+/sDgS1Zo25nvHG2OygEeAX4tIqwtn3f27tWPHDo4fP874GXNcfm13cTQLKwuNp3fv3ixfvtzqkJRrtdu53f7z4/bv7wc+N8YYEelvX96FiAwHkoBiD8XttS5dusSyZcsYN+M2/rbzhE/0d2pLUFAw2TfdzrJly7T6Slmqvr6el156ifHjx3PbbbdZHY5X6t0vhpvveYS3335bqzCUchNHAqMzS0ii+tjOuXjujEtj6oiOJjCceZPYbdTW1rJu3boryQBfMnr0aPr0H8CeLTlWh9KddGm+tzGm3P5nMZADZLgz2LYsWbKEoKAgMqbcbMXtuyQoKJg777yT5cuXU19fb3U4ykWc7Nz+J6CfiBRhWyriaKI7A9grIrux9Z152hhjbW2kF/jggw+oqalh6rw2i718ytR5X6Oqqoply5ZZHYrqxt58801KSkr42c9+5jN906ww//HvEBISwosvvghcPbXEl5OpSnmLU6dskyg7U4HhOOdipXWNPDuUwHDmTaKITBCRMuABYIGI5Ls6aG/x+eefU11dzZ133ml1KB0mIoybcjN7czfQ2KAf5Dyk0/O9RaSPiITav48GpgIFHovczhjD4sWLufXWW4ns1fF1c97gwQcf5Ny5c6xdu9bqUJQLOdG5vdYY84AxZoQxJtueCMQYs9QYM9reHDfTGPOhlX8Pb/HWW2+RmJhI8tgsq0NxiZT0CSQkJPDWW29ZHYrqpi5dusSLL77ItGnTmDt3rtXheLXe/WJ47rnnWLhwITt37rQ6HKX8zsmTJwHb71pH9eprq+4+X2ldC4gO98Bw4k3iNmPMEGNMhDGmnzFmtKuD9hYffvghERERPrs+OHPaLdRWX6ZgZ65mtj2gi/O9RwHbRWQPsA74hTHG4wmMrVu3UlJSwoMPPujpW7vMnDlz6N27NwsXdptJz0p1yKFDh8jJyeHJJ5/0m6fEAQEBZM25l7Vr1/Krpbp0UnneK6+8wqlTp/iv//ovv/m9cqcXXniBfv368fzzz2OMsTocpfyKI4HRsxMVGI6kx4WzPpTAUDZNTU188MEHzJs3j7CwMKvD6ZS0CdMI7RHOtnU6VtJTOjvf2xiz2RgzxhiTbv/zT1bE/84779CjRw/uvfdeK27vEqGhoTz44IP8/e9/59KlS1aHo5TXWbBgAUFBQTz++OPtH+xDZt75dQICA/l8mSYvlWcVFRXxX//1XzzyyCNMnDjR6nB8Qu/evfnpT3/K+vXr2bp2pdXhKOVXjh8/Tq9evQjrEd7hc3v1jUZEOH/mdPsHu4kmMDrpiy++4NSpUz79JDokLIyMqbPZlvMpTY2NVoejvFx1dTWLFi3i3nvvpWfP66ZM+pTHHnuM6upqFi9ebHUoSnmVqqoqfrfgj2TNuo2cY/71utA3JpasmXNZt+I9qqut656uuhdjDM888wyhoaG8+uqr7Z+grvjnf/5nMjMz+cuvf0r15YtWh6OU3ygvL2fgwIGdOjcwKIhefaOprDjp4qicpwmMTvrrX/9KREQEd9xxh9WhdMi1S0Um33oXl85X6jQS1a7Fixdz/vx5vvWtb1kdSpdNmTKFUaNGsWDBAqtDUcqr/OlPf6L68kXmPviE1aG4xbwHv0nVxQvaC0N5zJ///Gc+++wzfvaznzFo0KDr9muDytYt3FrK+9vLuefZF7lQeYaF//t/rQ5JKb9RVlZGXFxc+we2oW/MQCpPn3BhRB2jCYxOcDy5vf/++4mIiLA6nC4ZN+UmInv1YcPKJVaHoryYMYbf/OY3DEoYQVlogs+/yRIRvv3tb7Nt2za2bt1qdThKWcrxwenPG4t46f++Qsq4bL9p3nmt5PQsksaM59VXX6WhocHqcJSfO3bsGM899xzTp0/nmWeesTocn5SYms4djzzFuuXvsXvzOqvDUcovHDt2rMsJjDMnrxuk6DGawOiE999/n4sXL/KNb3zD6lC6LCg4hGnzvsb29au4UGndPF/l3TZs2MCOHTu47SH/aer3xBNP0KtXL1577TXg+uokpbqbnBXvc/bUce554lmrQ3EbEeGebzzL0aNHr1Rh6O++coeGhgYeeughmpubeeuttwgI0LfcnXXft/6VIYkpLHj5e5yrOGV1OEr5tLc3HOTEiRNcDOr8NMHogUM4e7Lcsga7+q9pBxljeP3110lNTb3yJNrX3/TM/to/0NTY0GpjM31jpwB+/vOfExMTw7R5vtu881pRUVE8/fTTLFmyhAMHDlgdjlKWqq2u4oO3/oeU9AmMmTjD6nDcKn3yTUyePJmXXnqJqqoqq8NRfuqFF15g8+bN/OEPfyAxMdHqcHxaSGgYz/3sdepqqvnf/3yG+vr6ds/R969Ktc5RORE9sPMVGP0HxlFXW8Pp09Y08tQERgfl5OSwY8cOvvvd7/rNk+hBCSMYO2kmn/3tHepra60OR3mZL774gtWrV/P973+fEB+duNOW559/nrCwMF588UWrQ1HKUsvfeZ3zZ07z8LM/9JvXtraICK+++irl5eW88sorVoej/MC1H5bfeustXnvtNZ555hkefvhhi6Pzbs4mGgYPS+Kf/uMVDuzZxne+850rT341UaFUx5wqKwEgdkh8p68RG2c7t6ioyBUhdZgmMDrAGMNPf/pTYmNjeeyxx6wOx6XuevTbXDx3hs+X63g59ZXm5ma+973vMXjwYL797W9bHY5LtHyzExMTw7/+67+yaNEiivbtsjo0pSxx7PABVv71D0y77V6Sxoy3OhyPmDp1Ko888givvPIKZUcOWh2O8iMffvgh3/rWt7j11lv59a9/bXU4fmXKnLu5+4ln+dOf/sRPfvITq8NRyicdLzkMQOzQ4Z2+Rmyc7VyrKpg1gdEBn376KevXr+dHP/oRYX72JDp1/GRGZ01h+du/4cKFC1aHo7zEH//4R7Zt28Zd//RvLMvzzx4pP/jBDxg4cCBv/fJHOk5YdTv19fX8/qXnCY+M4h+e+0+rw/GoX/3qV0RFRbHgpe/R2NB+SbpS7dm9+XMeeOABMjMzWbp0KUFBQVaH5Hce+Od/48knn+Tll1/mZz/7mWVr8JXyVeUlh+jZpx9Rvfp0+hoxg+IIDgmloKDAhZE5TxMYTqqpqeG73/0uycnJfjFGsjUPP/sf/H/27jw+rrre//jrk31p6L43TUJXu9El0JYCsohWREARbgERRMGL4gr4E0XE7V68CIKiXkEQrlC2ggoi0AJFtpI2bUr3dM/SNd2XNGmbfH9/zExIQ5ZJMjNnzuT9fDzyyOSs70xy5pz5zPf7PQf37eGOO+7wOorEgc2bN3PrrbcyZsp0zpj5Oa/jRE1OTg73338/m9eu5IX/+4PXcURiItQK6bNf/BqbS1fw1dvu4qSevb2OFVP9+vXjT3/6ExtXL+PJ39/ldRzxuXdefp57v38D48aN4+WXXyYnJ8frSAnJzPjTn/7ENddcw49//GMev//n1NfVeR1LxDcq1q8hd9joTm0jKTmZwQUjWLZsWYRStY9Kw2G6/fbbWbduHT+4/3GeW5qYIyAXjB7PeZ//Ir/73e+49NJLOeusxB7ITVpWU1PD5Zdfjplxw+2/Tvg+8ZdddhnTz7+I5x++j1GnnApTh3odSSTqXnvur8x99lE+PesrFH78U17H8cSll17Kpy7/Mq889TCD8oZx5dTbvI4kcaTxuApXtnBeOHbsGLN/91+89MSfGDNlOq+//jLdu3dvdVvSOcnJyTzyyCP06NGD+++/n21lG7jxzvsAnbtFWlNbW0v5+jV86vLO30kzf9Q4it9+FedczN8nqAVGGJ577jnuvfdevv71rzN+6plex4mqK75xG8OGDWPWrFls2eLd/X3FO8ePH+fqq69m0aJFPPbYY/QdOMTrSDFx3Q/+iwFD8rnvtq+xcuVKr+OIRNW///kMj/76x0yacR5X3PRDr+N46qpv3c4p08/mL//zIx577DGv44iPrFq1ijPPPJOXnvgTn/j8F/l/9/1fs8ULibykpCTuu+8+vvz9X7Ky+D1u++JMXn75Za9jicS1xYsXc/zYUUaMm9TpbY0YP5m9e/eyevXqCCRrHxUw2vD6669zxVVXMXzcJE79j297HSfqMrKyee655zh48CAzZ85k/57EHPdAmldTU8OVV17JnDlzuOeee7jkkku8jhRVjQf0zMrO4dbfPEpqahrnnHMOS5Ys8TqeSMTV1dXxk5/8hAd/cSvjTjuTb/3yDyR3wX76jY/95JQUvv3f/8vYU8/g2muv5ac//Sn19fVeRxSPhHNXiz179nDrrbcyceJE1q9fzzd/8Xu+/P1fkpKaFsOkAvCJz3+ROx96nqxuOVxwwQVceumlrF3b+YF5dXcTSURz587FzBg9eVqntzVmynQA5s2b1+lttZcKGK149NFHueCCC+g/JJ+b736YtPTEGrizJSuO9OBbdz3I2nXr+ekNl1Kxoe0RZvVC73+lpaWcccYZPPvss/z617/me9/7nteRYq7foKHc/sdnqE9OY/rpM/jqbXfxxPtl+t+WhLBmzRrOPfdcfvazn3HWZy7j5rv/nHC3Ru6o9IxMbvn1w3zpS1/izjvv5Nxzz/VsdHWJXxs2bOCWW24hPz+fe+65h6uvvpqVK1cy7RMXNizT+HpI10axUTB6PL987CV+/vOf88orr/Cxj32MB+74JuuWL9YgnyIEXpeeeL+Mhx9/ihHjp3RqAM+QfoOGMmbMGObMmROBhO3T7gKGmc00s1IzW29mP2hmfrqZPR2cX2Rm+ZEIGm2NTzK/fvoNLr74Yr785S8zY8YMfvyHZ7rc4GZjC2fwwwdmU1N9mNuvvZA5D96ju5NEQGeOHzO7LTi91Mwi1mF969at3HzzzUyYMIGNGzfy97//nZtvvjlSm/edgUNP5ucP/4MR46fw8F238dMbLmXFwnd0ERTn4vHYihcffPAB1113HePGjWPZsmU8+uij3HD73aSmpXsdLa6kpqXz6KOP8sgjj7B06VLGjh3LV77yFc8GKUuEN8JtHZfxzjnH1rINvPzUw4yeeBrDhw/nN/fdx2c+8xmWLVvGww8/TP/+/b2OKQSO39tvv52NGzfyve99j6XvzufO6z/P92edxx133EFRURF1PhjsM1HfZ4n3Vi1ZQOWGUs684NKIbfNLX/oS77zzDiUlJRHbZjisPRflZpYMrAXOByqBRcAVzrlVjZb5OjDBOfefZjYL+Jxz7j9a225hYaErLi7uSP5OaXohULZuFU8+8N8sL3qLjKxsPnfdt7jgiutJSk6OebZ4sX93FX+9/2csmPsCOTk5zJo1i/vvv5/MzMwWL6RaGugqQYU9ak1njh8zGwM8CZwGDAJeA0Y651o9G7d0bO3du5enn36aF198kVdfDQzAc/XVV3PXXXcxYMAA310kR0N9fT1v/fMZ5jx0L3urdjAgt4Brr/oPvvCFLzBlypQTlg1noDdpl3aNBhXrY8urc1a46uvrefXVV3nzzTd56aWXWLlyJZmZmVx//fX86Ec/ol+/fjrGWxA6fnfu3MkvfvELHnroIWpqahg3bhwXXHABZ599NjNnzozJgGVROMfGdJS1cI7LpiJ9bLX3tbmmpobb7nuMio1rKVu7kvUrS9i3aycAucNGM/38z3LGBZfyzc9ObXE/4p3Gf+OH31jF+6+9yLuv/p3SpQupr68nJyeHqVOnMnnyZMaPH8/555/P65trm12/nf87ETm2Eu19lnin6WvSkcOHuOMrF1NTfZh7nnkzYq0vDx/cz/cuPYt+Q/JYtaSI9PSIfjDS4nHV3o6vpwHrnXMbAczsKeBioPHJ6GLgzuDjOcADZmbOw48vw30RSk/PZFvZRj7/1e9y/qVXd7lWF83p3rsvN/3sd1x41dd45em/8MZ7xTz/wc5WL97Cuehqukwk3/TF8ZvJDh8/welPOedqgU1mtj64vQUdCbJ//35uvPFG8vPzueWWW7jhhhs4+eSTO/RLJaqkpCTOvmgWM2Z+jgXzXuSdl5/jf+6+m+UVe7nym31bXK+9F7KtHRfNLdMRcXxMRErcHFvx4MmFFXzzmus4sHc3Z54xgwceeIArrriCXr16eR0t7jU+VqZddQvjLvwq7839O2WL53Pvvffy1FNPUVZWFtb6jSXocdeWcI7LuBD6u9XWHOH+H94IQP8h+YydcjqjJp7G+NPOpN/gtl+rJX5kZnfjnIuv4JyLr+CTw7J47bXXeOuttygqKuI3v/kNx44d47XXXoNuIxrWiYO/qy/fZ3UFnf3fiMU5oLWM1YcOkJqWxjU3/zSiXUezc7rz1R/+ihf/+r/s37+ffv36RWzbrWlvC4wvADOdc18N/nw1MNU5d1OjZVYEl6kM/rwhuMyuJtu6Abgh+OMoIB47m/YB4nkUS+XrnEjk2+WcmxnOgp05fgicrN53zj0enP4w8LJz7iMdz+L82Ir3/4mmlDf6mssc9nEFsTm24uC48tPf1i9Zu1rOdh1XnRXOcRmcHqtjK97/3srXcV5ni8ix1QXfZ4V4/feLBP0OkdficeXZ0OPOuQeBB73afzjMrNg5V+h1jpYoX+fEe76Oiudjy2/PufJGn18ye31c+eV5Av9kVc74EKtjK96fR+XruHjO5hWvz1ntkQh/P/0OsdXeQTy3ALmNfh4SnNbsMmaWAnQHdnc0oEgC6czxE866Il2Vji2R+KNjS6R99D5LJAztLWAsAkaYWYGZpQGzgBeaLPMCcE3w8ReAN9QvSwTo3PHzAjArOPp0ATACWBij3CLxTseWSPwJ57gUkQ/pfZZIGNrVhcQ5d9zMbgJeBZKBR5xzK83sZ0Cxc+4F4GHgr8GB0PYQOPj8Kt6bXilf58Q0X2eOn+ByzxAYyOk48I227kASp+L9f6Ip5Y2+TmfuIseWn/62fsmqnFHU0nHpYaR4fx6Vr+PiOVvYuuD7rJBE+Pvpd4ihdg3iKSIiIiIiIiLihfZ2IRERERERERERiTkVMEREREREREQk7qmAEWRmj5jZzuD9lUPTJprZ+2a21MyKzew0D/Plmtl8M1tlZivN7NvB6b3MbJ6ZrQt+7xln+e42szVmtszM/mZmPeIpX6P5N5uZM7M+XuRLZGaWYWYLzeyD4HP/U68zhcPMks2sxMz+6XWWcJjZZjNbHnq98jpPW8ysh5nNCb4+rDaz6V5nihctnI/i4rW+qRay3mlmW4L/i0vN7AIvMwYzxfU5NIyccfecxhMzm2lmpWa23sx+0Mz8a82sqtHz99VG864J/v3Xmdk1TdeNQbbfNMq11sz2NZpX12heVAZAbe4YbjLfzOy3wfzLzGxyo3nRfu7aynZVMNNyM3vPzE5pNM9X58Suwi/njJb45VzSmoQ4zzjn9BUYB+QsYDKwotG0ucCng48vAN70MN9AYHLwcQ6wFhgD/A/wg+D0HwC/irN8nwRSgtN/FW/5gj/nEhgwqQzo4+X/YSJ+AQZ0Cz5OBYqAaV7nCiP394DZwD+9zhJm3s1++v8FHgO+GnycBvTwOlO8fLVwPoqL1/ows94J3OJ1tiY54/ocGkbOuHtO4+WLwGCHG4CTg68lH4TO742WuRZ4oJl1ewEbg997Bh/3jGW2Jst/k8DAjaGfD8Xg+fvIMdxk/gXAy8Fz+TSgKBbPXZjZTg/tE/h0KFvwZ1+dE7vKl1/OGa3k98W5pIO/g2/+DmqBEeSce4vAaL4nTAZOCj7uDmyNaajGQZzb5pxbEnx8EFgNDAYuJvBGgOD3S+Ipn3NurnPueHCx9wnc0zpu8gVn/wb4PoG/t0SYCzgU/DE1+BXXz7WZDQE+A/zZ6yyJyMy6E7iIeRjAOXfUObev9bW6jhbOR3HxWt9UC1njTryfQ0PaOFdJ804D1jvnNjrnjgJPEfi7huNTwDzn3B7n3F5gHjDTw2xXAE9GcP9tCuMYvhj4v+C5/H2gh5kNJPrPXZvZnHPvBfcNHl5jSvj8cs5oiV/OJa1JhPOMChit+w5wt5lVAL8GbvM4DwBmlg9MIvBJdn/n3LbgrO1Af49iNWiSr7HrCFTxPdU4n5ldDGxxzn3gaagEZ4HuGEuBnQQueJr+b8Sb+wgUteq9DtIODphrZovN7Aavw7ShAKgC/mKBbjp/NrNsr0PFubh7rW/DTcGm3Y/EW1PaeD+HhjRzLo3b59Rjg4GKRj9X0vzF+KXB52+OmeW2c91oZ8PM8gi8Nr7RaHKGBbowv29mXr0haul3iPZz115f4cRrTD+dE8WHr29+OZe0xq/nGRUwWncj8F3nXC7wXYKfFnrJzLoBzwHfcc4daDzPBdoCefrJdkv5zOxHwHHgCa+yBXM05Avm+SFwh5eZugLnXJ1zbiKBT0dOM7NxXmdqiZldCOx0zi32Oks7neGcm0ygGe03zOwsrwO1IoVAE9I/OucmAYcJNLmUMMTDa30b/ggMAyYC24B7vI3zoXg/h4Y0kzNun1OfeBHId85NINBS4LE2lvfCLGCOc66u0bQ851whcCVwn5kN8yZafDOzcwgUMP5fo8l+Oid2db57ffPLuaQ1fj7PqIDRumuA54OPnyXQFNAzZpZK4B/tCedcKNeOYFM+gt93xlk+zOxa4ELgquBB7Ylm8g0j8GnHB2a2mcCb6yVmNsCrjIku2E1gPhFuZhphM4CLgv8TTwHnmtnj3kZqm3NuS/D7TuBvePx61YZKoLJRS5w5BAoa0rK4ea1vi3NuR7BoWQ88RJz8L8b7OTSkuZzx+pzGiS0ExrIKGRKc1sA5t9s5Vxv88c/AlHDXjXa2RmbRpPtIo9f1jcCbBD4pjbWWfodoP3dhMbMJBP6mFzvndoem++yc2KX57fXNL+eS1vj9PKMCRuu2Ah8PPj4XWOdVEDMzAi1AVjvn7m006wUChRaC3/8R62zQcj4zm0mgKdYu5pAAACAASURBVP5FzrlqL7K1lM85t9w51885l++cyyfwpmqyc267VzkTkZn1teDdZ8wsEzgfWONtqpY5525zzg0J/k/MAt5wzn3R41itMrNsM8sJPSYweG6zo7bHg+AxVmFmo4KTzgNWeRjJD+LitT4coYu4oM8RB/+L8X4ODWnlXBp3z2kcWQSMMLMCM0sj8Lp9wh07mjx/FxHo8w2BAbw/aWY9g82lPxmcFrNswXyjCQyEuaDRtJ5mlh583IdAcd2L18kXgC9ZwDRgf7CpfLSfuzaZ2VACHzRe7Zxb22i6r86JXZ2fXt/8ci5pTSKcZ1K8DhAvzOxJ4Gygj5lVAj8BrgfuN7MUoAbwsg/dDOBqYHlwLAEIdH+4C3jGzL5C4C4al8dZvt8C6cC8wPHC+865/4yXfM65f3mQpasZCDxmZskEiqbPOOd8cWtSH+kP/C14jKUAs51zr3gbqU3fBJ4IXtRvBL7scZ640cL5KF5e60/QQtazzWwigSa0m4GveRbwQ/F+Dg1pKecVcficxgXn3HEzu4nAm+dkAnfxWGlmPwOKnXMvAN8ys4sIdB3dQ+CuJDjn9pjZzwkUGgB+5pyL2ACDYWaDQGHjqSatVD8G/MnM6gmcO+9yzkW8gNHCMZwazP+/wL8I3IlkPVBN8LU62s9dmNnuAHoDfwie/44Hu9z48ZzYJfjonNESv5xLWuP784x52KJfRERERERERCQs6kIiIiIiIiIiInFPBQwRERERERERiXsqYIiIiIiIiIhI3FMBQ0RERERERETingoYIiIiIiIiIhL3VMAQERERERERkbinAoaIiIiIiIiIxD0VMEREREREREQk7qmAISIiIiIiIiJxTwUMEREREREREYl7KmCIiIiIiIiISNxTAUNERERERERE4p4KGCIiIuJbZna2mf2znet8x8yyopVJREREokMFjC7AzPLNbEUn1v+XmfVoZf4JF4JtLd/CNu40s1s6mlGko8wsxesMIn7nw+PoO4AKGCIiIj6jAkaM+PDiroFz7gLn3L5WFjnhQjCM5UUiJligW2NmT5jZajObEyqomdkdZrbIzFaY2YNmZsHpb5rZfWZWDHzbzD5rZkVmVmJmr5lZ/+Byd5rZY2b2tpmVmdnnzex/zGy5mb1iZqmdzH52MMucRr9DKONmM+sTfFxoZm92Zl8irfHzcRR0kpm9ZGalZva/ZpYU3PcnzWyBmS0xs2fNrJuZfQsYBMw3s/nB5f5oZsVmttLMfhqBPCIiIhIFKmCEKQEu7kK/R4aZ/SW47RIzOyc4PcvMnjGzVWb2t2DOwuC8zWbWx8yygxeIHwR/1/9o4UKw8RuvL5nZsuA6f43U7yHSxCjgD865jwEHgK8Hpz/gnDvVOTcOyAQubLROmnOu0Dl3D/AOMM05Nwl4Cvh+o+WGAecCFwGPA/Odc+OBI8BnmgYxs1vNbGkzX79tIfskAkXAMcDJwIwOPQMinefn4+g04JsEjqNhwOeD56HbgU845yYDxcD3nHO/BbYC5zjnzgmu/yPnXCEwAfi4mU0I90kTERGR2PFtqwCPjAK+4px718weIXBx92sCF3c/Awi+Sb8QeDG4Tlrwoggz60ng4s6Z2VcJXNzdHFxuGHAOgYuvBcClzrnvm9nfCFzc/b1xEDO7FbiqmYxvOee+1crv8A3AOefGm9loYK6ZjQz+Lnudc2PMbBywtJl1ZwJbnXOfCWbo7pzbb2bfI3AhuKtJxrEELh5Pd87tMrNereQS6YwK59y7wcePA98icGyeY2bfJ9BCqBewkg+PzacbrT8EeNrMBgJpwKZG8152zh0zs+VAMvBKcPpyIL9pEOfc3cDd7ci+0DlXCWBmS4PbfKcd64tEit+Po40AZvYkcAZQQ+Cc+m7wc4U0AufX5lxuZjcQuC4aGFxvWTv2LyIiIjGgAkb7+PniLuQM4HfBbawxszJgZHD6/cHpK8ysuQu35cA9ZvYr4J/Oubfb2Ne5wLOhwoZzbk8H8oqEwzX92cwygD8Ahc65CjO7E8hotMzhRo9/B9zrnHvBzM4G7mw0rxbAOVdvZsecc6F91dPMa2gHiou1jR7XNdrmcT5sJZeBSPT5+Tj6SHbAgHnOuSuaWb7xvgqAW4BTnXN7zexRdMyJiIjEJXUhaZ/WLu6+EGwO+xCtX9w9EFzua02Wa7i4A8K6uGtn89pOc86tBSYTKGT8wszuiNa+RNppqJlNDz6+kkALhtDxtcvMugFfaGX97sCW4ONrOhPEOXe3c25iM1+ttYxqzmZgSvDxpZ3JJBImPx9Hp5lZgQXGvviPYPb3gRlmNhwg2A1yZHD5g0BO8PFJBM7V+4NdOz/dmewiIiISPSpgtI+fL+5C3ib4qVbwQm4oUAq8C1wenD4GGN90RTMbBFQ75x4n0PpjcnBW4wvBxt4ALjOz3sH11YVEoqUU+IaZrQZ6An8MDiT7ELACeBVY1Mr6dwLPmtliYFcry8XST4H7LTCGTp3XYaRL8PNxtAh4AFhNoHXj35xzVcC1wJPBVoULgNHB5R8EXjGz+c65D4ASYA0wm8D5UEREROKQffhBv7TGzPIJdOsoJvCp6CrgaudctZn9ArgC2A6sBcqcc3da4K4BtzjnioPbuBj4DbCXwJv7U51zZweb5B5yzv06uNwh51y34OMT5nUi+z+dc+OCLUb+CBQSaKL+PefcfDPLBh4j0O93DYHBBC9zzq0zs83B5acQKFzUA8eAG51zxWb2TeAmAuNjnBNaPjjuxTXArQTegJU4565tIeOdBAYyPBSa5pwb0tHfWbqOxv/fHkcR8S0dRyIiIuIHKmCEKdEv7swsGUh1ztWY2TDgNWCUc+6ox9FEWpXox6ZILOg4EhERET/QIJ4SkkXgVqipBAY++7qKF+IHzrnNgN50iXSCjiMRERHxA7XAkJgysx8BlzWZ/Kxz7pde5BERERERERF/UAFDREREREREROJeXNyFZObMmY7ALUr1pS+/fcWUmX3XzFaa2QozezI4KGuLdGzpy6dfcU3Hlb58+iUiIuJ7cVHA2LUrXu5aKBK/zGww8C0Cd3gZByQDs1pbR8eWSOTpuBIRERHxRlwUMEQkbClAppmlEBh4davHeURERERERGJCBQwRn3DObQF+DZQD24D9zrm5TZczsxvMrNjMiquqqmIdU0REREREJCpUwBDxCTPrCVwMFACDgGwz+2LT5ZxzDzrnCp1zhX379o11TBERERERkahQAUPEPz4BbHLOVTnnjgHPA6d7nElERERERCQmVMAQ8Y9yYJqZZZmZAecBqz3OJCIiIiIiEhMqYEhCcc7x9NNPs3nzZq+jRJxzrgiYAywBlhM4fh/0NJSIiIiIiEiMpHgdQCSSFi5cyKxZs5g+fTrvvfee13Eizjn3E+AnXufoqmYXlTc8vnLqUA+TiEhbGh+voGNWREQkEagFhiSUUNFiwYIFOOc8TiMiIiIiIiKRogKGJJS1a9c2PN6zZ4+HSURERERERCSSVMCQhFJe/mGT4YqKCg+TiIiIiIiISCSpgCEJZcuWLfTr16/hsYiIiIiIiCQGFTAkoezYsYMJEyY0PBYREREREZHEoAKGJAznHFVVVYwbNw6AnTt3epxIREREREREIkUFDEkY+/fvp66ujtzcXDIyMti9e7fXkURERERERCRCVMCQhBG660ivXr3o1auX7kIiIiIiIiKSQFTAkITRtIChFhgiIiIiIiKJQwUMSRj79u0DoHjbUY6lZLG2QoN4ioiIiIiIJAoVMCRhhAoYWdk5ZGXnUH3ogMeJREREREREJFJUwJCEsX//fgCyck4iK+ckqg8d9DiRiIiIiIiIRIoKGJIwGgoY3XLI6qYWGCIiIiIiIolEBQxJGAcOBAoWGVndyMzOoebwYZxzHqcSkXhgZrlmNt/MVpnZSjP7dnB6LzObZ2brgt97ep1VRERERJqnAoYkjAMHDtCtWzeSkpLIzO5GXd1xampqvI4lIvHhOHCzc24MMA34hpmNAX4AvO6cGwG8HvxZREREROKQChiSMA4ePMhJJ50EQGZWt4ZpIiLOuW3OuSXBxweB1cBg4GLgseBijwGXeJNQRERERNrS4QKGmuNKvDlw4AA5OTkAZGR3a5gmItKYmeUDk4AioL9zbltw1nagfwvr3GBmxWZWXFVVFZOcIiIiInKizrTAUHNciSuHDh1qKGBkZmU3TBMRCTGzbsBzwHeccydUOF1g0JxmB85xzj3onCt0zhX27ds3BklFREREpKkOFzDUHFfizcGDB+nWLdDyIiMzu2GaiAiAmaUSKF484Zx7Pjh5h5kNDM4fCOz0Kp+IiIiItC4iY2B0pDmuSKQ1LmCkZ2U1TBMRMTMDHgZWO+fubTTrBeCa4ONrgH/EOpuIiIiIhKfTBYyONsdVf2KJtEOHDjUUMEKDeKoLiYgEzQCuBs41s6XBrwuAu4DzzWwd8IngzyIiIiISh1I6s3JrzXGdc9taa47rnHsQeBCgsLCw2SKHSHscPnz4wxYYGZkN00REnHPvANbC7PNimUVEREREOqYzdyFRc1yJK41bYGRoEE8REREREZGE0pkWGKHmuMvNbGlw2g8JNL99xsy+ApQBl3cuokjbnHMcPnyY7OxA4SI9IzAGhlpgSLTMLipveHzl1KEeJhERERER6Ro6XMBQc1yJJ7W1tdTX1ze0wEhNT8eSklTAEBERERERSRARuQuJiNdCXUVCLTDMjPSMLHUhERERERERSRAqYEhCqK6uBj4sYABkZGY2TBcRERERERF/UwFDEkKoq0hWVlbDtLSMTHUhERERERERSRCduo2qSLwIFSqys7M5GJyWnpGlAoZ0WuPBOkVERERExDtqgSEJoXEBIyQ9Uy0wREREREREEoUKGJIQQmNdNO5Ckq4uJCIiIiIiIglDBQxJCM0N4pmekcWRI0e8iiQiIiIiIiIRpAKGJAQN4ikiIiIiIpLYVMCQhNB8F5KMhLuNqpn1MLM5ZrbGzFab2XSvM4mIiIiIiMSC7kIiCeHEAsZ+INACI9EKGMD9wCvOuS+YWRqQ1dYKIiIiIiIiiUAFDEkIzRYw0hOrgGFm3YGzgGsBnHNHgaNeZhIREREREYkVdSGRhFBdXU1ycjKpqakN09IzMqmpqaG+vt7DZBFVAFQBfzGzEjP7s5llN13IzG4ws2IzK66qqop9ShERERERkShQAUMSQnV19Ql3IIFAFxIgke5EkgJMBv7onJsEHAZ+0HQh59yDzrlC51xh3759Y51RREREREQkKlTAkIRw5MiREwbwhMAgnqF5CaISqHTOFQV/nkOgoCEiIiIiIpLwVMCQhFBdXf2RAkaoBUaijIPhnNsOVJjZqOCk84BVHkYSERERERGJGQ3iKQnhyJEjZGZmnjAtLT3hWmAAfBN4IngHko3Alz3OIyIiIiIiEhNqgSEJobq6+qMFjGALjMOHD3sRKSqcc0uD41tMcM5d4pzb63UmEZF45pxjzoP3cOqppzJ37lyv44iIiEgnqAWGJIRmu5AkZgsMERFph4Vv/Iu/PfJbzIzLL7+cDRs20Lt3b69jiYiISAeoBYYkhGYH8UxPuLuQiIhIO/3ziT8xKH84JSUl7N+/n4ceesjrSCIiItJBKmBIQmh2DIzEuwuJxIG648d59Zm/cPfNX2b27/6LQ/v3eR1JRFqwvXwTG1d9wDkXzeKUU07h9NNPZ/bs2V7HEhERkQ5SAUMSQnNjYKSmpzfME4mE+vp6/viz7/J/997Jjsoy/vXkQ/z8xsvYs2eP19FEpBlLF8wHoPDsTwHwuc99juXLl1NZWellLBEREekgFTAkIXShu5CIh974+2wWzH2By//zVu5+6nV+cP9f2V6xmZtuusnraCLSjBUL36H/kHz6DRoKwKc+FShkvPbaa17GEhERkQ5SAUMSQnMtMEJjYKgFhkTC4QP7efoPv2Js4elcdM03MDPGnXoGF33p6zz55JO89dZbXkcUkUacc6xbvpjRk05rmDZ27Fh69OjBe++952EyERER6SgVMCQhNDeIZ6rGwJAImjvnMaoPHeCqb/8YM2uY/tmrb6R///788pe/9DCdiDS1vWIThw7sY+T4KQ3TkpKSOP3001XAEBER8SkVMMT36urqqK2tbbELiVpgSGcdP36Muc8+xsTTzyFvxJgT5qVlZPDd736XuXPnsmLFCo8SikhTm9YsB+Dkj51ywvTCwkJWr16tc4OIiIgPqYAhvldTUwPwkRYYKSmppKSkqAWGdFrJO69zYO8uPnHp1c3Ov+6660hNTeWRRx6JcTJpDzN7xMx2mtmKRtPuNLMtZrY0+HWBlxklcjaXriA1LZ1BBcNPmD558mTq6+u5+8m5zC4q9yidiIiIdIQKGOJ7j7+zDoCVO4585GI0MzNTBQzptLdemkOPPv2YMPXjzc7v27cvF110EX/96185fvx4jNNJOzwKzGxm+m+ccxODX/+KcSaJkrK1qxhy8khSUlJPmD5x4sTA/NKVXsQSERGRTuhUAUOfZkk8OFobaIER6jLSmAoY0lnVhw+y7P1/M/0TnyU5JaXF5a666ip27drFv//97ximk/Zwzr0F6J63XUTlxlKGnDzqI9OHDh1KRlY3Kjet9SCViIiIdEZnW2A8ij7NEo/V1gQKFC0VMNTPWTqj5J3XOX7sKKed23otdubMmWRnZ/Pss8/GKJlE0E1mtixYlO/Z3AJmdoOZFZtZcVVVVazzSTvt2bOHfburyB028iPzzIwhJ4+gcqMKGCIiIn7TqQKGPs2SeKAWGBJNi9+aR4/efRk+bnKry2VmZvLpT3+aF198EedcjNJJBPwRGAZMBLYB9zS3kHPuQedcoXOusG/fvrHMJx2watUqAAYXjGh2/pCCkWzZtD6WkURERCQCojUGhj7Nkpg5FipgZGR+ZF5WVpYKGNJhx48fZ/nCtzhl+tkkJbX9cnnBBRewdetWli1bFoN0EgnOuR3OuTrnXD3wEHCa15mk80pLSwEYlDe82fkD807mwN5dHD64P5axREREpJOiUcDQp1kSU2qBIdHy/vvvU33wAKecfk5Yy8+cGehR99JLL0UzlkSQmQ1s9OPnAN0LNwGUlpaSmpZOnwGDm50/cOgwALaVbYxlLBEREemkiBcw9GmWxJoKGBIt8+bNw5KSGHfqGWEtP3DgQE455RRee+21KCeTjjCzJ4EFwCgzqzSzrwD/Y2bLzWwZcA7wXU9DSkSUlpbSf0geScnJzc4fmHcyANvKVcAQERHxk5aH1O8gMxvonNsW/FGfZknUhQoYqS0UMHbt2hXrSJIgXn/9dQpGjyc7p3vY65x33nn8/ve/58iRI2RmfrRbk3jHOXdFM5MfjnkQibr169czILegxfn9BuViSUnsqNwcu1AiIiLSaZ29jao+zRLPHa2tBdQCQyLr0KFDFBUVMXbK6e1a79xzz6W2tpb33nsvSslEpDX19fVs2LCB/kPyWlwmJTWNPgMGs10FDBEREV/pVAsMfZol8eCYupBIFLz77rscP36cMYXtK2CcddZZJCcnM3/+fHZ0O/EOCFdOHRrJiCLSjC1btlBbW0v/IfmtLtd/SD47KstiE0pEREQiIlp3IRGJGY2BIdHw9ttvk5yczMjxU9q1Xk5ODpMmTeLtt9+OUjIRac2GDRsA6D+45RYYAAOG5KkLiYiIiM+ogCG+pwKGRMPbb7/NpEmTyMjKbve6Z555JkVFRRw7WnvC9NlF5Q1fIhIdGzcGBubsN7j1Fk99B+Vy+MB+9u/XrVRFRET8QgUM8b0PB/FM/8g8FTCkI44ePcrChQs588wzO7T+mWeeSW1tLRtXL4twMhFpy6ZNm0hOTqZX/4GtLtdv0NCG5UVERMQfVMAQ3ztaU0Nqejpm9pF5mZmZ1NXVcezYMQ+SiV+VlJRQU1PDjBkzOrR+aL31K5ZEMpaIhGHjxo0MHTqUlJTUVpcLtdAIdTkRERGR+Bfx26iKxNqx2ppmu48ADbexPHLkCKmprV/MioQsWLAAgOnTp/NmxfF2r9+vXz9OPvlk1i1XAUMk1jZt2kR+fv5HpjftutV3UC4AmzdvjkEqERERiQS1wBDfOxpmAUMkXAsWLCA3N5dBgwZ1eBvTp09n3YolOOcimExE2lJWVtZsAaOp7JzuZGbnUFamO5GIiIj4hQoY4nsqYEikvf/++0yfPr1T25g+fTr7du1k1/YtEUolIm2pra1l69atYRUwAPoOHKIWGCIiIj6iAob43tHaGlJbKGAs2XIYgGffVx9nCc/27dspLy9n6tSpndpOaP2Nqz+IRCwRCUN5eaCbSLgFjD4qYIiIiPiKChjie621wAgVNkJ3KhFpy6JFiwA47bTTOrWdCRMmkJKaxoaVKmCIxEqoO0heXl5Yy/cZMFgFDBERER/RIJ7ie60VMELTj9aogCHhWbhwIcnJyUyaNCnsdRoPDnjl1MCdDdLS0sgbMYaNq1TAEImVxgWMLTvaXr7PgMEcPHiQffv20aNHjyinExERkc5SCwzxvdYKGOnpmQ3LiIRj0aJFjB07luzs7E5va9iYU9i4Zhn1dXURSCYibSkvLycpKYnBgweHtXyfAYMb1hMREZH4pwKG+F6rLTAy1IVEwueco7i4mFNPPTUi2yv42ARqj1SzrXxjRLYnIq0rKytj0KBBYd82O1TA0J1IRERE/EEFDPG9Y62OgZEOqIAh4SkrK2P37t0UFhZGZHsnf2wCABvXLI/I9kSkdeXl5eTm5oa9fO8BgxrWExERkfinAob4XlhjYKiAIWEoLi4GYMqUKRHZ3qC8YaRnZLJp9bKIbE9EWldRURH2AJ4AJ/XsQ1paGhUVFVFMJSIiIpGiAob4XjgFjGMJVMAws2QzKzGzf3qdJdEsXryYlJQUxo8fH5HtJSUnkzdyLBtVwBCJuvr6eioqKtrVAiMpKYkhQ4aoBYaIiIhPqIAhvne0tqbhdqlNJWgLjG8Dq70OkYiWLFnC+PHjycho/v+pIwpGj6d8/WoN5CkSZVVVVdTW1jJ06NB2rTd06FAVMERERHxCBQzxNeccx2prGwbrbCrRChhmNgT4DPBnr7MkGuccS5YsYfLkyRHdbv6ocdQeqWZ7xaaIbldEThQqQrSnBUZoeRUwRERE/EEFDPG1mppAYaKlLiTJKalYUhJHa47EMlY03Qd8H6hvaQEzu8HMis2suKqqKnbJfK6yspJdu3ZFpYABsKl0RUS3KyInCo1jsWJfCrOLwi9I5ObmsnXrVurUSkpERCTuqYAhvlZdXQ1AWnpms/PNjPSMzIRogWFmFwI7nXOLW1vOOfegc67QOVfYt2/fGKXzvyVLlgBEvIAxOH84qenpbNKdSESiKlTA6N1/ULvWy83Npa6ujm3btkUjloiIiESQChjia0eOBFpWtNQCIzTvaG1trCJF0wzgIjPbDDwFnGtmj3sbKXEsWbKEpKQkJkyYENHtJqekkDtsNGVrV0Z0uyJyooqKClLT08np0atd64W6nOhOJCIiIvFPBQzxtQ9bYKS3uExqegZHa/3fhcQ5d5tzbohzLh+YBbzhnPuix7ESRklJCaNGjSIrKyvi284fNY7Na1finGuYNruovOFLRDqvoqKCXn0HYmbtWk8FDBEREf9QAUN8LdQCIz2j+S4kAOnpGQnRhUSia8mSJUyaNCkq284fOZbqgweo2qY3SCLRUllZSa9+A9q9ngoYIiIi/qEChvhaqIDR0m1UIdiFpCaxChjOuTedcxd6nSNRVFVVsWXLlqgWMADKStWNRCRaKioq2j3+BUCPHj3IysqisrIyCqlEREQkklTAEF/7sAtJKwWMjMyE6EIi0bN06VKAqBUwcoeNJik5mc0aB0MkKurq6ti6dSu9+w1s97pmRm5urgoYIiIiPqAChvhaOF1I0tSFRNpQUlICRK+AkZaRwaC8YZStXRWV7Yt0ddu3b6euro5eHShgAAwZMkRdSERERHxABQzxtYYWGK0VMDIyqU2wLiQSWUuXLmXo0KH06tW+uxe0R96IMZStUwHDS2b2iJntNLMVjab1MrN5ZrYu+L2nlxml/WYXlfPwK8UA9OpAFxIIjIOhAoaIiEj8UwFDfC2sQTwzMjlaoy4k0rKlS5cyceLEqO4jb+RY9uzcxsF9e6K6H2nVo8DMJtN+ALzunBsBvB78WXxm986tAPTu37EWGLm5uWzfvp3jx49HMpaIiIhEWKcKGPo0S7wWaoGR2sptVNPS09WFRFpUXV1NaWlpDAoYYwDUjcRDzrm3gKYVpIuBx4KPHwMuiWkoiYg9O7cDdKoLSX19Pdu2bYtkLBEREYmwzrbAeBR9miUeCmsMDLXAkFYsX76c+vr6qI1/EZI3IljAWKeBPONMf+dc6F3rdqB/cwuZ2Q1mVmxmxVVVVbFLJ2HZvWMraekZdDupR4fW161URURE/KFTBQx9miVeC+suJOmZ1OouJNKC0B1Iot0CI6dHL3r1G6gWGHHMOecA18K8B51zhc65wr59+8Y4mbRlz87t9Oo3EDPr0PpDhgwB0J1IRERE4lw0xsDQp1kSM0eOHCE5OYWU1LQWl0nPyORYbS319fUxTCZ+sXTpUnr06EFeXl7U95U/cqwG8ow/O8xsIEDw+06P80gH7Nm5rcPjX4BaYIiIiPhFSjQ37pxzZtbip1nAgwCFhYXNLiPSlurqalJbaX0BH7bOqKmpISsrKxaxxEdCA3h29JPbpmYXlbc4L2/kGJYumM/RmhrSMlr/v5WYeQG4Brgr+P0f3saRjtizcxtjppzeoXVnF5XjnCMjK1stMEREROJcNAoYO8xsoHNumz7Nkmirrq5udfwLoOGNYnV1tQoYcoK6ujqWLVvG9ddf3zCttQJEZ+WNGEN9XR0VG0sZNuaUqO1HmmdmTwJnA33MrBL4CYHCxTNm9hWgDLjcu4TSEfV1dezdtYNe/QZ0H8jxDAAAHp9JREFUeBtmRq++A1TAEBERiXPRKGDo0yyJmerq6jY/yQ4VOELjZYiErFu3jurq6qgP4BmSN3IsAGVrV6qA4QHn3BUtzDovpkEkovbtrqK+ro7e/Qd1aju9+g9SFxIREZE419nbqD4JLABGmVll8BOsu4DzzWwd8IngzyJRUV1d3eoAnhC4C0loWZHGQgN4xqqA0XdQLpnZOZSt1Z1IRCJl986tAJ1qgQHQu98AFTBERETiXKdaYOjTLPHa4cOHSc9svVuIChjSkpKSEtLS0hg9enRM9mdm5I0cw2YVMEQiZs+OwLjhvft1vgXGtm3bOHbsGKmpqZGIJiIiIhEWjbuQiMRMdXU16emtj4ERmq8ChjRVUlLC2LFjSUtr+S42kZY3YgwV69dQX1cXs32KJLLdOwItMDrbhaR3v4E459i2bVvbC4uIiIgnVMAQXwtnDIzGg3iKhDjnKCkpiVn3kZC8kWOprTnC9opNMd2vSKLavXMb6RmZZOWc1Knt9OoXuA2rupGIiIjELxUwxNfC6UISmn/48OFYRBKf2LJlC7t27Yp5ASN/VGAgT3UjEYmM3Tu20qv/oE7fCjnUgkMFDBERkfilAob4Wji3UdVdSKQ5JSUlQOwG8AwZXDCClNQ0NpeqgCESCXt2bKN3sPVEZ/TqrxYYIiIi8U4FDPG1wF1IWi9ghAbxVAsMaaykpAQz45RTYns705SUVIacPFJ3IhGJkN07t9J7QOfGvwDIys6he/fuKmCIiIjEMRUwxNcCXUhaL2BkZAS6kKgFhjRWUlLCyJEj6datW8z3nT9qHJvXrsQ5F/N9iySSo0ePsn93VafvQBKSm5tLeXl5RLYlIiIikacChvhWfX19oAtJm2NgqAWGfNSSJUuYPHmyJ/suGDWOQ/v3Ntw9QUQ6ZsuWLTjn6N2/811IQAUMERGReKcChvhWTU0NQJu3UU1OSSUpOVktMKTBrl27KC8v96yAkT9qHACbS1d4sn+RRBHq7tGrk7dQDRk6dKgKGCIiInFMBQzxrVCLira6kJgZ6RlZaoEhDbwawDMkd/hoLCmJTWuWe7J/kUQRKjb0GTA4ItsbOnQou3fvVsFbREQkTqmAIb71YQGj9S4kgWUyVcCQBosXLwa8K2CkZ2QyOH+4WmCIdFKogNE7gi0wQHciERERiVcqYIhvNRQwMsIoYKgFhjSyePFiCgoK6NWrl2cZCkaPZ9OaFRrIU6QTysvLyenRq83baYcrVMBQNxIREZH4pAKG+Fa4XUgCy6iAIR9avHgxU6ZM8TRD/qjx7N9Txd6qHZ7mEPGzsrKyiLW+gA8LGGVlZRHbpoiIiESOChjiW+1rgaEuJBKwZ88eNm3a5HkBo2B0YCBPjYMh0nFlZWURG/8CYPDgwSQlJamAISIiEqdUwBDfOnToEBDuGBhZDctL17ZkyRIAzwsYeSPHBgfyXOZpDhG/cs4FChgDh0Rsm6mpqQwePFgFDBERkTilAob4Vnu6kGSogCFBixYtAqCwsNDTHBmZWQwuGMHG1SpgiHRE6G4hkWyBAZCXl6cChoiISJxSAUN8K1SQyMzq1uayGVnZ6kIiQKCAMXz4cHr27Ol1FIZ9bAIbVy/TQJ4iHRAqMqiAISIi0nWogCG+FSpgZGRmt7msWmBISHFxseetL0IKRk/g4L49uuOBSAdEq4CRn59PZWUlx48fj+h2RUREpPNSvA4g0lEfjoERzl1IslXAELZv305FRQWnnnrqCdNnF3lTQBg2diIACxcuJC8vz5MMIn61adMmAPoNGhrR7ebn51NXV0dlZSX5+fkR3baIiIh0jlpgiG8dOnSItLQ0UlLT2lw2IyubmpoafaLWxRUVFQEwdepUj5MEDB0+mtS09IZcIhK+zZs3c9JJJ5GVc1JEtxsqWmzevDmi2xUREZHOUwFDfOvQoUNkZ7fdfQQCXUgAjYPRxS1cuJDk5GQmT57sdRQAUlLTyBs5hoULF3odRcR3Nm/eTEFBAWYW0e0WFBQAH7bwEBERkfihAob41sGDB8nJyQlr2Yys7IZ1/MrMcs1svpmtMrOVZvZtrzP5TVFRERMmTCAzjG5HsTJ87CQWL16s1kEi7bRp06aodPHIzc0lKSlJLTBERETikAoY4luHDh1qdwHD5+NgHAduds6NAaYB3zCzMR5n8o26ujoWLVrU0H1kdlF5w5eXho2dSHV1NcuXL/c0h4ifOOfYtGkTJ598csS3nZaWxpAhQ9i4cWPEty0iIiKdowKG+Fb7WmB0a1jHr5xz25xzS4KPDwKrgcgOv5/AVq9ezYEDB5g+fbrXUU4wYlygO8uCBQs8TiLiHzt37qS6urqhu0ekFRQUqAuJiIhIHFIBQ3zr0KFDdOvWLaxlMxOgC0ljZpYPTAI+Mvqjmd1gZsVmVlxVVRXraHErVCCItwJGn4FD6N+/vwoYIu0Qah0RjRYYoe1u2LAhKtsWERGRjlMBQ3zrwIEDnHRSeKPPJ8IYGCFm1g14DviOc+5A0/nOuQedc4XOucK+ffvGPmCcWrBgAX369GH48OFeRzmBmTF9+nQVMETaIVRciFYBY9iwYWzfvp3q6uqobF9EREQ6RgUM8a32dCHJTIAuJABmlkqgePGEc+55r/P4ybvvvsv06dMjfseCSJgxYwYbNmxgx44dXkfpssxss5ktN7OlZlbsdR5p3YYNGzCzqHUhGTZsGIDGwRAREYkzUStg6GJQou3AgQPhj4ERvN3qgQMfabDgGxZ45/0wsNo5d6/Xefxk586drF27ljPPPNPrKM0644wzgECRRTx1jnNuonOu0Osg0rr169eTm5tLRkZGVLYfaqm1fv36qGxfREREOibaLTB0MShR4ZxrXwuM7MByfi5gADOAq4Fzg4XBpWZ2gdeh/CBUGAgVCuLN5MmTycjI4J133vE6iogvbNiwoaGVRDSEtq0ChoiISHxRFxLxperqaurq6ujevXtYy6elZ5CcnOzrAoZz7h3nnDnnJgQLgxOdc//yOpcfvP3226SnpzN58mSvozQrLS2NqVOn8vbbb3sdpStzwFwzW2xmNzSdqcFx48vatWsZMWJE1Lbfs2dPunXvycvvlnh+q2URERH5UDQLGLoYlKgJFSLCLWCYGd27d/d1AUM67t///jfTp08nPT3d6ygtOuuss1iyZIn+R71zhnNuMvBp4BtmdlbjmRocN37s3buX3bt3R6WAMbuovOFrQG4+2yt0K1UREZF4Es0Chi4GJWpCb/LCvQtJaFm9Oex69u3bR0lJCWeffbbXUVp19tlnU19fr24kHnHObQl+3wn8DTjN20TSknXr1gEwcuTIqO5n4NCT2VauAoaIiEg8iVoBQxeDEk379+8Hwm+BEVo2tJ50He+88w7OOT7+8Y97HaVV06ZNIzU1lTfffNPrKF2OmWWbWU7oMfBJYIW3qaQlpaWlAFHtQgIwILeAvVXbqak+HNX9iIiISPiiUsDQxaBEW6gQ0aNHj7DX6dGjhwoYXdDrr79ORkYG06ZN8zpKq7Kyspg2bRpvvPGG11G6ov7AO2b2AbAQeMk594rHmaQFa9asISUlpeFOIdEyKC8wkOe2ct1KVUREJF5EqwWGLgYlqvbt2we0vwVGaD3pOp578RWGjZvC8x/s9DpKm8477zyWLFnCnj17vI7SpTjnNjrnTgl+jXXO/dLrTNKy0tJShg0bRmpqalT3Myg/UCBRAUNERCR+RKWAoYtBibZQIaK9LTD27t0brUgSh3bu3EnFhjWMPXWG11HCct555+GcUzcSkVasXr2aUaNGRX0//YfkYUlJbNm0Lur7EhERkfDoNqriS6FCRHsLGGqB0bXMmzcPgHGnnuFxkvBMnTqVnJwc5s6d63UUkbh09OhR1q5dCz1zG+4WEi2paekMGJKvAoaIiEgcUQFDfGnv3r2kpKSQnZ0d9jo9e/bkwIED1NXVRTGZxJNXXnmFnB69KBg93usoYUlNTeW8887jlVdewTnndRyRuLN+/XqOHz/O4Pzojn8RMrhghAoYIiIicUQFDPGlvXv30qNHD8ws7HV69uwJoFYYXUR9fT2vvvoqE6aeRVKSf17qZs6cSVlZGWvWrPE6ikjcWbEiMB744ILo3oEkZHDBCLZXbqa2tjYm+xMREZHW+eeqXqSRvXv3NhQkwtWrVy8ADZDYRRQXF1NVVcWEafF9+9SmZs6cCcC//vUvj5OIxJ/ly5eTlJQUswJG7rDR1NfVsXr16pjsT0RERFqnAob40qpNW3Hp3drV/zlUwNBAnl3DCy+8QFJSEqecfo7XUdolLy+P8ePH88ILL3gdRSTuLF++nFGjRpGWnhGT/Q0dPrphvyIiIuI9FTDElw4d2Ee37mqBIS178cUXmTFjBjnt/D+JB5/97Gd599132b17t9dRROLKBx98wPjxsRvTZkBuAalp6XzwwQcx26eIiIi0TAUM8aVD+/fR7aTw70AC0Lt3bwB27doVjUgSR9avX8+yZcu45JJLvI7SIZdccgl1dXW8+OKLXkcRiRt79+5l8+bNTJo0KWb7TE5JIXfYKEpKSmK2TxEREWmZChjiSwf37yGnR692rdOnTx8AfardBTz33HMAfP7zn/c4SccUFhYydOhQ5syZ43UUkbixdOlSgJgWMADyRo6lpKREdwYSERGJAypgiO8cOXKE2iPV7S5g9OjRg6SkJKqqqqKUTOLFs88+S2FhIfn5+V5H6RAz49JLL2Xu3Lkas0UkaNGiRQBMmTIlpvs9+WMT2Lt3Lxs3bozpfkVEROSjVMAQ3wkVIHK6t6+AkZSURJ8+fVTA8LHZReUNXy0pLS1l8eLFXHHFFTFMFnlXXHEFx44d4/nnn/c6ikhcWLhwIQUFBQ2t6WLl5I9NAD4soIiIiIh3VMAQ39m5cycA3Xu1/yK2X79+DetLYpo9ezZmxqxZs7yO0imFhYWMGDGCxx9/3OsoInGhqKiI0047Leb7HTJsFJmZmbz//vsx37eIiIicSAUM8Z1QAeKkXr3bvW7//v3ZsWNHpCNJnKivr+fRRx/l/PPPZ9CgQV7H6RQz45RzLuLNN9/kvuff8TqOiKcqKiqorKzk9NNPj/m+U1JSOfXUU1mwYEHM9y0iIiInUgFDfGfbtm0A9Ojdr93rDhgwgO3bt0c6ksSJ119/nfLycq677jqvo0TEWZ/5AmbGmy8+7XUUEU+9++67AJ4UMEL7XbJkCYcPH/Zk/yIiIhKgAob4zocFjL7tXnfgwIFs27ZNo8knqD/84Q/06dOHiy++2OsoEdG7/yBOOf0c3nzhaY4ePep1HBHP/Pvf/yYnJ4eJEyd6sv+Pf/zjHD9+XK0wREREPKYChvjO1q1b6XZSD1LT0tu13uyicrYdzaCmpoZ9+/ZFKZ14paysjBdeeIHrr7+ejIwMr+NEzPmXfon9e6oabg0r0hXNnz+fM844g5SUFE/2P2PGDJKTk5k/f74n+xcREZEAFTDEdyorK+nZd0CH1g2tV1lZGclI4oHGdySZXVTOf/6/n2GWxI033uh1tIiaMO3jDMwbxt13362WQ9IllZeXU1payvnnn+9ZhpycHKZNm8a8efM8yyAiIiIqYIgPVVRU0Lv/wA6tG1qvoqIikpHEYwf27mb+P57k9E9dTG5urtdxIiopKYkLr7qBkpIS5s6d63UckZh7+eWXAfjkJz/paY5PfepTFBcX605WIiIiHlIBQ3ynrKyMPgMGd2jdPgOGNGxDEseLf/0jR4/WctGXvt7qco1bbMSr5jLOmPk5hg4dyh133KFWGNLlvPjiixQUFDBmzBhPc1x44YU453jppZc8zSEiItKVqYAhvrJv3z727t1L30Ed+5S9R59+pKSmsWnTpggnE69Uba1g3pz/44yZn2NQ/nCv43RIW4WV1LR0fvzjH7Nw4UKNhSFdyv79+5k3bx6XXHIJTy6s8KwAObuonFW1vegzYAi/ffjxmO9fREREAlTAEN+YXVTO7/8RuJVev0FDO7SNpKQk+g3KZd26dZGMJh564ne/xMy47Gu3eB0lqq699lrGjx/PLbfcQnV1tddxRGLib3/7G0ePHuWyyy7zOgpmxtTzLmB50dvs3r3b6zgiIiJdkgoY4itbyzYAMDBvWIe3MTBvGKWlpZGKJB5a/NY8Fs1/mYuvvYne/QcBHx3cM1GkpKTwwAMPUFZWxk9+8hOv44jExKOPPsrw4cOZNm2a11EAOGPm56k7fozZs2d7HUVERKRLUgFDfGXLxrUkJ6cwcGhBh7cxuGAE69at4+jRoxFMJpEUTgFi/+4q/vzfP+D/t3f/UVaUdRzH319ZEUUQRUoSNkABIci0XYEwA0VdSFCPHEUCDClJxdQsLcoSsYyQ/HFUzF9RJPkj13XRaisSLHANAlyEmwKiBJZFGlZ7RJb99sdcdEV+3HXvzDx39/M6Z865c+9zZj48dx6enWeemVt8dB/OGDc5wXTpOemkk5g8eTKzZs1i4cKFaccRidXq1atZtGgRkyZNwszSjgNAcc8+9Oh7LLNnz6a+vj7tOCIiIi2OBjCkoLyyLkPnj/agaP/WH3gbXY/qTV1dHZlMJo/JJEl129/m1m9ewlu1/+XS629r0vFQaGbNmkWvXr0YM2ZMo35NpznOSpHmbebMmRzQ5kAOPa4sqOO27NyJZDIZnnjiibSjiIiItDgawJCC4e68tKaGbr37NWk73Y/pD8DtD/06qD+KJTf1O3bwo+lf5YWVf+ILU2fQpUevtCMlqm3btpSXl1NbW8uIESN4/fXX044kkneZTIa5c+dy8lljadfhsLTjvMfAYSPp0aMH1157LTt27Eg7joiISIuiAQwpGH//6wbefGMLvT5e0qTtHNG1O+06HMZfVv4pT8kkKdvf3sad113Bkt88znmXXMPg089KO1Iq+vbty2OPPcbatWsZOnQomzdvTjuSSF7Me3YjP3vmZc4ZdyFt2h7MqAsuTTvS+7QqKuKzF15FTU0NF159Q9pxREREWhQNYEjBWLnkKQA+VjK4SdsxM/qVnkhN9dPU6+pZwVi/fj3Tv3Quz/y2kjGXfoNREy5JO1KqXju4J1f+4D5eXLee0tJSFixYkHYkkbyY/9M7ySyvZuyUqbQ/tGPacXZrwCmf5dhBQ/j5HTeyYsWKd97XrVoiIiLx0gCGBG3nH4IPVL/CkqoKio/uwxFduzV5u6VDynjzjS08v/SPTQ8psdq6dSvTpk2jf//+vPrKeq648S5Gjv9S2rGC0H/Ap/nO3eW0b9+eYcOGMWHCBDZs2PDO5zqZkkLzu0fn8vBdMxl02iiGjBqTdpw9MjMmf+sm2nfoyPDhw6mpqUk7koiISItQFNeGzawMuBVoBdzr7t+Pa1/S/K1Y/HteytQw8Wv5ma57/KeH0aFjJ8rvu4V+pSeyX6tWAIwdUJyX7celENtVLifPu9b79re38WLNMqoXPMmkqsd5q/a/nHDyCMZd8W06fqhzXFELUvHRx7B8+XKmT5/OzTffzLx58xg5ciTnn38+/zusD23bHZJ2xIJQiG2ruZj37Eb+9dqrPHTnDBZXVXDc4FOY/K2bgvnlkT05pGMnvn7rXL532VhOGDCQ0RddxbBzxtP6gDZpRxMREWm2YhnAMLNWwB3AqcAmYKmZVbr7mjj219w1PAEM/QQ7V7ue1O7t31VfX8/Ds39Al6N6M2TUeXnZ//6tD2DMlKncNe1Kli9eQMlJp+Vlu3EqpHbV2Cv+Dcsvrqrgnu9dzfZt2zigzYGUDh1O2XkXvvPwVXm/ilVb6H/Wxdz0qbPZtLicOXPmUFFRgZlx6ugLuOCqaWlHDFohta1Ctqe+bGHlg9w3Yypm+3H2pMs5e+KXaVUU2/WVvPpIt6OZ/uP53PPdq3ngtht4/Cd3cMOP59PpI13TjiYiItIsmbvnf6Nmg4Dr3P307Po3ANz9xt2VLykp8WXLluU9R2Ps7YS6sSdjezsZbwlTuZtSd3vyxpbX2FZbyxHF3fOyPYh+1eSF55ZyzCdO2GOZHAaMErtE2Nh2Bcm2rXx91xvXZlj05CP0PX4QHysdTJsDD8rLdluS+h07WLtqOc8v/SNHdu/JwGFnvOfzDzIQuqeTz1wHIxs5EJvopfc4+6ykBqBz+X7yuf989mWvvryOhfMf4tTRF9Cpc5e8bTdJ7k5meTXLFlUx/srvNGr2SIIXJsKe0iIiIpKDuAYwRgNl7v6F7Pp4YIC7T2lQ5iLgouxqb+CFvAfJzeHAlpT2nQvla5q4821x97IYt/+OXNpV9v1c2laI35sy5SbETJDfXIm1Kwiizwr1O02D6uJd+a6LRNuViIhIHFKbo+nudwN3p7X/ncxsmbs37Xc5Y6R8TRN6vjjk0rZCrBdlyk2ImSDcXPkSZ5/V3OuuMVQX71JdiIiIvF9cv0KyGWh4A2iX7Hsi8sGpXYnEQ21LREREpADENYCxFOhpZt3NrDUwBqiMaV8iLYXalUg81LZERERECkAst5C4e52ZTQGqiH6S7n53Xx3HvvIg9dtY9kH5mib0fDnLc7sKsV6UKTchZoJwc+1TAH1WwdZdDFQX71JdiIiI7CKWh3iKiIiIiIiIiORTXLeQiIiIiIiIiIjkjQYwRERERERERCR4LWYAw8zKzOwFM1tnZl/fzedfMbM1ZlZjZgvM7KMh5WtQ7hwzczNL9KfVcslnZudm63C1mc0LKZ+ZFZvZU2a2Ivsdj0gyX9LMrGv237vz+7h8N2XMzG7L1lmNmR0fSK7PZfOsMrMlZnZs2pkalC01szozGx1CJjMbYmYrs2UWpZ3JzA4xs/lm9ly2zMQ4MxWa0PuhJIXe5yUp9P5VREQkKO7e7Beih7KtB3oArYHngL67lBkKHJR9fTHwUEj5suXaAU8D1UBJSPmAnsAK4NDs+ocCy3c3cHH2dV/g5bSPy5jrpDNwfIPj5sXd1MkI4FeAAQOBZwPJ9akGx9HwuHPlkqnBcfZ74JfA6LQzAR2ANUBxdj3WNpdjpqnAjOzrTsDrQOu4j6tCWELvh0Kri2y5VPq80Ooizf5VixYtWrRoCW1pKTMwTgDWuftL7v428CBwZsMC7v6Uu9dmV6uBLiHly5oOzADeSjAb5Jbvi8Ad7v4GgLv/I7B8DrTPvj4EeDXBfIlz97+5+/Ls6/8AGeDIXYqdCfzUI9VABzPrnHYud1+y8zgigbaYY10BXAY8CsR+bOeYaSxQ7u4bs+VizZVjJgfamZkBBxMNYNTFmauAhN4PJSn0Pi9JofevIiIiQWkpAxhHAn9tsL6J3Z+g7DSJ6Mp0UvaZLzu9v6u7P5lgrp1yqb9eQC8zW2xm1WZWlli63PJdB4wzs01EV9AvSyZa+sysG3Ac8OwuHzW2XeTVXnI1lGhb3FMmMzsSOBuYnVSWfWUianOHmtlCM/uzmU0IINPtQB+iAcJVwOXuXp9UrsCF3g8lKfQ+L0mh968iIiJBKUo7QGjMbBxQAnwm7Sw7mdl+wA+Bz6ccZW+KiKa5DiG6avi0mfV393+nmupd5wNz3H2WmQ0C5ppZv+Z+cmVmBxPNGrjC3d9MO89OueQys6FEJ3EnBpDpFuAad6+PJhckYx+ZioBPAqcABwLPmFm1u7+YYqbTgZXAycBRwG/N7A8hHXuFIMR+KEkF0uclKfT+VUREJDEtZQbGZqBrg/Uu2ffew8yGAd8ERrn7toSywb7ztQP6AQvN7GWi5xVUJvhQs1zqbxNQ6e7b3X0D0f3xPQPKNwl4GMDdnwHaAIcnki4lZrY/0YnmA+5evpsiObWLFHJhZh8H7gXOdPd/BZCpBHgw2/5GA3ea2VkpZ9oEVLn7/9x9C9GzAuJ+4Om+Mk0kuq3F3X0dsAE4Js5MBST0fihJofd5SQq9fxUREQlKSxnAWAr0NLPuZtYaGANUNixgZscBPyL6ozHp+0v3ms/dt7r74e7ezd27Ed0bPcrdl4WQL6uC6OoQZnY40ZTXlwLKt5HoSjVm1odoAOOfCeVLXPYZBPcBGXf/4R6KVQITLDIQ2Oruf0s7l5kVA+XA+LhnE+Sayd27N2h/vwAucfeKNDMBjwMnmlmRmR0EDCB6LkWamRq2sw8DvUnu/4HQhd4PJSn0Pi9JofevIiIiQWkRt5C4e52ZTQGqiJ74fb+7rzaz64Fl7l4JzCR66Nwj2SniG919VED5UpNjvirgNDNbA+wAvpbElfNG5LsKuMfMriR60ODn3d2TyJeSwcB4YJWZrcy+NxUoBnD3u4ieBTICWAfUEl09DyHXt4GORLMcAOrcPc4rr7lkSto+M7l7xsx+DdQA9cC97v58mpmIHro4x8xWEf26zTXZ2SEtXuj9UJJC7/OSFHr/KiIiEhpr3udwIiIiIiIiItIctJRbSERERERERESkgGkAQ0RERERERESCpwEMEREREREREQmeBjBEREREREREJHgawBARERERERGR4GkAQ0RERERERESCpwEMEREREREREQne/wE+QLkdRsTULQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
val
hosp_prop0.0238(25)
ICU_prop0.367(11)
vent_prop0.760(30)
hosp_LOS11.55(25)
ICU_LOS13.45(27)
vent_LOS19.64(58)
incubation_days3.24(28)
recovery_days16.5(1.6)
logistic_k0.95(12)
logistic_x025.42(37)
logistic_L0.788(17)
nu2.440(72)
beta0.469(24)
\n", + "
" + ], + "text/plain": [ + " val\n", + "hosp_prop 0.0238(25)\n", + "ICU_prop 0.367(11)\n", + "vent_prop 0.760(30)\n", + "hosp_LOS 11.55(25)\n", + "ICU_LOS 13.45(27)\n", + "vent_LOS 19.64(58)\n", + "incubation_days 3.24(28)\n", + "recovery_days 16.5(1.6)\n", + "logistic_k 0.95(12)\n", + "logistic_x0 25.42(37)\n", + "logistic_L 0.788(17)\n", + "nu 2.440(72)\n", + "beta 0.469(24)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "thresh = 3.5 # Threshold for identifiying outliers\n", "POSTERIORS = {\n", @@ -207,9 +648,16 @@ "# Propagate normal posteriors to SEIR and compare to original prediction" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section takes the fitted posterior distributions as input and propagates the parameter uncertainties through the SEIR model." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -218,20 +666,48 @@ ").set_index(\"date\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below, the model is initialized.\n", + "To eventually run the simulation, the following parameters must be provided" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['dates', 'initial_susceptible', 'initial_exposed', 'initial_infected', 'inital_recovered', 'beta', 'gamma', 'alpha']\n", + "['recovery_days', 'inital_doubling_time', 'incubation_days', 'initial_hospitalized', 'market_share', 'hospitalization_probability', 'hospital_length_of_stay']\n" + ] + } + ], "source": [ "seir = SEIRModel()\n", "print(seir.model_parameters)\n", "print(seir.optional_parameters)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `model_parameters` must be provided before running a simulation.\n", + "The `optional_parameters` are pre and post-processing parameters which simplify the interface.\n", + "For example, if you specify `recovery_days`, this is used to compute `gamma`.\n", + "\n", + "On the other hand, `hospitalization_probability` and `market_share` will add hospitalization information to the simulation in the post-processing." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -260,9 +736,17 @@ "}" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also possible to make parameters time-dependent. This is done by providing a `update_parameters` method. The arguments of this method are the simulation date and initial parameters (combined `XX` and `PP`). This method should return the updated parameters.\n", + "In the below example, a social distancing measure is implemented using a logistic function." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -286,9 +770,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.8 ms ± 986 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], "source": [ "%%timeit\n", "seir.propagate_uncertainties(XX, PP)" @@ -296,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -305,9 +797,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, axs = subplots(ncols=1, nrows=2, figsize=(6, 9))\n", "\n", @@ -387,6 +892,13 @@ "show_plot(fig)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the size of the census uncertainties differs by a few standard deviations while the mean agrees. This is interesting as they are computed using admission data (which agrees) and use the same function (see `bayes_chime/normal/models/sir.py` line 70). " + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -394,11 +906,95 @@ "## Compute normal posteriors given normal priors" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, original priors are approximated by normal distributions and `lsqfit` is used to compute posteriors.\n", + "\n", + "To account for the offset, the data is extended with zeros before the first date." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hospventmort
2020-03-02000
2020-03-03000
2020-03-04000
2020-03-05000
2020-03-06100
\n", + "
" + ], + "text/plain": [ + " hosp vent mort\n", + "2020-03-02 0 0 0\n", + "2020-03-03 0 0 0\n", + "2020-03-04 0 0 0\n", + "2020-03-05 0 0 0\n", + "2020-03-06 1 0 0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "extended_range = date_range(\n", " DATA_DF.index[0] - timedelta(int(OFFSET)), freq=\"D\", periods=OFFSET\n", @@ -408,9 +1004,16 @@ "extended_data.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the same as above with the difference that now the priors are used instead of the posteriors and the date range is set by the data." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -434,56 +1037,89 @@ " \"nu\": PRIORS[\"nu\"],\n", " \"hospitalization_probability\": PRIORS[\"hosp_prop\"],\n", " \"hospital_length_of_stay\": PRIORS[\"hosp_LOS\"],\n", - "}\n", - "\n", - "## It seems like the fit wants to drastically change incubation days and hosp_prob\n", - "## The lines below would fix such values to their mean\n", - "# pp[\"incubation_days\"] = gvar(pp[\"incubation_days\"].mean, pp[\"incubation_days\"].sdev / 2)\n", - "# pp[\"hospitalization_probability\"] = gvar(\n", - "# pp[\"hospitalization_probability\"].mean, pp[\"hospitalization_probability\"].sdev / 5\n", - "# )" + "}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "pp[\"L\"] = PRIORS[\"logistic_L\"]\n", "pp[\"x0\"] = PRIORS[\"logistic_x0\"] + OFFSET\n", - "pp[\"k\"] = PRIORS[\"logistic_k\"]\n", - "\n", - "seir.update_parameters = update_parameters\n", + "pp[\"k\"] = PRIORS[\"logistic_k\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One has to specify the time range and data (columns) to fit. For now, this only fits the hospitalized census data." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ "seir.fit_start_date = \"2020-03-06\"\n", "seir.fit_columns = \"hospital_census\"\n", - "seir.debug = False\n", - "\n", - "yy = gvar(DATA_DF.hosp.values, DATA_DF.hosp.values * 0.1 + 10)" + "seir.debug = False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Furthermore, one needs to know the uncertainty of the data.\n", + "Since I have no experience with how reliable this data is (one also must account for temporal fluctuations), I estimate the uncertainty to be 10% of the mean plus an additional 10 patients to not emphasize early points too much." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "seir.check_call(xx, yy, pp)" + "yy = gvar(DATA_DF.hosp.values, DATA_DF.hosp.values * 0.1 + 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The below method checks if the function call does not raise any problems (e.g., too few prior parameters or data is of the wrong shape)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checks passed\n" + ] + } + ], "source": [ - "%%timeit\n", - "fit = nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" + "seir.check_call(xx, yy, pp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This runs the fit and computes posteriors (stored in `fit.p`)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "scrolled": false }, @@ -494,9 +1130,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.06 s ± 97.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "x_prediction = xx.copy()\n", "tf = FORECAST_DF.iloc[:100]\n", @@ -507,11 +1174,11 @@ "fig, axs = subplots(ncols=1, nrows=2, figsize=(9, 9), sharex=False)\n", "\n", "gv_kws = dict(color=\"black\", zorder=10, lw=3, z_factor=0.674)\n", - "gv_line_kws = {\"ls\": \"--\", \"label\": \"Normal posteriors\"}\n", + "gv_line_kws = {\"ls\": \"--\", \"label\": \"New normal fit\"}\n", "gv_fill_kws = {\"alpha\": 0.2}\n", "\n", "fill_kws = {\"alpha\": 0.3, \"edgecolor\": \"k\", \"lw\": 2}\n", - "line_kws = {\"ls\": \"-\", \"label\": \"Data\", \"lw\": 2}\n", + "line_kws = {\"ls\": \"-\", \"label\": \"Original fit\", \"lw\": 2}\n", "\n", "\n", "# Census\n", @@ -596,12 +1263,172 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Least Square Fit:\n", + " chi2/dof [dof] = 0.38 [47] Q = 1 logGBF = -194.77\n", + "\n", + "Parameters:\n", + " initial_exposed 69 (48) [ 160 (67) ] *\n", + " incubation_days 3.0 (1.1) [ 4.6 (1.5) ] *\n", + " beta 0.478 (89) [ 0.32 (12) ] *\n", + " recovery_days 17.1 (4.9) [ 15.3 (5.0) ] \n", + " nu 2.46 (25) [ 2.46 (25) ] \n", + "hospitalization_probability 0.0378 (71) [ 0.024 (10) ] *\n", + " hospital_length_of_stay 11.49 (83) [ 11.64 (83) ] \n", + " L 0.793 (47) [ 0.37 (23) ] *\n", + " x0 29.7 (1.1) [ 20.7 (6.9) ] *\n", + " k 1.02 (41) [ 0.78 (43) ] \n", + "\n", + "Settings:\n", + " svdcut/n = 1e-12/1 tol = (1e-08,1e-10,1e-10*) (itns/time = 117/2.2)\n", + " fitter = scipy_least_squares method = trf\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PriorsPDF from normal approxPDF from general distsdiffz
hosp_prop0.024(10)0.0378(71)0.0238(25)0.0139(76)1.839339
logistic_x020.7(6.9)25.7(1.1)25.42(37)0.3(1.1)0.256967
incubation_days4.6(1.5)3.0(1.1)3.24(28)-0.2(1.1)0.191273
logistic_k0.78(43)1.02(41)0.95(12)0.07(43)0.164162
recovery_days15.3(5.0)17.1(4.9)16.5(1.6)0.6(5.2)0.120074
beta0.32(12)0.478(89)0.469(24)0.009(93)0.095106
logistic_L0.37(23)0.793(47)0.788(17)0.005(50)0.094641
hosp_LOS11.64(83)11.49(83)11.55(25)-0.06(87)0.067488
nu2.46(25)2.46(25)2.440(72)0.02(26)0.066927
\n", + "
" + ], + "text/plain": [ + " Priors PDF from normal approx PDF from general dists \\\n", + "hosp_prop 0.024(10) 0.0378(71) 0.0238(25) \n", + "logistic_x0 20.7(6.9) 25.7(1.1) 25.42(37) \n", + "incubation_days 4.6(1.5) 3.0(1.1) 3.24(28) \n", + "logistic_k 0.78(43) 1.02(41) 0.95(12) \n", + "recovery_days 15.3(5.0) 17.1(4.9) 16.5(1.6) \n", + "beta 0.32(12) 0.478(89) 0.469(24) \n", + "logistic_L 0.37(23) 0.793(47) 0.788(17) \n", + "hosp_LOS 11.64(83) 11.49(83) 11.55(25) \n", + "nu 2.46(25) 2.46(25) 2.440(72) \n", + "\n", + " diff z \n", + "hosp_prop 0.0139(76) 1.839339 \n", + "logistic_x0 0.3(1.1) 0.256967 \n", + "incubation_days -0.2(1.1) 0.191273 \n", + "logistic_k 0.07(43) 0.164162 \n", + "recovery_days 0.6(5.2) 0.120074 \n", + "beta 0.009(93) 0.095106 \n", + "logistic_L 0.005(50) 0.094641 \n", + "hosp_LOS -0.06(87) 0.067488 \n", + "nu 0.02(26) 0.066927 " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "print(fit)\n", "\n", + "# Convert names back to original\n", "name_map = {\n", " \"L\": \"logistic_L\",\n", " \"x0\": \"logistic_x0\",\n", @@ -614,24 +1441,28 @@ "new_posterior[\"logistic_x0\"] -= OFFSET\n", "new_prior = {name_map.get(key, key): val for key, val in pp.items()}\n", "\n", + "# Create comparison frame\n", "comparison = DataFrame(\n", " [new_prior, new_posterior, POSTERIORS],\n", " index=[\"Priors\", \"PDF from normal approx\", \"PDF from general dists\",],\n", ").T.dropna()\n", "\n", + "# Compute difference in standard deviations\n", "comparison[\"diff\"] = (\n", " comparison[\"PDF from normal approx\"] - comparison[\"PDF from general dists\"]\n", ")\n", "comparison[\"z\"] = comparison[\"diff\"].apply(lambda x: abs(x.mean) / x.sdev)\n", + "\n", + "#Present\n", "comparison.sort_values(\"z\", ascending=False)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Besides the `hosp_prop`, fitted parameters seem to agree. This might be related to optimization criteria or the estimated data uncertainty which I have not analyzed in detail." + ] } ], "metadata": { From 87469846e04824edf33a7585fa3d7876e39e61aa Mon Sep 17 00:00:00 2001 From: ckoerber Date: Sun, 26 Apr 2020 14:38:51 +0200 Subject: [PATCH 33/40] First draft of notes --- bayes_chime/normal/doc/.gitignore | 9 ++ bayes_chime/normal/doc/notes.bib | 12 +++ bayes_chime/normal/doc/notes.tex | 168 ++++++++++++++++++++++++++++++ 3 files changed, 189 insertions(+) create mode 100644 bayes_chime/normal/doc/.gitignore create mode 100644 bayes_chime/normal/doc/notes.bib create mode 100755 bayes_chime/normal/doc/notes.tex diff --git a/bayes_chime/normal/doc/.gitignore b/bayes_chime/normal/doc/.gitignore new file mode 100644 index 0000000..ae34925 --- /dev/null +++ b/bayes_chime/normal/doc/.gitignore @@ -0,0 +1,9 @@ +notes.aux +notes.log +xetex_import.sty +notes.bbl +notes.blg +notes.out +notes.synctex.gz +notesNotes.bib +notes.pdf diff --git a/bayes_chime/normal/doc/notes.bib b/bayes_chime/normal/doc/notes.bib new file mode 100644 index 0000000..15acadc --- /dev/null +++ b/bayes_chime/normal/doc/notes.bib @@ -0,0 +1,12 @@ +@article{Bouchard:2014ypa, + author = "Bouchard, C.M. and Lepage, G. Peter and Monahan, Christopher and Na, Heechang and Shigemitsu, Junko", + archivePrefix = "arXiv", + doi = "10.1103/PhysRevD.90.054506", + eprint = "1406.2279", + journal = "Phys. Rev. D", + pages = "054506", + primaryClass = "hep-lat", + title = "{$B_s \to K \ell \nu$ form factors from lattice QCD}", + volume = "90", + year = "2014" +} diff --git a/bayes_chime/normal/doc/notes.tex b/bayes_chime/normal/doc/notes.tex new file mode 100755 index 0000000..b13d1c8 --- /dev/null +++ b/bayes_chime/normal/doc/notes.tex @@ -0,0 +1,168 @@ +\batchmode +\documentclass[paper=a4, fontsize=12pt, prl, notitlepage]{revtex4-1} +\usepackage[ssp]{xetex_import} +\linespread{1.4} +\errorstopmode + +\begin{document} + +\title{Math behind Bayesian uncertainty propagation using normal approximations} +\author{Christopher Körber} +\affiliation{% +Department of Physics, +University of California, +Berkeley, CA 94720, USA\\ +Nuclear Science Division, % +LBNL, +Berkeley, CA 94720, USA +} +\date{\today} +\begin{abstract} +This document addresses the math used to infer posterior distributions and propagate erros used in \href{https://github.com/pennsignals/chime_sims/pull/49}{the performance boost through normal approximations PR}. +\end{abstract} + +\maketitle + +%============================================================================== +% Content +%============================================================================== + + + +\section{Assumptions} +The general theme of this document is: \textit{casting everything to normal distribution simplifies computations}. + +In general, the techniques in PR \#49 make two approximations +\begin{enumerate} + \item All underlaying \textit{input} distributions of the model can be sufficiently approximated with correlated normal distributions (this includes model parameters as well as data) + \item The posterior distribution can be sufficiently approximated by a normal distribution +\end{enumerate} + +\section{Error propagation} +The \texttt{gvar} module is used to analytically propagate errors. +The eqution used to computed the standard deviation of a function $f(\vec p)$ at a given point in the parameter space $\bar {\vec p}$ is +\begin{equation} + \sigma_f^2(\bar {\vec p}) + = + \left[ + \sum_{i,j=1}^N + \frac{\partial f(\vec p)}{\partial p_i} + \left(\Sigma_p\right)_{ij} + \frac{\partial f(\vec p)}{\partial p_j} + \right]_{\vec p = \bar {\vec p}} + \, , +\end{equation} +where $\Sigma_p$ is the covariance matrix of the normally distributed parameters $\vec p$. +In the uncorrelated case, this simplifies to +\begin{equation} + \sigma_f^2(\bar {\vec p}) + = + \left[ + \sum_{i=1}^N + \left(\frac{\partial f(\vec p)}{\partial p_i}\right)^2 + \sigma_{p_i}^2 + \right]_{\vec p = \bar {\vec p}} + \, . +\end{equation} + +The module \texttt{gvar} is capable of tracing such derivatives because implelentated functions are aware of their analytical derivative. +E.g., if you add two \texttt{gvar}s, the resulting \texttt{gvar} knows that it's respective derivative in direction of the previous \texttt{gvar}s is one. + + + + +\section{Computation of the posterior} + +This section explains how the \texttt{lsqfit} module approximates the posterior distribution $P(\vec p|D,M)$ given data $D$, an input model $M$ and it's corresponding priors $P(\vec p| M)$. + +\subsection{Defintions} + +The posterior distribution is proportional to the probability of the data given the model and parameters $P(D|\vec p, M)$ (the likelihood) times the prior of parameters +\begin{align} + P(\vec p|D, M) &= + \frac{P(D|\vec p, M)P(\vec p | M)}{P(D|M)} + \propto + P(D|\vec p, M)P(\vec p | M) + \, . +\end{align} +The marginal likelihood of the data $D$ given the model $M$ is obtained by integrating over the whole parameter space +\begin{equation} + P(D|M) + = + \int d \vec p P(D|\vec p, M)P(\vec p | M) \, . +\end{equation} +Because we effectively normalize the posterior by the ratio of both distributions, we can neglect constant factors in the computation. + +The likelihood of the data given the model and parameters is described by a $\chi^2$ distribution +\begin{equation} + P(D|\vec p, M) + \sim + \exp\left\{ + - \frac{1}{2} + \sum_{i,j=1}^N + \left[y_i - \vec f_M(x_i, \vec p)\right] + \left(\Sigma_y^{-1}\right)_{ij} + \left[y_j - \vec f_M(x_j, \vec p)\right] + \right\} + = + \exp\left\{ + - \frac{1}{2} + \chi^2_D(\vec p) + \right\} + \, , +\end{equation} +where $\Sigma_y$ is the covariance matrix of the data and $f_M(x_j, \vec p)$ the model function evaluated at point $x_j$ which aims to describe the data point $y_j$. + +Maximizing the Likelihood as a function of $\vec p$ corresponds to minimizing the exponent which is the standard $\chi^2$-minimization procedure. +Computing the posterior distribution function for a given prior $P(\vec p|D, M)$ is what we call Bayesian inference. +Normal approximations of the posterior distribution are somewhere in the middle of a full Bayesian treatment and regular $\chi^2$-minimization. + +\subsection{Normal approximation of the posterior} +The including the multivariate normal prior distribution with mean $\vec p_0$ and covariance $\Sigma_{p_0}$, posterior distribution is proportional to +\begin{align} + P(\vec p|D, M) + &\sim + \exp\left\{ + - \frac{1}{2} + \chi^2_D(\vec p) + - \frac{1}{2} + \chi^2_M(\vec p) + \right\} + = + \exp\left\{ + - \frac{1}{2} + \chi^2_{DM}(\vec p) + \right\} + \, , & + \chi^2_M(\vec p) + &= + \left[\vec p - \vec p_0\right]^T \cdot + \Sigma_{p_0}^{-1} + \left[\vec p - \vec p_0\right]\, . +\end{align} +In short, the \texttt{lsqfit} module approximates the posterior by evaluating the combined prior and data $\chi^2_{DM}(\vec p)$ function up to second order in the parameter space at the point which minimizes the $\chi^2_{DM}(\vec p)$ +\begin{align} + \chi^2_{DM}(\vec p) + & \approx + \chi^2_{DM}(\bar{\vec p}) + + + \left[\vec p - \bar{\vec p}\right]^T + \Sigma_{DM}^{-1}(\bar{\vec p}) + \left[\vec p - \bar{\vec p}\right]^T + \, , & & + \left.\frac{\partial \chi^2_{DM}(\vec p)}{\partial p_\alpha}\right|_{\vec p = \bar{\vec p}} = 0 \, \quad \forall_\alpha \, . +\end{align} +In this approximation, the posterior is again a normal distribution of mean $\bar{\vec p}$ (same as maximal likelihood estimation) with covariance $\Sigma_{DM}(\bar{\vec p})$. +The vector $\bar{\vec p}$ and covarinace $\Sigma_{DM}(\bar{\vec p})$ are computed by the \texttt{nonlinear\_fit} method (the estimation of $\bar{\vec p}$ is the \textit{fitting} process). +The appendix A of \cite{Bouchard:2014ypa} describes how $\Sigma_{DM}(\bar{\vec p})$ is estimated using derivatives of the residulas with respect of prior parameters. + + + +%============================================================================== +% End Content +%============================================================================== +\bibliography{notes.bib}{} +\bibliographystyle{plainurl} + +\batchmode +\end{document} From e0dbe4e6234bfc3c1be3af932fe5c7a9fef1eae8 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 14:38:51 +0200 Subject: [PATCH 34/40] Typos, phrasing & example for gvar --- bayes_chime/normal/doc/notes.tex | 118 +++++++++++++++++++++++++------ 1 file changed, 96 insertions(+), 22 deletions(-) diff --git a/bayes_chime/normal/doc/notes.tex b/bayes_chime/normal/doc/notes.tex index b13d1c8..edd927d 100755 --- a/bayes_chime/normal/doc/notes.tex +++ b/bayes_chime/normal/doc/notes.tex @@ -18,7 +18,7 @@ } \date{\today} \begin{abstract} -This document addresses the math used to infer posterior distributions and propagate erros used in \href{https://github.com/pennsignals/chime_sims/pull/49}{the performance boost through normal approximations PR}. +This document addresses the math used to propagate errors and to infer posterior distributions (Bayesian statistics) used in \href{https://github.com/pennsignals/chime_sims/pull/49}{the performance boost through normal approximations PR in the \texttt{pennsignals/chime\_sims} repo}. \end{abstract} \maketitle @@ -27,20 +27,18 @@ % Content %============================================================================== - - \section{Assumptions} The general theme of this document is: \textit{casting everything to normal distribution simplifies computations}. In general, the techniques in PR \#49 make two approximations \begin{enumerate} - \item All underlaying \textit{input} distributions of the model can be sufficiently approximated with correlated normal distributions (this includes model parameters as well as data) - \item The posterior distribution can be sufficiently approximated by a normal distribution + \item All model and data \textit{input} distributions can be sufficiently approximated with multivariate normal distributions + \item The posterior distributions can be sufficiently approximated by a multivariate normal distribution \end{enumerate} \section{Error propagation} The \texttt{gvar} module is used to analytically propagate errors. -The eqution used to computed the standard deviation of a function $f(\vec p)$ at a given point in the parameter space $\bar {\vec p}$ is +The eqution used to computed the standard deviation $\sigma_f$ of a function $f(\vec p)$ at a given point in the parameter space $\bar {\vec p}$ is \begin{equation} \sigma_f^2(\bar {\vec p}) = @@ -65,10 +63,52 @@ \section{Error propagation} \, . \end{equation} -The module \texttt{gvar} is capable of tracing such derivatives because implelentated functions are aware of their analytical derivative. -E.g., if you add two \texttt{gvar}s, the resulting \texttt{gvar} knows that it's respective derivative in direction of the previous \texttt{gvar}s is one. +The module \texttt{gvar} is capable of tracing such derivatives since implemented functions are aware of their analytical derivatives. + +\subsubsection{Example} +For example, suppose +\begin{align} + f(x, y) + &= + x y^2 + && \Rightarrow & + \sigma_f^2(\bar{\vec p}) + &= + y^4 (\Sigma_p)_{xx} + + 2 x y^3 \left[ (\Sigma_p)_{xy} + (\Sigma_p)_{yx} \right] + + 4 x^2 y^2 (\Sigma_p)_{yy} +\end{align} +Thus, if $x, y$ follow a multivariate normal distribution of mean $\bar{\vec p}$ and covariance $\Sigma_p$, one finds +\begin{align} + \bar{\vec p} + &= + \begin{pmatrix} + 1 \\ -2 + \end{pmatrix} + \, , & + \Sigma_p + &= + \begin{pmatrix} + 2 & 1 \\ 1 & 1 + \end{pmatrix} + & + \Rightarrow + \sigma_f(\bar{\vec p}) + &= + \sqrt{32 - 32 + 16} = 4 +\end{align} +The corresponding \texttt{gvar} code returns +\begin{lstlisting}[style=python] +from gvar import gvar +mean = [1, -2] +cov = [[2, 1], [1, 1]] +x, y = gvar(mean, cov) +f = x * y ** 2 +print(f) +> 4.0(4.0) +\end{lstlisting} \section{Computation of the posterior} @@ -77,7 +117,7 @@ \section{Computation of the posterior} \subsection{Defintions} -The posterior distribution is proportional to the probability of the data given the model and parameters $P(D|\vec p, M)$ (the likelihood) times the prior of parameters +The posterior distribution $P(\vec p|D, M)$ is proportional to the prior times the probability of the data given the model and parameters $P(D|\vec p, M)$ (the likelihood) \begin{align} P(\vec p|D, M) &= \frac{P(D|\vec p, M)P(\vec p | M)}{P(D|M)} @@ -87,11 +127,11 @@ \subsection{Defintions} \end{align} The marginal likelihood of the data $D$ given the model $M$ is obtained by integrating over the whole parameter space \begin{equation} - P(D|M) - = - \int d \vec p P(D|\vec p, M)P(\vec p | M) \, . + P(D|M) + = + \int d \vec p P(D|\vec p, M)P(\vec p | M) \, . \end{equation} -Because we effectively normalize the posterior by the ratio of both distributions, we can neglect constant factors in the computation. +Because the posterior is normalized by the ratio of both distributions, one can neglect constant factors in the computation. The likelihood of the data given the model and parameters is described by a $\chi^2$ distribution \begin{equation} @@ -113,12 +153,12 @@ \subsection{Defintions} \end{equation} where $\Sigma_y$ is the covariance matrix of the data and $f_M(x_j, \vec p)$ the model function evaluated at point $x_j$ which aims to describe the data point $y_j$. -Maximizing the Likelihood as a function of $\vec p$ corresponds to minimizing the exponent which is the standard $\chi^2$-minimization procedure. -Computing the posterior distribution function for a given prior $P(\vec p|D, M)$ is what we call Bayesian inference. +Maximizing the Likelihood as a function of $\vec p$ corresponds to minimizing the exponent--which is the standard $\chi^2$-minimization procedure. +Computing the posterior distribution function for a given prior $P(\vec p| M)$ is called Bayesian inference. Normal approximations of the posterior distribution are somewhere in the middle of a full Bayesian treatment and regular $\chi^2$-minimization. \subsection{Normal approximation of the posterior} -The including the multivariate normal prior distribution with mean $\vec p_0$ and covariance $\Sigma_{p_0}$, posterior distribution is proportional to +Including the multivariate normal prior distribution with mean $\vec p_0$ and covariance $\Sigma_{p_0}$, the posterior distribution is proportional to \begin{align} P(\vec p|D, M) &\sim @@ -140,7 +180,7 @@ \subsection{Normal approximation of the posterior} \Sigma_{p_0}^{-1} \left[\vec p - \vec p_0\right]\, . \end{align} -In short, the \texttt{lsqfit} module approximates the posterior by evaluating the combined prior and data $\chi^2_{DM}(\vec p)$ function up to second order in the parameter space at the point which minimizes the $\chi^2_{DM}(\vec p)$ +In short, the \texttt{lsqfit} module approximates the posterior by expressing the function $\chi^2_{DM}(\vec p)$ up to second order in $\vec p$ at the point $\bar{\vec p}$ where the first derivative vanishes (stationary or almost always minimal point) \begin{align} \chi^2_{DM}(\vec p) & \approx @@ -152,11 +192,45 @@ \subsection{Normal approximation of the posterior} \, , & & \left.\frac{\partial \chi^2_{DM}(\vec p)}{\partial p_\alpha}\right|_{\vec p = \bar{\vec p}} = 0 \, \quad \forall_\alpha \, . \end{align} -In this approximation, the posterior is again a normal distribution of mean $\bar{\vec p}$ (same as maximal likelihood estimation) with covariance $\Sigma_{DM}(\bar{\vec p})$. -The vector $\bar{\vec p}$ and covarinace $\Sigma_{DM}(\bar{\vec p})$ are computed by the \texttt{nonlinear\_fit} method (the estimation of $\bar{\vec p}$ is the \textit{fitting} process). -The appendix A of \cite{Bouchard:2014ypa} describes how $\Sigma_{DM}(\bar{\vec p})$ is estimated using derivatives of the residulas with respect of prior parameters. - - +In this approximation, the posterior is again a multivariate normal distribution of mean $\bar{\vec p}$ (same as maximal likelihood estimation) with covariance $\Sigma_{DM}(\bar{\vec p})$. +The \texttt{nonlinear\_fit} method numerically computes the vector which minimizes the posterior $\bar{\vec p}$ (fitting) and analytically computes and evaluates the covariance matrix $\Sigma_{DM}(\bar{\vec p})$ at this point. +The appendix A of \cite{Bouchard:2014ypa} describes how $\Sigma_{DM}(\bar{\vec p})$ is estimated using derivatives of the residuals with respect of prior parameters. +% +% \subsubsection{Example} +% +% Suppose the fit function is a linear function $f(x_i, \vec p) = p^{(0)} + p^{(1)} x_i$. +% In this case, the normal approximation of the posterior is exact +% \begin{align} +% \chi^2_{DM}(\vec p) +% & = +% \sum_{i,j=1}^N +% \left[y_i - p^{(0)} - p^{(1)} x_i \right] +% \left(\Sigma_y^{-1}\right)_{ij} +% \left[y_j - p^{(0)} - p^{(1)} x_j\right] +% + +% \left[\begin{pmatrix} p^{(0)} \\ p^{(1)} \end{pmatrix} - \vec p_0 \right]^T +% \left(\Sigma_p^{-1}\right)_{ij} +% \left[\begin{pmatrix} p^{(0)} \\ p^{(1)} \end{pmatrix} - \vec p_0 \right] +% \\ +% & = +% \left[ +% \sum_{i,j=1}^N y_i \left(\Sigma_y^{-1}\right)_{ij} y_j +% + \vec p_0^T +% \left(\Sigma_p^{-1}\right) +% \vec p_0 +% \right] +% + +% \left[\begin{pmatrix} p^{(0)} \\ p^{(1)} \end{pmatrix} - \bar{\vec p} \right] +% \left(\Sigma_{DM}^{-1}\right)_{ij} +% \left[\begin{pmatrix} p^{(0)} \\ p^{(1)} \end{pmatrix} - \bar{\vec p} \right]^T +% \, , +% \end{align} +% with +% \begin{align} +% \bar{\vec p} &= \ldots +% \\ +% \Sigma_{DM}^{-1} &= \ldots +% \end{align} %============================================================================== % End Content From 0e9744265b7c53fe6e759b191bc379e7b197d0eb Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 15:36:58 +0200 Subject: [PATCH 35/40] Included correlations in posterior --- ...-to-use-normal-approximations-module.ipynb | 178 +++++++++--------- 1 file changed, 94 insertions(+), 84 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index 0d92c17..744f651 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -41,6 +41,7 @@ "from gvar import gvar\n", "from gvar import mean as gv_mean\n", "from gvar import sdev as gv_sdev\n", + "from gvar.dataset import avg_data\n", "\n", "from lsqfit import nonlinear_fit\n", "\n", @@ -57,6 +58,7 @@ " plot_band,\n", " plot_gvar,\n", " plot_posterior_fit,\n", + " plot_gv_dist,\n", ")" ] }, @@ -509,7 +511,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -546,55 +548,55 @@ " \n", " \n", " hosp_prop\n", - " 0.0238(25)\n", + " 0.0235(30)\n", " \n", " \n", " ICU_prop\n", - " 0.367(11)\n", + " 0.368(11)\n", " \n", " \n", " vent_prop\n", - " 0.760(30)\n", + " 0.764(40)\n", " \n", " \n", " hosp_LOS\n", - " 11.55(25)\n", + " 11.59(29)\n", " \n", " \n", " ICU_LOS\n", - " 13.45(27)\n", + " 13.45(26)\n", " \n", " \n", " vent_LOS\n", - " 19.64(58)\n", + " 19.62(61)\n", " \n", " \n", " incubation_days\n", - " 3.24(28)\n", + " 3.25(29)\n", " \n", " \n", " recovery_days\n", - " 16.5(1.6)\n", + " 16.6(1.7)\n", " \n", " \n", " logistic_k\n", - " 0.95(12)\n", + " 0.94(14)\n", " \n", " \n", " logistic_x0\n", - " 25.42(37)\n", + " 25.41(42)\n", " \n", " \n", " logistic_L\n", - " 0.788(17)\n", + " 0.787(19)\n", " \n", " \n", " nu\n", - " 2.440(72)\n", + " 2.440(73)\n", " \n", " \n", " beta\n", - " 0.469(24)\n", + " 0.467(26)\n", " \n", " \n", "\n", @@ -602,19 +604,19 @@ ], "text/plain": [ " val\n", - "hosp_prop 0.0238(25)\n", - "ICU_prop 0.367(11)\n", - "vent_prop 0.760(30)\n", - "hosp_LOS 11.55(25)\n", - "ICU_LOS 13.45(27)\n", - "vent_LOS 19.64(58)\n", - "incubation_days 3.24(28)\n", - "recovery_days 16.5(1.6)\n", - "logistic_k 0.95(12)\n", - "logistic_x0 25.42(37)\n", - "logistic_L 0.788(17)\n", - "nu 2.440(72)\n", - "beta 0.469(24)" + "hosp_prop 0.0235(30)\n", + "ICU_prop 0.368(11)\n", + "vent_prop 0.764(40)\n", + "hosp_LOS 11.59(29)\n", + "ICU_LOS 13.45(26)\n", + "vent_LOS 19.62(61)\n", + "incubation_days 3.25(29)\n", + "recovery_days 16.6(1.7)\n", + "logistic_k 0.94(14)\n", + "logistic_x0 25.41(42)\n", + "logistic_L 0.787(19)\n", + "nu 2.440(73)\n", + "beta 0.467(26)" ] }, "execution_count": 8, @@ -623,10 +625,9 @@ } ], "source": [ - "thresh = 3.5 # Threshold for identifiying outliers\n", - "POSTERIORS = {\n", - " col: fit_norm_dist_to_ens(POSTERIOR_DF[col].values, thresh=thresh) for col in PRIORS\n", - "}\n", + "keys = PRIORS.keys()\n", + "POSTERIORS = avg_data(POSTERIOR_DF.T.loc[keys].T.values, median=True, spread=True)\n", + "POSTERIORS = {key: val for key, val in zip(keys, POSTERIORS)}\n", "\n", "stacked = (\n", " POSTERIOR_DF.T.loc[PRIORS.keys()]\n", @@ -636,9 +637,18 @@ " .rename(columns={\"level_1\": \"param\", 0: \"x\"})\n", ")\n", "g = FacetGrid(stacked, col=\"param\", col_wrap=5, sharex=False, sharey=False,)\n", - "g.map_dataframe(plot_posterior_fit, thresh=thresh)\n", + "\n", + "plot_dist = lambda **kwargs: distplot(\n", + " a=kwargs[\"data\"].x.values, kde=False, hist_kws={\"density\": True}\n", + ")\n", + "\n", + "g.map_dataframe(plot_dist)\n", + "\n", + "for ax, gv in zip(g.axes, POSTERIORS.values()):\n", + " plot_gv_dist(gv, ax=ax, color=\"black\")\n", + "\n", "show_plot(g)\n", - "DataFrame(data=POSTERIORS, index=[\"val\"]).T" + "DataFrame(data=[POSTERIORS], index=[\"val\"]).T" ] }, { @@ -777,7 +787,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "21.8 ms ± 986 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "20.4 ms ± 1.17 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] } ], @@ -802,7 +812,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAKYCAYAAAAmIGzwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydeXgcxZm435pLM7pG9336tnzJ4APixTgQ8G5IgGySBcICDhAIARISlhybbOKwm2xukgD7I4TDEByOAIEACZAQbI5gMBjjS7Z1jaSRNDpGmtEcmrt+f3TPWJJ1jGRLlk2/z9PPTFdXVVdVd9fXVfX19wkpJRoaGhoaGrMN3YkugIaGhoaGxmhoAkpDQ0NDY1aiCSgNDQ0NjVmJJqA0NDQ0NGYlmoDS0NDQ0JiVaAJKQ0NDQ2NWogmoDyFCiCohhBRCaN8YjEAIsUFtG9uJLsvx4FSrj8aHC01ATREhxFohxNNCiC4hREgI0SmE+KsQ4l9PdNk0Tm6EEDZVqGw4DtnZgV8BDxyHvCaNEKJCCHGPEKJNCBEQQjQJIe4QQuRNkC4uWEdunxkSp0oI8awQwiuEcAshnhBCFKnHhBDil0KIfvXclw9Jt1AI4RdCnJZE+SuFEPepeYSEEB3qeeaMEb9qSFmzkm8pjdEwnOgCnIwIIT4LPArogYPA80AGsBb4HPD0CSybUUoZPlHnnyk+LPU8FtQ2agBuOQ75TLqtVQH7LGACXgHagFLgeuAyIcR6KeXhCbJ5G9gxZL9ezVsHvADUAC8DKcBngXLgTOATwFeAP6th9wkhXpRSOoE7gQellLsmKP8i4E0gB2gHfg9YgfPU/00TNoLGsSGl1LZJbEAq4AQkipAyDDmmB2qG7C9FeYi6gR7gKaBiyHGpbjcBhwEP8AhgGhLnQuAdYABoAX4OpKrHNqjpbcBmtVwPAsXAa0AvEFbP/QiQpaarip97jDp+Xz1+55Cw76lhdwEC+CFKhxMEHMBLQO4Y+W1T0/6vWi4/yoNfOSTOcuBFtcw9wHPAwiHHbWoe3wb2A9ER4d9Xw73AL1E6rvfUNn0USBlynh1Av9o2nWqdTCPbdJx7YOh1awRcwP2AZUicTwE71fO3AHcPaX8T8Fu13YJqOz43oj5Dt03HcC8cVZ9jaOtb1PoG1bTbhqYb0Ub5ahmeB4qAa4FvAP8E/D/1Pnh3nDaOl3vzGMcvVo/vGfLsxcu9Afi6+j8XRXBJYA3wabXO2Uk86y+q6Q4A1iHhVqBkjDRVQ65b1onur0727YQX4GTbUN6e4jfgonHiFQF9QAhlRPUHNU0dRzrLeD5OYAtKxy2Ba9TjG9X9HuAhlE5dorz9DX2IJcpUzr3A14AFKJ3jg8D/oQg/Cdyjpks8RGOUfa56vAPQqWH7hzzkH+NIZ/h/wBNq3Kox8tumxo8AW1E6Vwn8Tj1ejCIwpNqhvaz+74x3JEM6nwjwGPCHEeEetY1C6n6feq5edf9aNf65KJ3jfcBv1HaTwDdHtKltnGsbb/MulKmzbnX/5+rxj6v7QbVM+9T9F9Xj16r7+9T2ewZwqse+iyKAJPAkirBdcwz3wrD6TLWtgXlDzn8PR0YQG8Zoo++r9UtBmWKMl+2gmn8eimA/a4z08XIPqO3YBNzOkReJ+EvUg0PS/FENuwX4pPr/rygCJgBUAK2oz9cEz7lFrb8Erp9E/1A1pK6agDrG7YQX4GTbgMuH3IBmNexHQ8KkGnYbR96+fqlu8Y7sn9U48TSfVfcfUvfvUvdfUPdfVtP/n7ofQxnJbRiyP29EOVeivEX+bMiDe1g9lniIxqlnvAPcACxR/9epx/5F3f+berwAZVSlGyOvbWr8u9X9z6v7+9T9+Nvuq0PSvK+GXafu29T920fkHQ//zohzPaHu/3zoudWw9cC3gF+gTD1J4GX1WLxNbeO0Tfy6XaTuX6Tu96j7f1b3v6fu56GM1iTKy8MNHBmBrwOyAf0oddowJGxK98LI+ky1rYHFatgHwPlAmRquH6ON3gS+hDKyCahlzkaZsouX5Vng5jHSnw3sRXnJ+j0wqJ7/h+rxezh6lP+IGvYjlPvxVyjCuA3luf0h8BawCGV01IDygpE+yvlLh1znf55E/1A1JJ0moI5x09agJk/3kP/lKHPib6j/PzfkWJX6u1jdhjJvxP776q9L/U0fkcd56hZHAEMXabukstagHBTiMpSHeiT5o4SNxUPAR4BLOFLnh9Xfl1E6yCuAV9Wwd1GmoDrHyXOietYNiXsQqAUqR+Tx5hh5x9PG8z6k/nrU3zQAIcS3UDqqkUymbUae86D6myeESGFEfaSUvUKIXpRRdSVKO25AEWyXogp7IcSnpJS+Mc4Vz3NS98I4+UyqraWUdUKI7wFfRpnORQhxCPgMykhpJPko04H5KKOov0gp+4UQr6LUGZSpzugY5XxNSrksviOEuB5FKH0a+E+U0SscuYeG/ndIRVp8Rd0QQsxHmVY9C0UoeVHa/1WUe/bbI87fp5ZNz9HtojFDaFp8k+dNlJsX4FtCCCGlfB746Yh4NvX3j1JKEd9QpljuHxE3ov7KMfL4yog85koph3YKwRHpLlF/f4PSOcT3xfhVG8YTKG++n1bTx1DeUEF5aG8CslCE7cPAKpSpq/GYqJ6LhoQtVH9bRsQdWdc4Izu6sTq+eFt8B0VJ6Bvq/mTaJk78xSNe7l4pZZAR9RFC5KKMokCpT0RKeQmQqebxNxShE9cAjZd96PMZz3Oy98JIhpVNZcK2FkLogR9IKfNQOuwfq+m+OsZ5etV4PWo+H1e12s5R8/sXlOnWHWOknyOEGO2axNTf3ervalVjTw/EtfI+GCXdncBDUsr3UITxbinlfpQ6146MLKUcRBldA3xFCGGNHxNCpA/RFiwWQiwSQhSMUY+k4miMwYkewp2MG8obYBSlo92NIgj+wvApvhKOzPW/pMb5G8pUT5UaJz4VEN//pbq/Rd2Pr2UMokwHPYAyUmlWj29glOko9VwSZb79fpQ3RAm41ONVQ8s6Tj2fGFLGV4aEb0Dp6B5FWfxvUOOMNV2zTT2+Sd2PL3DbhrSVSw37E0cWpx1AjhrHxohprxHhF6v7z6j7m9X9zSPa9CWOTL0+OOQa7R6vTUecM94mDrV941O3v1CPX6DuB1DWFvcyfBpxE8oI5ncoCgPx6/PJEe31hnpPlB/DvTAsfKptjXLPdKGsR92Nct9L1HW3UdroBygjZiOKcIi3WeuQ/6OmVdNvQZmdeIjhU3zxqVyd2obxac/t6v+3R8nrXxmiGAHsQhGgD6MIvF+MUYYalJdRibKutwXlmejhyP22RT3+y5HPFkeUYobF0bZJ9LUnugAn64aijfQcioJDXBPrRYYswKJoSz2nPtg+9YH6Jeqc95AbuUrdHyag1LCLUd4y3WrH8g5wi3psrE6pBPi7+lDvBm5magIq3tFK4Koh4fNRFp+7UZQSOlA62pQx8tnGOAJKDVuJIjycaufxPLB4yHEbx0dA1aB07AEUZYn/YuoC6jqUTtStdkKpQ+J8FkWL0IvSKd/DkQ7yTOB1ta4hlLf4/wbEkDLUc+QlaNUx3AtHhU+lrVFUrZ9Tr3VIvfaPMoY2HMpMgRtFQSgP+ALwTZT1v/8Ezp3g3rtYvT5OFOWhAyhKH7ohcarVMnlRpnKfZIR2Hcr6XAuqkowatgpllOVFWS8cVft0yDkeQBFQIZSXiT8Ac9TjW9AE1LRt8QdCQ0MjSYZY4KiWUtpOZFlmM0KIjSifVkQ58kJTiPJyd5eU8r9PYPE0TgI0AaWhMUk0AZU8qnLCd1DW2HJQlFd+DTwgtc5HYwI0AaWhMUk0AaWhMTNoAkpDQ0NDY1aiqZlraGhoaMxKNAGloaGhoTEr0QSUhoaGhsasRBNQGhoaGhqzEk1AaWhoaGjMSjQBpaGhoaExK9EElIaGhobGrEQTUBoaGhoasxJNQGloaGhozEpOGQH1z//8z3ELwpPe3nrrrSmnnW3bqVCXU6EOp1JdToU6aHWZnduQOozKKSOgent7p5w2GJzIx9vJw6lQl1OhDnFOhbqcCnWIo9VldjFRHU4ZAaWhoaGhcWqhCSgNDQ0NjVmJJqA0NDQ0NGYlhhNdAA0NjQ8P4XAYu91OIBA4Iee3Wq3U1dWdkHMfb07GupjNZsrKyjAajUnF1wSUhobGjGG328nIyKCqqgohxIyf3+PxkJGRMePnnQ5OtrpIKXE6ndjtdqqrq5NKo03xaWhozBiBQIDc3NwTIpw0TixCCHJzcyc1etYElIaGxoyiCacPL5O99pqA0tDQ0NCYlWgCSkND40NFV1cXn/vc55gzZw6nn346Z555Jn/84x9PWHm2bNnCTTfdNG35//CHP5xSumuvvZYDBw4c59JMDk1AaWhofGiQUnLxxRezfv16mpqaeO+993jsscew2+3Tet5IJDKt+Y/HVARUNBrlvvvuo6amZlJpjjeagNLQGAUpJYFAAJfLRU9PD52dnXR0dNDR0UFXVxdOpxOv13tCOx6NybN9+3ZMJhNf/OIXE2GVlZXcfPPNgNLJ3nbbbaxevZrly5fzm9/8BoBt27axYcMGPvOZz7Bo0SIuv/xypFRMyL333nucffbZnH766WzcuJHOzk4ANmzYwC233MKqVav41a9+xXPPPcfatWtZuXIlH/vYx+jq6hq3rJs3b+aKK67gzDPPZP78+fz2t78FlHvztttuY+3atSxbtozHH38cgM7OTtavX09tbS1Lly7l9ddf55vf/CaDg4PU1tZy+eWXA/DII4+wZs0aamtruf766xOCJT09nVtvvZUVK1bw1ltvsWHDBt59910AHn30UZYtW8bSpUv5xje+kSjjyDTf/OY3qampYfny5fzHf/zHsV0sZkjNXAhhBl4DUtRzPiml/J4Qohp4DMgF3gOukFKGhBApwMPA6YATuERKaZuJsmp8ePH7/bhcLjweD36/n1gsllQ6k8lEeno6VqsVq9WKXq+f5pKeGlR984Vpydf2owvGPFZXV8dpp5025vH7778fq9XKzp07CQaDrFu3jvPPPx+A999/n/3791NSUsK6det48803Wbt2LTfffDPPPvss+fn5PP7443z729/mgQceACAUCiU6+f7+fnbs2IEQgvvuu4+f/OQn/PznPx+3Lnv27GHHjh34fD5WrlzJBRdcwFtvvcXu3bv5xz/+QTAYZPXq1axfv57f//73bNy4kW9/+9tEo1H8fj9nnXUWd911F7t3707U//HHH+fNN9/EaDTypS99ia1bt3LllVfi8/lYu3btUWXq6OjgG9/4Bu+99x7Z2dmcf/75PPPMM1x88cXD0jidTq655hoOHjyIEAKXyzXxxZqAmfoOKgicI6X0CiGMwBtCiL8AXwPukFI+JoS4B7gG+H/qb7+Ucp4Q4lLgx8AlM1RWjQ8R4XCY3t5enE4nwWAQKSXBYBCfz0cgECAcDhMOh4lGo4k3Zp1Oh16vx2QykZKSgsViwe/309fXhxACq9VKfn4+mZmZJ7h2GhNx44038sYbb2Aymdi5cycvv/wye/bs4cknnwTA7XZTX1+PyWRizZo1lJWVAVBbW4vNZiMrK4t9+/Zx3nnnAcoIrLi4OJH/JZcc6bbsdjuXXHIJnZ2dhEKhpL4Fuuiii7BYLFgsFj760Y/yzjvv8MYbb3DZZZeh1+spLCzk7LPPZufOnaxevZqrr76acDjMxRdfTG1t7VH5vfLKK7z33nusXr0agMHBQQoKCgDQ6/V8+tOfPirNzp072bBhA/n5+QBcfvnlvPbaa1x88cXD0litVsxmM9dccw2f+MQn+MQnPjHxBZiAGRFQUnmyvequUd0kcA7wOTX8IWAzioC6SP0P8CRwlxBCyHgPoaFxjAQCATo7O+nv70dKic/nw+124/V6E1MeRqMxMTrS6/XodDqklESjUaLRKKFQiP7+fvr6+gCwWCxkZGQQDodxuVyYzWbcbjdSSk21ehTGG+lMF4sXL+aFF46M3O6++256e3tZtWoVoEyf3XnnnWzcuHFYum3btpGSkpLY1+v1RCIRpJQsWbKEt956a9TzpaWlJf7ffPPNfO1rX+PCCy9k27ZtbN68ecLyjrxvxruP1q9fz2uvvcYLL7zApk2b+NrXvsaVV145LI6Ukquuuor//d//PSq92Wye9Oh/aBqDwcA777zDK6+8wpNPPsldd93F3//+90nlN5IZsyQhhNCjTOPNA+4GGgGXlDI+iW8HStX/pUAbgJQyIoRwo0wD9o7I8zrgOoDCwkK2bds2pbJ5vd4pp51tnAp1mc46xEdMAwMDSCnxer14PB7C4TA6nS7xtprswyqlJBQKEQgE8Pv9hEIhhBCkpqaSmZlJNBply5Yt5OXlnVRf/Q/leF4Pq9WKx+M5LnlNhX/6p3/i+9//PnfccQfXXnstAN3d3Ugp8Xg8nH322dx5552sXr0ao9FIfX09JSUl+P1+IpFIouzxa15SUkJXVxd/+9vfWLt2LeFwmIaGBhYvXkw0GsXn8yXS9Pf3k5WVhcfj4b777iMajeLxeAgEAoRCoaPaJRgM8sILL3DTTTfh8/l49dVX+c53voPX6+WBBx7goosuorm5me3bt/O9732P/fv3U1payqWXXorb7WbHjh186lOfwmg00tfXh9Fo5IwzzuDSSy/lC1/4Avn5+fT19eH1eqmoqAAYVoZ4+Wtqarj55psTI8ZHHnmE66+/PhE3/uv1ehkcHOSss85i+fLlLF++fNRrHQgEEvdT/N7asGHDqNdrxgSUlDIK1AohsoA/AouOQ573AvcCrFq1So5VyYkYr4FONk6FukxHHaSUOBwOHA4HWVlZ9PX10dfXR3p6OtXV1WRnZ5ORkYFOd2x6Q8FgEJfLhcvlIhaLYbPZWL16NWazmYyMDCoqKjCbzcepVjPD8bwedXV1J1RQezwennvuOb761a/y61//mvz8fNLS0vjJT35CRkYGN910Ew6Hg7PPPhspJfn5+TzzzDOkpqZiMBgSZTeZTJjNZnJzc3n66af58pe/jNvtJhKJcMstt7BmzRr0ej1paWmJNLfffjubNm0iOzubc845J2H2yWw2YzKZjmqXlJQUamtrufDCC+nt7eW73/0uCxYsYP78+ezevZuzzjoLvV7PT3/6U+bNm8dDDz3EJZdcgtFoJD09nYcffpiMjAyuu+461q1bx2mnncbWrVv54Q9/yL/+678Si8UwGo3cfffdiXMPLUO8/PPnz+fHP/4xn/zkJ5FScsEFF3DppZcm4sXTeL1eLr30UgKBAFJK7rjjjlGvtdlsZuXKlcDE95Y4EbNmQojvAoPAN4AidZR0JrBZSrlRCPGS+v8tIYQBcAD5403xrVq1SsYXIyfLqdCpxzkV6nK86+Dz+bDZbAQCAdxuNz09PYTDYdLT08nLy8NisRy3c8WJRqP09/fz+uuvs2jRIrKzs8nPz8dgMFBSUkJhYeFJM+13vAXU4sWLj0teU+Fksl+3efNm0tPTx9SGO5nqMpSh98CQe2vUh2GmtPjygbCU0iWEsADnoSg+vAp8BkWT7yrgWTXJn9T9t9Tjf9fWnzQmi5SSjo4OHA4H4XCYzs5OfD4fZrOZkpISUlNTp+3cer2evLw8SkpKyM7OxuVyMTAwQFFREVJK3G431dXVmEymaSuDhsbJzkxN8RUDD6nrUDrgCSnl80KIA8BjQoj/Ad4H7lfj3w/8TgjRAPQBl46WqYbGWIRCIZqamvD5fLhcrsQ3J0VFRWRlZc3Y6EWv1yfO2dnZSXt7Ox6Ph6KiIg4cOEB1dTVWq3VGyqJxcpGMEsWpzkxp8e0BVo4S3gSsGSU8AHx2BoqmcQoyMDBAc3MzwWCQzs5OPB4PqamplJSUJO2H5nhjNpupqqrC6XTS09PD4OAgZWVlNDQ0UFJSMkw1WUNDQ0HzB6VxStHd3U1bWxuBQAC73U4kEiE/P5+8vLwTXTSEEOTl5ZGamkp7ezs2my0hmAKBAJWVlcespKGhcSqhCSiNUwIpJW1tbfT09ODxeGhvb0ev11NRUZHUWlMsFsPtduN2u8nNzZ3WxefU1FSqq6tpb2+no6ODYDAIKNOS8+bN0yxRaGioaAJK46QnFovR3NyMy+Wit7eXnp4eLBYLZWVlGAwT3+LhcJgPPvgA54CPQCRGfnpH4juY6cJgMFBRUZGw6xcKhSgtLeXQoUPMnz//hE1FamjMJrT5BI2Tmmg0Sn19PS6XC4fDQU9PT+J7o9GEUyQS4cCBA7z99tvYbDacTif79++nvc9Dd1CPV6bQ4w3S2NiYtC2+qSKEoKioiIKCAjweD62trfh8Pg4dOkQoFJrWc3+YEUJw6623JvZ/9rOfzbhCwlBDrMeb3bt38+c//3nS6To6OvjMZz4zDSWaOtoISuOkJRKJUF9fj8/nS2jH5eTkUFhYOCxeNBqlsbERv99PMBiky+1nICjpcjdj1AlCMYk7YmBezTJisRgN+3dj7+iiq6uLtLQ0Fi1aRHp6+rTVIzc3F71ej8PhoLW1lfLycg4dOsTChQs1NfRpICUlhaeffppvfetbU1qbjEQiSY3MTxS7d+/m3Xff5eMf/3jSaSKRCCUlJQkbhMmmme520EZQGiclkUiEw4cP4/V6sdvteDweCgoKjhJOUkoOHjxIfUsH++19NPb48GCmqHoBEUsuHn0GUUsucxYtxWhKIcVsobiiGrtP0uiK0NQ9wHu73qe7u3ta65OVlUVpaSmBQIDW1lYGBwc5fPiwNpKaBgwGA9dddx133HHHUcdsNhvnnHMOy5cv59xzz6W1tRWATZs28cUvfpG1a9fy9a9/nU2bNnHDDTdwxhlnMGfOHLZt28bVV1/N4sWL2bRpUyK/G264gVWrVrFkyRK+973vTVi2qqoqvv71r7Ns2TLWrFlDQ0PDuOX6wx/+wNKlS1mxYgXr168nFArx3e9+l8cff5za2loef/xxfD4fV199NWvWrGHlypU8+6zyuemWLVu48MILOeecczj33HOx2WwsXboUUJR2Pv/5z7Ns2TJWrlzJq6++Omqa0Vx8HE80AaVx0hEXTj6fD7vdjtfrpbi4mNzc3GEmjaLRKIcOHaLV0UtvEIqqF1E0dzHzalZgzcmjfO4CqhcuoXzuAlLMR6xJ5OQXseT0M1hy2hmYsgppdYc4ePgwfr8fj8eDz+eblnplZGRQVlZGMBiktbUVv99PfX094XB4Ws43G9i8eTNCiKS266677qj011133bA4yU7V3XjjjWzduhW32z0s/Oabb+aqq65iz549XH755Xz5y19OHLPb7fzjH//gF7/4BaDY1nvrrbe44447uPDCC/nqV7/K/v372bt3b8K9xQ9+8APeffdd9uzZw/bt29mzZ8+EZbNarezdu5ebbrqJW265Zdxy3X777bz00kt88MEH/OlPf8JkMnH77bdzySWXsHv3bi655BJ+8IMfcM455/DOO+/w6quvcttttyXu4V27dvHkk0+yffv2YWW4++67EUKwd+9eHn30Ua666ioCgcBRaeIuPnbv3s0HH3wwqgX1Y0ETUBonFfE1p7hw8vl8FBcXk5WVRTAYZO/evXxw4BDv7z/Ejh07aLI76PLHqJi3mMzsHDKs2Umrcuv0ekqr5pKWlU+3J8SuXbt4+91dvL3zXQ4cOIDf7z/u9UtPT08Iqba2toSQmg5vpR9mMjMzufLKK/n1r389LPytt97ic59THCxcccUVvPHGG4ljn/3sZ4dpWH7yk59ECMGyZcsoLCxk2bJl6HQ6lixZgs1mA+CJJ57gtNNOY+XKlezfvz8pF+qXXXZZ4jduJX2scq1bt45Nmzbx29/+dsx75OWXX+ZHP/oRtbW1bNiwITFKBzjvvPPIyck5Ks0bb7zBv//7vwOwaNEiKisrOXz48FFpVq9ezYMPPsjmzZvZu3fvcdd+1QSUxklDLBajoaEhseY0VDjFYjH2799PU6cThx96Q3pa+oP0BvVUL1xKeubUrTWUVM1hEBNt7hDtXknrQIyDrV28s/NdDh06hMPhSLxdHg/S09MpLS1lcHAQu92O3++noaFh2pU2Pmzccsst3H///UmPiIe6zgAS7jd0Ot0wVxw6nY5IJEJzczM/+9nPeOWVV9izZw8XXHBBUvfJUCsnE1k8ueeee/if//kf2traOP3003E6nUfFkVLy1FNPsXv3bnbv3k1ra2vCFt7IOiXD0DRxFx+lpaVs2rSJhx9+eNL5jYcmoDROCqSUNDY2Jr5xik/rZWVlAcocvaNvAE/MyPxlK1mwdCX5lQuYt3QFqenH9lan1xuYs2gZueXzWFi7igXLT0Nk5GNzR9jX1M67ew/y9tvvJNbEjgcZGRkUFxcnhLHX6028lZ9KbN68GSllUtu99957VPp77713WJzJaOPl5OTwb//2b9x///2JsI985CM89thjAGzdupWzzjprynUbGBggLS0Nq9VKV1cXf/nLX5JKF3fh/vjjj3PmmWeOW67GxkbWrl3L7bffTn5+Pm1tbWRkZAxzc7Fx40buvPPOhMPN999/f8IynHXWWWzduhWAw4cP09raysKFC4+K19LSQmFhIV/4whe49tpr2bVrV1J1TJbZq4qioTEEm83GwMAADocDj8dDYWFhQji1t7dja22j2x+jatECjEZF8y0r9/hZjzClpGBKiXseNVBWPY+8ohIG+vvw+zz0uvvpC7TT2t5JXraVpUuXHrOGU1ZWFtFolO7u7oQtQbvdnvDqqnHs3Hrrrdx1112J/TvvvJPPf/7z/PSnPyU/P58HH3xwynmvWLGClStXsmjRIsrLy1m3bl1S6fr7+1m+fDkpKSk8+uij45brtttuo76+Hikl5557LitWrKCioiIxpfetb32L//qv/+KWW25h+fLlxGIxqquref7558ctw5e+9CVuuOEGli1bhsFgYMuWLcNGiXG2bdvGT3/602EuPo4nJ8TdxnSgudtQOBXqMrIOdrudrq4uuru7cTqd5OXlJdxP22w2GppaaPdGyC+rIr+odIxcp5fAoB9nVyfuvl7yzJIl86qoqqri3XffTXhrnSoOh4P+/n4KCwvJycmhoqIiUf+ZQHO3MXPE75lk1CiMWosAACAASURBVN9ne13GYjLuNrQpPo1ZTU9PD11dXfT39+N0OhN+lUCZQmmytWD3Rimumn/ChBOA2ZJKadVcKucvptcfpUW1B3g8KCwsJCMjg66uLrxeL21tbSfUK62GxkyhCSiNWYvb7aa1tRWPx4PD4SAjIyPxnVN8TarXHyW3qJTsvIITXFqFtIxM0rJy6fdHjpumnxCCkpISzGYz7e3tDA4O0tjYmLDhp3HqYLPZZoVh49mCJqA0ZiWDg4M0NTURCARob2/HYrFQUlKS0Grq6uqip3+AgDSSX3ziRk6jUVxezUDEQGOXi0P1DTQ3N3OsU+k6nY7y8nJ0Oh12u51gcGbMMU0Hp8qygsbkmey11wSUxqwjEonQ0NCQ+BbIYDBQVlaW+H7J7/dzuKGBLl+E4ooq9PrZpetjSklhwfKVpGQX0xMycrCxhb179x6zMIm3QyQSob29Hb/ff9Jp9pnNZpxOpyakPoRIKXE6nZjN5qTTzK4nW+NDT9xNu9VqxW63E4vFqKysTGjExWIxDhw4QLcnRFpWPlm5M6csMBn0egPFFdX09rvpDoagu4+Mlhaqq6uPKV+LxUJRURGdnZ10d3cjhKCrq+soE0+zlbKyMux2Oz09PSfk/IFAYFId5GzmZKyL2WyelBaqJqA0ZhVxO3QdHR0EAgHKy8uHPYQOh4Mel5dBUphfNecEljQ5LGnpFBcWYDu0j5SWVrKzsxPq8VMlKyuLQCBAX18fFouF9vZ20tLSptWg7fHCaDQes5A+FrZt28bKlUc59z4pOZXqMhbaFJ/GrKGnp4fe3l7cbnfC+OvQTjcWi9HW1kZfIEZRWeUxT+1JKWl1R7C5wkRi0zfllJaRSW5RGV2+KAcPHjwuBmALCwuxWCx0dnYSCARoamoiEokch9JqaMwetBGUxqwgrj7t9XpxuVwsXryY3NzcYXG6u7vp9waQBjPWnNwxcpqYSEyyvyfEzo4gvX5lXcikhzPLzKwtTUE3gXmZqVBYWo7P48bh9rJ37170en1CDb2kpISKiopJ5SeEoLS0lObmZtrb26mqqqK5uZl58+ZNaB5HQ+NkQRNQGieccDg8TGPPZDJRVFQ0LE5PTw8NDQ30DUYpqKiecifs8EZ4ss6HN6SMmNJNAotB0OOPsb0lQENfmCX5JgYjEoc3Sn6qjoI0PUJAWYaBNNPUJh2EEFTMXUD9vt1Eu92EYhCKSnQCBvzNeL3eSXvSNRqNlJSU0NbWRldXFzqdDofDQXFx8ZTKqKEx29AElMYJRUpJU1MTwWAQu92OEIL8/PxhFsd7enrYs+8And4oZmvOlBUj+gajPHHAhz8syU/VsbbUzOI8I3qdoKk/zAv1fto9Udo9g4k09X1H0lsMgosWplKVNTV37EZTCtULl+Dud5KVloE5NY1Bv5f2psMM2rtwuVwsXLjwqJHjeKSnp5OXl0dvby+pqamAYsfvZFiP0tCYCE1AaZxQ4v6cOjo6CIVCVFRUMDAwMCxOa2sr3f4oWUVlFJZObiosjsMb4ak6RThVZxn4zOI09Lojo7A52UauXZnBIWeYFlcYEYtQkq7HHTHgDsXwBGN0eqM8vt/H8kITc7INdPuiLMg1UZimH+fMw7GkpWNJOyI8TCkpmJfUYm9uoLnPQ6yujjPOOGNSdvzy8vLw+Xw4HA4sFgvNzc3U1NQMcw2hoXEyogkojRNGf39/wr5eXClipPl/l8tFv9tLCAP5xVMzknqwN8QL9X7CMSjL1PPxagMN9YdpbmrGZrNx/fXXI3QCi1FHbVEKc9NCfO+7twNgNqdQUFBIQWEh5RWnYxf5fNAV4oMuRdFhb1eIa1ZmkmKY+rpPitnC3MXLaDq4D9egIqwnsyYVX49qamqio6ODyspKWlpamDNn9ms5amiMhyagNE4IgUAAm82G3++np6eHjIyMUae27HY7rmCU3IKypB0NxonEJDvsQd5oU5QRygw+Ajtf5vtb9g/7aNbr8w4zuhmNHHH8Fggo3m1bW1th50706bnkrvwYaTmF6FOtDIRge+sg589JnWwTHEVBSTn2+n20tbVRUlIyqVGU0WikuLiY9vZ2enp6EELgdDonNV2ooTHb0ASUxowTi8VoamoiFArR3t6OwWAYdWF/cHCQbqcTb1hQUlA0Sk5HYx+IsKszSExCuyeCJyRBSoKHXmPXvu2jpnG73cMEVEzGyMzMJBgMHmXvLup10v264q/HYC0k52NfYFdniIpMA4vyTMk2waikZ1oxWjJw+f3U1dWxcOFCTKbk88zMzMTn8+F0OklPT6etrY309PRR3SRoaJwMaAJKY8Zpa2tLfIwbjUapqqoadb3EbrfjDsSw5uYlfDyNxs6OAPu7w6SZBE39EYZ+0RQd6MHzwcuEuhqHpSkuKWbOnDnMnTuX/LzhShc5OTls/v5mkDDgGaCrq4uOjg4OHz5MQ30D4XAYgIi7C0P7biJlp/HMIT8f8UWpzjZSlqGfspZhcUU1tkP7CXf04vV6qa2txWKxJJ2+sLAQn89HR0cH1dXV2Gw2FixYoKmea5yUaAJKY0ZxOp309vbS29ubcNk+mrmWUChEh8OBOxBj7ryxjcG2eyL8vTmgCCXVc/eakhTe2/4ivZ12wt3NibhZWVmsWr2K1atXJ+dPSSijkszMTObPn8/ZZ59NOBSmvqGet3fsYN/+/ayvziBcbOb11gD/sAf5hz3I4lwDFy5Mm5JQSE3PYP6ylbQ2HKLd5cW4fz+1tbVJT/fpdDpKS0tpaWnB4XCg1+vp7u4+aUwhaWgMRRNQGjNGIBCgtbUVn89Hb28vmZmZR5n9GRgYYO/evQQCAQYGI6Rl5WC2jL6+E45KXqj3I4HaQhMlGXoK0/QUphsoDdXwm3teB6CoqIiNGzeybPmySa9jjcRoMlJTU0NNTQ2ufhdp6WkYjUaK0vTU94U50BOizhnB8Zd3ufKjS6d4jhSqFtbQWLeX9j4Pxv37WbYs+bJbLBby8vISa3vt7e1kZmZOaiSmoTEb0ASUxowwdN2po6ND6dSLjl5Xstls9Id0NDiDgKC6anTNvXBU8vRBH32DMXItOj42x4JhiNr4woULOffccykpLaF2RS1Cd/ynuLKyjwjXuTlG5uYYifU2s4dS+q3zuePVVualDDBv3uTz1usNVM2vofHAHuw9/RgPHmTx4sVJj8pyc3MTfrRSU1Ox2WwsWrRIm+rTOKnQbPFpzAh2u53BwUE6OzuJRqOUlpYete40MDBAT18/AYzMW3YaC2pXkZo+3KV1TEoO9oZ4ZK+XZlcEiwF0h1/B1jR8jQnggk9cwMqVK6dFOI3FgG0vnvf/QiwcRGctpNE0l9/96ZXEutVkMKUoI6neALR19tDe3p502riTw1gshsPhwO/309nZOekyaGicSDQBpTHtuFwuenp6cDqdeL1eCgsLR113am1tpX8wSmZOHilmy1GKEV2+KFs+8PLMIT9dviip+hjeN7ey/+3X+d3vfjcr3KBfeumlXHJWDcHtv8F/eAdCp6MtfRG/vvdhnL3OSednSU2jtHo+3f4Ira2tkzIIm5KSQn5+Ph6PB7fbnRBUGhonC5qA0phWQqEQNpuNwcHBxJpIdnb2UfH6+vro6nHijQisI0wZ7XYEuf/9AR7c7aHbFyUzRbDM4qLj+V/ibFNGTp4BD3v27JmROk3E8hUr+OZt/8Ec0UXQ0YAuJY3Q8ou56/l32L//wKTzs2bnYrCk0+8LcfDgQfbu3Utvb29SaXNycrBYLDgcDsLhMDabTXMWqHHSoAkojWlDSklzc/OE3ztFIhHq6+vp9kcpKKnAYDhi667DE+HFxkF6/DH0Ak4rNrE8VMfft95JyOcFFGsPV151JevWrZuxuk2EJTWVTVddxRJdBwHbbhA6UuafyRPv2XnttdcnnV9RWRXOwSjNnb3UtfVw8ODBhDX08YhP9Ukp6ezsZHBwEIfDMZUqaWjMODMioIQQ5UKIV4UQB4QQ+4UQX1HDNwsh2oUQu9Xt40PSfEsI0SCEOCSE2DgT5dQ4vnR2duL1euns7CQSiYy67gTQ0tJC98Ag0pRGXlFJIlxKyd+aFcOtq4pNfHWtlUjdNp7+wxNI1X9Tdk42X/nKLdTW1s5MpSaDgNplNVyzfi6xD/6EjEawzF3DXw/1s23b6B8Nj0V6ppXsonJC5mykOZNub5jDhw8nldZkMpGfn4/X68XtdicElYbGbGdKAkoIsU4IMRkd2ghwq5SyBjgDuFEIUaMeu0NKWatuf1bzrwEuBZYA/wz8nxBCs3x5EuHxeOjs7MTlcuHxeMjLyxtVzTkQCGDv6MDpj1JWPdyX0d7uEB2eKGlGwVkVFp5/7ln+9re/JY6XlZfxla98hcKiY/vGJxgYnNZpr/Lycr5y5adJsb2BlJK0mvX0568gOkkniUVlFVTMXUj53AV4Ijocvf2Tnurr6uoiHA7T0tKiTfVpzHqSElBCiHvUEY4QQjwCvAZ8IIT4UjLppZSdUspd6n8PUAeM/fUlXAQ8JqUMSimbgQZgTTLn0jjxRCIRmpubCQaDCTXnvLy8UeO2tbXhGoyQnp2LJfWIodhmV5gXG5W3/LMrzDz/7NO8tv21xPGamhpuvPFGMjMzkyqTy9lDr6MDv9eT6JillLQ1HqZh7y4a6/bg906fkkV6Rjo3X3oBBc73MQjJIRfs7AhOnHAUjEYTBSXluAJROjo6kkojhKC4uDih1efz+eju7p7S+TU0ZopkR1DnA3YgFbgE2At4gC9P9oRCiCpgJfC2GnSTEGKPEOIBIUR89bwUaBuSzM74Ak1jFmGz2RLrTnHLBqOhmDvqpD8gE240pJQ0+VN4us5HTMKq4hQiHQd48403E+lW1K7g6qs/n7SNOXdfL53Nh/F12Wg9tIdDe3bR2WajpeEgwYFeqrIMZMhBmg/upa9n+tZnjCYj11x0DhctVNxtvO8IEYuPYiY5mMnOK8AfFfT29SetmZeSkkJeXh4ejwePx0NHR8dRtgY1NGYTIplhvhBiEHgA2ALsAGqBm4ArpJRJm3EWQqQD24EfSCmfFkIUAr0oj+d/A8VSyquFEHcBO6SUj6jp7gf+IqV8ckR+1wHXARQWFp7+2GOPJVuUYXi93lPGwduJrkvchUZ/fz8DAwMUFBSMOrUXi8VobGykcyCIPrOAgtIKYhLedmfQHlQET5U5wOmZXkCyfft2Duw/wPz58zn33HPR6Ud/t5KxGJ2tTQQH/QidjtT0TPweN1m6QXIz0wkGg3iDYYIxHQLIMEqqKiuVj1p7nPSFjVis2aRnZmEwmggGBvF7B8jMzjvqm6xkCAVDmFKGq8tLCS86s/FF9azLchPpauKdd97hgk9cMKr6/Vj0dLQRG+iiujB7zJeAkcSVJWKxGCUlJaSnp1NeXj5umhN9Tx1PtLrMLuJ12LBhw6gfKyZrScKLIpQuA8LAQcAETKxGpCKEMAJPAVullE8DSCm7hhz/LfC8utsODH1qytSwYUgp7wXuBVi1apXcsGFDssUZxrZt25hq2tnGiayL3+/n4MGDZGdnY7fbyc7OHtVaBEBzczPOAT9hq54FS1ci9HqeO+ynPRjGKGL8y/x0FudZEUJJP2/uPHbu3Mmq1avGNfnT0dpEWW4mBenZxGLgCcUQuRbmFOexbNkypJSJ77F0Oh05OTmJh7yzs5NDh+sZCEbxhUNEQyEsBijOT6c/FKKqshLDJFyyAzQ0NDBvFFMSTkuAbS0BmgYtHHjpRcKhMH/961+54Ys3YLYkJ6RKS4ppPrCb7JwUFi1alHRnFQgEaG5uTlyfqqqqcd1yaM/H7ORUqMtEdUh2im8bcCbwFeDvUsowsAw4lExioax83w/USSl/MSR8qM7xp4B96v8/AZcKIVKEENXAfOCdJMuqcQKIxWI0NzcTDofp7OzEbDaPaqBUSklDQwONza10+aKUz1mA3mBghz1IXW8Ykx7Oyh6gJt80TGFC6ARr1q45SjiFwyHCIWWaasDVj6u7k8J0AytXrGDt6tNZOrecuSX5LFiwQMlHCPLy8qiqqqKiomJYp15cXMzaNatZsXAOS8rzWFxipaYin7I8K+n6KA677bi11/JCE3oBnUEjsRQrAG2tbdz723uTnnazpKaRkVOAYyBEXV1d0h/xms1mcnJy6O9XpgftdvukPgDW0Jgpkh1BfQFFGBmAXwohTChCZFeS6dcBVwB7hRC71bD/BC4TQtSiTPHZgOsBpJT7hRBPAAdQNABvlFJGj8pVY9bQ2tpKIBCgvb09MX00mt231tZWGlvacfhjlM5ZQHqmFU8wxlt2ZTD+qYVpHNqxgz8efJ+LL7p4TDNFgUE/3R1tePqcCJ2OeUtX4rDbKEjVM3dOdcII7Wijl/GwWCxUVlYOC/P7/Xi879Ha102d20V2XgGFpRXHZNcu1ahjeaGJ9x0hFm68nANP/gp9Rh6d4VR+s/Upbvj3z2I0TTxaK62cQ0Odl85+L+a6OpYsWZKUUdm4hYnOzk4sFgttbW1UV1dPuT4aGtNBUgJKSukCvjMi+PZkTyKlfAMY7Wn+8zhpfgD8INlzaJw4+vr6Em40/H4/xcXFoyowxGIxOjo66PZHKJuzmMzsHABebw0QjsGCHCO47LzyyitEo1F8Ph+fu+wydOq3U94BN+5+J5FQCK+7j2yzoDJLT/9gjNbGg8SCfrLz05Jej0mW1NRUFi6Yj6GxkcFQhO7udiLhEKVV845JSH2kzMyerhC90krVp2/DL5S1Ol8kxJbfP8Y1V3wuUfex0On1VM1fTMP+DzB2OUlJaUiMFsdNp9NRVFREW1sbTqcTIQS5ublJa0VqaMwEyaqZ/32M7ZXpLqDG7CYYDNLS0oLf7x/ThUacnp4eXP4QupTUhHBqc0fY0x1CJ6DWGuCBBx4gGlUGy3a7PTHd1d1hp+XQPoSnC3PIRZXVQE11GSuWLSPLrGPQ58WaonS6x+pSYzSKior4yEc+wsrlSynNNBJw9XBg19u0Nh4iGp3a9FhGio7TihVB7hcWDDJM1O9GGEy0BNN48qmnktLuM6WYqVywmC6/pMXembSliPT0dDIzM+nt7SUYVFzbx2KxKdVFQ2M6SHaKb8MY4dqXfh9ipJTDXGgYDIYxlSIAOjo6cAei5JUpS4+BiOS5esXL4OmFep54+B58XmU/LT2NL1z7BSypqXS22Rjo7qDCaqCyvIy0tDSsVmtCO7CoIB93sAtrin5UU0rHi/goY8XyZVgOH8Y7OEivx4nDbqS0cs6U8vxIWQr+cIy8VD2nF1t56uU3aGEZlrmr2PHnX2O1Wtm4cWJDKmnpmRRXzqGrtZHUxkays7OTUsMvLCzE6/XicDhISUmhs7PzuI9ANTSmSrIC6vND/utRFCRuAO487iXSOGmw2+0JNw6RSGRM1+0Avb29OF0DBKWerJx8pJS81OhnICgpStNx+OXf092lfDiq1+u5+uqryc3LpbvDjru7nfJMI0uX1Iz6wW9FRQX9/f0UFhYm/W3UsZCVlcWaNWsYGBhg1/u7sXV3EgmH8Hs9pJgtZOXmkZM/tqAeisWo45MLjnygfMn56/jFa+1gycRcsZSXXnwJq9XKGWecMWFeOfmFDLj66PK4qK+vZ+nSiY29GAwGCgsLE1Y/4kJ4MuruGhrTRbJrUA+NDFM18zTrDh9S4t87TeRCAxSL5ocPH6bbFyW/pBKdXs877QFFa08Hafa32XP4iELoOeeeQ1FBPo0H9hAZ9FKaYaBm8aIxrVGkp6dz5plnTsvU3nhkZmZSVVnBYNhGKNBPqUVHKOqlu9WN0ZRChvVoq+0TodPrOHdhHi81B8k47QJiAR+dHcn7cSqtmkv9nl04up0U9faO2WZDycrKwuVy0d3dTXp6Oi0tLSxcuHDSZdfQON4kJaCEEOtHBGUCHwWqjneBNGY/8XWnoS40cnJyxoxfX19PjzeIPjWTvMISWtxhXrUpWnuLDQ7++spfEnHPO/88cq0ZNNXtIdeiIzfXzNy5cykoKBi3TDMtnOJUVFQQiUTQ6XQUFBTQ1dVFrLmN7va2KQkogNpiMx2eCHt7IfufLmPNiuQVF4xGE4VllXS3N9OoTvWNNaodSlFRETabjZ6eHgwGA06nc9xvozQ0ZoJkp/i2cfR6kwD+cVxLozHrGeq6fTwXGnHsdjvtXb24QoJ58+cTiEieP+xHAkutIbY9/GAi7qJFC5lXXkJ70yEWL6qkoqyUqqoqDIZkb9OZR6fTDVNlN5vNOBwO+vo8eAdcU8pTCMHHF6Sj1/nZ3R3mucN+rq7NwKRPTmMwp6CIvp4uegcGaW1tTUp9PP5tlNPpxGq1YrfbsVqts7rtNU59kn3tbB2x1QFbgcunqVwas5T4ulNHR8e4LjRA8aRb39hEpzdCafV8dEYTz9f78YQkpRl69j2/JeEKPTc7kzUrFpOGn8JUOK12BfPmzTvpOkiDwUB5eTk5Fj0t9XU4uzoSHxJPBiEEH5ubSn6qDlcgxiuq2xEZkxNq2gkhKKmaQ48/SktrGz6fL6lz5uXlYTQaE84NJ+NiXkNjOkhKQEkpq6SU1UO2pVLKK6SULdNdQI3ZQ19fHz09PfT29uL1ese0sweKja19+/bR6YmQXViKSM1m614vjf0RUvTwyQWpXHHF5eTl52HSw4aPrKEiK4V5pQUsXLhwTFX1k4GSkhIqi/IoT9cR6uvg8J5dtDUeJhRM2jIYAAad4JML0tAL+KArRF3XIA//7mH+9Kc/TZg2LT2TrPwiev2KM8hkbG7qdDoKCwsJBoP09fXR29ubtHDT0JgOkv0Oar4QYr3qbqNGCPFbIcRPhBDW6S6gxuxgcHBw2PdO4607BQIB9u3bR8dACFNGDoWlFTxz0EenV3HXftnSdLLMekpLS7nxhhs4/5yzWVqey8I5ldTU1CS1ZjKbMRgMLF26lNWnr6QyL4Mqqx6d30n9nl04uydnLb0gTc/ZlYryybN1LvbUNfDa9td4++23J0gJRWWV+GIGuvvc9PX1JXW+jIwMMjIy6Onp0fxGaZxwkp3iuxd4QCp36lPANcCtwN3TVTCN2UM0Gh227mQ0GsdcdwoGg+zZswd7v59YSgblcxdQ1xuhw6s4Hvz8igyK0pVpu1gsRle7jZrKQspLFKOlx2KZYbaRmZlJZWUlZ6xdw+KqEsoz9Thamwkk6R4jzuqSFCoz9WC0kF5zNgBPPfUU9jb7uOn0BgP5xaW4AlHa2trGjTuUuA3Frq4uBgcHcbmmtpamoXGsJCuglgI7hBClwELgx8Ae4GPTVTCN2YPNZmNwcBC73U40Gh1z3SkQCCjCqc9HyJBG1YLFRKVgW4uyfnJGkQ5P/xEPsM6uTvThQQqtqcydO3fG6jPTmM1mFi5cSHlpMbkWQUvDQVobD9HrSN7Z4HlzFa82lqpahMlCJBxhy0Nb8PvGF3Y5+YUMRnX09rtxu91Jnc9oNCb8Rnm9XpxOZ2KtUENjJklWQGUAA0ANijbf3cCbwMm7UKCRFA6HA5fLlXibLi4uHvV7p2AwyAcffEBrr4dBnZnqBTXo9QZebw3gCUkKUnXsevEx7vjFHezatYtIOExPRyt5qXrmz58/Y8oQ0WiUQCCA1+tNdMA+n49AIJAwsTRdzJkzh0JrKpm6IOZAP932ZnyegaTS5qXqmZttAL2BjAVrAehz9rH191uR47iO1+sN5BSW4ApEaW5uTtqUUW5uLiaTCYfDQSQSwW4ff7SmoTEdJNsr2IFPo7jccEop7UKIAhRngxqnKAMDA7S3t+N2u+nv7yc7OxurdfRlx/r6ejpdfkLGNOYuWILeYMA+EOGdjiACyO3bz/a6OgAe+d0jXPm5fyPHJCnKzyU7e2rfCyVDMBjE5/Ph9/sZHByc0K2E0WjEbDaTmppKWlracbVMEV+bKlKN6gq7g3ZbA/OW1Cb1HdfqkhQa+yNYF6/D17KPqKeXugN1/PVvf+X8888fM11+UQmHe7ro6HVhPnyYRYsWTXguIQRFRUW0trYyMDBAX18feXl5ZGRM3mmjhsZUSVZA3QX8AsgHviuE0AHrOeK2XeMUIxgM0tTURCAQSLhkGM2/EyhmjBzdTtwhmL9sEXqDAV8oxvP1yvTTovRBXn/6qUT8M9euwiSi5KYap8XFQzQaxe1243K5EsZmjUZjQuAYjUYMBkNCKMRiMSKRCKFQiGAwyODgIB6PBwCTyYTVaiUrK+u4jPJSU1OpqKggFovh8Xhwd3vodXRQUFI2YdpKq4GidD0OL+SefwO+g2/g2/8qL734IpUVFSwcQ/DoDQaqFiym6eBeDB1dmM1mqqqqJjxfWloamZmZHDx4kFAoRGtrKzU1NafUOqHG7CZZU0e/FEI8BxillAdVAbUWZdpP4xQj7o49FApht9vR6/WUlZWN2jFFIhEaGhro9kcpLKvGaEohFJX8oc6HKxCjwCLY+/yDiamlirJSFs2ppDTdwPx5c0lLSzsqz6kSiURwOp309/cjpUwI1YyMDIyqJ1ydTofJZMJoNCYEVDQaJRwOEwqFEhpr4XAYr9eL2+1OqNZnZGQcNzt18Q98B3x7aOtoIzMrB3Nq6rhphBD8W00ar7cG2O0Ikbb4LJAxfAe287tHHuHWr91Kds7oo1FLWjrlcxZibzyIrrmFlJSUpAzrFhYWIqWkq6sLk8lEd3f3mC8qGhrHm6RfCaWUjUKIHCFERTwIZW2qf1pKpnHCiJsxam9vJxKJUFlZOebooa2tjV5PAFLSyClQDKS+3OTH4Y2SZdZhOPgSfb3KTLDZbGb9maspTNdTWV5y3Kxmx2KxxHc7wDBBIoTAarWSmZlJenp6Imw0pJSJ9amBgQFSUlLIzs4mFArR39+Py+ViYGCAjIwM8vPzj3n6Lzs7m/KSYvyhDtqa66leUDOhS/lUo46Nc1OpyjLwzEE/aTVng96Ib+8rPPX0U1x77bVjps3MzqGwvEvEBAAAIABJREFUYg6dbY0YDtdjtVpJnUAoGgwGsrKyEmt2HR0dZGdnYzKZplRnDY3JkKwtvnNRXLaXjzgkk81D4+Sgp6cn8UGuz+ejuLh4zI9x/X4/La1t9PqjVC+egxCC9oEI+7rD6AXUxGw8s/OtRPyNH/somRYDBda046a1F3cVEQ6HycjIoKCgAJPJhMViIT8/n//P3ntHR3bdd56f+ypHVK5CoQq5G81OTC2KlCyJFpVsKo5lSl7LQfLYqzNyGIezntmZ2fWcPfY6jG15PMeelUeSKZNiW1YgKUq0TVumJEqkaVFi7tyIVUChIlA53v3jocroBio0utFEd7/POXWAerjv1a0Gun7v/u7v9/16PJ6B+6qEEFgsls65rVaLXC5HMpnEaDTi8/nIZDJkMhkKhQIulwu/339ZfVuTk5Nks1lqmSKnX3yO8Pg0Lm9/gdcZr5F798HXzhSxzbwB5/AYP3Zn/4DvDYQoF/Ok15OcP39+IMVzh8OByWQikUhgs9lYWlpicnJn9iIaGpfCoMHlfwKj2xzXktHXEcVikcXFRQqFAqlUCpfL1VXRodFocOLECVKlBkO+AFa7g2ZL8sR5taT8iKfF397/EACyUWNmegKv00bAqmN6evqyxV1brRarq6tks1mMRiOjo6PYbDYsFgvhcPiKKFEoioLH48Hj8XRsRXQ6HW63m1QqRTabJZ/PEwqFdlw8oNfrOXr0KNazZ1lJZojNncHpcvd10gU4HDDiNCl86dV1qs4RzpTM3DFAvUkoMs7pl9KsJNMMDyAKK4QgGAyysLBAOp1GURTy+bxWMKGx6wz6KRECngEmAQ/g3vTQuA5oN+NWq1VisRhms7nrXkOj0eDll19mKb1ORZgZjk6QLTf5q5cKrBSbOIyCU/9wnEqlimw1sZkU3veW1zHh0jE+Grnsqr1qtcrs7CzZbBaPx8Pk5GSnKfamm27aFZkkq1Xt1brppptwu92EQqGOkO3S0hKxWGzHZeoWi4UjR47gczsxKZL13GCqDwCjQ3reM6MGim8vVFir9i8j1xsM+MNRkqUmp0+fplLpL8HULphIp9OdgglNYUJjtxk0QH0ZKEgp56SUOSnlWvuxm5PTuHrMz89TrVaJx9Xm0ZGRkW1XOfV6nZdeeonFZI61up6JmUOUWwoPvlRgZUPK6FZzkvlzZ9UTGhXe//a3sH9ylB964xsvO7WXz+eZnZ2l2WwyOjpKMBjE7XZz6NAhfD7frleYWa1W9u/fz8TEhOoHNT6O3+/vzKtcLu/42sFgEKdJIZNMXNJ50x4DM14D9RY8drpIvSlZWlrq2R/lC4ZRLE7iuTKvvPLKQMF1s8JEpVJhdXX1kuapoXGpDBqgrMA9QogXhRCfE0J8ZuPx6d2cnMbVIZPJkM1mSSaTnWbc7TbBW60WL774IvOrOXINPZM3HUZnMPLwqSKFuiTi1PGxWxy84cg0H/nJn8Cka3Hs5kMc2TfG5OTkZZdpp1IplpaWMJvNTE5O4nA4GBsbY2pqqlOld7XweDydoOjz+RgbGwPUQD+o7t3FBAIBHCYd5fzaJSugv23Cgt0gWFxv8hdPzfHHn/wTvvFP3+g6XgjB2PQBSphYyeaZn++v+6zX6/H7/RQKBQqFAvF4XFOY0NhVBg1QP4a633QY+Ajws5seGtcwjUaDxcVFyuUy6XQal8uF07m9Qd78/DyJbJ58y8jUwaMYTGa+dqbE0rqa1vvAjA2zXqFcKmKizr+97z28582vY3p6+rKqvqSUrKyskEwmcTqdnf2mAwe6u+xeDXQ6HePj40xOTmK325mYmMBut5NIJIjFYgOrNrTR6/X4fT7sRjGwDFIbh0nhQ4ft6GmwrndjPXg3j3/9cebnugcenV7P6NR+ksUmC4tLFAqFvq/j8Xg6ChPNZlNTmNDYVQa9pf2vuzoLjdeMxcVF6vU68Xgcg8HQ1bk2n88zt7BIstRi7MA+9HoDXz1d4tUN2/YPHLBhM6r3O8sLs3jMgn3RSSYmJi6rb0hKSSwWI5/P4/V61VWGw3FFVmRXCrfbjc1m49y5c+h0OlKpVEcN/FL3pSKRCMuJVRZWl3F5/Vhs9oHP9Vt13HfQwedfKWKbeSO1xHkeePABfuM3fqNrSbzV7sAVGCaVW+H06dMcPXq057/rZoWJdDqNEAK/34/dPvg8NTQGZdBGXS1AXYcUi0UymUxn4zsajW5bMi2lVG3biw3cgWFsdiezuXonON13yE4pMUdRGUY269SKa4y4TUxPT19W6m1zcAoEAni9Xjwez55UPTcajRw4cICFhQUATCYTsViMlZUVqtXqwD1TDoeDsWiE0vlF5k6fwGgy4QmEcPt6W963GXWbuN1f5LkUOF/3PjJP/H888vAj3Peh+7qeExoZ5XQ2zWJqjdbzz3P48OGeNxU2mw2Hw0EqlWJoaIiFhQVuuummPfc70bj2GbjWVwjxU0KI7wohEkKI0Y09qHfu5uQ0dpd2I25bJaHbXXAikSCZy1ORBoIjarfB95drANwZMWOprfGZT3+aP/i93+Ofv/1NvBYdo6Ojlx2clpaWOmXc7dXTxMTEnv0gFEIwNjZGNBrF4XAwPj6OlLLT+DwoY2NjBIasBM0thiixvDC4yCvAPfvduEQZncWJ8/b38Mwzz/DySy93Ha/T65m66SgFaWIxnefs2bN9X+NiS45kMjnw/DQ0BmVQw8KfB+4H7gR8UsoF4G7gV3Zvahq7ydraGvl8vqO+0C2112g0mJubI1VsMjw6jqLTsV5tcTZTRxFw2Kfjwc8/SLlcIbu6zJOPP4x/yHZZKhHtlVOhUCAUCnXKuqPRi/vE9yaBQIDp6WmsViuhUAhFUZifnx9ojwfUvahbbrmF199+M36XHQNN8muDC7YoQvDhWwOIZh3TyAHME7dy/K+Ps77eXZnMaDIxceAw6zVIJNN9rTkutuSIx+N9hXg1NC6VQVdQ/x6YBb666dg/A7de8RlpXBUSiQT1ep1cLofL5epaxBCPx0kXKigWGy6vH4DnV6pIYMZr4Lvf/EfmZueQ9Qqyss7HPvwBbr755stSV8hkMp20Xjs4XSlZpKvF0NAQMzMzmEwmxsfHMZlMnRXhIBiNRlwul9oEbFLIpS5theKy6HjHpJqmsx++h3KtxfHjx1Xtly4YDEY8wREylSZzc3N9X8Pr9WIwGEgkEpolh8auMGiAGgP+ATi/6Vge2L7cS2NP01brzmbVu/JuSgLtD51MudlJ7WXKTf4lrpZAB5spnnjiCaRsIesV7rnzVt75zndeVsXe6uoqhUIBn8/XSetda8GpTVu5vP3VbDYTi8V6rmQuxu/34zQqFNayNC6xpPuWETt+Qw3FZMV26G5OnjjJU995qvfrhcKUGgrJTK5vuXy7YKJWq5FOp0mn0xSLxUuao4ZGLwYNUAvAm1DFYRFCHAbeg7qq0rjGWF1d7ejM2e32bfeKms0mCwsLZEs19BY7jiE3LSn56ukS9Rbsdwv+7m/+EtmSyHqFsNfBfR/8N139ogYhm82STqc7Yqxer/eaSet1w2g0MjMzc0GQisfjAwcpk8mE1+vBZpAk4oPbtoMaQN572AtSYpk6hs4Z4PGvP06l3F05QqfX4w9HSZVUZZF+e192u71TMFGv1zWFCY0ryqAB6i+BA8BHN56/AAQ2jmtcQzSbTTKZDOvr6zSbTTwez5YxKysrPP3005yaXeysnpotyWOnSywXmjiNgtQzD7OWW0M2GxhFi5/8N+++LAHRtuir3W7H4/EwNDTUaX691ukWpAZN942NjRGwGcinlsmlLy3V57fquDVkRAgF7x3v4d994hOYLb3L/r3BYeqKiWSu0FEW6cXmgolSqdTZ19TQuFwGDVB/CPweUERt2C0BfwD88S7NS2OXWFtb66yeTCbTFruF2dlZXj5xitlslWzLTGB0GpPdxZdOFNWych2Mlc9y8qUXkK0WrWqB97/tjdx85PCOe2EqlUpH/29kZKSjFLFXq/V2gsFgYP/+/VitVqLRaCfdN0jhhMPhYN/0FCGbntjsWdZzl+Zw85ZxC2Yd4Bohb+rf2KwoCuHRCVJldS+qn1rE5oKJYrGoFUxoXDEGClBSyqaU8j9KKZ1AQErpkFL+BynlztQxNV4zcrkcjUaDcrm8RTEik8lwbm6BpXwTf3SKfYduxuLy89evFDifa2A1CO7xl3jyq8eRUg1Ot82M89Y3vWHHzrjtfS5FUTof3N10AK91Lg5S7cKJUqnU99xwOMzE6Ahhu8Li2ROsZdMDv65Zr/CWMdUy5cn5Cq0BUnBOtwezw026VGd5ebnveI/H0ymYaDd+a2hcLj0/BYQQbxVC/JEQYrp9TEqZEkJMbhx/6+5PUeNK0Wq1OuXlwAV2CVJKZmdnSZeaBEbG8AZCtKTkSyeLxPKqCOxHjthZeOU5GvU6rUoBn1XhIx98LwcOHNjRaqddTt5oNIhEIhiNRqanp/eMQsRu0A5SFouFaDSKwWBgcXFxIEXx6elppsejhO064nPnaDYHX6XcHDLiNivkKi3OZNQVUSaToVardT0nPDZJtgKpTI5cLtfz+oqiEAwGqVarHT+xQQKvhkYv+t2m/mfgfcC5i47PAj8K/KfdmJTG7pDP52m1WuTzeQwGwwXqBolEgtRagaow4A2qVuBPLVRYWm9iNwg+csSBx6LjXe96J2++8ximZon//ac+xG233bbjhtz2nkUoFMJisTAxMdHVHPF6wmg0doLU6OgoOp2OxcXFnsGizeTkJAHPEBalwWp88LJuRQhuH1Z/3/8Sq/L000/zB7//B3ztsa91n6fJjG94hPWmjtnZ/vVQ7WbvVCpFo9HoqGpoaOyUfgHqKPCUvKgsZ+P508DNg7yIECIqhPgnIcSrQohXhBC/snHcI4R4QghxZuOre+O4EEL8dyHE2Q0F9dsu/a1pXEw2m6XZbFIqlS5I7+VyOU6fPUuy2CQUGUNRFOZydb67VEUA752x4TQptFotZk+/wusOTfHb/+k3ePvb377jkvK1tTWy2SxutxuXy3XFTAavFUwmE/v27cNsNhONRpFSsrCwMNDezdTUFF6LjkximVq1/8qrzdGgEZMOlvJNvvLEU1SrVb797W9z5syZruf4QyPUFROp7PpAxQ/BYBApJaurqxSLRdLpwVORGhoX0y9A2YBuImLWjZ8PQgP4dSnlQVQ1ik8IIQ4C/wH4RynlPuAfN54D/Aiwb+PxC8CfD/g6Gj1ob2JLKTvpvWKxyIsvv0xsrYbN48ftC1CotfjqaTU988aomdEhNeWWWomhq5cZcds4duzYjoNTtVpleXkZi8VCMBjE5XIxPDx8Zd7kNYTFYmF6erqT7mvvx/Ur7XY4HIRDQZxGSCXiSCkprOdo9RGmNeoENwfV/86hO+7tHD/+0PGupeeKTofbH+wUTPQrITcajXg8HtbW1iiVSiwtLe3YyFFDo1+AOg/cuxFMOmz0Qd3LgH1QUsplKeX3N77PAyeAEdT04f0bw+4H3r/x/fuAz0mVZwCXEOLG+wS7gtRqNWq1GqVSCSFERwx0fn6eZL6GweFhZHwaKSWPnSlRrEtGh/TcMazjiSeeoLC+TjK+hN+mY//+/TsOTq1Wi6WlJXQ6HZFIBLPZzPj4+BV8p9cWbZsOi8XCyMgI5XKZeDzeNxBEIhGGzAq55CrxhVnmT73C8uJc39e7Y8SEQYGaI4x9ZD+grqwfffTRruc4XV4aipH0enEgk0Kfz6cVTGhcEfoFqC+irpK+J4R4UAjxO0KIB4FnAQvwN5f6gkKIcVSJpH8GglLKdonQCtD2GB8BNnclLm0c09gh7Q7/crmMxWJBCEGpVGIlmSRfF4RHVRHWV5J15nINLHrBe/ZZ+dpjj/H41x/nj//b79LMp4kMhy4rFbeyskKtViMcDmM0GpmamrosWaTrAZfL1RGYDQaD5PP5voHAbrfjdQ1hVlrkVpcZcejJpVf7rqLsRoXXj6g3J6E3fKBz/JlnnuHVV1/d9hyhKATCUdKlJvPz831XeIqiEAgEqFQq5HI5VldXL8tpWOPGRfS6UxNCWIBvAse4UMVLAM8Bb5ZSDvyXJ4Swb1zvt6WUXxZC5KSUrk0/z0op3UKIx4DflVI+tXH8H4HflFJ+76Lr/QJqCpBgMHj78ePHB53KBRQKhevGz6bbe1ldXSWTybC4uIjT6cTlcrG4uMj86hrKUBB/OEqtJfi7lJuqVDjmzCNXTvL41x9HNhs0ixnuPBDlvvvu23FRRKFQ6JgiDg0NEQqFtlWeuBF+H9uRTCY77sbr6+t4vd6e52azWc7OLyEBiw5SNYWh4Qkcrq3N15tpSPjblJtKS4dx+UWWvvMwAFablQ9/+MNbrDZq1RoGo4GlcyextwpMRoYHMopsr6DC4TA2m43R0dH+/wi7zI36t7VXab+Hu+++e9sy4J71vFLKshDiLaiq5e9GVY9YBR4D/vslBicD8CXgQSnllzcOJ4QQw1LK5Y0UXvu2MQZs1riJbBy7eH6fAj4FcOzYMXn33XcPOp0LePLJJ9npuXuNbu/l5MmTrK6uYrfbO/1GxXKZNd0Q04dvpSpMPHqqSFU2iTh13B5x8Id//U0AWvUy0yN+fvmXf3nH/U7VapXZ2VkmJiYYGxvD6/V2Te3dCL+P7ZBScv78ebLZLEtLSxSLRaLRKDbb9lu9rVYL/4svotPp8Hq9PP/qadaFhanp6W3Hb8boq/M3rxapDR/Fc5dCvVql+Oo3eeH5F/jJj/zkBWPPnj3L9PQ0AZ+H5fMnsdpNHDhwoO+HY/t3PjQ0xPDwMOPj4111H68WN+rf1l6l33vo2w0ppSxLKX9XSvlDUsr9G19/V0o5cJODUJtkPg2ckFL+0aYfPQr8zMb3PwM8sun4T29U890JrG1KBWpcIq1Wi1Kp1EmzmM1mUqkUxWoTi91JGSOfeT7PUr6JzSB454SJBx98gFKxRKtWxmoQ/NR9H9ixLl6r1SIWi6EoSkcpYi/cTe81hBBMTExgs9k6KdClpaWu5eeKonDLLbdw5MgR1WnYrKdSWOfcqy/2beSddBt4y5i6UtKPHMYyeTvWm97Mc889x4svvrjtOUNuLzZ3gOW1Gi+99BLVarXna5hMJtxuN7lcjnK5TCwW0womNC6Jq9Wu/0bgp4C3CiGe33j8KPC7wNuFEGeAt208B/g6aoHGWeAvgH93leZ5XVIqlZBSUi6XMRqN6PV6UqkUhVqLIbeXf5ytUGmoRRE/d6uD5576BufPnadVKyPL6/xv734rt912244baFdXV6lWq4TDYQwGA5OTk9elUsSVQFEUpqenO+XnQggWFxf7frDr9XomxseZcBsYokTs/Jm+e0WvHzFx7z4rPxRVA5V59DDo9Hzxi1/sGhRHxqeQZgeJ9Qrnz5/fdsxmfD4fer2elZUVrWBC45K5Ki37G3tJ3aQG7tlmvAQ+sauTuoHYXCDhcDhoNBpksllKdUlT5+JMpopBgffssxKfP69aaDTrtKoF3vq6g7zn3nsH2nPYjkKh0Ol3aqcXb4Rm3MvBYDAwPT3NqVOniEQiLCwsEI/HiUQiPRU7IpEIoVCIF154gWxljcJaDqe7+36UEIIjAbUa80y6SqJkxrPvGD9+981dqzQVRSE6uZ8zL32f5cQq4XC4p4K9TqcjEAgQj8fJZrMIIfD5fNrfgMZAaLexNwCVSoVGo0Gz2cRkMpHJZChWm+isTr6xoMre3BUxozTKPPjAA7SaTVrVElG3hZ/76Efx+/07et1Go0E8HsdkMhEMBhkaGtrxtW40rFYrY2NjWK1WgsEghUJhIFt1vV6P3+/HYRTkMoMrn986rK6ixu58JzMzMz3HGk0mvKFwx5KjX0n80NAQVquVZDLZseTQ0BgELUDdAJTL5c5+gclkIplMUqi1+H5tmEy5hc+icEfYxEMPPcTa2jqyVsHQKvPxn/vZy+pRWl5eptVqdfZTbuR+p53g8Xg6lvdut5t0Oj2Qj1QgEMBmVMjnMn3Lztvc5DNiUCBWkMTy/dUs/MMjVKSBlcz6QDJIoVCIVqul/u1tVHNqaPSja4pPCPHTg1xASvm5Kzcdjd2gUql0ApSiKKTSaV6uuFlo6jHpBD92k416VXXZla0WrUaF+979Du64444d7xVls1kKhQLBYLDTjHs9i8DuFuFwmHK5jJSSSqVCPB7HaDRuKQXfjNlsxj3kJFHMkk6u4A/1byE06VWtvmdiVf7+XJmfudmOIgSVcmXbFZJOp2d0eoa5Uy9jnF/smEx2vf5GwUQmk8HlchGLxXC5XDd8D5xGb3p9YvwlF/Y+dUMLUHuYer1Os9mkVquhKArpdJp8pcUC6p7SO6csuC06wMqv/PIv86W/fpBycol7fvjuHfdYVKtVEokENpsNj8dDIBDYYu2hMRjtyr4TJ04QiUSYnZ1laWmJiYmJnh/uoVCIVHadldgclWKRyOS+vorzb4iaeTVZI1Fs8vxKDXP2HF/46y9w++23s2/fvi3jbQ4nwcg4ifgcc3Nz+Hy+nq/h8/lYX19nZWUFi8VCPB6/5h2TNXaXXgHqWwwWoDT2MO3S8mq1islkYmVlhbmKkfWmAatBMOP916bber3Gwf3TjL/uwI7dbKWULC8vq6Z34XDH30lj5+h0OqanpztBan5+vu+He1vb0HzuHIu5FJmkE28g1PN1jDrBWycsPHyqxDfP51n80mdAtnjqO0/xpje9CZd7q4KINzhMcjlGLl9ibW2tp8qITqcjGAwSi8XIZlXTRa/Xu8U0U0OjTdf8jZTybinlD/d7XM3Jalw6bZ+harVKo9Egly9yvqFWdh3yG9Ep/3rHuxpfwmUShIdDO66ySqfTlMtlQqEQBoOBiYkJraT8CtBOk7YFdguFQl918eHhYQ7MzOC36kgszdMcQCl9xmvAb1Woosd/8C4A6rU6x48f3/Z2VQiBJxBkrdocqITc6XRis9lYXV3VLDk0+jLwJ4cQwiaEuFMI8R4hxHvbj92cnMbls7mCr1Qqka9J4i013RYxFPjWt76FbEmqlTLrmSQus27HTbSVSoVUKoXT6cTpdBIOh7W74yuI2+3uFE0MDQ11Cg564ff7CXhd2HRNYvPn+vZGCSF4XVhVPHcdeQti4wbm9OnTfPe73932HI8/SKEGyWSqb/MubLXkGMTGQ+PGZKAAtSF3dB74DvAw8JVND409TLlc7jRdVqtVzlds1KVC0Kbj23/7CA9/5WH+7M//jDOvvtxZPfXagO9GWy1Cr9cTCoWw2+0Eg8H+J2pcEuFwGIfDQSik/p5isRj1er3nOVNTU/htBurraWZPvdJ3JXXQb8RmEKw19Nz69g92jj/61UdJp7ZW3xmMJuwuD7lqc6CKPpPJdIElR9tVWUPjYgZdQf0u4AfKqA23a0ATmN+leWlcIdoVfG0lidm6unryk+PVV1T16rMnXyWbiOGxGXa8ekomk9RqtU5qb3x8fEc28Bq9EUIwOTmJyWTq7O3185Cy2+3cesvNjHks6Gt54vO9FSD0iuCuiHqTkhi6CXdULZCoVWscP34c2dqa6xseHSdbhaXlxEArorYlR1thIhbbIrWpoTFwgDoKfA1Vdkii2mI8B/zxLs1L4wrQaDRoNBpUq1Wq1SqFOiSkalT4ypOq/49sNdk3HuHo5DD7NyR2LpVisUgmk7lALWKznbzGlUWv1zM1NYXJZCIcDlOpVPraczidTm655RYCDiPFXJL1bKbn+NuHjRzyG6i3wP76H0NnUlO1586d46mnntoy3mgyExwZY7XY5KVXXuH555/vmX5UFIVQKES1WiWTyajakBuKJxoabQYNUAowB7QFYoeAc8B/3oU5aVwh2qm9RqNBrVbjTMVOCwWPrkpi/hwAepq87Y3HiAwHCYV6V3ltR7PZZHl5GYPBQCAQYGhoaMeySBqDY7PZiEQiOBwOvF4v2WyWtbW1nudYLBYmx8cJWPUszZ2lUu6u9yyE4EemrQzbdVQxMvGuj3Z+9thjj5Fc3apS4Q0OY/UEmV9rcnY5w8mTJ3uqTNjtdhwOR0dhYn5+vq8qhcaNxaABagXwoQYpAbwA3AdoXXZ7mPaGda1Wo1KpcLaqrp7Wz30fANlscNO+CSJ+145tNNrVWCMjIxgMhh2Xp2tcOoFAALfbjd/vx2KxsLy83LdIYWRkhGG/G5+xxfkTL1Eudl/l6BXB+2as6EWLdYOX0G2qbGa9Xueh4w9tSSsKIRgZn+LALXdQkoaBHHjb+5SJRIJyuTyQY6/GjcOgAerLgAHVYXcZGEbtofrzXZqXxhWgvYKq1+sUS2VWm2qaZuXlZwBQZJ03HTtKdGRkRym5QqFALpfD4/FgsVgYHR3dsZmhxs4YGxvDYrEQiURQFKXvfpQQgkOHDjE27MNnlsyfPdlTDsll1nHMuRHEJt+AwRXCbDZx5+vvRBHbf3zo9HqCI6MDOfAaDAZ8Ph/5fJ5CoUA8Hu+qpK5x4zFQgJJS/rqU8oNSyixwBPgA8AYp5X/Z1dlpXBa1Wq2jIrFaM9BAh1Ir0qrkkc06+8ajjAbcO+rmbzQaLC8vYzab8fv9eDwePJ7eTq4aVx6dTsfk5CRGo5GRkRFqtRorKyt9zzl48CAhtwOTrLES613rFDHXuDlopIUg8vaf5Vd/4ze54/V3dPcnANy+ANJgJr1eIpFI9Ly+1+vFaDSysrJCo9FgaWmp53iNG4dBy8zPCyH+E4CUMiOlfAQ4LIR4pM+pGq8htVqNer1OuVxmRarVe+UVde+pVauoq6dodEernpWVFZrNJsPDwxiNRk2y5jWkvXq12Wz4/X7W1tbI5XI9z1EUhZmZGfw2PdnEMsVCbxHat01Y8FkUitLIiUL/1bYQgkB4lEylxcLCQt9V3fDwMPV6nVQqNdB+msaNwaApvnHgYq/mW1Ft4DX2KG31iHK5TKKl7j9VkwvIRg2/y84RUjE8AAAgAElEQVSBiciOZIhyuRz5fB6fz4fZbGZsbEwTgn2N8Xq9eL1efD4fVquVlZWVjopIN+x2O+OjUfw2HbG53k28Bp3gXdNqivjZeJW1yqaxXeoahjxeMJjJFPpXGVqtVoaGhshkMlSr1b5BTePGoGeAEkJ8QwjxjY2nH2w/F0I8Cfw0kN/tCWrsnFqtRq1Wo1Qqk2zZAGikF2jVq9wyM040Gr3kwFKv10kkElgsFnw+H36/v6dhncbVY3R0tKN9qNPpiMVifT/kR0dH8TutKPUy6cRyz7ERp56DPgONFnxjTtV4XFpc4g//6A+3lTlSV1FRMuUmp06d5vTp0z0bcgOBAIqisLy8TK1WY3m593w0rn/6raDu3nhIILLp+ZsBG/DVXZuZxmXRbDZpNpvU63XSFUlZGjDp4Nc+/lFef+wW7rr95h2Vlbc/iMLhMCaTiUgkcqWnrrFDFEVhamoKo9FIOBweeD9q3759BKw6kvGFvv1Rd49bMChwKl3nkadP8MlPfpLYUozPf/7z2xZbDHl8WN0BZtcanJ6Pc/bs2a7X1uv1BAIByuUyuVyuU9mncePSL0B9FPgY6nboExvPP4q6evrhja8ae5B2JVStVmOloaZmIg4dsl7hTXfcxuTk5CV78WQyGUqlEsFgsGNAqAnB7i3MZnNnP8rn8w20H+V2u5kYizJsU1g8d4r8WrbrWKdJ4W2TqpDwGRnCPHoEYbQQj8X5+yee2DJeCEFkYprJgzeTKrVYSaz2TD26XC4sFgurq6ud3iiNG5ee+R0p5f0AQggJvCKl/N5VmZXGZdPuhykUCmRR03shu55sOsmIVbnk1VNbrcDhcOByuTp6exp7D6/XSz6vZt9LpVLHf6lXK8Hk5CStVgu5EGPh7EnG9x/C5tjew+towMhcrsGJVB37sfdhrVXIPvlZ/uGJf+Dw4cPbrqotVhtOr59cMcXCwgL79+/vOpfh4WFmZ2dZXV1Fr9eTTCZ7miFqXL90vf0VQvxfQoh3bDwdA35049gFj6szTY1Lpb2CWl9fZx11BWWlgl42cDlsl2QguNnjKRQKYbVaCYfDuzJvjSvD5v0oRVEG2o+amppifCRE0Kowf+ZVal2afoUQ/Oi0lbvHzARtCorRjOO2e2m1Wnz+wc933WcKhCPkqpLl5ZWeqTuTyYTX62VtbY1isTiQIK7G9Umv/MxvAe/a9P3/fdGjfUxjD1Kr1Wi1WuoKqmkEIL88i1XHJUsRJZNJKpUK4XC44/GkCcHubRRF6fRHhcPhjstxL4QQ7N+/n2jQi0MvSS5370cy6AR3Rsz8xGE7Zp3E6BvFsu9OVlYS/P3f/f2255jMFpweP+lys+deFKirQIPBwPLyMvV6ncXFxf5vWuO6o1eAuh94duP7z23zuB/N7n3PUq1W1R6oSpWyUPcMHn7gf/GNv/86brd74OsUi0XS6XRHCDYSiexIUFbj6mOxWIhGo9jtdrxeL7lcjvX13v1ObYt5l1khl1qlXustnWTWK7x9Sk0hO25+B553fYInn3uZhfntjQhD0THydUEimSGZ3Krn10ZRlC29Uf320jSuP7ruQUkpP7rp+5+9KrPRuGLU6/WNCj5A0dEsrdGqFJiZug2HwzHQNdpCsEajkUAggNPpJBAI7O7ENa4oPp+P9fV1pJSUSqWO+ofRaOx6js1mIxTwky2vkFzpb4Nx0GegWjfzxMkUersH5+s+wOcfOs6v/9qvYjBe2ARuMBgJRsZIxGY5ceoUBoOhq028zWbr9EY5nU4WFxdxOByXXNyjce1yKY669woh/loI8R0hxHEhxL27OTGNy6Ner9NoNEhW1VRcYz1Jq1rk2LFjA1feLS8vd4Rg21V7GtceY2Njnf0ogFgs1lc1fHR0FLdFR3Y10XcVJYTgtrCZjx610syn0Tv9FAOH+PrjX992vCcQwjLkYylX44UXX+q5qmv3Rq2srFCr1Qaylde4fhhU6ujXgEeBHwfuQlUyf1QI8eu7ODeNy6Ber1MqlYgX1A+ixtoqbpt5YLXx7dQiNCHYa5PNen2D+kfZ7XbCoSAuE6QHWEUBBHwejjnXkbKFbeaNrDmntg2EQggik/swu/wki71LyfV6PcFgkHK5TCaT6djEa9wYDLqC+jVUB91PAh8H/mTj+a/u0rw0LoNGo4GUUjUSbKipnMZagnDAO9D+U7vB02q14vP58Pl8XdMwGtcGVqu14x/ldrvJZDI9DQUBJiYm8NoMVPJrxObOUS71DwzvvOtWgoWzgCRujPCthe17noQQDEfHKTQEyXTvuQwNDWG32zu9UXNzc5pv1A3CoAHKBDwkpfw1KeWnpJS/ChxHteDQ2GO0S3ILhQJFndqr1MjGmRiL9i1wkFISj8cRQnTUIjQh2OuDtqFkMBjEbDYTj8d7lm+bTCYmJybwGuqQX+X8qy9QzPcuskDAx951Bx84oBZOPBurUqhtX96uNxhw+YLkKq2+Cubtvr3l5WUqlYomg3SDMGiA+mPgFiGEG0AI4QFuAX5/tyamsXPaHzqlUommRbXAqKcWezZHtkmlUpTL5Y5K+cTEhKYWcR0xPj6OyWRiZGQEKWXf/aiRkRFm9k0xMxoiYFVYPH+mp39Umxmvkf0eA00J/xLvvoflD4VZr0kSfRQm2o7NxWKRtbU1VlZ691JpXB8M+snz88AhYEUIsYRqWngT8IkNK47zQohzuzVJjUuj3aS7ml1HWJzIRp16bplDhw71PK9cLpNKpRgaGsLpdBIOh7HZbFdjyhpXCb1ez8TEBEajkVAo1Pmd98JmszEzM0PAZcckqyRi25eQX8xdEVW54vvLFT59/wPbpvGMJjMOt5dctdl3FeV2u7FYLCQSCc0i/gZh0AA1tjHWAIQ3vupQbTg2PzT2AO0V1Km42jfSyCdx2S0de+3taLVaxGIxDAYDwWAQu93ec7zGtYvdbiccDjM0NMTQ0BCpVKpv4UHbP8pn1ZFJrtDsoUreZtihx6OUqbcEsyUzf/OFL2xrzREYjpItt4j1saxv+0a1Wi1WVlYoFvtbymtc2wwaoH54gMdbd2OCGpdOu8R8Iaf+Z2+srRIJ+Xtq57U3oMPhcCe1p6lFXL+EQiEcDgehUAij0Ug8Hu9phQHgcDjwez1YdZJMqrcqRZv9VjUNZ5m6nZdeeoVnn312yxiz1Yrd7SVXbjA3N9fzeiaTqWMRn8/nicfjPYOaxrXNoJbv39z8AM4Cz29zXGMP0C4x17lV0U67qHLopgNdCyQKhQLZbBaPx4PVaiUajfZs5NS49mkrRrSt4pvN5kA9RsPDw7jMOtKJ5YHSa285OoGhUUJnc2Mc3sdXvvIV0qn0lnHB8CjZCizEVvqm+rxeLyaTiZWVlU5Vn8b1yaB9UL8lhPi6UPl9YAFYFUJ8cHenp7ET6vU6hUIB6VBVH27bF+Gee+7ZdkXUbDZZWVnpqEW4XC683ovNkzWuR9q6imazmVAoRLFY7Lsf5fV6GbKZURo11rNbA83FCCF4w4TaomCdvoNqtap6R10kXGu2WhmZmCZeaHD67Dmy2e6WH+0K02azSSKRoFAoaKm+65RBU3wfRpVFMgK/BLRd0P7LICcLIT4jhFgVQry86dhvCSFiQojnNx4/uuln/1EIcVYIcUoI8c4B56ixQXsFVRCqirlHX+ua3ksmk53UnsFgYHR09GpOVeM1xul0EgqFcLlcOBwOUqkUpVKp63ghBJFIBN+GTXw/lQmAW8NmdEJiDE5iDM8wOzvLP33jn7aMc3n9eIejJIpNTp061TPlaDabO4rnhUKBWCympfquQwYNUKPAOdTKPSPwPuDzwNSA5/8l/6qMvpk/llLesvH4OoAQ4iBqQDy0cc6fCSE08a1LoF6vUyyWKG6IxPoN9W0DVKVSIZvNdqqjotGophZxAxIOh7Hb7QwPD6PX6/vuR4XDYcJ+D0OGFnNnTrKezfRM95n1Cj88rt4sOW9/D4rZzuOPP75tKi8QjiKNNpLrZc6ePdvzuj6f74JUn2ZueP0xaICqABPAO1EVJF7Z+Nq/IQKQUn4L6O0l/a+8DzgupaxKKWdR97vuGPDcG55ms4mUkpV8jZbQYaSOTS+xWCxbxq6srKDX6/H7/TidTjwez2swY43XmvZ+lMlkIhKJ0Gg0ejbCCiGYmZkh6DTjkGVWzp8kNte7y+T2YSPjQzoUkxXHrT9Kq9XiwQcepF67sFFYCEF0ch/pCszGErzwwgudtont5hEOh2k0GqyurpLP57VU33XGoAHqWeAdwO8A/yylLAMzqKuqy+EXhRAvbqQA2xo8I8Bm85eljWMaA9C+833m1Vn1+doqr778Alar9YJxuVyOcrlMIBBAr9drqb0bnLYYsNlsJhAIUCgUSKe77zEZjUZuu+02bj4wSWTIwFoqQaVPavDefTYMisQ0cgDj8H4SiQSPfe2xLWPNFitj+w+SrCjMr2Y5ffp01+uazWY8Hg+5XE5L9V2HiEEqcYQQY8Bvo+5D/RZwHvgz4LtSys8M9EJCjAOPSSkPbzwPAinUzoj/BxiWUn5MCPE/gGeklA9sjPs08LiU8ovbXPMXgF8ACAaDtx8/fnyQqWyhUChcN/bliUSCXC7HJ7/+POWb3k3x1HeIzD3Oxz/+8c6YtpyRTqcjFArh9Xov2cRwN7mefh/X2ntJJpNkMqpXU7lcJhgM0mq1tl2Bt4nFYswnsjRtXkLRiZ7XP1My80LeTrOYI/PE/+TwTfv5oTe9adsCnka9xuKZE/j1VWb2T2+5yWrTdnxutVqd5vJoNLrtNa+130cvrof30n4Pd99997Y9LV39oDYjpZwHPgIghNBLKRvAv72ciUkpO40UQoi/ANq3UjFgs/hbZOPYdtf4FPApgGPHjsm77757R3N58skn2em5e41HHnmEY8eO0fgntdu/kV3myJEjHDt2rDMmk8lgt9uJRqO4XC6OHDmyp+SMrqffx7X2XqSUnDp1ivX1dWZn1VV4JpO54O/nYo4cOcIzzz7LbKaG3+tmyN29CnRSSlZeKJDAxcEP/io/9boAeqV7v92Q3UotE8fj8XD48OGu4yqVCnNzcx0FlEgksm2j+bX2++jF9fBe+r2HQcvMhRDiNzdkjqpCiKWN5zvu5BRCDG96+gGgXeH3KPBhIYRJCDEB7ONfnX01+tBsNmk0GlQMQwDUs/EL0netVot0Oo3VasVutxMKhfZUcNJ4bbm4P6rRaPRM9YHaPDsWjRJ26ImdO8lqvHsfkyIE75+xYjUIkg0Tj5wqUW92z+L4QyMUGoJEMk0s1t32Y3NVXz6fJxaL9dT207g2GPST6VeA/xdV5khsfP0d4N8PcrIQ4iHgaWBmI7j9HPD7QoiXhBAvoipR/CqAlPIV4AvAq8DfAp+QUg5UjKGh7kEVi0WkVd3Sq2fjTE5Odn6+vr5Oo9HA5/NhMBjw+/2v1VQ19igmk4nx8XEsFgt+v59SqUQm07vGaXx8nJv2TRJ16knF51nPdh/vtui476ANkw7OZOo8+FKhp+J5cGSMWL7BidNnezbltr3LlpeXqdfrzM7Oalp91ziDBqhfAJLA+4EDG19TqCKyfZFS/oSUclhKaZBSRqSUn5ZS/pSU8oiU8qiU8r1SyuVN439bSjklpZyRUj5+ie/phqbRaLC4FEPnUPeUdMU04XC48/NsNovJZMJmsxEMBrXVk8a2uFwuAoEAXq8Xq9XK6upqX/XwaDTK/ukpQnY9S7NnevZIhex6PnLUgcussFJs8ndn8tx///3blp77QmFC4/tYyjc5NzdPLpfb9poXa/W1Le41rl0upQ/qUSnlo1LK01LKR1FTcVrp1x6j2WxycnYJoTfSqhTw2M2dDe5SqUSlUsHj8aAoiqYYodGTSCSC1WrF6/Wi1+uJxWJ99fpGRkY6PVKL58/0HOu36viJw3YEktPZJi+dnuevPvdX21bhuX0B/OEoq32aeM1mM36/n3w+Ty6X64jKalybDBqgFoEfEUL8kBDCJ4T4IdQm2t6iWRpXnUajwfnEmvp9IYvX5egEqGw2i6IonZ4nvX6gGhmNGxQhBJOTkxgMhs5+VL8VSbtHym83Ui+uk0317ksaMilMOSVCKFj3vZ5kMslXvvyVbcf6QiNIg5XkerlnU67H4+nYctRqNWZnZ7dIK2lcGwwaoD6Huu/0TSCx8TW8cVxjD9FsNlleV+9Am4U0gUAAnU5Hq9Uin88zNDSEoija3pPGQJhMJkKhEBaLZaD+KFB7pKampgjYdCzPn6fRw7UX4M2TakGPZeJWFJONZ599lh/84AdbximKQmRyH6lyi8WlWNeVkRCCkRG1dbKtdt5PgFZjbzJogPoD4L8BJdQiiTLwhxvHNfYIUkqazSaZqlpc2VhPEgiogrGFQgEpJQ6HA7PZ3LWnREPjYtreYB6PB4fDQTKZ7KnXB6qdR8jnxqZvkVzpXn0HELDpmHLrEXojzjs+AAj+5gtf2DYQWqw2XL4g6VKDs2fPdk31tX3NSqUS6XSaZDLJ2trawO9ZY28wqN1GQ0r5f0gpHUBQSmnfeN771kjjqtI2KiyiOpk21lY7BRLr6+vo9XpsNhtut7vrNTQ0tmNkZASbzdbR6xtkP2piYgKPRUdmdZl6fXu5ojbvmrJi0YMxOInt4JupVKo88MAD29rLhyJjFJo6lpJZnn322a4K7G0B3GQy2emT6jdnjb1FzwAlhHjvxQ/grouea+wR2gHKO7ofgMOTYfbv30+r1aJQKOBwOAC0AKVxybT3o9p6fc1mk1gs1rOM2+FwEPB5ceglqeXeqyiHSeE9+22AxHbwLdgO3s383DyPfe1rW8bq9HrG9x9kHQuz6QpnzpzpuscUCoXQ6XTEYjFqtRqJxGBGixp7g34rqIeBr/R4fHlXZ6dxSTQaDRqNBjW9Kn/yugPjjIyMbEnv9ZKt0dDoRttpue0fVSqV+vpHjY+P47boyKyuUKv2bpyddBu4d58NpMR28M1YJo/x5D89ycsvvbxlrNXuYPrgzUiDmfVyrWvpuV6vZ3h4mFqtxurqquYddY3RL0AtbHoUUPefNh9b7H6qxtWmXq9Tq9U7KT6XvoHZbKZUKqEoClarVVs9aVwWTqdTddV1uXC5XKRSKQqFQtfxdrudcCiIywTxhdm+1z8SMPLufer+qO3QWxB6Iw899FDXRmG3z0++2uwZdOx2Ox6Ph2w2S7lcZmlpqW9Pl8beoGeAklKOSyknpJQTwGfVQ+rzTcc19gj1ep18rUVT6NDLBjZ9C5PJRLFYxGq1IoTopPk0NHbK8PAwTqeTYDCI2WzupM+6MTExgc9moLKeIb/W3Sm3zaGAkWGbQDHZsO6/i5kDM1gt2xf1uLx+CjVJMpXqub8UCAQwm82k02nq9Trnz5/XSs+vAS5FRkDTDNnjNBoNVovqprKZKgadgk6no1ardQKUzWZ7jWepca3T1uszm82dcu5YLNb1A78tneSz6IjNnd+28OHi698zqf6dOm56E+/98Z/EbDFvO9ZoMmO2OShU+ntYhcNhWq0W8XicSqXC4qKWANrraDo31xH1ep3vnTgPQDY+x9NPP90pB7bZbNjtdk3aSOOKoNfrO0UTIyMjVCoVVlZWuo4Ph8ME3A5Mssrqcv+epIhTzwGvgZZQeOR0iWarh7Pu8AirpSZnzp0nmUx2HWcymfB4PBSLRVKpFKlUimy2/4pO47WjXxXfl9sP4N0XHxNCfOmqzFJjIOr1Omt19VdazSYQQnT2n8xms5be07iitH2X7HY7Pp+PtbW1rh/4iqKwb98+fFYd6ZVYT3PDNu+atuA0CZYLTb698K8FFhenE4fcXnzhUeL5Ji++8irf//73u/Y82e12HA4HqVSKcllVpNAMDvcu/W6n37/pMYVaJPH+ix4ae4R6vU5ZqKmQxnqK4eFhisViJ62nBSiNK43f78fr9eL3+7HZbCQSia4FCE6nk+hIGK9ZEJvvb8Zt1iu8d7/6t/tsvMrKepUv/s0X+dM//dNOS0WbQDiKKxRhKS85s5zjxIkTNLukEjf3crWlkDTV871JPzG2/3pVZqFxRWg0GtQNdgyoKhKh0EHq9TputxtFUbT9J41dYXR0lFKpxMjICLOzsywtLTExMbGt1uPExASpVIr1VJ5MMoHHv9VUcDMRp55bgkaeT9T43HfOsfLd7wLw5S9/mQ996EMXjA2OjOIfjnDu1RfJFCosLy8TiUS2XFOn0zEyMsL8/DzLy8udPqntxmq8tvQMUFJKLUBdI7RaLZrNZscHqrme6Ni4WyyWTpGEhsaVRlEUpqamOHHiBJFIhLm5OZaWlhgbG9vyN9feuyqUTxJfOI+i6HB5fT2v/5YxMyfTdSrOMObxW6nM/YB/fuafGR0d5a677toyl2BkjPi5V5mfnycUCm0bKNteV6urq50Sdrvdjsvlusx/DY0ribZjfp1Qr9fJ5/ModtVCQxbSOJ1OAE17T2PXMZlMTE5OYjabGR4eplwud1VtCAaDTI5FCNsU4rOnWF6Y7VnZZzEo3DOhNpc7b78Xg091+fnyl77M/NxWVXOny43B6iRTqves1PN6vTgcjo7X1dzcnLYftcfQAtR1QqPRYH4xhs7mQrZaOJQaUkqMRmOnSVdDYzdxOp2MjIwwNDTUaYztpvAwNTXFgX2TjA4ZqGSWOfvqCz37ko4EjBwbNoJQcL/xQwiDmWazyV/+5WfJ5/Nbxg9Hx0mXmiwsLvW0fr94P0rrj9pbaAHqOqFer3M2lkQIhVZ5DafdSrPZxGxWiya0AKVxNQiFQh03XqvVysrKSteiiWg0yrHbbmXcZ0dpVFjL9JZNeuuEhYhTBwYLQze/HYC1tXXuv//+LSswq92B0+Pvq3re3o9qNBrE43FKpZJmzbGH0ALUdUK9XmduVS2tbRayeNzuToASQnQClYbGbjM+Po7FYmFkZAS9Xs/S0lLXAOFwOBgdHcVlUkglepshKkLwjkkrAjCO34J+SLWSOX/uPI88+uiW8aHoGOt1mF9O8b3vfa/ram6z11UqlSKZTPb1vNK4OgwUoIQQtwohflYI8R+EED8nhNAkjvYY9Xq9Y1TYKGQ6m70mkwmLxaIVSGhcNXQ6HdPT0xcony8tLXUt5fb7/TgtBhrlAqXC1nTdZgI2HbcNGwFB+J6fRTGplanf/ta3ee57z10w1mA0MXngCGtYmE2XePnll7uu5tpeV6lUimKxyMLCgqbXtwfo16jrFkJ8Dfge8Gngt4FPAWeEEH9yFeanMSD1ep1MRc2dNwvpjiisViCh8VqwuWgiHA5TLpe7Kk3odDqGh4cZMiusxvvLD7151ELApqOimAm+4+cRelUc+fG/fZxm48JUn8VmZ/rgUQwOD/F1teepm27g8PAwBoOhsx917ty5rr1UGleHfiuoTwI/AuSAdmfcN4EG8ItCiF/fxblpXAL1ep3Jw8cAuHnfGEePHsVgMKDX67UApfGa4HQ6iUQiOJ1OfD4fuVyuqyp5OBzGazVQy+dI9vGOMukFHz5kw2dRaJqc+G97G2NjY/zSL/4SOr1uy3ghBNHJ/bSMdnKVFrOz26uq63Q6IpEIrVaLpSW1uKLbWI2rQ78A9W7gCcAHHENVkvg0cAuwBvzCrs5OY2AajQbZippCCQ+pskYmk3pnqQUojdeKYDDYUZpwOBwkEolt7TnMZjMHDhwg5NCxGpunWFjveV2rQeFd0+rftWH8dj728X/HkGuo63hFUYhM7qPQ0hNbXmF9ffvrm0ymzoovkUiwtrZGPB6/hHescSXpF6B0QEqqyeN2U8NNUsqTwKPA2G5OTmNw6vU6aw311zmkVzekjUYjgFYgofGaMjo6is1mIxwOYzKZiMVi2/Yb+Xw+Jkaj+K0KsblzfeWHIk4940N66i14drlBq894k9mC0xsgVWpy6tSpbcvTQV35eb3eTpn88vJy1wILjd2lX4D6AfAhIcQ/Ak+jWm6017wGoPeOpsZVo16vk2+oHfN2UcNgMGAymTAYDOh0W9MeGhpXi7bShNlsJhqNIoRgcXFx28q+sbEx/E4rSr1MaqX/yuWNo+rN17/Eq/yPf1nnVFrdXzp18iTf/ta3t4x3+4LUdWZmk3m+9/0fdHUEbmsLtsvkZ2dntaKJ14B+Aer/BMrADwOTwBngQSGEAbgdeHJXZ6cxEI1Gg9VMjip6aDUxySoGgwGj0aitnjT2BAaDgampKUwmE9FolEajQSwW27JKalcA+q06krE5zp98mfVspmvzbNSp552TFjwWhVJd8uipEl/71nN86i/+gocf/govv3yhXbyi0zF98GaMriDxfINz585te+22f1S7TL5dNNHLFFHjytPPUfdp4Cjwi8C/BV4npaxIKetSygNSyh+/GpPU6E29Xuc731f/IzaKOR78q/s7KygtQGnsFaxWKxMTE1gsFoaHhymVStuaDHo8HmamJ5nymLA2CyRmT3Lyhe913Ze6ddjEz9/q4LaQkaaEl2QEYbAiJTz4wINb9pAUnY7w2CQYzGTy5a5Gh3q9/oIy+XbRhKZ8fvXo2wclpZyVUv6ZlPIzUkotpbcHaTQazG806bZKa9htVkwmEzqdTgtQGnsKl8vVkUNqe0htl2aLRqO8/vWv55YDU+wPOQmYJXOnXulqGS+E4G2TFsaG9KA34Tl6NwDVapVP/69Pb9lvEkIQjIyRLre6phuBC8rkl5eXWV9f15QmriI7VpIQQnxWCKGtd/cA9XqdlTU1P94s5hgaGtIKJDT2LKFQqFPZ53Q6SSaT21bVGQwGotEot99+O5OREMM2hcWzp2g2t//YUYTgLWPq37tp/DbMdlUsOZvN8tnPfnaLh9SQ24vOYiOxXubkyZNdV0ZOpxO/38/a2hrpdJrV1dWezr0aV47LlTrS5An2APV6nXRJ/U/bLGYYGhrqBCYtQGnsRcbGxnA4HITDYSwWS0cHbzuEEOzfv5+gZ+m/3GYAACAASURBVAiz0iKT3F4lHSDs0DM2pKcuBa97/8cQivoRNTc7x/GHjiMvso4fnZohVxXEEmnm57cqo7fx+Xwd5fNCocDi4mLXKkCNK0c/JYlmtwfw01dpjhp9UCv41Eq9ZjGLy+XqqJi3V1IaGnsJIQSTk5NYLBYikcgFxQjdxkciEdwWHamVeE/F8Tsjav/fqYqTg+//REdp4gc/+AH/P3t3Hh35dRX6/nt+Nc+DqqSSSvOsHtzddrs9xEMndhxnhrxAiAnkEnJD7oPLfSzWW7C4A3C5PGDxSAIhixc7kIGb4BiDM2ESYicmkMR2bHe3e1RrnlUaalDN43l/lFTdakmt7nZ3q1R9PmvVUquGX50jqbV1zm//9v7xiz9e91yjyUxrTz9zySKj4xOXTSdvamrCbDYzMzNDOp1mZGTkspXSlTduuxWU2OamVIF8Pk+a8n/CQnyJuro6lcGnVD29Xk93dzdms5nW1nKPp8nJyS3PB9XV1eF12tCX8oQXNi+bBNDu0nO0zYxOwKLmpe3RX648dvzY8Q3p53anm7pAkFCyfH3UVu+vaRotLS1omsb09DTZbPayldKVN267ABUB/gU4tMntmzd2aMqVyuVyFI12AIrxMHV1dSqDT9kVTCZTJUitpZ9PT09vmfrd2tpKvU3HwvQ40eXNzwMJIbi72cwvHXRg1gtSZh9tD38Ia9+96Jz1fO3rX9uQmFHf1II02gjFUpw/f37L8er1+nXjTKfTDA8Pqx5SN8h2AeoloENKeeLSG+XgpVZRVWBpaQlhKxeHLSXLhWINBoMKUMquYLPZKunnwWCQTCaz6TVSAPX19fR0thO065gdO8/ouVOkU8lNj+uz6nh3b7kcUtrdiX3/w7jve4wPPPYhfL71beY1TaO1q5dIFqbnFy+bqWc2mwkGg6TTaWZnZ0kmk4yPj1/7F0DZ0nYB6qPAVtc6/SZwRW03hBB/I4RYEEKcuug+rxDiu0KIodWPntX7hRDiL4QQw0KI14UQt1/Je9zKpqdn0Nu9ABjziUrtvbVafIpS7dxuN62trTgcDhoaGkgkEltWP29ra6O/t4tOrwlrIcHYuZNk0psnWHR5DLy928IenwG3CXRWJ2lf/6bPNZktBDt6mE8UGBwa4bXXXiMWi2363LVxxuNxQqEQkUhEpZ/fANtdqDsrpXx9i8eWpZRbp72s9wXg0Uvu+23geSllD/D86udQrp7es3r7GPBXV/get6Riscjw1CxCb6SUS2PRSez28nafClDKbuL3+wkEAng8nkr1863SuZubm7n7rrvoDPqpM8H4+TMszs1supo60GDiPX023t1b/n/x8kyW10NZCqWNKzSX14evuZ2phGRoLsrp06c3pKev8Xq9eDwewuEw4XCYUCjEwsLCG/gKKJe6qjRzIcR/F0KMXO2bSCl/AFxaZ/+9wBdX//1F4Kcuuv9LsuxFwC2EaLza97xV5HK5ShXzUiqG2WRUKyhl1woGg5VrpNxuN0tLS1u26DAYDPT39xP0ufAaCqQXJhg9c4JkfPOKE0GnnnZzhqKEZ4fTPPFanNlwkqeeeopM+kI2nj8QZODQEaTZwWIiy+jo6JbjbWhoqFRpX1lZYWpqikhk84uJlat3tddBeYH26/TeDVLKtRoj80DD6r+DwMVdy6ZX71M2kc/naewaAMBnN3HXkSOVKhJ6vX6HR6coV6+trQ2Xy0UgEKj88t9qq02n07F//34ODvTQ39pAg1VjcmSQ4haZdbc7E7y924LPohHLlvjS8Qg/OXmeJz73BPnchZWSpmk0d3QTycD03PyWQXKtZt/F13KNjY2pa6SuE3E1daWEEJ8Efl1KedXlsYUQ7cC3pJT7Vj+PSindFz0ekVJ6hBDfAv5YSvnvq/c/D/yWlPKVTY75MVZ7UjU0NNzx5JNPXu2wAEgkEpVtsd0mFovx9Guz/Fu2FWd8nD3L/8Y999yD2+2mrW13dkPZzd+PS9XCXHZiDmtNA1OpFAsLC2SzWfx+PxaL5bKvGR0dZT6WoWhxE2jtRNPW/w2ey+YwmowUSvDdOQNJvYtCNET4+SdobWnm7e94+7rq/5HFEInFGerNkt7eni2vKywWi4RCIUqlEg0NDZWiuDcyUamWfraOHj26acLd1f6JPQL84I0PC4CQEKJRSjm3uoW3tnk7A7Rc9Lzm1fs2kFI+TrkFPYcPH5ZHjx69poG88MILXOtrd9rc3Bz/NP4izIHHrGGxWDhy5AgNDQ10dnbu9PCuyW7+flyqFuayU3MoFAoMDg6STCaZnJwkm83S2tp62Qact912G8eOHWMmmqZQyNDetwed7sKvueHhYbq7uwHo7JJ85scL4G7A2n8fk2d/wEsvvcSHPvShSmCTXV1MDJ1FS0cxmUwcOHBgy52JfD5fyeZrb2/HYrHQ19d3w4LUrfCzdVVbfFLKv5RSvvmNDmrVN4APr/77w8DXL7r/F1ez+e4GYhdtBSqXyOfzLKeLAJhlBoPBoFLMlZqg1+vp7e3FYrHQ0tKCwWBgamrqstUbzGYzBw8epNljRcslmJ3YumW7USd43/5y9qtt4H6MDZ0cP3acp59+utz5jgvt4lOYmF2Oc/bs2S2veVqrHVgqlZicnCSTyTA0NLRldQxle1cUoIQQPyuE+FshxHdWP15Vmw0hxN9RbnjYJ4SYFkL8MvDHwFuFEEPAw6ufAzwLjALDwBPA/3k173WryWazjMwuA5CLLmA0GhFCqAQJpSYYDIZKkGptbUWn01V++W/FYrGwf/9+Ak4jycjClhf0ArS5DNzRaERoOlxvegxzxyFe/PGLfPOb36wEKZ1eT0ffHsI5wXRomdOnT2/aERioXHCcz+eZmpoinU4zNDSkqk1co+1q8QkhxNPA3wGPAW9d/fikEOLvr/RNpJQflFI2SikNUspmKeVfr6apPySl7JFSPiylDK8+V0opf1VK2SWl3L/ZuSflgqWlJRaS5R/+l1/4dmXlpAKUUitMJhM9PT2VkkhrHXkvtzKx2Wz0dncTsOmZHR9mYXZ6y2rlD3dYuDtoQmgajtvfhaG+k+9///s8++yzlSBlMlto6x1gIQ1DM0u88sorWyZCWK1WmpubyWazTE1NkUqlGBoaolgsvuGvxa1muxXUx4H3Ua4Y8TLw1OpHAbxvNUlB2UETExPoHeWr4i2FZOUksgpQSi2xWCz09PRUVlJSSiYnJ7e8RgnKbT0625ppdmjE5ieZGj2/aZASQnC03cK9wfLug+uun0Zn8/Dcc8/x7e98u/I8m91Jz223UzA5mYpmOXXq1JYrObvdXukjNT09TTKZVEHqGmwXoD4IlIB3SSnvkVL+nJTyHuA9q4///A0dnXJZUkrOjYyjme3IQg67vojFYkHTNAwGw04PT1GuK5vNRnd3dyVIlUolJiYmLhukurq6OHTbflrdRjKxZcILW5/Ovq/NQrtLh2ay4X3kP2G/7a0Mj45RLFwIKgaDkbaeAYTFyUw0zeuvv75lmxCn00ljYyPJZJKZmRkSiYSq23eVtgtQ/ZSrPTx78Z1Sym9Rrv6wec0Q5abI5/OMzJWvzygmozgddsxms1o9KTXLbrevC1LFYnHbIOX1etmzZw9NDj3xpRDR5Y0dfKHc8PC9fTb6vDqETo+19x689/08hUt+TWqaRlt3Pzm9jcnlBMeOHdtyu8/tdhMIBIjH48zMzBCPx1WQugrbBSgHsFVp30HAeX2Ho1yNfD7PdLhc2qWYCONxuzGZTCpAKTXN4XBcU5Dq7e7CY8gzOz5MPrd5koPFoPHTAw4e22PGZhBMxkt89XSCXHH91qBOr6ezfy/S4t52u8/j8VBfX088Hmd2dpZ4PM7IyIgKUldguwBlAh4VQvzjpTfKNfNUN7wdlMvlWEqVf8gLiXKbDb1erwKUUvOcTiddXV1YrdYrDlLBYJA6lwOXUTI5cv6yAaLVY+YXbrPjNAlmE0W+PpikJCVjoxfS1nU6Pa3d/QiLk9lomlOnTm2ZuLFWvmllZYXZ2VlWVlZUkLoCV5Jm3kW5Tt6lt915FWgNyWazrBTK38JiYolAIACoNu/KrcHlctHZ2XlVQaq5uZkGpxkycWYnLl9W1G3W8YE9dsx6wUikwBf+fZRPf/rTPPtPF7L71rb70sLM1HKcY8eOEQ6HN00r9/l8+P1+YrGYClJXaLtKEr9/U0ahXJNcLkdWZ8UMFGKLBIN3ACqDT7l1uN1uOjs7GR0dpa2tjYmJCSYmJmhtbd20LJHBYKCvr4/8iRNMhheZKBZpbOnAuMX/mTqrjvcP2PjKyTgLWh22PQ/y3HPPkc/nee973wtidbtvYB8TQ2eZWE4STZ7EbNDY09+P3+9fd7y1PlQXV2lfq25xaVkmZZsAJaVUAaqKLS8vg3W1UWF8kcbGRvL5vApQyi3F7XbT1dXFyMgIbW1tTE5OVoLUZv8XHA4He/r7kWfPEk5FGD4dpXvvoS2DVLNTz7t6zHzjfAbbngfRe5r4t5e/RaGQ533v+z8QmsBgMNLZt4+FuWmWoxFKyRS6wUHsdvuG+oEXBykpJU1NTQwNDdHd3b2uDqCy/YW679nudrMGqmw0OjqKzlH+C81cTGK32xFCqBRz5Zbjcrno7u6ubPdB+RrBrRIXfD4fd915J50BLw69ZGF28rLH31Nv4V09FkQxh6mxB8+bP8KPj53mySefpLR6bZOm0xFobqNn30HMLi/z8Rxnzpy57HbfyspKJbvv/PnzquLEJbZbU34NeOYyt3+8oaNTLiuXy2NwlQOU3yJwOBwYDAaE2LQwsKLUNKfTWQlSbW1taJrGxMQE6XR60+ebzWZ6e3vxWnTElhfJZjZ/3pp9DWY+fqcHYyaMzurC88Av8urJs/zN5z+/rlUHQHN7N2lMTC+vcPz48U0Dpc/nq3TlnZ6eJpFIMDg4eNlzaLea7QLU5Da3qa1fqtxIhUIBs9sHOgP6Up63P3QUh8OxZTsARbkVOByOSu2+trY2dDodExMTJBKJTZ9vsVhoagzgNgmmRs+T2eKi2zUui4H/dH8bplwMnd2D656f5czZQT77+GfXBcJyGvo+EpiZWFzhxIkTmwYpr9dLY2MjiUSCqakpkskkg4ODW9b6u9Vs1/K9XUrZcbnbzRqosl4ul2M+Vv4hNsosJpMRk8mktveUW57NZqsEqfb2dkwmE9PT06ysbN5pt7W1Fb/DhLWUYuTMcWYnRykWt95qsxh1/MqbWjAUMxjqmnHe8W7GJmf5zF9+Zt17GE0muvr3kzPYmA4nOXny5KZp6G63u1IW6eIgtdXK71ay3Tmonwghfl0IUX+zBqRcmWw2y2y8/MNuKaVViSNFuYjVaqWvr69yTspsNlfO9VzKbDZz5M472dvZQrtLTy4yz9CpExQus9VmNWr8/O0+hCxhbrsN3zv/L2KWxg2dd3V6PR29e8noLMyEE5w5c2bTenwul4vm5mYymQwTExOkUikGBwdv+c68223x3QF8EpgWQvyTEOKDQoitW1oqN00ul2MuUf5Bt8kUNpsNQG3xKcoqs9lMX18fNpuN1tZWHA4H4XB4XYr3GoPBQHd3N4fvuJ0OvxObyDE5MrhlBXSAgF3Phw448YokQm/Efugd6LzNG55Xbtexl5WinpmlKKdOnSIUCm1IiLDb7bS2tlIoFCpBamhoiEgk8sa/GLvUdgHqt4ATlNPR3w78b8qdcD8vhHhYqLPxOyabzfJvx8tVqOJzo5UApVZQinKB0Wikr68Ph8NBMBjEbreztLTE7OzspsHHbrezb98+Ak4TxdQK81Pjlz1+0KHnY/cGOVAHEsHXzyVJ5jZeeGswGOno3ctSWjI0u8xrJ8/y2muvEY1G1z1vLcFDSsn4+DjJZJLR0VEWFhY2HPNWsN05qD+VUt4ODAB/SLmRoB34ReA7lBMllB0wNTXFiixXjBh59Yc4nU6VYq4om1jrzOt2u6mrq8Pn8xGLxZiamtp0u81sNjMwMECjQ8/K4hwz4yOXXUkBPNLrotmpI5GX/PNICikloVCIH/zgB5WqE2arle59t2NtaCNcMjG6mOC14yeYn5/f8P7t7e3o9XomJyeJx+NMTU0xNTW17ThqzRVduiylHJRS/ncpZQ9wFBih3BOq6QaOTbmM8+eHMHiDAFiLKzidTsxms0oxV5RNaJpGV1cXLpcLv99PY2MjqVRqy9JIHo+H/Xv30OIykI6EGD7z+mUz/HSa4N29Nkw6GA4XeHlihSeeeIKvPfM1/uEfnq5cK2U0mfAHgnTvOYDV18RMvMCZc4PMzMysO57BYKCtrQ2z2cz09DThcJiFhQVGR0dvqdJIV9ryXSeEeLsQ4kvANynX51N20OuDo2hmO6VcGpehhNPpVBUkFOUyhBAEAgGamppwu900NzeTz+cZHx/f8jqlgwduo6POikOmGTl7gnhs6/NBLpPGWzutAHx/ukjGV+5G9MMf/ognPvc50hcFOE3TaGxpp66pnZl4gdODwxuKzer1+sq5s1AoxPz8PJFI5Ja6Vmq7LL4HhBB/BcwD3wI+RLkFxxDwu0D3DR+hskE+n2dwrrx3XYiF8NV5sVqtqkisolyBxsZG2tvbcTgctLW1IYRgfHx804w5l8vF4cOH6WkN0GjTmBo+x+i5U0yPDVPcpOrDXr+Be5pNIDTs+x/Gdd9jCJOVwXODfOpTf04oFFr3fH9jkEB7L3NJycjsIqdPn1637ahpGs3NzXi9XiKRCNPT08Tjcc6ePbtllYxast0K6gXgY0AdsAh8GrhLStkvpfwDKeXY5V6s3BiZTIaZePkvqEJ0nsbGRoQQKkApyhWqq6ujp6cHm81Ge3t7ZSttaWljM0O9Xk9fXx/dq+3jXTJJcWWB6fHhDc8VQvBgm4X3D9iw6AWmQDfeh38Fnd3L4uIif/6pT3HmzJl1r3HX+enZf4iVooHZ5RhDQ0MbzjU1NDRUuvOuZfhNTU1tSGuvNdsFqDTwJPBOICil/C9Syp/c+GEpl5PNZokWyskQ+fAczc3l1FYVoBTlyjkcDvr7+ytp6E6nk8XFRWZmZjac5xFC0NXVxd13Hubwgb0EHEYysTDhxflNj93tNfCRgw6anTp0Fgfu+x5DGC1kMln++nOf43vf+14leQLAYDTR1jPAYloyNhPitddeIxQKrVslud1uWlpayOfzjI2NkU6nGRsbY2ZmpmaTJ7YLUPVSyp8HzgL/QQjx20KIjwoh2m/4yJQtpdNpMkY3APnINB0d5YIe6hyUolwds9lMf38/LpeLYDBYKeC6VfKEzWbD5/PR09NDwKZjbnKMTHrz5AmHSeNn99ipt+nQ2b3U3f9BEAIp4Vvf/BZf+tsvkc1cKGlksdpo6xlgKadjJBTj1ZNn+dGLL63L8ltb8el0OkKhEJFIhPn5eYaHhzfNSNzttkszTwoh/oBy2/fHKaeafxYYEkL84U0Yn7KJyclJdO5GALR4eYtPr9ej12/X3ktRlEvp9Xp6enrw+/34fD5aWlrI5XKMjY2RTCY3fU1DQwPNTQ3UmQRTI+dJrEQ3LTZr1AneP2DDZhBonmaC97638tjxY8c5dvzYuufbnW569x3CHmgjoXMwEy8wPDy8biVlMpkq25Lz8/PMzc0Ri8U4e/ZszZVH2i5J4heA/0r5Qt0CEFr9qAN+Wwjxizd8hMoGJ0+fweBpQsoS1kIch8OhtvcU5Q0QQtDa2lrJmltbpUxNTZX7rm2iu7ubBrcVYzHF/MgZhk++RnR54zksp0nj3b3l7L58420ceEu5S9GBAwe4+667Nzxf0+nwB4J09O3F4qxjIZFncHCQcDhc2XrU6XT4/X7q6uqIRqNMTEyQTCY5d+7cluPdjbbb4vs1ygHp44BNStkE2IBfAUrAr97Y4SmbeWVwCqHTU4wv47YacblcKkApynXg9/vp7e3FbrfT0dGB3W5nYWGB6enpDVtoer2ePXv20N3opb/JQ9ChZ2ZsiMRKbMNx290G7msp/x8N1R3kzY/9Ko+892cocflzR01tHcQLgtH5MD85fpJTp05VzjcJIaivrycYDJLJZBgdHSUejzM+Ps7ExERNXC+1XYDaC3xNSvm4lLIAIKUsSCmfoNwrau+NHqCyXi6Xw9lSvr7ClIsx0N+PyWTa0LVTUZRrY7fbGRgYwOFw0NzcTH19PYlEgrGxsQ2p3Xa7nYMHD3Lo0CE6WoMEbBoTQ2dYiW68XupNLSaONJkoSTidq+OLZ3I88Vqc10NZiiVJPpfnK1/+8rpMQoPRROfAbejcjcynYHYxwtTU+i5HTqeTjo4OdDodk5OTLC0tsbS0xLlz53Z9Kvp2Jy0uV5agNtNGqlwmkyEqy8Eo6NBzV/ddACpAKcp1ZDAY6OvrqwQDi8XCzMwM4+PjBAIB3G73htd0dXVRKBTQZkNMDZ/F7WvAF2jCZC7/3xRC8OZ2M26zxpmlHJF0iUimxLPDaV6YyGAJD3H2lVc5efIU73//+7nj8B0AmC1WGlvasTtdTA2dwTQ2jpRy3YrOZDLR0dHB3Nwci4uLpFIpmpqaOHv2LK2trdTV1d2Er9r1t90K6gzwU0KIXxJCaABCCE0I8UvAT60+rtxE2WyWmWT5bwOHTGC32wEVoBTlels7L7W21dfR0YHVamVubm7TLT8hBH19ffR0tNLq1CHjCwyffI2J4XOVTD8hBLc3mvjQfge/eqeTd/ZY8Vs1UnnJsqMb+8FHyWazfPnLX+YrX/nKuiw/h8uDN9DM9EqeU+fHOHducN11UJqmEQwGCQQCpFIpxsbGKlt+Y2NjuzLLb7sA9RnKq6zPASkhxAyQWv1cB/zVjR2ecqlMJsN8uvxtc8kkbrdbZfApyg3k9XorW36tra34/f7Klt+lWXNCCDo6OrjrzsPs7QjS4TViyEQYOXOC8OL6KhKaEOyvN/KRgw7e129FQ2LtPoLr3g+gdzfyyk9e4c8+8WdMjE9UXhNobqO5Zy8rwkIoDcdfP8nExMS643o8Htrb29E0jcnJSRYXF1leXubs2bNbdhauVtulmX8B+FPK23lGoHH1owQ+IaX8/I0eoLLe7MISsaIBIUu4RAq3261WT4pyg61dL+Xz+fD5fLS1tQEwMTHB0tLShgtl17r63n3kCH2tjTTbNBYmh5nbpH2HEILeOiPvG7Cj18DU1IfnoY9iat7L0uISf/Hpv+DZZ5+lWCivgOxON10Dt2H3B5lcKTI0Uk6KuHgMZrOZjo4OXC4XS0tLTExMEI/HGRwc3LLVSDXatlislPK3gF7KmXz/bfVjr5Ty/77BY1M28Zm//UcAivFFRs6dUgFKUW4STdNoa2ujs7OzsuXncDhYXFxkYmJi03buJpOJ/v5+9u3po9lpYGVhdsv2Hd1eAx+/w8ntASNCCJx3vgedqx5Zkjz33ef45Kc+ydzcHFAOah5/A8GOHmYSRQZHxnn55ZeZmpqqZO9pmkZTUxNNTU1ks1nGxsaIRqPMzc3tmgSK7a6D0gshnMDkaibf/yOlfByYEEI4hRBqX+kmyufznF8oL9EzS1MUcjksFosKUIpyE3k8Hvbs2VOpPrEWAEZHRzc0IFwTCATWte8YGzy9aUt5u1HjrZ0W9vkNCJ0B34MfQrOWEzJmZ2b5xCc+weTEhTZ87jo/wc5eQlkdQwtJTg2OcOzYsXVbeS6Xi87OTsxmc+X82crKCmfOnCEUClX1amq7FdQnKBeJbbnk/iDli3b/7EYMStlcOp1mMVf+myC/PE1rayugEiQU5WYzGo309vZWWnd0dnZisViYm5tjcnJy0zJJa+072r0W9NkVxgZPUyxurIguhOBtXVaa7Dqk0U7T2z+OpbHcOKK1tZXmlvVt5V1eH3233UFj1wBLeT2jCzFefe0Y09PTxGIxSqUSBoOB1tbWSsr86OgoKysrTE9PMzg4WLWrqe0C1DuAFy6tWi6lnASeX31cuUlSqRRpoweA/NIkPT09gApQirIThBA0NjbS399fad3R0NBAKpXacjXlcrk4dOgQrT4HpmKK0XOnmZ+e3HBxr0En+MBeO81OHTlhxPGmxwi889e5/z2PoWkbf20LIXC6PfTuO4Te6WcyluPEuWFeevU4r776Kul0GiEEdXV1tLe3YzAYmJ6eZmZmhlgsxpkzZ5ibm6u61dR2ASoIjG/x2AzQvMVjyg0wODiI5il/yWVkqlKPa7MfWEVRbg6r1crAwAD19fV4vd5122mbrabMZjP79+8n6Ck3QixEZpg8f4qZ8ZFK510Ak17wgT123tRiwm4QlCxuvj2t4x/OJolmys8rFYt84fNfYOj8EFAuk9Tc0UNjRx9pg5tQVsfEUpxjx45VAuZaS3m/3088Hmd0dJRYLMbs7Cxnz57dsv7gTtjuHFISuPPSO0W5r/iR1cffECHEOBAHikBBSnlYCOEFvgq0Uw6QPyul3LqV5S3iuX/7MXrHfkr5LF59gbq6Omw2204PS1FueZqm0dLSgsfjYXx8HKPRSCQSYWFhgZGREfx+P16vl/KvznKQOHToEIuLi2SzWaZnZglFQ4wkE7T3DmAwGIHySur+Vgv3Npt5ZS7LDyczDIXzjEXz7LeZmfjXf+X111/n9ddf58iRI7z7Pe/GZrPh8vpweX0UiwUmhs4xEVkhc/wEbS3NdHR0oGkaPp8Pu93O/Px8ZSUVCAQ4d+4cfr+fYDCITqfbyS/rtiuoHwMHhBBfEEL0CCGMQoge4AvAbauPXw9vllIelFIeXv38t4HnpZQ9lLcSf/s6vc+uJaXkpbPlk6OF6DwBvxen04nVat3hkSmKssZut7Nnzx4aGhrweDx0dnZis9lYWFjY0FreZDLR3NxMV1cXd9x+iHafHWspxdDJY0yODK4rl6TTBHcFzfzH253s8RkolOBY3M6LYSua1QXAyy+/zB/90R/xox/+6KKisnrae/dg9zczuVLk/NgUr7/+OtFolEwmg9lspq2tjfr6RM//IAAAIABJREFUepLJJCMjI4TDYRYWFjh9+vSON0TcbgX1x8CjwC+s3i5WAv7kRgwKeC9wdPXfX6Tc2fe3btB77QrZbJbxaA5aIB+Zpa2lGZPJpFZQilJl1tq0ezweJiYmMBgMrKysEAqFGBsbw+Px4Pf7161O1mr6Gc+cYSkSI52JMDO8xEpdPQ3NbZUVlcOk8Z4+G13eHM+eT0JjP75AL7nFSfLhadJDL/H000/zox//iPe97310dnaiaRqB5lYcbjeTQ4Ok5yOEwjEMOggGAnR1dVFXV4fT6WR+fp5QKFRZTY2NjbG4uEhra+uOnOsW250UE0L8HPCXgPeiuyPAf5ZSfuUND0CIsdXjSeCzUsrHhRBRKaV79XEBRNY+v+S1H6Pckp6GhoY7nnzyyWsaQyJxoWRQtYpGo3zs8e9hve1tRH/8FO9qKfLAAw/Q3d297hzUbpjLdmphDmtqYS61MIc1N3suUkoikQhLS0sUi0VisRjxeBxN03C73RvGIqUkk8mwsrLCfGiBlbwgJfU43HXUBYLr/q8vp0qM5J1MZUzI1bKppWyK+PFvk506BUBPTw/33HtP5X0KhTzh0Bz5XJZcOoldK+Aylaui19XVoWkayWSSSCRCsVjEbrfj8XjQNA2v14vf77+uX5+178fRo0c3rfu6bYACEEJYgDcB9cAC8CMp5eZtJK+SECIopZwRQtQD3wX+M/CNiwOSECIipfRc7jiHDx+Wr7zyyjWN4YUXXuDo0aPX9Nqb5Xvf+x6P/fUrmFv2Ev3nT/GJ//JB7r77bvbs2bPuebthLtuphTmsqYW51MIc1uzUXLLZLJOTk6ysrJTLlc3Pk06nsVgsNDQ0bLo6SSaTjI+PE1paYjlVJKez0N4zgNFUbtsxPDxMd3c3yVyJ2USRV2YyTKyUkyeyM+eIH3uWUiaB0WTkne94J/c/cP+642fSKWbGRyik4tRZNBq8Tvbs2YPZbKZYLLK0tEQkEkEIQUNDA263m56eHpxO53X7ulz0/dg0QF3RhbZSyjTw3HUb1fpjz6x+XBBCPEM5+SIkhGiUUs4JIRopB8Vb2vHjJzD62wFwyRWVIKEou4jJZKKnp4dIJML09DRms5loNMri4iLj4+O4XC7q6+vX1dS02Wzs3buXtkSCs2fPMhdJMHz6BG09A9gcF4KEzajR49Xo9uh5fSHH86NpCPZj8LeVV1OTJylscr2V2WKla2A/K5Ews5OjpEJREsmfYNDrK8HI7XYzPT3N8vIybrebQmHjcW6kHa0EIYSwAZqUMr7670eA/wl8A/gw5XNgHwa+vnOj3HmlUglPUzvaghGtmOPugwO4XC6VIKEou4zH48HlcjE3N4cQAofDwfLyMuFwmJWVFXw+H16vd91Wnt1u59ChQ5jPnsUQWmZ88DTe+gCFwvr0dSEEBxpMdLgNfHs4xWjUguvIT1PqOMDBI1u37nN6vNgcTqbGhhgJhxHk8MYzJJNJ9u3bh9ls3rELeXe6VFED8Mxq6qUe+IqU8ttCiJ8ATwkhfhmYAH52B8e449LpNKcXMoAReylBZ1srVqsVh8Ox00NTFOUqrbXF8Pl8TE9Po9PpcLvdLCwssLi4SCQSwe/343K5Kmnper2effv2YbGMYJqeIRyZY3JiFotO0BBsxXzRH6tOk8bP7LFxciHHc2Npcv5O/vfpDD+/X4/XoqMkJfOzczzzzDO8453vKDc71Otp7xmgWCyQz+aYHDnHxOIKuddeo66ubse6JexogJJSjgIHNrl/GXjo5o+oOiWTSc7Hyj+onlIEj9uFyWRSbd4VZRczmUx0dXURj8eZmprCaDSSTqcJhULMzc2xvLyM3++vnPMRQtDd3U0gEGB8fJzo3DjGbITRsxHaeveu2/YTQnBbg4l2t4Fvnk8ytVLk704lMOgEkXQJLZ0hpqvn05/+DHv29PO2t72NlpYWdDo9OqueroHbmBguXz81v3AOn7fcwuNmUyUIdoHl5WXG0yYA6ooRvF5vzWRVKcqtzuFwMDAwQFtbG06nk/b2dpqbyxVjZmZmGBsbW1f81W63s2/fPvYODNDd3ECDVWN88DShmcl1lShgbTVlJ+jQEc9JwukSEihavNhveyvet36c87NRPvmJT/LEE09UCtHq9Ho6+vZi8QaYSZQYmZrn+PHjZLNZbqad3uJTrsDnn/oGK6V9aKU8fl25B5Ta3lOU2iGEqJx/WlhYYH5+HofDQTQaZWlpiampKSwWS6X6A5Tb0g8MDGA0GjFMz7C8OM2ZuRlsDieB5jYstvLzjDrBz+yxc2w+S71VR9Cp5/RUmO+Pp8Hpw3P0P5A88wIjkSX+/DP/H31d7Tzytkdob28n2NZJCY3p0SEml1Z4+eWX2b9/P3a7HZ/Pd8PLrKkAVeWy2SzP/PAU3L6P1PQ5FvITOBxvVSsoRalBmqYRCATw+XzMz8+jaRoul4toNMry8vK6QAUXtv38fj9jY2NEYjESuTij507S3NmLy1MHgFkvuKf5wimBOzrqONAm+dbpZc6t6LHvfxiAYibB8I++yrk//wt6e3t56OGH8Hq9tHT1k1pZ4tz0MsuJ17AYNVy2clPEvr6+GxaoVICqcouLi8RM9ViB7NwQPUfa8Xg8qoK5otQwvV5Pc3MzDQ0NzM3NVS7svThQzc3NEY/HcTgcuFwuDh48SC6XY2xsjImZeWZGzpFpbKG+qaWSbLHuPTTBT+33cXYxx8nZOFPLCTC78Dz4YXKhEaYWxnjh5RP89NvejN5goKt/PxpFiprGXCzK+HKY5USaxcVF7r333huSSKECVJX77nefw9iyHwD98gjdXXety+5RFKV2rfVxCgQClRWV2+0mFosxNDTE9PQ0RqORuro6XC4XRqORvr4+LBYL+tEx5kPTxCLLeHz1eOrq0RsMG95jwG9kwF9HseTlW2fCnI3pMTX1YWrqYxn4xqTksEfQoNMRCARx2MunF+KxKOdPnwAW6Zibo6Xl0raBb5wKUFXu6e/8K/r291PMJGgw5aivr8flcu30sBRFuYmMRmMlUIVCIXQ6HU1NTQSDQZaXl5mbm2NxcRGPx4Pb7aa1tRWHw8G5c+eIpXKszE+wMD2B0+PD4fZid7o2BCudJnjvvjrenC1xejrK6dkoSWMdC2l4Nm3iufkYbXV5jnT6uKezDofLjdvro5ANV4rTXm8qQFWxdDrNibk0+nbIzQ+zp7ujcqGfoii3HqPRSEtLC4FAgOHhYTweD06nk0QiQTgcZnFxkaWlJdxuNx6Ph7vuuotwOMz8/DwLy8sk08ssrywxXZAYzRbcdX48vnoMRlPlPZwmjXu6vNzT5SVbkHxvKML5mCBdFAwtphhanOQ7p+f5j/d33vD5qgBVxY4fP07W3YYeyM8Pceht+/D5fBiNxp0emqIoO8hgMOD3+9m/fz+Li4ssLCxgt9vJZDJEIhGi0SiRSASbzYbH42Hv3r10ZTKVqhWxWIx0Ps/K4hSLM5MYLFYcLk+5qoT9wvVUJr3gSL3kkDuHo66epZKVfx+NMRVJ88f/fI5ej8b9vht3ukEFqCr21N//Pea2cossZ2qW5uaHcLs3FHVXFOUWpdPpCAQCNDQ0EA6HCYVCmM1m/H4/0WiUaDTK9PQ0BoMBt9tNIBCgubmZUqlENBplbm6OSCRCKpcjEZljamEGzWjB42vA6fFiMl9IxrIZNTobXDzQ38TXj8/y3bMhBiMlhqMm3nvfjanRpwJUlSoUCnznxdfRPfAQxWSUXr8Fr9ertvcURdlACEFdXR11dXXE43EWFhbQ6/XU1dWRSCSIRCKV7T+73V7ZAvR6vZRKJWKxGMvLyywtLRFLZokvTLAwPY7L14DJvv53jkGn8f47mnl4oJ6///cz6IppnOYbE0pUgKpSIyMjzJZcuIHs/DCH9vZTX1+vKpgrinJZDocDh8NBLperBKW1zyORSKUnlcFgwOVy4XK58Hg8lQ7A4XCYpaUlQguLzEcXmJ2eolQsUsqn1vWDcluNvKXVgDEbv2FzUQGqSn3pS1/CMvAgAIal8/Q8/ACBQECllyuKckWMRiPBYJDGxsZKaw+j0Uh9fT3xeHzdqslisVQq1Ph8Pnw+H8FgkNOnT1NKxyiW8mSW5xk6fYLegf3Yna4bXkUCVICqSsVikYbeg5iKVshnGHAVqaurw+v1bv9iRVGUi6x1w/V6vWQyGZaWljAYDDidTgqFAtFolFgsxtzcHPPz89jtdpxOJ3a7ncOHD+NyDZFOp8lmsxQKScbOvEZeanT2bt3C43pRAaoKhcNhfjRT7vXil2HedMdtBAIBtb2nKMobYjabaW5uJhgMEovFKsHK5/ORyWSIxWKsrKwQj8cr/aqEELhcLoLBIKVSiUKhQGg5yti51ymhEXBuvPj3elEBqgqdHxriZLycPdNYXKTOZd+RUveKotQmIQRut7vSJTccDrO8vIzZbKahoYFkMlkJVFJKoBzcOjo68Hq9jI2NYT11mlg6i0HTbli/KBWgqkwmk+H5k1MkpR1jKUOnNUdDQwP19fU7PTRFUWqQXq+nvr6e+vp6MpkM4XCYcDiMzWYjEAiQTCYrHXXXzoF3dHQQDAZZWFggk8kQCARuzNhuyFGVa/blL3+Zr53MgN2OPzdPoMlGX1+fujhXUZQbzmw209TURFNTE6lUikgkQiQSIZvNotfr13VRMBqNlb5VN4oKUFWkUCjwh//vX1B81/+EUglH+Cx1ew/Q2XnjS4ooiqJczGq1YrVaCQaD5HI5dDodOp3upo5BddStIk899RRLji6ETk9u9hz7WuoqXTYVRVF2itFovOnBCVSAqhrFYpH/9j9+D+fh9wDgWhmlpd7LwYMHd3hkiqIoO0MFqCrxuc99jkVbB3qnn0I0xMN9Xtrb29ddua0oinIrUQGqCkSjUf7H7/4+rns+AIBj6RQdjT4OHz6sKkcoinLLUgGqCvzGb/wGqcaD6N0NFFcWeVuvm/a2VoLB4E4PTVEUZceoALXDvv3tb/OlJ/8B9wO/CEBjcohWv5MHH3xwh0emKIqys1SA2kFTU1N88IMfxPOWj6KzOJDLE7yt183+fXvx+Xw7PTxFUZQdpQLUDvqff/AHiMMfwL7/IWSpyF2OMM0+J/fdd99OD01RFGXHqQt1d8i5c+eYa3oQp9eNLBVpi5/mjm4bDz30EBaLZfsDKIqi1DgVoHbA5OQkf/qN1ziVcaNR4oAYY3+rgTsPHaC7u3unh6coilIVVIC6iY4dO0YoFOI7g1GeD5erQxwyLtBrzHGov1tt7SmKolxEnYO6CRKJBL/zO7/DnXfeyUf/5Es8M+cABP36Rbr0YQ72tPLII4+ogrCKoigXUSuoGygcDvPZz36WT3ziEyxHV/C89VfRH3gEgH5diAOmZQ73t/PII4+oZoSKoiiXUAHqOpJSMjExwfPPP88zzzzDv/zLv5DP5zEF+2n8pT/E4A0ii3n6S5Pc7ZXc3t/Hgw8+iMvl2umhK4qiVB0VoFalUik+8pGPYDabsVqtOBwOXC4XTqcTp9OJw+HAZDJRKpWQUvLud78bKAelfD7PF7/4RX7zN3+TeDxePqBOj63vPryH3o65eS8AxnyCuyzz3N3qYH9/N3feeafK2FMURdmCClCrTp48yVe/+tUreq5Op+Oll15ad182myUejyP0Jhy3vwvnXe9DZy2vjLRSng5dhAdacuxtaWXf3gF6e3vRNHUKUFEUZStVHaCEEI8Cfw7ogM9JKf/4RryPlJLFxcUrfn6pVCKfzyOlpFAocG42ykthM/6f/q+Y2w6gmawA2IpJOo0xjjTp6Gly09LYwL59+9SWnqIoyhWo2gAlhNABnwHeCkwDPxFCfENKeeYGvBd79+7l937v98hms2QyGdLpNKlUilQqRTKZJJlMktKspBv2U9Rb+JPvTZEvlpjJGIkUjUAj1t5GANxahiPuNHc2GvHa/QTq/XR3d9PQ0HC9h64oilKzqjZAAUeAYSnlKIAQ4kngvcB1D1AAHR0d/O7v/u66+4rFIp/53hBPvzpNKp1iOashKbe/OLZy4XkmrUSLpUC3s0SvCxqsgjqnj/b2dpqbm7Hb7TdiyIqiKDVNSCl3egybEkK8H3hUSvnR1c9/AbhLSvlrFz3nY8DHABoaGu548sknr+m9EonElkHk785l+c54ofx+lAiKKB6SaEiMOolPn6dRl8Cg1/D5fNjtdoxGI263e0daJF9uLrtFLcxhTS3MpRbmsEbNpbqszeHo0aObNr6r5hXUtqSUjwOPAxw+fFgePXr0mo7zwgsvsNVr996R5bHhcYZHhmn1e/HamyqPORwOgsEgJpMJTdOqIunhcnPZLWphDmtqYS61MIc1ai7VZbs5VHOAmgFaLvq8efW+m8rvMPHgoT4ePNR3s99aURTllrbzf/Jv7SdAjxCiQwhhBH4O+MYOj0lRFEW5Sap2BSWlLAghfg34DuU087+RUp7e4WEpiqIoN0nVBigAKeWzwLM7PQ5FURTl5qvmLT5FURTlFqYClKIoilKVVIBSFEVRqpIKUIqiKEpVUgFKURRFqUoqQCmKoihVSQUoRVEUpSpVbbHYqyWEWAQmrvHlPmDpOg5nJ9XCXGphDmtqYS61MIc1ai7VZW0OS1LKRy99sGYC1BshhHhFSnl4p8dxPdTCXGphDmtqYS61MIc1ai7VZbs5qC0+RVEUpSqpAKUoiqJUJRWgyh7f6QFcR7Uwl1qYw5pamEstzGGNmkt1uewc1DkoRVEUpSqpFZSiKIpSlVSAUhRFUaqSClCKoihKVVIBSlEURalKKkApiqIoVUkFKEVRFKUqqQClKIqiVCUVoBRFUZSqpAKUoiiKUpVqJkA9+uijErim249//ONrfm213WphLrUwh1qaSy3MQc2lOm8XzWFTNROglpauvS1KNpu9jiPZWbUwl1qYw5pamEstzGGNmkt12W4ONROgFEVRlNqiApSiKIpSlVSAUhRFUaqSClCKoihKVVIBSlEURalKKkApiqIoVUkFKEVRFKUqqQClKIqiVCUVoBRFUZSqpAJUjSoWi8RisZq42lxRlFuTfqcHoFxfUkomJiZYXl5GSokQgv3792MwGHZ6aIqiKFdFraBqTDKZZGlpiUgkwuzsLFJKEonETg9LURTlqqkVVI3J5/MALCwsIGW5SHAul9vJISmKolwTFaBqTLFYXPexVCpVgpaiKMpuorb4akyxWKRQKFQ+z+fzagWlKMqupAJUjSkUCipAKYpSE1SAqjHFYrGyvQflgKW2+BRF2Y3UOagas7bFJ6VkdnYWvV6Px+OppJwriqLsFmoFVWPWVlDxeJzZ+RCjo6NIKddt+ymKouwGKkDVECllJUCl02nywkg8kaRQKKjzUIqi7DoqQNWQtXNNhUKBTCZDQejI5IskEgl1HkpRlF1HBagasraNVywWyWQyFNGRXg1QagWlKMpuo5IkashagEqn0+QLRYoYKRYkKysragWlKMqus6MrKCGEWQjxshDihBDitBDi91fv7xBCvCSEGBZCfFUIYdzJce4Wa0EoHo9TQMNgMJAvCaLRqFpBKYqy6+z0Fl8WeIuU8gBwEHhUCHE38CfAJ6WU3UAE+OUdHOOusbaCisfjFKSG11dPAY14IkEymdzh0SmKolydHQ1Qsmyt1LZh9SaBtwBPr97/ReCndmB4u04qlSIUCrG8vEwBDZvThclsIZUrEolEdnp4iqIoV0WsVbzesQEIoQNeBbqBzwB/Cry4unpCCNEC/LOUct8mr/0Y8DGAhoaGO5588slrGkMikcBut1/bBKrIiRMnePnYSaKJNJrVSXv/AcZHzmMtrHCgr5N77713p4d4RWrl+wG1MZdamMMaNZfqsjaHo0ePblpFYMeTJKSUReCgEMINPAP0X8VrHwceBzh8+LA8evToNY3hhRde4FpfW00ymQwvvj5IfUc7bV3dBIItFPMZ9OkIvb29PPDAA2jaTu/qbq9Wvh9QG3OphTmsUXOpLtvNoWp+W0kpo8D3gXsAtxBiLXg2AzM7NrBdJJvNUixJbE4XXn8DAAajiXxRks1mVTUJRVF2lZ3O4vOvrpwQQliAtwJnKQeq968+7cPA13dmhLtLNpulVCqhabrKSslkMlMoFsnlcipAKYqyq+z0Fl8j8MXV81Aa8JSU8ltCiDPAk0KI/wUcA/56Jwe5W+RyOYpSrgtQBpOJXFGqAKUoyq6zowFKSvk6cGiT+0eBIzd/RLuXlJJ8Pk9JgtBplQBlNJkoFEsqQCmKsutUzTko5Y1ZKxJbKkn0ugt/d5iMZoqyfBFvNpvdwREqiqJcHRWgakQlQAE6w4UApek0dDo9+WL5OilFUZTdQgWoGrHWqLBUYt0KStM09HoD+WK5aKyiKMpuoQJUjShv75UoSYlOfyFA6TQNncFArlBU5Y4URdlVVICqEaVSiWKxiIR1AUrTdOUVVKGktvgURdlVVICqEblcjlKphJQCnU5XuV/TNPQGA/miClCKouwuKkDViGw2SxFAE2jiwrdVpysHqFyxRDqd3rHxKYqiXC0VoGpELpdDlkATGkK7UHdR03To9EbyKkApirLLqABVI/L5PEUpQbC+IKwAg7F8DkrV41MUZTdRAapG5HI5isUSQtOt2+KDcjWJfA1Wk1i7+LhUKl32eblcjmw2y063llEU5ersdC0+5TrJZrOUpEQIsW6LD8BoWl9Nwmw279AoNzc6OsrZs2e5//77cTqdGx5fWlrixRdf5NChQwSDQQCmp6d55ZVXKSFx2Gy85S1vYXJykjNnznDffffhcrkAOHPmDIPnh5BIGhsauOeee27q3BRFuXZqBVUjcrkchWIJTdPQxPoApWkamk5HQVKV10LNzs6yks4yNze35ePxTI7Z2dnKfXNzc0xF0pyeibMcSxCLxSrHmZ+frzxvfn6e4YUEZ2bjhEIL5PP5Gz4fRVGuDxWgakQul6NYkghNh7hki0/TNHR6PcVS9QUoKSXRaJRwIkcsFtv0ObFYjOVLHo/FYqRzRRwuN6lckWg0SiwWI5zIEY1GgfKKcSWeIFeSWO0O0oXilu+hKEr1UQGqRuTzeYqlEkLT0HQbA5QQOgolWXUBKh6Pk84VSGQ3Dx6lUolYLEYsnSeeSJLL5cjlcsQTSfISfA0B0rki09PTpDK5dceJxWKk8wWsNgcOp5t0tqQClKLsIipA1Yh8Pl/Z4hObbPGV6/GVqi5Ara2EcoUS8WSKTCaz7vF4PE4qV64xmM5fWCml80Vsdid2h4tUvkAsFiO1epxEKk0mkyk/L1vC7nBhsztI5QuV1ZWiKNVPJUnUiHIlCVleQV2yxafT6coX6xayVVdNIhqNksoXAUjnNq6iygGssOHxdK6IzeHFaneQK5QolSTpi44TjUZXj13Aa3dgc7qY2eT4iqJULxWgakQul6NQkohLLtQF0Gk6dHoD+Vy66gLUWgCy2u2kV1dCF4tGo6RyJax2O6lclmg0ihCCdL5IncOFpmmYrXbS+SKpXHHdcdZWZzanC4vVRq4kWYknyOfzGAyGHZqxoihXSm3x1YC1brrRkomwMcDJxTwnQlmGw3mklBdWUMViVQUoKWVla66hqZlUbuMW3FoACwRbKiuoaDRKKlvE5iinpNsdLlK5IulcoXycbIGlpaVKgoTFakPTNKw2x6ZBUFGU6qRWUDWgVCpRKBR5kX5yFgMTwxdKGn1wr40WR/kcVLqwc+egSqUSr776Kj6fj46ODs6cOcPMzAypbB6DyYLLU8fM6HlisVhldbOWIJHOF6nzBxgfHiSeKI8/L8FitQFgczhYjMyjN5orxwmFQsSSGRA64vE4JVmihCC0HOX73/8+Xq+X+++/n3g8zokTJyoX+woh6OnpobW1FYB0Os3LL79MPp/HZDJx5MgRTCbTDnwFFeXWowJUDSgWi+QKRXLCAFLS7xGEcxoLqRLT8SJtLgN6w4V6fHL1gt6bKRqNMjk9QyQSobW1leHhEc7OrVCSEn9TC2aLlSKCeDKF3WoBIJFIkMoVMJqs6A0GvL56zs2HEAI8dfWVObi9PoYHT+N0OwhHoyyEo8zMziAl+IOtLC4tlr9OaIzNLDE6u0TANkWpVCISiXB+Zomc1GEym3GYjRiNxkqAmpubY2x2kdBKlia3mbZQqPKYoig3lgpQNaBYLJIulMv4iGKOH3zuT/DtuQdtz//P3ptHyXWe95nPd9faq7qrdwCNxr6QECkTpCRKlijJomgnsmMriqlkopHlHE9OcpzE1kyS42RmPHHmJON4sjmJNEpkWbSTyFbsWFIs2aJskZJsizQpkQQJEMTWaHR3dde+V931mz9uVaEbaADdXQ1wu885dbrWW9+trrrvfb/vfX+/D7DSdEEENvCeH1T72bZ9x7OAbrdL2/YQok0+n6fjuKhGhBP3nsQwA2WLeCJFx7bBD5x/q9UqHdslkQpUIQ4dfwtWN8gOzUgU27Gp1+u0mk0mZw8ihKBeqzM5u59uu43reXhCYXlpGV8GGVJ6cg/lfI7lQon5+XkajQb5qs3ug3eh6hoLF84yndTwPA9VValWq7QsF0WP0LSC4oswQIWE3BnCAPUGwPM8Ok5wAFbx+dCHPsTTL72CBK5UukACTdUQioIrg8zk1QhQjifp2D6XL1+mY3skUplBcAJIJFN0Gqv4VlBq3i+QiGeuyh+ZkSitdovi8lKgzi6h0w2KP6zuVV2+vg+WqqiBP1YvYZS+xLW6FGsFlpaWqNcb5LsqIzNdItEojVabpaUlnn/+ecbGxigUCrQdj8k9+yguXgjXr0JC7iBhgHoD4Pv+IIMyVMHpU6dZvXiBsRMWXd2kZfuoqorSU5NoNBpks9k7OkbLsnC8wJK+UCjQtj2S2fW6e/FkinxpCacbZFD9AomJZBKAdqdNqVQKvK9cj2azSavVwveD/q9INELEjGCaJqqmXjeGPtGoSbdP1mp4AAAgAElEQVRWIJXSUIwInY6KZui02i3q9QZLfp3V1VVs2+all05TsA2O/sAEVy4Fa2T99wsJCbm97OivTAixSwiR3slthtwaz/Po9gKUrkg+/OEPA+BWA026lZYX6PEpgZrEq1HJ1+12cT2fttXraeo12q4lnkzRsf1B0OkXSOhmhOXcMsvLy7RaLcrlMrmVHI1mA9M0GRsbY2ZmhtHRUWLx2E2DEwRZmCcUfMAXOtnxccbHx5mZniYzOoLnSxYXFzl16hSlWgNPQi63guW4tLo2zWbzdn1MISEhaxgqQAkhflEI8VUR8MvAApAXQvzlnRleyGbwPI9u0KOKimRqagpd13ErgfjqYqUbZFBqEKBejQNst9vF8SUdJ2iq7TpXy8T79AslOl2LYrFIq2tj2S65lRWazSbVSpWVlRXa7TaJeILpqWmyY1ki0chgCm8zCCGIxhJ0XbA8n2gsAYCiqiRTaUbHJ5mYmMBxHAqVOs12h2azieP5XJi/wuLi4k5+NCEhITdg2AzqUYJpQgP4WaAvI/2/D7ndkC3gOA5WL0BpSmBaODI6glMJ1L8XqxaKqqCqGq736mRQlmXhuH4gRWS5RKLxYG1oDUII4okUlg9nz57l4uVFHN+n2WyykguCVCKeCDKdkcwtM6WbEY3HsT2frguReHxwv26YeL5E0zTS6TSJzAixRIJyuUy3a1NrdTh16hQLCwu39KEKCQkZjmHXoGaBbwLHCILUjwF/G/jIkNsN2QK2bWPJ4Fwjd+Uyn3nh98mv5lGTQdQqdAO5I1V79eSOgiKJQBGi1OoST41v+Lx4Mskr9SbPPvss1ZaFbehUyhUM02AkM4Ju7IwCRCyepFxawfEl0ejVAKXpOm5LYtvBVJ5UDPbsmUMqCp12g+XFEhkjeNwwDHbt2jXw19I0jSNHjhCNRndkjCEhb3aGDVBdYB/wQcADXur99YbcbsgWsG0bywvmuKx2k5fPvAyA16wgpaQrVRACTddx7DvfrOt5HpZl40vITkyxOH+e/bOj1z/P92hbNqvVDqrZoFhtMr1/jMxIhkQisaNjiiVSLHkQTaRQ1mRyum7Q6q3TtVotbF8SiQdKFHNz+ykuLfDyUomL+QbpdJrvvbJAZmSEeDxOOqpjmibHjh3b0bGGhLxZGTZAPQ08DHwA+FMpZUcIcQS4MPTIQjaNZVlYfpBBSdcGYN/+fVy6eAlptRCRBJYfqEm0nTsvd9Sv4DPMCDN75khnRkmmM+ueY9s2udwyhhkjPjqFSGSYndjL7tm9aNrOF5sapsmBu+5F09ZnZLph4PlQqVSwPIhE44OKPd00eevbf5BKuUi1VsMTCslMBiViYiuCSqsVqqWHhOwgw/7y/xfgnwI68H8KIQzgLPCnww4sZPPYto3tBxlUP0AdOHCASxcv4XUaKJEEbVcEU3yef8cDVLfbxfUlhmGiKMp1wanVarG6uorjOBRLRaSqMrN7NrBtv42CF5Fo7Lr7NN3Alb11PdcnumZ9CiASizEdm2Vs0qFcKuO4DlHNwIyYXF64yKGp6y3rQ0JCtsewRRLvAf6NlPJRKeVZKaUN/CLw3NAjC9k0juNg9QOUYwFBgALwez1FHVegahqu79Ppdu/oAn9//Uk3jOseq9Vq5FZydK0uq/lVXNclnU6Tztze4HQjdMPA9YOSfcuTROPJjZ+n60xMTBCNRKnX6oGZois5d+FimEWFhOwQwwaoXwc+es19nwT+fMjthmwBy7IGfVDStdENnbm9c3zoRz/EgT1TADRdiVAEiqLdcWfdYIpPrlONACiWihSKBTrtQP5ICMHExMSrKsaq6QaeDD7LrntVkHYjhCLIjmVJpVO0W226tk291eWZZ54JVC5CQkKGYlsBSgjxbiHEu3s39/RvCyEeAk4Cmzo9F0LsEUJ8UwhxWgjxkhDi7/bu/0UhxJIQ4rne5Ue2M843C7Zt0+5JHUnXZmRkBDNi8t73vpfZqTEAmgM1CRXP5472Qg0yqF7gkUjyhTzVapVmo0mpVMYwDCYnJl51n6agoTkI4rYvidwkQPVJpVJks6Moms5yoUSxWOTs2bOvOffikJDXG9tdg3oCkL3Lh3uXtZzf5HZc4JNSyu8JIZLAs0KIx3uP/Ssp5a9sc3xvKlzXpetJ0K8GqD4JIzgHadoSNaKi9g6+dzpAuZ5PUjeC4LSap9FsUK/XqdfqRKNRRkdHrzNafLXQDYOWY2NGY5uWNIrGYuzaPcv5F1Y4f/48e/fu5ZVXXgkzqZCQIdhugFogCE57gQZQ7t3vAVcI1qFuiZQyB+R61xtCiDPArm2O6U1LUCQRHEh912Jk5GqPUcIIDvr9DApVwfMl9Xp9R8fg+z6Li4vYtn3dY9VqFceXaKbJ6upqoArRy55i8RijI6OvynrTjdB0g3anSyyztdL29MgosWSGZrPOU089xczMDBcvXuTBBx8MCj5CQkK2hJC9+fZtvViIeeCzUspfGnogQswB3wLuBn4e+DhQB54hyLIqG7zmZ4CfAZicnLzvC1/4wrbeu9ls7nifzZ3kW9/6Fp/LzyIT45S+/mneemSWBx54AICyo/HH5QwZ1eHtkSVWFxdIyDYn7zrIPffcs2NjKBQKvHjmlYFo7bXULElmei+eDLK3drtNNBolmby+CMG2bAzz+oKKO0Vh+QqNSpGxmVlSI1sT1Z0/+yKm2xqcAKSiBm85foS3vOUtr9sG3tf772Mt4b68tujvw0MPPbThKepQZeZSyrlhXt9HCJEAfgf4e1LKuhDiU8AvEWRpvwT8v8AnNnj/zwCfATh58qR86KGHtvX+TzzxBNt97auNlJLV1VVE2Q/mXF2L3bt3c/DgQb7/ve/zjW9+G+XtH6Nh+xw6cQhdQMRtcujQoR3d5xdeeIFiR+LoCeLx6380zXYHM56gWq0SMSMk5hJkMpkNtgTnz5/n4MGDOza2rbJ3dg/1aoXR8cktGztOT05Qr5RwXJeV5SVWL73M1NQUU1NTHD58mHj81mtarzVez7+Pawn35bXFrfZhywFKCOEB/1pK+cne9Y2QUspNbVsIoRMEp/8spfzd3otX1zz+H4H/sdVxvlkI7N5dFCOOD7zvPT/I8ePHgaAYobi0wATgKQZCBB5Jdtfd8TWovjXG3gNzpK/JOgrFAo6oUa/VaTaCM6YbBafXArphkp2Y2tZr48nUQAQ3lRlh+dI5Ll68yOHDhzl//jyHDx9+3WZSISF3mu1U8QmurhiIG1w2tV0RnJ5+FjgjpfyXa+6fXvO0Hwde3MY43xR4nhdcRCDXc2DfLGNjQeVeOpUG6Qe9UEJgyUBNwu55Ke0Ua60xrrXQKJfL1Gq1oCCiXicej5MZee0Gp50kmc5gxpO02x3m5+fpdrucO3duw3W6kJCQ69nOFN8+grWh/vVheCfw14FTQoh+c+8vAB8VQtxLMMU3T6BYEbIBnudhuz5SKAgk6poZqVQ6CBZet4kSSdD1+oKxgZqElHLLU1gb0Ww2adsuhhlDW1MmXqvXKFfKtFqtoFovFl1XYfhGR1U1zGic5MgIrVaLy5cvMzc3x7lz5zhy5MhtkXAKCXkjseVfiJTy8kbXt4OU8jtsXL/11WG2+2YicNMNeqB0sb5AIZUKApTfaUBmipYjiRoGrucHArOWNVDiHoZqtUrHdtf5O7VaLQqFAp1Oh0qlghkxyY5mX1PVencCMxpFKhqpVArHcbhy5Qqzs7OD6b7QmTck5MYMa1i4VwjxmBDilBDi4ppLKBZ7h/A8j7YdBCjtmv+maZpEIuZA7qjU7AZ2FYqCKwPr950gmN7zSSSDUuqu1R1YppdKJQzDYCw79qYLTgBmNIbl+vi+z8zMDJ1OZ+AMfOnSJYapog0JeaMz7BzDfwXevsH94a/uDrHW7r1RKfLYV3+TX/iFX0BVBLphkk5naHaDQFRudjgYV1GUQE2i0WgwPr6xL9OtaDQaWFag+1cul2lbLuPJJK7rspJbwXZsioUiqqoyls3esgm32vX41uUu7957fUb31GKX8xVncDumK/zwwSiOB394sY11TWm7rgreNxclE1H4g/NtatZ6YRNFCN62y2T/iM6fLXYxVMF907dHXsmMxOh6bWq1GhMTE4yPj1MoFLhy5Qqu62KaJrt3774t7x0S8npn2AD1FuAU8I8IGnZD7jC+79PoBgdvz7HotDssz5+n02pw+C33kU6nqbVrAJTaHqpmIJTA+r1Wq23rPWu1Gn/0zSfoOleLODuORyyeIJfLDYITwNjY2Dq/pRvx9LLF6aJDVBfrFjYdT/LE5e41Zzwe+zIabUdyvuxuuL2MabF/ROfFgrPh454vGY+pPHm5iwDeOmWg7MB63LWYkShWvUWx1qL67HPMze4inU7z7W9/h8nJCR566CFM09z2iUJIyBuZYQPUHwIpKWVYBv4q4Xke9U5QFSYdG13XaTdqRDRBu1EnlUriXsgBULYVNFXDMCN0bJdyuXyzTd+QYrFIteVQ7ErMSFAyvWtummK5jGVZlEolXM9lfGx809p6q80g2K00PfatccFYbXlIYDSq8MiBGGdLNs/mbFaaHu1e5vTOPSZ708H75Fse37jUYaXlEdODOc/jYzr3TgUZkuNJvnimxWrLY7kZBDcJtB05UN3YSRRVZXLXXirVEl67RaZaZXx8HF/VWFpapl6vc+XKFSKRyIZNyyEhb2aGDVA/BzwvhFgi0N/rn1JLKeX7h9x2yCZwXTfIoARIz8bQVHRFENUEnXaLVDqNW3sO6Xu0hYEvVMxIlHa3QqVynTjHpqhWq7Qdl917DzExE0xPlctlypUy1WoVq2sxMhoI1m4GX0pWW8FXJ9/ykGvahFZ6gWtXUmM2rSGRQYBqXV17M2qLLC+XqNfqge1I6n5W6g6dRhVIMmlY7E5GBwUJKVNQtyRn1mRXTdsf6BbuNBMzuxmbmuH0s39Gqx1M98WSGdp+icuXL3Po0CEuXrzI0aNHX1Ul95CQ1xrDBqjPAOneZW3vUrgGdYewLIuW7YHZy6BUhYgGpiqoNxtBL5Tv4dby6CPTlCxBJBanWituO4Oq1Wq0bY89qaAootVqDcrJm80miWRiS4oJpbZPrxARx4e6d3VKcKUVZDlTieC+yXjwlc23PHwZiOP+1q99mrVfuewjByExQtmPIRT4b5/7FL/brfOJn/4ER44cYSquUbccXimvDVC39yurKApGNIbl2oE5ow+ZkSyu67K4uMjc3BwXLlzg6NGjYWVfSEiPYQPUu4El4D8BoUvbq4Bt27T7Acq10BSBqSqYmqDTaHLPPfewb98+nm0kOFOBYhemTRPHl9QaTVqt1paCieM41OsNHF8SjcWxbXtQsdcvJ8+kt9aIu9JaL0hSda5+LftTfwsvPcNbxh4gouuMRBQq3SCiefU8154POdUcamIEoaj4joXXKOEBMzMzQBDsXik7+Gte1rRvv4FjLJ7AahXpdDp03aDYY3x8nGazydLSErOzs1y6dGlgNhkS8mZn2AD1BNCQUv5fOzCWkG1g2zadXp2AdG1UBUxNoCkCIV0iEYNUejf5nMWZSrA2M5vS0QwTy5WsrKxs6YBYq9XouB6xntNsbiWH6zoUi0HFXnZ068rkK721oKgm6LiSSi9AXVnKUWhFkFLy7a99iQPjCd5yzz1MJdRBgMpoDmOHDwcuvOk0mq6xrMZZ6W1b61ZJJBMkk8nBGk8/G1vL5VyReyd33dZS+GgsQbNeQEqJ7ft4vkBRFKampsjlcoGmohCsrKwwNbU9qaWQkDcSwwaoAvDXhBB/CLzM+jWoTw657ZBNYNs2lte3e7dRRRCgUqkUZqNMp9XEMCODg/JK00Mf01F1A8vzWF1d3XqAsnwSyVFW86s4tkOxVML3fSYnJjdVsXct/XWmExMGTy9bFLrwuV/7Nc4sVRl93yfwannwXZ599tlBgDpTDKbn3nPfXZz44beu296lqsNvvRSYBd53ZJb3P/JP1skLbRSgvvfiyyx8+3d5+IMPc+TwkdsSqKLxBEUXLA+kDKYzbdtmZmaGbrdLpVIZ6PTFYrFBo3VIyJuVYQPUX+/9/QDwQ73rgmDOJQxQdwDXdbH94GjqOx0MBeKxGJlMhshqhXazQTIzykRcRRFQ6vig6BhGhLZdZ3V1dd32pJT4/o2nu/oFEqrv02q1qFar2JZNNjsaNAHfgpeLNsuN9VN6/QKJu0YVnl4OpvjaTBE/dgIIpuyOHj3KyZP3AzAVvxpg1l7f6L7+dcO4at8R0xVShqBuS9xmCS2RRYkkWCg2+PzXvsveJ57kJ37ixxkfH2ep7g7Wqo6N6Uwltv+TicTiOL6k4/oIoeBLOeglGxsbo9VqsbS0hK7rXLp0iWPHjq0bd0jIm41hA9RjhAURryqWZWHLYFFd2l1MTZBIJEgkEpiqILe6TGl1hcnZOVKaQdVRaXgaZjRGvRHYk/fxPI8nn3ySeuPmQrLVRpt41EXa3qAoIhqL3fQ1AG3H50tn2xt+YeKKy3/61V9BnnwULZklfuTBwWMP/cBR3nvsocHtyYSGpoCmCLKx6wsKorpCNqpQ7vjMJDfO6HanNE4XHU7uHeW5EqjRFMn7PoQxtoeLTz7GL//yL/Pe976XhYl3UrWCEV+qunzi3u2XgvcLJRpWh0QqjdOu4TgOFy5cYHFxEc/zWF3Nc+rUi7zvfe/FNE2OHDmyI3qJISGvR4b1g/r4Do0jZJvYto0rgn+j73QxoxrRaJRMJsN4JkHC7PCvPv05VtuSkYd+CnPmMF2pEDcjOF5QKNHpdIhGo1SrVfLlGufzTcQNKsk8z6NtuaRUnXwhj2Eamy6KWGn2epoiCvdMBpmBLyUvv3yG09/5Ol69hPpnX8ScOkBmZIQTJ04wmc1w98R6N9qIJvjoXQlUhRs21/7E0TgN22ckunGAev++KIezOtNJjedKdRJj01huMD59dBftwjx/9OSfMP6jD6IKiS8FhZaH40l0dfsBIzsxTSmfIzsxTe5iDcuyaDQazNdcfBRsfQS/Web8+fOMj48PtPtCQt6MbMcP6kc38zwp5Ze3PpyQreI4DiMT0xSA97/nXehL30dVVTRN4+TJkywtLRGPRqDVxu9JHrUcSGkqmm7SdXxyuRz79+8flI+PT+3iwNG7rnsvKX0Wl5bodDqsrq6iKApj2c0LwPbXmvaPaLxtdyBpJH3Jqa8906vGA9Ntcv+MwY9+6P03lUfalbr5VzcbU8nGbrweFjcUjo4ZeL1Svq4H9CxLUrsO0D77J+gjQeeEU8kxMb2bYscn3/bYldz+eV12YorsxBSObeH6kk6ng+16SKFy931vp1LMs/zKC1SrVUqlEgDJZPJNpQIfEtJnO7+032Nz03pbXy0P2TK2beP1PupsOolTjqyzcTBNk0wqCYXmQDS2afsYcQNV17E8j3w+z/79+weq5JmJjRfnC4UilmVRLpfxPI/x8fEtFUX0A9TadRyhCP7qR/8qv/Irv8LMrhk++tGPBtVst9Du2ylURRDTBW3n6lc6Ob2Pd//kX+EPXgzW5w5MpognVYodn5XmcAGqj6Yb+AQZqeVKoj0XYk3XMaMxdN2nUCgQjUaZn58nFouFTbwhbzq280tbYH2A2kNQvVcCsr1tDmXDEbJ5XNfF7YnSq8LHQ65r9NR1nZFMCimX8TpBBtW0Jcaogd4rlFhcXAR6DbiOx67E9QGqVq9RbwSmg91Ol0wms+UD5qDp9prChkQywd/5u3+HkcwIQhHXFW7cbuLXBKiaJbnngQe4HKtxqQHHZyewXMmLOIMgOyxCCDTNwJM+lieJJoMApesmri9JJpNomsby8jJzc3NcvHiRI0eOhE28IW8qtvxtl1LOSSn3SSn3Af+eQCx2Sko5Q6AmcYrAJTfkNtO3e3d6GZQqXYQAdU1WY5omo5nUVWddoOn4RKNRzGiMWiuYrrMsi3q9ge1JYon1hQDtTptiMWgwrdfqxOIxEr0D6mZpOz51SyKkx3PffeK6x0dHR+9Y1nQtyTUSR33LkpWWR9kOPsepuLqmTN9l4fICTzzxxNDlQZqu4/pguZJYL4PSDQPPD048du/ejeu65HI52u324EQiJOTNwrCnY38feFFKWQGQUpYJ7Nl/btiBhdwaz/OCANUrMxeuHbjqrglQhmEwOpIB6eO1AyPkpi3RNI14MknX8WhbFufOnaPjeERjiXVn6bZjs7Kygm0F3k66oTOS2fp6SK4elGpbpSW++j9+n+efe36YXd9R4msC1JFsUCo/X3WpWT6aAtmYwmRcRQDFts/nHnuML3/py3zhC1/A97afUemGgetLut7VKT5V0/AROK6LpmlMTk7SbDYplUoUCgWq1VCwJeTNw7ABygIeFUJ8Rgjxvwoh/iPwk0B7+KGF3Arf93EcB0cGAeqz/9+nQcp1a1CKojAxPo6U3qBIoi/rE4vF0DSDVtfh9OnTtG2P+JrpPcd1WF5axnUciqUiiqIwPja2YabTsHxeLtobXk6vdvnKU2cBcCuBsvoLp164PR/KNkj2VMwzEYW96eCzO5UPGnsn4yqKEOhqUNIuAWfsCOauYzy3WOPTn/11up0u1a53ne/UrdB0A8uTSKFimFd9sILA1SuAGRkhmUxSKBTodrvMz8+vazoOCXkjM+xq7z8D/h3w073b/SPX/zPkdkM2ged5VGp1hDqO9D0MTaAIsS6DAshmsyhI/G4TKX3ajoLnS2LRWDDN12ywtLSEjGeZnJgDguKLXG4Z27YoFIp4nndTpYjfPt2k0L7JATodlEq7lWUefPBBPvzhD+/IZ7ATJM3gPG06oTLdK+Dor0mtVZ2YTmgU2zaJt3xgcF9+4RS/+u8/hf6un0JTBX/rZGrTvlK6YVC1JdH4+ilVXTfwZId2u8358+fpdDrkcjnOnj3LkSNHiEajpNNprly5wr333rtpS5OQkNcbw/ZB/QchxEvA/wTsIhCO/S9Sym/uxOBCbo7v+5QbQbIqHQtD11GuWYMCAq+hWIym5+J3W6jRJC1HkjJVRsbGufxKHlc1UepFZu+OU6vXKBVLuK5DoVjEcZ3A2+kGShFd16fQ9lEFHBy9+hwpfS5dmh9Yy/vdFvfvH+PHf/RDryn797vGDSodn3unDEYiCu/aE6HQ9tAVuH/maiHI23eZ+FLi+pBbzVPXRtDH9lI49xSjHuBJyh2fsZuUt68lnkyxuuQzNpJdd7+mG7hOm9XVVRbzZYptF8czqVZrOKfPMDc3x5kzZ3B9mJiYYO/evTv5cYSEvGYYul5WSvkk8GT/thDiHiHEv5BS/m/Dbjvk5nieR6XRDrygXBvDNBBcH6AMwyCZiNGo2fjdBmo0SdP2SZkKe2bnEIqCEILpqRmKpcCCo2886Ps+Y9mxm3o79SvbJuMqP340UEb3PY/PP/YYSy+cGjzv4Ycf5pFHXlvBCcBQBe/bd9WE6l2z19vOQ9Bb9aHDwf7JI3P8yp9WIJbCmDo4eM7ZpTJjhzbnjptIZbjrvrejqut/hpph4FqSSqVC1/VJZqfITkzzyukXqNWWWVxcZGVlBREf3bYrckjI64EdqVkVQuwSQvx9IcQLwPeAn9+J7YbcHM/zqLcDLTfp2oMMqtlsUiwWB5p6hmGQTsRRBGhesH7R9z9SNZXJyWkURaNQKlIqlcjn8xTyBYQQTE5MEolufMDuc7W/KQiM0pf81m/9NqfWBqcPPswjP/zIay44bRchBDOpIFuM7bsqVvvHT7+wpWq7a4MT9Kb4/Ks9Uol0hkgsxsTkNKgmr7zyCs2OxZWVwqCZNyTkjci2A5QQIiGE+LgQ4o8I+p7+GXA3wSHoyZu+OGRHCAJUEHB818Y0DVzXZXl5mUKhwMpKYDphGAaPPPIwP/dzf4977zoMrPc/ikQjjI+PY5omtm0jpSSTyTA5ObkpAdhrA9Tvfen3+PM///PB4+95z3t45IOP7MxOv4boNxwrsatSTDIxzqf+w6co5Avb3m6/ug+g60qisaDCLxqPE0mmqNVqrBYrtC2Hixcv3lTcNyTk9cy2pviEEF8APgREuHpO/ALwFuDLUsq/tDPDC7kZAzddgjUo09DxemXPIyMjVCoVRkdHMU2TmGnQ8lwSZvDvutagz4yYm7Zov5a+4WD/gD01NYWiKPi+z9ve/jZ+7Md+7A2TOa1lIyV1PTPF7OHDjI6Obnu7mq7jSXB9iVA1jF5DdDSexJUKkyMjXFip4PsdiuUaCwsLzM3Nbfv9QkJeq2x3DeqvELQpvgh8HvjvUspLQggfCE/n7hCWZdEamBVamIaB7/vous74+Dj1ep18Ph8Y+SkCx7ZJJIOkeacszruuT7Ub9AuN9ZTF3/GOdzCSGeG5557jIx/5yBsyOMH6Cr9sVKFru7Qw+JEPfxRV277SV19NwnIlkdjVhmjDNEHRMCIaqtGl6zjUOxZnzpxhZmYmtOYIecMx7BrUUeAR4BEhxMwOjCdkC1iWRdcNAo10baKmied5RCIRVFUdeAxJKVEVcB2bhB78y1vO8OcRjie5VAki5ERMXVdeffTYUR796KNvaGme0ahCv8d3KqGyKx1kOgsNSa3rU+v6yG2cB/TVJLobqHpEYnG6rsSIxhkZmyBfrlIul7l06RJyO28WEvIaZrtHj79BYPeuEhgV/jvgCkFWNS2E2Jz/QshQWJaF7fe8oBwL09SRUhKJBEUNfYtzz/PQBFTKZfJXLgFQ6/vEb5Ou6/MfnqnzpVeCMvfx2O1LkzzXZWXxMo5tXfdYvVqhXAjW2qxuh9WlhQ3XZMqFVerVyo6OSwjBRC+LmkpclUP6xqUOn3q2zqeerfPtSoonnnhiSwoQfTWJYP0pvu6xWCKowNQjUXbP7qXr+Fy5coVms3nHNQxDQm432wpQUspfk1K+H9gL/EOCqT7RuzwAhKJhdwDLsnCVoIhBOha6pqEoyiBA6bqOEALHcdB1nSf/+I/4nXDRhC8AACAASURBVN8MZBLLXTmwmtgOi3WPjisD7bp2hdPf/O+3TYanuLpMKbdIfnn910pKyZULZ8nNX8DqdlhZvExx+QqVYn7d82zLIjd/noULL+94lvHAjMmelMqxMYNjYzoTcYWUKUj11vryts5X/sfX+PSnPkWr1dr0diPRGJbHdRlUPJmi6fjEk2lSmRG0SJxCoUi1WmV5eZl2OxRxCXnjMNT8i5RySUr5y1LKe4B7gH8BLAPRm78yZCfodrscOBL4Nr3jgZPM7tkzCFD9Xqh+ZV5fk086XdxGCR9BsbP9ab5+5V6kfIH8V3+VpTPf59/+m3+LYzvD79g1dFpNkoag3Vrv9GtbXRTpEdUEnVYrsLc3BJ1W45rXN4hoAg0fq9PZ0bEdzhr8tRNJEobCSFTlE/em+Fsn0/ytk2lGDR+EQMtMkc8X+OxnP7vpz2fvoWPsP34PurG+cCWZHmHfkRPMzO5DVTXSI6Og6czPz+M4DvPz82FVX8gbhh1bIJBSnpJS/gNglmDaL+Q2Y1kWVk+Hz9QVBIEOn6ZpgyoywzCwbRvTNMmOZsD3cauBHt5Kc/vTfP3XLp19bnDfww8/vKmy9K3SabVImypWu7Xu4NtpNTFVgakJmvUKnmOTNNXrAlmn3SKiCUxV0Gnf3M5+J9md6WWyo4Hx4fyleR77jcc2JTBrmOZ103t9Eqk0ak9vMZZIEEtmaDabLC8v0+l0WF5e3qE9CAl5ddnxFWwZEEod3QFs28bprUFp+HiuM5jeGxkZQQiBaZo4joOmaYxnR5HSHwi2rg7hbbRYC9aD+tt6x4Pv4O3vePswu7Mhjm3huzaGJtAUidW9mgF1Wk3MXuCplopBsFLB7rTXBbJ2szEIZHcyQPXXpPadeNvgvpdefIn/9ju/M7RVR59oLIGHQjQapdVqUalUWF1dHchLhYS8nnnjlli9CbBtG0cG/0JdePieOyg17juw9m8LIZgcy4KUOL2gkttmgLqyWqLrq/iOhdcsM7dvjp/48Z8Yfoc2oNNqYWoiqESUHqVCnlq1RqVcYWV5iXa9QqtWpl6r43RbtNtthOfRXbPeczWQKXSadz5AyXiW977vvYP7v/tn3+Xrj399R94jGo9jeYFqfTweZ3V1Fdu2mZ+fH/TEhYS8XnlVA5QQYo8Q4ptCiNNCiJeEEH+3d/+oEOJxIcS53t+tGxC9Ceh2u9S7gZJEp1lHEBRGqKqKqqpEIpF1rrepVIJIxBhM8eVb3pYLJRzb4b9+5RsAuNUc6XSKj3/840P1/dwI3/MoFfO06xVyuRyNSol8Lkej2aDdadNqNBC+G3hduRZOp0m1WqVZK3Hx4jkKhQLlYrGXgamYWjDdd6fKsSfiKgJJqePz8CN/gfvuu2/w2B987Q946qmnhn6PaCxB15M0m81Bg/Ty8jKWZXHlypWhtx8S8mryamdQLvBJKeVx4O3A3xZCHCeoDPwjKeUh4I96t0PWIKWkVqtRqgYZwTf+4KsIJLquD+wXIpEIhmEghEAIga6IXqGEhdss40m2Vigh4Qtf+AJ1Pwh6XnWFj3/8p0ilrreIHwbbtikVSyzncuRXVlClx+zsLJPZDLFYhN27djOWHWV0JMW+vbMcPXqUXRNjzO2a4cSJE0xkM6iA53qsruRoVkp0Oh2k56Hir5smvJ1oiiCleUig0PF59NFHOXz48ODxL/72Fzl//vxQ76FqGroRwXJ8bNtmamqKTqdDqVSiVCqFBochr2u2rCQhhPjYZp4npXxsE8/JAbne9YYQ4gyBbcePAQ/1nvZ5gp6rf7DVsb6R8TyPer2OogfJpS5kIAaraesClBACXdexbRtNEYyNZVkp1XErObTEKP/lVIPphMZHjsc5X3H4xsUO3g0SDNu2sXe9l7geBKgfODzL3rlbWz3YloVjW8STKXzPo1mvkcwEa2QAruNQr5botrs0Wk0W5+fBtYlGY0RNnT3pSU6cOMHzL7xApwWu1cGzOuyaGOPo0b0kk0mqXZ+RqMrx48fJl2vkuoKp6Slcq4VIJzAMg2azSaPSYv78K4yNTVxnvBiJxYkndzbYjmguNVfji6ebqIqAH3iUiaMdXKtN/anf4Td+4zf4x//oH6MbQQ/bV15poyjwFw9tXCCxEdF4HMuqsrS0xNjYGKlUinw+j23bKIrCiRMn1plYhoS8XtjOt/bX2dwS7y0D1FqEEHPAW4GngMle8AJYASZv8JqfAX4GYHJykieeeGIrbzmg2Wxu+7WvFo7jcOrUKUTm4eAOz2J5aYmJTIJnn312UNG1sLBAoVCg3W5TqtQw9WBNylp+GXP3cSxPMF9zeebly5xuxWjYN5HLETpKJAh+wrPZP2luKgNYvHgWu9Nhz8Fj1KslasVVxqb3kBodA2Bl4RKV3AK+a6MqCqqmUfKagMDQdZoijm3beK4LnTYXX/guAFENlpd14vE49cIySjoQUrU7TaoVl0K+wNLCAkqziJuJYds2jVKO3PIS53rl+JGISV+LqeurzB65e1AhtxNMqIJ5TCxPMIj8RhTNiBLfdy/vm4tyeeEyAG1P4XQxqL48zHk2MC7ekGqpTHN1kQuX5okqPocO7ufixYuUSmXuvvsuTp8+za5du7a9D6/H38eNCPfltUV/Hx566KENH9/OL/Fb7FgNUoAQIgH8DvD3pJR1sUYyR0ophRAbvp+U8jPAZwBOnjwpb7STt+JmH9BrlU6nw1e+8hWEElTtxQyN3bt3kUgkeNe73sWePXvwPI/nnnuOfD5PsVgkXyggM12+99IrWFdeopg7z4Mf/4ecq0q0kWkazS4g+fg9CZLG9bO/nufx+1/9KvnVVf7m3/gEpjFxy3H6nke3skpsfITMxBiG4jMR11CTI8zuP0i9UWfl8gUOzIxy9OB+RkZGOHPmDO985zsHQreTk5NMTk5y3333sby8PFhD0jSNgwcPous699577yB7UBQF4/wyh+46juZ1OTB6jJM/8FYqlQqXLl2i2WxSqVTodDpomsbY2BidTofzhTaze3YTjSdusVdb4Px53nl3ZqBODjBfdfnKuTZzJ+7nB996dXn1bMmGYtBou2vvfuIb/A82wpubI5+boVGrkMLi0KFDxONxnjtzjng8ztGjR5mbmyObzd56Yxvwevx93IhwX15b3GofthygpJQ33to2EELoBMHpP0spf7d396oQYlpKmRNCTAP5G2/hzYnneTQaDZSxIEBpwkcRrFuDUlUVTdMG61CKEJi6xt1334VhmBw+chgvqXGu6nCu7NB2JBFNMBlXERvalit89MM/hmM76MbmvjqddgtDEUR0QafVpNNuMhNTydWqrOZXsTpdFHz27prm/vvvZ2JigvHxcX7oh65vpctmszc8yO7fv39wPZPJENPzlIt5hHRJJ0fYv38/Ukr27t1LLpfDtu2BPJBt25RKJQQ+jm0T3fzs2qYwNYG5RjF3Nh18dmUrqE7sf9Zry/67riS+Se1XVdOY3jOHrhu0VudpNpt4noevx1lZWaHdbnPlyhWSyWQoKBvyumLouQwhRBw4AYyzRrdaSvnlTbxWAJ8Fzkgp/+Wah74M/M/AP+/9/dKw43yjYVkWjVYXMakhfR9NEeiqiqIogwAFwTpU/7aiKKgKPProTw6aQBfrLlxxmK8GjbdTa4OTZEMl8q004wYl3hBRFVYqJVTp49tdCit10mMzxGIRxkbSTExMcNdddxGLxbh06dL2PpQe6XSaqKGSzy0R1VXS6cCvSQjB2NgY2WyWfD5PLpcjHo9TKpVYWFigVq4SH6uRGtm+VcZmSJoKcV3QcuRg7QxgodJlMN14o4XAmxBNJCgtQaVSoW1ZqGYc1+oyPz/P0aNHuXz5MocOHdrJXQkJua0MFaCEEO8BfhsY2+DhzdQdvxP468ApIURfkuAXCALTbwshfprADPGvDDPONyLdbpdm3wvKtdBVFW2DAHVtL1TfdqMfoCbjKoKrc7YDC4lexd5odpSHP/Dwti0zOu0WpqZgauDaNtgtyo0mMdMklYxj210mx0Y4ceIEsVhse29yDZlMhpih4lQ6jKZNMpn12sVCCCYnJ8lmsywuLiKEYN++fVwpvkCxUCCaTJPJZG6rEvtUQuVCxWWl6TESVblw4SIL5QiKGXwGfZX6rRCNxnF8GSiMOBKhQDw9MrBdURSFQqHA+PjmLOlDQl5ths2g/jlB5tQGYkAVSLBJsVgp5Xe48aHv/UOO7Q2NZVk0e5YZ0rXRNBVNU1AUZV3FlmmaA9HYIEAFtht9dFWQjSkU28G2phIqSPjq177K008/DUCxWOTRn/xJFHXrvU6dVoOELhAEvVqaZzE+msTUE3iuQzIWIx0XjIzsXKtbKpUiqqsIEazN9TOoa9E0jbm5OUZHRykUCkyOZ6lKg3a7jW3ZZLPZ2yLdBGsCVMvj2Bh89RtPotz944PHS9UGB7aYySmqihGNYXk2lhdMHUo1mPKtVCokEgkWFxdJpVLr+uNCQl6rDHuK+Bbg94H/SHASPgk8C/yrIbcbcgssy6IzMCvsBaheg+61GRRcVTZXhVgXoLqdLn796hLfRFTwe1/6Pb7x+DcG9ymKgqJsPTj5nofd7aALH8uykJ7N+GiKAwcOMJpKkErEcawuMUO9YRDZDpqmkUolMXWFqK7cctupVIoTJ06QTiWJmAbj4+P40mc1v0q7dXvUwafiwUnEStMDAT/4I+uVOJ74zp9tS3g3GktguYHZYTIziuVKDMPAMAxWVlYGgrIhIa8Hhg1QCjBPkEEBpIELwD8ecrsht8CyLLpOz6ywZ7XRn8q7NoNa+1dTwLGDAPXUU0/xT//vf8rlF58JHsPjc5/+Vb715LcGrz967Cgf+cubd8X1fT8oByeY3lPxaTQaGIbBZDbDaDrBPffcw97d0zTrNaxum5ip73izbyaTIRXRScSim5o6jMfjTE9OkEjEiUaiTE1OYhom5XKZ/OoKnWYT27rej2q79KdSlxouXzzd5JlC8AFLGWSy9bbNY196nG9e6mxJ7SMai2N5Pl1PMjo+RdeTtFotdu3aheu6rK6uht5RIa8bhg1QKwTrT/MEh7DnCdaLdl73JmQdlmVhJHqL/76LaegDmaO1FXhrvaEgUDdwehmUQNButbHzl5C+T/PKyywtXp2dveeee/jpT/z0lmSMli9f5Mz3n6bbadOo12jVK5imyeHDh8kmouzdsydYbzI0dFzSUX1QGr6TpNNpsnFj05lZJBJBVwW6qrF7z24ikSjj4+MoSE4/+11OPf0tzj7/53Tam/d0uhkJQzASUXB9uFBxB4oeIyJQuVCMCEv6Lp5atjhf2XwmFU0kaDsSKVSS6Qy+UGhbFkIIstkstVqNRqPB0tIS3W53R/YlJOR2Mewa1O8SmBb+N+AXgene/Z8acrsht8CyLI6/9X7+xIKDe3czY05hGMZ1igFrS81N00Rrdej2DrIPPPAA5UqZxx9/nPLjn8LvBArYmq7x8Ace5n3vf9+WA0e9WiaiQa1cJrd0BR2fw4cPMz09TSaTYd++fSiKwtGjR0mllhFCcPDgwZ35UNawe/duyuUy+/bt29TzDcNAVxVcx0LXdHbv3s1qfhVFSGZGk4hujUbLp14u3dAGYysIIfirdydYaV0tLY9qglI7ytcudBB6BDUamBW+dLnAkezmGm1j8SSpsSkisThCiN6UX5tms8nY2BjNZpOVlRWi0Sjz8/McOXLkBi0FISGvPkMFKCnlJ/vXhRAngB8EVqWU3x12YCE3p9vt0u1bbQgfRcggAG2ggtAvlIhEIij4uLaF57qomsYjjzzC8WPH+dM//VNsx2Z8fJwH7n+A7NjWmzod20K6DjETlpcWaLeaHJoYY2xsjEOHDq3LZg4ePHhbAlMfwzA4efLkpp/fN3pURB3HtjDMCNNT01w+9zIjqTjZXWOceuUiS0tXGJ2cXrfOt12SpkLSXH8C0LSDTCqRyeL2AtTphTzv2RvZVKOtEIJdcwcGt2PxBFatSbPZJJvNMj09zfz8PCsrK2iaxsrKCtPT0zfZYkjIq8dQ8ypCiItCiH8EIKUsSym/BNwthAj7lm4zlmVh+cHUm4aLAjcNUKZpDvyhrjXum907y6MffZSPfexj/PAP//C2ghME1hi6IqlXSrQaDWKmSTJmcs899+xoEcTtwjRNNFUM1uggmBLdPTXBgQMHmJkcp9NqUcgXsNc8ZyeJaEE2k5meRai9/rXUJL/2uc9tr2giHhRN9P2hIpEIY2NjNBoNarUauVwutIkPec0y7MT/HHDt0eytwF8ccrsht8C27UEGpeMhRHCAVTcoBV9bam4YBqYK7dvgi9RuNujUqyi+SyxiEI/oHD50aEdLyG8nwTqUMiiGsK0u0nOYnhznbW97G6lYhEQsgi898vk8VnfniiYGY+gFqOqaTStmjF37j2yrFy0aT2D17Dj6ZLNZotEoq6urg6q+O2VBEhKyFbYVoIQQfyyE+OPezb/cvy2EeAL4GBDaed5mWq0Wq5U6AI1yAVURgyKJa+kXShiGEUz16crOO8tKWMktge8wNpYlHjGZnsgOJVJ6p4lEIuiKgm0HxQPNep1orwQ+k8lw7NgxEhGDVDyOrukUigW6nZ0tNOgHqGuFJO57zwe3Na1omBE8odCxrEHWJ4Rgenoa3/fJ5XKhTXzIa5btZlAP9S4S2L3m9ruBOPCVoUcWclNKpRL5ShBkTj//fbReg+5GU3zRaBS4OgVoqoEu3k5SrVapV6uMj6SYnJxkenyUsUzqdTG118c0TXTt6hRfq1lfJ5U0NTXFnpkpXMdmfHwMXdcplop0OjvnLxXRNv5JrmzT/bhfKNF1WWcDb5omExMTNJuByePKygqt1s5UKIaE7BTbLZL4KYIJh18DHgf+S+9+D7hCoHgechupVqsoZnDg1HDQ1CBA3SiD6q8/aZqGrrCuUGJYGo0G1UqZiKExNpLh+PHjvDy/RMxQr5MZei0TiUTQlKtTfK1GnbR5dR8ymQypmIlQYpimyfj4OMVikVKpNJg2GxZTZZ30VNpUqFk+50oOWs9/YySicCgtNq1yEY3HsetXCyX6jI6O0mg0WF1dJR6Pc+nSJY4fP35bJZ5CQrbCto5OUsrPA/RsMF6SUj6zo6MKuSm+7wdmheYMAJp00bUbByghRM/7KLKmUMKj026SSG09gNiWxYXTL+C6NrblUK/Xeo24aWZmZjh69ChXlleI6NqON+DeTiKRCLomWFpeJJ9bREqYnkkOMqh0Ok3M1LiSK1LO5ymVSziOQ71e55zrkEymMM2rauETM3u2PAYhBKYmBlp8h0Y1nsnZFDs+3164Op2YOveH/M2PfWRTwSQWT1IurXD58mUWFhbWPea6LisrK7z44oscPXqUdDrNnj1bH3dIyO1gO466/wfwXSnl1wl6oPYKIX7k2udJKf/JDowvZAP6VhsiEigkqNJFU4J+pxsdsKLR6EBNIiiUaNNubi9ANWoVoorDSFyy2iwzmtKZmBghHo9z8uRJ0uk0M5PjJBKJDQPma5WRkRGmRlKkI1czk2w2O1CiSCaTTI2NDqbh3F1JlpaWsDIqxWIJ264wls4SiURwfMgV82jxrX++kTUBajqp8ZdSGvmWh+/5fPfcMiTGWazZPP7443zwgx+85fbiqTQ5dM6XNy7q6IoUjUoT49I8hw8vkclkSCaTWx53SMhOs50M6heBfw18vXf92vKf/gxFGKBuE7Zt02y1UVLBlJImHTRV3HQRPRqNouv6QEw2om2/UKLTaqAjiUaj3H//Sfbt20csFuPYsWODMbzrXe/a1rZfTUzT5AMf+MC6ira1TayKovDud7973eOO43D27Fna7TYLCwtYlsXu3bt5/vnncesWwnS3PI5+oQQEihN70zpHe34Bly+2yDGONjLN1//wq+yd3cvRY0dvuj1dNzj21vtvWqn3ve9+h0IlmK6cn5/n+PHjr6uTi5A3JtuZbP488HTv+mMbXD7PFu3eQ7ZGt9ul1bFQjCBA6fhoqoJhGDfNoGBNoYQm6GxzUbzTatFuVDFNkz179mCaJocOHdqR5tXXAn3l9xspLKx93DAMjhw5QjweZ3Z2FtM0WVpaGhSjWN2t9xitC1D6+v/nu3/gGAD6yDRSwm/+59+kUq5seb+uvUxOTuEiuHTpEpZlsbi4KUOCkJDbynYcdX9qzfWP7+hoQjZFu90eKA74dhdDU9DUQAmheYP+pn6AikQidDodTE3BtbtbLpTwfZ9yqUDG77Jv3z6i0Shzc3M7UiDwesUwDA4dOsTZs2eZnZ3l8uXLNJtNVOljbaPCL6KuzaDWB6jplAF00DKTIBTarTa//vlf52d/9mc3rODcLPFUmkY8TblcDtyFhRiU14eEvFoMXa4jhPgLQojfEkL8iRDiC0KIv7ATAwu5MZZl0fJ66tdOJ7DY0NRBv9NGGIaBqqqDdahIJHKdosRmqJaK2J0WE+PjA+mc10sj7u2kL4gbiUSYnZ0lkUjQrJXpNLfeEtjPoHQlsIu/9rGRiIJQNPTMJABXFq7wpS8NJ94SjSUQelDgUSwW6Xa7XL58Gdfd+hRlSMhOMazU0c8T2LN/BHgHgZL5l4UQn7zpC0OGotvt0ukFKN/uousauqbd0oQuGo2uUzc3VbY0zec4DrnlJeKmxp49e4JiiJmZ7e/IG4xIJDIIUocPH8YQklKpgO9trYepH6CuzZ769K067nvokcF9f/KdP+HZZ57d5sjBjEZxpUIkGkVKyfLyMo7jcPny5W1vMyRkWIbNoH6eoPfpXwN/E/g3vds/N+R2Q26CZVl0ZTCd49sdzJ5a+a2meJLJZCCIqihB6bmm0G5t7gzf931KxRKW1WFydIRsNrtppfA3E9FolIMHD5LNZtk9M4Xn2KzkVvB9f9PbuBqgNl4D6wcodXw/Rx/8IYzJAxiTB/jdbz7NwlJuW+MOGnrjuFIlmUxiWRb5fJ5qtUqtVtvWNkNChmXYLk0T+K9Syp/v3yGEyAK3rn0N2Tbdbpf0+DRFwFQk0WhkUwEqlUqRy+WIx+NYloWpCvLVCudPP3/L96xV69i2RSRiEI9EOHHiRFjldQMSiQQHDhzg+9//Pul4lEuvvMTS5fNk0hnEmlPCVCbLxMzu614f1YPAlLxRBhUPPvdzZQdmHiQz8+DgsS9+f55P7tqeOnkknqDbaLG8vEyj0eDs2bOcOHGCev3/Z+/NoyS5qzvfzy8it8h9qcra9+pVjbaWkGUBagED2Axg5tksxtjYYIHxoufxvMHnvecznuPj8Tz7DDaP7ViAQLIB+SHZmAHZGARCAwIJLbTULfVS3bVmLZmV+xIRmRn5e39EVXW3eqvKqlZ3V8fnnDyVGZFx8xdVUXnj/n73fm+Jer2+1hDTweGVYrMR1F8DNwohYgBCiDhwI/CXmx2Yw/kxTZORnXsBGBnopTMRP6+S+ekEAgEURcHv96OqKh6XoC+okFCMCz7c1TRePUN/UDAc9TIy2Ed3d/crcapXLZFIhOuuu46ED0ZibjQjiyiliAudhGIQVwzSqelzTv/tiLt5VdLDLb3nnrIdiLi4qdvDSNTFSNRFr9aisWxPxbk7h9secygcJa+3OJ6usFCTzBbrPPvss9TrdadNvMNlYbMR1G8DA8CiECIDdGI7vd8VQvzuynuklHLsfAYcNo5pmhintdq4kA7f6QghCAaD6LqOoijs2bPnoutWlUqF+fl5wnt20d3dTWdnJzt27NhUxti1wm233cbx48fp7+8nn8+TyWSIRqMkk0mOHj1KplpG16sEgmeqbfjdCm/dcf429YoQvHnszP2ppME/zEGtafeUOt/61YUIx+KM7bsJy7ITI4wXX0CvLJJOpymXy6TTaZLJ5IbtOji0y2a/ZYZWfirA6avlw6c9d3T8t5gzmhXKJqoq1uWgwJ7mK5VKuFwuTNOks7Pzgp9TKpXo6OhgcHCQSCTCjh07nA6s60QIwcDAAGNjY6TTaXw+H7lcjkajYa8HLpcxqmc7qHbo6++lO19hptRksWIxHm9vcsSnnXJ8kWgMq1Ulm81SLpeZm5sjFApd0yUFDq8sm3VQd23JKBw2hGmamNL+ArJljtYXQQFr2nihUIhCoUCz2TzncY1Gg7m5OVwuF/39/fh8PkZHRx3n1AYDAwM0GnazwUajQTqdRlEUvOrWtj3pDqqnOSg3L774IgMDA23LFvn8QRp6kFphmYWFhbU28bt373auA4dXhM22fP/B6a+FEH1ARUrppP1cQgqFAovZOsQ7WJ6fYyi2/ghK0zT8fj+xWIx8Pk8+nz8rimo2m8zMzGBZFkNDQ2tKEc60XvsMDw/TaDTo6+tjenqa5eVlsOrUtrDtyWp230KlwSPf+h7f/e53Gd8xzkc+/GGUNhJa/IEg6Yxd49VqtdbaxM/Pz19Vfb4crl42Wwf1p0KIR4TNXwIzQFoI8ctbMzyHc5HJZCgZ9jrB1MRLuFV13Q4K7L5GXq+XUChELpfDOm2hfrX2pdFoMDAwgKZpjI6OXrAI2OHiKIrC2NgYmqbR399PJBKhXMhSq5Q3lIJ+IVYdVKrY4NFHvwvAxPEJ/vVfv92WPS0QwGxKms0myWTSbquy0jvqfIolDg5byWaz+N6DHYV5gN8HFle2/8km7TpcgGKxiOK11wpcLWutF9R6HVQ0GsXr9ZJIJGi1WszNzdFoNCgUCkxOTtJsNhkYGMDv9zMyMnJVtcy4knG5XIyPj+Pz+RgaGsKvadRKBWqV0pbYj/kUPCoYLYXXveUdCLcP4fLw3e9+l0OHDm3YntvjRbjcmA0LTdMIBAIsLi5Sr9eZnJw848bGweFSsFkHNQicAPZgO6l3YDcvdLL2LhGrrTYUz4qDWmlW6PV6170usNryW9M0ent70XWdiYkJFhYWcLvdDA8PEwwGGRkZcWSMthiv17vmpEZGRnBhcfTwC6QmT5CaPklqgtGUcQAAIABJREFU+iSLc9M0V9asNoIQgq6VGqmXAjfQ+Y7/TOcv/THajtv4yle+QnY5u2Gb/kCQhhScPHly7TPm5+cxTZPZ2dkN23Nw2AibdVAGMIJdmGsBh1d+OrdWl4h6vU65WkPxBQFQW3VcqrLhzKpEIkFfXx+RSIShoSF6enoYGBhgZGSEQCDAzp07icfjl+IUrnkCgQAjIyMkk0n6O6OIyjLF1DFEeQlRXqKWSbG8NN+W7Ru7vPjdAq8qWBVC9/btxdANvnT/l9aSNdaLPxiiaqkcmVli4uQkkUgEXdfXOgnn8+tTUndwaIfNrno/BbwJ+HfAE1JKXQixCzuqcrgEGIZBxWyiuL3IZh03Fp42HBTYa1Eej4elpSUajQaKopBIJEgmk45KxCUmGo2yf/9+hBBkMhlyuRyxWAxN05iYTlFqQ2QW4Lqkh+uStuKD3mjxiadKK6KygtRcin/6x3/iXe9+17rtdXT1EukZwnT50Ju2MnskEiGbzRIMBpmeniYQCDgqEw6XhM06qA8Df75i50+FEB7gKPDEZgfmcG50XadYt6fyLL2M26XicatrXV83SjwedyKly0RPTw+vetWryGQyLCwsUCgUCIVCdsv3Snu9uk5HcyuEvYISHtRwB1Ypw09+8hOGh4d59W2vXpcNRVUJxxKE/T6MzAyVSoWRkRFqtRqpVIqRkRGmpqac+jiHS8KmpviklNNSyl+TUr4HmJBS1qWUH5JS3rdF43N4GaZpUmmtCMUaFTxuF16Px8myu0oZGBggHA7T3d2N3++nUCggZAtpNamb527RvhG6g/a1Mn7Tz61te/jhh0mlUhuyowUCmJatLKKqKr29vTQaDZaWliiXyywtLW16rA4OL2ezaeZCCPExIcQcYAoh5lZeO7dSlwhd19Gx5Ylaegmfx43P53NqlK5ShBCMjo7i9/vp7+/H7XZTq9Vwi9aWFPGuCssOX3frmn6ioigbVij3B0KYlqRSqSClxO/309HRQbFYpFQqMT8/T7XNDs0ODudjs0kS9wB/gS1zJFZ+/jfgf1+vASHEfUKItBDi0Gnb/lQIkRJC/Gzl8YubHOe2wTRNTGFHS5ZeQvM6DupqR1VVxsfH8Xq9a+n91VKeannz6eertVEZXfKB3/wAQ8ND/OF//EP27t27sTG6XLg8XoyGteaIOjo60DSNhYUFJ/Xc4ZKwWQd1N5ABfgnYvfJzGVtEdr18CXjLObb/tZTyxpXHI5sc57bBMAwaLnu9qaWX8fu862q14XBl4/F41pzU2NgYLmmxOJ/atJLlqoNaqlp0dHZyzx/c07bgq+YPrkVRYEd/qw0rU6kUhmE4qecOW8pmv9UGsftBfWPl9TEhxNuA967XgJTycSHE8CbHcc1gmibhrgEqQDzgIRK0v9zcbvflHprDJgkEAgwPD6PrOp3xCEeXCkyfnKB3cBC324Np6OjVCiAIRaKo67gp8a8mSpiSv32mjHKOyfebuj28uu/ia5haIIiRybG8vIyinLq3VVV1zUFlMhkqlQrxeJxkMuncODlsCiFl+7doQoiXgBC2osQR7Cjqq0BVSrl7A3aGgW9KKfetvP5T4ANACXga+CMp5VkFF0KIu7GjOLq6uvY/+OCDbZ1HpVIhGAy2dewrzVNPPcXfLXVTdicYKT5HrDTBzXvG2b9/P5qmXVXncj62wzms0s65LC8v8/jjjzOX16nqBsGOHoZ37mX62GE8LRNLCryRBMm+oYsbA54rBTihX6AMoa7zC7E0gWDg3LvNOh6vh1qlxPL0BEHX2dN45XKFer1OOBLG4/HQ1ZFgx8jgFdd1+Vq/tq40Vs/hwIED58xb2OztzQPYaeY/eNn2zUodfRb4M+wJjj8D/gfwWy9/k5TyXuBegFtuuUUeOHCgrQ977LHHaPfYV5pisUgrZ39BJMMafZEB9u/fz+tf/3q8Xu9VdS7nYzucwyrtnsvAwAATExMcOvwik0WLzkSCZlcno3F7HWjBsNet1sOYlBTNFq2X3YsePnyY/1XuRPFo/ODJZ/i9D/3GOUVlJyYmGB8fR0rJUkeCummc9Z5kq0UulwPsOqlWU2d0dJQ777xzw+d+KXGurSuLi53DZh3UXwEx4HeAAFADPrOyvW2klGs5q0KIzwHf3Iy97YSuGxjYd8Oupo7bJ5w1qG3IrbfeSiQSIZ/Pk6qkmJk8gQ+LaDRqt0kpmVjN5rqm+YQQRH1nO57usEZzdgFPcpT5UoNvfesR3vb2t13QTnf/+aO23nqddDqNx+1haeY4k5OTvPa1rz1jOtDBYSNstg6qKaX8z1LKENAlpQyuvN64kNhpCCF6Tnv5TmDjSpfblJJex0JFpYVsGLhdCj6fz1F+2Gasqp8nEgk641FK+Sy1UgG/308wGMSrCmrV9tQmVtmxcweDMftmxx3r4fvf/z4vPP9C2/Y8Hg+RSIR6vY7VkixlcszNzW1qjA7XNm3ddgsh3n6e7WvPT0ucuJitrwIHgI6Veqr/AhwQQtyIPcU3ha1Y4QAcOjEDxJFmlRMTx9l9+z6nw+k2xe12c91113FkaoGy34eq65TLZQKBAF41h16tEopsTsz3tuvG+OdjNVxR+57wq1/9Ct09//GCnZYvRCgUwjRNGpakbNR58cUX6enpcZJ4HNqi3Xmhr3PhBFi5XttSynNl/H2hnUFtd6SUzGXLEAGjlGVxYR6fd7+jIrGN6erqor8nSaaWoqsjihCCWq2Gz7013Xh7Qnbk7UnYDQgNw+SL932Re+65B6/P25bNeCzGYiBAenmOXC7H5OSkI4Xk0BbtTvHNnPaw817P3OYUQ1wCms0mxRX1m5Zexut24fP5nLvTbUw0GqUjGiIRjZCIxejp6cGyLMxqeSXlfHNEvAo+l0B4/LhDdjS2uLjIV776lbZrsBRVpbe3H71hMTMzQ7lcZmFhYdNjdbj2aCuCklIOrz4XQvwN8PtSyisrn3QbYpomFcu+47X0Mr4VB+UkSGxfvF4vwYCf/mSc7rCXzs5OTNPkyJGj1EwVvVpBUVWEUPB4Nx7xrPaQmi42GX3LB1mYthsRTANf+MFRfu01O9sadyQWx60FyWSW17L7gsGg0/zSYUNsxTfbJmvdHdaLruvo0o6WWnoZn8dxUNcC0WiURLnK7t12aWFvby+xWJTsUpGJF57B7XZhtSA5MExnd9+G7Q+EXUwXm+SlH9/gq9a2Z4AfHltiqI1OGqrLRTgaR5RNpqam8Pv9TE5OsnfvXifid1g3Tv7nVYSu65isOKh6FZ/Xg6ZpjoPa5oyOjtLX08Xg4CBjY2NomsaNN97IYEwjJmqMxn10BVTKhfaaB97W5+Wdu/28bYeft4778E3/CH3yWQAMd/sRjz8YJBCJYZomqVSKer3OyZMn2Yw4gMO1RbtZfP942stXnWOblFL+b5sZmMPZGIZBQ1lxUGYNf8TR4bsWSCQS3H777Wuvx8fHaTabxGIxpqamEEJgpBbaXpNyq4JdiVNh0sjb7+SFqTQ/KMJipcmuUHvj1vxB9EqWQCBAvV5nYWEBRVGYn5+nr2/jkZ7DtUe732y/dJFtzi3SJUDXdSzFiwCkWSOoRR0HdQ3i8/kYHR1lYmKC/v5+ZmdnqVXLCOmnbhp4vJvL6gwGg9yyJ8DjPymyXGthtammowUCFCywLIve3l4ymcxaY81AIEA0Gt3UOB22P+1+s/3XLR2Fw7owTZOWy4cKWGaNYKDHEYq9RgmHwwwMDDAzM0MymWRiYoKGXqVWqWzaQYEdVXX4FTK1FoWmi2azybFjxzbUpkPzBzFW1M/j8Ti6rrO0tISmaUxNTbFnzx68bSR2OFw7tJvF5zioy4BhGOC2i3KlWSUU0PB6vU4EdY3S2dlpXxNAd3c3c4cnyGUzRBMdW2K/K6iSqbVYqlh85jOfYWpyit/64G+xb9++dR2vuly4PT7MRpNarUZPTw9TU1PMzc0xPDzMiRMn2L17tyOF5HBenCvjKqJarSK8K72gjCrhQAC32+04qGuY/v5+IpEIw8PDhPweMkuLmMbmW8UDdAfs6+r4YpGpySkAvvLlL2+ovbvdKt6OolwuF319fTSbTebn59F1nZmZmS0Zq8P2xHFQVxGVmo7i0UBKxkf60TSf46CucYQQjIyMkEwm6e6I0zAMlrPLNBqbksMETjU7dCUGSVx/AG381ciOMe77wn3UqrV12fAHQhjNFuWyrRuoaRpdXV1Uq1UymQzZbJZMJrPpsTpsT5xvtquIat1us+EWLW64bq9TA+UA2A0D9+3bx5NPPkkk3ODE4YOcfNGunzp9+qyzp59kb/+67XYFVBQBunSh7nwdq8l8+cf/ji/d/yU+8uEPn7M9x+msJkosLi6e4Yiy2SyLi4vceuutfP/736e3t5c77rjDkUNyOAMngrqKWC7pALiwUIRE0zQnQcIBsJXEb7nlFsYSGvt6QyRdBkEzx2AQhsKC3oAgm96Y3JBbFbxjl59xTWd/j4eIYk8duhP9TByf4KGHH75ovq4/EMJS3JzI1TmW0dceBalRLBaZmZlhcmqKnz797FqU5eCwyqZuv4UQNwE3AN3Yheffk1JObsXAHM6k1WqRLdWABB5FogocB+VwBrfeeivDw8OcPHmSUqlEKpUiHA7T29vLk08+Sats0mw0cG3gmtmV8KDmq4yP9tAbdPE/j9dwryif/+THP6Gnu4fXvu615z1eUVV23XALLevMLrwvHfwpwVDY1ulLZ0l2dnLkyBFuvfVWJ4pyWKPdQt0Y8PfAW162SwohPi2lvGfTI3M4g0KhQGllWcGFhSrA7/c7DsrhDDo7O2m1WszNzdFqtchkMhQKBbuHVLGOXqu03aJjdU3K3zVEcWXb1//563R2drJ7z+7zHieEOKuxouYP0sBex6rVLZZzefL5PLOzswwODrY1PoftR7tTfH8D/AJQAFZXY38ANIHfE0L80RaMzeE0stkszxw+bj9fTDE3M+2sQTmck66uLjo7O+no6CAajbK8vIyUEq8qNqWAHtcUPApYLo3BsV0AyJbkgQfuZ2lx/Zl9AP5AELPZwjRNvIEQFd1cW6dykiYcVmnXQf174DtAB3ALdruNLwA3AkXg7i0ZncMauVyOktkCoFbMUTd1vF6vE0E5nJOBgQEikQjd3d0EAgFqtRqyaaJXq23bFEKQXImi3vDO96wpQXR1daP5N9Y0UwsEMZv2ApbL68fj87G0tESlUmF2dpZKZfOtRByuftp1UCqwLG3Vx9Vbpz1SyiPAN4ChrRicwymy2SyGtKOlllklFPA7KhIO50UIwejoKIFAgL6+PmKxGLVinnKxsCm7PUH7Giy1vHzwQx/k1be9mo9+9KMbbqOhBYKYlkRKSd1qEQiGURSFVCqFYRicOHGCer2+qbE6XP2066CeA94thHgU+DF2Ls9qcoQbcNJxthApJYVCgYZiC3q2TN1RkXC4KIqiMD4+jqZp7NixA5/HRW45jakbbdvsDtgR1HSxCaEuXvuLv0zaEKRKTVKlJumqtS61co/XhyUUag2JBFoIYrEYQgjm5uYwTZOJiQlarVbbY3W4+mn32+3/BP4NuGvl9THgy0IIN7AfeGzzQ3NYpVKpUK4ZWKoXFTuCioZCuN1uJ4JyuCBut5vx8XGOHj3K0NAQ84cnOfj0j0l0dKAoCp09fQTD6xdtXU2UmCk2+bsXzj0N99pkgzt2dF7QjhACzR+kZJTR/EGaZg3LsgiHwzzzzDOcPHmS3bt34/V6CYfDpNNp9uzZ48giXWO0q8X3YyHE9diJEgbwNSnl6m3Z+dN5HNqiXC5TMxu0VFtYs2VWiUb7cblcjoNyuCiapjE2NsaJEycYyxZIL2dpZKqEonGWUq0NOai4pnBzj4fFinXWPr0hyRstvvPTF1GXvfzc7T93QVuhSIylcpGeniRLs5PU63U769CE5aVlqrVn6enp4bnnnkOoLhKJBN3d3Rs+f4erl7bnh1bqnT6zhWNxOA+GYVAolRErQrGiaRAMBu303YtU8js4AIRCIe68806i0SjFYpH5+XlS8wvoHoGUct21R0II3jTqP+e+f/vxz8gzjCvaw0MP3UskGmHPnj3ntdXZ00c4GseraSysOKhyuUxD9eEOKuRLdtr5zOwsqj9GoVBwHNQ1xpbHy0KILwohmltt91rGNE1yxZKtwwe4WqaTIOGwYTo6OrjuuusYGhpi586dtKwmtVKJutn+mtTp3HHjbmi1UMMdtITK/fffz9zc3HnfL4TA5/cjhMDl8mBJMOoNhOqip7cf4fZx5MgRShWdVDrD/Pz8lozT4erhUk3oOqXgW4hhGBSLFRSv7aA8sumkmDu0RXd3N8lkcm26zKrXSC9uTALpfAQ0Hwm/ghAK7mg3dbPO5z73OfK5i7eid7ndNFtgNiU+fwAtGMIfilCtVlnK5qgaTY4cObLWXsTh2qAtByWEsM73AH59i8d4zWMYBsVKZW2Kz6tYTpGuQ9v09/cTi8UYHBwk7PexnE5T3UR91On0he1MUy1pq0GUS2Xuvfde9NqF1c/dHg9WS2JYEn8whOYPUG8J4vE4DamSLRQpV6ocOnSIZtOZoLlWaDeCEhd5OGwh1WqVctVA8fiQsoWmSieCcmgbIQTDw8P09PTQlYjRshrk83mMTaSfr7Ka5bdr/x2oLvv50tISX7jvPhr187cAOT2C0gJBfP4AjZat5aeFogghWMjkyGQyTvr5NUS7DiqPnWZ+0zke/3NrhuawSq1Wo39sJwCqtBgfG3XWoBw2haIo3HDDDYT9Prwr2aDL2WVMc3PNDlcdVFX4ec973svqPevJE5N86YH7zxKNXcXl9tKUEqMp0fxBFEXBq/kxLZCKysDwKBWjwcmTJ6lWq0xOTq6r3srh6qbdOaIngTEp5cGX7xBC5HGiqC3Dsixquo7iC0IDvIqkt7vLqYFy2DSBQIAd46NM5V+iUStTKBTJLs2TiCdwuU99NeQzi1jDw2cJvp6LTr+KAJb1Ft9hlOQv/8navoXlGf6/hx7iPe9+91nHuT0eKk2JUF14vHY5hRYIUC7V8Pg0Ep1Jqtl5UqkUzzzzDNdffz0ejweXy0UwGCQUCpHP52k2m3R2XrgGy+Hqod0I6kPAr5xn3x8BI23adXgZpmli1Jvoip3a66OBS1VxuVx4PJ7LPDqHq52Ojg72jfbi0nOEhE6rsEj65CHMzCxWfh4rP081M09mMbUue25VsC/pOXO+fyXS8XQMMrr3xnMe5/X50JsSf+iUZJI/GKZUX1mTCoRQ3BqVloufvXiUQ4cOceLECf712//Gc889h5SSp556iiee+PGmo0CHK4d2C3XngXPmfEops0B2M4NyOIVhGJj1BmURACBEDbdLcYp0HbaEffv2EY1G0XWdyclJdF1nfn4eIQR9fX00m03mZ6eoVdavXvbWHX7euuO0WikJn/r+CSreBKHuc9+7BsNRBkZ3EQiF1rbFOpIIIQhFYrjcbvrHd1Mu5FiaOs7MzAyapjGzuIzH46ZcLlOu6pjNFoVCga6urrZ/Jw5XDluSBiaE+BPgA1LKsa2w53AKwzAwG03ylu2ggq0qbpcTQTlsDas6fQCjo6McP36cgYEBpqenAejr68Mt5KbadCDghvFefjRrsli12HOeGbhoouPMw4Qg1pFcex2JJfAHQxSWl2i1ykxNTVE0JLOpRQ4fPozesBwHtc3YqjqoODC8RbYcTsMwDGqGyVzRzoB65vuPoCpibf7dwWGrCAaDjI2NoWkaAwMDNBoNMpkMblVBSGtTBb3dAftaPV0iqVQs8dJLL23IjtvtQXV5CYaj1Go10rkiZb3OM888Q75co1ZvUiwWL27I4arAUV68wjFNk/l8FdUfodUwMXLzeNwuNG1j/XccHNZDOBxmZGQEv99Pf3+/vQZqGHgUNhVFrWb3LVZstfPl5WU++clPct8X7tuwk9ICARpSEI1GsVBZXM5Rq9WYW0hTqpmOg9pGbJWDOgE83s6BQoj7hBBpIcSh07bFhRDfEUIcX/nZXo/qbYBhGEwX7ZqPZmERzevF43Lh959bD83BYbPEYjGGh4cJBoP09fWhKAq1UoFquf0uOkGPIOAWmJakYLT4h3/4B7LZLJZl8cUvfpFjR4+t25YWCGI0JU1UItEo9ZZgeXmZqlEnncmRLxQdxYltwpY4KCnlp6SUd138nefkS8BbXrbtj4FHpZQ7gEdXXl+TmKZJumGvNTXzC3h9XtwuxYmgHC4piUSCgYEBQqEQPT09YJksLqSQrfZqj4QQp6KoqsX7fvV9xBNxAJqNJl/4wheYmJhYly3Nbzc7NJuSWEcngXCUerNFqarj8fmYnE05beO3CZtaxBBCvAt4G5AE0sA3pJRf24gNKeXjQojhl21+B3Bg5fn92P2lPraJoV616LpOcSWDr5GfJ+7z4vV68fl8l3lkDtudZDJJq9UikUiAonJ0qcD05Ani8TiKqhIIhdetgg7QFVA5kW/y6KROwK3S/ZbfRclkaNZNKs9/h89//vN8+O4PMzJqZ/o9t2CyrFu8cUQ743O0QACzKXErdideU6/h8khcukSvNyg1TZ588kk8Ho+TLHGVI9qpxhb21fI14J2rm7C76gL8o5TyfDVS57M3DHxTSrlv5XVBShk97bPyq69fdtzdwN0AXV1d+x988MENnwvYDQGDwWBbx15qnnjiCT63OID0x8l++7P0enTe8nP7uPPOO4nH42e9/0o+l/WyHc5hle1wLjMzMzz99NOkiiaVag2Px4PXHyTRN0Iouv7Z9+W6i8fy5+49Zcy8QOmpf8LtdvO2t7+N7u5uvpGOU5cKb4jnibnPVKCYOnoI2WzQM7KTUn6ZaiGHP5LAqNepZlJ0RzX8HjcHXvcaOjpOZQduh7/HKtvhXFbP4cCBA+e802k3gvoI8B9Wnj8JTANDwG3AfxBC3C2lvLdN22cgpZRCiHN60ZXPuBfglltukQcOHGjrMx577DHaPfZSYlkW6XQambPrnSy9SLK/l71793LXXXcRi5395XClnstG2A7nsMp2OJfHHnuMvXv3cvjwYcrlMgsLC5QbEI5H6R8dX7edcWC3YWE0T/075/QW3zhWw5PoA6DRaPDIt77F3b/zUerSXoFwx3oZ7/aeYaszEcOoVenqG8Q0dJYX5+3npsGRF57HatSJROyZhte+9rVrfdO2w99jle1wLhc7h3bXoN4LtIB/L6W8XUr5Hinl7cDbV/a/r027qywJIXoAVn6mN2nvqsQ0TQq1Brg8SKuJNKsE/X6nSNfhFeeWW27hjW98I7fffjs333wzrbrB4sLCqXmTdRL1qXQHXWuPnQk3igAlECMYsW+4DMPk8/d/Ze2Yc3XvjcQSdPXZiulen0bf8Bgut5tAMMSe628iHO9kKVcgk8lw/PhxrPNoADpc2bTroHZjJzE8cvpGKeU3sZMaNtv2/RvAb6w8/w3gnzdp76rEMAyyup3B1zLKICXhUBC32+0U6Tq84vT19dHV1UV/fz+d8Qjlku0ANuqkTselCDr9KiB45/t/G3/Azk6tc+oGbLG6MefiD/jp7uuloteZnJykUqk4TuoqpV0HFQLOlxd6FAifZ99ZCCG+CvwY2CWEmBNCfBD478C/E0IcB9648vqawzRNssaqg6ogkUTCQSeCcrhs9Pf309fXR3dXF9GQn2Ihz3J2eVNOajW7r+GL8pGPfARN0xjeeapVfKZqYW0wezAaixOKRCmWK5w8edJxUlcp7a5BeYG3CCH+8Rz7rgfWfXsvpXzveXa9oZ2BbScMwyBTqQNg6WXcqgu/puHz+TaUPeXgsJX09/czODjIZKaE6lYxdIPMcoaORAdC2fh12RNUObgES1WLV+/s5w/u+QOmGyG+N71y7UvI1Cy6gxv7uop3dKKU7HVcr9dLX18fqVQKy7LW1qQcrmw2k2Y+tvI4F06jli3AMAx07MXhPaODdETfjMelOjVQDpedXbt28dLJOXKWJBaPkc/lWV5epqNj405qNYJaWFlr6urq4si0fsZ7FisWopKlq3v9aeNaIEiz7kfTNMrlMqlUCl3XOXbsGDt27HCkwq4C2v0L/dctHYXDOTEMg3LD/mePaG5ikShu1XJUJBwuO5FIhN6uDkoLZTweN+FQkFw+T6NRp6u7e0MRSodfRRF2Rt+3T9TYnXBTqdv3uHFNIae3eOrFSY4/8gXe/+vv5/rrr1+XXS0QZDkjEcJuHb+0tMTCwgL5fJ5Dhw6tOSm3242iOKpvVyLttttwHNQrgGEYVC37H0dTJZZl4fE4MkcOl59IJILPreLzKCyePEqpVKJeNymVysydDHPLz7+OxdQ0+Uyana+6CbfHe15bLkXQE1RJlS2eW6xzMt8krtnX/XjMzVO6yVLVwrIsHrj/AX71fb/KzTfffNExan5bEimbL5DNF6hWq7xw6EV0s04inuAHj/+Qnt5ewkE/r3/9653EoyuQthyUEOLtF3uPlPIb7dh2OEW1WqUm7WQITZVIaaEqnqu+OM/h6sflcjE6MoxfWwSSFAp2Rl+p5OL52TzzqRSFdBqv0qJcLBDvvPDU3Nt2+pnMN/nelE7RbGGtCAiMxV08NW/iinaDUGi1Wnz57/8eQzf4+Tt+/oI2PV4vwViC2XJpZUuQRqiH2QosmCUi4TAnC1PcNNZPLpeju7t7878Yhy2l3Sm+r3PhdSa5CdsOK1QqFaoNQAW3rFNvtXALCJ3W1M3B4XJx/fXXnzHdls1m+cY3vsFitUWxkCOfzTCUjNoq6BdxUFGfyk09KoczdebK1toUX0JTifkU8gZ0je5h6cRhpISHHnqIcqXMm9/05pW2vedmaPzMihdPKE5fby/ZXA6Px0OzVmZqLsXi4qLjoK5A2p14nbnIY3ZLRncN02q1qOk6tZY9l//3991LemkRVbVbIjg4XGkkEgl2795NyO9DaTVxC0m5kKVULKyJcBZBAAAgAElEQVTbRlfw1NqVAPzuUyKzd739XQwMDqzt//a/fpuHH36IVqu1oXFqfj8diQ7q9TpVo05Zr3Po0CGq1eqG7DhcetpyUFLKYSnlyIUeWz3Qaw3DMCjpDYTbh7SatMwagYAft6o6U3wOVyxDQ0MM9XbTbNTp7ozjVQVL8yn0mn7xg+GMVPKgR6CcpoKeb6h89KMfZdfuXWvv+dGPnuCB+x+g0WhsaJw+zUdnRycuj4fFZTsD8dixY5RKpYsf7PCK0ZaDEkL8VAjxB0KI5MXf7dAOhmEwX7D/qVtGBUVAJBhA0zQn48jhiiUSiRCPBEjE44Q0L91dSbwuhfnU7LoilO7TIqiAx77OuwOnmh16vV4+9MEPcfP+U0kSzz//PPfeey+6vj4nuIrX56W/fxApVGbmUuTzeSYmJsjlchuy43DpaPebbj/w18CcEOJbQoj3CiGc4pwtxDRNZpftBnEto0wwGMDrcREIBC7zyBwczk8gECCg+dB8XkYH+0gkEiQTUaRlkc/lLxqhJDQF98q3UtBjLy51rURV6RVFCdWl8r5ffR933nnn2nEL8wtUyhvv+Ov2uOnu7aXRUjhy5AiVSoXJyUkWFxc3bMth62k3keFj2IKxNwK/gN1wsCqEeBj4MrZOn1OsuwkMw2CxZEAQLL1CKBDA43IclMOVTyQSIeQrEA0HGdy3l1T2UUyPB59fo1Qs0bJaRKPRcyY3KELQFVCZK1sEVzyVzyVWEiVaPDVvEnDbB4783FswokO8cOgQB+48wIIMs7BkEvYqDEfXLwUWikRpWlUajQazs7N2g0agXq8zMDDgqLZcRtqtg/or4K+EELuAXwPeg60q8esrj3lg4PwWHC6GaZrkdAuCKxFUwI/X7aw/OVz5RCIREgEPkUiEZDLJyGAvTx9PUSrmqFaqWC3JyO7r6OjoQFEUFuemadTr9I+MI4SgJ+RirmwR8Z2a4OkJquSNFj+Yflkrd/cwwZuGeboElE5N8f3WjSGSgfUVC2v+ILllQavV4tixY7zwwgtEIhEikQiBQICenp61aXVFUdi7d6+T8fcKsalUcCnlUeBPgD8RQrwO+Dx225feLRjbNU2lUqFi2f9gLb1MIBDApQgnxdzhiqenp4eTJ0/S29tLLBajIxLijj1DZDJpyv4Wk5kKhVwW2ZLEYzGWF+ZQBJg9ffg0P7f3e3ErcFP3qcLZOwZ8eFSBdZF5mflyk6ze4oWpNGrmKAfuPHDBNHSAQDjMfEswWWiA9FM2LaZnc2gZnWAwgGc2Rywex6W6CHhV/H6/46BeITbb8l0F3oQ93fcOwLm93yLK5TL6iuZuy6gQjPtxKcJJMXe44onFYrz1rW9dmxp74xvfSL1uC78+/vjjFH76PIrXS9NqMjMzhWhZaF4XerWCT/Pjdyu8bujMJe2EX+Ut4xdXUPnpvMmjkzo/PjRB7iffYGF+gV/+lV++oPq/2+1h1423YjVPKZ2XikXK5Qpen4d4PIHH7SaRiHPyxYMUCutPm3fYHO1m8b1OCPFZYBH4JvY0Xwg4DvwX7CjKYROUy2Waqv1P2jLsCEpVhDPF53BVcPq6jaraAseaprFnzx76ujuRrSbJZBLTqFEtZmk1TPTaxpMcXs5qFqAM2G3ef/rTn/KZT3+GUvHCyRmq6sLj9a49OpJJkt1dtCQUiyUkgmKpglFvUNUNarXapsfqcHHazeJ7DLgbSAAZ4JPAbVLK3VLKP5NSTm7R+K5ZyuUyLY+dEGHpFYJ+P27FKdJ1uLqJRCJ0xqNoPi9er5eAz0vA66ZWyrO8tLRp+10r607uaBco9vPp6Wk+/vGPMzM9syFbgUCAzo5OmlaTpaUldEPHqDeYT2cpFoubHqvDxWnXQenAg8BbgT4p5T1Syp9u3bCubVqtFsVSCdUfAUBtGvi8HjSv12m14XBVEwqF8HtcCGnR29OD1WzS29VBNBggl11mObO8YWWI0/GogoSmgFB4wzvetZbcUCqV+NSnP8WRI0c2ZM/r85JMJlEUxe4eLBSWsnkOHjzoND98BWjXQSWllO8DXgI+IIT4YyHEh4QQw1s2smsYwzAwmgLh9qEg+e0PvB9FCAJ+n9NJ1+GqRlEUIpEImltFr1YIB/zEwkF6e7oIBzRKxQLppfSGlSFOZ3War3fH9dx9991r6v/NRpPvPfo9Hn7oIZrN5rrtud1ukl1JvF4vZt1iOV9iYWGBI0eOYBjGxQ04tE27UkdVIcSfYbd9vxf4c+BvgeNCiD/fwvFdk9gp5vZdpKZKFBU8LoVAIODUZDhc9UQiETSPi/RCCs3rYveuXQwNDREL+QloPlqtFul0esPKEKusOqjpYpPYwBi/8dE/pGt0D2q4EzXcyU9eOM4nPv93pJfz67apKAqdHZ0kkp0UKjonTpygUqnw0ksvkc+v347Dxmi33cb7gf9r5WUDyGKvR7mBPxZCHJVSPrA1Q7z20HWdvJ30hKZKaLVwqYqTYu6wLYhGo2huhbnlNPGAh1gsRl9fHyfml5nJLqO63BRLRVKTEwSDQUZ27EYLBMgspvB4fURiiQva7w7YX2tHsg2OZFfaAdz8K5x+VAP48tEmfxCXqOvtACygM9lFOBqnUlvmu9/9Ll1dXRw6dIh4PE4ymVy7gXS5XOzevRufzwfYa8qzs7Ps2rXLaTe/AdpNM/89oLny8z4pZVMI4QJ+E/gM8LuA46DapFQqrdVAaaqk1bKcBAmHbUM8HiesuRlSBD63Sjwex+/3098ZJaB5SS8tEQwICk2DYjrH0XqdnXv3kZ6dAkUlfHP8gjMJvSGVXQk32drZa0SlUomaruMOxjEVF5madYZA7XpIdCap5eFEusCxhQKhUBC/tojXe4J4Io6qqkQ1Dz6fj9277XYfR44cYTaVQtM0RkYcLe310q6Dug74upTy3tUNUsom8DkhxJuw5Y8c2qRUKnHo5Bz09GPpJUxVJ+oSdHZ2Xu6hOThsmmAwyOsP3EmtVsPtdtPR0YEQggOvey2madJsNpmZmSGXy/HMzw4ykS0wMz2FSzawJNRNA6/v/MlCqiJ45+5zS4JNTKTxen08XfFwNGexVDnloGRLItYRTfWPjFNJdGC1WhTyBUzDQPh8aLEoTZcLt89LoXxmpl+hUCBXbTjZfxukXQd1ob+io8G3SXK5HFNLeUI9cOzQz7j+xi78MQ/xePxyD83BYUuIRqO2Ht9pJBKnJuEGBgZYWFhgcnKSkF5Fr5RpFfN4/EH0SuWCDupiDAwMMJ8yOJqzWKxa3AAYusFnPvMZXv+G13PjjTde8HjV5SISt+us4h1JSqUSpVIJs2ERCsdoSYvF5fza2pRpmlSqNQq1ulPku0HazeJ7EfglIcRvCiEUACGEIoT4TeCXVvY7tMnx48dRAzHA7qQrpUVI8571D+3gsF0RQtDb27vSANGLKiSRoIZZq5Cam6W1yRTv01t4ADz88MPMzc3xwP0P8OCDD2Ka5rpthcNhOjs7kVKylF6i3mhSrukcmzhBPp+nWCyiNyyMZotSqeykp2+Adh3Up7Gjr88DNSFECqitvFaBz27N8K5NTpw4geK3nVFAlXhUQTQSxuPxXORIB4ftRV9fH8P9vXg8Hro7Y3QlIpRLBRYXl9rO8oMzW3iUKhUmp05pCzz15FN8/H98nLnZuXXb83q9dHd14fP5KOQLNJotCuUaTz/9NJOTk9TqFrIFeqPpNEXcAO2mmX8J+Cvs6TwP0LPyUwIfl1J+casGeC0yPT2NGlhxUK4WfrdKR0fHZR6Vg8MrTyQSIaR56El20NPVRTQcwO/zorpUsstZ8rk8srXxVYXVFh6WBB0f/+mP/tMZTRAzmQyf+MQn+M53vrPuaE1R7f/TaDQKisrcUobFxUWOHj3K3HwaoQhqdcuZ5tsAbbdmlVJ+DNgJfAT4v1d+7pRS/h9bNLZrEsMwSKVSqJqdsRfxqXhdgmTSaV7scO1h10yp+D0udu7cyc6xMXxuF9FwmFAoRLVaZXFpcU2MdiOs1kstVi18mo9fe9+v8d5ffS9erxcAy7L4l0f+hb/5xCdYWFhYt91gKEj/wCBNqXDixAlmZ2fJV6o0JOSKFSdRYgO0WwflAvzAzOmZfEIIVQgRBmorWX0OG6BcLnPs2DFS6Rxurx/Zsoj5PXhVha6urss9PAeHV5xQKETA5yFoNolGo0gpGVyuUilmaUmBaDWoG3XSS2lcikAVgAKRWAcer5daxe5K7Q+eXUPYHVB5abnBt0/ofPfk6nThDhJv/880m01We66awJeOgXoii6qqCOC2fh93DPjOO+5wLEYgEkMIg0w2y3JTo2dkN3NTRzl06BB+v/+MeqiOjg4ikcgW/da2D+1m8X0c+DCwGzhdGLYPOIqtLnHP5oZ27fHss8/y7OHjFNxxOgGrmicSChDwuc7IcHJwuFYQQhCJRKjXG8RiMaSUdIZ8aGaTaqWCXixgCg+dfcO88PQTBF0tgqEI1VKRwbFdTB49BMCem25b0+VbZSzu5kdzBnULzpwlFKC6z0pVbgGrMoEHF80LOiiP14dQ3TTdKmpQxWNAqVqlWKlxbGaBE6lHiCdi+DU/AkF/Z5g3velNm/59bTfadVC/CDz2ctVyKeWMEOLRlf2Og9og1WqVF07O4el/lb2hnCE04CMaDq9NOzg4XGvccMMN5PP5M6KMVS29I0eO8sOXZtB8XiJBP+FWGbOyTMZo0tndjxuJBEy9hhY4s1VNh1/lnldHLtgEMb2U5mtf+9qKCsROPvCbv8WnflqkVJfUGi387vOvkgyO76JcyBOMCvpiCXSzTrijm2zdIOKPsGyq+FWVpqkT8deo1WpruoEONu06qD7g0fPsSwFvaNPuNUuz2aReb7CUzuDpGATAVy8S8IadAl2Ha5pgMLjWB83tdrNz5861fel0mp5kDawGYb+PXX29zM7OsrRU4uTxo2iyicvtolatnOWgwC7qvZDwUH9vF/f83u/wg8cf56Ybb8LrEnQFVeZKFosViz6tgdd37pvHYDhKMHyqNMQfBL/fTz6fp9VqEQiFCYfDTE+8RDrXpFAoOA7qZbTroKrArS/fKGz9kVev7HfYAIZh0GhJlrM5XH03ABCihs8dcRIkHBzOQyQSwe9eolQpMTzQR09XFEVRyNbnyOaXaUodLRBArZRJJNtr066oKnfdddfa6+6A7aBSpTr/8Nn/l6GhQd7+9ncQDF28maimaXg9HgrFoi27VKshVBeppQwHDx4kHo+v6fc5tJ/F92PgBiHEl4QQO4QQHiHEDuBLwPUr+x02gGEY1Iw6ozt24on1ANDtB4+TIOHgcF5Ws/yajQZhv5ebbrqJnTt3Eg36CQdDxEIBmnqVudlp9C3qgrsqjXRoaolMJsPTTz/DX/zFX/DEj55YV8q7otr6gx0dHUgktZpJJldifn6eF198kVQqtameWNuJdh3Uf8deM3w/cAS7geER7NbvLeD/2YrBCSGmhBAvCCF+JoR4eitsXqmYpklN1wn3jiKFQsjVorcjit+tOBGUg8N5iEaj+D0rwsoehWg0ysjICKND/Wiaj2RHjP6eJFa9znJmmUK+sKFeUOdiNT29wim5JV3Xeeihh/jEJz7BzMz6Ovf6NB/dXd0kkp2UagbHjx8nn8+zuLjI4cOHnTYetF+o+yNs55TH1uVbfRSA35BS/nDLRgh3SSlvlFLesoU2rzgMw6BqmJSkfdFH1QZel0IkHHJCfgeH8xAOh9HcKh6XQtDvx+fzEY1GCWkeers62LljB4l4nI5YBJ/PS9Nqsri4SKlYaqvAFyCuKbgVsFwaH7j7IyQ6TmXYzszM8Dd//Td85ctfXldBrlAEnckuYokOLCmYmppiamqKUqnEyZMnOXbs2KYUM6522l2DQkr5oBDin4E7gCSQBp6QUm5NHH2NsTrFl63bf5KQqBHwuZ3pPQeHC+ByuQiHQ8TKxlqGn6ZpBP0aYa1Of38/XV1dLFWfplHX0TwepNVgcT5FxqUSCYfxaaciIVVV15Ip6qaJy+VCeVn/JkWcSpR4xuxh+G2/TyRvi8OulE4xAXzyeyfZG6zytgO3nVemLF21eDJlMB6KE5YqLpeLbDZLJpMhEomQSCSYnZ2lo6ODnp4eEokEqqpSr9cpFotks9mzbCqKHUluh+amYrUY7UpECDGJHaVJ4G9PLwpe2X83cDdAV1fX/gcffLCtz6lUKmtZQpeLY8eO8YOnD/N87DWUhZ8dlefpaczz8zddt9ZTZj1cCeeyWbbDOayyHc7lSj+H48ePs7CUZnhwgMFBOwP2xRdfZDmXZ8fYKK1Wi8PHJ8nVmuRyWYRQsKwmtZpOs9nE5XLh92uoqgtLChJ9Q3h8GnMnjhKKxkn2DZ71mYcrfl6qXjzjzph7Edfx7/Hud737nK08niyEmDW9DLNIX+4gmtpCtiTVWtVu4yEUNL8fTfPhUgTjI0PcdNNNPPfccyzlSmjnyCBUBYyNDNHf39/Gb/OVZfXaOnDgwDm9adsR1CvEa6SUKSFEEviOEOKIlPLx1Z0rDutegFtuuUUeOHCgrQ957LHHaPfYrUIIwV989gFab3w9QoUuTTI+MMyb3/zmDTU4uxLOZbNsh3NYZTucy5V+Dvv37+f48eNcd911a/WCN9xwA9PT0+zbtw/Lstj5/PM0Gg2effZZRkdHyWQyWJZFpVIhn89jWRZerxdDumiFYvg0P75GL3XcjI+Pn/WZo1Kyv2xhnWOaMDU/zw+feo7WjgO4oz3c8ZrXsGPnjnOO/dFnSkALNdrLQGdrTek8DjQbTSrVCo16nZaigirt6DAYJJHs4uiySf/YDWfYazYbqJbB2Ngwt99+++Z+sa8AF7u2rmgHJaVMrfxMCyH+CTuF/fELH3V1ksvlyNZdxFUXzXIWd6CF1606XXQdHC5CKBTi5ptvPmNbLBYjFrNb1rhcLm691a6KqdfrHDhwAMuyWFhYIJ1O02w2yWazzMzMcOjIceo6xBIJgh6F5VqdRqOO233mFJ0iBP3hc399DkWHePWufj7+kyIEY9yyf+Cs9ywuLBLt7CJv2Nl66Zpk+Na957Rn6AaFQoGjB59mZrZKIpFgbiFNo9lieOdeAoFTzRnrpsHBJ//XttH7a1ss9lIjhAgIIUKrz4E3AYcu76guHS+88AJKfCUkrywTDAYIaJqTIOHgcAlQVZX+/n727t1LIpEgmUyyb98+IkE/xXyW2ekp6rUyHgX06sbLOl2qSnfIDcCycWaUNTc7x1/+5V/y+Qe/vratXJdU6+dOLfdpPrq7u0kkk1TNJgcPHmQxkwNVZWFxgbnUHDXdXvpflViq6ga1LUqrv5xcsQ4K6AJ+KIQ4CDwFfEtK+a+XeUyXhGazyaFDh3GvKEiEhI60LAKaz5E4cnC4hPh8PsbGxti5cyfxeJyB/j464zEUJHqlRLmQJZtZaqtP+MubIq7yyL88AsBC+cx095e/7wwEJDqTRBKdeL1eykadmlEnn8tTrVSZn58nlUqh6zqBUJhaY3u09bhip/iklCeBGy76xm1ArVZj4uQk7hsPACsXtmwRCYdwua7YP5GDw7YhFAqxZ88e0uk0s/nncLtdJL0hmstFMktL+IIRQqEQwUCQs1Rkz8NaO4/THE/LsgiHwghF4I7aBfkts4bi9fPNHzzJ22/oY2T03GvOmj9IblnQEYkQavrwKF6qtSrVWpVgIEgrbKEbOpVqDSmrFItFent7N/eLucxcyRHUNUMul2Nydh73ioLEeFcElyIc+X0Hh1eYwcFBRgf76emM09vbS393J163C1VVKeQLLCwuUKlU1lVDtao4sVg95aAUVeU9730PH/vYxwh0DwNgTB8EoNBw8clPfpJPf+rTHD1y5KyoTQsEMCxJw5K4PD6isTg93T0EA0Eq1QrzCwsU8gUQCjPzSxw8ePCqj6Kc2/PLjJSSZ599Ft0TI6K6sap5hsa70LMNtNPqMxwcHP7/9s48Sq6rvvOf33u1770v2iVbki1L8YZss9gCDAg8BgZsDAkGJjjGScyQhJw5CQeYBJMJcBgfCGeYyQIE8AQHJsTG2NgssQ22JBsv8iJZlrVYa7d6rera1zt/3FetltVaWuquqn66n3P6dFe9W/1+37r16vfu7/7u78498XickM/GaovzpisvY/PmzRzKHCYRj1OpVJhITzA2OkYymSQajRCLxqdNHwfoDFl4LEgWavzH3jxTlyUpFaXqK2KhWBwoMAJ4OxcTXvtWBoHvP/wC7Q8+yCf/6I/x+ryM5KoMZGwEm1y5RjASowLYHptEW4JoNMrExMRk1t9oMs3AwAA7d+4kEAjQ09NDR0fHKddGWZbVUuunjINqItVqlUcffZQf/vBH+Hp1Kqu/lMK2w0RMgoTB0HC0g/JgW0J7eztLlixhKA8De18mk8lQUzXKpTK5XJ5yuUQk3saqiy4hEglPu6C311nQ++Th4rTn64t6+PAH38vXtiQp+kOEV71h8pj/0BN4fTrR4me7chxKV9kQ68BbHCbRFiadP7qLsO2xaWtvIxaLkU6n2b+rwqsHDjJ8773EYjG8Xi+27SERjxOLxY6zdfKcPi9XX3015XKZLVu2sG7dOrq7u3nsscdob29n3bp1Z/sWzwjjoJrI+Pg4R0aTPLNvFP9CXcmpOyiUSyUS4aBJkDAYGoxt2yxbtpRcLkc0GmXx4sVMTExwfm+cWq1GKpUimUxSrUbJ5/NsG8yQHB9nIj1BJBwhHAnj9Xon/99154XYOVqeNsdCgPM7vIgIN10UZX+qQj5f4MUDI2T9nfSvvBiAak1NzmPtT9eQaoGlHV2kDx463n5nRLVy9YXs37ubI8k8anwMr9dLMBjEN1rEkmGCoRChUAjvlDlupRQL2oIMDQ2Ry+VIZvIcPHgQr9fL4Mg42WyWtWvXNnSEZRxUE0mlUoyk0hwZHiWydikAqxZ2oGpVwgG/GUEZDE1g7dq1k38vWrSIRYuOXcdUq9UYGxvjvvvuY6hgE4tFUFhkshkymQyBYIBIOEIgGKAtaHPFwpPtOKXpj3roj3qAAIs7w/xoe5asrStVjOSqk5sq7jyc5IlNP+WFl/ewfPlyVixfMW2IsW/xMvoWL6NWq5HJaLtq1Rper5dINKJ38rWEYDBIIp4gFA5x5NABUof2kEqlyOVyjGZKtCeTJJNJssUKtiWk0+mGrs00DqqJJJNJ9h0cJBRL4InrmntrlvSQHxvAa1vGQRkMLYhlWXR2dnLJJZcwVnyWCjUS7R3E4zEy2SyZTIaR/Agej4dIJEIoHDpuu/mTUU9PH8pUUUodk2Qh0W6Ugu3btrN923Y2bdrElVdcyfor1k/rOCzLIhaLEYvGyOa0beNj46SsFOFwmGqlSj6fx+vxICgyxRLJZJJ8Pk8qXyKTy3PkyBHy5Spe2yKVShkHda6QSqXA4+PDn/gTfrTXIkiJSCBBSSy8tpgQn8HQwiQSCTriUQq+CAv6F5BMJbFse9IZZLNZkskkyVRSh//C4ck5pZMR9llEfUK6pBjL145JU7cjbYg3gCoXABgbHeOBBx7gwQcfZM1Fa3j9VVexcuWq40dVAuFwmHA4TLFQJJPJkE6nSWfSBANBwuEwPp+XA4cGSZAjGIlSqSnypSrj4+PkilU8tkUymTxuRDmXGAfVJMrlMmNj4xRKFSb0Z43+uA8RwbbFjKAMhhanvhfVyESKYDBIMBikXCmTSqawbItwOEypVNIhNif85/P7CIfDkyG2E9EbsUmPVRjMVCcdlMeCSg1u/qM/Y9/Wx3niiS0UCjr5olar8cLzL/DC8y/Q1t7Gxo0bJ8s7vRZ/wI8/4Kda0bUIs9ks+Xwe22NTqSmGxydQyQzDeUWIIt6eNoqVGvlSpeEllIyDahKpVIqxiSz+UJihrA4w98e8BAIBKuUyHsvMQRkMrUwsFiPo81AoJKlWKtgeD16Pl87OTtrb20ln0qSSKXw+H4lEglw2RzabZXxsnHEZJxwKEwqHpo2U9EY8vDJW4XCmwpAT4lvV4WXbcJmCJ8J73vseVq9eRSabZcvmLezevXvyteNjp7fRoe2xiSfixONxcrkcmWyGSlVxYGAIj9ePhNs5MpqkmE2TtSKUSxYTExMopRqWKGEcVJNIpVIMJjMME2fA2Y9sQcxHwO8HVcPn85oqEgZDC1Of3wl602QzaWKJtmOOxWNx4rE4+XyeiYkJbNsmEo1QKpXIZrLk8tph2R5bj6pCoclrvj4P9dJImaqCRMBiSdzDtuEyu8fLJAIWg5UQvUuW89Yla7k8lWLnyzvZtWc31XKFwMI17Bg5moauFGzevIn+/gUsWrgQ23Ns4kYi4KO3u5taucjw3iyjeUUwEmJ86FUq0QCBnjYmMhOMpdINTZQw34AN5Pnnn2dsbAyAbDbLXc+OUVqwZPK4JzvE3h1DeC0T3jMY5gM6zDfIK9ufP+UNZVXVyGdzZHM5KpUyqgaFUoFivki5XEIsi/4ly2nv7KI8PAh0kyvr6EpfxJ6sTHFgosqBiRwQg1S9IKwX4msIXrIGgPv3lIDSsQZ0XMxQEbbuPn5NlgC3XRYjGo+TDER5QVZQLvl5nW+EkYkUXYkywVCEdK7Ak08+eYxWr9fLpZdeOieFBYyDahC5XI5Xdu9hz7CujLx//36ywW68QGloD9dech750SNctGohHkuHBAwGQ2vT3d1NT+xVOk5r+3gL4jEgRrFQIJ1Ok81WqUVtKlU/oxNZxoeHKBWLDO97heXBPNKxFJ/H5qqFAbpCFm9cFGA4p0N+M9lI8sCBA5M3x8dYZFkEuxZT9YZ4dSzP2t4IOStIFj/UINCzjNLAywTDEcIhPwOpMTJ7jhzzP3rjARYtGp7cLHI2MQ6qQaRSKXLlKr5wnGUrL+CXm7fi6boIpWp0DT3NZb0XMFrx0x4Lc9VVV7X0DqYGg0HT19fHO9/xdiqVyqkbT0N98e/Bg9ibYIMAABauSURBVAf5zaYtDBa9RMIhytEgZPazMBjF6/chuTw5Qrx+QQDL1tGVXbsGOO+8ntM6z3B7B08/8ypbt25l6MjQMcdKF1xNZM0Gfvzz3/BEaT/LL3/L5LFKtJfzO8PUqjXau3pJnLeSUPDoTsIH9u6iUk0zVzuzGwfVIJLJJPlSlWgigWXbPLv7IKEei0pqiCvXX04hl6M9FiGR0HW1DAbD/OBsQ1vxeJyFCxcyPDzMxCuDUK3QlYgRCNWIRcJ4/AFy+ZxOrgB8fh/BYJDqDJxiV3cXGzduZOM7NjIwOMBzzz036awqyQEA7HgvO379c0IXbJgsI34kW2NlyKZW1XtV+QNBQuGjN88ejxdOskvI2WIcVINIpVLkS1X6onEefvgRqoF2fSA7wtq168mlxokEvKaCucFwDmJZFm1tbXQksuRKVZYvX8LASIqSKJ1pl4hTLpXJF/Lkc3lSyRSjY2MMDgwSCAYIBpzSaKdKrhM96uvr65t0Vk89t51tgKetVzeJdoGzR+NgtgqdsGnTJt73/vfN6XswHcZBNYhkMkmuVCUUjfDQzx/C06YnMxfEfHg8HixqBL22mXsyGM5R4vE4Qd8A+XKVSMBHd2eCZC3E0iVLyToVKrw+L7FYjGpFL6C1PbZeZ5XOIJYQ8AcIBAME/IHjMvWOw3FW1/f1se/JFBkCvPdDH2VryaK+10eyUOPw0EjTphyMg2oAuVyObL4AlocXX9zOnt17aLv2WgDWX7iMQCDAeLFIMBEyIyiD4RwlkUgQ9NoEvTaBQIBytcbB4RQej4d4XK9XqtaqZLNZspksoXCIrq4uVE1RKBYo5AsUigXyeb1uxePxEAgE9MJcv/+k5ZZ6IjaZ8Qr+BavIvVrAbwvtQYuBTJWXDgxz2YoVjXobjsE4qAaQSqXIl2tIIMq/3ns/drgNT6wLlOL8/nYCfh8WNSIhs8WGwXCuUt+LKl/20NvbS+3wYahlKBby+AN6nsu2dCmlWDTG8PAwfX195HI5ctns5FxYuVymUChQLBYnK1iAnrvy+7Sz8vl9xzis3ojN7vEKzw2WJh/XHVRsyYUof4lUsYYvV6bE0TT1VLGGvzx374lxUHPE4cOHGRrS2TLpdJrNR+D+Q8D519Fxvm6T8NbIjQ8zlE8R9FomvGcwnMPEYjFCfi/FSk1XnsjlCPrG2bPzJbxe33HtD+/fTch71MmUK+XJUVSxWEApQEGpXKJcKlEslSiXyzp6J3r9ktfrJdHeQU9Izz+NFXQyRN1BAWwdtdg6GoD9E8DEcXZEPAHee82svx2AcVBzQq1W45lnnmHfSJZ6LHf7uC5nUitmUdUKXo+HyxbFyCcH6e1tIxAL0N7e3kSrDQZDM7Esi/b2dmq1Udrb2ykUCvTGBiiUs1DKHtfemxshUOqcfBwAon7A76GmwhQLBfKFAsVakaJdgiCogEWpqB1VMZukVC6z89B+Fq26mJ5AjExF8HuEVQmLRMjL1kiJiUIFFNi2hWXbWHLUKVYqZcJ2bc7eE+Og5oB0Ok2uWCZbtVi4ZDkAo3uHgBqVp3/MxOA+Pv3nnyYWquArRzhvUS/Lly+np+f01jQYDAZ3cumll1IoFIhEIqxYsUJviVGdPo87aFW56qr1p/V/K5WKnrtyki2KRR2mO3DgANsOjBIK2Lx7iaJYLFCr1ailM4xl4F19forFIh6Ph96+Xnp6eohGji6D2b1jG77i8QuAZwvjoOaAesZeNJ6gu38hyVyRieIgXgtuuuF6kuPj9PX1Uc6lCYuX3t5e+vv7m222wWBoMoFAYHIe2rZtFixYcMK2e/bsOePqDdWqrmT+29/+liPpEpZl0dHZAWhnViqWKJVKlMqlU6euzyHGQc0B9aSISLvOyNv2qi4N0u6rEQwEWHrxxYTDYUaTowQDlsncMxgMDcW2beLxOKtWreLwSIq0hFm4YAGFQpF8IU+xUKRSdRYCKz2/VX9dIzEOag7QVSMq9ESjDA0PsWtITyy2eSu0tbdhe2w6OzvZv3MbwWjEOCiDwdAU9Norm8FkhkAgSCAQJIFO1qpUKhSLRQrFAqViabKCRSM5/X2IDadFrVZjYmKCfLnK7r37uP3229lxYASABXGd4tnV1UW5WMQrEI1G8PmOz9AxGAyGuSYajRIO+CgX81TKx+aLezwewuEwHe0d9PX10dHegTQ43mcc1CyTTqfJlSoMj47z5a98mUK+oMuFAMu6IsRiMaKRKJmJFCG/bUZPBoOhaYiITm/32WTSjd0t93QwIb4Zks/nJ9c3TeWBHeM89PI4n74izqMv7OMnw20E33wbQcAORPCIIu6pUCsXOHL4AKPDQ4S9xkEZDIbmosN8HoYGDlEs5Gf02nwui28Op6WMg5ohzz77LLsPDFB5zf4v397hZ7ho8T/+5Ume2n2E8EXnHXN8Vaef1JFD2BkdzvMA0ajfLM41GAxNpa2tjXjQw3h2nFTu9LaLr+MDAgHvnCVPGAc1A5RSJJNJ9o/l6OxZgIiOx5aqipGi3tnyqf0TeLv12qf8M/fx4Xe/hSWLl9CTCHFo5zDn97dPrncKBoN0dnZOfzKDwWBoAP39/Vxy0YWUSqVTN54Gn89Hb2/vLFulMQ5qBqTTabKFEl5/kBWrdTXyYrHI93/yCxS6g3ydi7FjXQB8/IaNrFq+mL7ePo4cOkDQZ9Pd3c26deuapsFgMBimYlkWq1evbrYZ02KSJGZAfU+nsLOSulqr8r3vf49fbN462cbbsRDL6yfiFdatPp/+/n4syyKTTpntNAwGg2EGGAc1hS1btnDzzTdz5513ksvljjk2NjbGPffcQypXQGwPe/buYe/evVx6yaV4246vArGsK0JnZ+dkWmY2PUHIZ5IiDAaD4XRp6RCfiGwEvg7YwD8ppb40V+fat28fb33rW8nlctx11118/vOfZ9GiRQAMDw8zOjoKwE1/8Ckuu/pawraXQqGoV2QvWEERiPmEiZJOnljefbReVbVSoVDIEepqIxaLzZUEg8FgcBUtO4ISERv4X8A7gQuBD4nIhXNxLqUUt9566zGjpmw2y44dO9ixY8ekcwLYs/8gYnkolyuEQiF8oTAlTxhL4OpVR4u9LmkPHf1fmTQhr00sFjvppmEGg8FgOEorj6DWA7uUUnsARORu4D3A9tk+0eHDh3n88cenPRZZ9zaC512JZQn+QJBMooP7X60BBWy7RE08KKAv6mNR9GiqZZe/RjatSxyNjw4TNOE9g8FgmBGilDp1qyYgIjcAG5VStziPbwauUErdPqXNrcCtAD09PZfdfffdZ3SuTCbDiy++yA9+8AM6Ozu58cYbSaVSpFIpnqktZQcnrihcZylDrGSQ/+BCgpS5WnYcczzhh7Wrz5uzdMw6mUyGSCQyp+eYa9ygoY4btLhBQx2jpbWoa9iwYcO0NZTmtYOayuWXX66eeuqpMzrXww8/TG9vL9lslmq1yhVXXDF5bOeRNP/vZ48c0z4UDh/z2GPBqnYbvy0M52r4bIj7jw3l+Xw+Lr300jmvu/fII4+wYcOGOT3HXOMGDXXcoMUNGuoYLa3FFA3TOqhWDvEdAhZNebzQeW7WERFWrVpFoVAgFAodc2xlT5TPfOz6uTitwWAwGE5CK8/Y/xY4X0SWiYgP+CDwk7k6mWVZxzkng8FgMDSPlh1BKaUqInI78BA6zfzbSqltTTbLYDAYDA2iZR0UgFLqAeCBZtthMBgMhsbTyiE+g8FgMJzDGAdlMBgMhpbEOCiDwWAwtCTGQRkMBoOhJTEOymAwGAwtiXFQBoPBYGhJjIMyGAwGQ0vSsrX4ZoqIDAP7zvDlncDILJrTTNygxQ0a6rhBixs01DFaWou6hhGl1MbXHnSNgzobROQppdTlzbZjNnCDFjdoqOMGLW7QUMdoaS1OpcGE+AwGg8HQkhgHZTAYDIaWxDgozT8024BZxA1a3KChjhu0uEFDHaOltTipBjMHZTAYDIaWxIygDAaDwdCSGAdlMBgMhpbknHFQIjLtnvfzETdpMRhmG7dcH27QcbYazhkH5TIiACJiN9uQM0VEFjTbhtlCRNaLSKzZdpwNIvJuEVnRbDtmiWD9Dzd8yc9zJr+jzqQvXO+gRGSjiNwL3CEi83ZRm2i6ReQR4J8AlFLV5lo1c0TkWhF5Grit2bacLSJyjYhsB24F5qWDcvpjM/AtoK/Z9pwNInKdiPwS+DsR+T0ANQ+zwETkehH5AfAXIrKk2facCVP64k4RuRrOrC9c6aCcL/OAiPwz8Fn0xRcBPi4inU017gxxOrfg/KwTkXcCiEjL96HTHz4R+SbwVeAOpdTnph5vnnVnhogEgE8BX1BK3aKUOug83/JanP6IiMh96Ovjs8AWYIlzvOU/U69FRN4O/BXwdeBJ4C0i0t9Uo84AEbkW+BzwXcADfFJErnOOzYt+EZGlwN8A3wBeAm4VkVucYzPSMC8EzxSlKQD3AtcopX4C/BidVj8va1c5HbsQ2Ar8BfB5AKVUrZl2nQ5Of5SAEHCPUuoeEbFE5Hfqx5tr4RmxABhVSt0tIkEReZ+IdOGENFrZUTn9kQHuUkptUEr9CngIeI9zvOU/U9NwDfCQUuo+4CnAq5Q63GSbzoRrgZ8qpR4E/h6IAr8vIuF51C8rgMeUUvcC30FHfD4pIm1KqdpMrg1XOSgR+a8i8iUR+QCAUurflVJV5/G/AatF5A4ReWNzLT01U7S8Hya/NA4DK4HHgQERuU1Ezm+mnSdjioabnKfuAN4kIl8FngG+KCL/ICLvaJ6Vp8cULTc4T5WBNzufpXuAjwBfQ9/FtyRTNNwIoJT6V+d5CxgHDoiIv5k2ni6vvdaB+4E/EZEvAw8AS0TkH0XkVqd9S94wTKNjE/AGEQkopYbQERMb+P2mGXkKROQGEbliylMHgfeLiF8pVVBKPYLW9fmZ/m9XOCgnZPGnwE3ou6e/FpGPiUiP02QIeAv67uQw8DHnbrflmEbLFx0t7cB5wHPOKHAT8D+BO53XeZpl82uZRsNficjHlVK70V/mq51jvwu8CPznVg29TqPlDhG5RSm1Hz1C/xbwVaXUe4EvAu8WkQtbaVQ4jYYvOJ+pLpi8+dkLXKeUKjbR1FNygmv9FnRY72KgC7hBKXUN8O/oz9bSVuoPOKGOjwI70N9RPxSRh9Fzm/cC0VYL8YmeE38U+DvgL+v2KaVeBn4BfNlpJ8D/ARaJSM9M+qJlvtTOBqWUEpE3A59VSj0sIhngHYACvut4cABE5AXgTUC+KcaeghNo2Yi293H0COQB9HzB48Ae56UtkzBxAg3vEpEPKKW+ISLfcUJMiMhW4Eog10ybT8QJtLzTGRV+DfgkTlhPKfWSiGwCvM2z+HhOcn1Uge87bTaJyEERebcTEm9JTnJ93KSU+r8isgwYcJq/ABxBfw+0FNPoyAJvR18HtwDrgH6l1P2iEz6WtVqITyk1JDoB7ZfAHwKfAP63c/ivgYdE5B+VUttEpACkgcxMztFSHvlMmHJX8RTa8eDEb3cCF4jIyte85O3oL/uWc1An0fIy8DvAJejh82+VUmuADwIbRGRBq9whnkTDS8BlIrKq7pwc3oa+KAsNNfQ0OImWHcDlwAQ6weDPRGSNiHwOuAjdRy3BKa6PNSKy2mkXQ+sqN8PO0+EU18closPdvwK+4rT7L+i5wvEGm3pSTqDjZ+g+eR1wnlLqWaXU/U67y4AnGm7oSZii4RvAduDnwHUi0gfgREu+BXzTCYN/GOgGZuRk552DEmftTz2mPOWuYhd6GLzWefwoEAdiojPIbhaR54GlwF+2Qor2DLT8Gj1ZOgTcppT67077MeANSqlDDTV8CjPsjxhaByLyQRF5ET0S/Ewr3B2egZZlSqmvAHcBf4wOwd6olBptqOFTOIPrI+K0m0An4fTQIsxQSwit55uAR/RyjDXAzY62pjFDHVGOXiPvEpEn0dfIvzXU6NdwIg1KqbJSqoKectiBzmzFOfa3aCf1cWAV8HGl1IwGBvPGQYnIG0Tku8BnRaS9PmIQkXo45UmgArxdRDxKqe3ou6fLnAyyA8AfKqU+4kw+No0z0LIN/SG9RClVEBF7ygdlRkPmJmqo90d9Ldo+5m9/bEevGXo9gFLqe8CnlFIfVUoNTHOKOWcW+gPgg0qpf26k3dNxhloWAeudm7YPAR9QSt2klBpshgY4qz55nXP8FfQN6fuVUk0ZBZ5Ew+R3kMMI8BNgpYgsFD0/1eZcG59QSn3gTPpiXjgoEVmOvjN6GP1FfYeIvAu0B3d+70IPmVeg07ABijjbwCulHlFKPd5g04/jLLW86hyvNjOkN0v9sVkp9ZsGm34cZ6mlPv832bYZzMZnymnT9DDrWWgp4PSHUirXAjc9s3Gdv6KUeqaxlh/lFBqqzjyaX3S2XlUp9WtgGzrx6VH0du44A4QzYl44KGA98JJzd/fn6LVA19fjnSLyRRH5FvA0OqNkvehqBWPo2Ggr4QYtZ6PhoeaYfELO9f5oFQ113KLFDdfIqTR8Ab3Gqf74NnSixN8D65RSr5y1BUqplvsBrgduB650Hi9HZ6wtdh5fCHwJ+FPgjcC/oCcW66+PAIlm63CLFjdocJMWN2hwmxY36JgFDddOfTwbPy01ghKRPtHlV/4b0AZ8R0TeoZTaA2wGbnSavoweSsaAF5RSv6uU2iVH8/AzSqlkEyRM4gYtbtBQxw1a3KChjlu0uEHHLGioL7P4pdJhy1mjpRwUesL2N0qpNyml7kDX1brVOfYbYK2IXKF0Bt4h4GqlVAp02qNqgUywKbhBixs01HGDFjdoqOMWLW7QcbYa5iwjuukOSkQ+IiIbRJdY+RXOwkGHUfTaANDrAJ5FV8eNoFNI94lICFqjfpgbtLhBQx03aHGDhjpu0eIGHfNFQ1MqSYiIAL3oGGYN2A38ATpVd0BEvEpnuvShh5wonaL4ddHl57+Nzir5iFKqqRUI3KDFDRrquEGLGzTUcYsWN+iYlxpONUk12z+A7fxeia6mDLpUzDeAH7+mzX3Atc7f3c5vDxBttN1u1eIGDW7S4gYNbtPiBh3zVUPDRlDORNodgC26llwMp36c0hXHPwUcFpFrlFKPiogPGAZ2isjfAP9JRDYovWAt3Si7p8MNWtygoY4btLhBQx23aHGDjvmuoSFzUCJyDTrfvw1d3uMOjm5XsB4mY5l/hS4yCBAAPoaOj0bRHr3pNbXcoMUNGuq4QYsbNNRxixY36HCDhkYNL9+ErolVf/xNdPXbjwFPO89Z6PjoD9E1wdYD3wMubvSw0u1a3KDBTVrcoMFtWtygwxUaGvRGhQA/R2Ocvwf8rfP3VuCTzt+XA3c3+01xuxY3aHCTFjdocJsWN+hwg4aGhPiUro1VVEfz5d+GjnOCLol/gYj8FPgBekg6WTW31XCDFjdoqOMGLW7QUMctWtygww0aGppm7kzYKXRJ//qmaGngM+h9dPYqZ+sI5bj2VsUNWtygoY4btLhBQx23aHGDjvmsodELdWvo3UZHgHWO9/4cUFNKPaaauK/RGeAGLW7QUMcNWtygoY5btLhBx/zV0OiYInp77xrwGHoDq6bHOc9lLW7Q4CYtbtDgNi1u0DFfNYhjfMMQkYXAzcCdSqliQ08+y7hBixs01HGDFjdoqOMWLW7QMV81NNxBGQwGg8FwOjS9WKzBYDAYDNNhHJTBYDAYWhLjoAwGg8HQkhgHZTAYDIaWxDgog8FgMLQkxkEZDAaDoSUxDspgMBgMLcn/B7Bvu5SErk6zAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1137,7 +1147,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2.06 s ± 97.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "1.89 s ± 223 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], @@ -1286,7 +1296,7 @@ " k 1.02 (41) [ 0.78 (43) ] \n", "\n", "Settings:\n", - " svdcut/n = 1e-12/1 tol = (1e-08,1e-10,1e-10*) (itns/time = 117/2.2)\n", + " svdcut/n = 1e-12/1 tol = (1e-08,1e-10,1e-10*) (itns/time = 117/1.8)\n", " fitter = scipy_least_squares method = trf\n", "\n" ] @@ -1324,73 +1334,73 @@ " hosp_prop\n", " 0.024(10)\n", " 0.0378(71)\n", - " 0.0238(25)\n", - " 0.0139(76)\n", - " 1.839339\n", + " 0.0235(30)\n", + " 0.0142(78)\n", + " 1.830691\n", " \n", " \n", " logistic_x0\n", " 20.7(6.9)\n", " 25.7(1.1)\n", - " 25.42(37)\n", + " 25.41(42)\n", " 0.3(1.1)\n", - " 0.256967\n", + " 0.257920\n", " \n", " \n", " incubation_days\n", " 4.6(1.5)\n", " 3.0(1.1)\n", - " 3.24(28)\n", + " 3.25(29)\n", " -0.2(1.1)\n", - " 0.191273\n", + " 0.201248\n", " \n", " \n", " logistic_k\n", " 0.78(43)\n", " 1.02(41)\n", - " 0.95(12)\n", - " 0.07(43)\n", - " 0.164162\n", - " \n", - " \n", - " recovery_days\n", - " 15.3(5.0)\n", - " 17.1(4.9)\n", - " 16.5(1.6)\n", - " 0.6(5.2)\n", - " 0.120074\n", + " 0.94(14)\n", + " 0.08(43)\n", + " 0.188333\n", " \n", " \n", " beta\n", " 0.32(12)\n", " 0.478(89)\n", - " 0.469(24)\n", - " 0.009(93)\n", - " 0.095106\n", + " 0.467(26)\n", + " 0.011(93)\n", + " 0.120969\n", " \n", " \n", " logistic_L\n", " 0.37(23)\n", " 0.793(47)\n", - " 0.788(17)\n", + " 0.787(19)\n", " 0.005(50)\n", - " 0.094641\n", + " 0.108672\n", " \n", " \n", " hosp_LOS\n", " 11.64(83)\n", " 11.49(83)\n", - " 11.55(25)\n", - " -0.06(87)\n", - " 0.067488\n", + " 11.59(29)\n", + " -0.09(88)\n", + " 0.107157\n", + " \n", + " \n", + " recovery_days\n", + " 15.3(5.0)\n", + " 17.1(4.9)\n", + " 16.6(1.7)\n", + " 0.5(5.2)\n", + " 0.105776\n", " \n", " \n", " nu\n", " 2.46(25)\n", " 2.46(25)\n", - " 2.440(72)\n", + " 2.440(73)\n", " 0.02(26)\n", - " 0.066927\n", + " 0.069792\n", " \n", " \n", "\n", @@ -1398,26 +1408,26 @@ ], "text/plain": [ " Priors PDF from normal approx PDF from general dists \\\n", - "hosp_prop 0.024(10) 0.0378(71) 0.0238(25) \n", - "logistic_x0 20.7(6.9) 25.7(1.1) 25.42(37) \n", - "incubation_days 4.6(1.5) 3.0(1.1) 3.24(28) \n", - "logistic_k 0.78(43) 1.02(41) 0.95(12) \n", - "recovery_days 15.3(5.0) 17.1(4.9) 16.5(1.6) \n", - "beta 0.32(12) 0.478(89) 0.469(24) \n", - "logistic_L 0.37(23) 0.793(47) 0.788(17) \n", - "hosp_LOS 11.64(83) 11.49(83) 11.55(25) \n", - "nu 2.46(25) 2.46(25) 2.440(72) \n", + "hosp_prop 0.024(10) 0.0378(71) 0.0235(30) \n", + "logistic_x0 20.7(6.9) 25.7(1.1) 25.41(42) \n", + "incubation_days 4.6(1.5) 3.0(1.1) 3.25(29) \n", + "logistic_k 0.78(43) 1.02(41) 0.94(14) \n", + "beta 0.32(12) 0.478(89) 0.467(26) \n", + "logistic_L 0.37(23) 0.793(47) 0.787(19) \n", + "hosp_LOS 11.64(83) 11.49(83) 11.59(29) \n", + "recovery_days 15.3(5.0) 17.1(4.9) 16.6(1.7) \n", + "nu 2.46(25) 2.46(25) 2.440(73) \n", "\n", " diff z \n", - "hosp_prop 0.0139(76) 1.839339 \n", - "logistic_x0 0.3(1.1) 0.256967 \n", - "incubation_days -0.2(1.1) 0.191273 \n", - "logistic_k 0.07(43) 0.164162 \n", - "recovery_days 0.6(5.2) 0.120074 \n", - "beta 0.009(93) 0.095106 \n", - "logistic_L 0.005(50) 0.094641 \n", - "hosp_LOS -0.06(87) 0.067488 \n", - "nu 0.02(26) 0.066927 " + "hosp_prop 0.0142(78) 1.830691 \n", + "logistic_x0 0.3(1.1) 0.257920 \n", + "incubation_days -0.2(1.1) 0.201248 \n", + "logistic_k 0.08(43) 0.188333 \n", + "beta 0.011(93) 0.120969 \n", + "logistic_L 0.005(50) 0.108672 \n", + "hosp_LOS -0.09(88) 0.107157 \n", + "recovery_days 0.5(5.2) 0.105776 \n", + "nu 0.02(26) 0.069792 " ] }, "execution_count": 25, @@ -1453,7 +1463,7 @@ ")\n", "comparison[\"z\"] = comparison[\"diff\"].apply(lambda x: abs(x.mean) / x.sdev)\n", "\n", - "#Present\n", + "# Present\n", "comparison.sort_values(\"z\", ascending=False)" ] }, From 9bb092852555fe302afa4fe14b37c5125bf43d89 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 17:47:58 +0200 Subject: [PATCH 36/40] Implemented vent and icu admits and census (not tested) * Changed hospital related model parameter names to just "hospital" to allow looping * SEIR now inherits parameters from SIR --- bayes_chime/normal/models/seir.py | 27 +++++--------------- bayes_chime/normal/models/sir.py | 42 ++++++++++++++++++++----------- tests/normal/models/sir_test.py | 8 +++--- 3 files changed, 38 insertions(+), 39 deletions(-) diff --git a/bayes_chime/normal/models/seir.py b/bayes_chime/normal/models/seir.py index 265c84b..ba3dc4b 100644 --- a/bayes_chime/normal/models/seir.py +++ b/bayes_chime/normal/models/seir.py @@ -10,31 +10,14 @@ class SEIRModel(SIRModel): """Basic SEIR model """ - model_parameters: List[str] = [ - "dates", # DatetimeIndex - "initial_susceptible", - "initial_exposed", - "initial_infected", - "inital_recovered", - "beta", # or inital_doubling_time - "gamma", # or recovery_days + model_parameters: List[str] = SIRModel.model_parameters + [ "alpha", # or incubation_days ] - optional_parameters: List[str] = [ - "recovery_days", - "inital_doubling_time", + optional_parameters: List[str] = SIRModel.model_parameters + [ "incubation_days", - # all keywords below are used to compute hospital admissions and census - "initial_hospitalized", - "market_share", - "hospitalization_probability", - "hospital_length_of_stay", ] - compartments: List[str] = [ - "susceptible", + compartments: List[str] = SIRModel.compartments + [ "exposed", - "infected", - "recovered", ] def parse_input( # pylint: disable=R0201 @@ -67,7 +50,9 @@ def simulation_step( gamma: Recovery rate for infected nu: changes effect of susceptible for exposed to `(S/N) ** nu` optional: - hospitalization_probability: Percent of new cases becoming hospitalized + hospital_probability: Percent of new cases becoming hospitalized + icu_probability: Percent of new hospitalizations being treated in icu + vent_probability: Percent of new icu cases in need of ventilation market_share: Market share of hospital Returns: diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index 50ad3d0..5cf0901 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -20,16 +20,21 @@ class SIRModel(CompartmentModel): "inital_recovered", "beta", # or inital_doubling_time "gamma", # or recovery_days - "nu", ] optional_parameters: List[str] = [ "recovery_days", "inital_doubling_time", # all keywords below are used to compute hospital admissions and census - "initial_hospitalized", "market_share", - "hospitalization_probability", + "initial_hospital", + "hospital_probability", "hospital_length_of_stay", + "initial_icu", + "icu_probability", + "icu_length_of_stay", + "initial_vent", + "vent_probability", + "vent_length_of_stay", ] compartments: List[str] = ["susceptible", "infected", "recovered"] @@ -64,15 +69,16 @@ def post_process_simulation( # pylint: disable=R0201, W0613, C0103 df = df.fillna(0) # Add hosp census - hosp_keys = set(["initial_hospitalized", "hospital_length_of_stay"]) - if hosp_keys.issubset(pars.keys()) and "hospital_admits" in df.columns: + for kind in ["hospital", "icu", "vent"]: + cenus_keys = set([f"initial_{kind}", f"{kind}_length_of_stay"]) + if cenus_keys.issubset(pars.keys()) and f"{kind}_admits" in df.columns: - census = [pars["initial_hospitalized"]] - for admits in df.hospital_admits.values[1:]: - census.append( - admits + (1 - 1 / pars["hospital_length_of_stay"]) * census[-1] - ) - df["hospital_census"] = census + census = [pars[f"initial_{kind}"]] + for admits in df.hospital_admits.values[1:]: + census.append( + admits + (1 - 1 / pars[f"{kind}_length_of_stay"]) * census[-1] + ) + df[f"{kind}_census"] = census return df @@ -90,7 +96,9 @@ def simulation_step( beta: Growth rate for infected gamma: Recovery rate for infected optional: - hospitalization_probability: Percent of new cases becoming hospitalized + hospital_probability: Percent of new cases becoming hospitalized + icu_probability: Percent of new hospitalizations being treated in icu + vent_probability: Percent of new icu cases in need of ventilation market_share: Market share of hospital Returns: @@ -124,11 +132,17 @@ def simulation_step( "recovered_new": d_ir * rescale, } - if "hospitalization_probability" in pars and "market_share" in pars: + if "hospital_probability" in pars and "market_share" in pars: out["hospital_admits"] = ( out["infected_new"] - * pars["hospitalization_probability"] + * pars["hospital_probability"] * pars["market_share"] ) + if "icu_probability" in pars: + out["icu_admits"] = out["hospital_admits"] * pars["icu_probability"] + + if "vent_probability" in pars: + out["vent_admits"] = out["icu_admits"] * pars["vent_probability"] + return out diff --git a/tests/normal/models/sir_test.py b/tests/normal/models/sir_test.py index 00a904f..0750a8e 100644 --- a/tests/normal/models/sir_test.py +++ b/tests/normal/models/sir_test.py @@ -99,9 +99,9 @@ def fixture_sir_data_wo_policy(penn_chime_setup, penn_chime_raw_df_no_policy): "gamma": simsir.gamma, "initial_susceptible": day0.susceptible, "initial_infected": day0.infected, - "initial_hospitalized": day0.hospitalized, + "initial_hospital": day0.hospitalized, "initial_recovered": day0.recovered, - "hospitalization_probability": simsir.rates["hospitalized"], + "hospital_probability": simsir.rates["hospitalized"], } x = { "dates": DatetimeIndex(raw_df.index), @@ -126,9 +126,9 @@ def fixture_sir_data_w_policy(penn_chime_setup): "gamma": simsir.gamma, "initial_susceptible": day0.susceptible, "initial_infected": day0.infected, - "initial_hospitalized": day0.hospitalized, + "initial_hospital": day0.hospitalized, "initial_recovered": day0.recovered, - "hospitalization_probability": simsir.rates["hospitalized"], + "hospital_probability": simsir.rates["hospitalized"], } x = { "dates": DatetimeIndex(raw_df.index), From f323c278bbc87f572c90aeaa4fb236125908b343 Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 18:13:24 +0200 Subject: [PATCH 37/40] Moved admits and census computation entirely to post process and enabled looping --- bayes_chime/normal/models/seir.py | 12 ------- bayes_chime/normal/models/sir.py | 56 +++++++++++++++---------------- 2 files changed, 28 insertions(+), 40 deletions(-) diff --git a/bayes_chime/normal/models/seir.py b/bayes_chime/normal/models/seir.py index ba3dc4b..8915f51 100644 --- a/bayes_chime/normal/models/seir.py +++ b/bayes_chime/normal/models/seir.py @@ -49,11 +49,6 @@ def simulation_step( alpha: Incubation rate for infected gamma: Recovery rate for infected nu: changes effect of susceptible for exposed to `(S/N) ** nu` - optional: - hospital_probability: Percent of new cases becoming hospitalized - icu_probability: Percent of new hospitalizations being treated in icu - vent_probability: Percent of new icu cases in need of ventilation - market_share: Market share of hospital Returns: Updated compartments and optionally additional information like change @@ -92,11 +87,4 @@ def simulation_step( "recovered_new": d_ir * rescale, } - if "hospitalization_probability" in pars and "market_share" in pars: - out["hospital_admits"] = ( - out["infected_new"] - * pars["hospitalization_probability"] - * pars["market_share"] - ) - return out diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index 5cf0901..fe2d35f 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -63,22 +63,40 @@ def parse_input( # pylint: disable=R0201 def post_process_simulation( # pylint: disable=R0201, W0613, C0103 self, df: DataFrame, **pars: Dict[str, FloatOrDistVar] ) -> DataFrame: - """Compute Census based on exponential LOS distribution if parameters present. + """Compute admits and census based on exponential LOS distribution if parameters + present. """ # fill initial hosp admits if present df = df.fillna(0) - # Add hosp census + if "market_share" in pars: + df["infected_new_local"] = df["infected_new"] * pars["market_share"] + + dependency = { + "hospital": "infected_new_local", + "icu": "hospital", + "vent": "icu", + } + for kind in ["hospital", "icu", "vent"]: - cenus_keys = set([f"initial_{kind}", f"{kind}_length_of_stay"]) - if cenus_keys.issubset(pars.keys()) and f"{kind}_admits" in df.columns: + # Check if it is possible to compute admits + if not (f"{kind}_probability" in pars and dependency[kind] in df): + break # if not stop + + df[f"{kind}_admits"] = df[dependency[kind]] * pars[f"{kind}_probability"] - census = [pars[f"initial_{kind}"]] - for admits in df.hospital_admits.values[1:]: - census.append( - admits + (1 - 1 / pars[f"{kind}_length_of_stay"]) * census[-1] - ) - df[f"{kind}_census"] = census + for kind in ["hospital", "icu", "vent"]: + # Check if it is possible to compute census + keys = set([f"initial_{kind}", f"{kind}_length_of_stay"]) + if not (keys.issubset(pars.keys()) and f"{kind}_admits" in df.columns): + break # if not stop + + census = [pars[f"initial_{kind}"]] + for admits in df.hospital_admits.values[1:]: + census.append( + admits + (1 - 1 / pars[f"{kind}_length_of_stay"]) * census[-1] + ) + df[f"{kind}_census"] = census return df @@ -95,11 +113,6 @@ def simulation_step( pars: beta: Growth rate for infected gamma: Recovery rate for infected - optional: - hospital_probability: Percent of new cases becoming hospitalized - icu_probability: Percent of new hospitalizations being treated in icu - vent_probability: Percent of new icu cases in need of ventilation - market_share: Market share of hospital Returns: Updated compartments and optionally additional information like change @@ -132,17 +145,4 @@ def simulation_step( "recovered_new": d_ir * rescale, } - if "hospital_probability" in pars and "market_share" in pars: - out["hospital_admits"] = ( - out["infected_new"] - * pars["hospital_probability"] - * pars["market_share"] - ) - - if "icu_probability" in pars: - out["icu_admits"] = out["hospital_admits"] * pars["icu_probability"] - - if "vent_probability" in pars: - out["vent_admits"] = out["icu_admits"] * pars["vent_probability"] - return out From e9ea031f9575988bc64ba9a11470f55d487614cf Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 19:03:13 +0200 Subject: [PATCH 38/40] New census implementation --- bayes_chime/normal/models/seir.py | 2 +- bayes_chime/normal/models/sir.py | 32 +++++++++++++------------------ 2 files changed, 14 insertions(+), 20 deletions(-) diff --git a/bayes_chime/normal/models/seir.py b/bayes_chime/normal/models/seir.py index 8915f51..0646240 100644 --- a/bayes_chime/normal/models/seir.py +++ b/bayes_chime/normal/models/seir.py @@ -13,7 +13,7 @@ class SEIRModel(SIRModel): model_parameters: List[str] = SIRModel.model_parameters + [ "alpha", # or incubation_days ] - optional_parameters: List[str] = SIRModel.model_parameters + [ + optional_parameters: List[str] = SIRModel.optional_parameters + [ "incubation_days", ] compartments: List[str] = SIRModel.compartments + [ diff --git a/bayes_chime/normal/models/sir.py b/bayes_chime/normal/models/sir.py index fe2d35f..babb742 100644 --- a/bayes_chime/normal/models/sir.py +++ b/bayes_chime/normal/models/sir.py @@ -2,9 +2,10 @@ """ from typing import Dict, List -from numpy import log +from numpy import log, NaN from pandas import DataFrame + from bayes_chime.normal.utilities import FloatOrDistVar, NormalDistVar from bayes_chime.normal.models.base import CompartmentModel @@ -69,32 +70,25 @@ def post_process_simulation( # pylint: disable=R0201, W0613, C0103 # fill initial hosp admits if present df = df.fillna(0) - if "market_share" in pars: - df["infected_new_local"] = df["infected_new"] * pars["market_share"] + # Local infections + df["infected_new_local"] = df["infected_new"] * pars.get("market_share", NaN) dependency = { "hospital": "infected_new_local", - "icu": "hospital", - "vent": "icu", + "icu": "hospital_admits", + "vent": "icu_admits", } for kind in ["hospital", "icu", "vent"]: - # Check if it is possible to compute admits - if not (f"{kind}_probability" in pars and dependency[kind] in df): - break # if not stop - - df[f"{kind}_admits"] = df[dependency[kind]] * pars[f"{kind}_probability"] - - for kind in ["hospital", "icu", "vent"]: - # Check if it is possible to compute census - keys = set([f"initial_{kind}", f"{kind}_length_of_stay"]) - if not (keys.issubset(pars.keys()) and f"{kind}_admits" in df.columns): - break # if not stop + df[f"{kind}_admits"] = df[dependency[kind]].values * pars.get( + f"{kind}_probability", NaN + ) - census = [pars[f"initial_{kind}"]] - for admits in df.hospital_admits.values[1:]: + census = [pars.get(f"initial_{kind}", NaN)] + for base in df[f"{kind}_admits"].values[1:]: census.append( - admits + (1 - 1 / pars[f"{kind}_length_of_stay"]) * census[-1] + base + + (1 - 1 / pars.get(f"{kind}_length_of_stay", NaN)) * census[-1] ) df[f"{kind}_census"] = census From 899d01f407b202b7404b3a57d79299ad4db9fbec Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 22:43:20 +0200 Subject: [PATCH 39/40] Added new vent fits to notebook --- ...-to-use-normal-approximations-module.ipynb | 859 ++++++++---------- 1 file changed, 378 insertions(+), 481 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index 744f651..e6b9a4a 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -244,7 +244,7 @@ " \n", " 0\n", " n_hosp\n", - " 1.000\n", + " 1.000000e+00\n", " constant\n", " NaN\n", " NaN\n", @@ -253,7 +253,7 @@ " \n", " 1\n", " hosp_prop\n", - " 0.025\n", + " 2.500000e-02\n", " gamma\n", " 6.326833\n", " 0.004169\n", @@ -262,7 +262,7 @@ " \n", " 2\n", " ICU_prop\n", - " 0.450\n", + " 4.500000e-01\n", " beta\n", " 52.059311\n", " 96.867420\n", @@ -271,7 +271,7 @@ " \n", " 3\n", " vent_prop\n", - " 0.660\n", + " 6.600000e-01\n", " beta\n", " 5.224029\n", " 3.078885\n", @@ -280,30 +280,173 @@ " \n", " 4\n", " hosp_LOS\n", - " 12.000\n", + " 1.200000e+01\n", " gamma\n", " 195.497640\n", " 0.059681\n", " Hospital Length of Stay\n", " \n", + " \n", + " 5\n", + " ICU_LOS\n", + " 9.000000e+00\n", + " gamma\n", + " 231.467053\n", + " 0.058324\n", + " ICU Length of Stay\n", + " \n", + " \n", + " 6\n", + " vent_LOS\n", + " 1.111111e+00\n", + " gamma\n", + " 73.324820\n", + " 0.268274\n", + " time on vent\n", + " \n", + " \n", + " 7\n", + " mkt_share\n", + " 2.600000e-01\n", + " constant\n", + " NaN\n", + " NaN\n", + " Hospital Market Share (%)\n", + " \n", + " \n", + " 8\n", + " region_pop\n", + " 1.200000e+06\n", + " constant\n", + " NaN\n", + " NaN\n", + " Regional Population\n", + " \n", + " \n", + " 9\n", + " incubation_days\n", + " 5.000000e+00\n", + " gamma\n", + " 9.514379\n", + " 0.513980\n", + " Days from exposure to infectiousness\n", + " \n", + " \n", + " 10\n", + " recovery_days\n", + " 1.400000e+01\n", + " gamma\n", + " 9.833457\n", + " 1.642266\n", + " Days from infection to recovery\n", + " \n", + " \n", + " 11\n", + " logistic_k\n", + " 1.000000e+00\n", + " gamma\n", + " 4.018954\n", + " 0.227382\n", + " logistic growth rate\n", + " \n", + " \n", + " 12\n", + " logistic_x0\n", + " 1.400000e+01\n", + " gamma\n", + " 6.407435\n", + " 2.859728\n", + " logistic days from beginning of time series to...\n", + " \n", + " \n", + " 13\n", + " logistic_L\n", + " 5.000000e-01\n", + " beta\n", + " 2.000000\n", + " 3.000000\n", + " logistic depth of social distancing\n", + " \n", + " \n", + " 14\n", + " nu\n", + " 2.500000e+00\n", + " gamma\n", + " 93.955217\n", + " 0.026343\n", + " Networked contact structure power-law exponent\n", + " \n", + " \n", + " 15\n", + " beta\n", + " 2.500000e-01\n", + " beta\n", + " 5.000000\n", + " 10.000000\n", + " SEIR beta parameter (force of infection)\n", + " \n", + " \n", + " 16\n", + " hosp_capacity\n", + " NaN\n", + " constant\n", + " NaN\n", + " NaN\n", + " Hospital Bed Capacity\n", + " \n", + " \n", + " 17\n", + " vent_capacity\n", + " 3.830000e+02\n", + " constant\n", + " NaN\n", + " NaN\n", + " Ventilator Capacity\n", + " \n", " \n", "\n", "" ], "text/plain": [ - " param base distribution p1 p2 \\\n", - "0 n_hosp 1.000 constant NaN NaN \n", - "1 hosp_prop 0.025 gamma 6.326833 0.004169 \n", - "2 ICU_prop 0.450 beta 52.059311 96.867420 \n", - "3 vent_prop 0.660 beta 5.224029 3.078885 \n", - "4 hosp_LOS 12.000 gamma 195.497640 0.059681 \n", + " param base distribution p1 p2 \\\n", + "0 n_hosp 1.000000e+00 constant NaN NaN \n", + "1 hosp_prop 2.500000e-02 gamma 6.326833 0.004169 \n", + "2 ICU_prop 4.500000e-01 beta 52.059311 96.867420 \n", + "3 vent_prop 6.600000e-01 beta 5.224029 3.078885 \n", + "4 hosp_LOS 1.200000e+01 gamma 195.497640 0.059681 \n", + "5 ICU_LOS 9.000000e+00 gamma 231.467053 0.058324 \n", + "6 vent_LOS 1.111111e+00 gamma 73.324820 0.268274 \n", + "7 mkt_share 2.600000e-01 constant NaN NaN \n", + "8 region_pop 1.200000e+06 constant NaN NaN \n", + "9 incubation_days 5.000000e+00 gamma 9.514379 0.513980 \n", + "10 recovery_days 1.400000e+01 gamma 9.833457 1.642266 \n", + "11 logistic_k 1.000000e+00 gamma 4.018954 0.227382 \n", + "12 logistic_x0 1.400000e+01 gamma 6.407435 2.859728 \n", + "13 logistic_L 5.000000e-01 beta 2.000000 3.000000 \n", + "14 nu 2.500000e+00 gamma 93.955217 0.026343 \n", + "15 beta 2.500000e-01 beta 5.000000 10.000000 \n", + "16 hosp_capacity NaN constant NaN NaN \n", + "17 vent_capacity 3.830000e+02 constant NaN NaN \n", "\n", - " description \n", - "0 Number of hospitalized COVID-19 patients on day 1 \n", - "1 Prportion of infections requiring hospitalization \n", - "2 Proportion of hospitalizations admitted to ICU \n", - "3 Proportion of ICU patients requiring ventilation \n", - "4 Hospital Length of Stay " + " description \n", + "0 Number of hospitalized COVID-19 patients on day 1 \n", + "1 Prportion of infections requiring hospitalization \n", + "2 Proportion of hospitalizations admitted to ICU \n", + "3 Proportion of ICU patients requiring ventilation \n", + "4 Hospital Length of Stay \n", + "5 ICU Length of Stay \n", + "6 time on vent \n", + "7 Hospital Market Share (%) \n", + "8 Regional Population \n", + "9 Days from exposure to infectiousness \n", + "10 Days from infection to recovery \n", + "11 logistic growth rate \n", + "12 logistic days from beginning of time series to... \n", + "13 logistic depth of social distancing \n", + "14 Networked contact structure power-law exponent \n", + "15 SEIR beta parameter (force of infection) \n", + "16 Hospital Bed Capacity \n", + "17 Ventilator Capacity " ] }, "execution_count": 4, @@ -313,7 +456,7 @@ ], "source": [ "PRIOR_DF = read_csv(path.join(DATA, f\"params.csv\"))\n", - "PRIOR_DF.head()" + "PRIOR_DF" ] }, { @@ -484,7 +627,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -506,124 +649,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
val
hosp_prop0.0235(30)
ICU_prop0.368(11)
vent_prop0.764(40)
hosp_LOS11.59(29)
ICU_LOS13.45(26)
vent_LOS19.62(61)
incubation_days3.25(29)
recovery_days16.6(1.7)
logistic_k0.94(14)
logistic_x025.41(42)
logistic_L0.787(19)
nu2.440(73)
beta0.467(26)
\n", - "
" - ], - "text/plain": [ - " val\n", - "hosp_prop 0.0235(30)\n", - "ICU_prop 0.368(11)\n", - "vent_prop 0.764(40)\n", - "hosp_LOS 11.59(29)\n", - "ICU_LOS 13.45(26)\n", - "vent_LOS 19.62(61)\n", - "incubation_days 3.25(29)\n", - "recovery_days 16.6(1.7)\n", - "logistic_k 0.94(14)\n", - "logistic_x0 25.41(42)\n", - "logistic_L 0.787(19)\n", - "nu 2.440(73)\n", - "beta 0.467(26)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "keys = PRIORS.keys()\n", "POSTERIORS = avg_data(POSTERIOR_DF.T.loc[keys].T.values, median=True, spread=True)\n", @@ -667,7 +695,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -686,20 +714,25 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['dates', 'initial_susceptible', 'initial_exposed', 'initial_infected', 'inital_recovered', 'beta', 'gamma', 'alpha']\n", - "['recovery_days', 'inital_doubling_time', 'incubation_days', 'initial_hospitalized', 'market_share', 'hospitalization_probability', 'hospital_length_of_stay']\n" - ] - } - ], + "outputs": [], "source": [ - "seir = SEIRModel()\n", + "from bayes_chime.normal.models import seir as ms\n", + "from bayes_chime.normal.models import sir as msi\n", + "from importlib import reload\n", + "\n", + "reload(msi)\n", + "reload(ms)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "seir = ms.SEIRModel()\n", "print(seir.model_parameters)\n", "print(seir.optional_parameters)" ] @@ -717,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -732,7 +765,9 @@ " \"initial_susceptible\": META_PARS[\"region_pop\"],\n", " \"initial_infected\": 0,\n", " \"initial_recovered\": 0,\n", - " \"initial_hospitalized\": META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"],\n", + " \"initial_hospital\": 0,\n", + " \"initial_icu\": 0,\n", + " \"initial_vent\": 0,\n", "}\n", "## Variable parameters (distributions)\n", "PP = {\n", @@ -741,8 +776,12 @@ " \"beta\": POSTERIORS[\"beta\"],\n", " \"recovery_days\": POSTERIORS[\"recovery_days\"],\n", " \"nu\": POSTERIORS[\"nu\"],\n", - " \"hospitalization_probability\": POSTERIORS[\"hosp_prop\"],\n", + " \"hospital_probability\": POSTERIORS[\"hosp_prop\"],\n", " \"hospital_length_of_stay\": POSTERIORS[\"hosp_LOS\"],\n", + " \"icu_probability\": POSTERIORS[\"ICU_prop\"],\n", + " \"icu_length_of_stay\": POSTERIORS[\"ICU_LOS\"],\n", + " \"vent_probability\": POSTERIORS[\"vent_prop\"],\n", + " \"vent_length_of_stay\": POSTERIORS[\"vent_LOS\"],\n", "}" ] }, @@ -756,7 +795,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -780,17 +819,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20.4 ms ± 1.17 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" - ] - } - ], + "outputs": [], "source": [ "%%timeit\n", "seir.propagate_uncertainties(XX, PP)" @@ -798,33 +829,21 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "FORCAST_DF_NORMAL = seir.propagate_uncertainties(XX, PP)" + "FORCAST_DF_NORMAL = seir.propagate_uncertainties(XX, PP)\n", + "FORCAST_DF_NORMAL.head()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAKYCAYAAAAmIGzwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydeXgcxZm435pLM7pG9336tnzJ4APixTgQ8G5IgGySBcICDhAIARISlhybbOKwm2xukgD7I4TDEByOAIEACZAQbI5gMBjjS7Z1jaSRNDpGmtEcmrt+f3TPWJJ1jGRLlk2/z9PPTFdXVVdVd9fXVfX19wkpJRoaGhoaGrMN3YkugIaGhoaGxmhoAkpDQ0NDY1aiCSgNDQ0NjVmJJqA0NDQ0NGYlmoDS0NDQ0JiVaAJKQ0NDQ2NWogmoDyFCiCohhBRCaN8YjEAIsUFtG9uJLsvx4FSrj8aHC01ATREhxFohxNNCiC4hREgI0SmE+KsQ4l9PdNk0Tm6EEDZVqGw4DtnZgV8BDxyHvCaNEKJCCHGPEKJNCBEQQjQJIe4QQuRNkC4uWEdunxkSp0oI8awQwiuEcAshnhBCFKnHhBDil0KIfvXclw9Jt1AI4RdCnJZE+SuFEPepeYSEEB3qeeaMEb9qSFmzkm8pjdEwnOgCnIwIIT4LPArogYPA80AGsBb4HPD0CSybUUoZPlHnnyk+LPU8FtQ2agBuOQ75TLqtVQH7LGACXgHagFLgeuAyIcR6KeXhCbJ5G9gxZL9ezVsHvADUAC8DKcBngXLgTOATwFeAP6th9wkhXpRSOoE7gQellLsmKP8i4E0gB2gHfg9YgfPU/00TNoLGsSGl1LZJbEAq4AQkipAyDDmmB2qG7C9FeYi6gR7gKaBiyHGpbjcBhwEP8AhgGhLnQuAdYABoAX4OpKrHNqjpbcBmtVwPAsXAa0AvEFbP/QiQpaarip97jDp+Xz1+55Cw76lhdwEC+CFKhxMEHMBLQO4Y+W1T0/6vWi4/yoNfOSTOcuBFtcw9wHPAwiHHbWoe3wb2A9ER4d9Xw73AL1E6rvfUNn0USBlynh1Av9o2nWqdTCPbdJx7YOh1awRcwP2AZUicTwE71fO3AHcPaX8T8Fu13YJqOz43oj5Dt03HcC8cVZ9jaOtb1PoG1bTbhqYb0Ub5ahmeB4qAa4FvAP8E/D/1Pnh3nDaOl3vzGMcvVo/vGfLsxcu9Afi6+j8XRXBJYA3wabXO2Uk86y+q6Q4A1iHhVqBkjDRVQ65b1onur0727YQX4GTbUN6e4jfgonHiFQF9QAhlRPUHNU0dRzrLeD5OYAtKxy2Ba9TjG9X9HuAhlE5dorz9DX2IJcpUzr3A14AFKJ3jg8D/oQg/Cdyjpks8RGOUfa56vAPQqWH7hzzkH+NIZ/h/wBNq3Kox8tumxo8AW1E6Vwn8Tj1ejCIwpNqhvaz+74x3JEM6nwjwGPCHEeEetY1C6n6feq5edf9aNf65KJ3jfcBv1HaTwDdHtKltnGsbb/MulKmzbnX/5+rxj6v7QbVM+9T9F9Xj16r7+9T2ewZwqse+iyKAJPAkirBdcwz3wrD6TLWtgXlDzn8PR0YQG8Zoo++r9UtBmWKMl+2gmn8eimA/a4z08XIPqO3YBNzOkReJ+EvUg0PS/FENuwX4pPr/rygCJgBUAK2oz9cEz7lFrb8Erp9E/1A1pK6agDrG7YQX4GTbgMuH3IBmNexHQ8KkGnYbR96+fqlu8Y7sn9U48TSfVfcfUvfvUvdfUPdfVtP/n7ofQxnJbRiyP29EOVeivEX+bMiDe1g9lniIxqlnvAPcACxR/9epx/5F3f+berwAZVSlGyOvbWr8u9X9z6v7+9T9+Nvuq0PSvK+GXafu29T920fkHQ//zohzPaHu/3zoudWw9cC3gF+gTD1J4GX1WLxNbeO0Tfy6XaTuX6Tu96j7f1b3v6fu56GM1iTKy8MNHBmBrwOyAf0oddowJGxK98LI+ky1rYHFatgHwPlAmRquH6ON3gS+hDKyCahlzkaZsouX5Vng5jHSnw3sRXnJ+j0wqJ7/h+rxezh6lP+IGvYjlPvxVyjCuA3luf0h8BawCGV01IDygpE+yvlLh1znf55E/1A1JJ0moI5x09agJk/3kP/lKHPib6j/PzfkWJX6u1jdhjJvxP776q9L/U0fkcd56hZHAEMXabukstagHBTiMpSHeiT5o4SNxUPAR4BLOFLnh9Xfl1E6yCuAV9Wwd1GmoDrHyXOietYNiXsQqAUqR+Tx5hh5x9PG8z6k/nrU3zQAIcS3UDqqkUymbUae86D6myeESGFEfaSUvUKIXpRRdSVKO25AEWyXogp7IcSnpJS+Mc4Vz3NS98I4+UyqraWUdUKI7wFfRpnORQhxCPgMykhpJPko04H5KKOov0gp+4UQr6LUGZSpzugY5XxNSrksviOEuB5FKH0a+E+U0SscuYeG/ndIRVp8Rd0QQsxHmVY9C0UoeVHa/1WUe/bbI87fp5ZNz9HtojFDaFp8k+dNlJsX4FtCCCGlfB746Yh4NvX3j1JKEd9QpljuHxE3ov7KMfL4yog85koph3YKwRHpLlF/f4PSOcT3xfhVG8YTKG++n1bTx1DeUEF5aG8CslCE7cPAKpSpq/GYqJ6LhoQtVH9bRsQdWdc4Izu6sTq+eFt8B0VJ6Bvq/mTaJk78xSNe7l4pZZAR9RFC5KKMokCpT0RKeQmQqebxNxShE9cAjZd96PMZz3Oy98JIhpVNZcK2FkLogR9IKfNQOuwfq+m+OsZ5etV4PWo+H1e12s5R8/sXlOnWHWOknyOEGO2axNTf3ervalVjTw/EtfI+GCXdncBDUsr3UITxbinlfpQ6146MLKUcRBldA3xFCGGNHxNCpA/RFiwWQiwSQhSMUY+k4miMwYkewp2MG8obYBSlo92NIgj+wvApvhKOzPW/pMb5G8pUT5UaJz4VEN//pbq/Rd2Pr2UMokwHPYAyUmlWj29glOko9VwSZb79fpQ3RAm41ONVQ8s6Tj2fGFLGV4aEb0Dp6B5FWfxvUOOMNV2zTT2+Sd2PL3DbhrSVSw37E0cWpx1AjhrHxohprxHhF6v7z6j7m9X9zSPa9CWOTL0+OOQa7R6vTUecM94mDrV941O3v1CPX6DuB1DWFvcyfBpxE8oI5ncoCgPx6/PJEe31hnpPlB/DvTAsfKptjXLPdKGsR92Nct9L1HW3UdroBygjZiOKcIi3WeuQ/6OmVdNvQZmdeIjhU3zxqVyd2obxac/t6v+3R8nrXxmiGAHsQhGgD6MIvF+MUYYalJdRibKutwXlmejhyP22RT3+y5HPFkeUYobF0bZJ9LUnugAn64aijfQcioJDXBPrRYYswKJoSz2nPtg+9YH6Jeqc95AbuUrdHyag1LCLUd4y3WrH8g5wi3psrE6pBPi7+lDvBm5magIq3tFK4Koh4fNRFp+7UZQSOlA62pQx8tnGOAJKDVuJIjycaufxPLB4yHEbx0dA1aB07AEUZYn/YuoC6jqUTtStdkKpQ+J8FkWL0IvSKd/DkQ7yTOB1ta4hlLf4/wbEkDLUc+QlaNUx3AtHhU+lrVFUrZ9Tr3VIvfaPMoY2HMpMgRtFQSgP+ALwTZT1v/8Ezp3g3rtYvT5OFOWhAyhKH7ohcarVMnlRpnKfZIR2Hcr6XAuqkowatgpllOVFWS8cVft0yDkeQBFQIZSXiT8Ac9TjW9AE1LRt8QdCQ0MjSYZY4KiWUtpOZFlmM0KIjSifVkQ58kJTiPJyd5eU8r9PYPE0TgI0AaWhMUk0AZU8qnLCd1DW2HJQlFd+DTwgtc5HYwI0AaWhMUk0AaWhMTNoAkpDQ0NDY1aiqZlraGhoaMxKNAGloaGhoTEr0QSUhoaGhsasRBNQGhoaGhqzEk1AaWhoaGjMSjQBpaGhoaExK9EElIaGhobGrEQTUBoaGhoasxJNQGloaGhozEpOGQH1z//8z3ELwpPe3nrrrSmnnW3bqVCXU6EOp1JdToU6aHWZnduQOozKKSOgent7p5w2GJzIx9vJw6lQl1OhDnFOhbqcCnWIo9VldjFRHU4ZAaWhoaGhcWqhCSgNDQ0NjVmJJqA0NDQ0NGYlhhNdAA0NjQ8P4XAYu91OIBA4Iee3Wq3U1dWdkHMfb07GupjNZsrKyjAajUnF1wSUhobGjGG328nIyKCqqgohxIyf3+PxkJGRMePnnQ5OtrpIKXE6ndjtdqqrq5NKo03xaWhozBiBQIDc3NwTIpw0TixCCHJzcyc1etYElIaGxoyiCacPL5O99pqA0tDQ0NCYlWgCSkND40NFV1cXn/vc55gzZw6nn346Z555Jn/84x9PWHm2bNnCTTfdNG35//CHP5xSumuvvZYDBw4c59JMDk1AaWhofGiQUnLxxRezfv16mpqaeO+993jsscew2+3Tet5IJDKt+Y/HVARUNBrlvvvuo6amZlJpjjeagNLQGAUpJYFAAJfLRU9PD52dnXR0dNDR0UFXVxdOpxOv13tCOx6NybN9+3ZMJhNf/OIXE2GVlZXcfPPNgNLJ3nbbbaxevZrly5fzm9/8BoBt27axYcMGPvOZz7Bo0SIuv/xypFRMyL333nucffbZnH766WzcuJHOzk4ANmzYwC233MKqVav41a9+xXPPPcfatWtZuXIlH/vYx+jq6hq3rJs3b+aKK67gzDPPZP78+fz2t78FlHvztttuY+3atSxbtozHH38cgM7OTtavX09tbS1Lly7l9ddf55vf/CaDg4PU1tZy+eWXA/DII4+wZs0aamtruf766xOCJT09nVtvvZUVK1bw1ltvsWHDBt59910AHn30UZYtW8bSpUv5xje+kSjjyDTf/OY3qampYfny5fzHf/zHsV0sZkjNXAhhBl4DUtRzPiml/J4Qohp4DMgF3gOukFKGhBApwMPA6YATuERKaZuJsmp8ePH7/bhcLjweD36/n1gsllQ6k8lEeno6VqsVq9WKXq+f5pKeGlR984Vpydf2owvGPFZXV8dpp5025vH7778fq9XKzp07CQaDrFu3jvPPPx+A999/n/3791NSUsK6det48803Wbt2LTfffDPPPvss+fn5PP7443z729/mgQceACAUCiU6+f7+fnbs2IEQgvvuu4+f/OQn/PznPx+3Lnv27GHHjh34fD5WrlzJBRdcwFtvvcXu3bv5xz/+QTAYZPXq1axfv57f//73bNy4kW9/+9tEo1H8fj9nnXUWd911F7t3707U//HHH+fNN9/EaDTypS99ia1bt3LllVfi8/lYu3btUWXq6OjgG9/4Bu+99x7Z2dmcf/75PPPMM1x88cXD0jidTq655hoOHjyIEAKXyzXxxZqAmfoOKgicI6X0CiGMwBtCiL8AXwPukFI+JoS4B7gG+H/qb7+Ucp4Q4lLgx8AlM1RWjQ8R4XCY3t5enE4nwWAQKSXBYBCfz0cgECAcDhMOh4lGo4k3Zp1Oh16vx2QykZKSgsViwe/309fXhxACq9VKfn4+mZmZJ7h2GhNx44038sYbb2Aymdi5cycvv/wye/bs4cknnwTA7XZTX1+PyWRizZo1lJWVAVBbW4vNZiMrK4t9+/Zx3nnnAcoIrLi4OJH/JZcc6bbsdjuXXHIJnZ2dhEKhpL4Fuuiii7BYLFgsFj760Y/yzjvv8MYbb3DZZZeh1+spLCzk7LPPZufOnaxevZqrr76acDjMxRdfTG1t7VH5vfLKK7z33nusXr0agMHBQQoKCgDQ6/V8+tOfPirNzp072bBhA/n5+QBcfvnlvPbaa1x88cXD0litVsxmM9dccw2f+MQn+MQnPjHxBZiAGRFQUnmyvequUd0kcA7wOTX8IWAzioC6SP0P8CRwlxBCyHgPoaFxjAQCATo7O+nv70dKic/nw+124/V6E1MeRqMxMTrS6/XodDqklESjUaLRKKFQiP7+fvr6+gCwWCxkZGQQDodxuVyYzWbcbjdSSk21ehTGG+lMF4sXL+aFF46M3O6++256e3tZtWoVoEyf3XnnnWzcuHFYum3btpGSkpLY1+v1RCIRpJQsWbKEt956a9TzpaWlJf7ffPPNfO1rX+PCCy9k27ZtbN68ecLyjrxvxruP1q9fz2uvvcYLL7zApk2b+NrXvsaVV145LI6Ukquuuor//d//PSq92Wye9Oh/aBqDwcA777zDK6+8wpNPPsldd93F3//+90nlN5IZsyQhhNCjTOPNA+4GGgGXlDI+iW8HStX/pUAbgJQyIoRwo0wD9o7I8zrgOoDCwkK2bds2pbJ5vd4pp51tnAp1mc46xEdMAwMDSCnxer14PB7C4TA6nS7xtprswyqlJBQKEQgE8Pv9hEIhhBCkpqaSmZlJNBply5Yt5OXlnVRf/Q/leF4Pq9WKx+M5LnlNhX/6p3/i+9//PnfccQfXXnstAN3d3Ugp8Xg8nH322dx5552sXr0ao9FIfX09JSUl+P1+IpFIouzxa15SUkJXVxd/+9vfWLt2LeFwmIaGBhYvXkw0GsXn8yXS9Pf3k5WVhcfj4b777iMajeLxeAgEAoRCoaPaJRgM8sILL3DTTTfh8/l49dVX+c53voPX6+WBBx7goosuorm5me3bt/O9732P/fv3U1payqWXXorb7WbHjh186lOfwmg00tfXh9Fo5IwzzuDSSy/lC1/4Avn5+fT19eH1eqmoqAAYVoZ4+Wtqarj55psTI8ZHHnmE66+/PhE3/uv1ehkcHOSss85i+fLlLF++fNRrHQgEEvdT/N7asGHDqNdrxgSUlDIK1AohsoA/AouOQ573AvcCrFq1So5VyYkYr4FONk6FukxHHaSUOBwOHA4HWVlZ9PX10dfXR3p6OtXV1WRnZ5ORkYFOd2x6Q8FgEJfLhcvlIhaLYbPZWL16NWazmYyMDCoqKjCbzcepVjPD8bwedXV1J1RQezwennvuOb761a/y61//mvz8fNLS0vjJT35CRkYGN910Ew6Hg7PPPhspJfn5+TzzzDOkpqZiMBgSZTeZTJjNZnJzc3n66af58pe/jNvtJhKJcMstt7BmzRr0ej1paWmJNLfffjubNm0iOzubc845J2H2yWw2YzKZjmqXlJQUamtrufDCC+nt7eW73/0uCxYsYP78+ezevZuzzjoLvV7PT3/6U+bNm8dDDz3EJZdcgtFoJD09nYcffpiMjAyuu+461q1bx2mnncbWrVv54Q9/yL/+678Si8UwGo3cfffdiXMPLUO8/PPnz+fHP/4xn/zkJ5FScsEFF3DppZcm4sXTeL1eLr30UgKBAFJK7rjjjlGvtdlsZuXKlcDE95Y4EbNmQojvAoPAN4AidZR0JrBZSrlRCPGS+v8tIYQBcAD5403xrVq1SsYXIyfLqdCpxzkV6nK86+Dz+bDZbAQCAdxuNz09PYTDYdLT08nLy8NisRy3c8WJRqP09/fz+uuvs2jRIrKzs8nPz8dgMFBSUkJhYeFJM+13vAXU4sWLj0teU+Fksl+3efNm0tPTx9SGO5nqMpSh98CQe2vUh2GmtPjygbCU0iWEsADnoSg+vAp8BkWT7yrgWTXJn9T9t9Tjf9fWnzQmi5SSjo4OHA4H4XCYzs5OfD4fZrOZkpISUlNTp+3cer2evLw8SkpKyM7OxuVyMTAwQFFREVJK3G431dXVmEymaSuDhsbJzkxN8RUDD6nrUDrgCSnl80KIA8BjQoj/Ad4H7lfj3w/8TgjRAPQBl46WqYbGWIRCIZqamvD5fLhcrsQ3J0VFRWRlZc3Y6EWv1yfO2dnZSXt7Ox6Ph6KiIg4cOEB1dTVWq3VGyqJxcpGMEsWpzkxp8e0BVo4S3gSsGSU8AHx2BoqmcQoyMDBAc3MzwWCQzs5OPB4PqamplJSUJO2H5nhjNpupqqrC6XTS09PD4OAgZWVlNDQ0UFJSMkw1WUNDQ0HzB6VxStHd3U1bWxuBQAC73U4kEiE/P5+8vLwTXTSEEOTl5ZGamkp7ezs2my0hmAKBAJWVlcespKGhcSqhCSiNUwIpJW1tbfT09ODxeGhvb0ev11NRUZHUWlMsFsPtduN2u8nNzZ3WxefU1FSqq6tpb2+no6ODYDAIKNOS8+bN0yxRaGioaAJK46QnFovR3NyMy+Wit7eXnp4eLBYLZWVlGAwT3+LhcJgPPvgA54CPQCRGfnpH4juY6cJgMFBRUZGw6xcKhSgtLeXQoUPMnz//hE1FamjMJrT5BI2Tmmg0Sn19PS6XC4fDQU9PT+J7o9GEUyQS4cCBA7z99tvYbDacTif79++nvc9Dd1CPV6bQ4w3S2NiYtC2+qSKEoKioiIKCAjweD62trfh8Pg4dOkQoFJrWc3+YEUJw6623JvZ/9rOfzbhCwlBDrMeb3bt38+c//3nS6To6OvjMZz4zDSWaOtoISuOkJRKJUF9fj8/nS2jH5eTkUFhYOCxeNBqlsbERv99PMBiky+1nICjpcjdj1AlCMYk7YmBezTJisRgN+3dj7+iiq6uLtLQ0Fi1aRHp6+rTVIzc3F71ej8PhoLW1lfLycg4dOsTChQs1NfRpICUlhaeffppvfetbU1qbjEQiSY3MTxS7d+/m3Xff5eMf/3jSaSKRCCUlJQkbhMmmme520EZQGiclkUiEw4cP4/V6sdvteDweCgoKjhJOUkoOHjxIfUsH++19NPb48GCmqHoBEUsuHn0GUUsucxYtxWhKIcVsobiiGrtP0uiK0NQ9wHu73qe7u3ta65OVlUVpaSmBQIDW1lYGBwc5fPiwNpKaBgwGA9dddx133HHHUcdsNhvnnHMOy5cv59xzz6W1tRWATZs28cUvfpG1a9fy9a9/nU2bNnHDDTdwxhlnMGfOHLZt28bVV1/N4sWL2bRpUyK/G264gVWrVrFkyRK+973vTVi2qqoqvv71r7Ns2TLWrFlDQ0PDuOX6wx/+wNKlS1mxYgXr168nFArx3e9+l8cff5za2loef/xxfD4fV199NWvWrGHlypU8+6zyuemWLVu48MILOeecczj33HOx2WwsXboUUJR2Pv/5z7Ns2TJWrlzJq6++Omqa0Vx8HE80AaVx0hEXTj6fD7vdjtfrpbi4mNzc3GEmjaLRKIcOHaLV0UtvEIqqF1E0dzHzalZgzcmjfO4CqhcuoXzuAlLMR6xJ5OQXseT0M1hy2hmYsgppdYc4ePgwfr8fj8eDz+eblnplZGRQVlZGMBiktbUVv99PfX094XB4Ws43G9i8eTNCiKS266677qj011133bA4yU7V3XjjjWzduhW32z0s/Oabb+aqq65iz549XH755Xz5y19OHLPb7fzjH//gF7/4BaDY1nvrrbe44447uPDCC/nqV7/K/v372bt3b8K9xQ9+8APeffdd9uzZw/bt29mzZ8+EZbNarezdu5ebbrqJW265Zdxy3X777bz00kt88MEH/OlPf8JkMnH77bdzySWXsHv3bi655BJ+8IMfcM455/DOO+/w6quvcttttyXu4V27dvHkk0+yffv2YWW4++67EUKwd+9eHn30Ua666ioCgcBRaeIuPnbv3s0HH3wwqgX1Y0ETUBonFfE1p7hw8vl8FBcXk5WVRTAYZO/evXxw4BDv7z/Ejh07aLI76PLHqJi3mMzsHDKs2Umrcuv0ekqr5pKWlU+3J8SuXbt4+91dvL3zXQ4cOIDf7z/u9UtPT08Iqba2toSQmg5vpR9mMjMzufLKK/n1r389LPytt97ic59THCxcccUVvPHGG4ljn/3sZ4dpWH7yk59ECMGyZcsoLCxk2bJl6HQ6lixZgs1mA+CJJ57gtNNOY+XKlezfvz8pF+qXXXZZ4jduJX2scq1bt45Nmzbx29/+dsx75OWXX+ZHP/oRtbW1bNiwITFKBzjvvPPIyck5Ks0bb7zBv//7vwOwaNEiKisrOXz48FFpVq9ezYMPPsjmzZvZu3fvcdd+1QSUxklDLBajoaEhseY0VDjFYjH2799PU6cThx96Q3pa+oP0BvVUL1xKeubUrTWUVM1hEBNt7hDtXknrQIyDrV28s/NdDh06hMPhSLxdHg/S09MpLS1lcHAQu92O3++noaFh2pU2Pmzccsst3H///UmPiIe6zgAS7jd0Ot0wVxw6nY5IJEJzczM/+9nPeOWVV9izZw8XXHBBUvfJUCsnE1k8ueeee/if//kf2traOP3003E6nUfFkVLy1FNPsXv3bnbv3k1ra2vCFt7IOiXD0DRxFx+lpaVs2rSJhx9+eNL5jYcmoDROCqSUNDY2Jr5xik/rZWVlAcocvaNvAE/MyPxlK1mwdCX5lQuYt3QFqenH9lan1xuYs2gZueXzWFi7igXLT0Nk5GNzR9jX1M67ew/y9tvvJNbEjgcZGRkUFxcnhLHX6028lZ9KbN68GSllUtu99957VPp77713WJzJaOPl5OTwb//2b9x///2JsI985CM89thjAGzdupWzzjprynUbGBggLS0Nq9VKV1cXf/nLX5JKF3fh/vjjj3PmmWeOW67GxkbWrl3L7bffTn5+Pm1tbWRkZAxzc7Fx40buvPPOhMPN999/f8IynHXWWWzduhWAw4cP09raysKFC4+K19LSQmFhIV/4whe49tpr2bVrV1J1TJbZq4qioTEEm83GwMAADocDj8dDYWFhQji1t7dja22j2x+jatECjEZF8y0r9/hZjzClpGBKiXseNVBWPY+8ohIG+vvw+zz0uvvpC7TT2t5JXraVpUuXHrOGU1ZWFtFolO7u7oQtQbvdnvDqqnHs3Hrrrdx1112J/TvvvJPPf/7z/PSnPyU/P58HH3xwynmvWLGClStXsmjRIsrLy1m3bl1S6fr7+1m+fDkpKSk8+uij45brtttuo76+Hikl5557LitWrKCioiIxpfetb32L//qv/+KWW25h+fLlxGIxqquref7558ctw5e+9CVuuOEGli1bhsFgYMuWLcNGiXG2bdvGT3/602EuPo4nJ8TdxnSgudtQOBXqMrIOdrudrq4uuru7cTqd5OXlJdxP22w2GppaaPdGyC+rIr+odIxcp5fAoB9nVyfuvl7yzJIl86qoqqri3XffTXhrnSoOh4P+/n4KCwvJycmhoqIiUf+ZQHO3MXPE75lk1CiMWosAACAASURBVN9ne13GYjLuNrQpPo1ZTU9PD11dXfT39+N0OhN+lUCZQmmytWD3Rimumn/ChBOA2ZJKadVcKucvptcfpUW1B3g8KCwsJCMjg66uLrxeL21tbSfUK62GxkyhCSiNWYvb7aa1tRWPx4PD4SAjIyPxnVN8TarXHyW3qJTsvIITXFqFtIxM0rJy6fdHjpumnxCCkpISzGYz7e3tDA4O0tjYmLDhp3HqYLPZZoVh49mCJqA0ZiWDg4M0NTURCARob2/HYrFQUlKS0Grq6uqip3+AgDSSX3ziRk6jUVxezUDEQGOXi0P1DTQ3N3OsU+k6nY7y8nJ0Oh12u51gcGbMMU0Hp8qygsbkmey11wSUxqwjEonQ0NCQ+BbIYDBQVlaW+H7J7/dzuKGBLl+E4ooq9PrZpetjSklhwfKVpGQX0xMycrCxhb179x6zMIm3QyQSob29Hb/ff9Jp9pnNZpxOpyakPoRIKXE6nZjN5qTTzK4nW+NDT9xNu9VqxW63E4vFqKysTGjExWIxDhw4QLcnRFpWPlm5M6csMBn0egPFFdX09rvpDoagu4+Mlhaqq6uPKV+LxUJRURGdnZ10d3cjhKCrq+soE0+zlbKyMux2Oz09PSfk/IFAYFId5GzmZKyL2WyelBaqJqA0ZhVxO3QdHR0EAgHKy8uHPYQOh4Mel5dBUphfNecEljQ5LGnpFBcWYDu0j5SWVrKzsxPq8VMlKyuLQCBAX18fFouF9vZ20tLSptWg7fHCaDQes5A+FrZt28bKlUc59z4pOZXqMhbaFJ/GrKGnp4fe3l7cbnfC+OvQTjcWi9HW1kZfIEZRWeUxT+1JKWl1R7C5wkRi0zfllJaRSW5RGV2+KAcPHjwuBmALCwuxWCx0dnYSCARoamoiEokch9JqaMwetBGUxqwgrj7t9XpxuVwsXryY3NzcYXG6u7vp9waQBjPWnNwxcpqYSEyyvyfEzo4gvX5lXcikhzPLzKwtTUE3gXmZqVBYWo7P48bh9rJ37170en1CDb2kpISKiopJ5SeEoLS0lObmZtrb26mqqqK5uZl58+ZNaB5HQ+NkQRNQGieccDg8TGPPZDJRVFQ0LE5PTw8NDQ30DUYpqKiecifs8EZ4ss6HN6SMmNJNAotB0OOPsb0lQENfmCX5JgYjEoc3Sn6qjoI0PUJAWYaBNNPUJh2EEFTMXUD9vt1Eu92EYhCKSnQCBvzNeL3eSXvSNRqNlJSU0NbWRldXFzqdDofDQXFx8ZTKqKEx29AElMYJRUpJU1MTwWAQu92OEIL8/PxhFsd7enrYs+8And4oZmvOlBUj+gajPHHAhz8syU/VsbbUzOI8I3qdoKk/zAv1fto9Udo9g4k09X1H0lsMgosWplKVNTV37EZTCtULl+Dud5KVloE5NY1Bv5f2psMM2rtwuVwsXLjwqJHjeKSnp5OXl0dvby+pqamAYsfvZFiP0tCYCE1AaZxQ4v6cOjo6CIVCVFRUMDAwMCxOa2sr3f4oWUVlFJZObiosjsMb4ak6RThVZxn4zOI09Lojo7A52UauXZnBIWeYFlcYEYtQkq7HHTHgDsXwBGN0eqM8vt/H8kITc7INdPuiLMg1UZimH+fMw7GkpWNJOyI8TCkpmJfUYm9uoLnPQ6yujjPOOGNSdvzy8vLw+Xw4HA4sFgvNzc3U1NQMcw2hoXEyogkojRNGf39/wr5eXClipPl/l8tFv9tLCAP5xVMzknqwN8QL9X7CMSjL1PPxagMN9YdpbmrGZrNx/fXXI3QCi1FHbVEKc9NCfO+7twNgNqdQUFBIQWEh5RWnYxf5fNAV4oMuRdFhb1eIa1ZmkmKY+rpPitnC3MXLaDq4D9egIqwnsyYVX49qamqio6ODyspKWlpamDNn9ms5amiMhyagNE4IgUAAm82G3++np6eHjIyMUae27HY7rmCU3IKypB0NxonEJDvsQd5oU5QRygw+Ajtf5vtb9g/7aNbr8w4zuhmNHHH8Fggo3m1bW1th50706bnkrvwYaTmF6FOtDIRge+sg589JnWwTHEVBSTn2+n20tbVRUlIyqVGU0WikuLiY9vZ2enp6EELgdDonNV2ooTHb0ASUxowTi8VoamoiFArR3t6OwWAYdWF/cHCQbqcTb1hQUlA0Sk5HYx+IsKszSExCuyeCJyRBSoKHXmPXvu2jpnG73cMEVEzGyMzMJBgMHmXvLup10v264q/HYC0k52NfYFdniIpMA4vyTMk2waikZ1oxWjJw+f3U1dWxcOFCTKbk88zMzMTn8+F0OklPT6etrY309PRR3SRoaJwMaAJKY8Zpa2tLfIwbjUapqqoadb3EbrfjDsSw5uYlfDyNxs6OAPu7w6SZBE39EYZ+0RQd6MHzwcuEuhqHpSkuKWbOnDnMnTuX/LzhShc5OTls/v5mkDDgGaCrq4uOjg4OHz5MQ30D4XAYgIi7C0P7biJlp/HMIT8f8UWpzjZSlqGfspZhcUU1tkP7CXf04vV6qa2txWKxJJ2+sLAQn89HR0cH1dXV2Gw2FixYoKmea5yUaAJKY0ZxOp309vbS29ubcNk+mrmWUChEh8OBOxBj7ryxjcG2eyL8vTmgCCXVc/eakhTe2/4ivZ12wt3NibhZWVmsWr2K1atXJ+dPSSijkszMTObPn8/ZZ59NOBSmvqGet3fsYN/+/ayvziBcbOb11gD/sAf5hz3I4lwDFy5Mm5JQSE3PYP6ylbQ2HKLd5cW4fz+1tbVJT/fpdDpKS0tpaWnB4XCg1+vp7u4+aUwhaWgMRRNQGjNGIBCgtbUVn89Hb28vmZmZR5n9GRgYYO/evQQCAQYGI6Rl5WC2jL6+E45KXqj3I4HaQhMlGXoK0/QUphsoDdXwm3teB6CoqIiNGzeybPmySa9jjcRoMlJTU0NNTQ2ufhdp6WkYjUaK0vTU94U50BOizhnB8Zd3ufKjS6d4jhSqFtbQWLeX9j4Pxv37WbYs+bJbLBby8vISa3vt7e1kZmZOaiSmoTEb0ASUxowwdN2po6ND6dSLjl5Xstls9Id0NDiDgKC6anTNvXBU8vRBH32DMXItOj42x4JhiNr4woULOffccykpLaF2RS1Cd/ynuLKyjwjXuTlG5uYYifU2s4dS+q3zuePVVualDDBv3uTz1usNVM2vofHAHuw9/RgPHmTx4sVJj8pyc3MTfrRSU1Ox2WwsWrRIm+rTOKnQbPFpzAh2u53BwUE6OzuJRqOUlpYete40MDBAT18/AYzMW3YaC2pXkZo+3KV1TEoO9oZ4ZK+XZlcEiwF0h1/B1jR8jQnggk9cwMqVK6dFOI3FgG0vnvf/QiwcRGctpNE0l9/96ZXEutVkMKUoI6neALR19tDe3p502riTw1gshsPhwO/309nZOekyaGicSDQBpTHtuFwuenp6cDqdeL1eCgsLR113am1tpX8wSmZOHilmy1GKEV2+KFs+8PLMIT9dviip+hjeN7ey/+3X+d3vfjcr3KBfeumlXHJWDcHtv8F/eAdCp6MtfRG/vvdhnL3OSednSU2jtHo+3f4Ira2tkzIIm5KSQn5+Ph6PB7fbnRBUGhonC5qA0phWQqEQNpuNwcHBxJpIdnb2UfH6+vro6nHijQisI0wZ7XYEuf/9AR7c7aHbFyUzRbDM4qLj+V/ibFNGTp4BD3v27JmROk3E8hUr+OZt/8Ec0UXQ0YAuJY3Q8ou56/l32L//wKTzs2bnYrCk0+8LcfDgQfbu3Utvb29SaXNycrBYLDgcDsLhMDabTXMWqHHSoAkojWlDSklzc/OE3ztFIhHq6+vp9kcpKKnAYDhi667DE+HFxkF6/DH0Ak4rNrE8VMfft95JyOcFFGsPV151JevWrZuxuk2EJTWVTVddxRJdBwHbbhA6UuafyRPv2XnttdcnnV9RWRXOwSjNnb3UtfVw8ODBhDX08YhP9Ukp6ezsZHBwEIfDMZUqaWjMODMioIQQ5UKIV4UQB4QQ+4UQX1HDNwsh2oUQu9Xt40PSfEsI0SCEOCSE2DgT5dQ4vnR2duL1euns7CQSiYy67gTQ0tJC98Ag0pRGXlFJIlxKyd+aFcOtq4pNfHWtlUjdNp7+wxNI1X9Tdk42X/nKLdTW1s5MpSaDgNplNVyzfi6xD/6EjEawzF3DXw/1s23b6B8Nj0V6ppXsonJC5mykOZNub5jDhw8nldZkMpGfn4/X68XtdicElYbGbGdKAkoIsU4IMRkd2ghwq5SyBjgDuFEIUaMeu0NKWatuf1bzrwEuBZYA/wz8nxBCs3x5EuHxeOjs7MTlcuHxeMjLyxtVzTkQCGDv6MDpj1JWPdyX0d7uEB2eKGlGwVkVFp5/7ln+9re/JY6XlZfxla98hcKiY/vGJxgYnNZpr/Lycr5y5adJsb2BlJK0mvX0568gOkkniUVlFVTMXUj53AV4Ijocvf2Tnurr6uoiHA7T0tKiTfVpzHqSElBCiHvUEY4QQjwCvAZ8IIT4UjLppZSdUspd6n8PUAeM/fUlXAQ8JqUMSimbgQZgTTLn0jjxRCIRmpubCQaDCTXnvLy8UeO2tbXhGoyQnp2LJfWIodhmV5gXG5W3/LMrzDz/7NO8tv21xPGamhpuvPFGMjMzkyqTy9lDr6MDv9eT6JillLQ1HqZh7y4a6/bg906fkkV6Rjo3X3oBBc73MQjJIRfs7AhOnHAUjEYTBSXluAJROjo6kkojhKC4uDih1efz+eju7p7S+TU0ZopkR1DnA3YgFbgE2At4gC9P9oRCiCpgJfC2GnSTEGKPEOIBIUR89bwUaBuSzM74Ak1jFmGz2RLrTnHLBqOhmDvqpD8gE240pJQ0+VN4us5HTMKq4hQiHQd48403E+lW1K7g6qs/n7SNOXdfL53Nh/F12Wg9tIdDe3bR2WajpeEgwYFeqrIMZMhBmg/upa9n+tZnjCYj11x0DhctVNxtvO8IEYuPYiY5mMnOK8AfFfT29SetmZeSkkJeXh4ejwePx0NHR8dRtgY1NGYTIplhvhBiEHgA2ALsAGqBm4ArpJRJm3EWQqQD24EfSCmfFkIUAr0oj+d/A8VSyquFEHcBO6SUj6jp7gf+IqV8ckR+1wHXARQWFp7+2GOPJVuUYXi93lPGwduJrkvchUZ/fz8DAwMUFBSMOrUXi8VobGykcyCIPrOAgtIKYhLedmfQHlQET5U5wOmZXkCyfft2Duw/wPz58zn33HPR6Ud/t5KxGJ2tTQQH/QidjtT0TPweN1m6QXIz0wkGg3iDYYIxHQLIMEqqKiuVj1p7nPSFjVis2aRnZmEwmggGBvF7B8jMzjvqm6xkCAVDmFKGq8tLCS86s/FF9azLchPpauKdd97hgk9cMKr6/Vj0dLQRG+iiujB7zJeAkcSVJWKxGCUlJaSnp1NeXj5umhN9Tx1PtLrMLuJ12LBhw6gfKyZrScKLIpQuA8LAQcAETKxGpCKEMAJPAVullE8DSCm7hhz/LfC8utsODH1qytSwYUgp7wXuBVi1apXcsGFDssUZxrZt25hq2tnGiayL3+/n4MGDZGdnY7fbyc7OHtVaBEBzczPOAT9hq54FS1ci9HqeO+ynPRjGKGL8y/x0FudZEUJJP2/uPHbu3Mmq1avGNfnT0dpEWW4mBenZxGLgCcUQuRbmFOexbNkypJSJ77F0Oh05OTmJh7yzs5NDh+sZCEbxhUNEQyEsBijOT6c/FKKqshLDJFyyAzQ0NDBvFFMSTkuAbS0BmgYtHHjpRcKhMH/961+54Ys3YLYkJ6RKS4ppPrCb7JwUFi1alHRnFQgEaG5uTlyfqqqqcd1yaM/H7ORUqMtEdUh2im8bcCbwFeDvUsowsAw4lExioax83w/USSl/MSR8qM7xp4B96v8/AZcKIVKEENXAfOCdJMuqcQKIxWI0NzcTDofp7OzEbDaPaqBUSklDQwONza10+aKUz1mA3mBghz1IXW8Ykx7Oyh6gJt80TGFC6ARr1q45SjiFwyHCIWWaasDVj6u7k8J0AytXrGDt6tNZOrecuSX5LFiwQMlHCPLy8qiqqqKiomJYp15cXMzaNatZsXAOS8rzWFxipaYin7I8K+n6KA677bi11/JCE3oBnUEjsRQrAG2tbdz723uTnnazpKaRkVOAYyBEXV1d0h/xms1mcnJy6O9XpgftdvukPgDW0Jgpkh1BfQFFGBmAXwohTChCZFeS6dcBVwB7hRC71bD/BC4TQtSiTPHZgOsBpJT7hRBPAAdQNABvlFJGj8pVY9bQ2tpKIBCgvb09MX00mt231tZWGlvacfhjlM5ZQHqmFU8wxlt2ZTD+qYVpHNqxgz8efJ+LL7p4TDNFgUE/3R1tePqcCJ2OeUtX4rDbKEjVM3dOdcII7Wijl/GwWCxUVlYOC/P7/Xi879Ha102d20V2XgGFpRXHZNcu1ahjeaGJ9x0hFm68nANP/gp9Rh6d4VR+s/Upbvj3z2I0TTxaK62cQ0Odl85+L+a6OpYsWZKUUdm4hYnOzk4sFgttbW1UV1dPuT4aGtNBUgJKSukCvjMi+PZkTyKlfAMY7Wn+8zhpfgD8INlzaJw4+vr6Em40/H4/xcXFoyowxGIxOjo66PZHKJuzmMzsHABebw0QjsGCHCO47LzyyitEo1F8Ph+fu+wydOq3U94BN+5+J5FQCK+7j2yzoDJLT/9gjNbGg8SCfrLz05Jej0mW1NRUFi6Yj6GxkcFQhO7udiLhEKVV845JSH2kzMyerhC90krVp2/DL5S1Ol8kxJbfP8Y1V3wuUfex0On1VM1fTMP+DzB2OUlJaUiMFsdNp9NRVFREW1sbTqcTIQS5ublJa0VqaMwEyaqZ/32M7ZXpLqDG7CYYDNLS0oLf7x/ThUacnp4eXP4QupTUhHBqc0fY0x1CJ6DWGuCBBx4gGlUGy3a7PTHd1d1hp+XQPoSnC3PIRZXVQE11GSuWLSPLrGPQ58WaonS6x+pSYzSKior4yEc+wsrlSynNNBJw9XBg19u0Nh4iGp3a9FhGio7TihVB7hcWDDJM1O9GGEy0BNN48qmnktLuM6WYqVywmC6/pMXembSliPT0dDIzM+nt7SUYVFzbx2KxKdVFQ2M6SHaKb8MY4dqXfh9ipJTDXGgYDIYxlSIAOjo6cAei5JUpS4+BiOS5esXL4OmFep54+B58XmU/LT2NL1z7BSypqXS22Rjo7qDCaqCyvIy0tDSsVmtCO7CoIB93sAtrin5UU0rHi/goY8XyZVgOH8Y7OEivx4nDbqS0cs6U8vxIWQr+cIy8VD2nF1t56uU3aGEZlrmr2PHnX2O1Wtm4cWJDKmnpmRRXzqGrtZHUxkays7OTUsMvLCzE6/XicDhISUmhs7PzuI9ANTSmSrIC6vND/utRFCRuAO487iXSOGmw2+0JNw6RSGRM1+0Avb29OF0DBKWerJx8pJS81OhnICgpStNx+OXf092lfDiq1+u5+uqryc3LpbvDjru7nfJMI0uX1Iz6wW9FRQX9/f0UFhYm/W3UsZCVlcWaNWsYGBhg1/u7sXV3EgmH8Hs9pJgtZOXmkZM/tqAeisWo45MLjnygfMn56/jFa+1gycRcsZSXXnwJq9XKGWecMWFeOfmFDLj66PK4qK+vZ+nSiY29GAwGCgsLE1Y/4kJ4MuruGhrTRbJrUA+NDFM18zTrDh9S4t87TeRCAxSL5ocPH6bbFyW/pBKdXs877QFFa08Hafa32XP4iELoOeeeQ1FBPo0H9hAZ9FKaYaBm8aIxrVGkp6dz5plnTsvU3nhkZmZSVVnBYNhGKNBPqUVHKOqlu9WN0ZRChvVoq+0TodPrOHdhHi81B8k47QJiAR+dHcn7cSqtmkv9nl04up0U9faO2WZDycrKwuVy0d3dTXp6Oi0tLSxcuHDSZdfQON4kJaCEEOtHBGUCHwWqjneBNGY/8XWnoS40cnJyxoxfX19PjzeIPjWTvMISWtxhXrUpWnuLDQ7++spfEnHPO/88cq0ZNNXtIdeiIzfXzNy5cykoKBi3TDMtnOJUVFQQiUTQ6XQUFBTQ1dVFrLmN7va2KQkogNpiMx2eCHt7IfufLmPNiuQVF4xGE4VllXS3N9OoTvWNNaodSlFRETabjZ6eHgwGA06nc9xvozQ0ZoJkp/i2cfR6kwD+cVxLozHrGeq6fTwXGnHsdjvtXb24QoJ58+cTiEieP+xHAkutIbY9/GAi7qJFC5lXXkJ70yEWL6qkoqyUqqoqDIZkb9OZR6fTDVNlN5vNOBwO+vo8eAdcU8pTCMHHF6Sj1/nZ3R3mucN+rq7NwKRPTmMwp6CIvp4uegcGaW1tTUp9PP5tlNPpxGq1YrfbsVqts7rtNU59kn3tbB2x1QFbgcunqVwas5T4ulNHR8e4LjRA8aRb39hEpzdCafV8dEYTz9f78YQkpRl69j2/JeEKPTc7kzUrFpOGn8JUOK12BfPmzTvpOkiDwUB5eTk5Fj0t9XU4uzoSHxJPBiEEH5ubSn6qDlcgxiuq2xEZkxNq2gkhKKmaQ48/SktrGz6fL6lz5uXlYTQaE84NJ+NiXkNjOkhKQEkpq6SU1UO2pVLKK6SULdNdQI3ZQ19fHz09PfT29uL1ese0sweKja19+/bR6YmQXViKSM1m614vjf0RUvTwyQWpXHHF5eTl52HSw4aPrKEiK4V5pQUsXLhwTFX1k4GSkhIqi/IoT9cR6uvg8J5dtDUeJhRM2jIYAAad4JML0tAL+KArRF3XIA//7mH+9Kc/TZg2LT2TrPwiev2KM8hkbG7qdDoKCwsJBoP09fXR29ubtHDT0JgOkv0Oar4QYr3qbqNGCPFbIcRPhBDW6S6gxuxgcHBw2PdO4607BQIB9u3bR8dACFNGDoWlFTxz0EenV3HXftnSdLLMekpLS7nxhhs4/5yzWVqey8I5ldTU1CS1ZjKbMRgMLF26lNWnr6QyL4Mqqx6d30n9nl04uydnLb0gTc/ZlYryybN1LvbUNfDa9td4++23J0gJRWWV+GIGuvvc9PX1JXW+jIwMMjIy6Onp0fxGaZxwkp3iuxd4QCp36lPANcCtwN3TVTCN2UM0Gh227mQ0GsdcdwoGg+zZswd7v59YSgblcxdQ1xuhw6s4Hvz8igyK0pVpu1gsRle7jZrKQspLFKOlx2KZYbaRmZlJZWUlZ6xdw+KqEsoz9Thamwkk6R4jzuqSFCoz9WC0kF5zNgBPPfUU9jb7uOn0BgP5xaW4AlHa2trGjTuUuA3Frq4uBgcHcbmmtpamoXGsJCuglgI7hBClwELgx8Ae4GPTVTCN2YPNZmNwcBC73U40Gh1z3SkQCCjCqc9HyJBG1YLFRKVgW4uyfnJGkQ5P/xEPsM6uTvThQQqtqcydO3fG6jPTmM1mFi5cSHlpMbkWQUvDQVobD9HrSN7Z4HlzFa82lqpahMlCJBxhy0Nb8PvGF3Y5+YUMRnX09rtxu91Jnc9oNCb8Rnm9XpxOZ2KtUENjJklWQGUAA0ANijbf3cCbwMm7UKCRFA6HA5fLlXibLi4uHvV7p2AwyAcffEBrr4dBnZnqBTXo9QZebw3gCUkKUnXsevEx7vjFHezatYtIOExPRyt5qXrmz58/Y8oQ0WiUQCCA1+tNdMA+n49AIJAwsTRdzJkzh0JrKpm6IOZAP932ZnyegaTS5qXqmZttAL2BjAVrAehz9rH191uR47iO1+sN5BSW4ApEaW5uTtqUUW5uLiaTCYfDQSQSwW4ff7SmoTEdJNsr2IFPo7jccEop7UKIAhRngxqnKAMDA7S3t+N2u+nv7yc7OxurdfRlx/r6ejpdfkLGNOYuWILeYMA+EOGdjiACyO3bz/a6OgAe+d0jXPm5fyPHJCnKzyU7e2rfCyVDMBjE5/Ph9/sZHByc0K2E0WjEbDaTmppKWlracbVMEV+bKlKN6gq7g3ZbA/OW1Cb1HdfqkhQa+yNYF6/D17KPqKeXugN1/PVvf+X8888fM11+UQmHe7ro6HVhPnyYRYsWTXguIQRFRUW0trYyMDBAX18feXl5ZGRM3mmjhsZUSVZA3QX8AsgHviuE0AHrOeK2XeMUIxgM0tTURCAQSLhkGM2/EyhmjBzdTtwhmL9sEXqDAV8oxvP1yvTTovRBXn/6qUT8M9euwiSi5KYap8XFQzQaxe1243K5EsZmjUZjQuAYjUYMBkNCKMRiMSKRCKFQiGAwyODgIB6PBwCTyYTVaiUrK+u4jPJSU1OpqKggFovh8Xhwd3vodXRQUFI2YdpKq4GidD0OL+SefwO+g2/g2/8qL734IpUVFSwcQ/DoDQaqFiym6eBeDB1dmM1mqqqqJjxfWloamZmZHDx4kFAoRGtrKzU1NafUOqHG7CZZU0e/FEI8BxillAdVAbUWZdpP4xQj7o49FApht9vR6/WUlZWN2jFFIhEaGhro9kcpLKvGaEohFJX8oc6HKxCjwCLY+/yDiamlirJSFs2ppDTdwPx5c0lLSzsqz6kSiURwOp309/cjpUwI1YyMDIyqJ1ydTofJZMJoNCYEVDQaJRwOEwqFEhpr4XAYr9eL2+1OqNZnZGQcNzt18Q98B3x7aOtoIzMrB3Nq6rhphBD8W00ar7cG2O0Ikbb4LJAxfAe287tHHuHWr91Kds7oo1FLWjrlcxZibzyIrrmFlJSUpAzrFhYWIqWkq6sLk8lEd3f3mC8qGhrHm6RfCaWUjUKIHCFERTwIZW2qf1pKpnHCiJsxam9vJxKJUFlZOebooa2tjV5PAFLSyClQDKS+3OTH4Y2SZdZhOPgSfb3KTLDZbGb9maspTNdTWV5y3Kxmx2KxxHc7wDBBIoTAarWSmZlJenp6Imw0pJSJ9amBgQFSUlLIzs4mFArR39+Py+ViYGCAjIwM8vPzj3n6Lzs7m/KSYvyhDtqa66leUDOhS/lUo46Nc1OpyjLwzEE/aTVng96Ib+8rPPX0U1x77bVjps3MzqGwvEvEBAAAIABJREFUYg6dbY0YDtdjtVpJnUAoGgwGsrKyEmt2HR0dZGdnYzKZplRnDY3JkKwtvnNRXLaXjzgkk81D4+Sgp6cn8UGuz+ejuLh4zI9x/X4/La1t9PqjVC+egxCC9oEI+7rD6AXUxGw8s/OtRPyNH/somRYDBda046a1F3cVEQ6HycjIoKCgAJPJhMViIT8/n//P3ntHR3bdd56f+ypHVK5CoQq5G81OTC2KlCyJFpVsKo5lSl7LQfLYqzNyGIezntmZ2fWcPfY6jG15PMeelUeSKZNiW1YgKUq0TVumJEqkaVFi7tyIVUChIlA53v3jocroBio0utFEd7/POXWAerjv1a0Gun7v/u7v9/16PJ6B+6qEEFgsls65rVaLXC5HMpnEaDTi8/nIZDJkMhkKhQIulwu/339ZfVuTk5Nks1lqmSKnX3yO8Pg0Lm9/gdcZr5F798HXzhSxzbwB5/AYP3Zn/4DvDYQoF/Ok15OcP39+IMVzh8OByWQikUhgs9lYWlpicnJn9iIaGpfCoMHlfwKj2xzXktHXEcVikcXFRQqFAqlUCpfL1VXRodFocOLECVKlBkO+AFa7g2ZL8sR5taT8iKfF397/EACyUWNmegKv00bAqmN6evqyxV1brRarq6tks1mMRiOjo6PYbDYsFgvhcPiKKFEoioLH48Hj8XRsRXQ6HW63m1QqRTabJZ/PEwqFdlw8oNfrOXr0KNazZ1lJZojNncHpcvd10gU4HDDiNCl86dV1qs4RzpTM3DFAvUkoMs7pl9KsJNMMDyAKK4QgGAyysLBAOp1GURTy+bxWMKGx6wz6KRECngEmAQ/g3vTQuA5oN+NWq1VisRhms7nrXkOj0eDll19mKb1ORZgZjk6QLTf5q5cKrBSbOIyCU/9wnEqlimw1sZkU3veW1zHh0jE+Grnsqr1qtcrs7CzZbBaPx8Pk5GSnKfamm27aFZkkq1Xt1brppptwu92EQqGOkO3S0hKxWGzHZeoWi4UjR47gczsxKZL13GCqDwCjQ3reM6MGim8vVFir9i8j1xsM+MNRkqUmp0+fplLpL8HULphIp9OdgglNYUJjtxk0QH0ZKEgp56SUOSnlWvuxm5PTuHrMz89TrVaJx9Xm0ZGRkW1XOfV6nZdeeonFZI61up6JmUOUWwoPvlRgZUPK6FZzkvlzZ9UTGhXe//a3sH9ylB964xsvO7WXz+eZnZ2l2WwyOjpKMBjE7XZz6NAhfD7frleYWa1W9u/fz8TEhOoHNT6O3+/vzKtcLu/42sFgEKdJIZNMXNJ50x4DM14D9RY8drpIvSlZWlrq2R/lC4ZRLE7iuTKvvPLKQMF1s8JEpVJhdXX1kuapoXGpDBqgrMA9QogXhRCfE0J8ZuPx6d2cnMbVIZPJkM1mSSaTnWbc7TbBW60WL774IvOrOXINPZM3HUZnMPLwqSKFuiTi1PGxWxy84cg0H/nJn8Cka3Hs5kMc2TfG5OTkZZdpp1IplpaWMJvNTE5O4nA4GBsbY2pqqlOld7XweDydoOjz+RgbGwPUQD+o7t3FBAIBHCYd5fzaJSugv23Cgt0gWFxv8hdPzfHHn/wTvvFP3+g6XgjB2PQBSphYyeaZn++v+6zX6/H7/RQKBQqFAvF4XFOY0NhVBg1QP4a633QY+Ajws5seGtcwjUaDxcVFyuUy6XQal8uF07m9Qd78/DyJbJ58y8jUwaMYTGa+dqbE0rqa1vvAjA2zXqFcKmKizr+97z28582vY3p6+rKqvqSUrKyskEwmcTqdnf2mAwe6u+xeDXQ6HePj40xOTmK325mYmMBut5NIJIjFYgOrNrTR6/X4fT7sRjGwDFIbh0nhQ4ft6GmwrndjPXg3j3/9cebnugcenV7P6NR+ksUmC4tLFAqFvq/j8Xg6ChPNZlNTmNDYVQa9pf2vuzoLjdeMxcVF6vU68Xgcg8HQ1bk2n88zt7BIstRi7MA+9HoDXz1d4tUN2/YPHLBhM6r3O8sLs3jMgn3RSSYmJi6rb0hKSSwWI5/P4/V61VWGw3FFVmRXCrfbjc1m49y5c+h0OlKpVEcN/FL3pSKRCMuJVRZWl3F5/Vhs9oHP9Vt13HfQwedfKWKbeSO1xHkeePABfuM3fqNrSbzV7sAVGCaVW+H06dMcPXq057/rZoWJdDqNEAK/34/dPvg8NTQGZdBGXS1AXYcUi0UymUxn4zsajW5bMi2lVG3biw3cgWFsdiezuXonON13yE4pMUdRGUY269SKa4y4TUxPT19W6m1zcAoEAni9Xjwez55UPTcajRw4cICFhQUATCYTsViMlZUVqtXqwD1TDoeDsWiE0vlF5k6fwGgy4QmEcPt6W963GXWbuN1f5LkUOF/3PjJP/H888vAj3Peh+7qeExoZ5XQ2zWJqjdbzz3P48OGeNxU2mw2Hw0EqlWJoaIiFhQVuuummPfc70bj2GbjWVwjxU0KI7wohEkKI0Y09qHfu5uQ0dpd2I25bJaHbXXAikSCZy1ORBoIjarfB95drANwZMWOprfGZT3+aP/i93+Ofv/1NvBYdo6Ojlx2clpaWOmXc7dXTxMTEnv0gFEIwNjZGNBrF4XAwPj6OlLLT+DwoY2NjBIasBM0thiixvDC4yCvAPfvduEQZncWJ8/b38Mwzz/DySy93Ha/T65m66SgFaWIxnefs2bN9X+NiS45kMjnw/DQ0BmVQw8KfB+4H7gR8UsoF4G7gV3Zvahq7ydraGvl8vqO+0C2112g0mJubI1VsMjw6jqLTsV5tcTZTRxFw2Kfjwc8/SLlcIbu6zJOPP4x/yHZZKhHtlVOhUCAUCnXKuqPRi/vE9yaBQIDp6WmsViuhUAhFUZifnx9ojwfUvahbbrmF199+M36XHQNN8muDC7YoQvDhWwOIZh3TyAHME7dy/K+Ps77eXZnMaDIxceAw6zVIJNN9rTkutuSIx+N9hXg1NC6VQVdQ/x6YBb666dg/A7de8RlpXBUSiQT1ep1cLofL5epaxBCPx0kXKigWGy6vH4DnV6pIYMZr4Lvf/EfmZueQ9Qqyss7HPvwBbr755stSV8hkMp20Xjs4XSlZpKvF0NAQMzMzmEwmxsfHMZlMnRXhIBiNRlwul9oEbFLIpS5theKy6HjHpJqmsx++h3KtxfHjx1Xtly4YDEY8wREylSZzc3N9X8Pr9WIwGEgkEpolh8auMGiAGgP+ATi/6Vge2L7cS2NP01brzmbVu/JuSgLtD51MudlJ7WXKTf4lrpZAB5spnnjiCaRsIesV7rnzVt75zndeVsXe6uoqhUIBn8/XSetda8GpTVu5vP3VbDYTi8V6rmQuxu/34zQqFNayNC6xpPuWETt+Qw3FZMV26G5OnjjJU995qvfrhcKUGgrJTK5vuXy7YKJWq5FOp0mn0xSLxUuao4ZGLwYNUAvAm1DFYRFCHAbeg7qq0rjGWF1d7ejM2e32bfeKms0mCwsLZEs19BY7jiE3LSn56ukS9Rbsdwv+7m/+EtmSyHqFsNfBfR/8N139ogYhm82STqc7Yqxer/eaSet1w2g0MjMzc0GQisfjAwcpk8mE1+vBZpAk4oPbtoMaQN572AtSYpk6hs4Z4PGvP06l3F05QqfX4w9HSZVUZZF+e192u71TMFGv1zWFCY0ryqAB6i+BA8BHN56/AAQ2jmtcQzSbTTKZDOvr6zSbTTwez5YxKysrPP3005yaXeysnpotyWOnSywXmjiNgtQzD7OWW0M2GxhFi5/8N+++LAHRtuir3W7H4/EwNDTUaX691ukWpAZN942NjRGwGcinlsmlLy3V57fquDVkRAgF7x3v4d994hOYLb3L/r3BYeqKiWSu0FEW6cXmgolSqdTZ19TQuFwGDVB/CPweUERt2C0BfwD88S7NS2OXWFtb66yeTCbTFruF2dlZXj5xitlslWzLTGB0GpPdxZdOFNWych2Mlc9y8qUXkK0WrWqB97/tjdx85PCOe2EqlUpH/29kZKSjFLFXq/V2gsFgYP/+/VitVqLRaCfdN0jhhMPhYN/0FCGbntjsWdZzl+Zw85ZxC2Yd4Bohb+rf2KwoCuHRCVJldS+qn1rE5oKJYrGoFUxoXDEGClBSyqaU8j9KKZ1AQErpkFL+BynlztQxNV4zcrkcjUaDcrm8RTEik8lwbm6BpXwTf3SKfYduxuLy89evFDifa2A1CO7xl3jyq8eRUg1Ot82M89Y3vWHHzrjtfS5FUTof3N10AK91Lg5S7cKJUqnU99xwOMzE6Ahhu8Li2ROsZdMDv65Zr/CWMdUy5cn5Cq0BUnBOtwezw026VGd5ebnveI/H0ymYaDd+a2hcLj0/BYQQbxVC/JEQYrp9TEqZEkJMbhx/6+5PUeNK0Wq1OuXlwAV2CVJKZmdnSZeaBEbG8AZCtKTkSyeLxPKqCOxHjthZeOU5GvU6rUoBn1XhIx98LwcOHNjRaqddTt5oNIhEIhiNRqanp/eMQsRu0A5SFouFaDSKwWBgcXFxIEXx6elppsejhO064nPnaDYHX6XcHDLiNivkKi3OZNQVUSaToVardT0nPDZJtgKpTI5cLtfz+oqiEAwGqVarHT+xQQKvhkYv+t2m/mfgfcC5i47PAj8K/KfdmJTG7pDP52m1WuTzeQwGwwXqBolEgtRagaow4A2qVuBPLVRYWm9iNwg+csSBx6LjXe96J2++8ximZon//ac+xG233bbjhtz2nkUoFMJisTAxMdHVHPF6wmg0doLU6OgoOp2OxcXFnsGizeTkJAHPEBalwWp88LJuRQhuH1Z/3/8Sq/L000/zB7//B3ztsa91n6fJjG94hPWmjtnZ/vVQ7WbvVCpFo9HoqGpoaOyUfgHqKPCUvKgsZ+P508DNg7yIECIqhPgnIcSrQohXhBC/snHcI4R4QghxZuOre+O4EEL8dyHE2Q0F9dsu/a1pXEw2m6XZbFIqlS5I7+VyOU6fPUuy2CQUGUNRFOZydb67VEUA752x4TQptFotZk+/wusOTfHb/+k3ePvb377jkvK1tTWy2SxutxuXy3XFTAavFUwmE/v27cNsNhONRpFSsrCwMNDezdTUFF6LjkximVq1/8qrzdGgEZMOlvJNvvLEU1SrVb797W9z5syZruf4QyPUFROp7PpAxQ/BYBApJaurqxSLRdLpwVORGhoX0y9A2YBuImLWjZ8PQgP4dSnlQVQ1ik8IIQ4C/wH4RynlPuAfN54D/Aiwb+PxC8CfD/g6Gj1ob2JLKTvpvWKxyIsvv0xsrYbN48ftC1CotfjqaTU988aomdEhNeWWWomhq5cZcds4duzYjoNTtVpleXkZi8VCMBjE5XIxPDx8Zd7kNYTFYmF6erqT7mvvx/Ur7XY4HIRDQZxGSCXiSCkprOdo9RGmNeoENwfV/86hO+7tHD/+0PGupeeKTofbH+wUTPQrITcajXg8HtbW1iiVSiwtLe3YyFFDo1+AOg/cuxFMOmz0Qd3LgH1QUsplKeX3N77PAyeAEdT04f0bw+4H3r/x/fuAz0mVZwCXEOLG+wS7gtRqNWq1GqVSCSFERwx0fn6eZL6GweFhZHwaKSWPnSlRrEtGh/TcMazjiSeeoLC+TjK+hN+mY//+/TsOTq1Wi6WlJXQ6HZFIBLPZzPj4+BV8p9cWbZsOi8XCyMgI5XKZeDzeNxBEIhGGzAq55CrxhVnmT73C8uJc39e7Y8SEQYGaI4x9ZD+grqwfffTRruc4XV4aipH0enEgk0Kfz6cVTGhcEfoFqC+irpK+J4R4UAjxO0KIB4FnAQvwN5f6gkKIcVSJpH8GglLKdonQCtD2GB8BNnclLm0c09gh7Q7/crmMxWJBCEGpVGIlmSRfF4RHVRHWV5J15nINLHrBe/ZZ+dpjj/H41x/nj//b79LMp4kMhy4rFbeyskKtViMcDmM0GpmamrosWaTrAZfL1RGYDQaD5PP5voHAbrfjdQ1hVlrkVpcZcejJpVf7rqLsRoXXj6g3J6E3fKBz/JlnnuHVV1/d9hyhKATCUdKlJvPz831XeIqiEAgEqFQq5HI5VldXL8tpWOPGRfS6UxNCWIBvAse4UMVLAM8Bb5ZSDvyXJ4Swb1zvt6WUXxZC5KSUrk0/z0op3UKIx4DflVI+tXH8H4HflFJ+76Lr/QJqCpBgMHj78ePHB53KBRQKhevGz6bbe1ldXSWTybC4uIjT6cTlcrG4uMj86hrKUBB/OEqtJfi7lJuqVDjmzCNXTvL41x9HNhs0ixnuPBDlvvvu23FRRKFQ6JgiDg0NEQqFtlWeuBF+H9uRTCY77sbr6+t4vd6e52azWc7OLyEBiw5SNYWh4Qkcrq3N15tpSPjblJtKS4dx+UWWvvMwAFablQ9/+MNbrDZq1RoGo4GlcyextwpMRoYHMopsr6DC4TA2m43R0dH+/wi7zI36t7VXab+Hu+++e9sy4J71vFLKshDiLaiq5e9GVY9YBR4D/vslBicD8CXgQSnllzcOJ4QQw1LK5Y0UXvu2MQZs1riJbBy7eH6fAj4FcOzYMXn33XcPOp0LePLJJ9npuXuNbu/l5MmTrK6uYrfbO/1GxXKZNd0Q04dvpSpMPHqqSFU2iTh13B5x8Id//U0AWvUy0yN+fvmXf3nH/U7VapXZ2VkmJiYYGxvD6/V2Te3dCL+P7ZBScv78ebLZLEtLSxSLRaLRKDbb9lu9rVYL/4svotPp8Hq9PP/qadaFhanp6W3Hb8boq/M3rxapDR/Fc5dCvVql+Oo3eeH5F/jJj/zkBWPPnj3L9PQ0AZ+H5fMnsdpNHDhwoO+HY/t3PjQ0xPDwMOPj4111H68WN+rf1l6l33vo2w0ppSxLKX9XSvlDUsr9G19/V0o5cJODUJtkPg2ckFL+0aYfPQr8zMb3PwM8sun4T29U890JrG1KBWpcIq1Wi1Kp1EmzmM1mUqkUxWoTi91JGSOfeT7PUr6JzSB454SJBx98gFKxRKtWxmoQ/NR9H9ixLl6r1SIWi6EoSkcpYi/cTe81hBBMTExgs9k6KdClpaWu5eeKonDLLbdw5MgR1WnYrKdSWOfcqy/2beSddBt4y5i6UtKPHMYyeTvWm97Mc889x4svvrjtOUNuLzZ3gOW1Gi+99BLVarXna5hMJtxuN7lcjnK5TCwW0womNC6Jq9Wu/0bgp4C3CiGe33j8KPC7wNuFEGeAt208B/g6aoHGWeAvgH93leZ5XVIqlZBSUi6XMRqN6PV6UqkUhVqLIbeXf5ytUGmoRRE/d6uD5576BufPnadVKyPL6/xv734rt912244baFdXV6lWq4TDYQwGA5OTk9elUsSVQFEUpqenO+XnQggWFxf7frDr9XomxseZcBsYokTs/Jm+e0WvHzFx7z4rPxRVA5V59DDo9Hzxi1/sGhRHxqeQZgeJ9Qrnz5/fdsxmfD4fer2elZUVrWBC45K5Ki37G3tJ3aQG7tlmvAQ+sauTuoHYXCDhcDhoNBpksllKdUlT5+JMpopBgffssxKfP69aaDTrtKoF3vq6g7zn3nsH2nPYjkKh0Ol3aqcXb4Rm3MvBYDAwPT3NqVOniEQiLCwsEI/HiUQiPRU7IpEIoVCIF154gWxljcJaDqe7+36UEIIjAbUa80y6SqJkxrPvGD9+981dqzQVRSE6uZ8zL32f5cQq4XC4p4K9TqcjEAgQj8fJZrMIIfD5fNrfgMZAaLexNwCVSoVGo0Gz2cRkMpHJZChWm+isTr6xoMre3BUxozTKPPjAA7SaTVrVElG3hZ/76Efx+/07et1Go0E8HsdkMhEMBhkaGtrxtW40rFYrY2NjWK1WgsEghUJhIFt1vV6P3+/HYRTkMoMrn986rK6ixu58JzMzMz3HGk0mvKFwx5KjX0n80NAQVquVZDLZseTQ0BgELUDdAJTL5c5+gclkIplMUqi1+H5tmEy5hc+icEfYxEMPPcTa2jqyVsHQKvPxn/vZy+pRWl5eptVqdfZTbuR+p53g8Xg6lvdut5t0Oj2Qj1QgEMBmVMjnMn3Lztvc5DNiUCBWkMTy/dUs/MMjVKSBlcz6QDJIoVCIVqul/u1tVHNqaPSja4pPCPHTg1xASvm5Kzcdjd2gUql0ApSiKKTSaV6uuFlo6jHpBD92k416VXXZla0WrUaF+979Du64444d7xVls1kKhQLBYLDTjHs9i8DuFuFwmHK5jJSSSqVCPB7HaDRuKQXfjNlsxj3kJFHMkk6u4A/1byE06VWtvmdiVf7+XJmfudmOIgSVcmXbFZJOp2d0eoa5Uy9jnF/smEx2vf5GwUQmk8HlchGLxXC5XDd8D5xGb3p9YvwlF/Y+dUMLUHuYer1Os9mkVquhKArpdJp8pcUC6p7SO6csuC06wMqv/PIv86W/fpBycol7fvjuHfdYVKtVEokENpsNj8dDIBDYYu2hMRjtyr4TJ04QiUSYnZ1laWmJiYmJnh/uoVCIVHadldgclWKRyOS+vorzb4iaeTVZI1Fs8vxKDXP2HF/46y9w++23s2/fvi3jbQ4nwcg4ifgcc3Nz+Hy+nq/h8/lYX19nZWUFi8VCPB6/5h2TNXaXXgHqWwwWoDT2MO3S8mq1islkYmVlhbmKkfWmAatBMOP916bber3Gwf3TjL/uwI7dbKWULC8vq6Z34XDH30lj5+h0OqanpztBan5+vu+He1vb0HzuHIu5FJmkE28g1PN1jDrBWycsPHyqxDfP51n80mdAtnjqO0/xpje9CZd7q4KINzhMcjlGLl9ibW2tp8qITqcjGAwSi8XIZlXTRa/Xu8U0U0OjTdf8jZTybinlD/d7XM3Jalw6bZ+harVKo9Egly9yvqFWdh3yG9Ep/3rHuxpfwmUShIdDO66ySqfTlMtlQqEQBoOBiYkJraT8CtBOk7YFdguFQl918eHhYQ7MzOC36kgszdMcQCl9xmvAb1Woosd/8C4A6rU6x48f3/Z2VQiBJxBkrdocqITc6XRis9lYXV3VLDk0+jLwJ4cQwiaEuFMI8R4hxHvbj92cnMbls7mCr1Qqka9J4i013RYxFPjWt76FbEmqlTLrmSQus27HTbSVSoVUKoXT6cTpdBIOh7W74yuI2+3uFE0MDQ11Cg564ff7CXhd2HRNYvPn+vZGCSF4XVhVPHcdeQti4wbm9OnTfPe73932HI8/SKEGyWSqb/MubLXkGMTGQ+PGZKAAtSF3dB74DvAw8JVND409TLlc7jRdVqtVzlds1KVC0Kbj23/7CA9/5WH+7M//jDOvvtxZPfXagO9GWy1Cr9cTCoWw2+0Eg8H+J2pcEuFwGIfDQSik/p5isRj1er3nOVNTU/htBurraWZPvdJ3JXXQb8RmEKw19Nz69g92jj/61UdJp7ZW3xmMJuwuD7lqc6CKPpPJdIElR9tVWUPjYgZdQf0u4AfKqA23a0ATmN+leWlcIdoVfG0lidm6unryk+PVV1T16rMnXyWbiOGxGXa8ekomk9RqtU5qb3x8fEc28Bq9EUIwOTmJyWTq7O3185Cy2+3cesvNjHks6Gt54vO9FSD0iuCuiHqTkhi6CXdULZCoVWscP34c2dqa6xseHSdbhaXlxEArorYlR1thIhbbIrWpoTFwgDoKfA1Vdkii2mI8B/zxLs1L4wrQaDRoNBpUq1Wq1SqFOiSkalT4ypOq/49sNdk3HuHo5DD7NyR2LpVisUgmk7lALWKznbzGlUWv1zM1NYXJZCIcDlOpVPraczidTm655RYCDiPFXJL1bKbn+NuHjRzyG6i3wP76H0NnUlO1586d46mnntoy3mgyExwZY7XY5KVXXuH555/vmX5UFIVQKES1WiWTyajakBuKJxoabQYNUAowB7QFYoeAc8B/3oU5aVwh2qm9RqNBrVbjTMVOCwWPrkpi/hwAepq87Y3HiAwHCYV6V3ltR7PZZHl5GYPBQCAQYGhoaMeySBqDY7PZiEQiOBwOvF4v2WyWtbW1nudYLBYmx8cJWPUszZ2lUu6u9yyE4EemrQzbdVQxMvGuj3Z+9thjj5Fc3apS4Q0OY/UEmV9rcnY5w8mTJ3uqTNjtdhwOR0dhYn5+vq8qhcaNxaABagXwoQYpAbwA3AdoXXZ7mPaGda1Wo1KpcLaqrp7Wz30fANlscNO+CSJ+145tNNrVWCMjIxgMhh2Xp2tcOoFAALfbjd/vx2KxsLy83LdIYWRkhGG/G5+xxfkTL1Eudl/l6BXB+2as6EWLdYOX0G2qbGa9Xueh4w9tSSsKIRgZn+LALXdQkoaBHHjb+5SJRIJyuTyQY6/GjcOgAerLgAHVYXcZGEbtofrzXZqXxhWgvYKq1+sUS2VWm2qaZuXlZwBQZJ03HTtKdGRkRym5QqFALpfD4/FgsVgYHR3dsZmhxs4YGxvDYrEQiURQFKXvfpQQgkOHDjE27MNnlsyfPdlTDsll1nHMuRHEJt+AwRXCbDZx5+vvRBHbf3zo9HqCI6MDOfAaDAZ8Ph/5fJ5CoUA8Hu+qpK5x4zFQgJJS/rqU8oNSyixwBPgA8AYp5X/Z1dlpXBa1Wq2jIrFaM9BAh1Ir0qrkkc06+8ajjAbcO+rmbzQaLC8vYzab8fv9eDwePJ7eTq4aVx6dTsfk5CRGo5GRkRFqtRorKyt9zzl48CAhtwOTrLES613rFDHXuDlopIUg8vaf5Vd/4ze54/V3dPcnANy+ANJgJr1eIpFI9Ly+1+vFaDSysrJCo9FgaWmp53iNG4dBy8zPCyH+E4CUMiOlfAQ4LIR4pM+pGq8htVqNer1OuVxmRarVe+UVde+pVauoq6dodEernpWVFZrNJsPDwxiNRk2y5jWkvXq12Wz4/X7W1tbI5XI9z1EUhZmZGfw2PdnEMsVCbxHat01Y8FkUitLIiUL/1bYQgkB4lEylxcLCQt9V3fDwMPV6nVQqNdB+msaNwaApvnHgYq/mW1Ft4DX2KG31iHK5TKKl7j9VkwvIRg2/y84RUjE8AAAgAElEQVSBiciOZIhyuRz5fB6fz4fZbGZsbEwTgn2N8Xq9eL1efD4fVquVlZWVjopIN+x2O+OjUfw2HbG53k28Bp3gXdNqivjZeJW1yqaxXeoahjxeMJjJFPpXGVqtVoaGhshkMlSr1b5BTePGoGeAEkJ8QwjxjY2nH2w/F0I8Cfw0kN/tCWrsnFqtRq1Wo1Qqk2zZAGikF2jVq9wyM040Gr3kwFKv10kkElgsFnw+H36/v6dhncbVY3R0tKN9qNPpiMVifT/kR0dH8TutKPUy6cRyz7ERp56DPgONFnxjTtV4XFpc4g//6A+3lTlSV1FRMuUmp06d5vTp0z0bcgOBAIqisLy8TK1WY3m593w0rn/6raDu3nhIILLp+ZsBG/DVXZuZxmXRbDZpNpvU63XSFUlZGjDp4Nc+/lFef+wW7rr95h2Vlbc/iMLhMCaTiUgkcqWnrrFDFEVhamoKo9FIOBweeD9q3759BKw6kvGFvv1Rd49bMChwKl3nkadP8MlPfpLYUozPf/7z2xZbDHl8WN0BZtcanJ6Pc/bs2a7X1uv1BAIByuUyuVyuU9mncePSL0B9FPgY6nboExvPP4q6evrhja8ae5B2JVStVmOloaZmIg4dsl7hTXfcxuTk5CV78WQyGUqlEsFgsGNAqAnB7i3MZnNnP8rn8w20H+V2u5kYizJsU1g8d4r8WrbrWKdJ4W2TqpDwGRnCPHoEYbQQj8X5+yee2DJeCEFkYprJgzeTKrVYSaz2TD26XC4sFgurq6ud3iiNG5ee+R0p5f0AQggJvCKl/N5VmZXGZdPuhykUCmRR03shu55sOsmIVbnk1VNbrcDhcOByuTp6exp7D6/XSz6vZt9LpVLHf6lXK8Hk5CStVgu5EGPh7EnG9x/C5tjew+towMhcrsGJVB37sfdhrVXIPvlZ/uGJf+Dw4cPbrqotVhtOr59cMcXCwgL79+/vOpfh4WFmZ2dZXV1Fr9eTTCZ7miFqXL90vf0VQvxfQoh3bDwdA35049gFj6szTY1Lpb2CWl9fZx11BWWlgl42cDlsl2QguNnjKRQKYbVaCYfDuzJvjSvD5v0oRVEG2o+amppifCRE0Kowf+ZVal2afoUQ/Oi0lbvHzARtCorRjOO2e2m1Wnz+wc933WcKhCPkqpLl5ZWeqTuTyYTX62VtbY1isTiQIK7G9Umv/MxvAe/a9P3/fdGjfUxjD1Kr1Wi1WuoKqmkEIL88i1XHJUsRJZNJKpUK4XC44/GkCcHubRRF6fRHhcPhjstxL4QQ7N+/n2jQi0MvSS5370cy6AR3Rsz8xGE7Zp3E6BvFsu9OVlYS/P3f/f2255jMFpweP+lys+deFKirQIPBwPLyMvV6ncXFxf5vWuO6o1eAuh94duP7z23zuB/N7n3PUq1W1R6oSpWyUPcMHn7gf/GNv/86brd74OsUi0XS6XRHCDYSiexIUFbj6mOxWIhGo9jtdrxeL7lcjvX13v1ObYt5l1khl1qlXustnWTWK7x9Sk0hO25+B553fYInn3uZhfntjQhD0THydUEimSGZ3Krn10ZRlC29Uf320jSuP7ruQUkpP7rp+5+9KrPRuGLU6/WNCj5A0dEsrdGqFJiZug2HwzHQNdpCsEajkUAggNPpJBAI7O7ENa4oPp+P9fV1pJSUSqWO+ofRaOx6js1mIxTwky2vkFzpb4Nx0GegWjfzxMkUersH5+s+wOcfOs6v/9qvYjBe2ARuMBgJRsZIxGY5ceoUBoOhq028zWbr9EY5nU4WFxdxOByXXNyjce1yKY669woh/loI8R0hxHEhxL27OTGNy6Ner9NoNEhW1VRcYz1Jq1rk2LFjA1feLS8vd4Rg21V7GtceY2Njnf0ogFgs1lc1fHR0FLdFR3Y10XcVJYTgtrCZjx610syn0Tv9FAOH+PrjX992vCcQwjLkYylX44UXX+q5qmv3Rq2srFCr1Qaylde4fhhU6ujXgEeBHwfuQlUyf1QI8eu7ODeNy6Ber1MqlYgX1A+ixtoqbpt5YLXx7dQiNCHYa5PNen2D+kfZ7XbCoSAuE6QHWEUBBHwejjnXkbKFbeaNrDmntg2EQggik/swu/wki71LyfV6PcFgkHK5TCaT6djEa9wYDLqC+jVUB91PAh8H/mTj+a/u0rw0LoNGo4GUUjUSbKipnMZagnDAO9D+U7vB02q14vP58Pl8XdMwGtcGVqu14x/ldrvJZDI9DQUBJiYm8NoMVPJrxObOUS71DwzvvOtWgoWzgCRujPCthe17noQQDEfHKTQEyXTvuQwNDWG32zu9UXNzc5pv1A3CoAHKBDwkpfw1KeWnpJS/ChxHteDQ2GO0S3ILhQJFndqr1MjGmRiL9i1wkFISj8cRQnTUIjQh2OuDtqFkMBjEbDYTj8d7lm+bTCYmJybwGuqQX+X8qy9QzPcuskDAx951Bx84oBZOPBurUqhtX96uNxhw+YLkKq2+Cubtvr3l5WUqlYomg3SDMGiA+mPgFiGEG0AI4QFuAX5/tyamsXPaHzqlUommRbXAqKcWezZHtkmlUpTL5Y5K+cTEhKYWcR0xPj6OyWRiZGQEKWXf/aiRkRFm9k0xMxoiYFVYPH+mp39Umxmvkf0eA00J/xLvvoflD4VZr0kSfRQm2o7NxWKRtbU1VlZ691JpXB8M+snz88AhYEUIsYRqWngT8IkNK47zQohzuzVJjUuj3aS7ml1HWJzIRp16bplDhw71PK9cLpNKpRgaGsLpdBIOh7HZbFdjyhpXCb1ez8TEBEajkVAo1Pmd98JmszEzM0PAZcckqyRi25eQX8xdEVW54vvLFT59/wPbpvGMJjMOt5dctdl3FeV2u7FYLCQSCc0i/gZh0AA1tjHWAIQ3vupQbTg2PzT2AO0V1Km42jfSyCdx2S0de+3taLVaxGIxDAYDwWAQu93ec7zGtYvdbiccDjM0NMTQ0BCpVKpv4UHbP8pn1ZFJrtDsoUreZtihx6OUqbcEsyUzf/OFL2xrzREYjpItt4j1saxv+0a1Wi1WVlYoFvtbymtc2wwaoH54gMdbd2OCGpdOu8R8Iaf+Z2+srRIJ+Xtq57U3oMPhcCe1p6lFXL+EQiEcDgehUAij0Ug8Hu9phQHgcDjwez1YdZJMqrcqRZv9VjUNZ5m6nZdeeoVnn312yxiz1Yrd7SVXbjA3N9fzeiaTqWMRn8/nicfjPYOaxrXNoJbv39z8AM4Cz29zXGMP0C4x17lV0U67qHLopgNdCyQKhQLZbBaPx4PVaiUajfZs5NS49mkrRrSt4pvN5kA9RsPDw7jMOtKJ5YHSa285OoGhUUJnc2Mc3sdXvvIV0qn0lnHB8CjZCizEVvqm+rxeLyaTiZWVlU5Vn8b1yaB9UL8lhPi6UPl9YAFYFUJ8cHenp7ET6vU6hUIB6VBVH27bF+Gee+7ZdkXUbDZZWVnpqEW4XC683ovNkzWuR9q6imazmVAoRLFY7Lsf5fV6GbKZURo11rNbA83FCCF4w4TaomCdvoNqtap6R10kXGu2WhmZmCZeaHD67Dmy2e6WH+0K02azSSKRoFAoaKm+65RBU3wfRpVFMgK/BLRd0P7LICcLIT4jhFgVQry86dhvCSFiQojnNx4/uuln/1EIcVYIcUoI8c4B56ixQXsFVRCqirlHX+ua3ksmk53UnsFgYHR09GpOVeM1xul0EgqFcLlcOBwOUqkUpVKp63ghBJFIBN+GTXw/lQmAW8NmdEJiDE5iDM8wOzvLP33jn7aMc3n9eIejJIpNTp061TPlaDabO4rnhUKBWCympfquQwYNUKPAOdTKPSPwPuDzwNSA5/8l/6qMvpk/llLesvH4OoAQ4iBqQDy0cc6fCSE08a1LoF6vUyyWKG6IxPoN9W0DVKVSIZvNdqqjotGophZxAxIOh7Hb7QwPD6PX6/vuR4XDYcJ+D0OGFnNnTrKezfRM95n1Cj88rt4sOW9/D4rZzuOPP75tKi8QjiKNNpLrZc6ePdvzuj6f74JUn2ZueP0xaICqABPAO1EVJF7Z+Nq/IQKQUn4L6O0l/a+8DzgupaxKKWdR97vuGPDcG55ms4mUkpV8jZbQYaSOTS+xWCxbxq6srKDX6/H7/TidTjwez2swY43XmvZ+lMlkIhKJ0Gg0ejbCCiGYmZkh6DTjkGVWzp8kNte7y+T2YSPjQzoUkxXHrT9Kq9XiwQcepF67sFFYCEF0ch/pCszGErzwwgudtont5hEOh2k0GqyurpLP57VU33XGoAHqWeAdwO8A/yylLAMzqKuqy+EXhRAvbqQA2xo8I8Bm85eljWMaA9C+833m1Vn1+doqr778Alar9YJxuVyOcrlMIBBAr9drqb0bnLYYsNlsJhAIUCgUSKe77zEZjUZuu+02bj4wSWTIwFoqQaVPavDefTYMisQ0cgDj8H4SiQSPfe2xLWPNFitj+w+SrCjMr2Y5ffp01+uazWY8Hg+5XE5L9V2HiEEqcYQQY8Bvo+5D/RZwHvgz4LtSys8M9EJCjAOPSSkPbzwPAinUzoj/BxiWUn5MCPE/gGeklA9sjPs08LiU8ovbXPMXgF8ACAaDtx8/fnyQqWyhUChcN/bliUSCXC7HJ7/+POWb3k3x1HeIzD3Oxz/+8c6YtpyRTqcjFArh9Xov2cRwN7mefh/X2ntJJpNkMqpXU7lcJhgM0mq1tl2Bt4nFYswnsjRtXkLRiZ7XP1My80LeTrOYI/PE/+TwTfv5oTe9adsCnka9xuKZE/j1VWb2T2+5yWrTdnxutVqd5vJoNLrtNa+130cvrof30n4Pd99997Y9LV39oDYjpZwHPgIghNBLKRvAv72ciUkpO40UQoi/ANq3UjFgs/hbZOPYdtf4FPApgGPHjsm77757R3N58skn2em5e41HHnmEY8eO0fgntdu/kV3myJEjHDt2rDMmk8lgt9uJRqO4XC6OHDmyp+SMrqffx7X2XqSUnDp1ivX1dWZn1VV4JpO54O/nYo4cOcIzzz7LbKaG3+tmyN29CnRSSlZeKJDAxcEP/io/9boAeqV7v92Q3UotE8fj8XD48OGu4yqVCnNzcx0FlEgksm2j+bX2++jF9fBe+r2HQcvMhRDiNzdkjqpCiKWN5zvu5BRCDG96+gGgXeH3KPBhIYRJCDEB7ONfnX01+tBsNmk0GlQMQwDUs/EL0netVot0Oo3VasVutxMKhfZUcNJ4bbm4P6rRaPRM9YHaPDsWjRJ26ImdO8lqvHsfkyIE75+xYjUIkg0Tj5wqUW92z+L4QyMUGoJEMk0s1t32Y3NVXz6fJxaL9dT207g2GPST6VeA/xdV5khsfP0d4N8PcrIQ4iHgaWBmI7j9HPD7QoiXhBAvoipR/CqAlPIV4AvAq8DfAp+QUg5UjKGh7kEVi0WkVd3Sq2fjTE5Odn6+vr5Oo9HA5/NhMBjw+/2v1VQ19igmk4nx8XEsFgt+v59SqUQm07vGaXx8nJv2TRJ16knF51nPdh/vtui476ANkw7OZOo8+FKhp+J5cGSMWL7BidNnezbltr3LlpeXqdfrzM7Oalp91ziDBqhfAJLA+4EDG19TqCKyfZFS/oSUclhKaZBSRqSUn5ZS/pSU8oiU8qiU8r1SyuVN439bSjklpZyRUj5+ie/phqbRaLC4FEPnUPeUdMU04XC48/NsNovJZMJmsxEMBrXVk8a2uFwuAoEAXq8Xq9XK6upqX/XwaDTK/ukpQnY9S7NnevZIhex6PnLUgcussFJs8ndn8tx///3blp77QmFC4/tYyjc5NzdPLpfb9poXa/W1Le41rl0upQ/qUSnlo1LK01LKR1FTcVrp1x6j2WxycnYJoTfSqhTw2M2dDe5SqUSlUsHj8aAoiqYYodGTSCSC1WrF6/Wi1+uJxWJ99fpGRkY6PVKL58/0HOu36viJw3YEktPZJi+dnuevPvdX21bhuX0B/OEoq32aeM1mM36/n3w+Ty6X64jKalybDBqgFoEfEUL8kBDCJ4T4IdQm2t6iWRpXnUajwfnEmvp9IYvX5egEqGw2i6IonZ4nvX6gGhmNGxQhBJOTkxgMhs5+VL8VSbtHym83Ui+uk0317ksaMilMOSVCKFj3vZ5kMslXvvyVbcf6QiNIg5XkerlnU67H4+nYctRqNWZnZ7dIK2lcGwwaoD6Huu/0TSCx8TW8cVxjD9FsNlleV+9Am4U0gUAAnU5Hq9Uin88zNDSEoija3pPGQJhMJkKhEBaLZaD+KFB7pKampgjYdCzPn6fRw7UX4M2TakGPZeJWFJONZ599lh/84AdbximKQmRyH6lyi8WlWNeVkRCCkRG1dbKtdt5PgFZjbzJogPoD4L8BJdQiiTLwhxvHNfYIUkqazSaZqlpc2VhPEgiogrGFQgEpJQ6HA7PZ3LWnREPjYtreYB6PB4fDQTKZ7KnXB6qdR8jnxqZvkVzpXn0HELDpmHLrEXojzjs+AAj+5gtf2DYQWqw2XL4g6VKDs2fPdk31tX3NSqUS6XSaZDLJ2trawO9ZY28wqN1GQ0r5f0gpHUBQSmnfeN771kjjqtI2KiyiOpk21lY7BRLr6+vo9XpsNhtut7vrNTQ0tmNkZASbzdbR6xtkP2piYgKPRUdmdZl6fXu5ojbvmrJi0YMxOInt4JupVKo88MAD29rLhyJjFJo6lpJZnn322a4K7G0B3GQy2emT6jdnjb1FzwAlhHjvxQ/grouea+wR2gHKO7ofgMOTYfbv30+r1aJQKOBwOAC0AKVxybT3o9p6fc1mk1gs1rOM2+FwEPB5ceglqeXeqyiHSeE9+22AxHbwLdgO3s383DyPfe1rW8bq9HrG9x9kHQuz6QpnzpzpuscUCoXQ6XTEYjFqtRqJxGBGixp7g34rqIeBr/R4fHlXZ6dxSTQaDRqNBjW9Kn/yugPjjIyMbEnv9ZKt0dDoRttpue0fVSqV+vpHjY+P47boyKyuUKv2bpyddBu4d58NpMR28M1YJo/x5D89ycsvvbxlrNXuYPrgzUiDmfVyrWvpuV6vZ3h4mFqtxurqquYddY3RL0AtbHoUUPefNh9b7H6qxtWmXq9Tq9U7KT6XvoHZbKZUKqEoClarVVs9aVwWTqdTddV1uXC5XKRSKQqFQtfxdrudcCiIywTxhdm+1z8SMPLufer+qO3QWxB6Iw899FDXRmG3z0++2uwZdOx2Ox6Ph2w2S7lcZmlpqW9Pl8beoGeAklKOSyknpJQTwGfVQ+rzTcc19gj1ep18rUVT6NDLBjZ9C5PJRLFYxGq1IoTopPk0NHbK8PAwTqeTYDCI2WzupM+6MTExgc9moLKeIb/W3Sm3zaGAkWGbQDHZsO6/i5kDM1gt2xf1uLx+CjVJMpXqub8UCAQwm82k02nq9Trnz5/XSs+vAS5FRkDTDNnjNBoNVovqprKZKgadgk6no1ardQKUzWZ7jWepca3T1uszm82dcu5YLNb1A78tneSz6IjNnd+28OHi698zqf6dOm56E+/98Z/EbDFvO9ZoMmO2OShU+ntYhcNhWq0W8XicSqXC4qKWANrraDo31xH1ep3vnTgPQDY+x9NPP90pB7bZbNjtdk3aSOOKoNfrO0UTIyMjVCoVVlZWuo4Ph8ME3A5Mssrqcv+epIhTzwGvgZZQeOR0iWarh7Pu8AirpSZnzp0nmUx2HWcymfB4PBSLRVKpFKlUimy2/4pO47WjXxXfl9sP4N0XHxNCfOmqzFJjIOr1Omt19VdazSYQQnT2n8xms5be07iitH2X7HY7Pp+PtbW1rh/4iqKwb98+fFYd6ZVYT3PDNu+atuA0CZYLTb698K8FFhenE4fcXnzhUeL5Ji++8irf//73u/Y82e12HA4HqVSKcllVpNAMDvcu/W6n37/pMYVaJPH+ix4ae4R6vU5ZqKmQxnqK4eFhisViJ62nBSiNK43f78fr9eL3+7HZbCQSia4FCE6nk+hIGK9ZEJvvb8Zt1iu8d7/6t/tsvMrKepUv/s0X+dM//dNOS0WbQDiKKxRhKS85s5zjxIkTNLukEjf3crWlkDTV871JPzG2/3pVZqFxRWg0GtQNdgyoKhKh0EHq9TputxtFUbT9J41dYXR0lFKpxMjICLOzsywtLTExMbGt1uPExASpVIr1VJ5MMoHHv9VUcDMRp55bgkaeT9T43HfOsfLd7wLw5S9/mQ996EMXjA2OjOIfjnDu1RfJFCosLy8TiUS2XFOn0zEyMsL8/DzLy8udPqntxmq8tvQMUFJKLUBdI7RaLZrNZscHqrme6Ni4WyyWTpGEhsaVRlEUpqamOHHiBJFIhLm5OZaWlhgbG9vyN9feuyqUTxJfOI+i6HB5fT2v/5YxMyfTdSrOMObxW6nM/YB/fuafGR0d5a677toyl2BkjPi5V5mfnycUCm0bKNteV6urq50Sdrvdjsvlusx/DY0ribZjfp1Qr9fJ5/ModtVCQxbSOJ1OAE17T2PXMZlMTE5OYjabGR4eplwud1VtCAaDTI5FCNsU4rOnWF6Y7VnZZzEo3DOhNpc7b78Xg091+fnyl77M/NxWVXOny43B6iRTqves1PN6vTgcjo7X1dzcnLYftcfQAtR1QqPRYH4xhs7mQrZaOJQaUkqMRmOnSVdDYzdxOp2MjIwwNDTUaYztpvAwNTXFgX2TjA4ZqGSWOfvqCz37ko4EjBwbNoJQcL/xQwiDmWazyV/+5WfJ5/Nbxg9Hx0mXmiwsLvW0fr94P0rrj9pbaAHqOqFer3M2lkQIhVZ5DafdSrPZxGxWiya0AKVxNQiFQh03XqvVysrKSteiiWg0yrHbbmXcZ0dpVFjL9JZNeuuEhYhTBwYLQze/HYC1tXXuv//+LSswq92B0+Pvq3re3o9qNBrE43FKpZJmzbGH0ALUdUK9XmduVS2tbRayeNzuToASQnQClYbGbjM+Po7FYmFkZAS9Xs/S0lLXAOFwOBgdHcVlUkglepshKkLwjkkrAjCO34J+SLWSOX/uPI88+uiW8aHoGOt1mF9O8b3vfa/ram6z11UqlSKZTPb1vNK4OgwUoIQQtwohflYI8R+EED8nhNAkjvYY9Xq9Y1TYKGQ6m70mkwmLxaIVSGhcNXQ6HdPT0xcony8tLXUt5fb7/TgtBhrlAqXC1nTdZgI2HbcNGwFB+J6fRTGplanf/ta3ee57z10w1mA0MXngCGtYmE2XePnll7uu5tpeV6lUimKxyMLCgqbXtwfo16jrFkJ8Dfge8Gngt4FPAWeEEH9yFeanMSD1ep1MRc2dNwvpjiisViCh8VqwuWgiHA5TLpe7Kk3odDqGh4cZMiusxvvLD7151ELApqOimAm+4+cRelUc+fG/fZxm48JUn8VmZ/rgUQwOD/F1teepm27g8PAwBoOhsx917ty5rr1UGleHfiuoTwI/AuSAdmfcN4EG8ItCiF/fxblpXAL1ep3Jw8cAuHnfGEePHsVgMKDX67UApfGa4HQ6iUQiOJ1OfD4fuVyuqyp5OBzGazVQy+dI9vGOMukFHz5kw2dRaJqc+G97G2NjY/zSL/4SOr1uy3ghBNHJ/bSMdnKVFrOz26uq63Q6IpEIrVaLpSW1uKLbWI2rQ78A9W7gCcAHHENVkvg0cAuwBvzCrs5OY2AajQbZippCCQ+pskYmk3pnqQUojdeKYDDYUZpwOBwkEolt7TnMZjMHDhwg5NCxGpunWFjveV2rQeFd0+rftWH8dj728X/HkGuo63hFUYhM7qPQ0hNbXmF9ffvrm0ymzoovkUiwtrZGPB6/hHescSXpF6B0QEqqyeN2U8NNUsqTwKPA2G5OTmNw6vU6aw311zmkVzekjUYjgFYgofGaMjo6is1mIxwOYzKZiMVi2/Yb+Xw+Jkaj+K0KsblzfeWHIk4940N66i14drlBq894k9mC0xsgVWpy6tSpbcvTQV35eb3eTpn88vJy1wILjd2lX4D6AfAhIcQ/Ak+jWm6017wGoPeOpsZVo16vk2+oHfN2UcNgMGAymTAYDOh0W9MeGhpXi7bShNlsJhqNIoRgcXFx28q+sbEx/E4rSr1MaqX/yuWNo+rN17/Eq/yPf1nnVFrdXzp18iTf/ta3t4x3+4LUdWZmk3m+9/0fdHUEbmsLtsvkZ2dntaKJ14B+Aer/BMrADwOTwBngQSGEAbgdeHJXZ6cxEI1Gg9VMjip6aDUxySoGgwGj0aitnjT2BAaDgampKUwmE9FolEajQSwW27JKalcA+q06krE5zp98mfVspmvzbNSp552TFjwWhVJd8uipEl/71nN86i/+gocf/govv3yhXbyi0zF98GaMriDxfINz585te+22f1S7TL5dNNHLFFHjytPPUfdp4Cjwi8C/BV4npaxIKetSygNSyh+/GpPU6E29Xuc731f/IzaKOR78q/s7KygtQGnsFaxWKxMTE1gsFoaHhymVStuaDHo8HmamJ5nymLA2CyRmT3Lyhe913Ze6ddjEz9/q4LaQkaaEl2QEYbAiJTz4wINb9pAUnY7w2CQYzGTy5a5Gh3q9/oIy+XbRhKZ8fvXo2wclpZyVUv6ZlPIzUkotpbcHaTQazG806bZKa9htVkwmEzqdTgtQGnsKl8vVkUNqe0htl2aLRqO8/vWv55YDU+wPOQmYJXOnXulqGS+E4G2TFsaG9KA34Tl6NwDVapVP/69Pb9lvEkIQjIyRLre6phuBC8rkl5eXWV9f15QmriI7VpIQQnxWCKGtd/cA9XqdlTU1P94s5hgaGtIKJDT2LKFQqFPZ53Q6SSaT21bVGQwGotEot99+O5OREMM2hcWzp2g2t//YUYTgLWPq37tp/DbMdlUsOZvN8tnPfnaLh9SQ24vOYiOxXubkyZNdV0ZOpxO/38/a2hrpdJrV1dWezr0aV47LlTrS5An2APV6nXRJ/U/bLGYYGhrqBCYtQGnsRcbGxnA4HITDYSwWS0cHbzuEEOzfv5+gZ+m/3GYAACAASURBVAiz0iKT3F4lHSDs0DM2pKcuBa97/8cQivoRNTc7x/GHjiMvso4fnZohVxXEEmnm57cqo7fx+Xwd5fNCocDi4mLXKkCNK0c/JYlmtwfw01dpjhp9UCv41Eq9ZjGLy+XqqJi3V1IaGnsJIQSTk5NYLBYikcgFxQjdxkciEdwWHamVeE/F8Tsjav/fqYqTg+//REdp4gc/+AH/P3t3Hh35dRX6/nt+Nc+DqqSSSvOsHtzddrs9xEMndhxnhrxAiAnkEnJD7oPLfSzWW7C4A3C5PGDxSAIhixc7kIGb4BiDM2ESYicmkMR2bHe3e1RrnlUaalDN43l/lFTdakmt7nZ3q1R9PmvVUquGX50jqbV1zm//9v7xiz9e91yjyUxrTz9zySKj4xOXTSdvamrCbDYzMzNDOp1mZGTkspXSlTduuxWU2OamVIF8Pk+a8n/CQnyJuro6lcGnVD29Xk93dzdms5nW1nKPp8nJyS3PB9XV1eF12tCX8oQXNi+bBNDu0nO0zYxOwKLmpe3RX648dvzY8Q3p53anm7pAkFCyfH3UVu+vaRotLS1omsb09DTZbPayldKVN267ABUB/gU4tMntmzd2aMqVyuVyFI12AIrxMHV1dSqDT9kVTCZTJUitpZ9PT09vmfrd2tpKvU3HwvQ40eXNzwMJIbi72cwvHXRg1gtSZh9tD38Ia9+96Jz1fO3rX9uQmFHf1II02gjFUpw/f37L8er1+nXjTKfTDA8Pqx5SN8h2AeoloENKeeLSG+XgpVZRVWBpaQlhKxeHLSXLhWINBoMKUMquYLPZKunnwWCQTCaz6TVSAPX19fR0thO065gdO8/ouVOkU8lNj+uz6nh3b7kcUtrdiX3/w7jve4wPPPYhfL71beY1TaO1q5dIFqbnFy+bqWc2mwkGg6TTaWZnZ0kmk4yPj1/7F0DZ0nYB6qPAVtc6/SZwRW03hBB/I4RYEEKcuug+rxDiu0KIodWPntX7hRDiL4QQw0KI14UQt1/Je9zKpqdn0Nu9ABjziUrtvbVafIpS7dxuN62trTgcDhoaGkgkEltWP29ra6O/t4tOrwlrIcHYuZNk0psnWHR5DLy928IenwG3CXRWJ2lf/6bPNZktBDt6mE8UGBwa4bXXXiMWi2363LVxxuNxQqEQkUhEpZ/fANtdqDsrpXx9i8eWpZRbp72s9wXg0Uvu+23geSllD/D86udQrp7es3r7GPBXV/get6Riscjw1CxCb6SUS2PRSez28nafClDKbuL3+wkEAng8nkr1863SuZubm7n7rrvoDPqpM8H4+TMszs1supo60GDiPX023t1b/n/x8kyW10NZCqWNKzSX14evuZ2phGRoLsrp06c3pKev8Xq9eDwewuEw4XCYUCjEwsLCG/gKKJe6qjRzIcR/F0KMXO2bSCl/AFxaZ/+9wBdX//1F4Kcuuv9LsuxFwC2EaLza97xV5HK5ShXzUiqG2WRUKyhl1woGg5VrpNxuN0tLS1u26DAYDPT39xP0ufAaCqQXJhg9c4JkfPOKE0GnnnZzhqKEZ4fTPPFanNlwkqeeeopM+kI2nj8QZODQEaTZwWIiy+jo6JbjbWhoqFRpX1lZYWpqikhk84uJlat3tddBeYH26/TeDVLKtRoj80DD6r+DwMVdy6ZX71M2kc/naewaAMBnN3HXkSOVKhJ6vX6HR6coV6+trQ2Xy0UgEKj88t9qq02n07F//34ODvTQ39pAg1VjcmSQ4haZdbc7E7y924LPohHLlvjS8Qg/OXmeJz73BPnchZWSpmk0d3QTycD03PyWQXKtZt/F13KNjY2pa6SuE3E1daWEEJ8Efl1KedXlsYUQ7cC3pJT7Vj+PSindFz0ekVJ6hBDfAv5YSvnvq/c/D/yWlPKVTY75MVZ7UjU0NNzx5JNPXu2wAEgkEpVtsd0mFovx9Guz/Fu2FWd8nD3L/8Y999yD2+2mrW13dkPZzd+PS9XCXHZiDmtNA1OpFAsLC2SzWfx+PxaL5bKvGR0dZT6WoWhxE2jtRNPW/w2ey+YwmowUSvDdOQNJvYtCNET4+SdobWnm7e94+7rq/5HFEInFGerNkt7eni2vKywWi4RCIUqlEg0NDZWiuDcyUamWfraOHj26acLd1f6JPQL84I0PC4CQEKJRSjm3uoW3tnk7A7Rc9Lzm1fs2kFI+TrkFPYcPH5ZHjx69poG88MILXOtrd9rc3Bz/NP4izIHHrGGxWDhy5AgNDQ10dnbu9PCuyW7+flyqFuayU3MoFAoMDg6STCaZnJwkm83S2tp62Qact912G8eOHWMmmqZQyNDetwed7sKvueHhYbq7uwHo7JJ85scL4G7A2n8fk2d/wEsvvcSHPvShSmCTXV1MDJ1FS0cxmUwcOHBgy52JfD5fyeZrb2/HYrHQ19d3w4LUrfCzdVVbfFLKv5RSvvmNDmrVN4APr/77w8DXL7r/F1ez+e4GYhdtBSqXyOfzLKeLAJhlBoPBoFLMlZqg1+vp7e3FYrHQ0tKCwWBgamrqstUbzGYzBw8epNljRcslmJ3YumW7USd43/5y9qtt4H6MDZ0cP3acp59+utz5jgvt4lOYmF2Oc/bs2S2veVqrHVgqlZicnCSTyTA0NLRldQxle1cUoIQQPyuE+FshxHdWP15Vmw0hxN9RbnjYJ4SYFkL8MvDHwFuFEEPAw6ufAzwLjALDwBPA/3k173WryWazjMwuA5CLLmA0GhFCqAQJpSYYDIZKkGptbUWn01V++W/FYrGwf/9+Ak4jycjClhf0ArS5DNzRaERoOlxvegxzxyFe/PGLfPOb36wEKZ1eT0ffHsI5wXRomdOnT2/aERioXHCcz+eZmpoinU4zNDSkqk1co+1q8QkhxNPA3wGPAW9d/fikEOLvr/RNpJQflFI2SikNUspmKeVfr6apPySl7JFSPiylDK8+V0opf1VK2SWl3L/ZuSflgqWlJRaS5R/+l1/4dmXlpAKUUitMJhM9PT2VkkhrHXkvtzKx2Wz0dncTsOmZHR9mYXZ6y2rlD3dYuDtoQmgajtvfhaG+k+9///s8++yzlSBlMlto6x1gIQ1DM0u88sorWyZCWK1WmpubyWazTE1NkUqlGBoaolgsvuGvxa1muxXUx4H3Ua4Y8TLw1OpHAbxvNUlB2UETExPoHeWr4i2FZOUksgpQSi2xWCz09PRUVlJSSiYnJ7e8RgnKbT0625ppdmjE5ieZGj2/aZASQnC03cK9wfLug+uun0Zn8/Dcc8/x7e98u/I8m91Jz223UzA5mYpmOXXq1JYrObvdXukjNT09TTKZVEHqGmwXoD4IlIB3SSnvkVL+nJTyHuA9q4///A0dnXJZUkrOjYyjme3IQg67vojFYkHTNAwGw04PT1GuK5vNRnd3dyVIlUolJiYmLhukurq6OHTbflrdRjKxZcILW5/Ovq/NQrtLh2ay4X3kP2G/7a0Mj45RLFwIKgaDkbaeAYTFyUw0zeuvv75lmxCn00ljYyPJZJKZmRkSiYSq23eVtgtQ/ZSrPTx78Z1Sym9Rrv6wec0Q5abI5/OMzJWvzygmozgddsxms1o9KTXLbrevC1LFYnHbIOX1etmzZw9NDj3xpRDR5Y0dfKHc8PC9fTb6vDqETo+19x689/08hUt+TWqaRlt3Pzm9jcnlBMeOHdtyu8/tdhMIBIjH48zMzBCPx1WQugrbBSgHsFVp30HAeX2Ho1yNfD7PdLhc2qWYCONxuzGZTCpAKTXN4XBcU5Dq7e7CY8gzOz5MPrd5koPFoPHTAw4e22PGZhBMxkt89XSCXHH91qBOr6ezfy/S4t52u8/j8VBfX088Hmd2dpZ4PM7IyIgKUldguwBlAh4VQvzjpTfKNfNUN7wdlMvlWEqVf8gLiXKbDb1erwKUUvOcTiddXV1YrdYrDlLBYJA6lwOXUTI5cv6yAaLVY+YXbrPjNAlmE0W+PpikJCVjoxfS1nU6Pa3d/QiLk9lomlOnTm2ZuLFWvmllZYXZ2VlWVlZUkLoCV5Jm3kW5Tt6lt915FWgNyWazrBTK38JiYolAIACoNu/KrcHlctHZ2XlVQaq5uZkGpxkycWYnLl9W1G3W8YE9dsx6wUikwBf+fZRPf/rTPPtPF7L71rb70sLM1HKcY8eOEQ6HN00r9/l8+P1+YrGYClJXaLtKEr9/U0ahXJNcLkdWZ8UMFGKLBIN3ACqDT7l1uN1uOjs7GR0dpa2tjYmJCSYmJmhtbd20LJHBYKCvr4/8iRNMhheZKBZpbOnAuMX/mTqrjvcP2PjKyTgLWh22PQ/y3HPPkc/nee973wtidbtvYB8TQ2eZWE4STZ7EbNDY09+P3+9fd7y1PlQXV2lfq25xaVkmZZsAJaVUAaqKLS8vg3W1UWF8kcbGRvL5vApQyi3F7XbT1dXFyMgIbW1tTE5OVoLUZv8XHA4He/r7kWfPEk5FGD4dpXvvoS2DVLNTz7t6zHzjfAbbngfRe5r4t5e/RaGQ533v+z8QmsBgMNLZt4+FuWmWoxFKyRS6wUHsdvuG+oEXBykpJU1NTQwNDdHd3b2uDqCy/YW679nudrMGqmw0OjqKzlH+C81cTGK32xFCqBRz5Zbjcrno7u6ubPdB+RrBrRIXfD4fd915J50BLw69ZGF28rLH31Nv4V09FkQxh6mxB8+bP8KPj53mySefpLR6bZOm0xFobqNn30HMLi/z8Rxnzpy57HbfyspKJbvv/PnzquLEJbZbU34NeOYyt3+8oaNTLiuXy2NwlQOU3yJwOBwYDAaE2LQwsKLUNKfTWQlSbW1taJrGxMQE6XR60+ebzWZ6e3vxWnTElhfJZjZ/3pp9DWY+fqcHYyaMzurC88Av8urJs/zN5z+/rlUHQHN7N2lMTC+vcPz48U0Dpc/nq3TlnZ6eJpFIMDg4eNlzaLea7QLU5Da3qa1fqtxIhUIBs9sHOgP6Up63P3QUh8OxZTsARbkVOByOSu2+trY2dDodExMTJBKJTZ9vsVhoagzgNgmmRs+T2eKi2zUui4H/dH8bplwMnd2D656f5czZQT77+GfXBcJyGvo+EpiZWFzhxIkTmwYpr9dLY2MjiUSCqakpkskkg4ODW9b6u9Vs1/K9XUrZcbnbzRqosl4ul2M+Vv4hNsosJpMRk8mktveUW57NZqsEqfb2dkwmE9PT06ysbN5pt7W1Fb/DhLWUYuTMcWYnRykWt95qsxh1/MqbWjAUMxjqmnHe8W7GJmf5zF9+Zt17GE0muvr3kzPYmA4nOXny5KZp6G63u1IW6eIgtdXK71ay3Tmonwghfl0IUX+zBqRcmWw2y2y8/MNuKaVViSNFuYjVaqWvr69yTspsNlfO9VzKbDZz5M472dvZQrtLTy4yz9CpExQus9VmNWr8/O0+hCxhbrsN3zv/L2KWxg2dd3V6PR29e8noLMyEE5w5c2bTenwul4vm5mYymQwTExOkUikGBwdv+c68223x3QF8EpgWQvyTEOKDQoitW1oqN00ul2MuUf5Bt8kUNpsNQG3xKcoqs9lMX18fNpuN1tZWHA4H4XB4XYr3GoPBQHd3N4fvuJ0OvxObyDE5MrhlBXSAgF3Phw448YokQm/Efugd6LzNG55Xbtexl5WinpmlKKdOnSIUCm1IiLDb7bS2tlIoFCpBamhoiEgk8sa/GLvUdgHqt4ATlNPR3w78b8qdcD8vhHhYqLPxOyabzfJvx8tVqOJzo5UApVZQinKB0Wikr68Ph8NBMBjEbreztLTE7OzspsHHbrezb98+Ak4TxdQK81Pjlz1+0KHnY/cGOVAHEsHXzyVJ5jZeeGswGOno3ctSWjI0u8xrJ8/y2muvEY1G1z1vLcFDSsn4+DjJZJLR0VEWFhY2HPNWsN05qD+VUt4ODAB/SLmRoB34ReA7lBMllB0wNTXFiixXjBh59Yc4nU6VYq4om1jrzOt2u6mrq8Pn8xGLxZiamtp0u81sNjMwMECjQ8/K4hwz4yOXXUkBPNLrotmpI5GX/PNICikloVCIH/zgB5WqE2arle59t2NtaCNcMjG6mOC14yeYn5/f8P7t7e3o9XomJyeJx+NMTU0xNTW17ThqzRVduiylHJRS/ncpZQ9wFBih3BOq6QaOTbmM8+eHMHiDAFiLKzidTsxms0oxV5RNaJpGV1cXLpcLv99PY2MjqVRqy9JIHo+H/Xv30OIykI6EGD7z+mUz/HSa4N29Nkw6GA4XeHlihSeeeIKvPfM1/uEfnq5cK2U0mfAHgnTvOYDV18RMvMCZc4PMzMysO57BYKCtrQ2z2cz09DThcJiFhQVGR0dvqdJIV9ryXSeEeLsQ4kvANynX51N20OuDo2hmO6VcGpehhNPpVBUkFOUyhBAEAgGamppwu900NzeTz+cZHx/f8jqlgwduo6POikOmGTl7gnhs6/NBLpPGWzutAHx/ukjGV+5G9MMf/ognPvc50hcFOE3TaGxpp66pnZl4gdODwxuKzer1+sq5s1AoxPz8PJFI5Ja6Vmq7LL4HhBB/BcwD3wI+RLkFxxDwu0D3DR+hskE+n2dwrrx3XYiF8NV5sVqtqkisolyBxsZG2tvbcTgctLW1IYRgfHx804w5l8vF4cOH6WkN0GjTmBo+x+i5U0yPDVPcpOrDXr+Be5pNIDTs+x/Gdd9jCJOVwXODfOpTf04oFFr3fH9jkEB7L3NJycjsIqdPn1637ahpGs3NzXi9XiKRCNPT08Tjcc6ePbtllYxast0K6gXgY0AdsAh8GrhLStkvpfwDKeXY5V6s3BiZTIaZePkvqEJ0nsbGRoQQKkApyhWqq6ujp6cHm81Ge3t7ZSttaWljM0O9Xk9fXx/dq+3jXTJJcWWB6fHhDc8VQvBgm4X3D9iw6AWmQDfeh38Fnd3L4uIif/6pT3HmzJl1r3HX+enZf4iVooHZ5RhDQ0MbzjU1NDRUuvOuZfhNTU1tSGuvNdsFqDTwJPBOICil/C9Syp/c+GEpl5PNZokWyskQ+fAczc3l1FYVoBTlyjkcDvr7+ytp6E6nk8XFRWZmZjac5xFC0NXVxd13Hubwgb0EHEYysTDhxflNj93tNfCRgw6anTp0Fgfu+x5DGC1kMln++nOf43vf+14leQLAYDTR1jPAYloyNhPitddeIxQKrVslud1uWlpayOfzjI2NkU6nGRsbY2ZmpmaTJ7YLUPVSyp8HzgL/QQjx20KIjwoh2m/4yJQtpdNpMkY3APnINB0d5YIe6hyUolwds9lMf38/LpeLYDBYKeC6VfKEzWbD5/PR09NDwKZjbnKMTHrz5AmHSeNn99ipt+nQ2b3U3f9BEAIp4Vvf/BZf+tsvkc1cKGlksdpo6xlgKadjJBTj1ZNn+dGLL63L8ltb8el0OkKhEJFIhPn5eYaHhzfNSNzttkszTwoh/oBy2/fHKaeafxYYEkL84U0Yn7KJyclJdO5GALR4eYtPr9ej12/X3ktRlEvp9Xp6enrw+/34fD5aWlrI5XKMjY2RTCY3fU1DQwPNTQ3UmQRTI+dJrEQ3LTZr1AneP2DDZhBonmaC97638tjxY8c5dvzYuufbnW569x3CHmgjoXMwEy8wPDy8biVlMpkq25Lz8/PMzc0Ri8U4e/ZszZVH2i5J4heA/0r5Qt0CEFr9qAN+Wwjxizd8hMoGJ0+fweBpQsoS1kIch8OhtvcU5Q0QQtDa2lrJmltbpUxNTZX7rm2iu7ubBrcVYzHF/MgZhk++RnR54zksp0nj3b3l7L58420ceEu5S9GBAwe4+667Nzxf0+nwB4J09O3F4qxjIZFncHCQcDhc2XrU6XT4/X7q6uqIRqNMTEyQTCY5d+7cluPdjbbb4vs1ygHp44BNStkE2IBfAUrAr97Y4SmbeWVwCqHTU4wv47YacblcKkApynXg9/vp7e3FbrfT0dGB3W5nYWGB6enpDVtoer2ePXv20N3opb/JQ9ChZ2ZsiMRKbMNx290G7msp/x8N1R3kzY/9Ko+892cocflzR01tHcQLgtH5MD85fpJTp05VzjcJIaivrycYDJLJZBgdHSUejzM+Ps7ExERNXC+1XYDaC3xNSvm4lLIAIKUsSCmfoNwrau+NHqCyXi6Xw9lSvr7ClIsx0N+PyWTa0LVTUZRrY7fbGRgYwOFw0NzcTH19PYlEgrGxsQ2p3Xa7nYMHD3Lo0CE6WoMEbBoTQ2dYiW68XupNLSaONJkoSTidq+OLZ3I88Vqc10NZiiVJPpfnK1/+8rpMQoPRROfAbejcjcynYHYxwtTU+i5HTqeTjo4OdDodk5OTLC0tsbS0xLlz53Z9Kvp2Jy0uV5agNtNGqlwmkyEqy8Eo6NBzV/ddACpAKcp1ZDAY6OvrqwQDi8XCzMwM4+PjBAIB3G73htd0dXVRKBTQZkNMDZ/F7WvAF2jCZC7/3xRC8OZ2M26zxpmlHJF0iUimxLPDaV6YyGAJD3H2lVc5efIU73//+7nj8B0AmC1WGlvasTtdTA2dwTQ2jpRy3YrOZDLR0dHB3Nwci4uLpFIpmpqaOHv2LK2trdTV1d2Er9r1t90K6gzwU0KIXxJCaABCCE0I8UvAT60+rtxE2WyWmWT5bwOHTGC32wEVoBTlels7L7W21dfR0YHVamVubm7TLT8hBH19ffR0tNLq1CHjCwyffI2J4XOVTD8hBLc3mvjQfge/eqeTd/ZY8Vs1UnnJsqMb+8FHyWazfPnLX+YrX/nKuiw/h8uDN9DM9EqeU+fHOHducN11UJqmEQwGCQQCpFIpxsbGKlt+Y2NjuzLLb7sA9RnKq6zPASkhxAyQWv1cB/zVjR2ecqlMJsN8uvxtc8kkbrdbZfApyg3k9XorW36tra34/f7Klt+lWXNCCDo6OrjrzsPs7QjS4TViyEQYOXOC8OL6KhKaEOyvN/KRgw7e129FQ2LtPoLr3g+gdzfyyk9e4c8+8WdMjE9UXhNobqO5Zy8rwkIoDcdfP8nExMS643o8Htrb29E0jcnJSRYXF1leXubs2bNbdhauVtulmX8B+FPK23lGoHH1owQ+IaX8/I0eoLLe7MISsaIBIUu4RAq3261WT4pyg61dL+Xz+fD5fLS1tQEwMTHB0tLShgtl17r63n3kCH2tjTTbNBYmh5nbpH2HEILeOiPvG7Cj18DU1IfnoY9iat7L0uISf/Hpv+DZZ5+lWCivgOxON10Dt2H3B5lcKTI0Uk6KuHgMZrOZjo4OXC4XS0tLTExMEI/HGRwc3LLVSDXatlislPK3gF7KmXz/bfVjr5Ty/77BY1M28Zm//UcAivFFRs6dUgFKUW4STdNoa2ujs7OzsuXncDhYXFxkYmJi03buJpOJ/v5+9u3po9lpYGVhdsv2Hd1eAx+/w8ntASNCCJx3vgedqx5Zkjz33ef45Kc+ydzcHFAOah5/A8GOHmYSRQZHxnn55ZeZmpqqZO9pmkZTUxNNTU1ks1nGxsaIRqPMzc3tmgSK7a6D0gshnMDkaibf/yOlfByYEEI4hRBqX+kmyufznF8oL9EzS1MUcjksFosKUIpyE3k8Hvbs2VOpPrEWAEZHRzc0IFwTCATWte8YGzy9aUt5u1HjrZ0W9vkNCJ0B34MfQrOWEzJmZ2b5xCc+weTEhTZ87jo/wc5eQlkdQwtJTg2OcOzYsXVbeS6Xi87OTsxmc+X82crKCmfOnCEUClX1amq7FdQnKBeJbbnk/iDli3b/7EYMStlcOp1mMVf+myC/PE1rayugEiQU5WYzGo309vZWWnd0dnZisViYm5tjcnJy0zJJa+072r0W9NkVxgZPUyxurIguhOBtXVaa7Dqk0U7T2z+OpbHcOKK1tZXmlvVt5V1eH3233UFj1wBLeT2jCzFefe0Y09PTxGIxSqUSBoOB1tbWSsr86OgoKysrTE9PMzg4WLWrqe0C1DuAFy6tWi6lnASeX31cuUlSqRRpoweA/NIkPT09gApQirIThBA0NjbS399fad3R0NBAKpXacjXlcrk4dOgQrT4HpmKK0XOnmZ+e3HBxr0En+MBeO81OHTlhxPGmxwi889e5/z2PoWkbf20LIXC6PfTuO4Te6WcyluPEuWFeevU4r776Kul0GiEEdXV1tLe3YzAYmJ6eZmZmhlgsxpkzZ5ibm6u61dR2ASoIjG/x2AzQvMVjyg0wODiI5il/yWVkqlKPa7MfWEVRbg6r1crAwAD19fV4vd5122mbrabMZjP79+8n6Ck3QixEZpg8f4qZ8ZFK510Ak17wgT123tRiwm4QlCxuvj2t4x/OJolmys8rFYt84fNfYOj8EFAuk9Tc0UNjRx9pg5tQVsfEUpxjx45VAuZaS3m/3088Hmd0dJRYLMbs7Cxnz57dsv7gTtjuHFISuPPSO0W5r/iR1cffECHEOBAHikBBSnlYCOEFvgq0Uw6QPyul3LqV5S3iuX/7MXrHfkr5LF59gbq6Omw2204PS1FueZqm0dLSgsfjYXx8HKPRSCQSYWFhgZGREfx+P16vl/KvznKQOHToEIuLi2SzWaZnZglFQ4wkE7T3DmAwGIHySur+Vgv3Npt5ZS7LDyczDIXzjEXz7LeZmfjXf+X111/n9ddf58iRI7z7Pe/GZrPh8vpweX0UiwUmhs4xEVkhc/wEbS3NdHR0oGkaPp8Pu93O/Px8ZSUVCAQ4d+4cfr+fYDCITqfbyS/rtiuoHwMHhBBfEEL0CCGMQoge4AvAbauPXw9vllIelFIeXv38t4HnpZQ9lLcSf/s6vc+uJaXkpbPlk6OF6DwBvxen04nVat3hkSmKssZut7Nnzx4aGhrweDx0dnZis9lYWFjY0FreZDLR3NxMV1cXd9x+iHafHWspxdDJY0yODK4rl6TTBHcFzfzH253s8RkolOBY3M6LYSua1QXAyy+/zB/90R/xox/+6KKisnrae/dg9zczuVLk/NgUr7/+OtFolEwmg9lspq2tjfr6RM//IAAAIABJREFUepLJJCMjI4TDYRYWFjh9+vSON0TcbgX1x8CjwC+s3i5WAv7kRgwKeC9wdPXfX6Tc2fe3btB77QrZbJbxaA5aIB+Zpa2lGZPJpFZQilJl1tq0ezweJiYmMBgMrKysEAqFGBsbw+Px4Pf7161O1mr6Gc+cYSkSI52JMDO8xEpdPQ3NbZUVlcOk8Z4+G13eHM+eT0JjP75AL7nFSfLhadJDL/H000/zox//iPe97310dnaiaRqB5lYcbjeTQ4Ok5yOEwjEMOggGAnR1dVFXV4fT6WR+fp5QKFRZTY2NjbG4uEhra+uOnOsW250UE0L8HPCXgPeiuyPAf5ZSfuUND0CIsdXjSeCzUsrHhRBRKaV79XEBRNY+v+S1H6Pckp6GhoY7nnzyyWsaQyJxoWRQtYpGo3zs8e9hve1tRH/8FO9qKfLAAw/Q3d297hzUbpjLdmphDmtqYS61MIc1N3suUkoikQhLS0sUi0VisRjxeBxN03C73RvGIqUkk8mwsrLCfGiBlbwgJfU43HXUBYLr/q8vp0qM5J1MZUzI1bKppWyK+PFvk506BUBPTw/33HtP5X0KhTzh0Bz5XJZcOoldK+Aylaui19XVoWkayWSSSCRCsVjEbrfj8XjQNA2v14vf77+uX5+178fRo0c3rfu6bYACEEJYgDcB9cAC8CMp5eZtJK+SECIopZwRQtQD3wX+M/CNiwOSECIipfRc7jiHDx+Wr7zyyjWN4YUXXuDo0aPX9Nqb5Xvf+x6P/fUrmFv2Ev3nT/GJ//JB7r77bvbs2bPuebthLtuphTmsqYW51MIc1uzUXLLZLJOTk6ysrJTLlc3Pk06nsVgsNDQ0bLo6SSaTjI+PE1paYjlVJKez0N4zgNFUbtsxPDxMd3c3yVyJ2USRV2YyTKyUkyeyM+eIH3uWUiaB0WTkne94J/c/cP+642fSKWbGRyik4tRZNBq8Tvbs2YPZbKZYLLK0tEQkEkEIQUNDA263m56eHpxO53X7ulz0/dg0QF3RhbZSyjTw3HUb1fpjz6x+XBBCPEM5+SIkhGiUUs4JIRopB8Vb2vHjJzD62wFwyRWVIKEou4jJZKKnp4dIJML09DRms5loNMri4iLj4+O4XC7q6+vX1dS02Wzs3buXtkSCs2fPMhdJMHz6BG09A9gcF4KEzajR49Xo9uh5fSHH86NpCPZj8LeVV1OTJylscr2V2WKla2A/K5Ews5OjpEJREsmfYNDrK8HI7XYzPT3N8vIybrebQmHjcW6kHa0EIYSwAZqUMr7670eA/wl8A/gw5XNgHwa+vnOj3HmlUglPUzvaghGtmOPugwO4XC6VIKEou4zH48HlcjE3N4cQAofDwfLyMuFwmJWVFXw+H16vd91Wnt1u59ChQ5jPnsUQWmZ88DTe+gCFwvr0dSEEBxpMdLgNfHs4xWjUguvIT1PqOMDBI1u37nN6vNgcTqbGhhgJhxHk8MYzJJNJ9u3bh9ls3rELeXe6VFED8Mxq6qUe+IqU8ttCiJ8ATwkhfhmYAH52B8e449LpNKcXMoAReylBZ1srVqsVh8Ox00NTFOUqrbXF8Pl8TE9Po9PpcLvdLCwssLi4SCQSwe/343K5Kmnper2effv2YbGMYJqeIRyZY3JiFotO0BBsxXzRH6tOk8bP7LFxciHHc2Npcv5O/vfpDD+/X4/XoqMkJfOzczzzzDO8453vKDc71Otp7xmgWCyQz+aYHDnHxOIKuddeo66ubse6JexogJJSjgIHNrl/GXjo5o+oOiWTSc7Hyj+onlIEj9uFyWRSbd4VZRczmUx0dXURj8eZmprCaDSSTqcJhULMzc2xvLyM3++vnPMRQtDd3U0gEGB8fJzo3DjGbITRsxHaeveu2/YTQnBbg4l2t4Fvnk8ytVLk704lMOgEkXQJLZ0hpqvn05/+DHv29PO2t72NlpYWdDo9OqueroHbmBguXz81v3AOn7fcwuNmUyUIdoHl5WXG0yYA6ooRvF5vzWRVKcqtzuFwMDAwQFtbG06nk/b2dpqbyxVjZmZmGBsbW1f81W63s2/fPvYODNDd3ECDVWN88DShmcl1lShgbTVlJ+jQEc9JwukSEihavNhveyvet36c87NRPvmJT/LEE09UCtHq9Ho6+vZi8QaYSZQYmZrn+PHjZLNZbqad3uJTrsDnn/oGK6V9aKU8fl25B5Ta3lOU2iGEqJx/WlhYYH5+HofDQTQaZWlpiampKSwWS6X6A5Tb0g8MDGA0GjFMz7C8OM2ZuRlsDieB5jYstvLzjDrBz+yxc2w+S71VR9Cp5/RUmO+Pp8Hpw3P0P5A88wIjkSX+/DP/H31d7Tzytkdob28n2NZJCY3p0SEml1Z4+eWX2b9/P3a7HZ/Pd8PLrKkAVeWy2SzP/PAU3L6P1PQ5FvITOBxvVSsoRalBmqYRCATw+XzMz8+jaRoul4toNMry8vK6QAUXtv38fj9jY2NEYjESuTij507S3NmLy1MHgFkvuKf5wimBOzrqONAm+dbpZc6t6LHvfxiAYibB8I++yrk//wt6e3t56OGH8Hq9tHT1k1pZ4tz0MsuJ17AYNVy2clPEvr6+GxaoVICqcouLi8RM9ViB7NwQPUfa8Xg8qoK5otQwvV5Pc3MzDQ0NzM3NVS7svThQzc3NEY/HcTgcuFwuDh48SC6XY2xsjImZeWZGzpFpbKG+qaWSbLHuPTTBT+33cXYxx8nZOFPLCTC78Dz4YXKhEaYWxnjh5RP89NvejN5goKt/PxpFiprGXCzK+HKY5USaxcVF7r333huSSKECVJX77nefw9iyHwD98gjdXXety+5RFKV2rfVxCgQClRWV2+0mFosxNDTE9PQ0RqORuro6XC4XRqORvr4+LBYL+tEx5kPTxCLLeHz1eOrq0RsMG95jwG9kwF9HseTlW2fCnI3pMTX1YWrqYxn4xqTksEfQoNMRCARx2MunF+KxKOdPnwAW6Zibo6Xl0raBb5wKUFXu6e/8K/r291PMJGgw5aivr8flcu30sBRFuYmMRmMlUIVCIXQ6HU1NTQSDQZaXl5mbm2NxcRGPx4Pb7aa1tRWHw8G5c+eIpXKszE+wMD2B0+PD4fZid7o2BCudJnjvvjrenC1xejrK6dkoSWMdC2l4Nm3iufkYbXV5jnT6uKezDofLjdvro5ANV4rTXm8qQFWxdDrNibk0+nbIzQ+zp7ujcqGfoii3HqPRSEtLC4FAgOHhYTweD06nk0QiQTgcZnFxkaWlJdxuNx6Ph7vuuotwOMz8/DwLy8sk08ssrywxXZAYzRbcdX48vnoMRlPlPZwmjXu6vNzT5SVbkHxvKML5mCBdFAwtphhanOQ7p+f5j/d33vD5qgBVxY4fP07W3YYeyM8Pceht+/D5fBiNxp0emqIoO8hgMOD3+9m/fz+Li4ssLCxgt9vJZDJEIhGi0SiRSASbzYbH42Hv3r10ZTKVqhWxWIx0Ps/K4hSLM5MYLFYcLk+5qoT9wvVUJr3gSL3kkDuHo66epZKVfx+NMRVJ88f/fI5ej8b9vht3ukEFqCr21N//Pea2cossZ2qW5uaHcLs3FHVXFOUWpdPpCAQCNDQ0EA6HCYVCmM1m/H4/0WiUaDTK9PQ0BoMBt9tNIBCgubmZUqlENBplbm6OSCRCKpcjEZljamEGzWjB42vA6fFiMl9IxrIZNTobXDzQ38TXj8/y3bMhBiMlhqMm3nvfjanRpwJUlSoUCnznxdfRPfAQxWSUXr8Fr9ertvcURdlACEFdXR11dXXE43EWFhbQ6/XU1dWRSCSIRCKV7T+73V7ZAvR6vZRKJWKxGMvLyywtLRFLZokvTLAwPY7L14DJvv53jkGn8f47mnl4oJ6///cz6IppnOYbE0pUgKpSIyMjzJZcuIHs/DCH9vZTX1+vKpgrinJZDocDh8NBLperBKW1zyORSKUnlcFgwOVy4XK58Hg8lQ7A4XCYpaUlQguLzEcXmJ2eolQsUsqn1vWDcluNvKXVgDEbv2FzUQGqSn3pS1/CMvAgAIal8/Q8/ACBQECllyuKckWMRiPBYJDGxsZKaw+j0Uh9fT3xeHzdqslisVQq1Ph8Pnw+H8FgkNOnT1NKxyiW8mSW5xk6fYLegf3Yna4bXkUCVICqSsVikYbeg5iKVshnGHAVqaurw+v1bv9iRVGUi6x1w/V6vWQyGZaWljAYDDidTgqFAtFolFgsxtzcHPPz89jtdpxOJ3a7ncOHD+NyDZFOp8lmsxQKScbOvEZeanT2bt3C43pRAaoKhcNhfjRT7vXil2HedMdtBAIBtb2nKMobYjabaW5uJhgMEovFKsHK5/ORyWSIxWKsrKwQj8cr/aqEELhcLoLBIKVSiUKhQGg5yti51ymhEXBuvPj3elEBqgqdHxriZLycPdNYXKTOZd+RUveKotQmIQRut7vSJTccDrO8vIzZbKahoYFkMlkJVFJKoBzcOjo68Hq9jI2NYT11mlg6i0HTbli/KBWgqkwmk+H5k1MkpR1jKUOnNUdDQwP19fU7PTRFUWqQXq+nvr6e+vp6MpkM4XCYcDiMzWYjEAiQTCYrHXXXzoF3dHQQDAZZWFggk8kQCARuzNhuyFGVa/blL3+Zr53MgN2OPzdPoMlGX1+fujhXUZQbzmw209TURFNTE6lUikgkQiQSIZvNotfr13VRMBqNlb5VN4oKUFWkUCjwh//vX1B81/+EUglH+Cx1ew/Q2XnjS4ooiqJczGq1YrVaCQaD5HI5dDodOp3upo5BddStIk899RRLji6ETk9u9hz7WuoqXTYVRVF2itFovOnBCVSAqhrFYpH/9j9+D+fh9wDgWhmlpd7LwYMHd3hkiqIoO0MFqCrxuc99jkVbB3qnn0I0xMN9Xtrb29ddua0oinIrUQGqCkSjUf7H7/4+rns+AIBj6RQdjT4OHz6sKkcoinLLUgGqCvzGb/wGqcaD6N0NFFcWeVuvm/a2VoLB4E4PTVEUZceoALXDvv3tb/OlJ/8B9wO/CEBjcohWv5MHH3xwh0emKIqys1SA2kFTU1N88IMfxPOWj6KzOJDLE7yt183+fXvx+Xw7PTxFUZQdpQLUDvqff/AHiMMfwL7/IWSpyF2OMM0+J/fdd99OD01RFGXHqQt1d8i5c+eYa3oQp9eNLBVpi5/mjm4bDz30EBaLZfsDKIqi1DgVoHbA5OQkf/qN1ziVcaNR4oAYY3+rgTsPHaC7u3unh6coilIVVIC6iY4dO0YoFOI7g1GeD5erQxwyLtBrzHGov1tt7SmKolxEnYO6CRKJBL/zO7/DnXfeyUf/5Es8M+cABP36Rbr0YQ72tPLII4+ogrCKoigXUSuoGygcDvPZz36WT3ziEyxHV/C89VfRH3gEgH5diAOmZQ73t/PII4+oZoSKoiiXUAHqOpJSMjExwfPPP88zzzzDv/zLv5DP5zEF+2n8pT/E4A0ii3n6S5Pc7ZXc3t/Hgw8+iMvl2umhK4qiVB0VoFalUik+8pGPYDabsVqtOBwOXC4XTqcTp9OJw+HAZDJRKpWQUvLud78bKAelfD7PF7/4RX7zN3+TeDxePqBOj63vPryH3o65eS8AxnyCuyzz3N3qYH9/N3feeafK2FMURdmCClCrTp48yVe/+tUreq5Op+Oll15ad182myUejyP0Jhy3vwvnXe9DZy2vjLRSng5dhAdacuxtaWXf3gF6e3vRNHUKUFEUZStVHaCEEI8Cfw7ogM9JKf/4RryPlJLFxcUrfn6pVCKfzyOlpFAocG42ykthM/6f/q+Y2w6gmawA2IpJOo0xjjTp6Gly09LYwL59+9SWnqIoyhWo2gAlhNABnwHeCkwDPxFCfENKeeYGvBd79+7l937v98hms2QyGdLpNKlUilQqRTKZJJlMktKspBv2U9Rb+JPvTZEvlpjJGIkUjUAj1t5GANxahiPuNHc2GvHa/QTq/XR3d9PQ0HC9h64oilKzqjZAAUeAYSnlKIAQ4kngvcB1D1AAHR0d/O7v/u66+4rFIp/53hBPvzpNKp1iOashKbe/OLZy4XkmrUSLpUC3s0SvCxqsgjqnj/b2dpqbm7Hb7TdiyIqiKDVNSCl3egybEkK8H3hUSvnR1c9/AbhLSvlrFz3nY8DHABoaGu548sknr+m9EonElkHk785l+c54ofx+lAiKKB6SaEiMOolPn6dRl8Cg1/D5fNjtdoxGI263e0daJF9uLrtFLcxhTS3MpRbmsEbNpbqszeHo0aObNr6r5hXUtqSUjwOPAxw+fFgePXr0mo7zwgsvsNVr996R5bHhcYZHhmn1e/HamyqPORwOgsEgJpMJTdOqIunhcnPZLWphDmtqYS61MIc1ai7VZbs5VHOAmgFaLvq8efW+m8rvMPHgoT4ePNR3s99aURTllrbzf/Jv7SdAjxCiQwhhBH4O+MYOj0lRFEW5Sap2BSWlLAghfg34DuU087+RUp7e4WEpiqIoN0nVBigAKeWzwLM7PQ5FURTl5qvmLT5FURTlFqYClKIoilKVVIBSFEVRqpIKUIqiKEpVUgFKURRFqUoqQCmKoihVSQUoRVEUpSpVbbHYqyWEWAQmrvHlPmDpOg5nJ9XCXGphDmtqYS61MIc1ai7VZW0OS1LKRy99sGYC1BshhHhFSnl4p8dxPdTCXGphDmtqYS61MIc1ai7VZbs5qC0+RVEUpSqpAKUoiqJUJRWgyh7f6QFcR7Uwl1qYw5pamEstzGGNmkt1uewc1DkoRVEUpSqpFZSiKIpSlVSAUhRFUaqSClCKoihKVVIBSlEURalKKkApiqIoVUkFKEVRFKUqqQClKIqiVCUVoBRFUZSqpAKUoiiKUpVqJkA9+uijErim249//ONrfm213WphLrUwh1qaSy3MQc2lOm8XzWFTNROglpauvS1KNpu9jiPZWbUwl1qYw5pamEstzGGNmkt12W4ONROgFEVRlNqiApSiKIpSlVSAUhRFUaqSClCKoihKVVIBSlEURalKKkApiqIoVUkFKEVRFKUqqQClKIqiVCUVoBRFUZSqpAJUjSoWi8RisZq42lxRlFuTfqcHoFxfUkomJiZYXl5GSokQgv3792MwGHZ6aIqiKFdFraBqTDKZZGlpiUgkwuzsLFJKEonETg9LURTlqqkVVI3J5/MALCwsIGW5SHAul9vJISmKolwTFaBqTLFYXPexVCpVgpaiKMpuorb4akyxWKRQKFQ+z+fzagWlKMqupAJUjSkUCipAKYpSE1SAqjHFYrGyvQflgKW2+BRF2Y3UOagas7bFJ6VkdnYWvV6Px+OppJwriqLsFmoFVWPWVlDxeJzZ+RCjo6NIKddt+ymKouwGKkDVECllJUCl02nywkg8kaRQKKjzUIqi7DoqQNWQtXNNhUKBTCZDQejI5IskEgl1HkpRlF1HBagasraNVywWyWQyFNGRXg1QagWlKMpuo5IkashagEqn0+QLRYoYKRYkKysragWlKMqus6MrKCGEWQjxshDihBDitBDi91fv7xBCvCSEGBZCfFUIYdzJce4Wa0EoHo9TQMNgMJAvCaLRqFpBKYqy6+z0Fl8WeIuU8gBwEHhUCHE38CfAJ6WU3UAE+OUdHOOusbaCisfjFKSG11dPAY14IkEymdzh0SmKolydHQ1Qsmyt1LZh9SaBtwBPr97/ReCndmB4u04qlSIUCrG8vEwBDZvThclsIZUrEolEdnp4iqIoV0WsVbzesQEIoQNeBbqBzwB/Cry4unpCCNEC/LOUct8mr/0Y8DGAhoaGO5588slrGkMikcBut1/bBKrIiRMnePnYSaKJNJrVSXv/AcZHzmMtrHCgr5N77713p4d4RWrl+wG1MZdamMMaNZfqsjaHo0ePblpFYMeTJKSUReCgEMINPAP0X8VrHwceBzh8+LA8evToNY3hhRde4FpfW00ymQwvvj5IfUc7bV3dBIItFPMZ9OkIvb29PPDAA2jaTu/qbq9Wvh9QG3OphTmsUXOpLtvNoWp+W0kpo8D3gXsAtxBiLXg2AzM7NrBdJJvNUixJbE4XXn8DAAajiXxRks1mVTUJRVF2lZ3O4vOvrpwQQliAtwJnKQeq968+7cPA13dmhLtLNpulVCqhabrKSslkMlMoFsnlcipAKYqyq+z0Fl8j8MXV81Aa8JSU8ltCiDPAk0KI/wUcA/56Jwe5W+RyOYpSrgtQBpOJXFGqAKUoyq6zowFKSvk6cGiT+0eBIzd/RLuXlJJ8Pk9JgtBplQBlNJkoFEsqQCmKsutUzTko5Y1ZKxJbKkn0ugt/d5iMZoqyfBFvNpvdwREqiqJcHRWgakQlQAE6w4UApek0dDo9+WL5OilFUZTdQgWoGrHWqLBUYt0KStM09HoD+WK5aKyiKMpuoQJUjShv75UoSYlOfyFA6TQNncFArlBU5Y4URdlVVICqEaVSiWKxiIR1AUrTdOUVVKGktvgURdlVVICqEblcjlKphJQCnU5XuV/TNPQGA/miClCKouwuKkDViGw2SxFAE2jiwrdVpysHqFyxRDqd3rHxKYqiXC0VoGpELpdDlkATGkK7UHdR03To9EbyKkApirLLqABVI/L5PEUpQbC+IKwAg7F8DkrV41MUZTdRAapG5HI5isUSQtOt2+KDcjWJfA1Wk1i7+LhUKl32eblcjmw2y063llEU5ersdC0+5TrJZrOUpEQIsW6LD8BoWl9Nwmw279AoNzc6OsrZs2e5//77cTqdGx5fWlrixRdf5NChQwSDQQCmp6d55ZVXKSFx2Gy85S1vYXJykjNnznDffffhcrkAOHPmDIPnh5BIGhsauOeee27q3BRFuXZqBVUjcrkchWIJTdPQxPoApWkamk5HQVKV10LNzs6yks4yNze35ePxTI7Z2dnKfXNzc0xF0pyeibMcSxCLxSrHmZ+frzxvfn6e4YUEZ2bjhEIL5PP5Gz4fRVGuDxWgakQul6NYkghNh7hki0/TNHR6PcVS9QUoKSXRaJRwIkcsFtv0ObFYjOVLHo/FYqRzRRwuN6lckWg0SiwWI5zIEY1GgfKKcSWeIFeSWO0O0oXilu+hKEr1UQGqRuTzeYqlEkLT0HQbA5QQOgolWXUBKh6Pk84VSGQ3Dx6lUolYLEYsnSeeSJLL5cjlcsQTSfISfA0B0rki09PTpDK5dceJxWKk8wWsNgcOp5t0tqQClKLsIipA1Yh8Pl/Z4hObbPGV6/GVqi5Ara2EcoUS8WSKTCaz7vF4PE4qV64xmM5fWCml80Vsdid2h4tUvkAsFiO1epxEKk0mkyk/L1vC7nBhsztI5QuV1ZWiKNVPJUnUiHIlCVleQV2yxafT6coX6xayVVdNIhqNksoXAUjnNq6iygGssOHxdK6IzeHFaneQK5QolSTpi44TjUZXj13Aa3dgc7qY2eT4iqJULxWgakQul6NQkohLLtQF0Gk6dHoD+Vy66gLUWgCy2u2kV1dCF4tGo6RyJax2O6lclmg0ihCCdL5IncOFpmmYrXbS+SKpXHHdcdZWZzanC4vVRq4kWYknyOfzGAyGHZqxoihXSm3x1YC1brrRkomwMcDJxTwnQlmGw3mklBdWUMViVQUoKWVla66hqZlUbuMW3FoACwRbKiuoaDRKKlvE5iinpNsdLlK5IulcoXycbIGlpaVKgoTFakPTNKw2x6ZBUFGU6qRWUDWgVCpRKBR5kX5yFgMTwxdKGn1wr40WR/kcVLqwc+egSqUSr776Kj6fj46ODs6cOcPMzAypbB6DyYLLU8fM6HlisVhldbOWIJHOF6nzBxgfHiSeKI8/L8FitQFgczhYjMyjN5orxwmFQsSSGRA64vE4JVmihCC0HOX73/8+Xq+X+++/n3g8zokTJyoX+woh6OnpobW1FYB0Os3LL79MPp/HZDJx5MgRTCbTDnwFFeXWowJUDSgWi+QKRXLCAFLS7xGEcxoLqRLT8SJtLgN6w4V6fHL1gt6bKRqNMjk9QyQSobW1leHhEc7OrVCSEn9TC2aLlSKCeDKF3WoBIJFIkMoVMJqs6A0GvL56zs2HEAI8dfWVObi9PoYHT+N0OwhHoyyEo8zMziAl+IOtLC4tlr9OaIzNLDE6u0TANkWpVCISiXB+Zomc1GEym3GYjRiNxkqAmpubY2x2kdBKlia3mbZQqPKYoig3lgpQNaBYLJIulMv4iGKOH3zuT/DtuQdtz//P3ptHyXWe95nPd9faq7qrdwCNxr6QECkTpCRKlijJomgnsmMriqlkopHlHE9OcpzE1kyS42RmPHHmJON4sjmJNEpkWbSTyFbsWFIs2aJskZJsizQpkQQJEMTWaHR3dde+V931mz9uVaEbaADdXQ1wu885dbrWW9+trrrvfb/vfX+/D7DSdEEENvCeH1T72bZ9x7OAbrdL2/YQok0+n6fjuKhGhBP3nsQwA2WLeCJFx7bBD5x/q9UqHdslkQpUIQ4dfwtWN8gOzUgU27Gp1+u0mk0mZw8ihKBeqzM5u59uu43reXhCYXlpGV8GGVJ6cg/lfI7lQon5+XkajQb5qs3ug3eh6hoLF84yndTwPA9VValWq7QsF0WP0LSC4oswQIWE3BnCAPUGwPM8Ok5wAFbx+dCHPsTTL72CBK5UukACTdUQioIrg8zk1QhQjifp2D6XL1+mY3skUplBcAJIJFN0Gqv4VlBq3i+QiGeuyh+ZkSitdovi8lKgzi6h0w2KP6zuVV2+vg+WqqiBP1YvYZS+xLW6FGsFlpaWqNcb5LsqIzNdItEojVabpaUlnn/+ecbGxigUCrQdj8k9+yguXgjXr0JC7iBhgHoD4Pv+IIMyVMHpU6dZvXiBsRMWXd2kZfuoqorSU5NoNBpks9k7OkbLsnC8wJK+UCjQtj2S2fW6e/FkinxpCacbZFD9AomJZBKAdqdNqVQKvK9cj2azSavVwveD/q9INELEjGCaJqqmXjeGPtGoSbdP1mp4AAAgAElEQVRWIJXSUIwInY6KZui02i3q9QZLfp3V1VVs2+all05TsA2O/sAEVy4Fa2T99wsJCbm97OivTAixSwiR3slthtwaz/Po9gKUrkg+/OEPA+BWA026lZYX6PEpgZrEq1HJ1+12cT2fttXraeo12q4lnkzRsf1B0OkXSOhmhOXcMsvLy7RaLcrlMrmVHI1mA9M0GRsbY2ZmhtHRUWLx2E2DEwRZmCcUfMAXOtnxccbHx5mZniYzOoLnSxYXFzl16hSlWgNPQi63guW4tLo2zWbzdn1MISEhaxgqQAkhflEI8VUR8MvAApAXQvzlnRleyGbwPI9u0KOKimRqagpd13ErgfjqYqUbZFBqEKBejQNst9vF8SUdJ2iq7TpXy8T79AslOl2LYrFIq2tj2S65lRWazSbVSpWVlRXa7TaJeILpqWmyY1ki0chgCm8zCCGIxhJ0XbA8n2gsAYCiqiRTaUbHJ5mYmMBxHAqVOs12h2azieP5XJi/wuLi4k5+NCEhITdg2AzqUYJpQgP4WaAvI/2/D7ndkC3gOA5WL0BpSmBaODI6glMJ1L8XqxaKqqCqGq736mRQlmXhuH4gRWS5RKLxYG1oDUII4okUlg9nz57l4uVFHN+n2WyykguCVCKeCDKdkcwtM6WbEY3HsT2frguReHxwv26YeL5E0zTS6TSJzAixRIJyuUy3a1NrdTh16hQLCwu39KEKCQkZjmHXoGaBbwLHCILUjwF/G/jIkNsN2QK2bWPJ4Fwjd+Uyn3nh98mv5lGTQdQqdAO5I1V79eSOgiKJQBGi1OoST41v+Lx4Mskr9SbPPvss1ZaFbehUyhUM02AkM4Ju7IwCRCyepFxawfEl0ejVAKXpOm5LYtvBVJ5UDPbsmUMqCp12g+XFEhkjeNwwDHbt2jXw19I0jSNHjhCNRndkjCEhb3aGDVBdYB/wQcADXur99YbcbsgWsG0bywvmuKx2k5fPvAyA16wgpaQrVRACTddx7DvfrOt5HpZl40vITkyxOH+e/bOj1z/P92hbNqvVDqrZoFhtMr1/jMxIhkQisaNjiiVSLHkQTaRQ1mRyum7Q6q3TtVotbF8SiQdKFHNz+ykuLfDyUomL+QbpdJrvvbJAZmSEeDxOOqpjmibHjh3b0bGGhLxZGTZAPQ08DHwA+FMpZUcIcQS4MPTIQjaNZVlYfpBBSdcGYN/+fVy6eAlptRCRBJYfqEm0nTsvd9Sv4DPMCDN75khnRkmmM+ueY9s2udwyhhkjPjqFSGSYndjL7tm9aNrOF5sapsmBu+5F09ZnZLph4PlQqVSwPIhE44OKPd00eevbf5BKuUi1VsMTCslMBiViYiuCSqsVqqWHhOwgw/7y/xfgnwI68H8KIQzgLPCnww4sZPPYto3tBxlUP0AdOHCASxcv4XUaKJEEbVcEU3yef8cDVLfbxfUlhmGiKMp1wanVarG6uorjOBRLRaSqMrN7NrBtv42CF5Fo7Lr7NN3Alb11PdcnumZ9CiASizEdm2Vs0qFcKuO4DlHNwIyYXF64yKGp6y3rQ0JCtsewRRLvAf6NlPJRKeVZKaUN/CLw3NAjC9k0juNg9QOUYwFBgALwez1FHVegahqu79Ppdu/oAn9//Uk3jOseq9Vq5FZydK0uq/lVXNclnU6Tztze4HQjdMPA9YOSfcuTROPJjZ+n60xMTBCNRKnX6oGZois5d+FimEWFhOwQwwaoXwc+es19nwT+fMjthmwBy7IGfVDStdENnbm9c3zoRz/EgT1TADRdiVAEiqLdcWfdYIpPrlONACiWihSKBTrtQP5ICMHExMSrKsaq6QaeDD7LrntVkHYjhCLIjmVJpVO0W226tk291eWZZ54JVC5CQkKGYlsBSgjxbiHEu3s39/RvCyEeAk4Cmzo9F0LsEUJ8UwhxWgjxkhDi7/bu/0UhxJIQ4rne5Ue2M843C7Zt0+5JHUnXZmRkBDNi8t73vpfZqTEAmgM1CRXP5472Qg0yqF7gkUjyhTzVapVmo0mpVMYwDCYnJl51n6agoTkI4rYvidwkQPVJpVJks6Moms5yoUSxWOTs2bOvOffikJDXG9tdg3oCkL3Lh3uXtZzf5HZc4JNSyu8JIZLAs0KIx3uP/Ssp5a9sc3xvKlzXpetJ0K8GqD4JIzgHadoSNaKi9g6+dzpAuZ5PUjeC4LSap9FsUK/XqdfqRKNRRkdHrzNafLXQDYOWY2NGY5uWNIrGYuzaPcv5F1Y4f/48e/fu5ZVXXgkzqZCQIdhugFogCE57gQZQ7t3vAVcI1qFuiZQyB+R61xtCiDPArm2O6U1LUCQRHEh912Jk5GqPUcIIDvr9DApVwfMl9Xp9R8fg+z6Li4vYtn3dY9VqFceXaKbJ6upqoArRy55i8RijI6OvynrTjdB0g3anSyyztdL29MgosWSGZrPOU089xczMDBcvXuTBBx8MCj5CQkK2hJC9+fZtvViIeeCzUspfGnogQswB3wLuBn4e+DhQB54hyLIqG7zmZ4CfAZicnLzvC1/4wrbeu9ls7nifzZ3kW9/6Fp/LzyIT45S+/mneemSWBx54AICyo/HH5QwZ1eHtkSVWFxdIyDYn7zrIPffcs2NjKBQKvHjmlYFo7bXULElmei+eDLK3drtNNBolmby+CMG2bAzz+oKKO0Vh+QqNSpGxmVlSI1sT1Z0/+yKm2xqcAKSiBm85foS3vOUtr9sG3tf772Mt4b68tujvw0MPPbThKepQZeZSyrlhXt9HCJEAfgf4e1LKuhDiU8AvEWRpvwT8v8AnNnj/zwCfATh58qR86KGHtvX+TzzxBNt97auNlJLV1VVE2Q/mXF2L3bt3c/DgQb7/ve/zjW9+G+XtH6Nh+xw6cQhdQMRtcujQoR3d5xdeeIFiR+LoCeLx6380zXYHM56gWq0SMSMk5hJkMpkNtgTnz5/n4MGDOza2rbJ3dg/1aoXR8cktGztOT05Qr5RwXJeV5SVWL73M1NQUU1NTHD58mHj81mtarzVez7+Pawn35bXFrfZhywFKCOEB/1pK+cne9Y2QUspNbVsIoRMEp/8spfzd3otX1zz+H4H/sdVxvlkI7N5dFCOOD7zvPT/I8ePHgaAYobi0wATgKQZCBB5Jdtfd8TWovjXG3gNzpK/JOgrFAo6oUa/VaTaCM6YbBafXArphkp2Y2tZr48nUQAQ3lRlh+dI5Ll68yOHDhzl//jyHDx9+3WZSISF3mu1U8QmurhiIG1w2tV0RnJ5+FjgjpfyXa+6fXvO0Hwde3MY43xR4nhdcRCDXc2DfLGNjQeVeOpUG6Qe9UEJgyUBNwu55Ke0Ua60xrrXQKJfL1Gq1oCCiXicej5MZee0Gp50kmc5gxpO02x3m5+fpdrucO3duw3W6kJCQ69nOFN8+grWh/vVheCfw14FTQoh+c+8vAB8VQtxLMMU3T6BYEbIBnudhuz5SKAgk6poZqVQ6CBZet4kSSdD1+oKxgZqElHLLU1gb0Ww2adsuhhlDW1MmXqvXKFfKtFqtoFovFl1XYfhGR1U1zGic5MgIrVaLy5cvMzc3x7lz5zhy5MhtkXAKCXkjseVfiJTy8kbXt4OU8jtsXL/11WG2+2YicNMNeqB0sb5AIZUKApTfaUBmipYjiRoGrucHArOWNVDiHoZqtUrHdtf5O7VaLQqFAp1Oh0qlghkxyY5mX1PVencCMxpFKhqpVArHcbhy5Qqzs7OD6b7QmTck5MYMa1i4VwjxmBDilBDi4ppLKBZ7h/A8j7YdBCjtmv+maZpEIuZA7qjU7AZ2FYqCKwPr950gmN7zSSSDUuqu1R1YppdKJQzDYCw79qYLTgBmNIbl+vi+z8zMDJ1OZ+AMfOnSJYapog0JeaMz7BzDfwXevsH94a/uDrHW7r1RKfLYV3+TX/iFX0BVBLphkk5naHaDQFRudjgYV1GUQE2i0WgwPr6xL9OtaDQaWFag+1cul2lbLuPJJK7rspJbwXZsioUiqqoyls3esgm32vX41uUu7957fUb31GKX8xVncDumK/zwwSiOB394sY11TWm7rgreNxclE1H4g/NtatZ6YRNFCN62y2T/iM6fLXYxVMF907dHXsmMxOh6bWq1GhMTE4yPj1MoFLhy5Qqu62KaJrt3774t7x0S8npn2AD1FuAU8I8IGnZD7jC+79PoBgdvz7HotDssz5+n02pw+C33kU6nqbVrAJTaHqpmIJTA+r1Wq23rPWu1Gn/0zSfoOleLODuORyyeIJfLDYITwNjY2Dq/pRvx9LLF6aJDVBfrFjYdT/LE5e41Zzwe+zIabUdyvuxuuL2MabF/ROfFgrPh454vGY+pPHm5iwDeOmWg7MB63LWYkShWvUWx1qL67HPMze4inU7z7W9/h8nJCR566CFM09z2iUJIyBuZYQPUHwIpKWVYBv4q4Xke9U5QFSYdG13XaTdqRDRBu1EnlUriXsgBULYVNFXDMCN0bJdyuXyzTd+QYrFIteVQ7ErMSFAyvWtummK5jGVZlEolXM9lfGx809p6q80g2K00PfatccFYbXlIYDSq8MiBGGdLNs/mbFaaHu1e5vTOPSZ708H75Fse37jUYaXlEdODOc/jYzr3TgUZkuNJvnimxWrLY7kZBDcJtB05UN3YSRRVZXLXXirVEl67RaZaZXx8HF/VWFpapl6vc+XKFSKRyIZNyyEhb2aGDVA/BzwvhFgi0N/rn1JLKeX7h9x2yCZwXTfIoARIz8bQVHRFENUEnXaLVDqNW3sO6Xu0hYEvVMxIlHa3QqVynTjHpqhWq7Qdl917DzExE0xPlctlypUy1WoVq2sxMhoI1m4GX0pWW8FXJ9/ykGvahFZ6gWtXUmM2rSGRQYBqXV17M2qLLC+XqNfqge1I6n5W6g6dRhVIMmlY7E5GBwUJKVNQtyRn1mRXTdsf6BbuNBMzuxmbmuH0s39Gqx1M98WSGdp+icuXL3Po0CEuXrzI0aNHX1Ul95CQ1xrDBqjPAOneZW3vUrgGdYewLIuW7YHZy6BUhYgGpiqoNxtBL5Tv4dby6CPTlCxBJBanWituO4Oq1Wq0bY89qaAootVqDcrJm80miWRiS4oJpbZPrxARx4e6d3VKcKUVZDlTieC+yXjwlc23PHwZiOP+1q99mrVfuewjByExQtmPIRT4b5/7FL/brfOJn/4ER44cYSquUbccXimvDVC39yurKApGNIbl2oE5ow+ZkSyu67K4uMjc3BwXLlzg6NGjYWVfSEiPYQPUu4El4D8BoUvbq4Bt27T7Acq10BSBqSqYmqDTaHLPPfewb98+nm0kOFOBYhemTRPHl9QaTVqt1paCieM41OsNHF8SjcWxbXtQsdcvJ8+kt9aIu9JaL0hSda5+LftTfwsvPcNbxh4gouuMRBQq3SCiefU8154POdUcamIEoaj4joXXKOEBMzMzQBDsXik7+Gte1rRvv4FjLJ7AahXpdDp03aDYY3x8nGazydLSErOzs1y6dGlgNhkS8mZn2AD1BNCQUv5fOzCWkG1g2zadXp2AdG1UBUxNoCkCIV0iEYNUejf5nMWZSrA2M5vS0QwTy5WsrKxs6YBYq9XouB6xntNsbiWH6zoUi0HFXnZ068rkK721oKgm6LiSSi9AXVnKUWhFkFLy7a99iQPjCd5yzz1MJdRBgMpoDmOHDwcuvOk0mq6xrMZZ6W1b61ZJJBMkk8nBGk8/G1vL5VyReyd33dZS+GgsQbNeQEqJ7ft4vkBRFKampsjlcoGmohCsrKwwNbU9qaWQkDcSwwaoAvDXhBB/CLzM+jWoTw657ZBNYNs2lte3e7dRRRCgUqkUZqNMp9XEMCODg/JK00Mf01F1A8vzWF1d3XqAsnwSyVFW86s4tkOxVML3fSYnJjdVsXct/XWmExMGTy9bFLrwuV/7Nc4sVRl93yfwannwXZ599tlBgDpTDKbn3nPfXZz44beu296lqsNvvRSYBd53ZJb3P/JP1skLbRSgvvfiyyx8+3d5+IMPc+TwkdsSqKLxBEUXLA+kDKYzbdtmZmaGbrdLpVIZ6PTFYrFBo3VIyJuVYQPUX+/9/QDwQ73rgmDOJQxQdwDXdbH94GjqOx0MBeKxGJlMhshqhXazQTIzykRcRRFQ6vig6BhGhLZdZ3V1dd32pJT4/o2nu/oFEqrv02q1qFar2JZNNjsaNAHfgpeLNsuN9VN6/QKJu0YVnl4OpvjaTBE/dgIIpuyOHj3KyZP3AzAVvxpg1l7f6L7+dcO4at8R0xVShqBuS9xmCS2RRYkkWCg2+PzXvsveJ57kJ37ixxkfH2ep7g7Wqo6N6Uwltv+TicTiOL6k4/oIoeBLOeglGxsbo9VqsbS0hK7rXLp0iWPHjq0bd0jIm41hA9RjhAURryqWZWHLYFFd2l1MTZBIJEgkEpiqILe6TGl1hcnZOVKaQdVRaXgaZjRGvRHYk/fxPI8nn3ySeuPmQrLVRpt41EXa3qAoIhqL3fQ1AG3H50tn2xt+YeKKy3/61V9BnnwULZklfuTBwWMP/cBR3nvsocHtyYSGpoCmCLKx6wsKorpCNqpQ7vjMJDfO6HanNE4XHU7uHeW5EqjRFMn7PoQxtoeLTz7GL//yL/Pe976XhYl3UrWCEV+qunzi3u2XgvcLJRpWh0QqjdOu4TgOFy5cYHFxEc/zWF3Nc+rUi7zvfe/FNE2OHDmyI3qJISGvR4b1g/r4Do0jZJvYto0rgn+j73QxoxrRaJRMJsN4JkHC7PCvPv05VtuSkYd+CnPmMF2pEDcjOF5QKNHpdIhGo1SrVfLlGufzTcQNKsk8z6NtuaRUnXwhj2Eamy6KWGn2epoiCvdMBpmBLyUvv3yG09/5Ol69hPpnX8ScOkBmZIQTJ04wmc1w98R6N9qIJvjoXQlUhRs21/7E0TgN22ckunGAev++KIezOtNJjedKdRJj01huMD59dBftwjx/9OSfMP6jD6IKiS8FhZaH40l0dfsBIzsxTSmfIzsxTe5iDcuyaDQazNdcfBRsfQS/Web8+fOMj48PtPtCQt6MbMcP6kc38zwp5Ze3PpyQreI4DiMT0xSA97/nXehL30dVVTRN4+TJkywtLRGPRqDVxu9JHrUcSGkqmm7SdXxyuRz79+8flI+PT+3iwNG7rnsvKX0Wl5bodDqsrq6iKApj2c0LwPbXmvaPaLxtdyBpJH3Jqa8906vGA9Ntcv+MwY9+6P03lUfalbr5VzcbU8nGbrweFjcUjo4ZeL1Svq4H9CxLUrsO0D77J+gjQeeEU8kxMb2bYscn3/bYldz+eV12YorsxBSObeH6kk6ng+16SKFy931vp1LMs/zKC1SrVUqlEgDJZPJNpQIfEtJnO7+032Nz03pbXy0P2TK2beP1PupsOolTjqyzcTBNk0wqCYXmQDS2afsYcQNV17E8j3w+z/79+weq5JmJjRfnC4UilmVRLpfxPI/x8fEtFUX0A9TadRyhCP7qR/8qv/Irv8LMrhk++tGPBtVst9Du2ylURRDTBW3n6lc6Ob2Pd//kX+EPXgzW5w5MpognVYodn5XmcAGqj6Yb+AQZqeVKoj0XYk3XMaMxdN2nUCgQjUaZn58nFouFTbwhbzq280tbYH2A2kNQvVcCsr1tDmXDEbJ5XNfF7YnSq8LHQ65r9NR1nZFMCimX8TpBBtW0Jcaogd4rlFhcXAR6DbiOx67E9QGqVq9RbwSmg91Ol0wms+UD5qDp9prChkQywd/5u3+HkcwIQhHXFW7cbuLXBKiaJbnngQe4HKtxqQHHZyewXMmLOIMgOyxCCDTNwJM+lieJJoMApesmri9JJpNomsby8jJzc3NcvHiRI0eOhE28IW8qtvxtl1LOSSn3SSn3Af+eQCx2Sko5Q6AmcYrAJTfkNtO3e3d6GZQqXYQAdU1WY5omo5nUVWddoOn4RKNRzGiMWiuYrrMsi3q9ge1JYon1hQDtTptiMWgwrdfqxOIxEr0D6mZpOz51SyKkx3PffeK6x0dHR+9Y1nQtyTUSR33LkpWWR9kOPsepuLqmTN9l4fICTzzxxNDlQZqu4/pguZJYL4PSDQPPD048du/ejeu65HI52u324EQiJOTNwrCnY38feFFKWQGQUpYJ7Nl/btiBhdwaz/OCANUrMxeuHbjqrglQhmEwOpIB6eO1AyPkpi3RNI14MknX8WhbFufOnaPjeERjiXVn6bZjs7Kygm0F3k66oTOS2fp6SK4elGpbpSW++j9+n+efe36YXd9R4msC1JFsUCo/X3WpWT6aAtmYwmRcRQDFts/nHnuML3/py3zhC1/A97afUemGgetLut7VKT5V0/AROK6LpmlMTk7SbDYplUoUCgWq1VCwJeTNw7ABygIeFUJ8Rgjxvwoh/iPwk0B7+KGF3Arf93EcB0cGAeqz/9+nQcp1a1CKojAxPo6U3qBIoi/rE4vF0DSDVtfh9OnTtG2P+JrpPcd1WF5axnUciqUiiqIwPja2YabTsHxeLtobXk6vdvnKU2cBcCuBsvoLp164PR/KNkj2VMwzEYW96eCzO5UPGnsn4yqKEOhqUNIuAWfsCOauYzy3WOPTn/11up0u1a53ne/UrdB0A8uTSKFimFd9sILA1SuAGRkhmUxSKBTodrvMz8+vazoOCXkjM+xq7z8D/h3w073b/SPX/zPkdkM2ged5VGp1hDqO9D0MTaAIsS6DAshmsyhI/G4TKX3ajoLnS2LRWDDN12ywtLSEjGeZnJgDguKLXG4Z27YoFIp4nndTpYjfPt2k0L7JATodlEq7lWUefPBBPvzhD+/IZ7ATJM3gPG06oTLdK+Dor0mtVZ2YTmgU2zaJt3xgcF9+4RS/+u8/hf6un0JTBX/rZGrTvlK6YVC1JdH4+ilVXTfwZId2u8358+fpdDrkcjnOnj3LkSNHiEajpNNprly5wr333rtpS5OQkNcbw/ZB/QchxEvA/wTsIhCO/S9Sym/uxOBCbo7v+5QbQbIqHQtD11GuWYMCAq+hWIym5+J3W6jRJC1HkjJVRsbGufxKHlc1UepFZu+OU6vXKBVLuK5DoVjEcZ3A2+kGShFd16fQ9lEFHBy9+hwpfS5dmh9Yy/vdFvfvH+PHf/RDryn797vGDSodn3unDEYiCu/aE6HQ9tAVuH/maiHI23eZ+FLi+pBbzVPXRtDH9lI49xSjHuBJyh2fsZuUt68lnkyxuuQzNpJdd7+mG7hOm9XVVRbzZYptF8czqVZrOKfPMDc3x5kzZ3B9mJiYYO/evTv5cYSEvGYYul5WSvkk8GT/thDiHiHEv5BS/m/Dbjvk5nieR6XRDrygXBvDNBBcH6AMwyCZiNGo2fjdBmo0SdP2SZkKe2bnEIqCEILpqRmKpcCCo2886Ps+Y9mxm3o79SvbJuMqP340UEb3PY/PP/YYSy+cGjzv4Ycf5pFHXlvBCcBQBe/bd9WE6l2z19vOQ9Bb9aHDwf7JI3P8yp9WIJbCmDo4eM7ZpTJjhzbnjptIZbjrvrejqut/hpph4FqSSqVC1/VJZqfITkzzyukXqNWWWVxcZGVlBREf3bYrckjI64EdqVkVQuwSQvx9IcQLwPeAn9+J7YbcHM/zqLcDLTfp2oMMqtlsUiwWB5p6hmGQTsRRBGhesH7R9z9SNZXJyWkURaNQKlIqlcjn8xTyBYQQTE5MEolufMDuc7W/KQiM0pf81m/9NqfWBqcPPswjP/zIay44bRchBDOpIFuM7bsqVvvHT7+wpWq7a4MT9Kb4/Ks9Uol0hkgsxsTkNKgmr7zyCs2OxZWVwqCZNyTkjci2A5QQIiGE+LgQ4o8I+p7+GXA3wSHoyZu+OGRHCAJUEHB818Y0DVzXZXl5mUKhwMpKYDphGAaPPPIwP/dzf4977zoMrPc/ikQjjI+PY5omtm0jpSSTyTA5ObkpAdhrA9Tvfen3+PM///PB4+95z3t45IOP7MxOv4boNxwrsatSTDIxzqf+w6co5Avb3m6/ug+g60qisaDCLxqPE0mmqNVqrBYrtC2Hixcv3lTcNyTk9cy2pviEEF8APgREuHpO/ALwFuDLUsq/tDPDC7kZAzddgjUo09DxemXPIyMjVCoVRkdHMU2TmGnQ8lwSZvDvutagz4yYm7Zov5a+4WD/gD01NYWiKPi+z9ve/jZ+7Md+7A2TOa1lIyV1PTPF7OHDjI6Obnu7mq7jSXB9iVA1jF5DdDSexJUKkyMjXFip4PsdiuUaCwsLzM3Nbfv9QkJeq2x3DeqvELQpvgh8HvjvUspLQggfCE/n7hCWZdEamBVamIaB7/vous74+Dj1ep18Ph8Y+SkCx7ZJJIOkeacszruuT7Ub9AuN9ZTF3/GOdzCSGeG5557jIx/5yBsyOMH6Cr9sVKFru7Qw+JEPfxRV277SV19NwnIlkdjVhmjDNEHRMCIaqtGl6zjUOxZnzpxhZmYmtOYIecMx7BrUUeAR4BEhxMwOjCdkC1iWRdcNAo10baKmied5RCIRVFUdeAxJKVEVcB2bhB78y1vO8OcRjie5VAki5ERMXVdeffTYUR796KNvaGme0ahCv8d3KqGyKx1kOgsNSa3rU+v6yG2cB/TVJLobqHpEYnG6rsSIxhkZmyBfrlIul7l06RJyO28WEvIaZrtHj79BYPeuEhgV/jvgCkFWNS2E2Jz/QshQWJaF7fe8oBwL09SRUhKJBEUNfYtzz/PQBFTKZfJXLgFQ6/vEb5Ou6/MfnqnzpVeCMvfx2O1LkzzXZWXxMo5tXfdYvVqhXAjW2qxuh9WlhQ3XZMqFVerVyo6OSwjBRC+LmkpclUP6xqUOn3q2zqeerfPtSoonnnhiSwoQfTWJYP0pvu6xWCKowNQjUXbP7qXr+Fy5coVms3nHNQxDQm432wpQUspfk1K+H9gL/EOCqT7RuzwAhKJhdwDLsnCVoIhBOha6pqEoyiBA6bqOEALHcdB1nSf/+I/4nXDRhC8AACAASURBVN8MZBLLXTmwmtgOi3WPjisD7bp2hdPf/O+3TYanuLpMKbdIfnn910pKyZULZ8nNX8DqdlhZvExx+QqVYn7d82zLIjd/noULL+94lvHAjMmelMqxMYNjYzoTcYWUKUj11vryts5X/sfX+PSnPkWr1dr0diPRGJbHdRlUPJmi6fjEk2lSmRG0SJxCoUi1WmV5eZl2OxRxCXnjMNT8i5RySUr5y1LKe4B7gH8BLAPRm78yZCfodrscOBL4Nr3jgZPM7tkzCFD9Xqh+ZV5fk086XdxGCR9BsbP9ab5+5V6kfIH8V3+VpTPf59/+m3+LYzvD79g1dFpNkoag3Vrv9GtbXRTpEdUEnVYrsLc3BJ1W45rXN4hoAg0fq9PZ0bEdzhr8tRNJEobCSFTlE/em+Fsn0/ytk2lGDR+EQMtMkc8X+OxnP7vpz2fvoWPsP34PurG+cCWZHmHfkRPMzO5DVTXSI6Og6czPz+M4DvPz82FVX8gbhh1bIJBSnpJS/gNglmDaL+Q2Y1kWVk+Hz9QVBIEOn6ZpgyoywzCwbRvTNMmOZsD3cauBHt5Kc/vTfP3XLp19bnDfww8/vKmy9K3SabVImypWu7Xu4NtpNTFVgakJmvUKnmOTNNXrAlmn3SKiCUxV0Gnf3M5+J9md6WWyo4Hx4fyleR77jcc2JTBrmOZ103t9Eqk0ak9vMZZIEEtmaDabLC8v0+l0WF5e3qE9CAl5ddnxFWwZEEod3QFs28bprUFp+HiuM5jeGxkZQQiBaZo4joOmaYxnR5HSHwi2rg7hbbRYC9aD+tt6x4Pv4O3vePswu7Mhjm3huzaGJtAUidW9mgF1Wk3MXuCplopBsFLB7rTXBbJ2szEIZHcyQPXXpPadeNvgvpdefIn/9ju/M7RVR59oLIGHQjQapdVqUalUWF1dHchLhYS8nnnjlli9CbBtG0cG/0JdePieOyg17juw9m8LIZgcy4KUOL2gkttmgLqyWqLrq/iOhdcsM7dvjp/48Z8Yfoc2oNNqYWoiqESUHqVCnlq1RqVcYWV5iXa9QqtWpl6r43RbtNtthOfRXbPeczWQKXSadz5AyXiW977vvYP7v/tn3+Xrj399R94jGo9jeYFqfTweZ3V1Fdu2mZ+fH/TEhYS8XnlVA5QQYo8Q4ptCiNNCiJeEEH+3d/+oEOJxIcS53t+tGxC9Ceh2u9S7gZJEp1lHEBRGqKqKqqpEIpF1rrepVIJIxBhM8eVb3pYLJRzb4b9+5RsAuNUc6XSKj3/840P1/dwI3/MoFfO06xVyuRyNSol8Lkej2aDdadNqNBC+G3hduRZOp0m1WqVZK3Hx4jkKhQLlYrGXgamYWjDdd6fKsSfiKgJJqePz8CN/gfvuu2/w2B987Q946qmnhn6PaCxB15M0m81Bg/Ty8jKWZXHlypWhtx8S8mryamdQLvBJKeVx4O3A3xZCHCeoDPwjKeUh4I96t0PWIKWkVqtRqgYZwTf+4KsIJLquD+wXIpEIhmEghEAIga6IXqGEhdss40m2Vigh4Qtf+AJ1Pwh6XnWFj3/8p0ilrreIHwbbtikVSyzncuRXVlClx+zsLJPZDLFYhN27djOWHWV0JMW+vbMcPXqUXRNjzO2a4cSJE0xkM6iA53qsruRoVkp0Oh2k56Hir5smvJ1oiiCleUig0PF59NFHOXz48ODxL/72Fzl//vxQ76FqGroRwXJ8bNtmamqKTqdDqVSiVCqFBochr2u2rCQhhPjYZp4npXxsE8/JAbne9YYQ4gyBbcePAQ/1nvZ5gp6rf7DVsb6R8TyPer2OogfJpS5kIAaraesClBACXdexbRtNEYyNZVkp1XErObTEKP/lVIPphMZHjsc5X3H4xsUO3g0SDNu2sXe9l7geBKgfODzL3rlbWz3YloVjW8STKXzPo1mvkcwEa2QAruNQr5botrs0Wk0W5+fBtYlGY0RNnT3pSU6cOMHzL7xApwWu1cGzOuyaGOPo0b0kk0mqXZ+RqMrx48fJl2vkuoKp6Slcq4VIJzAMg2azSaPSYv78K4yNTVxnvBiJxYkndzbYjmguNVfji6ebqIqAH3iUiaMdXKtN/anf4Td+4zf4x//oH6MbQQ/bV15poyjwFw9tXCCxEdF4HMuqsrS0xNjYGKlUinw+j23bKIrCiRMn1plYhoS8XtjOt/bX2dwS7y0D1FqEEHPAW4GngMle8AJYASZv8JqfAX4GYHJykieeeGIrbzmg2Wxu+7WvFo7jcOrUKUTm4eAOz2J5aYmJTIJnn312UNG1sLBAoVCg3W5TqtQw9WBNylp+GXP3cSxPMF9zeebly5xuxWjYN5HLETpKJAh+wrPZP2luKgNYvHgWu9Nhz8Fj1KslasVVxqb3kBodA2Bl4RKV3AK+a6MqCqqmUfKagMDQdZoijm3beK4LnTYXX/guAFENlpd14vE49cIySjoQUrU7TaoVl0K+wNLCAkqziJuJYds2jVKO3PIS53rl+JGISV+LqeurzB65e1AhtxNMqIJ5TCxPMIj8RhTNiBLfdy/vm4tyeeEyAG1P4XQxqL48zHk2MC7ekGqpTHN1kQuX5okqPocO7ufixYuUSmXuvvsuTp8+za5du7a9D6/H38eNCPfltUV/Hx566KENH9/OL/Fb7FgNUoAQIgH8DvD3pJR1sUYyR0ophRAbvp+U8jPAZwBOnjwpb7STt+JmH9BrlU6nw1e+8hWEElTtxQyN3bt3kUgkeNe73sWePXvwPI/nnnuOfD5PsVgkXyggM12+99IrWFdeopg7z4Mf/4ecq0q0kWkazS4g+fg9CZLG9bO/nufx+1/9KvnVVf7m3/gEpjFxy3H6nke3skpsfITMxBiG4jMR11CTI8zuP0i9UWfl8gUOzIxy9OB+RkZGOHPmDO985zsHQreTk5NMTk5y3333sby8PFhD0jSNgwcPous699577yB7UBQF4/wyh+46juZ1OTB6jJM/8FYqlQqXLl2i2WxSqVTodDpomsbY2BidTofzhTaze3YTjSdusVdb4Px53nl3ZqBODjBfdfnKuTZzJ+7nB996dXn1bMmGYtBou2vvfuIb/A82wpubI5+boVGrkMLi0KFDxONxnjtzjng8ztGjR5mbmyObzd56Yxvwevx93IhwX15b3GofthygpJQ33to2EELoBMHpP0spf7d396oQYlpKmRNCTAP5G2/hzYnneTQaDZSxIEBpwkcRrFuDUlUVTdMG61CKEJi6xt1334VhmBw+chgvqXGu6nCu7NB2JBFNMBlXERvalit89MM/hmM76MbmvjqddgtDEUR0QafVpNNuMhNTydWqrOZXsTpdFHz27prm/vvvZ2JigvHxcX7oh65vpctmszc8yO7fv39wPZPJENPzlIt5hHRJJ0fYv38/Ukr27t1LLpfDtu2BPJBt25RKJQQ+jm0T3fzs2qYwNYG5RjF3Nh18dmUrqE7sf9Zry/67riS+Se1XVdOY3jOHrhu0VudpNpt4noevx1lZWaHdbnPlyhWSyWQoKBvyumLouQwhRBw4AYyzRrdaSvnlTbxWAJ8Fzkgp/+Wah74M/M/AP+/9/dKw43yjYVkWjVYXMakhfR9NEeiqiqIogwAFwTpU/7aiKKgKPProTw6aQBfrLlxxmK8GjbdTa4OTZEMl8q004wYl3hBRFVYqJVTp49tdCit10mMzxGIRxkbSTExMcNdddxGLxbh06dL2PpQe6XSaqKGSzy0R1VXS6cCvSQjB2NgY2WyWfD5PLpcjHo9TKpVYWFigVq4SH6uRGtm+VcZmSJoKcV3QcuRg7QxgodJlMN14o4XAmxBNJCgtQaVSoW1ZqGYc1+oyPz/P0aNHuXz5MocOHdrJXQkJua0MFaCEEO8BfhsY2+DhzdQdvxP468ApIURfkuAXCALTbwshfprADPGvDDPONyLdbpdm3wvKtdBVFW2DAHVtL1TfdqMfoCbjKoKrc7YDC4lexd5odpSHP/Dwti0zOu0WpqZgauDaNtgtyo0mMdMklYxj210mx0Y4ceIEsVhse29yDZlMhpih4lQ6jKZNMpn12sVCCCYnJ8lmsywuLiKEYN++fVwpvkCxUCCaTJPJZG6rEvtUQuVCxWWl6TESVblw4SIL5QiKGXwGfZX6rRCNxnF8GSiMOBKhQDw9MrBdURSFQqHA+PjmLOlDQl5ths2g/jlB5tQGYkAVSLBJsVgp5Xe48aHv/UOO7Q2NZVk0e5YZ0rXRNBVNU1AUZV3FlmmaA9HYIEAFtht9dFWQjSkU28G2phIqSPjq177K008/DUCxWOTRn/xJFHXrvU6dVoOELhAEvVqaZzE+msTUE3iuQzIWIx0XjIzsXKtbKpUiqqsIEazN9TOoa9E0jbm5OUZHRykUCkyOZ6lKg3a7jW3ZZLPZ2yLdBGsCVMvj2Bh89RtPotz944PHS9UGB7aYySmqihGNYXk2lhdMHUo1mPKtVCokEgkWFxdJpVLr+uNCQl6rDHuK+Bbg94H/SHASPgk8C/yrIbcbcgssy6IzMCvsBaheg+61GRRcVTZXhVgXoLqdLn796hLfRFTwe1/6Pb7x+DcG9ymKgqJsPTj5nofd7aALH8uykJ7N+GiKAwcOMJpKkErEcawuMUO9YRDZDpqmkUolMXWFqK7cctupVIoTJ06QTiWJmAbj4+P40mc1v0q7dXvUwafiwUnEStMDAT/4I+uVOJ74zp9tS3g3GktguYHZYTIziuVKDMPAMAxWVlYGgrIhIa8Hhg1QCjBPkEEBpIELwD8ecrsht8CyLLpOz6ywZ7XRn8q7NoNa+1dTwLGDAPXUU0/xT//vf8rlF58JHsPjc5/+Vb715LcGrz967Cgf+cubd8X1fT8oByeY3lPxaTQaGIbBZDbDaDrBPffcw97d0zTrNaxum5ip73izbyaTIRXRScSim5o6jMfjTE9OkEjEiUaiTE1OYhom5XKZ/OoKnWYT27rej2q79KdSlxouXzzd5JlC8AFLGWSy9bbNY196nG9e6mxJ7SMai2N5Pl1PMjo+RdeTtFotdu3aheu6rK6uht5RIa8bhg1QKwTrT/MEh7DnCdaLdl73JmQdlmVhJHqL/76LaegDmaO1FXhrvaEgUDdwehmUQNButbHzl5C+T/PKyywtXp2dveeee/jpT/z0lmSMli9f5Mz3n6bbadOo12jVK5imyeHDh8kmouzdsydYbzI0dFzSUX1QGr6TpNNpsnFj05lZJBJBVwW6qrF7z24ikSjj4+MoSE4/+11OPf0tzj7/53Tam/d0uhkJQzASUXB9uFBxB4oeIyJQuVCMCEv6Lp5atjhf2XwmFU0kaDsSKVSS6Qy+UGhbFkIIstkstVqNRqPB0tIS3W53R/YlJOR2Mewa1O8SmBb+N+AXgene/Z8acrsht8CyLI6/9X7+xIKDe3czY05hGMZ1igFrS81N00Rrdej2DrIPPPAA5UqZxx9/nPLjn8LvBArYmq7x8Ace5n3vf9+WA0e9WiaiQa1cJrd0BR2fw4cPMz09TSaTYd++fSiKwtGjR0mllhFCcPDgwZ35UNawe/duyuUy+/bt29TzDcNAVxVcx0LXdHbv3s1qfhVFSGZGk4hujUbLp14u3dAGYysIIfirdydYaV0tLY9qglI7ytcudBB6BDUamBW+dLnAkezmGm1j8SSpsSkisThCiN6UX5tms8nY2BjNZpOVlRWi0Sjz8/McOXLkBi0FISGvPkMFKCnlJ/vXhRAngB8EVqWU3x12YCE3p9vt0u1bbQgfRcggAG2ggtAvlIhEIij4uLaF57qomsYjjzzC8WPH+dM//VNsx2Z8fJwH7n+A7NjWmzod20K6DjETlpcWaLeaHJoYY2xsjEOHDq3LZg4ePHhbAlMfwzA4efLkpp/fN3pURB3HtjDMCNNT01w+9zIjqTjZXWOceuUiS0tXGJ2cXrfOt12SpkLSXH8C0LSDTCqRyeL2AtTphTzv2RvZVKOtEIJdcwcGt2PxBFatSbPZJJvNMj09zfz8PCsrK2iaxsrKCtPT0zfZYkjIq8dQ8ypCiItCiH8EIKUsSym/BNwthAj7lm4zlmVh+cHUm4aLAjcNUKZpDvyhrjXum907y6MffZSPfexj/PAP//C2ghME1hi6IqlXSrQaDWKmSTJmcs899+xoEcTtwjRNNFUM1uggmBLdPTXBgQMHmJkcp9NqUcgXsNc8ZyeJaEE2k5meRai9/rXUJL/2uc9tr2giHhRN9P2hIpEIY2NjNBoNarUauVwutIkPec0y7MT/HHDt0eytwF8ccrsht8C27UEGpeMhRHCAVTcoBV9bam4YBqYK7dvgi9RuNujUqyi+SyxiEI/oHD50aEdLyG8nwTqUMiiGsK0u0nOYnhznbW97G6lYhEQsgi898vk8VnfniiYGY+gFqOqaTStmjF37j2yrFy0aT2D17Dj6ZLNZotEoq6urg6q+O2VBEhKyFbYVoIQQfyyE+OPezb/cvy2EeAL4GBDaed5mWq0Wq5U6AI1yAVURgyKJa+kXShiGEUz16crOO8tKWMktge8wNpYlHjGZnsgOJVJ6p4lEIuiKgm0HxQPNep1orwQ+k8lw7NgxEhGDVDyOrukUigW6nZ0tNOgHqGuFJO57zwe3Na1omBE8odCxrEHWJ4Rgenoa3/fJ5XKhTXzIa5btZlAP9S4S2L3m9ruBOPCVoUcWclNKpRL5ShBkTj//fbReg+5GU3zRaBS4OgVoqoEu3k5SrVapV6uMj6SYnJxkenyUsUzqdTG118c0TXTt6hRfq1lfJ5U0NTXFnpkpXMdmfHwMXdcplop0OjvnLxXRNv5JrmzT/bhfKNF1WWcDb5omExMTNJuByePKygqt1s5UKIaE7BTbLZL4KYIJh18DHgf+S+9+D7hCoHgechupVqsoZnDg1HDQ1CBA3SiD6q8/aZqGrrCuUGJYGo0G1UqZiKExNpLh+PHjvDy/RMxQr5MZei0TiUTQlKtTfK1GnbR5dR8ymQypmIlQYpimyfj4OMVikVKpNJg2GxZTZZ30VNpUqFk+50oOWs9/YySicCgtNq1yEY3HsetXCyX6jI6O0mg0WF1dJR6Pc+nSJY4fP35bJZ5CQrbCto5OUsrPA/RsMF6SUj6zo6MKuSm+7wdmheYMAJp00bUbByghRM/7KLKmUMKj026SSG09gNiWxYXTL+C6NrblUK/Xeo24aWZmZjh69ChXlleI6NqON+DeTiKRCLomWFpeJJ9bREqYnkkOMqh0Ok3M1LiSK1LO5ymVSziOQ71e55zrkEymMM2rauETM3u2PAYhBKYmBlp8h0Y1nsnZFDs+3164Op2YOveH/M2PfWRTwSQWT1IurXD58mUWFhbWPea6LisrK7z44oscPXqUdDrNnj1bH3dIyO1gO466/wfwXSnl1wl6oPYKIX7k2udJKf/JDowvZAP6VhsiEigkqNJFU4J+pxsdsKLR6EBNIiiUaNNubi9ANWoVoorDSFyy2iwzmtKZmBghHo9z8uRJ0uk0M5PjJBKJDQPma5WRkRGmRlKkI1czk2w2O1CiSCaTTI2NDqbh3F1JlpaWsDIqxWIJ264wls4SiURwfMgV82jxrX++kTUBajqp8ZdSGvmWh+/5fPfcMiTGWazZPP7443zwgx+85fbiqTQ5dM6XNy7q6IoUjUoT49I8hw8vkclkSCaTWx53SMhOs50M6heBfw18vXf92vKf/gxFGKBuE7Zt02y1UVLBlJImHTRV3HQRPRqNouv6QEw2om2/UKLTaqAjiUaj3H//Sfbt20csFuPYsWODMbzrXe/a1rZfTUzT5AMf+MC6ira1TayKovDud7973eOO43D27Fna7TYLCwtYlsXu3bt5/vnncesWwnS3PI5+oQQEihN70zpHe34Bly+2yDGONjLN1//wq+yd3cvRY0dvuj1dNzj21vtvWqn3ve9+h0IlmK6cn5/n+PHjr6uTi5A3JtuZbP488HTv+mMbXD7PFu3eQ7ZGt9ul1bFQjCBA6fhoqoJhGDfNoGBNoYQm6GxzUbzTatFuVDFNkz179mCaJocOHdqR5tXXAn3l9xspLKx93DAMjhw5QjweZ3Z2FtM0WVpaGhSjWN2t9xitC1D6+v/nu3/gGAD6yDRSwm/+59+kUq5seb+uvUxOTuEiuHTpEpZlsbi4KUOCkJDbynYcdX9qzfWP7+hoQjZFu90eKA74dhdDU9DUQAmheYP+pn6AikQidDodTE3BtbtbLpTwfZ9yqUDG77Jv3z6i0Shzc3M7UiDwesUwDA4dOsTZs2eZnZ3l8uXLNJtNVOljbaPCL6KuzaDWB6jplAF00DKTIBTarTa//vlf52d/9mc3rODcLPFUmkY8TblcDtyFhRiU14eEvFoMXa4jhPgLQojfEkL8iRDiC0KIv7ATAwu5MZZl0fJ66tdOJ7DY0NRBv9NGGIaBqqqDdahIJHKdosRmqJaK2J0WE+PjA+mc10sj7u2kL4gbiUSYnZ0lkUjQrJXpNLfeEtjPoHQlsIu/9rGRiIJQNPTMJABXFq7wpS8NJ94SjSUQelDgUSwW6Xa7XL58Gdfd+hRlSMhOMazU0c8T2LN/BHgHgZL5l4UQn7zpC0OGotvt0ukFKN/uousauqbd0oQuGo2uUzc3VbY0zec4DrnlJeKmxp49e4JiiJmZ7e/IG4xIJDIIUocPH8YQklKpgO9trYepH6CuzZ769K067nvokcF9f/KdP+HZZ57d5sjBjEZxpUIkGkVKyfLyMo7jcPny5W1vMyRkWIbNoH6eoPfpXwN/E/g3vds/N+R2Q26CZVl0ZTCd49sdzJ5a+a2meJLJZCCIqihB6bmm0G5t7gzf931KxRKW1WFydIRsNrtppfA3E9FolIMHD5LNZtk9M4Xn2KzkVvB9f9PbuBqgNl4D6wcodXw/Rx/8IYzJAxiTB/jdbz7NwlJuW+MOGnrjuFIlmUxiWRb5fJ5qtUqtVtvWNkNChmXYLk0T+K9Syp/v3yGEyAK3rn0N2Tbdbpf0+DRFwFQk0WhkUwEqlUqRy+WIx+NYloWpCvLVCudPP3/L96xV69i2RSRiEI9EOHHiRFjldQMSiQQHDhzg+9//Pul4lEuvvMTS5fNk0hnEmlPCVCbLxMzu614f1YPAlLxRBhUPPvdzZQdmHiQz8+DgsS9+f55P7tqeOnkknqDbaLG8vEyj0eDs2bOcOHGCev3/Z+/NoyS5qzvfzy8it8h9qcra9+pVjbaWkGUBagED2Axg5tksxtjYYIHxoufxvMHnvecznuPj8Tz7DDaP7ViAQLIB+SHZmAHZGARCAwIJLbTULfVS3bVmLZmV+xIRmRn5e39EVXW3eqvKqlZ3V8fnnDyVGZFx8xdVUXnj/n73fm+Jer2+1hDTweGVYrMR1F8DNwohYgBCiDhwI/CXmx2Yw/kxTZORnXsBGBnopTMRP6+S+ekEAgEURcHv96OqKh6XoC+okFCMCz7c1TRePUN/UDAc9TIy2Ed3d/crcapXLZFIhOuuu46ED0ZibjQjiyiliAudhGIQVwzSqelzTv/tiLt5VdLDLb3nnrIdiLi4qdvDSNTFSNRFr9aisWxPxbk7h9secygcJa+3OJ6usFCTzBbrPPvss9TrdadNvMNlYbMR1G8DA8CiECIDdGI7vd8VQvzuynuklHLsfAYcNo5pmhintdq4kA7f6QghCAaD6LqOoijs2bPnoutWlUqF+fl5wnt20d3dTWdnJzt27NhUxti1wm233cbx48fp7+8nn8+TyWSIRqMkk0mOHj1KplpG16sEgmeqbfjdCm/dcf429YoQvHnszP2ppME/zEGtafeUOt/61YUIx+KM7bsJy7ITI4wXX0CvLJJOpymXy6TTaZLJ5IbtOji0y2a/ZYZWfirA6avlw6c9d3T8t5gzmhXKJqoq1uWgwJ7mK5VKuFwuTNOks7Pzgp9TKpXo6OhgcHCQSCTCjh07nA6s60QIwcDAAGNjY6TTaXw+H7lcjkajYa8HLpcxqmc7qHbo6++lO19hptRksWIxHm9vcsSnnXJ8kWgMq1Ulm81SLpeZm5sjFApd0yUFDq8sm3VQd23JKBw2hGmamNL+ArJljtYXQQFr2nihUIhCoUCz2TzncY1Gg7m5OVwuF/39/fh8PkZHRx3n1AYDAwM0GnazwUajQTqdRlEUvOrWtj3pDqqnOSg3L774IgMDA23LFvn8QRp6kFphmYWFhbU28bt373auA4dXhM22fP/B6a+FEH1ARUrppP1cQgqFAovZOsQ7WJ6fYyi2/ghK0zT8fj+xWIx8Pk8+nz8rimo2m8zMzGBZFkNDQ2tKEc60XvsMDw/TaDTo6+tjenqa5eVlsOrUtrDtyWp230KlwSPf+h7f/e53Gd8xzkc+/GGUNhJa/IEg6Yxd49VqtdbaxM/Pz19Vfb4crl42Wwf1p0KIR4TNXwIzQFoI8ctbMzyHc5HJZCgZ9jrB1MRLuFV13Q4K7L5GXq+XUChELpfDOm2hfrX2pdFoMDAwgKZpjI6OXrAI2OHiKIrC2NgYmqbR399PJBKhXMhSq5Q3lIJ+IVYdVKrY4NFHvwvAxPEJ/vVfv92WPS0QwGxKms0myWTSbquy0jvqfIolDg5byWaz+N6DHYV5gN8HFle2/8km7TpcgGKxiOK11wpcLWutF9R6HVQ0GsXr9ZJIJGi1WszNzdFoNCgUCkxOTtJsNhkYGMDv9zMyMnJVtcy4knG5XIyPj+Pz+RgaGsKvadRKBWqV0pbYj/kUPCoYLYXXveUdCLcP4fLw3e9+l0OHDm3YntvjRbjcmA0LTdMIBAIsLi5Sr9eZnJw848bGweFSsFkHNQicAPZgO6l3YDcvdLL2LhGrrTYUz4qDWmlW6PV6170usNryW9M0ent70XWdiYkJFhYWcLvdDA8PEwwGGRkZcWSMthiv17vmpEZGRnBhcfTwC6QmT5CaPklqgtGUcQAAIABJREFU+iSLc9M0V9asNoIQgq6VGqmXAjfQ+Y7/TOcv/THajtv4yle+QnY5u2Gb/kCQhhScPHly7TPm5+cxTZPZ2dkN23Nw2AibdVAGMIJdmGsBh1d+OrdWl4h6vU65WkPxBQFQW3VcqrLhzKpEIkFfXx+RSIShoSF6enoYGBhgZGSEQCDAzp07icfjl+IUrnkCgQAjIyMkk0n6O6OIyjLF1DFEeQlRXqKWSbG8NN+W7Ru7vPjdAq8qWBVC9/btxdANvnT/l9aSNdaLPxiiaqkcmVli4uQkkUgEXdfXOgnn8+tTUndwaIfNrno/BbwJ+HfAE1JKXQixCzuqcrgEGIZBxWyiuL3IZh03Fp42HBTYa1Eej4elpSUajQaKopBIJEgmk45KxCUmGo2yf/9+hBBkMhlyuRyxWAxN05iYTlFqQ2QW4Lqkh+uStuKD3mjxiadKK6KygtRcin/6x3/iXe9+17rtdXT1EukZwnT50Ju2MnskEiGbzRIMBpmeniYQCDgqEw6XhM06qA8Df75i50+FEB7gKPDEZgfmcG50XadYt6fyLL2M26XicatrXV83SjwedyKly0RPTw+vetWryGQyLCwsUCgUCIVCdsv3Snu9uk5HcyuEvYISHtRwB1Ypw09+8hOGh4d59W2vXpcNRVUJxxKE/T6MzAyVSoWRkRFqtRqpVIqRkRGmpqac+jiHS8KmpviklNNSyl+TUr4HmJBS1qWUH5JS3rdF43N4GaZpUmmtCMUaFTxuF16Px8myu0oZGBggHA7T3d2N3++nUCggZAtpNamb527RvhG6g/a1Mn7Tz61te/jhh0mlUhuyowUCmJatLKKqKr29vTQaDZaWliiXyywtLW16rA4OL2ezaeZCCPExIcQcYAoh5lZeO7dSlwhd19Gx5Ylaegmfx43P53NqlK5ShBCMjo7i9/vp7+/H7XZTq9Vwi9aWFPGuCssOX3frmn6ioigbVij3B0KYlqRSqSClxO/309HRQbFYpFQqMT8/T7XNDs0ODudjs0kS9wB/gS1zJFZ+/jfgf1+vASHEfUKItBDi0Gnb/lQIkRJC/Gzl8YubHOe2wTRNTGFHS5ZeQvM6DupqR1VVxsfH8Xq9a+n91VKeannz6eertVEZXfKB3/wAQ8ND/OF//EP27t27sTG6XLg8XoyGteaIOjo60DSNhYUFJ/Xc4ZKwWQd1N5ABfgnYvfJzGVtEdr18CXjLObb/tZTyxpXHI5sc57bBMAwaLnu9qaWX8fu862q14XBl4/F41pzU2NgYLmmxOJ/atJLlqoNaqlp0dHZyzx/c07bgq+YPrkVRYEd/qw0rU6kUhmE4qecOW8pmv9UGsftBfWPl9TEhxNuA967XgJTycSHE8CbHcc1gmibhrgEqQDzgIRK0v9zcbvflHprDJgkEAgwPD6PrOp3xCEeXCkyfnKB3cBC324Np6OjVCiAIRaKo67gp8a8mSpiSv32mjHKOyfebuj28uu/ia5haIIiRybG8vIyinLq3VVV1zUFlMhkqlQrxeJxkMuncODlsCiFl+7doQoiXgBC2osQR7Cjqq0BVSrl7A3aGgW9KKfetvP5T4ANACXga+CMp5VkFF0KIu7GjOLq6uvY/+OCDbZ1HpVIhGAy2dewrzVNPPcXfLXVTdicYKT5HrDTBzXvG2b9/P5qmXVXncj62wzms0s65LC8v8/jjjzOX16nqBsGOHoZ37mX62GE8LRNLCryRBMm+oYsbA54rBTihX6AMoa7zC7E0gWDg3LvNOh6vh1qlxPL0BEHX2dN45XKFer1OOBLG4/HQ1ZFgx8jgFdd1+Vq/tq40Vs/hwIED58xb2OztzQPYaeY/eNn2zUodfRb4M+wJjj8D/gfwWy9/k5TyXuBegFtuuUUeOHCgrQ977LHHaPfYV5pisUgrZ39BJMMafZEB9u/fz+tf/3q8Xu9VdS7nYzucwyrtnsvAwAATExMcOvwik0WLzkSCZlcno3F7HWjBsNet1sOYlBTNFq2X3YsePnyY/1XuRPFo/ODJZ/i9D/3GOUVlJyYmGB8fR0rJUkeCummc9Z5kq0UulwPsOqlWU2d0dJQ777xzw+d+KXGurSuLi53DZh3UXwEx4HeAAFADPrOyvW2klGs5q0KIzwHf3Iy97YSuGxjYd8Oupo7bJ5w1qG3IrbfeSiQSIZ/Pk6qkmJk8gQ+LaDRqt0kpmVjN5rqm+YQQRH1nO57usEZzdgFPcpT5UoNvfesR3vb2t13QTnf/+aO23nqddDqNx+1haeY4k5OTvPa1rz1jOtDBYSNstg6qKaX8z1LKENAlpQyuvN64kNhpCCF6Tnv5TmDjSpfblJJex0JFpYVsGLhdCj6fz1F+2Gasqp8nEgk641FK+Sy1UgG/308wGMSrCmrV9tQmVtmxcweDMftmxx3r4fvf/z4vPP9C2/Y8Hg+RSIR6vY7VkixlcszNzW1qjA7XNm3ddgsh3n6e7WvPT0ucuJitrwIHgI6Veqr/AhwQQtyIPcU3ha1Y4QAcOjEDxJFmlRMTx9l9+z6nw+k2xe12c91113FkaoGy34eq65TLZQKBAF41h16tEopsTsz3tuvG+OdjNVxR+57wq1/9Ct09//GCnZYvRCgUwjRNGpakbNR58cUX6enpcZJ4HNqi3Xmhr3PhBFi5XttSynNl/H2hnUFtd6SUzGXLEAGjlGVxYR6fd7+jIrGN6erqor8nSaaWoqsjihCCWq2Gz7013Xh7Qnbk7UnYDQgNw+SL932Re+65B6/P25bNeCzGYiBAenmOXC7H5OSkI4Xk0BbtTvHNnPaw817P3OYUQ1wCms0mxRX1m5Zexut24fP5nLvTbUw0GqUjGiIRjZCIxejp6cGyLMxqeSXlfHNEvAo+l0B4/LhDdjS2uLjIV776lbZrsBRVpbe3H71hMTMzQ7lcZmFhYdNjdbj2aCuCklIOrz4XQvwN8PtSyisrn3QbYpomFcu+47X0Mr4VB+UkSGxfvF4vwYCf/mSc7rCXzs5OTNPkyJGj1EwVvVpBUVWEUPB4Nx7xrPaQmi42GX3LB1mYthsRTANf+MFRfu01O9sadyQWx60FyWSW17L7gsGg0/zSYUNsxTfbJmvdHdaLruvo0o6WWnoZn8dxUNcC0WiURLnK7t12aWFvby+xWJTsUpGJF57B7XZhtSA5MExnd9+G7Q+EXUwXm+SlH9/gq9a2Z4AfHltiqI1OGqrLRTgaR5RNpqam8Pv9TE5OsnfvXifid1g3Tv7nVYSu65isOKh6FZ/Xg6ZpjoPa5oyOjtLX08Xg4CBjY2NomsaNN97IYEwjJmqMxn10BVTKhfaaB97W5+Wdu/28bYeft4778E3/CH3yWQAMd/sRjz8YJBCJYZomqVSKer3OyZMn2Yw4gMO1RbtZfP942stXnWOblFL+b5sZmMPZGIZBQ1lxUGYNf8TR4bsWSCQS3H777Wuvx8fHaTabxGIxpqamEEJgpBbaXpNyq4JdiVNh0sjb7+SFqTQ/KMJipcmuUHvj1vxB9EqWQCBAvV5nYWEBRVGYn5+nr2/jkZ7DtUe732y/dJFtzi3SJUDXdSzFiwCkWSOoRR0HdQ3i8/kYHR1lYmKC/v5+ZmdnqVXLCOmnbhp4vJvL6gwGg9yyJ8DjPymyXGthtammowUCFCywLIve3l4ymcxaY81AIEA0Gt3UOB22P+1+s/3XLR2Fw7owTZOWy4cKWGaNYKDHEYq9RgmHwwwMDDAzM0MymWRiYoKGXqVWqWzaQYEdVXX4FTK1FoWmi2azybFjxzbUpkPzBzFW1M/j8Ti6rrO0tISmaUxNTbFnzx68bSR2OFw7tJvF5zioy4BhGOC2i3KlWSUU0PB6vU4EdY3S2dlpXxNAd3c3c4cnyGUzRBMdW2K/K6iSqbVYqlh85jOfYWpyit/64G+xb9++dR2vuly4PT7MRpNarUZPTw9TU1PMzc0xPDzMiRMn2L17tyOF5HBenCvjKqJarSK8K72gjCrhQAC32+04qGuY/v5+IpEIw8PDhPweMkuLmMbmW8UDdAfs6+r4YpGpySkAvvLlL2+ovbvdKt6OolwuF319fTSbTebn59F1nZmZmS0Zq8P2xHFQVxGVmo7i0UBKxkf60TSf46CucYQQjIyMkEwm6e6I0zAMlrPLNBqbksMETjU7dCUGSVx/AG381ciOMe77wn3UqrV12fAHQhjNFuWyrRuoaRpdXV1Uq1UymQzZbJZMJrPpsTpsT5xvtquIat1us+EWLW64bq9TA+UA2A0D9+3bx5NPPkkk3ODE4YOcfNGunzp9+qyzp59kb/+67XYFVBQBunSh7nwdq8l8+cf/ji/d/yU+8uEPn7M9x+msJkosLi6e4Yiy2SyLi4vceuutfP/736e3t5c77rjDkUNyOAMngrqKWC7pALiwUIRE0zQnQcIBsJXEb7nlFsYSGvt6QyRdBkEzx2AQhsKC3oAgm96Y3JBbFbxjl59xTWd/j4eIYk8duhP9TByf4KGHH75ovq4/EMJS3JzI1TmW0dceBalRLBaZmZlhcmqKnz797FqU5eCwyqZuv4UQNwE3AN3Yheffk1JObsXAHM6k1WqRLdWABB5FogocB+VwBrfeeivDw8OcPHmSUqlEKpUiHA7T29vLk08+Sats0mw0cG3gmtmV8KDmq4yP9tAbdPE/j9dwryif/+THP6Gnu4fXvu615z1eUVV23XALLevMLrwvHfwpwVDY1ulLZ0l2dnLkyBFuvfVWJ4pyWKPdQt0Y8PfAW162SwohPi2lvGfTI3M4g0KhQGllWcGFhSrA7/c7DsrhDDo7O2m1WszNzdFqtchkMhQKBbuHVLGOXqu03aJjdU3K3zVEcWXb1//563R2drJ7z+7zHieEOKuxouYP0sBex6rVLZZzefL5PLOzswwODrY1PoftR7tTfH8D/AJQAFZXY38ANIHfE0L80RaMzeE0stkszxw+bj9fTDE3M+2sQTmck66uLjo7O+no6CAajbK8vIyUEq8qNqWAHtcUPApYLo3BsV0AyJbkgQfuZ2lx/Zl9AP5AELPZwjRNvIEQFd1cW6dykiYcVmnXQf174DtAB3ALdruNLwA3AkXg7i0ZncMauVyOktkCoFbMUTd1vF6vE0E5nJOBgQEikQjd3d0EAgFqtRqyaaJXq23bFEKQXImi3vDO96wpQXR1daP5N9Y0UwsEMZv2ApbL68fj87G0tESlUmF2dpZKZfOtRByuftp1UCqwLG3Vx9Vbpz1SyiPAN4ChrRicwymy2SyGtKOlllklFPA7KhIO50UIwejoKIFAgL6+PmKxGLVinnKxsCm7PUH7Giy1vHzwQx/k1be9mo9+9KMbbqOhBYKYlkRKSd1qEQiGURSFVCqFYRicOHGCer2+qbE6XP2066CeA94thHgU+DF2Ls9qcoQbcNJxthApJYVCgYZiC3q2TN1RkXC4KIqiMD4+jqZp7NixA5/HRW45jakbbdvsDtgR1HSxCaEuXvuLv0zaEKRKTVKlJumqtS61co/XhyUUag2JBFoIYrEYQgjm5uYwTZOJiQlarVbbY3W4+mn32+3/BP4NuGvl9THgy0IIN7AfeGzzQ3NYpVKpUK4ZWKoXFTuCioZCuN1uJ4JyuCBut5vx8XGOHj3K0NAQ84cnOfj0j0l0dKAoCp09fQTD6xdtXU2UmCk2+bsXzj0N99pkgzt2dF7QjhACzR+kZJTR/EGaZg3LsgiHwzzzzDOcPHmS3bt34/V6CYfDpNNp9uzZ48giXWO0q8X3YyHE9diJEgbwNSnl6m3Z+dN5HNqiXC5TMxu0VFtYs2VWiUb7cblcjoNyuCiapjE2NsaJEycYyxZIL2dpZKqEonGWUq0NOai4pnBzj4fFinXWPr0hyRstvvPTF1GXvfzc7T93QVuhSIylcpGeniRLs5PU63U769CE5aVlqrVn6enp4bnnnkOoLhKJBN3d3Rs+f4erl7bnh1bqnT6zhWNxOA+GYVAolRErQrGiaRAMBu303YtU8js4AIRCIe68806i0SjFYpH5+XlS8wvoHoGUct21R0II3jTqP+e+f/vxz8gzjCvaw0MP3UskGmHPnj3ntdXZ00c4GseraSysOKhyuUxD9eEOKuRLdtr5zOwsqj9GoVBwHNQ1xpbHy0KILwohmltt91rGNE1yxZKtwwe4WqaTIOGwYTo6OrjuuusYGhpi586dtKwmtVKJutn+mtTp3HHjbmi1UMMdtITK/fffz9zc3HnfL4TA5/cjhMDl8mBJMOoNhOqip7cf4fZx5MgRShWdVDrD/Pz8lozT4erhUk3oOqXgW4hhGBSLFRSv7aA8sumkmDu0RXd3N8lkcm26zKrXSC9uTALpfAQ0Hwm/ghAK7mg3dbPO5z73OfK5i7eid7ndNFtgNiU+fwAtGMIfilCtVlnK5qgaTY4cObLWXsTh2qAtByWEsM73AH59i8d4zWMYBsVKZW2Kz6tYTpGuQ9v09/cTi8UYHBwk7PexnE5T3UR91On0he1MUy1pq0GUS2Xuvfde9NqF1c/dHg9WS2JYEn8whOYPUG8J4vE4DamSLRQpV6ocOnSIZtOZoLlWaDeCEhd5OGwh1WqVctVA8fiQsoWmSieCcmgbIQTDw8P09PTQlYjRshrk83mMTaSfr7Ka5bdr/x2oLvv50tISX7jvPhr187cAOT2C0gJBfP4AjZat5aeFogghWMjkyGQyTvr5NUS7DiqPnWZ+0zke/3NrhuawSq1Wo39sJwCqtBgfG3XWoBw2haIo3HDDDYT9Prwr2aDL2WVMc3PNDlcdVFX4ec973svqPevJE5N86YH7zxKNXcXl9tKUEqMp0fxBFEXBq/kxLZCKysDwKBWjwcmTJ6lWq0xOTq6r3srh6qbdOaIngTEp5cGX7xBC5HGiqC3Dsixquo7iC0IDvIqkt7vLqYFy2DSBQIAd46NM5V+iUStTKBTJLs2TiCdwuU99NeQzi1jDw2cJvp6LTr+KAJb1Ft9hlOQv/8navoXlGf6/hx7iPe9+91nHuT0eKk2JUF14vHY5hRYIUC7V8Pg0Ep1Jqtl5UqkUzzzzDNdffz0ejweXy0UwGCQUCpHP52k2m3R2XrgGy+Hqod0I6kPAr5xn3x8BI23adXgZpmli1Jvoip3a66OBS1VxuVx4PJ7LPDqHq52Ojg72jfbi0nOEhE6rsEj65CHMzCxWfh4rP081M09mMbUue25VsC/pOXO+fyXS8XQMMrr3xnMe5/X50JsSf+iUZJI/GKZUX1mTCoRQ3BqVloufvXiUQ4cOceLECf712//Gc889h5SSp556iiee+PGmo0CHK4d2C3XngXPmfEops0B2M4NyOIVhGJj1BmURACBEDbdLcYp0HbaEffv2EY1G0XWdyclJdF1nfn4eIQR9fX00m03mZ6eoVdavXvbWHX7euuO0WikJn/r+CSreBKHuc9+7BsNRBkZ3EQiF1rbFOpIIIQhFYrjcbvrHd1Mu5FiaOs7MzAyapjGzuIzH46ZcLlOu6pjNFoVCga6urrZ/Jw5XDluSBiaE+BPgA1LKsa2w53AKwzAwG03ylu2ggq0qbpcTQTlsDas6fQCjo6McP36cgYEBpqenAejr68Mt5KbadCDghvFefjRrsli12HOeGbhoouPMw4Qg1pFcex2JJfAHQxSWl2i1ykxNTVE0JLOpRQ4fPozesBwHtc3YqjqoODC8RbYcTsMwDGqGyVzRzoB65vuPoCpibf7dwWGrCAaDjI2NoWkaAwMDNBoNMpkMblVBSGtTBb3dAftaPV0iqVQs8dJLL23IjtvtQXV5CYaj1Go10rkiZb3OM888Q75co1ZvUiwWL27I4arAUV68wjFNk/l8FdUfodUwMXLzeNwuNG1j/XccHNZDOBxmZGQEv99Pf3+/vQZqGHgUNhVFrWb3LVZstfPl5WU++clPct8X7tuwk9ICARpSEI1GsVBZXM5Rq9WYW0hTqpmOg9pGbJWDOgE83s6BQoj7hBBpIcSh07bFhRDfEUIcX/nZXo/qbYBhGEwX7ZqPZmERzevF43Lh959bD83BYbPEYjGGh4cJBoP09fWhKAq1UoFquf0uOkGPIOAWmJakYLT4h3/4B7LZLJZl8cUvfpFjR4+t25YWCGI0JU1UItEo9ZZgeXmZqlEnncmRLxQdxYltwpY4KCnlp6SUd138nefkS8BbXrbtj4FHpZQ7gEdXXl+TmKZJumGvNTXzC3h9XtwuxYmgHC4piUSCgYEBQqEQPT09YJksLqSQrfZqj4QQp6KoqsX7fvV9xBNxAJqNJl/4wheYmJhYly3Nbzc7NJuSWEcngXCUerNFqarj8fmYnE05beO3CZtaxBBCvAt4G5AE0sA3pJRf24gNKeXjQojhl21+B3Bg5fn92P2lPraJoV616LpOcSWDr5GfJ+7z4vV68fl8l3lkDtudZDJJq9UikUiAonJ0qcD05Ani8TiKqhIIhdetgg7QFVA5kW/y6KROwK3S/ZbfRclkaNZNKs9/h89//vN8+O4PMzJqZ/o9t2CyrFu8cUQ743O0QACzKXErdideU6/h8khcukSvNyg1TZ588kk8Ho+TLHGVI9qpxhb21fI14J2rm7C76gL8o5TyfDVS57M3DHxTSrlv5XVBShk97bPyq69fdtzdwN0AXV1d+x988MENnwvYDQGDwWBbx15qnnjiCT63OID0x8l++7P0enTe8nP7uPPOO4nH42e9/0o+l/WyHc5hle1wLjMzMzz99NOkiiaVag2Px4PXHyTRN0Iouv7Z9+W6i8fy5+49Zcy8QOmpf8LtdvO2t7+N7u5uvpGOU5cKb4jnibnPVKCYOnoI2WzQM7KTUn6ZaiGHP5LAqNepZlJ0RzX8HjcHXvcaOjpOZQduh7/HKtvhXFbP4cCBA+e802k3gvoI8B9Wnj8JTANDwG3AfxBC3C2lvLdN22cgpZRCiHN60ZXPuBfglltukQcOHGjrMx577DHaPfZSYlkW6XQambPrnSy9SLK/l71793LXXXcRi5395XClnstG2A7nsMp2OJfHHnuMvXv3cvjwYcrlMgsLC5QbEI5H6R8dX7edcWC3YWE0T/075/QW3zhWw5PoA6DRaPDIt77F3b/zUerSXoFwx3oZ7/aeYaszEcOoVenqG8Q0dJYX5+3npsGRF57HatSJROyZhte+9rVrfdO2w99jle1wLhc7h3bXoN4LtIB/L6W8XUr5Hinl7cDbV/a/r027qywJIXoAVn6mN2nvqsQ0TQq1Brg8SKuJNKsE/X6nSNfhFeeWW27hjW98I7fffjs333wzrbrB4sLCqXmTdRL1qXQHXWuPnQk3igAlECMYsW+4DMPk8/d/Ze2Yc3XvjcQSdPXZiulen0bf8Bgut5tAMMSe628iHO9kKVcgk8lw/PhxrPNoADpc2bTroHZjJzE8cvpGKeU3sZMaNtv2/RvAb6w8/w3gnzdp76rEMAyyup3B1zLKICXhUBC32+0U6Tq84vT19dHV1UV/fz+d8Qjlku0ANuqkTselCDr9KiB45/t/G3/Azk6tc+oGbLG6MefiD/jp7uuloteZnJykUqk4TuoqpV0HFQLOlxd6FAifZ99ZCCG+CvwY2CWEmBNCfBD478C/E0IcB9648vqawzRNssaqg6ogkUTCQSeCcrhs9Pf309fXR3dXF9GQn2Ihz3J2eVNOajW7r+GL8pGPfARN0xjeeapVfKZqYW0wezAaixOKRCmWK5w8edJxUlcp7a5BeYG3CCH+8Rz7rgfWfXsvpXzveXa9oZ2BbScMwyBTqQNg6WXcqgu/puHz+TaUPeXgsJX09/czODjIZKaE6lYxdIPMcoaORAdC2fh12RNUObgES1WLV+/s5w/u+QOmGyG+N71y7UvI1Cy6gxv7uop3dKKU7HVcr9dLX18fqVQKy7LW1qQcrmw2k2Y+tvI4F06jli3AMAx07MXhPaODdETfjMelOjVQDpedXbt28dLJOXKWJBaPkc/lWV5epqNj405qNYJaWFlr6urq4si0fsZ7FisWopKlq3v9aeNaIEiz7kfTNMrlMqlUCl3XOXbsGDt27HCkwq4C2v0L/dctHYXDOTEMg3LD/mePaG5ikShu1XJUJBwuO5FIhN6uDkoLZTweN+FQkFw+T6NRp6u7e0MRSodfRRF2Rt+3T9TYnXBTqdv3uHFNIae3eOrFSY4/8gXe/+vv5/rrr1+XXS0QZDkjEcJuHb+0tMTCwgL5fJ5Dhw6tOSm3242iOKpvVyLttttwHNQrgGEYVC37H0dTJZZl4fE4MkcOl59IJILPreLzKCyePEqpVKJeNymVysydDHPLz7+OxdQ0+Uyana+6CbfHe15bLkXQE1RJlS2eW6xzMt8krtnX/XjMzVO6yVLVwrIsHrj/AX71fb/KzTfffNExan5bEimbL5DNF6hWq7xw6EV0s04inuAHj/+Qnt5ewkE/r3/9653EoyuQthyUEOLtF3uPlPIb7dh2OEW1WqUm7WQITZVIaaEqnqu+OM/h6sflcjE6MoxfWwSSFAp2Rl+p5OL52TzzqRSFdBqv0qJcLBDvvPDU3Nt2+pnMN/nelE7RbGGtCAiMxV08NW/iinaDUGi1Wnz57/8eQzf4+Tt+/oI2PV4vwViC2XJpZUuQRqiH2QosmCUi4TAnC1PcNNZPLpeju7t7878Yhy2l3Sm+r3PhdSa5CdsOK1QqFaoNQAW3rFNvtXALCJ3W1M3B4XJx/fXXnzHdls1m+cY3vsFitUWxkCOfzTCUjNoq6BdxUFGfyk09KoczdebK1toUX0JTifkU8gZ0je5h6cRhpISHHnqIcqXMm9/05pW2vedmaPzMihdPKE5fby/ZXA6Px0OzVmZqLsXi4qLjoK5A2p14nbnIY3ZLRncN02q1qOk6tZY9l//3991LemkRVbVbIjg4XGkkEgl2795NyO9DaTVxC0m5kKVULKyJcBZBAAAgAElEQVTbRlfw1NqVAPzuUyKzd739XQwMDqzt//a/fpuHH36IVqu1oXFqfj8diQ7q9TpVo05Zr3Po0CGq1eqG7DhcetpyUFLKYSnlyIUeWz3Qaw3DMCjpDYTbh7SatMwagYAft6o6U3wOVyxDQ0MM9XbTbNTp7ozjVQVL8yn0mn7xg+GMVPKgR6CcpoKeb6h89KMfZdfuXWvv+dGPnuCB+x+g0WhsaJw+zUdnRycuj4fFZTsD8dixY5RKpYsf7PCK0ZaDEkL8VAjxB0KI5MXf7dAOhmEwX7D/qVtGBUVAJBhA0zQn48jhiiUSiRCPBEjE44Q0L91dSbwuhfnU7LoilO7TIqiAx77OuwOnmh16vV4+9MEPcfP+U0kSzz//PPfeey+6vj4nuIrX56W/fxApVGbmUuTzeSYmJsjlchuy43DpaPebbj/w18CcEOJbQoj3CiGc4pwtxDRNZpftBnEto0wwGMDrcREIBC7zyBwczk8gECCg+dB8XkYH+0gkEiQTUaRlkc/lLxqhJDQF98q3UtBjLy51rURV6RVFCdWl8r5ffR933nnn2nEL8wtUyhvv+Ov2uOnu7aXRUjhy5AiVSoXJyUkWFxc3bMth62k3keFj2IKxNwK/gN1wsCqEeBj4MrZOn1OsuwkMw2CxZEAQLL1CKBDA43IclMOVTyQSIeQrEA0HGdy3l1T2UUyPB59fo1Qs0bJaRKPRcyY3KELQFVCZK1sEVzyVzyVWEiVaPDVvEnDbB4783FswokO8cOgQB+48wIIMs7BkEvYqDEfXLwUWikRpWlUajQazs7N2g0agXq8zMDDgqLZcRtqtg/or4K+EELuAXwPeg60q8esrj3lg4PwWHC6GaZrkdAuCKxFUwI/X7aw/OVz5RCIREgEPkUiEZDLJyGAvTx9PUSrmqFaqWC3JyO7r6OjoQFEUFuemadTr9I+MI4SgJ+RirmwR8Z2a4OkJquSNFj+Yflkrd/cwwZuGeboElE5N8f3WjSGSgfUVC2v+ILllQavV4tixY7zwwgtEIhEikQiBQICenp61aXVFUdi7d6+T8fcKsalUcCnlUeBPgD8RQrwO+Dx225feLRjbNU2lUqFi2f9gLb1MIBDApQgnxdzhiqenp4eTJ0/S29tLLBajIxLijj1DZDJpyv4Wk5kKhVwW2ZLEYzGWF+ZQBJg9ffg0P7f3e3ErcFP3qcLZOwZ8eFSBdZF5mflyk6ze4oWpNGrmKAfuPHDBNHSAQDjMfEswWWiA9FM2LaZnc2gZnWAwgGc2Rywex6W6CHhV/H6/46BeITbb8l0F3oQ93fcOwLm93yLK5TL6iuZuy6gQjPtxKcJJMXe44onFYrz1rW9dmxp74xvfSL1uC78+/vjjFH76PIrXS9NqMjMzhWhZaF4XerWCT/Pjdyu8bujMJe2EX+Ut4xdXUPnpvMmjkzo/PjRB7iffYGF+gV/+lV++oPq/2+1h1423YjVPKZ2XikXK5Qpen4d4PIHH7SaRiHPyxYMUCutPm3fYHO1m8b1OCPFZYBH4JvY0Xwg4DvwX7CjKYROUy2Waqv1P2jLsCEpVhDPF53BVcPq6jaraAseaprFnzx76ujuRrSbJZBLTqFEtZmk1TPTaxpMcXs5qFqAM2G3ef/rTn/KZT3+GUvHCyRmq6sLj9a49OpJJkt1dtCQUiyUkgmKpglFvUNUNarXapsfqcHHazeJ7DLgbSAAZ4JPAbVLK3VLKP5NSTm7R+K5ZyuUyLY+dEGHpFYJ+P27FKdJ1uLqJRCJ0xqNoPi9er5eAz0vA66ZWyrO8tLRp+10r607uaBco9vPp6Wk+/vGPMzM9syFbgUCAzo5OmlaTpaUldEPHqDeYT2cpFoubHqvDxWnXQenAg8BbgT4p5T1Syp9u3bCubVqtFsVSCdUfAUBtGvi8HjSv12m14XBVEwqF8HtcCGnR29OD1WzS29VBNBggl11mObO8YWWI0/GogoSmgFB4wzvetZbcUCqV+NSnP8WRI0c2ZM/r85JMJlEUxe4eLBSWsnkOHjzoND98BWjXQSWllO8DXgI+IIT4YyHEh4QQw1s2smsYwzAwmgLh9qEg+e0PvB9FCAJ+n9NJ1+GqRlEUIpEImltFr1YIB/zEwkF6e7oIBzRKxQLppfSGlSFOZ3War3fH9dx9991r6v/NRpPvPfo9Hn7oIZrN5rrtud1ukl1JvF4vZt1iOV9iYWGBI0eOYBjGxQ04tE27UkdVIcSfYbd9vxf4c+BvgeNCiD/fwvFdk9gp5vZdpKZKFBU8LoVAIODUZDhc9UQiETSPi/RCCs3rYveuXQwNDREL+QloPlqtFul0esPKEKusOqjpYpPYwBi/8dE/pGt0D2q4EzXcyU9eOM4nPv93pJfz67apKAqdHZ0kkp0UKjonTpygUqnw0ksvkc+v347Dxmi33cb7gf9r5WUDyGKvR7mBPxZCHJVSPrA1Q7z20HWdvJ30hKZKaLVwqYqTYu6wLYhGo2huhbnlNPGAh1gsRl9fHyfml5nJLqO63BRLRVKTEwSDQUZ27EYLBMgspvB4fURiiQva7w7YX2tHsg2OZFfaAdz8K5x+VAP48tEmfxCXqOvtACygM9lFOBqnUlvmu9/9Ll1dXRw6dIh4PE4ymVy7gXS5XOzevRufzwfYa8qzs7Ps2rXLaTe/AdpNM/89oLny8z4pZVMI4QJ+E/gM8LuA46DapFQqrdVAaaqk1bKcBAmHbUM8HiesuRlSBD63Sjwex+/3098ZJaB5SS8tEQwICk2DYjrH0XqdnXv3kZ6dAkUlfHP8gjMJvSGVXQk32drZa0SlUomaruMOxjEVF5madYZA7XpIdCap5eFEusCxhQKhUBC/tojXe4J4Io6qqkQ1Dz6fj9277XYfR44cYTaVQtM0RkYcLe310q6Dug74upTy3tUNUsom8DkhxJuw5Y8c2qRUKnHo5Bz09GPpJUxVJ+oSdHZ2Xu6hOThsmmAwyOsP3EmtVsPtdtPR0YEQggOvey2madJsNpmZmSGXy/HMzw4ykS0wMz2FSzawJNRNA6/v/MlCqiJ45+5zS4JNTKTxen08XfFwNGexVDnloGRLItYRTfWPjFNJdGC1WhTyBUzDQPh8aLEoTZcLt89LoXxmpl+hUCBXbTjZfxukXQd1ob+io8G3SXK5HFNLeUI9cOzQz7j+xi78MQ/xePxyD83BYUuIRqO2Ht9pJBKnJuEGBgZYWFhgcnKSkF5Fr5RpFfN4/EH0SuWCDupiDAwMMJ8yOJqzWKxa3AAYusFnPvMZXv+G13PjjTde8HjV5SISt+us4h1JSqUSpVIJs2ERCsdoSYvF5fza2pRpmlSqNQq1ulPku0HazeJ7EfglIcRvCiEUACGEIoT4TeCXVvY7tMnx48dRAzHA7qQrpUVI8571D+3gsF0RQtDb27vSANGLKiSRoIZZq5Cam6W1yRTv01t4ADz88MPMzc3xwP0P8OCDD2Ka5rpthcNhOjs7kVKylF6i3mhSrukcmzhBPp+nWCyiNyyMZotSqeykp2+Adh3Up7Gjr88DNSFECqitvFaBz27N8K5NTpw4geK3nVFAlXhUQTQSxuPxXORIB4ftRV9fH8P9vXg8Hro7Y3QlIpRLBRYXl9rO8oMzW3iUKhUmp05pCzz15FN8/H98nLnZuXXb83q9dHd14fP5KOQLNJotCuUaTz/9NJOTk9TqFrIFeqPpNEXcAO2mmX8J+Cvs6TwP0LPyUwIfl1J+casGeC0yPT2NGlhxUK4WfrdKR0fHZR6Vg8MrTyQSIaR56El20NPVRTQcwO/zorpUsstZ8rk8srXxVYXVFh6WBB0f/+mP/tMZTRAzmQyf+MQn+M53vrPuaE1R7f/TaDQKisrcUobFxUWOHj3K3HwaoQhqdcuZ5tsAbbdmlVJ+DNgJfAT4v1d+7pRS/h9bNLZrEsMwSKVSqJqdsRfxqXhdgmTSaV7scO1h10yp+D0udu7cyc6xMXxuF9FwmFAoRLVaZXFpcU2MdiOs1kstVi18mo9fe9+v8d5ffS9erxcAy7L4l0f+hb/5xCdYWFhYt91gKEj/wCBNqXDixAlmZ2fJV6o0JOSKFSdRYgO0WwflAvzAzOmZfEIIVQgRBmorWX0OG6BcLnPs2DFS6Rxurx/Zsoj5PXhVha6urss9PAeHV5xQKETA5yFoNolGo0gpGVyuUilmaUmBaDWoG3XSS2lcikAVgAKRWAcer5daxe5K7Q+eXUPYHVB5abnBt0/ofPfk6nThDhJv/880m01We66awJeOgXoii6qqCOC2fh93DPjOO+5wLEYgEkMIg0w2y3JTo2dkN3NTRzl06BB+v/+MeqiOjg4ikcgW/da2D+1m8X0c+DCwGzhdGLYPOIqtLnHP5oZ27fHss8/y7OHjFNxxOgGrmicSChDwuc7IcHJwuFYQQhCJRKjXG8RiMaSUdIZ8aGaTaqWCXixgCg+dfcO88PQTBF0tgqEI1VKRwbFdTB49BMCem25b0+VbZSzu5kdzBnULzpwlFKC6z0pVbgGrMoEHF80LOiiP14dQ3TTdKmpQxWNAqVqlWKlxbGaBE6lHiCdi+DU/AkF/Z5g3velNm/59bTfadVC/CDz2ctVyKeWMEOLRlf2Og9og1WqVF07O4el/lb2hnCE04CMaDq9NOzg4XGvccMMN5PP5M6KMVS29I0eO8sOXZtB8XiJBP+FWGbOyTMZo0tndjxuJBEy9hhY4s1VNh1/lnldHLtgEMb2U5mtf+9qKCsROPvCbv8WnflqkVJfUGi387vOvkgyO76JcyBOMCvpiCXSzTrijm2zdIOKPsGyq+FWVpqkT8deo1WpruoEONu06qD7g0fPsSwFvaNPuNUuz2aReb7CUzuDpGATAVy8S8IadAl2Ha5pgMLjWB83tdrNz5861fel0mp5kDawGYb+PXX29zM7OsrRU4uTxo2iyicvtolatnOWgwC7qvZDwUH9vF/f83u/wg8cf56Ybb8LrEnQFVeZKFosViz6tgdd37pvHYDhKMHyqNMQfBL/fTz6fp9VqEQiFCYfDTE+8RDrXpFAoOA7qZbTroKrArS/fKGz9kVev7HfYAIZh0GhJlrM5XH03ABCihs8dcRIkHBzOQyQSwe9eolQpMTzQR09XFEVRyNbnyOaXaUodLRBArZRJJNtr066oKnfdddfa6+6A7aBSpTr/8Nn/l6GhQd7+9ncQDF28maimaXg9HgrFoi27VKshVBeppQwHDx4kHo+v6fc5tJ/F92PgBiHEl4QQO4QQHiHEDuBLwPUr+x02gGEY1Iw6ozt24on1ANDtB4+TIOHgcF5Ws/yajQZhv5ebbrqJnTt3Eg36CQdDxEIBmnqVudlp9C3qgrsqjXRoaolMJsPTTz/DX/zFX/DEj55YV8q7otr6gx0dHUgktZpJJldifn6eF198kVQqtameWNuJdh3Uf8deM3w/cAS7geER7NbvLeD/2YrBCSGmhBAvCCF+JoR4eitsXqmYpklN1wn3jiKFQsjVorcjit+tOBGUg8N5iEaj+D0rwsoehWg0ysjICKND/Wiaj2RHjP6eJFa9znJmmUK+sKFeUOdiNT29wim5JV3Xeeihh/jEJz7BzMz6Ovf6NB/dXd0kkp2UagbHjx8nn8+zuLjI4cOHnTYetF+o+yNs55TH1uVbfRSA35BS/nDLRgh3SSlvlFLesoU2rzgMw6BqmJSkfdFH1QZel0IkHHJCfgeH8xAOh9HcKh6XQtDvx+fzEY1GCWkeers62LljB4l4nI5YBJ/PS9Nqsri4SKlYaqvAFyCuKbgVsFwaH7j7IyQ6TmXYzszM8Dd//Td85ctfXldBrlAEnckuYokOLCmYmppiamqKUqnEyZMnOXbs2KYUM6522l2DQkr5oBDin4E7gCSQBp6QUm5NHH2NsTrFl63bf5KQqBHwuZ3pPQeHC+ByuQiHQ8TKxlqGn6ZpBP0aYa1Of38/XV1dLFWfplHX0TwepNVgcT5FxqUSCYfxaaciIVVV15Ip6qaJy+VCeVn/JkWcSpR4xuxh+G2/TyRvi8OulE4xAXzyeyfZG6zytgO3nVemLF21eDJlMB6KE5YqLpeLbDZLJpMhEomQSCSYnZ2lo6ODnp4eEokEqqpSr9cpFotks9mzbCqKHUluh+amYrUY7UpECDGJHaVJ4G9PLwpe2X83cDdAV1fX/gcffLCtz6lUKmtZQpeLY8eO8YOnD/N87DWUhZ8dlefpaczz8zddt9ZTZj1cCeeyWbbDOayyHc7lSj+H48ePs7CUZnhwgMFBOwP2xRdfZDmXZ8fYKK1Wi8PHJ8nVmuRyWYRQsKwmtZpOs9nE5XLh92uoqgtLChJ9Q3h8GnMnjhKKxkn2DZ71mYcrfl6qXjzjzph7Edfx7/Hud737nK08niyEmDW9DLNIX+4gmtpCtiTVWtVu4yEUNL8fTfPhUgTjI0PcdNNNPPfccyzlSmjnyCBUBYyNDNHf39/Gb/OVZfXaOnDgwDm9adsR1CvEa6SUKSFEEviOEOKIlPLx1Z0rDutegFtuuUUeOHCgrQ957LHHaPfYrUIIwV989gFab3w9QoUuTTI+MMyb3/zmDTU4uxLOZbNsh3NYZTucy5V+Dvv37+f48eNcd911a/WCN9xwA9PT0+zbtw/Lstj5/PM0Gg2effZZRkdHyWQyWJZFpVIhn89jWRZerxdDumiFYvg0P75GL3XcjI+Pn/WZo1Kyv2xhnWOaMDU/zw+feo7WjgO4oz3c8ZrXsGPnjnOO/dFnSkALNdrLQGdrTek8DjQbTSrVCo16nZaigirt6DAYJJHs4uiySf/YDWfYazYbqJbB2Ngwt99+++Z+sa8AF7u2rmgHJaVMrfxMCyH+CTuF/fELH3V1ksvlyNZdxFUXzXIWd6CF1606XXQdHC5CKBTi5ptvPmNbLBYjFrNb1rhcLm691a6KqdfrHDhwAMuyWFhYIJ1O02w2yWazzMzMcOjIceo6xBIJgh6F5VqdRqOO233mFJ0iBP3hc399DkWHePWufj7+kyIEY9yyf+Cs9ywuLBLt7CJv2Nl66Zpk+Na957Rn6AaFQoGjB59mZrZKIpFgbiFNo9lieOdeAoFTzRnrpsHBJ//XttH7a1ss9lIjhAgIIUKrz4E3AYcu76guHS+88AJKfCUkrywTDAYIaJqTIOHgcAlQVZX+/n727t1LIpEgmUyyb98+IkE/xXyW2ekp6rUyHgX06sbLOl2qSnfIDcCycWaUNTc7x1/+5V/y+Qe/vratXJdU6+dOLfdpPrq7u0kkk1TNJgcPHmQxkwNVZWFxgbnUHDXdXvpflViq6ga1LUqrv5xcsQ4K6AJ+KIQ4CDwFfEtK+a+XeUyXhGazyaFDh3GvKEiEhI60LAKaz5E4cnC4hPh8PsbGxti5cyfxeJyB/j464zEUJHqlRLmQJZtZaqtP+MubIq7yyL88AsBC+cx095e/7wwEJDqTRBKdeL1eykadmlEnn8tTrVSZn58nlUqh6zqBUJhaY3u09bhip/iklCeBGy76xm1ArVZj4uQk7hsPACsXtmwRCYdwua7YP5GDw7YhFAqxZ88e0uk0s/nncLtdJL0hmstFMktL+IIRQqEQwUCQs1Rkz8NaO4/THE/LsgiHwghF4I7aBfkts4bi9fPNHzzJ22/oY2T03GvOmj9IblnQEYkQavrwKF6qtSrVWpVgIEgrbKEbOpVqDSmrFItFent7N/eLucxcyRHUNUMul2Nydh73ioLEeFcElyIc+X0Hh1eYwcFBRgf76emM09vbS393J163C1VVKeQLLCwuUKlU1lVDtao4sVg95aAUVeU9730PH/vYxwh0DwNgTB8EoNBw8clPfpJPf+rTHD1y5KyoTQsEMCxJw5K4PD6isTg93T0EA0Eq1QrzCwsU8gUQCjPzSxw8ePCqj6Kc2/PLjJSSZ599Ft0TI6K6sap5hsa70LMNtNPqMxwcHP7/9s48Sq6rvvOf33u1770v2iVbki1L8YZss9gCDAg8BgZsDAkGJjjGScyQhJw5CQeYBJMJcBgfCGeYyQIE8AQHJsTG2NgssQ22JBsv8iJZlrVYa7d6rera1zt/3FetltVaWuquqn66n3P6dFe9W/1+37r16vfu7/7u78498XickM/GaovzpisvY/PmzRzKHCYRj1OpVJhITzA2OkYymSQajRCLxqdNHwfoDFl4LEgWavzH3jxTlyUpFaXqK2KhWBwoMAJ4OxcTXvtWBoHvP/wC7Q8+yCf/6I/x+ryM5KoMZGwEm1y5RjASowLYHptEW4JoNMrExMRk1t9oMs3AwAA7d+4kEAjQ09NDR0fHKddGWZbVUuunjINqItVqlUcffZQf/vBH+Hp1Kqu/lMK2w0RMgoTB0HC0g/JgW0J7eztLlixhKA8De18mk8lQUzXKpTK5XJ5yuUQk3saqiy4hEglPu6C311nQ++Th4rTn64t6+PAH38vXtiQp+kOEV71h8pj/0BN4fTrR4me7chxKV9kQ68BbHCbRFiadP7qLsO2xaWtvIxaLkU6n2b+rwqsHDjJ8773EYjG8Xi+27SERjxOLxY6zdfKcPi9XX3015XKZLVu2sG7dOrq7u3nsscdob29n3bp1Z/sWzwjjoJrI+Pg4R0aTPLNvFP9CXcmpOyiUSyUS4aBJkDAYGoxt2yxbtpRcLkc0GmXx4sVMTExwfm+cWq1GKpUimUxSrUbJ5/NsG8yQHB9nIj1BJBwhHAnj9Xon/99154XYOVqeNsdCgPM7vIgIN10UZX+qQj5f4MUDI2T9nfSvvBiAak1NzmPtT9eQaoGlHV2kDx463n5nRLVy9YXs37ubI8k8anwMr9dLMBjEN1rEkmGCoRChUAjvlDlupRQL2oIMDQ2Ry+VIZvIcPHgQr9fL4Mg42WyWtWvXNnSEZRxUE0mlUoyk0hwZHiWydikAqxZ2oGpVwgG/GUEZDE1g7dq1k38vWrSIRYuOXcdUq9UYGxvjvvvuY6hgE4tFUFhkshkymQyBYIBIOEIgGKAtaHPFwpPtOKXpj3roj3qAAIs7w/xoe5asrStVjOSqk5sq7jyc5IlNP+WFl/ewfPlyVixfMW2IsW/xMvoWL6NWq5HJaLtq1Rper5dINKJ38rWEYDBIIp4gFA5x5NABUof2kEqlyOVyjGZKtCeTJJNJssUKtiWk0+mGrs00DqqJJJNJ9h0cJBRL4InrmntrlvSQHxvAa1vGQRkMLYhlWXR2dnLJJZcwVnyWCjUS7R3E4zEy2SyZTIaR/Agej4dIJEIoHDpuu/mTUU9PH8pUUUodk2Qh0W6Ugu3btrN923Y2bdrElVdcyfor1k/rOCzLIhaLEYvGyOa0beNj46SsFOFwmGqlSj6fx+vxICgyxRLJZJJ8Pk8qXyKTy3PkyBHy5Spe2yKVShkHda6QSqXA4+PDn/gTfrTXIkiJSCBBSSy8tpgQn8HQwiQSCTriUQq+CAv6F5BMJbFse9IZZLNZkskkyVRSh//C4ck5pZMR9llEfUK6pBjL145JU7cjbYg3gCoXABgbHeOBBx7gwQcfZM1Fa3j9VVexcuWq40dVAuFwmHA4TLFQJJPJkE6nSWfSBANBwuEwPp+XA4cGSZAjGIlSqSnypSrj4+PkilU8tkUymTxuRDmXGAfVJMrlMmNj4xRKFSb0Z43+uA8RwbbFjKAMhhanvhfVyESKYDBIMBikXCmTSqawbItwOEypVNIhNif85/P7CIfDkyG2E9EbsUmPVRjMVCcdlMeCSg1u/qM/Y9/Wx3niiS0UCjr5olar8cLzL/DC8y/Q1t7Gxo0bJ8s7vRZ/wI8/4Kda0bUIs9ks+Xwe22NTqSmGxydQyQzDeUWIIt6eNoqVGvlSpeEllIyDahKpVIqxiSz+UJihrA4w98e8BAIBKuUyHsvMQRkMrUwsFiPo81AoJKlWKtgeD16Pl87OTtrb20ln0qSSKXw+H4lEglw2RzabZXxsnHEZJxwKEwqHpo2U9EY8vDJW4XCmwpAT4lvV4WXbcJmCJ8J73vseVq9eRSabZcvmLezevXvyteNjp7fRoe2xiSfixONxcrkcmWyGSlVxYGAIj9ePhNs5MpqkmE2TtSKUSxYTExMopRqWKGEcVJNIpVIMJjMME2fA2Y9sQcxHwO8HVcPn85oqEgZDC1Of3wl602QzaWKJtmOOxWNx4rE4+XyeiYkJbNsmEo1QKpXIZrLk8tph2R5bj6pCoclrvj4P9dJImaqCRMBiSdzDtuEyu8fLJAIWg5UQvUuW89Yla7k8lWLnyzvZtWc31XKFwMI17Bg5moauFGzevIn+/gUsWrgQ23Ns4kYi4KO3u5taucjw3iyjeUUwEmJ86FUq0QCBnjYmMhOMpdINTZQw34AN5Pnnn2dsbAyAbDbLXc+OUVqwZPK4JzvE3h1DeC0T3jMY5gM6zDfIK9ufP+UNZVXVyGdzZHM5KpUyqgaFUoFivki5XEIsi/4ly2nv7KI8PAh0kyvr6EpfxJ6sTHFgosqBiRwQg1S9IKwX4msIXrIGgPv3lIDSsQZ0XMxQEbbuPn5NlgC3XRYjGo+TDER5QVZQLvl5nW+EkYkUXYkywVCEdK7Ak08+eYxWr9fLpZdeOieFBYyDahC5XI5Xdu9hz7CujLx//36ywW68QGloD9dech750SNctGohHkuHBAwGQ2vT3d1NT+xVOk5r+3gL4jEgRrFQIJ1Ok81WqUVtKlU/oxNZxoeHKBWLDO97heXBPNKxFJ/H5qqFAbpCFm9cFGA4p0N+M9lI8sCBA5M3x8dYZFkEuxZT9YZ4dSzP2t4IOStIFj/UINCzjNLAywTDEcIhPwOpMTJ7jhzzP3rjARYtGp7cLHI2MQ6qQaRSKXLlKr5wnGUrL+CXm7fi6boIpWp0DT3NZb0XMFrx0x4Lc9VVV7X0DqYGg0HT19fHO9/xdiqVyqkbT0N98e/Bg9ibYIMAABauSURBVAf5zaYtDBa9RMIhytEgZPazMBjF6/chuTw5Qrx+QQDL1tGVXbsGOO+8ntM6z3B7B08/8ypbt25l6MjQMcdKF1xNZM0Gfvzz3/BEaT/LL3/L5LFKtJfzO8PUqjXau3pJnLeSUPDoTsIH9u6iUk0zVzuzGwfVIJLJJPlSlWgigWXbPLv7IKEei0pqiCvXX04hl6M9FiGR0HW1DAbD/OBsQ1vxeJyFCxcyPDzMxCuDUK3QlYgRCNWIRcJ4/AFy+ZxOrgB8fh/BYJDqDJxiV3cXGzduZOM7NjIwOMBzzz036awqyQEA7HgvO379c0IXbJgsI34kW2NlyKZW1XtV+QNBQuGjN88ejxdOskvI2WIcVINIpVLkS1X6onEefvgRqoF2fSA7wtq168mlxokEvKaCucFwDmJZFm1tbXQksuRKVZYvX8LASIqSKJ1pl4hTLpXJF/Lkc3lSyRSjY2MMDgwSCAYIBpzSaKdKrhM96uvr65t0Vk89t51tgKetVzeJdoGzR+NgtgqdsGnTJt73/vfN6XswHcZBNYhkMkmuVCUUjfDQzx/C06YnMxfEfHg8HixqBL22mXsyGM5R4vE4Qd8A+XKVSMBHd2eCZC3E0iVLyToVKrw+L7FYjGpFL6C1PbZeZ5XOIJYQ8AcIBAME/IHjMvWOw3FW1/f1se/JFBkCvPdDH2VryaK+10eyUOPw0EjTphyMg2oAuVyObL4AlocXX9zOnt17aLv2WgDWX7iMQCDAeLFIMBEyIyiD4RwlkUgQ9NoEvTaBQIBytcbB4RQej4d4XK9XqtaqZLNZspksoXCIrq4uVE1RKBYo5AsUigXyeb1uxePxEAgE9MJcv/+k5ZZ6IjaZ8Qr+BavIvVrAbwvtQYuBTJWXDgxz2YoVjXobjsE4qAaQSqXIl2tIIMq/3ns/drgNT6wLlOL8/nYCfh8WNSIhs8WGwXCuUt+LKl/20NvbS+3wYahlKBby+AN6nsu2dCmlWDTG8PAwfX195HI5ctns5FxYuVymUChQLBYnK1iAnrvy+7Sz8vl9xzis3ojN7vEKzw2WJh/XHVRsyYUof4lUsYYvV6bE0TT1VLGGvzx374lxUHPE4cOHGRrS2TLpdJrNR+D+Q8D519Fxvm6T8NbIjQ8zlE8R9FomvGcwnMPEYjFCfi/FSk1XnsjlCPrG2bPzJbxe33HtD+/fTch71MmUK+XJUVSxWEApQEGpXKJcKlEslSiXyzp6J3r9ktfrJdHeQU9Izz+NFXQyRN1BAWwdtdg6GoD9E8DEcXZEPAHee82svx2AcVBzQq1W45lnnmHfSJZ6LHf7uC5nUitmUdUKXo+HyxbFyCcH6e1tIxAL0N7e3kSrDQZDM7Esi/b2dmq1Udrb2ykUCvTGBiiUs1DKHtfemxshUOqcfBwAon7A76GmwhQLBfKFAsVakaJdgiCogEWpqB1VMZukVC6z89B+Fq26mJ5AjExF8HuEVQmLRMjL1kiJiUIFFNi2hWXbWHLUKVYqZcJ2bc7eE+Og5oB0Ok2uWCZbtVi4ZDkAo3uHgBqVp3/MxOA+Pv3nnyYWquArRzhvUS/Lly+np+f01jQYDAZ3cumll1IoFIhEIqxYsUJviVGdPo87aFW56qr1p/V/K5WKnrtyki2KRR2mO3DgANsOjBIK2Lx7iaJYLFCr1ailM4xl4F19forFIh6Ph96+Xnp6eohGji6D2b1jG77i8QuAZwvjoOaAesZeNJ6gu38hyVyRieIgXgtuuuF6kuPj9PX1Uc6lCYuX3t5e+vv7m222wWBoMoFAYHIe2rZtFixYcMK2e/bsOePqDdWqrmT+29/+liPpEpZl0dHZAWhnViqWKJVKlMqlU6euzyHGQc0B9aSISLvOyNv2qi4N0u6rEQwEWHrxxYTDYUaTowQDlsncMxgMDcW2beLxOKtWreLwSIq0hFm4YAGFQpF8IU+xUKRSdRYCKz2/VX9dIzEOag7QVSMq9ESjDA0PsWtITyy2eSu0tbdhe2w6OzvZv3MbwWjEOCiDwdAU9Norm8FkhkAgSCAQJIFO1qpUKhSLRQrFAqViabKCRSM5/X2IDadFrVZjYmKCfLnK7r37uP3229lxYASABXGd4tnV1UW5WMQrEI1G8PmOz9AxGAyGuSYajRIO+CgX81TKx+aLezwewuEwHe0d9PX10dHegTQ43mcc1CyTTqfJlSoMj47z5a98mUK+oMuFAMu6IsRiMaKRKJmJFCG/bUZPBoOhaYiITm/32WTSjd0t93QwIb4Zks/nJ9c3TeWBHeM89PI4n74izqMv7OMnw20E33wbQcAORPCIIu6pUCsXOHL4AKPDQ4S9xkEZDIbmosN8HoYGDlEs5Gf02nwui28Op6WMg5ohzz77LLsPDFB5zf4v397hZ7ho8T/+5Ume2n2E8EXnHXN8Vaef1JFD2BkdzvMA0ajfLM41GAxNpa2tjXjQw3h2nFTu9LaLr+MDAgHvnCVPGAc1A5RSJJNJ9o/l6OxZgIiOx5aqipGi3tnyqf0TeLv12qf8M/fx4Xe/hSWLl9CTCHFo5zDn97dPrncKBoN0dnZOfzKDwWBoAP39/Vxy0YWUSqVTN54Gn89Hb2/vLFulMQ5qBqTTabKFEl5/kBWrdTXyYrHI93/yCxS6g3ydi7FjXQB8/IaNrFq+mL7ePo4cOkDQZ9Pd3c26deuapsFgMBimYlkWq1evbrYZ02KSJGZAfU+nsLOSulqr8r3vf49fbN462cbbsRDL6yfiFdatPp/+/n4syyKTTpntNAwGg2EGGAc1hS1btnDzzTdz5513ksvljjk2NjbGPffcQypXQGwPe/buYe/evVx6yaV4246vArGsK0JnZ+dkWmY2PUHIZ5IiDAaD4XRp6RCfiGwEvg7YwD8ppb40V+fat28fb33rW8nlctx11118/vOfZ9GiRQAMDw8zOjoKwE1/8Ckuu/pawraXQqGoV2QvWEERiPmEiZJOnljefbReVbVSoVDIEepqIxaLzZUEg8FgcBUtO4ISERv4X8A7gQuBD4nIhXNxLqUUt9566zGjpmw2y44dO9ixY8ekcwLYs/8gYnkolyuEQiF8oTAlTxhL4OpVR4u9LmkPHf1fmTQhr00sFjvppmEGg8FgOEorj6DWA7uUUnsARORu4D3A9tk+0eHDh3n88cenPRZZ9zaC512JZQn+QJBMooP7X60BBWy7RE08KKAv6mNR9GiqZZe/RjatSxyNjw4TNOE9g8FgmBGilDp1qyYgIjcAG5VStziPbwauUErdPqXNrcCtAD09PZfdfffdZ3SuTCbDiy++yA9+8AM6Ozu58cYbSaVSpFIpnqktZQcnrihcZylDrGSQ/+BCgpS5WnYcczzhh7Wrz5uzdMw6mUyGSCQyp+eYa9ygoY4btLhBQx2jpbWoa9iwYcO0NZTmtYOayuWXX66eeuqpMzrXww8/TG9vL9lslmq1yhVXXDF5bOeRNP/vZ48c0z4UDh/z2GPBqnYbvy0M52r4bIj7jw3l+Xw+Lr300jmvu/fII4+wYcOGOT3HXOMGDXXcoMUNGuoYLa3FFA3TOqhWDvEdAhZNebzQeW7WERFWrVpFoVAgFAodc2xlT5TPfOz6uTitwWAwGE5CK8/Y/xY4X0SWiYgP+CDwk7k6mWVZxzkng8FgMDSPlh1BKaUqInI78BA6zfzbSqltTTbLYDAYDA2iZR0UgFLqAeCBZtthMBgMhsbTyiE+g8FgMJzDGAdlMBgMhpbEOCiDwWAwtCTGQRkMBoOhJTEOymAwGAwtiXFQBoPBYGhJjIMyGAwGQ0vSsrX4ZoqIDAP7zvDlncDILJrTTNygxQ0a6rhBixs01DFaWou6hhGl1MbXHnSNgzobROQppdTlzbZjNnCDFjdoqOMGLW7QUMdoaS1OpcGE+AwGg8HQkhgHZTAYDIaWxDgozT8024BZxA1a3KChjhu0uEFDHaOltTipBjMHZTAYDIaWxIygDAaDwdCSGAdlMBgMhpbknHFQIjLtnvfzETdpMRhmG7dcH27QcbYazhkH5TIiACJiN9uQM0VEFjTbhtlCRNaLSKzZdpwNIvJuEVnRbDtmiWD9Dzd8yc9zJr+jzqQvXO+gRGSjiNwL3CEi83ZRm2i6ReQR4J8AlFLV5lo1c0TkWhF5Grit2bacLSJyjYhsB24F5qWDcvpjM/AtoK/Z9pwNInKdiPwS+DsR+T0ANQ+zwETkehH5AfAXIrKk2facCVP64k4RuRrOrC9c6aCcL/OAiPwz8Fn0xRcBPi4inU017gxxOrfg/KwTkXcCiEjL96HTHz4R+SbwVeAOpdTnph5vnnVnhogEgE8BX1BK3aKUOug83/JanP6IiMh96Ovjs8AWYIlzvOU/U69FRN4O/BXwdeBJ4C0i0t9Uo84AEbkW+BzwXcADfFJErnOOzYt+EZGlwN8A3wBeAm4VkVucYzPSMC8EzxSlKQD3AtcopX4C/BidVj8va1c5HbsQ2Ar8BfB5AKVUrZl2nQ5Of5SAEHCPUuoeEbFE5Hfqx5tr4RmxABhVSt0tIkEReZ+IdOGENFrZUTn9kQHuUkptUEr9CngIeI9zvOU/U9NwDfCQUuo+4CnAq5Q63GSbzoRrgZ8qpR4E/h6IAr8vIuF51C8rgMeUUvcC30FHfD4pIm1KqdpMrg1XOSgR+a8i8iUR+QCAUurflVJV5/G/AatF5A4ReWNzLT01U7S8Hya/NA4DK4HHgQERuU1Ezm+mnSdjioabnKfuAN4kIl8FngG+KCL/ICLvaJ6Vp8cULTc4T5WBNzufpXuAjwBfQ9/FtyRTNNwIoJT6V+d5CxgHDoiIv5k2ni6vvdaB+4E/EZEvAw8AS0TkH0XkVqd9S94wTKNjE/AGEQkopYbQERMb+P2mGXkKROQGEbliylMHgfeLiF8pVVBKPYLW9fmZ/m9XOCgnZPGnwE3ou6e/FpGPiUiP02QIeAv67uQw8DHnbrflmEbLFx0t7cB5wHPOKHAT8D+BO53XeZpl82uZRsNficjHlVK70V/mq51jvwu8CPznVg29TqPlDhG5RSm1Hz1C/xbwVaXUe4EvAu8WkQtbaVQ4jYYvOJ+pLpi8+dkLXKeUKjbR1FNygmv9FnRY72KgC7hBKXUN8O/oz9bSVuoPOKGOjwI70N9RPxSRh9Fzm/cC0VYL8YmeE38U+DvgL+v2KaVeBn4BfNlpJ8D/ARaJSM9M+qJlvtTOBqWUEpE3A59VSj0sIhngHYACvut4cABE5AXgTUC+KcaeghNo2Yi293H0COQB9HzB48Ae56UtkzBxAg3vEpEPKKW+ISLfcUJMiMhW4Eog10ybT8QJtLzTGRV+DfgkTlhPKfWSiGwCvM2z+HhOcn1Uge87bTaJyEERebcTEm9JTnJ93KSU+r8isgwYcJq/ABxBfw+0FNPoyAJvR18HtwDrgH6l1P2iEz6WtVqITyk1JDoB7ZfAHwKfAP63c/ivgYdE5B+VUttEpACkgcxMztFSHvlMmHJX8RTa8eDEb3cCF4jIyte85O3oL/uWc1An0fIy8DvAJejh82+VUmuADwIbRGRBq9whnkTDS8BlIrKq7pwc3oa+KAsNNfQ0OImWHcDlwAQ6weDPRGSNiHwOuAjdRy3BKa6PNSKy2mkXQ+sqN8PO0+EU18closPdvwK+4rT7L+i5wvEGm3pSTqDjZ+g+eR1wnlLqWaXU/U67y4AnGm7oSZii4RvAduDnwHUi0gfgREu+BXzTCYN/GOgGZuRk552DEmftTz2mPOWuYhd6GLzWefwoEAdiojPIbhaR54GlwF+2Qor2DLT8Gj1ZOgTcppT67077MeANSqlDDTV8CjPsjxhaByLyQRF5ET0S/Ewr3B2egZZlSqmvAHcBf4wOwd6olBptqOFTOIPrI+K0m0An4fTQIsxQSwit55uAR/RyjDXAzY62pjFDHVGOXiPvEpEn0dfIvzXU6NdwIg1KqbJSqoKectiBzmzFOfa3aCf1cWAV8HGl1IwGBvPGQYnIG0Tku8BnRaS9PmIQkXo45UmgArxdRDxKqe3ou6fLnAyyA8AfKqU+4kw+No0z0LIN/SG9RClVEBF7ygdlRkPmJmqo90d9Ldo+5m9/bEevGXo9gFLqe8CnlFIfVUoNTHOKOWcW+gPgg0qpf26k3dNxhloWAeudm7YPAR9QSt2klBpshgY4qz55nXP8FfQN6fuVUk0ZBZ5Ew+R3kMMI8BNgpYgsFD0/1eZcG59QSn3gTPpiXjgoEVmOvjN6GP1FfYeIvAu0B3d+70IPmVeg07ABijjbwCulHlFKPd5g04/jLLW86hyvNjOkN0v9sVkp9ZsGm34cZ6mlPv832bYZzMZnymnT9DDrWWgp4PSHUirXAjc9s3Gdv6KUeqaxlh/lFBqqzjyaX3S2XlUp9WtgGzrx6VH0du44A4QzYl44KGA98JJzd/fn6LVA19fjnSLyRRH5FvA0OqNkvehqBWPo2Ggr4QYtZ6PhoeaYfELO9f5oFQ113KLFDdfIqTR8Ab3Gqf74NnSixN8D65RSr5y1BUqplvsBrgduB650Hi9HZ6wtdh5fCHwJ+FPgjcC/oCcW66+PAIlm63CLFjdocJMWN2hwmxY36JgFDddOfTwbPy01ghKRPtHlV/4b0AZ8R0TeoZTaA2wGbnSavoweSsaAF5RSv6uU2iVH8/AzSqlkEyRM4gYtbtBQxw1a3KChjlu0uEHHLGioL7P4pdJhy1mjpRwUesL2N0qpNyml7kDX1brVOfYbYK2IXKF0Bt4h4GqlVAp02qNqgUywKbhBixs01HGDFjdoqOMWLW7QcbYa5iwjuukOSkQ+IiIbRJdY+RXOwkGHUfTaANDrAJ5FV8eNoFNI94lICFqjfpgbtLhBQx03aHGDhjpu0eIGHfNFQ1MqSYiIAL3oGGYN2A38ATpVd0BEvEpnuvShh5wonaL4ddHl57+Nzir5iFKqqRUI3KDFDRrquEGLGzTUcYsWN+iYlxpONUk12z+A7fxeia6mDLpUzDeAH7+mzX3Atc7f3c5vDxBttN1u1eIGDW7S4gYNbtPiBh3zVUPDRlDORNodgC26llwMp36c0hXHPwUcFpFrlFKPiogPGAZ2isjfAP9JRDYovWAt3Si7p8MNWtygoY4btLhBQx23aHGDjvmuoSFzUCJyDTrfvw1d3uMOjm5XsB4mY5l/hS4yCBAAPoaOj0bRHr3pNbXcoMUNGuq4QYsbNNRxixY36HCDhkYNL9+ErolVf/xNdPXbjwFPO89Z6PjoD9E1wdYD3wMubvSw0u1a3KDBTVrcoMFtWtygwxUaGvRGhQA/R2Ocvwf8rfP3VuCTzt+XA3c3+01xuxY3aHCTFjdocJsWN+hwg4aGhPiUro1VVEfz5d+GjnOCLol/gYj8FPgBekg6WTW31XCDFjdoqOMGLW7QUMctWtygww0aGppm7kzYKXRJ//qmaGngM+h9dPYqZ+sI5bj2VsUNWtygoY4btLhBQx23aHGDjvmsodELdWvo3UZHgHWO9/4cUFNKPaaauK/RGeAGLW7QUMcNWtygoY5btLhBx/zV0OiYInp77xrwGHoDq6bHOc9lLW7Q4CYtbtDgNi1u0DFfNYhjfMMQkYXAzcCdSqliQ08+y7hBixs01HGDFjdoqOMWLW7QMV81NNxBGQwGg8FwOjS9WKzBYDAYDNNhHJTBYDAYWhLjoAwGg8HQkhgHZTAYDIaWxDgog8FgMLQkxkEZDAaDoSUxDspgMBgMLcn/B7Bvu5SErk6zAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fig, axs = subplots(ncols=1, nrows=2, figsize=(6, 9))\n", + "fig, axs = subplots(ncols=2, nrows=2, figsize=(12, 9))\n", "\n", "gv_kws = dict(color=\"black\", zorder=10, lw=3, z_factor=0.674)\n", "gv_line_kws = {\"ls\": \"--\", \"label\": \"Normal posteriors\"}\n", @@ -835,8 +854,8 @@ "\n", "t_range_shifted = FORECAST_DF.index - timedelta(days=OFFSET)\n", "\n", - "# Census\n", - "ax = axs[0]\n", + "# Census hospital\n", + "ax = axs[0, 0]\n", "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", "ax.grid(True)\n", "\n", @@ -863,9 +882,35 @@ "\n", "ax.legend(bbox_to_anchor=(1.0, 1.0))\n", "\n", + "# Census vent\n", + "ax = axs[0, 1]\n", + "ax.set_ylabel(f\"COVID-19 Vent Census\", fontsize=12, fontweight=\"bold\")\n", + "ax.grid(True)\n", "\n", - "# Admits\n", - "ax = axs[1]\n", + "## General posteriors\n", + "plot_band(\n", + " x=FORECAST_DF.index,\n", + " y1=FORECAST_DF[\"Vent Census 25%\"],\n", + " ym=FORECAST_DF[\"Vent Census Median\"],\n", + " y2=FORECAST_DF[\"Vent Census 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "## Normal posteriors\n", + "plot_gvar(\n", + " x=t_range_shifted,\n", + " y=FORCAST_DF_NORMAL[\"vent_census\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "\n", + "\n", + "# Admits hosp\n", + "ax = axs[1, 0]\n", "ax.set_ylabel(f\"COVID-19 Hospital Admits\", fontsize=12, fontweight=\"bold\")\n", "ax.grid(True)\n", "\n", @@ -891,6 +936,33 @@ " fill_kws=gv_fill_kws,\n", ")\n", "\n", + "# Admits vent\n", + "ax = axs[1, 1]\n", + "ax.set_ylabel(f\"COVID-19 Vent Admits\", fontsize=12, fontweight=\"bold\")\n", + "ax.grid(True)\n", + "\n", + "## General posteriors\n", + "plot_band(\n", + " x=FORECAST_DF.index,\n", + " y1=FORECAST_DF[\"Vent Admits 25%\"],\n", + " ym=FORECAST_DF[\"Vent Admits Median\"],\n", + " y2=FORECAST_DF[\"Vent Admits 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "\n", + "## Normal posteriors\n", + "plot_gvar(\n", + " x=t_range_shifted,\n", + " y=FORCAST_DF_NORMAL[\"vent_admits\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "\n", "\n", "fig.suptitle(\n", " \"General vs normal posteriors @ 50% C.I.\", y=1.02, fontsize=12, fontweight=\"bold\"\n", @@ -927,84 +999,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
hospventmort
2020-03-02000
2020-03-03000
2020-03-04000
2020-03-05000
2020-03-06100
\n", - "
" - ], - "text/plain": [ - " hosp vent mort\n", - "2020-03-02 0 0 0\n", - "2020-03-03 0 0 0\n", - "2020-03-04 0 0 0\n", - "2020-03-05 0 0 0\n", - "2020-03-06 1 0 0" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "extended_range = date_range(\n", " DATA_DF.index[0] - timedelta(int(OFFSET)), freq=\"D\", periods=OFFSET\n", @@ -1023,7 +1020,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1036,7 +1033,11 @@ " \"initial_susceptible\": META_PARS[\"region_pop\"],\n", " \"initial_infected\": 0,\n", " \"initial_recovered\": 0,\n", - " \"initial_hospitalized\": META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"],\n", + " \"initial_infected\": 0,\n", + " \"initial_recovered\": 0,\n", + " \"initial_icu\": 0,\n", + " \"initial_vent\": 0,\n", + " \"initial_hospital\": META_PARS[\"n_hosp\"] / META_PARS[\"mkt_share\"],\n", "}\n", "## Variable parameters (distributions)\n", "pp = {\n", @@ -1045,14 +1046,18 @@ " \"beta\": PRIORS[\"beta\"],\n", " \"recovery_days\": PRIORS[\"recovery_days\"],\n", " \"nu\": PRIORS[\"nu\"],\n", - " \"hospitalization_probability\": PRIORS[\"hosp_prop\"],\n", + " \"hospital_probability\": PRIORS[\"hosp_prop\"],\n", " \"hospital_length_of_stay\": PRIORS[\"hosp_LOS\"],\n", + " \"icu_probability\": PRIORS[\"ICU_prop\"],\n", + " \"icu_length_of_stay\": PRIORS[\"ICU_LOS\"],\n", + " \"vent_probability\": PRIORS[\"vent_prop\"],\n", + " \"vent_length_of_stay\": PRIORS[\"vent_LOS\"],\n", "}" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1070,12 +1075,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "seir.fit_start_date = \"2020-03-06\"\n", - "seir.fit_columns = \"hospital_census\"\n", + "seir.fit_columns = [\"hospital_census\", \"vent_census\"]\n", "seir.debug = False" ] }, @@ -1089,11 +1094,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "yy = gvar(DATA_DF.hosp.values, DATA_DF.hosp.values * 0.1 + 10)" + "yy = gvar(\n", + " [DATA_DF.hosp.values, DATA_DF.vent.values],\n", + " [DATA_DF.hosp.values * 0.1 + 10, DATA_DF.vent.values * 0.1 + 2,],\n", + ").T" ] }, { @@ -1105,17 +1113,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Checks passed\n" - ] - } - ], + "outputs": [], "source": [ "seir.check_call(xx, yy, pp)" ] @@ -1129,7 +1129,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { "scrolled": false }, @@ -1140,17 +1140,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.89 s ± 223 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], + "outputs": [], "source": [ "%%timeit\n", "nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" @@ -1158,22 +1150,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "x_prediction = xx.copy()\n", "tf = FORECAST_DF.iloc[:100]\n", @@ -1181,7 +1160,7 @@ "df = seir.propagate_uncertainties(x_prediction, fit.p)\n", "df.index -= timedelta(days=OFFSET)\n", "\n", - "fig, axs = subplots(ncols=1, nrows=2, figsize=(9, 9), sharex=False)\n", + "fig, axs = subplots(ncols=2, nrows=2, figsize=(12, 9), sharex=False)\n", "\n", "gv_kws = dict(color=\"black\", zorder=10, lw=3, z_factor=0.674)\n", "gv_line_kws = {\"ls\": \"--\", \"label\": \"New normal fit\"}\n", @@ -1191,12 +1170,12 @@ "line_kws = {\"ls\": \"-\", \"label\": \"Original fit\", \"lw\": 2}\n", "\n", "\n", - "# Census\n", - "ax = axs[0]\n", + "# Census hospitalized\n", + "ax = axs[0, 0]\n", "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", "ax.grid(True)\n", "\n", - "## Fit\n", + "## Fit hospitalized\n", "plot_gvar(\n", " x=df.index,\n", " y=df[\"hospital_census\"].values,\n", @@ -1206,7 +1185,7 @@ " fill_kws=gv_fill_kws,\n", ")\n", "\n", - "## Original\n", + "## Original hospitalized\n", "ax.set_ylabel(f\"COVID-19 Hospital Census\", fontsize=12, fontweight=\"bold\")\n", "plot_band(\n", " x=tf.index,\n", @@ -1219,10 +1198,10 @@ " zorder=20,\n", ")\n", "\n", - "## Data\n", + "## Data hospitalized\n", "plot_gvar(\n", " x=DATA_DF.index,\n", - " y=yy,\n", + " y=yy.T[0],\n", " ax=ax,\n", " z_factor=0.674,\n", " color=\"red\",\n", @@ -1232,11 +1211,14 @@ "ax.legend(loc=\"upper left\")\n", "\n", "\n", - "# Admits\n", - "ax = axs[1]\n", + "# Admits hospitalized\n", + "ax = axs[1, 0]\n", + "ax.set_ylabel(f\"COVID-19 Hospital Admits\", fontsize=12, fontweight=\"bold\")\n", + "\n", + "\n", "ax.grid(True)\n", "\n", - "## Prediction\n", + "## Prediction hospitalized\n", "plot_gvar(\n", " x=df.index,\n", " y=df[\"hospital_admits\"].values,\n", @@ -1248,7 +1230,7 @@ "ax.grid(True)\n", "\n", "\n", - "## Original\n", + "## Original hospitalized\n", "plot_band(\n", " x=tf.index,\n", " y1=tf[\"Hospitalized Admits 25%\"],\n", @@ -1260,6 +1242,76 @@ " zorder=20,\n", ")\n", "\n", + "# Census vent\n", + "ax = axs[0, 1]\n", + "ax.set_ylabel(f\"COVID-19 Vent Census\", fontsize=12, fontweight=\"bold\")\n", + "ax.grid(True)\n", + "\n", + "## Fit vent\n", + "plot_gvar(\n", + " x=df.index,\n", + " y=df[\"vent_census\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "\n", + "## Original vent\n", + "plot_band(\n", + " x=tf.index,\n", + " y1=tf[\"Vent Census 25%\"],\n", + " ym=tf[\"Vent Census Median\"],\n", + " y2=tf[\"Vent Census 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "\n", + "## Data vent\n", + "plot_gvar(\n", + " x=DATA_DF.index,\n", + " y=yy.T[1],\n", + " ax=ax,\n", + " z_factor=0.674,\n", + " color=\"red\",\n", + " line_kws={**line_kws, \"label\": \"Data\"},\n", + " fill_kws={**fill_kws, \"alpha\": 0.5, \"zorder\": 5},\n", + ")\n", + "ax.legend(loc=\"upper left\")\n", + "\n", + "\n", + "# Admits vent\n", + "ax = axs[1, 1]\n", + "ax.set_ylabel(f\"COVID-19 Vent Admits\", fontsize=12, fontweight=\"bold\")\n", + "\n", + "ax.grid(True)\n", + "\n", + "## Prediction vent\n", + "plot_gvar(\n", + " x=df.index,\n", + " y=df[\"vent_admits\"].values,\n", + " ax=ax,\n", + " **gv_kws,\n", + " line_kws=gv_line_kws,\n", + " fill_kws=gv_fill_kws,\n", + ")\n", + "ax.grid(True)\n", + "\n", + "\n", + "## Original hospitalized\n", + "plot_band(\n", + " x=tf.index,\n", + " y1=tf[\"Vent Admits 25%\"],\n", + " ym=tf[\"Vent Admits Median\"],\n", + " y2=tf[\"Vent Admits 75%\"],\n", + " fill_kws=fill_kws,\n", + " line_kws=line_kws,\n", + " ax=ax,\n", + " zorder=20,\n", + ")\n", + "\n", "\n", "fig.suptitle(\n", " \"General PDF vs normal PDF @ 50% C.I.\", y=1.02, fontsize=12, fontweight=\"bold\"\n", @@ -1273,168 +1325,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Least Square Fit:\n", - " chi2/dof [dof] = 0.38 [47] Q = 1 logGBF = -194.77\n", - "\n", - "Parameters:\n", - " initial_exposed 69 (48) [ 160 (67) ] *\n", - " incubation_days 3.0 (1.1) [ 4.6 (1.5) ] *\n", - " beta 0.478 (89) [ 0.32 (12) ] *\n", - " recovery_days 17.1 (4.9) [ 15.3 (5.0) ] \n", - " nu 2.46 (25) [ 2.46 (25) ] \n", - "hospitalization_probability 0.0378 (71) [ 0.024 (10) ] *\n", - " hospital_length_of_stay 11.49 (83) [ 11.64 (83) ] \n", - " L 0.793 (47) [ 0.37 (23) ] *\n", - " x0 29.7 (1.1) [ 20.7 (6.9) ] *\n", - " k 1.02 (41) [ 0.78 (43) ] \n", - "\n", - "Settings:\n", - " svdcut/n = 1e-12/1 tol = (1e-08,1e-10,1e-10*) (itns/time = 117/1.8)\n", - " fitter = scipy_least_squares method = trf\n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PriorsPDF from normal approxPDF from general distsdiffz
hosp_prop0.024(10)0.0378(71)0.0235(30)0.0142(78)1.830691
logistic_x020.7(6.9)25.7(1.1)25.41(42)0.3(1.1)0.257920
incubation_days4.6(1.5)3.0(1.1)3.25(29)-0.2(1.1)0.201248
logistic_k0.78(43)1.02(41)0.94(14)0.08(43)0.188333
beta0.32(12)0.478(89)0.467(26)0.011(93)0.120969
logistic_L0.37(23)0.793(47)0.787(19)0.005(50)0.108672
hosp_LOS11.64(83)11.49(83)11.59(29)-0.09(88)0.107157
recovery_days15.3(5.0)17.1(4.9)16.6(1.7)0.5(5.2)0.105776
nu2.46(25)2.46(25)2.440(73)0.02(26)0.069792
\n", - "
" - ], - "text/plain": [ - " Priors PDF from normal approx PDF from general dists \\\n", - "hosp_prop 0.024(10) 0.0378(71) 0.0235(30) \n", - "logistic_x0 20.7(6.9) 25.7(1.1) 25.41(42) \n", - "incubation_days 4.6(1.5) 3.0(1.1) 3.25(29) \n", - "logistic_k 0.78(43) 1.02(41) 0.94(14) \n", - "beta 0.32(12) 0.478(89) 0.467(26) \n", - "logistic_L 0.37(23) 0.793(47) 0.787(19) \n", - "hosp_LOS 11.64(83) 11.49(83) 11.59(29) \n", - "recovery_days 15.3(5.0) 17.1(4.9) 16.6(1.7) \n", - "nu 2.46(25) 2.46(25) 2.440(73) \n", - "\n", - " diff z \n", - "hosp_prop 0.0142(78) 1.830691 \n", - "logistic_x0 0.3(1.1) 0.257920 \n", - "incubation_days -0.2(1.1) 0.201248 \n", - "logistic_k 0.08(43) 0.188333 \n", - "beta 0.011(93) 0.120969 \n", - "logistic_L 0.005(50) 0.108672 \n", - "hosp_LOS -0.09(88) 0.107157 \n", - "recovery_days 0.5(5.2) 0.105776 \n", - "nu 0.02(26) 0.069792 " - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "print(fit)\n", "\n", @@ -1443,8 +1336,12 @@ " \"L\": \"logistic_L\",\n", " \"x0\": \"logistic_x0\",\n", " \"k\": \"logistic_k\",\n", - " \"hospitalization_probability\": \"hosp_prop\",\n", + " \"hospital_probability\": \"hosp_prop\",\n", " \"hospital_length_of_stay\": \"hosp_LOS\",\n", + " \"icu_probability\": \"ICU_prop\",\n", + " \"icu_length_of_stay\": \"ICU_LOS\",\n", + " \"vent_probability\": \"vent_prop\",\n", + " \"vent_length_of_stay\": \"vent_LOS\",\n", "}\n", "\n", "new_posterior = {name_map.get(key, key): val for key, val in fit.p.items()}\n", @@ -1455,12 +1352,12 @@ "comparison = DataFrame(\n", " [new_prior, new_posterior, POSTERIORS],\n", " index=[\"Priors\", \"PDF from normal approx\", \"PDF from general dists\",],\n", - ").T.dropna()\n", + ").T # .dropna()\n", "\n", "# Compute difference in standard deviations\n", "comparison[\"diff\"] = (\n", " comparison[\"PDF from normal approx\"] - comparison[\"PDF from general dists\"]\n", - ")\n", + ").dropna()\n", "comparison[\"z\"] = comparison[\"diff\"].apply(lambda x: abs(x.mean) / x.sdev)\n", "\n", "# Present\n", From 8193550c90909f601e34a7c958256f1d3a9b4a3e Mon Sep 17 00:00:00 2001 From: ckoerber Date: Mon, 27 Apr 2020 22:47:40 +0200 Subject: [PATCH 40/40] Added executed notebook. --- ...-to-use-normal-approximations-module.ipynb | 718 +++++++++++++++++- 1 file changed, 687 insertions(+), 31 deletions(-) diff --git a/notebooks/How-to-use-normal-approximations-module.ipynb b/notebooks/How-to-use-normal-approximations-module.ipynb index e6b9a4a..507e117 100644 --- a/notebooks/How-to-use-normal-approximations-module.ipynb +++ b/notebooks/How-to-use-normal-approximations-module.ipynb @@ -627,7 +627,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -649,9 +649,124 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
val
hosp_prop0.0235(30)
ICU_prop0.368(11)
vent_prop0.764(40)
hosp_LOS11.59(29)
ICU_LOS13.45(26)
vent_LOS19.62(61)
incubation_days3.25(29)
recovery_days16.6(1.7)
logistic_k0.94(14)
logistic_x025.41(42)
logistic_L0.787(19)
nu2.440(73)
beta0.467(26)
\n", + "
" + ], + "text/plain": [ + " val\n", + "hosp_prop 0.0235(30)\n", + "ICU_prop 0.368(11)\n", + "vent_prop 0.764(40)\n", + "hosp_LOS 11.59(29)\n", + "ICU_LOS 13.45(26)\n", + "vent_LOS 19.62(61)\n", + "incubation_days 3.25(29)\n", + "recovery_days 16.6(1.7)\n", + "logistic_k 0.94(14)\n", + "logistic_x0 25.41(42)\n", + "logistic_L 0.787(19)\n", + "nu 2.440(73)\n", + "beta 0.467(26)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "keys = PRIORS.keys()\n", "POSTERIORS = avg_data(POSTERIOR_DF.T.loc[keys].T.values, median=True, spread=True)\n", @@ -695,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -714,9 +829,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from bayes_chime.normal.models import seir as ms\n", "from bayes_chime.normal.models import sir as msi\n", @@ -728,9 +854,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['dates', 'initial_susceptible', 'initial_infected', 'inital_recovered', 'beta', 'gamma', 'alpha']\n", + "['recovery_days', 'inital_doubling_time', 'market_share', 'initial_hospital', 'hospital_probability', 'hospital_length_of_stay', 'initial_icu', 'icu_probability', 'icu_length_of_stay', 'initial_vent', 'vent_probability', 'vent_length_of_stay', 'incubation_days']\n" + ] + } + ], "source": [ "seir = ms.SEIRModel()\n", "print(seir.model_parameters)\n", @@ -750,7 +885,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -795,7 +930,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -819,9 +954,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21 ms ± 155 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], "source": [ "%%timeit\n", "seir.propagate_uncertainties(XX, PP)" @@ -829,9 +972,192 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
susceptibleinfectedrecoveredexposedexposed_newinfected_newrecovered_newinfected_new_localhospital_admitshospital_censusicu_admitsicu_censusvent_admitsvent_census
date
2020-03-061.2e+0600163(21)00000(0)00(0)00(0)0
2020-03-071.1999999999999997335465(32)e+0650.3(8.7)0(0)113(14)0(0)50.3(8.7)0(0)13.1(2.3)0.307(28)0.307(28)0.113(11)0.113(11)0.086(10)0.086(10)
2020-03-081.1999765(42)e+0682(13)3.03(70)102(13)23.5(4.2)34.8(5.2)3.03(70)9.0(1.3)0.213(11)0.494(36)0.0783(45)0.183(14)0.0598(51)0.142(15)
2020-03-091.199938(11)e+06108(17)8.0(1.8)109(15)38.3(6.4)31.3(4.7)4.9(1.1)8.1(1.2)0.1916(89)0.643(42)0.0705(40)0.240(17)0.0538(45)0.188(19)
2020-03-101.199888(19)e+06135(21)14.5(3.2)126(18)50.6(8.4)33.5(5.3)6.5(1.4)8.7(1.4)0.205(12)0.792(49)0.0753(53)0.297(21)0.0575(55)0.236(23)
\n", + "
" + ], + "text/plain": [ + " susceptible infected recovered exposed \\\n", + "date \n", + "2020-03-06 1.2e+06 0 0 163(21) \n", + "2020-03-07 1.1999999999999997335465(32)e+06 50.3(8.7) 0(0) 113(14) \n", + "2020-03-08 1.1999765(42)e+06 82(13) 3.03(70) 102(13) \n", + "2020-03-09 1.199938(11)e+06 108(17) 8.0(1.8) 109(15) \n", + "2020-03-10 1.199888(19)e+06 135(21) 14.5(3.2) 126(18) \n", + "\n", + " exposed_new infected_new recovered_new infected_new_local \\\n", + "date \n", + "2020-03-06 0 0 0 0 \n", + "2020-03-07 0(0) 50.3(8.7) 0(0) 13.1(2.3) \n", + "2020-03-08 23.5(4.2) 34.8(5.2) 3.03(70) 9.0(1.3) \n", + "2020-03-09 38.3(6.4) 31.3(4.7) 4.9(1.1) 8.1(1.2) \n", + "2020-03-10 50.6(8.4) 33.5(5.3) 6.5(1.4) 8.7(1.4) \n", + "\n", + " hospital_admits hospital_census icu_admits icu_census vent_admits \\\n", + "date \n", + "2020-03-06 0(0) 0 0(0) 0 0(0) \n", + "2020-03-07 0.307(28) 0.307(28) 0.113(11) 0.113(11) 0.086(10) \n", + "2020-03-08 0.213(11) 0.494(36) 0.0783(45) 0.183(14) 0.0598(51) \n", + "2020-03-09 0.1916(89) 0.643(42) 0.0705(40) 0.240(17) 0.0538(45) \n", + "2020-03-10 0.205(12) 0.792(49) 0.0753(53) 0.297(21) 0.0575(55) \n", + "\n", + " vent_census \n", + "date \n", + "2020-03-06 0 \n", + "2020-03-07 0.086(10) \n", + "2020-03-08 0.142(15) \n", + "2020-03-09 0.188(19) \n", + "2020-03-10 0.236(23) " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "FORCAST_DF_NORMAL = seir.propagate_uncertainties(XX, PP)\n", "FORCAST_DF_NORMAL.head()" @@ -839,9 +1165,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAKYCAYAAABuAFmoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd3xc1Z3w/8+ZIo3KqMvqzb1bxo2yGAcSyJKEEEKAwAM4QEiDLGUhIckmhGeT3VQ2AX5PQkhCSAiQEFJJYSmGADbF4F5VRprRFM2MNNL0en5/3JmxJMuWLMuWLJ/36zWv0dxy7jlXI937vacJKSWKoiiKoiiKoijK8dNNdQYURVEURVEURVFmChVgKYqiKIqiKIqiTBIVYCmKoiiKoiiKokwSFWApiqIoiqIoiqJMEhVgKYqiKIqiKIqiTBIVYCmKoiiKoiiKokwSFWApiqJMIiFEsxBCCiHUHBgjCCE2pM+NZarzMhlmWnkURVGUyaECLEVRph0hxDohxDNCCJcQIiaEcAgh/lcIcdlU5005tQkhLOmgaMMkJGcDfgD8bBLSOmZCiEYhxI+EEFYhREQI0SGEuF8IUTHGfpnAcOTr8iHbNAsh/iiECAghBoQQvxFCVKfXCSHE/wgh+tPHvmbIfguEECEhxBnjyH+TEOKRdBoxIYQ9fZzZR9i+eUheS8Z/phRFUU4uw1RnQFEUZSghxMeAJwA9sA/4C2AG1gFXA89MYd6MUsr4VB3/ZDldynk80ueoDbhtEtI55nOdDhD/COQALwBWoA74FPBxIcR6KeWBMZJ5A9gy5PPBdNo64FlgMfAckAt8DGgAzgI+CPwb8Nf0skeEEH+XUnqBB4CfSynfGSP/C4HXgDKgB/g1UAy8L/1zx5gnQVEUZZpSNViKokwbQoh84EdowdWTwDIp5Y1SyiuA2cBXh2y7VAjxrBCiVwjhFkL8TgjROGR95kn3LUKIA0IIvxDiV0KInCHbXCKEeFMIMSiE6BJCfC+dh2HNv4QQ9wohvMDDQogaIcQrQgiPECKePvavxvtEXQjx9XS6DwxZ9rX0sgfTtQPfTD/VjwohnEKIfwghyo+Q3qb0vv+VzldICPGaEKJpyDbLhRB/T+fZLYT4sxBiwZD1mVqdLwshdgOREcu/LoTYna7N+B8hxGIhxNb0OX1CCJE75Dhb0jUbcaHVPD449JyP4/wM/b21CyF8QoifCiHyhmzzESHEW+njdwkhHsqcfyFEjhDiJ+nzFk2fxz9nygNkzstL6eNsTK+byHfhsCaCx3Gub0uXN5red9PQ/Uaco0rgd8A/gRbgD4AF+DbwC+AAWpAylr9LKW8b8tqeXn4JWnC1U0p5EXAB0AWcKbTAblF6u+uA/wuYgDlCiI8CK4GvjOPY/4MWXO0FlkgpN0opPwI0A2+OY39FUZTpS0qpXuqlXuo1LV5oT69l+rXwKNtVA31ADK1G67fpffYCueltMul4gUeBUPrzjen1F6U/u9FuSl9Lf/55ev2GIWnYgIeBO4D5wFvAz4H/D+1mVgI/Su/XnNnvCHmfk15vB3TpZbvTy9YC703/bEmn/5v0ts1HSG9TevsE8DjajbAEfpleXwP0p5f9Ba1GQgIOoDS9jWVIGk8Cvx2x3J8+R7H05770sTzpzzelt78AeAV4BPhx+rxJ4IsjzqnlKL/bzDl3oTW9601//l56/cXpz9F0nnalP/89vf6m9Odd6fP3B8CbXvdVYDC9/mm0m/y1x/FdGFaeiZ5rYO6Q4/+IQzU4G45wjr6eLl8uWhPFTN72pdOvAHzAuUfYP5PvwfR57ADuA3KGpJ8tf3rZ79PLbgM+lP75f4E9aEFiI9BN+u9rjL/zvHT5JfCpY/j/0DykrCVT/f9KvdRLvdTrSC9Vg6UoynQya8jPFgAhxH8PqdXIDBxxLVAKtKHd1PWg3ZwuBN4zIs1PSyk3ot3IgvaEHeDz6fd30W6KM0/vr8/UXKRJtBvdm6WU35das6ub0YK5EFpwBHD+eAoopWwHXke7GV8vhFiCVluwT0r5JmBMb9qGFlzdgtb0q3uMpH8spbwGuHdEOa8FSoBNUsoPSikvBLahBakfG5HGN6WUV0kpRy7/lpTy+nS+AZ5PH+sXQ48lpXwBrfaiHQgC+9Prx3VuRrhZSnkD8Mn05+vS77cMyev1aMFCArhICDGfQ+dvJ1oQ+AnS3ysp5X1owSHAg1KrtXmTCX4XRsnzRM91Js92tAcGd0spZ6PVUI3mvWjBYwKtSeAP0GqDBtLl9AAvA61H2D8TgP4u/aoB/oND352q9HtgyD7B9Hs1WvD4Q2A1WvPdG4FPo/0dvpauwWsTQvxMCFE4yvHL0GqpQXsgoCiKMqOoPliKokwnvUN+bkDrE/Jq+uerh6xrTr8v4lBzpYy5Iz6/m373pd8zN3yZNN6XfmUItOaIGS6p9bXRVgrxcUZvflU5yrIj+QVwNnAlh8r8WPr9ObSb52uBl9LL3kZrtuU4SppjlXPvkG33od18NzHca0dIO7NvJu1M4ORPvxcACCHuAb45yv7Hcm5GHnNf+r0i3RSxeeh6KaVHCOFBu/FvQjuPG4APA1ehBRPPCyE+IqXMBAkjZdI8pu/CUdI5pnMtpdwrhPgaWqD3DwAhxH7gcrRAaKRKtCC2Eq0W629Syn4hxEtoZQatb1byCPl8RUq5LPNBCPEptJqzjwJfQqs9hEPfoaE/O6WUEq0P1r+l958H/AQ4F63WMYB2/l9C+85+ecTx+9J503P4eVEURTnlqRosRVGmk9c4VMNwjxBCSCn/AnxnxHaW9PvvpZQi80J7Ev/TEdsm0u8jh03PpPFvI9KYI6UcelMbHbHflen3H6Pd3GY+i6MXbZjfoDWr+mh6/xTwq/Q6PVotTQlasPgYWk3BTWOkOVY5Fw5ZlunbM7L2YGRZM0beqB/pxj1zLr6C9gDvC+nPx3JuMjKBcybfHilllBHlSfdNy4ya1wUkpJRXAkXpNJ5HC5oyI1Bm8j70+pdJ81i/CyMNy1vamOdaCKEHviGlrEALOL6V3u/2IxzHk97OnU7n4nQftPPT6f0rWnPNLUfYf7YQYrTfSSr9vi39vkZo9EBmVMDth+/GA8AvpJRb0YLJbVLK3WhlPqwWTUoZRhuYA+DfhBDFmXVCiEJxaLTCGiHEQiHErJFpDNl+zG0URVFONlWDpSjKtCGlDAkhPsehpl1nCCHeQOvfMdTjaE/aPyKE+Afaje0c4DxgHodudI/mIbT+PN8SQpwFhIHlQDnawAFHknm6fzFa066Lx3GsYaSUvvTACx9Dq4V4UUppTa8+G63P2Ga0YPOc9HLfyHTG6Vdo5+o9Qog/odVsrEQrx9MTTPNIMufmGrTg8NLjSOvHQohL0Pr7APwy/f4Q8K/Al4Q2nPcqtGvZ/0opDwghNgohvoBW6xcAMjU1mfNnRauVui+d/veY+HdhpIme6wbgDSHEK2g1mmP9zl8CPoPWD/AnaDVfn0+XrQFtdL/vyyOP5PcfwDlCiNfRvsMfSS9/PP3+R7SatyVoNWq56XTflFK+NDQhoU2dsAr4eHrRPuCGdJC0Cq2f22huR6udXgTsFkI8D+SjNfH9JFrfuf8CrkdrAnmk0RrHs42iKMpJpWqwFEWZVqSUT6IFSn9Bu6nbCCxFu9G7Kb2Nfcg2rcD/Qeun9BDa0/3xHOevaDeW29Furi9De4L/gzF2/TraDW4l2g3kaE3ixuMXQ35+bMjPPWhNIy9Au9HMjKz48EQOkj5X70FrengOWm3Ys8B7pJR9R9t3Am4HtqIFMHOA0fopjddXgfVoN/e/ID0ynZTyWeAKtL5vl6MN7f1jDtWe7Uf7DlyM1jcoBvwn2ncFtH5GbWjDjf8bUHUc34VhjuNcD6KNnHcO2u+8Fm0AjP88wvYPop3jp9C+jzcD96D9HXwZeK+U8s6jHO8PaE33PogWBHcCd5L+LkspU2jn4S9oAf8ZaH21PjI0kXT/tPuBe6SU/enFN6N9hy8D/g58Y7QMSCn3oP39/Dy96Gq0JoabgB1HybuiKMq0J7Sm1IqiKIoy9YYMZNIipbRMZV6mMyHERWhBTxJtNL9etMEp/gVtAI//O4XZUxRFOa2pAEtRFEWZNlSANX7pwSW+gtbHrAyt9u6HwM+kurgriqJMGRVgKYqiKNOGCrAURVGUU50KsBRFURRFURRFUSaJGuRCURRFURRFURRlkqgAS1EURVEURVEUZZKoAEtRFEVRFEVRFGWSqABLURRFURRFURRlkqgAS1EURVEURVEUZZKoAEtRFEVRFEVRFGWSqABLURRFURRFURRlkqgAS1EURVEURVEUZZKoAEtRFEVRFEVRFGWSzJgA6/3vf78EJvTavHnzhPedjq+ZUp6ZUo6ZVJaZUo6ZWJ6ZUpYh5ZiR1LVqZpVnJpRhJpZnppRjppVlJpVnrGvVjAmwPB7PhPeNRqOTmJOpN1PKM1PKATOnLDOlHBkzqTwzpSwzpRxHoq5Vh8yE8syEMgw1U8ozU8oBM6ssMHPKM1Y5ZkyApSiKoiiKoiiKMtVUgKUoiqIoiqIoijJJVIClKIqiKIAQ4mdCiF4hxK5R1t0phJBCiIr0ZyGE+KEQok0IsUMIccbJz7GiKIoyHRmmOgOKopze4vE4NpuNSCRy0o9dXFzM3r17T/pxT4RTtSwmk4n6+nqMRuNUZwXgUeBB4LGhC4UQDcCFQPeQxf8KzEu/1gH/L/2uKIqinOZUgKUoypSy2WyYzWaam5sRQpzUY/v9fsxm80k95olyKpZFSonX68Vms9HS0jLV2UFK+YoQonmUVfcDdwN/HLLsw8BjUkoJbBFClAghaqSUjhOfU0VRFGU6UwGWoihTKhKJTElwpUw9IQTl5eW43e6pzsoRCSE+DPRIKbeP+I7WAdYhn23pZYcFWEKIm4GbAaqqqti0adOE8hIIBCa873Q0E8ozE8ow1Ewpz0wpB8ysssDMKU+mHBs2bBh1vQqwFEWZciq4On1N59+9ECIf+BJa88AJk1I+DDwMsHr1anmkC/JYjnYxPxXNhPLMhDIMNVPKM1PKATOrLDBzyjNWOVSApSiKoiijmwO0AJnaq3rgHSHEWqAHaBiybX16maIoinKaU6MIKopy2nO5XFx99dXMnj2bVatWcdZZZ/H73/9+yvLz6KOPcsstt5yw9L/5zW9OaL+bbrqJPXv2THJupi8p5U4p5SwpZbOUshmtGeAZUkon8CfguvRogmcCA6r/laIoigIqwFIU5TQnpeTSSy9l/fr1dHR0sHXrVp588klsNtsJPW4ikTih6R/NRAKsZDLJI488wuLFi49pn1OJEOIJYDOwQAhhE0LceJTN/wp0AG3AT4DPnoQsKoqiKKcAFWApyhii0SiDg4N4PB6cTid2ux273Y7T6cTj8TAwMEA0Gp3qbCoT9OKLL5KTk8OnP/3p7LKmpiZuvfVWQAsS7rrrLtasWcPy5cv58Y9/DBxqf3355ZezcOFCrrnmGrQB5WDr1q2cd955rFq1iosuugiHQ6vY2LBhA7fddhurV6/mBz/4AX/+859Zt24dK1eu5L3vfS8ul+uoeb333nu59tprOeuss5g3bx4/+clPAC1I/MpXvsLSpUtZtmwZTz31FAAOh4P169fT2trK0qVL+ec//8kXv/hFwuEwra2tXHPNNQD86le/Yu3atbS2tvKpT30qGxgVFhZy5513smLFCjZv3syGDRt4++23AXjiiSdYtmwZS5cu5Qtf+EI2jyP3+eIXv8jixYtZvnw5//7v/358v6wTTEr5cSlljZTSKKWsl1L+dMT6ZimlJ/2zlFJ+Tko5R0q5TEr59tTkWlHGR0pJJBJhYGBg1OuZ2+0mEAgQDodJpVJTnV1FOaWdlD5YQggT8AqQmz7m01LKrwkhWoAngXJgK3CtlDImhMhFm4dkFeAFrpRSWk5GXhUlcwHy+/0EAoFxP4XX6/UUFBRQVFREcXExJpPpBOd05mn+4rMnJF3Lf3/giOt2797NGWcceY7Yn/70pxQXF/PWW28RjUY555xzuPBCbcyDd999l927d1NbW8s555zDa6+9xrp167j11lv54x//SGVlJU899RRf/vKX+dnPfgZALBbLBin9/f1s2bIFIQSPPPII3/72t/ne97531LLs2LGDLVu2EAwGWblyJR/4wAfYvHkzO3fuZPv27Xg8HtasWcP69ev59a9/zUUXXcSXv/xlkskkoVCIc889lwcffJBt27YBsHfvXp566ilee+01jEYjn/3sZ3n88ce57rrrCAaDrFu37rA82e12vvCFL7B161ZKS0u58MIL+cMf/sCll146bB+v18uNN97Ivn37EELg8/nG/mUpijIppJQEAgEGBwcJBAKEQqExA6eenh727NmDEAKTyURhYSFms5mioiL0ev1JyrminPpO1iAXUeB8KWVACGEEXhVC/A24A7hfSvmkEOJHwI1okzXeCPRLKecKIa4CvgVceZLyqpyGEokEXq8Xr9dLOBwGtJqrUChEJBIhGo2SSCRIJBLZWgohBAaDAYPBQG5uLiaTiWAwyODgIDabjby8PMrLyykvL5/KoinH6HOf+xyvvvoqOTk5vPXWWzz33HPs2LGDp59+GoCBgQEOHjxITk4Oa9eupb6+HoDW1lYsFgslJSXs2rWL973vfYBWA1ZTU5NN/8orD/0rs9lsXHnllTgcDmKx2Ljmgvrwhz9MXl4eeXl5vOc97+HNN9/k1Vdf5fLLL0ev11NVVcV5553HW2+9xZo1a7jhhhuIx+NceumltLa2HpbeCy+8wNatW1mzZg0A4XCYWbNmAdpDg49+9KOH7fPWW2+xYcMGKisrAbjmmmt45ZVXuPTSS4ftk3nQcOONN/LBD36QD37wg2P/AhRFOS7BYBCPx4PP58tes8LhMOFwmGg0SiwWG/V6ptfrcTqd2Gw2TCYTJpOJQCCA2+1GCEFRURHl5eWUlJRM69E/FWU6OCkBVnoixkD6ozH9ksD5wNXp5b8A7kULsD6c/hngaeBBIYSQmf8EijJJotEoTqeTvr4+UqkU4XCYgYEBAoEA8Xgc0G4yc3JyyM/PR6/XZ5/ipVIpEokE8Xgcv9+ffTpvMBgwm80UFxcTDoex2+24XC5isRg5OTlTVtZTwdFqmk6UJUuW8Lvf/S77+aGHHsLj8bB69WpAewr8wAMPcNFFFw3bb9OmTeTm5mY/6/X67A3LkiVL2Lx586jHKygoyP586623cscdd3DJJZewadMm7r333jHzO/LG5mg3OuvXr+eVV17h2WefZePGjdxxxx1cd911w7aRUnL99dfzX//1X4ftbzKZjvmp9dB9DAYDb775Ji+88AJPP/00Dz74IC+++OIxpacoytiklPT19eFyubJN/Px+f7YlRub2yWAwDLue6XQ6hBCkUimSySQ6nY5IJILf7wfI1mSZzWZisRgDAwMYDAYqKyuprKzEaDROZbEVZdo6acO0CyH0aM0A5wIPAe2AT0qZ6emdmaQRhkzgKKVMCCEG0JoRekakqSZvHMVMKc+JLEcikcDj8TA4OEgqlSIYDOL3+4nFYgghsjUEubm5476AxONxotFo9kmhlJKcnBzMZjM6nY5HH32UkpISysvLT9mmFifid1JcXJy9mJ9syWSSNWvWEAwGuf/++7npppsA6O3tRUqJ3+/nvPPO44EHHmDNmjUYjUYOHjxIbW0toVCIRCKRzXssFiMSiVBbW4vL5eL5559n3bp1xONx2traWLRoEclkMvtdA62JYElJCX6/n0ceeYRkMonf7ycSiRCLxQ47L9FolGeffZZbbrmFYDDISy+9xFe+8hUCgQA/+9nPuPrqq+nv7+fll1/ma1/7Grt376auro6rrrqKgYEBtmzZwkc+8hGMRiN9fX0YjUbOPPNMrrrqKj75yU9SWVlJX18fgUCAxsZGgGF5yOR/8eLF3Hrrrdkau1/96ld86lOfym6bec/05zj33HNZvnw5y5cvH/V3HYlEst+rsSZvVBTlkExg5XA4iEajRCIR+vv7GRgYQEqJ0WikpKSEgoIC8vLyMBiOftvX09PD3LlzSSaTRCIRQqEQgUCA3t5eent7KSgooLS0lEQigcvloqKigpqamjHTVZTTzUn7i5BSJoFWIUQJ8Htg4SSkqSZvHMVMKc+JKIeUEqfTidPppKSkhP7+frxeL4WFhTQ1NVFaWorZbD7uAChzo9zf308kEmH//v0sW7aMkpISDAYDtbW1VFZWnnLNLE7E72Tv3r2YzeZJTXO8/H4/ZrOZP//5z9x+++388Ic/pLKykoKCAr797W9jNpu55ZZbcDqdnHfeeUgpqays5A9/+AP5+fnZ2kqAnJwcTCYT5eXlPPPMM3z+859nYGCARCLBbbfdxtq1a7P99DL73HfffWzcuJHS0lLOP/98bDYbZrMZk8mUDc6Hys3NpbW1lUsuuQSPx8NXv/pV5s+fz7x583jzzTf5l3/5F4QQfOc732Hu3Ln84he/4Morr8RoNFJYWMhjjz2G2Wzm5ptv5pxzzuGMM87g8ccf55vf/CaXXXYZqVQKo9HIQw89lD320Dxk8j9v3jy+9a1v8aEPfQgpJR/4wAe46qqrsttl9gkEAlx11VVEIhGklNx///2j/q5NJhMrV64EZs7/L0U50fx+P1arlXA4TCQSyQ5SIYSguLiY4uJi8vPzJ5R25m+9oKCAysrKbO3VwMAANpsNo9FIRUUFyWQSj8dDdXU1VVVV6HRq7DRFARBT0epOCPFVIAx8AahO11KdBdwrpbxICPGP9M+bhRAGwAlUHq2J4OrVq2Wm4/ixmmkX9JlSnskuRzAYxGKxEIlEGBwcpLe3l3g8Tn5+PhUVFcOabk2mzBP5OXPmkJOTQ1VVFYWFhRQUFNDc3HxKDYZxogKsRYsWTWqa45UJsE4V9957L4WFhaOOxneqlWWood+BId+xU+vpwzipa9UhM6E8U1GGRCKB1Wqlr6+PWCxGb28vfr8fvV5PWVlZ9kHeRLz99tvZ5tGjydTse71eIpEIOTk5VFZWUlRURG5uLg0NDRQXF0+0aJNmJny3MmZSWWDmlGesa9XJGkWwEohLKX1CiDzgfWgDV7wEXI42kuD1wB/Tu/wp/Xlzev2Lqv+VMlFSyuwwtPF4HKfTSSAQyF4MCgsLT+jxCwsLqa6upqGhAafTidVqpaioiKqqKvbs2UN9fX12UAFFURRFORKfz0dXVxfxeByv14vHo/WcqKyspLS09IQ3P88MdlFUVITf78ftdtPT00N/fz/V1dW0tbVRVlZGQ0ODajaonNZO1re/BvhFuh+WDviNlPIvQog9wJNCiP8E3gUyc478FPilEKIN6AOuGi1RRRlLNBqlo6ODUCiEz+fLzjNUVVVFaWnpSW2iV1hYyJw5c7IXxWAwSG1tLVarFb/fT3Nz8ynbN0s5OcYzCIaiKDNPKpXCZrPhdruJRCLY7Xai0Shms5nq6upRgxkp5Qm9xpnNZgoLC/H5fPT29tLZ2UlFRUW2lqu5uZmioqITdnxFmc5O1iiCO4CVoyzvANaOsjwCfOwkZE2ZwQYGBujs7MyOFOj3+ykoKKCmpmbKRj4SQlBRUUFhYSF2ux2r1UppaWl2GN05c+aQl5c3JXlTFEVRpp9oNEp7ezvhcBiPx4PH40Gv1x+xBUYqlWL37t0EAgHmzp2bnU5hqP7+frq7u6mrq6OiomLCeRNCZPsuu1wu3G43fr+f2tpaDh48SHV1NbW1tadcf2NFOV6q/laZkRwOB3a7nUgkgs1mI5FIMGvWrGkzJ5XJZKKlpQWXy5UdCKO+vp59+/Yxe/bsadGGXVEURZlag4ODdHR0EI1GsdvtBIPBI9ZaZYZjt9vtWF1e+sMpgpE9FJhy0Ol0NDc3U1VVRTQaZc+ePTgGo3j6fDTW12avR21tbcybN4/i4mIGBgbIz88f1wNJg8FAXV0dRUVFOBwOOjs7qa6uBrT+z7Nnz1ZNBpXTivq2KzNKKpWiq6uLvr4+fD4fTqcTg8Ew7sEkpJTZkZLMZjNlZWUnLK9CCKqrq8nPz8dut9PZ2UlDQwNtbW00NjaO+tRRURRFOT243e7sKIGZB4XV1dWUlpYetm1/fz/vbt9BMqVNMtobkpRX12Fz2WEwhEEnCIT3ZefFcgdiRHUmrP4ooU4bTqeTcDyFfSDKrl27KCkpwdnroTDfxIoVK8Y9GJPZbCYvLw+73Y7D4SAUClFdXc3evXuZM2fOhEc1VJRTjQqwlBkjkUjQ3t6enbPD6/WSn59PXV3duJ6cJZNJdu3ahcvrI5xIUWIysHrVGSdsdMGMoqIicnJysNlsWCwW6urq6O7uJhaLUVdXN3YCiqIoyozS09OTHZDJZrOh1+tpamoa1oS8r6+PAwcOUFVVhcvlwhVMEhdGUskkdS3zKCmvYFZNPclUEp/Xjc1mwd9uBWAgJpi3bAmJRAJ7Vwc+3yAp9KRMRfQMROkLuXGHEhRHkuh27qS1tXXcTesNBgONjY14PB7cbjfRaJT6+nr2799PS0sLJSUlJ+ScKcp0oiYsUGaEeDzOgQMH8Pv92Gw2vF4vpaWlNDY2jhpcJRIJ9u3bx5YtW+jo6MDr9bJ3715svf04woKQLh93UEszkUhwogexNJlM2Vq2np6ebO1bd3f3CT2uohFCcOedd2Y/f/e73z3pA0ps2LCBiQ7fPZZt27bx17/+9Zj3s9vtXH755ScgR4qijEZKicViwel00t/fj9VqJTc3l5aWlsP651osFqz9Ifa2d+EeDCNzCli4YjVLVp1JSbnWr0qn12M05lBZXUfj/KXoSmrQFVfTtGAxxpxc8vILmLNoGQ0LljF/+Spqm+agKywjIPKYvXA5EX0ejv4AnZ2dx1yWiooKGhoaiMViWCwWgsEg7e3t9Pb2Tsq5UpTpTNVgKae8aDTKgQMHss0oQqHQqP2tkskk7e3thEIhYrEYroEQvkgS12AXOTpBIiXpiwpmL1qKMTeHAzvfxekdYOC11zDl5jJ37tzj6gw8lsxTv56eHhwOB4lEAtCaPTY3N5+w4yraBL7PPPMM99xzz4R+x4lEYlr3L9i2bRtvv/02F1988Vz2eG8AACAASURBVLj3SSQS1NbW8vTTTx/TPtP5PCjKdCalpLOzk/7+ftxuNx6Ph8LCQurq6g6bwNfv99M/4CeY0BHBQCqZYPaieUcdTKKwqJjCotH79xYUaqP9CZ2Oprnzs8sb5yygffc27A4ndXV1x9yio7CwkObmZqxWK11dXdTV1WG1WonH46qFhjKjqRos5ZQWiUTYv38/oVCI7u5uwuEwtbW1hwVXUkr27t3LwS47u219tPUGGEzlUDN7IamCCvx6M7G8MloWLsWUn49eb6BxzgI8cSMdviTt7hDbdu6mvb39hJZHp9NRX19PUVERbrcbt9uN1+vFYrGc0OOe7gwGAzfffDP333//YessFgvnn38+y5cv54ILLsjWKm7cuJFPf/rTrFu3jrvvvpuNGzfymc98hjPPPJPZs2ezadMmbrjhBhYtWsTGjRuz6X3mM59h9erVLFmyhK997Wtj5q25uZm7776bZcuWsXbtWtra2kbNl9WqNf357W9/y9KlS1mxYgXr168nFovx1a9+laeeeorW1laeeuopgsEgN9xwA2vXrmXlypX88Y/aFISPPvool1xyCeeffz4XXHABFouFpUuXAtrf2ic+8QmWLVvGypUreemll0bdx+FwsH79elpbW1m6dCn//Oc/J/6LUZTThJSSjo4O+vv7cblceDweSkpKqK+vPyy4Aq12eSCaoqyyigXLV7FgxWpMeZPfv8mUl09JRRXeUGJCtVigPcDKtNCw2Wz09/fjdDrp6uo64a1DFGWqqABLOWVFIpFszVV3d3e2nXdxcXF2JCWXy0UymWT//v1YnR48EahuWUj1nEXMXbyC4tJy6lvm0bJgCY1zFpBXcGjI2wJzEQtXrGLZmrMpq2vG5k/R2W2jt7eXcDjMwMDACbk4CCGora2lpKQk24bd6/XS1dU16ceaju69916EEON63XzzzYftf/PNNw/bZrxN/T73uc/x+OOPMzAwMGz5rbfeyvXXX8+OHTu45ppr+PznP59dZ7PZeP311/n+978PaB3NN2/ezP33388ll1zC7bffzu7du9m5cyfbtm0D4Bvf+AZvv/02O3bs4OWXX2bHjh1j5q24uJidO3dyyy23cNttt42ar7vvvhuA++67j3/84x9s376dP/3pT+Tk5HDfffdx5ZVXsm3bNq688kq+8Y1vcP755/Pmm2/y0ksvcddddxEMBgF45513ePrpp3n55ZeH5eGhhx5CCMHOnTt54oknuP7664lEIoft8+tf/5qLLrqIbdu2sX37dlpbW8d1/hXldJUJrjJNw/v6+igtLaWmpmZYjVQymcTpdLJ7925cvb0MRlOUzapGCIFef+JqjmfVNRBICJxuL16vF9BGBty+fTvbt28nlUqNmUamhYbZbMbpdGaHm7dYLCrIUmYk1ZZDOSUNbRaYmdW+oaGBgoICwuEw+/btw9k3iE5AYa4BXziOOyxpnr+EAvOxT3xYUV2L0OlwWjvI2b+fZEoST0rKi7XmD5M9/LsQgpqaGgA8Hk/2IqvX66mvr5/UYymaoqIirrvuOn74wx8O6+uwefNmnnnmGQCuvfbabCAD8LGPfWzY5NAf+tCHEEKwbNkyqqqqWLZsGQBLlizBYrHQ2trKb37zGx5++GESiQQOh4M9e/awfPnyo+bt4x//ePb99ttvHzVfd911FwDnnHMOGzdu5IorruCyyy4bNb3nnnuOP/3pT3z3u98FtIcVmZq5973vfaOOnvnqq69y6623ArBw4UKampo4cODAYfusWbOGG264gXg8zqWXXqoCLEUZg8ViyQZX/f39lJWVUVVVNWwbr9fLvn37GAjHCcRShBMSc1kFuaYTP2+i0ZhDZV0jbkcXbW1t+P1+urqtuINxCow6Kp1Oamtrx0xHp9NRV1eHw+HA7XZnAzMpJS0tLWquLGVGUQGWcsqJxWLDaq7i8TiNjY3k5+eTSCTYuXMnVm+AoDSCBG8oSkJnZPaixeTlT3xEwPJZ1QQGfNgG+oilBEKvpy88QP/ALirKiqmoqMBsNk/qHFY1NTVIKXG73dlmIgaDITu/iDK5brvtNs444ww+8YlPjGv7kf0RcnNzAe1GIvNz5nMioTWx+e53v8tbb71FaWkpGzduzNYCHc3QG4+xbkJ+9KMf8cYbb/Dss8+yatUqtm7detg2Ukp+97vfsWDBgmHL33jjjQmNmjl0n/Xr1/PKK6/w7LPPsnHjRu644w6uu+66Y05TUU4H3d3d9PX10dvbe8TgyufzsWv3HmwDcXR5BZTVVVFrLj4pwVVGRVUtPo8b92AYj9+CJ5Qkt6CIvpCf7u5uqqurR23KOFKmhYZOp8Pr9WZrr4QQNDc3qyBLmTFUE0HllJIZLTATXMViMRoaGrJzaxw8eBCXL0hUn8/8pStZsPwMKpvmM29J63EFVxkNs+dR3jCHecvOYOGK1RTVNNETggP2PrbuOchb72xj27ZtuN1uksnkcR8PtCDLbDbjcrkYGBigp6cHj8czKWlPR/feey9SynG9Hn744cP2f/jhh4dtcyyjAZaVlXHFFVfw05/+NLvs7LPP5sknnwTg8ccf59xzz51w2QYHBykoKKC4uBiXy8Xf/va3ce331FNPZd/POuusUfN19tlnA9De3s66deu47777qKysxGq1Yjab8fv92fQuuugiHnjggezNzbvvvjtmHs4991wef/xxAA4cOEB3d/dhARpAV1cXVVVVfPKTn+Smm27inXfeGVcZFeV0k6nJ8Xq92ZFvRwZXkUiEXbt20TMYp6C8irmLV1BWWX1SgyvQAqD6lrl4IjBIHo3zlzJ74VLIzaM/EKGjo4NYLDbu9DLzefX19eFyuejr6zttmsErpwdVg6WcMpLJJG1tbYTDYaxWK7FYjPr6egoKCrKjL9kcvfRFYc6SBejTo5llhqudDDq9nrLKQxfAyuo6yiqq8PV5iISC9PR56Av34fAOYM7Vs2TJklEnhTwWQojs3FgOhwO9Xk93dzc5OTkUFR17c0fl6O68804efPDB7OcHHniAT3ziE3znO9+hsrKSn//85xNOe8WKFaxcuZKFCxfS0NDAOeecM679+vv7Wb58Obm5uTzxxBOj5uuBBx4A4K677uLgwYNIKbngggtYsWIFjY2N/Pd//zetra3cc889/Md//Ae33XYby5cvJ5VK0dLSwl/+8pej5uGzn/0sn/nMZ1i2bBkGg4FHH310WC1dxqZNm/jOd76D0WiksLCQxx577BjPkqLMfF6vF7vdjs/no7e3l6KiolFbJnR2duIOxjGaS6ltmj0FOT0kr6CQxWesG1bLVF3XRE/7XhKdNuxOJ63Ll4/7upQpb19fXzZNnU5HY2Pj5GdeUU4yFWAppwQpJe3t7QSDQWw2G+FwmPr6egoLtUEp9u3bR7e9F0cwSf3s+Sf16Z7eYKB8lnahqGloxut20u9x4xsIYTxwgNWrVx/3MYQQ1NfX093djc1mo7m5mfb2dhYuXHjY3CjKsQsEAtmfq6qqCIVC2c9NTU28+OKLh+3z6KOPHvFzc3Mzu3btGnXdyP0yNm3adMT83XXXXXzrW98atmxkvjI1VJl+WUOVlZXx1ltvDVv24x//+LDtNm7cOGzEw6HlMJlMowaXI/e5/vrruf76649YFkU53fn9frq6uggEAjidTgoKCkbtw+Tz+bC7ehmIwbz5s6dF87mReSgqLYO5i3E7bET9fqxWK0uWLBl3etXV1Ugp8Xq92SaGer1eDeGunPJUE0HllGCxWPD7/djtdoLBYLbZHIDL5cLq6MUZljTNX0xx2Ymbq2osOr2eyuo65i5ZQcqYh9cfpqenZ1LS1uv1NDQ0YDAYsFqtRKNR2traiMfjk5K+oiiKcmJFIhHa29sJh7VrQ05ODnV1dYcFLuFwmP379+MJJqmoriNnlNri6aKopJTGuQvwx8Dj8RKNRo9p/+rq6uzUJJkh3NVkxMqpTgVYyrTX09OT7QQ8ODhIZWUlJSUlANmBA9yhJNUNLRQWlUxxbjVCCGobW/CEknR1dw8bMel4GAwG6uvrSaVSWK3W7MV6MtJWpieLxXJCJ7hWFOXkyEx2H41Gsdls6HQ6Ghoaho1ECtoQ6Nu2bcPaFySVW0Bl9fSvzTEaczCXljEYTeJwOI5p38zAF4WFhTidTgYHB7FarfT395+g3CrKiacCLGVa83g82aFrM52Ah95sdnV14fFH0JkKKK2YNYU5PVxhUQnm8llY+qN09jh59913hzU9myiTyURdXR2xWCxbo3eqdw5W86CcvtTvXjkdZOa6CofD2Gw2EokEDQ0NGI3GYdslEgn27NmDtT9MMreIlgVL0I0IwKar8lnV+KIpnE7nuEZHHSrT1zgvLw+73U4oFKKzs3PY4DyKcipRAZYybQWDQbq7uwkEArhcLsxm87ARlrxeLxarDU84RW3j9GifPlJ9yzxqZy/CLwro7B3g7XfemZSncoWFhcyaNQu/34/b7c6OxHQqMplMw4brVU4fmb4XJpNpqrOiKCeUw+FgcHAQp9NJOBymtrb2sO+93+9n7969OPoDxA15NM9bdEInEJ5shUUlGPIK6ekPsW3btuzk5eOl0+mor6/HaDQOa6FxrMGaokwHp85frnJaiUQiOBwOSkpKsNls5ObmUltbmw2iIpGINplwIEllbSP5heYpzvGRFZWWUT97AcIANp8X4759rFq1ipycnONKt6ysjGg0isfjITc3l56eHvLz87N9004V9fX12Gw23G73ST92JBKZMTf3p2pZTCaTmjxbmdF8Ph8OhwOfz4fP56O8vHzYSHtSSvbs2YOj10MglmIgLpi7ZNEpU3M1VMv8JVgO7qW7z09y2zZWrFiRHYxqPAwGA42NjVgsFqxWK83NzbS1tbFw4UIMBnXLqpw61LdVmXYyw7HH43FsNlt2cIehkxh2d3fjDsTIKSyhsmb6t0/X6fU0zJ5D5/7duAb97N+/n6VLlx53rVt1dTXRaBS73U5ubi4dHR0sWrTouIO3k8loNNLS0jIlx960aRMrV66ckmNPtplUFkWZKaLRKBaLhXA4nB0xsLKyctg23d3d2JwenCFJcUUVs2dVk5N76j0sAW1U3ZYFS+hu24fN50Nu20ZDQwNms5loNEppaemYD4KMRiMNDQ1YLBZsNhuNjY20t7czf/78adlSRVFGo5oIKtNKpp16JBKht7c320596JOrSCSCw+nCF5XUNLYc9z9cKSU9/gTtfXFiyRPXTE0IQcPseQzEddjdfVit1klJs76+Hr1ej81mIxqN0tHRoZrbKYqiTLHM9SwWi9HT04PBYBjWEgO0fsbtnRacwQQNcxdQ1zQbU17+FOb6+Ol0OhrnLkRvLqOzP8qO/Z28+e5O3tm9n127dpFMJsdMI9PXOBwOY7fbCQQCp3xfY+X0omqwlGmlp6cn2049Go2O2k7dZrPhiyQwl5Yf13xXyZRknyfOW/YozqD2D18vYGV1Luc1mTDqJ/9JmTEnl/rZ87G17SGn00IgECAYDJJIJMjNzWX+/PnH1JwCtCYVIycittlsNDQ0THr+FUVRlPGx2WyEQiEcDgeJRIKmpqZhDwtdLhd79u3H4U9SVt2Aufj4JqWfTnQ6HU1zFxIY9OHtdRKMx4nFIuAL0NnZydy5c8dMw2w2U1lZidvtxuPxAJCfn8+sWdNrQCtFGY0KsJRpIzNQQ39/Pz6fj+Li4sPaqXd1ddFt66E/nGLO7IkHEJ5Qkt/sCTAY1Wp68gyCYpMOZyDJ244oFl+cZVU56ITANpigMEdQW2hAr4OKfD0V+RNvG19UUkpZdT2O3h68ISfhhCSZgnxjmEBoGwvmzRs2mMd45OfnU1lZSW9vL319fYB2ccoMZ68oytiEED8DPgj0SimXppd9B/gQEAPagU9IKX3pdfcANwJJ4PNSyn9MScaVaWdgYCD7/9jv91NVVTVsUvhQKMTeffuxDcYpqaqnur5xwsfyhpKUmHTodeN/KGj3J/DHUlQV6Ckxnbi+XoVFJdnpU8LBAB17d2Cy9SClpLGxkdwx5veqqKggFovhdrvJzc3FZrNhMpmG3RsoynSkAixlWgiHw3R1dREKhXC5XBQWFh4WHLS3t9PW1YMzkKCyrglT/sSaUfgiSZ7cHSAQk5Tn6VhTm8uSyhyMeoEzkOBP+0N4wilesgwfuWgrMQAEsKHJxNq63Ak3T6yqa0RvMCAQzCoqxmAw4LR20d3vIbJ7HzW9vSxcuPCwIXyPpry8nHA4TG9vL3l5eVgsFhYvXnxK9cdSlCn2KPAg8NiQZf8L3COlTAghvgXcA3xBCLEYuApYAtQCzwsh5kspx27/pMxo8Xgci8WSbepuNpspKysbto3NZqM/kqSgdBbV9U0TPtau3hh/ORhicYWRSxYUjLqNoz9AJBhEn4oSi8UYiAqe95Uh0a5fZ9fnsr5p4q1BxiuvoJCq+masNguBmA2v18vq1avHHLyiuro628zSaDTS2dl5yvU1Vk4/KsBSplxm8sWh/0Bra2uHDTsei8XocThwBhI0zl884aYUrmCS3+3VgquGIj1XLC4c1hSwutDANYtz2dHjxxHWgdBRb9YRxYgnnCKeknT0J3ipK0Jbf5xVNbn4IimKc3Usqhz/P3shxGGTRzbMmU+fuxiH1ULU4SE3t5P58+cfU/mqq6uxWCz09PTQ0tJCR0cHCxYsUB2DFWUcpJSvCCGaRyx7bsjHLcDl6Z8/DDwppYwCnUKINmAtsPkkZFWZxiwWS/Z6ptfrqa6uHrY+FovhcLkYiKSYM3d8gzRFEimSKSjIOdR1PhRP8XxnGIA9njjLq+I0lxjxhZM8+dp+Yva9eF0OTOuuRErBwGu/J+7uomjdRzE1lJPwe9EXlPC6LUqd2cCcsvE/0JuoiupaCotLsLYfwO2P0NXVxZw5c466T2b49s7OTmw2Gy0tLbS3t7NgwYJhg18pynSiAixlynV2dhKJRLDZbCSTSRobGw+b2d5utzMYTlBQUjbh4GqfJ8azB0PEU1Br1vPhObl4e11U1wy/+HW2H+S3P/3ZsGVGo5HKykpmVc1iTv1irHlzsA4msQ4emjg4zyhoLjm+C1RZZRUF5iLadr2Lw+GksbHxmIbezvTH6urqyvbHstvt1NVN/5EWFeUUcAPwVPrnOrSAK8OWXnYYIcTNwM0AVVVVbNq0aUIHDwQCE953OpoJ5RlZhv7+/sOaBg4MDGTXp1Ip7HY71l4fifwybD32MY8RTOp4sa+EaEpHqSFOU16UWTlxdgbyiSRyMYoUcanj2X0DzM2PsDuQTyyvFtlSTW5dGKE3IoCSf7macMc7mBqWIJMJfK88hqlxGYXL3sszewPk6ZPMMpigrY2DBw8ihKCluRn9CRgePSZ17Gy30mvtwGazkZ+fP+aDwGg0isvl4uDBg1RWVrJ9+/bDgteMmfDdyphJZYGZU55MOTZs2DDqehVgKVPK6XQyMDCAy+UiHA5TV1d3WJvsZDKpzSESTdHQdOyBQiIled0a4XVbFIA6Y5DEOy/w9V/uJD8/n6/f+3UY8n+9pPjwfkvxeBy73Y7dbod3tyGMuZQsOY+C+vnMqijHFpD8rS3MjSsN5Bzn4Bi5pjyKSivoD3mxWq3MmzfvmPbPy8ujoqICt9uNz+cDoKio6JSbH0tRphMhxJeBBPD4se4rpXwYeBhg9erV8kgX5LEc7WJ+KpoJ5Rlahkgkwt69eykrK8NqtVJWVjasP20wGGT37t3kFpZQpDPTtGAZBeaj9yWKJyW/3BkgmtJanvYnjPT7Dz3IEzLJGUYbB/Qt9EcMvOvXBkkypcJEdHkIUwGJPhuG6CCiZjH589YBoHPuwZwj8B/cwoLV6+mJ5hBIGggkC1ldVsU77zyF1+OlsLCQM888k7PPPpuS0snt01tcmEdy0E08pV1jlyxZQnFx8VH36e/vx+l0UlFRQWVlJY2NjYcNew8z47uVMZPKAjOnPGOVQwVYypTx+/309PQwMDBAf38/ZWVlo3Zc7e3txReMojcVjnkxyuj0xdnhiiElWAcTBOMSpCS6/2Xe3fXKoTwM+vF4PVRUVGSXFZcUU1FZgUxJEok4sViccDg8LH0Zj9K/7Tmk5U1u/dKX+OXuEL3BFH9vC/GBefnH1Nl4NJW19bTvctNjd2QnYj2WZn4VFRWEQiGcTid5eXl0dnayePFiNVGjokyAEGIj2uAXF8hDcyD0AENH2qlPL1NOQ1LKbNNAh8NBbm7uYaPdHTx4kG5vgKjORP2c5jGvZ1JK/tYWojeYpNSk4+qlhdj8Cd6whnAFEkR69hPc/zpvmSQbP3cn23ujhOKS6kI98/NhS2c/fkMx71+1CHOuDosvwcH+OJG45MJ1/4LpivWkkkmklAzEBbt6Y7xui/Jcmx+vVxssKRAI8Pzzz/PCiy/Q2trK+9///lEDmomoaWjB3iWxDw5gDEUQe/ZwxhlnHHXgi9LSUsLhMB6Ph7y8PKxWKwUFBeRPsE+2opwo6m5LmRLxeJyOjg6i0SgOh4O8vLxRh16VUmK1WumPpKgco/ZqkyVM10CCPIOgw5cYti4x4MK//TnivZ3DlldVVeH3+4cFWGazmS996UvDtguHQvT2unG6nLS3tbFv334CgQBnnnkmRqOBi+fm8/jOAHs8cQbDA6yYZWDerHxMhom1Dzfl5VNe00CX00r0QAd+v59FixYdU5BVW1tLR0cHdrud5uZmuru7mT179oTyoyinKyHE+4G7gfOklKEhq/4E/FoI8X20QS7mAW9OQRaVacDlchEMBnE6nSSTSRoaGob9v3a5XPT2DRBMGViwdDl6/di3X2/ao+zxxMnRwWWLCsgVCbq3vsS+l14iFo1lt3MCfqeF980d2pfJxL+OqHFqKTXSUjq8Gbsu3Ry/zABnN5jY7gjhi+tZ+sEbsP3zd9lWEDIlefedd9m+bTtr163lwgsvPO5RavUGAw1z5iOlpHP/bhwDfvbu3Utra+tR96uuriYSiWC327N9jRctWnRY1wJFmUoqwFJOuqGTL9psNvR6/ag1NFJKPB4P/YEwSX0uxWXlR0xzryfGlp5o9rNOQF3Sxf5tbxAd7CfuOTRBYUlJCatXr2bV6lXjHg49Lz+fpuYmmpqbWLduHTIl6enpyTaZqC408PGlhfx2TxBbUGLrTGDo8LKxtZiKwomNdFRd30h+oRlbx36kw01OTs645g7JMBgM1NTUYLPZcLvdCCHwer2Ulx/5PCrK6UwI8QSwAagQQtiAr6GNGpgL/G/6f9QWKeWnpZS7hRC/AfagNR38nBpB8PSUudkfHBzE7/dTWVk5rO9sKpWis7MTdyhJdcOccQVX7X1xNqVHsv3A/HwCzm4efuLXeD3eYdvNnTeXDRs20DK75bjLYdAJWs0BXvMV05tbR+tVd1Af6eaVfXaCZfMJ7vsnkY6tbNm8ha3vbGPN+z/KxWetID/3+G4lhRA0zlnAgV3v4ukbwOfzHTV4GzroRU9PD01NTVgsljEHy1CUk0kFWMpJl5mV3eFwEIvFaGxsPKzpWldXFzt37iQajdIfTlJZ13TE2ptALMVz7VoTvrPrcykx6diz+SXefPm5YdtV11Rz0YUXsWz5suMeeUjoBPUN9cOW1ZoNvK9ikCde2kZOzTwoqeaR161cNlvHRI9WVFJK07zFdB3YjaG7J9tccLwyc2F5vVpbeqvVitlsVsPbKsoopJQfH2XxT4+y/TeAb5y4HCnTXaZpYDwex+l0YjKZDnuI5fV68QWjkJNHacWRJ8kNxFIc7Itj0Ameaw8hgTNrjex79W+88vLLZBunol3PLvnQJSxcuHBYH+LjVZMb57KFBfz5QJA9ngT7RS3J+lr0QNHKfyUV9BH3dFOw7grajM38vy1url09i1kFx1d7ZDAaKausxue14XA4xqwdy8nJoaamhp6eHlwuF0IIent71STEyrShAizlpBocHMTpdOLz+RgcHKSyspKCguFzd8RiMbq6u3FFjej7ouiMuUe8KAViKZ7aHSCckDSXGDi30YQQguqzz2Dray+QTCSZNauSiy++mGXLliOOs2/UWIzJCCbXDvoOvE7pe27EUFTB090h8kN2bqgOU1R47HONFJiLqG2eR0/nfkRbOwaD4YgjJ42mqqqKYDCYbU5hsViOefh3RVEU5XA+n4+ioiJcLhepVIqamprDHgb29vbijyUprZp1xAeFUkr+sD+IbfBQJegcc4o3fvMQLqczu8xkyuWSSz7M2nVrT9gQ5fPLjVy73MxLljCdvgRGnda88IA3Ttm5V5OKR8CoXcvihjx+ucPPZYsKaDnOUXTLZ1VxwGGj1+1mzpw5Yz4ILCoqIhQK0d/fT0FBATabjcLCQtUfS5kWVIClnDTxeDw7JLvT6aSgoGBY36cMm82GL5zAZC5m7jJtEsKRF5JYUrLbHWOLLcpANEV5no4Pzjs0zOusWbN4/0XvJ5lKcv7555+0wR3mzZ/HPV/8Iq++9hp/f/l35K28BGNpDZHcuTz0/F7+zxmzaGgcfw1URkl5BYl4DHtPJ/r9BygqKhr3RUSn01FXV4fFYqG3txe9Xq+e9CmKohynWCyGx+OhrKws+8Bw5LQaiUQCb18fgZikruzw613Ggb44tsEkJoNgVr6eYpOOBXoXb7rd2W0WLlzIFVdecdx9n8ZjVoGeK5cU4gokMBl0FOUK/toWZmdvDIx55MgYi1IW4lVL2OOJ8/SeIJcsyGdB+cRbRxhzcikoKWUwOoDNZhtXn+GqqirC4TB2ux2TyZTtj6UoU00FWMpJMbTfVWbyxdra2sO2i8fj9Njt9EdSlFZWkzPKaEIH++L8oy1EIK61lyjRx1khHBTmLB+23QXvveDEFGYMOr2e9evXs3zZcp5++mkOvOPj/2fvzYMku6s7388v98zKfc/K2peu3rvVarVayBLaABnZSALMZmPDgD2BjfM9kQAAIABJREFUTYx5Qcx7815MvHgzLyZixjPD8xs/21iAMCBAgBBIeCyE0cImCZDUrd6XWrJyqdz3fb3vj+xKVXVXdWX1om5J9xOR0VU37+93f7er6v7ynPM951hv+0MUrgm+/MwL3D25wO233bZpWYfTO0itWiZTTBEIBNi+fXvfY/V6PQ6Hg3Q6jclkIhKJYDabN9VjS0ZGRkbmdRYXF2m1WsRiMbRa7Zr5ralUilK9jcFkQa1Zuzpesy318q1uH9Gxz7d83jgPvv9BnvjhEzzw4APccvCWKyoH7AeP8fWPifdNG7h7XEepIWHTKVAq3EiShF5d5ZVogx+eqjDNWYY1FW666aZLup7TM0jwTIb5xRAKhYKxsbGLni+EwO/3r8rHCgaDl3RtGZkriWxgybwhRKPRDfOuAObn58lUmuhNVtrK1zejdkfi+cUap9MNCvWuYeUdUGItL/LL73+DBQWMDnr6LlrxRmC1Wfn0pz/NK6++wuPPPYnx4B+g3/IOfpaNcupb3+cTf/D7m86F8vhHOHM0RSyRRKU6Q6PRYGJioq9olsvl6v0MdDodgUCAmZmZTVUmlJGRkZHp9mMqFArk83lMJhNjY2MXPEtTqRQLCwvk6x3sQ2uXNl8qtvinsxWyta4SY6939Z7wjlvewbat27DZbVftXjaDTqVAt2LrFkJwz7genUrwq1CdM/h59dBzhEJhHrj/fb0qhf1iNFvwjU0TDszC/CIajWZNZ+xKNBoNXq+XpaUlUqkUQohVzZ1lZK4FV0fAKyOzgkKh0G0UfJG8K4BMJkN4KUa2BoOjq6UBL0fr/HapTqEuoVMJ7hrVYQ8+z88fe5hOq0mz0eQHP/jBG3VL/SPgxhtv5P137Ed95lnalTxqm4+M/1ayNWnj8eeh1mhxeAZJVdqcWIhwJpzk1KlTdDqdjZciBIODg7Tb7V5J4Xg8fil3JSMjI/O2pd1uEwqFqFarFAoFbDYbev3q/NpEIsFrR4+zkK4idCas58kDy40OT5wu8/UjJTLVDnadYCD4K0qF4uqLCa4b42o9hBDcNqLHmDgCgHHHnRztDPF3//AQ5XJ50/PZnG4Gx6aIllucnZ2jVCptOMZisWC1WkmlUpTLZRKJBPV6fcNxMjJXizfEwBJCDAshnhNCnBBCHBdC/OW54/+XECIihDh87vXeFWP+dyHErBDitBDiPW/EOmWuPM1mk0AgQL1e7+VdrSWjaLfbnD17lkSljds/glb3+mZVanT4Vagrn7h/i4HP3KDnxL88yvPPPdc7Z2h4iI997GNX/4YuEYvVwuf++AFmCofopAOg1vH9MzWy1c1XdXb5/ChNDjC5KUtq4plC35IInU6H0+mkUChQKBRYWlqiVqtteg0yMjIyb1cikQiNRoNYLIZSqbyg8W6n0yEQCBAvtzG5h5jYuvOCSM7Tc1VOppooBez3KKm/9C1e/tm/8MV/+CLVSoU3I3/63puxhV+gU6+g9U0T7Vj5whe+cEmOPJvTjdHuJl5qcurUKSRpY4ekx+NBo9EQjUZptVrMz8/3NU5G5mpwSQaWEOJWIcTOTQxpAZ+XJGk7cBD4CyHEcgLJ/yNJ0t5zr38+N/924CPADuBe4O+EEHIHuTchy8bVyryrtSRp0WiUdLFKR63H6X1dDiBJEs8uVGm0YdKmYsoi+OrDD3PkyJHeOTt37uSzn/0sZrP5stZar1Wv6sNYpVLxwQ88wGfv2oLfpKRQl/jakRKLueam5lEqVYxMzuAfm2RofJpEpc3iYrBvQ8nhcKDT6YjFYj0DWN6EZGRkZDamUqmQTCbJZrPUajVsNtsFDW7j8Xh3P1Pp8PiHL9jzCvVuOXaFgD/apuHYj77CwuxZAGLRGIcOH37D7udKotVq+dcfei/TRAAwbLuNbL7E3/yPv2FhfmHT8w2OTFCT1OQKZQqFwobnLxd0arVapNNpKpUKS0tLm76ujMyVoC8DSwjxxXMRJiGEeAT4OfCaEOLP+xkvSVJUkqRXz31dBE4C/osMuR94VJKkuiRJC8AscKCfa8lcP8RiMQqFAvF4nHq9js/nWzPvqtVqEQwGSVfbeIdW69h/Hqxx4pyX7za/koceeogzp8/03r/9nbfziU9+ou9cplw6SSq2RLlUWGVULAXnmT36KmePHaKYz17GXW+M2WjgQ9uNTNlU1FoSj58q88sXfsOrr7666bmMZgtGm5NcvU1sRSnfiyGEwOfz0el0elLBRCKx6WvLyMjIvN0IBoO0Wi2SySQDAwMXyN1rtRqLi4tkKm28QyNrOhQPx+pIwLRNyWOPfGWVAuF997+Pd7zjHVf7Nq4eAj54536sygZKnRHD1AEqlQp//8W/X+UY7QeFUonV6aLQ6PS9R+l0OlwuF5VKhVwuRywW60tiKCNzpek3gvVuIAwYgA8DR4Ei8G82e0EhxBhwA/Drc4c+K4Q4IoR4WAixLDT2A6EVw8Jc3CCTuc4olUosLS2Rz3e7sjscDoxG45rnhsNhsuUGar0Js7X7K1BvSbxSGODFcB0BvHdczXe/9iXm5uZ64+793Xt54IEH+u4Fks+kiAXOUI4HCJ8+xukjrxANBQjOnaaYjDFqVWFTNgidPUEsfHWrEGlVgvdvG2DIrKTehqcOzfHNRx7hhV+9sOm5HG4fhXqHaDTaVy4WrJYKLv+sZL26jIyMzPos5/fE43EkSbqgH2GpVOLw4cNEshUU+gHMtjXk8B2J1+INAMK/eXpVZOeDH/wgd9xxx2Wvs1IqMnfiCCcO/YbA2ZMU81kkSSIeCRJemO17n7hUhBC8Z6a7lw/suAPN4AytZouv/eM/8sILm9vjrA4XxUaHZDLZ97pXqjQajQYLCwu025uX48vIXA79VhH0AU8B2+kaZR8HPnvu374RQhiB7wOfkySpIIT4e+D/BqRz//534F9tYr4/A/4Mutrb559/fjPL6VEqlS557PXItb6fdrvN4uIi1WqVWCyGSqWiVCqtmSdULpc5OzdHsq7GMzbN7OwspZaCn2ctVDp6BBL7BvL8z298l1j09QjNwVsOMjExwezs7Jpr6LTbRIPzNGpVFEol+gET5UIOu7KG1mxEqtcp15ukQ7MIYEDVoa0fQarXaaTinFiKcObUCUxWB2qthlazSbmQR2cwYLGvXQ3qYjTqjTXX6kdNGAv6if1UZ3/LY489RmQpwg033LCp+aPJLKV4kFKphM3WX0K0JElEo1FOnz7N4OAgx44dY3h4+KJjrvXv1pXmrXQ/b5V7Wb6PK/FBU0bmStFqtYhEIlQqFQqFAk6ns6eckCSJcDjM/EKAWLGJpDMxPr3tguhVR5J4arZCuSmhrOVZOPy6sXH/A/fzjlv7j1w16nWUKiVK5esf46rlEolomFI2jdOgxD0gqDbyhM5m0BiMSLUyQkBSo8HjH0GSpKtWRXbMquKmQS2/XapjueUPqIeOUwuf4LHvPcbY2NiGlQGX0RsGUOkMFKsNMpnMmr0z18LhcCCEYGlpidHRUUKh0IYl32VkriT9GlglYC/wUaAJnAI0QN/Z8UIINV3j6puSJD0OIElSfMX7XwL+6dy3EWDlJ72hc8dWIUnSQ8BDAPv375cudUN+q23m1/p+5ubmsFgsBAIBbDYbExMTqNUXdnhvNpscOnQIk2cMt8OHb2ScfL3DT44WqXQkrKoW799pw6W3Upqf7hlYDz74ILfdfttF1xCcO82Y24LDYKfd6RbKUDj0TAy62LlzJ5Ik9crsCiGw2+2YTCYA0uk0x0+epFBtUW40aTWa6BTgdQ6Qrrbxed0MGDeX7zU7O8vU1NQFx8c7EsdezlM2u1C7xmgmA7z4wou4XW7eecc7+57fbjGSCc9jsRjZu3dv342Va7UaCwsLWK1WfD4fo6OjF93ArvXv1pXmrXQ/b5V7eavch8xbi2g0SrPZJBaLoVarVxVrmp2dZSG0RLTUwuL04hsZv0BZkSi3eT5QZT7XQnRapF56vertfffdxzvf2f/zvlTIs3jmOEKhZHB0EknqkEnGqZcLWHUKxu0ahv1+PB4PyWSS+cAiuVoFl1VDs9UmGI1QyueolAsYjBZcXj9mm/3y/5NWIITgrjEdagW8EK6jG9mFbmQXo+1I38bVMjaHm1xskdOnT9PpdHC73RuOUalU+Hw+IpEI6XQaIQQWi6VvB6SMzOXSr4H1PPABugUqnpYkqSmE2AWc7mew6LpIvgKclCTpCyuO+yRJip779kHg2LmvnwS+JYT4AjAITAO/6XOtMteQRCJBLpcjHo9Tq9UYGhpa07iqVqscO3aMpWyZllqPZ2iUjiTx+MkyhbrEoEnJTbo07oHuh/0HH3wQvUGPXqdf07hq1OsoFApUajWZZJxqLs2ITcO+vXuBbj5YvV5nenoaoGdU2e0XbioOh4ODBw70EpkbjUZ3bpUKRSxFZGGWqR17+5YmXgylQnCDV8cvQzWcN9xN9CdfAeCJJ55AoVBsaEguY3W4ScdjRHNlTp48yc6dO/vyTOp0ul4DYrPZTDgcxmKxrPkzk5GRkXk7Uq1WSSaT5HI56vU6fr+/9/yPxWJkCmWWSh2GJ7etaaj8OlLjuXONhJVSi+TPvk4rHQbgnnvu4e577u57La1mk9DcGTwDShQC4oEzqBVg0ioYsmvx+XwMDQ2h1Xb7SA4MDGA2m4nFYgwPDxONRqk2l+h0KvisakrNMkvzJ0kazHj8I5f7X7UKIQS3j+rZ6dZwJFrlpWiLRaWfk8kG21z994B0uL2Ui3kWMjmqx08ylMkwNTW1oSPRbDZTLBZJpVIMDAwQDAYxGo3y/ibzhtCvgfWndI0pFfDXQggNXSOo36z8W+nKCY8KIZbL4/wfwEeFEHvpSgQDwL8GkCTpuBDiu8AJuhUI/0KSJFlAe51TqVQIh8OUSiWy2Sw2m60XFVpJp9PhtddeI5ytUFfqGd+yHYVCweFYnXi5jVkr+ND2AcKBFZXtBNx7770XzFUuFkgshagUcijUGrbsvIF4OIh3QMmWqale3tda0aOLodFo8Pv9+P2vp/61222q1VcpJYqcPPQbjBYr/tFJVJf5sN7n0/CbSI2G2c/o7psJHn8Vlc3HU6/M0lGqeeetBzecQ6FQMDq9jdnjh4kkMhjm55mcnOzr+su5WNFoFL1eTzAY7HusjIyMzFudUChEs9kkmUxiMBh6FWtLpRLReAK1y8DQ5MyaxlUo3+L5c8bVPo+aYz/+Ts+42r//Rt773vdeMEaSJCrlInqDcZUjr1TIEw0FGFA08TnsOBwOYrEYer0em82Gx+NZ0+hY6UzU6/W02210Oh0+n49UKkUwGCRTLhM+e4xoMoNOCWabo5cTfbnY9UrumDCiUdf4ebDGE2cqhIst7hzTo0Da0FmpUCoZ27KddCJGOLRANRijUqmwb9++Da/t9XqpVqssLS0xPj7O4uLipj8PyMhcCn0ZWJIk5YB/f97h/9jvRSRJ+iWwljv9ny8y5j8B/6nfa8hcW9rtNvPz8zQaDZaWltDpdHg8njXPTSQSZEs16ko9k9t2oVR2q+n9PNjdhO4c0xMOzCN11i4dnk0lqJSK1GtV6qU8Nr0Sj1VFrNQkcPYkKqmJ3Wy+IAH5clEqlczMzCBJpyhVquQqWeZPH2NiZudlGVkGtYKb/Fp+Faqj2XUvrsk7Qdn17j0XPo751UPcsG/jnCyNVsvI1FaCZ0+gWgyj1WoZGhracJxCocDn8xEMBkmlUigUCnK5HFar9ZLvSUZGRuatQC6X60VBOp3Oqn0tHA5TbikYc3mxrFHQotrs8OSZMhJw0K/ljjE97/zTT/CNb3yDRqPBhz/8kTU/GcVCATLxJbQDRsamt6NSq4kGF8gllrDrlTiserZu3YpOp9swb/Z8VCoV27Zt630/NDSE1+slHA53K+7FF1GVk4TTcUZndiFJHdLxGB7/CDqDYVPXOp9bhrQoRLc68CvRBgpJYu6ZbzI9Pc2dd9654XiH24vRbGHuxBH0+SKlUmnd4lnLKJXK3v6WSCRQKBSkUqm+c7lkZC6VvgwsIcSz67wlSZLUf2xb5i3L4uIitVqNSCRCp9PB7/evK1GLRCLk6h2cQ4O9BN3nA1UqTYkhk5LK4jG++cgjTE1PMTY+1gvnd9ptwoFZqrk0Zq3AqBD47V0jQq/X0zh+imAhj8+oWhV5upKYzWYOHDjQkziG0iVOv/ZbtIYB/GNT6A0DG0+yBgcGdbwSbZCvS6DUIMoZOnoLWv82Hv3h32EYMDAzM7PhPEazhcGxKSILZ1DMzmEymbBYLBuOGxgYwGq1kslkMJvNBINBTCbTBf1dZGRkZN4uLBevqNVqPaeTTqcDuvmrsXiCSkeFy3vhfiNJEv/zbIViQ8JvUnLbSHecVqvlX33ykzSbLZSqC5+v1XKJTCLKiFVFrlrhzLFDaLU62tUSo1YNY6Mj+P3+vvNs+0GlUjE2NsbIyAi1Wg2fz8dsKEp4YZZ2s45JDQtnikzt2INa3b+073yEEBwc0uEzKfn2sTK/jVRJzgc5dfIUapWa37ntdzacQ6vTY7E7KZcSpFKpDQ0s6O5vNpuNbDaLyWQiFAphMpl6MkoZmatBv0kkd1zkJfM2ZzlXKZlMUq1W8fl86/alyuVyZAslGqiwOrrV+M6kGxyON1AK2K7N8Oij3wZg9uwsTz31FNA1rhbOnKBdTDNq07B36yT7d23jwIEDjI2N4fF4cFhN2HRKLHp1X0mwl4Ner2f37t1M+uyMW1WYpCqLZ0/RucRSsFqV4L5pAzMONR/ZMcBnb/UgknMIoUA7sZ90Kt33XFaHC5vHT7Lc5vTp07Rarb7Gud1ulEol0WiURqNBJHJBXRkZGRmZtw2JRIJ6vU4ikUAIsSrqEQ6HydfbGCw2NGt8UH85Wmc220KrFLxvywBKxesOR4VSiVZ34ZhOp0M4MIdDr8Dv9TLuseI3SBilCkMWNbt27mB0dPSKGlcrUSgUGI1GpqamcJr0KFo17FpwG9WYlC0Wz5685D1uJaMWNRMWBShVGLbcAsDjjz/Oy799ua/xFruDUl0ilUr1jjUajYvudW63G41G0ytWEggELuseZGQ2ot+/0k+u+FoJ7AI+A/zNFV+RzJuKSqVCKBSiVCqRTqexWq3rRkwkSSIQCJCrtbG7hlAoFORrHf55tgrATc42j3/9S7Rb3Qe4zW7jXe96F512m+D8GRT1IiN2A7t27bqguSPA+Pg45fIxRkZG3pDIi1arZc+ePbRaLQ4fPkwlUSBw9iTNRgMhYMBkweMf6Vs+OG1XM21fPlfNBw9u4bEFME0fYO+Bzcn1PP4RZvNZEvkKgUCgL825UqnE4/EQiUTIZrO9QiD9eAhlZGRk3kq0Wi2i0SilUolyubwqv6nVahGLxcjVOlidFzrzXl6q88xCV/LuzBzl5GEVBw+unUtbLZdIxaMYjCbymRSqZhmX3cDk5CRKpZJyuUyxWMRoNK6Z03w1UCqVTE5OUq4exzRgYOfOnRw5coTFdJnQwllGJmcuu7z7baMG5o+UGJg6QPXMS3TqZR599FFMJiMzW7dedKzBaKaJgnypTLlcRpIkDh8+jFarZf/+/WuuTaFQ4Pf7CQQCxONxlEoliUTiqjtjZd6+9BXBkiTpayteD0uS9L8AXwQOXN3lyVzPnJ93pdVq1827gq7HL57OU+mocHp8NNsS3z9VptaSGDMr+PUPvkKlXAHAZDZx3333Ua+UOH30VaRyFr9Fu65xBWCz2bj11ls3rUm/XFQqFTMzM7gGVCjrBdyaJi51k1Y+TmRxbuMJ1mFq0MqIWUkbBd8+VqLU6L85pEKhYHhiC6lqh2A4QrFY7Guc2WzGaDSSSCRoNpsEg0Ekae1cOBkZGZm3KtFolFarRTweR61WryrvnUgkyNdaaAfMaHX63vFkpc0PT5X56ULXaTipSHLoXx7nu9/5Lo9977ELoj/peJT5k0dRVlLkI/Mo6wWGrDp27tyJSqVCCIHRaMTn871hxtUyTqeTG2/Yy969e9Hr9ezYsYNBs4ZGIUNw9jS1auWy5veZVEzZVaBU47z594FuBO+r//iPa/bMXIlCocBsc1BqdDh79ixHjx4lkm+QLVbI5/PrjluumpvP5ykWi0QiEWq1vrsNychsir4MLCHE7ee9fg+4k25vLJm3KWvlXa1XDahUKnWbMJZb+MenUapUPDVbIVFuY9MpKL38BPFYt8+VSq3iTz7+ccrZFPHAWTy6DpMeC3v27FnXuFrmSpROvxRMJhPbZrawc3yQ/Xt3cWDfHlxGNaVsmlrl0jei398ygEOvIFnp8OixEs22RKvV6kumoTcMYPcMkqq0OXv2bN+G0nJxkFgsRrVaJR6PbzBCRkZG5q1DvV7vlWVvNBp4PJ5VUZGlpSXytQ4Ot693LJhv8dXDRU6lmygF3Opq8vIPvtx7v1qtolB0lRWSJBFZnCcZnmfIpGBmxMe2YSfjbgt79+69blQDK1t2GI1GduzYgd+sRlXLMnf8MMV89rLmv2dcj1IA7i3YxrYD0Kg3+NKXvkQymbzoWIfbS7YGs9EMoWyVSltQanRIJBIXHed0OtHpdMRiMRqNBoFAQHYiylwV+v00+jzw3IrXE3RlgkevzrJkrncSiQTZbJZEIkG1WmVwcHDdhNFms8nx48eJFZtYnF7MVhtHEg1OpJqoFeBOH+LEkUO983/vd++lVkijqGQYt2vZs32Gffv2XTebznp4vV62bt2K3W7HarXi9/mw6RXEly7ujbsYJq2CP9xlxKFXkKp2ePpskS9+8Ys89tj3u80NNsAzOEwNNclskaWlpb6uqVarcblclEolisUi0WiUer1+yfcgI3OtEELcKoTYea3XIfPmIhKJ0G63SaVS6PX6VdGjXC5HrlCmJdS9suy1lsQ/nS3TkWC7U82ndut58QdfpdlsAt294cMf+XCvYuBScIFqJsaIRcOu7VvZunUru3fv5sYbb8RwmZX6riY2m42bD9zE1lEfboOCaChwWfNZdUpuGeoW/3C94/0Yzu3x5VKZh/7hIQqFwrpjDUYTW3bvw+AeRWv3Mr51B8VGh2QySaezvtpDCIHP56PdbhOPxymXyxsaZTIyl0K/BlbwvNdJ4JvAH16ldclcx5RKJcLhMMVikUwmg81m6/UFOZ9Op8OpU6eI5Su0NQP4RsaJlVr8dL4rodiuSfOLp54Aul69G/fswGXS4jPAoM3A/v378Xq9l633vhYMDw9j1auo5tMsBWYpFXKXNI9BreB9MwMoBBxLdwhXVLz00ks8/7PnNxyrUCoZHJ0gUWmxsLDQtxzCbrf3vHzLUkEZmesdIcQXhRCHRZdHgJ8Drwkh/vxar03mzUG5XCabzZJOp2m1WhfI3kOhELl6G7vbg0KhQJLg6bkKhbqEz6jkvmkDzzz1JLFzigy1Ws0f//Ef9wo/tZpNcsk4PqOKPbt3XVRWfz2i0+mYnp7GbtQh1avk0ilKhTztPospnc/Nfi1WnYJcQ8FtH/5ML2KWTqd56KGHqNfWd+6pNVpcPj+DIxMMGM2odAZKtRavvfYa8/PzPQN3rXtY7v8oSwVlrhb95mCNSZI0vuK1U5Kkj0uStHi1FyhzfdFsNpmfn6der7O0tIRer193g5AkiTNnzhCOp8k1FIxObeVossk3jpRodmDK3OEXj325d+6w18FNu2YYsajZvmWS8fHxN3UZVa1Wy8z0NOM2Ldp6jsjZE5w+8irZVGLTkgTPgJI7RruePvP+30ehHeBHTz7JsaPHNhxrsTnQme0ky03m5vrLCRNC4PV6abVaJJNJCoUC2ezlyUFkZN4A3g2EAQPwYboqiyLwb67lomTePITDYVqtFul0GpPJhF7/eo5VqVQikc5QbgmcnkEkSeJoycDJc2qM399i4NiRI7z4wou9MQ++/0G8vtd7MmbTCQwqCafD/qbtNahUKhkeHsauVxCaO0Xk7HHOHD1EubR+xGk91ErBPePd/+PjJT0f/vgne1L/Wq1GsdRf/jCAzeEmXW1zZilLPF+5qGPQ4XCg0+lWVRWUpYIyV5J+c7Cmz+VeCSHEdiHEl4QQfyWE2LjBjsxbBkmSWFhYoF6vEw6HEUJctN/V/Pw8i0tx4lWJsS3bidWUPDVbpS3BHo+G/ZYy2nM9RcwDOt51+y2MOwzs3bOboaGhN2XU6ny8Xi8HDx5kfNDFlMuAU90kFZxl9vhrm/b43TSoZdSsRKEdwHTT/UgSfOORb/Ql/fOPTlBoQCyRumgS8Er0en2vd0itViMUCtG+AiV6ZWSuIj5gEdhOd3/7OPAdYORaLkrmzUE+n6dUKvXKf59fYS4YDJKrtrG5vChVKo7EG5ypGFAIeHDrAIpake989zu98/fesJeDN3erB9YqFWqVCtlkHItW2ct1fbPi9Xpxmg2MWdVMOvW4tG0WTx8nsRSi0+lsyliZsquZtqtotCGsGeaDf/BBxsfH+dznPrephsAOjw/b4Bgm3yillpKlc8bTWixLBTudDrFYjHK5LOcby1xR+pUIPgQ8LHX/Yr4PfAr4PPC3V2thMtcfkUhkVU7O4OBgL5x/PoFAgLnFMLFyh5GpregGjPx0oVvs4ZYhLb87ZWBsZJjPf/7zbJme5K7fOciY08i2bdvetF699VCpVHg8Hg4cOMDeHTNMugbQtCssLc5vah4hBL+3ZQCtErTeKTSDMzQbTb768FepblBIQ63RYvcMkq21CYVCfV/T5XKhUql6Xr50uv9+XDIy14AS3eJLHwWawClAA8j6H5mLIkkSkUiEer3eayq8sp9jIpEgmkhSbAqc3kE6ksSvwt1fq/dM6hm3qHj00UepVbvHHA4HH/qDD4HoGldzJw4zf+IQnUYVs0GD3W6/Jvd5pVAqlezbt49bbznIzTffzPTYEEMmBYV4iOOvvMix3/6KWLh/kdPd43pUCjiRauLdeiN/8dm/2HTetUKhwOm+t8pvAAAgAElEQVQdxOX1ozVayFWahMPhdc9flgoWi0WKxW6esiwVlLlS9Gtg7QReEkL4gRngvwBHgHuu1sJkri8ymQzxeJxMJkOhUMDlcq378AsEAszOL7JUauOf2ILJYuNIvEGi3MGsFbzjXFIrdDus33XbLWwf9TA+OrKqFO5bDYVCgdfrZffu3bhNGsq5JMG50wTnTlOvVfuaw6RVcNtIV05h3Hor0NWqP/LNbyJ1Lu4xdHoGKbUEiVSaUqnU1/WWe2PVajUymQzZbJbKZVRFlJG5yjwP3AL8JfCsJElNugWZTl/LRclc/2QyGarVaq963crISaFQ4OSp00SLbdxDI6g1Ws6kmxTqEkZlm91uDb/85S85c+YMAEIh+NjHPoZO393rYpFFbDrBuFXNoEmFz+e7ahVvJUmiVqtRKBRIp9Mkk0kSiQSJRIJUKkU2m6VUKtFoNC77WiqVCq1Wi0KhYGpqihv37mHKbWLCqmLMpiYdW6JR789gseqUvc8GT81WeTHSIFdbrZi4WCPh87G5PWRqHcKRyEXvdVkquJxvLEsFZa4U/TYaNgEFurILiW7kygR8+iqtS+Y6olqtsri4SKVSIZFIYDKZ1g3bz83NMbcY7hpX49NYbA6K9Q7PBboP2TtH9aiVr0v/MokYilYNp83I6OjoG3I/0O3h1Ww2abfbqx6mKpUKtVp9VRsV6/V6piYmqJ86S7WaodWB8HydiW27+pJF7vZo+GWoRs0+hMo+RCsT5uSJkzz9k6e599571x2nUquxuTzkcnEWFhbYuXNnX9czm83kcjmSySTtdpvFxUW2bt36lpBwyrzl+FO6xpQK+GshhAZ4Enj1mq5K5rpGkqRe9KJYLOJ0OntNhZdziWPFJgN2Ny6vH+g2EwaYMlQRQmCz2RgwDlAulbnrzrsYnxgHoFwqUMln8Nq13LR/P41G44r3tKpUKpRKJSqVCrVa7QIDYflZff5xhUKBXq/HYDBgNBrR6XRcDlarlZtuuol2u9saJF+LEo+EGJ6Y7mv8Ab+WE8kGqWqHXwRrvBKt8ye7TVh0Co4dPcbjjz/OZz7zGVxu14Zz6fQDqLRqMpU8wWCQqampNc9blgouNyBWqVQkEok3XfERmeuPfg2sMPABup7BtCRJYSGEG0hdtZXJXBe0Wi1mZ2dpNBpEIhHUajU+n2/Nc7PZLIFgmKVSh6HJGSw2B5Ik8dRshXq720z46W/9PdK73sX27dtpt1rEI0EGDUomJiauag+rer1OuVzubUDr6bKXUalU6HQ69Ho9AwMDqxKdrwSDg4MoFAparRbhcJi5VIlsKo7dtbEuX6MU3ODV8GK4zvBt7yfw1JeQGlV+8vRPGBkeYfuO7euOdXn9nE0lCcfT6HSzTE/3t/F5vV7m5+d7EaxUKoXLtfEmJyPzRiJJUg749+cd/o/XYi0ybx6SySSNRoNEIoFSqVwl30smk2QKZepCzdjoBADhQotwsY1WCWO6rvNw566djI6N8uwzz/Kee98DQLVcIjR3BodeyfDQEDqd7rKNmGWazSa5XI58Pk+z2UQIgU6n61WA1Wg0FzgLJUnqORfr9Tq1Wo1KpUIymSSZTKJWq3vzrSf/7welUsno6CixeIJAJknN60fXR/l5lULwR7tNzGWaHIrVCRfbPHayxJbKcX74/e8hSfDlL3+Zz33uL9H3MZ93aIy544eILEXx+/3r7uPLUsFkMonZbGZpaQmr1fqmLrIlc+3p18D6/4AvAC7g/xRCKIDbgV9frYXJXHskSepVDAyHw3Q6HUZGRtaM7ix7rBKVNq7BESw2BwC/idSZz7XQqQS1Iz8mGFjky1/6Mu+59z1Mj/oxqTq4HfZNJbL2S6vVIp/Pk8/ne32c1Go1er2+p69XqVQ9w67T6dBqtWg2mzQaDarVKqVSiWQyiUqlwmw2Y7FYrtgGuZzkrNFoKFZOshQMYLLYUGs2fqjf6NPyylKdstqK677Pkf/ND6lHTvLMs8+wffv2Xr+V81FrtIxObyNw+jiq0BJarZaRkY3z/zUaDU6nk+PHj1MqlYhEIlit1svahGVkrjRCiGfXeUuSJOnuN3QxMm8KOp0O0WiUcrlMuVzG7Xb39jhJkggGg6SrbTxDo+fKskv8bLEr6b7Rp0W1wldnMpm4/4H7kSSJZCxCIhzEZRD47GaGhoauyHrr9TrpdJpCoYAkSRiNxp5kf3ndWq0WnU6HVqtFqVT29rh2u02r1aJer1OtVnuSu1arRalUIp/Pk8vlmJ2dxWQyYbfbL7kvl16vxz/oo1iPEJw/zdT2PX05UXUqwQ63hkm7iq+/ViJZ6eAxT6BSqWk2mySTSb7xyCN8+tOf3nA+ncGA2eEmXUr1lBfr4XA4KBQKxGIxDAYDgUCAmZmZTd+3jMwyfRlYkiT9tRDiR4BakqRT5wysm+nKBmXeoqwsalGtVhkaGlrXo7O4uEiyUKGj1uPydSUURxMNnlvsevempQjPvPxS73xFuwHVAj67/oo/xJaLMeRyOSRJ6pWSN5lMPYNACIFWq0WtVq8ysJaNq+VGhcsbT6lUIpvNkslkMBgMOByOK9b42O1243MnKIaTRAJzjG1ZPwK1jFGj4OO7TTwXqDKfA/PNH8ARf5lPvO+OdY2rZQZMZoYmponMn0Yxt4BGo+mropXdbkelUhGPxxkYGCAcDjM+Pt7nXcrIvCHcsc5xOalCZk0SiUSvHYVarV6VB5xMJkkXyrQUGqyObkXB+VyLUKGNTiU44NcRDqyeT5IkFmdP0ShmGTYpGR32XxGFRqvV6uVQLUsS7XY7arUalUqF1WrFYrFgNBp78saNaDQaFItF8vk8Wq0Wq9VKNBrF4XCQy+UoFosYDAZcLtclGVrj4+Nd1UOyRDQUwH8uAtgPOpWC90zp+faxMoGajo989GN84+tfA+DUyVP8+Kkf89773rvhPB7/CGePpliKxxkeHmZgYGDN84QQDA4O9qSCSqWSZDIpKzVkLpl+I1hIkjQnhLALIZbd3RLdPCy5Oc5bkJVFLfL5PE6nc13deLlcJhgKkyy3Gd82hRCCRLnNU7PdYgg3O9s8/dWv986/Ye8uhj12fBYNO3fuvGIRoXa73duAACwWCzabDZ1Oh0KhwGw2Yzabe1rz9XKIJEnqSQqLxSI6nQ6r1dqLiGWzWUKhEDqd7qLFPjbD9PQ0+XyehUyOZCzS0/lfDNeAkg/tMPKzxSovhuvkBg9wMiuxpw/puMXupNVsshSeR3n6DGazecMNVKFQYLfbaTQapNNphBAX/b2QkbkGfHLF10q6BS4+A/xNP4OFEA8DvwckJEnaee6YnW6p9zEgAHxIkqSs6D5A/l/gvUAF+IQkSXKu15uIdrtNLBajVCpRrVYvKD4RCoXIVNu4z0WvWh2J5wLd6NUtfi1PPv49fF7fqvyeVGyJVinLmE3LzMzMFVFnZLNZEolu/0SbzdbLETOZTLhcLqxW6yXlxGo0GhwOBw6Hg06nQz6f5+TJk7jdbpxOJ7lcjnQ6zeLiIiaTCbfbvaqy4kaoVCq2bdtGpXqIUCpK8lxj4H4ZMauw6xRkah2ME9u5+557eOanPwXgpz/9KUNDfnbv2XPxe9RqsTrdZPPxXlRqPQNUp9PhcDhIpVKYzWbC4TAWi2VT9ywjs0xfBpYQ4m7gK8DweW9J/c4h8+ZhraIWF/PizM7Okqq0sDg9GIwmJEniJ/MVOhLscat49cmv0Kh3q/i4XE727tiK06BgYmzsin04z+fzxONx2u02VqsVp9OJWq3ued/sdnvfHsRlLfvyw1aSJIrFIqlUCrVajd1uJ5/Pk0qlCIVCDAwM4PF4LkuvrdVqmZqaonriFLHIIvlMitGprX3JBW8f0dHuwG+W6jw1WyVd6XDX+MY5Yw6Pj2qlRLqQZG5ujl27dm04Rq/XYzKZehtQMBhk+/btcsELmesCSZK+dv6xc4bQgT6n+Ee6kvivrzj274BnJEn6z0KIf3fu+/8N+F1g+tzrZuDvz/0r8yZhec9Yjl5ZLK+39kyn06TzJZqoe9Gr5wM1UpUONp2CVug1Xnqxq8pIpVI8+OCD1OtVEpEgwyYl27Ztu+xS7M1mk6WlJSqVCgaDAa/Xi1arxWw2Mzg4uG405lJQKBTYbDaGhobYsWMHsVgMpVKJ1Wolk8mQSqUolUo4nU4cDkffz3yTycS2rTN0Tp4iHAnQaNRxuL3o9BtHxIQQ7PFqeC5Q49lAlbrzVvzvHiHyzNeh3eJb3/42brdnVSPntXAPDnEmFWcpniKZSuF0ONi5c+ea5zqdzp5UUK/Xs7i42HeusozMSvqNWX+RbqNGcd7r6lUlkLkmtNtt5ubm+ipqAd2S7PF0jnJbiW94DIBjySbhQhuDWlA9+TMi4QiS1IFWlVtv2otRJeG2GvH7+/dkrcdykYilpSU0Gg3j4+P4fD6sVivT09Ns27YNp9N5WfIMIQRms5mJiQl27tyJ1+vFbrczOTmJx+OhWq2ysLBAIpHoSQsvBY/Hw85tM0y5DGiaZRJL6/fvOH99d43ree+UHqXoGloL2SavvPIKiUTiomO9Q2OU2griqUyvueZGLMsJ4/E4tVpNbs4oc90ghLj9vNfvAXfS7Y21IZIk/RzInHf4fmDZcPsa8MCK41+XurwEWIUQ6z8sZa4rWq0WiUSCQqFArVbD5XKtMhpCoRDZahunr1uQaCHX5OVoHYWAu/wS//yjJ3vnqlQqKuUiC6dPYNOB3+e5bOOqWCwyPz9PrVbD5/MxOjqK2WxmamqK6enpK2pcnY9Op2NsbIwdO3bgdDpxOp1MTU1hMplIJpPMz89TrfbXWgS6e9vWLdMMmVV08nHmjh8ml+5vv9nl1qAQkK11qLQkmuYhXHd9EqXZRaPe4OGvPrzhWtQaLZ6hMaI1BfO5FrFEuqd0OZ9lqeByvlehUOh7b5SRWUm/0Scv8BLwMSCHrGd/y7K4uEitViMcDtNut9ctagEQDoeZXej2uxqe3IpQKvlFsMoLoW5BiRlNjqefewYAqVHjtv072DvqYEDXlU5cbtSjXC6ztLREu93G7XbjcDhQq9UMDw9ftX5aGo2GoaEhPB4P0Wi0Jz1MJBKk02mKxSJ+v/+SZY9erxej0Ujl5VcIpZP4hsdQ9FkyfrdHS6Up8fxije8fSbL0o+/g87j43F9+DrVm7WIUKrUa9+AIiaUAZ86c6atUr0qlwuVykUgkejl6drtdllHIXA88z4X7kwBeuIw5PZIkRc99HQOWRbh+YGXX7vC5Y1FkrntWRq80Gg1ms7n3XjKZJJnJU5OUjJ2r7PqLYDef+HeGdbzw9Hd6H+rNZjO33nKQhVNHcRkUeKwmJicnL3ldkiSRSCTIZDLo9XoGBwd7ebJXs3/WWmi1WsbHx3G73YRCIVQqFRaLhVgsRiAQwOFwXGCYrsfg4GBPdhdaihMJnEWr16M3XNxQNKgV3DOuJ1JsMWVT81ygSsHiw/Huz1CPzZJ64Ts88sgjfPpTn0Yo1l+H0zuI0ztIYilEJhEiGAyu+zlBr9djt9vJZDKYTKaeVFAu6iSzGfo1sB4HfJIkBa7iWmSuMclkkmw2SzKZpFqt4vf715S9SZJEIBBgLhAkUmwxODaN2WbnJ/MVXo12pYD7XIJfPvKV7vntFkNeJ/fedjM33LAXk8l02cZVOp0mkUig0WgYHh7u5UP5/f6r2sNqGbVazcjICC6Xi2Aw2KsyuLzxLHv9LgWj0YjVbCJezlHIZbA6+k+yvWlQy2vRClkMmG64j+jLT/CDH/6AD33oQ+uOcXh8FPNZlvJ5NMeOsXfv3g2TpJdlkssFL0Kh0GV9qJCRuUIEWW1glYFDXFi6/ZKQJEkSQmzawSiE+DPgz6DrzX/++ecv6fqlUumSx16PXKv7abfbzM/P96TfTqezF9HodDqcPn2aaFnC4h1hfmGBTFPFUtGKWnTIn/wlrx1+rTfXO95xC4d++yIWyjSdNjpmA6+99tp6l74onU6HZDJJrVbrVfHL5/P4fD6KxSJnz569Ivd/Mdb7mUiSRD6fJ5lM0mq1yGaznDhxAq1W23Nu9ksxl6aczvNiItl1zm5gNJoBswLIw21mBSfLegIVNVrvFNqh7Zw8cZTnnn9uVUXcRr3B7OzsBXN12m0WQzFyS4GeAbUWy9Ulz549i8/n4/jx41dEdXMpyH/31yfL93HHHXes+X6/BpYBuFsIcQQ4DCy305YkSfrUZa9S5pqzXIq9VCqRTqex2WyrPHorWVxc5OxCkKVSG9/oFDanmyPxOq9GGygFfHDbAP/y3a9SLBSRmnX0GiXvv/dORkaG152zXyRJIhqNks/nMZlMPe/e+Pj4Zc99Kej13SqIyWSScDiMXq8nGo2STCapVCoMDg72XdFpJV6vl2imQCYZ35SBpVQI7t9m5uuvFdCP7UFqNXjpxaeYmppi3759a44RQjAyOcPsiSNEsyWsgcC6TRlXjvF6vSwuLpJKpVAoFBQKhWvyM5CRWUaSpLGrMG1cCOGTJCl6TgK4rLuNsDoveejcsbXW9RDwEMD+/ful9TbkjbjYZv5m5Frdz3JEYn5+nuHhYSYmXq9uFwgESBYqKDs6pnbsQQjBk6fLQJPdLjUv/MuveuceOHAAq8mAy2Bi0jPJvn37Ltl52Gq1CAaDmM1mvF5vryrg+Pj4G+I0XGajn0mj0SAQCFAsFikWiywtLQHdCFW/OdU33HADhw4dYi5ewGQa2FThC+hWrjkcq/PjuSoD0wf46F37Lih2MTs7u+4+Zh7QU0qGUShVeDwehofPLy/QpVwuEwwGsdvteDweJiYmrpo65mLIf/fXJxvdR7+x5g/QlVnsBP4I+MSKl8xbgEAgQLPZJBqNotVqcbvda55XKBRYWOwaV8NT27C7PMxlmjw915VLvHtCz7hNzY033ohKatIuJnjwrpuZHFr/IdYv7XabYDBIPp/H5XIxNDSE2Wxm+/bt1/yDvcvl6q1jaGgIr9dLpVIhEAhQq9U2PZ/b7cakVVIt5qmWS5sa6zWq+NB2E3TaGKZuQjdxI9/77vdIJpPrjlGqVIxMzZCudgiGIxQKG3dgMBgMWCwWMpkM9XqdYDB4WTloMjKXixBi+lzulRBCbBdCfEkI8VdCCMvGo9flSeBPzn39J8ATK47/8blrHQTyK6SEMtcpy7k1+XyeRqOxqoDTctQiU23jGxlHCEGu1uZUuokAcid/ST6XB8BoMvKue+4in4rjNCiZmpq6ZONq2WhpNpsMDQ1htVrx+brVCd9I46ofNBoNW7Zs6e2/ExMTaLVawuEwyWQSSdo4wKtUKpmcnMRhUJKMhiiXClQr5U2tY7tLg1YJKpsf9+SOTY11Dw6hs7oJ5Bqcnp0nnU6ved7AwABWq5VsNkutViMYDPZ6h8nIbES/BtZ/WOf1H6/SumTeQJLJJKVSqadJHxwcXFPn3W63OX36NIlSC7tnELPVxmymyfdPlWlLsN+nZY+3Kymc2TLJB++/jwfuuY2PfPBB9u3bd0mRnGVarRaLi4tUq1UGBwd7ErwtW7ZcN7porbabW+b1erHZbIyNjQFd47Vc3tzmoVKpGPT5cBqUhBdm+9q0VjJmU/O7k91cKtOed9PSmnnkkUfotNvrjtEbBrB7BklV2pw5c4ZGo7HhddxuN0IIYrEY9XpdLnghc615CHhY6v7BfB/4FPB54G/7GSyE+DbwIjAjhAgLIT4F/GfgXUKIs8A9574H+GdgHpgFvgT8+ZW8EZmrw/I+l0ql0Ol0q6IuyWSSXKWBUjuA0WyhI0n86Ey3Iu64scWvf/ZM79z3ve99pKJhzMoWw/7BVRUIN0OtVmNxcZFOp8Po6Cgmk4mxsTEGBwcv+16vJh6Ph5mZGQYGBhgdHcVqtZJKpXr52xths9nwOO2YVBKh00eZ30ThCwCNUrDL3c37/U2kvqm1KxQKhsancA6OkKm2e1G4tVhuPL20tESz2SQc7q/4lIxMv42G/8PVXojMtaHdbhOJRHpd3J1O57pFDkKhEIl8mZZKh8c/QkeSeHquu/ns92m5e7w7TpIkosEA414bu27/KA6H47LW2Gw2WVxcpNVq9RoF+v3+vprjvtEIIfD7/RiNRhYWFhgbGyMcDpNKpXpa/34ZGxvrFs5IlTl7/DAqlRr/2CRa3cYl2AH2DA5wJpFkrqzGcvMHCD37ZX7846cv2pzRMzjM2WyGULpI+9Ahdu3addH+WCqVCrfbTSwWo1Ao9HplXU7JehmZy2An8LQQwg/MAP8FuJeuYbQhkiR9dJ237l7jXAn4i0tcp8w1YGX0qtls4vGsbhoYjUYp1No4hrp7y69CNSLFNiaNIPHCD3oR+smpSTw2C61iEptBvUpiuBmWoyJCCEZHR9Hr9UxOTl5zRUa/DAwMsG3bNhYWFnrtTeLxOIuLiwwPD2/o/JycnKRWq3V7cJVrRIMLmKxWlMr+nLE3+rQcijU4kWoybK5zg09LtVrl2LFjfUn5HG4fyWiYZDpDuVxeszKjUqnE5/MRCoV6/R9tNtslG9Qybx/6LkcjhPi4EOIFIURcCDEihHhYCPGeq7k4matPNBql3W6TSCRQq9XrGgC1Wo3FUIhUpY1/bAqFQsHZTJNiQ8KuU3D3uK7ntYpHQtCo4DDqLjspdNm4Wq5oaDQaGRsbuy6Nq5VYLBa2bt3a8+4NDAyQTCaJxWJ9R6NUKhVbtmzBY1TiVDZQN4oko5vznt2/y4lOqqGyuDHufjfPPPNT5mbn1j1foVQysW0nNaWBUKbMqVOnNryG1WrtbazNZpNQKLThGBmZq4QJKADb6Ra7+FvgV4D1Wi5K5vrgYtGrQqFAOpen1lFgtbsIF1q9irgH7VUW584A3ejHHb9zC5VcEq9Zc9FKuxdjWVa9bFwZDAamp6ffNMbVMiqViqmpqZ5yY2hoiGaz2Zc83mAwcNNNN3HgwAHcdgsGRZNYONj3tW16JfdOdR2AP5mv8qvTUb7w37/At7/1bebn5zccr1SpsNhd5OsdIpE10yeBbuEps9lMKpXq/dz6idLJvL3py8ASQvwp3f4fBwGnJElB4A7gL6/e0mSuNo1Gg0QiQS6Xo16v9+ReazE/P0+63MJoczJg6m4AyxUDb/BpOXzoMP/tv/5Xjh85TC4ewmdSMT09fVn68Xa7vcq4GhgYYGJi4rIjYm8UOp2OrVu3Yjabe80Zs9kskUikbyPLZrNx4MYb2bd7O1adgnwmdVGZ3/lolIKP7HF287Em96P2zfDNb36TaqWy7hi1WsP4zA4qHTWpXHHDHiDLBS9arRapVIp8Pk8ul+t7jTIyV5Aw3ZzhvwLSkiSFATcgN7J5m9NqtVZFr1Y6E+v1OidOnCBdaWNzeWhICp48U0YCDvq13Djp5d/+r/+WLTNbuHHvbkSzyqBJyfatW9Hr+1MUrGTZESWEYGRkBL1ez/T0NEaj8Qre8RvHsnJjbGwMk8nE6OgoQoi+5fFCCKampnAYVBRTUSKL833n8+5yazjo1yIBv0jpqbq7+VjPPvss6dTauVUrcXoHydc6hJaiFzWyPB4PCoWCaDTa6xMqI3Mx+o1gfQ5YAH604tivgRuu+Ipk3jDi8XivLKxer1/Xc1YsFoklkhSa9JoJpyptFvMt1Arwq0p873vfJR6L8+W/+x8UI3Ns3TJ9WYZQq9XqeRtHRkYwGAxMTk5itb65HNEqlarnlXS73Xg8HorFIqFQqO8NxGg04nK5sFst6BT/P3vvHSXHdd/5fm7nnKZzT0/CDAACIAAmMYu0KFuJQZYlW3tsydZa69Vz0kres5bXfm+9Xj1ba3udjvfYT7teSaRERUtmkGzJokRJVGASCVIAkTG5c87xvj9qugmQM909AyLX55w6M11dt+sWelC37v39ft+vpJAbPmicTtCu45awMtG1738zza4klRr8vKnV6vCHx8nUOszPzw+dEJrN5jOKgTdzfSoqryF/C/iAfcDfCCE0wOuBZy9or1QuOL3xLpPJYDQa+9ErKSUHDx5kNV+ja7DhCU3wlcMVig1J0Krl9gkl9d3v93PvW36GvTunGbfr2D67bUtWHD21wE6nQzQaxWw2Mzs7e06Ng88XY2NjfRPkqakpDAYDS0tLI4km2Ww2rtqxnQmngVo2ztJaxHAU7pg08YYpEwKw7b4TnStEs9HkE5/8BK1ma2Bbk9lCIDrNcrHN4aPHSSaT6x6n0ymKg7VajWw2269dV1HZiFEnWJPAN1EKenuUUOwJVC5BOp0OmUyGYrFIu90eOFAsLCyQrXXw+ILoDcZ+7RXALq+eL3zmAer1BrJVw6Jpc+MN1xEKhbbct2632y+UHR8fx2KxMDMzc8nmPAshCIVC+P1+PB4PoVCIarW66TSDYDCIw6ghl15/ABjEbTNOHJomWouTO37xg0xMTgxt4/YFaGsMZAoV4vH40ON9Ph8ajYZ4PE6z2RypjYrKa4mU8q+AOWCXlPKja7tvRFW8vaJpt9skk8m+cuDp4106nSaVL1Hu6hjftpOHjtVYKLSx6gX37bCgXTOvLRcLFNMxpt0m9uzayfj4+Kb70RvbWq1Wf3K1bdu2SzZytR52u50dO3ZgNpuZnJzEZDKxsrIyUlZDMBjkmv37iDoNNEpZlk8dY/7YS8QWTw1sJ4TgdRET14WU2l/L7PUArK6s8pV/+srQ83qDYXzjU8QrHU6dOrXh4qDT6cRms5FMJmk2m31xEhWV9Rh1grUI3I6S344QYg9wD0pUS+USJJPJ0Ol0yOVyGAyGdW/wUkrS6TTJdIZyW+Bd86p4aqXBUrGDVS+oHf4ui4uLyG4H2g1+6efuZdeuXVvul5SSlZUV6vU6Xq+3vxJ2qUWu1iMajRIOh3G5XITD4X6kZ9RJltfrxWbUUi8XKOZzmzq3Rgju3e0B4Pk05GrDz6nRaAiOT5GqKoPOMHnanuBFrVajUCj0lQVVVM4nUgyij/YAACAASURBVMoTQFIIMYHiTSVZG7tUrkySySTdbpd0Oo3RaDwjW2NxcZFcrYMvFOUbCy1O5tqYdYJ377aha7+cSp1cXcJt0jI1OfEqcYxRWV1dpVarEYlEsFgsF8y/8VxjNpv7Nci99P5YLEY2mx3a1uFwcNVVVxGyaannU1iaBXLJVeoD0tp77A8qqoKWqX0InfL7j374I5577rmhbb2BMOhNZEu1gWq4wWCwr5xbr9eJxVRnBpX1GXWC9UlgJ/C+tdcHUPLaP/nad0nlfJBMJqnVatRqNTwez6veLxaLPP300zz3wkGSlQ4efwi93sCLySbfWVAKV/cY0jzxrX9FSkm3UeWO1+3jlptv2lJOeo94PE65XCYQCGA2m5mYmFi3f5cqoVCo7x8SiUQ2lU6n0+mYmpwkaNOxfPIIjXptU+ced+jY7dPTkfDYqdHausa86Cx2MuUG8/Pzw493uTCbzSSTyX4qjIrK+UIIcZcQYh5IoSwA9rbhFe8qlyU9EadisUiz2TwjdT2bzZItlGmg43DDycFUC70GfmG3lfiJQ3z0ox/lm//6TQq5LM1KAbdFv2XhplQqRalUUjwO7Xai0egFMa09XxgMBnbs2IHNZiMajWK320kkEht6Tp3O2NgYV+3Yzo6Qi7DXid2gIZ/d2Mexh9eiJerQ0kVD9Lo39Pd/8QtfGFqPJYTAH54gW+8O9HTU6/X4/X4qlQr5fJ5EIkF1hMmfypXHqBOs/4Eid1tBMRyuAn8G/OU56pfKOaRardJoNMjlcmg0mlel3iWTSZ57/gAnU2VidQ1WXwR/OMqPlut89VgVCVzvg8e+9AkAZLPKVNDNfW96A5OTk1vuVyaTIZ/PMzY2htvtxuPxnGECebnQc4632+39SNaoJr3RaJSIfwyPQXLqyEGajc2ZGP/UlBmDFo7n2pzItTh18hTf/e53B7YJT86QqUuWVpTV12H0BC9SqRTFYpFcbnPRNhWVs+DvgQmUcer0bWTFXJXLi2Qy2U+JNxgM/YiRlJL5+Xly9Q4OX4QfrXkpvX2HFZ9J8PAjD9NqtvjqV7/Ko//0JdwmLZFIZEt+joVCgXQ6jcvlYmxsDL/fj9/vf02v82Kkp4Rrs9mIRCLY7XaSyeRIk6xQKMS1117L9PQ0doOSGj+KONT+gJImKCauZcyvlCrU6w3uf+B+Ou3BmRtOzxjoTWRKtYF+V263G7PZ3FfOXVhY2LRXpcrlz0iDjpSyI6X8PSmlA/BLKe1Syo9IKVWdykuQXC6HlJJyuYzdbj/DVLher/PSkSMsFpqY3AF27L2OQGSCxxebPL4WubpryshLX3+AaqVKt1nFrO3y3ne8ld27d2/Z9LdcLpNMJrHb7f1apctxctXD7/cTjUZxOByEw2FqNeWGPuwmLYRg586dRLxOXNoWJw69uKlIls2g4daoUrT98Isp/vZ//i0PPfTQwOiU2WLF7Q+SqbZH6qPJZMLtdpPP56nX6ywvL6t56irniyDwI2AG8ADu0zaVK4xut0symaRcLlOv1xkbG+sr5cbjcVK5EnWpZwU37S7MuHRs8+h54okn+hEPk17D3h3b8NpNW6q76qWRWSwWgsEgTqdzS59zqaLVapmbm8Nut58xyRolXRCUuieH1YSm06JSGi6WsdOrJ2jVUpM6Zt/8K30l46XFJb72ta8NbCuEIDQxraTFLywMlJkPhUJIKYnH41Sr1YFphSpXJgMnWEKINwgh/kIIMdvbJ6VMCyFm1va/YVB7lYuTfD5PpVKh0+mc4QMCKCt61TZm5xiRqW1oNBq+v9Tg6dUGGgH3breQev7bnDp5im6ziqyX+KV7f5obbrhhy4W6vYdwk8lEOBzue11d7vj9/n66YCgUolKpjCThrtPp2Lt3LxMBD059m5X5jX2t1uP6kBG7QdDQWtD7Z5FdyYMPPkiz2dywTSAyQbWrJ1+pbUnwQs1TVzlPfBkoSynnpZR5KWWht13ojqmcf1KpVN8+Qq/X97M1Wq0WJ0+eJFXtEJqY5kBCqS/dHzRSqVT4xje+AYDsdtm3ewcTYzZmZ2c3Hb1qt5VFKZ1ORyQSwWw2Mz09vaEdyuXKepOsRCIxUnaDEIJAIIDDKIgvzw+1KdFqBPdst6BFcqqqZ++9v4oSxIZEMjF0sc/udGN3+8hU2hw5cmTD441GI16vl1KpRKlUIhaLDfX9UrmyGBbB+gPgPuCVT3CngLcCv38uOqVy7qjX69TrdcrlMkKIM6RhS6USq/EE+cbLcuzz+RZPLCk3jXfstGKrxnnssW/SbVTpVIvcdcMe7n7bW7csyd7pdFheXkar1RKNRjGZTGzbtu2KGYACgUBf+KIn4T7KBEan07Fr1y68VgPNSoFibrTVQFAGoOvDShqFbefNAKRTaR55+OGN22h1hCamKbZ0zM/PDxW80Gq1fcGLXp66OvionAcswF1CiBeEEPcLIf7P2vYPF7pjKueXbrdLIpGgUqlQq9XOiF6trq6SrbTQWx3ktU6y9S52g2DWo+MbX/9GPxXaZTNx875dhPzeLUmyx2Ix2u024+PjGI1Gtm3bdlbekJcyGo3mjEmWzWYjHo+PpC4YCoXwO8zoWxVOHT00dJI1ZtFyjUORUF/RBhl/y7/j3vvu4/2/+v4zMnY2IjgxRbmjZTmV49ChQxtOssbGxjCZTMTj8X6qoIpKj2F/aXuBJ+QrltTXXv8QxWtkKEKIqBDi20KIQ0KIg0KID67t9wgh/lUIcWztp3ttvxBC/I0Q4vjaQHnt5i9NZT16K0alUgmbzda/2dRqNQ4ePEi62sHtD2Awmig3uzx8VCnevDVqZNajJxqNcvstNyLrRWa8Zn77t35zSwMPKDnwq6ur/QHIYDBsaZXwUicUChEIBPB4PHi9XvL5PKnU8IJevV7P5OQkXouO1cWNpWXXY1/AiEEDOu8UOqeiiPX97/+AI4cPb9jGNeZFY7aRrTRGMllUBS9ULgA/h7JcvQf4JRR59t6mcgWRyWRotVqk02l0Ol0/etXtdonFYuQbHcaC43xrXplM7QsYSadSfP/73wdAdjtcv/9qfHYjMzMzmz5/Op3uCzaZTCampqYwmUyv3QVegmg0GmZnZ7HZbIyPj/fVBYf5ZBmNRvbt28e424KmUWLp5LGhmR5T5gbv3m3FrBM0rUHcV93UC2QNRa83MLVjN+m6YCGe5uDBg+suKvYsWDqdDolEgnK5PNLYrXJlMGyCZQWMG7xnWXt/FNrA70gpdwE3Ab8hhNgFfAR4TEo5Bzy29hrgLSheJnPArwF/N+J5VIZQLBap1Wq02+1+emCr1eLAgQMs56p0jXaCkUm6UvLwkSrVlmTSqevX7dTrVeamorz/F+7lv/3RH51VndTpA1AvdeJsFAgvZcbHxxkbG8Pn8+FyuUin0yOlT4TDYbwOC9pOg2IuS7fToVTIDa+T0gn2rhUDh26+p7//c5/7HNXKxopIY4EwmWqHpaUlWq3BBo6gCF50Op2+gpYqeKFyjvmvG2x/dCE7pXJ+kVKSSCSo1WpUq1U8Hk9/MTGbzVKoNBB6My8UjSQrXVwmDa+LGHn44Yf7C1Vhv4drrpohEg5telyqVqukUikcDgdut5tgMHhZWI28FvTSBS0WC+Pj45jNZlZXV4ea9prNZq6++moiTiPNUpbVId5YAFMuPT89o3x3TyzWaXXkyGIUZouV6Z17yDQ0zMcyvPDCC+taqphMJjweD4VCgXK5zMrKysB0e5Urh2ETrJPA29YmQ33WfLDexog+WFLKmJTyx2u/l4CXgAhK+uGn1g77FPD2td/vA+6XCj8CXEKIrTvXqgDKoFOpVPqSor30wJWVFVLFOk2dlantV6HRavnBUoPFomK2eM92CxohkFKyfOo4Y2YNr7/9NrZt27blvpTL5b6qkjoAKUxOTuJ0OgkGg9jtduLxOKVSaWAbjUZDJBLBZdKQSayycPwwi0cPkU0NL7i9MWJEr4GGLYxjYicAhUKRf/zyP27Yxmy1YbK7yFVbI0WkeoIXuVxu075fKiqbRUr5XzfaLnTfVM4fuVyORqNBJpNBo9GcMbasrKxQaHTQuEL8YElRDnzrrIWFE8c5dPCQcpDscOO1+xmz6DetjNtut1lZWcFgMBAKhbDZbITD4dfs2i4HtFot27dvx2KxEI1GMRgMLC8vD1WptVqt7N69m4hDTyUTZ/HExjVSPa7y6glYtZSakr99usif/7DA0VSDRx5+hBMnBtcvmy1WZq66mnxHRyxb3DBzw+v1YjAY+qmCaraGCgyfYH0JJUr1jBDiM0KIPxZCfAZ4CjADX9zsCYUQU8A1wJNAQErZq36PAz33vgiwdFqz5bV9KmdBtVpFSkmtVkOv16PT6fqDQa7eITw5jVarI13t8INlpV7mnu0W6kUlMpJLJ6BRwe8wn5UIRavVYnV1FaPRqBSvrinpXekIIZiZmekPyGazmZWVlaGDjt/vx2HS0aiWaFUKBGw6MsnhohJ2o4YbI0pkMnDz2/v7n/vxcwONGYPjk2RqXZZXV0eqq/L5fOh0uv7gowpeqJxLhBDvEUL8QAiREEJMrNVgvelC90vl/NEzOS+VSng8HrRaLVJKjh07RiKTp9YRHKzYkcD+gIFxu4aHHnqo3373ju3MjPsJBAKbVsaNx+N0Oh0ikQgGg+GKFLUYBZ1Ox9zcXN/vUqfTsbS0NNSc3uVycfWe3Uy4DLSLGVYXBk+ShBD81JQyzjU6ko6EL/8kw+NP/JBPf/rTVCqVge2NJjPj07Nkax0WFxfXzdzQaDSEQiFarRbJZJJCoTCySqLK5cuwYpePoaTrXQ+8+7T9Anh27f2REULYgH8E/oOUsnj6TUdKKYUQmzISEEL8GkoKIYFAgMcff3wzzfuUy+Utt70Y2eh6stksqVSqr9jXEx84tZqibnCijyeRMsl3ck66Us+0uUZpcYn//YXPY7fb2bVtgrBFUjJN8Pzzz2+pb73UjXa7TTAYpFgsMjU1te7K0OX0vWzmWjod5UZer9eJx+McPnx46ECfzWYpxLMYNV2aWkG8rqMpNZjMg7N4vRLMGjeFjoGJO97J4ne+BMAXPv8FNEKD1XZm+2ajyUosTr5S4/nEEplUiomJiaHXVKlUSKfTzM/PY7fbmZycxGjcKPv4/HGl/o1dzPSu484779x0WyHEvwP+v7WXUkq5KIS4E0W+/euvWSdVLloKhQK1Wo1MJoMQom/mu7CwwMmlVWLlLpbxnRw+0UYr4JaoiVw2R33NU1Cn17F3z1U4jMpD82bI5XKUSqUz6q4MBsNrfo2XCwaDgbm5OY4cOcLExAQLCwssLS0xNTU1sBbb4/Fwzf79dH/8HKfSScb8IczWjVWMp1x6fnW/HY2AR46UiGPBvv/NFJ7+Jz772c/y/l99/8D6LJvDhcHqJFctsbi4uG72jsVi6WdrOJ1OlpaWcDgcV1xNucrLDPzmpZQ1IcQdwAeBuwE/kAQeBf5GSjmyAY8QQo8yufqMlPLLa7sTQoiQlDK2lgKYXNu/AkRPaz6+tu+V/fs48HGA66+/Xm5lQAa2PJhfrGx0PSdOnCCZTGK1WgmFQjidTp588kmyXRO7ZndhsLr415NV0q0WFr3g3j0BHvjkI1QrVcr5LOWV43z0Ix/kuuuu2/KKXCKR6JsOOp3OvgnhZq7jUmSz19JoNDh8+DCVSoWFhQW0Wi1TU1MbKlDV63VeeOEFvF4vUkpePL6ItFkZn55d9/jTMflafP5ghbpvF95b30WjXqNx/EdotVpmZ89sf/z4cWZnZ4mORzj+4nM4HVrGx8cJBoNDz7OwsECj0WBmZgaXy8WOHTtG+8c4h1zJf2MXK2d5Hf8BJXX9JyhjFijZElv+QJVLi16kvFgs4nK50Ol0dDodVlZWiJfbRGd38c2YAWixP2jAYdSAcYyPfOQj/PAHP6RczOG2mXA77JuyHmk0GiQSCaxWKx6PB7/f3xfWUNkYk8nE7OwsR48eJRqNsrCwwOLiIpOTkwMVF202G+ORMMX6EquLp9h21dUDz+OzKp917047//vHRUyTe5Gyy6FnH+V73/set7/+9oHtQ9EpTh46wOLyCh6Ppz9xP+McPh/lcpnV1VVmZmZYWlpienp6hH8FlcuRoXqVUsqalPJjUsrbpJTb135+TEq5cSX8KxDK0/g/AC9JKf/itLceBn557fdfBh46bf9719QEbwIKp6USqmyRcrncr78ymUwUCgVK1QbojJhsLh54ocRPUi10GiUn/Uff/w6HXzqMbLfoNqvcc9dtZyWhXi6XyWazuN1uHA5HX6pV5dX0JH1NJhORSIRWqzXQI8tkMvG6172OmZkZgsEgDqOGfDrBycM/GWrOOOXSc9e0UgisCV2Fefpa9r/937Pn6j0b989kJjgxzWq5zeEjR0eS2g0Gg3S7XVKpFOVymUwmM7SNisommQS+iVI/3KMEOC5Md1TOJ5VK5Yx7S88+JJVKUay1MFhsZLFxNNtCr4GbIi+r+ul0Om655Wamo2Fcm4xeSSmJxWJoNJp+enckolY1jIrVamXbtm39f7dmszmSqf3k5CRjNgPtaolCbrTxxGPW8rNX2RCyg3lqP47XvZ2HH3l4qDKu2WpjLBQlVmpz6NChddPjtVotwWCQZrNJOp0mm82ONDaqXJ4MNwR4bbgVeA/wBiHE82vbW1FSDH9aCHEMeCMvpxx+DWWAPA78L+DXz1M/L1sajQbtdptarYZGo8FkMpFOpyk1uzjdY/xwuU661sVt0vAr++zoi6t89dGvIjstOvUiN101xZt++q51V21God1us7q6islkIhAI4HQ6CQQCwxtewfQMl61WK8FgkEqlMpJbvNVqZWI8wrRLh6VdZmX++NA214UM3LPdwp2TygPHUlVLtTW4eHgsEMLpCxMrtzl69OjQYmOj0YjH4yGfz1Or1VheXlYFL1ReaxaB2wE79AWZ7mFEQSaVS5t4PE673Safz+NwOPpp1bFYjEKji8sb5JunlMSbm8dN2I0vPwJJKVk4fhgLTQIex6bGp0wmQ61WIxgMotfrmZ6eHslvSeVlHA4Hk5OT2Gw2QqEQ1Wp1aL2uTqdTJllmDYmVxZEVAuc8en7xaht0Wpiie9AFtvPA/fcPVf8LRKLobS6S5Sbz8/PrHmOz2XA6nWQyGer1OouLi+o4d4VyXu4AUsonpJRCSrlXSrl/bfualDIjpbxLSjknpXyjlDK7dryUUv6GlHKblPJqKeUz56OflzO9Qs5arYbFYkFKSTqdptLqgnWMJ1eUwtK3zVmw0uD+B+6n02nTbVQIWbV84P3ve1W62KhIKVlZWaHb7RIOhzEYDGclknEl4fF4CIVCuFwuPB4PuVxuJKnz2dlZbrn5ZmV1r1GjVh1cyCuEYLfPwE3jJmbcOjoSDqaGS80Go1N0dSbSxepI3lherxe9Xk8sFutH5VRUXkM+CewE3rf2+gBKavsnL1B/VM4T9XqdfD5PPp9HSonH4wEUa5JsoUijq2Gh7SBdfVmWPZN+OeqRScToVIuEnCZ27do18gSpF61wOBx9waYr1W7kbBkbG+uXD/h8PgqFwlBfqVAohNtmgkaNQnb0rIhxp5Fbgsp3bL/mLaTyZb7yla8MbCOEIDw5Q6HeJZFKbTgh8/v9aLVaYrFYPxqncuWhLrFcIdRqNaSUNJtNTCYTxWKRcrVBR2PgO3ENHQm7fXrG7To+9/nPk8vmkI0qulaF3/zA+9m+ffuWz53JZKhWqwSDQYxGI9PT02rh5yYIh8O43W4CgQA2m41EIjFU+QiUAmKfz4fdoKGQTY98vn0BpSj7QKKJlJJUMsWzzz677rFCCEIT02RqnX6N1SA0Gg2BQIBGo0EulyOVSo10LSoqI/I/gP8OVFDK1qvAnwF/eSE7pXLuSSQSdLtdstksNpsNk8lEp9Ph6NGjZKodXL4gP44rCnB3TJiolkr86Z/+KX//d3/P/PwpkiuL+C2KfPiohsC9hcpeapjNZlMzM86SYDCI1+vF6/X2PSEHpdlpNBomJyfxWLTEl+dpNQePQadz+5wHl6iiMdmwbL+ZJ3/05EAFXQCD0YTV5aFY7xCPx9c9RqfTEQgEqNfrZDIZJVtoiOWKyuWHOsG6QqjVajQaDaSUGAwGxfi11eWEZpz5fBuzTnDnpJknnniCF194Edlu0qmX+Tf3vZlbb711y3VXtVqNdDqN3W7H5XIRCoX6BscqozM1NYXFYiEcDqPX60c2M/T5fNgMGvKZ0d3lZ916LHpButrl4Sde4M///M/53Gc/x+rK6rrH251uTA4PyXKLQ4cODU0VtNuV4vFUKkW73WZxcfTUDhWVQUgpO1LK35NSOgC/lNIupfyIlFLN0bmMabVaZDIZCoUCnU6nH72an58nkS/T1Jho2EJkal1sBsH2MT3/8vV/odVqcfToUT57/6ewaLv4xlx4vd6Rz5tOp2m1WoRCIfR6PVNTU6ok+2vAxMQEDoeDYDCI1WolHo8PXIgLBAL4XTbsmhYnXvoJzSELfT2EENy92w+Aefpa0Or44he+MLQ+eMwfpFDvsrq6uuGiosPhwG63k06naTQaLCwsDB0bVS4vNpxgCSHeO8p2PjursnXq9Xr/gVyv15NMJjles3CobEYj4Gd3WqnmUjz8yMNIKek269ywextvf/vbtyyn3e12WVlZQafTEQqF+uqFKptHo9H0RS+i0ahi+ry8PPSG7XQ6cViM0G6Qz4wWxdJqBDePK9/54ZaHVlfS6XT4zIOfodNur9tmfGqWclfHaqbA8ePDa74CgQBSSuLxONVqlXR69AibisorEUK8QQjxF0KIfh6zlDIthJhZ2/+GC9k/lXNLKpVCSkk2m8VsNmO1Wmk0Giwvr5CqdonOzPFcQrl37Q8YyaRTPPXkUwB0Ww2u3XsVYxbtuvLbG9GLTlit1r4y7sVgPXE50POEtFgsRCIR9Ho9y8vLG05mNBoNe/fuZcLnxK5psnzq2Mjniji0BCwCjdGCaeJqxtaUeAdhd7oRBhPxQo2nnn6a1dX1Fx+DwSBCCGKxGI1GQ02Jv8IYFMH6JPCJETaVi5xut0uj0ejfnIrFIoVai3npA+C2qIkJp46vf+PrtFttZLvJmMPEv3nnz55VukMikeiv7qmGi2ePwWBg27ZtGI3GvtLSRjf2HkIIgsEgfquO1VNHWF08OfD4HteFjPgsGqTRjn3XHQDEVmM89fTT6x6v0+uZmruKVFWyHIsNNUc2GAx4vV5KpRLlcpmVlZV1DRxVVEbkD4D7gFe6jp4C3gr8/nnvkcp5oadMWiqVaDab/ehVMpmk2Oxic3ro6K0cy7bQCNgfNPDPX/tnut0u3VaDkMfGTTunmJ2ZHlnVtqcaqNVq8Xg82Gw2/H7/ubzMK46eTYjJZGJiYgIhBEtLS7Q3WOTT6/VcffXVeK16GuUCtUp5pPMIIXjduFIz591/F//2A781UhRzavtu2iY3p7INjhw7vm4KYC9VsFarkc1mSSaTlMuj9Uvl0mfQBOu7I24qFzk9OdFGo9GPXiVrgkRbiV71am7e/e53c8utt6CVbX7+7p9hbm5uy0pIpVKJfD7P2NgYVquVaDSqru69BlitViYmJrDZbPh8Pkql0tDoz+TkJLvmZphyGSimYiPVY2mE4E3bLMo5t9+MMCgD0PPPPcepU+sLspmtNhweL6VGd6j6EygFzQaDoa/8pRYCq5wFe4En5CuWntde/xDYd0F6pXLOyWQytNttMpkMer2+n4KeSCQoNbq4vX5eSjeRwKxHTza+zIEDB5BSIls17r7jBnZftX0kw/Qe2WyWer1OIBBAq9UyOTl5jq7uyub0RcVoNEq73R5oV6LX64lGo4xZtGQSgxcfT2fnmB6XSUNTa+ETL1Y5mhmefm8wGpmc24nLHyZVaXPkyJF1M0pcLhc2m41kMkmz2VRTBa8gNnx6llLeKaX8qWHb+eysytY4fYIlhCCTy3G06UQimHXrsRqUPwODwcCdt93Ce37hHezavm1Tuein0263icVimEwmfD4fbre770eicvZ4vV58Ph9jY2M4HI6+r9RGCCGIRqPMzW7Db9GxuniK7giyseMOHdMuHV2hYfyGNwEgJTz44IMb1n/1ctNjsdhQadpedK1XP5HNZtVCYJWtYgU2WsGxrL2vchmSTCap1+vUajXcbjdCCIrFIvlShZbQYXe5OZRWouO7xvQ8+uijAMh2k23RIPv27N5U6nqz2SSVSmG323E4HHi93pFFMVQ2j9VqZWpqCrPZ3Jdv30hcAiASieC2GOjWy8SXF0c6h1Yj+MU9NuY8epod+NrxGvX22iRoSHlwIDJBQxhJ5sssLq5/vtNTBev1+tDME5XLg5HDE0IIqxDiJiHEPUKIe3vbueycymtDT0Gw1WpRr9epNCUrKBOevWvRK4Bup0Mytsyk38Xk5OSW0/lisdgZkuzq6t5rTzQa7fuFGI1GVldXh6bYhUIhvC4bJlqsLp4aSVjixojyzKoZ34vJokS0MukMjzzyyLrHW2x2dGYbxVprqLwuKIOnw+EgnU7TbDZVwQuVrXISeJsQYtfpO9d8sN6G6oN1WVIoFPq1UBqNBpfLBSh+WMVGF/eYj1y9S7zcwaCFbvokx48pNaKi0+RNd9xCOBze1Dnj8Xh/cchsNm/ZG1JldNxuN+FwGKfTydjYGPl8nmw2u+6xOp2O7du34zG0ySeWmD/2EivzJ6jXqgPPYTdqeMdOC1GHlnpb8sOlBt/77vf4xCc/MXCSpdFqic7Mkax0OLWwSLFYfNUxer2eQCBAtVoln8+PrASscmkz0gRLCHEHygD2feCfgK+ctqlc5NTr9b6CYL1eZ7lhpNTRYdULvNqXbzrpxCom2nhd9i1Hr3K5HOVymUAg0Jdk12q1r9WlqKzRKwI2Go2Mj4+PJHohhGB2dha/VUc9n+TUkYN0OuvnhjhkfwAAIABJREFUs/eYdOoIWLXUOnDNPb/S3//9J77PkSNH1m3jDYTI1bvMz89vmC9/OoFAACEE8Xicer0+cHVSRWUDvoQSpXpGCPEZIcQfCyE+AzwFmIEvXtDeqZwTkskk7XabUqmEy+VCq9XSbrdJJJPKBMsX4KW16NWcW88/f+2rAMhOi52z08xOjuPz+UY+X6FQoFKp4Pf7+ya3al3x+SEUCuHxePD7/djtdhKJxIaZG16vl6lolHGHHnOzQLeYZPHE+il8pyOE4A1TSjr8k8tVHvr6t3nxhRf5zne/M7Cd1e7AEwiTLLc5evTohqmCFoulX5s+Pz+vLiZe5owawfoY4ANqKN4iBaADLJyjfqm8htRqtX5KV71e50TTAcA2h+Rjf/InfPrTn2Z1eYnU6hJeq5bp6ektnafRaJBIJLBarX3fJlWS/dyh1+vPEL0YZXLidDrZv28vk24Tol4ktjh4YV8Iwe0TSvrLiY6X6P7b+u997nOfo1Z99aqga8yHxmQjWayNpCio0+nw+XxUKhUKhUJfcUlFZRN8DHgGMAHvBn537acJ+PHa+yqXEfV6nWKxSC6XQ0rZjyTF43GKtTZmuxOpM/F8XLmXmErLrCwrKm4a2eauW28gHA6PXGfc6XRIJBL9qJXf78dqVTNPzyeTk5NYrVbC4TBGo5GVlZUNxwq3280N113L9VfvJDpmQ9uqkYoNr/MN2XXs9ulBo8Vxw32A4NFHHh1aIxwYn6SlNZHKl0kkEuseEw6H+wIpaqrg5c+oE6y9wFeB/4USLA0Az6KaN170SClpNBo0m02azSa1RouVjhOAxItP0Gw0efaZZ/jkx/+OgEXD9ER0SykPvZuGRqPpO9lvNvVCZfP0BERsNhter5dCoTDQlBGUlbR9+/YRsOkpZpKUCrmBx8969NwWVSZZ7dk7sQWiABTyBV46fPhVxwshGJ+ZI9uAxdUETz755FDRC7fbjclk6q9Ib5TLrqKyHlLKGnAH8J9RRC1OrP38z8Ada++rXEYkk0mklORyOex2OwaDASklq6ur5OtdxvxhvnqsSqkpCdu01OOKdLfstNm9fZao372pMSqVStHtdgkGg+j1enV8uwD07Ep6ohdCCJaXlzes97XZbASDQebm5vBbtWTiK6RiK0MjWXdNm7HoBQbfJNZdd9DpSh64/4GBC38ajYZAZIJsvcvS0tK60aleqmClUumnClbXWaRUuTwYdYKlAeaB3l+CE2UA+4Nz0CeV15Be5KrZbNJoNJhvWGigw6GX/ORH3wZAthrcfsM+Ql4XU1NTWzpPJpOhVqv1B5+pqaktKxCqbI6e4IXP5+ubMvaETTbCarUyMz2F36pj+eTxofnpt0aNXOXV00FD4I5fxO318uu/8etce+216x5vNJmJTM0Rr2k4lqzw0pGjQ4U4QqEQ7XabVCpFsVjcMMdeRWU9pJQ1KeXHpJS3SSm3r/38mJRSfYK5zOh0OmcYC/cWBTOZDPlyja7OyImGheO5Nkat4N4dFu65+25+5z/+DrPTE9xx034ikQg6nW6k89VqNXK5XH8haGJiQk19v0Do9XpmZ2f76fGtVovV1dWB6XYul4vpyQkiNg2F+AInDr1Aq7nxZMmi13D33JqK7q7X4737wxQNXr7y5cFVMU7PGFJnIluqkUwm1z3G7XarqYJXCKM+AccBL8okSwAHgJ8H1DvMRU5vxaXZbFKv1znaUNIDNZmTyK5Eyi6RgJf9O6aYmZnZ0qSoVquRTqdxOBw4HA7C4TCWNUEElfPDxMREP2qo0+lYXl4eWv80Pj5O2OvCY+hw8qUXqZY3VvATQvDmbRZs2jalroHr3vXbzM7Obng8gGvMy87912PzBsnWOhvKu/cwmUy43W5yuRy1Wo2lpaWhSoQqKucLIcSHhBAHhRA/EUJ8VghhEkJMCyGeFEIcF0J8XghhGP5JKmdLNpul2+2Sz+cxGAz9VL14PE6h0cE2FuS7i8rY9+ZtZlwm5VHFbNBy1+tvJuRxEIlERjpXzxBdp9Ph9XpxOp19MQ2VC4PFYmFychKLxUIgEKBcLg8VVZqenua6/XvZ5rNhkTWOH3xh4MLijFvPW2bNWGmiMVqwX3c3T//4AD/+8Y83bCOEwBeKkK11OHny5IbRqVAo1M/6qdVqI9maqFx6jPo0/WVAj1JIHANCgA74u3PUL5XXiF4Eq91uU6/XibWVic/8s2vRq2adW67dQ8DnxeFwbPrzu90uq6ur6HQ6gsEgNpvtrMyJVbbG6akTkUikL5U/CCEEe/bsYSrkxWeSLBw/PFD0wqgT3OQsoRXwQqrNS6nhXiFCCALhKJW2hkQ6Sy43OB3R5/Oh0+mIxWK0Wi3VG0vlokAIEQF+G7heSrkHZXHx3cB/B/5SSjkL5IBfvXC9vHJIJpPUajVqtVrfWLher5PKZKi0BC/VndTbkgmHjp1ePQDlYp7YwklCNh075uYwGEabC+fz+b7nVc9nSeXC4/F4CAaDuN1u3G53P6I5CLfbzTXXXMNUwI1T3ya+PFhGYF/AyG/e4sNYz6AxmDHP3ciXvvhFMunMhm1cYz60FgdLuRoHDhxYN2XfYDDg9/spl8vk83ni8biaKngZMtIES0r5O1LKd0opc8DVwM8Ct0gp/+9z2juVs6bZbCKlpNlskq13qUoDmm6bZiaG7HbweZzs3T61ZSn1nnleKBTqpwaqqkoXBqPR2PcL6a3qDTMh1mq17Nq1i6DHgUW0iC8NHnBc+g53TSsqS/98okqupkSYyqUyx44dW7eNTq/HGxonW+swPz8/tD/BYJBGo0E2myWdTg9MLVRROY/oALMQQofirRUD3oCy8AjwKeDtF6hvVwylUol6vU4ul0MI0V8YjMfjlBpdNA4vzyWVhaI7Jww0m026nQ5LJ48RsGqZmYwSDAZHOle73SaZTPbtJILBIEbjRnZrKuebnnR7IBDAbDb3xSMGodfr2bVrFy6jlnI+R6s1eKFQCMG9exWfNMvcTTQ6ggceeGBDL0mNRsPU3FVIk4PFbI1nnzvA4cOHX5UG6PF4MJvNaqrgZcxICchCiJPAP0gp/18pZRZ4SAjxfiHE70kp7zu3XVQ5GxqNRt//Kt5VxC3a2WVAIlt1bt5/DZGQEnnaLOVymVwuh8fjwWq1MjExoQ4+FxiXy9WPIFarVVKpFGazeaDalUajYfv27ZTKzzGfjuP0eLE5nBsef03QwEKhzZFMi2+crHFV+xRf+tIXabdb/Kf/9Lu43K9On/EGQqTjK2RySm1Vb9V5Pex2O3a7nVQqhcPhYGFhgV27dqkTd5WhCCEmgKKUcrDSyyaRUq4IIf4cWERR0/0GitBTXkrZC/suA+vmnQkhfg34NVBsCR5//PEt9aNcLm+57cXIVq4nFouRz+dZWVnBarVSLpfpdrscPnyY1YogGwrRlRA1Nnjq24/z1FNPsX16kgmvHb3HTMZhGbm+M51OU61WCYfD5PN5CoXCq+wp1O/kwtLpdFhcXFQydGIxjhw5QjAYpNls8swzz2zYLpVKkstUOPAsuLz+oedxYSJvsGHZfhOLBx/nMw8+yM0337zh8VJjIFfrcmIphvvECZaXl1+VWtpqtYjFYpw8eRKfz8fBgwfXtQ241L6TYVwu19O7jjvvvHPd90er8IQpWHOmfZlrgLu33DOV80Kz2aTVainu51L5z12NnUB22hg0XV539Y4tRa96KWhGoxG/34/L5WJs7JV/IioXgkgkQqVSIRQK9aVgp6enBxZ022w2JieiVJrzLJ86zvarr9mwHk8IwZu2mZnPtziVb3PiJy/0o0yf/exn+cAHPoDQnDkZ0mi1+ELjZOILLCwsDJxgAf0IXDweR6/XE4/HCYVCm/yXULkCOQX8NfDh3g4hxMeA/0tKufGqwRCEEG7gPmAayKP4ar151PZSyo8DHwe4/vrr5UYD8jAGDeaXIpu9nna7zQsvvEAmk8FutzM9PY3JZGJlZYVMsYroGDlUcwOSW6ad3P/o89QqFX781A8I3bKPu9/7WyNbh9RqNebn5xkbG8Pv9zM3N7duGv2V/p1cDNTrdQ4fPkylUmF+fh6z2UwymeT666/fsM3U1BTPvnCQVFM/tJ4YwORv8+kXy5hnb8SQPMJtt97G9MwQS5vt28kk4xRWTuL1eti/f/+rDslmsyQSCUKhEC6Xi507d75qQfRS/E4Gcblcz7DrGJgiKIT4lhDiW2sv39l7LYR4HHgvsHFVvMpFQS+CVavVSHaUKFUrs4RsN9g1HWFqagqTybTpz43H43Q6HcLhMHq9fssphiqvPT0TYoPBQCQSodPpsLKyMjT9YGJiAr/LhqHbILm6NPBYi17D7RNKqqB935sReqXO4dixYzzxxBPrthnzB6lLLclckWeffXagnLxer+/nqBeLxZFSP1RUUESYXskksPkQ/Zm8ETglpUxJKVsodcm3Aq61lEGAcWDlLM+jMoBsNouUknw+j8lkwmQy0e0qstiZWpeKfZJKS+K1aFj4yZMUCkVks4aZBj/79vs25ct4urCFy+XaUo2yyvnBZDL1J9uhUIhqtTq03tfj8eC0GKFVJ7Z4auj4OO7QMe3SodEbueld/3745GoN95iPeldDJlegVHr1I7PH43mVquAwGXmVS4NhNVh3rm0SZfDovX49YAUeOWc9UzlrpJS0Wi1arRb5apOCNCI7bZqZZbrtBjdec/WWvDzy+TylUgmv14vJZGJqampkuVuV84Ner2dmZgaTyUQwGOynCw5Co9EwNzeHz6olG18hnxl8/DVBAz6LhkpHy/Y3v6+//9FHHyWVfHVbjVbL+Mx2EjUNx+IFXnjxxb4Iy3r0JJETiYTqjaUyECFERwjRQRmrPth7vbbv54HBf8zDWQRuEkJYhJKrehdwCPg28M61Y34ZeOgsz6MygHQ6Tb1ep9Fo9NOtYrEY2XIdYTRzpKQIV1zt1fKtxx5Ddtp0m1XeeNuNzM3NjXyenrCF3+9Hq9UyPj5+Tq5H5bXD6XT2a7LcbjelUmngIp5Go2FmZoaIQ0c5HWPh2EsDRZ4Abp9QFqOfTXb53MEy2dpwlVuNVovbF6DQ6G4o2nS6qqBqQHz5MGyC9T7g36KsCv7r2uv3oUSvfmrtp8pFSu/htdVqEWuZAYFDU2f7TJSg28Y1+/Zuumaq2Wz23ey9Xi8+nw+nc8uZNyrnELvdTjgcxuVy4XK5yGQyQwUjnE4nszPTRGxaVk4dI5/ZWCRDqxHcs92KVkDOGCT4ureitXlotVo8+OCD6xYBO1xuduy7Do3FSb7WZmlp40hZzxur0+mQTCYplUpkMhurN6lc0Qhejl6JV2wt4I/P5sOllE+iiFn8GHgRZez8OPC7wIeFEMdR0uj/4WzOo7Ix1WqVWq1GPp/vi1t0u8pDa67WxeCdYLHYRq+B/NGnKJfKdFs1rJo27/y5nxtZNbB3vzGbzTidTlXY4hKil2YXCAQwmUxDPSH9fj/X7NvLpNuIqOU5fvAFmo2Njw/bddwxaUKvgfl8m4ePVPsL2YMYC4QoNmElnlx3odNgMPQNiHO5HIlEQhV3ugwYOMGSUn5KSvlJlEnV76+9/pSU8tNSyu9IVfLkoqY3wapUKmS7ijz7jvAYd91xOx/4lfdsuqZFStlfWYlEIn2jP5WLl2AwiMPhIBAIYDQaWV1dHToYTExMMDszuTbJOkoxt3FBuN+q7asKdieuZ+zNv4lp6hoWFhZ47FvfWreNRqMhOD5Jrt5lNRYbGMXqeWPl83mq1SpLS0tD+69yRTINzKBMqP7P2utpYAKwSyn/5mxPIKX8L1LKnVLKPVLK90gpG1LKk1LK10kpZ6WU75JSbuxeqnJW9NIDC4UCdrsdrVZLOp0mV64j9SaOVZX70A63lu996zFkt4Ns1XnTnbcyMzMz8nlSqRSdTodgMIjBYBhZcVDl4qCnpNuz/BjmCelyubj22muZ8jmwiQbLp44P/Pybx038+vUOzDpBvNLhu88f46Mf/SjLSxtbihiMJoLRKeLlDkeOHKFWq73qGLfbjdVqJZFI0Gw21VTBy4ANJ1hCiP9HCPEzay8ngbeu7TtjOz/dVNkKPZPhYrFIUShFkw5ti26zhsNiGCo08EoymQy1Wq0/8ExPT2/JmFjl/CGEYHp6uu+PJaUcqR5ramqK2ekJwjYtSyeOUKtsvJp2TdDAPdstbPcodVi2fT+DxmznG1//Bisr65ekmK02LA43uWpraOqfz+dDr9cTi8Vot9uqN5bKq5BSLkgp51EmVf9x7fWClHJ5rWZK5RJGSkk2m+0rBvayJpaWlsjVO7gDYX6SVL7m9tIBqtUqst3EbtRy9913j5zC3mg0yOfzuFwuTCYT4+Pj6hh3iaHVapmdnUWv1zM+Pk673R465pnNZvbt24fPZqBZKQxcVAQw6zVcE1Qiot8+lqFULHH/A/fTqG+8vjIWCGFyeIiXmrz00kvrTp5CoRBCCFZXV2k0GupYd4kz6M7xh7yskvSHwH95xdbbp3KR0vPAKpVKlFBW94ztMhadwOv1bmrgqNVqpNNpHA4HTqeTUCg0UPpb5eJBp9OdUY9Vq9WG1mMBTE9PMxkJMmaCxMrGkyAhBLt9Bt5xlZU5t1IEbL/2bXSFjs985jMbrh4GxifJ1iVLK6sD0yE0Gk1fdjedTpPNZocaSqpcseSBDwkhHj5NlOlbQojHLnTHVLZOqVSi1WpRKBTQarVYrVaSySTZQpkWemLSRaMjCVoET3/7n5FSIttN7rr1dZvK1EgkEggh8Pl82Gw23G73ObwqlXOF0WgkGAyeUYOcTCYHtumJdXnNWmJLw6NH14aMaITEGN6JzhkgnUrzj1/+x4FtxqdnqWEgni1y8uTJdfsQCASo1WpkMhlSqRTFYnH4BatclAx6wv4U8NTa7/evs31q7afKRUqj0aDdblOr1SlKpThTV8tiMWg3NXD0VOh0Oh3BoOKZpaZNXFrYbLYzCoBHqccCZZLlsuipFnMDo1g9fnqbBb2QGEPbGbv7QxQsUQ48f2DdY80WK25/kEy1zbFjxwauMNpsNpxOJ5lMhnq9zuLiIp0NjB5VrmgeBP4AxULkzldsKpco2WyWTqdDuVzG4XDQbDY5duwYyUoHfyTK8wklemXMnVDSr7ptHBYjt99y08g1wuVymUqlgtfrRafTEY1Gz+UlqZxjemOey+XC7XaPtDAXDofxOq1o2nWKucH1vjaDhqv9RoQQuF7/HvS+KZ55+hmefebZDdtodTomtu0gWZXML65w8uTJV417Lper7wPZaDSYn59Xx7pLlA3j5lLK9532+6+cl96ovKb0FAQLjQ5toUO26nz7Xx7m7lv2vsrwbhA9FbeJiYl+aqBq+nrpEQwGKZVKdLtdarVa3x9Lvyaxvh4Gg4FwKES2ukhidQnExscCOIwafmGPnUdeiFPQ2bBf82aC2zeWRg5EJjiayRDPFDh8+DA7duzYMLLak22Px+N975uJiYnRLl7lSuEOIAv8T5RollonfInTk2UvlUpIKXE6ncrkqtxEb3PSsniJlcuYtIL5p76ptGm3uPXGawmHwyONVVJKEokEBoOSOu/1erFYLOf60lTOMT3Jdill34jYaDRuaE2j0WiIRqOkC4dJxVZwjb3a9Pd03jhtptzsciJnwX3He+nWKzz0g8eYnJrE6/Wu28ZisxOZnmX51DG680sUi0W8Xi/hcLg/9gWDQU6ePMnq6ipTU1NDo28qFycj54gJId4mhPi8EOL7QojPCSHedi47pnL2tFot2u02qbryNbcKSY68+DwWs3nknPRCoUChUGBsbAyLxdKfZKlcmmylHmt8fByXWUe1kB0pijXu0PGBWyJc41NE3L56rEqrs/45tFodE7M7SNYkp1YSHD58eMPP1el0r0qfUJWWVF7BUeBRKeUfSin/Skr5173tQndMZWuUSiU6nQ6lUgm9Xk+z2SSeylBsCsanZ3kurojkXB0w8OEPfZC7734bfq+bm67dg883+AG5Ry6Xo9lsEggE0Ol0RCKRc3lJKueRnujF+Pj4SKIXPp8Pl9VIp1GhXBwc8dJrBe/YaeX6gA7ZKKMxWTHvfwuf+uLDdNobR51cYz4m5q4iVuny0kqWF4+cOCNlUKfTEQqFqNfrpNNpisXiUF8vlYuPkSZYQogPAw8D7wJuRvEVeVgI8TvnsG8qZ0mz2aRWqxGvKq87xRR62WbPnj0jtW+1WsTj8b4k+9jY2KaFMVQuLnr1WEajkVAoNFI9ltFoZDIaxWvRko4tD52QAQiN4K5ZB16zhmy9yxcOlam21s9pt9odTO+8mmRNEksMzjl3Op3YbDZSqRTNZpOFhQVVaUnldD4PvEsI8WEhxBuEEK/vbRe6YypbI5/P0+12qVQq2Gw2lpaWyNc7eAJhOho9h1LKBGt/wIDRaOS6a/fzzvvuxuNyjlQn3G63SaVSWK1WbDYboVBI9XW8jNBqtWzbtg2DwUAkEqHdbrO6urrhOKbVahW5d6OWVGy4yIRWI3jjrI1fmoX6wgGEVk81ejOPfu1fBrazO93s2HcDY9FZEpUOi8srZywY2u32flp8o9FgcXFRVdC9xBg1gvVhoAP8FfAB4K/XXn/oHPVL5SzpdDp0u13K5TKppjJYtPJxQj43Y2NjQ9v3ohug5CWbTCY1J/0yoZeb7nA4Rq7Hikaj+BwWaFZZPH6EcnFjA8ceOo3gvh1WbHrBUrHD/QdKLK7E1j3WbLXh8YfI1TsDvbFASZ8QQvRNGWOx9T9T5YrkTwAz8Gco3o3fXtvW9wxQuejJ5/OUy2WklGg0GpLpDOW2wBsIcSDRpNWFSaeOMYtWOT6dwmHSEggERvr8dDqNlBK/34/RaMTv95/Ly1G5AJhMJqanpzGbzQSDQSqVysCFxXA4jMuio1HOk00lRjpHdGKc14c1dMo59O4QLxp28oMXTwxso9XpcHv9ePwh0tXOq2qRexHVTCbTl25XuXQYdYJlBD4rpfywlPLjUsoPAZ8DBhdkqFwweisdlUqFklByydv5GFPRyEireul0ui/JbjQamZ6eRqvVntM+q5w/gsEgTqezb8g4zB+rJ33rNrTRN3IsHztINhUfeh6fVcsv77Pj0HXINySf+vpTVCqVdY/1BsOUW4JEOk21Wt3wM/V6Pf7/n703j24su+5zv3Mv5nkiCIDzWGPP1a3Bsq3Rkpy2LCnybE223H6J7ZV42S9xvJbXcwb7ZXSc9/I8yJEcy5LsRIqVlhRZsixb3Ypag3uorq5mTaziTJAgAGKeLoDz/rgEuljEwKquKrKq7rfWXSwC514cFMl7sPfZ+/cLhymVSmQyGTY3N3uON7inWO5y9I7aDQ4lxWIRTdPI5/OoqsrW1haZShNfaBDFZOK5uC6L/WhMNwJu1OsUsmlcFrGv8sBOsuxGf/Hdic/nIxKJ4PP58Pl8pFIp8vl8x7EWi4WZ6WmiThPx5StUyvtbX970fW/Av/Ed6tkEJneQp9Iektm9nlfXEh4aoSLNbKRzu4Ko1m6apmkkEglyudy+FIANDgf7DbD+I/CgEMIPIIQIAA8C//ZWTczg1XF1gFWz6IIWWmqV6enpvgtIqVQimUzi9Xrxer3EYjFDkv0uZHx8vF02sZ9+rEAgwLHZWe6bHiPqNLGxvNDT9b6FTWmQ+rsvAqCMPsx/+++f6Sg9YDZb8AZDZCvNvrtYfr8fh8PB5uYmmqaxuLi4r9JFg7sbKeW4lHKi03HQczO4fjKZDFJKCoUCQgg2tpLkNAhHh7iU1shVJTZZ5eknP8n62jpbG2s4TBD0+7FarX2vn0gkEEK3LXG73dcl/mRw59Gq3IhEItjtdtbW1tp+odcSiUQYjg0yYBMsnD9LudQ5MXg1QhF84L2Po333z9E2LyNMZr6d6F/CrqomRqZm2Sw2WFhaJpV6RcHQ6XTi8XjY3t6mUCiwurpKpdJ/3TU4ePYbYP0ccALYEEKsAnHgGPALQogrO0fvvVCD20orwMrmi0iHH9lsoqVWOX78eM/zGo0G6+vrmM1mIpEIbrd736UWBncWN9KPZbPZmJycZCgaxmeFlSuX+r6O2WzmvW96FC2zgWp3M18w8+3vfLvj2IHoMNmqJL6x2dHt/mqi0ShSSuLxOOVy2SgVNAD0BKAQ4gkhxL8RQnh3erCMm9gdSC6Xo1wu02w22draIl1uEByMYbZY+bt1/YNx7vw3OXvmJf7dv/nXnP7utwg5VMbGxvpeu1gsUigUCAaDmEwmhoeHb/XbMThghBBMTExgs9kYGhpCURRWV1e7yqBPT08zGgkSsjZZOHeGaqX/bpTL7eLDH/oA73/9BIqAswmNjUJ3UY32eR4vA7FRNgp6qeDVc/J6vVitVuLxOLVajYWFBSOheAew3wBrbGesGYjtfFWB8WsOg0NCK8C6tJFBKAqNQgqLqDM1NdXzvJYk+9DQEGazmfHxcaNk4i7mRvqxQF94BlxWtFKOYr6/EeKJE8cZQQ/eHDOv5XOf+xxbib3BnNVmxxMYILOPXiyLxdKWbs9kMmxsbPQNygzuboQQJ4A54PeBX915+C+B3zyoORncGPV6nVKpRLFYJJvNUihVKDVUBqJDbBTqrOYaqLJB9sJ3kVLisCjcPz3M2MhwX++rliy72WwmGAy2VXIN7n5MJhNTU1NYrVaGh4fRNK1rcs5kMnHixAlGIyF8Vlhb3N8+wvj4OOORAKei+i7qFy+WqNb7B0QD0SGwOEgXKqyvr7cfVxSFWCxGo9FgY2ODUqm063mDw8l+A6w37eN4862YoMGNUavVaDQaLKT0D5z1bILY4ABud3dPolwuRzabJRQKYbfbGRsbMyTZ7wEikQgej4dwOLyvfizQd6VisRheq0Jyc383+p9462ugksfkDiICY3zyU5+k2SFzGI4Nk6lK1uMbfYO9QCCA3W4nkUgYpYIGAL8D+IErAFKZFf43AAAgAElEQVTKLPAU8NaDnJTB9dPqjykWi/rapEEoMoSqmtq7V9Xl08h6DRp1HrrvKIM+F+Pj432vnc1mqVarhMNhVFU1ZNnvMVqfbxwOB+FwmHw+TzKZ7DhWURSOHDlCyGlBK+bYTu7fk+p7RmyE7ArJcpPPnctTLvcu7RNCEBkZI1VusLy8vEtO3mazMTAwQD6fbycUDZuSw82+Aiwp5VNXH8A8cLrD4waHBE3TKJfLJGu6MEU9u8lILNI1S1ev14nH49jt9nZGz+/3384pGxwgN+KPFY1G8VpVCttptFrnOvarsVotPLyT0bNPP8bK8gpf/spX9o6z2fEGw2wW6pw9e7ZrjfzV82g2m+3M3sZGf/ENg7uWx4A/A7541WNL6JUXBncQuVyORqNBJpOhXKlS1CAwMEih1uRcUgMkmZe/CYDNovD6B08yPDzcV4ypVW5ot9vxeDwMDg72NFs3uDsJBAIMDg4SCATwer09fRXNZjNTU1OEnSrxpcv7Fr2wmgTvO+7EqjRZzDX5+F+f7mt97vb6sTi9pIsaS0tLu55r7bRubGy0SwW7lTcaHDz79cH6TSHEl4TOv0VXZUoIId53a6dncKNomkahUKBi0YMkLb3OxPh42yn8WjY2NpBSEo1GsVqthiT7PUanfqx+7vG6pPEAbgtsbazt63W+dyaEkE2skWlUd5Cvfe1rLFxZ2DMuNjaJtLlZz5R5+eWXe3pdWa3WdmYvm80Sj8cNVcF7lyJwrXzc/UCqw1iDQ0wul6NYLJJMJqkJK57AACazmdMbNZoSSC7QLGWQjTr3HZ0h5NEluPuRTqep1+vtwGo/5xjcnQwNDeF2u4lEIthsNtbW1qjVah3HRiIRhiMDBG2CxYvnaPQwK76aWi5F4qlPI6Uk55/lL595oe850dEJUpUmK6tre1R3h4aGEEKwvr5OtVrdE4QZHB72WyL444AJsAC/BLRSxL+xn5OFEB8XQiSEEGeveuw3hRBrQojTO8cPXvXcPxNCzAshLggh3r7PORpchaZpujFjTO+5euMjx3jsscc6js1ms+TzeQYGBrBarYyPjxuS7Pcg1/ZjpdPpviUIw8PDBBwmMok4+Wx/p3m7WeH+QX0Xy/3QDyKbkk9+6pNUrimdUBSF8ZljFHeka5eXl3tet1UqaKgK3vP8b+DtwN8HEEJ8F3gt8PRBTsrg+qhWq9RqNYrFIul0mlJTIRiOIKXkTELf0d6eewYAsyp5/cMnGRoa6msQXK/XSSaTuN1u7HY7sVisa9LR4O5HCMHk5OQuif7V1dWuCb0jR44QDbhxUGVlob/AE0A4HOahiTClC88ghMLzRT+LS70NjO0OJ77QIMlSnfn5+V3PmUymXaJU29vbu1QHDQ4P+72zjAKX0ZUDLcAPA58GeismvMJ/Bd7R4fH/KKV8cOf4EoAQ4jh6QHdi55zfE0IYn/avE30Hq0hxxwPrWMRDLLa3SqbRaLC5udkuDRwY6N2nZXB3c60/1traWs9+LLfbzeT4GINOE6tXLpHe2qDR6J3Z+74xOzYVLOEJ7LOvYzu9zTe/+c0941STiZHJWRI70rXb290DOCFEu1TQUBW8p/k/gUVgGBDAqZ3vf/3gpmRwvbQSO1tbWzRQUSx2HC43i9k6uaqEah4tcQXZbHBsZoqwz0k0Gu173ZZKajgcbq95Bvc2LdGLlmVJrVbrKiChqionTpxg0G2hmtvelxckwHve8x48mQu6kq7Tx6e/MUe5T5VFZHiMYkMlkcrsWfs8Hk/by6tYLLK8vNy3lN7g9rPfAKsCTKBnBhvAyztf91X8KaV8Gkjv87V+GPhzKWVVSrmA3u/VeevFoCONRkOvMy9UqQsTZuq4Tc2O/VdbW1s0m00ikQhms9lo9jVgfHy83Y8F9O3HGh0dJTbgZ8DaJLN6hUtnX+woXtHCaVF4fFb3VXOdfDNvfdf7ePObO2vkON0eApEh4vk6p8+81FNZUC9Z3K0q2M3U2ODuQgjxC0KIoJRyBbgP+FHgn+x8vU9K2XsL1OBQUSwWaTQaeoClWnD79FL3M5t6+VZh/jkAFBq87qGTDO5UX/SiUqmQyWTw+/1YLBbDVNigjcPhYGxsDKfT2S437yZ6YbPZmJ2dJeJUiS8vUNlHObrZYubDH/wAtZf/GgAx+jB/+tnP9+zHUk0mIiNjJEoN4vH4LsELgMHBQSwWS1u6/cqVK0bVxiFjvwHWd4EfAH4b+I6UsgwcQd/VejX8ohDizE4JYUtRYQi4+lPU6s5jBvuk9YcYL+gfcp2ihsWkK+dcTaVSYXt7u+1iPzIyYpQGGmAymdqiF/vpxxJCcPLkSR46eZSJAReWZpVUn8zedMDMA4MWhKKSDt2n7zV0ITI8hmsgxnJW48KlK10XPtBLBVsGxLVajcXFxZ79WwZ3Df8vsC6EeBJ4HPiClPLfSyk/K6U0GvLuMAqFAuVymVwuR12YcHv9rOfrXExpICWVxdNIKZmdHCMWdO/LwyqRSKAoCqFQCI/Hg8fjuQ3vxOBOIRgMEg6HCQaDeDyenqIX4XCY4dggIZtg8dL++rFCoRA/8o7vo7z0IkI1seE+wt/87d/2PMcfGkS1uchWmiwuLu56TlEUhoaGqNfrbYGntbX99UIb3B56Fyy/ws8Dv7Uz/jeFEBbgAvDMq3jt3wf+JXoM/y+B/wD8zPVcQAjxBPAE6NH817/+9RuaSKFQuOFzDyPZbJbFxUWevbgKkXEopFjKX8HtdOzK2CUSCWq1GrFYjO3t7bYs7mHhbvq53InvJZ1Ot2u85+bmGBgYQAjBs88+2/WcQqFAJr7IlbVNRmeOo/QI2MeagvOKn9Uc/PVLq0w4epc4lBqCFy4tshlfZXZ2tmv2ueVrMj8/z+DgIC+//DLhcLjrfO+0n0s37pb30nofb3zjG6/ntDngOPBD6AFWXgjxWeBPDYXbO4tGo9EOrgqlEg2nhyxOPvNygYaEEWsJ32iEiy8neeyBE4T8PlwuV89rFgoFisViW5bdMBU26MTw8DClUoloNEq1WmVtbY2JiYmOdjUzMzMUi0WqiSzLly8wPnu8747o/fffz6XFL3GhUsASnuBv555ibOxyV39SIQSx8SmuXLrA6to6Q0NDuxLlLen2RCLRLiM0kgeHh30FWFLKJeCnAYQQJillHfjIq3lhKeVm699CiD/iFVndNeBqCbvhncc6XeOjwEcBTp06Ja9zQW5zA4v5oebJJ5/k1KlT/M7f6uoySy8/y9FwgUcffbQ9plQq4XQ62xmb48eP79nhOmjupp/Lnfpe5ufnyWQyLC0tUa1WSafTnDp1quc5gcBpLq6nMVsUhsanei46cqvGFy6WOF1wMzMaYdStMD9/mdkjs3vGNicnufCimQF7k/HxcQYGrhWLe4VMJkM8Hm/L8M7OznbsLbxTfy6duFvey428DynlSSHE/cBPAT+G3jf8M8CHhRCrwKellP/sZs/V4ObTUgDd2NigoZhxeXx85UqFWgOOhcw8PhNDPPIEzz/zNBMh+74Ub7e2tjCbzQQCgbbPo4HBtbREL86fP8/IyAgLCwusrq4yNja2p7qn1Y9VqTzHcibL+vICQ2OTfV/jPX/v7fynT/wFlZm34jj2vXzqK3/JL78/3LX33e5w4vQFSZcbLC4ucuzYsV3PB4NBisViu5e+NcawHjh49ivTLoQQ/3RnoaoKIVZ3vr/hAmYhxNUdqe8BWgqDnwd+XAhhFUJMADPoJYoG+6TRaFCv16mYdTf7+vb6noxdIpHAZDLh9/sJBoPGgmPQkWv7sZLJZN+Su4mJCcJOE5XMFgsXXu4penE8ZObhqIWGhM/OFfjdP/ksf/jRP9yjnAR6SUR4aIRUucHly5d7Khz6fHpWO5FIUK1WWVxcNPxC7nKklGeklP9USjkOfC96lUQKPWH3Tw5ybgb752qBi6ZiRbMHSJab2E2Cx2ccqIpge2sTv9NCwOsiEAj0vF4mk6FSqTAwMICqqh3FngwMWpjNZiYnJ3eJXnQTTLLZbJw8eZKY20w+GSe+vNC3D0pRVT78nrehzeuqgub738nn/+4yzR7n+Qci5GoQ30yQy+X2PB+LxVBVlbW1tfZ6Z3Dw7LcH6x8B/ze6WaPY+frbwD/ez8lCiD8DvgUc2QnOfhb4t0KIl4QQZ4A3Ab8MIKV8Gfjv6CUfXwZ+QUppfDK6Dur1OqVSiYbdB+x4YE1MtJ8vl8uUy2WCwSCqqu5Lfcng3qTlj3X1YtPPH8vr9fLQgw8wHrAjKjnWF690HSuE4G0Tdk4OmKlLQXXmbdgmHuFTn/xkxwDKHwojrC6W0yVOnz5NNpvteu1oNIqiKMTjcarVal+pd4O7g53EnxVd8dZoKr3DKBaLVCoV8vk8DWFiuaYL4hwLmVEVQaNeJ7G+SsCuMjo62vNazWaTZDKJ3W5vq6MamX2Dfjidzn2LXni9Xo4dPcKwx0wxFWfhQm/fRtATgD/62mlK555CCIUV6zgffT7Per5zMtJssRAYjLJVbDA3N7fHq6sl3V6r1djc3CSXy7GxsT+FQ4Nbx34DrCeALeDdwNGdr0ng5/ZzspTyJ6SUUSmlWUo5LKX8mJTy/VLK+6SU90sp3yWljF81/reklFNSyiNSyr+8zvd0z6OrLyVR3CEAmrnNXQtROp1GURR8Ph+BQKCv+pLBvY3T6WR4eBiXy4XX62V7e7tnYAP6onP//fcT8VgoZrZIb212HSuE4AdnHDw8AEJRcD/0gxSx82d/9md7VJYURWHi6EkUV4DVbI3z58/vUVdqYTKZiEQilMtlkskk6XS6p9S7wZ2NEOI1QojfRS8p/yp6iaAfuAL8q4Ocm8H+KZVK5HI5ypUqmG1czOg3AVtulUa9ztL8eZyKxoDfQygU6nmtdDqNpmmEw2FMJhODg4O34y0Y3AVcLXrh9XrZ2trq2qceDod56IH7GQ/YkeUcyY3+YhNHjx7hV3/kTfzQjAOfTSFTafLly6WuO2CDQ6NIq4t4tsyZM2dYX1/ftfa5XC6CwSCZTIZsNsv6+npfH0uDW8v1+GB9Xkr5eSnlRSnl59FL+XqnjwwOhHq9zsvziyhmG81qCZ9dbdf31ut18vk8Pp9PL7nq0vxvYHA14XAYv9+Pz+fDbre3d4V64XQ6mZ2eJuo0EV++Qq1a6TpWEYIfmPUxYdUXBMfs6zg3d46nntqrT6AoCqNTR2iaHSRyZa5c6b5D5vF48Hq9pFIpyuUyS0tLe7J/Bnc+QojL6KJLvwRE0G1B/gD4HinltJTy/zrI+Rnsj3q9jqZpJJNJalKh5giTr0nsSp3/+Yk/4Dd/49d57pmniHptHDt2rGd/Z71eJ5VK4XK5cDgc7TIqA4P9Mjw8jNvtJhKJYLfbWV9f77ru+Xw+jh07xoBDZSu+Sm0fvlQer4cTYQsfeciN0yxIFJssZjsnDBVFYXTmKIWmmcubOU7PXWRubm7XmIGBAex2OxsbG1SrVRYWFromIA1uPfsNsFaAdwoh3iCECAkh3oBuAtzbjtrgQKjX61zeyADQKKQJ+bztHqvt7W2klPj9/vbCY2CwH8bGxtr+Maqqsrq62revKRKJMBQN47fC6sLevqprefvJKEiJdeQkisPLF7/4xY7eV0IIRiZnSZUlK+txMplM12sODg5iMpnapslGffpdyQRQBT6L7qUYlVL+gpTyWwc7LYProSVwkUqlaCpmNtD7iGVCv3fkttPUMglmZ2ex2Ww9r5VMJpFSEg6HsdlsfXe7DAyupSV6YbPZGBoaQlEUVlZWuq57Pp+PWCSM1wLrS5f37UtlUgSPRPVKoi+dWUeraR3Hmc0WZk48iG94iq0yJFLbu9Y+IQRDQ0MIIYx+rEPAfgOsT6D3XT0FbO58je08bnDIaDQarGX17Ek9n2RgIITJpAtGZrNZnE4nFovF2L0yuC5aDeIWi4VYLNaWQ+/H1NQUIacFrZjrWSoI4LOpHAuZEYqC48j30Gg0+MQnPkGlvHf3y+ZwMBAbJllsMD8/37XuvTVvTdPY3Nwkn8+zudl7HgZ3HD8LDEopf0xK+YUdpVuDO4xyuQzopX11YWalrMtjx1/6JrLZgHqNN33v6/sKW9RqNTKZDF6vty3SY5gKG9wIJpOJ6enp9u9RvV5nbW2ta/A0MTHBgNOMVsgQX1nY9+tM2ivQ0MirXj7xhb/pakKsmkwEBgYJRmJsVxp7EpBms5lYLEalUmFzc5NsNmv0Yx0Q+w2w/h3w74ESushFGd236t/donkZ3CBSShqNBumK/tfZyCfbdeeVSgVN0/B4PKiqis/nO8ipGtyBWK1WRkdHcTqdhEIh8vk86XS65zkWi4Xp6WnCTpXN1eW+DcCvH7EjkDimTmGJzpBKpvjMZz7TccEJRYaoKVa2skWWl5e7LnoOh6Ndn57P51lbW2tnyw3ufKSUfyylPFxGfgbXTblcplKpUCgUyatu8hqYmjW01BqyoTEWHeDIkSMoSu+PLltbW4BeMuVyuYy1zuBVYbfbGR8fx+FwEIlEKBaLXcWeWsqCQx4zua1436Rii6XLFyhe0K1lN0MP8aVvdPebBAgNxijVBYlUek8Fh8ulq2tub2+Ty+WMfqwDYl8BlpSyLqX8J1JKN3qW0LXzfed9TIMDQ9P0H0lB6tvN9WyirRKYzWYRQuB2u/H5fEZGz+CGCAaDDAwMEAqFcLvdJBKJvsFKOBwm6HVhQSOd6J1NG3CqfP+YXtLqefTdqE4/L7zwAt/+zrf3jFUUhdjYJMlSnYtXlnjuuefaWfA91x0YwGazEY/HqdVqLCws9A32DAwMbh+lUolkMkm1CVmrnhisbVwCQNY1HnngOMFgsOc1KpUKuVyOYDCIyWQyTIUNbgp+v59oNIrP58Pv95NO7w1sWvh8Po7MzjDoNLGxskhjH31Qr3nsNZzwVCgvvYhisnC6HuOFC4tdx6smE4HBIbaKDc6dO7enNywcDrf7pSuVCleuXGl/PjS4PfQMsIQQ77r2AF53zfcGhwhN05BSUjProhZaZrPt+5HP53E6naiqit/vP8hpGtzhjIyM4HA4iEaj7f6mXs20QgjGxsYI2lUS8VWafXq3XjNkZcpvQrHY8b3pw5i8gzz77LPI5t4dKo/PT3h0io2ywnIyz8JC57KMVn16s9lkfX2dSqXSV3LewMDg9iClpFKpkEqlqDUEiZ3+q9zCGaRsYjEJHr7veN+1a3NzE1VVCQQC+Hw+nE7n7Zi+wT1ALBbD5/MxODiIw+FgY2Oja0IvEokQDnhxqg021/dhESLg77/3vXgTL1CNX0SxOvjLVZXVRPf+4nBsGGxu4tkKc3Nzu3rDOvVjLSz09+kyuHn028H6n8Dnehx/cUtnZ3Dd1Ot16vU6Ju+OHG1xi5GREcrlMpqm4Xa7UVUVj8dzsBM1uKMRQjA1NYXVamV4eFjv++tRlw4QCoUI+tzYRZ1EvLeMrRCCd806GfUoqDYXobf8DB/42Z9HKJ13XQMDEaZP3E+u2iSZSnUN9iwWC5FIpJ0pz2azhnS7wb4QQviEEJ8VQpwXQpwTQrxOCBEQQnxVCHFp56uRubpBKpUKUkrS6TQlxU5aMyGadWqbC8h6jSMTI4QHBtr9xJ0oFAqUSiVCIb3vuGWQbmBws2iVCg4NDWEymVhdXe26MzQ9PU3ArrKd2KCQ621tAnr/1M988EM0XvoyteQyis3Np5+LU9e6KwuOTR+lKM2sp7JcunRpz/VisRjVapWNjQ3y+Tzr6+vX/6YNboh+AdbyVUcBvf/q6sf2ynsZHCiapqFp9bYH1q/+/IcIh8MUi0UAozzQ4KZhsViYmJjAZrO1g5Z+O0JTU1OEHCqpjbWesu0AVpPgR0+4GXErNBUz34n3Lm8wW6zY3V7y1UZXU0jQyzc8Ho9eilStGtLtdxFCiIeEEB8SQvyaEOJnhRAT/c/aN/8J+LKU8ijwAHAO+DXga1LKGeBrO98b3ACtMuPt7W22VV3EQkuuIBsaUqvy2P3HiEQiXc+XUpJIJDCbzfj9fkKhUF+lQQOD60VVVaamprDZbIyMjNBsNlldXe1Ybu5yuRgbGSbiVFmeP0e5VOx7fZ/fxwff/1Pkv/0ZmtUSTU+Ur51Z7DreZDYzPnOcZFmyvL65R/TC5XIRCoXIZrNkMhk2Njb6+lga3Bx6BlhSynEp5YSUcgL4Y/0h/furHjc4RGiaRq7WpCFUTLKOyyyx2+0Ui0VsNpuxe2VwU/F4PO2yiVZdei6X6zre6/USiwzit8H6Unf/qhYmRfC2Kb3E54WNGtvl3qWFvuAAhWqzr2pSJBLBZDLpfju1GleuXDFKJ+5ghBB+IcT/Ap4FPgb8FvBR4JIQ4j/dhOt7ge/buTZSypqUMoMuCf8nO8P+BHj3q32te5VKpUKlUqFYrpAz66IUla1FaGi47SZOHp3p2X+VzWapVquEw2FUVW33HhsY3GysVusu+fZKpdJ1Z2hycpLR6AAhGyxeeJnKPsSVpqanePwdb6Vw9m8AyASO8/Qz3+k63uZwMDx5hHihztLS0p4dtVAohNPpZGNjg0qlwsLCQl8fS4NXT/e99r0Ynz7uADRNI7WzMWCnikkRmM1myuVyu3a9ZTpsYHAziEajFIvFdg/F+vo6VqsVq9Xacfzk5CTJZJKF7W2y6STeQG9/mrBT5WTYzNmExl8vlHnfUSdPf+NpRkZGmJyc3DXWGwgSX75COpslm83i9Xo7XlNVVYaGhjhz5gzxeBxVVVlfXzdKiu5cfhd4J7ANOAEzup3I64FfFEIsSyn/w6u4/gSwBfyxEOIB4DngH6GLPrW8CjaAwU4nCyGeAJ4A3Zft61//+g1NolAo3PC5h5Gr38/a2hpLS0ssLK+RnngUVH0Hq1mvEhvwkk6nee655zpep9lstv+Oi8ViO2N/u9/D3cDd8n5ux/toSaDncjnm5uY4f/58R8XKZrNJMZ0gny3yv9fWiI5PY7XZe147Fosx/PI5Uuk1zIEhns5WqT79LSZiA13PSWUL5DZWyGQye3Z7G40GGxsbXLhwgWg0yunTpxkdHe2ryHkruNt+x974xjd2fP56AiyDO4B6vc52TS//cwgNm83Wrm13Op3YbDbMZvMBz9LgbmNiYoJz584xPDzMwsICq6urjI+Po6rqnrEWi4XJyUmK5y+xtnQFl8eH2qOvAuD7Ru1cSmlc3q7ze09+g8tPP4nH4+FXfvVXdiUMVNVEYCDCZirO2bNneeCBB3C5XB2vabfb8fl85PP5dh+W2+02dnjvTB4Hvgq8AzgBnEHfbfqHwDPowc2rCbBMwMPAL0kpv7OzK7arHFBKKYUQHRORUsqPou+ocerUKdltQe5Hr8X8TuTq9zM3N0e9Xscfz1JWXQgkb3nsBH9XWuHNb3gNb3vb27r2X6VSKdxuN6Ojo3i9Xk6ePNnx3nOr38PdwN3yfm7X+1hZWSGRSBCP64b3sVisY2Lv1KlTzM3NsbSRJFWrMDY6i9nSOQnZYnxsnN/9gz+iqr4VkzfMJcsA3zvuwWbqHBRFI2GWzr+Ez2flgQce2PNZr1KpsLi4iMPhYHR0lEAgwMTE7S9Eu1d+x/qpCP5F60BfwHY9JoT4Hzd1tgavGk3TuBzXfYnquS295KJYRAiBw+Ewdq8MbgmtunSLxcLQ0FBfE+JoNMpgwItTqRNfWex7fY9V4QdnHADkQicw+SLkcjk++aef3FP7HhkZx+Tys5at8nfPPcdLL71EpdK538vj8eB0Otnc3GyXThj9WHckKpCUep1ny3jmmJTyPPB5YOxVXn8VWJVStup0PosecG0KIaIAO18NWcoboLX7vb29TUp4kAgiLhOnHjjBT77vPTz04INdg6tGQ++5dLlcOJ1OYrHYbQuuDAyGh4fxeDxEIhEcDgfxeLyjsqCiKBw/fpyhkA+PWmfx4jkajd7y7WaLmZ97/08S3fouYYdCrgZfuFjqWs7udHmwu31slzSWlpb2PN/ql275eKXTaUNJ9xbSb2/w3VcdU+giF+++5jA4RGiaxnpW/zB5+aXnWVxcpFQqYbPZUBTFCLAMbhl2u52xsTEcDgfhcJh8Pt9VbEIIwczMDANOM7nUJsV8976tFkeCFh6OWBCKivvhvwfApUuX+PKXv7zn2qOTs5jcIZayDebXk1y8eLHrdVsfyNbW1tr+WEY/1h3HC8CPCSG+BnwLvaS9pddvBl6VCbGUcgNYEUIc2XnoLcAcevD2wZ3HPgg8+Wpe516lVqshpdRVPVW9lH3YYyK3ncZpUQiFupcRp1Ipms0mAwMDWK3WnmMNDG42QggmJyex2+1tZcGVlZWOyoKKonDixAlifieWRomlS+f7ejH6/D6+/3tey3uPObGZBJe363xjubtAVGRknFRFsrrW2VzY5/Ph8/lIpVLk83lWV1fJ5w2P9ltBvwDrn/c5/sUtnZ3BdaNpGtqOB1Y9p5sMVyoVHA49+28EWAa3kkAgwODgIIFAAK/Xy9bWVtebt9PpZGx0hJBDZW1xfl+mv98/ZsdlFpgDQ9jGHwLgr7/615w9e3bXOEVVGZmaZfaBU+RqgkRqu6scu8lkIhaLUavViMfjFAoFQ8r2zuPXgTLwJmASuAR8SghhBh4Bvn4TXuOXdq55BngQ+G3gXwNvE0JcAt66873BdVKtVqlWqxRLFQo7Ahcxp6CQzeAwi67eV/V6nXQ6jcfjaQsOGAq5BrcbVVWZnp5uKwtKKVlZWdnlS9XCbDZz3333MeSzQznH/MunSayv9N3N8tlU3jXrQADPrFb55nzn5KXd4cQXGiRZqnPu3Dnm5+fbKtItIpEIdrudtbW1tgmxUblx8+mnIvjP+x23a6IG/Wk2m/qHVLu+QDWymwwMDCClriRos9l6eogYGNwMhoaGcLvdRCIRbDYb6+vrXRWLRkZGGPA4MDcqLF6c6+t4bzUJ3jyhNwd7H/wBFIf+u/7pT5cN+wEAACAASURBVH2Kzc3NPePNZgsDsRFSpUZPpUCn08nAwAC5XI7t7W02NjbIZLobPBocLqSU3wLuB34R+AjwqJSyIqXUpJRHpZQ/chNe47SU8pSU8n4p5bullNtSypSU8i1Syhkp5VullOlX+zr3IpVKhVKpRFFrkBd6z6RPFLGZwOfxdBXM2draAiAcDuNwOPqaEBsY3CqsVmtbvn14eJhardbVG9Jut3Pfffcx4rcRMmkUEyv72s2a9Jt5287693Rc8Fffnes4LjI8Rqlp4koiz5n5FV588cVdAZQQguHhYVRVZWVlhWq1yuXLl/eV5DTYP7dfPsTglqFpGsVise2B1chvtZstbTZbexfLwOBW0iqZaC00iqJ0zeapqsrx48cZ8dsxVXPMz53pa8h4LGRmym9CmqwEv/+nECYrlUqVj3/s4x1r34PhCFXMJLOFjkFYi1AohMvlavdjLS4uGlK2dxBSygUp5e9JKT8upTRqXu4gKpUK+XyeVMNBQ6jU8yk++rv/nvNnnu8qzV6r1chms/h8Psxms6EAanDguFwuxsbGcDqd7V6nbmuOy+Xita99LacePMmIX9/NWrnSvZS9RXH+uxQvPINQVJ4tBTgzv7pnjGoyMXX8AQKjs9RMThL5KhcuXNgV7LWMuOv1Ouvr65RKJRYXF2/4vRvsxQiw7iI0TWNheRXV4UU26rgVvQZYVVXMZrMRYBncNkwmE9PT01it1vZNvFs2z+Vy8dBDDzE24CFgqrF88Szpre4+VkIIfmjWSciuIJxBvI/9MKBnsz/1yU8hm7tfQ1FVIiNjJIsNFhcXqffYJYtGo5hMJlZXV9v+WEZW785GCPHHQojeW6MGB0q1WiWbzZJS9B1pLbVCOrUFWrWj7DXQbs4PhUKG+qfBoSEYDBKNRvH5fASDQV24JZXqOFZRFILBoF4y6LVQyabJpjuX/rV49NFHcSZeorLyMorZxhcXGmyl9lZbWKxWfMEQo9NHyGoKq4k0L7744q5yQYfDQSQSoVAokEgk2tUbBjcHI8C6i9A0jQsr+qLTKGXxed00Go22m70RYBncTux2O+Pj4+2beEu5qBM2m42HH36YY1NjRF0mNtdWegpN2EyC9x13YlbAEjuKZXAK0KWev/JXX9kz3hccQNicpPK6UmC3oKlTVm95efkG3r3BIcNozDnEVCoVMpkMaUWvuNCSy8hGjRNHZzvaLLR2vILBYPtv1sDgsBCLxQgEAoTDYdxuN4lEoqeQhMvlYmpqipBDJb6y2DOpZ7Pb+MhHfpb63F+hbcdRHF4+/rcvUyl3Fr4wW6yMTh9lqyKYj6d54YUXdlVm+Hw+/H4/qVSKbDbL2tqaUR5/kzACrLsITdNY2tL/iBuFNAG/n3q9bgRYBgeG3+8nEom0b+LpdLrrzVtRFMbHx/G7HZiaGrlM73YWn03le0b03+3w698Diorf7+fkyZN7xgohiI1NsFVqML+0xvPPP7+n8beF3W5ncHCQQqFAMpkklUp1VUM0OBwIIRrdDuADBz0/g+40m01qtRq5XJ6M0EWYaptXcJhVjhyZ7WiEurW1haIoBAIBfD4fTqfzdk/bwKAnY2NjuFwuYrFYW1CiUwl7i0gkQsjrxNyskdrsbnEC+q7thz7wfgrPfxHZbCCjJ/jYZ79Es0MZPoDL42X2vodpWD0kixoLCwu7nh8cHNwlMb+wsNBzrgb7Y18BlhDiISHEh4QQvyaE+FkhxO13JjPoi6ZpbOT0LEajkMbv97cFLqxWq+ENYnAgDA0N4fV62zfxjY2NrjdvIQTRaBSvTem7yAA8GrMStCvUVAczjz/BP/rlf8zw8HDHsU6Xh9HZ4yQ1MwtbOV566aWuykl+v7+tglgoFFheXu4akBkcCkSfw+CQUq1WqVQqbFWgYbLTrJaoZzcYG4p0NGwtl8sUCgWCwSCqqhKLxQ5g1gYGvVEUhampKex2O8PDw2359m5rTqt3OeRQSawvUymXel5/enqa973j+ymd/yYAmcgj/LfPfV43qOiAajIxPDFNpgrrG5vkcq9Yowgh2hLzrfL4+fn5nuX0Bv3pZzTsF0L8L+BZ4GPAb6G70V/acbI3OERomkaqov91NfLJtqKSIXBhcNBMTEzgcDh23cQ7+YSAnsnz2kxUCtm+gheqInh8xoFFhaxlgG9s9E4iuL1+Zu97iIbFzdp2iYWFha6LSCQSwWq1sra21lZZ6jZngwNnG/gr4KEOxxcOcF4GfajVapTLZdbq+i6UllpBNhqMD3cOsLa2tlBVlUAgQCAQwG633+4pGxjsC5PJxMzMTFu+HWBlZaXrmhMIBBiODhK0wsqVS337fx997DFeP2xFS+m99xcZ5mt/+zddx1usNgKDUZKlBnNzc7t8skwmE8PDwzSbTVZWVqhUKoay4Kuk3w7W7wLvBDJA65PFU0Ad+EUhxK/cwrkZXCeaplFomgGo55L4fL62wIVRQmFwkKiq2pawHRkZad/EO928Wzf6sNPEyuULaLXeSn5Rt4kfPe7CrMBLiRpLmVeCoEQisadsQlEUxmeOUVFsbJc0VlZWOl5XUZT2btjq6irVarWn1LvBgfIdYEJK+eK1B3rwZexiHVKq1SrFYpF0U08Cauk1aGhMj4/u8W0slUoUi0WCwSCKohCNRg9iygYG++Za+XZN01hdXe0auExPTxP2OjBpReZfPk0+29m/scU73/F2RksXadbKWKMzfDPj47svnOk6PhwbpmlxsZQq8fzp07t2slpecpVKhfV13ah4aWnpxt64Qd8A63Hgq0AIOIW+SH0M3WQxCzxxS2dncF1omoYjpH8gDNhE29keMLJ8BgeO1Wpty7cPDQ1Rq9W6GvqOjY0xNODHY2qwPH+hb1Az7DHx2mG9H+sbKxWklJw9e5bf+Z3f4XOf+9yesgnVZGJoYppcXWV5ZZVSqXM5hsViYWhoiGq12l5wugVkBgfKR4BuXle/Ahhl7YeUarVKPp8n3dDXqvp2HFU0mZ2Z2ePbmEwmMZlM+P1+gsFgu7/YwOAw43K5dlVxlMtl1tfXO65rJpOJ48ePMx5yEVBrLF+co1TIdbjqDgJ+6n3vwrn4DZqVApbBSf6uEkVrdF4zVdXExNGTmDxB1rM15ubmdlVmuFwuBgcHyefzJBIJ0uk08Xj/cn2DvfQLsFQgKfXfgpaY/zEp5Xng88DYrZycwfVRr9dR3LpnyA+9+XUMDg4aAZbBocLtdjM6OorL5SIcDrdv4tcihODYsWNEvHaalQLpRH/p2FNRKzaTYDXX4Bvn1vjjj3+cWrXGN7/5DE9/4+k9450uD05fkGRR21MucTUul4uBgQHy+TzJZJKtra22wanB4UBKuS6l7Ji23TEDNtKwh5RqtUqhUKCo6GqBWnqNaNBHIBDYNa5cLlMsFgkEAsbulcEdh9/vZ2RkBLfb3Q5gunlkud1uTp06xezECFGXicTqUs9KDpPJxM/96OO45/8Kt6lBvmnmG8udVQVhpzpjYgasLjayZebm5nb5VAYCgbayYCaTYX19nXTa8FC/XvoFWC8APyaE+BrwLfQ8cEt+xAwYZo6HBCkltVqNQkPP+HlMdUwmExaLpV0maGBwGAiFQgwODu65iV+L2WzWyyUcKptrvRcYAKtJ8FhMTyg8s+0i+kO/jOoJA/Dkk08yN7fX9T44GKOEhcWtHM89/0LXRSQUCuHxeNqiFysrK10DMoODRwjxG0KIywc9D4P+1Go1kvkyDbODplalnksyGhvc43+VTCZRVV0pNBAItJOHBgZ3CuFwuL32tTyyuinUKorC5OQksXAAB1WW5y/07IdyOB380hM/w3uOexHAd9erLGe7i1QoisLo9BG9iiOxzYsvvrhLvn1wcBCn08nGxgbFYpHFxcWeUvMGe+kXYP06UAbeBEwCl4BPCSHMwCPA12/p7Az2Tb1eJ1vWqKMimhqWpobZbMZqtRplFAaHjquVBa++iV9LKBQiEg7is0guvfQ88eUFKl3K+QAeG7LyaMyK0yyoW9wE3/h+FLsb2ZT86Sf+dE9JomoyMXPyQRT3AOt5jcuXL3ctR4xGo9hsNtbW1toNwN0UoQwOnAAwftCTMOhPuVxmNa9/cBTlDLJRY2Z8eJdxcKVSoVAoGLtXBnc8w8PDbY+sllJtN+sSIQRHjhzBb1OgWiC+stj74gJibhOvG9aTD587X2RlK0u10jk5abZYmTh6kkzdxGIiy/PPP99OMraUBS0WC6urq+01r1LpvjNmsJueAZaU8lvA/cAvote4PyqlrEgpNSnlUSllt5p3g9uMpmnEs7r0taleASPAMjjEtCRpnU7nrpv41Rm0FjMzM0xGQwy7FeqZDa7MvcDChZdpNPZm50yK4C0Tdv7BKQ8jHhUsToLf99MgBNVqlf/yR/9lV1Mv6DXpQ+NT1BUrqVypa9lGS/RCCMHKygrVapX5+fldpRUGBgb7p16vUyqV2Krra9Sx0TA/9+H38/DDD+/qv0qlUiiKgt/vx+fzGWuawR3N+Pg4brebaDSK0+kkHo933R2yWCyMjY0RdZvJJ+Nkt1N9r/+GURuTfhPluuSTL6T52Cc+1VW50GZ3MH38ATSLm4VUmRfOvMT58+epVquoqsrIyAiKorTXvEuXLhlquvukrw+WlHJBSvl7UsqPSymN/cFDiqZpfP07p/V/59PMz89jNpsxmUzGYmRwKGn5hLSUBVs38WsXAqvVyn333cdjjzzMyckhpoM2lEqWK+fOUu9yozcpgvcedeK1Kgj3AK6JBwDIZDJ87GMfQ6vtPk9RFCLDo6TKDRYXF7suRmazmeHhYer1OqurujjGwsKCoSx4+LgM7G28MzhUaJpGuVwm3dDXKBclAm4HAwMDu8bk8/m2Km4kEjmo6RoY3BSEEExNTeF0OhkeHm4bEXcTW3I6nUxPTTLgMBFfXugrna4IwduGoZlLIJx+kuFH+NSn/7zreSazmYkjJ/BGRlnJNTm/FOf5559H0/RE/cjICPV6vS3fbiQW98e+jIY7IYT4YyGE4UJ2SNA0jcvremajlI6ztLTUrlE3AiyDw4rFYmF6ehqr1brrJt5pIXC73czOzvLII48wFnJjbZSILy90uKqO3azw+p1Sicij70QoulL3yvIKn/70p5HN3UGRNxBCWBxs5cqcP3++a9DkcDiIRCKUSvpuVzabZXV19Ub/CwxuAVLK/yylfNNBz8OgN5qmUalUyEhdhMmm5XCYlV39V9vbukx1IBDA7XYbliMGdwWqqjI9Pd02Ijabze0AphOxWIyQ14m5WSO12V/Vz+9x8YB5nUY5h2VgjAXbFP/jfz7Z1YhYCEE4NszMfQ9RUhwk8npJINCWmK9Wq6yurlIsFg3Lkn1wwwHWDoa3yCFB0zS2K/qH0kYhjc/nw2KxAIaCoMHhxuFwtOXbWzfxtbW1rjdvm83GfffdR9BhIpdOUutQVtjiRNiCyyLINcx873s+0H78xRdf5Itf/OKusUIIRqePkK4J1jZTPf0/fD5fu0k5nU6TSCQMZcFDgBDiR4UQfyqE+MrOV6OM/RCjaRqlUpm80D2wbLUMNpNo9181m022t7dxuVyYzWbC4fBBTtfA4KZiNpuZmZnBbrczOjqKqqqsrKx07O1tldWHHCqbq4ucffZbrC7M7/F5vJq/95Y3Mlm6QFOrYhs6xgXbCb7w1ad6zslitTE6Nct2FVbjm20RDpfLRSQSoVgsEo/HyeVyLC4uvqr3f7fTM8ASQjS6HcAHep1rcHvRNK2tIFjPvxJgCSHagZaBwWHF6/W25dsHBwcpFApsbHSXZrfZbEQGw3isgq2Nta7jTMoryoIXlTGOvvODIPTbnsvl2jPearMzMnWEeLHBlcWlrs3HoCtCud1uNjc3KRQKLC8vk81m9/uWDW4iQuezwJ8BPwm8befrnwshPnOgkzPoiqZpbGTL1IUZpVFje20Js9mMouh/o9lslmazSTAYxGq14vV6D3jGBgY3F6vVyszMTLtUXkrJ8vJyxz6nQCDA6FCUmaCVca+Clk0wP/ci1Uq588UF/PjjbyUSf4Z6bguTN8wZOcLXv/md3nOy2QkPjbJZbPDy3Ll2kOXz+RgYGCCbzbY9sozqje7028ESfQ6DQ4KmaVRVfaeqUUi2TRhtNhtCGD8qg8PPwMAAkUikbSKayWS6StiCrsbksylktja6LzDAI1ErD0UsNCWknWNMvOUn+en3/zRvenPnCjK3108wMsxmscH58+d7NvTGYjFsNltbZenKlStd6+gNbin/B/Be9HXpu8B/3/kqgPcKIZ44wLkZdEHTNFYy+g50Jb3Ok3/xmV29HZlMBpvNht1uJxwOG2uZwV2J3W5vlwuOjo7SaDRYXl7u2As8OzvLG97wBh595BEmwx48osqVcy9RLu1V4QUQiuCDP/IugitPoaXXUV0BvrHt5rkXOtoGtgkNxnAGBlnJarz08hyLi4s0m01CoRA+n49UKkU6nWZzc7OrMNS9Tr8Aaxv4K+ChDscXbu3UDK6HWq1Gw+oGoJFLEg6HsVgsRv+VwR3F0NDQviVsXS4X0cEwIbvClXNnuwZZqiJ4+5SDnzjhRBFQ9E2SDx7j26sVCvXOt8DBoRGwOtnMlblw4ULXckVFURgZGcFkMu1SFjTk2287PwE0gcellK+TUv64lPJ1wLt2nv+pg5uaQTc0TWMxpSck6rkkVlUwNjYG6NLslUoFn8+HoigEg8GDnKqBwS3F5XIxOTmJ3W5nZGRETz6srHQVk3C5XDz44IOMRYIErU0Wzr9Epdw5uaeaVH7mA+/HufgUjUIasz/G/7pS46WzL3edjxCCofEpvIPDLGc1zs0vcubMGZrNJpFIpF290epB7pUMvVfpF2B9B5iQUr547YEefBnppENCIpFAdQb0b8ppPB4PZrPZCLAM7jiulbDd2Njoauo7OzvLSNiP39Jg/uxpVhfmuyoLjvnMvHVC3+X91mqVry9V+FbWQ1NKtJpGKvmK/K0QgtGpo2SqgrVEipWVla7zNZlMDA8P02w2203Kly5dMlSWbi9Hga9JKb909YNSyi8CX9t53uAQIaWkVCqxltez9PXcFoMhf7t0d3t7GyH0fiy/34+qqgc5XQODW47X62ViYgKHw9HuR+4m+gT62nPy5EnGIiGCVli8OIemdU7uWW1Wnvjw+1HPfYVmtYglMs3/OL3J6krvEr/I8CijsyfZqqqsJzMsLS0hhCAWi2G324nH4xQKBZaWltqCNAY6/QKsjwDdmoR/BZjYz4sIIT4uhEgIIc5e9VhACPFVIcSlna/+nceFEOL/EULMCyHOCCEe3s9r3MtIKbmyuIzq9CGbDayNMna7HSGE4XZvcMdxrYRtqwSvU+mdqqqcPHmS6eFBRr0KjVyChYtzXRt/H4pYeOOYjRMDZjwWQbZu4ttLBf7gD/+A//z//Wcy26/sllmsVoYnZ9ko1Ll4eYFnn322bcJ4LS2BjlqtxurqKuVymfn5+b5yugY3DTdwsctzFwBPl+cMDghN06hWq2Sa+hrVyCYYigzgcrloNptks1k8Hg+qqhIKhQ54tgYGtwe/38/Y2Bgul4uhoSEqlQpbW1td1xJFUTh27BhDIS9OobE8373iwuVy8Q8+9JPIl76EbGjYJh5Gcw50HLvrPI+X0ekjJEpNFpb0XuNW9YbVat1lWXKtz+S9TD+j4XUpZcdCTSllSkrZXWZrN/8VeMc1j/0aesZxBj3D+Gs7j78TmNk5ngB+f5+vcc9Sr9e5tKrXwDbLeewWczsLaARYBnci1yNhq6oqx44d4zWnTjEadGGuF1m8dI7kxjpabbfCoBCC1w7b+KFZJz8wpSuXPb1cZl1zkM0V+P3f/30K+Vd2yzz+AIOjU6yVBJc2c8zNzXWV0XU6nUSjUUqlEuvr6xQKBRYXFw0p29uDFXiHEOIvrj3Q1xRD6eeQUavVqNVqVEx6abuWWWdsZASz2Uw+n0dK2TYV7iRIY2BwtxIKhRgZGWlXclQqlZ7KuqqqcuLECaJeG7KSZyvefVfK6/PyD9//PgZr6wB8dbFKvdl/jXK6PQQjQyRLDa5cudJ+3ZGdv9mVlRXK5TKXL1/uWnFyr3FdMu1CiN8QQly+3heRUj4NXJv6/WHgT3b+/SfAu696/BNS59uATwgRvd7XvJeo1WosJXT1skYpg8Nuw+HQPzwaAZbBnUpLwtZms/WVsAU9wDl58iQxjxVbPU9xc5FLZ0/vCbJaTAfMxKxVUC14X/P3Cbzt50kVqvzhR/+QSvmVICoYjnD0gVOYXH4SBY35+fmuc/Z6vYTDYXK5HJubm2xvb/csLzS4qUyhryPXHpMHOSmDzlSrVcqVKtKhl7bXU6uMj48DkM/nMZlMOBwOAoHAAc7SwOBgCIfDDA0N4fV6CQaDFAqFnkGWxWLh6NGjDDpVttZXKOS6K+D6A34+8Ob7CdgV0uUmX7lcprmPRGA4Oky5qZLK5NrlgCaTqb0+Ly8vt6s3DLGn6/fBCgDjN+m1B6WULbe0DWBw599DwNWfSFZ3HjPogqZpxLN6g3+jmMHpdGKxWFAUBbPZfMCzMzC4cbpJ2HZSVwLdU+vhhx/moaNTTEX8eM1Nli9f7Loovcab5+2TdpxCw+QO4X/jh4hvF/mj//JHaLVXerkURWFofIp8XRBPpHpKyAeDQfx+P+l0mmQyydbWFuvr66/uP8KgH/+8z/EvDm5qBp2o1WqkqxKhmmiUsjQqeWZmZmg0GhQKhbYXlhFgGdyrRCIRotFo24Mqn8/3DLL8fj8TY6NEnSrLl85RKuS7Xtuk/P/svXd0o+d95/t50Hsj0UGAIME6nKLRSJZlW5JL5N5LYrmXOD4p6z33nl373t099+TmZE8Sr+NrZ10k25FLNmvZieWeOI5tWbYljcpUksMyJNFIECwAC1jQ+Nw/QEJDERyqzAynvJ9zcEgCL4DnBUk8+D3P9/f9Cl4XM6FRwdmZEg8OrfCv//ZzpjO7z20qtZpmX4DcWnXbwqFWqyUcDiOEqO9kjYyMsLa2u7vvjYBmvwcAIKWUQojnrKPZtN79GIDX6+Whhx56Xs9fKBSe932vBvL5PHpHrT41q6p4PB4GBgZwOp3XdC7Ptf57uZDr5Vz26zxWV1frVuizs7MMDg7i9Xov2vheLpdZnE6RXYOZ2Tma/aEdNs/VUgnrSopXNgt+PqVlzezAfts7mfjl1/jCF77Aa1/32m3PUdxQ8dRwgmR8nI5Ye32nuBFzc3MMDg7S1NSExWLB4/HgdDpf+IuxC9fb39hdd931rO8jpfzzyzcihctBsVgktVACR83gwmzQ4fF46vJAm82GyWRSVBgKNzSBQACXy4XT6URKSTabZXJykmAw2DC2oLW1lWKxyEZ6mvjIAJGOXszWxi2oIZuGPzhg4buDBUZzFUqrHh796tf44499FK/X2/A+TR4/s5k0s/N5pqen8fl8QG0HraWlhWQySTKZJBKJMDIyQldX1w1rtvZcC6wx4OFL9NxZIYRfSpnZlADObF4/CbRccFxo87odSCnvA+4DOHbsmHwuE/KFPNfJ/GpjcnKSfx6TMAdtfhcRY4Rbb70Vn89HW9u1q4651n8vF3K9nMt+nsfi4mJd351KpdDr9XVpwm709PRw+sxZJpfKGFSSUFts26R0/vx5YrEYAG1tki89NgtOP6au20kO/Zbjx4/z3ve+tx58CpBuclFamEGn03Hw4MFdPwBKKUmlUqyurhIMBrFarUSj0cu2In8j/40JId601zFSyh8+3zEpXHpKpRLThSo4oLo0i9vpwGQykc/n0Wq1GI1GZfdKQYFaRuRWwSOlZGZmZtciSwhBZ2dnzcV2eo748AChtg7srsZGMSGbhje0VPnu0Co6d4TKsXfxxW88wMff9078/p3dOWqNBk8wzNRkHM4NUyqVCIfDAHU5fyKRIJFI0NraysjICJ2dnTdkkfWcJIJSyv8ppWyczvnc+SHwgc3vPwD84ILr37/pJngbsHiBlFChAaVSidx6zWHGINfRaDTodDpl5U/husJut9Pa2lp3F9zLwhZqyfOHDx0k5NCxvjjHbKbhWg0ABo3grX21HSZz753ovO2cOnmK7zzwHeQFTcCBSBtSb2FqYY3+/v5d5YpCiLoL4uTkJCsrK8Tj8V1zvRReEN8HHrzI5Xv7NzSFRiwvL7NELTahsjSHt9mFTqdjZWUFq7VmfHE5d3wVFK4lQqEQHo+Hpqam+k7vbnJBlUpFb28vHZEgQYuKyfER8nMzDR61RkewiTe1bFBdnkNjc2O47R7u/dHvmEw3lra7fUGag1HSy1VGxia2SeC3iqxKpUIikajLBXczh7qeeVYFlhDiXUKIbwkhfrb5dTfr9t3u/7+BR4EuIURaCPER4K+A3xNCjAKv2vwZ4KfAOHAe+Arwx8/luW5EyuUyC5t9/CaKGAwGhBA35IqBwvWNy+WqW9gGAgHW19efVZF1oKcHr0XN7FSSlcLuNrKtDi03+3QIlRr7S9+Nse0Yjz/+OL/4xS/qx6hUKiIdPaxIHZPzS5w+fXpX16QtK1udTlffzRofH1esbC89yT0uitPIVYSUkqWlJVSO2gq5x6Sip6ebUqmElBKLxYLRaESnU8wfFRS2aGlpedZFlhCCWCxGR1uEoFVNJj7K6MBpcrONe6z6OiO8q0NNKXEKodZgOPAq7n8sTSLZ2JGw2RfAF2lnarnC8Oh5ZmaeLuCMRiPhcJhyuVw3vhgZGaFYbGw4db1yUYmgqO09fhd469ZVgATuEUK8S0r5rAotKeW7d7nplQ2OlcCfPJvHVahRLpdZqtRkUma5Vi+slB0sheuR5ubmeqivlJKpqSkmJycJhXb2WG3R1NRENNxCaTxJYngAf6QdZ7On4bGvajOiVwsemSxiPfo6nBYtL3nJ7duO0Wi1tHUfYHyon+LMIoWVk/T2dON278wUOrT2UQAAIABJREFUUavVhMNh4vF4XZs+NjZGLBarr9QrvDCklK37PQaFZ0+5XGZ1dZWKobZDdcfRLl4csVEoFFCpVJhMJux2+z6PUkHh6qOl5ekOGiHEs+rJ0mg06CcmWCmtM5McAwQu984eq472KB/UqPnaD3+Ivu9uNP5Ovv7QcT505wbhSHjH8S63l1KxyGQ2TXXgHJHFRdrb2+v/wy0tLaRSKZLJJOFwmOHhYTo7Oy/p63E1s9cO1seBt1ErrB4HvrP5VQBv2zSZUNhnHjv+OMtVNVJKTj/6kFJgKVz3XGhh6/f7KRQKpNPpi2ZOtba2Egl4CJhVZBOjZFLxhscJIbij1cgdLbX/H3XP77HCzv8lnd5AR98RNDYPqcUyg+eGdpX/aTQaIpHIDitbJS/k0iCEeEII8R+EEI2rZoWrilKpxPLqOkW1GaTEqS5hNBopFAqYzWaEEEqBpaCwCy0tLXi9XlwuV91d8GJKjlAoxO23305fVzt+i4ZMYpy1lcZzTzgS5g/f+grWn/wecmMDffuL+Mo//QsTExMNj/eFwjQFW0kvbzCSmOTMmTP1KBWz2UxLS0stSugCueCNspO1V4H1bmADeIOU8sVSyj+QUr4Y2Goofs9lHZ3CnlSrVQYnJhEqNRtryyzOz2A0GhWLdoXrni0LW4fDgc/n2zMnZEuXfrC3i5BNy+LMJIvzs7s+/otbDMRcGopV+PtTy/xsbJVSdftjq9UaQtEYlmYfU8tl+vv76/kgz+RCK9sLi6yVlZXn/yIobHEz8FkgLYT4iRDi3UII46V+EiGEWghxUgjx482fo0KI40KI80KIB4QQiqbtWVAsFkkvFkEIjLKIQSNQqVSUy2UsFgtqtRqz2bzfw1RQuGoJhUL4fD6cTid+v5+VlZWLFllqtZpQKEQ46MdjEsRHBimuN7ZRD4VCfPyet1AeexQA401v4Cvf/DYT442LrGZfgLbeQ8yX1MSzeU6dOlUvoraKrHK5XC+ytuTy1zt7FVjdwC+klD+98Eop5Y+BX2zerrCPlEolxrO1VfPqSh6n3YbBYFB2rxRuCAKBQH2SeTY5IVArzHq6OglYNeSm0xSWGkcZCCF4Y4eZgx4dUsLJ6RL/2F/g4Uef4Pvf/35NLL01jnAUna2J5EKJU2fO7pqTpdPpCIfD9TyvtbU1RkdHlSLrhfNJ4DQ12ftrgX+g5lR7vxDiVWI37ehz5xPAuQt+/mvgs1LKGJAHPnKJnue6plQqMbVcBcDEOlr10x9FLBYLNpttV7mvgoJCjWAwWF9kDAQCrK2tkUwmaw6CuxCLxQh5XLh0G4yf66e0y25SIBjgI3cfpToXR6U3Y37RO9EYdo8lMZrMxA4cZlUYSedWOHv2LOVyLUvSbDbXjS/i8TjFYpGRkZHrft7bq8CyAiO73DYMNDbXV7hilMtlppdq/yDVwjxOpxOtVqsYXCjcMASDwedVZLW3RnBqK6TGRqju4gSo1whe32HiwzdZcRhUTBeqPLzo5DePPsl3/+m7dXdBIQQtbZ1Y3AHSS2XODY/supO1ZS8vpayv6ClF1gtDSvlpKeVRoAf4S2pGSRbg/cDPqBldvCCEECHg9cBXN38WwCuAf9o85BvAW17o89wIFItFnhiu/Ury6fMMD5xhY2MDnU6HRqOphwwrKChcnEAgUJfLB4NB1tfXSSQSu7rbqlQqDhw4QMjtwK6tMDE8sOv8Fwz4ed8tfuRKHrW1mYfnTZSru8+rWq2OaNcB1oSeydwyZ8+erY/DZDIRDoepVqtks9n6vLe8vHsY8rXOXgWWHniNEOJ7z7xQWyVU5BD7TKlUIr+5AFFZnqO5ubnW0KjsYCncQASDQbxe77YiK51OX9RdMBKJ4LQYMavKpCZGL1qQuU1q3ttnQVNcQmNtxvHSd/Po8Sd54IEH6s8hhMDf0orDGyKzXGFgYGBXt8AtK1tlJ+vSIqUcllL+NyllB3AXtexGAQQuwcP/f8B/piabB2gCFqSUW59O0kDwEjzPdc/S0hJzpZqEPZcaZW4mS7VarQd3WyyW/RyegsI1hc/no6WlBavVSigUqvc8be0gPRO1Wk1fXx9BlxWjXCc+em7XuTIc8PJHLwlh0QpSS1X+eWiFtfLu86pGqyXadYClqo7U3CJnz55lYWEBKSVGo5FIJFJfXFxdXeX8+fMsLjZWkVzrPJug4fbNSyN2/0SicEUolUqsSB1qoLo0h6+rlqqtFFgKNxoXuggKIchkMqTTaUKh0Lag4C2EEE/vJOXzTKfi+MPRXR/folfxsRf7uff4LLiC2G97B48/8gDlSpn33HMPqs3AY28wTHF9jdRijuqp03R2xHC5XDv+J7eKrGQySSKRIBKpJd93dHQoHzCfJ0IINXA3tf7hN1PbxboUj/sGYEZK+ZQQ4q7ncf+PAR8D8Hq9PPTQQ89rHIVC4Xnf92ri9OnTrKotCKCcnwKLnoGBAZqbm8lms9fUqvb18jvZ4no5n+vlPODZn8vi4iLT09MUi0VmZ2fp7+/H4/Hs2o9fKpUozKSZWZfMzM7hDrQ0PA7gdpuah3J24gsVvvzkAp0bKZaT57j52M0N5bxSa+RcfJLxiQSPP3USu8VENBpFrVZjtVoZGBhgYGAAj8fDE088gc/nu+Z2rrd+L3fddVfD2/cqsP78ko9I4ZKyvr5OSWvFCFSWZgiFjgJKgaVwY/JMq9rp6WmSySQtLS2oNwugC9HpdMRiMcqnz5CanaJSLuNriaDVNf7/sRm1fOgWN3//VB69vwPrzW/k5FM/pFKp8P73vR+1Rl2XC04lxknlZlgdGEavFYSDQWKx2LbHe2aRFQ6HGR0dpb29/ZqbbPYTIcQd1IqqdwAuartWUJO4/y9qPVkvhJcAbxJCvA4wUJPHfw5wCCE0m7tYIaBhkrWU8j7gPoBjx47J3SbkvbjYZH6tUMvAWoZkzWmsMp/mpje9g97eXmKxGB6Ph7a2tn0e5bPnevidXMj1cj7Xy3nAczuXhYUFxsfH62YSUkpaWlowGht7/vT19XHy1GmSiyVcdgsut2/Xx46uVfnJ+VXSS3Cm4id37ieoNWre/va3N1zEjHXEmM9myM1mMWqraDQaDh06xOnTp3nZy15W7xcLhUL1Pq1GUSdXK3v9Xi4qEZRS/vlel0s9YIXnxuTkJGpLEwCqtTweT82lWCmwFG5UAoEAgUCg3vi7FUa8mybd4XDQ091F2K6DlXlG+09SLu1uI9ts1vKew07ERhVj62GcL/8wg4ksX/3aV+vOSSqVilA0hjvczpLKQnJxg4nkZEPzC4PBQCQSAdgmm9jN8l2hIQ9R2yFqAmaBvwNeJKXsllL+hZSysf3Vs0RK+X9JKUObeVt/APxSSvke4FfUijqADwA/eCHPcyNQLBZJzS0itAY21gtsrORxu91otVq0Wq2SDaeg8AJwOBx0dHRgMpmIRCKoVCoSicSukSA2m42uzo66fftupk8ATqOa9/RZsKxmEBod9tvewaPHn+Rb3/xWw/lVq9XhC0XoOHCYpaqO9PwSIyM1WwedTkdraytarZZUKsXy8jLJZJKpqalL80JcBVy0wBJCvGmvy5UaqEJjzp8/j9pWq/gN1RUsFgsqlQqdTmmPU7hx8fv9hEIhbDYboVCI9fV1ksnkrkWW1+vl1luO0eZzYtVIspOpiz5+0K7l3QftaKrraF1BnC//MOOzq3z5S1/e1kflcntp6+4j0NrO9EqF4ZHRhnpzvV6/bTJcXV1lfHycXC73wl6IG4c14NvUTCiCUspPSCmfuALP+0ng/xBCnKdW3H3tCjznNU2pVOJsohaPUFmaxW41o9FolP4rBYVLhNVqpbOzE5PJRGtrK3q9nnQ6veuinc/nIxoO4TOrSY6eY2W5ce8w1KT1H72zA02pgMbuwXnn+zk7MsG9X76X1ZXG1utanZ627j7yRcjMzNUlwBqNhnA4jMFgYHJykoWFBTKZDIlE4qI90dcKe5lcfB948CKX713W0SlcFCklQ+cnUButyGoZq6aK1WpV8q8UFKgVTeFwGIvFUg87jMfj9RDEZ2I0Guns7MRlVLM4P7NrRsgWYYeGP7vdi7M8j0qjw/7Se5hcrvDlL395R8Ows9mDxeVharnMqdNnmJ3dmb+l0+nqYcRbK44TExPMzMw8/xfhxsGzuaN0DvigEOJTQoiPCiFaL/UTSSkfklK+YfP7cSnlrVLKmJTynVLKGyNB8wVQLBaZmKstQlQWZ2h22tFqtZhMJjQaza5SJgUFhWeP2Wymq6urvpNlMpnIZDLMzc01PL6trY2QtwmPEeLD/UyndzdeNeg0fPBWH9rqGlpXENerPsaUdPK5z31+18fX6fW4/S3MrVaZmpqqz5FbRZbZbK6Pb25ujrGxsYuaVF0L7FVgJfe4XHyZV+GyUiqVmNjKwCrkcdntGI1GpcBSUNjE7XYTjUaxWCxEIhE2NjZIJBKsr683PN5kMhHw+3DoBanxEdZWL+7qp9cI/vDONtwsoNLqsd/+Ll72ytc01KMHW2MYHB5Si2XODgw2LJy0Wi2tra3odLq6bCKVSl1XsonLgZRyRQjxF9R6ru6jZtV+LzAqhPjLfR2cwjZWV1fJrtVa5CqLM7gcNvR6PUajUQkXVlC4hBgMBrq7u+thv3a7ndnZWTKZzI4dIiEEvb29dLdHiNg1LGbTzE43bCkFoNms4Y9v82LfWEKlN2E9+jrKPa/hc3/3BSYmdg8kLqv0LKyWGBwcpFwus7q6ihCCUChUH9/09DQLCwsMDw/v6oR4LbBXD1arlDJ6scuVGqjCTkqlEn0vugMAq2aDm266CZ1Op8gDFRQuwOVy0d7ejtlsJhKJIIQgkUjsaokeDodxW/WYN1YZHzjFZHxs15wQAJUQfPDFEZyqNdQGK+dEmPzazqBHIQShaAyHL8TkcoWBc0MNV/t2k00kk8nrQjZxORBCvA/4L9SMmypAdvOrGviUEOL9+zg8hQtYWFhgWVWTAZYXM7ibag6ber1eKbAUFC4xWq2Wrq4u7HY7gUCA5uZmFhYWSKVSOwKJVSoV0WiUvt4eAlY1s+k4M1MpyuVdVB86FR9/aQs36WfYWF9G52lFc/C1fOnL93Ly5Mkdx6tUKiId3SxJA4npOX73yCM8cvwJzpw5Q7VaJRAI0NTURD6fJ51OUygUGBoa2nVB9Gpnrx6sJ4QQ/0EI4blSA1J49hSLRebWayuBdt0GbW1tqFQqZQdLQeEZ2O32bY2/Go2GVCrVsMgyGAzcesst9La10OrQUlnMMrKH8YVaJXjfMS82vSBTqHLviWV+NraKlJJyafsKnDcYxuENMblUYWDwXMOsrK0i60JZx+zsLOPj49e8bOIy8afUCqqPA2YpZQAwA39ELbfqT/ZxbAoXkM/nqRicAFRyU7jdbgwGA4BSYCkoXAbUajWxWIympibcbjd+v5/V1dVds7LcbjextihBq4bV2RQjp58iP9dYqi6E4NXHOnlDGGRpDb2/E9OR1/Otb36LVGqnyM1oMuNvjTFfVDGxUCVV2CCezXHy5EnW19fxeDz4fD4KhUK9H3loaOiaim7YYi+J4M3AZ4G0EOInQoh3CyEUgfRVQqlUIrNS+7Blkav1JmFlB0tBYScWi6WuSW9tbcVgMDA3N9fQSEKr1RKLxTh281HavA5s6grJ88MXLW5MWhX39Fk46NGhFnByusTD40v8zaf/hl8/9OttqYG+UATzZk9Wf38/yWRyR7GnUqloaWnBZrNtk02MjIzsatZxA3MA+L6U8r6t4F8pZUVK+RVqvcQH9nV0CnWyc3mEpQm5UaWcn8Lj8dT7rrbmMAUFhUuLEILW1lb8fj8Oh4OWlhbK5TLxeJy1tZ39xuFwmJsO9dHT4iFkVZGJjzKb2V0yeKijhbfGdFApYQgfpPN1HyYUCjU8Vm8w0nX4GL0330bXwaMUMJCYW+bkyZMUCgWcTictLS0Ui0Xi8TgrKyuMjo7u2t91tbJXgfVJ4DQ12cVrqWWJZIUQ9wshXiUapYspXDGKxSIzm1p2q1yt29sqO1gKCo0xGo11TfrWDlE2myWbzTY83mKx0NfXh89uhGKBqcTYRWV6DoOa13eYeEtXbSX+0UyVJWHlBz/4AQ8++OC2Ai3Y2o7aZCeeW+fk0BiPP/kU8Xh82zFCCILBIC6Xqy6bWF5eZmhoqG4JrwA8nXvVCEVXeZVQqVRI5mtyH111lWOH+3A6nRiNRvR6PRrNXtGcCgoKL4RAIEBraysWi4XW1ta6ZL6Ru21TUxN9fX10d7TTYtMwNxlnMbd7kdPd0sTbuk0IucGCKcRvkrtL+1QqVU1xpdPT3nOQqt5GMrfG6dOnKRQK9fFJKUkkEiwvL5NIJOrZXtcCe/VgfVpKeRToodY0PA5YgPcDP6NmdKGwT+RyOWY3JYI2agWWIhFUULg4Op2Orq4urFYrbrcbp9NJLpcjnU433KHS6XT09vbit2pZy8+SHLv4ThZAR5OWW7wqECpst74FoTXwm9/8hvvvv79eGAkhiHT04GntpGpqJrFQZvB8nDNnzuzYofJ6vXi93npWyMrKCkNDQ7tmm9yADAJvEUJ8SAihAhBCqIQQHwLesnm7wj5TLBaZKtT+tm2qCq3hFsXgQkHhCtPU1ERnZydms7mu5piammrobgsQCoXojLXjs2iYnBhlfbWxHTtAp9fCW3usCOCRdJEfjaxwbq7E6upaQ8kggFqtobWzF5XFyeRikbNnz7K2tobBYCAajaLT6Uin0+RyOWZmZjh//vyO/rGrkb12sACQUg5LKf+blLIDuAsYo7ZiGLiMY1PYg1/95nesCgNyo8rxf/sBNputrmVXUFDYHY1GQ2dnJxaLBZ/Pt614aSS/s9lsHD50kLBDx0Yhx2j/KVYKu2eFALy83UrAokJttGG9+Q0ADPQP8Hef/zvyuTxQW8Wzu5ppaeugtfsgc0U1qZkF+vv7d9jJu1yueqbXlmxiZGREycqq8QVqSouvAqtCiElgdfNnNfClfRybwibr6+tMr9RWn82iCNUSZnMtB0spsBQUrhwWi4Xu7u66w67D4WBubo50Ot2weAmFQrT4PTQbBGPnTjM3vbuzbWeTltd11OS+A7NlfjC8yn2/GuLzn/88x48fb3gflUpFuL0LabCRXljjxIkT5PN5NBoNkUgEi8VCNpslk8mwuLjIuXPnrnrzi2dVYAkh1EKI1wohvgn8CGi/vMNS2AspJafO1/SwleU59BqBxWJRCiwFhWeJSqUiEAjg9XpxuVy0tLTUi5dGb9wOh4MjR47Q5rHh0pSID/Xv2vgLNXfBN3WZ0anBEOrF/uJ3IbS1lcLPfvazTIxvt7I1W2209x4kX1ETz+Z54okndli5W63Wut18PB6vZ2VNTu6ujb8RkFJ+Hfg0NTmgDvBvfpXA30op79+/0SlssbCwwFy5prAwyTVkpYTD4QAUgwsFhSuNXq+nu7sbu92O3+/H6/VSKBR2zYvs6OigLeQlZFExPxknO7m7iO2gR8eHj1i5M2JAJTdYd0TRRY/xwLcf4OFfP8xGgyJuy2UQo4NEvsipM2eZmppCpVIRCoXqDohbLsBDQ0O7hidfDezlIniHEOJLwDTwY+C9gBUYBf4fIHbZR6jQkGKxSCJX+xBYWZjG7Xaj1+uVAktB4Tmwlb+xFUjc2toKQDweb+haZLFYOHr0KF3RFkJWNZn4KGODZ0iODVMqNijKDGre3GlGrwZ9sBvX730cbXOYQqHAF7/4RR577LFtx+v0BmK9hyjpbEzkivQPntvR2Gs0GolGo2i1WlKpFAsLC0xPTzM5OXlNyCYuF1LKTwKd1JwE/+vm104p5X/a14Ep1Mnlck/3DbOOoPY/JYRQAoYVFPaBLYfBCxcaq9UqExMTOyToGo2Gnp4eDh2o2bjPZ1IX7cnymNW8OGTgrk2tm+XQ3Rhab6K/v58vfulLDedYtVpDpKMHqydIeqnM4PBoXRLodrsJBoOsr6/Xxzc2NsbU1NRV2Ze11w7WQ8DHgCZgFvg74EVSym4p5V9IKRuniSlcdtbX15nZ7L+q5DMEArW/YKXAUlB47rjdbjo6OrZp0tPpdEPXIpVKRXt7Oz2dMVpsGhxiDfVqjvjouYa9We0uLR86YiVoVaM22XDc+X4M0ZuoVqt854Hv8OD3HkRuPD05aHV6ol0HcPpbmFquMtig10qr1RKJRDCbzWQyGaanpykUCgwPD9+Q5hdCCI0QwgYkN50E/7uU8j4gIYSwCSEU94SrgIWFBRaqtR2sf3/wf7GxsYHBYMBgMDQM51ZQULj8bC00tra2YrVa631PqVSK2dnZHcWLx+OhM9aO36IhPT7KUv7iMvVb21y8LKRFCIHt2BsxH7iL8XiSz/yPzzB2fqzheHyhCJ5wO+nlKsPxNCdOnKibQF1ozrGVE3n+/Pmrzl13r3e0NeDbwOuBoJTyE1LKJy7/sBT2olgsUlDVJBXl3CThcBiobfkqKCg8d2w22zaHwS179N3ML4LBILff9iJuu/kwQZcFTXmNTCre8LEdBjX39Fl4cUiPECpsR1+PzlcTABRLRYRqpwmeJ9CCydFMZrHEk0+dYGxsjIWFhfoulVqtJhQK1R0Gs9ksy8vLnDvXOFvrOudvqS0Ctjzj+iC10OHPXPERKexgYHwSoTVQXVtmLZ+ty9oVe3YFhf2nqamJrq4uzGYzkUgEu93O3NwcqVRqR/ESCoVoCwcJWFSkxoaYTicorq/tupP0koiZV0Vru9Tmnjtoes2fUnK18cUvfYmf//zn2xYZt3C5fUS7D7JQ1XF+ZplTwxM8efI009PTtLa21nMiL+zLapRtuV/sVWB5pJTvAc4BHxRCfEoI8VEhROtlH5nCRVlYWGDD3AxAeT5FNBoFlB0sBYUXgsFgqGvSg8EgHo/nopp0g8GAw+Ggu7sbr0XD4myGxfx8w8dWqwR3RozcHtKDUOG8/V0EOg7w9re9fdfxBKMxdA4P8YUy/WNJjj91mieffLIeDimEwOv14vf7d2SGTE9PX5oX5drgdcBDz1RVSCmTwC82b1fYR8rlMmcStZ7CytIMdosZo9GIRqNRCiwFhasEk8lET08PdrudQCBQDyVulJcVi8XoiIZpsaopzU8y1n+C/icfqak5GsjVjwX0vPuAGdPGKmqjDduxN+F4xUf5+SOnuPe+eyks73TFNVmsxA4coTncibB7SS9XGR1PMDY2htvtrvdlbfUkDw8P7+hd3i/2smlfEUL8BTAC3EfNqv1eYFQI8ZdXYHwKuzA8PILWFQRAv57D5XKh0+kUmYWCwgtEo9HQ0dGBx+OhqamJlpYWKpVKQ036FlarlVh7G36LhsnxUZYW8qwWGifPvyxsoLdZi1RpsN76dqR6u3qtUqnUk5tUKhWhaIy23sNIi4eZkprpxVXGxrbLKhwOB16vFykl8XicxcVFJicnrxk720tAEIjvctsk0DjxUuGKsb6+Tny+Zu9cXZrFYTXXsxuVAktB4ephaw70+Xw4HI56b3IikdjhWhuNRrn5psMciAbo8phpd2iQK3mS4yMNd7MiDi2v9a3yyiCIYgGtw4fzFR8hLbz89F//peF4VCoVjqZmAuE2Qm2dTK1sMJSY4vEnnmR9fZ2WlhZKpRITExMsLS2RSqUYGxvb97lvL5OL9wH/hZr9bYWa1KJCzfb2U0KI91/2ESo05PH+EVR6MxvrBey6DRwOh7J7paBwiRBC0NLSUg9kvFCTPjMz03DiCAaDBDxNOPWS7Pg5ksNnmIw31pe/Jmai2agiX4Sfjq6ysfV4Er797W/zjW98g/W1p00zjGYLwdZ2ol0HyK/DZCZbz8PaQq/XE41GMRqNTE1NMT09zcLCAufOnWP1Irkl1wkrwC3PvFIIIYBbN29X2EdWV1eZLaoBqCzO4LSZ686BSoGloHB1sRVy397ejtlsJhqN1q3S0+n0Nsnglorjtttu49ixYwTteiqFPKMDp5ifmd6xmyUE3NLq4D++1EdzcQqEwNL3cmT3q1kqXjxj0u5qpq3nMGWDk/hCiXOj4ySTSQKBQD0vK5vNks/nGRwc3NesyL22O/6UWkH1ccAspQwAZuCPgA3gTy7v8BQaUa1WOZuqyZDK+QxNTqdi0a6gcBloamqq92VtZYXMz883zMsSQtDV1UVbwE1vyEXYrqMwn2VmKr3jcXVqwVu6zWhVMDRf5sGhFaYLFR767SOceOoEp0+f5jOf+QzJxHYbXL3BiDvQQqZQ5fTQOMefeJJsNlu/XaPREA6H631ZiUSCQqHA0NDQriGS1wmPAoeFEF8XQnQIIXRCiA7g68ChzdsV9pFcLkdBXduxqixM09zkqs9bivJCQeHqxOFw0NPTg9VqJRQKbbNyb7RwZzab6evrI9pkwqUusTg5ztCZp5if2SlZ1+s0fPQVvbzEvoBOJZlY2uDLTy3xs7FVVkq7F1oGk4lIrJtgezeZlQ1G01lOnDpVH28ul6vPfSMjI2QymX1xGdzrXe0A8P1NV6YKgJSyIqX8CvD9zdsVrjDFYpHkYu3DXXk+jc/nQ6VSKTa3CgqXgS1NusPhwO/34/f7WVtbY2JiYkdDrVarpa+vjyNHjtDb003AqiaXSTCd3pkX0mxS8wcHLOjVgtFcha+fLnBcdGO96XWozLVC7vOf/zy//OUvtzUAewIhvK0dFA0OpparjIyObtPGb/VlBYNBisUiExMT9RDl8fHxfZdNXCb+itqi3/uAIWoGTUPUokU2gL/ev6EpAMzNzVE1ugAo5aYIbq44K7tXCgpXN1t5WR6PB5fLtU0y2Mhl0G63c+utt3LzwR46/A6CRslsaozcbOO+4DsORvnwTTZ6mrVsSDg5XeK+E0vc/5Pf8fjxx+uS+WdidzbRfuBIbTcrX2J4PMn8/Dw+n68+9y0sLDA1NUU8Hr+Er8izY68Ca6e11dNcfabzNwiHZ9R5AAAgAElEQVTr6+uUTFsGF8n6H7tSYCkoXB40Gg2xWAy/31/XpKtUKpLJZMMJBmrW773dXYRsWpayacaH+llezG87JmjT8N6DFjpdWtwmFVKoMLYfo+k1f4b9pfcgzE5+/KMfc99X7tuWGeJochOJdWN0NJFdLtHf37/DOdBms23Ly8pms+RyuX2XTVwOpJS/o1Zc5anNW1uXBeADUsrf7uPwFICh8+OoLE3IagW5nCUYDCoGFwoK1whbsvn29nYsFgttbW11l8FEIrHDBEqlUuHxeDh69Cg9XTH8Fg2ZxPiOOXALh0HNm7vMfPQmK20ODcUqZB0H+OHpKf7+6/fvOmfpDUYisW7CnQfIrsHY1CwjIyM0Nzej1+uZmpoin8/v6B27EuxVYA0CbxFCfEgIoQIQQqiEEB8C3rJ5u8IVplgsYvZ3AHDH4RiHDh0ClAJLQeFyIoQgEAjQ0dFR78u6cILZcva7EJ/Px6G+A0ScOszVAlPnzzHSf3JbOKPbrOZtPWY+cpONP7zJykGPDo0K9L4Yjjs/gNrazPDQMJ/+9KcZHNj+lhuMtLMuDIzPLDM6HufMmTPbcrB0Oh2RSASn07lNNjE8PHzVhjM+X6SU36Zm0343tZ2ru4EWKeU/7uvAFNjY2OCxgZrBY2V5DofFhNPpBKj3YSkoKFz9bEkGt1wGt5QS4+PjLCwsNLxPMBikvTWM36ImdX6I4vpaw+Ogpux4Z48ZbeIxpNzAcuAukqYuPv3ZzzM4uHvJYbE5iB04zIowEZ9b4Wz/AOVymUqlsm/5WHsVWF+gZnDxVWBVCDEJrG7+rAa+dHmHp9CI5cIKc+Wa85hPX6GpqQm9Xq/o2BUUrgA2m43e3t76BBMIBOoTTKP8qaamJl70ohdxqKuNmNuES1UkMzFMamyEanX7G3+TSc3rO0z86S12Wu1q1AYLzrs+iLHjNgqrRb761a/ynQe+Q3G9VkSpNRo6DhzG6o+Q2zByfmqeJ598ksXFxfpjqlQqfD4foVBom2wik8lcd8HEUso1KeW/Syn/cfPrde/ucS2wurrK2GxNTltdmsVps+BwOABlYVBB4VpDp9PR0dFBMBjEbrfT1taG0Wgkk8k0zMwCaG1tJez30GwUZBJjLMzPNsyXBBAqwZ+94xUE8mfYKBcxhHrRvegevvmT3/DAd76zzQBq27j0Btp7DmJs8hNfrDA0Mcnw8HDDiJUrwV427V8HPk1NDqgD/JtfJfC3Usr7L/cAFXZyNp5lAxW6jTWMqgoOh0OZpBQUriBarZaOjg4CgQAOh4NoNIper2dycpKpqakdfU5arZZwOMytt97KoZ4OIk49G4U5xs6dpVze+eZv1Kp4e4+FNocGld6E9fDdOF/+IYRGx2OPPcZP/+Wn9WNVajVuX5BQrJuK3kZyocjZs2d3rCZarVba2trQ6/VkMhnS6TRLS0sMDg5e7wYYCvtMNptlTV8rqCqLMzQ7bDgcDnQ6HWq1ep9Hp6Cg8FwRQuDz+eju7sZqtRKJRPB6vaysrDRcbNwygQq5nTjEGrOJUc4PnqbSQPkBtSLuA2+8i7ubF9lYzKI2O3Dc/vucd9zCZ358gkdODze8n0qlwh+O0tZ7mCX0zBbKDA0NbZPYXyn23PKQUn4S6KTmJPhfN792Sin/02Uem0IDpJQMTNY+OJmqK+jUKqXAUlDYB4QQ+P1+Ojs7sVgsRCIRmpubWVpaamiAAbU3/2AwyLGjR4k0WzHJdcYGz1Iq7lyR06oF7+w1844eM3YdaB0+rMfejM1m49V3v3rH8RqNltbOXnS2JlKLJU6cOs3JkyeZn386+Fir1RKJRHC73RQKhfpEmEwmGR0d3beVPoXrm2w2i9ETBaCvzc+hvh6cTqfifKugcI2zZQLldrtxuVz1SJPJyckddu4qlYqDBw/SHg7S7jZj3FhnfLh/1yIL4FhfJ392RxDrzGk2iquozU7UgV5+vezhc/9yhsz8TtUIgNFkpq2rj6LaRCq3yvEnT/CrX/3qivYf75WDpRFC2IDkppPgf5dS3gckhBA2IYTmYvdXuPSsr6/z8OlRADQrc3WLW6XAUlDYHywWC729vTQ1NeF2u4lEIgghSCaTTE9PN5RBmEwmDh8+TLjZhkNd4vzAqYbNv0IIYi4tv99nRa8GQ6iHA2/6Q4ym7f/vWy6DQgha2joxN/lJLm8wPJXn5Jl+zp07V+8RE0LQ3NxcN+pIpVL1zKzBwUHm5uZ2jENB4YUwOzvLXLVWTNlZw2G3YzQa0ev1+zwyBQWFF4pKpSIcDtPR0VHfzbpwEe+ZknWXy8WRI0doabLUiqyhs5RLu0vVrRYLf/KWO3mNc4a1R77F6uhxkBus2cJ8c7DMiUzj+2q0WoLRTrR2L1OrKgYSWR5++DdkMpld5YmXkr12sP4WmKXWOHwhQWqhw5+5HINS2J21tTVGsrUKfPjJX9e3PZUCS0Fh/1Cr1USjUdra2uoGGE6nk3w+z/j4eMO8EJ1Ox+HDh4kG3PhMguToOZbyjZ2OXEY1b+oyoxIwtm7mJ+dXWb4gkPGBBx7goV89xNraWm1nLRyl58it2PwR0oUNRlLTPPXUU2SzWQqFAlJKDAYD0Wi0npm1tZuVSCQYHR29rnqzFPaXeGaWgtSjYgOrLGCz2QCUHSwFheuIrf5kt9tNc3NzfTdramqKZDK5zQhKr9dz6NAhws1WLKLI+YEzDUOJ6wg4etMR/vMff5hu3Ty5n32R8tQQUqXm38bXODm9e5Hla2ml69BRhNHBcGaBh373KD//+c9JJnfGp1xK9tqBeh3wkJRy4sIrpZRJIcQvNm//xOUanMJO8vk8VasPFVCeidPZ+WqEEMpKoILCVYBzM/Q7kUigUqmwWq1kMhkSiQROpxOPx7PNjEaj0XDgwAGMxnFEIk1qbBiXx4dWp8fp9qBWP/0W3e7U8o4eM98bWqF/pszATJlet5ZwJcPjjz8OwF//1V/z9re/nYOHDtZ7s+zOJpJjw0zMr5ArnEOnFnianPT29qLRaPB6vVit1vok6HQ6qVarFAoFAoEAHo8HIS6W2KGgsDvr6+uM5msfmuyiiE5s1A0ulHlLQeH6Qq1W151rE4kEer2eXC7HzMwMY2NjuN3uunutXq/nyJEjaPr7yeYWyU+OMzc9RVtPH1qtruHjm81m7rnnHm4eHmZ9bZ2K18jPx9f42dgaKyXJzW7QqNVoddpt91Op1bT3HSGTSjCZSZPOzbFYeIr5+Xluuummy/Ja7FVgBYFf7HLbJPDKSzschb343WNPoHF4kdUKurV5AoEAJpNJ+QCkoHCVoNVqicVizM3NkU6nMRqNzMzMkM/nKRQK+Hw+LBZL/XghBO3t7TXJQmqK1cVplquSuexUTe5ntdWPbXNqee9BC4+mi4zmygzMlhnccGDqup3V0eMsLS1x//33c/DQQd7+trdjs9vQ6Q20dR9kPpthZXmR2eUlVsvzlEqn6O3txWQyYTKZaGtrY3Z2llwuVx/nxsYGuVyOSCSi5BUpPC8ymQwnU0tgA/VKFiolHA4HBoNBMbhQULhOsdlsHDhwgMnJSaBmsjQ9Pc3MzAyZTIa1tTWMRiMajYZDhw4xNzdHMpkkPb/M+Ll+Wto6MFmsuz5+V1dX/fvqhuSX8XV+m1rnqfPzFI5/jze/8bX0Hejbdh8hBIFwK4FwK3PZDOeH+1GrEnR1dV2W+W2vAmsFuOWZV4rap/lbN29/QQgh4sAyUAUqUspjQggX8ADQCsSBd0kpG6eT3WD84slBhP5FlBen8TitOJ1O5YOPgsJVSHNzMzabjWQyiUqlwm63MzU1RSqVwmaz4fV60WiefguOxWI4HA7W1taYnZ0lm18mPtyPP9KGy+2rH+ezaHhrt4aF9Sq/jK8zMg+Wg6/CFD3KwqPfpbKY5eyZs4wMj3D33Xdzxx13oNaocfuDuP1BSsV1JoYHKc0usfLkU7S3RQmFQqhUKrxeLzabrW63a7Va8fl8nDt3Do/HQyAQUD4UKzwnMpkMU6XaTtXI47+mubmIy/UGzGaz4l6poHAdo1KpaGlpweVykUgk0Gq1LC8vMzIyQjwex+Fw4Ha70Wg0eDyeWjbe6dNM5ZZJDp+hvCFqWVg2B5FYN2pN45Ll1qABj1nN988ts6ZvYuPgG/jfD5/BM7rA4VYvhxsUas1eP+n4GBuSy9aPtVcP1qPAYSHE14UQHUIInRCiA/g6cGjz9kvBy6WUR6SUxzZ//hTwCyllB7UdtE9doue5pqlUKgxO1RwEywsZgn4vFotFCWpUULhK0el0xGIxotFo3Sbd7XazvLzM2NgY+Xy+LpcQQuB2uwmHw9x00010RVsIWdXMJMcYGzzDdDqxzW3JYVDztm4zv3/ATJNRhcrioulVH8UYexGoNRSLRX70ox/x6U//DcPDT1va6vQGYr2HUFndJBZKDI6MMTg4yOLiIqVSCaPRSDQarTcpj42NkcvlyGazDAwMbHMlVFDYi8mpDFV7EIBydpxQoCZJVeYtBYUbA7PZTE9PTz03KxAI4HK5WFxcZHx8vD4ParVaDh8+TG9bCx1uM20ONTGnFm1pmbFzZ1hf2z3WsNWh5XZTlo2VHFqnH+vhV7Pm6eOxVTdf719jsXj5TS2eyV47WH8FvAZ43+blQjaAv74cgwLeDNy1+f03gIeAT16m57pmWFtbY6aoQQDl+TTt7e0IIZQdLAWFqxyXy4XNZiOdTiOEwGazMT09XXfv8/l824xqVCoV7e3tmM1mtKOjrJbWWJkvMDqbxR9uw+5qqsuCow4tHzqi4Z9OZomvG7AeeTXWA3eyPjNBeSbOzPhT3Pvlezl4sI/3vu99aLVa1BoNLW0dLDqcTE6MspbOkp6eRauGcChUt5zfGmc2m2VxcRGfz0e5XGZubo6WlhblvUfhokgpeWRgApW2h2ohj7qyQtDvR6fTKQWWgsINxFZultPpZHBwEK/Xi91uJ5vN1udBr9eLyWQiFosRi8WoVCpUKhX6+/vJ5JYZ6z+JxdlEMNKORqvd8Ry3Hu4hulDgu8fHyE5nkXIDvb+LosXJt/sLRMJFmi1Xru/zogWWlPJ3Qoj3Af8TcF1wUx74Mynlby/BGCTwb0IICdy7aQPvlVJmNm+fBryN7iiE+BjwMQCv18tDDz30vAZQKBSe932vJFNTUxQNTRiA8mwcQ1eMEydOsLS0tK0H61o5n724Xs4Drp9zuV7OY4v9OJ+VlRVmZmYolUqsrq6Sy+U4ceIEFosFh8OxQ4Kn12qplldZWpplZXmFE6k4aA00eQOYbY76cYcMJfx6C0MrRvIYMAR7MAR7MEaPsvTkD1kuFEgkEjvGIww2JmYzlEtFymurDIxMYNP/Dq/Xi8vlQgjBysoK+Xx+xzgdDsclN8HY+p3cddddl+wxFfaHxcVFTk+tgBPK8ymcNgtOp1OJFlFQuEHR6/UEg0Ha29tJpVIYDAaWlpaYmZkhkUhgtVrxeDzodDo0Gg0ajYbDhw9jj8eZmp5mfiXP+cEztHb2YDDuXOBzOyz88asPk0wm+d4/fw/tegr9Le9kbn2D//vBsxwNO3nb0SAe6+V3MN0zx0pK+W0hxA+AlwAeYAZ4REq5+17dc+OlUspJIYQH+LkQYugZzy83i69GY7sPuA/g2LFj8vlOyNfKZP6Nb3wDrbsVAN3aLHfd9VEOHz68rdkPrp3z2Yvr5Tzg+jmX6+U8ttiv89nY2Kiv3FUqFWZnZ8nn8/WMqq3C5kKklGQyGdLpNPnlNaZXipj1GnyhWu7W+fPnuTMW5g4pya1tMLlc4bfJNZYcXpyv+AgdzdDa5kSjalQMHQBgbaVAeuI8srgKGjVarZaenh70ej0bGxvMzc2Ry+XqckaXy0VbW1tNO3+JuBr/xoQQLcA3qS32SeA+KeXnlH7hizM1NcX0Rs3QpTQzgd9hobm5GbPZrBgzKSjcwDgcDmw2G9lsFpVKhcViIZfLMTc3R6FQwOl00tzcjFpdm4c6OjpoaWlhYGCAqfnabpbBbMUdaMHm2Dn/hMNhPvGJTzA+MY7FIXhsTsPwfJknE3lOpxd446EA3oaVxaXjWQUFSynXgH+/HAOQUk5ufp0RQjxIzTwjK4TwSykzQgg/taLuhufhx0+itv4eG6V13PoNnE6nIrNQULgGUalU+P1+XC4X6XQalUqFw+FgZmam7ji4ZZ++hRCCQCCA3+9ncnIS3dg403NTJNZWaWnv3HZck0lNk0lNT7OOh5PrPDFV5HQOUqeWeV3MRMimobhe5Ktf/Sp33nknfX19IMBothA7cJjF3DyZ5AQr03mWlx9Ho9HgcDjo6OjAbrczOTnJ/Pw8LpeLSqWyHy/hlaYC/J9SyhNCCCvwlBDi58AHqfUL/5UQ4lPU+oVveDn7FplMhlVjzaClOD2GP+bE7XYr85aCgkJ9HmxqamJycnLbPJjL5VhcXKSpqam+4GgwGDh8+DCWsTGyMzMUiqtMjQ2SszoJtraj1W2X/wmVQK/TY9QI3txlpskf5nsnJnl0fJ7vnZzEpdPx7vbL15v1rAqsy4UQwgyopJTLm9/fDfy/wA+BD1DrAfsA8IP9G+XVQblc5kxiDvqgspAh6HNjs9mUHggFhWsYvV5Pe3s7S0tLpFIp9Ho9hUKBmZmZusW71+vdJqcSQhAKhbBYLAwMDJBZWmC0/xRr5Q2klNt2BrRqwSujRrqbtfx0dJX5tQ3+4WyBm/06SiO/ZWxsjLGxMaLRKG980xtpbW1FCIGjqRmLzU5qfITzuQUEJVzL66ysrHDgwAFMJlM95PxGYFOyntn8flkIcY5ajInSL3wRBuPTYHKwUVqjkkvRGurG4XAoBZaCgkIdnU5HNBrF4/GQSqXQaDS4XK5tC47Nzc3Y7XY0Gg1dXV20t7czPT1NPB5nbmWR0f5TBFvbsbuad30ep0nHR14a5bY2F/9wPMnscpEfJeHj8vJsZe1rgUVNbvHg5gcCDfCPUsp/FUI8AXxHCPERIAG8ax/HeFWwsrKCs+sWZgHNygydsRgajWZbno6CgsK1ic1mo7e3l9nZWaampjCbzSwsLDA3N0c8HsdqteJ2u7cFszocDo4ePcrAwABziyucSSQ4pwZnkxtPsGVbSHHQquFDR6z8LrXOY+kiT2VKbMhWhNaALK8zMRHn85/7PAcP9nH3q19NMBhEo9US7TpAtVKhXCqRHBsiPrtE6eRJ3G73frxMVwVCiFbgJuA4z7Jf+EakUqnw63OToHFQnkti1KlojUSUeUtBQaEhZrOZ7u5u8vk8k5OTGAwGCoUCs7OzZDIZ5ufncbtrmwsajYZQKITb7WZkZITMbI7MxDDzM9OEojF0+t17rA4E7Pz5Gw/wtX99nJf55WWTK+9rgSWlHAcON7h+HiXEeBv5fJ5lYwAqcNBn4nD3YfR6PTpd47RrBQWFawshBB6PB5fLRSaTqWdn5XI55ufnKRQK2O12mpub0W46KBmNRo4ePcrMzAxzmRQ+kySXyzC+vES0s3eb05JGJbgzYqSrScsPhlfJ4yH4+j9hrVRFpTdRzmcYTZzm7P/4Ww4e6uPuu+8mGAyi1mhQazS09x4ieX6YRH6Rmdlz2G1WotHofr1c+4IQwgL8M/AfpZRLF07MF+sXvtEMmQByuRz9MyUI1PqvrEY9uVyOs2fP1nc/r6Xz2Y3r4Rwu5Ho5n+vlPOD6Ohd4ducjpWRhYYH5+Xmq1Sqrq6ssLCxQLpfR6XTY7fa6gktKyUZpjep8lulMirHREZp8QWzOJmZmZjCbzJgt5v+fvTuPkiu7Czz/ve+92CMjM3KLzJRSu1SSSrWqXJur7DLeCpuDzQww0A1N9wDmDAOzHHfTwHQ39GHOAH3cGKbNzOkC0zaNGRqbMmCwDdi4sCkvtZdr0ZZaUlLuW+zL2+788SJCmVpKylRKEXr6fc7RkfJlLPdGVuWNX/x+93ep1WprniNXPkH+TINvfCO2oaY7V2vI1OkMlrhGZ87PMOsmQGsG/TwDA7vkU0AhQsiyLMbHxxkeHl5Tl764uEg+n6dQKNDX18fg4CCWZWEYBiMjI+zfv5+9e/dy7Ngxzi9XOPHGK4yO71zT0h2Cg4p/9FCaz7xWpkCKVqIrOjhOdHCcxK77efO5P+e1j/3HNRkt07TYse8gs+fOcO7kcZZK86RffpnR0dEOvVI3l1IqQhBcfUZr/XTz8jXtF77dGjIBvPTSSzR6CgDYcye5e/tW3vGOd3DXXXcxPj4O3FrzuZIwzGG1sMwnLPOAcM0F1jcfz/OYn59nbm4Oz/PalR2O4xCPxxkcHGzvVbZtm4mJCaZmF5ireBhuncFsH8Mjo/Rls+zZvWftY1cKbO81efzxxzf0fvpq85AA6xagteabJ+bRREh5RXpjmt7e3jUb4IUQ4RKLxdi1axeVSoXp6Wksy2JgYKAdaOXz+TWBFkBvby/33HMP1htvML9SYv7McabPWvT0ZhkZ304kEmS8MzGDf3pXmu/O2WzvsxhMGLx4eoFvTntEsmNk3/1TVF7/e44t5jn3qf/Kv/nFf4VhmiilGN22E4wIZyaOcnaxxHPPPYfjOKRSqTVjCRMVRKifBI5orX9r1bdkv/AVHJ+cRvcMg++RVTX27riDvr4+WbeEENfMNE1GR0cZGhpidna2XdlRKBRYXFzk/PnzxGKxdqB18OBBBgbmOHnyJIvlEifPz5Kfn2brzl3s3L4D8yauT+FbCUOoWq3yykwV6CXj5unpiZFOpyWDJcRtIJVKsXfvXkqlElNTU0QiEQYGBlhaWloTaLW6+cViMe677z7m5uaYnJykXKtTKC9y8s0CO/YeJN4sq8jEDB7bdqFO/bF9OR7crfn8a0ucrkTpufdJAKI4zFU1o6veFydSabbu3kejtMLxmTyFxkvEIyaZRJRt28Y5ePBgu4wxJN4O/DjwmlLqlea1XyYIrGS/8GW8dHYF6KffcjjwyAPsGh8gFovJuiWEWLfWnqtcLsfc3BymadLb20uxWGRxcbG9Ng4ODrZL7c+dO4dXyWNYGmdllleee5a9B+8i09d/9SfcjDHflGcR1+XYsWM8O7FINNdL8eRL9D+xn0wms2bDuxAi3Hp6eti/fz+FQoHp6Wmi0SiDg4PtQGt6eprp6Wn6+/uJx+OMjIwwMjJCpVLh+PHjTC8WOHXkVcZ27KVv4PKdlqKm4ofvGeC1eZs3Z0pM52vYkR7+6LUyO/sstvdF2N5r8eUvfIGx0VG+513vQuGiTZOFYpHJpRUWSnUWFxd55JFHQtPlVGv9j8CVdkLLfuGLlMtljgfVgWRVhbih290ww5jhFELcHJFI5IqB1tLSEjMzMywsLJDNZtm+fTuNRoNEIsHKygqJjMXx115iaGwbW3fsvuFjld90t4Cn//pviAwfQnsOK8eeY/RH3yWfAgpxm+rt7W2XSMzMzLQ/tTt//jzFYpFCoUA6nWZgYIBkMkkqleLuu+8mfvw4kZl5Zk4fY3lhluzgML3ZAQzTXPP4SinuzsW4OxfD8zVfOV3j5VmbiRWXiZUgS+Zk72f+zKu82zQYHt5Kb6YXgFqlwvE3X8WfXWZscpIDBw7c9NdHdN7Zs2eZagSbxlP2MnETRkZGpDxQCLEpWoHWyMgI8/PzmKZJJpOhUqmwtLTEwsICi4uLQFAFsn37dtLpNImjR5lemuKVuRlc1wFu3JEREmB1Od/3+dtXzqD23k1jfoJtw33t8wCEELevVqBVLBaZnZ2lr6+PPXv2kM/nWV5eZnJykng8Tn9/P5lMhgMHDpDJZIifOkWpUWb5XJGZyVP0DgzR05sllcmsae0OYBqK9+9O8vDWOJN5h8mCy5HZMpH+Lbj9W/itbxcYzzZ4YGeNR3YN0JNKMTyyhcr8GXz/xh3gKLrb60dPsOjGQGkilXkyfTGy2aysW0KITWVZFmNjY+RyORYXF5mbmyOVSlGv11leXqZYLALBB4f79+8nl8vx2muvMbuwRN0xsQx1w7LqEmB1uVKpxDk7SQxoTB/nrv176e3tJZPJdHpoQogukMlkyGQynDx5st1kor+/n0KhwPLyMtPT08zPz5PNZsnlcuRyORYWFpidnWU5X6Rcnmd+ZY66C7Fkir6BQbIDw2tavPfGjHZW6/ERzZ+/OEkxMUrVMzi1VOfU0nm+9Pos//zRHQx38LUQnae15ul/eBGdeAi/MMfZE6/z6Pe+k1gsJhksIcQNYZomuVyO4eFhlpeXmZubIx6PMzw8jOu6GIYBQDab5fHHH2dlZYVqtUosFiMev/KZWddDAqwu99WvfhVjNCiz8WePcf8P/CB9fX1Sxy6EWCORSLB7927q9Tpzc3NYlkU2m6VcLrO8vNwumejp6aG/v5/R0VHK5fKF9u/FIjWnTnF2krlzZ4glUvT09ZPpy5JMX3hj3JdJ8+F7t1CtVckOjbCsk3znbJnjc2X+099PsCsb4YGMyWP6skdCiZBbWFjgjQUHtkFtdgK7UmR0dJRMJnPDDvQUQggIMlUDAwMMDAxQLBaZm5ujUqmQy+XW3Ka/v5/+/hvb7ELepXe5P/7zLxEZ+zC+XSNnVRgdHZUyCyHEFcXjcbZv386WLVtYWFhgYWGBdDpNo9FgZWWFQqFAsVgkFgvKtsbHx9mxYwee57GyssLs7Gzw6Z7doLI8xdm5cxjRBNnBHJlsP7H4hQMZExGDe4d6eHz/Fv7uzTm+8N1pTq04nFqJ89ghm0MdfB1EZ5w8eZKV6DAWYM+eZM/2LQwMDNDX19fpoQkhbiOt6o5OkQCrizUaDZ6bLGCMBQc1PrB7O/39/RJgCSGuyrIsRkdHGRkZYWVlhfn5eWKxGMPDwxSLxXYwNTc3RyaTaZ+pNTg4iOd57RLDxcVFCpUGpflJ5s+foXdwmGRmYM1zGUrx/jtHeHzvIF947gTnFwvs7pcup7ejv/2Hb2IO70P7Hu7ccfa/+/vo6+uTstdcP94AACAASURBVHYhxG1FAqwu9sILL1Dr20kKaEwf4/53383AwACJROKq9xVCCFhbDlGtVllYWMCyLPr6+qjVauTz+Xb3wWg02m6e0brPrl272oHW3MICs/kFZqemsB0Hv1FdU2aRjFq8Y3uSSmK+gzMWnVKpVPjrV86hduynMXOCkd4EY6Mj9Pb2hu1cNCGEeEsSYHWxp/7LH5LY834AMoXT7Nz57hteMyqECK9kMsn27dvZunUrS0tLLC4ukkgkyOVyFItF8vl8u6wwmUzS29tLT09PO7O1detW3njjDVSjRMOt4RTmOf76yxw4dC/pnl5M2Rt6Wzt27BhT5jARoH7ude7Zua196KcQQtxOZDXsUrZt89VjS1hvj9GYneD+7cGmPVmohBDXyzRNhoeHGR4eplKpsLi4SCQSoa+vD9u228HWzMwMs7OzpNNpMpkM6XSaw4cPk82eolQq4bouNnUmj7xCw4dtu/ahpbnFbevP/+pLWKMHAfBmjnLXQ+8im83KuiWEuO1IgNWlTp8+TerQu2kAjTMv8dD33M3o6OgNaycphLg9pVIpUqkU4+Pj5PN5lpaWiEajDA4OUqvVKBQKlEolSqUSSil6enpQSpHJZNi+fTuu6+L7PvNLK0yePobjG2ST5tWfWIRKsVjkr1+eRN1xL/bSOUZ6EwwP9LJ161bpeiuEuO3Ib70u9fwbEzR6x1Ha4/HtwZuf1W0mhRBiMxmG0d535TgOy8vLLC0ttUsIq9UqxWKRUqmE53lYlkU0GmXPnj0MDQ0xNTVF6tXvslKuAUGWTNw+Xn75ZWaSu4gCjcnvct+OrfRnswwPy8loQojbjwRYXahSqfDl4wWgl6yzxIHtOUZGRhgYGLjqfYUQ4npFIpH2ocT1ep3l5WVWVlZIpVKMjIxQqVSoVqsA7bONtmzZQi6XY3FxkVKpxPj4eCenIG4iz/P4z//1T4lseRLtuTDzBocefjejo6PSnl0IcVuSAKsLHT8xwSvFJAAj7gwj/b3s2bNHujAJIW66eDzO2NgYY2NjVKtV8vk8Kysr1Ot1TNOkp+fCIcSWZTEyMsLIyEgHRyxutmPHjlEcvhvlGzjTx9iRy5LL9nDgwAEMw+j08IQQ4qaTAKvLuK7LH3zp25T9rcS8GrsSdUZHdzM6OtrpoQkhbnPJZJJkMsnY2Bi2bWMYhuyvuc35vs9zL7zIKT8oBXx4PMXw8J3khocZGxvr8OiEEKIz5KOlLvPpT3+a//biFADJlROM9qXYsWMH6XS6wyMTQogLotGoBFeCiYkJvnzGpUqUtOkTK0+xdaiPPXv2EIvJYdNCiNuTBFhdxPM8/q9P/AGJ3W9Dey7uxLcYGR5k7969nR6aEEIIsYbneXzt2y/xQjXYH3xnbIl0xGCgNygPFEKI25UEWF3kqaeeojj+dpQyqJ18jvc9dIg9e/aQzWY7PTQhhBBijYmJCT7xzVlcTLYkXOKFScYGeti3bx+ZTKbTwxNCiI6RAKtL1Ot1fu3//j2SBx5Hey4jpWPs2THOoUOH2l26hBBCiG5Qq9X49U9+jlLfXrTrUHjhC5jaoz8V4/Dhw50enhBCdJQEWF3iF37hF3APfAClDOqnnud7Hw6yV/39/Z0emhBCCNGmteZr//B1/r4YNLaoHP1H3JVpxgeD7FVvb2+HRyiEEJ0lAVYX+Pa3v80nv/gtkvsewXca7LIn2bllhIceekiyV0IIIbrKyZMn+ZU//jpG3xhueRn7xLM8+sA95PpSPPbYY50enhBCdJwEWB22uLjIj/zYP6PvPf8TAN7xr/N9j93N4cOHpYZdCCFEV8nn83ziDz7D3OD9AJRe/iKH9u5g//gQ73jHO6TjrRBCIAFWR/m+z4/885/GfvznifTlcAtzvGebyfhojvvuu6/TwxNCCCHaGo0GX/rSl/jTkwojGqcxdZRMdYZ3PXgPe3bu4ODBg50eohBCdAUJsDro4//P73FkyweI5nbhlVfYOv8t7tu3jfe9731yvowQQoiuUSwW+dKXvsS/fuoLRHceRnsOjTf+ju95xyOM9qd573vfi2HIWwohhAAJsDrm5JlJ/mxugEh2DGdlhvh3P8uHHt7P2x99lJGRkU4PTwghhACgUqnw1a9+lX/5H/4z3PffAVB+9W94+M5d7N8alAb29PR0eJRCCNE9JE3SAeenZ/mZT32HaSdFDJux5ed5z3sf5q4Dd/C2t72t08MTQgghALBtm29961v80m9/ivp9P4oVTVA//yZ39TZ48OBB7jqwj7vvvrvTwxRCiK4iAdZNVCqV+Ma3n+c3v7HEpJ3C0i53+yc5dHgfB3dv43u/93s7PUQhhBACCM66evbZZ/nj70ziPvwvsFQEZ3mKndWjPHz/AfZtH+P9739/p4cphBBdRwKsm+Tpp5/m5/7NrxN9189CzzAR7XC/nuDggOLg7m38wA/8AKZpdnqYQgghBMVikS9/5Wv87ss1Jp0RUJDVRbLlV3ng3v0cGB/m+7//+4lEIp0eqhBCdB0JsG6w5557jo/+q3/Nd50cfR/8P8CMYNaWeTg5xx1Zg7vu2M0HP/hBaWohhBCi4/L5PJ/4xCf4+gvfZeHgD7Pi92Apzf39DlucFczUDu7ePcb3ffCD0pJdCCGuQN7V3wDz8/P82Z/9Gb/7h3/KVGwH6Xt+mmwyONm+NvEdDkdnuPvwAR579BEefvhhOUxYCCFER73yyit8/Ld/m7/4yj/ijx6i77F/guEnSFs+7xtpoPMzJE2Hw4d28653vYu+vr5OD1kIIbqWBFib5OzZs3zqU5/i85//PG9MF+l7/MdIvvNf0tv8vrM8Tc/0d/jhe8c5tO9x3vOe9zA2NtbRMQshhLg9zc7O8o1vfIOnn36aZ555hiU3xtCHf4m+H/uh9m2ilTnes03jLCyzazjD3fsP8vDDD5NKpTo4ciGE6H5dHWAppZ4Efgcwgd/XWv9GJ8ZRq9WYn59nbm6O+fl5zp8/z0//9E9Tr9cpFAqcOH2Wz3zleT739XPE7/spxt6/AwDt2tTPvEJf+QxPHhzlzifv45GHH+Lee++VkkAhhAiBblmnLuY4DuVymWw2277mui7/7lf+Pb/39N9Stj0ifaNER/dhvet/ZXTsDpQVxW9U0eVFxvQih4dNRiN97LhzB4fuPMj+/ftlr7AQQlyDrn2Xr5Qygd8F3gucB55XSv2l1vrNG/F8nufx+7//+5w6dYqJiQnOnj3L/Pw8i4uLVKvVYExWlOSBdxAd3sWXFv4UrQxKrsFkPY7PLjJv2wUEgRXnXmaXM8nDh3aza/wx7r33Xg4dOkQikbgRwxdCCHGT3ex1CuD06dN8+ctfZmFhob1GrayskM/nyefzFItFisUi1WqVBx98kJ/8yZ9sr2EV3+LzpZ2kPvTvuFwOypw/ygHvDHu2b2HL4BD7tg5z5513sm3bNlm7hBBiHbo2wAIeBCa01qcAlFJ/AnwIuCELV7Va5aMf/SiVSmXN9cjgdsb+yS8CYKSymPFgU++ra26m6aOKN3eMEQrcs7WXsUcGuPPA2zl48CBjY2PyqZ8QQoTPTV2nAL72ta/xsz/7s5dc73v8x0i+4+0YQF/zz4xp8p9O9+PrAQAaWLhJC69awM3PEvEbDMY1g0mLbX1RDh1OMtz/KMNDQ/T397N//36SyeSNmooQQoSW0lp3egyXpZT6QeBJrfVPNb/+ceAhrfXPrbrNR4CPAORyucN/8id/sqHnKpfLrKys8Eu/9EtMTU2t+V50ZC+jP/Hx9td6ZQpz/gjD/X2kk3HiymHYWyJleAwPD7F161aSySTpdLpjderlcjkU3Z3CMg8Iz1zCMo+WMM0nLHNpzeOJJ57o+u4/17JONa9vylq1srLCN7/5TT72sY9d8r3+J3+ennuufiZV2l5m2/yzZOIRYrEo8USCTCLKWH8PO3fupKen56Z9IBiG/2bDMIfVwjKfsMwDwjUXCM98rrZWdXMG66q01k8BTwE88MAD+oknntjQ4zzzzDO87W1v49VXX6VYLLJlyxZGR0cZHBwk3Ztloepz7tw54hGTPaNbSCb3kEgkSCQSjI2Nkc1mMQyja7JUzzzzDBt9LbpJWOYB4ZlLWObREqb5hGUuYZnHapu1Vn3ta1/jAx/4ABMTE2SzWfr6+ujt7aWnpwcSvZyYfIFIJEI8FicajWKaJsPDw8QTceKxOMlEnK29wxjGwTWPm0gk2Ldv303fGxyGn3UY5rBaWOYTlnlAuOYC4ZnP1ebRzQHWFDC+6uutzWs3RC6X4zd+4zfQWsvBiUIIIa7FTV2nlFI88cQTPPTQQ0QiEVmrhBCiSxmdHsBbeB7Yq5TaqZSKAj8C/OWNfELLsmTBEkIIca1u+joFkEwmZa0SQogu1rUZLK21q5T6OeBvCNrf/oHW+o0OD0sIIYQAZJ0SQghxeV0bYAForb8IfLHT4xBCCCEuR9YpIYQQF+vmEkEhhBBCCCGEuKVIgCWEEEIIIYQQm0QCLCGEEEIIIYTYJBJgCSGEEEIIIcQmkQBLCCGEEEIIITaJBFhCCCGEEEIIsUkkwBJCCCGEEEKITaK01p0ew6ZQSi0Akxu8+yCwuInD6bSwzCcs84DwzCUs82gJ03zCMpfWPBa11k92ejCbTdaqNcIwnzDMYbWwzCcs84BwzQXCM5+3XKtCE2BdD6XUC1rrBzo9js0SlvmEZR4QnrmEZR4tYZpPWOYSlnncCGF7bcIwnzDMYbWwzCcs84BwzQXCM5+rzUNKBIUQQgghhBBik0iAJYQQQgghhBCbRAKswFOdHsAmC8t8wjIPCM9cwjKPljDNJyxzCcs8boSwvTZhmE8Y5rBaWOYTlnlAuOYC4ZnPW85D9mAJIYQQQgghxCaRDJYQQgghhBBCbBIJsIQQQgghhBBik0iAJYQQQgghhBCbRAIsIYQQQgghhNgkEmAJIYQQQgghxCaRAEsIIYQQQgghNokEWEIIIYQQQgixSSTAEkIIIYQQQohNIgGWEEIIIYQQQmyS0ARYTz75pAY29Odb3/rWhu/bjX/CMp+wzCNMcwnLPMI4n7DMZdU8QknWqnDNJwxzCON8wjKPsM0lTPO52loVmgBrcXFxw/dtNBqbOJLOC8t8wjIPCM9cwjKPljDNJyxzCcs8rkTWqgvCMJ8wzGG1sMwnLPOAcM0FwjOfq80jNAGWEEIIIYQQQnSaBFhCCCGEEEIIsUkkwBJCCCGEEEKITSIBlhBCCCGEEEJsEgmwhBBCCCGEEGKTSIAlhBBCCCGEEJtEAiwhhBBCCCGE2CQSYAkhhBBvQSn1B0qpeaXU66uu9Sul/k4pdaL5d7aTYxRCCNE9JMASQggh3tqngCcvuvaLwFe11nuBrza/FkIIISTACjPP8ygUCqE5NVsIITpBa/11YPmiyx8CPt3896eBD9/UQQkhhOhaVqcHIDaf1prJyUmWlpbQWqOU4tChQ0Sj0U4PTQghwiKntZ5p/nsWyHVyMLciz/N49tlnqdfrRCIRDh8+TCqV6vSwhBDiukmAFUKVSoXFxUXy+TzVapWxsTHK5TL9/f2dHpoQQoSO1lorpfSVvq+U+gjwEYBcLsczzzyzoecpl8sbvm83mpmZ4fipSRZqmr4YnD9/nrGxsU4Pa13C9jMJy3zCMg8I11wgPPNpzeOJJ5647PclwAohx3EAmJubQ2vN2NgYtm13eFRCCBEqc0qpUa31jFJqFJi/0g211k8BTwE88MAD+koL8tW81WJ+K/rsZz/Lnn37iSxVGemN8cAD97Jv375OD2tdwvYzCct8wjIPCNdcIDzzudo8ZA9WCLmui9Ya3/fRWuN5XjvoEkIIsSn+EviJ5r9/AviLDo7lluR5Hp4OEn+eRtYpIURoSIAVQp7n4Xle+2vHcSSDJYQQG6SU+v+AbwF3KKXOK6V+EvgN4L1KqRPAe5pfi3XwPA/P11iRCJ7nS4AlhAgNKREMIc/zcF23/bXruhJgCSHEBmmtf/QK33r3TR1IyLiui2dEiCcSeE5VAiwhRGhIBiuELhdgycIlhBCim7iui+drYvEEntayTgkhQkMyWCHUCrC01kxPT2MYBn19fe2W7UIIIUSnBRksTTKeoJKXAEsIER6SwQoh13XxPI9yuczM3AInT54EkDJBIYQQXaPV5CIWj+P70uRCCBEeEmCFjO/7+L6P53lUq1UcFaFSreE4jixeQgghusaaEkFfmlwIIcJDAqyQaS1QrcYWLgY1J8hmSQZLCCFEtwiqLVoBVrB+aX3F85qFEOKWIQFWyLSaW3ieR71ex8OkZnuUSiUJsIQQQnQN13XxdNCm3bIsPF+vadAkhBC3KgmwQqa1ONVqNWzHxVMGDR8KhYKUXwghhOgarT1YlhXBbAZYsk4JIcKgowGWUiqulHpOKfWqUuoNpdS/b17fqZT6jlJqQin135RS0U6O81bSWpzK5TKuNohFYzi+Ip/PSwZLCCFEVwgOGfZRKAzDCAIsadUuhAiJTmewGsD3aK3vAe4FnlRKPQz8JvBxrfUeYAX4yQ6O8ZbSymAVi0VcDHoHhvCVSblSpVKpdHh0QgghRPBhoK/BtCIAWFZEMlhCiNDoaIClA+Xml5HmHw18D/C55vVPAx/uwPBuSZVKhdnZWZaXl3Ew6Mn0EU8kqTkeS0tLnR6eEEII0Q6wLCs4jtOSEkEhRIh0/KBhpZQJvAjsAX4XOAnktdatna7ngS1XuO9HgI8A5HI5nnnmmQ2NoVwub/i+3eall17i+Olz5Ms1jGQGIzPCcr5Adb5AzAi6M90qhw2H6ecSlrmEZR4tYZpPWObSmscTTzzR6aGIG+hCgBVksEwrgmdLgCWECIeOB1haaw+4VynVB3we2L+O+z4FPAXwwAMP6I0uyGFazMvlMs+9PsHwrp3s2L2X3NgWfNeG8gJ33HEHjz/+ePsTw24Xpp9LWOYSlnm0hGk+YZlLWOYh3prjOHgazEizRDBi4dflsGEhRDh0eg9Wm9Y6D3wNeAToU0q1ooCtwFTHBnaLaTQaeFqTzvTRPzgMQDQWw/H84FwsaYErhBCiw4IMll5VIhjBkcOGhRAh0ekugkPNzBVKqQTwXuAIQaD1g82b/QTwF50Z4a2n0Wjg+TroymQGP95oLI7jSoAlhBCiO1xaImjha2SNEkKEQqdrxUaBTzf3YRnAn2qt/0op9SbwJ0qp/xN4GfhkJwd5K7FtG8/3MUwTwzABiMUSOJ6m0WjI4iWEEKLjXNdtdhG8kMHyJIMlhAiJjgZYWuvvAvdd5vop4MGbP6Jbm+d5eJ6HprloNXtZRGMx3ObCJWdhCSGE6DTHcfBZlcEypYugECI8umYPlrh+rQDL8zWmabavW5YFysD2PGq1WgdHKIQQQjQDLH9Vm/aIBFhCiPDodImg2ETtDNaqunYAwzSCDcSOJ4cNCyGE6LjWHizP91leXqaQX6HWaEiAJYQIBQmwQqQVYPm+xoxc+NEahoEVieJ4vgRYQgghOs5xHCrVGrPzc/RkbOr1GkvLeQmwhBChICWCIeL7fhBgEdSzt5iGiWlFsF2farXauQEKIYQQBAFWrR50vZ2enqZWr9OQfcJCiJCQACtEHMe5UCK4OsAyTaxIBMeTAEsIIUTnOY6D4/v4vsb3fdDB9Xq9Hnzd5RYWFnj++ec5cuQIZ8+e3dBjHD16lKmp4JjPubk53njjDbTW7e/Pzs5ecm1mZoY333zz+gYvhLjhJMAKkUajgQdgGBjGhR+tYQR7sGzXkwBLCCFExwUfCPrtbreu52KaFg3buSXKBCcmJnjp6GmOnV/aUMBTrVY5duw4R44cAeDYsWNMTJykUCi0b9O6ViwW29eOHj3KiRMTlEql65+EEOKGkQArRBqNBtoHpRRKqfZ1wzAwIxEcKREUQgjRYVoH5zL6gGq+DXFdF6MZYN0K5zXatk2x7lB2NbZtr8kyXev9bc9vl0S2vl4dXF7umuM4a+4nhOhOEmCFSPBLHkCtyWApQ2FFgxLBRqOB53kdG6MQQojbm+u6NGwHwzDb5YCe52GaJg3n1shgtdrMA3i+XndQ6DgOjucHBy63zql0LxNMXcM1IUT3kQArRGzbxvE9DMNAGWrN92KxOI4ffGp4K3w6KIQQIpxc18V2HJRhXNhvpYPqC9txb4ngwXEcXN/H2OAByY7jBIGZH2TAWgFX63GCoMtdc83zPBzXw/UlwBKi20mAFSLBJ2oaddEeLIBINIbb/EUdtl/Mtm0H5ZFXKdG41tsJIYS4cRzHwXaCPVee57X3YaEMGnb3B1ha63YGKxKN4un1B1iu6+L5Gt/X1Gq1drDVehzHcfC0vyZ4C4IyH8+j618jIW53cg5WiNi2jes1Ayy1NoNlWRbKMNtnYaXT6Q6N8sq+8Y1vAPDYY4+t2UPWcvz4cSYmJnjnO99JKpUC4MiRIxw9dhyNZnhwkMcee4yjR49y+vRp3vnOd5JMJgF44403OH5iAo1mNJfjkUceuXkTE0II0RYEWB6GaeL5HrFojEajAYpboslFKziyLCsIEq8zg9UKsFY/TlA6yGWCLvC0L5UoQnQ5CbBCxLZtPN/HUAZKrc1gGYaBMk1cn65sdFGpVJhfXAKC8bUCqNWmpqYoVOvMzs6ye/duIGhZOzFfpu74KBT1ep2pqSnylRrz8/Ps2LGjfbsTc2Vsz8dA4TgOkUjkps1PCCFEoJXBUoaB9jXRaDQIsFDYbvdnsFrBkRmJBAHWBjJYQYlhEFRVq1U8rS/JVrm+xtdcmsHSksESottJiWCItAIsdZk9WKZptj9pq1QqHRrhleXzeaq2R9X2yOfzl3zfdV2KxRLLZafdxtZxHIqlMrav6ento2p7LC4uUiqVWak47cdpNBqUyhVcFKmeDDXn8s8hhBDixgsaNbjtSgUrYjXXLNUOOLpZkEnSwbpqmXjexgIsX2t83Qyw/EsDrOCav+aa74PnyR4sIbqdBFghYts2rq8xDAPjMhks04zgduniVSgU2gHW6nNAWorFIjXHo2q77eCoUChQc1ySqR56Mr3UHI/Jycn27VqP03rsVDpDOtNLzfYv+xxCCCFuvGAvsNeutDANE8u00Ap8HZTMdbNW8GNZQQbL99lQF8FWiWA7wNJrAyxfX1o2eHEgJoToThJghYht2/ief9kmF8EnbRYN16NcLndohFeWz+epOd4Vs0utDFfD9SmWyjhOkMmqNXzSPb2kMr1UGy7Ly8tUbY+661MoFPE8r/3YqZ4eUukMVceVDJYQQnRIK4NFM4NlmiaWZYFW+Lo7y9hXuxBgWRimhavXfy7VJSWCzYYXF5cIrm4B3/oQdSMliUKIm0sCrBBp/UJWhnlJiaBhGFiR4Cysblu8tNZBlqnhUm0EmaeLO/3l83lqtovWUHOC2+TzeaqOSyrdQyrdQ80J2v3WHA/t085iBRksl3RPL+lML9XG5bNkQgghbjzHcXC9VRks08A0TTTgaW6ZDJZpRYISwQ1msPxmAHXFLoKXa3yh195OCNGdJMAKEdu28fXlSwSDTwij2I7XdXuwKpUKlVoDMxLDjMSo1BqXjLFV5teT6aXW8Mnn8+2sVirTSyKZwsfA8TyqDa9dMtgKxGq2T6onQyKZwtEEe7fW+YmjEEKI62fbNo7nAQoUGEawl0kZBp7n3zIBlhVpdRFc/56oC00sNL7vt7NVlwRY+tJrvi9NLoTodhJghYTneXiex4ofYyk6wqvzDV6dazCx7KC1DmrcuzSDFeyl8kj3ZEg3m1CszjC5rkuhWML2NUOjY1Qdt93MwvE1yVTQcj7Vk6Fc93A0DORGqDY85ubmKFWqeCjiiSRKKVLpS59DCCHEzVGv1wnOF1ZBObsK9mGZhoXj+dTr9U4P8S21giPLijRbzW+8yYXnB9Uavg6CqVYm7HIZrCDzp+WgYSFuAdKmPSQ8z8P1fL6jDuLGLM5MXPgE8H84mGJHrxUEWG5nA6y5uTlOnjzJ/fffD8Bzzz1HtVoNMlGDvQBUF4tr9kitbmaRzvQxZXssLCwE+6pSmXYnqlRPhqX5Aql0hp5MH7NnXKanp1ku1VBGhGKxiK99NIr55TzPPPMMvb29PP744ziOw0svvbSmzGPr1q3s378fAN/3ef755ymVShiGwT333MPAwMDNetmEECI0grbkgKEwTRMIytgNM8hgBS3bu1cQHIFpWZiWheevv7X86iYXAJ6v0T44bvBh6dpslYvfDKo87bczWFrry54ZKYToPAmwQsLzPGqOj6sslPa5I2uw4hjMVXzOFV12ZiPtDFaj0ejYOVBnz55lZm6eqakpDMPg9PQ8s4UGnq+5c98gtt1gZXpto4t2iV86SzKVRllx3pwu4mvN2PY97dv1Dw0zefI4Qz2DrBSKTC8scW6qjtYwPL6DhcUFAFzg7NQSp6YXGU6aeJ5Ho9HgyJlpar5JNBYjFo3gum47wMrn80yen+b0YpW+ZIRs9qwEWEIIsQGNRgNfA+pCgNU6SsTxb40Mluf7QRdBw8Rz15fB8n0f1/XwffBXBVjB336zy2LQCh5olwkGz0v79q7rynmOQnQpCbBCwvd9qs0mD8qt8/Xf/xgD+x/EPPQkcxUPCD5tU6aJp4N9T319fTd9nPV6nUIt6OJnmiblukdu2y5GxsaxIhGitk2t2ZwikUgArQ6CLv3DQbbqngcfxbEbKMMgGo1Rb9QpFotUKhVGd92BQlEqlxjdvpd6rYrrebjaYHpqGl8Hr1FmZCv5hXlmFuaZnJzEcRwWlisM7thLOpPl1JvfZSjqUq/XicfjFAoFKraHFU9SrFelC6EQQmxQrVbD0xqtaXe8NU0jOHhYa2zHwfO8dvDVbVa3aTcsC6+xvgCrlYkC1mSwgPYhwq0mGEC7u2ArsGvdvlMflAohrk4CrJDwPI+aG/wy1q7N8PAQi2ePM3joSc6t1NE61f6E0PWhVCp1LMAq1oMWfugxJAAAIABJREFU64ZhUHNcxvr6sZqLRCQaxYrGqdYvNKBoNbgYzwQlhIZhEI3HKZfKzM3N07Ab6GYnplqtRr1RRzcXplb3RNM0MQ0TWtUUGnzbYW5llpmZGWq1GtMlTSK3DcOqYbsO8wtLvPjii4yOjjI7O0u14TE8uo2zp49TLJZwXTdoLSyEEOKatTJYhrpwpIhhBMGUUiaO62HbdvtDtm7TOo/KtIImF4117sFqZaKCDoQXAqbW161gyvWCa66/NoNlWqa0aheiy8m7w5DwPI96M8BKJ2KQyTA/fxK/UcWOJSnZQaMLwwg25Haik6DWmkajQbnhUiwGe5kark8y3bPmdqmeDFW7jPYqOI5DsVjC8TWJZAqNplQqsbK8jOO6OLZDuVymUq2ABsM0SCVTxGJRYrEYxlt8AppKJSgvz9LXFyEaT9JjeiSTacqVMpVylalKhZmZGSKRCK+99hrnlhvct+sgiWSamuNRLBbp7++/0S+bEEKEhtY66Hjra7RSF85sVMEHYsow8Jut2rs1wLrQRTD48E7rZgt137/kDMq3un8snqBWDc6l9LQmFk+2s1Wu6wbXEsl2OWArgxVLpuWwYSG63KZ2EVRKbVFK9W7mY4prszrAspTmh37ohwBw8zMAzJRcTNNEmSauT0cOG7ZtG9t10X5wVlXVdokn05eUgaSanQTL5XLQ4MINmlnU6jXOnT3H/Pw8lWqVhYUF5ubmqFQrpJIphoaHGBsboy/bRyKZfMvgCiASjWFYURxP4xsWA4NDDAwOsGVsC/0Dg2CYzMzMcOzYMaampylW6yyt5LEdj3LNljJBIYRYpyAz46MMA7U6wILmWtD9hw239ke1KhhMK4K76kDga7q/r4lEYyhU+zyseDzRDpxazxGLxfGbQWlwDhbEYnEJsIToctcVYCmlflUp9UUV+A/AWWBeKfWDmzM8ca1s26bhB/VvlqEZHhomFovhrAQB1rl8HcM02puIO5HBqtfruF4QBNZsn6rtke65NB5P92So2i7lcpl8Pk+x2qDaaDAzM0OlWmFpcYn5uXkc2yHTm2FsdJRsf5ZYLLbuMSXSaeqepu5qEs1278pQpHsz9PYPkMvlMAyD5UKZcrVKuVzGB06ePc+pU6cuORBZCCHElTmOg+N67Q/AVp/ZGGSwFJ6vu7qTYPugYTMIsCwr0s48ref+lmU1gzMfrYMP/dzm3B3XQ6Ha12q1Gm7zdbMiUQmwhOhy15vB+hGCMsMo8PPAbPP6v73OxxXr1Gg0qPvBjzOCBgUDAwO4y9MATBXsYD+S1bmzsOr1Ok4zwKo6LjXbI53JXHK7dE8vVTs4EPn06dOcOTuNxqCQLzA3N0e9USfTm2F0dJRMJnPVTNVbSabSNFxNw9Mkkun29UgkiueDUop0Ok3vwBC9vf0UC0UK5TKFco2JiQmOHz/e1W8EhBCimziOg+N5qPbeq1UBlmmAUvjQtYcNB+3SXXSzTTuwZp/UtbiQAYtgWRa262NaQadfX+ugjb3fvGZZeH7zmg6COitiSYAlRJe73j1Y24CvAQcIgqwPAf8z8EPX+bhinRzHoeEFGaxifolXX1nCMAycpSDAWqwH7XDNSAS72pkMVqPRwPF80pkM1WoZZcCW9KUBlhWJYEaiTM8tkHjzTQqVGrpSwbJdkqkkfb291xVUrRZPpil6moarSaRXBVjRKBU/KMuwbRtPmYyMbSGdybK8tMSZQolz5xt8+9vf5oUXXiCXy61pGrJ161ZGRkY2ZYxCCBEWrRJBQ5mAgzIunOPULhFsZmy6UasDoGld6N4XZJTq685gmZaFZUVouHYz2IpQawdTBBmuSIRG8/Vo7fuyrMi6G2sIIW6u6w2w6sBO4P2AB7zR/Nu7zscV62TbNg0dLFRz01N8+m++QiQSwXcctOfimBY+BlYkGux/6lgGyyfT189io4GvL21wAVBv1KnVbebKLs7UEvmqy+COBAMDAxsqA3wryVQa21dE4nEikWj7uhWJ4GnaAVbDhVwqTSweY3RsjIXpYc4tzzLz4ptkMhmiJ6dJplJks1ksw2BlZUUCLCGEuIjrukGJoHH5EkHDMHE9r2vPwgqaWQRlgS2maeKvo6tfqwthvNnm3fHqWJEYlmXhehcyWK0MV7UVdPka04xgWhZ+s527EKI7XW+A9RzwPuC9wDe11jWl1B3AyesemVgX27bbGSztBiVru/fs5uiRo/i1EmY6S9VTQTmC39kSwUw8zqH7H0RrfUnHpUKxwOLiIv0jYxinBohmhzmwd4ih4dyaTzo3ixWJsPvOey8ZRyQS1L1Xq1XqjQaOD7FEMvimgoP3Hia/vMTKygqu6xLt6SHRk8aPxFjKL1CqVNtnaAkhwksp9b8DPwVo4DXgX2ituzM66ALtJhdmEKBc3OTCMExc3+naAMu2bVxfY0UuvH2yrMi6zsKybbuZjbKCNbnhY8aaZ2rpYH32fTCb2apW2aDbbKxhWZF2O3chRHe63j1YPwN8Bvgs8FNKqShwDPjE9Q5MrI9t29g6+HFqJzhDavfu3QB49RIANVcFG2o9n1qtht88f+NmaWWwotE4sXiCeCtgATSa+YV5FhYWqFVrLC4uEYun2LF7D8MjIzckuGqJxRNEomszY5FosAcrCFwhlkyteSNgRSIM5kbYs28/ubEtYFjYniaWTFKt1VkpVSgUCjdszEKIzlNKbQH+F+ABrfUhwCTYmyyuINiD5UMzc+VBe2+uaZiYponTXKO60YUzsFaVCFrr2xPVfgwzCJZsz28GThaeH+zzutAEw8L1Nb7v468qEZQ9WEJ0t+vNYL0T+B2t9QutC0qpXwWGr/NxxTrZto3tr81g7d2zFwDDCRaqsqPJGArDtHCa2Zn0qn1HN1o7wLqozM/3fWZmg8N+i8UixUKRSDRCtj/bsXNQTMvCR+FrTcP1SaRSl72dMhT9/f3EYjFWVlaYm5/HsCJMnp/hzJkz5HK5mzxyIcRNZgEJpZQDJIHpDo+nq9m2jev5mJbJGT3E178TfAC4fyDCB3dFMUwTt+6xvLzMxMQEO3fuvOQoj6upVqucPXsWrTX9/f3kcjkqlQrnzp1rd35VSrFt2zaSyeSa+5bLZc6fP3/FDrHlchl/VYt2oL1PanZ29pqCnnw+HzS5iATlfrarSVmRdmYKCLJkzWu+H4zF88BMBEGX52uKxSJHjhxZ12uzmmVZ7Ny5E8uyOHPmDLVajfPnz+O67pr5XcnCwgKu6zI6OrrhMQgRVtcbYH0K+DjwwqprHyX4RG9zuhCIa2LbNjVHgwHatUkkEmwd38qv//qv841pjxdmbMq2T9Y0MUwTz4dSqXTTAyzX12sCLNdzmZmeodFosLyyTLVSJZFM0J/tp1Qq3bSxXU4kGsX1g/PFeq/yOqVSKSKRCIsLi1RrdajUOXr0KNu3b5e9WEKElNZ6Sin1MYIjSmrA32qt//bi2ymlPgJ8BCCXy/HMM89s6PnK5fKG79stTpw4weTkJH66wnLkIDSLEyaWG5xS55mdn6e2PEt+eZFTZ6e468A+hoaG1v0cp6bmcHwYSJg8/PDDnDhxgtPT8zjNwo2oAbu2jrBnz5419z169CiTs4vt211Ow4Nk/wgNbVCv1Tm1OM/SuVOcOHH8msdYsqFmpqiWisycO81QzSFfqTExcYrZc4q6C5ncVpbLFU6eOMn02ea1kXGWi2VOTZxk+uwp4Dvrem1WS1qKg/t2k06nefGVVynZGsO1sT73uWtat5577jlc1+Whhx5adxB8o4Xh/5WWMM0FwjOf1jyeeOKJy35/QwGWUuodq74cX/W1ATwAXFPtmVJqHPhDIEdQv/6U1vp3mlmwnwYWmjf9Za31Fzcy1tuF4zjUXA3RIMDK9mcxDINYPEY6GtSyl22NmTIxjaDk4GZ2EtRat8/BsprNJGzHZmZ6moZts7S4RKPRINObIXOZ1u2dELRqrwUt3FOXNuO4WDQaJZfL4bkup8+eYm4uwtTU1DUfPimEuLUopbIE3XN3Anngs0qpH9Na/9Hq22mtnwKeAnjggQf0lRbkq3mrxfxWEY/HmZjNQ3qQl+cuvAVxtcHevftIJVP47i7cRpXtY/3cf//97XL39TxHxUxTqrns35Lh7W9/e/PaGVL9I2itqeXnuOvOXTz00ENr7mtZFlXrLD2DY0Rjl99DaxgGg7lRItEor73+GocPH2Zhdh+uc+2/62OJBIPDI3iex/LCHNmBIaxIhJ3btlGtlDFMg6HcWHBtfBu1agXTMhnKjWFaFju3badW3fgaXsgvE/fK3Hvv3fT19ZGv2pxeqFCcm+T+++9n3759b3l/rYMMmuP5PProox2rNrmSMPy/0hKmuUB45nO1eWw0g/UMQUCkgf+++We1iWt8HBf4qNb6JaVUD/CiUurvmt/7uNb6Yxsc323HcRzsZlirnQZ9AxdahqejQa172fYxe0yUYeD5+qZmiFot2q1IFMMwsG2bqekpHNtmYXERx3Ho7+8nmUpe/cFuEisaxW5UcX1FLH5ti4dpmWwZ38q5k0eYnplldjY4Gq71txAiVN4DnNZaLwAopZ4GHgX+6C3vdRtrNBr4Gixl4l60DbzhaZShyPT1Y9ci2K67oX1GrTboQHuvUnDNJze2Fc/zOLN8+XK+1n1zW8ZJpq6twsMwDHJj4+seJwSNPYZGxtpfZweHyA6uzdj1D1266+Jy19bDMAzKc+Wgq2PztQGuuTuh4zi4vm6/vt0WYAnRaRsNsM4SBFfbgRKw3LzuAeeAX72WB9FazwAzzX+XlFJHgC0bHNNtzbZtnFaTC9emP9vf/l46GtRglOyg7h3DwPE9yuXypo9jZWWFpaWlS64HAVZQHthoNJiemcZu2EENt+cyODBIPNFdHfci0SjVkk88lbqky+BbMQyDkdEtuEtneeWVVxgbG2NqaorXX3+dO++8E6VuXMMOIcRNdRZ4WCmVJCgRfDdrS+bFRVoBlg+4zZ0E6Yii7AQHvpuGiecFbdwd1954gOVpDNPA03pVEAFGu1Ph5ZtEXDgE+Hp3UHS3YB+Xvyr4pPl6XXuA5a8KsIQQa23oN4jWegeAUuoM8Emt9a9d70CUUjuA+wgKit8O/JxS6p8RLFYf1VqvXOY+UtdOkKp/9dVXcdkPgO82cF2XiYkJqtUqU8tViOxnoVDlrJ5jfn6BvFPiWdPF8zbvyDKtNc8//zxLFZvL7Q92fHCjPcyulHAch0K+gO/79Pb1XrYlr92wmZi41mTo5issLbA0O0VmYBjWOY6l5WVqyyXOnJ/mWy+/SdQyWVn5L7ztbW8jl8vdskHWrf7/ysXCNJ+wzOVqde2bodn9r6y1vq5Wn1rr7yilPge8RFCR8TLNUkBxeY1GA09rTGWiUVgGJKMGZSfY72qYBr7vE4lEsOuVjQdYWhOPJy/JYEUiUXzfu2JgcOEQ4MhlHjk8VnciDLoa+sTjiXVnsNx1nP8lxO3kuj6iaQVa10splQb+DPjftNZFpdT/C/waQZbs14D/CPyPl3l+qWsnaPk6PT2NfjHY26Qdm/Ft4+zZs4dvPvtNvvLXX2Dow/tpaJO9e/YSs0x0eZHdu3dv6rxLpRJLKwW8xTrDq0oe2uP0PGxfYxgW8wvzpNNphoeGiUQvv5BNTExcsgH5ZvJ37mR5YTvZwWHMdX6auWP7dpbmZ/A9j0KhyGsvv0C6p4edO3cyMjLC9u3bb9Cob6xb/f+Vi4VpPmGZy42YR3Nf74PAB4HfJGjG5Cql/qnW+nPX89ha618BfuW6B3mbsG07eBPfLA+Mm4q4GXzgVHc1PYaJ4zjEIlEc19vQm3fXdfG0JhpP4PnVoMLDcfB1kLlRfpDZuvixfd/HdT1AdV3Ths1mRay1wacOjizR6wiwPF/jeRJgCXE56w6wlFIe8Nta6482/305Wmt9TY+tlIoQBFef0Vo/3bzz3Krv/x7wV+sd5+3E87ygkYIVNGLYtnWk3XUp05tBuw20a4MVxVMmlhWh7G5+iWA+n6dqe2T6smzfc8ea79mOzdTUFEbDZn5hHt/33zK46gaGaTJ4mUDxWliRCLkt2wAYBU6dOM5SvsTZs2exLAvDMBgf31jNvhBi3X6EoJwvCvw8MAsMAv8WuK4AS6xPrVbD0+DpIICJWYqYdSHA6jNN6o06pmVR28AeLM/zcFwPpYygUZFdCZ7T8zFME6WC4EmhcF0Pz/PawVQQaPgYZrjLAwHMVRmsoKTSJ9azvgyWrzW+f223F+J2s5GDhhXtxqrtf1/855oeVwV1Up8Ejmitf2vV9dWHKvwA8PoGxnnb8H0f2/XAMFFoPvDkk+3MT29vLwBerXnYsK+wIlEcx9v0LoKFQoGq45Hu6V1z3XVdZqang4YWCwu3RHC12bKDg5ixJOfOnWNpaYn5+Xmmp+W4HCFukm3ASeAAQZD1IeCPgfW1pxPXxfd9HNcFFE7z3Ma4pYg3A6xGc9+U9nWwB8vx1/3mvVUKaFmRdpYmCOqCc6VaTCuC6699/NZeJCvk5YHQPBxZry6f1MTiCXyuLWBqHZbs6vX/jIS4HWzkY5qdQHHVv6/H24EfB15TSr3SvPbLwI8qpe4lKBE8A/zMdT5PqHmeR7V5aEdEaVZv72kFWH69DD0DVB0wIxauH5RqNBoNYhcd/LtR+Xyemu0y2HOhpbnne0w3W7EvLC7iei5DQ0O3VXAFEEskiVvB6zw/P9/+xNSyLIaH5VxuIW6wOsF69X6CZkxvNP/evE2o4qocxwmyS4aBrS8NsOquvlCap8DZQAarVe5mWRaWFRwAXK1Wm/uqLrzlsSwLX7PmGI1WoGFFwp/Bsi7OYGlNLJEIgqZrOFqk9Vpda8ZLiNvNun+LaK0nL/fvjdBa/yMXsmGryZlX6+B5XnDIMBC5KHeYTqcxDAO/mcEq1F1ykQjKMHA1FIvFdR/ieDla6yCDZV/IYGntMzMTHCK82GzFPjgwuGkB3a0kFk/QsEskEgnS6TSzs7OYpsm5c+eIRCJks9lOD1GIMHsOeB/wXuCbWuuaUuoOgqyWuEkcx+H/Z+/NoyRL6zrvz3PX2CMyI7eqylq6qrq6urp6oW2QAekGabSBkeUdBY7KOyKyKDoiqON75qjvnJk5qMz7Kr7IjgvqqKA0MjCKCt2sY0ND0xvd0LVXbpEZ+3b3+7x/3IjIzMqoqty6qqm8n3PiVMbNiHufG1F5n/t9fr/f9+cHIYqi4vYiWKYqMHs1WI4fuQhGCLxg4zVY/QiWqumomkYolwWWphmD10UCIxgSwbr2DS4gqkWTPYHpui5+KDHNxCCCJaW8pBnTwKY9iCNYMTHD2EyK4AAhxH4hxMeEEI8KIU6teMST1hUkDENsf7jAUhSFbC5LaEcCq9Ky0FQNoagEIdvWC6vVatF1PHQziabrSCQLpRK2bVOtVnEdl+Lo6DPOiv1KYZgJ/FDQtSwmJydJJBLMzs7S7XY5ffr0Fe1JFhOzA3kL8JfAJ4CfE0IYwHeB917VUe0w+hEsRSgDgbUmgqUtm0sEPdOJsNejab3HCMJIQPSjNN1uF/8C63VV19c4Cfbriq51i/Y+qqrh9z6fMIxqhxVFxQ/Cy0ax+p9VbNMeEzOcrV5F/gp47pDtQ0y6Y54ugiCg40aZLt1WgwdPPsh11x0gDAJ0wySXy1G2I0OLWsdFHUuAIvDDqBP7ZnFdd/D+crlM1/XJZHMAVCoVOp0O9Vody7IoFAokU5dvIvydJZeFdsCLDqwWYkEo+ceTFnV7OaNnLKXyIweTLHYC7j9r44er/9sZquAlB5NkDIV/ONGl6ayepAWCO3YbHCkaPLTg0PUkz9/79AhAoSiYqTROYLO0tMTY2BilUonz588zOTnJyZMnOXr0KInEzhSgMTFPM3cB75FSDnpU9ZwF4/zcK0gUwQoQqoLbuxwr0ifREzROsJwiGAQhIAh6NT7rzXxYrsGKBFYUZQkIAolqrE4RDPy1AssPJdrTnMLuBz6O4+A4Dr7X69EVREIylNEHowgFRVFQVRVdj+rJTNPENE20bTLhUHU96mUVBIO6NVVddhfU9Yt/DgMXwdimPSZmKFv9K70FeBT4T0QNh2OuAr7v07JcAFr1Kg8//DDPedZxrE6LI7f8AIV8nsVqHYCa3Z94DFxva06CX/nKVyhV6gM13bJ9spM5Gs0G9XqddqtNu90mk82QyWYuuz8pJf9y2qLrSa4vrr6wn2/6PLroXrAt4JYJg28tuJyuD19tmyy5TGVUHl8aPgFYfsjBEZ1/PmURSrh10iBjbCmwe1FS6QztRodHnzxB0lC44/bbefjhh3nooW9z1113omkaR48e3TGrpzExV5A/BX6f1U2A3wn8B+Da9uN+BrGcIqhh99La7/vnz3FkehxGb4v6YCkKiEiECEXF8zcjsKIUQFXTCHsLb/0ITR9V1fDdtQLrwlqt7UASRYn6j5XHDPwAP/AJeyJnMKEKUBUFRVXRVG1VZE/XddKpNKl0imQyiRhaaXF5NC2KYBlSDqJ+iqYSrkM0DfpgrbNmKyZmp7HVq8jngJyUMrZRv4p4nkfLji5wMnAxDINuq0FCE3RbTXL5PP6p7wBQ93UUVcEwTSyvTbVa3dQxbdum3mxyqtwlkysAoCVTpPMFyuUytmVTr9dJJpMUCoV17bPlSrq9SXeh7bOyKmm+HUWujhZ1bt9l8sCszcmaz0I7YKEdnfs9h5KMJqNJaKbp86VzNgud5YjX8QmdWyaiSTqUkr95vEO5GzLXCugHv9pu+LQJrOLELuYdm1K3w4QMsCyLRCKB5YWcOHFiEMm6/vrro5uMmJiYLSGEuHPF070rnivAHcD6c89itozv+3h+CEJQb3VBSSBdG4Jo8ayf6q6qamSfrmm43saMLnzfJ5SRSNJ6aYAAvgzRV0R++vVZK/fdd8ZLbFMNlu3YNJtN2u02YRgiQ4nt2DiOg+u6uK67/nwfAYZhYBgGCTOB67jUG3VUVSWTyZDL5jZc3xylUDq9+jStZ2GvrSvtz/M8wjC2aY+JuRhbFVi/AjwshJgFTrDsyCSllC/e4r5j1onjOLSdAMyoybCuKRhKlNdudTvkc3mCTo3QtfCMJHaoYiZTWJUGlUplU8eMHANDsvkRjt12BxD1upqZmcF1XMqVMrqhMzo6uu59zreXV8EW2gEjKzTGQk9gHRzR2JfXKHU0TtZ8zjd9yt0QgUQpn2Cm2aDZbGJjQPZ2zlUtajUHyDClO+zNphBKtNo3llJY6oY8UnIGx2m7T192ayKV4robbmJh5ix2bY52u43ruiRyI7Tbbebm5lAUhXPnznHgwIGnbRwxMTuI+4luYSXw73qPlZy40gPayURmCpHJheWFvTnLRg2ia7+zQmCFQYiqqjg9l7uNHCMIJYamD6zIAUK52n5d03TsC4RE/71bcRGUSNqtNvVGHcdxkKGka3WxLAvbtqP/iT2xlEln0A0dVVFRVRVV7U16QoCMDCSi9L0Az/VwPZd2u0271QYBiUSCVDKF7/k0Gg2SiST5Qp5M+vIZI9AXmfaqqJ2qavgbimDFJhcxMcPYqsD6EJDvPVb2roprsK4gnudFNu0mSN9BVxRMDRKqoNluMT4+zvT0NNJt4hlJlmxIJlLUvIBGo4Hv+xtOS4uaCvuk85EDYRiGLMwv4Hse5UoZRVEYHxsbiJn1UGovR5sW2gE35lj1HGBXJhrnVO/fJ8suEoFXL/Gnf/vRVfsb+7Gj+GaKaiAQKvz1h/8/jv7GOwfpilMZjaWuyxPl5cmh7T79C9rJdIbykozq1mwHqRqk0xqtVoulpSUgmjinpqae9rHExFzjnCOaj/YTpbH3Q/YBcB74v6/OsHYmvu9HNViaQr8kNvRsioUMM4Ad9ASWouJ5Hqqm4W0iguUHUUSmH40B8INwtU27ruEHwyNY6iZqnCSSVqtFrVqN7OVdj3a7TafbAQmqFkWakolkFGlax9SoqCo6PVGY7h0nlDiOg23bWLZF1aoiFEE6lcbP+li2haEbjBZHLyu0NE0ncKI6qoHA0lSCYH0CK1gRwbqc62BMzE5jqwLrTmAW+AhQ3/pwYjaD67pYfjRbSd9FVcDUFExNYLXa3PoDz+XW227l/jMW/zrrUOqEHNY1FE3H8kIWFxfZvXv3ho7Zt2SfyuWRSEqlEq7rUq5UCIKAyYlJFHVjpQ3zKwRWxQrxMtHF2vJCGk6IKiTFVLTCN5lWEUDYm6X82vya/Xm1ecypQwhVI3Q6GKFNJrM84UxlVB5dhGDFckDrSgisVAbbj3LyHT+a3PqplOVyeZDmkUwmB33MYmJiNo6U8gCAEOIM8FEp5X+5qgPa4ThOlI4WtQmJruXStZkYLUB3dQTLdmxUVcPxNmbVHvV0ClF1fWBFHqWyrW00HMghjYalXFWrtR46nQ7lStSKpG/+ZFs2CEilUqTT6W1rTyIUQSKZIJFMUKCAYzu0O+3o0W6TTCbJ5XK4notpmoyPjZFIJIfuS9M0AkuusrBXVY0wZF0ugoGUKIoYpBQahnHJ98TE7CS2KrDuB1pSyv+8DWOJ2SSu62IHkdCQvosqouiVpgiE9HEdG8NMMJWJBM9CO+DYpIGmmzh+yMLCwoYFVr1ex/IC0pkstWqNTrdDvV7HdVxGR0c33EhYSjmIUqV1QceT1H0VJDzw+GmgiLV0nvKSx8TEBIYqKKYUyt1IEJlekz1Hj5LL58jlcmiaxoxmstjbv27X2X/gwKpVw12ZtQLw3EIFOb1nQ5G3jWKYJqLnbuUEEj+MbjympqZwHIe5uTkMw+D06dOxs2BMzDbQF1oxVxfHcQglCKEQCA1BlCI4URxFdMELI8dYRVWQoURRVDzf2bjAChlkZfSFVCSc1tdoeL0RLNdzKZfLJJNJPNej0WxgWzaKopDL58ik0xteaNwoZsLETJiEQUCrFQktq2SRTCUp5AvMOLNkMhnGxsbWuA9xuOiYAAAgAElEQVSqetSIOVhhTa+oGr68dNpf2LPPFwh0MxELrJiYIWxVYC0BPyWE+BzwJKtrsN65xX3HrBPXdXHDaDUw9BwUIUnoCvl8nkSrjNVprxZYnQBd09FNE8vrsri4eKndr8GyLNpdCymi9ItqrUqn06HdbpPNZkmlL2/HfiENJ8TyJUlNcP2ozrdLLidLLb762f9OPXeQzPEfxq/N8a1vznHPS+8BoghUX2C94cdfzq7s6v/O36243PtkF4AfvOkgd77splW/H0+pIEMQy8VeJ87N8d+/+Ffcfffd3HrrrU+b2UQylcb2W9i+JJQSPwgIgoDp6WnOnDnDzMwMBw4cGNi3q0/zJB0Tc60hhAiAP5BSvrP38zCklDK27bxC2LZNIEETIFU9ykLwbP7l8/+MPPhS0BK0bQ+td70TisBzNxHB6lmOQ5QGF4bgX9BAuN8jy3Xd1e8NVke6hiGR1Go1arVaZOhUq9PutBFCkMvnyGayT+si3TAUVSVfyJPNZWk1W7TaLSzLIpfNRXVg3S5jY2Pkssu595qmYUnZs7CPzllVox6Zl/rMB1HCFXVucR1WTMxqtjqxvL7370uAu3s/C6Kc91hgXSE8z8Ojn25hYWqCdDpNLpfD1Cp02k2yhVHypkJSE3Q9iS0MzGSaTrU5VGAFwcXuR6BarWJ5IWYyOUgNrNVqmAlzXSltlhfyzXkXd0VuXqOXkL8ro5LFBhROd3Xc4jESU4ejMTVLhBPjg/dMpTUew0MRMJ5eK0D6dVrRz2t/r6uCnBbQDBT8xiJafgIlkaVUbfG3X32SL9x3P//u/3g1Bw4coG4HPFxyCULYnVU5Ora1lbpkOotdbeIE0SqtH0ZCOZlMsmvXLs6ePTswuzh79iwHDx7c0vFiYnYgguWY9cXuduOikSuI4ziEIXQ7NkIvApDUFeZm55C7OmjZBKVynX3jPREglA27CPYjWP3IkaZr+GEY2bRrq10Eg0CujWBJiXoJkwvXdSktlnAch26nS6VaIZlKkklnyOWyT3vE6nIoihIZXWQy1Bt1ms0mnW6H0ZFRFhcXabfbTExMoKnLjZgjC/t+BEsluIxxxaCZ82AfG4syxsTsBLYqsD5GbGhx1XFdF7/3VYauRSKhkM1myWQymJrCfGmeb3/j60g9CembIDFG3VVJmQlqnk+lWl1ldPHggw8yMzt3yWO2bRfLUUn4HuVyGVVVKY6Orut25cF5h6+ed4b+zlo8w2e+8g/kf/hN6IUp9MKy0cObX/tK9k8uW75P56KJbFdGRRuyWpgzBDlT0HblwBzjQg5PpPnWvMvzjkzy9ZJETWZJH/9hkgduo/LNz/CH7/lDnv3sZ2Pc8lKeakTvEcD+vEZS33x0K5lO0yhJUDSSiSR+aNHpdHj44YdxXJdOp0OtVuPEiRPcfffdpNNpJicnN328mJgdyHVAc8XPMVcZx3EIkdRaHYQQhJ7D6OgI6XSaRc8GoFStcd1U1KRDIPD8YEN9lvoRLF3v1RRpOkFo46+IakEvgiWH9MGSF49gNRoNypUyge9Tq9WxLAtVVZmcmNxwWvzTjaqpFItFnLRDtVZlaWmJTCaDDCXnnfNMjE+g9vpg+TLE6J2zqmmRa+FlBZZE79W5BaEd98KKibmALQksKeXPbNM4YraA67oEIvoqpedgZlUSiQSFQoHxfJqsafOPn/wqs02f/HOzJA+O0Q0gq2momoG9wujC933m5uZ5bLaBuER6XLPZYmrfQcqVCmEYbsjUYr4VRcdumTAoJqNjdLpdHnrw6zzy0P1I36X+tb9By46yb99+jh49yq58kv0XNB+eymi85lia0eTwcQoh+IkbM1i+JGsOf82d+xJMZzWOFHW+XmqgJDLk996AC+jFaezT3+Ib3/gGY2PPRUmPkNAEti8pdQIOFDYvsDK5PFoyQyFfwLEtAqdLqVSi1nFY6AQIkaQlPfzSEqVSCUVRSKVSZLPZTR8zJmYnIaU8O+znmKtHZHIB1VYXMlH9VbFYJJvJUvKiRbdyrTVoqisFG4pgSSl7fbAYuOJpvUiVlKyaoyJhsCywgiDAD0KEUNakhodhSGmxRKfTwbZsqtUqoQzJF/JYtvWME1crMRMmU5NTNJoN2q02lm0xVhxjfmEeTQiCMCQI1VU27UF46c+8L7AUTRs4EcYRrJiY1WxYYAkhXrGe10kpP73x4cRsBs/zMDN5LODIwf0U5CKqqqJpGnfccQcLCwvksxlmG1VCuw1EduTTSR3VMLD9kFKpxO7du2k2m3Rdn1Qmyy13/Juhx6vWqlSrVeq1jZtaSCkHboHP22tSSKiEQcC73vX+VT25JtQOP3jzcZ7//Odccn8HRy593GGpgytJaArHxqOVzr65hqtGjkvZXdfRAoSeQEmPoClw45jOQwsu8+2AA4XNT6qqqnHo2C0AzJ07hW9J6vU6ti8Z37WXqel9nHriMdylM5w/f57R0VFOnz7NjTfeiL5Bh6uYmJ2OEGI/8F+AZzEwvAaiGqxDV2dUOw/XdQmRNLp2JLBcm7HiGLlcjnA+imDVWh0URYlqmGRkemFZ1rr27/s+vh+gqOrAMlxVNVw3RFW1VTbi0TEU/F6ELLJoD9dEr1zXZX5hHs/1qDfqtFttdENnfHQcXdcplUrb9Ok8fQhFUCgUSCaTVKtVSoslCvkCmqpQKi2xZ2p8cN6qqhJ4lxZMfYGlaVpk627FAism5kI2E8H6FOtLC4yr8q8AspfioCYiY4nn/MCt2Ce/scoUwTAMRvJZOF8hsFtA1FDXyEVOgrbXHUwSUX+rgHRmeIPgTqdDtbpsapHJZjZkatF05cDMIt+LKimqyqte/So++pGPoigKL33ZS3nRi17EqVOnNvWZbJaModDxlmvPAjPPG9/8Zr7wje/QASbSKruzGg8tuAPHw+1A102sQBKGIU4gyfd6l+iGQaIwQhAEzMzMcN1113Hq1CmOHDkS9xuJidkYfwU8d8j2OMX9ChEEAa7nAwoHbzjGTA3y6QS3HrqVdruNPDsLQKMTCS1N0/C9SJB1u911HcP3/TUpfpqmYXuRbfuFrEwTjN7Lqrmz0+lQKpXwfY9ypYLruGQyGQqFwvdl9Z5pmkxOTlKr1qjX62iaiuU4zM+XGN13BABF0wid9ZhcRJ+zpkVOhLHAiolZzWYEVr9xY5+9RO6BFaDY22ecjnGFCMOo07svNRCgygAhWCuwCnmkDAmtvsAKMUwDM5GiXakxNxfVXDUaDSzXpzCRW3Ms13VXm1qYJoV8Yc3rLsVCO8rTnsqoq0TCTTfdxMte9jKOHDnCvv37Nvw5bAcZQ1DqLD+XQH7PYZ6dPcD9Z22mMurALGO+5fPAAw/wg8/5wS1PtLph0O79RTm+JJmOFtg1wyDsKoyOjkarqPPzKIrC3Nwce/bs2dpBY2J2FrcAjwL/iajhcMwVxvM8/CBA03SEGmUN5DIJpvdOUilXCL1oQa3jRDfqmqrhOZGx0HoF1sBmfaWZha7jhSGatrYPlbYiTXAQwerVbtXqNSqVStTfsVwmDEOKxVGSqY275D6TUBSF4lix1xS5RrVWRx3JsVSukMmPRL3H1mVyEX3OqqYRxi6CMTFr2LDAWtlPRAjxq8BPAT8spawJIUaBLwCf2LYRxlySoGfv7fcChkroI1jtlmSaJmMjBZAhYS+C1XIlCTOBmUhQtn1q9TqNRmMQwZrOrnYD9AOf+fm5aCWvb2pRXJ+pxUr6kZ/IKXB1l/m7X3L3kHdcObLGct69rkQ9WRbawSClcVdGo5hU0JUoEvfxT3+aJ594kte97nWYic03kdR0Az8EL5AomoFumL3tOlYoe591kaWlJdI98ZXJZOImxDEx6+dzQE5K+ZmrPZCdiud5uF7AN90pluzoGmeIaGVpZKSA8KMaLGX/HfzFI03umVaRyEEEa3Z2lvHxcQzDGJgAXUi73V7VNBeiudD1QhKJtRGsqEeWx9zcXDSXhqBoKt/43nk+83iZu3YLFLt+USOLs3WP+6p5RroBxdTapB3bl3zyiQ43TxrcPGH0toX87Xc6tFxJUhe8+oY0ugp/90SHtitJ6YJXH02jCrj3ux3u2GVu2bX2QqSU3D+vkFBGMUIoV+rs8jxKpRJW10L0+oOdP39+aLZErVYjCCWJXgRrZS1bp9MhCAJyuRye57G4uIiU0fcshGBiYiJOc4/ZEWzVRfDXgc9JKWsAUsqqEOIx4FeA/7bVwcVcniAI8P2AYCCwPARyVQRL13XGiqMQhgTdyFSr7YYIRZBKp0Eo2L7k1KlTNJot3FCSTC+LHymjZsSu67HUW8nbiKnFSs6Uu4DKQ1/+J+7c/woymcxl33OlyKwQWDeNG3y75DLf9geicCqjoghBGps6CfSR3Tz88MMsLi3ypp97E4WRjUXz+uiGQSCjpsPJFZ+Hrpu0ek2Ix8bG6Ha7LCwskEgkOHPmDDfeeGPc2DEmZn38CvCwEGIWOMHqno0vvnrD2jl4nkfDk8z4y0Y9o3qU0aCoKqbfREqJYiSYaYWUXZWMUJBSsNiwuP+rD3Dj4QPcfvvtfO1rX2O+0kQOyfC0vBDNXC6z0w0TNwzJDLmp13WdhmXxwLcfA6Bt+zRsl287OrOtgMcXHO6YMCkWR4fOd98pe1Q8nRM1b6jAmmn6nGv6hMiBwDrX8JnpGT01HDhV90hqgtkV207XPXRFMNMMMFR32wVW15M8vuShCnjp2BjVSplavY5uJGg0G+ihQ7md5AtffeDi+3ADsvpagfW1r30Nz/O45557+O53v8ujT34P14/asOiqwk1HDnHrrbdu6/nExDwT2WoXVQd4nRDiQ0KIXxVCfBh4LbC+eH7MlgnDkGqzhRQCQp8vffE+BKxpTDsxMYEMfUK7jZQhXU8ShJJ0Ko2RSNLs2jzxxBNYnk8qnR24KEkZMr+wMHBO8lyPseLYUFOLUEpO1TyeLLtDH196Ypa5ZtTUsXbue/zFn//FM6oCImP0iqIFHO9NhmfrPg0nRFcYOB4emohuEMx9xzH33EhVFHjPh/6UmZkZ3EAO0iDXi6breGG02plMrbwxMPAlg0aYu3fvRlVVZmdncV2X06dPD1YGY2JiLsmHgDywC3gB8MIVj5grgOd5OF50vUoqIW88rnMoZQ9+X5Btyv/z/8FZOAmAL6M5bGr6AC2SlJo23W6XMAyxLItz1S6WXljzEOkxpvcv9w0sjI6xe+917Nm/tpfg9IFDiPQYll6go+ao2pAdKdLqRtfcUNUZHx+/6GKi7Ufn4/jDr8PDfm9f8FrHl2veb6/YdrF9bwWn14MykLDruus5evNtpNNZqtUq3W6Xwtgksy2frpYb+hlbeoHs+G5GxydXuTH2vxvbdXFdl263y1LToREmacgUpaaz7nTPmJjvd7YawXoX8F7gjb3n/Vjy725xvzHrJAgCqo2ocCh0Hc6ePcuzD06uEVjpdJpUwsQJA0K7g5rM0vEkuUSCRDpNo9qgVCqhpkdIj++P9heGLJQW6Ha7VGtVLMuiUCiQSCaGjuWRkss/nryU21MaYUBotzFw+dF7fvQZVSic65luTKbVXrQK2r0bgsle9Apgd1bnmwseyf23ktwfrcSFrsV73/debnv1L3DGTfPam9Jct06XQVXVEIpC15Pk08uru7ph4IcS13VpNBqcPHkSy7IolUo89dRT3HbbbWSzWbrdLpZlcfz48dj8IiZmOHcCs8BHgPpVHsuOxPM8nDC6nrYaVX7/dz7KyOgov/ZrvwbAyMgI8sTJQRq7L6PrcTpfwNTGsKrzeJ4X1UuFElXTOXzjzZc9rqqq7Dt4/dDfpbM5Dh29iSAMmJubY9xMU6lU6LgS0BBa4pJzVF/82MFwEdQXMitFkhOsFVMXXrYdXxKqy7/fblbu08yOkCkWQUKlWqF9vo0UGuO795JKpdg1NYUQF1+L13R9VR2bH0qCMEox7H9XBw4cRFFUTjz6jbhWK2bHsNU+WO8TQjwO/DSwh2gC+x9Syvu2Y3AxlycIAmqdSNSEvoOh62tMLiAyushmUjjdyOhCTWZpuyE5U2FsfJInZs5yYqmDWve5fd+NdDodypUynutRrVXpdrrk8jky2Yun9J1vRpGb3Rl1Vd+pdqvN6dOnCPt52Esnedvb3vaMM2o4UNB43rTJoVEdTRHccyjJyZqPIuD2Xcs1VkeKOre3DDqepN1uc74VoBgpwsQIJyo2WjbN2bq/boEFkMnm6XbapDPLAkvTo9RB13WZm5vjzGKDjhfSdXWceg3TfIKJiQnOnDmDoukcOHAg7pMVEzOc+4GWlPI/X+2B7FQ8z8PtBfdl4GPbzqqb7R/6oR/iWc96Fk/543ynCa4EBPiej6Fr+EE4sFMPw4s3A94oQRgwNzuHbdtUqhVsyyZUonnuQjF0IfYQAbXq90MEWH9bUhNYfpQarvQEVkoXdD2JHUjCFcZH280qwedLMgYgoFgskkqlaLfbhDIECXNz8+zatWtNb7A+mqYR9PqPRVEsORBcfbdBVdNRFIUgvLQ7YUzMtcRWI1hIKb8IfLH/XAhxqxDi3VLKX9vqvmMuTxiGka1tGqTvYhoGykUEVj6TYanTGKwQtt0oL3p8YhLv+LNwXZddu3Zhez7zC/MEfkClGlnT5vI5crm1zoIr6ZtB/MihJFOZ6L/W6VOn+cDffgDPjS6q+UKen//5n2diYmJbP4ftQBGCO/cnB89vmTS5ZXKteYWuCn7kUN9JKs0nHqlwsgXGxHVo2SIAT8yUeeGBves+9r7DR0HKVakoiqKgKBpeGFKr1eh4IbsOHsUwEnzzf3+Jubl5FhcXOTMzx9jkLur1eiywYmKGswT8lBDic8CTrK7BeufVG9bOwff9ZcESRh9/wlzOhti3L3KPrZyzoWlj+xLVUPF9P3K2692wu66LH0o0fcu3L6vEVblcxnEcRkZH8MsBEF42ejQQUJcRWG4QpdArQgy25RMKVjuIIli91+dNha4XRBGsnp65WHRsK9iXSFnMZDLk8jmajSYylBSLRebm59i9a/dQkaX2arBc1x1ErFYKrDCMRJiiqASXcSeMibmW2GoNFgBCiD1CiF8XQjwCfAt4x3bsN+by+L5Py4ouWNJ3MQwdIQTNZnNgLQuRk+Chg/t51m23Mj0R9bhqu72IkiKYmJpCN00qtRqVcoVyucz8wjyu61Isjl5WXDm+pGqFqALGesW+58+f58Mf/tBAXBUKBX7xbb/4jBRXW+G6sWi1M3P4jsG2mqfxla9+dd37UBRlaJ6/bhgEAbiehx8KsvkRkuk0E5OTeAgee+wxOrbH7MISjUZj6ycTE3Nt8nqi+e4lwC8Cvwy8vfeIuQK4rktvTQ8ZRKGsYe6rphbJDTuIGtn6gY+iqvh+iOf5OI7TswjfWgRrmLgaHR0lnU5fVjj1uVyd1IWRopX/FnpZHrYvl0XXkG1+CH64vSJrVURtiIDL5XIUCgUsy6JSiaJ6s3Ozg/uJlaiqipTg+wG2bRNcILD8XvNmTdcJZRTBimuHY3YCm14CEkJkgB8nmrjuIspU7i/E3L/lkcWsC8dx6PRmLek5JAyDIAgGfa1c12X37t3ous4P3HYbdmKEc/pels7bgwgWRG5Kk5OTtFttHCeyy81lc6TTaVTt8m6BpU60IjmeVtEUwcL8Ah/84Aex7WhfmWyGt/78WymOFbf1/J8J9HtjkVy2TVeMJNOHjm1535GFu0uIwEylByuI6Wwe1x1hcXERW0uTSElOnz7N8ePHt3zMmJhrkI/xjLLU2Xn4vo+zIkUQIJFYW8+b6Aksx5fomk6n22tOKCCQkYlCKOWaLI2NEIYhc3NrxVUqnRocGy6dIiilHJoCuJILUwOT+vK2fEIZHKufIlhYsS1ccXqOL9GM7auvHSb8LiSTzYCAeq1OuVJmrDh20UhWZHe//N30a4d930fKyCVSCIGiqgS9VM/Yqj3mWmdTAksI8dfAjwEJlkXVI0TNHD8tpXzV9gwv5nLYto3Vu0BK38E0DXw/mrxGRkao1WqMjo5imiaqIvA9j0w6+spa7uoLq67rjIyObGoc8/0GwuloVviHf/hfdDuRW1AqnXrGpgVuB5NpFcGKuzcZglCw1PQl3rU+dMPEt9qEfkhqhYV7Mp3GrRuk02lKFQtPGJw6dYpOpzPolRUTExMhpfyZqz2GnU6U2td7EkbzRXKIwOr3xrJ9iaqpyFASBgESCHtNh/1Qopmbu0GXMmRufg7HdihX1oqrUMpBpO1SESwvXL7mX+x1w8wtnCHRqr7JxcptKzWb7UvS2+jUfqkUwZVkMhmEENSqtYHImp+fZ/fuXauMLzRNX/XdhFIOflZVbWC+pGn6oF4rFlgx1zqbTRF8DZG4egz4VeCQlPK23u/WxpBjnjYigRX9LD0H09SRUmIYBuPj46iqSqlUwjAMNAU81x30e1oZwdoqC4NmvJHA+smf+iluPHYjpmnylre8hV27dm3bsZ5p6KpgLLX8p3R9MUp7WegEF3vL+vdtGARhZNm7sjdZMp3FCST5QgGpaHQth67t8vjjjw9N44iJ2WkIIV6xnsfVHudOwbZt/N567HKK4GqB9e53v5s/+fAHAOg6PoYeqQrXjcwT/DC6cY+aCW98fTgSV/PYlk2lUsGxo5qrvriC1YLD8eVF09kufN3lXnNh2qHitqPzdAPadpRGn1KiOcMO5Or3bnMd1noFFkQOxIWRwuAzsyyLufl5pFyeZzRdW/XdBL2fw1CirhBSKy3dY2KudbZaJXoUuAewhBB/vw3jidkgjuPghNGkFfoOSdMkCAISiQSqqjI+Ps7CwgJhGKIq4HkO+V6qwXYILCklLVcODC766XKmafLGn/1ZSouL17S46jOV0VjqumgKHJ/QearqMdv0adjRZ3x+rsT83DwvuPMFG9qvpuk4Ya8J8QqBZSaS+KHA8aE4PknHslgo11haWmJ2dpa9e9dvsBETc43yKdaXFrj5XLOYdeM4Dl64WmCtNLnoE7iRK27XCwaN1F3PJQhD/CAY3MSbG4yASCQLpVJUV1SNhEJhpLAm4r9SLEkigwpzyJ3SSmHihUR1YYq46Gu+8KWvUv3eg7i3vQYlmeMvP/oBij/6NiwvoNOxUJNZPvLe36d4z9uw3JBQX160224nwZWpj5dzSoQokoWEer1OpVqhKIoslEpMTU0hED2jC3uNwPIvEMKqqhGEXiywYnYEm41g/RxRnZUK3E3UC+s80fVolxCisC2ji7ksjuPg9u4PpOdgGgZSykFue99VzvM8dFXlsUce4e//5i8BaNgba4g7jH84YfG+B5vU7dUGFxDlXW+nuLK7XRbnzg9dUaxXlmjUKgBY3Q6LczNDX1ddKtGs17ZtTH36wnIirbInG00oM62A93+zyfu/2eRfxVH+5xe+xpe/9OUN7Vc3DLww6gmTSC6vsiqKEvUvcwKy+QLjk1O0bJfZ2VkWFxdpNpvbd3IxMd+fnLvgIQEfKPX+BTh7dYa283AcZxDBIohusC+swRopjCDdqPmw40uEItB1Hdd1UTUNy3awLGtTEaylpSU6nQ71Wh2ra0VtRzJr245cGNG5aI+rIc2BAcIgGGQRrBQvp8/NMTc7B1qU4RBabWTgI1QNxYxEXmA1kWFIgMDyVkeZPv/5z/PkE08SBlvPjNhIBKtPJhu5C1pdi3qtTqfTYWlxCYhcAkMpB99NEMoV39OyENY0DV/GEayYncGmBJaU8o+llC8G9gO/QZQq2De5eA4ws20jjLkkruviyb7ActE1Nbr57k1ckT2qguu6GIZBaX6OJx95iNCzcUOFlrP5KJaUkqeq0YXSlC7TorJmBW87mTt3iqXZczSq5VXbPc9l9tT3OH/iu1Hx8pmTLM2epVmvrnqd6zjMnznBuZNPbruL0dGizr68xnN2m2QMhVsmDHKmIGcKROAiFBVj6jD33nsv//qv/7ru/ZrJFJYfkspk1zQRTmfztL2QTC7P2PgEQjc5f/48tm1z5syZQS1eTMxOREp5QEp5nZTyOuCPgEeBKSnlbmBX7/lHr+YYdxKu6xLIXgSrV4N1YdP6kZEC0osEltuLdhmGgeu4qKpGt9c7K5Qb64NVqVZoNps0m03a7XYkFi7ijHthROei6X8XvK7W6vL5f/k8//W//jdOnjiJlHLVe0fGJ0EIFN1ESkk+k0QELgBCUZBhgCrCwfmv3Hu9bfG/PvtZPvShD/Fbv/3b3PvJe1laWlr3+a85x3WkNw4jl8uRzWZpt9s06g2arSblShlN0/F7qX+hlARy+Wd1hRDWdJ0giAVWzM5gSzbtUspZKeXvSSlvBW4F3g3MAclLvzNmu3Ach8np/QAcOXSAQj6HEIJEIjEoIjVNE8dxMAyD4kgBZIBfmwe2VifUdCSWLzFEyOy9v8c3Pv5HfOpTn9qWFbZhWJ02OVOh22mt3t5uY2oCXQGr28bqdsgaAqvTvuD9LZKaQCPEsaxtHVvaUPjJ4xmOjkUpLS+7PsUv3JHnF+7I8yOHotVJbSSK5n3iE5/gscceW9d+E8kUh268lb2Hjqz53eTuvRw4chMjYxMkUxnMZBbHcZiZmcF1Xc6ejRfnY2J6/DrwmJSyBiClrBItDP7KVR3VDkH2Gqb7fYEVrO2DBVAojCB9FylDQqEShBLDNKKIkBBYVuRK64erb9wvRaPRoFar0W63aTaapNIpCoWLJ9msiWCto74K4I8++GE++9nPUq/XeeTRR3CC1SLp4A038sa3/kJ03prCb/32bzGaX46gpU2N3/vd36OQTXEhZ2fm6a8JdjtdvvzlL/M773oXH/nIR3jqqac27I+5mQhWn3whTzqdptVq0W61qdfrdKwoNRAY9MEC1kSwVE0jjJsNx+wQtqUPFoCU8lEp5X8E9hGlDcZcARzHwUhFF+nDB/aRNE10XUdVVUZHo35Xpmniui6maTJeHAEp8foCq5WeHwMAACAASURBVL35KEffObC7eHaQEnH27FnCp6HHhWNbCBmQ0hWs9gXCqdvGVAWmBvVKGU2EpHSFbnu1EOt2IiFmqmKNSHs6mR6JbiIS41FdlAwlf/6xP+f0qdPren8qk0XX11pIKapKNh+5PqqahpFMkcoVaDQalEol6vU65XJ5zftiYnYgDvA6IcSHhBC/KoT4MPBaoHuVx7Uj8H0f1/cJRZRt8ew7bucd73xHZAW+gsJIJHwGaYKBHBhdBH6I1WshEobri2C12i2WyktYVpTWlkgmGB0ZveR71iuw2l1n1XOpLI/n9OnTayJDqWyB3XsPAMtW9Al1OSvBVAVCEaT0tSWB2ZEid73wrlXCUEr4zuPf4f3vez9/9L4/4uyZ9S+oXa4P1uUYGRkhmUxSr9fpdrq0Wi2arWheDkNJEKwUWCsiWJqOL+NmwzE7g20TWH1kxH3bvd+Y4TiOg9tLEdRE1F/CNKMc75GREYQQGEZk3a5pGhPjY0gZ4teiPll997/NMNuI0huccpQRms/neMMb3rApd6fLYXXaJHoiyup2VqX4WZ02CU2QUAW1cqkntoZFsNrLv+v3VrkCFJMKKhLMLMVde4BoBe8jH/kIC/ML23acVCaD0CKB3V+xPX/+/KCvWUzMDuZdRDXDbwR+t/ev2vs55mnG9308L0Qq0VyVTSWZnp5e08tqZCRaMAp7aXK2L6NMDBH1rnI9D9/3e+YJlxZYXavL4uIijuNQqVQwTIPiaHG5scxFuFAYXZgyKEPJ1772Nf7pvi+t2i70BNN7p/nJn/xJ3v72t68RLrYvB/saCCxteTDDtvXREmle+cpX8pu/+Zu89a1v5dhNq3ssnjxxkve85z388Uf/eFAXdTEuTF3clIGGYND+pVqrEgSSpXJlYGwRyOVo1koXQU1bbjYcE3Ots/13wjFXlKgGSwMBqgyQYTDIa08mkyQSiYHgklIyNjqCogi8nsCab/lIKdfU91wOGUoePjkL6Um82hyarvGGN/zsRfPat4rViz4pQOjaVCtlVE0nDENK8/NM6A4B0LRUjLSCIzQCT8G1bYxePZrVaTOeFSiBoHoFI1iKEBR0n4qn8/LX/gyf/Oh7aLfaWJbFBz/0QX75P/zyYOV2KyTTGbrtCqZpomka8/PzJJNJTp8+zQ033LDh7zgm5lpBSvk+IcTjwE8De4BZ4H/Ei4FXBs/z8IMAKaJolHqRpd3iaNSIfqXRBSKqw7JaTTQJnU6HIARVv/jti+3YLMwv4Dou5XIZTdUYKxYR66gRHiaM+iwtLvHxj3+ckydPkrnlR1a97oUv+VF+9Oa9AwHndFZnhzgrrNfNnogyhwgsc4jA6r9PKIIjNxzhyA1HWFpc4r777+PrD3x9kEHy2GOPceSGI4xPjF/0/PyQNT22NoNQBMWxIkuLS1Qri6iux8LCAo6aQ6jRdxPVyq1wEdQ0giCOYMXsDLY9grURhBB7hRD3CSG+I4R4XAjxy73to0KIfxZCPNX7d3Pdb69xgiCIVvN6X6MSegiiC5qu6wOzi77VrRACU1cZHSkQduqErkXXX9tweD384z99DluPxJRfm+MnfuIn2Ld/3/ad3Ao812OpVKJVq7CwsECnVac0N0e73abTbuE5FpoCSuDjeQ5Op0Wz2aRTr3LyxPcol8tUl8pI3yVh6Jga2J3OthtdXIoRvZdOqaR585vfTCIRid5GvcEHPviBQVPmrZBMZXCC6AZkz549BEHA/Pw8nU6HhYXti5TFxHw/IqX8opTyTVLKl0kp3wRUhRDvvtrj2gl4nofnB8jeXKVdROjkcjk0XRsYPTR7aXipVIpQShzPp9lsElzC5MJxHObm5nA9l6XyEoqiMD4+jqKuz42/Lzj6gsfudUeWoeRP/uRPOHnyJADCiBbuVBmJhfzo+KroWP99y/tZFlj91MCV0SpzyLbBe4ek8Y1PjPOa17yG3/i/foNn3f4sAPbu28vznve8DZ7fxXt9XQ5FURgbG0NTNar1Op7nsVSuEgThwE1wtYugThDK2IApZkdwVQUWkVXuO6WUx4DnAm8TQhwjcib8vJTyeuDzvecxFxAEAQsLC9Ra0c35V+7/AooAXdcHBhfJZBLDMBBCIKVEE4KRfBQtWU4T3NjF7pFHHuHzX/k6ipEksNv80HNu59nPfvY2nlk0mdmWTalUYmFhgWplCVOBgwcPMlUcIZdJMT09TS6bYWp8lMOHD3Po0EGmxse4bu8ebrnlFsZH86hC4Hs+pYU5WrUohQEp0YTEtq5c+cWoFn3G8+2A6elp3vCzPztIj1ksLfLAAw9s+RjJdBonkHQ6HQzDYGxsjFarRaPRGAitmJidjBBijxDi14UQjwDfAt5xtce0E/A8Dy8M8HqmtTLwkOHam3qhCIqjxUGKYLkeZRqkUikUTaXTtbBsG98PUJS1ty+u6zI3Pxctyi0tgYSxsTFUbf2tzvopc3lTWfVcKIJXvepVQCQsJndHNbVZfVmorMS+YD+2v5yaN4hgqUMiWCu2XTiGYYyNjfH617+ed7zzHbzuda9b87k0m008dzli1E9TTOsCTYn8MbwttMRUNZWJiUmCULK4tIQfBLRabfwgiFIE1ZUughpBz/AkJuZaZ8MpgkKI/3M9r5NSfmwdr5kH5ns/t4QQTxClb7wSeGHvZX9G1HPrP250rNc6YRjSaDRAi1wE69UlhCiuElh9u/Z+HZaqQLE4ysnz83i1eYzJQ3zme10KSZvXHstg+ZJPPtG5aOFrGIZ0u0VGX/wmAEy3wSt+7N+ua7ytRo1kKoOm69jdLhJJMrXc5NHqtOk0m3SsLp12m7mZGTQhMU2D8dEC+6ayHD58mJbtUQ8DfMdCBB7Tk+McO3YjlmVhcYrdIxn27t3L+VKZWiiY2jWFa7VQ8hkMw4jcpGptzp58iuLY+JoJSTcT5ArbGzTtR7BOVD3+8OsNYIJdr/4NbNtiXLN40Z3Xr3p91Qq498kOL9iX4EhxrcHFMFRVwzCT2J7HuXPnKBQKJJNJZmdnsW0bwzA4duzY0BuTmJhrFSFEBvhx4PXAXSy3FIFobol5mvE8D98PaVs26Fk+8/ef4smC4K677lrz2mKxyPleimDbjm7EFUUhncpQshyCkKE36LZtMTc/j+95LC4tEoYhE+MTg7lwvfTnvkJCodQJVs2FR244wstf/nKO3niUL1bzNJs+aTWg7mtrBFZfyOR7+3F8OdjXemuwBmNYRxrf9PT0mm1hGPJnf/ZndDodfvqnf5rp6elVaYoJX9AOo8iaoW4+hdxMJshkc7hOja7fJZFIMr9QIjCyq9we1Z6dexzBitkJbKYG609ZnynoZQXWSoQQB4BnAQ8Akz3xBbAATF7kPW8G3gwwOTnJ/fffv5FDDmi325t+79XEsiyefPJJxKFe9Mi3mZuZZWo0z4MPPsjMzAyO43DmzBnK5XKvg30NrZcA78x/j9SRf4OLymIn5H9/d5ZOoFK119rELiMGTREBjk0mOXX68m543XaThbMnSedHmNi9j7PfexwpJftvOI6iKMgw5KlHv0XYbRCEIbquo2kqS6c7CCCTMnBGIpHotJtYToNT1ei/SEYXzMxk8TyP1tI8dTFOoVDAtzpUW21y5TJz58+jdcr4I2lc16VdWWB+bhZFEZhmgkQiMahRckKFXYeOYia2r9uA4bvktCxNX6M7aCCpoiQyVMjw+FMnMZXlP6vvtJMsddN840wVpdYevtMhVGo1FptlnjhxmrQmOXrDER577DHa7Q633HIzjz/+OJOTQ/+c1sX369/KxbiWzudaOZf+ebzwhS/c8r6EEH8N/BiQYFlUPQLcAnxaSvmqLR8k5rJ4nocXBPiDCJZPOjW87vTHf+LH+fqSwrcWQ/LFicH2XC6HH4a0u11sTce2LRK9a3Sj2aBSruC4DuVymTAMGR8fRzc2Jq5gOVrUrSwAxTXRoxff/WIA7KUoupZWI6OoC80w+kKm0I9gBcsRrGFiyhyybRDB2oTTH8B99903cKv9g9//A175yley+/hzB8dxNUHb643L3NQhgKi2StMNcokC5ZpH17JpGR7djuR6fXWj4dimPWansBmB9SU23HXh0vRWGP8OeLuUsrmyGF9KKYUQQ48npfwQ8CGAO+64Q252Qt6uyfxK02g0+Ku//msUPYpSpUydvdO7yeVyvOAFL2DPnj1IKfnWt75FuVxmaWmJcrmMUnF45HunaFdmaP7je3jh69/OQxWFMFXEdULo+Lz0cJLDI2snp1OnTvHxj3+cwA94y5vfxP7pg+sa68LMWbLY2FJnenoPQWsJgWDP7inMRIq52Rmy6QQH9xY4ePAgyWSS7373u9x5553k83kMw+DAgQNkMhmOHz9OtbrcRNg0Ta6//vrB+Pbs2UMyGU28xukljt18M4rb4friTTz7jtupVCqcPn2aTqdDrVaj2+2iaRqjo6P4vs+pxRbF3bvIj45t9SsacOLECd56UxHLW/1f+e+e6DDXDkiO7+Pgis/720+0oeOjJzMcPjy17uPs2ztNuTRHo1ph0gw5duwYvu/zvbOzFAoFDh8+zPXXX79pM5Lv17+Vi3Etnc+1ci7bfB6vIZqvHiPKhrhXSnlaCBECW0iMitkIkclFSND/xMOAVHr4Ql6hUCDTsgF7VeQmlc6gahq1Wh11LM/8wgKZTAbbtnEcB9uyB/PCxPjEpsQVgNU75nceeoDss15G2x4ebenXWKXUsPd8uMDKGAJFROYS7V69cz8NcJXJxZBt+cRyeuFmzKiymSyGGTVqDsOQe++9lyNlFyZ/gIQqcLTh6Y0bRVU1wl5GSsbzcVyXViugjU/XskilM4PX+WFschGzM9iwwJJSvnA7ByCE0InE1V9KKT/Z21wSQuySUs4LIXYBi9t5zGsF27ZpWdGFSvoupq6hKgqKogzSIvo27f3nqqqiq4JXvPzfMjI2xnUHDnCuFfJQpcN8O6DhRJPF/rxG2libSnbz0cPs/oW3UK6U2T+9/ht/q9MmYyh0Oy7NWgVTjSadytISim7SatQZy2c5evQQx48fZ/fu3UxOTvKiF71ozb6mp6eHpkMAHD58ePBzoVAgaVSoLC6gIinksxw4cID9+/dz4MAB5ufncRyHbrdLqVTCtu1e3n6A9zTkiCtCkDZWT5C7sipz7YCFdsDBEZ3AD/i7T/4d83vvBhRsb2MTn2Em2L3vIFKC3SpFKaRC4KsJZmdnufnmmzlz5gzHjh17Wuz0Y2KeoRwF7gEsIcTfX+3B7DQ8z4uMD+g3GvZJr0gPv5C+yFgZuVFUhVyuQNgt02236Xa6BH6A67l02h06nQ66rlMcK2762uY4DrVWB7QkQacOQLneBNZG2/rRqH4Ea02K4IpolakKLF8O5tehfbCGbOvXSflhVCdlrL+UDIDn/OBzOHToEB/7849x/tx5AM7PlchORlb4CS0KW22mF9ZKorRzBT+U5PMF2p0O9fosvqlQq9XIZDIkEslVjYY3IxhjYr6f2HIxhhAiLYR4rhDix4QQr+g/1vleAXwUeEJK+f+u+NWngX/f+/nfA/GEOATbtmm50QU79F00TUPT1FUCC1jjJKgKwdEbb+DQoUMoqspUJrpqL7QDup4koYlBasIwimNFbrjhhg2Ntd+rytQE1cUSpgLdVp3F+TlMwySTTDKSTbF//36OHz/O+Pj4li++hUKBlKFRmpshaSiDJo1CCIrFIjfddBP79u0jl8tx3XXXMTU1hZSSWqVMs9HY0rHXy65MdCOw0A7odrp84AMf4OsPPYYVLq9cboZUOoPjy8g215cYySy27TA7O4vrupw7d27bziEm5hnMzxHVWanA3cB7gfNEUa1dQoit90eIuSxRimBIIHsCK/QvGsGC1Q53K9FNg1xhFEUoLC0tMTM7w2JpkU63QyabYWJiYtPiqtvp8oH3f4BQRO/vC6xEJr/mtVJKnF4LyX4E68JUwpX1Vv3zWSOwLlOD1e/vOGz/66U4VuSXfumXeP7zI3dB0ct4efibX8fttra075Vomo4XSlRdY2RkFBSNVjsyu5hfWMD3fYQQaJpGEMo4ihVzzbMlgSWEuAs4BXwV+BRw74rHeng+UeHxDwshvt17vAz4HeAlQoiniCbF39nKOK9VbNum27P/kZ6DpqroqhpFqVYILNM0VwksTWFVhCahKYwklEHe51RGHYibxx59jEq5sqVxuo4DoY+m9FbyrC7NWpnQtVEVwfjEOKHvcd2+PRw7dmxN88nNks/nSeoqruOQMjTy+dUTpRCC8fFxjh8/zsTEBCMjIxw6dIhUwqRaqbC0tEQYbL4R83pYFrc+lmUxvzCP9v+z9+bRkWX1nefnvj02KTbtUu5FZWVtWStFm4bCGA80NtCGNuCxOWDsAmwzduPptnum3c0Zz7h77NNte8CG4/ZAY2wwuFw2YJbGxlSZmqI2qILaq3KRMqXUFhEKxf7WO3+8iNCSklJSKKsys97nHB0pQhE37nshxbvf+/v9vr/MSPf3TW93WUyhZXvo1mR7EhRBoi9NuVxmcXGRpaWlNWmWERFXIlLKT0kpXw/sJ3SjfZIVk4vbgeleX0MIkRZC3C2EeFYI8YwQ4lW9jnml4Xkenh8QdMrgfI9EfHOBFdhNABaKy2s+g1VVA1VjcGiIfD5PX18fmWyG0dFR0un0tvpcbUSlUuHjf/Rxps5OI1Qd6Xv8yO2h9bmzQXSnE1kzVTBFO0XQ3ziCZa4WWK2ge9/q77BxH6zOpuRG4+8ETdN4+zvewc/8zM+gmeF5dxs1nn/6yXDsPRBYiqri+qFroGbo9PVnUFWNQqGA67rMzs4SBAGqrkcCK+JlQa8RrP8MDABNwgvWMuADU9t5spTyfimlkFLeIKU83v76mpSyKKV8vZTyKinlj0kpo5XgBti2TbOdHi49B01VN4xgmaaJ2hZeocAS56XADSdWRM1Ie9H/zDPP8JnPfIY//H/+kDNTu494NOvVMCVQURC+Q2V5GRWf0cE8uiqIx2KkknEyqeR5IqgXwghWeCwxXe1GsNajqioTExMcPXqUbDbLQD5HPG5h2zZzc/O0mq09m9N6sjEFQ4GKI7H6Mrz/59+PkR3r/r7pBhvaGV8IMxbDkwq+lNh+gBAK6GED4lKpRKPR4MyZM5FdbsTLAinljJTyd6WUNwI3Ar8HnAP2wsnmD4FvSCmPtsd+Zg/GvKJwHCcUWCJcckjfJZ7YPEXwni9+HoC5QonyqmwCVVNxA9ANAytm0dfXRyKR6MkZtVgs8rGPfYy52bluPbOhwlvf/EYAbD9smLua1U58etucaH0/qdU9rzoiqfPb7fbBMlWxaTRvN9x6261ce9MtQJgiGLTdGp87Odnz2J33RtU0VFXDFwrpTAbf9ykWi9i2zfzCfBjBkpGTYMSVT69FGDcAXwVOAP8LodvfPwGf63HciG1g2zbN9uae9Gw0bUVYrU6TWG3VDqAq4HnhwjrwfR559FGeeraAcuRHgDCq8r1Hv8fnP/95giCgVq1xzz338Gu/9mtrGilul2ajHu7EmSa18hlMzeDQwX2YponXADwXS1fo60vtWfQKQmGZTMQxtBpxQ72geEskEtxwww089dwLlBbqDA0NUSqWKBQK9PX37doYYisUIRhKqpyt+MzVfQ4fOsj4rE53R0Eo/I9v/SNvfMPrdzSuEIJYPIHtNWl50J/NYdeKGIaBpmmcO3eOQ4cOMTU11TUIiYh4OSClfAL4DSHEb7LSDmRXCCH6gdcA722P7QDRrsU6bNsmkCCFiiCswYrFLMqlEs36WpdUw7RIJ+Phrq1uUSwUyWazQBjBsgOJomx8nXi+6PDDeWfbLlyu4zI5eQbvFW+g/xUgtPAambLC3pGmGgqsu5+uszpj3elGsASqAFWAL+HuZ1Z6DS6tilZZ6yzQt9sHa3UE6x9PN4nrvdcszTsGIMn2JVlqbx4uW0N840SDHzu0st9wuuzy/dnwfTuaN7h+cG27kKodcP/ZFreNmuTj6pr3RtVUvEBixWJkMhmWSkuUy2UQ0Gg08WNmeHubJBIJNE1DtntomWYPlocRES8SvQosBZgEOh1b+4GTwL8HPtbj2BEXwLZtnHatjnQdDD00s1AUZY1Q6XwY6brejWA125GLL3zhizzyyCPo+f1k2gLrO1+7h6e//3D3+Zlshve+9707Elee66KoYTStUauitOp4nkUqESdupsjn8+zfvx/3+Snmz00T17VNI0y9kE6nSceXSCUT2/pQjsViDOZzzDVVYlaMwcFBlspLVJYrNBp1UokEqqphbZHeslOGkxpnKz7fnmzy/VmbqpKEAGTgIxSVf/j2d3Czhzk4Mcp1g9vriQUQSyZpLddxA8lofpDZctho+ZprrmFqaor5+XkURWFhYYHBwcELDxgRcQUhw3DDt3sc5iCwCHxaCHEj8D3gV6WUa7p6v9xbijz88MOcnZ5DpvaHAivweOLRhxCezfypZ9c8NlB1tHbanTAsnnr60W7q3/zsLPXlJRqBRqVxfmbBPxTTVLydLGsEysDB8xzKjaDFiRMLxEU/NjqnyhtHWwy/iWM7JFWPZU/j5NLax2kiYP7saWjFgfCaoYuA2TOnWGhfT+NKBk8KZqZO0clwjCkZfCmYnjyFYieAGLO1vU1Xf/Ut1/PY0y+wDFQceHzeIWUvksHhxIkT3Fvqp+CGG7Znyw6xytpEoufrMX5YS1CvLnM8VV/z3iiqysL0OaxECmEmqNVqnDl7hr5UH+XCLIt6wHPPbD/Qm07Fuemmmzh9+jSzs7PceOONJLaIgMLl+7+yEVfSscCVczwXainSq8CaA/KEfUUE8APClMFKj+NGbAPbtnGkikYY7jcNvRuhWE1HWHS+K0hcxwbgjlfdwSOPPIJXniWwGwROY424Gh4e5gMf+AD96e2n7rUaDU489TiZwWHG9h+iuLhAyl1m8LprSCQSLFfrHD9+HMuyeGFqhrrdoi9h7Wl6YId0Ok0uYWx7bF3XMXUNTVMYHRtlcXERoQhUReHxh76DISDZ18/IgSPkh0f3ZI77+jUeOWdTaAQUGuHCImUI6stVglgaNZXjqVaaZ16oczSvo22zziCeSDG7MIsRi5NI9uEEklq9jmVZ5HI5isUiqVSKmZkZ+vr6upHOiIiIbaMBNwMfllI+JIT4Q8Jar99a/aCXe0uRpaUlztYFNNrXJt9jZHgISme46fi1QBh1bzQanCzZ+EaSxwBFt3Bdt+sOOzw4QGFuhrEDh9GN8zfMvlFaBiRvviq+JtVuI2QQcO+993Hq1Ck0VeUNP/7jjI6NIoDxvj4sbZDR/QEz1Y2FjQAm+vo5O1nlPVdlObeBAMrHFDKxLIcDyY0VDy+AgbhC2sp2H/O+iQBfyjX3/fxEQCCh38pywJecrXj0aPS3hpQhGE6meeV1h5mp+tw71WS64pMdHEFfPsPBAwe5t1IPrQsBVyocPnx4jfHUzFQTajZmoo8jR0bWvDeKonI2lSCbH6IvkwUJi4VFbNtmdHiQ8uI8iXweTb/wErRerXJovJ/XvOY1GIZBfybD8ePHGRsb2/J5l+v/ykZcSccCV87xXOg4ehVY9xAWD98NfBToVOd/osdxI7aBbdscu+k2ngcOTYzQX57v1lutRogwPU/XdSzLQq1UaDUbSCk5ePAg7373u/jre+6h9A9/AsHKReL222/nrW99C7EdRmuqy0tYGlTLJQqxJI1ahX1D/Rw6dKjrJHTw4EEArto/xn7HwTAMRkf3RrCsZt++fZTL5TX27VvRPVeKQuB5jI6OUiqVqJSXGOhPYTplGo0SpcLingmsIxmNn70+2e2/AjCUUPnbZ+BcXaL1h9GlAMF0sc6BgeS2xu1LZ6lk8vRn8yiqimHFsD2Xer3OwMAAtVqN2dlZLMticnKSq6++OrLNjYjYGdPAtJTyofbtuwkFVkSbTlqX47oINVxyaKpAUcB2bBKJBJZlMTExwWOPPYYibIYHB5AVD6FqTM/MdcdK9vWT7Nt8s6xjBHF1TsdQL/xZduRfvp6/unuJ48ePc/XV+8/7fVxXuCp74fquhLH14zRFcDC9cV+u1AaOvavv01WxpkfiXiKEYLxPIx9Tma74tHzJ6eef5+6/+iviP/pBOmkrEnB8MFetGDs1YR0zj/XvzYGrrln1QpDLZplfWKDlehy4+himZTExPnHB+rlH7v92t2bLdV0cL6rfirg86ElgSSl/vfOzEOJ64J8D81LKB3udWMSFsW0b1QrTybL9Scy6tmEEC1acBHVdD50GZYDdamLF4tx2++0cOnyYe++9l0qlQjaT5cbjN3LgwIFdzatRr9JnKEwWlvCkQn88xoEDB+jv7w+t4Vd9oN5xxx27PfxtYZomt912246eY1kWuipwbBsrFieXzVGYm6EvYXLw0FGefvZ5ZmdnmDj8im5D417oXOTWkzBVqHsY6aHufd944Pt88K2v2da4iqqy7/CKnX4skcJuFqlWq6RSKUZHR5mcnGRubg5N05ibm2NkZGSLESMiLk+EEPuAipRy+4Uf20BKOSeEOCuEuFpK+RzweuDpvXyNyx3XdXE9H9OMIWwVkPz7f/ebnHn+SZrNJrqu02q1up9DqhAMDw0iiy2EmmS+uETg+ygXqM/1AokXgCJA36bnhaKqvPOd7+z9IC9zOnVeZ2cXuO9b30IGkgHbQ6h6tw6t5cs1DocdgbVdd0NFVcnn8swvzFMoFhkcGGR+fp7hkWHEFvUHmqYTtF0HO3b/kTlTxOVArzbtp4QQ/zuAlLIkpfwScF3UyPHFwbZtWjJ8C3Xpowg2jGDBWqt20zSxNEGrsVImkMvlePvb38773vc+3vq2t+5aXAE063WcZg23WcNu1BjI9jEyMsKRI0d6cnt6sbAsC00VOO00SgDpeRwYH2ViYoKJsRFUJPOzs9RqtS1G6nEeWniuhg6u7AQOH7lhoc5epwAAIABJREFU1+OFphcB1WrY+8SyLPL5PNVqleXlZWZnZ2k0GhcYJSLisuQ08B9W3yGE+M9CiL1oePdh4C+EED8EjgO/swdjXjGEi2IftHazewG6oSMIXff6+/vJZDJUKhU8z0MRYFkm+KGNty80FguFC75O1xZdFRtG4l3X5dFHHmXbDhgvI1acCgMUoYCihnb1QUBskz5f9roI1nbQDZ1cNotjO5TLZeqNOkulpS2f0zHM6Ags2wuiCFbEZUGvq90DQG7dfTcBP9HjuBHbwHEcXBmKKVW6qKItDjaIYFmW1bVqN00TUxM06tU9n5PvedQqZRrVZfpiJrqmkE7Gue666y6b9LMwgqXi2isCq16rkk7GufXWW8nn8wxm00jpU14qU6lcnJLDzkWvIVZqDUru7l0WY8kkLY81ojCXyxGLxZibm8NxHE6fPk0Q7K73VkTEJcxGHz77ge3l226BlPJxKeWt7XYjb5NSbr1ifJnheR6e54PSdrgVAt/38D0XVVWJxWIMDAyg6zqVSgVFhO62RsfoQreYmZm54Ot0bdE3qL0KgoA//+xn+dznPsff/O3f7Kr1xZVMx+WwLzPAm3/izRix8N9Cuk2K87PA+TbxncjVTu3jY/E4qVSKWq1GvV6ntFSiXq9v+nhNC/tmOY7TjWBFPbQiLgd2JbCEEP8ohPjH9s13dG4LIe4F3gPs/co94jyazSatIFxwa9Jr98HSNhVYQDeF0FQVmhch+rJULGLXq1iWxVA+g6GbHBgf7drsXg6YphmmCLYjWI7dIvAcknGLTCbDjTfeSH/CImaYxBNxKsuVHVnObpfOQsFZVTtdaPh4u1wcxGIJ3LbRhd9u3imEYHR0FCkls7OztFqtbS1mIiIuB4QQvhDCJ4xb/Grndvu+nyZ0AIy4iIR1MwF06q+UUEAFntcVWIqi0N/fH0awCDfqrHaen2JYzExf+DOp0/z3PIEl4e677+aJJ8Kmut/5p+/w1NNP7d0BXgF0Uv9sXzI+Ps47f/bnAAicFl4zFD/zhbX7BruJYHXo7+/HtEyWlpZwHIf5hXkcd+O0P1XTCKSk2WziBxLPj5oUR1we7LYG6872dwmMt79W8xe7nVDE9pBScvr0aWYWRjCHMzzywD/xpmuHwhz2DVIEO7VClmVRr9cxNWgu15FS7llkyXEczs2cJW5qHD58mGq9hd7fRyoZv6wc6jo1WM22wKpXq8TafbSEEORyOQ5OjHKi0CCbzaIIhVq1BhLSmb2zmt9wJ1bCQt1nNKUxNTnF0NAQVmx751ZRVYxYHNtzqNfr3b5ehmEwPDzM7OwspVJoxZtOp0mlUnt2LBERLxGdfyLJ+VEshyid76LTSREsV9obeoFHZbmG77mYptlNGzfNsBF64Hj4vkcqZlDzdh7BMtd9bn7jG9/gwe+ulIXf+bo7ue666/bo6DbH9/zQ6dd18DwP3/PxA39NhkCnpYqmhhujuq6Haf7a3vWD3A5rmhmrMDS2D4o18B2kG9rhf+3vv8VE/E6GR4ZXHgs4AfiBRN2muy2wxvSiWCwyNDjI3Owc4+Pj55URaJqOZ0sajQZ+IPFlJLAiLg92K7DeR3ix+hTw96w0FvaBs4TNhiMuIr7vU61WUczQHc+3G6iKQNO0DeucdF1H0zQsy0JRFAxNQxMt7GZzT3o6+Z5PYbGA67QYy2fYt28frVaLM8XGRelvdTGxLAtNUXDaKYK16jIxXe0eRzqdJm5qWKbR7cUhhKBarSKlJJPN7Mk8YusWCrmYQrEZ8OC0TatwkmeefYbxONz17rd2+8RciHgiiV0PjS5WN05Op9NUq1UWFhZIJBJMTk5y7NixPW38HBHxEnCQ8Fp1ivB69dvt+31CQ6ZopXaRcV0Xz/M5OXkG9r2C5aUSD579PhNpk2S7dUgikcBxHFRVJfCa+L5HfyLJ7DKM7T/I0dyFP9+6KYKr3APvv/9+vvnNb3Zv33LLLfzkT/zkHh/hCq7j0mg0aDabK3VCAnQtvP4aioFQBCKsQEMGEj/w8TyPZqvZrQ9TtbAPYywWC9urXOTsenO1wDJXzuXYYJ4zS+eAMJPijz/xx/zKr/wKg4ODa1IDbV8S34nAYq3pRbFYYmBggIXFBYaHhtc8TtM0/GZbYEmJH0QCK+LyYFcCS0r5GQAhhASeklI+uqezirggrutSq9VR+sPIlC49NFVB07RNI1LdD2vC3UJTtWnUq7sWWFMnnqWyVCQIJMvlMoEM6OvrJ2HFOX78OC+88AJ127ssBZauKSwvlnjw3m8iJRwYiHd7acXjcRIxC/wap5/5IZXlZZqtJo16g0ajgWlZpFIrpR2GGUOYWzdF3HAe6wTWK3I63522eb7kgjJE4tgQRbvOP3zrW7zhDT+2rTFj8SS1yiInT57k1KlTa37n+z5zc3M8+eSTXHXVVaRSqZ7MTiIiXmqklFMAQoiDwPJeuwhGXBjXdfH8ANsL05Jl4KFrGoLwmqTrOv39/dTr9XAx3Y72pJMxWLa5+fZX8c8mLhylt9fVYP3g8R/wN/fc0/390WuO8u53v2vbm1HbRQYyrCeq1cOFf9tsKpFMYJkWuq5vTyDJ8FzZtk3LblGr16jVaiiqQiKeIJFMbJj+vxd0ROn6tL9MKk7u+mM8XQsjibVqjU9+4pN85H/9N2v6ctmeJL4LJ3nd0MlkMiyVligvl0FA2SyvWTOouo4drIpgRSmCEZcJO/5vFUL8B+BBKeU3CYuE9wsh/sX6x0kp/489mF/EJrRaLRrNFspAuHBXpYveFlibsVpg6bqOqQmajc2LS7fC9zwqS0UOpTWKhSIxw2FgII9lWRw7dg35fB7btqnX65ed9XcikWAol+m6+EF47vL5fPf2xMRE1ypWjvezuLhIpaJRqUClUiEhIdNOFzxXa7Ebc771AuuOMQtLE9ie5LnnnmdRG0AxE3zzG99l374Jrr766k1GWiGVzjI/c4YTpY3z3W3RR6VcRZs6w/T0dNfhKyLiMqcMfEQIcRNrjS2klPL1L9GcXhZ0rbXdtsDyfXRVRSH8XE0mk8Tbm3zxeBzfc/F9D8tYqQvaDh3TBVMTvPDCC/z5X/w5sv3Uffv28d73vveCVu87QQaSaq1KsVQMhaKhk86kicfjKIqCIhRMy8SyrLCuV9NRNRW1nWEiZWi+4fnt/k6OE4qrZoukTCIDSavVpNFoUq1VqVarxGIxUn2priPwXtFNEewYV6w6l7lUhqdrLbRYuNZ4/Y+9HnQTWDGB2qnRxWoSiQSu41Kr1jANgwIFTNPsljVomkYjiFIEIy4/drMd8lHgD4Bvtn9e/58l2vdFAusi0mw2qbUchKYjAx9dAU1VMAyja2Cwnk4xsa7rBEGApSqUdukk2GzUsFSB73lcc81RRkZGSKfTHDx4kFwuNJYcHx9nfHx9ed6lj6IovPa1r0XKlT/t9VHBa6+9lmPHjq25b2pqikKhwOLiIoVCgUwmQ6PRoPjCGZbqO1dYqwVWXBeYmuCVY+FO7qvHr+O//I9n8M04WnqUz372s/z6R379gumJhmly7OZXrjm29fzwew9RWJ6lUChw5swZkslkuAsbEXH58jngjZwfS4js5C4yKxGsdu1R4KEaKoriYxgGlmV1F9NdgeV5a9PWtkG38W29wqf//FP47YjZ4OAAv3jXL+6dKJFQb9RZLi8TBAG6rjMwOBDWkwmFZDJJIpkgHoshxOY+YkKE1xpN07BMa9XwklazE8HSiMXjBL5PrVanVqvRnG9iWibp/jS6sTefy6vPtZRrHRk7v7v6mus5cjTNbbfdRqGxdo2x3V5Ym5FOp3Fch2KpxJCuMzc/x8T4RNu0SydoN6uOBFbE5cRuBNZngIfbP/8Z0QXqJaHValFrf8ZIp4muquia2jWx2IjVRhe+72Nq0CrvzuiiUasROE18QyebzZLJZBgZGemKqyuBC52T9b/vpNN17i8Wi+3zLLCbvQmspLH2Qq2oKjdfNcEjCxI9O0pt+ik+/d8/zYc//OFtiaGtjm1waITZ5QVOnTrF2NgYU1NTHDlyZMfzj4i4hHgtUAL+iDCaFV23XiQ6JhduexEu/bbjrSrDemDD6LrbJhIJhAxwHLubttZZ7AdBQBAEm2ZpdNLavv/wd2m1wuhKf7qfD3zgg91a2Z6PxXEpLZVwHRfDNEin07TsFslEgnQ6QyqV6rnXo0AQi8W6WRONeoPlyjKKqob25vUa1UqV+fl5YvEY6f50z6YYmiLQFPCCsDhxdU+xznXISCS57ZrbgM17Yu0aAflcjrn5eYqFIoNDg8zNzzE2NoaqaV3n3CAAGYDnB/i+H9UIR1zS7FhgSSnft+rn9+7pbCK2TavVouGHH3yB00LTVDRV2ZbAMk2TWq2GZZpoSp1Ws0EsvrMLUHW5TKteIbvvKoaGhkin04yOjvZ2UFcA+/fv7/4speTcuXM49SqtngXW+YJofy7OIwt19Ex43qfPTnPPPffwzne+cxczXyGRTGEl+iiXyywsLKAoCouLiwwMDPQ0bkTES8jzwA+klB99qSfycsN1XXw/wPYDTED6Yf8rXZXh9/aGUCwWCwWWAKdl09f+/CtXG3zhC3/HU089xZve9CZe9apXbfg6HSH2mlfdwTdOhGXhd911196YDskw9btSraAoCtlslngijq5pZNIZ9u3fj7gIThQCQSKR6JqALC0tIZTwvlq1RqVaodls0tfXR1+qryczDEsV1AKJGyhrIljrhS6cH7Gq2R7QW4RQUVVy2RyLhUWWSksoikKhUMDUNIK2wHLbDox+EPbCigRWxKVMzxWTQog3E/a+Gid0EPyslPKrvY4bsTWhwAp3ygKnia5rGG2L181QFCU0tzBNpJRhbrjaoFmv7UhgBb7P3OwMeU3hqquuIh6PR2YIbYQQ7N+/v2vFGwQBzz33HM1aDdd10PXtX4QUITDU0L0pqZ+/KzqcDC8uVn4lDfOhBx9i//793HHHHbs+hlgigVR1NM2nVCqRTCaZnp6ObNsjLme+APyWEOIJ4HHA6/xCShm53l5EOimCri8xAXwPRQFNCy3KO6l7HYGlCkHNbnVT02q2yxMPPgTAAw88wCtf+coNo0SdWq3RoRy/9Eu/hB/4e1L/63kexWIR13GJJ+Kk02lUVSWTzpDJpKlUqxdFXK3HMAyGhobIZDMUi0UURSGRSFAul6ksV2g2mmSymV2nQpqaoOZKXCnW9BRb3SOrw/qI1f/34CPc/LZX91zjZlom/f39LJeXqVbD8oW+VHIlgtV+Wb9tCHI5tX+JePnRUyxbCPER4MvAvwJeRdi48ctCiF/fg7lFbIFt2ziEO3/SaWLqWteKfSvi8fia4lFTEzTrO2g4LGF+fh7XbjE6NEAmk+Hw4cPRTtIqhBAcPHiQ/v5+RkZGyOfzeK0axYWFHY/ViWJtFMFKGgopQ+ALlRvueE33/r/+67/mzJkzu56/bpgomoHZLmqenZ3FcRwmJye3rN2KiLiE+U9ADPg9wtYi325//eNLOamXA61WC8fzCWT7M0z6CEBX1TURrHg8jq7r6JqG6ziY7UuKasa7j5mZnlnT0wqg2XYQWt0Ha3RslImJiZ7n3mw0mJ+fx/d8cvkc2WyWRDzBxMQE2Wx2yxqri4WhG4wMjzA+NkY8HieXz5HP5wlkwML8Asvl5V0lwHYb2wdizbm0NqiFW18XVyhX+fzn/xIZ9H59SKVSxGIxlpeXsVs2S6Ul7LahlL8ughURcSnT66fDRwhTdv8A+CDwh+3b/7rHcSMugG3bOCIUU4HbxGxHry4ksFKpVHgR03WEEFiaQmMHAqtcLlMpl8n1J8lmsxw+fHjLqNnLFSEEhw4dIpVKcfDgQeKmxvzsue5iYLt0nAxTxsb/qsPJ8P3ef9sbGD52G8bQYfSBQzw3W8Hv4WIXSyaxg/DvpWPfXq/XKRaLux4zIuIl5MwmX2dfykm9HHAch2azBWooklQh8D0fXVPXbApaloUQgljMIvB9dBEupt1AhM51bb72ta9x6tQpKpUKX/27r/Lbv/3bnDlzZsM+WLtGwnJ5mWKxhK7rDA0NEY/HyefyjI2NYewgE+FiYVkxxifGyefyxONxhoaGSCQSVKtV5hfmdyxAOpEqV4o157IjsOwNBJYiQ7MLoZt873vf48tf+fKeVDdmshk0VaNYKiKlpFAo4ft+95rmB0QCK+KSp9cUQRP4vJTyI507hBA54H/qcdyIC9BqtfAUA5V2BCu+PYHVaS6bTCaxbRtDhVa1xomnf3Dh12y2qFaq6IbGYDLG4cOH1zSrjViLoigcPnyY2dlZMsk49coSjz/8AP39/RimsepxKqP7D2HFzu9HFu9EsMyNBdZIUuWFkstDsy4cexOd7iHf8yA+Y/Mj2+gfsxHxRBK7UGZmZoZWq0W5XKZUKuG6LvV6fc+KxiMiXgyklAde6jm8XOm0FBFqeG3SFQh8D12Lr9mc66R7maYJsoneXry3PMmdd97JIw8/QrFYpNFo8PGPfXzNa3zq//0UmTf9WjiO1pvACoKAUqkU2qUnk6TToVvf8NDwJbeZKBCk02mSySTzC/MoikIsFqNUKjE/P08mk9n2Z3VHmLqBsqanmNnpkeVDICWKWEkhzCV0FhsBih6+d/fdex99qT5e96Ov6+m4FEUhl88xPz9PqVzGCwLm5ufx1RSmZRFEzYYjLgN6jWD9PnBcCJEBEEJkgePA7/Y6sYitsW2b629+JQDHrjpEf1+qbWm6tcAyTRPDMLq9OizDYDylkVNaW34l3WXE8jnyus2hrMXEQB9Hjx59MQ71skZVVW655RZSls4rhlNkRAO5NE2fV+meW82uUFqc2/D5d4yb3DhkcKB/4/f1+kGDozmdg2mNg2mNA/0aI+3arKllb8PnbIdEXz8VO+BkocFM1We66vHEk0/RbDY5ffp0t8YsIuJyQQiRFULcJYT4v4UQ/UKI1wghhl7qeV3JBEGA63lIIejPZAEwDQ2QmG33wA6deqwwhV3i2i10pR0QUXXe9e53rdmYWk06k8FuO4ebPQiswPdZXFyk1WqRzqRJZ9IkEgkmxicuOXG1Gk3TGBsdYyA/QCweY3h4CNMwWSotUSqVtpW6100RlGJNHywhRDdd0+n0yWoLsH4rXEL25VYMkL7yla/wyCOP9HxMuq6Ty2Zx7DACWq3VKVeqmFYMLxJYEZcBvUawfhGYAOaEEIvAAKFo+2UhxC+3HyOllId7fJ2Iddi2jSs0kJC0dIyWti2BBWEUq9lsAnDo0KFuTdZmuK7LmTNnmBgZZP/+/SQSCa699tooerVNkskkP/7jbyCdTtNoNDhz5gxBELBv3z5arRZPPHeS5U2cHw+kdQ6kN7ddT5kKbzu6doey5gR8/JEK8zVvVxb8AIlkH0euvxnPCy9i8uQJnOIU09PT2LbN2bNn1zgmRkRcygghrgW+RXiNAvgd4OuErUY+9FLN60rHdV1c12dgYIDrJg7zwyW44bprUU7et2HGRceeXEFi2y1MLY7rSFqe5PDhw/zmb/wmX/7Kl3nyySfRVJWBwUFe+9rXcu31x/n9hytoSmg5vhs8z2NxcRHf98nn8lgxi0wmQy57+bQe6e/vJxaLMTc3x8DgAJXlCpVKBddxyeVzW64PuimCq2qwOqLL1MKoVcuTWNoqgdXOrMgNjmIePszJkycB+MJffoFEPMGxa4+tf5kdEYvHSdoOjutSqzco+x7ZoXGCqBdWxGVArwKrs8JSgNUe3QdW/RxVxV8EbNvGkeG2kia9sI+Fpm2rB1IqlaJQKBCLxWg2mwwNbb6J6/s+U1NTXafARCLBNddcs+ed5K90EokEt9xyC88++yzJZJLJyUnK5TKjo6NY2knmKrVdi6H1dMwvqo7k1GyJb/zNX/LTP/3TO7ZZN60YJqH4TmXSNJwy1YUZCoUCEF7M0+n0VkNERFwq/FcgA5wCDkkpl4UQ9wE/9tJO68rGdV1cz0NRV3oZicBDgQ0FVqfpsCIEtm1jqQlqhAv7PhPSmTTvec97kIFErBJSVTuMqJu7rL9yHZfFxUUAhgaHMEyDgYGB0Pr8MsMwDCYmxllcLHRvF0tFFuYXyOVymNbGkbhOimAzUAgkqGJFrFqaoGLLlWbO7e/pdgTLCeD9738/H/+jj3Nu5hxBEPCZz3yGD37ogxw8eLCn40mn05iWFfYfi+Wo1mvoRmRyEXHp02uK4Ou28fWjPb5GxAbYto0tw4uTGrhoqrKjCBaEkZVms0mr1drwcVJKZmZmcByHsbExLMvi0KFDkbjaJZZlceTIESzLYmJiAs/zmJ+fxzIMVBlgt5p79lpD7TTBz/7N1zl54iSf/vSncdpOTLshnkihtvPsC4UCrVaLqamp6CIXcblwO/B54O9W3TfF2o3BiD3GdV0c30fVNPxOVrHvoarKhq63sVgsNGFSFexWa0ODBWCNuIKVvky7qb9yHZeFxQWEIhgYHMA0TYaHhy9LcdVBCIXBwUEGBweJxWMMDQ2hqiqLhUVqtY1NrTrnruGra24DWGq4VOwIrM757m/nDrY8iRWzuOuuu8jlwoif67p8+ct7YHohIJvJECCoVCoIRWVhYTG69kRc8vQksKSU963+Ak4Aj29wf8QeU6vVaLY/7IRvo6nqtmzaIczXTqfTpNNphBAbOsN1xFW9Xmd4eJhkMsn+/fujXkg9kkwmOXjwILFYjPHxcWzbptlsYqqCVmPjNMHdMNJ2F5TJMGo1NzvHF7/4xV1f7Kx4gpYnMQwDTdO6wntycnKPZhwRcVGps5Ie2OEGILLFvIi4rovn+qiqitcWWDLwuhuC6zMuLMtC0zQMXWunCLYtwv2tP7hsb3cCy3EcFhbDZuqDA4OYpsno6AiJHfSFvJTpS/WFm6OmxcDgAJZlUV4qU14qn3ct6Jzreru/5upzub4Xlr2uBqtzf19fH3d94K5wvXBgP+9///t7an7cQTdNUv0ZpBDUqjWaLZvp6eneB46IuIj02gfro0KIr4mQ3yW0vV0QQrxjb6YXsRFBEPDCCy9QrtsAPHz/fWiq2HYEC2B4eBhN08hkMlSr1TXRjSAImJmZoVqtMjQ0RDqdZmRkpLszFdEb6XSaffv2kUwmGR4eRgiBXa/SqFf37DU6TYhHjlzfve/73/s+3/nOd3Y1nmnF8IWC6/nkcrlwYbKwQKVSYWEX/b0iIl5k7id0t307gBDiYeAOIGoyfBFxXRc3CJicmqJQKgPQatS6Amt9/8TVAstx7G7a2vq+S+tZ3bdp23NrpwV2xJVhGoyNjmFZW9ckX25YpsX4xDixWIx8Pk8ymaRWq1EsFteYX1hdgRW+J6vP5fpeWJ3vSV2gCPACuimgAwMD/PIv/zK/9KFfIplM7skxKIqKoun09fVhOy7Vep3FxUVKpdKejB8RcTHoNUXwXYR1XAbwYaBjhfZbPY4bsQW2bVOr1VHM0NZbk+GOoGma267hSSQSpFKprmianp6m1WpRq9WYnJykVqsxNDRENptlaGiI0dEok2YvGRgYYGRkhHQ6zfj4OJ5dp7Awv2fjDyfCi2RDiXPbj/xzhG6BqvOlL32J06dP73g8IQSxeBJXCoIgIJfLsbS0RLVaZXp6umuaEhFxifJvgElgnHBP/db27f/tpZvSlY/nebiux5NPPsV8uyaoXCqga+qGESxVVYnFYhi6RuAH6MraiMlm7LQH1mbi6lJ2CuwFTdUYHxsjkUiE7ojpNM1mk8XCIoEf2i926teCdshp9bk0VwldKeUaE4yNGhEPDQ+hGxeuB98uqqbhBZBM9ZFIJqjW6tRqNaampqJrT8QlS68mF/uAbwPXEIqstwK/DPyrHseN2IJWq0W92UIZDHfadOGhq2q3j8h2GR0dpVqtMjExwfT0dHfhres64+PjJJNJhoaGGB8f3/NjiAjPv+M4uK7LE088xcnFAieefWqNq2MsHic7MLzjsROGQp8ZFiZPjbyOgbe+DikDqo98iT/7zGf41x/5yI5dIOOJJPOB4OzZs6TTaQzDYHZ2llgsxunTpzl69CiK0uueTUTE3tF2s/1LKeVZIcT1wJsJTZgmga9JKXfW+TtiRziOg+sH2I6z0gdLCHRl4wgWhGnUhq7j171us+Fniw41Z/PWEPP1UCRsJ0XQ8zwWC4thzdXAALqhMzY6tmltsZShqNiMIAhe9LYVQohtbaaunpcQgpHhEQrFUOiqmkqxWGRhYZGBgYHzzp21QQTrhaJL3ZFIwn5mqiKwVEHDldx/prXl+e9kPBw5cgQAXRXcPGwQ0xV+OG8zEFcZSW28JFVVDTcAXVXJ5fNMKSpzc3O0Wi1OnDjB0aNHz/tb2up9WX2d6jwmunZF7DW9CqwWcJAw9cIHnmp/93scN2ILWq0WVdtHqBqB56ArAk1VdiywOvVAk5OTHDhwgGaziRCCvr4+FEVh37595PP5i3QUEQD79+/HcRzGx0ep2GeoTD+Plsl2+73MLQYkUv2Yu0hbuXnY5MEZGynBDwI8FMyxa1g+8wSf/bPP8qEPfRBlgwXOZsSTKZq+ysnZEqnSMsdecZharca5c+fYt28fMzMzTExM7HieEREXkY8B/1UI8Q3gz4EvSyntl3hOLxs8z8PzfFrNFkINIxq6JtC08Hq1kUjo7+/HMnSCahOrLbCmKz7TlQsvK5LG1ovkTp8rJOQH8hhGGLl6/onHUDSNYzfewszUac6dneSGW+/A8zyefuxh/GDz156cnKS5tHfZB9vBMGPceOurqJSXOPHME1x17Q2k+tL84JEHyA4McuDIUU4++xSL8zPd5yhC4egNN5PP5dE1ncVCKKwKhQLzC/P0ZfIoAjpZg6vPZcoM36fpqs90NTwXqfbvk6ZCqRXw+PyFTJT6IdZPYWbl308AR/M6XzvRZCih8r7jG9d4hxEsiaVp6LpBMtVHs1nkb7/0ZQYHB3jggQcYHh74D1yrAAAgAElEQVRZ85wnnnyCanVjQ4/x8bGuq+9zzz0PwMTEODfffDMQiq777ruPdDrNTTfddIHjiojYmF4F1sPAjwNvAB6QUjaFEFcDJ3ueWcSmtFotakH41gXNCpqqYGgq8Xh8x2Nls1l0XefcuXPYdvjBl06nGR4ejtwCXwSEEBw+fJjl5WWGh4eZnp7G933GxsYol8u0Zss067VdCaw7xi3uGA9Fd7Hh898eq6JlwovQyZMn+buvfpW3vOUt2x6vL5MjO3aAIJ6k1ixj2zbDw8PMzs52jVL6+vro7+/f8VwjIi4STwPHgJ8EfgKoCiHuBj4bGTBdfFzXxfUDmnaLmB6m31kKW2ZchBt8AlVRmEg4xA71d00UtkJXBNcNbn7NCoKAxcUCQRCEhhaGyejICKqiUK8tI2UYrVpeKiJ9l1q1guvYpGMqE9m+TSNGanmaG/Zlt3E29oYgCHhurkKr2aBSLiEDj0p5CVXV8JwWS4UCB47AUnGRa4ZTWIYemlYtNaiUl+hLZ+nv70fVVObn5xkcGGSxsMhyaZG3XZXl+XMlhgZyXDuwci6P5Q2CYK3ZyMF0uAZ54+EYzxfdzf2TJHz/+99ndna2e9eh469iwY9TdwPqTvjMurt5FDDZ149qmPSls2i6TiqTo7QYUK1UmXcrJBI+k1VJMrFS8zVVBXGusuGEjHb64sLCAi8sVHG8AHNVE+tGo0F5uRI5FUb0RK8C6wPA/9Ue56NCCAN4Dnig14lFbE6z2aQehB8QQbOKoWmYhn7BhsGbkUqluPrqq/dyihE7QFVVbrzxRkzTZGRkhMnJSYIgIJ1OYxWWadSrpHM762G1nmxMwVDBifejmAkCu869376Xq6++etvvvRCCVDpDbiDH/Kmw/urw4TCKtbi4SCKRYHJykmPHjm2rH1tExMVGSnmdEOIG4H8G3kmY1v7zwPuEENPA56SU/+6lnOOVTKcPVqvlkGi3eTDVAF0La602ah3R19eHCiiKIPAcbh4ze3aik4GkUCjgei4D+QEM02BoeAjLitFqNtAUJYzyuy6e56JrCr7r4nkeihAcOXKEo0ePbjh2IpHgzjvv7G2CO+C73/0uJxZquK6D53kYmrJ23r4HgO+5qEqMN77xjUxOTrLw4GPdxvEAyUQSdURldm6WocEhFhYXiNtFDukVjo2OrXlNXRXcNLJxfVo2pnLH+NaZELcO38YnP/HJbhnCKbdO8ua30PLkecYZG2FaMY7eeGv39qGj13HoKJSXytRqNXK5LLF4nLHRse46KP7kE1x/3fVrxpFS8uC9f4/rush2s2I/CKN2nfuEEN3U1khgRfRCrzbtU1LKn5VSvgs4IaV0pJS/IKX81B7NL2IDbNumQbjb4jerWIbWdV+KuDwxDIMjR45gmmZoeuF5VKtVdAWam/Qt2QlCCIbaxheHjr8SgNe89jVc1c6H3wmxeBLbk9RqYXPk4eFhVFXtWrfvxkQjIuJiIaX8oZTyN6SUB4B/DnyC0J59Avi3L+XcrnQcx6HebIWNgY1QYOkEaFtEsGKxGIahoQgB7YVvT0golUo4tkMum8W0TAYHB7tW7L7noSigKgqeF4oqU1XwPA/fddEUcUldW3VdR1XA9308z8Voiyq/PW/fc/F9H4lE11TUdgsXRQHP9daMFYvFwvoz02BocBBd01leXqbV3Lg3Zi9z/vn3/3y32b3XDEsfKw27GxVb7US4XdLpNIZpUCyVcF2Xufk5PM/b9PFChO+lH4TiKhRYQZhG7wfd53qeh+tLXM/H96OKl4jd0atNuxBC/EZ7J9AWQky3b+9B54OIzWi1WjhquEsTNCtYphEJrCuAeDzOoUOHwove2BhCCBrLSzQb9S2LrLdLpzfWNbe/lve973287W1v21ENVgdN11F0g5br02g00DSta9gxPz9PtVplbm7uwgNFRLyItK9LJqEh087/8CN2jG3bNJpNEEroZAoovoOuKZtmXOi6TnxVfZbj7r5BOkC5XKbZbJJOp4nF4+RzeVLJlVofzwtFlKqENVq+62LoaldsqYq4pNLldV1HFWGEzfc8DE1t17qFESyJxHVsVCG6mQShKBP43vli1TRNxsbGMAyTgYE8mqZRKBb23J0vkUhw111hjyzphgLuzMwclfqKmLuQW+R5CMjnciiKQrFQ7IosuUXDR1XX1wisQIJhmvhSdgVWKLwkfhBFsSJ2T6+2Kb8K/CdglDCIPwr8DvBr2x1ACPEpIcSCEOLJVfd9VAgxI4R4vP31L3qc5xWFbdt4Wrj7FjQqJGMWpmlGaVlXAP39/UxMTJBKpRgbG0MGPq16FbvV+8Wu0xur2BJcf8P1F3j01sQTKWxfUq2GvbsSiQT5fJ5yuUylUuHcuXPU63vXODkiYrcIIV4phPgDYAb4e8IUwQxwCvg/X8q5Xem0Wi0aTRthtFuIeA7IAEWITSNYmqYRj8dQRLiocOzdC6xqtUqtViOZSpJMJUmnQ4vy1fiejyrCmq9u2p2q4LdFi3oJRrA0VXRFlaGuTWdUhcBuNVHFyrw7Amuz6I6hG4yNj2FaFun+0CG2WCzSbOytyWYun+MXfuEXUIJ2GqPQ+O7D3+v+fju1dutRVJVcLofneyyVlmi1WhQKhU0fr2kavpQ0m018P0BRVbRVogvaDbIDib8XEdSIly29Cqy7gEXgbcDR9vcC8Is7GOO/A2/c4P7fl1Ieb399rcd5XlHYtk1ghMWcfnOZRNwKP3QvoYtAxO4ZHBxkcHCQXC7H0NAQbqtOcbH3Zr4jbYE1Vzs/5UEGkqnJqW2PFUskabkBtVXpi/l8nlgsxuzsLLZtc+rUqSi9IuIlRQhxkrAm+MPAMFACPgn8iJTyiJTyP76U87vSsW2bZstGGKEBk/AdpJSoCluaMiWTSRQhUFRlwzqt7dBsNFguLxOLxUin0ySTSfK5811xPddBbUewnFYLRQFNEXheGCFSVkWCLgVWxJK7UoPlufiu2z4Ogd1soqnnR7C8DSJY3XG10K5eN/SwTs0wKBZLNOp7K7L27d/HT731zQAI3aLSXHEVvFBD6c0wTZN0f9jbq1KpsLy8vOm8NS0UU41GA19KNE1HVbXzBFYgowhWRG/sRR+sz0spv9y+/bwQ4ieBd293ACnlPwkhDvQ4j5cVzWYTJRHuwvmNZZKJsEFiJLCuHMbHx7Ftm/3793NyZpHpM5OYhkluaBghBLXKMp7roCgqqXRmWz1R0paCqULNlXzye5Vu3XggJdVqBcfxuHF5hp+8cWzLcQBiiQTLc2H6zcLCivjTdZ3Z2VlqtRrj4+NUq1X2799POp0mkUjs9nREROyWg4TtRL5CaNP+dSnl5kUaEXtKq9Wi2bJROumBgYcMAhTY0pQpmUyGqXm6TrNlh1EmbftZnbZtUyyVMEyDXC5HzIoxNDi44WN930dVFfAlrVYTTVG60R7Pc9HMS0tgaVpYn+a3a8QMLYbn2WHtmCLQFEGr1URR1gkssXGK4Pqx8/k8pmkykA8t3EulEgDxxM5dijfjhmNH+dZDywjD6qaOwu4FFkAylcR2bCqVCoZuUC6HTrfrm0erqroisAKJqmlomoYnnTUCyw8kQRBFsCJ2T68r8rPAm4QQrwaeJYxivRGY7nViwK8IId4DPAr8upRyaf0DhBB3EUbRGBoa4t57793VC9VqtV0/96XgscceI569Dge47fprKC7M88wzz7SLg43L7ng240o5DtjdsQRBwMzMDK1amcXyOWZOvcDEVceIJ1PMnnoOQwlwA4XM6D76MrltjTmkJznjW5Rb6yxxjRSaAU8u2Yw/9jipVHLD5zu2w4kTJ/B9j6mzMyzNTvHQY0+seYxtO1SrVWLxGIl4nL7+fsbyaW699dZtCcEXk5f739ilSOc49siZ7f3A3VLK6l4MFrF9fN/H9TwSySQHrrqaKmCoEq2durZVXZNlWcQsE93QaLZsms0myU0+k9bjui6FQgFN1cjnchiGwfDIMEJsnLDjeS6qAFSBY4cRLEUB327XYAntkhJYhmGgKQLbc/H9Tjpj6CIYVwSKEh7HxjVYF95bUFWVsfExzs2cI5/PXxSRZahh+qeiGajWyvu64xqsdWQzWRbcBUqlEp7vMTc3y/jEBKqyIs413cC3a2GKYCDRNCNMEXTWpQj6Ej+QW5pmRERsRa8C688IbdrX9xP5rR7H/QTw24Bsf/8vhHnza5BS/gnwJwC33nqr3O0FeQ8v5i8KU1Nn8J4Jd31Gc32MWRa33XYbr3vd61AU5bI7ns24Uo4Ddn8sr371q/n617/O3NwcP3j2JJ4iGMhmSAZjDKcMlhoeXiLL+MHtuQEelpJyK1hTAlypVPn0pz+Fccs7UON93Pfw43z4/T+34Y7xiRMnONJ2Hsxn0tSryxu+TrVSpdEIC8vdVoOxfePcfvvtl1wUK/obu/TYy+OQUn56TwaK2DGu6+K4PhMT++hL7OPeRcikEmg1BU3bWrTouk4iHkcQRlW2K7AC36dQKCCEYGBgAMMwGRkdWbPAXk9YZ6UgpKTWbLYNL1bS7hRFv6QElqZpKIrAbrUQAlRFtI0tHBSjHcFqNjFWRbA0TetG5TpW5FuhKiqjY6MXTWQJIbA0QdOTDO47RLmdBdraRQ3WmnEVQS6fY35+nkqlguO4zM3NMTo6imjnbKiait8MI1ielOG50TSCFuelCHqB3HWKakRErwLr9wiLhT8EJIAG8Mft+3eNlLLbFl0I8d+Av+tlvCuNctMhQEEXAXg2hq4Ri8VQlF5L6iIuNQzD4A1veAOPPvoo84UlXihUmZ2dYdCCgYEBGjNzVOrbt3EXQpCJrV1sZGNpfu4db+EvHptFjfcxXw/40pe+xE+9/ae2HCs3OExucHjD38lAsrCwgO/72FXBmZk5SqXSJSewIiIiLg6dHliKqnbNC3R8VEUJIypbOJhqmkYyHqPl+cRiMaq1KoHvb+l6Gvg+CwuL3UbCuq4zMjKCrm0tjnzPw1CAIKxdiikCVYRW3b7vXbI27XY7nRFYMbawwkhVvdUktiq1UbSjWaoSHq+2DcG4mcgSAmJb1M9tF7MtsOreyrqllxTBDpqmkcvmmJqaYqm8hFAExWKxW3+naTp2J0XQl6iGhqbpeDJYmyIoZSiyoghWxC7ptQ+WJ6X8t1LKFDAkpUy2b/eUtCqEGFl1818CT2722JcbUkqWmmF6V0yVeK6Lrm5ueRtx+ROPx7nuuuvoS1iYhk5laYlmZZnh4WFMTeA0GwQ9mkkcOXKEw4OhdbGeHeX+++/n4Yce3vV4QhFkc1kCGdByPKpNh6effrqnOUZERFw+hGlWAUJRcIIweqARoGvKeXUx69F1HV3T0DSVWDwGEpqtzXszBUHAYqGA53vkc3kMM0wLvNDrAHhuGMFSFXBsu20UoeA6DkJ0IkaXzuZlKJQUHNumMy1VETi2jaYIFCG6x7E68tZ53lZGF+vpiCzLssjn892eU3vhLmip4d+EuypbvdNf8U//9E9ZXFzc/dgxi2QiQaPeoFatUS6XqdbCLGFV0whkWB8YBLRrsPQ1joErNu0yqsGK2DW72pYRQrxlk/u7P68yvrjQWJ8H7gTy7X5a/xG4UwhxnDBFcBL4wG7meSXi+z5nCxVgDMVr0mzWsczsppa3EVcG2WyWAwcOcGb5hbBXi1Oj1WqRTCTQl5dpNuskkn09vcY/u/4qvvhMHS0zCsBf3f1XDA8P///svXmQZFd97/k5d8t9qazMWnvvloRWEIhF4zESwmBjsz8eBmNke8BCYsD4PU+M/d4L4sWbFxMxMZ6JMWZHkoVZ/DD2w1iAMWDGQgMISYB2qffqpSqrKvfK9Wbe5cwfNzOrqrurqyqrWtVddT8RGVV9s+7JX2Zn5j3f8/ud7489e/cMNJ6u6wwNDdGoLlAq5pmZmaFQKJBOn+/k5ePjs72wLIuO7aAoCh2nJ7AcNGX1BcGeFXnA0NENA13XqVarXnPgc6rbXMchXyhgWRbp4XS/kXA4tLYsi23bqEHorTerqmdyIRTQutm2ywnPsML7Xe3OuTRF0AaUrskFcEGBpXQzWOuhJ7JmpmfIpDPkC3mKpRLDQmxoYTeonV+mWKk3+cRXP0exUGR+fp6PfexjRKNr23t3LuFIhFAoRGWhgm7o5HN5DN3ough6qs6WLrqmo2oajrOYwfKylxLb8QWWz+AMuizzTeAfLnL7xloHklK+V0o5LqXUpZS7pJT3SynfL6W8UUp5k5TyrVLK2QHj3HaYpsnRs14F5eyp4xw7cthvMrxD2L9/P8OJGMlYhHR6uF8TH9SgVV97meBKjMW88htjaBwQOLbDAw/8FdVqdeAxI5EIQ8NpyrUGhUKBM2fObHoDSx+f1RBC3CyE+H0hxJ8JIT4ghNi/1TFtd6xub6bHHv85U9Mz3YMtNE1dtXFvz5QhGAyiKAqJRALHdvpZiKWPkcvl++IqGAoyMjKyrJHwaji21e2D5f1bWSJeFIXLU2B1U1c9MaUoi0JLXfL7uQKrZz+/XnoiKxAIeJmsbp8ss7VyVnE1AhcQWM2OS3XBu94UC0Xuv/9+rM7gAmcoNYSmaotNiOdmEYqC43qliK70SgZ71u3LGg1LiSN9m3afwRlUYJ1ZcqvjrSktPXZ2U6LzOY9Wq0Vdehcnt1UloKuEQqHL7iLgs/kkk0kmR9MkIyH27dtHOBym2WwiXJtWc+NNfcO6QjwgQNWJjOwCYGGhygMPPLChOvRMZgQjGCY7l2NhYcHvj+XzoiGEGBJCfAfPjfZ+PFOmLwDHhBCf2NLgtjmWZWE5Li+88AL5sjdplpa5ppJ2XddRhEA6LqmhFMFQkEAwQLVapdVq4ToOtVqNXC6H67pk0pm+uIrH1pfJt227XxYIoInFfU3qZdYDCzyXP11TEcpyYaUoXhVRT2Cd27+rZ9U+6He5pmrLRJau6xSKBdpme/WTL8CFMlhqIMT73/9+esVQp0+d5itf/Qqu6573t2tBURSG08NIJIVigU7HolgqLWawHNcrEdS95sM9Q4u+wPJt2n02wEACS0q5T0q5X0q5H3jAO+T9e8lxn0tAq9XCFF5dudOsEgoYfgZrh5BMJgkbKrvGR8hkMuzatYtEIkGjUqS2UKFttmibLSxrcNejsaj3Ptp7x/uIv+odxF/1Dpq7b+XbR2pU24Nd5IQiGBkfp+3CsWPHaLVanD699qbGPj4b4C+ANwEVoDdT+hFg47UC+ZOtCmy745lcOLRMs98HK6BKVFVZtaR9abYlkUyg6zqpoRSa5mUjstlZFioLGIbB6OgooVCI0dHRdYsr6Nm0i37ZXW9fk6aK87JAlwuapnWzbl0xqCwXVr1jS+cFfav2DQgGTdWYnJgkYBhk0ml0TSdfyNNur19kBdTzBZZpS2648Qbe/vZ39I898/QzPPjgmnacXBBd1xlODWN1LMqVMpZlUyp77reu2200rOnY3QyWbdvYjot08RsN+2yIzdi5uXHbF581Y5omHcW7OLmtmi+wdhCxWIxwQCceMnjpS19KIBDg6quvRlcE5fwcx5/5OVPP/ZKjTz5ObeG8tnFrYnfcex8VbIPgnhsJ7rkRMXo1hyuCx7ODrVQCxBNJQtEExWKRfD5PuVxe1qDYx+cS8WbgB0AauAWv2uJ+4GXAAt0+ij6bj2VZNFttbNvpN5MNqqJf+ncxemLAtm0EgrHRMYLBAKMjoySHkiSSCUZGvYWmYCjI5OTkusoCe7iui3Td7r6r3h6sxbI75TIVWL1s1GJZo+jvx1paIri0FNNzblQ2XD2gaRoTk5MYRoBMJo2mahQKhXWX8i3NYGnd59Hrg/Wrr/1Vbrv9tv79D//oYX70o3O7Aa3jsUJB4ok4zUaTZqtFtV6nWq3iSImme42Ge02FPYMLbzHRz2D5bAR/Vn6FYZomjuplsNx2g3Ao7DUe9AXWtkdRFK655hoajQbpdJpwOMzRo0d52cteyvPPP09AbZNKpcjX29QWysQSQ+t+jJePGSQCCpbTq1GXlE2Xn063mavb7B1wT3MoEmVBD6JpUCwWCYfDTE9PE4lEfOt2n0uJChSklFII0Wv/ca2U8qtCiAeB92xhbNsay7Ko1r0dBL0Mli4c1DWYI/QEltv2ytkCgQC7du+mWCiiqApIb6KfSCaIx2IrNhFeDadbHqjrOsK2PWMLIQgEAqii0beUv9zwxJJAE54jo6qYqIoXd9vyBJRyoQyWYKA9WOc9vqZ7xhczM2QyGXL5HPl8nkwmg26s7fVaKrASAYViy13WB+utb3kr5VKZp59+GoAH//EfGRoa4qabbhoo5ng8jtWxqDcamGaHfD5PS0+iajqqqmF3s1VeeSDohoFjd3yB5TMwg7oILjWxuPECx6SU8t9sJDCfC9NqtXC1IAqewIqGhgkEAr7A2iFcddVV/d8jkQj79u3DdV0mJibIZrNIKam28lQGNL1QFcHVw8svkI2OJ7Dm6w4yiJezvnifyvMIhaO0HYmuGwQCAWZmZti/fz8nT57k2muv9d+/PpeKJ4DfFkKMAXvx3r1T3ft0oLbSiT4bo9VqUW80EUIgjK7AwkERXuuJi9ETWEsnt6qiMjIywggjmxZjrzzQMAxv/1J3D1M4HEZVyqiXockFLL4+ikI31mo/7nrTMxE6d/+Y12x4fTbtF8PQDSYnJpmemfZEVi5HvtAVWWt4zQIXEli27DdCForgfe97H9ValVNTp5ASvvqVrxL/cJx9+/YNFHMqlcK2bar1Gu2OQb5aBLrW7d1sVafTwXFdgsEQ9Vpnzc2ZfXzOZdASwbcvuR3Em269/ZybzyXANE2k7q3+ue0GsWgIo2tj67PzGBoaYnJykkQiQSaTwXEcOs0qrWYDKTenejdiKMQNQceFZ09O88lPfXLd5SCarqMZAdq2y9CQl1mbmZnBNE1Onjy5abH6+JzDfwRawOuAA8Ax4KtCCB14BfDQ1oW2vWm32zSaLRCiXyKoutaaMlieGADHubRNXh3b9jJBmrak7K4nsLwM0eV4be3Hqnqx9twDQ6FQ3/BC15f371raaHizMAxPZBmGQSaTAQmFQgHHXr0MMbhkD1bEUFCF5+pnL9nqqxs6H/jAB0hnvNYelmXxL//yLwPHKxTBcHoYVdXI54t0Oha5QgGQaJqG40parRaO612zFFXFth2/2bDPQAy6bPxfNjUKnzXTarUQhrf655oN4pGIXyK4wxkbG+tvMu50Ohw+fBhbKrRbLYKrrBSv+TGiGtWSxePPT2GemeJrf/s13v+7719XJisUjtK2KrTbbSYnJzl79ixzc3MoikI2m2VycnJTYvXx6SGlfEQIcROe0YUJ/J2Usuct/ZKti2z7Y5omzWYLhIqiB0BKVBwUoa6awTIMA1UoOJuUbVkJ27YWSwS7gkUViwLrcrRph8UMltYVq0rX8KJXzaKr5wvDfqPhTS55CwQCTIyPk83O9ssFc/kcoyMjKKq64nlLSwQDqiCoCRqWxLQl+lLxFYlw11138YlPfIIDBw7wu+/73Q3Fq2kayaEUnWqWaqeObdvM53KoumfV3mw2cVzPXVBVPXdB27Yvy/eBz+XNQLNyKaUvsLaIYrmCYsSQ0kVxO4SDhi+wfNizZw/tdpvx8XFSqRRzZ/MsVEqbKLBUjpYsrwnxmWd44pdPMDE+wet/7fVrHiMUiWLmS9TrdcbGxkin0xQKhf5qdiQSIZlMbkq8Pj49pJRTwGe2Oo6dhmmaNFqtfnmg4lqIrotgIBC46LmKoqBpKhKJ4zioF5mobwTbtlEEiwJLEWiaSjAY9Jz51MvY5EJZnm3rlTPquo6hrSSwwO5sfjYmGAwxNj7G7OzsYrlgvkAmk15RZC0tEQxqiwKr7UjOtStJp9P88cf+mKHU0LKs3MDxhkIYJMgXWlQXqgghaLZaOIloV2B1qy66osuyrA01VfbZmWyGi6DPi8j0vFczLDsmhqb2V6wu1QXI58pACMHBgwcJhUIcOHCAkK4wOz29aRt0x6Le+ys+ebB/7Dvf+U5/A/JaCEUitB2od/eHZTIZotEo8/PztFotpqamMM3BG1f6+KwHIcQDQgi/9ucS0W63aZptlG7FhYqDdF0CmrqmBcFeGdylzGJ5TYaVRWGiKmia5i1adjNEl+Pi5bkCS1tSzth7HhcUWJfw9QyHwoyNjhEIBMikM1i2Rb5QWLGH1bIMlib6gsu0L1wuPpwe3hRxBV4vsUAwTCQapVar0Wg0aDabVGv1xQyW2s1gdQWWj8968QXWFUbV7M4H7DaRUJBgMHhZrrD5vPioqsqhQ4cYHh5mPJOibTYpFAq4m9DUtyewZHiY3a/5TUKHXkVw38189WtfZ3p6ek1jhCMx2o6kVqv1L7rj4+Nomsb09DSdTocTJ074TYh9Xkw2Zee6EEIVQjwhhPj2Zox3pSOlxDRNWqbZz2BpuCAletcWezWWWrVfKmzLRutmqTRN62d+eo2Oe+WDlxt9k4tuOaPSLWfs7SUzNOW81/jFeD0jkQgjIyMEggHSw2ksy6JQKCDd80XT0j5YQU3092StJLAuxMMPP8y3HvzWuuNUNQ3LhUQySSAQoFwu4zgO87k8pVIJR4Kmee8JW/oCy2cwLr+lGZ8VkVJiRJNQgaFoiJe+7jZCodBleQHw2RoCgQA333wzTzz5FLpmc/TpX3BS10jEk/RMkIQQjE7uYXh0fM3jhnWFZFChYro4u24htss7Xn8mzP333ce/+3f/nnji4k0+VU1DM4K0bZtHHnmk78rU6XQolUoATExM8LWvfY03vvGN3qZpH58NIIR4sdT6x4AXgPV3ut2G2LZNx7LZv/8AMS3DPBDUQFO88ru1OLL1mw1fwsmt49jLRFSgK7A8k43LW2BpikBTlb6xRa+cUdf1/vM49xxViE1zEVyJWDSGlJJcLsdwKkWxVKJQLJBJZ5YtZ+iq19zZkZ7hRUipl+kAACAASURBVC+j1V6DwHJdlwcffJCHf/QwAMlkkl997a+uOUZV1bBciWpoDA+nmM/lqNUbRIIuU1NTEB0mrmleiWDHF1g+g+ELrCsIx3FYaHkfdB0HVeALLJ/zSCaT3HjD9bjPPEMzIimVSoQsl+H0MAAdGwr5uXUJLIDfuirMoyfyJBIJ8lWTMw0FfXgXC0d+wn3338dHP/LRVXugJIfTnJ2dRrB8FTWqh8jlclQqFar1Jk888QRvfOMb1/fEfXzOZ7WZ/IbtK4UQu4DfAv534N9vdLztgG3bWLbN8N5rsQOTzNchbGho7upNhnvouo6iiEvqJOjY9jI78545RK9EUBGXr8DqxertV9PQFacvsC5kcqFpmrevzXVxXXfTyu0uRDwWx3VcChQYkpJyqUyxWGR4eHjZJ7K372ppieDUgrXqh1JKl6wdJbjnRgC++8vj1ELj7Nm7p/83860AZq4DQDqsMBZdnO6qmkbTgYCqoagq6XSa+enT5EtFEiGNUi7PyIHrPft202827DMYGxJYQoibgZcCY0Ae+H+7G4p9LgHVapVax/vq0YXrCyyfFXnDG97Addddx/T0NMVikVwuRyqVIp1O87NHH6VTb+I6zkVdns5ld1yjHWtw6MA45VaAz/+y5pleANNnp/mbv/kb7rzzToSy8px2bNdeMuOTy6a1+bksneI0mqYxNzdHw1GYmZmhXC73Ld19fAakDDwO/OkF7vvfgDdvwmP8BfC/wnl783ckx44d4/Tp0zQtl59Ye3EsbyJvCBdNVdclsDRFcOLwc+v6nloPttVhVyLQv4YaSzJYSjdDdDnuwVpazgh0ywKti5pc9M5TFcGTj/1kxbGnpk5i1Ssbii+eGOLQtTfgSq8UXLqSSqVCqVwilUr1/y6sewIrrAvCunfdeDZn8WxuDYJm/Bbi47f0//l0B54+1lzyBzGoev/WFPjoKxN9EaeqKpYrCWve+0rXdVKpNLnyLKVSCdNIUCqXCRo6jnQ5evSol9naAEII9u/fz/79+zc0js+Vw6CNhoeArwC/cc5dUgjxaSnlxzYcmc95FItF6rZ3sVKl1W8yeDleAHy2nsnJSVzXRdM0pJSUy2VCoRDRSARjYYFWs0EkNlhFUzKoEFChHYqhBKO4Zp2nn3ma02dOr9oEUlWXv18jsRi1nGfN7DgO86UGuzM1Tp06RTAY9N2bfDbCo8BBKeVT594hhCizwT1YQog3Azkp5S+EELdf5O/uAu4CGB0d5aGHHhro8er1+sDnvlg8/vjjnCq1ma40cRJ7UHAZEzUS1bNka1mOhtz+c7jY88lms5Snp7jA9p1NZbqk8FQ8hOM4HHnheVqNOrVajakTx9F1nR/96EcXPX8r/k9s2+b40SMkEglUVeXEiRNUq1USsSilUoljx46B6zA3N7fsvJMnT2KVynQu8pom3TatmSMbiu/4EZd620LVNKoLVWr1Gs1mkzNnzxAKhYjFvLWIawydEUWjPFMg4SocCIWw5do/ko7jcObMWayOl6kSisLu3bsJBgO4jouiKmTbBrar8PzxKWKaJ/ia9Sqz2VnaUsV0vMdr1qrMLzQ5NZvHCJVxwil0RWEhN8MvL7JouFY0BQ6kn+Lmm29e97lXwud+PWyX59N7HrfffvsF7x90Zv4XeH1FykAE0IEfAf8D8BEhxBkp5f894Ng+K1AqlTg1V4TEGPVyAVu2CAQCfgbLZ0V27dpFp3vxsW2b+fl5FEUhoEGrUR9YYAkhGItqnF6ween/+Gu88OPv8v4771xVXF2InvlFtVolEovjlC2y2SydTofjx49z7bXX+osIPoPyQSC9wn1/AvznDY7/K8BbhRC/CQSBuBDiK1LKZc16pJRfAL4AcMstt8iVLsircbGL+eVCo9GgfaZE6rpxnnquTVyX/PqeIPVqGtFQePWrX9l/Dqs9H9M0L7npjWEY/Wvom970pv53zW233QawaindVv2fvO51r0NRFIQQ3Hbbbbiu23cTtm37gt+Zt912G81m87zjS3n44Yd57WtfO3BcP/3pT/nlyRwvueYagiHPQTKXz1GtVlmoLFCr1YjGoiSTSQ6dc+5NAzxe+VCYv/zLT7CwUAXAeT7KH/3RH1GpVDh06BAPPFljvuEwNrmH8djia3L9jTedt9h37Q03UC6VMFttUsPDXpyvfBWRDbY7sS2Lw089zvUHRgZ6r1wJn/v1sF2ez2rPY9BZy5uBH+BlsK4HngbuBz4M/BRvpc4XWJtMsVhktliFBJw5cZRDw9V+SYCPz4XolSUcPXqUiYkJzpw5Q6FQQHFtWo36hsYei6qcXrDZc/0t/Oarr+/v8VovnvlFAMt1sKRCJBan0y5y6tQpDhw4wIkTJ7j66qvXtDHex2cpUsoskF3hviJQ3OD4/wH4DwDdDNb/cq642kk4joNlO4CgXGsCKrVykR+ffYaX3XA9qsKaSwRhfX+7GSwVJZdyj9JmsLQ1i9ckefHfKy1ICSGIRCIXHTcUCq36NxfDMAwUxdvf1iOTyfSdBKWU1Gt1FEUhHt+4J8xQaoi7PvQhPvXJT9FqtajX6nz+c5/nLW/xqn975hmmszxtd664AtB1g5GRMYrFIpWFCpqmsSAEoXCYSHjw18RxHBzfjXDHMeg3iAoUpJQSmO8eu1ZKeRh4ENi7GcH5LCKlV8NsKQYAbrtBPBbxM1g+q6IoCocOHSIUCrFr1y7i8Tj1SpFadWFD4/as23NNd2Bx1SMUidK2JaYt0TSVZGqYWq3G7Ows9XqdM2fObGh8Hx8AIcTHhRAntjqO7YplWTiui1CUrsCCZrXM1MkppHRRxNpNLnyuTPruj0vcCgWCkdERr5n8UJJwJOyVDtZqm/KY4+PjfPCDH+zPhYrFIt/69rcxW+a63Am7wZJKpdB1nUKxQKfdYX5unna7PXB8qqoiENi2s2JfMJ/tx6AC6wngt4UQPwQewduy3tsBqAOb86nx6dNsNqk1mkjNuzjJdoNkLOa5HfnlUz6roGkaV111FcFgkGuuuQZdERRy81idwS8a412BNVt3mKnay25HshU++5VvUCqvTcSFIzFM26XdXWXUAkESiQTVapVCoUChUGB+fn6VUXx8ViUF7LsUA0spH5JSboZpxhWLZVm4EhRFpdb0vltcy/T2UUqJ0jVm8tm+LNrBL3d/FAjGxsYIh8OkhlKEQiEWKgv9xvMbZf+B/dz5e3f2M4+VSoXsbLbfb2s9/bWEIsik06iqSr6Qx7IsZmdnN9RDTFE1HOn6WawdxKAC6z8CLeB1wAHgGPBVIYQOvAJ4aFOi8+lTqVSo1Jqgexcnt9MkmUygKBd2C/LxOZdAIMChQ4cIh8Ps378PVdo8+fjPOPHCM0wdeY56dX3OUYmAQlATNC3Jl5+pL7v9wxQs7L+De398ira5uogLRSK0HW+VMRyNYbuSaDRKtVrlkUce4bHHHuPw4cNUKhWOHj3KzMzMYC+Cj4/PJcPLYEkURaHe9iajsmMSDoeQ0kVXVQzD2OIofS4lvYbGzgWEhEAwPjZGKBRieHiYYChIpVyh0WhsymNff/31vPvd7yYcCfO2t76NAwcOLJYIrkNgAZ59+3AaKSWFQoGO1WF2dnbgDJSm6Tiub/m+kxgo9SGlfEQIcROe0YUJ/J2U0uze/ZLNCs5nkVqtRr68gDC83kWaYxIOh1FV9bKvFfe5fIhEIv19TQdLC+SLJexCjVgyxfy0Q/S65JrHEkJw294gz+Y6y/qWtFotcrkcemoXTmyML/71l/jDD/5PF7VaDkWiWKjoIYNQJIZda1KpVKg1Tc5W2mRLJwgEAiiKwnR2lmQ8xsTEhL8vy2e9nAAe3uogtiu2beO4EoSg2bHBAGmZhGJhkBLdUP0FwW2OruuoqrKiOYkQCuPj42Rns6SH0+QLecqlMkp3r9NGedWrX8UNN9xAdtbbetkvEXTWb0epG3o/xmKhSCaTYXZu1rv2rNOAVNM1HNfPYO0kBq4t6/a7+swmxuJzEdrtNuWFGopxAADDtfz9Vz4DkUgkuO222xgaGmJhYYFsNstMdpaWLpBSrku03DwW4OaxwDlHY/zsZyf5YbWCGklyfCbP3/393/Pb7/7tFU2xVVXjqhtehhAKpfw8bddzzWw7kshQhkphnqmpKYaHhzlxJsvBvbtoNBpEo9HBXwifHYeU8lPAp7Y6ju3KYgZLxbRcMLwSwXA4jJQSQ9P8a9Y2xysRZNkerHNRlK7ImlkUWcVSibRQCIY2vkcvHFkUar3eV3XTAtZfnhoIBkgNpSiVShRLRYbFMPPz84yNjq1rHFXTcVzTF1g7iE1PfQghHhBCXLrW6zsU0zSpVGsoAe+LI6A4/v4rn4HJZDJcf/317N27l6uvvhrpOrTqVdqt1qaM/5rXvIaU4a1g6kPjPPqzR/n+D75/0XN0I4Cm6+iGge1KOp0ObVuSGhknHE/SaLY4cuQIDbPD6eksxeKGDOB8dhBCiHcLIb4shPhe9+e/3eqYtiOWZWG7EhD9kizZMT1XOinRdT+Dtd3RNA1VKBcVWACqojIxOUEgECCdTmMYBoViAbNlXvS89RLs7sF68tkX+OEPfzjQGOFImHgiTqvZolKpUK/XKRQK6xpD0zQc13cS3Elcqtoyv25nk2k0GtSaJkIzkK5DQBN+BstnQ4yNjTEyMsLw8DDj4+M47Sa5+dlNG/9lBycB0IYmAPjn7/4zjz362KrnabpOr5rDtCWRWIxINE58aJh8Ps98aYFqs81zzz2HZ2Tq43NhhMffA/8N+B3gDd2fXxNC/N2WBrcN8UwuJEJR6LjeNMC1TKLRKNJ1Mfy2Itser0RwuU37SpwrsnrOfWvZt7tW2k3Pc81G5Tvf/g4//vGPBxonHo8TjUap17xG1JWFCuVKec3na5ruW7XvMAYSWEIIZ6UbcOcmx+iD5yJYbXuTSbfTIhwMEAwG/YuVz4bYvXs3Q0ND7Nmzh3gkRCGX2zRXp56Ne2ziQP/Y3379b3n2mWcvep6uB7qr4F7dfCgcJRSJIFWdeDxOw+xQqHgW7r59u88q3A28E2/R7zHg692fAninEOKuLYxt29ErEUSA3Z1eSMskFo3huo5fIrgD0HUdRRHYaxQSmqoxOTFJwDDIpNPomk6+kN+QLfpSUjGvf5Wie6WH3/jv3+Dxxx8faKxkMtl3P2w2mhSLxTVbzat+BmvHMWgGS6xy89lEXNel2WzS6u4ZlV2BtbQDvY/PoOzfv5+JiQlGU0mkY1MpV2g1mxsetyewRCzD+KSXzZKu5Etf/hLHjx9f8TyvRBA6jkTrlg2GIjHajsQIRojFk1QbLbLZLPl8ntnZzcu6+Ww73gu4wJullLdKKd8jpbwVeGv3/vdtXWjbD8uysB2JlAJXeNcm2TGJJ+I4jk3A8DNY2x1d19EuYNN+MTRNY2JyEsMIkMmk0VSNfD5Pp9PZcDzRkPd+M8KL+3W/9rWv8dSTT61/sG6PrEAgQKlcwmyZ5PK5Nbkgei6CckNW7z5XFoMKrDLwfeDmC9y+tTmh+fRot9u02hbJUa/USsMhlUqi+auBPpuAEIKXvexlJKMhDM2zUS6WShuuhQ/pComAgu3Cu+78Q9KZDCCwLYef/PSnK56nahoSQcv2slcA4UgU05a0HcnI+DiReIJ8qczs7CzZrL8fy2dFXgL8UEr5T0sPSim/DfwQ3/V2U7EsC0e6NJoNhOFlDHTFxTAMpHQIGDrqRdxEfa58+jbtq+zBOu88TWdicgLDCDAykvF6UG2CyOr1wQrFkkxMenMo6Uq+8pWv8MILL6x7PKEIhtPDi+WM7TZz83O0Vtm/7LkIyk0RjT5XBoMKrEeB/VLKp8694YkvP4u1iZimSduymdx3FQDD8QgH9+33Vop8kwufTSAQCHDVVYcIBVQ6zSqVwjyHn3uKMyePMTd9un8r5ebotNcuvHrNiP/2mIty2z2MvOvjjLzr4xSueitnF1ZeydMNg0bHJRTxBFYgFMZ2BS3bJRSOMjIyjtCDPPnkk5w4cYLTp09TLpc5ffp0vwRjbm6OarW6gVfFZxsQA46ucN8RIP4ixrLt6TUaNowgRjgGwKte8TIUBArCbzK8A+gJrEEyNYZuMDE5gW4YjI6MoCgK+XweqzN4Wd2iTTvc/aG7GRnJAOA4Dl984IucOH5i3WMqitJvRFzIF+h0OszOzV60rFFVNT+DtcMYVGB9EFjJhelPgP0DjutzAXoCq4m3Ihhw22iagqZpftNGn00jnU5z3f5JtFaZOCZU5ymcfA4zdxqnnMUpZzGLM8yeObXmMa/LGOjK+fXDlgtHiiuv5AWCIZq2JBLz5r+KohCKRKl1JOFYjHA8hhpOkC03+cnPHmV+fp6HH36YRx59lOPHj9NoNPjZzx7l5z//+cCvh8+2IAD8hhDiG+fe8Po4+l+gm4hlWXQsGyMYwEEBJC+/8UYkLqoiCAY3bsHtc3nj2bSLVV0EV8LQDSYnJtENg5GMJ7Jy+dzAIktTQBXgSAhGItx9zz2khlOA93697777mJqaWve4iqqSyWRA0BeB2dksHevC1zXPvMnfg7WTGLTRcBbIrnBfEfDrdTYR0zQxOzZlx5sLRNwahq76AstnU7nuuuuIx+OYLzU5efIkpmkyMzODlJKJiQlUVSV3dopmfW2begGuHtb5k1uXNy8+Wbb4+vMN5uqLjSgty1pW7jq57yCtZqMvsAB2HbgKs9kgEo0TCnkblzFytPJnOXLkCLFYjOnCAiPpNLFYjKppI6nRbrcJBM7t1eWzgzjYvV0I34ZyE7FtG8t20IQGdDAUEAKQEk1V/evVDkDTNDRNRbouruuiKOtfxzcMg4nxCbKzWUYyI+TyOXL5HCOZEXRjfdsihBAENEHTkpi2JJlMcs/d9/DJT36SarVKu93m3i98gY/98R8zOjq6rrE1TSOTzvTjGx0ZITuTZXLXJLq2PM5eBssXWDuHTakvE0J8HPh9KeVKFzGfDdBut+nYNiXL+8BG7Bp61LtY+fXsPptFMBjk0KFDABw8eJAjR46we/duTp8+DcDk5CSGpuDaHSyrg64PNlnqmV/MNxxcV/L9732PFw6/wD1339NvMmkEghiB5avdgWCIQNArMVJUlczYJIqiUu7UaDab5PN56mqcF154gWQySdNyUBXBwsICIyMjA8Xqc8XzX7Y6gJ1Ep9PBsh2k9D7juvD0qwAMze+BtVPQNA1FeFbtyoCiOhAIMDE+wUx2ZsMiK6guCqyoAcPpYe758D18+tOfpl6rc93115NJpweKUzd0MpkMuVyOfL5AJpMmm80yOTG5bAuHpuk4ji+wdhKbtYEnBezbpLF8zsE0Tc7Ol6mxD1yH+ZPP8fJXvYRwOLzquT4+gxAKhbjqqqs4evQoe/bs4fTp05w9exbDMBCaoFWvow+lBho73DW/WGi7fP1b3+exh7wGxPfeey93feiudWWbwpEoBTSCQZVcoUi+4zIWVXn88cepiwiaIqhUKr7A2qFIKX2B9SJi2zYdy8aVXtbCULrNhqXrW7TvIHRdR1O8ZsP6BrKWgUCAyYnJDYusQG8flr2YsB4dHeXD93yYRx55hLe9/W0DZdp6GIZBJp0hX8iTLxTIZDJks1kmJifQVG+areqaXyK4w7hUjYZ9NhHTNDndNQSwKnOcnjqJrqr+hmGfS0okEuHQoUOEQiH27NmD4zg0m0104dJqbqxXVi+LZaR39Y9NTU1x3733ravWPhAKY7lenVc8OYztOMzmijQaDabnctRNi4WFhQ3F6nPlIoR462q3rY5xu2DbNrbtIJF865++B0A5P0c26+0m0HU/g7VT8Hphra3Z8Gr0RJZu6Mv2ZK3Hja9ndGE6yyuCx8bHeMc737EhcdWPMxggPZzGsiwKBc9dcDY7i+N6pfB+o+Gdx2YJrBPAw4OcKIT4KyFETgjx7JJjKSHED4QQx7o/hzYpzisS0zQpOF65lFXKEgp5TYb9DcM+l5pYLMbBgwf7IsswDOqVEo0NuvP1BFZ0fD9ve/vb+sdPnDjB/fffv2aRpSgKgXCEtgNSM0gkE9TbFrO5ArbtMj2b8y3cdzbfBP7hIrdvbF1o2wvPol0ihEKt5bmpmY0qQoB0XQzdz2DtFDwnQWVgo4tzuZDIWo+Fe/ACGawVkfDd736Xs2fPrjvOYCjIcCpFp92hUChgmibZbBbHdVAUBSEUbMfFcZzVB/O54tkUgSWl/JSU8nUDnv5F4DfOOfZneL1LrsLrVfJnGwjviqfRaFBTPctbqzRNOOA1GfY3DPu8GMTjcQ4ePEg4HGbXrl2o0mY2O4O7gYtEz759ru5w22238Za3vKV/39GjR3ngiw+s2c42FI7Qtl3atmR0fJJQNE6t1cZFYFo2J05O0dyExsk+VyRnVrmtfxblc0Esy8JxJQiFluUCvSbDCRzHxtA1v63IDsETWGyqJXlPZBmBJe6CudxFrdH753Z7YZmrCSwJ3/zHb/KD7/+Az332cwOJrFA4TCqVot1ue32yzDbZbBbXdbvNhl0/i7VD2JDAEkK8WwjxZSHE97o/V7JuXxEp5cNA6ZzDbwP+uvv7XwNv30icVzKu69JoNmkHvCSeXcoSCYfRdd1fDfR50UgkEuzfv59EIsGuiXHsjsmJo0eoFPNUK+V1i62xJQLrgSdrnErdwr53/glDr/8gsZf/FodfOMwXv/hFHNsb13IkDx5pcKx4/oUpHPWaEJuOJJUZQ+hBgtEEKBqW7VCut/jxj3/slwruQKSU+6SU+y922+oYtwu9DJaU0Pb0FdJqE4/HcWzbz2DtIDyrdmXdzYZXY6nIGh0ZQVM18vk8bfPiIqtfIriKwKosVPqtPVqtFp/9zGcGsnAPR8IMpYZom0tE1mwWoSg4El9g7RAGWk4SQgjg74B39A7hbYP4HSHEu6WU6xZa5zAqpZzt/j4HXNA7UwhxF3AXeBsWH3rooYEerF6vD3zupcY0TX7+xLPI4KuQrotdzWGnRjl+/DiPPvoo0Wj0vHMu5+ezHrbL84Dt81zi8TgnTpxAmjWe+/mPUYQgHI0RSY2Smdi9rrGGtARlW2e+0RVnSgR9KII+NEHz+GM8/9zzfOazn+HX3/jrzFlBnl+IM1NpIcqVZeO0zRazp2eQioqRnGc+X0RabWKZIMVCnvlTZaamTvLP3/s+b/i11y/bu7hd/l9g+zyX3vO4/fbbNzyWEOJx4MvA16SUuQ0P6LMilmVhu5JWq4XQvPJ1RVoEAgFqjQUCetAXWDsEXdfRVIFtbX5TXcPw+mRls1lGRjLk8wXyhTzp4XTfhfZcFpsNX1xgJZNJ7rnnHj772c/SbDQxzTaf//zn+cAHPsBVV121rjgjEa+VSLlUplAskB5Os1BdwIomfIG1Qxg0X3838M7u748Cp4G9wKuBdwoh7pJSfmET4kNKKYUQF/xUdB/jCwC33HKLHPSCvFkX80tBqVTi6dN5mALXrIPrsGfXLm644QbuuOOOCzoJXs7PZz1sl+cB2+e5PPTQQ9x111385Cc/odVqMTs7y0KjhUzE+hbva2XvfkmxtTzz9dApk1MLNnpyHKeaZ+rkFE8++SSHXvs2WGhRczT27j+Iropl52VSSQLBEIlUmpH0MM16ldHJPRTzeaaOHUFIh2QqSCwW41d+5Vfw1oi2z/8LbJ/nssnP4xXAy4H/SwjxA+ArwDellK3NegAfD9u2cRxJvdlA6J4TqKGAqqjdDJZvcrFT8EoEBY6z+QILun2yJifIzmTJZNLkCwUKxQLDw8MXNP8KrDGDBV47kg9/+MN87nOfo16r02l3uO/e+/i93/89rrvuunXFGYlEkFJSKVcoFAvYlsNMdpZWy//62QkMWiL4XsAF3iylvFVK+R4p5a1Az5HpfRuMa14IMQ7Q/bljVx5N06TU8uotXLOGlJJ4LIqu6/4eLJ8t4eDBg7z5zW/mlltu4fbbb0e4Drn5OazO6rXwS9FVwVhUW3bbm/TWfPbeeAsAwWCA19z6Guqd7mdAQr55fjniyMRuEimvj0k8OcTYrr0IIUiPjHD19TdhhCLkSwvMzMwwNTWFlH5/2R3CnwJP4S0mvglPYM0LIR4QQvya6Cltnw3j9cCyKTZt1IhX0h7UBKqm9hsN+wJrZ6DrOooQ2JcwU2PoBpO7JgkEAmQyGQzDoFj0HGTPJdhdkFtou8zV7VVvSnyE93zwoyR3H0JLjiEjw3zpv3+XR5/oe7FR77j960jbln0DDSll/3rlBRomkUxgtkxqjTqtVpujR49u6v40n8uTQTNYL8EzofinpQellN8WQvwQeOkG43oQ+D3g/+j+/McNjnfFYpomxe6E0m3VEAJi0YiXgvc3DPtsEamU1wNramqK/fv2kj98hukzZ9iz74A3oRqQ3t6s8Mhe7nj9HVx/3fXs2bOHZ48tmlTM1h0mYmt/7yeSCVKZEU4/P82ZM2c4dOgQUkoOHDgwcJw+VwZSyj8H/lwIcQ3wu8B7gIPAnd1bFlhfbavPMqSUPP/88+RyOY4vCJ4I3kxg3LsvbGjdPkASTRG+wNoheH2wBPlinsNP/3JTxhSKwuSe/UTjCbJnTlGtlBCKwtjkHhZqdaTVplWrgYT6QoXC7DQHDhxAUZR+ieCpis0XK2ttMaJjvPp3WNrt8V+bUHv0WW64/iV88ak6r5wIcMe+IA88VUNKuPsVMR46bfLoTJvfuymKC3z56Tq37gpwS3qI3MwZCvUyR48eZX5+nj179qxpHvfCCy+sq++pYRhcd911aJrGc889x8TEBMPDw2s+32dzGHSGHgOOrnDfEeBX1zqQEOK/AbcDaSHENPCf8YTV14UQH8ArP3z3gHFe8bTbbXI1LzPgmDXC4RABQ/d7YPlsOalUCiEEx44dYzRfo1Gv9ZtADiqyxiLeefMNh/f91m+hdBMMS1cE5+rrdy8cG59g5sRh5ufnmZ31fMOzzgAAIABJREFUtneePHnSz2TtEKSUR4CPAx8XQrwWuA84BExsaWDbgIWFBZ4/coxspcWpbvcG12xglWcY1kxUVUVKiaLgC6wdQiQSIRpUmVAANsfBtdl2mJ0+zYGrr+Ps1FH2DIdptB3yc1l27T/I04/9f9iOSyozyrHnniI3l6VRWyCWGGJXXONQSqPWXv/3veM45PN5pBFGCUT418eeoilVYJx8w8F2oWJ616eOA7nunuJ808HtPlyu4RDZGyU9MsLpIzkeP3yaZDLJU1NzZNJpVPXi18sT00U6gRNrjjkdDTA0NEQoFOLkySkajYYvsLaAQQVWAPgNIcSFeojcBKy5dk1K+d4V7nr9IIFtN0zTpGS6EAC3VScUCqJrqt8Dy+eyYGhoiOuuu46jp7MIxcB1XXL5HJlMZqAMa0hXSAQUFtouhabLSFdw1a1FgfX8mRx37Bpd1yKDpuskUsPobZidne3vwerZ525Go0mfyxchhAq8Ea+8/W3A+e5APgPR6XTo2C6OFiKUSkC1SWvqFzSee4jkb74JTdMQAlSh+AJrh5BMJrnj9tsxTXNTxltYWODnTz1HybaxbQtNUUiGDKDDgtVBui6jmQzz+QJDQ0PoukbHbFIulYglhtBVwbuuHfwjX6upfOaffoHc9TKMcJRIIgUlr3Hx0n1dprNYKth2JG73stUz19i9/yDBUIRSsYgI6MRTKdAN0uNj6OrKn42KrTJ+8No1xZqfz9KyqnQ6HVRVpeP4tvBbxUZqzA52bxfCXxbeJEzTxDW8L4Z9ExlCxj4MTVtXutjH51Kyd+9e9kyM8vTZEiOZEfL5PLlcjkw6g26sf0I1HlX7tfJ9gdVZ/EqxA3E+/bnPc89df9h3aloLoXCUkG5jGAblctmrla/XOXHiBAcPHvRF1jakm616L/AuIIXneAteBcZX8fZk+WyAXv+rYCiM3fKmFG7Hm1gnEwmkdNGEgqap/mdsB5FMJjdtLMMwUBRw2ha2bdN7G2lCYNs2ruOgawojmTSBgEE4HCISNKgtVCmVSqSGUouf/AGIxWLc+spX8NNZh5fd8hoCkQSUzH57kB5te1FwmbbsZ7B6x4QQjIyPE0skKJZKdGyXRDJKy7QYmsisuK8+Pj9PKjOyplhbzQZmYQHbtrEsi47tC6ytYlCB9V82NQqfFWk0GnTUILhw0zUHkUkLXVMvaM/u47MVxGIx0kMJosUWQkqSQwkK+QLZ7Ayjo6ME11nOOhZVOVy0+MVsh1LL5VWTAZqWBCT2Qg4tMUqu4fLpT32au++5m3g8vqZxQ5EoZr6EYRhEIhHy+Tzz8/Pk83lM0+TgwYOo3Y34/kRw2/AQ3oKfwDNL+lvgK1LKx7cyqO1Er/+Vpuk0297G/Vtf+XLiN4wxOjbWbzLsZ698BsXb06Vg2xaObfX386kdG8e2sKwOqqKgKZDJZNA1jWg4RCgcotlo4rouw6lhhDK4yoqFDKBFIBLrZ6SWmlsAywTXUoHVPse9MBQOkxYKhWKBXC7PyEiGmewM4+PjBAMbq07SdA3HlX4G6zJgIIElpfQF1otEvV7HlN5/U0iVNFwXVRF+BsvnskFRFBKJBKl4jWJ2ilKpiG3bVCoLnDr8DDe/5lfRNJUTLzzDxJ79DI+OX3S8XXHv/T7fcJhvOPQWCKOGQjQZYE6CPjTB3PHH+ORffpIP3f0h0un0qnGGo1EW5mA66+3BqtWqPPfs87TMNqnUMIHgw4yPjxOPRrjjjjv8CeH2oAV8Ey9T9X0p5fo38PlclF4GS9U0mpa3XzgVj7Bn7AChUAjHdggYvsDyGRzPldBrBWBbNqoQhEIhGi3TE12Og6qAqwocyyIRj1MLBwmFgsSGklTKlW6vrGGUVfY7rcRSq3dnSWZqei4PhPr/7pcIXiCDtZRgKEgmnSFfyDOf88rqszNZxsbHCIcGn9+pqiew/AzW1jNoo+G3rvY3UsoHBxnbZxHHcWi2WpjSK4MKqS5110VVvKyBj8/lwr59+zBNEyklpplmZmYGczjI86fnOX3qBLFIhKAKlVJhTQLr37wkwtGSxTO5DkeL3sUhaii8dNc4cydb6EMTtIBischffuIvueuuu9i1e9dFxw1HYiihGGcb3R4kSoJOdJTTNclsu0osFudE6TSvuGqScrnMyMjaSjJ8LmtGpJQNIcQ+4PeFEBmgAPyLlPLUVga2XeiXCGo6rY732TK6CWBVU3EcG13XfYHlMzBeXy0Fx7awbQulu8islis4jo1jWahCwVVc2m0TVREMJeNEwmGi0SiqqlIsFsnl8mQymYFMmJY2K+4JJwl8/6EfY1z/BgCKteai+Fryd5aLtwhxTgYtEAwwOjK6rKx+dnaWkZERYtHB5niaruNIiWVZqKqK7Uhs28G2bd95+kVm0Ff7m1x8n5XcwNg+XUzTpNaysFBRkBhCgnTRBGsui/LxeTHYvXs3u3cvul2bpslDDz1EpWWTa1vMz84yEnJpNAVSSlZrP3TVsE4sIHgm12Gh7e0Ujhqib+Oe2X8trSe/g2VZ1Ot1Pv3pT/MHf/AHXH3N1SuOqagqB6+9cdkxI5ZifHyccqmMETDoNGtMnc0yPz/vC6xtQFdc/Ve8flhLZ1WuEOL/lFL+py0KbdvQz2DpKi3bSxDqijc90DQN6dhoqm9w4TM4qqqiayoSSafTRlMVQqEQmqbiOg4dq4OmClwpaLdaqIqCAkQjkX6WKJPJUCgUmM/ND7Q/OLg0g7WkgtxSw31Xt3/96S9Q9r68/3fuklly25GEL1CiqBs6mREvtlw+R3o4zfz8PK7jkkgk1hUjLGawegLLkS6OlL7A2gIG3WhwZpXb2U2JbodjmibFfpPhOt/5zrdQhLfhMxAIbHF0Pj4rEwwGefnLX04iHCSg67iORbtWod2o0zbX1sU+E1ZRl1yPYoZCJqKiCKi5Oh/40N39Utl2u829997Lk08+ue5YI5EIw8MpOp0OLbNNrdnm6aefvmDDSp8rCyHE+4H/hLfgZwPz3Z8q8GdCiDu3MLxtQU9ggaDVbaeg4wktTfUcBP0eWD4bRdd1VCHomCaKoN8LVFW8Y6oiUISgbbZQFFAUzwAjkUgwNjZGMBhkZGQEIQS5fA6ztT6Hw4C6KLCWGlvsW7Jo11EW52UX2p91sec2khlBVVTyhTytZpN8IU+hWFhXjACapuM4nsCybRvHBUd6bp8+Ly4DCSwp5T4p5f6L3TY70J2IaZqcLXlN8azGAmdOTRE0NCKRyKoZAB+frSadTnNw/x6EdIhHw8SiETqtOnMzM2vyGVUV0XcRBK9EUFMEmbB3LJTezUc+8hESSW+Vz3EcvvylL3HmzJl1xxoKh0kPp1F1g7lCmUKhwNGjR1lYWFj3WD6XFR/BE1R3AxEp5QQQAT4EuMD/vIWxbQts28aRnsBqdDyTi7+693M8/vPHUVUVgfdZ9gWWz0boiSnTbKF1Lf97oss0WyhCoKnd+7sZLMfulpdHokyMTxAIBBgdGUHTNArFwroW0ZaWCC4VTlpkqP+7Gll0Tqy1OstE1blGF+eiaiojI56TYLFYol6rU6lUmJufQ7pruGD2xtG1fomgt/jh4rgutm2veQyfzWEggSWEeFwI8UdCCL+G5hLSbrfJlr0mfU6rRjQaJaBr67Km9vHZKhRFYWhoiMmxEYaiYVKpFMPxKKVigUKxsKaLRq8kELwSQfBs3AFm6zZj42N87I8+xsio91X0qle/mj279wwUbzAUZHLXblyhcvrsNOVymRMnTlAsFgcaz+ey4Hrgm1LKL0gpbQAppS2lvBev1P36LY1uG9DLYLkS3G4Vpts2CQaD3R5YXmbBF1g+G8EwDDTFKwHsNa32HF+h3WqhKQK1e78q8EwxrEVREQqF2DW5i0AgQCaTIRAIUC6VWaisbRFtqcmFaS/2ZeyVsANoSwRWs+PQ7Cx66izNeq2Eoqpk0hlCoRCVSoVKpUK9XqdQLOC4a/Pn0TT9HIEFjotvdLEFDFoi+Arg/wGmhRDfEUK8VwixPi9mn1UxTZNi0/uCcM0a0UgEQ/ct2n2uHJLJJJGAzu6JUSYnJxlOxtE1BdM0yeVzuM7FLxrLBZay7Nhc3Ts3OZTkox/9KK973ev4t+9614b6nQQCAcYmJrBcweHDh6nVapw6dYpsNjv4oD5bycXeDX6/xk3AsiwcR9KyXBAC1zIBSSKRQCgCgV8i6LNxNE1DUQSddgtVFYsZLEWh026hdEsEO+1Wt1wQbHu5qDAMg8lduwiFQmTSGaLRKLVajWKhuOqCn6YINAVcCe0lly2vhYiHCCwufit6ACkWp9gXKxFcilAEw8PDRKNR6rU6xUKRdrvN9PQ0lr26SFIUBSEUbMfFNM1+BssXWC8+gwqsPwWewqtrfxOeBe68EOIBIcSvCb9+bVNoNptULe+ldFs1IpEQuqr6DoI+VwzJZJKQrhA2NG699VbG0kMI6fUksSyL+VwOq7PyF/94dHFT7rkCa7pq8/R8m6fn25yoa+x99Rt5trB47On5Nk/Mtjg5v74yv1g8QTyVxrIspqenqVQqzM7OcurUKaT05+RXGM8DbxdC/IEQ3mxHCKEIIf4AeHv3fp8N0OuD1bK8lXzZazLcazQrpV8i6LNheuWArivRxFKBBa4rURVPBLmuRFUVFAGuc35ZnKZqTE5MEolESA4lSSQTtFot8oX8qgt+QXXwqe1qJYLLECyLrVKp0DZNpqenabVW38OsaTqO6+K6Lq70M1hbxaB9sP4c+HMhxDXA7wLvAQ4Cd3ZvWWD3yiP4rIVarUZLehcl16wRTUfQfYt2nyuIRCJBOKB5e6cyGfbt3cOZBYtTR57FcRwWqlWq45Ps3XeQYChI22wxffIYo7v2EI0nSYcVdMWzuY13SwQzYRVNgWpH8k/HV7/YSLvD73Rm2Lt7ck0xhyIxSkWB67ocO3aMZ555hkQi4T2XcJjx8XHUbi8VIQQHDhxg/35/2+llyqeBvwLuAz4rhCgCw0Bvtv/ZrQpsu9ATWDXT20TvWiZC0O9NJ/AFls/G8cSUdw3ovZ880aV0j3k27UC3RFAgkV6PrHN6XymKwtj4GMWCV/6taRrFYpG5+Ys7DAY0Qd0abJFtrRmspcRiMTRV5ez0WeZzOdLpNNnZLJlMhnhsZSdpzz0QHMdFSvwM1haxIc9GKeUR4OPAx4UQr8W7iB0CJjYhth1PrVbDUr3KS6dVJxIeQVWEb9Huc8UQi8XIDCUwDINgMMjY2BgvrdVoNJrMzeeo6WH+f/bePDiu7L7v/Zy79XZ7B9AACZDDZcjZZ0jNiKPFo5EUjWjJsR1vKcWSYyeOnLKlZ6nsZ6deXtWreqn4xYkjxXFiW3q2ZCu2LE1sydazY2mkkTjjWTgz0mzcdxIEiAbQe9/uvt13Oe+P22gABMghQc5wu58qFBv3dp8+3Wz0ud/z+/2+v5lalVK5RCaTwaqVcTpNSrMzmKkMihD82PYEtiuJ6QsLqeDDt8c5Wb140e709BQlL44SNfncn/0F//SHH+X+B+5/wzknUinO+YJTNQdkDKvnc+ZshehcK1jwJivk8jl0TUdXA9v5UGBdn0gp/0QIcSfwa4ABLDRh84HPSim/eM0mdxPgui6u5yOEwkypCqhIxyaZTBGNRPv3CgRWaBEdciVcSGBp/aiSKsAfnF9cKzzXWSGwAASCoaEhdEOnVCqhqYHxxezcLPlcjlh8ZbPfBaOLtdC9hBqs1YjF42QyGaSUzM3Nkc/lmZubo9ftkR/KI1bJgtZ0A8938Pri05NhBOtacEXfeEIIFXgM+AjwY0BYHHQVsSwLT4+j0o9gxW9DU0QYwQq5YVAUhUcffXTw+913382WLVuQUlIul3n8L79GzfOIRqPUqjUqs0WGIoJ6yxo8Zmtu5W7inUMGdw4ZK44v5Ygv+eorpzAm7kUkh/nTP/1TPjDzAXZ/cDdilX4kC+i6wfYHHsJzF9NFms0GjXoTI6KTz+XRdJ1CYYSj+16habXo9XoYxsXnE3JtkFL+phDic8A/AoZYbDR88trO7MYnsIH2UTWN4lwVGEL2bLLZLJqmoWsabc8LI1ghV8wygSUCwb5cdCn4sh/B6he/KCKwajcu0tUmnUqj6zrFYpHCyAilcplyuUKy5wR9qJYsFVcisBYiWN1ul+eff55HHnkERbm0Kh1d1ymMFCiVAoOoTDpIv+05PQqFAqqyXECqmtYXWMFzel4YwboWrNVF8BEhxB8AReBvCdIEk8Ax4P8iiGKFXAGu69K0WohoIKb8TmByoatKKLBCbiiEEMvaCkSj0cDRaXycbVs3oymQTiUxkybVcgm7UcHt2jjOlfXt2L59O4/svBMALRsE1b/9xLf54he/SNfuXvSxqqphRCKDn/zQMKNjo0gE1XodKaFcqSJR6DheaOd+nSKE0IQQKWCy7yT4W1LKzwNnhBApIUQYVrkCer0engRFKFQageW179hkMhk0XUM3DFzXRQ1dBEOukAUxJQSoqjIQWIoQCCWIVi0Iq4UIlqYI3EsQFvFYnPHxcaLRGCPDIyQSCZrNJqVyCd9fdAmMXEENlu1KkPDVr36Vb/zNN/j85z5/WTbxgY37CLFo4DBYrVRpt9pMTU2t6HGlaVrf3KIvsPqNh0PeWtZqcrEH+DhBLvs88HvALinlHVLKfyelPHWV5nfLYts2kzPzKEYM6bnEDAVVEcQierhTHnLTkM/n2bCugEASj8VIJqJ4To9Wo0qzVrvi8beNBTt95uhtg2P79+/nd3/3d5mfn7+ssWLxOIWRAlJKZudm6XQ69DyXszOzVCqVK55ryJvCZwjWqPNrgtcTNB3+z2/5jG4iFiJYEqi3AnML6dhkspnBBbDnOGEEK+SK0XUdre8OqOs6oi/aNUUMIlqL9VhBHZKiCLxL7P9k6Abj4+PEE3GyuSyZbAbbtpmdnR0YMS2NYCWNxduGApElQaSl5xZqh7uu5LXXXuPVV14F4OjRo3zmM59hamrqkt8DoQjyQ3lSqRStVou5+bmB+YW1JOsjMLkAV0pUTQ1TBK8RaxVYHeArwIeB9VLKX5VSvnT1phVi2zan5oILTL/TJJ0O7K2TyeQlh5VDQq53MpkMMUMjEY0S0TXSiRgjIyMYCpydPE2n3b6i8YfjauAmFc3wyHvfNzheLBb57Gc+w8mTl5clphs6o4VC0AyyVMbzoFK3eO2111bsIoZcF3wI2HP+pp+UchJ4sn8+ZI0s9NmRCFqd4ALO79nkc3kURUHXdDzPDQVWyBWzEK1SFWXwWVqIaqlCEIlE0DS1H81Sgt8VscKq/WIoisLY2BjZbBbTNBkeHl7cUGu3lwmsdHTxOiyqCaKasuq5hdu2J7nvvvt47IOPDc5VK1V+77/+Ht9/6fuX9V6k0iny+Ry9Xo/i7Cwdu0OxWAz6SyJRNQ1fSjxPEonGcEOTi2vCWq/UR6SUPwscAn5eCPFvhBC/KIS47arN7Ban2+2SGt0IQCZh8ODOnRiaFqYHhtxUBC6DKlazgaYIJsZGyGQyrCsM4TkO5XKFWq225o5FuioYiitI4MFHd/ORf/YRND3ICrPtLt/8+2/y0osvXtaYC80g44k4juszW64xOzvLoUOHaDaba5toyJvFeuD0Bc5NA+Nv3VRuPgKB5SOlRBiBqYV07IGDoKoqiCURh5CQtTIQU/0mw7DQG4vlfbGEQBVBKrp6mQILAvOLfC7P6OgosWhscUOtXMHvLaaWZyKLl88RTQwaEZ9/Lt2/bbsSoQh2797Nv/iX/4JoNCgMcxyHL3/5yzz+1ccv2rLkfBYyKoQQzM/PYzUtarUa56bPgSJwfYnvQzQaw/eDaHPIW8uaBJaUsiWE+HfAUeDzwL8HPgccE0L8+6s4v1uWZrNJyw++RLIJg4mJcTSFsMlwyE1FJpMhrqu0mg1aVpNcOsm73vUuUvEIsYgxaLY4P//GPUouxGgiEFQnqw633b2Tn/ulT5Gb2IqaGiY5upHC5ruYb3s4l+HyJBRBLpdjeLSA7XqcmTxLpVLh6NGjFIvFNc0z5E2hBTx0/sF+r8a398+HrJFBBEvCptu3A/Dou9/J0HDfol2AtiTiEBKyVgbpgCsiWMpy2/YlES1FCLw1rhtmwmR8fJxINMrI8AimaSJde3B+aZQqoollPbJWi2At7YN1zz338KlPf5pCoTA4tnfvXj772c9SnLn09UM3dAqFQmASVatRLpdpt9vMzc3TbndwpY8RjYY27deINRX4CiE+Bvzb/q8OsLS3yL8RQhyRUn7p6kzx1qTZbGJ5QVJvXJXgSzSF0KI95KYiHo+TiEWRnkWzVmF8zGTLli1sO32ac6+fpFaawe7YnGs2OHNCYWh4hI1btuF7HrPnJhkqrMeIXMQiChgzVV6fg+emujw31QXiaLv+Gfn++S8fcYEm2ajCx3cmL2unPZlMMjq2nm75LE899RSFQgHTNDFNk7GxsYE1tRCCjRs3Dnb2pZQcOXKEQqFANptdwzsXcok8D3xICPEnBBuBZ4CNwP8J3Af8r2s3tRufhQiWD9j9RsNmNKgTXvg7UpZEHEJC1koQrQoiWAvfq0HEioGJiuu6aIpA01QMw8BH4F6BWZJhGEyMTzA7NwsC8m0LKkEkKC4WhVtUXW7klL5ABGspIyMjfOpTn+Lxxx/nlVdeAfqp65/9LP/kJ/4JD+96mFUc2FegKApDQ0M0Gg0a9QazvVk0FSqzc+SzaUaHNuD3a7CklGEk+S1krQ5KnwDc/r9fkFK6fTemXwB+H/gVIBRYV0Cj0aDdj2DFVIn0PTRFBLahISE3Efl8no3NNp6UpJNJYrGgDmvn7T1KlSo1p0vKVKhUqkwdL2NEYigCqrMz+J7H+KbbLzr+9iGdg6UenVUaRC7Yq1dtf/BTPHWEO7ZvR1mld8pqZHJDVLttpuo1TpVOEI/FMZNJtEOnyOXyRCIGEU2l1WrxyCOPAMFCevDwYUqlEu9+97sv/00LuVT+A7Ab+Fj/Zyk+8Ntv+YxuIhzHwfUlUorBBaShyCCaoOn4gwve0Kwx5MpYTP9TBkZf50ewHMfB0IIIl6ZpqL6g664tgrWAoiiMjY5Rq9VI110gMJPotZsYSoyeH9RgLQgXXYG4viiwTENBFUEvKteXaEtahESiET72sY9x+7bb+frXvo7jODiOw/79+wOBdRmkUikiRoRyuUylXqPb6QTpuZUKEnA9H9d1w82Ot5C1fuvdDfx13+4WACmlC/y/QojHgB++GpO7lSmVSlRtD7RAYDkdG9M0wt3ukJuOBx54gPHxcaSUg8/3Aw88wMTEBFJKms0mk5OTTE9P89L+Y5TmZvFch5whaS9xTroQcV3hZ+9dvXbx+PHjbN26lb88aHG86vLSwVN868/+iM1bNvPRn/0omWzmDccfWTdOPGHiez6NZp2W1cI3dMxsFl/TiGQyzE9Psr7RwPd9FEWhVqtRaTkYWm1wLOTqI6V8tp9x8d+A3JJTVeCTUspnrs3Mbg4cx6Hbc1C1WF9gCQwFNFVDN3RcJ7BoD51vQ64URVHQdQ1dWxTsqqqiaypavwbLMIzlAsvlsmuwLkQmk2Fi1If9wZqTTsTQqz49FIx+HRgEYmtpPdbC721HYrsS0zgvgiTg4YcfZuPGjfyPL/0PbNvmIx/5yCVFr84nEo0wOlpg2ukx22jiOg7ZnkOlWqWRUnAcJxRYbyFrXdUv9l+/xnL0kKUcPHiQs/NBb52X9/4DTtfGjBlhBCvkpkPXdcbGxli3bh2xWAwIUjMWjm3fvp33vOc9bN68mcJwDl1TaNar2PUSVqO+5tqspYyawYL9wsHAbO7kiZP8zu/8Dvv37X/DxyqKQiqbIzM0xIZNW9i0dRtxM4XteOiROFLRsNptGm2bRqMBQL1ex+q6tHsulvXGIjFk7Ugpv0Jg0/4YQc/Gx4AJKeWXr3RsIcSEEOJ7QoiDQogDQohfvdIxbyQWBNahQ4exusGFrCrdwcWu6zooYQQr5Cqh6zqGurymb+GYpmlomjY4r6pqUIN1Fc0dMsn44HY+mySmB1kOrt1C8YPnOb8eK7rk9/PTBJcyNjbGpz/9aX7pl36JRCKx7Jznupe8zimqykihQCyWoN3pUKlU8TyfmZlZTp48uayvV8iby1oF1kHgx4UQvyBE0HhACKEIIX4B+PH++ZAr4NSpU6jxQEwpTgdNhUwqSTQavcYzCwl56zEMgx07dlDIZ/GcHumkiaEptBo1ZoszV7ytM2YGC2Vu4/ZBNKndbvOFL3yBr3zlK9gd+2IPX0Y0FmW0MIqu61QqFaqVKoqqc+L0WSYnJwGo1Wp0eh6dnhu4JIa8qUgpO1LK70gpv9z/98r8/xdxgV+TUt4FPAz8ihDirqs09nWP4zj0eg7PPv8C3f71X60U1KsYhoHnumhqaHIRcnXQdZ2ItvzzpGna4NjS85qmoamX7yJ4MeL64kbBuqEcMSNYN6K6gtcNvlIiqlhm5x5RFyNaLcfH9eUFf4SmkR8ZWXH8mef28l//2+9zrjh30ccv/EhFxYglSKSyoCg0Gg3qzSbFYpFDhw7RvsL2JyGXxlq3lf478AXgj4A/EEIsNbkA+IOrMLdblm63y9lz51DuDwRWOgIxTWF4ePgazywk5NphmiYb1o9xzvKxrTqFeIGmX6M8P4eqB+mza72QG+0LrJ6e4pd/+Vf48z//M6rVKgAvvvAix44d4yMf+Qhbt269pPFUTWVkeCQoPG40aHVsej2bAwcOYBgGzVYb15O0ez61Wo0NGzasad4h1xYp5Qww07/dFEIcIrCGv6k3GXu9HqdPn8ayLH5Qj+K96+MoQiB9n3zOZObsaXC62O0WcRGaXIRcHXRdH6QALrA0LdB13cFtVVVRhUu30+HMiaNX5fl9ubiT5zQrxPVAOOWTCcqlWSCC06ozNzkDjASPsS1U3wUU/mL/Gk1Lt//pRbSBAAAgAElEQVQ4AF86AZyoX+KDgn2eRBkejpU50bT42pMtfnrjIXYcPszw8DBDQ0NX1fQiEomwadMmfN/n9OnTy3pDLjyfZVlMTk5y6NChVccYGRkhn8/TaDSoVqts3LhxxX2mp6eJxWLkcrlVRrh+WJPAklL+iRDiTuDXAAMY65/ygc9KKb94leZ3S1Kr1ZirWih6BOn2SMcjRHURCqyQWxohApOXbKpGJJMg4ncY6UosNaj1mJ2dJZPJrKmVQcJQSBqCZk+SHtvAr//6r/E///IvefWVV4GgIeTv//ff55H3PMKHP/RhdOMSLhhF0BAyEonQ67aZmT7FVEIjk8lw4swU0kiHEaybiH4fyB3AC6uc+zjwcYBCocCePXvW9ByWZa35sVeTyclJjp46i+1JjjUnEBGB9D3cmcOcKJ0jrfu0iyMIghSpVzSfmZmZFeNcL6/nSrgZXsNSrufXc+TIEUqlEpoiOH78+LJjuqrQ7XY5evQojVqVXC7H0SOHqHU8qtMnrtocxpXbcKXCqZdfQXdyJPUN2MVj9M6dIZraiVE6yIGjx0lOfIBkMsX3n3sJIXKo5h3INRRWSSlXpPUJQT/T4sLjSSmDBuCOoOQJ5noJuhGNv3/tJEc7h4kYBrphkEql0LRLM3R6I0xd8MC9d+M4DvsOHaW9JCVyxDR4+9vfzsGDBzk2WeT145MrHi+A0XSMt73tbRw4cIBarcb999+/bE3v9Xq89NJLxGIxdu7ceVXmvVYW/lYeffTRVc+vOTFaSvmbQojPAf8IGAJKwHeklCfXOmZIQL1eZ77lEge8TpNUIo6hKoyOjl7rqYWEXFMymQwxfYpERGPnPffj7n2RI7MtRkcLlCsVatUatm2Ty2Yv2QVwgVFTo1lxKFoed4/E+bmf+znuvfde/uqv/op2K0ipePqppzl86BD//Od/nrGxsTcYMSASjbBh4yaKZ04yM1NE0zRqVg8jn2W2XKVWM0OjixscIYQJ/BXwKSll4/zzfUOozwM8+OCD8kIL8htxscX8reT111/HkhFkNI14JaghrH73C6xL6Yzt2sk961N88LEPoChBbczExATqKn+P18vruRJuhtewlOv59ezatYtKpcK6desGkZeFY+vXr8f3fc6dO8fw8DDPP/88/+oXf5F6/VIjPpfGx/v/njlTYN3pWTbeuYVKKUlnfZyfivaIRO7h1dclmdoxto3vZFZmGVUkP36HRsJcW5udvXv38sw/PMO5c+cGx6KxKD/6oz96QTv3ltXgb096nGrCxu134863mKlDbGgdQ6pCNBollU6iqhqZTJpkMoVYi7NGn/J8kbzh8uCDD9Lr9Wj2BA0ZIZsfZvLkMe6YSPOe97wHRVE4cLbCA297N4axWPIikUydPs4dG3KDz1+pUuOhhx5a1i+s0WjQsNokYpFr/jl9o7+VtfbB0oA4MLnUSVAIoQohUkC77yoYcpnMzc1x8OBBLF8nThBeNnNxklH9ug+HhoS82aTTaeKGSkxX2LBhA6PHT3DOktQrJXBdfMem5bt0u11UJKoiUBSFTH4YVdNo1qvoRoRoLL5i7DFT5VjF4e+Ot/nmiYUc9U1kPvTrmJ6L7O8iSgR/fkpHnF6MPG3L6/zjbYkVYy6g6TpDIyOYTp1ischMy2fTyEZ6rs/xk2d4+eWXlzmE6rrO+Ph4KLpuAIQQOoG4+nMp5deu9XzeCoL+V5Jsboie3wYFpGOTyxcQCsSiEW6//faw507IVSUWi7F+/foLHlMUhfHx8cG54eHhNy3zp1qtooo5XMfFdVySiQTv3LWTbrfL5NmzzLs2EkmlVCJrxvB6a78kHhoa4lOf/hTf+ua3+O73vov0JXbH5vGvPs4Pvv8DfuZnfobhkeWvM2GmSMRa0HRwURGROOAQMTPcNp6i0WjgC4V0Josei4FmMDw8smbHz17XxmuX+nWZPVzpk8nlWb9xE+cmT+H5cmBD7wOj6zcQiy9fM6dPn8BxPTzPC8bxVjZI7vV6OP3j13tfr7Wu3p8B5gmcmZayHpgF/vOVTOpWxbZtnn3ueb719F6MkU0AaE6LmKGT6acahYTcymSzWcyIRspMYJommUyaibxJRu2h21V69TlU6SF9j8OvfZ+Zo69RPnuC+eI0XbvD6aMHmTx+eNWxt+Z0dIWgKaO/+ONKQNEQmtH/0XHPu8+BeeeiDlEAcTNJV4mgJfNI1aDbdej2XM7VWnzj23v42t9/h+8+9wP27H2Z51/6wbLdypDrExGs7n8MHJJSfuZaz+etwnEcPCnxpI8jgwscv9dhKJ9HV1Xi8fh1feETEnKlaJqGqgQmGp7roKqCeDzOnXfeyWihgKHrDOXzRKNROp0WxeIM3W73ip7vwz/yYT7xK58gP5QfHD9x4gT/6Xf+E0888cSKVMKoutjkuNtfn7quJJVKURgpoGoq5VKZcqlMu9Xi7NRZKpUKcg2uUaqm4fmB8HFdF88PjgGour5MYHm+RNNWptmrmj4Yw3Eceu5KgeW6Lq6Ug/GuZ9aaIvghYI+U8tTSg1LKSSHEk/3zt5Rd7dWg3W7TdX1OFKsYY9sBiDp1zGiakZGRazy7kJBrTzwe5x0P7xpsNtx///0MD59DSolt27yy/xDHSx3SyRRDaZO436LVmKesRjAiUUxdYNkdPNcdfPkvMJJQ+dSuNN5F1paWZZE4r8bry/stipbHmZLF9tHV+20BjKzbQEU3kL7P3ePb0aMxEIJaeQ6hmggRx277RAydnudQqVSW7caGXJe8i6CB8T4hxKv9Y/+HlPJ/XcM5veksXCR5no9Uggsl6XYZHh5CVdw11UGGhNxIGIaBqip4rovrumiGGJhvDA0NUag5aJpCOmWi+Qae5zI/N49pmqTSqTVnJ2zavInf+N9/g2898S32fG8Pvu/jOi4nT55EEcvHXHAz7HpysAFo9xc43dApjBRoNAMjpm6xSzqTRkqJZVkMDw8P2qZcCpqm05MsEVH+QERpmoYn5UB8+QRZHSvH0PBkYPTmOC7uKiLKcRw8b1FgXc899tYqsNYDT17g3DTw/jWOe0tj2zY9x6Naq2Ns3AVAVrGJaJlQYIWE9Flai5hOpwe94brdLmcmz2K2QUGSSyfYNrGFffsPMDk7i5SCtOITVRU6bQsztbKJsKoILla5ZaRXCqiE3wKifOXvvsuH7lvHQw8+tGpOvBGJMDq+3BEpOrEBM5nE7tioEYNMJkvXbjM9fZJyOTS1ud7pNyq+5UI1Cxc5jU4PhMB3uiAlw0PDdKvFFX18QkJuNjRNQxVBI2PXdVCjiwIrsIvXyWWy5LIZ3E4TPZMlkjCxLIuO3QnqiS9DwCxFN3R+5Ed+hB07dvD4449TnCny0z/10yu+iRbs4W13icBammkhIJVKEYvFqFarVCtV2u022WyW6XPTpJIp8kN5VOWN65k1TcPz/FWjVJqm4/ldOp0OruuhKOqqEe7gfi7tdhtP+hcUWL4PnpS4V7HH2ZvBWlMEW8BD5x/sp0u8vX8+5DKxbZuW3WW+0kBNDSN9nyHDJxIaXISEvCGRSAQzEUcT4Ds9bhtfx8TEBBsmxkmaMSrlOerleVy7RfsqNff1PY8Tr+4FQCaG+Isv/wV/+Id/yNzc3CU9XtVUhoaGyOVygRPi3CyO61NttNi3bx/FYhEpw97tIdcXCymCk9OzQFB/lc6kiUYNdFUhHl9Z4xgScjOh6zqqUPopgi7qkobagU28oNvpkDJNJtatIxIxyGQzjBRGUIQySM3z3EtrILwa69ev51d/9Vf5xCeXpw0COD2Hmckgycx2JV1vMUVwtdcyMjJCJpuh1+tRLBYHLUbOnDlDvVF/w7TB1dIABymCqorny75wkhc0oArGCLK5fB88b3WB5Uofz5fLbOCvR9YqsJ4H7hdC/IkQ4nYhhCGEuB34E+C+/vmQy6Tb7dK2u8QKGxFCwW3MkUnGiBlhD6yQkEshk8kQN1ScXo9sMsGuXbvYsGEDmUSMdDJJMhGh224yNXmGrr32fPgFFFXlPW8L+o3o2cBV8OjRo/zH3/6PfOMb37jkBsXxRJzR0QLxeJxWq0Wz06FStzhy5AiHDh3CukqCMCTkahDUWEjOnAus12XPZnh4GE1RiUb0sO9VyE2PrusoCv0UQQdFLI9gqYqg2+2gKgLD0MlmshQKBWKxGIVCgXQmTcfuMFOcodFosIayJyAw9piYON8OAZ787pM89/QeAKrN9kBYOT54/upPZpomY6OjxKIxGvUGxWKRTrvD/Pw8U1NT2N0Lr2dL0wDPF1iabuD5kk6nExxXV0+e0/p1XJ1OB9eXg3qspQRjB6/hZo1g/QeCnlcfAw4Dnf6/H+0f/+2rMTkhxGkhxD4hxKtCiO9fjTGvZ2zbptXp8sAPPQbApqEEaTNONp2+rvNMQ0KuFzKZDDFDJaIpJM0E0WiU7du3s3F8HWYsyujICGPDeTrtFvPz84GTkrf2HUSAXffejipANXMokSDlw/d99nxvD7/1//wWe/fuRV5gQVuKoqrkcrl+7nuCmfly0NOl0eDIkSOcOnXqui/qDbn58Tyv7/Tlkx1eB4Cu+ExMTKAogmgkEgqskJuehSiV4zj4noemKssjWCKIYKmKQFMEnueSNJNs2LCBVDpFMplkbHRsmZi51A25N6JcLvPd734X6QTjnZ4q0l2yzHUvUmisqCr5oTxDQ0NIJPPz85TLZTrtNlNTU8zNzeF6K4WNpumDlL6FCPfC94CqLYlg+XLVlg0LYyxEsDxf4vVrupayUN91I5hcrElgSSmfJRBXVYKsz4WfGvDP+3npV4v3SikfkFI+eBXHvC6xbZtOt8t8N/jw5dQeZlQP669CQi6RBRv3eEQlk8kMjmXMGBvHC9x5553k0klSZpx4Ikav2+PczBXuIApBwQz+Zv/pv/wEmzZvGpyzmhaPf/VxPvtfPsupU6cuNMQyItEI4xs2EkkkmZ+f58SJE5RKJcrlMvv376dYLK5wiwoJeatYuMDxpSSZC9KS1heG2bVrF57nEYuGAivk5kfXdTQh6NkdFBH8vlBXtOAw2LUDgaUIMYi2qIrKyPAI4+vXE4/Hl4mZUqlEuVS+4shMKpnife97H4oMBIgaTy873+y8sTCJxqKMFkZJpVJ0Op3BOtloNJg8M0mlWkHKxXVI1TR8n+URrH6kakF8tdttXClRtNUjWKqm4cvgfr68WATr5nYRREr5FSHE3xC4KI0Ac8BzUsr2xR8ZciE6nQ5216HkBX+kSVpE9bD+KiTkUgkaEavEdW1gfrEgurqOzpYtWzAMg7mXDuD1bKIRHek6FKenmdeKpNNpotHF5oeqqhKNJxBC4PS6qKq2av74qKlyrunxSiNB/tFfwHiwuWyhtICvHXN4NNrlbWMXbrcgpeTpSZuEMElFE6TTcXzf5+TJk5w9e5bh4WEqlQrHjh1jbGyMQqFAMhkYb7Tbbcrl8qrjGoYxuF9IyJUQ7E6D5/vYTnCBZSgSQzewex3iiVBghdz8LKQB2nYbTVGWfeYH51odzERw2+suFwPRaIzxiXEa9QblSploNEqj2aDZbNIpdgK3wdTa3AZ1Q2f37t3c+cBD/MUJUOPLGxx/7o+/yAffuYOHHnroouMLRZBKp4gn4tRrdRr1Bq1Wi0w6jS99mo0GuVyeZDLZjz75QQ8s10XKJTbtS4ST510sRVCnsyDEfInnXyiCJVc1wLjeWLPAApBSdoDvXKW5rPoUwBNCCAl8bmlTYwAhxMfpN9YuFArs2bNnTU9iWdaaH3s1ee655zg5XaWWvxOBpDl9nHN6l1OnTtFsNi95nOvl9VwpN8vrgJvntdwIr+PkieO0OjYHEhrT09MAnDh+jLbdZb+pU6lU6FlVZmdnqdWqVKcUXNftOxy56JpGLB5DVTU8Kcit20AsYXL2+CHiZorRDZtXPGfENoAUFdunYvtADCU3ztLEXgd48mSbpHUW5QK+c1VH5flKFk343Dt/jkYxWEAcp4dltfBcD93QScQTaLpGPKLzjl1vJx6P88JLP2Dv919ZdVxdgQfuv++GEFkLn7FHH330Wk8lZBUWU3R82v28I11IDMPAtiS6ZoQCK+SmZ0FE+Z6PaiymB55/TuunCLrOyqiUQJBOp0mYCSrlCggwEwlq9TpW06LdapNKp9ZsdDQ6lIMT9RXH212Xr37lqzy15yl+7Md/jO3bt190HE3TyA/lsTs29XqdcrmCYVlkMhkc16VWr5HL5fD8fp8qX6Iu6XMViC+J53n4PhdJEdRwveB+Xr8G6/xo3oLA8uVNLrDeAt4tpZwWQowA3xZCHJZSPr1wsi+4Pg/w4IMPyrUuyNfDYu55HidOnuTYi2cgL0gqXcZGhtk+EudDH/rQZbkyXQ+v52pws7wOuHley43wOrZv3065XObuu+8epGxs27aNarXKXXfdRavV4sCBA3iexw9+8AM2b97M/Pw8nudhWRa1Wg3P84hEInSlhmtmMFMZjO46Op5gy5YtKyxmt0jJ9pa3qkNTs9mkWCxyVKyn0YXMuk2MJFTsjs0zzzzDD/3QDxGJBlGtV4tdqHRwpcLmB96B0q4MxhmR0LE7tKwWUvpIVSFh6hiGQSwWo+MrjI1vJxKJLnv+rt0hF4U77riD22+//Wq/3VedG+EzdisT9LLxkVLS6gUXOIYCRsRAVRQ0RYQCK+SmZ6HOCkBVlGV18gsCKzgnUPoNiS+EpmqMjIyQSqcolUooqkrSTFKr1ahVa1QrVTqdzmXbuhtqULtz/qok9GCNKBaLF8x6WI1oLEo0GsVqWTTqDeZm54jFY6TTabrdLrV6jdZQBF03ljUSXkgRBHClv6IH5QKqruP10w4DERV830gpB2vuoMn5zR7BerORUk73/50TQnydwAL+6Ys/6sbEtm0OHTlGsSVIAdWzRxEbIBGPLktZCgkJuThjY2OMjY0tO7Zu3TrWrQsK8k3TZNeuoM9cr9fj0UcfxXVdZmZmmJ+fx3VdyuUyU1NTvH7wMHbLRwhBTBc4vk+30yF63oaHEIJR8wJfp5kc90zksA63aHQdZiyXkYTKnqf28MS3nuDpp5/mAx/4AO945zuYsRYrkZ34MHdtXL9iON/3aTaanJue5NzUCc4kdDKZDDOlClt2ZNiy/Q70JYtbaXaG+dOHqdVqa3o/Q0KW4rouHbvLd558ksrwThi7G6/bRtNGUFVlmV11SMjNiqqqaJqKEKAKVkawxKLAUoXAu4jAWiAaiTK+fpym1aRSLqMbOnbHZmbmHOVSGSNikE6lBxtyb4QQgogmlve+Au7Z8Tb2z58glUrxcH8tvGREsIbG43GspkWj2aDT6WAmTBzH4ezZKaKxODI2NHhIUJ8VzMGXXDBFMLBzD257vkRKcL0girWwabPgYHrTpwi+mQghEoAipWz2bz8G/N/XeFpvGrZtc+ToMfSh+wFIiy66GiO9xhzckJCQS0fTNCYmJhgeHmZ6ehpVVUmn05w9e5aj81Vsu8N4UkFXY7RbzRUC61IYM1UOlx2KlseW+GKqpWVZfP3rX+d73/se2ff/KxDBLuWM5XHXKt0ZFEUhnUlj6Ft4fW6aYrHI3NwcrU5QGzM5OUnSTJLNZdE1nYSZ4kzPCwVWyFWh1+vRtrtMnZ1Gpu8jBmgi2BhQlUBghRGskJsdIYKNBEUEn/vVarBgMYIlRGDpfqHozVKSZnKQKlitVsnmcmRzWRqNBvPz80SiEdKX6C4dXUVgbdl2Jz/20L+lVq+tqCk+dvQYTz31FI998DE2bNhwwXEVRSGVTmGaCRqNJlbLolqrY3qCmOvRbAuKs0Vy2Rxav0cWgOf5F+yDtVDHBYtW8gupgLqu4/dNL3wf/FBgXREF4Ov9sKAGfFlK+c1rO6U3D8uyOHH6DPo7fgSAdUkNTREDJ7SQkJA3n2g0ypYtW7Asi6mpKTZs2EBdzlNptrAti47fwoukyOZHEBcqpLoAo32nwaLlEd+U4Cd/8if55t9/k2q1CkCt0USXBgvZhzNNB7hwSkgsESeZzpI2HJqNBu2eQ7lSJem6+J5P02qSTCbJZDJ4CKxWm263SyRyabufISGr4bouxeIstXqdbD/VaGwojxDBhWQosEJuFQIhpaCq4qICa+Ffz7s0gQUghEI2kyWVSjFzbgbTNEnEEzStJs1Gk7nZOaKxKOlUGt248N9bRF25TtmuxEyamElz+QkJ3/zWNzl18hQHDx7kzrvu5IOPfZANGy8itFSVTDaDmTSZnzpNvTFHrWGh5Q0ajQaWZWEYOnY/nXhpf6zzUTVtMYLVrztbmgq4UN91/vHrletWYEkpTwL3X+t5vFVUq1Wm56pkU8NIz2VzIYWGPXBCCwkJeeswTZM77riDUqnEZNlCqCqjsSRzlQaluTnMzAxm0iRpJi9ZaBX6KYRzLQ+J4KGHHmLHjh08++yzPPnkk9haCqGoeJ0maizJ2arNd7/7A971rndeUBTFEibSa2JmcuSHfHRDp16r02w2SSVT+J5Po9Gg23Opt2xqtRqFQuGqvU8htx6O43Dk2DEQYlDLkU5EiUaiVF0PRWihwAq5JQiEVJAieEGBJQSKoqD2rdqNy9zfUhWVVDrFxg0bqVQXjDBMmlYTq2kxOztLNBYllUqtGtGKaovrU0IXtBx5wT5YM8UZTi9pJ3Lo4CEOHTzEHXfewfve9z62btkaFHWtgqZpZPN5jJik3mzS7nQpzhQxkybxWIzi3Bzn9C4dP4JqpC4wxvIIlqKIZUIqiF71j8vrv9HwdSuwbjVef/113GRQN+I15hjdPARW+bKLGkNCQq4eGzZsYPPZIrOVBuvTBpqu0yp10XSNRr2B1bSCnUDTfMNU3qgmyEYVqrbPfNtj1NTQNI33vOc9vPMd7+TrLxzhJNCbPYkxchtqPM3fP/k8B/bv55P/2ydXHTOWMLGrDQASyRTDw8N0u10a9Qa1Wo1Gs0EymUQKwYkzZ9m3b1+wE5pIXO23KuQWod1uc+r0GUCgGIHASkR1YrEYnuugKrFQYIXcEgwiWKumCAa3VUUQj8dRlTruFURcNE1jZHiETCZDtVJFKALTNLEsC6tpMTc7RyQaIZVMLavRWiqw0lGFluOtSBlcYGxsjN/4jd/kiW8/wauvvMKCeeHhQ4c5fOgwExsmeO9738t99967apqfqmqomk46kyURGyISidCoB9bz7VabRkNQbIGa9Gm1WyTiy9chTdfpB6jwPEkkGsNdIqQcx8H1g+Ndux1GsELeGN/3efrppzEKgf1zzLMQwiQeGlyEhFxTMpkM8YjGcDbFw29/gH379nHOOoUZj6EkkzSaDWrVGvV6HTORIJVKXTQFZMxUqdo+z0za5OPLF6h2ciO0PO7eOMzx+XmIp0nc815y64f53ukOt+d0xlOLYx8u9dAUE1yJACKxoC4sEokwPDJM1+7SaDSo1+pYVhunbnHmzBlSqRSmaTI6OnpJEXJFUVa4JobcutRqNc5OTSNEbBDBimqCSCSCRKJr6gVtmENCbiYGESxllQiWCBSWqghisViQIngVIi6GblAoFMhms1SqFRRFIWkmsVoWzWaT+fl5jEjQ9zAWiy1LEUxHFM41LyywAAqjBT72sY/x2GOP8cQTy4XW2cmzfOlPv0Q+n+f9738/D7/j4WWPVTW17/AXOA7mh/I4PYdGo4Hd7TE906RBgrhhMjMzQ8SIkMkE6YUCEaQZqyqe5+NJSSwWx/Na9Ho9YNGi3YhEsTttHMfF9/3r1qcgFFjXmFKpxHPPPcfze/ei3/lTAIyZGk6vRyoVCwVWSMg1xDRN4oYGUpLNZoOIVr3LuekzNC0Lz3dxHY92p02v20OPRLnz/gdJpVOr7uKvT2kcLDkcr7ocr66+2P7Q/duYqPV4arJHdP2dnAXOTnc5VOrxyw+mQcJX//bbnMo9RDai8W4pEQIi5xlvRKIRhqPD9Ho9FAWOTR7nwIGDnD5zhmQyiaqq6LpBJpMmmUwixOqLVMTQefTRR+l2u7zwwgvcc889jI2N8eyzz5JIJNi5c+cVv88hNw5Hjx6lYVloqfggghXTFTRdRRVh/VXIrcOCkDo/gqUoCpqmovVrswzDQH0Dq/bLxTAMRguj9HK9xYhWwqTVbtFsBo3uNU1DlYvrQjoSfMev1k7kfAqFQGjt3r2bp/Y8xYsvvTjo5VUulzl9+vQKgaUoGq4MjCkWnAJ1Qyc/lGdoeIhor0qxauPUG1QqFZJmkm6vS7lcJpVOkU6n+/0nJZ6URCJR/HZrWQTLl0ENl6oFlu6O41y3dcWhwLrGzMzMcHS6xJmGJDO8CYC7N47gexbxuBkKrJCQa4iiKGzevJl6vU42m8V1XbbMz3PbcBIpJc1mk2q1iuMk6PV6HJ1tUinP0+l0iMaiJM3ksnSN+0YMFLhgDnw6ojCW1MjHVSKaSq9/v+fO2jS6klbPpzh5itdOFknloNqVHJ8vcc/2LUh9dUcpwzAYW7ceq1qmNFdkutSFUmB2EYvF0OY7KMos8XiCRDyBqi4KLSkl49kY8/PzWJZFtdlmamqKeDzOzFyJiFblvvvuC225byG+//3vg1BBqAgtggCSiSi+44UW7SG3FLquo6liRQRr4VxEC4TXQirh1RRYCyxEtHL5HNVqFUVVMBMm7XabptXE73WAYA1K9ZcI+wLrz2oMDw/zUz/9U+zevZtnnnmGZ559hnarvWqvwlq9Rqzfv+r8TA4jEiUVz5KRXfxInHa7TbvVJhKNkDSTuJ5LtVrFslpYMR+BQDcMnJa/zOTC8yVaREfTdHyfUGCFXJh6vc6Bw8fwo2m01BDSc7lzY4G5yRa6oly3H5yQkFuFu+66a3C7UCiwe/fuFfep1Wrs2bOHSvcYMTNBNJnCalrMd+bRdb1f6BtHVwU7xt74b9pQBTuX3O9E1eFsw6Noeex5ag9aduPg3POHz/LCC3u5fds2ksnkqnphrmUAACAASURBVCYWQgi23XM/27gfz/VoWk1arRbSl0E6iWkSi8VBQCKRIJ1OE4/FOTd5mtbcGWq1GpZlUba6ZGs1arUarZ6HL6HRaJDL5S73bQ25Ael0Orz66qsIRUEYQX1wRBOYiQSu66Ap4pKso0NCbgYWzCzOj2AtnDOWCCylb9P+ps1F0xkZHiGXy1Gr1VBUhXgiTq7bgnpfoLRqQAzb8S97fDNpsvuHd/O+97+Po0eOMjo2uux8q9Xij/7oj0nIDvc/sINHxjYvO6+qKq4v0Q2DSCrFunXrgvoxy6JUKqFpGmbSpGN3ODNVoSmj5LpdpOsvM7nwfImmaWi6huv713UdViiwriG+71Or1Th8/CR6fhwAw2lg6EMoikBXRRjBCgm5AchkMuzYsYPZWos5G1KpFKlkila7hdW0qFaq1JQaiUQC0zQve5d/zNQ42/CYsTx+9B//KH92oE23f07LrqM9e5J9r+9j3+v72LJ1C+9617u49557UbVVCpE1lUwmQyqVot0KdjnL5QqqVieRSOB7Hq1WC13XEdLH6vQCQdVqUe84WO0OMzMztLseUgbiMhRYtwalUomDBw9CZj3KgsBSBYlEglajjhJGsEJuIYI+WGKFiyAEv+vqosDSrnKK4AXnpGoM5YfIZXM0Gg3SZRcInnckGYO5wKZ9dnYO00wQj8Uvq+WIYRjcc+89K46/8MILeK5HpVHje3ue5oUDJ3jbg29n165dbNy4EVXTcDoSVQveJ0VRButku93GalnUqjUqtRoONn5MoVqrYc2cY2o0w9atWxdNLnQ9SBH07VBghayOZVnUWx12Pvh24k6eE35QBC+lRFMVdDWMYIWE3Cik02myyThN6Qf9s+p1FEUhkUjQ7XaxmtbA8SkSjWAmEoOo0Rux2EPL5eHxIZxIHfpZHonCbbQPPzO474njJzhx/AQJM8FHP/pRtm/fvuqYiqIMHBBt26ZpNWnUGzQaDWKxWF8IqpyZPkdatIkmTFxf0nF8yuUybccFZNjA+Bbi4MGDJBIJLKGSzA8BQf2VoRs0XBct7IEVcguxIJxURVmxsXB+BEtVBLbz1tmKK4pCJpNhYh1w+DgAY0Np1JN1PClwXH/Zxl8ikbiiv13P8zAiUVyhgKLQ6zns3buXvXv3Mjo6yrbNG9i2fggtlV/+QAHxRJx4Ik6v16M6P0OzVMHrqcSSdTrtFrOzsxw4cIDp6WkaTYvCiIqmadd9s+FQYF1DarUa1UaLdDaL28xBC+6aGO6LK5VoNHrduqOEhIQsJ5VKEY/o2HYVVSgMDw2Tz+UDJ79GnUgkgu95WK0WrVaLcrmC0l/c4on4RRe3sSVNikvtIDVPV8DxIbV+Cz/5r/81T3z7CU6fOo3f7yPSbrUojFxCzysROD5FY1Ecx6FltWi1W3TaHTRNw/Ek89U6XrXJfFsSlTbR0Rxd1wcZpDmH3Px4nkc2m+UTn/wkL56YRV1/D/uBRCS4jHBdByU0uQi5hVgQTpp6AYGlLhdY3lsQwTqfhBHMSxGweeM4sVeaWD2fzPAIuu8M0vSspoURMYL16DKjWgAf+MAHeGjnTr7z//1P9h04SMNZfHyxWOTc5Cm+166y5e4HePCdj7B169YVYxiGQS6fpyW79ISBBGq1OqdOnWJ4eJhyuUypXMZPFJGug1A613UvrFBgXUNqtRqVRgs9nqU0H3wY12ciGJqOroowehUScgOxkPIQ1xu0rAapTG6wi5jJZGi1WzTqDRRVJZVKYXdsWq0WTatJs9kcLG6xWGzFxkomqhBRwXIkxyrBIr01p3Oi4tDsSdZv2sru3YGoe37v87z4wosURgtkspll48zNzfF3f/d37Nyxk7vuugvdWJnWkslmSKfTtDttWq0Wni85e24WVY+gmEPMVep4HQtLJLAVlXqjieu6YWrYDYpt25RKpQue/509U7w42cTv1zvY9j14Y/ci1Ah4YAiP+eI5GrUqahjBCrmFWGpkcbFzgwhWq8188dxlP0+tPL+mxwHYVrBeRDUFq1YlpilYPZ8vvdYE6QMKUsaRUoIQQBcpbQAUIQYtOlbre3U+Umo4t/8E+dt/giFVpdvt0u12QcpgfOnTEAov+Cav/6Cx6hiem8Hzgr6Sak3DSaZ5tQtff7aH56Xw/CTaMYGUOgXFJhvby9zcHJlMZtW+sZ99aornzzQHv2djGr/1odvIJ4L/s0QiQTabvZy39JIJV8RrSLlc5lzDoU2UlqegCcjHArtbXVXC+quQkBuMTCZDzJih1WySyiyvS0r0Xfpc16XRaNBQG0Rj0aDmqd2mZbWoVqpURZVYNEYikQi+A0RgUjFqapypu7w2G/QEGTNVrJ7P2YbHy8Uunm3gujFue/B9bHzbe+naXQ6Xesvm8PIrJzladjn6nRfRnnqFDRMTbNq8iXVj61DU5aIuF4syMpLA63Yon2lT6kjiSpzK7En8VARjKEWn16PasKjX6+Tz56V+hNwQvPzyy5ycKuL5Kwvfez789f6lFy0CRCxIa/WCIzmalCcrAKTiRmhyEXLLEIlE0FVl1c+8YRiDc4ZhYKgKEWzKk0cu+3nq0ycox9bWi9D3IaYmKBgu5ckjDGtR5tFp9CSL+emXMPYlG2P03wsP0OKoWnzFPbpA177QeEowhtcfg0iQDu8B6MHpftDK8jJ8/9A+jpw6ixAC3dBJJEwS8TiaruFJ+Kt9y0XXuUaPLz35Kvflgi+wTMxg9+4PvikBjVBgvYVYlsWrr746CGnu27ef77TGcbvBf+xIXDA7eYpmNIKphQIrJORGI5PJENNVpk6fYG5m6qL3lYDdtWm32thdG6TEcVy6to3d7SJ9n7iZYtO2O/GcHvFeF0hi9YLiqzFTw+pJzjY8nj3bBVJQb5/3LOf9bt5B+h13DH4tA+UWcNxeMT9NgV9+MEUqk6Uxm2S/2EzPjvJQdJ5So0Ym2SNlJqi3bV5++eVlu7iqqnLPPfe8aTuDIVePdrvNdLWDmcmvsFZu9iTQI67BB7Jl2p0OLatFIp1h0+YtzJw6ynu3jrBx4rZ+7x+N8fHxa/NCQkLeYhKJBHfffRepVGrFuQ0bNuB5HhMTE0SjUe675y62tFprep6I0+TB+1evpb0U3nmv368VE7zjPsl8y2OpvOn1epw5O8O5lke+sJ5Dr73EhpROLBalVCoxVbGID02QHR4mGokSi8WXtfNYSq1cQlGVFRuMnudx8uhhHF+SMJNs3LjohHvwwEH++q//GoBsJsP4+gL3PfA2Nt52G5XSLN12Z3BfzTBI54b46mGbtiuY6erUXY9YNEpUjWJ1BHQ6GBEDoQfiLqLCz99l8Mw5lwNlnwZxOrpKpTRH3NDeNKv3UGC9hUxNTXF0skjZCvy//uYf9uNu2Yx0u6TcOg9vKSCbbTatS6IphBcnISE3GPl8npwZJR651K/WOAzH8TyPlmXRbFr0uhKJgd3tcrpco1otMzc1ScLucVvuPrR4gnxcZzylkowI2o6P4wcbOKZpXvTZut0u1WqVWq0WpG6sgqqqRIY34mpRZpoem9IJWkoUiyj4EClsxp05TCKZIplOUSrN8OqpuWVj5BIGuVwu/A67AQisj3223HEP2nmpTudqHXjtAGZUZ893nmDjbRvZumUrQ8ND5OIadkxFUwQ7duwI64VDbklWqyUCiMViy1p8bNu2bc3PUa/X2bFjx5of/0bUajW+VZvDUzS2bx7HnjnKllyEu+/+/9s70yi5qutQf7tuzdXVg1qtbk0tCQkNCCQzD2JyAhgHbCcGbF4cEycQYr+Y5yTrOc/OsrEd7JU4iZ04WeElcUjixH7xkMHYiRM7BgMBHDPKGBBIAoGGbg0t9VjzrTrvx7lVqla35u6q6sP+1mKhrrpVdb57695d+55z9lnP1q1bCb+0A9JRklGhmB8nn7dD2hOJBMlEclK12q4lR5v36zH/vA0AbN++na7E4dds2fwjyplhAIYywwzt2cHmJ/6bzs5ONmzcwIYNG1i+fPmka0xbrETWr9C/9hzaTJ5cPgfGVslNJpIkk0nGyyFgnGTUY/3aVeziEC8c3Etq3gJWrVvE5h89ymyiCVYDGRkZYTxfom/5mSTa0uz45mNEgOL+13nTohLdoXbSnWnO6F/CWWedRTI5tWtVUZTWJZVK8ZbrrqVYLB5/46OQy+UYHh7miSeeIFPZS1d7O8PhEAvjZTqK21nYu4KQF2J0JEk8HufGM1MgsH37IKtWHa+oRQqYBwZ279nNs88+y+ZnNzM8PDxpq7YN15JcfSl7M2VWzouQWroettq7iH7bAtZsaKNQLNDR1c3S/uW0pVK11x4Y3ENpdO8p+yuNwxgTJFhTFwYFyBbtMJpSPsO2bdvYtm0bTz/1NB/+8IcJhYRYNGJLVWtypShzlkgkgieC7/v4vk8iFmPx4sVs3LgR3/d5ZWCIYizOggUL8H2fbDZLLpdjdGSU0ZFRorEo8XicRCJxSnMwL990ObFYjBdfeHHSjb+RkREeefgRHnn4EdrSbaxbu45NmzbRv6yfmBcMa/SidHemqFQq5HI5crlcbV7zsB8G4kTFsG/fPpIRO1wwF1zXZhtNsBrIyMgI2WKZVfMX8KMnnqQY6yICmIn9XHD+tYwPHyCdjtLd3a3JlaLMUWKx2GkNN0in0yxYsABjDKPFJxn1CyRjURbOizOQDzFv3jxyuRwTGVv9SUJ2vbx8Pk+lUjmxH7sCS5YsYcmSJdx4w428vvN1Nm/ezE+e+wnDw8MkyxMADE7Y4cz7socHlPz4lQE6evJ0dtoCGrF4nGTqcM9ZNBandQvnKvX4vl9buLM6mb2ebNEe/4mRQ7XH1q5bSzwRJ5lIaFELRXGAWpXDUomyX6qd1yJCd3c3vQsW4Ce66VnQy/jEOJFIhPb29lqylc/n7RIfo2OEw2ESiQTxRJxYNHZC07vWrlvL2nVrKZVKbN26led+/BwvvPAC2ezhIe4T4xM8+eSTrF9/Fv3L+omH7Rvny3bIfHVJlOpajrl8nqEhO/Q9IhXK5TLJqO01y2iC5RbZbJZMLo94EWLxBN/73veIdL0JgP6uBLF4jAlTIRmN1n64KIryxqWzs5OudIrRg1lW9C+mNykc3DFEIpkgmUpiKoZ8IU8ulyOfyzM2NsbAwACxaMyWXY/HT+jHr4SE5cuXs3z5cn72HT/L7j272TeW5z+HbVl4gL2ZwwHpUNHjvr+6j9WrV/P+D7x/1vyV2cf2Xplpe6/gcA/W+PDhKoMXXnghAIm4JliK4gLVBMv3ffySP+m8ts9BoeyTTqdJp9OUK3Yx+omJiVqyVfbL5PKTe5BCoRCxeIxEPEE8HjtuJcJIJML69etZv349lXKZbdu389xzz/H8888zPmbfb/VqOxctFiRYuUKFP/iDP+CMFStYs2YtK1etJJGwRaJiuQiQJciragmW9mA5xsjICNlSmVS6nddff43nn3+eeW97KwBXvGktIQQqPolIeNoJk4qivLGwFQlDVCqGVCxMKhWnr6dCT3cXsXiKTCZDJjNRK007OjZKui1NPp+3QzcYxQt7JOL2Bk4sFjt+71bQs7XYGB750SgTRcN4oVJLtEylgpfqRGJJFi9ePNu7QJllSqUSZXOsBMv2YFWKdnjoihUr6O/vp62tDcHg6bpXijLnkeA8DoWgUMhNk2CFKNetN+WFPNrT7bSn26lUKjbZythkq62tjUqlQiGfJ5fPk8/lyQVFKqKxKPFY3A6hry9iOA0hz2PNmjWsWbOGm2+6mV27djG4d5B4whZ/iwdFNvbsH2JwYJDBgUEee+xxJCQsXbKU1atX4y05B0gTqyVY9jpXva7NNppgNYjR0VGyhTJt89r52j/+I5LsIhSJQTHDmcsXE4l4xCMeHR3teCew3oCiKG4Tj8dpSyaJhCdIRDw7oTiWIzs+QWfXfBKJBPPnz6dQKJDJZkglU3R0dtBBB2W/TL5gg1sma+80wuEAF4vFiEajR11Msr4s/LZDJbIlQ9yDRKjIcCVOeuEKVpyxopG7Q5kFqj1Y4fD0pdX3HbKLSJuSnRex6fJNdm23jg6y4+Pag6UojhCJRAiHQhTyObxQaEoPln+UpCQUCtV6toyp2EqjmQzZTJZEMNWlWCySz+ftUMLxMUZGRtgzsKcWi2Kx2JQ1GeuRkNC/rJ/+Zf21x6pDBPceODRpW1Mx7Ny5k507d5JcnaVtwzXkJ8aATh0i6CojIyNkimWGRrL88JmfEO21lWd6kyG7oBqQiHg6PFBRlBqdnZ0kIwdJRD2WLVvGnqERJsZHJ21TDVA9C3pYvny5HY6cyRDJRUilUmCgUCxQyBfIF2yAYwwQiEVjtncrOjXh6mvzeH3U59m99sf1wnSY+ckOnhwocNF17ySazDNaqBDOlvBDdROT82WyRaFiTEP2kXLqVHuwjrZI9PNbtkKkD1PM09PTwzlnn0M8HiceTzCuCwsrijPUerByOSIhpunBOv7MWpFQbb1Heqjd/Mtms0SjUdrbbY/X6OgoqWSqNqQQbKIWix2OR8dKuODwEMGlK1Zy1a/9T15+6WW2btvK7l27qIYeidrerq60TfQSOkTQDaqT9Uol+6UcHh7mazuT7CsU6XrLXbXtVvW2M3ZwP2Nln/lxj46OjmY1WVGUFqOjo4POZJR0Kklvby/JaJiBAwfZvuX5KdvueW07Ca++R8pQLBbJ5XMUCgUKBVvZsFKp4JdKFIpFisUifim4Myk2mEYjEebNX0Bvcj4AB4ICF31tHvOTNkA9d0h47lACdo9hs7UjSfJT52mC1eqUSiXKZYM3zY+ZgcEBdg7sI7asj0opx2WbLiMSjdDVaUvv+6XSpDvdiqLMXcLhMOGQkM/nSISP6MESauu3ngzVm3/zuuZRrpTJ5XJks1mSySSdXZ100lkbbWFjVGFKwhWNRe3/I9FJQwqrPViFCqxavYpVq1ZxAzeQy2bZvv0Vtm7byraKvValYtal2oOlQwTnODt37uTZF15mNGt/1Ez4wr5CG8ZUqOTGAehIJVgoGcLFEp2pGO2JMPPmzTvW2yqK8gaiu7ubjkSE7u5uOwwjGWdhuw/F4SnbRrJDxIvzJz0WB9rjQDxKpRIml89TyBfIVQqUwiUIg6mEKBaLFAoFSpkShVKJLQN7WLp2IwtibWTLQjQsrO4I0ZUKsyjtMZYrUzEVwp5HyPMIyeG5XeWyj6n4J1Q9SmkupVKJSgXCkak/Bb7yla9gPFv2vy0e5bJLLyMej9teUexx9kIctfdLUZS5Q7VUez6fJ9QeqZ3X4XAYLxTCP4EerGPhhTzaUm20pdro6+ujv7+/lnBF81HKZdur5Pt+LdmqT7gQiEajRKNRYtEoUbHJUt6ffCMvkUxyzoZzOGfDOdz/coYtQ6Wpc7BKZUwDRljolXGWGB4eZiRbJNrRS1u6nf1DBWAYRgc5+P376O/v54O//usM799DdzrOuevX0NfXpwUuFEWpMX/+fC6/fBPt7e2ICJs2bZqyZlWVRKjMpZdedMLvXSqVapWgstlsbf2RHTt28OLACOlElLcvr1AsFKlUKpTHJxiagOv7ohQLRUJeiEWLFtHT00NH++Ge98Fdr5PZ/xrJiK6N1OqUSiV8UyEantwLtXXbVh579DHaN/08AOdvPJtINEL3vO7aNr5fIiwhotHp528pijJ3OFxJsITnRWvndTgcJuyFbOfAiS4DcgJEI1GikWgtdhSLRZtw5WzZ92rCVSmXKQQ3AIvFIhMTE0wYmMiHgCQT+RJjY2P2/aKRSZUKC0HyVU2wvJAQC4co+BXypQqzjSZYs0S1qMXSxUtJtaV5dOA1AM5e3kdx02VceNFFRCJhJCjNvmLFitqdQUVRlCrd3Yd/1FYnE0/Hq6++Sn9//7TPnQjVhEtE2J/ZTsQTuubbHjHf9ykW7JDCYqmovVOOYNfBmrzIcKVSIRKJcNPNN/HgITt34ex1q0klU7WKlQB+ySeuPViK4gSRSAQvqMzniUw6r6u9W2XfJzRLN1SqvVPVaTLFUlAYI5cnl8/Vpttg7HP+SAH2lyn4hrHRw8PUvbBHNBIlEo2QLdoEK1pXNy4Z9Sj4lYYME9Qr4yxQLBYZH5+gZCCZaqNcKbN9n52Y3umV2HjtdbR32BKX+8s+qURckytFUZpKJBKhs7OTNWvWsHckSyneweLFi8nnC3YeV76AXw6CkoFSMGREq57OXYrFIuVKhXBdD9bQwSHK5TIrV67kKUJkKpCKhunp6Zn02rJfwvO0yIWiuEB1rhVA+IjiNdUEy/dLRBrUY13t4WpP21Fd5UqZfC5vq+Pm8xRMFhilLB6LFi+iVCxRLNmbgKViyfaGFZNAiFhdp1syGmY4WyJbmv1CF5pgzQKjo6PkSmVSbe0gsH/ffgbH7Q+T3lSI9vZ20m1pTNknEdXCFoqitA7V9bdGMxPE4wni8QSd2OqmftmvVSMsFopEIhFSQSleZe5he7AMnmd/CmQyGcbGxhgbG6NYKOKLvfG3sKd7Sk+V7/uEo5pgKYoL2CTKZiIhmSbB8mTSWliNxgt5pFKpWmdE13wfntpMoQxdXV12CGGhSMXYoX+mYvAHbMdGWzyKiM0ea4UuCppgzUlGRkbIFssk0/P4/c9+lrbuXsaj5xARw4q+LsLhMPN75jPw+g4tza4oSkvR0dFBIhImOzQ2Zcx92AsTToW1x90RautgRSLs2rWLkdERwl6YsbExwuEIxbL9UbJg/tQY5fslvLgmWIriAtUy7cCU5Rfq52e1ComIhwgUy4aued2EQyEMhlKxVCuQUazYBKujLV6rb1BfSXC2R7prgjUL2DWvfP7j/m/x2GOPE114Jp2bzqE3ZScE9y3swwt5TIyP0RnTHixFUVqHcDhMR3ua6L5xcpkJUmktvOMq1QRr/4H9fOqeTxMKhXj7295OT08P6a55GDLEwiEi00xsL/s+IYlogqUoDlDtpQKbYE03B+tUSrXPFiJCMuKRKZbJFcuk4yEEOVxpMJHCr7xGOCSsWXUGoZBNrOorCc72bUJNsE4SYwyDg4OHJ9wFZIplPvYfO7l6ZQdnyhB//uguxtMX0X3jxYhnA9DCdISQKTN68ACjwMToCIsWJLQHS1GUlqKjo4NkdB+Du3eSPskbQGOjw+isrLlBqVRi98AA3/iLv2U0mCj+9a9/nY989CNUxP48SEanP5q+X8ILRTXBUhQHiEQihEXwQrbgRHVIHVRLtcsJLTbcSJLRMJlimWyxTDo++TpULWKRiHq15Kr6N9ghgppgtRh79uzh8SeeIlOYnMk/P+zxzJ4or+wbpfDvnyX30x/Fq7vrJ8DKDhjdu5NSkEF3JT3akgmSOodBUZQWorOzk85klNGJIUYnhk7qtQKk4mEtfjEHePDBB7nvK/dTjrQhInhhj/f8wntob2+nkugCRmt3fOsxxlAplwl7Ia0iqCgOUB0G6IWmntO1IYKl1unBgrpkqTh1PlX1sSNvEDVysWG9Mp4khw4d4uBEkaKXJJE8nP/uLhYBn1E/zKHwIuaFQvij+1k8/Cw3vfOd9PX2kDkwQKIUY83yxbU5DH19fU0yURRFmZ7+/n678HDp1O5Yep7HsmXLZrhVykxx6NAhPvShD/HlL3+ZaN+ZeFEhEo1w2223cfb6s+nt7WXPhJ0sPl0Plh0eaH941d/pVhRlblJNokIhpvRKt+IcLIDUMZKlXFAlMHXEDaLq9SynVQRbj9HRUXJFn+VnraS9cx4AW7e+zDOvDELKlrFNrbkMgJ6E4X3Xv4vevl7a0+1sfvUluts9zjrrLJ13pShKyxIOh1m3bl2zm6HMMNlslnvvvZfPfOYzjIyMgIRAhI6Odm6/4w6WLVvGwr4+4vEEmYN2QevpEiw7PFB7rxTFFcLhsF3/KjS1cE0kEiHUYnOwoG4+1TQ9WNVRZokpPVh1r5nly5deHU+CSqUyuQQ7sPnHm7n743cz/x3/h+qAwOjCMwG46KwzWLp0CfF4grLvU8hnSfZ0HXWhUEVRFEWZDR588EFuueUWDh06dPjBUIgzzjiDX/ngb9Ld3U1vb28taaquEzPdEMGy7097p1tRlLlJOBzG80JTKghCMD8rJORbrAfrWEMEc8cbIljQBKuh7N27l7vvvpuOjg7uuusu+vv7a88VCgUef/xxXt8zSMhLs3/oAJlMhrZUGwuWnwmRWG1bCdYSOG+VTa4AMhNjJCK2YmBomopMiqIoinIi7Nq1iwceeIArrriClStXTnl+//79xONxkskkIyMj7Nq1C2MMY2NjtW0WLFjANdffQN/a8+nv76ejswOpK1xc/YFy5B1gsD1Y4VBIEyxFcQQJ1r6Khb1jDBFstR6sow8RPDwHa/ohgtkGzCdr6QRLRK4HvgB4wF8ZY35vtj7L931uuOEGnnnmGQD+6I/+iP7+flKpFKOjowwMDFAul7n6LTdy6fU/RyaToZAvUPJLnHneJrYB7RHDWCkocylCf/fhOVoTY2MkomEdGqgoiuIQjYxTAK+99hrnnXcew8PDiAjnnXceZ5xxBpVKhb179/LSSy9x8OBBPvnJT3LjjTcCUCwW8X2fSy+9lK1bt3Lbbbdx1VVX8crOPZTTfdNWsq3+QElNm2D5eKI9WIriEpFIhIg39cZJNcGqFFozwcpNV+SidLQerKMPK5xpWjbBEhEP+DPgWmA38KSIfMsY8+JsfN7nPve5WnIFUC6X2bFjx5TtXt25m8vDUfK5PNFohFg8RsfiM2GwwOWre/n+y0MU/QqLuxJEvMM9VbYHK6Ql2RVFURyh0XHK931uvfVWhoft/ChjDE8//TRPP/30lG23bNnClVdeSaVSwfM8urq6+MQnPkFbWxtLliyhVCpxaCLPmMSmvBYmlzk+knKpNO1QIkVR5i6RSIRo+OgJVqsVuagmS5npEqwgGTzmEMFZpmUTLOAiYLsx5lUAEfkq8A5gj16IhgAAEqRJREFUxgNXuVzmS1/60rTPhbsW0fXm2wGIRiNE0p08fCiNN1YACsSiUfaM2wPZ3xFhcXuUHYfyLE6HyYwfHo4xPjZKd2dYEyxFURR3aFicAti2bRubN2+e9rn0eTcSX34uAKFQiBfm9fD5J7O158PhPJFolLBXgGdfoZAvMJ6NUKoUSQ1smfJ+e0YLAHiV0qRYBpDNTuBNc6dbUZS5y7ETLLtu3pHXglMhl83MyPt4lSIAm3cOc3AsO+m5gbHpr18mSMZGckX+dXeY9VnhrafdkukRY8wsvfXpISI3A9cbY+4I/n4vcLEx5oN129wJ3AnQ29t7/le/+tVT+qyJiQkGBwf5xje+wbZt2/jwhz+M7/sMDQ0xWIzyn5x73PcIUeGneZ7X6WErCzmXHSySkTohWJL2uPjii2d9DtbExARtbW2z+hmNwBUPcMfFFY8qLvm44lL1uPrqq1u+/veJxKng8RmJVcPDw2zevJkvfvGLXHLJJVx44YUMDAwwNjbGyx0XsDd5xukJTcOlbGWeZKY8no7B+pXLWLp06Sm/twvfWRcc6nHFxxUPaJzLyy+/zIGhIdasXk1PT0/t8UqlwuM//CGDEzOTLxSKRWLR6Gm/z4hJ8hhrjrnNxWxjvkzU/jYGvs/ZFLFJ5IrwML+1qZtEInHSn3+8WDWnE6x6LrjgAvPUU0+d0mc99NBDrFy5kv379+P7Phs3biQejwMwmi3xtR88zdCBA7Xtk6mp6z/3pYRFbR5+xbB7vMKy9tCU9UEWLVrEqlWrTqmNJ8NDDz3E1VdfPeufM9u44gHuuLjiUcUlH1dc6jycSbDqOZ1Y9cADD9DT08P4+DjxeJzzzz+/9twLA6Pc/71HTul9p4tpAO1RYWXn1FgGturYhg0bTuuHnwvfWRcc6nHFxxUPaJzLgQMH2LFjBxs3biQWmzx0eMuWLRyo+x18Ojz77LOce+7xOy5OhFdHyowUps9j0lFh1TTXr6FchZ1jdp2/RV1Jbvnpi09pPb/jxapWHiK4B6i/NbYkeGxWWLJkCd3d3cTj8Uk9TB3JCHfecMlsfayiKIoyd2lonPI8j/Xr11MsFqfccV2/qIP173vbbH20oiiO09PTM6nnqp5169bN2NqIlUqFK6+8ckbea2beZXZo5XrhTwJnisgKEYkCtwLfmq0PExGSyaSWUFcURVFOlIbGKbBJ1qkMZ1EURVEaR8v2YBljfBH5IPBdbPnbvzbGvNDkZimKoigKoHFKURRFmZ6WTbAAjDHfAb7T7HYoiqIoynRonFIURVGORMfDKYqiKIqiKIqizBCaYCmKoiiKoiiKoswQmmApiqIoiqIoiqLMEJpgKYqiKIqiKIqizBCaYCmKoiiKoiiKoswQmmApiqIoiqIoiqLMEJpgKYqiKIqiKIqizBBijGl2G2YEETkAvH6KL58PDM1gc5qNKz6ueIA7Lq54VHHJxxWXqseQMeb6ZjdmptFYNQkXfFxwqMcVH1c8wC0XcMfnmLHKmQTrdBCRp4wxFzS7HTOFKz6ueIA7Lq54VHHJxxUXVzxmA9f2jQs+LjjU44qPKx7glgu443M8Dx0iqCiKoiiKoiiKMkNogqUoiqIoiqIoijJDaIJl+ctmN2CGccXHFQ9wx8UVjyou+bji4orHbODavnHBxwWHelzxccUD3HIBd3yO6aFzsBRFURRFURRFUWYI7cFSFEVRFEVRFEWZITTBUhRFURRFURRFmSHeMAmWiEiz2zCTuOajKLOFS+eKKy6ueMwGru0b13wUZTZw7Txxwed0Hd4wCZaDtAGIiNfshpwOIrK42W2YKUTkIhFpb3Y7ThcRebuIrGx2O2aQRPUfLlz0HaF23dJj4jxzPla5FKdAY1WLonGq9TitOOV8giUi14vI/cA9IjKnFzYTywIReQj4KwBjTLm5rTo1ROQaEXkaeH+z23K6iMhVIvIicCcwZ4NWcEx+CNwHLGx2e04XEblBRL4P/ImIvAfAzNGqPiLyNhH5B+AjIrKs2e05VeqOyedF5EqYu8dkptFY1Xq4FKdAY1Ur4lKcAjdi1UzFKScTrODiHheRvwU+hj0J24DbRWR+Uxt3GgQHOB/8t0FE3gogInPiOAbHJSoi9wJ/CNxjjPl4/fPNa92pISJx4EPA7xhj7jDG7A4enxMuwTFpE5FvY8+VjwH/DSwLnp8T360jEZHrgE8CXwCeAH5KRBY1tVGniIhcA3wc+BIQBu4SkRuC5+bM8RGR5cBngD8FtgB3isgdwXNzxmMm0VjVergYp0BjVSviUpwCN2LVTMapOSF8shhLHrgfuMoY8y3gn7Fl6Yea27pTJzi4S4DNwEeAuwGMMZVmtutECY5LEUgC3zTGfFNEQiKysfp8c1t4SiwGDhpjvioiCRF5p4j0EHQtt3rwCo7JBPBlY8zVxpgHgO8C7wienxPfrWm4CviuMebbwFNAxBgz0OQ2nSrXAP9qjPkP4C+ANPDLIpKaY8dnJfCoMeZ+4G+wPRt3iUiXMabS6ufKbKCxqvVwNE6BxqpWxKU4BW7EqhmLU04lWCLyv0Tk90TkXQDGmH8xxpSDv/8JWCsi94jI5c1t6YlR53MT1C4gA8Bq4DFgUETeLyJnNrOdx6PO493BQ/cAV4jIHwLPAJ8Wkb8Ukbc0r5UnRp3LzcFDJeDNwXfqm8BtwB9j70q1LHUetwAYY74WPB4ChoFdIhJrZhtPhiPPfeDfgF8Xkc8C3wGWicgXReTOYPuW/TExjcvjwCYRiRtj9mN7BTzgl5vWyBNARG4WkYvrHtoN3CQiMWNM3hjzENbt7qY0sIlorGo9XIpToLGqFXEpToEbsWo245QTCVbQdfwbwLuxdwE+JSLvE5HeYJP9wE9hs+sB4H3BnZuWZBqfTwc+84BVwI+Du5uPA58DPh+8LtysNk/HNB6fFJHbjTGvYC/wa4Pnfh54Hvg5adFhMdO43CMidxhjdmLvPt8H/KEx5meBTwNvF5GzWu1u5zQevxN8t3qg9sNoB3CDMabQxKaeEEc59+/ADrd4E9AD3GyMuQr4F+x3bHmrHRc4qssvAi9hr1tfF5EfYOdO3A+kpQWHXYide/Mw8CfAR6ttNMa8DPwn8NlgOwH+HFgqIr2teExmGo1VrRerXIpToLGqFXEpToEbsaoRcaplLnKngzHGiMibgY8ZY34gIhPAWwADfCnIQAEQkZ8AVwC5pjT2BDiKz/XYNj+Gvav2HezY48eAV4OXttQk4qN4/IyIvMsY86ci8jdBlz8ishm4BMg2s81H4ygubxV7t/OPgbsIhloYY7aIyONApHktnp5jnCtl4O+DbR4Xkd0i8vZgyFLLcoxz5d3GmK+IyApgMNj8J8A+7HWh5ZjGJQNchz0n7gA2AIuMMf8mdjL0ilYcdmGM2S+2WMP3gQ8Avwr83+DpTwHfFZEvGmNeEJE8MA5MNKe1jUVjVevFKpfiFGisakVcilPgRqxqRJxqqYzyVKjLip/CBiOC8Z9bgXUisvqIl1yHvfi3ZNA6hs/LwEbgXGwX5pPGmPXArcDVIrK4le52HMNjC3C+iKypBq2Aa7EnZ76hDT0BjuHyEnABMIadcPubIrJeRD4OnI09Ti3Dcc6V9SKyNtiuHetWakY7T5TjnCvnih2O9ADw+8F2v4SdhzDc4KYel6O4/Dv22FwIrDLGPGuM+bdgu/OBHzW8ocehzuNPgReB7wE3iMhCgKBX4D7gXrFDlX4BWAC0VPCdDTRWtV6scilOgcaqVsSlOAVuxKpGxak5l2BJsJZG0G1XP7FxO7Yb8pzg74eBDqBdbEWg94rIc8By4KOmRUrGnoTPI9gJg/uB9xtjPhFsfwjYZIzZ09CGH8FJHpd2rAsicquIPI+9w/nbrXCX4xRcVhhjfh/4MvBr2KExtxhjDja04UdwCudKW7DdGHaCei8txEn6JLFO9wJhseWi1wPvDfyaykm6pDl8vvyMiDyBPV/+qaGNnoajeRhjSsYYHzs07CVs9TKC534XG7xuB9YAtxtjWjKJOB00VrVerHIpToHGqlaMVS7FKXAjVjUrTs2ZBEtENonIl4CPici86h0wEal2bT8B+MB1IhI2xryIvQtwvrEVgXYBHzDG3Gbs5Lumcgo+L2C/qOcaY/Ii4tV9WZo2vOY0jkt1nZfXaZHjcoouC4HLAIwxfwd8yBjzi8aYwWk+oiHMwDEBuNUY87eNbPfROEWfpcBFwY+6/wG8yxjzbmPM3mY4VDmNY3Nh8Pw27I/Wm4wxTbvDeQyP2nUpYAj4FrBaRJaIHffeFZwrv2qMeVezj8lMo7Gq9WKVS3EKNFbRgrHKpTgFbsSqZsepOZFgicgZ2Az/B9gL9z0i8jNgM9Dg/9uxXZYrsWVhAQrYCyPGmIeMMY81uOnTcpo+rwXPl6tflmYxQ8flh8aY/2pw06dwmi7VeQW1bZvFTHy3gm1aYgjMafjkCY6LMSbbIj+KZuK832aMeaaxLZ/McTzKxhgjIjGxVZjKxphHgBewBQIeBuYH2xabYzB7aKxqvVjlUpwCjVW0YKxyKU6BG7GqFeLUnEiwgIuALcFdiv+NXVvjbRKMlxSRT4vIfcDT2IogF4ldff0Qdmxlq+GKz+l4fLc5TT4qekxay6OKSz6unC/H8/gd7Noh1b/fj51A/BfABmPMtmY0ukG49H0FN3xcOe+quHBMwB0PcMsF3Dhnmh+njDEt9x/wNuCDwCXB32dgKxD1B3+fBfwe8BvA5cD/w06sq76+DehstodrPq54uOTiioeLPq64zIDHNfV/u/SfK8fYJR8XHFz0ccXDNRdXfGbAYcbjVEv1YInIQhH5NvBbQBfwNyLyFmPMq8APgVuCTV/GduW1Az8xxvy8MWa7HK5jP2GMGWmCwiRc8XHFA9xxccWjiks+rrjMgEe1FPT3jR1O4gyuHOMqLvi44FCPKz6ueIBbLuCGTyvHqZZKsLATF//LGHOFMeYe4AvAncFz/wWcIyIXG1tVaQ9wpTFmFGzZRdMilX3qcMXHFQ9wx8UVjyou+bjicroeLVH9bpZw5RhXccHHBYd6XPFxxQPccgE3fFo2TjU9wRKR20TkahGJYdcC+Pu6pw9ia+uDraP/LPB5EWnDlrJ8XUSSMKl0ZFNxxccVD3DHxRWPKi75uOLiisds4Nq+ccHHBYd6XPFxxQPccgE3fOaKQ3g23/xoiIgAfdgxkBXgFeBXsGVDB0UkYmylkoXYLj+MLZH4BRFZBvw1tirIbcaYpq+o7oqPKx7gjosrHlVc8nHFxRWP2cC1feOCjwsO9bji44oHuOUCbvjMSQfT+IloXvD/1cCXq49hV1T+5yO2+TZwTfDvBcH/w0C60e123ccVD5dcXPFw0ccVF1c8dN+8MXxccHDRxxUP11xc8ZmrDg3rwRI7kewewBOR72AnmpXB1qQXkQ8BAyJylTHmYRGJAgeArSLyGeBGEbna2AXLxhvV7qPhio8rHuCOiyseVVzyccXFFY/ZwLV944KPCw71uOLjige45QJu+Mx1h4bMwRKRq7D18ruA7dgdVgLeLCIXQW0s5CeBTwUviwPvw46vTGMz0qasBn0krvi44gHuuLjiUcUlH1dcXPGYDVzbNy74uOBQjys+rniAWy7gho8LDo3q3rsCeG/d3/cCH8DuiKeDx0LY8ZVfB5ZgFwn7O+BNjWjjG9HHFQ+XXFzxcNHHFRdXPHTfvDF8XHBw0ccVD9dcXPFxwqFBOyoJxDg8RvI9wO8G/94M3BX8+wLgq83eKW8UH1c8XHJxxcNFH1dcXPHQffPG8HHBwUUfVzxcc3HFxwWHhgwRNMZkjTEFc7je/LXYcZIAvwSsE5F/Bf4B2yVYrRjSkrji44oHuOPiikcVl3xccXHFYzZwbd+44OOCQz2u+LjiAW65gBs+Ljg0tEx7MGHNAL3At4KHx4HfBs4Gdhhj9gCYIDVtZVzxccUD3HFxxaOKSz6uuLjiMRu4tm9c8HHBoR5XfFzxALdcwA2fuezQ6IWGK0AEGAI2BNnnx4GKMebR6k6aQ7ji44oHuOPiikcVl3xccXHFYzZwbd+44OOCQz2u+LjiAW65gBs+c9fBNH5c5SXYHfYocHujP1993PZwycUVDxd9XHFxxUP3zRvDxwUHF31c8XDNxRWfueogQeMbhogsAd4LfN4YU2joh88Crvi44gHuuLjiUcUlH1dcXPGYDVzbNy74uOBQjys+rniAWy7ghs9cdWh4gqUoiqIoiqIoiuIqjZ6DpSiKoiiKoiiK4iyaYCmKoiiKoiiKoswQmmApiqIoiqIoiqLMEJpgKYqiKIqiKIqizBCaYCmKoiiKoiiKoswQmmApiqIoiqIoiqLMEJpgKYqiKIqiKIqizBD/H23Erj1VKPlqAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, axs = subplots(ncols=2, nrows=2, figsize=(12, 9))\n", "\n", @@ -999,9 +1338,84 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hospventmort
2020-03-02000
2020-03-03000
2020-03-04000
2020-03-05000
2020-03-06100
\n", + "
" + ], + "text/plain": [ + " hosp vent mort\n", + "2020-03-02 0 0 0\n", + "2020-03-03 0 0 0\n", + "2020-03-04 0 0 0\n", + "2020-03-05 0 0 0\n", + "2020-03-06 1 0 0" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "extended_range = date_range(\n", " DATA_DF.index[0] - timedelta(int(OFFSET)), freq=\"D\", periods=OFFSET\n", @@ -1020,7 +1434,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1057,7 +1471,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -1075,7 +1489,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -1094,7 +1508,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1113,9 +1527,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checks passed\n" + ] + } + ], "source": [ "seir.check_call(xx, yy, pp)" ] @@ -1129,7 +1551,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "scrolled": false }, @@ -1140,9 +1562,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.54 s ± 255 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], "source": [ "%%timeit\n", "nonlinear_fit(data=(xx, yy), prior=pp, fcn=seir.fit_fcn, debug=False)" @@ -1150,9 +1580,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "x_prediction = xx.copy()\n", "tf = FORECAST_DF.iloc[:100]\n", @@ -1325,9 +1768,222 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Least Square Fit:\n", + " chi2/dof [dof] = 0.3 [94] Q = 1 logGBF = -318.38\n", + "\n", + "Parameters:\n", + " initial_exposed 21 (13) [ 160 (67) ] **\n", + " incubation_days 2.0 (1.0) [ 4.6 (1.5) ] *\n", + " beta 0.497 (92) [ 0.32 (12) ] *\n", + " recovery_days 16.4 (4.9) [ 15.3 (5.0) ] \n", + " nu 2.46 (25) [ 2.46 (25) ] \n", + " hospital_probability 0.0450 (20) [ 0.024 (10) ] **\n", + "hospital_length_of_stay 11.78 (80) [ 11.64 (83) ] \n", + " icu_probability 0.370 (35) [ 0.349 (39) ] \n", + " icu_length_of_stay 13.47 (89) [ 13.47 (89) ] \n", + " vent_probability 0.830 (89) [ 0.65 (17) ] *\n", + " vent_length_of_stay 18.5 (2.1) [ 19.5 (2.3) ] \n", + " L 0.829 (39) [ 0.37 (23) ] **\n", + " x0 29.73 (79) [ 20.7 (6.9) ] *\n", + " k 0.95 (37) [ 0.78 (43) ] \n", + "\n", + "Settings:\n", + " svdcut/n = 1e-12/1 tol = (1e-08,1e-10,1e-10*) (itns/time = 63/1.5)\n", + " fitter = scipy_least_squares method = trf\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PriorsPDF from normal approxPDF from general distsdiffz
hosp_prop0.024(10)0.0450(20)0.0235(30)0.0214(36)5.879241
incubation_days4.6(1.5)2.0(1.0)3.25(29)-1.3(1.1)1.181243
logistic_L0.37(23)0.829(39)0.787(19)0.042(44)0.960861
vent_prop0.65(17)0.830(89)0.764(40)0.067(98)0.686208
vent_LOS19.5(2.3)18.5(2.1)19.62(61)-1.2(2.2)0.540339
logistic_x020.7(6.9)25.73(79)25.41(42)0.32(89)0.357845
beta0.32(12)0.497(92)0.467(26)0.030(95)0.318960
hosp_LOS11.64(83)11.78(80)11.59(29)0.19(85)0.227801
nu2.46(25)2.46(25)2.440(73)0.02(26)0.082891
ICU_prop0.349(39)0.370(35)0.368(11)0.002(37)0.061055
recovery_days15.3(5.0)16.4(4.9)16.6(1.7)-0.2(5.1)0.031884
ICU_LOS13.47(89)13.47(89)13.45(26)0.02(92)0.022986
logistic_k0.78(43)0.95(37)0.94(14)0.007(399)0.018485
initial_exposed160(67)21(13)NaNnan +- 13.3117NaN
\n", + "
" + ], + "text/plain": [ + " Priors PDF from normal approx PDF from general dists \\\n", + "hosp_prop 0.024(10) 0.0450(20) 0.0235(30) \n", + "incubation_days 4.6(1.5) 2.0(1.0) 3.25(29) \n", + "logistic_L 0.37(23) 0.829(39) 0.787(19) \n", + "vent_prop 0.65(17) 0.830(89) 0.764(40) \n", + "vent_LOS 19.5(2.3) 18.5(2.1) 19.62(61) \n", + "logistic_x0 20.7(6.9) 25.73(79) 25.41(42) \n", + "beta 0.32(12) 0.497(92) 0.467(26) \n", + "hosp_LOS 11.64(83) 11.78(80) 11.59(29) \n", + "nu 2.46(25) 2.46(25) 2.440(73) \n", + "ICU_prop 0.349(39) 0.370(35) 0.368(11) \n", + "recovery_days 15.3(5.0) 16.4(4.9) 16.6(1.7) \n", + "ICU_LOS 13.47(89) 13.47(89) 13.45(26) \n", + "logistic_k 0.78(43) 0.95(37) 0.94(14) \n", + "initial_exposed 160(67) 21(13) NaN \n", + "\n", + " diff z \n", + "hosp_prop 0.0214(36) 5.879241 \n", + "incubation_days -1.3(1.1) 1.181243 \n", + "logistic_L 0.042(44) 0.960861 \n", + "vent_prop 0.067(98) 0.686208 \n", + "vent_LOS -1.2(2.2) 0.540339 \n", + "logistic_x0 0.32(89) 0.357845 \n", + "beta 0.030(95) 0.318960 \n", + "hosp_LOS 0.19(85) 0.227801 \n", + "nu 0.02(26) 0.082891 \n", + "ICU_prop 0.002(37) 0.061055 \n", + "recovery_days -0.2(5.1) 0.031884 \n", + "ICU_LOS 0.02(92) 0.022986 \n", + "logistic_k 0.007(399) 0.018485 \n", + "initial_exposed nan +- 13.3117 NaN " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "print(fit)\n", "\n",