diff --git a/.gitignore b/.gitignore
index ea2ab6b59..5644f7eed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -118,6 +118,9 @@ venv.bak/
 .vscode/
 .devcontainer
 
+# pycharm project settings
+.idea/
+
 # Rope project settings
 .ropeproject
 
diff --git a/bofire/data_models/strategies/actual_strategy_type.py b/bofire/data_models/strategies/actual_strategy_type.py
index 88099d537..c0cbc97b2 100644
--- a/bofire/data_models/strategies/actual_strategy_type.py
+++ b/bofire/data_models/strategies/actual_strategy_type.py
@@ -19,6 +19,7 @@
 from bofire.data_models.strategies.predictives.sobo import (
     AdditiveSoboStrategy,
     CustomSoboStrategy,
+    MultiplicativeAdditiveSoboStrategy,
     MultiplicativeSoboStrategy,
     SoboStrategy,
 )
@@ -32,6 +33,7 @@
     AdditiveSoboStrategy,
     ActiveLearningStrategy,
     MultiplicativeSoboStrategy,
+    MultiplicativeAdditiveSoboStrategy,
     CustomSoboStrategy,
     MultiFidelityStrategy,
     QehviStrategy,
diff --git a/bofire/data_models/strategies/api.py b/bofire/data_models/strategies/api.py
index c93ec0fe9..26de1beb3 100644
--- a/bofire/data_models/strategies/api.py
+++ b/bofire/data_models/strategies/api.py
@@ -26,6 +26,7 @@
 from bofire.data_models.strategies.predictives.sobo import (
     AdditiveSoboStrategy,
     CustomSoboStrategy,
+    MultiplicativeAdditiveSoboStrategy,
     MultiplicativeSoboStrategy,
     SoboStrategy,
 )
@@ -61,6 +62,7 @@
     ActiveLearningStrategy,
     AdditiveSoboStrategy,
     MultiplicativeSoboStrategy,
+    MultiplicativeAdditiveSoboStrategy,
     CustomSoboStrategy,
     QehviStrategy,
     QnehviStrategy,
diff --git a/bofire/data_models/strategies/predictives/sobo.py b/bofire/data_models/strategies/predictives/sobo.py
index b2a83ea43..6410ab694 100644
--- a/bofire/data_models/strategies/predictives/sobo.py
+++ b/bofire/data_models/strategies/predictives/sobo.py
@@ -1,6 +1,7 @@
-from typing import Literal, Optional, Type
+from typing import List, Literal, Optional, Type
 
