diff --git a/clt_toolkit/base_components.py b/clt_toolkit/base_components.py
index 5f8d01d..69af008 100644
--- a/clt_toolkit/base_components.py
+++ b/clt_toolkit/base_components.py
@@ -1152,6 +1152,8 @@ def __init__(self,
 
         for model in self.subpop_models.values():
             model.metapop_model = self
+        
+        self.run_input_checks()
 
     def __getattr__(self, name):
         """
@@ -1163,6 +1165,16 @@ def __getattr__(self, name):
             return self.subpop_models[name]
         else:
             raise AttributeError(f"{type(self).__name__!r} object has no attribute {name!r}")
+    
+    def run_input_checks(self) -> None:
+        """
+        Run input checks to ensure that the provided inputs are valid.
+        Subclasses can override this method to add additional checks.
+        If inputs don't make sense we raise a MetapopModelError, and
+        in some cases only a warning is issued.
+        """
+        
+        pass
 
     def modify_simulation_settings(self,
                                    updates_dict: dict):
@@ -1241,7 +1253,6 @@ def simulate_until_day(self,
             self.apply_inter_subpop_updates()
 
             for subpop_model in self.subpop_models.values():
-
                 save_daily_history = subpop_model.simulation_settings.save_daily_history
                 timesteps_per_day = subpop_model.simulation_settings.timesteps_per_day
 
@@ -1433,6 +1444,8 @@ def __init__(self,
         self.state.schedules = self.schedules
 
         self.params = updated_dataclass(self.params, {"total_pop_age_risk": self.compute_total_pop_age_risk()})
+        
+        self.run_input_checks()
 
     def __getattr__(self, name):
         """
@@ -1512,6 +1525,19 @@ def get_start_real_date(self):
                 print("Error: The date format should be YYYY-MM-DD.")
 
         return start_real_date
+    
+    def run_input_checks(self) -> None:
+        """
+        Run input checks to ensure that the provided inputs are valid.
+        Subclasses can override this method to add additional checks.
+        If inputs don't make sense we raise a SubpopModelError, and
+        in some cases only a warning is issued.
+        """
+
+        # Check that all compartments have non-negative initial values
+        for compartment_name, compartment in self.compartments.items():
+            if np.any(compartment.init_val < 0):
+                raise SubpopModelError(f"Compartment '{compartment_name}' has negative initial values.")
 
     @abstractmethod
     def create_compartments(self) -> sc.objdict[str, Compartment]:
@@ -1805,6 +1831,8 @@ def update_compartments(self) -> None:
 
             # By construction (using binomial/multinomial with or without taylor expansion),
             #   more individuals cannot leave the compartment than are in the compartment
+            ## TODO check whether the following reason is still valid: a flooring function 
+            #  was added to transition variables when using Poisson distributed transitions
             # However, for Poisson any for ANY deterministic version, it is possible
             #   to have more individuals leaving the compartment than are in the compartment,
             #   and hence negative-valued compartments
@@ -1813,7 +1841,8 @@ def update_compartments(self) -> None:
             #   allows us to take derivatives in the torch implementation)
             # The syntax is janky here -- we want everything as an array, but
             #   we need to pass a tensor to the torch functional
-            if "deterministic" in self.simulation_settings.transition_type:
+            if ("deterministic" in self.simulation_settings.transition_type) and \
+               (self.simulation_settings.use_deterministic_softplus):
                 compartment.current_val = \
                         np.array(torch.nn.functional.softplus(torch.tensor(compartment.current_val)))
 
diff --git a/clt_toolkit/base_data_structures.py b/clt_toolkit/base_data_structures.py
index c7d9dc7..ac60881 100644
--- a/clt_toolkit/base_data_structures.py
+++ b/clt_toolkit/base_data_structures.py
@@ -44,6 +44,11 @@ class SimulationSettings:
             valid value must be from `TransitionTypes`, specifying
             the probability distribution of transitions between
             compartments.
+        use_deterministic_softplus (bool):
+            If the transition type used is deterministic this determines
+            whether we use a softplus function once compartment values are
+            updated. If true this matches the behavior of the torch
+            implementation of the model, if false true zeros are used.
         start_real_date (str):
             actual date in string format "YYYY-MM-DD" that aligns with the
             beginning of the simulation.
@@ -58,6 +63,7 @@ class SimulationSettings:
 
     timesteps_per_day: int = 7
     transition_type: str = TransitionTypes.BINOM
+    use_deterministic_softplus: bool = False
     start_real_date: str = "2024-10-31"
     save_daily_history: bool = True
     transition_variables_to_save: tuple = ()
diff --git a/clt_toolkit/plotting.py b/clt_toolkit/plotting.py
index ab63dd8..73fdd1f 100644
--- a/clt_toolkit/plotting.py
+++ b/clt_toolkit/plotting.py
@@ -120,6 +120,48 @@ def plot_metapop_epi_metrics(metapop_model: MetapopModel,
     for ix, (subpop_name, subpop_model) in enumerate(metapop_model.subpop_models.items()):
         plot_subpop_epi_metrics(subpop_model, axes[ix])
 
+@plot_subpop_decorator
+def plot_subpop_epi_metrics_justM(subpop_model: SubpopModel,
+                            ax: matplotlib.axes.Axes = None):
+    """
+    Plots EpiMetric history for a single subpopulation model on the given axis.
+
+    Args:
+        subpop_model (SubpopModel):
+            Subpopulation model containing compartments.
+        ax (matplotlib.axes.Axes):
+            Matplotlib axis to plot on.
+    """
+
+    # Compute summed history values for each age-risk group
+    history_vals_list = [np.average(age_risk_group_entry) for
+                         age_risk_group_entry in subpop_model.epi_metrics.M.history_vals_list]
+
+    # Plot data with a label
+    ax.plot(history_vals_list, label="M", alpha=0.6)
+
+    # Set axis title and labels
+    ax.set_title(f"M")
+    ax.set_xlabel("Days")
+    ax.set_ylabel("Epi Metric Value")
+    ax.legend()
+
+
+@plot_metapop_decorator
+def plot_metapop_epi_metrics_justM(metapop_model: MetapopModel,
+                             axes: matplotlib.axes.Axes):
+    """
+    Plots the EpiMetric data for a metapopulation model.
+
+    Args:
+        metapop_model (MetapopModel):
+            Metapopulation model containing compartments.
+        axes (matplotlib.axes.Axes):
+            Matplotlib axes to plot on.
+    """
+
+    for ix, (subpop_name, subpop_model) in enumerate(metapop_model.subpop_models.items()):
+        plot_subpop_epi_metrics_justM(subpop_model, axes[ix])
 
 @plot_subpop_decorator
 def plot_subpop_total_infected_deaths(subpop_model: SubpopModel,
@@ -175,6 +217,51 @@ def plot_metapop_total_infected_deaths(metapop_model: MetapopModel,
         plot_subpop_total_infected_deaths(subpop_model, axes[ix])
 
 
+@plot_subpop_decorator
+def plot_subpop_total_infected(subpop_model: SubpopModel,
+                                      ax: matplotlib.axes.Axes = None):
+    """
+    Plots data for a single subpopulation model on the given axis.
+
+    Args:
+        subpop_model (SubpopModel):
+            Subpopulation model containing compartments.
+        ax (matplotlib.axes.Axes):
+            Matplotlib axis to plot on.
+    """
+
+    infected_compartment_names = [name for name in subpop_model.compartments.keys() if
+                                  "I" in name or "H" in name]
+
+    infected_compartments_history = [subpop_model.compartments[compartment_name].history_vals_list
+                                     for compartment_name in infected_compartment_names]
+
+    total_infected = np.sum(np.asarray(infected_compartments_history), axis=(0, 2, 3))
+
+    ax.plot(total_infected, label="Total infected", alpha=0.6)
+
+    ax.set_title(f"{subpop_model.name}")
+    ax.set_xlabel("Days")
+    ax.set_ylabel("Number of individuals")
+    ax.legend()
+
+@plot_metapop_decorator
+def plot_metapop_total_infected(metapop_model: MetapopModel,
+                                       axes: matplotlib.axes.Axes):
+    """
+    Plots the total infected (IP+IS+IA) data for a metapopulation model.
+
+    Args:
+        metapop_model (MetapopModel):
+            Metapopulation model containing compartments.
+        axes (matplotlib.axes.Axes):
+            Matplotlib axes to plot on.
+    """
+
+    # Iterate over subpop models and plot
+    for ix, (subpop_name, subpop_model) in enumerate(metapop_model.subpop_models.items()):
+        plot_subpop_total_infected(subpop_model, axes[ix])
+
 @plot_subpop_decorator
 def plot_subpop_basic_compartment_history(subpop_model: SubpopModel,
                                           ax: matplotlib.axes.Axes = None):
@@ -219,3 +306,54 @@ def plot_metapop_basic_compartment_history(metapop_model: MetapopModel,
     # Iterate over subpop models and plot
     for ix, (subpop_name, subpop_model) in enumerate(metapop_model.subpop_models.items()):
         plot_subpop_basic_compartment_history(subpop_model, axes[ix])
+
+@plot_subpop_decorator
+def plot_subpop_TransitionVariable(subpop_model: SubpopModel,
+                     ax: matplotlib.axes.Axes = None):
+    """
+    Plots the values for a given transition variable for a subpopulation model.
+
+    Args:
+        subpop_model (SubpopModel):
+            Subpopulation model containing transition variables.
+        axes (matplotlib.axes.Axes):
+            Matplotlib axes to plot on.
+    """
+    #transition_history = subpop_model.transition_variables.R_to_S.history_vals_list
+    transition_history = np.array(subpop_model.transition_variables.ISH_to_HR.history_vals_list) + \
+        np.array(subpop_model.transition_variables.ISH_to_HD.history_vals_list)
+
+    #transition_history is AxR matrix, so need to sum over all entries 
+    #total_infected = np.sum(np.asarray(infected_compartments_history), axis=(0, 2, 3))
+    total = [np.sum(age_risk_group_entry)
+                  for age_risk_group_entry
+                  in transition_history]
+    
+    # Aggregate to daily values if needed
+    timesteps_per_day = subpop_model.simulation_settings.timesteps_per_day
+    if timesteps_per_day > 1:
+        total = np.array(total).reshape(-1, timesteps_per_day).sum(axis=1)
+
+    #ax.plot(total, label="R to S", alpha=0.6)
+    ax.plot(total, label="ISH to HR and HD", alpha=0.6)
+
+    ax.set_title(f"{subpop_model.name}")
+    ax.set_xlabel("Days")
+    ax.set_ylabel("Number of individuals")
+    ax.legend()
+
+@plot_metapop_decorator
+def plot_metapop_TransitionVariable(metapop_model: MetapopModel,
+                             axes: matplotlib.axes.Axes):
+    """
+    Plots the TransitionVariable for a metapopulation model.
+
+    Args:
+        metapop_model (MetapopModel):
+            Metapopulation model containing compartments.
+        axes (matplotlib.axes.Axes):
+            Matplotlib axes to plot on.
+    """
+
+    for ix, (subpop_name, subpop_model) in enumerate(metapop_model.subpop_models.items()):
+        plot_subpop_TransitionVariable(subpop_model, axes[ix])
diff --git a/developer_notes.md b/developer_notes.md
index 8c8b0fe..434c554 100644
--- a/developer_notes.md
+++ b/developer_notes.md
@@ -1,7 +1,20 @@
 # Journal
+
+## 2025 12 11
+Added input checks for subpop and metapop models.
+We check that humidity, vaccination, contact matrix, and initial compartment values are non-negative. All values at zero are possible but wouldn't make sense.
+For transition rates we need strictly positive values.
+For vaccination rates we check whether cumulative vaccination rates in each age-risk group are not exceeding 100% in any 365-day period. This only issues a warning.
+The mobility matrix (or travel_proportions) should have rows that sum to 1: this ensures people either travel to another subpopulation or stay in their home location.
+
+A new parameter called use_deterministic_softplus is added to the simulation settings. If the object oriented model is run with deterministic transitions this can be used to prevent softplus values instead of zeros in compartments, which leads to strange behaviors when epidemics occur in populations without any exposure.
+
+Small fixes were made to the travel model equations in the file `flu_travel_functions.py`.
+
 ## 2025 11 17 - Adding ghost compartments
 Updated website notation and made code updates in a lot of places.
 
+
 # For future developers (from LP)
 
 Technical notes
diff --git a/flu_core/flu_components.py b/flu_core/flu_components.py
index b5cc3e9..4a9e516 100644
--- a/flu_core/flu_components.py
+++ b/flu_core/flu_components.py
@@ -7,6 +7,7 @@
 from typing import Optional
 from abc import ABC
 import json
+import warnings
 
 from functools import reduce
 
@@ -581,9 +582,9 @@ class FluContactMatrix(clt.Schedule):
             -- "date" entries must correspond to consecutive calendar
             days and must either be strings with `"YYYY-MM-DD"` format
             or `datetime.date` object and "is_school_day" and
-            "is_work_day" entries are Booleans indicating if that date is
-            a school day or work day. Identical to `FluSubpopSchedules` field
-            of same name.
+            "is_work_day" entries are floats between 0 and 1 indicating if 
+            that date is a school day or work day. Identical to 
+            `FluSubpopSchedules` field of same name.
 
     See parent class docstring for other attributes.
     """
@@ -739,6 +740,185 @@ def __init__(self,
         # creates deep copies.
         super().__init__(state, params, simulation_settings, RNG, name)
 
+    def check_humidity_input(self) -> None:
+        """
+        Check that absolute humidity values are non-negative.
+        """
+
+        humidity_values = self.schedules['absolute_humidity'].timeseries_df['absolute_humidity'].values
+        if np.any(humidity_values < 0):
+            raise FluSubpopModelError("Error: absolute humidity values must be non-negative.")
+    
+    def check_vaccination_input(self) -> None:
+        """
+        Check that vaccination values are positive.
+        If vaccinations exceed 100% over a year, issue a warning.
+        """
+        
+        df_vaccine = self.schedules['daily_vaccines'].timeseries_df.copy()
+        
+        ## Check all entries are positive
+        all_positive = all([
+            (x >= 0).all() for x in df_vaccine['daily_vaccines'].values
+            ])
+        if not(all_positive):
+            raise FluSubpopModelError("Error: vaccination values must be non-negative.")
+        
+        ## Check cumulative vaccination never exceeds 100% over 365 days
+        df_vaccine['datetime'] = pd.to_datetime(df_vaccine['date'])
+        df_vaccine.set_index('datetime', inplace=True)
+
+        # Ensure there is one row per day within time range
+        full_date_range = pd.date_range(start=df_vaccine.index.min(), end=df_vaccine.index.max(), freq='D')
+        df_vaccine = df_vaccine.reindex(full_date_range)
+
+        # Replace NAs due to reindexing (if any)
+        na_rows = df_vaccine['daily_vaccines'].isna()
+        value_shape = df_vaccine['daily_vaccines'].values[0].shape
+        df_vaccine.loc[na_rows, 'daily_vaccines'] = \
+            pd.Series(
+                [np.zeros(value_shape)] * na_rows.sum(), 
+                index=df_vaccine.loc[na_rows].index
+                )
+
+        # Calculate rolling 1-year sum of vaccination rates
+        window_size_days = min(365, len(df_vaccine))
+
+        data_windows = np.lib.stride_tricks.sliding_window_view(
+            df_vaccine['daily_vaccines'].values, 
+            window_size_days
+            )
+        vaccines_rolling_sum = np.sum(data_windows, axis=-1)
+
+        # Check whether any cumulative vaccinations exceed 100%
+        max_values_above_one = [x.max() > 1 for x in vaccines_rolling_sum]
+
+        # Find first index rolling sum exceeds 100% for some age group (if there is one)
+        if sum(max_values_above_one) > 0:
+            first_exceeds_idx = max_values_above_one.index(True)
+            
+            vaccines_cml_exceeds = vaccines_rolling_sum[first_exceeds_idx]
+            exceeds_first_date = df_vaccine['date'].values[first_exceeds_idx + window_size_days - 1]
+            
+            msg = 'Cumulative vaccination over a 365-day period exceeds 100% on (at least) ' +\
+                f'the following date: {exceeds_first_date}. Cumulative vaccination by that date is \n' +\
+                str(vaccines_cml_exceeds)
+            warnings.warn(msg)
+        
+    def check_calendar_variables_input(self) -> None:
+        """
+        Check school and calendar variables in flu_contact_matrix
+        schedule are between 0 and 1
+        """
+        
+        flu_contact_matrix = self.schedules['flu_contact_matrix'].timeseries_df
+        
+        for variable in ['is_school_day', 'is_work_day']:
+            values = flu_contact_matrix[variable].values
+            
+            if (values.min() < 0) or (values.max() > 1):
+                msg = f'Error: {variable} values must be between 0 and 1.'
+                raise FluSubpopModelError(msg)
+    
+    def check_contact_matrix_input(self) -> None:
+        """
+        Check contact matrix entries are non-negative.
+        Check total contact is greater than the sum of the
+        school and work matrices.
+        """   
+        
+        if not(np.all(self.params.total_contact_matrix >= 0)):
+            raise FluSubpopModelError(
+                'Some entries of the total contact matrix are negative \n'+\
+                f'{self.params.total_contact_matrix}'
+                )
+        
+        if not(np.all(self.params.school_contact_matrix >= 0)):
+            raise FluSubpopModelError(
+                'Some entries of the school contact matrix are negative \n'+\
+                f'{self.params.school_contact_matrix}'
+                )
+        
+        if not(np.all(self.params.work_contact_matrix >= 0)):
+            raise FluSubpopModelError(
+                'Some entries of the work contact matrix are negative \n'+\
+                f'{self.params.work_contact_matrix}'
+                )
+        
+        if not(np.all((
+            self.params.total_contact_matrix - self.params.school_contact_matrix - 
+            self.params.work_contact_matrix) >= 0)):
+            raise FluSubpopModelError(
+                'The total contact matrix must be at least greater than the sum of ' +\
+                'the work and school contact matrices.'
+            )
+    
+    def check_rate_input(self) -> None:
+        """
+        Ensure all rate values are strictly positive, and other
+        variables (waning, saturation, reductions) are non-negative.
+        """
+        
+        p = self.params
+        rates_list = [
+            p.R_to_S_rate, p.E_to_I_rate, p.IP_to_IS_rate, p.ISH_to_H_rate,
+            p.ISR_to_R_rate, p.IA_to_R_rate, p.HR_to_R_rate, p.HD_to_D_rate,
+            p.E_to_IA_prop]
+        
+        other_params_list = [
+            p.humidity_impact, p.inf_induced_saturation, p.inf_induced_immune_wane,
+            p.vax_induced_saturation, p.vax_induced_immune_wane, p.inf_induced_inf_risk_reduce,
+            p.inf_induced_hosp_risk_reduce, p.inf_induced_death_risk_reduce, 
+            p.vax_induced_inf_risk_reduce, p.vax_induced_hosp_risk_reduce,
+            p.vax_induced_death_risk_reduce, p.IP_relative_inf,
+            p.IA_relative_inf, p.relative_suscept,
+            p.ISH_to_HD_prop, p.IP_to_ISH_prop, p.beta_baseline
+        ]
+        
+        for value in rates_list:
+            if not(np.all(value > 0)):
+                raise FluSubpopModelError('All transition rates must be strictly positive values.')
+            
+        for value in other_params_list:
+            if not(np.all(value >= 0)):
+                raise FluSubpopModelError('Some parameter values are negative.')
+        
+    def check_initial_compartment_input(self) -> None:
+        """
+        Ensure all initial compartment and saturation values are non-negative.
+        """
+        
+        compartments_list = ["S", "E", "IP", "ISR", "ISH", "IA", "HR", "HD", "R", "D"]
+        immunity_values_list = ["M", "MV"]
+
+        for state_name in compartments_list + immunity_values_list:
+            if not(np.all(getattr(self.state, state_name) >= 0)):
+                raise FluSubpopModelError(
+                    'Initial compartment and immunity values must be non-negative. ' +\
+                    f'{state_name} is negative: {getattr(self.state, state_name)} for subpopulation ' +\
+                    f'{self.name}.'
+                )
+    
+    def run_input_checks(self) -> None:
+        """
+        Check the following:
+            - if total vaccinations exceed 100% over a year we issue a warning
+            - school and work calendar variables must be between 0 and 1
+            - absolute humidity values, contact matrix entries, daily vaccination
+              must be non-negative
+            - total contact matrix must be greater than the sum of the school
+              and work contact matrices
+            - all rate values must be strictly positive
+            - initial compartmental values must be non-negative
+        """
+        
+        self.check_humidity_input()
+        self.check_vaccination_input()
+        self.check_calendar_variables_input()
+        self.check_contact_matrix_input()
+        self.check_rate_input()
+        self.check_initial_compartment_input()
+    
     def create_compartments(self) -> sc.objdict[str, clt.Compartment]:
 
         # Create `Compartment` instances S-E-IA-IP-IS-H-R-D (7 compartments total)
@@ -948,6 +1128,31 @@ def __init__(self,
         self._full_metapop_params_tensors = None
         self._full_metapop_state_tensors = None
         self._full_metapop_schedule_tensors = None
+    
+    def check_mobility_input(self) -> None:
+        """
+        Check that all elements of the mobility matrix are positive,
+        and that rows sum to 1.
+        """
+        
+        travel_proportions = self.mixing_params.travel_proportions
+        if np.any(travel_proportions < 0):
+            raise FluSubpopModelError(
+                f'All entries of the travel matrix must be non-negative:\n {travel_proportions}.')
+        
+        if not(np.allclose(travel_proportions.sum(axis=1), 1)):
+            raise FluSubpopModelError(
+                f'Rows of the travel matrix must all sum to 1:\n {travel_proportions}.')
+
+    def run_input_checks(self) -> None:
+        """
+        Check the following:
+            - rows of mobility matrix must sum to 1
+            - mobility matrix entries are between 0 and 1
+        """
+        
+        # Mobility matrix check
+        self.check_mobility_input()
 
     def modify_subpop_params(self,
                              subpop_name: str,
diff --git a/flu_core/flu_data_structures.py b/flu_core/flu_data_structures.py
index e3b67bc..7d9c70b 100644
--- a/flu_core/flu_data_structures.py
+++ b/flu_core/flu_data_structures.py
@@ -293,8 +293,8 @@ class FluSubpopSchedules:
             -- "date" entries must correspond to consecutive calendar
             days and must either be strings with `"YYYY-MM-DD"` format
             or `datetime.date` object and "is_school_day" and
-            "is_work_day" entries are Booleans indicating if that date is
-            a school day or work day
+            "is_work_day" entries are are floats between 0 and 1 
+            indicating if that date is a school day or work day
         daily_vaccines (pd.DataFrame):
             must have "date" and "daily_vaccines" -- "date" entries must
             correspond to consecutive calendar days and must either
diff --git a/flu_core/flu_travel_functions.py b/flu_core/flu_travel_functions.py
index 4327f4c..7f79eeb 100644
--- a/flu_core/flu_travel_functions.py
+++ b/flu_core/flu_travel_functions.py
@@ -91,9 +91,9 @@ def compute_effective_pop_LA(state: FluTravelStateTensors,
                               active_pop_LAR
 
     mobility_modifier = params.mobility_modifier[0, :, 0]
-
+    
     effective_pop_LA = precomputed.total_pop_LA + mobility_modifier * \
-                       torch.sum(outside_visitors_LAR + traveling_residents_LAR, dim=2)
+                       torch.sum(outside_visitors_LAR - traveling_residents_LAR, dim=2)
 
     return effective_pop_LA
 
@@ -143,7 +143,7 @@ def compute_local_to_local_exposure(flu_contact_matrix: torch.Tensor,
     # grab the first element of the risk dimension.
     mobility_modifier = mobility_modifier[location_ix, :, 0]
 
-    result = (1 - mobility_modifier * sum_residents_nonlocal_travel_prop[location_ix]) * \
+    result = np.maximum(0, (1 - mobility_modifier * sum_residents_nonlocal_travel_prop[location_ix])) * \
              torch.matmul(flu_contact_matrix[location_ix, :, :],
                           wtd_infectious_ratio_LLA[location_ix, location_ix, :])
 
@@ -229,6 +229,7 @@ def compute_total_mixing_exposure(state: FluTravelStateTensors,
     mobility_modifier = params.mobility_modifier
     flu_contact_matrix = state.flu_contact_matrix
     travel_proportions = params.travel_proportions
+
     sum_residents_nonlocal_travel_prop = precomputed.sum_residents_nonlocal_travel_prop
     wtd_infectious_ratio_LLA = compute_wtd_infectious_ratio_LLA(state, params, precomputed)
 
@@ -250,6 +251,9 @@ def compute_total_mixing_exposure(state: FluTravelStateTensors,
                                                                     l)
 
         for k in np.arange(L):
+            if k == l:
+                continue # no visit terms from a location to itself
+            
             raw_total_mixing_exposure = raw_total_mixing_exposure + \
                                         compute_outside_visitors_exposure(
                                             flu_contact_matrix,
diff --git a/flu_demo_2popAustin.ipynb b/flu_demo_2popAustin.ipynb
new file mode 100644
index 0000000..dcd55c1
--- /dev/null
+++ b/flu_demo_2popAustin.ipynb
@@ -0,0 +1,1474 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "42ab1932-d72e-45f2-b27e-c628c62d08a1",
+   "metadata": {},
+   "source": [
+    "# Overview"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5884588d-2b40-45ff-adcd-94dfd0fc0463",
+   "metadata": {},
+   "source": [
+    "Simple demo with flu model with \"toy\" (not necessarily realistic or finalized) parameters\n",
+    "\n",
+    "We go over\n",
+    "- How to set up subpopulation models and metapopulation models.\n",
+    "- How to run accept-reject algorithm.\n",
+    "- How to run experiments to organize output of multiple replications. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01e5a95f-6833-4723-b369-e03eb1f64025",
+   "metadata": {},
+   "source": [
+    "# Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8948cfc7-d6fa-45b3-b98d-c7f81379ceec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Misc: suppress SSE4.2 deprecation warnings\n",
+    "# This is not an error, just a warning about future hardware compatibility (not relevant in general)\n",
+    "import os\n",
+    "os.environ[\"MKL_DEBUG_CPU_TYPE\"] = \"5\" \n",
+    "\n",
+    "from pathlib import Path\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Import city-level transmission base components module\n",
+    "import clt_toolkit as clt\n",
+    "\n",
+    "# Import flu model module, which contains customized subclasses\n",
+    "import flu_core as flu\n",
+    "\n",
+    "# Import immunity module, which contains some nice graphing functions\n",
+    "#import toy_immunity_core as imm\n",
+    "\n",
+    "import json"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71a20de2-2c0a-4d20-bcf6-af57f2a8a30f",
+   "metadata": {},
+   "source": [
+    "# Reading Input Files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "00b59007-7bde-4453-b6bd-943e7ad2e6b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that this can be cumbersome due to the complexity of the model \n",
+    "# Users may prefer to create the model inputs or even the models themselves in a separate .py file and import them! \n",
+    "\n",
+    "# Obtain path to folder with JSON input files\n",
+    "base_path = clt.utils.PROJECT_ROOT / \"flu_instances\" / \"austin_input_files\"\n",
+    "\n",
+    "# Get filepaths for east subpopulation\n",
+    "east_compartments_epi_metrics_init_vals_filepath = base_path / \"init_vals_east.json\"\n",
+    "\n",
+    "\n",
+    "# Read in files as dictionaries and dataframes for east subpopulation\n",
+    "# Note that we can also create these dictionaries directly\n",
+    "#   rather than reading from a predefined input data file.\n",
+    "east_state = clt.make_dataclass_from_json(east_compartments_epi_metrics_init_vals_filepath,\n",
+    "                                     flu.FluSubpopState)\n",
+    "east_vaccines_df = pd.read_csv(base_path / \"daily_vaccines_east.csv\", index_col=0)\n",
+    "\n",
+    "# Get filepaths for west subpopulation\n",
+    "west_compartments_epi_metrics_init_vals_filepath = base_path / \"init_vals_west.json\"\n",
+    "\n",
+    "# Read in files as dictionaries and dataframes for west subpopulation\n",
+    "# Note that we can also create these dictionaries directly\n",
+    "#   rather than reading from a predefined input data file.\n",
+    "west_state = clt.make_dataclass_from_json(west_compartments_epi_metrics_init_vals_filepath,\n",
+    "                                     flu.FluSubpopState)\n",
+    "west_vaccines_df = pd.read_csv(base_path / \"daily_vaccines_west.csv\", index_col=0)\n",
+    "\n",
+    "# Get filepaths for files shared across subpopulations\n",
+    "subpop_params_filepath = base_path / \"common_subpop_params.json\"\n",
+    "mixing_params_filepath = base_path / \"mixing_params.json\"\n",
+    "simulation_settings_filepath = base_path / \"simulation_settings.json\"\n",
+    "\n",
+    "calendar_df = pd.read_csv(base_path / \"school_work_calendar_austin_2023_2024.csv\", index_col=0)\n",
+    "humidity_df = pd.read_csv(base_path / \"absolute_humidity_austin_2023_2024.csv\", index_col=0)\n",
+    "\n",
+    "# Read in files as dictionaries and dataframes for files shared across subpopulations\n",
+    "# Note that we can also create these dictionaries directly\n",
+    "#   rather than reading from a predefined input data file.\n",
+    "params = clt.make_dataclass_from_json(subpop_params_filepath, flu.FluSubpopParams)\n",
+    "mixing_params = clt.make_dataclass_from_json(mixing_params_filepath, flu.FluMixingParams)\n",
+    "settings = clt.make_dataclass_from_json(simulation_settings_filepath, flu.SimulationSettings)\n",
+    "\n",
+    "# Set the schedules for each subpopulation\n",
+    "east_schedules_info = flu.FluSubpopSchedules(absolute_humidity=humidity_df,\n",
+    "                                        flu_contact_matrix=calendar_df,\n",
+    "                                        daily_vaccines=east_vaccines_df)\n",
+    "west_schedules_info = flu.FluSubpopSchedules(absolute_humidity=humidity_df,\n",
+    "                                        flu_contact_matrix=calendar_df,\n",
+    "                                        daily_vaccines=west_vaccines_df)\n",
+    "\n",
+    "# Create two independent bit generators\n",
+    "bit_generator = np.random.MT19937(88888)\n",
+    "jumped_bit_generator = bit_generator.jumped(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d1ab0b6c-6e75-4473-9e86-dac59e2d44fe",
+   "metadata": {},
+   "source": [
+    "# Creating Subpopulation Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9b601dd8-4d09-4bbb-a1e9-3b7d689b48fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create two subpopulation models, one for the east\n",
+    "#   side of the city and one for the west side of the city\n",
+    "# In this case, these two (toy) subpopulations have the\n",
+    "#   same demographics, initial compartment and epi metric values,\n",
+    "#   fixed parameters, and school-work calendar.\n",
+    "# If we wanted the \"east\" subpopulation and \"west\"\n",
+    "#   subpopulation to have different aforementioned values,\n",
+    "#   we could read in two separate sets of files -- one\n",
+    "#   for each subpopulation.\n",
+    "east = flu.FluSubpopModel(east_state,\n",
+    "                           params,\n",
+    "                           settings,\n",
+    "                           np.random.Generator(bit_generator),\n",
+    "                           east_schedules_info,\n",
+    "                           name=\"east\")\n",
+    "\n",
+    "west = flu.FluSubpopModel(west_state,\n",
+    "                           params,\n",
+    "                           settings,\n",
+    "                           np.random.Generator(jumped_bit_generator),\n",
+    "                           west_schedules_info,\n",
+    "                           name=\"west\")\n",
+    "\n",
+    "# If a metapopulation model has N subpopulations that have most of their parameters in common,\n",
+    "#    users can make a JSON file with common parameters, and N smaller JSON files with\n",
+    "#    parameters that are specific to each subpopulation.\n",
+    "# We recommend using `clt_toolkit / utils` functions `updated_dataclass()` and `updated_dict()` for this."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a4aabdc-9883-4e45-a371-199b7145de25",
+   "metadata": {},
+   "source": [
+    "# Modifying Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a78193bf-7989-4779-91ab-5772771f7375",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.01745\n",
+      "[[0.278]\n",
+      " [0.278]\n",
+      " [0.278]\n",
+      " [0.278]\n",
+      " [0.278]]\n",
+      "[[0.228]\n",
+      " [0.228]\n",
+      " [0.228]\n",
+      " [0.228]\n",
+      " [0.228]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We can also manually change a fixed parameter value\n",
+    "#   after we have created a SubpopModel -- like so...\n",
+    "# Note that this is quite a large and unrealistic value of\n",
+    "#   beta_baseline, but we'll use this to create\n",
+    "#   a dramatic difference between the two subpopulations.\n",
+    "#east.params = clt.updated_dataclass(east.params, {\"beta_baseline\": 10})\n",
+    "\n",
+    "# The structure of the code allows us to access\n",
+    "#   the current state and fixed parameters of each\n",
+    "#   subpopulation model.\n",
+    "# For example, here we print out the fixed parameter\n",
+    "#   value for beta_baseline for the \"west\" subpopulation.\n",
+    "print(params.beta_baseline)\n",
+    "print(west.state.MV)\n",
+    "print(east.state.MV)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eef0842e-bab0-4be0-a65a-9f48b7e6cfa9",
+   "metadata": {},
+   "source": [
+    "# Create Metapopulation Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f44aa524-3dc7-4010-9863-f0fc5b89585e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Combine two subpopulations into one metapopulation model (travel model)\n",
+    "flu_demo_model = flu.FluMetapopModel([east, west],\n",
+    "                                     mixing_params)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f7a1c0e4-76e4-4d89-ab43-a8d67776cbec",
+   "metadata": {},
+   "source": [
+    "# Simulation and Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b3aa79bb-11df-47fc-b581-70849b26ca1a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 2023-10-20\n",
+      "180 2024-04-17\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the current real date of the simulation and the\n",
+    "#   current simulation day\n",
+    "print(flu_demo_model.current_simulation_day, flu_demo_model.current_real_date)\n",
+    "\n",
+    "# Simulate for a given number of days\n",
+    "flu_demo_model.simulate_until_day(180)\n",
+    "\n",
+    "# Get the current real date of the simulation and the\n",
+    "#   current simulation day\n",
+    "print(flu_demo_model.current_simulation_day, flu_demo_model.current_real_date)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "5c0e8cf6-8f53-485f-9bcd-84da258d8fc6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Generate simple compartment history plot for flu model\n",
+    "clt.plot_metapop_basic_compartment_history(flu_demo_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a63278ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "clt.plot_metapop_total_infected(flu_demo_model)x\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "97e9edf4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "clt.plot_metapop_TransitionVariable(flu_demo_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "44a27269",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "clt.plot_metapop_epi_metrics(flu_demo_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "27d96687",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.55\n",
+      "0.61\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print the %population exposed for east and west Austin,\n",
+    "# knowing that some individuals are exposed twice since have R to S, many protected by immunity, but possibly not all\n",
+    "print(round(np.sum(np.asarray(east.transition_variables.S_to_E.history_vals_list))/387413,2))\n",
+    "print(round(np.sum(np.asarray(west.transition_variables.S_to_E.history_vals_list))/543134,2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c9415928",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "82\n",
+      "193\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print the per capita number of hospitalizations for east and west Austin\n",
+    "east_IS_to_H = np.asarray(east.transition_variables.ISH_to_HR.history_vals_list) + \\\n",
+    "    np.asarray(east.transition_variables.ISH_to_HD.history_vals_list)\n",
+    "west_IS_to_H = np.asarray(west.transition_variables.ISH_to_HR.history_vals_list) + \\\n",
+    "    np.asarray(west.transition_variables.ISH_to_HD.history_vals_list)\n",
+    "eastHosp = round(np.sum(east_IS_to_H)/387413*100000)\n",
+    "westHosp = round(np.sum(west_IS_to_H)/543134*100000)\n",
+    "print(eastHosp)\n",
+    "print(westHosp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8805c193",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "a07f8aa2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "147"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Compute per capita hospitalization across Austin, weighted average of east and west\n",
+    "# For PHR7, which includes Austin, it was 89.2, flu_instances/texax_flu_hosp_rate_20232024/austin_flu_hosp_rate_20232024\n",
+    "round((eastHosp*387413+westHosp*543134)/(387413+543134))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9f84f62e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "63\n",
+      "62\n",
+      "62\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Timing of infected peak, first for East\n",
+    "# First need to sum over all \"I\" compartments\n",
+    "infected_compartment_names = [name for name in east.compartments.keys() if \"I\" in name or \"H\" in name]\n",
+    "infected_compartments_history = [east.compartments[compartment_name].history_vals_list for compartment_name in infected_compartment_names]\n",
+    "total_infectedE = np.sum(np.asarray(infected_compartments_history), axis=(0, 2, 3))\n",
+    "print(np.argmax(total_infectedE))\n",
+    "\n",
+    "# then for West\n",
+    "infected_compartment_names = [name for name in west.compartments.keys() if \"I\" in name or \"H\" in name]\n",
+    "infected_compartments_history = [west.compartments[compartment_name].history_vals_list for compartment_name in infected_compartment_names]\n",
+    "total_infectedW = np.sum(np.asarray(infected_compartments_history), axis=(0, 2, 3))\n",
+    "print(np.argmax(total_infectedW))\n",
+    "\n",
+    "# and finally total\n",
+    "total_infected = np.asarray(total_infectedE+total_infectedW)\n",
+    "print(np.argmax(total_infectedW))\n",
+    "# Peak hospitalizations was week of 12/30 in Austin and peak 7 day average was day of 1/4 in TX.  Peak infection usually occurs ~2 weeks prior or 12/21 (day 62).\n",
+    "# [Comparing peak ILI and peak in hospitalizations: https://www.cdc.gov/flu/whats-new/flu-summary-2023-2024.html]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "0e49b6d6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print the % of recovered that become susceptible again for east and west Austin\n",
+    "# It's the same since this is just based on rates of being recovered and going to susceptible, \n",
+    "#    which is same in two subpopulations\n",
+    "numRtoS_east = np.sum(np.asarray(east.transition_variables.R_to_S.history_vals_list))\n",
+    "numIAtoR_east = np.sum(np.asarray((east.transition_variables.IA_to_R.history_vals_list)))\n",
+    "numISRtoR_east = np.sum(np.asarray((east.transition_variables.ISR_to_R.history_vals_list)))\n",
+    "numHRtoR_east = np.sum(np.asarray((east.transition_variables.HR_to_R.history_vals_list)))\n",
+    "numR_east = numIAtoR_east + numISRtoR_east + numHRtoR_east\n",
+    "print(round(numRtoS_east/numR_east))\n",
+    "\n",
+    "numRtoS_west = np.sum(np.asarray(east.transition_variables.R_to_S.history_vals_list))\n",
+    "numIAtoR_west = np.sum(np.asarray((east.transition_variables.IA_to_R.history_vals_list)))\n",
+    "numISRtoR_west = np.sum(np.asarray((east.transition_variables.ISR_to_R.history_vals_list)))\n",
+    "numHRtoR_west = np.sum(np.asarray((east.transition_variables.HR_to_R.history_vals_list)))\n",
+    "numR_west = numIAtoR_west + numISRtoR_west + numHRtoR_west\n",
+    "print(round(numRtoS_west/numR_west))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "575a4a09",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([[0.27824262],\n",
+       "        [0.27824262],\n",
+       "        [0.27824262],\n",
+       "        [0.27824262],\n",
+       "        [0.27793717]]),\n",
+       " array([[0.2784772 ],\n",
+       "        [0.2784772 ],\n",
+       "        [0.2784772 ],\n",
+       "        [0.2784772 ],\n",
+       "        [0.27786715]]),\n",
+       " array([[0.27870527],\n",
+       "        [0.27870527],\n",
+       "        [0.27870527],\n",
+       "        [0.27870527],\n",
+       "        [0.27779145]]),\n",
+       " array([[0.27892385],\n",
+       "        [0.27892385],\n",
+       "        [0.27892385],\n",
+       "        [0.27892385],\n",
+       "        [0.27770711]]),\n",
+       " array([[0.27913447],\n",
+       "        [0.27913447],\n",
+       "        [0.27913447],\n",
+       "        [0.27913447],\n",
+       "        [0.27761566]]),\n",
+       " array([[0.27933416],\n",
+       "        [0.27933416],\n",
+       "        [0.27933416],\n",
+       "        [0.27933416],\n",
+       "        [0.27751414]]),\n",
+       " array([[0.27952593],\n",
+       "        [0.27952593],\n",
+       "        [0.27952593],\n",
+       "        [0.27952593],\n",
+       "        [0.27740557]]),\n",
+       " array([[0.27970684],\n",
+       "        [0.27970684],\n",
+       "        [0.27970684],\n",
+       "        [0.27970684],\n",
+       "        [0.27728701]]),\n",
+       " array([[0.27987689],\n",
+       "        [0.27987689],\n",
+       "        [0.27987689],\n",
+       "        [0.27987689],\n",
+       "        [0.27715848]]),\n",
+       " array([[0.28003762],\n",
+       "        [0.28003762],\n",
+       "        [0.28003762],\n",
+       "        [0.28003762],\n",
+       "        [0.27702151]]),\n",
+       " array([[0.28018606],\n",
+       "        [0.28018606],\n",
+       "        [0.28018606],\n",
+       "        [0.28018606],\n",
+       "        [0.27687316]]),\n",
+       " array([[0.28032374],\n",
+       "        [0.28032374],\n",
+       "        [0.28032374],\n",
+       "        [0.28032374],\n",
+       "        [0.27671495]]),\n",
+       " array([[0.28045068],\n",
+       "        [0.28045068],\n",
+       "        [0.28045068],\n",
+       "        [0.28045068],\n",
+       "        [0.27654692]]),\n",
+       " array([[0.28056543],\n",
+       "        [0.28056543],\n",
+       "        [0.28056543],\n",
+       "        [0.28056543],\n",
+       "        [0.27636763]]),\n",
+       " array([[0.28066801],\n",
+       "        [0.28066801],\n",
+       "        [0.28066801],\n",
+       "        [0.28066801],\n",
+       "        [0.27617711]]),\n",
+       " array([[0.28075846],\n",
+       "        [0.28075846],\n",
+       "        [0.28075846],\n",
+       "        [0.28075846],\n",
+       "        [0.2759754 ]]),\n",
+       " array([[0.28083829],\n",
+       "        [0.28083829],\n",
+       "        [0.28083829],\n",
+       "        [0.28083829],\n",
+       "        [0.27576402]]),\n",
+       " array([[0.28090605],\n",
+       "        [0.28090605],\n",
+       "        [0.28090605],\n",
+       "        [0.28090605],\n",
+       "        [0.27554154]]),\n",
+       " array([[0.28096175],\n",
+       "        [0.28096175],\n",
+       "        [0.28096175],\n",
+       "        [0.28096175],\n",
+       "        [0.27530798]]),\n",
+       " array([[0.28100544],\n",
+       "        [0.28100544],\n",
+       "        [0.28100544],\n",
+       "        [0.28100544],\n",
+       "        [0.27506339]]),\n",
+       " array([[0.28103714],\n",
+       "        [0.28103714],\n",
+       "        [0.28103714],\n",
+       "        [0.28103714],\n",
+       "        [0.2748078 ]]),\n",
+       " array([[0.28105689],\n",
+       "        [0.28105689],\n",
+       "        [0.28105689],\n",
+       "        [0.28105689],\n",
+       "        [0.27454127]]),\n",
+       " array([[0.2810647 ],\n",
+       "        [0.2810647 ],\n",
+       "        [0.2810647 ],\n",
+       "        [0.2810647 ],\n",
+       "        [0.27426381]]),\n",
+       " array([[0.28106062],\n",
+       "        [0.28106062],\n",
+       "        [0.28106062],\n",
+       "        [0.28106062],\n",
+       "        [0.27397549]]),\n",
+       " array([[0.28104468],\n",
+       "        [0.28104468],\n",
+       "        [0.28104468],\n",
+       "        [0.28104468],\n",
+       "        [0.27367632]]),\n",
+       " array([[0.28101541],\n",
+       "        [0.28101541],\n",
+       "        [0.28101541],\n",
+       "        [0.28101541],\n",
+       "        [0.27336488]]),\n",
+       " array([[0.28097433],\n",
+       "        [0.28097433],\n",
+       "        [0.28097433],\n",
+       "        [0.28097433],\n",
+       "        [0.27304268]]),\n",
+       " array([[0.28092148],\n",
+       "        [0.28092148],\n",
+       "        [0.28092148],\n",
+       "        [0.28092148],\n",
+       "        [0.27270977]]),\n",
+       " array([[0.28085688],\n",
+       "        [0.28085688],\n",
+       "        [0.28085688],\n",
+       "        [0.28085688],\n",
+       "        [0.27236618]]),\n",
+       " array([[0.28078057],\n",
+       "        [0.28078057],\n",
+       "        [0.28078057],\n",
+       "        [0.28078057],\n",
+       "        [0.27201196]]),\n",
+       " array([[0.28069405],\n",
+       "        [0.28069405],\n",
+       "        [0.28069405],\n",
+       "        [0.28069405],\n",
+       "        [0.27164862]]),\n",
+       " array([[0.28059588],\n",
+       "        [0.28059588],\n",
+       "        [0.28059588],\n",
+       "        [0.28059588],\n",
+       "        [0.27127472]]),\n",
+       " array([[0.28048607],\n",
+       "        [0.28048607],\n",
+       "        [0.28048607],\n",
+       "        [0.28048607],\n",
+       "        [0.27089028]]),\n",
+       " array([[0.28036762],\n",
+       "        [0.28036762],\n",
+       "        [0.28036762],\n",
+       "        [0.28036762],\n",
+       "        [0.27049832]]),\n",
+       " array([[0.28023611],\n",
+       "        [0.28023611],\n",
+       "        [0.28023611],\n",
+       "        [0.28023611],\n",
+       "        [0.27009442]]),\n",
+       " array([[0.28009602],\n",
+       "        [0.28009602],\n",
+       "        [0.28009602],\n",
+       "        [0.28009602],\n",
+       "        [0.26968306]]),\n",
+       " array([[0.27994588],\n",
+       "        [0.27994588],\n",
+       "        [0.27994588],\n",
+       "        [0.27994588],\n",
+       "        [0.2692628 ]]),\n",
+       " array([[0.27978424],\n",
+       "        [0.27978424],\n",
+       "        [0.27978424],\n",
+       "        [0.27978424],\n",
+       "        [0.26883217]]),\n",
+       " array([[0.27961262],\n",
+       "        [0.27961262],\n",
+       "        [0.27961262],\n",
+       "        [0.27961262],\n",
+       "        [0.2683927 ]]),\n",
+       " array([[0.27943251],\n",
+       "        [0.27943251],\n",
+       "        [0.27943251],\n",
+       "        [0.27943251],\n",
+       "        [0.26794591]]),\n",
+       " array([[0.27924246],\n",
+       "        [0.27924246],\n",
+       "        [0.27924246],\n",
+       "        [0.27924246],\n",
+       "        [0.26749033]]),\n",
+       " array([[0.27904249],\n",
+       "        [0.27904249],\n",
+       "        [0.27904249],\n",
+       "        [0.27904249],\n",
+       "        [0.267026  ]]),\n",
+       " array([[0.27883262],\n",
+       "        [0.27883262],\n",
+       "        [0.27883262],\n",
+       "        [0.27883262],\n",
+       "        [0.26655296]]),\n",
+       " array([[0.27861438],\n",
+       "        [0.27861438],\n",
+       "        [0.27861438],\n",
+       "        [0.27861438],\n",
+       "        [0.26607271]]),\n",
+       " array([[0.27838628],\n",
+       "        [0.27838628],\n",
+       "        [0.27838628],\n",
+       "        [0.27838628],\n",
+       "        [0.2655838 ]]),\n",
+       " array([[0.27814836],\n",
+       "        [0.27814836],\n",
+       "        [0.27814836],\n",
+       "        [0.27814836],\n",
+       "        [0.26508626]]),\n",
+       " array([[0.27790361],\n",
+       "        [0.27790361],\n",
+       "        [0.27790361],\n",
+       "        [0.27790361],\n",
+       "        [0.26458308]]),\n",
+       " array([[0.27764908],\n",
+       "        [0.27764908],\n",
+       "        [0.27764908],\n",
+       "        [0.27764908],\n",
+       "        [0.26407133]]),\n",
+       " array([[0.27738776],\n",
+       "        [0.27738776],\n",
+       "        [0.27738776],\n",
+       "        [0.27738776],\n",
+       "        [0.26355399]]),\n",
+       " array([[0.2771167 ],\n",
+       "        [0.2771167 ],\n",
+       "        [0.2771167 ],\n",
+       "        [0.2771167 ],\n",
+       "        [0.26302813]]),\n",
+       " array([[0.27683889],\n",
+       "        [0.27683889],\n",
+       "        [0.27683889],\n",
+       "        [0.27683889],\n",
+       "        [0.26249673]]),\n",
+       " array([[0.27655287],\n",
+       "        [0.27655287],\n",
+       "        [0.27655287],\n",
+       "        [0.27655287],\n",
+       "        [0.26195835]]),\n",
+       " array([[0.27626014],\n",
+       "        [0.27626014],\n",
+       "        [0.27626014],\n",
+       "        [0.27626014],\n",
+       "        [0.26141447]]),\n",
+       " array([[0.27595923],\n",
+       "        [0.27595923],\n",
+       "        [0.27595923],\n",
+       "        [0.27595923],\n",
+       "        [0.26086365]]),\n",
+       " array([[0.27565017],\n",
+       "        [0.27565017],\n",
+       "        [0.27565017],\n",
+       "        [0.27565017],\n",
+       "        [0.26030591]]),\n",
+       " array([[0.27533593],\n",
+       "        [0.27533593],\n",
+       "        [0.27533593],\n",
+       "        [0.27533593],\n",
+       "        [0.25974423]]),\n",
+       " array([[0.27501358],\n",
+       "        [0.27501358],\n",
+       "        [0.27501358],\n",
+       "        [0.27501358],\n",
+       "        [0.25917567]]),\n",
+       " array([[0.2746846 ],\n",
+       "        [0.2746846 ],\n",
+       "        [0.2746846 ],\n",
+       "        [0.2746846 ],\n",
+       "        [0.25860173]]),\n",
+       " array([[0.27434754],\n",
+       "        [0.27434754],\n",
+       "        [0.27434754],\n",
+       "        [0.27434754],\n",
+       "        [0.25802095]]),\n",
+       " array([[0.2740039 ],\n",
+       "        [0.2740039 ],\n",
+       "        [0.2740039 ],\n",
+       "        [0.2740039 ],\n",
+       "        [0.25743483]]),\n",
+       " array([[0.27365518],\n",
+       "        [0.27365518],\n",
+       "        [0.27365518],\n",
+       "        [0.27365518],\n",
+       "        [0.25684489]]),\n",
+       " array([[0.2732999 ],\n",
+       "        [0.2732999 ],\n",
+       "        [0.2732999 ],\n",
+       "        [0.2732999 ],\n",
+       "        [0.25624965]]),\n",
+       " array([[0.27293957],\n",
+       "        [0.27293957],\n",
+       "        [0.27293957],\n",
+       "        [0.27293957],\n",
+       "        [0.25565061]]),\n",
+       " array([[0.27257123],\n",
+       "        [0.27257123],\n",
+       "        [0.27257123],\n",
+       "        [0.27257123],\n",
+       "        [0.25504482]]),\n",
+       " array([[0.27219788],\n",
+       "        [0.27219788],\n",
+       "        [0.27219788],\n",
+       "        [0.27219788],\n",
+       "        [0.25443527]]),\n",
+       " array([[0.27181803],\n",
+       "        [0.27181803],\n",
+       "        [0.27181803],\n",
+       "        [0.27181803],\n",
+       "        [0.25382049]]),\n",
+       " array([[0.27143319],\n",
+       "        [0.27143319],\n",
+       "        [0.27143319],\n",
+       "        [0.27143319],\n",
+       "        [0.25320199]]),\n",
+       " array([[0.27104337],\n",
+       "        [0.27104337],\n",
+       "        [0.27104337],\n",
+       "        [0.27104337],\n",
+       "        [0.25257977]]),\n",
+       " array([[0.27064859],\n",
+       "        [0.27064859],\n",
+       "        [0.27064859],\n",
+       "        [0.27064859],\n",
+       "        [0.25195385]]),\n",
+       " array([[0.27024886],\n",
+       "        [0.27024886],\n",
+       "        [0.27024886],\n",
+       "        [0.27024886],\n",
+       "        [0.25132425]]),\n",
+       " array([[0.26984418],\n",
+       "        [0.26984418],\n",
+       "        [0.26984418],\n",
+       "        [0.26984418],\n",
+       "        [0.25069097]]),\n",
+       " array([[0.26943458],\n",
+       "        [0.26943458],\n",
+       "        [0.26943458],\n",
+       "        [0.26943458],\n",
+       "        [0.25005404]]),\n",
+       " array([[0.26902006],\n",
+       "        [0.26902006],\n",
+       "        [0.26902006],\n",
+       "        [0.26902006],\n",
+       "        [0.24941345]]),\n",
+       " array([[0.26860064],\n",
+       "        [0.26860064],\n",
+       "        [0.26860064],\n",
+       "        [0.26860064],\n",
+       "        [0.24876924]]),\n",
+       " array([[0.26817781],\n",
+       "        [0.26817781],\n",
+       "        [0.26817781],\n",
+       "        [0.26817781],\n",
+       "        [0.24812288]]),\n",
+       " array([[0.26775009],\n",
+       "        [0.26775009],\n",
+       "        [0.26775009],\n",
+       "        [0.26775009],\n",
+       "        [0.24747292]]),\n",
+       " array([[0.26731751],\n",
+       "        [0.26731751],\n",
+       "        [0.26731751],\n",
+       "        [0.26731751],\n",
+       "        [0.24681935]]),\n",
+       " array([[0.26688006],\n",
+       "        [0.26688006],\n",
+       "        [0.26688006],\n",
+       "        [0.26688006],\n",
+       "        [0.2461622 ]]),\n",
+       " array([[0.26643926],\n",
+       "        [0.26643926],\n",
+       "        [0.26643926],\n",
+       "        [0.26643926],\n",
+       "        [0.24550295]]),\n",
+       " array([[0.2659951 ],\n",
+       "        [0.2659951 ],\n",
+       "        [0.2659951 ],\n",
+       "        [0.2659951 ],\n",
+       "        [0.24484163]]),\n",
+       " array([[0.26554611],\n",
+       "        [0.26554611],\n",
+       "        [0.26554611],\n",
+       "        [0.26554611],\n",
+       "        [0.24417674]]),\n",
+       " array([[0.26509528],\n",
+       "        [0.26509528],\n",
+       "        [0.26509528],\n",
+       "        [0.26509528],\n",
+       "        [0.24351128]]),\n",
+       " array([[0.26463963],\n",
+       "        [0.26463963],\n",
+       "        [0.26463963],\n",
+       "        [0.26463963],\n",
+       "        [0.24284227]]),\n",
+       " array([[0.26418066],\n",
+       "        [0.26418066],\n",
+       "        [0.26418066],\n",
+       "        [0.26418066],\n",
+       "        [0.24217122]]),\n",
+       " array([[0.26371839],\n",
+       "        [0.26371839],\n",
+       "        [0.26371839],\n",
+       "        [0.26371839],\n",
+       "        [0.24149813]]),\n",
+       " array([[0.2632543 ],\n",
+       "        [0.2632543 ],\n",
+       "        [0.2632543 ],\n",
+       "        [0.2632543 ],\n",
+       "        [0.24082448]]),\n",
+       " array([[0.26278395],\n",
+       "        [0.26278395],\n",
+       "        [0.26278395],\n",
+       "        [0.26278395],\n",
+       "        [0.24014584]]),\n",
+       " array([[0.2623118 ],\n",
+       "        [0.2623118 ],\n",
+       "        [0.2623118 ],\n",
+       "        [0.2623118 ],\n",
+       "        [0.23946667]]),\n",
+       " array([[0.26183638],\n",
+       "        [0.26183638],\n",
+       "        [0.26183638],\n",
+       "        [0.26183638],\n",
+       "        [0.23878549]]),\n",
+       " array([[0.26135769],\n",
+       "        [0.26135769],\n",
+       "        [0.26135769],\n",
+       "        [0.26135769],\n",
+       "        [0.2381023 ]]),\n",
+       " array([[0.26087722],\n",
+       "        [0.26087722],\n",
+       "        [0.26087722],\n",
+       "        [0.26087722],\n",
+       "        [0.2374186 ]]),\n",
+       " array([[0.2603935 ],\n",
+       "        [0.2603935 ],\n",
+       "        [0.2603935 ],\n",
+       "        [0.2603935 ],\n",
+       "        [0.23673291]]),\n",
+       " array([[0.25990654],\n",
+       "        [0.25990654],\n",
+       "        [0.25990654],\n",
+       "        [0.25990654],\n",
+       "        [0.23604523]]),\n",
+       " array([[0.25941782],\n",
+       "        [0.25941782],\n",
+       "        [0.25941782],\n",
+       "        [0.25941782],\n",
+       "        [0.23535705]]),\n",
+       " array([[0.25892587],\n",
+       "        [0.25892587],\n",
+       "        [0.25892587],\n",
+       "        [0.25892587],\n",
+       "        [0.2346669 ]]),\n",
+       " array([[0.25843366],\n",
+       "        [0.25843366],\n",
+       "        [0.25843366],\n",
+       "        [0.25843366],\n",
+       "        [0.23397774]]),\n",
+       " array([[0.25793823],\n",
+       "        [0.25793823],\n",
+       "        [0.25793823],\n",
+       "        [0.25793823],\n",
+       "        [0.23328661]]),\n",
+       " array([[0.25743958],\n",
+       "        [0.25743958],\n",
+       "        [0.25743958],\n",
+       "        [0.25743958],\n",
+       "        [0.23259351]]),\n",
+       " array([[0.2569392 ],\n",
+       "        [0.2569392 ],\n",
+       "        [0.2569392 ],\n",
+       "        [0.2569392 ],\n",
+       "        [0.23189993]]),\n",
+       " array([[0.25643711],\n",
+       "        [0.25643711],\n",
+       "        [0.25643711],\n",
+       "        [0.25643711],\n",
+       "        [0.23120588]]),\n",
+       " array([[0.25593181],\n",
+       "        [0.25593181],\n",
+       "        [0.25593181],\n",
+       "        [0.25593181],\n",
+       "        [0.23050987]]),\n",
+       " array([[0.25542481],\n",
+       "        [0.25542481],\n",
+       "        [0.25542481],\n",
+       "        [0.25542481],\n",
+       "        [0.22981339]]),\n",
+       " array([[0.2549161 ],\n",
+       "        [0.2549161 ],\n",
+       "        [0.2549161 ],\n",
+       "        [0.2549161 ],\n",
+       "        [0.22911645]]),\n",
+       " array([[0.2544057 ],\n",
+       "        [0.2544057 ],\n",
+       "        [0.2544057 ],\n",
+       "        [0.2544057 ],\n",
+       "        [0.22841904]]),\n",
+       " array([[0.2538936 ],\n",
+       "        [0.2538936 ],\n",
+       "        [0.2538936 ],\n",
+       "        [0.2538936 ],\n",
+       "        [0.22772118]]),\n",
+       " array([[0.25337981],\n",
+       "        [0.25337981],\n",
+       "        [0.25337981],\n",
+       "        [0.25337981],\n",
+       "        [0.22702285]]),\n",
+       " array([[0.25286433],\n",
+       "        [0.25286433],\n",
+       "        [0.25286433],\n",
+       "        [0.25286433],\n",
+       "        [0.22632407]]),\n",
+       " array([[0.25234866],\n",
+       "        [0.25234866],\n",
+       "        [0.25234866],\n",
+       "        [0.25234866],\n",
+       "        [0.22562632]]),\n",
+       " array([[0.25182982],\n",
+       "        [0.25182982],\n",
+       "        [0.25182982],\n",
+       "        [0.25182982],\n",
+       "        [0.22492662]]),\n",
+       " array([[0.25131079],\n",
+       "        [0.25131079],\n",
+       "        [0.25131079],\n",
+       "        [0.25131079],\n",
+       "        [0.22422795]]),\n",
+       " array([[0.25079157],\n",
+       "        [0.25079157],\n",
+       "        [0.25079157],\n",
+       "        [0.25079157],\n",
+       "        [0.22353031]]),\n",
+       " array([[0.25026919],\n",
+       "        [0.25026919],\n",
+       "        [0.25026919],\n",
+       "        [0.25026919],\n",
+       "        [0.22283072]]),\n",
+       " array([[0.24974664],\n",
+       "        [0.24974664],\n",
+       "        [0.24974664],\n",
+       "        [0.24974664],\n",
+       "        [0.22213217]]),\n",
+       " array([[0.24922243],\n",
+       "        [0.24922243],\n",
+       "        [0.24922243],\n",
+       "        [0.24922243],\n",
+       "        [0.22143317]]),\n",
+       " array([[0.24869804],\n",
+       "        [0.24869804],\n",
+       "        [0.24869804],\n",
+       "        [0.24869804],\n",
+       "        [0.22073519]]),\n",
+       " array([[0.24817346],\n",
+       "        [0.24817346],\n",
+       "        [0.24817346],\n",
+       "        [0.24817346],\n",
+       "        [0.22003822]]),\n",
+       " array([[0.24764579],\n",
+       "        [0.24764579],\n",
+       "        [0.24764579],\n",
+       "        [0.24764579],\n",
+       "        [0.21933936]]),\n",
+       " array([[0.24711794],\n",
+       "        [0.24711794],\n",
+       "        [0.24711794],\n",
+       "        [0.24711794],\n",
+       "        [0.21864151]]),\n",
+       " array([[0.24658841],\n",
+       "        [0.24658841],\n",
+       "        [0.24658841],\n",
+       "        [0.24658841],\n",
+       "        [0.21794318]]),\n",
+       " array([[0.24605871],\n",
+       "        [0.24605871],\n",
+       "        [0.24605871],\n",
+       "        [0.24605871],\n",
+       "        [0.21724586]]),\n",
+       " array([[0.24552883],\n",
+       "        [0.24552883],\n",
+       "        [0.24552883],\n",
+       "        [0.24552883],\n",
+       "        [0.21654955]]),\n",
+       " array([[0.24499728],\n",
+       "        [0.24499728],\n",
+       "        [0.24499728],\n",
+       "        [0.24499728],\n",
+       "        [0.21585275]]),\n",
+       " array([[0.24446566],\n",
+       "        [0.24446566],\n",
+       "        [0.24446566],\n",
+       "        [0.24446566],\n",
+       "        [0.21515705]]),\n",
+       " array([[0.24393236],\n",
+       "        [0.24393236],\n",
+       "        [0.24393236],\n",
+       "        [0.24393236],\n",
+       "        [0.21446086]]),\n",
+       " array([[0.2433989 ],\n",
+       "        [0.2433989 ],\n",
+       "        [0.2433989 ],\n",
+       "        [0.2433989 ],\n",
+       "        [0.21376568]]),\n",
+       " array([[0.24286528],\n",
+       "        [0.24286528],\n",
+       "        [0.24286528],\n",
+       "        [0.24286528],\n",
+       "        [0.21307149]]),\n",
+       " array([[0.24232999],\n",
+       "        [0.24232999],\n",
+       "        [0.24232999],\n",
+       "        [0.24232999],\n",
+       "        [0.21237681]]),\n",
+       " array([[0.24179604],\n",
+       "        [0.24179604],\n",
+       "        [0.24179604],\n",
+       "        [0.24179604],\n",
+       "        [0.21168462]]),\n",
+       " array([[0.24126202],\n",
+       "        [0.24126202],\n",
+       "        [0.24126202],\n",
+       "        [0.24126202],\n",
+       "        [0.21099352]]),\n",
+       " array([[0.24072784],\n",
+       "        [0.24072784],\n",
+       "        [0.24072784],\n",
+       "        [0.24072784],\n",
+       "        [0.21030341]]),\n",
+       " array([[0.24019199],\n",
+       "        [0.24019199],\n",
+       "        [0.24019199],\n",
+       "        [0.24019199],\n",
+       "        [0.20961279]]),\n",
+       " array([[0.23965599],\n",
+       "        [0.23965599],\n",
+       "        [0.23965599],\n",
+       "        [0.23965599],\n",
+       "        [0.20892314]]),\n",
+       " array([[0.23912132],\n",
+       "        [0.23912132],\n",
+       "        [0.23912132],\n",
+       "        [0.23912132],\n",
+       "        [0.20823598]]),\n",
+       " array([[0.23858649],\n",
+       "        [0.23858649],\n",
+       "        [0.23858649],\n",
+       "        [0.23858649],\n",
+       "        [0.20754979]]),\n",
+       " array([[0.2380501 ],\n",
+       "        [0.2380501 ],\n",
+       "        [0.2380501 ],\n",
+       "        [0.2380501 ],\n",
+       "        [0.20686317]]),\n",
+       " array([[0.23751355],\n",
+       "        [0.23751355],\n",
+       "        [0.23751355],\n",
+       "        [0.23751355],\n",
+       "        [0.20617752]]),\n",
+       " array([[0.23697684],\n",
+       "        [0.23697684],\n",
+       "        [0.23697684],\n",
+       "        [0.23697684],\n",
+       "        [0.20549284]]),\n",
+       " array([[0.23644147],\n",
+       "        [0.23644147],\n",
+       "        [0.23644147],\n",
+       "        [0.23644147],\n",
+       "        [0.20481062]]),\n",
+       " array([[0.23590444],\n",
+       "        [0.23590444],\n",
+       "        [0.23590444],\n",
+       "        [0.23590444],\n",
+       "        [0.20412786]]),\n",
+       " array([[0.23536726],\n",
+       "        [0.23536726],\n",
+       "        [0.23536726],\n",
+       "        [0.23536726],\n",
+       "        [0.20344605]]),\n",
+       " array([[0.23483141],\n",
+       "        [0.23483141],\n",
+       "        [0.23483141],\n",
+       "        [0.23483141],\n",
+       "        [0.20276669]]),\n",
+       " array([[0.23429541],\n",
+       "        [0.23429541],\n",
+       "        [0.23429541],\n",
+       "        [0.23429541],\n",
+       "        [0.20208828]]),\n",
+       " array([[0.23376074],\n",
+       "        [0.23376074],\n",
+       "        [0.23376074],\n",
+       "        [0.23376074],\n",
+       "        [0.20141231]]),\n",
+       " array([[0.23322452],\n",
+       "        [0.23322452],\n",
+       "        [0.23322452],\n",
+       "        [0.23322452],\n",
+       "        [0.20073587]]),\n",
+       " array([[0.23268813],\n",
+       "        [0.23268813],\n",
+       "        [0.23268813],\n",
+       "        [0.23268813],\n",
+       "        [0.20006036]]),\n",
+       " array([[0.23215308],\n",
+       "        [0.23215308],\n",
+       "        [0.23215308],\n",
+       "        [0.23215308],\n",
+       "        [0.19938728]]),\n",
+       " array([[0.23161788],\n",
+       "        [0.23161788],\n",
+       "        [0.23161788],\n",
+       "        [0.23161788],\n",
+       "        [0.19871513]]),\n",
+       " array([[0.231084  ],\n",
+       "        [0.231084  ],\n",
+       "        [0.231084  ],\n",
+       "        [0.231084  ],\n",
+       "        [0.19804538]]),\n",
+       " array([[0.23054847],\n",
+       "        [0.23054847],\n",
+       "        [0.23054847],\n",
+       "        [0.23054847],\n",
+       "        [0.19737506]]),\n",
+       " array([[0.23001427],\n",
+       "        [0.23001427],\n",
+       "        [0.23001427],\n",
+       "        [0.23001427],\n",
+       "        [0.19670714]]),\n",
+       " array([[0.22947991],\n",
+       "        [0.22947991],\n",
+       "        [0.22947991],\n",
+       "        [0.22947991],\n",
+       "        [0.19604012]]),\n",
+       " array([[0.22894538],\n",
+       "        [0.22894538],\n",
+       "        [0.22894538],\n",
+       "        [0.22894538],\n",
+       "        [0.19537401]]),\n",
+       " array([[0.22841219],\n",
+       "        [0.22841219],\n",
+       "        [0.22841219],\n",
+       "        [0.22841219],\n",
+       "        [0.19471028]]),\n",
+       " array([[0.22787743],\n",
+       "        [0.22787743],\n",
+       "        [0.22787743],\n",
+       "        [0.22787743],\n",
+       "        [0.19404605]]),\n",
+       " array([[0.22734401],\n",
+       "        [0.22734401],\n",
+       "        [0.22734401],\n",
+       "        [0.22734401],\n",
+       "        [0.19338421]]),\n",
+       " array([[0.22681192],\n",
+       "        [0.22681192],\n",
+       "        [0.22681192],\n",
+       "        [0.22681192],\n",
+       "        [0.19272474]]),\n",
+       " array([[0.22627966],\n",
+       "        [0.22627966],\n",
+       "        [0.22627966],\n",
+       "        [0.22627966],\n",
+       "        [0.19206615]]),\n",
+       " array([[0.22574873],\n",
+       "        [0.22574873],\n",
+       "        [0.22574873],\n",
+       "        [0.22574873],\n",
+       "        [0.19140993]]),\n",
+       " array([[0.22521763],\n",
+       "        [0.22521763],\n",
+       "        [0.22521763],\n",
+       "        [0.22521763],\n",
+       "        [0.19075456]]),\n",
+       " array([[0.22468785],\n",
+       "        [0.22468785],\n",
+       "        [0.22468785],\n",
+       "        [0.22468785],\n",
+       "        [0.19010155]]),\n",
+       " array([[0.2241594 ],\n",
+       "        [0.2241594 ],\n",
+       "        [0.2241594 ],\n",
+       "        [0.2241594 ],\n",
+       "        [0.18945089]]),\n",
+       " array([[0.22362927],\n",
+       "        [0.22362927],\n",
+       "        [0.22362927],\n",
+       "        [0.22362927],\n",
+       "        [0.18879958]]),\n",
+       " array([[0.22310046],\n",
+       "        [0.22310046],\n",
+       "        [0.22310046],\n",
+       "        [0.22310046],\n",
+       "        [0.1881506 ]]),\n",
+       " array([[0.22257148],\n",
+       "        [0.22257148],\n",
+       "        [0.22257148],\n",
+       "        [0.22257148],\n",
+       "        [0.18750246]]),\n",
+       " array([[0.22204381],\n",
+       "        [0.22204381],\n",
+       "        [0.22204381],\n",
+       "        [0.22204381],\n",
+       "        [0.18685665]]),\n",
+       " array([[0.22151747],\n",
+       "        [0.22151747],\n",
+       "        [0.22151747],\n",
+       "        [0.22151747],\n",
+       "        [0.18621316]]),\n",
+       " array([[0.22098954],\n",
+       "        [0.22098954],\n",
+       "        [0.22098954],\n",
+       "        [0.22098954],\n",
+       "        [0.18556908]]),\n",
+       " array([[0.22046293],\n",
+       "        [0.22046293],\n",
+       "        [0.22046293],\n",
+       "        [0.22046293],\n",
+       "        [0.18492732]]),\n",
+       " array([[0.21993764],\n",
+       "        [0.21993764],\n",
+       "        [0.21993764],\n",
+       "        [0.21993764],\n",
+       "        [0.18428787]]),\n",
+       " array([[0.21941216],\n",
+       "        [0.21941216],\n",
+       "        [0.21941216],\n",
+       "        [0.21941216],\n",
+       "        [0.18364922]]),\n",
+       " array([[0.21888799],\n",
+       "        [0.21888799],\n",
+       "        [0.21888799],\n",
+       "        [0.21888799],\n",
+       "        [0.18301287]]),\n",
+       " array([[0.21836513],\n",
+       "        [0.21836513],\n",
+       "        [0.21836513],\n",
+       "        [0.21836513],\n",
+       "        [0.1823788 ]]),\n",
+       " array([[0.21784208],\n",
+       "        [0.21784208],\n",
+       "        [0.21784208],\n",
+       "        [0.21784208],\n",
+       "        [0.18174551]]),\n",
+       " array([[0.21732033],\n",
+       "        [0.21732033],\n",
+       "        [0.21732033],\n",
+       "        [0.21732033],\n",
+       "        [0.18111451]]),\n",
+       " array([[0.21679989],\n",
+       "        [0.21679989],\n",
+       "        [0.21679989],\n",
+       "        [0.21679989],\n",
+       "        [0.18048576]]),\n",
+       " array([[0.21628074],\n",
+       "        [0.21628074],\n",
+       "        [0.21628074],\n",
+       "        [0.21628074],\n",
+       "        [0.17985928]]),\n",
+       " array([[0.2157599 ],\n",
+       "        [0.2157599 ],\n",
+       "        [0.2157599 ],\n",
+       "        [0.2157599 ],\n",
+       "        [0.17923206]]),\n",
+       " array([[0.21524036],\n",
+       "        [0.21524036],\n",
+       "        [0.21524036],\n",
+       "        [0.21524036],\n",
+       "        [0.17860709]]),\n",
+       " array([[0.21472211],\n",
+       "        [0.21472211],\n",
+       "        [0.21472211],\n",
+       "        [0.21472211],\n",
+       "        [0.17798436]]),\n",
+       " array([[0.21420516],\n",
+       "        [0.21420516],\n",
+       "        [0.21420516],\n",
+       "        [0.21420516],\n",
+       "        [0.17736388]])]"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "west.epi_metrics.MV.history_vals_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f7c0559",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25194d91",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/flu_instances/austin_input_files/common_subpop_params.json b/flu_instances/austin_input_files/common_subpop_params.json
index 8aafb62..22cdee6 100644
--- a/flu_instances/austin_input_files/common_subpop_params.json
+++ b/flu_instances/austin_input_files/common_subpop_params.json
@@ -1,7 +1,7 @@
 {
 	"num_age_groups":5,
 	"num_risk_groups":1,
-	"beta_baseline": 0.01745,
+	"beta_baseline": 0.07,
 	"humidity_impact": 0.0119,
 	"inf_induced_saturation": 0.7,
 	"inf_induced_immune_wane": 0.01,
diff --git a/flu_instances/austin_input_files/init_vals_west.json b/flu_instances/austin_input_files/init_vals_west.json
index 8f288c1..6f8e4c5 100644
--- a/flu_instances/austin_input_files/init_vals_west.json
+++ b/flu_instances/austin_input_files/init_vals_west.json
@@ -5,9 +5,9 @@
 		[342610],
 		[117000],
 		[83514]],
-	"E": [[1],
-		[1],
-		[10],
+	"E": [[5],
+		[5],
+		[50],
 		[0],
 		[0]],
 	"IP": [[0],
diff --git a/flu_instances/austin_input_files/simulation_settings.json b/flu_instances/austin_input_files/simulation_settings.json
index 44fc2ce..216b3fd 100644
--- a/flu_instances/austin_input_files/simulation_settings.json
+++ b/flu_instances/austin_input_files/simulation_settings.json
@@ -1,7 +1,8 @@
 {
 	"timesteps_per_day":7,
 	"transition_type":"binom_deterministic",
+	"use_deterministic_softplus": false,
 	"start_real_date": "2023-10-20",
 	"save_daily_history": true,
-        "transition_variables_to_save": ["ISH_to_HR", "ISH_to_HD", "S_to_E", "R_to_S","IA_to_R", "ISR_to_R","HR_to_R"]
+        "transition_variables_to_save": ["ISH_to_HR", "ISH_to_HD", "S_to_E", "E_to_IP", "R_to_S","IA_to_R", "ISR_to_R","HR_to_R"]
 }
diff --git a/flu_instances/calibration_research_input_files/ABC_mixing_params.json b/flu_instances/calibration_research_input_files/ABC_mixing_params.json
index bff2dec..748faf3 100644
--- a/flu_instances/calibration_research_input_files/ABC_mixing_params.json
+++ b/flu_instances/calibration_research_input_files/ABC_mixing_params.json
@@ -1,6 +1,6 @@
 {
 	"num_locations":  3,
-	"travel_proportions": [[0.1, 0.05, 0.3],
-							[0.05, 0.1, 0.25],
+	"travel_proportions": [[0.65, 0.05, 0.3],
+							[0.05, 0.7, 0.25],
 							[0.4, 0.4, 0.2]]
 }
\ No newline at end of file
diff --git a/flu_instances/calibration_research_input_files/AB_mixing_params.json b/flu_instances/calibration_research_input_files/AB_mixing_params.json
index d5c9284..191db27 100644
--- a/flu_instances/calibration_research_input_files/AB_mixing_params.json
+++ b/flu_instances/calibration_research_input_files/AB_mixing_params.json
@@ -1,6 +1,6 @@
 {
 	"num_locations":  2,
 	"travel_proportions":
-		[[0.4,0.05],
-		[0.01,0.4]]
+		[[0.95,0.05],
+		[0.4,0.6]]
 }
\ No newline at end of file
diff --git a/flu_instances/examples/flu_demo.ipynb b/flu_instances/examples/flu_demo.ipynb
index 8f5b27f..166a89f 100644
--- a/flu_instances/examples/flu_demo.ipynb
+++ b/flu_instances/examples/flu_demo.ipynb
@@ -103,32 +103,6 @@
     "jumped_bit_generator = bit_generator.jumped(1)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "65c06ed2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "484568"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a=np.array([[31395],\n",
-    "\t\t[65760],\n",
-    "\t\t[276758],\n",
-    "\t\t[67914],\n",
-    "\t\t[42741]])\n",
-    "a.sum()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "d1ab0b6c-6e75-4473-9e86-dac59e2d44fe",
@@ -139,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "9b601dd8-4d09-4bbb-a1e9-3b7d689b48fe",
    "metadata": {},
    "outputs": [],
@@ -183,7 +157,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "a78193bf-7989-4779-91ab-5772771f7375",
    "metadata": {},
    "outputs": [
@@ -221,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "f44aa524-3dc7-4010-9863-f0fc5b89585e",
    "metadata": {},
    "outputs": [],
@@ -241,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "b3aa79bb-11df-47fc-b581-70849b26ca1a",
    "metadata": {},
    "outputs": [
@@ -266,7 +240,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "8fea54fb-2b4b-4bc5-805e-e57b1edde0af",
    "metadata": {},
    "outputs": [
@@ -274,51 +248,51 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "FluSubpopState(S=array([[ 224364.],\n",
-      "       [ 362128.],\n",
-      "       [1138268.],\n",
-      "       [ 504636.],\n",
-      "       [ 613997.]]), E=array([[ 143034.0000071 ],\n",
-      "       [ 452704.        ],\n",
-      "       [1062048.        ],\n",
-      "       [ 400050.00000004],\n",
-      "       [ 297739.00000085]]), IP=array([[ 19404.65973221],\n",
-      "       [ 61394.8393474 ],\n",
-      "       [144034.83150073],\n",
-      "       [ 54256.2280289 ],\n",
-      "       [ 40388.50903972]]), ISR=array([[ 40916.95901544],\n",
-      "       [129496.42294079],\n",
-      "       [303707.33004208],\n",
-      "       [114329.58756694],\n",
-      "       [ 84099.85026886]]), ISH=array([[  79.59123849],\n",
-      "       [ 106.5305584 ],\n",
-      "       [ 483.4417227 ],\n",
-      "       [ 364.50069492],\n",
-      "       [2160.34082493]]), IA=array([[ 20300.95901939],\n",
-      "       [ 64230.41971404],\n",
-      "       [150703.22768632],\n",
-      "       [ 56770.58756066],\n",
-      "       [ 42266.9037497 ]]), HR=array([[ 141.8128429 ],\n",
-      "       [ 165.72033873],\n",
-      "       [ 749.64390146],\n",
-      "       [ 541.69487994],\n",
-      "       [3274.59018392]]), HD=array([[ 41.32148357],\n",
-      "       [ 38.30811443],\n",
-      "       [ 40.93754379],\n",
-      "       [ 40.91785459],\n",
-      "       [290.76766706]]), R=array([[ 1465740.18447399],\n",
-      "       [ 4556766.79877596],\n",
-      "       [10761586.66898591],\n",
-      "       [ 4071789.96657804],\n",
-      "       [ 3087159.14219258]]), D=array([[1.47149953e+01],\n",
-      "       [6.55250789e+00],\n",
-      "       [1.41215228e+03],\n",
-      "       [2.25612032e+03],\n",
-      "       [2.36599620e+04]]), M=array([[0.87616278],\n",
-      "       [0.89734915],\n",
-      "       [0.88855763],\n",
-      "       [0.88292896],\n",
-      "       [0.85797593]]), MV=array([[0.00082439],\n",
+      "FluSubpopState(S=array([[ 251802.],\n",
+      "       [ 409855.],\n",
+      "       [1285933.],\n",
+      "       [ 568912.],\n",
+      "       [ 686520.]]), E=array([[ 140050.],\n",
+      "       [ 447477.],\n",
+      "       [1045912.],\n",
+      "       [ 393032.],\n",
+      "       [ 289883.]]), IP=array([[ 19001.],\n",
+      "       [ 60687.],\n",
+      "       [141849.],\n",
+      "       [ 53307.],\n",
+      "       [ 39323.]]), ISR=array([[ 40066.],\n",
+      "       [128010.],\n",
+      "       [299111.],\n",
+      "       [112329.],\n",
+      "       [ 81880.]]), ISH=array([[  80.],\n",
+      "       [ 106.],\n",
+      "       [ 472.],\n",
+      "       [ 360.],\n",
+      "       [2118.]]), IA=array([[ 19879.],\n",
+      "       [ 63492.],\n",
+      "       [148419.],\n",
+      "       [ 55777.],\n",
+      "       [ 41153.]]), HR=array([[ 127.],\n",
+      "       [ 166.],\n",
+      "       [ 750.],\n",
+      "       [ 541.],\n",
+      "       [3213.]]), HD=array([[ 41.],\n",
+      "       [ 36.],\n",
+      "       [ 41.],\n",
+      "       [ 41.],\n",
+      "       [291.]]), R=array([[ 1442963.],\n",
+      "       [ 4517187.],\n",
+      "       [10639131.],\n",
+      "       [ 4018480.],\n",
+      "       [ 3027168.]]), D=array([[7.0000e+00],\n",
+      "       [0.0000e+00],\n",
+      "       [1.3980e+03],\n",
+      "       [2.2370e+03],\n",
+      "       [2.3467e+04]]), M=array([[0.86944384],\n",
+      "       [0.8929046 ],\n",
+      "       [0.88318925],\n",
+      "       [0.87699613],\n",
+      "       [0.85002811]]), MV=array([[0.00082439],\n",
       "       [0.00164878],\n",
       "       [0.00247317],\n",
       "       [0.00329757],\n",
@@ -350,7 +324,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "ec0c554d-3f75-43f5-ba64-ce24518db58f",
    "metadata": {},
    "outputs": [
@@ -358,16 +332,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "#0. 'S':   <clt_toolkit.base_components.Compartment object at 0x1443a2a90>\n",
-      "#1. 'E':   <clt_toolkit.base_components.Compartment object at 0x106a498d0>\n",
-      "#2. 'IP':  <clt_toolkit.base_components.Compartment object at 0x144b82190>\n",
-      "#3. 'ISR': <clt_toolkit.base_components.Compartment object at 0x143d31f50>\n",
-      "#4. 'ISH': <clt_toolkit.base_components.Compartment object at 0x14453a090>\n",
-      "#5. 'IA':  <clt_toolkit.base_components.Compartment object at 0x106a47e90>\n",
-      "#6. 'HR':  <clt_toolkit.base_components.Compartment object at 0x1447b1890>\n",
-      "#7. 'HD':  <clt_toolkit.base_components.Compartment object at 0x14631b310>\n",
-      "#8. 'R':   <clt_toolkit.base_components.Compartment object at 0x14631bc10>\n",
-      "#9. 'D':   <clt_toolkit.base_components.Compartment object at 0x14631b910>\n"
+      "#0. 'S':   <clt_toolkit.base_components.Compartment object at 0x1143aedd0>\n",
+      "#1. 'E':   <clt_toolkit.base_components.Compartment object at 0x12227f590>\n",
+      "#2. 'IP':  <clt_toolkit.base_components.Compartment object at 0x125739f50>\n",
+      "#3. 'ISR': <clt_toolkit.base_components.Compartment object at 0x126910b10>\n",
+      "#4. 'ISH': <clt_toolkit.base_components.Compartment object at 0x126e2d910>\n",
+      "#5. 'IA':  <clt_toolkit.base_components.Compartment object at 0x1229b0810>\n",
+      "#6. 'HR':  <clt_toolkit.base_components.Compartment object at 0x10784c350>\n",
+      "#7. 'HD':  <clt_toolkit.base_components.Compartment object at 0x12711f090>\n",
+      "#8. 'R':   <clt_toolkit.base_components.Compartment object at 0x107847d90>\n",
+      "#9. 'D':   <clt_toolkit.base_components.Compartment object at 0x1245d59d0>\n"
      ]
     }
    ],
@@ -382,7 +356,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "0ef54f51-8a31-4c11-b757-dba05e6f20b4",
    "metadata": {},
    "outputs": [
@@ -390,11 +364,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[ 224364.]\n",
-      " [ 362128.]\n",
-      " [1138268.]\n",
-      " [ 504636.]\n",
-      " [ 613997.]]\n"
+      "[[ 251802.]\n",
+      " [ 409855.]\n",
+      " [1285933.]\n",
+      " [ 568912.]\n",
+      " [ 686520.]]\n"
      ]
     }
    ],
@@ -408,13 +382,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "5c0e8cf6-8f53-485f-9bcd-84da258d8fc6",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -430,13 +404,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "53b75eaf-c7aa-4454-97fd-16f79992a27e",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -477,7 +451,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "id": "bc5062d3-e7ac-4119-9e5d-65e616544720",
    "metadata": {},
    "outputs": [],
@@ -514,7 +488,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "id": "241277df-9e5c-4969-9a5f-e37e23f57885",
    "metadata": {},
    "outputs": [
@@ -540,7 +514,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "id": "0794e89e-e54c-4f9b-9084-f869a94901da",
    "metadata": {},
    "outputs": [
@@ -548,7 +522,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'S': [[174198.0], [281661.0], [886270.0], [392843.0], [475330.0]], 'E': [[140975.00000710343], [451116.0], [1055292.0], [396328.00000030594], [289112.0000023786]], 'IP': [[19062.72741990676], [61112.98684110877], [142832.837220815], [53615.42316794436], [39010.587753336]], 'ISR': [[39835.01024937403], [128450.50788895693], [299352.41969417804], [112081.72735800338], [79434.90675785148]], 'ISH': [[133.69581470056255], [166.5912384869248], [806.5305584038797], [571.5622503745981], [3585.4104333707946]], 'IA': [[19831.01048619242], [63792.4241353469], [148881.3301011523], [55835.727358000644], [40477.90675780829]], 'HR': [[280.89749764349335], [340.812842900109], [1629.72033846862], [1137.767653060937], [7205.644884806403]], 'HD': [[41.410374246891955], [38.385772838348544], [43.030560620943106], [83.01263657256573], [629.8560658227489]], 'R': [[1519667.264085335], [4640352.857925087], [11026525.782302385], [4190463.0645740144], [3239893.1956208455]], 'D': [[13.775836994969888], [5.860786223465865], [1401.2280143906473], [2077.213298906184], [20357.05284145343]], 'M': [[0.471333273194946], [0.48639225459339236], [0.47892065294916086], [0.4748988376672331], [0.45686884490857776]], 'MV': [[0.0004532901200728371], [0.0009065802401456742], [0.0013598703602185113], [0.0018131604802913484], [0.002266450600364188]], 'absolute_humidity': 0.013399104, 'flu_contact_matrix': [[1.41415435, 2.37024572, 3.83356137, 0.71327459, 0.35347632], [1.00728934, 10.60466906, 4.14690412, 1.08705454, 0.40621624], [0.70293355, 1.76839296, 7.78559557, 2.11908831, 0.55215071], [0.33809671, 1.19880912, 5.48841938, 3.16470291, 0.76774731], [0.27421269, 0.7469776, 2.39706181, 1.21965752, 2.01500593]], 'beta_reduce': 0.0, 'daily_vaccines': [[1e-05], [2e-05], [3e-05], [4e-05], [5e-05]]}\n"
+      "{'S': [[196038.0], [319719.0], [1005890.0], [444869.0], [532088.0]], 'E': [[137044.0], [445276.0], [1035562.0], [387361.0], [277725.0]], 'IP': [[18509.0], [60288.0], [140033.0], [52347.0], [37423.0]], 'ISR': [[38593.0], [126546.0], [292927.0], [109195.0], [76002.0]], 'ISH': [[133.0], [163.0], [796.0], [559.0], [3473.0]], 'IA': [[19228.0], [62874.0], [145778.0], [54438.0], [38771.0]], 'HR': [[275.0], [342.0], [1627.0], [1135.0], [7130.0]], 'HD': [[41.0], [34.0], [41.0], [83.0], [620.0]], 'R': [[1504149.0], [4611774.0], [10938980.0], [4152966.0], [3201568.0]], 'D': [[6.0], [0.0], [1382.0], [2063.0], [20216.0]], 'M': [[0.4655963502218194], [0.4816538085835662], [0.4737386543074666], [0.4694688938637291], [0.4507093341751248]], 'MV': [[0.0004532901200728371], [0.0009065802401456742], [0.0013598703602185113], [0.0018131604802913484], [0.002266450600364188]], 'absolute_humidity': 0.013399104, 'flu_contact_matrix': [[1.41415435, 2.37024572, 3.83356137, 0.71327459, 0.35347632], [1.00728934, 10.60466906, 4.14690412, 1.08705454, 0.40621624], [0.70293355, 1.76839296, 7.78559557, 2.11908831, 0.55215071], [0.33809671, 1.19880912, 5.48841938, 3.16470291, 0.76774731], [0.27421269, 0.7469776, 2.39706181, 1.21965752, 2.01500593]], 'beta_reduce': 0.0, 'daily_vaccines': [[1e-05], [2e-05], [3e-05], [4e-05], [5e-05]]}\n"
      ]
     }
    ],
@@ -562,7 +536,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "id": "5a38154c-41b1-4732-93e5-d38f3f1c6c97",
    "metadata": {},
    "outputs": [
@@ -661,7 +635,7 @@
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>7</td>\n",
-       "      <td>4.933514</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
@@ -671,7 +645,7 @@
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>7</td>\n",
-       "      <td>11.856053</td>\n",
+       "      <td>4.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -681,7 +655,7 @@
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>7</td>\n",
-       "      <td>37.766822</td>\n",
+       "      <td>20.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -691,7 +665,7 @@
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>7</td>\n",
-       "      <td>21.812035</td>\n",
+       "      <td>10.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -701,19 +675,19 @@
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>7</td>\n",
-       "      <td>82.695814</td>\n",
+       "      <td>50.0</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "  subpop_name state_var_name  age_group  risk_group  rep  timepoint      value\n",
-       "0       north             HR          0           0    0          7   4.933514\n",
-       "1       north             HR          1           0    0          7  11.856053\n",
-       "2       north             HR          2           0    0          7  37.766822\n",
-       "3       north             HR          3           0    0          7  21.812035\n",
-       "4       north             HR          4           0    0          7  82.695814"
+       "  subpop_name state_var_name  age_group  risk_group  rep  timepoint  value\n",
+       "0       north             HR          0           0    0          7    1.0\n",
+       "1       north             HR          1           0    0          7    4.0\n",
+       "2       north             HR          2           0    0          7   20.0\n",
+       "3       north             HR          3           0    0          7   10.0\n",
+       "4       north             HR          4           0    0          7   50.0"
       ]
      },
      "execution_count": 18,
@@ -812,240 +786,227 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9</th>\n",
-       "      <td>20489.486093</td>\n",
-       "      <td>170865.489862</td>\n",
-       "      <td>186307.489862</td>\n",
-       "      <td>110154.489862</td>\n",
-       "      <td>57685.489862</td>\n",
-       "      <td>32873.489862</td>\n",
-       "      <td>22204.489862</td>\n",
-       "      <td>17462.489862</td>\n",
-       "      <td>15060.489862</td>\n",
-       "      <td>13474.489862</td>\n",
-       "      <td>12358.489862</td>\n",
-       "      <td>11557.489862</td>\n",
-       "      <td>10850.489862</td>\n",
-       "      <td>10234.489862</td>\n",
-       "      <td>10114.489862</td>\n",
+       "      <td>16424.0</td>\n",
+       "      <td>162787.0</td>\n",
+       "      <td>188702.0</td>\n",
+       "      <td>113579.0</td>\n",
+       "      <td>59369.0</td>\n",
+       "      <td>33389.0</td>\n",
+       "      <td>22221.0</td>\n",
+       "      <td>17345.0</td>\n",
+       "      <td>14927.0</td>\n",
+       "      <td>13371.0</td>\n",
+       "      <td>12271.0</td>\n",
+       "      <td>11462.0</td>\n",
+       "      <td>10756.0</td>\n",
+       "      <td>10150.0</td>\n",
+       "      <td>10019.0</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "timepoint           7              14             21             28   \\\n",
-       "rep                                                                    \n",
-       "0          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "1          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "2          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "3          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "4          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "5          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "6          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "7          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "8          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "9          20489.486093  170865.489862  186307.489862  110154.489862   \n",
-       "\n",
-       "timepoint           35            42            49            56   \\\n",
-       "rep                                                                 \n",
-       "0          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "1          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "2          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "3          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "4          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "5          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "6          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "7          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "8          57685.489862  32873.489862  22204.489862  17462.489862   \n",
-       "9          57685.489862  32873.489862  22204.489862  17462.489862   \n",
+       "timepoint      7         14        21        28       35       42       49   \\\n",
+       "rep                                                                           \n",
+       "0          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "1          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "2          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "3          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "4          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "5          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "6          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "7          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "8          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
+       "9          16424.0  162787.0  188702.0  113579.0  59369.0  33389.0  22221.0   \n",
        "\n",
-       "timepoint           63            70            77            84   \\\n",
-       "rep                                                                 \n",
-       "0          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "1          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "2          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "3          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "4          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "5          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "6          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "7          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "8          15060.489862  13474.489862  12358.489862  11557.489862   \n",
-       "9          15060.489862  13474.489862  12358.489862  11557.489862   \n",
+       "timepoint      56       63       70       77       84       91       98   \\\n",
+       "rep                                                                        \n",
+       "0          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "1          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "2          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "3          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "4          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "5          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "6          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "7          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "8          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
+       "9          17345.0  14927.0  13371.0  12271.0  11462.0  10756.0  10150.0   \n",
        "\n",
-       "timepoint           91            98            100  \n",
-       "rep                                                  \n",
-       "0          10850.489862  10234.489862  10114.489862  \n",
-       "1          10850.489862  10234.489862  10114.489862  \n",
-       "2          10850.489862  10234.489862  10114.489862  \n",
-       "3          10850.489862  10234.489862  10114.489862  \n",
-       "4          10850.489862  10234.489862  10114.489862  \n",
-       "5          10850.489862  10234.489862  10114.489862  \n",
-       "6          10850.489862  10234.489862  10114.489862  \n",
-       "7          10850.489862  10234.489862  10114.489862  \n",
-       "8          10850.489862  10234.489862  10114.489862  \n",
-       "9          10850.489862  10234.489862  10114.489862  "
+       "timepoint      100  \n",
+       "rep                 \n",
+       "0          10019.0  \n",
+       "1          10019.0  \n",
+       "2          10019.0  \n",
+       "3          10019.0  \n",
+       "4          10019.0  \n",
+       "5          10019.0  \n",
+       "6          10019.0  \n",
+       "7          10019.0  \n",
+       "8          10019.0  \n",
+       "9          10019.0  "
       ]
      },
      "execution_count": 20,
diff --git a/flu_instances/examples/flu_demo_2popAustin.ipynb b/flu_instances/examples/flu_demo_2popAustin.ipynb
index 9f8a8d3..30c20c0 100644
--- a/flu_instances/examples/flu_demo_2popAustin.ipynb
+++ b/flu_instances/examples/flu_demo_2popAustin.ipynb
@@ -189,7 +189,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.01745\n",
+      "0.07\n",
       "[[0.278]\n",
       " [0.278]\n",
       " [0.278]\n",
@@ -285,7 +285,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAArKRJREFUeJzs3Qd4VGXWB/AzfdJ7hdB7kSrFjiCg2FnFslJEXRG7K5ZVLOuKq59dhFUU3LXjqqtYkWKhqCAI0ntL73UmU+73nDO5w0wIJCGZzJ3k/3u8TrszczM35Mx5y3l1iqIoBAAAAAAAAADNTt/8LwkAAAAAAAAASLoBAAAAAAAAAgg93QAAAAAAAAABgqQbAAAAAAAAIECQdAMAAAAAAAAECJJuAAAAAAAAgABB0g0AAAAAAAAQIEi6AQAAAAAAAAIESTcAAAAAAABAgCDpBgAAAAAAAAgQJN0AEHK2bt1Kjz76KO3fvz/YhwIAAAD1ePXVV2nRokX4nKDNQtINACGZdD/22GNIugEAAEIAkm5o65B0AwAAAAAAAAQIkm4AaBZHjhyh66+/nlJSUshisVDfvn3pzTff9D5eXV1Ns2fPpiFDhlBMTAxFRETQmWeeSStWrDjmtd5//33ZLyoqiqKjo6l///704osvymM8PO2KK66Q66NGjSKdTifbypUrcSYBAABq2bRpk8TJzz77zHvf+vXr5b7Bgwf77Xv++efT8OHDvbe/+uoridUcszkmT5gwgbZs2eL3nOzsbJo2bRq1b99e4n9aWhpdcskl3tFonTp1kud8//333ph9zjnn4DxBm2IM9gEAQOjLycmhESNGSCC99dZbKSkpSQL19OnTqbS0lO688065XLBgAV199dV04403UllZGb3xxhs0btw4+uWXX2jgwIHyWkuXLpV9Ro8eTf/85z/lvm3bttGqVavojjvuoLPOOotuv/12eumll+jBBx+k3r17yz7qJQAAABzVr18/io2NpR9++IEuvvhiue/HH38kvV5Pv//+u8RnbuB2u920evVquummm2Sf//znPzRlyhSJ0xyPKysrad68eXTGGWfQhg0bJJlmEydOlKT6tttuk/tyc3Mllh88eFBuv/DCC/JYZGQk/e1vf5PncAM9QFuiUxRFCfZBAEBou+GGG+jLL7+kzZs3U0JCgvd+Tp45+c7KyiKz2Uwul0suVcXFxdSrVy9pOecEnHGCvnDhQiosLCSDwVDn+3300UfS28295GgtBwAAOLELL7yQ8vLy6Oeff/Ymyux///sfLVmyhMaPHy+JNPd8833nnnsuZWRkSKx97bXX/BrZe/bsSVdeeaXcz3E8Li6OnnnmGfrrX/96wsQ/MTERo9KgzcLwcgBoEm63++9//0sXXXSRXM/Pz/du3DpeUlJCv/32myTQasLNremcVDudTho6dKg8ruLW+IqKCmklBwAAgKbjIeIcazm+sp9++okuuOACGWXGvd6ML3nEGvdkcwzmhJobz33jOsdyHn6uTg0LCwuT2M5TvIqKinCqAI4Dw8sBoEm45ZwDM7d4+7aG++KhZuytt96iZ599lrZv304Oh8P7eOfOnb3Xb7nlFvrwww9lXlm7du1o7Nix0qLOrfAAAABwckk3N3SvWbNGerA5LvN9PCzcN+nu06cPxcfH065du+Q+7vGuCw9HZzyHm4ee33PPPTJknKeaca/65MmTKTU1FacKoAaSbgBoEu61Zn/+859l7lddTjnlFHr77bdp6tSpdOmll9K9995LycnJ0mI+Z84c2rNnj3dfvn/jxo30zTffyNB03ni4OQdwTtoBAACgcXhUmdVqlXndHTp0kFjbo0cPSbx5OS+73S5J92WXXeYX23led13Js9F4NIXgaWE82u3TTz+V2P3www9LbF++fDkNGjQIpwoASTcANBUXTeOKpjxfe8yYMcfdj+dhd+nShT7++GMZvqZ65JFHjtmXh6pxAOeNAz/3fv/rX/+SQN6tWze/5wMAAMCJcVwdNmyYJNacdHOyzfiSE+533nlH5mtzsVLWtWtXueTk/ESxXcX7c283b9xLzsPWeWQbN7gzxG1o6zCnGwCahHuruSALz+v+448/6hx+ru7HfGs3ckEXHurmq6CgwP+PlF4vPeWMvxgwXrqE8bB2AAAAqB8n2Bx3eT62mnRzcTNe/UNdLUS9n2uy8BDyJ5980m86WO3YzhXNbTbbMQk4N8arMVuN24jZ0JZheDkANNlTTz0lQZyLq/ByYDwnjAulcdGW7777Tq7zHC/u5eaha1ytfN++fTR//nzZt7y83K8SOu/P88h4zc8DBw7Qyy+/LK3m6rJgfJ2TeP6SwIXaeE4Z788t8gAAAHAsTqj/8Y9/0KFDh7zJNePebR5Nxst7cdxlnHDz8mDXXXedVDS/6qqrZGQbLwP2xRdf0Omnn06vvPIK7dy5U5b45NorHM952Pknn3wiveb8HNWQIUPk9Z544gkZscbx+njzxQFaJV4yDACgqXJycpSZM2cqGRkZislkUlJTU5XRo0crr732mjzudruVJ598UunYsaNisViUQYMGKUuWLFGmTJki96k++ugjZezYsUpycrJiNpuVDh06KH/5y1+UrKwsv/d7/fXXlS5duigGg4G7zpUVK1bgJAIAABxHaWmpxMyoqCjF6XR673/77bcljl533XXHPIdj67hx45SYmBjFarUqXbt2VaZOnaqsW7dOHs/Pz5fY36tXLyUiIkL2Gz58uPLhhx/6vU52drYyYcIEeW9+r7PPPhvnCdoUrNMNAAAAAAAAECCY0w0AAAAAAAAQIEi6AQAAAAAAAAIESTcAAAAAAABAgCDpBgAAAAAAAAgQJN0AAAAAAAAAAYKkGwAAAE6I1+/V6XTHbDNnzpTHbTabXE9ISKDIyEiaOHGirNPri9f3nTBhAoWHh8savffeey85nU6/fVauXClrAlssFlnLd9GiRcccy9y5c+V4rFYrDR8+nH755Re/xxtyLAAAAC3J2KLv1sa53W7KzMykqKgo+bICAABQm6IoVFZWJrEiOjpaE/Hi119/JZfL5b39xx9/0HnnnUdXXHGF3L7rrrvoiy++oMWLF1NMTAzdeuutdPnll9OqVavkcX4uJ9ypqam0evVqysrKosmTJ5PJZKInn3xS9tm3b5/sc/PNN9M777xDy5YtoxtuuIHS0tJo3Lhxss8HH3xAd999N82fP18S7hdeeEEe27FjhyTyDTmWhkC8BgCAxsTs9PR00utP0J8d7IXC25JDhw4p/JFjw2eA3wH8DuB3AL8DDfkdKCkpUbTojjvuULp27aq43W6luLhYMZlMyuLFi72Pb9u2TY5/zZo1cvvLL79U9Hq9kp2d7d1n3rx5SnR0tGK32+X2rFmzlL59+/q9z6RJk5Rx48Z5bw8bNkyZOXOm97bL5VLS09OVOXPmyO2GHEtDIF7j3yf+RuN3AL8D+B2gRnwGHDdOJKg93Y8++ig99thjfvf17NmTtm/f7h0ids8999D7779PdrtdWrNfffVVSklJ8RuuNmPGDFqxYoUMI5syZQrNmTOHjMajPxoPV+OW8S1btlBGRgY99NBDNHXq1GOGqz3zzDOUnZ1NAwYMoJdffpmGDRvmfbwhx1If7rVghw4dkt4LAACA2kpLSyVWcaxQ44aWVFdX09tvvy1xlXvh169fTw6Hg8aMGePdp1evXtShQwdas2YNjRgxQi779+/vFzM5jnL85tg8aNAg2cf3NdR97rzzTu/78ns98MAD3se5V4Gfw89lDTmWhkC8BgCAxsTs+uJ10IeX9+3bl7777jvvbd9kubUNV1OHCHLCjaQbAABORCtDy2v79NNPqbi42Nt4zY3VZrOZYmNj/fbjBJsfU/ep3Uit3q5vH/5CU1VVRUVFRRL369pHbaxvyLHUhRvTeVPxUEGGeA0AAA1RX7wOeiE1TrI5aVa3xMREub+kpITeeOMNeu655+jcc8+lIUOG0MKFCyW5Xrt2rezz7bff0tatW6XFfeDAgXT++efT3//+d+m15hZxxol0586d6dlnn6XevXtLsvynP/2Jnn/+ee8x8HvceOONNG3aNOrTp488hwu9vPnmmw0+FgAAgLaA4yHHW56/1lrwCDluUFc37rUAAABoLkFPunft2iWBu0uXLnTttdfKcPGGDBFjxxuuxq3iPFxN3aeu4Wrqa6jD1Xz3aexwtePhVnM+Ft8NAAAgVB04cEBGp/GIMRU3mHMs5d5vX1wxnB9T96ldQVy9Xd8+3NscFhYmjfIGg6HOfXxfo75jqQsPWecGdnXjof0AAACtIunmody8HMjXX39N8+bNk6HgZ555pgzraqnhavn5+ccdrub7GiczXA0t5wAA0JrwKC+edsXTtlQ8+oundfH0LRVPz+JG9JEjR8ptvty8eTPl5uZ691m6dKkk1DzCTN3H9zXUfdTX4DjM7+W7D1cZ59vqPg05lrrwEmXqUHIMKQcAgOYW1DndPDxNdcopp0gS3rFjR/rwww+lVTvUccs5zxWvPdEeAAAg1HCCy0k3Fyz1rb/Cw7GnT58u8S4+Pl6S1ttuu02SXLVw2dixYyW5vu666+jpp5+WBmsuasrraXPCy7j2yiuvvEKzZs2i66+/npYvXy7fB7ieiorfg99/6NChUuyUa7BUVFTI9LCGHgsAAEBLC3ohNV/ck9yjRw/avXu3rP+pDhHz7WGuPYzsl19+adJwNR6q1pjhasc7lrrwFwn1ywQAAEAo42Hl3GPMCXFtXCeFp2ZNnDjRb4UPFcfZJUuWSLVyToAjIiIkeX788ce9+3D9FU6wuXDpiy++SO3bt6cFCxZ4i56ySZMmUV5eHs2ePVsSd67nwqPlfEer1XcsAAAALU3H64aRRpSXl8s8aV5KjINxUlISvffeexI41SFiPJdaXfbjq6++ogsvvFCqlqtVxl977TW69957ZQgbJ7z33XcfffnllzKsTXXNNddQYWGhBGrGPezcYs7LhKmt+XwcXHTt/vvvl/ld9R1LQ3BPN7fC8+uhejkAACBWaBPiNQAANGe8CGpP91//+le66KKLZEh5ZmYmPfLII9IafvXVV2O4GgAAAAAAAIS8oCbdhw8flgS7oKBAepLPOOMMWYKLrzMMVwMAAAAAAIBQpqnh5a0dhqsBAABihfYhXgMAQHPGi6Cv0w0AAAAAAADQWmmqejnUr6DcTgt+2kc6bjHR6UinI9Lxpe9tvq7n/x+9j2/yXny/Ua8jg7rpfK7rdWQy6Mli0pPFqCeryUBmg+eSb3vuN5DVpJf7+X0BAACgbv/beIR2ZJfVxGadxGK+UXPhidF1xGw1pvP9Bh1JfPZcP3ppNOgkFquxmeO02Xj0unq/5z69xH7EbQCA4EDSHWJcboWKKx3BPgz5UsDBPtxsoCiriaLDjHIZZTVStNVEMWEmSow0yyWCPAAAtEUVdhcVaSBmM4OeKMLiidGRFqNsseGmms1MceFmirYaycg7AgBAs0LSHWLiIsw0c1RX4pn4vLkVRTaemM/T8z33EfE9brfnsva+nLh7N0Uhp5v39Vw6XG6yO9xkc7qo2ukmm8NNdqeL7E7P/XxdXl8hz31O9wm/UHDjfWRNIs4JuWwWT5BPjbFSSrRVetcBAABam7F9U+jM7omeOMxxWeKnGrN5D/U+T4xW9zsas7mx3U0ut6fR3RvD+dKlSAyudrlq4nNNvHbwfTW3HS6qdnlK9/BrlFY5ZTtRgzrHaU7AY8PUZNxEaTFhlBaLeA0AcLKQdIcYTlDbx4UH7f35y4JDAr1LEvKqaheV2hyyldk4mPN1J5VUVlNBRbV8YThRkOcAnxhpofQYK3WID6eM+HBKi7GipR0AAEIex7dg40Z1ScIdbiqzO6jc7qRyjtc2h4yc44Zzjtl8yY3vasw+UEcjOsdn/g7SKTGCuiZFyAg3AACoH5JuaBQeKm428qanKGv9gb7M7qSymoTcs3mu55fbKbvERhXVLsors8v2++ESzy+lXkft4sIkCW8XG0ZJURbZ0CMOAADQODwH3KrneiwGigk3nbBRnRNyTyJe7b0srKimzOIqKre76EixTbaf9xXKc1KiLdQ1KVK2LkkR8h4AAHAsJN0Q0EDPc7p5O16A56Sck+8jRVV0oKCCDhVVUWW1iw4UVMrmfS0dSet650TeIqljQjiCOwAAQDM2qntqs5hk1FnteM1J+JHiKjpYWEl7csspq9RGOaV22VbvKZCRa8lRPHItTBLwnqlR6AkHAKiBdbpbENb9rB8H9vzyajpUVEkHCyopq8QmveKciPvi4M694NwbzkGe54dzUs4VXgEAQhliRfDhHNSvstpJe/MqaHduOe3JK5fYXVv7uDDqnRZFvVKjZWg6CqsCQFuNF0i6NXhS4FhFFdW0N7+C9slWToUVxxZv4yVRuAech6InRFikenpytPW4Pe0AAFqEWBF8OAeNV1LlkGHoh4uqaGdOmVz64lVOeqV6EnAejs7T1AAAQh2Sbg1CEG8+JZUO2ptfTpnFnp7ww0WVMt+sLtzS3ic9mvqlx0hCDgCgZYgVwYdz0Ayfoc1BO7PLaFtWqfSGq1XUmcmgk8SbC7LxqDXewsyYDw4AoQdJtwYhiAd2WHpmiY0OF1ZK1fSCcrsMdcsrt9csy+LBw9uGdoqjwR3iMCccADQJsSL4cA6aFy9HyiPVOAHfnl0m88NrS4gwSwP5aV0TZKkyAIBQgKRbgxDEWx5XYt2aWUpbMkukpZ2XMFOHog/vHE9ndE9EoRcA0BTEiuDDOQhsIzkXX9shQ9ArZUi675QxLs3Sr10MndEt8ZiCbgAAWoOkW4MQxIOL1xTfcKiIft5bSLlldu8Qt7O6J9GZPRLJYsTQNgAIPsSK4MM5aPmibPvzK2n1nnzak1fhvb9bciRN6J8mxVIBALQISbcGIYhrp5WdW9iXb8+lQ4WeQi9RViP1TY+WAi+81AnWBAeAYEGsCD6cg+DJKqmin3bl0++Hi8nl9qxWMqJLAo3rm4LGcQDQHCTdGoQgrr3ke0tmKX25OYuKfOaXmQ066p4SReP6pqLwGgC0OMSK4MM5CL7Cimr6Zks2bTpcIrfjI0x05dAM6pgQEexDAwDwQtKtQQji2uR0uWlXbjnt4Cqr2aVUWuWU+416HY3pk0JndkskPdb/BoAWglgRfDgH2rE7t4z++9sRKb7GofjCU9JpRJd4rPkNAJqApFuDEMRDpwr6t1uyaWdOuXfJsYmD22NOGQC0CMSK4MM50Babw0WfbjhCv9f0evN636d3S6SuSRFIvgEgJOKFvkWPCkDjdDqdrBc69bRO9Kch7SjMZKDDRVX0yopdtGZPgSTlAAAA0HKsJgNNOjWDzu+XKnO8edmxN37aRy98t4vW7i2gaqcbpwMANA1JN8Bxku8hHePpjjHdqXdalBRz+ez3TPr4tyMyHB0AAABaNi6f1SOJ7hzdXYaX89KfvBLJ/zZm0twVu6mkjrW/AQC0Akk3wAnEhJnouhEdaXxN6/q6A0X0n7UH0KoOAAAQBMnRVrpkYDu6//xedOEpabL6CCff877fQ3k1y4ECAGiNMdgHABAKretn90ii1GgrvfvzAZnrvXDVPppyWicZ8gYAbQtPM6modlGZzUFlNqdclttdVFXtIrvTRV2TIqlfu5hgHyZAq8bxl+d190mLlpicV15N//p+D009vRO1jwsP9uEBgAZVO91UYXdSec1WWe2Uka0tAUk3QAP1TI2i68/oTItW76f9BZX09toDknhjTW+A0OdwualcEmgnldkdx1znpJqLOfHGgdp9gvIOBr0OSTdAC4mLMNNNZ3elt1bvlxosC37cR9eN7CiNXwDQurndClU6XJJIc8z2Taj5uuc2x20HVdi5YfzYKaLcSG4xBr4TDUk3QCPw+qDTz+gsQX1PXgV98OshuurUDDIaMFMDQKs90p4E2kFlNUHZe1uSas/tKoerUa/N000izAaKsppkeGuExSiFF7n3rWMCetkAWlKkxSixmRvDOTb/Z80BuuHMzujxBmgFMby4slqWDCypcshlcdXR25xcN7bGMS8JzDFbYrfZQE6XQpYWyIh1CsoxtxgsQdJ67M4tl1Z1p1uh+AgTje2TSqe0j8HSJQAtjHueiyqrqajCIZcFFRyMq6mg3HNZ7VIaFYg5CEdajRQlAdmTUPMXeg7Q4WZPUi3B2mIkPS8aHACIFcGHcxC6I1b+veaAxOhIi4FmnNON4iPMwT4sADgOLk5cXOWgwgpP3ObLwgq7xPKiiobFcG4ED6+JzRyvOYZ7rhsowuy5rjaO8+NchJGnjrZ0vEBPN8BJ6JYcSdeO6ECf/HaECisc9P6vh2hHThldNqgdhpsDNCOXW5HWbA7C/G+NAzIn13JZUS2t4PXhZJkDriTRNcGXr3Ng5gAcXXPbamreQAwALYune107vAO9/sNeyiyxSeP4LaO6tsjQUQA4fuN4oSTTnoZxSaprEmxOuOvrqeYYHRNuotgwsxQ4jgs3eW6Hm+WxCHPgGsGbE5JugJPUKzWa7h4bQT/tyqfl23Npw8Fi+SMy5bSOFG7GPy2AxgZlrjycW2arubTLJQflE82fVpNq7s2KDTdRQoSZ4sLNMs9T7gszYfoHQBvCo1GmnN5JlhGTJcU2ZNIVQ9ujQQ0gwHOrOaHOKbVRdomNCmp6qwvL628cNxl0Eq85fsdHWDzXI1tfDEdmANAE3Ho+uneKzOF89+dDdLCwkt79+SBNO72zFFMCgGOT68ziKgnKeeWexJq/GPP86hMFZG7Rjg83eZNpTqz5kjesIgAAvqKtJrr61A70+o97acOhYonRw7sk4EMCaCKelVxa5aTsUpsnwebLEpvEcZ5yeTyRFm4ct3gaxmtityTZkWYZgdYWRpkh6QZoBt2So+ims7rQ/O/3SBGXLzZn0cUD0vHZQpvGS3Fwgn2k2CaXvOWXVx93/+gwIyVFWigpykLJUVa55I2Hj7WFgAwAzadTYgSN65tKX/2RLTGZp4UlRFrwEQM0EC+DyUk1N5Jzgu3Z7MctPGo26Cg52kop0Z747em5RuO4Ckk3QDNJjbHSlUMz6D9rD9CaPQXULtbaYmv/AQQbVxCVBLuIk2xPgl1U6ahzX56PlRYbRsk1SbWaaKPHWtuOHDlC9913H3311VdUWVlJ3bp1o4ULF9LQoUO9PSCPPPIIvf7661RcXEynn346zZs3j7p37+59jcLCQrrtttvo888/J71eTxMnTqQXX3yRIiOPLu+0adMmmjlzJv3666+UlJQk+8+aNcvvWBYvXkwPP/ww7d+/X17/n//8J11wwQXexxtyLND6ndk9kXbmlElj+Me/HZGK5mjAA6i7oFlWiY0OFVXS4cIquTxeIzkP5EyMtMj33tRoKyVHW+SSE2z8+zo+JN0AzahPejSN6Z1M323Lpf9tzJTlSrjFD6BVDS2zeRJsdTtcXCXDzeqSGGmm9Ngw2bghii9R8yD0FBUVSeI6atQoSbo5Gd61axfFxcV593n66afppZdeorfeeos6d+4sSfG4ceNo69atZLV6/g5ee+21lJWVRUuXLiWHw0HTpk2jm266id59911vFdixY8fSmDFjaP78+bR582a6/vrrKTY2VvZjq1evpquvvprmzJlDF154oTz30ksvpd9++4369evX4GOB1o8TgMsHt6cXv9tJe/MraM3eAjqta2KwDwsg6HGc66UcKqqiQ4WVkmBnFdvqHB7OtVI4oU6Jtsj3WU60uaG8tcyzbklYMqwFYQmStvPH7M1V+2XJEu7JQ+VUCOXfZa4cfrjoaILNFYHrmn+tq2n55sS6XWw4pcdaKS0mjMLMqBrcGmLF/fffT6tWraIff/zxuL8r6enpdM8999Bf//pXuY+PPyUlhRYtWkRXXXUVbdu2jfr06SM92Grv+Ndffy091IcPH5bnc2/03/72N8rOziaz2ex9708//ZS2b98utydNmkQVFRW0ZMkS7/uPGDGCBg4cKIl6Q44lFM8BnLzVu/Pp801Zcn10r2Qa3TsZPXLQpqZ6HVYTbEmyq6iyjuJmXJQ0Iy6MMuLDpdMoIx6N5A2BJcMAgtiyPunUDHp52S4pLPHNlhzM7wbN40SFh4P7Dg/nra6qo5xgc4MS91q3r+nF5tZvDA9vvT777DPpKb7iiivo+++/p3bt2tEtt9xCN954ozy+b98+SZS5h1rFSevw4cNpzZo1kujyJfdYqwk34/15mPnPP/9Ml112mexz1llneRNuxu/Lw8e5t5171nmfu+++2+/4eB9OzBt6LLXZ7XbZfL9EQesxsmsC5VdUy9SvZdtzZZ7qNcM6hMQyQwAnE8v3F1TQgYIK2p9fKd9FazPqdZQWa6UMSa45yQ6TOdgYHh44GF4OEAC89i8vUfLGT/slyPdvF0OdEyPwWYNmcA/2wYJKOlxUWZNk2+osjsLfSXlo2dEh4p4E22zE0LK2ZO/evdILzcnugw8+KL3Vt99+uyTHU6ZMkSSXcW+yL76tPsaXycnJfo8bjUaKj4/324eHg9d+DfUxTrr5sr73qe9YauOh6o899thJfDIQCjiR4OKmnFh8uuEIbckspSWbs+iiU9KQZEDIL9WVWVIl8Xx/QaUk2jwFrLakSLP0XrePD5NEOy3GiiHiLQxJN0AAK5oP6xxHv+wrov+uP0y3j+6ORAWCFpS5Z+dAQSUdLOTW78o6i5xxyzcn1JxYe5JsT5GUpszdcrlcMncX/JlMJjIYQmfovdvtlh7qJ598Um4PGjSI/vjjDxnOzUl3qHvggQf8es+5pzsjIyOoxwTNb3CHODIb9PTuLwelQZx79k7vhjneEFrLbnJjOfdgc282Dxu3O91++3DI5mlenRLCqWNChCyZF2FpWMqHmB24eI2kGyCAzu+XRjuyy6mgoppW7MiV5UsAWiooH6hp+eY5XLWDMg8RT4u2UoeEcEmy28VxNXFrs60vz0PcuFeRK0dD3XiodWpqakj0tKWlpcl8bF+9e/em//73v3Kdfw6Wk5Mj+6r4Ns+1VvfJzc31ew2n0ykVzdXn8yU/x5d6u759fB+v71hqs1gsskHr169dDI2vWUrs6z+yqWdqlNSjANCiCruT9uZVeIeLc10VpVa9M6tJTx3jjybY3KPd2NFoiNmBj9dIugECiOe4XjQgjd5ee5B+2pVPp3aKlyUVAJpTSaWD9tUEZB5illV6bFC2GPXUQYKyJzDzMMtAzsFWE24eThweHh4SiWVL4S83vOSWmoD6JoZaxZXLd+zY4Xffzp07qWPHjnKdh4TzF5Jly5Z5E1vuLea52jNmzJDbI0eOlN+J9evX05AhQ+S+5cuXSy86z7dW9+FCajw6gnsXGFc679mzp7dSOu/D73PnnXd6j4X34fsbeizQtvFSYnvyymlnTjl9/nsmTT2tE/5GgSY4XG5pMN+dWyYFeetKsnnZzU4JEdJozpdcWbypMRYxO/DxGkk3QID1SYumbsmR8sfzi81ZdN0Iz5dUgKb0ZHPL967cMtqTW055dayl6RuUOdFOibK2WNEgHp6mJtwJCQkt8p6hJiwsTC45kPPnpPWh5nfddReddtppMrz8yiuvpF9++YVee+012Rh/4eMk+IknnpC1sNVluriKOC/npfaMjx8/Xoqv8bB0TqxvvfVWKWzG+7FrrrlG5lZPnz5d1gTnIey8jvfzzz/vPZY77riDzj77bHr22WdpwoQJ9P7779O6desadSzQtvHvyEUD0unF73ZJ4r0tq0yW/AQIRlLHhc525ZRLTN+XX0EOl3+WzdO8OidFeIaLx0dQTLinQbK5IGa3TLxG0g3QEsH9lDR6cdku2ppZKq2XPN8boKGcLjcdLOSW73Lak1cha2r6tnxzAzcPEZde7HhPoh0T1rxBuTHUOdzcww3Hp34+/HlpPek+9dRT6ZNPPpG5z48//rgksi+88IKsu62aNWuWLOXF62lzo8sZZ5whS4L5rov9zjvvSKI9evRoqVo+ceJEWU/bt8r4t99+SzNnzpTe8MTERJo9e7Z3jW7GyT+vzf3QQw9JUTdOrLlyubpGd0OPBdo2HlJ+RvdEWrkjj5ZsyqQeKZEoLAUtotzulHi+K8fTm1278Fm01UhdkyOpe3KkdNpEWQMbzxGzWyZeY53uFoR1P9s2HsK2ek+BDOu95ZyuGMoGJ55bVWqjPbkV0kjDLd/VtVq+uRJp15qA3CUxUlPrYdtsNlm2iRMzJDmN/5wQK4IP56BtsDtd9NzSnVRa5aQL+qfSmd2Tgn1I0Epj+qHCKtqa5el4OVJs83vcZNBRl8QI6ZDpnhIpS3K25JQsxOymfUZYpxtAY0b1Sqb1B4qk0iQvV8LFXAB8i6Vszy6Tlm+ea1hu91++K9JikASbt65JkRQbjtoAAABNYTEaaGyfFPpo/RFasT2PhnSMo3AzBoFC84xQ25tfISMcOdkuq9WbnR5jlQSbE20eNt6UVUIgNOAvC0ALrt3NS5Ms355LS7fmyFzvlppjC9qUV2anbVmlsh0o9B8ybjboZG13DshdkyNkTheKkbXQecnLkyHNX3zxhVS85gJeAwYMkPu4oBgAtB6DMuLop10FMrqI4/OFp3jqCwCcTL2VnTllkmhzI7rvqiFczLRXapRUy2+JIeNtRV4IxWsk3QAtXDGV1wblohnfbs2WJcSQSLUdLrciFcZ3ZJdJol27ABq3fHNA7p4SRRlxYWj5DhKeZ1xdXU1vvfUWdenSRQI5V8IuKCgI1iEBQIBw4zcPLX9z1X76eW+hDDEPZk0MCC1lNocU4tuaWSI1V5xuxW9udu+0aCnSx8PH0ZvdtuM1km6AFsRLNI3vl0qfbDhC3+/Ml+FGlw9u32xrI4M2AzJXx+VEmyuT2hxHW755NFnnxEgZ9dA7LQpDxjWAi279+OOPtHLlSqmQzXhZrGHDhgX70AAgQLjnsXNiOO3Lr6QfduZJZXOAE8X1zUdKaNPhEily6jtKjeutcJLdJy2GMuLD0LESQMUhFq+RdAO0sGGd44lzbE68fztYLFUsrxneQeaWQevozeYgzEPMdmaXyRqbviLMBuqRGiXDzHqkRAV0rWytFZKpdh1tcGhJZoO+wV98IiMjZeNq2CNGjCCLxRLw4wOA4OK/D+f2SqY3ftpPv+4vpHN6JmH4LxwzdJzr8fx+qJh255X7JdpcIJcT7b5p0ZTUwkXQAgHxOjCQdAMEwdBO8RRpNdJ7Px+UXtDXf9hL007vTBEW/JMMRSVVDimAtqNm+Q/f3mw1IHOCzYk2L+3VFufyc8L96Gdbg/Lej17cp8GNWkajkRYtWuRdS3rw4MHSgs5rSZ9yyikBP1YACA4uUNkhPlwaTX/clU8X9E/DqWjjHC63jFL7/XCxXPqun8292APax1K/9JhmXzc72BCvAwPf8AGCpFdqNN1wZhd6a/V+WT7ii01ZdOWpGTgfIZRob88qleFl+woq/Fq9w7k3OyVSEm2en81F9CC05ohNmDBBhq2tXbuWvvrqK3r66adpwYIFNHXq1GAfHgAEAPdOju6dTAtlbncBjeqZrKmlGKFluN0K7c0vp42HSuiPIyV+xdB46PjADrF0SvtYWecdgm9iCMVrzazT/dRTT9EDDzxAd9xxB73wwgveNdHuueceev/998lut9O4cePo1VdfpZSUFO/zDh48SDNmzKAVK1bIkMApU6bQnDlzpLdCxWP97777btqyZQtlZGTQQw89dMyJmDt3Lj3zzDOUnZ0tVe9efvllvzkBDTmW+mDdT6jLocJKmvf9Hknabj67C3VMiMAHpeG1s7dzwZSsUln6zRe3evdM8QwZb6u92SdazzJUhqsdzw033EBLly6lAwcONNtxYZ1u7UK8bpv479TLy3dTVolN6q+c3QPrdreV884jHH4/XEKbDxf7LdkZHWaUHu0BGbFS7DTUh443JBYhXrfidbp//fVX+te//nXM0L277rpLSsAvXrxYfphbb72VLr/8clq1apU87nK5pHUjNTWVVq9eTVlZWTR58mQymUz05JNPyj78AfE+N998M73zzjtS0Y6/PKWlpUnizD744ANJynko4fDhwyXp58d27NhBycnJDToWgJOVER9OQzvG0a/7i+jz3zPplnO6temETWvrbO4vqKCtWWXSq11U6Tgm0eYiaByQ4yKwbvaJ8BeVUK5b0KdPH5nnDQCt++/U6d0SZN3u1Xvy6YxuiSh02kpxYsmNK5sOF0uyXewT33m0Wv92MZJo8xrarTHRPhHE68AIetJdXl5O1157Lb3++uv0xBNPeO/n1oI33niD3n33XTr33HPlvoULF1Lv3r1l+AAXuPn2229p69at9N1330mP88CBA+nvf/873XffffToo4+S2WyWRJpbJZ599ll5DX7+Tz/9RM8//7w36X7uuedk/t60adPkNj+HE+w333yT7r///gYdC0BTjO2bKpUweZj5ugNFUmwNgqOq2iVzs3lJL57D5Tu0zGTQSZVbXgKEl/aKxjqbrQ4vM3LFFVfQ9ddfLw3BUVFRtG7dOhmudskllwT78AAgwLgR9ZstOVRa5ZThxZx4QetRWe2kDQeLad3+Ihm95ruONhdDG5gRK/P7saqM9hWEWLwOetI9c+ZM6YkeM2aMX9K9fv16cjgccr+qV69e1KFDB1qzZo0kunzZv39/vyHenEjzcHMeSj5o0CDZx/c11H3uvPNOuc5ru/F78dB2lV6vl+fwcxt6LHXhYei8+Q4/AKgLz/kd0zuFlmzKom+2ZEsLK+aStRy700V/HCmlDQeLaF9+Bfkss0mRFoPMv+dEmxNus1HfgkcGLY2nKfGIJ26Y3bNnj/zt52lJ3DD74IMP4oQAtHK8lvLwzvH03bZc+ml3PpLuVtKrzUVOuVNja2apdy1to15HvdKipKGFG9JNvI4nhIzIEIvXQU26eX70b7/9JsPLa+O51dxTHRvr38LICTY/pu5Te061eru+fTgBrqqqoqKiIhmmXtc+27dvb/Cx1IXnlj/22GMN+iwARnRJoF/2FVJumZ2Wbsuhi7FOaMBbu7fVzM/myuO+VUlToi2SZPdOjcY6m20MLxHGf7t5A4C2aXiXBFq5I09qdxwuqqT2ceHBPiQ4CUUV1bT+QBGtP1jkN3y8XayVhnSMl15tdHCELkuIxeugJd2HDh2SomlcmKb2hPTWgnvPea64ihN9boEBqAsPZbpoQDq98dM+qZw6rFM8pca0zn8bwVJS6aAtWSXS0l27Rzsx0kyDO8TRKe1jKAFVSQEA2vTos77p0TLXlxvDkXSHVi0WbkznOjl7fNbTDjMZpPI419BJjw0L9mFCGxS0pJuHbOfm5soaqCrucf7hhx/olVdeoW+++UaGfhcXF/v1MOfk5EjhNMaXv/zyi9/r8uPqY+qlep/vPlxdLiwsjAwGg2x17eP7GvUdy/FaYHgDaCgevtyvXbQMdV6yKZOmn9G5zRXwaO4hZXlldtqSWVpnxfHUaKt8seJ5XGmttCopAACcXG83J928LCSv2W01hW4hyLYgq6RK5mlvPFRMldVHq493TYqgoZ3iJdZj+Di0yaR79OjRtHnzZr/7uJAZz5XmQmjcI8xVyLnaOK/BxriaOC8RNnLkSLnNl//4xz8keVerjHPPOSfUXGlW3efLL7/0ex/eR30NHjY+ZMgQeZ9LL71U7nO73XKbK5Qzfry+YwFoLhf0S5MCXnvyKiT57t8+Bh9uIxNtTq63ZJZIsp1fXu19jHPqDvHhnkQ7LRo92gAAUCeuWp0cZZEpX5zI8RQw0BaHy02/Hyqmn/cV+jWq8zJfQzrESbIdj5VFoK0n3Vxhrl+/fn73RUREUEJCgvf+6dOny/Ds+Ph4SaRvu+02SXLVwmVjx46V5Pq6666TSnU8v5rX4ObibGoPMy8Vxj3ns2bNkup2y5cvpw8//FCqk6v4PXh976FDh8ra3LxkWEVFhbeaOS8RVt+xADQXXnrqrO5JtGx7Ln2xOUuKe6B4V/1KqhxSafbX/YWUU3q0gCEXSuGW7j7pMdQ7LYqiUHEcAADqwSOfeCURLnC6enc+DeoQG9LLHrYmhRXVMg2PC6OpvdpcA41rsQztGE/dkyOx9CpoTtCrl58IV6PjSuLcu8xVwLnq+Kuvvup9nIeFL1myRKqVcwLMSTsnz48//rh3H14ujBNsXmf7xRdfpPbt29OCBQu8y4WxSZMmUV5eHs2ePVsSd1567Ouvv/YrrlbfsQA0p7N6JHkLfyzfnkPj+6XhA64DB17u0eYRAQcLK/2W9uLgyz3aPVKiMCwQAAAajet8rNyRS3nl1fTezwfpupGdsJRUEEex8RztNXsKaFt2mXeudly4SaYCDOkYJ3PxAbRKp/BvMbQILqTGvea87jf3lgOcCBf7+s/aAzIkesbZXSkjHtVTWW6ZjbYcKZVe7cySo2tsMh46PiAjhgZlxKEiaRDZbDbat2+fNHq21kKZgfycECuCD+cAVIcKK+n1H/fKChec2E0c3A71P1qQzeGSdbXX7C2QGi0q7s0e2TWBeqZEoVe7qZ8xYnaTPqOGxgs0CQFoFBf3GpgRQxsPldDi9YfptnO7tckiINwumFVikySb52jz/DoVN0h0SYygvukx8nnFhJmCeqwAANC6cIP31cM6SCM4Lz8VG2aiMX38l5mF5pdbapNEmxNuu9Mt91mMehrcMY5GdImn5Cg06EJoQdINoGG8hBgXVOPW3WXb2tYw8/xyO63bX0ibj5RQYcXR9TW53aFbEld5j6FeadEYTgYAAAHF05UuHdiOPtlwROqtxISb6NRO8fjUm5nbrchKI2v3Fsh3H1VSpJlGdE2Q4f6oIg+hCkk3gIaFm40S6LmF/Ydd+dQnLYY6JIS36oC7PbuMft5XQDtzyv3maHdPiaJ+6dHUKzUaQ8cBAKBFcVG14spqWrEjjz7/PZN6paIwZ3Mptzvp132FUoWci6KqI9m4sWNkl3jqmhSJIf0Q8pB0A2gcD5selBFLGw4V00e/tb5h5rzkx968CtqeXUrbssr8Am6P5EhZ8qN7SiSqxgIAQFCd1ydFemC5cOcPO/NpwiltZ/RZoIqhrtieK0uyOd2eElMRZgOd2jmehneOp9hwc7APEaDZIOkGCAEXDkij3XnlMsx8wY/76Iqh7Skx0rMsXiji3gLu0fasR14uBWpU4WYDDe0YJ9VIsb4mtLSpU6fSW2+9dcz9vGIFr2oBAG17GbHRvZNp4ar9MiLr7J5JmOJ0ktPHVu7Iow0Hi6gm16aM+DBZC71/u5hW1bEAgTU1hGI2km6AEBlmfuXQDHrn5wPSwv7Ssl00qlcyndEtMWSCU1W1S+Znc5DdX3B0eS/GBdB4qB4v78W92qHyM0HrNH78eFq4cKHffRZL6DZyAUDz4arZ7ePC6HBRFf20K69N1VppalFU/v6yek+BFEZVk+0eKZE0uldKq546B4EVKjEbSTdAiOiWHEl3ju5Bi9cfkuFt327JoZ/3FtJpXFxEo+tTutwK7cwpk+qj27JKvcPHeOh4x/hw6pkaJXO0U6ItmK8FmsHBOjU1NdiHAQAa7u1+a/UBWru3kM7snkQRGoy/WvoesOlwMa3anU9Hio8u89mTk+3eKVgOFdpMzMZfCYAQwhVTp5/RmX4/XELfbMmm4koHffVHNi3dmkNn90iic3slB329SqfLLUt88RwtDrTldpf3MU6uufrogIxYLO/V1igKkas6OO9tMHtaegAAmgGvDd0u1ipJ5E+782lcX+1/4Q/G6LZf9hfS6j35VFrl9BZFHdA+VtbXTo8NC/YhwvEgXms36S4uLqbY2NjmeCkAaEAr+8CMWOqbHi09yL/uL5RhbryMyc7cMpo4uD2lRLfM+pVlNgdll9gkyc4utcn13DIbuTxLaoooq1GC7KAOsZQWY0WPdlvFCfdXs4Lz3uc/TWRs+FCzJUuWUGRkpN99Dz74oGytAWI2QNPj8Lm9UmRlkTV7CujM7okyDQw8xdG4IeK3A0Xe9bX5e8DILglSAR6jAkJACMXrUIrZjf4L8c9//pM6depEkyZNkttXXnkl/fe//5Vu/S+//JIGDBgQiOMEgFp43jMHMN5+P1RMn248QocKq+jFZbukENmYPikUbTU163wsLuTGBdB255ZTVkmVXy+2L4tRL0PHuVeb578Fu/cdoDFGjRpF8+bN87svPj401+RFzAYIjN5pUdKQzI3OP+3Kp7FtvLf7UGElfb8zT9bZ5o5SlhptpTO6J0jDuxG1WqCNx+xGJ93z58+nd955R64vXbpUtq+++oo+/PBDuvfee+nbb78NxHECwAnwcO2OCeH0xeYs+uNIKf26v0gScZ5rdkb3RLKaDCf1+VU73VJdnOdlc6XxokrPcl4qHrGbGGGmlBgrpceESQ87fwmJDTehRxuOHeLNLdjBeu9GiIiIoG7dulFrgJgNEMje7mR65+eDUhyM422Y+eRibSjLLbXR0m058t3Dd742f/fA+tohKoTidSjF7EYn3dnZ2ZSRkeHtzuee7rFjx0rv9/DhwwNxjADQALye5bXDO9KBggr6cnO2VAnlIeer9uTLepdJURYy6PUy59rmcFNRZbV3TWyDXif381Cwar50uKnK4aIKu9NbYZQZ9TrqkhQhVcY7xIdLkm02otI4NAC30DRyyBg0HWI2QODwNC+uVZJTape5y1wYrC31bK/knu3MUu+feJ76xvVlWmqKGwQI4nVANPrbclxcHB06dEiu8/pnY8aM8Q49dbnqHmoKAC2nY0IE3Xx2F7pmWAdJtDnB/n5nPn20/gh98Osh+u9vR6RHnFvmt2SWyrbpcAltzeI1sytkiHpumZ3KbJ6Em3utR3SJp8kjO9JDF/amaad3ptO7JUrFUSTc0BrZ7XZJVn23/Px8CkXNFbMfffRR6dnz3Xr16uV93Gaz0cyZMykhIUHm1k2cOJFycnL8XuPgwYM0YcIECg8Pp+TkZBkd53R6CiypVq5cSYMHD5ZqtNxzsWjRomOOZe7cudLQb7VapbH/l19+8Xu8IccC0Bz438GonslyfdXuArI5Wvf3YP67sSunjBb8uJdeXbnHm3Bz48Mdo7vL0qZIuKGl2UMkZje6p/vyyy+na665hrp3704FBQV0/vnny/0bNmwIia59gLbyRaB/+xjq1y5a5ldxUm13uGTJLk6UzQa9JNMxYZ5hPG5FkTni6mN8GW42SMGTaKsRQ8WhTeHkNC3Nf+3dnj170vbt2ynUNGfM7tu3L3333Xfe20bj0a8Qd911F33xxRe0ePFiiomJoVtvvVXee9WqVfI4J/iccHP9l9WrV1NWVhZNnjyZTCYTPfnkk7LPvn37ZJ+bb75ZprEtW7aMbrjhBjkX48aNk30++OADuvvuu2XYPCfcL7zwgjy2Y8cOSeQbciwAzal/uxhati2H8sqrae3eAjqnJglvTdxuhf7ILKHvd+RRZoln2S8u1TKoQxyd1T2RktGzDUH0dYjEbJ3CzVaN4HA46MUXX5SW86lTp9KgQYPk/ueff56ioqIkQELdSktL5QtASUkJRUdH42MCgFaJexo5gercubP0RkLjPqfmjBXNFbO5p/vTTz+ljRs3HvMYH2dSUhK9++679Kc//Unu4y87vXv3pjVr1tCIESOk9suFF15ImZmZlJLiGYLLifN9991HeXl5ZDab5Tony3/88Yf3ta+66iqpts5fqhgn2qeeeiq98sorctvtdsuUt9tuu43uv//+Bh1LQyBeQ2P8drCIFq87LI3Vfx3bs9XM7eZkm382LpCWX+5Z8tFs0NGpnePpzG5JsowphD7E7KZ9Rg2NF43u6eZW6b/+9a/H3M8tywAAAKAdzRmzd+3aRenp6fKFY+TIkTRnzhzq0KEDrV+/XpJ7deg646Hn/Jia6PJl//79vQk34x7qGTNm0JYtW6QxgPfxfQ11nzvvvFOuV1dXy3s98MAD3sf1er08h5/LGnIsxxueyJvvlyiAhhrYPlZ6gXlq1rdbs+mSge1CPtnedKREevDVZJsbFE7rmiBrbGN5NIDGa1DS/dlnnzX4BS+++OKTOAwAAABoDoGI2dzDzPOrecgeDw1/7LHH6Mwzz5ReaZ4/xz3VsbGxfs/hBJsfY3zpm3Crj6uPnWgfToCrqqqoqKhIhqnXtY86jLAhx1IXbkDgnwngZPCymBcPTKcFP+6jn/cV0pCOcdQ+LjzkPkwe/Mp1Xr7bliPF4VikxUBn90imUzvHkcXYOnrwATSbdF966aUNnkeKYmoAAADBE4iYrc4FZ6eccook4R07dpTlQsPCwijUce85zxVXcaKvrtQC0BC8PNaA9jH0++ES+uz3TJpxdteQqYfCyfbOnHJJtg8XVcl9YSYDndkjUXq3kWwDtFDSzXOmAAAAQPtaImZzT3KPHj1o9+7ddN5558nQb5577dvDzBXDuXAa48vaVcbViuK++9SuMs63eY4cJ/YGg0G2uvbxfY36jqUuXC2dN4CmOL9/Gm3PLpNVQNYfKKKhneI1P4x8V245rdiRSwcKKuU+i1EviXZbXXccIFCwwC4AAAA0Snl5Oe3Zs0cqxg4ZMkTmjnO1cRVXE+clwnjuN+PLzZs3U25urnefpUuXSkLdp08f7z6+r6Huo74GDxvn9/LdhxsY+La6T0OOBSBQYsJMNKZmre6v/simymr/JfG0IrfURl//kUX//Ho7LVq9XxJuk0FHZ3ZPpL+O60lj+6Yi4QZoZo0upMYqKiro+++/lyDGLcq+br/99uY6NgAAAGii5ojZXIztoosukiHlXIH8kUcekV7nq6++Wqq2Tp8+XYZnx8fHSyLN1cQ5yVULl40dO1aS6+uuu46efvppmV/90EMPyXraag8zLxXGVclnzZpF119/PS1fvlyGr3NFcxW/x5QpU2jo0KE0bNgwWTKMf75p06bJ4w05FoBA4kJj6w4UypzoLzdn08TB7TQxzJwbAH4/VCLVyNUh5GqBtEEdYqVnmxsNAEAjSTev7XnBBRdQZWWlBDoOarwAeXh4uKyRiaQbAABAG5orZh8+fFgSbF7rm5fkOuOMM2jt2rVyXV2CjCuJT5w4UaqAc9XxV1991ft8TtCXLFki1co5AY6IiJDk+fHHH/fuw0uxcILNldV5mbP27dvTggULvGt0s0mTJskSY7Nnz5bEfeDAgbKcmG9xtfqOBSCQDHqdVC9/7Ye9MsS8pMpBfxrSPigJLc/V5uHjv+4vpO1ZZeR0K941tnulRsk623xpNGDgK4Dm1uk+55xzZB4Xr6/JLcq///67DOX685//THfccQddfvnlgTvaEId1PwGgLcCan037nJozViBmnxzEa2iqX/YV0pJNmeRwKTJPmodun94tkaymwM+TdrkV+v1wMf24M5+yS23e+9NjrDS4YxwNyIilSMtJDXaFVggxW6PrdG/cuJH+9a9/SSsyt1xzK3KXLl1kuBi3WiPpBgAA0AbEbIDgGNY5njolhtPidYdlOPd323Lpx1351CctmoZ2iqMuSZHN/p42h4vW7S+in3bnSw8744SfE+1TO8VRWkzorzQAEKoanXRzrzYn3IyHpvEcsd69e0uGf+jQoUAcIwAAAJwExGyA4EmOstIt53SlzUdKaOnWHMovr6YNh4plG5QRSxecktbkHmdOtPflV9DOnDLaeKiYbA7P6gVRVqPMLx/ROQFF0QA0oNH/0gcNGkS//vorde/enc4++2yZV8Xzw/7zn/9Qv379AnOUAAAALWDq1Kmy3NSnn34q19966y1v8tqhQweaPHkyPfjgg2Q0hsbQTMRsgODiImqntI+l/u1iPEuJHSykX/cXSeK9NatUlufiYecRDUi+nS43FVZW05GiKjpYWClVx3n4uO9E0aRIM53ZI4kGZsSSCXO1oZWbGkIxu9FH8OSTT1JZWZlc/8c//iE/DBdG4ST8zTffDMQxAgAABMX48eNp4cKFMpXqyy+/lGrbHMwfeOCBkDgjiNkA2km+OySEyza0Yzx9uuEIZZbYaMWOPBl2zkk5DzvvlBBBeq50VtOLfaS4inbnltPO7DJJsGtqofmJjzBR9+Qo6pUWRT1TojRRLR0gGMZrOGY3OunmZTpUPLycq4YCAAC0RrycVWpqqlznBuZPPvmEPvvsM00E8IZAzAbQnoz4cLr13G60JbOUvt+ZJ3O+1WHnkRYDJURaqLjS4Z2X7YvnaCdFWahjQrgk6PxaWOoLQPsxO/h97QAA0OrxQhkO97FfIFuCSW9qtp6fsLAwWTYLAKAp+G9Sv3Yx1Dc9WpJurnbOSXi53UXl9krvfnHhJuoQH049U6OoS2IkRYcZ0ZMNAdVa4rXWYnajk24ulX6iD2Pv3r1NPSYAAGhlOIDP+WVOUN77gWEPkNlgbvKXkGXLltE333xDt912G4UKxGwAbePv1NxbzdulgxTal19OldUuig0zU2KUmcLN6B+DlhXq8VqrMbvR/5LvvPNOv9sOh4M2bNggw8zvvffe5jw2AACAoFqyZAlFRkZKrHO73XTNNdfQo48+GjJnBTEbIHQY9DrqlhwV7MMACFlLNByzG51033HHHXXeP3fuXFq3bl1zHBMAALQyPGSMW7CD9d4na9SoUTRv3jwym82Unp6uiQqojYGYDQAAbSFeaz1mN9uRnH/++TJJnSvGAQAA1B5C2RxDxlpaREQEdevWjVobxGwAAGhN8VrrMVvfXC/00UcfUXx8fHO9HAAAAAQIYjYAAICGe7oHDRrkV0iNJ6pnZ2dTXl4evfrqq819fAAAAHCSELMBAABCMOm+9NJL/W7r9XpKSkqic845h3r16tWcxwYAANCiFi1aVOf1UIWYDQAArdWiEIrZjU66H3nkkcAcCQAAADQrxGwAAIAQSbpLS0sb/ILR0dFNOR4AAABoAsRsAACAEEy6Y2Nj/eZxn4jL5WrqMQEAAMBJQswGAAAIwaR7xYoV3uv79++n+++/n6ZOnUojR46U+9asWUNvvfUWzZkzJ3BHCgAAAPVCzAYAAAjBpPvss8/2Xn/88cfpueeeo6uvvtp738UXX0z9+/en1157jaZMmRKYIwUAAIB6IWYDAACE+Drd3Ks9dOjQY+7n+3755ZfmOi4AAABoIsRsAACAEEy6MzIy6PXXXz/m/gULFshjAAAAoA2I2QAAACG4ZNjzzz9PEydOpK+++oqGDx8u93EP965du+i///1vII4RAAAATgJiNgAAQAj2dF9wwQW0c+dOuuiii6iwsFA2vs738WMAAACgDYjZAAAAIdjTrQ5Xe/LJJ5v/aAAAAKBZIWYDAACEQE/3pk2byO12e6+faGuMefPm0SmnnELR0dGy8RJkPGxdZbPZaObMmZSQkECRkZEyrD0nJ8fvNQ4ePEgTJkyg8PBwSk5OpnvvvZecTqffPitXrqTBgweTxWKhbt260aJFi445lrlz51KnTp3IarXKsPnaReEaciwAABDaeDnMSy+9VK7n5eXRjBkzqEOHDhI/UlNTady4cbRq1Srv/hw3dDqdbByHeCUPrnESTIGK2QAAAFoyNYRidoN6ugcOHEjZ2dmS1PJ1PlBFUY7Zj+93uVwNfvP27dvTU089Rd27d5fX47W+L7nkEtqwYQP17duX7rrrLvriiy9o8eLFFBMTQ7feeitdfvnl3g+P34sTbv5QV69eTVlZWTR58mQymUzenvh9+/bJPjfffDO98847tGzZMrrhhhsoLS1NTgT74IMP6O6776b58+dLwv3CCy/IYzt27JCfmdV3LAAA0Lpw42p1dbXEpi5dukhDK8eQgoICv/14Kc0bb7yRKisrJUbw9Xbt2tH5558flOMOVMwGAADQqolaj9lKA+zfv19xu93e6yfamiouLk5ZsGCBUlxcrJhMJmXx4sXex7Zt28bfGpQ1a9bI7S+//FLR6/VKdna2d5958+Yp0dHRit1ul9uzZs1S+vbt6/cekyZNUsaNG+e9PWzYMGXmzJne2y6XS0lPT1fmzJkjtxtyLA1RUlIiz+FLAIDWqqqqStm6datchpopU6Yol1xyiVJUVCR/r1euXHnC/Tt27Kg8//zzfvfFx8crd91110l/Tk2NFS0Zs1srxGsAaCsQs+Prjdkn+owaGi8a1NPdsWNH7/WUlBQZgt3cuLWdWxsqKipkmPn69evJ4XDQmDFjvPv06tVLhgzwuqMjRoyQSx4WwMek4h5qHlqwZcsWGjRokOzj+xrqPnfeeadc5xYRfq8HHnjA+7her5fn8HNZQ44FAACOj3taFYcjKB+RzmSSXt3G4GlEvH366afyN56HqtWHh3R/8sknVFRURGazmYKlJWI2AAC0TqEWr0MlZje6kBoPV7vsssvoz3/+M40ePVoS1KbYvHmzJNk8Z5o/LP7h+/TpQxs3bpQPIDY21m9//gLBw+YYX/om3Orj6mMn2qe0tJSqqqrkg+aEv659tm/f7n2N+o6lLna7XTYVvycAQFvEATzniX8E5b1THvob6RoZUI1Go9T/4GFnPPWI64KcffbZdNVVV0ktEl/33XcfPfTQQ/L3nmuKxMfHyzQmLWjumA0AAK1bqMXrUInZjY6+PE6ex8Dz3Gse/849xuvWrTvpA+jZs6ck2D///LP0UE+ZMoW2bt1KrcGcOXNk/re6cQVZAAAInflhmZmZ9Nlnn9H48eO9RTlrF+PkAp4cx5YvXy51QXhtbC7aqQXNHbMBAAC0aKLGY3aje7q5xZy3srIy+uijj+i9996TbnyesM4t6bNnz27U63EPsvqDDhkyhH799Vd68cUXadKkSTL0u7i42K+HmSfFc+E0xpe1q4yrFcV996ldZZxvc7X0sLAwMhgMstW1j+9r1HcsdeEh61ygzbenG4k3ALRFPGSMW7CD9d4ni4dmn3feebI9/PDD0hr+yCOPSMVUVWJiosQx3niaFE97Gjp0qIzaCrbmjtkAANC6hWq81nrMPulxZlFRUTRt2jT69ttvZdmRiIgIeuyxx5p8QDy+nrv7OQHnKuRcdU7F1cR5iTAejs74koen5+bmevdZunSpJNTqB8f7+L6Guo/6Gpz083v57sPHwLfVfRpyLHXh+QTqcmjqBgDQFvEcLb3ZHJTtZOaHHQ/HFq49cjzcsMqNxr51QrSguWM2rzzCn6taH4VhmU8AgNDXWuK11mL2SSfdHFw//PBDWRuNu+4LCwulu74x+Af84YcfaP/+/ZI8820eCnDttdfKcOzp06dLT/GKFSukmBl/YeAkVy1cNnbsWPkwr7vuOvr999/pm2++kTH6vJ62OoGelwrbu3cvzZo1S+Zov/rqq3LcvASYit/j9ddfl2F427Ztk2HufIL4/VhDjgUAAFoPXmLk3HPPpbfffluSVF5+klvEn376aRmqfSJ33HEHff7555oaxt0cMVvFI9L+9a9/HTNPjuMq/9z8OX3//fcyzI+X1lSpy3zyyDFe5pNjLg/78+1tV5f5HDVqlAz/46Seeyo4vqvUZT659+K3336jAQMGSIFU3wb4+o4FAABaj4JQiNmNLSv/9ddfK5MnT5ZluXhZlJtuukn5/vvvlZNx/fXXy3IrZrNZSUpKUkaPHq18++233se5LPstt9wiy4iFh4crl112mZKVleX3Grzkyfnnn6+EhYUpiYmJyj333KM4HA6/fVasWKEMHDhQ3qdLly7KwoULjzmWl19+WenQoYPsw0uIrV271u/xhhxLfbAECQC0Ba1h+RGbzabcf//9yuDBg5WYmBj5u9+zZ0/loYceUiorK0+4ZBjjZSk5NgVjybBAxWxWVlamdO/eXVm6dKly9tlnK3fccYfc39qW+US8BoC2AjFbqTdmN8eSYTr+X2OS9PDwcLrwwgulN/qCCy6QYdfQMDynm3vNS0pKMNQcAFot7lXlVubOnTtjuaqT+JyaM1Y0d8zmYqdc6ZULz5xzzjk0cOBAeuGFF6QgDVdH5xVBfGuf8PJl3FvNPc/co80FbrgHW8U/P88v5x5rXubzrLPOkp54fk3VwoUL5TX48+Becv6ZeH4699r7HhfXXfnf//7XoGNpyGojPOwQ8RoAWjvE7KZ9Rg2N2Y0upMbFw3huGAAAAGhbc8bs999/X5JjHl5eW0OW1tTyMp+82khz1KUBAAA46aSbg52auXPH+InWm0axMAAAgOAJRMw+dOiQzHvjQqS1W/lbA6w2AgAAQU+64+LiKCsri5KTk6XluK7KchzY+X5ugQYAAIDgCETM5gKiXKiMh36r+LlcDPWVV16RQmehvMwnF19VC7ACAAAEJenm+VE8h4tx9W4AAADQpkDEbJ4jzauM+OJVPHr16kX33XefzH9Wl9acOHHicZf5/Mc//iHJOzcIHG+Zzy+//LJBy3yqc7rVZT5vvfXWY5b5PN6xAAAAaC7pPvvss+u8DgAAANoSiJjN88L79evndx+v9Z2QkOC9X11akxN+TqRvu+224y7zycu48Pzqupb55J5zXubz+uuvlwYEXursiy++8L4vvwcXThs6dCgNGzZMiq4db5nP4x0LAACA5pJuXu+soWqv2wkAAAAtJ1gxmyua6/V66V3mSuC8dvarr77qfZyHhS9ZsoRmzJghCTAn7Zw8P/744959uDIsJ9hcYfzFF1+k9u3b04IFC+S1VJMmTaK8vDyphs6JO1dQ//rrr/2Kq9V3LAAAAC2pQUuGceDiuV/qHLATwZzu48OSYQDQFmD5kaZ9Tk2NFYjZTYd4DQBtBWJ2yywZpm/A+8ib7N27Vy7/+9//yhtyi/GGDRtk4+tdu3aVxwAAACB4ELMBAABCcHh5x44dvdevuOIKeumll+iCCy7wG57GRVQefvhhb2ETAAAAaHmI2QAAANrSoJ5uX1y9lHu6a+P7tm7d2lzHBQAAAE2EmA0AABCCSXfv3r1pzpw5sgamiq/zffwYAABAqJo6dap3xBYX6+KiXx06dJDq2rzGMxfkWrVqlXf/Tp06SfXs2h599FEp8BVsiNkAANBaTQ2hmN2g4eW+5s+fTxdddJFUFFWrnnKlVC6w9vnnnwfiGAEAAFocV77mRuW33nqLunTpQjk5ObL2c0FBQcicDcRsAABoCyZqPGY3OunmNTG5qNo777xD27dv9y7fcc0118jyHwAAAKGuuLiYfvzxR1q5cqV3rWueK80xMJQgZgMAQGtXHAIxu9FJN+Pk+qabbmr+owEAgFaJl5x0O+tdoTIg9EZdvctd1hYZGSnbp59+SiNGjJChaqEKMRsAAFprvA6VmH1SSfeuXbtoxYoVlJubS2632++x2bNnN9exAQBAK8EB/IcPdwblvc+6sgcZTI0L4kajkRYtWkQ33nijDNEePHiwtJ5fddVV3qlVqvvuu48eeughv/t4iFufPn1ICxCzAQCgtcbrUInZjU66X3/9dZmknpiYKBPUfVsj+DqSbgAAaC3zwyZMmCBD1tauXUtfffUVPf3007RgwQIp3qK69957/W4zXlrzhx9+oGBDzAYAgLZgosZjdqOT7ieeeIL+8Y9/SCsBAABAQ4eMcQt2sN77ZFmtVjrvvPNke/jhh+mGG26gRx55xC9gcyN0t27d/J4XHx9PWoCYDQAAbSFeaz1mNzrpLioqoiuuuCIwRwMAAK0Sj4Q6mSFjWsPDz3jOWKhAzAYAgLYYr7UWsxu9Tjcn3N9++21gjgYAAEADeImRc889l95++21ZFnPfvn20ePFiGap2ySWXUKhAzAYAgNauIARidqN7urk7nrvreax8//79yWQy+T1+++23N+fxAQAAtDiugjp8+HB6/vnnac+ePeRwOCgjI0OKtDz44IMhc0YQswEAoLWLDIGYrVO4LnwjdO7c+fgvptPJGt5Qt9LSUoqJiaGSkhKKjo7GxwQArZLNZpNWZo4XPL8KGvc5NWesQMw+OYjXANBWIGY37TNqaLxodE83vyEAAABoH2I2AABACM7pBgAAAAAAAICGaVBP9913301///vfKSIiQq6fyHPPPdfAtwYAAIDmhpgNAAAQgkn3hg0bZEK6ev1Ec7oBAAAgeBCzAQAAQjDpXrFiRZ3XAQAAQFsQswEAALQFc7oBAAAAAAAAAgRJNwAAAAAAAECAIOkGAAAAAAAACBAk3QAAAAAAAADBTLoHDx5MRUVFcv3xxx+nysrKQB0PAAAANAFiNgAAQAgm3du2baOKigq5/thjj1F5eXmgjwsAAKDFTZ06lS699FK/+9asWUMGg4EmTJgQEmcEMRsAANqCqSEUsxu0ZNjAgQNp2rRpdMYZZ5CiKPR///d/FBkZWee+s2fPbu5jBAAACJo33niDbrvtNrnMzMyk9PR0TZ8NxGwAAGir3tBozG5Q0r1o0SJ65JFHaMmSJaTT6eirr74io/HYp/JjSLoBAKC14JFdH3zwAa1bt46ys7MlHj744IOkZYjZAADQFpVrOGY3KOnu2bMnvf/++3Jdr9fTsmXLKDk5OdDHBgAArQSPknI5nUF5b4PRKI3CJ+PDDz+kXr16SRz885//THfeeSc98MADJ/16LQExGwAA2lq81nrMblDS7cvtdgfmSAAAoNXiAL5i4b+C8t6jpv2FjCbTST2Xh6dx4Gbjx4+nkpIS+v777+mcc86hUICYDQAAbSFeaz1mn9SSYXv27JGx8mPGjJHt9ttvl/sAAABaix07dtAvv/xCV199tdzmaVWTJk2SoB5KELMBAKC126HxmN3onu5vvvmGLr74YinUcvrpp8t9q1ator59+9Lnn39O5513XiCOEwAAQhgPGeMW7GC998ngQO10Ov2KsPCwO4vFQq+88grFxMSQ1jVXzJ43b55s+/fvl9v8fK7hcv7558ttm81G99xzj0xFs9vtNG7cOHr11VcpJSXF+xoHDx6kGTNm0IoVK6QY65QpU2jOnDl+NWJWrlxJd999N23ZsoUyMjLooYcekuq0vubOnUvPPPOMzNcbMGAAvfzyyzRs2DDv4w05FgAAaD3xOhRidqN/svvvv5/uuusueuqpp465/7777kPSDQAAx+D5VE0ZMtbSOHD/+9//pmeffZbGjh3r9xgvT/Lee+/RzTffTFrXXDG7ffv28hrdu3eXLzFvvfUWXXLJJbRhwwZJwPk9vvjiC1q8eLF8sbn11lvp8ssvlwSfuVwuWb4lNTWVVq9eTVlZWTR58mQymUz05JNPyj779u2Tffhzfeedd6R+zA033EBpaWmSODMukMNJ+fz582n48OH0wgsvyGPcw6HWmqnvWAAAoPXE65CJ2UojWSwWZefOncfcv2PHDnkMjq+kpEThj5wvAQBaq6qqKmXr1q1yGWqmTJmiXHLJJconn3yimM1mpbi4+Jh9Zs2apQwdOjRgn1NzxopAxuy4uDhlwYIF8hmZTCZl8eLF3se2bdsmP8OaNWvk9pdffqno9XolOzvbu8+8efOU6OhoxW63ez/Xvn37+r3HpEmTlHHjxnlvDxs2TJk5c6b3tsvlUtLT05U5c+bI7YYcS0MgXgNAW4GY3bTPqKHxotFzupOSkmjjxo3H3M/3oaI5AAC0BjxMjWuW1DUcbeLEibIcyaZNm0jrAhGzudeah25XVFTQyJEjaf369eRwOOTzUnH12A4dOtCaNWvkNl/279/fb4g391CXlpbKUHJ1H9/XUPdRX6O6ulrey3cfXlGFb6v7NORY6sLD0PlYfDcAAAgNb4RAzG708PIbb7yRbrrpJtq7dy+ddtppch8P2frnP/8pQ74AAABCFa/pWR+eP8xDrENBc8bszZs3S5LNc6Z5TvYnn3xCffr0kQTebDZTbGys3/6cYPO8a8aXtedUq7fr24cT4KqqKioqKpKEv659tm/f7n2N+o6lLjy3/LHHHmvU5wEAAMG1KIRidqOT7ocffpiioqJkzDyve8Z4wvqjjz4qVcwBAABAG5ozZvO6p5xg8xIsH330kRRC46VYWgP+bHwbITjR50JuAAAAQUm6eXI9FynhraysTO7jgA4AAADa0pwxm3uQu3XrJteHDBlCv/76K7344ouyJAsP/S4uLvbrYc7JyZHCaYwveSkXX/y4+ph6qd7nu090dDSFhYWRwWCQra59fF+jvmOpC1e35Q0AAEAz63SrOHAj4QYAANC+5o7Zbrdb5kJzAs5VyLnauIqrifMSYTwcnfElD0/Pzc317rN06VJJqHmIurqP72uo+6ivwUk/v5fvPnwMfFvdpyHHAgAA0NJOfjE0AAAAaBN4+DWvyc0FybjH/N1335U1tXkdcC5cM336dBmeHR8fL4n0bbfdJknuiBEj5Pm8hAsn19dddx09/fTTMr+a1+CeOXOmt4eZl3PhtVRnzZpF119/PS1fvpw+/PBDWf5Lxe/Bw9qHDh0q8/R4yTAu6DZt2jR5vCHHAgAAEFI93U3FhUtOPfVUaXnnKqq8jhq3SPvigi0clBMSEqRwC1egqz20jFuweW3P8PBweZ17771X1mvzxV8OBg8eLMGdh8fVNfF+7ty51KlTJ7JarbL+Z+2hcA05FgAAgNaGe6h5XW2e1z169GgZWs4Jt7rO9/PPP08XXnihxMWzzjpLhnJ//PHH3ufzsPAlS5bIJSfAf/7zn+X1Hn/8ce8+nTt3lgSbe7cHDBgg89AXLFjgXaOb8VD2//u//6PZs2fTwIEDZY75119/7Vdcrb5jAQAAaGk6XjeMgmT8+PF01VVXSeLNSfKDDz5If/zxB23dupUiIiJknxkzZkgQ5iSZW7BvvfVWWSKEq68yrmTKgZeD6jPPPENZWVkSyLli65NPPin77Nu3j/r16yet6DfccIMMO7vzzjvlddVg/sEHH8jz5s+fLwk3t54vXrxYGgHUZVXqO5b6cGEWfh4XoeHWdwCA1ogbKPnvLidR3IgJjfucECuCD+cAANoKxOymfUYNjhdKI1RXVyvnnnuusnPnTiUQcnNzZXHx77//Xm4XFxcrJpNJWbx4sXefbdu2yT5r1qyR219++aWi1+uV7Oxs7z7z5s1ToqOjFbvdLrdnzZql9O3b1++9Jk2apIwbN857e9iwYcrMmTO9t10ul5Kenq7MmTOnwcdSn4Yung4AEMqqqqqUrVu3yiU0/nNqrlgR6JjdmiFeA0BbgZjdtM+oofGiUcPLuThJIBcW5xYCxvOw2Pr168nhcMhi56pevXrJnLI1a9bIbb7s37+/39Ay7r3mVoctW7Z49/F9DXUf9TW40im/l+8+3IPNt9V9GnIsAAAAWhHomA0AAAABmtPN87DeeOMNam5cgZSHfJ9++ukyFJxxoRWuVuq77AfjBJsfU/fxTbjVx9XHTrQPJ+ZVVVWUn58vw9Tr2sf3Neo7ltq4qiu/h+8GAADQUgIVswEAACCA1ct57vWbb75J3333nSzNoc69Vj333HN0MrhAGc/n/umnn6i14EJxjz32WLAPAwAA2qhAxWwAAAAIYE83J8ZcBZwrju/cuZM2bNjg3biK6MnggmRc1XTFihXUvn177/1cHI2HfhcXF/vtzxXD+TF1n9oVxNXb9e3Dk93DwsIoMTFRKqrWtY/va9R3LHUtscJD5tXt0KFDjf5sAACg5UydOlVW0qiNV8DQ6XQSA9Tr6paUlEQXXHCBrEOtNYGI2QAAAFowNYRidqN7ujkxbi5cOJ3Xz/zkk0/kA+GKcL64VZ7npHG1cV76g3E1cV4ijJccYXz5j3/8Q5YzUauM83IjnFDzmqDqPl9++aXfa/M+6mvwsHF+L34f9cTxcHe+zQ0CDT2W2nh5MnX9UQAAaF04BnCsyczMlKUqeenK3bt3S0zRiuaM2QAAAKFqR5Bj9kmv080HyWt08pxodjIrj/GQ8rfffpveffddaYXnudG8qa/J5denT59Od999t3xx4GJm06ZNkyR3xIgRss/YsWMlub7uuuvo999/l2N66KGH5LXVhJeXCtu7dy/NmjWLtm/fTq+++ip9+OGHdNddd3mPhd/j9ddfp7feeou2bdsmy4NVVFTI+zX0WAAAoO3ghl4e6cQ9yVyThEczcYzRouaI2QAAAKEqOcgxu9E93QUFBXTllVdK4sld9Lt27aIuXbpIQhoXF0fPPvtsg19r3rx5cnnOOef43b9w4UIZLsCef/55qSTOvctcmIyrjnPSrOJh4Tw0nZNkToB5vtqUKVPo8ccf9+7DPei8vjYn2S+++KIMYV+wYIF3jW42adIkysvLo9mzZ0viz2t/f/31137F1eo7FgAAqJskea4gJXoGz5CyQOHpQ++//75c11Ivd3PHbAAAaP1ac7wOZsxudNLNiSsPs+Zh1b179/ZLWrkXuDEBvCEt7bwA+dy5c2U7no4dOx4zfLw2Tux5DtuJ8FBydTj5yR4LAADUwaVQ8Wd7gvLRxF7clcjY8CDODbmRkZF+9/EKF7WpNUh4VBS7+OKLZSlJLWnOmA0AAG1ACMXrUIrZjU66v/32Wxmi5lvwjHXv3p0OHDjQnMcGAADQ4kaNGuUdiaX6+eefZfktXz/++COFh4fT2rVr6cknn6T58+eT1iBmAwBAazYqRGJ2o5Nubh3gA66tsLAQRcMAAKBuBp2nBTsYDI1rNedpSt26dfO77/Dhw8fsx1OXYmNjqWfPnlLMk3uPf/jhB9ISxGwAAGit8TqUYnajC6mdeeaZ9O9//9t7m8fdc6Xvp59+WloaAAAAapOlOoz64GwBnh/GuHgnL8/Fq3FoCWI2AAA0RmuP18GK2Y3u6ebkevTo0bRu3TpZt5orgm/ZskV6uletWhWYowQAANAwHgF244030iOPPCJLT7bUF4f6IGYDAAAEP2Y3uqe7X79+tHPnTjrjjDPokksukaFrl19+uRQp69o1SEMRAAAAgowLcfKSk4sXLyatQMwGAAAIfszWKViss8WUlpbKet9cqp4XZwcAaI1sNhvt27dP5k/xqg/QuM8JsSL4cA4AoK1AzG7aZ9TQeNHo4eWsqKiI3njjDWkdYH369KFp06ZRfHz8ybwcAAAABAhiNgAAQHA1eng5V3nr1KkTvfTSSxLIeePrnPlrrWorAABAW4aYDQAAEHzGk6n2xiXWeT00g8HgXYD8lltukcc2b94ciOMEAACARkLMBgAACMGe7t27d9M999zjTbgZX7/77rvlMQAAANAGxGwAAIAQTLoHDx7sncvti+8bMGBAcx0XAAAANBFiNgAAQIgML9+0aZP3+u2330533HGHtJ6PGDFC7lu7di3NnTuXnnrqqcAdKQAAANQLMRsAAEBbGrRkmF6vl0XD69uV9+H53VA3LEECAG0Blh9p2ufU1FiBmN10iNcA0FYgZmtoyTB+EwAAANA+xGwAAABtaVDS3bFjx8AfCQAAADQZYjYAAECILxnGMjMz6aeffqLc3Fxyu91+j/GcbwAAANAGxGwAAIAQS7oXLVpEf/nLX8hsNlNCQoLM41bxdSTdAAAQqqZOnUrFxcX06aef+t2/cuVKGjVqFBUVFdHGjRvluhr3oqKiqEuXLnTeeefRXXfdRWlpaaQViNkAANBaTQ2hmN3opPvhhx+m2bNn0wMPPCDFWgAAANqiHTt2SNEULqLy22+/0dNPP01vvPGGBPv+/fuTFiBmAwAAUNBjdqOz5srKSrrqqquQcAMAQJuWnJxMqamp1KNHD4mLq1atoqSkJJoxYwZpBWI2AAAABT1mNzrpnj59Oi1evDgwRwMAAK0SLznpdDqDsjVgZcxmERYWRjfffLMEcq55ogWI2QAA0BhtIV4HI2Y3enj5nDlz6MILL6Svv/5auuJNJpPf488991xzHh8AALQCLpeLvvrqq6C89/nnn09GY8PD3ZIlSygyMvKY42+IXr16yeX+/fulVT3YELMBAKC1xutQitn6kwng33zzDeXk5NDmzZtpw4YN3o0nqgMAAIQyLrjC8cx3W7BgQYOeq7bS+xYZDabmitn8OqeeeqoUoOEvJpdeeqnMj/Nls9lo5syZUmSVvwBNnDhR3tfXwYMHacKECRQeHi6vc++990rvhi+eXzd48GCyWCzUrVs3KQZX29y5c6lTp05ktVpp+PDh9MsvvzT6WAAAIPSNCpGY3eie7meffZbefPNNqRYHAADQEAaDQVqwg/XejRERESHJnq/Dhw836Lnbtm2TS04ItaC5Yvb3338vSSwn3pwkP/jggzR27FjaunWrfF6Mq8B+8cUXMgUtJiaGbr31Vrr88stl6J7a88AJN8+pW716NWVlZdHkyZNlxNyTTz4p++zbt0/24SF/77zzDi1btoxuuOEGqS47btw42eeDDz6gu+++m+bPny8J9wsvvCCPcSOA2lNR37EAAEDox+tQitmNTrq55fn0008PzNEAAECrxK3IjR0yFmqqqqrotddeo7POOkuKs2hBc8VsnlLmi3ufOcFdv369/LwlJSVSBfbdd9+lc889V/ZZuHAh9e7dm9auXUsjRoygb7/9VpL07777jlJSUmjgwIH097//ne677z569NFHZSlSTqQ7d+4sjQWMn//TTz/R888/7026eRrbjTfeSNOmTZPb/BxOsLlx4f7772/QsQAAQNuN18GI2Y0eXn7HHXfQyy+/HJijAQAACBFceCU7O5t27dpF77//viS3+fn5NG/ePNKKQMVsTmxZfHy8XHLy7XA4aMyYMX5z5Tp06EBr1qyR23zJtWA44VZxIs3Lt2zZssW7j+9rqPuor1FdXS3v5bsPL1/Kt9V9GnIsAADQtuQGOWY3uhmD500tX75cJq337dv3mEJqH3/8cXMeHwAAgCb17NlTegR4znCXLl1kuDUPe+bh01oRiJjtdrvpzjvvlC8s/fr1k/v4iwz3VMfGxvrtywk2P6bu45twq4+rj51oH07MuVeiqKhIhqnXtc/27dsbfCy12e122VT8fgAA0Hr0DHLMbnTSzUGM50UBAAC0NnUV7WLnnHOOt+CK73WtC0TM5rndf/zxhwz7bi24UNxjjz0W7MMAAIBWGrMbnXTzvCgAAADQvuaO2VyQjHvNf/jhB2rfvr33fu4p4KHfxcXFfj3MXDFc7UXgy9pVxtWK4r771K4yzrejo6NlTVUussNbXfv4vkZ9x1LbAw88ID0evj3dGRkZJ/EJAQAANMOcbgAAAGhbuJeAE+5PPvlEhqtzsTNfQ4YMkaHrXG1cxdXEeYmwkSNHym2+5GXLeF6daunSpZJQ9+nTx7uP72uo+6ivwcPG+b189+Hh7nxb3achx1JXwTk+Dt8NAAAgaD3dHGhPtJbZ3r17m3pMAAAA0AyaK2bzkHKuBv6///1P1upW50bzclzcA82X06dPl95iLq7GSettt90mSa5aLZznz3Fyfd1119HTTz8tr/HQQw/Ja3PSy3ipsFdeeYVmzZpF119/vST4H374oVQnV/F7TJkyhYYOHUrDhg2TJcMqKiq81cwbciwAAACaTrq5eIovrhC6YcMGWU7k3nvvbc5jAwAAgCZorpitVnfluXG1h6+ra4Dzsl5cSXzixIlSlIyrjr/66qvefXlYOA9NnzFjhiTAvLYqJ8+PP/64XyMBJ9i8zvaLL74oQ9gXLFjgXS6MTZo0ifLy8mj27NmSuPPSY/zz+BZXq+9YAEKFy2Unm+0Q2WxHyOEoJpfbRoriIr3ORHqDlUzGGDKZYslojCGzOZ6MxqhgHzIA1EGnNNPM8rlz59K6desw5/sEeI4Yt8DzUisYugYArZXNZqN9+/ZJAmW1WoN9OCH3ObVErEDMPjHEawgm/mpeUbGLSkrWU3n5DnIrjgY/l5Nwq7UdWcPaUXhYRwoL60g6HWaTwvEhZjftM2povGi2lc/PP/98KUSCQmsAAADahpgNoM1ku7x8O+XnLyObPct7v8kUR2HW9mS2JJFBbyWdzkBuxUluVyU5HCXkcBbLpdNRTA5nCTnKS6isfKs812AIp8jInhQV2ZciIrqRXu+/bCAAtIxmS7o/+ugjmTsFAAAA2oaYDaAtNlsW5eR+QZWV++S2Xm+m2JghFBMzmCyWtBPWZvAdim63Z5LNlklVtsNUWbGHnK4KKinZIBu/ZlRUX4qJHkjh4V3QAw6g5aR70KBBfv/wuVWO51Tx/CrMlwIAANAOxGwAbXO7nVRQsIIKCn8gRXGTTmek+PjTKD7uDDIaIxr1WgaDhcLDO8vG+PWqqg5QWdlW6fnmOeFqAs5zv6OjB0gCbrGkNiipB4AWTLovvfRSv9tcqCQpKUmKq/Tq1asJhwIAAADNCTEbQLuqq/PpyJH3yGb3rAbAvdApyefLcPLmwHO51SQ8OfkCqqo6SKWlG6m0bDM5nWVUWPiTbBZLiiTfnISbTDHN8t4A0MSk+5FHHmnsUwAAACAIELMBtKmsfDtlZS6WauRGQwSlpFxE0dH9A/Z+3JMdHt5RtuTkCZ5CbaUbpFCb3Z5DuXnfUF7et5KgR8cMpOio/jIcHQCaB8oZAgAA1ODlr/jLKW8mk0kqlfKa0Vy5FACgORSXrKcjh9+WhDs8rAN16nRrQBPu2vR6I0VF9ab27a6h7t3up7TUyyg8vBMppFBF5V7KyvqYdu95mnJzv6bq6sIWOy6A1hyzG9zTzcPI65vvwY87nc7mOC4AAICgGD9+vKzEwWtar1+/XtaS5vj2z3/+M2TOCGI2gDYVFa2l7JzP5ToXSktJuViS4GAxGMIoNnaobA5HEZWU/k7FxevkekHhjzL8PCKyJ8XHnS694Jj7DVozPkRidoP/lX/yySfHfWzNmjX00ksvkdvtbq7jAgAACAqLxUKpqalyPSMjg8aMGUNLly7VXAA/EcRsAO0pK9viTbjj406TedZaSmJ5LnliwjmUEH8WlVfspKKiNVRRsVuWMePNakmj+PjTKUqGngevoQAgFGN2g//FXHLJJcfct2PHDrr//vvp888/p2uvvZYef/zx5j4+AABoBXilC0WpDsp763Tmk/5i+8cff9Dq1aupY8eOFEoQswG0tyRYZtZHcj0udrjmEu7aBdiiInvJZq/Op6LC1VRS8pusHc4/gzHvG4qLG0FxscNkHXBoXUI1Xms9Zp9UM1VmZqYUZ3nrrbdo3LhxtHHjRurXr1/zHx0AALQKHMB37AxOw2zPHrNJp7M0eP8lS5ZQZGSkTJey2+0yVPuVV16hUIWYDRBcvH72kSPvkNtdTRHhXSkl5ULNJty1WcyJlJp6MSUljaGi4l9keDxXPs/LW0oFBSspJnqwLHFmNicG+1ChDcbrUIrZjUq6S0pK6Mknn6SXX36ZBg4cSMuWLaMzzzwzcEcHAADQwkaNGkXz5s2jiooKev7558loNNLEiRND7jwgZgNoQ27ul1TtKCKzKY7atbtKepJDDfdo89BzXj+8rGyzzPXmpc6Kin+m4uJfKDKylww9DwvrFDINCtA6jAqRmN3gpPvpp5+WsfE8Zv69996rc+gaAADA8YaMcQt2sN67MSIiIqhbt25y/c0336QBAwbQG2+8QdOnT6dQgZgNoA3l5TupuGQd6UhHaWkTQ344Ns/ljokZRNHRA6mych8VFq2S+d5l5dtkC7O2o7j40yk6qh/pdIZgHy608ngdSjG7wUk3z90OCwuTH4qHlfNWl48//rg5jw8AAjxvx+ksJrs9l1yuCnK5qryXvHSIir8s6PUWqXJqMsWT2ZJEZlMC6fUmnB9oEM+SHo0bMqYFPEztwQcfpLvvvpuuueYaiYOhADEbQBvDyrOzPYWI4+JGSvXv1vQ3PSKii2x2ex4VFfG87w1UZTtCVZkfUp7xa/mZY2NPle8OEDpCNV5rPWY3OOmePHkyhosAtAJut5PKy7d5topd5HJVntTrcCJuMsWSxZouFU2t1nZktaaT0RjZ7McMEExXXHEF3XvvvTR37lz661//GhInAzEbIPgKClaQw1lKZnMCJSWdR62VxZJEqamXUGLiGBlqXlS8Vn7u3LxvKL9gBcXEDJZq7fw5ALTVmN3gpHvRokXN/uY//PADPfPMM7KmWlZWlixxcumll/r1wnHBttdff52Ki4vp9NNPlzH73bt39+5TWFhIt912m1RQ59YNHsP/4osvyoR61aZNm2jmzJn066+/UlJSkuzPC6f7Wrx4MT388MO0f/9+eX0eSn/BBRc06lgAtN7izi3RHAydznLv/Ty3zGxOIpMxWoa98aY3hHHfts+zFXK5beRyVlK1o4Cqq/OkN5znqPHGy6CoTMYYsoa1RyIOrQbPD7v11ltlyPaMGTNkKJvWBSJmA0DDce8vD71mKckTSK9v/LDZUGM0RlBi4iiKjz+Tyso2UWHhKs+876K1VFz0M0VG9vb2+GPeN7S1mB3URfZ4wjuPu7/++uvp8ssvP+Zx/rB4/W8eyt65c2dJirla+tatW8lqtco+vFQZJ+y8Hhsvij5t2jS66aab6N1335XHS0tLaezYsbJm2/z582nz5s3yfrGxsbIf49LyV199Nc2ZM4cuvPBCeS4n/7/99pu3KntDjgVAixTFLS3P+fnLyemqkPs4wY6OHiABkHuoG7veJjdC8TB0Tr5ttkyy8XAy2xGqrs4nh7OEHGUlxybiNT3h4eFdKCwsIyQLyUDrd7xklYdr8wYA0JAYmZO7ROIvFxiLjOzZpj40z7zvwRQdPYgqK/dK0TVe97usfKtsFnOyLDnG88INhtAcxgzasCiEYrZO4b8MGsAtXr493XxY6enpdM8993iHBnAl1pSUFPmAr7rqKtq2bRv16dNHerCHDh0q+3z99dfSQ3348GF5PvdG/+1vf6Ps7Gwymz2tjHwSPv30U9q+fbvcnjRpkjQAcMl51YgRI6RCOyfqDTmWhuAGgJiYGHludHR0M3+CAMfihDgr+xO5ZLykR2LCKIqK6tfoRLuhvel2e6ZfIu6oLvCbH864Nz0yood8EYmI6I75Xq2MzWajffv2SQMlGiUb/zkhVgQfzgE0BTc6Hz7yLul0RurS+XYMq5ae/1zp8S4p3SBLpzGuFcNF2bj3m5cmg+BAzG7aZ9TQeBHUnu4T4R+ME2XuoVbxDzR8+HBas2aNJLp8yT3WasLNeH8eZv7zzz/TZZddJvucddZZ3oSbcQ81Dx8vKiqiuLg42Ycn3PvifTgxb+ixAGiJ2+2QuWQFhT9KSzsXMUlMHE1xscMCWk2UW6x52JhvsRjfRLyq6hBVVO6WeeQlpRtl4x7vsLAOFBnh6Q3goe4YdgYAAKGIE8qc3C/lekL8GUi4a1gsyTXrfY+VxJsTcB4dx5e8RUR0o7jYEfI9ACPhoDXSbNLNSS7j3mRffFt9jC+Tk5OPGccfHx/vtw+3StR+DfUxTrr5sr73qe9Y6sILtPPm2xICEGic2GZmfSTBjPGyHSkpF5LRGBWUD792Is6NAFVVB2QZlfKKHWS351Bl5X7ZcvO+lnVMIyJ7UlRk75p5X1hyBAAAQgM3djscxVJoNCHh7GAfjuYYDFaKjxspCXZl5R5JuHnJsYqK3bKZTHHSQRAbOzTkl1cDCImkuzXgOeKPPfZYsA8D2gieBsGF0jhx5cSW522npFxMUVG9SUu4BVtNwpNpHDkcRVRevsMTdCv3eYqz1bR8cw99ZERPiozqTZER3WUoGgAAgBZxY3dBwQ9yPTn5/DZRPK1pS451k626upCKi3+V9cz5O4FUPc9fTtHR/WXoOdeDAQh1mk26U1NT5TInJ4fS0tK89/Ntnmut7pObm+v3PKfTKRXN1efzJT/Hl3q7vn18H6/vWOrywAMP+A1b557ujIyMRn4SAA1bBozXAuXh2mrvdmrqpSExV1pateNGyOZ226miYq8k4LykGRd+U4eh63UmCc6eBLwnliYDAABNNXxn53xOiuKUWBUV2TfYhxQyzOZ4Sk4eR4mJ51Jp2SYqKlxDNnsWFZf8JhtPQePvCPyZBqIeDUBL0Gz5YB4SzsnusmXL/JJWnqs9cuRIuc2XvHwXLzmmWr58Obndbplvre7DS5NxZXMVVzrv2bOnDC1X9/F9H3Uf9X0acix1sVgsMqHedwNobjxn+vCR/3jnR6emXETp6VeFRMJdG/dkc898Wtpl1K3b/dSxw40Uz3PiTHHkVhxUVr6NsrI+pt27n6IDB1+X5Ui4hRwAACCYyso2y/BoLp6WknIRapOcBL3eRLExQ6hTp5nUqeNfKCZ6gEwxq6o6SJmZH9KePU9Tbu43ZK+ZPgcQSoLaXFReXk67d+/23uaCZRs3bpQ52R06dKA777yTnnjiCVkLW12mi6uIqxXOe/fuTePHj6cbb7xRqoxzYs3rsnFhM96PXXPNNTLEe/r06XTffffRH3/8Iet4P//88973veOOO+jss8+mZ599liZMmEDvv/8+rVu3jl577TXvEJj6jgUgWAXTDh/5t8yH5mFs7dKvpsjIHq3iZHiGoXeSLTlpPNnt2dL7XVa2VVrA1XngXLDGYkmlKFmWpY8MQ0MhNgAAaMnGb2/xtISzUIm7iTiGc+82b8nO86m4eJ0sfepwllJB4Q+y8XeD2JihFBXFvd8Yxg/aF9SkmxPbUaNGeW+rQ7GnTJkiS3HNmjVLlvLi9bS5R/uMM86QJcF8S7W/8847kmiPHj1aqpZPnDhR1tP2rTL+7bff0syZM2nIkCGUmJhIs2fP9q7RzU477TRZm/uhhx6iBx98UBJrrlyurtHNGnIsAC2J521zy68n4bZQh4zrKSysfasNwFZrmmw8/IznfJWVbZNh6JVV+yQh5y2/YKWsCc7VT3ltVF4TnFvOAQAAAiU//ztyOsukUnlC/Fn4oJsRF4FNTBwljRkc8zkBr6jY5W14N+QsoejoAVJ4DXO/Qcs0s053W4B1P6E55eR8QYVFq2UoW4eMqX7LdLUlvPwYF2LjoecciNX1Pxm3fkeEd6tJwnsGrYJ7W4M1P5v2OSFWBB/OATQUL4e5f/+rpJBCGRlTpegnBJbDUUIlMt97vTTCqzjp5t7v6OhTQnKKXbAgZrfxdboB4PhKSzdJws3S069oswk34yVFYmIGycbD7Ssr1UJs22UoWln5Vtl0pCNrWIa3F9xiTsEwdAAAaNKIs+zs/0nCHR3VHwl3CzGZYmp6v8+RZce495sb3rkBJNv2GeXmfkVRUf0oNnYIhYV1QqwHTUDSDRBi7PY8ysr+RK7zcCuuVA4ePJRc7dVWlIvJbs/yJuBVtiNSjIW3vLylUjU9smY9cA7KqIgKbOrUqfTWW2/JdaPRKDVGTjnlFLr66qvlMZ7GBADAONmrsh2WKV7JyRfgQwnismNOZwWVlm6U3m+7PYdKSjfIZjYnSnG26OiBZDKhoHFrMzWEYjaSboAQWxosM/MDGUIdEd6FkhLPC/YhaXweeLpsnnngpZ4EvGI7VVbslSFpvBY4b/yFiYcEcg84J+Lcew5tFxfoXLhwIblcLlkakut3cMHNjz76iD777DMJ7ADQtvEc7ry8b+R6UtJ5SOiCzGiMoPj40yku7jSy2Q5Jg0hp2WZZO53X/c7L+1bqvETHDKCoyH5kMFiCfcjQxmK2No4CABokP3+ZVO42GiIoPf1KqfANDcMt3HFxw2Q7uh74Niqv2EFOZzmVlv0hGw9DDwvvSJERvWRNcIs5ER9xG8PLPfIykaxdu3Y0ePBgGjFihBTs5CKfN9xwQ7APEQCCLDf3a3K5bdKwGxfrWaYWNFb5PHmCLOVWUrKeKqsOUkXlHtlydJ9LI3t0zECp+4KRbqHNEiIxG0k3QIiorNxHhYU/yvXU1EtRFKwZ1gPnjWtJ2myHvcPQbfZsb1XU3LyvpRotB2fPMPSOaOg4Sfw5VwepbqdZp2vynL5zzz2XBgwYQB9//LFmAjgABAc32paUbpRG2tSUSxAXNIp7s7mqOW/V1YVUWvq7bPbqPOkF541HtvF8fK6Azok6lhwN/Xit1ZiNpBsgBLhcVZSZuViKtfDcpKioPsE+pFbWKp4hGw8RlOXIahJwbuiori6gwsJVsnE11MiIHpKER0R0R3XURuAA/tCuIxQMT3RvR5ZmCOK9evWiTZs2UVv1ww8/0DPPPEPr16+nrKws+uSTT+jSSy/1+6L2yCOP0Ouvvy5La55++uk0b948WYZTVVhYSLfddht9/vnn3mU+X3zxRYqMjPTuw58xL/P566+/UlJSkuzPy3b6Wrx4MT388MO0f/9+ef1//vOfdMEFFzTqWABOdppXds7/5Hps7LBWu1Rna2M2x3uLr3HBtdIyTwLOI92Kin+WzWyKk+Sb539bLEnUVrWGeK3FmI2xqQAax18euTqqw1kiva4pKROCfUitGhdYi48bSR0yplH3bn+jdu2uppjoQdIazo0fJaW/05HMD2jX7ifp4ME3JRnnxBzaxr/FttwLUlFRIT0Hc+fOrfPxp59+ml566SWaP38+/fzzzxQREUHjxo2TpVZU1157LW3ZsoWWLl1KS5YskUT+pptu8lt6ZezYsdSxY0dJ7jnJf/TRR+m1117z7rN69WopkjN9+nTasGGDJP68/fHHH406FoCTwSPOeJ6w0RgpDbUQig3t7Sgl+QLq1vU+WeaNYzwvMVrtKKL8gpW0d98Lsgwcx3dengxCk6KxmI2ebgCNKy3dIEOgeP52etqVMjQaWm5oGleH542XhuHK57wmOM8F5+Fp3vlhuV+SxZxcU4itl/SaY779sUPGuAU7WO/dHLZt2yZrdLZV559/vmzH+3Lzwgsv0EMPPUSXXHKJ3Pfvf/+bUlJS6NNPP6WrrrpKPj8ucMM92EOHDpV9Xn75Zemh/r//+z9KT0+nd955h6qrq+nNN98ks9lMffv2pY0bN9Jzzz3nTc65Z5wL59x7771y++9//7sk8a+88ook2Q05FoCTwSOhCgq+l+tcrRxrQYc2jtNSRDWiO7ndF0l852kDFRW7PCue2I5IfA+zZlBUVF/ZuMe8tWsN8VqLMRtJN4CGcQ9qds7ncj0xcTSGsQU5OIeHd5ItOXmc9HRwgOa1QauqDpC9OpfshblUUPiDFLqLiOjhXcqEe0TaOm5tbq4hY8GwfPly2rx5M911113BPhRN2rdvH2VnZ9OYMWO898XExNDw4cNpzZo1kujyZWxsrDfhZrw/DzPn3ujLLrtM9jnrrLMk4VZxDzUPHy8qKqK4uDjZ5+677/Z7f96HE+qGHgvAycjN+5bcioPCwztTdNQp+BBbEe7QiI4+RTZPcdXNVFa6iaqqDlGVzbNxnRerJc2bgFssydQahXq81mrMRtINoFGK4pJ53Lw8GCd6CfFnBfuQwAev/Rkfz9vpMuycW8Y5Aa8o30lOV4V3jVAWZm1Xk4B3rynUYsBnqWF2u12SNt/lR+bMmUMXXnghTZ48OdiHp0n8eTHuTfbFt9XH+DI52f9Lqrququ8+tXsm1Nfkxzjp5sv63qe+Y6nrnPPmO8wdwBcnX6Wlm6R4Gg9N1tKwVWhe3FDO08x446Xhysq2UFnZVqqs2icryPCWl/8dWcxJPgl4Gn4ngsQeIjEbSTeARvEfdG5ZNeitlJ52BYYraxgPMVRbyLmxpLLygCThFRU7pRq6Okwtv+B7aU3nNdbVnvC2MFQt1HDATktLk4SQkzyex8zzg6dMmSK9stD68Be0xx57LNiHARrFUxZyc7+U6zExg2SZMGgbjMYoiosbIZvTWSHTyzgJ56llPM3MXrBS5oFzEbaoqH5S6NZq5SlmaJRpKV+HSMxG0g2gQbxedEHBD3I9NfUSMplig31I0EDcix0RwUl1Fx70Kq3knICXV+yiyoo90gvOPeK8MS6Ox+uEcgIeHt6FDAYrPusg4jU9eYPGUddI5V4G/vKj4tsDBw707pObm+v3PKfTKRXN1efzJT/Hl3q7vn18H6/vWGp74IEH/Iasc093RkYGfg1AlJX9Ies86/UmSkxE8bS2ymiM8C5B5nLZZJWTsvKtMsKNi7AVFP4om8kYTZFRfaQeDJYaDaxFIRSzkXQDaIzdnkNZWf+V6zx0mXtPIbRbyWNiBsvmWRM8U3rAKyp3S2E2nrfPGy9XwvPGw6ztZRh6eHhXFGSDkMFDwjnZXbZsmTex5cSV52rPmDFDbo8cOVKW7+Kq5EOGDPHOu3O73TLfWt3nb3/7GzkcDjKZTHIfF0nr2bOn9GCo+/D73Hnnnd735334/oYeS20Wi0U2gNrcbgfl5X0j13mal8kUjQ8JpIE8JmagbG63XRrWuQeca704nKVUVLRWNh4JxzE9MqKnXHLiDm0Tkm4ADeG5wYePvCPzuCPCu1Jy0vhgHxIEYKkS3hJpFLlcdqqs3OsZil65R4qzcW8Kb0TLaoaid6WICN66kcmUgCFrEDTl5eW0e/du720uWMaVxXlOdocOHSQJfuKJJ2QtbE58eR1trkiuruXdu3dvqTp+4403SpVxTqxvvfVWKWzG+7FrrrlGhnnzcmD33XefLAPG1cqff/557/vecccddPbZZ9Ozzz5LEyZMoPfff5/WrVvnXVaM/53VdywADcWJE/dicu8lN4QD1FmErWalE26k4XhezvPAy7eTy1UptQDUegC8uklEZE9Jwi2WVMT0NgRJN4BGcC9oZuaH0uvJw8nT06/EPO42sCRZVFRv2dTlaCoq9tQk4XslWPPQNd7UNcTViug8L5zXDgdoKZzYjho1yntbHY7N8+Z4eN+sWbNkLW9e2ot7tM844wyZa2e1Hp0ywUuCcaI9evRomWs3ceJEmXvnW2X822+/pZkzZ0pveGJiIs2ePdtvLe/TTjuN3n33XVkS7MEHH5TEmiuX9+vXz7tPQ44FoD48PSi/YIVc5zW5sWQn1IenIERF9pItVZYaPUQVFbzU6A6p8aI2rOflLSWTMYYiIntIAu6ZXobRNq2ZTuFv+tAieHgbf6EoKSmh6GgMTwJ/eXnfSXDX60zUseNNKNTSxvG64DZbFlVUckE2z1B0LtKm4hZzbiXnpWs4WHOFe62sGWuz2aQXlHsYkeQ0/nNCrAg+nANgvIIIr9vMK1B07DgDvZLQJA5HMZWX76Tyih1S44WXn1Op08vCa0a3cTE2vb5l+kYRs5v2GTU0XqCnG0ADeCkKtTWdC6ehMipIAFaHoiecI3PGKiv3SwLOG68Lri5dUli0+mgSHtGFwsM6ayoJBwAINTzqiBNuWSIs5WIk3NBkPIoxLm6YbDwMnaeXcQ8413nhKQxqL7h0wOhNUoSNp5hxIm618pJk2qnEDY2HpBsgyOz2XMrM+kiux8edJsuRANTGwxojeR5YZE/vsMfKyn3ejZcu8SbhtEr2sZiTZf4Yrw3Om9mc1KJfHLlAFuDzAQg1nBBl53wm12Njh1FYWPtgHxK0MpxU+8b06upCT42Xyj3elU7URnbGjegyqi2skzSqe+aDN28Sjpgd2M8GSTdAEHHv5ZEj78klDxNOTkbhNGh4VXR1bfDaSTjPB+eibNwbzltxyXpv0Obha2oSzsPXAjGHzGw2y3zdzMxMSkpKkttYs/QontVVXV1NeXl58jnx5wMA2pGXv1T+hhqNkTKXGyDQzOZ42Xg5Mo4R9uocSb45nnNc50K7XB2dN7UhnhvVOQnnHnFuGNLrTy6WIGa3TLxG0g0QRDk5SyQp4gSqXfpVssYzQPMk4eVUZTtMVVUHpJCLzXZYgjYva8Ib42GTZgv3hneQZNxqbUcWS3KTfw85MPG8p6ysLEm8oW7h4eFS9Zs/LwDQzrDywkLPaKG01MsxTQdaHDdSWy2psnHFfK7nYrMdkd9Njuk8BJ07a3x7wrnX22pJr2lUzyCrtb0UX21IgzdidsvEayTdAEFSUrKBikt+k8SnXfokaVEHaC78+6RWUGUctHkN+MqqA2SrOuRZI9xRJPfxVky/yn46nZGslhSyWNMlgKuJOA+FawxuDeYA5XQ6yeU6WgAOPAwGAxmNRowAANAQp7OCsrL+K9fjYod5h/4CBBM3hKsj1NRCqxy3PQn4Aaqq3C9rg0tDu+0wUZHneUZDBFl5ipmMcPMk4ry+eF0QswMfr5F0AwSB3Z7nnS+WmHiuDC0HCHTQ5gJ9UqQvbqR3SHpVTQLOreg2Wya53Daqsh2R7ehz9TI/nJ/LyThX8rVYUupdPocDlMlkkg0AQMs4kcnM/IAczhIymxMw3Qs0S3q1rWmyxcWNkCHQTmcxVVYeoCrbIbJVHZb6LjwvvLx8u2ze0W3mJBmKztPL+NJ3bjhidmAh6QYIQoGWI5nvk9tdLVUpExLOwTmAoA1Jj4rqIxvjwO1wFErybbNnei45EXdVyvqivFHJb97gbTInkNXiCfyWmkt+TQCAUJOX960UseJ5se3bXYs1uSFkeJLlOIqJ4W2g97um3Z7laVi3HZYRbjK6rabWixrLeRQbj2gLs2aQNay9XJpMMUH+iVonJN0ALYiTmpycz8huz5bhv+npV2AJCNBU4OYeHt6iqb/c52lBL/Em4Goyzr3kXGiIt9Kyzd7X4N9rTsTVJJxb0c3mRPyeA4BmFRevo4LCH+V6WuplMpIHIJR5lhw7OiTdt9aLTDGTmi+HvMuR8qYyGaM9U8u4N12mmaWT0RiN6VBNhKQboAUVFv7kncednnYlegUhRFrQY2VTe8QZJ902W5Y0IPEwNrstSxJwDurlzqPF2pheZ5IvsZ4Aribj9Q9PBwAINF4nOTvnf3I9MeEcbzFKgNZf64Urc+d5h6RzEs5V03l+uKO8lMrKtx19riHCJwlXG9QTUAC4EZB0A7SQsrJtlJf3jVxPTplAERFd8dlDyOJh5JGRvPXw3sct5rzuvCcZ5zXDs+WSh7l5C7zUUIenSzJu5mXF1C0xIMuYAQDUxksx8bKdPJ87JmYQJSaOwYcEbapRnQul8kYxQ7xx/OjItiyJ59XVuTI/3OlTLd3zfIPEbK75wq/Bq6HwdSTjdUPSDdACeJkHnsetkCIVUeNiR+Bzh1ZHXTeUNxV/ma12FJLdlunpFbdxMp7lNzy9rNbr8NA2DuRHN08yzr3tasEXAICm4AKShw7/m9yKgyIjesiw8qZWJwZoDXGci/v6Fvj1zA/Plell9pqEnOeFc20idQUU30BedzKeJPPOT3Yt8dYASTdAgPE8mcNH/kOK4qSoyD6UknIhAju0GZ7K5xx8E4noFP/h6dITnlOTfOd5h6fL0DZnKVVU7vV7LR6mbjLHk9kUXzPkPY5M3uvx6CEHgAapqjpMBw8t8hY0bdfuGgyTBTjh/PB2sqnUiumcjPPGveFy/QTJuNqozqPcJI5LPPfUkTGZElp9DEfSDRDguWI8dI1b0iMiulF6+iQEdgB1eDpvEd39Pg+Xq8rbA86JuN17vUD+HXkDeR0MhnAym+LIaIqtScw5KY+TwG4yxjR6rXEAaH24l+7QYU647RQe3onat+dK5fjbAHAyFdN5813P/njJeHV1vixJqjaqV9K+Y16T542rCbiZ4zZfN3pqyvB3hlAf6YakGyCA1VC5OAsPr+Wha+3aXU16Pf7JAZyIwRB2zBB1xv+OHI4iSb75Uq47CsnpKJZlUHhZM96qXJVEPmuM+792uLSyG9XN5Ln03Bcl1w2GCIxEAWiluMHu4KGF0rjHVZ3bt5uMgo4ALZSMu93cqF5I1Y4CclQX+F2XOeO8VVUQVR089nVJ54nTNQm4jHAzxnhiuIkvYzSfmCMDAGhmiuKinJwvqKj4Z7kdEz2I0tJ4rpgBnzXASeJAqi5nVheXyy5rjDscxTWXnJR7knPeeLibmpgTrzd+3PcxSms7V3k1GCPJaIj0XJf7osggtyMkgfck6NoN8ABwlN2eRwcPviF/A8Ks7Smj/ZRWP5wVQEvJuMEQTmFhvLU/TgznRLygJhGvScgdJeR0lsp3a7WX/PjvoZeYbfCL4dyg7nOfz2VLx28k3QDNiL/cH8n8UAq0sKTEMZSQcA56zgACjL88Gwye5chqU1vYPcG7TAK4ZyuTAO6sCercys61FxzOEtka9r5h3gSck3W+zlNJsOwQgHZwAcdDh9+Sf+O8bGFGxlQyGKzBPiwA8IvhnjXB64rhLld5TQwv8SbiHKd5tJtD4nqJZ0Scmpjb6YS451xitzGSOmRMa5ElfJF0AzST0tLNlJ39qcxZMeitlJZ+hXctRAAIfgs7b0THJuUqt9spgZ2LuTld5eSqueTk3OWs8N6n9pjzagQ8TJU3ogK/6q9IugG0obxil6e2itsuawtnZEyTxjIACJ0YbpQpYJwYH9tLzjjhltjN8drlE8O98dw/hnP8Voe06/Ut0wCHpBugiXjYak7ul1Rc/Kvc5nli7dKvlPksABA6uOaCXu8p2lIfDvCehJsTcE8Qd8r1Chm6CgDBxb1jBYXfU37+Mvn3yksgtW93LRJugFZIp9OTycTzu6MbGL8rJCHn2N1ShRSRdAM0sSjLkcwP5JKHqiQknEWJiaMxfxuglZO5Y0aeGxbBE0mCfTgAUGuqV1b2p1RRsVtux8QMotSUS1HMFADIE7/VnvOWg6Qb4CRwK1lR0RrKy1sqyxhxUYb0tCspIqIrPk8AAIAg4CkiRcVrKT//O3K7HaTXmSgl9SKKiR6M2ioAEFRIugEaiYuk5eQsoaqaZYl4ObC0tImSeAMAAEDLDyUvK99CeXnfSvVjxmtwc++2xYKRKAAQfEi6ARrIZsuk/PzlVFa+TW5zsbSkpHEUG3sqWtABAACCkGxXVOyUUWc2e5bcxw3gSYnnUUzMEMRmANAMJN0A9QxVK6/YTkVFa6mycp/cx3O3Y2IGU1LSeS0+HwQAAACIKir2Un7+UqqsWaJTrzdTfPwZFB93BtbfBgDNQdINUEfLOfdql5T+RqWlm6SyoVp4ITqqPyUkjMJwNQAAgCBN8crL+44qKvfIbZ63HRc3guLjz6wpbAgAoD1IugFq8Np+JaW/U0nJb1KNXGUyRkvl09jY4WQyxeDzAgAAaEFcFK28fBsVFq2RpJvpdAaKjRlKiYmjMOoMADQPSTe0abxGX0XFLiot+0PmhXFVcrXlPDKqtwwjjwjvKr3cAAAA0FLxuYwqKvbIsl9l5VvJ7bZ7k+2Y6IGSbJtMcTgdABASkHRDm8JDxW22LKqs2k8V5TvJZjtCCinex8PCOlBM9CCKju5PBkNYUI8VAACgrXC5qqiycj9VVO6myoq9ZK/O9XucE+zYmMFSvBT1VAAg1CDphlbL6awgmz1TEmueo223ZVK1o+iY/ayWNIqM7EnR0QMxVxsAAKCFhozzUPHKSu7N3nNMIzgXLbVY02S0GcfosLBOQalG7iopoep9+6j64EFSnC7SR0SQITaWjMlJpA8LI6W6mlylZeQqLCBnYSG5CgrJXVlJisPBy5yQPjycjPEJZOnRnSxdu8ptAGh7kHRDqyh8xsPQOMG227IkwebrDkdxnfubTXFktbaniMjussZ2sFrM+bg5WOsMBiKDwe/LBD/mrqggZ16ebK7CQrntrqzise+kMxjJmJJMpnbtyNyxI+ktlqD8DAAAAA3Bw8Orqg7JSiA82qyq6jApitNvH7M5UZLs8IguFBHehQyG8OB8p8jNJfvOXWTbupUcR4406fU4CXccOkxVv/8uSbilWzcK69+fLL16kd5sbrbjBgBtQ9INIYWDocNRUJNYZ3mTbKeros79zeYEslrbkdWSTlarZwvWsHHF7ZZAXn3gIFUfPECOgwfJVVLqedCgJ0NklLSgK9V2T4JdZTvxC27d6rnU68jcvj2Zu3QlS9cuZExOltZ3AACAYHE4SslmO+xJtKv2y3W1bopvodLw8K4UEdFFLoNRrJS/V3DDtiMzi6r37iH77t2e2KwoRE4bkbOKTBmdydyjL+kjwj0N4gUF5MzNk95snclE+sgIMsbFkiE+gYxJSaSPiCQdJ9Qup+xffegw2Xft8iTzO3bKpjMaydy1C5nS08mUkkKGhER5DXkeALQ6SLobae7cufTMM89QdnY2DRgwgF5++WUaNmxYYM5OG8drZFdX5x3twbZzgp3lLabiiwudmc1JNcl1miTXFksaGQzWoCXYPCSNA6zj0CGqPnyYHIcPk1JVTlRdSeR2EYXFEekNnie4PPu7iouIXA4il53I7SBDhJWMySlkTE4lfUwM6SOiiSxRpNjt5MjKpupDB8lVWETVBw/JVr5ypbycPswqQV8fHka68HAZzubZIsgYH0eGxEQyxsdL0AcAaK0Qs1uGy2Unuz1TEuwq22GyVR0ih7OmUdmHyRhD4eGdKSy8k1yaTQkBHzIuSXVxMTkOHyHHkcPkOJJJ7opyGWnmrq6WS06OJTZXV8jmcJZTVayLihL0lBVnIDLnUoLeSekdz6eOqcPJxA39u74je/EByiw9QoUVRVRSWUGOMh3pj8SQwRRBRoOFouMyKKPv+RTd9SyKHjeWHLm5ZNu8mao2b5bYrSbgvgzRUWSIiydDQrzEaU8inyjJvE6Poq4AoUqn8F8jaJAPPviAJk+eTPPnz6fhw4fTCy+8QIsXL6YdO3ZQcnJyvc8vLS2lmJgYKikpoejo6Db/qcsQarednM5S2RzOEnJUF0nxlGp7HlU78o9pFZdfWp2RrJZUmeul9mBbLCmk15ta5pjLeO5WITnz88mZX0DOgnxJmGX+ltPpCeRlhUT2ClIcVWSvLiNbdQVVOKqoXK9QcZSBSiMMpIuJIEtGD0pK7EoJpghyHPiNKvMOUBm5qYRcVGxQqNLtJuLRdy4indszxy0iLIpik7pQYloPSk3rRonmWDIUFJD70GFycWJfXnev/zH0OjLExZGRE/DEJE9QT0iQ5FxntXqGrJtMQZlDB9CWIVYEP2bjHBwneXVVktNZQtXV+WS350rDuHrpOx/bOyfbkiKjzcLCO1J4WGcphtacMUWmaXHsdbmkZ9pdVSUxmuOzIyuTnIf3kvPwQXKWFVF1dTmR0UKGyBQyGK2kc9jIUZlHlRV5VOasoqJwAxWF6yk3QkflJj3pHDrZSGeURnDPD2Ugo8FMJreTnOQiB8foenC19fCweIqJSaLk9K6U0b4PxcQnkb6ogCgvl3TF5URl5aQrKSXFZj/+6xiNZEpPI2NamvSM66OiyBAZKZc8Sk6mqgFAi2tovEDS3QgctE899VR65ZVX5Lbb7aaMjAy67bbb6P7772+2kxLKJAAqDnK5bORylcuSXC5Xhc9lWU2C7Um03e7qE76eXm/xDAu3eHqveeMe7aYs4SVJMQfmykrPMO6yImn15kPhod1cKIVbvRW7jZSqYlJs5VRVXkhV+XlUVcyNAlVkd1WT3eX0BFwO3gYz8dcIxeWgaqeNHIqbeHB4pVlPNrOBHCY9Ocx6cpl0RAajZ9ia4jrOEeo8PeD8M/LGveJq44Nc+n6x0ZNeb6Qw/iLhdpPe7ST+ZIwKkUHRkZF0ZFCIjG6d9Pob9VayugwUXk1k1ZkpzGQlo05PesVJep2eDDq9tKTzdf6MOYgbrGGeJNxqIZ3FSjqrhfQWq/Sm8/06C9+28Mny/UU4+tMYjTL8Tjaz2f+y5nrtOe0AbVlbiBVaj9lt6Rxw47Z/nK4dr0vI6fDE7dpzsGv3YlvD2lOYNYPCwtpLvOYY7v9eCp8IUjhJ5kZql4sUp1OSZr6U+Ouuue7g3ucqUuzl5CoppOrifLIV5VB1SYHEa3KaiOwu0rsUctrLyVFVRDZnJdkcNqpyOSRGcxy2K0TVOiKb2UjVFj05LHpyG3SkkI7cHHZ0OnJzvspxl+MzN+DrjWQ1R5DVFEUR4dFErlKqKN5PpXY7uV018c1gJjKFk8lgJqs1kixhkWQ0GchNdlLc1eR0VVN5STZV26pJV5OzexN3nY4MboXbvklPOtk4/nI8Nik6MpGRzPowspCFItxGCqsmCtOZyGowkYH35+f7xGq+zXHYEBEh08s8I9vCSOe9HuG5tFo88ZbjtXrJMdr30vfxOmrOAMDJxQuMLW2g6upqWr9+PT3wwAPe+/R6PY0ZM4bWrFlDLaUoL5vW//w9KeT2tCpLkusmcnMQqNm4tVdNzhSX517F//GjyRs/X7JFUrgrVV7XLY/LJd8nr8EJopMUHQdcfsxBpPO5T66rmycg+aaG3veXO32u83G4DKQ4DaQ4jETVRnLbTUQ2Eyk2CynOatK5eejVTtLxMblrfmb11eV6TTDgBLgm2fPcJ2mwDPXm93FJi7Sb3PL58Ob5sqF+Mry/ojv6PPkcOSj7nYFYUkyx5LZ6grSi91y6OGDzc3We9+bXUUyexJlbuc0cKI1hFBYWSdaIaLJaw8hZkU/2ygIqt1eQ3eUgoymC9NZosoZFkdUSSWHWSIqwchA3k97oeS2Xo4JK83dTWXEWldsqqcrBX1zcZHfWHHathm7uaTgG72PyfPExuCvI4FRI51LI4Cb58iI96orn5byvoju6cWot6bX3XErznfec67xXeP+aYM2fg/fVfF+75jQe/dTlivolQp7HhePktWrOq+8L+fyeeU4df95qo0Xtz8Lnus7nnppzLm+n4+d5rh/zKdZ8Oas5QO/tY/b1Hp/Pgcp/+poPrtYP4PN8/5eq/fjxdmwAeS1uxKl1v9+/xxMNevKcg+M9dty7mmEcVaNeQv0ZvH/vfF6lvkFdfg/X/IU58Udy9Heh1vuldUyn0y6b1Jgjh1Yas9ev/o4KC/NrYq0nmijc4Or2/131xmyJr54pSjU7+P9+qbG55rXcEotrvg/I/Z5hUZ73ctfEbDVW82NObzxXY7gat73/fLzfE2r+rvNr1dyWhnWO2Ryj7SZy242k2MykVJk985+VHCJlnef4JL7zhacXmn9mz0+ixlgZvuUTr3Xe5/FP5FTfz+ebRe1/2f7CSTGGE5l0pOg5J9eTy6gjxWggt8noiUeKS6qmy6tIw7aBjEYrmS1RFBYVTRERsRQVGUexUYlkCY+UzcCNxHxsbicplXmUV7ifHDoTmWPSKdwSTeHm8ON0BPBn5aLKvD8or3Av5RXnUFF5GVXZucG+ZgQbJ/Cc+Z/obw23nIcppHfaSe+ykdHhJj0/VyHSc+Lu9yXFJ157Y88xUccTX2ti+dHH+Rme2CkRuyYO6/jcqfGP43HNC3FslleQF+FLvX/s9e7oGVnnGRp/NHYejY2ev6NHQ6dP7KsVX30vPSHfN46rj/rGOp/H/UJqzT7eLxDeby+e39Xa71vzfO95rhUP1c/a74nqsdXWkPjdqBgfoAaRxsTMWrsq9cTXo459j3oHYMvDakeUmlf4xH3f5/ucVg/fG0f3Gzt1KkXExlGgIeluoPz8fHK5XJSSkuJ3P9/evn17nc+x23mOk92vJaSp1v+8gua7y4994Lgdv8Gb/6Nw1HPr5VJxGzy3+bpiIMVdc580L9f8sTLXbJGkXccka3Xv5NlNDXo+Ic33KTGpRDHH+8NQ8zelUn1Q7V0wEZl6EyX1PtqGoTa+HJPoqI/6/FGq9QfJbzhgrb9zaNcGODl99ufRafjwQipmByJes3f2bKCDMbGNCM3qX96WHyrsjdESn/Wk8DGosVritid2yzFyB7bWFs2oqzH1mFhc55OOPoVxL3pBpWcj/7XCPWrOZ3EJEfFWH/6gehNF9ZbvN7WH4bOjsdxzeTTx8Gn88Pk/4jVA8xmcm4ukO9TNmTOHHnvssWZ9TYPRRGabz/AupSEpEg+johM/pyZjU7yZG7e8eoZfebsfJWGuuV+CM1967pf3UK+r9/v1lR7b0urhPolevJNpPfRt4vRtVfUJzJ5PwOcpR9t+PS2vJ5mGnrhRr2GPnZDaQ3DsvXXe8D3tdb2pGvRP9CWgwXxHJDT+aSf1oRznKb5NDU124mZcaOPMRhQ7CjWBiNfM6FbI7K4rZjcxbteO2TUx1z9m09G47Y3hnETX7FsTrz0x+2iSf2y0q9075NsTeIKfob59jvtU/xjt24t49Ho9710XpYmPN/DtagZ+ncQLHed7kPf6ceJo7aTcb2Sh+sxjr9X1Gn6pfb3DffxeoFF3a1q9xxyKP1RrpGu2VzKYWmbFAPR0N1BiYiIZDAbKycnxu59vp6am1vkcHtZ29913+7Wc83yyphg1/k80qkmvAAAA0Lo1NmYHIl6zp6fMavJrAABA6ENzfAOZzWYaMmQILVu2zHsfF2Xh2yNHjqzzORaLRSbU+24AAACgrZiNeA0AAIGEnu5G4FbwKVOm0NChQ2Vtbl5+pKKigqZNmxa4MwQAAACNhpgNAABagaS7ESZNmkR5eXk0e/Zsys7OpoEDB9LXX399TKEWAAAACC7EbAAA0Aqs092C2tK6nwAAcHIQK4IP5wAAAJozXmBONwAAAAAAAECAIOkGAAAAAAAACBAk3QAAAAAAAAABgqQbAAAAAAAAIECQdAMAAAAAAAAECJJuAAAAAAAAgABB0g0AAAAAAAAQIMZAvTAcS1EU73puAAAAdVFjBF9GRUWRTqfDB9XCEK8BAKAxMVuNG8eDpLsFlZWVyWVGRkZLvi0AAIQgjhUlJSUUHR0d7ENpcxCvAQCgsXEjJibmuI/rlPrScmg2brebMjMzm9xzwS0q/GXs0KFDIf1lDD+H9uCcaAvOR9s8HxyWOXhzrOD3QU93y0O8Phb+HmkLzof24Jy07Zidnp5Oev3xZ26jp7sF8Ylo3759s70e/wKFctKtws+hPTgn2oLzoS0tcT5O1FoOgYd4fXz4e6QtOB/ag3OiLdEaidkopAYAAAAAAAAQIEi6AQAAAAAAAAIESXcIslgs9Mgjj8hlKMPPoT04J9qC86EtreV8QMtpTb8zreVnwc+hLa3lfLSmnwU/R2CgkBoAAAAAAABAgKCnGwAAAAAAACBAkHQDAAAAAAAABAiSbgAAAAAAAIAAQdIdYubOnUudOnUiq9VKw4cPp19++YW0bM6cOXTqqadSVFQUJScn06WXXko7duzw2+ecc84hnU7nt918882kNY8++ugxx9mrVy/v4zabjWbOnEkJCQkUGRlJEydOpJycHNIa/v2p/XPwxseu5fPxww8/0EUXXUTp6elyTJ9++qnf44qi0OzZsyktLY3CwsJozJgxtGvXLr99CgsL6dprr5X1GmNjY2n69OlUXl6umZ/D4XDQfffdR/3796eIiAjZZ/LkyZSZmVnvOXzqqada9Oeo72dhU6dOPeY4x48fH1LnhNX174W3Z555RnPnBLQFMTs4EK+DDzGbNBUfEK+fCfr5QNIdQj744AO6++67pTLib7/9RgMGDKBx48ZRbm4uadX3338vydzatWtp6dKlklSMHTuWKioq/Pa78cYbKSsry7s9/fTTpEV9+/b1O86ffvrJ+9hdd91Fn3/+OS1evFh+bk6ULr/8ctKaX3/91e9n4PPCrrjiCk2fD/6d4d95/hJbFz7Gl156iebPn08///yzJK3874MbQ1Sc3G3ZskV+5iVLlkgQuummmzTzc1RWVsq/7YcfflguP/74Y2mkuvjii4/Z9/HHH/c7R7fddhtp7ZwwTrJ9j/O9997ze1zr54T5Hj9vb775pgRpbljT2jkB7UDMDi7E6+BCzCZNxQfE64nBPx8KhIxhw4YpM2fO9N52uVxKenq6MmfOHCVU5ObmKvxr9/3333vvO/vss5U77rhD0bpHHnlEGTBgQJ2PFRcXKyaTSVm8eLH3vm3btsnPumbNGkXL+LPv2rWr4na7Q+Z88Of6ySefeG/zsaempirPPPOM3zmxWCzKe++9J7e3bt0qz/v111+9+3z11VeKTqdTjhw5omjh56jLL7/8IvsdOHDAe1/Hjh2V559/XtGSun6WKVOmKJdccslxnxOq54R/pnPPPdfvPi2eEwguxOzgQbzWFsRsbcUHxOuOQTkf6OkOEdXV1bR+/XoZMqvS6/Vye82aNRQqSkpK5DI+Pt7v/nfeeYcSExOpX79+9MADD0iPnxbxcGUegtqlSxfpoTt48KDcz+eGe/F9zw8PPe/QoYOmzw//Xr399tt0/fXXS89dqJ0P1b59+yg7O9vv84+JiZEpGOrnz5c8fHno0KHefXh//nfEPeNa/jfD54aP3RcPheKpDIMGDZJhzk6nk7Ro5cqVMrWkZ8+eNGPGDCooKPA+FornhKeMfPHFFzIMvrZQOScQeIjZwYd4rV2I2dqMD4jXgWUM8OtDM8nPzyeXy0UpKSl+9/Pt7du3h8Tn7Ha76c4776TTTz9dkjnVNddcQx07dpRkdtOmTTKnlYfU8tBaLeEEbtGiRZI88FCUxx57jM4880z6448/JOEzm83HJEZ8fvgxreK5q8XFxTL3NtTOhy/1M67r34f6GF9y8ufLaDRKA5BWzxEPjefP/+qrr5Y5z6rbb7+dBg8eLMe+evVqaRjh38nnnnuOtISHlvMUi86dO9OePXvowQcfpPPPP1+SbYPBEJLn5K233pIaFbWnjoTKOYGWgZgdXIjX2o3XDDFbe/EB8Tor4OcDSTe0GJ7bzQmq7zxo5jt/kwtIcSGs0aNHy5f0rl27auYMcbKgOuWUUySoc3L64YcfSuGuUPTGG2/Iz8UJdqidj9aOR05ceeWVUiBu3rx5fo9xbQff30Vu8PnLX/4ihQstFgtpxVVXXeX3u8THyr9D3JrOv1OhiOdz8ygXLmYZiucEoC3EbMRr7ZyLtiLUYzbi9V8Cfj4wvDxE8FBf7hmqXQ2bb6emppLW3XrrrVIkacWKFdS+ffsT7svJLNu9ezdpGfdq9+jRQ46TzwEPJ+Re41A5PwcOHKDvvvuObrjhhpA/H+pnfKJ/H3xZu+ggD+/i6tlaO0dq8OZzxAXGfHu5j3eO+GfZv38/aRlPy+C/ZervUiidE/bjjz/KqI/6/s2E0jmBwEDM1hbEa21BzNZ+fEC8bn5IukMEt4oNGTKEli1b5jdcm2+PHDmStIpb/Djh/uSTT2j58uUyzLQ+GzdulEtuPdcyXtaIW/b5OPncmEwmv/PDX855zrdWz8/ChQtlaO+ECRNC/nzw7xUHcd/Pv7S0VOYFq58/X3KjCM+/V/HvJP87UhsWtJRw83xEbhThOcL14XPE86BrD9XWmsOHD8ucbvV3KVTOie/IEP63zpXOW8s5gcBAzNYWxGttQczWfnxAvA6AFi/dBift/fffl2rMixYtkqq/N910kxIbG6tkZ2dr9lOdMWOGEhMTo6xcuVLJysrybpWVlfL47t27lccff1xZt26dsm/fPuV///uf0qVLF+Wss85StOaee+6Rn4OPc9WqVcqYMWOUxMREqcjObr75ZqVDhw7K8uXL5ecZOXKkbFrEle/5WO+77z6/+7V8PsrKypQNGzbIxn+6nnvuObmuVvV+6qmn5N8DH/OmTZukwnTnzp2Vqqoq72uMHz9eGTRokPLzzz8rP/30k9K9e3fl6quv1szPUV1drVx88cVK+/btlY0bN/r9m7Hb7fL81atXS9VNfnzPnj3K22+/rSQlJSmTJ09u0Z+jvp+FH/vrX/8q1fv5d+m7775TBg8eLJ+5zWYLmXOiKikpUcLDw5V58+Yd83wtnRPQDsTs4EG8Dj7EbG3FbMRrJejnA0l3iHn55ZclWTKbzbIcydq1axUt4y+wdW0LFy6Uxw8ePCgJXXx8vDQodOvWTbn33nvlC67WTJo0SUlLS5PPvl27dnKbk1QVJ3e33HKLEhcXJ1/OL7vsMkmWtOibb76R87Bjxw6/+7V8PlasWFHn7xIvS6UuG/bwww8rKSkpcuyjR48+5ucrKCiQhC4yMlKJjo5Wpk2bJoFIKz8HJ6fH+zfDz2Pr169Xhg8fLo1ZVqtV6d27t/Lkk0/6JbJa+Fm4YW3s2LESzHg5PV5S68YbbzymkVDr50T1r3/9SwkLC5Ol6GrT0jkBbUHMDg7E6+BDzNZWzEa8VoJ+PnT8v0D0oAMAAAAAAAC0dZjTDQAAAAAAABAgSLoBAAAAAAAAAgRJNwAAAAAAAECAIOkGAAAAAAAACBAk3QAAAAAAAAABgqQbAAAAAAAAIECQdAMAAAAAAAAECJJuAAAAAAAAgABB0g0AAAAAAAAQIEi6AaDJpk6dSjqdTjaTyUQpKSl03nnn0ZtvvklutxufMAAAgAYgXgMEB5JuAGgW48ePp6ysLNq/fz999dVXNGrUKLrjjjvowgsvJKfTiU8ZAABAAxCvAVoekm4AaBYWi4VSU1OpXbt2NHjwYHrwwQfpf//7nyTgixYtkn2ee+456t+/P0VERFBGRgbdcsstVF5eLo9VVFRQdHQ0ffTRR36v++mnn8r+ZWVlVF1dTbfeeiulpaWR1Wqljh070pw5c3AGAQAAEK8BNAtJNwAEzLnnnksDBgygjz/+2PMHR6+nl156ibZs2UJvvfUWLV++nGbNmiWPcWJ91VVX0cKFC/1eg2//6U9/oqioKHnuZ599Rh9++CHt2LGD3nnnHerUqRPOIAAAAOI1gGYZg30AANC69erVizZt2iTX77zzTu/9nCw/8cQTdPPNN9Orr74q991www102mmnyTB17s3Ozc2lL7/8kr777jt5/ODBg9S9e3c644wzZP4493QDAAAA4jWAlqGnGwACSlEUSZAZJ8+jR4+WIejcc33ddddRQUEBVVZWyuPDhg2jvn37Si84e/vttyWxPuuss7wFYDZu3Eg9e/ak2/+/vft3pT6O4gB+npSZ3XIXk9Qtyl9gs1AscsNwN2UwmC0ok5QymiS7LCbjndwYZbmxWCXJ0/kUJZ56lG++w+s13l/d+g6nd59zzmdlJc7Ozjw9AFCvodaEbqBS19fX0Wg0yoK1XKo2OjoaJycn0el0Ym9vr3wmZ7Xf5Gn32wx4tpYvLi6+h/acFb+5uYmNjY14fHyM2dnZ0noOAKjXUFdCN1CZnNm+vLyMmZmZErLz+rCdnZ2YmJiI4eHh6PV6n74zPz8ft7e3ZX776uoqWq3Wh/dz2drc3FwcHBzE0dFRCfAPDw+eIgCo11BLZrqBH/H09BR3d3fx8vIS9/f3cXp6WjaL5+n2wsJCdLvdeH5+jt3d3ZiamoqLi4vY39//9DuDg4MxPT0da2trMTk5GUNDQ+/v5fbznPVuNptlKdvx8XHZmD4wMOApAoB6DbXkpBv4ERmyMxDngrS8A/T8/LycVue1YX19fWWLeYbmra2tGBkZKZvH/3Xd1/Lycmk5X1pa+vB6zoFvb2/H2NhYjI+Pl5b1XLSWARwAUK+hjv685pYjgBo5PDyM1dXV0n7e39//238HAPiCeg3/R3s5UBu5xTyvC9vc3Ix2uy1wA0ANqdfwPXoygdrI1vG81zvntNfX13/77wAAX1Cv4Xu0lwMAAEBFnHQDAABARYRuAAAAqIjQDQAAABURugEAAKAiQjcAAABUROgGAACAigjdAAAAUBGhGwAAACoidAMAAEBU4y/JUC6SHYbbWQAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -301,13 +301,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 8,
    "id": "a63278ef",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgspJREFUeJzt3QeYU2XWwPEzvReGoXcRKQLSBLFggcVeVuyuImLv5QNXV7CuWNYuylpAXXUV1t4bWEFRBKkCKgoKw1Cm95LvOW9yQ2YYYEpucpP8fz4x7U5yMxlycu573vNGuVwulwAAAAAAAL+L9v9DAgAAAAAAkm4AAAAAAGzESDcAAAAAADYh6QYAAAAAwCYk3QAAAAAA2ISkGwAAAAAAm5B0AwAAAABgE5JuAAAAAABsQtINAAAAAIBNSLoBAAAAALAJSTcAR1u5cqXceuut8ttvvwV7VwAAQCM8/vjj8uyzz/K7AjxIugE4Pum+7bbbSLoBAAgRJN1AXSTdAAAAAADYhKQbQJP9+eefcv7550u7du0kISFB9t13X5k5c6b3/srKSpk6daoMHTpUMjIyJCUlRQ455BCZN2/eTo/18ssvm+3S0tIkPT1dBgwYIA8//LC5T0vTTj31VHP58MMPl6ioKHP67LPPeNcAAGjA0qVLTax86623vLctWrTI3DZkyJA62x599NEyYsQI7/X333/fxGuN2xqXjz32WFmxYkWdn8nJyZEJEyZI586dzXeADh06yIknnuitSOvevbv5mc8//9wbtw877DDeK0S02GDvAIDQsnnzZjnggANMEL3iiiukTZs2JkhPnDhRCgsL5ZprrjHnTz/9tJx55ply4YUXSlFRkTzzzDNy5JFHysKFC2XQoEHmsT7++GOzzejRo+Wee+4xt61atUq+/vprufrqq2XUqFFy1VVXySOPPCI33XST9O3b12xjnQMAgLr69+8vmZmZ8sUXX8gJJ5xgbvvyyy8lOjpafvzxRxOj9SB3bW2tzJ8/Xy666CKzzX/+8x8ZP368idUak0tLS+WJJ56Qgw8+WBYvXmySaTVu3DiTVF955ZXmttzcXBPP169fb64/9NBD5r7U1FT5xz/+YX5GD9IDkSzK5XK5gr0TAELHBRdcIO+9954sW7ZMWrdu7b1dk2dNvjdt2iTx8fFSU1Njzi35+fnSp08fc9RcE3ClCfqsWbNk+/btEhMT0+Dz/e9//zOj3TpKzpFyAAD27LjjjpMtW7bIt99+602U1ZtvvinvvPOOHHXUUSaR1pFvve2II46QLl26mHj75JNP1jnQ3rt3bznttNPM7RrLW7VqJffdd5/83//9324T/+zsbCrTAA/KywE0mh6je/XVV+X44483l7du3eo96ZHxgoIC+eGHH0wCbSXceiRdk+rq6moZNmyYud+iR+JLSkrMEXIAAOAfWiKu8VZjrPrqq6/kmGOOMZVmOuqt9Fyr1nQkW+OwJtR6AN03tms81/Jza3pYUlKSie86zSsvL4+3C2gkyssBNJoeNdegrEe7fY+E+9IyM/Xcc8/J/fffLz/99JNUVVV57+/Ro4f38mWXXSazZ882c8o6deokY8eONUfT9Qg8AABoftKtB7sXLFhgRrA1NuttWhbum3T369dPsrKyZO3ateY2HfFuiJajK53DraXn119/vSkZ1+lmOqp+7rnnSvv27Xm7gF0g6QbQaDpqrf72t7+ZeV8NGThwoLzwwgty3nnnyUknnSSTJk2Stm3bmqPl06ZNk19++cW7rd6+ZMkS+fDDD01pup603FyDtybtAACg6bSyLDEx0czr7tq1q4m3++yzj0m8dTmviooKk3T/9a9/rRPfdV53Q8lzbOyOlEGnhmnF2xtvvGHi95QpU0x8nzt3rgwePJi3C2gASTeARtOmadrNVOdrjxkzZpfb6TzsvfbaS1577TVTuma55ZZbdtpWy9Q0eOtJg76Ofv/73/82QXzvvfeu8/MAAGDPNLYOHz7cJNaadGuyrfRcE+4XX3zRzNfWhqWqZ8+e5lyT893Fd4tur6PdetJRci1b1+o2PeiuiN1AXczpBtBoOlqtzVh0Xvfy5csbLD+3tlO+fRq1mYuWufnatm1b3Q+k6GgzUq70S4HSZUuUlrUDAIDG0QRbY6/Ox7aSbm1upiuAWCuGWLdrXxYtIb/rrrvqTAmrH9+1o3l5eflOCbgekLfithW7idvADox0A2iSu+++2wRwbayiy4HpfDBtlKYNWz755BNzWed36Si3lq1pt/J169bJjBkzzLbFxcV1OqHr9jqHTNf7/P333+XRRx81R8ytZcH0sibx+gVBG7XpfDLdXo/GAwCAhmlC/c9//lM2bNjgTa6Vjm5rRZku76WxV2nCrcuDnXPOOaaj+RlnnGGq23QZsHfffVcOOuggeeyxx2TNmjVmmU/tv6IxXcvOX3/9dTNqrj9jGTp0qHm8O++801Stacze1XxxICLokmEA0BSbN292XX755a4uXbq44uLiXO3bt3eNHj3a9eSTT5r7a2trXXfddZerW7duroSEBNfgwYNd77zzjmv8+PHmNsv//vc/19ixY11t27Z1xcfHu7p27eq6+OKLXZs2barzfE899ZRrr732csXExOjQuWvevHm8YQAA7EZhYaGJm2lpaa7q6mrv7S+88IKJpeecc85OP6Px9cgjj3RlZGS4EhMTXT179nSdd955ru+//97cv3XrVhP/+/Tp40pJSTHbjRgxwjV79uw6j5OTk+M69thjzXPrcx166KG8V4horNMNAAAAAIBNmNMNAAAAAIBNSLoBAAAAALAJSTcAAAAAADYh6QYAAAAAwCYk3QAAAAAA2ISkGwAAAAAAm8Ta9cCRpra2VjZu3ChpaWkSFRUV7N0BAIQwl8slRUVF0rFjR4mO5vi4vxGzAQCBjNck3X6iCXeXLl389XAAAMiGDRukc+fO/Cb8jJgNAAhkvCbp9hMd4bZ+4enp6f56WABABCosLDQHcq3YAv8iZgMAAhmvSbr9xCop14SbpBsA4M/YAv8iZgMAAhmvmSgGAAAAAIBNSLoBAAAAALAJSTcAAAAAADZhTjcA+EFNTY1UVVXxu0SjxMXFSUxMDL8tAAgw4jWCEa9JugGghesz5uTkSH5+Pr9HNElmZqa0b9+eZmkAEADEawQzXpN0A0ALWAl327ZtJTk5mQQKjfriV1paKrm5ueZ6hw4d+K0BgM2I1whmvCbpBoBm0hI1K+Fu3bo1v0c0WlJSkjnXQK5/P5SaA4B9iNcIdrymkRoANJM1h1tHuIGmsv5u6AUAAPYiXiPY8ZqkGwBaqCVzfBC5+LsBAD53ERnxmqQbAAAAAACbkHQDLbRyY6E88dkv8uGKHNlSVMHvE9jFUeI33nhjl7+bww47TK655pom/e5++uknOeCAAyQxMVEGDRoUcq8ZQOD9uqVY3l26SR7/7GdzDmBnxGz/I+kGWujzNVtk/fZS+Wz1FnnwkzWyalMhv1M4OpDu7nTrrbfu8md/++03s82SJUv8vl+vvfaa3HHHHU36mVtuuUVSUlJk9erV8umnn/plP0iUgfClB8af/mqdfPXzVtmwvcycF5Q1f44mYDdidvjEbLqXAy1QXVMrG/PLzOW2aQmSW1Qhq3OKpG+HdH6vcKRNm3aM7LzyyisydepUk7RaUlNTg7JfWVlZTf6ZX375RY499ljp1q2bLfsEIHSt31Yq2Wnxkhy/46uuxmeXS6RdeoLU1rpkS3Gl/JxbJEO7Nf3zBwgEYnb4YKQbaIGN+eVSXeuS1IQYObxPW3PbpoJyfqdwrPbt23tPGRkZ5iixdV2XwnjggQekc+fOkpCQYEq2P/jgA+/P9ujRw5wPHjzY/JyWhKvvvvtO/vKXv0h2drZ5zEMPPVR++OGHJu1X/fLy7t27y1133SXnn3++pKWlSdeuXeXJJ5/03q/Pv2jRIrn99tvrjNBv2LBBTjvtNMnMzDSJ/IknnmhG6H3NnDlT9t13X/Madc3NK664wvuc6q9//at5TOu6evPNN2XIkCGmlH2vvfaS2267Taqrq733r127VkaNGmXu79evn3z88cdNev0A/Ofn3GJ54vNf5LUf/qxz+9rcInM+rFuWDOycaS6v2VzMrx6ORcyWsInZJN1AC2hZueqalSwdMxLN5c2F5eYIOiKPy+WSiuqaoJz0uVvq4Ycflvvvv1/+9a9/ydKlS+XII4+UE044wQQntXDhQnP+ySefmKPvWhKuioqKZPz48fLVV1/JN998I7169ZJjjjnG3N4Sui/Dhg2TxYsXy2WXXSaXXnqpd1Ren1+D8PXXX28u/9///Z9ZykP3WZP0L7/8Ur7++mszcn/UUUdJZWWl+bknnnhCLr/8crnoootk2bJl8tZbb8nee+/tPXigZs2aZR7Tuq6Pde6558rVV18tK1eulH//+9/y7LPPyj//+U9zf21trZx88skSHx8v3377rcyYMUNuuOGGFr12AM23dnORN/mu8cTjqppaWbe1xFzu1S7VnNzbFhOzIxQxm5j9bQBjdmywF6rX0YkXXnhBcnJypGPHjnLeeefJzTff7G3Nrv8gdN7eU089Jfn5+XLQQQeZL036pc6yfft2ufLKK+Xtt9+W6OhoGTdunPny6FsmqV8g9YuWfolq06aN2X7y5Ml19mfOnDkyZcoUMyqij3/PPfeYL47Arvy+3R3Au7ZOkezUBImLiZKK6lrZVlIpbdIS+MVFmMqaWrn1rZVBee5bT+gnCbExLXoMTbY18Jxxxhnmun4Gzps3Tx566CGZPn26+exUrVu3NkffLUcccUSdx9ERaR1p/vzzz+W4445r9v7o568m20r368EHHzT707t3b/P8sbGx5nPe2heNJZoAP/30094Yogm07stnn30mY8eOlTvvvNMk6ppAW/bff39zbr0+3d739ekR8r///e/mwILSo+Y6/1xjiMYnPQihTd0+/PBDE8eUjtIfffTRzX7tAFp+QFzj8aaCMuncKll+31YiVTUuSU+KNdPB9DhlUlyMlFXVyB95ZdK1tXsdXkQOYrYbMVsCErODOtKtX+g0gX7sscdk1apV5vq9994rjz76qHcbvf7II4+YoxB6NEKb5uhIRnn5jhLes88+W1asWGFKA9555x354osvzCiGpbCw0HzZ0nl/Wo543333mWTft1Rx/vz5cuaZZ8rEiRPNqMpJJ51kTsuXLw/gbwShRA8I+Y50R0dHSbt092i3BnkglOjn5MaNG82BTV96XT+fd2fz5s1y4YUXmoOVWl6enp4uxcXFsn79+hbt08CBA72XrTL43NzcXW7/448/ys8//2xGujUZ15OWmGu80Pnf+rP6GkePHt2k/dDH1TJ26zH1pK9XR8NLS0vN76dLly7ehFuNHDmyma8aQEt7rfzp6bWift9WWqeMvFfbNPN5ojG7Z9uUOmXnQKggZodezA7qSLcmujrfThvhKK3F/+9//+stYdSkRkdYdORbt1PPP/+8tGvXznSq09EY/cXpnEMdwdYyRKVJu46Q6KiN/kJffPFFU1qocwK0/E9LErX7rs5dtJJzHRnXEsRJkyaZ6zqKoUm8HhDQhB+oL7+0SgrLqiU6SqRTZpK5rWNmojlirvO6B3bmdxZp4mOizYhzsJ47WHQEeNu2beZzVA9u6rwrDWBWSXdzxcXF1bmuX5R1JHtXNNEfOnSo+cyvT0extRKqOfRxdbRbS8jr0/lgAJxD46+OaFt+21YiB+2dLWs8Jef7eMrKVe92abL8z0KTkI/u2y4o+4vgIWYTswMpqEn3gQceaEab16xZI/vss485MqFzAjUZVuvWrTNl52PGjPH+jI6ijBgxQhYsWGCSbj3XUkAr4Va6vX650pFxnVyv2+hkeU24LTpariPreXl50qpVK7PNddddV2f/dJtdtaGvqKgwJ98jTogs1ih3x8wkiY91f5lvn67Jd55s8jnKjsihSWFLS7yDRUen9SClzoPWRmgWvT58+HBz2foM1alBvnSbxx9/3DsdR5uZbd26VQJNm6ZoR3ZtCKevpyF6cFeXFzv88MN3mejXf336uDqX3Jr7XV/fvn3Na9aj6NrkRencdgCBtyHPHZtT4mOkpLLGdDHPL62UzYUVorNO9m67I+nWUW/rZ3TOd1wQD14i8IjZxOwOAYzZQf100Tlymjj36dPHfNHRjrjavVbLxZUm3EpHtn3pdes+PdcvWL50np+WFPpu09Bj+D7Hrrax7q9v2rRp5gCAddIyBUSW331Kyy060q02FdLBHKFHK330YKQmrppk6me0VgVZ85/1szYpKclUF2lJeUFBgbldy8r/85//mMojPdipn+G6XaDp82oHda2M0uZneuBW53JfddVV8scff5htdGqRNmjTaUvaIE67rPtOabKScv3s14OySpdV0yorHe3WqUz6Ol9++WVThWUd6NUDxzrirweP9bn/8Y9/BPz1A3AvFab275ElmkMXllfLnO/d//57tE6ps4SYzu/Wed06v3t7Scsqc4BAI2ZLSMXsoCbds2fPNmWAL730kvni89xzz5mScD13uhtvvNF84bROOsqByPKbpwtqN5/mK9acbi07L67YsTQBEAo0OdWKH200NmDAAJNca3dvq3GlHtDUZFW7d+uouDXt55lnnjHBTkeEzznnHPM49Q+GBkJycrLp6aHLi2kpuI5Aa58OndNtjXxrkNVpSzoyr1ONtNGb1Z1daUKuU4v0QKoeCLaqnrRfyEcffWSarh1wwAGmqZu1PrhWVr3++utSVlZmqgIuuOACb2dzAMGpQuvZJkU6Zbrj869bS8wo99EDdjRItEY6W6e6K3i2Fu+oXgRCATFbQipmR7n8sc5MM+kvSEdStKu4RTvLagda7QT766+/Ss+ePU1jM10v1qKlj3pd5w/qPG39gmgd3VC6DpvOs9Nu5Fperku9aPm3b6m4dsDVjrva+VzLy/VLmn7Z9F0nVrvS6s/oUZA90cfXEW9NwHdV1ojwUVReJXe995O5/I9j+0pqwo4j5/d/tFq2FlfKxIO7y96e0jWEJ03mdDRV169mbi/8+fdDTLEXv9/wjs2aYE89rp/M+ylXvljrnuoyokeWnDS4004/8/LC9fLjHwVydP/2Mmof9woGCD/EawQ7Xgd1pFs7yNVvbBMTE+NtlKMvTLvVatmA7wvT8kWry5ye61Ji2pXcMnfuXPMYOvfb2kZHP3QNV4seFdFlZzThtrbxfR5rGzrQoiG69qfStbl9E27V3rNe98Z8SswBAAiUDdvd/VTapSVKYlyM9GiT4p3fPXbfhhultU51L++5rYSRbgD2CWrSffzxx5vh/Hfffdesja1D/dpETUenrbIfHXnW0W8tcVy2bJkZtdayRl3OS2n5oHYd11bw2vVcG/pcccUVZq641Qr+rLPOMg2AtMxQa/t1vqKOkvs2TtM5i1pKqWUKOsqu8/6+//5781iAyiup9Cbb1nkvny6oljaeAJ5XyvwwAAACpaDMPbiSnRbv7U5+wn4d5fyDe9SZy+3LKi/fVkzMBhCm3cu1ec2UKVPksssuM+unapJ88cUXmwnwlsmTJ0tJSYlZ2ktHtA8++GCTHPsO7eu8cE2Ode1VHTkfN26cmXdo0SF/revXMnZdTkYb7ehz+K7lrZ3UdW65TrK/6aabzBxGLS3v379/AH8jcLJXvt9g1vs8bVhn+XmLO+n27YJqSU9yL3NU6An+AADAfuXV7pUHEj2rSOjgzcierXf7M9kp7gPlOi0MAMIy6U5LSzMNbfS0K/qBqQuc62lXtFO5Jsy7M3DgQNOdbndOPfVUcwLq09YH1jJgby7ZKBXVurRIlHRr7S5d85We6Em6y2mkBgBAoFRWu6cnJsQ1vpDTGunWUXKWDQNgFxYkBBpB1/qsrHH3HNSEW3VvndLgmp66BIlvmRsAALBfeZV7pDvBM9LdGMnxMZLoSdJZNgyAXUi6gUbO51Y6um1paD63yvCUl+uSYTW1QVscAAFkNX8E+LsBgsc6KJ4Q2/ivt1pRme3pxcKyYeGPeI1g/d0EtbwcCBVWU7SOmUmmMcuyPwtkvy6ZDW6r3cx1ALym1r18SWayu3QN4UcbNGofiY0bN0qbNm3Mdf0CB+xpukplZaVs2bLF/P3o3w0A/yXd2rm8KVqnxMsfeWU0UwtjxGsEO16TdAONYJWcZSXHy+F92prTrmjSlZYYJ/mlVVJYVk3SHcb0A1iXNty0aZNJvIGmSE5Olq5du+60dCaA5qnwlpc37d8Uy4aFP+I1gh2vSbqBJox0t0pp3BGudCvpLmded7jTo576QVxdXS01Ne4vfMCexMTESGxsLJURgB3l5U1opKZYNiwyEK8RzHhN0g00wvYSd/KcleKer70nNFOLLPpBHBcXZ04AgGCPdDetvJxlwyIH8RrBQk0b0Aj51kh3I+dnW83UWKsbAADnNlJTWfWWDQMAfyPpBhrRRCGviUn3jrW6KS8HAMDJjdRS4mNMA1RVUlFtx64BiHAk3cAeaDM0PfAdHbVjBHtPrO1YqxsAAPvV1rqaPdKtJcfJ8e4Zl2WeEnUA8CeSbmAPtntGuTOT4yRaM+9GSPeWl3PEHAAAu1X6lIU3Nen2HR0vqyTpBuB/JN3AHjS1tFylJ8Z6y8u1PB0AANinosqddMdGR0msVSveBEmepLuUpBuADUi6gT3IK2lG0u0Z6a6qcVGqBgCAzcqrm7dGtyXJs8xYOeXlAGxA0g3sQV6ptVxY45PuuJhoSY53HzWnxBwAgMCMdDd1jW6LNaebkW4AdiDpBho70t2EpLvOsmF0MAcAwFYV3pHupnUutyR6DpTTSA2AHUi6gUbP6W5c5/L687rpYA4AQKCWC2vmSLdnTjfl5QDsQNIN7EG5p2TNarLSWDs6mLNWNwAAdrKS5eaOdCdZI900UgNgA5JuYA8qa5oXyNMS3Ul3UTnLhgEAYKfmrtG905JhNFIDYAOSbmA3qmtqxVr6M76JgdwaGadUDQCAAM3pbmZ5OUuGAbATSTewG7rklyUuJqpJvytrXhlJNwAAgelentjC8nJiNgA7kHQDu1HpKVeLjY6S2JjoZpWqlXseAwBCVU1NjUyZMkV69OghSUlJ0rNnT7njjjvE5dpxYFIvT506VTp06GC2GTNmjKxdu7bO42zfvl3OPvtsSU9Pl8zMTJk4caIUFxfX2Wbp0qVyyCGHSGJionTp0kXuvffenfZnzpw50qdPH7PNgAED5L333rPx1SOUysubWpVmsZb5ZMkwAHYg6QYaUa7WnCDuTbqZHwYgxN1zzz3yxBNPyGOPPSarVq0y1zUZfvTRR73b6PVHHnlEZsyYId9++62kpKTIkUceKeXl5d5tNOFesWKFfPzxx/LOO+/IF198IRdddJH3/sLCQhk7dqx069ZNFi1aJPfdd5/ceuut8uSTT3q3mT9/vpx55pkmYV+8eLGcdNJJ5rR8+fIA/kbgNFastWJvS2K278EkAPAHkm6gEUfO45o4yu1bXk5TFgChThPdE088UY499ljp3r27nHLKKSY5Xrhwoblfk5SHHnpIbr75ZrPdwIED5fnnn5eNGzfKG2+8YbbRZP2DDz6Qp59+WkaMGCEHH3ywSdpffvlls5168cUXpbKyUmbOnCn77ruvnHHGGXLVVVfJAw884N2Xhx9+WI466iiZNGmS9O3b14y4DxkyxBwQQORqaSM1a6S71rXjsQDAX0i6gd2orGl+ELeOmlvzzAAgVB144IHy6aefypo1a8z1H3/8Ub766is5+uijzfV169ZJTk6OKSm3ZGRkmOR6wYIF5rqea0n5sGHDvNvo9tHR0WZk3Npm1KhREh8f791GR8tXr14teXl53m18n8faxnoeRHZlWnNHuvXguk4lUywbBsDfYv3+iEAYzuluSXm5HjGvrXVJtCeYA0Co+fvf/25Kv3UedUxMjJnj/c9//tOUiytNuFW7du3q/Jxet+7T87Zt29a5PzY2VrKysupso/PG6z+GdV+rVq3M+e6epyEVFRXmZNHXgvBiHeBu7pxuq5maLvOpFWqt/LhvAMBIN9CIpLtZI90+P1PuOQIPAKFo9uzZpvT7pZdekh9++EGee+45+de//mXOQ8G0adPMyLt10gZtCC9WnG1u93LfZcOYFgbA30i6gUaUlzfnyLl2O7eWGSunxBxACNP50zrarXOstVv4OeecI9dee61JZlX79u3N+ebNm+v8nF637tPz3NzcOvdXV1ebjua+2zT0GL7PsattrPsbcuONN0pBQYH3tGHDhmb/LuDske7mrtPtu2wY5eUA/I2kG2hMeXkzGqn5HjWngzmAUFZaWmrmXvvSMvPaWvdnpJaEa9Kr8759S7h1rvbIkSPNdT3Pz883Xcktc+fONY+hc7+tbbSjeVVVlXcb7XTeu3dvU1pubeP7PNY21vM0JCEhwSxT5ntCeGlpIzXfZmqMdAPwN5JuwKY53SqBpBtAGDj++OPNHO53331XfvvtN3n99ddNR/G//vWv5v6oqCi55ppr5M4775S33npLli1bJueee6507NjRLOeltNO4dh2/8MILTdfzr7/+Wq644gozeq7bqbPOOss0UdPlwHRpsVdeecV0K7/uuuu8+3L11VebLuj333+//PTTT2ZJse+//948FiJTdU2tVGvbcZN0N7+83OrFwkg3AH+jkRrQiCPnzU26mR8GIBzo0l5TpkyRyy67zJSIa5J88cUXy9SpU73bTJ48WUpKSsy62zqirUuCaXKcmJjo3UbnhWtyPHr0aDNyPm7cOLO2t0XnW3/00Udy+eWXy9ChQyU7O9s8h+9a3tpJXeeW6/JkN910k/Tq1cssS9a/f/8A/kbgJL5LfLVkpJuYDcAuJN1AY+Z0N7O83FqrmzndAEJZWlqaWYdbT7uio9233367Oe2KdirXhHl3dI3vL7/8crfbnHrqqeYE1DlAHhPVopVCvEl3Jc1PAfgX5eVAY7qXN3Pdzx1rdRPAAQCwc43u5sbqnRqpEbMB+BlJN9CIQN7SkW4COAAA9rCqyXyX6mwOupcDsAtJN9CoRmpRLexevmO+GQAAcOBIN+t0A7AJSTfQmPLyZnZDpXs5AAABWqO7hSPd3iXDmNMNwM9IugEblwxL9CTr5Z6j8AAAwHlrdCtGugHYhaQbCED3co6aAwBgj/Iq/5SXJ/o0UnO53Ot+A4A/kHQDdo50W93LfdYQBQAAdkwF889It+bbxG0A/kTSDTRm7c9mBvIdjdQoLwcAwA7WFK7m9l+xxMVES1yMu3EqFWoA/ImkG9gFLS3zlpe3cKSbpBsAAJsbqXmmdLWENVrOSDcAfyLpBnahqsZlSsxaMqfbd8kw5ocBAODcRmrux7CmhVGhBsB/SLqBXbBGuVuSdFtH3atrXeYEAAD8y0qQreqylmCkG4AdSLqBPTVRi4mS6Gj3HK/mBO8oz49SYg4AgP9pNZkVc1vKOlhufQcAAH8g6QZs6lyuoqKivGt16xIkAADAnpHuljZS861so7wcgD+RdAM2Jt2+a3VbjV4AAIBD53RbS30SswH4EUk3sAuVNe4j5/ExLTtybs0xY6QbAAD/sxJk5nQDcCqSbsCmNbotrNUNAIA9dGUQ7zrdflkyjO7lAPyPpBsIUHm51egFAAD4f3lP/ywZxjrdAPyPpBvYQ9Ld0iBuzQ+jezkAAP5lNTzTlUKau7ynL+tAu1XtBgCOSbrz8/P98TBAWJaXW3PMSLoBOAExG+G6XJiuGNJSjHQDsEOTs4l77rlHXnnlFe/10047TVq3bi2dOnWSH3/80d/7BzhgnW7/zOmmkRqAQCNmI9z5c7mwut3LWeYTgP80OZuYMWOGdOnSxVz++OOPzen999+Xo48+WiZNmuTHXQOCq7LGT+XlVqkac7oBBBgxG+HOn8uF+T4O5eUA/Cm2qT+Qk5PjTbrfeecdM9I9duxY6d69u4wYMcKvOweEQyM1bwD3JPEAECjEbIQ7fy4Xpki6AdihydlEq1atZMOGDebyBx98IGPGjPEu2VDjWdcYCAd+S7opVQMQJMRshDvvcmF+Gune0UiN77QAgjjSffLJJ8tZZ50lvXr1km3btpmycrV48WLZe++9/bhrQHBZI9MtndPNUXMAwULMRqSMdPtjje4663QzJQxAMJPuBx980JSS62j3vffeK6mpqeb2TZs2yWWXXebPfQPCYqTb+nnr8QAgUIjZCHf+b6Tmidk1taaK0x8d0QGgyUl3XFyc/N///d9Ot1977bX8NhFW/D6nm6QbQIARsxHurNia6LeRbvfjuFzuxNtfyTyAyNaopPutt95q9AOecMIJTdqBP//8U2644QbTAb20tNSUqM+aNUuGDRtm7tejjLfccos89dRTZm3Rgw46SJ544glT3m7Zvn27XHnllfL2229LdHS0jBs3Th5++GHvKLxaunSpXH755fLdd99JmzZtzPaTJ0+usy9z5syRKVOmyG+//WYeX5daOeaYY5r0ehCOR89bmnS7AzYj3QACwc6YDTg16W7pVDCLPo4Obpuku5qkG0AAk+6TTjqpUQ+mJThNaaaWl5dnkujDDz/cJN2aDK9du9Y0frFoCfsjjzwizz33nPTo0cMkxUceeaSsXLlSEhMTzTZnn322KW/X5cuqqqpkwoQJctFFF8lLL71k7i8sLDQd1rXpmy6fsmzZMjn//PMlMzPTbKfmz58vZ555pkybNk2OO+4487P6un/44Qfp379/o18TwkeVd053jN+aslCqBsBudsVswInKPetp+6t7uf670MRbk3k9pfnlUQFEukYl3bW19sxF1ZFkXX5MR7YtmlhbNEF56KGH5Oabb5YTTzzR3Pb8889Lu3bt5I033pAzzjhDVq1aZbqo6wi2NTr+6KOPmhHqf/3rX9KxY0d58cUXpbKyUmbOnCnx8fGy7777ypIlS+SBBx7wJt06Mn7UUUd51xq/4447TBL/2GOPmUQdkccamW5pcxZrpLzWJVJd65K4GOaHAbCPXTEbiIR1us1jxe1IugHAH/z3CdXMEjhNlE899VRp27atDB482JSRW9atW2fWGLWWJVMZGRlmPfAFCxaY63quI9ZWwq10ey0z//bbb73bjBo1yiTcFh0tX716tRltt7bxfR5rG+t56quoqDAj6L4nhBd/laz5/jwBHAAA/6nwjHRby3P6Q4InbluPDQABb6SmSkpK5PPPP5f169ebEWRfV111VaMf59dffzXzs6+77jq56aabzGi1/rwmx+PHjzcJt9KRbV963bpPzzVhr/OiYmMlKyurzja+I+i+j6n3aTm7nu/ueerTMvTbbrut0a8VoaW21iVVNS5zOa6FR8+jo7VULUoqa1zu0fMEP+0kAAQwZgORM9LtWTaMkW4AwUq6dT1uLd3WpmcayDW53bp1qyQnJ5vktykBXEvgdIT6rrvuMtd1pHv58uWmnFuTbie78cYbzcECi450a6k8woN2LLX4I5BrAK+sqfY2ZwOAQPBnzAacqMLPc7p9K9RogArAX5qcTejSYMcff7wpy05KSpJvvvlGfv/9dxk6dKiZQ90UHTp0kH79+tW5rW/fvuZovGrfvr0537x5c51t9Lp1n57n5ubWub+6utp0NPfdpqHH8H2OXW1j3V9fQkKCpKen1zkh/JJu7WAaG93yOdgEcADB4M+YDUTSnG7fxwaAlmryJ5Q2ILv++uvNnOmYmBgzt1lHeLXLuJaIN4V2Ltd51b7WrFkj3bp1M5e1JFyT3k8//bTOiLLO1R45cqS5rue6lNiiRYu828ydO9eMouvcb2ubL774wnQ2t2iTtN69e3s7pes2vs9jbWM9DyKLd41us3RIy5Nu1uoGEAz+jNlAxCTdPquOAIA/NPkTKi4uzgRvpaVp1qi0NjjbsGFDk4/A61F3LS//+eefzTJdTz75pFlPW2myc80118idd95pmq7pUl/nnnuu6UhuLYmiI+PadfzCCy+UhQsXytdffy1XXHGF6Wyu26mzzjrLzBOfOHGirFixQl555RXTrdy3PPzqq682XdDvv/9++emnn+TWW2+V77//3jwWIo+/OpdbrMehVA1AIPkzZgNO7L/iTbr92Ugt1jOnu4qRbgBBmtOt86614VmvXr3k0EMPlalTp5r5Yf/5z3+avJ71/vvvL6+//rqZH3377bebkW1dIkzX3bZMnjzZzEPTpb10RPvggw82ybG1RrfSJcE0OR49erT5cjFu3DiztrdFv1x89NFHJpnXkrrs7Gyz39ZyYerAAw80Sb8uT6ZH//X16bJkrNEdmbxBvIWdy+uXl3PUHEAg+TNmA07uv5Joy0g3STcA/4hy6WLYTaCjv0VFRXL44YebudQ68jx//nwT0HUd7P32208ikZa9a3JfUFDA/O4wsDqnSJ6d/5t0zEiUK0f3avHj/Xfheln6R4EcP7CDHLh3tl/2EUD48ldMIWbb+/tFcBWUVsndH/wkelz7zpMG+O1xP121WT5ZlSvDe7SSvw7u7LfHBRC58aTJI92+62FrqZqOOgPhxt/l5d6Rbp+j8gBgN2I2wplVPWaVg/sL5eUA/M1/tThAGKmsqamTLPutEyrzwwAA8ItyT0xN9NMBcgvdywH4W5NHunXe9e66Of/6668t3Scg6Kx5XPF+OnrOnG4AwUDMRiQcIPf/SDd9WAAEOenWbuK+dBmuxYsXmzLzSZMm+XPfgOAvGeanxixWV1W6lwMIJGI2ImGk25/Lhbkfj+7lAIKcdOvSWg2ZPn26adgChAN/J907RrqZ0w0gcIjZiIw53f5Nuq3Y79sdHQBawm+fUkcffbS8+uqr/no4IKisQOv3Od0k3QAcgJiN8JrTbVd5OUk3AIcl3f/73/8kKyvLXw8HOKN7ub/Ky62j5gRwAA5AzEY48PdKIzsl3VXukXQACHh5+eDBg+s0UtNlvnNycmTLli3y+OOPt3iHgLCc001TFgBBQMxGOCv3JMWJ/m6kZvVhqXFJba1LoqN33UAYAGxJuk866aQ616Ojo6VNmzZy2GGHSZ8+fZr6cICjy8v9N9JNIzUAgUfMRjgr98zptqu83Po+kBjt38cHEHmanHTfcsst9uwJ4CDWetp+a6TG/DAAQUDMRkR0L/dzeXlsdJTo4Haty/19wN9JPYDI06iku7CwsNEPmJ6e3pL9ARw10h3nr0ZqzOkGECDEbERcebmfk2KdRqkVamVVNZ4O6XF+fXwAkadRSXdmZmadedy7U1ND0wmEPqtjqb/Ly6trXVJdUyuxfkrmAaA+YjYirnu5n+d0m8eMizZJt/UcANASjfrmP2/ePJk7d645zZw5U9q2bSuTJ0+W119/3Zz0crt27cx9QDjw+zrd9eaHAYBd7IrZf/75p/ztb3+T1q1bS1JSkgwYMEC+//77Oo1Vp06dKh06dDD3jxkzRtauXVvnMbZv3y5nn322qYrTgwMTJ06U4uLiOtssXbpUDjnkEElMTJQuXbrIvffeu9O+zJkzx/SR0W10P957770m/54QPiPd/i4vV0me0XNNvAEgICPdhx56qPfy7bffLg888ICceeaZ3ttOOOEEE/SefPJJGT9+fIt3Cgi3pDsmOsrMEdORbp0flhzvl4cFgIDE7Ly8PDnooIPk8MMPl/fff980UNWEulWrVt5tNDl+5JFH5LnnnpMePXrIlClT5Mgjj5SVK1ea5Fhpwr1p0yb5+OOPpaqqSiZMmCAXXXSRvPTSS97S+LFjx5qEfcaMGbJs2TI5//zzTYKu26n58+eb1zNt2jQ57rjjzM9qw7gffvhB+vfvz19EBLGrkZpKinc/Zmlltd8fG0DkaXJGsWDBAhk2bNhOt+ttCxcu9Nd+AUFV6ZkmkRDjv0DundfNSDeAAPFXzL7nnnvMqPOsWbNk+PDhJqnW5Lhnz57eUe6HHnpIbr75ZjnxxBNl4MCB8vzzz8vGjRvljTfeMNusWrVKPvjgA3n66adlxIgRcvDBB8ujjz4qL7/8stlOvfjii1JZWWlG4ffdd18544wz5KqrrjIHDiwPP/ywHHXUUTJp0iTp27ev3HHHHTJkyBB57LHH/PAbQyg2PU300wHyhpJuRroB+EOTP6U06D711FM73a5BVO8DQp3OubbyYn+NdPs+lvUlAQDs5q+Y/dZbb5lE/dRTTzXl6rr+t+/jrlu3TnJycswItSUjI8Mk15r4Kz3XEWvfgwC6vS49+u2333q3GTVqlMTH7ygH0tHy1atXm9F2axvf57G2sZ6nIRUVFWYU3feE0KbrZ1v9V+wY6U62ku5KyssBBGHJsAcffFDGjRtnyss0mCo9Wq5lZq+++qofdgkILt+R6LiYxjUQbHwztSrvKDoA2M1fMfvXX3+VJ554Qq677jq56aab5LvvvjMj0Joca4m6JtxK54r70uvWfXquCbuv2NhYycrKqrONjqLXfwzrPi1n1/PdPU9DtBT9tttua/TrReiUlttWXs6cbgB+1ORhvGOOOUbWrFkjxx9/vGmIoie9rLfpfUC4zOfWOdj+7DJuNXqhEyqAQPFXzK6trTUl3HfddZcZ5db51RdeeKGZdx0KbrzxRikoKPCeNmzYEOxdQgtZsVQPjmvfFH9LinePS5Uy0g0gGCPdSkvSNPAC4cjfTdQs8Z4EnjndAALJHzFbO5L369evzm06n9oaLW/fvr0537x5s9nWotcHDRrk3SY3N7fOY1RXV5sDAdbP67n+jC/r+p62se5vSEJCgjkhfNi1Rnf9kW7reQDA9qRbl+/QjqA670ov7442TwFCWYVNSbc10s2cbgB2siNma+dynVftS0fLu3XrZi5rSbgmvZ9++qk3ydZ50zpX+9JLLzXXR44cKfn5+bJo0SIZOnSouU2XNdNRdKv0Xbf5xz/+YTqbx8XFmdu003nv3r29ndJ1G32ea665xrsvuo3ejghMum1oouY7p5uRbgABS7o1gFpzsfRyVFSU6VRan95ew3xVhDhrJNoamfbvnG5N6jlqDsA+dsTsa6+9Vg488EAzYn7aaaeZeeG65JierMfSJPjOO++UXr16eZcM69ixo1nOyxoZ167jVlm6JtZXXHGF6VCu26mzzjrLzL3W9btvuOEGWb58uelWrnPTLVdffbVZFu3++++XY4891nQ/1/XCrX1BZJWXJ9g10k0jNQB+1KikW7uS6pqc1mUgnNlWXm4tGeZ5fACwgx0xe//995fXX3/dzI3Wtb81qdYlwnTdbcvkyZOlpKTEzPfWEW1dEkyXCLPW6LaWBNNEe/To0WYkXpu86drevh3PP/roI7n88svNaHh2drZMnTrVu0a30uRf1+bW5cm0qZsm+bosGWt0RxY71+hWNFIDEPCk2yofszqE+gZQINxYSbG1rra/WI9nla8DgB3sitnHHXecOe2KjnZrQq6nXdFO5Zow76nk/csvv9ztNrp0mZ4QuXbM6ba3vFyXDNNKEf37BoDmavInlZar6fIgOn9K52EBYVtebtNIN0k3gEAhZiNcWf1REj1Tt/zNGkGvrnVJVc3O0zMAoCmanFU899xzUlpaKieeeKJ06tTJzOHSuVRA2JWX+31Ot5V0M6cbQGAQsxGu7O5erjHbWolMR7sBoCWanFX89a9/lTlz5pjlObShysqVK+WAAw6QffbZZ7clZUDIlZf7uWTN+mLAOt0AAoWYjfCf021PebmWk3tLzFk2DEALNfuTKi0tTSZMmGAanuiSJCkpKabjKBDqrJHo+Bj/Hj1nzU8AwULMRrixDmDbNdLtG7dLK6ttew4AkaHZSXd5ebnMnj3bLAUyZMgQ2b59u0yaNMm/ewcEgTXnOi4myp5OqJSpAQgwYjbCjd2N1FRSvLvfMCPdAALSvdzXhx9+aDqP6vIcsbGxcsopp5jR7lGjRrV4ZwBnlZf7eaSbMjUAAUbMRtiv021TIzWV5EnoOVgOIOBJt84P0yVDnn/+eTnmmGMkLi6uxTsBOLJ7uZ8bqVklcHrEnOVHAAQCMRvhyu5GaiqZkW4AwUq6tYGazg0Dwr57uZ+XDLMasrhc7hJ2O78oAIAiZiNc2d1IzTy2J26XMi0MQCCS7sLCQklPTzeXdYROr++KtR0Q8uXlfk6642KiJTY6yqz5qaVqJN0A7EDMRkSt023nSLd31RGWDAMQgKS7VatWsmnTJmnbtq1kZmaaZRTqs8pla2r4YEJos2uk25rXXVRebUrMW/n90QGAmI3wV1vr8jY9tbV7OSPdAAKZdM+dO1eysrLM5Xnz5vnruYGImtNtdTC3km4AsAMxG+HOSrhVog0HyHdqgEp5OYBAJN2HHnpog5eBcA7mdox0e5upEcAB2ISYjXBnlXvr0p6xNhwg32mpTw6UAwhE0r106dJGP+DAgQNbsj9AeJeXexq+MD8MgF2I2YicJmr2NiS1GqByoBxAQJLuQYMGmfnajVnmiDndCGX6N+4tL7ch6baWH6ETKgC7ELMRKWt021la7jvSTcwG0FKN+rRat26d/Prrr+b81VdflR49esjjjz8uixcvNie93LNnT3MfEMo04dYlvezoXu67/AilagDsQsxGuLOqxRJsHum25nTryLoelAcAW0e6u3Xr5r186qmnyiOPPCLHHHNMnZLyLl26yJQpU+Skk05q9s4ATjl6rgUddjVScz8PjdQA2IOYjXBnxVC7y8utmK35tn4/sJJwAGiqJmcVy5YtMyPd9eltK1eubPIOAE5SYc0Ti43Z41SKFjVloZEagAAgZiOsy8s9fVLsok3arKo3KtQAtESTP6369u0r06ZNk8rKSu9tellv0/uAUFbhCeQJNgXypHiCN4DAIWYjrBupxdo/8myNppdWVtv+XAAivLzc14wZM+T444+Xzp07ezuVa6dUHRV8++237dhHIOAj3XbM51ZJcTRSAxA4xGyEo4oAlZer1IQYKSirkuIKkm4AAUy6hw8fbpqqvfjii/LTTz+Z204//XQ566yzJCUlpQW7AjipZC3G3qYszOkGEADEbIQjq9Tb7vJylZ4UJ3/ml0thGUk3gAAm3UqT64suuqgFTwtE6kg3STeAwCJmI9xYS3gForFZWqL7q3JReZXtzwUgfDUr6V67dq3MmzdPcnNzpbbWPTJomTp1qr/2DQjanG7bRrp91vxszLr3ANBSxGyEG6sZqRVT7ZSeGGfOC0m6AQQy6X7qqafk0ksvlezsbGnfvn2dpEEvk3QjlFVU19o60p3oaaRW63KvCZ4QgCYwACIXMRvhnHQnxzdr7KjJ5eWK8nIALdHkT6s777xT/vnPf8oNN9zQoicGnMiaa21XMqxrf0dHuZPu8kqSbgD2ImYjnOd0B3Sku4zycgDN1+ThvLy8PDn11FNb8JSA80e67WrOotUgyZ45aKVVNGUBYC9iNsJRIOd0pye5x6coLwfQEk3OLDTh/uijj1r0pECkjnT7Hpm3yuMAwC7EbISb2lqX9wB5YBqpuUe6iytqpEbL1AAgEOXle++9t0yZMkW++eYbGTBggMTFuT+MLFdddVVz9gNwBJ1nbfcyJImeLwlWeRwA2IWYjXDjGzuTA1BenhIfIzHRIvr1QDuYZybH2/6cAMJPk5PuJ598UlJTU+Xzzz83p/qlsyTdCGWBHOlmrW4AdiNmI1yTbm14Gq1NUmym3211XndeaZVppkbSDSAgSfe6deua9URAKC0ZlmDjSPeO8vK6y+0BgL8RsxG+ncsDt/pHmpV0s2wYgGayL7MAQlB5tTuYJ9o50m01UqukkRoAAE7tXG6hmRqAgIx0X3fddXLHHXdISkqKubw7DzzwQIt3CoiEke5yTyMYAPAnYjbCWSA7l++8bBgHywHYmHQvXrxYqqqqvJd3N+8FCIslwwIw0l1O93IANiBmIxLKywOadCd5km7KywHYmXTPmzevwctAOKmuqZVqz3IggRjpprwcgB2I2QhnZVXVQZjT7Vmru8w9AAUAITun++677zYj5ddcc433tvLycrn88suldevWpmP6uHHjZPPmzXV+bv369XLsscdKcnKytG3bViZNmiTV1XXLfz777DMZMmSIJCQkmOVTnn322Z2ef/r06dK9e3dJTEyUESNGyMKFC218tXAi33LveF0fxCbJ8e7gXcJINwAATWI1IQ3onG5PeXlROeXlAEI46f7uu+/k3//+twwcOLDO7ddee628/fbbMmfOHLM82caNG+Xkk0/23l9TU2MS7srKSpk/f74899xzJqGeOnVqnc6tus3hhx8uS5YsMUn9BRdcIB9++KF3m1deecXMgbvlllvkhx9+kP3220+OPPJIyc3NDdBvAE5QEaBlSLxHzClTAwCgSawqsSTPAexAoJEagJBPuouLi+Xss8+Wp556Slq1auW9vaCgQJ555hnTmO2II46QoUOHyqxZs0xy/c0335htPvroI1m5cqW88MILMmjQIDn66KNNwzcdtdZEXM2YMUN69Ogh999/v/Tt21euuOIKOeWUU+TBBx/0Ppc+x4UXXigTJkyQfv36mZ/RkfOZM2cG4TeCYM/ntrO03PeIeXF5tbhc7nJ2AACwZ+XB6F7uidvlVbVS4VnlBABCKunW8nEdiR4zZkyd2xctWmSat/ne3qdPH+natassWLDAXNfzAQMGSLt27bzb6Ah1YWGhrFixwrtN/cfWbazH0ORcn8t3m+joaHPd2qYhFRUV5nl8TwiPQJ5gYxM1lZoYK9pzUKePU2IOAEDTu5cHck53YlyMqYJTlJgDsC3p1vnQeXl55vLtt98upaWl4g8vv/yyKeeeNm3aTvfl5ORIfHy8ZGZm1rldE2y9z9rGN+G27rfu2902miSXlZXJ1q1bTZl6Q9tYj9EQ3eeMjAzvqUuXLk1+/XDoSLcnsNolJjpKUjxfFoooMQfgZ3bFbMBJ63RrIhxI6TRTA9ACjcouVq1aJSUlJebybbfdZkrCW2rDhg1y9dVXy4svvmial4WaG2+80ZTAWyd9PQiPke5ABPI0mrIAsIkdMRtw2pJhgRzp9l02LJ8O5gCaoVFdKHS+tM53Pvjgg80c1H/961+mm3hDfJuY7Y6WdGujMj0ib9ER5y+++EIee+wx0+hMS7/z8/PrjHZr9/L27duby3pev8u41d3cd5v6Hc/1enp6uiQlJUlMTIw5NbSN9RgN0U7oekL4CNRIt9VMbVMBI90A/M+OmA04baQ7kHO6VavkeF13RPJL3T2DAMDvSbd2BNfO3u+8845Z1uv999+X2Nidf1Tva2wAHz16tCxbtqzObfolQedt33DDDaZcOy4uTj799FOzVJhavXq1WSJs5MiR5rqe//Of/zTJuy4Xpj7++GOTUGtDNGub9957r87z6DbWY2gJuzZp0+c56aSTzG21tbXmujZdQ+Ql3YEc6S5k+REAfmZHzAacoKqmVqpq3A1IkwI80t0qxR2380pYqxuATUl37969zfxrq8mYJqRWkttcaWlp0r9//zq3paSkmDW5rdsnTpxolvLKysoyifSVV15pkuUDDjjA3D927FiTXJ9zzjly7733mjnYN998s2nOZo1CX3LJJWbkfPLkyXL++efL3LlzZfbs2fLuu+96n1efY/z48TJs2DAZPny4PPTQQ6Y0Tw8CIBIbqdk/0p2a4P6nR0MWAP5mR8wGnNRETVf1DESs9pVpRrpF8hjpBtAMTV7kUEeBA0WX9dIvDDrSrd3Ctev4448/7r1fy8L1SP6ll15qknFN2jV51sYxFl0uTBNsXfP74Ycfls6dO8vTTz9tHsty+umny5YtW8wRf03ctTTvgw8+2Km5GsJbIMvLrYYsNFIDYKdAxmwgkMuFaaVG4MvLRfJLGekGEICkW/3yyy9mNFibtSgdbdamaD179pSW+Oyzz+pc1wZruua2nnalW7duO5WP13fYYYfJ4sWLd7uNlpJTTh7ZaKQGIBzZFbOBYI10B7q0XLVKthqpVUptrUuidbgdABqpyUN62uBMA7Y2MBs4cKA5ffvtt7LvvvuaudJAqAp0IzXFSDcAOxGzEY6dy4ORdKcnxpmy9ppapoYBCMBI99///ndTqn333XfvdLs2QPvLX/7SjN0Agq8ioEuG7ZjTrd2FA10mByAyELMRTsqqqoPSuVzpyHZGUpzklVaZ0e4Mz8g3ADRGk4f0tDxNG5zVp03KVq5c2dSHA5w30h0XiJFud7DWLqzW8wKAvxGzEU7KKmuDskZ3/Xnd20tYNgxA0zQ5u2jTpo0sWbJkp9v1NrqjIhxGuhNi7Q/m8bHR3jJ2OpgDsAsxG+GktLI6YBVpDWmVQjM1AAFKui+88EK56KKL5J577pEvv/zSnLTU/OKLLzb3AaGq3LtOd2CWIaGDOQC72RWz9TF0Wsw111zjva28vNws2alLf6amppqVRzZv3lzn59avXy/HHnusJCcnmwP1kyZNkupqdyLl21R1yJAhZunPvffe26w7Xp82WO3evbtpuDpixAjTZwbhr8yne3kwZCbtaKYGALbO6Z4yZYpZY/v++++XG2+80dzWsWNHufXWW+Wqq65q6sMBjlHpbaQWmGCuJeZbiisZ6QZgGzti9nfffSf//ve/TSNVX9rvRZfonDNnjmRkZJgVQU4++WT5+uuvzf01NTUm4W7fvr3Mnz9fNm3aJOeee67ExcXJXXfdZbZZt26d2eaSSy6RF1980awxfsEFF0iHDh28S32+8sorct1118mMGTNMwq2d2fW+1atXU3EX5grK3Mt16dzqYGiV4n7e7SUsGwagaaJc2sWpmYqKisy5BvRIV1hYaL5kFBQUSHp6erB3B02ky3/8443l5vKU4/pKcnyzVtNrkpcXrpcf/yiQYwd0kIN7Zdv+fAAiO6b4I2YXFxebUejHH39c7rzzThk0aJBJenU/tZT9pZdeklNOOcVs+9NPP0nfvn1lwYIFcsABB8j7778vxx13nGzcuFHatWtnttHEWZuwbtmyReLj481lTdyXL3d/HqszzjhD8vPz5YMPPjDXNdHef//95bHHHvOuRd6lSxe58sorTeO4xiBmh6aHP1krOYXlMuGg7rJPu8B/9/x1S7E89eU6aZMaL9eN7R3w5wfgPI2NJy2qo9XATcKNcFBe7S5ZU/ExgSkvt5qpsWwYgIB85vghZmv5uI5Ejxkzps7tixYtkqqqqjq39+nTR7p27WqSbqXnAwYM8CbcSkeo9QvLihUrvNvUf2zdxnqMyspK81y+20RHR5vr1jYITzpGlFdaWaehWaBlep5XO5i3YMwKQASyfzgPCKG1P7W5WWzAku4dy4YBgNO9/PLL8sMPP5jy8vpycnLMSHVmZmad2zXB1vusbXwTbut+677dbaOJeVlZmeTl5Zky9Ya20ZH1XamoqDAniz4eQm8+t7XaR2aQluvSsnZd4bO61iVFFdVm7W4AaIzAZBdAiDRnCWRHVCvpLixnbhgAZ9uwYYNcffXVZp61Ni8LNdOmTTPlf9ZJy9ERWqxlujR2xgXo4Hh9MZ61ulU+87oBNAFJN+Az0h3ItT/TPYG70NMYBgCcSku6c3NzzXzu2NhYc/r888/lkUceMZd1pFlLv3XutS/tXq6N05Se1+9mbl3f0zY6Ty4pKUmys7MlJiamwW2sx2iINpHT+XbWSQ8iILTkl1YFtbTc0sozym6VugOA35Nuna81evRoWbt2bVN+DHC8YCxDsmPpEeaGAfA/f8ZsfZxly5bJkiVLvKdhw4bJ2Wef7b2sXci127hFu4nrEmEjR4401/VcH0OTd8vHH39sEup+/fp5t/F9DGsb6zG0hH3o0KF1ttFGanrd2qYhuvyYPo/vCaFlx3zu4JZ075jXTdINwKY53RpQly5dyu8XYTvSnRjAkW6rRK2qxiWllTWSkkCLBQD+48+YrQ3Y+vfvX+e2lJQUsya3dfvEiRPNUl5ZWVkmqdVu4poIa+dyNXbsWJNcn3POOXLvvfea+ds333yzac6mSbHSpcK0K/nkyZPl/PPPl7lz58rs2bNNR3OLPsf48eNNoj98+HDTPb2kpEQmTJjgl9cKZ5eXt0oJ9kh3fJ2RdwCwpbz8b3/7mzzzzDNN/THA0Uo9I93JARzp1oZt1rxuHe0GAH8LZMx+8MEHzZJg48aNk1GjRply79dee817v5aFv/POO+Zck3HdN12n+/bbb/du06NHD5Ng6+j2fvvtZ9YXf/rpp71rdKvTTz9d/vWvf8nUqVPNkmU60q7LidVvrobwQnk5gFDW5KG16upqmTlzpnzyySemxEuPdPt64IEH/Ll/QECUe0a6kwI40m2Ndmv38vzSSumUmRTQ5wYQ/uyM2Z999lmd69pgbfr06ea0K926dZP33ntvt4972GGHyeLFi3e7zRVXXGFOiBzOKy/nYDkAG5Pu5cuXm0Yqas2aNXXui9J1FIAQpOXdgZ7TbS178kdemRQQvAHYgJiNcKBrYntHuoNeXu7px1JaafaL774AbEm6582b19QfARwvGEuGqcwkz9wwyssB2ICYjXA5MO5do9vTDyVYrLW6tR9LSWWNpNKPBYCdS4b9/PPP8uGHH0pZWZm5rkf7gFAVjCXDrJFuRUMWAHYiZiMcmqilJ8WafijB5NuPJc+zXwCwJ03+5Nq2bZtZOmSfffaRY445RjZt2uTtWnr99dc39eEAZy0ZFoQ53Sq/jMANwP+I2QgHTmmiZqGDOQDbk+5rr73WLEOia28mJyfX6Saq3UOBUBSMdbp9R7qZ0w3ADsRshFMTtSzHJN3u2M1a3QBsm9P90UcfmbLyzp0717m9V69e8vvvvzf14QBHlZcHeqTbOlpeWF4t1TW1QS+bAxBeiNkIp/Jy60B1sO3oYE6VGoDGafI3/JKSkjoj3Jbt27dLQkJCUx8OCLqaWpe3QUug53Tr88XFRHkTbwDwJ2I2Ql15VY0s+7PAXO7okKU1KS8HYHvSfcghh8jzzz/vva5LJdTW1sq9994rhx9+eJN3AHBKablKjA1s0q3/fqxOrLr8CAD4EzEboW7BL9tM9/I2qfHSr0O6OAHl5QBsLy/X5FobqX3//fdSWVkpkydPlhUrVpiR7q+//rrJOwA4pbQ8ITZaoqMDv9Z8RnK8bCmuZNkwAH5HzEaox+cv1241l0f3bReUGL278nJt8MZa3QBsGenu37+/rFmzRg4++GA58cQTTenaySefLIsXL5aePXs29eGAiF0uzGKNdNNMDYC/EbMRyub/stVUo7VLT5ABnTLEKay55To1zbdaDgD8NtKtMjIy5B//+EdzfhRwnGB1Lq8fvGnIAsAOxGyEqjWbi835Ib2yHTPKreI8a3UXlVebJm/J8c36Og0ggjTrUyIvL0+eeeYZWbVqlbner18/mTBhgmRlZfl7/4CwXaO7ftJtrUMKAP5EzEao2lpcYc47ZDijgVr9ZmqadGvs7twq2HsDIOzKy7/44gvp3r27PPLIIyaQ60kv9+jRw9wHhJpgLRdmyUiy5obRSA2AfxGzEapKK6tNAzXVOtUZ63M31EzNWs4MAPw60n355ZfL6aefLk888YTExLiTlJqaGrnsssvMfcuWLWvqQwJBVVZVHdQ53VkpnqS7jIYsAPyLmI1QtbXIncxmJMVJQoBXFmlK7CbpBmDLSPfPP/8s119/vTfhVnr5uuuuM/cBoaassjaoc7r1C0VUlEhVjYu1ugH4FTEboWpribu0PNuBo9y+o+8k3QBsSbqHDBnincvtS2/bb7/9mvpwgGPmdCcGKemOiWatbgD2IGYjVG0tspLuBHEindOtSLoB+K28fOnSpd7LV111lVx99dXm6PkBBxxgbvvmm29k+vTpcvfddzfqSQEnKau0ystjg1qmlldaZYJ3t9YpQdsPAKGPmI1wsLW40tFJd+uUBO/KI7W1Lkd1VwfgPI3KMgYNGiRRUVHicrm8t02ePHmn7c466ywz3xsIJcFeMmzHEfMSlg0D0GLEbIRT5/LsNGeWl6cnxUpsdJRU17pMTxZrjjcANDvpXrduXWM2A0KS1R01Kb7Jsy1saMjCsmEAWoaYjVCngzzepNuhI906GNUqJV62FFXI9pIKkm4ALU+6u3Xr1pjNgJAU7Dndvmt157H0CIAWImYj1BWWVZvmolqxbc2ddqLWnqR7W3Gl7N022HsDwMmaNYl148aN8tVXX0lubq7U1ro7P/vO+QZCcZ3uYM/pVttZqxuAnxGzEWq2eEa5NanVZqNOZcVundcNALvT5Czj2WeflYsvvlji4+OldevWprzGopdJuhFKqmtqzdH0oM/p9gTugrIqqal1OfpLBoDQQcxGaM/ndmZpef2kextVagD8nXRPmTJFpk6dKjfeeKNERwdvDizgDyWeUW49dpQYF7y/57SEWImLiTIHAPJLK6W1Q+ewAQgtxGyEctJtdQh3Km+VmqfTOgDsSpOzjNLSUjnjjDNIuBEWCsvcjcvSE+PqVG0Emj53pmfeGmVqAPyFmI3QXqPbufO5rfJ3a6Tbd4UfAGhx0j1x4kSZM2dOU38McCQt5/ZtZBZMWZ59oIM5AH8hZiMUFZRV15l65VTW/lVU13pXQgEAv5SXT5s2TY477jj54IMPZMCAARIXVzdZeeCBB5r6kEDQWKPKmUlxjgne25kbBsBPiNkIRUXl7gPiaYnBa3DaGHEx0Wa9bu22rrE7JcHZ+wsgxJLuDz/8UHr37m2u12+kBoSS/FIHjXTTBRWAnxGzEWq0majVbyUtMfixuTEl5lbS3SUrOdi7AyBcku77779fZs6cKeedd549ewQEUL6nvDwjKfglbNZapIx0A/AXYjZCTXGFu7RcF/FIiQ/eqiKNlZWSIOu2lhK7Afh3TndCQoIcdNBBTf0xwJHyPaXcrVLinNMFlfJyAH5CzEaolpanJsaGRAWlbzM1APBb0n311VfLo48+2tQfAxw90p3pgJHu1p4urdqMpYyGLAD8gJiNUFNUXu1dSjMU7Dhg7u64DgANafIn2sKFC2Xu3LnyzjvvyL777rtTI7XXXnutqQ8JBEVFdY2326gT5nQnxMZIemKsFJZXmzVKmRsGoKWI2QjV8vJQmM/tm3Qz0g3Ar0l3ZmamnHzyyU39McCxy4UlxkVLYpwz5o1lpyaQdAPwG2I2Qra8PMRGurWZWlVNreloDgD1NfkTbdasWU39EcDZncsdUFruW2L+69YS2VbM3DAALUfMRsiWlzt8uTBLcnyMJMRGm7W680oqpW16YrB3CYADcTgOEctJy4X5jnQrLS8HACByk27nxObd0WZvNFMDsCdNPozYo0eP3XaT/PXXX5v6kEBQ5Je6R5NJugGEK2I2Qk2ojXSrrNR42VhQzuojAHapyZ9o11xzTZ3rVVVVsnjxYvnggw9k0qRJTX04IPidyz3rYztBtqeD+dbiSnG5XCGxXAoA5yJmI9QUV1SFXNJtjXSz5CeAXYltzvIjDZk+fbp8//33TX04IGgKvHO64xzVkEXzbJ0bph1cQ6W8DoAzEbMRSvRgc6iVl6tWnoP3JN0AbJ/TffTRR8urr77qr4cDbJdf5rzy8tiYaO9BAB3tBgA7ELPhRHrAuarGZS6nJDhjVZHGNkFVLBsGwPak+3//+59kZWX56+EAW9XWuhzZvdy3mdo2mqkBsAkxG05kjXJrN/CE2NBJurNS3HFbu5fraD0AtLi8fPDgwXXmmeqHS05OjmzZskUef/zxpj4cELTAXusSiY5y3rwxPWK+NpcO5gBajpiNUFyjO91hcXlPtEJNv09U17rMet0ZDqqgA+AMTf5UO+mkk+pcj46OljZt2shhhx0mffr08ee+Abb5eUuROW+fnijRGikdpI132TDKywG0DDEboTjSnRpiSbd+j9B53Vpevq2kgqQbwE6a/Kl2yy23iL9MmzZNXnvtNfnpp58kKSlJDjzwQLnnnnukd+/e3m3Ky8vl+uuvl5dfflkqKirkyCOPNCPq7dq1826zfv16ufTSS2XevHmSmpoq48ePN48dG7vj5X322Wdy3XXXyYoVK6RLly5y8803y3nnnbdTM7j77rvPjNzvt99+8uijj8rw4cP99nrhHMv/LDTn+3ZKF6fJTmOtbgD+4c+YDdhNG4iGWhM130aomnTneZYjBQBb5nQ3x+effy6XX365fPPNN/Lxxx+b5cfGjh0rJSUl3m2uvfZaefvtt2XOnDlm+40bN8rJJ5/svb+mpkaOPfZYqayslPnz58tzzz0nzz77rEydOtW7zbp168w2hx9+uCxZssQsoXLBBRfIhx9+6N3mlVdeMUm5fkH54YcfTNKtCX5ubm4AfyMIhPKqGvk5t9hc7t8xw9FLjzA3DAAQaeXlTpv21aRmalSpAWhAoz/VtIx8T2sG6/3V1e6jlI2ha3v70mS5bdu2smjRIhk1apQUFBTIM888Iy+99JIcccQRZptZs2ZJ3759TaJ+wAEHyEcffSQrV66UTz75xIx+Dxo0SO644w654YYb5NZbb5X4+HiZMWOG9OjRQ+6//37zGPrzX331lTz44IMmsVYPPPCAXHjhhTJhwgRzXX/m3XfflZkzZ8rf//73Rr8mON9POUVm3lWb1Hhp4xlVdhItUYuJFtPBtaCsylHriAMIDXbEbMBuhVZ5eULoJd0sGwZgdxr9qfb666/v8r4FCxbII488IrW1tdISmmQrqwu6Jt86+j1mzBjvNjpvvGvXruY5NenW8wEDBtQpN9dEWsvNtZRcm8joNr6PYW2jI95KR8n1uW688cY6X1j0Z/RnEV6W/+n+O9u3U8Yev5QGa25YVnK8bCmulK3FFSTdAJosEDEb8LfiEFyj27e8XLFsGIAWJd0nnnjiTretXr3ajAJr+ffZZ58tt99+uzSXBn9Ngg866CDp37+/uU3nVutIdWZmZp1tNcHW+6xtfBNu637rvt1tU1hYKGVlZZKXl2fK1BvaRuebN0Tnl+vJoo8F56usrpU1m91N1Pp3cl5pue+8bk26txRVyt5tg703AEKN3TEbsENhGJSX69QwAPDLnG6dV62l2DrCrKVpOk9a51J369ZNmkvndi9fvtw0TAsF2qgtIyPDe9LmbHC+DXmlpmw7IylOOmYkilO19qz5qV1QAaAl7IjZgL9pD5P8UnfSnRmCS25Z5eWllTWmdwwANDvp1vJvnSu99957m9LtTz/91Bwxt0amm+uKK66Qd955x3Qf79y5s/f29u3bm9Lv/Pz8Ottv3rzZ3Gdto9fr32/dt7tt0tPTTdf07OxsiYmJaXAb6zHq01J0/X1Ypw0bNrTod4DA2FxYbs47ZiY6srTcku05Yr61iKQbQPPYFbMBO5RV1UhFtXvKQ2ZS6PUySYyLkdSEGHOZ0W4AzU667733Xtlrr71Mcvzf//7XdAo/5JBDpKVHNTXh1rlnc+fONc3OfA0dOlTi4uLMFwXf8jhdImzkyJHmup4vW7asTpdx7YSuCXW/fv282/g+hrWN9Rhawq7P5buNlrvrdWub+hISEsxz+J7gfFs8SWzbNOeOcvsuG8bcMADNYUfMBuyU5xnl1sQ1Pjaoi+s0W5anSo2kG0B9jf5U03lguma2HjHXsjRdtquhU1NLyl944QXTnTwtLc3MvdaTzrNWWrY9ceJEs5SXjoJrszPtLq6JsDZRU7rEmCbX55xzjvz4449mGTBdg1sfWxNjdckll8ivv/4qkydPNnO0dZ3v2bNnm+XILPocTz31lHltq1atMo3YdOkyq5s5wmuku22687qW+8r2Cdw1ta5g7w6AEOPvmK1Tqvbff38Tq3WVkZNOOskcBPelz6ext3Xr1pKamirjxo3bqYJMD5rrEp7JycnmcSZNmrRTB/XPPvtMhgwZYmK47r+ubFLf9OnTpXv37pKYmCgjRoyQhQsXNvl3BGfJ88yFDuUVO6wlPzlgDqC+RneqOPfcc/1ejvvEE0+Y88MOO6zO7bos2HnnnWcu67Je2klcg7c2LtOu45o0W7QsXI/ka5KsyXhKSoqMHz++ToMYHUHX5b80yX744YdNCfvTTz/tXS5MnX766bJlyxazvrcm/rr0mC5pVr+5GkKXVlZsLnSPdLdLd/ZId3pSrMTHRElljUvySislO9XZBwkAOIu/Y/bnn39uEmpNvDVJvummm8xBb12yU+Ou0hirsXbOnDnmoLlWsmli//XXX5v7tWGpJtw6bUtH3jdt2mT2Uyva7rrrLrPNunXrzDZ6sPzFF180FWcXXHCBdOjQwRuzX3nlFXOgXJf21IT7oYceMvfpQQBN5BGarPncVhfwUGTt+3b6sQCoJ8qlmQhaTLuX65cMnUNHqbkzFVdUyz/fXSX6PfTW4/d1fPnaI5+ulU0F5TL+wG7Spz3TF4BI4vSYogepNcHVZHzUqFFmP9u0aWMq10455RSzjVaW9e3b17vE5/vvvy/HHXecaexmHdDWxFnnnevj6VQvvayJuzZWtZxxxhmmt4seCFeaaGvy/9hjj3mng2kz0yuvvNKM8IfD7zcSvf3jRpn/yzY5dJ9sOap/BwlFP6zPkznf/yE926TIBYfsFezdARAAjY0nzs46ABtKy1slxzk+4fZdfmRbMcuPAHAW/XKhsrKyzLlO/6qqqpIxY8Z4t+nTp4907drVJN1Kz7WDum8FmY5Q6xcWbfRmbeP7GNY21mNoc1V9Lt9ttBpOr1vbNEQr5fR5fE9wlvxSd6zLCMEmapYsT2k8c7oB1Of8zAPwc9Lt9NJyi1VSvrWYDuYAnENHlq+55ho56KCDvJ3QdVqWjlRnZmbW2VYTbL3P2qb+lC3r+p620SRZ+71s3brVlKk3tI31GA1hmc/QaaQW0uXlnoPl+WVVUl3j7sQOAIqkGxEjVDqX77RsGCPdABxE53Zr+ffLL78soYJlPp1P+5dY1WihKi0hVuJiokQnbmriDQAWkm5E4Eh3aDQlY6QbgNNoczRtXqorimhTUos2R9PSb5177Uu7l+t91jb1u5lb1/e0jc6TS0pKkuzsbNNAtaFtrMdoCMt8OltZZY2UV7lHhjNCOOnW5oU7mqkxNQzADiTdiLjO5W1DrLxcO7pWVNcEe3cARPhnqCbcr7/+usydO9esCuJr6NChpgu5dhu3aDdxXSJMVxZRer5s2TLJzc31bvPxxx+bhFqX/rS28X0MaxvrMbSEXZ/Ldxstd9fr1jYIPfllld41uhNiYySUeZcNo0oNQHOWDANCWUlljZRW1pjO5W1CZPmtlIRYSYmPMfuuJeadMpOCvUsAIrikXDuTv/nmm2atbmv+tHZs1RFoPZ84caJZykubq2kird3ENRHWzuVKlxjT5Pqcc86Re++91zzGzTffbB5bR6KVLhWmXcknT54s559/vknwZ8+ebTqaW/Q5dGnQYcOGyfDhw82SYSUlJTJhwoQg/XbQUnklVSG/RrclK0X/losY6QZQB0k3IkJuiHUut7RNT5B1W0vN/pN0AwiWJ554wpwfdthhdW6fNWuWnHfeeebygw8+aDqJjxs3znQL167jjz/+uHdbLQvX0vRLL73UJOO6vrcmz7fffrt3Gx1B1wRb1/x++OGHTQn7008/7V2jW51++ulmibGpU6eaxH3QoEFmObH6zdUQevO5M0O4tNzSJs19ACm3yP29AwAUSTciKqC3NkegQ4c2fTNJt6cJHAAEq7x8TxITE2X69OnmtCvdunWT9957b7ePo4n94sWLd7uNlrrrCeEVo60lt0JZe88UthzPwX4AUKEz5Af4oXStVUpoHUXXkW7fkXoAAMKN9i4Jl/JyK24XllWbBnEAoEi6ERG2e0vXQiugW8ubMdINAAhXeSXhU16eGBcjGUnu10GJOQALSTciQn6Ilq5ZR8y3lVRKVY17ORUAAMJp6oLGON/O36GuvSd25xRQpQbAjaQbESHPU7rWKsSS7rSEWEmKixGdTrm1mHndAIDw4l4Ws1ZiokVah8jqInvSzjOvezP9WAB4kHQj7NXWuqSwzDNfLMTmdEdFRfnM6ybpBgCEF2v6VHZqgsRER0k4aGsl3Yx0A/Ag6UbYKyirklqXSGx0lBk5DjXtPEn3ZpqpAQDCjDXv2ephEg6suM2cbgAWkm5EzFIkuka3jhyHGpqpAQDC1WZPFZeVqIYDjdv6daO4okaKK6qDvTsAHICkGxGTdIda53JL2zTriDnl5QCA8BKOI93xsdHexq00UwOgSLoR9kJ1jW6L9UVkW3GFVNPBHAAQRp3Lc8NwpLtOiTlTwwCQdCMShPpId3pSrCTHx5h56TkEbwBAmCgsqzady7V/WlaYLBdWv4P5JpqpASDpRqQsRxKKa3RbdB56p8wkc/nPvLJg7w4AAH6x2VNarp3LY3XNsDDSuVWyOf99e2mwdwWAA4TXJxyw20ZqoZl0q06t3En3HyTdAIAwYZWWW0tjhpPu2e6ke0tRBc3UAJB0I/zX6NYlw0JxjW5fnT1J95/5jHQDAMKDtRRmuzBqomZJjo/1zuv+bWtJsHcHQJAx0o2wFuprdFs6ZyZ7v6BUVtcGe3cAAGgxa1WOcBzpVt1bp5jz37dRYg5EOpJuhLVQX6Pbt5laWmKsOYCwqYDRbgBA6FeieUe6PU3Hwk33bHfS/ds2RrqBSEfSjbCmc6lUqHdF1QMG3hJz5nUDAMKgiZp2Lk+IjZY2qeE50t3DM9K9Mb9MKqprgr07AIKIpBthzVpiq31G6B9FtzqY00wNABDq1ntKrrtkJUu0rhkWhjKS40ylnVapbaCLORDRSLoR1sKpdM1afuQPmqkBAEKctZRWtyx3bAtX1rzu37YyrxuIZCTdCFsul0tyCirCZ6TbU16+tbhCyiopUwMAhC5r5Ldr6/BOunu0cSfdqzcXBXtXAAQRSTfCVmFZtZRV1YhWrYXDfLHUhFhpkxovLpfIL1uKg707AAA0S3FFtWwtdjc67eKp4gpXfTukm+8hOjVMD5oDiEwk3Qj7+dxt0hIkNiY8/tR7t0835z/lcMQcABDa87l1Heuk+BgJZ3rAfO+2qebysj8Kgr07AIIkPDIRYHdN1MJgPreld3t34F6zuciUzwMAEGrWb3cvodUtzEvLLQM7Z5jzJRvyid1AhCLpRtjaXOBpohYG87l9G7Lo8ipF5dWy0fP6AAAIJeut+dxh3kTN0q9DhsRGR0luUYVsLqTEHIhEJN0IW+E40q1l8j09ZWqrcwqDvTsAADRJSUW1bNheZi53zXI3GQt3WkK/T/s0c/nHP/KDvTsAgoCkG2GpptYluUXhl3Sr3u3cgXt1Ds3UAAChZeG67VJd65JOmYmSnRovkWJQ50xzvuj3PKmuqQ327gAIMJJuhCXtEKoxTUuxM5PjJJz09hwt35BXKkXlVcHeHQAAGkWTzW9+3WYuH7R3tkRFRUXMb65fx3RJT4o108MY7QYiD0k3wtLGfHfpWrv0xLAL6hlJcdIlK8ksHfb9b3nB3h0AABpl6Z8FUlheLemJsTKgk7u5WKSIiY6SkXu1Npe//nkbDdWACEPSjbD027aSsG7ScoAncH+zbpsppQcAwMm2FFXIZ6u3mMsH9GwdNkt5NsXwHlkSHxMlmwrK5Zct7u8pACJD5H3iISL86glme7UJzyYtAztlSGpCjBSWVcvKjTRUAwA4ky5v+e7STfLQJ2tM4p0UFyMjemRJJEqOj5Uh3VqZy1+udR+AABAZSLoRdgpKq2RrcaVoVXmP7PBMunWEYP/u7i8tC37dGuzdAQCgQR+u2Cxf/bxVtCirb4c0ueTQvUzyGakO3jtboqNE1mwull+20BAViBQk3Qg7v2x1B7FOmUmSGBcj4WrEXq1N4F63tVQ2eNY8BQDAKX5Ynyefr3GP6J4ytJOcO7K7tA2zFUWaqnVqgikzVx8sz2FuNxAhSLoRvqXlYTrK7dtQbXBXd5na+8s3EbgBAI7xR16pvP7Dn+byYb3byNBukVlS3pDRfduZ1VX+yCuTZX8WBHt3AAQASTfCzq+ecq292qRKuPtL33YSFxNlRrtXbmJuNwAg+Eorq+Wlb9eb9bj7dUiTsf3aBXuXHCU1IVZG7ZNtLn+4IkeqWLcbCHsk3QgreSWVkldaZcquu7UOz87lvjKS48z8MKtMTddABQAgWGprXTL7uw0mFrdOiZdThnYJu6U7/UHXKdeKte0lVfLVWnqzAOGOpBthZW2ue5S7c6vksJ7P7WvUPm1MJ3NtHmctxwIAQDAS7jmLNsjqzcWmCuvsA7pKUnxkxOKmSoiNkaP7tzeXP1uda5rAAghfJN0IKz9uyDfnfTqkSaTQgwvH79fRXJ63OlfWb6OpGgAgCCPc32+QJRsKTLXZacO6SIeMJN6G3RjYOUN6ZCdLZY1L3lu+id8VEMZIuhFWpeW/bi0xS4UN6eJuMBYpBnbOlEFdMsySLDrKUFFdE+xdAgBEkM/XbpEf/yiQmGiRs0d0k/6dMoK9S46nZffHDexovrcs/aNA1mwuCvYuAbAJSTfCxuINed6u5TrXOdKcsF8nMz9My8zfXLKRbuYAgIB1Kv9k5WZz+a+DO0m/jun85hupY2aSHNTT3ZvlzSV/SmU1vVmAcETSjbDgcrlk8Xp3afmQbpE1ym3ReXOn768Na8T8Lhb97j4IAQCAXbSyShunaaXVgE4ZMsSzlCUab0y/tt6manN/ch+8ABBeSLoRFtZvLzUjvLru5b4RfIS9R3aKd2mWt37cKBvzy4K9SwCAMFVT6zJLg20prpT0pFg5abCWStOpvDlN1U4c5O7N8sXarfJzLmXmQLgh6UZYNG95Z6m7AYnOIdPgFckO3aeN9G6XKlU1Lnl+we9SXFEd7F0CIqbiRntLAJHy9/7G4j9ljadT+d9GdJPk+Nhg71bI6tshXYZ1ayUul8jLCzfQzRwIMyTdCHnasfuPvDJJjIuWv/R1j/JGMh1lOH3/rtImNV4KyqrkxW9+Z/1uwA9yC8tl6R/58vXPW2Xx+jzvAS098Lf8zwJ5/LNf5OFP10p5FY0MEd40tjw7/zf5/vc8M6XpzOFdpUtWcrB3K+SdMKijdMxIlJLKGnnh29/5LAFspLG6rDJw8ZpDkgjpo+za7XPuT7nm+omDOkVkA7Vdze8+Z2R3mT7vZ/ltW6n8d+F686UoVtvKAmjS58yG7WXm4N5POXVLPjXZSI6LkbKqGjOfVcVGR5npLvu0i5xlCxE5/xbWbS2RZX8WyJIN+VJeVWv+3k8a3MmM0qLl4mKi5awRXWX6vF/MYMJTX/wqEw7uIakJfF0HmkIbEv6+rUSKKqqloqpWOmUmSadWSaKTX7YUV8g3v24z/Y8O2jtb/uKZlmk3/hUjJG3YXmrmLGtQsta63K8zy5P4apOWIH87oKs8N/93WbmpSF7yJN4a1AHsfp6qJhcrNxXKyo2FZlTPSrK7ZiVLemKcbCuukI0F5WZESiXFxcgBe2XJyJ6tJS2Rg38IL1rV8foPf5hYYuncKklOHdpZ2qYnBnXfwk3r1AS54JAeMuvrdeYzZsZnv8jJQzrJXm1Sg71rgOMPDOYWVZhk+rvftktpvVFs/fpbU29xAE3MAyXKpXuIFissLJSMjAwpKCiQ9HSO+NpF/1y1ychHK3LMyJI2TtOjVIf1bkMyuQvakEXndusc7w4ZiabDeTu+JCFCPz82FZTLz7nFUlRebUaoW6fES4fMRImOipKSimpZu7nYjGjrfZb4mCjTL+Kw3m3NwSxLYXmVlFbUmIQ7NTFWYqL910CKmGIvfr+Nt35bqSl11n8zOrI9qEumDOicIXu3SZVoP/7No64tRRUy8+t1kl/qPug3uGumHF7vMwiIdGWVNfLLlmJZnVMka3OLvQfJla4IoP9eYqK04XKZN67rx1af9mkysme29GyT0uLmj42NJyTdfkIAt19ReZXM/v4P84XZGt0+fr+OlF01gn4gvbxwvRRX1JgvTQfs1VoO3jubcnyEPZ1v/Wd+mZlzvXxjgVmSpzFSE2KkT/t0s97w3m1TA35Qj5jC79cJdBRo1te/SUV1rbRNS5AzhneRDhlJwd6tiJpz+uGKHPnm1+3muuYG/bThWvdWsk/bNA56IKz/9lfnFJmKMz0Apdf1+2ub9ERJT4yV6hqXKRPXyldrepfSpo66ks/wHlnSt32699+IaXRaWiXxsdFmWpg/DxiSdAcYX5Dsn7v9ztKNJmnUf1An7NdRhnZrxdIkTTxo8doPf3rnpernjSYTGsD7dEg3RwQBpyfQWjq2qaDMnJdW6shbtBlpbp0aL5nJ8WY7HbH+I6/UzMXWhFsTBot+fvRqmyrZqQmSEBdtgnlOQYX5MqvNGDtlJptlB7WMPJijeMQUfr/BtmZzkVkOTP/96GjQOSO7RfzqIMGiiYX2lVjlU96flhgrg7tkmu9ClPgjFOZYK02cG4qtev/67SXyy5YS+XVLiYnhvsn07ugBwV7tUk0vFU24nXqQnJHuAP/C0TR6lOv95Ztkc2GFua7l0Wfs34UA04IDGFp+88WaLeaDzZfOz+vdLk16tk2VLq2SaLoG2xNoLQPbVlIpFdU1ZpkcnS6i86FjY6LMdb0/t6hccgsrzPnG/PI6CXRj6eNqKdm+HTNkn/apIZE4EFP4/QZLdU2tfLxys5nKpfTg7DkHdDMjRAiuzYXlZq7qkvX53n4SVvzW8nON4TonHAgWHZHWg9kas//ML5dN+WWytbjCDJpZ0pNipY0e+I6Nlupa91KbW0sqTdz3pavw7NspQ7q3TpHk+BjzXUHzAT2wHqffFxJipWebVGmV4j7gHiwk3c00ffp0ue+++yQnJ0f2228/efTRR2X48OF++4WjcfJLK+XdZZtk+Z+F5rqOQB3SK1sO6cXcbX/RD0RtEqVHzrXbsi/9IOzeOtksAaPzv3UUPDEuxnRF11FFf85dhT0JrSanGqD0i3Ji7I5SKr2v1LNMhp50XnJhWZVJcPVU6ekyou+xBrmkuFhzru+/1QJE/68XXeaS+wYrVuqz6N9JSkKsuawBVZsw6XPoc+n8RA2w20srd2po0hj6t9kxM1HapiWakR59fA3AGtR1zqk+p77mjplJZrRa/4Y1uIfa3FNiin3xmt/vrhsILtmQJ5+uyjVlmEqbAx4zoAM9Uxx4YGT15iL54fc8U73mOyKo8VpH/rJS4s3nsH5+60kvayzQ71MJcZ7zEDgAiR3/Ps0SV574rfFdG4XpKgJ6u8Y9/X6W6HlvNYZrrxL3yb2crFZ0+V7Xc/25+Jhob+Woxnn9/qDxWmOq++T+frC1qEIKy6tN3FUpnr8tvaoj1RqH9f7mykiKk73apJhEWqtrrOq1cInXdC/38corr8h1110nM2bMkBEjRshDDz0kRx55pKxevVratm0biPdNIj2I/LatRL7/Lc8sSaL/iPUD4cCe2XJEn7bmizz8R5OWtr0TTXMo/UDVqgKdL6/zv/WI5OrNxebUEC0P0tFILeHRy3quZbsawPUIpnZ31hHLlIQYc1t8rHvk0vpeYCVsvkc1rQCh5zFRUVLjcpkgU+s5955cLpM41le3D0aU9zbdVpvIVdfWmjlA+hjR0Z4AZMrs3c+r25qTRJltqmprpcb6Oc9zN5b1+mpr3a9ZX4Ne0NemJc3uLz6aCLsDqXl881zu5zO3efZV90N/3AqM1u/AvY0m1p5TVY2Ue84ra+ruq74u/Z0qK1g6gf7t6BFq/aKg/9b1y4QGeH1turu6TI6WTeoXSD21z0iUdmmJIZdAw/+I1y1jHXzTg2E6KqWxd9kfBd7RUz2gpdO4tIEgnEeX/9TKHT3pQU0d+V65qcAcQLcOoDaGJkyanGtDST3XuOQb263YqOfKuu7+DrAj/utHsoYWjXV6cnkvu5M46/uclehpnDWPG70jDlvfCdwHdT2Xfb4rmFgd7Y6jVjwz3wf0uTzfFfSyxg/rOa24bX4m2tr/qN1+t7Au63Pqz+l3G53G5L7sPtefrapxf6fQmG2+Y9S447We63NZBzRMXNdtzXcRjdFW3HYnzHrujuG15nH1PdGfNd9fXC4TF62fsYu+Rn1t+lvVA+/6ehpjyy5u1znX2sBM+z+Yg+TpiZKVHG/eP33s7cWVZj62/q71d6XJtg7waMxvaVMzJ6O83Icm2vvvv7889thj5nptba106dJFrrzySvn73/++218koxJNo3MxN+brfEstHS2X7SWV5rpvsqBHuY4d2IGmLQGmwSqnsFx+yS0x51rOpiOJekTVzg99+J9+IdpVkq1HwjXZ1dGPzOQ4E/T0pLcpDYz671Tfd+uoun4L0HBoxUTri5P7sps+m/X3ovQLih4Nz0iOMwdj0pPipFVyvGSnxpvrJNANI6bYF68j6fer/27zSqrMZ7nOkcwpKJetxZVmFKuhtWu0geDBvdrIyL1aU04eou+3TsPRJQ21WsH6DLc+k3VEVOO4njvo+CuaWO1lKg9N9aE7jmuSrsmyGQnX97m6xsR+94ELz4EJn4Mhem4dWNjd82jyrAMoehBOvx/ogRkdfdYkXX9Un0v/rvRAiibter8m27p/kaSQke6mqayslEWLFsmNN97ovS06OlrGjBkjCxYskEDRI5b6IekdEvTR0L8N6x+Mt8yzgft29Rj1V4vb0+Jx9e/f1XPqP2Tr6J+e6z/IHWUq7qPqVulaffoPvHf7NNNdW8tDEXh6lFGPTjbUoVaPAuuHuZYR+Y4emyO+OnJSqSOVWq5cbd5zDfQaCHQb89je53A/T/3H9h5pdrnMkWxNyKxzTSB9R8N9f9wKLL58y5117k9cdLTExbp/fkfw2TEKbW7zjErrtvocesTfnEe7j+g3/nfoGRnwnFtH8vUoeIXPlx4tr7Ze147n8hxV1yPPnv3Qh9LfuZ70dv2dmO2jokxw09FzDbqJPuc6Kq4jEXokWY+U60i6/le/3BwINU6J1/qZowmsGZXzfA5ZnyP1R+qsET/v1Iz6P2N9FtWrBKr/eO5Rs7qVOFU+51YFjJZ46jQt33mUDdEDYtlaRZKeaBoIalknnw2hSz//tZGUnnbHKiHOK62UbcWVZuBDL+ttvqO33r9j79+w+2/S+jur8pxbI9nWSLJ12bes2ffvfscouJUUanWTp+LMczDXOsBrjbK7n3fH8ysrPmosdF92P6f1vcH3Z031mOcfpe93i5h63zO890XVHaX2veyOwe4KP2vU3xoR19isz6ej09Y+uuO7xmWtdtMk2R2rrQTaXI/TioGoHQe5DY3x7sRaqz39HbutvwP97qbf45S+Hk206eHgf5SXe2zdulVqamqkXbt2dX5Bev2nn37a6RdXUVFhTr5HOfxh/s9bZd7qXRVshBcd6dLEWoO9dh7W0hItIQ3n0pJQpx/2yfE6RyzYe4LG0oCvJVtApMZru2K2fn9/4OM14nRarqrd+rXZlpZ66mWd1pES79+15RE69HuWJnu7OsCOyGD9HUTayHSw8E2smaZNmya33Xabf98Nz4icBsj6fMNiQzlpQ4mq95aGtm/gRt+HaCgMN/i8Plta9+uRujjPUT09YqZH57Q0xT3PN9aUn2iyzT9yAECoxmyNeToC5R6N29EnQv+nl9y37ah2saZneHtIeA5kWo9lbVdntM87B9Z92XeOaazPuVa2WCNqWuap+5XlM08XABBcJN0e2dnZEhMTI5s3b67zC9Lr7du33+kXp2Vt2nTN96i5zidrqcN7tzUnAADQ8nhtV8zWJHjq8f14iwAAe8Siix7x8fEydOhQ+fTTT72/HG3MotdHjhy50y8uISHBNF/xPQEAAGfFa0XMBgAEEyPdPvQo+Pjx42XYsGFmrU9dMqykpEQmTJgQvHcIAADUQbwGAIQSkm4fp59+umzZskWmTp0qOTk5MmjQIPnggw92atYCAACCh3gNAAglrNPtJ5Gy5icAwH7EFH6/AIDwidfM6QYAAAAAwCYk3QAAAAAA2ISkGwAAAAAAm5B0AwAAAABgE5JuAAAAAABsQtINAAAAAIBNSLoBAAAAALBJrF0PHGlcLpd3rTYAAFrCiiVWbIF/EbMBAIGM1yTdflJUVGTOu3Tp4q+HBABEOI0tGRkZwd6NsEPMBgAEMl5HuTiM7he1tbWyceNGSUtLk6ioqBYfMdHkfcOGDZKeni6hjNfiXLw3zhRO70u4vZ5AvhYNzRrAO3bsKNHRzARzaszm79u5eG+cKZzel3B7PbwWe+M1I91+or/kzp07iz/pP95Q/wds4bU4F++NM4XT+xJurydQr4UR7tCJ2fx9OxfvjTOF0/sSbq+H12JPvObwOQAAAAAANiHpBgAAAADAJiTdDpSQkCC33HKLOQ91vBbn4r1xpnB6X8Lt9YTTa4F/hNPfRDi9lnB7PbwW5+K9caYEB/77p5EaAAAAAAA2YaQbAAAAAACbkHQDAAAAAGATkm4AAAAAAGxC0u0w06dPl+7du0tiYqKMGDFCFi5cKE43bdo02X///SUtLU3atm0rJ510kqxevbrONocddphERUXVOV1yySXiRLfeeutO+9qnTx/v/eXl5XL55ZdL69atJTU1VcaNGyebN28WJ9K/pfqvRU+6/05/X7744gs5/vjjpWPHjma/3njjjTr3u1wumTp1qnTo0EGSkpJkzJgxsnbt2jrbbN++Xc4++2yz5mRmZqZMnDhRiouLxWmvp6qqSm644QYZMGCApKSkmG3OPfdc2bhx4x7fz7vvvttRr0Wdd955O+3nUUcd5cj3Zk+vpaF/P3q67777HPe+IPCI2cFFvHZGvA63mE28dma8DvWYTdLtIK+88opcd911ptveDz/8IPvtt58ceeSRkpubK072+eefmyTum2++kY8//tgkEGPHjpWSkpI621144YWyadMm7+nee+8Vp9p3333r7OtXX33lve/aa6+Vt99+W+bMmWNeuyZGJ598sjjRd999V+d16PujTj31VMe/L/r3o/8G9EttQ3Q/H3nkEZkxY4Z8++23JlnVfy96UMSiQWLFihXmdb/zzjvmw/qiiy4Sp72e0tJS829+ypQp5vy1114zB65OOOGEnba9/fbb67xfV155pTjtvVGaZPvu53//+9869zvlvdnTa/F9DXqaOXOmCdB6sM1p7wsCi5jtDMRrZwinmE28dma8DvmY7YJjDB8+3HX55Zd7r9fU1Lg6duzomjZtmiuU5ObmuvRP6/PPP/feduihh7quvvpqVyi45ZZbXPvtt1+D9+Xn57vi4uJcc+bM8d62atUq83oXLFjgcjp9D3r27Omqra0NqfdFf7+vv/6697ruf/v27V333XdfnfcmISHB9d///tdcX7lypfm57777zrvN+++/74qKinL9+eefLie9noYsXLjQbPf77797b+vWrZvrwQcfdDlJQ69l/PjxrhNPPHGXP+PU96Yx74u+riOOOKLObU58X2A/YnbwEa+dKZxiNvHame9LKMZsRrodorKyUhYtWmTKbSzR0dHm+oIFCySUFBQUmPOsrKw6t7/44ouSnZ0t/fv3lxtvvNGM7jmVljxp6cpee+1ljvCtX7/e3K7vkY7k+75PWnretWtXx79P+jf2wgsvyPnnn2+O+oXi+2JZt26d5OTk1HkfMjIyzJQM633Qcy2DGjZsmHcb3V7/XelR9lD4d6Tvk74GX1oCpVMbBg8ebMqlqqurxYk+++wzM92kd+/ecumll8q2bdu894Xqe6PTSN59911TWldfqLwv8A9itnMQr50v3GM28dqZNjssZsfa/gxolK1bt0pNTY20a9euzu16/aeffgqZ32Jtba1cc801ctBBB5kkznLWWWdJt27dTCK7dOlSM39Vy2e1jNZpNAg8++yzJlnQkpPbbrtNDjnkEFm+fLkJGvHx8TslQvo+6X1OpvNe8vPzzXzbUHxffFm/64b+vVj36bkmfb5iY2PNwSCnv1dabqfvxZlnnmnmUFmuuuoqGTJkiHkN8+fPNwdJ9G/0gQceECfR0nKdctGjRw/55Zdf5KabbpKjjz7afKmKiYkJ2ffmueeeM70r6k8nCZX3Bf5DzHYG4rXz43W4x2zitXM957CYTdINv9K53Zqc+s6BVr5zP7RZlDbSGD16tPlC3rNnT0e9C5ocWAYOHGiCuiams2fPNs0/QtUzzzxjXpsm2KH4vkQKraQ47bTTTNOZJ554os592vPB929TDwBdfPHFpplhQkKCOMUZZ5xR5+9K91X/nnT0W/++QpXODdPKF210GYrvCxBuMZt47bz3JJIQr51tpsNiNuXlDqHlvToCVL8Ltl5v3769hIIrrrjCNFiYN2+edO7cebfbaiKrfv75Z3E6HdXeZ599zL7qe6FlhTpiHErv0++//y6ffPKJXHDBBWHxvli/6939e9Hz+k0ItXxIu3A69b2yAri+X9qwxHeUe1fvl76m3377TZxMp2noZ5z1dxWK782XX35pqkD29G8olN4XNB8x25mI184UjjGbeO3M98XJMZuk2yH0KMvQoUPl008/rVOqrddHjhwpTqYjcppwv/766zJ37lxTUronS5YsMed69NzpdFkEPZKs+6rvUVxcXJ33Sf9R65xvJ79Ps2bNMmVbxx57bFi8L/o3ph/2vu9DYWGhmfdlvQ96rgdHdB6+Rf8+9d+VdXDBiQFc5yfqARKda7Qn+n7pfLf6JXlO88cff5g53dbfVai9N1aliP77166p4fK+oPmI2c5EvHamcIvZxGtnvi+Oj9kBb92GXXr55ZdNJ8dnn33WdHG86KKLXJmZma6cnBxH/9YuvfRSV0ZGhuuzzz5zbdq0yXsqLS019//888+u22+/3fX999+71q1b53rzzTdde+21l2vUqFEuJ7r++uvNa9F9/frrr11jxoxxZWdnm67s6pJLLnF17drVNXfuXPOaRo4caU5OpV3wdX9vuOGGOrc7/X0pKipyLV682Jz0o+qBBx4wl61u3nfffbf596H7vXTpUtOhskePHq6ysjLvYxx11FGuwYMHu7799lvXV1995erVq5frzDPPdNzrqaysdJ1wwgmuzp07u5YsWVLn31FFRYX5+fnz55tum3r/L7/84nrhhRdcbdq0cZ177rmOei163//93/+Zbv76d/XJJ5+4hgwZYn735eXljntv9vR3pgoKClzJycmuJ554Yqefd9L7gsAiZgcf8doZ8TrcYjbx2pnxOtRjNkm3wzz66KMmQYqPjzfLkXzzzTcup9M/+oZOs2bNMvevX7/eJHJZWVnmoMLee+/tmjRpkvlH4USnn366q0OHDuY96NSpk7muCapFA8Rll13matWqlflH/de//tUkR0714Ycfmvdj9erVdW53+vsyb968Bv+udDkqawmSKVOmuNq1a2f2f/To0Tu9xm3btpnAkJqa6kpPT3dNmDDBfGA77fVocrqrf0f6c2rRokWuESNGmANciYmJrr59+7ruuuuuOoHRCa9FD7aNHTvWBDFdXk+X5rjwwgt3OnjolPdmT39n6t///rcrKSnJLHFTn5PeFwQeMTu4iNfOiNfhFrOJ186M16Ees6P0f/aOpQMAAAAAEJmY0w0AAAAAgE1IugEAAAAAsAlJNwAAAAAANiHpBgAAAADAJiTdAAAAAADYhKQbAAAAAACbkHQDAAAAAGATkm4AAAAAAGxC0g0AAAAAgE1IugE0yXnnnSdRUVHmFBcXJ+3atZO//OUvMnPmTKmtreW3CQCAQxCzAWcg6QbQZEcddZRs2rRJfvvtN3n//ffl8MMPl6uvvlqOO+44qa6u5jcKAIBDELOB4CPpBtBkCQkJ0r59e+nUqZMMGTJEbrrpJnnzzTdNAv7ss8+abR544AEZMGCApKSkSJcuXeSyyy6T4uJic19JSYmkp6fL//73vzqP+8Ybb5jti4qKpLKyUq644grp0KGDJCYmSrdu3WTatGm8WwAAELOBkELSDcAvjjjiCNlvv/3ktddec3+4REfLI488IitWrJDnnntO5s6dK5MnTzb3aWJ9xhlnyKxZs+o8hl4/5ZRTJC0tzfzsW2+9JbNnz5bVq1fLiy++KN27d+fdAgCAmA2ElNhg7wCA8NGnTx9ZunSpuXzNNdd4b9dk+c4775RLLrlEHn/8cXPbBRdcIAceeKApU9fR7NzcXHnvvffkk08+MfevX79eevXqJQcffLCZP64j3QAAgJgNhBpGugH4jcvlMgmy0uR59OjRpgRdR67POecc2bZtm5SWlpr7hw8fLvvuu68ZBVcvvPCCSaxHjRrlbf6yZMkS6d27t1x11VXy0Ucf8U4BAEDMBkIOSTcAv1m1apX06NHDNFjTpmoDBw6UV199VRYtWiTTp0832+hcbYuOdltzwLW0fMKECd6kXeeKr1u3Tu644w4pKyuT0047zZSeAwAAYjYQSki6AfiFztletmyZjBs3ziTZunzY/fffLwcccIDss88+snHjxp1+5m9/+5v8/vvvZv72ypUrZfz48XXu12Zrp59+ujz11FPyyiuvmAR++/btvGMAABCzgZDBnG4ATVZRUSE5OTlSU1Mjmzdvlg8++MB0FtfR7XPPPVeWL18uVVVV8uijj8rxxx8vX3/9tcyYMWOnx2nVqpWcfPLJMmnSJBk7dqx07tzZe592P9e53oMHDzZN2ebMmWM6pmdmZvKOAQBAzAZCBiPdAJpMk2xNiLVBmq7/OW/ePDNarcuGxcTEmC7mmjTfc8890r9/f9N5fFfLfU2cONGUnJ9//vl1btd54Pfee68MGzZM9t9/f1Oyro3WNAEHAADEbCBURLm08xEABMl//vMfufbaa035eXx8PO8DAAAORcwGmofycgBBoV3Mdbmwu+++Wy6++GISbgAAHIqYDbQMdZoAgkJLx3Vdb52nfeONN/IuAADgUMRsoGUoLwcAAAAAwCaMdAMAAAAAYBOSbgAAAAAAbELSDQAAAACATUi6AQAAAACwCUk3AAAAAAA2IekGAAAAAMAmJN0AAAAAANiEpBsAAAAAAJuQdAMAAAAAIPb4f+KTIt+8Xl+kAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -322,13 +322,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "id": "97e9edf4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -343,13 +343,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 10,
    "id": "44a27269",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x400 with 2 Axes>"
       ]
@@ -364,7 +364,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "id": "27d96687",
    "metadata": {},
    "outputs": [
@@ -372,8 +372,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.55\n",
-      "0.61\n"
+      "1.18\n",
+      "1.09\n"
      ]
     }
    ],
@@ -386,7 +386,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "id": "c9415928",
    "metadata": {},
    "outputs": [
@@ -394,8 +394,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "82\n",
-      "193\n"
+      "444\n",
+      "528\n"
      ]
     }
    ],
@@ -421,17 +421,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "id": "a07f8aa2",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "147"
+       "493"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -444,7 +444,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "id": "9f84f62e",
    "metadata": {},
    "outputs": [
@@ -452,9 +452,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "63\n",
-      "62\n",
-      "62\n"
+      "53\n",
+      "54\n",
+      "54\n"
      ]
     }
    ],
@@ -481,7 +481,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "id": "0e49b6d6",
    "metadata": {},
    "outputs": [
@@ -515,7 +515,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "id": "575a4a09",
    "metadata": {},
    "outputs": [
@@ -1424,7 +1424,7 @@
        "        [0.17736388]])]"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/flu_instances/examples/torch_calibration_demo.ipynb b/flu_instances/examples/torch_calibration_demo.ipynb
index 8fc71f1..6fffade 100644
--- a/flu_instances/examples/torch_calibration_demo.ipynb
+++ b/flu_instances/examples/torch_calibration_demo.ipynb
@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "id": "d06e131f-82f0-4a53-8f04-993fadaf3e1b",
    "metadata": {},
    "outputs": [],
@@ -47,7 +47,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 3,
    "id": "9373f347-e015-409d-9fcf-0004b1de5544",
    "metadata": {},
    "outputs": [],
@@ -146,7 +146,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 4,
    "id": "10a2fdf0-028f-4503-a8dd-69cdfae43d1d",
    "metadata": {},
    "outputs": [],
@@ -172,7 +172,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 5,
    "id": "ee31216c-8577-4c87-8b73-6938ea4424ba",
    "metadata": {},
    "outputs": [
@@ -211,7 +211,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 6,
    "id": "bd4fa2aa-94ba-40e8-8c36-07f86a67d423",
    "metadata": {},
    "outputs": [],
@@ -235,7 +235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 7,
    "id": "0eb76c80-e76f-4cda-b882-02ae9ddf474f",
    "metadata": {},
    "outputs": [],
@@ -264,7 +264,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 8,
    "id": "1f748385-4a9e-463b-8e3c-9667bf26daaa",
    "metadata": {},
    "outputs": [
@@ -274,17 +274,17 @@
      "text": [
       "\n",
       "Adam iterations: 0\n",
-      "Elapsed time (sec): 0.36\n",
-      "Loss function: tensor(0.8672, dtype=torch.float64, grad_fn=<MseLossBackward0>)\n",
+      "Elapsed time (sec): 0.45\n",
+      "Loss function: tensor(0.7965, dtype=torch.float64, grad_fn=<MseLossBackward0>)\n",
       "Estimated betas: tensor([1.4100, 2.0100, 2.0100], dtype=torch.float64, requires_grad=True)\n",
-      "Grad tensor([-10.2195,  -0.5579,  -1.2170], dtype=torch.float64)\n",
+      "Grad tensor([-9.1177, -0.5031, -1.1884], dtype=torch.float64)\n",
       "Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
       "\n",
       "Adam iterations: 50\n",
-      "Elapsed time (sec): 15.53\n",
-      "Loss function: tensor(0.0214, dtype=torch.float64, grad_fn=<MseLossBackward0>)\n",
-      "Estimated betas: tensor([1.5154, 2.3586, 2.2558], dtype=torch.float64, requires_grad=True)\n",
-      "Grad tensor([-0.3324, -0.0905, -0.1526], dtype=torch.float64)\n",
+      "Elapsed time (sec): 14.93\n",
+      "Loss function: tensor(0.0197, dtype=torch.float64, grad_fn=<MseLossBackward0>)\n",
+      "Estimated betas: tensor([1.5188, 2.3615, 2.2489], dtype=torch.float64, requires_grad=True)\n",
+      "Grad tensor([-0.2500, -0.0816, -0.1399], dtype=torch.float64)\n",
       "Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"
      ]
     }
@@ -324,7 +324,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 9,
    "id": "f2661721-402f-45be-b199-14ed5f982c05",
    "metadata": {},
    "outputs": [
@@ -332,23 +332,23 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[[1.5179],\n",
-      "         [1.5179],\n",
-      "         [1.5179],\n",
-      "         [1.5179],\n",
-      "         [1.5179]],\n",
+      "tensor([[[1.5199],\n",
+      "         [1.5199],\n",
+      "         [1.5199],\n",
+      "         [1.5199],\n",
+      "         [1.5199]],\n",
       "\n",
-      "        [[2.4244],\n",
-      "         [2.4244],\n",
-      "         [2.4244],\n",
-      "         [2.4244],\n",
-      "         [2.4244]],\n",
+      "        [[2.4270],\n",
+      "         [2.4270],\n",
+      "         [2.4270],\n",
+      "         [2.4270],\n",
+      "         [2.4270]],\n",
       "\n",
-      "        [[2.3122],\n",
-      "         [2.3122],\n",
-      "         [2.3122],\n",
-      "         [2.3122],\n",
-      "         [2.3122]]], dtype=torch.float64, grad_fn=<AsStridedBackward0>)\n"
+      "        [[2.3022],\n",
+      "         [2.3022],\n",
+      "         [2.3022],\n",
+      "         [2.3022],\n",
+      "         [2.3022]]], dtype=torch.float64, grad_fn=<AsStridedBackward0>)\n"
      ]
     }
    ],
@@ -359,13 +359,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 10,
    "id": "a21a1a84-ed03-44eb-9ca7-ec7b79d4ca55",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -385,6 +385,14 @@
     "plt.legend()\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d74af9b0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/flu_instances/texas_input_files/mixing_params.json b/flu_instances/texas_input_files/mixing_params.json
index d5c9284..38c81da 100644
--- a/flu_instances/texas_input_files/mixing_params.json
+++ b/flu_instances/texas_input_files/mixing_params.json
@@ -1,6 +1,6 @@
 {
 	"num_locations":  2,
 	"travel_proportions":
-		[[0.4,0.05],
-		[0.01,0.4]]
+		[[0.95,0.05],
+		[0.01,0.99]]
 }
\ No newline at end of file
diff --git a/flu_instances/texas_input_files/simulation_settings.json b/flu_instances/texas_input_files/simulation_settings.json
index 303eb08..385d0e9 100644
--- a/flu_instances/texas_input_files/simulation_settings.json
+++ b/flu_instances/texas_input_files/simulation_settings.json
@@ -1,6 +1,7 @@
 {
 	"timesteps_per_day":7,
 	"transition_type":"binom_deterministic",
+	"use_deterministic_softplus": false,
 	"start_real_date": "2022-08-08",
 	"save_daily_history": true,
 	"transition_variables_to_save": []
diff --git a/tests/conftest.py b/tests/conftest.py
index 3737b92..81fba51 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -108,13 +108,18 @@ def _make_flu_subpop_model(name: str,
 def make_flu_metapop_model():
     def _make_flu_metapop_model(transition_type: clt.TransitionTypes,
                                 subpop1_id: str = "caseB_subpop1",
-                                subpop2_id: str = "caseB_subpop2") -> flu.FluMetapopModel:
+                                subpop2_id: str = "caseB_subpop2",
+                                settings_updates: dict = {}) -> flu.FluMetapopModel:
         state1, params1, mixing_params, settings, schedules_info = subpop_inputs(subpop1_id)
         state2, params2, mixing_params, settings, schedules_info = subpop_inputs(subpop2_id)
 
         settings = clt.updated_dataclass(settings,
                                          {"transition_type": transition_type,
                                           "timesteps_per_day": 1})
+        
+        if len(settings_updates) > 0:
+            settings = clt.updated_dataclass(settings, settings_updates)
+            
 
         bit_generator = np.random.MT19937(88888)
         jumped_bit_generator = bit_generator.jumped(1)
diff --git a/tests/test_flu_metapop.py b/tests/test_flu_metapop.py
index 4d9db9c..80743ec 100644
--- a/tests/test_flu_metapop.py
+++ b/tests/test_flu_metapop.py
@@ -45,7 +45,10 @@ def test_oop_and_torch_agree(make_flu_metapop_model):
     same model and give the same result.
     """
 
-    oop_model = make_flu_metapop_model("binom_deterministic_no_round")
+    oop_model = make_flu_metapop_model(
+        "binom_deterministic_no_round",
+        settings_updates={"use_deterministic_softplus": True}
+        )
     d = oop_model.get_flu_torch_inputs()
 
     state = d["state_tensors"]
@@ -66,7 +69,10 @@ def test_oop_and_torch_agree(make_flu_metapop_model):
     for max_day in days_list:
         print('max_day:', max_day)
         for day in range(max_day):
-            oop_model = make_flu_metapop_model("binom_deterministic_no_round")
+            oop_model = make_flu_metapop_model(
+                "binom_deterministic_no_round",
+                settings_updates={"use_deterministic_softplus": True}
+                )
             oop_model.simulate_until_day(day + 1)
             L = oop_model.precomputed.L
             for subpop_ix in range(L):
@@ -114,7 +120,7 @@ def test_metapop_no_travel(make_flu_subpop_model, transition_type, inputs_id):
     subpopB = make_flu_subpop_model("B", transition_type, num_jumps = 1, timesteps_per_day = 1, case_id_str = inputs_id)
 
     metapopAB_model = flu.FluMetapopModel([subpopA, subpopB],
-                                          flu.FluMixingParams(travel_proportions=np.zeros((2, 2)),
+                                          flu.FluMixingParams(travel_proportions=np.eye(2),
                                                               num_locations=2))
 
     metapopAB_model.simulate_until_day(1)
diff --git a/tests/test_flu_travel.py b/tests/test_flu_travel.py
index 3b34c50..497d833 100644
--- a/tests/test_flu_travel.py
+++ b/tests/test_flu_travel.py
@@ -41,7 +41,7 @@ def test_metapop_no_travel(make_flu_subpop_model, transition_type, inputs_id):
     subpopB = make_flu_subpop_model("B", transition_type, num_jumps = 1, timesteps_per_day = 1, case_id_str = inputs_id)
 
     metapopAB_model = flu.FluMetapopModel([subpopA, subpopB],
-                                          flu.FluMixingParams(travel_proportions=np.zeros((2, 2)),
+                                          flu.FluMixingParams(travel_proportions=np.eye(2),
                                                               num_locations=2))
 
     metapopAB_model.simulate_until_day(1)
@@ -63,7 +63,7 @@ def test_size_travel_computations(make_flu_subpop_model):
 
     metapopAB_model = flu.FluMetapopModel([subpopA, subpopB],
                                           flu.FluMixingParams(num_locations=2,
-                                                              travel_proportions=np.zeros((2,2))))
+                                                              travel_proportions=np.eye(2)))
 
     for i in [1, 10, 100]:
 
diff --git a/tests/test_input_files/caseA_mixing_params.json b/tests/test_input_files/caseA_mixing_params.json
index 43b3118..ee3b55e 100644
--- a/tests/test_input_files/caseA_mixing_params.json
+++ b/tests/test_input_files/caseA_mixing_params.json
@@ -1,6 +1,6 @@
 {
 	"num_locations":  2,
 	"travel_proportions":
-		[[0.5,0.02],
-		[0.01,0.9]]
+		[[0.9,0.1],
+		[0.01,0.99]]
 }
\ No newline at end of file
diff --git a/tests/test_input_files/caseB_mixing_params.json b/tests/test_input_files/caseB_mixing_params.json
index 49af455..a606c93 100644
--- a/tests/test_input_files/caseB_mixing_params.json
+++ b/tests/test_input_files/caseB_mixing_params.json
@@ -1,6 +1,6 @@
 {
 	"num_locations":  2,
 	"travel_proportions":
-		[[0.8,0.5],
-		[0.01,0.1]]
+		[[0.8,0.2],
+		[0.01,0.99]]
 }
\ No newline at end of file
diff --git a/tests/test_input_files/simulation_settings.json b/tests/test_input_files/simulation_settings.json
index 303eb08..385d0e9 100644
--- a/tests/test_input_files/simulation_settings.json
+++ b/tests/test_input_files/simulation_settings.json
@@ -1,6 +1,7 @@
 {
 	"timesteps_per_day":7,
 	"transition_type":"binom_deterministic",
+	"use_deterministic_softplus": false,
 	"start_real_date": "2022-08-08",
 	"save_daily_history": true,
 	"transition_variables_to_save": []