diff --git a/.gitignore b/.gitignore
index 55c1d3a..09ca5eb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,8 @@ data/3dmeshes/*.pk
 data/ground_truths/**/*
 data/output/*.pt
 data/output/**/*
+data/train_datasets/*.pt
 *.egg-info
 tensorboard_logs
-**/__pycache__
\ No newline at end of file
+**/__pycache__
+wandb
\ No newline at end of file
diff --git a/README.md b/README.md
index c05b3f3..309e1c0 100644
--- a/README.md
+++ b/README.md
@@ -17,62 +17,82 @@ conda env create -f environment.yml
 conda activate masconcube
 ```
 
-Or, if you want to install also development dependencies:
+## Project structure
 
-```bash
-conda env create -f environment_dev.yml
-conda activate masconcube
+```
+masconCube/
+├── data/                           # Data folder
+│   ├── 3dmeshes/                   # 3D meshes (to be downloaded from darioizzo/geodesyNets)
+│   ├── ground_truths/              # Ground-truth mascon models (to be generated with scripts/generate_ground_truth.py)
+│   ├── output/                     # Output folder for trained models and results
+|   ├── train_configs/              # Training configurations for MasconCube (yaml files)
+|   ├── train_datasets/             # Training datasets (to be generated with scripts/generate_train_datasets.py)
+|   ├── val_datasets/               # Validation datasets (to be generated with scripts/generate_val_datasets.py)
+|   └── test_datasets/              # Test datasets (to be generated with scripts/generate_val_datasets.py)
+├── mascon_cube/                    # Main package
+│   ├── data/                       # Data loading and processing
+|   ├── geodesynet/                 # GeodesyNets original implementation, mostly unmodified
+|   ├── pinn_gm/                    # PINN-GM III original implementation, mostly unmodified
+│   ├── contstants.py               
+│   ├── losses.py                   
+│   ├── metrics.py
+│   ├── models.py
+│   ├── training.py
+│   ├── trajectory.py
+│   ├── utils.py
+│   └── visualization.py
+├── notebooks/                      # Jupyter notebooks                 
+├── scripts/                        # Scripts for data generation, training, and evaluation
+└── environment.yml                 # Conda environment file
 ```
 
-Development dependencies include packages for linting and contributing to the project.
+## Data
 
-## Reprouducing the results from the paper
+Data is not stored in this repository to keep the size of the repository small. You can populate the `data` folder by following these steps:
 
  1. Download the 3D meshes from [darioizzo/geodesyNets/3dmeshes]([darioizzo/geodesyNets/3dmeshes](https://github.com/darioizzo/geodesyNets/tree/1edbb64d1e8e355e124a41eac27a14d7c5c5d881/3dmeshes)) and copy them inside the `data/3dmeshes` folder. For more information, see the [data README](data/README.md).
  2. Generate the ground-truth mascon models in the `data/ground_truths` folder by running the following script:
     ```bash
     python scripts/generate_ground_truth.py
     ```
-3. Generate the validation datasets in the `data/val_datasets` and `data/test_datasets` folders by running the following script:
-    ```bash
-    python scripts/generate_val_datasets.py
-    ```
-4. Train MasconCubes with the following command:
-    ```bash
-    python scripts/train_cubes_all.py [--gpus <gpu1> <gpu2> ...]
-    ```
-5. Train GeodesyNets with the following command:
+ 3. Generate the training datasets using in the paper in the `data/train_datasets` folders by running the following script:
     ```bash
-    python scripts/train_geodesynet_all.py [--gpus <gpu1> <gpu2> ...]
+    python scripts/generate_train_datasets.py random
     ```
-6. Train PINN-GM III with the following command:
+ 4. Generate the validation datasets in the `data/val_datasets` and `data/test_datasets` folders by running the following script:
     ```bash
-    python scripts/train_pinn_all.py [--gpus <gpu1> <gpu2> ...]
+    python scripts/generate_val_datasets.py
     ```
-7. Evaluate the models and produce plots using the provided notebooks.
-
-Note that steps 5 and 6 are required only to compare the results with previous state-of-the-art methods, and they might take a long time to run. You can skip them if you are only interested in MasconCube. If you want to run them, multiple GPUs are recommended, so that you can run them in parallel. The `--gpus` argument allows you to specify which GPUs to use for training.
 
-### Training on single asteroids
-
-If you want to run the training on single asteroids, you can use the scripts `scripts/train.py`, `scripts/train_geodesynet.py`, and `scripts/train_pinn.py`. For example, to train MasconCube on `eros_uniform`, you can run:
+## Training MasconCube and other models (legacy method)
 
+MasconCube, GeodesyNet and PINN-GM III can be trained using their respective training scripts in the `scripts` folder: `train_cube.py`, `train_geodesynet.py`, and `train_pinn.py`.
+The cli interface for all the training scripts is similar:
 ```bash
-python scripts/train.py eros_uniform
+python scripts/train_<model>.py <asteroid_name>
 ```
 
-MasconCube trainings also support TensorBoard logging (development dependencies required). You can run the following command to start TensorBoard:
-
+It is also possible to train a model for every asteroid in `data/ground_truths` on multiple GPUs using the scripts `train_cubes_all.py`, `train_geodesynet_all.py`, and `train_pinn_all.py`.
+Again, the cli interface is similar for all the scripts:
 ```bash
-tensorboard --logdir runs
+python scripts/train_<model>_all.py [--gpus <gpu1> <gpu2> ...]
 ```
 
-And then enable logging in the training script by passing the `--tensorboard` argument:
+Default settings should replicate the results in the paper. However some small implemention details could lead to slightly different results. If you want to replicate exactly the results of the paper checkout [v1.0.0](https://github.com/esa/masconCube/tree/v.1.0.0).
 
+## Training MasconCube (new method)
+
+The recommended way to train MasconCube models is with yaml configuration files stored in the `data/train_configs` folder.
+The folder alredy contains a configuration file called `paper.yaml` that you can use as a starting point.
+It use similar settings to the one used in the paper, but for an exact comparison follow the instructions in the previous section.
+
+To train a MasconCube model using a configuration file, run the following command:
 ```bash
-python scripts/train.py eros_uniform --tensorboard
+python scripts/run_config.py data/train_configs/<config_file>.yaml [--use-wandb]
 ```
 
+The `--use-wandb` flag is optional, and it enables logging with [Weights & Biases](https://wandb.ai/).
+
 ## License
 The code is released under the [Apache 2.0 license](https://github.com/esa/masconCube?tab=Apache-2.0-1-ov-file).
 
diff --git a/data/train_configs/paper.yaml b/data/train_configs/paper.yaml
new file mode 100644
index 0000000..247e93e
--- /dev/null
+++ b/data/train_configs/paper.yaml
@@ -0,0 +1,42 @@
+# Training configuration for the paper experiments
+
+asteroids:
+  bennu: 
+    train: bennu_100000_spherical_0.0_1.0_42.pt
+    val: bennu_1000_spherical_0_2.pt
+  eros_2: 
+    train: eros_2_100000_spherical_0.0_1.0_42.pt
+    val: eros_2_1000_spherical_0_2.pt
+  eros_3: 
+    train: eros_3_100000_spherical_0.0_1.0_42.pt
+    val: eros_3_1000_spherical_0_2.pt
+  eros_uniform: 
+    train: eros_uniform_100000_spherical_0.0_1.0_42.pt
+    val: eros_uniform_1000_spherical_0_2.pt
+  itokawa: 
+    train: itokawa_100000_spherical_0.0_1.0_42.pt
+    val: itokawa_1000_spherical_0_2.pt
+  itokawa_cos: 
+    train: itokawa_cos_100000_spherical_0.0_1.0_42.pt
+    val: itokawa_cos_1000_spherical_0_2.pt
+  planetesimal: 
+    train: planetesimal_100000_spherical_0.0_1.0_42.pt
+    val: planetesimal_1000_spherical_0_2.pt
+  planetesimal_decentered: 
+    train: planetesimal_decentered_100000_spherical_0.0_1.0_42.pt
+    val: planetesimal_decentered_1000_spherical_0_2.pt
+  planetesimal_uniform: 
+    train: planetesimal_uniform_100000_spherical_0.0_1.0_42.pt
+    val: planetesimal_uniform_1000_spherical_0_2.pt
+
+train:
+  n_epochs: 1
+  batch_size: 1000
+  loss_fn: normalized_l1_loss
+  lr: 1.0E-5
+  cube_side: 100
+  differential: False
+  normalize: True
+  activation_function: linear
+  data_from_trajectory: False
+  batch_persistency: 10
\ No newline at end of file
diff --git a/data/train_configs/test.yaml b/data/train_configs/test.yaml
new file mode 100644
index 0000000..68e1957
--- /dev/null
+++ b/data/train_configs/test.yaml
@@ -0,0 +1,49 @@
+# Training configuration for the paper experiments
+
+asteroids:
+  # bennu: 
+  #   train: bennu_100000_spherical_0.0_1.0_42.pt
+  #   val: bennu_1000_spherical_0_2.pt
+  # eros_2: 
+  #   train: eros_2_100000_spherical_0.0_1.0_42.pt
+  #   val: eros_2_1000_spherical_0_2.pt
+  eros_3: 
+    train: eros_3_traj_1_10000_1.0.pt
+    val: eros_3_1000_spherical_0_2.pt
+  # eros_uniform: 
+  #   train: eros_uniform_100000_spherical_0.0_1.0_42.pt
+  #   val: eros_uniform_1000_spherical_0_2.pt
+  itokawa: 
+    train: itokawa_traj_1_10000_1.0.pt
+    val: itokawa_1000_spherical_0_2.pt
+  # itokawa_cos: 
+  #   train: itokawa_cos_100000_spherical_0.0_1.0_42.pt
+  #   val: itokawa_cos_1000_spherical_0_2.pt
+  # planetesimal: 
+  #   train: planetesimal_100000_spherical_0.0_1.0_42.pt
+  #   val: planetesimal_1000_spherical_0_2.pt
+  # planetesimal_decentered: 
+  #   train: planetesimal_decentered_100000_spherical_0.0_1.0_42.pt
+  #   val: planetesimal_decentered_1000_spherical_0_2.pt
+  # planetesimal_uniform: 
+  #   train: planetesimal_uniform_100000_spherical_0.0_1.0_42.pt
+  #   val: planetesimal_uniform_1000_spherical_0_2.pt
+
+train:
+  n_epochs: 100
+  batch_size: 1000
+  loss_fn: normalized_l1_loss
+  lr: 1.0E-5
+  scheduler_factor: 0.8
+  scheduler_patience: 2
+  scheduler_min_lr: 1.0E-7
+  cube_side: 100
+  differential: False
+  normalize: True
+  activation_function: linear
+  data_from_trajectory: False
+  batch_persistency: 3
+  starting_training_data: 2000
+  add_data_every_n_epochs: 5
+  data_to_add: 1000
+  warmup_epochs: 10
\ No newline at end of file
diff --git a/data/train_datasets/.gitkeep b/data/train_datasets/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/environment.yml b/environment.yml
index 245bc00..70b05fa 100644
--- a/environment.yml
+++ b/environment.yml
@@ -10,11 +10,17 @@ dependencies:
   - numpy ~= 1.26.4  # numpy 2 is not compatible with cascade
   - cascade ~= 0.1.9
   - lazy_import ~= 0.2.2
-  - scipy ~= 0.15.2
+  - scipy ~= 1.16.3
   - seaborn ~= 0.13.2
   - torchquad ~= 0.4.1
   - pyvista ~= 0.45.2
   - pykep ~= 2.6.4
+  - pydantic ~= 2.12.3
+  - tqdm
+    # dev
+  - pre-commit ~= 4.1.0
+  - ipykernel ~= 6.29.5
+  - nbformat ~= 5.10.4
 
   - pip:
     - tetgen == 0.6.4
@@ -22,4 +28,7 @@ dependencies:
     - torch
     - torchvision
     - torchaudio
+    - sobol_seq
+    - pyvistaqt
+    - wandb
     - --extra-index-url https://download.pytorch.org/whl/cu118
\ No newline at end of file
diff --git a/environment_dev.yml b/environment_dev.yml
deleted file mode 100644
index 66c3534..0000000
--- a/environment_dev.yml
+++ /dev/null
@@ -1,32 +0,0 @@
-name: masconcube
-channels:
-  - conda-forge
-  - nvidia
-  - pytorch
-  - defaults
-dependencies:
-  - python ~= 3.12.6
-  - pip ~= 25.0.1
-  - numpy ~= 1.26.4  # numpy 2 is not compatible with cascade
-  - cascade ~= 0.1.9
-  - lazy_import ~= 0.2.2
-  - scipy ~= 0.15.2
-  - seaborn ~= 0.13.2
-  - torchquad ~= 0.4.1
-  - pyvista ~= 0.45.2
-  - pykep ~= 2.6.4
-  # dev
-  - pre-commit ~= 4.1.0
-  - ipykernel ~= 6.29.5
-  - tensorboard ~= 2.19.0
-  - nbformat ~= 5.10.4
-
-  - pip:
-    - tetgen == 0.6.4
-    - -e .
-    - torch
-    - torchvision
-    - torchaudio
-    - sobol_seq
-    - pyvistaqt
-    - --extra-index-url https://download.pytorch.org/whl/cu118
\ No newline at end of file
diff --git a/mascon_cube/constants.py b/mascon_cube/constants.py
index bfc6f81..87ad1b3 100644
--- a/mascon_cube/constants.py
+++ b/mascon_cube/constants.py
@@ -4,10 +4,11 @@
 DATA_DIR = ROOT_DIR / "data"
 GROUND_TRUTH_DIR = DATA_DIR / "ground_truths"
 MESH_DIR = DATA_DIR / "3dmeshes"
+TRAIN_DATASETS_DIR = DATA_DIR / "train_datasets"
 VAL_DATASETS_DIR = DATA_DIR / "val_datasets"
 TEST_DATASETS_DIR = DATA_DIR / "test_datasets"
 OUTPUT_DIR = DATA_DIR / "output"
-TENSORBOARD_DIR = ROOT_DIR / "tensorboard_logs"
+CONFIGS_DIR = DATA_DIR / "train_configs"
 
 
 # -------------------------------------------------------------------------------------------------------------------- #
diff --git a/mascon_cube/data/datasets.py b/mascon_cube/data/datasets.py
new file mode 100644
index 0000000..73c22bd
--- /dev/null
+++ b/mascon_cube/data/datasets.py
@@ -0,0 +1,133 @@
+from pathlib import Path
+from typing import Union
+
+import torch
+from torch.utils.data import Dataset
+
+from mascon_cube.constants import TRAIN_DATASETS_DIR
+from mascon_cube.data.mascon_model import MasconModel
+from mascon_cube.data.sampling import get_target_point_sampler
+from mascon_cube.trajectory import simulate_trajectory
+from mascon_cube.utils import compute_acceleration
+
+
+class AccelerationDataset(Dataset):
+    def __init__(
+        self,
+        path: Union[str, Path],
+        n: int = -1,
+    ):
+        """Dataset for acceleration data.
+        Args:
+            path (Union[str, Path]): Path to the dataset file.
+            n (int, optional): Number of samples to use from the dataset at the beginning.
+                If -1, use the entire dataset. Defaults to -1.
+        """
+        data = torch.load(path)
+        self.data = data
+        assert n <= len(self.data), "n cannot be greater than the dataset size"
+        self.n = n if n > 0 else len(self.data)
+
+    def __len__(self):
+        return self.n
+
+    def __getitem__(self, idx):
+        return self.data[idx][:3], self.data[idx][3:]
+
+    def add_data(self, n: int) -> int:
+        remaining = len(self.data) - self.n
+        to_add = min(n, remaining)
+        self.n += to_add
+        return to_add
+
+
+def create_random_dataset(
+    asteroid: Union[str, Path],
+    n: int,
+    sampling_method: str = "spherical",
+    sampling_min: float = 0.0,
+    sampling_max: float = 1.0,
+    seed: int = 42,
+) -> Path:
+    """Create a dataset and save it to disk.
+
+    Args:
+        asteroid (Union[str, Path]): Name of the asteroid.
+        n (int): Number of samples.
+        sampling_method (str, optional): Sampling method to use. Defaults to "spherical".
+        sampling_min (float, optional): Minimum value for sampling. Defaults to 0.0.
+        sampling_max (float, optional): Maximum value for sampling. Defaults to 1.0.
+        seed (int, optional): Random seed for reproducibility. Defaults to 42.
+
+    Returns:
+        Path: Path to the saved dataset.
+    """
+
+    asteroid_name = asteroid if isinstance(asteroid, str) else asteroid.stem
+    dataset_name = (
+        f"{asteroid_name}_{n}_{sampling_method}_{sampling_min}_{sampling_max}_{seed}.pt"
+    )
+    dataset_path = TRAIN_DATASETS_DIR / dataset_name
+    torch.manual_seed(seed)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    sampler = get_target_point_sampler(
+        n, asteroid, sampling_method, [sampling_min, sampling_max], device=device
+    )
+    data = sampler()
+    ground_truth = MasconModel(asteroid, device=device)
+    labels = compute_acceleration(data, ground_truth.coords, ground_truth.masses)
+    data = torch.cat([data.to("cpu"), labels.to("cpu")], dim=1)
+    torch.save(data, dataset_path)
+    return dataset_path
+
+
+def create_trajectory_dataset(
+    asteroid: Union[str, Path],
+    n: int = 1000,
+    safety_coefficient: float = 1.4,
+    exit_radius: float = 2.0,
+    starting_orb_params: tuple[tuple[float, float, float, float, float, float]] = (
+        (1.5, 0.0, 3.1415 / 2, 0.0, 0.0, 3.1415 / 2),
+    ),
+    propagation_days: float = 1.0,
+) -> Path:
+    """Create a dataset from a simulated trajectory and save it to disk.
+
+    Args:
+        asteroid (Union[str, Path]): Name of the asteroid.
+        n (int): Number of samples. Defaults to 1000.
+        safety_coefficient (float, optional): Safety coefficient for the trajectory simulation. Defaults to 1.4.
+        exit_radius (float, optional): Exit radius for the trajectory simulation. Defaults to 2.0.
+        starting_orb_params (tuple, optional): Starting orbital parameters.
+            Defaults to (1.5, 0.0, np.pi / 2, 0.0, 0.0, np.pi / 2).
+    Returns:
+        Path: Path to the saved dataset.
+    """
+    asteroid_name = asteroid if isinstance(asteroid, str) else asteroid.stem
+    ground_truth = MasconModel(asteroid, device="cpu")
+    assert isinstance(
+        starting_orb_params, tuple
+    ), "starting_orb_params must be a tuple of tuples"
+    dataset_name = (
+        f"{asteroid_name}_traj_{len(starting_orb_params)}_{n}_{propagation_days}.pt"
+    )
+    dataset_path = TRAIN_DATASETS_DIR / dataset_name
+    positions = []
+    for params in starting_orb_params:
+        body_frame_traj, _ = simulate_trajectory(
+            asteroid_name.split("_")[0],
+            ground_truth.coords.numpy(),
+            ground_truth.masses.numpy(),
+            safety_coefficient,
+            exit_radius,
+            params,
+            n,
+            propagation_days,
+        )
+        positions.append(torch.tensor(body_frame_traj[:, :3], dtype=torch.float32))
+    positions = torch.stack(positions, dim=0)
+    positions = positions.permute(1, 0, 2).reshape(-1, 3)
+    labels = compute_acceleration(positions, ground_truth.coords, ground_truth.masses)
+    data = torch.cat([positions, labels], dim=1)
+    torch.save(data, dataset_path)
+    return dataset_path
diff --git a/mascon_cube/logs.py b/mascon_cube/logs.py
deleted file mode 100644
index 5c834be..0000000
--- a/mascon_cube/logs.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from dataclasses import dataclass
-
-import lazy_import
-import torch
-
-tensorboard = lazy_import.lazy_module("torch.utils.tensorboard")
-
-
-@dataclass
-class LogConfig:
-    """Dataclass for logging"""
-
-    log_every_n_epochs: int = 1
-    draw_every_n_epochs: int = 50
-
-
-class SummaryWriter(tensorboard.SummaryWriter):
-    """Override the SummaryWriter class to fix a bug in the add_hparams method."""
-
-    def add_hparams(self, hparam_dict, metric_dict):
-        torch._C._log_api_usage_once("tensorboard.logging.add_hparams")
-        if type(hparam_dict) is not dict or type(metric_dict) is not dict:
-            raise TypeError("hparam_dict and metric_dict should be dictionary.")
-        exp, ssi, sei = tensorboard.summary.hparams(hparam_dict, metric_dict)
-
-        logdir = self._get_file_writer().get_logdir()
-
-        with SummaryWriter(log_dir=logdir) as w_hp:
-            w_hp.file_writer.add_summary(exp)
-            w_hp.file_writer.add_summary(ssi)
-            w_hp.file_writer.add_summary(sei)
-            for k, v in metric_dict.items():
-                w_hp.add_scalar(k, v)
diff --git a/mascon_cube/pinn_gm/_training.py b/mascon_cube/pinn_gm/_training.py
index e8d3e92..2704d52 100644
--- a/mascon_cube/pinn_gm/_training.py
+++ b/mascon_cube/pinn_gm/_training.py
@@ -1,23 +1,23 @@
 from copy import deepcopy
-from dataclasses import asdict
-from datetime import datetime
+from dataclasses import dataclass
 
 import numpy as np
 import torch
 from tqdm import tqdm
 
 from mascon_cube import geodesynet
-from mascon_cube.constants import TENSORBOARD_DIR
 from mascon_cube.data.mascon_model import MasconModel
 from mascon_cube.data.sampling import get_target_point_sampler
-from mascon_cube.logs import LogConfig, SummaryWriter
-from mascon_cube.pinn_gm import PinnGM, pinn_loss
-from mascon_cube.training import AbstractTrainingConfig, ValidationConfig
+from mascon_cube.pinn_gm._network import PinnGM
+from mascon_cube.pinn_gm._utils import pinn_loss
 
 
-class PinnTrainingConfig(AbstractTrainingConfig):
+@dataclass
+class PinnTrainingConfig:
     """Dataclass for training configuration for PINN models"""
 
+    asteroid: str
+    val_set_path: str
     n_epochs: int = 8192
     batch_size: int = 2048
     n_data: int = 100000
@@ -25,12 +25,11 @@ class PinnTrainingConfig(AbstractTrainingConfig):
     sampling_min: float = 0.0
     sampling_max: float = 2.4
     lr: float = 0.00390625
+    val_every_n_epochs: int = 50
 
 
 def training_loop(
     config: PinnTrainingConfig,
-    val_config: ValidationConfig | None = None,
-    log_config: LogConfig | None = None,
     device: str | torch.device = "cuda",
     progressbar: bool = True,
 ) -> PinnGM:
@@ -48,7 +47,7 @@ def training_loop(
     mascon_points = mascon_model.coords
     mascon_masses = mascon_model.masses
     ground_truth = geodesynet.ACC_L(dataset, mascon_points, mascon_masses).to(device)
-    val_dataset = val_config.val_dataset.requires_grad_(True) if val_config else None
+    val_dataset = torch.load(config.val_set_path).to(device).requires_grad_(True)
     val_labels = (
         geodesynet.ACC_L(val_dataset, mascon_points, mascon_masses)
         .requires_grad_(True)
@@ -59,14 +58,6 @@ def training_loop(
     best_loss = np.inf
     best_model = None
 
-    if log_config is not None:
-        log_dir = (
-            TENSORBOARD_DIR
-            / config.asteroid
-            / datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
-        )
-        writer = SummaryWriter(log_dir=log_dir)
-
     iterator = tqdm(range(config.n_epochs)) if progressbar else range(config.n_epochs)
 
     for i in iterator:
@@ -92,16 +83,12 @@ def training_loop(
             # labels = geodesynet.ACC_L(batch, mascon_points, mascon_masses).to(device)
             # Compute the loss
             loss = loss_fn(predicted, labels)
-            if val_config is None and loss.item() < best_loss:
-                # If we don't have a validation set, we use the training loss to determine the best model
-                best_loss = loss.item()
-                best_model = deepcopy(model).cpu()
             # Backpropagate
             optimizer.zero_grad()
             loss.backward()
             optimizer.step()
 
-        if val_config and i % val_config.val_every_n_epochs == 0:
+        if config.val_every_n_epochs == 0:
             # If we have a validation set, we use the validation loss to determine the best model
             val_predicted = model(val_dataset)
             val_predicted = torch.autograd.grad(
@@ -115,18 +102,4 @@ def training_loop(
                 best_loss = val_loss
                 best_model = deepcopy(model).cpu()
             optimizer.zero_grad()
-
-        # Tensorboard logging
-        if log_config is not None:
-            if i % log_config.log_every_n_epochs == 0:
-                writer.add_scalar("Loss/train", loss.item(), i)
-            if val_config is not None and i % val_config.val_every_n_epochs == 0:
-                writer.add_scalar("Loss/val", val_loss, i)
-
-    if log_config is not None:
-        writer.add_hparams(asdict(config), {"best_loss": best_loss})
-
-        torch.save(best_model.state_dict(), log_dir / "best_model_state_dict.pt")
-        writer.close()
-
     return best_model
diff --git a/mascon_cube/training.py b/mascon_cube/training.py
index c96083d..9e44ab9 100644
--- a/mascon_cube/training.py
+++ b/mascon_cube/training.py
@@ -1,19 +1,22 @@
+import warnings
 from abc import ABC
 from copy import deepcopy
 from dataclasses import asdict, dataclass
-from datetime import datetime
+from pathlib import Path
 from typing import Optional, Union
 
+import seaborn as sns
 import torch
 from tqdm import tqdm
 
+import wandb
 from mascon_cube import losses
-from mascon_cube.constants import TENSORBOARD_DIR
+from mascon_cube.constants import MASS_VMAX
+from mascon_cube.data.datasets import AccelerationDataset
 from mascon_cube.data.mascon_model import MasconModel
-from mascon_cube.data.sampling import get_target_point_sampler
-from mascon_cube.logs import LogConfig, SummaryWriter
 from mascon_cube.models import MasconCube
-from mascon_cube.visualization import plot_mascon_cube
+from mascon_cube.utils import compute_acceleration
+from mascon_cube.visualization import mascon_cube_to_point_cloud, plot_dataset
 
 
 @dataclass
@@ -21,17 +24,22 @@ class AbstractTrainingConfig(ABC):
     """Abstract training config"""
 
     asteroid: str
-    n_epochs: int = 1000
-    n_epochs_before_resampling: int = 10
-    loss_fn: str = "normalized_l1_loss"
+    train_set_path: Path
+    val_set_path: Path
+    starting_training_data: int = -1
+    add_data_every_n_epochs: int = 0
+    data_to_add: int = 0
+    warmup_epochs: int = 0
+    n_epochs: int = 10
     batch_size: int = 1000
-    sampling_method: str = "spherical"
-    sampling_min: float = 0.0
-    sampling_max: float = 1.0
+    loss_fn: str = "normalized_l1_loss"
     lr: float = 1e-5
     scheduler_factor: float = 0.8
-    scheduler_patience: int = 200
+    scheduler_patience: int = 2
     scheduler_min_lr: float = 1e-8
+    val_set_path: Optional[Path] = None
+    val_every_n_epochs: int = 50
+    batch_persistency: int = 10
 
 
 @dataclass
@@ -44,33 +52,31 @@ class CubeTrainingConfig(AbstractTrainingConfig):
     activation_function: str = "linear"
 
 
-@dataclass
-class ValidationConfig:
-    """Dataclass for validation configuration"""
-
-    val_dataset: Optional[torch.Tensor] = None
-    val_every_n_epochs: int = 50
-
-
 def training_loop(
     config: CubeTrainingConfig,
-    val_config: Optional[ValidationConfig] = None,
-    log_config: Optional[LogConfig] = None,
     device: Union[str, torch.device] = "cuda",
     progressbar: bool = False,
+    use_wandb: bool = False,
 ) -> MasconCube:
     """Train the mascon cube to fit the ground truth
 
     Args:
         config (CubeTrainingConfig): Training configuration
-        val_config (Optional[ValidationConfig]): Validation configuration. Defaults to None (no validation).
-        log_config (Optional[LogConfig]): Logging configuration. Defaults to None (no logging).
         device (Union[str, torch.device]): Device to use for training. Defaults to "cuda".
         progressbar (bool, optional): If True show a progressbar on command line. Defaults to False.
+        use_wandb (bool, optional): If True, log training to Weights and Biases. Defaults to False.
 
     Returns:
         MasconCube: The trained MasconCube
     """
+    wandb_run = (
+        wandb.init(
+            project="mascon-cube",
+            config=asdict(config),
+        )
+        if use_wandb
+        else None
+    )
     cube = MasconCube(
         config.cube_side,
         config.asteroid,
@@ -81,108 +87,120 @@ def training_loop(
     )
     ground_truth = MasconModel(config.asteroid, device=device)
     optimizer = torch.optim.Adam([cube.weights], lr=config.lr)
-    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+
+    def lr_lambda(i):
+        if config.warmup_epochs == 0:
+            return 1.0
+        else:
+            return min(1.0, i / config.warmup_epochs)
+
+    warmup_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+    plateau_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
         optimizer,
         factor=config.scheduler_factor,
         patience=config.scheduler_patience,
         min_lr=config.scheduler_min_lr,
     )
-    data_sampler = get_target_point_sampler(
-        n=config.batch_size,
-        asteroid_mesh=config.asteroid,
-        method=config.sampling_method,
-        bounds=(config.sampling_min, config.sampling_max),
-        device=device,
+
+    training_data = AccelerationDataset(
+        config.train_set_path, config.starting_training_data
+    )
+    if wandb_run is not None:
+        sns.set_theme()
+        sns.set_style("whitegrid")
+        fig = plot_dataset(
+            training_data,
+            cube,
+        )
+        wandb_run.log({"data": wandb.Image(fig)})
+    dataloader = torch.utils.data.DataLoader(
+        training_data, batch_size=config.batch_size, shuffle=True
     )
     loss_fn = getattr(losses, config.loss_fn)
 
     best_cube = deepcopy(cube)
     best_loss = float("inf")
+    val_dataset = torch.load(config.val_set_path).to("cpu")
 
-    if log_config is not None:
-        log_dir = (
-            TENSORBOARD_DIR
-            / config.asteroid
-            / datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
-        )
-        writer = SummaryWriter(log_dir=log_dir)
-    iterator = tqdm(range(config.n_epochs)) if progressbar else range(config.n_epochs)
+    iterator = (
+        tqdm(range(config.n_epochs), unit="epoch", desc="Training", position=0)
+        if progressbar
+        else range(config.n_epochs)
+    )
     for i in iterator:
-        if (i % config.n_epochs_before_resampling) == 0:
-            target_points = data_sampler()
-            labels = compute_acceleration(
-                target_points, ground_truth.coords, ground_truth.masses
-            )
-
-        predicted = compute_acceleration(target_points, cube.coords, cube.masses)
-        loss = loss_fn(predicted, labels)
-
-        if val_config is None and loss.item() < best_loss:
-            # If we don't have a validation set, we use the training loss to determine the best model
-            best_loss = loss.item()
+        _train(
+            dataloader,
+            progressbar,
+            device,
+            cube,
+            loss_fn,
+            i,
+            optimizer,
+            wandb_run,
+            config.batch_persistency,
+        )
+        val_loss = _validate(val_dataset, device, cube, ground_truth, loss_fn)
+        if val_loss < best_loss:
+            best_loss = val_loss
             best_cube = deepcopy(cube)
-
-        if val_config and i % val_config.val_every_n_epochs == 0:
-            # If we have a validation set, we use the validation loss to determine the best model
-            with torch.no_grad():
-                val_labels = compute_acceleration(
-                    val_config.val_dataset, ground_truth.coords, ground_truth.masses
-                )
-                val_predicted = compute_acceleration(
-                    val_config.val_dataset, cube.coords, cube.masses
-                )
-                val_loss = loss_fn(val_predicted, val_labels).item()
-                if val_loss < best_loss:
-                    best_loss = val_loss
-                    best_cube = deepcopy(cube)
-
-        # Tensorboard logging
-        if log_config is not None:
-            if i % log_config.log_every_n_epochs == 0:
-                writer.add_scalar("Loss/train", loss.item(), i)
-            if val_config is not None and i % val_config.val_every_n_epochs == 0:
-                writer.add_scalar("Loss/val", val_loss, i)
-            if i % log_config.draw_every_n_epochs == 0:
-                fig = plot_mascon_cube(cube)
-                writer.add_figure("Cube", fig, i)
-
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-        scheduler.step(loss.item())
-
-    if log_config is not None:
-        writer.add_hparams(asdict(config), {"best_loss": best_loss})
-        torch.save(best_cube, log_dir / "best_cube.pt")
-        writer.close()
-
+        if wandb_run is not None:
+            wandb_run.log({"val_loss": val_loss, "epoch": i})
+            point_cloud = mascon_cube_to_point_cloud(
+                cube, range=(0, MASS_VMAX[config.asteroid])
+            )
+            wandb_run.log({"cube": wandb.Object3D(point_cloud), "epoch": i})
+            # fig = plot_mascon_cube(cube, range=(0, MASS_VMAX[config.asteroid]))
+            # wandb_run.log({"Cube": wandb.Image(fig), "epoch": i})
+        if i < config.warmup_epochs:
+            warmup_scheduler.step()
+        else:
+            plateau_scheduler.step(val_loss)
+        if wandb_run is not None:
+            wandb_run.log({"lr": optimizer.param_groups[0]["lr"], "epoch": i})
+        if (
+            config.add_data_every_n_epochs > 0
+            and (i + 1) % config.add_data_every_n_epochs == 0
+        ):
+            training_data.add_data(config.data_to_add)
+
+    if wandb_run is not None:
+        wandb_run.finish()
+
+    if training_data.n != len(training_data.data):
+        warnings.warn("Training data was not fully used during training.")
     return best_cube
 
 
-def compute_acceleration(
-    target_points: torch.Tensor,
-    mascon_points: torch.Tensor,
-    mascon_masses: torch.Tensor,
+def _train(
+    dataloader, progressbar, device, cube, loss_fn, i, optimizer, wandb_run, persistency
 ):
-    """
-    Computes the acceleration due to the mascon at the target points. (to be used as Label in the training)
-
-    Args:
-        target_points (2-D array-like): an (N, 3) array-like object containing the coordinates of the points where the
-            acceleration should be computed.
-        mascon_points (2-D array-like): an (N, 3) array-like object containing the points that belong to the mascon
-        mascon_masses (1-D array-like): a (N,) array-like object containing the values for the mascon masses.
-            Can also be a scalar containing the mass value for all points.
-
-    Returns:
-        1-D array-like: a (N, 3) torch tensor containing the acceleration (G=1) at the target points
-    """
-    device = target_points.device
-    mm = mascon_masses.view(-1, 1)
-    retval = torch.empty(len(target_points), 3, device=device)
-    for i, target_point in enumerate(target_points):
-        dr = torch.sub(mascon_points, target_point)
-        retval[i] = torch.sum(
-            mm / torch.pow(torch.norm(dr, dim=1), 3).view(-1, 1) * dr, dim=0
-        )
-    return retval
+    iterator = (
+        tqdm(dataloader, leave=False, unit="batch", desc="Current epoch", position=1)
+        if progressbar
+        else dataloader
+    )
+    for target_points, labels in iterator:
+        target_points = target_points.to(device)
+        labels = labels.to(device)
+        for _ in range(persistency):
+            predicted = compute_acceleration(target_points, cube.coords, cube.masses)
+            loss = loss_fn(predicted, labels)
+
+            if wandb_run is not None:
+                wandb_run.log({"train_loss": loss.item(), "epoch": i})
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+
+@torch.inference_mode()
+def _validate(val_dataset, device, cube, ground_truth, loss_fn):
+    val_dataset = val_dataset.to(device)
+    val_labels = compute_acceleration(
+        val_dataset, ground_truth.coords, ground_truth.masses
+    )
+    val_predicted = compute_acceleration(val_dataset, cube.coords, cube.masses)
+    val_dataset = val_dataset.to("cpu")
+    val_loss = loss_fn(val_predicted, val_labels).item()
+    return val_loss
diff --git a/mascon_cube/trajectory.py b/mascon_cube/trajectory.py
index 7206a66..20173cf 100644
--- a/mascon_cube/trajectory.py
+++ b/mascon_cube/trajectory.py
@@ -77,6 +77,13 @@ def build_initial_conditions(
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
     Builds initial conditions in the rotating frame.
+    Args:
+        keplerian_params (np.ndarray): Keplerian parameters [a, e, i, W, w, E]
+        angular_velocity (np.ndarray): Angular velocity vector of the rotating frame
+        gravitational_param (float): Gravitational parameter of the central body
+    Returns:
+        Tuple[np.ndarray, np.ndarray]: Position and velocity vectors in the rotating frame
+
     """
     pos_inertial, vel_inertial = pk.par2ic(keplerian_params, gravitational_param)
     vel_inertial = np.array(vel_inertial)
@@ -104,6 +111,16 @@ def simulate_trajectory(
     mascon_masses: np.ndarray,
     safety_coefficient: float = 1.4,
     exit_radius: float = 2.0,
+    starting_orb_params: tuple[float, float, float, float, float, float] = (
+        1.5,
+        0.0,
+        np.pi / 2,
+        0.0,
+        0.0,
+        np.pi / 2,
+    ),
+    n: int = 1000,
+    propagation_days: float = 1.0,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
     Simulates the trajectory of a spacecraft around an asteroid.
@@ -195,15 +212,12 @@ def apply_delta_v(taylor_adaptive, _):
         t_events=[ellipsoid_entry, sphere_exit],
     )
 
-    deployment_sma = 1.5
-    keplerian_params = [deployment_sma, 0.0, np.pi / 2, 0.0, 0.0, np.pi / 2]
-    init_pos, init_vel = build_initial_conditions(keplerian_params, rotation_vector)
+    init_pos, init_vel = build_initial_conditions(starting_orb_params, rotation_vector)
     taylor_integrator.state[:3] = init_pos
     taylor_integrator.state[3:6] = init_vel
     taylor_integrator.time = 0.0
 
-    propagation_days = 1.0
-    time_grid = np.linspace(0.0, propagation_days * pk.DAY2SEC / unit_time, 1000)
+    time_grid = np.linspace(0.0, propagation_days * pk.DAY2SEC / unit_time, n)
     trajectory = taylor_integrator.propagate_grid(time_grid)
 
     return trajectory[5], _rotate_states(time_grid, trajectory[5], rotation_vector)
diff --git a/mascon_cube/utils.py b/mascon_cube/utils.py
new file mode 100644
index 0000000..073e323
--- /dev/null
+++ b/mascon_cube/utils.py
@@ -0,0 +1,30 @@
+import torch
+
+
+def compute_acceleration(
+    target_points: torch.Tensor,
+    mascon_points: torch.Tensor,
+    mascon_masses: torch.Tensor,
+):
+    """
+    Computes the acceleration due to the mascon at the target points. (to be used as Label in the training)
+
+    Args:
+        target_points (2-D array-like): an (N, 3) array-like object containing the coordinates of the points where the
+            acceleration should be computed.
+        mascon_points (2-D array-like): an (N, 3) array-like object containing the points that belong to the mascon
+        mascon_masses (1-D array-like): a (N,) array-like object containing the values for the mascon masses.
+            Can also be a scalar containing the mass value for all points.
+
+    Returns:
+        1-D array-like: a (N, 3) torch tensor containing the acceleration (G=1) at the target points
+    """
+    device = target_points.device
+    mm = mascon_masses.view(-1, 1)
+    retval = torch.empty(len(target_points), 3, device=device)
+    for i, target_point in enumerate(target_points):
+        dr = torch.sub(mascon_points, target_point)
+        retval[i] = torch.sum(
+            mm / torch.pow(torch.norm(dr, dim=1), 3).view(-1, 1) * dr, dim=0
+        )
+    return retval
diff --git a/mascon_cube/visualization.py b/mascon_cube/visualization.py
index c5449aa..c763b8e 100644
--- a/mascon_cube/visualization.py
+++ b/mascon_cube/visualization.py
@@ -7,6 +7,7 @@
 from torch import Tensor
 
 from mascon_cube.constants import GROUND_TRUTH_DIR
+from mascon_cube.data.datasets import AccelerationDataset
 from mascon_cube.models import MasconCube
 
 
@@ -198,6 +199,38 @@ def plot_mascon_cube(
         return fig
 
 
+def mascon_cube_to_point_cloud(
+    mascon_cube: MasconCube,
+    cmap: str = "viridis",
+    range: Optional[tuple[float, float]] = None,
+) -> np.ndarray:
+    """
+    Convert the mascon cube to a point cloud numpy array of shape (N, 6): [[x, y, z, r, g, b], ...]
+    where r, g, b are values in the range [0, 255] representing the mass color in the given colormap.
+
+    Args:
+        mascon_cube (MasconCube): The mascon cube to convert.
+        cmap (str, optional): The colormap to use for coloring the points. Defaults to "viridis".
+        range (Optional[tuple[float, float]], optional): The range of the colormap. Defaults to None.
+
+    Returns:
+        np.ndarray: The point cloud numpy array.
+    """
+    coords = mascon_cube.coords.detach().cpu().numpy()
+    masses = mascon_cube.masses.detach().cpu().numpy()
+    colormap = plt.get_cmap(cmap)
+    if range is None:
+        range = (0, np.percentile(masses, 99))
+    # clip masses to the range
+    masses_clipped = np.clip(masses, range[0], range[1])
+    colors = colormap((masses_clipped - range[0]) / (range[1] - range[0]))[
+        :, 0, :3
+    ]  # drop alpha channel
+    colors = (colors * 255).astype(np.uint8)
+    point_cloud = np.hstack((coords, colors))
+    return point_cloud
+
+
 def stokes_degree_error(
     preds: np.ndarray,
     gt: np.ndarray,
@@ -418,3 +451,32 @@ def plot_panel(ax, traj, az, el, D, title, ticks):
     )
 
     return fig
+
+
+def plot_dataset(
+    ds: AccelerationDataset,
+    cube: MasconCube,
+) -> plt.figure:
+    fig = plt.figure(figsize=(5, 5), dpi=300)
+    ax = fig.add_subplot(111, projection="3d", aspect="equal")
+    ax.scatter3D(
+        cube.coords[:, 0].cpu().numpy(),
+        cube.coords[:, 1].cpu().numpy(),
+        cube.coords[:, 2].cpu().numpy(),
+        c="k",
+        s=2,
+        alpha=0.05,
+    )
+    ax.scatter3D(
+        ds.data[:, 0],
+        ds.data[:, 1],
+        ds.data[:, 2],
+        c="b",
+        s=1,
+        alpha=0.9,
+    )
+    ax.view_init(45, 45)
+    ax.set_xlabel(r"$x$")
+    ax.set_ylabel(r"$y$")
+    ax.set_zlabel(r"$z$")
+    return fig
diff --git a/notebooks/02_eros.ipynb b/notebooks/02_eros.ipynb
index 57a84ef..580a2d0 100644
--- a/notebooks/02_eros.ipynb
+++ b/notebooks/02_eros.ipynb
@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 182,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
@@ -30,14 +30,15 @@
     "import torch\n",
     "import torchquad as tquad\n",
     "\n",
-    "from mascon_cube.constants import GROUND_TRUTH_DIR, OUTPUT_DIR, VAL_DATASETS_DIR\n",
+    "from mascon_cube.constants import OUTPUT_DIR, VAL_DATASETS_DIR, TRAIN_DATASETS_DIR\n",
     "from mascon_cube.data.mascon_model import MasconModel\n",
     "from mascon_cube.data.mesh import get_mesh, is_outside_torch, unpack_triangle_mesh\n",
     "from mascon_cube.data.stokes import combine_stokes_coefficients, mascon2stokes\n",
-    "from mascon_cube.training import CubeTrainingConfig, ValidationConfig, training_loop\n",
-    "from mascon_cube.visualization import plot_mascon_cube, stokes_boxplot, stokes_heatmap, plot_asteroid\n",
+    "from mascon_cube.training import CubeTrainingConfig, training_loop\n",
+    "from mascon_cube.visualization import plot_mascon_cube, stokes_boxplot, stokes_heatmap, plot_asteroid, stokes_degree_error\n",
     "from mascon_cube.metrics import compute_acceleration, cosine_distance, norm_distance, relative_norm_distance\n",
     "from mascon_cube.data.loading import load_dataset\n",
+    "from mascon_cube.data.datasets import create_random_dataset\n",
     "from matplotlib import pyplot as plt\n",
     "import pandas as pd\n",
     "import gc\n",
@@ -50,7 +51,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 183,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -67,16 +68,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 184,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "asteroid = \"eros\""
+    "asteroid = \"eros_3\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 185,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -86,7 +87,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 186,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -96,20 +97,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 187,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 1000x1000 with 1 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 469,
-       "width": 600
+       "height": 800,
+       "width": 780
       }
      },
      "output_type": "display_data"
@@ -120,6 +121,23 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_set = create_random_dataset(asteroid, 10000, \"spherical\", 0.0, 2.0, 42)\n",
+    "val_set = VAL_DATASETS_DIR / f\"{asteroid}_1000_spherical_0_2.pt\""
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -129,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 188,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -138,7 +156,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 189,
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([2170])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cube_gt.weights.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -155,20 +193,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 190,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 600x600 with 7 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 575,
-       "width": 592
+       "height": 576,
+       "width": 591
       }
      },
      "output_type": "display_data"
@@ -181,20 +219,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 191,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAIKAkEDASIAAhEBAxEB/8QAHAABAAIDAQEBAAAAAAAAAAAAAAQFAgMGBwEI/8QAVRAAAQMCAwMFBw4LBwUAAwEBAQACAwQRBRIhBhMxFCJBUXEVMmGBkaGxBxYjMzQ1YmNyc6Ky0eE2QlJTVFWCkpOzwSQmdKPC4vAXJUODlERkdVbj/8QAGwEBAAIDAQEAAAAAAAAAAAAAAAEDAgQFBgf/xAA5EQACAQMBAwkGBQQDAQAAAAAAAQIDERIEBVFxExQVITEyM1KhIzRBYZGxImKB0fAGJFNjcpLB4f/aAAwDAQACEQMRAD8A9/REQBERAEREARFFxGV8GGVU0ZtIyF7mnqIBsgJSLy/Y7bzEWbBYjX7RTiqxKipo6xjhG1nKI5ow6IBrQBfPmj0HFqs9hcex1+y2KT7QOnxTEaDEpaRzaWBge7LkGVrW5RoSdT0dKA71FQYZtVTYhWzUNTRV2GVkUPKDBXRtaXRXsXtLHOaQDa+txcLTg22EeOy0zqXBcXbRVQLoK+WFjYXtsSHd/mANtCWjiEB0qLl49taarr5YMOwnFq+nhnNPLW00DTA14NnAFzg51jxLWkL5iO29HQYjWUVPhuKYk+haDWSUMDXsp7jNZxLhd1tbNzFAdSi5au27wmj7ibmOrrxjUcklFyOIP3mVrXWsSCCQ7xWN7WUWv9UGjpdlcbxYUNXFV4SRHNQVTQyVsj7bsGxIs7M3UE6IDs0XI0+DbYmnjqp9q2NriA99K2gjNKD0s/OW6L5/Cruhxumr8YxTC4mSifDXRNmc4DK7eMzjLrfgemyAs0XnuMbff2DZTGMPNVHQ4jiLoJYNw18srQ2QBgaL6l7W2sV0GG7YUFdPX09VT1eF1VDFyieCvY1jhDr7IC1zmluh1B0trZAdEi5Oj29oKuooRJh2K0lJXyCOjramnDIZ3O70DnZm5vxczW3XWIAiLznFNpp5NuMSwWs2qi2ahpWw8jDoos1Xmbdz88oLSA7m5W66ID0ZFwm0e0WM7MQbMQsE2MSVtcIZ6inhibvmZXuDWgvADjzbHhzXajQG1rNsoKOSjpHYRik2KVUTpxhsMcbp44wbFz+fkaL6d9qgOmRcLjO2fKdmKTEsEmlp5DjFPQ1Mc0IEkRMzWyRva4GzrHz3BVydssJ3mJuD5TQ4Ywuq8QDRydjhxjDr3c8dIaDbhe+iA6FFzFBtpS1mI0lFU4XiuGurb8kkroGsZOQM2UWcS12W5s4NOiUe2cOI1m7ocHxapo+UGm5fHCzcZmvyOOr82UOBBdltoUB06KNXVtNh1DUVtZM2GmgjdJLI7g1oFyVT4PtUMZljyYJi9LTSsL4qqqgayN7bXv3xc244ZmhAdCi46D1RsKm3FRyLE48KnnEEOKvpwKZ7i7KNc2YNJ0Di0DwqbiO2FNRYpPh1LhuJ4pVUzWvqW0ELXiAOF2hxc5ozEa5Rc+BAdIi862r23q5aLZ07NMrZIMYnAFZSxQufkDXkxtbK4ASXb+MLCx6dFootodoq/byPBC3GqeloaenfO7k9GXzFznZnzHMcrSG29jF+PDRAemIuQottMPp9kqLFZ5sQrDV1ElPTxugZymokEj25QyPm/inq0FyssU2qMWy2IYlU0WM4PyYxgl8MLpec9oBYC5zDxsbnRAdai5/Ftq6bDcUGGQUFfideIhNJT0MbXGKMmwc4uc1ovY2F7m3BRKn1QMGpcBoMXLaySCsrBQtjjgJljm5wLHs4ggtIsLm9rXQHVouVZtnHUQ4pAzC8SpsToaXlIo6mNjZJGG4a9nPLSLtI77TpVbs9t9JLsPTY3jmGV8B5PC4ziOMtqpJCGgRNa8u1cRxDeKA7xFU4RjMuKvlbLg2J4c6MAjlrGAPvfvSx7h0KNtBtZRbO1uG0dRTVtRPiLpGU7KWIPLnMaDa1xxv2ddhqgL9Fy0220Mc8dJHgmL1GI7rfzUUEMbpKZhJDTIc+QE2NgHElRMT2t5XQbM1+C1LmQV+MR0k7XxAPDbSZ43NcLtcHNsenRAdoi53Ftqu4884lwPGJqWnGaWsgga6NrbXJ1eHOAHHK08CqjHttKyh2s2cpMNw6qxHD8RpZ6hxpWxEzABpZkL3tta9ze2jm2vrYDuUXKz7UxUWIYu+aPE3mgwyKuloRFEcjXZ75SDdz+abguy6CysKzabD6Smwidu9qG4tPFDSCEAl2duYO1I5oaC4nqQF0i5Ot29w+kmrt1h2KVtJh7zHWVtLTh8MDm9+CS4Odl/Gyh1l09PPFV00VRBI2SGVgfG9puHNIuCEBtRchUeqFhkHKKhtBic2F00pinxSGAGnjLTlcb5szmtNwXNaRodVIxPbWjw/aFuBxYfiNfXvpG1sbKOJrw6Muc29y4AWLemw1GtzZAdOi5Sl25pa3GarC6XCcVlqKOdkFU4RMDIMwac7nF9sozHhd3NOnXpg9UbCptxUcixOPCp5xBDir6cCme4uyjXNmDSdA4tA8KA7FFy9RttSxbR1uBU2F4pW19GInStp4mloa8XDsznAWHh16gbFdQgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAouIxPnwyqhjF5Hwva0dZINlKRAed4T6nm/wAM2RnxKSSlq8Ko4Yaykblc2fdlr2NcQbcyRubS/So8+yuPO2bx+mjpiX1O0L67kwqRGaylL2kszg83M0Hjbwr0xEB5ns9svWUG3Yxik2RpcFw3uXNT7lksWeSUvY4bzISNQDa2a1jc62WeEYDi9JtDhsmEYFWbPUUcrnV0UmJNmpZY8p5scLXOscxFiAy1l6SiA4TZqDaHZOjGANwE19HFUyOp6+KqjY0xySOf7I1xDg4Zj3odeyRUu0ey+L4/3MwMYtTYpVGtglbVRxbqRzGtcyQPIOW7AQW5tDwXdogPO8I2MxDBazYSENbUQ4PT1bKydrgGtfIxtrA6kZswFhwGtltxPYuqx2s22pakGnpcXjpOSVAcHc+JnfZQb814bxtdd+iA5GnxnbBtNHTT7KMfXABj6ptfGKVx6X/nAOnLk8C0OpMewTbHG66gwcYlTYu2BzJBUsiEEkbMhDw7XKdDdoceOi7VEB5TT7L7T0WyOxUMWGxTYjhOIPqaqF87GtDfZfxrnjmFrXsSL8CrOfZrF9rcTxuvxSiODx1ODPwmmifKyWQ53FzpHZCWgA5QBc9PBehogPLcM2UrHPw2jxXZ/GZDSywufO/aJ8tKHMIIe1hkzG1rhpYOpekV1GzEKOSllknjZILF1PM6F41vo9pDh4ipSICDhmGxYTScmhmq5mZi7NVVL533Pwnkm3gVFj82IVE89HUbEsxqiFtzJyinLXXaL5mykZdbjTNwXVogPLqbY/HcJ2P2djjpWVVXheMHEHUENQLRwu3g3THvsCWiQcbDQq4qqfHabauDaqkwKWoFThwoqnDzUxMngLZHPa4OLsjgcxBAd1LuUQHl1bsXjOI7M1wq6RorMWx6GvnpYZwNxAHMBGe4u4MZclvTwUmo2Oxl+yWJbDAMfhhpx3NxFpawsyuDmxTNFje479o1HGx4+kIgPOMJ2dqZ8Yw6TEdnsbY6kmEwmrdoXVMMcgBs5jDI4u4katboStU2A4ycainwPZ+swKpdXNlqalmKNdSSsz3eXQhxzFzb/iNNzxXpiICk2uwN20uyeJ4MyURPq4HRseeDXcRfwXAUPD63HcUpzh2L7OyYeJIHRz1TKuJ8d8tvYw05tfCBZdOiA8tdgG1FZsRSbDVGDxRQxbmnlxZtSwxGCJ7Tmay+fOQ0aEAXPFbsS2TxGi2rxbEIaLF8QpMSkZM0YbjLqN0TwwNIezeMa4c0EOBv0W0XpiIDz9mytTT0+x0VBhb6WDD8SkqqmGSrEzoWuZLcl7jdxLnjhfirrD8KrYPVDxvFZIMtFU0VLFDJmbznMMmYWvcWzDiOldMiA8yoNlMew/ZrZiqhoo34rgtbVTvoZJmgTRyulBAeLtDsrw4X061bbTQ45tTsNilE3AZaKrkMQhgmqYXOktI1zjdri0WA/KXbogPOsf2Vr49sa7G6akxOvpsQhhZJFh2LOopInxhw1GdjXtII4m4N+tfHbJ1TcKwFlDhE9M6PaGPEauKorhUSNbZ2aRz3O5xPN0BPHpXoyIDlarBK2o2/nxARZaGTA3Ue+zDSUy5rZb34a3tZU2D0GKxep7Ds3i2x7qzkdPFTvjfWQ7uqDT3zDmuCLBwzBvavQ0QHE7HYXjVDjFbJLT11BgroGNgoK+uFXI2UE5nNdmdlZlsMuYqfjmE1tZtvsriMEGeloHVZqJMzRu88WVuhNzc6aLp0QHnGO7KV8W2OIY1T0mKV9NiMUIdHhuLOopIXxtLdRnY17SLa3uDfTVbRsrVR4Vs/HQ4TNSuix5uI1cU9aJ5Gts/M9z3O5xJIJAJ49K9CRAeU45shiVbX7Q8q2Xp8bqq2R7sPxKqqIzHTRlgDWZHHM0tN+9bzj0jirBuB45hlLsFXRYU+snwXDnUtZSRTxtkDnwxtu0ucGmzmEHndOi9GRAcrh2GVztucTxaqonRUdXhlLC0SPY452ukL2EAnhmGvA9BKodkdlMaoNpYY8UhAwjAY5ocHkMrXOmErzZxANxkjAj1txK9IRAeUN2MxDCp8So3YXjWJUlTVTTxS0OOupo8kji4tkiMjQCLkEtBvxXpOEUUeG4JQ0MUHJ46enjibDvDJuw1oGXMe+twupyIDyGl2Gr8Kw6bAqjB8axSlLpWMlpcfdBTyxPc42fEZG5dHWcGtcDqeldjQYDVUfqhd0GUuTDWYFDQxybwOs9sr3FnHN3pbrZdaiA5LAcBq4aza4VkRhixOuc+B4c0l8ZhYy+h01DuK5p2AbUVmxFJsNUYPFFDFuaeXFm1LDEYIntOZrL585DRoQBc8V6kiA5jBcJraTbranEpoMlLXNoxTyZmnPu43B2gNxYnpXToiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIqpuMZ9qZcFZT3ENEyqkmz8M73Na3LbpyON79CtUAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBFhI/dxuflc7KCbNFyexU+A7Rw49JXxMoa2jmoZmxTRVjGtddzGvBGVztMrhxQF2iIgCIiAItNTOKalmnMckgiY5+SJuZ7rC9mjpPgVPhu08Vdigw2ow3EMOq3wunhjrGMG+Y0gOLSxzhpmbcGx1GiAvkREAREQBFrmk3UL5Mj35Wl2Rgu426B4VSYftRHV4tHhlVheI4bVzROmgbWMjtM1pAdlLHuFxmbobHVAX6IiA5vAKaoO0+02IzwSRNlqIaaAyNLc8ccTTmF+Lc8kmvgK6REQBEVFJtVh7NrIdnGsnkq5I3PMjGjdRlrc2Rzr99lINgDoRe1wgL1ERAEREARR6upZRUc9VI1xZDG6RwaNSGi5sqrANopceiinbgeJUVLNA2eKoqjBlka6xAAZK51yDfUBAXqIiAIiIAi1yyMhifLK9rI2NLnOcbBoHElU+D7RjGpWugwnEoqORm8hrJ42Mjlb0FozZxfiMzQgLxERAEREARFy/rwfHi+H4dV7OYxSSV8rooHymmc27WlzickznWDQTeyA6hERAERee+qDJiuN4vh+yWA4jUUFZJTzYhPUU0pjexjGlsbSR+K6Rwv8AJQHoS5XGcX2spa2qbhezUNbSstHC91Y2N73lt85adN2Ccp1zaEgFYYVtXUYn6mfrjpqYz17KCSR1MBqaiNpDmW49+0hcjsmzD9s8LpqmT1RMXfjs8Qknp6TEBBuJCLljYLWs06ag3sgPWW3yjNa9tbLJRYJYoXRUDqtstUyEOLXvG8c0aZyOq/T1qUgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIDF7srHONyAL6C5XD7J4oJ9r9pHOw7F4I6+pimp5KnDZ4WOaynjYbuc0Ac5pFjxXdLWyRj3Pa17XOYcrgDfKbXsfER5UBsREQBERAR6yoFHRT1RimmEMbpDHCwve+wvZrR3zjbQLjNk652NY6/GMVpMTgxN8Lo6emnw6eKKjhuCWbx7A10jiGlxv0ADQa92tbJGPc9rXtc5hyuAN8ptex8RHlQGxERAEREBpqJuT000+7kk3bHPyRNzPdYXs0dJXDYRByjb6DE8MpMZ5M6nnbWyYtHM0R5nNLGw77nN5wNwzm2A6gu/WtkjHue1r2ucw5XAG+U2vY+IjyoDYiIgCIiAwkDzG4RuDXkHKSL2K80pdmtp8K2s2ZD6uhq4Yn1UlTVR4fKHOLw0vdI7ekZ3/inQC3AgWXpy1iRhlMYe0vaA4tvqAb2NurQ+RAbEREAREQEWvMYw6pM0L54hE7PFG3M6QW1aB0k8LLiMAoKSPbCjqNm8ErcKwxlLKyv31I+ljldzd2BG8DM4EOOYDh06r0FaxIwymMPaXtAcW31AN7G3VofIgNiIiAIiICs2hw+XFtmsVw2F4ZLV0c0DHHoc9haD51weyWFmnxnADhuDYjh01NSvZjUtTE+NszsgABc7SV285wc29gDrrZenrWJGGUxh7S9oDi2+oBvY26tD5EBsREQBERAFy1JSVOI+qBW4lU08sdJhlO2jojIwgSPks+aRt+IsI2XH5Ll1K1iRhlMYe0vaA4tvqAb2NurQ+RAbEREAXkuB7SzUO1+0uNYnsztM+erqG09JucJle1tLELNsbaZiS4jsXrSIDyTZjaKvwXGtpBTbJbSS4TVVba6nY7D3RPYXi0wAfYHnWIaDfUrHaeibt5V0EOD7JYhh+IR1kc8uMVtFyU07GuubOPOe7wDReuogOYwn+17f7RVZ1bSwUtC3wHK6Z381nkWe19fiNJTYZTYTUMp62vxGGnZI+MPDW6vk5p48xjvtHFS63AIpcOxKlw+omw+bEZt9PUwvdvM3Na4tN+acrA0W4cbKdUYfS1dXR1c8Weaje58DsxGRzmlhNuB5riNetAee1+JbTUeHbXSt2je6HAyTTzGjiMk8m4ZJun2blyguA5oDudx019JiLzCwygCQtGYDgD0quk2ewqWjrKSSlzQVs/KKhu8d7JJdpve9/wAVunDSytUAREQBERAEREARVtJjdDWYhJQxSTCpYHOyS08kYe1rg1xYXNAeASBdt+I61ZIAiIgCIiAIiIAiIgCIiAwLrG1k3ngWLu+XxaE601JpMysZbzwJvPAsUWHL1N4sZbzwJvPAsUU8vU3ixzu1u1p2W5JaiFTyjP8A+XJly28BvxXM/wDVt36lH/1f7Fl6rXDCf/b/AKF5msdRqKkKjjF9R6zZWytLqNLGpUjdu/xe/iel/wDVt36lH/1f7FW4b6oxw+uxap7liTuhVtqS3lFt3aGOK3e6+13vpx8C4ZFRzutvOj0HofJ6v9z0v/q279Sj/wCr/Yn/AFbd+pR/9X+xeaInO628dB6Hyer/AHPWKf1SjPA2TuUBfo5R/tW3/qK79Vj+P/tXntB7ij8fpKkqh66vfvfY1pbH0afc9X+53P8A1Fd+qx/H/wBqrcN2wOH1+LVPIRJ3Qqm1Jbvbbu0McVuGvtd76cfAuYRRz+v5vREdD6Py+r/c7n/qK79Vj+P/ALU/6iu/VY/j/wC1cMic/r7/AEQ6H0fl9X+56DFt2ZIw/ucBfo33+1Z+vg/q4fxv9q4ul9zt8fpW5VvaGo83oa0tl6VPu+rOu9fB/V4/jf7VW4btGcPr8WqeS7zujVtqcu8tu7QxxW4a+13vpx8Co0TpDUeb0I6M03l9Wdd6+D+rx/G/2p6+D+rx/G/2rkUUdIajzeg6M0vl9WdnFtkZG35CBrb237ln67j+hD+L9y5Om9rPat6xe0dT5vRFMtn6dPu+rOm9dx/QR/F+5VsOM7naOtxfcX5TSQU26z97unSuve2t97wt+L4VVonSWp83oY9H6fy+rOm9dx/QR/F+5PXcf0EfxfuXMonSWp83oOj9P5fVnSna8j/8EfxfuXz13n9BH8X7lzJ4r4p6R1Pm9Cej9P5fVnT+vA/oI/i/cq2HGjDtHW4vye/KaSCm3Wfvd06V1721vveFvxfCqpE6R1Pm9EOj9P5fVnT+vA/oI/i/cnrwP6CP4v3LmETpHU+b0HR+n8vqzrodqDMwnkltbe2fctnrjP6L/mfcuao/aj8pSVHSWp83oa8tFRT7PuXnriP6L/mfcq2Ct3O0dbi+7vymkgpt1fvd26V179N97wt+L4VFROktT5vQjmdHd9y89cR/RR/E+5PXEf0UfxPuVGidJanzeg5nR3fcvfXGf0UfxPuT1xH9F/zPuVGidI6nzeg5nR3fcvPXEf0X/M+5VsNbudo63F93flVJBTbq/e7p0rr36b73hb8XwqKinpHU+b0I5nR3fcvPXEf0X/M+5PXEf0X/ADPuVGidI6nzeg5nR3fc6zD63l0LpDHks7La9+gfapiqdn/cUnzh9AVsvQaWbnSjKXazk1oqM2kfURFsFYREQHw8F5Di/q3nCsbr8O9b295JUSQbzluXNlcW3tu9L2Xr3QvyRtcP76Y7/wD0aj+Y5Q2dHZunp15tTVz03/r+f/8AMj/7v/8AmrTA/Vilx2pqKdmE4fQmKHfb2vxXdRHnNbYu3Rsed5l4KR4F6J6jTKyTa+sbQTwQT8gfZ88LpWgbyP8AFD2+lQnfqOjq9n0KdGU4x61xPf8AC562poWS18FLDM7UNpagzxlvQQ4sbfyLm8Jimw71RsWo+6FfU07sLgqt3U1LpA2R00wOUHRujWiwtwXXszhjd4Q59tS0WBPZquch2QdBtO/HvXDjD6iRrY3xPMG7dE1znNjsIr5QXu6b68VkedOVwurxGLBNltqXYrXTVeL1kLKunknc6AxzkjI2PvWZLtsW2PNN73XdnCqw1u/9cGJCPeZ+T7unyWvfJfdZrdHfX8KraLYjD6KuppmVVdJS0kzp6SgklaaenkdfnNGXNpmdYOcQ2+gC6dAczhjcSq9qaquxPCqqmbCx9PROMkLoxFmaXOOV5dmeWtOrbNDQON79MiIAiIgCIiAIiIAiLkMdxPEZtqYsCpMZp8GZyQVO/kibJJO4vc3JGHnLzQ0F2hPPagOvRchgWJ4jDtTLgVXjNPjLOSGp38cTY5IHB7W5JAw5ecHEt0B5jl0eIyYhHSF2GU1NUVOYWjqJ3Qst0nM1jz5kBvd3yh0+I0NXPLBTVtPNNCbSxxytc5nygDovtBJiElMHYlTU1PU3N46ed0zLdHOcxh8yo6OrbWbSy1UtLWU7KRj6WnYaGVu8zPZneXZcti5rbC/AFx8HMmryZmXsFdSVU00NPVQTS07ss0ccgc6M9TgOHA8VJXI1U9V3X2ibhlPVMq30EbaaR1JI2N0rd6TZ7gGk85vTrftW/ABiUMMu7mkrGOlbdtbHUUxiFudl3u8c/o0uG+FYuIL+nrqSsfM2lqoJ3QvySiKQOMbvyXW4HwLKCpgqWudBPHM1jzG4xvDg1wNnNNukHoXNRyVU2JbQwYZDNBUyBghlqKaWKIloyuLZCzKTrpa9+OoUnZCkqqGhrKepoo6RrauTdMjlc8FunS5rbjw9KnEHNeq1wwn/ANv+hecy0lTDEyWWCWOOTVj3MIDuw9K9H9VrhhP/ALf9C4osDMCfA40rJHSMkaWThzpAGu74ZjlsDpwve1ieGGpjerL+fA9rsmq4aKnb4t/dla+mnjgZM+CRsT9GyOYQ13Yelal0zJqInPVTROpJ+SsEYeCW5QM1wNRazhe3TpdQcUNJI9maNtO5rHc6nfFKH66XyZQ3yXVLppK9zoU9VKUsZR/n86mVklNPDEyWSCRkcmrHuYQHdh6VjJFJCWiWN7C5ocA4EXB4HsXQz1FCHSS1EjZaWaeGSOKJzXODWscCC24ta4bY28Cg4/UQ1VTTyw1Lp3GBudzmBpv2AnydCiVNJXuTS1M5zUWv5/Oo20HuKPx+kqa6nmjibK+KRsbu9e5pAPYVCoPcUfj9JXRVb45KBzWPhuWxZXNkGaTK0g5hfS3DgPGtVQUrlGoquE0l8So3b91vcjt3fLmtpfqusVeMnw6Sjp4nSyCJk8d4nMA0scxuHE9J1t1BRK80z3MzMbCQ06wujkzG+l8uUD0qZUkldMphqW5YuJD5LUWjO4ltKbR8w8/s61jLDJA/LLG9jvyXtIKuZKhscrpoXwvMk0T4WOkAADWnvteba4GtlW1zIWSRboMa4svI2N+drXXOgNz0WPE8UnTSjdE0q8pTs1/P51G6m9zs8fpUncyiLemJ4jPB+U28qjU3udvj9KtKcBtFMHGFpkaA128GY84c0i+g0vew7VrRipNlVebg7/MjCmndDvRBIYuOcNOXyrUpMT2RUUtyM8rgywOoaNT58vkKlVxpHOAaxrIg85XxuY9xb0c0WPV32qy5NON0yrlpKVmiv3Mu7Em7fuybB2U2v1XSWCWAgTRPjJ4B7SFPzs5OXiRmUwNja0uF8weDw6OBN/CtNfkfllLYmzvc4yNifmFtLHidePT0KZU0o3MYVpSnZoxpvaz2qS6N7Gtc5jmhw5pItfsUal9rParGVhNFBz4yQXEjeNuBpbS/gVMY3uY1ZYyRGyOyZ8py3te2l+pfFZtlpHU8THPfkbKy7HNA0sbnitFUYXObdojIB1jLX5uq+WwCzlRSjdMojWbdmiNuJeYd0/n97zTzuzrXx8b4nZZGOYepwsVYOlDXmRj43F8kbo2lw0sDx106AodU2NrmZA0Etu5rHZgDc8D2WSdNRV0IVZSlZkd3FfXRvY1rnsc0OF2ki1x4F8PFSpWF1DT8+MkFxI3jbgaW0v4FXGN0y2UsWjQ6CZse8dFIGHg4tNvKtamQuhZFBHI4FskueWx4NGgB+l5UqjC5zbtEZDTrGWvzdV8tgFY6axumYKq72aI+4l5nsT+f3nNPO7OtYvjfE7LIxzHdThYqxdKGvMjHxuLpI3RtLhpYHjrp0BQ6psbXMyBocW3eGOzNBueB16LKZ01FXRFOrKUrM3UftR+Upe7fu8+R2T8q2nlUSj9qPylYgB9OA8RgtbZhD9TrwIv4Sq4RyvcprSakaCx4jDy12QmwdbRfFIa08jddzbZwbZhe2vR41nUmEkBoDWAmzmlrjbsFvOsuS6rlfKWdiMWOyB+V2Xhe2i+OjewAua5oPAkWupYewRh5cC3dhuW+t8wPDylYVeQuLm5cznk8117joJ8KmVJKN7kRqNysRhwWe7fkz5HZPyraLFSAA+nAeIwWizCHanncCL+ErCEVK9zOcmrGgMfkzhjsnDNbRfFKa5u5BLhlEZaRfW9+rzr7U7kkBrQ1lzZzC1xt2C3nVjpLG6ZgqjvaxF3bsmcsOXhe2i+uY9gBc1zb8CRa6kh7BGHEgs3YblvrfMOjylY1eQuL25cxee9de46CfCkqSUb3IjUblYutn/ccnzh9AVsuVpJ8ciprYTh9BVMLznNVWvgINhwDYn38ynbU1lZQ7E4xW04yVsGHzSsyHNleIyRY21sfAvS6LwI8DkajxZF4i87w/CqDZ7aXZLuM0R90qeZlY5rieVNbEHiR/wCU4OtzuPPPWvRFtFIREQHzrX5K2tH988d//oVH8xy/Wp4Ffk3awf3yxz/+hUfzHLGXYdvYavVlwKSy7v1KIIJ9pqyOpwjutGaF16XJE6/sketpC1unauHsvQvUdZWP2tq20M8EE/IH2fPC6Vtt5H+KHt9Kxi+s7G0Y200z9CQtAgjDYt00NAEdhzB1aaaeBbVgzOGN3hDn21LRYE9mqzVh4wIiIAiIgCIiAIiIAiIgCg4lhGGYzAIMTw6krYgbhlTC2RoPWA4KciAg4bhGGYNAYMMw6kooibllNC2NpPWQ0KciIDU/vivi+v74r4uXU77M12BERYEhEREDzn1WuGE/+3/QvM16Z6rXDCf/AG/6F5msNX4rPdbD9xh+v3YREWsdcIiIC7oPcUfj9JUlRqD3FH4/SVJWtLtZqS7zCIigxCIiAsKb3Ozx+lblppfc7PH6VuVT7TTl3mERFBAREQEqm9rPat60U3tZ7VvWDNaXaERFBiEREBi7ivi+u4r4pJCIiAIiICbR+1H5SkqNR+1H5SkqGak+8wiIhiEREB9CIEUhhERCAiIgOj2f9xyfOH0BWb2Newse0Oa4WIIuCFWbP+45PnD6ArZes0XgR4HC1HiyKTCNk8EwOqNTh9EYpd3umF0r5N2y98jA5xDG3A5rbDQK7RFtFIREQHw8CvyftWP7445//QqP5jl+sDwK/KW1Q/vhjf8Aj5/5jlXU7Dv/ANPq9aXApbL0D1IKaWq2tq4oa2ejeaF5EsDWF3tkenPa4eZcFbwLv/UhdWR7WVTqCCCefkLrMnmdE228j/GDHehYQfWdzakbaSZ+g2NLWNa57nkAAuda58OizWDM5Y3eANfbUNNwD26LNXnhAiIgCIiAIiIAiIgCIiAIiIAiIgPPNpPVJOA7QVWGDChPuMvsnKMt7tDuGU9aqv8ArAf1GP8A6v8AYuY9UX8PMT7Y/wCW1cuuPVk1Nr5nudHsfR1NPCcodbSfa9x6f/1hd+ox/wDV/sT/AKwu/UY/+r/YvMEVeTNroPQ+T1f7np//AFhd+ox/9X+xfW+rAS4A4IAL8eVf7F5einNkdB6Hyer/AHPbsUx3YfHmQOxCpE4jvk5sote1+AHUFXZPU16h/nrzKm9zs8fpW5ZS1bb64r6GvDYsaaxhVml8mej5PU06h/npk9TTqH+evOEWPOvyr6GXRP8Aun/2PR8nqadQ/wA9fRH6mpIFh/nrzdfWd+3tUrVflX0Ilsmyvy0/+x6TtXgGHYVFRtw+AQB2e4uTfh1nwrmeTfD8y7nbrvaDsf8A6Vxy1Nd+Gu0v51Gts2rOWmi5O76/uR+TfC8ycm+F5lIRad2b+ciPyb4XmTk3wvMpCJdjKRJpab+zt5/X0eFbuS/D8yypfc7fH6VuVbZpSnLJkfkvw/MnJfh+ZSEUXIzkR+S/D8ycl+H5lIRLjORpadwMvfdK+7/4PnXybv8AxLWhkkn1s3b/AOD503/wfOtKKRijdv8A4PnTf/B860ooGKJ9PBylhdmy2NrWut3c/wCM+imGe0P+V/QKapNKpUkpNIhdz/jfMnc/436KmooMOVnvIXc/436Kdz/jfMpqIOVlvIN+Sczvr634Jyz4HnXyt9uHyVHQujFSV2SeV/A86cr+B51GRQZcnEk8r+B505X8DzqMiDk4lrSN5TGX3y2NrcVI5J8PzLThPud3yz6ArDpViRz6kmptIi8k+H5k5J8PzKUiWRjykiLyT4fmTknw/MpSJZDlJFlgsW6pXi97vv5grNQcK9zP+WfQFOXqdH4ETkVneoz6iItorCIiA+HvSvyrtUP7341/j5/5hX6qPA9i/LG1I/vdjX+Pn/mFVVuw9F/TnjT4FLlXo3qLC22lT/gH/wAyNee5V3vqS00tVtVVRQ1s9G/kTjvYGsLh7JHpz2uHmVVN/iR3trL+zqH6BRYMaWsa1z3PIABc61z4dFmto+fhERAEREAREQBERAEREARFSY5tPQ4DU0lPUw1089W2R0UVHSSVDiGZcxswEi2ZqAu0XHs25jqsfwbDKbDMThFdPJHJJXYfNThrWwySc0vaAXXYNOq66TEZMQjpC7DKamqKnMLR1E7oWW6Tmax58yA8M9UX8PMT7Y/5bVz0tFVU8Mc01NNHFIAWPfGQ11xcWJ46aq422fWybYYg7EKeCnqSWZ44JjKwexttZxa0nT4K1VrGVOHMlmFIysaIo4zFUBxkjbHYlwzEAgNb1XJtYrkVIpzkfRtJVcNNRXwaX2RVy0dVBCyaammjik7x72ENd2HpWldFh/JIKCKKvNM2KSphe8xTB75W86+cAnKAD1A9vRoxY0UkkeaJlO5rDrTvimEhvpfJlDfISsXBWuXQ1Tc8Wv1KmSlqIYY5paeWOKTWN7mENd2HpWMsMsBaJY3xlzQ4BzSLg6g9hXS1FTQB0s1VK2Wlnngkjiic1zw1rHAgtuLWuG2Nr9HBQNoqiCrqqaaGqfUONOzeOcwNN9egOOvg6ElBJCjqZzmotfz+dRGpvc7PH6VLlpaiGJkksEscb9WOcwgO7D0qJTe52eP0q8qIDBhLImTQSunc2aVwqGHLZrsrbXvexN/DYduso3uZVqmEkl8SukpaiGJk0sErIn949zCGu7D0rUr2h5LDRRx1pp2xPqInOMcud0jdb5gCctgeoeNaMTNJI9maNsDmtOsD4pQ/XS+TKG+S6ydNWuUQ1Tc8Gv1K2SmniiZLJDIyOTVjnMIDuw9KGKSGVgkjewuAcA4WuDwPYr6eeiDpZaiRslNNNC9kcbmucGtY4EFtxa1w2xt4FDxueGprKWWKodO4wszucwNIPYCfIpdNJXuRDUzm8Wt56Pt13mH9j/8ASuP3b93vMjsl8ua2l+q67DbrvaDsf/pVFPLTTYY2KGRwLHjKx7Q38U3N83Xf0LDWRyryv8vscLZ9Rw00Or4v7lc6GVkbZHRvax3euLSAewrBXEU1M6Jpqms9ldE05ZQ7mt0vYd7p19eijVpgc5oLGxENOsTmSZj0Xy2A9K1pUkldM3IaiTli0ROTz2j9hk9k0ZzTzuzrWMsUkLsssbmO45XCxVs+cMeZo3xOL5YnxNLxYZWnjrpa4GtlX1jImPj3YYHFl5Gsdma11zwNz0W6TxSdNRV0KdaUpWZJpfc7PH6VIdG9jWucxzQ4XaSLX7FHpfc7fH6VYysJooOfGSC4kbxtwNLaX8C14xyuU1ZYyIxikEYkMbshNg62h8axVm40khifJkDAIwCH3JFgHAjoHi8q0VW5cW3aIyGnWNzX5uq+WwCslRSV0yiFZt2aI24l5nsT+f3vNPO7OtfHxvidlkY5jupwsVYOlDXmRj43F0kbo2lw0sDx106AolU2NrmZA0Etu4MdmANzwOvRZROmoq6EKspSsyFL3/iXzcyiLemN4jPB+U28q+zd+OxSYAG0cwcYQZGgNdvBmPOGhF9Bpe9h2rGEcjZlNximiLupDEZRG/dg2zW0v2rBWLHxima4vbkEBjLA4Zs2Ynh4wbpWmmc4BrWsjzHK+NzXkt6NBY+XVWOksbpmCrvKzRA3Mm7Em7fuybB1tL9q+ywywECWJ8ZPAOaQp2dnJy8SMymFsYaXC+YOB4dHAm6012R+WUiNsz3OL2xvzDoseJ8PT0JKklG4hVk5WsSsM9zu+X/QKcGktLgCQOJtwUHDPaHfL/oFbtdEaR0YcQ6w0IAub9d1XCClc09RLGbIxY7dh+U5SbB1tF8W9rf7I67m9+DbML216PGtlRuSQA0NaCbOaQ427NPOs+SWNyrlOuxFyOyZ8py8L20RzHsALmkA8Li11KD2BmYuBZkDct9b5h0edYVWQuzNy3Lz3rr3HQSplSSje5EajcrFRWe3D5K0ujexrS5jmhwu0kWv2LdWe3j5KykYTRQc+MkFxtvG3A0tpfwKmMb3N5SxUTQ6GVjGvfE9rHd64tIBWCnt3L90+pEbbOY3mPuXNAsbi5toB1LCqMTnNu0RkNOsZa/N1Xy2AVkqSSumYxrNuzRG3EvMO6fz+95p53Z1r4+N8TssjHMd1OFirB0oa8yMdG4vkjdG0uGlgeOunQFDqmxtczIGglt3NY7MAbngeyyTpKKuhCrKUrMssJ9zO+WfQFYFrgASCAeFxxVdhPuZ3yz6ArVzTuGc5vE6ZgkI3TNGu7VGay1waCWkA8DZfFJa5haN4Bzi0Gzr6DwdC1y5SRcZdPxSDfyWVsqSSumUqbuay1wAJabHgbcUc1zSA4EdoUkPYH5i4ZS5pFjw0WiUAFtrXtqAbhRKmlG6YUm3YtMK9zv+WfQFPXOCfHIowMJw+gqmEnOaqtfAQdOAbE+/mVxUUkeIYc6lroWujmZlljDzY9YvoSPIvR6PwInPrd9ktFyHqdU8NHgWI0tPG2KCHGK+OONosGtFQ8ADxLr1slYREQHx3Ar8ubTj+9mM/wCOn/mFfqN3A9i/L+0wvtZjH+On/mFa+odoo9H/AE348+BTZV6H6jQttjU/4F/141wGVeheo6LbYVP+Bf8AXYqKT/Gj0G11/ZVD3REVPhu0uE4xiNVh9DUvkqqVodKx0EjLNJLQQXNAcLtcNL8FvnzwuEVHS7XYFW4r3Np68PqS98bPYnhkj2d81khGVzhY3DSToVvO0uAit5Ecbw0Ve83W45VHnz3tly3ve+lkBaouepcXrxtfJhFQ+GWEwSTNc2kkgMdnMytDnOLZtH6llspbrbMAuhQBERAEREAREQBR5aOnmq4KqSFrp6fNupCNWZhZ1u1SEQGialp55qeaWFj5ad5fC9wuY3FpaSOrmucPGt6IgPAfVF/DzE+2P+W1csup9UX8PMT7Y/5bVyy41XxHxPpuzvdKX/FfYIiKs3AiIgLCm9zs8fpW5aab3Ozx+lblQ+0qfaERFBAX1nft7V8X1nft7VK7SJd1nrm3XeYf2P8A9K45djt13mH9j/8ASuOUbQ94f6fY85sv3WP6/cIiLSOgEREBY0vudvj9K3LTS+52+P0rcq2aU+8wiIhiEREBpm7/AMS1rZN3/iWtSWx7AiIhkEREBa4Z7nf8v+gU1QsM9zv+X/QKahzavfYREQwCIiAgVntw+So6kVntw+So6g26fdQREUGYREQFvhPuZ3yz6ArBV+E+5nfLPoCsFauw5dbvsIiIVhERAW+Fe53/ACz6At9VSxVtJLTTbzdSsLHbuR0brHqc0gg+EG60YV7nf8s+gKevUaPwInLrd9lJgeymEbOyzPwyKpjMxc6QS1s0wLi7MXZZHuFydSeKu0RbRWEREB8dwPYvzHtK3+9WMf42b+YV+nHcD2L8z7SD+9OL/wCNm+uVq6t2ij0n9NePPgU+UrrfU9oZq/G6uCCMyPNI4hor5aP/AMjP/JEC4dnSuWt4F13qd08E+O1UdRg/dWM0hvS5InX9kZraQtbp2rVoP2iPRbXX9lUPccLw+PDKBlPEahwHOO/qpKhwJ4jPIS4hcZS7TYHN6rdfBFjFEZZMLp6RjRM0kzNmnzMA/KFxp4V3kLQIIw2LdNDQBHYcwdWmmngW1dQ+cnkmEVcFRs7sdszDfu5h2IQGspcp3lPui7eyP6mu1s78bOLXuvW0RAVMGCCPFm4hPiFZVyRteyBk27DIQ4guy5WNJ70C7i427SrZEQBERAEREAREQBERAEREB4L6ocWbbrEjmtrH/LauX3HwvMus9UH8OMS7Y/5bVzK4dZ+0lxPpez3/AGlL/ivsadx8LzJuPheZbkVdzcuadx8LzJuPheZbkS4uZxP3cYZa9ulZb/4PnWpFjYho27/4PnTf/B861IlkLG3f/B86yZOBI3M3S+uq0IlkQ4pqx7RXbU7GYkIuWVgkyA5bRyC1+PAeBQ+63qf/AJ4fuzfYvJRwX1bMtTk7uKf6HEjsKnFWjUklx/8Ah613W9T/APP/AEZvsTut6n/5/wCjN9i8lRY8tHyR+hPQkf8ALP6nrXdb1P8A899Gb7EGK7AEgb76M32LyVfWd+3tRVo+SP0IexYpX5Wf1PWNsG0mAMohSUotLnuM56Ldd+tct64D+jD9/wC5dL6pneYX2Sf6V5+qNZSgqzSRhsqjGrpYzn1t3+5d+uE/ow/f+5PXCf0Yfv8A3KkRavJx3HR5pR3F364T+jD9/wC5PXCf0Yfv/cqRE5OO4c0o7jooMQ5Wwv3WWxtbNdbN/wDB86rcN9zu+X/QKaqpRSZqzpxjJpG3f/B86b/4PnWpFjYxxRt3/wAHzpv/AIPnWpEsMUWFNifJ4y3c5rm981v6Ld3bP6P9P7lUolip6em3dot+7Z/R/p/cnds/o/0/uVQiWI5tT3Fv3bP6P9P7l87tn9H+n9yqUSw5tT3FsKnlnsmXJbS17rLL4VHoPaXfKUpVvtKJLF2Rjl8KZfCskUEXMcvhTL4VkiC5JpazksZZu81ze+ay391/iPpfcq4r4srsrdGEndosu63xH0vuTut8R9L7lWomTI5vT3Fl3W+I+l9yd1viPpfcq1EyY5vT3HabP1PKaJ7suW0hFr36ArdUOyvvdL86fQFer1mj8CPA87qUlWkkfURFtFAREQHx3A9i/NW0bb7UYsf/AN2b65X6VPA9i/OG0Tf7zYt/jJvrlaWtf4Uek/pnx58CmyrtPUxpZanaSojhrZ6N5pHHewNYXDns057XDzLksi6rYJuDjGqnu7yHkPJTm5dk3d87LXz6XWpp37VHotr+5VOB7qxpaxrXPc8gAFzrXPh0Wa1w7rcR7jJucoyZO9y9FrdC2LsHzkIiIAiIgCIiAIiIAiIgCIubxfHcVhxs4XguFQ100NM2rqN/VbgBjnOa1rOa67iWP42Atx1QHSIuawva6nxfGaOhpYnN3tLUS1DJebLTSxPhaYnt6D7L5gRcG6ucRkxCOkLsMpqaoqcwtHUTuhZbpOZrHnzIDxX1Qfw4xLtj/ltXPy0lTBEyWWnljjk1Y97CA7sPSrbbGStk2sr3YhTwU9SSzNHBMZWDmNtZxa0nT4K1lgZgT6dxpWSOkZI0sna50oDX98Mxy2B04XvaxPDi1I3qS/U+iaWo4aWjbcvsVW5k3G+3b91myZ7HLmte1+tYLp46rCJcOpIHzyiCOqhzQvjA0sc5JDiSCSdbdQUDFTRyPZmjbTuax3Op3xTCTXS+TKG+QlYumkr3LYatuWLj/P5uKySmqIoo5ZIJWRyase5hAd2HpWMkMkJaJY3sLmhwDwRcHgewro6iooQ6WWpkbLSzzwyRxROa5wa1jgQW3FrXDbG3gUDaCogqqqmmhqXTudTtzucwNN+wE+ToSUElcmlqZzmotfz+dRULdLSVMETJZaeWOOTVj3sIDuw9K0q4LAzAX07jSskdIyRpZO1zpQGv74ZjlsDpwve1ieGEY3Lq1RwasV0tHVQwsmlppo4n2yvdGQ11xcWPTotC6BhophSTYk2mYWvgjvDNmMkQbY5wCctgG9A6dD0R8VNHJIzNGync1h51O+KYSa6XyZQ3yErOVNdqKKeqbeMl/P8A0rJKaoiijlkglZHJqx7mEB3YelYyQyQloljewuaHAPBFweB7CujqKihDpZamRstLPPDJHFE5rnBrWOBBbcWtcNsbeBQNoKiCqqqaaGpdO51O3O5zA037AT5OhJQSVyaWpnOai1/P51FUOC3mkqRTCpNPKICbCUsOTy8FoHBXFEwMwqqa80zTPGGsk34zk528wtzaDS9yBw420NcY3Lq1R00mt5XGkqRTCpNPLuCbCXIchPbwWlW8EQpsGlmM0Mj6hu7MYnZmjjDgTzb3JJGgtw16VIxd2HPc1kcTIYBI7dzQPjkeWW0BYMpHR3xusuT6rlK1Tzxav1v0KU01QKYVJgkEBOUS5TlJ6r8E3Uke6e+N7WSasc4EBwvbTr1V1vabkRkfO007qNkG7a4bwOEgJ5t9OBdfhrxWONVVJVU2Hupp3uLS8bt0Ybu25uaNHHoUuml13MVqZSeLj8X9jufVM7zCx4JP9K4KSCaFjHyRPY2QXYXNIDh1jrXe+qZ3mF9kn+lchUROfhFH7LC5zXPJbv2FwBAIuL3HAqdXG9aX6f8Ahzdk1MNJT+bf3ZCkpaiKJkskErI32yvcwgOvqLFaldNNLKKaWvbA0tfCz2KXMXxgWOYAm1gB1di04iaV72BzGwOa06wOjkz66XyZQPSqHSVrpm9T1Tbxa/n/AKV76eaONkj4pGxv7xzmkB3YelYyRSRECRjmEgOAcLXB4FXs09GHSSTyCSnmlieyOMhzg1rCCCLi1rgWNvAoeNTQ1FRBLFO6YmFucuYGkHxE+RJU0le5NLUSnNRaPuG+53fL/oFPbG9zHPDHFjbZiBoL8LqBhvud3y/6BdBFLTOwqWBsjmvIbzXNADnZuN83Z2WWqoqUma2pqYS6t5XBj3Mc8NcWttmIGgvwusVZwzUvcqaHePa7KC5uUc52YcDfXQDo619rzSOIaxjY4g85ZI3Me4t6OaLHq743WTpLG9zXWoeWLiV25l3W93b92TYPym1+q6+ywTQECaKSMngHtIv5VPzs5MXtkZlMDY2sLhfMHg8OjgTfwrTiGR+WUtibPI5xkbFJnFtLHiddT09CSppRuRCtKU7NEJZCN7mOeGuLG2zEDQX4XWKs4paZ2FSwNkc15Dea5oAc7Nxvm7OyywhHK5bVqOFrEA08whE+5k3R/HynL1cVrU8ZH0AE4iG7ZaNzZOeTmvYtv4T0LbXmkc4NYxjIg85ZInMe4t6OaLHq743WbpK10ytV3lZreV25l3W93b92TYPym1+q6+ywTQECaKSMngHtIv5VYZ2cmL2yMymBsbWFwvmDweHRwJv4VoxDI/LKWxNnkc4yNikzi2ljxOup6ehJU0o3IhWlKdmjOg9pPylMdG9jWlzHNDhzSRa/YodB7S75StJGE0UHPYSC423jbgaW0v4FrKN7lNaVpkd0UjGBzmOa13AkWBWKnRtZFHEJHseyR7XSWeDYdAtx6dVhVGJzm3aGEA6xlrr9V7WAWcqStcojWu7WI+5l5h3b+f3vNPO7OtfHxvidlexzHdThYqe6UNeZGOjcXSMcxpcNLA8eroCiVLWNc3IGglt3BrswBueB7LJOmoq6EKkpSszQV9dG9jWlzHNDhzSRa/Yvh4qTIwmig58ZILjbeNuBpbS/gWEI3TLZSxaNDopGsD3Rua08CRYFYKdBumQtbOYw0yMJyvuXDXiLm1r+BYVRic5t2iMgHWMtdm6r2sArJUlje5hGs8rNEfcy8w7p/P73mnndnWsXxvidlexzD1OFirF0oa4yMdG4ukY6NpcNLA8ddOgKHUtja5mQNBLbuDXZgDc8D2WSdNRV0IVZSlZnT7K+90vzp9AV6uPwqfHIqMjCcPoKphkOc1Va+Ag2HANiffzLocQpKXEMIkgxaOPkzmB1Q0yEMGWzjd2nN08FxxXptF7vHgef1XjS4lgi4rYiigbiGKYnhFJyHZ+qZEyjp2jKyZzc2edrPxWuzNA/KDM3SF2q2jXCIiA+HgexfnbaBv8AeXFf8ZL9cr9EngexfnzH2/3jxT/Fy/XK0Nd3Eej/AKb8efAp8i7j1K222pn/AMI767Fx2Rdb6nlDFXY/UQTPnaw0riTBO+F3fs/GY4HzrS0z9qj0O13/AGVQ9oRYMYI42sGazQAMzi4+U8Vmu4fOwiIgCIiAIiIAiIgCIiAKJ3Ppe6fdIR/2sw7gyZjrHmzWI4cb+U9alogK0YHhjMfdjraRjcTdTmmdUNuC6PMHWI4HVrdTrorJEQHhPqg/hxiXbH/LauZXTeqD+HGJdsf8tq5lcOt4kuJ9K2f7rS/4r7BERVG4EREAREQBERAEREBkOC+r4OC+qAERFAC+s79vavi+s79vapXaYy7rPVfVM7zC+yT/AErz5eg+qZ3mF9kn+lefKzW+M/58DjbF9yj+v3YREWodYIiIC0w33O75f9ApqhYb7nd8v+gU1US7Tn1e+wiIsSsIiIAiIgCIiAIiICwoPaXfKUpRaD2l3ylKVcu00qneYREWJgEREB8K+L6V8UmQREQBERAdbsr73y/On0BTsYwihx7Cp8LxKF01HUACWNsjo8wBB4tIPEDpUHZX3vl+dPoCvV63Re7x4HmNV40uJV4VgFFgznuo3VpL2gEVNfPUAAdQke4DxK1RFtGuEREB8dwPYvAcdb/eHE/8XL9cr353erwfHG/3gxL/ABUv1iuftB/gR6L+nPGnwKnL4F1ewFbR4Zjs9TXVcFLAKYgyzyBjQc7NLlc3lXY+psLbSTf4V31mLQ0r9tE7+1n/AGdQ9UjeySNr2ODmOF2uabgjrWaIu+fPgiIgCIiAIiIAiIgCIiAIiIAiIgPLNrNkziW01ZVit3e8yc3dXtZjRxv4FS+sU/rEfwf9y7/GPfWf9n6oUFeU1NaarSSfxZ6rTa2vGjGKl1JLccd6xT+sR/B/3J6xT+sR/B/3LsUVPLz3l/P9R5vRHHesU/rEfwf9yesU/rEfwf8AcuxROXnvHP8AUeb0R5lX4RyGtkpjPnyW52S17gHr8Kjcj+M8yvMf9/Kn9n6oVatmM5NI7tGcpU4t7iLyP4zzJyP4zzKUiyyZbdkXkfxnmTkfxnmUpEyYuzGLDM8YdvrX+D96z7k/HfR+9Taf2hq2qtzZS6krlb3J+O+j96dyfjvo/erJFGciOUlvK3uT8d9H71kzCgJGkzaX15v3qwRTykiHUk1a56HimM7H4ruRiNQJTEDls2QWva/AeAKuv6nn/N8uAn9ucta3XrHLrcV9Dl09jxhFKNWSXyf/AMPQ7+p5/wA3yX9Tz/m+XniKOdfkX0M+iv8AdP6nod/U8/5vkv6nn/N8vPEU86/IvoHsr/dP6no+0GGYRh+AU9ZhlOGtmkaWuzO1aWk9PYFyfKvgedddtB+AeEdkX8sriVTroxVTqVupGvsu86Lzd3d9pI5V8Dzpyr4HnUdFp2OnhEkcq+B505V8DzqOiWGES4oKU1sJkz5LOy2tdSu5Px30fvWOBe43/OH0BWipk2mcqrVnGbSZW9yfjvo/encn476P3qyRRkyvl6m8re5Px30fvTuT8d9H71ZImTJ5epvKy3IvY+/vzr8E5V8DzrKv9vHyftUVO0uhFSV2SOVfA86cq+B51HRTYy5OJI5V8Dzpyr4HnUdEsOTiWdMzlUZdfLY2txW7kfw/MsML9zu+V/QKd0pZGjUnJSaRE5F8Z9FORfGfRUtEsY8pLeRORfGfRTkXxn0VLRLDlJby82bi3VDIL3vKT5grlVeA+45PnD6ArVer0fgR4HA1DvVkwiItopCIiA+HgV4bjbf+/Yif/wBqX6xXuR4LxPGW/wDfcQ/xMn1iubtLuRPQf087Vp8CryLrvU6bbaKX/DO+s1cvkXQ7HV0OF4tNVTsqHxinIIp6aSd+rm/ixhzvMufpH7aJ3tqyvo5o9aRQ8OxGHFKQVMDKlkZcW2qKaSB+nwZGh3mVJheLYydscQwfFOQGGKjirIXUzHghr5JG2cXONz7HfQDivRHgTp0XCYftfjU0GDY1VQUIwXGKlsEEUbXieFsl909zi7K7NZt2hotm4my6Y1GPctyDDcO5JvLb3l8mfJfvsm5te3Rm8fSgLVFwWCPxA+qNPNiOF1cFRUUUgzvkhcxsbZRkDcshNreDvnO0AXeoAiIgCIiAIiIAiLk9pNqq3B62pjo8OiqqfD6EYhXvknLHNhu8WjGU5nWjkOpA0AvqgOsRcxgmN4zLjLMNxuio6eSppDWUxpZXPs1rmtex+YDnDeM1GhuepXeIyYhHSF2GU1NUVOYWjqJ3Qst0nM1jz5kBzuM++s/a36oUFbKiSvkqpXYlTU9PU3AMdPO6ZgFhbnOY0+Zb5g+SnaS2VuUNaGuNwbDiB4vOvJ14ZVZ8Wd2lPGnBfIiIpxbvmRb3eRsBY2zjzSLWuP8AnStU8UYIsDEbG4e0i/ZxVcqLSun1GUayfUyMisgBvG7y+6zs3V+FrHh5rqJVB2ZhcZMxbqJDcjVJ0cY5XEauTsefY/791P7P1Qq1WWP+/lT+z9ULbWQVsuB4e+SKdzWmQNJabBtmkW8FgT4itinHKJ6inVwp00/j+xUIrynkfJQUNJV1Um5qqhpIc8kMjbzRa+g1Lv3QtGI0lMx7AyOSjcGEkTxvYH66ZRd58psrXS6roiOqWeEkVSLpapkb2FtZIY6HexcmcQSMmR2bLYH4N7Dja6gY+WvqaeRssT81Oz2prgB4BcDRTKlZXuKWr5SajiR6f2hq2rVT+0NXRVzHvwvIGPs0RFribsfZhvkHR1njw6FRGGV2YV63JzSt2lEivHMNZFS8rNRTwh0MeWR/MeMtiWggW4X6eKi19NA17A1j6VwaSRNG5odrplF3HymyylRaV0Uw1ak8Wuv6lai6J75YZGSiN8kTJoXUrB+M0NJIb5r26VVYmx7Z43PfOXvjDiyd2Z7NSLE+K/AcUnSxjcmlqc54tFLP7c5a1sn9ucrOshrZcEw98kU7mNMga4tNg2zSLeCwJ8RSEckbs6uGKfx/YqEXQuiNbDR8sNVSwh0MWWV/Me3LYuYCBbQX6e+UPEqSmY9gYx9G7ISWzxvYH66ZRdx8psrHRaV0ymnrIyeMl1/UqkXSVTI3sLayQx0O9i5M4gkZMjr5bA/BvbptdQceLX1NPI2WJ+anZ7U1wA8AuBokqVle5FPV8pLHE7PaD8A8HHwYv5ZXErttoPwDwjsi/llc3DPOzCJWCSRwne2GOPMSNDmdYdd8vlKs1kVKr+hytmzcKDa8zK1Fex37ihhDxGYHEyXvGDvOBH5fhvwtp0rTiVFSROayJr4QHkCaRjgx7eg3BdftAA1Wu6DtdM3I6xOWLXxfoVCK7IeMP0u6l5O3Jbvd7nF7fC77w2WjGTJM5lTKKiN8r3+wzuzFg0NxoLA3tw6FEqVo3uTDU5TUbEvAvcb/AJw+gK1VXgXuJ/zh9AXRZM9E0M3gGS5seaXZuBHXw8y1VDOTOZqp41HxIKKXEH8jkDxIGW5rnHm8RwHXxX2qghYcrQ5gDiA97TZw8pv4lPIvHJGvyqvZohop/wD+OM1+T7sdmbML+Pj4lhXtNwSXgZ3BrXHS3WPAkqFo5XEat5WsUVf7ePk/aoqlV/t4+T9q3QCZ2HTMcybIWjIXElh5w0aPyuPn0UU4ZG/nhCLK9FYxsqGYW58m8dC8ZWCxLW87V3g6vKvtdS08bgxjXxAOIEr2kNcOu4Jv4gOKs5B43HOFli0VqK1s4UWlzT7luXqMmYXt4ePiWnEzJIWTyCZjpHO9ildctGhuNBpr5klRtG9yIV8pY2N+F+53fL/oFOUHC/czvl/0CuWBhontY9pcbEixve/Dgq4QybNOvLGbInQnQpjb8mHHdbs36s1/TwXyohiaQ1oLACQHuBsR5TfxLN0Ha6KFVV7ERFNA9hGa+5yDszZtfHxWFaDe5LxziA1x0t1jwKZUbRvcKrd2LfAfccnzh9AVquWpZ8cip7YTh+H1TC45zVVr4CDYcA2J9/Mr2qo48Rw59LXU8crJWASwl12E9V7ai/gXpNF4EeBydR4jJiLgNjqR2FbZ4tQyYbT4PvKOGaLD6GXeU7mh72ulDrNs8khpGVugHfdHfraKQiIgPh4FeM4w3/vdf/iZPrFezngV47i7f+9V3+Ik+sVy9qdxHd2C7VZcCtyK52ah3ldO3ktdU+wH2OhqdxKec3g7Oyw/aVZkVvs9LBTVk8lRi/cmMQ2NVnibbnN0vIHN17FztG/bRO3tKV9LPgepQi0MYyvbZo5r3ZnDTpNzc+Mrk6fDNp27d1GMTUmD8hnpo6JwbWSmQRskkcH5TFbMd53t7acV1kLgYIy2XetLQRJcc8demmvgW1elPDnCYfshjMMGDYNVT0JwXB6ls8EsbnmeZsd90xzS3K3Ldt3Bxvl4C67tEQBERAEREAREQBERAFG5DTcufWmFpqHxCF7/AMpgJIafBdx8qkogIpoKY4k3ETF/a2wmBshcdGFwcQBw1LW+QKUiIDkcZ99Z/wBn6oUFTsZ99Z/2fqhQV4/VeNPiz0FDwo8EERFQWhERAcLj/v5U/s/VCrVZY/7+VP7P1Qq1bsO6j0+n8GPBBERZFwREQE6n9oatq1U/tDVtVXxNeXaEREICIiAhT+3OWtbJ/bnLWrEXR7AiIhkERFJD7D0naD8A8I7If5ZXErttoPwDwjsh/llcSr9f4i4I4WyfBlxYREWkdQIiIDoMC9xv+cPoCtFV4F7jf84fQFaLXn3jiV/EYREWJUEREBXV/t4+T9qiqVX+3j5P2qKs0b1PuIIiKTMIiIC2wv3M75f9Apyg4X7nd8v+gU5Qcyr32EREMAiIgOhwH3HJ84fQFLr6CnxOiko6pr3QyWzBkjmHQgizmkEagcComA+45PnD6ArVer0XgR4HCr+IyqwrZ7C8Flmload4mmAEk80z5pHgcAXyOc6wudL9KtUWmeohpYXTVE0cUTe+fI4NA8ZW0VG5FriljnjbJFI2Rjho5puCtiA+HgV5Jirb4xW/4iT6xXrZ6V5Vijf+71vz7/rFcnar/BE7WxXarLgV2RXmys8tJicssNFPWP3JG6gLA7vm689zR51VZFc7MOrIsSldQwQTz7k2ZPM6Jtszfxgx3oXN0T9vE6+0Jf20z0Rji5jXOY5hIBLXWuPBos1gzOWN3gDX21DTcA9uizXqDxwREQBERAEREAREQETEZ6qmoZJqKj5ZUNtlgEojz6i/OOg0ufEqL15OptMU2cx6ht3zxScpYPHAX6eJdQiA001RHV0sNTCSYpmNkYS0tJaRcaHUdhW5EQBERAec7S44aTaCqg5Pmy5dc9vxQepVXrlP6KP4n3L5tl+Fld2s+o1US8tqILlZcWe40ekpS08JNfBfYvvXKf0QfxPuT1yn9EH8T7lQoqcImzzOju+5feuU/og/ifcnrlP6IP4n3KhRMIjmdHd9zZXNOIVklVfJvLc3jawtx8S0ch+M+ipMfeBZLK7XUXRk4rFdiInIfjPopyH4z6KlomTJ5SRE5D8Z9FOQ/GfRUtEyY5SRFDtwN3xt0pv/AIPnWM/tzlgp7S1JNXNu/wDg+dN/8HzrUimxOKNu/wDg+dN/8HzrUiWGKNvJ997Jmy36LJyL4z6K3we0tWxY5Mqc5J2InIvjPopyL4z6KlooyZHKSInIvjPopyL4z6KlomTGcjvY8V2bqMCoqHEZw8Qxs5uV4s4Nt0DtWn+4vg/zVwzuK+Ldeub70U/0OStlRV8aklwZ3X9xf+b1P7i/83q4VFHPPyR+hPRn+2f1O6/uL/zep/cX/m9XCop55+SP0D2Z/tn9Tv8AGYcMwjA4avD6YZJpGlpzu1BaTfXsC5ru8f0f6f3K/wBo/wACMK/9X8sriFhrqceU6lbqRTs2lGpSbn1u77WXPd4/o30/uTu8f0b6f3KmRaWCOhzWluLnu8f0b6f3J3eP6N9P7lTImERzWluLyOU4gDLl3duba9/+cVlyb4fmWjCfczvln0BWCql1OxqTeMnGJH5L8PzJyX4fmUhFFzHORH5L8PzJyX4fmUhEuM5H2nm5Kwstmub8bLd3QP5vzqI/vlipuYunF9bJvdD4r6Sd0PivpKEiEclHcTe6HxX0k7ofFfSUJEHJR3Ha7NTb6gkdly2lItfwBXSoNkve6X54+gK/XrNH4EeB5nVK1aSR9XH+qBGJaHCGtw1uJ1BxOPk9HIWiKVwZJcPLtAMmcg684N0K7BVWO4DSbQ0LKSsfVRsjlbMx9NUPhe17e9OZpHC99emx6AtooKTZihoaXGJnx7FSYDVuhIfNG2HcyDM3QGJxueB1aDoV2CpcJwSswqqc5+P4jX0pYWtgrBE7K645we1jXcARYk8VdIAeC8vxNv8A3Ws+ff8AWK9QXmeJD/ulZ88/6xXI2v3I8Tr7IdqkuBByq32cq4sPr5J5mTuYIiCIKeSZ3fN/FY0nzKsyq+2RFsXf8y76zVy9D48Tqa9/28jtWPEkbXjNZwuMzS0+Q8FmiL1Z5QIiIAiIgCIiAIiIAiIgCIuQ2qx7H8GxOAUdPhseFSRgPrq10gZHLmPNfkByttls46XuCRpcDr0XHbD4ltNikdXNjL8NkpmVVVCx9OXZ8zJ3MAtYAsAaQDxNm31uulxGTEI6QuwympqipzC0dRO6Fluk5msefMgPL9svwrru1n1GqiVntFJXS7QVbsRp6enqbtzR08zpWAZG2s4tafoqTVHf4S4ujqGk7vcxubZos05izrFtSbDovdecqwyqz4s91pq3J6ekrdqX2KPoRXEEjpKKjpaqok3VTOCQ5+jY280Wvw1J/dC1V9LTscwNY+ldlJImjc0P10yi7j5TZVul1XRdHVLLGSKxF0b5JYZGSiN8sTJ4XUjB+M0NJIb5r26bdKqcUY9s8TpHzl74w5zJ3Zns1IsT4r8BxSdLFXuKWpzni0aGd4FksWd4FaQTTswiWMSSOE7xDHHmJGnOdYdd8vlKqjFSMqs3DsK1Fa0om7lVDZWzNhLLte8ndDnDQC3fcdb9ei+4jR0sTmsja+EZyBNIxwY9vQbguv2gAaqzkXjdFHOkp4tFSiuiHjD7C7qXcNyW70y5xe3wuPhstGMGSVzKiUVEb5Hv9hndmLBobjQWBvbh0JKlaN7iGpymo23lBN7c5YLOb25ys6uGslwWgfJFM5rTIGuLTYNs0i3gsCfEVEI5Jm9Krhin8f2KlFfU8TpsPhgrt/HEZ4gHzO5pabj2O4FtCL8Rw4KJiFLTsewMY+kcGEkTxuaH66ZRdx8psrHRaVyqGsi54Ndf1KxF0VSyN7C2rkMdFvYuTuIJGTIb5bA+C9um11Bx0tdUU72yxSZoG+1hwA8AuBokqWKvcUtVnNRxI8HtLVsWuD2lqvt1vcIjbCZwzdZnFp5jn5+9I6XcLa9WiphDO5XXq8m182UqK5gcH4S4SiaOFsJbq32Nz82jgel3Ra3RxssMRo6WJwZG18LQ8gTSMcGPb0G4Lr9oAGqzdB43TKY6tZYtFSiuiHjD7C7qXcMyW70y5xe3wuPhstGMGSVzKiUVEb5Hv9hndcsGhuNBYG9uHQolStG9xDU5TUbbyqdxXxfXcVeMD3YIIgyQtMGjgbxl284W/L6L38XSsacM7l1atyVurtZRIrmMP7mtBzCk5O7P+TvM5+l3vht4FjiVFSROayJj4AHkCaRjgx7eg3BdftAA1Vjou10ytauOWLW/0KhFdkPGH6XdS8nbkt3u9zi9vhd94bLRjBkmcyplFRG6R7/YZ3ZiwaG40Fgb24dCOlZXuRHU5SxtvOl2j/AjCh81/LK4hdttH+BGF/8Aq/llc3BPOzCJWCSRwneIY48xI05zrDrvl8pWxrIqVT9EaOzZuFBteZlaitaUTdyqhsrZmwll2veTuhzhoBbvuOt+vRfcRo6WJzWRtfCM5AmkY4Me3oNwXX7QANVrci8bo3udJTxaKlFdEPGH2F3Uu4bkt3plzi9vhcfDZaMYMkrmVEoqI3yPf7DO7MWDQ3GgsDe3DoSVK0b3ENTlNRtvNmE+5nfLPoCsFAwn3M75Z9AV3NHO+gpnOZIQMwBINgLC39VqYZXe409RPGoQ0VjEwyU0bKjeMYZGAOkOlte9vw0Wmqhia4Wa6E2NxI0jN2alZSoPHI14103i0REVq572Oa/I57GyMMDR0ixvl81/CoVY1wewuMhc5tyJDdzdTofT40nRxV7iFbKVrEN/fLFZP75TJ4534fSucyQgFwBINgLC3oKwhDJP5F0p42+ZBRWEbnOpqeGaV2SaUXu7vWDQW6tSfItdVBE1zcrXQGxJEjCM3ZqVY6P4bpmCrdeLRDRW7nvY5rwxz2NkjMDR0ixvl81/CoNa1zZGFzpC5zLlshu5up0Pp8aTo4q9yIVspWsdPsl73S/PH0BdB0rjMHnxyKhIwnD6CqYZDnNVWvgINm8A2J9/MrnaLF6nBdnZa6OjfPVgNY2KGN8oa9xAuQ1uYsbe5sL2HBem0XgR4HntX40uJdIvNfU4qqJu1O01JTzV08shgnfPVUc0Jlduxnc7O0ZSXO0bppwFgvSltGuEREB8PArzfER/3Or+ef6SvSDwXneID/uVV88/0lcfa/cjxOrsrxHwIWVWuAurY62R1DBBPPujZk87om2zD8YMd6FXZVebKi2Kv+ZPpC5eh94jxOlrn7CR17M5Y3eANfbUNNwD26LNEXrDzAREQBERAEREAREQBERAFg9jZGFj2hzXCxBFwQs0QETDsNosJomUeH0sNLTNLnNihYGtBJubAeElS0RAeR7ZfhXXdrPqNVEr3bL8K67tZ9Rqol5jUeLLiz6BofdqfBfYIiKo2giIgNzO8CyWLO8CyWJW+0IiIQEREBDm9ucsFsm9uctazRsx7EEREMgiIgJkHtLVsWuD2lq2KtmrLtYREQgIiIDF3HxL4vruPiXxSSEREJCIiIhnc7R/gRhf/q/llcQu32j/AAIwv/1fyyuIW5rvEXBHK2T4MuLCIi0zqBERAXGE+5nfLPoCnqBhPuZ3yz6Ap6159pzKvfYREWJWEREBrf3yxWT++WKkyCIikkIiIDsNkve6X54+gLoOlc/sl73S/PH0BdB0r1mj8CPA8tq/GlxIdNhtJS11ZWwxZamsLDO/MTnLW5W6E2GnUpiIto1wiIgPnQvPq8f9xqvnnekr0HoXBVzf+4VPzrvSVx9sdyPE6ezHao+BDsrrZcWxN/zR9IVTlW6nqKqkEstHMIZgy2Y0EtZpcf8AjiIce2+i5Wh94jxOhrHehI9ARQcLFeKFhxGpp6iocb54KZ0DcvQMjnOIPjXLYRhdFhHqoYwygpmxCbCKeaQN/HkM093Enp0HkXrTzh26LyTCKSCn2d2O2mgv3cxHEIBWVWY56jel29Y/ra3Wzfxcgtay9GOAUZreV77Et5vN5lGJVGS9795ny2+Da3RZAfMKxruvLUCLD6uGCGaWEVEpjySOjkdG7KA8u4tPFo0Vsuaw3Aqim2nkxIUOHYfE5krZBRSOc6re97XCSQZGgEWd+UeedevpUAREQBERAEREAREQBERAef7RbOGux6pqeVZM+Xm7u9rNA6/Aqv1pH9NH8L712OJ++Evi9AUVeU1Eny0uLPRUNZXjSjFS7EtxzHrRP6aP4X3p60T+mj+F966dFTky3n2o83ojmPWif00fwvvT1on9NH8L7106Jkxz7Ueb0RwVZSchqn0xfnyW51rXuL/1WhWGOe/U/wCz9UKvWZ2qMnKmm/igiIhYEREBZUmzRxCmbVcqyZ783d3tY26/At/rNP6cP4X3q4wL3ng/a+sVZLBzZxqmu1EZuKl1J7kcr6zj+nj+F96es4/p4/hfeuqRM5GHSGo83ojlfWcf08fwvvT1nH9OH8L711SJmx0hqfN6I4SpoOQTvpjJnyW51rXuL/1WvJ4VYY177T/s/VCgqTrUpylTUn2sxyeFMnhWSIWXMcnhTJ4VkiC5up8P5Swu3uWxtbLdbu43x/0PvUjDfaHfK/oFNVbm0zTnXqKTSZVdxvj/AKH3p3G+P+h96tUWOcjDnFTeVXcb4/6H3p3G+P8AoferVEzkOcVN5fPrtn5MIpKDEpQ8RMZzbPGoFujxqLk2J6h/mrl8R90D5P8AUqIulz+UkrwT/Q16WzVjeNSSvuZ2eTYnqH+amTYnqH+auMROe/kj9Czo7/bL6nZ5Nieof5qZNieof5q4xFPPfyR+hHR3+2X1O1xujwzDcFhqsPgAbK9pacztQQT09gXNd0j+a+kuk2g/A3Df/X9QrjVhroR5TqVupFezY50m5u7u+0n90vivpJ3S+K+koCLSxR0eRhuJ/dL4r6Sd0vivpKAiYocjDcXFM7lcZfbJY2txW7k3wvMtGFe53fLPoCnquXUzQqNxk0iPyb4XmTk3wvMpCKLmObI/JvheZOTfC8ykIlxkzpNl2bvD5Re/sp9AV70ql2b9wS/On0BXK9bovd48Dzep8aR9REW2UBERADwXCVw/t9T8670ld2uIrW/26o+cd6VxtsdyPE6GznabImVb6aaCm3klRjHcmMMsarPE22o0vI1zdexY5fApuGOrI6h7qCngnnyaMnmdE21x+MGO9C5eh94jxOhq37GR1cLgYIy2XetLQRJcc8demmvgVHDsXgkGNnGY460V5dcyOxGocDqXBpaZMpbdx5tra8FfMzljd4A19tQ03APbos1608+UdLsjgVFioxKnoAypD3yM9leWRvf3zmRk5WuNzctAOpV4iIAiIgCIiAIiIAiIgCIubxvao4TU4lTsoXTy0lLSzRNEmXfSTyyRMZw5vOYNde+4aagdIi5rCMYxkY6cHx6joYqiSmdVU8tFM57Hta5rXtIc0EEF7NeBzdFlc4jJiEdIXYZTU1RU5haOondCy3SczWPPmQFTiXvhL4vQFER0lfLK92JU1PT1N9Y6ed0zLWFuc5jT5lIkbIKdocHG9iNNGi3/ADyLyteGVWfFnWhK0IkdFIYSY42Pecr3DieAGn2+RfJmNBFgYzbg4EX7OKrdLqumZKp12ZoRTRbMM/teZuS/C1ujzKPODdpcXXI4PNyNVM6OMb3Eal3Y4bHPfmo/Z+qFXqwxz35qP2fqhZQTTswiVgkkcJ3iGOPMSNOc6w675fKVMI5Ho4TcKMLfIrUVkyOpkwF+ZspgZOwg5SWtFnXPlWzEaOlic1kbXwjOQJpGODHt6DcF1+0ADVWci7XJ51FSwaKlFdEPGH2F3Uu4bkt3plzi9vhcfDZaMYMkrmVEoqI3yPf7DO7MWDQ3GgsDe3DoSVLGN7kQ1OU1G28v8C954O131irFVuBe88H7X1iroNk5KSQ5zXaNFrga8f6LXjDJs4eplapLiR0W5j3NpnAuNnHKBfTrP9PKs54o2mzQWi+jnA2I891lyV43TKOU67MjIpY9qGb2rKOy99fHxWNWNbkvHOIAcdLdY8CmVG0b3CqXdjh8Z99p/wBn6oUFT8Z99p/2fqhbrTVGEMjLKiNsTLMOY7uUl50Atx53h4JCGR6CNTk6UPnYqk8Cu4we4wYQ8RmEkyXvGDn4EfleG/Vp0rTiFHSxODI2vhAeQJpGODHt6DcF1+0ADVWOg7XTIjq05Ytb/QqkVyQ8UFhd1LuG5bd6ZM4vb4XHw2WnFzJK5lRKJ43SOf7DM65aNDcaDTW3DoUSpWje5MNTlPG28Yb7Q75X9ApyhYb7nd8r+gVzNHO+gpnOZIQMwBINgLC39VrYZXe41q8sahDRWMTDJTRsqN4xhkYA6Q6W172/DRaaqGJrhZroTY3EjSM3ZqVlKg8cjXjXTeLRERWrnvY5r8jnsbIwwNHSLG+XzX8KhVjXB7C4yFzm3IkN3N1Oh9PjSdHFXuIVspWsUeI+6B8n+pURS8R90D5P9SpNpqjCGRllQxsTLMOY7uUl50Atx53h4LKlDJHS5TCEfmyrRXAjD8Jja100cYiLpHA2YXZzo4dJtbp6tFhiFJSxuayJr4QHkCaRjgx7eg3BdftAA1VroO1zFaqLli1v9CqRXBzigsLuptw3LbvTJnF7fC4+Gy04sZJSyolE8b5HP9hmdctGhuNBpr1dCOjZXuI6nKWNt50W0B/ubho+b+oVxq7LaD8DcN/9X1CqECaowlkZZUMbEyzecd3KS86AW487w8FtayGVT9EaGz6mFHjJlWisWR1EmCPzNkMLJmkHKbNFnXPlss6+kpoyGRtfCA8gSyMIa9vQbguv2gAarU5F43N/nMcsWirRXBDxQ2F3U24bkt3pkzi9vhcfDZacWMkrmVEonjdI5/sUzrlo0NxoNNeroUyo4xvciGoymo2NuFe5n/LPoCnqvwr3O75Z9AVyx8gontzOO8cGNbc26zYeTyrVUVKTNPUStN23kboToUyIScjkDxII7c1zjzeI4DrX2qp4WOysDmAOID3NOVw8pv4llyDxyRRyyvi0Qk4BWA9zjNfk+7HZmzC/j4+JYV7TcEmQDO4Na46W01HgUyoWjlciNa8rWLrZv3DL84fQFdLksPnxyKlIwnD6CqYXnOaqtfAQbDgGxPv5lY7T4NPtHslW4Tnigmq4gwudd7Gm4J6rjyL02i93jwOJqfGkXiLitk4I8C2ir8AdhOD0lQaWOsFRhVNuGTMLnNs9lyQ4EG3ONw7oXarbKAiIgHQuNrB/bZ/nHeldkuRqx/bJ/nHelcja/cjxN7Qu02RLKZh1LLVTPihraijfkvvoGxl3Eac9rh5lot4FKoKGKulfBM6djCy94KiSF3EfjMcD51ytF48eJu6l+yZ07GlrGtc9zyAAXOtc+HRZrBjBHG1gzWaLDM4uPlPFZr1hxAiIgCIiAIiIAiIgCIiAKlxLZTA8ZxKLEcQw2Gesha1sczr5mhri5vA9BJPjV0iAiHD6V2KNxIxk1bITA1+Y6MLg4i3DUtbr4ApaIgOdxP3xl8XoCiKXifvjL4vQFEXktT40+LOxS8NcAiIqSwIiIDi8c9+aj9n6oVerDHPfmo/Z+qFXqxdh6Sh4UeCCIiktCIiA7LAveeD9r6xViq7AveeD9r6xViqn2nm6/iS4sIiIVBERAcjjXvtP+z9UKAp+Ne+0/wCz9UKAs0ehoeFHggiIhaEREBaYb7nd8v8AoFNULDfc7vl/0CmqmXac+r32ERFiVhERAVeI+6R8n+pURS8R90j5P9Soiuj2G/S7iCIiksCIilBnabQfgbhv/q+oVxq7LaD8DcM/9X1CuNW5rvEXBHL2X4L4sIiLSOmEREBb4V7md8s+gKeoGFe5nfLPoCnqmXacyr32ERFiVhERAdPs37hl+cPoCsMQoKfFKKSjq2vdDJbMGSOYdCCLOaQRqBwKr9m/cMvzh9AV0vXaL3ePA87qfGlxKrCNn8MwN076Cnc2WcjezSzPmkfbhme9znEDWwv0q1RFtlAREQHzoXLVTf7XMfhu9K6noXNVLf7VN8s+lcnavcibmjdpMi5VJo46x8jxQTwQT5dHzwOlba4/FD2+la8qn4QLVbvkH0hczRL28Ta1D9my5ZnDG7whz7alosCezVZoi9SckIiIAiIgCIiAIiIAiIgCIiAIiIDjsaxHcYvPHus2XLrm+CFA7r/EfS+5fdovf6p7W/VCq15DUv20+LPT6ahB0otr4Is+65/MfS+5O65/MfS+5ViKi5dzenuLPuufzH0vuTuufzH0vuVYim45vT3Eavh5ZXST3yZ7aWvbQBR+5/xn0VOdxXxTkzbjOUYpIhdz/jfop3P+N+ipqJkzLlZbyF3P+N+inc/436KmomTHKy3kugruRUTKfd58t+dmte5upPdn4j6f3KrRQ2asqEJNtotO7PxH0/uTuz8R9P7lVohHN6e4tO7PxH0/uTuz8R9P7lVog5vT3GNZEayqfUXyZ7c3jbSy08h+M8ylt71fVOTL4zlFYoh8g+M8ycg+M8ymIoyZPKy3kPkHxnmTkPxnmUxEyY5WW8+Uke4jLb5rm91Iz+Bam8FksWVPrd2Z5/AmfwLBEMbGefwJn8CwRBY0z0nKZA/PlsLWtdau5h/O/R+9TmcFkpyZkqso9SZX9zPjfo/encz436P3qwRMmTy095X9zPjfo/encz436P3qwRMmOWnvOnjfhFZg9NSVbxI2JrRazhZwbboWruZsv+aHleqel9rPat66D2hJ9sIv9Dkc3cG1GbX6lj3M2X/MjyvTuZsv+ZHleq5FHP8A8kfoOSn/AJJfUse5my/5keV6dzNl/wAyPK9VyJz78kfoOSn/AJJfUnYth+H4dhkctFAGh7xYhx1BB6+xUXKPg+ddFj/4PUnaz6pXLLDaEUqqsrdSLtDedNuTu7s38o+D505R8HzrQi0TdwRv5R8Hzpyj4PnWhEGCOy2XfvMPlNreyn0BXvSuf2T97pfnj6Ar/pXrtF7vHgeY1XjS4n1ERbRrhERAfCueqB/aZfln0roVQVA/tEvyz6VytqdyJs6XvM0ZVtgoYq8ugmfO1hbe8FRJC7iPxmOB86xspuGD+0u+R/ULm6Ne3ibNZ/gZaMYI42sGazRYZnFx8p4rNEXpzmhERAEREAREQBERAEREARFy20G1cmDVVfTR0rJJYKOCeHPJlEj5ZnRAHTRrSGlx6A5AdSi5nCMWxqPaHuLjjcPfNLSuq4ZaHO0BrXta5rmuJPF7bG+vO0FldYjWT0VIZqfD6mvkDgNxTujDz4fZHNb50Bxm0Xv9U/s/VCq1KxKqmrMSnmnoKiheSAYKhzC8c0a8xzm+dbZ46ltAxsrZXl5D23BIY0A6DtGviXk68Mq0+LPUUZ40aa+S+xARWIikmpqHlAeIjIW5iNA05ba+VaquCJrmhrXQGxuJGObm7NXKuVFpXLFXTdmQ0Vw9743teGOexssZgaOkWN8vmv4VArWuEjC90mZzLlspu5upFj5L+NTOjir3IhXylaxDdxXxfXd8p9RHUtw9jZWyvLyHtuCQxoB0HaNfEsIQyTL5zxaW8r0VjE5z6Wmgnmfu5pRe7tGtGg48NSfItdXBE1zcrXQGxuJGObm7NXfYs3R6rplar/ixaISK5e+SN7XhjnxtljdTtHSADfL5r+FQK5rmysL3S53MuWyuu5upFj5L+NJ0cVe4hXylaxFRFYsjqRhhLmyvjks2NgBLRzu+8GunjKwhDK5ZUnhYrkVoGB2GsDXSsYIyXuB5hdmOhHSbW8ywraanjIaxrogHECV7TlcOu4Jv4gFY6DtcqWoV8WiuRWlnCj0uafcty9RkzC9vDx8S1YkXyFk0gmY57nexSuuWjTUcNNfMolRtG9xCvlK1iG3gvq+DgrBkdSMNJc2V8clmxtAJaOd33g6vGVXCGVzOpPCxARTmsmfhLszX7psrSDlNho65WVZTQRkNY10QDiBI9pyuHXcE38QCz5F45FfLpSxaK9FZ84UelzBum5eovzC9vDx8S1YiXvLJpBMxz3O9ildctGnDhpr5lMqNo3uRGvlK1iGzgslizgp88c7sPpXOZIQMwBINgLC3i0KqjDJP5Gc54tfMhIrZ0UcrIWl8jKf2MXJ5jrjW3h469qi1UMTXNs10BsSRIwjN2alWSoNK9yqOoTdmiGit3PfG9rwxz2NkjMDR0ixvl81/CoNa1wkYXulzObctkN3N1Oh9PjSdHFXuIVspWsaW8FksWcFOmjnfQUznMkIGYA2NrWFv6quMMk/kZzni0Q0ViIpDBAyp3mSR7SCeDG+A+H+i01UMTXNs10JsSRI0jN2alZyotK5VGum7ERFaue9jw/I57GyMMDR0ixvl81/CoVY1wkYXmTM5tyJDdzdTofT41M6OKvcQrZStYype8Pat60UvtZ7VZsDDQyNY9pcQCRY3Jvw4LCnDO5VVliyGim5Q6jbYva3IS4g829+B8PBY1EMTCA0FmpAe5pykeU38SsdB2vcrVZXtYiIp1vYBmvuMg7M2YX8fFYVrTcEl4GYhrXHS3WPAjo2je5Cq3drEjHvwfpO1n1SuWXU49+D9J2s+qVRzxzuw+lc5khAzAEg2AsLeLQrZ10MqnBIy0M8afFshIrZ0UcrIWl8jKf2MXJ5jrjW3h469qi1UMTXNs10BsSRIwjN2alasqDSvc2o6hN2aIaK3c98b2vDHPY2SMwNHSLG+XzX8Kg1rXCRhe6XM5ty2Q3c3U6H0+NJ0cVe4hWylax0+yfvdL88fQFf9K4zCMUrMPoi2mwLEMSDpCS+lfAAzQaHeSMPkW71QsSrcO9T3EqyhbJFVFkTAM4a5gfIxrucL5SGudzhw4r02i93jwPPavx5cTrUXC7KUY2f2nmwSXDMJgnnohVtqMOidHmDX5S2TMSXOu4WdfXXQLultGuEREAVFOP7RJ8s+lXqpJh7PJ8o+lczafdibGn7WabKXh9m1BJNuafSFHsq7G4KCfC5GYlNhEVOXNJdi0DZYL30u0vbr1arnaRe2iX1X+BnXAgjQ3VHhe0sOJY5WYR3Pr6WopomzXqY2tbIxznNDm2cTxY7iAp2E4fQYZh0UGG01JT05GcNpImxxuJ4uDRpquSpsVEnqn1svc7GGwTYfDQsqHYZO2PeslmLueWWDbPac3DXivSGgWtFtvh1dXU0LKWujpKuZ0FJXyRNFPUSNvzWnNm1yusXNAdbQlWRx+jFbyTc4lvN5u8ww2oyXvbv8mW3wr26brhMLpcRlwTZbZZ2FVsNXhFZC+rqJIHNgEcBJztk71+ezbBtzzje1l6ggOP2cx6oxLFnPrJa+NlS+pZSwviiFO4RSZeaQN5mAGuYgG7rDRdgqymwLDqTEX18MDm1Di83Mr3NaXm7y1hOVhcdTlAv0qzQBERAEREAREQBU+PbMYNtLTthxegZUtYHBpzOY9od3wDmkOAPSL6q4RAU2BbK4Js02QYTQNpzIAHvL3SPcBwBc4l1hfhdXKIgOA2i9/qrtb9UKrVptF7/VP7P1QqteQ1PjT4s9ZpvBhwQREVBeEREBg7ivi+u4r4pMwiIgCIiAIiIQEREAREQGbeC+r43gvqgxfaEREAREQGTOCyWLOCyUGL7QiIgCIiAzZwWSxZwWSGL7QiIhAREQEql9rPat60UvtZ7VvUmtLtCIiGIRERAs8e/B+k7WfVK5ZdTj34P0naz6pXLLe2h4i4IjZ3hPiwiItA3wiIgOw2T97pfnj6ArirpKeupJqSqhZNTzMLJI3i7XNOhBCptk/e6X50+gLoOlet0XgR4HltX40uJUYRs3hWBySyUFM9ssrWsfLLNJM8tb3rcz3EhoudOCt0RbRrhERAfCqiYezP8AlFW5VVKPZn/KK520e6i6h2s1WX0OrI2udQQQTz27yed0TbX/ACgx3oX2yj1zsOZSOOK1vI6XS8vLHUut9Bna5p8V1z9KvaxL6j/Cy+ZnLG7wAPtqGm4B7dFmtUJYYIzE7PHlGV2bNcdBv09q2r0JpBERAEREAREQBERAEREAREQBERAcpi2AVdbik1RE+EMfa2ZxvoAOpQvWtX8d5B+8fsXZv75Yrh1tLTlUk3vN+GurRiop9hx3rWr/AM5B+8fsT1rV/wCcg/eP2LskVXNKRl0jX3nG+tav/OQfvH7E9a1f+cg/eP2LskTmlIdI1955tW0slFVvp5C0vZa+XhqLqPZWm0Pv7U/s/VCrFzqixk0j0FCbnTjJ/FIWSyIsC0WSyIgJ9Lg9TV07Zo3RBrr2Dib8bdS3et6s/Lh8p+xW+C+9UP7X1irBbEacWjj1NZVjNpM5j1vVn5cPlP2J63qz8uHyn7F06KeSiYc9q7zmPW9Wflw+U/YnrerPy4fKfsXTonJRHPau84qenfSzOhkILm8S3h1rWp2Me+s/i9AUFa0upnVpScoJsIiKCwIiICXS0clTGXMLQAbalbu5c/5UflP2KRhHuV/yz6ArFZYo59SvNTaRT9yp/wAqPyn7E7lT/lR+U/YrhFOKMOcTKfuVP+VH5T9idyp/yo/KfsVwiYoc4mUEsLqZ4Y+xJF9FhmUrE/dQ+R/UqGsH2m3TblFNmWZMyxRQZ2MsyZliiCxNpTeM/KUiyj0ftR7VIUmrPvMWSyIhiLJZEQF7PHQVuGwQVNUxmUNdpIAb2t0qF3FwX9Yf5rfsVHU+2jsWldCWuhLvU0yqnpJxX4ZtHRdxcE/WB/it+xO4uCfrA/xW/YudRY87pf4kZ82q/wCRnRdxcE/WB/it+xO4uCfrA/xW/YudROd0v8SHNav+RndYTSUtJTOZSTb1heSXZg7Ww6lPVHst73S/On0BXi9BppKVKLSscOvFxqSTdz6iItgqCIiAFVko9lf8oqzVdIPZHdpXP1/dRbR7TXZYurIsPYZ5mVDmDS0EEkzv3WNJ8y2WW6lFpfEtLTL2sS2b/CyUx4kja8ZrOFxmaWnyHgs0Rd01QiIgCIiAIiIAiIgCIiAIi5TFdpMYotqJ8PoMD7pUtPRQ1M26qGsnbvHyt5rXWa72rhmB16UB1aKjwbarC8cqX0cD5oMQiZvJaGrhdDMxtwL5XDUXI1FxqNVYYjWT0VIZqfD6mvkDgNxTujDz4fZHNb50Bvf3y+KLQ1c1bTCaow+poJCSNzUOjLx4fY3Ob51L6FzJq8mZnxF96EIWLgD4i+r4VLhZA4LaH39qf2fqhVis9off2p/Z+qFhPHUtoI2ytleXkPbcEhjQDoO0a+JcWcMpyPT0Z40qfBfYr0VqWcpjp+Ub6GMOjZZ7ua4Wtdo6OHnUergia5oa10BsbiRjm5uzV32JKg0rp9RnHUJvFrrISK5c98b2vDHPY2WN1O0dIAN8vmv4VX1zHCRhe6XO5ly2V13N1IsfJfxqJ0cVe4p18pWsdHgvvTD+19YqwVfgnvVD+19Yq2eLs0vYWt1HRbFOF43OLXdqsuLNKLblLmR5r5b2v4NF8e0XGhb2jis3TaVypSNaLc8kNJ1AuMv3LCU3da98otqkoKKClc5HGPfWfxegKCpuMX7qzeL0BZsjqRhpLmyvZJZsbQCQOd33g6vGVpKGUmd2E8KUP0K9FZsDjQi5Ip9ycx6M+Y28fDxLGtpqeMhrGuiAcQJHtOVw7QTfxALJ0Ha6YWoWWLRXIrOzuSaXMG5bl6i/ML28PHxLViJe8smkEzHPc72OV1y0aajhpr5klRtG9xGvlK1iXhHuZ/yz6ArFV2Ee5n/LPoCuA2TkxJDi12jRbhrxSnDI0NRK03xNCLcGvNKbh2UOHRw4rKaONpsAW698QbEedZck8blPKK9iOilf+IZvasg7L39PFY1I1uS4DMQA49HWPAspUbRvchVLuxz+J+6h8n+pUNTcT91D5H9Sk8c7sPpnOZIQMwBIOgsLf1WuoZX+R04TxjH5kJFaNjp30sUe/Zu98zNYEG5BvxH/ACyj1UMTXNs10BsSRIwjN2alZyoNRvcRrpvFohorZz3sc1+Rz2NkjMDR0ixvl81/CoNa1wkYXukzObctkN3N1Oh9PjSdHFXuIVspWsbaP2o9qkKPR+1H5StGBhoZGse0uIBIsbk34cFhThncprSxkQ0UyMR8hkAkbcgFwsb3v2f8uvlTDE0hrQWWJAe4HKR5TfxKx0HjdMq5VXtYiIpv/hGa+4yDszZhfx8VjWg5rkvAzENa46W6x4ElRtG9wqt3YqKr20di0rdU+2jsW6aOd9BTOcyQgZgDY8LC39VVGGSfyNxTxSIaKxEUhggZU7zJI9pBPBjfAfD/AEWmqhia5tmuhNiSJGkZuzUqyVFpXMY103YiIrVz3seH5HPY2RhgaOkWN8vmv4VCrGuEjC8yZnNuRIbubqdD6fGk6OKvcQrZStY6TZb3vl+dPoCvlQ7Le98vzp9AV8vTaL3ePA8/qvGlxCIi2igIiIB0KC8c93aVO6FCeOe7tWjre6iyn2mFlhLh9FiUZp66kgqoDzjHPG17SeuxW2y1zVkVBEZ5mVDmDS0EEkzv3WNJ8y1NOvaIzk+onxsZHG1jGhrGiwa0WAHUs1gx4kja8ZrOFxmaWnyHgs12SgIiIAiIgCIiAIiIAiIgCjMoadmIy4g2O1VNEyF8lzzmMLnNFuGhkf5VJRAY5QXB1hmAIB6VkiIDU/vivi+v75fFy6nfZmuwIiLAkIiIDgtoff2p/Z+qFWKz2h9/an9n6oVYuLV8R8T1Wm8GPBBERVl4REQHWYL71Q/tfWKsFAwX3qh/a+sVPW3Huo89W8SXFhERZFYREQHKYx76z+L0BQVOxj31n8XoCgrTn3md6h4ceCCIixLQiIgLnCPcz/ln0BWKrsI9zP8Aln0BWKsXYcqt32EREKwiIgKjE/dTfkf1KhKbifupvyP6lQlW+06NHuIIiKC0IiICbR+1HtUhR6P2o9qkKTUn3mEREMQiIgIdV7aPkrSt1V7aPkrSoZsw7qCIiGQREQHWbLe98vzp9AV8qHZb3vl+dPoCvV63Re7x4HmNV40uJ9REW0UBERAFFcOce1SuhR3DnHtWnq+6jOBhZZxDn+JLLKMc7xLWoL8aMm+o3IiLqlQREQBFXU+OYRWVz6CmxWhmrGZs1PHUMdI3KbOu0G+h4qxQBERAEREARQ6HE6DFInzYdXU1ZFG8xvfTytkDXji0lp0Oo08KgbTxSSYYy2O9xYGSh1RVAsad3Y80Ofo3nZdeoEdKAu0XM7H1bZ6Wq3m1dHtDUulzulpTGGxNytaGhrXOtwufC4rpkAREQGtzCTe6ZCtiKh0IN3Jua8h61DpK6Ctqa6nhcTJRTiCa4tZ5jZJp1817VYKHR4dT0VTXVEIcJK2cTzXN7vEbI9OrmxtTm8BckZD1pkPWtiKObwF2cniuzlbXYnNURPhDH2tmcb6ADq8Ch+tLED/5Kf8Aed9i7dFRLZtCTu0bkNoV4RUU+w4n1o4h+cp/3nfYolJgVRW1NdBDLAZKKcQTXLhZxjZJpprzXtXoSh0mHU9FU11RCHCStnE81ze7xGyPTq5sbVHRlDczLpPUbzlPWjiH5yn/AHnfYvnrRxD85T/vO+xdwidGUNzHSeo3lHh2FVFLQxwvdGXNvctJtxJ6lL5DL1s8qsEWa0FFGtKvOTbZX8hl62eVRKSRlbU10ELwZKKcQTXBFnGNkmnXzZGq8UOjw6noqmuqIQ4SVs4nmub3eI2R6dXNY1OY0SOVkauRSdbPKnIZetnlViicxojlpHJV+zdbU1sk0b4crrWDnG/ADqUb1p4h+cp/3j9i7VFg9mUH12NiO0K8UkmcV608Q/OU/wC8fsUSkwSoramughlhMlFOIJrlws4xsk0015r2r0BRKTDqeiqa6ohDhJWziea5vd4jZHp1c1jVHRlD5mXSWo3nK+tPEPzlP+8fsT1p4h+cp/3j9i7ZE6Mobh0lqN5zVBgNXTQuZI+Ikuvo4/YpXcmo/Kj8p+xXa+KejaBTLV1JO7ZS9yaj8qPyn7FFji3uLVGGte3lMEMc7xrbLI57W62643LpVDjw6nixaoxJodymeCOB5vpljc9zbDtkcnRtAx5zUIHcmo/Kj8p+xO5NR+VH5T9iu0To2gOc1Dlq3Z2sqJg9j4bBttSfsUb1rV/5yD94/YuxRR0ZQ+ZbHX14qyZx3rWr/wA5B+8fsUSPB55cVqMNbLDymCGOd4u62WRz2t1t1xuXeKJHh1PFi1RiTQ7lM8EcDyTpkjc9zbDtkcnRen3My6Rr7zmfWtX/AJyD94/YnrWr/wA5B+8fsXYonRen3MdI195y1Ps7WRMIc+G5N9HH7Fu7g1f5cX7x+xdGidGUPmYPW1W73Oc7g1f5cX7x+xRI6J8uLVGGtkj5TBBHO8a2yyOe1utuuNy69Q48Op4sWqMSaHcpngjgeb6ZY3Pc2w7ZHJ0ZQ+ZHPKu8p+4NX+XF+8fsTuDV/lxfvH7F0iJ0ZQ+Y55V3nJzbN1sjwQ+HhbVx+xa/WxXflwfvH7F2CJ0XQ+ZmtfXXVc4/1sV35cH7x+xRI8JmlxWow1ssXKYII53i5tlkc9rdbdcbl3SiR4dTxYtUYk0O5TPBHA8k6ZY3Pc2w7ZHJ0Xp/mOkK+85v1sV35cH7x+xPWxXflwfvH7F16J0Xp9w6Qr7yswWglw+lfFMWFznlwyE2tYfYrOyIt2nCNOKjHsRqTm5ycn8T6iIrDEIiIAtZYblbEVc6an2k3sa92VEr6megpTPBh9TXyAgbimdGHnw+yOa3zqeixjQhF3QuQ8OrJ62kE1Rh9TQSFxG4qHRl48PsbnN8657CqrFabbvE8Mr8VfW0jcPhrI2ugjj3RfLK0gZRcizG8SV1q5Sn2cx2LbGXHZMdonxyxMpn0ww1zTuWPe9oD9733sh51vEriCkw3HsfOH7PbSVWIiWjxmrjifh24YGQRzXEZY8DMXN5l7kg3OgXYmnx7lucYlh3JN5fdcgkz5L97n31r26cvi6FRUGxE1HJh1LLi5mwXDKjlFHRcnDXtcM2Rr5M3OazNoMo4C5Nl2SAoqWCaq2wrq+aF7IaSBlHTF7SMxdaSVzesH2Jt+thV6iIAiIgC5jb7G5sC2PrJ6S5xCoy0lE0HV08hyst2Xzfsrp1w+22z+0uM49gNZg/cl9Lhcrql0FfNI0STWysdZjD3tyRrxKAq9l8Ki9T7bin2eidagxjDmPid0Oq4Ghslh1uZZx8IX3A6KDb7bDG8YxmJtVh2EVr8Ow6ilGaJr4wN5KWnRziSLE8B4ljjuA+qJj02FTSx7L082G1rKuKWGpqM2lw5msfeuBsVYxbMbTbN41ilRsvU4VNh+J1LqyWkxHeMMMzu/cx7Abg24EIDpoNmcEpcWjxSmwqkp65kbohNDEGOym1wbceHSt2C4rBjmD02J0rZW09S3PGJQA4tvodCePHxqgr6rH8H2Lx7Esdq6OWrZTSPgioonNjjsw5QC45nEutqfIrrAYabDcKo8EinidPh1JDFJE14LmNy5WkjiAcpt12KAtUXkNZg9JieC1uMFru6WK7SNioqoOIfA1tQ2HPH+Sd3E43HEWvour2cw2jw/braGPDYBT0sVNSRyRsJIknO9e57ut2VzLnielAdmiIgMXEhpIFzbQLybCKSCn2d2O2mgv3cxHEIBWVWY56jel29Y/ra3Wzfxcgtay9bVHS7I4FRYqMSp6AMqQ98jPZXlkb3985kZOVrjc3LQDqUBeIiIAiIgMJI2yxvjeLtcCHC/QVxuxWHUmE7Q7X0VBTsgpo66DJGzgL0sRPlJJ8a7N7Q9rmm9iLaGyocJ2NwXBcSkr6GOsZUyayPlxColDzYNu5r3kONgBcjSyA6BERAEREBpqaaOrpZaacF0UrHRvAcRdpFjqNRp1LidmsOw87Xy12zVJHR4LT08lLPJAMsdbPnbYtbwdu8rgX9JcRrYrtKukhrqGejqGl0E8bopGteWktcLEXFiNDxGqq8H2TwnAHxnDhXRsjZu2RSYhUSxtb1Bj3lo8iAvEREAREQGuaJk8L4ZG5o5Glrm9YPFef4XhrcC9UekhZhFJg1NU0tQyBlBLnZWlrmOzSjK3K5rdRo7vnc7oPfVFPHVU0tNM0uilY5j23Iu0ix1HgVXhuy+EYTW8spqeV1VkMYmqamWd7Wni1rpHOLRoNB1IC6REQBERAYSPEcbnkEhoJs0XK8josdgxD1R9ncWrY8SirqrlMQp5cPqGCmjLWiOPVlibkue4aAnU5Q1evqHPhtJU4hSV8sWappA8QPzEZM4AdpexvYcUBMREQBERARcRpnVmGVdIxwa6aF8YJ4AuaQuE2Vwduxe0GGYPPhmCGasonsir8PpdxM7dZMwluTmzXBzA8RwXf1NPHV00tNO3NDMx0b25iLtIsdR4FWYXsvhGEVjqukp5TUuZut/UVEk7wy98odI5xa2/QEBcoiIAiIgKraSsqMO2WxetpBepp6KaWEWvd7WOI84XC7HQPwbEdnpqzDsMfNjdK4trIA81IcIxId7I4ne5gDzubY20XprmhzS1wBadCD0qlwrZLBMFqxVUFFu5WsMceaV7xC0m5bG1ziI2mw0aANEBeIiIAiIgC879a+AP9UzD4MLwXD6VuEQOrqqWnpmMc6WS7IWEgdQkfbwNXoihUuGUdFV1lXTw5aitkElRIXFxe4NDRxOgDWgWGiAmoiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAKLDh9LTVtVWRQhtRVFpmkuSXZRlb2ADoHWesqUiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAKqx7HqXZ3D2VlWyeRj54qdkcDM73PkcGtsOnjfr06VaqkxvCJ8VxDBHtdGKahreVztcTmdlje1gbpbvnNOv5KAqpPVApYm4g12CY1ynDhvKun3MZfFHlzCQnPlIIvoHZtDzdF1VPPHVU0VRC7NFKwPY7raRcLla7ZfEarC9r4o5qdtXjjyyF+Z2WOHcsiAdzeOjzpfVy6yKJkEMcUbQ1jGhrQOgBAbEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAf/2Q==",
       "text/plain": [
        "<Figure size 700x500 with 2 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 524,
-       "width": 563
+       "height": 522,
+       "width": 577
       }
      },
      "output_type": "display_data"
@@ -214,34 +252,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 196,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 1000/1000 [06:39<00:00,  2.50it/s]\n"
+      "Training: 100%|██████████| 10/10 [08:04<00:00, 48.41s/epoch]\n"
      ]
     }
    ],
    "source": [
     "config = CubeTrainingConfig(\n",
-    "    asteroid=asteroid, cube_side=100, n_epochs=1000, n_epochs_before_resampling=10, activation_function=\"linear\"\n",
+    "    asteroid=asteroid,\n",
+    "    train_set_path=train_set,\n",
+    "    val_set_path=val_set,\n",
     ")\n",
     "\n",
     "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
     "\n",
     "val_dataset = torch.load(VAL_DATASETS_DIR / f\"{asteroid}_1000_spherical_0_2.pt\").to(device)\n",
-    "val_config = ValidationConfig(val_dataset=val_dataset, val_every_n_epochs=50)\n",
     "\n",
     "# Train the cube\n",
-    "mascon_cube = training_loop(config, val_config, log_config=None, device=device, progressbar=True)"
+    "mascon_cube = training_loop(config, device=device, progressbar=True, use_wandb=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 197,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -258,20 +297,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 198,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 600x600 with 7 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 575,
-       "width": 592
+       "height": 576,
+       "width": 591
       }
      },
      "output_type": "display_data"
@@ -284,20 +323,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 213,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 700x500 with 2 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 524,
-       "width": 563
+       "height": 522,
+       "width": 577
       }
      },
      "output_type": "display_data"
@@ -317,7 +356,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 199,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -326,10 +365,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 200,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
+    "geodesynet.enableCUDA()\n",
     "torch.cuda.empty_cache()\n",
     "gc.collect()\n",
     "os.environ[\"TORCH_DEVICE\"] = \"cuda:0\"\n",
@@ -349,18 +389,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 201,
+   "execution_count": 36,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/pietrofanti/miniforge3/envs/masconcube/lib/python3.12/site-packages/torch/optim/lr_scheduler.py:60: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# EXPERIMENTAL SETUP ------------------------------------------------------------------------------------\n",
     "# Number of points to be used to evaluate numerically the triple integral\n",
@@ -395,7 +426,7 @@
     "# Here we set the optimizer\n",
     "learning_rate = 1e-6\n",
     "optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)\n",
-    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.8, patience=200, min_lr=1e-6, verbose=True)\n",
+    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.8, patience=200, min_lr=1e-6)\n",
     "\n",
     "# And init the best results\n",
     "best_loss = np.inf\n",
@@ -408,7 +439,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 202,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -422,7 +453,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 203,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -489,7 +520,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 204,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -502,7 +533,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 205,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -519,7 +550,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 206,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -530,7 +561,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 207,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -542,7 +573,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 208,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,14 +594,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 209,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor(0.9982, grad_fn=<SqueezeBackward0>)\n"
+      "tensor(0.9994, grad_fn=<SqueezeBackward0>)\n"
      ]
     },
     {
@@ -592,7 +623,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 210,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -612,7 +643,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 211,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -632,7 +663,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 212,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -648,27 +679,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 214,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Sampling points...: 2633it [01:15, 35.06it/s]                          \n"
+      "Sampling points...: 2561it [01:19, 32.13it/s]                          \n"
      ]
     },
     {
      "data": {
-      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAIxAlUDASIAAhEBAxEB/8QAHAABAAMBAAMBAAAAAAAAAAAAAAMFBgQBAgcI/8QAWBAAAQQBAgIEBQ8JBgUCBQMFAQACAwQRBRIhMQYTIkEUMlFhcQcjNEJSVHJzkZKTsbLR0hUWMzZTVnSBwSRVYpSh0yUmdZW0gsJDY2Si8Rfh8ESEo6Ti/8QAGwEBAAIDAQEAAAAAAAAAAAAAAAIDAQQFBgf/xAA3EQEAAQMBBAcHAwQDAQEAAAAAAQIDEQQSITFREzIzQXGRsQUUIlJhgdEjJKEGQsHwJTREQ2L/2gAMAwEAAhEDEQA/APv6IiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiLwTgEoCKoGtPIyK7fn//ALKGfXrMMYMGk2Lryf0VZ7NwHl7ZaMfzWpRrdPcudHTXE1ck5oqiMzC+RVuk6jZ1GKR9nSrenOa7AbZdGS7zjY5yp9O1PVn37tWQTSWBWklEc0IjZHIHkMawgDc0jHHJ5c+YG2g1SLFw6rel066x9/UGTQPjbA51aNk00ro89VsczHjeYcOOccVbbtQ/OOjCb8mDXdNartZH1QwA0AHbvGXEuHa9oUF8iIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICLxyVezXNJkpy249UourQkNkmbYYWMJ5Bzs4HNBYouepeqahB11K1DZhzjrIZA9ufSF6O1GlHVjtPuV215RlkplaGPGC7IPI8AT6Ag60REBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQF6u8R3oXsvV3iO9CxPAZEPwFYaMc3j8A/WFUF2CVaaEc3nfAP8AReF9mR/yn3n/AC2a680YaNckem0YXvfFSrxue8yOLYmgucQQXHhzwSM+crrRe7ayufoekPqsrO0qk6vG/eyI12FjXcsgYwDhdcdeGJ++OGNj9jY9zWgHa3OG+gZOB5ypkQEREBERAREQEREBERAREQEREBERAREQEREBERB6udtaTgnAzgLC3WTT2NQvRRalZgdLQfumpPZI0R2t7mMjDGuc1rSXZ2k8fGPdvEQZ/R2usdIdU1KKtNBUnhgib10TonSyMMm5+1wDhwcxuSOO3yALP29P1Rg1enBXssh0uvbm0+WNrsySTMJj6sj2zN0rOHHi1fQF6l7Q4NLgHO5AniUGPbBqk/SmUWL1yCMzERxx1pzG+Ex4/SB/VNOcnJbu3DyYXJoR6RzapQN8XmQ2CHTB24Nj6hjo3DzdY8tePdAFb1EBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQF6u8R3oXsvV3iO9CSMI9+Hn0rppatX0p7rNiOw9hGzFeB8zs/BaCccOa4JXYlf6Vc9GTm7J8BeP0FvHtHP1lXFzM4XGk6zW1mKSStHbYI3bSLNaSE/yDwMqvh12zJ0qk04iLwcSOjbiJ4PCNr89Zna52SRsA3ADPILRKuOi0DfN7qpBPv6zImeGh2ANwbnaCQME44jIPMr2CxS0OkF+/LfjM9Ku2FrpGyy13hjGtkc08S8CUbW53NIAzxUrekF1z9GiNeNstotNvc1w2McHbNozlpcWk4OcBpB4rtk6MaRMyWN9eXbIRkCzKNva34bh3ZG7Bw3A4BSydH9KmlrTTUY5p67muimmy+UFucdt2XHGe8oLRERAREQEREBERAREQEREBERAREQEREBERAREQF4JxzUM9mOAYJLnnkxvMrky+2xr5TiNwyIxy/n5UE0lt0hLa4B8sh5D0eVcb4GOuQdZl5du3OJ4ngusDHBQv8AZ1b/ANX1IJxJLX8bMsXl9s3710xyMlYHMcHNPeFGonQ4f1kTurk7yOTvSEHYi5ILgkOyQbH5LfM4jyFdaAiIgIiICIiAiIgIiICIiAiIgIiICKKaVsEL5X7ixjS4hjC44HkA4k+YLl/K9L8lw6j1rzWmDTGRE8udu8UBmN2fNjKDvWN6X6hb0+9D4BbmYZYS26G5eK1fcM2APaubk+njz2LQM13TZJ60LLG51ljXxkRu24dnbl2MNJ2nAOCcFdgrQCWWUQRiSVobI/YMvAzgE9+Mn5UGb17UJKFDwvTJLTptLYHOjsNlENmMgAgyEYe7k4OBJyPOV3zyzdHOitm1NLJesVoXzyPkcRvfxcfLtbnu9qPQrM06vgYp+Dw+ChgYIdg2Bo5Dbyx5lM4Nc0h2CDwIKDO3b2t0mabELGmzT3rgg6xtd7WMYY3vJx1h3HLPKM+bmoIukGpeExPlNN1c6i7TnRNjc2XcMgyZ3EYy3dtx4pzuV5W0nS6YaK2n04A2TrWiKFrcPwW7hgc8EjPkK9/ydQ8ON7wOt4YRtNjqm9YRjGN2M8kGbg17Xn1J4n14BqzWxSeB+DEdWxzsOcHdbtmAwcYc3OPPhW9XU7Nvo3Ncq9VbusbK1rDG6BrpWlzdha4kt7QwclTM0DRY4Ja7NI09sMpBkjFZga8jlkY44XUylTZS8CZVgbU2lnUCMBm08xt5YQZWTpRqUcMNVkbZ9Tlt+Duj8E6rqfWjJxa+bDiQ3hiQDj5sHrr6xrlqzU098NWhdkhmmkdOzrQ5rHho2tZJwJDg49s7eXHmrhujaSyk6k3TaTaj3bnQCBuxx8pbjGUfoukyU46cmmUn1YjmOF0DCxh8zcYCDMzalq9c9JJpbcE0Fa9DFFEI3sLd0dc8HNfy7buHecnOOyu1vSC+bzXkVfA3ak7Tuo2u64EZG/dux3btu3xeOVdv0vTZJ3TvoVHTPaGOkdC0uc0EEAnHIEA/yC9xp9AXjfFOsLhGPCOqb1mOWN2MoM/oWv6pck0l19tMxalWkla2CNzXROZt5kuO4EO8gx51LqmrTUdV1ewRI+LS9JFpkDXECVznSE59AhaB5NxV7HTqRdSIq0DBA0ti2xgdWDzDfJyHJektKCW6LfFs3UugLgebSQeI78EcPSfKgy1zpHrWny3K736ZZmirVZonxRva0mWYxkHtnhgcD/8AhS2dd6QxanZo1KUNySk2N0zmxtjbLuyeG+YFgxwzh/EH0Ky0rorpmlGwWsE5nDA/rYomtwwlzcNYxreDjnOM5xx4BWNvS9NvyxzXKFSxLH4j5oWvLPQSOCChra9rNzWZWV9ODtPhuuqyuOwFoacF+7rc+fb1fEY4pomvapbm0p14UzDqMcrmthjc10bmcskuO4EZ7hjzq+fpemyXm3pKNV1xvi2DC0yD/wBWMqSOnUi6nq60DOpyItrAOrzz2+TPmQU+p6tqFDWomSCKDS3GJnXmu6Xc9z9u0lrx1fNoBLSO0qOt0itafTE8gdZMdTUrB6yV2SYrLWtB44xh3PBIA4YGQdhLpenTXmXZaNWS2zG2d8LTI3HLDsZXuylTic0x1YGOaHtBbGBgPO549BIBPlKCj1PVdY0qtTZ/Zbtu7YEMTq8GxrBsc/k+UB3i4Habz/kfR2oaoBoti7E6tYkuyVZoGvG2RhY8h21rnAHsNdzOO0M8VcM0TSI6klRmmUm1pXbpIWwMDHnyluMFeW6RQhNYw1o4WVN5hiiaGMY5wwXbRwzguH/qPlQYad2J5PhFXnRU5uy/AWdsuxZk+EVZ6Fq1DSXy2dSuQVICAwSTvDRu8mT6CvO6S3jWZ8Wharzdw3iLg0zWtM1mOSTTL9a4yM7XugkDw0+Q4XqdV26zHpr6NlrpGPeycmMxua3bk8Hbubmji3vXom+sUVONckdctVG6TeM9djJNgMPba5zmgg9Zj2rjxxyXtX12GzNQYytZDLrXFkhDdrHNByx3aznsnkCPOgtkREBERAREQEREBERAREQEREBERAREQERc81lkR2AF8p5Mb/XyIJnODAXOIAHMlcb7L5siAbWftHD6gqK9qF8ahN1bIrrINjpajOy+NpB4t7nHh3q4qWWXKsdiMODZBkB7S0j0gqMVRM4WVWqqaYqnve7Imxg4yXO5uPEletb2LD8AfUvaSRkY7R4nkBzK568b5a8e84j2jsjv9KkrSmYvJbCNx73HxR96hdXabcAe5zi7dl2cd3d5F1gBoAAwB3BQSSMbqFRjntDnb9oJ4ngnAzhPvkg/SZkj92BxHpCma5r2hzSCDyIXlQugLXF8J2OPNp8VyD1gY2SF7XtDmmR/A/CK9gZq/i5li9yT2m+g96jpzNLNjuzJuccHv7R5eVdSD2ilZMzcx2fL5QpVirmu3J5JrVWEafp8DhG+/aYQXu3BoDY+8Z4ZP9Fq2WSwhlgBpPJ48V33KddqqiIyROXUiIoAiIgIiICIiAiIgIiICIiCOQyCJ5ia10gadjXOLQT3AnBx8hWeq6XqsWh6dXfHTFqg6NzA2w4skIDmuBOwFvZPDgeK0qIMrW6OXYHwxmWu6GR8E1h+5wc2SOQyYYMcWk7RxIwAeeVqkRBkbGmR6r01vQ2LFxscVOB7WwWpIgCXSA8Gke5C7fzP073zqn/cZ/xJU/XzVP4Ct9uVaBVU0UzmZhRRRTVmZjvlQfmfp3vnVP8AuM/4k/M/TvfOqf8Acp/xK/RS6Onkn0VHJQfmfp3vnVP+4z/iUVfolQkqxPda1QucwE/8Rm8nwlpDyUNP2FB8W36k6OnkdFRyU35n6d751T/uU/4k/M/TvfOqf9yn/Er9E6OnkdFRyUH5n6d751T/ALlP+JRS9EqDJIALWqYc/af+Ize5J915lpFBP+mrfGH7Lk6OnkdFRyU/5n6d751T/uU/4k/M/TvfOqf9yn/Er9E6OnkdFRyUH5n6d751T/uU/wCJPzP073zqn/cp/wASv0To6eR0VHJm4uiVB8k4NrVMNftH/EZvcg+686l/M/TvfOqf9yn/ABK4g/TWfjB9lqnTo6eR0VHJQfmfp3vnVP8AuU/4k/M/TvfOqf8Acp/xK/ROjp5HRUcmL6SdG6lDo1qVuva1Ns0NZ72E6hMQCGnHAuWug9hxjJPYHE+hVPTH9TdY/hJfslW8PsSP4sfUo00xFU4RppimucR3PmFt+Lc3wyr/AKHtZLbnD2NcNnIjKzN139un+GVpOg5zcsfAXPsW8ajPi5mnrzqceLasjZGCGMa0H3IwuPwB/wCVZb4maXOijhY1zMhjQ4uf383ZHo2jmu9F1XZUtnR7UkGpeC3xBZuytd1xiLurYGtbsGHA8mnjkYLiQn5Ittm0l0dmpFFQ4GJlRwDhtLcN9c7I2n/ErpEBERAREQEREBERAREQEREBERAREQF6ve2Nhc9wa0cyVBNbaxxZGOsk8g5N9JXHI17p4XzP3kuPDuHA8ggnfYln4RZjj92fGPo8i8MjbGMNHpPeV7L0klbHjPEnk0cygratYRdJL8/XRkzQRetg9oY3cSvXU6DtRljmpWJK9uHIZO09nHeCOTgvSOhM/pPPblaGwSVGM2h3HIcefyq6AAGBwChFOYxLYruTTVFUTvxCqbqNejchqXpC21KwYmc3Ecju8A93o84XfV9jR+hc2qzaa2BkGpGIsncGMjeMl7u7AVD1XSI6hFO4Z0psm1tWu8CTbyy4kcW9+M/UsTVs/VD4bm6ndP8AC3j1tl6+6np0b52syJbTf0UZ8mfbHzBcX5q0pLERvvluWpcl9l7trwQMjZjxQPMr2ua4a6Ov1YDHYc2PHZPPkF4eQL1bj7r6lnZz1t7Xm387isX9R0u6Gz1HWdOeWtbPCC6SI/429484Vy17Xt3McHDyhessscMbpJXtZG0Zc5xwAPKSsjqGnau/pAH9HHGjDMBJatSOD4Zc+4Zx7Xn4Kyi3VM8d31N9P1WtjWdPqSV6ExfNbnkOyCFu97RuPbOPFA8qhbots6yNR1O7LaigeTVhiyxkI7i4Dx3Y7/8ARedEuaWdRsxCs2pqkjiZBIza6YDgHNPthgdy0Ksi7TEYt/f/AHuZiYlR9KKrNT0DwcWIomyTw4e93A4kacf6K7IDm4cMgjkVQ9J9Kmv1aram0PF2CSQE4Ba14J/mrqObLhHI0sk8h5H0FKp/TpjPfP8AhnveA2Wvxh7cf7Mnl6CuiGdkwO08RzaeBC9VzTR77UOCWu2uO5vPuVTKwRcjbD4uzYAx3St5fz8i6gQRkcQg8oiICIiAiIgIiICIiCt16SWHQrkkD3se2PJezxmt9s4ecDJVPBcrHo/qjzans1Kr3yV3R239ZJHjhiQO3OBeHtBzxx3rVIgxrIptK1fSIpdXNuyIIK8lJ1mQyOd2982N+HDtcdzTwZz4LZIiDN1xKenmp9W9jf7BWzubu9vL5wr3Za/bQ/RH8Span6+ap/AVvtyrQqFHBXb4T4yg2Wv20P0R/Emy1+2h+iP4lOimsc5Zax+mh+iP4lDVbZ8EhxLEBsbgGM8OHwl3HkoKfsKD4tv1IGy1+2h+iP4k2Wv20P0R/Ep0QQbLX7aH6I/iUEzbPW18yxE9Zw9bPuXf4l3KCf8ATVvjD9lyBstftofoj+JNlr9tD9EfxKdEEGy1+2h+iP4k2Wv20P0R/Ep0QcMLbPW2MSxA9Zx9bPuW/wCJT7LX7aH6I/iSD9NZ+MH2WqdBBstftofoj+JNlr9tD9EfxKdEGd6XtsDodq+6WIt8EkyBGR7U/wCJXkPsSP4A+pVPTL9TdY/g5PslW0PsSP4A+pQ/vlX/AHz4Q+R3341Cx8Y761pugZzbs/ACyeouxqVn4x31q76J6ZX1jwmvYksMYNr8153wuzx9swg448lr0UYuZcPSVfu/N9NXI2/XfefTa6R00fj4icWNOAcF+NoOCDjOeKg0nRq2jRSR1pLbxI7cTZsyTH+ReThVkWg2a3SOTUYWVtj7BmdKZHCV7XMDDERtxtB7Y48wBgcXLbegWcmuUYoLU7nTmKrnrXsrSObwODtIb28HOducY4rzNrVCCzBA+ZwkmDHNxE4gB52s3EDDdx4DdjJVFW6M3aNfUI6zKYMsEkLD1rm9eXPJD5TtOC1pwMbuZ5Be9jQNSs3aFh5rsMUddrw2y/awxyFzjtDQJdwwBuxtIyOKDVoiICIiAiIgIiICIiAioelccT9JiMlWSw9luB8YjrumcxwkaS4BoJGGh3H71wa9E+7fimjqWJXOia2k/qH+sTCUbnHh2OG3icZDT5eIa1ERBw6lq1DR6os6hajrxFwYC8+M48gBzJ8wXh8stjgMxRf/AHO+5emr1oJqomlgjklgcHRPcwExnIyWnu4KVB6sY2Nu1jQB5lHPwMRPc/8AoV7yStjwDkuPJo5lc8zHvax02A3e3sDlz7/KglMrpeEPLvkPL+XlXvHE2PJ4ueebjzK98Y5Li1LVamlQiS1JguOGRtG58h8jW96xM43yxMxEZlxmtMOmPhWw+DmjsL88N2/OPkK9ruqXHXfAdLqdbMMGSeXLYYx6fbHzBVV6la1rpFSFk24NOlpuL67SW5OR2Xkenl5lqmMbHG1jBta0YAHcoU5nOFl7aqinwcUGkVIdQkvlhltycOtkO4tHkb7kehdNb2OP5/WveSVsYG7meTRzK5oWboN0ztsbS47e7mfGKnEd0K4iI4OOXS4pdUbfovfXm3evSR+JKPIR3+lVd3pJV0+/HVvUrPhr3PEMDW73WfIWEcPuVjY1Cxq1AHo3YquzKYX2X5LYgBxLR7Y/6KWrVjoupQz232pYd+6xOQXgu8/d9yti3TR8VXkt6WaoxVv5Tyc9nRn6wKdjVm2DXYwOfp/WBzQ/n28ePhaGHq+paIdojAw0N5AeRVNOLUNLmkbZti1pwYXiWQ+ux47jjxh5111p616FtuhYY5r/AGzeLXekeX/VV1X9rdM4x3FVqad8b45vaOpBZrwPmiY58eXMeR2mHyg9y4Kr9W0yw+K+9lugGlzbnBr4x5Ht7/SFYUp2mFkbuy/HI9/oXXzUM0zwlTNPezevtdq9fRJtPLbELdTglc+NwxsbkkrRPjZI3a9uQsdr+jzUNT0yzoTJY5JroMsMb3NhdhjjlwHLjgLQaXrAvukrz1pal2HHWwSD/VruTh51dVOKKYlGKt+J4uvMsHPMsfl9s370a9sttjmODm9WeI9I+5dC5HRE3XuidseGA8uB4nn8igsdfNQiN8BzXPZ74zy/l5EZP2gyVux/d5HegqZB5hnbKCMFrm+M1w4hTLlr8bU58zW/X966kBERAREQEREBERBw6tcfQ0uezE1rpGNwwO5bicDPmyVWP1HWXaZZFWGGxqFa2IHlkfZc3suLg10jeO13Iv5hXdmvFbrS152B8UjSx7T3grjbotKOq6sw2WRuO5xZbla4nJOS4O3Z4nJzx4Z5BBVR9IbM0sEsRhfUHgzJsxOa975nbctG7shpxwO7v48OOnVazQtNjnrysrbXV2NZGA9wbhuduW5w4jJwTkjJVkgzdeVsXTzU9wec0K3isLvby+RXvhcfuZvoX/cqWp+vmqfwFb7cq0KhRwV2+E+MoPC4/czfQv8AuTwuP3M30L/uU6Kaxzm3HjxZvoXfcoatqNtSFpbLkMaOETj3ehdx5KCn7Cg+Lb9SB4XH7mb6F/3J4XH7mb6F/wBynRBB4XH7mb6F/wBygmsxmWuQ2XhJn9E73LvMu5QT/pq3xh+y5A8Lj9zN9C/7k8Lj9zN9C/7lOiCDwuP3M30L/uTwuP3M30L/ALlOiDhhsxiWwS2XjJn9E73LfMp/C4/czfQv+5IP01n4wfZap0EHhcfuZvoX/cnhcfuZvoX/AHKdEGd6X2WO6HauA2XJqSc43D2p8yvIfYkfwB9SqemX6m6x/ByfZKtofYkfwB9ShHXV/wB8+EPi+puxqlr4131rWep0c27fwQsbqjv+LW/jXfWtd6m5zaufBas7OJy8/o5/e/eX0ZEXLHqFKW7JSjuV324hmSBsrS9g4c28xzHyhSekdSKv/LeldVYm/KdLqqxxYf17cRHOO0c9niMcVI/UqMdqKq+7WbYmaHRxOlaHvB5Fozk8j8iDsREQEREBERAREQEREBFT9Ipup0+IvnfBXNiNtiVkhjLI93HtDi0ZwCfITyWfvW+t6MU7EmtMgfA+RzWSWHsdaaA7q2Ese125zSx3fzBwUG4RRxPMkLHuYWOc0EsPMeZSIOTUnMZptl8r2sY2NznOccAADK4q9sX60U1R7XwyNDmzDiHA+58q69UoVtT06apbrxzwvGTHI3LSRxHD0gKGoGinCGgBoY0ADu4IPeOJseccXHm48yvSzwgJ8haf9Qo9Q1CvplU2LBdtBDQGNLnOJ5ADyqrngs67pLzqEMtKHdvFdkvaezHKTHL4IUZq7o4ozV3RxdFvUbVmFrdDbBYc95Y6w5/rcOOZOPGPmC6KmnNiEMtp4tXY2lvhL2AO488eQLqr14asDIa8TIomDDWMGAF5kkbGMuPoA5lIjvkinvlV3bE0XSfS4WvIhmin3txzI2kKxMrpDthAPleeQ+9VV+1O3XNJruDWwWDKHt7+yzcOK9otag1OW3Q0iTdNDGf7SI90DH9zc9578BSt0TVnHCP4bF3q0bu7z3y7LdiLS6U1yRk0xYOIiYXvdxwAAFU1a0+vaPKzXqja1Z029kDZXB20HlIRwPHuXTpemM0cyySWZ72o2cdbLIeL8cgG8mtGSuxkfVyf2viNxc0A5Y0nyq2u7Raj4Z+6iIy94IswshqxivVaNrdrccP8I7lK5sMMLo2gAHxs8c+le75sNO0Z84XKQ924815/2j7U2I2LW+Z71tFHNGHvjxsJLPc/cuA0o677NvT42R25W+KSQwnykDv8678cMKNze1hnjLx9V/UVVdbj6tqidng5NNvPuwvisVZK88ON7XDIPkLXd4VnFM+PG7Lm+XvC5LFaG7VNOzlrHd7XbePMHPl4Lm6yXQtN337EluMSbWyNjy5jMc34548q3LHS0z0lEpVU0XOrunkl1W/O3Xuj1eCXEc88nWBvJzRE4q5vUYdRqvrT7w13tmOLXNPlBHJZ2XUpBr+hR0ZYnwXevc53MODGAj0cStNHMHu2OGyT3J/p5V7nTV3Lmmt1XIxmP8y0K6cTMSqWWLegU5HanYfcqscAydkRMjW+WQDnjyhWFOzDce+xXlZLE5jdr2HIPNdao5dOsVRYdoXg9aQSh7ons9bl7PEHHi+kKe+nwV76eHBdPY2Rpa9oc09xUOJYOWZYvJ7Zv3qCjqRsRxNtwmnbfkeDyOBJI57fdBd6lExKUTlHSc2QzyNOQZMD5oXWual+jkd5ZXfXj+i6VlkREQEREBERAREQc923FQpzWpclkTS4hoyT5gPKVyxaqZ6L54aFt80chikrAxiRrh5cu28sHxu9T6lTGoafNVLzGZG9l4GS13MHHmOFWSaLqDtNt149TijntyiSaZtZ3HucAN+QC0NbzyME5yRgPNbpRTualVowxSmSzWZaaXOjbhrt2OyXbiRsOdoPcr1Uz9IsymjE+zVbVqujf1UNUsO5nLa7edreXDB4ZGeKuUGeqfr5qn8BW+3KtCs3BDFL071PrI2vxQrY3DPt5Ve+B1fe0XzAoUcFdvhPjLzLNHBC+aV7WRsBc57jgADvKzFrptG50f5JpuvMcMukc4xAeQcW5P8A+F46bxV2aLFVFaP+1WGRF7QBtx2s8v8ADj+aroq7K1drYwNoHcuR7W9qVaOIpojfJTTXdrmmmcRHm8zdJ+k75nOho0IoTja2Te8j+YIz8i62dL5KVdrJ6D3OZtbiNwI28ATk448+C9H5LRtxw7lEYOuYexjyrhR/UWp2omqIwtnSVRE4rnK9g6YaBNK+P8p14nMDXHrX7BxGeBdjPn8nermKaOeJksT2vjeA5r2nIcDyIPkXxDpTpsUTuuZkOzjAHAjv4/Is/FqN6tEIob1mONvJjJXNA/lle10VUaqzF2jvcuNbXRVNFyN8cn6TUE59erfGH7Ll8Y6PeqFY0+cRapEy/V2tZxY0SMx7YHHa4e658OI4rdar006L0IKliOSK0JHZ6uqxrnBu0+MDjbzHA8fNwKuqtVUzjDco1FFVOeDaZRfHmeqdINRllfo9V1RzWiOuCA5hHN2/bxz6O4efMep+qZNZpmKjpVajKXD18lspA78Atx8ue/8Alnoa+SHvdrm+yrmvXqum05blydkNeFu573dw/qfN3r4Nqfqg6vd08U/7NBjbvnrx7JH48+eGeZ24+Tgsvc1mxZa3wmzNNt8XrJC7HoyraNJVVxTi7VV1KX2296p+hUoLEtJ7707pW7Ig10YI2jJLnN4cj5f6qnPqzsbz0QD/APu//wDhfE5tRLckKtlvSyu5kBbMaS3HFfRpr1e+Zw/SWg+qvpOp2zXvxDTs4Ecjpd7Cc4w44G30nhzyR3/QM+cL8aadbniuRSMILmODgHtDhkeVp4EeYr9T9C6Qb0M0nwqGB0rq7X5GXdk8W8Xcc7SM9wPLhha2osxRvhmq3VbnZmcurpj+pusfwcn2SraH2JH8AfUqPpfVrs6Haw5sEYcKkhBDB7kq8h9iR/AH1LSjrqv758HwzVnf8XufGu+taPoRTsagLkNfUbFB4LHdbXDC4jj2e21wx/LuWY1d3/GLnxzvrWz9TA5tXfgtWxVT8Lz2jj9795bjSdOs6dFIyzqtvUXOdkOstjBb5hsa1cLatiHpI+xVpXIoJHE2nuna6OYkNa0tZvO0jGScN4NPjEhaBFU9KygoXIausR1dOusrS13NirS2GPL5nOdlzMyENb2gcEj0eWR1S4+zp08Gn3a9wMgZNM6wwRtja8l7Hsa87jtLsYafGHEccadEBERBBbt1qNZ1m3YirwMxulleGNbk4GSeHMrjq9IdFvWGVqesafYnfnbFFZY9zsDJwAc8goukzAdAsSGSGMwOjsAzHDCY5GyBrj5CW4/mqXRdUf0qv1LUOnNpV9PmfJIZHt6x0mx8e3aOIHadxOPF5c8BskREBZ7Wta1XS7EUcGmU7TrEoirR+GuZJIe87eqIAAySc8AFoVnnaJqo16zqsWp0i+RoihbPRc8wR97WkSt5niTjjw8gQaFF4HLjzXlARQW3Stpzurt3TCNxjHldjgsdU1F35F1AVdRnniEELzM6YvkaeHXlpPEbWlpwPFLu5BuEVP0dm66jMWTvsVhYkbXlfIZC+PPujxcM7gD5AFcIPCytLWBqVOato8kctmDsGZ7SYmuzyyOZ8wWmmhjsQSQytD45Glj2nk4HgQsvBojqMwfo0jKrYpDE+sR6y5gPc0eKQPIo1Z7kKs9zv0zSzQa+Se1LbtSnMksh/wBGt5NHmC7ZxmvKPKw/UuaLVactmes2bE8Dtr43Ah3pA7x5wpXNknY7fljMeKOZ9KzTjG5mnGNzyJi9obENzscXHk1ewjbEHSOLnvAyXYyf5Bea+PBoscBtH1L1szCKJwBPWOB2tbxJKlG+YhJk/wAoape1rTLN6nFV02d8kUdaZmZSCx3afnxeXi+fitJVhjirsradCyvWjGA5rcAfBH9VQ6VRs9Jeiem2rlt8dxrRJHK1oO14yMkd/oVydaipXmafea6GRzR1cxGI5j5Ae4+YqWormiuqKt0Ry4bl8URcop2N8xE5dTmsrgtjzu73HmVHI8u4nie8Ly9+/iOPlXoY3HgDleD1+qu3q6ponMSlTTEI2uLOXi+RSNc1xLt2MDv7lG44IB4nyIY9zskgEeTkudZuVT1+5OQkvPkHlXkDa3PJewdnALQCf9V0R1jntcG+RbFrQX71WKYz9WJriEXV7mhoGcp1EkQBDTJH7n2w+9drI2sAwqzVukNTS7ENTbJavzH1urAN0hHuj7lvnK9To/YtO7b3zyhRVdnuU+pSPq65pFTQoKbXOZYnIfHjPi5Gebc5+paOlP8AlKgyWerLXkyQ6OQYcxwPcfqIVbDoEo12bWp7hfZLdkEYYAyFnDI/xEnvUvRvUZbenA3Hnr3SyBpcMAgPIGF27kUU7NNHJLfXamqY4Tx79603yQfpMvj92BxHp+9KxDjM9pyHScCPQFOuOGJ46ySF2D1jssPI8f8ARRUvGpaVT1aARW49xadzHtO18bvK13cVwT37HR+GBttk9ym1uJLo7T4/IXtHMf4gu+1qtSjXfPckEAZzD+Z9Hl/kuKxVOv068szrNamQ50tRw2Ok8m4jiB5vOoVY/t4qqv8A88VrpsrJ6EU0Tw+OTL2ubyIJzldi5dPiZBp1eKNgYxsTQGtGAOC6lKFgiIssiIiAiKu1uVsOkTyOtT1du3bLXj3vDtw2gNwd2TgYxxygsUVFo9zpFY6j8paXUgicDvlbZIk78HqtpAJ4cOsOM8yr1ARVuvRyzaFcjga973RkFjPGc32zR5yMhUArsOlviFCf8li+JfBPBX+xzwx1eM46wF23Gcd3FBsUWEp0LTLVHradjwoCsasronHqIWvcZGOdyaer4EHnlvPHDdoM9U/XzVP4Ct9uVaFZuuxz+nmp7ZXx/wBgreLjj25fKFe9RJ76m+Rv4VCjgrt8J8ZZnp4Xx6XSla0lsdxhccZ2gtcMnycSB/NccMRfXDicnnwWj1jRjq2lz0pLkzQ8Ah2G8HAgg8uPEBZLSrj5KjGS9l7SWuB4FpHcfOvMf1LYmYoux4J2KoovzFXCqPR3NIUrDgelczn4dljeXeugvGOXa8/cvIzDpQoOlVdr9PdIQAQvlF2fq92F9S6YWXDSC3HjHGQvkWotdtJ4r6T/AEnM+6fFzl5+9RRVrp+ziddc13Nex1R23GVVvcd+F7Mi3BesdedPbxvhZw6i9z8ZVrFYLSyVmwvYQ4bmhwyPK08CPMVQQQEO5KyYXNbhYmI72jqbNvMbLlsyuY48VXyTF3MrrvZwSqklxcnB0NPRGzl7SPyML0hbudhTR13SFWNbTHZynituXqLcb5dOm6cx0D5y/D2SNaGdniCHZPjZ4bRyBHHiRwz+qtGpv0/RKFOUtMlevHE4tPAlrQDj5F879S/oa+o063Y6yPfG0VN7Gh2CO27BzgdzTkEjJxghfTOok99TfI38K5mpuRVViO5ztqa6tuVX0y/UzWP4OT7JVtD7Ej+APqVH0vhe3ofq5NmVwFSTgQ3j2T5leQ+xI/gD6lpx10f/AKT4PgmsH/jV34531ra+pcc2r3wW/wBViNZP/G7vxzvrWn6AR6lM283S7VevYywl9iEyt28cjAc3jy71uVx8DhaSP3nm+uIq3SYdXhikGrXKtqQu7Dq1d0QaPOC52VRaVrUrukGsPteGjNeKSGo+GRu3a6bssDgAXOaxruHM55hvDWeha9F8+GqO/Imqz39RtwTQ6nC5rpZJa4YXMicY27tuWjc/s+TiQrwX6djplHXp6lmZjN9mI2y5r2uZljGRl2M4w8uA5Ae6QaVERBWa5EJNLOY55ermhmDIGBz3FkjXjAJGeLRnzZVR0UbGNR1Yll6Odzw8x2oRFtjfJLI0NwTu7T5O19ytekEzYNIe50ksbXzQxGSKXq3M3ytbndg4xu4+bKq+ic8Etu85jLTpHxxyMs2LJmdNBulbGf8ACMtecDucDnjwDUoiICIiAiIgIo5TKInmFjXygHY17toJ7gTg4+QrL63HetNrnVtKjlpsL8xU3vskvLCGkt6tuMHkeOCQeGMoNYiyOuUW2tCpNvMszahUZlrWUvCGST9VycCxw2nd43D4QwtVEXmFhlAbIWjcAcgHvQSLPUtTq2ruoVqUzJ5a85Eu05bGT3E+XzLQqor14atu1FBDHDHuD9kbQ0ZI4nA86COTSqs9qG3OzfZhOWS52kebh3eZQU9QuC+6jqFUskO50U8QJjkb/wC0+lWUszIW5eefIDmVCa77bSLGWQuGOracEjzlRx3wjNO/MPSvJJJAyOAeK3DpDyH3rqirthy4ZdIfGeeZVLXpWOj0diRtp02nRs3siewukb/hyOY86tqV+tqFds9aRr2OGeBWaZzxKas8eLg6L6jY1Xo9WuWi0zvMjXbRgdl7m/0Xfeggs1zFYiZIwnO17cjIXD0bveH6U6TweKDZPLH1cQw3svIz/Pmu+0Q1gJOP6qr2pNVNFzZjE79yy3OJiVDu1OnqGQ1tqjM7HDDXwfib/qrBkrbALq7w9o4FwOQD3hezg44DgQO5q4Y9FZWvG5SkdCX566uwjZKe447j5wvC7PSTs44cm/tU1xv3T6u9oAyQCT5e9Sxwl+3h/NcGlalBqUrqz2PrXYh67Xl4Ob5x5R5wrtjQxoaF09B7KquVbV7q/wCWvdmaJ2Zje9TDGWbCwEKMufWBLiXwjv72/eotU1alo1J1u9O2KIcB3lzu4NHefMqmSjL0soV332W6FMuc59IuDXTt9rvI4gf4fPxXr7NimmmN2KWtMpNSv6pfMNbQGxCKZu5+pOIdHG3/AAt9s7/RWlXT4K0hn2Mfbe1rZbBaA+THlP8AReYqUdOJjKTGQMYNoiaMMx6O5TRzB52EbZBzaVKqvds0xiP5ljCQ8AVVaHYfq2g17FprXPl3E4GPbED/AEVnI/q4nvPc0lV+jXGT6DVtvZHA17NxYwYa30KmesujspnHfG/zdQfNV8fMsPuvbN9PlXO+6+HTnyVIDbn3nETHAHLnHGfIFxx6idedarUXyxRMbtFprAWb/J510afokOkxnwJzuufxlkkO4zHyuTOeDX2trqpK2nTWK0btYME9pshlYY2YEJ8jTz4eVdE0ksEEgk7bdpw8D6wpIbLZHdW9vVyj2h/p5V5t8asg8o2/KsxGEojDqibtiY3yNAXuiLLIiIgIiICIiAiLwTgIPKLP39cE7IK9J12tJNPHG6eWjJHsaXccGRm3ceQ58+S8x35JejDbdm/LXcwua6xCxhdJteWgtaWuBL8DgB38EF+iy7Z9cqXNMsahPirLFDBNDG6MOFhxdkuGw5HFnivGMHhhahBnqn6+ap/AVvtyrQrN13uZ081PbE+T+wVvFxw7cvlKvevk96zfK38ShRwV2+E+MplgOkunz6Vrkd+Jsr6Np7Wy9ouLJCccsEhp4Y58eHkC3HXye9Zvlb+Jc92FmoVjXsU53Rkh3ZkDSC0ggghwI4gKN6zReomiuNyN63t07uMcGOqzh9drzk7uLTjmvLHu6zeXHDv9F1S9Hb9R+NOizWBOI5nNy1vAgAjnx3cT3YHcqtk13rA06XdxntEQvI/kcYIXh9X7I1FquYopzH0bFGpxTEXN0uLpSG2NLc0cS3jlfM54BK0hfTdS0zW9RjLKmmTkPbk78M7yPbY9z9XlCxh6O63u4aLqOP4V/wBy9j/T1m5p9Ns3N2/LiamuuvUTcpjcxF3TzBakY17ZWtcQJGg4cPKMgHHpC8xQEdy+s6d6mmq6pUil1GV9VoYOpjLBI5rSScEFzdvE5x5znBUGsepbf0+sJqUjrZGd0ZjDHnAz2QHO3cM+Tlwzlehp1NGcTLpxqbs0ZqpfMwwsKnbyyumWvgLifJtO1Xxid6umuLu+HJdY6TgFxx1Hl3JW8URkdyW+6Oep5e1eSrakpzVtMkY15kMjC94xx2jhjcc4yOAPtu+Fy5TRvlse8zRGzTGZZHo1oU2qX4atek+xO6Vh47urazODv2jcG5Le0CMDPl4fXOjnqVQ0LEFnV7Edos4mrGz1suzwy48XDzYH8xz1eh6RQ0JtqHTdMdC18gLsODieyMAuc7PeflVv18nvWb5W/iXPu6mqqfh3QhNG3O1XvdAHBFB18nvWb5W/iTr5Pek3yt/EtZaqumX6m6x/ByfZKtofYkfwB9So+l8z3dD9XBrStBqScSW8OyfOryH2JH8AfUoR11f98+EPz/rR/wCOXvj3fWtt6lRzZv8AwW/1WG1s/wDHb3x7/rW49Sc5s6h8Fv8AVdC5H6bj6aP3Xm+ooiLSdwREQEREFV0hkZHodjrJZGNeWR5jhbK5xc8NDQxwIO4kN4+VUvR69adrEmnzflTMcUcmbNOGJoZ640N7HdkZHwfTm41qvq8rI5dImqdcxrh1FxjjE8ktLXZbxBaW8OfM+Yjn6Oi31lp+otvi8QwSmy1nV47WOq2dnbxP+Llu7kF+iIgIiICIiAo5Zo4IXzTSNjjY0uc97sNaBzJPkUirSzVY53yvsVZ6w3EV46pbI4ccND3S7c8uJGPQg62W60lMW2WInVizrBM14LC3Gd27ljHHK817MFuBs9aaOaF/iyRuDmu9BCz1elfk6GQafJQlisxwt3RyPjw4sc07MtcR2uI+XOFaaLBPFXsSTwugdPZkmELiCYwTyO0kZON3A+2QWazL9drzdKrWk1A+SxFE3r5CwiOJ3MNLu9xDgcBaZRzQxzxlkjQ5pQccNdsbt7iXyHm8/wBPIplzu62kcSkyQd0ne34X3qcEOAIOQe8IPKqLOl+BwWJ9HrwstyPDyCS1rsc8dwJ//KtnOaxpc4gNHeVDmSfxcxxeX2zvuWMZYmMs/wBF9Ziu0rTIdO8CliuSwyRuPDrAeLifP5FoPBxgued8nl8noWfq6Zpmp19RrUfCasle/I50m7iJtoJcBni0g8j512s1F2kCpV1Ww18s2WiVrCG5HIZ8uO5Z1MRVVNMxulGmrZ4u9wdy/mF4jbvcMNxg810gMkAe05HcQvLjHFG57i1jGjc5x4ABcan2VPSZmdy/pNyC3SZZY4tJinLCxs7AN7PQVnH9INR02teqz+B27tXYGyidsbXbjgGQe0Pf5+5dVbV5ekvhUGnR2INP2FjdSHZL3cvW2nmP8S79P6P6bpunPowVmuil/TGTtOlPeXk+MV3ejpt76uMd35Kbm7Zqjd/P2R6VplllcTavajv23SdaCGARwnHKMeQeXmrdUfg8vRui80YbF2sH7vBy/Lomd+zPP0KyoahW1Oo2zUkD43cPIQe8EdxUJuTXPxFVrEbVO+HUvSSJkow4cRyI5he6qL+uw17UdKu19i1IfEiG4tHe70elRmYjiqmYjfKa/fbp9aTwnbINji3tBu7hyKq9AZd1GKvalgiqab1OIamA8uBHM+QfWpbmi04Bd1PUny2wyN7msd/8NmOO0e686saEbYdPrGm13g/VN2xPPENxw4+VQxM1b1kRm1v5uyGGKvCyGGNscbBhrGDAAXuvSOVko7PMcweYXurEI3PSWFkzcPHLkRzHoVRrGsM0SvG6+JZK7pWh00bC4xtzkueBx28OYVm6Z8khirgOePGefFYumvVZXy7JfI7xnnmUE4IcAQcg968oiAiIgIiICIiAiIghsV4LcDoLEMc0L+Do5GhzXekFQTaVp1mAQT0KssIDWiN8LXNAbnaMEd2TjyZXtfus0+sJXRySuc9sbIowNz3OOABkgfKVw2+kVSnokeqvZKYXvazaSxjmuLtuHFzg0YPA8e5B2R6Tp0NiKeLT6rJoW7I5GwtDmN9y044DieHnXaqg6/XFqCAwTgStiL5RsLIjJkMa4h3MkY7ORxHHiFboM9U/XzVP4Ct9uVaFZuCaKLp3qfWSNZmhWxuOPbyq98Mq++YvnhQo4K7fCfGU6KDwyr75i+eE8Mq++YvnhTWJzyUFMDwKD4tv1IblXHsiL54UNW1XbTha6eMEMaCC4eRB24CYUHhlX3zF88J4ZV98xfPCCdQT/pq3xh+y5PDKvvmL54UM1uuZa5E8RAkye2OHZKDOdLuglPpIJLcTvB9RDMNkHiSEct4/0yOPpwAvlUfqXdKJbjWv04Rtc4AvdPHtaPKcOJ+TK+/eGVffEXzwvHhlX3xF88K63frojEK5tRmZjdljdA9S7RtIkZPbc7UJ2hwLZWARcTz2ceOPKT5fJjcgADA5KHwyr75i+eE8Mq++YvnhV1V1VTmUqaYp4EH6az8YPstU64obdcS2CZ4wDJkdsceyFN4ZV98xfPCiknRQeGVffMXzwnhlX3zF88IKrpl+pusfwcn2SraH2JH8AfUqPpfarv6Haw1s8ZcakgADx7kq8h9iR/AH1KEddXHaT4Q/POuH/j1/49/1rV+p1esUG35q+nWNQfljeqruYHAdrj23NGP596yOun/j9/49/wBa3XqSHNnUfgt/quld7JzbEfuPN9D0nUbOoxSPs6Vb05zXYDbLoyXecbHOXK+xbg6VQV3TWTUsxPIbI2Pqw5uODC0bweZO7h5FeLjGmUBafaFGsLEhBfKIW73YIIycZPEA/wAgtB1mes6hqNbVbNDwu0xkj64ilmZCS0PlLXOZtGMcmjeM5Pf3841vVmS03vknfEZ4q7CyAGOxmy6J73u29nsBjxgt4nv5DTs0jTY4p4madUbHY/TMbC0CT4Qxx/mvdum0WzQzNpVxLAzZC8RN3Rt8jTjgPMEHWiIgIiICIiAiIgIiICIiAigtWq9Ou6e1PFBC3G6SV4a0Z85VXNrQms6a/TLlKzUmsmCcxnrDnY5w2ua7DT2e8Hn3ILtFRaxq9ulccyu2Hqq8LZ5xI0lz2uft2twRg4Djxz3K9QeCARg8QqTWJZ9GqmxQo2LrnvDG1IRzce/PJo8pPBXiIKqqfCo2zTY398fdGfJ6fOuteLFTrHddE7q5h344O8xUUU+XmKVvVzD2p7/OEFdo8dGK/q7ak0j5XWt9hrhwY8sbwHDljCsbVSC7XfXsxNlieMOa4cFXaZVgr65rMkdtsss8kT5YQ3Bh7AAzx45xlQ39fmGqjStKput3Glpnc7LYoGnvc7y45AK+u3NdeKeUcfBHdje5dV1Q9GblONrY3UpgIWQscTLuHft9sOXEKXT62q6hqj7uq2RBDEXNi06E5bj3UhPjHyDkF3U9Bp1NTn1Mh896Y8ZpnbixvuWe5b5go7Wiy/lRt+hbdBI9w69j8uZIOWQO52FXNUW4xRvzz/wjiYW7WtY0MY0Na0YAAwAvKraWs1rVmaoX7bELyx7XNLSfPg+VWSrznenExPAVTq1GcxNsULngdiIl3L1uTzPHf6ea6tR1OrplZ01mQNaO496rTSf0iqQTWzarQlzi+ueyZG92e8BYq37oZi7NE/DxcU+r6lqElPTo/B6lizF1jpTIHN2/4PdHzLSw1YYXGRsbOuc1rXyBgDnY8q5bmiULtFlOSu1sUX6Lq+yYj3FpHIrjsapNok8cV2F79P2ta24DuLT/APMH9VGN2+pbFqLk5p48vw79Y8HOj2xbkdHXdE4SOaMlrSMHC6K0bIqsMcZJY1gDSfJhcWuxQ2dDtRTWW14pGYMzhkNyV2vkZWiaHHuw0Dm70KUdYndajxkmjYfXN3Vub7f71WUr13UdSnozUbFWCNu9loDLLDf8J9qfMeKs46r7DhJaGG82w9w9PlXf3KSpHFEyGMMjaGtHcFIiICLjuapp+nFgvX61XfnZ18zWbsc8ZPFctPUJrGt2IBLWmpGtFYrviac4cXA5duIcOzkYA596C2RUVXV7U2siJ7YfBJZpoImtaesa6PmXHOCDh3cMcOeVeoCIiAiIgLwRkLyiCkn6OxFrJKtq1HYje2SN9izNYYCD3sc/ByMjuPHmpoNOuUtObWq3IBI3tGSauXgvLnOecB7eZPAZ4edd9ixBUgdPYmjhhZxdJI4Na30kqObUKdeo23NbgjrOALZnyNDDnl2uXFBTV+i/gxrRsuZrMEBmjMPGR8Ti5pac9kZxwweDQBhaNcEes6XNPDDFqVOSWdgkhY2dpMjePaaM8R2XcR5Cu9Bnqn6+ap/AVvtyrQrPVP181T+ArfblWhUKOCu3wnxkREU1jwRwUNMf2KD4tv1Kc8lBT9hQfFt+pBOiIgLnnHr1b4w/ZcuhQT/pq3xh+y5BOiIgIiIOeAevWfjB9lq6FBB+ms/GD7LVOgIiIKPpiP8Ak3Wf4OT7JVtD7Ej+APqVT0y/U3WP4OT7JVtD7Ej+APqUI66uO0nwh+c9eP8AzBqH8Q/61u/UiObOo/Bb/VYDXz/zBqH8Q/61sPU01WvpLNRs2GWHsJYzFeB8zs8fatBOOHNdS9H6Pk0rVP62X2ZFW6TrNbWYpJK0dtgjdtIs1pIT/IPAyoxcuN6RCkX15YHxOkLWROa+EAgNLnbiDuO7AwOR54K5zorZFmptX1KC3ZqB9SZ4lgijmbC5rInyOOWvG87iG4dwLfGHLK54uk9uS9BXdE1jIi1tuZsJezc6d8Ix2wWgujPHDvGGeWUGtREQEREBERAREQEREBERAXDd0ytqElZ9gTF1d/WRdXPJHh2MZO1wz38/KfKu5EFfY0ilbmilnie98Ti5pMr+Pa3YPHtDcAQDkDHBWCKh1fX2V6VpldltlhgLRJJSlEbDyLtzm7cDnzwcIL5FQQyanZ0jU61e3vuwSvgr2pQ0bjgEE4bt4E7fF9ryXZodmWzp2J3yPsQyvhlc9zXZc1xHAta0Ef8ApHn45QWahnrx2GbXg5HFrhzafMpkQfOH6Pr1npTqrp5pNN0ey6ON1huBNP1Y28CCdjTnnz4LdQxMhjayMYaBjyrre1r2lrgCDzBXA+GWnxiDpIO9nNzPR5Qrbl6q5iJ7mIjCdF6xyMlYHscHNPeEe9sbS55wAqmXPY06pZtR2ZYGOsRAhkhHEZHLzhUUer6xWZPVkoOsTxtzHLB+jkGQOBPIjPI/6rQbX2PHyyL3Pe70qYANAAGAO4KM08kJp5blXpdGZ1XrNTfDZmfIJWgMBbGccNp5nHlVqoXROY4vhwCebDyd9y9o5WyZHFrhzaeYWYjCURhIhAPAgJyXOHyW3Flc7Y/bS/hWWWW6T6VqborLdFkdZ6/a6ai93DAIOWE+KeHLlxWsoQZijsyseLEjA4iQDczI8XHdhdMFeOvHtjGM8yeZPnUqjFMROVtd6qumKZ7nlEXgnAUlTyiz9/XBOyCvSddrSTTxxunloyR7Gl3HBkZt3HkOfPkvDZdX1HozA+jZay6ZdpmJawSMa8gkZY4Dc1ufFPNBoVwO0io7UZr39oFiWMROcLMgG3jwDQ7A5niBzOea86Rb8O0ipZzIesiaSZNu4nvztAHycF3IOKLSqcOoyX2QkWH5y7e4t44yQ3O0E7W5IHHC7URAREQEREBeDy4c15RBn79PWnsgklmq3WQTxzeD16xhe/DvdPlLeHPBxxA4r3qw6jS6NS14K2Lwie+Fpc3a173OLWZz7XIz3eTKvUQZo6Q+lqOnM06rbYYI4YH2uvAidCzd2XM3Zc7tOwdvN3NaVEQZuuxz+nmp7ZXx/wBgreLjj25fKFe9RJ76m+Rv4VS1P181T+ArfblWhUKOCu3wnxlB1Envub5G/hTqJPfc3yN/Cp0U1iAwSY9lTfI38KgqQyGpCRZlALG8AG8OHoXceSgp+woPi2/UgdRJ77m+Rv4U6iT33N8jfwqdEEHUSe+5vkb+FQTQyCWuPCZTmQ9zeHZPmXcoJ/01b4w/ZcgdRJ77m+Rv4U6iT33N8jfwqdEEHUSe+5vkb+FOok99zfI38KnRBwwwyGWwPCZRiQdzePZHmU/USe+5vkb+FIP01n4wfZap0EHUSe+5vkb+FOok99zfI38KnRBnel8L29D9XJsyuAqScCG8eyfMryH2JH8AfUqnpl+pusfwkn2SraH2JH8AfUoR11cdpPhD82dID/zFqP8AEP8ArW/9R05sal8Fn9V896Qn/mPUf4h/2l9A9Rs5san6Gf1XWvdh5KaKcXMvriro9FpRahPeYLDZ53h8hFqXa4jGOzu28mgclYouY2lTF0d02KCeBkdjqp39a5rrUrsP3b9zcu7Lt3HLcL3Og6aDXIrkeDhoYBI4A7Xbm7hnt4d2huzx481ZogIiICIiAiIgIiICIiAiIgIiIC9JGMljdHI1rmOBDmuGQR5CvdEHH+S9PFUVvAawrhjmCIQt2BpIJGMYwSAceZTV68FSBsFeGOGFgw2ONoa1voAUygtyugpzzMZvfHG5zW+6IHJBOiyUOq34tJuk3hZkbDXkZZLGjqzLwdwAAw3xhnuIzlXWizzy17Ec8zp3QWZIRM5rQZADzO0AZGdvAe1QWaIiCo1dtmnUluaZUfatggCsxzWiUk44k8BzyT5MrxQdLPGx11rW3WtHWRNPZjd37fKPOrhc9iqywAclkjfFe3mEHqigbM+KQRWQGvPivHiv/wD3U6AobIjDOse7YW8njmF5lnEZDGtL5T4rBzXvBTO8TWHB8vtQPFZ6PvQVemu1PULdqHVKJrQROBhkY8FthpzjPe0jHFv+qvmtDWhrQAByAXsiAiKC3K6CnPMxm98cbnNb7ogckE6LJQ6rfi0m6TeFmRsNeRlksaOrMvB3AADDfGGe4jOVdaLPPLXsRzzOndBZkhEzmtBkAPM7QBkZ28B7VB22K8FuB0FiGOaF/B0cjQ5rvSCoZtL0+eDqJqFaSHa1nVvha5u1udoxjkMnHkyuxEHpGxkUbY42taxoAa1owAPIF7oiAiIgIiICIiAvB4DyryiDNa7qUknR3Uzap3tMYys97bL7MceHjxQHRyFwJOPTy7176nqEEuk0ni+1tV8kRszxT7S2I5w7e05aC5oG7PlWiRBhKd+0+1R625Y8KIrCrE6Vw6+Fz3CR7m8nHq+JJ5Ybyzx3aIgzFqrrdfpPZ1DT6lOxDPWii9esOjILXPPc13ulN4X0r/unS/8APP8A9taBFDY5Sr6PHCZZ/wAL6V/3Rpf+ef8A7aeF9K/7o0v/ADz/APbWhRNmeZsT80/wz3hfSv8AujS/88//AG16RT9K4oWRjSdMOxobnw5/+2tIibM8zYn5pZ7wvpX/AHRpf+ef/tp4X0r/ALo0v/PP/wBtaFE2Z5mxPzT/AAz3hfSv+6NL/wA8/wD216PsdKnvjd+SdMGx272c/jwI/Z+daRE2Z5mxPzSz3hfSv+6NL/zz/wDbTwvpX/dGl/55/wDtrQomzPM2J+af4Z7wvpX/AHRpf+ef/tp4X0r/ALo0v/PP/wBtaFE2Z5mxPzT/AAzbLHSpj5HfknTDvdu9nP4cAP2fmXv4X0r/ALo0v/PP/wBtaFE2Z5mxPzSz3hfSv+6NL/zz/wDbTwvpX/dGl/55/wDtrQomzPM2J+af4ZDWI+lWq6NcoHTNNjFiF0W8XXktyMZx1a1MTXMrMa8DcGAHHlwpV4d4jvQlNGJzlmmjE5zl+Yekbv8AmTUv4l/2ltvUp1WhpLdSs6lcgqQExsEkzw0bu1wyfQVhekjv+ZtT/iZPtL6D6jDWSzaoHsa4YZwIz5V17/YeRFOJy+qaZrWma1HJJpl+vcZGdr3QSB4afIcLzFqLZdWs6ea8zHwxsk6x23bI12R2cHPAtI4gLrZGyMEMY1oPuRhVp0+6Nel1BtyuIXxRxdSazi4Na4k9rfzO53tfJzxx5ab1OvRCO451O02StabV6ohm6V7g0t29rGCHt5kY45wg16NzKsop2uosPERlwzEUhfs2OG7dkOGDgEedc7tCuvlvyOvwbp7cduHFY+tOYGNAd2+0C1gB8XmeS9T0bc40A+xXcKs3hBl8G9e6x0hkeWP3dhrjwLcHs5GUGhREQEREBERAREQEREBERAREQEREBFUXukNPTZrUNlszZIYmysbtBNgOO0CPj2juIbjhxc3ygq0Y4uY0lhYSAS04yPNwQc0Wl6fBG6KKhVjY8ODmshaA4OxuyMd+Bny4Cmr1oKkDYK0McMLPFjjaGtb6AFMiAipdes2Yn1YK9s0xL1rnThrXY2MLgO0CPP6GlcVy9qgi0vVRIYaJjjdbgY5ofue5mODmOyOJGA5p8nFBp0REEcsTJoyyRoc09xWd1C/qOnatU06rptq3XnLRJcDezXa47ePuuPyDiVpkQQV6rK4O3Lnu8Z55uU6IgIizl3UbkWulrLJbDFNXh8G2txKJM5dnG7h3YPtHc0GjRUNefUa/SeSC7OZKtoPdUYxzC1gaGZ3DYHA5J47nDj3cFfIOOLS9PgjdFFQqxseHBzWQtAcHY3ZGO/Az5cBTV60FSBsFaGOGFnixxtDWt9ACmRARVOp9IKWkzuiu9ZF6wZo37QRLg4LGccl/FvZ79wxnjiyhe6WFkjo3xF7Q4xvxub5jgkZ9BQSIiICIiAiIgIiICIiAiIgLgty6oyYCnTpzRYGXTWnRnPoEbvrXeiDPaMYK2r622OnPA2S21+RUkY2RxYxpcDtw7tA5I9PLiubo1Vlg1CRxqywv6nbce+ItE0+9x3Anx+Ge0M8HALVIgLweXDmvKIM1qw1SzUjZqGmVnUmzxunjrzvsOewOHDZ1Tdw5E8+XIqCSlBZ6JwUdSjuRxse2RrI6hmcxnWExtLSxwOGhoIwcd+FrEQV+i9eNEpCzC2GUQtBjawMDeGANvtfR3KwREEFtsrqc7a7tsxjcIz5HY4LHVKsjdFvwVKFqCCSCHdAYHML3Nx1/McS5pDf8RBxniVuFyvvVI2zvktQNZXOJy6QARHAPa9zwIPHyoOHo9D1NGYMgfBWNiR1eF8ZjLI8+5PFozuIHkIVwiICz3Seu2dtU2Kctum0yb4oojId5Ydh2jz549xIPDmtCiDHX6bpHaNakisT6vWZHGGupdZG529u8ue5h2eKSHBzfKMrYoiAiIgz0PUVumd6RlOdhnrQsfMypJtkeHO5vDcHAc3v4fyK5ejlWWC7K41ZYX9QW3HvjLRNPvcdwJ8fhu7QzwcAtWvV3iO9CD8sdJXf8z6p/EyfaX0b1ETmfVfQz+q+Z9J3f806p/FSfaK+k+oacz6t6I/8A3Lq3+w8lk07svsyIvBIaCSQAOZK5St5RcNHVqWowST1pi6NnjF7HMwMZBw4A4IOQeRXN+cmlmp4SJ5DHvEeBXk3k7d/ibd2NvazjGOKC3RcEesUJbzacdjdM4Zbhrtp7O7G/G3dt7W3OcceS70BERAREQEREBERAREQEREBERBU6ppRv6po9sNhIo2XyuLx2tpie3s8PdOaf5eZWyIgIiIOe1Sq3ohFbrQ2Iwd2yVgeM+XB71G/TKEk8U76NZ80Ti6OQxNLmEnJIOOHHiuxEBEVZBatnpDbpSuhdXbBHNFtjIe3cXNIcdxB8XuAQWaKi0XV7d6yG2GwiKxB4TAI2kFjd23a7JOTgt4jHfwV6gIophKYXiFzGylp2Oe3c0HuJGRkfzCpYtXuzaBpVhvUNu3jGzcY3GJji0ucdu7OMNOBu8nFBfrlm0+lZnE89OvLM1hjEj4mucGnm3JHI5PDzqPSbj7+lwWZWtbI4EPDeW4EtOPNkLuQcsWn04LUtqGpBHZl/STMjaHv9LuZXUiICIiDO67oFnXbkb32WwRUwJqWzJIsg8JHjyNHDb37nZ7leQGY14zYbG2csHWCNxc0O78EgEj+SmRAREQEREBERAREQEREBERAREQEREBERAREQEREBYnWqdm10lbqsVCZ1Gg+NtqIMduukdoOa32wiLg4c9x3AeKFtkQEREBERAREQEREBervEd6F7L1d4jvQg/JnSl3/Neq/xUn2it96j2mQaxFq1exJYYwOjfmvO+F2e17ZpBxx5L530rfjpbq/8XJ9or6d6gpzNrHoj/wDcune7DybVdP6b63pOjVtGikjrSW3iR24mzZkmP8i8nC9bulT3XSj8r3YopW7TAxsOzGMEZLN3/wBytEXMarPU9GvGrajumu19mBlR3UPcQ1jWOG8ZaO0XOPDuHecLmbourtmZqGKJvMLWCLrHdUWCMsznbnO45xjlwz3rVIgzGm9HLOn26kYkifTrSsnEhcesc5tbqNu3GMe23bvNjvWnREBERAREQEREBERAREQEREBERAREQEREBERAVedJqHU36ifCBZe1rXEWZA3a05A27tuP5d58pVgiDip6VToTTTVoSx8x7RL3OA4k4aCeyMuJwMDiu1EQRyRtlifG4uDXtLSWuLTg+QjiD5wq6LQNOh08UWMseDt27GutSuczacgtcXZafOCFaoghrVoqlaKvAwRxRNDGNB5AKZEQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBervEd6F7LxzQfj7pa/HTDWP4uT7RX1H1AHbpdZ9Ef/uX1OXob0dnlfLLo1OSR53Oe+FpLj5SV16boOl6Q57tOowVS8Yd1TA3d6cLar1EVW9jDYrvRVRs4WaIi1WuIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiIPCIqjUrc8NsMjkLG7AcADzqjUX6NPbm5c4QlTTNU4hbrys5+ULfvh3yD7l4jr9KppWTM1fTG1XODhG6i4v2+Td1mM478fyVOj9oWdXnop4M125o4tIizfS+q+xTgc2sLWxzx4O6J72uc5hAd2WuwQeROBx5jmq3VqV+caYWx+EXhFHD1kkMnrErXt3yNdt2jODzLcgDG7kd1BtkWRrxUZrmt2Do0jYGxlrqrqDx4WWOLi85bteS7xcZPf7bAu9A078k6FUpFjGPYzMjYxhvWOO5+B3DcSgs0REBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERARF4ccNJQEWcGo2yATYd8g+5eHTazbPVaderwzeMX2YOtbjyYa5vH+a5tn2rpr17oKJ+Lf8Awsm1VEZlpUVbpMOrwxSDVrlW1IXdh1au6INHnBc7Kzuk0bUWpahEGugifDLC61HBIHzSlznNkduaMkDdxGRxGHcQF0lbaIvnkdUx6Lajn0RrobEzIqsTKMsjIX9XtfOWFgcPmjJ4Z47loY9KrydJaNptMZqVd7rckOJJHuGxuXEZJDQ/I/xNQaJERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERA7lntaOLw+AP6rQrN68cXm/AH9VyvbUZ0Vf29U7c4qy4t61FL2DB8ALH7lsaPsGD4AXJ/piMRc+3+UrtW1h0IiL1aoREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAXq7xHehey9XeI70LE8Bj9+FY6Kc3j8A/0VQ52CVaaCc3nfAP9F4b2ZT/ymfrP+WxXXmjDSIiL3TXEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAWX6RHF1nwFqFlOk5xdj+Aud7VjOkrjw9UapxGVUHq6gtdKA6JkOk6Y6mCA2V154eWeXb1fPHdlZ4P4rf0fYMHwAud7Ao2Yr+yNFe0oemVmWvTpiOwIQ+Zwc6S26qz9G/AdI3iOOCB34wqnWNWnLdHljuSt3Vg87pzC58m9gIbG3hJJ4wMbuAyt4i9EsYxurR+F6vJpN2awI8QGMSvsvbMX4dII8uLWMzyAAODw4Am56Kzus9GKEjpJ5XdXtL7G7e7BIyd3E+lXSICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgL1d4jvQvZervEd6EkYN7sSOHnXTRm1KN7naVVr2LGMFliYxN295yGu48u5cErsTPHnVz0YOb0nwF5HQW8e0Nr6yqpuZqwudJm1eaKQ6tTq1ZA7sNrWHShw85LW4Wfh1GRnTmWKW2WxmcxdU60d2OqZtzD4rWbuUg4lzg3vWyReuWvntTWIYXapJqt6wKzWkubHefvD+uIa13FvUuOWtDWnBGcnguo6lbjsdHYHW7MkQfGXz1xJLHO5+8bTI0YcGgccnjkO7luEQEREBERAREQEREBERARV8N+Z+t2tPkrsbHFDHNHK2UkvDi4EFu0bcFp7z/JVbelEjw3FBu+xsNIGfhK1z9mXdnsY4O9twPl4INGsDGY/wA6hZ2yHo8627qQCNjr/Ld8Au3AccdZk94K2em3fyhRZYMfVv3OjezO7a9ri1wz39pp4rxqWp0dIput6haiq12kAyyu2tBJwOKREzOIjeMx0p1PTZYKlbUKFKtqVouZXOrNhcK7BjfKTuc3A4YbntHA8pFlVbV0boTKOjQhuR1K0rqwicHiWQAnm3mS7njyr1/P7ol+8mmf5lv3p+f3RL95NM/zLfvVvQXflnyYzDhk1OWSpRbpvSY3X2LsUM0oZC4xtc1xIDWt7JOPbZIwvQaxfh1cVnao+S2y/HWGnvjjzLXw3dMcNDs4Ln7hhvDbhWP5/dEv3k0z/Mt+9Pz+6JfvJpn+Zb96dBd+WfIzCjg6QXn0r0R16u+3G1khsieA1WNMgBDXBmY3FuQBIHd3PBWg0vU5LvRWe3Fbd1rGzBti31ZbubntZjAa5nnHco/z+6JfvJpn+Zb96fn90S/eTTP8y3706C78s+RmFCOkuofkrFe/1rxbjhs3pJ4TBC1zHOy2WOItxuDW9phxu44yCuuPWbvV6ezUNeq1qkonLtSrSRva9zXN2RmR7AzOHOzhozs4Y4qz/P7ol+8mmf5lv3p+f3RL95NM/wAy3706C78s+RmFBftyVZek7vyw6WTq4pYK0whc2RnVs7YaW5IznlwVjJrd5uuuhF/Fkaiyu3S+rZ2q525l5b+Rc7dnbwxhd35/dEv3k0z/ADLfvT8/uiX7yaZ/mW/enQXflnyMw4dD1LVJJ9Gmt6g+wzUDYY+J0UbWs2ZLS3a0HOG4OSefcujWi6TWr7JfEh0aR0APunOIkP8AINj+d51N+f3RL95NM/zLfvUT+m3Qx9iOw7pBpZmjDmsf4S3IDsZHPkcD5AnQXflnyMwzP5Slm6MGpHqX5Qr/AJMhkm7DR4LLvjAZ2QMZBd2XZcNnPir2z0jnr3ZqL7jG3PyzDAyEtbv8Hds7seKcu7X+uV3fn90S/eTTP8y370/P7ol+8mmf5lv3p0F35Z8jMK3Q9Z1e9rsbLV+hHmWZs2nusN66Nrd23bH1QcDwbxL3AgkjmF161rE9DpJWjdqO2s/qWtp1nxdc5znkEuY9pc5nFviEEYcp/wA/uiX7yaZ/mW/en5/dEv3k0z/Mt+9Ogu/LPkZhn6l+7Rga6jC2WdtfW5o2GMOLpG227QD42OJ7IPHh5Au+9rU1fSIJdN1+PUGy2WR2bckkLG1WljjkubG4My4NHaa7G7+asfz+6JfvJpn+Zb96fn90S/eTTP8AMt+9Ogu/LPkZhww2rc0Og2pblW3a/KLoWTVZRI2SJzH7gXBrQSA3JwAMsCk6WHF2L4CuNN1PRtfcLmnW6101nFgkieHiMuAzy78YVH0wOLsPwFz/AGhRPQVU1cVV+cW5lRh/EL6NR9gwfAC+ZNf2gtfX17UY3RVmdGNTkiaQwWGvh2OHuhmTOO/llaXsmjZ2vsp0lW1lpkVVr9u5R0ie3SkgbLE0uDJoTJ1hx2WDDm4JdgfzUWrWtUqRUTXmp9dNNHC+N9dzt7nEbi0h42gND3cc8l2G4ukVC6/qgt6lWjmpvdBCJGSCB22JxJIY8b+0dvHgW93DiFZ6dYfb0ypZk2h80LJHBo4AkA8EHWiIgIiICIiAiimdI2GQwsa+UNOxr3bQ49wJwcfIVVM1uWTQ9Pux1GeE3ixscBmw0OcMnL9vIAOOdvdyQXSLOwdJzPJCW0sQZhZYeZeMUkjiwNAx2sOABOR4w5rRIMdqGnbelbKjOskoWopNSmpMDfXZonRtABJAAcXtcQeBcweV2eXpTc0a/Zq6bfg0+lqNmImWfURCZKtcOIyHEkFxOdoBOMlx5YOlvdI9G0yz4Ne1KtXmwHbJJA04PfxXP+efRv8Avuj9M371Hap5rIsXZjMUz5PW5NFpPQ4P0HqvB4ImMgfEOsYyPcGl4x421uXefC4X3Z7FnSaum9JH2obNiVs1qMQSOw2LcGgtZtHHB5d6sPz06N/33R+mb96fnp0b/vuj9M37026eaXu935Z8lLX13UDejZ+VGOtOsWYrNGSNm2pExsmyV2AHAZbHxJw7fwxwXNF0guP0mYfl2Lr4ZohNZfZrdS4Oa/LYZRHt3ZbnD25x5MgrR/np0b/vuj9M370/PTo3/fdH6Zv3pt08z3e78s+T0/Kc1joX4fWueDzPhyyxf2Mwc43OLRt9BALeRwQqCTpJffQqeD6gWQusSxT37U8LGBzWtLWtlbE6MtO48dvNpHArRfnp0b/vuj9M370/PTo3/fdH6Zv3pt08z3e78s+Spi1m06anDqevV6MLqjZGW6zozHbk3uBAfIzBw1rDhoGd/DgFxtsy1pNRjdqj5rA12u3wScRO6uN88WHBu3cOB4H+Y48Vovz06N/33R+mb96fnp0b/vuj9M37026eZ7vd+WfJTQa9ffqEbfyh1ll9izHY07q2f2WJgkLH8tw8WPi4kO6zh3Lq6OahqUlnSWXb77Y1DSfDHh8TGdXIDFnbtaOB6zvzyXf+enRv++6P0zfvT89Ojf8AfdH6Zv3pt08z3e78s+Sr1q7apzdKLsEnV26dCLwVxaHbGkPduwfK4HPl2DyLn1zUtZ03U3UWazXrxtrtlis35o4WzSFzst/QuDg3DeyC13a5nORb/nX0W8K8J/K9DrtnV7+ubnbnOOflUv56dG/77o/TN+9Nunme73flnyZvXdTsWLLq9vUmwyx6vQZHp7WNxJH1sDusBI3HtF3azt7O3GVedLdTn0xlWRmpR1IfXHSME0Uc0uAMdX1rXNOOORwPEcV0fnp0b/vuj9M370/PTo3/AH3R+mb96bdPM93u/LPkoorjzrUsrAQJ9Uph3XRDeAaoPEEdl3o5L3i166dAu3Y9TE+sMhc6TSyIx4Kd4BO1res7I8uc+TiFdfnp0b/vuj9M370/PTo3/fdH6Zv3pt08z3e78s+Sgkv3bPRjWJpNTo33VurmpvrWWzPbMDlrXObHG3i4NwMZ4nK3bvEd6FnZ+lnRWy1rZtXoPa17ZADM3Ac05B59xAP8loA9skW9rstcMghImJ4IV266I+KJh84ndixJ8Iq96JnN2X4Czll2LUvwyrHRL9ii6Wavp1i+/g3qq7mBwHuu25ox/PvXB0tvGsz4uXarzew+gIq3SdRs6jFI+zpVvTnNdgNsujJd5xsc5Qm3qDeksdMS1n03QPme0QOEkYBa1oLt+Dkl3tfalegdFcIs+27qpu6nC+7p7IKscbuvfVcBG45c5rvXeOGbTnh4y81dU1GWXRnTMgZHdY4SxmJweHBpcHDLuyCAOyQSM80F+iIgIiICIiAiIgIiIK06U78syak2/aa58bIzCBH1e1pzjxN3HJ7+/wBGOUdGKrWvDbNoHLeodubmuGv3gM7PLPut3DhyVo25VfcfTbZhdZY3c+EPG9rfKW88cQuU69o4ExOrUcQY63+0s9bydo3ceHHhx70HRSpx0KbK0Tnua3JLnnLnOJy5x85JJ/ms/wBPwHdHYARkflKlwP8AERrSwzRWIWTQSMkieMsexwLXDygrN9Pv1er/APUqX/kRq/TdtT4sTwaIVK2B/Z4vmBPBK3veL5gUw5BeVTtVc2cIPBK3veL5gTwSt73i+YFOibVXMw4mVK/h0vrEX6NntB5XKbwSt73i+YEb7Ol+LZ9blOm1VzMIPBK3veL5gTwSt73i+YFOibVXMwg8ErY9jxfMChp1K5pQf2eL9G32g8i7DyUNP2FB8W36k2quZg8Ere94vmBPBK3veL5gU6JtVczCDwSt73i+YFDPUr9dW/s8X6Q+0HuXLtUE/wCmrfGH7Lk2quZg8Ere94vmBPBK3veL5gU6JtVczCDwSt73i+YE8Ere94vmBTom1VzMMp0Ta1mv9LGsaGgakzgBj/8Ap4lydNDi5B8BdvRb9Yelv/Umf+PEq/pwcXK/wCo+0Y2omPpHpDU1c4sVM21/aHpX1Sj7Bg+APqXyRr+0PSvrlH2DB8ALR0VGztNf2dVna+zzYqw22MZOze1kjZQMkdprg5p4eQgH+S9XUoHywSPY5z4HukjLnuO1zgQTz8hI8wOAulFvumq4tAoQR2mRiy1tpznSjwuXiXHLiO12SfNhdlKnDQpxVK4eIYhtYHyOeQPJucSSuhEBERAREQEREEcjHSRPY2R0bnNID2gZb5xkEZ9IVTD0eZDpcFH8oXHNr7DBK7q98RbnBGGYPA44g8FbyPZFG6SRzWsaCXOccADylcx1TT20RdN+qKjjgTmZvVnjjxs45oOGLo3UhmrvZLYDIhHui3DbM5hLmufwzuDnE8CMnGc4V0uCPWdLmnhhi1KnJLOwSQsbO0mRvHtNGeI7LuI8hXegzNWJknT3Vd7Gu/sVfmM+2lWg8Gg/Yx/NCoqP6+6t/BV/tSrRqFMbmzfqmJjwj0Q+DQfsY/mhPBoP2MfzQpV5UsQ19qrmh8Ggx+hj+aFDTrQGlAepj/Rt9qPIus8lDT9hQfFt+pMQbVXN58Gg/Yx/NCeDQfsY/mhTImINqrmh8Gg/Yx/NCgnrQddW9Zj/AEh9qPcuXauef9NW+MP2XLOINqrm9vBoP2MfzQng0H7GP5oUyLGINqrmh8Gg/Yx/NCeDQfsY/mhTImINqrm4oK0HXWfWY/0g9qPctU/g0H7GP5oXrB+ms/GD7LV0JiDaq5ofBoP2MfzQng0H7GP5oUyJiDaq5s50zrwt6HasWxMBFWTiGj3JV5AMU4/gD6lUdNP1M1f+Fk+yVbw+xI/gD6lGI+JfVMzYjPOfSHy+27Fyb4ZWh6FnNyf4CzF12L0/wz9a0nQc5uWPgBc6xbxfz4vO6erOpx4tyubwKDwmSztcJpQxr3h7gSGElo58suPDvycrpRdR2ldZ0Whbq2K80TzHZlE0uyV7HOeNuDlpB9q3h5kdotN81SV3hLpKhzCTblOPhdrtf+rKsUQEREBERAREQEREBERBmoqF2LXQ803mFluSx4QHs9ca9gbtxuzwzk8OTBjJ4L3t6a6zJqli7RsWBLJCyCKvMGSdXEQ9rg7e3B6wud4wOAFokQcGkMtxaVXZdLjYDTu3ODnAZOA497gMAnvIVJ0/Gej0A48dSpcv4iNalZfp9+r1f/qVL/yI1dpu2p8WJ4S0IqR48ab6Z/3rz4JH7qb6Z/3qccgipZQeCR+6m+mf96eCR+6m+mf96nRBwtrR+GSN3S4EbT+ld5XedT+CR+6m+mf96M9nS/Fs+tynQQeCR+6m+mf96eCR+6m+mf8Aep0Qc5qR48ab6Z33qGrVjdUhcXS5LGnhK4d3pXceSgp+woPi2/UgeCR+6m+mf96eCR+6m+mf96nRBB4JH7qb6Z/3qCatGJa4DpeMmP0rvcu867lBP+mrfGH7LkDwSP3U30z/AL08Ej91N9M/71OiCDwSP3U30z/vTwSP3U30z/vU6IMp0TaGa90saM4GpM5nJ9jxKt6enFyt8Eq06LfrD0t/6kz/AMeJVHqhHFur8EqesjMzH0j0hpa7dp6v972Ua/tj0r6TX6XdHIBFTl1ugy03EboXTtDg7ljGeeV8vY/tt9K+y0q8JpwOMMZdsBztGeS1bNOzlqeyZzFX2c2ua0NHigxF1s08hYxh3Y4NLiTta53ADuafkyRBe6SRU7VKuxsUhsRiZ0hkd1bGEgbtzWO73cztHlIyF36jpzdQbCevmrywvLo5odu5uWlp8YEcQT3Ljl6NVJIK8AmsRxQxeDlrC31yHIIjd2fFGAMjBx38Sr3YR2NfmqQ6q+epE3wKVjGnwjsOa7bh73bewAHZd42ADzXfpGo/lXTIrgYxgeXDsP3tdtcW7muwNzTjIOBkELkl6PMnluvkv23C3JHLt9bxE6Nwcwt7HcWjxsjy5Xdp9CPTqng7JJJMvfI6STG5znOLnE4AHMnkAg7EREBERAREQV2t1ZbujWq8DQ6V7eywnAfg52/zxj+a4K8epxabqskFN8Nuw981eKR7MNc4bQDhxHNu4/C7zlaBEGaOkPpajpzNOq22GCOGB9rrwInQs3dlzN2XO7TsHbzdzWlREGZqxNl6earuLhilX8Vxb7aXyK/8Ej91N9M/71R0f191b+Cr/alWjUKeC/UdaPCPRB4JH7qb6Z/3p4JH7qb6Z/3qdFNQ5zUjx4030zvvUNWrG6pC4ulyWNPCVw7vSu48lBT9hQfFt+pA8Ej91N9M/wC9PBI/dTfTP+9Togg8Ej91N9M/71BNWjEtcB0vGTH6V3uXeddygn/TVvjD9lyB4JH7qb6Z/wB6eCR+6m+mf96nRBB4JH7qb6Z/3p4JH7qb6Z/3qdEHDDWjMtgF0vCTH6V3uW+dT+CR+6m+mf8AekH6az8YPstU6CDwSP3U30z/AL08Ej91N9M/71OiDN9Mq7GdDtWcHS5FWTnI4+1PlKvYfYcfwB9SqOmv6mav/CyfZKt4fYcfwB9Sh/cvq7CPGfSHyK+/GoWPjHfWrzonq1DSXWbOpXIKkB2sEkzw1u454ZPoKzuouxqVn4x31rUdAWsls2g9jXDaOBGVTRRivLy+kq/eebZ6ZrWma1HJJpl+vcZGdr3QSB4afIcLkr6+yzr8+mxxsDYnGMyOc4Fzw0OLWjbtOA73WeB4Y4q3ZGyMEMY1oPuRhVh0OH8p+HNsWGHrevEQLdgk2hhdxbnJblvPHaJGDxWy9C4IulL7dTUZ6dWGTwZjpImSTPjMrWuIJz1eAOyfFLvIcFS2+k3guo0ahrxE2mxOAdPte7rHbfW27e3t8Z3EYbxUh6NVxHZjZctsbNG+Jm0s9YY925zWZb3n3W7kMYR3RuB8kEj7tt5jbCx4PV+vCJ5fHuwzhgk+Ltz35QXiIiAiIgIiICIiAiIgycF5zOlLmPuyCc2ZI5q75TsZDsb1bgwnAy4sweZLiFXttGv4bXGr+F1TPC+xchtSesMdM4OYSXuDMDhlu3hzAwCt4iCq0CWSfRoZJJHyDc8RyPOS+MPcI3E9+WbTnvyqrp/kdHoMYJ/KVLGf4iNalZfp9+r1f/qVL/yI1dpu2p8WJ4S0Ifax+hh+lP4V532v2MP0p/CpxyCKllBvtfsYfpT+FN9r9jD9KfwqdEHC11nwyT1qLPVt4dYfK7/Cp99r9jD9Kfwo32dL8Wz63KdBBvtfsYfpT+FN9r9jD9KfwqdEHOX2sfoYfpT+FQ1XWfBIcRREbG4JkPHh8Fdx5KCn7Cg+Lb9SBvtfsYfpT+FN9r9jD9KfwqdEEG+1+xh+lP4VBM6z1tfMUQPWcPXD7l3+Fdygn/TVvjD9lyBvtfsYfpT+FN9r9jD9KfwqdEEG+1+xh+lP4U32v2MP0p/Cp0QZTooXHX+lm8AO/KTMgHI9jxKn9UY4t1PglXXRb9Yelv8A1Jn/AI8SovVJOLVP4LldqIzc+0ekNHX/APWq/wB72MY/1xvpX3Gj7Bg+AF8IY71xvpX3KlYhFOBpmjDtgGNwzyVGzhpexp3VfZ2oqrWdcr6Iys6xG9/hEvVMDXxs7W0u4l7mj2p70u65Xo6tS018Ujp7YJYQ+NoABAPjOBPPk0ErLtrVFSWuklenX1CaxVsxijMyJ4cYxv3loa5p34De0PGLVZ07LblOKyxpY2VocAXNdw9LSWn+RKDoREQEREBERBW69JLDoVySB72PbHkvZ4zW+2cPOBkqgdPDa0K3EzX21a0dwGC3NZcd0WQcF4e1xaXCRoO7jt71sUQYeDUrE1vT3umnhsuZU8Grde8tljc4iV2HHL+zk5dkjDTwzx3CIgzNUyjp5qvVsY7+xV87nY9tL5ir/fa/Yw/Sn8Ko6P6+6t/BV/tSrRqFPBfqOtHhHog32v2MP0p/Cm+1+xh+lP4VOimoc5fax+hh+lP4VDVdZ8EhxFERsbgmQ8eHwV3HkoKfsKD4tv1IG+1+xh+lP4U32v2MP0p/Cp0QQb7X7GH6U/hUEzrPW18xRA9Zw9cPuXf4V3KCf9NW+MP2XIG+1+xh+lP4U32v2MP0p/Cp0QQb7X7GH6U/hTfa/Yw/Sn8KnRBwwus9bYxFET1nH1w+5b/hU++1+xh+lP4Ug/TWfjB9lqnQQb7X7GH6U/hTfa/Yw/Sn8KnRBm+mTrB6HatvijDfBZMkSE+1PmV7D7Dj+APqVR01/UzV/wCFk+yVbw+w4/gD6lD+5fV2EeM+kPi2pvxqlr4131rW+p0c2rfwQsbqrv8Ai1v4131rW+pzKxlm4572tG1vFxwpbON7yej/AO795fSEXoyRkgJY9rgPcnKramuV7utXNLjjkEtThI8vjx4rTwaHb/bDiW44FZelWqKhg6UV7VDULkFOzKyi5zXsY+EvdtJDsDfwxgntbThTHpBW/LFbTBFIZp4WzNJfG0Brt3c5wc49k52g4QXCIiAiIgIiICIiAiIgooNXtya0IXth8DksSVowGkSBzGbtxOcYOHDGPJxUE+o6412owU2Vbk8Bh2GOEtDdz+2wh0gDnCPteM3mOHFWg0ekNQfeETxYcclzZXgZ7PHbnAJ2tBOOIGDkKKHo/QrwzRQ+GMZM8yPDbswO4u3Eg7+zkk5xjKDo0y34dpsNgu3Oe3D8RlmHA4cNuTjBBGMn0qi6fnHR6A8eGpUuX8RGtHVrQ0q0dauzZFGMNbnP+p4k+dZ3p9+r1f8A6lS/8iNXabtqfFieDQi3HjxZvoX/AHLz4XH7mb6F/wBynHIIqWXP4VH7mb6F/wByhs6pTpwOnsyGGJvjPkY5oH8yFJevV9OpyW7crYoIhlzj/wDzn5l891LWJ+k8YZNE2vUEnWQxbWyOe3A2l59o7xuA8pB8rqb9+ixbmuucRCm5d2fhp3zyWz+m4luOfpumy2YnDZ1krxEDtJwRwJIOe/C8S9PpKrmGzpLmRnxnRy7yP5YH1rmrRxQs2sYMdy4NdiL6sjWtaMMJ547l5ux7euXdRFvZiKZlC/av27U3Iq3+CzpeqlpEs7o7texUbvIbJje3b3F2OIJ5YAPpVjb9UPo3W0/wtl7wjJw2GJvrh4+5djH88fUvhMzyJXelcM9javcU6Wmre1tPfvVxiX3er6qnR2xKWS+F1mhud80WQfN2S4/6dyiHqo6DVYyBsdycMY0dZFG3aTgctxB/0XwJ10gqWPUMqc6SnultV06iI3YfoGv6p3RyaFz5Zp6zg7AZLCST5+zuCppfVhqCN5i0iZ0glIaHTBoMfc4nBw7/AA4I86+QCd0o4I5xY3KRpaFHSXeEzvfaYvVd0V0bTLSvtk2je1jWOAPeAdwz8gXZS9Ujo/qdmJjpZqhY/ObLQ0EbXd4JA/njmvz6+9h2MoL/AA5p7nS2Ip1D9V1tUp3a7Z6spnhdnbJExzmnjjmApvC4/czfQv8AuX5s6M9KLOiWvDq9zEkORFVeHOZKX8HbsEADDQeechnA8S37X0T6e0uk0z6r4fA7nOOJ0m8SNxxwcDiOPDycePHGrdsVUeCe3idmvdLU+Fx+5m+hf9yeFx+5m+hf9ynRULGU6KOD9f6WOGcHUmcxg+x4lQ+qacWqXwXLQdFv1h6W/wDUmf8AjxLO+qecWqPwXLZvdr9o9IaOv/61X+97DRu9cb6QvsVfoj0cnEV2XRKD7TsSOmdA0uLuec455XxmN3rjfSF+gKXsGD4AVVyMNL2Pwq+yDVKlq7TdXrTwQiRrmSGaAy5aRjgNzcH059C5bWj2bNSvS8MiFSMs3gwF0jgxwc3Dt/A4ABODx4jCuUVbtqaPTdShuajZivVM2nsdGHVHHq9uBx9c7XZH+Hjx8y7NLo/k2g2sZOsdvfI9wbtBc95ecDuGXHA8mF2ogIiIKAdJZZXyivoGq2I45pIetj6na5zHljiN0oOMtPMBWun3Y9R02reha9sVmFkzA8YcGuaCM+fisJNd1SLXn06FuWno9yzM3rdjHyMk65sUhYD4oMsnfu5k4wt9UqxUacFSu3bDBG2KMeRrRgfUgnREQcOrXH0NLnsxNa6RjcMDuW4nAz5slcUd+6/Tbpls0689KZzJbD4XGLaGh27bvBHZcPbeVWtmvFbrS152B8UjSx7T3gqvk6PabLS8EfHOYC9sjh4VLuLg4uDi7dknJznPcPIEHBDrGr+G6c+5VZXo2YId7+pyRO/dlhPWAs9pjsO8bBK0qrvyPTM8EzxYe+DHViSzI9uRycWl2C7j4xBKsUGZqyti6earuDjmlX8Vpd7aXyK/8Lj9zN9C/wC5UdH9fdW/gq/2pVo1Cngv1HWjwj0QeFx+5m+hf9yeFx+5m+hf9ynRTUOc248eLN9C77lDVtRtqQtLZchjRwice70LuPJQU/YMHxbfqQPC4/czfQv+5eDciAJLZsD/AOS/7l0LH+qJrFzR+jTX0pOqknmEJkHjNaWuJ2nuPZ5+fyrNMZnCFdcUUzVLik9VfQWSOa2vfka1xG9sbQHDyjLgflSD1T9Au3q0Lm2q46zjJMxuxvZI44cfKvh9631Ldo5rkq6hmTtFb8aSJhrW51FVG2/VVbVKlyBs9aUzwu8WSNjnNPHHAgKfwuP3M30L/uXwfoPrdvTukdIVZfWrc8cM8Z4te1zsZx5Rngf6Ehfflp3LfRzhdZu9JG+MTCHwuP3M30L/ALk8Lj9zN9C/7lOirXOGGzGJbBLZeMmf0Tvct8yn8Lj9zN9C/wC5IP01n4wfZap0EHhcfuZvoX/cnhcfuZvoX/cp0QZvplYY/odqzQ2XJqyc43D2p8oV7D7Dj+APqVR01/UzV/4WT7JVvD7Dj+APqUI6y+rsI8Z9IfDNWd/xi58a761pugml0NYNytqVOC3ANrxHOwOG7jxwfSVltXd/xm58c761svUwObV74LVs1R8Lymjj9795bzTNF0zRY5I9MoV6bJDue2CMMDj5ThQyadbm1eK5Jbg6uDd1Mba5DgHYDtzt/HgDjAHHB44VqipekUU2i3bHh8kl6v4RZr+DRubVIaxmXHtN35ce0e8DzL2fpF2eKjBPdrmCu6J7wysWve+N25u1xedo4NyMHv48eF2iAiIg4dU1Bul0XWnwTTgPZG2KHbvc57wxoG4gc3DmVxQdIJH36tWxoupU/CZDHHLP1JZuDHPwdsjjyY7uXv0l2HQZw8Slznxth6kgPExkaIiCeA7e3nwVH0Xk1PV9QdLrloOsac9/VwRRtbHndJDvLubj63IO7ny4oNoiIgKGCxBZa90E0crWPdG4xvDtrmnDmnHeDwIUyy0HRu1RE17TZY62pPs2JZGnJhstdK9zRIB37XDtDiPOOCDSwzR2IY5oXtkikaHse05a4HiCD3qRV2hVZqPR7TKlgBs8FWKKQNOQHNYAePpCsUHDHqtOTUn0GTE2GZy3Y7GQASA7G0kBwOAc8VAOkGmFs7hYeeocGuAiflxLto2DHby4bezniuWPSbsesCYeDmrHZfZYescHkvbtc0jbjAy8jjx7I4c1xM6O6iwQu3VS6iI2VR1jsStbJuPWdnsktAHDdxyfMg0tWzDcrR2IH74njLXYI/0PEHzLO9Pv1er/APUqX/kRq60mnJR09sUzmmVz5JZNh7Ic95eQPMC7H8lSdPwD0egBAIOpUsg9/wDaI1fpu2p8WJ4NSOQXnKgFOrj2NF8wJ4HV97RfMCoZYbpBZ/KvSqKKC4Xw6ftd1bBlomy7JJ73Dsjvxx5ccnU2MycbvajJ5dyg1eKv0f6XlsYMFW6wzbnglnWZO4DA9Bx3bvIu100M4DmP+ReK/qCb/T/F1O5DR7EzVtdbKGGIs4A5xxwVNPWbbruDhjgvYDa3hleN5bC8k4yFwKKp24mG9VFOxMS+OaxB4LemYDkBx4rMWp+0VpukMv8Aa53E83FY+w/c4r7TponoaZni5Xsy3mjal437kDyHKNrHFSMYd62I3uxMRha1JSAF0WH+trmiAZGCo5pC8YSI3ub0cVXMq2xLh5UInJXRLFk8lC6HHFYl1KdnD2jnIcFptDvywWoZ452wywu62N7hnDm9ocMHvAHk8vBZuCuXu4BazozortT1mpQLpGeEP2b44+sLfPtyOA5njwGT3KNUxszlpazYmnHe/UYOQOK8qAUquPY0XzAngdX3tF8wLioM70W/WHpb/wBSZ/48SzfqpHFqj8F39FouijGx690saxoa0akzAA/+niWb9VQ4s0Pgu/otqvto8I9Glrozp6v972BjPrjPhBfoWj7Br/AC/O8Z9dZ8IL7VX6I6dM6K66xqYlcRIWt1GZrM8/FDsY83JQvxwansmMbX2aCxYhqV3z2Jo4YYxufJI4Na0eUk8kmsQ1wwzzRxB7xGwvcG7nHkBnmT5FR9MdN1DVtEmqUYoZg6KTdFJMYy92whmDtI4OIdxxxaOKh12hq+oyUZoqddzYJoZDE+ztLXtnYXPHZIcNjTg8DhzuGeCodhdnVdOEdiU6hVEdZ/Vzu65uIne5cc9k8uBXRDNFYhZNBKyWJ43MexwLXDyghUDn6pVta3PW0aaWR7ozWDpIg2UgBufH4e6444Dyq00WuamlQxOjljf2nPE23cXucXOJ2ktGSScA8MoLBERBhrzmV9cpyOdoUrYtQ2RwtkeZ2dbK3cQ3dguzhx4cME9y2dixDViM1iaOGMFrS+Rwa3JOAMnykgfzWSjj1c6u6WGiIXV7h62Q1Yx4RHJYwMOxnDYcuJHHcRnPELQa7pv5V0wVDHHKx1iB8jJBlrmNlY5wIPPstKDukmjjfGx72tdK7YwE4LnYLsD+TSf5FSrMM0LUaWraXHWsCbR69h0vVzOJlr+syMDWu9szLxwPFvlI5adBDZsRVK0tid4ZFG0ve49wC5fy1R/J/hvWydTv6vHUv6zfnG3q8bt2e7GV7atTff0uetE5rZHtywu5bgcjPmyFVjStSMbpyyoLfhguCPrndXnbsLN2zPiYOceMTw4cQsGa7psk9aFljc6yxr4yI3bcOzty7GGk7TgHBOCrJZWt0cuwPhjMtd0Mj4JrD9zg5skchkwwY4tJ2jiRgA88rVIM5R/X3Vv4Kv9qVaNZmrDHL081XrI2vxSr43DPtpVf8AgdX3tF8wKFPBfqOtHhHonRQeB1fe0XzAngdX3tF8wKahMTwUNM/2KD4tv1IadXHseL5gUNWrXdThc6CMksaSS0eRB2ZXyT1XtWsC5V0oForNiFgjHaLyXt5+YD/U+bH1TwOr73i+YF8G9UhgZ021FjGhrR1eABw/RtV+mjNxr6ifhiOcvntovkccrlHYKtrDW4VXO09y6057m9Yq2oiIaXotqDaer0bcoc6OvYjlcG8SQ1wJx5+C/T1WzFcqQ2YH74ZmCRjsEZaRkHivyhpLTtzhfafUokdaq6lWn2ywwGN0bXtB2bt2cfIOH3laGspz8TQmuKdRNEd76cig8Dq+9ovmBPA6vvaL5gWi2XiA+vWfjB9lq6FxQ1K5lsAwRkCTA7A4dkKbwOr72i+YEE6KDwOr72i+YE8Dq+9ovmBBUdNP1N1f+Fk+yVbw+w4/gD6lRdMq1dnQ7VnNgja4VZMENA9qVew+w4/gD6lCOsvq7CPGfSHwXWT/AMau/HO+tbT1LTm1f+C3+qxGtH/jd34531rUdANLg1ht6vYksMYCx+a874XZ4+2aQcceS3a4/TeY0kfu/N9cULbEL7EkDJo3TRAGSMOBc0Ozgkd2cH5CuPSdGraNFJHWktvEjtxNmzJMf5F5OFT6ZQ1ulrGqWZalUyXIGBs7bBc0yNdMRuBaCGgOY3hnht58car0C9k1TT4ml0t+qwCbwcl0zRiX3HPxvNzXu2/TdddSbbgNtrdzoBIOsA8pbzxxHyrJxaTq1PRdUru03rpZrsMsYgsNeZMMi3vJfs4lzHefJPDHE3OLlvpJC+fTZ4qdZu+GXfEQ6RzMEuw/dwBLQMcyTywUF6iIgr9abu0qQ76jC1zHtfbJEbSHggnBHeBjz4VL0Ve0anq0I/Jj3Ex2Hy0HOcHOkMhIcXE4OQTtHLdnvVtrwlOkPMMBnIlic+IRiQujEjS/DTzO3dj/AEXF0bj1GJ1gW4Gw15WMniibC1nUuc5+Y+zz2tEeSe8nj5A0KIiAiIgIi4LcuqMmAp06c0WBl01p0Zz6BG760HeiyegQSVdSfI+pPE/Y5l2QwuAmmdL2HA47Qxu7Q4AOGcY4cbqOm6jHq/WUblCrJJC3qotNfukMcu7rS0xlr9zvM7sjJ58A26y/T79Xq/8A1Kl/5Eat9CErdEqNnhEL2s2hgjEeGg9nsjxSW4OO7kqfp/k9HoMYB/KVLGf4iNXabtqfFieEtUOQRc4Zax+mh+iP4l52Wv20P0R/EqWXpcoVdQhEVuvHMwO3BsjA4A+UZ71htc6OXND229JbYt1QTvrN7UjCc4LeHabkjhz8/eN5stftofoj+JeNlr9tD9EfxKu7Zt3adm5GYU3LNNe/hPN8+0rVo7kT2St6ueMlr45ODmkHBBb/APz/AEU81jDH+VaS1odfUNWbZtRQSzwxANe6N2MEu4Y3cf55VfJ0LLo3MGoyeLhpcwHH3rzeo/p6npYrszu5SzNy/FGzO/6vi2u14bFq6583Vua3dG3bnrHbgNue7sknP+HHesv4GN3EL7XqXqT2p2SS19WhdNnsskhLWnjxy4E4+RZX/wDTXpT/AHV//sRfiXt9NdpptRTM8Grp6r1mjZmlgRT8y9H1y3kF9Mpepb0in39dBXq7cY66YHd6Nm7/AF8q6WepPrU0TJGz6dhwDhmR/wCBXzqaOa73m78svmcMD3s5Lw+oQvqcHqS6yJGNkt0GRlw3ua57iB34G0Z+UK9b6kWnFgEuo2nOxxLWtaM/6qM6qiEaa781ZiHww1S7hhePyU+RffKnqUaJWmL5JJbTS3GyYkAHy9gtOf5961MGnjTYKVOoIIYI3bY2MjOB2Xf4uPf/AD4qurWx3Qviu9zw+K9FPUx1DUZHC5Wmpsilj3unDoi6M7t4YCw7ncB3gDz54fadH6N6PoO78m0IoXuyHP4ueQccNzsnHAcM4Vhstftofoj+JeNlr9tD9EfxLUuXqrnFKKd+Z3y6EUGy1+2h+iP4k2Wv20P0R/Eqkmd6LfrD0t/6kz/x4ll/VVOLND4Lv6LTdEw4a/0s3kF35SZkgYHseJZj1WDizp/wXf0W3V20eEejU1cZsVPnsZ9dZ8IL9GUvYMHxYX5wiPrrPhBfo+j7Bg+AFHU9zW9mxja+zoREWs6giIgL1c5rGlziA0DJJ5BeyhtV4rlSatOwSQzMdHIw8nNIwR8iDD6jpNyO2dUg0rRIJnai0RusMcZXEzhofnIGSO1w8vlW4rRCCrDCGsYI2BoawdkYGMDzLOw9FpaOsx34LQvje3s6mXSyQt7+qk9rw7iDk+2C1CAiLweXDmg8os1qw1SzUjZqGmVnUmzxunjrzvsOewOHDZ1Tdw5E8+XIqJzmVuiLIreky3SzBiqPrPkAa57urDgGnxW43cCW45cshqkWLh0uKtqujWKzbVm7HXgruM9Ahgibvy7e5mY3dp3Z3dzQQVtEGco/r7q38FX+1KtGszVEp6ear1b2N/sVfO5ufbS+cK/2Wv20P0R/EoU8F+o60eEeidFBstftofoj+JNlr9tD9EfxKahOeSgp+wYPi2/UvBZax+mh+iP4lDVbZ8EhxLEBsbgGM8OHwkHavhPqm1JY+mduR7MNnZHJGc827A3Pytd8i+37LX7aL6I/iWd6T9Douk0TDNNHDaj4MsMhydvuT2uI+o/zzbZr2KsqNRRVXR8PGH52liJOCoTU3nGF9bu+pBdbs8D1KvNnO7rmOjx5MY3Z7/IuQ+pRrUTmNNnT8vdgeuP8hPuPMuhGqowqpu3qIxssTo+nPsW61KItEk8rYml3LLjgZ+Vfono9ocHR7R4dPgO/bl0kpaAZHHmTj5PQAO5Z3oh0EPR5xu2Za8uoHLWuDC5sQ/w8uJHM483lzsNtr9tD9EfxLRv3uknclYtzmblfGXQig2Wv20P0R/Emy1+2h+iP4lQ2iD9NZ+MH2WqdcMLbPW2MSxA9Zx9bPuW/4lPstftofoj+JBOig2Wv20P0R/Emy1+2h+iP4kFR01/UzV/4WT7JVvD7Dj+APqVF0ybYHQ7Vt8sZb4LJkCMj2p86vYfYcfwB9ShHWX1dhHjPpD8/62f+OXvj3fWtv6lJzav/AAW/1WF1s/8AHb3x7/rW49Sc5s6h8Fv9V0LkfpvO6aP3Pm+pIiLSdsREQEREFVr0TrOkyVmVIbj5XRtEE3iEb2guPeQ3O7+SpOj2lWNP6Q2a7qmjxQRRRSnwSNzX7z1rRzce7PP3XDvV5rGiQ6xG3dZt1J42uZHYqTGORjXY3DPeDtbz8gUPR/SZtHimrvZSMeQWzV4jG+Q8cmQZOXcu1njx4BBdIiICIiAiLguazpenzCG7qVOtKRuDJp2sJHlwSg70VDo+r2rtxrZ2wdTYifPB1bSHMa1+3DiSckgtPDHeuNmt6tG+erbihguvnjZXa6DsCN8haHkiR2/gOXYOfSg1Ky/T79Xq/wD1Kl/5EautJuSXtPbLM1gla+SKTYOyXMe5hIz3EtyqTp/w6PQHBP8AxKlwH8RGrtN21PixPCWqHIIucTyY9izfK37156+T3pN8rfxKllOig6+T3pN8rfxJ18nvSb5W/iQG+zpfi2fW5TrhbNILkh8Glz1beGW+V3nU/Xye9Jvlb+JBOig6+T3pN8rfxJ18nvSb5W/iQTnkoKfsKD4tv1IZ5MexZvlb+JQVJpBUhArSkBjeILePD0oO5FB18nvSb5W/iTr5Pek3yt/EgnUE/wCmrfGH7Lk6+T3pN8rfxKCaaQy1z4NKMSHvbx7J86DuRQdfJ70m+Vv4k6+T3pN8rfxIJ0UHXye9Jvlb+JOvk96TfK38SDOdFv1h6W/9SZ/48SyvqtHFnT/gu/otT0TcXa90sJaWn8pM4HmP7PEsr6rhxZ074Lv6LcmP148I9GtqN9mXzmI+us+EF91gq9KC6J8OraY2mSC2J1F5eGeTd1nPHfhfB4j68z4QX6Wo+wYPgBY1UcFGgjG0qOlsEVnRJIXV2zSuB6ndRfZ2uweIDfFPkd3Lj1qLwqDS9tJzr0csR7dSSR7dr27g2bGI+R7R4OHpytWi1HQYF+mzPba/skrHt3uvdZXkLbbhZa9jey0l7SwPGWh2GvAI7lpujUNiDQoWWoxE/rJXNiaCBHG6RxY0AgEANLRggYxyCuEQEREBERARF4JwMnkg8oqG30kpTNig0nUtPsXJpWxtDZWyhgJ4uLWuyQB5xxwj9S1Wx0eitUK0cl7rerkYG5b2Xlry0Oe3yEjLkF8izEfSGzNLBLEYX1B4MybMTmve+Z23LRu7IaccDu7+PDjp0Gco/r7q38FX+1KtGszVe5nTzVdsTpP7FX8XHupfKVf9fJ71m+Vv4lCjgv1HWjwj0TooOvk96TfK38SdfJ70m+Vv4lNQnPJQU/YUHxbfqQzyY9izfK38SgqTSCpCBWlIDG8QW8eHpQdyKDr5Pek3yt/EnXye9Jvlb+JBOoJ/01b4w/ZcnXye9Jvlb+JQTTSGWufBpRiQ97ePZPnQdyKDr5Pek3yt/EnXye9Jvlb+JBOig6+T3pN8rfxJ18nvSb5W/iQIP01n4wfZap1wwzSCWwfBpTmQd7eHZHnU/Xye9Jvlb+JBOig6+T3pN8rfxJ18nvSb5W/iQVHTX9TNX/hZPslW8PsOP4A+pUXTKZ7uh2rA15Wg1ZOJLeHZPkKvYfYcfwB9SjHWXz2EeM+kPzzrp/49f+Pf9a1nqcx6lM2+3SrVevYywl9iEyt29rIwHN48u9ZDXT/x+/8AxD/rW79SM5s6j8Fv9V0bvZOFYj9x5voekw6vDFINWuVbUhd2HVq7og0ecFzsqrdExnTSO1DUIb1bmWJGUZGOLjtALpcYkHLgPF5k4HDTItB1mFnph1/UJIdOcdOfJXM8cVCSHrA2VxeCwj148clzRxAxg98bNNvC3proqp3mSIwmSKQOqQNsPeWh23a3MJDS0uaeyBg8At8iAiIgIiICIiAiIgIiIK+vo9KrNLNBE9kkrtziJX8O1uwBnsguJJAwDnio/wAgac4Th0czzMW73vsSOeNrtzdri7LcO4jbheaGswahafBHFNGQHOjfIBtmaHFpc3BPDI78cx5VxXOlUOnm54Xp9yHwUQlxe+EBwlk6thB6zAGQT2scAguataGnWjr12bImDDW5J+UniT51nen36vV/+pUv/IjWirTi1Vina0tEjA8Aua7APnaSD/IkLO9Pv1er/wDUqX/kRq7TdrT4sTwakcgi8DkF5VLIiIggZ7Ol+LZ9blOudh/t0vxbPrcuhAREQDyUFP2FB8W36lMTwUNM/wBig+Lb9SCdERAUE/6at8YfsuU655z69W+MP2XIOhERAREQZXot+sPS3/qTP/HiWS9V44s6d8F39Frui36w9Lf+pM/8eJY/1YTizpvwX/0W7/6I8I9FF6M25fN4nevM+EF+maPsGD4A+pfmKI+vM+EF9/gtdKA6JkOk6Y+mCA2V154eWeXb1fPHdlNX3KtJGMtMiz/Sy3Vq6WwWLbq88rjHWItOrgyEHBc4EdkcSc55cicBc2sahS8I0quzVw29LI3ZI231cZa146wuaHbXE8WhpB4nzEjSbjUovn82oXmxWjWvSGc7hf6yVxbV/tLGg4z62BEZT2ccGh3nWq6OzmxosT928B8jGyiRzxIGvc0PBc5ziHAZGSefMhBbIiICIiAiIg5rlOC9WMFhpdGXB3ZeWkEHIIc0gggjmFCdJqeCNqsE8ULGta0Q2ZIyA3OOLXA95ye/vypL91mn1hK6OSVzntjZFGBue5xwAMkD5So2akJ9MZerVZ5w/wD+CzY17TnBB3OAyCDnj3IPRmhabHPXlZW2ursayMB7g3Dc7ctzhxGTgnJGSrJUFHpVUvX6VOOtOyS3VZbZ1j4m4Y/djs79xPYPig4yFfoM5R/X3Vv4Kv8AalWjWco/r7q38FX+1KtGoU8F+o60eEegiIpqA8lBT9hQfFt+pTE8FDTP9ig+Lb9SCdERAUE/6at8YfsuU655z69W+MP2XIOhERAREQQQfprPxg+y1TrngPr1n4wfZauhAREQUPTX9TNX/hZPslW8PsOP4A+pVHTT9TdX/hZPslW8PsOP4A+pRjrL57CPGfSH5z14/wDMGofHv+tbz1ITmzqPwW/1WA18/wDMOofxD/rWw9TOXUom6i7S6tazYzGCyxMYm7e1k5DXceXcunej9Hyci1T+rl9mRVukzavNFIdWp1asgd2G1rDpQ4eclrcKri1Ck7pjLBBqW10LCy1FLbJDpHbdjWRl2BjvLQPGA4knHOdBpkWGdqNaaTUJKeqyfk9tiCGwfDnOezEpEjwd2Y2cQ3IxycRgYKii1K8NQ0/rbRfWHViqx80jX2musPZuG1w37YxE87g7ge7JKDfIiICIiAiIgIiIC4LmlV7swklkuNcG7cQ3Jom/IxwGfOu9EFLp+hy0LPWC22RkTTFXaYsdXG5+5zSd3aPAAHhjA4Hvnbp1iF16avZiFm1M2QPlgL2sa1rWhu0OBPInnzcVZog4tMojTdOiqdZ1hZkl23aCSSTgdwyTgdwVF0/APR6AEAg6lSyD3/2iNalZfp9+r1f/AKlS/wDIjV2m7anxYng0Qp1cexovmBPA6vvaL5gUw5BeVSyg8Dq+9ovmBPA6vvaL5gU6IOJtSv4ZI3qItojacbB5XKbwOr72i+YEb7Ol+LZ9blOgg8Dq+9ovmBPA6vvaL5gU6IIDTq49jxfMChq1a7qcLnQRkljSSWjyLtPJQU/YUHxbfqQPA6vvaL5gTwOr72i+YFOiCDwOr72i+YFDNUriWuBBGAZMHsDj2Su1QT/pq3xh+y5A8Dq+9ovmBPA6vvaL5gU6IIPA6vvaL5gTwOr72i+YFOiDKdFGtj17pY1rQ1o1JmAB/wDTxLH+rGcWNN+C/wDotj0W/WHpb/1Jn/jxLGerKcWNM9D/AOi3v/RHhHoqrjNEvmcR9eZ8IL9Q0vYMHwAvy1C715nwgv1JR9gwfAH1Jre5GzGMulERaK8REQEREBERAXgjIXlEFJP0diLWSVbVqOxG9skb7FmawwEHvY5+DkZHcePNSDSJW6FNpjbm3rYnMMwj7Qe8uL3Dj37uA7vOrdEFVa0qWzZqNE8MdGu9kjYWweubmcsP3YDeXDb5ePFWqIgzNWGOXp5qvWRtfilXxuGfbSq/8Dq+9ovmBUdH9fdW/gq/2pVo1Cngv1HWjwj0QeB1fe0XzAngdX3tF8wKdFNQgNOrj2PF8wKGrVrupwudBGSWNJJaPIu08lBT9hQfFt+pA8Dq+9ovmBPA6vvaL5gU6IIPA6vvaL5gUM1SuJa4EEYBkwewOPZK7VBP+mrfGH7LkDwOr72i+YE8Dq+9ovmBTogg8Dq+9ovmBPA6vvaL5gU6IOKGpXMtgGCMgSYHYHDshTeB1fe0XzAkH6az8YPstU6CDwOr72i+YE8Dq+9ovmBTogzfTKtXZ0O1ZzYI2uFWTBDQPalXsPsOP4A+pVHTX9TNX/hZPslW8PsOP4A+pRjrL57CPGfSH5s6QH/mLUf4h/2lv/UcObGpfBZ/VfPekR/5j1L+If8AaX0D1GjmxqfoZ/VdW92Hk59FOK8vrqIi5jZEREBERAREQEREBERAXBbl1RkwFOnTmiwMumtOjOfQI3fWu9EGe0YwVtX1tsdOeBsltr8ipIxsjixjS4Hbh3aByR6eXFUMenzBjt+n2OrBi/KbTXcfCXibJcBj1wYyTjOWkDzLfogqtAikg0aFkkb4xueY43jBZGXuMbSO7DNox3YXr0i0NvSHSvAXWpqpE0cwlhDS5rmODh4wI5gK3XPLcrQWIa81mGOewSIY3yAOkwMnaOZx5lmiuaKoqp4jO/mrq/76ax9FX/2k/NbV/wB9NY+ir/7S0U9yrWliinswxSTO2xMe8NMh8jQeZXQrveLn08o/DGIZX81tX/fTWPoq/wDtJ+a2r/vprH0Vf/aWqRPeLn08o/BiGU/NTVQ8v/PPWNxABPV1/wDa868/mtq/76ax9FX/ANpaKG7VszSxQWYZZYTtlZG8OMZ8jgOS9a2o0rskrKlyvYfC7bK2KVryw8Rh2Dw5H5Fj3i59PKPwYZ/81tX/AH01j6Kv/tJ+a2r/AL6ax9FX/wBpapFn3i59PKPwYhlfzW1f99NY+ir/AO0vDeimrMYGt6Z6wGtGAOrr/wC0tG+7VjtsqPswtsyDcyEvAe4eUN5nkjLlWS2+oyzC6zG3c+ESAvaPKW8xzCe8XPp5R+DEM7+a2r/vprH0Vf8A2k/NbV/301j6Kv8A7S1SJ7xc+nlH4MQyv5rav++msfRV/wDaXh3RTVnFpPTPWCWnI9br8P8A/EtWuNmqUJKkttl6s6tDkSTCVpYzHPLs4Ce8XPp5R+DEKH81tX/fTWPoq/8AtJ+a2r/vprH0Vf8A2lo69mC5XbPWninhdnbJE8OaeOOBHNTp7xc+nlH4MQyv5rav++msfRV/9pPzW1f99NY+ir/7S1S57FyrTEZtWYYBI8RMMsgbueeTRnmT5E94ufTyj8GFX0e6PHQjekfqNm9NdnE8stgMByGNb7UAcmhfPPVoOLGl+h/9F9XmuVa0sUU9mGKSZ22Jj3hpkPkaDzK+S+rWcT6X6H/0UrFdVd+KquJMbsPmELvXo/hBfouvr2oxuirM6ManJE0hgsNfDscPdDMmcd/LK/N0LvX4/hBfq+j7Bg+AFdre5imMOTWrdqlSjnquhBFiJkglYXbmOeGkDDhg9rnx9Cahat1tS0uOJ0Pg9md0MzXsJf8AonvBa7cAOLO8Hn3KfUNOrapVFe2JTGHtfiOZ8RyDkcWEHnxUU+jVLLqrpfCS6rIZIiLUoIcc8Th3a4EjjngcLQSVdfWdQsveN1eNs0U01ciu+QxtikDSHNDsvJDgRtxxyOKs9EvyalpMNqXZ1ji9rtjS0dlxb4p4tPDi08WnIPJeBoVBrrDmRyxusHL3R2JGkdrcdpDuxl3E7cZ7111asNKs2vXYWxNyQC4uJJOSSTxJJJJJ4nKDoREQEREBeDy4c15RBmtcbfudHdTg1LSqr4XVnhrK8r7L3Se1Gzqh34Oe7C99Tcy5pNIPq2JqrZIn2oDWeS6PiMFhbl2HBpLcZwOXFaJEGEp0LTLVHradjwoCsasronHqIWvcZGOdyaer4EHnlvPHDdoiDPXujk1nWZdSq6vbpSSxMie2FrCCGkkeM0+6K9fzd1T96dS+jh/Arqvcq23SitZhmMLzHKI5A7Y8c2uxyPmSG5VtSTR17MMr4XbZWxvDjG7yOA5FR2IX+83MRHL6Qpfzd1X96dS+jh/An5u6r+9OpfRw/gWjRNiD3m59PKPwzn5u6r+9Oo/Rw/gXq3o3qbGBrelGohrRgDq4fwK/sWYKkDp7E0cMLOLpJHBrW+klRzahSrUxbnuQRVXBpEz5GtYc8u0eHFNiD3m59PKPwpvzd1X96dS+jh/An5u6r+9OpfRw/gV/FKyeJksT2yRvaHNe05DgeRB71ImxB7zc+nlH4Zz83dV/enUvo4fwL1d0b1NxaT0o1ElpyPW4eH/2LSrkh1ClYryWIbleWCLIklZK0tZjnkg4GE2IPebn08o/Cn/N3Vf3p1L6OH8Cfm7qv706l9HD+BXtezBbgbPXmjmhf4skbg5rvQQpk2IPebn08o/DOfm7qv706l9HD+BPzd1X96dS+jh/AtGue1dq0YhLbsw14ydu+V4YM+TJ702IPebn08o/Cjb0b1NpcR0o1EFxyfW4eP8A9i8/m9qv706l9HD+BXM+oUqtiGvYuV4Z5ziKOSVrXSccdkE5PEjl5V1JsQe83Pp5R+Gc/N3Vf3p1L6OH8Cfm7qv706l9HD+BaNE2IPebn08o/DK3OiV2/TlqWekuoyQysLHsLIcEHnyYtIyPqoGsyTtbjJ7+C9I7lWW1LViswvsQgGWJrwXx55bhzGV4iuVbLp44LMMr4TtlbG8OMbvI4DkUppiJyhXerriIq4Q/NHSN3/MmpD/6l/2ltfUsvT0WanNW06xffmNvVV3MDgO1x7TmjH3rC9JHY6Tan/EyfaX0X1FDmxqnoZ/Vda/2HkpinE5fT9J1GzqMUj7OlW9Oc12A2y6Ml3nGxzl4gtWz0ht0pXQurtgjmi2xkPbuLmkOO4g+L3AKzVedJqHU36ifCBZe1rXEWZA3a05A27tuP5d58pXLSVrtW1FgvwudVdPHqMdSB4icGta9sbsuG7tEB55EZwOSjOu3Wt06Z5gAmsmpLGK0hBe2UxucJd21g72hw7XIHJVidA08utksnJtyNllJsynttxhze12SNrcFuMYC9xodBrq2I5dtfb1cfXybMtO4Es3bXOzx3EE5wUFkiIgIiICIiAiIgIiICIiCCy2w6BwqyxRTEja+WMvaP/SHN+tU16HVRLphkhF90VzrXyVI2wtjZsc3iJJSScu7vJ8ugRBmtZoXblxzoab3tsQivvc9g8HLZc7+fIjtDGT2RkDu0qIgLgtxao+YGncpwxYGWzVXSHPpEjfqXeiDNaNQvU7rXTVHNbXifAXhzD15fLu3jjyAyTnB7RwD39Gi1J6uoWjHWtVaLgC2KxOJN0hc4uczDnbWnI4cPQFeogIiIM1qFC67WnyxVHzRySwTidr2DYIt2WYJByeQ7u2ckL2qadcj14OfXLYYp55/CdzSJRIBhmM7uHfkY7AVvqN5mm0JbksUskcI3SCJu5wbni7HeAOJ78Dhlemn6rW1OSyKhdJFA8M68YMcjsZIac8ccM92eHccB3oiIILcTp6c8LH7HyRuY13uSRzWcpadYdSuR3dInbDNVigNaKZgLurbg4cHjGd2BxHBnHHBapEFZokVuLTtlsTNd1jzGyaTrJGR7jtDnZOTjzn0lWaIgKo6RR2ZdKEdWnLal6+J2yNzGkBr2uJ7TgOTf9VbogzOr0b1611kVKQixC2Dc97AaxbLu3ntccjj2cnsj+WB9W84n0r0Sf0X2RfGPVzOJ9J9En/tV+m7WEqd8vlULvX4/hBfrSj7Bg+LC/IsD/X4/hD61+oK/S7o5CIqUut0GWm4jdC6docHcsYzzytjXdzNcYaJEVPZ1p0GrCqKwdXY+KKWbrMFr5M7QG44jxcnI8bvWgguEVJb17wTUnQurg1InsimsdZhzHuaXABuOI8Xjn23JcsXSWzL1MA01jbtjq3QxOs9gsex7w5ztvA+tvGADxxx45QaVFy6fcZqGm1bsbXNjsRMlaHcwHDPH5V1ICIiAiIgIiIC4LcWqPmBp3KcMWBls1V0hz6RI36l3ogpNOFuLVdWfLp07I5p2Oifujw8BjWFwAfkci7jxx5+C59A065VttNisYW163g/Wbmnwh28u3jBzjv7WDlxWjRAXg8uHNeUQZ+/T1p7IJJZqt1kE8c3g9esYXvw73T5S3hzwccQOK9Gae8dHoqdvTrczmvE3V1p2xuYS9zg1rt7fE4Dn5MZWjRBxaTHbi0qqy84utNjAkJOTnznvPnXaiIILcTp6c8LH7HyRuY13uSRzWXi0zUZNOtsOnOrufBAxsBkYQ4w4yMh3t87R5m8ccFr1UXukNPTZrUNlszZIYmysbtBNgOO0CPj2juIbjhxc3ygoJNFgnir2JJ4XQOnsyTCFxBMYJ5HaSMnG7gfbKzXoxxcxpLCwkAlpxkebgvdAVLr1azK+rPXqG51XWtdAHNaTvYWg9ogeb0OKukQZexpttsOmCCrbN+tGyHwtthrY2ta5u/e3f2g4NzjaeftStQiICIiCkaLcfSqxMNOndWfWiiE4fHtLg5xPDfu4B3k7j5s82h6dcq2c2KxhbXrGv1m5p8IdvLt4wc47+1g5cVpF6u8R3oQflfpM7/mjVP4qT7S+jeogcz6r6I/6r5n0odjpVqv8VJ9orfeo9q1DSW6rZ1K5BUgJjYJJnhrd3a4ZPoK6t/sPJbVT8OX3JFwaZrWma1HJJpl+vcZGdr3QSB4afIcLqnmZXryTyHDI2l7j5gMrlKkqKmo646aramu1RWfXhbYcxsnWetuaXA5wOPZcCPNzK5W9I7ji2sNMZ+UHuBbB4T2NhjL92/Zz4FuMc+/HFBo0VBS6Stv3K4irf2Ow9sTJjJ2t5g68dnHi7O/PPu71foCIiAiIgIiICIiAiIgIiICIiAiIgIiICIiDh1SK7Y0+SChKyGeTDOuf/8ADaT2nAY4uAzgHhnC4+j+jP0CCXToHNOmRu3U2lxL4weLmHPMbskHPfju43SICIiAiIgIiICIiAvivq7nE+keiT/2r7UviPq9uxNo/ok/9qv03awstRmuHySB39oi+EPrX68pV4TTgcYYy7YDnaM8l+O4H/2iP4Y+tfsmj7Bg+AFfre5ZfjGHi5Qp6hEIrtSCzG07gyaMPAPlwVwN6OUIbcc1ZprQsc15qwNayFzm5LXFoGcguzwI5DOcK4RaLXVMmgwS3mWZZ55MbTJE7bsme1paHuAbzwe7A4DhwUEfRivFCwMu3RNE5nVWNzDJG1rXMa0dnBAa944gntE5zxV6iCCpWipU4KkDdsUMbY2NznDWjAU6IgIiICIiAiIgIiICIiAiIgIiICIiAqnVNKN/VNHthsJFGy+VxeO1tMT29nh7pzT/AC8ytkQEREBERAREQEREBervEd6F7L1d4jvQg/JfSl2OlmrfxUn2ivpPqGNZLLq4exrhiPgRn3S+X9K346Xav/FyfaK+n+oI7M2seiP/ANy6d6f0PJtV0/pvtbI2RghjGtB9yMLhsaHpNqw6xY0ulLO7iZXwNLz5O1jKsUXMaqpp6FBUgkiNixYEoDJDMWkujDS0MOGjsjOfLnmTxXO3oxCIgBfveEB4c21uZ1gAZs2+LjG0nuzk5znir5EFRX6P1Kt2OxC+VscRD2V8jq2vEfVB/LdnZ2eePNnirdEQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQF8Z9XHStR1ObSRQpWLRjEm/qYy7bnbjOF9lXggHuCnbr2KtqEqKtmrL8gwdFekQnjJ0TUAA8ceod5V+uKXsKD4A+pTbW+5HyLyp3b03MZTuXZreURFSqEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQF4d4rvQvKIPyj0n6Na9Z6U6pNBo92SKS1I5j2QuIcN3ML6P6h+lajpc2rC/RsVTII9gmjLd2M5xlfZdrfcj5EAA5BbFeomqjYwuqvTVTs4eyIi11IiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiIC8IiDyEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQf/9k=",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 600x600 with 7 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 561,
-       "width": 597
+       "height": 565,
+       "width": 594
       }
      },
      "output_type": "display_data"
@@ -681,8 +712,6 @@
     "geodesynet.plot_model_vs_mascon_contours(\n",
     "    net,\n",
     "    encoding,\n",
-    "    mascon_points,\n",
-    "    mascon_masses_nu,\n",
     "    c=c,\n",
     "    progressbar=True,\n",
     "    crop_p=1e-8,\n",
@@ -695,20 +724,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 215,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "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",
       "text/plain": [
        "<Figure size 700x500 with 2 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 524,
-       "width": 563
+       "height": 522,
+       "width": 577
       }
      },
      "output_type": "display_data"
@@ -729,55 +758,50 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 216,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [],
    "source": [
-    "cube_error = np.abs(cube_gt_stokes - gt_stokes) / (np.abs(gt_stokes) + 1e-16)\n",
-    "mascon_cube_error = np.abs(mascon_cube_stokes - gt_stokes) / (np.abs(gt_stokes) + 1e-16)\n",
-    "geodesynet_error = np.abs(combine_stokes_coefficients(stokesC_gann, stokesS_gann) - gt_stokes) / (\n",
-    "    np.abs(gt_stokes) + 1e-16\n",
-    ")"
+    "import seaborn as sns\n",
+    "sns.set(style=\"whitegrid\")\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "sns.set_context(\"notebook\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 217,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:matplotlib.category:Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n",
-      "INFO:matplotlib.category:Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n",
-      "/home/pietrofanti/code/masconCube/mascon_cube/visualization.py:272: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
-      "  ax.plot([i + 1, i + 1], [i, i + 1], color=\"white\", linewidth=3)\n"
-     ]
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
     },
     {
      "data": {
-      "image/jpeg": "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",
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAyADASIAAhEBAxEB/8QAGwABAQEAAwEBAAAAAAAAAAAAAAMEAgUGAQf/xABVEAABAwEDBgYNCQUGBQQDAQAAAQIDBAURFBIhMVOS0QYTQVFxkxUiMjRSVGFyc4GiscEWM0JFgoORwtIjQ4SUskRGVVZioQclY8PTJDXh4hdlhaT/xAAYAQEBAQEBAAAAAAAAAAAAAAAAAQIDBP/EACwRAQABAwIEBgICAwEAAAAAAAABAhESA1ETIWGhIjEyQVLwkbFx4QSB0UL/2gAMAwEAAhEDEQA/AP38AAACUk8UKsSWVjFe7JajnImUvMgFQSdPEyZkLpWJK9FVrFcmU67Tch9kekcbnqjlyUVbmpeq9CAUIy1MUL0Y91zlS+65VzHCirYa+n46BXZOU5io5qtVHItyoqL5T79Y/dfED5jqfWLsruGOp9Yuyu40gDNjqfw12V3HzHU9/wA57K7jSectbhVZ9m2tFSy8a57M8jmtvRl6ZukkzEebNVUUxeqXd46n8NdldwxtP4a7K7ji20aJydrVwL0SJvKJWUy6KiJftoLreHHHU+sXZXcMdT6xdldxRJ4l0SsX7SHLjGLocn4lut4Rx1PrF2V3DHU+sXZXcaL0XlQ+3pzgZsdT6xdldwx1PrF2V3Gi9OcXpzgZ8dT6xdldwx1PrF2V3Gi9OcXpzgZ8bT+Guyu4Y6nvu4zP5q7jR6zDLXUrLThp31MTZ3MddGr0ylzpyC6XiFsdT6xdldwx1PrF2V3GkBWbHU+sXZXcMdT6xdldxpAGbHU+sXZXcMdT6xdldxpAGbHU+sXZXcMdT6xdldxpAGbHU+sXZXcMdT6xdldxpAGbHU+sXZXcMfT33cZn81dxpIJ38vo096gccdT6xdldwx1PrF2V3GkAZsdT6xdldwx1PrF2V3GkAZsdT6xdldwx1PrF2V3GkAZsdT6xdldwx1PrF2V3GkAZsdT6xdldwx1PrF2V3GkAZsdT6xdldwx9PrF2V3GkhH35N5rfiBxx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+jjPZXcaSMPz1R56f0oBwx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU+sXZXcaQBmx1PrF2V3DHU6/vPZXcaSFNol9K4DjjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruCV9OqZpFX7K7jSQo+9Y+gDjjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruGOp9Yuyu40gDNjqfWLsruCV1OudJF2V3F3/Nu6FOFN3rD5jfcBPHU+sXZXcMdT6xdldxpAGbHU+sXZXcVilZMzKjW9L7tBQz0ncy+lf7wNAAAHmeGTYVoqJzqOWonjrYJGOipXTOja2VjnqmS1cntU9dx6YAeEtSjmqLXrnMoJ31dVU0UtDVcQqpFG1WZV7rv2eTdIqtW6/K5bz1fYikZNLUQRNiqZEd+1RL1RV5blzHYADDZlnMsqiw8b1emW5/co1EVy3rc1MyJ5EOUjXutBMmRWLxWlEReU2Gb6x+6+IHLiZvGX7Ldw4mbxl+y3cXAEOJm8Zfst3HnrU4JUVo2pHUzTTI+RbpEbkojrk6D1Bnm75p+l3uJMRPmzVTFUWqhh+T1n3d7U38tHuPi8HbOXTSUv8tHuO3AtBjTs6deDVmLpo6X+XZuOPyXsvxOn9ULTugMYTCnZ0nyWsvxWL1MQ+LwVsvUInQd2BaDCnZ0nyVs7kY9Oh7k+J8+StByOnTomdvO8Axgwp2dJ8lqNNFRWJ0VD94+TFPyVtop0VTt53gJjGxhTs6P5NxJotK0/5px5ur4E1klvNfHWXwPcknGyPVZW3XfivMp78/L7X4T8IoOHL6SmVVSOZI46VGJdIxbtPLn038hujQ4vKPZy1aKLReHt22HO3ubatJOl7F97Tn2LtFvcW5VfbiiX8pLslb/+AQ/zyfpHZK3v8Aj/AJ5v6Rw/t27U9e6i2fbKdzbbV8+kavuVDgtJwgTubVpHedSqnucfOydu/wCX2/zzNw7KW7/l7/8A2s3Dhz9n+y1PXu+cXwlavfFnv+w5u8+5XCNumKif5syp72Hzspbn+XXfzsY7K25/l1385GOHO/eD/cmJt1vdWdleZUs+LT7jrVTu7LrPsSwr8R2Vtv8Ay5J/Nxbx2Vtr/Lk381FvHDnfvB/uXFbVq291Z1qN6Ione5T4ltOTu4LVZ/B3+5FOfZa2OXg5P/MxfqHZa1uXg5U/zEP6hw6t/wBF537OPZ2lTu6itj8+ien5TpW8NadbaWJeOSnVeLxCo3n05N2j/c7zsvaqf3bq+vh/UfnENtTfL5ZexDFkWoVuERO3R3PpuyuW/R7yxoalXpmOTlqV1xa09n6Olv2Wq/8AvUSdOSnwOaW1ZrtFuU3WRk1tqqu7fg7aXq4pfzk3Ww1e74N2n66eNfzEwqdcqt2xLToXaLap16JIyjaynd3NqRr0OYdS60qF3d8GrQ9dAinBayxl7vg3Vp02Wq/AY1LlLvkeju5r0XoyCiMkXRVu9TW7jzK1HBte7sKdvTZUiflOCzcEvpWdIz+AlT8owr2TOej1PFTeNO2W7hxcvjL9lu48rx/A5NLJGfczt+AxfA5NFXIz72dvxGFey5z0/L1XFS+Mv2W7hxUvjL9lu48slZwU+jbUrP46VPepySq4OL3PCaVv/wDRX4qMK9kzl6fipfGX7Ldxmicj66aJtYiyNa3KRMm/l0odGk1ir3HC2RP49i+88RYVTSu4UtatqugblyXVSZsrTyuzdt5SY6ntSxXrTTMRbzfrvFS+Mv2W7hxU3jL9lu46JHRfQ4WuXpfAv5TmnHL3HClq9LIV9yEtOzpn0d1xU3jL9lu4cVN4y/ZbuOobHXr3PCOF3TAxfcpRIbV+jblK7zqVPg8c9lznb9Oz4qbxl+y3cOKm8Zfst3HWpDbnJaNC7ppnfrPuRwgTRUWc7pien5hfoZdHY8VN4y/ZbuHFTeMv2W7jrb+ESf4avWIfeM4QJphs133r0/KLmbseJm8Zfst3DiZvGX7Ldx1+It5NNBQu6Kp36BjbbTTZNOvm1n/0GRnH2G/ipvGX7LdxKKKVZZ//AFDk7dPotz9qhiktG2GRud2FRVRFXtapq/A8twe4UWzV2rJG+HFpI1XrGxGsVt12dFXk5M5ma4ibMVa1NMxE+73nFTeMv2W7hxU3jL9lu46/srXp3Vh1fqliX8w7M1Sd1Ylf6uLX85q7ecOw4qbxl+y3cOKm8Zfst3HXdnJE02PaSfdtX3OPnZ7nsu00/h7/AIi5nDsuJm8Zfst3DiZvGX7Ldx13ygj5aC0k/hHH35Q0vLTV7emjk/SMoXOnd2HFTeMv2W7hxU3jL9lu4wfKOz07rFN6aSX9J8+Utl8s0qdNPIn5RlCZ07uw4qbxl+y3cOKm8Zfst3HX/Kex+WsROmNyfA+pwmsb/EIU6VVBlBnTu38VN4y/ZbuI08UqpJdUOT9o76LTI/hNYzInP7I07slL7keiqvQhgsjhfZdY+Zj5FpVRyvRZ3NajkXy33X+QmUbpxKL2u9BxM3jL9lu4cTN4y/ZbuM6W3ZS6LSpF++bvOSWtZy6K+mXolbvLeGsoW4qbxl+y3cOJm8Zfst3HBLRo3aKuBeiRN5zSrp3aJ416HoVbwcVN4y/ZbuHEzeMv2W7jmk0a6JGL9o5o5F0Kn4gvCPEzeMv2W7hxM3jL9lu4venOfL05wqPEzeMv2W7hxM3jL9lu4tenOL05wI8VN4y/ZbuI0sUq0zFSociXaMlDRLLHDE6SV7WMal7nOW5EQzWXV09XRMfTzxytTMqsdfcoul48l+Jm8Zfst3DiZvGX7LdxcXoFQ4mbxl+y3cOJm8Zfst3F7xeBDiZvGX7Ldw4mbxl+y3cXAEOJm8Zfst3DiZvGX7LdxcAQ4mbxl+y3cOJm8Zfst3FwBmfFLkO/9S/R4Ldxxp4pVporqh6JkJmyW83QaX9w7oOFN3rD5jfcBx4mbxl+y3cOJm8Zfst3FwBDiZvGX7LdxxokVI5EVVVeMfn585pM9J3MvpX+8DQAAAAAAAAZvrH7r4mkzfWP3XxA0gAAQm75p+l3uLkJu+afpd7gLgAAAAAAAAAAAAMVqWhHZdmzVkiK5I29qxNL3Lma1PKqqiesxWLZ0lCyN1SrXVtQj5ql6csjlbeieRMzU8iEZP8AnPCRsWmistyPfzPqFTtU+y1b+lycx3Tu/IvMd72m55RZiOc3WABhsAAAAAAAAAF4Hy4xpTQJarp0hj47ikTjMhMrTzmw69tfSrazqfERLNkImRlZ77yTVEEUzPk7EXAXoULkAAC4+XH0AfLj7cgAHxWoulEU4LBC7uomL0tQoBdLMzqGkd3VLCvTGh5ug4DWNR23LVpG+RG9syGRUcxquvvzXZ/JeesIx99zea34morqjlEpNMT5wzLYdku02ZRr007dxxXg/Yy6bJoV/h2bjsQTKVxh1S8GbCXTY9B/Lt3HFeC1gr9UUXqhQ7gFzq3TGNnSLwSsBfqml9TLj58kbB/w2JOhXJ8TuwM6tzGnZ0nyRsPxK7olen5gnBKxk0U0qdFVKn5jvAM6tzGNnSfJSyuRtW3orZv1Hz5LUCaJrQb0V836jvAOJVuYxs6CTgtTPiextdabMpFS/GyLd+KnluD3/D+torVklq7QVkcSKxjqSRzHuvROXkTyH6QQh+eqPPT+lDUatcRMXZnTpmbup+TV2i2bXT+Kv96D5OPTRblrp9+1fe070Gc5axh0fYCpTueEFqp0ujX8g7B16aOEVo+tkK/kO8Azkwh0fYa1E7nhHWfaghX8o7E2ymjhHN66SLcd2BnP2IMYdJ2Lt1NHCH8aJm8djrfT6/hXpoE/Ud4BnP2IMYdHgeEKaLZo16aFf1nzCcJE+srNd00Tv/Id4Bn9sYw8vadDwknsuqiSSy5ldE5qMbTPRzs2hFV1155LgfZ1vLX1EjaGCJGR5DlroXXZV6Zk5bz9VI02iX0jixXFudMXc6tGmaoqdCtn24umksF3Sx6fA4LZlsL3Vl8H3ep/6T1AM36N4Q8qtlWly2Fwfd0Ocn5DgtlV30uDNhO6JlT/ALZ60FvG0Jw4ePWyanl4KWQvm1N3/bOK2VNy8EaH7NaiflPZHwl6fjBwqXjexcqf3Ri+zXpuHY6VP7pyp5tpJ+o9kB4fjCcKl47Ayp/divTzLST/AMgw0qf3ftlvm2in/kPYgeH4wcKl+c8I8uGw6h7rLtqFrclVdPVI+NEvTuky3e46zgjPxyVax01rSNRW9tQvRqX5+67ZD9WexsjHMe1HNclytVL0VDNZtPBTUMbIIY4mZ1yY2o1L/UW2na+PNif8eM4qeYV7k/svCpPtIv5hxzk+hwqT7tFPaXAnh2dOG8Zi3J+84Up/C3/lGOcn9r4St6aC/wD7Z7IXDw7Jw+rx3ZRyfWdvN86zFX/tjswqfXVqt86yl/8AGexuQXDwbdzh9XjuzaJp4Q1iedZbv0Hzs81P7yvTzrMduPZXC4Wo2n8nDnf9vG/KFif3ng+1Z7k+J9ThIz/M9n/ao3J+Y9j6gLUbT+Thzv8At+dcIeEb32UscdvUM2W9rXMpo3MeqdOUuY7X/h9WyVVlVLH1PHNimyWoq3qxMlF/A762bGo7bs99JWMVWX5SKxbnNcmhUUlwesSjsOzWwUbXXSXSPc9b3OW5Bjp2yi92I0qo1Mru4ABHoDPSdzL6V/vNBnpO5l9K/wB4GgAADouFNVXUNlNrKGpSF0U8SPasaP4xrpGtVM+julO9MFqWRRWzTtp6+J8sSOR+S2VzEvTRfkql4Hn7btu0qWttSWmmZHBZTIHugWNFxGWq5V7tKZsyXcum/Qd7UQWhMlQx80OFex7UbDGrZc6KiXOV11/qOMtgWZPNBNLSo+SBrGtc97lVUat7crP29y50yr7lznaAdTwfgqaazuJqIljRkjkiR1yPVnIrslVTK06PIapHqyvRUY937L6KeU2Gb6x+6+IHLEL4vNspvGIXxebZTeXAEMQvi82ym8jLOqzwLxMuZXfR8nSbSE3fNP0u/pAYhfF5tlN4xC+LzbKby4AhiF8Xm2U3jEL4vNspvLgCGIXxebZTeMQvi82ym8uAIYhfF5tlN4xC+LzbKby4Az4hdRN+CbzBa9rus6z3Sx08jqh6pFBGqJ28jszU08/+15sq7QpKFEWomaxXdy3S53QiZ1POtfWcILZZW0aMipaJXRRrO1b0l0Odk8qonapfovUkVUxPNcKph2lmRR2LZTIpUkVzb3zzPuTLkct7nKt/Kp0FRwvn7Nph4mSUzXcW1t3bPRbs6L7j0kViwLIk1Y99ZMmdHTLejehvcp+BZ9HTOtGKZYI1lRjrnq1L0zpynLUjUr5xNnbSq0tPzi7OtqVy9zYtUvS+NPzHzslanJYkn2p2IdsDeE7sZ0/H9un7IWwuix2N86pTcfMXbjtFDTt6ZHL8DuRcMJ3kzj4w6bjrcX93St+w9fiMq2l0zQN6KZy/nO5Aw6pn0h0qsthdNZd5tGnxefOJtVdNoVH2aZifE7sDCPsnEnp+IdLha9e6tG0PsxRJ8D5gJl7qutVehWJ7kO7A4cHEqdJ2MT6VRarvvlT3KdC3gvMltLIssvEI/jb0v4zTz36fKe5uIIn/AK53o096mKtCiq126Neui9p83V9jE+jUWq375V96jsfInc1tqp9pq+9Duxcbwpc86nS4Ssb3NoWj62Rr8BxFpJotGr+1Txqd2Bw4+yvEn7EOkSK10/t7186kb+o+3WwmiqYvTSL+s7kDCPsnEnp+IdNl22mh9M7pp3J+YcfbifuaV32XodyBh1M+jpsXbaaaCnd0SqnwPuPtlNNjsXoqU3HcAYTvK5x8YdR2StVEz2I/1VDVPO2fwotKe23MWmSRJFVvEMREc26/lXm5bz3JlihibXzyNjYj1a29yNS9dJzr065mLVN0atERMTRDJ2VrOWxqv1Oj/Ufey1Ty2PW+x+o7UHTGd3PKnZ1XZeVNNlV+yxfzBbZemmzK/qk3naXILhardMqdnVdm/wD9daCfcf8AyFtxnLQ2gn8M47W5OY+i1W5lTs6ns/Dy0len8K/cfPlDTJpp61P4V+47a4XC1W63o27uo+UdFyx1adNM/cPlLZ6acQnTTv3Hb3JzILk5kJavfst6Nu/9OmXhPZjWqqySpdzxO3HW2fwxpJqqZs8L4WPXKa9Vv5ETP+B6lWNc1WqiKi5lQ6mzbDs+hrJ5qeHJejslFVyrkoqItyGKo1cotMWboq0cZyib+3N9+U1lL/aUTpzH1OEllr/ambSbztclvgofFijXTG1fUdPHvDF6Np/LrU4RWYv9pj227zklvWcuioj6xu82rTQLpiYv2UPi0VKumniX7CC1fRPB1ZUtqiXRMxfvGbzklrUq6HtX7bd5VbOol00kC9MaHFbKs5dNDTL903cPGeAS0oF0Z/tN3nJK5i6GOX1t3k1sazF02fS9U3ccewdlLps+l6po8R4Oq+LRdEUi/hvPuJ/6Mv4JvMvYCyf8Pp+rQ4/J+yV/sEPqaL17FqN5/H9tTqtI2uc6KRrWpeqqiXIn4mCzbao6xZm0z3SuRyuVEbctyn2fg3ZcsEkbaZsauaqI5t97fKdXY/BKGCWaSrl4+5VY1rUVqJn06TnVVqxVERHJ1pp0ZpmZqm/8PSYr/oTbKbxiv+hNspvMfyesxP3D/VM/eOwFnckcqdE7950vXt3crUbz+P7bMV/0JtlN4xK6ib8E3mPsDQ8iVCdFTJ+odgaPkfVJ/FSfqF6tu5ajfs2YldRN+CbxiV1E34JvMfYKm5J6xP4qTefOwUPJVVyfxT94vVsWp3bsSuom/BN4xK6ib8E3mHsIzkra9P4lw7CJ/iFf/MKL1bJjTu3YldRNspvGJXUTbKbzD2FX/ErQ67/4HYZ6aLUr+sTcL1bGNO7atTcl6wSonOqJvIUdU11LGrI3vbztuVPedbalhVVRZ0sUNo1Mj3JmZK5uS7yLchh4O2BX09PI+SslpUkcioyFWrf5VvRTnOpXnEY8nWNOiaJqy5vUYldRN+CbxiV1E34JvMXYysTRbFX62x/pHY6u5LYqPXFH+k6ZTs54x8v224hfF5tlN4xC+LzbKbzF2PtLktmX1wx7j5gLTTRbDvXTsGU7GMfKO/8AxtxDtRNspvGIdqJtlN5iwNq8lrp66Zu8YK1v8Vj9dKm8ZTsYx8o7/wDG7Er4vN+CbxiV8Xm/BN5iwlrp9ZwL00v/ANhh7YT6wpV6aZf1DKdjCN47tuIXUTbKbxiF1E2ym8w8TbXjlGv8O79Q4q2/GaJfuXfqGc7GHWGx1QqsVOIm0eCm84U86pTxJxMq3MT6Kc3SdJbbLf7GSZEkLs6ZSUzHI+71qW4JJXpZjsbxmTlfsuM7rJu9xiNW9eFm50baed4d1iF8Xm2U3jEL4vNspvLg7OKGIXxebZTecaJcqKRblS+V+Zek0mek7mX0r/eBoAAAAAAAAM31j918TSZvrH7r4gaQAAITd80/S73FyE3fNP0u9wFwAAAJyyxwxq+R7WMal6uctyISRzF9x1S2w6pXJsymfVf9Ve0iT7S6fUinxLLqavPaVY57V/cQXsZ617pfxM539PNvC3q5K1Fs0sUqwRZVTUJpigTKVOnkT1kuKtWv+elbQwr9CLt5F6XLmT1IdjT0sNLEkUETI2JoaxtyFRjM+qTKI9MPO2lFFY9IjLPjR1p1juIgkeuU9XLpcqrnual7vUdvZ1BFZlnwUcF+RE3JvXS5eVV8qrevrOrsr/m9sT2w7PTQ5VNRJyKl/wC0k+0qXJ5G+U786zEUxjDneapyl9Iu78i8x3vaWIu78i8x3vaZVYAAAAAAAAAAAAAIJ3870Se9S5BO/neiT3qBcAAAAAAAAAAAAAIR9+Tea34lyEffk3mt+IFwAAAAAAAAAAAAAjD89Ueen9KFiMPz1R56f0oBYAAAAAAAAAAAAAIU2iX0ri5Cm0S+lcBcAAAAAAAAAAAAAIUfekfR8S5Cj70j6PiBcAAAAAAAAAAAABxf827oOFN3rD5jfcc3/Nu6FOFN3rD5jfcBUAADPSdzL6V/vNBnpO5l9K/3gaAAAOuta2ILGhimqIp3xvkbGroo1cjMpURFdzJeqHYnS8JqCvtSyMHQNplkfLG5y1EjmIiNejs1zXX9zd6wOddwioLPrlpZuNVWIxZpGRq5kKPdksV7uS9U+K3IaeycElS+khc5alMpER0T0beieFdcdFaXB20a+etyX00cNqRwNq73uV0SsXtsjte2vbmz5N2nPoPVXAdfY1dPaFCs87I2/tXsYsTlVHta7Jys/Pcpo+sfuviVhhjp4WRQxtjiY1GtY1LkanMhnkiZLaCJIxHIkXKnlA2AjhKfUx7IwlPqY9kCpCbvmn6Xe4+4Sn1MeyeVtjhBBZ1rpTNoGPZFcsiqtyrenIYr1KdOL1OmnpVak2ph7Ay1doUtC1HVEzWX9ymlXL5E0qdayirbQajnNhoYHJejY0R8qp0rmb6rzZS2LQ0mdlO10nLJJ2z19akymfKDGmn1SjjLRrs1HTYaJf31Smf1MTP+NxyjsSBz0lrZH1syZ0WZe1b0NTMhuwlPqY9kYSn1LNkuEe/NM/jyWRERLkTMfSOEp9THsjCU+pj2TbCp0vCCpmWGGy6R6tq69yxte3TGz6b/AFJo8qodk6mpWNVzoo0REvVVTQdJYVLFaM9RbcsLUZUfs6Rit7mBq5l6XL23Rkmqd5Zq2d7S00VHSxU0DEZFExGManIiFyGDp9THsjCU+pj2TKrkXd+ReY73tGEp9THskXUsGKjTimXKx2a7ytCtgI4Sn1MeyMJT6mPZAsCOEp9THsjCU+pj2QLAjhKfUx7IwlPqY9kCwI4Sn1MeyMJT6mPZAsCOEp9THsjCU+pj2QLEE7+d6JPep9wlPqY9kglLBjFbxLLuLRbrvKoG0EcJT6mPZGEp9THsgWBHCU+pj2RhKfUx7IFgRwlPqY9kYSn1MeyBYEcJT6mPZGEp9THsgWBHCU+pj2RhKfUx7IFiEffk3mt+J9wlPqY9kgymgWqmTimXI1ua7pA2gjhKfUx7IwlPqY9kCwI4Sn1MeyMJT6mPZAsCOEp9THsjCU+pj2QLAjhKfUx7IwlPqY9kCwI4Sn1MeyMJT6mPZAsRh+eqPPT+lBhKfUx7JGKlgWWdFiZmel2b/SgGwEcJT6mPZGEp9THsgWBHCU+pj2RhKfUx7IFgRwlPqY9kYSn1MeyBYEcJT6mPZGEp9THsgWBHCU+pj2RhKfUx7IFiFNol9K4YSn1MeyRp6WBySXwsW6RyaANoI4Sn1MeyMJT6mPZAsCOEp9THsjCU+pj2QLAjhKfUx7IwlPqY9kCwI4Sn1MeyMJT6mPZAsCOEp9THsjCU+pj2QLEKPvSPoGEp9THskaSlgdTMV0LFW7TcBtBHCU+pj2RhKfUx7IFgRwlPqY9kYSn1MeyBYEcJT6mPZGEp9THsgWBHCU+pj2RhKfUx7IFgRwlPqY9kYSn1MeyBR/zbuhThTd6w+Y33HB9JTox37GPR4Jwp6WndTRKsLFVWJfm8gGsEcJT6mPZGEp9THsgWM9J3MvpX+85YSn1MeycKNqNjka1LkSV9yesD7W1cVBQVFZNlcVBG6V+Sl65LUvX3HTW7Kysiugq4mYKRstSySeSFMlzVyb3MzppReXQdrasdLLY9bHXScVSPgkbPJlZOSzJXKW/kzX5z83nkp6iZ1PZvCC165tp5DXZdl8akjWXZ2yZLEzJ9K9ecD9Mo43xUcUciKj2tRHIsqyZ/OXOvSpoCAAAABm+sfuviaTN9Y/dfEDSAAPh1dbZNBV19PPPTMfJeqKq8tyZr+c7Uzzd80/S73EmmKuUrTVNPOJaLrgAVAAAACVRPHTU8k8z0ZFG1XvcuhETSoHTW+91dNT2FC5UdV3uqHNXOynTutrM1OleY7qNjIo2xsajWNTJaiaERDp+D8EkzJ7YqmK2or1RzWO0xwp82z8O2XyuU7s1Vy5M08+b6ADLQRd35F5jve0sRd35F5jve0CwAAAAAAAAAAAAAQTv53ok96lyCd/O9EnvUC4AAAAAAAAAAAAAQj78m81vxLkI+/JvNb8QLgAAAAAAAAAAAABGH56o89P6ULEYfnqjz0/pQCwAAAAAAAAAAAAAQptEvpXFyFNol9K4C4AAAAAAAAAAAAAQo+9I+j4lyFH3pH0fEC4AAAAAAAAAAAADi/wCbd0KcKbvWHzG+45v+bd0KcKbvWHzG+4CoAAGek7mX0r/eaDPSdzL6V/vAVr3x0NRJFTrUyNjc5sCKicYqJmbeubPozn5vQ1TJrSpq2y7LtSzp6WVWy0LmNqII1fmcixtdlxL5UajeW5T9Jqo5ZqSaOCZYJnxubHMjUdxblTM65cy3abjx1Hwct2gtantGqdS2zVQorG1MtVLA9rXZnXMRHM9QHuADyvDaSggpLPnq3sZNFXQOhc5VvaiSsV6pd/pvv8l4HqiU00VPC+aaRscUbVc57luRqJynhbWck1uVcjVldaT6ijdZTmo7PD2mXk8mT87leTTyHrKixqeoZUI907+Pa9qslqJHR9t/pyrvwuu5LgNdLVQVsCT00iSRrel6c6LcqeRT59Y/dfEz2PZaWVRPh4500kkr5pHuVc7nLeulVX/crJxnZBOLViLxX0kv5QNgIXVXhw7K7xdVeHDsrvAuQm75p+l3uF1V4cOyu8jKlRiIL3RX3uu7VebpA2ghdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAsdBbC9lbTp7EZnhS6orV5OLRe1Z9pyfg1TsK+sfZ1DPWVEkSRQsV7rmrf0Jn0mKwqGtgppKuqWJK2tfx06Oaqq1bszNOhqXJ+JqnlGTNXPk7y5EQ+kLqrw4dld4uqvDh2V3mWlwQuqvDh2V3i6q8OHZXeBci7vyLzHe9p8uqvDh2V3knJU4qPtosrId9FedvlA2AhdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAuCF1V4cOyu8XVXhw7K7wLghdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAuQTv53ok96i6q8OHZXeRRKjGL20WVxafRXnXygbQQuqvDh2V3i6q8OHZXeBcELqrw4dld4uqvDh2V3gXBC6q8OHZXeLqrw4dld4FwQuqvDh2V3i6q8OHZXeBcELqrw4dld4uqvDh2V3gXIR9+Tea34i6q8OHZXeRYlRiZbnRX5Lb+1Xy+UDaCF1V4cOyu8XVXhw7K7wLghdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAuCF1V4cOyu8XVXhw7K7wLghdVeHDsrvF1V4cOyu8C5GH56o89P6UPl1V4cOyu8lElTxs9zor8tL+1XwU8oGwELqrw4dld4uqvDh2V3gXBC6q8OHZXeLqrw4dld4FwQuqvDh2V3i6q8OHZXeBcELqrw4dld4uqvDh2V3gXBC6q8OHZXeLqrw4dld4FyFNol9K4XVXhw7K7yNOlRdJc6L5xdLV3gbQQuqvDh2V3i6q8OHZXeBcELqrw4dld4uqvDh2V3gXBC6q8OHZXeLqrw4dld4FwQuqvDh2V3i6q8OHZXeBcELqrw4dld4uqvDh2V3gXIUfekfR8RdVeHDsrvI0qVGGZkuiuu5WrvA2ghdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAuCF1V4cOyu8XVXhw7K7wLghdVeHDsrvF1V4cOyu8C4IXVXhw7K7xdVeHDsrvAq/wCbd0KcKbvWHzG+4m9KnId20OjwV3nGnSpw0VzorshLr2rzdIGsELqrw4dld4uqvDh2V3gXM9J3MvpX+8+3VXhw7K7zjRX8VJlXX8a++7pA0gAAAAAAAGb6x+6+JpM31j918QNIAAEJu+afpd7i5Cbvmn6Xe4C4AAHw+mC1rQZZdmzVbmq9zUuZGml71W5rU6VVEERebJPJ11b/AM4t+Kz0z0lCraip5nSfu2erul+yd+dbYlnvs6zkbO5H1crlmqZE+lI7T6k0J5EQ7I1VPtHskby+gAy0AAARd35F5jve0sRd35F5jve0CwAAAAAAAAAAAAAQTv53ok96lyCd/O9EnvUC4AAAAAAAAAAAAAQj78m81vxLkI+/JvNb8QLgAAAAAAAAAAAABGH56o89P6ULEYfnqjz0/pQCwAAAAAAAAAAAAAQptEvpXFyFNol9K4C4AAAAAAAAAAAAAQo+9I+j4lyFH3pH0fEC4AAAAAAAAAAAADi/5t3Qpwpu9YfMb7jm/wCbd0KcKbvWHzG+4CoAAGek7mX0r/eaDPSdzL6V/vA0AAADi6/JXJuyrs155eLhFaDbIq3zwUrq6O0Us+NI3OSNXOcxrVW/PcmVn6APVA6KhtW0qmGpiWjp5KukqVp5smZWMd2rXI5t7VXOjm5uTPnPk1TO23Y4ppKmJktC9ZGRtc9kb0VLla7J7q7L6btAHfGb6x+6+Jk4P1E1TYNFJO6V0/FIkizMVrlcmm9FRM/qND5Gx2giuys8XI1V5fIBsBHFR80nVO3DFR80nVO3AWITd80/S73H3FR80nVO3EJamNaiBbpMyu/du5ugDaCOKj5pOqduGKj5pOqduAqdB/7zwl56Ky3ep9Qqfkav4u8hptq10oLPc+Bjn1UqpFTxqxyZUjtHJ618iKcrJp4bKs2KlRZXual8kixOve9c7nLm5VvNxyi7M85s7UEcVHzSdU7cMVHzSdU7cYaWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWIu78i8x3vaMVHzSdU7cRdUx4qNbpO4d+7dzt8gGwEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYgnfzvRJ71PuKj5pOqduIJUx4xVuku4tP3budfIBtBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWIR9+Tea34n3FR80nVO3EGVEaVUq3Pztb+7d5fIBtBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWIw/PVHnp/SgxUfNJ1TtxGKpjSWfM/O9P3bvBTyAbARxUfNJ1TtwxUfNJ1TtwFgRxUfNJ1TtwxUfNJ1TtwFgRxUfNJ1TtwxUfNJ1TtwFgRxUfNJ1TtwxUfNJ1TtwFgRxUfNJ1TtwxUfNJ1TtwFiFNol9K4+4qPmk6p24jT1DESS9JPnHL827cBsBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWBHFR80nVO3DFR80nVO3AWIUfekfR8T7io+aTqnbiFJUMbTMRUk0ckbtwG0EcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBYEcVHzSdU7cMVHzSdU7cBR/zbuhThTd6w+Y33HB9TGrHZpNGrduOFPUxpTxJdJmYn7t3N0AawRxUfNJ1TtwxUfNJ1TtwFjPSdzL6V/vOWKj5pOqduJ0a5UUjkvuWV+lPKBqAAHxUvS7QdBDwUp46asgkr6+dtVMlQqyPajo5UVHI9qtaly3tb5Mx6AAYbNs2GzIXxxSSyvlkdLNLK698j15VuuTQiJmTQiG4AAZ/rH7r4mgzfWP3XxA0gAAQm75p+l3uLkJu+afpd7gLA+nUW/WzU9JHS0a3V1Y/iIP9Krpf0NS9fwLEXmyTNmaj/wCc2/LXrnpKBXU9NzOl/eP9Xcp9o7+4zWfRQ2dQQUcCKkULEa2/SvlXyrpNJapvPIiLPoAMqAAAAABF3fkXmO97SxF3fkXmO97QLAAAAAAAAAAAAABBO/neiT3qXIJ3870Se9QLgAAAAAAAAAAAABCPvybzW/EuQj78m81vxAuAAAAAAAAAAAAAEYfnqjz0/pQsRh+eqPPT+lALAAAAAAAAAAAAABCm0S+lcXIU2iX0rgLgAAAAAAAEZ1W5jUVUynIi3FiM+mL0ifEBxDfDk6x28yPrLPjrW0T65jap3cwrP26+q8hU2C2pqZJuyVpx5a35EVU5rW9Cch42r/4dV83CTEsr0WldK2RZnyOWZLrvJnXNmU66dFE+qbOdVVUeUP0TiG+HJ1jt5wSGOOK/Kka1qXr27sx1sXB5kUrJOylquyXI7JdVuVFu5FTmO1mYslLIxvdOYqJ+BzmIhuL+7qYrfsSais+sjtFXQWjKkNI7Kf8AtXrfmu0poXSdqkcTlcjZXqrdKJKub/c8VR8DK2lprMesjHvp3Uj8PmRIHIrFncjvpZWQnteESi4M2vJW1clXStyJ6Sphnw80cSTOe5qsyMliKmZHZ3qq3r5VvivcZMHF8ZxzsjwuNW73nLio8rJ4x+Vdfdxq33fieMhsG0WRUklTZFJV08Es2TQrxUaqj0ZkyORqcWr0yXp0O5yzuD1cttpM2hp2q6uhqm1ySJlwxNa1HQol1/0XNuTtbnKukD1T1p445JJJ1ayNuU9zplRGt03rnzIY6G07OtJ+TTTzuXJR6ZbZGI5q5kVquRMpOg8vHwKn7DU9HHDT008lm1FPUyot+VI57HMyru6TtXdCKvOdzaCWza1mSQvsqOCWJ8MzUWqa5JHMla9WtVEzIqNXOt2lMwHbT1NJTVEEEs8jZJ1cjEy3Xdq3KW9eTNzmhY42qiOkeiuzJfKuf/c8XNYVp1Fc2uqrHp6iPsjLUupHztdex1O2NNKZKuyk0aPKZJeB1pLHSsqGPnjwiQNjp5o0Wldxj3dq6RirciOYiObc79mnkuD9B4hvhSdY4cQ3wpOscURLkRNPSfQIrTtVF7aTrHHxlOxGNRHSIiJo4xS66D43uU6AJ8Q3wpOscOIb4UnWOKgCCNWOoa1HOVHNW9HOv5j5SdzL6V/vOb++YvNd8DhSdzL6V/vA0AAADi5yNarl0JnU6yHhDZc9mz2iyqupYXrHI98bmq1yXJdkql9+dOTPegHag62O3bLlpEqsdDHEr1jvmdxao9NLVR1yoqcynzso51e2mhhbKySldUQzNlTJfcqJd7SZwOzM31j918SNlWilqUCVKRrH27mK1VvztcqZtC3ZuVELfWP3XxA0gAAQm75p+l3uLkJu+afpd7gLKdBZH/NrUqLbfngbfT0Sf6EXt3/acn4NQpwgnklZBZFK9W1NeqsV7dMcSfOP/DMnlch29PBFS08dPCxGRRNRjGpyImhDXlT/ACz5yqADLQAAAAAAAARd35F5jve0sRd35F5jve0CwAAAAAAAAAAAAAQTv53ok96lyCd/O9EnvUC4AAAAAAAAAAAAAQj78m81vxLkI+/JvNb8QLgAAAAAAAAAAAABGH56o89P6ULEYfnqjz0/pQCwAAAAAAAAAAAAAQptEvpXFyFNol9K4C4AAAAAAABGfTF6RPiWIz6YvSJ8QKXpzodbJb1mxWglC+oRJ1XJVLluReZV0HOaxbNqJnzTUkT5Hre5ypnU6aXgXTPtLj2TKynV2UsCN/2ReY46k6semHfSp0Z9cy9TenOcUVEZeq3IYGWDZcb2vbRRI5q3oqJoU3KxskKscl7XIqKh0i/u4zb2dXQW8louhkp7PrVo5vmqtzWpG5OR12VlI1eRVaVjt+yZYKiZlpUroqdL5XpIlzE5FVebynQpwRrJWWdR1FXAtLZ6cXFPGxzZ3RZCsRi58nQqXry3aEJ0vAuogpGxrNTYinbC2nnVZn5XFPa9Ec1z1RrVVqZmmkeidwgshtJFVOtKmSCV6sY9ZEuc5NKdKcvMSpOEtmVFHQTy1UdO6uibLFFK9Edc7R/vmOrj4N2lDWpacdVR4+SaZ8rHQuWJGyNjbc3PfenFNzrpvdovzY4+A0sUVNGs8NQzB09JUMkdLGxeKRUymtY5EVFv7l34gemW3bLSeaHH0/GQKjZEy07VcpG3L9pUTpUz2rwms6yJ4I6h7nLJUtpnrGiKkLnMVyLJ4LbuXyodbPYE8T7Ukncq2dURTI+ipMtyyue6/KRrlua5M/c3Xq5VU42fwWnnsyzOyz2S1SyS1Fotcl/HOkhdG5ubNmRyJ0NA7dOEVmtjqZJ50p2QVLqZVmVG5T2oirk58+Zf9lOUHCCzqm2H2XFUI6pbEyZLs7XNeiqitXlzNv8AWh5uHgRXQxRSOtJtRVw1U8jXOWSLLjkRrUynMcjspEY3PoXPmz5u6smxJ7Jr43QLTpSLRxU8kTcu9ix5apkXquZcvlz5gO/AABdB8b3KdB9XQfG9ynQB9AAEn98xea74HCk7mX0r/ec398xea74HCk7mX0r/AHgaAAB8XRmS9TxUNl2xPR2gklnpBKtpx2jA19Q1UkyXsdkKrb8le006M6HtgB01hUdVAlfU1kbIpa2rWo4lrsri0yGMRFXQq3MvW7nNk1mU09alW9JuOSN0SK2Z7URq6UuRbuRM+nMhtAGeko4KGFYqditarleqq5XK5y6VVVzqpOSNJLQRFc9P2X0XKnKbDN9Y/dfEDlhm6ybrHDDN1k3WOLgCGGbrJusUz1EUcUkT3yyNamUrnOkXMiIbj8u4dcJbRituayWMa2kRrUVl3bTo5EvS/mXuc3lOmlpzqVWhiuuKYvL19g0q18k9tzLKi1Xa0zVeqKynTudruvWh3mGbrJusU5QXcRHczi+1TtPBzaCpiqby1EWhDDN1k3WOGGbrJuscXBFQwzdZN1jhhm6ybrHFwBDDN1k3WOGGbrJuscXAEMM3WTdY4YZusm6xxcAQwzdZN1jiTqduKjbxkvcO/eLztNhF3fkXmO97QPmGbrJuscMM3WTdY4uAIYZusm6xwwzdZN1ji4Ahhm6ybrHDDN1k3WOLgCGGbrJuscMM3WTdY4uAIYZusm6xwwzdZN1ji4Ahhm6ybrHEUp24xUy5fm0/eLzqbSCd/O9EnvUBhm6ybrHDDN1k3WOLgCGGbrJuscMM3WTdY4uAIYZusm6xwwzdZN1ji4Ahhm6ybrHDDN1k3WOLgCGGbrJuscMM3WTdY4uAIYZusm6xxFlO1aqVMuXM1v7xfKbSEffk3mt+IDDN1k3WOGGbrJuscXAEMM3WTdY4YZusm6xxcAQwzdZN1jhhm6ybrHFwBDDN1k3WOGGbrJuscXAEMM3WTdY4YZusm6xxcAQwzdZN1jiUVO1ZZu3lzPT94vgobCMPz1R56f0oB8wzdZN1jhhm6ybrHFwBDDN1k3WOGGbrJuscXAEMM3WTdY4YZusm6xxcAQwzdZN1jhhm6ybrHFwBDDN1k3WOGGbrJuscXAEMM3WTdY4jT07VSTt5fnHJmkU2kKbRL6VwDDN1k3WOGGbrJuscXAEMM3WTdY4YZusm6xxcAQwzdZN1jhhm6ybrHFwBDDN1k3WOJyQNY+JUfIvbppeq85rIz6YvSJ8QMk1sWZTyvhmtGmjkYtzmOmRFT/c6eXhtZcVppSIsj4r0atQ1yKxF/HOnlPSLBE5cp0bFVeVWodJNwRsue1ce6ORH5SPWNHdorudUMVZezjXxf/Nm1lt2S97WMtOlc5y3I1J23qv4muaaOlpZKiZytjiYr3rzIiXqckp4UW9ImIvPch9fEyeB0UjUfG9qtc1dCoulDXP3dYv7ujp7crOxvZauoY6ezVp1qL21CvlYxEykymZN16pyIq3eU+2vwkhs2dsEccksraiCKVqNcqokuVdk3aV7XQfY+DSpZ8lmS2pVy2c6B1OyByMvaxW5Kdvk5S3Jo/3vIP4IrNK+onterfVPlgl47IjTJWLKybkRt1y5S3lUrOFlNDQvq4GSy8XTVMr6dzHNlR0OTlNXwbsrPf0pefKXhOyOnctpfs50SFOIijflq+RHKjURdK3N/wBlvuOa8Ead9PK2SrnfLNDUxzSqjb3rPk5TrrrkuyERE0XHKu4I0de+aSSaTjHuhexVa1yMdG1zUXJcio69HOvRf9gOFXwvs+GzlqIEnnl4mWXimROVY+LzOy7u5RHZvdeaqm2lprGoKpKdZamtWKOGFslyLI9L7ldyNRL1v5kMkvBFjqdrIq+ankWnkppX08MbEkjet92Sjbmqi6FTPnXSdjU2JBU2VTUKyysWlWN0EzFRHsezuXJmu9Spct6gY04RNpYpuyOH4yOaODIoJ3VDst63I1zclHNW8rFwls+WsbTXVLXOfxSPfE5GJLk5SxZWjKu5OfNpJM4LsdUuq6mumnqXTQSufkMYi8U5ytbc1P8AW69dJRODMKWilRi51pkqlrEpO1yOOVO6vuyrs6uyb9P4AJuFFl09FHVySTcTJR41qpG5V4u9qX3c/bpmPq8JaBI3XsrOPSfDpTcS7jVfk5eZvNk9tfouMLeBUXE8TJaVXJEylwcLXIxOLjR7XJobnXtES9TdVcHGT18tdDWTwVTp2zse1rVyFSPi1S5UzorVXSBysy1Km2LAbX0kMaTSPkayOV7mNubI5ufNei3Jou0nWWPwskrOIbWUfFvqGPfHHSq+VUayTi3OcqtRGpfd+J3tkWYyyLMjomTSTIxz3rJLdlOVz1ct93lcY7L4N09mPheyeWTi4JILn3Z0fJxi6PLmAhaPCyjorLbWQxT1LpKVtXHE1FRXRuc1t/k7tMxxZwrhZak9LVU1TDHHxF0ixuXI43RxnI3trkJt4FQrTrBLaVXLG2jwUKORicVGjmubobncmS3Oum42ScG2TxVaVFXK+Wr4hZXo1rc8SoqKiXZr7gO0ljR9REmU9O1docqcwo25MciXqt0r9K38pzd3zF5rvgcaTuZfSv8AeBoAAAAAAAAMcsrIa5HPVURY7r7l5zYAM2Op9Z7KjHU+s9lTSAM2Op9Z7KmWofRTVdPM+Nj3Rqtz3RXq3NyLcdmcVVEVEVc66BdLIY6n1nsqMdT6z2VNICs2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7Kk3VcC1LHZeZGORVyV50Npxykyrr0v5gIY6n1nsqMdT6z2VNIAzY6n1nsqMdT6z2VNIAzY6n1nsqMdT6z2VNIAzY6n1nsqMdT6z2VNIAzY6n1nsqMdT6z2VNIAzY6n1nsqSSrgxavy+1ViJfkrzm445TcpW3plJyXgQx1PrPZUY6n1nsqaQBmx1PrPZUY6n1nsqaQBmx1PrPZUY6n1nsqaQBmx1PrPZUY6n1nsqaQBmx1PrPZUY6n1nsqaQBmx1PrPZUkyrgSplcr1yXI25clfKbjijmq5URUVU0pfoAhjqfWeyox1PrPZU0gDNjqfWeyox1PrPZU0gDNjqfWeyox1PrPZU0gDNjqfWeyox1PrPZU0gDNjqfWeyox1PrPZU0gDNjqfWeypKOrgbJMqvzOeip2q+ChuPl6X3X5wM+Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KjHU+s9lTSAM2Op9Z7KkoKuBiSZT7r3uVO1U26NJxZIyRFyHtddzLeBHHU+s9lRjqfWeyppAGbHU+s9lRjqfWeyppAGbHU+s9lRjqfWeyppAGbHU+s9lTi+rpXtuc9bvIimsAYePpNdLtPHH0mul2nm4AYePpNdLtPOEE1PxLeMlly+XtnHYnFrmu7lUXkzKBj4+k10u08cfSa6XaebgBh4+k10u08cfSa6XaebgBh4+k10u08cfSa6XaebgBh4+k10u08cfSa6XaebgBh4+k10u08cfSa6XaebgBgdNS5K3TS3+c8+RTU/FMy5pcvJTK7Z2k3Oc1jcpzkaicqqGPa9t7XI5OdFvAx8fSa6XaeOPpNdLtPNwAxtqKVjspJHKui9cpTnRKjonuTQsjlT8TSAAAAAAAAAAAAAAAeD4UU0klq2jl000tbLT07bJkZG53FyI92VkuRLmKjslXLm7W7kQ94AAAAAAAAAAAAAAAeStCSgp/+INlyJFk1LqeaOaVsDlvylj4trnIl3I7lPWgAAAAAAAAAAAAAAHjUdZ9Vw6ibTU7KSSkle6WfiHNkqpHMVMjKuzsRFvVVXO5rUTQp7IAAAAAAAAAAAAAAA8ZFFA/h7BUUMSKxGzNqEio3QrG5UTtpHqn7S9yZk8t+e49mAAAAA6Or4U2bQ1lXBPikbSKiVEzaaR0cV7Ud2zkS5O1VF8h27ZonpGrZGKkiXsVHd0nk5wKg4LIxH5Cvajua/OfONj7b9oztUvXttCc4FATWWNsaSK9qMX6SrmOaqjUVVW5E5VA+g4Ne116Nci5K3LcuhTmBOZz2wvdGzLejVVrL7speRL+Q8fwUhtGHhLasloWfNBPUUtPJPM+RrmukypMzbl0IioiJyI1L9J7QAAAAAAAAAAAAAAGS0oo5rMq4pnPbFJC9r3MblKjVaqKqJyqef4HRtpn1tLSNSSz42xLFUrRpTukdcqOatzW5VyI3trvpXch6sAAAAAAAAAAAAAAHS8K466XgraUdm5eLdAqMRiLlLz3Xct1+gxcEf2aV8METMAyVqwTtpEplkVW9smSiJfkrcmVd5OQ9OAAAAAAAAAAAAAADHaTabsdUOrKdtRTsYsj4lj4zKRufueVcx1/BOzFsvg/C2SBkFRUOdUzxsbko2SRcpW3f6b0b9k7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeQl7J0dqcIWwWNUVS1sjHU70dG2Jf2DGds5XXol6LfmX1nRP4HV9PURU1S2sqY2U1LBT1NGyBVi4pjWr20nbR9siuvbz85+mAD8zr6ZkPCCGCaijltGS34521iSRucsV+UjbsrL7VqXZN1yImUapOCtU3gtTsiocip7IPnrGRtjdJPFxkionb9q67Ka5GuzZuc90lHTNq1qkp4kqFTJWVGJlqnNfpNAH5tNwZq209A5tNaEtDG+oc+lkgpXPY56syXNiX9nk9q/MmdMpedT0NXZVX/+P1selbUvmkp2011Q5vGNY5Ua69Wrk5mqujmPUADz9i2O2zbetWWnoo6WkfHTxRJGiIj8lHK51ycvbI29c/anoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/9k=",
       "text/plain": [
-       "<Figure size 700x500 with 1 Axes>"
+       "<Figure size 2800x800 with 1 Axes>"
       ]
      },
      "metadata": {
       "image/jpeg": {
-       "height": 473,
-       "width": 584
+       "height": 256,
+       "width": 800
       }
      },
      "output_type": "display_data"
     }
    ],
    "source": [
-    "stokes_boxplot(\n",
-    "    [cube_error.flatten(), mascon_cube_error.flatten(), geodesynet_error.flatten()],\n",
-    "    labels=[\"Cubified Ground Truth\", \"MasconCube\", \"GeodesyNet\"],\n",
-    "    title=\"Stokes coefficients relative error\",\n",
-    ")\n",
-    "plt.show()"
+    "stokes_degree_error(np.stack([cube_gt_stokes, mascon_cube_stokes, geodesynet_stokes]), gt_stokes, labels=[\"MasconCube\", \"GeodesyNet\", \"Cubified Ground Truth\"])\n",
+    "plt.plot()"
    ]
   },
   {
@@ -791,7 +815,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 218,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -804,7 +828,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 219,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
@@ -836,21 +860,21 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Cosine Distance</th>\n",
-       "      <td>5.215407e-08</td>\n",
-       "      <td>9.585024e-07</td>\n",
-       "      <td>0.000141</td>\n",
+       "      <td>1.009703e-07</td>\n",
+       "      <td>7.653237e-08</td>\n",
+       "      <td>0.000028</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Euclidean Norm Distance</th>\n",
-       "      <td>2.227743e-04</td>\n",
-       "      <td>3.391246e-04</td>\n",
-       "      <td>0.003274</td>\n",
+       "      <td>2.680542e-04</td>\n",
+       "      <td>2.254027e-04</td>\n",
+       "      <td>0.001551</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Relative Euclidean Norm Distance</th>\n",
-       "      <td>2.270587e-04</td>\n",
-       "      <td>2.265655e-04</td>\n",
-       "      <td>0.005742</td>\n",
+       "      <td>2.790533e-04</td>\n",
+       "      <td>1.330144e-04</td>\n",
+       "      <td>0.003043</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -858,17 +882,17 @@
       ],
       "text/plain": [
        "                                  Cubified Ground Truth    MasconCube  \\\n",
-       "Cosine Distance                            5.215407e-08  9.585024e-07   \n",
-       "Euclidean Norm Distance                    2.227743e-04  3.391246e-04   \n",
-       "Relative Euclidean Norm Distance           2.270587e-04  2.265655e-04   \n",
+       "Cosine Distance                            1.009703e-07  7.653237e-08   \n",
+       "Euclidean Norm Distance                    2.680542e-04  2.254027e-04   \n",
+       "Relative Euclidean Norm Distance           2.790533e-04  1.330144e-04   \n",
        "\n",
        "                                  GeodesyNet  \n",
-       "Cosine Distance                     0.000141  \n",
-       "Euclidean Norm Distance             0.003274  \n",
-       "Relative Euclidean Norm Distance    0.005742  "
+       "Cosine Distance                     0.000028  \n",
+       "Euclidean Norm Distance             0.001551  \n",
+       "Relative Euclidean Norm Distance    0.003043  "
       ]
      },
-     "execution_count": 219,
+     "execution_count": 57,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -899,7 +923,7 @@
   "kernelspec": {
    "display_name": "masconcube",
    "language": "python",
-   "name": "masconcube"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -911,7 +935,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.9"
+   "version": "3.12.10"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/test_dataloading.ipynb b/notebooks/test_dataloading.ipynb
new file mode 100644
index 0000000..7373ab8
--- /dev/null
+++ b/notebooks/test_dataloading.ipynb
@@ -0,0 +1,274 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7e93b833",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mascon_cube.data.datasets import create_trajectory_dataset, create_random_dataset\n",
+    "from torch.utils.data import DataLoader\n",
+    "import torch\n",
+    "from mascon_cube.constants import VAL_DATASETS_DIR\n",
+    "from mascon_cube.training import training_loop, CubeTrainingConfig, ValidationConfig, LogConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5e385b66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "asteroid = \"eros_3\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9558d062",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1.5, 0.0, 1.57075, 0.0, 0.0, 1.57075)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "PosixPath('/home/pietrofanti/code/masconCube/data/train_datasets/eros_trajectory_1_17280_1759146619.pt')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "create_trajectory_dataset(asteroid, 60*24*60//5, propagation_days=10) # every 5 seconds for 24 hours"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "254bf91b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PosixPath('/home/pietrofanti/code/masconCube/data/train_datasets/eros_3_17280_spherical_0.0_2_42.pt')"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "create_random_dataset(asteroid, 60*24*60//5, sampling_max=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d3850b67",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|██████████| 10/10 [02:04<00:00, 12.43s/epoch]\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = CubeTrainingConfig(asteroid=asteroid, train_set_path='/home/pietrofanti/code/masconCube/data/train_datasets/eros_trajectory_17280_1758896005.pt')\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "val_dataset = torch.load(VAL_DATASETS_DIR / f\"{asteroid}_1000_spherical_0_2.pt\").to(\n",
+    "    device\n",
+    ")\n",
+    "val_config = ValidationConfig(val_dataset=val_dataset, val_every_n_epochs=1)\n",
+    "log_config = None\n",
+    "\n",
+    "cube = training_loop(config, val_config, log_config, device=device, progressbar=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "42e8090f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|██████████| 10/10 [02:00<00:00, 12.04s/epoch]\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = CubeTrainingConfig(asteroid=asteroid, train_set_path='/home/pietrofanti/code/masconCube/data/train_datasets/eros_3_17280_spherical_0.0_2_42.pt')\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "cube2 = training_loop(config, val_config, log_config, device=device, progressbar=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2fe5574f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mascon_cube.visualization import plot_trajectory, plot_mascon_cube"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "141f4186",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 7 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/jpeg": {
+       "height": 565,
+       "width": 595
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_mascon_cube(cube);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "3867ab43",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 7 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/jpeg": {
+       "height": 576,
+       "width": 591
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_mascon_cube(cube2);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "63446262",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mascon_cube.data.datasets import AccelerationDataset\n",
+    "trajectory = AccelerationDataset('/home/pietrofanti/code/masconCube/data/train_datasets/eros_trajectory_1_17280_1759146619.pt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8cc355af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "4d829107",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 2 Axes>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/jpeg": {
+       "height": 378,
+       "width": 715
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_trajectory(trajectory.data[:,:3], trajectory.data[:,:3], np.zeros([3,3]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9838291e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "masconcube",
+   "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.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/scripts/generate_train_datasets.py b/scripts/generate_train_datasets.py
new file mode 100644
index 0000000..ea6cc9b
--- /dev/null
+++ b/scripts/generate_train_datasets.py
@@ -0,0 +1,112 @@
+import os
+import sys
+from argparse import ArgumentParser
+
+from mascon_cube.constants import GROUND_TRUTH_DIR
+from mascon_cube.data.datasets import create_random_dataset, create_trajectory_dataset
+
+
+def random():
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--seed", "-s", type=int, default=42, help="Random seed for dataset generation"
+    )
+    parser.add_argument(
+        "--n-points",
+        "-n",
+        type=int,
+        default=100_000,
+        help="Number of points in the training dataset",
+    )
+    parser.add_argument(
+        "--sampling-method",
+        "-sm",
+        type=str,
+        default="spherical",
+        help="Sampling method to use for dataset generation",
+    )
+    parser.add_argument(
+        "--range", "-r", type=float, nargs=2, default=(0.0, 1.0), help="Sampling range"
+    )
+    args = parser.parse_args(sys.argv[2:])
+    for asteroid in asteroids:
+        dataset_path = create_random_dataset(
+            asteroid=asteroid,
+            n=args.n_points,
+            sampling_method=args.sampling_method,
+            sampling_min=args.range[0],
+            sampling_max=args.range[1],
+            seed=args.seed,
+        )
+        print(f"Created training dataset for {asteroid} at {dataset_path}")
+
+
+def traj(asteroids):
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--n-points",
+        "-n",
+        type=int,
+        default=100_000,
+        help="Number of points in the training dataset",
+    )
+    parser.add_argument(
+        "--safety-coefficient",
+        "-sc",
+        type=float,
+        default=1.4,
+        help="Safety coefficient for trajectory simulation",
+    )
+    parser.add_argument(
+        "--exit-radius",
+        "-er",
+        type=float,
+        default=2.0,
+        help="Exit radius for trajectory simulation",
+    )
+    parser.add_argument(
+        "--propagation-days",
+        "-pd",
+        type=float,
+        default=1.0,
+        help="Propagation days for trajectory simulation",
+    )
+    parser.add_argument(
+        "--orb-params",
+        "-op",
+        type=float,
+        nargs=6,
+        default=(1.5, 0.0, 3.1415 / 2, 0.0, 0.0, 3.1415 / 2),
+        help="Starting orbital parameters for trajectory-based dataset generation",
+    )
+    args = parser.parse_args(sys.argv[2:])
+    for asteroid in asteroids:
+        dataset_path = create_trajectory_dataset(
+            asteroid=asteroid,
+            n=args.n_points,
+            safety_coefficient=args.safety_coefficient,
+            exit_radius=args.exit_radius,
+            starting_orb_params=(args.orb_params,),
+            propagation_days=args.propagation_days,
+        )
+        print(f"Created training dataset for {asteroid} at {dataset_path}")
+
+
+if __name__ == "__main__":
+    asteroids = [f.name for f in os.scandir(GROUND_TRUTH_DIR) if f.is_dir()]
+    parser = ArgumentParser()
+    parser.add_argument(
+        "method",
+        type=str,
+        choices=["random", "traj"],
+        help="Dataset generation method",
+    )
+    args = parser.parse_args(sys.argv[1:2])
+    if args.method == "random":
+        random(asteroids)
+    elif args.method == "traj":
+        traj(asteroids)
+    else:
+        print("Unknown method.")
+        parser.print_help()
+        sys.exit(1)
diff --git a/scripts/run_config.py b/scripts/run_config.py
new file mode 100644
index 0000000..375d63c
--- /dev/null
+++ b/scripts/run_config.py
@@ -0,0 +1,57 @@
+from argparse import ArgumentParser
+from pathlib import Path
+
+import yaml
+
+from mascon_cube.constants import CONFIGS_DIR, TRAIN_DATASETS_DIR, VAL_DATASETS_DIR
+from mascon_cube.training import CubeTrainingConfig, training_loop
+
+
+def load_config(config_path: Path) -> list[CubeTrainingConfig]:
+    """Load a YAML configuration file.
+
+    Args:
+        config_path (str): Path to the YAML configuration file.
+
+    Returns:
+        dict: Configuration as a dictionary.
+    """
+    configs = []
+    with open(config_path, "r") as file:
+        config = yaml.safe_load(file)
+    for ast, ds in config["asteroids"].items():
+        configs.append(
+            CubeTrainingConfig(
+                asteroid=ast,
+                train_set_path=TRAIN_DATASETS_DIR / ds["train"],
+                val_set_path=VAL_DATASETS_DIR / ds["val"],
+                **{k: v for k, v in config["train"].items()},
+            )
+        )
+    return configs
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument(
+        "config_name",
+        type=str,
+        help="Name of the YAML configuration file. It must be located in mascon_cube/data/train_configs",
+    )
+    parser.add_argument(
+        "--use-wandb",
+        "-w",
+        action="store_true",
+        help="Use Weights & Biases for logging",
+    )
+    args = parser.parse_args()
+    config_name = (
+        args.config_name
+        if args.config_name.endswith(".yaml")
+        else f"{args.config_name}.yaml"
+    )
+    config_path = CONFIGS_DIR / config_name
+    configs = load_config(config_path)
+    for cfg in configs:
+        print(cfg)
+        training_loop(cfg, progressbar=True, use_wandb=args.use_wandb)
diff --git a/scripts/train.py b/scripts/train.py
deleted file mode 100644
index 3651991..0000000
--- a/scripts/train.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import os
-from argparse import ArgumentParser
-
-import torch
-
-from mascon_cube.constants import OUTPUT_DIR, VAL_DATASETS_DIR
-from mascon_cube.logs import LogConfig
-from mascon_cube.models import MasconCube
-from mascon_cube.training import CubeTrainingConfig, ValidationConfig, training_loop
-
-
-def train(asteroid: str, use_tensorboard: bool) -> MasconCube:
-    config = CubeTrainingConfig(asteroid=asteroid)
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    val_dataset = torch.load(VAL_DATASETS_DIR / f"{asteroid}_1000_spherical_0_2.pt").to(
-        device
-    )
-    val_config = ValidationConfig(val_dataset=val_dataset, val_every_n_epochs=50)
-    log_config = LogConfig() if use_tensorboard else None
-
-    # Train the cube
-    return training_loop(config, val_config, log_config, device=device)
-
-
-if __name__ == "__main__":
-    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-    parser = ArgumentParser()
-    parser.add_argument("asteroid", type=str)
-    parser.add_argument("--tensorboard", "-t", action="store_true")
-    args = parser.parse_args()
-
-    cube = train(args.asteroid, args.tensorboard)
-
-    if not args.tensorboard:
-        # If not using tensorboard, save the output in the default directory
-        output_path = OUTPUT_DIR / "mascon_cube"
-        model_path = output_path / args.asteroid / "model.pt"
-        os.makedirs(model_path.parent, exist_ok=True)
-        torch.save(cube, model_path)
diff --git a/scripts/train_cube.py b/scripts/train_cube.py
new file mode 100644
index 0000000..316b6e2
--- /dev/null
+++ b/scripts/train_cube.py
@@ -0,0 +1,68 @@
+import os
+from argparse import ArgumentParser
+from pathlib import Path
+
+import torch
+
+from mascon_cube.constants import OUTPUT_DIR, TRAIN_DATASETS_DIR, VAL_DATASETS_DIR
+from mascon_cube.models import MasconCube
+from mascon_cube.training import CubeTrainingConfig, training_loop
+
+
+def train(
+    asteroid: str,
+    train_set_path: None | Path = None,
+    use_wandb: bool = False,
+    progressbar: bool = False,
+) -> MasconCube:
+    if train_set_path is None:
+        train_set_path = (
+            TRAIN_DATASETS_DIR / f"{asteroid}_100000_spherical_0.0_1.0_42.pt"
+        )
+    val_set_path = VAL_DATASETS_DIR / f"{asteroid}_1000_spherical_0_2.pt"
+    config = CubeTrainingConfig(
+        asteroid=asteroid, train_set_path=train_set_path, val_set_path=val_set_path
+    )
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # Train the cube
+    return training_loop(
+        config, device=device, use_wandb=use_wandb, progressbar=progressbar
+    )
+
+
+if __name__ == "__main__":
+    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+    parser = ArgumentParser()
+    parser.add_argument("asteroid", type=str)
+    parser.add_argument(
+        "--train-set-path",
+        "-t",
+        type=Path,
+        default=None,
+        help="Path to the training dataset",
+    )
+    parser.add_argument(
+        "--use-wandb",
+        "-w",
+        action="store_true",
+        help="Use Weights & Biases for logging",
+    )
+    parser.add_argument(
+        "--progressbar",
+        "-p",
+        action="store_true",
+        help="Show progress bar during training",
+    )
+    args = parser.parse_args()
+
+    cube = train(
+        args.asteroid,
+        args.train_set_path,
+        use_wandb=args.use_wandb,
+        progressbar=args.progressbar,
+    )
+    output_path = OUTPUT_DIR / "mascon_cube"
+    model_path = output_path / args.asteroid / "model.pt"
+    os.makedirs(model_path.parent, exist_ok=True)
+    torch.save(cube, model_path)
diff --git a/scripts/train_cubes_all.py b/scripts/train_cube_all.py
similarity index 97%
rename from scripts/train_cubes_all.py
rename to scripts/train_cube_all.py
index e04321b..0040d5f 100644
--- a/scripts/train_cubes_all.py
+++ b/scripts/train_cube_all.py
@@ -42,7 +42,7 @@ def gpu_worker(gpu_id: int):
 
             tqdm.write(f"[GPU {gpu_id}] Starting: {asteroid}")
             env = {"CUDA_VISIBLE_DEVICES": str(gpu_id)}
-            train_script = Path(__file__).parent / "train.py"
+            train_script = Path(__file__).parent / "train_cube.py"
             process = subprocess.Popen(
                 [
                     conda_path,
diff --git a/scripts/train_pinn.py b/scripts/train_pinn.py
index 4ab1ddb..2532d8d 100644
--- a/scripts/train_pinn.py
+++ b/scripts/train_pinn.py
@@ -4,37 +4,33 @@
 import torch
 
 from mascon_cube.constants import OUTPUT_DIR, VAL_DATASETS_DIR
-from mascon_cube.logs import LogConfig
 from mascon_cube.pinn_gm import PinnGM, PinnTrainingConfig, training_loop
-from mascon_cube.training import ValidationConfig
 
 
-def train(asteroid: str, use_tensorboard: bool) -> PinnGM:
-    config = PinnTrainingConfig(asteroid=asteroid)
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    val_dataset = torch.load(VAL_DATASETS_DIR / f"{asteroid}_1000_spherical_0_2.pt").to(
-        device
+def train(asteroid: str, progressbar: bool = False) -> PinnGM:
+    config = PinnTrainingConfig(
+        asteroid=asteroid,
+        val_set_path=VAL_DATASETS_DIR / f"{asteroid}_1000_spherical_0_2.pt",
     )
-    val_config = ValidationConfig(val_dataset=val_dataset, val_every_n_epochs=5)
-    log_config = LogConfig() if use_tensorboard else None
-
+    device = "cuda" if torch.cuda.is_available() else "cpu"
     # Train the cube
-    return training_loop(config, val_config, log_config, device=device)
+    return training_loop(config, device=device, progressbar=progressbar)
 
 
 if __name__ == "__main__":
     os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
     parser = ArgumentParser()
     parser.add_argument("asteroid", type=str)
-    parser.add_argument("--tensorboard", "-t", action="store_true")
+    parser.add_argument(
+        "--progressbar",
+        "-p",
+        action="store_true",
+        help="Show progress bar during training",
+    )
     args = parser.parse_args()
 
-    cube = train(args.asteroid, args.tensorboard)
-
-    if not args.tensorboard:
-        # If not using tensorboard, save the output in the default directory
-        output_path = OUTPUT_DIR / "pinn_gm"
-        model_path = output_path / args.asteroid / "model.pt"
-        os.makedirs(model_path.parent, exist_ok=True)
-        torch.save(cube, model_path)
+    pinn = train(args.asteroid, progressbar=args.progressbar)
+    output_path = OUTPUT_DIR / "pinn_gm"
+    model_path = output_path / args.asteroid / "model.pt"
+    os.makedirs(model_path.parent, exist_ok=True)
+    torch.save(pinn, model_path)