diff --git a/bayesflow/approximators/continuous_approximator.py b/bayesflow/approximators/continuous_approximator.py index 31a24af47..7b6336236 100644 --- a/bayesflow/approximators/continuous_approximator.py +++ b/bayesflow/approximators/continuous_approximator.py @@ -65,15 +65,20 @@ def build_adapter( summary_variables : Sequence of str, optional Names of the summary variables in the data """ - adapter = Adapter.create_default(inference_variables) + adapter = Adapter() + adapter.to_array() + adapter.convert_dtype("float64", "float32") + adapter.concatenate(inference_variables, into="inference_variables") if inference_conditions is not None: - adapter = adapter.concatenate(inference_conditions, into="inference_conditions") + adapter.concatenate(inference_conditions, into="inference_conditions") if summary_variables is not None: - adapter = adapter.as_set(summary_variables).concatenate(summary_variables, into="summary_variables") + adapter.as_set(summary_variables) + adapter.concatenate(summary_variables, into="summary_variables") - adapter = adapter.keep(["inference_variables", "inference_conditions", "summary_variables"]).standardize() + adapter.keep(["inference_variables", "inference_conditions", "summary_variables"]) + adapter.standardize() return adapter diff --git a/bayesflow/experimental/continuous_time_consistency_model.py b/bayesflow/experimental/continuous_time_consistency_model.py index 6ddc4335b..8819a4431 100644 --- a/bayesflow/experimental/continuous_time_consistency_model.py +++ b/bayesflow/experimental/continuous_time_consistency_model.py @@ -9,7 +9,7 @@ from bayesflow.types import Tensor from bayesflow.utils import ( jvp, - concatenate, + concatenate_valid, find_network, keras_kwargs, expand_right_as, @@ -201,7 +201,7 @@ def consistency_function( **kwargs : dict, optional, default: {} Additional keyword arguments passed to the inner network. """ - xtc = concatenate(x / self.sigma_data, self.time_emb(t), conditions, axis=-1) + xtc = concatenate_valid([x / self.sigma_data, self.time_emb(t), conditions], axis=-1) f = self.subnet_projector(self.subnet(xtc, training=training, **kwargs)) out = ops.cos(t) * x - ops.sin(t) * self.sigma_data * f return out @@ -240,7 +240,7 @@ def compute_metrics(self, x: Tensor, conditions: Tensor = None, stage: str = "tr r = 1.0 # TODO: if consistency distillation training (not supported yet) is unstable, add schedule here def f_teacher(x, t): - o = self.subnet(concatenate(x, self.time_emb(t), conditions, axis=-1), training=stage == "training") + o = self.subnet(concatenate_valid([x, self.time_emb(t), conditions], axis=-1), training=stage == "training") return self.subnet_projector(o) primals = (xt / self.sigma_data, t) @@ -254,7 +254,7 @@ def f_teacher(x, t): cos_sin_dFdt = ops.stop_gradient(cos_sin_dFdt) # calculate output of the network - xtc = concatenate(xt / self.sigma_data, self.time_emb(t), conditions, axis=-1) + xtc = concatenate_valid([xt / self.sigma_data, self.time_emb(t), conditions], axis=-1) student_out = self.subnet_projector(self.subnet(xtc, training=stage == "training")) # calculate the tangent diff --git a/bayesflow/experimental/free_form_flow/free_form_flow.py b/bayesflow/experimental/free_form_flow/free_form_flow.py index 276a12c40..5e4d53155 100644 --- a/bayesflow/experimental/free_form_flow/free_form_flow.py +++ b/bayesflow/experimental/free_form_flow/free_form_flow.py @@ -6,7 +6,7 @@ from bayesflow.utils import ( find_network, keras_kwargs, - concatenate, + concatenate_valid, jacobian, jvp, vjp, @@ -181,7 +181,7 @@ def encode(self, x: Tensor, conditions: Tensor = None, training: bool = False, * if conditions is None: inp = x else: - inp = concatenate(x, conditions, axis=-1) + inp = concatenate_valid([x, conditions], axis=-1) network_out = self.encoder_projector( self.encoder_subnet(inp, training=training, **kwargs), training=training, **kwargs ) @@ -191,7 +191,7 @@ def decode(self, z: Tensor, conditions: Tensor = None, training: bool = False, * if conditions is None: inp = z else: - inp = concatenate(z, conditions, axis=-1) + inp = concatenate_valid([z, conditions], axis=-1) network_out = self.decoder_projector( self.decoder_subnet(inp, training=training, **kwargs), training=training, **kwargs ) diff --git a/bayesflow/networks/flow_matching/flow_matching.py b/bayesflow/networks/flow_matching/flow_matching.py index 3c6366f1b..b6f81befd 100644 --- a/bayesflow/networks/flow_matching/flow_matching.py +++ b/bayesflow/networks/flow_matching/flow_matching.py @@ -45,21 +45,19 @@ class FlowMatching(InferenceNetwork): } INTEGRATE_DEFAULT_CONFIG = { - "method": "rk45", - "steps": "adaptive", - "tolerance": 1e-3, - "min_steps": 10, - "max_steps": 100, + "method": "euler", + "steps": 100, } def __init__( self, subnet: str | type = "mlp", base_distribution: str = "normal", - use_optimal_transport: bool = False, + use_optimal_transport: bool = True, loss_fn: str = "mse", integrate_kwargs: dict[str, any] = None, optimal_transport_kwargs: dict[str, any] = None, + subnet_kwargs: dict[str, any] = None, **kwargs, ): """ @@ -97,23 +95,17 @@ def __init__( self.use_optimal_transport = use_optimal_transport - new_integrate_kwargs = FlowMatching.INTEGRATE_DEFAULT_CONFIG.copy() - new_integrate_kwargs.update(integrate_kwargs or {}) - self.integrate_kwargs = new_integrate_kwargs - - new_optimal_transport_kwargs = FlowMatching.OPTIMAL_TRANSPORT_DEFAULT_CONFIG.copy() - new_optimal_transport_kwargs.update(optimal_transport_kwargs or {}) - self.optimal_transport_kwargs = new_optimal_transport_kwargs + self.integrate_kwargs = FlowMatching.INTEGRATE_DEFAULT_CONFIG | (integrate_kwargs or {}) + self.optimal_transport_kwargs = FlowMatching.OPTIMAL_TRANSPORT_DEFAULT_CONFIG | (optimal_transport_kwargs or {}) self.loss_fn = keras.losses.get(loss_fn) self.seed_generator = keras.random.SeedGenerator() + subnet_kwargs = subnet_kwargs or {} + if subnet == "mlp": - subnet_kwargs = FlowMatching.MLP_DEFAULT_CONFIG.copy() - subnet_kwargs.update(kwargs.get("subnet_kwargs", {})) - else: - subnet_kwargs = kwargs.get("subnet_kwargs", {}) + subnet_kwargs = FlowMatching.MLP_DEFAULT_CONFIG | subnet_kwargs self.subnet = find_network(subnet, **subnet_kwargs) self.output_projector = keras.layers.Dense(units=None, bias_initializer="zeros") @@ -154,23 +146,23 @@ def from_config(cls, config): config = deserialize_value_or_type(config, "subnet") return cls(**config) - def velocity(self, xz: Tensor, t: float | Tensor, conditions: Tensor = None, training: bool = False) -> Tensor: - t = keras.ops.convert_to_tensor(t) - t = expand_right_as(t, xz) - t = keras.ops.broadcast_to(t, keras.ops.shape(xz)[:-1] + (1,)) + def velocity(self, xz: Tensor, time: float | Tensor, conditions: Tensor = None, training: bool = False) -> Tensor: + time = keras.ops.convert_to_tensor(time, dtype=keras.ops.dtype(xz)) + time = expand_right_as(time, xz) + time = keras.ops.broadcast_to(time, keras.ops.shape(xz)[:-1] + (1,)) if conditions is None: - xtc = keras.ops.concatenate([xz, t], axis=-1) + xtc = keras.ops.concatenate([xz, time], axis=-1) else: - xtc = keras.ops.concatenate([xz, t, conditions], axis=-1) + xtc = keras.ops.concatenate([xz, time, conditions], axis=-1) return self.output_projector(self.subnet(xtc, training=training), training=training) def _velocity_trace( - self, xz: Tensor, t: Tensor, conditions: Tensor = None, max_steps: int = None, training: bool = False + self, xz: Tensor, time: Tensor, conditions: Tensor = None, max_steps: int = None, training: bool = False ) -> (Tensor, Tensor): def f(x): - return self.velocity(x, t, conditions=conditions, training=training) + return self.velocity(x, time=time, conditions=conditions, training=training) v, trace = jacobian_trace(f, xz, max_steps=max_steps, seed=self.seed_generator, return_output=True) @@ -181,8 +173,8 @@ def _forward( ) -> Tensor | tuple[Tensor, Tensor]: if density: - def deltas(t, xz): - v, trace = self._velocity_trace(xz, t, conditions=conditions, training=training) + def deltas(time, xz): + v, trace = self._velocity_trace(xz, time=time, conditions=conditions, training=training) return {"xz": v, "trace": trace} state = {"xz": x, "trace": keras.ops.zeros(keras.ops.shape(x)[:-1] + (1,), dtype=keras.ops.dtype(x))} @@ -193,8 +185,8 @@ def deltas(t, xz): return z, log_density - def deltas(t, xz): - return {"xz": self.velocity(xz, t, conditions=conditions, training=training)} + def deltas(time, xz): + return {"xz": self.velocity(xz, time=time, conditions=conditions, training=training)} state = {"xz": x} state = integrate(deltas, state, start_time=1.0, stop_time=0.0, **(self.integrate_kwargs | kwargs)) @@ -208,8 +200,8 @@ def _inverse( ) -> Tensor | tuple[Tensor, Tensor]: if density: - def deltas(t, xz): - v, trace = self._velocity_trace(xz, t, conditions=conditions, training=training) + def deltas(time, xz): + v, trace = self._velocity_trace(xz, time=time, conditions=conditions, training=training) return {"xz": v, "trace": trace} state = {"xz": z, "trace": keras.ops.zeros(keras.ops.shape(z)[:-1] + (1,), dtype=keras.ops.dtype(z))} @@ -220,8 +212,8 @@ def deltas(t, xz): return x, log_density - def deltas(t, xz): - return {"xz": self.velocity(xz, t, conditions=conditions, training=training)} + def deltas(time, xz): + return {"xz": self.velocity(xz, time=time, conditions=conditions, training=training)} state = {"xz": z} state = integrate(deltas, state, start_time=0.0, stop_time=1.0, **(self.integrate_kwargs | kwargs)) @@ -258,7 +250,7 @@ def compute_metrics( base_metrics = super().compute_metrics(x1, conditions, stage) - predicted_velocity = self.velocity(x, t, conditions, training=stage == "training") + predicted_velocity = self.velocity(x, time=t, conditions=conditions, training=stage == "training") loss = self.loss_fn(target_velocity, predicted_velocity) loss = keras.ops.mean(loss) diff --git a/bayesflow/utils/__init__.py b/bayesflow/utils/__init__.py index 2854b016e..ecb546eae 100644 --- a/bayesflow/utils/__init__.py +++ b/bayesflow/utils/__init__.py @@ -48,7 +48,7 @@ ) from .serialization import serialize_value_or_type, deserialize_value_or_type from .tensor_utils import ( - concatenate, + concatenate_valid, expand, expand_as, expand_to, @@ -59,12 +59,13 @@ expand_right_as, expand_right_to, expand_tile, + pad, + searchsorted, size_of, + stack_valid, tile_axis, tree_concatenate, tree_stack, - pad, - searchsorted, ) from .validators import check_lengths_same from .workflow_utils import find_inference_network, find_summary_network diff --git a/bayesflow/utils/dict_utils.py b/bayesflow/utils/dict_utils.py index cb6f61647..7e9fb67f0 100644 --- a/bayesflow/utils/dict_utils.py +++ b/bayesflow/utils/dict_utils.py @@ -49,7 +49,7 @@ def convert_kwargs(f: Callable, *args: any, **kwargs: any) -> dict[str, any]: return parameters -def filter_kwargs(kwargs: Mapping[str, T], f: Callable) -> Mapping[str, T]: +def filter_kwargs(kwargs: dict[str, T], f: Callable) -> dict[str, T]: """Filter keyword arguments for f""" signature = inspect.signature(f) @@ -63,11 +63,10 @@ def filter_kwargs(kwargs: Mapping[str, T], f: Callable) -> Mapping[str, T]: return kwargs -def keras_kwargs(kwargs: Mapping[str, T]) -> dict[str, T]: - """Keep dictionary keys that do not end with _kwargs. Used for propagating - keyword arguments in nested layer classes. - """ - return {key: value for key, value in kwargs.items() if not key.endswith("_kwargs")} +def keras_kwargs(kwargs: dict[str, T]) -> dict[str, T]: + """Filter keyword arguments for keras.Layer""" + valid_keys = ["dtype", "name", "trainable"] + return {key: value for key, value in kwargs.items() if key in valid_keys} # TODO: rename and streamline and make protected diff --git a/bayesflow/utils/integrate.py b/bayesflow/utils/integrate.py index ab652f401..a932424f5 100644 --- a/bayesflow/utils/integrate.py +++ b/bayesflow/utils/integrate.py @@ -3,6 +3,8 @@ import keras +from typing import Literal + from bayesflow.types import Tensor from bayesflow.utils import filter_kwargs from . import logging @@ -238,8 +240,8 @@ def integrate( stop_time: ArrayLike, min_steps: int = 10, max_steps: int = 10_000, - steps: int = "adaptive", - method: str = "rk45", + steps: int | Literal["adaptive"] = 100, + method: str = "euler", **kwargs, ) -> dict[str, ArrayLike]: match steps: diff --git a/bayesflow/utils/optimal_transport/sinkhorn.py b/bayesflow/utils/optimal_transport/sinkhorn.py index 2900e54a9..5fb41854b 100644 --- a/bayesflow/utils/optimal_transport/sinkhorn.py +++ b/bayesflow/utils/optimal_transport/sinkhorn.py @@ -6,6 +6,7 @@ from ..dispatch import find_cost from .. import logging from ..numpy_utils import softmax +from ..tensor_utils import is_symbolic_tensor def sinkhorn( @@ -134,8 +135,8 @@ def sinkhorn_indices( rng = np.random.default_rng(seed) indices = [] - for row in range(cost.shape[0]): - index = rng.choice(cost.shape[1], p=plan[row]) + for row in range(plan.shape[0]): + index = rng.choice(plan.shape[1], p=plan[row]) indices.append(index) indices = np.array(indices) @@ -190,6 +191,9 @@ def sinkhorn_plan_keras(cost: Tensor, regularization: float, max_steps: int, tol # initialize the transport plan from a gaussian kernel plan = keras.ops.exp(-0.5 * cost / regularization) + if is_symbolic_tensor(plan): + return plan + def is_converged(plan): # check convergence: the plan should be doubly stochastic marginals = keras.ops.sum(plan, axis=0), keras.ops.sum(plan, axis=1) diff --git a/bayesflow/utils/tensor_utils.py b/bayesflow/utils/tensor_utils.py index a832daa49..b65df49a7 100644 --- a/bayesflow/utils/tensor_utils.py +++ b/bayesflow/utils/tensor_utils.py @@ -10,6 +10,16 @@ T = TypeVar("T") +def concatenate_valid(tensors: Sequence[Tensor | None], axis: int = 0) -> Tensor | None: + """Concatenate multiple tensors along axis, ignoring None values.""" + tensors = [t for t in tensors if t is not None] + + if not tensors: + return None + + return keras.ops.concatenate(tensors, axis=axis) + + def expand(x: Tensor, n: int, side: str): if n < 0: raise ValueError(f"Cannot expand {n} times.") @@ -83,6 +93,28 @@ def expand_tile(x: Tensor, n: int, axis: int) -> Tensor: return tile_axis(x, n, axis=axis) +def is_symbolic_tensor(x: Tensor) -> bool: + if keras.utils.is_keras_tensor(x): + return True + + if not keras.ops.is_tensor(x): + return False + + match keras.backend.backend(): + case "jax": + import jax + + return not jax.core.is_concrete(x) + case "tensorflow": + import tensorflow as tf + + return tf.is_symbolic_tensor(x) + case "torch": + return False + case _: + raise NotImplementedError(f"Symbolic tensor check not implemented for backend {keras.backend.backend()!r}") + + def pad(x: Tensor, value: float | Tensor, n: int, axis: int, side: str = "both") -> Tensor: """ Pad x with n values along axis on the given side. @@ -108,6 +140,55 @@ def pad(x: Tensor, value: float | Tensor, n: int, axis: int, side: str = "both") raise TypeError(f"Invalid side type {type(side)!r}. Must be str.") +def searchsorted(sorted_sequence: Tensor, values: Tensor, side: str = "left") -> Tensor: + """ + Find indices where elements should be inserted to maintain order. + """ + + match keras.backend.backend(): + case "jax": + import jax + import jax.numpy as jnp + + logging.warn_once(f"searchsorted is not yet optimized for backend {keras.backend.backend()!r}") + + # do not vmap over the side argument (we have to pass it as a positional argument) + in_axes = [0, 0, None] + + # vmap over the batch dimension + vss = jax.vmap(jnp.searchsorted, in_axes=in_axes) + + # flatten all batch dimensions + ss = sorted_sequence.reshape((-1,) + sorted_sequence.shape[-1:]) + v = values.reshape((-1,) + values.shape[-1:]) + + # noinspection PyTypeChecker + indices = vss(ss, v, side) + + # restore the batch dimensions + indices = indices.reshape(values.shape) + + # noinspection PyTypeChecker + return indices + case "tensorflow": + import tensorflow as tf + + # always use int64 to avoid complicated graph code + indices = tf.searchsorted(sorted_sequence, values, side=side, out_type="int64") + + return indices + case "torch": + import torch + + out_int32 = len(sorted_sequence) <= np.iinfo(np.int32).max + + indices = torch.searchsorted(sorted_sequence, values, side=side, out_int32=out_int32) + + return indices + case _: + raise NotImplementedError(f"Searchsorted not implemented for backend {keras.backend.backend()!r}") + + def size_of(x) -> int: """ :param x: A nested structure of tensors. @@ -126,6 +207,16 @@ def size_of(x) -> int: return sum(size_of(tensor) for tensor in x.values()) +def stack_valid(tensors: Sequence[Tensor | None], axis: int = 0) -> Tensor | None: + """Stack multiple tensors along axis, ignoring None values.""" + tensors = [t for t in tensors if t is not None] + + if not tensors: + return None + + return keras.ops.stack(tensors, axis=axis) + + def tile_axis(x: Tensor, n: int, axis: int) -> Tensor: """Tile x along the given axis n times""" repeats = [1] * keras.ops.ndim(x) @@ -169,11 +260,6 @@ def concat(*items): return keras.tree.map_structure(concat, *structures) -def concatenate(*tensors: Sequence[Tensor], axis=0): - """Concatenate multiple tensors along axis, some of which can be None.""" - return keras.ops.concatenate([t for t in tensors if t is not None], axis=axis) - - def tree_stack(structures: Sequence[T], axis: int = 0, numpy: bool = None) -> T: """Like :func:`tree_concatenate`, except tensors are stacked instead of concatenated.""" if numpy is None: @@ -191,52 +277,3 @@ def stack(*items): return keras.ops.stack(items, axis=axis) return keras.tree.map_structure(stack, *structures) - - -def searchsorted(sorted_sequence: Tensor, values: Tensor, side: str = "left") -> Tensor: - """ - Find indices where elements should be inserted to maintain order. - """ - - match keras.backend.backend(): - case "jax": - import jax - import jax.numpy as jnp - - logging.warn_once(f"searchsorted is not yet optimized for backend {keras.backend.backend()!r}") - - # do not vmap over the side argument (we have to pass it as a positional argument) - in_axes = [0, 0, None] - - # vmap over the batch dimension - vss = jax.vmap(jnp.searchsorted, in_axes=in_axes) - - # flatten all batch dimensions - ss = sorted_sequence.reshape((-1,) + sorted_sequence.shape[-1:]) - v = values.reshape((-1,) + values.shape[-1:]) - - # noinspection PyTypeChecker - indices = vss(ss, v, side) - - # restore the batch dimensions - indices = indices.reshape(values.shape) - - # noinspection PyTypeChecker - return indices - case "tensorflow": - import tensorflow as tf - - # always use int64 to avoid complicated graph code - indices = tf.searchsorted(sorted_sequence, values, side=side, out_type="int64") - - return indices - case "torch": - import torch - - out_int32 = len(sorted_sequence) <= np.iinfo(np.int32).max - - indices = torch.searchsorted(sorted_sequence, values, side=side, out_int32=out_int32) - - return indices - case _: - raise NotImplementedError(f"Searchsorted not implemented for backend {keras.backend.backend()!r}") diff --git a/bayesflow/workflows/basic_workflow.py b/bayesflow/workflows/basic_workflow.py index d2cf15431..27ec7506d 100644 --- a/bayesflow/workflows/basic_workflow.py +++ b/bayesflow/workflows/basic_workflow.py @@ -28,7 +28,7 @@ def __init__( inference_network: InferenceNetwork | str = "coupling_flow", summary_network: SummaryNetwork | str = None, initial_learning_rate: float = 5e-4, - optimizer: type = None, + optimizer: keras.optimizers.Optimizer | type = None, checkpoint_filepath: str = None, checkpoint_name: str = "model", save_weights_only: bool = False, diff --git a/examples/SIR_Posterior_Estimation.ipynb b/examples/SIR_Posterior_Estimation.ipynb index 4a4b1786d..c1ab7fc5a 100644 --- a/examples/SIR_Posterior_Estimation.ipynb +++ b/examples/SIR_Posterior_Estimation.ipynb @@ -1,21 +1,20 @@ { "cells": [ { - "cell_type": "markdown", - "id": "01fcb38f", "metadata": {}, + "cell_type": "markdown", "source": [ "# Posterior Estimation for SIR-like Models\n", "\n", "_Author: Stefan T. Radev_" - ] + ], + "id": "bdff5b1d08cd2bca" }, { - "cell_type": "code", - "execution_count": 1, - "id": "presidential-density", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "import datetime\n", "\n", @@ -36,12 +35,12 @@ "sys.path.append('../')\n", "\n", "import bayesflow as bf" - ] + ], + "id": "684f2d7e19d40e09" }, { - "cell_type": "markdown", - "id": "polished-warning", "metadata": {}, + "cell_type": "markdown", "source": [ "## Introduction \n", "\n", @@ -50,30 +49,26 @@ "The details for tackling stochastic epidemiological models with neural networks are described in our corresponding paper, which you can consult for a more formal exposition and a more comprehensive treatment of neural architectures:\n", "\n", "OutbreakFlow: Model-based Bayesian inference of disease outbreak dynamics with invertible neural networks and its application to the COVID-19 pandemics in Germany https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1009472" - ] + ], + "id": "576d14f2d1f377b9" }, { - "cell_type": "markdown", - "id": "corrected-little", "metadata": {}, - "source": [ - "## Defining the Simulator " - ] + "cell_type": "markdown", + "source": "## Defining the Simulator ", + "id": "c25067d290a9a3e4" }, { - "cell_type": "code", - "execution_count": 2, - "id": "ed081448", "metadata": {}, + "cell_type": "code", "outputs": [], - "source": [ - "RNG = np.random.default_rng(2024)" - ] + "execution_count": null, + "source": "RNG = np.random.default_rng(2024)", + "id": "81c104ae86c4f59a" }, { - "cell_type": "markdown", - "id": "appropriate-chester", "metadata": {}, + "cell_type": "markdown", "source": [ "As described in our [very first notebook](Quickstart_Amortized_Posterior_Estimation.ipynb), a generative model consists of a prior (encoding suitable parameter ranges) and a simulator (generating data given simulations). Our underlying model distinguishes between susceptible, $S$, infected, $I$, and recovered, $R$, individuals with infection and recovery occurring at a constant transmission rate $\\lambda$ and constant recovery rate $\\mu$, respectively. The model dynamics are governed by the following system of ODEs:\n", "\n", @@ -95,20 +90,18 @@ "\n", "In this way, we connect the latent disease model to an observation model, which renders the relationship between parameters and data a stochastic one. Note, that the observation model induces a further parameter $\\psi$, responsible for the dispersion of the noise.\n", "Finally, we will also treat the number of initially infected individuals, $I_0$ as an unknown parameter (having its own prior distribution)." - ] + ], + "id": "39846c15b88eaf8e" }, { - "cell_type": "markdown", - "id": "killing-feelings", "metadata": {}, - "source": [ - "### Prior " - ] + "cell_type": "markdown", + "source": "### Prior ", + "id": "36a6e034f7329fdb" }, { - "cell_type": "markdown", - "id": "ideal-median", "metadata": {}, + "cell_type": "markdown", "source": [ "We will place the following prior distributions over the five model parameters, summarized in the table below:\n", "\n", @@ -128,14 +121,14 @@ "$$\n", "\n", "How did we come up with these priors? In this case, we rely on the domain expertise and previous research (https://www.science.org/doi/10.1126/science.abb9789). In addition, the new parameter $\\psi$ follows an exponential distribution, which restricts it to positive numbers. Below is the implementation of these priors:" - ] + ], + "id": "3654ae4f3f243509" }, { - "cell_type": "code", - "execution_count": 3, - "id": "supported-builder", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "def prior():\n", " \"\"\"Generates a random draw from the joint prior.\"\"\"\n", @@ -146,27 +139,20 @@ " I0 = RNG.gamma(shape=2, scale=20)\n", " psi = RNG.exponential(5)\n", " return {\"lambd\": lambd, \"mu\": mu, \"D\": D, \"I0\": I0, \"psi\": psi}" - ] + ], + "id": "be2c630b4527ae40" }, { - "cell_type": "markdown", - "id": "sized-tamil", "metadata": {}, - "source": [ - "### Observation Model (Implicit Likelihood Function) " - ] + "cell_type": "markdown", + "source": "### Observation Model (Implicit Likelihood Function) ", + "id": "de749b48ab53d91" }, { + "metadata": {}, "cell_type": "code", - "execution_count": 4, - "id": "fourth-reconstruction", - "metadata": { - "code_folding": [ - 2, - 14 - ] - }, "outputs": [], + "execution_count": null, "source": [ "from scipy.stats import nbinom\n", "\n", @@ -216,32 +202,30 @@ " reparam = convert_params(np.clip(np.array(C[D:]), 0, N) + eps, psi)\n", " C_obs = RNG.negative_binomial(reparam[0], reparam[1])\n", " return dict(cases=C_obs)" - ] + ], + "id": "9e599e5cc2e0ff37" }, { - "cell_type": "markdown", - "id": "characteristic-reasoning", "metadata": {}, - "source": [ - "As you can see, in addition to the parameters, our simulator requires two further arguments: the total population size $N$ and the time horizon $T$. These are quantities over which we can amortize (i.e., context variables), but for this example, we will just use the population of Germany and the first two weeks of the pandemics (i.e., $T=14$), in the same vein as https://www.science.org/doi/10.1126/science.abb9789." - ] + "cell_type": "markdown", + "source": "As you can see, in addition to the parameters, our simulator requires two further arguments: the total population size $N$ and the time horizon $T$. These are quantities over which we can amortize (i.e., context variables), but for this example, we will just use the population of Germany and the first two weeks of the pandemics (i.e., $T=14$), in the same vein as https://www.science.org/doi/10.1126/science.abb9789.", + "id": "2e7e1dc9545f948a" }, { - "cell_type": "markdown", - "id": "rotary-queen", "metadata": {}, + "cell_type": "markdown", "source": [ "### Loading Real Data \n", "\n", "We will define a simple helper function to load the actually reported cases in 2020 for the first two weeks of the Covid-19 pandemic in Germany." - ] + ], + "id": "85d3204086674397" }, { - "cell_type": "code", - "execution_count": 5, - "id": "adolescent-employee", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "def load_data():\n", " \"\"\"Helper function to load cumulative cases and transform them to new cases.\"\"\"\n", @@ -260,93 +244,68 @@ " )[0]\n", " new_cases_obs = np.diff(cases_obs)\n", " return new_cases_obs" - ] + ], + "id": "59f5305859288ca0" }, { - "cell_type": "markdown", - "id": "legal-tokyo", "metadata": {}, + "cell_type": "markdown", "source": [ "### Stitiching Things Together \n", "We can combine the prior $p(\\theta)$ and the observation model $p(x_{1:T}\\mid\\theta)$ into a joint model $p(\\theta, x_{1:T}) = p(\\theta) \\; p(x_{1:T}\\mid\\theta)$ using the `make_simulator` builder.\n", "The resulting object can now generate *batches* of simulations." - ] + ], + "id": "260da93b2f20a502" }, { - "cell_type": "code", - "execution_count": 6, - "id": "adequate-fleece", "metadata": {}, + "cell_type": "code", "outputs": [], - "source": [ - "simulator = bf.make_simulator([prior, stationary_SIR])" - ] + "execution_count": null, + "source": "simulator = bf.make_simulator([prior, stationary_SIR])", + "id": "6a4e209c4ac07598" }, { - "cell_type": "code", - "execution_count": 7, - "id": "457d5692", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(2, 1)\n", - "(2, 1)\n", - "(2, 14)\n", - "CPU times: user 1.01 ms, sys: 182 μs, total: 1.19 ms\n", - "Wall time: 1.13 ms\n" - ] - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "%%time\n", "test_sims = simulator.sample(batch_size=2)\n", "print(test_sims[\"lambd\"].shape)\n", "print(test_sims[\"D\"].shape)\n", "print(test_sims[\"cases\"].shape)" - ] + ], + "id": "bb375d6690435d31" }, { - "cell_type": "markdown", - "id": "chemical-cleaner", "metadata": {}, + "cell_type": "markdown", "source": [ "## Prior Checking \n", "\n", "Any principled Bayesian workflow requires some prior predictive or prior pushforward checks to ensure that the prior specification is consistent with domain expertise (see https://betanalpha.github.io/assets/case_studies/principled_bayesian_workflow.html). The BayesFlow library provides some rudimentary visual tools for performing prior checking. For instance, we can visually inspect the joint prior in the form of bivariate plots. We can focus on particular parameter combinations, such as $\\lambda$, $\\mu$, and $D$:" - ] + ], + "id": "572000649eee6d15" }, { - "cell_type": "code", - "execution_count": 8, - "id": "97c7ebe7", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuUAAALlCAYAAABjOpj+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZwcV3nv/a2q3qdnX7Tvi21Ziy3JkozBxGxxMAmYJQSzhCW5eQnJG5KbcG8gELgkwSHhTbg3Dp9LINiEJcEGh4CxCd6CsS3JWqzVWmY0I2lmNJqZnt7XWs77R3XVdM/0bNJsPXO+nw9Y0+vp6jpdv/Oc5/k9ihBCIJFIJBKJRCKRSOYMda4HIJFIJBKJRCKRLHakKJdIJBKJRCKRSOYYKcolEolEIpFIJJI5RopyiUQikUgkEolkjpGiXCKRSCQSiUQimWOkKJdIJBKJRCKRSOYYKcolEolEIpFIJJI5RopyiUQikUgkEolkjpGi/DqxLIvu7m4sy5rroUgkiwIhBIlEAtn3TCKZeeR8k0hmDynKr5Pe3l5WrVpFb2/vNT3fNE3OnDmDaZrTPLLFjTyuM8N8OK7JZJL6+noOHz5cFd/vfDhmU0GOd+aoprE6OPMtmUzO6PtU47GZKeSxGGaxHQspyiUSiUQikUgkkjlGinKJRCKRSCQSiWSOkaJcIpFIJBKJRCKZY6Qol0gkEolEIpFI5piqFeVPP/00H/7wh7nxxhupqalhxYoVvPWtb+Xw4cOTen5/fz8f/OAHaWlpIRQKcfvtt/PUU0/N8KglEolEIpFIJJLReOZ6ANfKV77yFSKRCH/wB3/Ali1bGBgY4Etf+hL79u3jpz/9Ka973evGfG4+n+f1r389sViML3/5y7S1tfHAAw9w99138+STT/La1752Fj+JRCJZDAghOHSsi/1HOonFMzTUh9i3cx27tq9BUZS5Hp5EIhmBEILDxy/KOSuZNapWlD/wwAO0tbWV3Xb33XezceNG/uqv/mpcUf71r3+dkydP8sILL3D77bcDcNddd7Fjxw4+8YlPcODAgRkdu0QiWVwIIfiXR/Zz4sywdepQLM2FiwOcOtvLB951u7zISyTzCCEEDz38IsdPd7u3yTkrmWmqNn1lpCAHCIfDbNmyhcuXL4/73EcffZQbbrjBFeQAHo+H973vfRw8eJCenp5pH69EIlm8nDrfz/FXKv+uHDvdzeHjF2d5RBKJZDwOH79YJshLkXNWMlNUrSivRDwe58iRI9x8883jPu7kyZNs37591O3ObadOnZqR8c01+Xye559/vux/+Xx+roclkSx4jr/SN+79+490ztJIJBLJZJhoTso5K5kJqjZ9pRIf+9jHSKfTfOpTnxr3cZFIhKamplG3O7dFIpExn5vP58uErNPlzDTNa+o4ZZomlmXNSreqAwcO8O7f+msCNfYuQy7dz7997X9wxx13zPh7zzazeVwXEzN1XDVNG/O+kXMukUgAVM33a5omiWQOVB9jxUGGoql581mqbe5U03jn01jHmnNjzbdrvcZNlvl0bMCek0KIce+fqbHOt2MxlyyUYzHeNa6UBSPKP/3pT/Ptb3+b//N//g+7du2a8PHj5YKNd98XvvAFPve5z426vbOzk2w2O7nBlmBZFkNDQ7S3t6OqM7tx0d3djTfQjK9mOWCf7N3d3Zw/f35G33cumM3jupiYqeN64403jnnfWHMuGo1WxfdrWRYe1SQST4z521IbYt7Mw2qbO9U03vk01rHm3FjzraOjg3A4PGPjmU/HBsDQM8Tj8THvn8k5O9+OxVyyUI7FeNe4UhaEKP/c5z7HX/zFX/CXf/mX/N7v/d6Ej29ubq4YDR8aGgKoGEV3+NM//VP+6I/+yP27p6eHLVu2sG7dOlauXDnlsZumSXt7Oxs3bpz0Supa6e/vR9M0PB77a9c0jZUrV7Jp06YZfd+5YDaP62JiLo7ryDmXSCRYtWoVjY2NVfH9mqbJ3p1Xef5IH4pS+aJyzxtvY9OmNbM8sspU29yppvFWw1jHmm8bNmygrq5uxt53vh2be97o419/+NI498/cnJ1vx2IuWWzHoupF+ec+9zk++9nP8tnPfpZPfvKTk3rOtm3bOHHixKjbndu2bt065nP9fj9+v9/929na0zTtmk8YVVWv6/mTpdLrz8b7zhWzdVwXG7N9XEfOubkax/Ww9YalpPI+TlQo9tyxZSV7bl03r5wcqunYQnWNd76Pdaz5Nhtjnk/HZs+t6zjT3sexCsWeszFn59OxmGsW07GoalH++c9/ns9+9rP82Z/9GX/+538+6efde++9/O7v/i4HDhxg7969ABiGwbe+9S327t3L8uXLZ2rIEolkEaIoCu9/x15ePtUtPY8lkipAURQ+8K7bpU+5ZFapWlH+pS99ic985jPcfffd3HPPPezfv7/s/n379gHwkY98hIceeoiOjg7WrLG3mj784Q/zwAMP8K53vYv777+ftrY2/vEf/5GzZ8/y5JNPzvpnkUgkCx9FUdi9Yy27d6yd66FIJJJJIOesZLapWlH+ox/9CIAnnniCJ554YtT9TtW0UzFeWkXt9/t56qmn+MQnPsHv//7vk8lkuOWWW3j88cdlN0+JRCKRSCQSyaxTtaL82WefndTjHnzwQR588MFRty9ZsoSHHnpoegclkUgkEolEIpFcA1UryiUSiUQyGiGEzIOVSEYg54WkGpCiXCKRSBYIQggeevjFsvbgQ7E0Fy4OcOpsLx941+1SgEgWHXJeSKqF6nVil0gkEkkZh49fLBMepRw73c3h4xdneUQSydwj54WkWpCiXCKRSBYI+490Xtf9EslCRM4LSbUgRblEIpEsEGLxzHXdL5EsROS8kFQLUpRLJBLJAqGhPnRd90skCxE5LyTVghTlEolEskDYt3Pddd0vkSxE5LyQVAtSlEskEskCYdf2NezYsrLifTu2rGTX9jWzPCKJZO6R80JSLUhLxAVKPp/n0KFDZbcdP34cxBhPkEgkVY+iKHzgXbdLP2aJpAQ5LyTVghTlC5RDhw7xzg/9FYGaNve2xOAZgvUb53BUEolkplEUhd071rJ7x9q5HopEMm+Q80JSDUhRvoAJ1LQRql/t/p1LXZ3D0UgkEolEIpFIxkLmlEskEolEIpFIJHOMFOUSiUQikUgkEskcI0W5RCKRSCQSiUQyx0hRLpFIJBKJRCKRzDFSlEskEolEIpFIJHOMFOUSiUQikUgkEskcI0W5RCKRSCQSiUQyx0ifcolEIqkChBCyI6FEUqXI+SuZDFKULzKEULAsC1WVmyQSSbUghOChh1/k+Olu97ahWJoLFwc4dbaXD7zrdnlhl0jmKXL+SiaLVGaLCEutI08jA5EUmWxhrocjkUgmyeHjF8su6KUcO93N4eMXZ3lEEolkssj5K5ksUpQvEkzTwtSW4HzlyVQO05Jfv0RSDew/0nld90skkrlDzl/JZJHpK4uEdCYPioqCjs8XJF8wKJjBuR6WRCKZBLF45rrunwtkDq2k2pipc7Ya569kbpCifBEghCCX1wHwkCFc00C+YGAID7FEbo5HJ5FIJqKhPsRQLD3u/fMJmUMrqTZm8pyttvkrmTtk/sIioFAwEAIQBio6Ho+Gx6MCCi8c6Znr4UkkkgnYt3Pddd0/28gcWkm1MZPnbLXNX8ncIUX5IiBfMABQrSTOQj/g9wKw/6gU5RLJfGfX9jXs2LKy4n07tqxk1/Y1szyi8ZE5tJJqYybP2Wqbv5K5Q6avLAIKugmAYmUAPwB+n4dUOs8r7YPkCwZ+nzwVJJLZZrI5rIqi8IF33V41Odoyh1ZSbUzHOTvefK6m+SuZO6QSW+BYloVpWgAoIosjyjVNRcGioMNLL3fx6j0b53CUEsniY6o5rIqisHvHWnbvWDsHo50aModWUm1c7zk7mflcLfNXMnfI9JUFjhMlt0W46d6uKAqaaqe1/OLg+TkZm0SymFnIedcyh1ZSbVzvObuQ57Nk9pCifIFjGLYQ93m1Ufdpii3Kjxy/NKtjkkgkCzvvWubQSqqN6z1nF/J8lsweMn1lgaMbduqKx6NhjLhPU2zBfvTkJYQQMq9NIplFFnLedbXlwEsk13vOLuT5LJk9pChfwAgxHCn3elRGOpKriolHU4jGM1zsjrB2VcvsD1IiWaQs9LzrasqBl0jg+s7ZhT6fJbODTF9ZwAgULCEAO1I+EkWBdasaADh68vJsDk0iWfTIvGuJZOEg57NkOpCifAFjCVuIa5o65tbbxrVNgJ3CIpFIZg+Zdy2RLBzkfJZMBzJ9ZQFjCXvN5dEqr72EZRLQUgD81/Mnef5VLezevRu/3z9rY5RIFisy71oiWTjI+SyZDqQoX8A4kXKPp7Ioz2cG+ffHXoDABk6dH+AdH/orvv+NT3LHHXfM5jAlkkWLzLuWSBYOcj5LrheZvrKAcSLl2hiRcgBfoB57/a7gCy6dlXFJJBKJRCKRSMqpalGeTCb5xCc+wZve9CZaW1tRFIXPfvazk3rugw8+iKIoFf/X19c3swOfJdxIuTa6yNNBUYaLQJ3HSyQSiUQikUhml6pOX4lEInz1q19lx44dvO1tb+NrX/valF/jG9/4BjfeeGPZbc3NzdM1xDkjndERTBwpBzu9RTdMTCnKJZJpQwjB4eMXefFQBxe6ulm/tofbd2+Q+aUSiaQM57fCyUWvrw2wrNXDxo0b53poklmmqkX5mjVriEajKIrC4ODgNYnyrVu3snv37hkY3dzSczUJgKoqqOr4AsDr0ciiy0i5RDJNCCF46OEXOX66GyEE8WSeC5cG6bwc4dTZXj7wrtulMJdIJGW/FQ6RaIqjJ+Iksx4++Ouvkr8Vi4iqTl9x0k0ko+nus0X5RFFyKE9fEUVfc4lEcu0cPn6x7CJbyrHT3Rw+fnGWRySRSOYj4/1WHJe/FYuOqhbl08Fb3vIWNE2jqamJt7/97Zw8eXKuhzQt9BRF+Vh2iKU47iwClUgsO6PjkkgWA/uPdF7X/RKJZHEgfyskpVR1+sr1sHTpUj71qU+xb98+6urqOHHiBPfffz/79u3j+eefZ8eOHRWfl8/nyefz7t/JpC1+TdPENM0pj8M0TSzLuqbnjkf3lQQwOVGuKAoeTcUwLTouDk37WOaCmTqui52ZOq7aOMXII+dcImGf2/P5+x2KptxdJyEshBAIYeHEQYaiqXk79mqbO9U03vk01rHm3Fjz7VqvcZNlPh2b2aT0t8Kh9DdjPv9WzAYL5bwY7xpXyqIV5XfffTd33323+/edd97JPffcw7Zt2/jMZz7DD3/4w4rP+8IXvsDnPve5Ubd3dnaSzU49ymxZFkNDQ7S3t6Oq07dx0dU9ZP9DAcMw3PdSLLPi36qmgAnHTl3m/Pnz0zaOuWKmjutiZ6aO68hi61LGmnPRaHTefr+GniEejwN2zmg+nyceT7jpdrUh5u08u9bvWAjBqfP9HH+lj2QqR204wPablnLzprYZTTOsprk+n8Y61pwba751dHQQDodnbDzTfWzm6nycKqW/FQ6lvxl1Neq8/a2YDebTnLkexrvGlaKIBZJEPDg4SGtrK3/+538+aVvESvzKr/wKR44c4erVqxXvHxlF6OnpYcuWLXR1dbFyZeUWu+Nhmibt7e1s3Lhx0iupiRBCsHr3/6CgWzQ3hd1o+VDPS2j+Zupb1o/6O53Jk0rn2Xfrcn740B9Nyzjmkpk4rpKZO65TjZSvWrWKAwcOcMstt8zL7/fQsYv86w9fAuyoVzyeoL6+DkWx5+JvvPU2du+YfNtt253hEgePdhKNZ2isD7Hn1nXs2r562gXGtXzHQgj+5ZH9HH+lZ9R927es5P3v2DtjQqia5vp8GutUIuWrVq1iaGiIurq6GRvPdB6biuejEAwMpfBoKutWt9DUUDNjc2gqlP5WOJT+ZrznbXun9Fux0JhPc+Z6kJHya0QIMe5qzO/3l7Whd7b2NE275hNGVdXrev5I+gbiFHQLEGgTOK84OMWeXd3xqj7xS5nu4yqxme3jOnLOzdU4psKeW9dxpr2PY6e7AbVYlG7/d8eWley5dd2khUAld4ZYIkvn5Qhn2vtmxMllqsf20LEuTpzprTiOE6/08PKp7hntcjifz4WRzPexjjXfZmPM03VsRp+PgnMXBojEUgCYlqC1OTejc2iylP9WOBR/K25ePaXfioXKfJ8z00n17gXMAJ2dnTz//PPs27dvrodyXVwqpq4oiElPZm+x2LNvIE0ylZuxsUkkiwFFUfjAu27nvnv3sH51C/W1ftavbuG+e/dMWQBUg5OLLFaTzCdGnm8DkZQryAH6B5Puv+d6DpX9VqxppamhhvWrW3jz626Y0R0myfyk6iPljz/+OOl02i24PH36NI888ggAb37zmwmFQnzkIx/hoYceoqOjgzVr7G2gN7zhDdx5551s377dLfT84he/iKIofP7zn5+zzzMdXOqxRbmqWJN+jqqqKFgIVE6d7WXfrvUzNTyJZFGgKAq7d6zl1q2rOH/+PJs2bbqmSM9kBO9MRqEnQyyeua77JZLpZOT5VirCAfIFo+zvuZ5Dzm+FMwbTNDl//rwU5IuQqhflH/3oR7l4cXiV+/DDD/Pwww8DduR77dq1btV4afr8tm3b+Ld/+zf+9m//lmw2S1tbG6973ev49Kc/zebNm2f9c0wnjihXlKlVK6uKiSlUTp7pkaJcIpknVIPgbagPMRRLj3u/RDJbjDwfR4pwv69c+syHOSSRwAIQ5V1dXRM+5sEHH+TBBx8su+3v/u7vZmZA84CLPRFgapFyAE0xMYWXE2dHF2tJJJK5oRoE776d67hwcWDc+yWS2WLk+ej3ecgXdPfvtpbassfPhzkkkYDMKV+QODnlKlMT5apqR9ZPnpGiXCKZL0wkaOeD4N21fQ07tlR2n9qxZSW7ti9e9wjJ7DPyfCwV4c2NYVqayq0d58MckkhgAUTKJaO53Oukr0w9Ug5w5nwfum7i9S78SmeJZL6za/saTp3tHeHOYDNfBK9TrHb4+EX2H+kkFs/QUB9i38517Nq+RubGSmaVkedjY30ITVMxTYuWpnDZ+Thf5pBEAlKULzhM06L7ShSYevqKgkUo4CGTMzjfeZUtm5fPxBAlEskUqBbBO7JYTSKZS0aej7bX//yeQxKJFOULjN6rMQzDwqMpKEytL5SiwNpVDZw+P8jJMz1SlEsk8wQpeCWS60POIUk1IEX5AsNxXmltriEVi075+euKovz4Kz38+q/dNt3Dk0gWHDICJ5FIQP4WSK4fKcoXGE6R55LmEKnY1J+/cXUDAC+fvDR9g5JIFiiVum0OxdJcuDjAqbO9fOBdt8/h6CQSyWwxmd8CKcwlEyHdVxYYjh1iW0vNNT1/8/pmAF4+1U1hhLerRCIppxq6bUokkplH/hZIpgMpyhcYPVdiALQ2XZvv6vK2MA11IXJ5nVPneqdxZBLJwkO2l5dIJCB/CyTTgxTlC4zeqzEAWq5RlKuqwu4dtj3U4WNyZS+RjEc1dNuUSCQzj/wtkEwHUpQvMFxR3hi85tdwPFtfOtY1DSOSSBYuE3UClJ0CJZLFgfwtkEwHstBzgXHlahyApoZrF+W33bIWsHPk8vk8hw4dKrt/9+7d+P3+a359iWShINvLSyQSkL8FkulBivIFRDKVI5XOA9B8HaJ857bVKIpC1+UITz79C37rD/4/AjVtAOTS/TzyjU9yxx13TMuYJZJqZjLdNi1rak28JBJJ9VENnXcl858ZE+U///nPr/m5d9555zSOZHGQz+d57IlnAKgJejl/7jRT7B3kUlcb5IYNSzjT3seZjgiBmjZC9auncbQSycKgWrptSiSSmUX+FkimgxkT5b/0S790zSehaZrTPJqFz6FDh/iDT/0zeFaSzeX4s7/6JsH6jdf8eq/avYEz7X0cPzv2dpxEIpGdAqeCbK4imSzVeK7I3wLJ9TJjovwzn/nMqImzf/9+fvrTn7J582Ze9apXsWTJEq5evcoLL7zAuXPn+OVf/mX27ds3U0Na8Hj9TZgmeDw+tEDjdb3Wnfs288//+jzHXrk6TaOTSCSLGdlcRTJZ5LkiWazMmCj/7Gc/W/b3c889xxe+8AW++tWv8pGPfKRsQgkh+Kd/+if+4A/+gE996lMzNaQFj4V9TFVN5Xr3Gl69ZyOKotB9JUmNV/74SSTXixCCQ8e6qiryN51MprmKjDBKYHbOlWqMxEsWPrNW6PnpT3+ae+65h9/6rd8adZ+iKPy3//bfeOKJJ/j0pz/NM888M1vDWlAIYTtcaqpy3aK8oT7Eji0refnUZUxL1gNLJCOZykVdCMG/PLKfE2eGG3IttsjfZJqrSFEuAXjx8AUGIkn6B5PkCwZ+n4e2llpamsIoinLd54qMxEvmK7PmU3748GFuuummcR9z0003jbLfk0weqyjKVXV6vtbX3r4ZAEN4p+X1JJKFgnNR/86jB7lwccC9oH/n0YN88+EXEaK8yvrU+X6Ov9JT8bUWSwtu2VxFMhmEEDx34DztXf0kUlnyBZ1EKkt7Vz/nO/sRQlz3uTKZSLxEMhfMmij3+XwcPXp03MccPXoUn883SyNaeIhi+oqmTs8K/859mwAwLc8okSGRLGamelE//krfuK+3GFpwy+Yqkslw+Pgl4olsxfsi0RSDQ6nrPlcms2sjkcwFsybK3/SmN/HEE09w//33UygUyu4rFAp84Qtf4Kc//Sm//Mu/PFtDWnA46SuqNj1f655b1+HzqghUTFN6LUskDlO9qCdTuXEfvxiixBM1T5HNVSQAB4920tZSO+b9/YPJ6z5X5K6NZL4ya8nCf/M3f8Nzzz3Hpz71Kb785S+ze/du2tra6O/v59ChQ/T397N8+XK++MUvztaQFhQF3UQwnFM+HQQDPrbd0Mbhk33kCwYejzYtryuRVDtTvajXhgMkx3lKNUaJp1ooJ5urSCZDNJ6htTlMNJYhEkuNur+hLsiu7Wuuq1CzoT7EUCw97v0SyVwwa6J85cqVHDp0iP/5P/8n3/ve93jsscfc+wKBAO9///u5//77Wbp06WwNaUExFBve7pvOApVd25a6orwm5J+215VIqpmpXtS337SU5w+PncJSbVHiaymUk81VJJOhsT5ELJFl84Y2BiKhUcWee2+158r1FGru27mOCxfH7sFRbfNRsnCYVVuNpUuX8uCDD/JP//RPnD17lng8Tn19PTfccANerywmvB4iRVGuqcr0ivKt9iJJ100sS+aVSyQw9Yv6zZvaSGY9nKhQ7DmbUeLpsoG7Vss62VxFMhF7bl1H5+UIoNDaXEtrc3kqy75d66/bMnGmd22k3aLkWpkTrzuv18vWrVvn4q0XLJGoLcqnK5/cYWlrGBUTC42Cbkzra0sk1cpUL+qKovD+d+zl5VPdc3ahnk4bOGlvKJkpdm1fzZn2vnHn1gMPPjvua0x0/s3kro20W5RcD3Miyl944QVefvllN1J+yy238KpXvWouhrJgKI2UTzeaqmNZGvmCgdzPkEjGvqjvvXUtAA88+Kx722071lAXFHMeJZ7OhiyyUE4yU0xGME/m/JsoWj1T81E2yZJcD7Mqyn/+85/z27/927S3twP2itJZMW7atIl/+qd/4jWvec1sDmnB4EbKp8mjvBSPaqBbUCgYyFpPicRm5EV9rAhZR1c/S5u9/PdNm0a9xmxsczvv8aX/+zOuXI1hGBYC8HpU/D4vbS21tDaHpxTdloVykplkIsFcfv4JBiKpstzzW7au4hv/9jzPPH+27PYDRy7w+lffyG/++quuOxo+1ryVu0iS62HWRPmLL77Im970JnRd581vfjOvec1rWLJkCVevXuXnP/85jz/+OG9605t45pln2Ldv32wNa8EwGJ3BSLlioChgWQJLlapcIqnEeBGysxcGOXz8Ent3rndvm41t7tL3uHI1Rv9gklxeByDg91JfGySRyhKNZWisr5n068pCOclcMnz+Cc519Je5tOQLOifP9PD0L87g0VSK7TvcJkTReIabb1jObbdc2zk60byNjrNYBbmLJBmfWRPln/zkJ1EUhWeffXZUNPwTn/gE//Vf/8Uv//Iv88lPfpKnn356toa1YHDcV64np1xYJsePHy+77fjx4yiAz+shXzAwxJxkPEkk856JImQHj3aWifLZ2OYufQ/dsFxBDpDL6/h9HgIBL5FYinQmP+nXlfaGkrnEOf+efO6VUbaJzY1horE0kWiK+toggUB50mUkmuKRx45csyifaN56veMHruQukmQ8Zk1hvfTSS7z73e8eMz3lta99Le9+97v5/ve/P1tDWlBMR6Q8nxnkz//m36mpP+jelhg8Q7B+I76aoii3ZFa5RFKJiSJg0RH3z8Y2d9l7VDBPyuZ0V7RMxVtJ2htK5hLn/Dt9/sooy8SWpjA/+6/TQPn5Xcq5jqvX/N4TzduJzny5iyQZj1kT5YFAgBUrVoz7mBUrVhAIBGZpRAsH07SIxu2OgdebU+4LtRGqX+3+nUvZP15+n4ckYAmNRHLyETWJZKEwUf73RHnWjSMiZJMtlryevPPS9/B4VAJ+b1m03LTsTr3NjWHCU+xDMNeFq5LFjaIo1NYEuPmG5WM+xjm/SxFCEE9m+YdvPHNNi8mJ5m1NyM9NK5queRdJCMGhYxd57GfH8HjP09QYlovdRcSsifLXv/71E6alPP3007zhDW+YpREtHPojyaKHuECdgZxyAE1T8Wgqhmlx9PRVfuXuGXkbiWReMpn874nyrPfcWh4hm0yx5PXmnZe+R8Dvpa42gM/nIZfTMS2LUNDHxrVttDSFaawPcehYFy8e6uBCVzfr1/Zw++4NUgxI5i1jzaH6+hCZXAFtRJBKCEEimcOjae5cncx8Kl0YHz5+kUy24BZIj4yNNzbUXPMukjPfj526XHSng1giK+0UFxHTb9UxBl/60pfo7e3lQx/6ED095Q00enp6+OAHP0hfXx9/+7d/O1tDWjBcuRoHQEHM6IT1+ew13OGTY3cmlEgWIpPJ/961fQ07tqys+Jgb1rewa/vqYhSsi3/4xjO8cq6XU2d7GYgkEWJ08si+nesm9b7jUbpV3tZSi6IoBANeGhtCtDSF2X7TSlqba1EUiMTSfOfRg1y4NEg8mefCpUG+8+hBvvnwixXHJ5HMNWOlgqxf3UzA7yU4InUll7d7baxb3TLqOWPNJ0cof+fRg1y4OEC4xk8ilaW9q59zHf2MTPzat3Odu4v0ex+6i0/9wZvZt3Md+4908pdf/gn/8I1nOHSsq+Kcut75Lql+ZixS/rrXvW7UbU1NTXzzm9/k29/+NmvWrKGtrY3+/n4uXryIaZps376d3/zN3+Spp56aqWEtSK5cjQGgKKO36qYTv89DJlvgyMk+TNNCm+ZGRRLJfGVkHqkQgsGhYRu2K/1x/vvvvJH3v3MfN5+4VBYhs33K7ZSv0qi33+/B69Fo7+onGs+waV2bu6jeduNyTp/r5Svf/C+i8Qx+n4dVy5vYuLa1LEVtorzz0oLM1uYw0VjGLYxrbgzT0hQGoKEuRDSeqbiol97KkrlgMmlbYxUctzTVcue+zaQz+bKcc1VVWbm0sRjhHnsel77HSKHc0hQmGs8QiaaIxFIMREJu19GR6SlT3el68fAFBiJJrg4kSCbT1NamWdJaR0tTGEVRpJ3iImDGRPmzzz475n2GYdDR0UFHR0fZ7ceOHZNbM9dAb1GUq8ysKLerygXJdIGXT12WDguSRUNpHqkQgvMXym3YrlyN851HD7oX2tILp2manD9/nsPHL42Igils3tDGQCRE/2CSQsHkps3L2HPLGr7+3ec5/ko3g0MpCgWDVCrHQCTFuY4+brtlLUta6wBl1LgqiZjShUJjfQ3pTB4BhEN+Ghtq2LdzHS8evkAskR3z80sxIJlNJitmxys43rltNUdGLJBfOdeL3+8BlEnNY0cIl6IoCpvWtdFYb8/bZDrP3p3rK6anjB35Fjz53CucPn+F2pqA23jsuf3nuHwlCgIKukkylSOZzrmL9umwU5yN3giSa2fGRLlVocBCMjO46SvKzG4xK4qCRzEwhJcXD1+QolyyaCjNXR0cSo2yYfMXU7uOnb7Mt76vEE/mRnX0PHi0kmuDQmtzLa3Ntaxf08rvfegu/uWRFzn+StHGsGBS0E330cl0niMnL7NhdSubN7S5eecvvdzFX/7vn9DR2Q9AfV2Idaub6ejqr7hQGMkTz5wa9/NLb2XJTOGIxNJahvq6IE8998ooZ5XW5nDFObZv5zo+9sFfGiUqRxYi/8M3nnFzycefx8O7Q5XOfUUZnrdNDTX83ofuqvjZKju1DHur9w8mufmG5QzF0hw4coH2roHioqGcSDRFY32IDWvbxjuUEzIbvREk14c0nV4A9LqifOYXQppqYJheDhy5MOYPkUSy0Cgt4uwfTI66v62lFudie+rsFdcRwunouaTJw8UrWS5cHBxl3+ZcBJ2L/0+eOkkup5NI5cgXDCzLQlEV93HpdN7dNn/P2/bw0Pde4Bv/9gKXe4fc8WRyBaLxNGtXNTMQSfLK+SuEixG5SlEx2aFTMheUikTbFSXPhYsD/Nf+8+TyOvW1QVBKGv8Uz9GRc2yyorLSPBZCkMsbdvGzaXHqbC9tLWEe/tEh9h/p5NDxi2SLhZ3NjTVEoulR3UNLu5OXUknQD0SGFwP5guHe3j9o15bkcjoB/2gbx/7B5HXbKc5GbwTJ9VHVScHJZJJPfOITvOlNb6K1tRVFUfjsZz876ef39/fzwQ9+kJaWFkKhELfffntV5rM7kfKZTl8Bu7snwIEjnbL4S7Jo2LltNQ11QU6d7eViT4RoLEM2pyOEoLkhTGtz2L3Yll5owb7o/+dz7Rw/3U0ilXUFRntXP+c7+xFCIIQgmc7xD//8NAeOdtIfSZLNFhAIUBS7m65lzzdnF9Kp6XjqF2e4OpAYNeZcXuf8hX5Onu3l6MnLrnipVLw50cVeeitLZoJKInFgKEUynSOX18vsOwG6r0S5cGmQnitRjpy4VFYoPZlCyNJi7HzBcN1YEsksqqqgaSqJVJbDxy/x+DOn6Ojqp7ZY2Hm+8yrPv9RBe2d/2Tzu7Yvx0Pde4KWXO/mHbzzDX/z9Y24xZ31dcNQYShf1TmTeGU/A7x1zUdFQF7zu3enJ9EaQzC2zGikXQvAf//EfHDt2jJ6eHnRdH/UYRVH4+te/PqnXi0QifPWrX2XHjh287W1v42tf+9qkx5LP53n9619PLBbjy1/+Mm1tbTzwwAPcfffdPPnkk7z2ta+d9GvNNb2zVOgJoComPq/KUCxNe2c/m9YvmfH3lEjmEiEE33xkP7FEhraWWvoG4mSyBXI5O5K3aX0roLgX29ILLdjb5PFEjkBgtA94JJqioS5ILJ6lsSFEb18MwzSxLIFpWigKbu6ssAQIBZ/Pw8a1bWxY08qBo130DyYr+jGbpkW+YKBp6qiFwsiomOzQKZkLKonA/sEkmqpimlZ5cyshiMazmKZJuCZAvqAPR9CLOdcT1T6U5qBf6Y/T0TWAZYmyzp+5nL0Y8Fl2EahTIN3dFyWRzJY9trkhTEtTDY/8+AhP/eKMW/DpLIAb6oKjouilc9HeYbPx+zzkCzp1tQFWLmvkUvcAqurB7/fS1lLL3lvXXXdqyWR7I0jmjlkT5R0dHfzqr/4qZ8+eHTfCOhVRvmbNGqLRKIqiMDg4OCVR/vWvf52TJ0/ywgsvcPvttwNw1113sWPHDj7xiU9w4MCBSb/WXCKEGI6Uz3BOOYCiwOa1TZw8N8j+I51SlEsWPMPRPDuPdPtNK2nvsnO3C7rB4FCa1uZa92JrR82T7hZ3NJbGNA3CNUFqw8FReaynz10BIJWxC7r8Xg+6bqIAzk+lotjGa6ZloSoKZzv6MAyLpoYQ+YLuiphSTNNCCIFpWaMWClBevFkqVuzc3hzrV7eM6VMui8Uk00ElEVgoGAQCXgq6UbbYzOUNdMOur1BVhWgsg2lZaKpKLqfTWB+kuTFc8X0qna9vft1WvvX9/Wha+fmazdnBwmDAS/9gktbmWjZvaCOayJDL6eiGSVu4rujgIviv/ecZGEyieTRWLG1g/eoW1788lsjQWB8qKaIW6IZJNJbB5/O4O1wtTWHaWmpJpLL4fV5am2vxeSzq6+vd+bRv1/rrONI2Mk1t/jNrovxjH/sYZ86c4aMf/Sjvec97WLZsGR7P9b399fz4P/roo9xwww2uIAfweDy8733v45Of/CQ9PT0TdiCdD8TiGXeLT5mF9BWAmza2cPLcIAeOXOD979w3K+8pkcwVI6N5I60FnQu33+ehJuQjGsswFB++8GWyBXTdwOfLs3P7GhqHQkXBrpNI5khl8jQ31JAvGGSyBUzTQlUVhLCj45YlUBC2QFcUDNNkcChFKOBjKJYikcwRLIqYUixh/0ZqqloWkXMYKYgcb+Vbt67i/PnzbNq0CU3TRj1PFotJpotKItHn8xDweygUvG7KFtgRbFWxF6plXWlNi4JucOrsFfbeOlq4jnW+CiFIZQqjHm9aFgG/l4DfWxLVVvB6NBobQvh9XrZsXsa5C1fpvDRIPJm1d7YswZWrMaKxNOtXt7B5wxJAoamhhje/fhv7D1/g5wfOAxAIeAn4PSTTw+4qG9e2Eo2HR3X+henbrZqowZlMU5t7Zk2UP/fcc/zar/0aDzzwwGy95bicPHmS17zmNaNu3759OwCnTp2qClHuFHnW1vhgdDbQjLBlo914Yf+RC7PzhhLJHDI6mlduZaiqCuvXtHLr1lX89NlTdIy46Gmaiq6DJZztcNu1YSCSpL2rn0LBcJsCaqqKqVj4vR60gEoyncMwnEJP8GgKqqq6giEcDrg7jwG/l3Qmj2laWMLOPfdoaknnwXKuNSomi8Uk00UlkdjWUksynaOuNkBLUy26bpIvGHg0lWDAN2rx6ZBM5yrmcI91viqKQk3Qh9/noVB8D8fL3DItUMpT0Zz0Ep9X43xnP2fa+8jmdEzTLC5+7Umcy+v09MVobKihtbmWWCLrzocLlwZZuazBdV9xcNxV3nnPTm6+YTn7D1+YcLfqWpBpavOfWRPl4XCYjRs3ztbbTUgkEqGpqWnU7c5tkUik4vPy+Tz5fN79O5m080hN08Q0zYrPGQ/TNLEs65qeC9BzxXZcaG4MEum/ppeYMhvX1APQdTnCQCRBU0PN7LzxFLje4yqpzEwd10oRWYeRcy6RsLd8Z+v7ra8NEImmRt3e0mQ331m/uoWPfuBOhLC9h0c0+CPg92BZJoHidrXTsOfqQKJ4UbcYjKTQNBVVtfNUTMvCMC28Hg2PpiIAyxIEgz5qwwHXnSGf11m+pMFOYRuRFuj1aPh8HsIhvx1tH3FNv23HmorHb6Lv+MVDHeOmIL54qINbt64a8/7ppprm+nwa61hzbqz5dq3XuPG45eaVnDjTw/HT3ViWxVAsQyZrkU7n8Xg06msDxY6zilvUmc9r5AqjI1C1NYFiqlj5GMc7X9taal1bQoeBSJKOrgEQ9q6Y89zW5jDxhL0zfalniHxeLxZp29F4q8Q2I5HKcfx0N431IZYtqefAkQscOHrBfa1N61ppGAoW+xMY+HwelrXV87537EVRFHZsWUF7ezsbN25E07RptZh+79v3cOPGpRw82kk0bqfX7Ll1Hbu2r56XVtbzac5cD+Nd40qZNVF+991388ILL8zW202K8VaeY933hS98gc997nOjbu/s7CSbHbv5xlhYlsXQ0BDt7e1lnfomy8sn7O2wkB/6TRPDMNzXVazhvyvdNtHflW4z9AL7X3yO1iY/A0N5/vdXvs1N6+vZunUrPp9vyuOfKa73uEoqM1PH9cYbbxzzvrHmXDQanZXvd1mrh6Mn4mPcK8hmfXzubx8hmcpxpS9CKKhSKJgYhoXXq9G2oo5oLE0qq5NMWsTjcUDQ3RspCm8VPWeg67ae13UTSwgneI5Hs/PFvV6N+rAPRRHoBXvbPSVMbtzYCoS4OmDnjytAuMbPiqW1JFJ5rg7E8HmhqWE4injD+hbqgnnOnz8/6hNN9B1f6OomnsyPun34/lzF150pqmmuz6exjjXnxppvHR0dhMOVc7avh33bm6gN6Hznh8fo6YsRDPhYv7oBgMs9g8TiCXZuXcEbXr2WHzx+CkXRUFXbxtCyBKqqEPB7WL28ls6LPaPOvfHOV68m8HqcOWnj8wiCAbV4v+ne59UEjXU+Ll+Jk0xl0Q1HwApAwbIsdN1wnZKEZeHRoKHOx//95pNcHUixpLUGZ1vM54GVS4cDWnohTXt7OzDz50l9CN54R2kmQMF97/nGfJoz18N417hSZk2Uf/GLX2Tfvn38yZ/8Cf/rf/0vgsHR20yzSXNzc8Vo+NCQHXmuFEUH+NM//VP+6I/+yP27p6eHLVu2sG7dOlauXDnlcZimWbYinirWz+wUkhXLGrl8WXPz9FVVRVW1srz9kbdN9Hel24x8lK/8y37Umo2Aj69/7xgid5l/+9r/4I477pjy+GeK6z2uksrMxXEdOecSiQSrVq2isbFxVsaxceNGklnP6C1wIcjkCvT25+1FvBoAxUMmm6OpMcymdW22a4qwaKyPo5saliVYu3oZqXSexoaoW5wpRI5cwY6aC8Dj0cCJwmGnwCiKQjZvIoSdR6tpKoGAn4b6enIFhc0bKvz+CMHAUArTtFi7ellZVGyswMNE3/H6tT1cuDQ45vFav7qFTZs2TfbwXjfVNNerYaxjzbcNGzZQV1c3I++ZyPpZvfIK9bUB6uvrUBRbfK0rZlO85U23sWv7ak6fj3K24yp+n4/akvVBU2MNa1e3sX5Na9m5J4TA5ztJd9+QG5Ee2R/g1m0b2LtzfVnk+Hc+sBYh4KWXu9zbbrtlLf/40LNcGcygaQUMU9i7U4qCoqgoCpimwCpOWt2wEKjU1ISoq6uluy9NwdBch5aRlM6bajhPZovFdixmTZQvWbKEJ554gttvv52vfvWrbNq0qeIEVxRlVrzCt23bxokTJ0bd7ty2devWis/z+/34/cPWZs7WnqZp13zCqKp6zc+/Uqzebm2avappX6gNT7CWVDqPotXir2m7rs8/U1zPcZWMzWwf15Fzbi7G8cFff9Uo94b62gBHTlwqE7dLWutIpnMMxdJEouniBVhFVVXaGuu47949KIrCl/7vz9ANi0QySzDgpTbsR6QhVnSUsEyLutogoaCXZNrOE8/lDfIFg1DQ3pEyLYtMtsD5zgHWrGyqLLIVhbaWOpoaavizj98z6c873rG9ffcGOi9XTu9z7p/tOVdNc32+j3Ws+TaTY37p2MWisFXc/468f+/O9XzsQ3fxv7/+9KhOn05KWEN9iK988+fE4hnq64IMxdL09sdJpnMA5HWDZDpHLJF1F82vum0ju3esZe/O0UWi+3ZtcP996FgXl3qiBANemhpriMbSbrddIQSaqrp/a5pKOBzA59O4cGmQeDJHW0stA5EUbS2VFza3796Aqqojuptemdac8mplvs+Z6WTWRPnRo0d54xvfSCwWA+DIkSMVHzdbJ969997L7/7u73LgwAH27t0LgGEYfOtb32Lv3r0sX758gleYH1zps7fWmhtmd+fB67Enh26YVHBbk0gWFI4zyciW3SN/r0qdWRxXFrAv2nW1AR74xjN0dQ8xGEni8djRtVgiAwK7mFNVULHzygu6ga6bbn65k7/qRsn9XtsvWYFwOICuj51zOZ1WZ7JYTDLdTNY/e/eOtbzhNTeNOveEEGSzBY6evISTHnK2o4/2rn6aG8I0N9QQKXF5cQor3/CamyZ9vu4/0ukWewb8HmqCfkwrV+wnoBTrNhS8HpXacID62oD7++D0I2goFqKKYtF3/2DCtkH1ecnmCvyff34ayxK0NNbY3U0vDdJ5OSJdjRYRsyanPv7xjxOLxbj//vu57777WLZs2bSseh5//HHS6bRbcHn69GkeeeQRAN785jcTCoX4yEc+wkMPPURHRwdr1tgT8MMf/jAPPPAA73rXu7j//vtpa2vjH//xHzl79ixPPvnkdY9rtrjSXxTljbMryj1FUW5ZAkvIHwrJ4qOykBh2Zkmm8zQ11FAX9tNuZOnoGnCdWQzTIpMr4Pd5CPi9JJI5NE21C8aKNnD5gmFf5L0aSlFvK4rddbClybZOa2upc6OE4zHS6szxbX7x8AXOnO9jKJ6mqT7ETZuWcdsta6kLjt9LwvE0lz7lkumgoT5UsZi69H4Y+9yrrw2UCXIY7pwZiaXYuLaNxoaasgj7iqUNZUJ3Iu/9WDzjeokrikJdXQCfz7Y1LBQMTNOitsZPTY2fYMBbTF2zc9+z2QKRoZTro95zNUahYLgLaU1VefHwBQoFg/raIEOxGpY0D+9WSFejxcOsifLDhw/z7ne/m0984hPT+rof/ehHuXhxuLXuww8/zMMPPwzYxZdr1651q8ZLK7D9fj9PPfUUn/jEJ/j93/99MpkMt9xyC48//nhVdvOcbVHutCS27dcW/paSRDKSsRtx2E2G9u5cz+996C72H+7g6V+covNyjEyugKaqRR9y4fogK6pdKObzamQNC4HAsijmqdr/0DQVr1ejpSnMq/eU52yHQ35Wr2iaVPRaCMGD33uBp557hdPnrpBM59BUlUDAS9flCB1d/Sxt8fHajI9Dxy9VFCiVdg4kkmtl3851dHSNbR9Wuqgca9eqVJDDcOdMIQQXLg4SrvGXpbzUhPxlgnwi7/2G+hAtTWGi8czwAkKxd41V1bYq3bS2le4rUWLxLIZpousWQljF4BXUhHTOXbhKvpjfXigY1NUGQLF92Au6Pb6haBqfR1BfP/x5JupWKlkYzJoor6urY8mS6e/+2NXVNeFjHnzwQR588MFRty9ZsoSHHnpo2sc0W6QzeeLFTmHNDbPficvrsUW5KUW5ZBEymUYcQgi+8s3/4nJvzG4MZFllnTeFEBQKRbcVRcGnqShFW0TnfquYrkLRC7m0TbdDY0PNpKPXh4518f0fH6GnL0o8af9+OA1YCgWDhvogx04PceLckJv/KpsDSWaSXdvXcOJMD8+9ONrlaDIpUZV2rfw+D7l8gUQyh26YWMKOUucLOolU1t2ZUhRlUt77znzftK6Nhrogp89dIZ3Jo6kq4ZCfUNDHhUuDZHO2M5JpCdtJqbjzFSymm0VjGQq6XR9iF6J6CAa8bvfSbE4n4PcSiWZYu3r8zyhZeMyaKH/rW9/K008/jWVZVW1rM59wUldqgj5CwdlP7PZ4NMgbWJZMKpcsPiaTW334+EUuFosiNU0taxuuKAoBv5dCIYOiKHg8KvW1QTs/NqeXdDNUqK0NkssVUBQFv8876v327Vw36ej1I0VBHomlMQwLVbHHpmkqubzOK+evoCDweJKjitKmYxt9ojSB6WK23kdy/SiKwvvfsZfaoMGVAYN4Mjfu9zXyuz11rhePptLcWEMkmqZ/MEk0bhdbG4ZJMDDartc0LfdcHtm1dyT7j3TysQ/+kjvfFUXB7/fg99tCv7khDAi6r0SLHXlVdN0srq1t4R8KDRdoAxQKBl6vRi6nEwx47cZhpuXeP7JGZDrrQiTzl1lTU3/913/NG9/4Rt773vfyN3/zN9dkHyixyefzHDp0iONn7O2+hjq/7RozdhrojOAUe5pCLrIkC59KIm/vrWvZsnkZB452VRR++4904itWQgcC3lHdCC1LUBPyY5gW9bVBAgEv/pwX3RiOqAd8HrwelZRhF3z2DyY4eLSTdatbaG0Os2PLqgkjic7YXzjUwfd+9JIr+hXAUhVMS6BZAp9XIxrL0NQQtDuNVmD/YduG9VrE7mTSBKZDMM/W+0imD0VR2Lp5Cffes2ncerOR360QgmQqx/kLVzFMu4utk1qZyRSGA4G2nThgi+jW5rCbEmJHoQUDkdQoZ5fmxhqe23+O519qJxpLo6oKqXQev9eD3++lraUWhODFw53k83b0W9MEigoUXRM9muoush3x7eCIcOf3QSsGLb3e8mMwsi5EsjCZNVF+yy23UCgUOHToEN/73vdoaGigvjRhqoiiKHR0dMzWsKqSQ4cO8c4P/RVaYAVQQ1//EH/2Vz8jWD+7HVOdYk+BRipdmNX3lkhmk/FE3o4tK/nYB3+poshzisMiQwmCfi+FgkEuP9yN0LQsWpvtVuIej30xDhYvzoYCwrJt3HKDKUCgFrt+Xh1MkMkWeNvdt/D+d+6r+N6lxZzPHThPLJ4hGs+QyRYQArfLp1LMXQcLsyR1xlfRVknw8wPny3zKpyJ2J5MmMB15s7P1PpLZp/S7FUJw/oLdst6yBJlMHkVVi8LYdjfSPBq6bjAQSVIT8uP3eykYBgORFA11IQ4d6+LU2V5One2loBsEAl4CfttlJZ7IcDBu72Q1lqSIDg7Zz71122rOX+inpy9KJldwU8/M4kJAUxUU1LJdMmd++3we10oR7M6/hYIXf3HeNTcOv590NVo8zJootywLr9fL6tXDSVKVWt+O175ZMkygpg3hbYJ0Hq8vhBponPUx2MUtthVUZ3ds1t9fIpktrlXkNdSHaG0K01sXYCietzv9FS/amqqytLWe337vqzl68hKDQ/a2u3NRTqbz6LqBsFRMYQGKm/JSVxsA4ODLXXzyC48SrgmURawBdxExEElyuXeIbE5nIJLEDhfagtz+uS1ushftFmvD9mu3tYxucjIQSRFPZFm5bPj3xrF3+86jBzl4tJObNi8fM3I+mTSB6RDLs/U+ktmn9LsdHEoRidlFl5qmonk0DMMsRsYFPq8HVVMo6Ca5vE5tOICmKSRTORLJLN1XokTjGa70xxiKpbAEpNI5ggEfzU01JFI5EqkcjSNSRzRVJRJNcfTkJfIFg2xOR1XAFMMOSR7NFtuqhpvKMjiUQlNVp+cQhmGhKGYxj9zDutUtNNaH0DSVxlqN9atbpE/5ImPWRPlkCjIlU8PZAtM0hbEdimcWr0cjXzC4cCk2RyOQSGaeaxV5+3auo6Pzallqmcej4lc9qKpCU0OIrssRonG74PLmG5YBCv2DCY6cuEQur2MUc0s9Xg2fVyOX1xFCkMnq9FyJcbl3iO03raS1OexGrLdsXuYuIvoHk+4Wv2EMF5658Y/itr6wBKpXZcOaVjLZbEWrxf7BZJlYL41UArR3DeD3e8eMnE/Wj/p6ma33kcw+pd+dY3sIxTQQIVBV1TUh0A0DoYNVvD2b021vf7CbceUNjpy4RPeVKIZpuXPDMHN2EbZuopWknjg4qSaXeoZY0lpnL7I1FdMabh6kaSqWKTAM071WG4blptOEgj6aG2swTJNEMouh+1i7qoVf/qWb+Y237qajo4NNm8ZP5ZEsPGSFXhXj/FDMZeGspyjKO7tHV81LJAuFaxV5u7av4cc/O048mSPg96FguytksgVUReFid8SNTHdejnD+wlWWttXT3RvF59PwelT0goElwMzrFAoGqqqQzhRQFHvuZ7IF2rv6icYybN7QxrHT3Zw+f8UdQy6vk0jmyOZ0SjciSwNvqmLverU113LTpqWcOnOZ0+eusKS1rqwleUNdsEysl0YqgTJnmEo7CGPbSA7fPx3M1vtIZp/S77b0fNNUFavo81/Qh0/0Ye//cucjVbFtSC9ejlAwTBRFQVVsAW+aFolkzk7vUhXSmTzBgNcV9E6qSSqVd99b01Q008ISthA3DBMFKDqa4vd77GZgQmCaJplsHp9Xw+/zsKTVLqj2ejSOnrxER9cAppHB6ztPU2NYFigvIqQor2KcHDVVnbuJ6uTBdl6OzdkYJJKZxhYCqYqFYK3N4TFFnqLY0fBVy+u51JsklbFTWFBAUSGezHLgaKcrdBVVwTQt4qkshmG5domOmC5tLqRpCgrDOamRWIqBSIjW5lrOdVxl3eoWwI7O5fL29rqdbma/lpN65vXYLcE9msaNm5ZimIKlbWEKhkb/YJJCweDVezdx+671vHj4Ap0l+eSlkUrATb1xGLmDMBkbyelgtt5HMvuUfrdOh02wo9eJosWng6YqrihWFLtjbl04SFtLLZd7hrh8JUrBMO3UE0uUpc9awi6EViy7c3U8mSVfMKivC9rNg2rt5kF14aA9Z5NZNFUlX9BdX3LnGh0OB2lpqqHvagKzOH9NUxCLZwgEvO7rXh1M2B2BoymWtIRYt2YpsUR2XhcoS5ej6WXWRfmLL77Ik08+SW9vL/l8ftT9iqLw9a9/fbaHVZWUVnPPFY4Dy+XehCtUJJKFxt5b1/LE0ydHRIVtv+NoLMN73rZnzOfGEllAwe/z4PPVMBBJYZkWhgEIQS5nEA753Sjcpd4hLEuQy+tjXtQU+6koikIwMGyR2D+YpLW5ttyIqfgSjiOF84p27qtCIOAjGPDRUGuLFVuX2A2QHEvE23etd8V1qSgf6Zk+Mg995A7CZGwkp4PZeh/J7FP63TodNsGOXvv93rJCak1TAQtNtTvjtjbVcvMNywHcBadjCWqYFgJbZDo536WYpr249ec8BIodO9/x5p1E4xmEEBw5cYnLvUOuAQJAPm+4jcESyRwFw3ZnEZawF9sWmKbmvq5pCjTNfuOhWIZ1JafpfCxQli5H08+sKSjDMHjPe97DD37wA9ewv3RV6vwtRfnkcNwTAFRt7k56O0pvYVoqZ9qvsGPLqjkbi0Qyo4w1zSaYfo31IYZi9oU7kcqRzRXcyLcjkoeiaRoba8jldNLZvH3RtgQIO//Usqyy1BO7PlNgmranOeBG3ABu3LCEQjEX3aupBIpiRfNoYJj2f4t5tkG/l7Urm4uRdQUqeKs6Ee+RYrc0UunYzJUycgdhrDbp0x1Zm633kcw+pd+t05o+lsjS1lKLz6tx5WrC7ZwbDPhQVYVsrkAw4HN3dsFeQJ4+5wh3+3pamjvuzDe7+y4Yhp1f7uSl79iyik/+v7/Ct75/gGOnu/H7PNTXBsnmdEzLorYmQCqdxzDteZhK58veQxRrOQq6iWYVexMIQSho+5mP9CmH+VegLF2Opp9ZE+Vf+tKX+P73v8+HP/xhfvd3f5fdu3fz8Y9/nHe/+938/Oc/5/777+cNb3gDf/3Xfz1bQ6pqRIkSUOfwAqMoCppiYgqVk2d6pSiXLEgOHO1i07o2GutDo9JXWprCHDjaxW232CkRI7dzE8ksiWQOsJvzIMByonKWAFUhVzCIxtJFGzcF07LcVBVFEUUROZzGolAUCwiS6RyJVBafx8OKZQ0IIXjHPTs5fe4Kx0534/N58Pk85AsGCrbVYSjoo7YmQGNDiFu3rqYm5Cc6Tt68E/EeKXbzeYP2rn43jWfkCqVSmshkmxxdL7P1PpLZp/S7/b0P3eWej6l0noDfh8/nQdcN8gUTv0+zizoLdqdMh+bGGpoaarg6kCimiI1ejKqqnWdumoJCMRUlFPTx0Q+8lve9Yx+qqvKBd93OoWNd/M+/vIxu2NamzXVh1q9u4cKlQa5cjQF2CoxVTJEpe6tiDnu+YLiuSjDapxzmX4GydDmafmZNlH/7299m69atfO1rX3Nva2hoYO/evezdu5c3v/nN7Nmzh9e97nX8zu/8zmwNq2oRxYY9qqrMedRHVUxM4eXEK93A3jkdi0QyE8SKXsWtzbW0No+2CnQulpW2c4VlYVqCRCpT7Ngn3Eg3irPjJcjnDfx+D+GQ3y5kGyESFEXBdnoTeDTNLWpTFPtxed0gGs+Qzens2r6G3TvWcuhYF3/x9/2kM3m8Ho26cMBNk2luCLN5QxvvfMsu9h/pHFeUN9QFOXSsa1TU+Xd/87X8yyP7ZZqIZM4oFej7dq7jO48eHPUYIQTtnf0YlsXpc712hLrY6Gc8F2YhBKbtRoqKgubR8Hk9buqYw6lzV/B4NLdo27Is2rv68Xk97i6VaVoVhb9lCVTVTkNtrA+RSOUAaGoYXacy3wqUpcvR9DNrory9vZ3f+q3fcv9WFAVdH879uvnmm/nVX/1VvvKVr0hRPgksbFE+l/nkDppiogMnz/TM9VAkkhlhsm4eFbdzFYWNa5o4fPLKsPuDgBEua5hF8Z51mvuI4QI1Z4vdaTaiqgrCAp9Pc9NYHN/jC5cG+PYPDvC+d9hNhdavacW0BJFoyn3veDJLT1+Mru5Beq/GuXnzcjd9cDSCSCxdJnZK80bf/8593HziEi8evsCZ830MxdM01YdIpnIcPn5RpotIpsy1Fg9WqiUQwuLIicskUzlqwwESySzJdJ5sroBlFjtvWvY8sygX6U5uuSj+I5fT6R9M8v/9359x+twV3vWruxBCcPx0N20tYa4OJkimcm43XJ/PQ1NDDQDZrD5szqAwvKkk7AZHTQ0h2lrqSKRyNDXW0FjvH/X55luBsnQ5mn5mTZT7fD5CoeEvKBwO09/fX/aYNWvW8KMf/Wi2hlTVuJHyOcwnd1AVO/ft5Nne4ZbGEskCYrJuHmNt5zY2BPF6VAq6vbtlCjEqdVsIO480n9dRUIppac52t8Dv86AbFj6PhuZRMQ0Lr1dD1000ze5gKLD9yL/1/QNYlv1vRVHc1JurAwk6Lg7Y+eWaiq6bXOyO0HV5kLpw0C2CK6WhLkS0uFMwkmOnu7n5xCV2blvNY0+doL2rn3zBYCia4mLPEP/xn8dorA+57i1SoEsm4nqKB0emV0VjaQ4d6yKeyAAKl3uHSBcdkJzXUFXblQVALUbFRzoeCUFx0WovniPRFD/7+Wl0w2AolqGxPkhkKE08kSGXHy5+NrIFDMNkWVs9Hk0llsjadSSqMpyeBng0leVLG9h76zo2rWtjKJYmkUiUfbaxdp7m0v1EuhxNP7MmyletWsXly5fdv2+88UZ+/vOfl0Vn9u/fT1NT02wNqaqxhH3M5kOkXFUsvB6VVDpP1+UI69e0zvWQJJJpZbJuHpW2a4UQDMVyJRfh4WKv4a6aNk4kXVHtAjQhBKqi4Pfbrb9N07KtEnUDyxT2f4uPMU0LfzFnNl8wOHa6m3xex+/3uqk3saJThL/Y4rugG0RjGUzLIhrPsHFdGzduWEKnlXO7Cb54+ELRQaYyLx6+wGNPneCJZ066t/UPJsjl7RzeRCqL76iHzkuD0pFBMiZCCE6eu8o/P3ySgy93ldVsOOfLZIoHFUVx5+MjPz5Me2c/qUwB07IoFIySQktbZFvWcLGnx2v7jefzhptnroArop1xWAKS6RwDkRSXe6MMDvnp7bd7dXi9mpuqohT9/03LYs3KZmqGUgwOpdxib021d8G8Xo2d21bzsQ/dBcDBo5089rOX8HhD4/qUOwuYY6cuMzg0bNf6o/88xh23beBTf/Bmjp68PGOCXbocTT+zJspf+9rX8sMf/tA9Ud/97nfzx3/8x7zlLW/hzW9+M7/4xS/4xS9+wYc//OHZGlJVIxjOKZ9rFAXWLK+n/WKUk2d6pCiXLDgm6+YxcjtXCMH5zn76rsYwTFFMOxkW5M5/R6aaOs4rigKqV6W+Lkhbcy19/XEiWfv1DdNyC0aVoq2bZpjEE1lWLbdzW4fiGZa11buve6l3yB2X4+7gjN004fmX2rntlrX8t/v2sHnzZjRN44lnTo17bF4pFpQ64t6yBLphoqkKubyOz+dxrRqlI4OkEkII/uWR/Ty3/yzdfWnyBX3YcjSeYdO6tuHg3YjiQSEEh4518f3HjnCm4yoUxXRtOED/YJJMruB2wR3ZmdMu6yhvNKRpKj6/B6vY4VNgF2ajDNdvqYodEOsfTOL3ebjcO2TbHyoKHk3Bow0Hy3xeDwXdJK/bxeGmZeErWgebpuX+7/mX2vnW9/fzvnfsY/eONdSHChN29Dx8/CLHTl0u66oLtl3r40+f5MSZHlYua3THPd12hdLlaPqZNVH+4Q9/GNM06e7uZtWqVfz+7/8+zz77LD/+8Y95/PHHAdizZw/333//bA2pqnHSV+ZDpBxg3aoG2i9GOXGmh1/75VvmejgSybQzGTeP0u1cR5B3dA1QKNiFXh6PhmlYWMJEiOFFdcUCsGKULl8w6O2L0T+YAGFf5PO64Qpy+/mAZV/kY4ksgYCXgUiSxrrSnE5BOl2gUDAwTIGwLLwjxEE0muG7jx5kYGAtf7RpEzB+3qgQghNneuiPJNwof6FgYFoCq+gNncvpZX7m0pFBMpLDxy9y/BW7Jqkwwvs+Ek3RWB9yC6yd3R7HEvG5/edo7xpACEEg4CWX04knswT8XjRNLUbHrUpOn6NQFMV1aNF1k3S24Ir8YQ9zBU3zoCjQ0xclFPQRi2VQVHseGaaw3w+7467f57GFecHE7x+2TcxkC1iWhaap1NUGSZSknb337cN9D8ZLT9l/pHNUV12HXF7nxCs9BPzeUcXp07k4li5H08usifKdO3fyla98xf3b6/XyH//xHxw6dIiOjg7WrFnDnj17ZD7yJHHSV+ZDTjnAulV2NO6ELPaULGDGu0A69w/F0nReGiSZyhFPZt0IndejYVgWotiF07E9HP/9ht9X103bczmvuxf9UgzLQrEUNFUhnc7T3tXPDRuWsufWtRx/pZtzHf0UjKJgtmx/dNMwyRqWW3SmeiGZyvHjJ8/Q2trGB3/9VePmjQ4OpcgXdPvzFEW5E4w0LYFqCUzLKmsqJh0ZJCMprcXw+exFZynOTgvYTkBOzvlAJMn5zn7ixU6e+ZL0FKf5lmFYo3aiylAUfMWUk1DQz223rOX1r76Rp39xhp/vP08mVyh5qIKi2IJ9KJbG69HI5nR0w3T7AkBxOilgWaada57Msqytnoymuu5HBd0A7B4CAb/HHf+x093cuHEp9aGJ8+ujsfSorroOjl966bEbecylkJ5/zHn7xd27d7N79+65HkZVYW+pza9I+frVDQCcPNM7twORSGaIiS6QlhCceKWHxvoQg+EAVwcSZLP2Bd3rVfF4NIQhwKO5qSMTaPIR7z88DrDzXB0PZQenc6ElnFbeFjffsBxNUzl19goNdSEi0RRCKG6bILs4296aD4dsxwddNzlejKaNlzeqabaNm66bRZFhb+07QzJNC01Vyzp9TtWRQbbxXviULtTaWmpJpnNl95futNTXBTl60q5P6x9Mus2zgGKaynBqmL0rVTlFDIb9/n0+D7U1AT7+26/n/e+00zre/87b+fzf/ZiHHn6RXE7HME00VcUSYJqmLfhNgZkt2OktJQj3/0AgKBRMuq9ECfq9hEJ+MtkCpmmnsfi8GkpxVewsXg8e7eSNd6zg8PFL4zbn8Xq1UV11HUzLnnvD9wsGIsN55xcuDcp5NA+ZMVF+rbnhsqPnxCRSeZzQ1nzIKQdYu6IBRVHo648zEKm8MpdIqpnxutc9+dwrAO55H42lyRUjVY5IUBQT0xwWCXbb+8pNS8bCsT4ER5yXz3/DtLfDNVV1O2weONoFwM03LGfL5qX84mAHvVdj9uK+KCaEJQiGfNTXBoHhxiVONG2svNHHnz6JaVokUjnyBcN1dTEt0x3jktY6WpqGO31OxZFhrIVQR1c/P3nqBE0NNQzF0hh6hnve6GPPreukwKhCGupDrmVna1OYWDxblpLhiNUdW1aWFR3nC4ZrM+igFxeHliguOJXR9qNgz0G16A2+e4cdHb9p0zIe+MYzvHL+CkPxDFcHEtTXBqkNBygUDNKZPLmcPlzwaVl4PKq7CB4P0xSkMgWyOZ1QyI/Xq7ldfgu6SX1t0F28Oj0DDh4dvzmPQnlX3VLsjqbe4rETnOsozzvPZgt859GDsvh6njFjovzBBx+8pudJUT4xkaj9o6Qqc984yCEY8LB+TQsdXQOcPNPDXXfcONdDkkimlfG61zlbyC1NYc5f6Kf3apy8bhd+CSHQDcsuAvOoFAp2xA0FhGUiitaHFTJSKlLuo1wuBkzTIp83qK8Lsml9G6CURSEVReXVezZw5MRlOi8PkrfsPTefz8PS1jqc8LnTuKS0k2elvNH9RzppbQ4TjWXc3HG7SNUWPY31IW7dusr9nZqqI0OlhZAQwi1s27i2jZamMPF4nH/94Uucae+TAqMK2bdzHR1dRYtkRWHzhjYGIk73XJ0VS+vxejUu9Qxx5MQlwjV+WprC+H2estSpgm7aO0fuwpViLnj5+ynFQs2A38uvvWkHN9+wnKd+cYYHv/cCiWTOzU8fHErh9Wj4fHYTIMOwHVzsHSb7RSdMjxmBaQnyBcN1UzJNi1x++LdCCEFjcTdpvIZeADUhP3fctoHHS5yPHJa21pHXDdpaahmIjM47dxYAsvh6fjFjoryzc/wVnuTaGXRE+TzJJ3fYeuMKOroGOCFFuWQBMl4utLNF7BRdOdE7tz+IJSjoTptt23rN59GwfPaFuaCbiGLx5/WgKAoer0YqnefoiUvs3L7aTRdxijUVRWXnttXUhgO0d/bb9mzAYDSFpqosaa2loc5OY5ko1cTON++n2KMUr0dDVRW3wdGGtW00N4ZpbKi5pq3y8oWQvf1+4eIg/ZEEmqrSeWmQlsYa9xGTERgyHWb+sWv7Gk6c6eG5F+PFW5zuuWEyWZ1gwIuum0TjGTLZAn0DcaLxDK3NYfoHExR0wxW4mqZA0SJUoXzhOux4ZFsVbt+yghs3LeNnP3+F851XSSSH60B8Hg+qplAoGOQLhp3ihUIo5Cef1ykUd4MmU0A6EgWBZdouRc5i3TBMOi4OEEtkefev7QZ0GutD49qRNjbU8Lu/+VoAnn+pg3zBKLOSzObsY3f63JWy5zU3hst2r2Yyv1zOt6kxY6J8zRrpTzlTRGL2JJ0v+eTCMjl+/Dh1QR8Azzx3jN9536vx+0d3JJNIqhXHhUQIUeYJ7Pd50HWTmpDPjZhrqoounKJKNxkcw7RtDhVsmzSjKByU4q7XVFJZKmF3/LQvdH0DCQYiKe67dy9AWbGmoihsXNvK1YEEyXQOn9eOOAYCXvJ5g0u9cRoaGiZMNdm1fQ0/eeoEQ7E0gYDXLWID+8K/fnULa1c1E0/meOKZU+w/0jmlC/LwQmh4+z0ay7gC7OpggnOd/SxpHv6tGU9gXE9jGsnMoSgK73/HXmqDBlcGDOLJHA31IeprAxw5cQlFgYFIkv7BJNF4mkQyRy6nU18bYPnSBvIFg0Sx2FPTbK9xze8lmyuQL9g1E6qioGkKguEE84vdQ3ztO78gMpQik8lTMIaLNdPZvLtI1lQFb3EBLYrFy1BsBFYpN2YChIBQyIeaHz7X3BSYkpz4Pbeuo/NyZMzX2bdzHaqq8uk/fEtF4btz22qOnLjEX375J6MEe+l5PlPF13K+TZ05L/SUTJ3BIXsCzZd88nxmkD//m3/HX7saCPPcwXYOHTrEHXfcMddDk0imDWeLvZIncC6n4/GobmTc59XIZilrEuRcfDRVpaDbjiWO1RpFMT3SR3mqCAGZbAEFBa/XIJHKsXPbahRFcYs1nUXFhUuDxOIZaoI+QiE/Ab/HHqOAeMIWRROlmiiKQmNDDRvXtpUtUtpaamlurKG9c4BXzve5nUIne0F2omunzvVy5Woc3TDJZPIEAt6yHGJNVRmKpvF5BPVFO/bxBMZ4dQFyG39uURSFrZuXcO89w97c//CNZ1AUyvKhNc3ehYkns7xyvo87922isT7EwaNdGIZJKOijvi7EutXNHDlxiUQqZ0fNFQW/3+OmuGiaykAkSTSRIVds5sPoRruAnXJiFgtKS4tGS4usp4Izzx17RNOyCAV9bFzbRmtzmINHu3jjHSvYtX01Z9r7xm3OM1EkeveOtbz+NTeN23lzqsXXk0XOt6kjRXkV4qSvaNr8iJQD+EJt1NQvJRtJgeIrazUskSwEdm5bzde/+wvau/pdZ4NAwLYzW76kgVQmx9XBFIZpouum7TPubJc7/yt2Bgz4vbaLg1WcJ9MQJXew82gFum7w8olLfPiPHuJjH/wl3v/OfWw5fpEHHnyWy71RUukc4Ro/Ab+XXF6nUDCpDQfw+zzUBEM0NYQmFM37j3Tyk6dOYFliVARuIJIkEkvh93lHPX+8C3JpdM2jqeQLOtFYhoJupxGU5hAHi5H5SDTD2tX288cTGOPVBTj3S5Ewf4jFMxXzoetq7eZY0Viaw8cvsXJ5I6/es4G62gCRaIb+wSTdV2JksgU0VUFVbZEvignmjgWis1s12XoO9zWuE0VRSGfy+HweGhtCWJZFwO/j+Cvd5AsG4ZCfbPZm/nDDhnGb8wCTikSPZ2sKUyu+ngpyvk0dKcqrkOFI+fwR5WBHrVRFwRJwsSc+8RMkkipBCME3H9nPhYsDBANeN7rlbKGDnTMeCnpJZwQ504mq2fnVAruTsQKomorPp1FXGySeyJLKFFAVMIzpEeUOloBcweDg0U4Mw+SNd25hy+ZlNDXU0NRQw5ETl1zXBiftZPWKJrdwMhavnMs6ckvaKnohX+yOuAWjS1rr7GZHUOZRXsr+I53s2r5mlOCorw1w7NQlBofSXB1IkM4USGfyKKpCNlcgGLDT5Gx/5+FGLw7jCYyJtumlh/r8oqE+5KaE5XI62aI1oa5bgCAY8BEK+ljWVk//YILnX7pgd9N0izlw3VJqavz2wthnR8sLusm1ZE6URsqd3eqp7HB5NMXOVddNotE0oi5INJ7BsITdKVRTEZbg3/7jOB2XUnzl/veO2Zzn0LGuSUWix7M1rVR8PV154HK+TR0pyqsQN1I+T9JXSvF4VAq6yYXLsbkeikQybTjbsPmCOSp32i4OyxEMeAnXBFi2pIGzHX2IkhxyBPi9HlDsC7kloKkhzKv3bOR85wCXe4fo65+ZhWwsnmH/kQtc7o1SE/LR3GhbJVayUusfTLoFYI1jRJzLt6QFubzhNm8p6Ab9qkIynSOdLlBT4yvzKC8lGktXjPKdPNNDNJbB47WDDjVBH+lMnnxeB6GiaQqrljfZnR+Lx9axcJzI3WW87qTO/ZL5w76d63jkx4eIJ7Lk8va5apiWuwjzekyi8bTdSCeeZmAwSSjko642QCKZwyomaAvAMEx0o2gBWrRlUYv3TQ3H4d8W0ApgYE1KmPt8GkG/F8MU5E2dgm6nmOnFnR9TgGmZ+LweBHD8dDff/sEB3v/O2yu+3mQj0YqijBtxLxXa05kHLufb1JGivMqwLItI1F5dzqf0FQePR6Ogm3Reis31UCSSacO5+FUSsk7zkmDAjtxuWtdGNJahbyCOlSvg0TTqwj7CNUFiiSz5go5lCVKZPEdPduP3aaxa3kT/YMJ1ZxmPsRqhVMI0LYRQyGTt1uORoRTReIZoLENbSy2JVHk0vLQRyZ5bK0ecS4XAQCRFoWC4KTBgRyaDAS8F3aDJG6K1OVzxddKZfMUoXyxhe1TX1wbtxY8CdeEA8eKHDgb87Ny2erjYNq+zeX0jv/HW28b1KRdCUF8b4NTZ3rLcd3t89nNmahtfcm3s2r6GhroQl3qG3Nuc1CVVVcjldYaiaTRNJZHMoWoK+YLBUDRdbGMv3EVxQTdRi64sajGaPhl/8VLsouzy+TfZ13DGYQmBpjldRAW5Ec1/bJ9/23rR7/Pxk6dPjinKpxKJHsvWdCTTmQc+V2kz1YwU5VXGQCSFYdoVKfOl0LMUr8eOWMlIuaTaGG/L1rm4VRKypYWHbS21KIrC+jXNZLJ5TMPCME1yeQOPR0dRbBHv0VQiQymCAa/bdGcyfsdej13kphvmFHzNBZZpERlK4dFUPF6NwWiSxoYQzQ1hIrGUmxrg0VROne3lpo1N7Ny2quLrlV7o+weToNgFa36fx16gKFAXDtLcGC52+RxDJI8xXmfRk83p7o5EwD98nPIFOx3BtsyrZdtNK9i3vYnNm8feWneif8dOXcbr1Uik7MVRIpUlGsuweUMbO7asmpKHumTmURSFzRuW0NUdcZtxqYqCx6sisNOWnPPImYe6bpK3LCyniBr7XFMEeH0ahmEiivUewpqio6EyXB8icBa9dmqanbpZbr9Y3lPAXhjoholaLPKuCfnJZIebAWqq4u6A5/IGteHxhfdEkej6uiCHjnVNKQ1lOvPAp5o2I5GivOro6YsBts/pfLQS8njs6P3FnjiGYeIpinSJZD4z0ZZtQ12QoVgKhCCRzLn2a76iTZplCdKZAleLedSRaNr2NtYU/B4vIBiKpjEsCwX74p1K50hl8kBxG30cdaAoUFcbxOtRSaXzIBRUdXK5rE7jT9MS+HwqiWSWdFolk71MU32NbS+X11EVhVDIThU5cOQSv/3H/8LHPnSXu/3tUCoEHOcZJ8deU1WaG8Ns2bwMsH+vHCu70uj0G15zE5d6hio2R/H7PCQpX+yUCn8nJ94RGLfcvJL29vZxj4ET/VMUhU3r2misD7lj0g2TW7eu5n3v2Dcvf1MXK84i+VzHVfc8D4f8RfeiYtFv0YkF7LlgC/fhLrmqqiAsW5wLirvLClimVbREGsNuZRys0tcWxcLqSpN3jNcVxU6joBQF+XBuusAW7ophW6UODqVAsXPHKwnp8SLRQgiGYmm+8+hB97bJpKFMZx74VNJmJDZSlFcZV67GAFCUKZSLzyJ2So2goFt0dA1ww8alcz0kiWRCJtqyveXmlZztuErnpUFyOd3OUdVNN2Uj6PcS9HtIpnIMFMVeXTiAz+exc6LTWWJGHmFaeL0aimJH2fRisZk6wcXJvpCLovuIUsxLn/y2uR3Jg9oaP0OxDOl8nnQmTzpTwDDsDqOWAql0jmgsg64b9A2kOHa6m9Urmli+pIGungiFoqtSrmCwblUT8UTWzScH+zOlM3nOd/azaV0rwYC34sLB6VpYSZQ31IVIpfOjn1cU5m0tdZP63KWURv9Ko+wO8WROCoR5ROkiOZvTCQW9qKripor5vB6EJbCEIJ83uNwzhK6bmJYoyfguX7RaCBKJrHufpk0+DUxRSkW43TF0vAWxUvw/u3lRpdcbXkh4vVoxzWb4NiEsNFXBtCyaG8N859GDnDzTw803LOfA0S5X3O69dS07tqysGIm2Gw9lqLRTNV4aynTngU82bUZiI0V5leFEylXmpyi3L/4mlvBw4kyPFOWSqmDklu3IBkFnzl9hYChFNldAN+zGNShO0x/QTYtILENLUw3ZnF3A5fNq1NeF8Ps89PXH0U1729w0LXw+DYEKxdeajPFKNmt33tRUBZ9PQzesSXUBdQR/IOAjXoyKCyEQplVcYAgMbEHjbKtblm0Xl7sap38wgVrs0Gmalv1vRaG3L4ZWtHh0BIXtiOIhErUt7BrrQ6MEMMDxV3q4dWvl9JglrXUkUzlamsIUdLMYYdfI5e3oqMejMhRLu1G/E2d62Le9adxjIF0g5jdCCA4du8hjPzuGx3uedLZAb1+M1uawmzIWDHgJBrx2t02vh0vdQxR0E4S9q+JEq8ebDqX3TeQx7qzRVFW1DQwKht3YZxL9BETJm41MYynrMloM4StF4SyEKPscNcXuoYePX+TZF86yYmkDm9a3AYp7/m+/aQXvedtto8T6Iz8+wqmzV8ZsGjRWGorMA59bpCivMtz0lXkaKQfQiqL8+CvdvPMtu+Z6OBLJhJSKMiHEqAZBg0NJO+cbe+vZyUd1RLkjTjVVA8WurdB1u1irUDDI5w0sYXf3FJYdHbe7fU6cR+5gOA4NJm4B22Seq2kqoZDd8TJTTJexrRqHnSd03URR7VbfpQXkpiWwhC3+nduFbufEWpaFx6Ph92kYht3e3DBN4skclmkxFE2zZmUzwKgOgmAXdFaK8rU0hakJ+QkFvThRvoFIkvaufpqbytuDg+1QURs02Lx585jHQLpAzF9K8/3j8Tj19XD63BU333/Tertw2pmPSrFYMxTyYabsxaPdA2DYv356BgZ2809h7zDpRnH+T704tPQZIwW7088g4PMWiz4FHk3F51UJBbykMnmyOZ1EMksmazc52ryhDWduHH+lh603ruD3PnSX/frF43ngaKdbn+HWT8QzbFrXhqIoYy5EZR743CJFeZXhRsqV6fU0nk40xUDHz0svd831UCSSSVEq2gaHRjcrATsaZ+h2nYRHU8nlDTeqZQl7eztc46emxkd3b5REKksmV7CblBTbdyvYF+GCbhajYtc2XsO0W4ePJ8ydxYKd926SyeijWoJ7FNu2UQCiGP13itccnGI4pysi2AsTO//VQFUVmhprSKXzJJN5rGJzFqegMpnOlYkBh3giy+996K5x24M7t1/pj7NxbVtFcQ9w/JU+7r1n7OMlo3/zl0qpY44LUCSWonEoxOYNbQxEhusAUukc61e3cKa9z45gM0Ze93XgiGch7HqQa262W2GSuk3FFDsVTcGe05qqEAoG8Ho1DN1we5Hkimk7pmXR0xclmsjg9WhuBHz/4Qtu1Ns5npWcoiLRlLt7NdZCVOaBzy1SlFcZvVeiwDyPlKsmmPDyyctlzT4kkvlKqWgb2azEtCw8moplCUxTYBgGhqYWi7WcrWc73/tiT8Ru/V4U+E50GyHKLurTISDGi9hpqi0qLGGnvVgVFgCWJShYZvmNYmzLRSGGxYQouS1fMBgaSmOYxZxepegOUyyKtbssDosBh4b60Lj5pqW3/8XfPzZupDuZyo15H8jo33ymUuqYrptEYxlMyyKTLbD9ppW0NIVpba5FCMGLhzqIxNJQbLZjmJPzCb9WruelLUuMdmYBN+peKJjFpmJ21ahhWpimQFVBiCR1tYFhZ5mCSdzMks3pNDaE3Ah4oWDwsQ/dhaIo7vGs5BQF9u9ba3PtuAtRmQc+d0hRXmXM95xyAAWLxvoA0XiOw8cv8eo9G+d6SBLJuJSKtnxBL2tWEvDbeaypVB7TstwLqiimo4AdkfZ6NXTdpCCMYrHWcK71bO9rOWsBRSk6T0xhAM6CYeS2uzLi36XFdHndcO93FisIXJea+tqgKwYcphKdnij9pDYcGPf5Mvo3f3HSKIQQdHUPcamny/YYF8J172rv6nd3WwaHUmgezU6f0uwdGatkLs5H7I6+xX+L0SLf2YkC3DstC9LZPHndwFPsCmyjlDsTYaeCOYWbzvFsbQ6Xpf04RON2PcbjT59k/5FOOQfmGVKUVxGmadE3YFuuzedIuaLAlk0tPH+omwNHLkhRLpn3lIq2M+1X0A27q14g4KWQN+xcToYLsEzTKhOpzm0ejzbsgTwfNMLUHd/ccY96XskHVlQFMaJQzlmoDD/fjvpFoikymUKZp/NUo9MTpZ9sv2nignIZ/ZufNNSHiERTPHfgPH1X4253S6co2rIsWhrDDA4lAUFff4JE0o4WO4XJ82KujYMQ4PNqCAG6YU74+OEFrsAwTAxhggIeTbULsg3LXpyoKsGAl41rW93CzeEFrDIi7UcnkcwRDPpc56NoPHNNnTolM8f8awkpGZOrAwnMYt7ZtTQHnk1u3tgCwP7DF+Z4JBLJ5HBE27biVnljQwgFyBV0e95pKqXXLDdupTgCwm7SoyqK25nTiZjPlWiYytuq6nB+KxRz0jXFbVikKMpwDn3Rjk5xbd+E7QftFLCBa/OmKiqGaRJL2IVm73nbbVMWALu2r2HHlpUV79u+ZSU3b2qbwieVzCf27VzH+QtXuTqQcAU5DAtT0xSkMjkKBYPOSxHiiaxbB1HQ7SLqaS3wnAEcS0VlkopLUYdtUE3TboRkmYJ8wSSXs3sDpDN5u9dBOs9QNEO0uJNUvgNl23/efMNyVi1vwu/3sH51y6i551gkSuaeqhblqVSKj3/84yxfvpxAIMAtt9zCv/7rv074vAcffLDomjD6f319fbMw8mvDSV1paggy3xe0WzbZovzgy10Yk4gMSCTzhXDIT3Oj7fDh+CJbojyH2ymydPBoKsGg3XUymc6P6uRXDTgiWimKc69HIxzys3xpPU0NIRyJ76a3FBseuckuFRYsYAt7n89DOOznytU4D/7bizzw4LMcOtY16dx6Zyfjvnv3sH5NK00NNaxf08p99+7h/e/YKyN8Vcyu7Wvo60+UNf0BQFFcK85sVkcIyGQL5AsG2axu+5Kb1qji5fmIU3vh9CWYzONhuMeA/cfw3HPSdVTNXvB2Xh50G5E5C9iBSJJTZ3s5cuISp872cuHSIE0NNaPcixwm6uQpmR2qOn3l7W9/Oy+99BL3338/mzdv5jvf+Q7vec97sCyL++67b8Lnf+Mb3+DGG28su625uXmmhnvd9PTZRZ4tjUG6R5tDzCtWr6inrjZAIpnj5Nlebrm5siexRDLfaGyocbs+Hj1xCdNSURVwlpaqauemlOsHxe3sOZ9zWyfCKjZfAUCAYVgkU3maG2tIpnPk86Z7pyPKbc0wxm6AEKiavW2fTOXw+zy0d/Xj93sm3DZ3OjqOzAH/2Ad/qezxpikX/dWMothWmj6vhlWMgNsWh4r7PWeyBXTDpKCbbvS42rjWxXml3xNHrHs02wYykczyXy+c5R++8Qx7b11brOsQpDJ5BiJJdN1eEERrgzTU2Q24RlmUSq/+eUHVivKf/OQn/OxnP3OFOMBdd93FxYsX+ZM/+RPe/e53o2njt3jfunUru3fvno3hTgtOpLylKUT35bkdy0RoqsLtuzbw02dP8czzZ6Qol8xLKgm/+toAigKtzbWsWNZIIpW1t9aNQsWW2kLYW+yKYk068jtfEWK4nKxgmOimSa6gk0rny3JhRdEvTnED5EpJIdrwY1RVJRz0kSsYaEV7N8fuDsbuLFja0dFhZItwsO3fXjzUwYWubtav7eH23Rtk0VoV4vFoaMUmPU4/ANtn1BafliXKvP4XOm5dxhgfVYhibwHsqLlHU0mmcly4OMCBIxeIxtIIIBpLYximOx+i8QwHj3axecMSNq9fUjZPKlkkWpbFt39wgJ88fdL9fXzz67by3rfvde0aJdNL1YryRx99lHA4zLve9a6y2z/0oQ9x3333ceDAAV71qlfN0ehmht4rMcCOlFcDb7jzJn767Cme/Pkr/OF/e+NcD0ciKWMs4SeEcFt7t7XUEk9m0IsRukrYDUAsdENUvSgfibPgKI1GO1E6yxLF1uOi6ImuFq0fi440morf7yGv288NBrwA+H3llx2nQK10gfTKuV7auwZGdSEEW8gfOtbFqXNXOH66GyEE8WSeC5cG6bwckUVrVci2G1fws5+/YluIFq19BCAs59xSZtz2sBrRi82+LMsimclz6mwvqUyedCZPoWC4DlJgz0fTMsnk7G6pTQ0147ohWZbFR//ntzn+yvDvYyyR4R8fepbnX+rgH79wnxTmM0DVHtGTJ09y00034fGU/8Bv377dvX8i3vKWt6BpGk1NTbz97W+f1HPmktJIeTXwhtfcBMBLx7rcIhSJZL5QqWkJ2IIzGPBy69bV7Ll1HfW1ITsSXmJrNpLhos4ZHvQ8wPmsDk4BqM+rEQz48Pk8eDQVjzbc+MQy7a30aCyD16tRmnUei2fcBdJ3Hj3IhYsDtHcNkEhlae/q53xn/6jFziOPHan43YEsWqtG7rrjBrxeray+y8GjqYSCfjttTFKGvWi20A0L07C42B2hty9GNJZ2c8wdNE1F01Q36OD0Y4DKXv3f/sGBMkFeyrHTl/n2Dw5M/weSVG+kPBKJsH79+lG3NzU1ufePxdKlS/nUpz7Fvn37qKur48SJE9x///3s27eP559/nh07doz53Hw+Tz4/fLInk/aJbZrmNeU2mqaJZVmTem53Mae8qd4/5feZbUzTZPmSem7YsISzHVd56hevcO+v3Dqr7z/Z4yqZPDN1XMdLNRs55xIJ2xb0esfx4qGOcSPbsXiG3/3gL3G5J8Ll3iEiQ6mKdodOXvViEOQjEZZwCzztqJmwvxdLAHYTGABVs3PuvZrGYCSJEILN69pAUaivDXDwaCfHTg3n5OXzuqvbI0MpGuqCZVG9s+19rFttF5MLYRUdbiycONOLhzq4dev8S5mbT79LY825sebbtV7jJkMsnuGmTUtp77xKLm8fI1VVCdf4WbeqhTPtvVKUj4Hz+6NpKtlcwXajsWwXKCXgdYW4U0iroJDP2+4ta1c2sXfnenZtXz3cX6DIT546Ma5900+eOsF99+6Z4U83v+bM9TBROrVD1YpyYNztyfHuu/vuu7n77rvdv++8807uuecetm3bxmc+8xl++MMfjvncL3zhC3zuc58bdXtnZyfZ7OjuWRNhWRZDQ0O0t7dPuBV0udteaJiFJKZpYhjDuZmWZaFYw7eN/Hsyj7mW51S6zTRNuru7OX/+PLu2LuVsx1Ue/clBtm6sXPU9E0zluEomz0wd15EF16WMNeei0eh1jeNCVzfxZH6c+3OcP3+el092EfCrqJqCZVS+Si1GQQ7DrcgB0sXInKKAx2MXxxZ0A59XQ1Ug4Pfg86rouk7f1Sg+j6CxPsiy1qU89rOXiMfj7utalkGhUHD/vtQ9gM8zLBoymYz7eCEE+XyOrktZhmJZdN3k1JlLLGv1cPOmtnmVxjKffpfGmnNjzbeOjg7C4Zn5De+82ENbkx+sBlIZA1238Ho1mhpCNNR5OVYw3QWeZDSKUlw0WQJRLLq2il2GVcXuOmwWf6S8HhVNU1AVi2wmQV0wT3t7+6jXvNIXKZuDle4/f/78qNuFEJw638/xV/pIpnLUhgNsv2npNc/F+TRnrofxrnGlVK0ob25urhgNHxoaAoYj5pNl7dq1vPrVr2b//v3jPu5P//RP+aM/+iP3756eHrZs2cK6detYubKyj+54mKZJe3s7GzduHHcllc3pRGJ2dfTWLWvRtBfKUnds6yjNvW3k35N5zLU8p9JtmqaxcuVKNm3axLveqvKdHx7j0PFe1q1b73Zom2kme1wlU2MujuvIOZdIJFi1ahWNjY3XNY71a3u4cGlw7PtXt7Bp0yZCoRDWUBaf14MQBsISWGO5jSxynEuuqiiY5rB3uaKq5PImhgmBgJeA30s6a/Frv7yFlSuW8a1H7UIyn89DW0stq1e20tE13CxIVT3U19e7f7c0N7mFp5ZlceJ0jEzeREEBRQPFw/OH+0hmPfPKMrEafpfGmm8bNmygrq7uul/frh24xMGjnUTjGRrrQ3h9NdTX+1AUhc31dSiOobcQHD55CRhOk5IM47jUaKrdVMgwhheuTmqLhX2Ndh7n9WiEw0FWr2ylL6KTyPrZvWN0I69lS5vJXx4742DZ0mY2bdpUdpsQgn95ZD/HXylaS6sBkhmuay5Ww5yZTqpWlG/bto3vfve7GIZRJhBPnDgB2M4qU0UIMeFKzO/34/cPp484W3uapl3zCaOq6oTPv3LVFg81IT8NdfO/0NP5PPt2bqC5sYZINM1zBzvcPPPZYDLHVTJ1Zvu4jpxz0zWO23dvoHOci87tuzegaRo3bFzKmfY+t7mOYY20QxzemVv0hWjKsDMEit3irFAw0A3Ljp4XDDt6V6+wYW0rKArf+9FhsjmdvG6Q1w2S6RzNDWH7d6NYi+L3e91jvGPLSrZsXsZ3//0lACLRNPFkDp/P564KlrTalm8nXunh5VPd86qL53z/XRprvk3HmCsVV8cSWQYiSYZiaZY0+1EU1f2uB4ZS9A8kCQR86HqOqfenXZioCkXrSPs3yRIWpjn62Dh9BIRlEfL50DwqAb+XlUsbaWupBRReOnaRvTtHpwK/+fXb+MeHnh1zDG9+/bZR58OhY12cONNbUXhfz1yc73NmOqnavYB7772XVCrF97///bLbH3roIZYvX87evXun9HqdnZ08//zz7Nu3bzqHOW1c7LF3ANasbJo3UZ/J4PVqbi75wz86NMejkUiGGa9LZGnh0zvv2YnXq6HrZtHmTxlR8Fn8Q0bx3ENgFa0jhRj+t2WJovc05PI6ubzOiVd6AIoCYZhILEVjQw0b17ZRFw6ycW2b2yzoA++6nd071rrfXWnBGkBzY7isQYpsijJ/GKu4uqUpjBCCiz2x8oY3Fwco6AaWac37hnlzgUCgqeqYwQBVwT1umqayfEkDu7avYfOGNpzfrbH8yd/79r3s2FK5LmPHllW89+2jNdZEc03OxYmp2kj5r/zKr/DGN76Rj370oyQSCTZu3Mh3v/tdnnjiCb71rW+5K6qPfOQjPPTQQ3R0dLBmjX2RfcMb3sCdd97J9u3b3ULPL37xiyiKwuc///m5/FhjcqmYT756xfxtbjQWv/6ru/nad37BT546QTKdo7YmMNdDkkjcLpGVGtSUel3v3rGWdatbSCSzgGV39zSHY3ZiuK2lpISy3YTif03TQgESySwvvNTB2lUttLXU0txYQzQeJhId7orWP5jk5huW84bX3FTR4tD57v7i7x8j6dWoDQdY0lo3ykJRNkWZP0wkyuLJPE0NPvfvZDqPaVoVFsKjURV7AbjQUYpR8oDfi2lZGKZti2ia1qgdPKcCXVEULCGoCY3eAankTw52dPofv3DflHzKJ5prci5OTNWKcoAf/OAHfOpTn+Izn/kMQ0ND3HjjjXz3u9/lN37jN9zHOBXjpblo27Zt49/+7d/427/9W7LZLG1tbbzuda/j05/+NJs3b56LjzIhbqR8xdRy5ecDt25bzYa1do7oT548wbvfettcD0kiAWxhvnvH2nG3VBVF4aaNy2jv7CeVzlPIFUZd/IX72PIW2VDMr14MamE8igfDMGyvadspQieRypJIZYnGw2xc20pjfYj+wST5gkEo6OO+e/eM2QzI+e5e/+obOXqig/r6+oqPG0t0SGafsUTZ4FDKtsvUVG6+Ybn7PfYN2MW85gR2o6UCdCHhfKTS/yqKnRvu82oUCmC47kMlzyv+b/h2QaFgDM+3WMaNlpf6k4/VRfd979g3qR36hvoQQ+PYH8u5ODFVLcrD4TBf/vKX+fKXvzzmYx588EEefPDBstv+7u/+boZHNv24kfKV1SfKFUXhXW/Zzf3/8Dj/8v39UpRLqgohBJ2X7KJDy7LGjcb5vBoBv5dcTi82QlGKonzxOkc4AoGie6LPq7k2bQ6RaIrG+hCtzbWu9eH6Na2Tyj/dc+s6jp7oGPP+kU1RJHPHWKLNSUGyPeyH8fu8w1HgcbajKnXaXQgIMZw/7vxtC22TdMZu1GXXwo0WzILhNYqqKmVHLxJLMRAJ8YbX3OSm6U2mi+5EwnzfznVcuDgw7v2S8ananPLFhhMpr8b0FYB3vuUWNFVh/+ELPPSdH/P888+XeeFKJHOJEIJDx7r4h288w1/8/WP8wzee4dCxLjdyFE/mqKsN2kK7ArZPsO04ks3p6Kbt1e14/y5Gi2WlmM+qqAqqZtuw+fwetGJToaaGmrLHj8wNn+wFfNf21dywvqXifZWaokjmjrG+03zBQABer1qWU+71aPh9HrdL7EQsxLxzp45l5G2lHU4tS7iCWXH/z0ZV7K68liW4OpAgnSlQWxNg+dKGMqE9Vr4/TL4h12TrdCRjU9WR8sXEpe7hQs/oQHyCR88/ei6dxzLioNbxP77wOEq+i0e+8UnuuOOOuR6aZJEzUYQonszi9WoMRJKYY4hypx09CDCHr4lC2K2wVXXhba1XQlXtnTG1qMgtc3hRoqoqWlFcBPxebtq0jFg8SyRm55HnC8O9D6ZyAVcUhV97400ksn5eOnZxzNoAydyzc9tqfvLUCZ5/qYN8wcBftMD0eTW742s8jyXy5HI6pmWLTtO0UFFsu8sJijcW4hSzP9LYn334Mws0TXH/thsF2Xn2ioLbYTeVzhH1eagJ+srmxnC+v2AgknLTyJzvaP/hCxPuXE22TkcyNlKUVwGJZJZYws7FW72imehAdVYwB30KGQMMy0dNaMlcD0ciASaKEF3m1NkrxJMZTKOyIK/EyMunWCw55bZPG6pmNw/C40FTVJqaasjndExLEAh4WbGkgbaWWtpaahmI2HnkoaCP9Wtar+kCbueXr3Gt3ZwdjgcefFYKg3mCEIJvPrKfaDxDW0utK/r6B5M01AXpH0wwFM1gWAK12KFSVRTSmfyi/87GCgaMxLLAo9nHSgjF7ewJ9uImky2goHClEOPIiYvFDsWlLiyCcx397kIZIF+waz8KBYOPfeiuCb+LydTpSMZGivIq4GIxSt7cWEO4ZnT1dLWgqaZrLVcwpQOLZH4wniPEQCRF30CcUNCHx6viNTQKhannhy8SSW5H5SxBPm/g8ag0Ndbwmts20FBXw0vHL9LdO0QqleN85ipdlwdpqK9h3epmtmxexnvfvndaLuTTkRsrmX6cxa+iKGW1A0IInn3hLLFkloJhoigKpgDDNIajwEKgKGrRYWWxzKapI4RAoOD1aJiWhWk5EXMFC8clSmAJhbMdV/nmwy+686GhPsTZjr4yQV5KLJHl8PGLUmzPMFKUVwGXeqrLDlFYJsePHy+77fjx4yDs5kexeAbd8jEYlfZIkrlnPJuu/sEkfp/HdTGQYm5i3OIyRUFYgiMnLrOktY6g30Mub5DP6wjsPNlkOkc0nuY1ezexc9vqMV6vsiPEWFHvyeTGSmEx+4y1+B0cSpHK5DENC6+mYhY97Z3/KYBQQFWKeRgVmuRIhnEcjpx8c6W4kFFHzBVdN8vmw76d6/jRfx4b83XbWmrZf6RTzp0ZRoryKsCJlFeL80o+M8if/82/U1N/0L0tMXiGYP1Ggl7NjZY//JMzvPUtb5zDkUok49t45QsGDXVBorEshmFiWbbTwaLv3DkBigJ+v4d0tkAynSedLdgFsIaJUjSUtoptwXXdJJ3Jc+TEpVEX/MlEvUcymQYmUljMPmMtfvsHk2iq7cajqQrCskW4s79UDO5iODUbkgkp/X0aZZWoKq5v+UAkyZf+78+4efNy6uuCrksSI9a6TkMu6TM+80hRXgV0XuoHQBMZnn/+eTfqPJ/xhdoI1Q9HvnKpq4AdaQyH/ETjGX72XCcdFwfYsKZ1roYpkYxr4+X3efB6NTzePI0NNUSGUhjG4rU3nAq6bqIbFghhL3rEsCBQinmvimrnvXZejpSJZSc6/vCPD3PgSKdbbNbaHMZRDE6U79at5V0HZQOT2WWyOxljLX7zBYNAwEsmW8C0TAxTlEV6JdOEAEVTXL2toNDe1Y/f52VZWz1DsTSWEPh8Hvw+DwXddOed05BL+ozPPFKUVwEvn7wAwGNPvszPnjnoRp2rFZ/Pg6bomJaXz33pR3zzf394rockWcTs2r6GU2d7OVYh5eGO2zbwi4PtABQKhlsYtRA9kacTIWxRbhWPl2nYbdIVMWzbpqjDThHxeMYVy5Zl8fm/f4wXXuqg50oUw7QIBryjmp6AHfUeKcplA5PZYyr5+2Mtfv0+DwG/h7aWMJd7ovM93lS1WEKAVewV4NPQigtjv29YBi5praO9q5/VK5rcnP9SpM/4zCN9yquAnj7bvzcUbiFUvxpfoHGOR3T9+D1ZVFXhJ0+d4LkD5+d6OJJFjGPjdd+9e1i/ppWmhhrWr2nlvnv38Gcfv4fG+hC5nE46k8e07C12mVo+MVYxD9+JeJb9G0ZFQxvqQwgh+PzfP8YTz5wkkcqS1w0KukE8mSWeyBabngwXolWKek8kHKSwmD6m4m09lod1W0stLY213LB+CZqmlkRyJdONgt2gSdMUNI9GNJYhGk9z6mwvA5EkLU01NDeER/UMAOkzPlvISPk8J5fXGRiyLzyaZ+GsoTTF4u471/OTZzv49F//O089/N/dpiISyWwzno3Xa/ZuorsvRiSWtj24i93xTNNakL7I08VYx8ZudDLcnTCX02moC7H31rUcPn6RF14a7s6pqaprB5fL6/hzHvoHk7Q2hxmIpLjSH+cvv/wTDD3DPW/0sefWdePufEhhMb1MJX9/LA/r97ztNk6fu8K3f3CAUNBLwbAwdBPdMt0dFZnKcv0oii3InZqufE5H01QSyRzReIaL3RGWtNZx69aV6LrF+jWt0k50DpCifJ7TeWmweHEbXT1d7bznV7fwi8M9nDzby3cePcj737lvrockkYxi3671PPLYEfw+Dx7NFogibyAsgSlV+TUx3OAETEtQGw5w+twVEqlcWROhQMBLQR/+O5vTyRd0znVcpacvRijo50pfDMsyuHA5yRtecxM337CcZCpHPq8zFM/QVF/DjZuWcvuu9VJYTDNTzd8fa/G7e8daDhy5wFA0QX8kg6oqaB4VyxLXlCrmLPok9jFXEGiahsejURsOkkhm0TS1aJtoIYQgbxm0d/VzdSDBrVtXSyE+R0hRPs9p77SLPFXFXFCTQ1gmXZ1neefdm/nnh4/zmS8+Sks4w+vuugO/v3q92CULg9LitWgsjVnS0hqK0btFdNV3RM50ix1VVfBoKrU1fo6dvkw+bxeX5Qs6AAG/h0LBSy6vY5oWaT1Pb1+cQsHA6y22YLcsCoUC7V0DnO24yo0bl9DaXIffbxewAdSFA1JgzADj5e8LIUimc/zDN56ZMOKqKAo3bVpGz5VB0lmTZDrnvsZUzzcFKcgdVNXe2fN4PLQ0hVnSUgeA16MSLS6YhBDouolZ/H1LpXOk0jm+8+hB6es/B0hRPs/pKBbGqMrkuwlWA45tYqhuOapSSzJd4AN/+C3+/Wt+7rjjjrkenmQRU6l4bfWKRrqvDJHJFkAUi6YW0YXfETlKsTvgSNEzGbE+8jGKYjtAmJbF8TM9pDJ5lrXV09ZSSyKVdd+vrjaAXjDJ6TqWEFjZPMISWMIikcpRVxsE7PSWRDLLhUseWpvryt5b+pPPDGMVbwohOH+hn8aGELpuuxVVsrIsTWVJJrP0Xk3g86q2mCw2EZrsQtBpRL+IpuW4qKqCz6uhaSo1QT/BgJe2llou90YJ+H0E/Lq92LWEK8jt56nu7tRU5s1U+wlIKiNF+TynNFK+0PCF2qhpWI1XN4jGMgi1nlPnBpCaXDKXjCxeE0JwtuNqMVq7uC/5lmWn0YkR0mcyomnkY2wzCAsNFV03ae/sJ5HKcefeTUTjYSJRu6AzlzfIFuyGQ7U1AXJ5HQOBbtii3OfV0FTI5ezoenyMlArpTz79jJW/Pzhkf3e2hWU5x053c+hYF6fOXSmbZ5ZlkcoUyGYNPJqKZVpomlosGJ74BFvcM3MYRQGvRyMY8OH1agQDXgIBL80NYVqbw2iaStflQerrgvhzHiJRu1bGmaBCCHr6YrS11NHaHJ7UvFmMXXRnahEiRfk8p72rKMpZWJHyUnxeD8GAl2xO5x+/fYTffO9bymyaJJLZZGTx2vnOfq70xzFNMW7UTlHsyO5CL0qbatrOeMdMOKFNu58Q6UyefMFg07o2GutD9A8miQylEUIQDvlpbqyhpy/mPt80LZLpPA21frcgdCykP/n0M1bxps+rlXnKj+T7jx2hoA8HmoQQDA6lUBQo6AaqaS/UhJMzJamIqhR3B9ydLGhtrmXntlX0D6ZorA+haipN9SFu2rSMfbvWI4Tgz/76h64/vN/vwcoNBxxUVcEwLNq7+onGMjTW10w4jsXWRXcmFyFS+cxzOrqc9JWFFykvJVwTIJfL030lyRf+90/47B//2lwPSbJIGSne2juv2p7bE4htx01EYqMouFH18Q6LJQQaCqoCwYCPaDzDH/8/b3JF3lAsTU3IR8DvBcXuc2BkC+7zCwUD8LuFa/V1lX3Iq8mfvJpSASoVb/7F3z82rlf8mY6rrF/dAgynukSiKdSiu5FlWe7iTyzwRe71oCgqHo/dkEvTVCjm8b980haLHo/K5/7419i9Y6173gghuOO2DTz+zEnA3v1yFrSapqJpKsGAF4BILEU6k59wHIuti+5MLkKkB908JhJNucUYCy2nfCSqquD32J/1gQef5fmX2ud4RJLFSql4E0KQSOak2J4CthiHgM9LMODDspxdhMqPdxY7Ab8XhOBMex9PPHMKgLvvupnlSxsIBLxu0LW2xo+mjn6xQMBLwO9l3ermiu9TLf7kThTuO48e5MLFATcC951HD/LNh1+sinNxogVQ6bc3OJQiErPTXXxejUDAh1EUiVXwUecMez4JvJ5iwbNpkc8bFAommVyBTK7A+c5+PvelH5edN4qi8Gcfv4dfuWsrdeEgmqqgFfPPfV6NgN+eRw6T+QoWWxfdySxCrhUpyucxTj55S2NwUezgeVWDN7x6LUII/p//8a2KDQwkkpmmVLwNRJKY1tQdIBYzQtgRN7/fw7Kl9QQD3nGjuwpQE7TzXxMpewFUKkRtN43hLyAY9FEbDuD1aqiqQjDgpSbk4+bNy3jN3k20tYzuRFhN/uRTacgzX5loAbR5wxL336W/84qi0NxYYzcRKjlnFsP1b6oIYbtAmaaFaVoYpoUANNXuOGwURfrZC3189dvP8a3v73fnkaqqfPoP38Jf/s+3sWXzcpoawwQDPuprg9TXBt1VU3NjmHBoYje0iRZh1bRLNRlmchEiRfk85kx7HwArl9VN8MiFw0d+fQeb1rdx5Wqcj/z3h9zKfYlktnA6DwohOH3uihQE14BpCerrgmxc2+aKK6fx0sjj6fFohMMB15989fKmsvtrwwH8Pm/ZbQ31IZobaljSUsfrX30jv3T7ev7fj7yer9z/Xu67d++ozqzVVGg2k1G42WKs7p1gL5Deec9O92/nexfFf8cTWbSiVaZWtPTTNHXB9emYDjweDUvgWrYqCmiagq6b6LqJotj3RYZSfOv7B0ZFzHfvWMsb7tzC6199I7fdspa2FttKtC5sz91N69pobJg4p3yxddGdyUWIFOXzmJNnegFYv6p+jkcye4QCXr755Q8TrvHz4qEO/vh/PVwV27WShYNTvLZz22oKukEw4JvrIVUdqqqwankTb3rtFtfeDiHcYlgHR0Q4zinNjWE2rmsre63W5jDrVrewcW0bdeEgfp8tGrbeuII/+K3X83/+8j3c99Yd7Nq+miMnLlVFHvZ4LIRUAGcO3XfvnooLpN071rqi3e/zgIBEMksqXbBTGf1e195QVRVCQR8ejyoXyCVomko45Cfg87gNBoUlKOgWhWINjFGMoBumSb5gVNxp2bdzHYqi0Npcy803LGfnttXcfMNyWptrURRlXEEthODQsS5ePHyBnitRTp3tZSCSpDTppZp2qSbLTC5CZKHnPObk2R4A1q1qmNuBzBLCMjl+/DjbgY9/aBd/+cALfPsHB8ikovzmO7bZK/vdu2VzIcmMoygK8WSOFUsbSaSyGIZJLm/IBeIkURWV7itR+xgua6S3L0o+b7gFZWpJTrjXq1ET8rFpSRsb17VVENAKG9a08iuv21pRcFvFjoT/8sh+ThQDGVC9lmzjNeRx7q8Gxure6eC4tjz848M88/xZLEsQrvFRGw6Sy+vkC8Pni2lai6pZ12Sorw2wekUTigKXeqIkkhkM08Ky7GPmOEFZlomKnTMOo4sux7K1hPEF9UgHkuVLG/D5PPQPJikUDF6zdxP7FmgX3Ws9ZpNBivJ5imlanD5rX2AWiyh3GgrV1B8EwMpEUIIbePQ/z/HjJ48j8pf4/jc+KZsLSWaFWDzjNrKpCflRFMhk9bkeVlVgCYtYIks0lmbdqmb6BxLkMFC18s1Zr0fj1Xs2sXxpw7ipao0NNWMKPCEEP3rqDE/+oouCbncEbWupdS35qs2SbayGPKX3LwQc0b5r+xo+9IcPcra9j0LBdtUJ+L3UhQNkswUKumnbJ4piy3iFBW87OhGhoBef18Or92wklsjQ1lLHoeMXicUzCOEUyYpiF17bAclXtBkeudMylq1l6S5TJTeg+toAx09fxklAd6Ltrc12Tce+XeurZs5Nlckcs2tFivJ5SuflQdLZAsGAl+VLRhcuLVR8oTZC9asByKWuIkhhEEa3Anj9a8o6j0kkM0lDfYjW5jDRWIZsTrf9k1Uda2EbIblMtpNixedZAq9HJZXJ09pcS204QEE3ihFP251F01SaG+2GJhNdwhwhOkoc1AUZHEry9C9eQTcUUCBf0EmkskRjGTZvaAOUqrJkm8ko3HxEURTWr25hMJLkwqUM6ayB3+9h/eoW6moDHDvdQzyRwePzkMvrRZFoLtria1WBUNDHnlvX0tRQQyyRpbU5TNDnJampZX79whJ4fBo1IT96sUtnpZ2W8XY1xvLkPnW2F69Hc+fYSPYfvmD/t8rTycZiop2ga0WK8nnKyTN26spNm5ZVtP9aLHiUHMGaFpKpHLrl5zNf+k/+3LTcrThAprRIph0hBPW1AU6dvUK+oFMT9KHrJql0nsXSO7CS6JlIqCslD2xrqeXEK91ksnYqQk3Ib3siWxaaansh33zDckChJuTnphVN4wrRSuLgbEcf7Z39xBIZ6utqyqRBJJZiIBKitbm2KvKwHWYyCjcfEUJw4dIgkWiaoN+DKewag7MXrlJbE6CuNkBDXZBUJo8xZGIYi2RVPAK1pOh1SWs9H/3NX+Knz54u3qtQVxfAQhCLZcjm7R09j6bS2hQmEPCSL9g7UaU7LZPxwx/LDShfMEiksu4cK0fw8wPnuXBp0L2lWtPJZhspyucpTpHn1htXzPFI5p5Q0IeqKMQTGU6eT/Ibv/cwQU8aRRHk0v08IlNaJNOIZVl8/u8f4/mX2unrT1AoGAQD9nZ6Ipklm9PLChYnu5WuaQoKYJjVJ+pdMS4m6NAJrudxvmCiUCAcDtDXHydf0PFomtvkxz5+AiEs0pk8iVSOfN5gKJ4u60DoCIRDx7pGiQPHTk/XTXJ53W16Unp/a3Nt1eRhO8xUFG4+cvj4RTe6m0zny+ZHLJFBCMHqFc0Iy07B0DSLXE7HXAChckWx7Qkn6karKPa80jSV2toga1c1s3vHWg4c7XLrD/w+L8GAQXBJPfFkllxex+f12B7/2AW1pTstk+1KOZbbj9/nIV/Q3TlWykAkRTyRZeWyxlHPq7Z0stlGivJ5ihMpl6LcJhDwkhrqxvSuwBQeslZj1V1oJfMfIQSf//vHeKLY7a4m6ENTFbI5HdMSqKpCbY0fS4iiP7BdSDUZFBRUTUGxTFRVGe4AKoZj79eaMjLjCDsKrmpOV0D7ZgWgmHOqYPsm237HARQF/H4vm9a1IYTg5Jle0oUCoYDXtjn0e2jvGuBM+1Vu2LDEzgf3e1jWZrtN1YYDZRG7keJACEE0niGRzKLrJkPRNE2NNQT8Hvc5jt3eQsnDXojsP9JJa3OYi90RsjkdIShLcfJ6NOLJLOliF1en66RV5SksjiuRpqkogGlZoz6Ps/j3FD9za3MtWzYvY8OaVg4fv0h37xBHTlzC7/Pg9Wr2PFQU6muD+H0eakJ+PMXmQu97x17e9459E0bAoVw4j7XL5NTbOHOslP7BZMV+AQ7VlE4220hRPk85URTl229aQT7VM8ejmR+oIoNGHENtwjQthqJpgpo28RMlkkly+PhFXnipY/gGpdgpshht0nUDISAY8JLN6aQzeQRi3C11VQGKF18BhEN2S/iCYZLP64BSdBABTVXdbobzCcFwAxdh2eFyVVXRNLAse9xOIZmqqK6NZFuLbavWWB+iJuQjl9fxeDT3eOZyesWLOoyOqJWKA6c1eyKZpaAbxTxj21avUPBSVxtAUZRR0UHJ/MP5XlOpXMX7NY/qWmaCbYJQWltU3HCBSUadnefMtaD3elQ8Hvv6pagK6GAJe+GPEEW3GXvXKVwToO7/Z+/P4+So7zt//FlHn9NzH7rvAyEJSUiABMbmCokBY1sYwuEjJsSbn5Nsvo5je+PFIXEO42N3vfwS9ruxY4MwhzdcITbgDQSMsdEt0AU6ZiSNpNExZ093T59V9fn+UV093TPdMz2anume0ef5eAyo6/x0TdXUq971fr/eAS/Ll8ygszvM0eOd/N+37NSVcCROMmng9bpw6Wqm8dKcmfWZfO+1K+fmCHIozg//irULC7oBNTUE6OuP5i3Qrqvx0dQQKLjtqZRONtlIUV6BnDkX5HxXCE1TuXTZLN57V4pyB1Ux08UtUQzDImoE+PWuU4yUvZJIJNi1a1fONJmHLsnHtj3HC4pEsLtJhiPxjFA3LQuXoRGJJgqmsbg9LrR0BNnnddHcGCCeMGg/3YuqqOi6imWpKOl210rSIDUBebNOPiqCjG2aQKQj9vnXyRYvjvAVKOiqQl2tHY0L9scwTBO3S888rKDYnuPOjbmrJ5KJ3qUME4/bhceto6oqXo+Lrp4ILU3Dm6RlR9SyxYHTmt3ndZFMF7D5vC78PjexuF2MW1/rGxYdlFQedbV+DredIzyQQFPVYQ49Do7Fn+3EIjJOLAiBy62zYG4jqqrQeqJzUJhnvYUaui0ob6de0xTU1nhYPL+RM+dDaX9vcLt1TNMimTTw+z001VehKAqJpEFbexexWJKBaBIzfQ17Pa7MdWe5ddZfNoeZzTVU+T3U11UVrEUo1g+/kBuQoigsW9TC+svm0x+O5+Skb919jONZ+eRDkW+5CyNFeQWy/V37CXbVJbOpKqLF7cWGpqnU11XRH4qRTBp87wfb6erX+JuvfgK/b3ijl127dnHn/d/CW2U3JZF56JJCBPujmVzJfNRUeamttn2UwY4Qm4pdeJxMmSikc8zTUTtdU3G7NBbOrWP2zEa6eiJEY0n8PjdzZ9dnxHFfMJoRl4EqL31jiCRl32sVlGF+zo4neDpgj6oquFwuYjG7UYudg+LYp9nrOJtQFQUl3bZbUe3ouGVZBKq8mRur1+tCUzUCVR4SSQOvN8XShS00NQRy00jSbx1aAjXpAk/Ys/8kCcsq+CCULRyyxYGTS24XsBlEowl8PnfmYakm4OO+zVdJQT4F2LR+ET/7971omkoqz2Xn87qxLAu/5mYglgDsN1aGaaGqCrqu4fO4WLKwmebGavr6o/T0RQA7qj5UlSvpU96ZrKpKpkDYEhMv1FUFXC4dn89NXa2fBXOb+J0bLiPYH+XXO46SSJq4XRr94QgKGopqF746w0oZVkaQA8QTKTxunfo6+3qc2VzDtx/81KjjKNYPfyQ3oHWr5hW8xkYS5TKdrDBSlFcgO9KifOPl8sQthKoo1NX4CPZ2kbS8PP5/3uH1X33AX3/ldj7+22uHLe+tGrRalEgKUVfrz+RK5sPjcfG3X/sEh9vO8cobB9C1XkKROKqiEIvbnsqJpJGJmuu6iqaqnOsKY1kqHo+L6oCHFUtnsmf/KRLJdLQrK+KbSBpoqlKU/aemKbh0DV3TsISwt2Ha4sIuDlPxePR0ExELl67j97uprvJw5nw/ybQY1jU1sz/n9TmKkrnZ6pqGZQm8Hh1NtV+ROyiKwuIFTZlir8tXz+PdA6dyj1vWg052rqkz3ePOfyvKjqhli4NsEV9b7aMm4KamuirjU750YfOEODwU41YhGRsb1iygrsbHea+LeDyZM8/rceFNn78ul47HY58nQghC4Xjm4djvc2cKDpcsaCIaSxBPGKiKglDIafrl87hAUTAMOyfd5dZAYH82LNsHvQTK3HkYzn6Dpmn2g3pNjY/aai/VVV4uXT6bP7n/BoQQPPHsVva+fxohBP39QZKGRldPBCGgJuBlRnMN7+4/OWxfsXgqkxJ2qO18UeMr1g//QtyALjZbz1IiRXkF4kTKr5KifEQURcGjx/mvX/wt/vlfDnL6bB9/8OdPsGh+E1/49LVcsWp45bdEMhKb1i+i7URnTrQtmw9duYQr1y3kqssX8dk7r87cSH/8098ghLDTToTAsgRul4ZL1zIFoYmkQSJlYJqCI22deNxaRqh6PTrJpIt4IoVpmlmJsiOjqSqWgJoaH9VVHnr6Buz9JOyCOV233yp53BqRgaRt9VjjA6Cxvore/igqCi6XSsqwuyZq6cickyOuoKSLyKA64MHrcTEQHRRP2Wkqa1fO5dN3bMSyRM4N2XnQaawLpJv65E4vVBSWHVHLFgdnO/s5e74fj1unuTGAWzepra3LCITFC5onRJAX41YhGRuKonDtxmW4dJW9758injDRNNV+65Eu2l25bCaxeIqTZ3oz69RUe3G7ddT0v/0+N/dtvopX3ziAaVocP9WTrjkw0w+SdgqZx+NC09TMWxhdtes7LOdtkALCzBXyY8Up4lSUwbdNiuI8ZAzWPCSSRmYc2ef31l1tHDsRZ/HCuVx9xRJefePAiG/PsiPnxZ6BYxHOY3UDuthsPUuJFOUVRl9wgP0f2DnkmzYsLvNopgaXr5rJOz+7nX/48Rv800/e4vjJbv7rw/+Kz+vid2+/gstXVJV7iJIpgnOjAqiv9dPZHSaRNPC4dT505RK+8aXbcm4oiqLw2Ts38cIrezjfFUJVFQJV3nTuq0E8aeDWtUzUrLE+QDJp0BOM0FgfyNmOIzJ6TQvDNEb3BE+nong8Lma11NDSVJMT4YvHU1hCUFfjx+PWWblsFoZp0dkdIZE0qAl4qa3xk0jaDVlURSEaS9oOGJbAm86BdyJwSxfa6V+d3WFmNNewYunMTOHq0NzVoTfkRfObWLaohWAoSrZsaG4MUOX3DLMyhPwRNUcc/Pkf3szTL9qdf+2oYn/OchPxerxYtwrJ2Ll6w2KOtXdx5do5meiwc921NFXzx/ffwPY9x9n+7vGca3LZosHOrYsXNHPF2oVs23OcS5bOpKE+QGd3iLOdIRKJVMYj3zQtagJevG6dc10hkunibSeqDqAodpFlMcJc0xScYm0E6doQFY9bR9NUBqIJEKDrGjXVvhx3II9bz3kb5Jzfl6+ex9GjR1m2bBmaprFtz/GMKK+t8RMd8kZBUwffXC1fMqOoYz7RwvlisvUsJVKUVxhvbz+KEIIVS2dmrMEko+P3ufkvf/xR/vjzN/B/XtrJD578FW3tXWx5ditbAF2pwmWYuHTp1iIpjHOjWnXJ7KJvVHv2n6Sm2pfJ6QRbKHb1RDDSEeu6Gl8m57W7N0J4wHZMaKwPZCLyiqLYhaD1AUKROOGBeEFXF0UBTdPwpNuRtzTVZLqP9gTt7Xm9LpYubKG5sZq1K+dysqOXvv4ozY3ZBZX2ODu7wygKLFs8A8MwiUQinO+OZfTzYITbbqV93+arRrzZ5rshF0r9WH/ZfPbsPzkmYVCO1+PFulVIxs6GNQvYf6iDt7f209xYnVP0u3blXK5YuxBFUTh2sjtPoxob50HMSctwWr6vumQ2R4510nq80y5AbgiweH4TTQ0B9uw/SduJTnRdzbzlgnR0W1MQaSGfqbFw6jMUBZ9HR9M121UonmIglsQyBapmWxjW1fnTfQlMTNOiob5q2MNnS1N1UQ+Q2akmi+Y30tc/kEndATLbbawPcOdt64s44mS+hxTOlYUU5RXGW9uOAHDdpuVlHsnUJFDl4YH7ruX3fncT//LiW7z+zkl+/to+DOGit2+AKr8bZQp720omnrHeqByf5WxBrCh29z2PW6euxs9lK1qoq7PtAR0rschAglWXzM6JyC+c14jf66a9o4cDH3Rgmsm80XJVVdBU+2F04/rF+H0uQGH5kha6euzt1dX4uOryRVydbsDz6OO/zPMKXMmIl8ULmvnjz1/PjneP8/N/34H7WJD+cJyWpsFoJIwsekfLuS50XMcqDPK+6p/fxNVXLJmw1+PFulVIxo6iKHz2Uxup9hmc7TLoD8eHnTvFPogNX04hlTKpr/PTWBfIaQu//rJ5nO8KEY0n0dK9A7SsVvUmoAglHQ23i7fVtP9+c0OAaDxFQ539JjaeSGby3L0el527DlT50wXQnly51Vgf4KZrVxT1AJn9nZobq1k0v4mOc0E7zcxlv01oaarhpmtXlExgy/qJ8iBFeYXx/pGzAFx3jRTlxSAsk3379mU+J5NOgwkNUuf5/OYlLGwO8b+ePoIh3AxEk6hKgK4eeQOVlAZbjOUK4kTSyHSirQ54h6W8LFvUgtutM292A431ATauX5y54T36+C/xeu1X3O/uP0nKcJqkDNrAuXSNGU01/NZHVvLwf92cE2levKAl782zmMIuWzgvoNafZOnSpbx38HTRN+XJzrku9Kp/oijWrUJyYSiKwurlM9h8W/7fY7HpFvmW8/ncwx4u7WVV5s9pIBiK4XJpdHaHbFtG1S7cJmViWXbBs9ulZQqcawJeFFVhZnMNl182n5MdvZw9309NwIfbrZNMGpmi4yULm5k9ow5VVTjUdh4FO8XkztvWZ94AFHNssr9TQ10VkWgCBUa1PrwQZP1E+ZCivMJ48Ud/yAv/9ga62c1vfvMbAFt0yuhuXhLRbv7qe/9KVa2dXxrqPoTmqqGqdjamaaJpGqHuQ/hql1JVM49QOI4ldL7896/TOGMhH964rMzfQDLVGRRrg1FngK6eMK0nOvM6iyiKwl0f25A3quWI5+WLW4hE4pniNoeaah9z041B7rp9A6qqFhVpHmvKx1jfGEz3nOti3SokE0ex5+TQ5f7xsTcL/u5mNNegKAqrLpnFkbZO+21X+n5rWYl04ywlI8idYk1n3bs+tgEgU+OQj9/9+BXjPvcnM9Vkul/LlYwU5RXG7t27+fNvPJrx1AYyolKSH7d/0O4wHjmP5mnEXzsfwzDQdZ14xLaI8npcuHSN3r4goQjc+YX/zTe/8nH+8LMfkU/9kgumkFhzUlrqan1Abm74SCkg2eL58svs8/pcVwjTsqiu8rJy+SxamqpZu3LemHKnJ7qwa7rnXEubt6nLSA9UzY2BdBFyLOdtl8ejU1s9AyEsTpzqIZky7cJnj8vOTa8L8FsfvjTze59O58Z0v5YrmSktyiORCN/4xjf4l3/5F3p7e1mxYgV/8Rd/wT333DPqup2dnXzta1/j5z//OdFolLVr1/J3f/d33HTTTZMw8pEZ6qntiErJ+NE0Fb8e4Yr1a/jl9pN84zv/yr4PTvPf/+quTGtwiWQsFBZrCnfdvoFLlszgldd3obv8NNQHRhXB+V5VD0QTBZ1OxsJERtume861tHmbuoz8QDWPz965KZMC1lCXm04GsGvvCZ57eQ9H2s4jgBVLZvCpIekn0+ncmO7XciUzpUX5HXfcwc6dO/n2t7/N8uXLefrpp7n33nuxLIv77ruv4HqJRIKbbrqJYDDII488QktLC48++igf/ehHef3117nuuusm8VtIJh1hcuMVHpYuXMuPn93Hv/zbLnbvbePpR/8TSxbNLPfoJFOM0cSaZVnUVaXGlPM8FV0RLoac66n4e5EU90A10u/1ynWLuHLdyOlJ0+ncuBiu5UplyoryV155hddeey0jxAFuuOEG2tvb+epXv8rdd99d8Ab4ox/9iAMHDvDOO+9w9dVXZ9Zdu3YtX/va19i+ffukfQ/J5JOIdvPX/+0lqmpn41F14paftvY+brjzv/Odb9zFPZ+8cspFNiTlZTrdkC8UmXMtqWTkNVo88louH+roi1QmL774IoFAgLvuuitn+v3338+ZM2dGFNYvvvgil1xySUaQA+i6zmc+8xl27NhBR0fHhI1bUhk4eeg19bNpbKhBVQyicYP//I1nuP33/pE9eVoZSySSwmxYs4C1K+fmnTcV82olkosVeS2XjykbKT9w4ACXXnopup77FdasWZOZf8011xRc98Mf/vCw6c66Bw8eZM6cOSUesaRS0TQVn9rPNVddwlu7+ti2+xi/fc/3+dCVS/iT37+Rm65dgapO2edXiWRSkDnXEsn0QF7L5WPKivKenh4WLx7ehr6hoSEzf6R1neXGum4ikSCRSGQ+h8NhAEzTxDTN4gafhWmaWJaVWfdCtiHJg9NxpYg2yQDJWDf/8cZ5fDVzsFQfhuniNzvb+M3ONubMrGPzLev4xO+s47JL51zUf5CGnq+lYqRc66HXXCgUApiQcUwEE3XMJorxjvfy1fO4fPW8nGmWlb8zaSmYSse3ksZa6JordL1d6D2uWCrp2JSbSjkWk30t56NSjsV4KbaeaMqKcmBEcTSacLrQdR9++GG++c1vDpt+/PhxYrHYiPvMh2VZ9Pb20traiqqqnD59GtM0MQwjZxnFGpw29HOplpmo7ZZlfOkL2RjDdnRvI97ALLxApO8kly6bzeGTJh3ngvzjY7/kHx/7JQ11Pjaum8dV6+Zx2YoZzGgKlEWkJ5NJDhw4MGz66tWrcbsnzkVm6PlaKlasWFFwXqFrrq+vr+TjmAgm6phNFHK8E0cljbXQNVfoemtrayMQCEzYeCrp2JQbeSwGmS7HYqR7XDZTVpQ3NjbmjWj39tqNNvJFwkux7te//nW+/OUvZz53dHSwcuVKFi1axNy5+XOwRsI0TVpbW1m6dCmaptHZ2YmmaTlpOaqqoqqD04Z+LtUyE7XdsoxP0zAAXdMuaDtWsod9+zrx18zGq7swTBeGpdMbjPHqL4/w6i+PANBYX8Wly2Yxd3Y9M5oCBPu6cOsaKJBIGAzEkiSTJklDEI8bRGNJ4kkTTVVxuzVcuopLV6jyu6kOeAj4XVT53axbcymBKj/JlEEyaRCOxDj4/hEGYimisRSnO86zc+9JNJcXBVAQGKkQX/miwg3XbWL2jFqaG6szDS8KkUgk2LVrV860K664Ao/Hk3cZy7I4ffo0a9euxe+fnAr8oddcKBRi3rx51NfXZ66bSmboNV7pyPFOHFNhrIWutyVLllBTUzNh+50Kx2aykMdikIvtWExZUX7ZZZfxzDPPZBrEOOzfvx+wI4Yjressl00x63o8nhzB4rza0zTtgk8YVVUz618MJ92k4ESvxxHFdvtbqKob9Ivv6diFKTzovhmYQseyNHr6Bvj1jtbxjjYPu0ZfRKvFyH6TqHn57g928N0f2J3ldF1lZnMts2fUUlPjw+PW8bhd6LqKaVqYluD8+U627TqMqtnntGUmuWzlb6iurrFfV1uCYLCf1mNnUTRXehmD7/zoEP/ygz/m0mWzSv3FhzH0mnPIvm4qnak0VpDjnUgqfayFrrfJGHOlH5vJRB6LQS6mYzFlRfnmzZv54Q9/yPPPP8/dd9+dmb5lyxZmz57Nxo0bR1z3j/7oj9i+fXtmOcMwePLJJ9m4cSOzZ88uehxOftXZs2cv6HuYpsm5c+fw+XyZSHk0dBrTSGaWSQx0oSQTqIqV93Oplpmo7ZZlfJiYloWmqiUbX3KgE8VVg8vnw6VAPNHF3Z+4Bm9VC73BGMfaz7PvgzOoug8ABTASQVA0XJ4qFATJ6DlQPXh8tYCCEJCM9YDqQ3dXI1CwzBQtzXXouhtdV3FpCqlUnJMdPWiaB0URpGLdoLpwe+yW7gIVw0gya0YDsaRKfzhBMiE4eTrGydPnGBkXZkbd67x38FSeZRTISvfpONtLe/spqn2ly/ObPXt2Ua8nRbpOIBKJEAqFKv4PtWmaU2asIMc7kVTaWKurq0dNv3OuNycANVFU2rEpJ/JYDDKdjkUx1xtiCnPzzTeL+vp68YMf/EC88cYb4gtf+IIAxJNPPplZ5vd///eFpmnixIkTmWnxeFysWrVKzJs3Tzz11FPitddeE5s3bxa6rotf/vKXYxrDjh07BCB/5I/8GefPqVOnirrmTp06Vfaxyh/5Mx1++vv75fUmf+TPJP0Uc71N2Ug5wAsvvMCDDz7IQw89RG9vLytWrOCZZ57hnnvuySzjVIyLLBcOj8fDf/zHf/C1r32N//yf/zPRaJR169bx6quvjrmb5+WXX86OHTuYMWPGBRUhhMNhVq5cyfvvv091dfWY15fkRx7XiWEij2uxb6hmz57N+++/z8qVKzl16tSE5rmWAicndyqMFeR4J5JKG2sx1/Ds2bM5depUcVG+cVBpx6acyGMxyHQ6FsVcb4oQRXrGSSaEUChEbW0t/f39U/6EqyTkcZ0YKuW4Vso4imEqjRXkeCeSqTTWyUYem0HksRjkYjsWU9dfRiKRSCQSiUQimSZIUS6RSCQSiUQikZQZKcrLjMfj4a/+6q/yWlBJLhx5XCeGSjmulTKOYphKYwU53olkKo11spHHZhB5LAa52I6FzCmXSCQSiUQikUjKjIyUSyQSiUQikUgkZUaKcolEIpFIJBKJpMxIUS6RSCQSiUQikZQZKcolEolEIpFIJJIyI0W5RCKRSCQSiURSZqQol0gkEolEIpFIyowU5RKJRCKRSCQSSZmRonycCCEIhUJIu3eJZHKwLIvTp09jWVa5hyKRTHvkPU4imTykKB8n4XCY2tpawuHwBa1vmiaHDh3CNM0Sj+ziRh7XiaESjuuZM2eYN28ev/rVr6bE77cSjtlYkOOdOKbSWB3Ge48rlql4bCYKeSwGudiOhRTlEolEIpFIJBJJmZGiXCKRSCQSiUQiKTNSlEskEolEIpFIJGVGinKJRCKRSCQSiaTMSFEukUgkEolEIpGUGSnKJRKJRCKRSCSSMiNFuUQikUgkEolEUmakKJdIJBKJRCKRSMqMFOUSiUQikUgkEkmZ0cs9AIlEIpGMzKc/9wVOne4cNn3e3BaeeuKHZRiRRCKRSEqNFOUSiURS4Zw63UmPtW74jNPvTfZQJBKJRDJByPQViUQikUgkEomkzEhRLpFIJBKJRCKRlBkpyiUSiUQikUgkkjIjRblEIpFIJBKJRFJmpCiXSCQSiUQikUjKjBTlEolEIpFIJBJJmZGWiBKJRCKRSKY1Qgh272tn257jBPuj1NX62bR+ERvWLEBRlHIPTyIBpCiXSCQSiUQyjRFCsOXZrex7/3RmWm9wgGPtXRw8fIbP3XW1FOaSikCmr0gkEolEIpm27N7XniPIs9n7/ml272uf5BFJJPmRolwikUgkEsm0Zdue4+OaL5FMFlKUSyQSiUQimbYE+6Pjmi+RTBZSlEskEolEIpm21NX6xzVfIpkspCiXSCQSiUQybdm0ftG45kskk4UU5RKJRCKRSKYtG9YsYO3KuXnnrV05lw1rFkzyiCSS/EhLRIlEIpFIJNMWRVH43F1XS59yScUjRblEIpFUOKF4FT2RCALweV34fW4pJCSSMaAoClesXcgVaxeWeygSSUEqMn0lEonwpS99idmzZ+P1elm3bh0//elPR13vhRde4N5772Xp0qX4fD4WLlzIpz/9aY4ePTps2euvvx5FUYb9fPSjH52IrySRSCQXxP95aSen+2dgmBamaREZSBAZSABw5PAhPnLjJ3J+Pv25L5R5xBKJRCK5ECoyUn7HHXewc+dOvv3tb7N8+XKefvpp7r33XizL4r777iu43ne+8x1mzpzJgw8+yOLFizl16hTf+ta3WL9+Pdu2bWPVqlU5yy9evJinnnoqZ1pdXd1EfCWJRCIZM6fP9PG1v3sesCPkqqoyEE0QjSXxelwkDeix1g1Z6b1JH6dEIpFIxk/FifJXXnmF1157LSPEAW644Qba29v56le/yt13342maXnX/dnPfkZLS0vOtBtvvJGFCxfy/e9/n3/+53/Omefz+di0adPEfBGJRCIZJ//9n/6dgWgCnytOdaAaRVEwTYt4IkV4IF7u4UkkEomkhFRc+sqLL75IIBDgrrvuypl+//33c+bMGbZv315w3aGCHGD27NnMnTuXU6dOlXysEolEMlGc7eznp/+6E4AZgZ5MDnmgygNAKmWCVl228UkkEomktFScKD9w4ACXXnopup4bxF+zZk1m/lg4duwY7e3tw1JXANra2mhoaEDXdZYsWcKDDz5ILBa78MFLJBJJifjpv+4gZZhsvHwRfnciM13TVDwe+++j4p1fruFJJBKJpMRUXPpKT08PixcvHja9oaEhM79YDMPggQceIBAI8Gd/9mc586699lruvvtuVqxYQSwW49VXX+W73/0uv/71r3nzzTdR1fzPK4lEgkRi8AYZCoUAME0T0zSLHpuDaZpYlnVB60oKI4/rxDBRx7VQShoMv+bC4TDAlPn9XsgxE0Lw9Is7ALjvjqv43//wes58n9dNImGAZyZCiBwnFiHEuI7LVLt2ptJ4K2msha65Ut/jiqWSjk25kcdikOlyLEa6x2VTcaIcGNHqq1gbMCEEDzzwAG+//TbPP/888+bNy5n/d3/3dzmfb731VhYuXMhXvvIVXnrpJTZv3px3uw8//DDf/OY3h01va2sjEAgUNbZsLMuit7eX1tbWgg8CkrEjj+vEMFHHdcWKFQXnFbrmgsHglPj9XsgxO3Ksm+Mnu/G4dVYuriIej2NoRma+qggUBVA9xONJXK7BP/hxM57XcWoix1tOptJ4K2msha65Ut/jiqWSjk25kcdikOlyLEa6x2VTcaK8sbExbzS8t7cXGIyYj4QQgj/4gz/gySefZMuWLXziE58oat+f+cxn+MpXvsK2bdsKivKvf/3rfPnLX858DoVCzJs3jyVLllBTU1PUfrIxTZPW1laWLl1a9JOUZHTkcZ0YynFch15zHR0drFy5krq6uinx+72QY/b8/20D4Lc+fClrLluJ1+slKnL/XHs8BvF4CsMU+HyD87wuL8uWLZvU8ZaTqTTeqTDWUt/jimUqHJvJQh6LQS62Y1Fxovyyyy7jmWeewTCMnLzy/fv3A7B69eoR13cE+WOPPcaPfvQjPvOZz4x5DCM9jXk8Hjwez7DpmqZd8Amjquq41pfkRx7XiWGyj+vQa855nT6Vfr9jHev//eVBAG67eQ2aptlvCEXuMh63TjyeIpE0yC73VBRl3MdkKh1bmFrjrfSxTsQ9rlgq/dhMJvJYDHIxHYuKexewefNmIpEIzz//fM70LVu2MHv2bDZu3FhwXSEEX/jCF3jsscf4p3/6J+6///4x7XvLli0A0iZRIpGUjbOd/bx/5CyKovBbH7604HJul57OH7ebCkkkEolkalNxkfJbbrmFm2++mS9+8YuEQiGWLl3KM888wy9+8QuefPLJzJPSAw88wJYtW2hra2PBggUA/Omf/ik/+tGP+P3f/30uu+wytm3bltmux+Ph8ssvB+Dtt9/m7//+79m8eTOLFy8mHo/z6quv8oMf/IAbb7yR22+/ffK/uEQikQD33v8XgBePFuOTd9jN0o4cbaNxybqc5VRVASMIrnqSKQOf5p70sUokEomkdFScKAd44YUXePDBB3nooYfo7e1lxYoVPPPMM9xzzz2ZZZxKcCEG3+n+7Gc/A+DHP/4xP/7xj3O2uWDBAk6cOAHArFmz0DSNv/3bv6W7uxtFUVi2bBl/8zd/w5//+Z9P6WICiUQytTl1LgV40dw19Fh274Vk8lD+hY0+cNWTSpn4vJM3RolEIpGUnooU5YFAgEceeYRHHnmk4DKPP/44jz/+eM40R3SPxtKlS3n55ZfHMUKJRCKZGKJJW127XKP/eRapIIoPUsbUtguTSCQSSQXmlEskEsnFytnzQVKWCwCXXkRRk9Fn/8+wsCwxysISiUQiqWSkKJdIJJIKYfu7xwHQddXOGR8NK5FZzpDRcolEIpnSSFEukUgkFcKOtCgvKkqexmkclExJUS6RSCRTGSnKJRKJpEJwIuXF5JM7uNMCXuaVSyQSydSmIgs9JRKJ5GIjMpDgwKEzALhdY4mU60CCVCrXjUoikYwfIQS797Wzbc9xgv1R6mr9bFq/iA1rFthNvSSSEiJFuUQikVQA7x44iWla6KqBphX/ElPX7WWFEHax5/RveieRTApCCLY8u5V975/OTOsNDnCsvYuDh8/wubuulsJcUlJk+opEIpFUAHvTN36fKz6m9RRFyYh4WewpkZSO3fvacwR5NnvfP83ufe2TPCLJdEeKcolEIqkAnJu/15Uc87qudLTcMK2SjkkiuZjZtuf4uOZLJGNFinKJRCKpAPYfSkfK9cSY19VlsadEUnKC/dFxzZdIxooU5RKJRFJmIgMJWo93AeDVxx4pd0S5YchIuURSKupq/eOaL5GMFSnKJRKJpMwcPNyBEIKZLbXo2tij3Xo6p9w0LSwhC88kklKwaf2icc2XSMaKdF+RSCSSMvDpz32BU6c7AeiN1gBNRIJn6O5uo3HJujFtS1UVFEVBCEHCcJd+sBLJRciGNQs4ePhMpgg7m7Ur57JhzYIyjEoynZGiXCKRSMrAqdOd9FjrAOhPxYAUQq8nmUyNeVuKouDSVZIpk3hKinKJpBQoisLn7rpa+pRLJg0pyiUSiaTMOFaGTm74haDrGsmUKSPlEkkJURSFK9Yu5Iq1C8s9FMlFgMwpl0gkkjIihMgUaLrGJcrtP+cJ01WScUkkEolkcpGiXCKRSMqImfYWV7Bzwy8Up4GQjJRLJBLJ1ESKcolEIikjTsMfTVfHlaOqa2lbREsnFI6VZGwSiUQimTykKJdIJJIyYqZTVxxRfaGoqpKJtB85dn7c45JIJBLJ5CJFuUQikZQRJ1Lu5ISPB8evXIpyiUQimXpI9xWJRCIpI4ZpO684OeHjQdNUSJkcaZOiXCIZC0IIaX0oKTtSlEskEkmZyHZe0Usgym1LxZSMlEskY0AIwZZnt7Ivq0lQb3CAY+1dHDx8hs/ddbUU5pJJQaavSCQSSZmwLJH5dyki5Y6wP3qsc9zbkkguFnbva88R5Nnsff80u/e1T/KIJBcrMlIukUgkZcJpGqRp43NecdDSeentHT3EEym8HulZLrm4uJA0lG17jo+4zW17jsvmQZJJQYpyiUQiKROZIs8SRMkBVEVBVUwsS6PtRBerLpldku1KJFOBC01DCfZHR9zuaPMlklIh01ckEomkTJgldF4BuyW4R08BcLjtXEm2KZFMFS40DaWu1j/idkebL5GUChkpl0gkkjJhlMijPBuPliSW8spiT8m0pVCKyrbdx0Zcr1Aayqb1izjW3lVwvU3rF413yBJJUUhRLpFIJGVAiCw7xBJFyoFMpPyoFOWSKYIQgl1723n5tb3orqM01AcK5oGPlKLScbaPObPqgPy544XSUDasWcDBw2fYmyfKvnblXDasWXDB300iGQtSlEskEkkZMC0NkTZfKVVOOYBbTwJwRDqwSKYAjsjee/AU/f391NZCMBQrmAc+UopKMBTD7dZpbqzOO79QGoqiKHzurqulT7mk7EhRLpFIJGUgYdrOKJqqlPSm70TK2050Yhhm2rtcIqlMiskDz045GckppaWpms7ucEFR7qShjOTQIl1WJOVEinKJRCIpAwnDDYBWYtHsUg38PjfRWJL2jl6WLGgu6fYlklIyVjvCkZxQmhoCJJNG3nlOGsp0bhQku5JOfaQon0a8tbV3xPnXXd0wSSORSCSjkTDsSHkpU1cAFAWWLGxm/wcdHGk7L0W5pKIZqx1hXa2f3uBA3mUVReHajcu4esPigsJ0194TY4rMTxWm88PGxYQU5VOc0YR4oWWlQJdIyksynb5SKjvEbJYvnpEW5ee45cbVJd++RFIqRhLZzvxsRnNKuXrDYq5Yu7CgsJ7IRkHljFSPNQ1IUplUpE95JBLhS1/6ErNnz8br9bJu3Tp++tOfjrreCy+8wL333svSpUvx+XwsXLiQT3/60xw9ejTv8q+//jpXX301fr+fpqYmPv/5z9PZOTWKo97a2jsmQV7q9SUSyfhw0ldKHSkHW5QD0hZRUvGMZjc4dP6GNQtYu3Ju3mWLcUoZS2TedoU5wT8+9iZ/9z9f5h8fe5Nde08gnArtLJxI9dMv7uBYe1cmSv30izt44tmtedcpJcU8bEgqn4qMlN9xxx3s3LmTb3/72yxfvpynn36ae++9F8uyuO+++wqu953vfIeZM2fy4IMPsnjxYk6dOsW3vvUt1q9fz7Zt21i1alVm2bfeeotbbrmF2267jZdeeonOzk7+y3/5L9x0003s2rULj8czGV/1giilmH5ra6+Mmkskk0woHMOw7D+/Wgk9yh0GRfnUCDJILl4cO8L3Dp4aNi+fyB6vU0qxkfmxpoNMZqQ6X0T+gyNncbu1gt//QrqSyhz1yafiRPkrr7zCa6+9lhHiADfccAPt7e189atf5e677y54E/vZz35GS0tLzrQbb7yRhQsX8v3vf59//ud/zkz/6le/yvLly3nuuefQdfswLFq0iA996EP8+Mc/5otf/OIEfcPKQwpziWRycSLYqqqgqqW/uTmi/Ojx8wgh5A1UUrE4InvF0pm8/NpOdJd/RJ9yZ52RUlSyGSosIwNxunrCNDUE8m7bicyX0hXGmV8KUV7oYaH1RCcul8ayRS15v9dYu5LKHPXyUHGi/MUXXyQQCHDXXXflTL///vu577772L59O9dcc03edYcKcoDZs2czd+5cTp0afArv6Ohg586dPPzwwxlBDnDNNdewfPlyXnzxxYoV5ROVciKFuUQyeRxus0X5RKSuACya34Suq0QGEpw938/smXUTsh+JpBTYInsBtf4ky5YtK9nbo3zCEgR9wSh9/dFhAjY7Ml8aVxhBV0+Ezu4wHxw9CzDuSHOhh4WWpmpaT3RSX+vPawk5NA1otCi4zFEvDxUnyg8cOMCll16aI5YB1qxZk5lfSJTn49ixY7S3t/PJT34yZx/Z2xy6n9/85jcXMPKpjxTmEsnk4ETKS22H6OB26yya38TRY50cbjsnRbnkoiS/sFRYvqSFrp4IbrdOdZU3b1rG+F1hBEfaOukJRgCoCfg41t41YqTZEcpbd7Vx7MRpFi/s4OorluSMq9DDQnNjgL5gNK9P+9A0oGKi4JMV+ZfkUnGivKenh8WLFw+b3tDQkJlfLIZh8MADDxAIBPizP/uznH1kb3PofkbaRyKRIJFIZD6HQiEATNPETLfMHgumaWJZVtHrTmypCPxyay8fvqq2ZNt7e0d/zudSbnskxnpcJcUxUcd1pMjY0GsuHA4DTJnfb75jdrjtHJA/Up7vGi903eddVghM02TZohaOHuvkUOs5PrJp2bjGW8lMpfFW0lgLXXOlvscVy0Qcm6272goWWDbVVyEsQW21l96+CFt3tWGaFhvWzEdRFGqrvfT0RQpuu7bamzPWK9cuoO34ebp67ch4sD9KKBLH63Xh87hobgxkxvLewVOsWDqTK9bmCuWfPLeNfR90IIRFfyhOW3snx052s/9QB5/91EYURaG3L1LwOy1b1EwiabBoXiN9/VHqa/1cdfkiNqyZj2VZmeV27W1nb54c/uyxjbQfgN6+yKScx5V0zYyHYt/+VJwoB0Z8rVPsKx8hBA888ABvv/02zz//PPPmzSt6WyPt4+GHH+ab3/zmsOltbW0EAoGixpaNZVn09vbS2tqKqo7+Kts0Jj6S/ct3epjTfOFpMh1dhcf4y3fsB57xbL8YxnpcJcUxUcd1xYoVBecVuuaCweCU+P3mO2YHD9kRKgWBYeQ2OxGWVdS0QtPjZpyjR4/SWGtbLu567wg3bJw5rvFWMlNpvJU01kLXXKnvccUyEcfm2InT9IcTeeYITpwOEouluHSZnfZ6Anh3fxuXLG7i4zdfyqxmnXf39+dZ12ZW88wcZ7dqr8W5zh6OHOsGoD8cxzAs4vEkosaLSzPo7x/c3suv7aTWn8x8PnDkPG9vO2yPTggSiQT9/SEUReHtrf1U+wxWL5+BkYrmbGcoc2fVcvOH5mRNSdLa2pqzzMuv7R1xGy+/ttP+DiMsU+2noLNdKamka2Y8jHSPy6biRHljY2PeSHVvry3i8kW3hyKE4A/+4A948skn2bJlC5/4xCeG7QPyR917e3tH3MfXv/51vvzlL2c+h0Ih5s2bx5IlS6ipqRl1bEMxTZPW1laWLl066pPU2zv60SbpN3auz/5DNdbIdrFjPNfXMqFR87EcV0nxlOO4Dr3mOjo6WLlyJXV1dVPi9zv0mMXiKc512RE4j8c17EajqOqw9L180wpN97q8LFu2jE1XhPjJC+/S2ZNg2bKxRcqn0rUzlcY7FcZa6ntcsZTy2NhpICc5123XVLjdOi1N1TQ3BEBR6OoJE4tbVFdXUVtbm7Pe/iO99PQfJFDlwRQ6pmkNKwpds3Iun7x1Y860XXvbmdHSiKZ76OwOE4mmECggIBpLceR4kEXzmzLb0l3+nOvytd90ZMZiWSbtp2J0BwdIJk3cbp2de7v45K0f4rab3fz0pZ0Fv/ttN1/JsmUj20LqrqPUjnD71V1+fuf6VePeTymYCtdMKak4UX7ZZZfxzDPPYBhGzs1m//79AKxePXIjDEeQP/bYY/zoRz/iM5/5zLBlnG3s37+fW2+9NWfe/v37R9yHx+PJa5eoadoFnzCqqha1fjnqnH+dTj8ZLdfcKUAdyxgn+gIr9rhKxsZkH9eh15zzOn0q/X6zx3r85DmEEGiKmd9ZIs/6ha6rvMsqCpqmccnSWQAcPd455mM0lY4tTK3xVvpYJ+IeVyylODbZ+dK6rpFIGSRSBuGBOMH+WCafHAVmNNdkrkEhBK3Hu+gJRujqibDqktk01lfR1RMhGIqxZEEz9XVVBQs1d+5tR1VVWppqaG6sprs3QjBk552bFvT0DWAJQTAUY9miFhrqAznfsz8cR1EUexwnujl3vh+32w0KJFIG2987wVMv7OCzd27iUOs59uYpwly7ci5XXb5o1IyChvoAwVBsxPlXXb5o3PspFZV+zZSSihPlmzdv5oc//CHPP/88d999d2b6li1bmD17Nhs3biy4rhCCL3zhCzz22GP80z/9E/fff3/e5ebMmcNVV13Fk08+yVe+8pXML3rbtm0cPnyYL33pSyX9TtMB2WhIIikNTpGnW09O6E1t2SL7bVd3b4SevgiN9ROXeiCRVArZxZ1NDQH6+qOZ3HBbcPtJJA0a6wM0NQxeE929kUxRZiLppIQpmaLJW25cPWJhY3bhZ3fv8HxsM53T3dMXob7Wz6fvyNUyTqFod2+E3r7hPuoet87e90+zav/Jcfm0w+hdUTetXzRuP3jJhVFxovyWW27h5ptv5otf/CKhUIilS5fyzDPP8Itf/IInn3wyI6AfeOABtmzZQltbGwsW2K9Q/vRP/5Qf/ehH/P7v/z6XXXYZ27Zty2zX4/Fw+eWXZz5/5zvf4eabb+auu+7ij/7oj+js7OQv/uIvWL16dUExLykt0u1FcjFyJF3k6dFTE7qfKr+HebPrOXWmjyPHznP1BinKJdOfbNcQRVFYtqiF+lo/nd1hEkkDw7TYuH4RyaSRIyw7u8OZf3vcw6XRULeRoZaCB4+cQddUmhsDdHaH8XpcJJIG8UQK07QwTIvu3giaqhKOxFl/2fyc7TtCOXsc2bQ0VeeMo1if9nw4DZsKRcEdp5ax+MFLSkPFiXKAF154gQcffJCHHnqI3t5eVqxYwTPPPMM999yTWcapBM9+Gv3Zz34GwI9//GN+/OMf52xzwYIFnDhxIvP5+uuv55VXXuGhhx7i9ttvx+/387GPfYzvfe97Fd3NUyKRTG2cSLlHm1hRDnYToVNn+jjSdp6rNyyZ8P1JJOVmqFWhotjRbifi3VBXxUdvWMXTL+7IWW4wOj4ogAttNztFRghBV0+Yw63n6OoJ49I1dF3F53NTE/CSSpkkkwYul46mqvi8LoL9UX7y3LYcW0RHKO/Zf3LYvhvrAjQ3BvJ+vwtBRsErl4oU5YFAgEceeYRHHnmk4DKPP/44jz/+eM60bNFdDDfffDM333zzBYxQIpFILoyMKNeT5POFGPf2Dx/iIzfaxe3nwg1AHX//vX/m33/+GE898cMJ2KNEUjkM9wsfPj9fpNjj1kkkUzkCeOh6Dk6KjBCCI8fOc/xkN/FECgHEEimUBERjSbweF4Zp4vO60TQV07KIxVP4fR7eO3iKVZfMzkShHaH8wdGz7Nl/knDYpDrgZUZzTXo8yrBxjAcZBa9MKlKUSyQSyXQklTJpS+dyTpQoTxrQY60DwFCTQJxIqoFTpyfevkwiKTfF5kt/9s5NqC9s55U3DhDsj6JpCo31AZYtaiZfCXV2R0wnRaa7N8KZc0HiCfutl9ulYaoKpmlhCVugu3UN07IyOeWmaRGNJTh6vJOtu4/liGJFUbjzYxtIJG37xNra2mFR66GdOSXTCynKJRKJZJI4caobw7Co8rnRVXPCu4Hp6Y6hKcNihD4gEsm0oZh8aSEETzy3jX3vn2ZWSy2zWmpxOnAePd7FskUtOWJ4aEdMJ4WksztMLJ6bhqZpKm63jkvX6A/FSBpmTo661+PC43HRcbaPf331XfpDsZzUkQ1rFrD/UAdvbx3uET50HJLphxTlkrIhizwlFxtO6srSxS2kug9Ngii3PdCFEBjW9LcTk0iKyZfetfdETov59JoZu0S3Wyfg9zAQTSCAkx29PPr4LzPbcFJkEkkjEwHPRlNVamt8hAfiIGyh7uSTezwuQuEY8UQKSwh6gwPDWtx/9lMbqfYZnO0y6A/HZb73RYQU5VMEaUkokUx9HFF+yZKZHOie+P3ZnuUqpmmRMNwTv0OJpAIYLV8626FlyJo0N1Yzb1Y9gYA3I9z7+qP09Uczwnnj5Qs51t6Fx20Xb5pmrjD3ee1uur50c7D6usE88Hg8lUl3Gerysvf90+ze187lq+exevkMNt+27KLw5pYMIkW5RCKRTBKH22xRvnzxDA5sn5x96rotGuJSlEsqgKFWgk4UeN2quWNe50Ijx6M5mHxw9CwejyvvvL3vn2bl8lmsXTmXrp4wnd0hkqlB5xavx4U3LcqbG6vRdS1nvpPu4vW4qM9TtLltz3EuXz1vzN9JMj2Qonya0hsceX5D3WSMQiKRZONEypcvnjFp+3TpGomEIUW5pOxkWwk6OKkb+w91sGnN8JTGkdZx0j3GKsxHc2jp7Y+m88zzs/3dE/zx569n5fJZPPr4L9mz/yTJpIHPOyjIG+sDXLl2AcFQlO7egYxPuq6r+Lw+vF4XLU01w7ZdCstDydRFivJpiCPIPW417/xE0sosI8W5RDI5WJZF6/FOAJZNoijXNfvvQCIl+y9Iykt2t82h7Hv/NNU+g+XLlxe9jpPuMVZbv9EcWhpqq0ZcP9gfRVEUrly3iMe+v5Bde0/w/Mt7ONR2HgVYvmQGd962ng1rFvCT57ax9/3TGZ/0g4fPEIrEcLt02tq7ePeA7UteV+Nn0fwmFs9vGtN3kUwvpCifAowln3w0QZ49T4pziWTyOH02SDSWxKVrLJrXOGn7dRxYEqbdYTBft0KJZDIonMtts++Dc3zyVsGuvSeGdcpsrK+ip28w4uxx67Q0VefYChab5jKaQ0soEuf4ydyiDyEE3b0ROrvD+Hxu/vGxNzPbvnLdIq5cl9+qcGjR6brV89i6u43O7lBOw6JoLElvcIBli1pymiJKLi7kX+dpRDGCPJtyi/O3tvZKBxbJRcPRdOrKkoXNGaE8GaiqgqKAEAqH286x5tLCubsSyUQyWmpGKBzjJ89tY/+hM4CgqyfC/g9Ok0gYKAr4fG58XheKopBIpghFYiSTBn9y/w0ARae5jObQsntfe44oF0Jw9FgnPcEIYHf8PNbeldn2Z+/cxJ79Jws+DDg2htv2HOfMuT56egeIxpJo2vB79ZFj59m97yQl6hEkmWKMS5Q/8cQTRS/7uc99bjy7umgpNko+VkGeTbnFuURyMXA0nboymfnkYAsQl66RTJm8d+CUFOWSsjFaLnc0brDvgw4UBY602SLYMCySKYNkyiSeNEilPNRUezMCOxiKsXtfO8CY0lxGcmgZGknv7o1kBPnQjp/vHjjJtj3HONbenRPBbzvRmRHsjic6QFt7N4ZhIgDTsFBVBdMSmY6fx0/2sH3PMX772skrfJVUDuMS5Z///OdHPQGEEPZTqRTlE8Z4BHk25RDnMlouuVg4cmzy88kd9LQo372/nc/ddfWk718igaG53HYk3ElHcbs0agIaVf4AXb0D9PRFiCdSpAyTeMLIpHTE4kncbj1jO9jSVD1qWgzA1t3HAAoK2Wyh2xccIDKQINg/QG8wSse5IG6XzqL5jbQ0VeN0/BRC8O6BU5zvCmVsD50Ifl/6rYCqKjkPC4mkgSUEmqqQSpmgqJl+AqmUSWdPiF/vaOXmD83J+z0movBVUjmMS5Q/9thjeaf39/ezZ88enn76aT7+8Y9z++23j2c3kiIYryDPt63JEudSmEsuBg61ngNgxdKZk75vl0uDGOzZd3LS9y2ROAxGoE9lIuEOVX43p8+GiCVscdqfbrADtgQW2C3qUymTWCyJz+vKRK37ggOc6+yn9URXRuC73TqplEEiaeJ2aRw8fIZj7V0ZwZotZLOj2UNTVRrrAlT53SSSBsFQjObGahzN290b4XxXKG8DoZ6+CPW1fl5540COk4vjbZ6wDExLAFZOGoumqgRDMQ4e7RxW9AoTU/gqqRzGJcp/7/d+b8T5f/iHf8hNN93EF7/4xfHs5qKlmNSV0awPx0O20O8NDv7RmQiB7nxXKc4l0xEhRMYOsSyiPJ3Dfqj1HOGBONVV3kkfg0Ti5HI/+bzCwcNn8bhdmXSPxvoqwuEBevsGGIglM4IcbK99w7RAgCXs62npwhaaGwMIAW3tXZw9308oEkMIQWd3nHgiZbe0d+uEInGSSYOunjArl8/KinYLXn/7A3659TDH2rsxDItYIklfMIppWWiqSl8wSpXfjdutp4W2D1Do7A7TcbaPgWiiYPF0Z3cYVVWyRLnA7dJIGSaJhAFCgMgNqPm8Llqaqtn3wTk23zZ8m6O9Fdi257gU5VOYCS30vPrqq7n99tt56KGHuOmmmyZyVxc1pYySj7aPiY6ey6i5ZDrS2TNAOBJH11WWLGie9P1rmoquGhiWzt6Dp7n2qqWTPgaJBGxh3h+Os+qS2TnThRA01Pk53x0lMhDPmWfnWwtcbg1dU/H53BmLwe7eMGCnsYTCMULhOKFwDEvYjia6roGwc7aDoSgHDp9hbn89yxa3ZCLi0WgynSaTYiCaxLIsFEVBwU43SaUMPB4XtdU++2HCY0unRMpOq0kZJv2hGLU1vpxxJ5IGs2YMCnLn7YDHpRMhYUf/LYtkyo7mez0u5sysp7khQDiSewwcRiuWlT7nU5sJd19ZsGABL7/88kTv5qKkN1icIO/qyz+9uX7s+5wMcS6j5pLpxoPf/P8Djagizm999FMAHDnaRuOSdZM2Bp8rTjgRYM++dinKJWWlkHCsr/WSMhW6eiJYYvDtrKapeNXBPGm3S0t30wzTH4pSW+OjqSFgi+NwDMsSCCGwLEEqaaBpKu70vSseT9ETjKAch55gBCEE/aEYKdMklTKxLMeOUICiYBgmCcDjcdEfjpFKmQjhIRZPEY+nMukw8UQKT1zPNA8CO1Xl1htX8+6BU3T1DBaL1tb6SKQMYrFkRvzX1/pZuXx2Jvpf6G3W8GLZ3Nz8WTNq2bX3hCz6nKJMqCgXQvCrX/0Kn883+sKSHMbiTV4IR4x7PPmFe1ff4B+9sQr0oeJcRs0lksJ09qRzYzU/PdY6AJLJQ5M6Bp8rYYvy/TKvXFJeCrmwKIrCskUtWJbgfFeI8EAcTVXxel14Pbqd8gGoqkpnd5iWpup0YWWczu4w8UQKl65hGCYpQ6SXVVBUBdO0Mg4nACfP9OLzugiF45mIt7AG/cHtulLbqMIwLdxunUQihSUEwVAU07TnmaaFaQlM0yIWT+WI8g9duYRP37ERyxI8/eKOnO9aHfDiceu43TrxeIpE0qCz2476N9VXsebSWXmP3dBi2aG5+bqm8vSLO2TR5xRlXKL8V7/6Vd7phmHQ0dHBE088wc6dO/nsZz87nt1I8jBaLvlogjx7XiJh5UTTxyLQPW51wqPmUphLpjpJy+6m6bgslAOfKwHAzr0nMq5YEkk5GKmjpqIo3Lf5Kt49cDInAuxx67QsqsYu+VQy6SvO/Fg8RTJlR8VVVcESttDWVMUW42lRrqn2NZhMGiiKkhHyiUSKQi17FEUhHk8RjycxTIElBKoy2APAsgQWCpZlZfLkP3TlEr7xpdtQVZXP3XU1O949QeuJzsx3WTy/iSPHztPTZz+cmJZKKBIjFInh981l5dL8aW7Zdo3Z0XeAxvoATQ22XWO+os+xWClK28XyMC5Rfv3114/4yxFCcPXVV/M//sf/GM9uJAUolLpSjCDP2U7WctkCvVhxPtFRcynMJVOdlOmI8slrGjQUnyuB26VxvitEW3sXSxe2lG0skoubkTpqrlk5NxNdzm5P79AbHKChbrCzTktTNaFIbJgDirAsO4qtKJAyEUKQTJnoWhLDMHG5NOJxuxjU1K10d81cWS7sDBZUVSEaTZI0DEzTyugeVVXQVAWXS8M0LTweF3d+bMMw8aooCpcun4XHo2NZFq0nutiz/xShcBSneaeuq0RjSebNbsDn0Xm/tYtLLrlk2PHJbnz03//ptZxi2aaGQI4myy76HIuVorRdLB/jEuUPPfRQ3l+MqqrU19dzxRVXsGnTpvHsQpKHkaLkYxXkQxlP9Dw7ai6FuURiI4QYjJTn6eA3WaiK4Mp1i/jNzlZ+vaNVinJJ2cjXUbO22sus5pl88taNmehyvkjtq28cyHiAA2lLxKjtmGJaKNjFk6YlbIktREb4gsC0YCCWoFr1oqgKbpdOMJrENIfbGtqrC0zTTLu/2BsS6W0LS2CpCpqm4XHrVPncAPzizYNs23M8R5xvWr+I1uPn+fWOVrp6wiQSBqZlZYS/pqt4PbbDixCCmiolr/uKc/yuWLuQVctn59gtDiU7d38sVorSdrF8jEuU//Vf/3WJhiHJpph88nxR8vEK8pztX2D0XApziSSX02f7ENgR8nxttSeTa69aym92tvL29qN8/nevKetYJBc3QztqmqbJ0aNHc6LLzvzsVIo9+08SjSVpaarOFEXW1/mo8rkZiCYABUW1i0GTOYWbg/sN+L3U1/np6o4QjiSw8viM28uCqigI7Gs3lTKyBD4ZYZ5IpFBVN5GBRCYtx4ksHzjUwapLZrN9z3F2vneC02ftm6ldjDq4rWTSJBSO2/n2fQMcO1XAoSGL0Tqk1tUOvlEYi5WitF0sHyUp9LQsi9OnT9PR0UEqlcq7zEc+8pFS7EoyCqUQ5IW26YjzcgpziWSqcbjN9ifXNbXsr3w/vHEZ33n0F/xmRyuWZaGq5X1IkEiGIoRg194TgxHyGh89wQGC/VFbUFd5ONdle5L39g2gKNATHEh3yVRJGSZmqlDUm3RBZpJznSaJZCoj2hWFHJHsLI9KWn2LodktGUxLkEgY+LxuunrCmTQSIQTP/Xw3z7+8h2TK5GRHb2Z/lhB2X9D0nwTLsugLRjFM2x/99Fk7R/3dA6cK5nWPlJsPdu6+w1isFKXtYvkYlygXQvDtb3+b73//+/T09Iy4rGma49mVJE2h1JVCtoelxONRi46aO8K81MhouWSqcTjdyVMrY5Gnw/rL5uP3uenujXCo9Rwrl88efSWJZJIQQvCT57ax/9CZzLTDbedoPdFJY32ApQubEcIWwOGBOGfOBbFM2yfcEgI1bZtopFNRFIVM901HcAsByZQJ6Si6s46iKKjpos1s7a0qCoZlYRnmYGvRfGNH4PHotJ7opK8/yrJFzRw91sne909jGCa6rg12KE3bIKYNXjIYpkUyaWS6ev7Jg8/g93mGdSHNjr53nO0jGIoNyylfu3IuG9YsyGx7LFH1sSwrKS3jEuVf//rX+e53v0tLSwv3338/s2bNQtcn3Pr8oqdQgedoUfLOEbJiWorUuWONmstoueRiZzBSXr4iTwe3W2fj5Yt4853DvL39qBTlkori4NFO9n1wLqfg8Fh7N33BKN09YY6f7Mbl0vC6dYSAWDyVk54yNFVFCLsYU4ih04UToM4R5maeVBfDtIZF0PNhmYJQOAZC0C3ChCMxjrV3pwtIgZztiIJOL8mUidejoGsq+97vYOmilpxiVzv6vof/+PUhmhurmTOrDrdbp7M7TDJpcO3GZVy9YfEwl5SxRNXHsqyktIxLQT/++ONccskl7Ny5k0AgUKoxScbIaFFyR4z7PIVfnXf25v6JGE2kZ0fNCwlzGS2XSOxIH5TXDjGbD29axpvvHOaNXx/iDz97XbmHI5Fk2PfBucy/hRAcPdZJZ0/IdlFJ+4C73ToDqkoymT9VdihCiLxpKc6kwUj6cJlsW4eOvg9FARTStowmXo+OZQmSKaPAmPJvR1UV3C4NRVFIJE1cLtvyMVuUd/faNogpw0xPt+0hnWWu3rA4b773SI43Q6PqY1lWUlrGdZeIRCLcdtttUpBPEiN18CwUJS9GkDvznR9nvZEi6yPtczIoRXMliWSisSwrJ6e8Evjo9asBeHv7UcID+Vt5SyTlILu1vCM+HV9x07RwAtmxeBLDKC7gky2As++CqqqkfcaVYcsVWn+kfdjiX2AaJtFokkQildnjYIpM4W2oCvi8Lrt7qcdFKmWn/GYi7WmcBkNDpzsUKtJ0HG/u23wVixc001BXxeIFzdy3+aphFodjWVZSWsYVKV+3bh1nzpwZfUFJ0YxVbI4UJe/sHV2M58NZJ5YQGWE+UuR8tDQWmcIiuVhpP91LLJ4CrLI7rzgsW9zConlNHD/VzVvvHOFjN68p95AkEsDuchlO1xA64tPndZFMGVjCFq6maZEyrIKOKflQFDJNhJIpE01T0TUVw7SKFvejIQQ529LSot8Sgw8DThMjR+jbOe/2g4HHrePzuvF5XXg9LvqCEWKJFNF4kj37T2a8yBPpNwQed3751hccyC2UHVIcmu14MxJjWVZSOsZ1l/jGN77BSy+9xJ49e0o1HskFkC9ifaGCPJuhkfNi950zv0BkvxTIaLmk0jl42A5auNVExUSXFEXht69fCcAv3jxQ5tFIJIOsuXRm5t9OJNibFqmqApZTpJlOSSkmig2knVDA43HhTjf6SSSNgoJc05S86WaqaheDFoNpCVwuzS7wzrJ5dApKNVUhUOWlOuDF69EJVHmor/Pj9boAO70mFIqRTJmc6+zn2Mkudr53gq6eCAi7adJwBG3tXTz94g6OtXdlCkOffnEHTzy7NW+KjqSyGFek/KMf/Shbtmzhlltu4eMf/zhr166lpqYm77Kf+9znxrOri558riuFouSjpZ2MFZ9HyUTN80XMPR6Vrj6r6A6gEsnFwv5DHQC4tcpKE/noDav5p5/8itd+9X6m/bhEUm5WLWshHNPZ/0EHHreeiQrX1vjQdZXevgEsFBRVQcmTK56P7ILOeMLANAoXbiqAog6mo+TDKvpBwHZT8XlcpNI58VbaFcbt1pnZUotL1xAIQuE48UQKT1zH63URS6TS6W4K8Xgy80BvmhZG3EJTFZoahqcNd/VECo5nIpr+ZPvH54vKS8bOuER5IpHgpZdeoru7mx/96EcAw34RdqGEIkV5CcgXdR4aqS42h3ysjCbMy4Us+pRUMgcqVJRvWr+YmmovPX0DXHXdvVS5B8cnhKCu1se/Pv90GUcouRhRFIXPfmoj7x08zbM/3832PcczaRvnu0IYhkU8kbK7YRbowJmzPWwrUiFAKALDMPOKbcej3LYlV7DSgt+Znt1EqFhUVbHtFRVoqKsiFksSGYijKApVVR7cLo3+cJxEMoWm2nnklhB43C50TcVV42EgbpJIGoQjcZLpNwcul4ZpCbp7IzkFoGCnx9Rn7AoFXT0ROrvDJJIGHrfOcz/fPapgLlZoCyHY8uzWnM6fTmT+4OEzMvf8AhmXKP/yl7/MU089xZo1a7jzzjulJWKFUIwgP9ud++dlVtPo64wmzIuxSJwIpDCXVCqOKPeocUrvQzQ2jhw+xEdu/ETms5JqBqrpjC+kRvfmLBs/v3WSRyeR2Di5zBvWLOCJZ7dmHEBOnemjttqHx63TlQynlwUK9PRRVdsL3LJExipRCGGnn2SJbbLSYBQlbaFoAtgBRU1V0NMpLwDCMkcV5/Z2bKFd5fWwYG4j5ztDCAF+n8tOSekKpcdpB9ZShklNwMv3/vJTvPIf+/mPtw+iKArJpIEQAl1X7SZFSYN4PMm7+08yf24DliWor6vi1htXc/xkN8FQDBAcaeukJzgYOU8kU2zbc5wnnt1aUDCPRWjv3tees1zWVnj97Q94/8hZIgMJevsHaKj1c+myWWzKY9UoyWVcCvrZZ59lw4YNbN26VYrxSSZf6spoaSvZQtzvUwrOG0mgO8J8KI5FokQisekNDtBxLgjYkfJyx8qTBvRY6wYnuFMQj5FIpBBVHnmjlFQUjgOIE7U9drKbWCzJ0kUt/HrH0eGe4tjC1hHYmqpgZglyh+zCy3xWiYZp2yAq2AJd11RqAl6i0SRJw7RFu7OtEXJZFOxizCWLWvjG/3MrT7+4g4OHz9DZHco0EbK3YRGo8uHzuqgJ+FAUhfpaP6FwnHA0RSyezDxcmJbIRPq7eiNYQrB4fhOzWmp498ApeoMD1Nf6M841QtgpO/F4CtOy8PvcvP72B6xcPosr1w33Gi8stIenv+R3eUk/DPRFOHj4DB6PrQtPnLKL3o+dlFH00RhXImE8HueGG26QgnyCKdTFM1+RZb4o+dluwdlugd+nZH6Gkj3PWX4kxpK37nGrBb9DqZBFn5JK40C6K+GCuY2oSuU9sHrcOsKym6+kDNlxWVJ5OFHzP7n/Br7x/9zKqktm09xYnbFJFEJgpfO1wU7tUBQ7jcNJH8lHxqOc4TaFjuRWVHsbrnSUvK7Oj8/rwuNx4dI1dF3LWB0O276AlGExEE1QX+Nj2+5jgF2cabsxDWKaFr19A3T3RhiIJnj2Z7vo6RsgkrZVtB8UHMeZwQJXy7LoDQ6w74MOtu85TldPGNO06O61U1aEsHPVQ+EYyZSd7qMqCq0nOnn08V/mTeMpZKeYb36wPzpsfleP/TAQT6SG2a32BCN09UQy4l6Sn3GJ8g0bNtDa2lqqsWSIRCJ86UtfYvbs2Xi9XtatW8dPf/rTUdc7ffo0X/rSl7juuuuoq6tDURQef/zxvMtef/31mUro7J+PfvSjJf42xTOSsBzNxaSQ24ojrvMJ8UI4yxYS5iOlx4zWyGgikcJcUkk4qSurL6nMrpmKokCyE4BEIr/nsURSKWxYs4C1K+cCUFXlAWFHjwW2uBbCjoprmorHraMqo8sbwRAfcyXrc3p7pimIJ+1oc03Ay+wZtSxd1ExdjW+UAmmBaVp09YR5e/tRQNDcGMCdZWWYTJkkUyaGaeLSNUzL4s13jrBrXzuN9f5M0yTTzNfYyLGHtFNhWk900hccIBSJ03Guj/NdIULhWOaBxeuxXWwATpzqySuM8wntQvPrMrnrgzg2lrF4KvPglG/+aOL/YmZcIe5vfetb3HTTTfz85z/nYx/7WKnGxB133MHOnTv59re/zfLly3n66ae59957sSyL++67r+B6ra2tPPXUU6xbt45bb72VZ555ZsT9LF68mKeeeipnWl1dXSm+QkVwIYLcIVuYF0pnGZpbXgkpLDK/XFIpHDicFuUrZvP+zjIPpgAieRbFO4d4IkVAprBIyowQgl1729m5tz1vkaGTznKsvZOungi6I7zThZhOhPySxTN59+DJC9h/enNCgGp7isetJKqqYpl25Lum2ofLpZFK2aksup7rPQ6DOeWKqtBxLkhLUzVut05zY4DqgJdoNEEsnsIwbScVn9dNbY0PsHO/e/oGUABd1zALNAmyB2wfM6cI9NjJbgJ+D7XVdvqLJQDTwu3Sqan2ZfJ2PG6dbXuOD3Niqav10xscKLi7bCG+af0ijrV35cx3bCxNy6LK7xm2vjN/NPF/MTMuUf7aa69x/fXX84lPfIIbbriBdevW5bVEVBSFv/zLvyxqm6+88gqvvfZaRogD3HDDDbS3t/PVr36Vu+++G03T8q77kY98hK4u+yTZtWvXqKLc5/OxadOmosZVSXT15aau5EslGY8gz8ZJZxkqzAvllkskEhsnN3NVhUbKAUh2oyhkUljcLpmKKCkPQgheeu0DzvekMg+H+YoMr1i7kBuvvZSOc/309A23AHS5dEzLxKXrWFZqRNtEO9ItMmkhmbFgp7Fkp4o4nubxeIrO7lC6CFTFsgSqomBmbcB+8w4IQTAUZc7MOs53h+gLRolGE1hCDBaVYj9QOCF/j1snnkgRicRobAjQ2RUiaRVIL1NApFN04vEU8UQKl0vjkqUz6ewJoaej5KZlkUikMh7oLU3VeYVxPqE9dL7DhjULOHj4TKYQF8jYWFZXeXG7h+s0p+FRvii7xGZcf4H/+q//OvPvN954gzfeeCPvcmMR5S+++CKBQIC77rorZ/r999/Pfffdx/bt27nmmmvyrqvmeV1ysZCdUlIqQZ5NoYh5PieWfC4sdl65NSmdPd/a2su1V9VO/I4kkgJEBhIcOXYegHWr5pV5NCNh4XG7MjZzUpRLysXufSc5cqyb2trhf7uHFhmGwnE+dOUSWk90cepML4mkgdul4XG7CIWjHD3WlbY/HHmfVT438WQKa4jotVNDRshHF066TH6xLCyRcVtKJk07Wt5YTce5PjtCbtg54k7+u2GaxBMp5syqJ5k0ONnRa+fDi+GFqkPHaSFwu/VMrrrH7bIj8lVegqFB4R2L26K8sS5Ac2MgrzDOJ7Qd1q6cy4Y1CzKfhxbiBvujXL56Hh3ngghhNzEaitPwKFvcS3IZ11/gN998s1TjyHDgwAEuvfTSYcWja9asycwvJMrHSltbGw0NDYRCIRYsWMA999zDN77xDXw+X8F1EokEiUQi8zkUsm2NTNPENMdeLGWaJpZlYZoj2yyNNSbt9yp5V+rozD/GOS353z4424rGxTBhni9a7qSwFBrvZMXW397eT0uddUG/E0lhss/XUlLo7RcMv+bCYTsvcSLGUSreO9COZQlmz6ilqaEK4fiuZfv8Flg33/SJXNbjsSNzmRQWQCAq9tgOZaLOyYmgksZa6Jor9T2uWLbtaUMIgRAW+crdtu5q4/LV9gNubbWXnr4Iyxa1sGxRC0IIjh7vpO1El90gyLTQdRVjFC/z8EBiQrpcOnnuliVQVQhH4igI4gmTaCyJZVmAQFhgCBNVUYgnUtRW29akx092kzJMunsjo45PCHC7NAzDwuPW0TWFA4fOoGtq5o2DqtguMksWNNPcEEAIuHLtgry/z0/fcRUrls5kx7vH6euPUl/r56rLF7Fhzfz0uHO5fPW8zO9FCMFPnt/O3oOn6OuP0ts3mArTUF9FU30Vl106h3Wr5hZ9LlXSNTMeRrrHZTMuUX7dddeNZ/W89PT0sHjx4mHTGxoaMvNLwbXXXsvdd9/NihUriMVivPrqq3z3u9/l17/+NW+++WbBqPvDDz/MN7/5zWHT29raCASGd9gaDcuy6O3tpbW1FdNoGjY/FLF/RaYxmFcm0DHSn3v7NVy6hTO7q88etzHkBD6Xddi87twLK55UOd1pb2BmY/5xul2QTKoYQ10axPBpAjVnvIOo9AWhJjDxRWUC6OhqAFov6jcopSb7fC3lcV2xYkXBeYWuuWAwWPJxlIrX3toLwNKF9bS2tmIYBoY25DqxrMx1PNr0iVxWUwcFRDyRxKVrGIZRscd2KBN1Tk4ElTTWQtdcqe9xxXLseAfnu/ppa+8hlbJwuTQa6vzU13pRFIVjJ+IcPXoUgFnNOu/u78+s2xuMce58kGQyRSplomnFvSWeyLbzToQ7lTSImCYD0QSKotgNFdPLmJZIO7gIEokUh46eoabag6LYRaKWo+5HIRSOMaOpivBAklA4SiKRRAiBptqRes2t0VDnxa1b9IdCXLK4iRpfInM8h1Lrh5s/NCdrSrJoU49Naxqo9hlU++H4qV76wwlqq70snlfPmpWzWLWsYUwGIZV0zYyHke5x2VTku8qRio1KVYj0d3/3dzmfb731VhYuXMhXvvIVXnrpJTZv3px3va9//et8+ctfznwOhULMmzePJUuW5M2nHw3TNGltbWXp0qV09udvket2qziRg+4+8HoGP6OQ+1ZBEXaUPCvS0NFpogBVfufY5Z7YgfTqA1HB+bR4zxc5TyqCrqCWEy3XdegNKTkpLKZp0RfWaRqSwqIByaSFNhkWmgIMDDqDM/nwRpnKUiqyz9din/zHy9BrrqOjg5UrV1JXVzep4xgLp85tA+DajZeydOlSdF1H17ScSLmiqnntZPNNn8hlXS4XHk+KeMLAMAQ+j4au6xV7bIdSjnPyQpkKYy31Pa4YhBD0hX/Due4YbrcLRdFIGXC+O0rKVFi2qIVF85voj7rZ8e5xeoMDWELHMC2aGwKcPjeA2+3G7TYwDAtLiKI6fk4GAtv7HASapthFo5mOobZIN01Bld+F2+0mnhDMnlHHiVM9pAwT00rnt+fZtuOnbhgW4agBqASqfBmdZG/PIJ5I4ff7iCXsfG6fv4ZQzMOGNfMnpLh7+fLlbL6tNNuaCtdMKak4Ud7Y2Jg3Gt7ba1czOhHzieAzn/kMX/nKV9i2bVtBUe7xePB4hlcVa5p2wSeMqqpomlbwgbjQ9KEFno4XeTYd5+3o3KAgL4yzzEBU0NFpMmdG7vfx+xSisdEjC04KS6E99gWZ8Nxykf5jhQK/3tEvHVlKiHO+TtYfyKHXnPM6fbLHMRb2HjwF2Dma9rWtDDNEHsv1PtHLejyuzM3bTmFRKvbY5qOSz4WhVPpYJ+IeNxq79p7AsuwIsn2tDM7rDdoe3vV1Vfyff9uVmV5fV0V3b4S+UAxVVaip9tHUEOD9o2eJxpKTlio5FkxTgBhM71SUQWFeU+2jptpHS1M1/aEoXq+OMWBlCkLzNUtSlYyrOgMDCXRd41xniPo6P16PC0VV8PlcuFwaliWYNaMOgBOnezlxupdDreemRCOfSr9mSknFvQu47LLL+OCDD4a9Zt2/fz8Aq1evnvAxTKVXJCN5ho9FkGfjLO+sP5R8/uXFNhNy/NYnupnQUN7a2it9zCWTQk9fhPbT9rm2btX8Mo+mODxuPceFRSKZTLbtOU5zQ4DaGjunGmEXJnZ2hzl9po+tu9r4918epLM7lEk5URSFpoYApmnnaXec67NzsdNt6UcqkCwnlmPpksZ2X1Tx+1yZaYqiEPC70TQVTVXyaxIFVMcnXbGvW8OwC0bPd4U4cz5INJbE49LRVIVkavh1LRv5VB4VFynfvHkzP/zhD3n++ee5++67M9O3bNnC7Nmz2bhx44Tte8uWLQBT0iZxaJT8QgW5Q5VfYSA6/I9avmh5IXvEfC4sYAvzRLI8rxazhbmMnksmgvcO2FHyJQubqa3xTYkCJUVR0lZsht1IyDX6OhJJqQj2R0FRWDi3jqSh8f6Rs/T2DWBZFpqmkkyZnDkfpLM7THXAS03Aizttv3e+M0Qkmky7rYi03aDdBSinGVCFIDLdjsh6wIBgKIbXkyIUidHcYLuUaJqaaVBkDlhDHjQULCvXH9007Si8MO1cdQU41xXKvEnIRz6/ckn5qDhRfsstt3DzzTfzxS9+kVAoxNKlS3nmmWf4xS9+wZNPPpl5ffHAAw+wZcsW2traWLBg0KbnueeeA+DYMbut7a5duzLFKXfeeScAb7/9Nn//93/P5s2bWbx4MfF4nFdffZUf/OAH3Hjjjdx+++2T+ZWLJrtb5kiR6fEKcocqv0LH+fxpLPksErPtEUdrJDSZFomFcAS6FOeSUrIrHXm6fPXUiJI7ZKewiIq7M0imM3W1/rTnuH1PEUKg64O1U6ZpkEqZxBMGyZSREbM9wQHi8VS6k6eS6dA5kQWcpcB+WBgco2UJOrtDaKpqNyZKGvSH46RSpl0MqtiNhFKpwQwCJe3e4gTeNU3NbNPuGSQIDyRQVYVkysrpJJqNbORTWVTkn94XXniBBx98kIceeoje3l5WrFjBM888wz333JNZxrFnGnrxDfU3f/TRR3n00UeBwYtg1qxZaJrG3/7t39Ld3Y2iKCxbtoy/+Zu/4c///M/Lkr7y9o7+Yoqsc5oGOakr+XLJ8wny9rOxgttdMCv/U3QhYe7s1xHmY42Ww6Awh4nPMR8J2QVUUkp2vGu3kL7q8qnlxZudwpIwC9vCSiSlZtP6RbSd6ATsVuyO57aDpmkk04LUNC1i8RQpw8wI8qmGsMjkzTsNhCxTYBi2nWO3OUDKMNB0DefOqymgunVUVSWZNNLFovZ3Vx2Rn7Zdde7+yaRBld+DS9cyXT+HIhv5VBYVKcoDgQCPPPIIjzzySMFlHn/8cR5//PFh04t5Ql66dCkvv/zyeIY4KfQGB3Owi6XjvDlMkDtivDqQf1vhiJVZppA4HyrMCxV9jiVaDoOpLL1BKcwlU597P/sFfvWuH1D5349+n8d/8F2EEJxoP0XL8qvLPbwRyU5hGTAmxmVDIsnHhjUL2H+og7e39pNMGphZfthej4tEIkUyrdMtIYjGkhhmbjqH3Xlz9Pu/U1ypKEr5HFrSxZt2QbWaaRTkCPREykBVQddU0KC22md34xR2d84z54JYlsAwLVRVsTuKpo+Z3WnULizXNJVli1ro7o3kzSmH3EY+QoicZkB1tX42rV/EhjULKr4YdLpQkaJcMjLZqSvZRZf5CjNHE+TZ8xxxPlSYO/nl+SLm442WgxTmkulD64kgQgRQFIioKxmw7GsjlfqgzCMrDieFZSBVU/EpAJLpg6IofPZTG6n2GTz/6mG6eyMYqoXX68Lr0ekxTDRNtXOmBRiGOUyAjzVi7ve67O6aZRDmiqKg6xqWaaGoCpoCKPZ92LIG88G9bhfxZCrz5iAWT5FIGrQ01VBd5eH0ObuYM2vDKAq2gAdmzahj2eIWhCBvAXd2l04hBFue3cq+rG6evcEBjrV3cfDwmSnh0jIdkKJ8ipCdTw65rivZqSvZUfJiBHk2znL5oub5hHmpouWQ7cpS/nQWieRCiaZs9wiXS5+SNzAnhcUUbvbsP8lVlw9v5CaRTCTzZzfQ1t5FKBzPWCRqqorbpZEUIhPxveCHRpGOtseTtkVhGRCWwDDsTp6maQ22AM1CU1Vqqr24Ezq9wQEGonaXVcuyiMWTthhP589blp3Koih29B3sNwyL5zcCCsuXtHD56vn0h+MFI+C797XnCPJsHJcWWRA68UhRPoXIzieHkaPkYxXk2VQH1LxR80LCfLRoucej0tVnjRgtzyxbIVFzieRCiCVtUe7Wp6afrqIotqtFwuBn/75PinLJpCCE4CfPbePtbYepqamhpamayECC/nCMRNLA63ERiSbSAlYwnjRyZ9VyCXIA0rUbQiFdoCoyYlpTFVTNLvhUFIWBaALLsgs1hRDEExbBUMx2ZREiXQNngbD9zgUCTVVZNL+JprSLy9qV8/jMpzaNGCjYtuf4iEOWLi2Tw9Qx5JbkJV+UvJAgP9nRnfcnH0Oj5kP3MZSh3uX53GGGRvsLUS4vc4lkPAghsiLlU1OUgx1hA/jZa3uxrDLl3EouKnbva2ffBx2A/WC4bNEMNqyZz6wZdaiKgset4dI1JyG8zKMtjN3oZ/TlnJpMO5fcjooj0usrCkbK9hvv7A4xEE0M2iJaIvNvwzAxTLtJn8eto+sqfp+b2TPqaGmqYcGcBpYsbOG+zVcVlXoymguLdGmZHGSkfIqRT+xmR8nzCXJHeNcWiJpnC/P5c5oy/x4pYj5SGkuhaHkiYY2aX55ZXkbMJVOMkx29GJb9J3Uqi3KPW0fB5PTZIDvePcGmDTJaLikNhQoJt+5qo6snzMnT3cQTXSRSBh63i7oaH4vnN9HdG0ZRFc53hRiIJkffURkZ63NsyjBRVQW3rtnFq7axIylDYBhJrIz3uu3aoqgKliWwLAtFUVDVQaGuaSrVAS8et04skQIh+MWbB9m25/ioBZt1tX56gwMFxyldWiYHKcorlJGixD6PMiwynR3BHosgz57XH7E42dFdlDCH4Y4sQ9NYOntFJrccis8vzyxfxiZDEslY2b7H7o3g0rUpmU/uoCgKVa4QkVQ9z728W4pySUkoVEjYdqKTHe8exzQteoMRjHRaSZg4kYE4oUiM850hXC7b1q+SLRAvOM1diIwji42CJaxMYatlpRsiIVDEoOWhELZXecZFRoH+UJRgf4z3j5xh78HTrLpkFk0N1ZmCzc/euYk9+08OezDaePlCjrV3FRxjtkuLZOKQoryCcdI4CqV9+H1K3ii5w8mO7hHF+FBqA2rRwnxofnkxRZ8wtvxyBxktl0wFnJzMqRwldwi4+omk6nnpF+/xrb/YXLDxiERSLIUKCbt7I/T0DdhNbpLmYOt4IJ5IkUqZxOJJ4km1aEGuKoCiVLSAz0YIiCcMXLqayXl3GgMNLiMy/1fTlo4KoOmDUXIjZdHXHyWZMtFUhWAoyu59J/F6XFQHvBw83MG2PcfwelyZwIHjsLLm0jmsXTmXvXl+R9kuLZKJRf6lrQA6uhrQRvlNDC3yzCZflLxQrvho1A5Z3xHnIwlzh2KKPh1kGotkuuE0DZoOotyrDdDcWE1XT5g33znM71y/qtxDkkxxChUSnk+3ge8LRhFOVx1FQVNBUVWElcLl0kkkjaLTyTVNxe3WiU2x5kLZ9owjRd2ttDDXdA2EyBStCsBImVimBUIlGksSj6fweOx0lmTS4P0jZ2lurGbl8lk0N1ZnxPm+Dzq495NXsuqS2dKnvIzIQs8pRL58cofsKHmhlJXejj15f/IxVJxD4eLPoc4voxV9Og8YYy38lEgqlZ6+CIdazwHgngaiXFHgkx9dB8BzP99d3sFIpgX5CgWFEJzrDBFPpDAtC9Oy86ct0yRlWMTjKVKGhWlZGeu/0VCVdNQ4nas9lXAKQItJg9E1lboaH5YAS9jWkaZp2cJesR1dTNMimTIZiCbp7RtgYCCBYZgEQ1EOHj7D0eOddgqMEHT1hPkfP3idX7x5EICP3rCKP/789VyxdqEU5JOIjJRPMfLlkztk55LnE+QAdbW5v/Jgv5GZ1zBnfc68fOksTsTcIV+0PF/RZ740lrEUfsLEp7HIxkGSC2XrLjuf3KMl0xZlU59P3XY5P3zqbX7x5gEiAwkCVZ5yD0kyhclXSGh3mrRby6uKglDSohTAEijYwt0w7HtOcTnbCoZhl0tecJL3FMDl0mhpqk5/RUEyaWCYtlgXgJnVLMh+mBGZbqbJpEksnqKnL0JdjY9gf4yeYASP28Wsllp6gxG27zmGpqksWdBMfV2VjJhPEtPj7nERMjSffCR6O/ZQV6sPE+RAzvR8UfNCOeljiZZnNzrKZiwRc2mTKKlk3tnVCoDfHRtlyanDulXzWLygmVg8xc9f21vu4UimOPkKBTu7w/i8LkzTQk/7cqtqOl9aVTINdcRYUlCU9E+RkfWpisftYv1lC7hirf3jdttWpkIIrHSB6LBnknSzoZRhkkgaABw/1UNPMJLepg4IjrR10nqik8Nt5zhy7DzH2rt4+sUdPPHsVtnpd4KRorwC6Q0Wn7Ix1Dd8aHGnI8hHYyRh7mzXYaj/+dAxZHunZ5Mv/UYKc8l04J2dbQD43fEyj6R0KIrCvZ+8EoDH/+WdMo9GMtXZsGYBa1fOzZnmNAbyely4XRqaquQIcCcoKzL/GR0FOzJsWqLYVaYkTprcTdeuwO/zEE8kMbOOXd7vnnnIsUilO6P2Z6UVtTRV09UTyYh0sB+cHJzOnpKJQ4ryMvP2jv4R53f1jVzkCcOj1hdKIWGeL1peHVAvKFpeycL8ra0jJO1LJAUI9kc5eOQsAFWu6SPKAT59xyZcusauve3sff9UuYcjmcIoisLn7rqa+zZfxeIFzTTUVTFrRi1LF7WweEEzNdU+fF4XmqbaRYyqgsulo6DYHt1F7cNezrYQnOhvVF5ShonLpaGqCn6fi1ktdXhcOoqqohfoKJxpWiQYFvFurAvQ3BjIEeFAJqLuMFrnT8n4kDnl04Sh0WsoPkqeTV2tTrDfGDa9NqAOs0rMZrTcchjZjWUsHubSkUVSSWzbcwwhBEsWNqPHjsE0stZvaarm9t9eywuv7OHHP/0Nj/zNPcOW+fTnvsCp05050+bNbeGpJ344WcOUTBEUReGKtQsz7dp37T3B0y/uACAciaMpdsP5RCKFJcA0LNu/W1EHvbhHQKTF5jTX4+kUH7s3wr/9372Z4lZLCPS0paSiKAVTTZS0J7rH7aJurp+meluQgzJMhHvcQ+vQZGfPiURGyiV5KZTGUgoKucjYHubFbUOmskgqhXd22akr11yxpMwjmRh+/54PAfDCy3vo7o0Mm3/qdCc91rqcn6EiXSLJh5PS0twYoKHOT19/jFgsSTJlYpp2G3mRrvwcS+RbMH1rPJ3i13AkzomTPfQGI3T12j+GaRJPpGxhnecApO3bURQFj0fn/ruv4W++8nGaG6txcluGivCWpuqcz7Kz58QiRfkUobO3cMFkqSk2uj7WFBYo7juMRZh73Cq9QSnOJeXDySe/5sqlZR7JxLBx/SLWrppLLJ7ifz3+ZrmHI5lGOCkt937yKjTNjobrupbx+ldVp3ulmLYie6w4DxymaZFI2R1OLUtgGCaWJWwbSJGbT69pCpqmoqSLaFVFobE+wOfuupor1i7MyfXPFuGN9QGaGgKAbZl48PAZPjhyln987E127T0hiz4nACnKJWNipKZExRZ8wsjR8rGSHTWX4lwymYQjcfZ9YHfA+9A0jZQrisJX/n+/A8CPnv41PX3Do+USyYXiWOz19A3gcml43DrVVV48bpedipH23JbkYqX9xR0coZ6xlMxCpN80uHQVr9dFfZ2fWS21tsvNkFz/5YtncMmSmSxd2MKyRS0oChk3FpdLw+3WpBvLBCJzyiVF4/iWj5eRcsvBSWOxivYvh0Fh7uSa19eNb4wSSTFsf/c4liVYOK+R2TPryj2cCeOjN6ziskvnsP+DDv7X47/kL//sY+UekmSaIITg0cd/SWd3GMOwUDUwLQvLslBUBbeqpZ1CpPjLxrJACCvnDYIjzPOhqiouXaOu1ofP5+aSpTMz84bm+gsh2L2vnW17jvPBkTOkDJOlC1toagjk+JQ7bizOepLxI0W5pGhKIcizGdpQqBQ44rwvaAG6FOeSCeWdnbY/+XTLJz9+/BjX/9bmnBuwJzAL8PG/n3iLz965iYXz8hd9SyRjYfe+dk6c6kHTVFKpwemqqpBImqgK09pvfDyMFKTO2Emml3HpKgJBeCCRcV/ZtfdE3oZA2SL9Hx97E4/HVXA/2/Ycl6K8hEhRLhkThdxXxspERMuzcbtVksmxP0S8tbVXdvaUFM10LfI0TIVecXlOcLIh/B4f2fQ7/GrbUf7yuy/xk394oHwDlEwbtu05jset4/HoDAzESZl2lNxxUjEFoICSJy1DUhg7ZUVBUew0l1g8ha6paJrKvNn1pFIGj/zzf6BpKovnNzEQS6IAVX5PTgfP0dxWnPnZ0fVgf5S6Wr/sAnoBSFEuGUY+S8SpiKZa9AVVaZsomRAGogneO2h7d0/XIs9sFAUe/vodXPep7/HqGwf497cO8tvXrSr3sCRlZrxiLNgfpbkxwMmOHgzTsgsXncTo9OqqqiCs4d7aklEQAkW1CzuFsItA3S6dZYuaOXqsy24SJOD4yW6SKfu+31gXYPmSFo61d3Hw8Bnqanz0BgcK7qKu1o8Qgi3PbmXf+6cz03uDA5ltrFw+i+3vnpBivQikKJ8itDRAZ6+YNAeWhjnrJ2U/EslUZed7JzAMi7mz6pk/5+J4u3LJ0pn84Wev49HH3uSrf/McV//b9HpDIBkbo4mxz9119ajCy7bYE8TiSSwh0gWMzg7s/9VUeYkmUqRSpkxlGQuK0yzIzs8X2E2Hjh7vojc4gBCCUDhOZCCBx6OjqSqxeIq6Wh8tTTXsff80l6+eN+IuNq1fxO597TnnwCCCZ3+2m/o6f9p2ceznx8WGdF+ZBiyY5SNcIN+7VFHv/og1LHUlHLFYMMtXku1LJFONQSvEi0uYfu2PfocFcxvoOBfkW4+8Uu7hSMpIYTEG7x08xZPPb+MfH3uTv/ufLxe00du0fhHHTvZgGFbBSHh/JI6w0n7lJf8WU59sXev8e3Ca7V2jKErGOvFw2zksyyIUjhMKxzBMC9O0SKYMQuEY7x85m/ldBEOxHMvEbNaunMuGNQsKdvns6onQE4wM6xIKg0WiklykKJ/GXEi0O9hvDFuv2ALP7I6eEsl0551d07PIczSq/B7++1/9LgD//PSviSY9xM9lYgAAgyJJREFUZR6RpFwUEmNCCI4e6+TJ57dzrL0rEx3NZ6O3Yc0CogMJTEtkLPqGYlnCbiSUVuVqOiVDYjPUgUXTFFRVzRxP50dL55TH4ylCkQTxdOdUdcihDA/EM43C+kOxHMvEhroqFi9o5r7NV2Ui3YXyzh0xPrRLqEOh8+diRqavTAESCSuvf/ecGRod581h/uD9EYvawNift0aKqueLkudjzgwt8+9orLBIH6nIUyKpdO75zBfY/m4VoPCPj3yPHzxqXztHjrbRuGRdWcc2GVx/zSXc84kr+elLOzkbaqa2XsjX0BchhcRYd68dIfW4h7t2DLXRUxQF3aXhdmnE4oWj5dnIFJZBFBjWKMjt0kmlzCwxPijIAVRNZWAgga6rqAqZ6ZltqCqd3WGaG6upq/UPs0wcSl2tP2/euSPGh3YJdRitiPRiREbKK5x87iOzmpSCgjefO8pYUljGEiUvJnVlVlPhG3Wp7RAlksni6IkQAgVVVQgpqzLt5ZPJ1OgrTxP+5mufoLkxQMJ0MxBNlns4kjJQqOW6EyEtJMaGRkhrAj5Shl3kWUiTi3Suuaz1HEI6Aq6q9v9dukZjQwBVU/B4dHw+F82N1VT5B99oBfweLMu+t/u87mGi3Od1kUgaCCGorfYWlYKUD+f3n90lNJtC58/FjBTlZebDV9UOm9ZQZzfBGUpLw8gR5nzR62JTWEZKWykml3wgKnKi5CMRS4hJEeSmJU9vycQQS9k3OJeuXbQR4oa6Kr719TsA24nGMMwyj0gy2RQSY06EtJAYy46QCiEQCExj5DRJKcaHowC6rlLld+N266iqgsfjwuvRces6pmnh9bjwel3U1viorfZRV+OnpbGammr7c2NDAG+WD7mzvNulEYsleffAyaJSkPLlnbc0VdNYH6CpIZB3/IXOn4sZqVqmCUNF8tAId6FoebDfGLMgH0q+XPJoTOSNkhebtpJIlKZRkWweJJkIYikvAC5XcQ+i05VPfnQdAbf92jociZd5NJLJppAY87h1GusCNDfmF2PZEdLd+9pJJg1cLhVVvfgKOcfyTD+0oFNJJ4MnUyZul0bA72Fmcy0et4uGer8t1BWFcDiOqqisumQ211+znPVrFvAXf/JRVq+YQ221j5amambNqGP2jDpamqqpCfj48MZl+P1u8v1GhhZpKoqSN+/8Tx+4kTtvW583cOEUiUpykTnlU4R8eeXRmMibVz5/ThMnO7oznxvmrKe3Y09GmNfV6jkifayCPF/aSjG55I4gLzZKfqGNg4ALahwkkRSDEIKoEym/iET5kcOH+MiNnxg2PdZzBqqvJZkySSYN3AVSFiTTD0eMDfUpv3z1PN49cJJCEjs7Qrptz3F0XaMm4CMUiWKYIpMzfjHkjo/1DYCmKbYLjVPsqti+h16Pi8Xzm1m22PYgTyYN6mrsFBawbRGDoRjNjdWsWzWXz3xqE0LYAnsoa1fOJRyJ0zdCzvfQTp6F8s6vWLtwWjYVmqhmSfKv5xSguR66+gY/xxJ2FPps9/CrORyxqE4XeWYXfDrCO1uc50ttGasgL+S4MjRKPhZBnkhceCdPGEz9qQkYyFNcUmpOdvRiWvZ55dIvHlGeNKDHWjdseipxiKpmF7F4ivBAnAZX1eQPTlI28okxIWxhXUjwZUdIg/1RvB4XNdVeVFWQMgTJlIFp2vZ9yZRMi3JwunTqLhW3S8/YHHrcOvV1VSxf0pKxIUSBVZfMBuwc/0TSIJUyWX/ZfD7zqU0FH6gcYfn3o9idFlukOVqR6FSkFP78hZCKpUJpqIPeoIXHnRsdt5sI5V9nwSwf7WdjwPBoeWa7I+SY5xPkI0XHHUE+WpR8rIJ8PDiCvL4OzOnRmFRSYex87wRg53JO5UhPKQlUeYgnUhiGZecTy/YFFzWjCb7s66au1k9LUzWhcAyPW6c64M4E2GPxFGfPBzHN6R8xL4Z0UBxVtZ1UGur8RAaSmKZFb1+Eg4fPEokmALLSh5RM4x6A/nA8c/xHEsyFHFWy51+sjOTPP9RdaKxUZE55JBLhS1/6ErNnz8br9bJu3Tp++tOfjrre6dOn+dKXvsR1111HXV0diqLw+OOPF1z+9ddf5+qrr8bv99PU1MTnP/95Ojs7S/hNimNOcwGVPQYKRayL9RgvpSDPjpIXK8gTCSsTIb+QKHkiaZFIWjTU2Q80EslEsWvvCQDcLhnTcFBVFZ/XDUBUOrFIGBR8f3L/DXzjS7fxJ/ffwBVrFw57kN20fhHNjQEa6nPfsPSHYoTCMQJV3vQD8GSOfvIZ6hU+FOf7CyEwUiaqqhCOJEgkU3ZhplsnkTTo74/iceksW9xCvvShYiPcoxVhXsxFmqP5q4/Hf70iRfkdd9zBli1b+Ku/+iteffVVrrzySu69916efvrpEddrbW3lqaeewu12c+utt4647FtvvcUtt9zCjBkzeOmll3jkkUd4/fXXuemmm0gkEqX8OiWhuT5/FNnJK3fI7u7pCOyRhHl/xCqJIHfIV9xZjCCH8YlxkGJcMjnsSEfKL6bUlWLw+2xRnjJM2VBIUjR2seg8li9qYf6cOqoDXkzTtkecN7uBxfMb8Xlc0/6tlMC+hnRt+PdUVdt+1TkGpmWhqirxRApd0/B5Xay5dC7rL5vPnFn1JFJGpvnPUIqNcBcq4gVZpDnag814/NcrLtTzyiuv8Nprr/H0009z7733AnDDDTfQ3t7OV7/6Ve6++240Lf/N8CMf+QhdXV0A7Nq1i2eeeabgfr761a+yfPlynnvuOXTdPgyLFi3iQx/6ED/+8Y/54he/WOJvVlpGyiuHwdxyJ41lJGE+1vzxfGI8n9vKaNaH2Q8ZYxXk2ZaRUoxLJouBaIKDh88AF1eRZzFomorPa+eWdw/UlXs4kimCk+qyYulMXn5tJ7rLzwet59A1laaGAN29EU529JFI2TnR09UaUQj7gdbl1rEStke4y6WhKgqmaUE6f1wIgaqoWKbjM+7KcbppaaomFIllmv8MpdgI91hSkC42JjK1p+JE+YsvvkggEOCuu+7KmX7//fdz3333sX37dq655pq866pqcYH/jo4Odu7cycMPP5wR5ADXXHMNy5cv58UXX6xoUZ4vrzzbhSU7txzyNxTKx4VGxwsJ8kKMR4wDMjIuKRvvHTyFaVroqoE62vvmixC/z00sniKS9HP8ZDeL5hf3t0dycWOnuiyg1p9k2bJlPPwPv8iInqaGAB6Pi2TKAAGGOdj1c7oJdMu0MLAf+E3Torbah8ejEwzGSBomLt12Wwn43aAo1NX4Wbl8FooCBw+fJZE0cLs03C6dRJ5GZmONcE/HIs1SsGn9Io61d404/0KpOFF+4MABLr300hyxDLBmzZrM/EKifCz7yN7m0P385je/Gdf2S0WhYs+hRGMCv2+4QMh2YhmNC4mOO/sei9PKeFNVHKQgl5SDXenUFZ8rflFHigqh63a79GTKZMu/vMNff+Xj5R6SZAqSHYlUFIWZzTVoqkIoEicWT2FZFsISmNNIlTtdORVFoSbgJZFIkUgaeD0uZs2sJR5PEYuncLt1PnrDKlRFIZFMcfRYl+22kiaRTCGEYEZTDYvnNxEMxWSEu8RsWLOAg4fPFOUuNFYqTpT39PSwePHiYdMbGhoy80uxj+xtDt3PSPtIJBI5OeehUAgA0zQxzbFbN5mmabe7FSAKXCsj/dnJpLAImNOi0dGZGy13xHZ1VX5xHh4Y3epwTos2bBDR+PCiTihOkDfVj/ydhpLtOe40Axp1fZFeZoTjmo8PX1V7Qb/HiwXnfC31MSqUkgbDr7lw2G7hPRHjGI0dWaI8H3nPy3THwrSf2cjLFpg+qcuOc7x+n5tkKsZTL2znK1/8bXxeV971SsVEnZMTQSWNtdA1V+p7XLFkH5sr1y6g7cSg6UJLUzXhSByPW+fUmbQ/sKIwtjtJZeNcaqpid9Wc2eSnL5S0LQ9dOtVVXlqaqrnx2hV87s5N7N53kn/48Rv09A3PHVdQqA54uXLdQq5YOygQLWvq9e+opGsmm0/fcRUrls5kx7vH6euPUl/r56rLF7Fhzfy8x3mke1w2FSfKgRGf5Er5lFdoWyPt4+GHH+ab3/zmsOltbW0EAvm7l42EZVn09vZiiKYCbRZ0TMP29hPoxBMWumaB0IjFBS7dAqFipE9YAUSiAq/bYk6zfTPs6EplxPdQnGUMY9A/MJ60BfzMRvuzMcRbMJme31xvkbUaKSPtiV5r5ky3t6HSUG1PHItVoWnZ27Q9x4tfVwDCsjAwxtQh7ujRo2NY+uLDOV9bW1uLThcrhhUrVhScV+iaCwaDJR/HSAgh2L6nDQDNCpEcepKTPufyTLdfu5tFLZtv+mQvO57xqipoSpK+fvjhT/6dW65fPnz7JWSizsmJoJLGWuiaK/U9rlhM02Tb7lae+bd9hCMJDh7tpC8YQ9cUXC4NISx6g1EEApeu2jaJQsHMajCkaUrF2icWeoRw5IZpWqiqgs/jxuNWmNXip7bGRzSWYtXyFqoDXtZcOpNVyxppbW2lxieIxaIkk8PdjmprvLh1k5df20mtf/h8IQQHj3ay74NzhCPxrG23VFwkvZKumaHU+uHmD83JmpKktbU177Ij3eOyqThR3tjYmDdS3dtrJ1Hni25fyD4gf9S9t7d3xH18/etf58tf/nLmcygUYt68eSxZsoSampoxj8U0TVpbW+kM6gX7C2vpVJ7meujuA13XaWm088p1XQdFkExp+L0Kc1ugo9PMSf9ZMKu4X7MTHVdIR8eH4ETHUZwI+eAFEksIUJwIee7+BpsBFX+6JbP8xm3GeKoKMDDQtcLHNR/Lli0b234uMpzzdenSpUU/+Y+XoddcR0cHK1eupK6ublLHceJUN8FQHLdLo6ZKEMxzTiqqOiz1zo44g65pOZHnvMsWmD6py5ZgvA3+MF0Djbz6yzb+9Au3DVunlJTjnLxQpsJYS32PKwYhBFv+5R1+vfscNTU1tLb3Ex4wMCwwLYFpWSRSBvGEiZoueFRVBa/XgyIgnjLsYkgBHrdme+VXGEMFueOokt211KXrgEI4kuL02QEUzcXsGbXcs/nDbFgzf5hgXruqFZ/PT2d3ONNNt6WpmuaGACgKuss/7J4mhOAnz21j3wfn0gPxEo7Cb3afIxzT+eynNlaUMJ8K10wpqThRftlll/HMM89gGEbOH/r9+/cDsHr16nHvw9nG/v37h1kn7t+/f8R9eDwePJ7hdl+apl3wCaOqKiiFteNol0cmhSW9oFP0CVDlH/3iyklVKVDImb2voYyWsjKW/PFS5Y0L53iOcFzzcTFc9OPFblxx4ef7WBl6zTmv0ydrHJ/+3Bc4dbqTYCwAtKAxQFvbMRqXXD5s2bznmqKgoOQI3ILLFpg+qcuWYLz1/jDBRAt79p9k/6EzrFs1r8DapWGyz8nxUOljnYh73Gjs2nuCA4fPoigKPX0D9AYHUBTwenRC4Ti4dap8Hjq77dQ1RVHQFFtgoih4PS6EECSSBnU1fnp6IxhmZadqWJbIEeSqoiCEIJ40MC0LRRFUBxR0XeP//NsuDrWeG9Ypsr6uCkVJWyWm/5/974b6wLDf2a69J9h/6Exe4b3/gw7eO3i64go7K/2aKSWV9S4A2Lx5M5FIhOeffz5n+pYtW5g9ezYbN24c9z7mzJnDVVddxZNPPpmTp7Rt2zYOHz7MHXfcMe59jJUPX1U77m1ki2dHXA9ERcHGQtnz5szQhgnyaEzkNASaSEE+1G+8HIWc1109/rcwkunHqdOd9Fjr6EvarykVvYZkHmcDySC6anH7b68F4Ilnt5Z5NJJKJ7vZiiO8AeIJg3jCLnCMJ+xrTqSFrB1Bd1xYBDXVPj6ycTlbHrmfBfMacenalGo4JLAfKpJJg1g8RW8wRiJpWyMKITKdIjPLC0FvcIDWE52EIjESyRShSIzWE50cPd6JECKvC8hENr6RjJ+KE+W33HILN998M1/84hf54Q9/yJtvvsl/+k//iV/84hd897vfzTwpPfDAA+i6Tnt7e876zz33HM899xxvvPEGYPuVO9Oy+c53vsOhQ4e46667eP3113n66af53d/9XVavXs39998/OV92nLQ0DIpiRzAPFeZDxXn2jzP/QsQ4FFfUORqVIMYlkmJIGfYDvPQnL47f+92rAXj+5T2EB/IXxkokkNtsJZm0rQ/j8RS9fQPEEwYD0QShSBxd13LSQMysaHg8nuLWm1azYc0CLlkyA69HR9PGLnHKJeSzjWSEsFN2YvEkbSe6MiI7WzDv3tdOfyhKY93wPP+evgj1tf68LiAT2fhGMn4qLn0F4IUXXuDBBx/koYceore3lxUrVvDMM89wzz33ZJZxKsHFEEukof7mjz76KI8++ihAzrLXX389r7zyCg899BC33347fr+fj33sY3zve9/L++qunCSSubaIiYSFxzP8j42TxjLUIrGQneFQRktTccj2IB+P7aH0G5dMFYQQGIZ9vspOnsVxzRVLWLKwmbYTXbz4yrt87q6ryz0kSYVSV+vPuIi43TqdPWHiiRSGaTcLEgJi8RSqYqdzDPqUD96LGhsCfPqOjeze144Q4PHoJA0T0xTDdIKDk+KYK4gn6lsWxqWrWMJ+yFCw03OEgHAkTjxh0JcWyg11VZl1HIFeX+cnGIoS7I+STJlomkJ1lZcPjp5j9772YTaIE9n4RjJ+Ki5SDhAIBHjkkUc4e/YsiUSCvXv35ghygMcffxwhBAsXLsyZ7rzqyfczlJtvvpmtW7cSi8Xo6elhy5YttLS0TORXGzNDBWs+oZstkvNFzEej2Mh49r5aGqaXIJepK5KRSKXsKLmqKhcUfbsYcToCAmx59p0yj0ZSyWSnWbhdeiZVxRGTmqaiKnZ7+boaH/W1flwuDZeuUR3wsmr5bO75xBWoqpoRq6qq4nZpaJoyLPqtqQqaqqCkfcHzLTPZZB40GNQxhmkRiyUJReLsS6evOHZ7fcEBjrR10nqiE9OysITAME0SSYNINMHZ80GefnEHTzy7NUf/jNbYZjyNbyTjR95dpjj5hHG2MM8W3A7Z04tNU3F+ColxmLqCXCIZDUeUy9SVsXHPJ67E7dLYe/A07x08Ve7hSCqUDWsWsObSOfT1xzh1phfDsEgmbTtbTVXRtMEfyxLU1viYM7OOj2xazk3XXsqyxTO4esMSwE6/6OwOU1PttR2E8sSnsm0UhRDp9vWT9GXzYFn264DMg0F6LJYpbI9uwySeSLH/UAd//F+fxrIsBqKJTNOgeFbOPUA8kSKVTu0Zmou+Yc0C1q6cm3cc4218Ixk/FZm+Ihmd7BSWlgbo7BX4PIOiOltgOykt2YwUDXcYLU0lH8UI8koT4zJKLhmNpJNPLlNXxkRjfYDbfmsNL776Lj95buuEu7BIpi52dNhO4fB49LRQFijYPuXeahfJpJGp7WisD9DUYOdTZ4vJulo/iaRBPGG7mLhcKmaeGqdsYZ42LCmLMFdVBWvIjjON79LqXFVIW0FavPbW+2x+4P8lHInTF4zi87qIxfMUnmdtctue4xlHFecN1u597Wzbc5xgf1R2/KwgpCivIK67uoG3tvbmnZedV95cD119w5eJJXKFuUMxAjx7G9kUI8bHEiGvNEEukYyGEDJSPh5+73ev4cVX3+W5n+/hm1/5BIGqyqrZkZSf3fva2X/oDA11PmbPrMspDBZC0NRQTSplR4uFEFRVeTAMk3NdIW69cTWfvsN2Zdu19wSnzvTS3RsmFI6jKLniuxCTIcY11b4PKwoI7HQZBQUzq/ujqqpZKbdklldVBbdLI2VYJCyTw63nqA54UFWF/nAMw7DQ9cHEB6/HlfN5aPGmoihcsXZhSawPhRBS4JcQKcqnAA110BscPn1otBzsiDmQV5wX4kKEePYYoPiUlUpDRsklo5E09UxOpoyUj50PXbmExQuaOdbexYuvvstn79xU7iFJKoxsV5GWpuocUa4oCqmUycrlszjSdh5FtT8nkga9fQP8+1vvY5oWQgje+M1hzneFMAyLRDKFogw251HSVZ2Fij4nElWxH+gFdjqO3+fONA4aiCYy1oe6pmIYVs4YnSZDqZSJmW6alEgaeJI6NdVe3G6d3r4Bu7jVreP1uvB6dLweV2YbE1W8KYRgy7Nb2ff+6cy03uAAx9q7OHj4zDBfdcnoSFE+hcgXLR/qxGKnsgwX2iMxFhGeGUvW68CpmkMuBbmkGGIpL0Da91jeYMaK87r8r//bv/HEs1ulKJcMIzuS29QQIBiKZdxYABJJg66eMJ3dYXRXlhNZ2pv7ZEcvQohMaktdjS8jdp3un2o6Um1Z5DTtmQw0TbULOC2BhYWqKtTW+DLzXbpGyjDTRacq8XgqI8ztQLqVk46SShkkkgZ+nxuf10VjfRWxeIr6ukHx3dJUnfn3RBVv7t7XniPIs3Fy2SutEVGlI0V5hVEohSVftHwkYT4RDPUeL6Yx0EQI8kJiulDqz1i2IZEMJZpMi3KZulI0Rw4f4iM3fiLz2bBUYAHvHjjJvg9Os+bS/IVmkouTbEtERVFYtqiF+lq7fXwiaTBrRi1ul5YjyLPpONuHYFCIKqpCY32Avv4BYjE731pPF4la+So/JxBFAV1XUVSVhJECRSOeSOGJ21Ft07IwLVuou906TQ0Bunsi9IdjWc5xKgKR6dipaXaai9utk0wZ6e1k2UMWyLcvNcU0IpKifGxIUT7FGOpZXkiYl2RfeYpjiu3QCaUT5MUK6OzlTNPk6NGjLFu27KJozSuZOKLpSLlbivKiSRrQY63LmebxREkkDJ54div/7aG78q8ouSjZtH4RbSc6M58VRaG5sZrmRltk37f5Kv7+kVcKrp9IGsOmeb06VSkPhmlhGBZut048YS+nqkpO3vZE4HigK4qCoqpoqoKq2NaOYPuue70uNFVFQUHVFDTVvoc3NgRIplJEY6l07vlgtN1xofH53HjcOvPnNNDZHWZGUw0rls5EAAG/h/q6qgnP7ZaNiEqPFOVTCCdaPpIwB8Yszgt13xyLAB+2zRIIchnNlpSbnr4ISdMNyEj5ePF73SQSBs/9fDd//ecflwWfkgwb1ixg/6EO3t7aP2yeE+kdq35WFMW2RdRV+kNxNE21ix/T0WfLArPEqlzBzjKxizPVtKuLgmla6JqOz+fC63FhWbb9YU3Ai8el09beRdKwI+HxeAqvx05JMc1IJv3G43FhGCaapuL12HnjyZSZeXi5b/NVkx6Vlo2ISo8U5RXISC4shYo+swV0V9/YiyrHI8CHMl5BLsW4pFLY8e4JIN28RJVtHcaDy6Xh1lJEBuBff/Eun/mUzC2X2CiKwmc/tZFqn8HZLoP+cHyYi8eKJTM43zVctIPdBbTQdqv8Hn7n+lWsuXQuz/zrDo60nSeZMqnyu4lE4sSTRk7E3O6oOZjCraoqlmUVFVV3RLhdfzLo/OLkh8+dVU91wEtvcIDqgBeXrtMfjqGpKgK7wLM/HCORNPB5NFqaaux9A/W1fkLhOJYQeD06iqLgSX/vcvmLb1q/iGPtXSPOl4wNKcqnILYwz42WZ1NKgT1WxiPIpRiXVBo73rVzJmXqyvhRFAUj0ga+FfzF32zhB48+DMC8uS089cQPyzw6SblRFIXVy2ew+bb8KYefum09Bw6dyTTMyWburHoEImNdmk1jfYDfvf0Krly3iM98ahNb/uUdnnt5Dz19dhRaACnDvm/Z7kr2dhRFocrnYu7selqPd5EyzBGFuaJgp6loCpqu4nHrxGJJLGHns8+b3cDlq+ehKArdvRFcusqxkz3UVvtprA/QcTZIPJGyu3NagrpaLzNbGjh2spulC1vSqTyCrp5IJtd+3ep53PWxDWWzH9ywZgEHD59hb55iT9mI6MKQorxCGSlaDoPCHCgozieLbLtDGR2XTCe27zkGyNSVUmFET6P6VhA3vJxLXGYf19PvlXtYkinAFWsXctftG3j97Q8yotTj1mlpquama1dkLBHzzctunPN7v3sNqy6ZzXMv72HXeyc419mPx+sCYeemOykoLl3lskvnIAScPhfEjFijprsoQG3Ah8ejIwT4vG6SSYOli1pYtqglI5x/68OXEo7EqautAuxIuqIog44zAlIpi5bGaqoDPnxeV2YPTrrK2pVzy245KBsRlR4pyqcw2TnmMDnivJDfuBTjkulGPJHKtIZ3ueSfypIgkng9LuKJFNFYglqXzDmVFIcjAFddMjuvAAS47NK5o4pDRVG4ct0irly3CCEETzy7NU+kV1BX46e+roo3fn2IWc11nDH7iMVTdvdNIch2VXRyyL1eF7W1vnRqiYv1l83LbKc/FMsZk1O4KoSguzdCMmlgmoJEMoXHpVNd5eKeT17FlesWsmf/yYoVvaVsRCSRoryiGS1aDoNiOFucw+gCfTzNfEplbygFuaSS2XvwFMmUiaYamW58kvHj97uJJ1LEEwYB0wKZqi8pktEE4FjFYTGR3v60Z/q/vxVlIJZ0VkQRIlPUqesafp+bmS21BPyejI3jfZs3FhTPjg3k0WOdmZQcTVPw+9wgoDrgZcOa+aiqKkXvRYQU5RVOMcIccoXyUIFezDqTjRTkkkpne9qD1+9KVEREarrg0jXcLo1kyiQaS4Jr9HUkkmIZa9v30YS+4zBSV+OjPxwjlTRsMa4qIARq1jYXz2/KsXEcSUhvWr+I7XuO5c2RB7vB0e59J9m4fnHR310y9ZGifApQrDB3qLTOmUORglwyFfjNzlYA/K74KEtKxorf7yHZHyUWS2IGZKhcUhomou274zCi6xrVVR7CgGnaQS/H2lBT7Qj3WBr2bFizAE3Lf+431FdRX+thx7vHpSi/yJCifIowVmFeqUhBLpkKJJIG7+xqA6DKHaWwE6/kQnC7NHRNxTAtemM15R6OZJowEW3fHYeRg4fPUFvjw+PWCQ8kSCYNXB6Nujo/XreLlqZqlixsKTrfW1EUlixoxjStYcWpTfVV9IdC9MnmOxcdUpRPIaayMJdiXDKV2PneCWLxFC2N1Xi0FAOT25l72qMoCn6/m1A4Ts9ALf2hGLU1vnIPSzLFmYi2707euaoqPPn8drwegxnNtbQ0VdPcGCDdu/OCmvfU11XldC51cHzN62XznYsO+d5wijEVxe1UHLPk4uatrYcB+MjVy5Hp5BOD1+NC01QsofGPj71R7uFIpgET1fZdURQ+86lN3Lf5KtZfNp9Vl8xOC2n7j8OFenKP1lznqstl852LDRkpn4Jki9xKjpxLMS6ZqvzynSMAXLdpOe/vLPNgpimKohCo8tAfivG/n3iL37/3Wma11JZ7WJIpzES2fZ8IT+6Rmu9csriJDWvmX/B4JVMTKcqnOJUm0KUQl0x1gv3RjD/59dcs5//9hzIPaBrjcev4XHFicfj637/AY//z89LpRnLBTHTb91J7chcS+leuXUCNT7o+XYxIUT6NkIJYIhk/b/zmEEIIli+ewawZdeUezrRGURRmVXdzMvT/tXffcVLV9/74X2f6dlhY2rKCNBGpURFsFEUU9UaMxGCM3SRGv4kxXmK7itcoxpjivb8kiiaWiyVBxYJiQboUUZQiRZa6LLC979Rzzu+P2TN7ZuZM3Zk5U17Px2MeumfOzLz3cM7Oaz7zPp9zCpav3IH3PtmO78+eqHdZlKEy8bLvWkFfFEXs379fv6JIN+wpJyJSWf7pDgDAnIvG6VxJbrCZXbj79osBAP/532/i0NF6nSuiTKWMPF83dzKGDSlDaa8CDBtShuvmTtb9kvRE0eBIORFRl067CyvX7wEAXH4xQ3mq3PPTWfhk7W7s2H0MP7pjMVa8+iuU9irQuyzKQLzsO2UyjpQTEXVZs3EfOu0uDB7YGxPPqNC7nJxhsZjw6l9vw+CBvXHgcB2u+Mn/Yv/BGr3LIiJKKY6UExF1ef/T7QC8o+T8qju1BvYrwRvP3o5rbn8O3x2swcXX/hk/v2Eabv/xBb4rJf74httRdazW73GyLKNXSR7eees1PcomIkoYhnIiIgDtHU6sWLULAHDlrAk6V5ObRo8YiFVLf4Pb7n0ZG7cewB+f/QR/XvwpvjfuFEw9czi+rWyHwzg+6PLkjppNOlVMRJQ4DOVERADe/nAb2jucOPWUvpg8aaje5eSsfn2L8M4/f4EPVu7EMy98hm++rcKX24/gy+1HAAwA0A6DQYDZbITVYobNyrcxIsoO/GtGRDlPlmW8+K/PAQA3/vBcGAw83UZPBoMBV14yAVdeMgHVJ5qwdvN3+HL7Efxr2Ro4PVZIkgyn0wOn04O2dsBlLkNTSyf6lhZFfnIiojTFdx4iynnbdh7Fzj3VsFpMuG7uZL3LIZXygb1x3dxz8KeFP8TwPtUo61OE3iX5KMi3wGAQIMtAs6sfply+CP9843OIoqR3yUREceFIORHlvBff8I6S2wxNuOrq6/zu+27/AfQZPlGHqnKb1kmdyr+FxWKCxWJCQb4VTpcHLY01aG4FFjz2Jh5e9CoGFNXjtGElePWV53WqnogodgzlRJTzLpk2Bu9+uA4GW380SOV+97lce3WqKjd8t28vLpz5/eDl+w+gz/Af+C0L/LcQBAE2qxkNjevRe9gP0N7hgMNjxeGmcrTsbvVdtpyIKBOwfYWIct5/zJ6IU0tPwGLmOEWquTxAgzQx6OZyuWN4Fhn5eRb0LS2EzWoGADTZizH1ykV4c/lXkGU5OcUTESVQWoby9vZ23H333Rg0aBBsNhsmTpyIN954I6rH1tbW4qabbkLfvn2Rn5+PqVOn4rPPPgtab/r06RAEIeh26aWXJvrXISKiFDAYDCgpzkPvknxYjC7UNbTj579dgmtufxYHjtTpXR4RUVhpOSx09dVXY+vWrXjyyScxatQovPbaa5g/fz4kScJ1110X8nFOpxMXXXQRmpub8cwzz6Bfv37461//iksvvRQrV67EtGnT/NYfNmwYXn31Vb9lvXr1SsavREREKWKxmNC/zzFc/aO78KfnPsXaTd/hgu//HjfMm4pf3X4xBvYr0btEIqIgaRfKP/zwQ3z66ae+IA4AM2bMwJEjR/Cf//mfuPbaa2E0GjUf+49//AO7du3Cxo0bMXXqVN9jJ0yYgAULFmDLli1+6+fl5WHKlCnJ/YWIiCjlDAJwz89mYe5lk/Db372FVZ/vxQuvbcCSt7Zg/lWTcet152H0iIF6l0lE5JN2oXzZsmUoLCzEvHnz/JbffPPNuO6667Blyxace+65IR972mmn+QI5AJhMJlx//fV44IEHUF1djfLycs3HEhFR9lCfQCrLwJDeNtS2l8LuBF781+d48V+fI99sR7GtHaNPzcebry/WuWIiynVp11O+a9cunH766TCZ/D8vjB8/3nd/uMcq62k99ttvv/VbfuDAAZSWlsJkMmH48OF48MEHYbfbe/orEBGRztQnkDbKE+EwjUZRSRmkls2wWrzvL53uPJxsK8OaHfmYcc3TWPDYm3jjnS+w6asDOHa8CW0dDrjdIk8UJaKUSLuR8oaGBgwbNixoeWlpqe/+cI9V1ov02PPPPx/XXnstRo8eDbvdjhUrVuCpp57Chg0bsHr16pBX9HM6nXA6nb6fW1tbAQCiKEIUxSh+Q3+iKEKSpLgeS6FxuyZHsrZrqJY0IPiYa2trA4CE1xEqeGktDRXRNJfLMmTI3uFaQYjrOVK6bhbXKwgCZHcjepXkQxQlOJxuOJ0euD0idu6pxs491fhn15z1agaDALPJCINBgMvlgixLELpeRRBkGAQZVosRY0aPQH6eBXl5Zu9/bZau/5qRZ7Mgz2ZCc1Mjij4/BrvDjU67C512Fzo6XWjvcGLTF1+j0+6BJBu6bgIMBgO+XrkQ/fok9mqloY65RL/HRYt/s7txW3TLlm0R7j1OLe1COeD9wxnPfbE89ne/+53ffXPmzMHQoUNx77334t1338XcuXM1n2PRokV49NFHg5Zv374dhYWFYWvTIkkSmpqa0N7ezkt7JxC3a3Ika7uOGjUKRUVFmsdvqGPuwIEDAJCwOlpbW+AwtQctF91uOOztEZeFWy6JIhyOjrifI9Xr5kq9RgHItwE21w78+PqbsO9gAw4fa0ZdQyfqmzrh6bo6qCQCnggzNDpcHmz6MhFz2gvwfqToDiGbNm5Caa+8BDx3txEjRmDQoEFBx0+i3+Oixb/Z3bgtumXLtgj3HudHTjNTpkyRzz777KDlu3btkgHIzz33XMjHDhgwQJ43b17Q8uXLl8sA5I8//jjsa588eVIGIC9YsCDkOg6HQ25pafHddu/eLcP7F5Q33njrwa2lpSWqY27VqlW618obb9lwq6qq4nscb7yl6BbqPU4t7UbKx40bh9dffx0ej8evr3znzp0AgLFjx4Z9rLKeWjSPVQv3acxqtcJqtfp+LiwsRFVVVXSfgDS0traioqICVVVVKC4ujvnxpI3bNTmSuV2LirS/ng885i644AKsWrUKM2fOxO7du0M+Ll20tbVhzJgxGVErwHqTKd1qHTRoUNCyRL/HRYt/s7txW3TLpm0RzTGfdqF87ty5eP755/HWW2/h2muv9S1/+eWXMWjQIJxzzjlhH/uLX/wCW7Zs8a3n8XiwZMkSnHPOOZp/gNRefvllAIhpmkSDwYDBgwdHvX4oxcXFGb/DpSNu1+TQc7uaTCaceeaZAIDy8vK0//dVenIzoVaA9SZTJtWqSNR7XLT4N7sbt0W3XNkWaRfKL7vsMsyaNQt33HEHWltbMWLECLz++uv46KOPsGTJEl+z/K233oqXX34ZBw4cwJAhQwAAt9xyC/76179i3rx5ePLJJ9GvXz/87W9/w759+7By5Urfa6xfvx6PP/445s6di2HDhsHhcGDFihVYvHgxZs6ciSuvvFKX352IiIiIclPahXIAePvtt/Hggw/i4YcfRmNjI0aPHo3XX38dP/rRj3zrKGeCy6oZE6xWKz777DMsWLAA/+///T90dnZi4sSJWLFihd/VPAcOHAij0YjHHnsM9fX1EAQBI0eOxH//93/jN7/5TUafTEBEREREmSctQ3lhYSGeeeYZPPPMMyHXeemll/DSSy8FLe/fv7+vDSWUESNG4IMPPuhpmQlhtVrxyCOP+PXwUc9xuyZHumzXdKkjGplUK8B6kymTak01bptu3Bbdcm1bCLLMqyIQEREREemJfRpERERERDpjKCciIiIi0hlDORERERGRzhjKiYiIiIh0xlBORERERKQzhnIiIiIiIp0xlBMRERER6YyhvIdkWUZrays43TtRavCYI0odSZJw7NgxSJKkdylEWY+hvIfa2tpQUlKCtra2uB4viiL27t0LURQTXFlu43ZNjnTYrsox99VXX2XEv286bLNYsN7kyaRaFcePH0dFRQWOHz+e1NfJxG2TLNwW3XJtWzCUExERERHpjKGciIiIiEhnDOVERERERDpjKCciIiIi0hlDORERERGRzhjKiYiIiIh0xlBORERERKQzhnIiIiIiIp0xlBMRERER6cykdwFERERE6eanP78bh6tq/JYNreiPxc/+RZ+CKOsxlBMREREFOFxVg+qOUf4Lq77TpxjKCWxfISIiIiLSGUM5EREREZHOGMqJiIiIiHTGnnIiIiKiMGRZ1rsEygEM5UREREQaPB4Rre0OuN0iBEGATc7TuyTKYgzlRERERAE6XSY0NndAGSSXZRlHG0pw5rSb0afQ4bcup0qkRGAoJyIiIlJpabXjYE1vyDJgNhlRXGSD3eFGp92FI/W90CEVwmhUnZbHqRIpAXiiJxEREZHKQ79/By7RCKNBQK+SfJhMRhQWWAFPCwCg0+7SuULKRgzlRERERF2+2nEEr7/zBQCguDgPBoMAABAEAYLzIABvKJcknvxJicVQTkRERARAkiQ8sGgZAKC0sBMWc0CXr6fR17bidLpTXR5lOYZyIiIiIgBvffg1vtpxBAX5VpT3ag+6XwCQZzMDAOwM5ZRgDOVERESU80RRwh/+9jEA4O7bL4LZJGmuZ7N6Q7nbLUKUtNchigdDOREREeW85St34OCROvQqzsdtP74g5HpGowEmkzc+uVyeVJVHOYBTIhIREVHO+unP78ahozXYe6IPADNsQi1+8MObsXfffhQNHqX5GKvFBI/HBafTgzybJbUFU9biSDkRERHlrMNVNTjUPAx2lxkCANE0ANUdo+BwhJ720GrxtrC43B7IMmdhocRgKCciIqKcpsw7npdngcEQORqZTAYIAiDLgMfDvnJKDIZyIiIiylkuj8HXG67MrBKJIAgwd02X6Hazr5wSg6GciIiIclZjex4AwGw2wmQyRv04i9m7rsstJqUuyj0M5URERJSTJElCfVcoj3aUXGHuCuVutwi2lVMiMJQTERFRTtrwxQG4PCYIQvf849Eyd42qS7IMpyf6EXaiUBjKiYiIKCe9+/HXALyBXBCEmB4rCIIvmLc7OC0i9RxDOREREeUcSZLw0epvAQDWGEfJFUoLC0M5JQJDOREREeWcb3ZVoaauFQZB8p20GSvlcR3O+EI9kRpDOREREeWcFat3AQCK85wxt64olGkRnR4Tmls6E1Yb5SaT3gUQERERJdtPf343DlfV+H7eXd0HgBmdLUdgLegf13MaDAKMBgGiJOObb6sw/dzTElQt5SKOlBMREVHWO1xVg+qOUajuGIUjrSPgcHtbTtydNREeGZ6pq4Xl611He1wj5TaGciIiIsopyhU8zWYjBPTsipzKDCzffFvV47ootzGUExERUU5xub1B3GLueRevEsq/3sVQTj3DUE5EREQ5Q5ZluN0iAMQ964qayWQEIOP4yWbU1LX2+PkodzGUExERUc4QRQmSJAPonme8JwwGATazd+SdLSzUEwzlRERElDNcXaPkZrMx7qkQA+VbvKGcJ3tSTzCUExERUc5IZOuKIt/qBuC9IBFRvBjKiYiIKCfIsuw7ydOcgJM8FQUWbyjfvrsKsiwn7HkptzCUExERUU6QJNnXT57IkfI8ixsGg4C6hnacrG1J2PNSbmEoJyIiopygtK6YTIaE9ZMDgMEAnDZ8AADgm2+PJex5KbcwlBMREVFOcHu6TvI0JW6UXDFhzGAAwI49DOUUH4ZyIiIiygm+UJ7A1hXF+K5Qvp3TIlKcGMqJiIgo68ky4PEo7SvJGynfvpsj5RSfrAvlbW1tWLBgAS655BKUlZVBEAQsXLgwaL2bbroJgiAE3UaPHp36oomIiCipnB4jlIlRTMbEx5+xo8shCAJq6lpxso4ne1LsEjcfUJpoaGjA4sWLMWHCBFx11VV44YUXQq6bl5eHVatWBS0jIiKi7NLpNAPw9pMn8iRPRUG+FSNP7YfvDtZgx+5jGDCtJOGvQdkt60L5kCFD0NTUBEEQUF9fHzaUGwwGTJkyJYXVERERkR46Xd5QbkpCP7liwhmDu0J5NS6ZdkbSXoeyU9a1ryhtKERERESK7pHy5EWfCWMqAHgvIkQUq6wL5bGw2+0YMGAAjEYjBg8ejLvuuguNjY16l0VEREQJJIoSOl3e5oBkTIeoGM+TPakHsq59JVoTJkzAhAkTMHbsWADA2rVr8ec//xmfffYZtm7disLCQs3HOZ1OOJ1O38+tra0AAFEUIYpizHWIoghJkuJ6LIXG7ZocydquRmPoN8lQx1ym/Ptm2r7IepMnnWoNdcwFHm9tbW0A4n+Pi1ayt03loVpIsncc0piEkzxlWYYoijhj1AAIgoDjJ5txsrYZZX2KYn6udNpP9JYt2yLce5xazobyX//6134/z5o1C5MmTcI111yD559/Puh+xaJFi/Doo48GLT9w4EDIIB+OJElobGxEZWUlDIac/uIiobhdkyNZ2zXcrEehjrmmpqaM+PfNtH2R9SZPOtUa6pgLdbwdOnQIdrs9afUke9us2XQQgDeQBwY8UZLg8XiCHqO1PNS6u3btxIUXXw0AMBsGwyVacOlVP8eoIXn470d+G1Ot6bSf6C1btkW0M/vlbCjXMnfuXBQUFGDz5s0h17n//vtxzz33+H5ubW1FRUUFhg8fjuLi4phfUxRFVFZWYsSIEVF/kqLIuF2TQ4/tGuqY6927d0b8+2bavsh6kycTag083qqrqzFmzBiceuqpGDx4cNJeN9nb5r3PDgHwtq6YTP7Rx2gwBC0LtTzUuqJkRLM8EQBgMHUCogdN7qFoajmMkSNHxlRrJuwnqZJr24KhPIAsy2E/jVmtVlit1qDlRqMx7h3GYDD06PGkjds1OVK9XUMdc5n075tJtQKsN5nSvdbA401pF0tFzcncNvsO1AAATEk8yVNhMhkBpwcejwhBEOL6fdJ9P0mlXNoWmftdQBK8+eab6Ozs5DSJREREWWRv5UkAybmSZyDlRFK3J7P7oCn1snKkfMWKFejo6PCdoLJ79268+eabAIA5c+agrq4O1113HX70ox9hxIgREAQBa9euxV/+8hecccYZuO222/Qsn4iIiBLE5fLgwJE6AMm5kmcgJfhLkgyPyCmaKXpZGcrvuOMOHDlyxPfz0qVLsXTpUgDek1VKSkrQv39//OlPf0JNTQ1EUcSQIUPwy1/+Eg888AAKCgr0Kp2IiIgS6ODROng8EgyCBIMh+SHZYBC6TiiVfBcsIopGVobyw4cPR1zn7bffTn4hREREpKs9+72tK3kWT8ouLmgydYVyJ0M5RY895URERJS1lH5ymzl4KsNkUfrKOVJOsWAoJyIioqy1ryuU56UwlJt8oTwrGxIoSRjKiYiIKGvtPdA1Um5J/Ui5y2NCc0tnyl6XMhtDOREREWUlh9ONg10zr6SyfcVgEGDsOql0x55jKXtdymwM5URERJSVKg/VQpJk9CrOh9kopfS1lRaW7bsZyik6DOVERESUlZSTPEeP6I8UTbziYzYzlFNsGMqJiIgoK+3r6ic/bcSAlL+2b6T826qUvzZlJoZyIiIiykrKHOWjdQjlZpM3Yh06Wo/WNnvKX58yD+fqISIioqzx05/fjcNVNQCAb4/1BWDCP//xD1Qf3Y+iwaNSVofBYIDFKMIlGrFjTzXOnzwiZa9NmYkj5URERJQ1DlfVoLpjFI61j4TT4x17bPacAofDlfJa8q1uAMD23WxhocgYyomIiCjreDze2VYEQYDBoE/cybN4Q/kOnuxJUWAoJyIioqzjEUUAgMmkX9TJtygj5QzlFBlDOREREWUdZaTcZNQxlFu9Fyw6cLgObR0O3eqgzMBQTkRERFnHI3aF8q6pCfVgNkoYNKAXZFnGrr3VutVBmYGhnIiIiLKOx9PVvqLjSDkATBgzGADwzS6e7EnhMZQTERFRVpFkGZIkA9C3pxwAJo09BQCwbedRXeug9MdQTkRERFlF7OonN+g484rizPFKKD+iax2U/hjKiYiIKKukw8wrikljT4EgCDhyrBH1je16l0NpTP+9lYiIiCiBlJlXjDqe5KkoLsrDyFP7AQC+2sHRcgrNpHcBRERERImULid57tmzG5dcPh/19cUA8vGbB/6CP/Zux9CK/lj87F90rY3SD0N5llqzsTGux00/tzTBlRBRPFZviO4YnnE+j1miQN3TIeobyp0uGdUdo+CGC4ADjZ0lkC2DgKrvdK2L0hNDeRaJN4hHeg4GdaLUiTaMa63PgE4EiJLQPfOKUf/2FQAwd7XRuD0iZFnWuRpKVwzlWSIRgTzSczOcEyVXrIE83OMZ0ClX2V3eaGMwCDAYBJ2r8VJG7GUZELtG8YkC8UTPLJDMQB74Oql6LaJc09NArvV8iX5OokzgcHtDud795GqCIPiNlhNpSZ89ljIGwzlRYiUzPDOcU65RRspNaTDziprZ3BXK3QzlpI2hPMPpGY4ZzIl6LlWBmcGcckU6jpQD4Eg5RZReeyxlHAZzovilOihz1JxygV0J5Wlw4SA1ZaTc45Egsa2cNKTXHksxSZdAzHYWotjpGY4ZzilbNTS1wyN6w286XDhIzWAQYBC8J552usw6V0PpiKGcEobBnCg66RKIGc4p2+zZfxIAYFQF4HQhCAJMXaPlHU6GcgrGKREzVLoGYE6fSJR51MFcBiB6SnG8vgUzOa0iZZg9+48DSL+TPBVmkxEulwedDOWkgaGckmLNxkYGcyINmTQyHVgr5z6ndLf7uxMA0q+fXKH0lXewfYU0MJRnoJ6Oktc3aS/v27tHTxuEo+ZE/jIpkGvhxYko3e3Z3xXK0+RKnoGUGVhcHhPqGtpQ1qdI54oonTCUZ5h4A3lgELdY/EcRXC4paJ1EhXSGcyJg7aYWJKLDtU7jT0CZDoeWEtAZzildSJLk6ylP15Fyg0GA0WiAKErYuv0w5swcp3dJlEbSc6+lhFLCtsVi8N0Cqe9T7q9vCj2qHg/O0kK5qupk/MG1rtH/pnWsqu9PtUwf/afsUXW8CR2dTgiQYUyzOcrVLF0tLF9sO6RzJZRuOFKeQWINtOowHivlMeoRdI6cE8Vm9YZGyD14vBKywx3D6vtcLsn3mFSOnq/e0MgRc9Kd0k9uM3sgpNnMK2pmsxF2hxtffM1QTv7S96Mk9UhPArla4Mh5InHUnLJVT6caDBwVj1bg6HkqccSc9Kb0k9ssHp0rCc9s9o6HfvNtFRxOt87VUDphKM8QsQTYRAVyNeXNni0tRKElYt7vaEbHI1GO11S3tDCYk552d4XyvDQP5UaDAJNBhMst4ptdVXqXQ2mE7SsZIBmBPN6TxSwWg6+lJdGztRBlokQG0UQEcjXleE1lSwtbWUgve77zzlGeZ3ajvSd9Y0kmCAIKbW40dxqxZdtBTDlzmN4lUZrgSHkWiRTIA08Gs1kNvpvW/aEko52Fo+WUaRJ9NcxEB3KF1gmhycYRc0o1p8uDysN1ANJ/pBwACq0uAMBm9pWTiq4j5dXV1XjnnXewdetW1NfXAwDKyspw9tlnY+7cuRg4cKCe5aWFaMNquECufhNWAngg9XKHM/LImjICR5SLEh06Ywnk6uM5lpFv9XPXNQYfu4keReeIOaVS5aFaiKKE4iIbzMb0f2+qO7EPsJ2NVet3Ydac+RAEYGhFfyx+9i96l0Y60i2UP/LII3jqqafgcrkgy/7fM73yyiu499578cADD+Chhx7SqcLMEU0gDxXGtSjrKuE8XDCvb5ISOisLZ2ShdJaMEeBoAnng6LbNZoDDISUkoAP+s7YAgAxTQkI6gzmlitJPPmbkQLgaD+tbTBRczjbABoiSAUdbh8NkMgJV3+ldFulMl1D+4IMPYtGiRbBarfjJT36CadOmYdCgQZBlGSdOnMDq1auxdOlSPPLII/B4PFi4cKEeZeoumlHyRAdyNZvVEDGYKzWwv5yynR6B3HcM24LvVy9TB/R4wnTg6ztdEup1mFqRKF5KP/nokQOxY4vOxURBgAyz2QiX23vCp8mUnlcgpdRKeSg/ePAgnnrqKZx66qn46KOPMHLkyKB1br75Zjz00EOYPXs2nnjiCdx444049dRTU11qxkhGIFdECuY88ZNyQaoDuV/LmUYgD6Sso4TzngZpo0GCyWRKyEmiHC2nVFDmKB+TIaEcgC+Uu90ikKd3NZQOUn6i58svvwxJkvDKK69oBnLFqFGj8H//93/weDx45ZVXUlhheoh2lDzWQH6iPvxNi/pEUC2JPjGNKJ3oFchtNkNUgVxNeUyiTuhM1LznPPGTkm3HnmMAgHGnD9a5kugp85W73el/YiqlRsrT1Oeff46xY8fivPPOi7ju+eefj7Fjx2L9+vUpqCyzhJr5JFQgV0J3nk0IeVOvFyhSMA9XUyw4CwulEz0DeU8oj09kOFeejyjdnKxrQW19GwwGAWNGZc4EEeaulhVRkiGK6X9yKiVfykP5nj17MHny5KjXP+ecc7B3794kVpS5At/UwwVyAL7gHUpgOA8ULpgn66qfRNmkp4E80rdaauqR9nQI5hwtp2TZsds7Sj7y1H4oyLfqXE30DAYBJpP3uHJxtJygQyhvbm5Gv379ol6/X79+aG5uTl5BGUgr+IYL5OqwHY2eBvOe4mg5pYNEh8j6CIFcq10lsL0s3yYgP+BbrUgBPZGj5j09xhnMKRl27K4GAIwfkzmtKwpLVwuLyy3qXAmlg5SHcrvdDqs1+k+yFosFdrs9iRWln2hCqdabY6hAHo94gznANhbKfIkMj/WNQGOrya8/W6EE5VBhHOgO4vmqY1m9LN8mRAzniR41Z385pZPtu72Xqh+fQf3kCovZ28LicnGknHhFz4wTbpRcLVQgP1Eva960RBPMAyWyjWXNxkaGc8pY6pFpoyG4XzRUu0pgGI9GLOE8sLZYJeIbMQZzSiSlfWXCGRU6VxI75WRPSZLhdHNaxFynyzzlS5YswebNm6Nat7KyMqbnbmtrw2OPPYZvvvkGX3/9Nerr6/HII49oznW+bds2LFiwAJs3b4bJZMLMmTPx9NNPY9iwYTG9ZqpFGiXXelNWB++CPP83+g57dzAf2Nf/vjybALtDxol6YGDf4OfVmn4t0Vf7VAdzXlyIkq2ngVEddpVj1eORNNcJF8jjkW8T0BnmeFW/Zk+nT+zp1IucKpESob6xHdUnmwEA40aX61tMHAwGAWaTEW6PiDaHRe9ySGe6hPLKysqYwrYgRP8G1dDQgMWLF2PChAm46qqr8MILL2iut3fvXkyfPh0TJ07Ev//9bzgcDjz88MO44IIL8M0336CsrCzq19RT4GiX1kmdSuAODOMKZbkSzkMF80Dh5jBP9NU+FYEj5wzplA4Cj8Nors6pDuSRwnh1nfaH3PKy4Nfp7jlXPmhr16FcFTQeifrgrXwAYjineO3smgpx2JAyFBXadK4mPhaLN5S3M5TnvJSH8kOHDiX1+YcMGYKmpiYIgoD6+vqQofzhhx+G1WrF8uXLUVxcDAA488wzMXLkSDz99NP4/e9/n9Q64xGqJSSwlSSWQK5WkCeEDebe5cGv7XCGfnNO9kWFGNIpkeIZJY90VU6tdaMJ5IFBPD/gGO60y37rBAb0aEbNlZr0vmonwznFS2ldycSTPBXeFhYX2hwWyLJ2OynlhpSH8iFDhiT1+aMZVfd4PFi+fDluuOEGXyAHvLXNmDEDy5YtS8tQDvi/8YcaJe/+OfpArggXzJXX0ArmdY1SyDaWVF7tUwnpMgDRU4ow16ci6pFYwrh6/VgCeWAQV1PfpwT0UME8lJ6Olmsd9z2h/lDEgE7R+OeS5QAEfLF5HS65fAUAYO++/SgaPErfwmKgnOzpFo04cKQOp1b00bki0ktOnuh54MAB2O12jB8/Pui+8ePHo7KyEg6HQ4fKYhdulByILZBHeky4Ez+B9Jy/fN2WFp4wSgkX6+h4Y6t3/CNSIK+uk6IK5IGUdUO1uUSaNjEdLwq0ekOj70YUSl2zdyrBTqk/qjtGobpjFBwOl85VxUYQBJi7gvn6Lft1rob0pEtPud4aGhoAAKWlwSMxpaWlkGUZTU1NGDgw+MpgTqcTTqfT93NraysAQBRFiGLs84yKoghJkvweG8uXV8o3XScb/JeHmlGlujZ42qXyfsG7QUGeELa/PPAbNqvFAGeIHlP1iHmfFI2YQ+7ajjIgd/0Kq7uC+YXnlKSoiOyjtb8mgtEYetaBUMdcoutYu6klpvVjaVcxGyUYTUbfwX2i63jNswm+410J1PF8kAa6g/mxgBFzv5O1NQbgIrWghaOMlvdN8qD2KlUwnzbV//hN1j6ZDOlUa6hjLvB4a2trAxD/e1y04tk2za2dcHm871/K1TEzlcVsgtstYv2W/fjx3LPTZj/RWzodMz0R7j1OLSdDuSJcq0uo+xYtWoRHH300aPmBAwdQWFgYcw2SJKGxsRGVlZUwGAw4Vqv97tbU5v2n8ni8obqxxfuz2PUzZCPMZgnKj5ANsFpUPwOo6Xpfy7N079x2lxHVtR7013pZ2YATdTLKektBy0/WA2W9/A8SkwGobTCgtCQ4+BsMgCgZUN8E9C5K/nysMgBZkuCBB4H/kqs/b8Dgfhx9i0fg/pooo0ePDnlfqGOuqakpoXWInuiSpTLq7fGE3o+VdQBvIJdkCfAAEIC6Ju8fZ4tZgtj1FCcbvXtp4DELACcbwn9MH9AnYA+XDaiuFTGgtPtxFhPgchvgCfHGJsOA2kagtNj74pIkhf39Ah9bp3pssq1a34CKAd3Hb7L2yWRIp1pDHXOhjrdDhw4l9Zoh8WybbTu9Fw0yGARIkgip661KDLH/JmJ5sp7b2PUrr9u0D999tx/NzYn9+5ap0umY6Ylw73FqORnK+/TxDhcpI+ZqjY2NEAQBvXr10nzs/fffj3vuucf3c2trKyoqKjB8+HC//vRoiaKIyspKjBgxAkajEScatUfrBCgjc96dUhC8o9O+DiQBMJm8/5wn6mUU5AtQdydV13pQmK+8eXf/sxd2/W9Noxw0Ym4yeWdkUZ5XvdzukFHXYsKAgJE3jyShqdWk2WeqPEtz1weMpI6ay4AHHpiMJgSlcgAnGvtxxDwOgftrKoQ65nr37p3QOo7XRzdSHngsBqpr9K6jtJbJEAAPYDQZcbJBAASlFcx7f3WdBAjKCLnqmK1xAwCK8kMPHrR3yqhpkFHe3+xbphy3J5sE/xFzE1DXLGiOlpuMgMMp+Y51j8cTdNyHYgLgcnmP+2SPmCuO1/fzjZjrsU/GKxNqDTzeqqurMWbMGJx66qkYPDh5J1PGs21WbvSGcrPJ6Le/Gg0Gzf03EcuT9dxGoxHtHXY0tzrgEPNRWiqk9X6SKplwzCRSToby4cOHIy8vDzt37gy6b+fOnRgxYgRsNu2plaxWq+YVSY1GY9w7jMFg8D0+li+ulcH8SFfurK71hH1jB7xv/NW1nqBgHqmNJfALhXDTJCqUdpaGrj7zZJwEKgtdWVzQzOQAov86ifyp99dUCHXMJbqOaI69usbQbSuh5h4XZAF1zUbfARvYQy7Av39cCeOFBZErKiwQ0N4ho7rG7RfMC/IEdNplHNc4+fNEg/ZsLDZb/Cdu+s4dafQOVaZiNpd1m1p8J4Omep/siXSvNfB4U9rFUlFzrNtm597jAABThreuAN5v54tsLrTYbVi3eT/mTDslrfeTVEr3YyaRMve7gB4wmUy48sor8fbbb/v65QDg6NGjWL16Na6++modq4ss3ElZJ+plv55UrR7yUJRgHup5tZcHL1NGCMPVqVxy3DufOXy3VOLJn5QooQI54N8/HhjIgfgDuaKwQEBhgeB7rELrRNH8CCdrAz076VMJ56k6cZQngea27V3TISonSWa64jxvL//qz/fpXAnpJStD+YoVK/Dmm2/i/fffBwDs3r0bb775Jt588010dnYCAB599FF0dnbiiiuuwIoVK7Bs2TJcfvnl6Nu3L37zm9/oUneokKgVVpXgq35zDQzOSsCONEoeKDCYxzMbSzTBXJEOAZ0okkj7smYg7zo2LGb/8zLiCeRVJztQdbIj5OuHCuZB852HO267fgd1T3ysUh3MYz1Bl7JDW4cDBw7XAQBMpuyIMsV53lljtm4/jPYOZ4S1KRtlx54c4I477sC8efNwyy23AACWLl2KefPmYd68eaitrQXgbbpfs2YNzGYzrrnmGtx0000YMWIE1q1bl5ZX8ww304O6dUUJ0PEGcmV9rWCuNVoerm0mlmCuSHVA52g5AdGPuGodh3WN4QN5nsaUh/l5QlSBXAniVSc7UFxoQHGhwW+ZlsBgrryuWthgHsdxGyjVwZxyz7d7j0OWZZiNIowZfAKgmtUsYtiQMng8Er7adVzvckgHWdlTfvjw4ajWO/PMM7Fy5crkFpNgod7ktAJzYCCvqtE+c76if17Q49o6Zc0e81iu9gn495gDsfWaqgNQfZM3VKTqIkRE0Qh9PHYHX/WUh9H2jyuBu7gwOGyolynrVQwo8D1PYI95fld/eeDFhcJd8dNskuDxGHp0tU/l3JFUqDrJC4Xlmh17vK0r+ZbgD6GZ7KLzR+PgkTp88U0Vbrte72oo1bLj42UWWLdF+yvYSK0r4UbJFVU1dl8gLyoUgm7q+xVaI+zK88fSX67U29PRt8DRc6JUCrffBo6SqwO5QpnysKeBPJCyjnrUXHk+9Yh5qIsLRRox95782bMRb7axUDLs6Oonz7OkZirOVJlx3mkAgC1fV0EOvCAIZT2G8gwQ6SIl6pAc2LYSGMa1KMu1RtJD9ZcHBvNIV/sE/L8W70k4BxjMKfUCj0OtthWtQK51UaBwgVxpU4lWMoM50P07xnPMRnOBJaJ4+EbKrdk1Un7e2SNgMRtxsq4dlV0985Q7+Bczg9Q1ap/gCfi/4WsF8ki0gnm4/nIt0QbzRIyaA4kL5uwrp1hp7bta+70SgK2W7iCsFcjVfePxSOdgTpRodocL+w7UAMi+9pWCfCumnDkMAGdhyUUM5WmsvinyCZ5ao+RAbIFcEWswD3fiZ7hgDvT8ZDKOwFGiRDrJM9Q+qh4lV/Z3rSkPtT7Eas2wohXIq4/XhL1pPb4nwTzfJuBEQ/dVRwN/33jaWSwWA6dIpITa/d0JiKKEsj6FMBtTc95CKs3samFZ/flenSuhVGOySQPHaiOfSaV+U4tmlBwIDuRHqxuDboEyKZgDbGOh1FB/CAy1v0aagxzwhuNQLSuBlNDdq8ioeVPWUYfzWIK5Ml1iYDj3Hb/BFzwGwFFz0p8yP/n40wcHXcAuG0w/1xvKN355AHaHS+dqKJUYyjOIEmIB7VFydduKOpCrA3hJkcF3C7xPEUswB7RP/ExFMOdoOSVbtKPkgX3kQPyBXAna6vCtJTCcK6IN5uoaA4O5Mq8621koHSkneY4fM1jnSpJj9IgBKCstgMPpwaYvD+pdDqUQU02aCtW6ojVKrtW2oggM42rhwnm0wTzcjCyxBnOiVIum3SHcKHmoPvLAQH6yIfj40JpnXD06Hq1kBfNIx2+swZwBnhJFOclzwpgKnStJrD17duOSy+fjsv+4Hq7OEwCAu/7zT/jpz+/WtzBKGaYhnYWaClEt8M0scJQc8AbmwD5ydSAPJzCc+54zTDBXiyaYpzue7EmBohklB7TbVtR8J3aqjp1w0x7GEsgDH5PoYJ6oE0D5rRYlitPlwZ7vvIE120bKnS4Z1R2jcLzzNIhG78UDGjqKcLiqJsIjKVvwL2WG0BpNDhwlB2IP5Grhgrnfa+QHv26oGVkA5UNE1GUQpY1YR8mB4LYVAMizikHLtNpWwgXyxhM7/G6BlHaWaIJ5YYGQ8mBOlAh7K0/A7RHRqzgfFYOy92pyZpP3b4EoSnC6Y/+gTpmJoTwNhTp5MdSbonqUHAgdyBurtwXdAoUK5tHOYR7qwkJE6SaemToijZJr9pEHXlk3TNuKFiWE9y4x+W7q5YGiCeYAwgZz5WJHvuUJCuYM7tRTO3ZXAwDGjymHkI1neXYxGASYzd4w3mK36lwNpQpDeZpSRuhCta6EGyUH/AO5OoAHvbFrhPNQo+vRnvhJlOnqGiOPkkfbtqIlmraVwDCupj6OtcJ5T4J5QQ9HzENhCwslwg7VzCvZzmrxHvetnQzluYJ/JTNAuBMhtUbJAwM5gLBv7Or1FCVFhrj7y1M1Wu5ySeibvd9eUpqJFDq12lainW1FK5ADCDpmtahHzgNFE8yB4A8Q6osdqWnNMhNIz9HyGedHnl6WMpvvJM8zsuskTy1KKG9zWNDR6dS5GkoFhvIMEaknu6hQCJraUB3IwwkVzIHI/eUAR8uJAoUbJfdbL0zbSjSBPHBddTDX6k/XGqEPdfInoP0NAMDRctKHxyPi233HAWTfSZ5ajEYDDAYBMgSs27xf73IoBfgXUkexzvihnnUlVBAObD2J9o1daz2tNpbA/nKt0fJU4Cg56SWa1hVAY5S8RvsiQVqj5LEEcoXWYwLbWHy1aLSxBAp18nak0XLlqp+pNm1qSepflFLqu4M1cDjdKCyw4tSKPnqXk3SCIPhGy1eu361zNZQKDOUZSHmzVFpXtEawG6u3xfzG3rvEFLGNhYiCabWuRKIVlrVaUGIV6Tm0Phj4akrAaHk0eMInxUPpJx87uhwGQ27EFyWUf7puD2SZEylku9zYq3NAqoNz4GwsgSP3yewrd7m0QwJRMtQ1Rm7LiOR4vUNzuVaLSTyj5JEeG+9oeagPGz3pLU9GC0vFAKb8XLC9K5RPzIF+coXFYoIgyDh+shm7u+Znp+zFUJ5mQl3JMxpKu4lWb3i0tEbLgfC95YEtLOHmLNficEooi/H8LLauUCo5HD3/IFgc4pwMRSJGybVE21ueSD39EEOk5ZtvqwDkxkmeCkEQUGTznuT56Tq2sGQ7/uXMUj0ZbQsUywWIiLJNrB8YoxHqQkGJPG5zBXvJc8NtP7sbX24/BAD43//5My65fD4uuXw+9u7L/hMgS/K6QvlahvJsx7RFBGD6uZxKjYgoXe072ABZFiAIQL1zGKo7RqG6YxQcDpfepSVdSb43lG/dfhiNzcFTmlL2YChPM317Z07PtNZVPolyQafD/5yJTnvPzqGId8aVdKbXLCyUnTqdZgCAyWTM6it5arGYJJw+ciAkScaqDXv1LoeSiKGc4hJqznKibDewr//P5WWx/RkNNzc5EWnrdHk/tJpNwW1fuWDWhacDYF95tsuuoZkc19ImoaTIgNLy78U1JSJRLplxfilWbwg9lOtySX4nXTscUlwnMFbVBH/drNVPnghNLR6UDhzvt6y5TQxar7U9+Nu49g5Ot0bpq9PVPVKea/bs2Y12x1IAffDOii9xcNeHEARgaEV/LH72L3qXRwnEkXIdxdrHbHfIGNhXQEfXV+VtnV3/bZdxSnlieqKbWjwoLf9eQp6LKFMFntzZ05M9C2z6tqSVD+oftKxiQEHwev3Nfj932uWYvwlQJGLGmmis3dSSktch/Xg8oi+Um025F1ucLhnNnqEQBECUDDjc4u2pP1zFb92yTe7t3Rkq6Cvzft5R8Ir+eTpUkzjxTIeYDLFeXZVy28C+ie8r76mmluCr/Oo9Sp4OxzZlvn0HanwneRqNuRlbBEGApetCQi6X9hW9KfPl5t6dYRzO+EactN6kI62vNUre0pYZJ54SxWrG+eFTY+BJ16FGfyONJnc4kvunVjnWA1tXgPhHyTvCfMjodMhBAwVEyaLMT56LJ3mqKVf3dDoZyrMVQ3maUsJArCNNSoCOtQUlUoBPVHsMUaZIVAtLRf/gAJxIoQJ5qFHywEAebpQ83tYVokTa3hXKc/UkT4USyj2iBFHkYFk24l/cNBTuapX2rq/Mo+0rj2a03PemHsMoeVu7nPGtM0Q9odXCoijvb465JSTWb7bUjwkVyNWj5OHaVgJHyZ0uvjVQ+viGoRwAYDAYfNvAyRaWrMS/vBlE+bp4YF/v13eR+sqVkB3qzb6pxRNVIO/pKLk9RHCJty0nWdhXTlqibWEB4u8rV0J1tMHc79jVaFkBtAO5epQ8VCD3PT7EKHmoDyLRypTrMFB6cLtFfLvvOADAlIMneQbytbAwlGcl7uE6u/CcxF4i+pTyUr/RbXUwD7wp98cayNvaw78pa/Wihuo/jbUlwOWSwn6TQBSrcH3l0bSwKCE1llYPrdYSdTCPdCsdON53C3ze5jYxYh95uEDeYZcxoDT8MR6pnzzSzCs8AZSitbfyJJwuDwyClLMneapZrd0ne4pS7vbXZytOZJ0BykqBukYJNmv4P0ht7bLvoj7KnOVAbP3l6kAfboQ8UuuKMpqfadZsbIx5qkrKPcqc5QP7AifqY3ts+aD+IS8gFGrUOxpaLStAcB95uECuTIEoerRDdSyj5AzelAjbd3tbV/Kt7pw+yVNhMhlhNBogihJaOq16l0MJxo+daapv79Bf86rnKy/vZ0Jbp39/d7ztJurR8VDPodVL3tYp+1ppopVurStE4aiPxUij5UoLi7qvfFBfG1oDvmHSGi2PV6ge8ngCeSTpNuvKtKmJ/baR0sv2b48BAPItbNdQ2LpGy5s7bTpXQonGUJ5hIr0hqltLop3KsKVNQkubFDGMx3NyZ6h+ciB9W1fYW05qkfbTeEKqEp57EsyVVhWlXSXeHvJOuxxVIE+3aRBnnF8acUpLynzKSZ75VrfOlaQPq8V7DLfaLbA7XDpXQ4nEUJ4ltEbLlf5yrXCuLI82jAPaLSuBo+QddjmodSXwjTyeUXKeHEZ6CxwtD+ybVrd2qE/4bO9Ujp8CvxlQ1ME82nCuDuLKc2i1qwDRB3IgfD98p0NOq0DOMJ47XC4Pdn/nPckz38JQrjCZDDAYBEiyAas37tO7HEog9pSngcH9GnGisV/YdUL1lSstLNW13V/tqXvLlbB9tNp/9Ddci4t6tD3cyLgyHaO6FrVEjZIrYYgneFKyzDi/FKs3hP6GxHv8BS/X6i0vLzOgus67z5b3N6O6xj9MtLZLKC70HsdKoK4+XhN1MNc6iVN5XkUiAzkQ27cB4U7y7MmHawbx3LP3gPckz+IiG6wmEeCgMADv1T1tVjM67S58uHIn5swcp3dJlCAM5Wmsb2+gvkmCxeL/pukNAN4R6RP13cFXGS2vqrH7BXMgcp954Iwq0YbxwF7yRI+S6xXIecInaXG5uo9HraDe6ZCRb/MeA512Gfl5Asr7m3GsBijK94blqpMdfsEcCB20oxEqjAPxB3KX2wB4Yg/kinAfuuM5AZSBPDcp/eQTxlSgo+awvsWkGavFhE67Cx+t/hZutwizObfncM8WbF/JAspouUIJ1JGmLlTWUbenKDfNdTtlXyAv72cKaltR0xolVwJ5tG/KHCGndBJqv1VGhtXhVQm7mm0sXcFZOREzXurHVwwoCBodb++QUd7fHFMg73TIvmN3YJ/0O6mTcss33x4FAEwYM1jnStKP2WyEySCiubUTn2+t1LscShCOlGcYh9O/hUVrtLwoX/AF66oae9jni3TiZmCLitYsK0ogjzRKDkQXyBnGSQ+RWlgUWqPl/m0s3tFydRvLgD4Cahq8QbmwQPAFaGXUXKEePVfTCu+Bo+KKeEfHO1Vh3COKiOftIdL85PHgKHnuUkbKJ46twMbVOheTZgRBQK98J+rb8/HWB9sw/dzT9C6JEoChPE1ceE4J1m9pCbuO+uty5c0/r+urcnVvuRLMgcihO1BgCAe0g7hCK5DbNU4Ki6ZtRd1vykBO6Ug5BqNtYykvM+BYnQSrubu/XAnN6nCuqDrZEfK1Q4VwhfK8QGyBPKhvPM4LdiqBnPOTU0/8/Bf34MixWkgysP1IfwAC/vynP+LQwf0oGjxK7/LSSmmhHfXt+Xj/0+34/UM/QH6eRe+SqIcYyjOAOgBoUY+Wq4M5AF84Dyea0fBAoUbH421b4eg4ZYpoT/pUB/PqWhkmU3dYVsJ5YYH/8RMpeGsJF8aBGAN5nKIJ5PGc5MlR8txzuKoGxztPg9stQkYHBAGocw6Dw7EDRXoXl2YKrG6cUl6Ko9WN+Gj1Llw9J/oLBVJ6Yk95mtMKqepRZ3UIVoKyut9b6QNXB2/1ssAe8UiBvMMuRwzk6jd4BnLKJLGEQK0LCgX2lyuhd0Cp97hRX1hIubiQcotF4OO0eseBxARyh0OKeCsrjW6EnKPoFC23xzsbkdlk5JU8QxAEYN4VZwIAli7/SudqKBE4Up5hgltYlP/3jpZ32GUU5Hn/gKkDtnr0PNarbwaexBkYxoH4AjnDOGWqcG0sgSPmdocMi8kbjI/XSb5ZWQD/ke3AqRMj0Qrhip6EcYdTggwDPJ7wVzGNBa8zQLFyu7tCOWcVCeuaK8/CH5/7FKs27EVdQxvK+vD7hEzGUJ4hwrWw2B3e3nKtYK6IJYgHhnBAO4grr+293385AzllqmhP+NRqYwlcpgRzl9uAPFP3HOZKaM5XHafhQnYs4g3k6pM0S4s9MJkS+/bAUXKKhXqknEIbeWo/TBp7Cr7edRTvfPQ1bv/xhXqXRD3A9pU0Empe7MDgWlbaHXqVN9fucOwN50qbiVbADqReV92aor5pYSAnCh4FDrza58A+3v8qx0t5mcFvysTOKI7RaCjPpX5+v/ujCOTRtqHEIt5RcvaT5y5JkiGK3v2GI+WRzbuyq4XlfbawZDqOlGcB9dfkymwsSpBWRs7DPz62fj11H3u2BnJeOCi3xTpaHvhNlu8KvLau1pbeIuqaTX4XF1IHZ2XqREV+XnTHZGCgjzjdYeDx6khci4oW5XjnKDnFQhklNxoEGAwcOwxlz57duOTy+XCLBgBl2LbzKC6cdT1GD++Lxc/+Re/yKA4M5RkkuH+1e85yrWDuXZ6YE2QCZ1XRHG3LkkBOFItIwRwATKauEXMBvpmS8lXHaWBAj2X0PFQQB7rDOBA6kCczjCfr+Sm7dfeTM6KE43TJqO7wThNpsXTC5fLgcFM5bFVHda6M4sU9PkP07Q3UNwUvV19MSB3MAfiF81hpTW0YbpaGbArkHCUnIPrRciD0NInKcrfHAKU1Vj1lIuAfzoHwITsW0barhBOp9UT5EKK1HsM4xcvXT87Wlajl2cxwuTywO9yQEtMRRzpgKE8z088txZqNoYOA5mwPAcEc8A/nQOiArhW+1c8TiXp6RgZyymXKyHjgCdllpUCtcpzago9T9Wh2YECPVbiRcSC6dhWXyzv7iuSSwgZr5duBcM9FFCtZVo2U8yTPqFktJhgMAiRJRkunTe9yKE4M5RlEa7RcK5gDwW/IylfmWuK5cEg0YRxgIKfMFstoOeDfsqIO58psJsp9geEcCA7oQHQhPfAxIac6jDA6rh7tLi32wBhh9hUGcUoGl8cIWfbu0yYT+8mjJQgC8mxmdHS6cOSkhEsun+93/9CK/uwzzwA5G8rXrFmDGTNmaN63adMmTJkyJcUVRU+7dzU4mKv19Ip9gH8QV143XI1AZoRxgIGcEidUj7n6PiUgK+Ec0PogHRy4tURz8R/16wcK7P+WAYieiC9LlBQdTu/UoLxoUOzybBZ0dLogGUtxpLUQJqPq70/Vd/oVRlHL2VCueOKJJ4LC+dixY3WqJjJltFwrmAPdo3QAQgb0aAWGcPXrhJPoQB4uMIdr9SFKhFhHy4HIwRwIHc4VPf0gHW2rSrj79cLpEHNXh8sCgP3k8TAaDbCYjXC5RdjtLhQVso0l0+R8KB85cmTajYpH6isPFcyBgDd8Z3QBXSt8q58rWuoRt0QE8mhGryNtq0S9DlGs1B+UZRiC/tiqjy/1h2lAO6RHQx3EA19DjbOjULrqVI2UU+zy8ixwue1wON0oLLDy24YMk/OhPFOFC+ZA8Btt4Jt+uHXjkcrR8VDrxhPOGcgpGvGMliv6lgKix4OmVu+f20jHq3oEPR7RzqjCME7pxunywO7qCuUcKY+L1WICJCckWOF0eWCzJuZKwZQaOX8WxZ133gmTyYTi4mLMnj0bGzZs0LskANGFRSUAR3PFPOVKfVq3eLlcku/Wt3fiRsfjDcqxPo6BnGLR05aKvl3Hm/q40RLuWI3mForymsm4amcisXUld+2trIMMAQaD90axEwQBcJ0AANgdbp2roVjl7Eh5SUkJfvWrX2H69Ono06cPKisr8Yc//AHTp0/HBx98gNmzZ2s+zul0wul0+n5ubW0FAIiiCFEUY65DFEVIkqT52GimGu3TFYQbmoJnfEg0rRChvH5Pp0W98JwSAIhrG6pd0PU86za3eGuSATngb3uiXisXhdtfe8JoDD0qFuqYS0YdkVw4tQRrN7XE/XgZ3nAOAPWqKQWTddz6tZSVdtcQLT2mO4713zRZ+2QypFOtoY65wOOtra0NQPzvcdESRRHb93jDZM6f5Nk1+wxkGYhjOwju45BtQ+FyeSCKEoxGA2RZTov9LlbpdMz0RLj3OLWcDeWTJk3CpEmTfD9fcMEFmDt3LsaNG4cFCxaEDOWLFi3Co48+GrT8wIEDKCwsjLkOSZLQ2NiIysrKoMsJDywFjtVGN2rUq8j736a27n9SoyG+r8BFKXRA6F3kPy1DT2dpGNzP2xKwf39tz54oQP/e3u1a2rs0aLsm+rVySbj9tSdGjx4d8r5Qx1xTU1PC64jGoL5A1cnYRnMlSQI8/gdL72LvfxtbTXCqwnO8xy2gfeyWFntfN5ZjVaveVKgY0Bjz8ZmsfTIZ0qnWUMdcqOPt0KFDsNvtSatHkiR8ueMoAMBoFOAJ2P9ESQpaFmp5LOum63NLkgRPmHXDLZc8HbCYDHB7JLR3OFCQb0Gn3Y79+/cHrZvu0umY6Ylw73FqORvKtfTq1QtXXHEFnn32WdjtduTl5QWtc//99+Oee+7x/dza2oqKigoMHz4cxcXFMb+mKIqorKzEiBEjND9JjRwJrNsS/chcX9/IOSCFCdfhCOgeAQ+WmF1GGa0G+iTk+QJF2q4UHz22a6hjrnfv3rr9+44cidhGzD2h5/0ObCWpb4z/jUdA94h4tziO2YB6p00tCbNyjNsiBO9rxP73IJOO9UyoNfB4q66uxpgxY3Dqqadi8ODBSXtdl8uN7w56L8Rhs1pgCjjR02gwwKRxDGktj2XdtHxuWYYHgMloBAQhrufOz7eipdUOp0tEcZER+Xl5GDlyZNC66S4TjplEYigPoFy0INRXZ1arFVarNWi50WiMe4cxGAxhHx/Pl3jpOj94Kvu4I21Xik+qt2uoY07vf9+ZXb3PkU4AVbeARHMs693vrdQ7bWpJ1Nt2Zog+8GhOjk1ED7ne+0Is0r3WwONNaRdLds37Dx9He6cLBkHiRYOU/NGDFh71FT4dTjeEQiFt97lI0v2YSSSGcpWmpiYsX74cEydOhM2WPvN7JmLaP73xpErKVupQGe8MLelk2tSSrq+5e/4tFk/apGh9se0QAKDA6s7tfvIEEQQB+XkWtHc40Wl36V0ORSlnQ/l1112HU045BWeddRb69u2L/fv3449//CNqamrw0ksv6V1ekJ5M+6cnhnHKJZka0NV1Z/oJVZSZNvtCuUuXE4yzUZ7NjPYOJzweCR3OnI17GSVn/5XGjx+Pf/3rX3j22WfR3t6O0tJSnH/++fi///s/nH322XqXF1ImjJoziBN1B11RFLF//34cr++nc0XBOJJN6UCWZWzpCuWFVhfamMoTwmAwwGY1w+F0o661QO9yKAo5G8rvu+8+3HfffXqXEZd0HDVnECcKT+nRTocRdIZxSicHjtThRG0LzCYDCqwutDn0rih75OV5Q3lThw0NTe3o0zv2WeIodXI2lGcDPcM5QzhRfGZEeYJosl6XKN2s2+ydqm/saQOA9mqdq8kuZpMRJpMBHo+EV9/agl/edpHeJVEYDOVZINnhnAGcKPGS3X/OEE6ZYv3m7wAAZ44vx1cbv9K5muwiCALybRa0tjvwzzc+xy9umh403SSlD4byLKIOzz0J6AzhRKkVS0Bn2KZsIkkSNnxRCQA4a9wgfLVR54KykM1mRmdnB46daMK7H2/HDy7/nt4lUQgM5VkqloDOEE6UPhi6KZfs3FuNppZOFBZYMXpE+p0MnQ0EQUBZcSdONBfh//vnKlw9ZxKnnUxTDOU5gKGbiIjS0dpN3taVc88aDpMxxy8alERlRZ1ocfbBzr3VWLf5O0ybepreJZEGHgFERESki/VdJ3lecE7mXQI+k5iMMn589TkAgL88/5nO1VAoDOVERESUcm0dDmz88gAAYNpUhvJk+8VN02E2GbF+y36s6zq5ltILQzkRERGl3OoNe+F0eXDqKX0xalh/vcvJehWDSnHjD6cCAB5/5kPIMq/SlG4YyomIiCjlVqzeBQC4bOZYnniYIr/+6Szk51nw1Y4jvu1P6YOhnIiIiFLK7RbxydrdAIA5M8fpXE3u6F9WjJ9efyEA4JGn3kOn3aVzRaTGUE5EREQptemrg2hptaNvaSHOnjhU73Jyyq9uuwgD+5fgUFU9/vC3j/Uuh1QYyomIiCilVqzaCQC4ZNoYGDkVYkoVFdrw1EPXAAD+9vIabN9dpXNFpOCRQERERCnj8Yh49+NvAACXsXVFF5fNHIvvz54AUZRw6z0vo7G5Q++SCAzlRERElELrNu9HbX0bSnsV4KLzR+tdTs76w8PzMGRwKQ5XNeCWX78Et1vUu6Scx1BOREREKfP6O18AAK6eMwkWCy8srpfSXgVY8v/dhoJ8KzZ8UYnb730FTpdH77JyGkM5ERERpcTJuha8/+l2AMB1XVeYJP2cPnIgnn/6J7CYjVi+cgfm37EYLa12vcvKWQzlRERElBKvLN0Ej0fC5IlDMf70wXqXQwAumXYGXv/77SjIs2Dd5v2Y/oM/4IuvD+ldVk7i90ZERESUdG0dDjy/ZD0AQLYfwiWXz/fdJ8syOu12VB2tRlHFaXqVmLX27Nntt70VQyv6Y/Gzf8G0qafh3Zfvwm2/eRmHqxow5/pnUFbUiYG92mEyykHrU3IwlBMREVHSPb9kPZpaOjHi1H7wOHbgeOcov/s9Hg8czkMo0qm+bOZ0yajuGBV8R9V3vv+deEYFVr95L+57/C38670vUddWgIb2QhQWWmGzmr1XXVWtT4nHUE5ERERJdfxkM555fiUA4N6fX4LFf9+hc0UEhB5Bt7rq4MnzTpnY2uZAR6cLhQVWyPk6FJlD2FNORERESSPLMn7z30vRYXdh8sSh+MHl39O7JOqijKAH3tz2WvTpXYDCAisEARBFCS2tduw90Qf/encrZ2lJEo6UExERUdL8zwuf4dO1u2G1mPD0I/O8bRCU9gRBQEG+FXk2CzrtTnR0umB3mXHnA6/hvifexsUXnI4Lp4zC+DHlGHlqf+TnWfQuOeMxlBMREVFSvPDqejz2lw8AAI/99iqMGTVI54ooVgaDgMICG/LzLDCLJwBbBY6fbMayFV9j2YqvfeuZjSIsJhFWkwir2YOOlhM4pbwXLCbJ7/l4smhoDOVERESUUI3NHVj49Ht4bZn3QkF33jwDt/zoPJ2rop4wGAwYUNSBj97/L2zbeRQfrf4W23Yewedf7IMoGeAWjXCLRnQ4lUcUYdcxwGg0wGoxwWYzw2Q0AFX79fw10hpDOREREfWYxyNi286j+Nd7W/HWB9vQ3uGEIAg4/RQJG1e9jktWv+5bd+++/SgarDEbCKU9g8GAsyYMxVkThgIALrl8PqraRkIUJd/NI0lwtNcDphKIooROuwuddheMRgMM7kLsP1iDkcP66/uLpCGGciIiIorb3soTePRPy7H5q4Noa3f4lo8bXY5FD1yNhx9+MGg6PofjW059mEUMBgEGgxFms9G3zFXzJfoMuwoutwcOhxtOlweiKOFkSyGmXvkkxp42CJdfPB5TzhyGM8cPyaiedEmS0N7hhMstwmI2orgoLyHPy1BOREREcSvIt+LTtbsBAEaDhOI8J/oW2mGyn8TDD3/FUfEsojWFYrh/X4NBgM1qhs1qhiTJcLrcgKcZne587Np3HLv2HQcAmE1GDB9ahlPKSzFkcB/0Ksn3nmRqNaG1tQnb97XCYDTCIAgQBO9JqL7/wvtfSZYhyzJkGb7/KsugWi4FrNO9zPuz2+1Ba5sDre0OtLU70NZuR0ubHd/s2IdOhwhRMkCUBADeE5bL+8rYvvYvCdm+DOU9JMveK121trbG9XhRFNHe3o7W1lYYjcbID6CocLsmRzK3a1FRUVSzMijHXKb8+2bavsh6kyfdao3mmJMk70l6J06cCLmOAOCBu2bgtdeWoFUcCkGwodFZgsau3uKOjh3Iczv8HiOKIjzqZbIMjyhCFD3+y0OtH2Z5LOum5XN3bQtIRkAQ0qruTrsHR5pP8Vum9e8b6jnMRqB/wUn87X+fwqrP92HztsP4eucx1NS3Yve+I9i970jQ86Qf0e+n1lYHjh07FvFRgwYNgsEQfiZyQVbe4Sgux44dQ0VFhd5lEGW8lpYWFBcXR1yPxxxRYkRzzG3duhWTJ09OUUVE2auqqgqDBw8Ouw5DeQ9JkoTjx49HPcoXqLW1FRUVFaiqqooqkFB0uF2TI5nbNdpjSJIk7Nu3D2PGjMmIf99M2xdZb/KkW63RHHMejwdff/01+vfvH3GUryfa2towZswY7N69G0VFud1tzm3RLZu2RTQj5Wxf6SGDwRDxk080iouL0+KPdLbhdk0OPberwWBAeXm57nXEKpNqBVhvMmVSrSaTCWeffXbSX0dpAS0vL8+YbZMs3Bbdcm1bJO9jLxERERERRYWhnIiIiIhIZwzlOrNarXjkkUdgtVr1LiWrcLsmR7ps13SpIxqZVCvAepMpk2pNNW6bbtwW3XJtW/BETyIiIiIinXGknIiIiIhIZwzlREREREQ6YygnIiIiItIZQ7kO2tvbcffdd2PQoEGw2WyYOHEi3njjDb3LynhtbW1YsGABLrnkEpSVlUEQBCxcuFDvsjLeqlWrcMstt2D06NEoKChAeXk5vv/97+Orr76K+zl7cgzU1tbipptuQt++fZGfn4+pU6fis88+C1pv+vTpEAQh6HbppZemrN5jx47h7rvvxrRp09CrVy8IgoCXXnop5PorV67E1KlTkZ+fj759++Kmm25CbW1tWtabqO0bb61vv/025s+fjxEjRiAvLw9Dhw7Fj3/8Y+zfv19zfb23bSz1JnLfTWdr1qzR/D0FQcDmzZv1Li9pYnmv2rZtGy6++GIUFhaiV69euPrqq3Hw4MHUFpxE0W6Lm266SXM/GT16dOqLTiJePEgHV199NbZu3Yonn3wSo0aNwmuvvYb58+dDkiRcd911epeXsRoaGrB48WJMmDABV111FV544QW9S8oKf//739HQ0IBf/epXGDNmDOrq6vDHP/4RU6ZMwccff4yZM2fG/JzxHgNOpxMXXXQRmpub8cwzz6Bfv37461//iksvvRQrV67EtGnT/NYfNmwYXn31Vb9lvXr1Slm9lZWVePXVVzFx4kTMmTMHr7/+esh1165di8suuwyXX3453n33XdTW1uK3v/0tLrroInz55ZcxzT6QinqBxGzfeGv9/e9/jwEDBuDBBx/EsGHDUFVVhSeeeALf+973sHnzZpxxxhm+ddNh28ZSL5C4fTcTPPHEE5gxY4bfsrFjx+pUTfJF+161d+9eTJ8+HRMnTsS///1vOBwOPPzww7jgggvwzTffoKysLMWVJ14s79t5eXlYtWpV0LKsIlNKffDBBzIA+bXXXvNbPmvWLHnQoEGyx+PRqbLMJ0mSLEmSLMuyXFdXJwOQH3nkEX2LygI1NTVBy9ra2uT+/fvLF110UczP15Nj4K9//asMQN64caNvmdvtlseMGSNPnjzZb91p06bJZ5xxRsz1JbJeURR9/79161YZgPziiy9qrnv22WfLY8aMkd1ut2/Z559/LgOQ//a3v6VdvYnYvj2pVWu/rK6uls1ms3zrrbf6LU+HbRtLvYnad9Pd6tWrZQDy0qVL9S4lpaJ9r5o3b57ct29fuaWlxbfs8OHDstlslhcsWJCqcpMq2m1x4403ygUFBSmuLvXYvpJiy5YtQ2FhIebNm+e3/Oabb8bx48exZcsWnSrLfMrXWZRY/fr1C1pWWFiIMWPGoKqqKubn68kxsGzZMpx22mmYOnWqb5nJZML111+PL774AtXV1THXk8x6DYbo/sRWV1dj69at+MlPfgKTqfsLzHPPPRejRo3CsmXL0qreROlJrVr75aBBgzB48GC//TJdtm209VL2i+a9yuPxYPny5fjBD37gd3n5IUOGYMaMGTHtt+mM79v+GMpTbNeuXTj99NP93hwAYPz48b77idJdS0sLtm3bFvSVezR6cgzs2rXLt57WY7/99lu/5QcOHEBpaSlMJhOGDx+OBx98EHa7PWX1xvIa6ucMfJ1YXiOVf2N6un0TXevBgwdx5MgRv/0ynbetVr2KROy7meLOO++EyWRCcXExZs+ejQ0bNuhdku4OHDgAu90ecr+trKyEw+HQoTL92O12DBgwAEajEYMHD8Zdd92FxsZGvctKKPaUp1hDQwOGDRsWtLy0tNR3P1G6u/POO9HR0YEHH3ww5sf25BhoaGjwrRfpseeffz6uvfZajB49Gna7HStWrMBTTz2FDRs2YPXq1VGPCqfimFWeI9TvFstrpOpvTCK2byJr9Xg8uPXWW1FYWIhf//rXfq+hfs7A19Fr24aqF0jcvpvuSkpK8Ktf/QrTp09Hnz59UFlZiT/84Q+YPn06PvjgA8yePVvvEnUTab+VZRlNTU0YOHBgqkvTxYQJEzBhwgTfuQZr167Fn//8Z3z22WfYunUrCgsLda4wMRjKdRDuqxp+jUPp7r/+67/w6quv4n//939x5plnxvUcPTkGon3s7373O7/75syZg6FDh+Lee+/Fu+++i7lz50ZZbeqO2VDPFetrpKLeRG3fRNQqyzJuvfVWrF+/Hm+99RYqKiqifi49tm2kehO576azSZMmYdKkSb6fL7jgAsydOxfjxo3DggULcjqUK5gXvAI/uM6aNQuTJk3CNddcg+effz7o/kyVHR+3M0ifPn00R1OUr2C0PhUTpYtHH30Uv/vd7/D444/jrrvuius5enIM9PT4uf766wEgpunWUnHM9unTB4D2SGtjY2NMr6Hn35hYt28iapVlGbfddhuWLFmCl156Cd///veDXgNIn20bqd5Q4tl3M1GvXr1wxRVXYMeOHVnbrhONSPutIAhZOxtPtObOnYuCgoKsOiYYylNs3Lhx2LNnDzwej9/ynTt3AsjuaaAosz366KNYuHAhFi5ciAceeCDu5+nJMTBu3DjferE+Vi2Wr/9TccwqzxHqd4vlNdLhb0y027entSoB98UXX8QLL7zgC65q6bRto6k3kmxpXQlHlmUAuTUSHGj48OHIy8sLud+OGDECNptNh8rSiyzLWXVMZM9vkiHmzp2L9vZ2vPXWW37LX375ZQwaNAjnnHOOTpURhfbYY49h4cKFeOihh/DII4/06Ll6cgzMnTsXe/fu9ZvlwuPxYMmSJTjnnHMwaNCgsK/98ssvAwCmTJmSknqjVV5ejsmTJ2PJkiUQRdG3fPPmzdi3bx+uvvrqtKo3lFi3b09qlWUZt99+O1588UU899xzuPnmmzXXS5dtG229ocSz72aipqYmLF++HBMnTszp0GkymXDllVfi7bffRltbm2/50aNHsXr16pj222z15ptvorOzM7uOCZ2mYsxps2bNknv37i0vXrxYXrVqlXz77bfLAOQlS5boXVrG+/DDD+WlS5fK//znP2UA8rx58+SlS5fKS5culTs6OvQuLyM9/fTTMgD50ksvlTdt2hR0i0c0x8Att9wiG41G+fDhw75lDodDPuOMM+SKigr51VdflT/99FN57ty5sslkktesWeNbb926dfLs2bPlZ599Vv7kk0/k9957T77jjjtko9Eoz5w5028+7mTWK8uyb//7/e9/LwOQ77zzTt8ytdWrV8smk0meO3eu/Omnn8qvvvqqXFFRIY8dO1Z2OBxpVW8it2+8td51110yAPmWW24J2ie3bdvm9xrpsG2jrTfR+246mz9/vvzb3/5WXrp0qbx69Wp58eLF8mmnnSabTCb5008/1bu8pIrmvWrPnj1yYWGhfOGFF8offvih/Pbbb8tjx46VBw0aJNfW1ur8GyROpG1x+PBh+dxzz5X/53/+R/7www/lFStWyPfdd59ss9nkM844Q25vb9f7V0gYhnIdtLW1yb/85S/lAQMGyBaLRR4/frz8+uuv611WVhgyZIgMQPN26NAhvcvLSNOmTQu5TeP9XB/NMXDjjTdq/rudPHlSvuGGG+TS0lLZZrPJU6ZMCXoD379/vzxnzhy5vLxctlqtss1mk8eNGyc//vjjMYewntYby7b75JNP5ClTpsg2m00uLS2Vb7jhBs2LzuhdbyK3b7y1hjvWhwwZEvQ6em/baOtN9L6bzhYtWiRPnDhRLikpkY1Go1xWVibPnTtX/uKLL/QuLemifa/68ssv5YsuukjOz8+Xi4uL5auuukqurKzUr/AkiLQtGhsb5blz58pDhw6V8/LyZIvFIo8cOVJesGCB3NzcrHf5CSXIclfzFhERERER6YI95UREREREOmMoJyIiIiLSGUM5EREREZHOGMqJiIiIiHTGUE5EREREpDOGciIiIiIinTGUExERERHpjKGcUu7w4cMQBAE33XST3qUAAARBwPTp0xPyXAsXLoQgCFizZk1Cno+IiIhyA0M5ERERUQZQBrXUt/z8fAwaNAgXXXQRHn74YRw4cEDvMilOJr0LICIiIqLoDR8+HNdffz0AwOl0ora2Fl988QUee+wxPPHEE1iwYAEef/xxCIKgc6UUC4ZyIiIiogwyYsQILFy4MGj5+vXrccMNN2DRokUwGo147LHHUl8cxY3tK5QWvvrqK9x1110YO3YsSkpKkJeXh3HjxuHJJ5+E2+0OWn/o0KEYOnQoWlpacMcdd2DgwIEoKCjAhRdeiG3btgEATp48iRtvvBH9+vVDfn4+Zs+ejcrKypA1VFVV4dprr0WfPn1QUFCA6dOnY+PGjSHXnT9/PkpLS1FYWIhp06Zh3bp1idkYRGlizZo1EAQBCxcuxMaNGzFjxgwUFRWhrKwMv/jFL2C32wEAH330Ec477zwUFBSgf//++O1vfwtRFH3PE+5ci5deegmCIOCll15K0W9FlL0uuOACfPzxx7BarXjqqadQVVWld0kUA4ZySgvPP/88li1bhnHjxuFnP/sZbr31VsiyjPvvvx8/+tGPNB/jcrkwa9YsfP7557j22mvxH//xH/j8889x8cUXY+/evZgyZQr27duH66+/HhdffDE++eQTXHHFFX5hQdHU1ITzzjsPhw8fxk9/+lP84Ac/wKZNmzBjxoygIHHixAlMnToVb7zxBiZPnoxf/vKXKC0txaxZs7B58+ZkbB4iXW3ZsgUXXXQRSkpK8LOf/QynnHIK/v73v+P222/H0qVLcfXVV6OiogI/+9nP0KtXLzz11FN48skn9S6bKCeNGjUK1157LVwuF9555x29y6FYyEQpdujQIRmAfOONN/qWHT58WPZ4PH7rSZIk33LLLTIAecOGDX73DRkyRAYgz5s3T3a73b7lTz75pAxA7tWrl/zrX/9aliTJd98dd9whA5Dffvttv+cCIAOQf/KTn/itv2bNGlkQBHnEiBGyKIq+5TfeeKMMQP7d737n9zzPPfec77lWr14d83YhSjerV6/27dPvvPOOb7nL5ZLHjx8vC4Ig9+3bV/7iiy9897W2tsr9+vWT+/Tp4zs2H3nkkZDHxYsvvigDkF988cVk/zpEGU95/5w9e3bY9f7xj3/43tcoc3CknNLCkCFDYDQa/ZYJgoA777wTALBy5UrNx/3hD3+AydR9asR1110HAPB4PHjsscf8TnKZP38+AGD79u1Bz2M0GoNOipk2bRrmzJmDyspKXxuLy+XCv/71L/Tr1w+/+c1v/J7jtttuw6hRo6L+nYkyxfTp0/H973/f97PZbMY111wDWZZx5ZVX4uyzz/bdV1RUhCuuuAINDQ04duyYHuUS5bxBgwYBAOrr63WuhGLBUE5pweVy4U9/+hMmT56M4uJiGAwGCIKAM888EwBw/PjxoMf06tULQ4YM8Vs2cOBAAMDIkSNRUFCgeV91dXXQcw0ZMgQVFRVByy+44AIAwDfffAMA2LdvHxwOB8466yzYbDa/dQ0GA84999xofl2ijDJp0qSgZcrxNHHixJD3aR1rRJR8sizrXQLFgbOvUFq45ppr8P777/t64fr16wez2Yzm5mY888wzcDqdQY8pKSkJWqaMmhcXF4e8T+vE0X79+mnW1b9/fwBAS0uL338jrU+UTcIdT7Eea0SUfCdOnAAAlJWV6VwJxYKhnHS3detWvP/++5g9ezY++OADvzaWzZs345lnnkl6DbW1tZrLa2pqAHR/AFD+G2l9IupmMHi/lPV4PEH3KR90iShxlAkK1K1llP7YvkK6U64+dvnllwf1la9fvz4lNRw5ckRz6ijl9ZWv6E877TTYbDZ8+eWXcDgcfutKkhRyCkWiXNa7d28A2u0sX3/9darLIcpq3333Hf7973/DarVi7ty5epdDMWAoJ90pfeEbNmzwW/7tt99i0aJFKalBFEU8+OCDfn14a9euxYcffogRI0b4esUtFgt++MMfora2Fn/84x/9nuOFF17Ad999l5J6iTLJWWedBQB45ZVXIEmSb/mmTZvw6quv6lUWUdbZsGEDZs+eDafTifvvvx/l5eV6l0QxYPsK6W7y5MmYPHky/v3vf+PEiROYMmUKjh49ivfeew+XX3453nzzzaTXMH78eKxZswZTpkzBzJkzcfz4cbzxxhswm814/vnnfV+/A8CTTz6Jzz77DA899BA2bNiASZMmYc+ePfjwww9xySWX4JNPPkl6vUSZZMqUKZg6dSpWrVqFqVOn4sILL8SRI0fw3nvv4corr8SyZcv0LpEoo1RWVvqu6OlyuVBbW4stW7Zg165dMBqNeOihh/Dwww/rWyTFjKGcdGc0GrF8+XLcd999+Oijj7B161aMHDkSTz/9NC677LKUhPLevXvj/fffx7333ovnnnsODocDU6ZMwRNPPIHzzjvPb92BAwdi48aNWLBgAT7++GOsW7cOZ555Jj799FOsWrWKoZwogCAIeO+993DPPffggw8+wM6dOzFhwgS89957OH78OEM5UYwOHDiARx99FACQl5eHXr16YfTo0fiv//ov3HjjjRg+fLjOFVI8BJnz5hARERER6Yo95UREREREOmMoJyIiIiLSGUM5EREREZHOGMqJiIiIiHTGUE5EREREpDOGciIiIiIinTGUExERERHpjKGciIiIiEhnDOVERERERDpjKCciIiIi0hlDORERERGRzhjKiYiIiIh0xlBORERERKSz/x9kUIJGD8DMGAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "prior_samples = simulator.simulators[0].sample(1000)\n", "\n", "grid = bf.diagnostics.plots.pairs_samples(\n", " prior_samples, variable_keys=[\"lambd\", \"mu\", \"D\"]\n", ")" - ] + ], + "id": "9fbb5ca04e75e47b" }, { - "cell_type": "markdown", - "id": "6113f7e8", "metadata": {}, + "cell_type": "markdown", "source": [ "## Defining the Adapter\n", "\n", @@ -357,14 +316,14 @@ "- `summary_variables`: These are the variables that are compressed throgh a summary network and used for inferring the inference variables.\n", "\n", "Thus, what our approximators are learning is $p(\\text{inference variables} \\mid t(\\text{summary variables}))$, where $t$ is the summary network." - ] + ], + "id": "52520d4c6c04fe4c" }, { - "cell_type": "code", - "execution_count": 9, - "id": "rental-burner", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "adapter = (\n", " bf.adapters.Adapter()\n", @@ -377,58 +336,49 @@ " # to the unconstrained real space and can be back-transformed under the hood\n", " .apply(forward=lambda x: np.log1p(x), inverse=lambda x: np.expm1(x))\n", ")" - ] + ], + "id": "50d34e6dc1267048" }, { - "cell_type": "code", - "execution_count": 10, - "id": "15fc0d38", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(2, 14, 1)\n", - "(2, 5)\n" - ] - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "# Let's check out the new shapes\n", "adapted_sims = adapter(simulator.sample(2))\n", "print(adapted_sims[\"summary_variables\"].shape)\n", "print(adapted_sims[\"inference_variables\"].shape)" - ] + ], + "id": "c72020475ed04816" }, { - "cell_type": "markdown", - "id": "removed-discrimination", "metadata": {}, + "cell_type": "markdown", "source": [ "## Defining the Neural Approximator \n", "\n", "We can now proceed to define our `BayesFlow` neural architecture, that is, combine a summary network with an inference network." - ] + ], + "id": "33850f0bff73f125" }, { - "cell_type": "markdown", - "id": "traditional-colors", "metadata": {}, + "cell_type": "markdown", "source": [ "### Summary Network \n", "\n", "Since our simulator outputs 3D tensors of shape ``(batch_size, T = 14, 1)``, we need to reduce this three-dimensional tensor into a two-dimensional tensor of shape ``(batch_size, summary_dim)``. Our model outputs are actually so simple that we could have just removed the trailing dimension of the raw outputs and simply fed the data directly to the inference network.\n", "\n", "However, we demonstrate the use of a simple Gated Recurrent Unit (GRU) summary network. Any `keras` model can interact with `BayesFlow` by inherting from `SummaryNetwork` which accepts an addition `stage` argument indicating the mode the network is currently operating in (i.e., `training` vs. `inference`)." - ] + ], + "id": "7ee78608e39b07c5" }, { - "cell_type": "code", - "execution_count": 11, - "id": "gross-screen", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "class GRU(bf.networks.SummaryNetwork):\n", " def __init__(self, **kwargs):\n", @@ -443,52 +393,46 @@ " summary = self.gru(time_series, training=kwargs.get(\"stage\") == \"training\")\n", " summary = self.summary_stats(summary)\n", " return summary" - ] + ], + "id": "e34389285522c53f" }, { - "cell_type": "code", - "execution_count": 12, - "id": "e6c6e2af", "metadata": {}, + "cell_type": "code", "outputs": [], - "source": [ - "summary_net = GRU()" - ] + "execution_count": null, + "source": "summary_net = GRU()", + "id": "9169f1e899bf874f" }, { - "cell_type": "markdown", - "id": "812336e1", "metadata": {}, - "source": [ - "### Inference Network" - ] + "cell_type": "markdown", + "source": "### Inference Network", + "id": "fddf7a519ef6ccfa" }, { - "cell_type": "markdown", - "id": "fifteen-contract", "metadata": {}, - "source": [ - "As inference network we choose a flow matching architecture with some dropout to robustify the inference. Dropout is primarily important when learning from a (small) offline dataset. See below for details." - ] + "cell_type": "markdown", + "source": "As inference network we choose a flow matching architecture with some dropout to robustify the inference. Dropout is primarily important when learning from a (small) offline dataset. See below for details.", + "id": "43da1858d6d994b9" }, { - "cell_type": "code", - "execution_count": 13, - "id": "dbdbdab0", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "inference_net = bf.networks.CouplingFlow(\n", " subnet_kwargs={\"residual\": True, \"dropout\": 0.1, \"widths\": (128, 128, 128)}\n", ")" - ] + ], + "id": "bcbc90940a36139f" }, { - "cell_type": "code", - "execution_count": 14, - "id": "8b4c43e7", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "workflow = bf.BasicWorkflow(\n", " simulator=simulator,\n", @@ -497,407 +441,214 @@ " summary_network=summary_net,\n", " inference_variables=[\"lambd\", \"mu\", \"D\", \"I0\", \"psi\"]\n", ")" - ] + ], + "id": "5ab78d30046fd2a" }, { - "cell_type": "markdown", - "id": "welsh-eclipse", "metadata": {}, + "cell_type": "markdown", "source": [ "## Training \n", "\n", "Ready to train! Since our simulator is pretty fast, we can safely go with online training. Let's glean the time taken for a batch of $32$ simulations." - ] + ], + "id": "9c3456ee103b9c62" }, { - "cell_type": "code", - "execution_count": 15, - "id": "546f6152", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 4.82 ms, sys: 733 μs, total: 5.55 ms\n", - "Wall time: 5.06 ms\n" - ] - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "%%time\n", "_ = workflow.simulate(32)" - ] + ], + "id": "c550c08b9efcb0ba" }, { - "cell_type": "markdown", - "id": "b359ddd9", "metadata": {}, - "source": [ - "Not too bad! However, for the purpose of illustration, we will go with offline training using a fixed data set of simulations." - ] + "cell_type": "markdown", + "source": "Not too bad! However, for the purpose of illustration, we will go with offline training using a fixed data set of simulations.", + "id": "33aca301a75c32a2" }, { - "cell_type": "markdown", - "id": "endless-teens", "metadata": {}, - "source": [ - "### Generating Offline Data " - ] + "cell_type": "markdown", + "source": "### Generating Offline Data ", + "id": "f4fae304214cc745" }, { - "cell_type": "code", - "execution_count": 16, - "id": "dd328279", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "training_data = workflow.simulate(5000)\n", "validation_data = workflow.simulate(300)" - ] + ], + "id": "7731d6e78304a722" }, { - "cell_type": "markdown", - "id": "c2feeb0c", "metadata": {}, - "source": [ - "We are now ready to train. If not provided, the default settings use $100$ epochs with a batch size of $32$." - ] + "cell_type": "markdown", + "source": "We are now ready to train. If not provided, the default settings use $100$ epochs with a batch size of $32$.", + "id": "21880ce8a1643c2e" }, { - "cell_type": "code", - "execution_count": null, - "id": "regional-airfare", "metadata": {}, + "cell_type": "code", "outputs": [], - "source": [ - "history = workflow.fit_offline(training_data, epochs=300, batch_size=64, validation_data=validation_data)" - ] + "execution_count": null, + "source": "history = workflow.fit_offline(training_data, epochs=300, batch_size=64, validation_data=validation_data)", + "id": "edaf144e3e5a8c81" }, { - "cell_type": "markdown", - "id": "practical-cardiff", "metadata": {}, + "cell_type": "markdown", "source": [ "### Inspecting the Loss \n", "\n", "Following our online simulation-based training, we can quickly visualize the loss trajectory using the `plots.loss` function from the `diagnostics` module." - ] + ], + "id": "7a4859372b0df84" }, { - "cell_type": "code", - "execution_count": 18, - "id": "peaceful-conviction", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = bf.diagnostics.plots.loss(history)" - ] + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "f = bf.diagnostics.plots.loss(history)", + "id": "8b4d998d830cd24" }, { - "cell_type": "markdown", - "id": "optical-advice", "metadata": {}, - "source": [ - "Great, it seems that our approximator has converged! Before we get too excited and throw our networks at real data, we need to make sure that they meet our expectations in silico, that is, given the small world of simulations the networks have seen during training." - ] + "cell_type": "markdown", + "source": "Great, it seems that our approximator has converged! Before we get too excited and throw our networks at real data, we need to make sure that they meet our expectations in silico, that is, given the small world of simulations the networks have seen during training.", + "id": "66715891c31e66f9" }, { - "cell_type": "markdown", - "id": "parliamentary-indiana", "metadata": {}, + "cell_type": "markdown", "source": [ "## Validation Phase\n", "\n", "When it comes to validating posterior inference, we can either deploy manual diagnostics from the `diagnostics` module, or use the automated functions from the `BasicWorkflow` object. First, we demonstrate manual validation. " - ] + ], + "id": "f750fb25272c4f17" }, { - "cell_type": "code", - "execution_count": 19, - "id": "catholic-depth", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "# Set the number of posterior draws you want to get\n", + "num_datasets = 300\n", "num_samples = 1000\n", "\n", "# Simulate 300 scenarios and extract time series from dict\n", - "test_sims = workflow.simulate(300)\n", + "test_sims = workflow.simulate(num_datasets)\n", "time_series = test_sims.pop(\"cases\")\n", "\n", "# Obtain num_samples posterior samples per scenario\n", - "samples = workflow.sample(conditions={\"cases\": time_series}, num_samples=num_samples)" - ] + "samples = workflow.sample(conditions={\"cases\": time_series}, num_datasets=num_datasets, num_samples=num_samples)" + ], + "id": "e8eccd7f41072001" }, { - "cell_type": "markdown", - "id": "binary-florida", "metadata": {}, + "cell_type": "markdown", "source": [ "### Simulation-Based Calibration - Rank Histograms\n", "\n", "As a further small world (i.e., before real data) sanity check, we can also test the calibration of the amortizer through simulation-based calibration (SBC). See the corresponding paper for more details (https://arxiv.org/pdf/1804.06788.pdf). Accordingly, we expect to observe approximately uniform rank statistic histograms. In the present case, this is indeed what we get:" - ] + ], + "id": "e696cb368f2072ae" }, { - "cell_type": "code", - "execution_count": 20, - "id": "olive-nickname", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = bf.diagnostics.plots.calibration_histogram(samples, test_sims)" - ] + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "f = bf.diagnostics.plots.calibration_histogram(samples, test_sims)", + "id": "3895cc36a2f3e1bd" }, { - "cell_type": "markdown", - "id": "viral-space", "metadata": {}, + "cell_type": "markdown", "source": [ "### Simulation-Based Calibration - Rank ECDF\n", "\n", "For models with many parameters, inspecting many histograms can become unwieldly. Moreover, the `num_bins` hyperparameter for the construction of SBC rank histograms can be hard to choose. An alternative diagnostic approach for calibration is through empirical cumulative distribution functions (ECDF) of rank statistics. You can read more about this approach in the corresponding paper (https://arxiv.org/abs/2103.10522).\n", "\n", "In order to inspect the ECDFs of marginal distributions, we will simulate $300$ new pairs of simulated data and generating parameters $(\\boldsymbol{x}, \\boldsymbol{\\theta})$ and use the function `plots.calibration_ecdf` from the `diagnostics` module: " - ] + ], + "id": "b73fd0c6f8487943" }, { - "cell_type": "code", - "execution_count": 21, - "id": "further-dynamics", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = bf.diagnostics.plots.calibration_ecdf(samples, test_sims, difference=True)" - ] + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "f = bf.diagnostics.plots.calibration_ecdf(samples, test_sims, difference=True)", + "id": "c9c77ead431320cd" }, { - "cell_type": "markdown", - "id": "rural-safety", "metadata": {}, + "cell_type": "markdown", "source": [ "### Inferential Adequacy (Global)\n", "\n", "Depending on the application, it might be interesting to see how well summaries of the full posterior (e.g., means, medians) recover the assumed true parameter values. We can test this in silico via the `plots.recovery` function in the `diagnostics` module. For instance, we can compare how well posterior means recover the true parameter (i.e., posterior z-score, https://betanalpha.github.io/assets/case_studies/principled_bayesian_workflow.html):" - ] + ], + "id": "b9da20e3a66fd589" }, { - "cell_type": "code", - "execution_count": 22, - "id": "educational-department", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = bf.diagnostics.plots.recovery(samples, test_sims)" - ] + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "f = bf.diagnostics.plots.recovery(samples, test_sims)", + "id": "81416d87265a1c0a" }, { - "cell_type": "markdown", - "id": "e64f683b", "metadata": {}, - "source": [ - "Interestingly, it seems that the parameters $\\theta_1 = \\mu$ and $\\theta_2 = D$ have not been learned properly as they are estimated roughly the same for every simulated datset used during testing. For some models, this might indicate that the the network training had partially failed; and we would have to train longer or adjust the network architecture. For this specific model, however, the reason is different: From the provided observables, these parameters are actually not identified so cannot be learned consistently, no matter the kind of approximator we would use. " - ] + "cell_type": "markdown", + "source": "Interestingly, it seems that the parameters $\\theta_1 = \\mu$ and $\\theta_2 = D$ have not been learned properly as they are estimated roughly the same for every simulated datset used during testing. For some models, this might indicate that the the network training had partially failed; and we would have to train longer or adjust the network architecture. For this specific model, however, the reason is different: From the provided observables, these parameters are actually not identified so cannot be learned consistently, no matter the kind of approximator we would use. ", + "id": "1a680fb4138ae6b3" }, { - "cell_type": "markdown", - "id": "fca49ff1", "metadata": {}, + "cell_type": "markdown", "source": [ "### Automatic Diagnostics\n", "\n", "The basic workflow object wraps together a bunch of useful functions that can be called automatically. For instance, we can easily obtain numerical error estimates for the big three: normalized roor mean square error (NRMSE), posterior contraction, and calibration, for $300$ new data sets:" - ] + ], + "id": "a9414bace2440ce9" }, { - "cell_type": "code", - "execution_count": 23, - "id": "5c588463", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lambdmuDI0psi
NRMSE0.0672250.2341220.2456850.1684300.168900
Posterior Contraction0.9467750.2119030.0872450.4187740.899313
Calibration Error0.0242980.0375440.0226320.0163160.011404
\n", - "
" - ], - "text/plain": [ - " lambd mu D I0 psi\n", - "NRMSE 0.067225 0.234122 0.245685 0.168430 0.168900\n", - "Posterior Contraction 0.946775 0.211903 0.087245 0.418774 0.899313\n", - "Calibration Error 0.024298 0.037544 0.022632 0.016316 0.011404" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "metrics = workflow.compute_diagnostics(test_data=300)\n", "metrics" - ] + ], + "id": "a80e870b7eac9f29" }, { - "cell_type": "markdown", - "id": "4407a54d", "metadata": {}, - "source": [ - "We can also obtain the full set of graphical diagnostics:" - ] + "cell_type": "markdown", + "source": "We can also obtain the full set of graphical diagnostics:", + "id": "a4e86c702256c1d3" }, { - "cell_type": "code", - "execution_count": 24, - "id": "6fac0759", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":10: RuntimeWarning: overflow encountered in expm1\n", - "/opt/miniconda3/envs/bayesflow/lib/python3.11/site-packages/numpy/core/_methods.py:173: RuntimeWarning: invalid value encountered in subtract\n", - " x = asanyarray(arr - arrmean)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "figures = workflow.plot_diagnostics(\n", " test_data=300,\n", @@ -906,168 +657,24 @@ " calibration_ecdf_kwargs={\"figsize\": (15, 3), \"legend_fontsize\": 8, \"difference\": True, \"label_fontsize\": 12},\n", " z_score_contraction_kwargs={\"figsize\": (15, 3), \"label_fontsize\": 12} \n", ")" - ] + ], + "id": "1e3e4fc643dd226f" }, { - "cell_type": "markdown", - "id": "occupational-professor", "metadata": {}, + "cell_type": "markdown", "source": [ "## Inference Phase \n", "\n", "We can now move on to using real data. This is easy, and since we are using an adapter, the same transformations applied during training will be applied during the inference phase." - ] + ], + "id": "3637102a2416b6ca" }, { - "cell_type": "code", - "execution_count": 25, - "id": "architectural-steering", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lambdmuDI0psi
00.3899770.0993446.42384122.2594974.388555
10.3331740.0963197.38232143.24779113.968859
20.3744350.1082608.57152821.9242534.500786
30.4142560.1646388.25354425.9436829.791203
40.4085970.1284076.19328733.7447245.930839
..................
9950.4269010.1373567.52463619.4492805.443706
9960.3885060.1454158.96556825.82576211.506467
9970.4581620.1478179.5684769.22111012.137198
9980.3594140.1419699.41167639.5956992.017844
9990.3925890.1613387.94560730.8713841.356222
\n", - "

1000 rows × 5 columns

\n", - "
" - ], - "text/plain": [ - " lambd mu D I0 psi\n", - "0 0.389977 0.099344 6.423841 22.259497 4.388555\n", - "1 0.333174 0.096319 7.382321 43.247791 13.968859\n", - "2 0.374435 0.108260 8.571528 21.924253 4.500786\n", - "3 0.414256 0.164638 8.253544 25.943682 9.791203\n", - "4 0.408597 0.128407 6.193287 33.744724 5.930839\n", - ".. ... ... ... ... ...\n", - "995 0.426901 0.137356 7.524636 19.449280 5.443706\n", - "996 0.388506 0.145415 8.965568 25.825762 11.506467\n", - "997 0.458162 0.147817 9.568476 9.221110 12.137198\n", - "998 0.359414 0.141969 9.411676 39.595699 2.017844\n", - "999 0.392589 0.161338 7.945607 30.871384 1.356222\n", - "\n", - "[1000 rows x 5 columns]" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "# Our real-data loader returns the time series as a 1D array\n", "obs_cases = load_data()\n", @@ -1079,26 +686,26 @@ "samples = workflow.samples_to_data_frame(samples)\n", "\n", "samples" - ] + ], + "id": "aef0e4c163e0ea6a" }, { - "cell_type": "markdown", - "id": "wicked-mouth", "metadata": {}, + "cell_type": "markdown", "source": [ "### Posterior Retrodictive Checks \n", "\n", "These are also called posterior predictive checks, but here we want to explicitly highlight the fact that we are not predicting future data but testing the generative performance or re-simulation performance of the model. In other words, we want to test how well the simulator can reproduce the actually observed data given the parameter posterior $p(\\theta \\mid x_{1:T})$. \n", "\n", "Here, we will create a custom function which plots the observed data and then overlays draws from the posterior predictive." - ] + ], + "id": "2b5ba3061de00015" }, { - "cell_type": "code", - "execution_count": 26, - "id": "aggregate-share", "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "def plot_ppc(samples, obs_cases, logscale=True, color=\"#132a70\", figsize=(12, 6), font_size=18):\n", " \"\"\"\n", @@ -1142,46 +749,32 @@ " ax.set_yscale(\"log\")\n", " ax.legend(fontsize=font_size)\n", " return f" - ] + ], + "id": "25c5c5ad1a3e0071" }, { - "cell_type": "markdown", - "id": "romance-doctrine", "metadata": {}, - "source": [ - "We can now go on and plot the re-simulations:" - ] + "cell_type": "markdown", + "source": "We can now go on and plot the re-simulations:", + "id": "9b317bb5eaa5a634" }, { - "cell_type": "code", - "execution_count": 27, - "id": "native-suspension", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABAkAAAIhCAYAAAAsKOPgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZhkCV3n/75PnC32LffMWnup7qahQdq2WUakQfkBAiqICirOvcjo3B510FFw5vc4zjz8ZnFmvOrcchvnUXAZhlUYERQaBJG1m+5ma2yga8stMvaIs6/3j8jMquyu7qrKyj2/r+fhoSsiMuNk5cmsiM/5LkqapilCCCGEEEIIIYQ49DK7fQBCCCGEEEIIIYTYGyQkEEIIIYQQQgghBCAhgRBCCCGEEEIIIVZJSCCEEEIIIYQQQghAQgIhhBBCCCGEEEKskpBACCGEEEIIIYQQgIQEQgghhBBCCCGEWCUhgRBCCCGEEEIIIQAJCXZcmqYMBgPSNN3tQxFCCCGEEEIIITaQkGCHDYdDKpUKw+Fwtw/lKdm2jW3bu30YYpfJeSBAzgNxkZwLAuQ8ECNyHgiQ8+CgkpBgh5w+fZqnPe1p3HXXXbt9KEIIIYQQQgghxGVJSLBD7r33Xr7+9a/zxS9+cbcPRQghhBBCCCGEuCwJCYQQQgghhBBCCAFISCCEEEIIIYQQQohVEhIIIYQQQgghhBACkJBACCGEEEIIIYQQqyQkEEIIIYQQQgghBCAhgRBCCCGEEEIIIVZJSCCEEEIIIYQQQghAQgIhhBBCCCGEEEKskpBACCGEEEIIIYQQgIQEQgghhBBCCCGEWCUhgRBCCCGEEEIIIQAJCYQQQgghhBBCCLFKQgIhhBBCCCGEEEIAEhIIIYQQQgghhBBilYQEQgghhBBCCCGEACQkEEIIIYQQQgghxCoJCYQQQgghhBBCCAFISCCEEEIIIYQQQmxKGMZ4frjbh7GltN0+ACGEEEIIIYQQYr9I0xTHDbAdn6Hlo2sZjh0Z2+3D2jISEgghhBBCCCGEEFcQhjGOG9AfurhuAEoKioKKstuHtqUkJBBCCCGEEEIIIS7j8VUDQRih6yqFgomqZnC9YLcPcctJSCCEEEIIIYQQQlziclUDpqlTzed3+9C2nYQEQgghhBBCCCEOvStVDRwWEhIIIYQQQgghhDi0DnPVwOVISCCEEEIIIYQQ4lCRqoEnJyGBEEIIIYQQQohDQaoGrkxCAiGEEEIIIYQQB1aaprheiGV7UjVwFSQkEEIIIYQQQghx4EjVwOZISCCEEEIIIYQQ4kCQqoHrJyGBEEIIIYQQQoh9ba1qYDB0caRq4LpISCCEEEIIIYQQYt/ZzaqBKIxZaQ/59tkmYRxz4sj4tj7fTpKQYIecPn2a06dPE8fxbh+KEEIIIYQQQuxbu1Y1kKZ0+g5LjT5nLjTpdh0Glsv0RJU0TVEUZXuff4dISLBD7r33Xu69914GgwGVSmW3D0cIIYQQQggh9o3drBpw3YDllT7n59sstQa4bkihYDI1WUbX1W197t0gIYEQQgghhBBCiD1pt6oG4iim2bZYWO5yfr5D33LRNZVaJc/0eHlbn3u3SUgghBBCCCGEEGLP2M2qgX7fYWllwNkLLZqdIXGSUi3lODZXJ3NA2gmuREICIYQQQgghhBC7LgxjXC+gP9jZqgE/CFleGXB+vs3iSh/HCcjnDCbHy5gHsJ3gSiQkEEIIIYQQQgixK3araiBNEpodi4WlHufn2/SGLmpGoVrJMzlW4nDUDFyehARCCCGEEEIIIXbUblUNDIcey80+j51v0WoPCaOEcjHLkZkaauYwRwMXSUgghBBCCCGEEGLb7VbVQBBErLQGnF/ssrDUxbJ9clmd8XoR05C3xI8nfyNCCCGEEEIIIbbNblQNpElCu2uz1Ojx2IUW/b6LoihUKjnG68VD3U5wJRISCCGEEEIIIYTYUrtVNWA7PsuNHmfnO6y0Bnh+RKmQZXa6irbNmxEOCgkJhBBCCCGEEEJsid2oGojCmJX2kPnFLhcWOwxsj6yhUS3nyWX1bXveg0pCAiGEEEIIIYQQm7YrVQNpSqfvsLTc48x8i07HJgWqlRzH58aQGYSbJyGBEEIIIYQQQohrkqYpfhARBCGdnr9jVQOuG7C80ufcfJvl5gDXDynmTWamquiatBNsBQkJhBBCCCGEEEJcURTF+EGEH4RYdsCgPyCME0ql4rZWDcRRzErLYmG5y4WFDn3bQ1cz1Cp5pifK2/Kch5mEBEIIIYQQQgghniBJEoIwxvcjHNfH9ULCMCYlRddVdFMjr6rk8ua2PH+v77C8MuDM+SatrkWSpFRKOY7N1sgo0k+wXSQkEEIIIYQQQggBQBBE+GGE5wXYbkDgx8RJgqpmMAyVUjaLsvoG3XXiLX9+zw9pNAecn2+zuNLHcQLyOYOp8TKGrm7584knkpBACCGEEEIIIQ6pOE5WZwtEWLaHF0RE0ejNv2Fo5PPGtq4sBEjihFbHYmG5x7kLbXqWi5ZRqFbyTI6VkJqBnSUhgRBCCCGEEEIcEmmaEoQxQRBhOz6OFxIGEWmaoukqhq5S2Kb2gccbDj2WVvqcudCi1RoSxgnlYpajMzVUWU+wayQkEEIIIYQQQogDLIpiPH80cNB2AoIgIoxiMqqCoWsUiyaZzM5sBgiCaNROsNhhcbmHZfvksjrjY0VMQ96e7gXyXRBCCCGEEEKIAyRJ1loIYhzXx3FDwiiG1YGDZlajoO5MtQBAmiS0uzaLjR5nLrTo9V0yikK1kmO8XpR2gj1GQgIhhBBCCCGE2OfWBg667mjgYBiMBg5qWgZD18jl9PWBgzvFtn2WV3qcme/QbA7ww5hSwWRupoYm7QR7loQEQgghhBBCCLHPxHGC54erAwd9/HB14KCiYOjqjgwcvJwojGm0Bswvdplf6jKwPLKmRrWSJ5fVd/x4xLWTkEAIIYQQQggh9rg0Tde3EDhugOOOZgsAOz5w8DIHR6dns9QYDSHsdG0AKpUcx4+MIUUD+4uEBEIIIYQQQgixB4VhjB+MBg5atk8QRERxgqpmMAyVUim7YwMHL8dxfFodi8WmTaM5wPVDSnmTmakqurZ7xyWuj4QEQgghhBBCCLEHrA0c9P3RekLPH20hUJQUTdPI5nQ0Vd2140uThG7fodWxWVjustLs4LghpmFSreSZnijv2rGJrSMhgRBCCCGEEELsgjRNCcKYIIhwvdHAwcCPSNJ0VwcOXioIItodm1ZnwPxSj97AwfNjsqZKztSoVQsY+i61OYhtISGBEEIIIYQQQuyQKLq0hWA0VyCMYpSMgmloFIvmrrYQwGgrQbMzZKU5ZHG5x9D2iJOUfN6gVsmTNfXVr8Xf1eMU20NCAiGEEEIIIYTYJpcOHLQdH9cLCcOYlBRdVzFMjUJhd6/EP76NoNWxsB0fNZOhWMgyM1VB24VNCWJ3SEgghBBCCCGEEFsoDGO8IMT3QyzHJwzijQMHs9ldbSGAp24jKBZMxmpF2UpwSElIIIQQQgghhBDXIY6TjdUC/qhaQFFA1zVyOQN1D1yJv9o2AnG4SUgghBBCCCGEENcoCCL81VDA8ULCYDRwUNdVDF0lnzN2vVpA2gjEZkhIIIQQQgghhBBXIQgiPD/EdnxsNyCKEpQMGPreGDi4dozSRiCuh4QEQgghhBBCCPEk1ioGLNvDdgPCMEZVM2RNjUJ+b6z+kzYCsZUkJBBCCCGEEEKIS4RhjOeHezYYkDYCsZ0kJBBCCCGEEEIceuvBgOPjOAFBGKGqGUxjbwQD0kYgdoqEBEIIIYQQQohDaS0YsB0fezUYyKgKWUMnn8/v9uFJG4HYFRISCCGEEEIIIQ6NKIpx/RDbHgUDYRShZEbBQC6X29WNBGttBO2uzcJSl6a0EexpfhCxsNQlSVPSNN31bRZbRUICIYQQQgghxIG2l4MBaSPYX5IkZaU15Pxim7MX2jSaQyrl7G4f1paSkEAIIYQQQghx4FwaDDhugB+MWglMQ9v1YEDaCPafXt9lfrnDmXMt2l2bKE7I50yyWRXS3T66rSUhgRBCCCGEEOJAWAsGXDfAsn38YLViwNSolHcvGJA2gv3J8yMWlrucudBiuTHA9QIMQ6dSyWMY2upj/F0+yq0nIYEQQgghhBBi34rjBNcLcVwfy/YJwhgUdj0YkDaC/SlOUpZX+pxf7HL+Qouh45NRFIrFLLVqHg7I3IGnIiGBEEIIIYQQYl/ZEAw4AUEQrQcD5Wx214KB9TaClQGLjb60EewjnZ7D/FKXx8436XYd4jShkDOZGq+QUQ9+MHApCQmEEEIIIYQQe95aMOB6PkN7NRggxTR1yqXdCQakjWB/c9yA+eUeZ8+3WG4N8b0AM2tQrxXQdHW3D2/XSEgghBBCCCGE2JPiOMHzRxUDa8GAoqQYxu4EA2mS0B969Icu3Z7NUqMvbQT7TBinLK/0OD/f4fxCB9vxUDMqpVKWsUPSTnAlEhIIIYQQQggh9oy1YMD1AgaWTxhEsEvBQBTGDCyXXt+l3bVptPtYlo/nhyiKQi4nbQT7QQq0Oxbziz0eu7BCr++SpCnFvMnURPXQtRNciYQEV+n8+fP863/9r7n//vtZXFwkSRJOnDjBj/zIj/DmN7+ZUqm024cohBBCCCHEvpQka60EAUPbJ/BHwYCuaxSLJpnMzpTsB0FEb+AwGLo02xYr7QGOHeCFEVomQy5rUCnlmJooI28r9z7L8VlY6vHYhSbNloUfhORMg7Fa8VC3E1yJhARXqdFoMD8/zw/90A9x9OhRVFXl/vvv521vexsf/OAH+exnP4uuS4IohBBCCCHE1VgLBjw/ZGB5+F4IChjGzgUDrhvQH7j0hy6NZp9218Z2AqI4QVMV8jmTeq2Aacjbpv0iiGIWG30uLLS5sNjDdnx0NTNqJ6gVpJ3gKsjZfpXuuusu/u7v/m7DbT/zMz/DqVOn+JVf+RU++tGP8vKXv3x3Dk4IIYQQQoh9IEkSPD9abSXYGAyUStntDQbSFNsJ1ucJNFpDuj0b2/FJUjC0DIW8yeRECUOTq8z7SQqstIfML3Y5c77JYOiRpuloeORkBUWGRFwTCQmu04kTJwDodru7eyBCCCGEEELsQZcGA0Pbw/ciUtJtDwbSJGFo+fQGDr2Bw1Kjz8DycN2AJB2tS8znDGZnamjyJnJfGlge80tdzpxv0epYBGFELmcyXi+iStCzaRISXCPP87AsC9d1eeihh/jVX/1VstksL3jBC3b70IQQQgghhNgTniwY2M4ZA3EU07c8+gOXTtei0RwysD08L0RRIGvqFPIGY7UCGSk537f8IGKx0efcfJuF5R6O62PoKqVibtQWsoPf2zRNGHTmiSOXBx54gDvvvHPH5mdsp30VEjiOwyc/+UkeeOABvvSlL/HAAw9w/vx5AP7tv/23/Pqv//oVP8dwOOS//bf/xnvf+17OnDmDqqqcOnWKH/uxH+Pnfu7nMAzjKT/+j/7oj/i5n/u59T/fdtttfOADH+Do0aPX9bUJIYQQQgixnyVJgh+sBgOWj+eFJGmCYejbEgyEQUR/6NIfuLQ7FsutAbbj4wcRiqJQyBmUCyaTYyVZSbjPJSmstAZcWOhw5kKLoeWhKArFgsnMZHVX2gmW5x/haw98mG57kTSJec1r/ppbb72Vt771rbzoRS/a8ePZSvsqJPjCF75wXX3/586d44UvfCFnz54FIJ/P4/s+999/P/fffz9//ud/zn333UetVnvSz/GDP/iD3HrrrfT7fT7zmc/w8Y9/nMFgsOljEkIIIYQQYr9K03R9XeHQ8vH9iCRJ0A2NQsFEVbcuGPD8kMHApTdwabYHtNoWluMTRgmZDBTzJrVKHtPUZfPAAdEfuswvdXnsXIt21yKMYgo5k8mxMhlt967YL88/whc+8aeEgYeq51BVlVKpxJe//GV+5md+hj/4gz/Y10HBvgoJAGq1Gs9+9rPX//fmN7+Z5eXlK35cHMe88pWv5OzZs8zMzPCOd7yD7/3e7yVJEt797nfzpje9iQcffJAf//Ef56//+q+f9PMcOXKEI0eOAPCa17yGd7/73bz2ta/lox/9KN/7vd+7ZV+nEEIIIYQQe1EYxtiOTxhGtHurFQOrwUA+b2xZMOA4Ab2BM9o8sNKn03OwXZ8oTjA0lXzOZGKshCGr7A4UL4hYXOpx5kKLpZU+rhtgGBqVcg7D2P1tcmma8LUHPkwYeOQKVaI4QVEgl8sxNzfHwsIC/+k//Sde+MIX7tvWg30VEnz3d383nU5nw21vfetbr+pj/+RP/oSvfOUrALz3ve/luc99LgCZTIYf/dEfJUkSXv/61/PhD3+Y++67jxe/+MVX9Xlf/epXk81m+eM//mMJCYQQQgghxIGSJAlhlBCEEUEQ4TgBQRgzHA4BKJWLWxMMpClDy6c/dOj1HJaaA/oDB9sNSFMwDZV83mBmsoK2hdUJYm+Ik5SV5oDzCx3OzbcZ2B4ZRaFYNKlVqntqbWGneZ5BdxkjWyAlIYlDVG0UXiiKQr1e5x//8R958MEHufPOO3f5aDdnX4UEqrr5lPDtb387APfcc896QHCpH/uxH+Pf/Jt/w5kzZ3jHO95x1SFBFEVEUSTbDYQQQgghxL4XRTFBGBOGMa4X4PohURgTxaOSfk1T0XWVUimLgkIuZ27qeZI4YWB56+sIl1cGDGwPxw0AyBoahbxBrVpAlYECB1a35zC/PGon6HRt4jQhnzOZGi+T2aNhkO9axFFAEkeEoYeiqOSLY+v3Z7NZut0urVZrF4/y+uyrkGCzHMfhH/7hHwB42ctedtnHKIrCS1/6Un7v936Pv/3bv33C/Y1Gg6mpqSfc/gd/8AdEUcTdd9+9tQcthBBCCCHENkrTlCCM16sEXDfAD2LCMAJFIZNR0LQM2ZyO9riLdVEYXNNzRWHMwHLp9V3aXZtGu49l+XhBhALkcgaFnMF4rShDBg841w2ZX+5y9kKb5eYA1wvImjq1Wh5d3/tvT81ckSSJiWMPRcmgKAppmq7f73kehmEwPj6+i0d5ffb+d2ELPPLIIyRJAsDTn/70J33c2n3Ly8t0Oh3q9fr6fW95y1v4+te/zvd93/dx/PhxLMviU5/6FB/84Ae55ZZb+IVf+IXt/SKEEEIIIYS4DmtVAlEU43ohjhcQRwlRHAOrVQKaSi6XQ7nO8u4giOgNHAZDl2bbYqU1wHECvDBCy2TIZQ0qpRxTWRkyeBhEccrySp/zC23Oz3ewXB9VUSiWstSr+T3VTvB4cRyxdP6rVOpzlCoT1CeOUR2bo9M8T6E0Roq6fvhpmtLpdLjjjjv4ju/4jt098OtwKEKCxcXF9f+em5t70sddet/i4uKGkODVr3417Xabt7/97TSbTTRN46abbuL//r//b/7Vv/pXlMvly35O3/fxfX/9z2ubEGzbvq72ie1m2/ZuH4LYA+Q8ECDngbhIzgUBch7sF2tVAlEYE0QRnhfiBxFRlJCk6XqVgK6rGNraa9KYOIqJoyt/ftd1N/7ZCxgOPfqWR6s9oNt3cNyQKE7QVIV8zqBSMpgwspd8VEIc+Yj9K46euqKk23NYWO5zfrFNv++QpCn5nMnsRJGMuhYMJNt/oJsQBC7nvvUlzn7zfgLPYu7EHTzr7leCAs+6+5V87hN/TuDbqFoWVdWwbZtut0uxWOQXfuEXnvAzshcUCoWretyhCAnWBqvAaO3hk7n0vks/BuBVr3oVr3rVq675uf/jf/yP/Lt/9++u+eOEEEIIIYS4WnE8Gi4YRTGeH+H6AXGYEK5OXtfUDJqmYpoaGeX6e709L2Bgubh+j2bHot93cNyAJAVdz1DIGoyPFdF3cU2d2B2OG7LU6HNuoUWrY+P7IdnsaL6Epu3di6RrbKvLmX/8AhfOPEwShwCY2RLl6sXW85mjt/Kce36crz7wEbrtJaLAxbIy3H777fziL/4iL3zhC3fp6LfGoQgJdtOv/uqv8ou/+Ivrfx4MBhw9epRCoXDVSc5u2g/HKLafnAcC5DwQF8m5IEDOg92UpilhuDZgMMJxA/wgIgzjUZWAqmCaObTCqH1gKyRxQrfv0OnZLC73WGl2cNyAVNHJmhr5XI5avYomAwUOpRSdpUaP8wsdzi92sR0PTVUpFbNUyqX1doI4vcIn2mVfe+CvOf/tL8HqjIFSdZqTtzyHmaNPI6NqG45/8sjt3DN3G9/6x68TRy6/9xtv5M4779y3aw8vdShCglKptP7fjuM86eMuve/Sj7kepmlimpub+iqEEEIIIcRalUAYxnh+iOuFhKsbByBFVUdtA0XT3NI3KK4b0O5aNNsWC40uw4GHF8SYeoZcTmWmUsHQs1f+ROLASVIY2h79/oB2x+Lb53sMhg5JCqW8yfRE9ZJ2gr0rTUetDspqdU02V4Y0ZWLmRk7c8hzGJk8+5XyOKEoJlRqqOXZgAgI4JCHB7Ozs+n8vLCxwxx13XPZxCwsLl/0YIYQQQgghdsKlVQJRFOO4AV4QEYUxcZKgZBR0TcUwNQpbXLqdxAm9gUO7O6oWaHUsLGc0M6CQM6jXCpjG6O1DJLMEDo1RIODSH7gMhi7trkOzPcTzQpLYJ0lB003GayVUfe+3EwBEUcDCmYc5++jnueWZL2b6yG0AHLvpTibnbqFUmXiKj41ZaQ1ZWunTalukaYphqBs2HOx3hyIkuO2228hkMiRJwle/+tUnXYP41a9+FYDp6ekNQwuFEEIIIYTYDnGcEEbxapVAgOtFq7MFEtI0GW0c0FUKBWNbrlK6bkCnZ9PqDJlf6jEYuOvVAsVilqOzNTJ7ePK82FrrgUDfZWC5tDs2zY6F64X4QQhpSiaTwTR1slmdvGmSURXidH+EA5475Nw3v8iFb3+JMBgNFpx/7MH1kEA3cuhG7gkfF8cJzfaQpUafZntIklwMBLKmxlitQBDG5PbwYPprcShCgnw+z/Of/3z+/u//no985CP88i//8hMek6Ypf/M3fwPAS17ykp0+RCGEEEIIccClaUoUXWwdcL0A179MlYChkc9lrnsN4eWsVQt0ejaLjT7NloXleMATqwXEwZYk6ahlYODSH7p0uo8LBICMomCaOrmsTrWcf0ILQUaJd+PQr9mw1+DMP36OxfNfI01Gx5wv1Tlx6m7mTly+yjxJElodi6VGn5XWkDi+uIUhnzOYmaowPVnBWZ2/cJB+bg7OV3IFP/VTP8Xf//3f84lPfILPf/7z3H333Rvuf/e7381jjz0GwBve8IbdOEQhhBBCCHGAJEmyOlwwxg9CHDdcrxIgTVG10caBfN5AVbevl/kJ1QJDF8+PMHSVYtHkyEwNVQYOHmhrgUBvtWWg1bFpdy+tEIBM5qkDgf3sK1/8K/qdRQBqE0c5eeo5TM6dWp9FsCZJUjpdi6WVPo3mYPSzuipr6qNgYKpCuZhdD/Gc1ZDtINl3IUG32yWOLyZWSTL6xjmOQ6vVWr89m81SLBbX//xTP/VT/PZv/zZf+cpXeM1rXsPb3/52XvziF5MkCe9973t505veBMDLXvYyXvziF+/QVyOEEEIIIQ6K0SyBjVUCcRQTJymQousqhq6SzxnbUiWwJk0SugOXbtdiYbVawHY8EkbVArVKnqypb9vzi92VJClDy6M7dBkMXNpdi1bHwvUjgiAkTVPUjLq6leLgBQJJHLF4/mtMzd2CbowGa95w6/NYuvA1Tt7yXKpjcxsen6Yp3Z4zCgZW+gThxfeapqExPTkKBqrl3Lb+3O4lSrrPJiycOHGCc+fOXfFxP/VTP8Wf/MmfbLjt7Nmz3HPPPZw9exYYtSEkSYLnjdKf7/iO7+C+++6jVqtt9WGvGwwGVCoV+v0+5XJ5257netm2Dch6o8NOzgMBch6Ii+RcECDnwZr1KoEoJggibCcgXF1JmML6xgFdU7e1SmCN64V016oFFnv0h86GaoFiPrul1QJrgws1TbZ47aY4SRkOPXrWxUCg2bHwVgMBgIySIWvqmKaKoetbGgioq+0Ge2EmQRi4nP/WA5z71hfxXYtbnvlibrj1eZd9bJqm9AcuS40+yyt9/CBav0/XVaYnK8xMVqhV81cMBhorPTRV5UN/9vOy3WA/OnHiBF/+8pf5r//1v/K+972PM2fOoOs6t99+O6973ev4uZ/7OQzD2JbnPn36NKdPn95QBSGEEEIIIfaHNE3xg4ggiHDcANcPiVbXECrK6I2FrqvkcjtztfHSaoGllQErrSFDe3ThKy/VAgfSeiAwXGsZsGh1LTxv1MaSpqCtDhUs5HTqlTzKIWgjcawOZx79PAtnHiaORsGImSuhP249Z5qOKiyWGn2WVvp4Xrh+n6ZlmJooMzNZoV4rkjkEf29PZd9VEux3Ukkg9hM5DwTIeSAuknNBwOE5D9I0JVhtH/C8ANsNCINRKJBRFQxdQ9MyaDs4zfzSaoGFpR79gYsbROiqQqmU3fJqgacilQTbK05SBkOX/tBjMHBpdoa0u6sVAuHoqre6GgiYhopp6LsSCOxmJUGaJjz8ub9k+cLX19cPlqpTnLzlOcwcfRoZdXQ9fGh5LK/0WWr0cdzg4rGrGSbHS8xMVRivFzddBSCVBEIIIYQQQhxQowGDEX4QYjsBQRARRvH61oFsTt/RUODJqgVSRtUClXKO6axUC+x3UZwyHLr0LY/+wKHVsZ40ECgWDAy9cCgqBC4nTdP1Sh1FyYCikKYpEzM3cuKW5zA2eRJFUbAdn+VGh6WVPpbtr398JqMwMTYKBibGSjvSCrQfSUgghBBCCCEOpSiK11sIbMfHC1Y3D6wNGTQ1CoWdvVLu+SGdrk17dRPBhmqBYpa5mRraIX2DeBCsBQJrLQPN9pBOz14PBNI0RVdVDFOnWDAPdSBwqSgKWDjzMGe/+QXu/Cc/QrE8AcDNt38PN972fEqVSVw34Oz5FksrfQbDixsHFEVhfKzIzGSFyfESmrb78xP2OgkJhBBCCCHEoRDHCUEYEQQxjuvjeiHB6sAybYc2DzxemiT0hi6djs1ya8DKyoDBHq8WSJKEM4/9I8NBn2ptghMnTx2YMuutFK5VCAxd+oNRINDt26MZAlEMaYqmqqsVAhIIXI7nDjn3zS9y4dtfIgxcAM59635uf/bLAFCNEs2VAV/71mP0+s76xykK1GujYGBqooyuSzBwLSQkEEIIIYQQB9LaBoK1YYOOFxIGEUmaommj7QPlXVhrtlYt0OlYzC/36A1Gmwi0fVAt8LWv3M8H3/cOFhfOEkURmqYzO3ecV736Ddz+jO/c7cPbNWGcMhi4DCyXfn80Q2A9EFhdqaepqy0DpSyGpkkg8BSGvQZnHv08i+e+SpqM/v7yxRonTt3N5NztnF/osNzo0+nZGz6uXi0wPVVheqKMYchb3c2SvzkhhBBCCHEgrA8bDCLc1WGDaxsI1oYNFovmjl/1TpOE/tCj3bHWqwWGtkeSQj6nUynlmJ7YW9UCl/O1r9zPH/3+f8JzHAqlMgVNJ45Czp/7Fn/0+/+Jn/7Ztx6aoMAPIlbaQ9ptm2ZnsN4yEK4FAloG09AplbLoEghckySO+MIn/4zAG1UGVMePcOzGu0n0KRrNId/4/GNcOnq/Ws6NgoHJimz02CISEgghhBBCiH0rCCL8cG2uwMZhg4aukssZuzKczA9COh1nNFtgtVrA9UN0NUOpkGV2D1cLXE6SJHzwfe/AcxxqYxPrt6tmlpph0u00+eD73sFttz/7wLYeOG5AozVkcbnHwlIXy/FIkhRNG7UMlEtZDF0b1bqLq5bEEY3FR5k+ciuKkiGjahy/6S763WVKE8/A8vN89YxFmi6tf0y5lGVmchQM5HLbs8L+MJOQQAghhBBC7Btrwwb9IMS2A/xwdPU2kwFN03Zl2CBcrBbodG2WW30aKwOG1sZqgamJMvv17ePZM4+yuHCOYqmMsjpR3hr2UBQVXTfIF0osLpzj7JlHueHGW3f7cLdM33JprAyZX+qy3BzguKNJ+YWcyXi9hCpD8DYtDFzOf/tLnPvmF/HdIXd+948xNnUjzfaQYXKcdjRGcyEGhgAUC+YoGJiqUMjL6s3tJCHBDjl9+jSnT58mjuPdPhQhhBBCiH0jjpONGwj8iCiKSdIEXdd2ZdjgmvVqga7FwlKX7tDB9UK0jEK5mNt31QJPZTjojWYQ6GtXbVOGw8H6fvo0TUmThL98zx9zx7Pu5tjxmzh16x27d8CblAKdrkOj1efCQodm28L1Q9SMQiFvMjVeIaMejO/pbnGsHmcf/TzzZx4ijgIAFDXLo99ewP1mSBwn64/N5wxmVlsJSsXsbh3yoSMhwQ659957uffeexkMBlQqld0+HCGEEEKIPSlJRqFAGMaXHTZo6Bq5nL4rocCl1QKN1oDllf56tUAuq1Mp5pga37/VAk+lVK6iaRpRGGCYWdIUisUyURgShgFBGJCSsrhwjnarwalbnrEhJPibv343Y+NTTM8cZXr6CJq+d3rH4ySl2RnSWBlwfr5Nd+DiByG6plLIm1QreZkpsAWi0OcrX/w/NOa/QZqmRHGCopVR8jeTyR3FClUgIWvqo2BgqkK5mN2Vn/XDTkICIYQQQgixay43bDAMYuIkQVUzGIa6K8MG17heSLdn0+4MWVjur28iUDNQKuaYna6i7cLMg5124uQp6mOTnD/7TaZmjpLJZCiVq+utB532CpOTs/xfr/gRGkvzzB45sf6x1rDPpz7xofU/K0qGickZZmaPMj1zjBtuuo0jR0/u6NfjhzHN1pDllT7nF9oMhh5hFGOaOoW8wVitILMFtlhG1em2V3DcAMWYRCvfgpqbRlEUTENjerWVoLoLG0fERhISCCGEEEKIHZOmKWEY44cRvh+uDxuM4mR92GA+vzvDBgGSOKHbd+j2bRYbfZotC8vxSIF8dm22gH4gqwWeShgGKIpCHMc0lucZG5tE0w3iKMSyBuTzRX70J/75ZbcbJGnKP3nBS1laPM/S4nkcx2KlscBKY4GHH/wcz3n+966HBL7v8cmP/xUzM0eZmTtOfWxyywIi1w1ptIcsLneZX+pi2T5JkpDNGlSreXRd3hpdizRNaDfP4bkWerZMfeIYijL6XkVRwMKZh5k/8zC33vnDrHRclht9HPU2zKk7UI0quq6OgoHJMvVqQYKBPUR+EoQQQgghxLYKw9GwwSAMseyAIBzNFQDQdY1sTkdTd28AnG37dHo2zc5ocv1w6OEFMYaeoVg0OTJTQz3k5eb/5/1/ShgGHD95CtPM0li+gG0P0TSdY8dv4lWvfsOTrj8sl6u87JU/BoxCokG/y9LSeZYXL7C0eH7DoMPlxQt88uN/tf5nwzCZmj7CzOwxZuaOceNNT2NsfOqqj3tgeTSaAxaWeyw1+tirgwfzOZPxWhFVl8GDm7E8/whfe+DDDLrLJElEJqNRrk1z6ukvxLF7nHn0i7iOTRjFtOz7MCu3AJAtTjE1UWZmskK9ViRzyH+u9ioJCYQQQgghxJa63LDBMIqBFF1XMQxtV6eTR2FMp2/T6TosNnq0uxa2G6AwmlpfrxUwDXmZvObhBz/Hgw/8A4qS4Y0/8yscO3Ez3/7WVxkO+lRrE5w4eeqqr/YrikKlWqdSrXPrbc96wv3ZXI677n4hy6shQhD4XDj/bS6c/zYAr/iBH+e5/+T7AOh2mjz84OeZnTvG9OwxSqUKKArdnsNys8+FxdHgQc8LyWRG31sZPHj9lucf4Quf+FPCwMPM5VHVPIEf0Fz6No2FR8noJVB0MloRs3YrueqNTE1WmJmqMF4vHtgVmQeJ/PYTQgghhBDXZW3YYBDEOK6P64UEQQSAusvDBgFIUwZDj3bPptW2WFzpMhz6hHFMzhitTByrFZGLmk/U7TT5wHvfDsALX/wKTtwwuiJ8cvX/NW1rw56p6SP84A//U2B0XrVbyyytVhwsL57nyNEb1h975rF/5KMfeQ+kEMYxmpZDz9ZRszWMXJ2x8RNU6jWqZRk8uFWSJOarX/wQge+QL9ZJSfH8ENfqkiYJkJDEAaW5e5g7fjuz01Umxkq71j4kNkdCAiGEEEIIcU3SdPTGIAgiHDfA9cMnDBsslbK7esVwbT1hp2cxv9yj23fwvIur7CYnShiy4/4pJXHM//7z38f3XY4dv4kXfe8P7OjzZzIZJiZnmZic5Y5n3b3hviCKCSKdybnbWJg/x2DYJE1clEyXTEYhoyhMT72OQn4GgH5nkV57gVJ1inJ1Ck2/vnAjTRM6zfP4roWZK27ox98P0jQljgIC3yUMXcLAJY4ipuZOrT/mW1/7FP3OEkHgEAYeYeBiDztY/SYoContk6yuwETRUVRQdQNVgbu/81YmZ47v0lcnrpeEBEIIIYQQ4orWgoFOz8ZyPDTVJIoTMqqCoWu7OmwQRusJuwOXbtdmuTVgZWWA5fjESUo2q1EuZJkaLx26gYPXo9tt0+93yGZz/Mjrf4bMLs6NAPD8iOXmgKVGjwuLHSw7ojD5PO44+kKy2QyB22XQXWbQbzDsNihVL84uaCz8I9/++qfX/5wv1tYDg1J1mrHJ41cdHDxZP/7td76M6SO3bfnXfSVR6BMGLmHgjd7Q++76m/o0Tbjp9hesP/ahz76P9srZ0X1JsuHzqLrBS179lvU/d1vzrCx+iyiOieKEOEqII480TSFVSNIUhVG1kJ6toWsqkOI6faLA2aGvXmwHCQmEEEIIIcST8oMIzwsZDF1cL8R2LAxdI1vc3WGDAK4b0OnZtDpDFpb6o2MMInRVoVTIMjNdRZMy800bG5/k537xbawsz1OrT+zKMQxtj0ZzyMJyj8Xl3sXBg9lRi4h2yeDBXC5HpT572c9TKI8zOXszg14DzxngWF0cq0tj/hsAvODl/5/1kKDVeAzPGVKuTlEsj5NRL75lurQf38gWUNUCcRzRa8/zhU/8Kd91z09uSVDQbV3Acwbrb/bXr+b7Lkomw7Of/9r1x37xk39Or71w2c+j6saGkCAKPQLPXv9zRtXQjRy6kUU3cgwtl27fpdO1absTRLk8GdXEzBgoGYMkGuIsfRRNz2KYJpqqoCiQpqOfsygKyWQ0zFzxuv8O9jo/CBkOPWwnZLy+ezNWtoOEBEIIIYQQYoMoinH9EMvysN2AIIgxjNFqQk3NA+xKQBBHMd2+Q6fnsNTo0epYWI5PChRyBpVyjumsvuPHdZDl84X1OQQ7pdt3aDQHXFjsstIe4roBmYxCIWcwNV4ms4mKlbnjz2Du+DMACHyHYa/BoNdg2GtgD9vki7X1x84/9hBL578GgJJRKZbHR4FBZYpHv3IfQeCRL1TXZ2xomoGq6rhOj6898GHGJk8QhQFxHFIsj69/3vPffgBn2CEI3NHV/nD0/0Hgoukm3/Pye9cf+42HPvqUb/wvpRvZDW/2DSOPbl5845+m6fqx3vLM7+PUHS/GMHJoehYvSOh0bTo9m07P4R++8O2Ln9iYIZdVqJRz1KsF6rUClVKWT37oG/Ta86iZHJeOGUnTlMC3qY4doT5x7Jq/R/tBFMYMbQ/XCzB0jXqtyE0nJpibqR+oFY4SEgghhBBCCJIkwfVCHNdnaAf4fkhGVciZ+u5tIkhTLNtfHTg4upo8tDzCKMbQVYqFLEdna2QO0Ivz3ZamKe/933/EyRtu4dl3ffeOvPFJkpRWz6ax0uf8fId238H3AzRVpZA3qExWtnTwoGHmGZs6ydjUycveX65N43sWw16DMPAYroYJUehjDZoUKxPrfy+u0yeJI9I0IYkjVhb+kY+86/9B002y+TL3vPIX1j/vwpmHn/SNfxyHTziGTEYbvdE3c6sBQA7DyKGbG9/4P/uf/CiZzJVDuzRNQS3R7dl0ez06XZsgjDc8JpNRqJbz1GsF6tUClXLuCW1Et9/5Mr7wiT/FdXqY2TyqqhFFMYFvo+tZbr/zZftqPsOVJHGK5XjYjk9GUSiXcjzt1AxzMzUm6iVWWgN07WC9rT5YX80edvr0aU6fPk0cx1d+sBBCCCHEDvH8cNROYHm4bkBKimnqVMq5XbkyFgQRvb5Du2ezuNyj3bNx3IAMUMibjI+VMGW3/bb54uf/jgcf+Ae+/ODnOHHDrYyNT27L84RRQrM9YGllwPmFDoOBQxDFGPpoPeZYNQ+7FP7ccOvzuOHW543mcDh9Br0Gg+4ySxe+jm11UNWL1SpxHBJHozf4aZqSkpKkCZmM+oQ37tNHb6c2cWzjFf+1Un8zt+Gxt9/58qs+3icLCNLVkK3Ts+l0bbq9JwkFKvlRpcCThAKPN33kNr7rnp9cn8sQJA5KRqM6dmTX5jJsuTTFdnws2yNJoZQ3edrNMxydqzM9UUHXDk4IcjkSEuyQe++9l3vvvZfBYEClUtntwxFCCCHEIRaGMZ5/cc5AEEaY5mgV4E4PH0yThP7Qo9uzWWkNWWr0GToecZyQNXWKBZNxWU+4IxrLC/z1B/4CgJe8/Ie3PCDwgohGc8BSo8+FxQ5DyyNOErKmQbmcw9C1XQsGLkdRFHKFKrlClam5W6hPHqfdOEMcR2jaqOQ/my2NrupnFJI4Jo5Dnvu9/28mpm98Qsh28pa7L/c0W2YtFGivBgKdnk14mVCgthYK1EahwGa2kEwfuY2puVvot87iuRZ6trzvNjw8QZqO5gxYHkEYk8saHD86zokj48xNVcgeolYmCQmEEEIIIQ6BJElw3FE7gWX7+EGEqmbIZnUKhZ1tJ3C9cPQmpjNaT9gbOrir6wlLhdyhuFK310RhyLv+4vcJo5CbTj2d5333/7Uln9dyfBrNIYvLXRaWe9irMyTyWeMJgwf3uvrEMcq16VE/vqqjKMr6sMNRP36P6tgRJqZv2JEqnDRNGVreJZUCDmG0MRRQ1yoFLmkf2KrVpIqSYWxytOYwTvfP9/HxojBmaK3OGTA0xuslTh4bZ26mSqWYu/InOIAkJBBCCCGEOKDW1ha6XkB/6BH4ESkp2ezOthMkcUJv4NDp2SyvDFhpDRnaHmkK+Zy+up6wLOsJd9FHPvQulpcuUCiU+OEfe9N1vZHs9V2Wm33ml7qstIY4boCijNpFJjc5eHAvUJTMhn58wyygqhpxHO1IP/56KLA6aPCyoYCaoVbJU7tk0OBWhQIHSRInWLaP7Y7mDFQrOZ5+yxxzs1XG68VD/7tIQgIhhBBCiAMmCKIN7QRxnKAbGsWiuWNvGGzHp9O1aXUsFhpdhgMPL4hWBw6azM3UZD3hHvGNRx7is//wUQBe86M/Tal0ba2xSQrtrkWj2ef8Qpd218bzA9SMSrFgMDVRIaMejO/1E/rxfZvMNvXjp2nKYLhaKdAbtRBEUbLhMWuhwFqlQLmUIyM/V5eVJuloMKvlkQKlgsntt8xxbKbG1GQF7YCco1th20KCZrPJpz/9aVRV5QUveAHVanW7nkoIIYQQ4tCL4wTHC7BtH8vxCcMYTcuQzek7sq4wCmM6/dHVzYVGj3bHwnYDFEbrCeu1AqYh16f2opXlRRQUnvtPvpdbbnvmVX1MFKe0OxYr7RXOL3ToDRyCIMIwRoMH67s4eHC7rfXjd5rn8V0LM1fckn78JHl8+4BNFD8xFKhXRzMFarUC5aKEAk9ptZpqOPQI45h8zuSG4xOcODLGzHSVrPxOuqxN/63cf//9/O7v/i633347v/RLv7Thvne+85288Y1vxPM8AAqFAm9/+9v5oR/6oes7WiGEEEIIsS5NU1zvknaCIAKFnVlbuHaVs2/TbFksrnSxhj5BHJM1NIoFk7FaQdYT7gMvuOflHD9xM3NHTjzl4zwvZLk9pNHos9hoYVs+bgimqVMqZTH32ODB7TTqxz9xXZ8jSVIGlrseCHR6DvHjQgFNzay3DtSrBUrFrIQCVyEMIwaWj+8FmKbO1GSZk0dHcwZKhexuH96et+mQ4C/+4i94+9vfzn/9r/91w+2Li4u88Y1vxHXd9dssy+L1r389X/3qV7nxxhs3f7RCCCGEEAI/iHDdYMPaQsPQKJey2zpnII5iWu0hra7FSsejN3Bw3ZCMAsVClonxEsY+GkR32KVpun6+HD9582Uf07fc1cGDPZYafRzXXy3V1qhW89RUYwePeH9LkpTB0L1YKdC/TCigrYYC1bX2ge39mT5IkihhaPs4roeaUalV85y8bY4jMzXqtcKhnzNwLTYdEnzqU58C4FWvetWG2//wD/8Q13W54447eO9730s2m+UnfuIn+NSnPsXv/M7v8Nu//dvXd8RCCCGEEIdQFMW4Xohle9hOQBjF6Lq67WsL0ySh3bVpNAecm+/Q6fQI44RcPkepkGVyrCQvvvehhfkz/NVf/jk//GNvYmx8av32JElp92wazT4XFru0OzauH6BmFAq5i4MHVWU0MC9Od+sr2PuSJKU/vFgp8GShwFogUK+NKgUkFLh6aZJiOz6WPapgLxWz3HHbEY7O1pmcKKNK1cWmbDokWFpaQlEUjh8/vuH2D33oQyiKwtve9rb1qoHf/u3f5lnPehYf//jHr+9ohRBCCCEOkSRJcL1wddiWTxBGZDIZsqa2rWsL0ySh23dotIacv9Cm3bPwg5hCwaReL2LoGTRtZ9cmiq3j+x7v+vPfp9Vq8PGPfoAfeO0babaGLDcHXFjs0B+4BGGErqkU8ibVSh5F3mxdUZIk9AcXKwV6fYc42Zii6NroCvel7QMSClyj1TaroeURxQmFnMlNJ6c4fmSMmcmyzD7ZApv+G2y321SrVTTt4qdwXZeHHnoI0zR5yUtesn77HXfcgWEYnD179roOVgghhBDioEvT9AntBEoGDEOnXNrGtYVpSnfg0GxZnJtv0+oM8fyIfG60z37thXcU+dvz/GLH/NVf/hkrK8uY2RLjx57LX374QSzbJ0kSTNOgXMpiHKL5Apu1HgqsrSTsOySPDwV0dTRksFpgrFagWDAlFNikIIgYWh6+H2JmDWanKpw4OsHcTIXids9gOWQ2HRJomsZgMNhw2xe/+EXiOOa5z30uhrGxP6lYLGLb9mafTgghhBDiQAvDGNcLGFoejhsQxQmGoVHa5j3ng4FLsz3g3EKXlfYA143IZTWq5Ty5rL5tzyt2Xq/v8pl/+CSf/LuPEUYJp258Gd8+3yefMxmrFdFknsQVeX5IszVkpT2k07GeWCmwGgqsVQpIKHB94ihmaPu4ro+mqtSqBW54+lHmpmujDRpiW2w6JDhx4gSPPPIIX/ziF7nrrrsA+OAHP4iiKDz/+c/f8Ng4jun3+8zOzl7f0e5jp0+f5vTp08RxvNuHIoQQQog9Io6TDXMG/CBE11XMrE5R2743bLbt02gOuLDQZrk9xHFDsoZKpZRjelwG0R0UcZLS7FisNAdcWOiwuLTEl/7+HSRxxA23PJ+bbr6djOyGf0ppmtIfuDTbQ1ZaQ4aWt+F+Q1ep1wrrwwYlFLh+SZziOB6WM6paKhWznHra0dGcgfGSbHfYAZsOCb7v+76Pr3/969x777389//+31laWuIP//APAXjlK1+54bFf+cpXiOOYI0eOXN/R7mP33nsv9957L4PBgEqlstuHI4QQQohdkq7u7XZW2wl8f7S2MGtq1PKFbXtexwlotAYsLHVZWuljOT6GplIp52T44AHiBxEr7SHLjT4XFjsMLG805FLN8NhXP4yqxIxNH+dpz36xvNl6ElEU0+pYrLSGtNpDgnDjRb5KOcfkeImJsZLMFNgqaYrjBVhDnzhJyOdNTt0wxdEjY8xMVjClymVHbTok+Ff/6l/x9re/nQceeIDnPe95wOgfvRe96EXrf16zNszwuc997vUdrRBCCCHEPhUEEa4XMhi6uF5IkiQYpkapaG5bO4HrhTRbAxaWeywu9xjaHpqaoVLOMVYrIu8RD4ah47PSHLLU6LGw3MV2fJIUsqZOpZzHMDR8zyKTAU03eebdP7StLSz7ke34620E3Z5NekkXgaZmGB8rMjE2CgYMGYy3ZYIgZDD08YOAXNbkyGyV40fHmZuuUshJVdNu2fQZPjc3xyc+8Ql+6Zd+ic9+9rNUq1Ve8YpX8Bu/8RsbHpemKX/8x39Mmqbcc889133AQgghhBD7RRwno6tjto/t+ARBjGGo5PI6mro9V8b8YNQzvdQYML/YoW97qIpCuZzl2NyYBAMHQAp0ew7LzT4LSz1W2kNcNyCTUcjlDMbrJdTHtauY2SLPedFPYQ1a5IvVXTnuvSRJEro9h5X2kGZriOMGG+4v5I1RKDBeolYpSNXFForDmIEzmjOgaypj1QInj4/mDNQqMmdgL7iuGOyZz3wmH/vYx57yMUmScN999wGjYEEIIYQQ4iBLkgTPj3Bcn4Hl4/shGVUhZ+oUtmkCdxhENDsWS40eFxa6DCwXgHIpx7HZGhkph973wjil3V5dU7jQpjtw8YMQTVUp5A3KE5XLzhdI0wRFGVUNZFSNcm16pw99z/CDiOZqKNDqWMRxsn6foijUq3kmVtsItutn9bBK4hR7dc5ARhn9brrtpmPMzdSYHCtLeLnHbHutjKqqHD9+fLufRgghhBBiVz1+bWFKimnqVMrbs7YwCkd908vNPucW2vT7LilQLmaZnamhyavufc/zI5ZbAxqNPheWOgyHPlESYxo6hbzBWK3wlGsK0zTloc++j3yxzs1P/x4ymcPV152mKUPLY6U1pNke0h+4G+43dHU9FBivF9G2cVjooZSm2G6AZXkkaUohZ3LbTTMcna0xPVXBkL/vPWvLQoI0TWm32ziOw7Fjx7bq0wohhBBC7FlRFG/YThBGo3aCQsFEVbe+5zuJE1odi0azz7mFDp2eTZJCuWAyO11F24bnFDurb3msNAcsNvosLfewXZ8UyGUN6rXCNa0pvPDYl1i+8AhKRmX22O2UqlPbd+B7RBQndDrWehuBH0Qb7i+XskyMlZgcL1EubU+Ad6ilKX4YMRx6BGFEzjQ4NlvnxLFxZqcq5GXOwL5w3SHBl770Jd72trfxsY99DNu2URSFKLr4w9jtdnnrW9+Koij8zu/8DoYhJ4YQQggh9q8kGa0ttB0fy/bxgwhVzZDN6hQKW1+inCYJ7a5Nozng3HyHbs8mjBOKeYPpSbkat98lKbS7FiutARcWO7Q6Np4XkslAIWcyOV4ms4nwZ9hv8siDfwvALXfcc6ADAscN1tsIOj2bJLk4dVBVM4zVCusVA1lT38UjPbiiMGZoezhugGlo1GtFbjw+ztxUlUo5t9uHJ67RdYUEf/qnf8pP//RPE4bhkz6mVqtx5swZ7rvvPl75ylfy/d///dfzlEIIIYQQO25tzoDrBQxtD88NUTJsWztBmiR0By4rzSHnLrTo9Gy8IKJQMBkfL8k6sH0uiGJa7SFLzQEXFjr0By5BGKFrKoW8SbWcR7mOdpE4jnj4c+8niSPGp2/gxKm7t/Dod1+SpPQGDs3VNgLL9jfcn8vq66FAvVrYlqqewy6JU/wgJIpGc1fiRKVcyvG0UzPMzdSYqJdkzsA+tumQ4JFHHuFNb3oTYRjy8z//87zhDW/gpS99Ke12+wmPfcMb3sDHPvYxPvCBD0hIIIQQQoh9IY5HFQOeHzC0fQI/IkkTDEOnVMpu/Qq5NKU3cFlpDTm/0KbVtnD9kFxOp14rYMratX3NcQMardGawvmlLpY92gefNQ1KpSymrj3lfIFr8eiX72PYa2Bk89zxXT+wPrhwPwvCiFbbotke0mpbhFG8fp+iQLWSZ3J1G0Ehb0obwVZabSHwvAhvdX0rymjFZrlocOLoOHMz40xPVNC1/X+uiesICX7zN3+TIAi49957+a3f+i1gNKTwcl70ohcB8NnPfnazTyeEEEIIse2iKMb1Q1w3wHICgiBCUVJ0XaNYNLdlt/xg4NJsDzi32GWlNcB1Q3LZUYXCdLa85c8ndk6v79JoDZhf7tJoDnHc0RXvfM5krFa8pvkCV2tl6ZucffQLADzju16FmStu+XPshDRNsWx/vY2g23c23K9rKuNjRSbHS4zXS+hSXbM10pQoSvD8EM8PR2FMCoahkTU1Th4bY7xepFLOUavkyZoKCqBpsg3iINl0SPDxj38cRVF4y1vecsXHzs7Oks/nOX/+/GafTgghhBBiWwRBhB9E2I6P7QQEYYSSUTANjXIpuy1XJG3bp9Ec9aA32kNs28c0VKrlPNPjEgzsV3GS0uparDQHnF/o0Ok5eF6AqmYo5E2mxi+/pnBLjyEMUDWDozc8i8mZm7f1ubZaHCd0ejbN1pCV9hDP29jSXCyYTIyXmBwrUa3kpVpgCyRxguuH+H6EH4z+vrVMBtPUmZooMTFepl7OUynnKZdyaI87f6PIv9ynFfvcpkOCxcVFCoUCR44cuarH53I5+v3+Zp9OCCGEEGJLpGlKEMb4/mj4oO0GhGFMRh0FA5Xc9kw8d5yAlfaA+aUuS40+luNjaCqVco6JehF5u7M/+UHESntIozng/EKbwdAjDGMMQ6OQN6lX81vWRnA1Zo7dTqU+g5nbH2GT54frswXaHYv4kqGDmYwyGjo4NpovkJPJ+NclTUZzBHw/wvNDkjRFAbJZg3Ixy+TEJPVKgUolR62ckxanQ2zT33nTNPE8jzRNr/gPqeu69Ho9qtXqZp9OCCGEEGLT0jTFD0b9tJbt4fkRYRSPthKYozdz28H1QpqtAYvLPRaW+wxtFzWjUKnkGasVZbDXPmU5PivNIYuNHgvLXWzHJ0lSslmDSjmPoas7GgzAaLjmWjtMvljf0ee+Fmma0h+4620EA8vbcL9pauuzBcZqRRk6uFlpShjF+F6I64dE0WiOgKFr5HM6c9NVxseKVEt5KpUcxW36HSj2p02HBCdOnOArX/kK3/zmNzl16tRTPvav//qvieOYpz3taZt9OiGEEEKIa5IkyXowMLRHE7ijOEHXVQxT25Z1hQB+MLoyutQYML/YYWB7ZBSFcjnLsbkxCQb2oRTo9hwarT7ziz2a7SGOF6Awmi8wXi+h7uIqyn5nkQc/816ecdcrGZs6sWvH8WSiKKbVsVhpDWm1hwRhvOH+ajm3vo2gVNyeFp+DLokSXD/AC2KCIIQUNC1DztSZna4yWS9TreaplnKUS1ky8otIPIVNhwQvfelL+fKXv8xv//Zvc/r06Sd9XLvd5ld+5VdQFEU2GwghhBBiW8XxxYFbQ9vD9yLSNEU3VLI5He1JhixfrzCIaHYslld6XFjo0h+6AJRLOY7M1FDlBfm+E8Yp7faQ5dXZEd2+gx+EaKpKIW/syHyBqxGFPg9/7v24do/z375/z4QEtuOvzxbo9mzSi10EaGqG8bHiehuBIWXt12Rt/aAfRPh+QJKkZDIZsqZOrZxjamKSaqVArTKaIyArU8W12vRP5Jvf/GZ+93d/l9///d9ncnKSX/zFX9xwv+u6vP/97+ff/Jt/w7lz5xgfH+dnf/Znr/uA96vTp09z+vRp4ji+8oOFEEIIcdWiKMbzI1zPx3ICfC8EBXR9VC2wXeXKURjT7tosN3ucnW8zGHgkaUq5mGV2poYmwcC+4/kRy60BjUafC0sdhkOfKIkxDZ1C3mCsVtjxNoIreeTBv8UedsjmSzz9O3fvglySJHR7DiurbQSOG2y4v5A3RqHAeIlapSBXsq/W6gwVzw/xvZAoSQAwDZ18Tuf4XI16rUi1nKNazpOXuQ1iCyhpemmud23+6q/+ih/+4R8mDEN0XSdJEuI45tZbb+Wxxx4jCALSNMU0Tf7qr/6KF7/4xVt57PvSYDCgUqnQ7/cpl/fuQBnbtgEoFAq7fCRiN8l5IEDOA3HRXjoXwjDGC0IcJ8B2fIIwXl9VaBratqwqhNEk8FbXYmVlwNnFNt2eQxynlAom5VLuUOwIX5tmflBWnvUtj5XmaG7EYqOP4/qkQC5rUMyb27KmcKssnf8aD332faAo3P3Cn6Q+eXzHnltVYvwgYrnl0GwNaXUs4jhZv19RFOrV/HobwXbN/Tho4iherYaKCMIIUtB1laypMVYrMjlWprw6WLBUzO16+9JB+32wGcvNAbqmce//64UHplXmump7XvGKV/CpT32Kf/Ev/gX333//+u2PPPLI+n9/x3d8B7//+7/PXXfddT1PJYQQQohDbm1VoWV7OG5IGEWgKGRNjXJ2+/qY4yim3bNZaQ65sNih07MJo4Ri3mBqooyxi73o4tolKbS7FiutURtBq2PjeSGZDBRyJpPjZTL7YFieY/X46v0fAuDG256/IwFBkiT0+i7trkW7M6Q32Dh00DA0JlbbCMbrRTT52XhKa20Dnh/i+yEpkFEUslmDsWqBqckytUqeSilHpZw/FCGk2BuuuwHou77ru/jCF77Al7/8ZT796U+zuLhIHMdMT0/z/Oc/n+/8zu/ciuMUQgghxCGztqpwbSOB64eE4WgjgWlo5LZpVSGsBgNdm5XWkPMLHbo9myCKKRRMxutFWQ22zwRRTLN1cb5Af+AShBG6plLIm1TLeZTdviR7DZIk4eHPv58o9KmOH+Gm279nW54nTVMs26fdsWh1Lbpde8OKQoByKcvEWInJ8RLl0vb9TO57aUoQRnjeaJhqnIy2DWRXW1lOHh1nrFagWs5TLefIZvXdPmJxiG3Zv3B33HEHd9xxx1Z9OiGEEEIcQmmarl5VixhaHn4QEYQxuj4KBrazZHk9GGgOOLfYoddzCOOEfN5gfLwkw7/2GdsNWGmtrilc6mLZPnGSkDUNyqUshq7tufkCVyuJQ7K5Mppu8sy7f2hL22s8P6TdsUb/69r4QbThfkNXGasXmajnmRgroBvZLXvuAyNNiaKLQ1TDaDSTzNBUslmd40fHGK8XqVZGcwRKxSz780wUB5XE4EIIIYTYVUmS4PkRnh9g2cH6VbbtXlUIF4OBRrPPucUO/Z5LEMUUC6YEA/tQr+/SaA2YX+rSaA1x3FG/dD5nMlYr7un5AtdC002e9dxX49p98sXqdX2uKIrp9GzaHZtWx8J2/A33ZzIK9WqBsXqR8XqRYsFEURRUZfTGN970dLODI4lTPD/A9yO8IARAy2QwTZ3J8RKT42Vq5TzV1W0D2h7YiiHEU9mWkCCOY37v936Pj370o6iqyvd///fzxje+cTueSgghhBD70KWrCgeWR+BfXFWYy2/fqkK4uJVgpdVfrRhwieJkNH19vIRxQN5IHgZxktLsWKw0B1xY6NDpO3h+gJbJUMibe2ZN4VaJ44hMRkVRFBRF2VRAkCQp/aG7Xi3QGzg8fox5pZxjrFZkrD5ao7ddg0D3rTTFD0bVTmEUoyiQNQ1KxSw3jk9QrxaorFYJZKU1SexDmz5r//iP/5if/umf5jWveQ3vete7Ntz3ute9jve+973AqGzwAx/4AB/96Ed55zvfeX1HK4QQQoh9a21VoeOOVhUG/sVVhcWiua1vRNaCgUarz/mFDr3+KBgo5g0mJRjYV/wgotEa0FgZzRcYWB5hGGOstqPUq/l920bwVNI05eHPvR+AZ9z1CnQjd9UfZzvB6rDBUQvBpVsIAPI5g7F6kbFagbFaEV1+Hi4rCmOGlofjBZiGRr1a4MTRMWqVUShQkg0O4oDYdEjwN3/zNwD8+I//+Ibb/+7v/o73vOc9ADz/+c8nl8tx33338e53v5vXve51/MAP/MB1HK4QQggh9pNwdb+37fg4bkAQxkCKaeqUStltDwZaHYtGq8+FxS7d/mhdoQQD+8/Q9kbzBZZ7LC73sFyfNIWsqVMp5zEOwdXaC499icb8N1AyGRyrS6X+5CGBH0SrgcAoGPD8jXMFdE1lrF5YrRYoks8Z2334+1YSJQxtH8fzySgKtUqe22+ZZW62xnituOsrCIXYDpv+jfrQQw8BoyDgUu94xzsAeNOb3sQf/MEfAPC2t72NX/u1X+NP/uRPJCQQQgghDrggiC4JBkKCMCKjKpjG9q4qhFEw0GxbrLT7nF/o0u3bJAkU86asK9xHUqDTdWi0+iwsdVlpW7hugKJAPm8yUS+hHqLv5bDf5JEH/xaAU8+4h0p9dsP9cZyszhUYVQoMrY2rCTOZ0ZvbUbVAkXJpe38O97skTnEcj6HjowClYpY7bp1jbqbG1ERFZgqIA2/TIUGr1cI0TcbHxzfc/rGPfQxFUfj5n//59dvuvfdefu3Xfo37779/80cqhBBCiD0pXe3P9f1ox1cVAoRBRKtzSSvBwCFJoZgzmZ6sSDCwT4RxSqs9oLEy5MJCm+7QxQ9CdFUlnzeoTFb21ZrCrRLHEQ9/7v0kccTY9A2cvOU5pGnKYOjS6li0OzbdvkP6uMEC5WJ2FArUi9QqeVRV5go8pTTFdgMsyyNJUvJ5k1tumOLo3Bgzk2VZeyqeVJocvOmdmz7bB4MBxWJxw21LS0vMz88zNTXF7bffvn57rVajXC7TbDY3f6RCCCGE2DMev6rQ80OiOEHTtn9VIVwMBpabfc4vthkMPeIkpZSXYGA/8byQ5daQpZU+84sdLMsnSmJMU6dYMBirFQ7kfIFr8eiX72PYa6BqWcaOvoCHvjpPp2uvr9VbkzV1xldDgbFa4VC0YFy3NMUPQoaWRxDG5EyDY7N1jh8dY3a6SkHaMMRTsByfdteGNGV2pnqgqnM2/dujUqnQ6XRwHId8Pg/AJz/5SQCe97znXfZjslnZoyqEEELsV2urCv0wZWj5+H60vqowm9vejQQwCgaaHYtGczAKBgYeSZpSzJtMT1TQNblSuh/0hy6N5pCF5S7LKwPs1TWFuaxBvVY4MGsKr1cQRjz2za/yyJf/gSiOyU18F98821+/X9Myo5kCtcL6XIGD9CZlO4VhxNDy8VYHEI7XS5w8Ns7cVJVK+eoGQorDKQUGlku355LNapy6YYq56SqTE+XdPrQttemQ4OlPfzqf+tSneNe73sU//af/FBjNI1AUhe/5nu/Z8Nh+v89gMODUqVPXdbBCCCGE2FlhGOMHEa7n02z3CIMYwzQxDJ183tj2EuYgiGh1LJab/dEk+4FHnKaUC6OKAQkG9r4kSWn3bBrNPhcWurS7Np4fkslAIWcyNV4mI6XwxHFCr+/QWh02OBh6RF6XKDXQi0cwikeoVnKMrw4bLJdyZA5h+8VmxVGMZY8GqKqZDNVqnmfcOsfcTJXxehH5mxRPJUmhP3DoDVyKBZNn3DrLyWPj1GtFXC84cAVPmw4JXve61/HJT36Se++9l89//vMsLy/zkY98BNM0+ZEf+ZENj/3sZz8LwM0333x9RyuEEEKIbZWmKUEY4z9u8KCijO4rFAwKhcK2HsPjg4F+3yUFSgWTmakKmryh3PP8MKbVGrLcGg2QHAxdgiDCMFTyeZNqJX8o5wtcKk1ThpZHu2PR6lh0+w7J43qbq2NHOHHyx5moVxkbK6NJG801SeIU2/GwHJ+MAsVCljuedoSjMzUmJ8qoh/wcFFcWJyndns3A8qmVc3znHcc4NjdGpZLf7UPbVpsOCd74xjfynve8h4997GP84R/+IWmaoigKb3vb25ient7w2He/+92XrTAQQgghxO5bbyPwQ4a2TxBEhNETBw+6zvYdgx+EtDs2S40e84td+sO1YCDL7HRVgoF9wHYDVpoDFht9Fpa7WLZPkiRkTYNyKYuha4d+voDrBauhgE2na62uBL3INLTRoMGywcREjayp79KR7l9pkuK4PpbtkSRQyJvceuM0R+bqzExWMKWdRVyFKE5odS1cL6RezfPc77yBY3P1bZ+3s1dsOiRQVZWPfOQj/K//9b/4zGc+Q7Va5eUvf/kTViIGQcDS0hIveMELeNnLXnbdByyEEEKI63dpG4HlBAR+RJqm6IaKYWoUCtv/QsgPQlpti6XGaM1db+gCEgzsFynQ6zk0WgPml7qstIY4XgBAPmcyXiuiHvI3ZGEYr68mbHUsHDfYcL+qZqhXC4zVC4zXixTyJoPuEl/85Nvhmd/LkZPPkjkDV2N1kOrQ8gijmFzW4PiRcU4cHWNmskJeBhCKqxSEMa3OkDBKmBwrcdcdx5mbrR+6wE5JH78vRWyrwWBApVKh3+9TLu/dARe2bQNse0mp2NvkPBAg58FB8VRtBIahYRoamcxTvyl3nVEpQS6/+TLLS4OB+cUuA2tUMVAuZimVcmhS/runxUlKo9mm1bY5tzig23fw/RA1k6FYMMhlTTKHeId8kiT0+i7t7igU6A/cDfcrClRKOcbqRcbrRSrl/Ia5AlHo85mP/hH2sMPUkVv5juf98J4NCVRlVAURp7sXBIVhxMDy8L0Qc3W7w8ljo80ElaIMINwJUTQaPKpp+/sKu+eHtDoWaQrTkxVuvmGSuakq+lVsCXG9gExG4cSR8R040p0hu1F2yOnTpzl9+jRxHF/5wUIIIcQWuLSNwLJ9/CdpI9hufhDSbA1ZagxYWNoYDMzO1CQY2OPCKGGlNRitm5zv4Dg2YZSgZAwKeYOxav7QthGkaYpl+7RXhw12eg5xnGx4TCFvrK4lLFKvFdCfYq7AIw/+LfawQzZf4hl3vWLPBgS7KY5ihraP4/roqkqtWuDkbUeZna4wJgMIxTWy3YBWx0LLZDg6U+PGk5PMTlUP/TBVqSTYYVJJIPYTOQ8EyHmw3zxVG4Gua0/5BuVKrqWSwPNDWu1RMDC/1GFoeavBQI5SKSvBwB7nBxHLzQHLjT7nF0ffv4vzBTQMXdvVK8i7KQxjVloD2t1RG4EfRBvuN3R1PRQYqxfIZa+u1H3p/Nd46LPvA0Xh7hf+JPXJ49tx+FtmJysJkjjFcjzs1QGEpWKOk0fHOTJTY2K8JAMId9F+rCRIgaHl0ek5ZE2No3N1bjo+yeR4EeUKFXWXI5UET+Izn/kMn/70p5mfn8e2bZ4sd1AUhf/5P//nVjylEEIIIbh8G0EYxUCKYWgUi+YV2wi2iuePKgaWV0bBwMDyUBi9oJeKgb3PcQMazQELyz0WlrvYjk+SQi5rMFYroq3OF1h7c3iYRHFCszVgqdGn2bY2vNbNZJTVuQJFxmoFSsXsNVcAOFaPr97/IQBuvO35ez4g2AkXBxD6JGlKMW9y200zHJ2tMT1VwZBND+IajdYYuvQGDoWCye2nZjl5bIzxevHQVkM9mesKCb75zW/y+te/ni996Usbbl/bdHC52yQkEEIIIa7PldsI9B0rU3a9tYqB0fDBgT0KBsqlHEdmanKFb48bWB7LzVEbyNLKAMf1URgNHpyol8loh7fkNo4TWp3R/Ixma0B8yXrCYsFkcrzEWL1ItZxHvY7S5CRJePjz7ycKfarjR7jp9kO8DSxNcb0Qa3UAYT5vcuLoOMePjDE3VSGbPVzD48TWSNKUTtdhaHtUSjme/YyjnDgyfuDXGF6PTYcE7XabF73oRSwsLDA1NcX3fM/38K53vYtcLsdrXvMalpeX+fznP89wOGR8fJzv//7v38rjFkIIIQ6VvbCNYI3rhTRbo1L0heUefdsjgwQD+0W379BoDriw2GGlbeG6AZkMFPJZpsYrh3zwYEq7OwoGVpoDokvmC+RzBjNTFaYnK5SK2S193rGpk9iDNs+8+4d2rPJnLwmCiKHl4fujAYTTU2VOHBlndrpKeYv/rsXhESUp7dWtIvVqnu/6jpOcODK2o/9e7lebDgl+67d+i4WFBe6++27uu+8+8vk873rXu6hUKrzjHe8ARn2s//7f/3v+y3/5L+RyOX73d393yw5cCCGEOMj2UhsBacpg6LG00qHZGrLSdhmuVgxUSjmOSjCwpyUptLsWjWaf8wtd2l0bzw/QVJVC3qAyWUE5xN+/NE3p9GyWG32WmwPC8GI7RdbUmJ6qMjNZoVy69jaCq5HJZDj19Bdy8tTd6MbhmcgfhTFD28P1AnRNpV4pcPLpR5mdqjFWkyu8YvOCKF6dFxIzMVbk2c84xpHZOjmpRLlqmw4JPvShD6EoCv/hP/wH8k8ywKhQKPCf//N/JggCfud3fod77rmH1772tZs+WCGEEOIg22ttBL2eQ7trsdDo0Rs4OI6DqihUyiWOztbISA/nnhUnKc32aD7E+fk23YFDEEQYhkYhb1I/xBsJYBQM9AcuS40+yyv9DcMHDV1lerLCzFSFaiW/bT9zUeijZFRUdfRy/DAEBEmcYNk+tuuTURTKpRy33TzN3EyNyXppwzpIIa6VH0Q020OSJGVqssKpk5PMzdQwrmKNodho09sNKpUKtm3jeR6aNvqLz2Qy1Ot1Wq3Whsc2Gg1mZ2d50YtexEc/+tHrP+p9TLYbiP1EzgMBch5styiK8fwnthFouophXN82gmsRRzHdvkO377C00qfVtrBsb3VwnU6pYKLrKQr7a4r1YRJEMc3mkOVWn3PzbQYDjzCOMU2dYt7ENLQtCQZ2cqr9VkrTlKHlsdTos7TSx/PC9ft0TWVqosz0VIV6tbDtb1bTNOWhz74Xx+ryrOe+mkJpbFufbztc7XmQJimO4zO0RxtOSnmTo3N1js7VmZ6ooB/iuRcHwV7YbuCsrjHMZDLMzVS56cQks1MV1B3699N2fDQtI9sNAMIwpFKprAcEAPl8nuFw+ITHTk1NUalU+PKXv7zZpxNCCCEOhD3TRpCmDC2fTt+m2Rqy2Ohh2R5+kGDoGYpF8wkbCdZeDIq9w1tdVbjU6HNhoT2aBJ+kZLM61WoeXZcraJbts9TosbzSx3aC9dtVNcPUeInpqSrj9cKOzgKYP/MQyxceQcmoROEB/LlaHUA4tDyiOKGQM7jxxCTH5+rMTFXJmnJeius3sEdrDE1d5YbjE9x4fJLpydKm1hhuhueHeF6IrqsUcle36nS/2PRP6OzsLGfPniWKovWgYGpqirNnz/LYY49xww03rD82DEMGg8GGQEEIIYQ4LPZKG4Hnh3S7Dp2exfzyqIXAdQMURaGYNxmrFUdXm8WeZrsBjZUBi40eC0tdLMcnBfKPW1V4mDluwPJqxcDQ8tZvz2QUJsZKzExVmBgrXddWgs2yBi0eefBvADj1jBdSqc/u+DFslyAIGQw9gjAiaxrMTlU4cXSc2ZkqpbxUIInrlzJaY9jtO+TzBk+7aYaTx8eYqJd2pIUqXQ3AfD8ia2pMjpcoFrIH7t/OTX81J0+e5MyZM1y4cIGTJ08CcNddd3H27Fn+7M/+jF/7tV9bf+yf/MmfkCQJc3Nz13/EQgghxD7wlG0EO7SNII5iegOXbt9meWXASmu43kKQzWqUClkm6iWkDXjv61sejeaA+cUuy81LVhXmTSbHDveqwjWeH7K80mep0ac/cNdvVxQYr4+CgcnxEtoOlSBfThxHPPTZ9xFHIWPTN3Dylufs2rFslbUBhI4bYOoq9VqRk8fGmJuqUavKAEKxNZI0pdd36A9dysUcz7r9KCeOjVGr7EwrZJIkuF5IGMZkszqzUxUKeRP9gIaymw4JXvKSl/Dxj3+cj3zkI/zzf/7PAfjJn/xJ3vWud/G2t72NRqPBs571LB5++GH+x//4HyiKwg/+4A9u1XELIYQQe8qeaCO4pIWg1R6y2OgztNyLLQSFJ7YQiL2r23NYbvU5v9Ch2bZwvQA1k6GQNw/9qsI1wXq7RY9uz9lw31itwPRUhamJMsYeabt49MsfZ9hrYJh57viuV6Eo+zDcWf1dFwQenhcQJyrVco6nnZphbqYmwaPYUlGS0ula2E5AvZLnu551kuNHxiju0GrMOE5w3IAkScnnDCbHShTy5q5UIe2kTQ8ufPTRR3nJS17C8573PP7iL/5i/fbXv/71vPOd79xQNpmmKbfddhuf+cxnqFQq13/U+5gMLhT7iZwHAuQ8eCpXaiPQdXXb2wgubSFYbPTpDhwcZzQ5vJA3KRbMLSuD3AsDqg6yS1cVnrvQod138P0AXVXJFwzyWXNPrCrc7cGFYRjTaA1YbvRpdy0ufSVbreSZmaowPVHGNPfWurPm0re4/1P/C4A7v/tHmZw9tctHdPWS1TdKjhMQJTGGplIujdoJjsxMMDlZQZfQ6lDarn8Xgiim07HwgojxepFTN0xzdLZGbod6/8MoxnEDlBSKBZNyOUchZ+zo7JLdtOlXDadOneLs2bNPuP3P//zPueeee/jf//t/c+HCBSqVCi996Uv5pV/6pUMfEAghhNj/druN4PEtBM3WEMvxiZN0vYVgvFaUK3n7RBSntFZXFZ5baNN73KrCsUO+qnBNFCc0W6MBjc22xaXXuMqlLDNTVaYny+Sye3d4WKE0RnVsjkp9du8HBGmK54fYbkjgj+aW5HImR+dqzE5XGR8rUSlqqBlFQkOxpTasMRwvc/MNU8zNVjGNnQn9giBar9qqlHKUi1nyOWPH1g/vFZuuJBCbI5UEYj+R80CAnAdxnBCEEWEYX7aNwDS07b2ykKZYtk+7N2ohWFrpMxx6eEGErmUoFbMUCtkdaSGQSoKtEUQxK80hyyt9zi20GQ7XVhUaFAsGpr41qwq3y05VEsRxQqtjjYKB1oA4ufiStVgwmZmsML3aF7xfJElMmqao6t5of7hUFI6unDqeT5qAYWhUSjmOzFaZqJeYqJfI5S6+UZPfBwK27jxYW2OoZBRmp6vcfGKS2anqjgxiTdMUP4jWNxWUi1lKxeyeDh232977DSWEEELsorVQIAhiXC/A8UKiMCZOkh3bRuAHoxaCds9mcbk3aiFwAxSgkDOp1woHbpLyQbe+qnC5x4XFzuqqwoRs1pBVhZdIkpR2dxQMrDQHRHGyfl8+ZzA9WWFmqkJph/qRt4LnDMjmRxeGMpm9M+QsiVNcP8B1A8IwJpMZbTm5+cQU05MVJupFqtU8ezeuEgfBcHWNoaGpnDw2zo0nJpmZLO/IGsPRpoKAIIgxjYO7qWAzrutvYDAYkMlkKBaLT/k4y7JIkmRPXzkXQghxOMVxMpolEMY4ro/rR4RBRJKmqGpmtP+4sL19iEmc0Bs4dHs2y80BK80hw7UtBKZGsWBKC8E+tLaqcGG5y8JyD3t9VeHo+6ke0KnY1ypNUzo9m+VGn+XmgDCM1+/LmtpqMFClXMruu5LffmeRz3387Ry/+S5uueNFuzuocHXgoO0GeF4AQNbUmRgrcWSmxkS9SL1exJTzUmyzFBgMXTo9h1zO4NYbpzl5fJzJsZ1ZY5gkoxkbcZysbiookc8ZB3ZTwWZsOiR43/vex2tf+1p+9Ed/dMPgwsv5iZ/4Cf7P//k/vP/97+dVr3rVZp9SCCGEuG5RFK9O5h71Ha6tNEoZ7VA3DHX7NxGsthB0ejatrsXicm9jC0Ehy+x0Fe2AT08+iPqWS2NlyIWlDo2VIY43WlVYyJtMjpfJyPcUGAUD/YHLUqPP8kofP4jW7zN0db1ioFrJ77tgYE0U+jz8ufeTxBGO1YVduCZ/uYGDhUKWG49PMD1eYnysSKmwf6oyxP6WpIzWGA5cSkWTZ95+hBNHx6lXd6adMYpHLTUko8qkaiVPPmcc+E0Fm7HpkODd7343AG984xuv+Ng3velNfPCDH+Rd73qXhARCCCF2VBTFl1QKBHj+KBRI0hRNG1UKFM3tX0+41kLQ6dssLK22EDgBiiItBPtZyuqqwmafCwsdmh0L1wtRV0u3ZVXhRWmaMrS89WDA9cL1+zQtw/TEaMZAvVogcwDKZh558G+xhx2y+RLPuOsVOxN2pCmuF+J4FwcO5nMmR4/UmJ2qMjFWol4toB6Av1+xf8TJqFrIsn2q5Rx3Pes4x4+MUyrtTEAVhqOLAgoZSgWTcilPPqcfmk0Fm7HpVyMPPvggAHfeeecVH/v85z8fgC996UubfTohhBDiqlwaCtjOaC1hsHqVUt3BUGBDC0FryMrKQFoIDogkSWn1bBorfc7Od+j2bHw/RNdU8gWTajm/J1YV7hWW7bPU6LG80sd2gvXbVTXD5HiJmakK4/XigXrBvnT+a8yfeQgUhTvu/kF0I7dtz7U+cND1SVIwTZ1KMcuRU9NMjJWYrJfIZvfWOkhxOIRRQrtr4fkRY7UCd9x2hKOzdfL5nRkI6AchnhuiaSqVUp5yKUcuu70zhQ6KTYcECwsLlEolqtXqFR9brVYplUosLCxs9umEEEKIywrDeHXQYLRaKRARRasTxLUMhq5RLue2/0XB41sIGqstBL60EBwEnhey0hnSbFvML3afuKqwVtjTGwl2muMGLDf6o20clrd+eyajMDE2CgYmxkoHsszXsXp89f4PAXDjbc9nbPLEln7+0cBBH9cNCYIITR3NTTl1wxRTawMHKzJwUOweP4xpt4eEcTJaY3hykiNztR1ZY5iuru/0/QhD1xgfK1IsZMmaEpRdi02HBIqiEIbhlR+4KooiSW2EEEJctzAcVQoEYYjjBPhBTBjFpGmCrmvomrrt2wfWXNpCsLjco9t3sNe3EBjUq9JCsF9FcUqnP1o7ubjcY6Vt4bo+6eqV2nIpi7HHVxXuNM8PWV7ps9To0x+467crCozXR8HA5HgJTTu4w8HSNOHLn/9LotCnOjbHTbe/YCs+KUEYYbvh+sDBXNZgcqzE3EyNibEiY/UixgH+exX7g+uFtDoWKDAzVeXmk5PM7dAawyRJ1sOBbNZgaqJEMZ/FkH+DN2XTf2tHjx7lG9/4Bl/5yld4xjOe8ZSPffjhh3Fdl5tvvnmzTyeEEOIQStN0tVIgxg9WQ4EwIooSIEXTVAx950KBJE7oDV26XWvUQtActRDEcUouq1MsmIxJC8G+1bc82m2L5WafxUYPy/YJoxgto5LPGzJ48DKCtdWOjR7dnrPhvrFagempClMT5VGgcggoSoajNz4b1+nxzOe8etMrD9cGDtpOQJzEGPqoYuXG4xNMT5QZrxdk4KDYE1LAcQJ6Qxtdy3D8yBg3nZxkemJnfl/GcYLrBev/Do9PlyjkjQMdRu6ETf/GfuELX8gjjzzCv/23/5b3ve99T/nYX//1X0dRFO65557NPp0QQohDYC0U8FfbB2wnILgkFND1USiQzxk7NgTs0haCpUafwdDFC2J0VaFYyDI7JS0E+5UfRLQ6Fs2Wxfxyl17fwfNDUEZXaivlPIauSrXA44RRzPLKkMXGkHbXIk0v3let5JmZqjA9UcY8pOW9cyfuYPro01DVa3iZvT5wMCDwI5TMaFXm8SP19dYMGTgodkOUpIRBRBjFhOGoci8II5IEUCBNQkxD49QN09x4fILJ8Z1ZYxhGo1kcSgrFgkm5nKOQ2951xYeJkqaX/mq/et/4xjd4+tOfTpqmvO51r+O//bf/xtTU1IbHNBoN3vzmN/POd74TVVV5+OGHedrTnrYlB77fnD59mtOnTxPHMY8++ij9fp9yubzbh/WkbNsGoFDYmZUkYm+S80DA9p4H6ere7uBxoUAYxmQyoGkquqaiaeqOtay5Xki3Z9Pt2Sws9+kNL91CYFAsmIe2tzGKfAA0zdzlI9mcJEnp9h2a7SFLK30azcFoV3aSYuga+bxOzjRk6ODjJEnKYOjS7li0uha9vrMhGCiXssxMVZmeLJPL7sxAsr0mDFzSNMUw81f9MVEYY7vBehuLYerUillmZ0ctBHt94OB+/30gIFkN5tcCgCCMCcOIKFn9AU9BVZVRQK9p6IZKMW9SzGcpFAyyho6iROSyBtNTYztyzGvri9VMZhQOlHI7d+HgENl0SADwn//zf+ZXf/VXURQFXde58847OX78OIqicPbsWe6//36iKCJNU/7jf/yPvOUtb9nKY9+XBoMBlUpFQgKxL8h5IGBrz4NLQwHfD3FWB29FcYyirIYCq3MFdkoUxnQHNt2ey1KjR6tjYzsbtxDkc6a0ELA/3xRYjk+zbdFsDZhf7jK0fIIwQs1kyOeM0Y5sKUvdIE1TbMen3bFpdy06XZsoTjY8plgwmJmsMj1VoZDfP+fDdkjTlIc++166rQs867mvoT5x7LKPS+IU1/NxvYAgHLWxFAoGs1MVJicqTNZLVCq5fTNwcD/+PjhMUlh/8x+FMUE0CgCCKEFhdN4qioKhj8J43VAp5LKUCiaFvEk2q2EaOqapkTV0zKyGeZk5LK4zajPK5a8+INsMzw/xvBBdVykXs5SKo2GEEg5sj+tqEHvLW95CuVzmrW99K8PhkM9+9rN87nOfA0YnHkC5XOY3fuM3+Gf/7J9d/9EKIYTYV9ZDgSDC8wMcN1y/aqEooOsahqlR2MEXmWmyNlfAodUestTsY1k+YRxjaCqFosnsTA1NUoF9KYhi2h2LZttiYblLp+fgrg57y5o6pVL2si90DzvPD2l3LNpdm3bHwl9dG7pG11TqtQJj9SKT9RyFvEGcSrgCMH/mIZYvPIKSyWxsMVgbOOgEozYW1gYOlpmbqTE5VqJeL8jAQbEpUZyMrv5HEWGQEMUb2wAAdDWDbmgYqkqpkKVYMCkVTbKmQTarY+oaZnYUAmRNDWWPleqnq204vh+RNTUmx0sUC1kZCLwDrquSYE2v1+M973kPn/nMZ1heXgZgZmaG5z3vebz2ta/d01fMd5pUEoj9RM4DAdd2HiRJslquGOP5AbYbEAYxUZygZBR0TcUwVDR1B18Ur84V6PYdWp2LqwndIETNKBTzoxdOxg5MX97v9uKVwxTo9RyaHYtGc7Ryz7ZHw950XSWXNchlTTKqhAKXCqOYbnc0a6PdsbEdf8P9mYxCrZJnrF5krFakXMquX7FTlRjg0IYEaZrQaZ7Hdy2SJOJrD3yYJI645Zkv5sRNz8FxfWw3XB84WCyYHJmuMTlRZnysSOmAVF7sxd8HB0WyPrQ3IgwTgigiCuOLbQCAlsmg6RlMTUM3VYo5k1IxSz5vkjU0THP0xt80dExD27YNA9tRSZAkCa43uqiQzerUynkKeRNd/p3eMVsSEoirJyGB2E/kPBDw1OfBpaGA641CgSiMiZMUFHYnFGB0VbTbdej0LBYbfXqDi6sJ8zmDYt4km9X3TVnvXrFX3hQ4bkCzY9HqDJlf7NEfuvhBSCajkM+a5HPGjqzc2k+SJKHXd2l3LVodi8HQ5fGvACulHGP1AmO1ItVKHvVJBnIe5pBgef4RvvbAhxl0l0niiDD0UBSF2uRNPP05b0BVVXJZk8nx0oEfOLhXfh/sN0kKUXTJHIAoJgoiwjhZ/5nMKGDoGrquoulrcwBMCgWTnDkKAEZtAAaGqe5qddRWhgRRHOO6IUmSks8ZVMs5CnnzSX8Xie0jtRpCCCGu2looMBocNJrEHYUXKwUMXSWb03c8FLh0rsBys0+rbWHZHnEiqwkPgjBOaXct2p0hi8t9mh1rNOwNMA2dQt5grFaQFoJLpGnK0PLW2we6PXsU3l0inzcYrxVHbQS1olylu4Ll+Uf4wif+lCDw0I0cURSRJKPNK86gwXjJ5jvvei4T9RJZU15iH1ZPaAOIIoIwZu3HT1FA1zKjdjtNpVLMUiyOZgFkTePiDIDVMCBrqHuuDWCrhWGE44WyqWAPkd9gQgghnlIQRARhxNCOcP2QMIiJk4SMOmofyOWMHU/51+YK9HoOzbbFUrOHNbxkrkBB5grsd/2hS6tjsbwyYKHRw3F8wihGV0crMCfHd2YH937iuMFqmDIaOBiG8Yb7DV1dbx8YqxcO7SaCa5ameL7PQ5/7KzzPwcxVII1IIg9NVanVJ/B9h288+BF+4BUvlTc2h0SSwmDoYtneqA0gBZS1NgAVU1PJ5XRK+SLFUpZc1tjYBmDqZA3tUA9O9YMQ1w3QNY1qKTdql5BNBXuChARCCCGeIAgi/CDCsj3anR5hlJAv5FfXxO18KECaYjsBnd7ozc/icp+B5eL6IVomQyFvMj5ewpQrofuWF0S02hbN9pD5pS79gYvnByiKQi5rUK3kR1sv5MXjuiCM6KxWCrS7No4bbLhfVTPUq4X1FoJiwZQX31dpbROBbQdESYxnLeNaTUrlKvlcjkwG+kqEqmYoFIvousbiwjnOnnmUG268dbcPX2wjP4jo9mzcIKJSzHHTyanRpH1DG1UBmPr6VgBDBuw9QZqm65sKTENnvF6kVMwd2tXCe5WcuUIIIYCNwYDtBoRhjKpm0HWVfM4kl8/t6PGszRXoDmyWGn06PXvDXIFKKcfURFnmCuxTcZLS6dk020OWVvo0m0MczydOUkxDH/WjVvIoUg2yLo4Tun1nNRSwGAy9DfcrClTKecZqBcbrRSrlnFzVvgZRGGM5/vo2jHzW5OhcjbmZKu2lhK9/bjTodO3Kb31sYnT1GNB0g8gaMhz0dunoxXZKUhgOXbpDFz2TYWK8zI3Hx5iZqpHPS0XO1RhtKggIghjT1JmeLFPMZyVI2aPkuyKEEIfYaAtBiGV7OG442h+vZjANbX33ueskV/gsWyMKY3oDh27fYWmlT7ttMbQ9khSypiZzBQ6Aoe3Rals0WkMWlrtYtj865zIZCjmDiXqZjCZvatekaUp/6I5CgY5Nb+CQPG6uQLFgrrcQ1Kt5tENcunzNVter2Y5PEETomkqxaHLD8TmmJ8pMjpco5EZvAL/qLOB7Du0oZHJq9uLnWP19FIUBmqZRKld3/usQ28YPIrp9B9cPKRdyPP3ULEdn60yOFw/8nICtEscJrhcQRQn5nMH4VIlC3pDfVXuchARCCHHIPFUwkN/CFUZXkiYJ/aFHt2fT6tgsrnSxLJ8wStC1DEWZK7Dv+WFMuzOk1baZX+7S6dnr++KzWYNyKYuxi1O595o0TUdzBVbbB9pdiyjaGNJlTW11psBo4KCU6F6bJE5wHB/b9UkSME2dsVqRY3N1JsdLjNVL6I9bl/m1r9zPX77nj0FR8FybIAgwjItXj9M0xbIGHDt+EydOntrpL0lssSSFoeXSG7iomQwT4yW+8/g4M1PV9fBcXFkUx6MWqGRU/VedyJPfhRlGYnMkJBBCiENgPRhwfBwnIAgjMqpC1tB3NBiwbZ9u/+Jcgb7l4nqXzBUYk7kC+1mSQrfn0OoMWW4OWF7pYTsBcZJg6Bq5nEGllCejSiiwxvfD9Q0E7a6F50cb7te0zCgUqBUYqxdlqNe1SlOCMMJ2Ajw/RAEKOZMbjk8yO1VlarxEpXz5VirPc/nQB/6cL93/aQBuvOk2GssLWMMexWJ51GIQBljWgFyuwKte/QZp79jH/DAezRrwQsrFLE+7eZajszUmx0syJPUahGGE6wUoZCgXs5SKOfI5XX429pmrCgk++MEPks1meclLXrLdxyOEEGKLrAUDtuNjPy4YyOVyO/JGww9GcwU6/SfOFcjlDCrFHFPjMldgP7PdgGbbotkaML/cY2h5+EGImlHI5UzGa0VUCX7WRVG8OoBzFAxYtr/hfkVRqFXz6xsIKqWd+Vk9SNIkxfFGgWgYxhi6SqmU5ZYbppiaKDM5Xr7iisKzj/0j73nn/6DbbaGg8IIXfT8v+r4f5B8feYgPvu8dLC6cI7KGaJrGseM38apXv4Hbn/GdO/QViq2SpDC0XXp9l0xGYXKsxHc+c4KZySqFglQNXAs/CPHcEE1TqZbzlIo5clldfn/tU0qapumVHpTJZJiZmWFhYWH9the96EWMjY3x7ne/e1sP8KAZDAZUKhX6/T7lcnm3D+dJ2bYNQKFQ2OUjEbtJzoP9JwxjvCDEtkfBQBhFKJlRMKDr6qb+sXYdB4DcVVQcxFFMt+/QGzgsrwxotoYMHY84TsllR/vsC3mTjLxo2JeiyCeKEnrDkFZnyMJyj3bHxlkd9DaqTBlN9pYWgpEkSekPHFqrLQT9gcPjX3mVS9n1FoJaJb/ny3FVZbRaMU73TvgThzG2G+C4PimQyxqM1fKr/eNlxqoFMlfZupTEMb/1X/417XaDWm2cH37dP9vQRpAkCWfPPMpw0KNUrnLi5KlDeZU0ikYBl6btvzfTQTgK61w/olwwOTY3JlUD1yiKY6IowRpaRHFCuVSiUs5SLGSlDeoAuOqQYHp6msXFxae8TVyZhARiP5HzYH+IohjX39pgYE2SJNz/xS/Q7XSYmZ3l6c+4Y8OL4TRJGAw9On2HVttiaaWHZXv4QYKuKZQKWQoFE01edO1r/aFLs22x0myzvDJgYEVEcYymqeRzBrmseShaCNI0odM8j+9amLki9YljKErmcY9JsWx/vX2g03OI441zBfI5Y719oF4rjOYy7CN7IiRIU/wgxHJCfD9AzazOMZmqMjNVZXK8SKmQ3fSnP3fmmzzwxU/x8le9nmx2Zze77Bf7LSRIgYF1SdVAvcQNJyaYnZKqgaeSpilRnBBFo1AgiRNQFDQ1g6plSOOArKkzPlaTTQUHyFV9J/P5PN1ud7uPRQghxFV6qmBgq1oJPv33n+T/999/i29981HCMMQwDG686WZ++p/dy61Pezadns3icp/e0MH1QlRFWd9AYMoLhX3NDyJaHYtmy+LCcpd+38HzA3QtJZc1qVULaIeshWB5/hG+9sCHGXSXSZKITEajXJvm9jtfRmX8Rtqd0ayNdtcmCDbOFdB1db19YKw2misgrl0Sp7ju6HdelMSYhk6llOPoLbNMjZc2PdMkSRI+++mPohsG3/WcewA4fvJmjp+8eau/BLELgjCm07dx3ZBSweS2m2Y4OltnakKqBh4vTVOiKCaMEqI4Jk2ANEXTVTRtNGMga+pomoquq+haBtd1ASQgOGCu6rt56tQpHn74YX7zN3+Tn/3Zn93RIVdCCCFGLg0GHDfAD0YzBkxD2/IZA5/++0/yll9+M5ZlUalUyKgavh/w8MMP84tv/gV+8Efu5YZbnkU+q1MuZGWuwD6XAr2+Q7NtsbTSv2TgYIqhaxTyBtVKHk0dXRHfS2XmO2F5/hG+8Ik/JQw8jGyBTCZPEIa0Guf45If/J/npF6MXjq4/Xs0o1KqF1dWEBUrFrPTlblIUxliOj7va0pLPmhw9UmNuusrkWIVaNX9da1H7vTbv+d9/xGPfegRN07n51DOo1ce36OjFbkmBoeXR7TtkMgoT9RLPfvoEs1MVisXNV5gcJEmSEK2GAWGUQJqioKwHAKWCiWnoaFoGffU2+T12eFxVSPATP/ETPPTQQ/zyL/8yv/zLv7x+e6PRQFWv/oWCoihEUXTlBwohhAAuHwwoGYWsqVEpb89AsyRJ+O+/8/9lMBhQq08QhBG+baOqBsVSneGgw+f+/i954QtfeCj7cA8KL4hotoestIcsLnTpWh6BH5LJIAMHL5GmCV974MMEvotqlPCChDgevWFNlTxpZOO2vsjY9M1MjJUYqxWpVnLys7FZaYrrjQauBkGErqkUiyY3HJ9jZrLCxFiRwhZVYjz84Of4P+9/B67roOsGL3/V66jWxrbkc4vdEUQx3Z6D7QSUiia33jjN0bk6U+MlVO3w/j6L42R9hkAUxaQpZBQFXVcxNI1yUVsNBFR0bVQ1IIHA4XZVIcG//Jf/kjNnzvCHf/iHhGG4fvtVjDMQQghxjdaCAdcNsGx/R4IBGF2xa3dt/uEfPsPXvvZ1ND3P0HYZ9ttEYYCm61QqdUqlMksL5zh75lFuuPHWbTkWsfXW1hM22wMWG31WmgMczydJUgxTJ581GKvmZeDgqiRJ6fZszj72DZrLF0gVncgPSRMPRdFRNQNVy6AYRUgtbjmu/f/ZO+84ucqy/X/PzJneZ/tm0zsh1NCTkNARQYp0BUTBwgsWVPAVfoKCoCKvjaIiRUQCAgIKhEAIhA6hJkAqadvL9Hb674+zO9lNNpvNZnvO9/OJksycmefMnJl5nuu57+uipLxiqIc9ItE1nVxOIpuX0HTM/uaIn7FjopSXBiiJBnD0o+dFLpfl6Sf+zsqP3gagZuwkzj7/ckrLKvvtOSwGDwNIZwskEjkEm0BpxM8Bs8YypjK8V1YNdBYDNE3HMMBusyGKNtxOEU/Ii9MhFisExL1YPLHYOb0SCWw2G3/84x+55ZZbWL16NdlsloULFxKNRnn88ccHeowWFhYWox5V1ShIKrm8NCTCQFNrki11MRLJPJ+uWoeiKNjtdpKJBIaut49Rpa2tmUikBFVVSacSAzImi/4jn1dojqVpaUuztT5OOp1HUlTsNhs+j5OyaBCbaO14d6CqmmnQ2JqipS2NqurImUZ0XcMmurEJCppeAEFCMFw4xQA2m4t8roCUzwz18EcOhoGsqGRzMgVJQQB8HheTxpdTXRGmojRAKDgwZoGKInPn735mRhsKNo45/jQWHHMqtt2ojLUYHnRUDeTyMn6fi2mTKhhXU7JXVQ0oqlY0FNQ0DegwFLTj87jwuB2IDrM6wCHah31yisXwYbccJvx+P3PmbMuAdTqdHH300f0+KAsLC4u9ge2FAVnRQGBQhIHWWIbmthRb6mLEkzk0zcDvdVJeGkCeWIOiSOTzWWw2Gy6Xm1A4Sj6fQyrkEe0ioigSCIZRFQXRYUUdDRc03SCWyNLSlqa+MUFzW4Z8eySc2+nA73dT4hStaoFO5AsyLa1pmlrTxOLZLlWSToedSEU5SqsTp0tEFL1kMxqqIqEqEhlFwi46sNsduDz+ITyL4Y+hG+QKErmcjKJqOB0iQb+bGZMrKS8LUF4axD0IxmcOh5MD58zl4w/e5Ozzv0nNuEkD/pwW/UeXqgFBoDRqVg1UV4QJBEZv1cD2hoK6ZiB0ShgI+Fx43M4uhoJWy5PFntDnb+P77rsPj8eKhLGwsLDYHTRNJ19QuhUGgu6BMzfrEAbMioE48WQWXQe/10lFWRBnp12XCZOmU1JSTmPDVoLhKP5AEBAIOl0YgTDxeAvjxk+hpmYif/jtdUyaMpNjTzyDQCA0IGO36JlsXqalLUNTc5Laxnj7daUi2uz4vE7KS4OWg3cnDMMgnSnQ3JqmuTVFKl3ocnvHa1ZeGiAc8qLIedINy0nG6rHbHfj8UXRdpZBPI0t5FCmPIWrUb15JKFKF6LCi1DrQFI1sXiaXlzAM8HicVJWHqKmOUF4apCTsw7YnroO9pK52E6LooKJyDAALjz2VeUefhNM1eheVow1F1Ykns2RzZtXA1EkVjK8pobwkMOqSVnRdR9N0FFVHUTUM3UCAYsKA3+ttTxiwDAUtBo4+iwQXX3xxf47DwsLCYtTSRRjIyWY8mgAup0gwMHDCgCKrtMayNLcl2VwbI5HKtQsDLirLQ12EAVkqkM2miUTLsNlsXHTpD/jrXbegKBKyJCE6nGiqQiaTwuPxcdqZF7Fu7Sra2ppoa2viow/eZO78k5i74GRc1sR7QFE1g9Z4hta2FHWNCdpiWXLtzu9ul4NgwI3TYVULdKbDX6CpNUVza5pCQelyezjkpbzU3M32d8pLV+QCK5Y/jN3uQBRd5HMJnC4fdruI0+XD0HV0XcPtCZgigriXV9UYBpKskMkpyLKCrT0WdfrkSqoqwpSX+gn4Bu/7Qdd1li97hqVL/k1FZQ3f+p/rER0ObHY7Tqu9YNhjAJlsgXgiB0BpNMB+M8dSXREiOEDtKIPNrhIGgn4zYcButxV9BCxBwGIwEIx+cB+UZZkXXniBFStW0NzcjCAIlJWVccghh3DcccfhdFp5wB2kUilCoRDJZJJgMDjUw9kp2WwWAJ/PN8QjsRhKrOug73QrDGDgcjlwOcUBFwYaW5JsqW8jmcqjG+D3uAgG3V2EgQ5qt27kX/+8G7vo4DtX/azYPvDJyhU8/cTfqa/bhKqqiKKD6jHjOe3Mi5g122w92/T5GhY/8whbt3wOgN8fZOHxX+KQw47Gbrcyk/uLVKZAa1uGxpYk9U0JMlkJRdVwiHa8HicetwtbPxq77Qy7oAEjIwKxO3+BDmw2s0y5vDRIWWkAVzdl7qoi8e7yf5JorcXh9DB5n7l8vvoNUvFGdF3FZhMJRiqZdfDJOF3md2S0bBwAmqqwad07jJ8yZ1RWFnS+DnTNIN/+PafpGi6ng1DAw7h208HSkgCuIdjpjbU186+H/8KWzesBmDX7YM48++u4PVaMd3+hqhIAoti/17ii6sRTObJZCZ/PRU1VhPFjolSUBkd01cD2CQMgYBOEYkWAx+NoFwLsOB0jx1DQmiuOTvZYJPjLX/7C9ddfT2tra7e3l5aWctNNN3HZZZftydOMGiyRwGIkYV0Hu0eHMJAvSKSzgysMtMQyNLWk2FLfRipVQDMMAl4XwYAHx06M6XRN45Vlz/DSC0+i6zrBUISvXfYjyiuqt91H19mwfhXpVJJwpIwJE6ft0OdoGAafrnqPJc/+i9bWJgBKSyv45pX/D6/Xunb6gqLqtMUyNLelqWuI05bIUpDM3W+v24nX68ThGHwRZriLBPmCbLYRtKSIJXI7+AuUlQaoKA1SEvX3aOClKhIrlj9MvHUrDqeHQxd8hWCkEsPQibVsQcpncHn8RMvGIQg7Ps7nq99gzUdLcbg8TJ45l3FTDsZuHz1VBoYmk83LpLNmrLXX46K81E9NpdlGEAl7Gaq9TsMweP/dV3nm6X8iSQVcLjennv5VDjj4SGsHtp/pT5HAALI5iXj75zYa9TFpXBljKsKEQiNP2Nk+YQDMhAG7aMflsON2O0ZNwoA1Vxyd7JFIcM0113DbbbcVf4THjBlDTU0NALW1tdTV1ZlPIgj86Ec/4tZbb+2HIY9sLJHAYiRhXQe7pjthQBAMnM6BFQZkWaU1Zu4sb62PFYWBoM9FwL9zYaCDttZmHlu0bZdt9v6HctqZF3e7qO/tRFDTVN59+xWWvfAUY2omctHXv9/Hs9s7SabztLRlaGw2qwWyWXNn1uEQ8XiceN1OhEHo3+6J4SYS9NpfoCxIuJdmoKoq897yRcRaNuNwujnk6AsJRat3eVxnmurWsOajF8mmYwC4vQGm7DOfMRMPGJlmYoZBQVLI5mQkWcHjEPD5XVRWlFJVHqK8xI/XM/RVo5JU4LGH/8Knn7wPwISJ0/jyeZcRiZYN8chGJ/0hEqiaTjyZI9NeNVBdEWJCTQmVZaERUzXQOWFA13ToZCjodoqmf8AoThiw5oqjkz6LBK+88goLFy4E4KyzzuIXv/gFM2Z0zctes2YN119/PY899hiCIPDyyy8zb968PR/1CMYSCSxGEtZ10D2aplOQzFaCdFZGkVUYAmEgmcyjQ6+FAehul83DqWd8lQMOOmKn497diaAkFSjkc4TCUQBSqQTPPPUQx55wRpcqhb0dqf39bGnNsLUxTjKZM+PgBPB4XPg8zmE3SR4OIoHenuDQ3IO/QEVpgLLt/AV6g6YqrHh1EbHmTYgOF4cu+MpuCwTbxqlTt+kj1n/yCoVcGgBfIMrUfRdQNW5Wnx5zMNE1g3xBIpuVUdvbCCIhL+PGRCmLuIlG/biHmf+Iruvcc9ct1G75nONOOou5R580MkWZEcKeiASZ7aoGJo4to6Zy5FQN6LpOQVKRZdVc+Is2PC5Hu6Hg3pUwYM0VRyd9rlW84447APj617/OX//6127vM336dB599FEuu+wy/va3v/GnP/1prxcJLCwsRiYdwkC+IJPOSsjSNmHA73cN2ESgQxhoaEpQWx8nmc5jAAGfm+rKMOJu7kgYhsH7K15DkgpMmDSdL597GZFoab+O2eVydzEvfGnJk6z6+F0+Wfkecw6dxzHHn04wFOnX5xwJGEAimaOlLUNDc5LG5gTZnIymG7icIl6Pk3DIO+TVAsMRRdVobUvT3Jruk79Ab8llE6QTTdgdTubMv6DPAoE5LhtjJx1I9fjZbFn/Hp9/9hrZdIyGrZ8OW5FAUzQy7WkEYLa2jB0ToaYqQkVpkHB7G0HH4nA4IEkFbDYbDocTm83G2edfTqGQp6p63FAPzWI7OlcNeL1OJo4vZUJNCRWlQRyDEH/ZH6iaRj6voOsGbrdIVXkIj8eJ00oYsBhl9LmSoKamhsbGRurr6ykvL+/xvk1NTVRXV1NVVUVtbW2fBjpasCoJLEYSe/N1YBgGsqIhyyoFSTbNB9uFAYdDxOUUB0wYkGTFNKlrTlJbHyfRLgwEfW6CAfduCwNgnk/HBCYea+GTlSs4ct6JvTqHPS0pbWmuZ8mzjxVLgB2ig6Pmn8i8hafgdo8Oh+qdUZBVWtrSNLelqa0zRR5JVrDbBLNawO3EPsyqBXpiMCsJduUvYLYRBCiJ9OwvsLuk4o1omkKkdGy/PSaYPgeb1r5N5diZ+INm+Xs+lySfSRAtH9+vz9VrDANZUclkZSRJxmaz4fe5GFMVobo8RHlZEF83bQQDZVi3u2zZtI5/LforM/Y5gFNOu2BIx7I30tvroEvVQMTHxHFljKkMEx4hVQNg/i4XCgo2wYbf5yQQ8OB1O0dd60Bf2JvniqOZPosEbrcbn89HW1tbr+5fUlJCNpulUCjs+s6jGEsksBhJ7E3XgWEYKIqGpJjlg9n2RAJF1RBsAk6HfVCEgYYmUxhIZvKAWTHQV2EAQJYlFv/3EQSbjVNP/0qfHqO/FgSbN65j8TOPFH0QvD4/x590FocevnCPHnc4oRsQT2RpaUtT35SkqSVFriBh6OB0OfB5zHLUkRpPOJAiQRd/gZYUqcz2/gIuM6ZwN/wFeoOmqeTSbQTCFf3yeLvDynf+Q+3GDymrmsy02ccQjFQO+HMaukGuIJPLmQkZTodIKOhhbHWUyrJgr9IIhlok0DSVl154ildeegbD0AmHS7jqhzdb8auDTE/XgaobJBJZ0lkJj8fJmIoQE8aWUlk2cqoGzJYCBUnS2iOLXfh9btwuh1U10Im9aa64N9HnT2kgECCZTFIoFHC7e/5SzufzpNPpYb0otrCw2PtQFA1JVpFk05BLVlQURcNmA1EUcbpEfLvZ07w7SLJCS2uahqYUdQ1xUpn2igG/mzFVEcQ9LDuvq93Io//8M60tjQgIHH7kMZSVD50nwPiJU7n8ip/y6ar3WfLso7S2NtHa0jhk4+kv8nmF5pi5sK1tTJBO55EUFbvNhs/jpDwaxNYLv4i9kS7+Ai3pYoJDB5GQtygM+Lz9/1nUNZUP33iMtpbNHDL/gn6vHugJwzCwiSKCzUZLwwZaGjZQOXYmU/ddiD9Y0q/PpWs62ZxELi+jGwZul4PK8iBjq6OUlwYpifgZKV0uLc0N/Ovhv1BXuxGA/Q88glPP+IolEAwTsnmZeCKLphtEwz5mTq2iuipMJDRyFpCdWwo8bgclFaYxp3OEiBsWFv1Bn6/2/fbbj5dffpl7772X73znOz3e995770VVVfbff/++Pp2FhYXFHqOqpihgVgpISLKGomqAgcNhx+kUB2Qh0pmCpNDaZgoDtQ0x0plCURio7gdhAMzdj+XLnmHpkn+j6zqBQJizzv3GkAoEHQiCwKzZBzNjn/15791X2Xf2IcXbGuq3kM/nmDR5Rg+PMPRo7QvblrY09Q0JmmMZ8nkJA3A7Hfj9bkqc4oitFhhoOvwFmlrStMZ27i9QXhoY0Em5rql88ObjNNevw2YX0TRl1wf1I4IgMOugk5kw9TDWf7Kc+i2raNz6GU21qxkzcX+m7DMfjy/U58dXFJVMVqIgKdgEM6Zw8oRyxlSGKS8NEPSPrEW1YRi8/cZSFv/3ERRVwePxcdqZF7HfAYcN9dD2eopVAzkJj9vB+JoSxteUUFkeGlEL646WArvNRsDnwu934/M49wrzQQuL7enzJ/fCCy9k2bJlXH311bhcLr7+9a93e7977rmHq6++GkEQ+OpXv9rngVpYWFjsLpqmdxEFCpKKqmroho7DIeJ02PF4Br5ssCCZFQONzaYw0FFGHfR7+k0Y6CAea+FfD/+FzZvWAbDv7Dl86axL8Pr8/fYc/YHdLnZpMzAMg2ee+icbP1/N9Bn7c+IpZ1NRWTOEI+xKNr+tP35rQ5xstoCsaoh2u1ktUBrEZvWm7pSh8hfYGbqu8eFb/6a5bi02u8jBc8+ltGLSgD9vd/gCUfY//HQmzjiCdStfprl+LbWff4jL7Wfa7N1oxTEM8gWFbE5CVkzHdb/PzbRJFVSWmTGQ7hG0YNueTCbFC4sfR1EVpkydxZnnfL2YoGIx+Gi6QTorkU7n0QUH0ZCXQ6dWUVUZJhryjhiRdPuWgpKIz2opsLBgDzwJdF3n2GOP5ZVXXkEQBGpqali4cCFjxoxBEAS2bt3KsmXLqKurwzAMFixYwNKlS/f6D5zlSWAxkhhp14Gm6ciKiixr5PIS+YKComjohoEo2nA6RByD5ECcL3RUDCTNVoJsAQEI+D0EAu5+FQY60DSV22+9hkSiDZfLzamnf5UDDj5yj893MPqPVUXh2f88zLtvv4yu6wiCjYPmHMWxJ5wxJAsBVTNojWdobUtR15igLZYlV5ABcLud+NrdrEfKRLi/6K0nQYe/QFNLipbW9KD5C/QGXdf56K0naNz6GTabnYPmnkNZ1ZRBe/5dEW/dyuefvcF+h30Jh9Pc7c9lYjic3uLfO9A1g1xeIpuT0HQdt8tZjCksLwtSFvVjH4DvmqHyJPj4w7fJZFIcfuSx1u7uIKMbBrm83F6doiII4HUJlET9TJlYPeKqBlRNI5eXMXTwuB2Eg168HieOEWQkO1wYaXNFi97RZ5EAzAXvpZdeyhNPPGE+2HY/8h0PfdZZZ/G3v/1tWC+KB5o77riDO+64A03TWLt2rSUSWIwIhvt1oOt6MYEgl5fJFRQUWUU3DOx2G06nHYdoH7TJZL6g0NKaorEpSV1jgmS2gA0IBjwE/O4Bmaxvz8cfvs1br7/I2edfTiRa1i+POZgLgtaWRpY89y8+Wfle+3OaSQjzF3wBt2dgnbDT2YKZKtGSoq4xTiZrGrs5RDtejxOP24XNvneJAtvTk0ig6zqxRK5nf4Eys41goNt6doau63z89pM0bPkEwWbnoKPOprx66pCMpbcYhsFbL91PNtXGpJlHMmbCQRQkg1yhPabQ46KiLEBNZXtMYWjgE0MG4zuhkM/x36ceYvb+hzJ9ptWuOtjohlkBlMlK5CUFAfB6TBGqqjxEJOzD7QSP24nHO/JSCuztSR5WS8GeM9znihZ9Y49Egg7effddFi1axIoVK2hubgagvLycOXPmcN5553HIIYfs4hH2HqxKAouRxHC7DjrHEuYLMtm8jCKb7QNmAoHZQjCYP/b5vExLe8VA/RAIA+vWrAJg6vR9i/+m63q/vgZDsWu4ZdM6Fj/zaLFt4vSzLuGQwxf063MomkFbLE1LW5rahjixRI58e7WAx+3E53XiEPe+aoGe2F4kUBSN1lj3/gJ2m7nLWF4WpLxkYP0FeoumqXzw+r9obfqcA488m4ox04Z6SLtEymd486UHSCdbMQwDp8vPpJlHcejhCxhTVUJ5iWmqNpgM9HfCxg2reWzRX0kk2giGIlx9za8RHY4BeS4LEwMoFBQy7QaXhgEej4Ow30N1pSkKREI+fF5n8Tsxn8sBDHuRoKOlQJbNloKA30op6E+G21zRon/oF5HAovdYIoHFSGKor4OiKKCoFDqJAqqmF2MJnQ5x0HOK83mZ5rZ0sWIg1S4MhAIe/INUMaAoMoufeZS3Xn8Rvz/IlT/4Bf5A303OemKoSosNw2D1px/y/ruvcv5Xr8BmNxemibi5cOiLEJLMdFQLmG0guZyMquk4HDY8Hicel1Ut0BN2QSNfUGhoybb7C2TpPItwOkXKSwKD6i+wu2iaSjJWT7Rs3FAPZacYutlGkMvJKJqGU7SRS3xO/edvIRVSiKKdkpIyjj3xDPY74PBB3wUdqO8EVVF4cckTvPbyYgwMotEyvnze5YyfOLyrPUYqBUkhk5XJ5iUMA9xukZDfQ1VFiGi7KBDwu3YqlA53kUBRNfIFq6VgoBnquaLFwDD0sr6FhYVFJ2RZRVa0bbGEsoqiagg2AYdox+1xINoH/we+Qxiob0zQ0JQklS1gFwSCfjfjqiPYBnE3or5uM4/+88+0NNcDsO9+h+AchfFfgiAwc9aBzJx1YPHfVEXhnrtuwevzc+IXzmHy1H16fAxZ1WiLZWhpy7C1IU48kaVQUBAE8LhdRMI+RGvC2COGYZBKF2huTdHSmiKVkbrcPpT+Ar3BMHQaa1dTWTMTQRCw28VhKRBoqkY2L5PLmUkZHreT6sowNdVmG0EkfBS6eh7vvv0yLy/9D7F2k1KHw8ms2XOGevh7TGPDVh79559paqwF4OBD5nPKly6wog37EUnRyGYlMrkCmm7gdooE/G4mjC2hJOonEvISCrgRRnjpvSQr5PMyot1O0Ocm4Pfg9TislgILi93AEgksLCyGFEVpjyVUFLJZGUlRURQNmw1E0Y7TJeLzDX7/sqpoJFI5Eqkcjc0pmlrSpLMF7DaBYGDwhQEwSyZfe+U5Xlz8BJqu4Q+EOOucrzNtxn6DOo6hpLFhK7lchni8lXv/8mumTZ/NiaecQ2XVtnz7ZDpPS1uGxuYk9U0JMlkJXTdjLr0eJ+GgF2GkhMIPEZqmE4tnTX+BtjSSpHa5fTj4C/QGw9D55L1n2brhAyZOP5wZBxw/1EPaRnulVDYnUSjI2GwCPq+L6ZMrqaoIU14WILDda2tzODhi7vEcfMg83njtBdau/piZsw4q3p5JJwesomggaWtt5s7f34imqfh8Ac44+2tdzsuib8iqRi4nk8kWUFQDl9OGz+dixqRKSksChMNewgHPqEhm2b6loKzE/G6yWgosLPqG1W4wyFjtBhYjiYG4DlTVFAWUjsmxZFYKgLmIc4h2RHFwEgg6o2s6iXSeRCJnphK0JslkJGRFxyEKBPxuAn73oAsDHSiKzP33/JZNn68BYNbsg/nSWZfg8wUG/LmHqt1gZ2QyKZa9+DTvvPkSuq5jGDBt5hymzlpALGOQSOaQpPZqAY8Ln8dpVQv0AklWaWk1PRpaYxk0rZO/gN1GadRPRamP8lI/omN4XAs9YRgGn77/HFvWv4cgCOx32OlUj9931wcO5Jh0g4K0LabQKdoJBjyMrY5SUW56N7h2w7vBMIzid6WiyNz+q2soL6/m+JO/TM3YiQN1GgPynfDYor+Sz2U54+yvjUihYzigajrZnEQ2KyGpGg67Hb/XRVlZgIrSAOGgl3DQ22/fh8Oh3aBzS4HX4yQU8FgtBYOMtWYYnVgiwSBjiQQWI4n+uA40TTcrBdrNBvMFBVk2dyXFdlFgsGIJO2PoOql0gXgqR1ssQ0NLkkxaIi8r2G0Cfq8bn8+FaxhNNB5/5B4+WbmCU067gIMOmTdor9lwEwkMIJnMs27D5yx74d9sXP8Rum4gCHYOnHcpJaVl5u6RVS3QI4ZhkM1JNLekaW5Lk0jmutzucomUl5rVAtGwD7vd1usIxKHGMAw+/WAxW9atAEFgv0NPY8yEoam40TWdXE4im5fQdPC4HEQjPsaNiVBeFqI07MPWD9fqhnWf8sA9v0XTzfdo1uyDOfaEM6moHLPHj709e/qdYBgGH3/wFpOm7kOgXRBQFQW7KFq7vruBphtk8xK5rERBVrHZBAJeNyVRH5XlYcIhD+Ggd8BMQ4dKJDAMA0k2vYpEux2/z2W1FAwh1pphdGKJBIOMJRJYjCT6ch3oeocooJHLS+QltRhLKIo2nA5xSEQBDINsTiaezBJLZKlvTJJI580yX0HA63Hi95mlicOFXC6LrqnFXbVCIU8umyZaUj6o4xgOIoEkq7S2ZWhqS1NXHyOeLiBJCjYbaIUYW9Yux+FyM2feecVjOu+yWpjoukE8maW5NU1La5pcXu5yezDgLgoDAb97h9dvJIgEhmGw+sMlbFr7DggCsw/5IjUTDxjUMaiKRiYnkS/I7dFxLirLg4ypjFBRFiAUGJiYwnishaVLnuTD997AwEAQbBxw0BEce8Lp/RaJCnv2nZDLZXnq8ftZ9fG7TJ+xP1+99HvW57SX6Abk8hKZrFmFJwjg97qIRHxmLGHQSzjsHbTfscEWCbZvKQgG3MWUAouhw1ozjE4skWCQsUQCi5FEb64DXdeLsYS5vExeUlBkDU3XsdttOJ1mtcBQqPv5vEw8mSOeyNLQnCSezJFtXxR53Q78Xhcej5PhOD1dv3YVjz9yD5VVY7no6z8Y0kn0UIgEBpBI5GhuS9PQnKSxOUkuL6HpBi6XA6/bicftKLpuG4aBpsrFMngpn+GdV/7BpBlHUj1+XwRh791d6ogpbG5vJegcUygIAiVRnykMlARwu3uebI8EkWD1Ry+ycfWbAOx7yBcZO+nAXRzRDxgdbQQykqwg2uwEAi7GVkWpqAhR2YvXtj9paqzjxeef4NNV7wFgt4tcfe2vCIVL+uXx+/qdsG7NKp549B5SqQSCYOPY47/E0ceeau3+7gTdgEJBNmMJCwoAvnZfleqKjlhCL55BjsDsYLBEgo6WAnTwWC0Fww5rzTA6sYwLLSwsdotiLGF7+0A2L6MqZiyhzS7gdIh4vc4hiT6TZIVkMk8skaOxOUFbPEcmVzCjnVwifp+Lkoif4VyFrigyS579F2+89gIATqeLbCa1V/ToFiSV5rYULW1pausTJNN5pPb2D6/HRWk0gF3sflIoCEKXPvmNa98ik2zh47efYtPat5m+37GUVk4arFMZcnJ5uT2NIL1DTKHDYW+PKQxSEvEh7uQ1HakEQuUIgsA+B588oAKBrhnkCxLZrIyqa7icDiIhL2Oro1SWBSkpCeAYojjNisoxXHjxldRu3ciSZ/+Fy+XuIhBomordPnhTQFmWeP6ZR3nrjaUAlJZVcvb53xxQ34SRiAEUCoopCuTl9pQLB2G/hxlTKouxhD6vc6exhKOFjpYCqaBgt9uslAILi0HGqiQYZKxKAouRRDabxTAMnE43kqIite+UKYpWjCV0Ouw4HeKQiALbJxC0tKXJ5CRUTcftFPF5XXi9LsThrAp0oqF+C4/+8880N9UBcNgRx3DSKecMebzhQFUS6AbEE1la2tLUNyVpakmRK0gYOma1gMdhlpH2YTKsqQqb1r7N56vfQFXM8ZdWTmL6fscSjFT263kMBwzDIJnKm2kErWky2Z3EFJYGCIe8fa5MGQmVBADZdAxfINrvj6trurmAa48p9LqdlJcGqKmKUF4aJBL2DsvKJEWRcTjM3eZkoo07//BzjjjqeI6ce1yfvl925zuhrbWJB+/9HS0tDQAcfuSxnHjKOTidw8PjZKiRZJVMViKbk9AMA4/LQcDvproiTDTiIxL0Egy4h6UoMBCVBLquky8oKIrZUhAKeoopBRbDE2vNMDrps4x86aWXAnD99dczcaKlBFtYjCY6EgjiySzZnIzd7kTVzMWBwyHicov47IM/wdtVAoHf56ayLIRDHFm7DLqu8/ry53lh8eNomorfH+SMcy5lxswDhnpo/U4+r9AcM8vet9bHSafzSIqK3WbD53FSHg1i64f3zy46mLzPXMZOPogNn77K5vXv0dr4Oa1NG6mZuD/7zvniiO+DVjWdtljGrBhoyxQNQcFcT0RCPspLA5QN85jC/mDzunepqJmB22OmffSnQGDopsFjJlvAAAJeFzOmVFFdEaKsNIB/BLy2HQIBwLtvv0ImneSFxY/x5mtLWHjcacw5bAGiODCVBf5ACE3XCATCnHnOpXtVZGt3SIpGNiuRyRXQdXA57fh9bsbXlFAS9RMJeQkF3Ah72W759i0FZdGA1VJgYTGE9LmSQBRFRFEkn8+P+InWYGJVElgMRzr7CmRzUlHFzxdyOEQbgWAQx1CUJBtGpwSCNPXNwz+BoC/IUoE//d/PaGtrYuY+B3L62V/D7x8+3w97Ukmg6wZtxWqBBM2tGfJ5cxfW7XTg9TrNyLcB/h3JZeKsXbmMhi2fMGHaYcw88IQBfb6BoiAptLSa/gJt8Qy6vu0nXLTbKC0xqwVKS/w4Hf2/6BuOlQTrP1nOulWv4AuUcOQJ30AU+6E/2zDI5mWymQKabuD1uBhTFWbcmChV5SHcrpHbranrOh998BZLn3+CeLwVgEiklGNOOJ0DDjqyV6Xcu/pOSCbaCAQjxcdqaqwjEAjh9fn76SxGDoqqF0UmRTVwOmz4fS4qy0KURv1Ewl5CAc9OW6mGM3taSdC5pUAU7fh8LgI+t9VSMMKw1gyjkz6LBNXV1RQKBWKxWH+PaVRjiQQWwwVZVostBJmchCKbvgIdZoNOh0ghnwcGMd6ohwQCQRDwDcMEgj2hs/v+1s0baGysZc6h84ed8Lq7IkE2L9PSZu5w1zbESGfMTHjRZsfrdeL1OLENQXsKQDJWj8cXxunyFv/e1ryZ8VMPGdQe7d5iGAbpTKGYRpBM57vc7nE7KC8NUlYaIBr2DvjEeriJBBs+fY21K5cBMH3/45g044i+P5hhkC8o7Ys5DY/bSWVpkHFjSxhTGcY3ROZwA4Wqqrz3znKWvfg06XQCgDE1E/nWldfv8jra2XeCYRiseGc5zz79T044+cscMff4ARn7cEbVDbK5AtmshKRoiHYbAa+bsrIAFaUBwkEv4aAXcYSL29B3kaCjpUCWVdwuh9VSMMKx1gyjkz7PiA499FD+85//UFdXx5gx/Z/Ba2Fh0b9oWkc0YXu1gGRWCwiC2ULg8QyN2eCuEgiCPhcVpYFh2efbV3K5LE8/8XfGjpvEUfNPBGDs+MmMHT95iEfWN7T2aoHWtjR1DXFa2rLkCuYiwu1yEAy4zV3tYSB+hKLVxf82DIPVHy0l1ryJzeveZdrsBcMiCUHXdWJxM6awuTVNQVK63B4Ketr9BYL4fa5hJyoNFp+vfqMoEEzb75g+CwSyrJDOSEiSgstlii4Tx5VQXREesKjC4YAoihx25DEcOOco3np9KcuXPcPkKTP7LDRl0kn+/dh9rP70QwDWrv6Yw486btRfn5pukM1L5LJm5K/dZra+jamMUFkeIhLyEg55cTqHnwg52CiKSq6gIBhmS0F5idlSMNrMUy0sRgN9riRYtmwZxx13HF/72te45557+ntcoxarksBisOicQpBtj09SZBXdMHA47DgddkTR3uMEbiBMiWRZJZHMEU/maGgyEwiyuQJ6pwQCr8eJbZROLDes+5THHvkrqWQcp9PFj356O17v8P6cdbdrmMlJtLRlaGpJUdsQL+6+OuxmtYDH7cI2RM7uvcUwDOo2fcS6VS9TyKUBCIQrikkInT8bhqETa9mClM/g8viJlo3rVzFBVtRiG0FrLIOmbYsptNkESqN+01+gJIBrCHfbhkslwcY1b7P6wyUATJ29gCn7zNut41VFI50pkJdknKKdaMjHhPGlVFdEiEaGp/ngQJPPZxEEG263KYxs2riWpc//m+NPPotx46cU76frOhvWryKdShKOlDFh4jTWfPYR//7XvWSzaex2keNPOouj5p84KkvGDUxxO5UtUCioCIIZSxiN+KmqCBEJegmFvGZE6yinN3MEq6Vg9GOtGUYne5Ru8Mc//pEf/OAHnHHGGVx77bUcdNBB/Tm2UYklElgMJKqqUZBUJNlMIZBlFUXVitGETod9t36U+0Mk6JxA0NSaprklVUwgcDnMCYPP6x4xCQR9RVUUXlj8OK8tXwxASUkFZ59/+YioHlBVCU0ziKcVWttS1DUkaItnyRXMig+324nP48TpsA+LaoHdRdMUNq99hw2fvV5MQiipmMiM/Y8jGKmksfYzPnnvOVLxRnRdxWYTCUYqmXXwyVTWzOzz82ZzUnu1QIp4ItflNpdTpKw9jaAk4h+SKp/uGA4iQe3GD1n5zn8AmDJrPlP3PbpXx2mqRiYrkctL2Gw2wiEPE8aWUl0ZobwkMKyjUYeCe//8azas/xSAGfscwPEnnUVbaxNPP/F36us2oapmjKLD4UAQbHi8Pioqazj7/Mupqh43xKPvX2TFvHYyWVPQ9ngchINexrQnEISDXrze0dWO0ht6miNomk5Bam8pcDsJBdxWS8EoxVozjE76LBJMmmTmTTc2NiJJ5qTK4/FQUlKC3b7zHOsNGzb0caijA0sksOhPdL2jhUAjl5fI5RUUVQPaqwWcIuJOPo+9oS8iQW8SCHxe14hLINgTGhu28ug//0xTYy0Ahxy2gC+cet6QRxvuCkUzaGlN0tjUxpb6OImkjKJpOEQ7Xs/IqBbYHWQpx4bPXmPLuhXousasg7+A0+3lnWUPosgFnG4fdruIpqnIUhaHw82hC7/aa6FA1w0SqVy7v0CKbE7ucnvA7y6mEYQCnmFZpj0cRIJCLsXbLz9I1dh9mLrvgh5fJ10zyOQK5HISgiDg97mYMLakPbIwhDiKrt/+JhFv46UXnuT9Fa9jGDqFXI5UKoHNbiMQDCOKDqR8jtbWRgTBxoLjTuOir30P0THyF4G6YRRFAUnRcNrt+AMuqssjlJX6iYZ8wzaWcDDpbo6wfUtBOOixWgpGOdaaYXTSZ5GgLyVCgiCgtceo7a1YIoHFntJhOFgoyGRyMoqsoemm4aDLKeJw9NxCsDv0SiTonEAQz1DflCCTlijIKjYboyaBoK/kcllu++XVSFIBny/AGWdfysxZBw71sHaKohk0tyRpaEqyqbaNVDqPXdBwuR243R4cA+CYP9zIZRJsWf8uU2cv4OX//pFEa21RIOhoMTAMg3wuQbikhmNO+95OWw9UVaM1ljGFgbY0irLtN1AQBKJhL+VlQcpLAnhGgDHecBAJABS5gOjo3o/B0A1yOYl0e2Sh3+tibHWUmmqzR3xv/S7qKy3N9byw+AlefP4JZFlCtIsEgmECwTCCIJBJJ8nnckycPJ1rrv/diCwhN4BCQSGdk8jlZQTM66Yk4qOqIkw04iUS9I0Ks8H+pGOO4PZ4kGSVQkHBYbUU7HVYa4bRSZ9ne/fdd19/jsPCwmIndBgOSpJCNmcuvlVVA0HA6TD7vwe1FHm7BIKGxiTx7RIIQkEPlXtBP2Zv8Hp9zF94Clu3bOCML38NfyA01EPaAUXVaW5NUd+YYHNdjFQ6j64buN0OSiJ+XO1r16FeGA4WXn+YGQccT1vzJlLxRpxuL/lsAsPQcbp8uNw+BMGG0+UjFW8k1rKFkvIJxePzBbmYRtAWz9JZi3eIdspK/JSVBikt8Q9NtOgIZOvnHyCKTqrGzQLA4dyuCqcYWSih6Tpej4vJE8oZ3xFZaH0f9Zmy8moOP+o4XnvlOew2EUWVuySB+AMhnE4X9XWb2bRxLZMmzxjC0fYeRdXbqwXyqLqBx+UgFPAwfVI5pdEAkZBvr2wh6C2GYaBoGoqsIim0m34GrJYCC4tRQp9Fgosvvrg/x2FhYdFOh8mPLKvk8jK5goLc7m4uthsO+ry7n1e/J+QLColEjlgis9ckEOwJH3/4NmXlVcW+3PkLT0EQhGFVPq6oOs0tKeqaEmypayOVLqDrOm6Pi5KIf7sds72zAkzKZ9B1FUFwIwgCum4gFTLIUhany4vT5UXXVQr5NMlUnubWFM2tadKZQpfH8XqcxTSCcMiLzWp+3y1qN37IqhXPIABef2RbQoVhUJAU0pn2yEKXk5rqCONrSqiuDOEf5O/J0Uw6lcAwoLS8ElVRcDi7LgJFhxM1kyadSgzNAHuBbkAuL5HJSuQLCqJoRhNOmVhBRWmQSMRLOOBBsHa+d0DXdVRVR9U0FFU3Sy8MA1VVcTpEKivCVkuBhcUoY/TXjVpYjAAURTOrBWSFTFZCllVUTcdmF3A5RQIB96CW7CmySjyVo6k5RnNLikRaJZsroOkGHrcDv88swxytCQR9JZ/P8p9/P8hHH7xFecUYrvjuDYiO4VNuKasazS1p6hvjbK6Lkc4U0A0Dj9vZjTBg4fL4sdlEDMPAHyxDkfNIhQyapiIVsmYigk3k40/qENxdPwuRkLfdXyCIz+scVgLRSKJu08esfPe/YBiMnTqHYKQKWVZJZwpdIgsnjC1hTEWYUHD0RhYOJaYHgYiqyDhdbrbvVFUVGVE02xCGE5Ksks5IZPMSBmYKQWnUT3VlmJKwn0jYiibcHk0zxQBV1VFVDcMAmyAginYcDpGgX8TldGC325ClAg6HHb/f+txZWIw2rG9GC4shoLPhYCZboCCpnQwHRdwexx4ZDu72eNrNBuPxLC2xDE3NSdJZCVkp4HTYCQT8VFdFRn0CwZ7w+frPeGzRX0kmYwiCjX33OwRhGLxesqrR1JKiviHB5ro2MlnJEgZ6SbRsHMFIJYm2Wux2B6LDjSE4kKUCspQBXQMEVMOJ227rElNoLTz2nPrNq1j5ztNgGNRMPIiqifNoaErg6IgsnDWWMZWmu/zQf9JGNxMmTqN6zHi2bF5PxNm1QsMwDDKZFOPGT2HCxGlDNEITVTfIZgum2K5ouNtF9kkTSimN+ImGffh9rr3ecLCDzmJAR+yq3WbDbrfhdop4Ql6cDhFRtOEQ7TtWChjqEIzawsJiMNjjWUxtbS233347zz//PJs3b6ZQKKCq27404vE4d911F4IgcM011wybHTULi8HEMIxitUC+IJPNm4aDumFgb48n9Hgcg7fbaBikMxKxZLZoNphOF5BkDbsN/D4P5WUBbJi7A6Jole3uDFVReOH5J3j9lcUYGERLyjn7/Mu75IoPNpKi0dSSpL4xyZZOwoDX7aQ04sduCQO9QtUMxkw5mnjbIyQTbWBzgWAHw0AQ7AgOP9GKmRx0+CFEwz7sdht1m1ci5StwOsuHevgjmoYtn/DRW0+iaRol1bMoG38kPo+TWdOrqa4MUx4NWG0bg4jNZuO0My/inrtvJR5rwecLIDqcaKpCJpPC4/Fx2pkXDfoczwDyeZl0ewuBTQC/z83YMVGqK0JEQj7CQQ/2vbwM3jAMVNVsFVA1DUMzQBAQ7Tbsog1/u4+A6LDjEM0/wyV21cLCYmjoc7oBwIsvvsjZZ59NKpUqlp51l2Bw2GGHsWLFCl588UUWLly4ZyMe4VjpBnsPqrqthSCblZFks1pAsJmGg06HOKg/wvm8TDyZIxbPUteUIJHKkS8oCJglmH7fjmZDqmrGm1oiQfdk0knu++ttNDZsBWDOofP5wmkX4BqCaENJVmlqSVHXmGBrfayY5+11u/D7nHs0SR4ujvYDjapqxc9IWzxLKp0HQMluJd/6LpoURxB07HaRYKSK/Q79AlVj9ykeLxWyvPzfP6BrKuVjpjFln3nb+udHCQN9LeiaQWPDJla88nfAYMyE/TnxlAuoqS6hvCyEw4osHFI+WbmCp5/4O/V1m1BVFVF0UD1mPKedeRGzZs8ZlDHIikYmK5HNSWjtBquRoIcxlRGiER+RsA/PXmxUub1/gKEbCJieRqJow+Ny4naZ7QIOhx2HaOuzuGPNFS3Aug5GK32uJNi6dStf/vKXSaVSnHbaaVx00UVcdtllJBKJHe576aWX8u677/Lkk0/u9SKBxeils+FgNmfuasiyioGB0ynidIn4fIO32JZllUQyRzyZo6EpQVs8SyYnYRgUfQXKogGszbido+s6mzauJZ1KEAiGmTBxWpfJlNcXwO3x4vX5OfPsS5k566BBHZ8kqzS2mKkEW+tjZuSbAV6Pi9JoYK/fPdsVmqaTSOZoi5tJHclUju1lc6/HSbR6P6KHHIZNjaFrBVweP9GycTvEHuqaSnn1VBprV9Nct5bmurWUVk5i8sy5RMvHD+KZjSwM3SgayumGgT9QwewD5+J2CVz41W/hcVsO88OFWbPnMHPWQWxYv4p0Kkk4UrbD92J/oxsGmZxENmum+zjtdvwBFzOmVFFa4ica8ppeFHthC8H2/gEgtPsH2HCK2/wDxPbqAFG0Wf4oFhYWvaLPlQTf//73+f3vf88555zDokWLAKiqqqK5uXmHSoJNmzYxadIkDjzwQN577709H/UIxqokGF10tBAUJJlMTkKRNVRNx2634XSa1QKD9YOsazqJVI54IkdzW5qm5pQ5Js3sy/R5Xfi8Luy7oQrszZUE23bMNrfvmIlUjxnPMSeczoEHH4WzvS83mYhhs9sJDFK0oSSrNLSkqG+IU1sfJ5NrrxjwuPB796xiYGeMlkoCXddJpPLtlQIZEsn8DgZsZuyjj2jYR0nE36fovEyqhc8/e4P6zSuLjx8pG8usg08hECrrl3MZKvrtWjAMcnmZdEZC13W8HidVFSHGjymhuiKEy2UaRlotisOTgf5tyBcUUxjIy8Vqt5Kon+qKMJGwl2jIt1f5qRiGgaqZQoCq6u3z7I52ATsuhx2329Gzf8AAYM0VLcC6DkYrfRYJ9tlnH9asWcPq1auZOnUqsHORAMDj8eDxeIjFYns24hGOJRKMbHRdpyBtqxYoSCqyomKzgSiKOJ32wTMcNAxS6QLxVI7WtjQNzUnSmQIFWUNs9xXw+Zw492CisLeKBJ+sXME9d99KIZfDHwia8V6KTCLehqzIzJ1/Ipd9538HbTwFWaWxOUVdY5za+hiZbIdTtwu/14VNHNiF1EgVCXTdIJXOm5UC8QzxZA5d7/qT53KKpigQ8RON+PB6+m/XOpdJ8PnqN6jb+CEAR3/xStyeQL89/lCwR9dCe2RhJltAljU8bjMacnxNKbn0FlavfJuzz7sc0bH3loqPFPr7t0HVdDJZiXQmj6obeJwOggEPY6pClET8RMN+vN69o6Jke/8AXTMQOvkHuJ0iHrezPW1gz9oF9hRrrmgB1nUwWulzu8HmzZvxeDxFgWBX+P1+kslkX5/OwmJIMAwDWdGQ2w0HMzkZRVbRDQNRtOFying8nkGrFij6CsQypq9AOk8+L2MTBLweF9GwD5flqr5H6LrO00/8nUIuR6SkDEEQ0HWdbDaNrMjomsoH772OLEk4XQMnnhQks5WgriFObUNXYaC8JDjgwsBIxGgXzmIJUxSIJXJFx+4OnA470XZRoKRdFBioz6/XH2bfOV9gyqx5JFpruwgEn77/PKGSaqrGzhr1u+WyrJLOFpAKZmRhaTTAxHGlxcjCtWtW8u9Fd6NpKjVjJzFvwclDPWSLAUY3KLaY5AsKdrtAwOdm8sRyKkqCRCI+IkEPwij/bGiaXmwZUFTdNEVFKAoAAZ+rvV3ArA5wOOxWu4CFhcWg0OfVhM1m67ZioDsURSGZTBIIjOwdFIu9A03TKUgKkqyQycrI7YaDtvYUAr/fNWiT+g5fgVgiR0Nzgth2vgIBn4vykoAV/9WPbNq4lvq6zfgDQQRBQJYkYjGzQkoQBPyBEHa7SG3tRiZNntGvz12QVBqak9Q3drQSdBIGSoPYLLfpLhiGQSYr0RbPEGv3FVDVrqKAQ2wXBcI+ohEz/mywJ9luT4DKsTOLf0/GG9i87h1YB+tXvcKkGUdSPWE/7PbRI/CpikY6WyBfkHGIdiIhHxP3GUt1RYiSqL/4nbV+3Sc8dP8f0DSVWbMP5sh5xw/puC0GDklWyWSl4vea1+OkNOqnujJMNOQjEvHico7eKpLt4wYNw4wbFEUbLodIKNDRLmD5B1hYWAw9fZ6RjB07ljVr1rB161bGjh3b432XLVuGqqpMmTJ0kWAWFjujc7VANieRKyjIkjIkhoOaqpFM54knsjS1pWluTpPOFdA0A5fTjs/noiYU2S1fAYvdI51KmB4EDifZTJpkog0DEO0ikWgZosNBIt5GOpXol+crFBQaihUDpjAgAF6vJQxsj2EYZHMysXimaDaoKF3FarvdVhQESiI+An73sJtoe30Rps1eyKa1b5PLxFm14hnWf7qcidOPZOykA7GLI3OhpKs66ZxELi9hEwRCQQ8zp1YxpjJMecmOkYUb1n3Kg/f+DlVVmLnPgZxzwbdHlVCyt6PqBtlcgUxGQlZ0XE4bfp+bfadXU1oSoCRsinajzXBwe/8AXdPbf0NM/wCfx4XbLeJwiFbcoIWFxbClz7/Gxx57LGvWrOHPf/4zN910007vl8/nufbaaxEEgZNOOqmvT2dh0a/0VC3gcooEAu7BqRboKI9OZmmLZUxfgXSBgqLhsAv4fW4qy0I4rNLyQSMQDCOKIrJUIJWMYQAej5dwpBSbzYYsFRBFkUAw3OfnyOcVGluS1DbGqatPkMmbwoDP66LCEgaKGIZBPi/TlsialQLxLJKsdrmP3SYQDvvafQV8BP2eHRajww2H083kfeYyftqhbN3wARvXvEkhl+azD55nw2evcsj8CwlGKod6mL1C19oXgu3iVsDvZvb0MdRURSgv33lk4cYNq3nwPlMgmDHzAM776hWIoiUQjGQMzJa4TE4il1cQBAj43IwdE6WqPEQ07CMc9Iyq1JXt4wYxAMMoxg0G/W7cLsew8A+wsLCw2B36/Iv8/e9/n7/85S/cdtttTJ06lYsvvniH+7zxxht897vf5cMPP8Tn8/Gd73xnjwZrYdFXdqgWyMtDFk+Yy8nEk2bPdH1jkng6T6Egm6XsXhfRiOUrMJRMmDiN6jHj2bJ5PeFIKaqqEgiayQWGYZDJpBg3fgoTJk7brcfN5WUam1PUNsSpa0yQtYSBbskX5Pb0AVMUKEhKl9ttNoFw0FusFAgFPSN20i2KTiZOP4xxUw6mbtNHfP7ZG+i6hi9YWryPYeg7RC0ONUbHDnF7ZKHP42LG5EpqqqNUlQd3+f0lyxKL/nEniiIzbfpszrcEgn7BbmfQIm1t7bv/Ojq5nEw+L6MZOi6nSHnES/m0AOGQl2DAi8u17b3VDQ1d6V2r6nDF0HUkWUNRVGyCgL29NSDoFXE6RWw2G6Ldtp1/gIGhq8jykA6935Ek08DSPliGzRbDEus6GFxsNhsOh2PAqyT7nG4A8Ne//pVvfvObCIJARUUFsVgMRVE46aSTWLlyJXV1dRiG6cr6j3/8g/PPP78/xz4isdINBo9dVQsMVjyhJCskEnniyRz1zQlisQy5vIwOeN0O/F4XHo9zWPoK7G3pBhs3rEbTNaRC3kw3yOfw+7elG2QyKTweH1//1jXMmj1nl4+Xy8s0tAsD9e3CgE0Q8HmceL1ubDvZZR1uDGS6gSQpRUEglsiSy3edRQuCQDjoaTcb9BEOekdtaa6ua+QyMfzBsva/67zxwj2UVk5iwrTDhjQZQVU0cnkZVSmg6wYOp5vK8hDja0qoLg/h8exei8Smz9fwxmtLOOf8b1lpBnuAIEDILxDw2nE5B76H3TAMDAN0wwDDAEEwF8p2G3abgM1mG/aVPH2l49zBfN1tNgEEAQGGXUvTYKHrpgfMSBVqLfoH6zoYfBwOB4FAgNLS0gETZ/ZIJAB48skn+Z//+R/q6+u7vb2qqoo777yTL33pS3vyNKMGSyQYODqqBSRJIZeXi9UCCJhlfu39fwONpmokUnkSySyNrWmaW1KkswV0HdxOO15fe2zdCJhU7C0igWEYvPn6izz3n4dxuTxc8b0bqK/bzNNP/J36us2mR4EoUj1mPKedeVGPAkE2L9PYnGRrfZz6piS59ooBv9c1ooSBzvSnSCDLanv6gFktkM1JO9wn1C4KlIR9hMM+xFEqCuyKprq1vP/aIwDY7CI1Ew9g0owj8PjCA/7cmqKRK8jk8wqariHa7Xi9TqrKfJSXBqiuKiXgc+/WY+qahs3aaeo3BAEqo3bCIReBYBC324PN1o+vr2GmEBiGjm6Yf7fZBARBaI/9tSHa7dhtNoalyt0fdAgimFUags2GTRCKr8PeToeBubWDvHdjXQeDh2EYaJpGJpMhmUzicrkYO3bsgLz2eywSgJle8Nxzz/Haa69RX1+PpmlUVlZy1FFHceqpp+IawJiwkYYlEvQvw6FawNB1UukC8VSO1rYM9U0JslmJgqziEE2jJp/XNSJ9BfYGkUBRZJ587H4+fP8NAPY/8HBO//LXcDpd6LrOpo1rSacSBIJhJkyc1q1Sns3LNDQl2Vofo6E5tU0Y8LnxelwjUhjozJ6IBIqiFUWBWCJLOlPY4T5Bv7sYSxgNexFHUc/ynmAYBi2N69nw6WskWmsBc5EyZvx+TJp5JL5ASb89l67q7aKAjKrp2GxmxUtpSYCqilAxIcKG6Qmxu98JtVs38uhDd3P+RVdQVT2u38a9NxMOCFSVeaiorMbp3LPvaLMwwEDXjfYqgW275Xa7Gb9ns9mw2wXsNhuGYe4cjsaIwo7XoqMStnOFhCUMdMVaHFqAdR0MFfl8ni1bthAOh6moqOj3x+8XkcCi91giwZ4xXKoFsjmJRDJHW7uvQCKdp1AwjZr8Xhd+n2tU+AqMdpEgHmvhoQf+SEP9FgTBxslfPJcj553Qq4lgJifR2JxiS12MxnZhwGYT8Hldo0IY6MzuiASqqhFP5NrNBjOk0juKAn6fq91TwE8k7MXpGPmflYHEMAxizZvZ8NlrtDVtBMzy5qNO/CaBUFmfHlPXdPIFmXxBMYVVATxuF6VRP1UVQUrC/m79UfrynVBXu4n7/vJr8vkc+8w6iAsvuapPY7boytgKkaqqUsLh3ReLdH0ngkB7JJ/dbv6x2Wzdhg8Y+igTCdorBjqEgY7XouO/LbrHWhxagHUdDCUNDQ1ks1kmT57c7yKmNTOzGPbsqlogGPQMuLrf4SsQS2ZpaEoSi2fI5mUz69ntIOhzUVEaGLUVl6OR9es+4ZF/3EUul8Hr83P+V65g0pSZPR6Tzkk0NpmtBI3NSXJ5GZsN/F43FWWhUSUM9BZN04knc8VYwlQ6z/bSs9frpCTiL0YTjgYBbTARBIGSigmUVEwg3lrL55+9hiIX8HcyOCzk0z16FuiaQV4y2wcURUEQBDxuJ+WlAcZURChpN4J0u/vXH6Chfgv3/eU35PM5xk+YypfPv7xfH39vxW4Hl9OG2+3Z5X23FwQQKPoIuETTZK+jSmBv2ynX9XZhAFMMsIn2YjuBhYWFxXAnEAiQSCRQFAWn09mvj91vM7VPPvmEFStW0NzcDEB5eTlz5sxh1qxZ/fUUFnsJu6oWcLlFfPaB3dlWFY1EKkcilaOpJUVza5p0toCmGXjakxCiEd+I8BWw6J6PP3ibXC7DmJoJXHDRlYQjO+7GKZpBImmWytc2xGlq2VYx4PftncKAruskknna4hli8SyJVJ7tC9I8bocpCrSbDbpdljFdfxEpreHgeeehaUpxQafIeZY/dyfh6Bgm7zOXaNl4MKAgKeQKCrJsJkR43E5KIz6qKsOURnyURP34PP07qehMQ/0W7v3zr8nns4wdN5mLvv4DXK7d8zGw6B7TM0/YwYPAaBcDzMUvRUHAZhNwiWKnCoG9dyFsGAaGbmBgVk+IdnuxlWBvE0ksLCxGNh3VGx3mkf3JHosE//3vf/nJT37Cp59+2u3t++yzDzfffDOnnXbanj6VxShmqKsFdE0nkc6TSORobUvT0Jokk5GQFR2HKBDwuamuCO+1BmqjkdPO+CrhSJR5C76Aw2EulGRVI5bIEU9kaG7N0NSSJJ+XkVUdu03A73NRWR5G2Ism14ZhkMoUaG7L0BrLEU/m0PWuooDbJZp+Au1mg54BXHhamNjt24SXWPNmdFWlpfFzmuo34AtWUj3xMMqrphAJeKiurqQkEqAk6iPgHZzWoabGWu79y6/J5TLUjJ3EJd+4ule73ha9xzBA10FRNQydroKAy15c/HaIAnsz5mu1zYDQ3qliwBIGLCwsRioD+f21RyLBz3/+c2688cbiLpIoipSUmLtxbW1tqKrKJ598whlnnMH111/PDTfcsMcDthgddFctoCgaBsagVAt0Nhtsi2VoaEmSSUvkZcVcDHrdlJYEcDms/qrRQqytmTdff5GTv3iemWPtcHDU0V+kLZ4jlmyjsTlFa1vajHnTNGw2AbfbRTDoxemw021j7ijFMAwSqTzNLan26omusYROp0g0bJanRyM+vB6nNdEebAwDSVHJ5RV0RyUzDv0KLbUf0NbwKZrUSsP6xdilCRx44unsM2vsoEdTLV3yb3JZs1Lnksuuxu3xDurzjzZkVTM9JPIKBVnF67YztsJsN3E6RMROFQKjOm1gN9jegFC0WwaEFhYWFr2lz8aFixcv5gtf+AIA8+fP57rrrmP+/PnFfghZllm+fDm//OUvefnllxEEgWeffZYTTzyx/0Y/AtmbjQuHNInAMMjmZNNlPZGhoSllmg1KCjbA63Hh9zmtsujtGC3GhWvXrOTRh+4mm81w2NwvMGWfuaYoEMsUI95sNjsejwOv24ko2vYqUQDMXbZ4IktTuzAgyWrxNptNoDTqoyQaoCTiw+d1WZPswaZdWM3nZfIFGd0wcDnM1qfqijDlpQFKwn4EJN5Yvph33lqGLEvYbDZ++JPfEOqDuV139PY7QZIKPP/Moxx30ll4vcPLAHe4o2p6MX6yICkYBjhEG163k1DIS3nUTyDgxOuQmDBhAm7P4LdwDFvjwu0NCNu9FywDwoHBMqyzAOs6GEoKhQIbN25k4sSJuN39+1vQZ5HghBNO4MUXX+Tss89m0aJFO50wGobBeeedx7/+9S+OP/54nn/++T0a8EhnbxIJdlUt4HSKiAP4hZLPy+2GalkampMkUjmyeRkB8Hic+D1OPB6nteHSAyNdJMjmJJYsfopXlz2Foqh4AhVMmvUFRKcf0W7D43bgdjsR99KKEU3TaYtlaGxJ0dKaRlG14m12u43y0gAVZUEqSryIoq1PEYgWfcQwUFWdXF4mX5DQdAOnQ8TjcTKmIkRZSdBMhwh5ul385LIZ3nhtCZJU4JTTLij++9rVHzNp8kxER98E0Z6+E3K5rCUI7CaabhRTJvJ5Gd0Au13A63bi97spLwkQDnoI+N0EAm5cTvN9UxSZVLyZcePH9/vEsDcMN5GgswGhYOsaW2gxcFiLQwuwroOhZFiKBNFolGQyyZYtWxgzZkyP962trWXcuHGEw2FisVifBjpaGO0igapqSLI6JNUCXRIImpPE41kyOQnDMHum/b72aDprztBrRppIkMlJxOJZ2uJZauuaefvVJ2hpWANARc1sZh5wIj6fB/sgxGQOV1RVo7k1TXNripa2DJq2zezG4bBTURqkojxIScRXLFHfnQhEi76jKmZJeS6voOs6ot2G1+ukoixERWmAkqifSMiH2EezzMaGrfzx9usJhiLMnX8Shxy+AKdz9z7bO/tOaGtt4p67buHQwxey8Pgv9Wl8ox3dgEKHIFCQUTUdmyCYorXXRWk0QDTsIeA3RYGevD0skWBHA0J7p1YCq9JpcLAWhxZgXQdDyUCKBH32JJBlmXA4vEuBAKCmpoZIJIIsy7u873Dl/fff5x//+AdLly5l48aN6LrOvvvuy5VXXsmFF1441MMbMobSW0CRVRLpHIlknobmJG1tGdI5M4HA3Z5AUBOKYLdUgVFLKlMglsjRFs9Q35Qklc6bk/BsjA0rn0HKxXA6HOxz8EmMm3zwUA93yJBllabWFM0tKVpj2S5pBG6Xw6wWKAsSCXutyfUgoqlacQdZ1TTsNjtej4MJY0uoLA8SjfgpCftwiP2zEEsl4wRDEVLJOM/+52Feeem/HDnvRA4/8pg98gyItTVzz923kkol+Pijdzhq/ok49/IUAwOQJKX4/sqqjiCAy+XA53EypipCNOwj4HMTDLjxeZ17XYtTX+jsM2AThL3agPCGG27gxhtv5Oijj+bll1/uctsll1zCAw88wMUXX8z9998/JOPbm3n55ZdZuHAhwA7pP/fffz9f+9rXGD9+PJs2bRqC0Q0co/nc9kb6LBJMmjSJNWvWIMvyLnMZJUkik8kwY8aMvj7dkPPrX/+apUuXctZZZ3HFFVeQyWS47777+MpXvsL69ev52c9+NtRDHDR2VS0QcLsH5MdaUzWS6TzxRI7mtjTNLSkyWQlF03CIdvxel5VAMIoxgFQ6b4oCsTQNjUmS2QIFyYx3czpE3G6RoD9E2plnrZLB4wtx4JFnESkdO7SDHwLyBZmmljRNLUniiVyX23xeZ7swECIYGJjPq8WO6JreXlouIysadpsNj9tJTVWEyoogpZEAkbAXl7Pf0om7MG3Gflx9za/54L3XWb7sGWKxFl5Y/BivvvwMhx91HPMXnrLbEYXxWAt/u/tXpJJxysqq+Po3f7xXCgSSolFo94soKOaumtsh4vE4GFtTQmnUT9DvJuBzE/C7hk2Z/khgewNCs5XA3m/CQMdiu4OHH36Y8847r8djTjnlFJ599tni3zdu3MiECRP2eCwWFn3h/vvvZ9OmTSxYsIAFCxYM9XAsRgl9nolccMEF/O///i9///vf+cY3vtHjfR988EEUReGCCy7o8X7Dmauuuor777+/SynHt7/9bQ444ABuvvlmrrrqKiKRyBCOcOAYqmoBQ9dJpgvEkzla2zI0NCfIZiUKioZoA7/PTVlpwHSetxh16AYkUzliiaz5/rckSWckpPbMd6fTgcctEgp4sW1Xfh2KVHHQUWcTDFfi8viHYvhDQiYrFY0HU+l8l9uCAXexYsDv2/sWcUOBrhnkJYl8XkFWVLO03O2ioixIdUWEkoiPkogft2tgRIHuEB0ODjl8AQcfMo+PPnybV176Ly3N9ax4+xUWHHtqj8fqus7Gz9eQTiUJR8oIh0u498+/IpFoo7S0gku/dQ3+QGiQzmTo0HSDbE4iV5CRJBXDMHA67HjcTirKQ5RFAwQDpodAwOveaz1P9ojuDAhF+6AYEN533309igT19fXD3l+rqqqK6dOnU1VVNdRDsdiOUCjE9OnTe1WJ3Vvuv/9+XnnlFQBLJLDoN/o8M7n66qt59tlnueqqq3A4HFx88cXd3u/vf/87V111FfPmzePqq6/u80CHmiOPPHKHf/N4PHzxi1/k9ttvZ82aNRx++OFDMLKBoyApFOQM2dy2agG73YbTaR+YagHDIJ2RiCfNnvKGpiSpTJ68pGAXBHxeF9GIb8B22SyGFk03SCTztCUytLWlzVjKrIwsKyAIuJ0OPG4HkZAXYbtJoiIXWLXiv0yacSShaDUAZVVThuI0BhXDMEhlCjQ1m8JANid1uT0S8lJRHqS8NIi3h/5mi/7B0A0KkkKuYH5nCoDb7aS0JMCY8jDRqJfSiH9YvBc2u50DDz6S/Q88nM8+eR9FkXE4zHHpus6yF5/moDlHEYmWAfDJyhU8/cTfqa/bhKqq2Gx2VFXB5wtQM3YSl37zGoLB8BCe0cCj6QZtiSzZrETQ76Ek7Ke81E8w4DWrBPxunNbv0x6xvQGhaLdhs9kQhIHNAwcoLS0ln8/z4osvsnXrVsaO7b4C7e9//zuapjFhwoRhW1J9yy23cMsttwz1MCy64YwzzuCMM84Y6mFYWOySXv2a/fznP+/23+fNm8fKlSu59NJL+dnPfsaCBQsYM2YMgiBQW1vLK6+8wpYtWwiFQsybN49f/vKX/L//9//69QSGmvr6egDKysqGeCT9TyqVJyfruF2OAasWyOYkEskc8XiWuqYEyUyBXE5GEMDrcRIKeKgoC1oJBKMQVTOIJ7PE4llaY2kamlPkchKyom3r3fU6KYn4euzVTSdb+OD1R8mmY6QSTcw76duDngk/mBiGQTyZK1YMFApK8TZBECiJ+KgoC1JeFrQEtQGmQxTIF5RihYvb6SAS9FJdGaIkGqA04sPvHb7GnzabjVmz53T5t88+eZ+XXniSl5c+zf4HHkFV9Tgee+SvFHI5fIEgPtFBJp0il00jSwXO/cq3CYWjQ3QGA49uGLTFs2SyEqVRPwfOGktNVaRHY0GL3tNhQAgCgg1Eu31IDAh9Ph+nnHIKDzzwAA888ADXXXddt/e77777ALPv/4Ybbhi08VlYWFgMJr2aSXf0a23/59ZbbyWVSmEYBlu2bOHBBx/k1ltv5ZZbbuHBBx9k8+bNGIZBMpnklltu6dLz1RdyuRzPPfccN910E2eeeSbjx48v/oj09os6nU5zww03MHv2bPx+P6FQiEMOOYTf/va3u22s+Omnn/LEE09w+OGHM3ny5D6c0fDGwIzc8npc/RZVmC8oNDQm+XRtPUtf/Yznlq7kxVc/Y8WqLSRSeXweJ+PGRBk/JkpZ1I/H7bAEglGCouo0taX5bH0Dy99axxPPvsezS1ey/O11rF7fiCSrBAJuqipCVFaEiYR9uN09m3k11n7Gm0vvJZuO4fYGOeDwM0alQKDrOi1taVatrmPZa6t55/2NbN7aRqGgYLcJVJQF2W+fGo6ZN4M5B0xg7JioJRAMBIaBJCnEE1kamhI0NifJFxQCfhf7z6zh2LkzOfXE/Tn1+P04ePZ4JoyJDmuBYGeEwiVMmToLXdd5f8VrZktBrBV/IITT6cJmsxEKRygprcTpcvPSkifRdX3XDzzC0A2D1liGzbUxnE47Rx0yheOP3oepkyosgWAPMQyzakDTdDBMV3SHw47TISKK9vbqgcH/9f/a174GmOXb3YV/vfbaa6xdu5ZJkyYxf/78Xj3myy+/zPnnn8+4ceNwu92EQiEOPfRQfv3rXxeTpHbGc889x/HHH084HMbv97P//vvz61//GkVRejzukksuQRAELrnkkh1uSyaTLFq0iAsvvJDZs2cTjUZxu92MHz+eCy64gLfeemunj3vDDTcgCEKxpH3p0qWceuqplJWV4Xa7mTlzJjfeeCOFQmGXr8uuxm0YBnfffTeHHnoooVCIYDDI3Llzeeihh3Z6/IIFC4prAkVR+O1vf8ucOXMIh8MIgrCDweOGDRu48sormTlzJn6/H6/Xy8yZM/ne977Hli1behzr6tWrufDCC6msrMTtdjNp0iSuvPJKmpqaejzu/vvvRxCEHj0sstkst99+O0cffTSlpaW4XC5qamo4+uij+e1vf1t8jo7H6mg1uPHGG4vroo4/3VW7fPDBB1x66aVMnjwZr9dbvLauu+46Wltbexz/W2+9xemnn05paSkej4fp06dz3XXXkclkejyut7S1tfHzn/+cww47rHhtTpgwgRNPPJG7776bZDLZ5f7Nzc3ce++9nHnmmcycOZNQKITH42HKlCl84xvf4JNPPunx+Z5//nnOPPNMampqcDqdBINBJk2axAknnMBtt92201S+QqHAH/7wh+J75HQ6qays5PTTT2fx4sU7fb58Ps9tt93GEUccQSQSweFwUFZWxj777MPFF1/M448/vvsv2gDRq1nk/Pnzh4Wx1TvvvMMXvvCFPh+/efNmFixYUPzAeL1eJElixYoVrFixgoceeoilS5f2ylsglUpx9tlnY7PZ+POf/9znMY12ZFk1KwWSORqbk7TFs2RzZua32yXi8zqJRnzYhsH1ZdG/SLJKPGl6CjS1pGhpS5PLmS7uNpuA2+0iGPCYnhK7+f4bhs66Va+w4dPXAIiWj+eAI87E5R49/gOqptPali6+dqq6bREmijbKS01/gdKoH7tl1jlg6JpBLi8Vv7dcThG/z8nkCeWUl5iVAsGgZ1SJmTVjJ/K1y39E7ZbPefLx+9m6ZQOCYKOlpYFwOIrX5wcEfP4ADoeD+rrNbNq4lkmTR645cWd0A2LxLOlsgWjEy5EzJzOupgSP2zHUQxvRbG9AaMYW9p8BYX8wf/58Jk+ezIYNG3j11Vd3EAI6VxHsasyqqvLtb3+be+65p/hvfr+fbDbLu+++y7vvvsu9997L888/z/jx43c4fntDxXA4zKeffso111zDM888w1FHHdWnc/y///u/Lo/r95u/m1u2bGHLli0sWrSI3/3ud1x11VU9Ps5vfvMbrrnmGsDss5dlmdWrV3PDDTfwyiuv8MILL+xRJN7555/PI488YoqSoRCJRILXX3+d119/naVLl/K3v/1tp+9BoVBgwYIFvPHGG4iiSCAQ2OE+f/3rX7niiiuKgovLZQqgq1evZvXq1dx333089thjHH/88Tscu3jxYk4//XQkyWzx8/v9NDQ08Kc//YnHH3+cm2++uc/n/f7773P66aezdetWgOL519fXU1dXx/Lly7Hb7Xzve9/D4/FQUVFBLBZDURR8Pl/x/exg+/fgZz/7Gb/4xS+KIpjX60VRFD7++GM+/vhj7r33Xp555hkOPPDAHcZ27733ctlllxVF4VAoxKZNm7j11lt58sknufzyy/t83gBLlizhvPPOIx6PAyCKIn6/n82bN7N582aWLFlSXIh38OMf/5gHHnig+PdgMIiqqmzYsIENGzbwj3/8g4ceeoizzjprh+f7+c9/3sV43uv1YhgGGzduZOPGjbzwwgvMmTNnB5+HdevWccopp7Bu3TrArOIMBoM0NTXx1FNP8dRTT/Htb3+bO++8s8tx6XSaefPm8dFHHxWP67i2W1tb+eyzz3jllVe6HetQ0KuZ5csvv8yyZcv65c+eEolEOPbYY/nRj37Eww8/TGVlZa+O0zSNU089lU2bNlFVVcULL7xANpsll8uxaNEiAoEAH3zwQa/iDPP5PKeeeipr165l0aJF7Lfffnt6WqMGVdFobUuzfmMTr7+7nmdfXMmSVz7lzfc2UNcYxy4KVFWGmVATpbIsSMDntgSCUUJBVqlvSrBqTR0vvvYZTz73Ac8tXcUb765n45ZWNN0gEvZRVRGmojxMKOgx+3d38/1XVZn3Xl1UFAgmTDuMQ47+yqgQCBRFo64hzvsfb+alVz/jw1VbaWhKoqo6LqfI2DFR5hwwgWPmzmS/fWqoKAtaAsEAoCoaiWSOhqYETa1JNN1gfE0J8w6dwheP24/TTzyQIw6ayOTxpYRGmUDQmZpxk5i34At4vX68XvPzlc2mu1QNiA4nqqqSTiWGaJT9h25AWzzLpq1tOBw2Dj94EifMn8X0KZUjUiAwDKNoNjxkf3IymaxEOlMgm5MoFBQURSv+KbQbImdzUq/+dLe735903n2/9957u9yWzWZ59NFHsdls3e7Qb88Pf/hD7rnnHioqKrjzzjtpa2sjnU6Tz+dZtmwZBx54IGvWrOHMM8/coRLn6aefLi7kzz77bLZs2UI8HieVSnHHHXfw1ltvcdddd/XpHCsrK/n+97/PW2+9RTweL47p888/57vf/S4AP/jBD/jggw92+hgfffQR1157LT/+8Y9paGggHo+TSCSKLcXLli3rsnDbXZ588kkeffRRfvGLXxCPx4nFYjQ1NfE///M/gCnW/PGPf9zp8XfccQcff/wx9913H6lUilgsRmtra3G+3nlBe+2117Jp0yby+TzZbJbVq1dz9tlnk0ql+PKXv7xDRUFtbS3nnnsukiSx33778fbbb5NOp8lmszz33HPY7XZ+8IMf9Om8t27dyoknnlj0xFi0aBHpdJpYLEY+n2flypXccMMNxRbnc889l8bGxqJv2g9/+EMaGxu7/OnsrfG73/2On//85/j9fm655RYaGhqKa6EVK1ZwzDHH0NDQwGmnnbZDZcD777/PN7/5TXRdZ8GCBXz22WckEgkymQwPPfQQjY2NO21P7w0ffPABX/rSl4jH48yaNYtnn32WXC5HPB4vCmtXX331DoLPxIkTue666/jggw/IZDIkk0kkSWLVqlVceOGFSJLExRdfXGwP72Dz5s3Fz9gPfvAD6urqyGazpNNpEokEr776Kt/5znd2eL5EIsEJJ5zAunXrOOaYY1i+fDn5fJ5EIkEikeD222/H7/dz11138fvf/77Lsb///e/56KOPiEajPP744+TzeeLxOJIkUVdXx9///ndOOOGEPr+G/c2IqkedN2/eDmUf1157ba+Ovf/++1m5ciUAjz/+OEcccQRgKnTnnnsuuq5zwQUX8Nxzz7F06VKOPfbYbh9HlmXOOOMMXnvtNR566CG+9KUv7cEZjXx0TSeRzpNI5GiNZWhoMRMIZEVHtAv4faajen/lfFsMH/J5hbZEllgiS2NLkrZYlnxBRtcN7HYbXreDaMTX787edruIINix2UVmH3Iq1eP37dfHH2wKkkJza5qm5iSxRJbOc2CP22EmEpSHCAc9w2a3bdRhGOQLCtmcjKKo2G02AgEXk8aPoao8RHnJ8DAbHAoCwTBOpwu320MoFCGfz3ZZqKmKbO7UjWDTQt2ARDJHMp0nEvRy2EETmTSudMS3FOQLClOO+OlQD6Nf2fzurfgGuIXn4osv5mc/+xmPPfYYf/rTn4o7s48++iiZTIbjjz+esWPHsmHDhp0+xqpVq/jDH/6A1+vlhRdeYPbs2cXbHA4HCxYs4JVXXmGfffbh/fff5+mnn+6yO/qTn/wEgKOPPppFixYV2+g8Hg/f+c53sNvtfOtb3+rT+XV3nCAITJw4kd/97neoqsodd9zBHXfc0aUKojOJRIKf/exnXH/99cV/CwaD3HjjjaxatYonnniChx9+mEsvvbRPY0wmk1x//fVdfCHKysr44x//SCKR4B//+Ac33ngjl19+eZfUsQ4ymQxPP/00p566LbGlpKQEMOfxHWLD3XffvcMYp0+fzqOPPsqXvvQlnn76aW6//XZ+97vfFW//5S9/SSqVoqSkhBdeeIHy8nLAXE+cdNJJPPfccxx00EF9Ou///d//pbW1lZKSEl5//fUuC3yXy8W+++7Lvvv2bc7T2trKT3/6UwRB4N///neXdY7dbufggw/m+eef5/DDD+e9997jnnvu4Xvf+17xPtdddx2qqjJt2jSeffZZPB4PYF7P5557LuFwmFNOOaVPYwMzRa5QKDB16lRef/11QqFtSTler5c5c+YwZ86cHY7rLoLeZrMxa9Ys/vGPf5BIJHjmmWe49957u1xPb7/9NrquM23aNH772992OT4UCjF37lzmzp27w2PffPPNbNq0iWOOOYbnn38eURS7HPf973+fCRMmcOaZZ3LTTTdxxRVXFO/zxhtvAKaYc+aZZ3YZb3V1NV/96lf56le/2tuXbMAZUSu3PSlb6lA0Fy5cWBQIOnPeeecxceJEwHSu7Q5VVTnnnHNYsmQJ99xzzy5zdEcjhq6TTObYtLWV9z/exLPLVrJk2Scsf3sdazY0oqkGJdEAE2qi1FRFCAc9lkAwSsjmZbbUxfjwk1qeW7aKfz//IUteWcXbH3xOfWMCm02gNOqnqjJMeVkQf8DTrwKBYZg7LYJgY7/DvsQRx106YgWCXF5m45ZW3nrvc15+fQ2frqmnLW4KBH6fi8kTyjjykMnMP2IaM6ZWmYkOlkDQr+iaQSZToKk5SX1TglxBIRr2cugBEzn5mH350kkHccRBE5lQE91rBQKACROnUT1mPJlMCrso4g+EsNvNCY9hGGQyKarHjGfCxGlDPNLdRzcglsixubYNATj0wImcsGAWs6ZXj3iBwKLvjB07luOOO65YOdBBR6tBbxa+f/vb3zAMg1NOOaWLQNCZQCBQFAY6Ryp+/PHHfPrpp4C5MOvOZ+eyyy7r1wi9znQs9F577bWd3sflcvHDH/6w29s6Ns8+/vjjPo/B4/Hs9PE7qhVisRgvvPBCt/eZNWtWF4GgM8899xx1dXVUVFQUPSi646KLLgK6vjeGYfDII48AptjSIRB0Zt999+XLX/7yTh93Z2Sz2eJjX3vttTtN1+grDz30ELlcjjlz5ux0I1QURc4//3yg63knEoni33/0ox8VBYLOnHjiid2ur3rDunXritfbL3/5yy4CwZ6ys+s5HA4DFKtAeoNhGMUKo6uvvrqLQNCZ008/nWAwSGtrK++9994Oz9nQ0LA7pzBkjKhKgr6Sy+V4/fXXATj55JO7vY8gCJx00kncddddLFmyZIfbdV3nK1/5Ck899RR33nlnj18sowoDstmOWMIMDU0pEuk8hYKMTRDwelyEQx7crpFXimnRM5Ki0dKSoqUtQ31ThkQ6T75gmns6RDset4OykiC2AS5313WdtStfQi5kmX3oaQiCgMPpxuHccfdguGIYBpmsVEwkSGe6mjqFgmaKR0VZcMB3yfZmVEUjk5PIF2QEwONxMX5sCTWVEcpLA4RD3lHbOtBXbDYbp515EffcfSvxWAs+XwDR4URTFTKZFB6Pj9POvGhEGYYaQCKZJ5HKEQp4OGT/8UwcXzbqPnset4P1b/a9N7onjI7yeMFW9BmwtfsMCJ3+v78ZLMHua1/7GkuWLOHee+/l0ksvZf369bz66quEw+EuO/47o2NB8txzz/XYFttR0r158+biv61YsQIwF2zz5s3r9jibzcaCBQt6NPHric8//5w777yTZcuWsWHDBtLp9A4tD7W1tTs9ftasWfj9fjRN2+G26mozhnhnhm+9Yc6cOQSDwW5vmzp1KjU1NdTW1rJixYpuxYCe/Bo63pt4PE5VVdVO79dhZt75vdm4cWPxvI455pidHnvMMcfw8MMP7/T27lixYkXRH2FnAsee0HHeq1at6vGazOfzQNfzfv/994vXx67O+80339ztsXXssNvt9p2u03rio48+4s9//jOvvfYamzZtIpPJ7NCatP31fOihh1JaWkpDQwOHHXYY3/rWtzjuuOOYPn36Tr+7Pv300+L7f8kll/T4u9f5s33YYYcB8MUvfpGHH36YP/3pT7S0tHDuuecyd+5cSktLd/ucB4M9FgleeuklFi1axMcff0w8Hu/RcVUQhB7LswaKzz77rHhx91Sm03FbY2MjsViMaHRbpNMPf/hDHnnkEebPn08gEOAf//hHl2OPPPJIJk2aNACjHzq21MVY+3mMgqyQzbdPqt0Ogj4XFaUBazI9CkllCrS0pWloMndXpUIe3TBAcOLxiAT9IWz2wXvnZSnHh28+QVvTRgDGTj6ISGn/qusDhWEYJFP5ojCQy29LTxEEiIR9RWHAEtkGiE5tBLKs4BDt+P3b2ggqSgJ4PNZrvytmzZ7DN751LU8/8Xfq6zaRzaYRRQfjxk/htDMv2iFCcbhiAMlUnngiRzDgYc5+45g0vhyfb3SJAx0IgtB/i2rDfP0wDAxM8RYDbHZbuwGhbVgZEO4pZ5xxBpFIhNdff521a9cWq1EvuOCCbsvbt6ej/zmTyfTK9T2XyxX/u7m5GaDoar8zampqdvm43fHvf/+b888/v2i6B2argNvtRhAEZFku9oHvjO6MADvo2F1VVbVP4wN2WSUxZswYamtri6/V9nS3w99Bx3sjy/Iukwhg26IZ6PJ8PY2xL+9NY2Nj8b+7M7LcUzrOO5/PdzmnndHdNQn9f96w7dxLS0vx+Xy7deyf/vQnvvvd7xbXeR1mgB2fnXw+TyqV2uF6DofDPPzww1xwwQV88sknXHnllYDZMjB//nzOOecczj33XByObXOEzr4GLS0tvRpf59fxggsu4J133uGPf/wjixYtYtGiRQBMmTKFE044gUsvvZSDDz54t85/IOmzSKCqKhdddFGxNKY3ZjJD9ePR+U3t6eLufFt9fX0XkeD9998HYPny5SxfvnyHY++7775uRQJJkrp8EadSKcAsK9qT9omBJpvNsrm2mdqGGNUVYULlPmzFt89AU6WeDrcYIWi6QSyRpS2Wob4pQSyRQyooCAJ43C7KIh5sog3d6LhWBy/mLBlv5L3XHiOfSyKKTvY79IuUllUDO+5cDBd03SCWyNHYkqapJU1B2jZJMtsxfFSWBago9ZumjUWG7zkB2IThPb7O6JpOvqCQy0vouoHT5aAs6qGmsorSEh/RiB+xKHTpqNZ3Wa+YPnM2V//kV2xc/ynpdJJQpJTxE6Zis9mG/WtoAJl0gXgqT8DnYr+Z5YwfU9ouDmjkO03iRgqappjzLkPftqu/Bxjt/2O0qwHdzeiE9v8xo9XAZgO7vUMYMND1gTUVHCg676B37IyLosh5553HXXfdxV//+tfiZP6iiy4q3qfzLrqmaTv8HczS6R//+Me9GkfHMZ0XO93t1G8/bsMwdrhfx5x8+9va2tq45JJLkCSJhQsXct1113HooYd2KR9funQpJ5544g7n2N1zdhd92t3r0Fs6ryV6OnZn59fx7z29dh3ixYknnsgzzzzTq3F1957rur7T5+jpNejueuvu33fntes4757G1HHe3/zmN7njjjt69bjbX5M7G1vH7Ts7t13R22t+ez777DO+973voes6X/7yl7n66qvZf//9cTq3iaP33nsvl19+ebefk4ULF7J+/Xr+/e9/89JLL/Hmm2+ybt06/vOf//Cf//yHW2+9lWeffba4PuyoLgGKLSu9ofPz/va3v+Xb3/42jz32GK+99hpvvfUW69evZ/369dx5551cddVV3H777b1+DTo+h7lcrtevXW+FmD6LBL/61a+KX5rz5s3jxBNPpKKiYqf9GUNJOp0u/rfX693p/Trf1vkYYIds1d5yyy23dImaGWm4nWZMocXooZBXaUlkaG1NUduYJJcroKg6DocNj9tFyO9BaFeEhmpxWLtpJSvffRZdV/H6IsyZdzaBUNmQjGVXaJpOazxLY3OaptYMirLtNbPbbZSX+KksD1Be4kMUh68wOJJRVJVcXqHQ0UbgdjF2TAlV5UHKogGCwZHTmjKcsdlsTJhkeg/YxeH/u2AAmUyBeDKP3+tk9oxqJowtwz9KKwd6omPpZRgUqwGKN7RrZp1FAFu7ENCxuSO039ix19N5Uj9aufjii7nrrrv4wx/+gCzL7Lvvvt0ap3VHZWUlTU1NrFq1areft2MXvKWlBUmSdlpNsL1be2947rnnSKVSRCIRnnrqqW7nxL3ZXR9oemp1gG3n3uHyvzt0lNrvyXsD5hinTevei6Uv703nFoDNmzczffr03X6M3jx+h4n77tD5da6rq9tp5XRdXV2fxtbR9tHS0kI2m+31Ivbxxx9H0zRmzpzJP//5z27L/ztXaHSHz+fjK1/5Cl/5ylcA8xz++c9/cuONN/LJJ5/w3e9+l8ceewzo+h6tXLmy1yLB9kyZMqVovK/rOu+88w6/+c1veOqpp/jDH/7AwoULB6TlZHfp84r+gQceQBAEfvrTn+5R5MVo5yc/+UmXKJRUKsXYsWPx+Xy7XVIz2IiiE8HmQBT3vgnVaMIA4okcza0p6poSNLWkyeclDMDtduLz+XE67MUoQr3joE5oxuAtbteteoX1n5jVOmVVU9n/8NNxOD1ow2iTSlU1WtoyNLUkaWnLoGnb1HOHw055aYCKshAlEV+XiMLhdA59YTCvgx4pthFIKIqKaLfj97uZMaWCCquNYFAY7r8LyUyeWDyH3+fiwNmTmDy+jGBwR7OtkYqiyEj5NAg2hE4TY6O9JKBjQ7bzzqy5+Ac6fANMFQCBriLA7iz8h3NFZG/pvLDofD6HHXYYs2fPLi6qLr300i63b//fnf9+1FFH8dFHH/Hss8+Sz+d3yK7viUMPPRQwd37ffPPNbk3mdF3nlVdeAcz3a/v3YZu40/W2jkXc9OnTd9oy8NJLL3V7jrDttdr+cXvz372hY9zvvfceuVyu2zGuX7++KCIceuihXZ6j43ibzbbT5547dy5/+MMfqKur48033+zWwX5nTJkyhWg0SiwWY/ny5Rx//PHd3q/zxuLOXsPtbzvssMNwOp3Issyzzz7LPvvs0+txdTxOd9dCB3PnzuXpp5/m7bffpra2drdaGg455BBsNhu6rrN8+XKmTp3a7f16Ou+e6HgPNE1jyZIlvTZ+7Lie999//y5tAZ3p6XrujnHjxnHttdeSyWS4+eabefHFF4vH7b///gSDQVKpFP/617+KFTd7gt1u56ijjuLwww9n0qRJbNmyhaVLl/bK+6TjeJvNhtfr7VUr1O7QZ6ehrVu3IghCryMIh5LOXzK5HsoKO9/WU7/V7uByuQgGg13+WFgMNJKiUdeY4INVW/nv8x/x3xc/5tV31rN5axt2m0B5aZCqijCRkNcsex9Gu0HRsnEINhuTZ83j4Hnn4nAOj4m9LKvU1sd576PNvPTaaj76ZCuNzSk0TcftEhlXE+WQAyew8KgZzJ5ZQ3lpoItAYLFn6JpOJp0vphHkCwolET+HHjiJk47Zl9NPOpDD2tMILIFg7yWVKbBxaxuSrLH/PmM4Yf4+HDh73KgQCAzDQNU0JFmhUFDQDaO9vFhH0wx0zSiKAjbB9AlwiHacDhGnU+z6/w4RUbQj2m3Y7TZso8xToL/41a9+xdVXX83VV19d3GnsDZdddhmCIJBIJPjRj37U430VReniW7Dffvsxc+ZMwIxb666k/957793lbnt3dLjGr127lkKhsMPtH374If/85z93+3H7m3w+v0MsXQc33XQTANFodKeL9J449dRTizvX3/3ud3tcF0BXA0ZBEDjnnHMAMz6xtbV1h/t/+umnxZ3n3cHr9RZT02699Va2bt3a62M71haJRGKn9/nqV7+Kx+NB0zSuuOKKXbaydH6scDjMCSecAMBtt93W7bXz4osvFg0Id5cpU6Ywf/58wIyB7GjN3hUd1/PKlSu7bXt/7rnndloJ3rkVvDs6WnA6CwuiKBbTTR544IEeE0BgR/POnp7TbrcX2ySGi/ja5xlsWVkZwWCwx/L94UKH0yr0XArT+bbOx1hYjARSmQIbNrfw2jvreWrxBzz/8ie8t3Iz8Uwen9dJdUWIivIQfr97wBMJdhdV3dbnVVIxkfknf4dp+y5AEIZunIZhkM4U2LillXfe38hLr61m1eo6WtrS6LqB1+Nk4vhSjpgziaOPnM4+06opifix2axJdn+hKCrxZI6GpgTNrSl0AyaMLWX+YdM59bj9+OJxs9lv5hgqy4KdfAYs9kZSWVMcKMgqs2eM4fj5MzlovwmEQsN/jtIZTdORZZV8QSabk0im8ySTORLJHOl0AamgousgijZsgoBobxcBHHacTntRAHA6RRwOO6Jox263dTEWtISA3nPyySdz2223cdttt+1WafsBBxxQzJi/++67Ofvss/nwww+LCxlN0/joo4/4xS9+weTJk/nwww+7HH/zzWYqxbJly7jggguKgkChUODuu+/mf/7nf4pxarvDCSecgM1mIxaLceGFFxbnvbIs8+ijj3LCCSf02ybZnhAKhfjFL37BLbfcUmz/bW1t5bvf/W7RRPL666/v086p2+3mzjvvRBAE3n//fY466iief/75Lv3mGzdu5M9//jOHHnood955Z5fjf/KTnxAIBGhtbeX4448vplEYhsGSJUs4+eST+7w2uvnmmyktLaWtrY2jjjqKRx99tGgyKEkSH3/8MT/60Y948MEHuxzXYbz+7LPP7nSdU1lZya233grAM888w/HHH8/rr79eFAsMw2D16tXcfvvt7Lvvvvz3v//tcvwvfvEL7HY7q1ev5pRTTmHNmjWAWfHyr3/9i/PPP79P12QHv//973G73axbt46jjjqKxYsXF83wc7kcb7/9Nt/61rd48cUXi8ecdNJJAHzyySdcccUVxUV5Npvlz3/+M1/+8pcpKSnp9vl+9atfcfLJJ/Pggw92EdwkSeLRRx/lN7/5DQBf+MIXuhx3/fXXM3nyZFRV5aSTTuL222/vYmKYTCZZvHgxF1988Q7pJIcddhhXXXUVL7/8chcjxfr6eq688krWr1/f7XMOFX1uN5g/fz4PP/wwtbW1fXazHCxmzpxZLJNZtWrVTuM1OvqTKisru5gWWlgMRzTdoDWeoaU1xdb6OG3xLIV200Gvx0VpxI/dMTzUyJ6o3fghaz5eymELL8EfNL/Mvf7IkIxFllVaYxlaYxnaYhkkuas7c9DvpqIsSHlZEL/PZU22+5tObQSyouJobyOYNqGM8vIQlSUB3G6rSsBiG+lsgbZ4Drfbwb7TxzB5YhnR8PBt5dN1HU030DS9vQrA6LRTLGC3CWaptCjgdjpwOGw4HQ5sdrMyoGPnX1FkNubiRRHAYvjxm9/8BsMw+N3vfsdjjz3GY489htvtxufzkUwmu7j/b/9bcsYZZ/DTn/6Um2++mUceeYRHHnmESCRCOp1GVVXmzZvH3LlzueWWW3ZrTFOnTuVHP/oRv/rVr3jiiSd44oknCIVC5HI5FEVh4sSJ3HTTTVx44YX98hr0ldNPP51CocD//u//cv311xMMBkkkEkWR5aKLLuKqq67ao8d/8MEHufzyy/nwww856aSTEEWRUChEJpPpsuP7pS99qcux48aN4+GHH+ass87iww8/5JBDDiEQCKCqKvl8nqqqKm6//fbijvPuUFNTw/PPP89pp53G1q1bOffcc7Hb7Tuc///93/91Oe7iiy/mt7/9LevXr2fcuHGUlZUVBZTXXnutuE676qqrkCSJn/zkJyxbtoy5c+fidDoJBAKkUqkuCXXbX5Nz5szhzjvv5Fvf+hYvvfQSM2bMIBQKUSgUkCSJGTNmcPnll3dpsd4dDjjgAJ566inOOeec4lrN4XDg9/uJx+PF+3UIAwDHHnss5513HosWLeKuu+7irrvuIhwOk06n0TSNgw8+mEsuuaSYXNAZXddZvHgxixcvBszKAY/HQzweL77OM2fO3MFEMBqN8sILL3DGGWfw0UcfFSuNwuEwuq53qYKYMmVKl2MTiQR//OMf+eMf/1hMYVAUpYtg8P3vf79YtTHU9FkkuPbaa3nyySe55ppr+pzTOlh4vV6OOuooXn31VRYvXtxt6ZdhGDz//PMAw+bNsbDYnnxeoSmWprk5yZb6OJlsAUXVcDrseDwuwkFv0XRwuKNrKp99uIQt698DYOuG95h54OB+9nTdIJHMtQsDaVLpriV0NptANOKjNOqnvDQ4aBndexO6ppPLSWTzEroOLpeD0oifsWOilJcFKI0ErCoBix3I5CRaY1ncbpF9plYxZWIZ0Ujv+74HCsMw0HQdXTNQi0KAjmkLaCAgYBfN8n6nKOL0mlUAomjHZhPMRb9NwG639ShC9pA2bTFMsNvt/N///R8XXXQRd999N6+88gq1tbUkk0kikQjTpk3j+OOP5/TTT2f//fff4fibbrqJI444gttvv50VK1YgSRIzZ87kwgsv5Ac/+EGx2mB3ufXWW5k1axZ/+tOfWLlyJYqiMGXKFM444wx+/OMf88EHH+zpqfcLDz/8MAsWLOBvf/sba9aswefzMXv2bL797W/z1a9+dY8f/8ILL+SYY47hzjvvZPHixaxfv55EIoHf72fmzJnMnTuX008/naOPPnqHY0855RTef/99fvGLX/DSSy+RTCapqqrii1/8Itdddx2fffZZn8d10EEH8dlnn3HnnXfy5JNPsnr1arLZLDU1NUyePJnTTjuNCy64oMsxU6dOZdmyZdxyyy28/fbbtLW1FUWo7aMof/SjH3HGGWdw5513snTpUjZt2kQikSAYDDJlyhQWLlzI6aefzuGHH77D2C6//HJmz57NLbfcwuuvv04ul2P8+PGcccYZxXXhnnDCCSewbt06fv/73/Pss8+yYcMG8vk8EyZMYPr06Zx55pkcc8wxXY556KGHOPzww7n33ntZs2YNmqYxe/Zszj33XL7//e/z8MMPd/tcl19+OWPGjGHZsmWsXLmShoaG4mdz1qxZnHXWWXzzm9/stlpl4sSJrFixgocffphHH32U9957j9bWVux2OxMnTuSAAw7g1FNP3cF8cNGiRSxZsoTly5ezceNGGhsbUVWV8ePHc/jhh3P55ZfvcH5DiWD0JrtwJzzzzDN85Stf4fDDD+eaa67hkEMOGXQzvgkTJrB582Z+9rOfccMNN+z0fn/729/4xje+gSAIvPnmmxx22GFdbn/00Uc599xzAbOvpjujmP4glUoRCoVIJpPD2p8gm83y5OIP2FKXZMLY0qEezl7LLk0HPc4upoP9jb093aC/DesK+TQfvPEYidZaEASmzprP5H3mDkp7QS4nbasWiGe7mA4CBPxuSqN+SqN+wiGvtUtH/18HiqKSycnFNAKvx0VleZDqigiVZQFCo6B/fLTSEXc4VMaF2bxMSyyD2ykycWwpUyaWUxIdXHHAMAxUVStWBJiigG5+fxlGccFvswu42kv/RXt72b9daP9voVsn7t5SKBTYuHEjEydO7Hezqt7QUaI8XHpnLYaG/r4OLrnkEh544AEuvvhi7r///n55TIuBx/o+GDoG8rdgj/IKTzrpJK688kpuuukmlixZssv7C4Kwg6K1u8Tj8W5zRXO5XBcDEbfb3cVN9uKLL+b3v/89K1eu5KyzzuKBBx7g2GOPRdd1Hn/8cS677DLA7D8bKIHAwqI3SIpGa1ua5tY0tXUx4uk8kqxitwn4vC7KS4PDzlNgd4i3buWDNx5DymcQHS72P/wMyqu7d8rtD1RVoy2epa1dGMjl5S63Oxz2oihQEvXjdlnl7P3O9m0Eoh2/z2ojsOg9uXZxwOUQmTGpgikTyyktGdzeacMwyBdkZFnD6RCx2QXcThGXS8Qhiu0igPmnoy3AwsLCwsJiJNJnkSCXy/GFL3yBV199FaBbV8mB4MADD2Tz5s07/PtvfvOboskEsIMKKYoiTz/9NAsXLmTTpk0cd9xxeL1edF0vunQeeOCBw751wmJ0ksoUaGlL09BkOrdnshK6YeB0ivi8TkoivmGVQNBXYi1beOflf2DoGv5QGQcddTa+QPemMn3FMAxS6QKtsTStsQyJZI7OX0+CAOGQt10YCBAMuC1vgQGgcxuBpoPH5aA06mdstdVGYNF7OsQBp8PO1EkVTJ1YRlk0MKjfh0a7yCVJCh6Pk+qKAF6PE1HsuSXAwsLCwsJipNJnkeCWW25h+fLl2O12LrjgAk488UQqKioQxT0qThhQJkyYwMcff8xtt93GE088wcaNG3E4HMyaNYvzzz+fK6+8shg/0d/ccccd3HHHHT1GjljsPYwW08HdJVwyhnBJNS63n9mHnIro6J+S5YKkFCsFWmMZFKXr58zrcRarBaIRH6I4+l7b4YCiqGSyEgVJQQB8HheTxpdTXRGmotRqI7DoPfmCQnNbGqdoZ/KEMqZNqqC8ZGjEAVlWcbsdjKmM4Pe5rAoBCwsLC4tRT59X9A8//DCCIPC73/2OK664oj/H1CObNm3ao+MDgQA33ngjN954Y/8MqJdcccUVXHHFFUVPAou9j9FkOrg7FPJpnC5few63nTnzzscuOvdoB07TdOIdhoNtaTLZrtmzdruNknbDwdKSgGU4OEAYukFB6tpGEPC7mTapgoqyIBWlQdyu4SscWww/8gWFlrY0druNyePbxYHSoRUHqivC+LxOS1y0sLCwsNhr6PPsra6uDrvdzje+8Y3+HI+Fxaihi+lgY4Km1q6mg6Ggd0BNB4cDsebNfPDm41SP35eZB5jJBX2pHjAMg2yH4WBbhlgii653bXEKBjztooCfcNCLbRQKLsOB7dMI3F3aCIKURvxWG4HFblOQFJpb09htNiaMK2XaxAoqy4NDKg5UlYfw+1yWOGBhMUjcf//9lmGhhcUwoc8iQXl5OalUCpdraByOLSyGI92bDirYbbZRYTrYWwzDYPO6d1n90QsYuk5b0yY0VcEu9t6cTlE02uKmKNAay1CQumZ+uZxiURQoifhxOq0d6wHBMJBVlVxeJpPTsAngdXdqIygLEApYbQQWfUOSVZpb0wiCwISxpUydWEFleQBhD5z/dxdLHLCwsLCwsOhKn2fVJ5xwQjGTcvr06f05JguLEcXeYjrYWzRNYdWKZ6jftBKAqvH7MnvOF3cpEOi6QTKdp7XNNBxMpvJdbrfZBCIhL6UlAUqjfvw+l2UaNkAYukFeksnlZGRZxesW8PncTBpfZbURWPQLHeIAAoyrjjB1ciVV5cFBFwcKkoIkqbhcljhgYWFhYWHRQZ9neddffz2PP/44V111Ff/9739xOKz4Kou9g73VdLA35DIJPnjjX6TijQiCwPT9j2fCtEN3upjP5+Wi2WBbPIOq6l1u9/tclHQYDoZ9lmHYAKJrOtmcRK5TG0FZSYCx1RFKIm5KIj5czsHPY7cYXUiySktbBgODmuoI04dQHCgUrMoBCwsLCwuL7tijraC//e1vfP3rX+fggw/mBz/4AYcccgiBQM+5xePGjduTp7SwGBL2VtPB3UHXNd55+UHy2QROl5cDjjiLkooJXe6jajrxeLZdGEiTzcldbneIdkqipuFgSdSPx20ZDg4YhoGsaGRzndIIvC4mT6igqiJkphG0txGoqtTzY1lY7AJJ0WhpTWEYUF0VZsbkSqorQoMqDgDkC3IncSBIwO+2xAELCwsLC4vt6LNIMHHixOJ/J5NJvv71r+/yGEEQUFW1r09pYTFo6LpBPJmjpS1dNB3M5c2F0t5iOri72Gx2ZhxwHJ9/9gYHHvllPL4QhmGQzhSK1QLxRA7D2GY4KAgQCnqL8YShoMdqIRhAtrURSMiK1iWNoLIsSLnVRmDRz8iKRktbGk3TGVMVYfrkCqorwoPuzZIvyMW2gsryAAGfB8deWvFlYWFhYWGxK/o8G+w80R/IYywsBotsXqalLUNza5K6xgSpdAFZUYumgxV7ieng7qCqMvlsgkCoHIDKmpmEyyYTi+dYt7mW1lgGWe4qDLrdjqIoUBLxWxP1AUZXdbL59jYCA9xOB2UlQcZWR4ppBPa9vArGov+RVY3W1jSqplNdFWH6pArGVA6+OGC2FSi4nCIVZZY4YGFhYWFh0Rv6LBJs3LixP8dhYTHoKKpuuufH0tQ2xInFc+QKZvm72+UgEHDjcohWtcBOyGVivP/6Y0j5NDMPu4B0TqAtliGVLnS5n90mEI34iy0EPq/TqhYYSLZvIxDA5+nURlAWIOS30ggsBgZZNRNeFFWnqjzM9CkV1FSGsQ9ySb8lDlhYWFhYWPSdPosE48eP789xjHruuOMO7rjjDjRNG+qh7LUYQCqVp7ktTVNLivqmBNmsjKqbZddej5OK0hA2K+O9RwzDYOum1Xz89r+RCnk0nLz/4VpEV0nxPgG/u1gtEAl7sQ1y3/HehqEb5Asyufy2NoJgwM30SRVUlAUpLwvitiIiLQYQRdVpjaWRFI2q8hDTJ1cwtipiiQMWFhYWFhYjEGvWOEhcccUVXHHFFaRSKUKh0FAPZ6+hIKu0tKVpactQ1xAnkcojte+uejwuohEfojWB7BbD0Glr2Uwhn0Fw+DHsUVpjWbasfZNU8weAgegqwV8xD7cnUEwhKI36cbmstJOBZlsbgYyuG7hdDspLgowdE6Gs1GojsBgcVE2nNZahIKtUlQaZNqWSsVWRQf9e7SwOlJcGCPjcOC1hzMLCwsLCok9Yv6AWowpdN2hLZGmNpalvTNLcmiZfkNB1A6fLgdftJBr2Wi0Eu6Cx9jM+fucZkv+fvfsOr6JMHz7+Pb23dEICoSNFRVDXgggooKiA/iysr6Ci2NfFxRULiq5dV10VFcSGHdS1oCgosFhYVxBUBJHeA6SfXubM+8dJjglJIEB67s91cXE4M8/MM4dJzsw993M/xbtRYjFUtGgNbjR6M/FIKRrAldGLrn2GkpHuxmE3yxCChlbrMIIMsjNdZMgwAtGIYnGVgkIvoUiMzFQHJ3bNIjc7pUmCA8FgBJPRIMEBIYQQop4c9jfp7NmzD6vduHHjDneXQtTIGwhTUOhj774yduYX4/WHywsO6rBZDKSnONHqJd39YFRVpaQsyIbfVrLp53+jxCJodGbQGkFVUEJ7QFWwOlI59qTzyes2oKm73OpVGUYQSUy56agYRpBRPhuB3BCJRqQocQpL/ESiGjLTnJzQJYvcbA+GRj4Pw5EowWAUo0FPZrpTggNCCCFEPTrsb9TLL7/8kJ8cajQaCRKIIxaJKRQW+RJDCPKLKSoJEKxUcNDpMGOUgoN1oihxCov97C0oY2+Bl3A4infbVyixCFp9YiiGQa8rn0fchrd4DxarnY5dj2vqrrda1YYRmGUYgWha0VicMm8QXyAM8Sget43ePTqQ2z6l0W/MKwcHJHNAiLZly5YtySnYN2/eTF5eXtN2SIhW7LC/WTt06HDAIEFpaSklJSUA2Gw20tLSDndXoo1TgZLSAPuKfOzZW8ruvaWJgoOKgtGox2Ix4LRLwcG6ikRj7CvwsrfAS0GRD0WJ/7EwWgCxEiw2ByajCSUWLk8f1gAabM5UAr4SivZtIzUjr4mOoJWRYQSiGYpElfLAQAStFlxOC0cflYPbaSDFbcPlcjZqfyQ4IBrKtGnTuPfee6u9bzQaSU1NpW/fvlx44YWMHz8eg6Ft1ttZsmQJS5YsIS8vj8svv7ypuyOEaASH/Q27ZcuWg66zfv167r//fubOncsjjzzCRRdddLi7E21MKBRlb5GXz/bHvwAAkApJREFUfYVeduwqodQbJBKJodVqsJiNUnDwEAWCkUS2wD4vxaV+VPWPZSaTnsy0RAX8cJnKf3eB0WggFCglEglittgxmR0A6HR6ImE/4aCviY6kdagYRuAPhInGFIz6xDCCnl2yyEh3yDAC0STCkRil3iD+QASjXofLbaF7l0wyUp2kpdjRG3QEA4FG7tMfwYH0VDsOuwWT/GyIBpKZmZl87fV62b17N7t372bBggXMmDGDBQsW4PF4mrCHTWPJkiXce++9DBo0SIIEQrQRDfpN261bN1577TUMBgPjxo2je/fuHHvssQ25S9FCKRUFBwu97MovYW+hj2AwjKqqGE1GbFYjqR6bDCGoI1VV8fpC7NmXGEbg9YWqLLfbTImp8dKcOB1/FB0sjDnQaHT4ywqJxxPTdWo0f9RzUJQYWq0ek8XeeAfTSlQMI/AHwqgqmM0GMtMSwwgy0l2kum0yjEA0umAoSqkvSDAUxWTQ4XHZ6N09m/RUB6keW6NPYVghEokRCEYwGHQSHBCNJj8/v8q/t23bxv3338+LL77I8uXL+ctf/sLrr7/eRL0TQojG0yjfuNOmTePll1/moYce4t13322MXYoWoMwXorDIR/6+Mnbml+D3h4jEFPRaHVarkYw0J1qdFBysq3hcpbjEz57yjIFQOFplucdtTWYMWC3GGrdhNNmIx2PEomG0Oj02RwoGgxFVTQQeImE/7tQcUtI7NMYhtWyqSiQawx+IJIcR2C0munbKLB9G4MRlNzd1L0UbowLBYIQyb5BQJIbZaMDjsXFMrxTSU+ykuG1N+ns3EokRDEbQS3BANAMdOnRg5syZbNq0ia+++oo5c+bw/PPPY7dLoFwI0bo1ypVATk4Obreb//znP42xO9FMhaMKu/eU8vOanXy6aDUfL/iJr779jV9/30U4EsPptJKd6SYjw4ndbpYAQR3EYgr5e0v56dftLPpmLT+s2sK2HUWEwlG0Wg2Z6U76HtWeIaf25MTjOpPXIa3WAEHh3i18v+g1jEYLWp0evd6IRgOqGicWixAMlGAwmOnd/6wq2QXiD2pcxR8Is6+gjF17SigrC2KzGDm2Vy5nntaL0Wf1Y9CfutGtU4YECESjUQFfIMyuPSVs2V5ImT9EWqqDk/p3Ydjg3gw77SiO6taOtFRHk/3ejURilJYGiMYUUlNs5GankJbikABBMxePx1mxYgVffPEFK1asIB6PH7xRCzR8+HAAIpEI69evr3GdUCjE008/zaBBg0hLS8NoNJKVlcXo0aP5/PPPa922RqNBo9GwZMkS8vPzufHGG+nUqRNms5msrCwuvfRSfvvttwP2LxQK8dRTT3HyySfj8Xgwm8107NiRcePGsWrVqlrb5eXlodFoePXVV/H5fNx999307dsXh8OBRqNhy5YtaDSaZM2G//znP8n+ajQa9Ho9r732WrXt5ufnM2XKFI455hhcLhdms5nOnTtz1VVXsWbNmgMey86dO7nmmmvIzc3FZDKRk5PDFVdcwYYNGw7Yrq4ikQizZs1ixIgRZGZmYjKZaNeuHSeddBL33XcfmzdvrrJ+MBjk448/5uqrr+bYY48lPT0dk8lEdnY2o0ePZv78+Qfc32+//cbEiRPp3r07VqsVi8VCbm4uf/rTn7jjjjsO+H/74YcfMnr0aLKzszEajXg8Hk477TReeOEFotFore3mzJnDWWedRWZmJgaDAbfbTbdu3TjvvPOYPn06oVCo1rZCVGiUb99QKERZWVmbLfjSVsXV8oKDhT7y95WSv7cEfyCCEo9jNOixWoy4nVY0kmJ9SELhKHsLvOwtKKOwyI9aqcCA0aAjPc1BZrqTVI8dXR0v+MMhPyu+fgclFiW9XVdyOh/L778soaw4n0g8gEarx52aQ+/+Z5GVc1QDHVnLpMQUAsFEfQGVxAwbWRlOctolhhGkuW1o5RwXjSyugi8QoqwsSFSJY7OaaJfpJjfbQ1qKA7fT0iyGbyWGFYQxGPSkpthwOqwSGGghFi1axGOPPca6deuIRCIYjUZ69OjBlClTGDJkSFN3r15V/p5VFKXa8vXr1zNy5MhkAEGj0eB0OtmzZw8fffQRH330Eddddx3PPfdcrfvYvHkzY8eOJT8/H4vFgsFgYM+ePbz11lt88MEH/Pvf/2bEiBHV2u3cuZMRI0awevVqAAwGA1arlW3btvH666/z5ptv8tRTT3HTTTfVuu/CwkL69+/P77//jtFoxGq1ArB9+3YyMzPx+Xz4/X4MBgMpKSlV2losVQvrzps3j7Fjx+Lz+ZL9MRqNbN68mZdeeonXX3+dF198scbZzn788UfOOOMMiouLk9suLS3l1Vdf5YMPPuDFF1+s9RjqYvPmzZx33nnJz0qj0eByudi3bx/5+fn897//paioiKeeeirZ5t133+WKK66ocrx6vZ7du3cn/2//9re/8fjjj1fb38KFCzn33HMJh8PJz8Jms7Fjxw527NjB999/j9FoZNq0aVXa+Xw+xo4dy7x585LvOZ1OSktL+frrr/n666+ZPXs2n376abUaGRMmTODll19O/ttutxONRtmwYQMbNmzgk08+YeTIkTIzhDioRnlk8MorrxCPx2nfvn1j7K5Zmj59Or169eL4449v6q40qEAwwtadRSz/eSsfL1jFvC9/Zun369i4ZQ9xFdI8drKzPKSlOrBaTRIgqANVVfH5Q2zcso9lyzey5Nt1rFm3i4JCH6qqYrUYyeuQxonHdWLwqT3pe1QOGWnOOgcIAExmG0f1G067Dr05YfBl5HY+jiHn/ZXBI6/l5DMu57Szr2fIeX+VAAEkhhFEohSX+NmdX0xBkRcN0K1TJqef1INzhx3DiNP70KdHezJS7BIgEI0mrqqU+oJs31XEtp1FhMMxOuSkMujE7owY1JvBJ/ega6dM3C5rkwcIIpEYJaX+ROaAx05OOw/pqU4JELQQixYt4vrrr+fnn3/GbrfTrl077HY7P//8M9dccw2LFi1q6i7Wqy+++AJI3FRWTMFXoaSkhGHDhrF+/XqGDBnC0qVLCQaDlJSUUFJSwhNPPIHdbuf555/nX//6V637mDRpEkajkQULFuD3+/F6vXz//ff07duXUCjExRdfzI4dO6q0URSFCy64gNWrV+NyuXjjjTfw+XyUlJSwceNGzjnnHOLxOH/5y18O+MR72rRplJWV8cEHH+Dz+SguLmb79u3079+f/Px8Jk+eDMDJJ59Mfn5+8s/OnTurFCX/3//+xwUXXIDP5+Oaa65h7dq1BINBfD4fW7du5frrrycSiTBhwgSWL19epQ9er5cxY8ZQXFxMhw4dqnwOy5YtIzc3l2uuuaZu/2E1KCsrY/jw4axevRqPx8PMmTMpLi6muLiYYDDIunXr+Oc//0nHjh2rtHO73UycOJHFixdTUFBAIBDA7/eza9cu7r33XgwGA//85z/5+OOPq+3z+uuvJxwOM2zYMH755RcikUhyf7/88gvTpk2rtj+Ayy67jHnz5tG1a1feeustysrKKC0tJRAI8NFHH9G5c2eWLVvGlVdeWaXdN998w8svv4xWq+WRRx6hsLAQr9eL3++noKCAL774gvHjx2M01pxRKkRlGrVyePQQbNu27YDLQ6EQ27dv5/333+fll18mGo1yyy238Nhjjx1WR1uLsrIyXC4XpaWlOJ2NO4XUofD7/Xz4+Uq27SwlL7f26Stjikphia+84GAp+4rKCw4CJqMBq8WA2WRo8gvSlkZVVUpKA+wt8LJnXxmBYKTKcpfTQkaak8x0Bzar6YDTkdZGiUUJh/xY7e4q+628LZ0m8cREUdv2TBJqXCUQihComI3AoMdpN5ObnUJmhpOM1NadFh2LJZ6C6PWmJu6J2J8STxQpLfMGiQMOq5msTGdi6FaqA5utfv/PKmY3sJQ/aTxU0WiiIKFep8PpMON0WBLfEeKQhEIhNm/enExLP5BgMFjrMp1OV+WG4UDrarVaTCYT8Xic4cOH8/PPP5OdnV3lO0NVVXbv3k2fPn1YsGABWq022d/aLjc1Gk2VY6ht3f2fWNeXylMg7r/fyoULAc477zw++uijKuvceuutPP744wwZMoQvvvgCvb76d8G///1vzj//fNLS0ti9e3eVdSo+P6PRyKpVqzjqqKrB+L1793LUUUdRVFTE9ddfz/Tp05PL3n33XS655BIAPv/88+SwiAqxWIxTTz2V77//nj59+vDLL79UWZ6Xl8fWrVvR6XT88MMP9OvX74Cf0aBBg1iyZEny/YqsCp0ucY1wwgkn8MMPPzB16lTuu+++Grd188038/TTTzNq1Cg+/PDD5PuPPvoot912W62fQ35+Pr169UpmGWzevPmQnoZPnTqV+++/H5PJxLJly2o91kP1+OOPc+uttzJ06FC+/PLL5Pt79+5Nzpaxa9cu2rVrV6ftffrpp5xzzjlkZWWxfPnyGh+w7tixg549e+L3+1m5cmWyKHzFZzhs2LBkYKsx7H8eiMZzKN8Fh+qwr2r3j6QeiKqq9O7dm7vuuutwdyeakVJfiIJCH3v2lbJrTwk+f5hYTEGvqyg46EKrk6DAoVKUOIXFPvbuSwwliET/SGnUaDSkptjISHOSkeY44ovqcNDHim/eJRoJ8qehV2Ay25L7EQlKTMEfiBAon2XDbDYmhxFkls9GIFkCoinElHgiMFA+a4nTZqZHlyyyMl2kpziwWpvfU6LKwYEUt02CA41o4MCBtS475ZRTqjzdPvPMM2sdr3zccccxc+ZMVq5cybp16/D5fPz+++/V1ovH4yxbtoyVK1fSv39/AC688EJ2795d43Y7d+7MnDlzkv8eN24cmzZtqrbe/k+eG0JWVlbytdfrJVBpys+ePXtWGy6gqmoytftvf/tbjQECgNGjR+N0OikoKGDFihWceOKJ1da58MILq90YA2RkZHDttdfy4IMP8u6771YLEgCcdNJJ1QIEAHq9nnvuuYezzz6b1atX88svv9C3b99q640YMeKIb5p/+uknfvjhBwwGA3/7299qXW/cuHE8/fTTfPnllyiKkryxfOedd4DaP4esrCyuvfZaHnroocPqX8X/01VXXVVvAQKAkSNHcuutt7Js2bIqx+NwONBqtcTjcXbv3l3nIMGsWbOARDZBbRnYOTk5DB48mHnz5vHFF18kgwRutxuAffv2VemLEIfjsIMEdU1A6NKlC2PHjuW2227DZrMd7u5EEwpHYhQU+dhX6GPH7mJKSgOEIomCKVazEbfLikGvk2yBwxCJxthX4GVvgZeCQi9K/I+fK71eS3pqor5AWoodfT1NRVZWsocVX79DKFCGwWQhFChNBgnaNFUlFI7iD0YJhyPotFrsVlPi5ivDRXqaQ4oNiiYTjcUp8wbxBcJoAJfDQu/u2WRlOElLPfLAYUOR4EDrU1BQQDQaTd4A7U+j0RCPxykoKGiC3h2ZPXv21Pj+uHHjmDFjRrUndWvWrKGoqAiAyy+/PJk5UZOKMfpbt26tMUhwoDoOQ4YM4cEHH6SwsDD51BD+CJycccYZtbYdPHgwOp0ORVFYvnx5jUGCU045pdb2dfXNN98AiSBRjx49al2v4qmz3++nsLCQjIwMIpFIMsvhYJ/D4QQJtm7dyq5duwA499xzD7n9nj17eO6551iwYAG///47paWl1WpTBAIBiouLSUtLZN9aLBaGDh3KwoULGTFiBNdeey0jR46kX79+B0z3r/gcZ86cyezZs2tdr7S0NHlsFc444wzMZjMrV65k4MCBTJgwgSFDhhzSg10hKhx2kGD/6p/VNqzX4/F4ksVPRMuzM7+EH3/eTjS2GX8wghJXEwUHrQbcLik4eLgCwQh795Wxp6CM4pJAlWVmk4GMdAeZaU48DfCkeu/u9axa9gFKNILNkUL/gWOxOVIO3rCViisqgWAYfyCMEo9jMhpwOSzk9sgmM81BWqoDk0Ei8aJpRKJKeWAgglabGGZ09FE5icKkKTZMxuZ7s105OOBxWXE5rRIcaCJff/11rcv2f9K4cOHCWtetuAFOS0vDYDCQk5NT4xCAYDCI3+9P3iwBzJ0794DDDSqbPXt2nR9E1beK/aqqSn5+Ph9//DFTpkxh9uzZ9OnTh1tvvbXK+hU3npB4elsXlbMTKjtQ3a7Ky/bu3Zu86du7d+9B25rNZtLS0tizZ09y/f1lZGQctN8HU/FZKIpSa7BlfxWfRVFREbFYDDjwseTk5BxW3/Lz85Ova6oBcCDLli3j7LPPpqSkJPme3W7HarWi0WhQFCUZENv/vJ81axbnnXceP/30E//4xz/4xz/+gdFo5Pjjj2fUqFFMmDChSiHIaDSa3FZpaWkyEHAglc+nzp07M2vWLK699lqWLVvGsmXLAEhPT2fw4MH8+c9/5rzzzpOsUVEnhx0kONQfMtHybNi8ly07CsnOcpOWYkdXT0+y2xpVVSnzhthbUMaefWX4/OEqyx12MxnlMxI47OYG++W9Zf3/+G3lAlRVJSUjj+NO+T8MxoYZ49mcRaMxfIEIoVAEDWCxmOiYk0r7LDcZaU48bivy9SmaSjgSo9QbxB+IYNTrcLktdO+SSUaqk1SPDUMzr31RERzQabV4XFacDgsWc/Mb/tCWHMpY/rqs269fP3r06MEvv/ySvFGqoKoqxcXFHH300VVSug9lrGx9j6s9HBqNhnbt2nHNNdfQo0cPhgwZwm233Ub//v2rPOmu/DQ5Pz8/OQb9cPfZ0G1rW68+0tIrPouePXuydu3aw95OQ9/AHsr2Y7EYY8eOpaSkhGOPPZYHH3yQU089FYfDkVxn48aNdO3aFaieZd2hQwd+/PFHFi5cyGeffca3337LTz/9xLfffsu3337LQw89xHvvvZc8pyqfT++88w4XX3zxIR/fpZdeyllnncXcuXNZvHgx3333Hdu3b2fOnDnMmTOHgQMHMm/evGZdF000D837akM0KRUVk8mAw9H2biSPVDwep6gkwN59ZewtKCMUjiWXaTTgcdnISHeQkebEamn4C+it639g7Y+JIjY5nY6ld/+z0Oraxo+/GlcJhhK1BSIRBYNBh91mplvHdDIzXGSk2hvl/0CI2gRDUUp9QYKhKCaDDo/LRu/u2aSnOkj12FpEgDYaUwgGw2g1WtxOKy6nBAdaK61Wy9///neuv/56du7cSUpKCmazmVAoRFFREU6nkylTphww9b4lOf3007nsssuYPXs2N954I7/88kvyprpyDYNffvnliIIE+89cUNnOnTuTrys/9c/IyGD79u1s37691rahUIjCwkIg8US5oVR8Fps2bcLv9x/SEOOUlJTkkIi6fg6HonI9gC1bthxwOERly5YtSxZ2nDdvXo1ZDpWzFGqi1WoZPnx4smaE1+vlk08+4fbbb2fbtm38+c9/Ztu2bRiNRsxmc7K4+S+//HJYQQJIfJ7XXHNNcjaIjRs3MmvWLB555BG+/vprpk2bxhNPPHFY2xZtR+v4DS5EMxCLKezeU8pPv25n0Te/sXzVFrbtLCIUjqHTaclMd9L3qPYMPrUnJxzXibzctEa7OW3XoTc2Rwo9jh5Cn+PPafUBAiWmUFYWJH9PCfl7SwhHYmSkOvlT/86MGNKX0SP6ceJxncjLSZEAgWh0KolhR/l7S9myo5DSsiAep5U/HdeZYYN6M/z03vTu2Z6MdGezDxBEYwpl3gDhUBSXw0pOtoesDJcECFq5IUOG8Nxzz3H00Ufj9/vZvXs3fr+fo48+mhdeeOGA48pborvvvhudTsfatWt57bXXku/36dMn+US2ovDe4Vq8ePFBl6WkpFQZXz5gwAAAvvrqq1rbLlmyJJnKf7jTcFcEfA40DKSirkEkEuHf//73IW3faDRy9NFHAwf+HA53as0OHTokhyp88skndW5XEXxJT0+vdRhE5RkN6sLhcPDnP/+Zl156CUjUO6g860TF5zh37twaa34cji5duvDQQw/x5z//GTjwsCIhKtT5TmHp0qX1ssPTTjutXrYjRHMQCkfLswW8FBb7q3yBGo16MtIS2QKpHhs6XePG5KKREAZjIm3TaLJyyvCJ6HStdEywFB0UzZwK+ANhyrxBwhEFi8VAWqqD3OwU0tMceJwWNC3oyWvlzAGXQzIH2qIhQ4YwdOhQVq5cSUFBAWlpafTr16/VZBBU1qVLFy6++GLeeust/vGPf3DZZZdhMBjQ6/VceeWVPPXUU7z22mtcfvnlnHrqqbVup6ioqMoY9Mrmzp3LXXfdVe0pd0FBATNmzACo9mT5kksu4d///jfLli1jwYIFDBs2rMryWCyWnIqwT58+9OnT55CPHUgGQiqPy9/fgAED6NevHytXruTOO+9k+PDhB8xc2P+zuPjii1m5cmWtn8PevXt54YUXDqv/AFdeeSX33Xcfs2bNYsKECXWa4cDlcgGJG/k9e/ZUyxTZsWMHTz/9dI1tI5HIAQsUVh7aU3m4x8SJE/nss8/4/fffeeyxx7jttttq3Ybf78dgMCT3Ew6HMZlqn/a2Yp8y64GoizoHCU4//fQjHiek0WiS0UwhWiJVVfH5w+wtKGPvPi+l3qpzStusxsQ0helO3E5LkxWHKS3axfKv36Fb70F06JqYgqq1BQj+KDoYQYkrVYsOpjpIS7Vjaubjt0XrFlfBFwhRVhYkqsSxWU20y3STm+0hLcWB22lpcbPCRBWFUCiCNZ4IDjgdFsnGacO0Wm1ymsPW7vbbb+ftt99my5YtvPTSS1x77bUATJ06lU8++YSNGzcyYsQI7rvvPi677LLkDXJpaSnLli3j7bffZvny5fz66681bt9sNjNixAhefPFFhg4dikaj4YcffuDqq6+moKAAh8PBlClTqrS54IILOPHEE/n++++56KKLeO6557jwwgsxGAxs3ryZv/71r8nidY8++uhhH3tFcOHXX3/lu+++4+STT662jkaj4YUXXuC0005j27ZtnHjiiTz66KOcffbZySLmO3fuZPHixbz22mvk5eXx4osvJttfd911PPvss+zYsYMRI0Ywa9YshgwZgkaj4X//+x9XXXXVET1Znzx5Mm+//Tbr169n6NChPPLII1x88cU4nU6i0SibN2/mnXfewWq1MnnyZABOPfVUbDYbfr+fiy66iBdffJHu3bujKApffvklN9xwQ63Xed999x1/+ctfuOKKKxgxYgQ9evRAq9WiqirLli3juuuuAxLFGCvPODFq1CjGjBnDv//9b6ZMmcKWLVuYNGkS3bt3BxLBh5UrV/LBBx/w0ksvsWrVqmSWxI033khpaSkXX3wxAwcOTA5N8fl8vPHGG8nZEs4+++zD/hxF26FR61hCtj4iwxVVQNuysrKy5Hij5lw0xO/389d73mHt+gLyOqQdvEErpqoqxaWBZMZAIBipstzttJCR7iQjzYndVnsEt7Hk71jLT//9kLgSw+nJ4qQzJhz2z69Ok/h5VdTmEXWuqehgRpqdnCwP6amJooMy6Ub9i8USxTb1+qY/v5u7uKri9ScCA0o8ETjMTHeSk+UhLcWO02FucYEB+CNzIBwKY7eZyMpMleBAEwqFQsmp8Jqi0F/FtVxreCI5bdo07r33XuDg03uPHj2ajz76iJycHDZs2JB8art582bGjBnDTz/9lFzX7XYTj8cpKytLvte1a1fWr19fZZsVN5kvvfQSd955J/n5+VitVrRabXLaRJPJxPvvv8/IkSOr9Wnnzp0MHz48GXwwGo1YrdbkU3+tVsuTTz7JX/7yl2pt8/Ly2Lp1K6+88gqXX355rccdi8Xo06cP69atA8Dj8SSvYR999FEuuuii5LoLFy5k7NixyToIOp0Ot9tNMBisUon/qquuqhIkgMSUjmeeeWay75U/B4fDwaxZs5LZFJs3byYvL6/WPtdk06ZNnHvuuaxZsyb52bhcLsrKypLn9M0338xTTz2VbPPCCy8kb+ghMbNBLBYjFAqRlpbGyy+/zHnnnVetT0uWLGHw4MHJdgaDAafTSWlpafKBqdPpZN68eQwcOLBKPwOBABMmTKgyhMVms2E0GiktLa0SLNmxY0dyKMTll19eZTiM3W5Hr9dXyQA59dRT+fzzz+t1WvrW9PugpWnI74I6P2Y72JSHNdm7dy/3338/8+bNa7LpbIQ4HOFIjKJiPwVFXvYWeIlG/whuabUaUj328qEEDkzNZFovVVXZ9Nt3/P5zYsxeenY3jv3TmBad+lml6GBUwaCXooOi+VHiKl5fiDJvkDjgsJrpnJdBdqabjFQHtmYQPDxc+w8r0LnMWMwG+bkTbdKdd97JRx99xI4dO5gxY0byxrtTp04sX76ct99+mzlz5rBixQoKCgrQ6XR06tSJY489lnPPPZdzzz231m137tyZlStXJq+bd+/eTUZGBkOHDmXq1KkcddRRNbZr3749y5cv5/nnn2fOnDmsXbuWQCBAbm4up59+OrfccgvHHnvsER23Xq/nq6++Ytq0aXz55Zfs2rWL4uJigGQgo8KZZ57Jhg0beOGFF/j0009Zs2YNJSUlWCwWevXqxUknncSoUaM488wzq+1nwIAB/Pzzz9x3333Mnz+fffv2kZ6ezgUXXMBdd92FXn9k2YEVn/FLL73EnDlz+OWXXygrKyMzM5OOHTty9tlnc9lll1Vpc+2119KhQwcee+wxli9fTiwWo3379px99tlMmTKFSCRS476OP/545syZw+LFi/nf//7Hrl272LdvH2azma5duzJs2DBuvvlmsrOzq7W1Wq28/fbbXHPNNbz88st8++237N69G5/PR0ZGBr169WLEiBGMGTOmSq2EqVOn0r9/fxYvXszatWvJz89PtjnmmGMYO3Ys48aNk5t5USd1ziQ4FIFAgH/+85/885//xOv1oqoqPXv25MEHH2T06NH1vbsWRTIJmqdoVKG4xE9hsZ/CYl+1aQoNeh3pqXYy0p2kpdjRN7NiYnElxq8r5rNj8yoA8rqfQM9jz0SjObIAQVNkEigxBX8gERhQAbPJQIrbRm62h/Q0J2keO3pdy3sS25JJJkF1MSWeCAz4QgA4bWays9xkZbpIT3Fgtbbsm+jKwQGH3ZwcVuD3+wHq9SmUOHSSSdB6VGQSLF68mNNPP71pO3OI5DwQIOdBU2oWmQR1oSgKL7zwAvfffz979+5FVVVycnKYNm0al19+eYt+onmkpk+fzvTp09v8cIvmQlHiFJcGKCz2UVTkr1ZbAMBhN5PisZGR5sDjsqFtpnnsqhpn+ddvU7hnCxqNhqP6Dadjt8OrYNwkVJVwJIovULXoYPfOmbTLdEvRQdFsRGIKPl8Irz+MBnA5LPTqlk27TCdpqQ7MzSSr6EjsnzkgNQeEEEKItqfeggTvvPMOU6dOZdOmTaiqisfjYcqUKfzlL385YKXNtuKGG27ghhtuSGYSiMYVj8cpKQtSVJ4pUFIarDYExmo1kuqxk+qxkeK2YWwhRe80Gi2pmZ0pKdpFv5MuIL1d16bu0kHFFZVgMIxvv6KDOT3akZXqlKKDolmomKrQ6wsRCkfR6bQ4HWaOPiqHzHQnqSk2TMaWHxgAma1ACCGEEH844qvwBQsWcPvtt7Nq1SpUVcVisXDTTTdx++23y82waDKqqlLmDSUyBYr9FJf4UeJVgwJmkyEREPDYSPXYMZtb1sW+qsaTwwk69zyZ7A59sNia789cNBrDH4gQrFR0sEOOh/ZZbjJSXVJ0UDQLiWEEYXz+ELF4HKslETxs385NmseOx2XF0IoCWNFojGAoIsEBIYQQQiQd9pXO8uXLmTJlCosXL0ZVVXQ6HVdccQXTpk2rsQiHEA2pYmrCikyBohI/sVjVqXKMBh0pFZkCHhtWi7HJpig8Uju3/MzW9T9wwun/D73BhEajaXYBgj+KDkaIRGPJooNdpeigaEZUIBiM4PWHCYaiaLXgtFno3jmTjHQnqW5bi52R4ECi0RiBYGJ4jwQHhBBCCFHZIQcJNmzYwB133MH777+fTNceM2YMDz74ID169Kj3DgpRE1VVCYaiFBb5KCz2U1TiJxKJVVlHr9OSUilTwG4ztdigQAVVjbN+9X/YuOYbALZt/JHOPU9q4l79oaaig+mpjvKigw7SPA4pOiiaXCyu4veF8PpDRJU4FrMBj9NKnx7ZpHrspHhaznCjQ1U5OOB2SnBAiKYms38JIZqjOl8F5efnc++99/Lyyy8TjUYBGDRoEI888ggnnHBCg3VQiAqhcDSZKVBY7CcUilZZrtVq8LispKYksgUcdkuzLTZ4OBQlys/ff0z+9sT8vl16nUqnHic2bacqFR2MhCNopeigaKaCoSjeQJhAIIJWAw6bmc556WSluUjx2HA5zGhacXHdiuCAXqfD40oUJJTggBBCCCFqUucgQdeuXQkGE8XejjnmGB566CFGjBjRkH0TbVwkGqOo2F8eGPDjD1SdllCj0eB2WpKZAm6XpdXOoBEO+fjxmzmUFO5Eo9XRZ8DZ5HQ6tkn6IkUHRUugxFV8gRBeb4ioomIx6nE5LRzVJZPUFAcpHlurmI3gYCQ4IIQQQohDVecr+UAggEajQaPRUFxczPXXX3/IO9NoNGzcuPGQ24m2IRZTKC4JJDMFvOXzj1fmdFiSNQU8bht6XesMClTmK9vH8qVvE/SXYjBaOO6UC0nJ6NiofahcdBDAKkUHRTMUjsTw+kL4ghG0gM1qJi83jXYZTjweOx6npVVnC1QmwQEhhBBCHK5DetxXMW5q27Zth7Wzlj4eXNQvRYlTUhpI1BQo9lHqDbL/0Dy7zZTMFEhx2zAYdE3T2Sak15uIxxWsjhQGDLwEmyO14XdaPowgFAqV13rQY7dL0UHRvMRVFV8gjM8bIhyNYzbqcDotdOucQVqKgxS3DUsbO08rBwdS3DacDkubyJgQQgghRP2pc5Dgnnvuach+iDYgHlcp9QYpKs8UKCkNEN9vWkKrxVgeFLCR4pG0dQCz1cnxp/0Zk8WB0WRtuB2VF4P0B0JEogomg540j5mc7FQyMjxSdFA0C+Gogtcbwl9eHNNuMdK+nYfsLDepHhtupxVtG8gw2p8EB4QQQghRXyRIIBqMqqp4faFkpkBRSQBFqTotocmoTwYEUj1t76lfTVQ1zm+rvsSTlktW7lEAONyZDbOvuEogFMHvDxNTFMwmI+mpTjq095CV7sLlNKAhkc0gRFOIq+APhPD5w4QiMYx6HS6nhc55aWSkOkhx27Fa2+7vjUgkRiAYxqDXS3BACCGEEPVCHtOKeqOqKv5AJJkpUFTsJxpTqqxj0OuqZArYrEYZhlJJLBrmp//+m7271rN904940nMxme31uo+4ohIMhfH5w8TjKmazgfZZbnLLAwMe1x/ZCrFY+ABbEqJhRGIKPl8Ynz9EXAWb1Uhmhov2mYlsAY/Lik7f9oYeVVY5OJDqsUtwQAghhBD1RoIE4ogEg5FkpkBhsZ9wJFZluU6nJcVtSwYGHHazBAVqEQqUsfzrd/CW7EGr09P3+HPrLUAQV+IEAmF8gTCqmhjW0TE3ldx2KWRmOGWaQtGkVCAQjOD1hQiFYxh0WuwOE726Z5OR5iDVY8dmk2wWkOCAEEIIIRqeBAnEIQlHYomAQJGfwmIfwVC0ynKtVoPbZU1mCrgcFrRS9v6gSot2seKbdwkHfRjNNvqfejHu1PZHtE0lpuAPRPAHE9kANouJrp0yyWnnITPdgd0qN12i6URjcXz+xDACJa5itRpJT3XQPstDisdKisuGvg0WKq1NMjhgkOCAEEIIIRqWBAnEASlKnD37yigs9lFU7Mfnr5p+rtGAy2FJ1BRISRQN07XBomFHYs+O3/jp+w9RYlHsrnT6n3oJVrv7sLYViyr4AmGCoQgaDTisZo7q1o72WR6y0hyYzXJTIZqGSiLzqMwfIhSKodWCy26hR5csMtIdpLrtOOymxC8VkSTBASGEEEI0NgkSNJLp06czffp0FEU5+MrNwLOvLGHxdxspKQ1WW+a0m5PTEnrcVvRtfGzwkSou2I4Si5KW1YVjTzofg/HQUv+j0ViiqFsoglarxWE30y2vPVmZLjLTnDJDhGgyMSWOzx/G6wsSi6tYzEY8Lhs5PT2keeykuK0Y5PysUSQSIxiMoDfoSEux43RY5WdZCCGEEI1CrjgayQ033MANN9xAWVkZLperqbtzUL/8tisZILBZTeXDBxJ/jAY5bepTj2OGYnWkkNOpH1ptHbIwVJVINIbXHyEcjmDQ6XA6zRzVLYusdBcZaU4MesnmEE0jGIri9YcIBKPotBrsNhPdOmeRmeYgxW3D5bRItsABVA4OpKbYJDgghBBCiEYnVx6iRuP+70T2FZZRUhamW+eGmX6vrYpGgmxc+y3d+pyOTqdHo9HSoUv/AzdSVULhKD5/mEg0htGgx+200rFHe7IynaSnOtBJ7QfRBGJxFb8/hNcXIqaomE2Jc7NXt2xSPXZSUqyYjJIefzDhSJRQMCrBAVHvyrxBAqFIvW4zXj6dsbYRhxdazUacDkuj7U8IIdoyuQIRNTrl+C7MnfcD/kBBU3elVQn4ilj+9bv4ywqIRSP0GXB27SurKoFQBL8/TDSmYDIaSPHYyctJISvDRarHjsQFRFMIhaN4/WH8wQgawGEz06ljOllpTlJT7LgcZjR1yYoRhCNRgsEoBgkOiAZQ5g3y+AsLKCz21+t2VTURJNBoGu/nPNVjY/K1w+o9UPDqq69yxRVXHHS9hQsXcsYZZ9S6fM+ePTz66KPMmzePbdu2YbFY6N27N+PHj2fChAm1zuyUn5/PnXfeyaeffkpRURF5eXmMGzeOKVOmoNfX/LugoKCAnj17YjKZWLt2LU6ns24HexCbN2/m1VdfZdGiRWzcuJHCwkKMRiNZWVkcd9xxnHfeeYwZMwar1Vql3eWXX85rr71Gx44d2bJlS730RQjRtORKRIhGUlywnR+/mUMkHMBsddChy3HV1lHjKoFgGJ8/ghJXsJiMZGU46dA+lax0Fx63FYkLiMYUi6sEg1GiMYVgOEgkqmA26XE5rPTokklaioMUj02K6R2iysGB9FQ7DrtFggOi3gVCiWmKzSYDVoux3rarxsuDBI0UDAyUT7ccCEUaLJtAq9WSnp5e63KTqfYZgVasWMHw4cMpLCwEwG634/V6+eabb/jmm2+YO3cuH3/8cbVtFBcXc8opp7Bp0yYAbDYb69evZ+rUqfz000/MnTu3xv397W9/o7CwkA8++KBeAgTRaJRbb72V6dOnE4v9MZW1y+UiGo2yYcMGNmzYwJw5c8jKymLWrFmMHDnyiPcrhGi+5IpEiEawc+svrP7fJ8TjCs6UdvQ/9WLMFgcAcSURGPAHQsRVsJiNdMj2kNs+hawMJy5JrxQNTImrRCIxIpEY4Wji75iiAiparQaDXsVs0JPbPoXsTBcpHjsep0WyBQ5DRXDAaNBLcEA0GqvFiN1Wf9PeNnaQABIZTA0pNzf3sJ6Cl5aWcs4551BYWEjPnj15/fXXGTBgAJFIhBdffJFJkyaxYMECJk2axHPPPVel7ZNPPsmmTZs45phj+Pjjj+nQoQOLFy/mvPPO47333mPJkiWcfvrpVdosWrSI2bNnM2rUKMaMGXMER5wQiUQYMWIEixcvBmDEiBHcfPPNnHbaacmMgYKCAhYuXMjzzz/P119/zcKFCyVIIEQrJ1cmQjQgVVXZ8OtSNvy6FIDMnJ4cfeIotBo9Xm8QfyCMClgtJjp1SCennYesDCcO26HNcCDEwcRVlXA4RiQaIxxViISj5YEA0GrAaDJgNuhxOa14nFYcDjMWswGr2YgWBZNJj8PpaOKjaLkkOCBE6/T444+Tn5+PxWLhs88+o1OnTgAYjcZkweo77riDmTNn8te//pXu3bsn2y5cuBCABx54gA4dOgAwePBgrr76ap588kkWLFhQJUgQCoW49tprsdvtPPvss/XS/5tvvjkZIHjiiSeYNGlStXXS0tIYO3YsY8eO5f3332f16tX1sm8hRPMlVyhCNKBw0MvW9f8DIK/7n2jX+WT2FQbQAHariR5dsmif5SYz3VmvqaCibYqriSkxQ5EokYhCJBIjqsRBTUwoYDLpMRn0uGxmXNkpOB1mLGYjVrMxERCwGNEbqk9pGgwEmuBoWofKwYGMNAd2m1mCA0K0IrNnzwbgkksuSQYIKrvpppt48MEH8fl8vPnmm9x7773JZQUFibpPXbp0qdKmW7duAOzbt6/K+/fffz/r16/nX//6Fzk5OUfc9zVr1jBjxgwArrzyyhoDBPu74IIL6iWDQQjRvMmVihANSG+w0eXoc/CWFpLSvi8GvY7O3dNpl+UmK92JWW4WxCGqCASEozEi4cTQgEh5pXENYDLoMRn12K0mXO3cOO0WbBYjlvJAgMVixCjnXYPbPzjgsJnlcxeilVm3bh3btm0D4KyzzqpxHbvdzsCBA5k/fz4LFiyoEiRITU1lw4YNbNy4kZ49eybf37BhA0CVGglr1qzh0UcfZcCAAdx444310v/p06ejqiparZa77767zu3qNF2zEKJFkysWIepZUcFuSktLMdky0Wt1ZGV34cTjj6ddppv0NAemGp7UClGZCkSiCpFIlHBYIRKNEo3FUcszAowGHUZD4oa/XaYLl92C1WpKBAIsBiwWg0w72EQkOCBEy7Rv3z769+/PunXrUBSFdu3acfLJJ3PVVVdVqwtQoXLafZ8+fWrddp8+fZg/fz5r1qyp8v6ZZ57J999/z1133cXRRx9Nbm4uS5cu5cUXX0wuh8TQxYkTJxKPx3nxxRfr7Sb9q6++AuC4446jY8eO9bJNIUTrIFcuQhwpVSUcieLzR9i3eyObVn+GXq9j9Nib6dm9K2mpTgw6mZNAVKUC0ahCpLxQYDgSIxJVUElkBBj1OoxGPWaLnox0Bx6nBavFiMViSgQCzMZEJkot02qJxhUKRwkGI5iMBgkOCNECBQIBfvzxRzweD36/n82bN7N582befPNNrrjiCmbOnFltSsJdu3YlX7dv377WbVcsKysrw+fzYbfbAZg0aRKvv/46q1atokOHDthsNvz+xHSVY8aMYfDgwQDMnDmTb7/9lsmTJ3PsscfWy/HGYjF+//13APr161cv2xRCtB5yBSPE4VBVgqEo/kCISFTBZNDjK1rHrt+/xGbV0qVLd07o1x2bTQq9tXWRmFI+c0AiIBCOxFDLUwKMei1Ggx6TyUCax47LZcGWzAgoHyJgkkBAc1Y5OJCZ7pTggBAtTHZ2Nvfccw/nn38+PXr0wGQyoSgK33//Pffccw9ffvklr7zyCjabjWeeeaZKW6/Xm3xdMRNATSov83q9ySBBSkoK3333HXfccQfz58+nuLiYLl26cNlll3HHHXcAkJ+fz5QpU8jLy0sOVVi4cCH33nsvP/74I0ajkaFDh/Lwww8naxnURVFRUeK7qLwfQghRmVzJCFFHalwlEIoQ8IeJKgpmk5H0VCe57Vys+2Ux6zYswWzWc0y/kzj/wivRGyTdu62IxuJVMwIiMeLlKQEGrRajSY/RqCfT7cTjspYHAhLZAFaLEbNJL9MJtjASHBCidRg2bBjDhg2r8p5Op+Pkk0/miy++4Pzzz+ejjz7iueee4y9/+csh3YjXRXZ2Nq+++mqty2+++WZKSkp46623sFqtfPzxx5x//vmYTCZGjRpFcXExH3zwAUuXLmXFihXJWRIOpiJAAKCRQLQQYj9yRSPEAcQVlWAojM8fRomrWMwG2mW56NA+hax0FzazljlvzWDtmpUADB02msFnjJIv3FYoFleJhKOEIwrhaJRIJIaqJoYN6MsDASajjow0J26XBbvVXB4ISNQOsJoNEghoBULhKKFQFJNRL8EBIVo5rVbL448/zkcffUQ8HueTTz7hlltuSS53OP7IFgwEAjidzhq3E6g0Q0zlNgczf/585syZwyWXXMJZZ52FoijcdNNNKIrCZ599xqBBgwC46667eOCBB7j99tt5880367Tt1NRUNBoNqqpSWFhY5z4JIdoGubIRYj9KTMEfiOAPhgGwmo10zE0lt10KmRlOXHZzct2vFnzI2jUr0esNXHDxVRx97IlN1W3RAJS4SklpgDJfCL1em6gRYNCTnuLA5bDgsJcHAiwGrOZEdoBWJ4GA1iKmKMRicWIxBaV8BgkpSChE29K1a1fS0tIoKChg06ZNVZZlZ2cnX+/cubPWIMHOnTsBcDqdyaEGBxMIBLj++utxu9089dRTAKxYsYJt27bRv3//ZIAAYPLkyTz44IN88sknxOPxOhU21Ov1dO/enXXr1rFy5co69UkI0XbIFY4QJKaU8/nDhMJRtBqwWU307JJFdqabjHQHdqupxnaDBo9kT/52Tj1tBB3y6jcFUTSdcCRGUYmfcCSGx23l+GPyyEhzJAoHmg3o9DJDRWtTERCIRhUURQE06HVa9AYddqsJs8mAoXx6SYPMUCKEoOqMBqtXr+aoo46qcb2KWRB69epV523fc889bNmyhZkzZ5KZmQmQDFJ06dKlyrput5u0tDT27dvHvn37kusfzNChQ5NBgq1bt8oMB0KIJAkSiLYpWXgwQiQSxaDX4XCY6dE5k8wMJ5lpTky1PCXctnUDObmd0Wq16A0G/jzupkbuvGgIKuDzhygqCaDTasnKcNKlYzrtstyYTVJforVQVZWYksgOiMXixJU4aBIBAZ1ei8OWKByp1+swGHQY9FqZE1yINmzjxo0UFBQA0KlTpyrLevToQYcOHdi2bRuff/45F154YbX2fr+fr7/+GqBa7YParFq1iqeeeopTTz2Vq666qtryYDBY63uHMtzx+uuv5/nnn0dRFO677z5eeumlOrWra7aCEKLlkiCBaDMq6gv4/RFicQWT0UCK20rHnFQy0h2kpzjQaRNfrvF4nE0bf8NbVoLD6SavU3c0Gg3ffb2A+Z+8wymDRnDWORc38RGJ+qDEVYpLAnj9IWw2Ez06Z5KXm0ZGmkOGDrRw+wcEFCWOplJAwGk3YzYZJCAgRBulquoBb6pVVeXWW28FEvUJzjnnnGrrjBs3jvvvv5933nmHqVOnkpeXV2X59OnT8fl86HQ6Lr300oP2KR6PM3HiRLRaLTNmzKjSv4ogxY8//kgsFktOyfjrr7/i8/lwOBykpaUddB8VevfuzdVXX83MmTN5+eWX6du3L3/9618P2ObDDz/k559/5u67767zfoQQLY8ECRrJ9OnTmT59enkaq2gsNdUXyMn2kJvtITPNidttZf/Lg19/Wc7HH8xm186tyS/hdtkdSEvPYuuW9QCEQ0GJpLdw4UiMwmIfkaiCx23lhG555LTz4HLVPo2VaL5UVSUWU4jG4sQUhbiiotVo0Om16MsDAokMAS2G8qCAFBgVom3bunUrF110ERMmTODMM8+kU6dOaDQa4vE4//vf/5g2bRpffPEFANdccw09evSoto3Jkycza9Ys8vPzGTlyJLNnz6Z///5EIhFeeuklpk6dCsDEiRPp3r37Qfv07LPP8sMPPzB16tRqwxP69+9P+/bt2blzJ3fddRf33Xcffr+fm25KZDSec845h3xd8vTTT7N27Vq+/vprJk2axIIFC7j55ps57bTTsFgsQGK6xK+++ornn3+exYsXc/PNNx/SPoQQLY9GrTwHimhwZWVluFwuSktLay1w0xz4/X7+es87rF1fQF6Hukelm4PK9QU0GrBbTbTP8tAu003mAeoLQCJAMOuFhwkFAtgdTvQGI5FImMJ9+cTjcdLT2zHmois55bThbeIGIxZLBFf0+to/s5ZEBbz+EMUVQwoyXXTpkEZ2OzcmowwpqE2wvDK35QDzgDem/QMCahxQVfQGHXq9FovJWJ4hIAGB+ub3+wGw2WxN3JO2LRQKsXnzZjp16oTZbK51vfx9pfzjyU8xmwxYLcZ6278aTxTybKwZWwLBCKFwlKmTRpKV7qq37W7ZsqXKEAKTyYTD4cDr9RIOh5PvX3HFFcycOTP55H5/K1asYPjw4clZAhwOB6FQiGg0CiSGGXz88ceYTAf+Lt2xYwe9evWiXbt2/PzzzzWu//7773PhhReiqiomk4loNEo8HiclJYUVK1ZUy2Soi0gkwi233MKMGTOIxWLJ910uF7FYLPlzD5CTk8OsWbMYPnx48sHXhAkTeO211+jYsSNbtmw55P2Llq3iPNDppF5PY6vrd8HhkEwC0fIdQX2ByuLxOB9/MJtQIIAnNR2NRoMSi1FWUoQKqGoci9XGyQOHyQ1HC7P/kIKeXbLomJNKZrpDpiVs5v4ICCSCAmpcRQMYDIkCgg6b6Y8hA/pEkEB+PoVIsJqNpHpsFBb7CYWj9bZdVS0PEmga7/dnqseG1Vx/gQ6AzMxMnnnmGZYtW8aqVavYt28fxcXFmM1mOnXqxMknn8yVV17JKaeccsDt9O/fn19//ZVHHnmEefPmsX37dmw2G3369GH8+PFceeWVdXrCf+ONN+L1evnoo49qDShccMEFfPrpp/zjH/9g1apV2O12hgwZwsMPP3xYAQIAo9HIs88+yy233MIrr7zCokWL2LhxI0VFRRiNRrp27cqAAQMYPXo0o0ePPmiwQwjR8kkmQSOTTIL6UVN9AY/rj/oCaR4Het2h3Shs2vgbTz5yG2azBaPJjKqq7MnfgaIo6LQ6HE43ihJj0m2P0LlLzwY6sualpWcS7D+koGvHDBlScBgaK5MgHo8nphxUEgEBVBUNmmTNAItZj8koAYGmJJkEzcOhPD0q8wYJhCL1uv94+ZSgjVm3xWo24nRYGm1/4uDkCbIAOQ+akmQSCAHEY3F8wTD+QBhUsFoS9QVyst1kpblqrC9wIOFwiL35O8nfvZ383dv5dfWPlJQUkpmZAyQqBLtcKXi9paSmZqDRaikpLsRbVtIgxyfqR8WQgpLyIQWZMqSgWdo/IKDGEzUEEgEBPU77HwEBo0GHXqadFOKwOB2Wer+5lpsCIYRo3SRIIJq1muoL9OySRbtMNxnpDhwHqC9QIR5PPJHUll/M/PrLCr74dA5FhXtR+SORJhwOARAKBTGVR+MsVhsWixU0GiLhEHq9HofTXf8HKo5Y5SEFdpuJHjKkoNmIx+NEy2cYiMUUVBV02kRBQaNej9tpxGjQJ2sISEBACCGEEKLpSJBANC+qSigcxef/o76A3W6me+dMsupQXyAUDJCfvyORHbBrO3vyd7AnfwfnXzSBPkcfD4DBYKCwcA8AdoeLrHa5ZLXLJTOrPR9/MJs9u3dUnRZJo0FVVXy+Mjp07Epep4NXJxaNJzmkIBbH47LILAVNTFES2QGJKQcVVFVTniGgxWzUY3FZJSAghBBCCNGMSZBANLma6gukuK10bJ9KRkbN9QXi8TiKEsNgSBQx2rZlPe++9QIlxYU17iN/9/ZkkKBDx65cMfFWsrJysDuqVkk2mczMeuFhiov2YbcnZjeIRSP4fGVYLDbOO3+cTHvYDFSepUAvQwqaTEVAIBpVUJQ4qgp6nRadXofFZMBstmI06hMzDOh16Bpx/LIQQgghhDg8EiQQTaKivkAgEEbdr75AZpoLT6X6AgG/j23ldQMSfxLZAYPPGMXpQ88BwGpzJAMELldKIjsguyJDIIf09Kzkvs0WK1279a6xX737DuCqa6fw8Qez2bVzKzGfF71eT4eOXTnv/HH07jugQT8XcWCxuEpJiR+vP4y9fJaCvNw0MtLsMqSgAcXVOEpcRROOEoslAgKQGDKg0+uwWUyYzfrEjAMSEBBCCCGEaNEkSCAaTbX6AhYT3Ttnkp3lISPdgdWkIxwOYy2voF5ctI+Z0x+grJZCgXv37Ey+TknN4Kprp5DZLher9ciqbvfuO4Cjeh/Hls2/4y0rweF0k9epu2QQNKFwJEZhkY+IUj6koHsnctt5cDql0vWRUlUVJR4nrpT/HU/8rcYr6nVoCIci6LQaDIZEXRCzyYDekAgGGA06+dkQQgghhGhFJEggGk4t9QW6dcrAadOgRkso3LeBH79L1A7Ym7+TY/ufzPkXTQDA4XDj85UBkJKSnqwdkJWdyA5ISc1I7kqr1dKpHqcl1Gq1bWaaw+ZKBby+EMWliSEFWZkuOndMJzvLJUMK6uhAAYCKyW+1Gg06nRatVoNWp8FsNGAwaNHrdOXvawmFTOi0WlwuhwQEhBBCCCFaOQkSiGri8TgrV65kx5bV+EpiqLkpaDR1uzFI1hcIRIgpCgadBptFQ7/enclId+B2mHnykcnJm//9FRbuTb7WGwxc95d7SE3LxGSq37k/RfO1/5CCo7q2o2NOqgwp2E9tAYC4UlF0U0VD1QCAyaDHYPhjOIBWq0Wn0ySGDZSvlyzYWYmGGIAECIQQQggh2gAJEogqFi1axMMPP8zatWspLCpDUTXs2dye3v3PIivnqBrbxGNxvIEQJcWFBLwFxMLFECslGi4m4C2kc9eeHH3eKcn1jSYzGr+P1LSMP7IDyv+4PalVtp3dvmODHq9oPioPKUhxWTmhe3abHVJQOQAQV9XyQp2Jv6HmAIBRr8Ng0GM0HFoAQAghhBBCiMokSCCSFi1axDXXXIPX68Xj8RCMaAgEwpQU7uB/i1/nhMGXkZVzFLFYBF9ZMarWnqwvsPb7N4mGSxJTmhl06LSJmxGtVkNZaXGV/Vx+1WQcThdGo6kpDlM0I1WGFOjKhxR0aN1DClRVJR4vv/GP1x4A0Go1aLXaPzIArNUDAFqtFp02ESyQAIAQQgghhKgPEiQQQGKIwcMPP4zX66V9+/aoqopGE0Sj0aIzmAkGylj25SvYXNmEAiUYTXYGjfwL3TtnkpXuhNLObNm0lvT0dslZBSr+OJzuKvtKTcuouROizahpSEFebirpqS17SMGBAgAVNQA0kLzRrykAoNH+8fRfAgBCCCGEEKKxSZBAALBy5UrWrVtHamoqGo0GVVXxlRURCYdAk7j5CQZK0euN2KxWXG4bZw0+Cps1kQp+0Z8nYjFb0Rta59NfUT9C4ShFxX4iSpxUt42jWtiQAkWJ15wBoAIaDahqlQCAUa/HYNFhMOjQ63RodRIAEEIIIYQQzZsECQQABQUFRCIRTKY/hgDodHrQaNDrDRgMBuJKlFHnj2XgoBHYHa4q7R37/VuICjUNKejSMZ3sTDdGY/P/FRSNKQT8YaBqBoBBr8dq1mI06iUAIIQQQgghWo3mf4UuGkVaWhpGo5FwOIzFkniqm5KaSjTqwWIxEgmHCIWC9DjqmGoBAiFqsv+Qgl7dsumYk9JihhQoShx/MIxG1ZDisWGzmtDrE/U2KuoFCCGEEEII0dpIkEAA0K9fP3r06MHPP/9M+/btAdDrdMTjiaEGPl8ZHTp2Ja9T9ybuqWjuQuEohcV+ouVDCnr1yCa3XQoOR8uYxlJVVYKhCNFoHIfNhMdtw2oxNnW3hBBCCCGEaBQSJBBAYv7zKVOmcM0117Bz5048Hg/xeJxoJIzP68disXHe+ePk6amokQqU+YIUlwYx6LS0y3LTuUNaixlSUCEUjhIMRrFaDWSkOrFZjXLOCyGEEEKINqXlXL2LBjdkyBBmzJjBww8/zNq1a/H6AqDR0aFjV847fxy9+w5o6i6KZiYWVyku8ePzh3HYTPRuYUMKKkRjCn5/CKPBQFaGA6fdgl6va+puCSHEEUtkRin1uk1FSWxPp2u835MGgw6LWbK6hBCiMUiQQFQxZMgQTj/9dL777js++eJ7/CE9J/3pBHmaKqqoGFIQU+Kkemz0bmFDCirE43F8gUTdAY/Lhsdtw9SCMh+EEOJAgqEI8xetpqQsWK/bVeNxgEYNBrudFs4a0qfBAgXffvstzzzzDN9++y179+7F6XTSt29fxo8fz7hx4w5aiHbPnj08+uijzJs3j23btmGxWOjduzfjx49nwoQJtbbPz8/nzjvv5NNPP6WoqIi8vDzGjRvHlClT0Otr/j4qKCigZ8+emEwm1q5di9PpPOLjB9i8eTOvvvoqixYtYuPGjRQWFmI0GsnKyuK4447jvPPOY8yYMVit1irtLr/8cl577TU6duzIli1b6qUvQoimJVfDohqtVku/fv3Yuge27SyVAIEAqg4pMOq1ZGe56dwxnXYZrhY1pAD+qDsQiSg47WbcLitWi1FmIxBCtCrRqEJJWRCzSY/ZVH9TFMfLgwSNdX0QCkcpKQsSjSpYGiAWfdddd/HAAw8k/+12uykrK2Px4sUsXryYd955hw8//LDKDFCVrVixguHDh1NYWAiA3W7H6/XyzTff8M033zB37lw+/vjjau2Li4s55ZRT2LRpEwA2m43169czdepUfvrpJ+bOnVvj/v72t79RWFjIBx98UC8Bgmg0yq233sr06dOJxWLJ910uF9FolA0bNrBhwwbmzJlDVlYWs2bNYuTIkUe8XyFE8yV3f0KIA1LiKvuKfGzZXkQ0otC7WzZnnNaL00/qTsec1BYXIAhHopSWBdFqtbTPctMu04XNapIAgRCi1TKbDFgtxhb7pz4DHPubNWtWMkBwySWXsH37doqLi/F6vbzxxhs4HA4+//xzbrrpphrbl5aWcs4551BYWEjPnj354Ycf8Hq9+P1+nn32WQwGAwsWLGDSpEnV2j755JNs2rSJY445hq1bt+Lz+Vi0aBF2u5333nuPJUuWVGuzaNEiZs+ezahRoxgzZswRH38kEmH48OH861//IhaLMWLECObPn4/f76ekpAS/38++fft46623GDhwIPn5+SxcuPCI9yuEaN4kSNBIpk+fTq9evTj++OObuitC1IkvEGb3nlJ27ynFYjbwp/6dGDG4D8f3yyMjzdmiag4AxBSF0rIAsVicjDQHue08OB0WyZQRQog2SlEUpk6dCsBxxx3HW2+9RU5ODgBGo5FLL72Up59+GoCXXnqJX375pdo2Hn/8cfLz87FYLHz22WcMGDAg2f6GG27g3nvvBWDmzJn8/vvvVdpW3Gw/8MADdOjQAYDBgwdz9dVXA7BgwYIq64dCIa699lrsdjvPPvtsvXwGN998M4sXLwbgiSeeYP78+YwYMaLKkIK0tDTGjh3L0qVLee+99/B4PPWybyFE8yVXx43khhtuYM2aNfzwww9N3RUhahVT4uwr8rF5eyG+QIScdh5OOb4Lwwb15qhu7bDbW1bNAUikxXp9IQL+CG6nlZx2HlI9dilMKIQQbdzy5cvJz88HEin8NWWUjR8/nszMTOLxOK+99lq15bNnzwYSWQidOnWqtvymm27CbrejKApvvvlmlWUFBQUAdOnSpcr73bp1A2Dfvn1V3r///vtZv349DzzwQDKYcSTWrFnDjBkzALjyyitrzHbY3wUXXJAMrAghWi8JEgjRxqkksga27ypmV34JFrOBE/p1YsTpvflT/y7ktEtpcUMKIFF3IBCMUOYNYTEZaN/OQ2a6s0HTVoUQQrQcW7duTb7u1atXjetoNBp69OgBwOeff15l2bp169i2bRsAZ511Vo3t7XY7AwcOBKpnBqSmpgKwcePGKu9v2LABgPT09OR7a9as4dFHH2XAgAHceOONBz6wOpo+fTqqqqLVarn77rvr3E4y8IRo/eSnXIg2KhqLs7fIx9YdhQRCUTp1TGPIqT0ZPqg3vXtk43ZZD76RZioSiVFaFkSj0ZCd6aZ9Ozd2m9QdEEIIUbOKaR0PtGzdunVEIpHk+6tXr06+7tOnT63tK5atWbOmyvtnnnkmkCicuH37dgCWLl3Kiy++WGW5qqpMnDiReDzOiy++WG836V999RWQGGrRsWPHetmmEKJ1aHmPB4UQh00FvP4QJSUBAFJT7BzdM4d2GU5cLTgoUCGmKAQCYXRaHempdlwOKwaDDCsQQghRXV5eXvL16tWr6d+/f7V1YrEY69atS77et28f7du3B2DXrl3J9Sreq0nFsrKyMnw+H3a7HYBJkybx+uuvs2rVKjp06IDNZsPv9wMwZswYBg8eDCTqGXz77bdMnjyZY4899vAPeL/jqqiR0K9fv3rZphCi9ZBMAiHagEhMYU+Bly3bCwmHY3TrnMkZp/Vi+KDe9OyW1eIDBPF4HJ8/hN8XxumwkpPtIS3FIQECIYQQterfvz9ZWVkAPPLII1Wm/6swY8aMZO0ASNzoV/B6vcnXlQv97a/yssptUlJS+O677xg/fjwZGRlEIhG6dOnCtGnTePfddwHIz89nypQp5OXlJYsgLly4kFNPPRWr1Yrb7eaCCy5g/fr1h3TsRUVFqKqa7IcQQlQmmQRCtFIqUOYLUlIaRKvVkOaxc2zvXLIz3TgcLa8AYW0CwQiRSAy71YQnw4bNapRhBUIIIQ5Kp9Mxbdo0rr32WtauXcvIkSN58MEH6du3L8XFxbz11lvcfvvtGAwGotEoUP/j8bOzs3n11VdrXX7zzTdTUlLCW2+9hdVq5eOPP+b888/HZDIxatQoiouL+eCDD1i6dCkrVqxIzpJwMBUBAkC+M4UQ1UiQQIhWJhxVKC7xEwxFcdhMHNUli5z2KWSmOdC1oor+kUiMQDCCyWQgOzNRc0Cnk+QoIYQQdXfNNdewZcsWHn74YRYsWFCtuGBmZibXXntt8il+5en/HA5H8nUgEMDpdNa4j0AgUGObg5k/fz5z5szhkksu4ayzzkJRFG666SYUReGzzz5j0KBBQKKmwQMPPMDtt99ebQaF2qSmpqLRaFBVlcLCwjr3SQjRNsgVtRCtQFyFUm+QrTuL2FtQhsdp5dQTujJicB9O6N+Z7Cx3qwkQKEqcMm+AaFQhPdVObjsPLqdFAgRCCCEOy0MPPcR///tfJkyYQN++fcnNzaV///7ccccdrF69GpPJBCQCBJVnHMjOzk6+3rlzZ63br1jmdDqT9QgOJhAIcP311+N2u3nqqacAWLFiBdu2baN///7JAAHA5MmT0Wg0fPLJJ8Tj8TptX6/X0717dwBWrlxZpzZCiLZDMgmEaMHCkRjFpQGC4ShOm5le3bLJzfaQkeZA28pumlVVxR8IE1dUnA4LbpcVi9nY1N0SQgjRCpx44omceOKJNS5bunQpACeddFKV1PzKMxqsXr2ao446qsb2FbMg1DbNYk3uuecetmzZwsyZM8nMzARg06ZNAHTp0qXKum63m7S0NPbt28e+ffuS6x/M0KFDWbduHStXrmTr1q0yw4EQIql13UUI0QbEVSgpC7JlZxEFhT48bhsDT+jKiCF9OL5fHlmZrlYXIAiGIpSUBjAZDWS3c5OV4ZIAgRBCiAa3bds2Fi5cCMD48eOrLOvRo0eyBsDnn39eY3u/38/XX38NwLBhw+q0z1WrVvHUU09x6qmnctVVV1VbHgwGa33vUOoLXH/99Wg0GhRF4b777qtzu7pmKwghWq7WdSchRCsWjsTYvbeUrTsLicdV+vbI5sxBvThz4FF07ZSJzWpq6i7Wu2g0RklpAFTIznTTPsuNw2aWIktCCCEaXDQaZeLEiSiKQp8+fRgzZky1dcaNGwfAO++8w5YtW6otnz59Oj6fD51Ox6WXXnrQfcbjcSZOnIhWq2XGjBlVvu86deoEwI8//lhlJoZff/0Vn8+Hw+EgLS2tzsfXu3dvrr76agBefvnl5LCGA/nwww+5//7767wPIUTLJEECIZqxuKpSXBpky44iCop8pKc6OO2EbowY3If+x+SRke5sdVkDkKg7UOoNEg7HSPXYyGnnwe2ySt0BIYQQ9WrTpk3cdddd/Pjjj4RCIQAUReE///kPQ4YM4YsvvsButzN79mwMBkO19pMnTyYrK4tAIMDIkSNZsWIFAJFIhOeff56pU6cCMHHixGQNgAN59tln+eGHH7jtttuqDU/o378/7du3Z+fOndx1111EIhGKi4u56aabADjnnHMOefaFp59+moEDBwIwadIkzj77bL744osq2QpFRUXMnTuXIUOGMGbMGIqKig5pH0KIlkdqEgjRDAVDUYpL/USicVwOM8f0yqF9OzfpKXY09Tz9UnOiqiqBYIRYLI7TbsLtsmG1yLACIYQQDaOsrIwHHniABx54AI1Gg9vtxuv1Jp/UZ2dn895779GvX78a27tcLubNm8fw4cNZs2YNAwYMwOFwEAqFktMmDhs2jCeffPKgfdmxYwd33XUX3bt3584776y2XK/X869//YsLL7yQRx55hKeeeopoNEo8HiclJYUHH3zwkI/fZDLx5ZdfcssttzBjxgzmz5/P/Pnzk8cWi8Xw+/3J9XNycjjrrLMOeT9CiJZFggRCNBNKXKW0LEipN4jZqCczw0Xn3LTE+Ps2cKMcCkcJhaJYLUYy05zYbSYZViCEEPUgFI7W6/YqxqQf6lPrw1Xf/a8sLy+Pu+++myVLlrBhwwYKCgpwuVx0796d0aNHc/311x90RoL+/fvz66+/8sgjjzBv3jy2b9+OzWajT58+jB8/niuvvLJOn9WNN96I1+vlo48+Ss6osL8LLriATz/9lH/84x+sWrUKu93OkCFDePjhh8nLyzucjwCj0cizzz7LLbfcwiuvvMKiRYvYuHEjRUVFGI1GunbtyoABAxg9ejSjR4+utW9CiNZDo6qq2tSdaEvKyspwuVyUlpbWOp9uc+D3+/nw85Vs21lKXm7dx7eJQxcMRSkq8RNV4rjtFjp1TKV9lodUj63JswaC5XM7W6zWBttHNKYQ8IcxGPR43BZcDhlW0NxUPEWy2WxN3BPR1ORcaB5CoRCbN2+mU6dOmM3mWtcLhiLMX7SakrLqhe6OhFoeJGjM7yi308JZQ/pI0dpmRFEUAHS61jHFsjg8ch40nbp+FxwOySQQognE4iqlpQHKfCEsJgPZWW7yctNol+nCbKo+5rE1UpQ4/mAYLRpSPDZcTismo/xKEkKI+mIxGzlrSB+iUaVet9sUNwUGg04CBEII0UjkilyIRhQIRigq8ROLq3hcFgYc3YHs8qwB2khqfeW6Aw6bCY9b6g4IIURDsZiNWOr3AZM8ORRCiFZOggRCNLBYXKWkJIDXH8JiNpDbzkNex3SyMpyYjG0ja6BCKBwlGIxitRrITHNisxobbUyrEEIIIYQQ4uAkSCBEA/EFwpSUBlDiKh6XleO75pHdzk2Ky9pmsgYqRGMKfn8Io8FAVoYDp92CXi9PoIQQQgghhGhuJEggRD2KKXGKSwP4/GEsFiMdc1LpmJNKVoYLYxscbx+Px/EFwmhUDSluG26XTeoOCCGEEEII0YzJ1boQR0gF/IEwxSUBVFUlxWOjV/dssrNceJxtL2sAEnUHgqEIkYiC027G7bJis8qUSUIIIYQQQjR3EiQQ4jBFY3GKywL4/WFsNhOdOqaRl5NKZpoTQxt+Wh6OJOoOmM0G2mc5sNtMUndACCGEEEKIFqLt3skIcRhUwOsPUVISACA1xU6fHtm0z3TjclmbtnNNLKYo+P1h9HodGWkOXA6pOyCEEEIIIURLI0ECIeogElMoLgkQCEaw20x065xJh/YpZKY50Rva9o1wPB7HH4igxlXcTitulxWzqW3N2iCEEEIIIURrIUECIWqgApFIjGAoSqk3iFarIc1j59jeuWRnunE46nnS6RYoUXcgSiQSw2414XHbsFmNaNpgDQYhhBBCCCFaCwkSiDYvrkIoFCEUjhEKRYjE4gCYjDosJiM9u2SR2z6FzDQHOkmfBxIBlEAwgslkSARN7FJ3QAghhBBCiNZAggSiTYnF1URAIBQlGIqgxBOTD5hMBqxmAx1yUknx2HDYzNjtJuwWU5suQri/mKIQCITRaRN1B5x2C4Y2PtxCCCGEEEKI1kTufkSrFYkp5cGAKKFwFFUFrRYsZiNWi5EO2Sm43TbsNhN2qylRhV8nT8NrEo/HCQQjxBUVp9OKR+oOCCGEEEII0SpJkEC0eJXrB4TCUUKRGKgqBp0Os9mI22UlPdWOy27BXp4hYLMYEykE4oCiikIsGiMcReoOCCGEEEII0QZIkEC0KAerH5CZ7iTdY8dmN+OwmbDbzfLE+xAoSpxINEYkqqDGVZRoDINRT1aGG7vNhE4yLYQQQgghhGjVJEggmq2D1Q/IzUklVeoHHBFVVRNBgYiCosTRabUYjDpSXFYsZiPRaBijQYfdbmnqrgohhBBCCCEagdxRiWZB6gc0nmh5pkA0GkODBqNRj8NmwmoxYTTqMBn1yZkK/H6liXsrhBBCCCGEaEwSJBCNqu71A8zYbRapH1APYopCJJIICgDo9TpMBj2pbhtGox6TUY9epnYUQohWSVHixONqPW8zEUCOx+t1swek1WpkyJsQQjQSCRI0kunTpzN9+vTkF2tbUGP9AA2YDFI/oCHF43EiUYVINEZcUdHrEkMIXA47JpMBk0GPUYZlCCFEq6cocXbmlxApDxLXl3j5tYxW13gBZqNBT/ssd4MFCr799lueeeYZvv32W/bu3YvT6aRv376MHz+ecePG1Vqwd9q0adx7770H3f769evp2rVrtffz8/O58847+fTTTykqKiIvL49x48YxZcoU9Pqav6sLCgro2bMnJpOJtWvX4nQ6D+1ga7F582ZeffVVFi1axMaNGyksLMRoNJKVlcVxxx3Heeedx5gxY7BarVXaXX755bz22mt07NiRLVu21EtfhBBNS+4UGskNN9zADTfcQFlZGS6Xq6m7U+8OpX6AzWbCYZX6AfVFVVWi5UGBWCyOVqPBYNTjsluwWozJbAGZkUAIIdqWeDxRd0an09brzXVcSXyfNFaQoKKobjyu0hC7vOuuu3jggQeS/3a73ZSVlbF48WIWL17MO++8w4cffojJZKp1GwaDgZSUlFqX13TDX1xczCmnnMKmTZsAsNlsrF+/nqlTp/LTTz8xd+7cGrf1t7/9jcLCQj744IN6CRBEo1FuvfVWpk+fTiz2R0DJ5XIRjUbZsGEDGzZsYM6cOWRlZTFr1ixGjhx5xPsVQjRfcpcmDpnUD2h6iSEEMaJRBdBg0Ouwmo3YrKZkUEDSMoUQQgDodFoM9TisLF4ec27MTAJFaZixDbNmzUoGCC655BIee+wxcnJyiEQizJ07l+uuu47PP/+cm266iZkzZ9a6nZNPPpklS5Yc0r6ffPJJNm3axDHHHMPHH39Mhw4dWLx4Meeddx7vvfceS5Ys4fTTT6/SZtGiRcyePZtRo0YxZsyYQz3caiKRCCNGjGDx4sUAjBgxgptvvpnTTjstmTFQUFDAwoULef755/n6669ZuHChBAmEaOUkSCAOKKrEKSkLSv2AJqYocaIxhXAkBirodVqMRj1upxWT0YDJqMdgkLoCQgghRF0pisLUqVMBOO6443jrrbeSWXdGo5FLL72UaDTKFVdcwUsvvcRNN91E3759623/CxcuBOCBBx6gQ4cOAAwePJirr76aJ598kgULFlQJEoRCIa699lrsdjvPPvtsvfTh5ptvTgYInnjiCSZNmlRtnbS0NMaOHcvYsWN5//33Wb16db3sWwjRfEmQQNTKoNNh0GlBhcx0J2keG3a7ReoHNIL9hxDsPzWh0ajHaNDJEAIhhBDiMC1fvpz8/HwgkcJf03fq+PHjmTJlCnv27OG1117j8ccfr7f9FxQUANClS5cq73fr1g2Affv2VXn//vvvZ/369fzrX/8iJyfniPe/Zs0aZsyYAcCVV15ZY4BgfxdccEG9ZDAIIZo3CRKIWvXq3o68vCyy0pxSP6ARRGOJGQiiUQUNGgwGHXZrzVMTCiGEEOLIbN26Nfm6V69eNa6j0Wjo0aMHe/bs4fPPP6/XIEFqaiobNmxg48aN9OzZM/n+hg0bAEhPT0++t2bNGh599FEGDBjAjTfeWC/7nz59OqqqotVqufvuu+vcTq5FhGj95Kdc1MpqNeJxWSVA0EAUJU4wFKHUG6S0LEAkEsOo15OR5iAn20OH9im0y3TjclqwmI3ypSyEEEI0kAPNPlWxbN26dUQikRrX+fXXX+nTpw8WiwW73U6PHj24+uqrWblyZa3bPfPMM4FE4cTt27cDsHTpUl588cUqy1VVZeLEicTjcV588cV6ux746quvgMRQi44dO9bLNoUQrYPcdQjRSOLxOOFIFK8vRElpgGAwglarIdVtpX07Dx2yU8jJ9pDitmOzmtDXY5EpIYQQQlSVl5eXfF3bOPtYLMa6deuSr/cfAlChoKCAtWvXYrVaCYfD/P7778yaNYv+/ftz11131dhm0qRJdOzYkVWrVtGhQwfsdjuDBg3C6/UyZswYBg8eDMDMmTP59ttvmTRpEscee+zhH/B+x/X7778D0K9fv3rZphCi9ZAggRANJFFXIIY/EKa0NIDXGyKuqDjtZtpnucltn0KH7BTSU504bGaMMk2hEEII0Wj69+9PVlYWAI888kiV6f8qzJgxI1k7AKCsrKzK8m7duvHoo4+ybt06QqEQhYWF+P1+vvjiC/r374+qqjzwwAP885//rLbtlJQUvvvuO8aPH09GRgaRSIQuXbowbdo03n33XQDy8/OZMmUKeXl53HvvvUCi4OGpp56K1WrF7XZzwQUXsH79+kM69qKiIlRVTfZDCCEqkzxyIepRYmpChVgsRjwOBoMOs1GP3WOXqQmFEEKIZkSn0zFt2jSuvfZa1q5dy8iRI3nwwQfp27cvxcXFvPXWW9x+++0YDAai0ShQfTz+pZdeWm27RqORYcOGcdppp3Haaafxww8/MG3aNK666ipcLleVdbOzs3n11Vdr7ePNN99MSUkJb731FlarlY8//pjzzz8fk8nEqFGjKC4u5oMPPmDp0qWsWLEiOUvCwVQECAB5QCGEqEbuVoQ4AvF4nFA4SpkvSElpgFAwil6nJS3FQW52Ch3bp5KTnYLbZcVqMUqAQAghhGhGrrnmGqZMmQLAggULGDBgACaTiaysLG655Rbcbjd33HFHcn2Px1PnbZvNZh588EEAfD5fsgZAXc2fP585c+ZwySWXcNZZZ6EoCjfddBOKovDZZ5/x9ttv8/nnn3PnnXdSUFDA7bffXudtp6amJoMDhYWFh9QvIUTrJ3csQhwCVVWJRGL4/Im6Aj5fGFUFt8NKTjsPHXJS6dA+hVSPHbvNhMEgdQWEEEKI5uyhhx7iv//9LxMmTKBv377k5ubSv39/7rjjDlavXo3JZAISAYLKMw7UxUknnZR8vWnTpjq3CwQCXH/99bjdbp566ikAVqxYwbZt2+jfvz+DBg1Krjt58mQ0Gg2ffPIJ8Xi8TtvX6/V0794d4IDFFYUQbZMMNxDiICpPTQgaDHodNosJm1WmJhRCCCFagxNPPJETTzyxxmVLly4FEjf8jZWaf88997BlyxZmzpxJZmYm8EeQoUuXLlXWdbvdpKWlsW/fPvbt25dc/2CGDh3KunXrWLlyJVu3bpUZDoQQSXJnI0S5mKIQjkQJBMOU+YKUlgYoKQ0QCccwlE9NmJvtoWNOCtlZMjWhEEII0dpt27aNhQsXAjB+/PhDbv/f//43+bpTp051arNq1SqeeuopTj31VK666qpqy4PBYK3vHUoQ4/rrr0ej0aAoCvfdd1+d29U1W0EI0XLJ3Y1oU1RVJaYohMLRxKwD3iClZYk/oWCUuKJi1OtJcVlpl+kmNzuF3PYp5MrUhEIIIUSbEo1GmThxIoqi0KdPH8aMGVNleeXifzUJh8PceeedANhsNoYOHXrQfcbjcSZOnIhWq2XGjBlVbvorggw//vhjlZkYfv31V3w+Hw6Hg7S0tDofX+/evbn66qsBePnll5PDGg7kww8/5P7776/zPoQQLZMECUSrpKoq0VgiGODzhygtC1BaFqCsLEg4FENVwWzUk+axkZ3pIjc7UU+gY04que0T0xK6nBbsNhMmmZpQCCGEaJU2bdrEXXfdxY8//kgoFAJAURT+85//MGTIEL744gvsdjuzZ8/GYDBUabt06VLOOOMM3njjDXbs2JF8PxqN8tVXXzFw4EC+//57AO6++27cbvdB+/Pss8/yww8/cNttt9GrV68qy/r370/79u3ZuXMnd911F5FIhOLiYm666SYAzjnnnEPObnz66acZOHAgAJMmTeLss8/miy++qJKtUFRUxNy5cxkyZAhjxoyhqKjokPYhhGh5NOrBwqCiXpWVleFyuSgtLcXpdDZ1d2rl9/vZs68URdVht5mbuju1isfjKEqcmJL4W1HiqCpoNRp0ei06nRaTQY/JpMeg16HTaTHodej1WhkmUAd+vx9IPAERbZecB6KCnAvNQygUYvPmzXTq1Amzufbv6GhUYevOQnQ6bb3OrhNXFAC0usbJrKv4fu/YPrXeCwKvWrWKfv36AYlUfbfbjdfrTT6pz87O5r333qtSgLDCkiVLGDx4cPLfFosFm81GaWlplSkTp0yZwgMPPHDQvuzYsYNevXrRrl07fv7552TBxMref/99LrzwQlRVxWQyEY1GicfjpKSksGLFCvLy8g75M4hEItxyyy3MmDGjSoaCy+UiFoslf+4BcnJymDVrFsOHD0cpPw8mTJjAa6+9RseOHdmyZcsh71+0bBXnga6Rfh+IP9T1u+BwSOFC0SLE43FisT+CAfH4H8EAvV6HTq/BYjJhNhkS/9Zp0eu0GAw6yQIQQgjRJmm1GowGPZFoDEWpv3HkfwQJGu85k9GgR6ut/+/zvLw87r77bpYsWcKGDRsoKCjA5XLRvXt3Ro8ezfXXX4/dbq+xbd++fXn88cdZtmwZv/zyCwUFBZSUlGC1WunVqxcDBw5k4sSJ9O3bt059ufHGG/F6vXz00Uc1BggALrjgAj799FP+8Y9/sGrVKux2O0OGDOHhhx8+rAABgNFo5Nlnn+WWW27hlVdeYdGiRWzcuJGioiKMRiNdu3ZlwIABjB49mtGjR9faNyFE6yGZBI1MMgkOrOJpQUxRiClxVEUFDWg1iacger0Wk1GP2WRAp08EAvS6RGaABAPqnzw1FCDngfiDnAvNw6E8PUoE1uv3Uq8pnhxqtZp6zYYQR06eIAuQ86ApSSaBaHViipIMCERjcdS4ikajQVd+EWDQ67Fb9ZiMevTlwwP05emSEgwQQggh6iYx1KB+t1kxWk9uCoQQonWSIIFoMImZBOKVsgP+CAbodVq05fUCnHY9RoMhERww6JLBACGEEEIIIYQQjUuCBOKIVQQDYrE/sgMSCyivF6DFYjJgNhuSxQP1egkGCCGEEEIIIURzI0ECUWeVZxKIxRLFA0GDBpIzCditJoxGPUaDPlk8UGYSEEIIIYQQQoiWQYIE4oDCkRixmB/QoNMmAgE6vQaH7Y+ZBBL1AqR4oBBCCCGEEEK0dBIkELUymwzYbCZMRn1yJoGK4QISDBBCCCGEEEKI1keCBKJWLqdVprkSQgghhBBCiDZEBooLIYQQQgghhBACkCCBEEIIIUSLpKpqU3dBCCFEE2nI7wAJEgghhBBCtCAVMwYpitLEPRFCCNFUKr4DGmIWOQkSCCGEEEK0IAaDAYPBgM/na+quCCGEaCJerzf5fVDfJEgghBBCCNGCaDQaHA4HpaWlBIPBpu6OEEKIRhYMBikrK8PhcDTIrHMyu4EQQgghRAuTlpZGMBhk27ZtOJ1OHA4HOp2uUaYorkhx1el0Db4v0XzJeSBAzoPGpKoqiqLg9XopKyvDZDKRlpbWIPuSIIEQQgghRAuj0+nIzc2loKAAr9dLSUlJo+07Ho8DDTMOVrQcch4IkPOgKRgMBtxuN2lpaQ0WnJEggRBCCCFEC6TT6cjMzCQjI4NoNJq8WG9ogUAAAKvV2ij7E82TnAcC5DxobFqtFoPB0OBZYxIkEEIIIYRowTQaDUajsdH2V5FebDabG22fovmR80CAnAetleSFCCGEEEIIIYQQApAggRBCCCGEEEIIIcpJkEAIIYQQQgghhBCABAmEEEIIIYQQQghRToIEQgghhBBCCCGEACRIIIQQQgghhBBCiHISJBBCCCGEEEIIIQQgQQIhhBBCCCGEEEKUkyCBEEIIIYQQQgghANA3dQfaGlVVASgrK2vinhyY3+8HQFGUJu6JaEpyHgiQ80D8Qc4FAXIeiAQ5DwTIedASORwONBrNAdeRIEEj83q9AOTm5jZxT4QQQgghhBBCtCWlpaU4nc4DrqNRKx5ti0YRj8fZtWtXnSI4TamsrIzc3Fy2b99+0JNItF5yHgiQ80D8Qc4FAXIeiAQ5DwTIedASSSZBM6TVasnJyWnqbtSZ0+mUH3gh54EA5DwQf5BzQYCcByJBzgMBch60NlK4UAghhBBCCCGEEIAECYQQQgghhBBCCFFOggSiRiaTiXvuuQeTydTUXRFNSM4DAXIeiD/IuSBAzgORIOeBADkPWispXCiEEEIIIYQQQghAMgmEEEIIIYQQQghRToIEQgghhBBCCCGEACRIIIQQQgghhBBCiHISJBBCCCGEEEIIIQQgQQKxH6/Xy7Rp0+jbty92ux2Xy8Xxxx/PP//5TyKRSFN3TzSwwsJCXnnlFf7f//t/9OrVC5vNhslkIicnh9GjR/Pvf/+7qbsomtDDDz+MRqNJ/hFtR1lZGY888ggnn3wy6enpyd8LgwcPZtq0aZSUlDR1F0UDW7hwIRdddBEdO3bEbDZjsVjo3Lkzl156Kf/5z3+aunuiHgQCAebPn8/999/P+eefT8eOHZO/76dNm1anbezZs4e//e1v9OjRA4vFQkpKCgMHDmTWrFlIrfSW4UjOg507d/Lcc89x4YUX0rVrVywWCxaLhU6dOjF27FgWLVrUOAchjpwqRLktW7aoeXl5KqACqtVqVU0mU/Lf/fr1U4uKipq6m6IB6fX65P83oJrNZtVms1V576yzzlL9fn9Td1U0st9++001m81VzgXRNixatEjNzMxM/r/r9XrV7XZXORdWrlzZ1N0UDSQej6vXXHNNte8Gi8VS5b1JkyY1dVfFEVq8eHGV/9PKf+65556Dtl++fLmampqabGO326tcVwwbNkwNhUINfyDiiBzuebBt2zZVo9FUWd9qtVb7XXHllVeqsVis8Q5IHBbJJBAAKIrCueeey5YtW2jXrh0LFy7E7/cTCAR45513cDgcrFy5kksvvbSpuyoaUCwW44QTTuC5555j48aNBINBfD4fmzdvZsKECQDMnz+fa665pol7KhpTPB5nwoQJhEIhTjrppKbujmhE3377LSNHjmTPnj2cccYZfPPNN4TDYYqLiwkEAixfvpw777wTl8vV1F0VDeTVV19lxowZAPzf//0fv//+O8FgkEAgwG+//caoUaMAePLJJyXbrBXweDwMHTqUW2+9lbfffpusrKw6tSstLeWcc86hsLCQnj178sMPP+D1evH7/Tz77LMYDAYWLFjApEmTGvgIRH04nPNAURRUVWXo0KG89tpr7Ny5E7/fj8/n49dff03+rnj55ZfrnJkimlBTRylE8zBr1qxkhO+7776rtvytt95KLv/yyy+boIeiMSxatOiAyys/Tdq2bVsj9Uo0taeeekoF1EsvvVS95557JJOgjfD7/Wrnzp1VQL3gggtURVGaukuiCZx++ukqoHbt2lWNRqPVlkcikeR5cskllzRBD0V9qenpbseOHeuUSXDXXXepgGqxWNRNmzZVW/7ggw+qgKrT6dR169bVV5dFAzjc86CkpERdsWJFrcvj8bg6YsSIZJZJMBisj+6KBiKZBAKA1157DYDBgwfX+KTwkksuoVOnTgDMnj27UfsmGs/gwYMPuLwimwBg+fLlDd0d0Qxs3ryZO++8k9TUVJ588smm7o5oRK+//jqbNm3CYrHwwgsvoNXKJUNbtHv3bgCOOeYY9Hp9teUGg4Fjjz0WAJ/P15hdE/VMp9MddtuKa8PK14uV3XTTTdjtdhRF4c033zzs/YiGd7jngcvl4rjjjqt1uUaj4corrwQSvyvWrl17WPsRjUO+8QWBQIBvv/0WgLPOOqvGdTQaDSNGjABgwYIFjdY30byYzebka0VRmrAnorFcffXV+P1+nnjiCdLT05u6O6IRVVz0jxo1irS0tCbujWgqnTt3BuCnn34iFotVWx6NRlm1ahUAAwYMaMyuiWZi3bp1bNu2Daj9OtJutzNw4EBAriPbMrmObDkkSCBYu3Yt8XgcgD59+tS6XsWy/Px8ioqKGqVvonlZsmRJ8nXfvn2briOiUbz44ot89dVXnHHGGYwbN66puyMaUTgcTmYLDRo0iE2bNjFhwgRycnIwmUxkZWUxatQo5s+f38Q9FQ3tuuuuA2DDhg2MHTuWDRs2JJetW7eOiy66iE2bNtGlSxcZb95GrV69Ovm6LteRa9asafA+ieap4jrSaDTSvXv3pu2MOCAJEgh27dqVfN2+ffta16u8rHIb0TaUlJTw0EMPATBw4EB69OjRxD0SDWnnzp3ceuutWCyWZNEy0XZs2bIlOe3tjh07OProo3n55ZfZt28fVquVPXv28PHHH3P22WcnbyJF63Tuuefy5JNPYjQaee+99+jWrRtWqxWr1UrPnj1ZsmQJ1113Hf/73/9wOp1N3V3RBA71OrKsrEyGprRBmzdv5oUXXgDg4osvlt8XzZwECQRerzf52mq11rpe5WWV24jWLx6Pc9lll7F7925MJhPPPPNMU3dJNLBrrrmG0tJSpk2blkw3Fm1HcXFx8vVDDz2EwWDg7bffxufzUVxczLZt27jkkksAeOGFF/jXv/7VVF0VjeCvf/0rH3zwARkZGQAEg0GCwSCQyDrxer2UlpY2ZRdFE5LrSHEwwWCQCy+8kEAgQGpqavKhk2i+JEgghDiom2++mXnz5gHw3HPPccwxxzRxj0RDeuONN/j000859thjueWWW5q6O6IJVAxBq3j9wgsvcMkll2AwGADIzc3lzTffpF+/fgDcf//9NY5XFy1fIBDg4osv5pxzzqFDhw4sWLCAgoIC9u3bx4IFC+jduzdvvPEGJ5xwAj///HNTd1cI0czEYjH+/Oc/s2LFCgwGA2+99dYBM05E8yBBAoHD4Ui+DgQCta5XeVnlNqJ1mzx5Ms8++yyQmAe7ojKtaJ327t3LX//6V3Q6HS+++GKN1cxF61f5d3xubi4XX3xxtXW0Wi1/+9vfACgoKGDFihWN1j/ReG699VbmzJlD9+7dWbp0KWeeeSapqamkpaVx5plnsnTpUrp3705BQQE33HBDU3dXNAG5jhS1URSF//f//h8ffvgher2et956i2HDhjV1t0QdSJBAkJ2dnXy9c+fOWtervKxyG9F6/f3vf+ef//wnAI899hh//etfm7ZDosHddtttFBYWMnHiRHr27InP56vyp2KcOlDje6J1qPyUp2fPnrWud9RRRyVfb926tUH7JBqf1+tl5syZANx4441YLJZq61gsFm688UYAvvnmG/bu3duofRRN71CvI51OJ3a7vcH7JZpWRYDg3XffRafT8cYbb/B///d/Td0tUUcSJBAcddRRyfmvK1eo3V/FsqysLFJSUhqlb6Lp3HrrrTz22GMAPProo0yePLmJeyQaw+bNmwF4/vnncTgc1f5UHkdY8d7f//73puquaCApKSnJQIFGo6l1PVVVk68PtJ5omX7//ffkMJIuXbrUul63bt2Sryt+h4i2o/KMBnW5juzVq1eD90k0LUVRuPTSS3nnnXeSAYKaMtJE8yVBAoHVauWUU04B4PPPP69xHVVV+eKLLwAkTagNmDx5Mo8//jiQCBDceuutTdwjIURjq/hdv3bt2irBgMrWrl2bfN2pU6dG6ZdoPBUPEODAmSJ79uxJvpY08ranR48edOjQAaj9OtLv9/P1118Dch3Z2lUECCpnEFQUuhUthwQJBADjx48HYPHixXz//ffVls+dO5dNmzYByHzprdzkyZOTQwwef/xxCRC0MUuWLEFV1Vr/3HPPPcl1K9576qmnmq7DosFcccUVAGzfvp1333232vJ4PM4TTzwBJIYnHHfccY3aP9HwevbsmRxiMGvWrBqLUyqKkhyS4PF4ZHrcNqri2vCdd95hy5Yt1ZZPnz4dn8+HTqfj0ksvbeTeicaiKAp//vOfeffdd9Hr9bz55psSIGihJEgggESQoG/fvqiqygUXXMBXX30FJC4C586dy9VXXw3AWWedxdChQ5uyq6IB3XbbbckAwRNPPJEsSiaEaHsGDhyYHD963XXX8e677xKNRoFE4ODSSy9l5cqVADzwwANVnjqL1sFisXDVVVcB8OOPP3Luuefyyy+/EI/Hicfj/Pzzz5x99tl89913AMmip6LlKi4upqCgIPmnYqaTQCBQ5X2fz1el3eTJk8nKyiIQCDBy5MhkIdNIJMLzzz/P1KlTAZg4cSLdu3dv3IMSh+xwzgNFUbjsssuYM2dOskihDDFouTRqbTmEos3ZsmULgwcPTkaArVYr8XicUCgEQL9+/fjqq6/weDxN2EvRULZt20bHjh2BRIppenr6AdefPHmy1Clog6ZNm8a9994LUGsKumg9/H4/Z599NkuXLgXAZDJhtVopLi5OrnP33XcnzwnR+gSDQc4///wqaeQmkwmAcDicfG/s2LG8/vrrEiRo4fLy8upUhHT8+PG8+uqrVd5bsWIFw4cPp7CwEEgMPQmFQsng4rBhw/j444+T549ovg7nPFi6dCmDBg0CwGAwHLR+2b/+9S8JIjRjMreVSMrLy+Pnn3/m8ccf54MPPmDz5s0YDAZ69+7N2LFjuemmmzAajU3dTdFA9p8XvfIY05rs/xRBCNH62Gw2Fi9ezMsvv8zrr7/O6tWr8Xq9tG/fnoEDB3LTTTdx8sknN3U3RQOyWCx89tlnvP/++7zxxhusWLGCvXv3otFoyM3N5YQTTuCKK65g5MiRTd1V0cT69+/Pr7/+yiOPPMK8efPYvn07NpuNPn36MH78eK688krJOGrFKl9HRqPRg15HBoPBhu6SOAKSSSCEEEIIIYQQQghAahIIIYQQQgghhBCinAQJhBBCCCGEEEIIAUiQQAghhBBCCCGEEOUkSCCEEEIIIYQQQghAggRCCCGEEEIIIYQoJ0ECIYQQQgghhBBCABIkEEIIIYQQQgghRDkJEgghhBBCCCGEEAKQIIEQQgghhBBCCCHKSZBACCGEaAAajQaNRsOSJUuauiuiHuTl5aHRaHj11VebuiuHZMuWLclzccuWLU3dHSGEEC2ABAmEEEIAMG3atOTNRMUfrVaL0+kkJyeHk08+mRtuuIH33nuPSCTS1N0VQohm4dVXX2XatGkSEBRCtBr6pu6AEEKI5iczMzP5OhgMsmvXLnbu3MmyZct47rnnSE1N5R//+AfXXnstGo2mCXvafPXo0QMAq9XaxD0RbZnBYEieiwaDoYl70zq9+uqr/Oc//wHg9NNPb9rOCCFEPZAggRBCiGry8/Or/FtRFNasWcPChQt59tln2bx5M9dffz3ffPMNb7zxhgQKavDbb781dReEoH379nIuCiGEOCQy3EAIIcRB6XQ6+vbtyy233MLq1au55JJLAHjrrbd4+OGHm7h3QgghhBCivkiQQAghxCGxWq289tpr9OvXD4CHH36YoqKiKuvE43G+/fZbpkyZwp/+9CdycnIwGo2kpqYyaNAgXnjhBaLRaLVtv/DCC2g0GlJTUwmFQrX2IR6PJwvJTZs2rcqy3377jYkTJ9K9e3esVisWi4Xc3Fz+9Kc/cccddxzWU9UdO3YwadIkevfujc1mw2QykZ2dTf/+/Zk0aRI//PBDtTa1FS7cv5Dcnj17uPnmm+nUqRNms5nMzEwuueSSg/YzHo8zZ84cRo8eTfv27TGZTKSnp9O/f3+mTJnC6tWra2wXCoV4+umnGTRoEGlpaRiNRrKyshg9ejSff/75IX82NR1vfn4+N954Y/KYsrKyuPTSSw94TOvWreOxxx7jjDPOoEuXLlgsFpxOJ/369eOuu+6ioKCg1raViwpGIhEee+wxjjnmGGw2Gy6XiyFDhhz02ILBIPfffz+9evXCYrGQkZHB2WefzVdffVXnz2DJkiWMHTuWDh06YDabcblcnHDCCTz66KP4/f4a21x++eVoNBouv/xyIJG6ftJJJ+FyuUhJSeGMM85g6dKlyfVjsRjPPPMM/fv3x+l04nK5OPvss/nxxx9r3H5dChce7rl0MBs3buS6666jW7duyf/P4447jvvuu4+ysrIa2yxZsiTZX4ANGzZw5ZVXkpubi8lkIicnh6uvvpqdO3fWut8j+R3w4YcfMnr0aLKzszEajXg8Hk477bQaf2e9+uqraDSa5FCDe++9t1pdFykWKYRokVQhhBBCVdV77rlHBdS6fjXMnTs3uf5LL71UZdnmzZuTywBVr9erTqezynsDBw5UA4FAlXZer1d1OBwqoL7++uu17nv+/PkqoOp0OnXbtm3J9xcsWKCaTKbkPgwGg+p2u6vs95577qn7h6Kq6qpVq1SPx5Nsr9PpVI/Ho2o0muR748ePr9auYtnixYtr/WzmzZunZmRkqIBqtVqr9N3pdKqrVq2qsU/79u1TTzvttCrH5XK5VIPBkPz3qFGjqrX7/fff1W7duiXX0Wg0qsvlqrKd66677pA+n/2P9+WXX1azsrJUQLVYLKrdbk8uM5vN6vz582ts37Fjxyr9crvdVT7j9u3bq7/99tsB2z7zzDPqiSeemPy/r7xvjUZT7TytUFhYqPbr16/K+Vpx3mg0GvW5555L7uOVV16p1j4ajapXXXVVlc/RbrerOp0u+e8ePXqoW7ZsqdZ2/PjxyXOo4rVer0/+HFT8+5NPPlFDoZA6bNgwFVCNRqNqs9mS61itVnX58uXVtl/5fNu8eXO15Yd7Lh3Mu+++W+V8djgcVf6dm5urrlmzplq7xYsXJ9dZtGhR8v/Q4XCoer0+uSw7O1vdsWNHtfaH+zvA6/Wq55xzTpX1nE5nlXPwpJNOUouKipJt3nnnHTUzMzP5WdlsNjUzM7PKn8q/n4QQoqWQIIEQQghVVQ89SOD1epM3QePGjauybPv27eqoUaPUd999V925c6eqKEqyzSuvvKJmZ2ergDpp0qRq27322mtVQD3ttNNq3ff555+vAuo555xT5f2uXbuqgDps2DD1l19+Sb4fDAbVX375RZ02bZr68ssv1+n4KgwdOlQF1OOOO05dtmyZGo/HVVVV1XA4rP7+++/q448/rj766KPV2tUlSODxeNRTTjlF/eGHH1RVTdxsLly4UG3Xrl0ykLK/aDSqnnLKKSqgmkwm9ZFHHlH37t2rqqqqxmIxdfPmzeqMGTPU22+/vUq74uJiNS8vTwXUIUOGqEuXLlVDoZCqqqpaUlKiPvHEE8kbsqeeeuqQPqPKx+tyudQOHTqoCxYsSH5W33//vdq3b9/kjdf27durtb/44ovVZ555Rt2wYYMaDof/f3t3HlRl9f8B/A33ghcQvOygKMoyYaWSuDWgpFkCGkuppCODS2moU5KKtqjx1ZqSCaemBRfcxsItTVKzSbkuDA6JIEquuJCm7IJCyOVyP78/6J643pUrFvX7vGaYwec853nOc+65D57Pc55ziKitjg8fPkzDhg0Tn4E+mg68s7Mz9erVi77//ntSKpVERHTx4kUaMWKE6LjX1dXp5I+LixP1mZGRQU1NTUREdOPGDYqLiyMbGxuyt7c3GCR46623CAB5enrSV199RTU1NUREpFQqSaFQiADE4MGDxXdBQxMYkMvlZGdnR2vXrhXBs4sXL1JISAgBoL59+9L8+fPJxcWFdu7cSUqlktRqNRUUFJC/vz8BoNDQUJ2yGQsSWNqWTDl9+rToOIeGhlJxcTEREbW2tlJ2drZo3/7+/nT//n2tvO2DBM7OzhQdHU0XLlwgorb2sGPHDhFASUhI0Dm3pfeA2NhYAkABAQH07bff0r1790S+ffv2kZ+fHwGg2NhYnbzh4eEWBSAZY6yr4iABY4wxIup4kICIxFNpfZ0TY06dOiWevGk6ZBrFxcWiHJrOQXvl5eWiA5KdnS22V1RUiHy3b9/uUHmMsbOzIwCUl5fXoXzmBAmCgoJ0RlMQEWVnZ4t9Hu5Qb9iwQTzhPnDggNnlWbRokQgQtLS06N1nz549BIDc3NwM7mOIpry2trZ6nxBXVFSQi4sLAaC5c+d26Nj3798nT09PAkAnTpzQSdcECbp166a3zVRWVpJMJiMAtG3bNq20/Px8UXZ9Iw1UKhWFhYWJfR4OEpw7d46srKzI3t6ezp49q7f89+7dIx8fHwJAe/fu1UrTBAn0lY2I6OrVq1pPs/Vd/5EjRwy2F2NBAkvbkikRERGiw93Y2KiTXlhYKEYFpKWlaaW1DxKMHj1aJ6hCRPT5558T0DZSpX07tfQesH//fgJAXl5eekcnELUFPjUjN4qKirTSOEjAGPuv4TkJGGOMWczFxQUAdOYkMGXIkCHw8PBAY2Mjzpw5o5U2cOBAPPvsswCA9evX6+TdtGkTWlpa4OPjg6ioKLHd0dER1tZtf9bu3LnTofIYI5fLO/2YGgsXLoSdnZ3O9sjISNja2gIAzp07p5W2ceNGAEBUVJTW9RtDRCLfwoULIZXqX9woNjYWTk5OqK6uxunTp82+jvYmTZqE/v3762z38PDAG2+8AQDYsWNHh47ZvXt3hIeHAwByc3MN7jdx4kQEBQXpbHd3dxdt6uzZs1pp27dvBwD07t0bM2bM0MkrkUiwbNkyg+fMzMwEEWH8+PEYMGCA3n0cHR0RGxsLAPjpp5/07tOnTx9MnTpVZ7ufnx/8/f0BACNHjkRYWJjOPuHh4ejWrRsA3eszxpK2ZEpdXZ24xsWLF+tdAvSZZ57Byy+/DADIysoyeKx3331XfKfbi4mJAdA2j8SVK1fEdkvvARs2bAAAJCQkoFevXnr38fHxwejRowEY/gwZY+y/goMEjDHGLEZEBtOUSiUyMjLw4osvomfPnpDJZFoTelVWVgJomxTwYZrO5NatW6FUKrXOl5mZCQCYNWsWJBKJSLOzs8Pzzz8PAIiIiMDy5cuRn5+vld8SEyZMAAAkJiZi4cKFOHbsGP74449HOqbG8OHD9W6XSqVwd3cHoB2AUalUYpLEl156yezznD9/Xhxn+vTp8PLy0vvj7e2NhoYGAEBZWZlF1zRmzBiTaTU1Nbh+/bpO+v79+xEfHw8/Pz84ODhotZedO3cC0N9eNAzVJwD07NkTgG5Aq6CgAEDb+vaGlvIcNWqUwcCKJmjx448/GqxXLy8vbNq0CYDheh0yZIjB83t6egIAhg4dqjddIpHAzc0NAHD37l29+zzM0rZkSmFhobgvjB071uB+L7zwAoC2oIa+SUwBw5+n5rMEtD9PS+8Bms9w3bp1Rj/Dw4cPA7D8u8EYY/8W+v/iMcYYY2bQdEhcXV21tldWVmLs2LFaT8FlMhnc3NxEx76qqgpqtVrvrO+TJ09GcnIyqqursWfPHrHkYk5ODkpLSyGRSDBr1iydfBs2bEB0dDSKi4uxcuVKrFy5Era2thg6dChiYmIwa9YsMfrBXKtXr0ZpaSkUCgXS09ORnp4OiUSC4OBgjB8/HrNnzzb49NEUR0dHg2maTmn7DlRNTY34t6+vr9nnuX37tvi9qqrKrDyWBkKM1UX7tMrKSvTr1w9A2+z606ZN03qqLJVK4ezsLEZU1NfX48GDBwZXCQA6Xp+acpgqt0wmg6urKyoqKnTSNHXb0NAgAizGGKpXc8puyfUZYmlbMkVTn4DxOvXx8QHQFqyora0VgZD2DF1v+4DNw9fb0XtAS0uLWDmjvr4e9fX1Jq+xs4KEjDHWVfFIAsYYYxZpaGjAtWvXAEAMh9ZITk7GuXPn4Orqio0bN+LOnTtoampCVVUVysvLUV5eLp4G6huNIJPJxJJw69atE9s1rx9ERkaid+/eOvn69OmDwsJCHDp0CG+++SZCQkLEcowpKSkICAhATk5Oh65TLpcjJycHJ06cQEpKCkJDQyGVSnH69Gn873//Q2BgoNEh04+LoafO+rS2torfy8vLQW1zEhn90dT/4yyXRmZmJrKysiCRSLB8+XJcuXIFzc3NqK2tFe1l4sSJAIyPXnkUlpQb+KtuP/74Y7Pq9eElMbsCS6+9K56/o/eA9t+N7du3m/UZbt68udPKyxhjXREHCRhjjFnk0KFD4j/Yzz33nNje0tKCPXv2AAC++OILzJgxA15eXlp5W1tbja57D7S9cmBlZYWjR4+itLQU1dXV2Lt3LwBgzpw5BvNZW1tj3Lhx+Oyzz1BQUIDa2lp888036NOnD+7evYupU6da9ApCWFgYPvnkE+Tm5qKurg779u3DgAED0NTUhJkzZ+p9ytzZXF1dYWNjAwAdWn+9ff0/PMdBZzP2OkD7te09PDzE75p5AV577TWkpqYiICBA51308vLyTi6pdjmMlbu5uRk1NTV60zR1+7jrtbNZ2pZMaf+5GqtTTZpmxEhn6sg9QCaToUePHgD+fZ8hY4w9LhwkYIwx1mFKpRIfffQRAKBHjx5iUjagbTj7gwcPALRNUKZPbm6u2MeQwMBAjBkzBkSE9evXi/kJfHx8EBkZaXZZHR0dMXXqVDGXQUVFxSN3BmQyGaKjo0Uw5MGDB0Yn1OssUqkUw4YNAwD88MMPZud7+umn4eTkBOCvDvnjolAoTKa5uLiIVw0A4ObNmwAMt5eGhgbk5+d3Yin/MmTIEADAsWPHDI5SOH78OFQqld600NBQAMCBAwfMet2gq7C0LZkyePBgEeA5cuSIwf007/cPGjRIBCseF1P3AM1nuGvXLqjV6g4fX3O9j2uUC2OM/d04SMAYY6xDmpqaMH36dBQVFQEA3nnnHbECAAA4OTmJ4cPFxcU6+VUqFd577z2zzqWZwHDz5s3itYOHJyzUMDU6oP0qAvry66NSqYx2Giw55qPSzMVw8OBBHDx40Kw8UqkUM2fOBABs2bLFZECjo6tVtLdr1y5cunRJZ3t1dTXWrl0LAIiPj9dK0zzJ1ddeAGDlypW4f/++xWUyRlOW3377DVu2bNFJV6vVWLVqlcH8r7/+OqysrFBXV4fFixcbPVdLS0uXCiRY0pZMkcvlGDduHAAgLS1N7/v7xcXF+O677wAAU6ZM6ZTzApbfA2bPng0AuHz5MtLS0oweo7GxUec8mgBcXV1dR4rLGGNdFgcJGGOMmaRWq1FSUoL09HQ89dRT4h38hIQEpKSkaO3bvXt38WTu7bffRk5Ojuhol5SUICoqCgUFBXBwcDB53tjYWHh7e6OyshKXLl0yOGEhAOTl5WHgwIFYs2YNLly4IM5JRMjLy0NSUhKAtgnTDC1V97Bbt24hMDAQq1atQlFRkdbT5LNnz2LatGkAAAcHB4waNcqsYz6qhIQEhIWFgYjwyiuvIC0tTby60draihs3bmDNmjVYsmSJVr5ly5bB398fKpUKERERSE9P15rEsL6+HocOHUJiYiJGjhxpcflkMhkiIiJw+PBh8WT11KlTGDt2LKqrq+Ho6IilS5dq5YmIiADQNufEunXrRCesvLwcycnJWL16tc7kmJ1l+PDhiI6OBgAkJSVh/fr1aG5uBtAWOIiPj8fJkyf1LuUHAMHBwViwYAEAICMjA5MmTcKZM2fEtbe2topJ9Pz9/XWW/PwnWdqWTPnwww9hY2OD0tJSjBs3Tjy1V6vVOHjwIKKioqBSqeDv72/01aGOsvQeEBMTg7i4OADA0qVLkZSUhMuXL4t0pVKJ/Px8LFmyBL6+vlqTMwJtI3WAtmBL+1dqGGPsX4sYY4wxIlqxYgUBIADk6ekpfuRyOVlbW4s0AOTm5kYZGRkGj1VQUEAODg5i/27dupGjoyMBIKlUSlu3biVfX18CQJs2bTJarvfff18cZ8KECQb3UygUWmW0sbEhV1dXkkqlYpuTkxMdP37c7Dq5fv261jElEgm5uLiQra2t2GZra0u7du3SyatJVygUBo95/fp1g+c2Vj9VVVU0cuRIcRwrKyuSy+VkY2MjtsXExOjku3btGg0aNEjrmuRyOTk5OWltCwgIMLuOHr7ezMxM8vLyIgBkb29P3bt312oH+/fv18l79+5dCgoKEvtZW1uTXC4nKysrAkBz5syhxMREAkCJiYkdqisNY/mrq6u16sXGxobkcrmo2y+//NLoOVQqFS1YsECrDmUymU77A0C5ublml0sjPDycANCKFSsM7mOofKbam6VtyZTt27drfU+cnJxIJpOJf/fu3ZvOnz+vk6/999gYfd+vR7kHNDY20quvvqqV38HBgZydnXXuf7du3dLKe/nyZXFt1tbW5OnpSb6+vuTr60s3b97scN0xxtg/jUcSMMYY01FRUYGKigpUVlZCpVLBy8sLI0aMQFJSEnbv3o3ff//d6BPAkJAQ/PLLL5g8eTLc3NygVqvh6OiIyZMnIy8vDwkJCWaXZdKkSeJ3Y+ccOnQodu7ciaSkJISEhMDNzQ319fWQyWQIDg5GSkoKLly40KGn5L169UJ2djaSk5MxYsQIeHt7o6GhAVKpFE8++STmzZuHkpISMfP+38XNzQ1Hjx7Ftm3bEBkZCXd3dzQ2NsLZ2RkhISFYunSpmDOivX79+qGgoABbt27FhAkT4O3tLYZP9+vXD3Fxcdi4cSNOnjxpcdn8/PxQVFSEefPmwd3dHUqlEh4eHpgyZQqKioowfvx4nTxyuRx5eXlYsGAB+vbtC4lEAqlUiueeew5ZWVnIyMiwuDzmcHV1RV5eHlJTUxEUFARra2tIpVJERETg559/xty5c43ml0gkWLNmDQoLCzF79mw88cQTkEgkqK+vh7OzM0JDQ/HBBx/gzJkzYpRNV2FpWzIlPj4ev/76K+bMmQN/f380NzdDKpUiODgYqampKCkpQf/+/Tv1Wh7lHmBvb4+srCwoFAokJCTAz88ParUaDQ0N8PDwwJgxY7B69WpcuXJFZ2nHwMBAKBQKREdHw93dHTU1NSgrK0NZWZnBuSwYY6wrsyLiWVYYY4x1XZ9++ikWLVoEHx8f3Lhx42979591jGYeCoVCobXaBWOMMcb+XXgkAWOMsS6rtbUVX3/9NYC2ycU4QMAYY4wx9nhxkIAxxliXpFarsWLFCly9ehUODg5ipQPGGGOMMfb4SP/pAjDGGGPt7d69G4sWLUJtba1Y9i41NRXu7u7/cMkYY4wxxv77OEjAGGOsS2loaEBZWRlsbGwQFBSE+fPnY968ef90sRhjjDHG/l/giQsZY4wxxhhjjDEGgOckYIwxxhhjjDHG2J84SMAYY4wxxhhjjDEAHCRgjDHGGGOMMcbYnzhIwBhjjDHGGGOMMQAcJGCMMcYYY4wxxtifOEjAGGOMMcYYY4wxABwkYIwxxhhjjDHG2J84SMAYY4wxxhhjjDEAHCRgjDHGGGOMMcbYn/4PcGcIQdw+Hq4AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = plot_ppc(samples, obs_cases)" - ] + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "f = plot_ppc(samples, obs_cases)", + "id": "f5540a4c6db5fe53" }, { - "cell_type": "markdown", - "id": "african-rolling", "metadata": {}, + "cell_type": "markdown", "source": [ "That's it for this tutorial! You now know how to use the basic building blocks of `BayesFlow` to create amortized neural approximators. :)\n", "\n", "" - ] + ], + "id": "611b9c9fe8769f0f" } ], "metadata": { diff --git a/examples/Two_Moons_Starter.ipynb b/examples/Two_Moons_Starter.ipynb index b9cf2d86a..9238e1e54 100644 --- a/examples/Two_Moons_Starter.ipynb +++ b/examples/Two_Moons_Starter.ipynb @@ -404,105 +404,105 @@ "output_type": "stream", "text": [ "Epoch 1/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 3ms/step - loss: 1.5975 - loss/inference_loss: 1.5975 - val_loss: 0.3615 - val_loss/inference_loss: 0.3615\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 3ms/step - loss: 1.5975 - loss/inference_loss: 1.5975 - val_loss: 0.3615 - val_loss/inference_loss: 0.3615\n", "Epoch 2/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3963 - loss/inference_loss: 0.3963 - val_loss: 0.3259 - val_loss/inference_loss: 0.3259\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3963 - loss/inference_loss: 0.3963 - val_loss: 0.3259 - val_loss/inference_loss: 0.3259\n", "Epoch 3/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3793 - loss/inference_loss: 0.3793 - val_loss: 0.3774 - val_loss/inference_loss: 0.3774\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3793 - loss/inference_loss: 0.3793 - val_loss: 0.3774 - val_loss/inference_loss: 0.3774\n", "Epoch 4/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3734 - loss/inference_loss: 0.3734 - val_loss: 0.2816 - val_loss/inference_loss: 0.2816\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3734 - loss/inference_loss: 0.3734 - val_loss: 0.2816 - val_loss/inference_loss: 0.2816\n", "Epoch 5/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3625 - loss/inference_loss: 0.3625 - val_loss: 0.2620 - val_loss/inference_loss: 0.2620\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3625 - loss/inference_loss: 0.3625 - val_loss: 0.2620 - val_loss/inference_loss: 0.2620\n", "Epoch 6/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3600 - loss/inference_loss: 0.3600 - val_loss: 0.2465 - val_loss/inference_loss: 0.2465\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3600 - loss/inference_loss: 0.3600 - val_loss: 0.2465 - val_loss/inference_loss: 0.2465\n", "Epoch 7/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3646 - loss/inference_loss: 0.3646 - val_loss: 0.3418 - val_loss/inference_loss: 0.3418\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3646 - loss/inference_loss: 0.3646 - val_loss: 0.3418 - val_loss/inference_loss: 0.3418\n", "Epoch 8/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3593 - loss/inference_loss: 0.3593 - val_loss: 0.3830 - val_loss/inference_loss: 0.3830\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3593 - loss/inference_loss: 0.3593 - val_loss: 0.3830 - val_loss/inference_loss: 0.3830\n", "Epoch 9/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3493 - loss/inference_loss: 0.3493 - val_loss: 0.4498 - val_loss/inference_loss: 0.4498\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3493 - loss/inference_loss: 0.3493 - val_loss: 0.4498 - val_loss/inference_loss: 0.4498\n", "Epoch 10/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3492 - loss/inference_loss: 0.3492 - val_loss: 0.3947 - val_loss/inference_loss: 0.3947\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3492 - loss/inference_loss: 0.3492 - val_loss: 0.3947 - val_loss/inference_loss: 0.3947\n", "Epoch 11/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3459 - loss/inference_loss: 0.3459 - val_loss: 0.2970 - val_loss/inference_loss: 0.2970\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3459 - loss/inference_loss: 0.3459 - val_loss: 0.2970 - val_loss/inference_loss: 0.2970\n", "Epoch 12/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3457 - loss/inference_loss: 0.3457 - val_loss: 0.2243 - val_loss/inference_loss: 0.2243\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3457 - loss/inference_loss: 0.3457 - val_loss: 0.2243 - val_loss/inference_loss: 0.2243\n", "Epoch 13/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3451 - loss/inference_loss: 0.3451 - val_loss: 0.4153 - val_loss/inference_loss: 0.4153\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3451 - loss/inference_loss: 0.3451 - val_loss: 0.4153 - val_loss/inference_loss: 0.4153\n", "Epoch 14/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3433 - loss/inference_loss: 0.3433 - val_loss: 0.3919 - val_loss/inference_loss: 0.3919\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3433 - loss/inference_loss: 0.3433 - val_loss: 0.3919 - val_loss/inference_loss: 0.3919\n", "Epoch 15/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3373 - loss/inference_loss: 0.3373 - val_loss: 0.3400 - val_loss/inference_loss: 0.3400\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3373 - loss/inference_loss: 0.3373 - val_loss: 0.3400 - val_loss/inference_loss: 0.3400\n", "Epoch 16/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3440 - loss/inference_loss: 0.3440 - val_loss: 0.1885 - val_loss/inference_loss: 0.1885\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3440 - loss/inference_loss: 0.3440 - val_loss: 0.1885 - val_loss/inference_loss: 0.1885\n", "Epoch 17/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3429 - loss/inference_loss: 0.3429 - val_loss: 0.3297 - val_loss/inference_loss: 0.3297\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3429 - loss/inference_loss: 0.3429 - val_loss: 0.3297 - val_loss/inference_loss: 0.3297\n", "Epoch 18/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3389 - loss/inference_loss: 0.3389 - val_loss: 0.3932 - val_loss/inference_loss: 0.3932\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3389 - loss/inference_loss: 0.3389 - val_loss: 0.3932 - val_loss/inference_loss: 0.3932\n", "Epoch 19/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3330 - loss/inference_loss: 0.3330 - val_loss: 0.2640 - val_loss/inference_loss: 0.2640\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3330 - loss/inference_loss: 0.3330 - val_loss: 0.2640 - val_loss/inference_loss: 0.2640\n", "Epoch 20/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3272 - loss/inference_loss: 0.3272 - val_loss: 0.3262 - val_loss/inference_loss: 0.3262\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3272 - loss/inference_loss: 0.3272 - val_loss: 0.3262 - val_loss/inference_loss: 0.3262\n", "Epoch 21/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3301 - loss/inference_loss: 0.3301 - val_loss: 0.4301 - val_loss/inference_loss: 0.4301\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3301 - loss/inference_loss: 0.3301 - val_loss: 0.4301 - val_loss/inference_loss: 0.4301\n", "Epoch 22/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3329 - loss/inference_loss: 0.3329 - val_loss: 0.4407 - val_loss/inference_loss: 0.4407\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3329 - loss/inference_loss: 0.3329 - val_loss: 0.4407 - val_loss/inference_loss: 0.4407\n", "Epoch 23/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3384 - loss/inference_loss: 0.3384 - val_loss: 0.2786 - val_loss/inference_loss: 0.2786\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3384 - loss/inference_loss: 0.3384 - val_loss: 0.2786 - val_loss/inference_loss: 0.2786\n", "Epoch 24/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3283 - loss/inference_loss: 0.3283 - val_loss: 0.3840 - val_loss/inference_loss: 0.3840\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3283 - loss/inference_loss: 0.3283 - val_loss: 0.3840 - val_loss/inference_loss: 0.3840\n", "Epoch 25/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3235 - loss/inference_loss: 0.3235 - val_loss: 0.3168 - val_loss/inference_loss: 0.3168\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3235 - loss/inference_loss: 0.3235 - val_loss: 0.3168 - val_loss/inference_loss: 0.3168\n", "Epoch 26/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3227 - loss/inference_loss: 0.3227 - val_loss: 0.2289 - val_loss/inference_loss: 0.2289\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3227 - loss/inference_loss: 0.3227 - val_loss: 0.2289 - val_loss/inference_loss: 0.2289\n", "Epoch 27/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3367 - loss/inference_loss: 0.3367 - val_loss: 0.2283 - val_loss/inference_loss: 0.2283\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3367 - loss/inference_loss: 0.3367 - val_loss: 0.2283 - val_loss/inference_loss: 0.2283\n", "Epoch 28/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3331 - loss/inference_loss: 0.3331 - val_loss: 0.3331 - val_loss/inference_loss: 0.3331\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3331 - loss/inference_loss: 0.3331 - val_loss: 0.3331 - val_loss/inference_loss: 0.3331\n", "Epoch 29/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3281 - loss/inference_loss: 0.3281 - val_loss: 0.1447 - val_loss/inference_loss: 0.1447\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3281 - loss/inference_loss: 0.3281 - val_loss: 0.1447 - val_loss/inference_loss: 0.1447\n", "Epoch 30/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3228 - loss/inference_loss: 0.3228 - val_loss: 0.2868 - val_loss/inference_loss: 0.2868\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3228 - loss/inference_loss: 0.3228 - val_loss: 0.2868 - val_loss/inference_loss: 0.2868\n", "Epoch 31/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3226 - loss/inference_loss: 0.3226 - val_loss: 0.2819 - val_loss/inference_loss: 0.2819\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3226 - loss/inference_loss: 0.3226 - val_loss: 0.2819 - val_loss/inference_loss: 0.2819\n", "Epoch 32/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3167 - loss/inference_loss: 0.3167 - val_loss: 0.3676 - val_loss/inference_loss: 0.3676\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3167 - loss/inference_loss: 0.3167 - val_loss: 0.3676 - val_loss/inference_loss: 0.3676\n", "Epoch 33/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3264 - loss/inference_loss: 0.3264 - val_loss: 0.2303 - val_loss/inference_loss: 0.2303\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3264 - loss/inference_loss: 0.3264 - val_loss: 0.2303 - val_loss/inference_loss: 0.2303\n", "Epoch 34/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3141 - loss/inference_loss: 0.3141 - val_loss: 0.2125 - val_loss/inference_loss: 0.2125\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3141 - loss/inference_loss: 0.3141 - val_loss: 0.2125 - val_loss/inference_loss: 0.2125\n", "Epoch 35/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3096 - loss/inference_loss: 0.3096 - val_loss: 0.2754 - val_loss/inference_loss: 0.2754\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3096 - loss/inference_loss: 0.3096 - val_loss: 0.2754 - val_loss/inference_loss: 0.2754\n", "Epoch 36/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3187 - loss/inference_loss: 0.3187 - val_loss: 0.3006 - val_loss/inference_loss: 0.3006\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3187 - loss/inference_loss: 0.3187 - val_loss: 0.3006 - val_loss/inference_loss: 0.3006\n", "Epoch 37/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3157 - loss/inference_loss: 0.3157 - val_loss: 0.3113 - val_loss/inference_loss: 0.3113\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3157 - loss/inference_loss: 0.3157 - val_loss: 0.3113 - val_loss/inference_loss: 0.3113\n", "Epoch 38/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3212 - loss/inference_loss: 0.3212 - val_loss: 0.4190 - val_loss/inference_loss: 0.4190\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3212 - loss/inference_loss: 0.3212 - val_loss: 0.4190 - val_loss/inference_loss: 0.4190\n", "Epoch 39/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3162 - loss/inference_loss: 0.3162 - val_loss: 0.3351 - val_loss/inference_loss: 0.3351\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3162 - loss/inference_loss: 0.3162 - val_loss: 0.3351 - val_loss/inference_loss: 0.3351\n", "Epoch 40/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3159 - loss/inference_loss: 0.3159 - val_loss: 0.3813 - val_loss/inference_loss: 0.3813\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3159 - loss/inference_loss: 0.3159 - val_loss: 0.3813 - val_loss/inference_loss: 0.3813\n", "Epoch 41/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3134 - loss/inference_loss: 0.3134 - val_loss: 0.4158 - val_loss/inference_loss: 0.4158\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3134 - loss/inference_loss: 0.3134 - val_loss: 0.4158 - val_loss/inference_loss: 0.4158\n", "Epoch 42/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3142 - loss/inference_loss: 0.3142 - val_loss: 0.5772 - val_loss/inference_loss: 0.5772\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3142 - loss/inference_loss: 0.3142 - val_loss: 0.5772 - val_loss/inference_loss: 0.5772\n", "Epoch 43/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3136 - loss/inference_loss: 0.3136 - val_loss: 0.3419 - val_loss/inference_loss: 0.3419\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3136 - loss/inference_loss: 0.3136 - val_loss: 0.3419 - val_loss/inference_loss: 0.3419\n", "Epoch 44/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.3104 - loss/inference_loss: 0.3104 - val_loss: 0.5761 - val_loss/inference_loss: 0.5761\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 3ms/step - loss: 0.3104 - loss/inference_loss: 0.3104 - val_loss: 0.5761 - val_loss/inference_loss: 0.5761\n", "Epoch 45/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3166 - loss/inference_loss: 0.3166 - val_loss: 0.2678 - val_loss/inference_loss: 0.2678\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3166 - loss/inference_loss: 0.3166 - val_loss: 0.2678 - val_loss/inference_loss: 0.2678\n", "Epoch 46/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3197 - loss/inference_loss: 0.3197 - val_loss: 0.3576 - val_loss/inference_loss: 0.3576\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3197 - loss/inference_loss: 0.3197 - val_loss: 0.3576 - val_loss/inference_loss: 0.3576\n", "Epoch 47/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3165 - loss/inference_loss: 0.3165 - val_loss: 0.3637 - val_loss/inference_loss: 0.3637\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3165 - loss/inference_loss: 0.3165 - val_loss: 0.3637 - val_loss/inference_loss: 0.3637\n", "Epoch 48/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3145 - loss/inference_loss: 0.3145 - val_loss: 0.3348 - val_loss/inference_loss: 0.3348\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3145 - loss/inference_loss: 0.3145 - val_loss: 0.3348 - val_loss/inference_loss: 0.3348\n", "Epoch 49/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: 0.3104 - loss/inference_loss: 0.3104 - val_loss: 0.3068 - val_loss/inference_loss: 0.3068\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: 0.3104 - loss/inference_loss: 0.3104 - val_loss: 0.3068 - val_loss/inference_loss: 0.3068\n", "Epoch 50/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: 0.3090 - loss/inference_loss: 0.3090 - val_loss: 0.4407 - val_loss/inference_loss: 0.4407\n" + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: 0.3090 - loss/inference_loss: 0.3090 - val_loss: 0.4407 - val_loss/inference_loss: 0.4407\n" ] } ], @@ -637,105 +637,105 @@ "output_type": "stream", "text": [ "Epoch 1/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 4ms/step - loss: 0.3549 - loss/inference_loss: 0.3549 - val_loss: 0.2793 - val_loss/inference_loss: 0.2793\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 4ms/step - loss: 0.3549 - loss/inference_loss: 0.3549 - val_loss: 0.2793 - val_loss/inference_loss: 0.2793\n", "Epoch 2/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.3020 - loss/inference_loss: 0.3020 - val_loss: 0.3505 - val_loss/inference_loss: 0.3505\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.3020 - loss/inference_loss: 0.3020 - val_loss: 0.3505 - val_loss/inference_loss: 0.3505\n", "Epoch 3/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2831 - loss/inference_loss: 0.2831 - val_loss: 0.2429 - val_loss/inference_loss: 0.2429\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2831 - loss/inference_loss: 0.2831 - val_loss: 0.2429 - val_loss/inference_loss: 0.2429\n", "Epoch 4/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2813 - loss/inference_loss: 0.2813 - val_loss: 0.3600 - val_loss/inference_loss: 0.3600\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2813 - loss/inference_loss: 0.2813 - val_loss: 0.3600 - val_loss/inference_loss: 0.3600\n", "Epoch 5/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2732 - loss/inference_loss: 0.2732 - val_loss: 0.2537 - val_loss/inference_loss: 0.2537\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2732 - loss/inference_loss: 0.2732 - val_loss: 0.2537 - val_loss/inference_loss: 0.2537\n", "Epoch 6/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2722 - loss/inference_loss: 0.2722 - val_loss: 0.2904 - val_loss/inference_loss: 0.2904\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2722 - loss/inference_loss: 0.2722 - val_loss: 0.2904 - val_loss/inference_loss: 0.2904\n", "Epoch 7/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2618 - loss/inference_loss: 0.2618 - val_loss: 0.1984 - val_loss/inference_loss: 0.1984\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2618 - loss/inference_loss: 0.2618 - val_loss: 0.1984 - val_loss/inference_loss: 0.1984\n", "Epoch 8/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2663 - loss/inference_loss: 0.2663 - val_loss: 0.1680 - val_loss/inference_loss: 0.1680\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2663 - loss/inference_loss: 0.2663 - val_loss: 0.1680 - val_loss/inference_loss: 0.1680\n", "Epoch 9/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2599 - loss/inference_loss: 0.2599 - val_loss: 0.2595 - val_loss/inference_loss: 0.2595\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2599 - loss/inference_loss: 0.2599 - val_loss: 0.2595 - val_loss/inference_loss: 0.2595\n", "Epoch 10/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2567 - loss/inference_loss: 0.2567 - val_loss: 0.2612 - val_loss/inference_loss: 0.2612\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2567 - loss/inference_loss: 0.2567 - val_loss: 0.2612 - val_loss/inference_loss: 0.2612\n", "Epoch 11/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2530 - loss/inference_loss: 0.2530 - val_loss: 0.2694 - val_loss/inference_loss: 0.2694\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2530 - loss/inference_loss: 0.2530 - val_loss: 0.2694 - val_loss/inference_loss: 0.2694\n", "Epoch 12/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2596 - loss/inference_loss: 0.2596 - val_loss: 0.3073 - val_loss/inference_loss: 0.3073\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2596 - loss/inference_loss: 0.2596 - val_loss: 0.3073 - val_loss/inference_loss: 0.3073\n", "Epoch 13/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2566 - loss/inference_loss: 0.2566 - val_loss: 0.1798 - val_loss/inference_loss: 0.1798\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2566 - loss/inference_loss: 0.2566 - val_loss: 0.1798 - val_loss/inference_loss: 0.1798\n", "Epoch 14/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2589 - loss/inference_loss: 0.2589 - val_loss: 0.2743 - val_loss/inference_loss: 0.2743\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2589 - loss/inference_loss: 0.2589 - val_loss: 0.2743 - val_loss/inference_loss: 0.2743\n", "Epoch 15/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2493 - loss/inference_loss: 0.2493 - val_loss: 0.2189 - val_loss/inference_loss: 0.2189\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2493 - loss/inference_loss: 0.2493 - val_loss: 0.2189 - val_loss/inference_loss: 0.2189\n", "Epoch 16/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2649 - loss/inference_loss: 0.2649 - val_loss: 0.2154 - val_loss/inference_loss: 0.2154\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2649 - loss/inference_loss: 0.2649 - val_loss: 0.2154 - val_loss/inference_loss: 0.2154\n", "Epoch 17/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2609 - loss/inference_loss: 0.2609 - val_loss: 0.2758 - val_loss/inference_loss: 0.2758\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2609 - loss/inference_loss: 0.2609 - val_loss: 0.2758 - val_loss/inference_loss: 0.2758\n", "Epoch 18/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2526 - loss/inference_loss: 0.2526 - val_loss: 0.1542 - val_loss/inference_loss: 0.1542\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2526 - loss/inference_loss: 0.2526 - val_loss: 0.1542 - val_loss/inference_loss: 0.1542\n", "Epoch 19/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2510 - loss/inference_loss: 0.2510 - val_loss: 0.1860 - val_loss/inference_loss: 0.1860\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2510 - loss/inference_loss: 0.2510 - val_loss: 0.1860 - val_loss/inference_loss: 0.1860\n", "Epoch 20/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2559 - loss/inference_loss: 0.2559 - val_loss: 0.2213 - val_loss/inference_loss: 0.2213\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2559 - loss/inference_loss: 0.2559 - val_loss: 0.2213 - val_loss/inference_loss: 0.2213\n", "Epoch 21/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2524 - loss/inference_loss: 0.2524 - val_loss: 0.2497 - val_loss/inference_loss: 0.2497\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2524 - loss/inference_loss: 0.2524 - val_loss: 0.2497 - val_loss/inference_loss: 0.2497\n", "Epoch 22/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2477 - loss/inference_loss: 0.2477 - val_loss: 0.2030 - val_loss/inference_loss: 0.2030\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2477 - loss/inference_loss: 0.2477 - val_loss: 0.2030 - val_loss/inference_loss: 0.2030\n", "Epoch 23/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2447 - loss/inference_loss: 0.2447 - val_loss: 0.2862 - val_loss/inference_loss: 0.2862\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2447 - loss/inference_loss: 0.2447 - val_loss: 0.2862 - val_loss/inference_loss: 0.2862\n", "Epoch 24/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2451 - loss/inference_loss: 0.2451 - val_loss: 0.3859 - val_loss/inference_loss: 0.3859\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2451 - loss/inference_loss: 0.2451 - val_loss: 0.3859 - val_loss/inference_loss: 0.3859\n", "Epoch 25/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2429 - loss/inference_loss: 0.2429 - val_loss: 0.2310 - val_loss/inference_loss: 0.2310\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2429 - loss/inference_loss: 0.2429 - val_loss: 0.2310 - val_loss/inference_loss: 0.2310\n", "Epoch 26/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2437 - loss/inference_loss: 0.2437 - val_loss: 0.2236 - val_loss/inference_loss: 0.2236\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2437 - loss/inference_loss: 0.2437 - val_loss: 0.2236 - val_loss/inference_loss: 0.2236\n", "Epoch 27/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2432 - loss/inference_loss: 0.2432 - val_loss: 0.3466 - val_loss/inference_loss: 0.3466\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2432 - loss/inference_loss: 0.2432 - val_loss: 0.3466 - val_loss/inference_loss: 0.3466\n", "Epoch 28/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2353 - loss/inference_loss: 0.2353 - val_loss: 0.2234 - val_loss/inference_loss: 0.2234\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2353 - loss/inference_loss: 0.2353 - val_loss: 0.2234 - val_loss/inference_loss: 0.2234\n", "Epoch 29/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2351 - loss/inference_loss: 0.2351 - val_loss: 0.1637 - val_loss/inference_loss: 0.1637\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2351 - loss/inference_loss: 0.2351 - val_loss: 0.1637 - val_loss/inference_loss: 0.1637\n", "Epoch 30/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2364 - loss/inference_loss: 0.2364 - val_loss: 0.2324 - val_loss/inference_loss: 0.2324\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2364 - loss/inference_loss: 0.2364 - val_loss: 0.2324 - val_loss/inference_loss: 0.2324\n", "Epoch 31/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2310 - loss/inference_loss: 0.2310 - val_loss: 0.1853 - val_loss/inference_loss: 0.1853\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2310 - loss/inference_loss: 0.2310 - val_loss: 0.1853 - val_loss/inference_loss: 0.1853\n", "Epoch 32/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2287 - loss/inference_loss: 0.2287 - val_loss: 0.1234 - val_loss/inference_loss: 0.1234\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2287 - loss/inference_loss: 0.2287 - val_loss: 0.1234 - val_loss/inference_loss: 0.1234\n", "Epoch 33/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2159 - loss/inference_loss: 0.2159 - val_loss: 0.1985 - val_loss/inference_loss: 0.1985\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2159 - loss/inference_loss: 0.2159 - val_loss: 0.1985 - val_loss/inference_loss: 0.1985\n", "Epoch 34/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2228 - loss/inference_loss: 0.2228 - val_loss: 0.4063 - val_loss/inference_loss: 0.4063\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2228 - loss/inference_loss: 0.2228 - val_loss: 0.4063 - val_loss/inference_loss: 0.4063\n", "Epoch 35/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2155 - loss/inference_loss: 0.2155 - val_loss: 0.2233 - val_loss/inference_loss: 0.2233\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2155 - loss/inference_loss: 0.2155 - val_loss: 0.2233 - val_loss/inference_loss: 0.2233\n", "Epoch 36/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2257 - loss/inference_loss: 0.2257 - val_loss: 0.1208 - val_loss/inference_loss: 0.1208\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2257 - loss/inference_loss: 0.2257 - val_loss: 0.1208 - val_loss/inference_loss: 0.1208\n", "Epoch 37/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2231 - loss/inference_loss: 0.2231 - val_loss: 0.0776 - val_loss/inference_loss: 0.0776\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2231 - loss/inference_loss: 0.2231 - val_loss: 0.0776 - val_loss/inference_loss: 0.0776\n", "Epoch 38/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2193 - loss/inference_loss: 0.2193 - val_loss: 0.2310 - val_loss/inference_loss: 0.2310\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2193 - loss/inference_loss: 0.2193 - val_loss: 0.2310 - val_loss/inference_loss: 0.2310\n", "Epoch 39/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2204 - loss/inference_loss: 0.2204 - val_loss: 0.1733 - val_loss/inference_loss: 0.1733\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2204 - loss/inference_loss: 0.2204 - val_loss: 0.1733 - val_loss/inference_loss: 0.1733\n", "Epoch 40/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2219 - loss/inference_loss: 0.2219 - val_loss: 0.1291 - val_loss/inference_loss: 0.1291\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2219 - loss/inference_loss: 0.2219 - val_loss: 0.1291 - val_loss/inference_loss: 0.1291\n", "Epoch 41/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2127 - loss/inference_loss: 0.2127 - val_loss: 0.1073 - val_loss/inference_loss: 0.1073\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2127 - loss/inference_loss: 0.2127 - val_loss: 0.1073 - val_loss/inference_loss: 0.1073\n", "Epoch 42/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2257 - loss/inference_loss: 0.2257 - val_loss: 0.2174 - val_loss/inference_loss: 0.2174\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2257 - loss/inference_loss: 0.2257 - val_loss: 0.2174 - val_loss/inference_loss: 0.2174\n", "Epoch 43/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2178 - loss/inference_loss: 0.2178 - val_loss: 0.2001 - val_loss/inference_loss: 0.2001\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2178 - loss/inference_loss: 0.2178 - val_loss: 0.2001 - val_loss/inference_loss: 0.2001\n", "Epoch 44/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2150 - loss/inference_loss: 0.2150 - val_loss: 0.2282 - val_loss/inference_loss: 0.2282\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2150 - loss/inference_loss: 0.2150 - val_loss: 0.2282 - val_loss/inference_loss: 0.2282\n", "Epoch 45/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2130 - loss/inference_loss: 0.2130 - val_loss: 0.1956 - val_loss/inference_loss: 0.1956\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2130 - loss/inference_loss: 0.2130 - val_loss: 0.1956 - val_loss/inference_loss: 0.1956\n", "Epoch 46/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2046 - loss/inference_loss: 0.2046 - val_loss: 0.1937 - val_loss/inference_loss: 0.1937\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2046 - loss/inference_loss: 0.2046 - val_loss: 0.1937 - val_loss/inference_loss: 0.1937\n", "Epoch 47/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2082 - loss/inference_loss: 0.2082 - val_loss: 0.2303 - val_loss/inference_loss: 0.2303\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2082 - loss/inference_loss: 0.2082 - val_loss: 0.2303 - val_loss/inference_loss: 0.2303\n", "Epoch 48/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2067 - loss/inference_loss: 0.2067 - val_loss: 0.1300 - val_loss/inference_loss: 0.1300\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2067 - loss/inference_loss: 0.2067 - val_loss: 0.1300 - val_loss/inference_loss: 0.1300\n", "Epoch 49/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: 0.2201 - loss/inference_loss: 0.2201 - val_loss: 0.1432 - val_loss/inference_loss: 0.1432\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: 0.2201 - loss/inference_loss: 0.2201 - val_loss: 0.1432 - val_loss/inference_loss: 0.1432\n", "Epoch 50/50\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 3ms/step - loss: 0.2097 - loss/inference_loss: 0.2097 - val_loss: 0.1791 - val_loss/inference_loss: 0.1791\n" + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 3ms/step - loss: 0.2097 - loss/inference_loss: 0.2097 - val_loss: 0.1791 - val_loss/inference_loss: 0.1791\n" ] } ], @@ -828,65 +828,65 @@ "output_type": "stream", "text": [ "Epoch 1/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 6ms/step - loss: -1.2724 - loss/inference_loss: -1.2724 - val_loss: -2.2869 - val_loss/inference_loss: -2.2869\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m11s\u001B[0m 6ms/step - loss: -1.2724 - loss/inference_loss: -1.2724 - val_loss: -2.2869 - val_loss/inference_loss: -2.2869\n", "Epoch 2/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -2.4998 - loss/inference_loss: -2.4998 - val_loss: -2.1505 - val_loss/inference_loss: -2.1505\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -2.4998 - loss/inference_loss: -2.4998 - val_loss: -2.1505 - val_loss/inference_loss: -2.1505\n", "Epoch 3/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -2.6645 - loss/inference_loss: -2.6645 - val_loss: -2.6893 - val_loss/inference_loss: -2.6893\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -2.6645 - loss/inference_loss: -2.6645 - val_loss: -2.6893 - val_loss/inference_loss: -2.6893\n", "Epoch 4/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: -2.7494 - loss/inference_loss: -2.7494 - val_loss: -2.4783 - val_loss/inference_loss: -2.4783\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: -2.7494 - loss/inference_loss: -2.7494 - val_loss: -2.4783 - val_loss/inference_loss: -2.4783\n", "Epoch 5/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -2.7852 - loss/inference_loss: -2.7852 - val_loss: -2.7409 - val_loss/inference_loss: -2.7409\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -2.7852 - loss/inference_loss: -2.7852 - val_loss: -2.7409 - val_loss/inference_loss: -2.7409\n", "Epoch 6/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: -2.8575 - loss/inference_loss: -2.8575 - val_loss: -2.6789 - val_loss/inference_loss: -2.6789\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: -2.8575 - loss/inference_loss: -2.8575 - val_loss: -2.6789 - val_loss/inference_loss: -2.6789\n", "Epoch 7/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: -2.9127 - loss/inference_loss: -2.9127 - val_loss: -3.0435 - val_loss/inference_loss: -3.0435\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: -2.9127 - loss/inference_loss: -2.9127 - val_loss: -3.0435 - val_loss/inference_loss: -3.0435\n", "Epoch 8/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -2.9346 - loss/inference_loss: -2.9346 - val_loss: -2.9628 - val_loss/inference_loss: -2.9628\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -2.9346 - loss/inference_loss: -2.9346 - val_loss: -2.9628 - val_loss/inference_loss: -2.9628\n", "Epoch 9/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -2.9371 - loss/inference_loss: -2.9371 - val_loss: -2.3899 - val_loss/inference_loss: -2.3899\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -2.9371 - loss/inference_loss: -2.9371 - val_loss: -2.3899 - val_loss/inference_loss: -2.3899\n", "Epoch 10/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step - loss: -2.9999 - loss/inference_loss: -2.9999 - val_loss: -2.9758 - val_loss/inference_loss: -2.9758\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 4ms/step - loss: -2.9999 - loss/inference_loss: -2.9999 - val_loss: -2.9758 - val_loss/inference_loss: -2.9758\n", "Epoch 11/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.0083 - loss/inference_loss: -3.0083 - val_loss: -2.5975 - val_loss/inference_loss: -2.5975\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.0083 - loss/inference_loss: -3.0083 - val_loss: -2.5975 - val_loss/inference_loss: -2.5975\n", "Epoch 12/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.0434 - loss/inference_loss: -3.0434 - val_loss: -3.0387 - val_loss/inference_loss: -3.0387\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.0434 - loss/inference_loss: -3.0434 - val_loss: -3.0387 - val_loss/inference_loss: -3.0387\n", "Epoch 13/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.0920 - loss/inference_loss: -3.0920 - val_loss: -2.3253 - val_loss/inference_loss: -2.3253\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.0920 - loss/inference_loss: -3.0920 - val_loss: -2.3253 - val_loss/inference_loss: -2.3253\n", "Epoch 14/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.1255 - loss/inference_loss: -3.1255 - val_loss: -3.1556 - val_loss/inference_loss: -3.1556\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.1255 - loss/inference_loss: -3.1255 - val_loss: -3.1556 - val_loss/inference_loss: -3.1556\n", "Epoch 15/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.1654 - loss/inference_loss: -3.1654 - val_loss: -2.8726 - val_loss/inference_loss: -2.8726\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.1654 - loss/inference_loss: -3.1654 - val_loss: -2.8726 - val_loss/inference_loss: -2.8726\n", "Epoch 16/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.1779 - loss/inference_loss: -3.1779 - val_loss: -3.1917 - val_loss/inference_loss: -3.1917\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.1779 - loss/inference_loss: -3.1779 - val_loss: -3.1917 - val_loss/inference_loss: -3.1917\n", "Epoch 17/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.2124 - loss/inference_loss: -3.2124 - val_loss: -2.1857 - val_loss/inference_loss: -2.1857\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.2124 - loss/inference_loss: -3.2124 - val_loss: -2.1857 - val_loss/inference_loss: -2.1857\n", "Epoch 18/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.2409 - loss/inference_loss: -3.2409 - val_loss: -2.9640 - val_loss/inference_loss: -2.9640\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.2409 - loss/inference_loss: -3.2409 - val_loss: -2.9640 - val_loss/inference_loss: -2.9640\n", "Epoch 19/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.2689 - loss/inference_loss: -3.2689 - val_loss: -2.7462 - val_loss/inference_loss: -2.7462\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.2689 - loss/inference_loss: -3.2689 - val_loss: -2.7462 - val_loss/inference_loss: -2.7462\n", "Epoch 20/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.2759 - loss/inference_loss: -3.2759 - val_loss: -2.9262 - val_loss/inference_loss: -2.9262\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.2759 - loss/inference_loss: -3.2759 - val_loss: -2.9262 - val_loss/inference_loss: -2.9262\n", "Epoch 21/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.3185 - loss/inference_loss: -3.3185 - val_loss: -2.1308 - val_loss/inference_loss: -2.1308\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.3185 - loss/inference_loss: -3.3185 - val_loss: -2.1308 - val_loss/inference_loss: -2.1308\n", "Epoch 22/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.3447 - loss/inference_loss: -3.3447 - val_loss: -2.6838 - val_loss/inference_loss: -2.6838\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.3447 - loss/inference_loss: -3.3447 - val_loss: -2.6838 - val_loss/inference_loss: -2.6838\n", "Epoch 23/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.3607 - loss/inference_loss: -3.3607 - val_loss: -3.4517 - val_loss/inference_loss: -3.4517\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.3607 - loss/inference_loss: -3.3607 - val_loss: -3.4517 - val_loss/inference_loss: -3.4517\n", "Epoch 24/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.3540 - loss/inference_loss: -3.3540 - val_loss: -3.0357 - val_loss/inference_loss: -3.0357\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.3540 - loss/inference_loss: -3.3540 - val_loss: -3.0357 - val_loss/inference_loss: -3.0357\n", "Epoch 25/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.3831 - loss/inference_loss: -3.3831 - val_loss: -3.3768 - val_loss/inference_loss: -3.3768\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.3831 - loss/inference_loss: -3.3831 - val_loss: -3.3768 - val_loss/inference_loss: -3.3768\n", "Epoch 26/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.4183 - loss/inference_loss: -3.4183 - val_loss: -3.1671 - val_loss/inference_loss: -3.1671\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.4183 - loss/inference_loss: -3.4183 - val_loss: -3.1671 - val_loss/inference_loss: -3.1671\n", "Epoch 27/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.4194 - loss/inference_loss: -3.4194 - val_loss: 9.2951 - val_loss/inference_loss: 9.2951\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.4194 - loss/inference_loss: -3.4194 - val_loss: 9.2951 - val_loss/inference_loss: 9.2951\n", "Epoch 28/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.3851 - loss/inference_loss: -3.3851 - val_loss: -2.9896 - val_loss/inference_loss: -2.9896\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.3851 - loss/inference_loss: -3.3851 - val_loss: -2.9896 - val_loss/inference_loss: -2.9896\n", "Epoch 29/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: -3.4251 - loss/inference_loss: -3.4251 - val_loss: -3.3175 - val_loss/inference_loss: -3.3175\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 5ms/step - loss: -3.4251 - loss/inference_loss: -3.4251 - val_loss: -3.3175 - val_loss/inference_loss: -3.3175\n", "Epoch 30/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - loss: -3.4083 - loss/inference_loss: -3.4083 - val_loss: -3.2599 - val_loss/inference_loss: -3.2599\n" + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 5ms/step - loss: -3.4083 - loss/inference_loss: -3.4083 - val_loss: -3.2599 - val_loss/inference_loss: -3.2599\n" ] } ], @@ -918,65 +918,65 @@ "output_type": "stream", "text": [ "Epoch 1/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 11ms/step - loss: -1.0211 - loss/inference_loss: -1.0211 - val_loss: -1.5653 - val_loss/inference_loss: -1.5653\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m21s\u001B[0m 11ms/step - loss: -1.0211 - loss/inference_loss: -1.0211 - val_loss: -1.5653 - val_loss/inference_loss: -1.5653\n", "Epoch 2/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.2318 - loss/inference_loss: -2.2318 - val_loss: -2.4503 - val_loss/inference_loss: -2.4503\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.2318 - loss/inference_loss: -2.2318 - val_loss: -2.4503 - val_loss/inference_loss: -2.4503\n", "Epoch 3/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.5659 - loss/inference_loss: -2.5659 - val_loss: -2.6406 - val_loss/inference_loss: -2.6406\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.5659 - loss/inference_loss: -2.5659 - val_loss: -2.6406 - val_loss/inference_loss: -2.6406\n", "Epoch 4/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.7533 - loss/inference_loss: -2.7533 - val_loss: -2.6080 - val_loss/inference_loss: -2.6080\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.7533 - loss/inference_loss: -2.7533 - val_loss: -2.6080 - val_loss/inference_loss: -2.6080\n", "Epoch 5/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.8607 - loss/inference_loss: -2.8607 - val_loss: -2.8657 - val_loss/inference_loss: -2.8657\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.8607 - loss/inference_loss: -2.8607 - val_loss: -2.8657 - val_loss/inference_loss: -2.8657\n", "Epoch 6/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.9422 - loss/inference_loss: -2.9422 - val_loss: -2.3686 - val_loss/inference_loss: -2.3686\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.9422 - loss/inference_loss: -2.9422 - val_loss: -2.3686 - val_loss/inference_loss: -2.3686\n", "Epoch 7/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -2.9989 - loss/inference_loss: -2.9989 - val_loss: -2.9271 - val_loss/inference_loss: -2.9271\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -2.9989 - loss/inference_loss: -2.9989 - val_loss: -2.9271 - val_loss/inference_loss: -2.9271\n", "Epoch 8/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.0638 - loss/inference_loss: -3.0638 - val_loss: -3.0360 - val_loss/inference_loss: -3.0360\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.0638 - loss/inference_loss: -3.0638 - val_loss: -3.0360 - val_loss/inference_loss: -3.0360\n", "Epoch 9/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.0553 - loss/inference_loss: -3.0553 - val_loss: -3.2254 - val_loss/inference_loss: -3.2254\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.0553 - loss/inference_loss: -3.0553 - val_loss: -3.2254 - val_loss/inference_loss: -3.2254\n", "Epoch 10/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.1095 - loss/inference_loss: -3.1095 - val_loss: -3.0538 - val_loss/inference_loss: -3.0538\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.1095 - loss/inference_loss: -3.1095 - val_loss: -3.0538 - val_loss/inference_loss: -3.0538\n", "Epoch 11/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.2038 - loss/inference_loss: -3.2038 - val_loss: -3.1451 - val_loss/inference_loss: -3.1451\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.2038 - loss/inference_loss: -3.2038 - val_loss: -3.1451 - val_loss/inference_loss: -3.1451\n", "Epoch 12/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.2396 - loss/inference_loss: -3.2396 - val_loss: -3.2923 - val_loss/inference_loss: -3.2923\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.2396 - loss/inference_loss: -3.2396 - val_loss: -3.2923 - val_loss/inference_loss: -3.2923\n", "Epoch 13/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.2695 - loss/inference_loss: -3.2695 - val_loss: -2.7734 - val_loss/inference_loss: -2.7734\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.2695 - loss/inference_loss: -3.2695 - val_loss: -2.7734 - val_loss/inference_loss: -2.7734\n", "Epoch 14/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.2778 - loss/inference_loss: -3.2778 - val_loss: -3.3034 - val_loss/inference_loss: -3.3034\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.2778 - loss/inference_loss: -3.2778 - val_loss: -3.3034 - val_loss/inference_loss: -3.3034\n", "Epoch 15/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.3281 - loss/inference_loss: -3.3281 - val_loss: -2.5565 - val_loss/inference_loss: -2.5565\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.3281 - loss/inference_loss: -3.3281 - val_loss: -2.5565 - val_loss/inference_loss: -2.5565\n", "Epoch 16/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.3416 - loss/inference_loss: -3.3416 - val_loss: -3.1074 - val_loss/inference_loss: -3.1074\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.3416 - loss/inference_loss: -3.3416 - val_loss: -3.1074 - val_loss/inference_loss: -3.1074\n", "Epoch 17/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.3612 - loss/inference_loss: -3.3612 - val_loss: -3.4145 - val_loss/inference_loss: -3.4145\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.3612 - loss/inference_loss: -3.3612 - val_loss: -3.4145 - val_loss/inference_loss: -3.4145\n", "Epoch 18/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.3806 - loss/inference_loss: -3.3806 - val_loss: -3.3677 - val_loss/inference_loss: -3.3677\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.3806 - loss/inference_loss: -3.3806 - val_loss: -3.3677 - val_loss/inference_loss: -3.3677\n", "Epoch 19/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.4344 - loss/inference_loss: -3.4344 - val_loss: -2.7881 - val_loss/inference_loss: -2.7881\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.4344 - loss/inference_loss: -3.4344 - val_loss: -2.7881 - val_loss/inference_loss: -2.7881\n", "Epoch 20/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.4364 - loss/inference_loss: -3.4364 - val_loss: -3.2963 - val_loss/inference_loss: -3.2963\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.4364 - loss/inference_loss: -3.4364 - val_loss: -3.2963 - val_loss/inference_loss: -3.2963\n", "Epoch 21/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.4700 - loss/inference_loss: -3.4700 - val_loss: -2.8206 - val_loss/inference_loss: -2.8206\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.4700 - loss/inference_loss: -3.4700 - val_loss: -2.8206 - val_loss/inference_loss: -2.8206\n", "Epoch 22/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.4920 - loss/inference_loss: -3.4920 - val_loss: -3.0479 - val_loss/inference_loss: -3.0479\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.4920 - loss/inference_loss: -3.4920 - val_loss: -3.0479 - val_loss/inference_loss: -3.0479\n", "Epoch 23/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5153 - loss/inference_loss: -3.5153 - val_loss: -3.0690 - val_loss/inference_loss: -3.0690\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5153 - loss/inference_loss: -3.5153 - val_loss: -3.0690 - val_loss/inference_loss: -3.0690\n", "Epoch 24/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5309 - loss/inference_loss: -3.5309 - val_loss: -2.9115 - val_loss/inference_loss: -2.9115\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5309 - loss/inference_loss: -3.5309 - val_loss: -2.9115 - val_loss/inference_loss: -2.9115\n", "Epoch 25/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5516 - loss/inference_loss: -3.5516 - val_loss: -3.0176 - val_loss/inference_loss: -3.0176\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5516 - loss/inference_loss: -3.5516 - val_loss: -3.0176 - val_loss/inference_loss: -3.0176\n", "Epoch 26/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5659 - loss/inference_loss: -3.5659 - val_loss: -3.0676 - val_loss/inference_loss: -3.0676\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5659 - loss/inference_loss: -3.5659 - val_loss: -3.0676 - val_loss/inference_loss: -3.0676\n", "Epoch 27/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5792 - loss/inference_loss: -3.5792 - val_loss: -3.3448 - val_loss/inference_loss: -3.3448\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5792 - loss/inference_loss: -3.5792 - val_loss: -3.3448 - val_loss/inference_loss: -3.3448\n", "Epoch 28/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5791 - loss/inference_loss: -3.5791 - val_loss: -3.1989 - val_loss/inference_loss: -3.1989\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5791 - loss/inference_loss: -3.5791 - val_loss: -3.1989 - val_loss/inference_loss: -3.1989\n", "Epoch 29/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.5712 - loss/inference_loss: -3.5712 - val_loss: -3.0113 - val_loss/inference_loss: -3.0113\n", + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.5712 - loss/inference_loss: -3.5712 - val_loss: -3.0113 - val_loss/inference_loss: -3.0113\n", "Epoch 30/30\n", - "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 8ms/step - loss: -3.4733 - loss/inference_loss: -3.4733 - val_loss: -3.4334 - val_loss/inference_loss: -3.4334\n" + "\u001B[1m512/512\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m4s\u001B[0m 8ms/step - loss: -3.4733 - loss/inference_loss: -3.4733 - val_loss: -3.4334 - val_loss/inference_loss: -3.4334\n" ] } ], @@ -1049,7 +1049,7 @@ "for ax, net, name, color in zip(axes, nets, names, colors):\n", "\n", " # Obtain samples\n", - " samples = net.sample(conditions=conditions, num_samples=num_samples)[\"theta\"]\n", + " samples = net.sample(conditions=conditions, num_datasets=1, num_samples=num_samples)[\"theta\"]\n", "\n", " # Plot samples\n", " ax.scatter(samples[0, :, 0], samples[0, :, 1], color=color, alpha=0.75, s=0.5)\n", diff --git a/tests/test_networks/test_summary_networks.py b/tests/test_networks/test_summary_networks.py index 44e3dfee1..a8770f3d7 100644 --- a/tests/test_networks/test_summary_networks.py +++ b/tests/test_networks/test_summary_networks.py @@ -12,7 +12,7 @@ @pytest.mark.parametrize("automatic", [True, False]) def test_build(automatic, summary_network, random_set): if summary_network is None: - pytest.skip() + pytest.skip(reason="Nothing to do, because there is no summary network.") assert summary_network.built is False @@ -29,7 +29,7 @@ def test_build(automatic, summary_network, random_set): def test_variable_batch_size(summary_network, random_set): if summary_network is None: - pytest.skip() + pytest.skip(reason="Nothing to do, because there is no summary network.") # build with one batch size summary_network.build(keras.ops.shape(random_set)) @@ -43,7 +43,7 @@ def test_variable_batch_size(summary_network, random_set): def test_variable_set_size(summary_network, random_set): if summary_network is None: - pytest.skip() + pytest.skip(reason="Nothing to do, because there is no summary network.") # build with one set size summary_network.build(keras.ops.shape(random_set)) @@ -58,7 +58,7 @@ def test_variable_set_size(summary_network, random_set): def test_serialize_deserialize(summary_network, random_set): if summary_network is None: - pytest.skip() + pytest.skip(reason="Nothing to do, because there is no summary network.") summary_network.build(keras.ops.shape(random_set)) @@ -71,7 +71,7 @@ def test_serialize_deserialize(summary_network, random_set): def test_save_and_load(tmp_path, summary_network, random_set): if summary_network is None: - pytest.skip() + pytest.skip(reason="Nothing to do, because there is no summary network.") summary_network.build(keras.ops.shape(random_set))