diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a09a9fa4..74279369 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.10", "3.11"] + python-version: ['3.10', '3.11'] steps: - uses: actions/checkout@v3 @@ -20,7 +20,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install .[dev] + pip install .[all] - name: Black Formatting run: | black . @@ -28,7 +28,7 @@ jobs: - name: Lint with flake8 run: | # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --ignore=E203,E266,E501,W503,F403,F401 --show-source --statistics + flake8 . --count --select=E9,F63,F7,F82 --ignore=E203,E266,E501,W503,F403,F401,F821 --show-source --statistics # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide flake8 . --count --exit-zero --max-complexity=18 --max-line-length=89 --statistics diff --git a/.github/workflows/python-package-conda.yml b/.github/workflows/python-package-conda.yml index 57940bdb..9d45abb2 100644 --- a/.github/workflows/python-package-conda.yml +++ b/.github/workflows/python-package-conda.yml @@ -13,14 +13,15 @@ jobs: - name: Set up Python 3.10 uses: actions/setup-python@v3 with: - python-version: 3.10 + python-version: '3.10' - name: Add conda to system path run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH - name: Install dependencies run: | - conda env update --file environment.yml --name base + python -m pip install --upgrade pip + pip install .[all] - name: Lint with flake8 run: | conda install flake8 @@ -30,5 +31,4 @@ jobs: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | - conda install pytest pytest diff --git a/.gitignore b/.gitignore index ec64d053..315ad31e 100644 --- a/.gitignore +++ b/.gitignore @@ -182,6 +182,5 @@ wandb/ scripts.py -*.ipynb models/ -*.DS_Store \ No newline at end of file +*.DS_Store diff --git a/README.md b/README.md index 1a96aec1..58eba7c3 100644 --- a/README.md +++ b/README.md @@ -21,9 +21,7 @@ ## Installing the package -The codebase requires python >= 3.10 - -To install the latest stable version: +The codebase requires python >= 3.10. To install the latest stable version: ```bash pip install torchgfn diff --git a/pyproject.toml b/pyproject.toml index a73b69b1..83730722 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api" [tool.poetry] name = "torchgfn" packages = [{include = "gfn", from = "src"}] -version = "1.1" +version = "1.1.1" description = "A torch implementation of GFlowNets" authors = ["Salem Lahou ", "Joseph Viviano ", "Victor Schmidt "] license = "MIT" @@ -26,16 +26,17 @@ torch = ">=1.9.0" torchtyping = ">=0.1.4" # dev dependencies. -black = { version = "22.3.0", optional = true } +black = { version = "*", optional = true } +flake8 = { version = "*", optional = true } gitmopy = { version = "*", optional = true } myst-parser = { version = "*", optional = true } pre-commit = { version = "*", optional = true } pytest = { version = "*", optional = true } renku-sphinx-theme = { version = "*", optional = true } sphinx = { version = "*", optional = true } +sphinx_rtd_theme = { version = "*", optional = true } sphinx-autoapi = { version = "*", optional = true } sphinx-math-dollar = { version = "*", optional = true } -sphinx_rtd_theme = { version = "*", optional = true } tox = { version = "*", optional = true } # scripts dependencies. @@ -52,30 +53,32 @@ dev = [ "pre-commit", "pytest", "renku-sphinx-theme", - "sphinx", + "sphinx_rtd_theme", "sphinx-autoapi", "sphinx-math-dollar", - "sphinx_rtd_theme", - "tox" + "sphinx", + "tox", + "flake8", ] scripts = ["tqdm", "wandb", "scikit-learn", "scipy"] all = [ + "black", + "flake8", + "myst-parser", "pre-commit", "pytest", "renku-sphinx-theme", + "scikit-learn", + "scipy", "sphinx_rtd_theme", "sphinx-autoapi", "sphinx-math-dollar", "sphinx", "tox", - "black", - "myst-parser", "tqdm", "wandb", - "scikit-learn", - "scipy" ] [project.urls] diff --git a/src/gfn/env.py b/src/gfn/env.py index 6adc4d34..a21ae38d 100644 --- a/src/gfn/env.py +++ b/src/gfn/env.py @@ -23,16 +23,21 @@ def __init__( sf: Optional[TT["state_shape", torch.float]] = None, device_str: Optional[str] = None, preprocessor: Optional[Preprocessor] = None, + log_reward_clip: Optional[float] = -100.0, ): """Initializes an environment. Args: - s0: Representation of the initial state. All individual states would be of the same shape. - sf (optional): Representation of the final state. Only used for a human readable representation of - the states or trajectories. - device_str (Optional[str], optional): 'cpu' or 'cuda'. Defaults to None, in which case the device is inferred from s0. - preprocessor (Optional[Preprocessor], optional): a Preprocessor object that converts raw states to a tensor that can be fed - into a neural network. Defaults to None, in which case the IdentityPreprocessor is used. + s0: Representation of the initial state. All individual states would be of + the same shape. + sf: Representation of the final state. Only used for a human + readable representation of the states or trajectories. + device_str: 'cpu' or 'cuda'. Defaults to None, in which case the device is + inferred from s0. + preprocessor: a Preprocessor object that converts raw states to a tensor + that can be fed into a neural network. Defaults to None, in which case + the IdentityPreprocessor is used. + log_reward_clip: Used to clip small rewards (in particular, log(0) rewards). """ self.device = torch.device(device_str) if device_str is not None else s0.device @@ -53,6 +58,7 @@ def __init__( self.preprocessor = preprocessor self.is_discrete = False + self.log_reward_clip = log_reward_clip @abstractmethod def make_States_class(self) -> type[States]: @@ -184,12 +190,15 @@ def backward_step( return new_states def reward(self, final_states: States) -> TT["batch_shape", torch.float]: - """Either this or log_reward needs to be implemented.""" - return torch.exp(self.log_reward(final_states)) + """The environment's reward given a state. + + This or log_reward must be implemented. + """ + raise NotImplementedError("Reward function is not implemented.") def log_reward(self, final_states: States) -> TT["batch_shape", torch.float]: - """Either this or reward needs to be implemented.""" - raise NotImplementedError("log_reward function not implemented") + """Calculates the log reward (clipping small rewards).""" + return torch.log(self.reward(final_states)).clip(self.log_reward_clip) @property def log_partition(self) -> float: @@ -203,8 +212,9 @@ class DiscreteEnv(Env, ABC): """ Base class for discrete environments, where actions are represented by a number in {0, ..., n_actions - 1}, the last one being the exit action. - `DiscreteEnv` allow specifying the validity of actions (forward and backward), via mask tensors, that - are directly attached to `States` objects. + + `DiscreteEnv` allows for specifying the validity of actions (forward and backward), + via mask tensors, that are directly attached to `States` objects. """ def __init__( @@ -214,16 +224,22 @@ def __init__( sf: Optional[TT["state_shape", torch.float]] = None, device_str: Optional[str] = None, preprocessor: Optional[Preprocessor] = None, + log_reward_clip: Optional[float] = -100.0, ): """Initializes a discrete environment. Args: n_actions: The number of actions in the environment. - + s0: The initial state tensor (shared among all trajectories). + sf: The final state tensor (shared among all trajectories). + device_str: String representation of a torch.device. + preprocessor: An optional preprocessor for intermediate states. + log_reward_clip: Used to clip small rewards (in particular, log(0) rewards). """ self.n_actions = n_actions - super().__init__(s0, sf, device_str, preprocessor) + super().__init__(s0, sf, device_str, preprocessor, log_reward_clip) self.is_discrete = True + self.log_reward_clip = log_reward_clip def make_Actions_class(self) -> type[Actions]: env = self diff --git a/src/gfn/gym/box.py b/src/gfn/gym/box.py index 2a1bcc01..5aa272a7 100644 --- a/src/gfn/gym/box.py +++ b/src/gfn/gym/box.py @@ -20,6 +20,7 @@ def __init__( R2: float = 2.0, epsilon: float = 1e-4, device_str: Literal["cpu", "cuda"] = "cpu", + log_reward_clip: float = -100.0, ): assert 0 < delta <= 1, "delta must be in (0, 1]" self.delta = delta @@ -30,7 +31,7 @@ def __init__( self.R1 = R1 self.R2 = R2 - super().__init__(s0=s0) + super().__init__(s0=s0, log_reward_clip=log_reward_clip) def make_States_class(self) -> type[States]: env = self @@ -116,14 +117,15 @@ def is_action_valid( return True - def log_reward(self, final_states: States) -> TT["batch_shape", torch.float]: + def reward(self, final_states: States) -> TT["batch_shape", torch.float]: + """Reward is distance from the goal point.""" R0, R1, R2 = (self.R0, self.R1, self.R2) ax = abs(final_states.tensor - 0.5) reward = ( R0 + (0.25 < ax).prod(-1) * R1 + ((0.3 < ax) * (ax < 0.4)).prod(-1) * R2 ) - return reward.log() + return reward @property def log_partition(self) -> float: diff --git a/src/gfn/gym/discrete_ebm.py b/src/gfn/gym/discrete_ebm.py index 23af1eed..ea73b336 100644 --- a/src/gfn/gym/discrete_ebm.py +++ b/src/gfn/gym/discrete_ebm.py @@ -1,5 +1,5 @@ from abc import ABC, abstractmethod -from typing import ClassVar, Literal, Tuple, cast +from typing import ClassVar, Literal, Tuple import torch import torch.nn as nn @@ -48,14 +48,19 @@ def __init__( alpha: float = 1.0, device_str: Literal["cpu", "cuda"] = "cpu", preprocessor_name: Literal["Identity", "Enum"] = "Identity", + log_reward_clip: float = -100.0, ): """Discrete EBM environment. Args: - ndim (int, optional): dimension D of the sampling space {0, 1}^D. - energy (EnergyFunction): energy function of the EBM. Defaults to None. If None, the Ising model with Identity matrix is used. - alpha (float, optional): interaction strength the EBM. Defaults to 1.0. - device_str (str, optional): "cpu" or "cuda". Defaults to "cpu". + ndim: dimension D of the sampling space {0, 1}^D. + energy: energy function of the EBM. Defaults to None. If + None, the Ising model with Identity matrix is used. + alpha: interaction strength the EBM. Defaults to 1.0. + device_str: "cpu" or "cuda". Defaults to "cpu". + preprocessor_name: "KHot" or "OneHot" or "Identity". + Defaults to "KHot". + log_reward_clip: Minimum log reward allowable (namely, for log(0)). """ self.ndim = ndim @@ -89,6 +94,7 @@ def __init__( sf=sf, device_str=device_str, preprocessor=preprocessor, + log_reward_clip=log_reward_clip, ) def make_States_class(self) -> type[DiscreteStates]: @@ -133,16 +139,7 @@ def make_masks( return forward_masks, backward_masks def update_masks(self) -> None: - # The following two lines are for typing only. - self.forward_masks = cast( - TT["batch_shape", "n_actions", torch.bool], - self.forward_masks, - ) - self.backward_masks = cast( - TT["batch_shape", "n_actions - 1", torch.bool], - self.backward_masks, - ) - + self.set_default_typing() self.forward_masks[..., : env.ndim] = self.tensor == -1 self.forward_masks[..., env.ndim : 2 * env.ndim] = self.tensor == -1 self.forward_masks[..., -1] = torch.all(self.tensor != -1, dim=-1) @@ -183,16 +180,22 @@ def maskless_backward_step( # action i in [ndim, 2*ndim-1] corresponds to replacing s[i - ndim] with 1. # A backward action asks "what index should be set back to -1", hence the fmod # to enable wrapping of indices. - return states.tensor.scatter( - -1, - actions.tensor.fmod(self.ndim), - -1, - ) + return states.tensor.scatter(-1, actions.tensor.fmod(self.ndim), -1) + + def reward(self, final_states: DiscreteStates) -> TT["batch_shape"]: + """Not used during training but provided for completeness. + + Note the effect of clipping will be seen in these values. + """ + return torch.exp(self.log_reward(final_states)) def log_reward(self, final_states: DiscreteStates) -> TT["batch_shape"]: + """The energy weighted by alpha is our log reward.""" raw_states = final_states.tensor canonical = 2 * raw_states - 1 - return -self.alpha * self.energy(canonical) + log_reward = -self.alpha * self.energy(canonical) + + return log_reward.clip(self.log_reward_clip) def get_states_indices(self, states: DiscreteStates) -> TT["batch_shape"]: """The chosen encoding is the following: -1 -> 0, 0 -> 1, 1 -> 2, then we convert to base 3""" diff --git a/src/gfn/gym/helpers/box_utils.py b/src/gfn/gym/helpers/box_utils.py index 2dfd83e8..c6342c75 100644 --- a/src/gfn/gym/helpers/box_utils.py +++ b/src/gfn/gym/helpers/box_utils.py @@ -3,6 +3,7 @@ import numpy as np import torch +import torch.nn as nn from torch.distributions import Beta, Categorical, Distribution, MixtureSameFamily from torchtyping import TensorType as TT @@ -600,8 +601,8 @@ class BoxStateFlowModule(NeuralNet): """A deep neural network for the state flow function.""" def __init__(self, logZ_value: torch.Tensor, **kwargs): - self.logZ_value = logZ_value super().__init__(**kwargs) + self.logZ_value = nn.Parameter(logZ_value) def forward( self, preprocessed_states: TT["batch_shape", "input_dim", float] diff --git a/src/gfn/gym/hypergrid.py b/src/gfn/gym/hypergrid.py index 4d85f12c..028f716a 100644 --- a/src/gfn/gym/hypergrid.py +++ b/src/gfn/gym/hypergrid.py @@ -1,7 +1,7 @@ """ Copied and Adapted from https://github.com/Tikquuss/GflowNets_Tutorial """ -from typing import ClassVar, Literal, Tuple, cast +from typing import ClassVar, Literal, Tuple import torch from einops import rearrange @@ -25,6 +25,7 @@ def __init__( reward_cos: bool = False, device_str: Literal["cpu", "cuda"] = "cpu", preprocessor_name: Literal["KHot", "OneHot", "Identity", "Enum"] = "KHot", + log_reward_clip: float = -100.0, ): """HyperGrid environment from the GFlowNets paper. The states are represented as 1-d tensors of length `ndim` with values in @@ -41,6 +42,7 @@ def __init__( reward_cos (bool, optional): Which version of the reward to use. Defaults to False. device_str (str, optional): "cpu" or "cuda". Defaults to "cpu". preprocessor_name (str, optional): "KHot" or "OneHot" or "Identity". Defaults to "KHot". + log_reward_clip: Minimum log reward allowable (namely, for log(0)). """ self.ndim = ndim self.height = height @@ -80,6 +82,7 @@ def __init__( sf=sf, device_str=device_str, preprocessor=preprocessor, + log_reward_clip=log_reward_clip, ) def make_States_class(self) -> type[DiscreteStates]: @@ -105,17 +108,13 @@ def make_random_states_tensor( def update_masks(self) -> None: "Update the masks based on the current states." - # The following two lines are for typing only. - self.forward_masks = cast( - TT["batch_shape", "n_actions", torch.bool], - self.forward_masks, + self.set_default_typing() + # Not allowed to take any action beyond the environment height, but + # allow early termination. + self.set_nonexit_action_masks( + self.tensor == env.height - 1, + allow_exit=True, ) - self.backward_masks = cast( - TT["batch_shape", "n_actions - 1", torch.bool], - self.backward_masks, - ) - - self.forward_masks[..., :-1] = self.tensor != env.height - 1 self.backward_masks = self.tensor != 0 return HyperGridStates @@ -132,9 +131,7 @@ def maskless_backward_step( new_states_tensor = states.tensor.scatter(-1, actions.tensor, -1, reduce="add") return new_states_tensor - def true_reward( - self, final_states: DiscreteStates - ) -> TT["batch_shape", torch.float]: + def reward(self, final_states: DiscreteStates) -> TT["batch_shape", torch.float]: r"""In the normal setting, the reward is: R(s) = R_0 + 0.5 \prod_{d=1}^D \mathbf{1} \left( \left\lvert \frac{s^d}{H-1} - 0.5 \right\rvert \in (0.25, 0.5] \right) @@ -153,11 +150,6 @@ def true_reward( reward = R0 + ((torch.cos(ax * 50) + 1) * pdf).prod(-1) * R1 return reward - def log_reward( - self, final_states: DiscreteStates - ) -> TT["batch_shape", torch.float]: - return torch.log(self.true_reward(final_states)) - def get_states_indices( self, states: DiscreteStates ) -> TT["batch_shape", torch.long]: diff --git a/src/gfn/modules.py b/src/gfn/modules.py index 1dde4fa4..13080c7f 100644 --- a/src/gfn/modules.py +++ b/src/gfn/modules.py @@ -81,7 +81,7 @@ def forward(self, states: States) -> TT["batch_shape", "output_dim", float]: return out def __repr__(self): - return f"{self.__class__.__name__}({self.env})" + return f"{self.__class__.__name__} module" @property @abstractmethod diff --git a/src/gfn/states.py b/src/gfn/states.py index 19b4de57..0b631f24 100644 --- a/src/gfn/states.py +++ b/src/gfn/states.py @@ -303,6 +303,19 @@ def __init__( self.forward_masks = cast(torch.Tensor, forward_masks) self.backward_masks = cast(torch.Tensor, backward_masks) + self.set_default_typing() + + def set_default_typing(self) -> None: + """A convienience function for default typing of the masks.""" + self.forward_masks = cast( + TT["batch_shape", "n_actions", torch.bool], + self.forward_masks, + ) + self.backward_masks = cast( + TT["batch_shape", "n_actions - 1", torch.bool], + self.backward_masks, + ) + @abstractmethod def update_masks(self) -> None: """Updates the masks, called after each action is taken.""" @@ -371,3 +384,55 @@ def _extend(masks, first_dim): self.forward_masks = _extend(self.forward_masks, required_first_dim) self.backward_masks = _extend(self.backward_masks, required_first_dim) + + # The helper methods are convenience functions for common mask operations. + def set_nonexit_action_masks(self, cond, allow_exit: bool): + """Masks denoting disallowed actions according to cond, appending the exit mask. + + A convenience function for common mask operations. + + Args: + cond: a boolean of shape (batch_shape,) + (n_actions - 1,), which + denotes which actions are *not* allowed. For example, if a state element + represents action count, and no action can be repeated more than 5 + times, cond might be state.tensor > 5 (assuming count starts at 0). + allow_exit: sets whether exiting can happen at any point in the + trajectory - if so, it should be set to True. + """ + if allow_exit: + exit_idx = torch.zeros(self.batch_shape + (1,)) + else: + exit_idx = torch.ones(self.batch_shape + (1,)) + self.forward_masks[torch.cat([cond, exit_idx], dim=-1).bool()] = False + + def set_exit_masks(self, batch_idx): + """Sets forward masks such that the only allowable next action is to exit. + + A convenience function for common mask operations. + + Args: + batch_idx: A Boolean index along the batch dimension, along which to + enforce exits. + """ + self.forward_masks[batch_idx, :] = torch.cat( + [ + torch.zeros((torch.sum(batch_idx),) + self.s0.shape), + torch.ones((torch.sum(batch_idx),) + (1,)), + ], + dim=-1, + ).bool() + + def init_forward_masks(self, set_ones: bool = True): + """Initalizes forward masks. + + A convienience function for common mask operations. + + Args: + set_ones: if True, forward masks are initalized to all ones. Otherwise, + they are initalized to all zeros. + """ + shape = self.batch_shape + (self.n_actions,) + if set_ones: + self.forward_masks = torch.ones(shape).bool() + else: + self.forward_masks = torch.zeros(shape).bool() diff --git a/tutorials/examples/test_scripts.py b/tutorials/examples/test_scripts.py index 0f63316a..0e2021ec 100644 --- a/tutorials/examples/test_scripts.py +++ b/tutorials/examples/test_scripts.py @@ -6,6 +6,7 @@ from dataclasses import dataclass import pytest +import numpy as np from .train_box import main as train_box_main from .train_discreteebm import main as train_discreteebm_main @@ -68,13 +69,13 @@ def test_hypergrid(ndim: int, height: int): args = HypergridArgs(ndim=ndim, height=height, n_trajectories=n_trajectories) final_l1_dist = train_hypergrid_main(args) if ndim == 2 and height == 8: - assert final_l1_dist < 7.3e-4 + assert np.isclose(final_l1_dist, 9.14e-4, atol=1e-5) elif ndim == 2 and height == 16: - assert final_l1_dist < 4.8e-4 + assert np.isclose(final_l1_dist, 4.56e-4, atol=1e-5) elif ndim == 4 and height == 8: - assert final_l1_dist < 1.6e-4 + assert np.isclose(final_l1_dist, 1.6e-4, atol=1e-5) elif ndim == 4 and height == 16: - assert final_l1_dist < 2.45e-5 + assert np.isclose(final_l1_dist, 2.45e-5, atol=1e-6) @pytest.mark.parametrize("ndim", [2, 4]) @@ -84,13 +85,13 @@ def test_discreteebm(ndim: int, alpha: float): args = DiscreteEBMArgs(ndim=ndim, alpha=alpha, n_trajectories=n_trajectories) final_l1_dist = train_discreteebm_main(args) if ndim == 2 and alpha == 0.1: - assert final_l1_dist < 0.0026 + assert np.isclose(final_l1_dist, 2.97e-3, atol=1e-3) elif ndim == 2 and alpha == 1.0: - assert final_l1_dist < 0.017 + assert np.isclose(final_l1_dist, 0.017, atol=1e-3) elif ndim == 4 and alpha == 0.1: - assert final_l1_dist < 0.009 + assert np.isclose(final_l1_dist, 0.009, atol=1e-3) elif ndim == 4 and alpha == 1.0: - assert final_l1_dist < 0.062 + assert np.isclose(final_l1_dist, 0.062, atol=1e-3) @pytest.mark.parametrize("delta", [0.1, 0.25]) @@ -113,10 +114,10 @@ def test_box(delta: float, loss: str): print(args) final_jsd = train_box_main(args) if loss == "TB" and delta == 0.1: - assert final_jsd < 0.046 + assert np.isclose(final_jsd, 3.81e-2, atol=1e-3) elif loss == "DB" and delta == 0.1: - assert final_jsd < 0.18 + assert np.isclose(final_jsd, 0.134, atol=1e-2) if loss == "TB" and delta == 0.25: - assert final_jsd < 0.015 + assert np.isclose(final_jsd, 2.93e-3, atol=1e-3) elif loss == "DB" and delta == 0.25: - assert final_jsd < 0.027 + assert np.isclose(final_jsd, 0.0142, atol=1e-3) diff --git a/tutorials/examples/train_box.py b/tutorials/examples/train_box.py index 996f4c1f..7483fecf 100644 --- a/tutorials/examples/train_box.py +++ b/tutorials/examples/train_box.py @@ -33,6 +33,8 @@ ) from gfn.modules import ScalarEstimator +DEFAULT_SEED = 4444 + def sample_from_reward(env: Box, n_samples: int): """Samples states from the true reward distribution @@ -83,7 +85,7 @@ def estimate_jsd(kde1, kde2): def main(args): # noqa: C901 - seed = args.seed if args.seed != 0 else torch.randint(int(10e10), (1,))[0].item() + seed = args.seed if args.seed != 0 else DEFAULT_SEED torch.manual_seed(seed) device_str = "cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu" diff --git a/tutorials/examples/train_discreteebm.py b/tutorials/examples/train_discreteebm.py index a7aab784..f5e35a98 100644 --- a/tutorials/examples/train_discreteebm.py +++ b/tutorials/examples/train_discreteebm.py @@ -23,9 +23,11 @@ from gfn.utils.common import validate from gfn.utils.modules import NeuralNet, Tabular +DEFAULT_SEED = 4444 + def main(args): # noqa: C901 - seed = args.seed if args.seed != 0 else torch.randint(int(10e10), (1,))[0].item() + seed = args.seed if args.seed != 0 else DEFAULT_SEED torch.manual_seed(seed) device_str = "cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu" diff --git a/tutorials/examples/train_hypergrid.py b/tutorials/examples/train_hypergrid.py index e9fd465c..368d9243 100644 --- a/tutorials/examples/train_hypergrid.py +++ b/tutorials/examples/train_hypergrid.py @@ -31,9 +31,11 @@ from gfn.utils.common import validate from gfn.utils.modules import DiscreteUniform, NeuralNet, Tabular +DEFAULT_SEED = 4444 + def main(args): # noqa: C901 - seed = args.seed if args.seed != 0 else torch.randint(int(10e10), (1,))[0].item() + seed = args.seed if args.seed != 0 else DEFAULT_SEED torch.manual_seed(seed) device_str = "cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu" diff --git a/tutorials/notebooks/intro_gfn_continuous_line_simple.ipynb b/tutorials/notebooks/intro_gfn_continuous_line_simple.ipynb new file mode 100644 index 00000000..60815aba --- /dev/null +++ b/tutorials/notebooks/intro_gfn_continuous_line_simple.ipynb @@ -0,0 +1,867 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Continuous GFlowNets on a Simple 1D Line Environment" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "from torch.distributions import Normal\n", + "import math\n", + "import numpy as np\n", + "import torch\n", + "import random\n", + "from tqdm import trange\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial, we will explore a simple use-case of continuous GFlowNets: sampling from a multinomial Gaussian. This is an exceedingly simple example which is not representative of the complexities inherent with applying this method in real applications, but will highlight some common challenges and tricks useful. But first, please run the cell below to make available some helper functions:" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "def seed_all(seed):\n", + " torch.manual_seed(seed)\n", + " random.seed(seed)\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.manual_seed(seed)\n", + "\n", + "\n", + "def render(reward, trajectory=None):\n", + " \"\"\"Renders the reward distribution over the 1D env.\"\"\"\n", + " x = np.linspace(\n", + " min(reward.mus) - reward.n_sd * max(reward.sigmas),\n", + " max(reward.mus) + reward.n_sd * max(reward.sigmas),\n", + " 1000,\n", + " )\n", + "\n", + " d = torch.exp(reward.log_reward(torch.tensor(x)))\n", + " dual_plot = not isinstance(trajectory, type(None))\n", + "\n", + " if dual_plot:\n", + " fig, axs = plt.subplots(2, 1)\n", + " axs = axs.ravel()\n", + " else:\n", + " fig, axs = plt.subplots(1, 1)\n", + " axs = [axs] # Hack to allow indexing.\n", + "\n", + " if dual_plot:\n", + " ax_dual = axs[0].twinx() # Second axes for final state counts.\n", + " ax_dual.hist(\n", + " trajectory[:, -1, 0].cpu().numpy(), # Final X Position.\n", + " bins=100,\n", + " density=False,\n", + " alpha=0.5,\n", + " color=\"red\",\n", + " )\n", + " ax_dual.set_ylabel(\"Samples\", color=\"red\")\n", + " ax_dual.tick_params(axis=\"y\", labelcolor=\"red\")\n", + "\n", + " n, trajectory_length, _ = trajectory.shape\n", + " for i in range(n):\n", + " axs[1].plot(\n", + " trajectory[i, :, 0].cpu().numpy(),\n", + " np.arange(1, trajectory_length + 1),\n", + " alpha=0.1,\n", + " linewidth=0.05,\n", + " color='black',\n", + " )\n", + " axs[1].set_ylabel('Step')\n", + "\n", + " axs[0].plot(x, d, color=\"black\")\n", + "\n", + " # Adds the modes.\n", + " for mu in reward.mus:\n", + " axs[0].axvline(mu, color=\"grey\", linestyle=\"--\")\n", + "\n", + " # S0\n", + " axs[0].plot([reward.init_value], [0], 'ro')\n", + " axs[0].text(reward.init_value + 0.1, 0.01, \"$S_0$\", rotation=45)\n", + "\n", + " # Means\n", + " for i, mu in enumerate(reward.mus):\n", + " idx = abs(x - mu.numpy()) == min(abs(x - mu.numpy()))\n", + " axs[0].plot([x[idx]], [d[idx]], 'bo')\n", + " axs[0].text(x[idx] + 0.1, d[idx], \"Mode {}\".format(i + 1), rotation=0)\n", + "\n", + " axs[0].spines[['right', 'top']].set_visible(False)\n", + " axs[0].set_ylabel(\"Reward Value\")\n", + " axs[0].set_title(\"Line Environment\")\n", + " axs[0].set_ylim(0, max(d) * 1.1)\n", + "\n", + " if dual_plot:\n", + " axs[1].set_xlim(axs[0].get_xlim())\n", + " axs[1].set_xlabel(\"X Position\")\n", + " else:\n", + " axs[0].set_xlabel(\"X Position\")\n", + "\n", + " fig.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "trajectory_length = 5\n", + "min_policy_std = 0.1\n", + "max_policy_std = 1.0\n", + "batch_size = 256\n", + "seed = 4444" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we are explore Continuous GFlowNets in an exceedingly simple case: from an initial starting point on the number line, sample a set of increments such that we learn to sample from some reward distribution. Here, that reward distribution will be some mixture of Gaussians. Each step will be sampled from Gaussians as well distribution.\n", + "\n", + "The key difference with Continuous GFlowNets is that they sample some *delta* in a continuous space, instead of discrete actions. Typically, this means your GFlowNet uses a function approximator $f(\\cdot)$, which accepts the current state $s_{t}$, to predict the *paramaters of a distribution* $\\rho = \\{p_1, p_2, ..., p_n\\}$. Then your chosen distribution $D(\\rho)$ is used to sample a real-valued tensor $s_{\\Delta} \\sim D(\\rho)$ which is added to your current state to produce a the next step in the state space $s_{t+1} = s_{t} + s_{\\Delta}$ (note, we no longer consider a DAG here, but rather a topological space with distinguished source and sink states).\n", + "\n", + "As an aside, note that both $s_{\\delta} and the distribution $D(\\rho)$ can be as complex as you want, but this adds a lot of complexity and room for bugs. So to get you started, we're going to work with $s_{\\delta}$ being a single scalar, and $D(\\rho)$ being a simple Gaussian distribution. At the end, we will point to resources covering more complex settings which involve sampling from mixtures of distributions.\n", + "\n", + "In our case, we want to increment along the number line in such a way that we learn to sample from some arbitrary multi-modal distribution. So we need a distribution from which to sample these steps. Recall the formula of a Gaussian:\n", + "\n", + "$$g(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}} exp \\big(-\\frac{1}{2} \\frac{(x-\\mu)^2}{\\sigma^2} \\big)$$\n", + ".\n", + "\n", + "To parameterize this, we will need a neural network to predict the parameters of the Gaussian: $\\mu$, the mean, and $\\sigma$, the standard deviation. We're also going to enforce that $ 0.1 <= \\sigma <= 2$ to help with convergence (see the hyperparameters above).\n", + "\n", + "In our setup, we will define a multimodal Gaussian distribution on the 1D line. We will also define a an arbitrary starting point $S_0$ on the number line where all trajectories will start. The GFlowNet must sample increments along the number line such that it samples final values along the number line proportionally to the mixture distribution.\n", + "\n", + "We need to ensure there are no cycles in our state space to follow the theory of GFlowNets, but in this set up, a cycle would be easy to obtain. If we sampled first an increment of $+1$ and then an increment of $-1$, we could produce a cycle, and there are an infinite number of these on the real number line. To do so, let's simply include the count value, $t$, in the state $s_t$. In this setup, the state vector is `[x_position, n_steps]`, and the previous trajectory $[0, 0] \\rightarrow [1, 1] \\rightarrow [0, 2]$ would not be considerd a cycle. This step counter also can be used to know when to terminate this process, otherwise we never sample a final value. In this case, let's always terminate when $t=5$ (see hyperparameters above). There are more sophisitcated ways to handle termination, but they add complexity, and we want to focus this tutorial on only the core concepts.\n", + "\n", + "Since every state reachable by the backward policy must also be reachable by the forward policy, we also need to enforce that the the final transition of the backward policy goes exactly to $S_0$. We'll cover how this happens later." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Defining the Environment\n", + "\n", + "First let's define our environment. We require a few things. First, we need a reward distribution. This will be a mixture of Gaussians on the real number line, each defined by a $\\mu$ and $\\sigma$. The reward at each point will simply be the sum of the PDFs at that point across all elements of the mixture. We also define $S_0$ as `init_value`." + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3522/2321834419.py:7: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " Normal(torch.tensor(m), torch.tensor(s)) for m, s in zip(mus, self.sigmas)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class LineEnvironment():\n", + " def __init__(self, mus, variances, n_sd, init_value):\n", + " self.mus = torch.tensor(mus)\n", + " self.sigmas = torch.tensor([math.sqrt(v) for v in variances])\n", + " self.variances = torch.tensor(variances)\n", + " self.mixture = [\n", + " Normal(torch.tensor(m), torch.tensor(s)) for m, s in zip(mus, self.sigmas)\n", + " ]\n", + "\n", + " self.n_sd = n_sd\n", + " self.lb = min(self.mus) - self.n_sd * max(self.sigmas) # Convienience only.\n", + " self.ub = max(self.mus) + self.n_sd * max(self.sigmas) # Convienience only.\n", + "\n", + " self.init_value = init_value # Used for s0.\n", + " assert self.lb < self.init_value < self.ub\n", + "\n", + " def log_reward(self, x):\n", + " \"\"\"Sum of the exponential of each log probability in the mixture.\"\"\"\n", + " return torch.logsumexp(torch.stack([m.log_prob(x) for m in self.mixture], 0), 0)\n", + "\n", + " @property\n", + " def log_partition(self) -> float:\n", + " \"\"\"Log Partition is the log of the number of gaussians.\"\"\"\n", + " return torch.tensor(len(self.mus)).log()\n", + "\n", + "\n", + "env = LineEnvironment(mus=[-1, 1], variances=[0.2, 0.2], n_sd=4.5, init_value=0)\n", + "render(env)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Policies, Actions, and States\n", + "\n", + "Recall that in order to act in our environment, we have to do two things. First, we need to use a function approximator to predict the parameters of a distribution, then to sample from that distribution to produce the actions. Here, we have a neural network that outputs $\\mu$ and $\\sigma$ of the normal distribution, with the constraint that `min_policy_std <=` $\\sigma$ `<= max_policy_std`. Our policy is then this distribution object we can sample from:" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [], + "source": [ + "def get_policy_dist(model, x):\n", + " \"\"\"\n", + " A policy is a distribution we predict the parameters of using a neural network,\n", + " which we then sample from.\n", + " \"\"\"\n", + " pf_params = model(x)\n", + " policy_mean = pf_params[:, 0]\n", + " policy_std = torch.sigmoid(pf_params[:, 1]) * (max_policy_std - min_policy_std) + min_policy_std\n", + " policy_dist = torch.distributions.Normal(policy_mean, policy_std)\n", + "\n", + " return policy_dist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To keep things simple, we'll enforce that all trajectories are exactly 5 steps. With probabilisitc exit actions, the logic becomes more tricky, though it is often useful in some applications. \n", + "\n", + "For each forward action, we will add the action value to the current state, and increment the step counter. A backward action is simply the inverse: we will substract the action value from the current state, and decrement the step counter.\n", + "\n", + "Given this distribution we retrieve from `get_policy_dist()`, we sample an action $s_{\\Delta} \\sim D(\\rho)$. Recall that our state representation is `(x_position, n_steps)`. In this case, we are sampling $x_{\\Delta} \\sim \\mathcal{N}(\\mu, \\sigma^2)$, and our next state is `(x_position + x_delta, n_steps + 1)`.\n", + "\n", + "We'll also define a function that initalizes a state at $S_0$, which in our case has the `x_position` set to whatever we defined in our environment, and `n_steps` to 0." + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [], + "source": [ + "def step(x, action):\n", + " \"\"\"Takes a forward step in the environment.\"\"\"\n", + " new_x = torch.zeros_like(x)\n", + " new_x[:, 0] = x[:, 0] + action # Add action delta.\n", + " new_x[:, 1] = x[:, 1] + 1 # Increment step counter.\n", + "\n", + " return new_x\n", + "\n", + "\n", + "def initalize_state(batch_size, device, env, randn=False):\n", + " \"\"\"Trajectory starts at state = (X_0, t=0).\"\"\"\n", + " x = torch.zeros((batch_size, 2), device=device)\n", + " x[:, 0] = env.init_value\n", + "\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Loop\n", + "\n", + "Below is a simple training loop. We're going to use Trajectory Balance (TB), so we need a forward model, backward model, and an estimate of logZ, along with an optimizer. So let's set those up first. We'll parameterize both the `forward_model` and the `backward_model` as two small neural networks, each taking in the state `[x_position, n_steps]` and outputting the parameters of a Normal distribution `[mean, standard_deviation]`. The `logZ` estimate is a scalar parameter. Note a common optimization trick for TB here, where the learning rate of `logZ` is faster than the other networks. \n", + "\n", + "These models will be used to predict the parameters of the policies themselves." + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "def setup_experiment(hid_dim=64, lr_model=1e-3, lr_logz=1e-1):\n", + "\n", + " forward_model = torch.nn.Sequential(torch.nn.Linear(2, hid_dim),\n", + " torch.nn.ELU(),\n", + " torch.nn.Linear(hid_dim, hid_dim),\n", + " torch.nn.ELU(),\n", + " torch.nn.Linear(hid_dim, 2)).to(device)\n", + "\n", + " backward_model = torch.nn.Sequential(torch.nn.Linear(2, hid_dim),\n", + " torch.nn.ELU(),\n", + " torch.nn.Linear(hid_dim, hid_dim),\n", + " torch.nn.ELU(),\n", + " torch.nn.Linear(hid_dim, 2)).to(device)\n", + "\n", + " logZ = torch.nn.Parameter(torch.tensor(0.0, device=device))\n", + "\n", + " optimizer = torch.optim.Adam(\n", + " [\n", + " {'params': forward_model.parameters(), 'lr': lr_model},\n", + " {'params': backward_model.parameters(), 'lr': lr_model},\n", + " {'params': [logZ], 'lr': lr_logz},\n", + " ]\n", + " )\n", + "\n", + " return (forward_model, backward_model, logZ, optimizer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, our training loop, which is greatly simplified due to the use of fixed-length trajectories. In our forward loop through the trajectory, we use our `forward_model` to calculate the `forward_policy`, sample an `action` from that policy, and finally calculate the log probability of that action an add it to `logPF`, which records the sum of the log probabilities (i.e., the product of the conditional probabilities, which is the probability of the trajectory). We store each new state in the trajectory.\n", + "\n", + "For the backward loop, we sample the parameters of a `backward_policy` from the `backward_model`, and evaluate the log probability of the observed action (`trajectory[:, t, 0] - trajectory[:, t - 1, 0]`) under this policy. The trajectory dimensions are `[batch_dim, trajectory_step, state]`. We use this to calculate the probability of the backward trajectory by accumulating the sum of `logPB`. Note that the `n_step` counter is only part of the state, not the action, so we can remove it when indexing on the `state` dimension.\n", + "\n", + "We finally calculate the `log_reward` from the terminal states under our environment reward, and calculate the trajectory balance loss, which we use to update the parameters of the `forward_model`, `backward_model`, and `logZ`.\n", + "\n", + "This should only take a few minutes to train:" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter 0: (loss=4.999, estimated logZ=0.100, LR=0.001: 0%| | 6/10000 [00:00<02:54, 57.16it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter 9900: (loss=0.642, estimated logZ=1.985, LR=0.001: 100%|██████████| 10000/10000 [03:42<00:00, 44.96it/s]\n" + ] + } + ], + "source": [ + "def train(seed, batch_size, trajectory_length, env, device, n_iterations=10_000):\n", + " \"\"\"Continuous GFlowNet training loop, with the Trajectory Balance objective.\"\"\"\n", + " seed_all(seed)\n", + " forward_model, backward_model, logZ, optimizer = setup_experiment() # Default hyperparameters used.\n", + " losses = []\n", + " tbar = trange(n_iterations)\n", + "\n", + " for it in tbar:\n", + " optimizer.zero_grad()\n", + "\n", + " x = initalize_state(batch_size, device, env)\n", + "\n", + " # Trajectory stores all of the states in the forward loop.\n", + " trajectory = torch.zeros((batch_size, trajectory_length + 1, 2), device=device)\n", + " logPF = torch.zeros((batch_size,), device=device)\n", + " logPB = torch.zeros((batch_size,), device=device)\n", + "\n", + " # Forward loop to generate full trajectory and compute logPF.\n", + " for t in range(trajectory_length):\n", + " policy_dist = get_policy_dist(forward_model, x)\n", + " action = policy_dist.sample()\n", + " logPF += policy_dist.log_prob(action)\n", + "\n", + " new_x = step(x, action)\n", + " trajectory[:, t + 1, :] = new_x\n", + " x = new_x\n", + "\n", + " # Backward loop to compute logPB from existing trajectory under the backward policy.\n", + " for t in range(trajectory_length, 2, -1):\n", + " policy_dist = get_policy_dist(backward_model, trajectory[:, t, :])\n", + " action = trajectory[:, t, 0] - trajectory[:, t - 1, 0]\n", + " logPB += policy_dist.log_prob(action)\n", + "\n", + " log_reward = env.log_reward(trajectory[:, -1, 0]) # Reward from the final state.\n", + "\n", + " # Compute Trajectory Balance Loss.\n", + " loss = (logZ + logPF - logPB - log_reward).pow(2).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())\n", + "\n", + " if it % 100 == 0:\n", + " tbar.set_description(\"Training iter {}: (loss={:.3f}, estimated logZ={:.3f}, LR={}\".format(\n", + " it,\n", + " np.array(losses[-100:]).mean(),\n", + " logZ.item(),\n", + " optimizer.param_groups[0]['lr'],\n", + " )\n", + " )\n", + "\n", + " return (forward_model, backward_model, logZ)\n", + "\n", + "forward_model, backward_model, logZ = train(seed, batch_size, trajectory_length, env, device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can view the behaviour of our GFlowNet by sampling new trajectories under fixed models. We'll plot two things. On top, we'll see the distribution of the final samples from each trajectory, alongside the original reward distribution. Underneath it, we'll show the `x_position` values at each step along the full trajectory. Note that at inference time, we only need the `forward_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def inference(trajectory_length, forward_model, env, batch_size=10_000):\n", + " \"\"\"Sample some trajectories.\"\"\"\n", + "\n", + " with torch.no_grad():\n", + " trajectory = torch.zeros((batch_size, trajectory_length + 1, 2), device=device)\n", + " trajectory[:, 0, 0] = env.init_value\n", + "\n", + " x = initalize_state(batch_size, device, env)\n", + "\n", + " for t in range(trajectory_length):\n", + " policy_dist = get_policy_dist(forward_model, x)\n", + " action = policy_dist.sample()\n", + "\n", + " new_x = step(x, action)\n", + " trajectory[:, t + 1, :] = new_x\n", + " x = new_x\n", + "\n", + " return trajectory\n", + "\n", + "trajectories = inference(trajectory_length, forward_model, env)\n", + "render(env, trajectories)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Harder Example\n", + "\n", + "Well, it looks OK! Maybe not perfect (we could get there training for long enough with good hyperparameters), but let's move on. In this example, there's a reasonable amount of probability mass connecting the two modes of the distribution. Let's try to make the example harder by placing the modes far from $S_0$:" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3522/2321834419.py:7: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " Normal(torch.tensor(m), torch.tensor(s)) for m, s in zip(mus, self.sigmas)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = LineEnvironment(mus=[-2, 2], variances=[0.2, 0.2], n_sd=4.5, init_value=0)\n", + "render(env)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's train a model using the same hyperparameters on this environment." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter 9900: (loss=0.508, estimated logZ=1.351, LR=0.001: 100%|██████████| 10000/10000 [04:22<00:00, 38.03it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "forward_model, backward_model, logZ = train(seed, batch_size, trajectory_length, env, device)\n", + "trajectories = inference(trajectory_length, forward_model, env)\n", + "render(env, trajectories)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What we're seeing here is mode collapse due to on policy training. We can fix this with off policy exploration.\n", + "\n", + "We can go off policy in many ways, but one simple way would be to add some constant to the variance predicted by our forward policy for the normal distribution. We can also decay this constant linearly over training iterations too facilitate convergence.\n", + "\n", + "Let's define a new function that retrieves both our learned policy and off policy sampler:" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [], + "source": [ + "def get_policy_and_exploration_dist(model, x, off_policy_noise):\n", + " \"\"\"\n", + " A policy is a distribution we predict the parameters of using a neural network,\n", + " which we then sample from.\n", + " \"\"\"\n", + " pf_params = model(x)\n", + " policy_mean = pf_params[:, 0]\n", + " policy_std = torch.sigmoid(pf_params[:, 1]) * (max_policy_std - min_policy_std) + min_policy_std\n", + " policy_dist = torch.distributions.Normal(policy_mean, policy_std)\n", + "\n", + " # Add some off-policy exploration - TODO: FIll in the Blank here!\n", + " exploration_dist = torch.distributions.Normal(policy_mean, policy_std + off_policy_noise)\n", + "\n", + " return policy_dist, exploration_dist\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the below training loop, let's add the changes needed to allow for off policy exploration. To do so, we need to accomplish a few things:\n", + "\n", + "1) Define a value to increase the variance by, to encourage exploration. Ideally, this would be on a schedule, i.e,, the value we are adding to the variance of the predicted distribution will decrease over iterations. Let's use the `init_explortation_noise` variable for this.\n", + "2) Sample actions from the exploration distribution.\n", + "3) Calculate `logPF` using the log probabilities from the policy distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "def train_with_exploration(\n", + " seed,\n", + " batch_size,\n", + " trajectory_length,\n", + " env,\n", + " device,\n", + " init_explortation_noise,\n", + " n_iterations=10_000\n", + " ):\n", + " \"\"\"Continuous GFlowNet training loop, with expploration, and the Trajectory Balance objective.\"\"\"\n", + " seed_all(seed)\n", + " forward_model, backward_model, logZ, optimizer = setup_experiment() # Default hyperparameters used.\n", + " losses = []\n", + " tbar = trange(n_iterations)\n", + "\n", + " # TODO: Fill in the blank, optional.\n", + " exploration_schedule = np.linspace(init_explortation_noise, 0, n_iterations)\n", + "\n", + " for iteration in tbar:\n", + " optimizer.zero_grad()\n", + "\n", + " x = initalize_state(batch_size, device, env)\n", + "\n", + " # Trajectory stores all of the states in the forward loop.\n", + " trajectory = torch.zeros((batch_size, trajectory_length + 1, 2), device=device)\n", + " logPF = torch.zeros((batch_size,), device=device)\n", + " logPB = torch.zeros((batch_size,), device=device)\n", + "\n", + " # Forward loop to generate full trajectory and compute logPF.\n", + " for t in range(trajectory_length):\n", + " # TODO: Fill in the blanks here.\n", + " policy_dist, exploration_dist = get_policy_and_exploration_dist(\n", + " forward_model,\n", + " x,\n", + " exploration_schedule[iteration],\n", + " )\n", + " action = exploration_dist.sample()\n", + " logPF += policy_dist.log_prob(action)\n", + "\n", + " new_x = step(x, action)\n", + " trajectory[:, t + 1, :] = new_x\n", + " x = new_x\n", + "\n", + " # Backward loop to compute logPB from existing trajectory under the backward policy.\n", + " for t in range(trajectory_length, 2, -1):\n", + " policy_dist = get_policy_dist(backward_model, trajectory[:, t, :])\n", + " action = trajectory[:, t, 0] - trajectory[:, t - 1, 0]\n", + " logPB += policy_dist.log_prob(action)\n", + "\n", + " log_reward = env.log_reward(trajectory[:, -1, 0]) # Reward from the final state.\n", + "\n", + " # Compute Trajectory Balance Loss.\n", + " loss = (logZ + logPF - logPB - log_reward).pow(2).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())\n", + "\n", + " if iteration % 100 == 0:\n", + " tbar.set_description(\"Training iter {}: (loss={:.3f}, estimated logZ={:.3f}, LR={}, off policy noise={:.4f})\".format(\n", + " iteration,\n", + " np.array(losses[-100:]).mean(),\n", + " logZ.item(),\n", + " optimizer.param_groups[0]['lr'],\n", + " exploration_schedule[iteration], # TODO: Remove (b/c of fill in the blanks)?\n", + " )\n", + " )\n", + "\n", + " return (forward_model, backward_model, logZ)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note there are 3 elements defining the difficulty of learning this task: the `init_exploration_noise`, `trajectory_length`, and `n_iterations` hyperparameters. Increasing the noise without increasing the trajectory length, or vice versa, will not produce a good solution. Here we've provided the magic hyperparameters, but feel free to play around to see how easy it is to produce a bad sampler." + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter 9900: (loss=1.176, estimated logZ=1.986, LR=0.001, off policy noise=0.0198): 100%|██████████| 10000/10000 [06:37<00:00, 25.18it/s] \n" + ] + } + ], + "source": [ + "init_exploration_noise = 2\n", + "trajectory_length = 10\n", + "n_iterations = 10_000\n", + "\n", + "forward_model, backward_model, logZ = train_with_exploration(\n", + " seed,\n", + " batch_size,\n", + " trajectory_length,\n", + " env,\n", + " device,\n", + " init_exploration_noise,\n", + " n_iterations=n_iterations,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trajectories = inference(trajectory_length, forward_model, env)\n", + "render(env, trajectories)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Too Hard Example?\n", + "\n", + "Looks good! Let's try something more complex..." + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3522/2321834419.py:7: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " Normal(torch.tensor(m), torch.tensor(s)) for m, s in zip(mus, self.sigmas)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = LineEnvironment(\n", + " mus=[-2, 4, 6, 10],\n", + " variances=[0.2, 0.4, 1, 0.2],\n", + " n_sd=4.5,\n", + " init_value=0\n", + ")\n", + "render(env)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we have multiple challenges. Our starting point $S_0$ is now closer to Mode 1 than Modes 2 & 3, but the those combined modes have twice the probability mass that Mode 1 has. Furthermore, there is Mode 4, quite far from the initial starting point. To get started, let's modify some of out hyperparamaters to enable better sampling and exploration of this environment, and train for 10k iterations. We'll do this by allowing the policy to sample from Gaussian distributions with larger $\\sigma$ values, and increasing the `init_exploration_noise` value." + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter 9900: (loss=3.436, estimated logZ=3.427, LR=0.001, off policy noise=0.0495): 100%|██████████| 10000/10000 [07:25<00:00, 22.46it/s] \n" + ] + } + ], + "source": [ + "init_exploration_noise = 5\n", + "trajectory_length = 10\n", + "n_iterations = 10_000\n", + "min_policy_std = 0.1\n", + "max_policy_std = 5.0\n", + "\n", + "forward_model, backward_model, logZ = train_with_exploration(\n", + " seed,\n", + " batch_size,\n", + " trajectory_length,\n", + " env,\n", + " device,\n", + " init_exploration_noise,\n", + " n_iterations=n_iterations,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHVCAYAAAB8NLYkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3xT5f7H35lN926hi7KHLAFBBAQVAS8irisiyFBRueIAJxcUUC84EQfCFQXUH4pyxYmiiCLbgUxB9iijpTtt2iZpcn5/hOeQdEBT0qYtz/v1ygtycs5zvjk5PedzvuvRKIqiIJFIJBKJRCKp92j9bYBEIpFIJBKJxDdIYSeRSCQSiUTSQJDCTiKRSCQSiaSBIIWdRCKRSCQSSQNBCjuJRCKRSCSSBoIUdhKJRCKRSCQNBCnsJBKJRCKRSBoIUthJJBKJRCKRNBCksJNIJBKJRCJpIEhhJ5FcBBw5cgSNRsPixYv9bUqt0q9fP/r16+dvMyQSiaTWkMJOIqnnLF68GI1Gwx9//OFvUypk+vTpaDSaSl/p6en+NvGioaioiOnTp7NmzRp/myKRSGoIvb8NkEgkNU+TJk0oLi7GYDD4zYZ58+YREhJSbnlERESN7fOHH36osbHrI0VFRcyYMQNAejIlkgaKFHYSyUWARqPBZDL51YZbb72VmJiYWt2n0Wg87zolJSUYjUa0WhnAkEgk9R95JZNILgIqyrEbM2YMISEhnDhxghtvvJGQkBBiY2N57LHHcDgcHts7nU7mzJnDJZdcgslkIj4+nvvuu4/c3Fyf2bhmzRo0Gg2ffvop//nPf0hKSsJkMnHNNddw4MABdb0JEyYQEhJCUVFRuTGGDx9Oo0aNVPvL5tiJfSxdupSpU6eSmJhIUFAQZrMZgGXLltG1a1cCAwOJiYlh5MiRnDhxwmMfVT1u4pi/8sorzJ07l2bNmhEUFMSAAQNIS0tDURSee+45kpKSCAwMZOjQoeTk5JT7Tt999x19+vQhODiY0NBQBg8ezF9//eW1TUeOHCE2NhaAGTNmqKHw6dOne/ErSSSSuo4UdhLJRYzD4WDgwIFER0fzyiuv0LdvX1599VXeeecdj/Xuu+8+Hn/8cXr16sXrr7/O2LFjWbJkCQMHDsRut1dpXzk5OWRlZXm88vLyyq33wgsv8Pnnn/PYY48xefJkNm/ezIgRI9TPhw0bhsViYcWKFR7bFRUV8fXXX3Prrbei0+nOactzzz3HihUreOyxx5g5cyZGo5HFixdz2223odPpmDVrFuPGjWP58uX07t27nJ1VPW4AS5Ys4e233+bBBx/k0Ucf5ZdffuG2225j6tSprFy5kieffJJ7772Xr7/+mscee8xj2w8//JDBgwcTEhLCiy++yNNPP83u3bvp3bs3R44c8cqm2NhY5s2bB8BNN93Ehx9+yIcffsjNN998zmMlkUjqGYpEIqnXLFq0SAGU33//vdJ1Dh8+rADKokWL1GWjR49WAOXZZ5/1WPfSSy9Vunbtqr5ft26dAihLlizxWG/lypUVLi/LtGnTFKDCV+vWrdX1fv75ZwVQ2rZtq1itVnX566+/rgDKzp07FUVRFKfTqSQmJiq33HKLx34+/fRTBVDWrl2rLuvbt6/St2/fcvto1qyZUlRUpC632WxKXFyc0r59e6W4uFhd/s033yiA8swzz3h93MQxj42NVfLy8tTlkydPVgClU6dOit1uV5cPHz5cMRqNSklJiaIoilJQUKBEREQo48aN89hPenq6Eh4e7rG8qjZlZmYqgDJt2jRFIpE0TKTHTiK5yLn//vs93vfp04dDhw6p75ctW0Z4eDjXXnuth7eta9euhISE8PPPP1dpP5999hmrVq3yeC1atKjcemPHjvXIjevTpw+AapNGo+Gf//wn3377LYWFhep6n3zyCYmJifTu3fu8towePZrAwED1/R9//MHp06f517/+5ZGLOHjwYNq0aVPOOwjnP26Cf/7zn4SHh6vve/ToAcDIkSPR6/Uey202mxr6XbVqFXl5eQwfPtzjuOt0Onr06FHhca+qTRKJpOEiiyckkosYk8mk5l0JIiMjPXLn9u/fT35+PnFxcRWOcfr06Srt68orr6xS8URKSko5ewAPm4YNG8acOXP46quvuOOOOygsLOTbb7/lvvvuQ6PRnHcfTZs29Xh/9OhRAFq3bl1u3TZt2rB+/XqPZVU5bpV9HyHykpOTK1wuxti/fz8AV199dYXfISwsrNo2SSSShosUdhLJRcz5ctHAVTgRFxfHkiVLKvy8rJioKZsURVH/f/nll5Oamsqnn37KHXfcwddff01xcTHDhg2r0j7cvXW+tNGbdc/3PZ1OJ+DKs2vUqFG59dy9fd7aJJFIGi5S2EkkknPSvHlzfvzxR3r16nXBgsiX3Hbbbbz++uuYzWY++eQTUlNTufzyy6s1VpMmTQDYu3dvOQ/Z3r171c9rk+bNmwMQFxdH//79fTJmVbyZEomkfiNz7CQSyTm57bbbcDgcPPfcc+U+Ky0trbCytTYYNmwYVquV999/n5UrV3LbbbdVe6xu3boRFxfH/PnzsVqt6vLvvvuOPXv2MHjwYF+Y7BUDBw4kLCyMmTNnVlh5nJmZ6fWYQUFBAH77zSQSSc0jPXYSSQNh4cKFrFy5stzyhx9++ILG7du3L/fddx+zZs1i27ZtDBgwAIPBwP79+1m2bBmvv/46t95663nH+d///lfhzBPXXnst8fHxXtvVpUsXWrRowZQpU7BarVUOw1aEwWDgxRdfZOzYsfTt25fhw4eTkZHB66+/TmpqKhMnTqz22NUlLCyMefPmceedd9KlSxduv/12YmNjOXbsGCtWrKBXr1689dZbXo0ZGBhIu3bt+OSTT2jVqhVRUVG0b9+e9u3b19C3kEgktY0UdhJJA0H0KCvLmDFjLnjs+fPn07VrV/773//y73//G71eT2pqKiNHjqRXr15VGmP8+PEVLv/555+rJezA5bX7z3/+Q4sWLejSpUu1xhCMGTOGoKAgXnjhBZ588kmCg4O56aabePHFF2t02rNzcccdd5CQkMALL7zAyy+/jNVqJTExkT59+jB27Nhqjfnuu+/y4IMPMnHiRGw2G9OmTZPCTiJpQGgU94xkiUQikUgkEkm9RebYSSQSiUQikTQQpLCTSCQSiUQiaSBIYSeRSCQSiUTSQJDCTiKRSCQSiaSBIIWdRCKRSCQSSQPhomt34nA42LdvH40bN0arlbpWIpFIJJL6jqIoFBQUkJCQcNHf2y86Ybdv3z7atWvnbzMkEolEIpH4mLS0NJKSkvxthl+56ISd6Hy/e/duEhMT/WyNxNfYbDZeffVVAB599FGMRqOfLZL4i/p0LtQnW+sb8theHJjNZpKTkwkNDfW3KX7nohN2YhLs0NBQwsLC/GyNxNfYbDZMJhPgmpJJXsQvXurTuVCfbK1vyGN7cSHu8RczF3cgWiKRSCQSiaQBIYWdRCKRSCQSSQNBCjuJRCKRSCSSBoIUdhKJD1izZg0ajYa8vDx/myKRSOoI8rog8QdS2EkaFDqdjqFDhzJ06FB0Oh0AY8aMQaPRcP/995db/4EHHkCj0TBmzJhatrQ8p06d4o477qBVq1ZotVoeeeQRf5tUr6noXKir1Cdb6xuVHdv6cl1wZ8OGDej1ejp37uxvUyR1GCnsJA0KnU5H586d6dy5s8dFPDk5maVLl1JcXKwuKykp4aOPPiIlJcUfppbDarUSGxvL1KlT6dSpk7/NqfdUdi7UReqTrfWNcx3b+nBdEOTl5TFq1CiuueYaf5siqeNIYSe5KOjSpQvJycksX75cXbZ8+XJSUlK49NJLPda1Wq089NBDxMXFYTKZ6N27N7///rvHOt9++y2tWrUiMDCQq666iiNHjpTb5/r16+nTpw+BgYEkJyfz0EMPYbFYKrUxNTWV119/nVGjRhEeHn5hX1gikZyXLl26MNNoZP+IETB9OlD3rguC+++/nzvuuIOePXtW+/tKLg6ksJM0KJxOJ/v27WPfvn04nU6Pz+666y4WLVqkvl+4cCFjx44tN8YTTzzBZ599xvvvv8+ff/5JixYtGDhwIDk5OYCrs/nNN9/MkCFD2LZtG/fccw9PPfWUxxgHDx5k0KBB3HLLLezYsYNPPvmE9evXM2HChBr41pKKONe5UNeoT7bWN853bC+99FK2bdumvq+L14VFixZx6NAhpk2bVo0jILnYkMJO0qCwWkuZOXMj//73TlavduBwnP1s5MiRrF+/nqNHj3L06FE2bNjAyJEjPba3WCzMmzePl19+meuuu4527dqxYMECAgMDee+99wCYN28ezZs359VXX6V169aMGDGiXC7OrFmzGDFiBI888ggtW7bkiiuu4I033uCDDz6gpKSkpg+DBCgtLeXjjz/m448/prS01N/mnJP6ZGt9o7S0lCVLljJz5kaWLHGyZg0e14WOHTty7Ngx8vLy6uR1Yf/+/Tz11FP83//9H3r9RTengKQayLNE0mBYvhweesjAiRNjAPjsM0hKghYtIDwcYmNjGTx4MIsXL0ZRFAYPHkxMTIzHGAcPHsRut9OrVy91mcFgoHv37uzZsweAPXv20KNHD4/tyoZHtm/fzo4dO1iyZIm6TFEUnE4nhw8fpm3btr786hKJpBK++ELDnDkPYzaH8/77rmWvhk6nX9Q2TKYSgjt3pmXLlmzbto01ixbVqeuCw+HgjjvuYMaMGbRq1eqCj4Xk4kAKO0mDYPlyuPVWUBTP5SdOwPHjcNllrvd33XWXGvaYO3dujdlTWFjIfffdx0MPPVTus7qWlC2RNFSWL4fbb9ejKJ7TRxYUgLkAEhNc7y+99FK+/fZb3j96tE5dFwoKCvjjjz/YunWret1yOp0oioJer+eHH37g6quvrjF7JfUTKewk9R6HAx5+WIg6z3kChdDbtcu13qBBg7DZbGg0GgYOHFhurObNm2M0GtmwYQNNmjQBwG638/vvv6vtR9q2bctXX33lsd3mzZs93nfp0oXdu3fTokULn3xHiUTiHee8Lpz59/RpcDqhRYsWOBwO7HZ7nbouhIWFsXPnTo9lb7/9Nj/99BP/+9//aNq0aZXGkVxcyBw7Sb1n3TqXV+5cFBe71tPpdOzZs4fdu3dX2FYiODiY8ePH8/jjj7Ny5Up2797NuHHjKCoq4u677wZc1Wn79+/n8ccfZ+/evXz00UcsXrzYY5wnn3ySjRs3MmHCBLZt28b+/fv58ssvz5skvW3bNrZt20ZhYSGZmZls27aN3bt3e3U8JBKJ+3Wh8knh7aVw7BhotVomTJhQ564LWq2W9u3be7xEVW779u0JDg6u7uGRNGCkx05S7zl1yrv1wsLCzrneCy+8gNPp5M4776SgoIBu3brx/fffExkZCbhCJp999hkTJ07kzTffpHv37sycOZO77rpLHaNjx4788ssvTJkyhT59+qAoCs2bN2fYsGHn3Ld7i4UtW7bw0Ucf0aRJkwrbJkgkksqp6nWhoMD1b0BAAAHnuDb487ogkXiDRlHKZiU1bI4fP05ycjJpaWkkJSX52xyJD1izBq666vzr/fwz9OtX09ZI6go2m41Zs2YBMHnyZIxGo58tqpz6ZGt94VzXhWlMV/8/ZjSkpp55M316BWtL6gNms5nw8HDy8/PP+/AOuH7rGTM8l7VuDX//7fp/SQk8+igsXQpWKwwcCG+/DfHxZ9c/dgzGj3fdXEJCYPRomDUL/Fy9LD12knpPnz6u6tfjx51UlF2g0SgkJWno06f2bZP4D51Ox3XXXaf+vy5Tn2ytL/TpA9HRxWRnB1DhdQEICwNZy3QRc8kl8OOPZ9+7C7KJE2HFCli2zNVWYcIEuPlm2LDB9bnDAYMHQ6NGsHGjy0U8ahQYDDBzZu1+jzJIYSep9+h08OqrdoYN0wFlxZ0TRdEwZ45rPcnFg06no3v37v42o0rUJ1vrCzodtGs3n3XrHgYUpuHunVEADYMGgVZmml+86PUuYVaW/Hx47z346CMQVceLFkHbtrB5M1x+OfzwA+ze7RKG8fHQuTM89xw8+aTLG+hHr7s8pSUNgtjY9cCtaLXpZT45zq23LuXmm/1hlUQi8ReKorBnz0zgVmJjbR6faTWF3Hab6z4taViYzWaPl9VqrXzl/fshIQGaNYMRI1yhVYAtW8Buh/79z67bpo3Lvbtpk+v9pk3QoYNnaHbgQDCb4a+/fP/FvEAKO0mDYOPGjcDn3HLLo3z8cTqvv57JE098BzTl6NHX/G2exA84nU6OHDnCkSNH6vw0XfXJ1vrCvn37yMrKIjBwJb/8cpRbbynkhiE2NLyPU5lNQkK+v02U1ADJycmEh4erL5G7Wo4ePWDxYli5EubNg8OHXfH7ggJIT3d53CIiPLeJj3d9Bq5/3UWd+Fx85kdkKFbSIHAJO+jV63L27v0vAOPGjeCll5xs3bqV4uJiAgMD/WmipJYpLS3l/TNTDdT1goT6ZGt9YcOZXKju3bvz6acf0zfrD/r06cOWLTZOnISjR4/SsWNHz43ciydkIUW9JC0tzaN4IiAgoOIVz+S0AtCxo0voNWkCn34K9fxeIT12knqP0+lk0xn3uPuUPsnJycTGxlJaWsqOHTv8ZZ5EIvED69evB+CKK67wWJ6YmAjAqar2Q5HUK8LCwjxelQq7skREQKtWcOCAK+/OZoO8PM91MjLO5uQ1auR6X/Zz8ZkfkcJOUu85cOAAubm5mEwmOnTooC7XaDR07doVcPWEk0gkFw/ib/4yMZ/gGRo3bgxIYScpQ2EhHDwIjRtD166u6tbVq89+vnevKwdPzP/bsyfs3OmavkSwapWr1Lpdu9q1vQxS2EnqPcIb1759ewwGg8dn3bp1A6Swk0guJux2O3v27AHweNgDSEhwTRB76tQpLrI2rhJ3HnsMfvkFjhxxtSu56SZXKfXw4a72JnffDZMmuXrUbdkCY8e6xNzll7u2HzDAJeDuvBO2b4fvv4epU+GBB6CqXsIaQubYSeo9Yi7FcvkyID12EslFyN69e7Hb7YSFhZGcnOzxWUxMDHqdDqvNRk5ODtHR0X6yUuJXjh93ibjsbIiNhd69Xa1MYmNdn7/2mqsXzi23eDYoFuh08M03rgbFPXtCcLCrQfGzz/rn+7ghhZ2k3iOEXdknc3B58cB1oXc4HLL5q0RyESC8+B06dECj8ZwrVqfTERsby6n0dDIzM6Wwu1hZuvTcn5tMMHeu61UZTZrAt9/61i4fIEOxknrPuYRd06ZNCQgIoKSkRM63KpFcJAhhV5EXHyD2jFcmMzOz1mySSGoLvwu7uXPnkpqaislkokePHvz222/nXH/OnDm0bt2awMBAkpOTmThxIiUlJbVkraSuUVxczMGDBwGXsNPpdPTv35/+/fuj0+nQ6XS0bt0aQM25kVwclD0X6jL1ydb6wF9nGsRecskl6rFt1qyZ6r2LiYkBICsry282SiQ1hV9DsZ988gmTJk1i/vz59OjRgzlz5jBw4ED27t1LXFxcufU/+ugjnnrqKRYuXMgVV1zBvn37GDNmDBqNhtmzZ/vhG0j8zcGDB1EUhcjISPWc6dWrl8c6bdu2ZceOHezevZvrr7/eH2ZK/IBOpyt3LtRV6pOt9YEDBw4A0KpVq7PHdtUq9XPpsZM0ZPzqsZs9ezbjxo1j7NixtGvXjvnz5xMUFMTChQsrXH/jxo306tWLO+64g9TUVAYMGMDw4cPP6eWzWq0e04sUFBTU1NeR+AFxAW/RokWl67Q7U3ouPXYSScPH4XBw6NAhAFq2bFnhOu4eO1kZK2lo+E3Y2Ww2tmzZQn+3udi0Wi39+/dXm82W5YorrmDLli2qkDt06BDffvst//jHPyrdz6xZszymF2nn5/4yEt9SVtg5nU5OnDjBiRMn1KmZ2rRpA7gKKCQXDxWdC3WV+mRrXefYsWPYbDaMRiPJycnqsTWbzaqIi4qKQqvRYLPb5cO+pMHhN2GXlZWFw+Egvsxca/Hx8aRXMs/aHXfcwbPPPkvv3r0xGAw0b96cfv368e9//7vS/UyePJn8/Hz1tXv3bp9+D4l/2b9/P3BW2JWWlvLuu+/y7rvvUlpaCkDz5s0B1Kd4ycVBRedCXaU+2VrXEQ97zZs3R6fTqcf2zz//VEWzTqcj4sw8oLm5uf4yVSKpEfxePOENa9asYebMmbz99tv8+eefLF++nBUrVvDcc89Vuk1AQIDH9CKhoaG1aLGkpqlKKLZZs2YAZGRkYLFYasUuiUTiH8o+7FVGZGQkIIWdpOHht+KJmJgYdDodGWXmWsvIyKBRJfOsPf3009x5553cc889gKsK0mKxcO+99zJlyhS02nqlUyU+QAi7ynJpwHUBj4iIIC8vj8OHD6u97SQSScNDCLtzXRNACjtJw8VvSshoNNK1a1dWu83F5nQ6Wb16NT3FXGxlKCoqKifeRGsAmQB78VFSUkJaWhpw/qdzGY6VSC4OqvKwB1LYSRoufnVxTZo0iQULFvD++++zZ88exo8fj8ViYezYsQCMGjWKyZMnq+sPGTKEefPmsXTpUg4fPsyqVat4+umnGTJkiOz9dBFy6NAhFEUhLCxMrXKrDBGOlcJOImnYyFCs5GLHr33shg0bRmZmJs888wzp6el07tyZlStXqgUVx44d8/DQTZ06FY1Gw9SpUzlx4gSxsbEMGTKE//znP/76ChI/4p5fV3baoLJIYSeRNHyq0upEIIWdpKHi97liJ0yYwIQJEyr8bM2aNR7v9Xo906ZNY9q0abVgmaSuI2acEGHWcyGEndhGIpE0PE6ePIndbkev15OUlHTOdYWwK7RYsNvtGAyG2jBRIqlx/C7sJJLqcvToUQBSU1PVZTqdjr59+6r/F8gcu4uPys6Fukh9srUuI64JycnJ6nEUxzb18GEPz77JZCLQZKK4pITc3NwKZzuSSOojUthJ6i3Hjh0DICUlRV2m0+no169fuXWFx+7w4cM4nU5ZQX0RUNm5UBepT7bWZc55TSgTAQKIiIigOD1dCjtJg6Jad7eDBw8ydepUhg8fzunTpwH47rvv1ImXJZLaQDydN2nS5Lzriid4q9XKqVOnato0iUTiB7y5JoDMs5M0TLwWdr/88gsdOnTg119/Zfny5RQWFgKwfft2mfsmqVXE07n7RVxRFE6fPs3p06c9WuDo9XoSExMB1BYpkoZNZedCTbNmzRo0Gg15eXlV3sZftjY0KhJ24thaLJZyx1bMPuHNbyWR1HW8FnZPPfUUzz//PKtWrcJoNKrLr776ajZv3uxT4ySSyrBYLGRlZQGeYRe73c68efOYN28edrvdY5vk5GRACruLhYrOhTFjxqDRaLj//vvLrf/AAw+g0WgYM2ZMLVta3tbly5dz7bXXEhsbS1hYGD179uT777+vdbvqGxUJO3Fsf//993Lz8IaHhwNgNptrz0iJpIbxWtjt3LmTm266qdzyuLg49UYrkdQ0QpyFhYWpT93nQwo7CbjOg6VLl1JcXKwuKykp4aOPPvJ4SPAna9eu5dprr+Xbb79ly5YtXHXVVQwZMoStW7f627Q6jbeh2LCwMADy8/NrzCaJpLbxWthFRERUmKO0detWNdQlkdQ04gLuzY1YCjsJQJcuXUhOTmb58uXqsuXLl5OSksKll17qsa7VauWhhx4iLi4Ok8lE7969+f333z3W+fbbb2nVqhWBgYFcddVVHDlypNw+169fT58+fQgMDCQ5OZmHHnronPMWz5kzhyeeeILLLruMli1bMnPmTFq2bMnXX399YV++AaMoSoXFE+dCeuwkDRGvhd3tt9/Ok08+SXp6OhqNBqfTyYYNG3jssccYNWpUTdgokZSjovy68yGFnURw1113sWjRIvX9woUL1Rlv3HniiSf47LPPeP/99/nzzz9p0aIFAwcOJCcnB3CdSzfffDNDhgxh27Zt3HPPPTz11FMeYxw8eJBBgwZxyy23sGPHDj755BPWr19faf/OinA6nRQUFBAVFVXNb9zwycnJUcVyVYWd8NgVFhbicDhqzDaJpDbxWtjNnDmTNm3akJycTGFhIe3atePKK6/kiiuuYOrUqTVho0RSDumxk5wPhwMOH27Czp3t+eUXDe737ZEjR7J+/XqOHj3K0aNH2bBhAyNHjvTY3mKxMG/ePF5++WWuu+462rVrx4IFCwgMDOS9994DYN68eTRv3pxXX32V1q1bM2LEiHI5erNmzWLEiBE88sgjtGzZkiuuuII33niDDz74gJKSkip9l1deeYXCwkJuu+22CzomDRlxTYiPj8dkMsH06TB9OrrnnqPvzz9XuE1wcDA6rRYFKCgoqD1jJXWPF14AjQYeeeTsspISeOABiI6GkBC45RbIyPDc7tgxGDwYgoIgLg4efxxKS2vV9LJ43cfOaDSyYMECnn76aXbt2kVhYSGXXnrpeadvkUh8ibe5NCCF3cXE8uXw0EMGTpwYA8Bnn0FSErRoAeHhEBsby+DBg1m8eDGKojB48OBy8w0fPHgQu91Or1691GUGg4Hu3buzZ88eAPbs2UOPHj08tuvZs6fH++3bt7Njxw6WLFmiLlMUBafTyeHDh2nbtu05v8tHH33EjBkz+PLLL2WvtXNQnWuCRqMhLCyM3Lw8zGZzlfN1JQ2M33+H//4XOnb0XD5xIqxYAcuWuS4cEybAzTfDhg2uzx0Ol6hr1Ag2boRTp2DUKDAYYObM2v8eZ6h2g+KUlJQ6k2gsufi4kFBseno6NpvNo6pb0nBYvhxuvRXKdg05cULh+HG47DLX+7vuuksNh86dO7fG7CksLOS+++7joYceKvfZ+a6hS5cu5Z577mHZsmX079+/pkxsEIgHNvF3XlWEsJMFFA2DsvmSAQEBBAQEVL5BYSGMGAELFsDzz59dnp8P770HH30EV1/tWrZoEbRtC5s3w+WXww8/wO7d8OOPEB8PnTvDc8/Bk0+6PMZ+usd4Lezuuuuuc36+cOHCahsjkVSV48ePA5SbD1Kn06kek7JTM8XGxhIQEIDVauXkyZMeU5FJGgYOBzz8sBB1Go/PFMX1ftcu13qDBg3CZrOh0WgYOHBgubGaN2+O0Whkw4YN6gOE3W7n999/55Ez4Zq2bdvy1VdfeWxXtu1Tly5d2L17Ny1atKjU7orO248//pi77rqLpUuXMnjw4Cofg4uVEydOAOWvCRqNRhV77lOKCWQBRcOirLCfNm0a06dPr3yDBx5wed369/cUdlu2gN3uWi5o0wZSUmDTJpew27QJOnRwiTrBwIEwfjz89ReUKcaqLbwWdmU7dNvtdnbt2kVeXh5XC1UrkdQgiqKoF/Gyldg6nY4BAwZUuJ1GoyEpKYmDBw+SlpYmhV0DZN06OKP5K6W42LVev346NaRa0fyswcHBjB8/nscff5yoqChSUlJ46aWXKCoq4u677wbg/vvv59VXX+Xxxx/nnnvuYcuWLSxevNhjnCeffJLLL7+cCRMmcM899xAcHMzu3btZtWoVb731lrp/9/P2o48+YvTo0bz++uv06NGD9PR0AAIDA1UhIvGksmuCVqtV54quCNnypGGRlpam/qbAub11S5fCn3+6QrFlSU93edzKhufj412fiXXcRZ34XHzmJ7wWdp9//nm5ZU6nk/Hjx5/zj0ci8RXZ2dlYrVYAEhISvNo2OTlZFXaShkdVZ4v75JO19Ot3pccNoCJeeOEFnE4nd955JwUFBXTr1o3vv/9enYoqJSWFzz77jIkTJ/Lmm2/SvXt3Zs6c6RHZ6NixI7/88gtTpkyhT58+KIpC8+bNGTZsWKX7feeddygtLeWBBx7ggQceUJePHj26nHCUuKhM2J0P6bFrWISFhZ337xqAtDSXe3/VKjCZat6wWqTaOXbuaLVaJk2aRL9+/XjiiSd8MaREUiniAh4TE1PuaUxRFPXJOzw8vFzoRRZQNGwaNz7fGosB+L//G8Kzz7YlNjbW49MvvvjC473JZOKNN97gjTfeqHTE66+/nuuvv95jWdnWKZdddhk//PBDpWOUPW/XVDBhveTcVCbsFEVRHwQDAgLKXROkx+4iZcsWOH0aunQ5u8zhgLVr4a234PvvwWaDvDxPr11GhqtYAlz//vab57iialas4we8bndSGQcPHqTUzyW+kouDcz2Z2+12Xn/9dV5//fVyU4qBFHYNnT59ICKiEHBW+LlGo2AwpFNY+C0zZsyoXePOwfnOW8m5cU/PKOvFdzqdbN68mc2bN5ebUgykx+6i5ZprYOdO2Lbt7KtbN1chhfi/wQCrV5/dZu9eV3sTUfnes6drjNOnz66zahWEhUG7drX3Xcrgtcdu0qRJHu8VReHUqVOsWLGC0aNH+8wwiaQyqhtyASnsGjparUJg4FPk5b0BKLgXULgcNRqmTMlk+nQn7777LlOmTKHx+d18kjqO2WymqKgI8P66IDx2lqIiSktL0et9EsiS1HVCQ6F9e89lwcGunnVi+d13w6RJEBXlEmsPPugSc5df7vp8wACXgLvzTnjpJVde3dSproKMc+X21TBen8Fl5yrUarXExsby6quvnrdiViLxBVLYSSpjzZo1nDo1F5Mpl6ioDzl58qywS0qCOXPgppva8/33Pdm0aROzZ8/m5Zdf9p/BEp8grgkREREEBQV5tW1gYCAGvR57aSlms1nO7iE5y2uvgVbrakxstboqXt9+++znOh18842rCrZnT5cwHD0ann3WfzZTDWH3cyUdvCWS2sIXwk70wZM0LN555x0AxowJY/bsUsaP/4jCwlDuu+8Grr7agKv4VcOUKVO4/vrrmT9/PtOmTSMkJMSvdksujAu5Jogmxdk5OeTn50thdzFTNrfVZIK5c12vymjSBL79tkbN8haf5dhJJLXFhVzERY+r7OzsKk/nJKkf5OTksHz5cgDuvfdedDpo2vQoHTrsom9fBfeOJv/4xz9o1aoVhYWFfPzxx36yWOIrLuSaAGfDsTLPTtIQqJLH7tJLL62wsWNF/PnnnxdkkERyPi7kIh4ZGYnJZKKkpISTJ0/SrFkzX5sn8RNff/01NpuNDh06cOmll2Kz2SpdV6PRMG7cOB5//HHeeecdxo0bV4uWSnyNFHaSektamisBWDTW/u0312wX7drBvfdWa8gqCbsbb7yxWoNLJDXBhYZdkpKSOHDgAMePH5fCrgEhemzefPPNVVp/9OjRTJkyhT/++IOtW7dyqZ+6xEsuHF8Ju4KCAp/ZJJFUiTvucAm4O+90FV9cey1ccgksWeJ6/8wzXg9ZJWE3bdo0rweWSGqCkpISsrOzgYov4lqtlm7duqn/r4jExEQOHDig3gwk9R+LxcL3338PwE033QSc/1yIjY1l6NChLFu2jCVLlvhV2FXlvJVUzrmEnUajUVugVBZ5kh47id/YtQu6d3f9/9NPXRW5Gza45qG9//6aE3YSSV3h5MmTgKvRaEVJznq9/rzzaoo8u+Pnm3tKUm9YuXIlJSUlNGvWjI4dOwJVOxfuuOMOli1bxtKlS3nppZf8JqqqYqukcs4l7LRaLa1atTrn9qGhoYAUdhI/YLefbY3y449www2u/7dpU/WpdMrg9VXM4XDwyiuv0L17dxo1akRUVJTHy1vmzp1LamoqJpOJHj168FvZLs5lyMvL44EHHqBx48YEBATQqlUrvq1jFSmSmsP9Al7VvM+yiIu/9Ng1HL777jsAhg4d6tV5cd111xEeHs6JEydYt25dTZknqWHEA5+3UwwKZChW4jcuuQTmz3dNYL1qFQwa5Fp+8qSrp1418FrYzZgxg9mzZzNs2DDy8/OZNGkSN998M1qtlunTp3s11ieffMKkSZOYNm0af/75J506dWLgwIGcdu/i7IbNZuPaa6/lyJEj/O9//2Pv3r0sWLCg2nkVkvrH+XJpFEXBYrFgsVhQFKXCdYTHTgq7hsPqM93hr732WnVZVc6FgIAAbrnlFgC/VsdWxVZJxZSWlpJxZhqniq4LiqJgs9mw2WyVHlsh7AoLC3E4HDVnrERSlhdfhP/+F/r1g+HDoVMn1/KvvjobovUSr4XdkiVLWLBgAY8++ih6vZ7hw4fz7rvv8swzz7B582avxpo9ezbjxo1j7NixtGvXjvnz5xMUFMTChQsrXH/hwoXk5OTwxRdf0KtXL1JTU+nbty+dxIGQNHjOJ+zsdjuvvPIKr7zySqVTM4ltZSi2YXDo0CGOHDmCXq+nT58+6vKqnAsAw4cPB2DZsmXnrKStSapqq6Q86enpOJ1O9Ho9cXFx5T53Op1s3LiRjRs3VjilGEBwcDBajQYFl7iTSGqNfv0gK8v1ctc+997r8uRVA6+FXXp6Oh06dAAgJCREnTj5+uuvZ8WKFVUex2azsWXLFvr373/WGK2W/v37s2nTpgq3+eqrr+jZsycPPPAA8fHxtG/fnpkzZ57zCctqtWI2m9WXdLXXby60+s19W+mxaxgIb93ll19erUbDV111FfHx8eTk5LCmbINSSZ1H/B03bty42jmSGo2mfJ7d9OmeL4mkplAU2LLF5bkTGsVoBC9nURF4/VeQlJTEqTMJfc2bN+eHH34A4PfffyfAi7nRsrKycDgcxMfHeyyPj48nPT29wm0OHTrE//73PxwOB99++y1PP/00r776Ks8//3yl+5k1axbh4eHqq50fJ+aVXDi+EHYiFHvy5EkZdmkA/PjjjwBcc8011dpep9MxdOhQALXBsaT+4ItrAsg8O4mfOHoUOnSAoUNdc8xmZrqWv/giPPZYtYb0WtjddNNN6hPygw8+yNNPP03Lli0ZNWpUjc8V63Q6iYuL45133qFr164MGzaMKVOmMP8c7srJkyeTn5+vvnbv3l2jNkpqFl9cxOPj49FqtTgcjkrzOSX1A6fTyU8//QRUX9jB2d53X375ZaXhOkndxOOacAEeNtnyROIXHn4YunWD3FwIDDy7/Kab4IzW8pYqtzt56623GDlyJC+88IK6bNiwYaSkpLBp0yZatmzJkCFDqrzjmJgYdDqdmvQqyMjIoFGjRhVu07hxYwwGAzq3uYHatm1Leno6NpsNo9FYbpuAgAAPT6L8o63f+ELY6fV6GjduzIkTJzhx4gSNGzf2lXmSWmbnzp1kZWURFBREjx49qj3OVVddRXh4OOnp6WzevJkrrrjCh1ZKahJfeexkyxOJX1i3DjZudIVe3UlNhWqmC1XZYzdlyhQSEhIYMWKE+oQM0LNnTyZNmuSVqAMwGo107dpV9f6B6+l79erV9OzZs8JtevXqxYEDBzyeqPft20fjxo0rFHWShoWiKGpbgwu9iMsCiobB2rVrAejTp88FXQOMRqPaR06GY+sXMhQrqdc4nVBRStDx43DmYcNbqizs0tPTmT9/PidPnuTaa6+ladOmPPfcc6SlpVVrxwCTJk1iwYIFvP/+++zZs4fx48djsVgYO3YsAKNGjWLy5Mnq+uPHjycnJ4eHH36Yffv2sWLFCmbOnMkDDzxQbRsk9YesrCy1arG6/aoEsoCiYbBx40bA9dB3oYhw7Oeffy5bjtQjfPWwJ0OxEr8wYADMmXP2vUYDhYUwbRr84x/VGrLKodjAwEBGjRrFqFGjOHToEIsXL+a9995jxowZ9O/fn7vvvpsbb7wRg8FQ5Z0PGzaMzMxMnnnmGdLT0+ncuTMrV65UCyqOHTvmUeWUnJzM999/z8SJE+nYsSOJiYk8/PDDPPnkk158ZUl9RYiw2NjYSr0zWq1WbX9zrgo5OftEw0AIu4pCp1U9FwSDBg3CZDJx6NAhdu7cqc5gURt4a6vkLOK6kJCQAPv3l/tco9Go6T3nal4thZ3EL7z6KgwcCO3aQUmJa+7Y/fshJgaq2VuzWlOKNWvWjGeffZYZM2bw448/snjxYsaMGUNwcLDXyegTJkxgwoQJFX5WUeuBnj17et0vT9IwqErIRa/Xc+ONN553LOmxq/8cP35cffirKL+uqueCIDg4mIEDB/Lll1+yfPnyWhV23toqOcv5rgtarZY2bdqcdxyRY1dQUICiKNWe2UYi8YqkJNi+HZYuhR07XN66u++GESM8iym84ILmitVoNOj1ejQaDYqiyMaakhrFV7k0ID12DQHR77JTp07V6l9XETfddBNffvkln3/+udcz6UhqH7PZrDYU9lXxRKnDQXFxMUHV7CEmkXiNXg8jR/puuOpslJaWxqJFi1i8eDHHjh3jyiuvZMGCBerUPBJJTVAVYef+gGEwGCp96pYeu/rPucKwUPVzwZ0hQ4ag0+nYsWMHBw8epHnz5r4z+BxUx1bJ2b/f8PBwgoODK1xHURS14E6r1VZ6bPV6PcFBQViKijCbzVLYSWqOr76q+ro33OD18FUWdjabjeXLl7Nw4UJ++uknGjduzOjRo7nrrrto1qyZ1zuWSLylKsLObrcza9YswNXDsLJcPHdhJ8Mu9RPhsatM2FX1XHAnKiqKfv36sXr1aj7//HMeq2aDUG+pjq2Sql0TnE4n69atA1zV0+7tssoSGhqqCrvK2m5JJBdMVdMuNJqKK2bPQ5WzdBs1asSYMWMICwvj66+/5ujRozz//PNS1ElqDV+GYsUYFotFnRZPUn8oLi7mzz//BCoXdtXlpptuAmTbk/qAL68JIAsoLirmzYOOHSEszPXq2RO+++7s5yUlrpkgoqMhJARuuQXK9N3l2DEYPNg19VdcHDz+OJSWnn/fTmfVXtWcGanKwm7q1KmkpaXxv//9j+uuu05WbklqHV+1NQAICgoiMjISkOHY+sjWrVux2+00atSIJk2a+HRsIew2bdokczDrOCdOnGAa8K/Tp30yn6vsZXcRkZQEL7zgmqP1jz/g6qtd03r99Zfr84kT4euvYdky+OUXOHkSzrREAlyia/BgsNlcDYbffx8WL4ZnnvHL13Gnyups0qRJxMbG1qQtEsk58fXTuSygqL9s2bIFgG7duvk8jJ6QkKD2xfvss898OrbEt4iHPSHILhTpsbuIGDLE1SeuZUto1Qr+8x+XZ27zZsjPh/feg9mzXYKva1dYtMgl4ERXjh9+gN274f/+Dzp3huuug+eeg7lzXWLPG1avhuuvh+bNXa/rr4czc2BXB+l2k9QLSkpKyM7OBi68ObFAFlDUX/744w/AJexqgn/+858ALFu2rEbGl/gG8bcbWs0O/WWR04rVf8xms8fLarWefyOHw9VuxGJxhWS3bAG7Hfr3P7tOmzaQkgJncnvZtAk6dIAzfXcBVz86s/ms168qvP02DBrkmmXi4Yddr7Awl+icO7fq47ghhZ2kXiCezAMCAoiKivLJmFLY1V9qWtiJCv8NGzbI86MO42thJ0Ox9Z/k5GTCw8PVlyhKqpCdO11euoAAuP9++PxzV6Pg9HTX3K0REZ7rx8e7PgPXv+6iTnwuPqsqM2fCa6+5mhE/9JDr9dFHrmUzZ1Z9HDeksJPUC9zz63wVepOh2PpJYWEhe/bsAaBr1641so+kpCS1KEOGY+suQtjJUKxEkJaWRn5+vvpyn5a0HK1bw7Zt8OuvMH48jB7tCq/WJnl5Lo9dWQYMcIWEq4EUdpJ6QVXz67RaLe3ataNdu3bnLfCRHrv6ybZt21AUhcTExHO2pPDmXKiI2gzHXqitFyOlpaWkn/GMnMtjp9FoiI2NJTY29rwPhWKcEqtVnZdaUr8ICwvzeAUEBFS+stEILVq4cuhmzYJOneD116FRI1eeXF6e5/oZGa7PwPVv2SpZ8d6bVjk33ODyFJblyy9duXbVoEp97CZNmlTlAWfPnl0tQySSc+ExH+Q50Ov16g35fEiPXf2kqmFYb86Firj11luZOHEiGzZs4OTJkz7L7ayIC7X1YiQjIwOn04lWo6m0OTG4RPMll1xSpTEDAgIwGgzY7HbMZjMxMTG+MldSH3A6wWp1CT2DwVXUICZe2LvX1d6kZ0/X+549XQUXp0+7Wp0ArFrlyo9r167q+2zXzjXOmjVnx968GTZsgEcfhTfeOLvuQw9VacgqCbutW7d6vP/zzz8pLS2ldevWAOzbtw+dTldjYRGJxNcVse5jSY9d/aKm8+sESUlJ9OzZk02bNvG///2Ph6p4UZXUDu75db7ycmo0GsLCwsjKzqagoEAKu4bM5MmuStaUFCgocOW1rVkD338P4eGu+VonTYKoKJdYe/BBl/C6/HLX9gMGuETZnXfCSy+58uqmTnX1vjuXl7As770HkZGuELB7GDgiwvWZQKPxrbD7+eef1f/Pnj2b0NBQ3n//fbUPWG5uLmPHjqVPnz5V2qlE4i2+7GEnEGNlZWVRUlKCyWTy2diSmqO2hB3AsGHD2LRpE//3f/8nhV0dQ3jafVU4IRDCTubZNXBOn4ZRo+DUKZeQ69jRJequvdb1+WuvgVbr8thZra6K17ffPru9TgfffOPKzevZE4KDXTl6zz7rnR2HD/vuO53B67liX331VX744QdV1AFERkby/PPPM2DAAB599FGfGiiRQNU9djabrcpTM0VFRWEymSgpKeHkyZNyFpV6gNlsZt++fcD5Cye8ORcqY/jw4Tz22GP8/vvv/PXXX1UO6XmLL2y92Khq4YTD4ajylGIgW55cNLh7wyrCZHK1GzlXy5EmTeDbb31rlw/w2n9tNpvJzMwstzwzM1OWiEtqjKrm2HmDRqOR4dh6xtatW1EUhZSUlFppmB4XF8fgwYMBWLx4cY3vT1J1fN3qRCBbnkhqFUVxzW7xr3/Brbe6Zrdwf1UDr4XdTTfdxNixY1m+fDnHjx/n+PHjfPbZZ9x9993cXE0jJJJzoShKjeTYgSygqG/UZhhWMHbsWAA+/PBDSqsyD6SkVhB/s75qdSKQLU8ktcojj7jy9A4fdvXUCw/3fFUDr0Ox8+fP57HHHuOOO+7Abre7BtHrufvuu3n55ZerZYREci5ycnLU7uG+rkyUHrv6hRB2tVmo9Y9//IPY2FgyMjL49ttvueGGG2pt35LK8XUPO0Glws59LlofzEsrkQDw4YewfLlrpgkf4ZXHzuFw8Mcff/Cf//yH7Oxstm7dytatW8nJyeHtt98+Z8m5RFJdROGEyInzJdJjV79wnyO2tjAYDIwePRqAN9xbDzQQ1qxZg0ajIa9sz646Tk2FYmWOnaRWCQ8HH+d3eyXsdDodAwYMIC8vj+DgYDp27EjHjh2loJPUKDUVhnUfU3rs6j55eXns378fqF2PHcCECRPQarWsXr2aHTt21Np+x4wZg0aj4f777y/32QMPPIBGo2HMmDG1Zk9lrF+/nl69ehEdHU1gYCBt2rThtddeq7H9uadn1JTHzmKx4HA4fDq2RFKO6dNhxgwoLvbZkF7n2LVv355Dhw75zACJ5HxIYScBV/9MgKZNmxIdHV2r+27SpIk6f+ycOXNqdd/JycksXbqUYrcLf0lJCR999BEpKSm1aktlBAcHM2HCBNauXcuePXuYOnUqU6dO5Z133qmR/eXl5VFUVAT43mMXHByMVqNBwTV9nURSo9x2G+Tmupocd+gAXbp4vqqB18Lu+eef57HHHuObb77h1KlTmM1mj5dE4mu8EXZarZaWLVvSsmXLKjUtlaHY+oMIw3ap4sXO23PhfEycOBGAJUuWcOrUqQsez51z2dqlSxeSk5NZvny5umz58uWkpKRw6aWXeqxrtVp56KGHiIuLw2Qy0bt3b37//XePdb799ltatWpFYGAgV111FUeOHClnz/r16+nTpw+BgYEkJyfz0EMPYbFYKrX/0ksvZfjw4VxyySWkpqYycuRIBg4cqLYZ8TXimhAVFYXBYDjnuhqNhujoaKKjo6s0z7RGo5HhWEntMXo0bNkCI0e6euYNHer5qgZeF0/840yC3w033ODxR6IoChqNRrquJT5H5NhVpXBCr9dzxx13VHlsIRZPnTqFw+E4b48rif8QHruqhmG9PRfOR8+ePbniiivYuHEjzz//PHPP1d/KS85n61133cWiRYsYMWIEAAsXLmTs2LGsWbPGY70nnniCzz77jPfff58mTZrw0ksvMXDgQA4cOEBUVBRpaWncfPPNPPDAA9x777388ccf5XqPHjx4kEGDBvH888+zcOFCMjMzmTBhAhMmTGDRokVV+j5bt25Vj1NNYHrhBaYB8frz38K0Wi0dOnTwavywsDDyzWbZ8kRS86xY4WqM3Lu3z4b0Wti5z0IhkdQGNRmKbdSoEVqtltLSUk6fPk3jxo19vg+JbxDCrqoeu5rgP//5D1dddRXvvPMOkyZNonnz5j4b2+GAdetcjfAbNwb3iXxGjhzJ5MmTOXr0KAAbNmxg6dKlHsLOYrEwb948Fi9ezHXXXQfAggULWLVqFe+99x6PP/448+bNo3nz5rz66qsAtG7dmp07d/Liiy+q48yaNYsRI0bwyCOPANCyZUveeOMN+vbty7x5885ZwJSUlERmZialpaVMnz6de+65x0dHxxPhSfN1fp1AtjyR1BrJya4py3yI18Kub9++PjVAIjkfNSns9Ho9jRo14uTJk5w4cUIKuzqK+4wT/hR2/fr1Y+DAgXz//fdMnDiRL7/8skrhvfOxfDk8/DC4ZwQkJUGLFq6iudjYWAYPHszixYtRFIXBgweXm8f04MGD2O12evXqpS4zGAx0796dPXv2ALBnzx569OjhsV1PMfH4GbZv386OHTtYsmSJukxRFJxOJ4cPH6Zt27aVfo9169ZRWFjI5s2beeqpp2jRogXDhw/3+nicD+FJ83V+nUAKO0mt8eqr8MQTMH8+pKb6ZMhqJ54UFRXx999/s2PHDo9XdZg7dy6pqamYTCZ69OjBb7/9VqXtli5dikaj4cYbb6zWfiX1A2+Enc1mY+bMmcycORObzVal8cW4Ms+u7rJ9+3bAVUhQ1RknqnMuVIVXXnkFg8HA119/zaeffnrB4y1fDrfeqnD8uOKx/MQJ15zkZzIRuOuuu1i8eDHvv/8+d9111wXvtzIKCwu577772LZtm/ravn07+/fvP6+HsmnTpnTo0IFx48YxceJEptdQvzdvPHZiSrF169ZVOVVI5thJao2RI+Hnn6F5cwgNhagoz1c18Npjl5mZydixY/nuu+8q/NzbHLtPPvmESZMmMX/+fHr06MGcOXMYOHAge/fuJS4urtLtjhw5wmOPPUYf93iFpMFht9s5ffo0UPXmxKJxdlVJSkri999/l5WxdZjqhmG9PReqQvv27ZkyZQrTp0/nX//6F926dat2SNbhcHnqFAXA0/OnnNF5u3a51hs0aBA2mw2NRsPAgQPLjdW8eXOMRiMbNmygSZMmgOv7//7772pYtW3btnz11Vce223evNnjfZcuXdi9ezctWrSo1ncSOJ1OtbG4r/E2FOvtfUlOKyapNWqgyt5rYffII4+Ql5fHr7/+Sr9+/fj888/JyMjg+eefV/M2vGH27NmMGzdOnbZn/vz5rFixgoULF/LUU09VuI3D4WDEiBHMmDGDdevW1bvGmpKqI6oPDQZDjc0NKlue1H3qQn6dO5MnT+bbb7/lt99+4/rrr2fdunXlQqOVYbVa+emnn/juu+9YvdrB8eNzKSvq3CkuduXe9eunU0OqFRX5BAcHM378eB5//HGioqJISUnhpZdeoqioiLvvvhuA+++/n1dffZXHH3+ce+65hy1btpSbA/fJJ5/k8ssvZ8KECdxzzz0EBweze/duVq1axVtvvVWhjXPnziUlJYU2bdoAsHbtWl555RUeeuihKh0Tb5GhWEmD4Uzzc1/itbD76aef+PLLL+nWrRtarZYmTZpw7bXXEhYWxqxZs9QJs6uCzWZjy5YtTJ48WV2m1Wrp378/mzZtqnS7Z599lri4OO6+++7zltNbrVaPp0b5BFa/EGKrcePGPmlZURGy5Undx9tWJzWN0Wjkiy++oHv37vz999/07NmTr776qtL8M7vdzo8//shHH33EV1995SYYbq/S/kR3lfN5qF544QWcTid33nknBQUFdOvWje+//57IyEgAUlJS+Oyzz5g4cSJvvvkm3bt3Z+bMmR6h3Y4dO/LLL78wZcoU+vTpg6IoNG/enGHDhlW6X6fTyeTJkzl8+DB6vZ7mzZvz4osvct9991Xp+3lLTRdPCMFYUFCgdnyQSGqckhIomzZSjXPca2FnsVjUEGlkZCSZmZm0atWKDh06qE/VVSUrKwuHw0F8fLzH8vj4eP7+++8Kt1m/fj3vvfce27Ztq9I+Zs2axYwZM7yyS1J3EGKrJgonBNJjV7cpKipSPVV1RdiB62Hjhx9+4LrrruPAgQN07NiRu+66i5tvvpkmTZpgsVj466+/+OWXX/jyyy/Jzs722Hbo0KFER9/Cf/5zrr0sBiA0tBAIKffpF1984fHeZDLxxhtvnHPqs+uvv57rr7/eY5mImAguu+wyfvjhh3MZ5sGDDz7Igw8+WOX1L4SSkhKKzjRrrmlhV+pwUFxcTFBQUI3sRyLBYoEnn4RPPwW3a4RKNVrIeS3sWrduzd69e0lNTaVTp07897//JTU1lfnz59d4RWFBQQF33nknCxYsqHLYY/LkyUyaNEl9f+LECdq1a1dTJkp8TFpaGkCNdtiXxRN1mx07duB0OomPj69zVctt27Zl8+bNjBs3jm+++YZ33nmn0tkW4uLiGDZsGLfffjuXX345Wq0WhwPefx9OnFBQlIq8Qk7gOE8+eT0dO35TZ2aa8Ceir6Vep/P53NECvV5PcFAQlqIizGazFHaSmuOJJ1zFE/PmwZ13wty5rsqp//4XXnihWkN6LewefvhhNe9p2rRpDBo0iCVLlmA0GsvlapyPmJgYdDodGRkZHsszMjJo1KhRufUPHjzIkSNHGDJkiLrM6XQCrj/EvXv3lktiDggIICAgQH0vcybqF8eOHQNqVtiJUOyJEydk2KUO4p5fVxd/m0aNGvH111/z888/s2TJEtauXcvp06cJCgoiNTWVPn360L9/f6666ir0ZRrq6nTw+utw660ACu65dhoNKIqGyMhn2b17J71792b9+vUXp7hzq67VnenlFxYWVqPnQ1hYmCrsKrofSSQ+4euv4YMPoF8/GDvW1cCyRQto0gSWLIEzTcm9wWthN3LkSPX/Xbt25ejRo/z999+kpKRU2YsmMBqNdO3aldWrV6stS5xOJ6tXr2bChAnl1m/Tpg07d+70WDZ16lQKCgp4/fXXSU5O9vbrSOo4wmNX1d9Wo9GoFYFVvegLj53FYsFsNhMeHl4NSyU1RXULJ6pzLlwIV111FVdddZXX2918Myxd6uD++63k5gary5OSYM4cDd26PcOAAevZu3cv1157LevWrTtnx4CGjng496ZwIiIiwuv9hIaGcio9XToDJDVLTg40a+b6f1iY6z24ZqIYP75aQ3ot7A4dOkQzYQQQFBR0QXkvkyZNYvTo0XTr1o3u3bszZ84cLBaLmvMxatQoEhMTmTVrFiaTifbt23tsL/5gyy6XNAy89dgZDAbGjBnj1T6CgoKIjIwkNzeX48ePS2FXx6iusKvOueAvbrtNzy236MvNPOEqfk1h1apV9O7dm3379jFkyBDWrl3rEYm4mMjPzweo8t+pTqejc+fOXu9HtjyR1ArNmsHhw5CSAm3auHLtund3efKq8UAC1RB2LVq0ICkpib59+9KvXz/69u17Qf2Ohg0bRmZmJs888wzp6el07tyZlStXqgUVx44dq7FqSEndpzZy7MDltcvNzeXEiRNccsklNbovSdWxWq3s2rULqPocsfUVnc4VjamI5ORkVq1aRc+ePfntt994+OGHmT9/fq3aV1cQwq46XjhvkC1PJLXC2LGwfTv07QtPPQVDhsBbb4HdDrNnV2tIrxVTWloas2bNIjAwkJdeeolWrVqRlJTEiBEjePfdd6tlxIQJEzh69ChWq5Vff/3VY8qbNWvWnDN3b/HixeUqwyQNA6vVquZf1nSYXRZQ1E127dqF3W5X+7JdzLRq1YolS5ag0Wj473//y/vvv+9vk/yCtx676iKFXQNn1iy47DLXbA9xcXDjjbB3r+c6JSXwwAMQHQ0hIXDLLVCmJoBjx2DwYAgKco3z+ONQWlp1OyZOBNHvsX9/+Ptv+Ogj2LrV1b28Gngt7BITExkxYgTvvPMOe/fuZe/evfTv359PP/20xnoWSS5OhMgKDAwkOjq6StvYbDZefvllXn75Za+mkXIvoJDUHS6kcKK654I/qKqtgwYNUqfpmjBhAkeOHKkdA+sQoiF9VYWdw+Fgw4YNbNiwwasZKNx72UkaIL/84hJtmzfDqlUuD9mAAa72I4KJE10h0WXLXOufPOlKihU4HC5RZ7PBxo2uEvfFi+GZZ86//02b4JtvPJeJIor773d57ao5c4vXodiioiLWr1/PmjVrWLNmDVu3bqVNmzZMmDCBfpXFESSSaiDy65KTk726qRcVFXm9L+mxq5tc6IwT1TkX/EVVbZ0yZQqrVq1i/fr1jBkzhp9++umiSlepTii2OlPLSY9d/aTs71W2M4bKypWe7xcvdnnctmyBK6+E/Hx47z2X9+zqq13rLFoEbdu6xODll8MPP8Du3fDjjxAfD507w3PPufrSTZ8ORmPlhj77rEvEiZ6SO3fC3XfDmDHQrh289BIkJHhUhFcVr68GERER3HnnnZSUlPDUU09x8uRJtm7dymuvvcbQoUO9NkAiqYzaaHUikB67ukldm0qsLqDT6Vi8eDHBwcH88ssvvP322/42qdYoKSnBesajWVPNiQVi/BKrtc57fCVnSU5OJjw8XH3NmjWrahueeWAgKsr175YtLi9e//5n12nTxlXkIGbG2rQJOnRwiTrBwIFgNsNff517f9u2wTXXnH2/dCn06AELFrg8hW+84SqkqAZeC7t//OMfOBwOli5dytKlS1m2bBn79u2r1s4lknNRW4UTIGefqIvY7Xa2b98OSGFXlubNm/PSSy8BLg+e6C3a0BFh2KDAQIzn8ob4gICAAIwGAyC9dvWJtLQ08vPz1Zf7lKWV4nTCI49Ar14gOmykp7s8bmU9w/Hxrs/EOmVmzlLfi3UqIzfXc9tffoHrrjv7/rLL4Mw90Fu8FnZffPEFWVlZrFy5kp49e/LDDz/Qp08fNfdOIvEV7qHYmkbOF1v3+Pvvv7FarYSGhpZrPC6B++67j8suuwyz2cyjjz7qb3N8z/TpZ19nqK3CCYFseVL/CAsL83hVqS3QAw/Arl0ur1ltER/vanMCrhy9P/90hXcFBQVw5sHCW6qdmNGhQwd69epFz549ueyyyzh9+jSffPJJdYeTSMrhD49dVlYWJSUlNb4/yfkRYdhLL730osohqyo6nY758+ej1Wr5+OOP+fHHH/1tUo1TW61OBDLP7iJgwgRXEcPPP7u6ggsaNXIJrjNeYpWMDNdnYp2yVbLi/flmK/nHP1ztTdatg8mTXVW1ffqc/XzHDqjmA63XV8vZs2dzww03EB0dTY8ePfj4449p1aoVn332GZmZmdUyQiKpiNrMsYuKilKf7MRclBL/8vvvvwMNv3/dhdClSxceeOABAB588EFKvWmzUA/xl8dOCrsGiKK4RN3nn8NPP0HTpp6fd+3q8pitXn122d69rvYmPXu63vfs6Sp6OH367DqrVrlmkDjfnPTPPQd6vat/3YIFrpd7esHCha4q3WrgdVXsxx9/TN++fbn33nvp06eP7NIvqREURalWKFaj0ZCQkKD+35vtkpKSOHjwICdOnPCYXUXiH4Sw6969e7W2r+654A8uxNbnnnuOjz/+mL///pt3332X+++/vyZMrBN42+pE4M30YxVtJ0OxDZAHHnBVvH75pauXnciJCw+HwEDXv3ffDZMmuQoqwsLgwQddYk6ETAcMcAm4O+90VbGmp8PUqa6xzxcCjomBtWtdRRshIWKambMsW+ZaXg28FnbiYiuR1CT5+fkUFhYC3gk7g8HAuHHjqrVPIezSqpmwKvEdVquVbdu2AXDZZZdVa4wLORdqmwuxNTw8nOnTpzNhwgSeeeYZ7rjjjhqvGK0xztPaoTqhWJ1OV22vr/TYNWDmzXP9W7ZN26JFrpYjAK+9BlqtqzGx1eqqeHWvQtfpXGHc8eNdgi84GEaPdrUyqSqVPaSI6txqUK3ElXXr1jFy5Eh69uypVhF++OGHrF+/vtqGSCTuiMarMTExBAUF1co+U1NTATgsElolfmPHjh3YbDaioqKk97QK3HvvvbRu3ZrMzExeeOEFf5tTY9R2KFbsJ69snpWk/qMoFb/c55c2mWDuXMjJcTUuXr68fO5ckybw7bdQVASZmfDKK64Qqx/xWth99tlnDBw4kMDAQLZu3Yr1TGfk/Px8Zs6c6XMDJRcnQlzV5k1d7OvQoUO1tk9Jxfz222+AKwxb18OodQGDwaC2P3nttdfUNIaGRGlpKQVnvPi1JewiIyMByM3NRVGUWtmnRHKheC3snn/+eebPn8+CBQswuJXi9urVS61ik0guFCGuvBV2drudOXPmMGfOHK+7zUthV3e40Pw6uLBzobbxha1Dhgyhb9++lJSUMG3aNB9b6H9EONSg13vlxXc4HGzevJnNmzd7NaUYnA35Wm02iouLvdpWIvEXXgu7vXv3cuWVV5ZbHh4eLt3VEp8hPHZNy1YqnQdFUdTGlN4+YUthV3dw99hVlws5F2obRVHo/MUXdP7iC7Te5Oe4odFoVK/dBx98wN9//+1LE/1Obm4u4BJb3npxS0pKqtXGyGAwEHomgV3sXyKp63gt7Bo1asSBAwfKLV+/fr3MhZH4DCGuvBV2F4I4f9PS0uQUQn4kPz9fFSXVLZy4WOnevTtDhw7F6XTWH69dBY2IK0IIKxEerS3cw7ESSX3Aa2E3btw4Hn74YX799Vc0Gg0nT55kyZIlPPbYY4wfP74mbJRchPgjxy4+Pp7AwEAUReHo0aO1tl+JJ1u2bEFRFJo0aUJcXJy/zal3PPfcc2g0Gj799FO1srghIIWdRFI1vBZ2Tz31FHfccQfXXHMNhYWFXHnlldxzzz3cd999PPjggzVho+Qiw+l0VjsUeyFoNBoZjq0D+CK/7mKmQ4cO3H777QBMnTrVz9b4jpycHMDVTLw2EfuTwk5SX/Ba2Gk0GqZMmUJOTg67du1i8+bNZGZm8txzz8nkUolPSE9Px2q1otPpamWeWHeksPM/vsivu9iZMWMGOp2OFStWsGnTJn+b4xOkx04iqRrVnoDRaDTSrl07unfvjsFgYPbs2bXqXZE0XISoSk5O9qi8rg2ksPMviqKwceNGQAq7KlFJflrLli0Zc6Yf15QpU2rbKp+jKIrfPHZC2In9SyR1nSp30bNarUyfPp1Vq1ZhNBp54oknuPHGG1m0aBFTpkxBp9MxceLEmrRVcpFwIfl1Go2G2NhY9f/e0vzMpMtS2PmHw4cPk56ejsFguODCiQs9F2oTjUZDcHCwT8d85pln+PDDD/n555/58ccf6d+/v0/HrzbnKZKoiKKiImx2Oxq8m3VCcCHHVgg7s9mMw+FAV3bqJ4mkjlFlYffMM8/w3//+l/79+7Nx40b++c9/MnbsWDZv3szs2bP55z//KU94iU+4kIpYg8HAv/71r2rvW3rs/MuGDRsA1+T2gYGBFzTWhZ4LtYkvhGxZUlJSuP/++3njjTeYMmUK11xzjW8Errswq4ZIqw7CWxYWFobey67+Op3ugo5tcHAwBr0ee2kpeXl5REdHV3ssiaQ2qPJfyLJly/jggw+44YYb2LVrFx07dqS0tJTt27fX+adhSf1i3759ALRq1arW9+0u7BRFked2LSOEXa9evfxsScPg3//+N++++y7X/fYb++64g9atW1cuzHwt0nw4tr/y68DlTY2MjOR0Zia5ublS2EnqPFUWdsePH1cnUm7fvj0BAQFMnDhR3vgkPmfv3r2Af4SdmC/WbDaTk5MjL+K1jMivk8LON8THx/PQQw/BCy/w008/0apVKyq9YpcVX7XkjasK/sqvE7gLO4mkrlNlYedwODAajWc31OsJOdORWyLxFYqiXJDHzm63s2DBAsDVc9Hb4ovAwEASEhI4efIk+/fvl8KuFsnLy2PXrl2Ab4TdhZ4LNUIl4slut7PtTJuXLl26cM6kFi8F1+OPP85/Z88m4/Rp/vrrL9rXIcFWVbKzs4HqCTuHw6FOd9mlS5dqpQzJAgpJfaLKwk5RFMaMGUNAQADgmqLl/vvvL5eUunz5ct9aKLmoyMjIoKCgAK1WqxYyeIOiKGRmZqr/rw5t2rTh5MmT7N27l8svv7xaY0i8Z/PmzSiKQvPmzYmPj7/g8XxxLviEKggpRVGwWCwVb3OBQiwqKoorrriCn9es4eeff6Zdu3ZotdVuiFA9LvA7ZGVlARATE1Ot7T2ObTUQD3hCYPojz1AiqSpV/usePXo0cXFxhIeHEx4ezsiRI0lISFDfi1d1mDt3LqmpqZhMJnr06KH2saqIBQsW0KdPHyIjI4mMjKR///7nXF9SvxBh2NTUVPUhorZp06YNQIOba7Ou06Dy66o4TVZtcfnllxMUGEh2Tg7bt2/3fgA/fh9FUVRhJ6qcaxshKIUdEkldpsoeu0WLFtWIAZ988gmTJk1i/vz59OjRgzlz5jBw4ED27t1b4XRCa9asYfjw4VxxxRWYTCZefPFFBgwYwF9//UViYmKN2CipPfxZOCGQws4/rFmzBoA+ffr415AGSEBAAL179+aHVatYs2YNHTp08Lq61F/k5+djLy1Fp9X6pXgCzgrK3NxcSktL682xk1yc+P3snD17NuPGjWPs2LEAzJ8/nxUrVrBw4UKeeuqpcusvWbLE4/27777LZ599xurVqxk1alSt2CypOYTHrnXr1n6zQQq72sdisbB582YArr76aj9bU0V84b06M4bO4bjwsc7DZZddxqZNm8g3m/nzzz/P3wC6Ot+vBjx6wksWFRVV+yHkMwQHB2MKCKDEaiUnJ0fOYSyp0/jnr+QMNpuNLVu2eDTO1Gq19O/fv8rT4BQVFWG32ytNqrVarZjNZvVVUFDgE9slNUNd8tgdOHAAu93uNzsuJtavX09paSlNmjSRM9jUEAaDgSuvvBKAtWvX1ptz+0Lz63yBRqNR9y/yNiWSuopfPXZZWVk4HI5yidLx8fFV9pY8+eSTJCQkVNpVfdasWcyYMeOCbZXUDv5sdSJITEwkODgYi8XCoUOH/Oo9vFj4+eefAZe3rk63UKojOXPnpRI7u3TpwoYNG8jLz+e3336rF/mM/s6vE8TExHD8xAmZZyep8/jVY3ehvPDCCyxdupTPP/8ck8lU4TqTJ08mPz9ffe3evbuWrZRUleLiYg4cOADAJZdcUq0xNBqNWshTXYGg1WpVMSfDsbXDTz/9BPg2DHtB54IfigVMJlOl1zFfodPp6NevH+DykpaUlNTo/nyB8JBdiMfOF8dWCEsp7BoQa9fCkCGQkAAaDXzxhefnigLPPAONG0NgIPTvD/v3e66TkwMjRkBYGEREwN13Q2FhbX2DCvGrxy4mJgadTkdGRobH8oyMDBo1anTObV955RVeeOEFfvzxRzp27FjpegEBAR7VlWaz+cKMltQYu3fvxul0Eh0dfd7fvzIMBgOPPPLIBdvSpk0b/vzzT/bs2cPQoUMveDxJ5eTl5bFlyxYArrrqKp+N66tzoTbQ6XSVt9apqris4nodO3Zk/fr1ZGVns3Hjxjqd0+heEVtdYXfOY+sFsjK2AWKxQKdOcNddcPPN5T9/6SV44w14/31o2hSefhoGDoTdu0E8KIwYAadOwapVYLfD2LFw773w0Ue1+13c8KvHzmg00rVrV1avXq0uczqdrF69mp49e1a63UsvvcRzzz3HypUr6datW22YKqkFdu7cCUCHDh38Ho5r164dgNowV1JzrF27FqfTSatWrWRley2g1Wq55pprANi0aVOdftgtLCzEUlSEhroRigWXsHM6nX61ReIjrrsOnn8ebrqp/GeKAnPmwNSpMHQodOwIH3wAJ0+e9ezt2QMrV8K770KPHtC7N7z5Jixd6lrPT/g9FDtp0iQWLFjA+++/z549exg/fjwWi0Wtkh01ahSTJ09W13/xxRd5+umnWbhwIampqaSnp5Oenk6hn12fkgvHXdj5m86dOwOwbds2v9pxMbBy5UoAVWxIap42bdqQkpyMvbTU48G6rpGeng64RJW/Zw6JjIzEaDBgLy2VM1DUYdyLJc1mM1artXoDHT4M6emu8KsgPNwl4ERx56ZNrvCru4Opf3/QauHXX6v9HS4Uv7c7GTZsGJmZmTzzzDOkp6fTuXNnVq5cqRZUHDt2zKPEfd68edhsNm699VaPcaZNm8b0+pLYLKmQHTt2AJwztH4+7HY7ixcvBmDMmDHVvhl06tQJcOXYlZSU1Hju08WKoiisWLECgMGDB/t0bK/OBT9fOxwOh/oQ0blz52pNe+UNGo2GgQMHsuDdd9m+Ywc9evQgISHB+4Fq+LgJYVfd1Azw3bHVarXEx8eTdvw46enpfq3SlVROcnKyx/tqa4Mz5x5lZ8GJjz/7WXo6lG19o9dDVNTZdfyA34UdwIQJE5gwYUKFn4mmpYIjR47UvEESv+ALj52iKJw84wK/kGmkEhMTiY6OJjs7m7/++ouuXbtWeyxJ5ezatYtjx45hMpl8ml8HvjsXaovabsWUmJhIxw4d2LFzJ99//z1jxozxewpEWXwh7MB3x7ZRo0aqsGvfvr1PxpT4lrS0NMLCwtT3/prByJ/UCWEnkWRmZqpFNNWtiPUlGo2Gzp07s3r1arZt2yaFXQ0hvHVXX301QUFBtbtzHxcl1EeuueYadu/ezdFjx/j7779p27atv03y4NSpU8CFCztfIexI96M3RnJuwsLCPIRdtRHnXEaGqypWkJEBZ1J1aNQITp/23K601FUp68dz1u85dhIJoM5f2axZM0JCQvxsjQuRZ1etuTUlVUIIu+uvv97PllychIeHc8UVVwDwww8/1KmmxVarlZzcXEAKO4kfaNrUJc7cc1DNZlfunCju7NkT8vLgTFU/AD/9BE6nKxfPT0hhJ6kT/Hom0fSyyy7zsyVnkQUUNUv2mXYb4Pv8OknV6d27N2GhoeTm5bFu3Tp/m6MiPPhhoaEEBwf72RoXcXFxaIBCi0UW7DUECgth2zbXC1wFE9u2wbFjrr52jzziqpr96ivYuRNGjXL1vLvxRtf6bdvCoEEwbhz89hts2AATJsDtt7vW8xMyFCupEwhh18OPTzllEcJu69atOByOGk9ov9j45ptvcDqdtG/fnpSUFN8N7Db/at916/jFPXevAYdVq4vRaOS6667jk08/ZcOGDXTo0MHvrUUAjh8/DlC9oo4awmAwEBMTQ2ZWFqdOnaJly5b+NklyIfzxB7hfHyZNcv07ejQsXgxPPOHqdXfvvS7PXO/ervYm7sV0S5a4xNw117iqYW+5xdX7zo9Ij53E7yiKwm+//QbULWHXtm1bQkNDKSws5K+//vK3OQ2OTz/9FKBchbuk9mnTpg2tWrbE4XSyYsWKOlFscuzYMaB8laO/EUIzLS3Nz5ZILph+/Vz96sq+zlTTo9HAs8+6KlxLSuDHH6HsdJdRUa5mxAUFkJ8PCxeCn9OJpLCT+J1jx46RkZGBXq/n0ksvveDxgoKCfJKI796xXoQMJb4hNzeXH374AYDbbrutxvZjMBhqvyijmhgMBr/1atNoNPzjH//AoNdz5OhRv+eVKoqiCidfeHN9eWyFPVLYSeoqMhQr8TsiDNupUycCAwMvaCyj0cjjjz/uC7MAuOKKK1i1ahUbN27k/vvv99m4FztffPEFpaWldOjQofqVmO5h1QpCrDqdjl69etHLh+dDTSFs9ScRERH069ePVT/+yHfffUfTpk0JDw/3iy05OTlYiorQ63Q0dq9IrAa+PrbCg3jixAmcTqf0jkjqHPKclPgdIey6d+/uZ0vKIyoGpcfOt/zf//0fULPeOon39OzZk6TERKw2G19++aXfQrIiDJuQkIBeX7f8D7GxsZgCArDZ7bI6VlInkcJO4nd+/vlnAL97LCqiR48eaDQaDh48qFbpSS6Mw4cP89NPP6HRaLjzzjv9bY7EDa1Wy0033YRBr+fQ4cP8/vvvfrFDhDnrWn4duMLWwq60tDSXt1i8JJI6gBR2Er+SlZXF1q1bAejvPidfNRHTSC1evNgnPbnCw8PVDvNr16694PEksGjRIsD1ezdp0qTG9iOmkvLVuVCTCFu3bduGw+Hwqy3R0dFce+21AKxatYrMzMxa3b+iKBw8eBCA1NTUCx6vJo6tEHbCsyiR1CXqlo9bctHx008/AdC+fXt1fuALQVEUjh49qv7fF/Tv35+dO3eycuVK/vnPf/pkzIuV0tJSdf7Wu+66y3cDV+ItycvLI3XxYrQHD0Idb1eTl5fnbxNULrvsMvbu3cvBQ4f45JNPGDduXK1NzZSVlUW+2Yxep/OJsAPfH9umTZvCzz9z6NAhV56dVvpIJHUHeTZK/MrqM129feGtqykGDRoEwMqVK+tEG4j6zBdffEFaWhrR0dHcKJp8eoMMe9UKGo2Gm2++mdCQELKys/n6669r7dwX3romTZr4rUr4fCQmJhJoMlFcUqL225NI6gpS2En8hqIorFq1Cqjbwu7KK68kMDCQkydPsnPnTn+bU6+ZPXs2AP/6178wuTf5lNQ5goODue2229BqNOz66y82bdpUK/v9+++/AWjRokWt7K86aLVamjdvDsCBAwf8bI1E4okUdhK/8ddff3H48GGMRiNXXnmlv82pFJPJxFVnupN/9913fram/rJp0yY2bdqE0WjkX//6l7/NkVSB5ORkBg4cCMAPq1bVeKPuwsJCNZWiXbt2NbqvC0XMOrF//34/WyKReCKFncRvfPbZZwAMGDCA0NBQP1tzbv7xj38AsHz5cr/s3z0M5p4AXjYZvC6HiqefCZ+OGDGi/KTuMsRaZ+nevTvdz8zh/Pnnn9dowcDu3btRgMSEBL/10KsqLVq0QAOcSk+vU/mREokUdhK/oCgK//vf/wC45ZZb/GzN+bn11lvR6XT89ttv7Nu3r1b3vW/fPr744gt10nExZ+3bb7/N1KlT+eCDD9RWLBqNpk6Ku7Vr1/LDDz+g1+t5+umnq76hu+CTos8vaDQaBg0aRJvWrSl1OFiyZAknTpyokX2JCnlRiV6XCQ4OVos7ZIqGpC4hhZ3EL/z555/s2rWLgIAAhg4d6tOxa2Jqpvj4eAYMGACcba5bG2zYsIHrrruO+fPnc+jQIXX5vHnzeP311+nZsyfLly9n7ty5fPvtt4DrRlyXcDqdPPnkkwDcc889rorCc+FDIafT6VQhXNepy7ZqtVpuueUWmqSkYLXZ+OCDD3xeNHDy5ElOpaej02rp1KmTT8euqWMr7Ny+fXudfKCSXJxIYSfxCwsXLgTgpptuIjIy0mfjGo1G/v3vf/Pvf/8bo9Hos3EBRo4cCbiEndPp9OnYFfHbb78xaNAg7rrrLl5//XU6duyofmY2m5k1axY33HADb775JjExMfzyyy9qMUpd4r333mPz5s38x2DgpaCgWvO+6XQ6+vTpQ58+feqsYBLUB1sNBgMjRoxQxd2HH37o08IBMbtLu3btfDq/b00e27Zt22LQ68nKzq4xL6ZE4i1S2Elqnby8PD744APAx73Mapgbb7yR8PBwDh8+zJdfflmj+8rJyeHpp5/mqaeeYsqUKbRp08bj86SkJF599VXS0tJITk5m2LBhxMfHs3nzZt8acoHes5MnT6reuquvvrrO51JKzo3RaGTEiBE0TU3FarOxZMkSn8xOkZWVpRZm1MUZaCojICBAnetYTI0okfgbKewktc68efMoLCykffv2dbrNSVmCgoJ44IEHAJg1a1aNhl7sdjs5OTnqDADgEnu//fYbq1evpnfv3txxxx288cYbnDp1ivj4eG655RY+/fTTWmtLcT4cDgerevXiodxc5jdqVCfnApZ4j9FoZOTIkXTu1AkFWPHtt3z++edYrdZqjacoiqtHJNC6VavyhTV1nJ49ewKwa9cuch56SOaESvyOFHaSWiUnJ4eXX34ZgMcff9zn+WClpaV89NFHfPTRR5SWlvp0bICHH36YwMBAfv/9d1auXOnz8QWHDh1i27Ztakjqgw8+4O6776Znz54MGTKEhx9+mISEBEJDQ3nppZc4duwYTZo04dJLLyU/P7/G7KoSZ25qP/fty+EjRzAaDNx6663lu/PX8A3Q6XSyc+dOdu7cWSuh8wuhPtkKrvDm0KFD6X/NNWiA7Tt2MH/+fLVViTds376dAwcPotNq1TxWX1LTx7Zx48a0bNECBTntoKRuIIWdpFaZNm0aubm5tG/fnhEjRvh8fKfTyf79+9m/f3/lF/ELqLSMi4tj/PjxADz44IMUFRVdiLmV0qJFC7p27crNN99Mv379eOyxxwgPD+fLL79kxowZ/PLLL0RHRzN8+HBiY2O59tprGTlyJNu2bfPw8vmLX3/9lfUbNgAwZMgQoqOja90GRVHIzs4mOzu7zie21ydbBRqNht69ezN27FgiwsPJzctj0eLF/O9//6ty+49jx46xYsUKAPr27Vsj50ltHNu+ffsCsG379mqJW4nEl8i5YiW1xurVq3nrrbcAeO2112o3SfxCvUJu2880GkkMDcV88CDrrrlGbeDqk/2cITY2lvvuu4+VK1eSnp7OJ598Qvv27YmNjeX666/n+eefZ/fu3Vx55ZX8+9//pn///pSWltKjRw90Oh0Oh+Pcx7esnVWxuwrbKIrC+nXrWH1mDuCrr7qKDh06nH9sSb0lJSWF+++/nx9//JEtW7aw66+/2L17Nx06dOCyyy4jMTGxnGdeURS2b9/OihUrsJeW0rJFC/r06eOnb3DhJCUl0eXSS/lz61a++uor7rvvPp8Xb0kkVUUKO0mtsHfvXm677TYA7r333gvLrXMXFL4QUl6OERAQwODBg/l46VI2bd5MbGwsXbp08W5c8ZnDAevWwalT0Lgx9OmDotWi0WgYO3Ysd955J1qt1hXGnD4dRVHIzMykXbt2dO3aVR3OPX/N+cwz6ETYszrHp5rbFBcX88033/DX7t0A9Ondu17frCVVx2Qycf3119OtWzd++OEHDh0+zPYdO9i+YwfhYWGkpKQQFxeHwWAgPz+fAwcOkJmVBUCL5s257bbb6lybHm8ZMGAA+/fvJzsnh2XLlnH77bdTN+ubJQ0dKewkNc6GDRu45ZZbyMnJoXv37syZM6fG9qV77jn6rlvnejN5co3tp3Xr1vS98kp+WbuWr7/+mpKSEnr27ImmqqJo+nTYswe++w4KCs4uT0pC8/rrKDfdhEajQf/8867w0ZmbnkajYcuWLdybnk6Hzz6DM2Esd8rlsrnv05ecGa+0tJRt27bx008/UVRcjFajYeDAgfTo0cO3+5PUeRo1asSoUaM4ceIEmzdvZu/eveSbzezctavcukaDgT59+tCrV6/Kz9l6hMlkYtiwYbz//vvsP3CApUuXMvjRR4mIiPC3aZKLjDoh7ObOncvLL79Meno6nTp14s033zxnBd2yZct4+umnOXLkCC1btuTFF19Up3yS1B1OnjzJiy++yFtvvYXT6aRTp058/fXXBAYGVm2AqnjmziFWdM89BzUY7u3Xrx8Wi4U/tmzhh1Wr2L9/P/379ychIeH83oc9e+DTT8svP34cbrkFzW23wZk2CmKs48eP8+eff7J3717uueceTCYTiqKce1/eCE0vcDqdnDhxgr1797J161YsZ3INY2NiGDp0KElJSV6NJ2lYJCYmcsstt2C32zly5Ajp6elkZWXhcDgICQmhcePGtG7dGpPJ5G9TfUpSUhL//Oc/+fTTT9l/4AAdOnTg+eefZ/jw4TI0W1eZOxdefhnS06FTJ3jzTajnFfx+F3affPIJkyZNYv78+fTo0YM5c+YwcOBA9u7dS1xcXLn1N27cyPDhw5k1axbXX389H330ETfeeCN//vlnvZiGpiFitVrJzMwkKyuLo0ePsmPHDn788UfWr1+vFjCMGjWKN998k7CwsMoHqkrosg6h0WgYPHgwsbGxrFq1isNHjrDg3XeJi42ladOmJCYmEhkZSXh4OAEBARiNRpcIczpdnrpzsXIltG4NZzwZ69evZ//+/SiKwrhx44iIiMDpdPrc06EoCk6nE7vdrr6Ki4spKCjAbDaTm5tLRkYGJ0+epMStvUVoSAh9+vShW7duDcL7IvENBoOBli1b0rJlS3+bUmu0atWKu+++m08//ZS7jx/n8JgxzBk/nh0338wVV1xBq1atSE1NJTo6mpCQEJ/PkiPxgk8+gUmTYP586NED5syBgQNh716oQH/UFzSKn0uwevTowWWXXaYm1TudTpKTk3nwwQd56qmnyq0/bNgwLBYL33zzjbrs8ssvp3PnzsyfP7/c+lar1aO/UlpaGu3bt+e3336jcePGPv0u119/PZmZmWrlVWX/nuuzitYtu01F770Zr6bWrYhu3brxyCOPqFVjAAGzZ59zmwvB4XCojUJFIUFtkJ+fz4YNG9i3bx/OcxwTvU5HMnCTw3HeMb8OCOCUXo+iKCiKUmlBxLnOC2/WUxQFuxctYgKMRpo0aUKrVq1o3rx5nZsxwV/nQnWoT7bWN/x1bO12O1u3bvXwaAtecPu/TqcjKCgInU6HRqNBo9GoebXi/2J5Q2HUqFH861//8umYBQUFtGvXjqNHj3qEvwMCAggICKh4ox494LLL4Iz+wOmE5GR48EGoQH/UGxQ/YrVaFZ1Op3z++ecey0eNGqXccMMNFW6TnJysvPbaax7LnnnmGaVjx44Vrj9t2jQFkC/5ki/5ki/5kq+L7DVt2rTKBIii6HSKUkZ/KKNGKUol+qO+4NdQrMi5iI+P91geHx/P33//XeE26enpFa6fnp5e4fqTJ09m0qRJ6vvS0lL27NlDcnJygwwZiaeW3bt3y+mb6gnyN6t/yN+sfiF/r/qHt7+Zoijk5OSQkpLi4ZWt1FuXleXqSlBGTxAfD5Xoj/qC33PsapqK3LD1aS5CbzGbzYArefmc+WySOoP8zeof8jerX8jfq/5Rnd8sOTm5Jk2qN/jVZRUTE4NOpyMjI8NjeUZGRqXzBTZq1Mir9SUSiUQikUg8iIlxdU0ooyfIyIB6rif8KuyMRiNdu3Zl9erV6jKn08nq1avViZXL0rNnT4/1AVatWlXp+hKJRCKRSCQeGI3QtSu46wmn0/W+nusJv4diJ02axOjRo+nWrZvavNZisTB27FjAVT2TmJjIrFmzANck7H379uXVV19l8ODBLF26lD/++IN33nnHn1+jzhAQEMC0adMqzyuQ1Dnkb1b/kL9Z/UL+XvWPWvnNJk2C0aOhWzdX77o5c8BigTP6o77i93YnAG+99ZbaoLhz58688cYbatf6fv36kZqayuLFi9X1ly1bxtSpU9UGxS+99JJsUCyRSCQSicQ73nrrbIPizp3hjTdcbVDqMXVC2EkkEolEIpFILpyG1+9DIpFIJBKJ5CJFCjuJRCKRSCSSBoIUdhKJRCKRSCQNBCnsJBKJRCKRSBoIUtg1YFJTU9XJo8XrhRdeOP+Gklpj7ty5pKamYjKZ6NGjB7/99pu/TZJUwvTp08v9PbVp08bfZkncWLt2LUOGDCEhIQGNRsMXX3zh8bmiKDzzzDM0btyYwMBA+vfvz/79+/1jrAQ4/282ZsyYcn93gwYN8o+x9QQp7Bo4zz77LKdOnVJfDz74oL9Nkpzhk08+YdKkSUybNo0///yTTp06MXDgQE6fPu1v0ySVcMkll3j8Pa1fv97fJkncsFgsdOrUiblz51b4+UsvvcQbb7zB/Pnz+fXXXwkODmbgwIGUlJTUsqUSwfl+M4BBgwZ5/N19/PHHtWhh/cPvDYolNUtoaKicbq2OMnv2bMaNG6c2454/fz4rVqxg4cKFPPXUU362TlIRer1e/j3VYa677jquu+66Cj9TFIU5c+YwdepUhg4dCsAHH3xAfHw8X3zxBbfffnttmio5w7l+M0FAQID8u/MC6bFr4LzwwgtER0dz6aWX8vLLL1NaWupvkySAzWZjy5Yt9O/fX12m1Wrp378/mzZt8qNlknOxf/9+EhISaNasGSNGjODYsWP+NklSRQ4fPkx6errH31x4eDg9evSQf3N1nDVr1hAXF0fr1q0ZP3482dnZ/japTiM9dg2Yhx56iC5duhAVFcXGjRuZPHkyp06dYvbs2f427aInKysLh8NBfHy8x/L4+Hj+/vtvP1klORc9evRg8eLFtG7dmlOnTjFjxgz69OnDrl27CA0N9bd5kvOQnp4OUOHfnPhMUvcYNGgQN998M02bNuXgwYP8+9//5rrrrmPTpk3odDp/m1cnkcKunvHUU0/x4osvnnOdPXv20KZNGyZNmqQu69ixI0ajkfvuu49Zs2bJORMlEi9xDxd17NiRHj160KRJEz799FPuvvtuP1omkTRc3EPkHTp0oGPHjjRv3pw1a9ZwzTXX+NGyuosUdvWMRx99lDFjxpxznWbNmlW4vEePHpSWlnLkyBFat25dA9ZJqkpMTAw6nY6MjAyP5RkZGTKXpJ4QERFBq1atOHDggL9NkVQB8XeVkZFB48aN1eUZGRl07tzZT1ZJvKVZs2bExMRw4MABKewqQQq7ekZsbCyxsbHV2nbbtm1otVri4uJ8bJXEW4xGI127dmX16tXceOONADidTlavXs2ECRP8a5ykShQWFnLw4EHuvPNOf5siqQJNmzalUaNGrF69WhVyZrOZX3/9lfHjx/vXOEmVOX78ONnZ2R7iXOKJFHYNlE2bNvHrr79y1VVXERoayqZNm5g4cSIjR44kMjLS3+ZJgEmTJjF69Gi6detG9+7dmTNnDhaLRa2SldQtHnvsMYYMGUKTJk04efIk06ZNQ6fTMXz4cH+bJjlDYWGhhwf18OHDbNu2jaioKFJSUnjkkUd4/vnnadmyJU2bNuXpp58mISFBfbiS1D7n+s2ioqKYMWMGt9xyC40aNeLgwYM88cQTtGjRgoEDB/rR6jqOImmQbNmyRenRo4cSHh6umEwmpW3btsrMmTOVkpISf5smcePNN99UUlJSFKPRqHTv3l3ZvHmzv02SVMKwYcOUxo0bK0ajUUlMTFSGDRumHDhwwN9mSdz4+eefFaDca/To0YqiKIrT6VSefvppJT4+XgkICFCuueYaZe/evf41+iLnXL9ZUVGRMmDAACU2NlYxGAxKkyZNlHHjxinp6en+NrtOo1EURfGXqJRIJBKJRCKR+A7Zx04ikUgkEomkgSCFnUQikUgkEkkDQQo7iUQikUgkkgaCFHYSiUQikUgkDQQp7CQSiUQikUgaCFLYSSQSiUQikTQQpLCTSCQSiUQiaSBIYSeRSCQSiUTSQJDCTiKRSCQSiaSBIIWdRCKRSCQSSQNBCjuJRCKRSCSSBoIUdhKJRCKRSCQNBCnsJBKJRCKRSBoIUthJJBKJRCKRNBCksJNIJBKJRCJpIOj9bUBt43Q6OXnyJKGhoWg0Gn+bI5FIJBKJ5AJRFIWCggISEhLQai9un9VFJ+xOnjxJcnKyv82QSCQSiUTiY9LS0khKSvK3GX7lohN2oaGhgOvHDwsL87M1EolEIpFILhSz2UxycrJ6j7+YueiEnQi/hoWFSWEnkUgkEkkDQqZYyeIJiUQikUgkkgaDFHYSiUQikUgkDQQp7CQSiUQikUgaCFLYSSQSiUQikTQQLrriCUntoyiKR0KreO90OtFoNCiKglarxel0qp+L94qioNPpUBRF3V6sJ9bV6XQ4HA70ej0OhwNFUXA6nRgMBhRFUV+lpaUYjUZsNhs6nU4dS6zncDjUfYmXTqdDo9Gg0WhwOBzqOhqNBrvdjtFopLi4mKCgII/vabfb0Wg06PV67HY7Wq0WnU6H3W5Hp9PhdDrLfS/376Moijq+w+FQbXA6nTgcDoxGI6WlpWi1WkpLS9XvII6neIl+TuIYiX2I7221WtHr9Wg0GnQ6HVar1eMYiG3EdxHH3uFwEBAQoK7jvi+xjjhGBoPBYx1xbEwmE3a7HafTqZ4LTqcTrVaLXq+npKQEo9GITqejqKhIXV5cXIxGo0Gr1WKz2SgtLSUwMFD9PiUlJQQGBlJaWqqOGxQUBEBhYSFOp1M9D0pLS9VzwWq1EhQUhNVqxWazYTQa1e+h1WoxmUxYLBYAiouLCQ0NpaioCLvdjslkoqioCIPBQFhYGKWlpdjtdvLz8wkMDESj0XjYJY6VVqtFq9XicDiw2+1kZ2cTFRVFYGAgNpsNjUZDSEgINptNtSEzM5OAgABKSkpwOp3qORYXF0dxcTEBAQEUFRWh1+sJDAykqKiIoqIidDqdui+NRkNwcDBGo5H8/HzS09OJjo4mNDQUi8WCwWAgKCiInJwcQkJC1HO8tLSU0tJSSkpKCAgIUL+rXq9Xj7fD4aC4uBgAk8mkfs/CwkL176S0tBSHw4HBYFD7iur1egoLCwkMDASgoKAAk8mk/v7FxcUYjUYsFgsBAQFYrVZyc3PV86ykpITCwkJCQkLUbU6ePEl4eDhbt24lMjISh8NBUVERiYmJZGdnk5aWRnx8PBaLhdjYWDIzM4mLi0Or1dK2bVtMJhMlJSWEhoai1Wpp3rw5iqIQHR1NQEAAERERaDQaDAYDAQEB6rlkMBg8rh3ib979OiiT/CU1hRR2khqnMmHnflMFKC0tVdcT4sNms6k3A3GzFTcFRVFUUSLEkxANVqtVFQliX1arFUAVDMXFxQQHB2O323E4HJSWlmIymbDZbIBLoIgbMbjEjBAtQigVFhYSEBCA0+lUhVhJSQkOh0O1x/2CLm6C7uJNURQPESpujOJmoNVqPZYHBgbicDjU/ZhMJnU98R0BVTwEBARgt9spLS1Vb44Gg4GCggJ0Oh0BAQGqEBG/R2FhocdvEBkZCZwVrCEhIRQWFqqCQ2Cz2bDZbOoN0V3AW61WLBYL4eHhBAcHk5ubS3FxsSp0xFhBQUHqDd5gMGA2m7FYLOrywsJCDAYDFosFu91OVFQU8fHxnDp1iry8PI/fIyAggJiYGBRFISMjQ73xFxUVkZ2dTXh4uNrYNDIykpKSEo4fP05YWBh6vZ6AgAAMBgORkZGcPn2a/Px8D1EsxJU4d+Lj43E6nZjNZnJycigsLMRkMhESEqKKO/FbGwwG9dzMyckhKyuLiIgI4uLi1GMSHh6u/pYOh4PTp08THByM1WolPz9fFQ3x8fHqg0tRURGBgYGqOMzKylJ/NyHumjVrhtlsZv/+/ZjNZuLj4wkICABAr9ejKIr6+xmNRgICArDZbBQUFKjHNSkpSbXLbDarf5vZ2dnYbDZCQkJUwVdSUqKOKx5mcnJyyM/PJyQkhICAAHJzc9X9Z2VlYTQaCQoKwmw2U1BQoP4dWiwWiouLycrKupDLklcYjUbatGlDcnIyERERtGrViuTkZAIDAwkNDaVRo0Zqm43Q0FCCgoLQaDSq2BO2i9/yYm+gK6lZpLCT+AUh7ioSfO7LhJdIiBt3b5/wAAmB5+4Vcvf6Ce+MEEdCaOj1etXjVVZ8Cq+Y8NKJm5IYu6SkRBVUYj0hxMRNWdzUhBfO3VMjbuhlv48QQOImLG6CRUVFOBwOQkNDVYGnKAomkwmj0YhWq6WoqEg9jjqdDoPBoAozsU1ISAgOhwOr1YrJZKK0tFT1NBkMBtW7YzKZVG9dRESEKvL0ej1BQUGqqNTrXZcQq9Wqilm9Xo/NZsNgMKjrWSwWgoODiYuLQ6fTYbPZKC4upri4GIPBQGlpKUFBQdhsNiwWC6GhoZSUlJCVlUVgYCAhISGkpaWpolgIgtTUVBwOB4cPH8ZutwNnPYZBQUEkJSWRlpZGVlYWwcHBBAcHc/r0aQwGgyrwTCYTYWFhHDx4EIDExEQKCwsJDQ1VPS8HDhxQxb/VasVgMACogi4iIgK9Xk9ubq4qOPPy8oiOjlaPnU6nU+3X6XSUlJRgNpux2Wzk5uaSnJysCoLg4GBMJhMajUYVMk6nk7CwMNLT03E6nZhMJgIDA1VBJjyKQojl5eVhNpuxWq2qF8tkMhEXF8euXbvIyMggLCyMpk2bUlJSoj5kCGEeFBREeHg4BQUFmM1mzGYzer2exo0bEx4erv5WQuilp6dTXFxMeHg4RqMRu92uCsrg4GD1Ny8pKaGoqAiNRkNERARWq5WcnBwMBgOFhYVYrVaCg4NxOBzk5+djNpspKSkhJycHjUZDYWGh+lvXBo0aNaJNmzZER0fTtm1bGjVqRGBgICaTidjYWBISEggICECr1RIWFqZeF4KCgjz+rsVDpvTUSWoaKewkfkHcfMuGYMW/wiPm7sFzD0e6CzHxr/DoFRUVqWE09/Cfe4jRbrerQkKILiE4xL5F6FSML96LbcVNXaDRaFRPmxA5VquVwMBAj9CoEIfi+7sfAxF+E2FOjUaD2WxGo9EQHh5OSUmJuo64sZeWlqreNyE03UM/IowptncXFsJj53A4KCgoQFEUNcyl1WrVqffE9wBU4anX67Farar3CVC9qU6nE6vVqnrXwsPDVVFqsVgoKCjwOBaKolBcXExUVBRWq5Xjx4+r4cDc3Fzy8vIICQnBbDYTGBhIUlISwcHBZGVlqeE4IWAcDgeRkZEYjUb279+vhhGFIBOhQBGqLCkp4dSpU4SHh2MwGNSwpsFgICsrC4vFooaGCwoKiImJUT2TwrtmtVopKCgAUL16CQkJHl5L4RlVFIWioiJVqNjtdhISElRRIMKciqKQk5OjCier1cqJEycwmUyqJyg0NFQNO1osFiIjI9FoNGRnZ5Odna2KTiFQLRYLa9asISAggNTUVHVbIWSDg4PVhxidTkdmZqZqZ3x8PDExMepDQnFxsRpCzsnJUc+9goICNfwswvDFxcWcPn1aFfwOh4OgoCCys7PV8K4IXUZFRQFw6tQpMjMz1fO3uLjYwyNd04gHhyZNmpCSkkLbtm1Vb3V0dDTR0dEkJSWpD5YiXAsQGBjokZIgvptEUhtIYSfxC2U9ZIDqmRMIwSVEkBB2wvMl/i9uhkLMiAutey6eEGNWq1UVfUI4ihw14QVwFwDuXjqHw6HemNzDb+Jzu92uip3g4GA1r0nYLkJ4wksIqP8XOXyA6i0T3jSj0UhISAh5eXmqhyw4OBiDwYDNZqOwsNBD1InjJcK1Yp9C3AoPntFoVAWLEGjgEpcBAQFqmFqE48Rxtdls6nJhg3uunLC7tLSUyMhIVYgUFhZSVFSkClMxnt1uJzg4mMDAQNLT08nPzycyMhKbzcbJkydVEasoCo0bN1bDiVlZWeTk5KgiXIQtw8PDKSws5MiRI2ooVYQCs7KyVEFnsViwWCwUFRWpIkyETK1WK5mZmepvm5GRgUajoXHjxuTn52MymWjUqBGHDh1SQ/BGo5Hs7GwCAgJUIQaufKvQ0FBycnIwGo1kZmaq31+j0RATE0NERAR2ux2z2UxkZCQFBQXqeSjy00QuoV6vVz2B4niaTCZVuGdmZqreXSHGS0tLyczMVMO98fHxFBUVkZ6eTlBQEPHx8QQHB6vnTWFhoSoqo6OjiYiIUO2y2+3qOSTy2sS5oNPpPHIT7XY7p0+fVtMfhOdKhGyF51uc1yaTidzcXI4fP64+RImQt/j7qGmCgoKIjY2lRYsWNG/eXBV44reKiYkhOTmZ4OBg9SHJaDSq56j7w4o4VyWS2kQKO0mtIsSDEDkC93CruMiLC6II+QmPmXsSvchTcjgcBAYGqh4iIdrciwbck/TdPYFiPPcEfXHTFaJBeAyEGBJiQyCEmFhX5HiFhIQArlBqcHCwmmAu9iuEoihaEPlTVqtVFY4mk4m8vDw1vBUWFqZ6AwsKCtRQrHu4RxQGiO8ivp8IpwqPgkj+F8dIq9USGRmpJsGL72IymSguLlYT60WYWXjvxPctKSnBYrEQGBhITEyMmpsl8ryE8AsKClKPaUREBCUlJRw4cACdTkdYWBj5+fmqCC8uLiY2NlYVyaWlpeTl5ZGbm6sKHRHCdDqdaqhSfOfQ0FBMJhMnT57E6XQSHBxMXl6e+jCQkJCghqmFgM/Ozla9mvn5+cTExKiCNSUlhZycHHbt2oVGo1ELCPLy8jAYDOp5KAQtQFZWlupZFd7MkJAQoqKi1CIFo9FIXFwcp06dUkWROMYitGc0GlUPcElJCaWlpcTGxqqhSnFuRUVFqd5TEdLW6/UkJSUREBDAsWPHADzCqjqdjoKCAnJzc9VCj5iYGDVnLD8/H4vFoqY12O12iouL0Wq1qgAV54XD4SAnJ0c9X4TAFOJeeF6Dg4M9zt19+/ap4thqtVJUVFSrXrrIyEg6depEfHw8kZGRhIeHk5SURGBgIKmpqYSHhxMdHa0+0DmdTvX8El5ugbhOSCS1jUYpW5bXwDGbzYSHh5Ofny+nFKsl3D1x4sbjLuzEMlG0IG6GWq2WkpISANVr5B7qdBddYru8vDyCgoJUoSI8cSInTYgSYZMoPhCeraKiInX/7pWeYn9CfIpQmcidEuEy4ZmwWCxqRZ/wBJbNm3MvTjAYDKqXT9w49Xq9mnckQr+BgYGq4BCFG2JckSwvwmNarRaj0YjT6aSwsFAdT4g9i8WiigPhZRIeCOHtFHmIoihB/F5ifPHbCXt0Oh0RERGqoBU5ZMKzKPK2xLpBQUFkZmaqoVnhsRF5i06nk0aNGlFUVKSKi8LCQjIzM9XEdeE1FNWy4EqwVxSF8PBwiouLOXHihOpZEYIuIiJC9drFxsZ6hKOdTifZ2dno9XpiY2MpLi4mJiYGi8WiehVFcYB7bqc4HsI7ZTKZyM7OprCwUF1WUlJCVFSUun12djaRkZFERESwf/9+1Ysqil4cDoeaIyfOPZFTKfIdhfgTOW6AmucnHirEcc/PzycqKspDLIvQsDjHAwICCA8PJzY2ltLSUtLT09VKW/F7i3NY5PSJvDkh6BwOBxEREepDRk5ODoD62wYHB6t/h4cPH+b48eMEBQWh1+sxm80UFhb67Bp0PmJiYmjWrBmNGzcmKiqK6OhogoKCaNSoEYmJiSQmJhIQEKCevyIPNCwsTH2Qci+KEA+nktpD3tvPIs8+Sa0iPCLuFz53oVP2gijCNiKUKLxW7i1AhGBzL1pwD6fCWXHp7s1z34eiKOoTt7hBu+f+iTBr2WIJcaMWYUvhJXIPy4iwpxAMgtLSUrXqV+QmiTHEDVRU7goBCqhiRAhHIZBFOFV4ukT+lAjVCRFos9nIy8tTPXFiXCHqxHcTXlERxhZhMSH2RBgtNzeXoqIiwsLC1Bwsu92uVs0KT2FsbCyA6q2xWCzk5+erx6C0tJTTp08TExNDbm4uUVFRqlgOCgoiIyMDp9NJTk4OcXFxqtATwkHkxIl8ML1ez7Fjx8jIyFBFlKIoatj1xIkThISEEBERoYoSIWJF6LZRo0Zqq5oTJ06o+XMREREeVdsinzAoKIjQ0FA15/H06dOqiBEFJjExMWrhhsVioVWrVpw+fZr9+/er30k8SERHR+N0OtVcPXFsbDYbYWFh5OTkqF6ygoICoqOj0Wq15OTkkJubi8FgUItfMjMziYiIUIs0xIOSKIAQHmKj0Uh0dDTBwcFkZmaSnZ2t/u24/z2Ay8NVWFioPiBkZWWpoefi4mLy8vLUh43w8HDy8vJU711xcTHZ2dmqJzU8PByr1crJkyd9campEiK0GhUVRXJyMjExMej1evV9dHQ0iYmJGI1GIiMj1epxIfyE91WcI+Ickkj8ifTYSWocd4+de26ZuxdPJFALrxKg5joJMSg8RuIm5B4mFOO4txkRosdisajrh4SEYLVaVbEibBNepYCAALUAQ3hI3PPBRB6W8My5V0hqtVpVcLmHhkVxgrBXhAxFewoRVnUXi+L7lM0LdBcQer1eFYzCiyJCkCI0rCiKGq4UbTjEsRFhUpGHJkSnEFPuvdxEHpXwAArhk5eXh6IoxMXFqcKpqKjIo/IxICBA7YUmBLPZbFZDsoqieAi8kpISGjduDJwtJsnIyFA9anFxcTidTrWnnPi9MjIySEhIUPMRRXuT6OhoioqKVA/V6dOnVfEtBLhOpyMvL08V13FxcaogOn78uJpHKLxZwuvnHuIW3ikhri0Wi+pRNplMFBYWqraL/n7h4eFqaxT3HouidYYQeGFhYWpbFuEhE+e1KO4ICwvDbDaTn59PcXExYWFhanGICBkbjUYiIiLUliSisEH83ZlMJqKionA4HKSlpakeOfcK6sLCQiIiIjAajeTl5an95ESlscPhID09HZvNRkREhFrFLIpnhNjPy8sjPT2dwMBAIiIiPCqba4P27dsTHh5Oo0aNCAsLU9uuNG/enPj4eLWNjgh/C+EbHh7u4akV548skPAv8t5+FinsJDWOu7Cz2WweOXRCTIhWC8LjJtYXgkfkRgkB6N7zToRFhTAUHiMhuNwFj8jdEWJNVO/l5+ejKAphYWHqDU/k2IlqRvcwqsgLEt4kQA0Ti8/EdxPhWvHevfhD2OHeKFiIwKCgII8K3+LiYoqKitSbpRDH7sUL7gUJGo1GzccSN1NxvIQILttYWYR+xY1K5PsFBASoITJAbTshQnaiCEV4f8Q2ovWDyJMSYT3RhLekpITc3Fx1/aCgIOLi4lRPY3FxMQUFBWr+o2jW6+4Nzc7ORqPRkJiYiM1mIycnh1OnTql90CIjI9Hr9eTn55OVlaV6F8X5FBgYyMmTJ1Vxn5qaqjYcTktLQ6fTqWJGhLCFCBPiWzxMiAa44ncPCgpSQ+eiwlg8jIg8OnFMhV2BgYHqA4MoLHF/GBFhbfE7iP5xoigDUD2sIsQuPHFClIv8NSHqwdXWQ3hEs7Ky1HYedrudgoICNYcwOjqazMxMzGaz2utRhHRFFW1CQoL6wCLanbgfY5HLFxUVhV6vV1vN1AYpKSk0atRI9dTp9XrVi9q0aVOCgoJISUkhODhYLWoRfQHdmxCLhxQRYpeizr/Ie/tZpLCT1DhC2Akx4d4TToiRsg1UhbATN3ThARPrWSwW9YYBqE/PIpQoBJcId4qLsQiZCCEkBIvooyVuqiJHz907J8Sn8GIIMRkUFITFYilX0SvCqu6Nf93Fp1hPiDrhzRQ3YZGXJbxTDodDTYoXxSRCFAhxJsSn+J7ixio8kO75gO7HxL0/nwjRCRuFZ8/de6ooCkFBQepNXeRnCeHuHpoSsxBkZmZ6NOstLCwkPT1d9VCFh4erx1+EgDMyMlSBJpoZl11HiBcRChR2RkdHq/l3paWlnDhxArvdru5LePpOnz6tHv+UlBQ1J/H48ePqd4iOjlbDikI8C0HlflyEJ1a0anE/R0T4VITDhWAS7yMjI1V73f92hFcXIDc3V92/EE7iHHA/10QltXggKikpUdMahM3uuXSA2k/ParWSmJgIuJoIi+8sZgo5ffq0ao9IQSgqKuLUqVNqg2VRgBEaGsqJEydUT7WiKBw9elTtk3fkyBGP9ISaJDw8nMaNG9OsWTO1YjggIIDY2FjCwsLU4oi4uDhCQkLURuDuPQVF5a/79ca9ybrEf8h7+1lkjp2k1nCvSBUCyd2z5d4CAvBodSK8fEK0iLCIWF9sK/YjxheePXdh6Z4rJMSPCE0KD5kQNe4hVOGVEWFNYYOo/BNP8GJM9zYb4ubtXqUrPDni+wgbtFotBQUFqndRhESFkBDeJBEaFN/JPWws9ie8isJL53Q6Va+Xe38t9+pW4bETn4uCAtF+Rq/Xq+1WiouL1Wm6ALVKWYgMIQhLSkqIj49XvVwiDCfaaAivp2hWKzxUQthmZmaqIbDTp097eBqFqDp27JhqV2xsLHl5eWr40D3UKWZZ2L9/vyrwHQ4HzZs3x2q1qm1UxDEPCgri+PHj6o1dVBQL8Ss8sEI0CQ+hCIGKHMnw8HBVpDudTgoKCtRzKS4uTv3OYmotESoWXjSTyeTR9FmEs8UDj8jDFKF3kWfpXiku9iEqXUUoWbR9iY2NVRstiwcZkbN6+PBhNf9TtD45fvw4hYWFhIeHk5qais1m48iRIx6Nh0UObE5ODgUFBURFRZGWlkZ6enptXHYAV9PpuLg4GjduTHJysvo9xDRq8fHxJCUlERQUpIZkRXhd/G2Jhykp6iR1HSnsJLWCu9fO/YbsXlUKZ3vVuT/huzfDLdurzn1MONsaxV0wiRw3QL3BuW/jLtqECCwpKSE6Olq9ubnbJkKbIkQmnuKFgBL7Ep440c7EPYwrQnYiJCsKG7RaLfn5+Wr1pgjbifWMRiM5OTkeNxR30eZuo+gD5j5VlNivSAQXAkXkB4pjKmwROV3CwyOm+RLizP17iRugCMW6z3AhZh5wOp0cP35czaOLiYlRxacIEYrq5uLiYiIjI9WWKEVFRWqO3alTp9QKxdOnT2OxWIiOjla9Ynl5eZhMJjU/ToTrO3fuTEZGhtpaRQgg4Zk9fvw4ZrNZrewVVbDiOItjKMKhokWK8BKI3mbi/BOhcCGmbTabR/6iEA9CMIt5UMPCwtTQu6guFX3lhAc0PDxcPcbCiywEspgjVoi9wsJCLBYLYWFhREdHq9tlZ2erD0sxMTFqEYR4IBIFDsHBwaoQtNls6m8oKkMVReHUqVOq51QUugBqc2LxIHbo0KGauMRUSHh4OCkpKaonMSkpSX3QSklJISgoCJPJROvWrdV5fsXfrAixi0pk94IqKeokdZk6Vb6zdu1ahgwZQkJCAhqNhi+++MLjc0VReOaZZ2jcuDGBgYH079+f/fv3+8dYiVe459m5C6Wyn5X93L3KTCx3LyZwXy7+L/LpSkpKVG+BeMJ2b9XhPu+s2J/wxLmHNN1bs4hKUxHmBTyS3oUoFOE3QPWuCS+BCF2Jbd1nycjPz/doxyJsF+HQ7OxstapQeGRETqDIT3QP3QrBKMRoQECAOieq8AaKsKiwXxRACAEheryJ0JUojhCfi+R64Z0T4W9RNCBac2RlZXH48GFMJhOpqakkJCSouVuiwra0tJS//voLm81G48aN1RCy+5Rap06dIioqCoPBQFpamkeVqkajUUOTR48eVY9BYGAgiYmJHD16VJ10Pjw83KNA5vDhw5SUlJCQkEBwcDDp6emYzWbVSyfOx4KCAgoKCtSZE2w2G1FRUeqYorVMSEiIGu602WyYzWb1e4jzSbSFURRFnf1BHD8xL7BGoyEtLU0VZ6Idh2jhI0LpYuYKkScJqGJVCJmwsDAcDge5ublqKxpxDoq/DZGPmZmZqVaAup8noh2NaIicnZ1NXl6emi8ozjXRWy8vLw+AY8eOqfPB1hTib06v15OYmEiHDh1o3LgxLVu2pFWrVmohRJMmTQgMDCQqKopLLrlE9WCKc8W9ql08GLkjRZ2kLlOnPHYWi4VOnTpx1113cfPNN5f7/KWXXuKNN97g/fffp2nTpjz99NMMHDiQ3bt3ezSLldQt3EOu7iLNPQFehPncCxTKeqBEGMr9xig+E54594Rw9/w89555osmvyHNy3xe4hKPwQrjPWwkukSMEiBBcQiCJicy1Wq3aP02ECd2rX4Xn0b2prqhOdJ8pwb1oQzQoFgn/7l5O91k2xA1dNIwVTYCF10wk/4tjLIRGYGCgR3WwaOUhbnjCCydmlBCJ/GIsIbbF7+SeJynCrsHBwSQmJqpi5ciRI0RHR2M0GjGbzRw4cID8/Hx17tLjx4+rFcZCRIpKUtHkVnwnIaZFn74TJ06o+V/BwcEYjUaOHTum9pATeYfiunHw4EE1J62goEDN4XQPK4viEeEJzs3NVaspY2NjOXXqFPn5+cTHx3ukAogK4aCgILUNiug7KDzCouedqLYVnra0tDRV3AovogiTijxM0ehYiGrx4CCqjEWIVHjixNyzIs9N/M2JwhKRexoREaEWZIjvYDAYiIyMJD8/3+PcFd5u0U9P7Ee0tKkNRLVyWFgYzZo1U3vPJSYmEhoaqj4AREVFqfMWi7Yl4GrdIv6eRE6heNBxx72xukRSF6mzxRMajYbPP/+cG2+8EUDtP/Xoo4/y2GOPAagX0cWLF3P77bdXOI64kQrMZjPJyckywbIWcQ87ueMengXUSlYR7hI3DXdPUmFhoZrQDKihIXETFiEt0UdNhMbEfkQOXXBwsNpnTYTh3Nt7uOfZiWR94ckSBQPCQyaa64qbalhYmNqSxW63q14U0QLDaDSqrR9EuEvchMVN3b1lixCGwnMFqN5HEaIWyf/uYlgcDyFMhSdF5Oi5J9CLXDMxsbuoCBQhO5HbJ5L9RZjXXYQC6tgiT0zMBSo8fsLDqNfriY+PJzs7m5ycHI4fP64mtAvBLcK3ohmwEJDCC6coijofqsh/s9vtHD9+HKPRqM7Q4XQ61by8kJAQNSwYERGhhnyFN1WIESG84OwUc8IbZTab1V5vzZo1w2w2qyI1JCRELU4Qv7944LBarercruKcN5lMZGVlecwoIa5Zp0+fVhP3RYhfeKGFkG3atKkqIBVFUXvchYSEEB4ergpMUQ0rcjeFaDEYDJw+fVrNwxMPDsK7KAovhPgTv78QcYCaS1hcXKz+VllZWaqnrqYRDxJiBoiYmBiaNGlCZGQkjRs3xul0EhkZqU6zJipi4+PjVUEtxL8o+hEv95ZMYl+SuoksnjhLnfLYnYvDhw+Tnp5O//791WXh4eH06NGDTZs2VSrsZs2axYwZM2rLTEkZKnpuEILOPT/OvULTfZkId5bdViC8BkI4CUHmnlsmxJHwcLkXGghBJgoFRAhVrC96k4n1AI8GwsJjJcSlqBwUXo6IiAgA1XMTGhrqURUsvGOib5moghTiSORpiQa07pW7gEcxhzh+IkcOIDQ01KM9iPCOuXvWxLaiQCEhIUEdW3i1RBK+GEuIUOEp1Wq1BAcHq1Nx5ebmqpPBi1CfCFeL4oK0tDQ1JNioUSM1DCg8nqLNSXh4uEfrjLCwMIqKisjOzvZo/ZKTk0NOTo46SXthYaHaly4yMlKdDisqKgqtVkt6erpa7KHRaMjLy1N7BAqBI0STqFAuKCggODiYVq1aERYWxqFDhygtLSUuLs6jAlc8YIicSPG7id80ICCA4uJiMjIySExMVPchjrloayOqoM1ms1pAJDzKMTExaiuO7Ozs/2fvzWNkT8/q/lNdW9e+V+93mzubbQhyrIQ1wUJREmUBEgUlAsmQCEUkChD/AxYB2wQrIVEIEhL5BSlSTCBBQSgEI/GHRRSEA8EDgTHgWe/cubfX6tr3rbvq90fzefqpmr4zY8+1PXemXmk0M93VVd/6Lu973vOcc56FrhNskNhgUNqNx+OWV9fr9XR6eqr5fG7XpFarqdPpKJVKWWu5RCJhDB0Am43T2tpFCzq+I7rGL1dfVwDn5uam6eIef/xxxWIxM6vAhBaLRWUyGW1sbNh9Q9blshvfB6WzKbqqJLsaq/F2HI8MsEPAvLGxsfDzjY2N13VXfeQjH9GHP/xh+38Yu9X48gzMEZIso43/9s5Y/pvhjRPeSAHwucoB6vOllku/BL36oF8P7CjZkkmFOQJA4XVwHJ/Pw4OFoQMG7AyfT3AxQCIYDJoOLpFIGLsGqEMbh4kCUwEgzzN0sJkcA+AW16pfpChPYz4BSEynU+3s7Ng59CHGfD5gkO/nu16Ew2HrUIB2iy4IsHqUdRuNhjqdjon7Nzc3rd0UfwPgYIE+PT2VdAFUK5WKzs7OzLF4dname/fumQGAawMQps+tNxtgFAHsV6tVhUIhi1zBeQozyWsLhYIef/xxdbtdvfjiixbKm0wmrQMDAJ+cN9jFcrlsMTwwa7dv31an07H2bjCyjz/+uOncOG+VSkWxWEyPPfaYhQNLst64tEULhULWwYLSOYAYMNNut9Vut7W2tqZsNmu5cphjOPd0j2Dz4Fv65XI5O5fn5+cWCp1MJo3h9BrWhz3YDHHMuVxO733vey3KZ3193a7bY489pmAwqN3dXeVyOdv8UI7G8cq/mUMo7680davxKI1HBth9sYOMq9X48o9lts7n2AHyABjLZdpl4MfrfXmE94c58uCIxVi6BHUeCALmAG4svpgj0LphtIClgL0CMMFo0TQdNyRAEJcrAMMDI3R53qBBeZPwYPLacG7C8MFqUpYEUFBOIrbER7sQW8L5HwwG5qYkiBWwG41GrXG9JGN40CPhlJVk2kJKiJTF0Oaha+v3+9bNwDNQuHzpHYomK5VKKZlMmtuS+BIAdTab1eHhoarVqpLJpGXF+XI2IJjyON+Z80N5kyBeypwAQCQB6+vr2tzcVCaT0fHxsd3HMIMcG224cANjvtjd3bV+xPv7+4rH40qn06rX6+p0OlbiLJfLSqfTOj09tfcDOO3t7SmVSqnf71vHD+47TBhoPvl7ADpaxEAgoNPTU3U6HWt/1mg0bNMwGAxMmtBut42J8/2M0W1ifOl2u+p0OqbLm06nqlarD3EmWRyUkimVb29vq1gs6vbt2/YajDno6AKBgJ588km759h00Y2D54J7g7lipd1ejUdxPDLAbnNzU5JUqVSs3RD//zVf8zVfoaNajdcbLCT+/325AyDF61iQPcPH6zAMAFoAJ74FkRdz83s/SfNevvQLwwVQA2zCenHM/D0MACVN755F6ybJHLdk3AEwOL5Wq2V5WT4DDbYAIAPIIloFgAkQ9IL8cDhsoBaXKaU4n01Hth55bMuxKMPhUJ1OxxhMvks6nTYWDJAyGo3U6XQWOgxIMpB7dnZmZVX0doBsACqBzMsgOJVK6eTkRPP53DLvarWauU2ff/55YyZ9DuB0OrXAaEq/jUbDNGOVSsUiXuLxuMV8YBxIJBJ2TqULEBCJRBQKhVStVm0TkE6n1W63zUyDuQI9KcYb8vvOz89VqVTseLvdrnq9npWbi8WiBoOBjo6OTLcYCFx0D9nY2NBwOLTqBOcZNpnnhz6z3CPoKyml7+/vazKZ6ObNm5Iu2D5KupRbuUfIJ5zP52Y4wZndbDZ1//59A4Rc49Fo9CVtC1Yul+0aZ7NZlUol7e3taWtrS91uV+l02qJibt++beD19u3bNo9ks1nFYjGTRXhWG1OSD4VejdV41MYjA+xu3rypzc1N/eZv/qYBuU6no9/7vd/T933f931lD241XjMAa4Asn//ErtgDPO9+9e8B2PPOVi9ohpkBBHp3rXSpQfPAjFy0VqtlontKc3S4AHz4kGGOhZ8RRgsIosyK8YFj8x0HWDBh7/xrWVzIKqOkBDNIhAsuVsClJGMYASSJRMJKrMPhcMFZ7NPzyYpD7E85kWuEc1eSTk9Plc/nzURC+C+MHOVsQoth93q9npUbYUcBT5KMher3+5ZNB8DpdrvGwtXrdZXLZVWrVWOx0M+l02nrozsejw0EZjKZBRfoCy+8YHlvOGy73a6Gw6HC4bCi0aixT9y3vlTONcC0Q7RIMplUt9tdyFhEGyhJ3W5XR0dH9r4EBRPrsr6+rna7bTq7fD5v4C4ej6tWq2k0GimTydhnetcyPYDRe2JCAZTfvXtXh4eHeuyxx5RMJi2AeWNjw3SOsH7379+3ezGRSGh3d1ftdluVSkWNRsN68O7s7Fim3/Hx8cOdQK4YaONarZaKxaJu3LhhZelut2ttwcLhsHZ2drSxsbFwbySTSRWLRXt2KNkDoNlsrEDdajzq420F7Hq9nl5++WX7/7t37+qP/uiPlM/nde3aNf3gD/6gfuInfkKPP/64xZ1sb2+bc3Y13j4DFku6dJR5Bs5r76RL08Rynh3ACHOELy0SqwBQ4TV81jJbBzvFYgcIZEHkeHhv9GyAIG+sYPH0Lcso6TCIBAHMjkYjc8VGIhErvcJArq2tWRgswA+najQaVbfbNTB5dnamdrttLBzuXMBlvV63n0mych2lUlg6IkuWoyrm87l2d3c1GAysj26xWLQ+n2i+4vG4SqWSgbzxeKxcLmfntt/vq1qtGmBOpVLW6YB4ESIxyuWy4vG4lTppSwVoDQQCxmahAcPowWdzDzUaDRUKBetd2+v19Oqrr9oxANphXbl3uMdgaWHq+H2321UymbQyMP1UfSCv77Ha7/dVqVQsn5DrJWmhjVi9XrfjJ0AYZhLwns/nNZvNVK/XLbpjPp/r9PTUzBKU22eziw4jJycn1pbta77ma9TpdMw9OBwOdXBwYE7uarVqQcTT6VQbGxtaX1/X8fGx7ty5Y+3MwuGwnnjiCY1GIx0fHy/kGcIoP8yRTqcN4J6fn+s973mPisWiyuWygftSqaTt7W0Lc75165bNDWtra3ZvcS19zJJn5L3UYzVW41Edb6u4k//9v/+3PvjBD77m5x/60If0n//zf9Z8PtdHP/pR/dzP/ZxarZa+8Ru/UT/7sz+rJ5544k1/xsoS/aUf3mDg+6TyOw+2mFQJ9vWgS5KV7mjT5V2nvrMBpVeAGmVJSmMAD+JPYF7Q5nmXLL9HO+c7SdBCzJss2OWz6+e7EGLM+1NKxVnIOUDv1+12F8qSANFUKmWLN2yWb9kVj8etNDocDo2hA8RStsMVib6PUixxFgj4E4mE8vm8ZfIBAtGMsXjjGJ7P56YDzGaz1kWCgFtYQfRxxWJR9Xp9Ie+OzLlOp6OTkxMLSCaImPIyzFo6nVYsFjMgA/gHdPf7fWt7RcP6jY0Nc/EivIdlQ6vI90smkwqFQva6wWCgVqulQqGg9fV1tVotpVIp618LMxwMBi08uF6vW94ef0c0jnTJVHJfcO1hlyRZOXw+n1uZlWOjVAro5Bqk02n1+33du3fPSv38DRo8AF4gELB7ArAM6AkEAnrllVe0v79vmXt7e3vmHkZHRyjzwzZJRCIRiyvhez399NPGqAeDQW1sbOjatWvGeOfzed26dcvMSltbW9ZBgg0C2lTpMr6E53Z5c7kaj85Yre2X420F7L4cY3Xxv/TDOzVZ8HysCJOoz40DxKAxY8HHjMBiA9DgbyhzUgKTZKWxYDBouV39fl+SLLIhHA6by9CbJhDDExtBKCtxJZIMRKKpoyRG83ZfFuY4CRnGmendugALSbbIwuxEo1FVKhXLP4PlIUSXSA1J1sGBvwPU0ZN0fX3dnKtot8jvwzACowEwbLfbxkz6+JNMJqNqtWpGEcqu7XbbhPVEl8A8oSOk7Ef8BywZpT5Ywd3dXc3nF8G5lAbRmhGsTPkcjSPsF6VNHJ2An83NTe3t7en+/fsL7CQg2XdUoB8tOkVK45IMBA4GAwu/ZSPAeUJ/uLu7a8DdZ9XxDJDDB9jn3uP8wTpyTYnY4doCqgBB9+/ft0gUjoues+g2K5XKQvA2gd2Au0ajoT/6oz/SeDw2h+5sNtPJyYmVkSXZXPqwRz6fV7FYVL/fV7lcVrFY1M7Ojj2roVBI733vey0sORaL6datW7ahi8ViKpVKCxl3MKrME4A8nocVqHu0x2ptvxwrYLcaD3V4tg7Qwq4YVoVBqUSSLbIAQnbkCJ59H1JE97yeRQktHsHBgUDARPQs4DSBBzyw6BOaK8nYN38cLKYYG2AR6KVKCQe2kYWCvDLciwAZ78gFOMKKkJMHQ5VKpRa0aWixEP/TusmXDb35gygOuhEQxopOS7pobYUDmNJ0t9tVJpOxLguYE3x0TDKZtP6zrVbLyqyTyUSbm5v2eqIvOFd8HkaSw8NDSRdgmO4BlC8pG5ZKJfV6PR0dHSmRSJh2qtvtanNzU6+88opdA9hHrhUl40AgYBq6drtt9xPgdDabWY4b5Vr0jvSrnU6narVaJsyfTCYLOW7NZtNMHqVSyVhd7gnupfn8Ij+O88D149rAPhKgW6/XJV2Anmq1anElALr9/X0L4eVZwynMc1mpVOw55T5Bw8n9fP/+fcvt293dtY4dGFvY4KB3e5gDZrFUKlkUS6lUUrlctucjmUzq8ccfN5NEJBKxFmHoS+loQkYkm0DYT55RD+RWwO7RHqu1/XK8rTR2q/HoD3bAPjBXWmTx+L1n55bNEx5U+e4LlPNoNYVInHKdd9p63Qz6JXRr3llK2Yn386CODDRKkbwP7JkX1fM5AAIy6Fh8MG7w/b0GyJegiSKhPAgwCYVClgFH1AOZbrRA4/0AirPZTLVazRhNwBC9atHyAdboT4r5wTtMYRb5eS6XU61WM3CG67VUKtn1wRRBthpC9Xa7rUgkojt37qjdbiubzSoej+v09FSxWEztdluFQsEY0WKxqP39fQPC3rQwmUz04osvmr4SPSOlTcKBufaEE7MBoDyPhqxcLtt3nc1mZgxBC0ge2tnZ2UK0CVEmlM/L5bKVO3kWGo2GAXxJVub214+SazweNyC8v79vBpzPf/7zyuVy1jnh4ODAAAz6QzqbeMDWaDQs/xDTBUBckl599VW1Wi2dn59b2frZZ5+188l9JckCnR/m4JzhJt7a2tJ4PNbGxobS6bQFfj/22GPK5XJqNptKpVLa2dmx/EPYOu4zHMtsKpgPlkHdsoN/NVbjUR4rYLcaD20wOfqSB4BgOXDYgz+vu+PnlNn873zGFIG3kiyo1ztaYdni8bixH5QoWUyZ4BHR5/N5STJBNougJGPaKMnBckgy1orYBO+4w2ggydgxzBAs7pScYbcYODIp/9HLM5FIGEO0trZmpTuvP0yn09Yui++IEQKwQCkOHRw6JICcdBGs3Gw2zTBA1tn6+rru37+v6XRqMRe07FpbWzOAAKslXWouiVMBCJbLZQWDQd29e9cci/l83rRya2treumllyxyg/cNBoOWYwcTCcPFuSTbb3NzU0dHR2q329ZyC3az1+up3W5rc3NTqVRKtVrNwFc8Htf6+rpFpGSzWa2vr+v09NSYPKJoKHMXCgUr/QKsuE/RGlIa7fV6KhaLtlHwZg5czvV63QKJZ7OZ9vb2NJlMdHBwIElW3uUasGlg09FoNKxEz3cCvM/nF23Z6K1L+bnX66lSqVicijf68Mw+rBEKhbS9vW3P5vb2tjY2NrS2tqZbt24pk8mY3OHxxx9XNptVs9nUjRs3lMlklEgkLK/U3xveDOUNMd5Fz/Bmr9VYjUd9rIDdajy0sRxbsjyRLhsnJC0AP+nSQesH78kiA0DyfwdYopTnS8CwDWhzELyjbQLkoXnyjB+sDTlgsCi0fdra2rJF8+zsTPl8Xu122zRYlIMoceK2RewdDAatmf1wOFQ6nTaWxwvoW62Whd3ieEUMT5AtpdR4PG56O855u922ki7MHe22pEsROSXt+XxuDE+5XLaYEwBbpVKxUjILKOG0x8fHymQyymaz1ncVXRlBvkTEbG9vW1lxd3d3gflCmwlTg5GGNlt37txRrVZTIBDQ9va2gVjuGcTym5ubun//vprNpiKRiHK5nB0Pf7O7u6tEIqHj42Otr6+b1o3w4GAwaKwROkL+H90akgCy3e7fv79wn2O2yWQyqtfrisVixjRRJocN5RzA6hLITMmV6wyTCDvJ/QqzzfnOZDJ2T/X7fTUaDfV6PWMpfdeKl19+WYPBQMVi0bL5GNzPy63+vtCBNjKdTmt7e9vmha2tLQumzufzKhQKBsR3dnbs77/qq77KtIN0mfCmF553r+P1JdjVWI138lgBu9V4KOMqtysAAZblQa4zDwR979Or4lEot1JmlGQLIRM5OWLn5+fmNEUXBCMGWMQ5CuMBM+eDkz3DR2nQt6iSLqMrKM+iUfJaQM8i0O+11+vZsaZSKQOFnCMMDOgBeU+YKFySnCtiSLxeDi0cZUzcmZS3YSIJzSXstlQqLZyb09NT+z69Xs8YztPTU8uLm81mKhaLCofDC62ocMiGw2E1Gg1z3r700kva2toy1qrZbKrRaKhYLC64nrk29F596aWXrIx6/fp17e/vWzkSLWU2m1Umk9Hzzz9v5c50Oq3j42PFYjHlcjkzYcznc1WrVQtZjkajGgwGC0HKPicuHo+bdtKbZLLZrIUqA9IikYja7bby+bwFT2Ns4fO5LpTgj46ONJ/PjYWKRqNWhs/n83ZuMKHAyhKJw79xkwJwKN3DDMJuTSYT3b9/37SoqVRK9Xrdnmfy/thUvdUxm8309NNPm+M7lUqpVCopGAxqZ2fHrsH5+bn1eKWDB/pK9IOAWrSZzDU+W5IKwFWgbqWtW4132liZJ1bjoYzlrDp+hpZl2RHL7/1/w8j4SZlFldfBKKVSKfV6PUmX3SB4PTv24XBo5gs6QNAiCIAGWCBChHIm7AU6Jcq9vjm8z4Xjd+PxeAFE8r35HWWw09NT+ywWZkp7kqxtWa1W03Q6tZBcvh/fg04TgGeAGSVbytnD4dDKpJxDgDIlQAAzTBCAGp0dYn5E/y+99JKxLLhqeT3dFDqdjvUgbbfb6vf7ZoIIh8PW1aHRaKjRaJhmDtBK6Vu66OeKGziTySifzxvY8CX44XCoa9euqd/v6/Dw0Mqls9nMzCh0o8AgQnRIoVCwcjMgHQ0abK/XhwKwisWiOVS5/4gwgXH0bCmMb6lUMhfxeDw2RyoaMpg+novlrhYYM7i/JVm7MSQCkuye9t01iJC5c+eOOXABoQy6bLxVQMd7E7L8F//iX1S/39fx8bHK5bKy2ayi0aj29vasDB4IBLS1tWW5iJubm/Y6Nj/EtXS7XWP+2LAwHzF/PKjf6wrYvTPGam2/HCvGbjXe8qBs6UuvvoUWAIEF76rBhOwnZgT98/ncwJd0WQ7i9fzDwk5ZFJAJYPQsH78D+KDDIdYDB543a7DYo9eRLnP4ADWeAWKxJC4ENuHk5ET5fN7ADa/1/Wqr1aqxfmj0fN9K39dSkjE9lHvJmFtbW7NSL0AO9pGSNJlslLJ5HeYHStL0ET0/P9ezzz6rQqFgPWBpGD+fz02D53PUiCAplUqmZ6NsuL+/byVSmESuWywWM9NCq9WyrgIEGCcSCdOzUaaPxWKq1WoWq8IiL12UnNFodbtdc5AGAgFlMhn7W+4PyrW4V9GaUaKEWYLNZFPitZZsANgoNJtNxeNxYxopV+PcTCQS5jCORCLm6oRJhR1GO8c1Q3JAnM/JyYn1iD07OzMdJWxcq9VStVpdkEbAenEsGFLe6lhbW1M4HNb29rZu3bqlRqOharVqGrpoNKrNzU1jsnO5nHK5nDmLo9GoaSzRggJ2R6ORyuXya2JMeC3zwlVjZZpYjXfiWAG71XjL4yrH61WOs9ebQJd1djBLTM6eGaPE6B2ry63EJJkwHgBEiRbQx2txsoZCIdMr8Tn+/fm5ZwN8iY0MNhYYFnaiTQCJxDQgkke7N5vNLJh3NBopmUxajl4ymbTS2mQyMVaLeA40T2Sd8f+1Wk35fF6xWMz0cZSXKSkXi0VjC3lvQJdnRQuFgu7evat+v6+9vT27VjhvAb+SzNyBTo/4kLOzM+3t7enk5MQyyDg3aBJhzACdaAWJKyEPji4WMGMwsIDSVCplLC4ggJZksKecD8qiaMu8aYHAYX//ovuCMfQxNriCcdByn9LWrFgsqtVq6fnnn7d7kOvp8/8SiYRFrEha0FAeHBzYJgOwybNWq9Ws/E5XERi6QOCie0ej0VCz2bR7Co2apAVN3Rc7YJUJig4Gg9re3laxWLQuHU888YQ2NjasLE3HlWKxaMz29evX7d5BfpDNZm3DRwSP/z33rn9OHzRWponVeCeOFbBbjbc8lp2rr/ea1/sdrJ7X5vFzGDVKQuRZIWwHqHmQCVPHIr5s7JAuQ2BhPFgkJJmLNBaLGeuGKJ+sNjRKXqeGqJuF1Ee2UFb0pVs6Q9ASbD6/aLrearW0ublp5wRgxGIGmwSDCDgFaEwmE924cUOBQEC1Ws3aTgHo0CYhruf7AC7oQgE4evHFFxWPx1UoFOxv+v2+er2elVdhU2iNViwWDYxSNuv1etre3tbBwYGCwaBpC6ULA0alUrHSLuAVZnA8HuvGjRsGonEF0/ZM0oJDkg0DejdMH5SbiRehdJnP53VycqJWq6VsNmv3JyVvWsitra0ZY5jJZNRoNJTJZFQqlTSbzawhfSgUsjw+OqSgNwS406sXgA4Q4jNhsGljxvVPpVLKZrMLOtJOp6Pr16/bhiafzxtbSE9kri+GGMAhGkM+l/O5bHhivF44MdFA5XJZiUTCOlrcv39f6+vrxkJzbLDEBDBHo1Fdv37dchsBp/l83vrihkIh5XI569TCBlC6bG/2emXWd5kKaTXeRWMF7FbjoQ5vnvDDu2L9z2BS/MTsX7fskkXsT+QJC5EPN4atQpROSQlWTLpsr0UZDBBAOdT3BUW/5ZlEWENYt8FgoHq9rlKpZNl69JYFNCYSCSu/ElEBaCV3rdfrGeDzTeRhnQB+MFq+ZRmLKQ5f4kxgg3DTwn7RjkuSCekBHYj/6UnbaDSM6UOrx3EDenHZUqKkrE03h6OjI2UyGYvuAFy0Wi1Fo1GNRiO9+uqrpruDYfXmCWJLKEcCVAC/vmcvZTjKdYPBwFzN6PdqtZpyuZyy2awikYiOj48XmLD5fG66RUwjnhGl1E2mHCVMTBxsPNAF4gbmu9G6DVCcz+ctAxDgvrW1pU6no16vZ88MfWJ5Zii1JhIJ26AAfrhfWq2WXn31VdMnenc1ZgqAq6QFtjOVSlnfYcZVoA4AmUqllMlkLIwaFpBy9/n5uXZ2dizvkX/K5bJ2d3ft/B0dHSmfzyuTyVgbNQ/yPBvOfUyMEOfn9YDdiq1bjXfiWAG71XjLA2CE/sd3l5AuI03QHjE8IyDJQA5sl99te9YgGo2q1+tZmyU0YAAagJ9n57yWTdJrok68Bo4FfG1tzRZQHJ8MNITou9CpSbIuERwfnQwoIQIA0LhJWtAQBgIBi/2g1MnPWXiJSfF5eJSnEdQDEBuNhqbTqeLxuMWpkE2HmSAcDlv3B0Ab4KvX65mOCSYMYJrP5/Xqq6+qWq0aYwrIDgQC2tjYUKfTUb/ftz6yaAHpuTqdTnVycrLQ3QHmk9I5Ac+4RSlvenE8DOJ0OlU+n1ej0dBsNrOQaPq1Eiczm820u7tr5WdiRGA2O53OQr6fd1Y2m03rrEEZNplMKplM2ncibJl7EFMNDlbpImCacr6/f3lWCoWCdYvA6AEIHg6H1j2DbEKOp1armc7y8PBQZ2dnqtfrCgaDOj09NWDUarWM5ep2u+ZOpjMHesdlUHfV4Lvevn1bh4eHlgGIKYX7LRqN6oknnrDNy+7uriSpUCgYgAMIF4tFFYtFc+oSoI3ukGvP/eHnCW/UWh5e+rEaq/FOGytgtxpveTCZvp5ImYWUsTyxohGiRRasC5O0L0f6/qDeQCDJFkRYKhiWQCBgPS4RvPOZ5MCRfyfJGCv+GyaNlkos9LBW0qWmjrIS32UZnFDmBFSirSKSg3ZiAAkf4YL5oVKpKJPJGAtEOZaSZywWU71et5IrgKlarSoej1uf0UKhoH6/r4ODAwOd4/FYlUplIZrj9u3bOjo6Ui6XMxao2Wzq4ODAHL2wdIVCwc4j5Ur0azCMRKBIMkE/7mUMDaPRyJhWtGOcL6415wU3Z6FQ0Hw+Xyjn0kGkVCqpXq+bSWZzc9NAL0A9l8tZfhxM0LVr11SpVEzrNx6PtbOzo/X1dR0eHiqdTqtYLCoajVqZ8/DwUNvb26ab5DtgLGm32waCcfBxf7AhGA6Hajabthm5du2ams2mOWp55gAwPnB5Pr/IIaQN2cHBgYG0aDSqeDxuABfG9MaNG1ZGxgT0esMblbLZrPL5vEajker1ugG0VCpl7HEoFNLW1pZ1g9ja2tKTTz5prC8lVUna2dnRdDrV1taWzQN8jmeoPbBfno/eiI1bAbvVeKeOFbBbjYc2WGSv2g37cskyE0fJjswpBgsw700Zip/jEuW9WJx91wjPqLAIskiMx2Mrm41GIyud4lCl3AoLyd8iVkcPBCOJfg5RN6CUBRx9GaYMSrKnp6cKh8PK5XIWOAtohd0KBoPmGD07O1OxWLQ8Ou8KZqGrVCoGVAKBgLWygg3FoXx6emqlScAmxgcy02C5bt++beet3W7r3r17dv4xCeC+BdDQ4YD/h10k1JfrSteO3d1dnZ6emkYtHA6r2WyaU5m4EAAaDE4gENDm5qZl+I3HYyvr7+zsWEBvt9s1of7JyYlpFtEY3r1710A8jNPp6akxbul0eqEtGhoy9H+1Wk2SjGUiUgTA75lZNgbo/QDHgC2MNpTwq9XqQjmdYwwGgxYVM51O9cILL6hUKmk8HqtararZbBq4517geCORiB577DGNRiNVq1WLdnmjAWtWrVaVz+dtw7G+vq5kMmnPGPcgLfBox5bJZOy5i8ViCwHJ29vbBvRxpOP29XmQy88Z95OfE64aq3iT1XinjxWwW42HNq4SWwPU+NnypOodi/5v+DvviAXQEUrK64h8YDGJRCLGOMRiMY1GowXjBYwf5bPJZKJut2txCnyuN3FQ4vROVwBEOBy2qBAYJ9+RgWNj0fQuXIThLI7ElvguGUSNnJ+fmxB9PB4vgEpvmIDN8J8Lw8j5hcmJxWI6OTlRMBjUYDCwY6OLhu/vSpeFXq+n4+Nj00fBLiWTSdXrdWPZEomEOp2Ond/HHnvM9HFE2fC+kUhE165ds5y6XC5nrb7QVMHqNBoNRSIRHR4eamdnx8wHp6enarfbZkhIp9N66qmnNJlM1Gq1dP/+fSu3t9ttA/60JkOrhhsVEwjMX6lUes19tLa2ZrpJGNJUKmXAkXvV594BoHHpojnEVQwzSOeR09NTDQYDew+6gdByjY0ILd42NjYsyoRIEfIVW62WdZSIxWJKp9M6Ojp6jdRgeVDCl6THHntM9Xpds9lM6XRajUbD3KuYOTqdjp588kkzRsRiMe3t7Vn8CsBwfX3d+tYGAgFzxBL1woYqlUotSB8AeGwi/YbyjVywK6ZuNd7pYwXsVuMtj6tMESwSgDjKKf51MBa+bOJ34YAnWA7yuXy8BGAPFg3Wgs/2ZRncfrA2fB5uUI6JjDfKwWj6pMtSMWAKho8cN0AOpV3PEsJaAgwxYZRKJWNxiFsBcPF9MSBIsjw9gAUgIRwOm1kC5gdACGOIXgsmk5ZTlKwHg4E2NzdVLpd1cnJiPzs/P1e1WrXuB3t7ezo9PbWFO5VKLYQBS1K9XjeRfD6f1+c+9zljsjqdjpUnC4WC9d6FySNDDwCAo5PFG8NEKpVSv9/XvXv3rFfqU089ZdczEAjo+PhYR0dHSqfTC/o/NhK1Wk21Wk2FQkEbGxumfYTRJYYDEwzgF53XdDo1zSdlxrt37yqXy9nfYXSBKYvH48rlctYtIhQKmQYOLRpMIRufeDxuurvz83OLUKH8C3MI6Or3+1Zuzmaz6vV6euKJJ3R+fq5er2dZdsPh8IHPNvf3+fm59vb2NJ1OdefOHZXLZQtQfuqpp8yoM5tddP/AGDEajXT79m1Fo1FtbW2ZNCCVSimdTtvzRdmacw47ixGDsi/3OsObi94I1PG8r9i61Xinj1XnidV4y2O5XRiTK6UYr5WDUeO1lGF5HSVUD4SILSFrC50TjBuZcDBkiUTC2lxJUq/Xs0wtFh/Cin15FRMIWig0TwTvhkIhK6dSCoM9oGTkw5UpL6N7I+6k2+0agwarhVifjC7KZ+fn58aa0YJMkonSAbHc07AjkkyLxTVBNwcbCLOCPo+ODel02owEgUDAAoIpUabTafV6PQv4BSjj4qS0GI/HDdBxPimh4mZOJpOWZ3dycmKGCZ9d1+l0jHkdDAZmQsnn8zo8PLQuG9euXZMkbW5uGjA7OTlRrVYzoLCxsWE6NdhCumQQiQJ44L4mR63T6VjpkHN2enpq4AewCtgmzoQ+w7CbbEoA5rBubBZ8Wz2cv2QMAtgPDw8N3GHWqVQqFp/T6/WMFSX+BODfarWMsX3QCIVC1gsXtqzVaqnf72tra8vkAbDciURChULB2PFAIKB0Oq2bN29aeTaRSGht7SKwO5vNqlQqmevcP188O+l0WqlUaiF4HFbem5DYjL0RqFuVYN/ZY7W2X44VY7cab2n4nTLgzhsoPCPnu1AA2mDxWEh9LAptvHwOnHSppUH7dnZ2Zouz13IBECjZAC55H5+ZJckWbfq1snAA1jA5sJCx8OPgHY/H1uaq1+tZ7AksJAsxbNLa2ppFjnB8MBYsQIBTROlkuwFAYMgAKphCiNnABSldlNNgPQAGaMuCwaCefPJJjcdj3blzx4AnfU9p6dTtdq3fKGAL9gZ3Zy6Xs+/0e7/3e3b8MJqAN0pt+/v7BkgIUs5ms+r3+xYDU61WFYvFVK1Wtbu7q06noz/90z9VOp3WjRs3rDSJM3I4HOro6EjNZtPMFrTpajab5uxlc+DZVAB5Op22OBMY1ng8btq+ZrOpdDptXSKKxaKBxXQ6bWYdWGfKh4QyA4abzaYCgYC9P/ly3DM+vqNerxvoxySCaQVnLG7Wzc1NhcNhVSoVew7JMHy9gdYTp3G9Xtd0OlWpVLJSajAYNDPRjRs3NBqNzERULBaVSqVULBYNGNM5gogXSZaxJ11sVACvnBvAm9/k8VwvSzveDFO3GqvxbhkrYLcaX/QAgF2lreP/lxcm/3NJBk480GOR8mAQpymZcXRm8PEaLMxop/idNxn4QFQPLNEpYWqgHEwZk4UU1yd6LDoQsMj7Mimgd319Xc1mU+FwWJlMxkp9fD4OVtqYAQzi8bhpo9rttrl5AUgsfIA4HJGAWXrNFotFM0N0u11z6haLRQMdiUTC9GSSLB/Ot6Q6OTkx8DifX7Z5Oz4+thZQ5PmFQiEdHByYKQKgAFjZ29vT3bt3DTjncjkrK/peoJVKxcDSdDq1kN5wOKzHH3/cIlLInYtGoxYwTKkQ0NDpdMzli4sWcBmNRq2nLfmB5Pl5HSV9c7ne3C8wrTB/tVrNnKq4dSkvsyk4PDy0+3J9fV2FQsHKlz72hOw2gFMul1O1WtXR0ZGSyaTW19etxH52dmZZiv1+Xy+99JIBMFzIkix7EMaXQZn0/Pyi7zDhyo8//riGw6Hl3UnSk08+afdwMBhULpdTKpXS7u6usbuDwUDlclnxeFylUsmMHtvb25JknUZgQGHCvdaVeQJ9KwMJxhu5d5l7VmzdarxbxgrYrcYXNXx5dVnz4ida71rzv4edg1UCnMEewZJ5pk2SsWOTycQ0U8vuV0pBiNwxMnQ6HVvkx+OxBRh7JpFWRH5B4fsgFvexKJKsrMhx8R1YqAhBLhQKVsKELUokEuZYJeKDBb7f7+vs7EyVSsW0abgDcf+enZ2Z+cBnxLHoUSprt9tWiqYv69nZmZrNpra2tqx0xzGjyaPkXa/XlUwmrctCOBxWq9XS9va2ksmk9vf31e12baFHu4cGLhQKGUgkrJjOHIB1SnGJREL7+/sGGChVwswkk0ndvHlTg8FAhUJBkiwAen9/3wwU5+fnxroBeGmzBcCCPWy1WgbKANGU7XFm04nEZwz6HMVisah6va52u20mAjSLjUbD7r1Wq2UGEEAsIB0pAoYPX4JEh3j37l1Np1Ndu3ZNo9HI+tROJhMruzYaDfV6PcuE41mgVE9pmBGJRKx0+uKLL5rEIJ/PG4Afj8cWJ3Pz5k2NRiNj5aQLBi6fzxuD2Ov19J73vEfb29tWYp5Op9rd3VU4HDYDFM+OJCvFZrNZK6dzfMwdMOkPila6aq5aGSZW4900VsBuNb6o4curfsCYAWz8/zMRU14jukS67Dnqe7n60qkPvyUmhPBZGA8WRIwMvoxDQHE0GjXNniTrSyrJ2Bd0dSw4LOCwdz5gl/ZilJGITaFER0k3nU4buMI9SmcHNFXEblCC7vf7qtVq2tjYsDZl3W7XXL/SRU9Wzp90wbRFIhHrqkGJm9cB9JrNpobDoTY2NqxszHXa39+37grValW9Xk9bW1vW3onz9vjjj6vVaumzn/2sld7u3r2ryWSiTCaj0WikXq9n5ojpdKpyuay7d+8aYEQPGA6HVSwWdXJyort372pjY8PCd7vdrrLZrGkj9/b2NJlMlM1mjTmVpLt37xrTRFmSOJtOp6PZbGbXBOclwCyXy5n+MZ1OG3tXq9UspJgyIoxpLpczQAhzSezLYDAwnR3MIS2/0KER58JGJ51O6/79+9Zajk1FoVBQs9lUo9GwTQo9b3u9nj1Xm5ubZliRLjIE/UCq0O12zbgSDodVKBQ0mUy0t7en559/XqPRSDs7OwoGg2o2m8amZjIZlctlY7ATiYSSyaSxdePx2FjbWCymGzdu6Mknn7R7fTgcWskcYwkbKkAtOkJMQDB5PP9+7rnKZf96c9VqrMa7ZTxy5onz83N97GMf0y/8wi/o5ORE29vb+u7v/m79i3/xL97UrmwlsHzrw5sOlp1oACHYOB+xgfaJidoPACD/7bPpWOD4e8TW/C6RSLwmzBfWDB0YoIy+rhgXYAl5DGD7YP6ki9ZJu7u7tkB7LRd6K0AE4JPvF4vF7Hf09PSBuIDEZDJp59S7LJPJpMrlsrF+HHuv11vojkGEB4CGOBdYOpghcupwsnrTC4YKmJXnn3/eSoR0I4AdLRaLeu6551Sv17W9va14PK67d+8uuJnPzs60sbFh14E+qYAbIlVgLlutlrGGlKu5TvP5XNeuXbPSs+/pS3QJpWgc1MgAKG9HIhHrh5pKpUy471vEpdNpdbtdNRoNC1VGF8g9TMwLwGM8HmswGBhL12g07Hz6kr4k01nSbQF27+zsTM8//7yV5kejkTY3N618jLTAmzHomVoqlSzUmdgWSqyYZWjFRxxLKpXSYDBQKpWy18KCFQoFc9YS8cJ70OJtc3PTNhtsgDKZjEW05PN5bW1tGRim20U4HNbe3p5dO8AgZhkAZyKRsD65XH+OkbnB37uvN1etQN27Y6zW9svxyDF2P/mTP6n/8B/+gz75yU/qve99r37/939f3/M936NMJqPv//7v/0of3jt+LOvpPKjznSc8wKN0gtvQOw4xP/C+lGXRqOEoRUO33GYLnRNMXzwe18HBgZLJpC1mZJ8lk0lbQPhcNGOAJIKAcTd6UwjlPkqMaKCky7w9GIZOp6NyuWzHCrgEdLLgdjodyxWjHyiLG5olMs6It2g0GopGo1Y6xBwB6wZYhNUrFArqdDqq1+u2CKdSKdP0eVdhtVrVfD63iAxiYmCU0um0nn/+eb344otKJBK6fv26ZrOZXn75ZQMk7XbbeoXS8eHk5MRy5rhPfF9Zok1okyVdguzNzU1jaHx/UjR5gI1+v2/Mj48k6XQ6FqosyXqMSrJrzUbk6OhI+/v7xhDCcgUCAYu6odcpG4D5fK5isajDw0P1+31z1wIKMckQtHv9+nWNRiPTML788ssW5ZLP5w1IPf/880qn08rlcprNZpY3h55wfX1de3t7Oju76HnbbDaNweY7Ec/C+ULvRmeUWq1m5WhMG7VazTRx0oVDlk1BJpPRrVu37Jlh4wLTTSk9n8/r7OxM29vbpi9NJpMqFov2XNJSDOae8+znB9/dwlcB3qyublWCXY1343jkgN3v/M7v6Fu/9Vv1N/7G35Ak3bhxQ//tv/03ffazn/0KH9m7Y/gyyDJTB6hjIqYzBIwFOiGfM+eZDN9pAqDk8+/4XP7fp89LWki/Rz9H5wgy6TBmwLAAACQZKGLhxOkai8UMTPl+rByL74BAwC7Mxdramur1umW7AWrm84s2ZZReO52OOU1h3TxYrNVqprnL5XJWaiVLbjKZqNlsWo/U+XxuTB7Btb5sRr9RSaYrOzg4MBCCMSWbzSoUCmljY0P37t3T5z73OaXTaW1sbBgwIK4FA8jOzo65FzE7jEYj01kR27KxsaFsNmv3TL1eNxaMEu3e3p56vZ6VKQFRjUbDSn7eqEIcDB03Pv/5z5szk64Y/r4tlUqqVqu2gTg6OrJ4D0rrAJ7z83Mlk0kD314veufOHXt/6VJuAMCmxyudNLiHDw4OTCuIXrTValleHSXtP/zDP5R0Md9x/wJ079+/b3FB3E8EdKfTabufMpmMde2g1BmPx+37oqkESGNi4FzcuHHDer7SJs2XsnO5nCSZSYh+udls1tzEZAGyYVjOFPRB42x+vGbVVwve7Fy1GqvxbhuPHLD7+q//ev3cz/2cXnzxRT3xxBN69tln9ZnPfEY/9VM/deXr2RkySE9fjS98+LKGnzSXe8RSFmUSBrxRImRx9UJoQJ1P6PeuVaJLcA2isZNk+iWy7sjxomzpg4R9s3COh2NisfP5dbhL6VNJOatYLKpWqymZTNpxj0YjNRoNY+Bgvijbkf/GYsgCBmAYDAZWyqVBe6fTsWgOyq4wHuS3UV7E2YphoFar6fDwUIlEQjs7O7YgehYUYwRxHS+88IK2trYsGBht3uc//3nLROv3++p0Oqbhgl3Z2NiwsnG73dbW1paVNM/Pz3V6emqA4+bNm2Ym4fPpqFCr1RQIBLS1tWV6t+eee07JZFLxeNw6OsTjcQOgJycnBtZDoZBqtZqBRNpuwVIBHEOhkI6Pj02rVa1WzVCBc5gep4T0wrZyv00mEzNbtNttxeNxC1lmEwBDJslc2aenp1ZqLBQKZjzhmgaDQQPFzz//vB577DHTKsJA3rt3z9zNksyJi+aToOBer6fT01OVSiV1u10zRkSjUW1sbNg5QmYQCAQMVM5mM3U6HT322GMqFovWPQUWdz6/aNnGc5BMJpXP500WUC6Xjd2GtcdRjeyALESewWWmnPnkqnnozcxVq7Ea77bxyAG7H/7hH1an09FTTz1lE8EnPvEJfed3fueVr/9X/+pf6eMf//iX+SjfmWNZV+czpDyDx3+jcfJMG8yen7C9VmY54w7QBzj0XSZw/JFDB1OIvglhvWfu/OKOtgog2e/3LTeu0+mYmB6Wj++AEYLFB20dTA7MB5/F9+HzMHZQAoNhAfARj4J+EEMAcRF8F8qw8Xjc3Ly7u7uaz+e6f/++Wq2WnnjiCWWzWWMEyVfjnBwfH1tP1JOTE924ccOOK5FIGHCBQSPyBEDpuwbABmG2gEUEGKNNLBQK1iMXx2a5XFa73dZ4PFaxWNTt27fVbrf1J3/yJxbhMZlM7DOfeOIJ1et1MyR4M0W/3zctJ0ANAwulZ64XztxOp2PnhlgN/llmiekOgsYNneB8ftFRIxKJqFAoWCAz3TeSyaQFJhMA7O93QM729rbG47G1X/v6r/9600miTZxMJuZIlqRKpWL3daFQsBDhw8NDxeNx3bx50zSiSAlKpZLdn5gzKMFS+vfaQUq5mGsymYxtDE5OTkzryrnI5XKaTqc6Ojoyljsej6tYLNqGBVc4UUawepyPZeOEN2wtbzSX3fersRrv1vHIAbv//t//u37xF39R//W//le9973v1R/90R/pB3/wB7W9va0PfehDr3n9Rz7yEX34wx+2/6cd0mp84cNrWzy4Wy6NsHig5/JlVgwJlEDJsUNXBzDzYcUMJngWZxg6SdahgcBXmDsAHK2MWORhjhCl044KJtI7Y2HfJFkpGdYDRs5/Z68TYsDwoEfy3TrQ+QEwEP8TZcJ38SXtwWBgIIJzQDkUndXNmzetNVkymdTW1pYBjcFgoKOjIytfrq+vK5PJWESKdNGj9OTkRNPpVLlcTq+88op2d3eVTCZ17949pdNpY6Tu3r2rTqej7e1tRaNRHR8fa3193RZ++r9iRPB6RwBtPp/XYDDQzs6O/uRP/sQWfownGCmKxaL29/eNveL6E5I7mUxULBaNDV1bWzMDQjqdViKRsIw27jdKfWwWYWiRBuC0RRcKMAEAAepxLgNYd3Z2rJT4yiuvGHCRZNlysH07OzsqFAqqVCo6PT21vD2eNwAr9+vm5qbpK9vttjY2Nmwz4F25qVTK7r9KpaKtrS3dvHlTs9lMjUbDAoiffvppA6Q4xIvFouUiFotFDYdDa4VGZwgYbMAUZWeMJpLM3bu2tmYldK49zyFyhdls9poWf96Fz7O2bM5agbnVWI2L8ci5Yvf29vTDP/zD+qf/9J/az37iJ35Cv/ALv6Dnn3/+Df9+5Zx568ObIqTL3bJn5Bh+Jw3j4QX+uC19lAGLKe/nXa44AmHyiE2hZRWgC30QGW5oj1h4CZjFnMD3SiaTFl3inXsYA1hgarWaMpmMIpGIsWGAS7LiAGp0pMDZShmQzDvKwZlMxtqV0RUjmUzaa8jte/nllw0g5fN5c8gCNGA7CbKNxWJKJpOaz+c6Pj7WZDLR3bt3lc1mlUqlLCQWI0I4HLZojTt37lhUzFNPPaVoNKo//dM/1d7eniqVin2PaDRq5WRy6xqNhgEqgGm5XDa2DnAMY0dpE1AEMCREmHuCz4PpAQCNx2MzJMTjcVWrVQPiBBlHIhFz37JBYMNxfn5u4by04CI7Dp0dZeBYLGYGAiJPcPFSCifXrtlsanNz0wJ+MY1QImYTwHcAhME6E67MZiYajerOnTsKhUJ2nMTWkEfny8ew0WQgZrNZ636BrtPrHSXZ8xQIBAzw0991NBqZsQIAGI/HrXMJvX2985Y5I5fLmVvY62R5Jvw84asCPJ/eNPFm2oitxrtnrNb2y/HIMXb0vvTD79xW40s/fDnEAzx20T4/DpBBtAdAjQmdBQig5nV7fjH3wJEFn5IUr6cUywLBf+O8o8Tp+5myGBOU6llC9Hw4DAmn5RjQH83ncyWTSTUaDQNg7XZbx8fHKpfLymazluUFm1GtVk0nh/OREisMRjKZtNIibbtOTk6UyWSUSqUkSUdHRwsidK5PPB5f0C2dnZ3p4OBAZ2dnOj091ebmprLZrIbDoUV8ABIwc6Chy+VyymQyqlar1roNYwElwbOzM927d8/y/tC2wgAhtkfnBRuZTqet7RkuWL4/9xD3mM8bbLfb1rqM+4KYGEqeuGJxsbZaLQOYPqCaz+r3+xYHs7W1pY2NDQOpp6en9ppcLqdgMGgbAnrJYuzAfEIJOxKJ6OTk5DVld0KNK5WKMpmMut2u6QIlWasx2CiOjT7IaEVxQ6dSKZMC1Go1tVot+xmyh+FwaBEphHqjU2Ru5f4hDxEw6EOnO52OAoGAbty4odlsZtcinU4vtOhjU0AnFX89eebQ+/EML3eqYa7hefZM92qsxmq8djxywO5v/a2/pU984hO6du2a3vve9+oP//AP9VM/9VP6h//wH36lD+1dNZZT4NF4wbh51o4JGFDnmTuvX2KBpjzmS73LHSKky3gPhO4wFAAidEwwJbAXlI8wVgSDwQXzgiRjjFj82+22uV9hCSVZaZSw3+l0qlarZSAwGAwaGCIzjWNBA+Z/HggEjKXzHRlwgaZSKROnE0bsGUJJJkqnPAmLRnmsWCzaZ2azWR0fH5vuj44NnU7Hugx0Oh1Vq1Xl83nrF3v37l1zvlLSBARgiEilUnY/JBIJ3b59W51OR/fu3VMwGDRm6fj42Fgh2BtKiYASctX6/b7S6bS2t7ctd6/dblu5fTabqdlsant7e8Eggjat1WpZuTIej9t5ZUynU924ccPYpuFwqHv37mljY0OSDICjCfN9e4nKyWaz1vqtXq9LkskSaJGWyWT0+OOP65VXXjE3rI+BgXmmJFmtVq0vLGaEcDisW7du2fNHK7RWq6Vut2v3JpsTcvqSyaSSyaQ2Njb06quvGlsZj8dNW0m5FVYQIwjRMuvr68beEV4Na8l7ARABfdwjXGdf/ub5x3TFfOF/tyq3rsZqvLnxyJViu92ufvRHf1T/43/8D52enmp7e1v/4B/8A/3Yj/3YQoucB40VXfvwBpovgBrDAzAf0Mok7uNOlhk2XKleQzObzYzlgEUjQw6Wj/ZJkmzhRGtGXhwRCsRzhMNhMydQokXgT3ArC9B4PLYSHn9Lj07E8mtrazo4ONBsNjPXLqVRhOEA0dFopGw2awAOxgRTBYwXgCEYDC4wPix4tMkClFE2BsxMJhNtbm4aQOO80VqL0u/6+roODg5MFN9sNs1s4ktvtOuSLrRUTB+lUsnMGHQr2NjYsN6i6+vrxsrB3gHM/Lnf3Nw0dygZc/V63UrYyWRShUJB/X7fnLDcZ2w2tra2DNi3221Fo1HVajVr20WfWDYjHtTncjkDqtxfiURCnU7H3K98FoB/MBhoY2PDuiagWwR4UyJ9+eWXVSqVlM1mlclkdHh4uHD9yZ87OTkxEwL6PdzJm5ubBkzJVIQNQ8sIm0kJ+vz8okXXaDQylyqyAJ6JUCikSCSiUqm0EO5McHQmk7GYGZhXNJC4dSnrS5dxMzCN5EqyGZBkcwZzAqDNa1p9NQA2kTlmBfJWw4/V2n45Hjlg91bH6uI/nOFL3z5Ljt9xWwFMYNQwJgDYYD4AfkSX+H+zk5dkPVQBF8Fg0DLdMBWQm1WtVpXJZGyhPTs7s1BVNHOAE8qgaJhYbGh7NJlMdP/+fRP+J5NJi+WAnfFGiMlkYmXeZDKpXC5nC/bZ2ZkdF4waQnLeazKZWEwPTt3lpvbkocG+wZKhXaMEBvBttVqKxWLW2B2HbjqdVrVaVaPRMEBM2ZFrmE6njcUjcDYWi5mrMZVKWXkZfRmLOiL9tbU1xWIx62zAcTWbTRWLRTM2vPDCC3YthsOh8vm8isWiNZavVCqmP2w0GhaIOx6PF0rk5PTBlsHQwSwT5wFYRpvpjTZra2va399Xq9XS5ubmAtNJdIg3REgy9pVzdHp6ql6vp1KpZAzi2dmZxYfcv39fjz32mDlIYYmfffZZSbJgaLL8MpmM9vb2LA+QKCDK7oCnVqtlhhPy57a3t3V+fq79/X3NZjNtb28b61ssFo3V5Xh57miNlk6nlc1mlc/nLXZoZ2dH6XTaWG7ALfc0Gycie7zb2LvqrzJJSJcSDx+xtAJ2q7E8Vmv75XjkSrGr8ZUdvnTKWI4r8b+HlQPQ+fegPAOLAghAUA8zhphckrF9sFK+zdba2poZDGAWAoGAOSqn06lisZgtxDADnvnq9/vmRCVeAvcrCfw0cqfbAQJ/mMZOp2MLGS2gGo2GMY+7u7uaTCa6d++eYrGYMpmMidDpQADjSZ9OWDXPLqJhokUYYa6ARsqT5+fnqlarFtFBpwfACK7Tzc1NnZycGKCjDArriegeNywCfN+mjJIwn40xhpDgXC6nSqVin5lIJLS3t2dlVgJ7z87OLBYFoNHr9cxckUwmLQgXJigWi+m5554zBhXQQxgu5XE0XZKM5fTlWYB9u93WycmJgsGguVsxCoxGI+vsAViLRCLGJgM69vf3ra+sv6dh0ABQ3W7X/iGuBqDV7XaVy+Ws68Tjjz+u4+NjiwShqwMgfTKZmOP58ccft6w5DDm4vROJhOno+Det13K5nOnlKNMTB7O9vW3OY5jj8XhsxiNMGoR4o+MbDofWKox72WsIeRa9fm45Umk1VmM13nisgN1qvOnhs6QAZixgTMg+rJgyK8YJnyrPhO2ZI0qviOj9a1mUWKR9JArlRSIUJJl7FvbA65Ao+cLGtVotCzAeDoeWmdZqtazUC2hDOO4F+4BEyknkeVFyJJQYMLG/v289OePxuGnMJpOJRUGgJQMUk8vm9WcwYZK0u7tr7BWREnzP0WhkoIBS9Pr6unq9npVwg8Gg7ty5Y4wgIHcwGFg/1FKppFgspl6vZ6VMypa4bgE/gE6OFwMFpUXporVXPp9XpVKxsjGLOBlv6DDpPYtGkAxDrnev17N8uFQqZXEhBAxT9gVYYYYBhAIQAUto94rForLZrIFd9JKNRsPy9Si1DgYDO9+U3nO5nA4ODqy3KvctRoSzszPTb3Y6HR0dHVnZkgy+crlsXT22trbMAMR36/V6xiZWq1XVajXdvn3bWG+6Vfj8Q/Ry6FHpFIE+EGaW52Y8Huvpp582ZpAcRDpb4Dhng4ObGDDoDSPMH16n6+OTMHr4+YZ/r5i61ViNNx4rYLcabzg8S+cF+ssTLIuw1854xg4myrN1LHTL7cG8bm9tbc3Kh8u5efP53BZqXLcAMMprvV5PuVzOdFOJRMLYEkAbJgdiP3yJ1Xe0YOHFecgCDkilfArTRDkQ4T6v5bjJHxsMBsb2oM1bZihgncLhsFqtloni9/b2LNOO6BdYT4AX3S/4OXEpzWZTh4eHymazpm8D1HLcMGe4fjn+wWCg9fV1Y5+IJeG7A/68VhJmCw3j/v6+uWgBlbROIxKE4F7uuUgkYuYANHSRSMTYovPzc8vEA9DAUGKg8YHTlI3pJYsm0Med1Ot15XI5uwb0hG21WgZsvO4OANztdlUsFg1AEfoL+CbihdIx/Xlhxbgft7e37f6gI0k+n7cNBf2SE4mEgexEIqFbt26p2+1aGXQ+n1skD8fLZgTWmIxB9If9fl+PP/64aQEl2TmGbed8sXlBu0cJfDkOyUs5/DziX7dyva7GanxxY7X1WY3XHYAxH6exvGsmE4xF15diceb5kg0/Z4Intw12DtAjyVyr0iJQvIo99G2HcFT6Fkjkhp2fnxsoQ6Pms/Ng887OzozlwfQAMKKcBQvRarVM74eLl7Jkt9tVvV63UiuADYBTr9ctyBfWgpgMPhtmhn/Ozs60ubmpcrmsRqNh2izOd6vVUqvVUq1Ws/gQAqF5z/39fXU6Hd28eVPZbNaYOdgVokxarZaxdBhKKBNns1lj/NDWUU5GPwjD+dRTT1k+YKVSsWw2DAoAKMAd7A/3E0wmALPdbms4HKpQKBgblkwmjY3ypXFAC+wUmxTah1Hu905aSpDBYNBAVKvV0uHh4cImIRgMGlPKNQR4Ang6nY4ZKur1uun4vEFlfX1dm5ubun37tqSL/MROp2NdPFqtlk5OTqyzB2XNYrFojmSuQy6X07Vr19Tr9ewaBQIBbWxsmIwB7SdmnUwmY7pD2MFsNqv3vve9ajQatiGg3zDHPJ/PLSOQ5xytKpst382D83sVcONn3gm7GquxGl/YWDF2q/HA4csk/mc+a47JF4G6tBgsTFkF4ASjAlOA7siXePg5ZgpKqpS4ACho3WazmTY2NszAQOmu0Wgom82aYSCRSJhblDIVWh8AnyRjYjxDwfEQ6Irhg3LV7du31Ww2rYRKmZagXzRpGDso1bJgEtRM1h2Givl8bnlyvV7PMuNgB2kYv7m5qcFgoJOTE3W7XQs7LhQKZsSg3IzRIh6Pa2NjQ/P5XNVq1c6bdOlCJJqFsiQgH4aTjgyAs/39fU2nU+t5Go1GzWDw7LPPKhAIGNDLZrMWpcHn8j1DoZByuZx6vZ618RqNRuYE5ee0FiN+g5I+5hru0WQyqVAopK2tLVUqFQPulBApUROdA5vF8VcqlQWmiXZeZMM1Gg3dv39f0WjUyv2wwsTOwDinUikDRLPZTN1uV9evX7f7hBI4mrVWq2WdPIjH2d7eNtZzOp2qUChoPB6bs3hra8vAMdcGLd/p6alu3bplYBahOa+RZMCv0+moXq9rd3fXSs6UttnsUYL1Ok/PvPO8euMETCPn1JsivHRjNVZjNb7wsXLFrsZrxrJ+juFz65ZdbL60CnjDoSddLrAwNAAfSjN8LgCRWAzKWpQ10U8hRkdcDqMjXeigCNulYwA/A1RRGgaAYKiAlYKZ6Pf76vf71hkCbRqLNWwO5bVoNGqggjgRFrTZbKZSqWSsYLvdVqPRUKFQULlcVrfbtUgUerdKspJgIBCwkttoNLK8Nv776OjIBO8wNMVi0cqFmUxGL774oubzuW7dumXGk9PTU4sUga1h0acbQSaTUb/fV7VaNeYTAJXL5cyE0G63LSQ3lUpZ3h33AyW64XCoa9euGdN4enpqJURiYGBCA4GA8vm8lZsBFbwfmsiTkxMrMbNhkC6d0xhOKDv6lm10fSBqxbe34vgo2WazWQPWMKJedwlYk2Tt3nA2o/N8/vnnrXzvQ4YBctxLtVpNkqwdG5E/ntnO5/NWnsUtSzswmMdCobAgeUDHSPYdXUhSqZQx0jzb2WzWmFi6lKTTadOmhkIhZbNZe45gR9Hzce/DkMPaMT/wOUgGJFns0fLwz+5Ka7cafqzW9suxAnarsTCuYun4uQd8XvgMqKMMw0ROyZQJ3etqvFDafy6lN1gf330CrRSaKsTiZJyhGev3+2ak8P09Yfdg1QCkMAwsNrFYTM1m0zpESDIxu49goSyZTqcXHJiwghw3baGIf5hOp6pWqwqHwwb0Op2OadV86RqXpHTR4YAOEZw/SqS5XM40bGgFcb8SnHxwcKB0Oq1yuay1tTWdnp7qzp07Go1GZuTAmDGfzw1MnJ2dWZQJvXbL5bLm87nu3r1r4cKcX1y+gCTpQnNYr9dN/B+PxzUcDlWpVDQejy1GIxwOmzsUcA3oAhBgzjg7O7P8ONrMwSDBagJm6vW6aSO73e4CS4jZBf0b4Id7D0cv5zcQCNi93Wq17L2j0aju379vgCYWi2lzc9PuCY4DIwtmGLR9bC5gJNkIEEgNA4ojm7/3eXEAPTSDZMvxvALE+CeXy+n69es6PT1VKpUyTR3PZiwW02OPPWYMNnrQVCqlWq1m+kucrvl83kqvp6enphlkI+fNTIA/b45gLvAShOV5aAXsVuOqsVrbL8eqFLsakl6fpfOiZ+9s9SYGynPeyYpzzhsmvE7OGzKY7NHgwcbN53MT1wO60F5hJPAuPNg2AMBwOLQ+lAjocULC7LCY9ft9C7/lu45GI+XzeSu7cky4K2E2WOwwB5BxRngrpUPafLEA0hWDtlSBQMDaUUlacA0fHh5KkjFl9+/flyRdv37ddFwctyQ7X5TBcc42m001Gg0dHBwomUzqxo0bFt+RTCZVKpV0//59Y/T29/dNI1Uul9XpdHR8fKzxeKwnn3xSh4eHBuRw+ZZKJVuYJ5OJGo2Gtre3F9p2kTMIQxeJRNRsNtXpdAw44uSkfLe+vm7lVkT+dNmQZNeabDpMAslk0hg6HKWUR+kNS3ka7WQ2m1WtVjNpQL1etzJrNBrV0dGRxYpwP9OhAmCcSCR0cnKier2uQqFgwJ7zQr4gYLvf72t9fV2FQkGpVMr60fq+xLB2mE14bgBWgF5YOjZPdBLZ3NxUq9UyMCpdmpXQcN66dUu9Xk/lctn6/ZZKJWOUkVPw/PFdeE8MQLBw3Nuw+rDDnIflPrEAy2WdHaBuNVZjNR48VozdalzJ0nmgR4SFjzSBtUMo7d2yvB86Nnb+fJbXtPlWYL5vLLt+2lt55ymLMX+HWQG2hcUDwNdqtTQej+37jEYjK6s1Gg3r7cqCeXJyou3tbQsAhqUDyBLWm8/nVa/XrUSMCxPQS3stFu9CoaBAIKCDgwPdvHlTo9HIBOZ0CqADAi7K0Whk7bQQ6r/00kvG1hQKBdOKDYdDdbtd5fN56wO7vr5uLcVoPg+bShQFgAlQsL+/r0wmY6YJNGjeyZlKpYyVzOfz+pM/+RPLt+M6AvYAHbB/h4eH1u2BvDN638KicVxcV953MBiYHg5dISADDSammVqtZgwjJplkMqlKpWIgFvYUxmlvb28h+oaYEc7D+vq6sW71el2lUsmiYDzQB+wAWtC/hcNhY5WLxaIBmUgkosPDQ5XLZZuXCH7OZDKm8wuHwyqXyxZ8DADlczj3RLTQug3DA67XVqtl+tNEIqFqtapUKqVgMKhMJqNEImHfr9vt6tatW5pMJqblQ/eaz+fNZCTJWr0B5mASAWhoFtPptMkzlnvEskH00SeezWOsGLvV8GO1tl+OFbBbDWPdriq/UnYEeAHaAHf83XQ6NX2cf7102SoMcCjJ9GsM/tYDQZgYAJwkc/7RS5MFhgWfxR3whxgdkwMLTjqdVrPZtN9LFyU5IiZwJPZ6PW1sbJjzlxIYLArN3fl7mDliR2g3NZvNVK1WLdg1HA5ra2vLFmfKymj5zs7OVKlUzF3I4kjJcz6fmzaMoGAW0Ww2q/X1dU2nU7XbbQMV/X7f8vJqtZrFWeTzeStfHx8fmyng1VdftRZlnP/hcKhMJmNl0mazqfF4rHw+b90l0NM1Go0FpyZZfDCtGFByuZwkmXYRhgidG3pGXKCwkEShEITr2SEAlqTXxNGgSeQ9AHmAHO4h370iEAhYxA0gj+w3pAYcP0HBsMSTyUT7+/umYTs9PbUuG5SoYZCz2azpDYPBoLmvcVBzrfl+Ozs7Bj4B6vSnpczqy6he71kul+27+kiifD5vPWrpeOGfZZ4DwD4uXL4TwIzX+84cMOaewfdGDM41QPCqaJRVGXY1rhqrtf1yrIDdakh6cIse/3OYKD9xA/IkLTB5fqC/82YJfgaQY+GFfYIBA+zhPvSdIwKBgLEfMIuEu/Z6PRWLRQNUlMpgAWgnRsYWizIgSpKBvE6nI0nWmcA3m4fFIGOMSA4vHh8MBmo2mwoELjoB8B19B4xqtWo5ZhwPMSjEUqANo9ctmsRisaijoyO1Wi29733vkySdnJxofX1dzz33nMbjsW7evLlQ2oxEItYWq9PpGINEuTkcDuuVV16xjDO6dwSDQW1tbS3k5lF2Bsx70J5KpawfLWVyXL+4fROJhAGzTqdjwKZcLpurt1qtGsggngQ9HgARpoioEYAXbC2uZPrSojfzsTuU/SORiLG5uJVrtZq9B+CezY53bAPoMZTwTJAfh8mAXrg8C/RkJccvkUgolUrZ5oYA5EKhYK3WMDtgBDo/P9fm5qbdi7PZTI8//riB43g8biVcuq1Mp1PTegLq4/G4afUApwyY2bW1NYtdoUROjiHlczaGxO14yQa/ky6lHNLlRpPBfPIguchqrIa0Wtv9WAG71ZD0YNZOWgR3RBR4rYsvk/jcOiZhwB8gjs+BdSIKAa0an0e0iKSF/DnYDN/E3oejUtpBrE5nBMqbLPylUsnYL78IsYhubW0ZOwPjSH9YnIloAinD0W0ikUhYyRlwBmtI1hogDTBZKpU0GAwsBLnRaBgrArAh9oNm7eii2u22/RywVavVjNWhJM2Cjgi+Wq0asMPBSGmOcu3a2pqOjo7MoMJ1IR8OcODbfQHEy+WyKpWKJFnZdTQa2T3R7/eN8UWDhcvSR81sbm4qFAqZezcYDKrT6ZijFJMKmX0wyAQ/owvj+AFbROCQccfxsIkBRLGJoJzY7/ct6mU8HiuVStnx+ZJoo9Ewc0U6nTaQTsgxHUhwv9J/FYDHJgPH62w2MyBHmZm4m2QyqePjY9toUbINh8NWRqZfMB06YPqI6MGwBPtNGZcQ4lAoZPpQ3pd7hLkD0MxGwLOzPuaEeYT5h3uAZ/dB0pDVWI2rxmptvxwPzTzxwgsv6Gd+5mf03HPPSZKefvpp/bN/9s/05JNPPqyPWI0v4aA8cxWw8yCOCZrFY3nyBdDBjgGyAHyUSFkgGX7BIiCXkiSfRSkVhm44HBojhnaOkhZMTSQSsbZHPpIEZgXm7uzszBZS3KD1el3lctn0S4eHh2o2mxYpwXePRqOm3WJhms/n1i2BsF+OnTIt/6bM1mg01O/3lc/nFYlELJPu7OxMmUxGyWTSmA3YxWq1agxLq9VStVpVt9vV+vq6dnd3F+JFJpOJMYV37941Bo02WSzWzWZzwXhByO1oNDJ2Dj2gJCv3plIpFYtFuxcwQzSbTQvLrdVqymQyVnomNgP2slAoqN1uG/je2Niw96FFF4aAXq9nwcG+nReuYL4HAcKSLCIF/R79XSn/8965XM5CnjOZjDqdjjGlmC1gmUulkprNptrt9sJ1kaRsNmtlXNjAl156yfIMyX3jeNlkwBaiHczlcsYSzudz5fN5ywD86q/+agNihUJhgbFEBiFdxADt7u6aUader1sP2U6no0ajoWKxaBFBxM+wuSoWiyoWi2ZKgZ0DfKJpTaVSZl5iDmCzBuD2m0HmFh9vsuyiZx5ajdVYjTceDwXY/cqv/Ir+/t//+/rABz6gr/u6r5Mk/d//+3/1vve9T7/0S7+kv/t3/+7D+JjV+BKP10t7h0EDWOC0XB6+TZik1/SJ5b8pJeJShDGRZMyQjzbA8cn7sWAcHR0Zm4NIH/CCHgiGDV2dLwvm83kNh0N7HSCMaImTkxNbBEOhkK5du2YMEAtvKBRSs9m00hcMBywfWkFKYURBEBwbiUR0dHRkvT/Pz8/1x3/8x8aewWChJeM9iWkJh8M6Ojqy7xCLxayFFEHHMFT379839qZUKlnwLdo1zg9OYTRjGDFgNlutlmn2ksnkgvt3Op2ahm9t7aI9FlrEcrlsrmniWAC/MKII/IvFou7cuaNAIKCbN2+a6xlWaXd3V/1+XycnJ2o2m0qlUiqXy2q328auUXokZgMgzUamUqlYfM54PLZQ5EqlYqzkdDrVvXv3lEql1O/3LewZFrjVaqlSqdi9Op/PVS6XlclktL+/r2g0ar1r6dMKawaoHY/Hpk/jHDebTYuqkS6Cs2F//TVj08S9yznmGSOuBRB5dnamZrOpXC6ne/fu6datW4rFYrp165Y9c7DO3CvtdnshlgfGjc+GseO5AqQxXwAuYfK843U50oS5iGvEeFAU02qsxmosjodSin3sscf0nd/5nfrxH//xhZ9/9KMf1S/8wi/ozp07b/UjHtpY0bWvPx6kteM28cDPT9Be5OwZPt+mCYcprB9lT7K5WIT5HH4/mUys3AMjc3p6aun9MASAT0JtA4GAtVNikfMlPBahVCplIb69Xk+NRsNYChgdIlIoqbEQNxoNC7TlnuK1LHx0lQDsIO7354LSLW2jdnZ2zM1aLpfN0Xh6emqL6tHRkTGRtFAjIuPll1+2WA/O4fn5uXZ2dlSpVMzdWK/XjWUClMImkhHo26PhFgWg+nOKCH42m1n3C59JiCAf0IXpgnsHAw1AmLI1gAajTCQS0f7+vukmiTLhPTF4wALSrYL7dDgcWncHGEDKggcHB6bvzGQyajabOjg4sLgPn7tG+HCj0VCv19POzo6VsAuFgk5OToxZli7iZnhuJBnzTNkWhjGXy2lra8tK1RxbMpnU+flFj1YAWjwet3sIRhOGHEbcbzhgtFOplMLhsAqFgoLBoLmnb9y4YcBTunC5DodDnZycKJ/PW5kdgJvP520TxgaKjQfaQZ8H6P/9RiDt9dz6jBWLtxqM1dp+OR4KsIvH4/rc5z5nPQ4ZL730kv7cn/tzVrJ5O4zVxX/98XoOWXbQLBI+/sRr6jBJkCrvyzFEW7CAsxgDvObziz6n6HR8btx8PjdtE4J2+myycNOVgf6XsGIE9/L5lMVom5RIJNRqtawkCyMym81UKBTsdSzE0iWAffbZZ1UqlSwmIhKJ6M6dO0qlUua8pVUYPT+JywBY+HOLSaTdbmt9fV1PPfWUlW3Pzs5Ur9fV7Xbt8+nHSnacB2F0r4jH41aSrlQqJuyHkaERPSCDLg3lctnKlGjQaB/FMQSDQWOzksmkjo6OtLe3Z6VxX7bkv6PRqF1zNHEwhLBgkrS1tWWAGx0hrlxKwphuOM5er6dOp6ONjQ27f/icarVq0TOYHyit4mgmkPf09NRicwCElB9rtZq63a42NzclXYC8g4MDkwAAdujIQAcV6SJ38P/9v/9npXl6325sbGhvb0/5fN760Q4GA127ds1K4/F43Awls9lM9+7dM8AFKw34xohD6RXZAs7Xvb29BR1nKpXSk08+qXA4bGVZvhvsczgcttI896kHdLD5mGF4brne3k3/eqDszbJzq/iT1WCs1vbL8VBKsd/8zd+s3/7t334NsPvMZz6jb/qmb3oYH7EaX6bhtXbLZRDKLX6Chk3wLAsAD1bOT/iAMLLUAGM+RoX4CFprsfCS+eZbJa2trVmJlRKsZywo49IzExaEUiXhu5Iso06SuRlhnXzDc85DvV5Xr9dTqVRaKEV1u11jCs/Pz62HKUwR/01cCmDlxo0b1k6qWCwaeKbZPQGwa2tryufzOjg4WCjlVSoVPfHEE3YMwWBQ29vbqtfrltnHd0fIPh6PdXh4qHQ6rVgspkajoel0qnQ6bY3eAU6I5ZvNpmmo0H5xvYfDoXK5nDqdzkK/1ul0apEi9HYFGGDCwPkLCOO8EYacSCQsOsZnI7J5oFvDZDIx5or3pwx7fHysYrFoRo9EIqHT01MlEgkVCgUlEgm98sor6vf79h6pVMoiRWq1mgaDgbLZrNLptPXYlWT3Aq7m7e1tY83Q6Z2dnel//a//ZSx1KBTS9va2SqWSgUfAVjqdVjweV6PR0PXr1y2QGcC3vr6uxx57zLSk4XDY+uDCcBNLQj7d9evXNRwO1W63Va/XLVQZVp1+sOjseF4oIbPR4bzAkhP/48Oifes5zrd3tD8IvH0hJVcP5vx8tSrZrsa7eTwUYPe3//bf1g/90A/pD/7gD/S1X/u1ki40dr/8y7+sj3/84/q1X/u1hdeuxttzMDF6cAaLRimV/wfcAdIAMV4fx4LH7yUZI0QJDx3cVSUbFjKiGwAClEb5B2MCZT8WOT6TuAvAQLvdNo0gTlDYH6JLstmsDg8PjY30ANO3OcMRCvNCn1RKsYjc5/O57t27Z9qlbrdrx1EoFLSzs6P9/X0ru9ZqNYsBuX//vjqdjnZ2dmxBpkVVIBAwoDKZTHTnzh1tbm4a6Oh0Oua6hInEBAFDRWmYiA2AOq5PnL1o6wqFggaDgQGhg4MDA+3o5nBR9vt9Y22It9nc3LSMuGazqUKhYC3RMBvQ8QJzwmAwULlcVigUsn6+RKr4jQjaStip09NTex3atHa7bWB1bW1N5XJZkUhErVZLzWbTjA2SLLbEB0nTdQLGNJPJWLxOrVbTzZs3lcvlzDBRqVRUqVR0enpqESXdblc7OztWRp5Op0qlUsYKwhSura2pUCjYfUTgM88LTB2mF8qoPAPcG1tbW+b4BYwTNO11m81mUzdv3lwwpnizFBs5H1i+trZmzw8lcTZVfA5mFcwcbBCX3a48b1/M8CDPmy9WIG813m3joZRi3ywFDpPylRwruvZyvJ7rbDm/bhno+dR4L4LmPX3m3Wg0soXIt3k6Pz83J91yxh3N5ImoYDHwQI9yLqJ/Fg+foVWr1RaS8CkZk+ofDAZ1enpqzJwkW5RgGOj7Sf4Z3xMWkdIXYIEuCjB4r776qunPstmser2e4vG4tbACHHoh/P7+vrLZrH2vaDRqpgCAjiTr3iDJGMWTkxPTyvncN8qvhN7C9BC/AXABCAGi4/G49SpFXwfjhI6QHDtYXNqwvfrqq2aM4NnDhYn5YDgcqtVqKZ1OazqdmjYQAENA7vn5ubGPOHbZUHCPsgGg+wQdNAhyns/n6na7KpfLKhaLBuaI+8hkMnruuee0vr5uWXPz+Vw3btyw0GrPROKwhmmmFF+r1cz0gLYyHo9b4DHmHDpIXL9+3TY9tOUCKOHs5rrkcjl7rtiYSNKNGzdUrVYtX5ASazQa1c7Ojm1auG6bm5sGBm/evGm5jPl83nSJGHe4Lwlw9gYdSu44obn3JS10oOA8+bBj6bLThKQrjRRvdXhd3grkvXPHam2/HA/lKVoGCKvx9hxvNj4AwOa1X77/KAwJ4I0JGx0VJVTaDEmXOXS8ZyBwEa7rM+y86QIgGAqFbHElTJYoCpg6Fj//HmSPwbDs7+9bCYmyKixFNptVKBQyEAjY29vbs6iR+/fvW3wDmWmUgqPRqBqNhiKRiEqlkhqNhvL5vE5OTqx91mQy0c7OjsWCwAJms1nL0pMugBqxIABmWNB2u61IJGKAMBQKmYFja2tLmUxGR0dHxuqcn5/r3r17C2CZ8h4ZgmT7sXADkNAD0qs0FAoZgwrTyOTZbDbNIALgRtu3vb2t/f195fN5AycABthCnLFEyAAkcPUWi0VNp1PrqEBJu9vtWgmzVCrp8PBQk8nEABxtzwiAhuEiYJgyPCXd4XBo7lrvVO10Omq1WsYm5XI5HR0dqVAo2AaFcuP5+blOTk6MhSO+Bp0lYBvzw3Q61fb2tn1fTB+SLC+O+xIWr9/v23Wk3RilXmJrEomEyRBKpZIkGaNM6zg2GtIF+JzNZrp27Zoxs6lUyp61YDBo15b7BGBGph7MO8DPs+nL7N3ynMKz6zMGH9bwYG45RmWly1uNd+J46AHFLJpv1/FuQvVvBsgtu8y8vsVnTPnfeTaOjhIs0kzMgAXveERYLsn+H8YBwMgCgF4Kdo7FAJ0Sei36o6JrQtdzdnZmGjH0fIj/4/G4stmshQOjdfJ/D/DEUJHL5bS+vq5er2c6OQwFuHkrlYqVwI6OjqwUBhuWz+eN2USgfu/ePWUyGWP30CpR/tza2tLnPve5BY0amj/clvR5ff755y33bG1tTZ1Ox64DYM7H0JCfBssJc+iz5Hy8DWxXKBRSOp22EiURIlxPXK+UvYmFgXHz2jjy1mDYcG1y71CuJVONMup0OtXu7q7p88i5gy2FsQTgl8tlA1awl1xDNiOdTsdeg96Sz6MESckxEoloc3PTHLGUj3G2ZjIZlctlAzMYfaTFcG7vLCcyBv1cLpezLicAbNrIFYtFy62jfAuT22g0tLOzY9dIuggrRgOJKSIcDiuTyRjY4nvn83nrq0s53ru7udaz2cy0fFzP5Uw6ANxyjBJAlef+qvnpzZgs3upYgbx3zng3re1vNB7KnXx+fq5/+S//pWlGXnnlFUnSj/7oj+o//af/9DA+YmEcHh7qu77ru1QoFBSLxfRVX/VV+v3f//2H/jmP0mBS9f+w8+Wfq14jXZZN+H8WXLLS/OTHBA+AgUnzommAHmwa4mr6ajKhU5bjs+lpipYIACfJSkgYB3DPAnDopkAZdWNjw/R/vCfALR6PG+jBGRuJRKyjgHSxML366qsLmV4cBwJz3xt1NBpZpMm9e/dUKpXsWIrFovX5ZAG9c+eOnnvuOVss0bshZK9Wq5rNZnrxxRe1trZm5Tffq7NYLKparerk5ESf/exnDYShLwwEAkomkxabgjYKFmt7e3shKgMwcffuXSufd7tdNZtN602KexLAwfcbj8d2nXG7ApxhYrjWmFkAEABkH8uytnbRbYN8wMFgYJE4gUDAdHqwotls1nR6HkAmEgmVy2W7p8fjsU5OTgxo93o96xhCm7OzszMVi0VFIhED3cPhUJ1Ox4CwJDuvGFs437lcTsVi0QA6zOiNGzeM9aXkGIvFtLW1pRs3bujs7Mwc35LseqG1zOfzxoru7u5a2RdgirZxb2/PGMFUKqWtrS179tPptG3kKP8nEgkrDVPW5lzhqAXcch65PzBFwN4B2NBkkufo5xhYdbLtiNPh9zB4y078L0VlyM+P/nMeMt+xGqvxZR0PpRT7iU98Qp/85Cf1b/7Nv9H3fu/32s/f97736ad/+qf1j/7RP3oYHyPpouzzDd/wDfrgBz+o3/iN31CpVNJLL71kjcTfLWOZaUPH4sfyRLj8GhrLM+nCJPhJlPZIlExZqNG3Mfl6EAf4w2xAvAl6JEKE+Ryv/8pkMpJkZThMCHxWOBxWu922MmEkElkQ/MdiMeVyOQOllO0kmVZuNBpZsj9soT9+9GSbm5tWZq1UKsaIwCiORiPl83kDUTBgRH+Q9caxdzod9Xo9DQYD5fN5lctlYxxhF+v1uoUxHx8f230di8WMhUJr59kgdHBk4vF+lUrFIkNw0N66dcs6KUgyXZ13eOIkpdSHaYT4EwA/7mAWc7R1ADyOC9YUdhGWkEUVvRzGh8PDQwNWXENYTGJLKpWKdnd37f04Zu4N9IeZTEbdbleHh4cGfLl+gPt4PG4AqNVqWbmbWB3MAo1GQ5lMxhylSAK4V7j/zs8v29+hM+v3+9YqjXtmY2ND/X7fPof+rThOfZ/ibDZrAOjll1/WxsaGyR+I2pnP5zo+Ptbe3p4kmW6R5xZW8M6dO9ra2jLNK2CQXEQcysTPwM4CxgDvZEQyn3B++b6YOdCmrq2t2efAwvusS/8zL93wGYmMh82wrcwXq/FOGQ+lFHv79m39x//4H/Ut3/ItSqVSevbZZ3Xr1i09//zz+rqv+zpr9v0wxg//8A/r//yf/6Pf/u3fflOvZ+Jm0HPxUaNrrwJyfrK5ajd7VRSAB22USb3blc/gd5RWYef8YNKlxMREDAiE1aM8z26dUiGLClljHJ8v2RI1wfHBluDoI8Nta2trASzCHsEoUi6ErRoOh1ZypSwLy8DxsDAhvH/55Ze1s7Nj4FCSsRwweZgtMAEMBgPTEvG56Pxw6V67dk0vvPCCjo+PDfjG43Fj8QA3s9nMSqHBYNBYSErdvJbvgi7u/PxcjUbDRPmdTkftdttYKY4TZgpHKyxsKBRSoVAwJ6skW7zD4bBFqAwGA3W7XctTI35DkmkaMWz48jumDQwr3W7X2D6iUa5du2asX61WU7Va1e3bt62UPhwOLbZkfX1dGxsbC07P09NTY5TnfxZ8DRiTLoT8xMEkEgllMhkT/J+cnFhYMSCn2+1aGTebzSqVStkGhhgb5p7t7W0LmuZvATzk1KExJL+xWq2qWCyq0+no9u3bxkIWCgU73rW1NW1ublonjnw+r0qlolu3bun+/fvKZrMGBmkFRts1tIY8U4C0XC5n4A6DTTgcNrcy5WquGyV+zB4+zw7JAGCUcjabP0w13oXPZsG7ZL0ul995kPelBl7Lc++qZPv2HKtS7OV4KMAuFovp+eef1/Xr1xeA3ec//3n9hb/wF9Tr9R7GsUqS3vOe9+iv/tW/qoODA/3Wb/2WdnZ29E/+yT9ZYAr9+NjHPqaPf/zjr/n5o3Tx/Y52efiyq/TaSc4HgvJayhs4TtHG+VgTokNYfFnseR/ChWGjmLApE8LiETXS6/WUTqcXhP0wbCTZU7pESzWbzYzFIKYDdgDQQJPyVCql8Xis09NTFYtFC24F7FEuwtlJSYlICfRkiURC9XrdSruRSETdbtcCa9/znveo3++r0+moWCxa14fDw0PFYjHl83nT/GHAAOywiBGSm81mFxZVmEwAqSSLq+CcYRIAVJ2cnCibzdr5AvDm83kzIwDIUqmUsYHdblfJZHIBSDebTRWLRbsm3nFLayyYsK2tLbuPaI/Gd5C0IK7nnpBkQbXoEWGi6vW69dolXJrrtLm5qWw2q/F4rIODA0UiEfvO5+cX3TowCxC6y3fs9/sL8TYAl1QqZeAbkAYD65+nVqtlbBVRKzxjMMYbGxtKp9M6Pz83trfZbKrRaKhQKFi5mugVeuLOZjPr/IDGDxkCUTKAfMwb6XTaADo9cZPJpBqNhuXX+TiRzc1NM+9QUk+lUtrd3dXW1pY9T7VazRyxRKgQK8S1I6bHA3MMH6FQyLSRaEjZHHpdIsHSzA88F8w5VAcYMGe8L2VnQKIfXyrAtbxpJrpnNd5eYwXsLsdDAXZ//s//ef3zf/7P9V3f9V0LwO7Hf/zH9elPf/pNs2tvZjDJfPjDH9bf+3t/T88884x+4Ad+QP/f//f/6UMf+tBrXv9OYeweJDBeHsu7S8/ALb8foAdmgkl+OR7g/PzcNDv+vdit+24CMEu8znekYEJn4ua68P78DVELktTtdq08h/6KhaJYLBrrhcaISIpQKGRJ/bBG3W7X9E3D4VDJZNIAEsYFWnv1ej2Lc0D71W63TaBPUGw+n1etVjM2B80fTe9hG4kyqdVqkmQl3EKhoP39fctNQ4S/trZmbGGn07HyFXo0ypb8w+9otYaLke/Mf1NCY7NVrVYtggWBvRf7N5tNY//o9YqJhGgNgDwaOLpYwHjC3hFy7NnB8XhsrBJaSa55sVi0ewFWLpfLGaC5f/++6fs2NjbsPuK10kUpstFo6OTkxOJQuDekCwBaLpdtgwJIzOfzlvuGQQLgMRqNtLW1ZcwVYGw6nVpPW8r/MM3kEqKTI76GZ4McO8r0gHzKxIVCwaQTqVTKrjHsY7vdVrlctqw+Ni7c59xf4XBYqTgxhAAAhHdJREFUN2/eNIaNHsDRaFTFYtG6fwAiAVQ+HgdAnk6nF4wuPsoE9pHvj1ZxPp+bTpJNJLo+H4fi2TkvEQHQPWyGbnne9GPF0D0aYwXsLsdDAXb/83/+T33oQx/SRz7yEf34j/+4Pv7xj+uFF17Qz//8z+vXf/3X9Vf+yl95GMcq6ULU/oEPfEC/8zu/Yz/7/u//fj3zzDP63d/93Tf8+0f94nvX6hfyN8uuNAaTJhMru1H+279G0kLUgXfD+tcyyfvJcjnCoNfrGRtIWZRFrtPpaD6/DP+FSVtbWzPGIxAI6ODgwMqSk8lExWJR6+vrpks6Pz+3bC7KQYjlOTacgdIFUD05ObEFhDZQZKrhiKXHJmUt6cJ1iIHg1VdflSRrX1apVIwVy2QyZvo5OzvTycmJLcRo11i40BMCipPJpHq9nsbjsTE9s9nMHKE4XRHzR6NRO28AHs4X7KePGSFkmPPBeSJWhc/gcxqNhmmpYLwA5JhkKA/fvXvXdFaUaunRi5uW+BiALcdJ6RKmZj6fazgcqlAo6PDw0Mq8RMDU63Ulk0kr6xIn02q1jAHlHuIeYxPCsdM7NRqN6t69ewYwAUgbGxtqtVq2USAzEdYZU8p0OtXm5qZteACw3W7X4kpg6Li3icMBfHFOCoWCzVm1Ws0AH/2A0Yn2+31rm7exsaFSqWSAFLaNzUwqlVIikTCwjPO2VCrZvAGYozsJ84jv+UxrN+5dXoMkg+vJPcu8JGnh2b+KCfMu/bcKsh5kwFjp6B798aiv7Q9zPBTzxLd+67fqU5/6lH78x39ciURCP/ZjP6b3v//9+tSnPvVQQZ100TvyPe95z8LPnn76af3Kr/zKQ/2ct+vw7tY3O8mhR7nKXEE5hYkN8TIAksHOmhIKbjdey4Tc6XQWFmEyrAAOMCPEWrCosnhJMoG3d+dVq1UTsWME4P9ZDCORiI6Pj43NSiaT1m6M94cBoZx68+ZNhUIhy38DDPloiX6/b9/x2rVrxrYATkOhkE5OTowJhHmhHRTAlBIpJTGYPAKYE4mETk5OrHQI4ANo+HI5pTkauhNCzHGi4ULcz/mBLZnNZjo4OFA6nVav17OyMwaNWq2mdDptMSEAHYDYYDBQJpMxQIcr1GusMGPU63UDhxhKJBk7xDmWLsACQn90WJSiYRpxph4fH1sMDC5NSs537twxFrVUKpkDtlarWelvfX1da2trOjw8VCqVsjw5dIvVatU0isPh0LqCYMzhHsf4EQgEjIXLZDJKpVJKp9M6PT21sjfPGJo82FGOH10a3SMA5hgLarWaUqmUbt68+ZpwaNg5zCS4YAFzACwAPUwrvwsEAtre3rawZjYHhGh7Rp/P41rDgKJZlGTgGTAFCATgMe94DZ3fIH6xQGvFvq3Gu308tJjvb/qmb9KnP/3ph/V2Dxzf8A3foBdeeGHhZy+++KKuX7/+Jf/st8vwO9g3OwFeBe58ScNPwn6SZRJnQWAA6DxjxuIuXfTGxOnK7yUZWGNxZWGgjIZwG5YJ9gOXJ2G2sBpEZwwGA3Ou0mOUz0XnQ/mK7LNyuWzggwWMciWMWjAYNCYFFgPNGj1DWZxarZY5CWOxmKLRqN73vvdZsC4s4HQ6tYUccwglMc47IbII3j1ThvYJVooOBPP53IDAwcGBnUecrQCE+/fvKxKJWDbc1taWZfxhHPEO0fF4bJsAriFBuDhNg8GgstmsdSBg8wHTA/tHrAjuWfIDCQWG2ZpOp9YzlaDr8/NzbW1tmfGm2Wxqe3tbx8fHxsbx9/F43DSQzWbTgoFhWikJhkIhu7fu3btn4b/SpVQAgEY/XlzMPBunp6fK5XIWWDydTo3ho/XY+fm5sXLZbNZ64nJtKYejC0XbyDMKMC0Wi9aOjuuJrpNnqVQqmUGC+zUQuOjtmkwm7XnDaY0+1bO+/J7NDQwjblakAmQ4ShdaSrS3XgPH671RgnkM1p6N4esBLz+HvR54e5AeeTVW490yHkop9tatW3rmmWfMscVotVp6//vfb7l2D2M888wz+vqv/3p9/OMf13d8x3fos5/9rL73e79XP/dzP6fv/M7vfMO/f6fRtUxwb2Yie9Brl/V7ywDQRxJ4Z6EHfd6thgYMZgDTAhM/7wlwYrLv9/s6PDxULpdTIpEwPR4BqZR8zs7OjPHa399XIBCw/DevFWQBk2QOXHRfhLHS+ikUCunWrVvW3SEYDKrRaNh74c6ErQQE4aJELwYoQX/Eoh6JRKzTwWw2M7F7u902hgZwBwiGSalUKgai5/O5SqWS6dX4buixAJ1k59H9AC0kLlbCkolz6XQ6xgxybWEc6aQAS0S5djQa2fvT7xWXMq3PMIOsra0t9Gql3RfPYb/fNyYMcDkajRQOh42hg5VkE8DmABcwZeN4PK7xeKxGo6FEIqHt7W0zg9CaDEaKCBU2FbBUsJJoDSeTiba3t83R3O12VSwWjYWGfUW3igkF8A3biU6Rz+AZokxPdA0sJNedTVM8Hrf+rpPJxOJTAGIAe2JlMKdw7/tyMxpSPoPNEs9kLBYzYwSMO8CVfsqUT2HiiKMh2ghzkM+587o6QN+D5q/l0qnXBK9Kp6vhxzttbX8r46H1ij05OVG5XF74eaVS0bVr1xbMCw9j/Pqv/7o+8pGP6KWXXtLNmzf14Q9/+IGu2OXxTr34X4i5QtLCpMhEC4jxpdirgCAsA0CNyI9lLR+LAGwQIb98PqJ4dv6EvaKB4j0oy56cnBi4pORDhATGicFgYBlggBO0arTporUYC78kHR8fq1arGSAi120wGOixxx5TJpPRwcGBdTZAhF+pVFStVlUqlXT9+nX1+31VKhUzOQyHQ0WjUWuxRYsmnI4wG5R1+S6EFdODdjQa2blF6zQej9VqtdTr9cwViyEkmUyq0+lobW3NzAuUGAHGZM1R3uZzKLG1222lUil7Pd8dIDCbzezaY44AxOHexB0MwAew4RxNp9PGBnU6Hc1mMwPKMEp0gODcRKNR0zYCFNCCeZ0WLmBKlZR7AZeALtiq9fV1A+ihUMiMMdvb2yYhoIz86quv2udls1kDeAQU89nc55SYYcXG47Ha7bby+bxKpZKBQ7SUnIt8Pm/30NramkWgcP/xfJbLZZvPvJO03+9bWgGMGcybv58ASrD26Ba5BtxvaOYwy+CGRVvomTrP2nKcgG+ebe4J6bUGr6vms4ehs1uNd+Z4p67tX8x4S8Du137t1yRJ3/Zt36ZPfvKTJrqWLsomv/mbv6lPf/rTrymdfiXHO/nis8C90W72KjMFu2fpUseH283rZPi3j0KhhEjJ05fYJJnuisUL5oidP43FYWEAOoi9WVCIEYlGo5bBRZAtgI8S1mw2WwB8sBcwUzgC0VRRIgQYsZD7UitMCSVHSqyRSETVatWAMMC00WhIugCBGxsbFoFBiGsikVC1WjWA7FkoSraZTMaCkSkvA0y63a6VZgEivCaXy5kD9fj4WLPZzPRn4XDYtGZk9FGixDAAA4Rhg64flMbn87mBMlpXAfDYyMGMwgT1ej0rYzYaDQ2HQ9OXnZ+fGzuEUQWASY9X9HbHx8fm1ITBRIdH+zc2E3SYGAwGevnll61EWSwWValUTCrAPQX4J7BYutQCcv/CpAK4yCrEiEFeIiHUtBlLp9MW9wEIZOMDwyZdOqNhITEFoUmlTy9gCze675RBz1nu70KhYPpRgpcpaaPnw5HOPYHxxWsDg8HggtbOd4wAaDJg6yQZc+4lHLwP/4b9fyPgtgJ3q3HVeCev7V/oeEvAzmenLb9NOBzWjRs39O/+3b/T3/ybf/OtHeVDHO+Gi/96Llg/lsut/MwDRHb+iMR9KYTFTpLtxH2pltgEdu6UXtG5If5HsE+QNYtSIHCR7wYLRAkOJhANHfceOVlEfGBGiMfjtsCxKHY6HSUSCR0fH1uC/2w2s5wunIa+d+nGxoaxY+TiFYtF1et1cwrjLKT8mc1mDfSgLWPxJxKE85PP542N6fV65jzlHKGFOjo6stJ2Op1WIpFQrVYzswrCdtq4UcKDbQE0woRxbgEYoVDIQAjXiWOkJEq5MxKJ6PT0dKFFVrfbtbBeIkwADXyvQCCgYrFoYbyU6qrVquWpERJMKd/rsxqNhpWf19bWVCqVbENQr9eVTqcXGtifnZ3p9PR0ITA3l8uZ+eP4+FiS7J4icgQDyvXr1+1cELBNRxRao7VaLXuG/PWULubI9fV1y+yjDMp14H4AxAHKYMQAi2gFYQlhUrle9Xpd+Xze3Ls8r5TOYehSqZSBO3IkcecSp8J18iwooJ0NEPMEzB7P6LLOjr/3+t1lgObXER95ctX8tgJ2q7E83g1r+5sdD6UUe/PmTT3zzDPWXPrtPN5JF/+NBMRvxN75CdI71/zf8zMfdMzrAQIECAO26EsqXXawCAQuc8tgL8LhsHUZOD8/t5ZIsGowR+jvYHbQ9vjPabfbqtfrFj5L5EUwGLQYCvQ87Xbb+r/CYnmXKsAIfVW/37c+s7B0aK0k6fr165rP57p7964xY9ls1krILPhEV3CuKQtjuODfuGj5m3q9bkaUyWRiwbLe1cw14lxQRqPpfTweV7PZNGF/MpnUcDg0YFcqlSTJ2EvYmLOzM+3u7tp/k8OH8xg9HICFlmwYE2azixDe0WikZrNp5xHmB/CEkQDmFkYLp6fX0FFCJSqG8+wBWbvdNjNLOp02XSDGguPjY3tfevXCWlPSJq8PhzLRIDClpVLJnLfJZFInJyfa2dkxIA8rTLmb64CZJJlMGrhj8wTLJ8nOIeedUi7GHM4twAsQidEiGAxqa2tLuVzOvhfGmVQqpVgsZnNENpu1TEBMN2QU8v7j8dh6FnOPAPZ51tGgMm+wUVzWvy5v9Ngs+k2gLw8v/+1KY7cay+OdtLa/1fGWgN3v/u7vql6vLzByP//zP6+PfvSj6vf7+rZv+zb9zM/8zIIF/is9HrWL/0bg7Y0mt9czV/j3pvQoyfRS0uUkCohhkvclOW+I4N9MzN7dijMOUCBpYXePOJvSlo+TYLEnrqPT6dgCOpvNrFk5bbaInqAZO8n70sWCUywWbUFHhH50dKRcLrewwNdqNXN2Hhwc2N9zzugOgJ6q3W6r0+kom81qd3fX3J21Wm2BDWQRRFMFswXThomBrgj9ft9MCoBDNGMwb+iVWFw5x5QXcWZS6oTVjMViFtAMiAGQUKYkHBiDAUYNwNFoNFK1WrWSN3E46XRarVZLJycnBvB4T6JnENlzjMPh0EA3pTkctWwmYAQBS0Sq0FmjWq0qGo1qe3vbSv+pVMr0oTCl/X7fzhc9ZXEY0z6LKBqy4zY2NiRpIdoENjEUCqlarWptbc1YUs4fwGVvb2/hGQK4ZTIZZbNZM7ZwfgaDgYG4+Z85wumCQSl6NBot9BXmO/A8slmAfcYYlMvljN1j44UGDwAJq8ezyyaJ0jvPOD/3c4OfL5izAHJ+juB3zDF+PmEAfv134v1WYzUetbX9SzneErD7a3/tr+mDH/ygfuiHfkiS9Md//Md6//vfr+/+7u/W008/rX/7b/+t/vE//sf62Mc+9rCO9y2Pt+PFf6vg7c0MAJovZ3mWh7LPslsVEAE4x/XJe7HwUqbl37gM6R9JsC8gEMYGJykaKco5AJ/RaGR9TtEXERWBxopyHt+N7iSSjLUKBAKqVqsGLGDUBoOBpAsTBi5MnL2U78gp476BNaQczXfg3hqNRiqVStrf37fvhesVrRigRJItcOjoAKgeWNH43gNhFvxgMGiGEN8P1IcRc17RFZZKJWUyGQvZPTo6UiAQsMUfMwauy9FoZAs3+jyE8dPpVK+++qquXbumQqFgoBE3MGCJtm18n263q2g0qkqlYrpA6SL8l/tsOp0aoEI/6LtUBINBK7VXKhUDIdFo1AAE7BNOVErHlGur1aoymYzW19dVq9WslL65uand3V21221JskxCSvDBYFD1et16qVar1YUw59PTU2PG0L6NRiPt7u4a00nZmPZ4gFgyGNGPxuNxnZ2d2eaEzweccj0xMqA3DYVCajQaajQa2t7eVqFQsGsyn8+NTSb7DpDvzTpoLWHRAVxoRSWZmQpwi9yAa8DcwmbmKgbOv87Pex4U+sw7AB1zGIPfr8q1767xdlzbv1LjLQG7ra0tfepTn9IHPvABSdKP/MiP6Ld+67f0mc98RpL0y7/8y/roRz+qz3/+8w/naB/C+Epd/C8HeLvq8zyLxsTry6RowwA0lD7RuPhWX768uxzDgP6HRZTvioMRsAToIjKC+A8Yhm63a6CyXq8vaLM4NhYXz9iR4A9Anc/nthCjk2PBlqRSqaRer6fNzU1JF+xbu902xiIUCqnZbKper5txYmtry5q4ExQLAEqlUlaOPD8/t6BmAnUBy/w3LkoWUKItYOr4DrVaTe1225iWXC6no6MjBYNBFYtFA3MsdLg9fasxMvYwHFA+x7HpResAcMTt/X7fviti+1KppPF4rFqtpmQyaXo/GFDuFTo10CIMhjMYDJr2Ea3Z9va2ZrOZ7t69q8FgoHK5bGVqStTEs3Q6nYWAZj6bEib3CX/T7/ftu7OhACByvjAfABJDoZB9BoxzuVxWIBBQs9m0EiIlc0wi4XDYgDVACwa0UCgYWwYAo9+sdNGLtd1uKxqNKhaLKZVKGTiUZPcXzB33/o0bN6z9GWHSXhIAawYDhy6Pa+I7fUiy4yTTjn/4m0gkYiHiGEgk2X3jHfVsHmOx2IJpwrNzvI55y3ewYABi+RnstC/V+nKun/sYzHsrwPfOHCtgdzneErBbX1/XSy+9pL29PUnSN37jN+qv//W/rh/5kR+RdBEJ8FVf9VUWMPp2GF/Ki//lBm/Lnwlb5n/ntXJM3P517JxheAAC/MNkLcmAIfo6FsPhcGgN4AlFhc1j0ZBkwAE2DA2bL7tKsgiUUChk7NxsNlO73TY2gLZesH2whei4YH3Q7zF2dnbs+KWL5vaUECkhAWjW19dVr9et9La2tqbRaKSTk5OFuAlCjgGX8/lFmy6AaTqdtr6buEDr9bq1yvJlcL4LbBZhteTTIVqHBYTdTCaT1mUCQBiNRu2aIPSHARsMBkokEsrlcqYXo/crOitABe5WmDxYPRg9wAgZdrPZzPq8AnQBrLCyHkxJF6J8tH8wq6lUSvfu3bP7LxqNWr4bujTODyBrOp3aeWHTAVN3cnKiTCZjOYlkE2YymQW3KYAPk4w3AfB9MdIQLoyGjo4kTz/99IKblDiVRqNhur6trS27XnR7CAQCBmQ598S/NJtNbWxs2Hw7m81UqVSMnZzNLrLnstmsbbTItdvd3dVgMFAkErG2akgfcBJ3u137TgBungdAsjfQwMDBfrMRZOPFdfN/B9Pu5Q7z+dyeff9ZzF++lOvLr8tz7VVA7iqDmH+dn5dXgO/RHitgdzneErC7fv26/st/+S/6S3/pL5lO6VOf+pS+5Vu+RdJFafYv/+W/bLEPb4fxVi/+VwK88bkAJq+dWQZuy6YH/tuXTvlb/mb5tYAAz7wABr3rDXE4C+58PjdDhCQTvLMLZ7Ifj8dWfoJBGg6HFrTLYoLLkQbs9HWFRQyHwxYfQuN5NFsARa/dYpE9Pj5WNpvV6emplXck2aLG+wOiNjY2VK/XNRqNFsrFlLOkC0BGVwGYOMp9sFYcK5pByqQwYZTnYC5hMwBKmEMAxOSvzWaXgccwlPS3BShSnqtUKsaawgoBkPh+MKss0AA9mEA0dT7eZGNjw9hZIkYA6FwrtJFoCNEPoncEqBCTU6/XVSwWtbW1pVarpcFgYP17Ya3oCBGJROx+mEwmC65TnMbcG/P5fME5ur+/b85T4lXW1tbUaDRMRsD78V3YGOTzeZMdVKtVpVIpXbt2TZKM0a7VasZUwUxy7ih90jWCjEOYRZyq0gXLXS6XDfjlcjklk0nbIBCXg5EiHA7rPe95jw4ODsxZDMikrOqZLuQFxLEQnO0zK7n/YCzpUsFzBFCngwbsPUwwoIz7wgci85yyYUJmsGys4BniWvCM8yxynfycxs+X52j/d36z61+zAnyPxlgBu8vxloDd933f9+nZZ5/VT/7kT+pXf/VX9clPflJHR0f2cP/iL/6ifvqnf1rPPPPMQzvgtzrezMX/SoE3SQtBv8ufu/zfHpRIi+BveVfrNSksLIA9Jkn+HgE+xyLJwA5/i1YOkDGdTi1agkWG/2ahnM/nBt78BE33BbLUYLD4nrAWiPsRnFerVTWbTVuQE4mEib1ns5npkQiclWRM3GQysWPxJcjxeKxSqWTREWSY4SqlVRTvRWCuj4egNMw5wX0KkEBrSDwKizD6QUpvlIOTyaSVfWFY6JdL+ZySNgCbjhqBQMDau1WrVYtOIXOSkiwAENPCdDpVt9tVJpNRs9m07+d1mbzH+vq6gStCisnVg1kDHGNe4Bp1Oh0rg1OmLZVKBgYozYdCIe3v72tra0uz2Uzb29tmLOD9YE4BsvV6XWtra9rc3DQ2r9VqmRuUvDuuFywf9y0gWboM04WZpFMD2X8wV2jSKMlSrqQN23w+N7aK0ih6SUAKrBZdMPb29lStVhcMCTs7O2q321YmPT+/aLeGkQPWmTgfzEU+0kaSbTaKxaKFStNRhY4gyA1w82KwgeFHPwrzxnemBAuIlGSbRPSaADvkAN4IgX7TmysA68xXsHq8ly/PLpsqmNuWAeDrgT3+zr+esQJ8b6+xAnaX4y0Bu1qtpr/zd/6OPvOZzyiZTOqTn/ykvv3bv91+/y3f8i362q/9Wn3iE594KAf7MMZbBXbSlxbc+TLp8g6T42JC8UBMugz/9FoU3suHhbIQAMDRaTEpM8GimWOR4DXz+dxMAbCAHqyhaYMRYOKlZOvF08Ph0BZQ3Indbtd0Y+z4PVjN5XI6Pz/X4eGh9X0F/MGapNNp1Wo1DYdD6znKd0FvBgvIOaD0xMIxHo/VbDY1mUwMRKD14xwBkFngRqORmSEAt7Bg9LRlke10Onb8nBPclAQWw2agb5JkOjCYcNpRhUIhi2NBUE/JFkav1WrZd8axSrkxGAxayW82m+natWtKJBI6PDy00ivXnI4yOJUBz8Ph0DICKY+SK0jvUXR7tDPzAyAA2OZaMCjxwphyvrkmy+U4P/g9oGQ+n1toNcxpNpu1TDocsdzXyA6QEvCdME9Q1s7lcsaiwrpxbZd7CZfLZXvPaDSqYrGoXq9nZWkAJs8csUCAa8qg6Ah92C/XmDZkwWDQSsHk74VCIRUKBdPg4XxmLul0Onb88XjcNnY8T16XSCg0OliYd8rQdDdBPsB14LpgrIFpZ+MKk0frP78xBdAt6/b8xtb/44fX5y3P58sgkPddvp9W4+0zVsDucjyUHDsEyMs7JNyMAIi3w3gYF//LAfyumowepJlbfg3/739Ofhy7eQAMO2CvaWHC8jtm/kHs7x2wMGxe+4ROjCBUJmoYLdp1AZoQkXuTAVo0dGvNZtNYImIqAAeDwcD+hnIp343jPT+/aNi+ublpZeRsNmuBxcR4LDvyYO28WJ/OGGSHoRuDIfPlN0qrLFCk+lOi7nQ62tzctOw1PgdQy+LHNQOUn56eWkBxq9VacCSXy2W1Wi2Nx2PrijEej81wweJ3enpqjIrfNHDuADXlctk0jpVKRdls1kroRGkAUgFZ6NEoPbNY0rTea28xdACEAJrEz6BXBOgCchn83ZsZnHskBwyyDXkOWq2WlUljsZhtPrifYFnX1i5yAAEdaA5xXcOw8uwVCgVlMhkD/IA8yudE0PA80eIOAwsRMzDEtM1jMxWPx9Xr9WwjgWkkEAhod3fXXu+BIt+FEj9hyeFw2OZJJA5IDACIAPn19XXTKHKteba5p/z5YyPH3ONLqF46sryhBcwtb3qvGsvg7fXm7mU270tdnVmNhztWwO5yPBRg9yiNL8fFfyPgJ31huz3/fldp6JjklgdghNKqByteOM2OHIBHeY+dNQwPg89DbwfYkC7Fz7wnifaYJlicycpCiE0IL0wh4A79GWwHJVTYMrRKgB1iHjg2Wo4BPLz7luR+FisiHfgcv/BKMlYEZys6RCIjAIa+mwaAdz6/bEWGG9h3HUilUraQD4dDC9eFFaLkBztSLpfNgMD5530Bt4Duzc1Na+eFUabVaunatWsKh8MaDoeq1+uWDQd4BpSSE+d1VrPZRVcJHM1o6+ifCmMZj8et08V8Prd4GUlWpicSBKDiHcNv1njlmVb/jCwPmFZKomtra1YyJtaE7352dqZSqWTALJfL2WtoeYZRge/P5wLOADxeq5dIJCwzDzMIIIINMll+HCvPiyQDmAQ7A8r5OUB8Pp/bZycSCdsM8fyQiwjTynUEJAJU8/m8hYHDzqLJi8fjymazC8dFlxA2U1wfNinMEQxAsNfC+krDstt1eVxVdn3QWAZrDzJSrMajN1bA7nKsgN1XaLxeyUh6MPC7SuDLguIXNHa7fsfr3xdg5h2sADkAHrt3gJyfkH0J1jvicMGiQ+L3fCauuU6no6Ojo4WJmkgPGCRA0GAwMAaMcqpvIg+wAUhSavUxDJTPRqORtSgDWGUyGTUaDdN0UXLinGKMwG3JecMBzHHCgkhSs9k0kIimi8WZ8wzr0mg0rDRWrVYtfwwWZT6fmxGFhRdQyqItXWoJKYVxbimBw3RMJhMlk0lj04LBy3ZlfBbnCw0gobj8jPPdbDYNIAGsvJua8jiviUQi9j3ZbPhYDc4NA6bvrQ7fl5V7kXtsOXKDe4YBgEfwj06T8i1RHufnFwHQPjsRsJvL5YxxG4/Hdp8B3Ci7ArzoHkGfXAAO+jaeSV+yJMia68kGihiczc1N21gRYUMrMMrS9H1Gy8o5oeQcCFy0RoP55VlhUFaldL2+vm5AHVDtN2WwmN5AsWyY4N9+c7o8vDHs9TbNVzlnV+OdMd4ua/vbYayA3dt0vNnF7Co9nY8akPQawEcpBOCHfo2ykyQra6Ft8UCQnbfXokmXRgqA5mg0MqYOdg4mjcUHsNjtdk3TRiAwrcqkS6DENQuHw2q328Y+nJ6eWgkTXRJMGaVBRP4wLDAPlFoRg9NGjO+SyWRMH8TigkOT1xAgzILEggaYIfiW+InBYGDnFTCNq5RsuPF4bG5QytkcH1EssIKxWMw0bPP53JzElPS4Jslk0sA17ln63+J4TSaTqtfrVk4vFArK5XLmrKXLA8wsrFun01Gj0TBgAEOJccA7sRHQEwL9eiOTyVj2GqCS3q5v9HcwtThxeWZggv0IBi+CnoloedDw7OD169cVi8WMyaPVVrlctjJ/JBLRK6+8YucW4Ef5HqBDKXg8HltrNDY7rVbLwI100ecWAA84h1HjurE5YBOYSCTsHNLOjM0JMgLAo2fPMAfxXPmuID4iBlDIvEFlAFDKOfYgz+uElx2uHqh5iQjjQQyb3/xyvRkrIPfOHY/K2v7lGCtg9wiOZdMEE6EvSXi9nGfsmKwBdPyO6A0W3WVtCgCP1wMWvNYOACctgknYGwwBlOQAYiyUOEgpj9ZqNdOWlUoliycJh8MWpUEEBxoyWnIBKGA9AK+Uec7Pz+2zeB/YIoArC9xgMLC4DyJYAHiTycQYQkAe2kGiLILBoAGzZrNpOip0hbPZTMfHx2o0GlaWxTCRTCbNcAHgBJTCFk2nUx0dHWlzc1ORSMTMD5xrHL2weIVCwRZQ716k9EtpkLIvZdJ+v6/T01MT+sdiMWNM6e2az+f18ssvm/aQkqHXhi0DOW96wKRBHh15aQDJN5quKGcCSADmkmzTADv4RoOuG7BsXFOeI541jB57e3sqFotKJpM6PDy07ho8A8lk0oDX2dmZ6U/paiLJGEQAPLrTfD6vTCZj58rnwMFIwwJnMhnFYjHbjAQCAV27ds1c19Pp1EKgy+XyQuxNJBIx0webIY6Te97rbinjMucQt+IdrrDI3qAEKGR+4r2Ya3itd/J7cLc8r/m5kffz8pVVmfWdP94Ja/vDGitg94iMZZ2d15xcJQzm/z2LR4nEl53Q5sDUUSrh733yPAsYzAELHhNpOBw2nRmLBIs65RjAHeAKrRZsEcweMSbohCg70mIsHA7r+PjYyoqAD0mmGeNceEDKAgI7kEwm1ev11Ol0bCFDNwg7BPPYarUs7oTv5NlJX+oECMAyAjppG8X/A1T5XAAyrBpAlFIZJSwvnscA4fO9yInzbEypVLJYjel0qkqlYkwlpTNKowQeEzjMdwTw1et1JRIJK5/iCEXnx3UgJgMWifuRUrnX3QHEvAli2enqTRIs9LTsInqGSBPYYa7TG42rXI+Acpgqjtm7QSeTiQVOA/Z3d3cNvBUKBXMH82x5xsrrYDGl4PblO+Pm3traslKsN7wAZAF7MHmxWExbW1taW7vI5ctkMuaCZbPmzSqz2czAHvcEbCE/w6HtzTP8Pc9ZKBQyM4efp7zLlTmEjRfMut+IedbPl+j99/ZlWL95u2r+9Mah1XhnjUd1bf9SjBWwexuPBwl7/ST1oMvn2TiACD9jt83rvBHCOy95vY8yAUD5frEsJjg6WVRms9mC4B9ROKPT6RijARvR6/WMneKYYdfu3LljJUz0Q16TQ/wFgngy8mhID2uFW1CS/T+gFPeqB7aAzmAwqGazaXl7BN72+33rzDAYDAzIUP6jHA1wxFUoyUAsOWAYTQBQgUDA2JfJZKJXX33VALDXAHIN0XJRNvMRNaPRSEdHRxZjw/UDQFJqZqHnPWF60JlRbsS8cX5+bkyiv19LpZISiYQODg6sfAx7Q2u3q+7haDRq5f3lQWYa55LSM9+H87cck+IHYNqzdgCdra0t9ft9xeNxMwqEw2GTBiznxHU6HUUiEd24ccMiSjCaeE2Y7/lKuZoNBowYjmuA23w+N+0m+YQwfDDAsIiZTEapVMquy3K7stlsZll+aEzn8wuHMmCL4yBQezQaLWRDsonzESZo+XypFYAO+ytdAnlKw76C4M8PP/dSkuXqhJeRSJfsnWdQH1RyXa52+Hl1VaZ9tMejtLZ/qccK2L3NhmfYlieaq0oPyyUGJi4mVl++YgJefg8WUUogvC+TLkGr/D/Mje8xyd+y2MMowdJQGvSvn0wmVoKiNDuZTBaarqdSKXW7XUvNh0Fg0fG5cfTWBCQR/IuAHMACo8h3xsxB6ZLYDq+5g6EBnNRqNZ2cnNhCViqV7LoBojBKwHrxs/F4rFwut3AOKbNi+CDKBEaLqBGfH+YbskuXuivaSXU6HTtWIi0I5SWPj3I0IJpzOhgMlMvlLIsOYE/Qcq/XszgQdFa+LEs+3VXALR6P231I+Y1gYDYEsDY+Bw4wAVigTMuAJfImieUBUwtbBEgHtMDuwagCmAg/LpfLxqZyT5KjRtk6FAoZ+CaWBvdxLBbTzs6O/R1aQ65Pv9+3Vmh+g4M+T5Ldi8SwcP+QH1ksFm3uoBxL+RyDB/cJ5+Ts7Mx6JK+trSmdThsIh+UGTHvmDfDoTS7cM1wT3oMN4Xx+0TEElhE2n7mMUq135PvPZEPiN6p+LvTGJxi6B+n03oyWeVXGfTTG231t/3KOFbD7Mo7X04QsDz8BLTth+X9AnGfnvD6F9/ElHxZOXs8iCjtFKRGWD1aDBdNrYGAycFDCmrHbZmGmRMWiD+ODWQBww+eyyLED95qo+XxuwA/gNRqNVKvVFspX6A0pcUmXoneyt1goWGwoA6HDQgMII+XZT/RvxMWEQiHTcAUCl/0wOaeUlAG75LLxOhjDdDptMRbj8dhMDThNcVYWCgW1Wi01Gg11u13LhoPtoek8rB26P4Ati+90OlWz2bRzR8QHizXADYBBeTUYDGpra0u5XE7VatUAtY+tWB4AoNlstlBe5zPC4bD29vZ0eHhoWjEiQWCLyeTDqCPJGE6uNe0N2+22stmsgaxWq/UaswD6w0AgYKwxOXTcw/St9SVUHMhra2sGbmitBmu7tramXC5n9xffnSiadDpt4AWQBWOHwQb2DYcx145YE54DmHD64nKPsgFKpVJWyh8Oh5pMJkqlUsrn83a/eZBKBh9zDWwkDCESCkA6x+03hgBoqgJee8fmi2Om5MqmDwBOeRYG0oO0ZZmJZ+GY/7wchf+/CqgtR0b5+fdBc/Ty61bjKztWwO5yrIDdQxiv9+D710iXDMby/zP8/zMhra1d5sqxqPrdqLTYisyDNv/3vlxBCQ2g4nV6XuOCgQBWh0WKsiSMCi5QDxxZ3HE+AnRgaXCIAv5ms4vMrEqlYoYBACfsI3lugErPeEwmF/1ifdmG80DpFeADO4cJA+B1fHxsE/xoNFpgRiRZVwLpIssM0IGGDAA7n88t6BWNXbPZ1O7u7kIpDODo25v5DDzvagSIjEYjA8H9fl/5fN6Yj0ajoU6nYzoqSZYJx+8p+9GfFsAOQ0jWHUC9VqvZvUCJkhIygIQFFy0gkSmU7QAzfgDcuKe5XzCpdDodY4G5htlsVo899pi5m5vNpt2XXBNK67BC3O+8XyaTUb1eNyACIxYKhaxLA6wRcS+JRMIyA8fjsfb29ozVBGw1Gg0lEgltbGzY+RoOhxb0Wy6XLUibDh++NR8bB/SCaEcBzBwbbH4+n7eYHkAm3xVtG89iOp22jhjr6+vKZDKv6aELmCJ2BSYT9y45i4QOM18A5tE1ejmHj77x2laOlw0U7wNzDNDDXMU8slzy5b7zQG65XHuVBtkPzwByv/h71esi3yzjt2L5vvxjBewuxwrYvc74QgHb6/2NBxvLD/2yw4sJ0U8ifnEH5PCPn4wQwy+Xcvk7H7rr86RgYjwIHI/HpjMCqLGYh0Ih640J48DxESdCSc+XQbx2jkmR0tfe3p6xcbBf5J2hxaOTCf8APNvttiXhwx74893v960cTInUO1nJuAMU0DUFUBcOh1Wr1UwzyD3EewIUYZ4ojcGkBQIBC0XmPTlXg8HAGEFYH8rFnF8AFYsWBhGAMuVBSsUwkoDgVqtljB2OVspxnqkhV4+AW8qtuKZp68SiS3kPsE6PUzYaMKAPKo0uD1hEriEdHWCBz8/Ptb+/b1EtkUhEGxsbVpqmxEpMzHg8tvO7vr6uWCxm93+73VY+n7fngqiZs7OzhU46165dW2AwKU1zHmCgAaGBQEDXr1+3oGv+IToGIA4byP3Fs8HmCobRs46Yebh+lF95vsLhsHZ2dkyHR+D1cDi0cwU71+127TgoIfOswqrhSAeUcY+ibyRXkWcappP5ixK1Z/zZAK6trVn5l3mQ50+S3XNeh+eND1wDNkPL2jveg+PxeZpXsXPMwcu/93KWqzbiV2n0rpIgLH/eajzcsQJ2l+ORBnb/+l//a33kIx/RD/zAD+inf/qn39TfcPEJt3294cHYg8bybtA/6MvmB/7tf+7BGZ/D5ORLhfztVWwcoIvJl106zNFytANsyGw2s0XbM1sAABYbQlNhQeihiSmA4yNqBIaG70WpLJ/Pm+AbsTR/P5/P1Wg0LH9tbW3NNEUscl4cPR6P1Wg0bMGCaWCRgbkCgMB4+HMK20T5lJIn3x2B/Gw2s+Pl+2HKoKQMkOH8eZ0YbCKgkM9BGA/jEg6HdXp6qkgkYq3C0LQBjGDp0LkRyQHQobTd7XZVqVQ0HA61tbW1UGrmGLlHMUUkk0nTM1JSb7fbpv0DcLAhyGazxprw3U9PT+18wbowAE3eZLE8MJbE43Fjq3APx2Ix9Xo966aBdgydGc8qjCxAFaaO4/aGAO6Vvb09NZtNlUol9Xo9STKwDZggwDeXyxk7xTmh/RosZKfTsft1a2vLnvtAIGDfByaIlnY+1xGw5aUSvB/mEjZHhUJhIUrIR54kk0lj/mq1ml2PUqlkzyngiNZ8APZCoWCmEc4VGyueETaIdOdgToPR43lFXwh4A2R5M0cgEDADF/Er6Po8Mwd4ZAMA8IN59OCU33GP+g0ym5FlnR73kZ+7l1k9PsNvyJn/ea6WARz/vyytWf6c1fjixgrYXY5HFtg988wz+o7v+A6l02l98IMf/IKBXb1ef8OL7x/eNxo8kEz2D/obHngfleEnF/9vFgsmXv++7FB9eRagBsPGAsfCTynUa1KIKWAHTdcDdtUcGzqo0WhkZUMfHsyiQlZZJpMxNo0JudfrWdnm7OxMnU7H3H6RSESdTsd0d7hO0aKR5D+fzxfAI8wL5SofURIMBs31xzWnfAzoYnFAMI6+CiYLgOpL1pSdMRAEg0FruZTJZAxEck7oaEH5E5BCf1f0T74US0AwcSw4Kbl/aWvmHYn8jW8PReurcDisQqFgn8H5jEajZnrIZrMaDAY6Pj5Wv99XqVRSKpVSr9czhy/tsJrNpoG/er1upbqzszOVy2VJMkYI4wDlRc8kwjz5vLdEIrFQWoepQWdGLAiMJ8aG8XiscrlsOk3K05SleU54PfdjIBCw/DnAHE5UcgKbzaZqtZp1K5EuGKTd3V1zqnK/rq2tmXkACQNgHXYaoMicJMnKnOl02sKdedYxF3E8nKtoNKpgMKhsNqtsNmu/Ozg4sPPFvZlKpQwwMUfgagWwwfZSsqfkiybOSyLYKPDcwRyiA5W00JIPLS2bL4Cgd2UzN+CaZg7k2JgrKOny+dJlBuAy4PLuZEAZv+e/pUsnrn+m+P0y4FqW01xV6l0GcH7jf9XrH7TWXFUCXo3XjhWwuxyPJLDr9Xp6//vfr5/92Z/VT/zET+hrvuZrvmBgx8X/Ql1RfnLj//0p9CGby+2QlndkD5oIeC0TICUz2CRAliTTtFFy8cCS3aUv6zIpwl4R58B79Ho9A538rQc2lHK9y5PSFIs4v2MSZYEAYCDmx/hA2cfr+QAl169f12w2s2gJL/jn55JsIffOQ1iy4+NjKx/RUJ0yD9crGLzs+UpZiuMhfHc4HFrAa6PRsGBX3o97ghw1Fm8CjhHYw6x55yfMKgs3kRmAt3Q6bcwJhgrYTcAprlCYMu6f9fV13b1710BpIHDRDD6RSNj96DVqlHUrlYq9PyCe0h/niLIrDOi1a9fU7XbNGX379m0rxQIEx+OxUqmUacG4BtLFogpjRikYIAe4oStDu91WMBi0UiHRMrh5PbPl3c1samazmYrFogaDgYFh36GChdaXzjkfMGsEQvMsUKbnucbAwDnmXl9fX1ez2VQ+nzdTA880LG86nbZyajqdNqDLOZzP5xbrg4Epl8upXC4b4+91ZnQqwXR0fn5uQJLPZN7xDDYlU4AZP+f+ZJ6hfE3ZG+0qmkzvtOWYKc+yoZxOpwbWmD/4b17PZ6KX9aHIfq7ju8MmelMXQH8ZbPnNNSVhP3cjc1leHzyz+yAQuPzPVYO5yA/PFC6/91VynXfrWAG7y/FIArsPfehDyufz+vf//t/rm7/5m18X2AFEGJ1Ox8ouONeuGiy0vnTqtWIMJjlYInRGTJ4wCd61BUOETsyXYGE9wuHLZvRMYj7ag44HCLxhNZiwOC6aibNrpazGAtdut02j5jVR6+vrViLhGHzrrXK5/JqJmHKH13gxUQFaWq2W7t+/vzCZwmBls1n1+301m01JFxPaycmJTaYsvNKlwxWBOoJ7jr/b7ardbiscDmtzc9Py9wBZMH6cczRM5XLZukNwbVis9vf3jSHh3oKllLTQuQNQVavVjC07PT1Vs9lULpezwFm0YXxf6QJcsThyrQEuzWbTWCEiZdACUraULtu7cT9sbW0Zs9TpdLS9va1Op6NWq6XxeKxsNrugZeQ8SzIxPc5dvjvD6/bq9bokKZ1Om6sRg8r6+rri8bgxtX5DQumRUN1sNqtms6lOp3NlJl0gELDrinYTgMDkPplMzBnc6XSMcYxGoxavksvlNBwOdXR0pPPzczsuXLj0mJ1OpwbYYMnplILZAtBCWZTOHLhoiaPxZh6+i3dbDwYD64VcKpWMTc7n81pbu3BEc+2lC6bWywFg57kuSCAoA8fjcZtvvNEpkUiY45bnQpL1seV+9Pd/vV63TQabp3w+v8DaNZvNhagWtLG5XG5Bn0c/ZphuQBfXgmfg/Pzc7kOAGJsfNmSwpr7TDYweDCMbUl+Z8DIW5hkkHhyTN6r4wcab4/Es3Zth3JZJA/+eyyyjl+BwPZg/OAa/tC+7ft+JYwXsLscjB+x+6Zd+SZ/4xCf0zDPPaH19/Q2B3cc+9jF9/OMff83PAXavt8vxD7ofy1oJz4wxsfI6vwsEJDLxMMl4jQcPKzo33tdPPpIssgCnHgJlyhswCgAYr3XiOJgsWQRns5kBMsCUL/1KF+U1wOEyuCCqgz6kMAs466QLNqvdbqtarVrobTabtVIPr6VPLIsRoAlBPKAOUANTtbZ2GVRMWRKGAKDGzt43aueawCpKWmAmKJfBCCLCp9RKqCufB8uay+XM2OHPP8fgr6kH+a8XsLsaX77BAgHQ8fpAZAxsiHxAtSRjyQAjPOM4Xyk7wzi2223rSwzbC8sEsAa48EygK2N+gQUGRAP2YefY1AFyKTkj0yC6x5saPGsfiUQW4oZw1TLHoUNkTvHGByJTYEExrWCwYkMMKETrxzEwmLN5TnlmKFWzoUDOwYYXcxHnz7N1zHUAN3Snfm3wJVH+zicUPKi86smBBw1+v8zq8f5X/b1fu5bXsXdj6XYF7C7HIwXs9vf39YEPfECf/vSn9dVf/dWS9JYZO78LYjwI7PkSp/T6WXP8DKDmQaKf4H0gq6fyl8sFAAGfm8bfMaEgdJa0UAbmeJjw2BXClAA0RqORlcYAi0yAuCYBipTa0IgFAgEdHh5ayRFmwJd9PftIy6tms2klxVQqZcDP70Y9e+rLl2dnZ2q1WgvlIx/xgRA7EAhY2zDeF30V78fix/9jmuA4WZin06mVY2E6GV6gzSLsmRk/WDT5u2WDy2p8+ceDNE5+ZLNZK9n7v4E5hAlig8EziL4NzaIkA1Y844A02EHY5VwuZxmI3IfMF/xDuRYQQ1UA+cH5+bmVXJfL95TaAZrME5KMbaYcyGZqNptZaz/mFww2AGDAJLpMjh2w5sEqm6/5/DJ3kjkINhhWXrrM5wSEMScyxwDQpMvNsnTpjqW0Djj3myqeYR9z8qDxICC3/HO/cfc/9//Pvz1Q5P+Xy7Or8dqxAnaX45ECdr/6q7+qb//2b1+4yWE9YI/e6AF4kCvW74jYyS0Pvxgz0TGueqCvor/5Ow/2fDkATYhndZjIvXXfv4/v6OD1GNIlwIPt4jxRLqQsQq9UJljcpr70y/HjMuX90cxRsqQcyCLF69iVw7bBStCAvtFoGHhNp9PWcN6731icYOfQCnW7XdOHEdgK88E5JK6DcwlgJOmfdmXcU+R4wX5Op1O1220rV34xA0C6Go/mwCTA/Qe4IPIE1hrmWrq893nu8vm8mQpwgM7nczPYAHS4hz17Q4nd6/hgzz0rCHhhsxiPxxc2cejzMKdQaeB3RMxgwMD4w7FEo1Ht7e0tBJhzPD63Trpk2zBF+Y0Ymz7vbKbywHv4Urt3rY9GowUg6Bk+by7zm1+/WV6uxniQuQzyPcC7Csi93lgGb1f9/YP0eavx5scK2F2ORwrYdbtd3bt3b+Fn3/M936OnnnpKP/RDP6T3ve99b/gebxR38iDq3O8oeZ2n4b0mxL8Hk5oX3zL4/TKDB0PHLpSdqJ8cAHdovvzP0LTxXjAE7M4BipRBfDkJgTk6JDK4ms2mRWW0Wi31ej1Fo1Fre5RMJhcMGQjrEdXDJPqJFU0iZWUmfMAqjBsaEzLDvFOV78a54BrjcByNRmq32woEAgttmTguFjG0YOjEcNlyTGdnl90XEomE4vG4mRg8U7oa78zBM4qDuFgsGiCSpMPDQ0mXTlXK80gF5n+mxQyFQtaPNRAILOQITiYTFYtF08ICWAAy6XTadK4AAUmm6/X6Ty/98BtIypcAP46PDRuGDYw6GEk4bm/OYeMDa08JlfnQly6j0aiVYZEzoHHjtWzS/DEzZ/rNHK8FVHvmzW+qvd7YlzSZT7z71bN6vGYZZPHe/tz7v/P3itfsrdi3L89YAbvL8UgBu6vGG5Vil8cbXfxljQPDA7blUqsHXMvM3zL4A2z5SYiJn78BxDA5w275forsXv3rvc6PnT7xGpQOCVr1btper2cTIHEpACfyzdiRU4qRpGq1am7Wbre7AC4BrXQLYJIdjUYW1OuNIrhz0cahMYR9I/bAl5xZ8Cilttttm/Rx9/pyND1Sp9OpZcf598bVl8vl1O12F1oqERLLIkxsBkYM9EJ+sVmBvUd7+AiXBw3K77hbu92uRad4tyos1/n5uUWMwNT4NnBs5nD++jIl4ch0kJBkOjreC6YL1p3cSOYSWnN5RioWi6lQKNicQfQJzyHzBho7/pFkWjTmFNhD5gx0bmhY+Rv+G20wcw4aQN6L7+8NWpIs8si793kuAX/M0/yMv7+qtLqstfPAzZdoH3QPMHwlB/B4FQu3Yuce/lgBu8sReuOXvHvGcmn1qp2VB29XgT9P+y+XWpkwPHDDMeddTp6eB7ih41nW6/nMNnam/X5fjUbjNRMcLk2OlfIirCAgi/dnsqR1E393enpqkRiz2cxKmX7ynE6nikajKpfLOj09VbfbtXgTQJXvQ3p+fm7xFejbpAuTCzo1wDBidHp4AmBHo5Hpn9D7DAYDlctl0/FRCs7lciYKj0aj1t5pNpupWq1a26VqtarZbKZ79+4tAHFvbmDh5xwu7+AZLEScb5ysK33d229gAFpbu8gmjEajqtVqC+VMpAG4jYlv6XQ6Fo7tNwyAfeQLuVxOk8nEcv8ikYhSqZQF8sJs8feAo1arZexctVo1Vy6fR/xOoVCwTQatzxqNxgJDz9xUrVbNwQuTjXkDcOW7UwC8MpmMxbV4dor3lWRGLd/lhXmMEi8pAmw8yaiDsVveNAKSl0Gqn3dhMj2r5hk9riHzMvOLB1x+U+41e8u6OEk2//mxvEYwlsvA/rMe9P+rsRpvdjzyjN0XOjyqh3livJGT6EEsHoOJ1QNEv3tbnjQ8aJMugQGtiwBe/r084GR3Dxj0CfgwCRwT7lU+U5LlznnDAO2XiIPw58aLmwFpRGpMJhO1221juebzuXWG8JOmZ/L8dwWU4lTlZywuBMfC9DG5n5yc2I6e3DKf+UeEBsJzjBC4AmFVANkAQ/poLjuKJZlw/UEgjuvA67hGqVRK7XbbALqPbIBlXYG8t9eAfSKwGUabDRH3JACD8GEPtti8EAadz+cXyrToUnGrwt6x4QAAUT6lN7IHfLBbHFMwGLTAb/SlkUjE4lvoGkJGH/cjzy0MJPNFoVAwTRxgi3MhXYJS5gyikpb1csulUw/KKLnCivsNLIwepWT0wX4u9IkAzJUeXPI7/76eBeTnvCcgzc+5y3O4XzOWf7f8+zcay+vLg0Dh8nu/Gx2wV40VY3c53rXArtlsKpPJPHBHdJV2YvnBXabmfX6Qfyj9rpD39eG3Pk5AuowG8JoQXo/+zDOHs9llTAnlGJg6zzAA+Ph7dDTebccueD6fW3kFcwUN4QGKLCjD4VDBYHCBbaTsQykLvR7GCj+pL58r9HaEFNN6iwWI7wVY5VxhAAE8AqiazeYC+whYhpmAvUwmk6bT43qPRiMLRSaP8CrzBOwkxw/IpOPCVcMLuh/E8j2swfFIlyUizsdqfGEDAwVGnrOzM9XrdeVyOQsk9prPQCBgm0gCkbmfiPdAl8cAkG1vb0uSMfto3ch8o6sDmwzv9PbZdjhLyUck0sTrYinH+jZ1ZN7xnTA2ecMDc4Zn1ohbYY7wLn3y8pj3AI9oWJkbPLNNn2T/ezaV0mUJ1OvxeG+uAXOpj3LyeaO+osI84pk1P4dLMv3vVcaKB2m1H6ZJws//bzRWOXbvrvGuBnbLF395IvCTBjtz/6B7Kl+6fPCXRcv+oQe8ATQ81Y+ujNKijyZhp8vEyT/8DA0ckxTN2ymtBgIBay9FFAhu01QqJUmmF5tOp8bczWYzS/wPhUK2QFH69IsRjJsHoOPx2LKk+D5M4GgG0fl5nYzfxTPJA15h2Tiv5Myx0NCvFHbPL3jJZFKJREL1et1AjY+gYPGgxOwB8XQ6tdBZ4lKIfoBdRScFgP1ixsMCeqHQRd/V8Xj8QHC5Gm88stmsAX/uR5hpNke0kINFh0FGMwaYkC4Z3fn8wpkKExYMBs1gAAAhrgnmy29mMDwQG8ImDhB3fn7+Gser18NxX2OC8kYhsinX19e1s7Nj8xabNNqhZbNZm0fZBAIoeSZgrSnvemkIrBtMJ/8Pqw8YA5wCojBy+GqFZ+p8VYL5hO/lASImLekyCsUD8mXTBWsCm0HptXmny/o+Xr+s2+M4l/XbXwoA5tepBw0vAXoUxwrYXY53LbA7PT21XSDDP1SewvfCZCYID/L4GX/LhMkEDTPHe0laAIP8jWfUvEECkMCOlL+hbCldNCynbdP5+blNoL7kx6TljxNWjFZD3W7XJlm0QxwX+rRlfQgOU74fABNmwu90KY9QooVp4PP43r79ki/rANQwS/Ae6O24prh96dYgaSH8GI0NCwZdFSKRyILGj2vo4yn4fpPJxPSGDyqjArgBu4jZMYxw3/nzSWL+wwoppiT9RkaAt/tYPk8Pe3A/cJ9dNQBcsHaUKwEL/X7fQF0sFrNnBcaZjdXm5qbpSaVLUEGA7tnZmXXN4Nqdn59bcLCfCygZ0kMYUJfL5SziKBAIWHnXt1pjDmCTBZDx4b8ARJ8nB+smyTplAEyZC+jywfv6+BNkCrwHz5cHnByDl6UQ9cI8gYHK9671+jzuGT6Lci3XWnrtfeX7aXvDBwCO8i3XdtmQ4YGrn+f9xv9BY/l1fvPv3/dLAb747DdiAP1nv51A4ArYXY53LbA7OjpaCCjmZgZoeCreU96+HMtD7XdeHhDwYMPEMTkAlihnMmkhppcus+ooFwIwmJz5mY/kkC60LWSt0dmBDCtABscjyeJLAoGAibY5D17TB0vhy63o4jAyoIMZj8cLzdt931jOC4GolFwlWcsvv+h4p53XzVDWhU3hsynbUgamAXomkzEdGzttQCrHns/nNRqNFpgCtH04aSWpXC6r2+3aQoLmMJ1OL3QEmc8vW7V5XdJVw5exGD7SgV61HLMki54YDAYWOwMgfDPlmTc7Hpb2761m+L0ekwl7Q7mR+5tyYiwWs/7CbzTQuuHSxh1O4DZGIF6D0aFQKBiTJmmBnffgngBvb1xKp9P2/PFd+B4+UJdcOVhAgA0OWLSxbGAGg4G5dNH4eVMEAJNnaDweq91u28aJzZDfwAIsYAtTqZQx6Mw3vtzLz2Ey53+mmWMuZcPE9weAwR6yqUSX66OKYAM5L8ylPL/MyzCnHlTBEPKZfm5fLqX6TStzsZ/zPQPnY1OWP2/5Z/zcO4WlxXQGzwD63101/HtdBSIfBiPon6EHHcuX6rNfb6yA3eV41wK7F198UdlsdkFndRUV7rUJ/lRxcwPAWMx92Y5FgUUbJgwgeZUGw4Mm/pYcOF/m4D16vd6CbgzQx4QfjUYNPPJ3dE5gUiXRvdlsWhQJ5Umvx/OdK9jVwjQAfmAcvZgZowF/DwCTZIwCZad+v29/y3mnafx8PjdGDhbEL5rL1yAQuAxWZjGu1WrWx5NzSUgyGj1/7JS+2u22stmsnRMWV0n2mbAtodBFH1iYPe+G5Tv0ej3LBmRRASAEAgGLy2DRb7fb5ib2YbB8Lt/5YWXqPQjMAc4AFg/qrOEHDFgkErF4jkQiYecW9tKDtkDgIrzaR8683qCZPcAaFyjZi4A+3KucP0A5AB5AAsOWTCatPEoPYZ8tCVDJZDJKJpMGWPj9bDaztlsecMKew7p79ojSK88lblWuh48Wmc1mSqVS9vzw3BSLRZu7Wq2W6d28WYC5gvsnlUopnU4rk8kYu8bmk3mSCgD3R6vVsgpDuVy29+L6Agw9A4XxAxYQoEjZ1JudOFej0ch6YnNuYNoBe143x7HynSm5shmbzS5dwRwfzyrn0DN90mW+HddAWgzI59xSOvYMnweMzM+8J8e6vBT7zay0WOVZJhQ8MGRTfBXD7YGpX+cexLwtM4VvdlwF+K762Zv53Dc7VsDucrxrgd1zzz23EB66zJZwWmBAWBz8wwPooQzLpMbuFeDAYsOEBchhQfeLGswbOjLKibBdaNjYjdPg25eH2TFTxkTrxqQcj8cXxNCj0cgWO4CDb4KNccPnYTFpMGnBTjAhU/ppNpu2c+cc+tL0MgODWNyXiZgoAT78OxgMWpmGUg4Zdp1OR5PJxMqzDEpaiUTC8vu8BsmXw9Ht+PLUYDBQt9u1DheUvUKhkIE/mEHyuCghwR76SJxkMmkt1JLJpB23Lwc/7OHLUIyHwcrByrCY+sw1FlbvbEQbmUqlNJlMDBh7+YB0yWZKF+YD9LGALBZoAMV0OlW1WrV7C8Y2FAppY2PD7j8YcErtOzs7lnPozwUSjK2tLUkX93ij0bBS+sbGhobDoY6Ojszx6h2lsEKwt/F4XOVy2cqWaF8padLii3ul2Wwu5MYButDlkW/HsypdykGIY4G18mDDA1yuCRsFwALPAQ7cbDZrYGI+v4hAyWQypm3d39+3DR7uXdg4NgOtVsvmUfImATrhcFg7OztmxmDeY37lHmEuhNED5AD2AGcAR0AbphUvw/CaXQ+KYMxhZaVLaQaf6SNQmM986dmDGc/AcX2Wy7V+M+xZQ18Wli4BpX+Ol59pz1r60jR/fxVRwWuuKvcuv/+bBXqcj6vGg+Y4f97eCOTx+xWwuxzvWmD3B3/wBzb5ehaNiTYQuAy99OwPC7Vf9GezmS32koyx8ztEX5aNxWILDznAodPpLOjbmGBZ6GAd2G1KMpMDpVLKir5k67+fB1X+eCiZsjtm0iOGge/F9wCkkoTPP14szKK7tnaRveXPAxMikwMLf7/ft56xlLXI/vILNXEoXpcE28EiQORDIBBQJpPR2dmZ+v2+RUikUiklk0kDhslk0s4jMRTB4EXz8FarZb+HMQsGg6ZJxEzh2VEWFF+GIqes2+3q6OjIADQL3INKjZ4t/WIGuioWskAgYFKEUCikZrNprAMAHoG8D6x+vVEulxUIBKy3KGXRTqej4XCodDqt/f19Y6IoG8Iex+NxZTIZlUolnZ2dWR9egACsGOdoNBotZBoGAgHLHczlciqXy7aJ4TkcDofGIOZyOduAAGBgwCnZE+sDQ0sHBX4Gk+f1qxxLIHDRQYL5ApbYP8sAL0AUoI5n3y9waE15vubzufr9vn0uf8MmBMfsYDAwxg7WVLo0O/GsAor4DMBROBy254ge0Nz/MGh0nvBRQLCgvBa9LXOXd9bC3GNM4lzDjnKdvbvWtyED4PG+/u/ZeEYiESv7Aq4AON6EwTnk+7MZ5B7y1RBAoC/J+iUVcOeBki/5+vmfjTb/7cEXIHdZy+cBk783PIDzkiLP1nnw6FMKPJi8ivVj+E3+crnYH6OvUH0hLJwnEDiHDzoO6aIqk8vlVsBO72Jg9xu/8Ru2QPubn4cVrZsveXl323JcCYALsCHpNVoPHk4mdsAU5ZtMJrPAZlBapM2Xd4T6XDcYBz9hMjEARH2JlBIsk5vPiPK7QwAkDxYLFRo4L/Kn9RCTLmwkZRoYEtgrJkZcpEz4ACsmCwAz18ZPTD4jDLAkXZgPeLDJ5OMcI3r3pVdABTqcaDRqJhSuMbEIXC8YNQwc0uXki4YKNg+wCfs4GAzM0FEoFCRdRtxwz2Bm4fx6BuuNhp+MfZgyZTCAqwc5pVJp4R5gocSEIslA6WAwUK1WMwaHJvMcp2+wznfnOeG8EAtSLBaVTqfVarXUaDQkXS7SsVhMuVzOziOfzX0J64qDnM0WGxOYm2w2q0AgoGazaZsmAAPfbzAYaH193V7rwRfAF+cr7CLfw3dNYM6AGYL9ns/nVoJm4SSYl8gR/i6dTtvGIh6PGwtI+RW23rP0vBcRPzyLPL+4evkdx0HXB+YR7kFKomtra3bdub99DAogDqbTA0sqBzBpbCJg3KlwwCBy30iyPErmTd+uzG8e+T3g2G8U2SgxJ1P653jI5Mvn80qn03bvACK8qYR7i/cDZDIvAHKZVz145J7w/++fUX7mc/mW9XZ+XvfzK7/n/vFAjcFmmvPD2uOBnAebyxo6X7XwwGyZ8fOff9Vc5Bm45e941Vhm7F4PqsznF3rmUqm0AnZ6FwO73/u93zOGxzet52ElAsQ/xCxOLAz8vySbCJi02WWGQiFbfKRLut1nnfkJggXd7/784jCZTGwH2Ww2bSfKBA+7BpjhuGEkEILzXrAkfA+vUZNkDCaTCsDXxy9QGgZorq2tWZkqnU7bJMvi0+12bbGnfRfMH2UrFgC6aLDwMpkDwPh+gE5Jxn5wPmjMfnZ2GXjc6/Xs/SivUpoDYE4mE2NUYPoCgYC63a4xdOzqAdLJZNKYU3SBHN9oNFrIk8vlcjo7O7syF+8rPTwglC4Z2Ifl1H1Yw3c92N7etvuejQcGGs+EsujhMoWFY2H3oBo5hC9VstDh+j47OzPNF/EfGC94bjudzoIrE3DI80QuHWATJp2KQCaTMdYKcOU1aegUAXuUHiXZpgmQByO2trZm7Fs+n1e/31+Ixdne3tZwODTJCnE/nDvuBzSAACaYawA3cxjzWzgcVjab1XQ6tfgkNMTMIbPZzPrmMhdGIhHl83mrDPhr5bWnsJVsUmCM2FCy2To7O1MsFrNWhDiGk8mkddRgHmBDzvzDfMJGzzNigEA2H4RRwwJKWthwY17hXmL+xVXMfec1h4BEWHTPjMK4w1Z6tov7h9dSXfD6Qc4nDCGbTb/GeBC6zFTy3vxOWoyO8YCW8+lhyDJo9f/491oe7XZb+Xx+Bez0LgZ2v/Zrv2aLtr8xudlgBtiFsYBzYy47D4kagUkaDoe2KAC8AHoewDBxwW5QVpr/mYbEvz8Mly9pnp+fLyww7Izj8bixY7BPsH6AIQAZZRaOBW2gZ9K89ozFjfLospbEAx0WR/4WLZp31+HSRfRPpAHMlQ9Q5r1hLDyj9DCcm1cNNEKUy1djNb4cI5/PGyOGjg5m0rNTRKAAymjfxeLMQuhZeLSdaP5g8WHYeD5h3pj/AHdIHXj2Ydxg4H3Z0Zc3YfA5Htg05hMcvbjdJS2AQy9fYWPF3ORLx8sSCKoAXqvo243594B5Ys6hGuH1av6/mR+8NMfrqCEH+Cw2R/zMawL5e+Y0Xyb2oMgbNHgNwMmXdr0W0Jd5GR74saFmsB7ymZx3/7f+v5fZPA8t3ohxk16r8/tCR7fbXQG7PxvvWmD3B3/wB4rFYgYGYMHQjFAW4CFlZ4bea7m86newAC9AHJMKJoXZbGalCyZSH9rLTjKTySyUMwFVHKufvNmdUfoClGE2YMeJHs+L2Nlt+vIpYGo+vzR3+F2bF//yQMKq+dw9r/Xg+PgMwCOmCrRL5+fnarVaBggp+3D+MZCwC2Yy9xonv8v+UgG+1ViNhzEAE5RkWVy9a9Pf38Ph0MrfACM0jTh4yZzjWQZAeO2uZ/XYePJ+6IB5HpmnCDL2GzzfuQGgw5yEXpBnl2qFZ52Y09B08rkAVphzPiuZTFq7P4xQHtQA6LwUhuNgjgfscKzLWjdJC+feA2m/mYUhZaPt9Zq8D3OzL2kyYKy8Pm4ZkPH3HvAsM13LJV7mW37nHdHLOj3/vssa3zcCWcsA7kHg7PXeh+/yxYA5P1bmicvxrgV2d+/eXdC28JACwgAGy0yef8ApOXLT8jChUfFaG/6O3a0v8VJeBTSxQ0eY71tdMSHzEECn+3JDq9XSYDCwcgQTPzt1gNVgMLAyK+UELxLmODzdP5lMTMTNbhR2kfehnOTLDh4MSjI2EsA4HA7VarVM68PkvNwjkvdhl4sOkXNKnMUbCf1XYzW+1CORSJhOlAHwYS5hE0KpE5MG0g4W4lwuZxs8L50go4/nnI2Qz5/zoMJHBLGgwjZRHqY8C6BB4yhddpeAKeMzlg0AkhaeYeYs9Hr+79ikUZqWtFAiLBaLdtxojCn58p28c5p5xutm+RyAB8DUs4ucD3+OfNmeecnrDxmeDaVEvgzCPNDzpgoYPA/E/Nrjhwd9/A3rDkDbM36cw2VQyN95NnC5xPlmmLPl17yRbu5LOVbA7nK8q4FdNpu1h4ddsgcxlCuXzQfSZRo6pVyvsWDHtLyj9i5ZgAoPGJMgZgkmIdhCXGPowP7/9s41Rq7yvOP/2dnreGdmZ+9rY2xc8A0BSROwStW0BKvYimgiUuFULsFV4kTUuCq0jQhtAq6qYtqIRCkkfGmwLDU0/VCgbaS0qouJkhCgQaa4mDSGXXYN69313mbvt5l+2PzefeZ4116D1+vdfX6SZXsu57znnDnP+b/P7c1ms0F4STP9ppipk8/FzH5qaipU6JHzRQ4JuS825NHX16eRkZHg8SsrKwtFHIRQhoeHNTw8rJ6enuDmt0aG3neSwnnCa0mogkpcPKSjo6Pq7u4OopdxE9623jcaL5OMzYy+tLQ0NF22YQfHWWhor8Hv177O/UPuH3aA6uFVq1aFXDTuD5s/S4EW+V3c54gJJl52IkdeHfc6Hh3EEJ4tbIsNcdrUB/5vc8IQL+QCkt9licWmixMIr2Iji4tnmjJzD2ObbPGBbReEh40iNjyPfAZhwjalmdxnzgfXBjFsPXY2pYRzKKlAmCK4ovtCVLFP/ubfUTsUjXpwrrD79tzjceUzVvTyWevdjYo4rk10DLw+F3PZzvcbKl1I8r8snvCq2GlWrLBraWkJoTxJQZhgRLkRrEfPVn7yhxmkzQGTZmaE5KtZN7wNj9gZlU3Gx6PGrI4EcAw7uWrZbDZ41fDysT0788MA25k6LTY4DsbMAygej4d1dckts+Pl+Gj8anNH8MKVlpaqp6cn5P+QP2g9jRhfvKYUiyDOCLtwbmnWa/MSXcA5lxtUmeKtyWQyQSDhfaPXG/bG5rFKCp4sbJM0EyK03n/sB2KI0G5x8fSqJeTVUqnKtoqLi0NBkc0vwyOHgGMfdvusOkHz5VhsujEyFbyEbm2VbtSjw8oUNophoxGpVCoIF2mmwtPmrMXj8SBsbXNh9sl5sd49+x6ftcUJUmFFKO8jIG1yP9u3k3WeBVaQ2TCpPR+INWyh/Zs0Eyv6ouFbfl+2KpnfixVhs3nTovl2Ue/b5SjiZrP1+Xze250YVqyw6+joUCqVKhAFCAuMKzcPP268dDbvzM56uJEkFVS2TkxMBG8TIpF/M5Mkr4TvUPVJ2IKqN0khRItRiXriCK+Ojo6GlSS48RFwzEJtHgp9zQgLYxxINEYA8j28ElSLUaVqQ0u0BbE9rfBe2FkkDxH+bfNkuru7NTIyos7OzouyqoLjXApIxrchPAoREETYBhu646FeVVWlbDYb8sLi8XioIpUUBJekglUc8vmZHo3c9wgywqvRXnnc57bJus1b43uEZmOxWFh+LBabbheUTCZDKksmk1E8Pt3nMZ1Oh7QMCi947GBnJQXPoy3iIEzMcVgbwqTP2lnsN9EPxm7DsFas2FC1TffgOhCt4DxECwKsN80KV7bLdbIizFaMcv5tvpz1DFrBHw2VIoI5tmgI1lbFMp6oSLNiby7BdC6JMNs2L5YYnGvf9hzbc8ZvzYXdChZ2bW1tofIyKu4wYLzOjcOpwnjYpFRmdra3FN+fmpoK3dmZOUszy1VhsBBkJOEODg6G/DWb71ZUNF1ujzeAMn3c9vQ8Q/zxh7YnGLJsNhsMAq0JGA85doSCMf5TU1Mhx47ZJ/2xrAEaHx8PHgBboCIpCD9CueT3WQ+lzf+QFJq5slrB+Pj0Ml80Mb4cW4Y4Kw88X+SK4clGmNkHHkLKNtKlRQY2hXwttk1kgEpW7m3uAwoi8JZzD9rKS1IeyCWzLUq4/xBTNr8V75+kILoQdYg4BBzeQcYizeQXEoZl23bNXXLyEKx45glT4xmzeWKA+MQOEW7lmGz+ss1nY3tsC3uPION1/m+vI//mHNtVgqzgs9u1zxQrFm1BRtQjx77sRNh65/h81ENo/z2bUPqgOXGzbfN8YjC6Xz4fHctcAtEKUPsdz7GbYcUKO0Kx1itnk4ptjhueMRvelGb699jQib2JJAXvmC0gwNvFTU1+m83jQNjYClhEp12CrKenp8AjiKGiLQHCk/Yt1rBYo0ARwujoqCorKwvapCDwMLYIQxumIVTc398fziPVw3Zf7AfhF4/HQxgnl8uFfduqO2uEJYWO/3gHbYGKTSrn3EcrvRxnoWFyWFRUFNZNtb0x8Ywh3mzunC2CsKIKkYIokmaS+lk1wk4ymZDZxt62xQbjpPrcrpMbj8dDGBURiZeONW7JqSNNBfvF0mjkDaZSqbAthCZ2BqGKx9Cu4UzKCWLHitKhoaEgTBGYhFCttw/BQAjcil0b5rST5mgY0+bQIZ6sWCOCw3OB82/FMdvi3Nr0HBvx4W+bDxgNO7PP2SpsiahERZ/9v/3ObF66hSyAsMLUjpvzPBfWAzpXeNmF3QwrVti98847Yd1DaeaHhvdImjHOiCs7S0SsWa+cNFPZhDDh84gzaSYvw96gExMToULOhmwlhf5QGBcKEPr7+0OIFINHGJXmqAhTe2zsD28ZohHvACKQ9SEJs2I4rNhDqNlGxRQzWI8fXkEeQuTx8PDiPHd2dkpSaNhKlW15eXnw9BHW5bxQ+Uazaa+IdS4FdiIxGzzIaVTNbxevljSz2gDVohQ5UEyAMJyamgp9MhEuRUVFqqmpUTweD0vwcb8jBGibxD3HRMmG8RCDduk1SWd5shCPCC/G3dXVVfBwJkRK30yOJ1rljlCloITzgqhB6JHbjKCy1fbWi8kEkWIsbB3eU6mw4hTBhteRIhA72bdeNys+7DKLNiSOmGZ8No0FryG/jaiHDqFHegzjsMKMa8G5Y1v2OcaY+B0wkbchWSuIrADkPLPP95tnd74w6nyx52u27VkxmM1mVVNT48JOK1jYvfnmmwVLYtmcC9uDCONgq5BsDoYNXxIy5T3WPsWYMjPjx42Ri8ViYUHukZGRsMA4hlBSyGsjlMpls7lu1oOGobYhUkK1GCm8ehgTu+SY3RaVq4hZuuiPjIwEA2UXGM9ms6H3HKEhziPHKk3nClIIwQyW9SbZPrN8KoPxeDrOYsI9SGsQhMHAwIBKSko0Pj5+VjNrQrSrVq0qWC+acC193jKZTFjbOJ1OhwkmXi/EDfeE7Z2JJxuxYvOAk8lk8IgheFhJwubTWe83ApGlzLBXeOisUKChMhC6pcAMEYldseIrOkG2y7flcrlQRIFAtW1jcrnpJsu2fRXnBa9ZLBYL/e/wmCKsrOeRa0vkA2+iNLMGLeeK47fnj7xg23vORnyww9GQLJNgrgE204piK9iw6RwDx81Yoh4xfgMcmxVvVgCCFWZRkWZD0lGxGPWqfVBReCHfd4/dDCtW2L366quhXQbCJnqTsUQYHqfozTObqxzjZ9c6tLM5wq58h5wPblxuQgQbBsY2wrRCjpsfg2lz3/C+8W+MSjabDUnO0kwIgP8z6xwYGAgeMIzaxMREWHYHw2YLThCKGHPyCLn52R4LkzP7x9jY88735/qJ2hmw4yw0iAFJSqfTocF4tE+jDU/i/aI1Cb9pQogUVPCgzOWm1x/mHqK4gB533H8lJSVKp9NKp9NhfVJAbCL4bOEB38fu4eEjFEzeHx4hm6cmqSBMKs0sb5VIJJTNZsPnuDep6qVFCaIR24tXkgILvHS2ybikgokmNhJbLc3kPeMtZLKJreW62NAy+xsfHw9eUUQj30fESiqwY9gpbLEtsOB8ESK2RRnYasQ54ozzyLFa7yDXJ5oKxDbtOZcKizUIy9pnjvVYImxxOlgHh/UY2vHzW7dRLPs9tmPzD+eTPxdNZ7L/no/Ac2E3w4oVdv/6r/8aig/wVmFwp6amgjeKG5OiBG5mjCTCy+atYQCo/uSz0fJze+Ni8MC64PHasV8742L7kkJ7EEQhosgKOGbytBRhWSFrtLjR8bbZtQKl6ZuNwgeOF4NGaBYDMDo6GpY44ianSITjwbBhJG3YBiNtDfTAwMCcYs9xPgh4suxvHy+SLWCSZlaGwAOWTCZDL0nuCQSQbVVCnldpaWnw8DEJ4wFvc8ek6Qc0vRqlafvAWtGE/Hh44pmzXhoe8FS04u1iH/bhn0wmC9oxEcUg/Iggs5WyeNPwFhKGtbm4kgpWgLA5cnieyLsrKysLfe7o4WkLPbAl9Oq0k1hsChNybJcdI+KGc0EUwObGYcPIW8NDZfvocR1tHh7YpRSj0R5r9xCCdmLORD16vFHPGOLKOgasnbYRGtsY2XoYrXC03kCuP9cxGp4G65m0Imy2cKwN99rXouItGhq2z7G58FDsDEtO2D3yyCP653/+Z7355puqqKjQzTffrEcffVSbNm2a1/cRdgcOHCjwFiFkJIVlaySFxrgYUJrq2nYANi+PG8MuyYVhxPNmK2OjLntuusnJySCA+F4ulysI3/IeDx/CHgg/2xuKtiOlpaUaGhoKhhKDzXfoF0c1G21WMDSs3YqxGx8fV3d3dxC8POTYRyaTCQYCg4nRSCaTKioqCs2QEas9PT3hnHF9HOdCiVYn2sa7pBfwQOO3bENyURAReLkQeplMpmBftgKVyQj3FB47BANeOzxmFHTZyRH5uSznxfu2XRPRATsGlhRLJpPBC84kDQ8858Pm4HFuEG2pVEqZTCbYqtHR0YLwJbbLHqsVedLMg7q4uDjYDyaD2DuEjy3iwHtYVlamdDodbKX1NCKyOIZsNhsELMtDkn9Ini5jxg7bwgqbp8h14/gknWXbbZjVFj1wXfEA2gpYzq1ddcLm/HEtrThn0m17onJOOSecRxtatyFTsOfRegFt2xe7f64t4nM2L100H45j4DPsw4aD7XPPijs8vvMJyfLe0NCQamtrXdhpCQq7HTt26DOf+YxuvPFGTU5O6sEHH9Tx48f1xhtvhLUGzwXC7pvf/OZZ6yGywgHerqj72iY02zAss1GMvZ0R2RCk9YjZWRffZRzW6CEiec3O+igYYFZriyXoQM9+JYVwA4UKo6OjoVIPg49hHB0dLehpxf5isZhSqVQwCOQW8R4eQHrtSQrtTgYGBkIrlmieHMcWvZEvRNRFtzFfUqlUWNZtPngIeGlRUlISmubiQSbXjAc2wopG2vzubYPaoqKi8BrigH6QTIist4h7qqKiQnV1deGeYtJIUj+9JsvKysJ28LRUVlYWNDnOZrMqKysL/fAkBVGKMGMbeOyt5wyvOqvuWE8SeW94t6xdwTNZUVGh6urqAi8g4qWqqkqSwoRSUsGEFLvAtu19ysTaPsDx8tsJHueda4hnlSUMi4uLQ34vS6FZu0zaC94wev9xTRHekoJHEOFLIYcVkTY/kOp8G+Hg2WHDu0yKreDDnlhvL9tlMm1D4taTyPmzbWOiwiia/8bfCGvroUPo2THwPCPqY4UY94f1GttjQqjZSTrbByssmXDZsVphbQWiFYF9fX1qampyYaclKOyidHV1qb6+Xi+88II+9rGPnfW+vVGlaWG3du1a7du3r2CZHASPnU3YsKc0EwplhkTpvxWAdhYZ/XEiGG1iMgLLzvYGBweDxwxjZGfv1h2OGLMPFXLh2C5GdGRkJIRgGSNisLS0NBhCPIQ27GyNVD6fDxV6iEgKIEjqtm0NooY/l8sFDyL7t+eU42UWbRO3McypVCoYPcIEiMbZsOeMfVGB2NfXV/CQwdjV19eHfoIUfJyP2UIVHxQe3HNBj7/e3t7wOULYxcXFGhwcLJghR9tA2LxQ4DcahfAjeVZ4CeY6ZltxyW8TLzN/ovDA4XdIIU10H3a5LSpF8RbhLaMtB0KDMCu/Te4ZfruEpmKxWFhRIZ1Oh3ub0CrV5zaBn9cJ19XW1kpSSPUYHh4O+W02FGjXTiV8x4Pa5pjy27L3SF1dXcHDWVKwMXi+aA2C4OL64bnExiCAk8lkCP2yX4Qq55VraXPlJicnC/rpWa8S153zhwgiHxDxwO/OjpPwpp0wc075LZEHZyt6bZ4cURiba2dXwcF7anvRJRKJIKolhYk9x4vnkt8qNjSa64b95HfGbwwxzm+PhtLR6mN+T9g+tsX70szauuQ228IKuwwkthJ7YFN5eI7YTgtRT5kVVfxtw9ZMLuw5sPeUxT5LrZhnnNYe2H9jH9gGrw8NDWnNmjUu7CQVn/8jlzf9/f2SpOrq6lnff+SRR3TgwIGzXr/yyislzeQosOxOf39/waybm4W8DAxFPp8P/dRsXs3o6KiqqqoK3OK0JyEsgIEcGRkJfZ5smJTZNLM7/lBwwOzWlvVPTk6qtrZWU1NTYVkxtokRXLt2bRBxeCZt+MRWuXLD2GahFRUV6u3t1cDAgNavXx/EIR482/4lmUyGwgk7M+MhQYNU8obq6uqCUUMoDAwMhAeezfnDuBNeImnbeiRZzBxh0dnZGTyM5O90d3eroqIifI5zStjm9OnTwcNTWVkZ1s2lbcXq1auDwMlmsyovL9fQ0FAIXdGZv7S0VDU1NcELXFFRoZaWFg0ODmrz5s2h0fLAwEDo4xf14LD/WCymmpoanTx5MggCVhhJpVIqKSkJ406n0wWeHB70AwMDGh0dVX9/v/r7+1VeXq5UKhXWF56amlJbW5umpqZUU1Ojqakp9fT0BIFDKJDfBd4YxE1JSYmy2Wyoeo7Hp9cJLS6eboqN15dmvNwP/f39wUNiBWRXV9eswnF8fDysljIwMKBkMhn2gbcrKogRMHiB7PtR8d7d3S1pulfkfOCBg3hpbW0teJCPjY2dc/JhwStEWsdcIeKWlhZJKhByCGbEaCaTCfaJyAQChXHbtBSEZzKZDN5BvNl4KBG5VgzzYLdeIzxKiA2uLQKONBLrfUMw4yEtKysL1wZPUGlpaci947diCzrsNUZcIJYQdIgmmyfI8VjvElGJ4uJiVVdXB+FTVlam/v5+jY2Nhd8yQkWSBgcHCyYvNn0H8YZdszYWu45Nsp5HOyGgWI1nCmkw7IPrjaPALv3I+cU2MAEn79MKK54vto0U4lea8cra8C7izk6kEM4I41gsFq4h15ZtzNX5ACHM8eL1xnHhTLOkPXa5XE6/8zu/o76+Pv3oRz+a9TNzeewefPDB8MPAmNj1TqWZHB1+cJIKEnKtx8smmTKTwzPCZ63rHJc2M3nbMJSluBAvGAxyU2zINZ/PnxUukRRmf7HY9CLcGAZWjSDsQe83OrvzsLOzZY7Pur1tsQdCEgOKe97OKK0Axgtjq4YxgGyjtrZWIyMjwcDZfUxOTob2Bohsxk3/O+tV4Hwkk8nQc29iYkKVlZVBGNhcHTx5tK/o6enRqlWrQmL36Oioqqur1d/fr/r6ekkKeUx2G4hmPCYNDQ3q7e1VIpFQa2urBgYGdN1116mjo0N1dXU6ffq0amtrQ2NXVtNIJpMh1FBdXa3Ozk6Vl5drdHQ0CAXCgc3NzaE3oPXy1tXVaWhoSF1dXRoYGFBfX19BrzFpuncg6wdXVVWpv78/hOf4fRMKHBkZCUKX39Hw8LA6OzvDgxkDzO+6qKioYCLC64iBXC4XJmrO4oGg5D6QZkJ52EPbG856ThEK1nODzeA71lOGTaFhOQKNsKOt4MULGA3NSoXtWmzoD88dYykunm7Bgm2w3la8WIwZ+4p9mS2Uye+a+83+zunNh52058wKSkSoDVNyTBbGxb6jlbTRdbNt/p1NbeEYbQpR9JhsaBxHB59HXLEPG+mKnqOoN9BGCsCGdu155/92v1EvIp+Vpp9DV1xxhXvstMQ9dvv27dPx48fnFHWSClS9hQW5aUuCkcBLwoOMGw7jgmAiNMFNLM24lquqqkKVLbNftkGOCZ5AhADbxwDiNZIUHra433Hj0+eNKjhm6UNDQ6GJbywW05kzZ8L+bW4IidEUXXR1dRUYShs+olkwYoybjTYMiDPOw9DQkDo6OkLod9WqVWGZI7wyCEbbEoJGzC0tLQU5NtyojKW3t1d9fX2Spo1aVVVV8AQhcnt7e8PMtKenJ3g7q6urFY/Hlc1m1dHREQQeOUzxeDwIx5KSEjU2Nqq3t1dtbW3Be8e5am1tDWt+0m2fY6isrAxeX8KCiDVCOYS88ejwmaqqqnDuJycnw/U8c+ZM8MASQk6n03rvvffU29sbep1haLk2b7/9tnp6etTX1xf6eZG/2d3dHTwxnBcbhuvu7g6FM0wChoeHNTg4qGw2O+vs2oZx7eSAz9pKROfSQmiO+wRPH9ef68Q9bgsCCDXaVBGKrKznDqGD7eW9oqKi0CoJb5r1yCNe2J8NS7NNQsa2wEM6e8kubDfCgf3zWSZiNmTJvmy/P4oqbHQD0YOowY5FhQh22/a8w95FW6bYc23HafPZEDRM2BgToWM8k4wjmg7E+Nl+VMxarPfVjiX62agAAzsZsJ+14i8q6ubDbNvgfDrTLFmP3b333qvnnntOP/zhD3XVVVfN+3sUTxw+fDjkgwDJs/am4cHFgxdvFj9GG76YbcYVzU+xSaw83KKrJbBN63ZmBovBI2RAqAYvFLNeaTq0REsSjCKhGAQaIRbbSw8XOgaYNgIcU0lJSRAohIz6+vpCLhi5SZwjEs7xyHAcCCHCDdzkeKxsqxibnFxRURGKPsht6e/vDwIrl8upqqoqhLbJFyJ0MTU1FVq+4IUbHBxULBZTVVVVQa4h3jceAIQF8SQCSdsNDQ3BA0vVL82rE4mEampqgvhrbm7WjTfeqNbWVl1xxRXq6uoKHsuioqKwqHUul9Pg4KASiYR6enpUUlISxlFZWalTp06FY+LaMyMeHBxUe3t7EHTSzEOtp6cneOc6OzsLBDcV2Uwg4vF4QUGMc/nDb4A0Eh7STGgJfUozzXexC9arQuSBSSF2zHqjpJlwsH0d7zzv2WIFPsu2sKu2A4GNlgB2zIZQERZMfgkh4w2TZpb6wgZbsWOPjeIRvmvFFfYY24Q9xBZEhVI0VwyPlHUkWC+jFTuMLSqiEJRRb5jNO7PHZr181hsZfR5F9xHFCrW5PhP9/rk+Z7Get/dLNptVXV2de+y0BIVdPp/X/v379cwzz+jo0aO65pprLuj7CLtnn302CBGbK2Q9SDaMyE0cnQFKKsjH6+3tLcipQNBJCuLPVmhhjDAIePLw8uFyx0tok2MReXwHo4SRZLaJKLUJ6OwLrx/eRml64XKqA8nRYsw8HNLpdBABGDKMlX04WNHLLB8vJmLS5qmQEzg5ORnyWVgbEiE+MTGhwcFBlZeXq7e3V6lUKhhywuO2isxWQCKk8WaNjY2pqqpKq1atCiF58iFTqVRBvg45RwhmaTq3kwpkvGdUW5eUlCiTyRSsANLY2Ki+vj4lEgmdOHFCGzduVHd3t9atW6f29vZg7MlzSaVSOnPmjOrr6/X222+rvLxcZ86cCd6Q1tZWxePxggariURCg4ODam1tVV9fX/AY0CCbXDY8gngLqL6zE5jZCiicyxPbYgRbhQCyHi5JBblu0kzFuxVG2A7ub3I6CZVKKsjdJPWC+9eGbPGeRR83TJis523VqlVhvIzDChkiDzbEasUG+7UpK3bibSMWbNcKVhvixF6zLytM+a4VSVacRf9Ex2jFj90nr0erRufyaNmwZFTIzSaq5iO8OGf2/9Ew68UiKjDnKwajeIPiGZacsPvDP/xDffe739Vzzz1X0LuOB+r54OK/8cYbYQ1HSUEwkcNlDQIGAq8PBQX0o7OVqnzfikL7g0VwSArhNB6i0W3ZBGcKBbjZbVd2xCMCEIFKiJnZLILT9ozD8JLzRt4UXhobYqXalcR7K+oQB/F4XJlMJozbGk7EHLNyWi/wHkniJC/TcJkHEF6rZDIZQoGZTCaINQRqLpdTOp0ODx3Gzmy9srIyXBMKOZg5p1Ip1dbWhjBnLDZdrJDP54MHoKqqSolEQl1dXRofH1cmkykIu1BNJymEkcmBqaioUE1NjUZHR/XOO++EthX19fXq6urSxMSE1qxZo7a2NjU0NIScwVOnThWEvSYnJ3Xq1KkQXiZMlsvl9Oabb2pwcDD8VsbGxkJ4lckAnulYLBa8r87SgPue3DZbiYlnrbS0NBSoWCGDyCclApvFb5vJGtuyqRPS2SsdMPGxOWx22TTr8ZIUJi5834YesXsUikQ9VdJMxMB6pBBd0WIw7JutGrbeMMSZFXXRSTv7Y1/R3LSomLMeMWv77fFEv3Oua2w/g22z4/ugYmguoh7Eiy3mFgIXdjMsOWE31w/sqaee0p49e877fS5+c3NzeMDbbVoxJRWuDsFNbxNpeUjyOoIOdz2CcXh4OAjCkZGRINRsIrAt87cFF+yb/Ce2Y8NitmqJaig8ZjbRFWGJBxBBaSs+bQEFxRvc6HhzYrGZ3nyMg5Az3yfsSluMiYmJUFlJ41Q8bNYrSX6fDWXjeZgrFGhbgiB0ZgNjjsAk5CwpFFbwoKiurg5d+HmA8sBKJBJKpVJKJBLq7OxUPp8PPa4IR9fW1obcu6qqKo2MjGhiYkK1tbVh5Y6RkZEgQouLi4PgIkSFp5UK2/LycnV0dITvcV2npqbU0tISmjsnEgm1t7eHVTpsWwNnaUBlN6tDEMq0IUcmLrFYLEwmEGzYNoQf94X1GNlQIl45kv6jni0bnrQi0LZjst419oUn3nqpbIQAocLnCBFbUWG9ZHYbEIvFQnrKbN4yK+ysdygqkKKfOZfXKyp2o4LrYouupSi2LiUu7GZYcsLug8LFf/fdd0O1YfSmlGaMjc2ZAIyY/b/NwbDbs6LKJvbyHuLPCjPEE+1TSHIfGBgI22dfhAqY5drQCSI1l8sFcWC9kIgyjpt8O2s8yGtjrHaJGjx7jINEf0QZoWPGQRXnfMN7nDP+Xkyqq6vDOauoqAge4rKyMtXW1qq4uFg9PT2KxWIhby+RSKi+vl6Tk5MhXExDaULWfX19qq+vD6FqwuN4JfP56VYeCLSenh6Nj4+HbUxMTKi5uVkdHR2hNQtFJc7lBRWZVGUiphA01kNG/zRECTmoUU8OYsaGQ20FKd4hGz61qRt446KhPraJrUOgAWNhvFExZj1hUY8Yx852EI7REGU0/yuaK2b3YZnNW2a5mKLLxdblgwu7GVassOvq6goXf7bEzehNakWTFX0QLaCwLn37Ou/ZbdrwAKIH4TabMCTcimDCo4QAwxtEEjyFAXjToh5CO7tGuCHQ7N+EZCkGII9PUkiuR/zhJeI4eY3t8R28l0u5oqm2tlapVEqNjY2h5Qp5b/F4XE1NTZKkqqqqkKNXVVWlXC6njo6O0DKFhHZE/vj4uLLZbCheaW9vVzweD96/kydPqre3dzEPfcVSVFQUimMQWAiTsrKyEK63Aoz1W6WZwiq7WgATBSv6bK6tLUrA02aLbfCC4bFD/NgJkvUCkheK2OKzjI0wra1WnS3Rn+9JhS0prJdMUsHENuo5s0QF4YXiYmtl4sJuhhUr7M538a3Ym034zfa5c712rveswZvNgxgVfVFxOZuItKIxFosVCDibII+HCG8aYVm8gwg98gnx9iEMKUQg5w/RR8iUMDQh5uLi4rA/QsHsh+pfu/buUoPKV85vVVWVxsbGdPXVV4cHvjRTTfzuu+9qzZo1QVRTuNHX16f+/n4NDw8XNErO5/M6derU4h7kMqaoqCjkPdIKCNGTSqWCkCLciCeM4h1CowgrK5jwztmcNUkh/GhDo3ixqMymCptt8nmbr2WrM+1nowUBUY8VRP99rorJCxVM0bE6zsXGhd0MS7qP3UKykDO9qOdvrvctcwkdK+Sin0NM2W1FvYfWe4fwi46Nz9vWLGNjY6FtB2vAsuYlnkBCyYg2vo+Hjj+IoGw2G3IQ8/m8+vv7l1xVJt5SICza3t6uuro6ZTIZrVmzRmNjY2poaFB3d7cSiUQIidPfrq+vT319fWpra1ukI1keVFZWKpPJBIGEaCO/kqKBeDwe2vsgqki8l1TgzZIUOvnbNT/xfNEMG1HH+9azhZizFaFWfNlcLRuqhNmE14WKLhdbjrM8cWG3CCyUaDyXYJwrhzD6GVtZasXebGFnvmMriPEC4sHj+zTZnZiY0MDAgEZGRkLDXFvFi8hDIJFfRosTvHyDg4MFAmop0NXVpa6uLp08eVLr1q3TmTNnwmoPiLry8nK1tLSEdjPONBSmkKNGWx9WBKFJN1WaVnDZpPri4ukl4wh50uw2nU6H12wlpS0UsAIsmowfFV9R4RXNj5sLF1uO43xQXNgtIy61l/Fc4WobFrZ5fYhAvInSTBd126rFhn0HBgZCe5Oenh719PQETyDrpA4NDam/vz94unp6eua9LuelJpfLqbm5WdJ06O/dd99d5BFdWvCS0SswnU6ruro6eNMQXvRNs962iooKlZeXq7q6Ogg5BBnhbdvSw+aEWfEVzcM6l5CKFgM4juNczriwc+bFpfQyWm+gfc02Y7Z5fra62K4FOzw8rL6+PmWzWbW1tYWQcTabVV9fn7q6utTR0aHTp09f9OOaL0s1l1Ca9qLV19drzZo1QaCxFBvCrLKyMrR+yWQyIQ/NLtuER40qy6jXaq5cLxsadRzHcaZxYecsKgvtZbSFJLZAxTaY5s/Y2JgGBwc1MjKi3t5etba2qqWlRV1dXTp9+rTefvttvf322wsy1sWgqKhIGzZs0IYNG1RdXa2amholEgllMhk1NTWpqalJyWQyNIVGkNm8sGiI0cWW4zjO4uLCzlm2EEJbCKy3kIrioaEhdXV16dixY/rpT3+q73//+wveU+7jH/+4tm7dqs2bN2vr1q1as2aNampqQkgymvTvOI7jLG+83YnjOI7jOEsaf7bPMPuqwo7jOI7jOM6Sw4Wd4ziO4zjOMsGFneM4juM4zjLBhZ3jOI7jOM4ywYWd4ziO4zjOMsGFneM4juM4zjJhxfWxo7tLNptd5JE4juM4jnMx4Jm+wjq4zcqKE3YDAwOSpLVr1y7ySBzHcRzHuZgMDAwonU4v9jAWlRXXoDiXy+m9995TMplclgt6Z7NZrV27Vm1tbSu+SeNSwa/Z0sOv2dLCr9fS40KvWT6f18DAgFavXh2WOVyprDiPXVFRka644orFHsaCk0ql3IAtMfyaLT38mi0t/HotPS7kmq10Tx2sbFnrOI7jOI6zjHBh5ziO4ziOs0xwYbfMKCsr00MPPaSysrLFHoozT/yaLT38mi0t/HotPfyavX9WXPGE4ziO4zjOcsU9do7jOI7jOMsEF3aO4ziO4zjLBBd2juM4juM4ywQXdo7jOI7jOMsEF3bLmPXr1ysWixX8OXjw4GIPyzE88cQTWr9+vcrLy7Vt2za9/PLLiz0kZw4efvjhs+6nzZs3L/awHMMPf/hD3X777Vq9erVisZieffbZgvfz+by++tWvqqmpSRUVFdq+fbt+8YtfLM5gHUnnv2Z79uw5677bsWPH4gx2ieDCbpnzl3/5l2pvbw9/9u/fv9hDcn7J9773Pd1///166KGH9Oqrr+qGG27Qbbfdps7OzsUemjMH1157bcH99KMf/Wixh+QYhoaGdMMNN+iJJ56Y9f2/+Zu/0Te/+U09+eSTeumll7Rq1SrddtttGh0dvcQjdeB810ySduzYUXDfPf3005dwhEuPFbek2EojmUyqsbFxsYfhzMJjjz2mvXv36g/+4A8kSU8++aS+//3v6zvf+Y4eeOCBRR6dMxvFxcV+P13G7Ny5Uzt37pz1vXw+r2984xv6i7/4C33yk5+UJB0+fFgNDQ169tln9ZnPfOZSDtX5Jee6ZlBWVub33QXgHrtlzsGDB1VTU6MPf/jD+tu//VtNTk4u9pAcSePj4/rZz36m7du3h9eKioq0fft2vfjii4s4Mudc/OIXv9Dq1au1YcMG7d69W62trYs9JGeeNDc36/Tp0wX3XDqd1rZt2/yeu8w5evSo6uvrtWnTJt1zzz3q7u5e7CFd1rjHbhnzR3/0R/rVX/1VVVdX6yc/+Ym+/OUvq729XY899thiD23Fc+bMGU1NTamhoaHg9YaGBr355puLNCrnXGzbtk2HDh3Spk2b1N7ergMHDug3fuM3dPz4cSWTycUennMeTp8+LUmz3nO851x+7NixQ3fccYeuuuoqvfXWW3rwwQe1c+dOvfjii4rH44s9vMsSF3ZLjAceeECPPvroOT9z4sQJbd68Wffff3947frrr1dpaam++MUv6pFHHvFlWhznArHhouuvv17btm3TunXr9E//9E/63Oc+t4gjc5zliw2RX3fddbr++uv1K7/yKzp69KhuvfXWRRzZ5YsLuyXGn/zJn2jPnj3n/MyGDRtmfX3btm2anJxUS0uLNm3atACjc+ZLbW2t4vG4Ojo6Cl7v6OjwXJIlQlVVlTZu3KiTJ08u9lCcecB91dHRoaampvB6R0eHPvShDy3SqJwLZcOGDaqtrdXJkydd2M2BC7slRl1dnerq6t7Xd48dO6aioiLV19df5FE5F0ppaak+8pGP6MiRI/rUpz4lScrlcjpy5IjuvffexR2cMy8GBwf11ltv6a677lrsoTjz4KqrrlJjY6OOHDkShFw2m9VLL72ke+65Z3EH58ybU6dOqbu7u0CcO4W4sFumvPjii3rppZd0yy23KJlM6sUXX9R9992n3//931cmk1ns4TmS7r//ft1999366Ec/qptuuknf+MY3NDQ0FKpkncuLP/3TP9Xtt9+udevW6b333tNDDz2keDyu3/u931vsoTm/ZHBwsMCD2tzcrGPHjqm6ulpXXnml/viP/1h/9Vd/pWuuuUZXXXWVvvKVr2j16tVhcuVces51zaqrq3XgwAF9+tOfVmNjo9566y196Utf0tVXX63bbrttEUd9mZN3liU/+9nP8tu2bcun0+l8eXl5fsuWLfm//uu/zo+Oji720BzD3/3d3+WvvPLKfGlpaf6mm27K//SnP13sITlzsGvXrnxTU1O+tLQ0v2bNmvyuXbvyJ0+eXOxhOYbnn38+L+msP3fffXc+n8/nc7lc/itf+Uq+oaEhX1ZWlr/11lvzP//5zxd30Cucc12z4eHh/G//9m/n6+rq8iUlJfl169bl9+7dmz99+vRiD/uyJpbP5/OLJSodx3Ecx3Gci4f3sXMcx3Ecx1kmuLBzHMdxHMdZJriwcxzHcRzHWSa4sHMcx3Ecx1kmuLBzHMdxHMdZJriwcxzHcRzHWSa4sHMcx3Ecx1kmuLBzHMdxHMdZJriwcxxnRXHo0CFVVVWd93OxWEzPPvvsgo/HcRznYuLCznGcBWFqako333yz7rjjjoLX+/v7tXbtWv35n//5nN/9rd/6LcViMcViMZWXl2vr1q361re+dVHGtWvXLv3f//1f+P/DDz8cFoW3tLe3a+fOnRdln47jOJcKF3aO4ywI8Xhchw4d0g9+8AP9wz/8Q3h9//79qq6u1kMPPXTO7+/du1ft7e164403dOedd2rfvn16+umnP/C4KioqVF9ff97PNTY2qqys7APvz3Ec51Liws5xnAVj48aNOnjwoPbv36/29nY999xz+sd//EcdPnxYpaWl5/xuIpFQY2OjNmzYoIcffljXXHON/uVf/kWS1Nraqk9+8pOqrKxUKpXSnXfeqY6OjvDd1157TbfccouSyaRSqZQ+8pGP6L//+78lFYZiDx06pAMHDui1114LHsJDhw5JOjsU+/rrr+vjH/+4KioqVFNToy984QsaHBwM7+/Zs0ef+tSn9LWvfU1NTU2qqanRvn37NDExcRHOpOM4zvwoXuwBOI6zvNm/f7+eeeYZ3XXXXXr99df11a9+VTfccMMFb6eiokLj4+PK5XJB1L3wwguanJzUvn37tGvXLh09elSStHv3bn34wx/Wt7/9bcXjcR07dkwlJSVnbXPXrl06fvy4fvCDH+g///M/JUnpdPqszw0NDem2227Tr/3ar+mVV15RZ2enPv/5z+vee+8NQlCSnn/+eTU1Nen555/XyZMntWvXLn3oQx/S3r17L/h4Hcdx3g8u7BzHWVBisZi+/e1va8uWLbruuuv0wAMPXND3p6am9PTTT+t//ud/9IUvfEFHjhzR66+/rubmZq1du1aSdPjwYV177bV65ZVXdOONN6q1tVV/9md/ps2bN0uSrrnmmlm3XVFRocrKShUXF6uxsXHOMXz3u9/V6OioDh8+rFWrVkmSHn/8cd1+++169NFH1dDQIEnKZDJ6/PHHFY/HtXnzZn3iE5/QkSNHXNg5jnPJ8FCs4zgLzne+8x0lEgk1Nzfr1KlT8/rOt771LVVWVqqiokJ79+7Vfffdp3vuuUcnTpzQ2rVrg6iTpK1bt6qqqkonTpyQJN1///36/Oc/r+3bt+vgwYN66623PtD4T5w4oRtuuCGIOkn69V//deVyOf385z8Pr1177bWKx+Ph/01NTers7PxA+3Ycx7kQXNg5jrOg/OQnP9HXv/51/du//Ztuuukmfe5zn1M+nz/v93bv3q1jx46publZQ0NDeuyxx1RUND+T9fDDD+t///d/9YlPfEL/9V//pa1bt+qZZ575oIdyXqLh3lgsplwut+D7dRzHARd2juMsGMPDw9qzZ4/uuece3XLLLfr7v/97vfzyy3ryySfP+910Oq2rr75aa9asKRB0W7ZsUVtbm9ra2sJrb7zxhvr6+rR169bw2saNG3XffffpP/7jP3THHXfoqaeemnU/paWlmpqaOudYtmzZotdee01DQ0PhtR//+McqKirSpk2bznssjuM4lwoXdo7jLBhf/vKXlc/ndfDgQUnS+vXr9bWvfU1f+tKX1NLS8r62uX37dl133XXavXu3Xn31Vb388sv67Gc/q9/8zd/URz/6UY2MjOjee+/V0aNH9c477+jHP/6xXnnlFW3ZsmXW7a1fv17Nzc06duyYzpw5o7GxsbM+s3v3bpWXl+vuu+/W8ePH9fzzz2v//v266667Qn6d4zjO5YALO8dxFoQXXnhBTzzxhJ566iklEonw+he/+EXdfPPN8w7JRonFYnruueeUyWT0sY99TNu3b9eGDRv0ve99T9J0/7zu7m599rOf1caNG3XnnXdq586dOnDgwKzb+/SnP60dO3bolltuUV1d3ay98hKJhP793/9dPT09uvHGG/W7v/u7uvXWW/X4449f8Pgdx3EWklj+/VhWx3Ecx3Ec57LDPXaO4ziO4zjLBBd2juM4juM4ywQXdo7jOI7jOMsEF3aO4ziO4zjLBBd2juM4juM4ywQXdo7jOI7jOMsEF3aO4ziO4zjLBBd2juM4juM4ywQXdo7jOI7jOMsEF3aO4ziO4zjLBBd2juM4juM4y4T/B9LaVs7d/JPnAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trajectories = inference(trajectory_length, forward_model, env)\n", + "render(env, trajectories)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Things aren't looking good yet. The model has learned to sample positive x positions due to majority of the reward mass being located in this region, but we are nowhere close to sampling from the correct probability distribution.\n", + "\n", + "We likely don't have time to train this during the tutorial, but by playing with the above hyperparameters long enough, we can eventually learn to sample from this reward distribution. Try playing with this notebook at home to build an intution as to how the different hyperparameters affect the results:\n", + "\n", + "+ `trajectory_length`\n", + "+ `init_exploration_noise`\n", + "+ `min/max_policy_std`\n", + "+ `n_iterations`\n", + "+ `learning_rate` (for the model and logZ estimate seperately!)\n", + "+ `hid_dim`\n", + "\n", + "A key takeaway here is that the complexity of tuning the hyperparameters for training a continuous GFlowNet quickly grows with the complexity of the environment... even in a very simple case such as this one. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "vae", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/notebooks/intro_gfn_smiley.ipynb b/tutorials/notebooks/intro_gfn_smiley.ipynb new file mode 100644 index 00000000..76c15355 --- /dev/null +++ b/tutorials/notebooks/intro_gfn_smiley.ipynb @@ -0,0 +1,2120 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "nrLt_YA1nQLO" + }, + "source": [ + "# Using GFlowNets to Train the World's Most Powerful Smiley Face Sampler" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "hagz-Jq3JKvj" + }, + "outputs": [], + "source": [ + "# https://pypi.python.org/pypi/torchgfn # currently pulling from\n", + "# `easier_environment_definition` until we do the next release of torchgfn.\n", + "%%capture\n", + "!pip uninstall tensorflow -y && pip install torchtyping\n", + "!pip install git+https://github.com/GFNOrg/torchgfn.git@easier_environment_definition\n", + "!pip install typing-extensions --upgrade\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import matplotlib.cm as cm\n", + "import random\n", + "\n", + "from torch.distributions.categorical import Categorical\n", + "import torch\n", + "import torch.nn as nn\n", + "from tqdm import tqdm, trange\n", + "\n", + "# Reproducibility.\n", + "seed = 42\n", + "torch.manual_seed(seed)\n", + "random.seed(seed)\n", + "np.random.seed(seed)\n", + "torch.manual_seed(seed)\n", + "torch.backends.cudnn.deterministic = True\n", + "torch.backends.cudnn.benchmark = False" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ihLL2qXwbWF6" + }, + "source": [ + "Important Note: This material was mercilessly stolen from [Emmanuel Bengio's 2022 Tutorial](https://colab.research.google.com/drive/1fUMwgu2OhYpQagpzU5mhe9_Esib3Q2VR#scrollTo=w51Ha8TRZ29Z).\n", + "\n", + "GFlowNets (GFNs) are a generative modelling framwork - we train a model to sample from $p(x)$, i.e., we amortize the cost of sampling into the training process. This means we're going to have a `.sample()` method somewhere to generate an object $x$.\n", + "\n", + "The most common and easiest use-case of a GFN is to sample compositional, discrete objects like sets, sequences, or graphs. The objects are sampled piece-by-piece, i.e., the `.sample()` method iterates over $n$-steps of a `for` loop to generate an object composed of $n$ components.\n", + "\n", + "GFNs are different from \"dataset-based\" methods (such as variational inference), because we assume instead we have access to an unnormalized density function $R(x)$ which attributes a value to every generated $x$ (a dataset might come into play if $R(x)$ is the result of a model trained on some dataset $D$, but the GFN can be trained using rewards calculated on sampled objects $x \\notin D$).\n", + "\n", + "GFNs are different from vanilla RL methods in that wee use the reward to learn $p(x)$, instead of a reward maximizing policy $\\pi$. In other words, we seek $p(x) \\propto R(x)$.\n", + "\n", + "But first, we're going to define some helper functions (hidden). Make sure to run this cell! Once complete, it will print out the hyperparameters for our models.\n", + "\n", + "# Run Me (below!)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9i9IoXKsQNEC", + "outputId": "373a2d8d-1a86-461a-f4cc-6f837ee01ef1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For all experiments, our hyperparameters will be:\n", + " + n_hid_units=512\n", + " + n_episodes=10000\n", + " + learning_rate=0.003\n" + ] + } + ], + "source": [ + "# @title\n", + "# These feature globals will be referred to throughout.\n", + "_mouth_kwargs = {\"closed\": False, \"fill\": False, \"lw\": 3}\n", + "FEATURES = {\n", + " 'smile': lambda: plt.gca().add_patch(plt.Polygon(\n", + " np.stack(\n", + " [np.linspace(0.2, 0.8), 0.3 - np.sin(np.linspace(0, 3.14)) * 0.15]\n", + " ).T,\n", + " **_mouth_kwargs\n", + " )\n", + " ),\n", + " 'frown': lambda: plt.gca().add_patch(plt.Polygon(\n", + " np.stack(\n", + " [np.linspace(0.2, 0.8), 0.15 + np.sin(np.linspace(0, 3.14)) * 0.15]\n", + " ).T,\n", + " **_mouth_kwargs,\n", + " )\n", + " ),\n", + " 'left_eb_down': lambda: plt.gca().add_line(plt.Line2D(\n", + " [0.15, 0.35], [0.75, 0.7], color=(0, 0, 0))\n", + " ),\n", + " 'right_eb_down': lambda: plt.gca().add_line(plt.Line2D(\n", + " [0.65, 0.85], [0.7, 0.75], color=(0, 0, 0))\n", + " ),\n", + " 'left_eb_up': lambda: plt.gca().add_line(plt.Line2D(\n", + " [0.15, 0.35], [0.7, 0.75], color=(0, 0, 0))\n", + " ),\n", + " 'right_eb_up': lambda: plt.gca().add_line(plt.Line2D(\n", + " [0.65, 0.85], [0.75, 0.7], color=(0, 0, 0))\n", + " ),\n", + "}\n", + "\n", + "\n", + "def draw_face(face, title):\n", + " \"\"\"Given a list of features, render a face to an axis.\"\"\"\n", + " # Draw the yellow circle & two eyes.\n", + " plt.gca().add_patch(plt.Circle((0.5, 0.5), 0.5, fc=(.9,.9,0))),\n", + " plt.gca().add_patch(plt.Circle((0.25, 0.6), 0.1, fc=(0,0,0))),\n", + " plt.gca().add_patch(plt.Circle((0.75, 0.6), 0.1, fc=(0,0,0)))\n", + "\n", + " for feat in face:\n", + " FEATURES[feat]()\n", + "\n", + " plt.axis('scaled')\n", + " plt.axis('off')\n", + " if title:\n", + " plt.gca().set_title(title)\n", + "\n", + "\n", + "# Some utility functions:\n", + "def plot_loss_curve(losses_A, losses_B=None, title=\"\"):\n", + "\n", + " plt.figure(figsize=(10,3))\n", + "\n", + " if isinstance(losses_B, type(None)):\n", + " plt.plot(losses, color=\"black\")\n", + " else:\n", + " plt.plot(losses_A, color=\"blue\", linewidth=1, label=\"No Forward Masks\")\n", + " plt.plot(losses_B, color=\"red\", linewidth=1, label=\"Forward Masks\", alpha=0.5)\n", + " plt.legend()\n", + "\n", + " plt.yscale('log')\n", + " plt.xlabel('Step')\n", + " plt.ylabel('Loss')\n", + " plt.title(title)\n", + "\n", + "\n", + "def check_sampled_faces(sampled_faces):\n", + "\n", + " fig, ax = plt.subplots(8, 8, figsize=(4,4))\n", + "\n", + " n = 128 # final n samples to calculate stats over.\n", + " n_plot = 64 # 8 x 8\n", + " print('Ratio of faces with a smile:{}, ideal={}'.format(\n", + " sum(['smile' in i for i in sampled_faces[-n:]]) / n,\n", + " 2/3.,\n", + " ))\n", + " print('Proportion of valid faces:{}, ideal=1'.format(\n", + " sum([face_reward(i) > 0 for i in sampled_faces[-n:]]) / n\n", + " ))\n", + "\n", + " for i, face in enumerate(sampled_faces[-n_plot:]):\n", + " plt.sca(ax[i//8, i%8])\n", + " draw_face(face, \"\")\n", + "\n", + "\n", + "def analyze_torchgfn_results(visited_terminating_states, env, n_samples = 128):\n", + "\n", + " env = FacesEnv()\n", + "\n", + " # Calculate sample stats.\n", + " n_samples = 128\n", + " smiles = visited_terminating_states[-n_samples:].tensor[:, -2]\n", + " frowns = visited_terminating_states[-n_samples:].tensor[:, -1]\n", + " print(\"proportion of smiles:frowns = {}:{}\".format(\n", + " torch.mean(smiles),\n", + " torch.mean(frowns),\n", + " )\n", + " )\n", + "\n", + " # Generate smilies in string format.\n", + " sampled_faces = []\n", + " for s in visited_terminating_states[-n_samples:]:\n", + " face = []\n", + " for i, elem in enumerate(s.tensor.tolist()):\n", + " if elem == 1:\n", + " face.append(env.feature_keys[i])\n", + " sampled_faces.append(face)\n", + "\n", + " # Plot smilies.\n", + " fig, ax = plt.subplots(8, 8, figsize=(4, 4))\n", + " n_plot = 64 # 8 x 8\n", + " for i, face in enumerate(sampled_faces[-n_plot:]):\n", + " plt.sca(ax[i//8, i%8])\n", + " draw_face(face, \"\")\n", + "\n", + "\n", + "def recursively_enumerate(s, enumerated_states, transitions, only_valid=True):\n", + "\n", + " # Detects invalid configurations.\n", + " if only_valid:\n", + " if has_overlap(s):\n", + " return\n", + " else:\n", + " if len(set(s)) < len(s): # Don't allow for duplicates.\n", + "\n", + " return\n", + " elif len(s) > 3: # Max trajectory length.\n", + " return\n", + "\n", + " for i in FEATURE_KEYS:\n", + " if i not in s:\n", + " recursively_enumerate(\n", + " s + [i],\n", + " enumerated_states,\n", + " transitions,\n", + " only_valid=only_valid\n", + " )\n", + "\n", + " enumerated_states.append(s)\n", + " transitions.append((s[:-1], s))\n", + "\n", + "\n", + "def get_unique(l: list):\n", + "\n", + " unique = []\n", + " for i in map(set, l):\n", + " if i not in unique:\n", + " unique.append(i)\n", + "\n", + " return sorted(map(tuple, unique))\n", + "\n", + "\n", + "def get_face_positions_and_plot(enumerated_states, transitions, F_sa = None):\n", + " \"\"\"Plot a graph of all state transitions.\n", + "\n", + " If a GFlowNet state flow estimator if provided, the edges of the graph will be\n", + " colors according to the flows.\n", + " \"\"\"\n", + " use_flows = True if not isinstance(F_sa, type(None)) else False\n", + "\n", + " lens, levels = [], []\n", + " face2pos = {}\n", + "\n", + " for i in range(4): # All valid trajectories are length 4 (including s0).\n", + " lens.append(len([j for j in enumerated_states if len(j) == i]))\n", + " levels.append(sorted([j for j in enumerated_states if len(j) == i]))\n", + "\n", + " fig = plt.figure(figsize=(8, 8))\n", + "\n", + " # Maps from unique face hashes to unique (x,y) coorindates for plotting.\n", + " for i, (level, L) in enumerate(zip(levels, lens)):\n", + " for j, face in enumerate(level):\n", + " ax = fig.add_axes([j/L, i/4, 1/L, 1/6])\n", + " draw_face(face, \"\")\n", + " face2pos[face_hash(face)] = (j/L + 0.5/L, i/4)\n", + "\n", + " ax = fig.add_axes([0, 0, 1, 1])\n", + " plt.sca(ax)\n", + " plt.gca().set_facecolor((0, 0, 0, 0))\n", + " plt.xlim(0,1)\n", + " plt.ylim(0,1)\n", + "\n", + " # Now add all transitions (arrows).\n", + " if use_flows:\n", + " max_flow = 0\n", + "\n", + " for face_a, face_b in transitions[1:]:\n", + "\n", + " if not len(face_b): # We're at the end of the trajectory.\n", + " continue\n", + "\n", + " pos_a, pos_b = face2pos[face_hash(face_a)], face2pos[face_hash(face_b)]\n", + "\n", + " # Optionally color the arrows by the learned flows.\n", + " if use_flows:\n", + " Fstate = F_sa(face_to_tensor(face_a)) # State flow.\n", + "\n", + " Fa = Fstate[\n", + " FEATURE_KEYS.index([i for i in face_b if i not in face_a][0])\n", + " ].item()\n", + " c = cm.Reds(Fa)\n", + "\n", + " if Fa > max_flow:\n", + " max_flow = Fa\n", + "\n", + " la = int(pos_a[1] * 4)\n", + " lb = int(pos_b[1] * 4)\n", + " ws = [1/6, 1/6, 0.13, 0.11]\n", + " plt.arrow(\n", + " pos_a[0],\n", + " pos_a[1] + ws[la],\n", + " pos_b[0] - pos_a[0],\n", + " pos_b[1] - pos_a[1] - ws[lb],\n", + " head_width=0.01,\n", + " width=0.003,\n", + " ec=c if use_flows else (1, 0, 0),\n", + " fc=c if use_flows else (0, 0, 0),\n", + " length_includes_head=True,\n", + " )\n", + " plt.axis('off')\n", + "\n", + " if use_flows:\n", + " ax = fig.add_axes([1, 0.2, 0.05, 0.6])\n", + " plt.sca(ax)\n", + " fig.colorbar(\n", + " cm.ScalarMappable(\n", + " norm=cm.colors.Normalize(vmin=0, vmax=max_flow),\n", + " cmap=cm.Reds,\n", + " ),\n", + " cax=ax,\n", + " label='Edge Flow',\n", + " )\n", + "\n", + " plt.suptitle(\"Smiley State Space\")\n", + "\n", + "\n", + "def plot_state_space(model=None):\n", + " \"\"\"Get all of the unique possible states and their transitions, then plot.\"\"\"\n", + " enumerated_states, transitions = [], []\n", + " recursively_enumerate([], enumerated_states, transitions, only_valid=False)\n", + " unique_enumerated_states = get_unique(enumerated_states)\n", + " if isinstance(model, type(None)):\n", + " get_face_positions_and_plot(unique_enumerated_states, transitions)\n", + " else:\n", + " get_face_positions_and_plot(unique_enumerated_states, transitions, F_sa=F_sa)\n", + "\n", + "\n", + "def face_hash(face):\n", + " \"\"\"Returns a binary hash for each submitted face.\"\"\"\n", + " return tuple([i in face for i in FEATURE_KEYS])\n", + "\n", + "\n", + "def face_to_tensor(face, verbose=False):\n", + " \"\"\"Encodes a face as a binary tensor (converted to float32).\"\"\"\n", + " if verbose:\n", + " print(\"face={}, hash={}, tensor={}\".format(\n", + " face,\n", + " face_hash(face),\n", + " torch.tensor(face_hash(face)).float(),\n", + " )\n", + " )\n", + " return torch.tensor(face_hash(face)).float()\n", + "\n", + "\n", + "# Our feature space. A face has one mouth, one left eyebrow, and one right eyebrow.\n", + "MOUTHS = [\"smile\", \"frown\"]\n", + "LEFT_EB = [\"left_eb_down\", \"left_eb_up\"]\n", + "RIGHT_EB = [\"right_eb_down\", \"right_eb_up\"]\n", + "FEATURE_KEYS = MOUTHS + LEFT_EB + RIGHT_EB\n", + "\n", + "# Fixed hyperparameters.\n", + "n_hid_units = 512\n", + "n_episodes = 10_000\n", + "learning_rate = 3e-3\n", + "\n", + "print(\"For all experiments, our hyperparameters will be:\")\n", + "print(\" + n_hid_units={}\".format(n_hid_units))\n", + "print(\" + n_episodes={}\".format(n_episodes))\n", + "print(\" + learning_rate={}\".format(learning_rate))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bv_6Adrni7c6" + }, + "source": [ + "# Features: Faces, Both Happy and Sad\n", + "\n", + "For this simple example, we will generate 😀 & 🙁 faces!\n", + "\n", + "Here, we define a face of being composed of two eyebrows (each can be up or down) and a mouth (smiling or frowning), for a total of 6 `FEATURES`:\n", + "\n", + "\n", + "* `smile`\n", + "* `frown`\n", + "* `left_eb_down`\n", + "* `left_eb_up`\n", + "* `right_eb_down`\n", + "* `right_eb_up`\n", + "\n", + "(where `eb` is shorthand for `eyebrow`). Above, we defined our feature space and some helper functions which we will use throughout the tutorial (we've also hidden some helper code for brevity)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 192 + }, + "id": "4c64Iuws7dhA", + "outputId": "7554d54e-6a80-47b2-ea8f-ea91f91bbabc" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(1, 5, figsize=(10, 50))\n", + "plt.sca(ax[0])\n", + "draw_face(['smile', 'left_eb_down', 'right_eb_down'], \"happy\")\n", + "plt.sca(ax[1])\n", + "draw_face(['frown', 'left_eb_up', 'right_eb_up'], \"sad\")\n", + "plt.sca(ax[2])\n", + "draw_face(['smile', 'frown', 'left_eb_up', 'right_eb_up'], \"mouth invalid\")\n", + "plt.sca(ax[3])\n", + "draw_face(['frown', 'left_eb_up', 'left_eb_down', 'right_eb_up'], \"eyebrow invalid\")\n", + "plt.sca(ax[4])\n", + "draw_face(['smile', 'left_eb_up'], \"face incomplete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dMzh41bW78l3" + }, + "source": [ + "# The Reward Function\n", + "\n", + "A face is defined as a list of these keys. For example, above `['smile', 'left_eb_down', 'right_eb_down']` gives a happy face, and `['frown', 'left_eb_up', 'right_eb_up']` gives a sad face. Meanwhile other configurations give invalid faces, e.g., with multiple overlapping mouths or eyebrows, or not having two eyebrows in one mouth.\n", + "\n", + "If we want to train a GFN to sample faces, we first need to define a **reward function** which expresses the above intention. We want to only reward valid faces: those with two non-overlapping eyebrows and one mouth. If there are missing parts or two overlapping parts the reward is 0. Also, since it's better to be happy than sad, let's sample happy faces more often, by giving them a reward of 2, and sad faces a reward of 1.\n", + "\n", + "Since our trained sampler should respect $p(x) \\propto R(x)$, **at convergence** we should sample twice as many smiles as frowns! Note - we often don't *completely* converge without training for a long time, so we might not observe a $p(x)$ exactly proportional to $R(x)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a9OqdXP69Pta" + }, + "outputs": [], + "source": [ + "def has_overlap(face: list):\n", + " \"\"\"\"Checks whether face contains either overlapping eyebrows or mouths.\"\"\"\n", + " if 'left_eb_down' in face and 'left_eb_up' in face:\n", + " return True\n", + "\n", + " if 'right_eb_down' in face and 'right_eb_up' in face:\n", + " return True\n", + "\n", + " if 'smile' in face and 'frown' in face:\n", + " return True\n", + "\n", + " return False\n", + "\n", + "\n", + "def face_reward(face):\n", + " \"\"\"Reward is 0 with incomplete/incorrect faces, 1 for sad, and 2 for happy.\"\"\"\n", + " # A face cannot have overlapping features.\n", + " if has_overlap(face):\n", + " return 0 # We will only very rarely sample an invalid face.\n", + "\n", + " # A face must have exactly two eyebrows.\n", + " if sum([i in face for i in LEFT_EB + RIGHT_EB]) != 2:\n", + " return 0\n", + "\n", + " if 'smile' in face:\n", + " return 2 # We want twice as many happy faces as sad faces.\n", + "\n", + " if 'frown' in face:\n", + " return 1 # We want half as many happy sad faces as happy faces.\n", + "\n", + " return 0 # If we reach this point, there's no mouth." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_60a9KTZ9i85" + }, + "source": [ + "# State Space\n", + "\n", + "Now that we've defined a reward function, let's take a look at what the state space looks like. We want to see all the possible routes to a valid terminal state.\n", + "\n", + "By state space, we mean the **space of intermediate constructions**, i.e. in this case this will include both partially created faces and fully created faces. For this tutorial we refer to these states as $s$, and to the full constructions as both $x$ and $s$ interchangeably (because $\\mathcal{X} \\subset \\mathcal{S}$).\n", + "\n", + "As you can see, we start with a base face that has just two eyes and we progressively add all possible patches that make a valid face. We call one such construction path from bottom to top a _trajectory_ or an _episode_." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 836 + }, + "id": "KqlwrCmX9evc", + "outputId": "88dc9cf7-d77a-48c6-b51d-e64d255881c4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_state_space()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yynOkiks-DM0" + }, + "source": [ + "The directed acyclic graph (DAG) above can be thoguht of as the unrolling of the `for` loop of the generation process, which allows us to visualize all possible paths. In Reinforcement Learning we'd call this the Markov Decision Process (MDP).\n", + "\n", + "What we're interested in is a _policy_, something that will tell us at each step what action to take (what patch to add). Since we are interested in learning a distribution, the policy itself will be a distribution over actions (possible patches to add) which is typically written $\\pi(a|s)$ in RL, but which we'll call $P_F$ ($F$ for forward) here. We'll call these arrows above, the $(s,s')$ pairs (or equivalently, $(s,a)$ pairs), _edges_, and the set of all edges $\\mathcal{E}$.\n", + "\n", + "The main idea behind GFlowNet is to interpret the DAG as a **flow network**. You could imagine each edge in the graph as a pipe through which some amount of water, or particles, _flows_. We then want to _find_ a flow where, (a) flow is preserved (meaning the amount of water going into a node should equal the amount of water going out of a node), and (b) the flow coming into a terminal state (a finished object) is equal to its reward (and in fact every non-terminal state _does not have any reward_).\n", + "\n", + "> \"Network\" here thus does _not_ refer to a _neural_ network architecture - it's not the \"Net\" in \"ConvNet\" - it refers to the MDP. So we use a GFlowNet, powered by a neural network, to discover the flows of the state space network. Naming is hard 😉.\n", + "\n", + "A central finding of the first GFlowNet paper is that if we match to each edge a _flow_, $F(s,s')>0$, and that this flow respects the following property:\n", + "$$\\forall s', \\sum_{s: (s,s')\\in\\mathcal{E}} F(s,s') = R(s') + \\sum_{s'':(s',s'')\\in\\mathcal{E}} F(s',s'')$$\n", + "which ensures _flow consistency_, AND we define the following policy\n", + "$$P_F(s'|s) = \\frac{F(s, s')}{\\sum_{s''}F(s, s'')}$$\n", + "which allows us to sample trajectories (paths through the DAG) using this policy, we will sample terminal states (finished objects $x$) with probability:\n", + "\n", + "$$p(x) \\propto R(x)$$.\n", + "\n", + "### Building and training a flow model with flow-matching\n", + "\n", + "We'll now setup a model and train it with the _flow-matching_ loss, introduced in [Flow Network based Generative Models for Non-Iterative Diverse Candidate Generation, Emmanuel Bengio, Moksh Jain, Maksym Korablyov, Doina Precup, Yoshua Bengio](https://arxiv.org/abs/2106.04399)\n", + "\n", + "Now that we know we want to predict edge flows, we need to define some model which does that. We could use a model that is a function of a pair of states, but that's not too efficient (exercise left to the reader ;). Instead we'll take inspiration from RL and model a function of a single state which outputs multiple predictions at once, the flow for each possible child of that state.\n", + "\n", + "In other words, we train a model `F(state)` which outputs a vector which is indexed by the action used to reach a child of `state`, i.e. $F(s,s')$ is `F(s)[a]` if `a` leads from $s$ to $s'$ (e.g. `a` can be, \"add a raised eyebrow\")." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wKuO8kjd-KeC" + }, + "outputs": [], + "source": [ + "class FlowModel(nn.Module):\n", + " def __init__(self, num_hid):\n", + " super().__init__()\n", + " self.mlp = nn.Sequential(\n", + " nn.Linear(6, num_hid), # Input state is a binary vector representing feature\n", + " # presence and/or absence.\n", + " nn.LeakyReLU(),\n", + " nn.Linear(num_hid, 6) # Output 6 numbers for the 6 actions (child states).\n", + "\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.mlp(x).exp() # Flows must be positive, so we take the exponential." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O_dOaq7F4QrI" + }, + "source": [ + "Another important thing we need to define is how we deal with parents. Since we'll be using the flow-matching objective to make the _flow consistency_ equation respected, we need to be able to enumerate the $(s, s')$ pairs that are \"parents\" of $s'$.\n", + "\n", + "In the left sum $$\\sum_{s: (s,s')\\in\\mathcal{E}} F(s,s') = R(s') + \\sum_{s'':(s',s'')\\in\\mathcal{E}} F(s',s'')$$\n", + "the set $\\{s: (s,s')\\in\\mathcal{E}\\}$ is the set of parents of $s'$, while in the right sum, it is the set of children of $s'$. Since we're parameterizing $F$ with something that outputs a vector, computing the sum over children flows on the right is easy, we simply take `F(s').sum()`. But on the left, we need to do one forward pass for each parent to basically take `sum([F(ps)[pa] for ps, pa in parents(s')])` (we will see later in the tutorial that this is avoidable)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FCP6HZit4Pqr" + }, + "outputs": [], + "source": [ + "# TO IMPLEMENT.\n", + "def face_parents(state):\n", + " parent_states = [] # States that are parents of state.\n", + " parent_actions = [] # Actions that lead from those parents to state.\n", + "\n", + " for feature in state:\n", + " # For each face part, there is a parent without that part.\n", + " parent_states.append([i for i in state if i != feature])\n", + "\n", + " # The action to get there is the corresponding index of that face part.\n", + " parent_actions.append(FEATURE_KEYS.index(feature))\n", + "\n", + " return parent_states, parent_actions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ngrMxOMNi-Cz" + }, + "source": [ + "Finally, to actually train the model we'll use the simplest differentiable loss possible, by just turning the above equation into a mean squared error (there are more efficient losses, but we will start with this as it is simplest):\n", + "$$L(s') = \\left(\\sum_{s: (s,s')\\in\\mathcal{E}} F(s,s') - R(s') - \\sum_{s'':(s',s'')\\in\\mathcal{E}} F(s',s'')\\right)^2$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8CDBa8Rf40e9" + }, + "outputs": [], + "source": [ + "# TO IMPLEMENT.\n", + "def flow_matching_loss(incoming_flows, outgoing_flows, reward):\n", + " \"\"\"Flow matching objective converted into mean squared error loss.\"\"\"\n", + " return (incoming_flows.sum() - outgoing_flows.sum() - reward).pow(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vz1bG57fUoWo" + }, + "source": [ + "# Hyperparameters\n", + "\n", + "Previously, we defined some hyperparameters that we will use for all following demonstrations:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r_kFB8wgUnbp", + "outputId": "5dd85c88-0918-4415-b9dc-78465fe571b0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For all experiments, our hyperparameters will be:\n", + " + n_hid_units=512\n", + " + n_episodes=10000\n", + " + learning_rate=0.003\n" + ] + } + ], + "source": [ + "# @title\n", + "print(\"For all experiments, our hyperparameters will be:\")\n", + "print(\" + n_hid_units={}\".format(n_hid_units))\n", + "print(\" + n_episodes={}\".format(n_episodes))\n", + "print(\" + learning_rate={}\".format(learning_rate))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4Q0qdo9146Zj" + }, + "source": [ + "We're now ready to instantiate and train the model. First, we let the model generate its own data by following its own policy (i.e., sampling actions based on edge flow predictions), and simply train on that data. Let's go through this code and then run it for a minute." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ot0qdZ-K4PsF", + "outputId": "ec0c37f6-4869-44e0-a3d1-6da165e362e4" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter (loss=0.049533): 100%|██████████| 10000/10000 [00:52<00:00, 188.94it/s]\n" + ] + } + ], + "source": [ + "# Instantiate model n_hid_units optimizer\n", + "F_sa = FlowModel(n_hid_units)\n", + "opt = torch.optim.Adam(F_sa.parameters(), learning_rate)\n", + "\n", + "# To not complicate the code, I'll just accumulate losses here and take a\n", + "# gradient step every `update_freq` episode (at the end of each trajectory).\n", + "losses, sampled_faces = [], []\n", + "minibatch_loss = 0\n", + "update_freq = 4\n", + "\n", + "tbar = trange(n_episodes, desc=\"Training iter\")\n", + "for episode in tbar:\n", + " state = [] # Each episode starts with an empty state.\n", + " edge_flow_preds = F_sa(face_to_tensor(state)) # Predict F(s, a).\n", + "\n", + " for t in range(3): # All trajectories are length 3 (not including s0).\n", + " # Normalizing gives us the probability of each action, from which we can\n", + " # sample actions to obtain the next state.\n", + "\n", + " # TO COMPLETE: Sample the action.\n", + " policy = edge_flow_preds / edge_flow_preds.sum()\n", + " action = Categorical(probs=policy).sample() # TADA! We .sample()'ed!\n", + "\n", + " new_state = state + [FEATURE_KEYS[action]]\n", + "\n", + " # To compute the loss, we'll first enumerate the parents, then compute\n", + " # the edge flows F(s, a) of each parent, indexing to get relevant flows.\n", + " parent_states, parent_actions = face_parents(new_state)\n", + " ps = torch.stack([face_to_tensor(p) for p in parent_states])\n", + " pa = torch.tensor(parent_actions).long()\n", + " parent_edge_flow_preds = F_sa(ps)[torch.arange(len(parent_states)), pa]\n", + "\n", + " # TO COMPLETE: (with hints).\n", + " if t == 2: # End of trajectory.\n", + " # We calculate the reward and set F(s,a) = 0 \\forall a, since there\n", + " # are no children of this state.\n", + " reward = face_reward(new_state)\n", + " edge_flow_preds = torch.zeros(6)\n", + " else:\n", + " # We compute F(s, a) and set the reward to zero.\n", + " reward = 0\n", + " edge_flow_preds = F_sa(face_to_tensor(new_state))\n", + "\n", + " minibatch_loss += flow_matching_loss( # Accumulate.\n", + " parent_edge_flow_preds,\n", + " edge_flow_preds,\n", + " reward,\n", + " )\n", + " state = new_state # Continue iterating.\n", + "\n", + " # We're done with the episode, add the face to the list, and if we are at an\n", + " # update episode, take a gradient step.\n", + " sampled_faces.append(state)\n", + " if episode % update_freq == 0:\n", + "\n", + " # Normalize accumulated loss.\n", + " minibatch_loss = minibatch_loss / (update_freq)\n", + " losses.append(minibatch_loss.item())\n", + " tbar.set_description(\"Training iter (loss={:.6f})\".format(minibatch_loss))\n", + " minibatch_loss.backward()\n", + " opt.step()\n", + " opt.zero_grad()\n", + " minibatch_loss = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Qfiyp_UAjCd6" + }, + "source": [ + "*We* now trained the model for a little while. It's not perfect but the loss seems low enough:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 333 + }, + "id": "gLppRbOk4Pua", + "outputId": "14b9abce-dce0-483c-bcca-09e9434e1b6c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_curve(losses, title=\"Loss over Training Iterations using the Flow Matching Objective\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g73O48sojKJi" + }, + "source": [ + "Let's see what kind of faces the model is generating. Remember that we set the reward of smiling faces to 2 and the reward of frowny faces to 1. Since there are 4 possible smile and frown faces respectively (i.e. an equal number), we should expect there to be 2/3 smiling faces and 1/3 frowny faces when sampling from the model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 380 + }, + "id": "B2JT1ZIR4Pw2", + "outputId": "6efa1651-d4ea-46a5-ba6c-ac828f1c30f1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ratio of faces with a smile:0.7109375, ideal=0.6666666666666666\n", + "Proportion of valid faces:0.9375, ideal=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_sampled_faces(sampled_faces)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5W78EVVkjWkg" + }, + "source": [ + "And we can visualize the edge flows. Note two things:\n", + "\n", + "\n", + "\n", + "* Flows near the source node (initial state) are generally larger than terminal flows.\n", + "* The model has learned to ascribe low flows to invalid configurations.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 836 + }, + "id": "2Vy3vOaKjP0N", + "outputId": "d1179530-46a1-42c0-8664-1c24a1da214a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_state_space(model=F_sa)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L1fYebctjeGP" + }, + "source": [ + "Well, the results look OK, but not great. We're still sampling invalid faces, and we're not sampling the correct proportion of happy to sad faces.\n", + "\n", + "One interesting side effect of training a GFlowNet model is that the flow of the initial state _is the partition function_. $F(s_0)$ is the sum of all rewards in the network (in the state space) since, in terms of flows, it is the unique source to all the sinks (which each sink in $R(x)$ flow).\n", + "\n", + "Since we have 4 terminal smiling states and 4 frowny ones with rewards 2 and 1 respectively, the total reward is $8 + 4 = 12$. Let's see if the model has learned that:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pcQY_JVF4E8l", + "outputId": "6dbd2509-dd05-44d8-85aa-c701e9c8cd19" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final Z (partition function) estimate is 7.95\n" + ] + } + ], + "source": [ + "print(\"The final Z (partition function) estimate is {:.2f}\".format(\n", + " F_sa(face_to_tensor([])).sum())\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iqD-1gkI7DE-" + }, + "source": [ + "We're heading in the right direction, but we aren't there yet.\n", + "\n", + "# Action Masking\n", + "\n", + "At this point you might be wondering: if we don't want our trained sampler to ever sample an invalid face, why should we allow it turing training? That's a big waste of time. You would be right. We can learn to not sample a particular face by providing a low reward for that face and training for long enough, but we can also simply disallow that face from being constructed in the first place by masking those actions during training. This greatly speeds up convergence, and is a common practice when using GFNs with reasonably challenging applications.\n", + "\n", + "We'll calculate a mask which we apply to the `edge_flow_preds` vector (our unnormalized distribution over next actions), such that we never sample a masked state. Otherwise, our training loop remains the same." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gQx7B-kQ9qYw" + }, + "outputs": [], + "source": [ + "def calculate_forward_mask_from_state(state):\n", + " \"\"\"Here, we mask forward actions to prevent the selection of invalid configurations.\n", + " Recall our feature space is:\n", + " [smile, frown, left_eb_down, left_eb_up, right_eb_down, right_eb_up]\n", + " So we can only select one element from [0,1], [2,3], and [4,5].\n", + " \"\"\"\n", + " mask = np.ones(6)\n", + "\n", + " if \"smile\" in state or \"frown\" in state:\n", + " mask[:2] = 0\n", + " if \"left_eb_down\" in state or \"left_eb_up\" in state:\n", + " mask[2:4] = 0\n", + " if \"right_eb_down\" in state or \"right_eb_up\" in state:\n", + " mask[4:] = 0\n", + "\n", + " return torch.Tensor(mask).bool()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Hhqf47ib7Sp6", + "outputId": "59ddbd7c-aa89-439a-e00b-055b3d3b8967" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training iter (loss=0.013763): 100%|██████████| 10000/10000 [00:45<00:00, 220.62it/s]\n" + ] + } + ], + "source": [ + "# Instantiate model and optimizer\n", + "F_sa = FlowModel(n_hid_units)\n", + "opt = torch.optim.Adam(F_sa.parameters(), learning_rate)\n", + "\n", + "# To not complicate the code, I'll just accumulate losses here and take a\n", + "# gradient step every `update_freq` episode (at the end of each trajectory).\n", + "losses_masking, sampled_faces = [], []\n", + "minibatch_loss = 0\n", + "update_freq = 4\n", + "\n", + "tbar = trange(n_episodes, desc=\"Training iter\")\n", + "for episode in tbar:\n", + " state = [] # Each episode starts with an empty state.\n", + " edge_flow_preds = F_sa(face_to_tensor(state)) # Predict F(s, a).\n", + "\n", + " for t in range(3): # All trajectories are length 3 (not including s0).\n", + "\n", + " # Here we mask the relevant forward actions.\n", + " mask = calculate_forward_mask_from_state(state)\n", + " edge_flow_preds = edge_flow_preds * mask # Removes invalid forward actions.\n", + "\n", + " # Normalizing gives us the probability of each action, from which we can\n", + " # sample actions to obtain the next state.\n", + " policy = edge_flow_preds / edge_flow_preds.sum()\n", + " action = Categorical(probs=policy).sample() # TADA! We .sample()'ed!\n", + " new_state = state + [FEATURE_KEYS[action]]\n", + "\n", + " # To compute the loss, we'll first enumerate the parents, then compute\n", + " # the edge flows F(s, a) of each parent, indexing to get relevant flows.\n", + " parent_states, parent_actions = face_parents(new_state)\n", + " ps = torch.stack([face_to_tensor(p) for p in parent_states])\n", + " pa = torch.tensor(parent_actions).long()\n", + " parent_edge_flow_preds = F_sa(ps)[torch.arange(len(parent_states)), pa]\n", + "\n", + " if t == 2: # End of trajectory.\n", + " # We calculate the reward and set F(s,a) = 0 \\forall a, since there\n", + " # are no children of this state.\n", + " reward = face_reward(new_state)\n", + " edge_flow_preds = torch.zeros(6)\n", + "\n", + " else:\n", + " # We compute F(s, a) and set the reward to zero.\n", + " reward = 0\n", + " edge_flow_preds = F_sa(face_to_tensor(new_state))\n", + "\n", + " minibatch_loss += flow_matching_loss( # Accumulate.\n", + " parent_edge_flow_preds,\n", + " edge_flow_preds,\n", + " reward,\n", + " )\n", + " state = new_state # Continue iterating.\n", + "\n", + " # We're done with the episode, add the face to the list, and if we are at an\n", + " # update episode, take a gradient step.\n", + " sampled_faces.append(state)\n", + " if episode % update_freq == 0:\n", + "\n", + " # Normalize accumulated loss.\n", + " minibatch_loss = minibatch_loss / (update_freq)\n", + " losses_masking.append(minibatch_loss.item())\n", + " tbar.set_description(\"Training iter (loss={:.6f})\".format(minibatch_loss))\n", + " minibatch_loss.backward()\n", + " opt.step()\n", + " opt.zero_grad()\n", + " minibatch_loss = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S0iTuMkda1rF" + }, + "source": [ + "We can see this had a big effect on convergence:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 354 + }, + "id": "-Axzwc-GBolh", + "outputId": "9bdec36a-04b0-46ee-a4d7-e182b238409f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_curve(\n", + " losses,\n", + " losses_B=losses_masking,\n", + " title=\"Loss over Training Iterations using the Flow Matching Objective\\nWith and Without Forward Masks\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BjIEiJbba01f" + }, + "source": [ + "And we can also see a big change in the sampling distribution. Namely, we are now sampling only valid configurations, and the sampling proportion is pretty close." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 380 + }, + "id": "pds5ctnjGRI9", + "outputId": "d934f72d-a993-4727-9074-ee315eab16b5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ratio of faces with a smile:0.609375, ideal=0.6666666666666666\n", + "Proportion of valid faces:1.0, ideal=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_sampled_faces(sampled_faces)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jtjBgVeHbGts" + }, + "source": [ + "And our estimate of the partition function is improved, but not yet there:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Rhi15fSFHCp1", + "outputId": "c8192b1f-7771-4e70-d513-c83f01c80be2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final Z (partition function) estimate is 13.74\n" + ] + } + ], + "source": [ + "print(\"The final Z (partition function) estimate is {:.2f}\".format(\n", + " F_sa(face_to_tensor([])).sum()\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xY4N4y-fjnpY" + }, + "source": [ + "# Trajectory Balance\n", + "\n", + "[Trajectory Balance: Improved Credit Assignment in GFlowNets, Nikolay Malkin, Moksh Jain, Emmanuel Bengio, Chen Sun, Yoshua Bengio](https://arxiv.org/abs/2201.13259)\n", + "\n", + "So far we've thought of flow-consistency very locally by considering a single state and looking at all the flow coming into that state and out of that state.\n", + "\n", + "Let's instead think about the flow _trajectories_ $\\tau$. If you think of all the possible paths from the initial state $s_0$ to some state $s$, each path can be \"assigned\" some amount of flow (just as we \"assigned\" flows to edges earlier). If we adopt this view, we can say we want all of the trajectory flows that go to a state to equal its reward (just like we wanted all incoming flows to a terminal state to be equal to its reward $R(x)$).\n", + "\n", + "$$F(s) = \\sum_{\\tau, s\\in\\tau} F(\\tau)$$\n", + "\n", + "We can also write the probability of a particular trajectory as the product of its policy steps:\n", + "\n", + "$$P(\\tau) = \\prod_{(s,s') \\in \\tau} P_F(s'|s) =\\frac{1}{Z}F(\\tau)$$.\n", + "\n", + "Note the relationship of $P(\\tau)$ with $F(\\tau)$, which asks \"what fraction of the total flow $Z$ goes through $\\tau$?\".\n", + "\n", + "We can equivilantly think of _backward_ trajectories using a backward policy $P_B$, which gives the distribution over the parents of a state, with the following property\n", + "\n", + "$$P(\\tau) = \\prod_{(s,s') \\in \\tau} P_B(s|s')$$\n", + "\n", + "A bit of rearranging (see paper), let $\\tau=(s_0,...,s_n=x)$ gives us this equality:\n", + "\n", + "$$Z \\prod_{t} P_F(s_{t+1}|s_t) = R(x)\\prod_t P_B(s_t|s_{t+1})$$\n", + "\n", + "\n", + "Here's an intuitive view of what this means. Since all the incoming flow to a terminal state must be preserved, you can think of it being \"split up\" into different flows (one for each parent of that state). Since $P_B$ is a distribution, and therefore sums to 1, it does that splitting.\n", + "\n", + "> $R(x)\\prod_t P_B(s_t|s_{t+1})$ represents \"what fraction of the reward goes through this particular trajectory?\"\n", + "\n", + "The other side of this equation insteads splits up the partition function $Z$.\n", + "\n", + "> $Z \\prod_{t} P_F(s_{t+1}|s_t)$ represents \"what fraction of the partition function goes through this trajectory?\"\n", + "\n", + "and the equality enforces that those two quantities are equal.\n", + "\n", + "## Implementing Trajectory Balance\n", + "\n", + "Since we assume $R(x)$ is given, we'll now need to estimate $Z$, $P_B$ and $P_F$. In the last exercise, we modeled $F(s,a)$ directly, but as the number of states grows, this is not ideal. Instead, implementations of GFlowNet typically model $\\log F(s, a)$ (just like we typically train classifiers with a logsoftmax rather than predicting the probabilities directly). We will do the same thing here and actually estimate $\\log Z$ as well as the logits of $P_B$ and $P_F$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ezWPUujDjkg8" + }, + "outputs": [], + "source": [ + "class TBModel(nn.Module):\n", + " def __init__(self, num_hid):\n", + " super().__init__()\n", + " self.mlp = nn.Sequential(\n", + " nn.Linear(6, num_hid), # 6 input features.\n", + " nn.LeakyReLU(),\n", + " nn.Linear(num_hid, 12), # 12 outputs: 6 for P_F and 6 for P_B.\n", + " )\n", + " self.logZ = nn.Parameter(torch.ones(1)) # log Z is just a single number.\n", + "\n", + " def forward(self, x):\n", + " logits = self.mlp(x)\n", + " # Slice the logits into forward and backward policies.\n", + " P_F = logits[..., :6]\n", + " P_B = logits[..., 6:]\n", + "\n", + " return P_F, P_B" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5bNPW0fjkFm3" + }, + "source": [ + "Just like we turned the flow-matching equation into a MSE loss, we will use the following loss for a trajectory:\n", + "$$L(\\tau) = \\left(\\log \\frac{Z_\\theta \\prod_t P_F(s_{t+1}|s_t;\\theta)}{R(x)\\prod_t P_B(s_t|s_{t+1}; \\theta)} \\right)^2$$\n", + "\n", + "or equivalently\n", + "$$L(\\tau) = \\left(\\log Z_\\theta + \\sum_t \\log P_F(s_{t+1}|s_t;\\theta) - \\log R(x) - \\sum_t \\log P_B(s_t|s_{t+1}; \\theta) \\right)^2$$\n", + "\n", + "You may notice that in this loss there is no need to compute parents! In the current toy example this won't make a difference, but when generating complex objects this saves us O(average number of parents) forward passes.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fdvANn9RXFFU" + }, + "outputs": [], + "source": [ + "# TO IMPLEMENT.\n", + "def trajectory_balance_loss(logZ, log_P_F, log_P_B, reward):\n", + " \"\"\"Trajectory balance objective converted into mean squared error loss.\"\"\"\n", + " return (logZ + log_P_F - torch.log(reward) - log_P_B).pow(2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4WiUALPNA2Gn" + }, + "outputs": [], + "source": [ + "def calculate_backward_mask_from_state(state):\n", + " \"\"\"Here, we mask backward actions to only select parent nodes.\"\"\"\n", + " return torch.Tensor(\n", + " [1 if feature in state else 0 for feature in FEATURE_KEYS]\n", + " ).bool()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ROU2rrWnXKts" + }, + "source": [ + "Again we will roll out trajectories, then compute the loss after each trajectory and take gradient steps at some frequency. Let's train the model for a minute." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eUC059-SkCrP", + "outputId": "d4c74144-5601-4d70-8fde-c23a1c83cc6d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█| 10000/10000 [00:46<00:00, 215.73\n" + ] + } + ], + "source": [ + "# Instantiate model and optimizer\n", + "model = TBModel(n_hid_units)\n", + "opt = torch.optim.Adam(model.parameters(), learning_rate)\n", + "\n", + "# To not complicate the code, I'll just accumulate losses here and take a\n", + "# gradient step every `update_freq` episode (at the end of each trajectory).\n", + "losses, sampled_faces, logZs = [], [], []\n", + "minibatch_loss = 0\n", + "update_freq = 4\n", + "\n", + "for episode in tqdm(range(n_episodes), ncols=40):\n", + " state = [] # Each episode starts with an empty state.\n", + " P_F_s, P_B_s = model(face_to_tensor(state)) # Forward and backward policy\n", + " total_log_P_F, total_log_P_B = 0, 0\n", + "\n", + " for t in range(3): # All trajectories are length 3 (not including s0).\n", + "\n", + " # Here we mask the relevant forward actions.\n", + " mask = calculate_forward_mask_from_state(state)\n", + " P_F_s = torch.where(mask, P_F_s, -100) # Removes invalid forward actions.\n", + "\n", + " # TO IMPLEMENT w hints.\n", + " # Here P_F is logits, so we use Categorical to compute a softmax.\n", + " categorical = Categorical(logits=P_F_s)\n", + " action = categorical.sample() # TADA! We .sample()'ed!\n", + " new_state = state + [FEATURE_KEYS[action]] # \"Go\" to next state.\n", + " total_log_P_F += categorical.log_prob(action) # Accumulate the log_P_F sum.\n", + "\n", + " if t == 2: # End of trajectory.\n", + " reward = torch.tensor(face_reward(new_state)).float()\n", + "\n", + " # We recompute P_F and P_B for new_state.\n", + " P_F_s, P_B_s = model(face_to_tensor(new_state))\n", + " mask = calculate_backward_mask_from_state(new_state)\n", + " P_B_s = torch.where(mask, P_B_s, -100) # Removes invalid backward actions.\n", + "\n", + " # Accumulate P_B, going backwards from `new_state`. We're also just\n", + " # going to use opposite semantics for the backward policy. I.e., for\n", + " # P_F action `i` added feature `i`, so for P_B action `i` removes\n", + " # feature `i`, this way we can just keep the same indices.\n", + " # TO IMPLEMENT w hints.\n", + " total_log_P_B += Categorical(logits=P_B_s).log_prob(action)\n", + "\n", + " state = new_state # Continue iterating.\n", + "\n", + " # We're done with the trajectory, let's compute its loss. Since the reward\n", + " # can sometimes be zero, instead of log(0) we'll clip the log-reward to -20.\n", + " minibatch_loss += trajectory_balance_loss(\n", + " model.logZ,\n", + " total_log_P_F,\n", + " total_log_P_B,\n", + " reward,\n", + " )\n", + "\n", + " # We're done with the episode, add the face to the list, and if we are at an\n", + " # update episode, take a gradient step.\n", + " sampled_faces.append(state)\n", + " if episode % update_freq == 0:\n", + " losses.append(minibatch_loss.item())\n", + " logZs.append(model.logZ.item())\n", + " minibatch_loss.backward()\n", + " opt.step()\n", + " opt.zero_grad()\n", + " minibatch_loss = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LJbkZyIqkO7n" + }, + "source": [ + "Once again we can plot the loss and see that it's generally going down. We could do much better in terms of hyperparameters or learning rate scheduling, but for the purposes of this tutorial we'll leave it at that.\n", + "\n", + "Another thing we can see is that the value of $Z$ we're estimating reaches around 12 once again, confirming that the model \"learned about\" all possible rewards." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 619 + }, + "id": "dbHGmNz6kLqx", + "outputId": "473e370c-8cdf-4189-8a06-7361243a731c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Loss and Estimated Partition Function for the Trajectory Balance Model')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 1, figsize=(10, 6))\n", + "plt.sca(ax[0])\n", + "plt.plot(losses, color=\"black\")\n", + "plt.yscale('log')\n", + "plt.ylabel('Loss')\n", + "plt.sca(ax[1])\n", + "plt.plot(np.exp(logZs), color=\"black\")\n", + "plt.ylabel('Estimated Z');\n", + "plt.xlabel('Step')\n", + "plt.suptitle(\"Loss and Estimated Partition Function for the Trajectory Balance Model\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VtP4TiKxkVoJ" + }, + "source": [ + "This is the final value we get:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YRktx2rWkUzL", + "outputId": "1f82a63e-658f-42e0-cbd6-9db9158554b2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final Z (partition function) estimate is 12.00\n" + ] + } + ], + "source": [ + "print(\"The final Z (partition function) estimate is {:.2f}\".format(\n", + " model.logZ.exp().item())\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9kbvp88gkbvJ" + }, + "source": [ + "And we can once again check that we get about 2/3 of smiley samples and only valid samples." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 380 + }, + "id": "splrw97YkTFl", + "outputId": "90c72f8c-05dd-4728-a0a8-c87855151816" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ratio of faces with a smile:0.671875, ideal=0.6666666666666666\n", + "Proportion of valid faces:1.0, ideal=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_sampled_faces(sampled_faces)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SsmyL4cFZj81" + }, + "source": [ + "# `torchgfn`\n", + "\n", + "Now that we've walked through how to sample happy faces twice as often as frowny faces, let's look at how to implement this using the lightweight `torchgfn` library.\n", + "\n", + "We'll duplicate the relevant logic from above, to create self-contained examples below (just make sure you run the first two cells of this notebook to add the features). First, let's set up the python environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "AN0u6hy7Q3kj" + }, + "outputs": [], + "source": [ + "from torchtyping import TensorType as TT\n", + "from typing import ClassVar, Tuple, cast\n", + "\n", + "import gfn\n", + "from gfn.actions import Actions\n", + "from gfn.env import DiscreteEnv\n", + "from gfn.gflownet import FMGFlowNet, TBGFlowNet\n", + "from gfn.modules import DiscretePolicyEstimator, ScalarEstimator\n", + "from gfn.preprocessors import IdentityPreprocessor\n", + "from gfn.states import DiscreteStates\n", + "from gfn.utils.modules import NeuralNet" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4Rm5G7ZLV02g" + }, + "source": [ + "## `torchgfn` Smile Environment\n", + "\n", + "First, we need to define an environment for our `gflownet` to interact with. Face construction (at least, as defined here) is a discrete action space, so we will leverage the `gfn.env.DiscreteEnv` base class, as well as the `Actions` class.\n", + "\n", + "Each environment in torchgfn must generate an instance of the `States` class, which (in the discrete case) uses `masks` to define allowable actions, define whether the trajectory is complete, and backward actions to reach parent states. In `torchgfn` the forward action space (which in our case is the addition of 1 out of 6 facial features) has an additional *exit action*, which the framework uses to end a trajectory. The sampling process continues until all batch elements have exited. In our case, all trajectories are exactly length 3, so this is simple: we mask out the exit action until 3 non-exit actions have been selected, and then we mask all actions *except* exit to ensure the trajectory terminates.\n", + "\n", + "We must also define the `s0` (initial) and `sf` (final) state. In this case, `s0` is simply all zero, and `sf` is all `-1` (but it could be anything that does not look like a normal state tensor).\n", + "\n", + "We also define the `reward` using vectorized logic. Note that `torchgfn` uses `log_rewards()` internally, and since we have a reward of `0`, we must clip the `log_reward` (since `log(0) = -inf`). This clipping is handled automatically for us, and the clipping can be tuned using the `log_reward_clip` flag if so desired." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "92RxW4V7aLk7" + }, + "outputs": [], + "source": [ + "class FacesEnv(DiscreteEnv):\n", + " def __init__(self, log_reward_clip=-100, mask_invalid_actions=True):\n", + " \"\"\"Faces environment. States are represented as 6-element binary tensors.\n", + "\n", + " All trajectories are enforced to be length 3 using states.forward_masks.\n", + " \"\"\"\n", + " self.feature_keys = [\n", + " 'left_eb_down',\n", + " 'left_eb_up',\n", + " 'right_eb_down',\n", + " 'right_eb_up',\n", + " 'smile',\n", + " 'frown',\n", + " ]\n", + " self.device = torch.device(\"cpu\")\n", + " self.log_reward_clip = log_reward_clip\n", + " self.mask_invalid_actions = mask_invalid_actions\n", + "\n", + " state_dim = len(self.feature_keys)\n", + " n_actions = state_dim + 1 # all 6 face elements + 1 exit action.\n", + "\n", + " super().__init__(\n", + " n_actions=n_actions,\n", + " # We start with an empty face.\n", + " s0=torch.zeros(state_dim, dtype=torch.float, device=self.device),\n", + " # Sf represents when a trajectory is done (we selected the exit action).\n", + " sf=torch.ones(state_dim, dtype=torch.float, device=self.device) * -1,\n", + " device_str=\"cpu\",\n", + " # These are sometimes handy to generate tensors. In this case, not needed.\n", + " preprocessor=IdentityPreprocessor(output_dim=state_dim)\n", + " )\n", + "\n", + " def make_States_class(self) -> type[DiscreteStates]:\n", + " \"Creates a States class for this environment\"\n", + " env = self\n", + "\n", + " class FaceStates(DiscreteStates):\n", + " state_shape: ClassVar[tuple[int, ...]] = (env.n_actions - 1,) # this is 6.\n", + " s0 = env.s0 # this is 6 zeros.\n", + " sf = env.sf # this is 6 -1's.\n", + " n_actions = env.n_actions # this is 7. 6 features, plus 1 for exit.\n", + " device = env.device\n", + "\n", + " def update_masks(self) -> None:\n", + " \"Update the masks based on the current states.\"\n", + " # Backward masks are simply any action we've already taken.\n", + " self.backward_masks = self.tensor != 0 # n - 1 actions.\n", + "\n", + " # Forward masks begin as allowing any action. Allowed actions are 1.\n", + " self.init_forward_masks(set_ones=True)\n", + "\n", + " # Then, we remove any done action, and also the exit action.\n", + " self.set_nonexit_masks(self.tensor == 1, allow_exit=False)\n", + "\n", + " if env.mask_invalid_actions:\n", + " # Now we remove invalid actions. Here we are enforcing that\n", + " # only one left eyebrow, one right eyebrow, and one smile can be\n", + " # selected. 0 = not allowed.\n", + " invalid_actions = torch.ones(self.forward_masks.shape).bool()\n", + " invalid_actions[..., 0][self.tensor[..., 1].bool()] = 0 # l_eb\n", + " invalid_actions[..., 1][self.tensor[..., 0].bool()] = 0 # l_eb\n", + " invalid_actions[..., 2][self.tensor[..., 3].bool()] = 0 # r_eb\n", + " invalid_actions[..., 3][self.tensor[..., 2].bool()] = 0 # r_eb\n", + " invalid_actions[..., 4][self.tensor[..., 5].bool()] = 0 # smile\n", + " invalid_actions[..., 5][self.tensor[..., 4].bool()] = 0 # smile\n", + "\n", + " self.forward_masks = (self.forward_masks * invalid_actions)\n", + "\n", + " # Trajectories must be length 3. Any trajectory that has taken 3 actions\n", + " # should be forced to exit.\n", + " batch_idx = self.tensor.sum(-1) >= 3\n", + " self.set_exit_masks(batch_idx)\n", + "\n", + " return FaceStates\n", + "\n", + " def maskless_step(\n", + " self, states: DiscreteStates, actions: Actions\n", + " ) -> TT[\"batch_shape\", \"state_shape\", torch.float]:\n", + " return states.tensor.scatter(-1, actions.tensor, 1, reduce=\"add\")\n", + "\n", + " def maskless_backward_step(\n", + " self, states: DiscreteStates, actions: Actions\n", + " ) -> TT[\"batch_shape\", \"state_shape\", torch.float]:\n", + " return states.tensor.scatter(-1, actions.tensor, -1, reduce=\"add\")\n", + "\n", + " def reward(self, states: DiscreteStates) -> TT[\"batch_shape\", torch.float]:\n", + " \"\"\"The face reward is calculated as:\n", + " + 0 if the face is invalid (overlapping features OR not satisfying\n", + " the constraint of 2 eyebrows and 1 mouth).\n", + " + This will only be possible if `mask_invalid_actions` is False.\n", + " + 1 if the face is frowny. :(\n", + " + 2 if the face is smiley. :)\n", + " \"\"\"\n", + " if not env.mask_invalid_actions:\n", + " # Tensor organization is [left_eb *2, right_eb * 2, mouth * 2]\n", + " valid = torch.zeros(states.batch_shape + (3,))\n", + " valid[..., 0] = states.tensor[..., :2].sum(-1) == 1 # One left eyebrow.\n", + " valid[..., 1] = states.tensor[..., 2:4].sum(-1) == 1 # One right eyebrow.\n", + " valid[..., 2] = states.tensor[..., 4:].sum(-1) == 1 # One mouth.\n", + " valid = valid.prod(-1, keepdim=True) # Two eyebrows, one mouth.\n", + "\n", + " # Add the emotion rewards.\n", + " rewards = torch.zeros(states.batch_shape + (1,))\n", + " rewards[states.tensor[..., 4] == 1] = torch.tensor([2]) # Smiles.\n", + " rewards[states.tensor[..., 5] == 1] = torch.tensor([1]) # Frowns.\n", + "\n", + " if not env.mask_invalid_actions:\n", + " rewards = rewards * valid # This will remove any double mouths.\n", + "\n", + " return rewards.squeeze()\n", + "\n", + "env = FacesEnv()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kg6xAWT2Qu1d" + }, + "source": [ + "# A `torchgfn` Training Loop\n", + "\n", + "In this simple example, we use the environment's `States` class to keep track of our terminal states (our sampled faces). Our `gflownet` allows us to sample batches of trajectories, and allows us to calculate the loss using the `env` (which contains our reward function) and `samples`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "z3w9PQU0QyIU" + }, + "outputs": [], + "source": [ + "def train(gflownet, optimizer, env, batch_size = 128, n_episodes = 25_000):\n", + " \"\"\"Training loop, keeping track of terminal states over training.\"\"\"\n", + " # This stores example terminating states.\n", + " visited_terminating_states = env.States.from_batch_shape((0,))\n", + " states_visited = 0\n", + " losses = []\n", + "\n", + " for iteration in trange(n_episodes // batch_size):\n", + " trajectories = gflownet.sample_trajectories(env, n_samples=batch_size) # Temperature\n", + " samples = gflownet.to_training_samples(trajectories)\n", + " optimizer.zero_grad()\n", + " loss = gflownet.loss(env, samples)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " visited_terminating_states.extend(trajectories.last_states)\n", + " states_visited += len(trajectories)\n", + " losses.append(loss.item())\n", + "\n", + " return visited_terminating_states, states_visited, losses" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "meNtpO0VCxsS" + }, + "source": [ + "## Flow Matching with `torchgfn`\n", + "\n", + "The details of the Flow Matching objective are handled within the `FMGFlowNet` class, which requires us to provide it with an `estimator`, which is simply a neural network that accepts a state and produces logits over next actions. Under the hood, all `gflownets` in `torchgfn` inherit from `nn.Module` and function as expected (e.g., see `gflownet.parameters()`).\n", + "\n", + "Note that for numerical stability reasons, we estimate the log edge flows here, not the edge flows as we did in the above example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-MZpRVULBp5r", + "outputId": "ff931826-8927-4d2b-cc72-df3b49c70fc9" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 781/781 [00:30<00:00, 26.01it/s]\n" + ] + } + ], + "source": [ + "# nn.Module that estimates _log_ edge flows.\n", + "module = NeuralNet(\n", + " input_dim=env.preprocessor.output_dim,\n", + " output_dim=env.n_actions,\n", + " hidden_dim=n_hid_units,\n", + " n_hidden_layers=1,\n", + ")\n", + "# This is our _log_ edge flow estimator.\n", + "estimator = DiscretePolicyEstimator(\n", + " module=module,\n", + " n_actions=env.n_actions,\n", + " preprocessor=env.preprocessor,\n", + ")\n", + "\n", + "# The gflownet class wraps our estimator (inclusing sampler functionality).\n", + "gflownet = FMGFlowNet(estimator)\n", + "optimizer = torch.optim.Adam(gflownet.parameters(), lr=learning_rate) # TODO: Verify.\n", + "\n", + "visited_terminating_states, states_visited, losses = train(\n", + " gflownet,\n", + " optimizer,\n", + " env,\n", + " n_episodes=n_episodes * 10,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BU8M3lWLXQU2" + }, + "source": [ + "We can now see that our flow matching network is sampling faces as expected:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 362 + }, + "id": "vei7EVHe7Vj2", + "outputId": "dc512a4d-6541-4dbd-d9bb-522dcd582a41" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "proportion of smiles:frowns = 0.6796875:0.3203125\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "analyze_torchgfn_results(visited_terminating_states, env)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L9RQOhynW3fr" + }, + "source": [ + "And our loss curve is reasonable:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 333 + }, + "id": "4Xg_IPaHWvZy", + "outputId": "c3ba9fe4-6eae-4035-eb20-a32501dd48b4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_curve(losses, title=\"Loss Curve for Flow Matching Objective using TorchGFN\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MjvrVwpZqNfq" + }, + "source": [ + "To evaluate the flows at $S_0$, we first need to make an instance of the env's `States` class, and then pass that class an all-zero (empty) state. Finally, this $S_0$ states object can be passed to our trained estimator (estimators are wrappers for `nn.Modules`,\n", + "which know to handle `States` classes).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A5Kq52J0Ipoa", + "outputId": "d8ef424a-60e4-4c4a-d18f-b477321a2d58" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Partition function estimate Z=12.00\n" + ] + } + ], + "source": [ + "# Note that here, we have the log edge flows, so we take the sum(exp(log_flows)) to\n", + "# calculate the partition function estimate.\n", + "s_0 = env.make_States_class()(torch.zeros(6))\n", + "print(\"Partition function estimate Z={:.2f}\".format(\n", + " sum(torch.exp(estimator(s_0)[:6])) # logsumexp.\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XoTopzlxCmgP" + }, + "source": [ + "# Trajectory Balance with `torchgfn`\n", + "\n", + "Similarly, we can train a gflownet using Trajectory Balance using the `TBGFlowNet` class. Unlike before, we separately parameterize the forward and backward policies are two different `estimators`, which are passed to the `TBGFlowNet`. In this example we don't use a replay buffer, so we set `on_policy=True`.\n", + "\n", + "One common trick with trajectory balance is to learn the `logZ` parameter with a higher learning rate than the rest of the network." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6P1Z4QcbBfPE", + "outputId": "a63a05fd-b5f2-429d-af57-1225c78ffce6" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 781/781 [00:16<00:00, 46.45it/s]\n" + ] + } + ], + "source": [ + "# nn.Modules for the forward and backward policy estimators.\n", + "pf_module = NeuralNet(\n", + " input_dim=env.preprocessor.output_dim,\n", + " output_dim=env.n_actions,\n", + " hidden_dim=n_hid_units,\n", + " n_hidden_layers=1,\n", + ")\n", + "pb_module = NeuralNet(\n", + " input_dim=env.preprocessor.output_dim,\n", + " output_dim=env.n_actions - 1,\n", + " hidden_dim=n_hid_units,\n", + " n_hidden_layers=1,\n", + ")\n", + "# Estimators for the forward and backward policies.\n", + "pf_estimator = DiscretePolicyEstimator(\n", + " module=pf_module,\n", + " n_actions=env.n_actions,\n", + " preprocessor=env.preprocessor,\n", + ")\n", + "pb_estimator = DiscretePolicyEstimator(\n", + " module=pb_module,\n", + " n_actions=env.n_actions,\n", + " is_backward=True,\n", + " preprocessor=env.preprocessor,\n", + ")\n", + "\n", + "# Our trajectory balance gflownet accepts both policy estimators.\n", + "gflownet = TBGFlowNet(\n", + " pf=pf_estimator,\n", + " pb=pb_estimator,\n", + " on_policy=True, # No replay buffer.\n", + ")\n", + "\n", + "# Policy parameters recieve one LR, and LogZ gets a dedicated, typically higher LR.\n", + "params = [\n", + " {\"params\": [\n", + " v for k, v in dict(gflownet.named_parameters()).items() if k != \"logZ\"\n", + " ],\n", + " \"lr\": learning_rate,\n", + " }\n", + "]\n", + "params.append(\n", + " {\"params\": [\n", + " dict(gflownet.named_parameters())[\"logZ\"]\n", + " ],\n", + " \"lr\": learning_rate * 10,\n", + " }\n", + ")\n", + "optimizer = torch.optim.Adam(params)\n", + "\n", + "visited_terminating_states, states_visited, losses = train(\n", + " gflownet,\n", + " optimizer,\n", + " env,\n", + " n_episodes=n_episodes * 10,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 362 + }, + "id": "miDx7913Bm4B", + "outputId": "800dee7d-1f47-4f47-dc9d-3eb003e6ab5a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "proportion of smiles:frowns = 0.640625:0.359375\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "analyze_torchgfn_results(visited_terminating_states, env)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 333 + }, + "id": "ZrUZbfjmW8-z", + "outputId": "2d526d08-456e-4a26-a834-7e4210620f7c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_curve(losses, title=\"Loss Curve for Trajectory Balance Objective using TorchGFN\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9gybXbsWIa_t", + "outputId": "46a58d82-477b-4552-ba2c-d9db86269a80" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The partition function estimate is Z=12.00\n" + ] + } + ], + "source": [ + "print(\"The partition function estimate is Z={:.2f}\".format(\n", + " torch.exp(gflownet.logZ).item()\n", + " )\n", + ")" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}