-from pydantic import Field, field_validator
+import pydantic
+from pydantic import Field, field_validator, model_validator
 
 from bofire.data_models.acquisition_functions.api import (
     AnySingleObjectiveAcquisitionFunction,
@@ -74,7 +75,25 @@ def validate_is_multiobjective(cls, v, info):
         return v
 
 
-class MultiplicativeSoboStrategy(SoboBaseStrategy):
+class _CheckAdaptableWeightsMixin:
+    """
+    Contains an additional validator for weights in multiplicative objective merging.
+
+    Additional validation of weights for adaptable weights, in multiplicative calculations. Adaption to (1, inf)
+    requires w>=1e-8
+    """
+
+    @model_validator(mode="after")
+    def check_adaptable_weights(cls, self):
+        for obj in self.domain.outputs.get_by_objective():
+            if obj.objective.w < 1e-8:
+                raise pydantic.ValidationError(
+                    f"Weight transformation to (1, inf) requires w>=1e-8 . Violated by feature {obj.key}."
+                )
+        return self
+
+
+class MultiplicativeSoboStrategy(SoboBaseStrategy, _CheckAdaptableWeightsMixin):
     type: Literal["MultiplicativeSoboStrategy"] = "MultiplicativeSoboStrategy"
 
     @field_validator("domain")
@@ -86,6 +105,36 @@ def validate_is_multiobjective(cls, v, info):
         return v
 
 
+class MultiplicativeAdditiveSoboStrategy(SoboBaseStrategy, _CheckAdaptableWeightsMixin):
+    """
+    Mixed, weighted multiplicative (primary, strict) and additive (secondary, non-strict) objectives.
+
+    The formular for a mixed objective with two multiplicative features (f1, and f2 with weights w1 and w2) and two
+    additive features (f3 and f4 with weights w3 and w4) is:
+
+        additive_objective = 1 + f3*w3 + f4*w4
+
+        objective = f1^w1 * f2^w2 * additive_objective
+
+    """
+
+    type: Literal["MultiplicativeAdditiveSoboStrategy"] = (
+        "MultiplicativeAdditiveSoboStrategy"
+    )
+    use_output_constraints: bool = True
+    additive_features: List[str] = Field(default_factory=list)
+
+    @field_validator("additive_features")
+    def validate_additive_features(cls, v, values):
+        domain = values.data["domain"]
+        for feature in v:
+            if feature not in domain.outputs.get_keys():
+                raise ValueError(
+                    f"Feature {feature} is not an output feature of the domain."
+                )
+        return v
+
+
 class CustomSoboStrategy(SoboBaseStrategy):
     type: Literal["CustomSoboStrategy"] = "CustomSoboStrategy"
     use_output_constraints: bool = True
diff --git a/bofire/strategies/mapper_actual.py b/bofire/strategies/mapper_actual.py
index beea1cadd..90244d9d4 100644
--- a/bofire/strategies/mapper_actual.py
+++ b/bofire/strategies/mapper_actual.py
@@ -14,6 +14,7 @@
 from bofire.strategies.predictives.sobo import (
     AdditiveSoboStrategy,
     CustomSoboStrategy,
+    MultiplicativeAdditiveSoboStrategy,
     MultiplicativeSoboStrategy,
     SoboStrategy,
 )
@@ -29,6 +30,7 @@
     data_models.SoboStrategy: SoboStrategy,
     data_models.AdditiveSoboStrategy: AdditiveSoboStrategy,
     data_models.MultiplicativeSoboStrategy: MultiplicativeSoboStrategy,
+    data_models.MultiplicativeAdditiveSoboStrategy: MultiplicativeAdditiveSoboStrategy,
     data_models.CustomSoboStrategy: CustomSoboStrategy,
     data_models.MultiFidelityStrategy: MultiFidelityStrategy,
     data_models.QehviStrategy: QehviStrategy,
diff --git a/bofire/strategies/predictives/sobo.py b/bofire/strategies/predictives/sobo.py
index 6b4a27670..49a92fd6d 100644
--- a/bofire/strategies/predictives/sobo.py
+++ b/bofire/strategies/predictives/sobo.py
@@ -20,6 +20,9 @@
 from bofire.data_models.objectives.api import ConstrainedObjective, Objective
 from bofire.data_models.strategies.api import AdditiveSoboStrategy as AdditiveDataModel
 from bofire.data_models.strategies.api import CustomSoboStrategy as CustomDataModel
+from bofire.data_models.strategies.api import (
+    MultiplicativeAdditiveSoboStrategy as MultiplicativeAdditiveDataModel,
+)
 from bofire.data_models.strategies.api import (
     MultiplicativeSoboStrategy as MultiplicativeDataModel,
 )
@@ -28,6 +31,7 @@
 from bofire.utils.torch_tools import (
     get_additive_botorch_objective,
     get_custom_botorch_objective,
+    get_multiplicative_additive_objective,
     get_multiplicative_botorch_objective,
     get_objective_callable,
     get_output_constraints,
@@ -240,6 +244,7 @@ def _get_objective_and_constraints(
                 objective=get_multiplicative_botorch_objective(  # type: ignore
                     outputs=self.domain.outputs,
                     experiments=self.experiments,
+                    adapt_weights_to_1_inf=True,
                 ),
             ),
             None,
@@ -247,6 +252,38 @@ def _get_objective_and_constraints(
         )
 
 
+class MultiplicativeAdditiveSoboStrategy(SoboStrategy):
+    def __init__(
+        self,
+        data_model: MultiplicativeAdditiveDataModel,
+        **kwargs,
+    ):
+        self.additive_features = data_model.additive_features
+        super().__init__(data_model=data_model, **kwargs)
+
+    def _get_objective_and_constraints(
+        self,
+    ) -> Tuple[
+        GenericMCObjective,
+        Union[List[Callable[[torch.Tensor], torch.Tensor]], None],
+        Union[List, float],
+    ]:
+        # we absorb all constraints into the objective
+        assert self.experiments is not None, "No experiments available."
+        return (
+            GenericMCObjective(
+                objective=get_multiplicative_additive_objective(  # type: ignore
+                    outputs=self.domain.outputs,
+                    experiments=self.experiments,
+                    additive_features=self.additive_features,
+                    adapt_weights_to_1_inf=True,
+                )
+            ),
+            None,
+            1e-3,
+        )
+
+
 class CustomSoboStrategy(SoboStrategy):
     def __init__(
         self,
diff --git a/bofire/utils/torch_tools.py b/bofire/utils/torch_tools.py
index 557e6c2f0..101cd6aa4 100644
--- a/bofire/utils/torch_tools.py
+++ b/bofire/utils/torch_tools.py
@@ -26,6 +26,7 @@
     MinimizeObjective,
     MinimizeSigmoidObjective,
     MovingMaximizeSigmoidObjective,
+    Objective,
     TargetObjective,
 )
 from bofire.strategies.strategy import Strategy
@@ -484,33 +485,81 @@ def objective(samples: torch.Tensor, X: torch.Tensor) -> torch.Tensor:
     return objective
 
 
-def get_multiplicative_botorch_objective(
+def _callables_and_weights(
     outputs: Outputs,
     experiments: pd.DataFrame,
-) -> Callable[[Tensor, Tensor], Tensor]:
-    callables = [
-        get_objective_callable(
-            idx=i,
-            objective=feat.objective,
-            x_adapt=torch.from_numpy(
-                outputs.preprocess_experiments_one_valid_output(feat.key, experiments)[
-                    feat.key
-                ].values,
-            ).to(**tkwargs),
+    exclude_constraints: bool = False,
+    allowed_objectives: Optional[List[Type[Objective]]] = None,
+    adapt_weights_to_1_inf: bool = False,
+) -> Tuple[List[Callable], List[float], List[str]]:
+    """
+    Extract callables and weights from outputs object
+
+    Args:
+        outputs (Outputs): Outputs object
+        experiments (pd.DataFrame): DataFrame containing the experiments that are used for adapting the objectives
+        exclude_constraints (bool): exclude constraints
+        allowed_objectives (Optional[List[Type[Objective]]]): limit to allowed objectives
+        adapt_weights_to_1_inf (bool): transform weights from [0,1] to [1,inf) space
+
+    Returns:
+        callables (List[Callable]): list of callables
+        weights (List[float]): List of weights for callables
+        keys (List[str]): Output keys, for the corresponding callables and weights
+
+    """
+
+    def _x_adapt(feat):
+        """adapted output x, skipped for inputs"""
+        x = outputs.preprocess_experiments_one_valid_output(feat.key, experiments)[
+            feat.key
+        ].values
+        return torch.from_numpy(x).to(**tkwargs)
+
+    callables, weights, keys = [], [], []
+
+    for i, feat in enumerate(outputs.get()):
+        if feat.objective is None:
+            continue
+
+        if exclude_constraints:
+            if isinstance(feat.objective, ConstrainedObjective):
+                continue
+
+        if allowed_objectives is not None:
+            if not any(isinstance(feat.objective, obj) for obj in allowed_objectives):
+                continue
+
+        callables.append(
+            get_objective_callable(
+                idx=i,
+                objective=feat.objective,
+                x_adapt=_x_adapt(feat),
+            )
         )
-        for i, feat in enumerate(outputs.get())
-        if feat.objective is not None
-    ]
-    weights = [
-        feat.objective.w
-        for i, feat in enumerate(outputs.get())
-        if feat.objective is not None
-    ]
+
+        weights.append(feat.objective.w)
+
+        keys.append(feat.key)
+
+    if adapt_weights_to_1_inf:
+        min_w = min(weights)
+        weights = [w / min_w for w in weights]
+
+    return callables, weights, keys
+
+
+def get_multiplicative_botorch_objective(
+    outputs: Outputs, experiments: pd.DataFrame, adapt_weights_to_1_inf: bool = True
+) -> Callable[[Tensor, Tensor], Tensor]:
+    callables, weights, _ = _callables_and_weights(
+        outputs, experiments, adapt_weights_to_1_inf=adapt_weights_to_1_inf
+    )
 
     def objective(samples: torch.Tensor, X: torch.Tensor) -> torch.Tensor:
-        val = 1.0
+        val = torch.tensor(1.0).to(**tkwargs)
         for c, w in zip(callables, weights):
-            val *= c(samples, None) ** w
+            val = val * c(samples, None) ** w
         return val  # type: ignore
 
     return objective
@@ -521,39 +570,17 @@ def get_additive_botorch_objective(
     experiments: pd.DataFrame,
     exclude_constraints: bool = True,
 ) -> Callable[[Tensor, Tensor], Tensor]:
-    callables = [
-        get_objective_callable(
-            idx=i,
-            objective=feat.objective,
-            x_adapt=torch.from_numpy(
-                outputs.preprocess_experiments_one_valid_output(feat.key, experiments)[
-                    feat.key
-                ].values,
-            ).to(**tkwargs),
-        )
-        for i, feat in enumerate(outputs.get())
-        if feat.objective is not None
-        and (
-            not isinstance(feat.objective, ConstrainedObjective)
-            if exclude_constraints
-            else True
-        )
-    ]
-    weights = [
-        feat.objective.w
-        for i, feat in enumerate(outputs.get())
-        if feat.objective is not None
-        and (
-            not isinstance(feat.objective, ConstrainedObjective)
-            if exclude_constraints
-            else True
-        )
-    ]
+    callables, weights, _ = _callables_and_weights(
+        outputs,
+        experiments,
+        exclude_constraints=exclude_constraints,
+        adapt_weights_to_1_inf=False,
+    )
 
     def objective(samples: Tensor, X: Tensor) -> Tensor:
-        val = 0.0
+        val = torch.tensor(0.0).to(**tkwargs)
         for c, w in zip(callables, weights):
-            val += c(samples, None) * w
+            val = val + c(samples, None) * w
         return val  # type: ignore
 
     return objective
@@ -575,26 +602,96 @@ def get_multiobjective_objective(
         Callable[[Tensor], Tensor]: _description_
 
     """
-    callables = [
-        get_objective_callable(
-            idx=i,
-            objective=feat.objective,
-            x_adapt=torch.from_numpy(
-                outputs.preprocess_experiments_one_valid_output(feat.key, experiments)[
-                    feat.key
-                ].values,
-            ).to(**tkwargs),
-        )
-        for i, feat in enumerate(outputs.get())
-        if feat.objective is not None
-        and isinstance(
-            feat.objective,
-            (MaximizeObjective, MinimizeObjective, CloseToTargetObjective),
+    allowed_objectives = [MaximizeObjective, MinimizeObjective, CloseToTargetObjective]
+
+    callables_outputs, _, _ = _callables_and_weights(
+        outputs,
+        experiments,
+        allowed_objectives=allowed_objectives,
+        adapt_weights_to_1_inf=False,
+    )
+
+    def objective(samples: Tensor, X: Optional[Tensor] = None) -> Tensor:
+        return torch.stack([c(samples, None) for c in callables_outputs], dim=-1)
+
+    return objective
+
+
+def get_multiplicative_additive_objective(
+    outputs: Outputs,
+    experiments: pd.DataFrame,
+    exclude_constraints: bool = True,
+    additive_features: Optional[List[str]] = None,
+    adapt_weights_to_1_inf: bool = True,
+) -> Callable[[Tensor, Tensor], Tensor]:
+    """Computes the objective as a mix of multiplicative and additive objectives. By default, all objectives are multiplicative.
+    Additive features (inputs or outputs) can be specified in the `additive_features` list.
+
+    The formular for a mixed objective with two multiplicative features (f1, and f2 with weights w1 and w2) and two
+    additive features (f3 and f4 with weights w3 and w4) is:
+
+        additive_objective = 1 + f3*w3 + f4*w4
+
+        objective = f1^w1 * f2^w2 * additive_objective
+
+
+    Args:
+        outputs
+        experiments
+        exclude_constraints
+        additive_features (List[str]): list of features that should be treated as additive
+        adapt_weights_to_1_inf (bool): will transform weights from [0,1] to [1,inf) space
+
+    Returns:
+        objective (callable): callable that can be used by botorch for optimization
+
+    """
+
+    callables, weights, keys = _callables_and_weights(
+        outputs,
+        experiments,
+        exclude_constraints=exclude_constraints,
+        adapt_weights_to_1_inf=adapt_weights_to_1_inf,
+    )
+
+    if additive_features is None:
+        additive_features = []
+
+    def _differ_additive_and_multiplicative_features(callables, weights, feature_names):
+        callables_additive, weights_additive = [], []
+        callables_multiplicative, weights_multiplicative = [], []
+        for c, w, key in zip(callables, weights, feature_names):
+            if key in additive_features:
+                callables_additive.append(c)
+                weights_additive.append(w)
+            else:
+                callables_multiplicative.append(c)
+                weights_multiplicative.append(w)
+        return (
+            callables_additive,
+            weights_additive,
+            callables_multiplicative,
+            weights_multiplicative,
         )
-    ]
+
+    (
+        callables_additive,
+        weights_additive,
+        callables_multiplicative,
+        weights_multiplicative,
+    ) = _differ_additive_and_multiplicative_features(callables, weights, keys)
 
     def objective(samples: Tensor, X: Optional[Tensor] = None) -> Tensor:
-        return torch.stack([c(samples, None) for c in callables], dim=-1)
+        additive_objective = torch.tensor(1.0).to(**tkwargs)
+        for c, w in zip(callables_additive, weights_additive):
+            additive_objective = additive_objective + c(samples, None) * w
+
+        multiplicative_objective = torch.tensor(1.0).to(**tkwargs)
+        for c, w in zip(callables_multiplicative, weights_multiplicative):
+            multiplicative_objective = multiplicative_objective * c(samples, None) ** w
+
+        y: Tensor = multiplicative_objective * additive_objective
+        return y
 
     return objective
 
diff --git a/tests/bofire/data_models/specs/strategies.py b/tests/bofire/data_models/specs/strategies.py
index c9879602c..54153eea3 100644
--- a/tests/bofire/data_models/specs/strategies.py
+++ b/tests/bofire/data_models/specs/strategies.py
@@ -108,6 +108,16 @@
         "acquisition_function": qPI(tau=0.1).model_dump(),
     },
 )
+specs.add_valid(
+    strategies.MultiplicativeAdditiveSoboStrategy,
+    lambda: {
+        "domain": domain.valid().obj().model_dump(),
+        **strategy_commons,
+        "acquisition_function": qPI(tau=0.1).model_dump(),
+        "use_output_constraints": False,
+        "additive_features": ["o1"],
+    },
+)
 specs.add_valid(
     strategies.CustomSoboStrategy,
     lambda: {
diff --git a/tests/bofire/strategies/test_ask.py b/tests/bofire/strategies/test_ask.py
index ca7b6f34b..e6cf5e54d 100644
--- a/tests/bofire/strategies/test_ask.py
+++ b/tests/bofire/strategies/test_ask.py
@@ -14,12 +14,37 @@
 
 
 STRATEGY_SPECS_SINGLE_OBJECTIVE = {
-    # BoTorchSoboAdditiveStrategy: VALID_BOTORCH_SOBO_STRATEGY_SPEC,
-    data_models.MultiplicativeSoboStrategy: VALID_BOTORCH_SOBO_STRATEGY_SPEC,
+    data_models.SoboStrategy: VALID_BOTORCH_SOBO_STRATEGY_SPEC,
 }
+
+
 STRATEGY_SPECS_MULTI_OBJECTIVE = {
     data_models.QehviStrategy: VALID_BOTORCH_QEHVI_STRATEGY_SPEC,
     data_models.QnehviStrategy: VALID_BOTORCH_QEHVI_STRATEGY_SPEC,
+    data_models.AdditiveSoboStrategy: VALID_BOTORCH_QEHVI_STRATEGY_SPEC,
+    data_models.MultiplicativeSoboStrategy: VALID_BOTORCH_QEHVI_STRATEGY_SPEC,
+    data_models.MultiplicativeAdditiveSoboStrategy: VALID_BOTORCH_QEHVI_STRATEGY_SPEC,
+}
+mo_strategy_has_ref_point = {
+    data_models.QehviStrategy: True,
+    data_models.QnehviStrategy: True,
+    data_models.AdditiveSoboStrategy: False,
+    data_models.MultiplicativeSoboStrategy: False,
+    data_models.MultiplicativeAdditiveSoboStrategy: False,
+}
+mo_strategy_has_additive_objective = {
+    data_models.QehviStrategy: False,
+    data_models.QnehviStrategy: False,
+    data_models.AdditiveSoboStrategy: False,
+    data_models.MultiplicativeSoboStrategy: False,
+    data_models.MultiplicativeAdditiveSoboStrategy: True,
+}
+mo_strategy_support_weights = {
+    data_models.QehviStrategy: False,
+    data_models.QnehviStrategy: False,
+    data_models.AdditiveSoboStrategy: True,
+    data_models.MultiplicativeSoboStrategy: True,
+    data_models.MultiplicativeAdditiveSoboStrategy: True,
 }
 
 
@@ -33,7 +58,7 @@
         for descriptor in [True, False]
     ],
 )
-@pytest.mark.slow
+# @pytest.mark.slow
 def test_ask_single_objective(cls, spec, categorical, descriptor, candidate_count):
     # generate data
     benchmark = Ackley(categorical=categorical, descriptor=descriptor)
@@ -58,17 +83,28 @@ def test_ask_single_objective(cls, spec, categorical, descriptor, candidate_coun
 
 
 @pytest.mark.parametrize(
-    "cls, spec, use_ref_point, candidate_count",
+    "cls, spec, use_ref_point, add_additive_features, vary_weights, candidate_count",
     [
-        (cls, specs, use_ref_point, random.randint(1, 2))
+        (
+            cls,
+            specs,
+            use_ref_point,
+            add_additive_features,
+            vary_weights,
+            random.randint(1, 2),
+        )
         for cls, specs in STRATEGY_SPECS_MULTI_OBJECTIVE.items()
         for use_ref_point in [True, False]
+        for add_additive_features in [True, False]
+        for vary_weights in [True, False]
         # for categorical in [True, False]
         # for descriptor in [True, False]
     ],
 )
-@pytest.mark.slow  # use pytest . --runslow in command line to include these tests
-def test_ask_multi_objective(cls, spec, use_ref_point, candidate_count):
+# @pytest.mark.slow  # use pytest . --runslow in command line to include these tests
+def test_ask_multi_objective(
+    cls, spec, use_ref_point, add_additive_features, vary_weights, candidate_count
+):
     # generate data
     benchmark = DTLZ2(
         dim=6,
@@ -78,12 +114,29 @@ def test_ask_multi_objective(cls, spec, use_ref_point, candidate_count):
     )
     experiments = benchmark.f(random_strategy.ask(10), return_complete=True)
 
+    if vary_weights:
+        if not mo_strategy_support_weights[cls]:
+            print(f"Skip test: Weights not supported by {cls}.")
+            return
+        obj = benchmark.domain.outputs.get_by_objective()
+        obj[-1].objective.w = 0.5
+
+    kwargs = {**spec, "domain": benchmark.domain}
+    # skip tests, if kw-args (ref_point, additive_features) are not supported by the strategy
+    if use_ref_point:
+        if not mo_strategy_has_ref_point[cls]:
+            print(f"Skip test: Ref point not supported by {cls}.")
+            return
+        kwargs["ref_point"] = benchmark.ref_point
+    if add_additive_features:
+        if not mo_strategy_has_additive_objective[cls]:
+            print(f"Skip test: Additive features not supported by {cls}.")
+            return
+        kwargs["additive_features"] = [benchmark.domain.outputs.get_keys()[0]]
+
     # set up of the strategy
-    data_model = cls(
-        **{**spec, "domain": benchmark.domain},
-        # domain=benchmark.domain,
-        ref_point=benchmark.ref_point if use_ref_point else None,
-    )
+    data_model = cls(**kwargs)
+
     strategy = strategies.map(data_model=data_model)
     strategy.tell(experiments)
 
diff --git a/tests/bofire/utils/test_torch_tools.py b/tests/bofire/utils/test_torch_tools.py
index 0b6ac00f9..dbdd1688a 100644
--- a/tests/bofire/utils/test_torch_tools.py
+++ b/tests/bofire/utils/test_torch_tools.py
@@ -36,6 +36,7 @@
 from bofire.data_models.strategies.api import RandomStrategy
 from bofire.utils.torch_tools import (
     InterpolateTransform,
+    _callables_and_weights,
     constrained_objective2botorch,
     get_additive_botorch_objective,
     get_custom_botorch_objective,
@@ -43,6 +44,7 @@
     get_interpoint_constraints,
     get_linear_constraints,
     get_multiobjective_objective,
+    get_multiplicative_additive_objective,
     get_multiplicative_botorch_objective,
     get_nchoosek_constraints,
     get_nonlinear_constraints,
@@ -275,9 +277,12 @@ def test_get_multiplicative_botorch_objective():
     reward1 = obj1(a_samples[:, 0])
     reward2 = obj2(a_samples[:, 1])
     # do the comparison
+    w1, w2 = obj1.w, obj2.w
+    w1, w2 = [w / min(w1, w2) for w in [w1, w2]]
+
     assert np.allclose(
         # objective.reward(samples, desFunc)[0].detach().numpy(),
-        reward1**obj1.w * reward2**obj2.w,
+        reward1**w1 * reward2**w2,
         objective_forward.detach().numpy(),
         rtol=1e-06,
     )
@@ -818,7 +823,8 @@ def test_get_nonlinear_constraints():
     assert len(get_nonlinear_constraints(domain=domain)) == 2
 
 
-def test_get_multiobjective_objective():
+@pytest.fixture
+def mutiobjective_data():
     samples = (torch.rand(30, 4, requires_grad=True) * 5).to(**tkwargs)
     samples2 = (torch.rand(30, 512, 4, requires_grad=True) * 5).to(**tkwargs)
     a_samples = samples.detach().numpy()
@@ -858,6 +864,53 @@ def test_get_multiobjective_objective():
             "valid_omega": [1] * 10,
         },
     )
+
+    return samples, samples2, a_samples, obj1, obj2, obj3, obj4, experiments, outputs
+
+
+@pytest.fixture(
+    params=["default", "exclude_constraints", "allowed_objectives", "adapt_weights"]
+)
+def _callables_and_weights_kwargs_testcase(request):
+    return request.param
+
+
+def test_callables_and_weights(
+    mutiobjective_data, _callables_and_weights_kwargs_testcase: str
+):
+    kwargs = {}
+    if _callables_and_weights_kwargs_testcase == "exclude_constraints":
+        kwargs["exclude_constraints"] = True
+    elif _callables_and_weights_kwargs_testcase == "allowed_objectives":
+        kwargs["allowed_objectives"] = [MaximizeObjective]
+    elif _callables_and_weights_kwargs_testcase == "adapt_weights":
+        kwargs["adapt_weights_to_1_inf"] = True
+
+    samples, samples2, a_samples, obj1, obj2, obj3, obj4, experiments, outputs = (
+        mutiobjective_data
+    )
+
+    callables, weights, keys = _callables_and_weights(outputs, experiments, **kwargs)
+
+    testkeys = outputs.get_keys()
+    if _callables_and_weights_kwargs_testcase == "exclude_constraints":
+        testkeys = ["alpha", "gamma", "omega"]
+    elif _callables_and_weights_kwargs_testcase == "allowed_objectives":
+        testkeys = ["alpha"]
+
+    weights_data_model = [outputs.get_by_key(k).objective.w for k in testkeys]
+    if _callables_and_weights_kwargs_testcase == "adapt_weights":
+        weights_data_model = [w / min(weights_data_model) for w in weights_data_model]
+
+    assert testkeys == keys
+    assert weights == weights_data_model
+
+
+def test_get_multiobjective_objective(mutiobjective_data):
+    samples, samples2, a_samples, obj1, obj2, obj3, obj4, experiments, outputs = (
+        mutiobjective_data
+    )
+
     objective = get_multiobjective_objective(outputs=outputs, experiments=experiments)
     generic_objective = GenericMCObjective(objective=objective)
     # check the shape
@@ -875,6 +928,71 @@ def test_get_multiobjective_objective():
     assert np.allclose(objective_forward[..., 2].detach().numpy(), reward4)
 
 
+def test_get_additive_objective(mutiobjective_data):
+    samples, samples2, a_samples, obj1, obj2, obj3, obj4, experiments, outputs = (
+        mutiobjective_data
+    )
+
+    objective = get_additive_botorch_objective(
+        outputs=outputs, experiments=experiments, exclude_constraints=False
+    )
+    generic_objective = GenericMCObjective(objective=objective)
+    # check the shape
+    objective_forward = generic_objective.forward(samples2, None)
+    assert objective_forward.shape == torch.Size((30, 512))
+    objective_forward = generic_objective.forward(samples, None)
+    assert objective_forward.shape == torch.Size((30,))
+    # check what is in
+    # calc with numpy
+    reward1 = obj1(a_samples[:, 0]) * obj1.w
+    reward2 = obj2(a_samples[:, 1]) * obj2.w
+    reward3 = obj3(a_samples[:, 2]) * obj3.w
+    reward4 = obj4(a_samples[:, 3]) * obj4.w
+    assert np.allclose(
+        reward1 + reward2 + reward3 + reward4, objective_forward.detach().numpy()
+    )
+
+
+def test_get_multiplicative_additive_objective(mutiobjective_data):
+    samples, samples2, a_samples, obj1, obj2, obj3, obj4, experiments, outputs = (
+        mutiobjective_data
+    )
+
+    objective = get_multiplicative_additive_objective(
+        outputs=outputs,
+        experiments=experiments,
+        exclude_constraints=False,
+        additive_features=["gamma", "alpha"],
+    )
+    generic_objective = GenericMCObjective(objective=objective)
+    # check the shape
+    objective_forward = generic_objective.forward(samples2, None)
+    assert objective_forward.shape == torch.Size((30, 512))
+    objective_forward = generic_objective.forward(samples, None)
+    assert objective_forward.shape == torch.Size((30,))
+    # check what is in
+    # calc with numpy
+    reward_alpha = obj1(a_samples[:, 0])
+    reward_beta = obj2(a_samples[:, 1])
+    reward_gamma = obj3(a_samples[:, 2])
+    reward_omega = obj4(a_samples[:, 3])
+    w_alpha, w_beta, w_gamma, w_omega = obj1.w, obj2.w, obj3.w, obj4.w
+    w_alpha, w_beta, w_gamma, w_omega = [
+        w / min([w_alpha, w_beta, w_gamma, w_omega])
+        for w in [w_alpha, w_beta, w_gamma, w_omega]
+    ]
+
+    additive_objective = 1.0 + reward_gamma * w_gamma + reward_alpha * w_alpha
+
+    multiplicative_objective = (
+        (reward_beta**w_beta) * (reward_omega**w_omega) * additive_objective
+    )
+
+    objective_forward = objective_forward.detach().numpy()
+
+    assert np.allclose(multiplicative_objective, objective_forward)
+
+
 @pytest.mark.parametrize("sequential", [True, False])
 def test_get_initial_conditions_generator(sequential: bool):
     inputs = Inputs(
@@ -886,7 +1004,7 @@ def test_get_initial_conditions_generator(sequential: bool):
                 descriptors=["omega"],
                 values=[[0], [1], [3]],
             ),
-        ],
+        ]
     )
     domain = Domain(inputs=inputs)
     strategy = strategies.map(RandomStrategy(domain=domain))
@@ -922,9 +1040,7 @@ def test_get_initial_conditions_generator(sequential: bool):
 def test_constrained_objective2botorch(objective):
     x_adapt = torch.tensor([1.0, 2.0, 3.0]).to(**tkwargs)
     cs, etas, _ = constrained_objective2botorch(
-        idx=0,
-        objective=objective,
-        x_adapt=x_adapt,
+        idx=0, objective=objective, x_adapt=x_adapt
     )
 
     x = torch.from_numpy(np.linspace(0, 30, 500)).unsqueeze(-1).to(**tkwargs)
@@ -942,14 +1058,11 @@ def test_constrained_objective2botorch(objective):
     )
 
     assert np.allclose(
-        objective.__call__(np.linspace(0, 30, 500), x_adapt=x_adapt.numpy()),
-        result,
+        objective.__call__(np.linspace(0, 30, 500), x_adapt=x_adapt.numpy()), result
     )
     if isinstance(objective, MovingMaximizeSigmoidObjective):
         objective2 = MaximizeSigmoidObjective(
-            w=1,
-            tp=x_adapt.max().item() + objective.tp,
-            steepness=objective.steepness,
+            w=1, tp=x_adapt.max().item() + objective.tp, steepness=objective.steepness
         )
         assert np.allclose(
             objective2.__call__(np.linspace(0, 30, 500), x_adapt=x_adapt.numpy()),
@@ -960,8 +1073,7 @@ def test_constrained_objective2botorch(objective):
 def test_constrained_objective():
     desirability = [True, False, False]
     obj1 = ConstrainedCategoricalObjective(
-        categories=["c1", "c2", "c3"],
-        desirability=desirability,
+        categories=["c1", "c2", "c3"], desirability=desirability
     )
     cs, etas, _ = constrained_objective2botorch(idx=0, objective=obj1, x_adapt=None)
 
@@ -977,8 +1089,7 @@ def test_constrained_objective():
     assert np.allclose(y_hat.numpy(), transformed_y.numpy())
     assert (
         np.linalg.norm(
-            np.exp(-np.log(np.exp(y_hat.numpy()) + 1)) - true_y.numpy(),
-            ord=np.inf,
+            np.exp(-np.log(np.exp(y_hat.numpy()) + 1)) - true_y.numpy(), ord=np.inf
         )
         <= 1e-8
     )
diff --git a/tutorials/advanced_examples/merging_objectives.ipynb b/tutorials/advanced_examples/merging_objectives.ipynb
new file mode 100644
index 000000000..87574acbc
--- /dev/null
+++ b/tutorials/advanced_examples/merging_objectives.ipynb
@@ -0,0 +1,262 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0",
+   "metadata": {},
+   "source": [
+    "# Merging multiple objectives to a scalar target for single-target BO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "import bofire.strategies.api as strategies\n",
+    "from bofire.benchmarks.api import DTLZ2\n",
+    "from bofire.data_models.objectives import api as objectives_data_model\n",
+    "from bofire.data_models.strategies import api as strategies_data_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2",
+   "metadata": {},
+   "source": [
+    "## Benchmark Problem \n",
+    "Only used for domain definition"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bench = DTLZ2(dim=2, num_objectives=2)\n",
+    "experiments = bench.f(bench.domain.inputs.sample(10), return_complete=True)\n",
+    "\n",
+    "domain = bench.domain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
+   "source": [
+    "### Change the objectives: Multiplication, only reasonable for objectives > 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "outputs = domain.outputs.get_by_objective()\n",
+    "\n",
+    "outputs[0].objective = objectives_data_model.MaximizeObjective(w=1.0, bounds=(0.0, 5.0))\n",
+    "outputs[1].objective = objectives_data_model.MaximizeObjective(w=1.0, bounds=(0.0, 2.0))\n",
+    "# outputs[1].objective = objectives_data_model.MaximizeSigmoidObjective(w = 0.5, tp=2.5, steepness=3.)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6",
+   "metadata": {},
+   "source": [
+    "## Select Strategies\n",
+    "We will use pure multiplicative and additive Sobo strategies, as well as a mixed one for this example:\n",
+    "- Multiplicative: $f = f_0^{w_0} \\cdot f_1^{w_1}$\n",
+    "- Additive: $f = f_0 \\cdot w_0 + f_1 \\cdot w_1$\n",
+    "- Mixed (with f1 being the additive objective): $f = f_0^{w_0} \\cdot (1 + w_1 \\cdot f_1)$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "strategy_data_model = {\n",
+    "    \"multiplicative\": strategies_data_model.MultiplicativeSoboStrategy(domain=domain),\n",
+    "    \"additive\": strategies_data_model.AdditiveSoboStrategy(domain=domain),\n",
+    "    \"mixed\": strategies_data_model.MultiplicativeAdditiveSoboStrategy(\n",
+    "        domain=domain, additive_features=[\"f_1\"]\n",
+    "    ),\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "### We will now create the strategies and evaluate them on a grid to visualize the objectives.\n",
+    "We see the following:\n",
+    "- Multiplicative: The objective is a product of the objectives: If either $f_0$ or $f_1$ is low, the objective is low.\n",
+    "- Additive: The objective is a sum of the objectives: We see a linear increase in the objective with increasing $f_0$ and $f_1$. This is useful for complementary objectives.\n",
+    "- Mixed: The objective is more strict w.r.t. $f_0$ than the additive objective $f_1$. The overall desirability can also be high, if $f_1$ is low.\n",
+    "\n",
+    "Changing the weights $w_i$ in the objectives above will further change the preference of $f_0$ and $f_1$. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# map from the strategy data-model to the actual strategy object instances\n",
+    "strategy = {\n",
+    "    key: strategies.map(strategy_data_model)\n",
+    "    for (key, strategy_data_model) in strategy_data_model.items()\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# tell the strategies about the experiments. This is required to set up the models, but not for the objective evaluation\n",
+    "for _, strat in strategy.items():\n",
+    "    strat.tell(experiments)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get the objectives for evaluation as a torch executable\n",
+    "objectives = {\n",
+    "    key: strategy._get_objective_and_constraints()[0]\n",
+    "    for (key, strategy) in strategy.items()\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# f_0 / f_1 coordinates for objctive evaluation\n",
+    "mesh = np.meshgrid(np.linspace(0, 2, 100), np.linspace(0, 5, 100))\n",
+    "# transform to matrix-form torch tensor\n",
+    "mesh_tensor = torch.tensor([m.flatten() for m in mesh]).T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# evaluate objectives\n",
+    "objectives_eval = {\n",
+    "    key: obj(mesh_tensor).detach().numpy().reshape(mesh[0].shape)\n",
+    "    for (key, obj) in objectives.items()\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/nz/mktm3tp93bb8z4cp_xyjgtzr0000gn/T/ipykernel_6246/3646907364.py:4: UserWarning: The following kwargs were not used by contour: 'label'\n",
+      "  plt.contour(*mesh, obj, label=key)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAHHCAYAAAD58fFKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACfeElEQVR4nOzdd1QU19/H8ffssvQOUkWkKIooKCpiRcXeNfbeEo01xl8STWJLMSbRxCQmJpbYe+8NxV5BrNjoKqCigNLLPn8QeWKCEVQYYO/rnD1HZ2dnP8PC7nfv3CKp1Wo1giAIgiAIxUAhdwBBEARBEMovUWgIgiAIglBsRKEhCIIgCEKxEYWGIAiCIAjFRhQagiAIgiAUG1FoCIIgCIJQbEShIQiCIAhCsRGFhiAIgiAIxUYUGoIgCIIgFBtRaAhCCRgyZAiVK1cu1L4zZsxAkqTXep5ly5YhSRKRkZH52/z8/PDz83ut472JgrIIgqB5RKEhCDJITU1lxowZBAYGyh3ljX399dds27ZN7hiCIJRSotAQBBmkpqYyc+bMAguNzz77jLS0tLf2XAcOHODAgQNv7Xj/9LJCY+DAgaSlpeHo6Fhszy0IQumnJXcAQRBepKWlhZbW2/vT1NbWfmvHKgqlUolSqZTluQVBKD1Ei4ag0Z73h7h16xYDBgzAxMSEChUq8Pnnn6NWq4mJiaFLly4YGxtjY2PD3Llz8x/7sj4IgYGBSJL00ssikZGRVKhQAYCZM2ciSRKSJDFjxowXMv2dJEmMHTuW1atX4+bmhq6uLt7e3hw7duyV51hQH4309HRmzJhB1apV0dXVxdbWlu7duxMWFpa/z/fff0/Dhg2xsLBAT08Pb29vNm3a9K9cKSkpLF++PP88hgwZUuDPp2PHjjg7OxeY0dfXl7p1676wbdWqVXh7e6Onp4e5uTl9+vQhJibmlecrCELpIgoNQQB69+5Nbm4u33zzDT4+Pnz55Zf8+OOPtGrVCnt7e+bMmYOrqyuTJ08u1If7f6lQoQK//fYbAN26dWPlypWsXLmS7t27/+fjjh49ysSJExkwYACzZs0iISGBtm3bcvXq1SI9f05ODh07dmTmzJl4e3szd+5cJkyYQFJS0gvHmj9/PrVr12bWrFl8/fXXaGlp0bNnT3bv3p2/z8qVK9HR0aFJkyb55/Hee+8V+Ly9e/cmIiKC8+fPv7A9KiqKM2fO0KdPn/xtX331FYMGDaJKlSrMmzePiRMnEhAQQNOmTUlMTCzS+QqCIDO1IGiw6dOnqwH1u+++m78tOztbXbFiRbUkSepvvvkmf/uTJ0/Uenp66sGDB6vVarX6zz//VAPqiIiIF4555MgRNaA+cuRI/rbBgwerHR0d8///8OFDNaCePn36SzP9HaAG1BcuXMjfFhUVpdbV1VV369Ytf1tBmZo1a6Zu1qxZ/v+XLl2qBtTz5s3713Pn5ubm/zs1NfWF+zIzM9UeHh7qFi1avLDdwMAg/2fyd//MkpSUpNbR0VF/+OGHL+z37bffqiVJUkdFRanVarU6MjJSrVQq1V999dUL+125ckWtpaX1r+2CIJRuokVDEIARI0bk/1upVFK3bl3UajXDhw/P325qaoqbmxvh4eFyRMTX1xdvb+/8/1eqVIkuXbqwf/9+cnJyCn2czZs3Y2lpybhx4/51398v2ejp6eX/+8mTJyQlJdGkSROCg4NfK7+xsTHt2rVjw4YNqNXq/O3r16+nQYMGVKpUCYAtW7aQm5tLr169ePToUf7NxsaGKlWqcOTIkdd6fkEQ5CE6gwoC5H/IPWdiYoKuri6Wlpb/2p6QkFCS0fJVqVLlX9uqVq1KamoqDx8+xMbGplDHCQsLw83N7ZUdTnft2sWXX35JSEgIGRkZ+dtfd44PyLt8sm3bNk6fPk3Dhg0JCwsjKCiIH3/8MX+f27dvo1arCzxfAJVK9drPLwhCyROFhiBAgaMjXjZi4vm38Zd94BaldaG0On78OJ07d6Zp06b8+uuv2NraolKp+PPPP1mzZs1rH7dTp07o6+uzYcMGGjZsyIYNG1AoFPTs2TN/n9zcXCRJYu/evQW+BoaGhq/9/IIglDxRaAjCazIzMwP4V+fEqKioVz72dVoFbt++/a9tt27dQl9fP38US2G4uLhw9uxZsrKyXto6sHnzZnR1ddm/fz86Ojr52//8889/7VuUczEwMKBjx45s3LiRefPmsX79epo0aYKdnd0L+dRqNU5OTlStWrXQxxYEoXQSfTQE4TW5uLgAvDAKJScnhz/++OOVj9XX1wf+XaT8l9OnT7/QPyImJobt27fTunXrIs1X0aNHDx49esQvv/zyr/uet9YolUokSXqhdSYyMrLAibkMDAyKdB69e/fm/v37LF68mEuXLtG7d+8X7u/evTtKpZKZM2e+0JfjeT65Ll0JgvB6RIuGILymGjVq0KBBA6ZMmcLjx48xNzdn3bp1ZGdnv/Kxenp6uLu7s379eqpWrYq5uTkeHh54eHi89DEeHh60adOG8ePHo6Ojw6+//grkzcVRFIMGDWLFihVMmjSJc+fO0aRJE1JSUjh06BDvv/8+Xbp0oUOHDsybN4+2bdvSr18/Hjx4wIIFC3B1deXy5csvHM/b25tDhw4xb9487OzscHJywsfH56XP3759e4yMjJg8eTJKpZIePXq8cL+LiwtffvklU6ZMITIykq5du2JkZERERARbt27l3XffZfLkyUU6Z0EQ5CMKDUF4A6tXr+a9997jm2++wdTUlOHDh9O8eXNatWr1yscuXryYcePG8cEHH5CZmcn06dP/s9Bo1qwZvr6+zJw5k+joaNzd3Vm2bBm1atUqUmalUsmePXv46quvWLNmDZs3b8bCwoLGjRtTs2ZNAFq0aMGSJUv45ptvmDhxIk5OTsyZM4fIyMh/FRrz5s3j3XffzZ86ffDgwf9ZaOjq6tK5c2dWr16Nv78/VlZW/9rnk08+oWrVqvzwww/5hZSDgwOtW7emc+fORTpfQRDkJan/2TYpCEKpI0kSY8aMKfByhyAIQmkm+mgIgiAIglBsRKEhCIIgCEKxEYWGIAiCIAjFRtZC4/kqlX+/VatWTc5IglAqqdVq0T9DEIT/dOzYMTp16oSdnR2SJBU4HP2fAgMDqVOnDjo6Ori6urJs2bIX7n8bn9Oyt2jUqFGD2NjY/NuJEyfkjiQIgiAIZU5KSgqenp4sWLCgUPtHRETQoUMHmjdvTkhICBMnTmTEiBHs37//hf3e9HNa9uGtWlpahV6jQRAEQRBKO3Vu6ls5jqTQL9L+7dq1o127doXef+HChTg5OTF37lwAqlevzokTJ/jhhx9o06ZN/n5v+jkte6Fx+/Zt7Ozs0NXVxdfXl9mzZ/9rgavnMjIyXljcKTc3l8ePH2NhYfFGCz0JgiAI5Z9arebp06fY2dmhUBRfg35adC0ys9585gjJKvhfn206OjovLAvwJk6fPo2/v/8L29q0acPEiRNf2FaUz+kCybM6fZ49e/aoN2zYoL506ZJ63759al9fX3WlSpXUycnJBe4/ffp0NSBu4iZu4iZu4vbat5iYmGL7XEtLS1PbWCnfSk5DQ8N/bZs+fXqhcgDqrVu3/uc+VapUUX/99dcvbNu9e7caUKempqrV6qJ/ThdE1haNvzfx1KpVCx8fHxwdHdmwYQPDhw//1/5Tpkxh0qRJ+f9PSkqiUqVKrPpxPW0HtCyRzMUhKyuLI0eO0Lx585cucpWdncOA9j+Qm6Pm17XvYWllXMIp/1thzqEogkNjmPLzHkyNdVnz9UCUxfjt4+/e9nkU1rzDJ9kQfI3aFW34rc+bz3wp13kURnp2Fr0PrSP6WSLdnWrwuXeLAvcrzedQFFef3OHrW3+ilqBPxVZ0sfOTO1KRFfa1UKvVXHryB7efbQMk6ptPxtGw4NdXDo8fP6Zq1aoYGRkV23NkZmYS9yCH6KhbGBu//vMkJz+lkmNVYmJiMDb+//f7t9WaUVhF/ZwuiOyXTv7O1NSUqlWrcufOnQLvf1mTkZGhMRYWFsUdr9hkZWWhr6+PhYXFf/4RV3ayJzriIU+f5OBWvXSdb2HPobCaNzDFbNVJklMyuPsonTrVHd5Cyld72+dRWOPbtGDHjUguP0wk/Gka9SpXfKPjyXUehTXXvzu9969hW1wYvTLr0dC28r/2Ke3nUFgNjY3xu32BEwY32fLkGB521ahvUUPuWEVSlNeihcUUDB6quJm0lauZ8zHTNsXJ6NVT8pekkrjUbmJq/UKBUFTP+2cYGxu/0XH+i42NDfHx8S9si4+Px9jYGD09vQIf86rP6YLIPurk7549e0ZYWBi2trZyRymVKjnnLQUeHfFA5iTFT0tLSVNvVwACzt2SOU3xszY2pEftvA+fX4+ekTlN8fOxrsRAtzoAfHx6LylZmTInKl7umRVpa+2LGjXf3lhGdEqs3JGKjSRJ+FT4kCrGnVCTy/G4WUQ+PSx3LKEAvr6+BAQEvLDt4MGD+Pr6vvQxr/M5LWuhMXnyZI4ePUpkZCSnTp2iW7duKJVK+vbtK2esUquSU16hERX+UOYkJaN5vSoAHDl/h5zcXJnTFL+RjeuhUig4HRFDcPQ9ueMUu4/rNMPewJiYZ0l8Gxwod5xiN7xyVzxMXEjLyWDmtT9IzkqRO1KxkSQFvlYf42LUHjU5HIubLoqNEvDs2TNCQkIICQkB8oavhoSEEB0dDeR1Pxg0aFD+/qNGjSI8PJyPPvqIGzdu8Ouvv7JhwwY++OCD/H3exue0rIXG3bt36du3L25ubvTq1QsLCwvOnDlDhQoV5IxVajm65K1yGR2hGYWGj4cjhvo6JCSlcPnWfbnjFDt7U2O6erkD8Etg+W/VMFTp8I1v3vXf5TeDORMXLXOi4qVSaDHVfTjWuhbEpSfw9fUlZOVmyx2r2EiSgobWU3A2aptfbEQ9PSJ3rHLtwoUL1K5dm9q1awMwadIkateuzbRp0wCIjY3NLzoAnJyc2L17NwcPHsTT05O5c+eyePHiF4a2vo3PaVn7aKxbt07Opy9zHJ+3aIQ9RK1Wl/shvSotJU3ruLDnxHUCzt2idrU367dQFrzXpD5bQ65zKjya4Oj71KlkJ3ekYtXEzom+VbxYezuEj07tYV+nYeirtOWOVWxMVIZMr/EuH4bM40rSHRbe2cTYKr3L7d+yQlLSyPpTAMKf7uNo3DSaMQtHo+YyJyuf/Pz8UP/Hguz/nPXz+WMuXrz40se8jc/pUtVHQ/hv9o4WKJQKUp6lk/DwqdxxSkTL+lUBOHL+tkZcPqloZkK3/FaN0zKnKRlTvZtjp29M9LNE5mjAJRRHA1s+qjYYCYl9cafYcf+o3JGK1fNiw9moDWpyOBo3TVxG0TCi0ChDtLW1sHcwByAqrPx3CAWo71EJQ30dHiWmcOlm+e+3AHmtGloKBafCo7kQdVfuOMXOSFuHOQ3//xLKqdhIeQOVgPoWHgxz7gLA4rCtnEu4JnOi4pVXbHz2wmWU8KcH5I4llBBRaJQxz/tpRIVrRqGhrdKi2V+jTw6dLf+jTyCvVeP5CJSfj5T/vhqQdwmlf9W868r/O7WHp5kZr3hE2dfNvjltbHzJ/WskSviz8l1IP2/ZeN5B9ETcLMKS98kdSygBotAoYyr/VWhEakiLBkCrBnmXTw6fv012Tvm/fAIwqqkPKqWSs5ExnImIkTtOiZji7YeDoQn3UpL54kLAqx9QxkmSxPuuvfA0rZo3EuXq7yRkJMkdq1jlFRtT84e+noj/gttJu+SOJRQzUWiUMfmFxh3NKTTquVfC2FCXJ8mpBIdqxoeurYkRvbxrAjD/8Mn/7OBVXhiqdPi+UQckYMOdywTcLfyEQGWVlkLJlOrDqKhnzaPMRGZe+530nPLdmvN86KubSTdAzakHX3MjcbPcsYRiJAqNMub/L508JFcDOkdC3uRdLf6aU+PgmZsypyk57zauh46WkosxsRy7HSl3nBLhY12JEe71Afj03EGeluPhn88ZqfSZ4fEeJipDwp7dZU7ocnLU5ftvW5IU+FSYTHXTXgCcfTiXa0/WypxKKC6i0Chj7B3MUamUpKdl8iC2fDez/l1r32pA3uiTzKzy/+EDebOF9q/vBcD8w6fIzS3/rRoAH9ZuiptpBRIyUlmfFqsRrTm2epZ8XmMk2goV5x5f5Y+wLeX+vCVJop7lBDzMBgJw4dHPXHr8p8yphOIgCo0yRqmlxOGv+TQi7sS/Yu/yw8vNngpmBjxNzeDMlSi545SYkY3qYaCtzfW4BxwIvS13nBKhq9RiXuOOqBQKrmQ/Y3NE+R6R8Vx1Yyc+dBuAhMSu+8fYdq/8T24lSRJ1LEbhZTESgJCERQQ9+q3cF1maRhQaZdDzfhqaVGgoFQr8fdwA2H/qhsxpSo6ZgR5DfPPWBPnx8CmN6Qxbw9yaCTUbAvBl0GGinj6ROVHJaFyh9v8Pew3fxvGHwTInKn6SJOFpPpS6lmMBuPpkJWcfzkVdzi8faRJRaJRBTlWsAc3qEArQ5q/LJ8cvhpGSVr4X4fq7ob51MNPXIzLhCVtDNOPbPcCIavVwUeqTkp3FxOM7ydaQPknd7JvTya4pAN/fWMnVxPLfKRaghlk/GlT4HyBxM2kLJ+K/JFetGZdJyztRaJRBTq55hYYmtWgAVHOyppKNGRmZ2RwN0ow3XwBDXR1GNcnrIPlL4BnSNaSPilKhYIC+HUYqHS4+us/Pl0/KHalESJLESJfu+FrUIludw6zri4gqx6u9/p2baTeaWE9HQkn4030Exn5GTm75HoWjCUShUQZVds27dHI3KoHMTM340IG8N+DnrRr7T4XKnKZk9albCzsTI+KfPmP1uRC545QYc4WKGXVbAvDzlVNceFD+Z0oFUEoK/ldtENWNnUjJTmPald94lKEZl4+cjVvjZ/s1CkmbmJRjBNz/H1m55XelW00gCo0yyNLKGENjPXJzconWkCXjn2vTKK/QOHc1moREzXnz0VFpMdbPF4A/jp8jKS1d5kQlp3Pl6nRzrkGuWs2E4ztIztSMc9dRajOtxrv5c2xMu7KQp1mpcscqEZUMm+Bv9z1akh6xaRfYf3c86TmJcscSXpMoNMogSZJw/qufRsRtzbp84mBthoerLblqNQdOa06nUIAuntWpYmVBUnoGi06clztOiZpVv3X+rKGfntmvMaMSjFUGfFFzNBbaJkSlxvLFtT/IyNGM/km2+nVpU/FndBQmJGSEsi9mNClZmvV+V16IQqOMel5ohN+OkzlJyWvXqDoAezXs8olSoeBD/8YArDhzkdgkzVjBF/IWXpvfpDNKSWJnZCgb71yWO1KJsdI1Z1bN0Rgo9biWHM63N5aTo86RO1aJsNR1p63Db+hrWZGUFcXeu6NIyoyUO5ZQRKLQKKOc8gsNzavw/X3cUCoV3Ix8QFjMI7njlKhmVZyo51iRzJwc5h8+JXecElWngj2TvPJGY0w/f4g7iZrz2lc2sGOax7uoJC3OJFzh51vrNKZVx1S7Mu0qLsRYVYmU7Hj2xozmYbrmjL4qD0ShUUY5V7UBIOJWnMa84TxnaqRHI08nAPaevC5zmpIlSRIftW4CwPZL1wmN1awhzqM9GtDYtjJp2VmMObad9OwsuSOVGA8TFz6uPgQFEgfjz/JnxA65I5UYQ5UN7RwWYqFTnYzcJA7cHcfdlNNyxxIKSRQaZZSjsxUKhURSYioJDzWnCf25Dk3cAdh3KpQcDZlf4bma9jZ0rFkNNfDtgWMaVWgqJIl5jTtiqavPzcSHzNKAVV7/zteyFuOr9gVg890ANsYclDlRydFVmtKm4s/Y6fuQrU7n8P2PuJO8R+5YQiGIQqOM0tFVUdHREoDwW5rXT6OhpxPGhro8fJLC+WvRcscpcRNbNESlVHI6IkZjFlx7zkrPkB8ad0IC1twKYVekZvXVaWXTgOHOXQFYFrGTfbGacwlNpdCnpd13OBu1RU0OJ+O/5MrjFRpVbJdFotAow55fPtHEQkNbpUXrBnlTku8+rnnXayuamTDIxwuAOQeOkZWjGZ0Dn2ti58Roj7zhvp+c3ktksmbMMfFc94ot6OngD8Avt9dz7EH5n6r8OYWkRWPrz6hh1h+A4ISFnH04j1wN6SBbFolCowxzccsrNMI0sNAA6NikBgBHL9zhaYpmzK3wd+81qY+Zvh7hjx6zIeiK3HFK3CSvJtStUJFnWZm8f3Qr6TmaM3kdwODKnWhn2wg1ar6/uYJzCZpTcEuSgrqWY6hnOYG8Kcs3Exg7lexczXsfKAtEoVGGubjZAhB2UzMLjWpO1jjbW5CRlcPBs7fkjlPijPV0GffXJF4/HzmtUZN4AWgpFPzctDPmOnpcf/KAL85rVn8NSZJ437UnfhW8yVHnMjt0KZcTNWOF3+fczXrTzOaLv2YRPc6Be+PExF6lkCg0yjCXqnlDXO9FJ5CaonnrAUiSRMemea0au45elTmNPHp518S1gjmJaen8evSs3HFKnK2BcX5/jdW3LrI9XHO+1QMoJAUfuA3Ax8KDzNwsZl37gxvJEXLHKlGVjVrQ2n4+2gojHqZfY0/MuyRnxsgdS/gbUWiUYabmhlhaGQOa2U8DoG2j6iiVCq6FxxF+V3PmVXhOS6ng4zbNAFh9LoTwR49lTlTymtk7M/avJeU/ObOP2xo0vwaAlkLJJ9WH4mlalbScDKZdWcidp5r1QWut50k7h98x0LLhadZd9sS8S3zaJbljCX8RhUYZl99P46ZmrO74TxYmBjT2yptTY+cxzfo2+1wT18r4VXUiOzeXOfuPyR1HFhM9G9PQxpG07CxGHd3KsyzNauHTVqiYVmMk7sbOpOSk8fmVX4lMuS93rBJlql2ZDg6L/n+ujXvjiXiqOcN/SzNRaJRxz/tp3NHQfhoAnZp6ALD3xHWysjWz5/nHrZuhUig4ejuCo7c0q+kc8qZn/6lJZ6z1DAlLSuDjU3s1bsijrlKHGR7vUdWoEsnZKXx6eQF3UzVr5mA9LQvaVlyAg0FTctVZHIubLoa/lgKi0CjjXJ8XGjc0s0UDwNfTCUtTA548TeP4xTC548jCydKMgQ1qAzB7/1GNG+4KYKlnwK/NuqIlKdgddYMloZq18ByAgZYeszxG42RgT2LWU6Ze/oX7aZq1wrOWQhc/269wN+0N5A1/PfXga3LUmjOLbGkjCo0yrkr1vEIjKuwBmRma+YekpVTQvnHeTKHbj2jeMM/n3m/qg6WBPpEJT1h5TjOvT3tbVeSzui0AmB10hNNxUTInKnlGKgO+qvk+jvq2JGQmMfXyL8SmaVa/FYWkpF6FCfhU+BAJBXeSd3Pw3gQycpLljqaRRKFRxlWwMcHYRJ+cnFwiwzRr3Yu/6+JXE4CzV6OIfaSZbyaGujpMbpW3DsrvJ86TlKlZ80o8N7iaN92ca5CjVjPu2HZiUzTv98FE24ivao2hop41DzOeMOXyz8SnJ8gdq8RVM+1BS7vvUSn0iU8LISDuA7kjaSRRaJRxkiTlt2rcDtWszl9/V9HalLruDqjVsOOo5rZqdK5VHa+KtqRmZrHnvuZ9sEDe38TXDdpS3cyKR+mpjD66jQwNm8wLwEzbmNm1xmKvZ5VXbFz6mQfpmjcqyd6gAe0q5o1IScnR3PdIOYlCoxxwrfa80NDcfhoAXZvXAmDn0atk52jWQmvPKRQSn7dvjgSEPEnhfNRduSPJQk9Lxe9+3THR1iXk0X0+P3tAIzsEmuuYMLvWOOz0KhCf8ZhPLv2kkcWGmY4LHRwWU9N0mNxRNJIoNMqBKu72gGa3aAA083bB1EiPh09SOBkSLncc2dSws6ZXnbyROF/t07x1UJ6rZGTKz027oJAkNty5zMqbmrMeyN9ZPC82dPOKjY8v/aSRl1H0tMypZtxT7hgaSRQa5UBVdzsAIu88IFNDr8tD3kJrnf6aKXTr4csyp5HXOL8GGGgpCHv0mBVnLsodRzZN7Zz4pI4fALPOB3AmTvNW+gWw1DFltmdey8aDv4oNTesgKshHFBrlgNVfHUKzs3OIuK1Z4+b/qUvzvE6hZ65Ecv9Bksxp5GOip0s7OwsAFgSeITbpqcyJ5DPSvT6dK7uTrc5lzLFt3H2mmb8XljqmfFNrfH6fjU8u/aRxQ18FeYhCoxyQJIkqf7Vq3Lp+T+Y08nKwNqO+hyNqNWw9otmtGt7mhnhVtCE1K4uv9wXKHUc2kiQxp2E7aphbk5Ceysgjm0nNypQ7liwsdEz4ptY4KupZ8ygzkY8vzSdGwyb1EkqeKDTKCbf8QkOz+2kA9Gj5/51CM7M091KSQpL4vJ0fSkniYOgdjtzU3H4reloq/vDrjqWuPqFPHvDhyd3kamDnUMjrIPqN5zgc9W15nJnMJ5d+0rjpyoWSJQqNciK/Q6goNGhc24UKZoY8eZrGkfOatWz2P1W1smSIbx0AvthzhNRMzZzUDcDe0ISFft1RKRTsjb7Jj5dOyB1JNmbaxsz2HIfzXzOITrn0s8YtxCaUHFFolBNuNfJaNKLCH5CeppnNws9pKRV0/WsCr00BmjlD5t+N8fPFzsSI+0nJLAg8LXccWdW1qsjXDdoC8NPlk+yMCJU5kXxMVIZ8XWtc/tooUy//QqiGLTEvlAxRaJQTFhWMsahgRG6umtsavO7Jc12a10SpVHD51n1uRWl2hzd9bRWft8+blnvZ6WBuxGn2z6Onay1GutcHYPKp3YQ80txWQCOVPl/VHJO/6utnlxdwKfGW3LGEckYUGuWIW428yyc3r2rmJE1/V8HMkOZ1qwCw6ZDmDu98rrmbM62ru5KjVvP5joPk5GrmhGbPfVLHj5YVXcjIyWbE4c3c09CRKAD6Wnp8UXM0XqZupOdmMv3KQs4lXJU7llCOiEKjHHleaIgOoXl6tvICYN+pGyQ9S5M3TCnwabvmGOnocOV+PKvPhcgdR1ZKhYL5TTpTzbQCj9JTGH5kE8+yMuSOJRtdpQ7TPd7Fx8KDLHU2X15fzNEHQXLHEsoJUWiUI24eFQG4IVo0APCsakeVShXIyMxmx1HxDc3a2JAPWzUG4MeAU9x9ornf4gEMVTosafEOlroG3HjykHHHdpCtwS092goVU6sPx8+qLjnqXL67sYK990/KHUsoB0ShUY5UdbdDkiTi7yfyJOGZ3HFkJ0kSvVrXBmDzoUsau/7J3/WqU5O6jvakZmUxfVeARq7/8Xf2hiYsafEOukotjtwLY+b5Qxr9M9FSKPnQbQDtbRujRs0vd9azIfqgRv9MypoFCxZQuXJldHV18fHx4dy5cy/dNysri1mzZuHi4oKuri6enp7s27fvjY5ZEFFolCMGhro4OFkColXjuda+bpgY6hL7KJnjwWFyx5GdQiHxRadWaCuVnAyLYtul63JHkp2npS0/NumEBKy8GcyS0PNyR5KVQlLwvmtPeju0BmB55E6WRe1EjSg2Srv169czadIkpk+fTnBwMJ6enrRp04YHDx4UuP9nn33G77//zs8//8z169cZNWoU3bp14+LFi699zIKIQqOcqV5TXD75O11tFd1a5E3gtX6/Zi6q9U9OlmaMa+4LwDf7jvLwaYrMieTXtpIbn9bNG5nz1YXD7Im6IXMieUmSxCCnjoxw7grA9tijHNUPJUetmQv0vY6s3LQ3vhXVvHnzGDlyJEOHDsXd3Z2FCxeir6/P0qVLC9x/5cqVTJ06lfbt2+Ps7Mzo0aNp3749c+fOfe1jFkSryGcilGrVPCqyf/tFblwRhcZz3Vt6snL3BS7evMfNyAe4VbaSO5Lshvp6s/faLa7HPmDW7sP81LsjkiTJHUtWw6vXI/ppIituBjPx+E4q6BpQz9pB7liy6laxBUZaBsy/tZZbOrHMvrmMKe7D0FVqyx2t1NsY0Qk9w9f/iE17ljercXJy8gvbdXR00NHR+df+mZmZBAUFMWXKlPxtCoUCf39/Tp8ueP6cjIwMdHV1X9imp6fHiRMnXvuYBREtGuVM9Zp5b4w3r90jR/RJAMDa3IiW9fOGuq7dJ3rSQ96kZl93aY2WQsHBG3fYe03MnSBJEtPr+dPKoQqZuTmMOLKZO0mat5z6P/nb+PCJ2xCUagUXnlznsysLeJolWsFKioODAyYmJvm32bNnF7jfo0ePyMnJwdra+oXt1tbWxMXFFfiYNm3aMG/ePG7fvk1ubi4HDx5ky5YtxMbGvvYxCyJaNMqZSs4V0DfQITUlg6jwBzhXsZE7UqnQt603B07f5OCZm4zt0wRLU0O5I8mumk0F3mtSnwVHzzBr92F8KjtgYagvdyxZKRUKfmrSmX4H1nLx0X0GH1rP1vaDsNLT7N+X+uY16PC0NgFm1wlNjuCjS/OZ5TGaCrpmckcrtXo67cTY2Pi1H5+cnMxobIiJiXnhOAW1Zryu+fPnM3LkSKpVq4YkSbi4uDB06NAiXRYpDNGiUc4olQqq/jWfRuhlsXbBc+7ONtSqakd2Ti6bDoppyZ97r0l9qllXIDEtnZm7xSgUyFuAbUmLd3AyMuNeSjJDAzbyNFNz59h4zibHlK89xmChbUJ0ahwfhswTi7H9B5VC741vAMbGxi/cXlZoWFpaolQqiY9/cTXe+Ph4bGwK/sJZoUIFtm3bRkpKClFRUdy4cQNDQ0OcnZ1f+5gFEYVGOeT+V4fQ0Muin8bf9WvrDcDmw5dIS9fcxcX+TltLyeyueZdQDoTeYffVm3JHKhXMdfVZ7t8bS119rj2O573ALWTkaO5KwM856tsy12sSlfRtSMhM4qOQ+WLK8lJCW1sbb29vAgIC8rfl5uYSEBCAr6/vfz5WV1cXe3t7srOz2bx5M126dHnjY/6dKDTKIXfPSgBcFy0aL2jq7UJFKxOSn6Wz6/g1ueOUGtVtrRjVNG/tjy92HyY+WczBAlDJyJQ/W/bCQEubU3FRTDqxS+OnbgeooGvGt54TqGHsQkpOGtOu/EbggwtyxxKASZMmsWjRIpYvX05oaCijR48mJSWFoUOHAjBo0KAXOnaePXuWLVu2EB4ezvHjx2nbti25ubl89NFHhT5mYYhCoxyq9leLxr3oBBKfiE5bzykVCvr81aqxdl+Q+ND4m/ea1Mfd1oqk9Aym7dTsSav+rqaFDb//tbT87qgbGj+h13NGKgO+rPU+jSy9yFbn8N2NFWJir1Kgd+/efP/990ybNg0vLy9CQkLYt29ffmfO6Ojo/I6eAOnp6Xz22We4u7vTrVs37O3tOXHiBKampoU+ZmGIQqMcMjLWo5JzBQCuXxKtGn/XsUkNjA11ufcgicALd+SOU2qolErmdGuDSqnk6O0INgRdkTtSqdHYrjLzGuVN6LXiZjA/Xzkld6RSQVuh4pPqQ+hq7wfkTez1650NYq4NmY0dO5aoqCgyMjI4e/YsPj4++fcFBgaybNmy/P83a9aM69evk56ezqNHj1ixYgV2dnZFOmZhiEKjnKqRf/kkWuYkpYuerop3/D0BWLnrvPgG9jdVrCz5oGUjAObsP0ZUQqK8gUqRTk7VmV7PH4B5IcdZeUNM/gZ5s4iOdOnOuy7dkZDYE3uSWVcXkZqdLnc0oRQRhUY59bzQuBYiCo1/6tWqNjraWoRGxBN0XbT4/N2QBnWoX7kiqVlZfLx1n1gf5m+GVK/L+Fp5hdi0cwfYHi76+TzXxd6PT92Ho6NQceHJdT66NJ9HGU/kjiWUEqLQKKfcvfIm7rp9/T6ZGWKExd+ZGevTqWkNAFbs1ux1Lf5JoZCY3bUNhjrahNyNZdEJ8fP5uw88GzPYrQ5q4MOTuzl8V1x+e87Xshaza43HVGVERMo9Jl2cR9gzUcgLotAot+wqmmNmYUhWVg43r4ux7v/Uv11dlAqJs1eiuBEZ/+oHaBB7U2M+b98cgAVHz3DlXuFnACzvJEliev1WdHWqQbY6l9FHt3E6LkruWKWGm7Ej82r///DX/4XM5/Sjy3LHEmQmCo1ySpIkanj9dfnkongj/Cc7KxP8fdwAWLFTfGv/p861qtPWvQrZublM3ryXlIxMuSOVGgpJ4rtG7fGv6EpGTjYjDm/m4kNRzD9nrWvB914fUNvUjYzcTL66voTNMWIyOE0mCo1yLL/QEP00CjSoUz0ADp+/RXSsuJ78d5IkMbOTPzbGhkQ9TmT2vqNyRypVVAolvzTrSiMbR1KyMxkcsJ7rj0XL2HMGWnrM8BhFe9vGqFGzNGI782+tIStXTHqmiUShUY7VrO0IwLVLMWKBtQK4OlSgSW1n1GpYvuuc3HFKHRM9Xb7t3g4J2HTxKvvEwmsv0FVq8UfzHnhXsCc5M4OBh9ZzJ/GR3LFKDS2FkvddezLK5R0USByMP8unlxeQlPlU7mhCCROFRjnmXNUGfQMdUp6lE3lHfNsqyODOeTNi7j0Zyv2HSTKnKX3qV67IyMZ5LT+f7zjEvcTkVzxCsxiotPmzZU88zK1JSE+l38F1RCaL1rHnJEmik31TZniMQl+py7XkMCZenEvEs3tyRxNKkCg0yjGlUoG7Z97okyvBop9GQWq62lGvRiVycnJZtVtMo1yQcc198bS34WlGBpM37xFDXv/BWFuXlf59cDOtwIO0Z/Q7sJaYp4lyxypVvM2rM7f2JGx1LXmQ8ZjJIT9w8pFY3FBTiEKjnKtVpzIAl4MjZc1Rmg3rkjfL3Y6jV3n4RKzz8U8qpZK577THUEebizGx/BJ4Wu5IpY6Zrh6rWvXBxcSC+6nJ9D24lnvPRAvZ31XSt+GH2h/iaVqV9NxMvr6+hDVRe8lVi8K1vCtVhcY333yDJElMnDhR7ijlhkedvH4aV4OjRK/vl6hT3QEvN3uysnNYs1fM+FiQimYmzOqUNzPm78fPcSpMtJD9UwU9A9a06oOTkRl3nyXR98Ba7qeIS01/Z6Qy4Iuao+ls1wyA1VF7mR36J2k5GTInE4pTqSk0zp8/z++//06tWrXkjlKuVHW3Q0dHRVJiKlHhD+WOU2oN69IAgO1Hr/IsTfSML0h7Dzd61vFADXy0ZR8Pn4oF+/7JWt+INa374mhkSvSzRPoeWENsquj8+HdKScl7rj0YX6UvWpKSU48u8eHFedxPE+9P5VWpKDSePXtG//79WbRoEWZmZnLHKVdUKq38WUIvB0XInKb0qu9RiZqutmRm5XDmVqLccUqtT9s1p6qVJY9SUpm8ea9YAbcAtgbGrG3dj0qGpkQ9TWRgwAYSc8XsvP/UxtaXbzzHY65tTFRqLBMvfs+Fx9fljiUUAy25AwCMGTOGDh064O/vz5dffvnS/TIyMsjI+P8mtuTkvGbJnJxssrLK7h/y8+zFdQ4eXpW4eDackPMRtOtWp1ieo7jPoSQM7VyfSfO2ExyWTNyjRGwsTeWO9NqK6/VQAt91a0OfpRs4GxnDL0dO8X7Toq3kWFhl+XeqgrYeK1v0pH/ABqKeJfKzIoXGSY+pZGIud7TXUlyvhateRb6vOZE5N5dz81kUM67+Tj+Htrxj3xJJkt7qc0HZ/F0qD2QvNNatW0dwcDDnz796dsbZs2czc+bMf22/du06ij1lf2nigwcPFstxn2XkdXAMPnOb3bt3F8sf8HPFdQ4lQa1WY2+uw73HGXzzxw5ae1nKHemNFdfr0dnOlPVRD1l4/DyZ92OoaqxfLM8DZft3ariiAr9IqTzKzaLX3lWMNXTEXKGSO9ZrK67XojHOSPpZ3NC5z+qYvZwMu4Bfijvab/kjKjU19a0eTygcWQuNmJgYJkyYwMGDB9HV1X3l/lOmTGHSpEn5/09OTsbBwYEaNdxp375NcUYtVllZWRw8eJBWrVqhUr39N6GsrBz2rPuetNQsalSrR2UXq2J4juI9h5Ji4RDB5B93cSnyKVNHdcfK3FDuSK+luF+P9kD27sNsDrnOlthENrRvi43x2/1ZlZffqSZJj+mzbxWPcrNYnPuAlX69cDA0kTtWkZTEa9GJjuyPP82iiK1Eaj/kgPF1PnEbQiV9m7f2HAkJCW/tWELhyVpoBAUF8eDBA+rU+f/m/JycHI4dO8Yvv/xCRkYGSqUy/z4dHR10dHT+dRylUqtMvxE9p1KpiuU8VCoVHl6VCDoTxrWLMVSpZv/Wn+Pvz1WWXwufmpVxsNQl5lE6q/YE8fFQf7kjvZHifD0+79CS63EPCY17yP+27mfFkJ5oaylf/cAiKuu/U44m5owzcORPEoh8+oQBARtY3boPTsZl7zJKcb8WHSs2pYqxI7NDl3I//SEfXZnPhKr9aGr1di75luXfo7JM1s6gLVu25MqVK4SEhOTf6tatS//+/QkJCXmhyBDejGddJwBCzosOof9FkiSa1cj7ANhx9Cr3H4i5EF5GV6XFT706YqSjQ8jdWL47eEzuSKWWqULFqha98ufZ6L1/DbfFdOUFcjN2ZH7tyfnzbcy5sYzf72wW66SUYbIWGkZGRnh4eLxwMzAwwMLCAg8PDzmjlTue9fIKjctBkWLdk1eoVEGPuu4OZOfksnjbGbnjlGoO5qbM6ZZ32XLl2RB2Xbkhc6LSy1rfkPWt+1HtrxlEe+9fzTWxEFuBTLSN+KLmaHo65LUo7rh/lE8u/cTDdDG9e1lUKoa3CsWvSjVbDAx1SXmWzp0bsXLHKfVGdsubV2PvietE3n8sc5rSrUU1F95rkrdmzOc7DnIrXnxTfxlLPQPWtu5HTQsbHmek0ffAGoIfinU/CqKUlAxx6sznNUZioKXHjaeRjA/+lqDHoXJHE4qo1BUagYGB/Pjjj3LHKHeUWkpqeVcGIORcuLxhyoAaLjY0reNCrlrN75tOyh2n1Bvf3JeGzpVIy8pm3PqdJKelyx2p1DLT1WN1qz7UrVCR5MwMBhxcx6k4MdPqyzSwqMn82v/DxbAiydkpTL+6kJWRu8kRU5eXGaWu0BCKT20fZwCCRaFRKKPeaYQkweHztwkNj5M7TqmmVCiY26M9dibGRD1O5H9b9onJvP6DsbYuK/x70di2MqnZWQw5tIFDMbfljlVq2epZ8r3XB7SzbYQaNeui9/Pp5V94nCH6UJUFotDQILXr5xUa10KiyUgXE9e8iouDJW0bVgdgwYYTYq2YVzAz0OOXPp3Q0VJy9HYEPx0Ri6/9F32VNotbvEMrhypk5ubwXuAWtoZflTtWqaWtUDG2Sm/+V20wugptriTdYWzwHILFpZRSTxQaGsShsiWWVsZkZWZzNSRa7jhlwrs9GqLSUnL+WjRnr4rm7Vdxt7Xiy86tgbzF1/ZevSlzotJNV6nFb8260d25BjlqNR+c2MWy0AtyxyrV/Ky8mV/nfzgZ2JGU9YxpVxeyPGInOeqyP2ljeSUKDQ0iSdL/Xz45c0fmNGWDXQUT3vH3BGDB+uPk5opWjVfpVKsawxp6AzB1+wFuxInFsv6LlkLB9406MqRa3s9sxvlD/BByXLSg/YeK+tbM9ZqUfyllQ8xBPr70Ew/SRcft0kgUGhqmjo8LAMFnRT+NwhrS2QcDPW1uRT3kwGkxfLMwPvRvTCMXR9Kysnl/7Q4Snompn/+LQpKYXs+fiZ6NAZh/+STTzh0U/Vz+g45Sm7FVevNJ9aHoK3UJTY5gbPAcTj66JHc04R9EoaFh6vzVohF+K47Hj8Ty1YVhaqTHoI55wzd/23iCjEwxcdCrPO8c6mhuyv2kZMat30lmtvi5/RdJkpjo2ZhZ9VshAStvBjPu+HYycsTP7b80qVCbn+t8TFUjR1Ky0/j6+hJ+ub2e9JxMuaMJfxGFhoYxNTfEtZotIFo1iqJP29pYmRsSl/CUDQcvyh2nTDDV1+XXvp0x1NEmOOY+M3YdFpcDCmFQNW9+btoFlULBnqibDAnYQHKmGC78X2z0LPjWcwI9KrZEQmJv7EkmXvyO8GdijpLSQBQaGsjb1xWAoNOin0Zh6WqrGPVOIwCW7ThH4tM0mROVDS4VLPjhnQ4oJIktIdf483Sw3JHKhI6Vq7OsZS8MVdqcjoum1/7VxKeKFsj/olJoMcy5C1/WfB9zbWNiUuP54OL3bL8XSK6Yc0NWotDQQN4N8vppBJ0JI1dcAy60do3cqepYgWepGSzackruOGVGkyqV+aRNUwC+O3CMwzfDZE5UNjSyrcy61v2w1DXgxpOHdN+7kjtifZRX8jJz4xfvT/Cx8CBbncMfYVuYfnWhmHNDRqLQ0EDung7oG+iQ9CRFTEdeBAqFxIR+zQDYevgy4ffEktOFNdCnNr29a6IGJm/aS2jsA7kjlQkeFjZsbTcQZ2Nz7qUk033fSs7Gi6Hpr2KiMuRz95GMdu2JtkJF8JMbjAn6hvOPr8kdTSOJQkMDqVRa+ZN3nT8pZiMsirrulWjm7UJOrpqf1hyVO06ZIUkSn7VvTkPnSqRmZTFqzXbik5/JHatMcDAyZXPbgXhXsCc5M4OBB9ezM0JMUvUqkiTR0a4J8+v8//Tl8+6skTuWRhKFhoaq2zCvn8b5U6KfRlGN69sULaWC05cjOXUpQu44ZYZKqeTHnh1wrWBO/NNnjFqzjZQMMTKgMJ6vj9K2UlUyc3MYd3w7v109IzrXFkIlfRvmek2iR8WWmKgM5I6jkUShoaHqNaoCwM2rd0lOFHMcFIWDtRm9WtcG4MfVgWRnixkJC8tYT5eF/bpiYaBPaNxDJm3aQ3aO6CdUGLpaKhY07crw6vUAmBMcyNQz+8jKFb9/r/K8o+jcmh/IHUUjiUJDQ1WwNsHJ1ZrcXDUXxOiTIhvetQFmRnpExT5h48EQueOUKRXNTPi1b2d0tbQ4ejuCL/ceEd/MC0mpUPB5vZbMqOePQpJYe/sSwwI2ieGvhWSgpSd3BI0kCg0N9rxVQ/TTKDpDfR3e75U3i+OiradJSEqROVHZ4lnRlu97tEMC1l24zKIT5+WOVKYMqV6XP/y6o6el4nhsBD32riLmWaLcsQShQKLQ0GA+TaoCcP7UbXJE83+RdWzqQXUna1LSMvl1wwm545Q5/tVdmdrOD4B5ASfZfum6vIHKGH+HKmxs0x9rPUNuJz2i654VBD24K3csQfgXUWhosOo1K2JkosfTpDRCr4g3qKJSKCQ+HNQcgF3HrnHl9n2ZE5U9A31q5y/A9un2gxy/EylvoDLGw8KG7R0GU8PcmoT0VPoeWCuWmhdKHVFoaDCllpJ6DfMun5w5Lpbzfh01Xe3o1LQGAN8uDxCLYL2Gyf5N6FizGtm5uUxYv4sr9+LkjlSm2OgbsbFNf9r8NSLlgxO7mBMcSK7o9yKUEqLQ0HA+Td0AOHvslsxJyq4xvZtgpK/DraiHbAm4LHecMkehkPi6S+v8OTbeW72NyIQncscqU/RV2vzWrBvve/gC8NvVM7x7ZDPPsjJkTiYIotDQeHV9XVAqFURHPORejJjp8nWYGeszqmfeOigLN50UHUNfg7aWkp96dcTdxorHqWkMX7lFTOhVRApJ4qM6zfixcSe0FUoO3b1D970riX6aKHc0QcOJQkPDGRrpUbOOIwBnjorLJ6+rW4tauFW24llqBj+tPSZ3nDLJUFeHRQO64Whuyr3EZEat20Gq6KRcZF2da7C+TX+s9Ay5lfiIzruXcTI2Uu5YQglZsGABlStXRldXFx8fH86dO/fSff38/JAk6V+3Dh065O8zZMiQf93ftm3bImUShYaAb7NqAJw+ekPmJGWXUqHgk6H+SBLsOxnKhWtiPYrXYWGoz5KB3bEyMuDOw8f8GRZHamaW3LHKnNoV7NjRYTCeFrYkZqYz6NB6llw/L+YrKefWr1/PpEmTmD59OsHBwXh6etKmTRsePCh4baEtW7YQGxubf7t69SpKpZKePXu+sF/btm1f2G/t2rVFyiUKDQFfv7xC41pINElPRLP/63J3tqF7C08A5iwLICMzW+ZEZVNFMxOWDOyOsa4O0akZTNy0h8xs8bMsKht9I9a37U8PFw9y1Gq+uBDAhyd3kZ4tCrfyat68eYwcOZKhQ4fi7u7OwoUL0dfXZ+nSpQXub25ujo2NTf7t4MGD6Ovr/6vQ0NHReWE/MzOzIuUShYaAta0pzlVtyM1Vc/a46BT6Jt7v1RgLEwOi456wfOfLmyyF/1bFypJf+3RCWyFxOiKGDzftFVOVvwZdpRbfN+zAtHotUUoSW8Kv8c4+MblXSUjPyXjjW1FkZmYSFBSEv79//jaFQoG/vz+nT58u1DGWLFlCnz59MDB4cU2YwMBArKyscHNzY/To0SQkFK0/n1aR9hbKrUbNqxF+K46TgaG07lxb7jhllqG+DpMG+vHpL7tZvvMc/g3ccLa3kDtWmeRpb8NgZxuWRzzg4I07TNm2nznd2qJQSHJHK1MkSWJY9XpUM7Ni7NFtXH0cT6ddy/ipaRea2jnJHa/cGnDmc1QG2q/9+KyUvAUHk5OTX9iuo6ODjo7Ov/Z/9OgROTk5WFtbv7Dd2tqaGzdefVn83LlzXL16lSVLlrywvW3btnTv3h0nJyfCwsKYOnUq7dq14/Tp0yiVykKdi2jREABo2Lw6AEGnw0hLFUPi3kTL+lVp7OVMdk4us5ccJDdXXBd/Xa5Geszt3hYthYKdV24wY3eA6GfwmhraOLKzwxBqWdiQmJnO4EPrWXDllJhvo5RzcHDAxMQk/zZ79uxieZ4lS5ZQs2ZN6tev/8L2Pn360LlzZ2rWrEnXrl3ZtWsX58+fJzAwsNDHFi0aAgBOrtbYVjQn9u5jLpy6QxP/GnJHKrMkSeKjIS0J/iSGy7fvs/XwZXr4e8odq8zyq+rEt93bMnnzXjYEXUFPpcUnbZohSaJlo6jsDU3Y0HYAM84eZN2dS3x38Rghj2L5vlEHTLR15Y5Xrqxq8AXGxsav/fjk5GSs+Z2YmJgXjlNQawaApaUlSqWS+Pj4F7bHx8djY2Pzn8+VkpLCunXrmDVr1itzOTs7Y2lpyZ07d2jZsmUhzkS0aAh/kSSJRs3zOoWeOBwqc5qyz9rCiFHv5M2t8cv648QnPJU5UdnW3sONLzq3AmD5mYvMO3RCtGy8Jl2lFt80bMfsBm3RVig5GHObTruWcTVBzMj6Nukqdd74BmBsbPzC7WWFhra2Nt7e3gQEBORvy83NJSAgAF9f3//MunHjRjIyMhgwYMArz+vu3bskJCRga2tb6J+FKDSEfI1bugNw7sQtMjNEz/Q39U4rL2pVsSM1PZPZSw+KD8Y31KN2Daa1bwHAopMXmH/4lPiZvoG+Vb3Y1HYA9gbGRD9LpPvelay/fUnuWMIbmDRpEosWLWL58uWEhoYyevRoUlJSGDp0KACDBg1iypQp/3rckiVL6Nq1KxYWL/Yne/bsGf/73/84c+YMkZGRBAQE0KVLF1xdXWnTpk2hc4lCQ8jnVsMeS2tjUlMyCD4bLnecMk+pUPDpiNZoq5ScvhzJ3pOipehN9avvydS2fgAsPH6OBUfPyBuojKtlacvujkNpYe9CZm4OH5/ey+STu0kTQ2DLpN69e/P9998zbdo0vLy8CAkJYd++ffkdRKOjo4mNjX3hMTdv3uTEiRMMHz78X8dTKpVcvnyZzp07U7VqVYYPH463tzfHjx9/actKQUQfDSGfQqGgcQt3tq09w7FD12jw1zoowuurbGfOiG6+/LrhBD+sOoKPhyMWpgavfqDwUoMa1CY7N5dvDxzjl8AzKCUFo5v5yB2rzDLV0WNxi3f47eoZ5oYcY1PYFa4kxLGgaRdcTS3ljicU0dixYxk7dmyB9xXUgdPNze2lLYN6enrs37//jTOJFg3hBU3+unxy5uhNMsWEU29F//Z1qeZkTXJKBt/8eUg0978Fwxp6M6llXh+Y+UdOsSBQtGy8CYUkMaamL6ta9aGCngE3Ex/Sac9yNoddkTuaUA6IQkN4gbunAxYVjEh5lk7wmTC545QLWkoFn49sjZZSwbHgMPadEpdQ3oZ3m9TPLzZ+DjzNz0cKNymR8HINbRzZ03EYjW0rk5adxYcndzP55G5SxaUU4Q2IQkN4gUKhyB/aeuzgVZnTlB+uDhUY0S2v5/fcFUd48FiMQnkb3m1Sn/+1agLAgqNn+El0EH1jFfQMWN6yF5O8mqCQJDaFXaHb/lXcy0mXO5pQRolCQ/iXpq3yCo3TR2+SkS6+ybwtAzvWw93ZmqepGXy1+ID4QHxLhjeqy8etmwLw67GzYujrW6BUKBhfqxGrW/XBWs+Q8OTHzHsWyerbIeJnKxSZKDSEf6lesyJWNiakpmRw/tRtueOUG1pKBdPebYuOSsmZK1FsDhBDCd+WoQ29mdq2GZA39PXrfYHiA/Et8LVxZG+nYfjZOZONmhkXAng3cAuP01PljiaUIaLQEP5FoVDQrLUHAIH7RGewt8nJ3oL3e+c19f+09hjRsU9kTlR+DGpQhxkd8ubZWHk2hGk7D5GTKxZie1Pmuvr80bQr3XStUf01wVe7nUs5GRspdzShjBCFhlCg54XG2RO3SE0Ra5+8Tb1a1aZejUpkZGYzY6FYlfRt6lPPk9ldW6OQJDYGX+WTrfvFz/ctkCQJPx1zNrXuh4uJBfFpzxhwcB2zg46QmZMjdzyhlBOFhlAg12q2VHS0IDMjm1OBr175Tyg8hULi85FtMNTX4Vp4HH9uF0Mz36ZuXjWY26Nd/kJsEzfuIiNLDNV+G9zNrNjVYQj9qnqhBn6/dpZue1dwO/GR3NGEUkwUGkKBJEmieduaABzee1nmNOWPtYURHw/JW5Bo6bazXLp1T+ZE5Us7Dzd+6t0RbaWSQzfCGLVmG88yMuWOVS7oaan4ukFbFvp1w0xHj2uP4+m4exnLQi+IfjFCgUShIbxU83a1ALh4NownCc9kTlP+tPatRrtG1clVq5n+216epYpLVG9TCzcX/hjQDX1tFacjYhi2YjNPUtPkjlVutK3kxv5Ow2lq50RGTjYzzh9i0KENxKeKodvCi0ShIbyUvYMF1TwqkpurJnC/6BRaHCYPboG9lQmxj5KZs0zMGvq2NXByYPngdzDV0+XyvTgG/bmR+GRRNL8tVvqGLG/Zi5n1W6Gj1OJ4bARtdixhZ4SYlE74f6LQEP5Ti/Z5rRoBe8Tlk+JgqKfDzNHtUCokDpy+ye7j1+WOVO7UtLdh1dBeWBsZcvthAn2XrCP84WO5Y5UbkiQxuJo3uzsMwcPcmsTMdMYd387YY9t5ki5akARRaAiv4NfaAy0tJbdD7xMZ9kDuOOVSTVc73u3REIDvlgcQeV98CL5trlYWrBnem8oWZtxPekq/peu5dDf21Q8UCs3V1JKt7QcxoVYjlJLErshQWu9czOG7d+SOJshMFBrCfzIxM6B+4yoAHNodIm+Ycmxgx3rUq1GJ9MxsPv1lF+mZYkbWt83e1Jg1w3pRy96GxLR0hizfxLHbEXLHKldUCiUfeDVha7tBuJpY8DAthWGHN/HRqT0kZ4opzDWVKDSEV/Lv4AXA4T2XyRFzEhQLpULBjFFtMTPS407MI35YFSh3pHLJ3ECfPwf1oLGLI2lZ2Yxes50tF6/JHavcqWVpy64OQxjhXg8J2HDnMm12LCHwXrjc0QQZiEJDeKV6jatgbKJPwsOnBJ8VK7oWF0tTQ2aMbockwbYjV9h3UnSoKw4GOtr81q8LXWpVJ0etZur2AywIPCM64r5luloqPqvbkg1t+uNoZEps6lOGBGzgo1N7SBKtGxpFFBrCK2lra+XPqXFgx0WZ05RvDWpWZmgXHwC++fMQEfcSZE5UPqmUSmZ3bcO7jesBecvMf7bjIFlilsu3rp61A/s6DWdo9br5rRutty/mUIxYR0lTiEJDKJQ2XWoDcDrwBslJYkGl4jSimy913R1Iy8hi6s+7SBMr6BYLhUJikn9jZnRsiUKS2HzxGqPWbOdZupjP5G3T01IxvZ4/G9r0x9nYnPi0Z4w4spkJx3eIBdo0gCg0hEJxcbPFxc2GrKwcjoiZQouVUqFg1vvtsTAxIPxeAt/8eVA06xejPnVr8WvfzuiptDgZFkW/pRu4n5gsd6xyqZ61A3s6DuW9Gj4oJIntEdfx376I7eHXxO94OSYKDaHQ2nTOa9XYuy1YvCkUMwsTA74a2wGlQmLfqRtsOhQid6Ryza+qMyuH9qKCoT63Hjyi9+K1XLkXJ3escklXS8UU7+ZsbTeIaqYVeJyRxoQTOxl6eCN3nyXJHU8oBqLQEAqtebtaqLS1iLgdz+3Q+3LHKfdqV6vI2D5NAfhh9VEu3xI/8+LkYWfN+hF9qWplycNnqQz8cyMHrot+BMXF09KWHR2GMNmrKdoKJYH3wmm9YzFLQ8+TkytGt5UnotAQCs3YRJ/GLaoDsHdrkMxpNEPftnXw96lKTk4uU37eSUJiityRyjW7v+baaFbFifTsbMZv2MUfx8+JFrxioq1UMrZWQ/Z0GkZ9q4qkZmcx63wA3feu5NrjeLnjCW+JKDSEImnXzRuAI/uukJoiOs0VN0mS+HREa5zsLXiUmMInP+8kK1uMjChOhro6LOjTmYE+XgDMCzjJx1v3iaXmi5GriQXr2vTnS582GKl0uJQQS+fdy/jqwmFSssSqu2WdKDSEIqnlXZmKjhakpWaKhdZKiL6uNt9O6Iyhvg6Xb91n3sojckcq97SUCj5t15xp7VuglCR2XL7BoGUbefBULMhWXBSSxAC32gR0GUkHx2rkqNUsun6OVtsXcyD6ltzxhDcgCg2hSCRJon33ugDs3nRBNCmXkEq2Zsz8azKvLYcvsyXgktyRNEK/+p4sHtgdE10dLt2Lo+cfa7l6XzTpFycrfUMWNOvKny17UtHQhPupybwbuIURhzeJzqJllCg0hCJr1dELlbYWd27GcvPaPbnjaIzGXs6MeqcxAN+vPMLFG3dlTqQZfJ0rsWFkP5wtzYl/+oz+S9ez8/INuWOVe83tXTjYeQTve/iiUig4dPcO/tsXseDKaTLFxGpliig0hCIzNtWnqb87ALs2nZc5jWYZ3KkerRq4kZOTy8fzd3D/gfiGVxIcLUxZP6IPzao4kZGdw/+27GXO/mNki7V/ipWeloqP6jRjT8dh+Fg7kJ6TzXcXj9J25xKO3xcL4pUVotAQXkvHnvUBOHrgKsmJYma/kiJJEp+NaE01J2uSnqXz4bxtPEsTnXJLgpGuDr/27Zw/bfmfp4N4d/VWnqSmyZys/Ktiasm61v34oXFHLHUNCE9+zMBD63n/6Fbup4jJ1Uo7UWgIr6V6zYq4utmSmZHNfrH+SYnS1VHx3cTOWJrmzRw67dc9Yt6BEqJUKJjk35gfe3ZAX6XiVHg07/yxhmui30axkySJbs4eHO46kqHV66KQJPZE3aTl9kUsuHKKjBwxKqi0EoWG8FokSaJTr7xvdrs2nRfLx5cwK3MjvvugCzoqJSdDIvhx9VG5I2mUtjWqsm5EHyqZmXAvMZl+S9eL5eZLiLG2LtPr+bO741DqWVUkLTuL7y4eo/WOvIXaRAf10kcUGsJr82tTE0NjPeLuPeHCyTtyx9E47s42TH+vHQAbDlxkwwHRslSSqlpbsvHdfvn9NqZuP8C0nYfIzBbfrEtCdTMrNrTpz4+NO2GlZ0jU00RGHNnMkICN3EkSqx6XJqLQEF6brp427brVAWD7hnMyp9FMLX2qMqZ33kiUH1YFcjw4TOZEmsVET5ff+nZhfHPfvCXQg67Qb+kG7j4RnXRLgiRJdHWuweGuIxlVowEqhYKj98Npu2MJs84fIikzXe6IAjIXGr/99hu1atXC2NgYY2NjfH192bt3r5yRhCLq3LM+CoXE5QuRJDwQneLkMLBDPbr4eZCrVvPZgt2ERoj+AiVJoZB4v1kD/hjQDRM9Xa7ej6fH76sJvBUudzSNYajS4RNvPw50HoF/RVey1bksDb1A862/s+rmRbJFHyZZyVpoVKxYkW+++YagoCAuXLhAixYt6NKlC9euiWudZYWVrSkNm+etf3L57AOZ02gmSZL4aHBLfGo6kp6ZzaS5W7n/UHyjLmlNXCuz5b3+1LSzJik9g1FrtjP34HHxIVeCnIzNWdziHVb696aKiSWPM9L47Ox+2u9ayjExHFY2shYanTp1on379lSpUoWqVavy1VdfYWhoyJkzZ+SMJRRR936+ANy6/JjEx2LRLzloaSn5elxHXB0seZyUyofzdpCaISY1Kmn2psasHtaL/vW9AFh08gLDV20lMVP02yhJTeyc2NtpGDPrt8JUW5dbiY8YdGg9Y4/vkDuaRtKSO8BzOTk5bNy4kZSUFHx9fQvcJyMjg4yM/58zIDk5+a/HZpOVlVUiOYvD8+xl9RyquNtQpbott0Nj2bXpHAPebS53pNdWll8LHS0F30/sxHtfbyImPpGNJ9No0zoVIwN9uaO9lrL6WkjAJ60aU7uiDdN3BRAcE8sNpQKbG3doUc1V7nivpay+Fv1catHBoSoLrp5h1e2LnIyPkjuSRpLUMo8FunLlCr6+vqSnp2NoaMiaNWto3759gfvOmDGDmTNn/mv7F+PnULOFW3FHFf7D7WuPObg5Ej19LQZO8EBLJfoZy+VRciYrjtwjPSuXKrb69PC1QaGQ5I6lkR5lZLEmIp57aXkrkDapYEJbO3O0xOtR4h7kZHIuKZ7Fw8aRlJSEsbFxsTxPcnIyJiYmb/wcb+s4pYHshUZmZibR0dEkJSWxadMmFi9ezNGjR3F3d//XvgW1aDg4OLDl9510HNqmJGO/VVlZWRw8eJBWrVqhUqnkjvNa0tMyGNJ1Ps+SMhn7SXvadq0jd6TXUh5eC4Dg0Ggmzd1Bdq6a9o2rM2VoSySpbH24lZfXIiUtnQ9XbuDkw7wW2Bq2Vszp2hpHc1N5gxVBeXktEhISsLW1FYVGCZP90om2tjaurnnNid7e3pw/f5758+fz+++//2tfHR0ddHR0/rVdqdQq07/8z6lUqjJ9Hp4+FTh54B7b1p6lffd6KJVlt1WjrL8WdapXomsDa7acjmfPiVDMjPUZ16dpmSs2oOy/FgZA54qW9GrWmGm7ArgW+4Bei9fzeYfmdPV0L1OvSVl/Lcpy9rKs1H0S5ObmvtBqIZQd1WtbYmCky92oBE4fFatbyq2qnQGfDG0JwOo9QazYJRbAk1MLN2e2jR5IPceKpGZlMWXbAT7cvJen6eL9TijfZC00pkyZwrFjx4iMjOTKlStMmTKFwMBA+vfvL2cs4TVp6yjp2MMbgA3LToipgEuB9o2rM6FfMwB+3XCCLYcvy5xIs9maGLFscA8mtmiEUpLYc/UmXX5bxYWou3JHE4RiI2uh8eDBAwYNGoSbmxstW7bk/Pnz7N+/n1atWskZS3gDHXvWQ1tHi5vX7nHpvBi3Xhr0a+fNkM55q+1+u+wQ+06GypxIsykVCkY1rc/qYb1xMDPhflIyA//cyNxDJ8jMFkOShfJH1kJjyZIlREZGkpGRwYMHDzh06JAoMso4MwvD/I6ga/88LnMa4blR7zSiR0tP1GqY9cc+Ai/cljuSxvNysGXrqAF096qBGlh04jx9Fq8j7KFYp0N4fQsWLKBy5cro6uri4+PDuXP/vTxEYmIiY8aMwdbWFh0dHapWrcqePXve6Jj/VOr6aAhl3zsDG6FUKgg5F86NK6JJuDSQJInJg1rQobE7OblqPv1lN6cuiRYnuRnqaPN119b81KsjJnq6XI97QPffV7PiTDC5ueLSo1A069evZ9KkSUyfPp3g4GA8PT1p06YNDx4UPGtzZmYmrVq1IjIykk2bNnHz5k0WLVqEvb39ax+zIKLQEN46a1tTWrSvBcDapcdkTiM8p1BITB3RGn+fqmTn5PLx/B2cuyomMCoNWrtXYcfogTR2cSQjO4ev9x1l6IrN3EtMljua8JpSszLf+FZU8+bNY+TIkQwdOhR3d3cWLlyIvr4+S5cuLXD/pUuX8vjxY7Zt20ajRo2oXLkyzZo1w9PT87WPWRDZh7cK5VOfoU04tOsSZ47dJOxmLC5utnJHEgAtpYKZo9qRmZXDseAwJv+wnR8md8O7uoPc0TSetbEhiwZ0Y92Fy3x74BhnI2Po/OtKprRtRo/aNcrUMFgB6m/6BYWe7ms/Pjctb+XZ5zNgP/eyaR4yMzMJCgpiypQp+dsUCgX+/v6cPn26wOfYsWMHvr6+jBkzhu3bt1OhQgX69evHxx9/jFKpfK1jFkS0aAjFoqKjJc1a1wBg9eKjMqcR/k5LS8lXYzvQ0NOJjMxsJn2/leDQGLljCeRd4upbz5NtowZSx8GOlMxMPttxkHdXbyMu6anc8QQZODg4YGJikn+bPXt2gfs9evSInJwcrK2tX9hubW1NXFxcgY8JDw9n06ZN5OTksGfPHj7//HPmzp3Ll19++drHLIho0RCKTd/hzTh64BonD4cSfjsO5yo2ckcS/qKt0uKb8Z34eP4OTl+O5IPvt/Lj/7pTu1pFuaMJgKOFKSuH9mTZ6WDmHz7F8TuRdPp1JZ+0bUZ3r7I1yZemOvfO2DeeGdR21ExiYmJeOE5BrRmvKzc3FysrK/744w+USiXe3t7cu3eP7777junTp7+15xEtGkKxqexiRdNWea0aq34PlDeM8C862lrMmdCZBn8tLz/xuy1cuB4tdyzhL0qFguGN6rJt1AA87W14mpHBp9sPMHLVVtF3owzQV2m/8Q3A2Nj4hdvLCg1LS0uUSiXx8fEvbI+Pj8fGpuAveba2tlStWhWlUpm/rXr16sTFxZGZmflaxyyIKDSEYtV/ZDMkSeLkkVBuh96XO47wDzraWnw7sQu+tSqTnpnNpLnbOHtFdBAtTZwrmLNmeG8m+zdGW6nkRFgUnX5dwepzIWJkipBPW1sbb29vAgIC8rfl5uYSEBDw0hXRGzVqxJ07d8jNzc3fduvWLWxtbdHW1n6tYxZEFBpCsXJ0tqJ525oArFh4ROY0QkGet2w08srrszH5h22cDAmXO5bwN0qFghGN67Ft9AC8K9mRmpnFF3uOMHDZBsIfPZY7nlBKTJo0iUWLFrF8+XJCQ0MZPXo0KSkpDB06FIBBgwa90LFz9OjRPH78mAkTJnDr1i12797N119/zZgxYwp9zMIQhYZQ7Aa864dCqeDciVuEXhGdDksjHe28PhvNvF3IzMrhox93iEm9SiFnS3NWDunF5+2bo6+tIij6Pl1/W8XCY2fFrKICvXv35vvvv2fatGl4eXkREhLCvn378jtzRkdHExsbm7+/g4MD+/fv5/z589SqVYvx48czYcIEPvnkk0IfszBEoSEUO/tKFvh3yBuXvWxBwCv2FuSirdLi67Ed8fdxIzsnl6k/72LvyetyxxL+QaGQ6F/fi53vD6KxiyOZOTn8ePgUPX5fzcUYcXlS040dO5aoqCgyMjI4e/YsPj4++fcFBgaybNmyF/b39fXlzJkzpKenExYWxtSpU1/os/GqYxaGKDSEEjHgXT9UKiUh5yMIPhsmdxzhJbS0lMx6vx0dmtQgJ1fNzN/3sSXgktyxhALYmxqzaEA3vuveFnN9PW4/TKDfkvXM3BVA8l9zMAhCaSAKDaFEWNua0uGdegAs/fnQC52PhNJFqVDw2YjW9GzlhVoNc5YFsGzHObEabykkSRKdalVn99jB+WumrL1wmQ4LlrP7yk3xmgmlgig0hBLTd3hT9A10uB16n2OHRJN8aaZQSHw4sDlDO+c1kf628QQ/rT0mRjmUUmb6enzdtTXLBr9DZQszHj5L5cPNexixaiuRCU/kjidoOFFoCCXG1MyAdwY2BGDZL4fIzMyWOZHwXyRJYlTPRkzo1wyANXuD+HLRfrJFp8NSq4GTAztGD2Ccny/aSiUnw6Lo9OtKfjp8ivQs8fcmyEMUGkKJ6jGgIeaWRsTee8KujUVbaliQR7923kx/ry1KhcTuE9f5aP4O0tKz5I4lvIS2lhZj/Bqw4/2BNHJxJCsnh1+PnaXDguUcvin6RwklTxQaQonS1dNm0KjmAKxefIynyWkyJxIKo31jd76d2AUdlZKTIRGM+WYjiU/Fa1eaVbYwY/GAbvzYswM2xobcS0zm/bU7GLVmG9GPE+WOJ2gQUWgIJa5159o4uljxLDmNNWLBtTKjcW1nfvmkJ8aGulwLi2PErLXce5AodyzhP0iSRNsaVdk9ZjAjG9VFS6Eg8FYEHRes4MeAk6RmipYpofiJQkMocUqlgpETWwOwY/057sUkyJxIKKxaVe3447Pe2FoaExOXyPCZ67geXvhVHAV5GOho82GrJmwfPYCGzpXIzMlh4fFztP9lGXuuitEpQvEShYYgi3oNq1C3oSvZ2Tks+uGA3HGEInCyt2Dx9D64OVrxJDmVUV9t4GjQHbljCYXgUsGCJQO783PvTtibGhOX/IxJm/Yw4M8NXLsf/+oDCMJrEIWGIJv3JrVFoVRw+ugNMYlXGWNpashvn/bCt1ZlMjKz+Xj+DtbuCxbfjMsASZJoVd2V3WMGM87PF10tLYKi7/POH2v4bPtBHj5NkTuiUM6IQkOQTSWnCnTumTeJ12/f7yU7SwybLEsM9LT5flJXureohVoNP64O5Lvlh8nOEZOxlQW6qrzRKXvHDaFjzWqogU0Xr9Lm5z/5/fg5MRxWeGtEoSHIasB7zTExMyA6/CHb15+VO45QRFpKBR8Nacm4Pk2RJNgccIlJc7fyNEVMgV1W2JoY8X2PdqwZ1pta9jakZmbxQ8BJ2v+yjF1XbohWKuGNiUJDkJWRsR7Dx/kDsOqPQBIePpU5kVBUkiQxoENd5ozvjK62FmevRDF85lpi4sWMlGVJnUp2rBveh++6t8PW2Ij7SU+ZvHkvvRevIyhaLNYmvL63WmjExMQwbNiwt3lIQQO06uRFNY+KpKZksOQn0TG0rGpW15U/Pu+DlbkhUbFPGDZ9DReuRcsdSygChUKiU61q7Bk7mIktGqKvUnH5XhxDVm5hRXgc4Y9E8SgU3VstNB4/fszy5cvf5iEFDaBQKBjzcXskSSJgz2UuXYiQO5LwmtwqW/HnzH7UcLEhOSWD8d9uZsOBi6L5vYzR01YxqqkP+8cPpbd3TZSSxLWkVLr/sYbpOw/x4OkzuSMKZYhWUXbesWPHf94fHh7+RmEEzVXV3Z4OPeqya9N5fvp6F7+tG422dpF+PYVSwtLUkF+n9mT20kPsOxnK3JVHuBH5gI+HtERHvKZlSgUjA2Z28qdf3ZpMWbeN60mprA+6wo7LoQxqUIcRjepipKsjd0yhlCvSX33Xrl2RJOk/v51IkvTGoQTNNHRsS04eCeVu1CM2Lj9B/5F+ckcSXpOutooZ77WlaqUK/LLuOLuPXyPi3iO+mdAZa3MjueMJReRsac5gZxusPbz48chpQu7G8vvxc6y7cJn3mtSnXz1PdFWiiBQKVqRLJ7a2tmzZsoXc3NwCb8HBwcWVU9AAhkZ6vDepLQBrlx7nbtQjmRMJb0KSJPq3r8v8j7pjbKjL9fB4Bn++mos37sodTXhN3pXsWDu8N7/07oSLpTlJael8e+AYbX/+kw1BV8jKEUPUhX8rUqHh7e1NUFDQS+9/VWuHILyKXxsPvH1dycrM5scvd5CbK+ZkKOvqeziyfGZ/XB0seZKcypjZG1m954J4ryijJEnCv7or20cP5KvOrbA1NiIu+RnTdh6i44IV7Lx8gxzxdyv8TZEKjf/97380bNjwpfe7urpy5MiRNw4laC5Jkhg/tSO6etpcCY5i79aXF7ZC2WFnZcKS6X1p26g6Oblqflp7jE9+2smztAy5owmvSUupoEcdD/aNG8LUts0w19cj6nEi/9uyl66/reLA9duimBSAIhYaTZo0oW3bti+938DAgGbNmuX//+7du+IbqVBkNnZmDHm/BQCL5x/k0YNkmRMJb4OuTl6/jY8Gt0RLqSDwwh2GTFvNnZiHckcT3oCOSotBDepwcMIwJrZoiLGuDrcfJjB+wy56/L6GIzfDRcGh4Yp1wi53d3ciIyOL8ymEcqpzb5/8uTXmf7VTvFGVE5Ik0cPfkz8+7421hRExcYkMm7GWHUevite4jDPQ0WZUUx8OTRjG+0190NdWcT3uAaPXbqfnorUE3hIFh6Yq1kJD/FIJr0upVDBpehdUKiXnTtzi0K5LckcS3qIaLras+GIADWo6kpGZzVeLDzDz932kpmfKHU14Q8Z6uoxv0ZCACcMZ0agu+ioVV+/HM2qNKDg0lZiCXCi1HJ2tGDiqOZC36NrD+CSZEwlvk6mRHj9M7s7ono1RKiT2ngxl6PQ14lJKOWFmoMfkVk04NHEYIxrVRU+llV9wvPPHGgJuhImCQ0OIQkMo1d4Z0BC3GvakPEvnxy93iDemckahkBjSuT6/Tu1FBTNDIu8/Ztj0NWw+dEm81uWEuYF+XsExYTjDGnqjp9LiWuwDxqzbQbeFq9l37ZYYpVLOiUJDKNWUWkomz+yGSluLC6fusGfLBbkjCcXAy82eVV8NpKGnExlZOXy7PICpv+whNUPMy1BeWBjq81HrpgRMHM67jeuhr63iRvxDJm7cTadfV7I15JqYh6OcKnShcfny5SKPIBGzhApvQyWnCgwb2xKA3+ft5150gsyJhOJgaqTH3EldmdivGVpKBccvhrP4YAxBoTFyRxPeInMDfSb5N+bwxBG838wHY10dwh89Zsq2A7T9eRlrz18iIytb7pjCW1ToQqN27do8epQ3U6OzszMJCa9+sxdNn8Lb0rVvAzzrOpGRnsWczzaTnSW++ZRHCoVE33beLJ3Rj0o2pjxLz2Hi99v4ee0xMsWHT7liqq/L+OYNOTxxOB/6N8bCQJ97icnM3H2Ylj8uYdGJ8zxNF/OslAeFLjRMTU2JiMhbVTMyMrJQrRvXr1/H0dHx9dMJwl8UCgWTZ3bDwFCXm9fusXpRoNyRhGLkVtmKJdP74OVkhFoNq/ZcYNiMtYTFiGnpyxtDXR1GNq7HoQnD+LSdH3YmRjxKSWXuoRM0/2Excw8eF6vFlnGFLjR69OhBs2bNcHJyQpIk6tati7Ozc4G35xwcHFAqlcUSXNA8VjYmjP+0E5C3FopYTr5809NR0d7bitnjOmBqpMft6IcMmb6a1XsuiM6D5ZCetoqBPrXZP34o33Rtg2sFc55lZLLo5AVa/riUz7YfJPzRY7ljCq+h0Mvt/fHHH3Tv3p07d+4wfvx4Ro4ciZGRWIVRKFl+rT0IOn2HAzsu8u3nW/ht7WiMTfXljiUUoya1nfGsWpGvlhzgZEgEP609xrHgMKa92wZ7K1O54wlvmUqppKuXO51rVSfwVjiLT14gOOY+my5eZfPFq7Rwc2FYQ2/qVLIT/QDLiCKt6/t8+vGgoCAmTJggCg1BFmM+as/1SzHcjXrE3JnbmDGvr3jDKecsTA2YO6kr245c4ae1Rwm5eY/+U1cyvm9TurWoJV7/ckihkGhRzYUW1VwIjr7HkpNBBNwMy7/VsrdhqG8dWlWvgpZSDKAszV7r1fnzzz9FkSHIRldPm6mz30GlUnLm2E22rT0jdyShBEiSRLcWtVj91SDqVKtIWkYWc5YFMH7OZu4/FJO5lWd1KtmzoG9n9owZTC/vmmgrlVy+F8cHm/bQ+qc/+fNUkOg4WoqJMlAok1zcbBn5QRsAFv14gNArYgikprCzMmHBlJ5M7O+HjkrJuWvR9J+6gk2HQsjNFSPdyjPnCubM6uTPkQ9GMKZZA8z09biflMycA8fwm7eYr/cGEvM4Ue6Ywj+IQkMoszr3qk8T/xrk5OTy1ccbSXqSInckoYQoFBJ929Zh1VeD8KxqT2p6Ft8tP8yY2RuJiX8idzyhmFkY6jOuuS9HPhjBF538ca1gTkpmJivOXqT1T38yZu0OzoRHiykWSglRaAhlliRJfPB5Z+wrWfAwPok5n28p8qRyQtlWydaMhZ/2YvKg5ujpqAi+cZf+U1awcvd5snPE70J5p6vSoqd3TXa+P4jFA7rTxLUyaiDgZhhDVmymy2+r2BB0hbTMLLmjajRRaAhlmoGhLp9/2xsdHRVBp++wetFRuSMJJUyhkOjZqjZrvh5EvRqVyMjK4Zd1xxk2fQ03IuPljieUAEmSaOzqyKIB3dgzZjD96nmir1Jx68Ejpu08RLN5i5iz/xh3E5PljqqRRKEhlHlOVawZN7UjAKv+COTMsZsyJxLkYGdlws8f9+DTEa0xNtDhZtQDhk5bw/w1R8Xy8xrEuYI50zq0IHDSCD5u3RQHMxOS0zP483QQPRevkzueRhKFhlAutOroRade9QGY89lmYiLFDJKaSJIkOjfzYN2cIfj7uJGrVrNmbxB9PlnOseAwueMJJchYT5ehDb3ZN24IC/t1obGLIwbaKrljaSRRaAjlxnuT2lDDqxKpKRnM/HAtKU/T5Y4kyMTCxICvxnbgh8ndsLU0Jj7hKf/7YTsf/biduEei+VyTKBUK/Ko6s3hgd7aM7Ct3HI0kCg2h3FCptPj8295YWhsTE/mI2Z9uIkd0CNRoDT2dWPfNYAZ1rIdSqeBoUBi9Pl7Gsh3nxCJtGshYT1fuCBpJFBpCuWJmYciMuX3R0VFx/uRtFs8/IHckQWa6OirG9G7Cyi8G4OVmT0ZmNr9tPEH/qSs5cyVS7niCUO6JQkMod6pUt+PDGV0B2LL6NPu2BckbSCgVXBwsWfhpL2aMaou5iT7RcU+Y8O0WPvlpJ7HicopQTixYsIDKlSujq6uLj48P586dK9Tj1q1bhyRJdO3a9YXtQ4YMQZKkF27PlyMpLFFoCOVSs9YeDHjXD4Cfvt5FyLlweQMJpYIkSbRr5M7Gb4fSp00dlAqJI+dv0/vjZSzacor0DDHfglB2rV+/nkmTJjF9+nSCg4Px9PSkTZs2PHjw4D8fFxkZyeTJk2nSpEmB97dt25bY2Nj829q1a4uUSxQaQrk14F0//Np4kJOTy6z/rSfyjphTQchjqK/DBwP8WPHlAOpUq0hGZjaLt56h98fLOHjmpphRUnhjqZlZb3wrqnnz5jFy5EiGDh2Ku7s7CxcuRF9fn6VLl770MTk5OfTv35+ZM2fi7Oxc4D46OjrY2Njk38zMzIqUq0irtwpCWSJJEh9O78rD+GSuhUTz2fjVzF8+AosKxnJHE0oJV4cK/Dq1J4fP3eantUeJS3jKZwt2s+HARSb2b0YNF1u5IwplVJO5f6DUef3OpzkZeaPmkpNfvKyno6ODjo7Ov/bPzMwkKCiIKVOm5G9TKBT4+/tz+vTplz7PrFmzsLKyYvjw4Rw/frzAfQIDA7GyssLMzIwWLVrw5ZdfYmFhUehzES0aQrmmraNixry+VHS05GF8EtMmrCE1RazyKPw/SZJo6VOV9d8OYWR3X3S1tbh8+z7DZqxl+sK9xD9+KndEQYM5ODhgYmKSf5s9e3aB+z169IicnBysra1f2G5tbU1cXFyBjzlx4gRLlixh0aJFL33+tm3bsmLFCgICApgzZw5Hjx6lXbt25OTkFPocRIuGUO4Zm+jz5U/9mTBkMXduxvLF/9Yza34/VCrx6y/8P11tFSO6+dK5mQcLN55k94nr7DsZypFzt+jT1ptBnephqPfvb5KCUJDjH76LsfHrt54mJydj+81UYmJiXjhOQa0Zr+Pp06cMHDiQRYsWYWlp+dL9+vTpk//vmjVrUqtWLVxcXAgMDKRly5aFei7RoiFoBNuK5nwxvz+6etoEnw3ju2lbxRwbQoGszI2Y9l5bls3qnzccNiuH5TvP0ePDpWw8GEJ2duG/yQmaS19b9cY3AGNj4xduLys0LC0tUSqVxMe/2BctPj4eGxubf+0fFhZGZGQknTp1QktLCy0tLVasWMGOHTvQ0tIiLKzgmXSdnZ2xtLTkzp07hf5ZiEJD0BhuNeyZ9l1vtLSUHD1wld++2yM6/QkvVd3JmoWf9uLbiZ1xtDUj8Wka3684TJ8pywk4e0v87gilira2Nt7e3gQEBORvy83NJSAgAF9f33/tX61aNa5cuUJISEj+rXPnzjRv3pyQkBAcHBwKfJ67d++SkJCArW3h+y+JtmNBo3j7uvK/L7rzzdRN7Nx4HhMzAwa+11zuWEIpJUkSzbxdaeTpxLbAKyzecpqYuESm/rILd2drxvRqQt0aleSOKQgATJo0icGDB1O3bl3q16/Pjz/+SEpKCkOHDgVg0KBB2NvbM3v2bHR1dfHw8Hjh8aampgD52589e8bMmTPp0aMHNjY2hIWF8dFHH+Hq6kqbNm0KnUsUGoLG8WvtwdPEVH6Zs5tVfwRiaKRLt37/rvgF4TktLSXv+HvRrpE7a/ZeYM3eIK6HxzPmm03Ur1GJUT0biREqgux69+7Nw4cPmTZtGnFxcXh5ebFv3778DqLR0dEoFIW/kKFUKrl8+TLLly8nMTEROzs7WrduzRdffFGkviKi0BA0Uqde9UlOSmXFwiMsnLsPbR0tOvSoJ3csoZQz0NNmZPeG9GjpxZ/bz7Dl8GXOXYvm3LVomtZx4b13GuLqUEHumIIGGzt2LGPHji3wvsDAwP987LJly174v56eHvv373/jTLL20Zg9ezb16tXDyMgIKysrunbtys2bN+WMJGiQfiOa0XNwIyBv9tCDO0PkDSSUGeYm+nw4qAUbvxtKhyY1UEgSx4LDGPDpSj7/dTfRsU/kjigIpYashcbRo0cZM2YMZ86c4eDBg2RlZdG6dWtSUlLkjCVoCEmSGD6uFV37+AAwb9Y2jh64KnMqoSyxq2DCtHfbsGb2IFrWr4paDQdO36T3x8uY9fs+YuJFwSEIsl462bdv3wv/X7ZsGVZWVgQFBdG0aVOZUgmaRJIkRk1uR2ZmNnu2BDF3xnZadnWE9nInE8oSJ3sLvh7XkZuRD1i05RTHL4bnzcNxKpTWvm44GmbKHVEQZFOq+mgkJSUBYG5uXuD9GRkZZGT8/6yOz6dmzcnJJiur7C6G9Dy7OAf5jJrclszMbA7tusShrZG4u4fQqqOX3LFeW1l/PaBsnoOzvRmzx3UgNCKepdvPcvpyFHtP3kACwpL2M7RTfSrZFm2diNKgLL4WBSnr+csqSV1KBoPn5ubSuXNnEhMTOXHiRIH7zJgxg5kzZ/5r+xfj51CzhVtxRxTKObVaTeCuaEIvJgDQoosj1TwLP5+/IPzTvYR0ToQ+ISwuFQAJqO5gSMNqpliZiFlGS1pqair9+vUjKSnpjWbt/C/JycmYmJi88XO8reOUBqWm0Bg9ejR79+7lxIkTVKxYscB9CmrRcHBwYMvvO+k4tPBjekubrKwsDh48SKtWrVCpVHLHeS3l4RwAMjIy+XzSUq4HPUKSYMzH7WnbtY7csYqsPLwe5eEcIO88Vqzfyc0EFacuReZvb1LbmUEd61LdyfrlDy4lystr8XyiKVFolKxScelk7Nix7Nq1i2PHjr20yICXr1qnVGqV6V/+51QqVZk/j/JwDs3aO+DsVJldmy7wyzd7yMzIoceAhnLHei3l4fUoD+dga67L8AHtCb/3hGU7znLkwm2OXwzn+MVw6teoxKBO9anr7oAkSXJH/U9l/bUoy9nLMlkLDbVazbhx49i6dSuBgYE4OTnJGUcQgLwOou992AY9Ax02Lj/JHz/s51lyGoNGtyj1HwRC6eZW2YrZ4zsRfi+BlbvOs/9UaP48HNWdrBnUqR7NvF1RFmFSJUEo7WT9bR4zZgyrVq1izZo1GBkZERcXR1xcHGlpaXLGEoT8oa9DxuStTrhmyTF+/W4PubliITbhzTnbWzD9vbZs+n4YvVp5oaOtRWhEPFN+2kXvj5ex5fBl0jNFx0WhfJC10Pjtt99ISkrCz88PW1vb/Nv69evljCUIQF6x0XdYU8Z+0gFJktix/hxzPttCVla23NGEcsKuggkfDmrB9h9GMKyrD8YGOsTEJTLnz0N0nbiYJdvOkPhUfPESyjbZL50IQmnXqWd9DI30+G7aFgL3XyHxSQrTvu2NgZGu3NGEcsLMWJ/3ejRiYId6bA+8yrp9QcQlPOWPzadYvvMc7Ru706dNHSrbFTz0XxBKM3EhUBAKoXnbmnwxvz+6etqEnAvnw5FLefQgWe5YQjmjr6tN37Z12Pz9MGa93x63ylZkZGaz9fBlen+8jElzt3L+WrT4kiaUKaLQEIRC8vZ15ftFQzGzMCTidjwThywm8k683LGEckhLS0kb32osn9Wf36b2pEkdFyQJToZEMPabTfSfuoLtgVdEPw6hTBCFhiAUQZXqdvz45wgqOlryMD6JD4YtIehMmNyxhHJKkiTqVHfg+w+6sOHbofRo6YmuthZhdxP4eslBOk1YxIL1x4l9JFrXhNJLFBqCUEQ29mb8sHQ4HrUdSU3J4LPxq9i54ZzcsYRyrpKNGR8Nacmun95lfN+m2Foak/wsnRW7ztN90hI++nE7F8RlFaEUEoWGILwGY1N9Zv86CP8OnuTm5PLLnN38Mmc3Odk5ckcTyjkjA136t6/L5rnD+HZCZ+rVqESuWs3RoDDGfLOJPp8sZ8OBizxLzXj1wQShBJSKmUEFoSzS1tZi8sxuVHKqwNJfDrFzwznuRSUw9ZueGBnryR1PKOeUCgXN6rrSrK4r4fcS2HQwhD0nrhN5/zFzVx7h1w0naO1bjR4tPXGrbCV3XEGDiRYNQXgDkiTRe2gTpn3XBx1dFcFnwxg38A/RSVQoUc72FnmXVX5+l8mDWuBkb0FaRhbbA68w6PNVDJ2+mh2BV0hLF51HhZInCg1BeAsatajOD0uHY21nSuzdx4wfvIijB67KHUvQMIZ6OvRs5cXa2YNY+GkvWjVwQ0up4Hp4PF8tOUiH8b/z7bIAbkY+kDuqoEHEpRNBeEtc3Gz5ZeV7fD11IxfPhvP1lI3cvnGfoe+3RKmllDueoEEkSaJ2tYrUrlaRx0mp7D5+jW1HLnP3QRKbAy6xOeASbpWt6OpXk9a+1TDUF0vWC8VHtGgIwltkbKrPVz8NoOegRgBsXH6SqWNX8vjRU5mTCZrK3ESfgR3rsfG7Yfz8cQ/8fdxQaSm5GfmAOcsCaD/ud2Ys3EtwaIwYsSIUC9GiIQhvmVJLyYgJrXGtbscPs7YTcj6CMf0W8snX7+BZV6xQLMhDoZCo7+FIfQ9HEp+msffEdbYFXiHy/mP2ngxl78lQKlqZ0LGpB+0aVcfG0ljuyEI5IVo0BKGY+LX24OeV7+LoYsXjhGd8Mno5a5ceEyvACrIzNdKjbztv1n0zmMXT+9DFryb6utrcfZDEwk0n6TppMeO+2cS+k6GkZ4gOpMKbES0aglCMKjlV4KflI/l59i4O7b7EsgUBXAmO4qNZ3TA1N5Q7nqDhJEmipqsdNV3t+KC/H4fP32LX8WsEh97l3LVozl2LRl9Xm+Z1XTFVppGbKy6tCEUnCg1BKGa6etpMntmNWt6V+WXOboJO32FUn9+YPKMbdRu6yh1PEADQ01XRoUkNOjSpwf0HSew5cZ3dJ65z/2ESu09cByDg6nLaNqpOm4bVcba3kDmxUFaISyeCUAIkSaJNlzr8vCLvUsqThGd8Om4lv8/bR2ZmttzxBOEFdlYmjOjuy+bvh7Hws150auqOjpaCuISnLNtxjr6fLGfQZ6tYvecCD588kzuuUMqJFg1BKEGVXa35ecW7LJp/gJ0bzrFl9WlCzkfw8Zc9qOwiZm8USheFQqK2W0U8nK2pZpGGobUbh87d5tSlCG5GPeBm1AN+XneMOtUcaO3rRvN6VTAxFLPiCi8ShYYglDAdXRVjP+6AdwMXfpi1nfBbcYwd8DvDxraka98GKBSioVEofVRKBS3rV6FtI3cSn6YRcPYW+06Fcvn2fYJCYwgKjeG75YfxrVWZVg3caFzbBQM9bbljC6WAKDQEQSa+zarhtt6eH2Zt59zJ2/w+bz+nj97kw+ldsbE3kzueILyUqZEePfw96eHvyf2HSRw8c5MDp29wJ+YRxy+Gc/xiODoqJQ29nGnVwI1Gnk7o6qjkji3IRBQagiAjc0sjZs3vz54tF/jjhwNcDorkvd6/Mny8Px3fqSdaN4RSz66CCYM71Wdwp/qE333EgdM3OXj2JnfjEzly/jZHzt9GV1uLxrWdaelTlYa1RNGhaUShIQgykySJDj3qUbu+C/NmbeNKcBQL5uzh+KHrfPB5F+wczOWOKAiF4lzRklE9LXnvnYbcjHrAwdM3CTh3i9hHyRw6e4tDZ2+hp6OikZcTLepVxdezMvq64vJKeScKDUEoJewczPn29yHs3HiepT8f4nJQJKP6/MqQ91vQpbePWC9FKDMkSaJaZWuqVbZmbJ8mhEbEE3D21r+KDh2Vkga1KuNXtwqNaztjbKArd3ShGIhCQxBKEYVCQZfePvg0rsq8Wdu5dCGC3+ft5/DeK0z8rDOu1WzljigIRSJJEu7ONrg72zC2TxNuRMRz+PxtDp+7xd0HSRwNCuNoUBhKpYK67g74ebvS1NsFS1MxoV15IQoNQSiFbOzN+Oa3QezbFsySnw5yO/Q+4wb9Qfd+DRj4XnN0RW9+oQySJInqzjZUd7bh/V6NuR39kCMXbhN4/g7h9xI4eyWKs1eimLMsAA9XW5p5u9DM2xVHW3H5sCwThYYglFIKhYL23evSoKkbv32/l2MHr7Fp5SmOH7rO+x+1p0FTN7kjCsJrkySJqo5WVHW04r0ejYiKfUzghTscDbrDtbA4rt6J5eqdWBasP4GjrRlNarvQ1NsFD1dblKKTdJkiCg1BKOXMLY349JtetGx/kwVzdhMfm8j0D9bQoJkboz9sJ4bCCuWCo615/uiVh0+ecTw4jMCgOwRdjyEq9glRsRdYtecCpkZ6NPJ0onEdZ3w8Kou5OsoAUWgIQhnRoKkbXvWcWLUokC2rTnPm6E2Cz4TRe0hjeg5qjI6uGDIolA8VzAzp3tKT7i09eZaWwZnLkRwLCuPkpQgSn6ax+691WLSUCupUd6CRlxONvZypaG0qd3ShAKLQEIQyRFdPmxHjW9OqoxcL5uzh0oUIVv4eyP7tFxk5sQ1N/N2RJEnumILw1hjq6eDv44a/jxvZ2TmE3LrHib8mBbsbn8i5q1GcuxrFD6sCcbQ1o5GXMw09nfBys0clRmqVCqLQEIQyyNHZijkLB3Ps4DUW/XiAB3FJfPXJBmp5V2bU5HZUchIrawrlj5aWkrrulajrXomJ/f2Iin3MiYvhnAyJIOTWvb8usQSxZm8Q+roq6tWohG8tJ3xrVcbG0lju+BpLFBqCUEZJkkSz1h74NKnKhuUn2LjiJJeDIhnTbyH+HWth55ojd0RBKFaOtuY42prTv31dnqVmcPZKFKcuR3DqUgSPk1Lzh84CONlbUMtZjF6Rgyg0BKGM09XTZtCoFrTpUoclPx3k6IGrHNx5CS2Vgqyn5vQe0kQMhxXKPUN9HVr6VKWlT1Vyc9Xcin7AqZAITl+O5OqdWCLuJXAn4p7cMTWSKDQEoZywtjVl6uyedOvXgIVz93Hjyl3WLD7Gvq3BDHjPj7Zd6ojZRQWNoFD8/8ykw7o2IDklnfNXozl3+RZBG+ROp3nEYGRBKGeq13Tguz8G0/odJ6ztTHmc8Iyfvt7Fu70WcPzQNdRqtdwRBaFEGRvo0tKnKu9295U7SrFbsGABlStXRldXFx8fH86dO/fSfbds2ULdunUxNTXFwMAALy8vVq5c+cI+arWaadOmYWtri56eHv7+/ty+fbtImUShIQjlkCRJuLqbsXD9aEZPboeJqT53oxL48uMNjB3wO+dP3hYFhyCUM+vXr2fSpElMnz6d4OBgPD09adOmDQ8ePChwf3Nzcz799FNOnz7N5cuXGTp0KEOHDmX//v35+3z77bf89NNPLFy4kLNnz2JgYECbNm1IT08vdC5RaAhCOaZSKenatwF/bp9A/5HN0NPX5s6NWD4bv4oPhy/l0oUIuSMKQrmUlp71xreimjdvHiNHjmTo0KG4u7uzcOFC9PX1Wbp0aYH7+/n50a1bN6pXr46LiwsTJkygVq1anDhxAshrzfjxxx/57LPP6NKlC7Vq1WLFihXcv3+fbdu2FTqX6KMhCBrAwFCXQaNa0Lm3DxuXn2DHhnNcuxTNR+8tw7OuEwNHNadmbUe5YwpCudFh3O8otV9/NdqczLwWg+Tk5Be26+jooKOj86/9MzMzCQoKYsqUKfnbFAoF/v7+nD59+pXPp1arOXz4MDdv3mTOnDkAREREEBcXh7+/f/5+JiYm+Pj4cPr0afr06VOocxEtGoKgQUzNDBg5sQ3Ltk+gU6/6aGkpuXQhgskjlvLxqGVcDoqUO6IgCH/j4OCAiYlJ/m327NkF7vfo0SNycnKwtrZ+Ybu1tTVxcXEvPX5SUhKGhoZoa2vToUMHfv75Z1q1agWQ/7iiHvOfRIuGIGggiwrGjP24A70GNWLdn8fZv/0iIecjCDkfQQ2vSvQd1pS6DV3FLKOC8Jp2//wexsavP0lYcnIyNhs+JSYm5oXjFNSa8SaMjIwICQnh2bNnBAQEMGnSJJydnfHz83trzyEKDUHQYFa2poyf2ok+Q5uwYfkJ9m0L5lpINJ+NX4Wrmy19hjWhUYvqKMRqmYJQJHq6KvTeYP2hrMy8xxobGxeqYLG0tESpVBIfH//C9vj4eGxsbF76OIVCgaurKwBeXl6EhoYye/Zs/Pz88h8XHx+Pra3tC8f08vIq9LmIdw9BELCyNWXsJx1ZtmMi3fv7oqOr4s7NWL78eAMj31nAvm1BZGZmyx1TEISX0NbWxtvbm4CAgPxtubm5BAQE4Otb+GG9ubm5ZGRkAODk5ISNjc0Lx0xOTubs2bNFOqZo0RAEIZ+llTHvTWpLn6FN2LbuLDvWn+Vu1CN++GIHy387Qtc+PnR4py6GRnpyRxUE4R8mTZrE4MGDqVu3LvXr1+fHH38kJSWFoUOHAjBo0CDs7e3z+3nMnj2bunXr4uLiQkZGBnv27GHlypX89ttvQN4w+YkTJ/Lll19SpUoVnJyc+Pzzz7Gzs6Nr166FziUKDUEQ/sXEzIDBo1vQc1Aj9my5wNY1Z3j0IJmlvxxizZJjtOlcm659G2DnINaOEITSonfv3jx8+JBp06YRFxeHl5cX+/bty+/MGR0d/cJl0JSUFN5//33u3r2Lnp4e1apVY9WqVfTu3Tt/n48++oiUlBTeffddEhMTady4Mfv27UNXt/AjakShIQjCS+kb6PDOwEZ06eND4P6rbF55iog78Wxff5YdG87R0K8a3fo1wKO2o+g4KgilwNixYxk7dmyB9wUGBr7w/y+//JIvv/zyP48nSRKzZs1i1qxZr51JFBqCILySSqVFq45e+HfwJPhsOFvXnOb8yducPBLKySOhuLrZ0qWPD35tPNDWef0OcIIglD+i0BAEodAkScK7gQveDVyICn/A1jVnCNhziTs3Y5k7cxuL5x+gbdc6tO9RFxs7M7njCoJQCohRJ4IgvBZHZysmftaZ1Xs+ZNg4f6xsTEhKTGX9shMM6TyfaRNXc/7kbXJzc+WOKgiCjESLhiAIb8TYVJ/eQ5rwzoCGnD1+i12bzhN0Joyzx29x9vgtrO1MadfNmzada2NuaSR3XEEQSpgoNARBeCuUWkoaNq9Ow+bVuRv1iN2bL3Bgx0Xi7yeybEEAKxceoUEzN9p186aOjwtKpWhQFQRNIAoNQRDeuoqOlrw3qS2DR7fg+KHr7Nl6geuXYjh5OJSTh0OpYG1Cq05etOlcGxt70ZdDEMozUWgIglBsdPW0adXJi1advIi4Hc++bUEE7L3Mw/gk1iw+yprFR/Gq50SrTrVp3KI6unrackcWBOEtE4WGIAglwqmKNaP/157h41tx6uhN9m8L5uK58PzF3H75Rpsm/jVo1dELj9qV5I4rCMJbIgoNQRBKlLaOCr/WHvi19iA+NpGA3Zc4sDOE2LuPObDjIgd2XMTa1pRmrWug0E+TO64gCG9IFBqCIMjG2taUfiOa0Xd4U66FRHNwZwjHDl0jPjaRDctPAnA+YDHN29XCr40HFaxNZE4sCEJRiUJDEATZSZKER21HPGo78v5H7Tlz7CaHdodw4dRtwm7FEXYrjiU/HaRmHUeatfagcUt3TM0M5I4tCEIhiEJDEIRSRUdXRbPWHjRs7sbmTTvQU9hz7OB1rl6M4nJQJJeDIlnw7R686jrRrHUNGjavjrGJvtyxBUF4CVFoCIJQaunpa9G+vTddejfgQWwiRw9e5eiBa9wOvU/w2TCCz4bx09e78KrvTJOW7jT0q4aJaOkQhFJFFBqCIJQJVram9BzUmJ6DGnMvJoGjB65y7MA1Iu7EE3T6DkGn7/DT7F3U8q5M4+bVadi8GhYVjOWOLQgaTxQagiCUOfYOFvQb3ox+w5sRE/mIE4evc+LQde7cjCXkXDgh58L5Zc5uqtesSMPm1fFtVg2HypZyxxYEjSQKDUEQyjSHypb0HdaUvsOacj/mMSePhHIqMJTrl2IIvXKX0Ct3WfLTQRwqW+LbrBoNmrpRrWZFMQW6IJQQUWgIglBu2DmY03NQI3oOakTCw6ecCgzl9NGbXDofQUzkI2IiT7Bh+QlMTPWp16gKDZq6UaeBCwaGunJHF4RySxQagiCUSxYVjOjUsz6detYn5Wk650/d5vTRG5w/eYekxFQO7b7Eod2X0NJS4lG7EvUbV6Veoyo4VLZEkiS54wtCuSEKDUEQyj0DI1382tTEr01NsrNyuBoSzdnjNzl7/Bb3ohPyp0H/44f92NibUa+hK3UbVsGrnpNYf0UQ3pAoNARB0ChaKiVe9ZzwqufEe5Paci86gbMnbnHuxC2uBEURd+8JOzeeZ+fG86hUSjzqOOLdwAVvX1ecXK1Fa4cgFJEoNARB0Gj2lSzo3s+X7v18SUvNIOR8BBdO3eH8qdvE30/k4tlwLp4NZ/H8g5hbGFK7gQu16ztTx8dZDJ8VhEKQtdA4duwY3333HUFBQcTGxrJ161a6du0qZyRBEDSYnr4Ovs2q4dusGmq1mrtRCXlzdJwJ49KFCB4nPCNg9yUCdl8CoJJzBerUd8arvjO16lTGwEh0KhWEf5K10EhJScHT05Nhw4bRvXt3OaMIgiC8QJIkHCpb4lDZkq59G5CZmc31kGiCz4Vz8WwYt0NjiQ5/SHT4Q7atO4tCIVGluh1e9Z3xrOtEDU8H0b9DEJC50GjXrh3t2rWTM4IgCEKhaGtr4fVX6wVj/UlOTP2rE2k4IecjuBedwM1r97h57R7r/zyOlpYSNw97PGpXIjUrmfS0TFQqldynIQglrkz10cjIyCAjIyP//8nJyQDk5GSTlZUlV6w39jy7OAf5ifMoPUr7OegZqPD1q4qvX1UAHsYncel8JJeDI7l8IZJHD55yLSSaayHRAOxZ+z1V3O3wqF0JD69KVK9VsczM31HaX4vCKuv5yypJrVar5Q4Bec2Ur+qjMWPGDGbOnPmv7V+Mn0PNFm7FmE4QBKHw1Go1yU8yuRf1lPtRz7gf+ZRnyS9+yEkSWFjrYVvJEFsHQ2wrGfxfe/ce1NSd/w38DYEQVAgil3AJAURRUaBeyA9Xf+qvKFofR56Zp0V3a6njZcef7pRl267utKDbndG2rpe2TNnuU4vd3Yq6rTpP61KViv5WUbeIW9FCARFESLioXEWUfJ8/kLSRiwQ8SYjv10wG8j3fc/L58E08H0++5xyMdONXLVJqa2vDz3/+czQ2NsLdXZqJvE1NTVAqlUN+jSe1HVswrI5obNq0CSkpKcbnTU1NUKvViIiYhOeei7diZENz//59HD9+HPPnzx+2h1btIQeAedgSe8gB6Mrj2LFjiJocg6LL1Sh8eJSjpuo26nV3Ua+7i8sX6gAAvn5KTIpSY2KkGhOnBCIo1NsmLpVuL2PR0NBg7RCeSsOq0HBxcYGLi0uPdpnMaVi/+bs5OzsP+zzsIQeAedgSe8jBwcEBgRpvhIT5Y9H/ng4AaKhrwuWCSlx9WHhcK9FBX9MIfU0jTmYXAgBGjHTBhMmBmBgZiImRakyYHAg3d1er5THcx2I4xz6cDatCg4jIXozxdsfcBZMxd8FkAEBrSzuKLlfhyr8rceXfN1BcWIW21nu4eL4MF8+XGddTB3thwpTArgJkSiCCx/pA5iSzVhpEj2XVQqOlpQWlpaXG5+Xl5bh06RI8PT0RFBRkxciIiCxr5CgFpsWGYVpsGACgs9OA66V6XP3u4V1ov7uB6hu3Ht4crh7H/98lAICLizPCJvohPCIA4ZMDET7JH6qA0byCKdkMqxYa3377LebNm2d83j3/IikpCZmZmVaKiojI+mQyR4wN98PYcD8seT4GAHDndiuKLlehuLAKRYU3UfTwqMdPz24BAHflCIyb5I/wSf4YHxGAcRP9McbbjcUHWYVVC425c+fCRk56ISKyeR6jR+I//jMc//GfXWfZGQwGVFX8eP2O4sIqXPtBj6bGtq4rmub9eMR49JhRGDfRH+Mm+iFsQtdPLx93Fh8kOc7RICIaphwdHREU4o2gEG/M/1/RAICOjgcoL9Hjhys38cP31Sj5vhoV1+pwu6EFFx7ePK6bcvRIhIWrMDbcD2ETuh5+gaPh6Gj9M13IfrDQICKyI3K5U9d8jYgAY1v73Q5cK9Gj5OpNlBTVoLSoBhXX6tB4uxX558qQf+7HyaauI+QIHadCaLgKY8erEDpehYCg0dZIhewECw0iIjuncJVjUqQakyLVxrZ77fdRXqJHaXENyoprUFqsw/VSPe62dTw88+XHOR+Ojg5w95Tj8tl2jA33Q0iYL0LH+cJbpeRXL/RYLDSIiJ5CLgrnrtNkpwQa2zofdOJGRQOuFetQ9kMNyn7Q4doPejTebsWd+nv4nxNX8T8nrhr7jxylQHCYD0LCfBEc5oPgMF+EhPlglJv1rvVBtoeFBhERAQBkTjIEj/VB8Fgf/NdzkQC6Lqeur7mNg/u+hJeHBpXl9Sgv0aOyvA6tLe09zngBAC8fd2hCvaF5uC1NqA+CQr0xYmTPCy6S/WOhQUREfXJwcMAYbzcEhSnx3HMzjVfXvH//AW5cr8f1klqUl+pxvawW10v1qNU1or62CfW1TSZzPwDA21cJzdiuyauaUG8EhfogKMSLR0DsHAsNIiIym7OzU9ek0XEqk/bW5nZUlNeh4mHhcf1aHSrLanGroQV1+kbU6Rvx7dlSk3U8x4yCOsQbQSFeUId4Qx3shaAQb177w06w0CAioidmpJuix8RTAGhqbEPFtTrcKK9DxbU6VF6rQ8W1WjTUNeNWQwtuNbTg39+Wm6zjOkKOQI0X1MFeCNSMQaDGC4HBXghQe0LhyjvdDhcsNIiISHLuyhGY8owGU57RmLS3NrcbL6teWV738Pc6VFfdxt22DpQ8vBbIo7x9lQgMHoPAoDEI6H5oxkDl58F7v9gYFhpERGQ1I90UPc5+AbrmgFTfuIWq6w2oqqjHjYp6VFV0/d7ceNf4NUzB+Wsm68lkjlAFjEaA2hP+ak/4B41BgHoM/NWecJIbLJkaPcRCg4iIbI6zsxM0oV1nrDyq6U4bqiobUHW9HlWVDbj58FFdeQv37t03Pn+UAR2WCN2q0tPT8e6770Kn0yEqKgrvv/8+YmJieu175coVpKamIj8/HxUVFdi5cyeSk5NN+mzevBlbtmwxaQsPD0dRUdGAY2KhQUREw4q7xwhM8hjRYx6IwWBAfW0zqisbUF11q6v4uHGr61F1C21t96wUsWXs378fKSkpyMjIgFarxa5duxAfH4/i4mL4+PQs2Nra2hAaGornn38ev/71r/vcbkREBE6cOGF87uRkXunAQoOIiOyCo6MjfFRK+KiUiI4JNVlmMBhQVlKJ8RPetkgs7Xc7IHce/BGU9rvmr7tjxw6sWbMGK1euBABkZGTgq6++wp49e7Bx48Ye/WfMmIEZM2YAQK/Luzk5OUGlUvW5/HFYaBARkd1zdHSEp5ebxV5vefx2OMkGf4GyB51dR1+amppM2l1cXODi0nO7HR0dyM/Px6ZNm4xtjo6OiIuLQ15e3qDjAICSkhL4+/tDoVAgNjYWW7duRVBQ0IDX5y36iIiIbJRarYZSqTQ+tm7d2mu/+vp6dHZ2wtfX16Td19cXOp1u0K+v1WqRmZmJ7OxsfPjhhygvL8fs2bPR3Nw84G3wiAYREdETtu/rV+Hu7j7o9ZuamuCrehs3btww2U5vRzOktGjRIuPvkZGR0Gq10Gg0OHDgAFatWjWgbbDQICIiesIUrvIhXVSs437Xuu7u7gMqWLy8vCCTyaDX603a9Xr9kOZXPMrDwwPjx49HaWnp4zs/xK9OiIiIhjm5XI5p06YhJyfH2GYwGJCTk4PY2Ngn9jotLS0oKyuDn5/fgNfhEQ0iIiI7kJKSgqSkJEyfPh0xMTHYtWsXWltbjWehvPTSSwgICDDO8+jo6MDVq1eNv9+8eROXLl3CqFGjEBYWBgB49dVXsWTJEmg0GlRXVyMtLQ0ymQzLly8fcFwsNIiIiOxAYmIi6urqkJqaCp1Oh+joaGRnZxsniFZWVsLR8ccvMqqrq/HMM88Yn2/fvh3bt2/HnDlzkJubCwCoqqrC8uXL0dDQAG9vb8yaNQvnzp2Dt7f3gONioUFERGQnNmzYgA0bNvS6rLt46BYcHAwhRL/by8rKGnJMnKNBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJJhoUFERESSYaFBREREkmGhQURERJKxiUIjPT0dwcHBUCgU0Gq1uHDhglnrX/t3hUSRERERDR/m7k8PHjyICRMmQKFQYMqUKTh69KjJciEEUlNT4efnB1dXV8TFxaGkpMSsmKxeaOzfvx8pKSlIS0vDxYsXERUVhfj4eNTW1g54G0fe/wc+/t1nEEJIGCkREZHtMnd/evbsWSxfvhyrVq1CQUEBEhISkJCQgMLCQmOfd955B++99x4yMjJw/vx5jBw5EvHx8Whvbx9wXFYvNHbs2IE1a9Zg5cqVmDRpEjIyMjBixAjs2bPHrO1kbTuE9/77zzAYDBJFSkREZLvM3Z/u3r0bCxcuxGuvvYaJEyfirbfewtSpU/HBBx8A6DqasWvXLrzxxhtYunQpIiMj8emnn6K6uhqHDx8ecFxOTyK5wero6EB+fj42bdpkbHN0dERcXBzy8vIGvJ1f/nEF9ry2H1/+6Thu6e5gUmy4FOFKprOzE8XFRWi92gmZTGbtcAbFHnIAmIctsYccAPvIwx5yAIDm1maLvdbd1nY4y+RDWt8cg9mf5uXlISUlxaQtPj7eWESUl5dDp9MhLi7OuFypVEKr1SIvLw/Lli0bUGxWLTTq6+vR2dkJX19fk3ZfX18UFRX16H/v3j3cu3fP+LyxsREAMG1JJFzdR+CD//6/OH34LE4fPitt4BI5DfPmptgie8gBYB62xB5yAOwjj+GewwPcBwCLfM3+f/xXwgnOg16/O9ampiaTdhcXF7i4uPTob+7+FAB0Ol2v/XU6nXF5d1tffQbCqoWGubZu3YotW7b0aB8/frwVoiEiouGooaEBSqVSkm3L5XLIocA/cfTxnR9j1KhRUKvVJm1paWnYvHnzkLdtSVYtNLy8vCCTyaDX603a9Xo9VCpVj/6bNm0yOcxz584daDQaVFZWSvamsYSmpiao1WrcuHED7u7u1g5nUOwhB4B52BJ7yAGwjzzsIQeg6yh4UFAQPD09JXsNhUIBXX0NOjo6hr6tES5wcHAwaevtaAZg/v4UAFQqVb/9u3/q9Xr4+fmZ9ImOjh5wHlYtNORyOaZNm4acnBwkJCQAAAwGA3JycrBhw4Ye/fs6ZKRUKof1m7+bu7v7sM/DHnIAmIctsYccAPvIwx5yALrmLkhp9BgPSbffG3P3pwAQGxuLnJwcJCcnG9uOHz+O2NhYAEBISAhUKhVycnKMhUVTUxPOnz+PdevWDTg2q391kpKSgqSkJEyfPh0xMTHYtWsXWltbsXLlSmuHRkRENGw8bn/60ksvISAgAFu3bgUAvPLKK5gzZw7++Mc/YvHixcjKysK3336Ljz76CADg4OCA5ORk/OEPf8C4ceMQEhKCN998E/7+/sZiZiCsXmgkJiairq4Oqamp0Ol0iI6ORnZ2do/JJ0RERNS3x+1PKysrTY7mzJw5E5999hneeOMN/O53v8O4ceNw+PBhTJ482djn9ddfR2trK9auXYs7d+5g1qxZyM7OhkKhGHhgYhhrb28XaWlpor293dqhDIk95GEPOQjBPGyJPeQghH3kYQ85CGE/eQw3DkLwcppEREQkDatfGZSIiIjsFwsNIiIikgwLDSIiIpIMCw0iIiKSjM0VGunp6QgODoZCoYBWq8WFC/1fW//gwYOYMGECFAoFpkyZgqNHTS/7KoRAamoq/Pz84Orqiri4OJSUlEiZglk5/PnPf8bs2bMxevRojB49GnFxcT36v/zyy3BwcDB5LFy4UNIcAPPyyMzM7BHjo6c/WWMsAPPymDt3bo88HBwcsHjxYmMfS4/H6dOnsWTJEvj7+8PBwWFAd03Mzc3F1KlT4eLigrCwMGRmZvboY+5nbSjMzeGLL77A/Pnz4e3tDXd3d8TGxuLrr7826bN58+Ye4zBhwgTJcgDMzyM3N7fX99Oj94mw5FgA5ufR23vewcEBERERxj6WHo+tW7dixowZcHNzg4+PDxISElBcXPzY9Wxxn2HvbKrQ2L9/P1JSUpCWloaLFy8iKioK8fHxqK2t7bX/2bNnsXz5cqxatQoFBQVISEhAQkICCgsLjX3eeecdvPfee8jIyMD58+cxcuRIxMfHo73dvDvjSZVDbm4uli9fjpMnTyIvLw9qtRoLFizAzZs3TfotXLgQNTU1xse+ffskiX+weQBdVw38aYwVFRUmyy09FoPJ44svvjDJobCwEDKZDM8//7xJP0uOR2trK6KiopCenj6g/uXl5Vi8eDHmzZuHS5cuITk5GatXrzbZUQ9mfC2Zw+nTpzF//nwcPXoU+fn5mDdvHpYsWYKCggKTfhERESbj8M9//lOK8I3MzaNbcXGxSZw+Pj7GZZYeC8D8PHbv3m0S/40bN+Dp6dnjc2HJ8Th16hTWr1+Pc+fO4fjx47h//z4WLFiA1tbWPtexxX3GU8GqJ9c+IiYmRqxfv974vLOzU/j7+4utW7f22v+FF14QixcvNmnTarXil7/8pRBCCIPBIFQqlXj33XeNy+/cuSNcXFzEvn37JMjA/Bwe9eDBA+Hm5ib27t1rbEtKShJLly590qH2y9w8PvnkE6FUKvvcnjXGQoihj8fOnTuFm5ubaGlpMbZZYzy6ARCHDh3qt8/rr78uIiIiTNoSExNFfHy88flQ/y5DMZAcejNp0iSxZcsW4/O0tDQRFRX15AIz00DyOHnypAAgbt++3Wcfa46FEIMbj0OHDgkHBwdx/fp1Y5u1x6O2tlYAEKdOneqzjy3uM54GNnNEo6OjA/n5+Sb3vXd0dERcXBzy8vJ6XScvL8+kPwDEx8cb+5eXl0On05n0USqV0Gq1fW7T0jk8qq2tDffv3+9x05/c3Fz4+PggPDwc69atQ0NDwxON/acGm0dLSws0Gg3UajWWLl2KK1euGJdZeiyGksdPffzxx1i2bBlGjhxp0m7J8TDX4z4XT+LvYmkGgwHNzc09PhclJSXw9/dHaGgofvGLX6CystJKEfYvOjoafn5+mD9/Ps6cOWNsH45jAXR9LuLi4qDRaEzarTkejY2NANDvDdNsbZ/xtLCZQqO+vh6dnZ1m3fdep9P127/7pznbHIrB5PCo3/72t/D39zd5oy9cuBCffvopcnJy8Pbbb+PUqVNYtGgROjs7n2j83QaTR3h4OPbs2YMjR47gr3/9KwwGA2bOnImqqioAlh8LYOjjceHCBRQWFmL16tUm7ZYeD3P19bloamrC3bt3n8j71NK2b9+OlpYWvPDCC8Y2rVaLzMxMZGdn48MPP0R5eTlmz56N5uZmK0Zqys/PDxkZGfj888/x+eefQ61WY+7cubh48SKAJ/NvhqVVV1fjH//4R4/PhTXHw2AwIDk5GT/72c9MLp/9KFvbZzwtrH6vE/rRtm3bkJWVhdzcXJOJlMuWLTP+PmXKFERGRmLs2LHIzc3Fs88+a41Qe4iNjTXe8Q/ouob+xIkT8ac//QlvvfWWFSMbvI8//hhTpkxBTEyMSftwGA978tlnn2HLli04cuSIydyGRYsWGX+PjIyEVquFRqPBgQMHsGrVKmuE2kN4eDjCw8ONz2fOnImysjLs3LkTf/nLX6wY2eDt3bsXHh4ePW6qZc3xWL9+PQoLCyWfo0ODYzNHNLy8vCCTyaDX603a9Xo9VCpVr+uoVKp++3f/NGebQzGYHLpt374d27Ztw7FjxxAZGdlv39DQUHh5eaG0tHTIMfdmKHl0c3Z2xjPPPGOM0dJjAQwtj9bWVmRlZQ3oH0ipx8NcfX0u3N3d4erq+kTG11KysrKwevVqHDhwoMch70d5eHhg/PjxNjMOfYmJiTHGOJzGAug6I2PPnj1YsWIF5HJ5v30tNR4bNmzAl19+iZMnTyIwMLDfvra2z3ha2EyhIZfLMW3aNOTk5BjbDAYDcnJyTP6n/FOxsbEm/QHg+PHjxv4hISFQqVQmfZqamnD+/Pk+t2npHICuWc5vvfUWsrOzMX369Me+TlVVFRoaGuDn5/dE4n7UYPP4qc7OTly+fNkYo6XHAhhaHgcPHsS9e/fw4osvPvZ1pB4Pcz3uc/EkxtcS9u3bh5UrV2Lfvn0mpxf3paWlBWVlZTYzDn25dOmSMcbhMhbdTp06hdLS0gEV4FKPhxACGzZswKFDh/DNN98gJCTksevY2j7jqWHt2ag/lZWVJVxcXERmZqa4evWqWLt2rfDw8BA6nU4IIcSKFSvExo0bjf3PnDkjnJycxPbt28X3338v0tLShLOzs7h8+bKxz7Zt24SHh4c4cuSI+O6778TSpUtFSEiIuHv3rk3ksG3bNiGXy8Xf//53UVNTY3w0NzcLIYRobm4Wr776qsjLyxPl5eXixIkTYurUqWLcuHGS3oHQ3Dy2bNkivv76a1FWViby8/PFsmXLhEKhEFeuXDHJ1ZJjMZg8us2aNUskJib2aLfGeDQ3N4uCggJRUFAgAIgdO3aIgoICUVFRIYQQYuPGjWLFihXG/teuXRMjRowQr732mvj+++9Fenq6kMlkIjs729jncX8Xa+fwt7/9TTg5OYn09HSTz8WdO3eMfX7zm9+I3NxcUV5eLs6cOSPi4uKEl5eXqK2tlSSHweSxc+dOcfjwYVFSUiIuX74sXnnlFeHo6ChOnDhh7GPpsRhMHt1efPFFodVqe92mpcdj3bp1QqlUitzcXJP3SFtbm7HPcNhnPA1sqtAQQoj3339fBAUFCblcLmJiYsS5c+eMy+bMmSOSkpJM+h84cECMHz9eyOVyERERIb766iuT5QaDQbz55pvC19dXuLi4iGeffVYUFxfbTA4ajUYA6PFIS0sTQgjR1tYmFixYILy9vYWzs7PQaDRizZo1kv4jNJg8kpOTjX19fX3Fc889Jy5evGiyPWuMhbl5CCFEUVGRACCOHTvWY1vWGI/uUyQffXTHnZSUJObMmdNjnejoaCGXy0VoaKj45JNPemy3v7+LtXOYM2dOv/2F6Dpl18/PT8jlchEQECASExNFaWmpZDkMJo+3335bjB07VigUCuHp6Snmzp0rvvnmmx7bteRYDCYPIbpO83R1dRUfffRRr9u09Hj0Fj8Ak/f6cNln2DveJp6IiIgkYzNzNIiIiMj+sNAgIiIiybDQICIiIsmw0CAiIiLJsNAgIiIiybDQICIiIsmw0CAiIiLJsNAgGoaEEFi7di08PT3h4OCAS5cuWTskIqJesdAgGoays7ORmZmJL7/8EjU1Nf3eGhsA0tPTERwcDIVCAa1WiwsXLlgoUiJ62rHQIBqGum9WNXPmTKhUKjg5OfXZd//+/UhJSUFaWhouXryIqKgoxMfHo7a21oIRE9HTipcgJxpmXn75Zezdu9f4XKPR4Pr1633212q1mDFjBj744AMAXXcHVavV+NWvfoWNGzdKHS4RPeV4RINomNm9ezd+//vfIzAwEDU1NfjXv/7VZ9+Ojg7k5+cjLi7O2Obo6Ii4uDjk5eVZIlwiesr1fbyViGySUqmEm5sbZDIZVCpVv33r6+vR2dkJX19fk3ZfX18UFRVJGSYREQAe0SAiIiIJsdAgsmNeXl6QyWTQ6/Um7Xq9/rFHQ4iIngQWGkR2TC6XY9q0acjJyTG2GQwG5OTkIDY21oqREdHTgnM0iOxcSkoKkpKSMH36dMTExGDXrl1obW3FypUrrR0aET0FWGgQ2bnExETU1dUhNTUVOp0O0dHRyM7O7jFBlIhICryOBhEREUmGczSIiIhIMiw0iIaxyspKjBo1qs9HZWWltUMkoqccvzohGsYePHjQ7+XHg4OD+70PChGR1FhoEBERkWT41QkRERFJhoUGERERSYaFBhEREUmGhQYRERFJhoUGERERSYaFBhEREUmGhQYRERFJhoUGERERSeb/A5PV5RwbCfBsAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the objectives as contour plots\n",
+    "for key, obj in objectives_eval.items():\n",
+    "    plt.figure()\n",
+    "    plt.contour(*mesh, obj, label=key)\n",
+    "    plt.title(key)\n",
+    "    plt.xlabel(\"f_0\")\n",
+    "    plt.ylabel(\"f_1\")\n",
+    "    plt.grid(True)\n",
+    "    plt.colorbar()\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}