diff --git a/apax/cli/templates/md_config_minimal.yaml b/apax/cli/templates/md_config_minimal.yaml
index 4f0a0a4e..4f5bcf6b 100644
--- a/apax/cli/templates/md_config_minimal.yaml
+++ b/apax/cli/templates/md_config_minimal.yaml
@@ -11,9 +11,9 @@ ensemble:
     tau: 100
 
 duration: <DURATION> # fs
-n_inner: 100 # compiled innner steps
+n_inner: 500 # compiled innner steps
 sampling_rate: 10  # dump interval
-buffer_size: 100
+buffer_size: 2500
 dr_threshold: 0.5 # Neighborlist skin
 extra_capacity: 0
 
diff --git a/apax/cli/templates/train_config_full.yaml b/apax/cli/templates/train_config_full.yaml
index 13d89656..4aef6020 100644
--- a/apax/cli/templates/train_config_full.yaml
+++ b/apax/cli/templates/train_config_full.yaml
@@ -1,7 +1,6 @@
 n_epochs: <NUMBER OF EPOCHS>
 seed: 1
 patience: null
-n_jitted_steps: 1
 data_parallel: True
 weight_average: null
 
@@ -24,7 +23,7 @@ data:
   n_train: 1000
   n_valid: 100
 
-  batch_size: 32
+  batch_size: 4
   valid_batch_size: 100
 
   shift_method: "per_element_regression_shift"
@@ -39,30 +38,37 @@ data:
 model:
   name: gmnn
   basis:
-    name: gaussian
-    n_basis: 7
-    r_max: 6.0
-    r_min: 0.5
+    name: bessel
+    n_basis: 16
+    r_max: 5.0
 
   ensemble: null
-  # if you would like to train model ensembles, this can be achieved with
-  # the following example.
+  # if you would like to use emirical repulsion corrections
+  # with the following example.
+  # empirical_corrections:
+  #   - name: exponential
+  #     r_max: 1.5
+
+  # if you would like to train model ensembles, this can be
+  # achieved with the following example.
+  # Hint: loss type hase to be changed to a probabalistic loss like nll or crps
   # ensemble:
-  #  kind: full
+  #  kind: shallow
   #  n_members: N
 
   n_radial: 5
   n_contr: 8
-  nn: [512, 512]
+  nn: [256, 256]
 
-  calc_stress: true
+  calc_stress: false
 
-  w_init: normal
+  w_init: lecun
   b_init: zeros
-  descriptor_dtype: fp64
+  descriptor_dtype: fp32
   readout_dtype: fp32
-  scale_shift_dtype: fp32
+  scale_shift_dtype: fp64
   emb_init: uniform
+  use_ntk: false
 
 loss:
 - name: energy
@@ -86,20 +92,21 @@ metrics:
 optimizer:
   name: adam
   kwargs: {}
-  emb_lr: 0.03
-  nn_lr: 0.03
-  scale_lr: 0.001
-  shift_lr: 0.05
-  zbl_lr: 0.001
+  emb_lr: 0.001
+  nn_lr: 0.001
+  scale_lr: 0.0001
+  shift_lr: 0.003
+  zbl_lr: 0.0001
   schedule:
-    name: linear
-    transition_begin: 0
-    end_value: 1e-6
+    name: cyclic_cosine
+    period: 40
+    decay_factor: 0.93
+
 callbacks:
 - name: csv
 
 checkpoints:
-  ckpt_interval: 1
+  ckpt_interval: 500
   # The options below are used for transfer learning
   base_model_checkpoint: null
   reset_layers: []
diff --git a/apax/cli/templates/train_config_minimal.yaml b/apax/cli/templates/train_config_minimal.yaml
index 67f96a08..8aaa6d98 100644
--- a/apax/cli/templates/train_config_minimal.yaml
+++ b/apax/cli/templates/train_config_minimal.yaml
@@ -8,7 +8,7 @@ data:
 
   n_train: 1000
   n_valid: 100
-  batch_size: 32
+  batch_size: 4
   valid_batch_size: 100
 
 metrics:
diff --git a/apax/config/lr_config.py b/apax/config/lr_config.py
index 23791f2b..770fdf89 100644
--- a/apax/config/lr_config.py
+++ b/apax/config/lr_config.py
@@ -33,13 +33,13 @@ class CyclicCosineLR(LRSchedule, frozen=True, extra="forbid"):
 
     Parameters
     ----------
-    period: int = 20
+    period: int = 40
         Length of a cycle in epochs.
-    decay_factor: NonNegativeFloat = 1.0
+    decay_factor: NonNegativeFloat = 0.93
         Factor by which to decrease the LR after each cycle.
         1.0 means no decrease.
     """
 
     name: Literal["cyclic_cosine"]
-    period: int = 20
-    decay_factor: NonNegativeFloat = 1.0
+    period: int = 40
+    decay_factor: NonNegativeFloat = 0.93
diff --git a/apax/config/md_config.py b/apax/config/md_config.py
index aa1f209b..f61bca79 100644
--- a/apax/config/md_config.py
+++ b/apax/config/md_config.py
@@ -229,12 +229,12 @@ class MDConfig(BaseModel, frozen=True, extra="forbid"):
         | Time step in fs.
     duration : float, required
         | Total simulation time in fs.
-    n_inner : int, default = 100
+    n_inner : int, default = 500
         | Number of compiled simulation steps (i.e. number of iterations of the
         | `jax.lax.fori_loop` loop). Also determines atoms buffer size.
     sampling_rate : int, default = 10
         | Interval between saving frames.
-    buffer_size : int, default = 100
+    buffer_size : int, default = 2500
         | Number of collected frames to be dumped at once.
     dr_threshold : float, default = 0.5
         | Skin of the neighborlist.
@@ -273,9 +273,9 @@ class MDConfig(BaseModel, frozen=True, extra="forbid"):
     )
 
     duration: PositiveFloat
-    n_inner: PositiveInt = 100
+    n_inner: PositiveInt = 500
     sampling_rate: PositiveInt = 10
-    buffer_size: PositiveInt = 100
+    buffer_size: PositiveInt = 2500
     dr_threshold: PositiveFloat = 0.5
     extra_capacity: NonNegativeInt = 0
 
diff --git a/apax/config/model_config.py b/apax/config/model_config.py
index 4ac054fd..43f6f6a9 100644
--- a/apax/config/model_config.py
+++ b/apax/config/model_config.py
@@ -35,15 +35,15 @@ class BesselBasisConfig(BaseModel, extra="forbid"):
 
     Parameters
     ----------
-    n_basis : PositiveInt, default = 7
+    n_basis : PositiveInt, default = 16
         Number of uncontracted basis functions.
-    r_max : PositiveFloat, default = 6.0
+    r_max : PositiveFloat, default = 5.0
         Cutoff radius of the descriptor.
     """
 
     name: Literal["bessel"] = "bessel"
-    n_basis: PositiveInt = 7
-    r_max: PositiveFloat = 6.0
+    n_basis: PositiveInt = 16
+    r_max: PositiveFloat = 5.0
 
 
 BasisConfig = Union[GaussianBasisConfig, BesselBasisConfig]
@@ -84,6 +84,11 @@ class ShallowEnsembleConfig(BaseModel, extra="forbid"):
         If set to an integer, the jacobian of ensemble energies wrt. to positions will be computed
         in chunks of that size. This sacrifices some performance for the possibility to use relatively
         large ensemble sizes.
+
+    Hint
+    ----------
+    Loss type hase to be changed to a probabalistic loss like 'nll' or 'crps'
+
     """
 
     kind: Literal["shallow"] = "shallow"
@@ -101,12 +106,12 @@ class Correction(BaseModel, extra="forbid"):
 
 class ZBLRepulsion(Correction, extra="forbid"):
     name: Literal["zbl"]
-    r_max: NonNegativeFloat = 2.0
+    r_max: NonNegativeFloat = 1.5
 
 
 class ExponentialRepulsion(Correction, extra="forbid"):
     name: Literal["exponential"]
-    r_max: NonNegativeFloat = 2.0
+    r_max: NonNegativeFloat = 1.5
 
 
 EmpiricalCorrection = Union[ZBLRepulsion, ExponentialRepulsion]
@@ -120,13 +125,13 @@ class BaseModelConfig(BaseModel, extra="forbid"):
     ----------
     basis : BasisConfig, default = GaussianBasisConfig()
         Configuration for primitive basis funtions.
-    nn : List[PositiveInt], default = [512, 512]
+    nn : List[PositiveInt], default = [256, 256]
         Number of hidden layers and units in those layers.
-    w_init : Literal["normal", "lecun"], default = "normal"
+    w_init : Literal["normal", "lecun"], default = "lecun"
         Initialization scheme for the neural network weights.
-    b_init : Literal["normal", "zeros"], default = "normal"
+    b_init : Literal["normal", "zeros"], default = "zeros"
         Initialization scheme for the neural network biases.
-    use_ntk : bool, default = True
+    use_ntk : bool, default = False
         Whether or not to use NTK parametrization.
     ensemble : Optional[EnsembleConfig], default = None
         What kind of model ensemble to use (optional).
@@ -134,17 +139,17 @@ class BaseModelConfig(BaseModel, extra="forbid"):
         Whether to include the ZBL correction.
     calc_stress : bool, default = False
         Whether to calculate stress during model evaluation.
-    descriptor_dtype : Literal["fp32", "fp64"], default = "fp64"
+    descriptor_dtype : Literal["fp32", "fp64"], default = "fp32"
         Data type for descriptor calculations.
     readout_dtype : Literal["fp32", "fp64"], default = "fp32"
         Data type for readout calculations.
-    scale_shift_dtype : Literal["fp32", "fp64"], default = "fp32"
+    scale_shift_dtype : Literal["fp32", "fp64"], default = "fp64"
         Data type for scale and shift parameters.
     """
 
     basis: BasisConfig = Field(BesselBasisConfig(name="bessel"), discriminator="name")
 
-    nn: List[PositiveInt] = [128, 128]
+    nn: List[PositiveInt] = [256, 256]
     w_init: Literal["normal", "lecun"] = "lecun"
     b_init: Literal["normal", "zeros"] = "zeros"
     use_ntk: bool = False
diff --git a/apax/config/train_config.py b/apax/config/train_config.py
index 627d3025..df6e9f6e 100644
--- a/apax/config/train_config.py
+++ b/apax/config/train_config.py
@@ -118,7 +118,10 @@ class DataConfig(BaseModel, extra="forbid"):
         | dict of property name, shape (ragged or fixed) pairs. Currently unused.
     energy_regularisation :
         | Magnitude of the regularization in the per-element energy regression.
-
+    pos_unit : str, default = "Ang"
+        unit of length
+    energy_unit : str, default = "eV"
+        unit of energy
     """
 
     directory: str
@@ -210,16 +213,20 @@ class OptimizerConfig(BaseModel, frozen=True, extra="forbid"):
     ----------
     name : str, default = "adam"
         Name of the optimizer. Can be any `optax` optimizer.
-    emb_lr : NonNegativeFloat, default = 0.02
+    emb_lr : NonNegativeFloat, default = 0.001
         Learning rate of the elemental embedding contraction coefficients.
-    nn_lr : NonNegativeFloat, default = 0.03
+    nn_lr : NonNegativeFloat, default = 0.001
         Learning rate of the neural network parameters.
-    scale_lr : NonNegativeFloat, default = 0.001
+    scale_lr : NonNegativeFloat, default = 0.0001
         Learning rate of the elemental output scaling factors.
-    shift_lr : NonNegativeFloat, default = 0.05
+    shift_lr : NonNegativeFloat, default = 0.003
         Learning rate of the elemental output shifts.
-    zbl_lr : NonNegativeFloat, default = 0.001
+    zbl_lr : NonNegativeFloat, default = 0.0001
         Learning rate of the ZBL correction parameters.
+    rep_scale_lr : NonNegativeFloat, default = 0.001
+        LR for the length scale of thes exponential repulsion potential.
+    rep_prefactor_lr : NonNegativeFloat, default = 0.0001
+        LR for the strength of the exponential repulsion potential.
     gradient_clipping: NonNegativeFloat, default = 1000.0
         Per element Gradient clipping value.
         Default is so high that it effectively disabled.
@@ -230,11 +237,11 @@ class OptimizerConfig(BaseModel, frozen=True, extra="forbid"):
     """
 
     name: str = "adam"
-    emb_lr: NonNegativeFloat = 0.02
-    nn_lr: NonNegativeFloat = 0.03
-    scale_lr: NonNegativeFloat = 0.001
-    shift_lr: NonNegativeFloat = 0.05
-    zbl_lr: NonNegativeFloat = 0.001
+    emb_lr: NonNegativeFloat = 0.001
+    nn_lr: NonNegativeFloat = 0.001
+    scale_lr: NonNegativeFloat = 0.0001
+    shift_lr: NonNegativeFloat = 0.003
+    zbl_lr: NonNegativeFloat = 0.0001
     rep_scale_lr: NonNegativeFloat = 0.001
     rep_prefactor_lr: NonNegativeFloat = 0.0001
 
@@ -362,7 +369,7 @@ class CheckpointConfig(BaseModel, extra="forbid"):
     reset_layers: List of layer names for which the parameters will be reinitialized.
     """
 
-    ckpt_interval: PositiveInt = 1
+    ckpt_interval: PositiveInt = 500
     base_model_checkpoint: Optional[str] = None
     reset_layers: List[str] = []
 
diff --git a/apax/md/simulate.py b/apax/md/simulate.py
index a29108a2..4f299187 100644
--- a/apax/md/simulate.py
+++ b/apax/md/simulate.py
@@ -17,7 +17,7 @@
 from apax.config import Config, MDConfig, parse_config
 from apax.config.md_config import Integrator
 from apax.md.ase_calc import make_ensemble, maybe_vmap
-from apax.md.constraints import Constraint, ConstraintBase, FixAtoms
+from apax.md.constraints import Constraint, ConstraintBase
 from apax.md.dynamics_checks import DynamicsCheckBase, DynamicsChecks
 from apax.md.io import H5TrajHandler, TrajHandler, truncate_trajectory_to_checkpoint
 from apax.md.md_checkpoint import load_md_state
@@ -255,8 +255,6 @@ def run_sim(
         dynamics_checks,
     )
 
-    constraints = [FixAtoms(indices=[6, 8])]
-
     apply_constraints = create_constraint_function(
         constraints,
         state,
diff --git a/apax/nodes/optimizer/__init__.py b/apax/nodes/optimizer/__init__.py
new file mode 100644
index 00000000..8d73c6f6
--- /dev/null
+++ b/apax/nodes/optimizer/__init__.py
@@ -0,0 +1,3 @@
+from apax.optimizer.get_optimizer import get_opt
+
+__all__ = ["get_opt"]
diff --git a/apax/nodes/optimizer/get_optimizer.py b/apax/nodes/optimizer/get_optimizer.py
new file mode 100644
index 00000000..d25d2ba0
--- /dev/null
+++ b/apax/nodes/optimizer/get_optimizer.py
@@ -0,0 +1,157 @@
+import logging
+
+import jax.numpy as jnp
+import numpy as np
+import optax
+from flax import traverse_util
+from flax.core.frozen_dict import freeze
+from optax._src import base
+
+from apax.optimizer.optimizers import ademamix, sam
+
+log = logging.getLogger(__name__)
+
+
+def cyclic_cosine_decay_schedule(
+    init_value: float,
+    steps_per_epoch,
+    period: int,
+    decay_factor: float = 0.9,
+) -> base.Schedule:
+    r"""Returns a function which implements cyclic cosine learning rate decay.
+
+    Args:
+        init_value: An initial value for the learning rate.
+
+    Returns:
+        schedule
+        A function that maps step counts to values.
+    """
+
+    def schedule(count):
+        cycle = count // (period * steps_per_epoch)
+        step_in_period = jnp.mod(count, period * steps_per_epoch)
+        arg = np.pi * step_in_period / (period * steps_per_epoch)
+        lr = init_value / 2 * (jnp.cos(arg) + 1)
+        lr = lr * (decay_factor**cycle)
+        return lr
+
+    return schedule
+
+
+def get_schedule(
+    lr: float,
+    n_epochs: int,
+    steps_per_epoch: int,
+    schedule_kwargs: dict,
+) -> optax._src.base.Schedule:
+    """
+    builds a linear learning rate schedule.
+    """
+    schedule_kwargs = schedule_kwargs.copy()
+    name = schedule_kwargs.pop("name")
+    if name == "linear":
+        lr_schedule = optax.linear_schedule(
+            init_value=lr, transition_steps=n_epochs * steps_per_epoch, **schedule_kwargs
+        )
+    elif name == "cyclic_cosine":
+        lr_schedule = cyclic_cosine_decay_schedule(lr, steps_per_epoch, **schedule_kwargs)
+    else:
+        raise KeyError(f"unknown learning rate schedule: {name}")
+    return lr_schedule
+
+
+class OptimizerFactory:
+    def __init__(
+        self, opt, n_epochs, steps_per_epoch, gradient_clipping, kwargs, schedule
+    ) -> None:
+        self.opt = opt
+        self.n_epochs = n_epochs
+        self.steps_per_epoch = steps_per_epoch
+        self.gradient_clipping = gradient_clipping
+        self.kwargs = kwargs
+        self.schedule = schedule
+
+    def create(self, lr):
+        if lr <= 1e-7:
+            optimizer = optax.set_to_zero()
+        else:
+            schedule = get_schedule(
+                lr, self.n_epochs, self.steps_per_epoch, self.schedule
+            )
+            optimizer = optax.chain(
+                optax.clip(self.gradient_clipping),
+                self.opt(schedule, **self.kwargs),
+                optax.zero_nans(),
+            )
+        return optimizer
+
+
+def get_opt(
+    params,
+    n_epochs: int,
+    steps_per_epoch: int,
+    emb_lr: float = 0.02,
+    nn_lr: float = 0.03,
+    scale_lr: float = 0.001,
+    shift_lr: float = 0.05,
+    zbl_lr: float = 0.001,
+    rep_scale_lr: float = 0.001,
+    rep_prefactor_lr: float = 0.0001,
+    gradient_clipping=1000.0,
+    name: str = "adam",
+    kwargs: dict = {},
+    schedule: dict = {},
+) -> optax._src.base.GradientTransformation:
+    """
+    Builds an optimizer with different learning rates for each parameter group.
+    Several `optax` optimizers are supported.
+    """
+
+    log.info("Initializing Optimizer")
+    if name == "sam":
+        opt = sam
+    elif name == "ademamix":
+        opt = ademamix
+    else:
+        opt = getattr(optax, name)
+
+    opt_fac = OptimizerFactory(
+        opt, n_epochs, steps_per_epoch, gradient_clipping, kwargs, schedule
+    )
+
+    nn_opt = opt_fac.create(nn_lr)
+    emb_opt = opt_fac.create(emb_lr)
+    scale_opt = opt_fac.create(scale_lr)
+    shift_opt = opt_fac.create(shift_lr)
+    zbl_opt = opt_fac.create(zbl_lr)
+    rep_scale_opt = opt_fac.create(rep_scale_lr)
+    rep_prefactor_opt = opt_fac.create(rep_prefactor_lr)
+
+    partition_optimizers = {
+        "w": nn_opt,
+        "b": nn_opt,
+        "atomic_type_embedding": emb_opt,
+        "scale_per_element": scale_opt,
+        "shift_per_element": shift_opt,
+        "a_exp": zbl_opt,
+        "a_num": zbl_opt,
+        "coefficients": zbl_opt,
+        "exponents": zbl_opt,
+        "rep_scale": rep_scale_opt,
+        "rep_prefactor": rep_prefactor_opt,
+        "kernel": nn_opt,
+        "bias": nn_opt,
+        "embedding": emb_opt,
+        "weights_K": nn_opt,
+        "weights_Q": nn_opt,
+        "weights_V": nn_opt,
+        "scale": scale_opt,
+    }
+
+    param_partitions = freeze(
+        traverse_util.path_aware_map(lambda path, v: path[-1], params)
+    )
+    tx = optax.multi_transform(partition_optimizers, param_partitions)
+
+    return tx
diff --git a/apax/nodes/optimizer/optimizers.py b/apax/nodes/optimizer/optimizers.py
new file mode 100644
index 00000000..22237e22
--- /dev/null
+++ b/apax/nodes/optimizer/optimizers.py
@@ -0,0 +1,84 @@
+from typing import NamedTuple
+
+import chex
+import jax.numpy as jnp
+import optax
+from jax import tree_util as jtu
+from optax import bias_correction, contrib, update_moment, update_moment_per_elem_norm
+from optax._src import base, combine, numerics, transform
+from optax.tree_utils import tree_zeros_like
+
+
+class ScaleByAdemamixState(NamedTuple):
+    count: chex.Array
+    count_m2: chex.Array
+    m1: base.Updates
+    m2: base.Updates
+    nu: base.Updates
+
+
+def ademamix(
+    lr,
+    b1=0.9,
+    b2=0.999,
+    b3=0.9999,
+    alpha=5.0,
+    b3_scheduler=None,  # TODO maybe implement schedules
+    alpha_scheduler=None,
+    eps=1e-8,
+    weight_decay=0.0,
+):
+    """AdEMAmix implementation directly taken from the original implementation:
+    2409.03137
+    """
+    return combine.chain(
+        scale_by_ademamix(b1, b2, b3, alpha, b3_scheduler, alpha_scheduler, eps),
+        transform.add_decayed_weights(weight_decay),
+        transform.scale_by_learning_rate(lr),
+    )
+
+
+def scale_by_ademamix(b1, b2, b3, alpha, b3_scheduler, alpha_scheduler, eps):
+    def init_fn(params):
+        m1 = tree_zeros_like(params)  # fast EMA
+        m2 = tree_zeros_like(params)  # slow EMA
+        nu = tree_zeros_like(params)  # second moment estimate
+        return ScaleByAdemamixState(
+            count=jnp.zeros([], jnp.int32),
+            count_m2=jnp.zeros([], jnp.int32),
+            m1=m1,
+            m2=m2,
+            nu=nu,
+        )
+
+    def update_fn(updates, state, params=None):
+        del params
+        c_b3 = b3_scheduler(state.count_m2) if b3_scheduler is not None else b3
+        c_alpha = (
+            alpha_scheduler(state.count_m2) if alpha_scheduler is not None else alpha
+        )
+        m1 = update_moment(updates, state.m1, b1, 1)  # m1 = b1 * m1 + (1-b1) * updates
+        m2 = update_moment(updates, state.m2, c_b3, 1)
+        nu = update_moment_per_elem_norm(updates, state.nu, b2, 2)
+        count_inc = numerics.safe_int32_increment(state.count)
+        count_m2_inc = numerics.safe_int32_increment(state.count_m2)
+        m1_hat = bias_correction(m1, b1, count_inc)
+        nu_hat = bias_correction(nu, b2, count_inc)
+        updates = jtu.tree_map(
+            lambda m1_, m2_, v_: (m1_ + c_alpha * m2_) / (jnp.sqrt(v_) + eps),
+            m1_hat,
+            m2,
+            nu_hat,
+        )
+        return updates, ScaleByAdemamixState(
+            count=count_inc, count_m2=count_m2_inc, m1=m1, m2=m2, nu=nu
+        )
+
+    return base.GradientTransformation(init_fn, update_fn)
+
+
+def sam(lr=1e-3, b1=0.9, b2=0.999, rho=0.001, sync_period=2):
+    """A SAM optimizer using Adam for the outer optimizer."""
+    opt = optax.adam(lr, b1=b1, b2=b2)
+    adv_opt = optax.chain(contrib.normalize(), optax.sgd(rho))
+    return contrib.sam(opt, adv_opt, sync_period=sync_period)
diff --git a/apax/train/callbacks.py b/apax/train/callbacks.py
index 90825977..a89baa66 100644
--- a/apax/train/callbacks.py
+++ b/apax/train/callbacks.py
@@ -45,6 +45,10 @@ def on_train_end(self, logs=None):
         for cb in self.callbacks:
             cb.on_train_end(logs)
 
+    def on_test_batch_end(self, batch, logs=None):
+        for cb in self.callbacks:
+            cb.on_test_batch_end(batch, logs)
+
 
 def format_str(k):
     return f"{k:.5f}"
diff --git a/apax/train/eval.py b/apax/train/eval.py
index e111a618..984551af 100644
--- a/apax/train/eval.py
+++ b/apax/train/eval.py
@@ -120,7 +120,6 @@ def predict(model, params, Metrics, loss_fn, test_ds, callbacks, is_ensemble=Fal
         0, test_ds.n_data, desc="Structure", ncols=100, disable=False, leave=True
     )
     for batch_idx in range(test_ds.n_data):
-        callbacks.on_test_batch_begin(batch_idx)
         batch = next(batch_test_ds)
         batch_start_time = time.time()
 
diff --git a/apax/utils/jax_md_reduced/simulate.py b/apax/utils/jax_md_reduced/simulate.py
index 4f238887..f590cf81 100644
--- a/apax/utils/jax_md_reduced/simulate.py
+++ b/apax/utils/jax_md_reduced/simulate.py
@@ -290,6 +290,7 @@ def init_fn(key, R, mass=f32(1.0), **kwargs):
     @jit
     def step_fn(state, **kwargs):
         _dt = kwargs.pop("dt", dt)
+        _ = kwargs.pop("kT")
         return velocity_verlet(force_fn, shift_fn, _dt, state, **kwargs)
 
     return init_fn, step_fn
diff --git a/examples/01_Model_Training.ipynb b/examples/01_Model_Training.ipynb
index 08d983bf..5b4bc7e1 100644
--- a/examples/01_Model_Training.ipynb
+++ b/examples/01_Model_Training.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -57,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -107,11 +107,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!apax template train"
+    "!apax template train --full"
    ]
   },
   {
@@ -126,23 +126,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1 validation error for Config\n",
+      "1 validation errors for config\n",
       "n_epochs\n",
-      "  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='<NUMBER OF EPOCHS>', input_type=str]\n",
-      "    For further information visit https://errors.pydantic.dev/2.6/v/int_parsing\n",
+      "  Input should be a valid integer, unable to parse string as an integer\n",
+      "  input_type: str\n",
+      "  input: <NUMBER OF EPOCHS>\n",
+      "\n",
       "\u001b[31mConfiguration Invalid!\u001b[0m\n"
      ]
     }
    ],
    "source": [
-    "!apax validate train config.yaml"
+    "!apax validate train config_full.yaml"
    ]
   },
   {
@@ -153,13 +155,14 @@
     "\n",
     "```yaml\n",
     "data:\n",
-    "  batch_size: 32\n",
+    "  batch_size: 4\n",
     "  data_path: project/ethanol_ccsd_t-train_mod.xyz\n",
     "  directory: project/models\n",
     "  energy_unit: kcal/mol\n",
     "  experiment: ethanol_ccsd_t_cli\n",
     "  n_train: 990\n",
     "  n_valid: 10\n",
+    "  energy_unit: kcal/mol\n",
     "  pos_unit: Ang\n",
     "  valid_batch_size: 100\n",
     "loss:\n",
@@ -185,7 +188,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -193,14 +196,14 @@
     "\n",
     "from apax.utils.helpers import mod_config\n",
     "\n",
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
     "    \"data\": {\n",
     "        \"n_train\": 990,\n",
     "        \"n_valid\": 10,\n",
-    "        \"valid_batch_size\": 1,\n",
+    "        \"valid_batch_size\": 10,\n",
     "        \"experiment\": \"ethanol_ccsd_t_cli\",\n",
     "        \"directory\": \"project/models\",\n",
     "        \"data_path\": str(train_file_path),\n",
@@ -208,17 +211,17 @@
     "        \"energy_unit\": \"kcal/mol\",\n",
     "        \"pos_unit\": \"Ang\",\n",
     "    },\n",
-    "    \"model\": {\"descriptor_dtype\": \"fp64\"},\n",
     "}\n",
+    "\n",
     "config_dict = mod_config(config_path, config_updates)\n",
     "\n",
-    "with open(\"config.yaml\", \"w\") as conf:\n",
+    "with open(\"config_full.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -226,12 +229,12 @@
      "output_type": "stream",
      "text": [
       "\u001b[32mSuccess!\u001b[0m\n",
-      "config.yaml is a valid training config.\n"
+      "config_full.yaml is a valid training config.\n"
      ]
     }
    ],
    "source": [
-    "!apax validate train config.yaml"
+    "!apax validate train config_full.yaml"
    ]
   },
   {
@@ -245,32 +248,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 12:22:53 | Running on [cuda(id=0)]\n",
-      "INFO | 12:22:53 | Initializing Callbacks\n",
-      "INFO | 12:22:53 | Initializing Loss Function\n",
-      "INFO | 12:22:53 | Initializing Metrics\n",
-      "INFO | 12:22:53 | Running Input Pipeline\n",
-      "INFO | 12:22:53 | Read data file project/ethanol_ccsd_t-train_mod.xyz\n",
-      "INFO | 12:22:53 | Loading data from project/ethanol_ccsd_t-train_mod.xyz\n",
-      "INFO | 12:22:54 | Computing per element energy regression.\n",
-      "INFO | 12:22:54 | Initializing Model\n",
-      "INFO | 12:22:54 | initializing 1 models\n",
-      "INFO | 12:23:03 | Initializing Optimizer\n",
-      "INFO | 12:23:04 | Beginning Training\n",
-      "Epochs: 100%|█████████████████████████████████████| 100/100 [00:48<00:00,  2.07it/s, val_loss=0.105]\n",
-      "INFO | 12:23:52 | Finished training\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268187.845256  520474 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268187.848463  520474 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:36:31 | Running on [CudaDevice(id=0)]\n",
+      "INFO | 09:36:31 | Initializing Callbacks\n",
+      "INFO | 09:36:32 | Initializing Loss Function\n",
+      "INFO | 09:36:32 | Initializing Metrics\n",
+      "INFO | 09:36:32 | Running Input Pipeline\n",
+      "INFO | 09:36:32 | Reading data file project/ethanol_ccsd_t-train_mod.xyz\n",
+      "INFO | 09:36:32 | Found n_train: 990, n_val: 10\n",
+      "INFO | 09:36:32 | Computing per element energy regression.\n",
+      "INFO | 09:36:33 | Building Standard model\n",
+      "INFO | 09:36:33 | initializing 1 model(s)\n",
+      "INFO | 09:36:40 | Initializing Optimizer\n",
+      "INFO | 09:36:40 | Beginning Training\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:36:47 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [00:59<00:00,  1.69it/s, val_loss=0.0287]\n",
+      "INFO | 09:37:39 | Finished training\n"
      ]
     }
    ],
    "source": [
-    "!apax train config.yaml"
+    "!apax train config_full.yaml"
    ]
   },
   {
@@ -296,14 +303,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Epochs: 100%|█████████████████████████████████████| 100/100 [00:47<00:00,  2.12it/s, val_loss=0.105]\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268260.595895  520335 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268260.599126  520335 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:37:58 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [01:01<00:00,  1.62it/s, val_loss=0.0287]\n"
      ]
     }
    ],
@@ -311,7 +322,7 @@
     "from apax.train.run import run\n",
     "from apax.utils.helpers import mod_config\n",
     "\n",
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"data\": {\n",
@@ -326,12 +337,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 4 Axes>"
       ]
@@ -366,6 +377,7 @@
     "    axes[id].set_ylabel(f\"{key}\")\n",
     "    axes[id].set_xlabel(r\"epoch\")\n",
     "\n",
+    "plt.legend()\n",
     "plt.show()"
    ]
   },
@@ -381,14 +393,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Structure: 100%|███████████████████████████████| 999/999 [00:03<00:00, 280.74it/s, test_loss=0.0838]\n"
+      "Structure: 100%|███████████████████████████████| 999/999 [00:04<00:00, 228.47it/s, test_loss=0.0253]\n"
      ]
     }
    ],
@@ -400,29 +412,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Structure: 100%|███████████████████████████████| 999/999 [00:04<00:00, 214.87it/s, test_loss=0.0837]\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268339.519757  522195 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268339.522952  522195 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "Structure: 100%|███████████████████████████████| 999/999 [00:04<00:00, 229.06it/s, test_loss=0.0253]\n"
      ]
     }
    ],
    "source": [
-    "!apax eval config.yaml"
+    "!apax eval config_full.yaml"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 4 Axes>"
       ]
@@ -472,11 +487,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!rm -rf project config.yaml eval.log"
+    "# !rm -rf project config_full.yaml eval.log\n"
    ]
   },
   {
@@ -489,7 +504,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "apax311",
+   "display_name": "new_defaults",
    "language": "python",
    "name": "python3"
   },
@@ -503,7 +518,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.11.10"
   }
  },
  "nbformat": 4,
diff --git a/examples/02_Molecular_Dynamics.ipynb b/examples/02_Molecular_Dynamics.ipynb
index 83b414e8..0c2f5748 100644
--- a/examples/02_Molecular_Dynamics.ipynb
+++ b/examples/02_Molecular_Dynamics.ipynb
@@ -36,9 +36,17 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "There is already a config file in the working directory.\n"
+     ]
+    }
+   ],
    "source": [
-    "!apax template train    # generating the config file in the cwd"
+    "!apax template train --full  # generating the config file in the cwd"
    ]
   },
   {
@@ -50,7 +58,11 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Epochs: 100%|█████████████████████████████████████| 100/100 [00:47<00:00,  2.09it/s, val_loss=0.105]\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268437.776210  522570 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268437.779425  522570 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:40:57 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [01:01<00:00,  1.63it/s, val_loss=0.0287]\n"
      ]
     }
    ],
@@ -74,14 +86,14 @@
     "\n",
     "\n",
     "# Modify the config file (can be done manually)\n",
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
     "    \"data\": {\n",
     "        \"n_train\": 990,\n",
     "        \"n_valid\": 10,\n",
-    "        \"valid_batch_size\": 1,\n",
+    "        \"valid_batch_size\": 10,\n",
     "        \"experiment\": experiment,\n",
     "        \"directory\": \"project/models\",\n",
     "        \"data_path\": str(train_file_path),\n",
@@ -89,10 +101,9 @@
     "        \"energy_unit\": \"kcal/mol\",\n",
     "        \"pos_unit\": \"Ang\",\n",
     "    },\n",
-    "    \"model\": {\"descriptor_dtype\": \"fp64\"},\n",
     "}\n",
     "config_dict = mod_config(config_path, config_updates)\n",
-    "with open(\"config.yaml\", \"w\") as conf:\n",
+    "with open(\"config_full.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)\n",
     "\n",
     "# Train model\n",
@@ -139,7 +150,7 @@
     "    atoms=atoms,\n",
     "    timestep=0.5 * units.fs,\n",
     "    temperature_K=300,\n",
-    "    friction=0.01 / units.fs,\n",
+    "    friction=0.001 / units.fs,\n",
     ")\n",
     "\n",
     "traj = Trajectory(\"example.traj\", \"w\", atoms)\n",
@@ -182,7 +193,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -236,7 +247,7 @@
     "\n",
     "Open the config and specify the starting structure and simulation parameters.\n",
     "If you specify the data set file itself, the first structure of the data set is going to be used as the initial structure.\n",
-    "Your `md_config_minimal.yaml` should look similar to this:\n",
+    "Your `md_config.yaml` should look similar to this:\n",
     "\n",
     "```yaml\n",
     "ensemble:\n",
@@ -266,7 +277,10 @@
     "    ),  # if the model from example 01 is used change this\n",
     "    \"duration\": 5000,  # fs\n",
     "    \"ensemble\": {\n",
-    "        \"temperature\": 300,\n",
+    "        \"temperature_schedule\": {\n",
+    "            \"T0\": 300,\n",
+    "            \"name\": \"constant\",\n",
+    "        },\n",
     "    },\n",
     "}\n",
     "config_dict = mod_config(md_config_path, config_updates)\n",
@@ -319,22 +333,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 21:44:19 | reading structure\n",
-      "INFO | 21:44:19 | Unable to initialize backend 'rocm': NOT_FOUND: Could not find registered platform with name: \"rocm\". Available platform names are: CUDA\n",
-      "INFO | 21:44:19 | Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
-      "INFO | 21:44:20 | initializing model\n",
-      "INFO | 21:44:20 | loading checkpoint from /home/linux3_i1/segreto/uni/dev/apax/examples/project/models/etoh_md/best\n",
-      "INFO | 21:44:20 | Initializing new trajectory file at md/md.h5\n",
-      "INFO | 21:44:20 | initializing simulation\n",
-      "INFO | 21:44:23 | running simulation for 5.0 ps\n",
-      "Simulation:   0%|                                                         | 0/10000 [00:00<?, ?it/s]INFO | 21:44:23 | get_compile_options: no backend supplied; disabling XLA-AutoFDO profile\n",
-      "Simulation: 100%|█████████████████████████████████| 10000/10000 [00:20<00:00, 495.87it/s, T=319.8 K]\n",
-      "INFO | 21:44:47 | simulation finished after elapsed time: 24.48 s\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268531.123831  523603 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268531.126852  523603 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:42:13 | reading structure\n",
+      "INFO | 09:42:13 | Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
+      "INFO | 09:42:13 | Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n",
+      "INFO | 09:42:13 | initializing model\n",
+      "INFO | 09:42:14 | loading checkpoint from /SCR1/segreto/dev/apax/examples/project/models/etoh_md/best\n",
+      "INFO | 09:42:14 | Building Standard model\n",
+      "INFO | 09:42:14 | initializing simulation\n",
+      "INFO | 09:42:22 | running simulation for 5.0 ps\n",
+      "Simulation: 100%|█████████████████████████████████| 10000/10000 [00:14<00:00, 710.91it/s, T=177.5 K]\n",
+      "WARNING | 09:42:36 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Preparing data: 100%|████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 73997.11it/s]\n",
+      "Creating groups: 100%|███████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 256.12it/s]\n",
+      "Creating observables: 100%|█████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 1202.15it/s]\n",
+      "INFO | 09:42:36 | simulation finished after: 14.16 s\n",
+      "INFO | 09:42:36 | performance summary: 30.50 ns/day, 157.38 mu s/step/atom\n"
      ]
     }
    ],
    "source": [
-    "!apax md config.yaml md_config.yaml"
+    "!apax md config_full.yaml md_config.yaml"
    ]
   },
   {
@@ -352,7 +373,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -377,11 +398,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!rm -rf project md config.yaml example.traj md_config.yaml"
+    "!rm -rf project md config_full.yaml example.traj md_config.yaml"
    ]
   },
   {
@@ -394,7 +415,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "apax",
+   "display_name": "new_defaults",
    "language": "python",
    "name": "python3"
   },
@@ -408,7 +429,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.11.10"
   }
  },
  "nbformat": 4,
diff --git a/examples/03_Transfer_Learning.ipynb b/examples/03_Transfer_Learning.ipynb
index 36c2ad6e..5080e533 100644
--- a/examples/03_Transfer_Learning.ipynb
+++ b/examples/03_Transfer_Learning.ipynb
@@ -114,18 +114,9 @@
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/ms/miniconda3/envs/apax311/lib/python3.11/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
-      "  pid, fd = os.forkpty()\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "!apax template train"
+    "!apax template train --full"
    ]
   },
   {
@@ -134,7 +125,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
@@ -152,7 +143,7 @@
     "}\n",
     "config_dict = mod_config(config_path, config_updates)\n",
     "\n",
-    "with open(\"config.yaml\", \"w\") as conf:\n",
+    "with open(\"config_full.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)"
    ]
   },
@@ -165,26 +156,29 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 16:25:57 | Running on [cuda(id=0)]\n",
-      "INFO | 16:25:57 | Initializing Callbacks\n",
-      "INFO | 16:25:57 | Initializing Loss Function\n",
-      "INFO | 16:25:57 | Initializing Metrics\n",
-      "INFO | 16:25:57 | Running Input Pipeline\n",
-      "INFO | 16:25:57 | Read data file project/benzene_mod.xyz\n",
-      "INFO | 16:25:57 | Loading data from project/benzene_mod.xyz\n",
-      "INFO | 16:26:06 | Computing per element energy regression.\n",
-      "INFO | 16:26:06 | Initializing Model\n",
-      "INFO | 16:26:06 | initializing 1 models\n",
-      "INFO | 16:26:10 | Initializing Optimizer\n",
-      "INFO | 16:26:10 | Beginning Training\n",
-      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 16:26:23 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before May 1st, 2024. If your Pytree has empty ([], {}, None) values then use PyTreeCheckpointHandler(..., write_tree_metadata=True, ...) or use StandardCheckpointHandler to avoid TypeHandler Registry error. Please note that PyTreeCheckpointHandler.write_tree_metadata default value is already set to True.\n",
-      "Epochs: 100%|███████████████████████████████████| 100/100 [00:36<00:00,  2.71it/s, val_loss=0.00997]\n",
-      "INFO | 16:26:47 | Finished training\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268582.750898  524269 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268582.754067  524269 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:43:04 | Running on [CudaDevice(id=0)]\n",
+      "INFO | 09:43:04 | Initializing Callbacks\n",
+      "INFO | 09:43:04 | Initializing Loss Function\n",
+      "INFO | 09:43:04 | Initializing Metrics\n",
+      "INFO | 09:43:04 | Running Input Pipeline\n",
+      "INFO | 09:43:04 | Reading data file project/benzene_mod.xyz\n",
+      "INFO | 09:43:11 | Found n_train: 1000, n_val: 200\n",
+      "INFO | 09:43:11 | Computing per element energy regression.\n",
+      "INFO | 09:43:12 | Building Standard model\n",
+      "INFO | 09:43:12 | initializing 1 model(s)\n",
+      "INFO | 09:43:18 | Initializing Optimizer\n",
+      "INFO | 09:43:18 | Beginning Training\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:43:27 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [00:42<00:00,  2.36it/s, val_loss=0.0233]\n",
+      "INFO | 09:44:01 | Finished training\n"
      ]
     }
    ],
    "source": [
-    "!apax train config.yaml"
+    "!apax train config_full.yaml"
    ]
   },
   {
@@ -203,7 +197,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
@@ -234,21 +228,24 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 16:26:51 | Running on [cuda(id=0)]\n",
-      "INFO | 16:26:51 | Initializing Callbacks\n",
-      "INFO | 16:26:51 | Initializing Loss Function\n",
-      "INFO | 16:26:51 | Initializing Metrics\n",
-      "INFO | 16:26:51 | Running Input Pipeline\n",
-      "INFO | 16:26:51 | Read data file project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 16:26:51 | Loading data from project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 16:26:51 | Computing per element energy regression.\n",
-      "INFO | 16:26:51 | Initializing Model\n",
-      "INFO | 16:26:51 | initializing 1 models\n",
-      "INFO | 16:26:55 | Initializing Optimizer\n",
-      "INFO | 16:26:55 | Beginning Training\n",
-      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 16:27:07 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before May 1st, 2024. If your Pytree has empty ([], {}, None) values then use PyTreeCheckpointHandler(..., write_tree_metadata=True, ...) or use StandardCheckpointHandler to avoid TypeHandler Registry error. Please note that PyTreeCheckpointHandler.write_tree_metadata default value is already set to True.\n",
-      "Epochs: 100%|████████████████████████████████████| 100/100 [00:20<00:00,  4.81it/s, val_loss=0.0632]\n",
-      "INFO | 16:27:16 | Finished training\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268643.129714  525084 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268643.132821  525084 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:44:05 | Running on [CudaDevice(id=0)]\n",
+      "INFO | 09:44:05 | Initializing Callbacks\n",
+      "INFO | 09:44:05 | Initializing Loss Function\n",
+      "INFO | 09:44:05 | Initializing Metrics\n",
+      "INFO | 09:44:05 | Running Input Pipeline\n",
+      "INFO | 09:44:05 | Reading data file project/benzene_ccsd_t-train_mod.xyz\n",
+      "INFO | 09:44:06 | Found n_train: 50, n_val: 10\n",
+      "INFO | 09:44:06 | Computing per element energy regression.\n",
+      "INFO | 09:44:06 | Building Standard model\n",
+      "INFO | 09:44:06 | initializing 1 model(s)\n",
+      "INFO | 09:44:13 | Initializing Optimizer\n",
+      "INFO | 09:44:13 | Beginning Training\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:44:20 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|████████████████████████████████████| 100/100 [00:14<00:00,  6.96it/s, val_loss=0.0766]\n",
+      "INFO | 09:44:27 | Finished training\n"
      ]
     }
    ],
@@ -277,7 +274,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 100,\n",
@@ -318,30 +315,33 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 16:27:20 | Running on [cuda(id=0)]\n",
-      "INFO | 16:27:20 | Initializing Callbacks\n",
-      "INFO | 16:27:20 | Initializing Loss Function\n",
-      "INFO | 16:27:20 | Initializing Metrics\n",
-      "INFO | 16:27:20 | Running Input Pipeline\n",
-      "INFO | 16:27:20 | Read data file project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 16:27:20 | Loading data from project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 16:27:20 | Computing per element energy regression.\n",
-      "INFO | 16:27:20 | Initializing Model\n",
-      "INFO | 16:27:20 | initializing 1 models\n",
-      "INFO | 16:27:24 | Initializing Optimizer\n",
-      "INFO | 16:27:24 | loading checkpoint from project/models/benzene_dft/best\n",
-      "INFO | 16:27:24 | Transferring parameters from project/models/benzene_dft\n",
-      "INFO | 16:27:24 | Transferring parameter: radial_fn\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_0\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_0\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_1\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_1\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_2\n",
-      "INFO | 16:27:24 | Transferring parameter: dense_2\n",
-      "INFO | 16:27:24 | Beginning Training\n",
-      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 16:27:36 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before May 1st, 2024. If your Pytree has empty ([], {}, None) values then use PyTreeCheckpointHandler(..., write_tree_metadata=True, ...) or use StandardCheckpointHandler to avoid TypeHandler Registry error. Please note that PyTreeCheckpointHandler.write_tree_metadata default value is already set to True.\n",
-      "Epochs: 100%|███████████████████████████████████| 100/100 [00:20<00:00,  4.91it/s, val_loss=0.00483]\n",
-      "INFO | 16:27:45 | Finished training\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268669.330941  525885 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268669.334048  525885 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:44:31 | Running on [CudaDevice(id=0)]\n",
+      "INFO | 09:44:31 | Initializing Callbacks\n",
+      "INFO | 09:44:31 | Initializing Loss Function\n",
+      "INFO | 09:44:31 | Initializing Metrics\n",
+      "INFO | 09:44:31 | Running Input Pipeline\n",
+      "INFO | 09:44:31 | Reading data file project/benzene_ccsd_t-train_mod.xyz\n",
+      "INFO | 09:44:31 | Found n_train: 50, n_val: 10\n",
+      "INFO | 09:44:31 | Computing per element energy regression.\n",
+      "INFO | 09:44:31 | Building Standard model\n",
+      "INFO | 09:44:31 | initializing 1 model(s)\n",
+      "INFO | 09:44:38 | Initializing Optimizer\n",
+      "INFO | 09:44:38 | loading checkpoint from project/models/benzene_dft/best\n",
+      "INFO | 09:44:38 | Transferring parameters from project/models/benzene_dft\n",
+      "INFO | 09:44:38 | Transferring parameter: radial_fn\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_0\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_0\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_1\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_1\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_2\n",
+      "INFO | 09:44:38 | Transferring parameter: dense_2\n",
+      "INFO | 09:44:38 | Beginning Training\n",
+      "Epochs:   0%|                                                               | 0/100 [00:00<?, ?it/s]WARNING | 09:44:44 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|███████████████████████████████████| 100/100 [00:11<00:00,  8.62it/s, val_loss=0.00752]\n",
+      "INFO | 09:44:50 | Finished training\n"
      ]
     }
    ],
@@ -357,11 +357,27 @@
     "\n",
     "How much further can you improve the fine-tuning (or pretraining) setup?"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!rm -rf project config_full.yaml config_cc_baseline.yaml config_cc_ft.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "apax",
+   "display_name": "new_defaults",
    "language": "python",
    "name": "python3"
   },
@@ -375,7 +391,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.10"
   }
  },
  "nbformat": 4,
diff --git a/examples/04_Batch_Data_Selection.ipynb b/examples/04_Batch_Data_Selection.ipynb
index 6ab30370..abb58fa1 100644
--- a/examples/04_Batch_Data_Selection.ipynb
+++ b/examples/04_Batch_Data_Selection.ipynb
@@ -18,7 +18,17 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268812.515731  526715 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268812.518770  526715 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n"
+     ]
+    }
+   ],
    "source": [
     "from pathlib import Path\n",
     "\n",
@@ -47,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,29 +80,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/ms/miniconda3/envs/apax311/lib/python3.11/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
-      "  pid, fd = os.forkpty()\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "!apax template train"
+    "!apax template train --full"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "config_path = Path(\"config.yaml\")\n",
+    "config_path = Path(\"config_full.yaml\")\n",
     "\n",
     "config_updates = {\n",
     "    \"n_epochs\": 200,\n",
@@ -110,49 +111,43 @@
     "}\n",
     "config_dict = mod_config(config_path, config_updates)\n",
     "\n",
-    "with open(\"config.yaml\", \"w\") as conf:\n",
+    "with open(\"config_full.yaml\", \"w\") as conf:\n",
     "    yaml.dump(config_dict, conf, default_flow_style=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/ms/miniconda3/envs/apax311/lib/python3.11/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
-      "  pid, fd = os.forkpty()\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO | 18:13:29 | Running on [cuda(id=0)]\n",
-      "INFO | 18:13:29 | Initializing Callbacks\n",
-      "INFO | 18:13:29 | Initializing Loss Function\n",
-      "INFO | 18:13:29 | Initializing Metrics\n",
-      "INFO | 18:13:29 | Running Input Pipeline\n",
-      "INFO | 18:13:29 | Read training data file project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 18:13:29 | Read validation data file project/benzene_ccsd_t-test_mod.xyz\n",
-      "INFO | 18:13:29 | Loading data from project/benzene_ccsd_t-train_mod.xyz\n",
-      "INFO | 18:13:29 | Loading data from project/benzene_ccsd_t-test_mod.xyz\n",
-      "INFO | 18:13:30 | Computing per element energy regression.\n",
-      "INFO | 18:13:30 | Initializing Model\n",
-      "INFO | 18:13:30 | initializing 1 models\n",
-      "INFO | 18:13:34 | Initializing Optimizer\n",
-      "INFO | 18:13:34 | Beginning Training\n",
-      "Epochs:   0%|                                                               | 0/200 [00:00<?, ?it/s]WARNING | 18:13:47 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before May 1st, 2024. If your Pytree has empty ([], {}, None) values then use PyTreeCheckpointHandler(..., write_tree_metadata=True, ...) or use StandardCheckpointHandler to avoid TypeHandler Registry error. Please note that PyTreeCheckpointHandler.write_tree_metadata default value is already set to True.\n",
-      "Epochs: 100%|██████████████████████████████████| 200/200 [01:31<00:00,  2.18it/s, val_loss=0.000692]\n",
-      "INFO | 18:15:06 | Finished training\n"
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1732268817.378390  526800 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1732268817.381573  526800 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "INFO | 09:46:59 | Running on [CudaDevice(id=0)]\n",
+      "INFO | 09:46:59 | Initializing Callbacks\n",
+      "INFO | 09:46:59 | Initializing Loss Function\n",
+      "INFO | 09:46:59 | Initializing Metrics\n",
+      "INFO | 09:46:59 | Running Input Pipeline\n",
+      "INFO | 09:46:59 | Reading training data file project/benzene_ccsd_t-train_mod.xyz\n",
+      "INFO | 09:46:59 | Reading validation data file project/benzene_ccsd_t-test_mod.xyz\n",
+      "INFO | 09:47:00 | Found n_train: 1000, n_val: 500\n",
+      "INFO | 09:47:00 | Computing per element energy regression.\n",
+      "INFO | 09:47:00 | Building Standard model\n",
+      "INFO | 09:47:01 | initializing 1 model(s)\n",
+      "INFO | 09:47:07 | Initializing Optimizer\n",
+      "INFO | 09:47:07 | Beginning Training\n",
+      "Epochs:   0%|                                                               | 0/200 [00:00<?, ?it/s]WARNING | 09:47:16 | SaveArgs.aggregate is deprecated, please use custom TypeHandler (https://orbax.readthedocs.io/en/latest/custom_handlers.html#typehandler) or contact Orbax team to migrate before August 1st, 2024.\n",
+      "Epochs: 100%|███████████████████████████████████| 200/200 [01:56<00:00,  1.72it/s, val_loss=0.00414]\n",
+      "INFO | 09:49:04 | Finished training\n"
      ]
     }
    ],
    "source": [
-    "!apax train config.yaml"
+    "!apax train config_full.yaml"
    ]
   },
   {
@@ -167,7 +162,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,66 +173,70 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Energy per atom: Epot = -524.783eV  Ekin = 0.042eV (T=322K)  Etot = -524.741eV\n",
-      "Energy per atom: Epot = -524.784eV  Ekin = 0.032eV (T=246K)  Etot = -524.752eV\n",
-      "Energy per atom: Epot = -524.786eV  Ekin = 0.037eV (T=287K)  Etot = -524.749eV\n",
-      "Energy per atom: Epot = -524.784eV  Ekin = 0.033eV (T=252K)  Etot = -524.752eV\n",
-      "Energy per atom: Epot = -524.786eV  Ekin = 0.040eV (T=307K)  Etot = -524.746eV\n",
-      "Energy per atom: Epot = -524.781eV  Ekin = 0.036eV (T=275K)  Etot = -524.746eV\n",
-      "Energy per atom: Epot = -524.783eV  Ekin = 0.038eV (T=295K)  Etot = -524.745eV\n",
-      "Energy per atom: Epot = -524.777eV  Ekin = 0.031eV (T=242K)  Etot = -524.745eV\n",
-      "Energy per atom: Epot = -524.772eV  Ekin = 0.038eV (T=292K)  Etot = -524.735eV\n",
-      "Energy per atom: Epot = -524.776eV  Ekin = 0.039eV (T=305K)  Etot = -524.736eV\n",
-      "Energy per atom: Epot = -524.788eV  Ekin = 0.055eV (T=427K)  Etot = -524.733eV\n",
-      "      Step     Time          Energy         fmax\n",
-      "FIRE:    0 18:31:17    -6297.460205        2.9797\n",
-      "FIRE:    1 18:31:17    -6297.640137        0.9522\n",
-      "FIRE:    2 18:31:17    -6297.634888        2.8176\n",
-      "FIRE:    3 18:31:17    -6297.690125        2.0002\n",
-      "FIRE:    4 18:31:17    -6297.744812        0.7309\n",
-      "FIRE:    5 18:31:17    -6297.752930        1.0354\n",
-      "FIRE:    6 18:31:17    -6297.754883        0.9791\n",
-      "FIRE:    7 18:31:17    -6297.759338        0.8737\n",
-      "FIRE:    8 18:31:17    -6297.764954        0.7249\n",
-      "FIRE:    9 18:31:17    -6297.770813        0.5532\n",
-      "FIRE:   10 18:31:17    -6297.776001        0.4649\n",
-      "FIRE:   11 18:31:17    -6297.780212        0.4568\n",
-      "FIRE:   12 18:31:17    -6297.783813        0.4434\n",
-      "FIRE:   13 18:31:17    -6297.788879        0.5014\n",
-      "FIRE:   14 18:31:17    -6297.794434        0.5313\n",
-      "FIRE:   15 18:31:17    -6297.801697        0.4645\n",
-      "FIRE:   16 18:31:17    -6297.810730        0.3380\n",
-      "FIRE:   17 18:31:17    -6297.818176        0.2703\n",
-      "FIRE:   18 18:31:17    -6297.823425        0.2700\n",
-      "FIRE:   19 18:31:17    -6297.829163        0.3942\n",
-      "FIRE:   20 18:31:17    -6297.834229        0.3305\n",
-      "FIRE:   21 18:31:17    -6297.838928        0.2279\n",
-      "FIRE:   22 18:31:17    -6297.841248        0.3689\n",
-      "FIRE:   23 18:31:17    -6297.845642        0.3514\n",
-      "FIRE:   24 18:31:17    -6297.849121        0.2314\n",
-      "FIRE:   25 18:31:17    -6297.850342        0.3102\n",
-      "FIRE:   26 18:31:17    -6297.850586        0.2551\n",
-      "FIRE:   27 18:31:17    -6297.851562        0.1678\n",
-      "FIRE:   28 18:31:17    -6297.852051        0.1254\n",
-      "FIRE:   29 18:31:17    -6297.852356        0.1746\n",
-      "FIRE:   30 18:31:17    -6297.853149        0.2219\n",
-      "FIRE:   31 18:31:17    -6297.853760        0.2102\n",
-      "FIRE:   32 18:31:17    -6297.854919        0.1454\n",
-      "FIRE:   33 18:31:17    -6297.855469        0.0630\n",
-      "FIRE:   34 18:31:17    -6297.856812        0.1301\n",
-      "FIRE:   35 18:31:17    -6297.857239        0.1528\n",
-      "FIRE:   36 18:31:17    -6297.857483        0.0839\n",
-      "FIRE:   37 18:31:17    -6297.857483        0.0878\n",
-      "FIRE:   38 18:31:17    -6297.857605        0.0763\n",
-      "FIRE:   39 18:31:17    -6297.857544        0.0549\n",
-      "FIRE:   40 18:31:17    -6297.857056        0.0411\n"
+      "Energy per atom: Epot = -524.782eV  Ekin = 0.034eV (T=266K)  Etot = -524.748eV\n",
+      "Energy per atom: Epot = -524.786eV  Ekin = 0.047eV (T=367K)  Etot = -524.739eV\n",
+      "Energy per atom: Epot = -524.789eV  Ekin = 0.044eV (T=344K)  Etot = -524.745eV\n",
+      "Energy per atom: Epot = -524.798eV  Ekin = 0.050eV (T=389K)  Etot = -524.748eV\n",
+      "Energy per atom: Epot = -524.779eV  Ekin = 0.033eV (T=259K)  Etot = -524.745eV\n",
+      "Energy per atom: Epot = -524.778eV  Ekin = 0.029eV (T=226K)  Etot = -524.748eV\n",
+      "Energy per atom: Epot = -524.796eV  Ekin = 0.052eV (T=400K)  Etot = -524.745eV\n",
+      "Energy per atom: Epot = -524.778eV  Ekin = 0.030eV (T=230K)  Etot = -524.748eV\n",
+      "Energy per atom: Epot = -524.783eV  Ekin = 0.031eV (T=242K)  Etot = -524.751eV\n",
+      "Energy per atom: Epot = -524.799eV  Ekin = 0.037eV (T=286K)  Etot = -524.762eV\n",
+      "Energy per atom: Epot = -524.794eV  Ekin = 0.039eV (T=301K)  Etot = -524.755eV\n",
+      "      Step     Time          Energy          fmax\n",
+      "FIRE:    0 09:49:17    -6297.529843        3.433130\n",
+      "FIRE:    1 09:49:17    -6297.707876        0.822871\n",
+      "FIRE:    2 09:49:17    -6297.653997        2.416255\n",
+      "FIRE:    3 09:49:17    -6297.701468        1.822036\n",
+      "FIRE:    4 09:49:17    -6297.755201        0.799443\n",
+      "FIRE:    5 09:49:17    -6297.771731        0.639807\n",
+      "FIRE:    6 09:49:17    -6297.770975        0.635587\n",
+      "FIRE:    7 09:49:17    -6297.774358        0.628206\n",
+      "FIRE:    8 09:49:17    -6297.776426        0.617073\n",
+      "FIRE:    9 09:49:17    -6297.779687        0.603059\n",
+      "FIRE:   10 09:49:17    -6297.782312        0.586707\n",
+      "FIRE:   11 09:49:17    -6297.786402        0.568710\n",
+      "FIRE:   12 09:49:17    -6297.790373        0.550295\n",
+      "FIRE:   13 09:49:17    -6297.793097        0.528365\n",
+      "FIRE:   14 09:49:17    -6297.797588        0.504850\n",
+      "FIRE:   15 09:49:17    -6297.802828        0.477577\n",
+      "FIRE:   16 09:49:17    -6297.810041        0.446206\n",
+      "FIRE:   17 09:49:17    -6297.816479        0.407242\n",
+      "FIRE:   18 09:49:17    -6297.821895        0.358514\n",
+      "FIRE:   19 09:49:17    -6297.828423        0.300577\n",
+      "FIRE:   20 09:49:17    -6297.835409        0.244853\n",
+      "FIRE:   21 09:49:17    -6297.841073        0.207934\n",
+      "FIRE:   22 09:49:17    -6297.844864        0.208605\n",
+      "FIRE:   23 09:49:17    -6297.848110        0.154047\n",
+      "FIRE:   24 09:49:17    -6297.849490        0.151302\n",
+      "FIRE:   25 09:49:17    -6297.848904        0.132234\n",
+      "FIRE:   26 09:49:17    -6297.851377        0.131325\n",
+      "FIRE:   27 09:49:17    -6297.852449        0.132891\n",
+      "FIRE:   28 09:49:17    -6297.851385        0.134429\n",
+      "FIRE:   29 09:49:17    -6297.850981        0.132706\n",
+      "FIRE:   30 09:49:17    -6297.853413        0.127714\n",
+      "FIRE:   31 09:49:17    -6297.853684        0.119362\n",
+      "FIRE:   32 09:49:17    -6297.853303        0.107520\n",
+      "FIRE:   33 09:49:17    -6297.854404        0.095077\n",
+      "FIRE:   34 09:49:17    -6297.853003        0.086662\n",
+      "FIRE:   35 09:49:17    -6297.856393        0.082878\n",
+      "FIRE:   36 09:49:17    -6297.855421        0.077966\n",
+      "FIRE:   37 09:49:17    -6297.855617        0.070408\n",
+      "FIRE:   38 09:49:17    -6297.856790        0.064497\n",
+      "FIRE:   39 09:49:17    -6297.858416        0.063379\n",
+      "FIRE:   40 09:49:17    -6297.857967        0.061494\n",
+      "FIRE:   41 09:49:17    -6297.857515        0.062909\n",
+      "FIRE:   42 09:49:17    -6297.858565        0.051126\n",
+      "FIRE:   43 09:49:17    -6297.859075        0.076019\n",
+      "FIRE:   44 09:49:17    -6297.857729        0.045322\n"
      ]
     },
     {
@@ -246,7 +245,7 @@
        "True"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -287,7 +286,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -297,16 +296,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "142"
+       "146"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -317,28 +316,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Computing features: 100%|██████████████████████████████████████| 1142/1142 [00:04<00:00, 273.60it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(1142, 513)\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
+      "Computing features: 100%|██████████████████████████████████████| 1146/1146 [00:05<00:00, 224.35it/s]\n"
      ]
     }
    ],
@@ -361,33 +346,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([139,  99,   1,  34, 102,  78,   4,  17,  97,  72])"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "selected_indices"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
     "energies = np.array([a.get_potential_energy() for a in pool_atoms])\n",
     "# selected_indices = np.random.randint(0, len(energies), 10)\n",
-    "selection_energies = energies[selected_indices]"
+    "selection_energies = energies[selected_indices[0]]"
    ]
   },
   {
@@ -400,22 +365,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x79751d048c50>"
+       "<matplotlib.legend.Legend at 0x7fda74fda790>"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHACAYAAABONwdOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACeNUlEQVR4nO2deZwT9fnHP5Nzs0eSvQ92gV1AAUXkUARRqCAirfctoijFo1pvBWvVWquo1f7aWq3aKh7Fq1ZtSysWQUARuVFBWI7lWFiWhV02e2Q35/z+mHwnM9lJMskmm+t5v177gk0mk+8k2cxnnufzPA/H8zwPgiAIgiCIDEST6AUQBEEQBEEkChJCBEEQBEFkLCSECIIgCILIWEgIEQRBEASRsZAQIgiCIAgiYyEhRBAEQRBExkJCiCAIgiCIjIWEEEEQBEEQGQsJIYIgCIIgMhYSQgRBEARBZCwkhOLEf/7zH4wbNw4mkwn5+fm4+OKLg27rcrkwb948jBgxAjk5OaioqMD111+PhoYG2XabNm3CueeeC6vVisLCQtx8883o6OgQ73/jjTfAcZziT1NTk+q133LLLRg0aBBMJhOKi4tx0UUXYceOHRG/BgRBEASR7JAQigP/+Mc/MGvWLNx444349ttvsXr1alx77bVBt7fb7di0aRMeeeQRbNq0CR999BFqa2tx4YUXits0NDRg6tSpGDx4MNauXYslS5Zg27ZtmD17trjNVVddhcOHD8t+zjvvPEyaNAklJSWq1z9mzBgsXLgQ27dvx2effQae5zFt2jR4PJ6oXg+CIAiCSFp4Iqa4XC6+X79+/F//+tde7WfdunU8AH7//v08z/P8K6+8wpeUlPAej0fc5rvvvuMB8Lt27VLcR1NTE6/X6/m33npLdvsnn3zCjxo1ijcajXx1dTX/q1/9ine5XEHX8u233/IA+N27d/fqmAiCIAgi2aCIUIzZtGkTDh06BI1Gg1GjRqG8vBznn38+tm7dGtF+bDYbOI6D1WoFADgcDhgMBmg0/rfMZDIBAL766ivFfbz11lvIzs7G5ZdfLt725Zdf4vrrr8ddd92FH374Aa+88greeOMNPPnkk4r76OzsxMKFC1FdXY2qqqqIjoEgCIIgkh0SQjGmrq4OAPCrX/0Kv/zlL7F48WLk5+dj8uTJaGlpUbWP7u5uzJs3D9dccw3MZjMA4JxzzkFjYyN++9vfwul04vjx45g/fz4A4PDhw4r7ee2113DttdeKggkAHn/8ccyfPx833HADampqcO655+KJJ57AK6+8InvsSy+9hNzcXOTm5uLTTz/F0qVLYTAYIn49CIIgCCKZISGkkvnz5wc1IrOfHTt2wOv1AgAefvhhXHbZZaLfhuM4/P3vfw/7PC6XC1deeSV4nsef//xn8faTTjoJb775Jp5//nlkZ2ejrKwM1dXVKC0tlUWJGGvWrMH27dsxZ84c2e3ffvstfv3rX4siJzc3F3PnzsXhw4dht9vF7WbOnInNmzdj5cqVOOGEE3DllVeiu7s72pePIAiCIJISjud5PtGLSAWOHj2K5ubmkNvU1NRg9erVOOecc/Dll19i4sSJ4n3jxo3D1KlTg6agAL8Iqqurw/Lly1FYWKi43ZEjR5CTkwOO42A2m/Hee+/hiiuukG0zZ84cbNq0CZs3b5bdbjKZ8Pjjj+PSSy9VXL+SqHI6ncjPz8df//pXXHPNNSFfA4IgCIJIJXSJXkCqUFxcjOLi4rDbjRkzBkajEbW1taIQcrlc2LdvHwYMGBD0cUwE7dq1C1988UVQEQQApaWlAIDXX38dWVlZOPfcc2X3d3R04IMPPsCCBQt6PHb06NGora3F4MGDwx4Lg+d58DwPh8Oh+jEEQRAEkQqQEIoxZrMZt956Kx577DFUVVVhwIAB+O1vfwsAsqjN0KFDsWDBAlxyySVwuVy4/PLLsWnTJixevBgejweNjY0AgIKCAtGb86c//QkTJkxAbm4uli5digceeABPP/20aKhmvP/++3C73bjuuut6rO/RRx/FT37yE/Tv3x+XX345NBoNvv32W2zduhW/+c1vUFdXh/fffx/Tpk1DcXExDh48iKeffhomkwkzZsyI06tGEARBEAkioTVraYrT6eTvu+8+vqSkhM/Ly+OnTp3Kb926VbYNAH7hwoU8z/P83r17eQCKP1988YX4mFmzZvEFBQW8wWDgTznllB5l8Yzx48fz1157bdD1LVmyhJ8wYQJvMpl4s9nMn3766fyrr77K8zzPHzp0iD///PP5kpISXq/X85WVlfy1117L79ixo3cvCkEQBEEkIeQRIgiCIAgiY6GqMYIgCIIgMhYSQgRBEARBZCxklg6D1+tFQ0MD8vLywHFcopdDEARBEIQKeJ5He3s7KioqFFvDMEgIhaGhoYFGSxAEQRBEilJfX4/Kysqg95MQCkNeXh4A4YVk4y4IgiAIgkhu2traUFVVJZ7Hg0FCKAwsHWY2m0kIEQRBEESKEc7WQmZpgiAIgiAyFhJCBEEQBEFkLCSECIIgCILIWMgjRBAEQWQ8Xq8XTqcz0csgIkCv10Or1fZ6PySECIIgiIzG6XRi79698Hq9iV4KESFWqxVlZWW96vNHQoggCILIWHiex+HDh6HValFVVRWy8R6RPPA8D7vdjqamJgBAeXl51PsiIUQQBEFkLG63G3a7HRUVFcjOzk70cogIMJlMAICmpiaUlJREnSYj6UsQBEFkLB6PBwBgMBgSvBIiGph4dblcUe+DhBBBEASR8dAsydQkFu8bCSGCIAiCIDIWEkIEQRAEkUHs27cPHMdhy5YtcX2e2bNn4+KLL47rc8QCMksTBEEQBBE1+/btQ3V1NTZv3oxTTz1VvP0Pf/gDeJ5P3MJUQhEhgiCixu3xpsQXHUHEDZsNOHhQ+b6DB4X7MxSLxQKr1ZroZYSFhBBBJCn/3HIIN7y+DjZ79NUQ8WRHYxtOeuwzLPh0R6KXQhCJwWYDpk8HJk0C6uvl99XXC7dPnx43MfThhx9ixIgRMJlMKCwsxNSpU9HZ2QkA+Otf/4phw4YhKysLQ4cOxUsvvRRyX1u3bsX555+P3NxclJaWYtasWTh27Jh4v9frxbPPPovBgwfDaDSif//+ePLJJwEA1dXVAIBRo0aB4zhMnjwZQM/UmMPhwJ133omSkhJkZWVh4sSJWL9+vXj/ihUrwHEcli1bhrFjxyI7OxsTJkxAbW1tLF6uoJAQIogEc7TdgYPH7T1uf331PqzceRSr9xxTeFTiWfztYTjcXny8+RBFhYjMpL0daGoC6uqAyZP9Yqi+Xvi9rk64v7095k99+PBhXHPNNbjpppuwfft2rFixApdeeil4nseiRYvw6KOP4sknn8T27dvx1FNP4ZFHHsGbb76puK/W1lacc845GDVqFDZs2IAlS5bgyJEjuPLKK8VtHnroITz99NN45JFH8MMPP+Cdd95BaWkpAGDdunUAgM8//xyHDx/GRx99pPg8Dz74IP7xj3/gzTffxKZNmzB48GCcd955aGlpkW338MMP4/nnn8eGDRug0+lw0003xeIlCw5PhMRms/EAeJvNluilEGnKhAXL+JMeXcJ3dLtkt5/1zHJ+wLzF/AfrDyRoZaG57KXV/IB5i/kB8xbz+491Jno5BBEVXV1d/A8//MB3dXVFt4MDB3i+pobnAeHf1avlvx+Iz9/vxo0beQD8vn37etw3aNAg/p133pHd9sQTT/Djx4/neZ7n9+7dywPgN2/eLN43bdo02fb19fU8AL62tpZva2vjjUYj/5e//EVxLYH7Y9xwww38RRddxPM8z3d0dPB6vZ5ftGiReL/T6eQrKir4Z599lud5nv/iiy94APznn38ubvOf//yHBxD0/Qn1/qk9f5NZmiASiMvjxaHWLgDAYVs3Bpfkive12oUBkF0uT0LWFooupwffHmwVf994oAX9C6krL5GBVFUBK1b4I0BnnincXlMj3F5VFZenHTlyJKZMmYIRI0bgvPPOw7Rp03D55ZfDYDBgz549mDNnDubOnStu73a7YbFYFPf17bff4osvvkBubm6P+/bs2YPW1lY4HA5MmTIl6vXu2bMHLpcLZ7LXB8LQ1NNPPx3bt2+XbXvKKaeI/2ejM5qamtC/f/+onz8UJIQIIoF0S0QOEz6AYEJu63YDAOzO5BNCmw4ch8vjT4dt2Hccl4yqTOCKCCKBVFUBb7/tF0GA8HucRBAAaLVaLF26FF9//TX+97//4YUXXsDDDz+Mf//73wCAv/zlLxg3blyPxyjR0dGBCy64AM8880yP+8rLy1FXVxf7AwiBXq8X/88aJsZzIC55hAgigUijPcclpmgmgoDkFELf1DUDAApyhLEEG/cfT+RyCCKx1NcDs2bJb5s1q6eBOsZwHIczzzwTjz/+ODZv3gyDwYDVq1ejoqICdXV1GDx4sOyHmZoDGT16NLZt24aBAwf2eExOTg6GDBkCk8mEZcuWKT6ejSdh40qUGDRokLg+hsvlwvr16zF8+PBevAq9h4QQQSSQbqf/Kue4JCIk/X+X041kY22dYG68ccJAAEDtkXa0dSdndRtBxBWpMbqmBli9Wvg30EAdY9auXYunnnoKGzZswIEDB/DRRx/h6NGjGDZsGB5//HEsWLAAf/zjH7Fz5058//33WLhwIX73u98p7uv2229HS0sLrrnmGqxfvx579uzBZ599hhtvvBEejwdZWVmYN28eHnzwQbz11lvYs2cPvvnmG7z22msAgJKSEphMJtFkbVOoksvJycFtt92GBx54AEuWLMEPP/yAuXPnwm63Y86cOXF5jdRCqTGCSCBdQVJjrZLoULJFhLqcHmypbwUAXDCyAh9srEd9Sxe2HGjF2ScUJ3ZxBNGXHDwoF0HMEyT1DE2eDKxcCVTGNnVsNpuxatUq/P73v0dbWxsGDBiA559/Hueffz4AYRjpb3/7WzzwwAPIycnBiBEjcPfddyvuq6KiAqtXr8a8efMwbdo0OBwODBgwANOnT4dGI8RLHnnkEeh0Ojz66KNoaGhAeXk5br31VgCATqfDH//4R/z617/Go48+irPOOgsrVqzo8TxPP/00vF4vZs2ahfb2dowdOxafffYZ8vPzY/raRArH81T3Goq2tjZYLBbYbDaYzeZEL4dIM7bUt+LiF4VQ8W2TB2He9KEAgGXbj2DOmxsAAJeO6offXXVqopbYg693H8O1f12LMnMW1jx0Du794Ft8vPkQ7pwyBPeee0Kil0cQEdHd3Y29e/eiuroaWVlZkT2Y9RFqauppjGaRopISYMkSIIhRmegdod4/tedviggRRALpkkR7jnemRkTom71CWuyMmgJwHIfRA/Lx8eZD2EQ+ISLTsFgEkdPe3jPiU1UlRILy8kgEJTkkhAgigXTLzNISIdQlEUJJVj7PjNLjagoBAGMHCGHtzQeOw+3xQqcl6yGRQVgswYVOjNNhRHygbyyCSCDBqsZak9Qs3e3yYMuBVgDAGT4hdEJpHvKMOnQ6Pag9EvsOugRBEPGEhBDRKw7busQIARE50tRYKpilNx9ohdPjRanZiIG+BopaDYdT+1sBUBk9QRCpBwkholfc9e4WXP3qN9hJkYCoCBYRkpfPJ48Q2tYglMWOGZAvNjpjvwMkhIjUheqGUpNYvG8khNIZm00o71Ti4MGYTERmw0IP27p7va9MJLCzNPujtnUlZ0SIiTKLSS+7fVR/QQhtPRSfKdsEES9Yt2Wn0xlmSyIZsduFc5C0G3WkkFk6Xemjss4Oh+Bf6U4yQ2+qII32uDw8Op0e5Bp1soiQPYk8Qk6P0ADSEGCILsgWOssmk2gjCDXodDpkZ2fj6NGj0Ov1Yt8cIrnheR52ux1NTU2wWq1Bx4eogYRQutLeLogg1tCLiSFpF1S2XZRCiOeFEzdAQihaAgeqHu90Iteok3mEkmnoqsMtCCGjXv6lk6UXTh70OSBSDY7jUF5ejr1792L//v2JXg4RIVarFWVlZb3aBwmhdKWyskd307bX34L5puvlXVB7Ud7pcHvh8QqpHDoBRkcPIWR3oqogWyaEXB4eLo8X+iQoS3e6lSNCWT5hlEyijSDUYjAYMGTIEEqPpRh6vb5XkSAGCaF0RtLqfWH+SXj801b8RVOEc2vQM10WBSwtBgDdrvhNBk5nAgXkcbsLLo9X9toCQsrJYkq8EGIRIYNOvhajGBHygud5mZGaIFIBjUYTeWdpIi1I/DcrEV+qqoC338bmihMBAFtLBwNvv91rEQQAnTIhRJGAaAisCGu1O0WjNMcBGk55u0ThcAvrMAYIIZMkVcbEEkEQRCpAQijdqa8HZs1CuzEHANCtNwKzZsVkInKnw39ypohQdCh5hFg/IXOWHtkGIWibLIZpZ5CIUJZUCNFngSCIFCJlhFBLSwtmzpwJs9kMq9WKOXPmoKOjI+RjbrnlFgwaNAgmkwnFxcW46KKLsGPHjj5acRIgMUa3WYQuwN0FRX4DdS/FUKfk5NztTo6IRarR5RMNzGx83O4S/UH52XqYDILASJZqLCaEjDp5Xl6v1UDrC1+RT4ggiFQiZYTQzJkzsW3bNixduhSLFy/GqlWrcPPNN4d8zJgxY7Bw4UJs374dn332GXiex7Rp0+DxZMAX9cGDfqN0TQ3aTxgGAOi68GLBKM3EULA+QyrooNRYr2GvW4XFBEBIjbHGipZsA7J9QihZXt9gHiEAyNJR5RhBEKlHSgih7du3Y8mSJfjrX/+KcePGYeLEiXjhhRfw3nvvoaGhIejjbr75Zpx99tkYOHAgRo8ejd/85jeor6/Hvn37+m7xiSIvT+gT5KsOa/cIV+vdBpNglK6pEe7Py4v6Kcgj1HtEIWQVhFCL3SWmxvKz9aL3JtkiQkpCiEWvKDpIEEQqkRJVY2vWrIHVasXYsWPF26ZOnQqNRoO1a9fikksuCbuPzs5OLFy4ENXV1agKYRR2OBxwOBzi721tbb1bfKKwWIRmie3tQGUl2rq2AfClLaqqgJUrBRHUi2aKnVQ11muYCbrcIlSrtNqdYmrMatKjzWecThYhFMwsLdzGolf0WSAIInVIiYhQY2MjSkpKZLfpdDoUFBSgsbEx5GNfeukl5ObmIjc3F59++imWLl0Kg8EQdPsFCxbAYrGIP6FEU9JjsQCVlfB4FRofVlb2SgQBgWbp5DhRpxrMT1PuiwgdtzvR2iVEhKzZBtEs3eVKErO0J0RqjJoqEgSRgiRUCM2fPx8cx4X86a25eebMmdi8eTNWrlyJE044AVdeeSW6u4PPxXrooYdgs9nEn/oYVFclmo7u+KSwKDXWe/weISEidLzTb5a2JrNZWqG5IzVVJAgiFUloauy+++7D7NmzQ25TU1ODsrIyNDU1yW53u91oaWkJ21qbRXaGDBmCM844A/n5+fj4449xzTXXKG5vNBphNBojOo5kp607PuMaOpyUGustYmrM6jdLS1NjzCydPH2E2IiN4ELIQUKIIIgUIqFCqLi4GMXFxWG3Gz9+PFpbW7Fx40aMGTMGALB8+XJ4vV6MGzdO9fPxPA+e52UeoExAJoRieEKVRYTIIBsxPM+LwpRFhDqdHjS1CxHL/Bx/1ViyRYQMCm3tmbGbRDFBEKlESniEhg0bhunTp2Pu3LlYt24dVq9ejTvuuANXX301KioqAACHDh3C0KFDsW7dOgBAXV0dFixYgI0bN+LAgQP4+uuvccUVV8BkMmHGjBmJPJw+p707PpEbaqjYO5weL3yj2lBizhK7SO89ZgcAWEx6mPSsoWKSCSHyCBEEkSakhBACgEWLFmHo0KGYMmUKZsyYgYkTJ+LVV18V73e5XKitrYXdLpxEsrKy8OWXX2LGjBkYPHgwrrrqKuTl5eHrr7/uYbxOd9rj5BGiPkK9o9vpF4/ZBi2s2YKJ/1iHELHMl/QR6uqwB+/5dPAgYLPFd7E+xNSYUtUYeYQIgkhBUqJ8HgAKCgrwzjvvBL1/4MCB4Hle/L2iogL//e9/+2JpSQ8rwQZiK1jsThJCvYEJBr2Wg16rgTVbj5ZO//RrmVl68afA/Nd7Dstl3cNLSoR2Cb2sBAxHyIhQmpTP09BYgsgsUiYiRERPe4BZWioYe0MHlc8rcrTdoeo1ZkKImYzzs+VtHaySiJDd7e05GkUyQgVNTULPqDji9fJi+bxSRMhkSP3U2Nq6Zpz666X4eHP0HdcJgkgtSAhlANLUmJf394LpLdRQsScrdx7FaU9+jv9bujPstsy4bhKFkF68T8MBeUadPzU2cZJ8NMrXX8tGqGDFCqE3VByRfm5CRoRS2Di/bm8LbF0ufLnzWKKXQhBEH0FCKAOQVo0BsRMtgVVjsYo0pTKbDxwHAGzYfzzstiwixNJfVklEyGLSQ6PhYGLT57V6cTTKbpsTdy/4CHtaHX4R1AeNP8MKIbF8PnVFscvnXk8WczpBEPGHhFAGII0IAbFLXUjN0nwMI02pzJE2wejc0NoVdlv2PihFhFiaLFsv6SNUVQW8/TbeGTkdn5z0I7w5+gLg7bf7RAQBcoFjUGyoqPGvNUVx+z7Dnc7k6ORNEET8ISGUAQQKoVicqHiel0WEAHkVVKbS1Cb0AGpo7YbXGzpCxt4HVm2VnyOJCPlEkayPUH09MGsWjuVYAQA7i/oDs2b5PUNxRjpeQ8lMzCJCqZwac/ves1QWcwRBRAYJoQygR2osBicqh9vfAyeW+011mtqFiJDT48WxztCNO8XUmC+SIjVLs/+LVWNdDtET1FIodFPfXTqwp4E6joQarwFIhFAKm6VdYkQodY+BIIjIICGUAbTFISIkTYtRIz0/R9r8c+waWoPPtAOkQqhnasxqYhEh39DVY8dFY3Tz8FMBAMeyzGgZOsIvhoL1GYoR4uR5hfEagFQIpW5k0O1hESFKjRFEpkBCKANoj4NZmqXFsg1a8WSdyifAWOD2eMVmiEB4n1B3CLM0+7+YGtMZRWP0ccnbufuND4TbS0qAvLyYHEcw/OM1ggmh1BfEbi9FhAgi00iZhopE9LR1CaJFp+Hg9vIxOVGxiFCOUSeeGFP5BBgLmjudsnRhOCHEInNKfYSsvugQE0ndWj28K1aAq6xES+dWcbtdMOH0lSsFERTnZoqOEM0UAWlDxdT9HLg85BEiiEyDIkIZAIsIFecZAcRmBAKbM5Zr1ImpklQ+AcYCaVoMAA6FE0Ihq8bkZmkA6CopR4fDLavO23WkQ+gfFEYErdx5VCztjxbRI6TrOXAVSKLUmM0W9TgSadUYtYMgiMyAhFCa43R7xSv5Ep8QioVg6RQjQloxEpDpM6ZY6TwjbEQoQAjJ+gj5/p8lER12p0c2ggMAdjWF7yZ9vNOJm95Yj+tfWyeagaMh1HgNQNJZOpGmeZsNmD4dmDSpp4G8vl64ffr0oGKI9RHieX8EjCCI9IaEUJoj9QfFNCLkM5PmGHQSb0hmnzhYRIgJhXBm6W6n3CNk0GmQaxSy1SwipNFwolDqUhJCRzrCr6u9Gx4vj3aHG7WN0Y/hEM3SQYSQMRlSY+3twriRKMeRuCVCkZoqEkRmQEIozWEVYzkGLXJ8J9lY+B86JR4hsaNwhpfPsx5CJ1eYAaiPCLHXDwCqCrIBAJX52eJtomHa5RaFUHVRjvCc7Q7Y7HIzfCCtkvu31LeGPY5ghPUISZs/JorKSrEDdzTjSDwSk1dgnyyCINITEkJpDosImU16Mc0Si5A/G7gqFULkERJSY6P65wMQzNOhXhMWQTNJhNCL147CmzedLgodQNJLyOlBs08I9S/IRrklCwCw+2joKI9UCH3bCyEULjUmRgYTnVKqqhLF0GM15+KSP6+BY/8BVeNImFkaoFQvQWQKJITSHNZVOi9LJ55QYxkRyjVqxRN5pqfGmtqFiNCQklzk+F7rUFGhwFljAFBTnItJJxTLtsuWvG/HfUKoMMeAwSW5AMKnx2xd/nTatwdb1RyKIg7RLB3EI+T7HDjd3rBdteNOVRXaXn8Lb4+agc39hmJXYX9V40hY+TxAESGCyBRICKU5bV1CNCAvSx/T6i4xNWagqjEGiwiVWrJQYTUBCO0TCpw1Fgxx8KrEI1SQY8AJpULfoF1NoYWQNCK0q6lD1gwzEvwRodBVY0ASGI3r67HhF0/DqxHW1GkwqRpHIosIkUeIIDICEkJpDosImbN0ftNtLM3SktRYpqcSWESoNE8qhEJEhJw9PUJKsMGrdqdbTI3l5xgwxBcR2nkkTGqsyy+EeB74LsqokCNsQ0X/cSRUFPuM0WsN/siavX+1qnEkUrM0NVUkiMyAhFCaw+aM5WXpYyuEJH2E/I30Mjc15vJ4caxDECmlZqMohFgvoeYOB85+9gvM+/A78TFKqTElpKmxFklqbEipIIR2RxARAoBv64P30QmF2EcoyIgNrYaDXisMY02YKD54UDRGfzN4jHhzxxNPyQ3UQfoMuSUpPTuN2SCIjICEUJrTJvEIidVdMRAsHbKqMUqNHfUNW9VpOORnG9DPKhiZWUTov1sbcaDFjk+3HhYfE9hHKBhSs7Q0NTa4WEiNHbZ19xijIoWlR/v5xFm0hmmnR1hvsIgQkATdpfPygJISdJwwDFuLBoo3d+Za/NVkIcaRSFNjVD5PEJkBCaE0pz1uESFJQ0Uqnxd7CJXkGaHRcP7UmE0QQsu3HwEgCFMmEsQ+QuFSYwb/+yZGhHINsGTrxSaZoaJCrT6z9Nk+E3a0hmkmoIOZpQEgy5Dg6KDFAixZgo2vfwiJphGEe1UVsHIlsGRJ0E7cydRHqNXu9Jfz96JbNkEQoSEhlOaIHiGTTjxJxbSPkEFHVWPwG6VLzEIkSGqWtjvdWL2nWdyWDWb1p8ZC/xlmi2Zpfx8hNpeMpcdCGaZZamzi4CJoOCGCFDgORA1stEdIISSW0CdQRFgsWNsuXyNL5YYbRyJLjSWwaqy+xY7Tnvwcd7+/pdfdsgmCCA0JoSSD53ms2dMcMtURCdKIUJau50nK5fHik82HIj4xUmpMjmiUNgsRmn4Sj9CXu46J/hphW7kQCmeWZqkxW5dLfN0Lc4TnGVIipHhCRoR8QqjCmiVWmkXTWDFcHyFAkhpLcDRl7d4WAIKXCvCb+8MhHUFiT+DneVdTO1weHtsPt/W6WzZBEKEhIZRkrKg9imv+8g0elJhqewObPG8O0kfof9uO4O73t+CZT3dEtF+WNhCGrlLVWBMrnfdFhErNWeA4QTz8fYM8pXG03QGvl1dsqKgEqxo7dFxIs+k0HMwmIUrEGi/ub+4M+nibzyNkzTZgZKUVQHQ+IUeYoauAZPBqAiNCXU6PWBk3+cQSAFDdMsCdJOXz7LPR7fL06JbdOP0iHFn+lepu2QRBhIaEUJLBrtQ/335EPIH1hnaHr7N0ll7i5fFf9R5qtQMAjgXMsApHh4JHKJMjQiyixoSQQacR/TvLdwj+IItJmB92tN0hew/URoQO+oRQfo4BHCdUZ7H5cc0dyu+fy+MV3yurSY9T+1sBROcTUhURSoK5c5sOHIfLw6PckoVh5UIETG1zRHeSjNhgf0vi58TXLds1aDDOn3I/fvzxPrj27VfVLZsgiNCQEEoy2JW9y8Njmc9g2xtknaUVZkExseWM4Aqe53lJZ2mdP+WWyR4hX7qLCRPA7xPy8sKst2nDSwEIqTFp9CxsHyGfR4gJoQLJlPqiXOH5mO8oEKmYNpv0YkTou3qbbK6WGsLNGgOQFKJ4bZ3gxxpXXSDO1xM9QmGQdpZOZGqMvday17GqCu1/WYjj2RYcy8lHY26hqm7ZBEGEhoRQkrGv2S7+/7/fN/Z6f9LO0kqND/1CSL2I6XZ5wc6h2TRrDIB/4CqLCAF+IQQIFVv98oXfj0qEkEGngVbDhdy3tGoMEErnGYW5wv+PBYkI2cT3XwethsMJpbmwZuvR7nBj4eq96g8Q4afPA1IhlDhR/I3PHzSuplAihCJPjSXSLC1GhKSvY309un9+l/jrYXOxqm7ZBEGEhoRQkiH1eqzadbRXpmme5+VVYwqmZpvPQ+T0qD9xSf0W2XqtmLpJ+FiFBOJPjfkjQv0kQmjKsFIxWnS03SFG5cL5g4CeDRcLcntGhDocbkUhyozS1mwhLafTajBv+lAAwHP/q8UBifAOh7rUWGL9Yh4vL6aXT68uQK7RN2IjGrN0EniEnB7f3DafMdrR4L84ahh8kqpu2QRBhIaEUBJh63LhuN3f/M7p9mL5jqao99ft8oqeB2kfIYdkKCaLGLnc6tMk/tJ5LTQaLvFN9BKMw+0R37fSPElEyDcdnuOAyScWoziXCaFu1XPGAH9EiFEoiQiZs3Rig0PW1FEKG7hqNfkfc/VpVRhfU4hulxfzP/oOPK/uvQ83YgOAJE2amM+C3ekWBVs/qwk5vrSiarO0NzkaKkpfP8d+f3VY98Aa8faGux5U1S2bIIjQkBBKItjVeXGeEZeM6gcA+O/3h0M9JCRsvIaGE0SLNLLAqnrE1FgEESHpnDHAb5DN1KoxVjFm0GrEyAsADK8Q+tWMrylEUa5R7DEkTY2FG68B9BRC+RKPEMdxKBLTYz2FUGBEiD3m6ctGIEuvwdd7mvH+enXRBP+IjeBrFqODCfossNeV44QUXiSpMZ7nZb6pRI7YkFbdOUzZQjfsmhp0v/JX8fYGGFR1yyYIIjQkhJKIfb602ICCbJw/ogyAUE4fbfUKS6vlGnXgOH/kBvCH3tui8AhJ54wByWGQTSSsh1CJ2ShWcwFCauadn47DH68ZBcBvpD7a4RCjDeGM0gBg0utkvxdKUmMAUBSicowJIVaxxhhQmIP7p50IAHjyP9tF0RwKJpZDRoTE8vnEpEm7nf6WBBzHRWSWlo7XABIbEZJ6g7pNuUI37JUr0V1QJN5+uLVbVbdsgiBCQ0IoiWD+oAGFORhebsaAwmw43F58URs6PfbUf7fjlrc3yMYDAP45Y2bfSVCj4UR/B7tyZhGhSPw9nQ55RMgoKZlWm2ZJJ1hEqERSMcaYMLhI9PGwyI3Lw6PRN3rDFGSAqZTAiJDULC3sN3jlWGtXz4gQ48Yzq1GUa0S7w409YQa3An6zdOiGir7PV4JERGCTyhyJRyjcZ1NaMQYkWAhJI0JujyByKitlkaIGm68Japhu2QRBhIaEUBLBKsYGFmaD4zjMGFEOAPg0RPXYkbZuvLqqDp9tO4Lth+WdZf2l8/6ToNTDwfN8VOXz0h5CgDyqkYmG6cAeQsEw6rSiIDnQIrzX0aTGAoUQ8wwpCSEW8ZN6hBhaDSeuR02Vl5gaCyGEjDGIDjLDc6CwV0Og94pFLXk+fOq2Z0QokVVjXsX/SyNFbKAvQRC9g4RQEsE8QgN83YJ/5OuKG2ocwrLt/mgRa47IaJOUTjOk3aXtTo9oDg08CYRCOmcMkBt+YzHZPtVgPYSUIkKBMMP0gRYWEYq8aoyN12Cw1JhSCX2r3WeWVogIAZHNBlMjhHqbGuN5Hne+txkXv7ga72+IvBLKHxES1mjSa8G6E4QzTAcKL5eHl1WR9SUys3RgdMiHrcuV0KaPBJEukBBKIqQeIcA/PqHB1hV0svvnkqaLrOEeQyydl0SETJIrdmmzvWjK51lqTK/198JJ6LDNBNHsi8SwFFUomE/ogO+9VuMRYg0VGfk5clHDnvdoiNSY2RRECOnUm5vVjNgw9TIi9MbX+/Cf74QCgV1HwqfrAgk0oXMcJwr2cD4ht0KDyUSlx6Svnzw6JF/PYRtFhQiit5AQShLsTrc4jHNgoSCAinINyDZowfM9RQ57zOrdx8TfD7UGCiE2XsN/IpU2vJMKIY+XV91pmJ0cmBACEu8NSSRsInyhCiHEokZiakyFENJKvF2AvGoM8HuPjimUz4tVY0GEkCmgWWMoIhuxEfnnYNOB43jyP9vF31k0KxKYoJMWBqitHGNCyKDTQOcT9olKj8nSYW5lUQQADa2RDUsmCKInJISShP2+tJg1Ww+LL43BcRz6+6JDSo3vvtp1TD43LEAstXX3TI1JG94FzjJTWznmH6/hP9kkw7DNRMFSUoHeHSVYRIj1HVLjEQL8PiGLSQ99QNUWS7c1K8yLkw5cVcKo8wvjUHi8vEwoBCPaCsKWTifuWLQJbi8vvo7sNYoEpbYE2b7PqdrUmF7Dia93wiJCQcQPRYQIIvaQEEoSmBAa4IsGMQYUCkJon8J0ceYPYtv0jAjJq8YAec+faIVQYGpM2G/iRyskCn9ESL0QYqiJCEm3K1QQW36PkFJESKVHKIxwkX42QnuEops7939Ld6LB1o3qohw8+pPhAKKLCHX5yuelKcdclREh5pPTaTViOtKuckZZrHGojAgdoogQQfQaEkJJwv4AfxCDCaP9AREhr5fHMl/X6VlnDAAQXAjJzNJBPEKAep+QdOAqozcpkVRHFEIqIkIlefLKMjUeIcAf4chXeA72vK12l8zc6/X6qwKDpsZUjsSQCqF4RIS2NdgAAHdPHYKqAmE0SWtX9BEh6euqtrs0K5/XazkxihTv1Nj2w2247M9f4+s9x2S3B4sIBXoFD1PlGEH0GhJCSYK0dF6KmBprkQuhbw+24liHA3lGHS4bXQlAOBFKr3qlA1cZ7ITa7fKI9zPUCqEO31Wy1MSbqU0Vu10e8QQbWM2lRI+IUISpMaX0W362QTSrS5sqdjjd4nDcoGZplZE8dgLmOIj+mZD7izBFetjXE6eqIBsWX6n/cYVUXzj85fP+rza1TRXZwFWdRtNnqbFPtzZi4/7j+NeWBtnt4SJCZb5WDQ2UGiOIXkNCKEmQNlOUwtJe+wNSY6xa7OwTi5GfYxAN0dKoEEunSaegS+eCRZsaszvlfYSAzE2NsWiQTsPBbNKF2Tr61Fi2r7u0UtRJo+FEgSRNj9mYD0mvDRp5YpG8cFVjDknpvLR7do/9qfQcSXF7vGIvpgqLCfm+NF5btzviXkJKM9xyVUZ3WDRNp+X8qbE4C6EOX9S2M+B5glaN+UQRqyg9TKkxgug1JISSBL9HSB4RYhVk9ce7xEGpgN8fNHWY0GuoX77PJ+QzTHe7PGKUaWiZfwZRlthHyBsDszSlxpgQKsgxhBQIjMBeQ6o9QiEiQoByCb3SnLEe+1WbGlMxXgOQfA4iEBBHOxzw8oKYLM4zysaBsO7oamFVi1mSSBuLCIVPjQl/X3qtPyKkdmp9tHQ4hPeoK+B5gvURYrdXF/tba2RiN3eCiCUkhJIAh9sjhrgDI0LllizoNBycbi8afVfNR9q6saOxXZhqfoJPCPmiPgd9EaE9Rzvg8fKwmPSyk68pBlVjimbpDJ1AzyIwairGAKHqSyomslSmxpjPK1iJPiuhl6bGWn2T5wPnjElR2wmapWoMIXoIAdGlxlgJeKk5C1oNB51WIx7v8QgN0+x5peXz6s3SvoiQxt97SNoOoqXTqRyhstmCT34/eFC4PwgsXRcYeZI2pFTqLF3t+57odnmjqq4jCMIPCaEE8fXuY5jzxnpsPnAc9S1d4HlhQnxRQOWRTqtBZb4gcljUaMO+4wCAoWVm0TzLtmERoZ1HhHEbJ5blySIV0shNtB6hwKGrwn4zUwixiJCaZoqA0BKhWEGYhuOmidW4dFQ/XHBKueL9xQrzxoINXJWiNqXJPhuhKsYA//G4POr7UrES8HKL30jOeiVFWjnGqsZk5fOiWVqlR0irER/PIkL1LXaMe+pz/PzdzfIH2WzA9OnApElAfUAn7Pp64fbp04OKoXafOJMKIZfHK3vtlDpL52XpxM8cjdogiN5BQihBvLhiN5btaMIlL32Nm9/eAECIBimlV/r7rv4OtAienw37WwAApw3MF7dhESHmEdrR6BNCpf60GBCmakxtasx3cpDOwEr01PFeE+VVfXMEPYQYRRIhlKVi6CoAjO6fj99ddSpKgswzE0voJU0VQw1cDXz+cKkx5iEKJ4SkXiS1opj5XMolXjbmE2qNMNqh5BESB69GUjUmGUUDCGNuXB4eWxsCPgft7UBTE1BXB0ye7BdD9fXC73V1wv3t8jmADLYmaeQpcF6fQ2HuWJZei35Wn2GahBBB9AoSQgniiYtOxuVjKqHVcKg7yozS2YrbspJ6FhHauF+ICI0Z4BdC/oiQsE1toz8iJCVkQ0UVESGe55U7SyfAI7T1kA1/XLYr6PgR1fTiqr65M3IhVJwbeUQoHEqDV22sh5DCwNXA5w/bR4h5hMIIIalQUtOtGvBXPlVIIkKW7OiaKnaL5fP+dUTaR0ir6WmWZlGrjkDPUmUlsGIFUFMD1NWhfsaleHvRF3j2judwz7CL8ehlD8K17AthOwXY/uwu/34D3wslj5BRp0G5xeRbGxmmCaI3pIwQamlpwcyZM2E2m2G1WjFnzhx0dKibRcTzPM4//3xwHIdPPvkkvgtVSU1xLp67YiRW3D8ZM8f1R2GOQZw2H4i/cswOu9ONbQ1tAICxAwvEbfrlyyNCO8MIISEiJHz5spOXmoiQUxK2V4wI9WHV2DNLduB3S3fKBs9GRS+u6ls62Zwx9UKoxCyNCMVGCBWJqTF/KsmmKiLEZo2FSY2pGLgKCBVsTCxFHBGSpcZYRCjC1JhSHyGVZmn2udbLyueFxzCx0eFw9zQnV1WJYmjmhFvwyPd2vDRsGj4++Ry8NfhsrHUpX+BI1ySNCAW+bkpVY1l6rVgNSiX0BNE7UkYIzZw5E9u2bcPSpUuxePFirFq1CjfffLOqx/7+979XVdGTCKoKsvHkJSOw8ZFzccHICsVtWC+h/S2d2HKgFR4vjwpLlpgOA/ypsaZ2B451ONDg++I+IUhqrMvlFT1CzLOiZtK2tNOuvI9Q30eEjvrSQIGjRSIm4Kq+a8q5OLD0S/BMBNXUACtWoLu0XJzfxvCnxtR5hICAiJBKs3Q4lLpLix6hWKTGVMwZE/cpCiF1olj0CMlSY/4mkZHQpVg+r64UXl4+L+8jxMSay8P3SF0BAKqqYHvtTRzIFy5mrt+4GFXZwusQyvDdoeARCnzdlPoIGfUaVIipMYoIEURvCN/4JAnYvn07lixZgvXr12Ps2LEAgBdeeAEzZszAc889h4oKZQEBAFu2bMHzzz+PDRs2oLxcOeKS7Ei7S29gaTFJNAgQUjNZeg26XV6srD0KQLjCDjTKsivlVrtTTHcU5xlx8HiXqoiQ3XeiMej8E+eBxFSNsZNkU3sMTgTsqn7yZFwy8Q7sWNYG609+g1Gt9Sj40URs+8de7Gr6HgDw3zvPEiNtzRGM12BEY5YOhzh4VVY1xrpKB1+bWpO7U8XkeYbJoEVbt1v1Z4GJ9gqLXwixz22kVWMssmJSKJ8P6xFSGLHBCgOkM73au909I3n19djzwGPAlHtR2t6MX3/+Mm4uq0J9v5HizL9AeJ73e4RcHvA8D47jQkeEJBEvMTVGHiGC6BUpERFas2YNrFarKIIAYOrUqdBoNFi7dm3Qx9ntdlx77bV48cUXUVZWpuq5HA4H2traZD+JhkWE2rvdWOZrpDhW4g8ChGokFhVaXiukigLTYgBgMghveaPv5KPVcOLVtxoh1KVglAYSUzXGysObFKauR0VVFbxvvYUdJdXC/k1mfFF+Ev6x4zh2NLbD4xUqodZIxiFEMl6DodTOoLewKFNLp0NM8dhU9BFSW+6uZvJ84D7VeLecbq8YxSq3KqXGIosIsWhNloJZWvWIDQ0nPqbL591pkPhweuzHl0Kt821SU10K1NTA3CL8HbY1ysdnSNfKehfxvF/wBL5u8p5CvuPTaSURIRJCBNEbUkIINTY2oqSkRHabTqdDQUEBGhsbgz7unnvuwYQJE3DRRRepfq4FCxbAYrGIP1VVVVGvO1aYDFrx5PntQcGwO3Zgfo/tWFPFVb6IUGDFGOCP3LCTjzlLJ/a1cahJjfmuuLMDTuBZ4uiOvvEIdbs84nM1tcVICNXXw3HjHPHXd959CI9t/hB3n1aKV2aNwVVjhc/CPsnct+YI+wgBARGhGKXG2PN7eX8URU0fIbWdoNnJOVxDRek+WSl7KI60dYPnBYElFZOsLQQ7BrWIESGFWWPqh65y4uM7HR6ZWAMCDNMHD4o+srqakwEANYMqgBUrYPZFotpef1uxIjFQUDE/UqBfy+HuGRESUmPChc+RdofqVgUEQfQkoUJo/vz54Dgu5M+OHTui2ve//vUvLF++HL///e8jetxDDz0Em80m/tQHVhEliIGSRou5Rh2Glpl7bMMiQqw3iVJEiAkW9r1pMenFq3xVqTGF1AMg8YX0toJLJdKKt5ikxnxX9d31/plPp+u7cOP/3sDdD16F88wujKyyAvCPO+l2ecTRCMEaHSpR6iuB12m4sOZjtei0GjGKwk7aavoIibPnwvhnxBEbKsr9I/GLsWhGuSVL5uMTU2Od0XmElMzSnU6PrDt7IG7RI6QRH9Pl9IhijSHzieXlASUlQE0N6n58OQChEAJVVTDPvBoAYLMUCNsFEFiBxv62Av+GZBEhSfl8ca4Rei0Hj5eXpe4IgoiMhHqE7rvvPsyePTvkNjU1NSgrK0NTk7wyyO12o6WlJWjKa/ny5dizZw+sVqvs9ssuuwxnnXUWVqxYofg4o9EIo1H9Sa2v6F+YjXX7hP5Bo/pbZf4cBiuhZwQapYGeqRiLSQ+97ypflVlanDMm/+j0dWpMmjLpdWpMclXffdJoAIJI0X2x3F81NnkyBi5aDMAfEWJpMb2WE2e9qaHCasLPzxmM/Gx1YznUUpRrxHG7C8fanUBZZH2EwglY0SytJiIUQXdpVo0lrRgDom+oGKp8HhA8brlG5fdKHLGh4WQNFQPL09ulkRyLBViyBGhvx96/1wEAanzjL8ylhQCOoG3KecJ2AQRGhJiI62mWFn73eHnR15el00Cj4XBiWR62HmrDhn3HUZkfvDqNIIjgJFQIFRcXo7i4OOx248ePR2trKzZu3IgxY8YAEISO1+vFuHHjFB8zf/58/PSnP5XdNmLECPzf//0fLrjggt4vvo9hvYQAYOyAAsVtpFVkGg4YXJLbY5tAk6c52ohQYGpMUo3WF0hNtO0+Y27Upejsqh5A97vvA4tqhX1JDNQoKcGAigIAdahvscPt8cqaKUYqaO6bdmJ0aw1BUa4Ru5o6cKzDgW6XR3w/rdkhzNI6fydot8cLXRCh44woIqQ+TervISQX8aIQ6lIfEfJ6/RVd0s9nll4DDSdEQTsd7qBCyCUxS0tHbARGW3r0ErJY4MkzY2+zYKYfVCT83Zl9Ua02j/Jno2dqjAkhf/fodonpXOodYq/xmYOLsPVQG77cdQwXj+qn+DwEQYQmJTxCw4YNw/Tp0zF37lysW7cOq1evxh133IGrr75arBg7dOgQhg4dinXr1gEAysrKcPLJJ8t+AKB///6orq5O2LFES39Js0UlfxDg7yUEAAOLchSFgVJEKJI+QqJHqIdZWt0U81gRaKLtlU+IXdWvXInuIkEQiRGFqipg5UpgyRKUV5bAoNPA7eXR0NqN5k7mD0qOCKK0hJ69PsLcrOACUZriDNUV3D90NbzYVFuSD0i7SssjQqzk3+70qG6YKY1ASY+L4zhVvYRYakwfUD4fWJ6utI+GVqHq0qDTiH+HLEoYOMqGEehZ6nLKI0IsPcjEndQ7xP5mzxosXEh+tfsoDV8liChJCSEEAIsWLcLQoUMxZcoUzJgxAxMnTsSrr74q3u9yuVBbWwu73R5iL6kLK6HXajic6vOqBCKNCCkZpQFlISRGhFSkxrpEIZTY1JgtwETba5+QxQJUVko690pep8pKwGKBRsOJkbl9zZ1RVYzFE2kJ/dq9zQCEtFioaJXUoxTqvfMPXY2gakyNEBLnjMkjQuYsnZj+VVs5Jm1KmBVQ5i/2Egoxb8zllXaW9ndgD6zKCuwlBQhDjgFgYGG2uG4xIhSkfL5nakz4nb0PLKXJfmdCT+cbTAsIF0VGnQZH2hzY3aSuwSxBEHJSoo8QABQUFOCdd94Jev/AgQPDXhGl8hXTiH4WXDKqH2qKcnr4cxilZmFSvdvLKxqlgZ6pDYtJD43vRKkmIsTmjAWapU0RpENiQY+IUIxK6P2znJRP+AMKc7CrqQP7mzvFbSPpIRRPWHfpRWv3o92XvlEy1UvhOMGw7XB7Qwohp0fdrDEgsp5SLNpSERAR4jgOVpMezZ1OtNpdosE8FN2SEn9NgIcukoiQTqORCf26Y4LAMOm16HJ55B4hto1vTE5NkT8dbc7yCaEu5ecMmhrzCZ7AiJB0zhgjS6/F6dUF+HLXMXy1+xiGBLkAIggiOCkTEcp0tBoO/3fVqfj5lCEht2EphmARIaNOA2mAQGqWjiQiFJhuUWu6jRWB3pGmtth01xWHdgZJJw30pSj3HrNHNWcsnrCIUHu3G1oNhzkTq/HyrDFhHydWjoUSQhH0ETJF0EohWEQI8KfH1DZVVCqdZ7DPa6gSenHEhpZDlt7/d7KnSRA5zHPXwyMEv1hiRmkAMJt8qbFgEaEgVWOOgNSY0+2F18srGsEBwScEAF/tUu5XRBBEaFImIkSo49ZJg7BsexMmnahsQuc4Dlk6rejfsJj08PLCF3Vk5fPyj46xjztLxy8i5DvZBOmgPLCIdfnuFCNByZIaGzMgHya9FsPK8/DExSfjpIqelUpKCMfqCilcHCpnjQH+qGO4z0KX0yMOVQ00SwPMMN2punJMafI8w19CH1wISc3SHMchW69Fp9ODRp/IHlKai+8P2RSjSmJEqFgSEZIIGSUzf1CPUEBECBAuUhTTtgAm+oTQN3XNcHm84oUNQRDqICGUZswcNwAzxw0IuY3JIBdCrBdO78zS/igAGxUQT5hHqNRsxJE2R+yEkGSopRKsn9M+Xy8hILIeQvFkcEkevn1smqqojRQ1fX/UDl0FJA0VwwghFg3KNmjF6ImUSLtLB4uYACpTY5LO0oAg9jslviMWZW1XigiJQkjS78ugA8cJXaPbul09PlOBKbaeESG/wJY2EA08vuHlZhTmGNDc6cTmA604vVq5qpQgCGXo0iEDkV4xR9pQMfiIDf9HSXEoZYxhJ0fWK6nvPEJCaqy+pUtsXJgsqTFAXeoqEH/rgxBm6ShGbIRLjUl7CCkJZyYEjqs1Sys0U2Tkqpg3Jo0IAf7RHMI+NWKfnsCUVqfDLUaNBkk8QhoNhzzWXVrBJ9QzIiQ3S+cataLx2uH2itVzgREhjYbDBDE9djTo8REEoQwJoQxEapg2m/QwaIUvWzUNFTuDdZaWnHz6Ij3GhNCQEp8QirFHyBgkIlRhNUGv5eD0eLGjsR2A35uTqqgRLhF5hFT6xVg1VoW1Z1oMkEaEIvQIKfi7/PPGgq/JLZk+D8gvGCosJuT5yuEDIzl7jwnRoMIcg+hrYrDflXxCbKAre57APkJZeq0YgQsVEQKAiYMLAQBf7SafEEFECgmhDCRoRCgis7Q8laHXaqDzXb32ReUYG7FxQqlwBX401hGhIB4hrYZDla+EnkVJkqWPULRElhpT00dIXfl8sK7SDHHeWIQRoVAeIXvI1BjrLK2RPQYAyixZyGVCKEDUsNL56qIcBOKvHOt5DExQlZiFz489oLO0Ua+VDLD1R4SUIl4ThwiewG8P2oKaswmCUIaEUAYiE0LZerFJnpqUlj1I+TzQt72EWJSAlQs3dzpVRbTCEcpnwqgulJ/wkik1Fg0mVamxCIauqtgfELpiDJDMG1MZEXIolJczcg1qzNLyiJA0/VtuMYlprkCfkZI/iCEKIQVfEUuNFfs8ZuwiQxQ8Oo1/hp/LI4sUBdLPakJVgQkeL49th9qCHiNBED0hIZSBsC9SjhNOENGM2Aj0CAn77ZsSeqfbK6boqotyxEiUdEJ4tLC1K0UVGAMkQijSOWPJiJoITnRDV0N/noL1EGL45431PiKULYqYUKkxuUdI+hmvsGYhzydqOrrdsp5kdcd6VowxxBJ6hYgQ8xoV+zqC20WPkD8iZJREhML516w+TxVrzEgQhDpICGUg7MRnztJDo+EiM0u7ggshljbpCjPJvLe0+irGOE6IGrATyZHejNnwwaawh5pbNrDIP+4kmjljyYYqj5A4YkNN+by6yCBLZ5YEaZbIOiu3dqn0CIU0S4fvIxRYNSZtqlhuMYmpMbdkphkA7GU9hEKlxhTSVSyyVCIKIXn5fJZOI/MIBTNLM9QKUIIg5JAQykDYFyZLPegjMUuLBs+eUZC++iK2+SIEFpMeWg0nnkhiYZgOd9UNyCNCqe4PAtTNBotkxIZJpRBi4kDaL0eKVWyo2Dfl86xqTKtRSI1Zs5Ct14pNFtnaeZ7HXoUeQgxxzIZC1RhbCxPygbPGsqQRIVf4iFBfj7khiHSBhFAGwk5U7ARkjMgsLXx5S0uLGeIXcZxTY6yrtNW3/uI8IaIQixL6cH2EAH93aSD1K8YAdSdQ9tmIxCwdThCzdBGLmgTiT405VY3HUWOWVtdZWiE1ZjFBo+FErxFLax23u8Q0bf+CbAQSLCLE87y4lhLf59ffR8j/GRQ9Qm6/RyjYe+BvakoRIYKIBBJCGQgzOjMhxMzSgamxLfWtqG/xD7HleV6sbFEyS5tUeE1iAfOMWHwnSlZ1ExMhFKZ8HhCMqcyXlOpGaSD25fNqqtC8Xl6smlJqpgj4I0IuDy+KhFB0hyifV9dHKKB8Xpoa8/mYWAk9i+aw9F5BjkHxtQnmEXK4vWKVmhgREqvG/JEt5YhQuNQYRYQIIhJICGUgWQERISWP0JG2blz60mrc9MZ68TaH2wt2YR44fR7wX3Uf61Dn6YgWVjHGIkIsNXa0txPoIS2fD/6nodNqxBL6wnRIjenCR/L8/pTYDF3tcLrFz1KwiJBJrxU/m2oqx0J5hHLEqrEQZmmfMNGx8nmfoMoxaMWKMeYTYhGhJt9nrjhId/FgVWPSFB0blsvM0g5JqwJZRMgdPPUn3K6++pMgCD8khDIQVuXEZmUxj5BUCB22dcPLA/ub7WJaQnpVrpR+GFkpzLZau7clPgv3wXoIsYgBSy00xcIsHeJkKoV1mE6WyfO9wWTwnWyDiASe5yMascFSSl0uT9CUFouQGHSaoK81x3ERjdkIFTFRExFiDRX1AeXz5VaTaIhn+2HCxm/4DiKETMp9hJiQyjXqkG0M1lAxMCIU+rNJESGCiA4SQhnIFWOr8NOJ1bjpzGoAUGyoyK5OnR6veKXNTiJGnUY0lEphU7C/3n0MXm94T0e0sJNiYEQoNh4h4TUIVT4PAFeMqcKQklycM7Sk18+ZaMJ5u9xeHuztVJMaY6XqXj54dIKZh4NFgxisJFyNEApdPu8XG8E+m4EjNlikZqDEHJ/LSugdLCIkfOaCR4SUJ9Czx+cYtX7hKFaN+QWdNCIUbvCtmsgeQRA9Se0GKERUlJqz8MufDBd/lwohNjBVWgJv63Ih26ATTzTSjrtSRvUXpp83dzpRe6Qdw8rNcVk/K6fu6RGKQWpMRfk8APz4lHL8+JTyXj9fMpAVxmQrjRRGUjUGCOJZ6bVkwiCYP4jhrxwLnxoTp88beq4xV/KZ7XS6xZ5AUgLL588ZVoInLjoJZ/m6NgMSj5Bv/SwixHw+gQSrGmNCKNeoQ7beX5bf5fSIpu0snVbs29Tt8spM1EpkSaJHBEGohyJCBIw+szTP+30S9gAhJL0tWLTEoNPgNN/k69VxnHnUMyIkpMaOdTjFk0i0hPNhpCNZARGJQGRCSEUfIa2G6zE/K5BwFWMMaeVYOMTUkUJVlTSK2RmkqWJgQ0WjTotZ4wdioKQ/EPMKtXcHRITCCaGAiFCnRAhJzd0tkuM06jXisTjcoWeNSW+n1BhBREbmfNsTQZFe5bOTniwiZGdCSHnyvBQ2/PHrPc0xX6e4ngCPUFGuARwnlD+3dPbOqK3WI5ROSNMvSrCUjFbDiSIhHKy9QrCRFkxImIP0EGJYI/AIiWZphc8nx3Gi+TlYLyGXV141pkSuMbBqzGeWDiaEfBEkp9srEyhiRChL6OzOqhCPSz6/Rol/SuYRCtpQkfoIEUQ0kBAiRHMo4C8htktOYKxvj90RvKs0Y8IgwSe0tq45JrO/lBAjQr6TpE6rQaGvjL236TE1DRXTjXDl85EYpRmsqjBY9IVFSPLCjCex+iJCapoqdoWJWIYzTLOIEBu6qriPgAn0LCLEopKB5Bh0YHY6qWFa9Aj5XicWFWJC3qjTgOM48TV3yKrGgvURos7SBBENmfNtTwRFp9WIX9bspNeplBoL0UNI2NCG4d425Gfr0en04Nv6Vv99Bw8CNltM1sv8IhaTv2IrVk0VwzWtS0fY+xkskuD0+AauRiSEWGpMWXSoNUv7q8bUpMZCG93DNVUM7CythHTeGBDeI6TRcOJjpOkxsWrMJ6zY68U+20zsSEUq8/4EE6TGMKZ3giCUISFEAPCf5BwKqTF2JSt2lVboIQSbDZg+HZrJkzGhXCgtX73blx6rrwcmTQKmT4+JGGKpOnaSBCS9hHpRQs/z/hlSmZUaCy2EmMBQ4w9isBN7uIiQWrN0q8LQ0p7rDB0xYftqCSKqRLN0iNSY3yPkQrfLI6b4gpXPA/5jtEkM01KPEOCPoLHUGItIMrO0NCIUrNknpcYIIjpICBEA/Cc5p5gaC2GWVooItbcDTU1AXR0mfPAKAGD1nmOCCJo8GairE+5vb+/VOl0er5iWYGkTAKiwmgAAe5s7o963tNQ7aNQrDQlnshXHa0SQLmTRl2CT0NWapf2pMfUNFYNFhML1m/IEmKWVyJV0lmbRIKNOIwokJSwKhun2ACHE1tziE/liREhS0RfWLE2pMYKIChJCBICe3aWlJ7BWu1wIKXqEKiuBFSuAmhqcuWEZAGDzvhbYp0wTRFBNjXB/ZWWv1in1WZgl/pIR/YRmjt8dbI1639IoWKjO0ukGO+kGG7rqiGtESG3VWOiIEM/zErO08jqLw/SbEs3SIVJjuZKqMeZHKzEbxYaLSojdpSWf3U6xj5DcIyRGhHwCSBYRUlk+TxEhgoiMzPm2J0LCTnKukBEhVjUW5Oq3qgpYsQIDCkzoZzsCFw+sc2f7RVBVVa/XyVIkeVk62ZX7yCqfEKq3Rd3MkaUedBFUR6UDUh+KUidoFhEyROCbYunT8B4hlamxMBEhoQeW8P9gQqHUzHxkyoZ60Swd4r3PU4gIBWumyFAas8HM0nkBHqEWe0BqTBIRcoSdNUYjNggiGjLn254ISWBEKOLUGKOqCtzbb2Pcga0AgO/KTwDefjsmIgjoWTHGOKE0D1l6DdodbtQdiy49Fm6oZboiTbUonUSjqhozxiYixN5nW5crpMDtdkrSmkFTY76IkEJqjOd5/6yxUB6hLGlEKHTFGENp8GqH73URq8Z8a2aCzxgQEepyevwpymCdpamPEEFEBQkhAoCSEPJfvdpEszT78g4hFOrrgVmzUGU7AgA4nFcEzJol3B4DbF1s4Kp8xpdeq8HJFb1Lj0lnPGUSUuGndBJlA1cjqRoLFxES+wipHLHh5Xs2JZTC0mI6DRc0ohOqA7lbIrJCls8b/SM2mKAKVjHGMCtWjQn/zzEGRIQ6hduZAGIpMuljKSJEELEls77xiaCIVWOqzNJB0hkSY3SF79zQUNpf8AhNnhwTMRQsIgQAI6usACAv24+ATCydBwQRyXwxSkbbXvURCtZZ2ndit4SpGjPoNKLwDuUT6g5jlAYkZmkFjxBLiwFhGir6IkIeL4/643bffsMIIYUxGyxSxiJM7G+qNaB8ngkim+TYg/nXwlX/EQShDAkhAoDfF6HYWbpLhVn64EF/dVhNDcp//TAAoPGk0YJHiImhgwd7tU52MrQopFSYENpyMLoS/UxspsgIZbSNRgixztJ2hZ49PM+LaSKlmV+BqKkcYxGhYKXlAFDqiwi12l1ilIvBjNJAaCGUY9CC+aLrjgop2PARoZ6DVzsCzNLsb6q5M6CPkE/csCqzUP41aWpMyetFEIQymfeNTygSzizN83zoERt5eUBJiWiMrhgieIIa7G6xmgwlJcJ2vaC1K3hE6NRKKwBge0NbjxOdGphZOpNK5xnsJKpUOcZSLZGkxkxiQ8We++t0esRp9uFSYwCQnxN+zIZYOh+kYgwQxDM7hkCfkDQiFCo1xnGcWDlWd7QDQOgeQoA0ItRTCOUGCCEmOlnUJ1CUh/KvMRHo5f3NIQmCCA8JIQJAaLO0x8uj0+kJPXTVYgGWLAFWrgSqqlBmEfr6tHe70VFSLty+ZImwXS+w2ZU9QgBQVWBCfrYeTo8XOw5H3q/IEWaWUzqjLiIUTdVYz/0xQaDXcqqib+y9bu0KHhHqDjNeAxBEDKvwCkyPuX0XABwndIMOBesZxNJ+xblhzNIBVWM8z/doqBgovv2pMfntoaJy0tdSbXdpih4RBAkhwocxsI9QgMnV1uXym6WDNY+zWMQ+QblGneh/ONzaJdwepQiSflEfD+ER4jjO7xOKwjDdFaZPSzoTat6YaJaOpo+QgllarBjL0ofsv8Ng7/XxzhAeoTBzuBgsenM0wDDt8oafM8bIDSj5VxsRavcJQIfbK5qzxREbQQRPoB8o1PEZtBoxbafGJ/TdwVYMe3QJfrd0Z9htCSKdISFEAJB4hDxCLxk2V4zNXWq1O2H3NVlUmzqq8EWFDtv8Jx23x4v31x9AU5v64ag3vrEepz35OV78YjcaWrsAKHuEAGCkLz22JQrDdGZ7hIKXXjujSI0xsWxXKJ8XewiFKZ1n+JsqhvAIOdW1PigNYphmEaFQ/iCG1NfEcRAH/gZDLJ/3CcAOiW+KCaDA3lxBI0IhPpuyIa0qukt/tfsYeB54+5v94vETRCaSed/4hCLS1JjQWE+4nVXESCNCoabPSym3Ciedw7Yu8baPNx/CvH98jwf/8Z2qfXi8PFbuPIqj7Q789rNabNh/HID/5BjIqb2oHOtWYbhNV0whUmOOMP1rlAgZERLHa4SuGGOomTcWbrwGg0VvjgQIcbGHUJi0GOBPZwGCCArXfNPfWdoNnuf9A1eNOjEN1zM1FiQiFCY9GUl3aXZR0Wp3Yd3elrDbE0S6QkKIACCfNSbt/VJmEcRMW5dLLPnN1qs7gZX7IkINrf6TzraGNgDAV7uOidVogCC0LvzTV3jsn1tl+xCM2sL/TyjNFW9nXYIDOaVSSL/tOdoZsu+MEmJEKJM9QgreEiaAI0kZihEhBY9Qu0NdM0WGv2qsd+XzQPCmimq6SjOkqbGiMF2lAf9xOj1eONxeScWYf62BFxfstdZpNWJUVrg99Pqks8nCIf27XLKtMez2BJGukBAiAMgjQuzkZdRpxMjLcbtLUpmjMiJk6RkR2t0kVNq4vTy+2NEk3v7J5kP47qAN/9h0SLaPFl85sTlLhyV3nY2Fs0/Ds5edgpP7mRWfszDXiKoCQYB9H2EZfaY2VATkoxwCYdGTcF4YKf5ZY0oRIXXNFBn5KsZsqH3vgvUSckWSGpNEhEqCCHIpOQYtmJZp63L1qBgDev5NSaOS0qhQOMO6mOJUYZZmESEAWLK1MerRNASR6mTeNz6hiFQIMcGTbdDC6rualaYSpFeyofALIf9jmRAChC9fxj82Cf2FOhxuWek7O/nl5xig0XD40dASXHlaVUiTbbQ+IbF8PhNTY74TcZdCBKfR9/4Fi8IpwarGHG4vPAEnWDE1FqaZIkM0S4f0CKkT6f7u0gERITE1Fv4rMU8SEQo3ZwwQvDtmyQT6wIoxQMEjJBU/UlEULiIUQWrskE8IcZzwemyOshEpQaQ6JIQIAJLUmCQilG3QiV/gjRIxozZ1VGGVm6Xbu11olAiqlTuPotvlQW1jO76TRG+k/WL8VWKhDalSTvKN2th5JLIS+nBDLdMZduJViiSw96wsAiEkFSSBYzZYylJNM0XA/96r6SMUtmqMRYQCPUK+iJBeRUSIjdkA1EfJWPTL1uX2R4SypEJIXUQo3PEZQ1T/SWnrdoljTqYMLQUAfEbpMSJDISFEAPBHhFwSj1C2QStWZzX4xIxJrw3bZ4UhRoRau8DzPPb4OvEW5RrRz2pCl8uDVTuPitEgRnOH/8r/uC81VqBQLh+MmuIcAMDeCIev+r0wmfdnEax83u3xilPWmV9MDUad39sS6BNSO3meka9CCKkdmMuES3OnU0yHAf4GhOGMz4BcwKiJCAH+Kse2bn9qLEcSBQqMQgaPCIVJjbGqsTCpscM+f5A1W4/LRvcDIERoqacQkYlk3jc+oYjMLO3wp8bYF/hhXxhdbcUY4DdLdzo9aOt2i2mxwSU5OHe4cBX63+8P4+PNgi+IZbukKRD2/2BVYkrUFAlCqO5oZ0Rf7Gp70aQjLIITmFI51uGElxfaKKgxBjM4jgvqE1I7eZ7B0rMdDrdYyh+I2qqxgmyDWBl2rMOfHnP7RmyoqRqTpsZUR4R8acDPfzgiFgmEighJP4NGWURIbWosdESI+YMqLCZMOrEYRp0GB1rs2B5FI1KCSHVICBEAJENX3V6xh5DJoBX9GSw1Fsn4CenjD9u6JEIoF+edVAYA+Oe3DTja7kBhjgGjfKXvbN4SALRIPEJq6V+YDQ0nnDiPdvQcsBmMTC6fF1NjAUKIpcVK8oyy6iU1BOsuLW2oqAazSS+KZFuQEnq1VWMaDSfOBpNWjkVSNSY1S6uNCE0/uRwAsGjtAfxx2S4AYTxCQaJAqs3SYTxCzB9UYTUh26DDpBOKAQBLth4O+TiCSEdICBEA5ENXu8TUmE6MCLUrhPPVUC5pqrjHN5tpcHEuThuYj/xsvVgaf9Gp/UQz7nGJEGr1dRPOjyA1ZtRpUZmfDcA/GFMN/vL5zPuzMAYx2Tb6Kv4iMUozso1BIkJiQ0V1nyWthhM/h8Eqx8SqMRVCnZXQSwsAWJpMjdiTpcbCDFxlzDpjAP5w9anIMWjFz5lUCGXp/V2h2e8MoyxNFhuzNIsI9fP1+prmuzD5cvexcIdCEGlH5n3jE4oolc+bJKkxRqQDSStEn1A39ogRoTzotBpMHVYqbnf5mEox6tPS2TM1FolZGojOJ9SdwSM2WCSlKyClwiKBkRilGbGKCAH+9FiwXkKiWVqFiC1WKKFnVWPqzNKRlc8zLjq1HxbfeRZOqhBaP1T7UriAkEo0BYkCyf4fLiLku98RJIXIaJBEhACgKl/41xbCh0UQ6YpqIXT55ZdjyZIlZKZLU+RmadY4sacQisQjBPgNtvtbOrG/xQ5ASI0BwAUjKwAITRCHV5jFUQVKQqgggtQY4D/JsAnhauj2nTwysXw+WCShsS1yozQjO8gEelatpNYjBEgrx5QjQmrL5wHlEnqxj5CK8nnmV8s16pAT4d9DdVEOPv7Zmfj0rrNw+ZhK2X3Svy1ZFCiCqjG1qTHWTJEJoRxxkGzPvk8Eke6oznMcP34cP/7xj1FRUYEbb7wRs2fPRk1NTTzXRvQh4tBVj1c2XNWS3TshxL5ov9nTDI+XR65Rh1LfiejsE4qx6KfjRGHETjAtMrN08CGroagpFvYZSWrMkcERoWAnUJY+6o0Qkp5ceZ6XjNhQ/576myr2ziME+OeNSQevsl5HahoqDijMxt1Th2BgYY6qobGBGHQaDCvv2RBUKuKCRoRilBo7FBAREoWQwmw4gkh3VEeEli1bhrq6OsyZMwd/+9vfMGTIEJxzzjl455134HCoN6RGS0tLC2bOnAmz2Qyr1Yo5c+agoyP01f7kyZPBcZzs59Zbb437WlMRaR8hduJSTo1F6hESTjrfHRL6BA0qyZWdPM4cXCT6TwpzfV2sO3uWz0dSNQb4K8eiS41lXsY42Kwx1hU8mtRYtjh41S+EulweMQ2l1iMESMdsBPMIqe8B5Z83Fp1ZmuM43D31BFw8ql/YbSNBOrpGmgKLJCJkFE3vwVNjHi8vmuD7iULIL1op6k9kGhF94w8YMAC/+tWvUFdXh6VLl6KiogJz585FeXk5br/9dmzcuDFe68TMmTOxbds2LF26FIsXL8aqVatw8803h33c3LlzcfjwYfHn2WefjdsaUxm5WdqfGjPqtDJhEGkqgJml2Xfr4OLcoNuKESGf+OF5Xhy0GWlqjHmEDrTYZf1iQqG2KV86EqzsmomFaMzSOWJEyC+umFFaq+EiSkGGG7wayXsnzhuTRIRcEZTPxwtpREhqig5WSq9EMNO7lKb2bni8PHSSCjrme+J5/2tJEJlCZJf3Es455xycc845aG9vxzvvvINf/OIXeOWVV+B2xz7HvH37dixZsgTr16/H2LFjAQAvvPACZsyYgeeeew4VFRVBH5udnY2ysrKYryndkJXPB/gtrCYDGl2Rl88D/ogQY1BJTpAt/WKHCaG2breYsog0NVaalwWTXosulwf1LXYxVRYKf1Qh8yJCRoXUGM/zolk68H1UQ7ZolvZ/J/iN0rqI0kr54TxCEaTG/N2lo4sIxYvYeITY8Nzg4p8ZpcssWWKVnEmvBccJQqjD4e5Rzk8Q6Uyv/ur37t2L5557Dk899RRsNhumTp0aq3XJWLNmDaxWqyiCAGDq1KnQaDRYu3ZtyMcuWrQIRUVFOPnkk/HQQw/BbrfHZY2pjqJZ2vdlKE2PRWuWZoSKCDEhdNzuBM/zYlosx6AN2z8lEI2Gkxim1aXHxD5CGTh93l81JonedLvF36PxCInpFoc0IhRZM0WGOG+sM4xHKAKz9LEOhyi0Ixm6Gi/Ye2DUaWQiMTKPUHiz9KEAozQgpPvEKj/yCREZRsSyv7u7Gx9++CFef/11rFq1ClVVVZgzZw5uvPFGVFVVxWONaGxsRElJiew2nU6HgoICNDYGn49z7bXXYsCAAaioqMB3332HefPmoba2Fh999FHQxzgcDpnnqa2trfcHkAIYpGZpl3/EBhAohCL7yGTptSjMMYhNEpkxWgkmhFweHu0Od9Sl84zq4hz8cLhNlU+I53mx5JhSYwLMKG0x6aN6TUJHhCIVQr6IUFeYPkIqonmFOQZoOMDLA80dDpSYsyIauhovmIgLfK1lESGV5fOhhJC/h5BJdnu2QYsOh38WGkFkCqrPauvWrcPrr7+O999/H93d3bjkkkuwZMkSTJkyJarKCQCYP38+nnnmmZDbbN++Pap9A5B5iEaMGIHy8nJMmTIFe/bswaBBgxQfs2DBAjz++ONRP2eqojx0VfhSlV69R1NaXm7NQnOnEwatBv0LsoNul6XXItughd3pwfFOp3+8Rk5kJ03GIBYROha+hF7adyXS9F86wE6+DskJ9HAveggBoT1CkRilgdBVYy6PV5wVpubzqdNqUJhrxNF2B5rafUIogqGr8SJbFEJyMSbzCKlMjTlCmKX9PYTk72uuUYemdkePdgcEke6o/jY644wzMHLkSDzxxBOYOXMm8vPze/3k9913H2bPnh1ym5qaGpSVlaGpqUl2u9vtRktLS0T+n3HjxgEAdu/eHVQIPfTQQ7j33nvF39va2uIW6UompA0VuwJSY1J/Dkt3REKZ2YSth9owsCg77FDL/GwD7M4uNHc6xTRIpBVjjOpi9akx6RV0JnaWZidfaWrsiE8IlUaRFgP8VWNdkhNre7QRIVPwqjHZe6dSqJfkMSHUDcAiCqlIx4jEEvb3FngMwbpMK8G2DTV0NbCZovj8QTqBE0S6o1oIbdiwAaNHj47pkxcXF6O4uDjsduPHj0drays2btyIMWPGAACWL18Or9crihs1bNmyBQBQXl4edBuj0QijUf1wyXSBRYRcHl5WPg/IU2ORls8D/ivPUGkxRkGOAYdau+QRoSiFUE2Rr5eQitQYSwnpNJyqCeTpBoukuL083B4vdFqNWGJdHmVESGnoahtrphhxaix4RIi9dxwXXigwSvKM2AbgqK+pIhu6mkiztJga0wWmxiKYPq9i6KqSRwjwdwKnpopEpqH6r14qgr788ktcd911GD9+PA4dEiaHv/322/jqq69iv0IAw4YNw/Tp0zF37lysW7cOq1evxh133IGrr75arBg7dOgQhg4dinXr1gEA9uzZgyeeeAIbN27Evn378K9//QvXX389zj77bJxyyilxWWcqoxwRUvAIRZEa+9GJJcgxaMVBq6FgPqFmmRCKLjXGIkJH2x1iJCIYmVw6D8iPm1UcMSEUbURIacSG3ywdYWrM97lwSD6fDOZBytJpVafpWbqXdblmVWOJLJ9nf1uBqTF5Kb1Ks7SKiFCgRyhXbKpIQojILCK+/PnHP/6B8847DyaTCZs3bxaNxTabDU899VTMF8hYtGgRhg4diilTpmDGjBmYOHEiXn31VfF+l8uF2tpasSrMYDDg888/x7Rp0zB06FDcd999uOyyy/Dvf/87bmtMZaRmaVblo2yWjkIIDS3B9786DxedGr4BnVg51ukUu0pHMnleijlLjyLfdPBwhulMbqYIyCMp7LU40kuPkFJn6WjN0jkGrShSAtNjbFSG2gGogP+kz4QQS40lMhrIIkKBVYuRRISMYczSHQ43bD4xGtgSgaUyO6hqjMgwIs5z/OY3v8HLL7+M66+/Hu+99554+5lnnonf/OY3MV2clIKCArzzzjtB7x84cKCsI2pVVRVWrlwZt/WkG9KUQFdAKbLUIxStkVij8kpb7CVkd4o9Y6JNjQFCh+ljHQ7UHe3EKZXWoNtlcuk8IJRPZ+k16Hb5Iy6iWdoSXao4x9izHJuZpfOyIvvq4TgO1mwDjnU40Gp3ydI6LMIRSa+jPJ8QYxVSHm/izdLs9QqcMJ8VpLmiEuFSY4d9r5U5Sye+Boxcn0fIThEhIsOI+PKntrYWZ599do/bLRYLWltbY7EmIgEoeStYasPci/L5SBGFUIdTbKwYaTNFKazDdDifUCY3U2SIFUe+tIo4Z8xsCvqYUISMCEXYRwiQVo7JI0LRNH1kQoylTF1JUD5/5qAinFCaiwtHyhvEGoOM21AiXB+hwBljUtjfdgd5hIgMI+KzWllZGXbv3o2BAwfKbv/qq69oCGsKY1BICTADbW9TY5EgbarIjLGRjteQUq1y5hjzVGRi6TxDMOm60O3ywuH2iL2fommmCEgiQk4PeJ4Hx3FRDVxliE0VAwzT/siVesGWK6aBmEco8Q0V+xdm43/3TOpxOxM3Wg0X1sztF7Ne8TWXwqbOB/qDAOUIHgB4vTw4DlG3SSGIZCfiy5+5c+firrvuwtq1a8FxHBoaGrBo0SLcf//9uO222+KxRqIP0Gg4mVE0S68R01l9KYSk88Zaohy4KoWdxKWTxpUQJ89naGoM8IvALpdHHD9h0GmiNquzz4rHy8PpExpi1VgUEaFgTRXZYNjAvjih8EeE5GbpRKbGgsEiQmraOkgjRg6FMRv1xwUPpVJEKEehys/j5XHBn77CZX/+moaxEmlLxBGh+fPnw+v1YsqUKbDb7Tj77LNhNBpx//334+c//3k81kj0EXqtBm6vvIcQAFgTkRrr9EeEojVLA0BxLhunoNyRmBHJ9PJ0xT+53OOvGDMbo44ESD8rdocHBq0GzR2CwIom3RmsqWJjFKbuwIhQMqTGglFZYEKuUYcTSsO3n5BV/7k8PT7Pu460A1BuZcEiQtJU5rEOB7Y1CN31WzqdKMzNvNYiRPoT8VmN4zg8/PDDeOCBB7B79250dHRg+PDhyM0N/0dKJDcGnUZxeGVhrhHXnF4Fg1YT99QRE0INrd1iFCHaiAQA8Yv7WIcj5HaZXjUGwFdh145XVtbh4lFChV95lP4gQEjlGHUaONxedDrd4OGPCFXlB+8wHgwWEWIz6BgNNuW+OKHI7RERSrxZOhjmLD2+mvcjVSJdr9VAq+Hg8fKKhumdR4Qu60MURJW/fN6fGmMVZoBQnUdCiEhHor68NxgMGD58eCzXQiQYgySsHthBesGlfdN7iQkhJoIMOk1UYz0YRblsarkLLo83qMeCCcBwIwzSmfumnYBNB47jq93H8O3BVgDR9xBi5Bh1cLidsDs9OOJLt5VbsqIS1GJTRcnJ2en2iiI3Ei9TntFXNZZE5fOhiGTeXpZOg06np4dhusvpEVNjJ5Tm9XickrldGn070taNYeXmiNZNEKlAcv7VEwlBapiOpoN0LLCY9JBW2hdkG3pl0szPNoj7a+kMnh4TU2MZ7BEa1T8fr91wGow6jRgpKTP3LgIg7S69v1kwrA8szIlqX8wrJq0aO9LWDZ4XPruFEaRQmUdINEv7yucTOWIjVogl9AFNFXc3dYDnhYuNIoXIjlJDxcCIEEGkIySECBGp0TKaDtKxQKvhZFe/vSmdBwQTeEGO8KV/NMQXOaXGBMYPKsSr148VRXF5BJVYSki7S+/zVe4NLIo8LQb4PUD1LV3ibczLVGbJikgw50qEkNfLJ7VZOlKCDV7d6fMHDQky6iY7XGqsLXTBAUGkKpn9rU/IkKaN4l0dFgqpJ6g3FWMMlh5rDhURcvf0RmUqk04oxuuzT8MVYypx4akV4R8QAukgz73NQlom2ogQM/jWHesQPT2smWKkJf4s+gEIfXNcrHw+Cc3SkWIM0ktoZ5MghJTSYoC/oaI8NSaNvvW8kKBKMiIdUJ3/ePTRR3HRRReJQ0+J9EPqEUpkP53CHCP2+CbG96aHEKM4z4gdje04FiIi5KCqMRkThxRh4pCiXu+HRYS6XNKIUHRCqJ/VhGyDVoguNdsxuCRXrBiriFAIZem1MGg1cHq86Oh2w+1No4gQG7MRUD6/y2eUDlZ9xqr8ZENyZakxeUTooY++w9IfmvDPO86U9SU6eNyOd9YeEMWlyaDDdWf0R0le7/xmBBEvVAuhgwcP4vzzz4fBYMAFF1yACy+8EFOmTIHB0PsTFZEcSIVQQiNCOf6IUG9TYwBE70ioyjFKjcUH9jnqcLhFIVQdpRDSaDgMKcnFtwdt2HWkHYNLcqNqpsjIzdKhpdOJDodfCKVDRChYd2kxNRYkIsTK510eHk63FwadRpYaC4wILdnaiON2F95fdwD3TjtRvP3Rf27D8h1Nsm1dHi/mTR8a5RERRHxR/Vf/+uuvo7GxEe+++y7y8vJw9913o6ioCJdddhneeusttLS0xHOdRB9gkKXGEmOWBiB6eoT/xyI1JuwvZGosw6fPxwt2cq1v6UK7ww2OA/oXROcRAoDBJcJJfFeTEN2Ippkiwz941ZUUnaVjhX/emF8IdTrcOHhceK2CpcZyJBc/LCrUGsQj1OFwix2+P9p8CF6fkDxs68KKWkEE3XRmNU4fWCDsxx66jxdBJJKILn80Gg3OOussPPvss6itrcXatWsxbtw4vPLKK6ioqMDZZ5+N5557DocOHYrXeok4ok+SiFCBLCIUAyHkm0oeKjVG5fPxgaVYfzgsNOUrN2f1SmyytA6LbkTTTJEhnUDvN0unQ0Sop1l6t084FuUagl5c6LQasWCC+YSkEaGjHQ5R8NS32MXbDx7vwob9xwEAH244CC8PnF5dgEcvGI6pw0t6rIUgko1e/dUPGzYMDz74IFavXo36+nrccMMN+PLLL/Huu+/Gan1EH2JIGrO0QfL/3qfGWEToaMjUGCufT/0TYTLBogw/NNgARO8PYrBoBvO7NIgDVyNPjUlL6F1eZpZOh4iQLzUmKZ9nwjFYNIgR2FRRKoRcHh7HfZEdqRACgI82HYTXy+P9DfUAgKtPqwLgHw+iNO6DIJKFmOU/iouLMWfOHMyZMydWuyT6GKMu8X2EAKAwVyKEYpAaY/sLNWaDUmPxgaVY2WvfWyEkrRzrcnpE31d5FKkxUQhJIkLJ2lAxEkSztCQ1xlKJ4YRQtlGL5k5/fyVbwDiTI21Cd+kDPiFUbsnCYVs3/vPdYUwdVoqDx7uQl6XD+SeXA/B/pzgCehoRRDKR+n/1RMxIGrO0LCIUg6ox5hEKFRHyXbFS+XxsCexQXh1l6TyDVY65PDzW7WsRmykWRPE5kafGknfERqT4y+f9URi/UTr0KCR/3yd5aoy9LqxyjPmNLhhZgX5WE9odbsz/6HsAwMWn9hNTomwtFBEikhkSQoRIsqTGCiVm6Vimxpo7naLHIRAHRYTiQqDpvrcRIVY5BgAra48CEHoIaaJIaYnzxhxucehqOnSWNipFhI6oiwjlSLpL8zwvCqGaIuE1b/JVjrHUWP+CbFzim0vHonNX+dJi0rWQR4hIZkgIESJ6nf8kkMiqMWn5fCxSY8wc6vHysioYKVQ+Hx8CI0IDC6OvGGOw8u9Vu/xCKBrysvzzxvwRodR///1VY8IxdTjcOORrPHlCiVoh5EGn0yO2FWCRJBYRYjPLqgqyccnofuLjT+5nxsn9LOLvlBojUoGI/+o7OzvjsQ4iCTBo/SetREaEysxZqCnKwcn9zMgz9l6QGXQaWEzCSS9YeqybGirGBamg5jjhxNlbWESIVUKVRymE5OXzrI9Q6keEAs3Su3xpsZI8IyxhIqzS7tLStBjrBn6kzQGe58UxJ1X5JgwqzsXo/lYAwDWn95ftj8zSRCoQ8VmmtLQUV155JW666SZMnDgxHmsiEkSydJbWaTX47J6zoeG4Xg1clVKUa4Cty4WjHQ7FhnJdFBGKC1JBXWExxURoBqZ3op2HplQ1lk4RIZaOUpsWA6TdpT2iUdpi0qPUN3z3SFs3mjud6HJ5wHFAv3zhtf/D1aOwdm8LLh3VT7Y/8ggRqUDEf/V/+9vf0NLSgnPOOQcnnHACnn76aTQ0NMRjbUQfkyxmaUA4IcXSr1Ho8wkFqxxjqTFjBk+fjwfSiFC0HaUDCTT8RhsRkgohf9VYGkSEdPKIkFqjNCCfQM8iQhaTHiW+Pk1N7Q7RH1SalyX+vVQVZOPyMZU9vFpiasxFqTEieYlYCF188cX45JNPcOjQIdx666145513MGDAAPzkJz/BRx99BLfbHX4nRFJikJwEsvWJ8wjFg1CVYzzPi1eslBqLLVKPULRT5wPpZzXJuiBHnxoT0kRt3ek2YoNFhATxsfuoEBEaHGTqvBR2ASSkxoSLBotJjxJfU9Kmtm7U+yrGqgrCR+IoNUakAlH/1RcXF+Pee+/Fd999h9/97nf4/PPPcfnll6OiogKPPvoo7HZ7+J0QSUWypMbiQVFu8Hlj0i/pdDvuRJMjiQhFO3U+EI7jZCf1aFNjLPohHSyaDuXzgWZp5qUaXBxeCOUEiQiVKkSEqvLDC1u/WZqEEJG8RC2Ejhw5gmeffRbDhw/H/Pnzcfnll2PZsmV4/vnn8dFHH+Hiiy+O4TKJvkBaPh9Y7ZPqiKmx9p6psQ7JtG3qLB1bpCnWWAkhQD44NPqqMeGk3yKZQZcWDRUlQ1e7nB6xYkxNRIhF2jodHlEIWbMNKPZFhNxeHt/WtwIAKlUY38XoFFWNEUlMxPmPjz76CAsXLsRnn32G4cOH42c/+xmuu+46WK1WcZsJEyZg2LBhsVwn0QcYJP6YrDTzyvh7CfWMCC3+VvC4DSrOSYsTYTKRI6n6620PISls5phBq0FhlC0WmBBq6/ZHhNKhaozNy+t2e1B3rAM8D1iz9aoGGIsRIacbrRKztN73Ojd3OrHpgDBXrCpfTWpM+HtyeXh4vHxa9Gki0o+IhdCNN96Iq6++GqtXr8Zpp52muE1FRQUefvjhXi+O6FtYasyk10bVoC6ZYamxowFmaa+Xx8Kv9wEAZk8Y2MerSn+MOg1Ory5AR7c7Jj2EGKwCqtwaXTNFwJ8a4yU9NtOiakznT43tOSq0OxlcnKuqAlPJLG32tZ4oMWehudMpFhz0VxERMkqqMJ1uL6WeiaQkYiF0+PBhZGeH/gMwmUx47LHHol4UkRiYPyLRFWPxINgE+uU7mrC/2Q5zlg6Xjq5MxNLSGo7j8P7NZ4j/jxVnDi7C9eMHYHxNYdT7YJ2lGRyXHp2lpakx5g8apMIfBADZkoaKYmrMJ4RKzUZsP+zfVk1PKGm63eH2kBAikpKIhZDb7UZbW1uP2zmOg9FohMHQ+07ARGJgYex0/LIqyvGnxnieF0/Kr6/eCwC4Zlx/WRqHiB2xFEAMvVaDX190cq/2YdRpYdBp4HSnz+R5QG6W3hNBxRig3FCRNSNllWOAcNHEDNSh0Gk10Gk4uL08GaaJpCXiOLDVakV+fn6PH6vVCpPJhAEDBuCxxx6D10sf+lSDpcbSMyIkCPRulxedTsG4uf1wG77e0wythsP14wcmcHVEopB2Lk+H0nlAXj6/h0WEStT5s2QNFQOEkFT49LOaVEfP/L2E6JxAJCcRXwK/8cYbePjhhzF79mycfvrpAIB169bhzTffxC9/+UscPXoUzz33HIxGI37xi1/EfMFE/Dil0or+Bdk4/+TyRC8l5mQbdMg2aGF3enCs3YFcow6vfyVEg6afXIZ+1uhKsInUJjdLh2Zf1Vg6NFME/MKjy+VB3THmEQrfVRpQ9ghZs3tGhCIZlWLUa9Hp9FDlGJG0RCyE3nzzTTz//PO48sorxdsuuOACjBgxAq+88gqWLVuG/v3748knnyQhlGIU5Rqx6sEfJXoZcaMw1wB7SxeOdTiQbdTin1uEarGbzqxO8MqIRJEriQilg1Ea8EeE3F4e8PIw6DTiKIxwsGhwl8sjthWwSMzSjEoVPYQY1EuISHYi/sv/+uuvMWrUqB63jxo1CmvWrAEATJw4EQcOHOj96ggihhRJxmz8cdkuOD1ejO5vxZgB+QleGZEo8rKkqbH0iAgFzsurKcpRncaS+uTau4X+WkqpMTVdpRk0gZ5IdiIWQlVVVXjttdd63P7aa6+hqqoKANDc3Iz8fDq5EEmCzQYcPCgKoQ37WvDuunoAwLwxhcL9REbCxmwAaRQRCugBNkilURoQREugaDIrmKXVdJX271M+BJYgko2IU2PPPfccrrjiCnz66adiH6ENGzZgx44d+PDDDwEA69evx1VXXRXblRJENNhswPTpQFMTih77GwBg4df74PHymDIwD+Ou/TFQUgIsWQJYLAleLNHXyCJCaeIR0mg4GLQaOD2C8FBbOg8IFX45Bi3afNGgLL1GTLUVR+0RotQYkdxELIQuvPBC1NbW4pVXXkFtbS0A4Pzzz8cnn3yCgQMHAgBuu+22mC6SIKKmvR1oagLq6lD04TvA8OnweHlwAB585RdAXZ1/OxJCGUc6psYAQXwwIaS2dJ6Ra9SJQoilxQAhYnbWkCLsa+7EiaXqzNcApcaI5CciIeRyuTB9+nS8/PLLWLBgQbzWRBCxo7ISWLECmDwZRYf2AcOFmy/b+w1O3LIaqKkR7q+kZoqZSDqapQHBMM08PoOKIxttki15TawmeV+4t246HR4vH9EoGppATyQ7Ef3l6/V6fPfdd/FaC0HEh6oqYMUKccyGwe3EvZ++7BdBPm8bkXnkplNqzOeFA/yGaY4DaopyhdtVeuGkhmlpREjYHxfxPD7qI0QkOxFfAl133XWKZmmCSGqqqjDpiXsxZfc6PPXZn1DRfgx4+20SQRmOtKGiNpUbKjIv3KRJQH29aJjuZzXBdKRBuH36dFViKEfSUNUcIISigXmEuik1RiQpUY3YeP311/H5559jzJgxyMmRh11/97vfxWxxBBEz6uuRe+P1eI15ggBg1iyKCGU4eVkSD0wqe4QkXjhMnoysn/0FADA4TwdMnhyRFy5URCgaqGqMSHYiFkJbt27F6NGjAQA7d+6U3RePmUIE0Wvq6/0ng5oaIRI0a5Z40iAxlLlIPUIpnRqTeOFQV4esH7YCxYMw6PN/+T/3Kr1w0ogQ6yrdG8gsTSQ7EQuhL774Ih7rIIj4cPCgXAQx0SM5aWDyZGDlSjJMZyBSj1DKm6Uln+s8WzNQPAgn7PkuYi9c7CNCVD5PJDdRj9vevXs39uzZg7PPPhsmk0k20Zsgkoa8PKFPECA/GUjFUEmJsB2RcaRd+XxVFfD227jjipswoPUwfrL9S2DFsoginrmxFkJ6qhojkpuIhVBzczOuvPJKfPHFF+A4Drt27UJNTQ3mzJmD/Px8PP/88/FYJ0FEh8UiNEtsb+8Z8amqEiJBeXnUQyhDyZN0lo60Giopqa8HZs3C6IY6jG4Q+rxF6oVjE+iBGKfGXJQaI5KTiP/y77nnHuj1ehw4cADZ2f7uoldddRWWLFkS08URREywWIKnvSorSQRlMPLUWIpHhAK9cKt9fbJY+re+XtVucowxrhqj1BiR5EQcEfrf//6Hzz77DJUBJ5YhQ4Zg//79MVsYQRBEvJGZpVO5fD6GXri4VY2RECKSlIj/8js7O2WRIEZLSwuMRqPCI2JDS0sLZs6cCbPZDKvVijlz5qCjoyPs49asWYNzzjkHOTk5MJvNOPvss9HV1RW3dRIEkToYdBoxYpHSVWPMCxdojGZiqKZGtRcuR9ZZOnZ9hKhqjEhWIhZCZ511Ft566y3xd47j4PV68eyzz+JHP/pRTBcnZebMmdi2bRuWLl2KxYsXY9WqVbj55ptDPmbNmjWYPn06pk2bhnXr1mH9+vW44447oEnlKz+CIGIKM0zrU/l7gXnhVq7s6QViXjiVg4Wl5fMxrRqjPkJEkhJxauzZZ5/FlClTsGHDBjidTjz44IPYtm0bWlpasHr16nisEdu3b8eSJUuwfv16jB07FgDwwgsvYMaMGXjuuedQUVGh+Lh77rkHd955J+bPny/eduKJJ8ZljQRBpCa5Rh2OdThTOyIECCInmNCJoDWENCIUG48QpcaI5CbiS6CTTz4ZO3fuxMSJE3HRRRehs7MTl156KTZv3oxBgwbFY41Ys2YNrFarKIIAYOrUqdBoNFi7dq3iY5qamrB27VqUlJRgwoQJKC0txaRJk/DVV1/FZY0EQaQmrLt0WpTPxwDmm8o16mLSW4kaKhLJTlR9hCwWCx5++OFYryUojY2NKGG9YHzodDoUFBSgsbFR8TF1vpbyv/rVr/Dcc8/h1FNPxVtvvYUpU6Zg69atGDJkiOLjHA4HHA6H+HtbW1uMjoIgiGSEnfjTonw+BgwqzkVNcQ5GVeXHZH9+jxBFhIjkJCoh1NrainXr1qGpqQler/zDff3116vez/z58/HMM8+E3Gb79u3RLFFc1y233IIbb7wRADBq1CgsW7YMr7/+OhYsWKD4uAULFuDxxx+P6jkJgkg9WAl9yqfGYoTJoMWyeyfFrEEuzRojkp2IhdC///1vzJw5Ex0dHTCbzbI/Fo7jIhJC9913H2bPnh1ym5qaGpSVlaGpqUl2u9vtRktLC8rKyhQfV15eDgAYPny47PZhw4bhwIEDQZ/voYcewr333iv+3tbWhiqaQ0UQaQubQJ/SZukYE8spAZQaI5KdiIXQfffdh5tuuglPPfWUYhl9JBQXF6O4uDjsduPHj0drays2btyIMWPGAACWL18Or9eLcePGKT5m4MCBqKioQG1trez2nTt34vzzzw/6XEajMa5tAAiCSC6qi3IAABVWU4JXkp6QWZpIdiIWQocOHcKdd97ZaxEUCcOGDcP06dMxd+5cvPzyy3C5XLjjjjtw9dVXixVjhw4dwpQpU/DWW2/h9NNPB8dxeOCBB/DYY49h5MiROPXUU/Hmm29ix44d+PDDD/ts7QRBJDe3TBqECYOLMLKSOozHA/IIEclOxELovPPOw4YNG1BTUxOP9QRl0aJFuOOOOzBlyhRoNBpcdtll+OMf/yje73K5UFtbC7vdLt529913o7u7G/fccw9aWlowcuRILF26NG7VbQRBpB4GnQZjBsTGGEz0hGaNEckOx/M8H8kDXnvtNfz617/GjTfeiBEjRkCvl/eZuPDCC2O6wETT1tYGi8UCm80Gs9mc6OUQBEGkFI22bpyxYBl0Gg67n5qR6OUQGYTa83fEEaG5c+cCAH7961/3uI/jOHg8pPoJgiAIARYRcnt5uD1ealNAJB0RC6HAcnmCIAiCCAbzCAGAk4QQkYTQJ5IgCIKIGwaJ8KFeQkQyoloIzZgxAzabTfz96aefRmtrq/h7c3Nzj549BEEQRGaj02rE8SVUOUYkI6qF0GeffSYbPfHUU0+hpaVF/N3tdvfo2UMQBEEQ1FSRSGZUC6HA4rIIi80IgiCIDCVLT00VieSFPEIEQRBEXPH3EiIhRCQfqoUQx3E95s/Ech4NQRAEkZ4YxYgQpcaI5EN1+TzP85g9e7Y4h6u7uxu33norcnKEOT1S/xBBEARBMPweIYoIEcmHaiF0ww03yH6/7rrremwTyeR5giAIIjMgszSRzKgWQgsXLoznOgiCIIg0RZxATx4hIgkhszRBEAQRV2gCPZHMkBAiCIIg4gqlxohkhoQQQRAEEVfE1BhFhIgkhIQQQRAEEVeojxCRzJAQIgiCIOKK3yNEqTEi+SAhRBAEQcQVSo0RyQwJIYIgCCKuUENFIpkhIUQQBEHEFb9HiFJjRPJBQoggCIKIK0aaPk8kMSSECIIgiLhCqTEimSEhRBAEQcQVJoS6KTVGJCEkhAiCIIi4Elg1xvM8vt5zDE3t3YlcFkEAICFEEARBxJnAPkKb61tx7V/W4v6/f5fIZREEABJCBEEQRJwJ7Cy960g7AKC2sS1hayIIBgkhgiAIIq4EpsaOtDkAAE3tDjjJQE0kGBJCBEEQRFwJnD7f2CZ4g3geaLSRT4hILCSECIIgiLji9wj5IkIS8XOotSshayIIBgkhgiAIIq6IqTGfR+iIpFqsgYQQkWBICBEEQRBxpUdqzOYQ7yMhRCQaEkIEQRBEXJGapV0eL5o7JULIRkKISCwkhAiCIIi4IvUIHW13gOf99x1qJbM0kVhICBEEQRBxhaXGPF6+RyqMUmNEoiEhRBAEQcQVlhoDgP3NdgBAfrYegCCEeGmIiCD6GBJCBEEQRFwx6PynmgMtghA6tcoKALA7PbB1uRKxLIIAQEKIIAiCiDNaDQe9lgPgF0IDCnNQlGsAQL2EiMRCQoggCIKIOyw9tr+5EwBQYjain9UEAGggwzSRQEgIEQRBEHGHGaYPtAjRnzJzFipEIUQRISJxkBAiCIIg4g4TQsc6hB5CpRIhRKkxIpGQECIIgiDijlGvlf1OQohIFkgIEQRBEHHHqJOfbsosWehnzQJAqTEisZAQIgiCIOKOVAjlGLTINerII0QkBSSECIIgiLgjbapYahEiQUwINbU74HR7E7IugiAhRBAEQcQdNm8MAErzBCFUmGOAQacBzwNH2qiEnkgMJIQIgiCIuCONCJX5IkIcx4m9hMgwTSSKlBFCLS0tmDlzJsxmM6xWK+bMmYOOjo6g2+/btw8cxyn+/P3vf+/DlRMEQRDSiFCJ2Sj+v4IM00SCSRkhNHPmTGzbtg1Lly7F4sWLsWrVKtx8881Bt6+qqsLhw4dlP48//jhyc3Nx/vnn9+HKCYIgCKlZusycJf6/wkKGaSKx6BK9ADVs374dS5Yswfr16zF27FgAwAsvvIAZM2bgueeeQ0VFRY/HaLValJWVyW77+OOPceWVVyI3N7dP1k0QBEEIyMzSUiEkpsbII0QkhpSICK1ZswZWq1UUQQAwdepUaDQarF27VtU+Nm7ciC1btmDOnDkht3M4HGhra5P9EARBEL1DGhGSCqF++RQRIhJLSgihxsZGlJSUyG7T6XQoKChAY2Ojqn289tprGDZsGCZMmBByuwULFsBisYg/VVVVUa+bIAiCEJBVjUk8QmSWJhJNQoXQ/Pnzgxqa2c+OHTt6/TxdXV145513wkaDAOChhx6CzWYTf+rr63v9/ARBEJmONDVWkuePCLEKskYbpcaIxJBQj9B9992H2bNnh9ympqYGZWVlaGpqkt3udrvR0tLSwwekxIcffgi73Y7rr78+7LZGoxFGozHsdgRBEIR6WGqM9Q5iMON0h8ONDocbucaUsK4SaURCP3HFxcUoLi4Ou9348ePR2tqKjRs3YsyYMQCA5cuXw+v1Yty4cWEf/9prr+HCCy9U9VwEQRBE7GFCSOoPAoAcow55Rh3aHW4caetGbjEVsxB9S0p4hIYNG4bp06dj7ty5WLduHVavXo077rgDV199tVgxdujQIQwdOhTr1q2TPXb37t1YtWoVfvrTnyZi6QRBEAQEwQP4+wZJYX2FjlB6jEgAKSGEAGDRokUYOnQopkyZghkzZmDixIl49dVXxftdLhdqa2tht9tlj3v99ddRWVmJadOm9fWSCYIgCB/ThpfiijGVuHXSoB73MZ/QkXYSQkTfw/E8zyd6EclMW1sbLBYLbDYbzGZzopdDEASRdtz7/hZ8tPkQ5k0fitsm9xRKBBENas/fKRMRIgiCINITNo2eBq8SiYCEEEEQBJFQWOUYCSEiEZAQIgiCIBIKa7DYSEKISAAkhAiCIIiEwkrqm9ocCV4JkYmQECIIgiASSqkkNeb1Uv0O0beQECIIgiASSnGeERwHuL08mjudiV4OkWGQECIIgiASil6rQVGur6ki+YSIPoaEEEEQBJFwmGGahBDR15AQIgiCIBKOv4SeDNNE30JCiCAIgkg4JT4hRCX0RF9DQoggCIJIOGViCT0JIaJvISFEEARBJJwyiggRCYKEEEEQBJFwSlh3aRsJIaJvISFEEARBJJwy3+DVpnYySxN9CwkhgiAIIuGU5glCqKXTCYfbk+DVEJkECSGCIAgi4Viz9TDohFMSzRwj+hISQgRBEETC4ThO0kuIfEJE30FCiCAIgkgKWHdpqhwj+hISQgRBEERSUErdpYkEQEKIIAiCSApKKTVGJAASQgRBEERSQB4hIhGQECIIgiCSglJfLyFqqkj0JSSECIIgiKSgNE8wS1NTRaIvISFEEARBJAVlkogQz/MJXg2RKZAQIgiCIJKCcosJOQYtulwebK5vTfRyiAyBhBBBEASRFBh0GkwdXgoA+M93hxO8GiJTICFEEARBJA0/HlEOQBBCXi+lx4j4Q0KIIAiCSBrOPqEYeUYdGtu6senA8UQvh8gASAgRBEEQSUOWXotzfemxxZQeI/oAEkIEQRBEUvGTkUJ67L/fH4aH0mNEnCEhRBAEQSQVEwcXIy9Lh6Z2Bzbsa0n0cog0h4QQQRAEkVQYdBqcd1IZACE95vHyqG+xo4lGbxBxQJfoBRAEQRBEID85pRwfbjyId9cdwHvrD8Dl4cFxwMxx/fHAtKGwZOsTvUQiTaCIEEEQBJF0nDm4COWWLLi9PFweHnotB54H/vbNAZzz/Ap8sL4eTrc30csk0gCOpz7mIWlra4PFYoHNZoPZbE70cgiCIDKGI23d2HusE1UF2SgzZ2Hd3hY8+s+t2NXUAQDIz9bjwpEVuHxMFUZUWhK8WiLZUHv+JiEUBhJCBEEQyYPT7cUbX+/FX7/cKxvOOnVYCX754+EYWJSTwNURyQQJoRhBQoggCCL5cHu8WL2nGf/YeBD//f4w3F4eBq0Gc86qxm2TB8GcRR6iTIeEUIwgIUQQBJHc7G5qx68Xb8eqnUcBAHlGHa4bPwA3njkQJXlZCV4dkShICMUIEkIEQRDJD8/z+Hx7E55dskP0EBl0Gtw2aRB+fs5g6LRUG5RpkBCKESSECIIgUgevl8eyHU14acVubD7QCgAYOyAfv7/6VFTmZyd2cUSfovb8TRKZIAiCSBs0Gg7nDi/FR7dNwB+uPhV5Rh027D+O8//wJRZ/15Do5RFJCAkhgiAIIu3gOA4XndoP/73rLIzqb0V7txt3vLMZD374LexOd6KXRyQRJIQIgiCItKWqIBsf3DIePz9nMDgO+GDDQfzkj19h84HjiV4akSSQECIIgiDSGr1Wg/umnYh3556BcksW6o514pKXvsaNC9dh434SRJkOCSGCIAgiIzijphCf3nUWLhtdCQ0HfFF7FJf9+Wv89M31aLU7E708IkGkjBBqaWnBzJkzYTabYbVaMWfOHHR0dIR8TGNjI2bNmoWysjLk5ORg9OjR+Mc//tFHKyYIgiCSDWu2Ac9fORLL75uMq8ZWQafh8Pn2Jlz4p9XY0diW6OURCSBlhNDMmTOxbds2LF26FIsXL8aqVatw8803h3zM9ddfj9raWvzrX//C999/j0svvRRXXnklNm/e3EerJgiCIJKRgUU5eObyU/Dvn09EVYEJB1rsuPSlr/Hf7w8nemlEH5MSfYS2b9+O4cOHY/369Rg7diwAYMmSJZgxYwYOHjyIiooKxcfl5ubiz3/+M2bNmiXeVlhYiGeeeQY//elPVT039REiCIJIb453OnHHu5uwenczAODXF52E68cPTOyiiF6TVn2E1qxZA6vVKoogAJg6dSo0Gg3Wrl0b9HETJkzA+++/j5aWFni9Xrz33nvo7u7G5MmTgz7G4XCgra1N9kMQBEGkL/k5Brx54+m4YfwAAMCj/9yGF7/YjRSIExAxICWEUGNjI0pKSmS36XQ6FBQUoLGxMejjPvjgA7hcLhQWFsJoNOKWW27Bxx9/jMGDBwd9zIIFC2CxWMSfqqqqmB0HQRAEkZzotBr86sKTcOeUIQCA335Wi6c/3UFiKANIqBCaP38+OI4L+bNjx46o9//II4+gtbUVn3/+OTZs2IB7770XV155Jb7//vugj3nooYdgs9nEn/r6+qifnyAIgkgdOI7DveeegF/+eBgA4JVVdXjz632JXRQRd3SJfPL77rsPs2fPDrlNTU0NysrK0NTUJLvd7XajpaUFZWVlio/bs2cP/vSnP2Hr1q046aSTAAAjR47El19+iRdffBEvv/yy4uOMRiOMRmPkB0MQBEGkBT89qwY8Dzz53+34zX+2Y0SlFWMG5Cd6WUScSKgQKi4uRnFxcdjtxo8fj9bWVmzcuBFjxowBACxfvhxerxfjxo1TfIzdbgcAaDTyoJdWq4XX6+3lygmCIIh05qdnVWPLwVb857vDuH3RJiy+cyKKcukiOR1JCY/QsGHDMH36dMydOxfr1q3D6tWrcccdd+Dqq68WK8YOHTqEoUOHYt26dQCAoUOHYvDgwbjllluwbt067NmzB88//zyWLl2Kiy++OIFHQxAEQSQ7HMfhmctOwaDiHDS2dePOdzfD7aGL6HQkJYQQACxatAhDhw7FlClTMGPGDEycOBGvvvqqeL/L5UJtba0YCdLr9fjvf/+L4uJiXHDBBTjllFPw1ltv4c0338SMGTMSdRgEQRBEipBr1OHl68Yg26DF13ua8evFP5B5Og1JiT5CiYT6CBEEQWQ2n35/GLct2gQA+OWPh+GnZ9UkeEWEGtKqjxBBEARBJIrzR5TjFzOGAhAM1Eu2UvfpdIKEEEEQBEGEYe5ZNbjujP7geeCu97Zg3d6WRC+JiBEkhAiCIAgiDBzH4VcXnIRzhpbA4fbihtfX4evdxxK9LCIGkBAiCIIgCBXotBq8NHM0zj6hGF0uD258Yz1W7jya6GURvYSEEEEQBEGoJEuvxauzxmDqMCEyNPfNDSSGUhwSQgRBEAQRAVl6LV6aOQbnn1wGp8eLn/1tI7YfpgHdqQoJIYIgCIKIEINOgz9cPQrjawrR6fRgzhvr0dTWnehlEVFAQoggCIIgosCg0+Dl68agpjgHDbZuzHlzA+xOd6KXRUQICSGCIAiCiBJLth4LZ5+GghwDvj9kw30ffEvdp1MMEkIEQRAE0QsGFObg1VljoNdy+HRrI15asSfRSyIigIQQQRAEQfSSsQML8PiFJwMAnvtfLVbUNiV4RYRaSAgRBEEQRAy4dlx/XHO60H36znc3Y9+xzkQviVABCSGCIAiCiBG/unA4RvW3oq3bjdkL1+EIVZIlPSSECIIgCCJGGHVavHzdGFTmm7Cv2Y5rXv2GyuqTHBJCBEEQBBFDSs1ZeHfuGehnNaHuWCeu/etaHG13JHpZRBBICBEEQRBEjKkqyMa7c89AuSULu5s6cMlLq/FNXXOil0UoQEKIIAiCIOJA/0JBDFXmm3DweBeu+cs3+PW/f0C3y5PopRESSAgRBEEQRJwYWJSDT+86C9ecXgWeB15fvRfn/X4VPv/hCDVeTBJICBEEQRBEHMnL0mPBpadg4Y2nodRsxP5mO3761gbcsHA9fmhoI0GUYDie3oGQtLW1wWKxwGazwWw2J3o5BEEQRArT3u3Cn77Yjde/2guXRzj9FucZMa66ANVFOWhqc6CxrRscB1w6uhLnn1wGvZZiFtGg9vxNQigMJIQIgiCIWLP3WCee+XQHltc2wen2Bt2uwpKF68YPwPiaQgwrNyNLr0WX04PtjW3Y2diO5k4nWu1OdDjcGFWVjwtPrUCWXtuHR5K8kBCKESSECIIgiHjR7fLg2/pWfFPXgqb2bpSas1BmzsKh1i4sWrsfxzqc4rYaDii3mHDY1gVvkDN3YY4BM8f1x4TBRcg16pBt0MLt5WHrcqHV7oJJr8XJ/cywZhsAAE1t3VhT14wupwcXjKxAjlEXu4Oz2YD2dqCysud9Bw8CeXmAxRK75wuAhFCMICFEEARBJIJulwf/2tKA/3x/GNsabDJRVJRrwLByM8rMWcjPMUCr4fCvLQ041Nqlat+V+SYYtBrUScaAlFuy8NgFw3HeSWXgOA5OtxcNrV3Qajhk6bXINmjVCyWbDZg+HWhqAlasAKqq/PfV1wOTJwMlJcCSJXETQySEYgQJIYIgCCLR8DyPpnYH9jfbMbAwGyXmrB7buD1e/O+HI3h33QEcau2C3eFBp8MNnZaDxaSHxaRHa5cL+5vt4mM4Dhhebkar3SWKqFOrrLA73ag72gl3QOipn9WEUyotGFllxfiaQozoZ4FGw/Vc8MGDwKRJQF0dUFPjF0NMBLHbV66Et6IfeABapf30AhJCMYKEEEEQBJFO2Lpc2NZgg8Plxej++bBk69Hl9OClFbvxyso6OD1+z1KWXgOeBxxBfExFuQZMOqEE+dl6tNidaOl04ninE82dTrS0O5DV2Ybhh3dhuKMFg6+6AMUvPI/iPTvgquqP9Y88h3XHPVi/7zhevHY0Jg4piulxkhCKESSECIIgiExh37FOfLX7GPrlm3BiaR7KLVngOA5eL492hxs/NLTh24Ot2Lj/ONbsaUaHwx2T571ryhDcc+4JMdkXg4RQjCAhRBAEQRA9cbq92LCvBV/uPgaPl0d+tgGFOQYU5BhQkGtAQbYB7d1u/PDlJmx7/QPsyy/HsRwrjvUfDK9ej1Or8jGuugCnVxdgeIU55m0CSAjFCBJCBEEQBBElUk8QQ+oZiiNqz9/UpYkgCIIgiNgTaIxevVr4t65OuL2+PtErBEBCiCAIgiCIWHPwoFwErVgBTJgg/CsVQwcPJnadAGLYOYkgCIIgCAJCs8SSEuH/0jRYVZXwO+sjlJeXoAX6ISFEEARBEERssViEZolKnaWrqoCVK+PeWVotJIQIgiAIgog9FktwoaM0diNBkEeIIAiCIIiMhYQQQRAEQRAZCwkhgiAIgiAyFhJCBEEQBEFkLCSECIIgCILIWEgIEQRBEASRsZAQIgiCIAgiYyEhRBAEQRBExkJCiCAIgiCIjIU6S4eB53kAQFtbW4JXQhAEQRCEWth5m53Hg0FCKAzt7e0AgCo2MI4gCIIgiJShvb0dlhAzzTg+nFTKcLxeLxoaGpCXlweO42K237a2NlRVVaG+vh5mszlm+00FMvXY6bjpuDOBTD1uIHOPPVmPm+d5tLe3o6KiAhpNcCcQRYTCoNFoUBnH4XBmszmpPjh9SaYeOx13ZkHHnXlk6rEn43GHigQxyCxNEARBEETGQkKIIAiCIIiMhYRQgjAajXjsscdgNBoTvZQ+J1OPnY6bjjsTyNTjBjL32FP9uMksTRAEQRBExkIRIYIgCIIgMhYSQgRBEARBZCwkhAiCIAiCyFhICCWIF198EQMHDkRWVhbGjRuHdevWJXpJMWXBggU47bTTkJeXh5KSElx88cWora2VbdPd3Y3bb78dhYWFyM3NxWWXXYYjR44kaMXx4emnnwbHcbj77rvF29L1uA8dOoTrrrsOhYWFMJlMGDFiBDZs2CDez/M8Hn30UZSXl8NkMmHq1KnYtWtXAlfcezweDx555BFUV1fDZDJh0KBBeOKJJ2Qt/dPluFetWoULLrgAFRUV4DgOn3zyiex+NcfZ0tKCmTNnwmw2w2q1Ys6cOejo6OjDo4icUMftcrkwb948jBgxAjk5OaioqMD111+PhoYG2T7S7bgDufXWW8FxHH7/+9/Lbk+V4yYhlADef/993HvvvXjsscewadMmjBw5Eueddx6ampoSvbSYsXLlStx+++345ptvsHTpUrhcLkybNg2dnZ3iNvfccw/+/e9/4+9//ztWrlyJhoYGXHrppQlcdWxZv349XnnlFZxyyimy29PxuI8fP44zzzwTer0en376KX744Qc8//zzyM/PF7d59tln8cc//hEvv/wy1q5di5ycHJx33nno7u5O4Mp7xzPPPIM///nP+NOf/oTt27fjmWeewbPPPosXXnhB3CZdjruzsxMjR47Eiy++qHi/muOcOXMmtm3bhqVLl2Lx4sVYtWoVbr755r46hKgIddx2ux2bNm3CI488gk2bNuGjjz5CbW0tLrzwQtl26XbcUj7++GN88803qKio6HFfyhw3T/Q5p59+On/77beLv3s8Hr6iooJfsGBBAlcVX5qamngA/MqVK3me5/nW1lZer9fzf//738Vttm/fzgPg16xZk6hlxoz29nZ+yJAh/NKlS/lJkybxd911F8/z6Xvc8+bN4ydOnBj0fq/Xy5eVlfG//e1vxdtaW1t5o9HIv/vuu32xxLjw4x//mL/ppptkt1166aX8zJkzeZ5P3+MGwH/88cfi72qO84cffuAB8OvXrxe3+fTTT3mO4/hDhw712dp7Q+BxK7Fu3ToeAL9//36e59P7uA8ePMj369eP37p1Kz9gwAD+//7v/8T7Uum4KSLUxzidTmzcuBFTp04Vb9NoNJg6dSrWrFmTwJXFF5vNBgAoKCgAAGzcuBEul0v2OgwdOhT9+/dPi9fh9ttvx49//GPZ8QHpe9z/+te/MHbsWFxxxRUoKSnBqFGj8Je//EW8f+/evWhsbJQdt8Viwbhx41L6uCdMmIBly5Zh586dAIBvv/0WX331Fc4//3wA6Xvcgag5zjVr1sBqtWLs2LHiNlOnToVGo8HatWv7fM3xwmazgeM4WK1WAOl73F6vF7NmzcIDDzyAk046qcf9qXTcNGusjzl27Bg8Hg9KS0tlt5eWlmLHjh0JWlV88Xq9uPvuu3HmmWfi5JNPBgA0NjbCYDCIXxaM0tJSNDY2JmCVseO9997Dpk2bsH79+h73petx19XV4c9//jPuvfde/OIXv8D69etx5513wmAw4IYbbhCPTelzn8rHPX/+fLS1tWHo0KHQarXweDx48sknMXPmTABI2+MORM1xNjY2oqSkRHa/TqdDQUFB2rwW3d3dmDdvHq655hpx5la6HvczzzwDnU6HO++8U/H+VDpuEkJE3Ln99tuxdetWfPXVV4leStypr6/HXXfdhaVLlyIrKyvRy+kzvF4vxo4di6eeegoAMGrUKGzduhUvv/wybrjhhgSvLn588MEHWLRoEd555x2cdNJJ2LJlC+6++25UVFSk9XETPXG5XLjyyivB8zz+/Oc/J3o5cWXjxo34wx/+gE2bNoHjuEQvp9dQaqyPKSoqglar7VEldOTIEZSVlSVoVfHjjjvuwOLFi/HFF1+gsrJSvL2srAxOpxOtra2y7VP9ddi4cSOampowevRo6HQ66HQ6rFy5En/84x+h0+lQWlqalsddXl6O4cOHy24bNmwYDhw4AADisaXb5/6BBx7A/PnzcfXVV2PEiBGYNWsW7rnnHixYsABA+h53IGqOs6ysrEdBiNvtRktLS8q/FkwE7d+/H0uXLpVNYE/H4/7yyy/R1NSE/v37i99z+/fvx3333YeBAwcCSK3jJiHUxxgMBowZMwbLli0Tb/N6vVi2bBnGjx+fwJXFFp7ncccdd+Djjz/G8uXLUV1dLbt/zJgx0Ov1stehtrYWBw4cSOnXYcqUKfj++++xZcsW8Wfs2LGYOXOm+P90PO4zzzyzR3uEnTt3YsCAAQCA6upqlJWVyY67ra0Na9euTenjttvt0GjkX6NarRZerxdA+h53IGqOc/z48WhtbcXGjRvFbZYvXw6v14tx48b1+ZpjBRNBu3btwueff47CwkLZ/el43LNmzcJ3330n+56rqKjAAw88gM8++wxAih13ot3amch7773HG41G/o033uB/+OEH/uabb+atVivf2NiY6KXFjNtuu423WCz8ihUr+MOHD4s/drtd3ObWW2/l+/fvzy9fvpzfsGEDP378eH78+PEJXHV8kFaN8Xx6Hve6det4nU7HP/nkk/yuXbv4RYsW8dnZ2fzf/vY3cZunn36at1qt/D//+U/+u+++4y+66CK+urqa7+rqSuDKe8cNN9zA9+vXj1+8eDG/d+9e/qOPPuKLior4Bx98UNwmXY67vb2d37x5M79582YeAP+73/2O37x5s1gdpeY4p0+fzo8aNYpfu3Yt/9VXX/FDhgzhr7nmmkQdkipCHbfT6eQvvPBCvrKykt+yZYvsu87hcIj7SLfjViKwaoznU+e4SQgliBdeeIHv378/bzAY+NNPP53/5ptvEr2kmAJA8WfhwoXiNl1dXfzPfvYzPj8/n8/OzuYvueQS/vDhw4lbdJwIFELpetz//ve/+ZNPPpk3Go380KFD+VdffVV2v9fr5R955BG+tLSUNxqN/JQpU/ja2toErTY2tLW18XfddRffv39/Pisri6+pqeEffvhh2UkwXY77iy++UPybvuGGG3ieV3eczc3N/DXXXMPn5ubyZrOZv/HGG/n29vYEHI16Qh333r17g37XffHFF+I+0u24lVASQqly3DR9niAIgiCIjIU8QgRBEARBZCwkhAiCIAiCyFhICBEEQRAEkbGQECIIgiAIImMhIUQQBEEQRMZCQoggCIIgiIyFhBBBEARBEBkLCSGCIAiCIDIWEkIEQRAEQWQsJIQIgkgpZs+ejYsvvjjRyyAIIk0gIUQQBEEQRMZCQoggiJRl8uTJ+PnPf467774b+fn5KC0txV/+8hd0dnbixhtvRF5eHgYPHoxPP/1UfIzH48GcOXNQXV0Nk8mEE088EX/4wx9k+3W73bjzzjthtVpRWFiIefPm4YYbbpBForxeLxYsWCDuZ+TIkfjwww/76tAJgogRJIQIgkhp3nzzTRQVFWHdunX4+c9/jttuuw1XXHEFJkyYgE2bNmHatGmYNWsW7HY7AEHAVFZW4u9//zt++OEHPProo/jFL36BDz74QNznM888g0WLFmHhwoVYvXo12tra8Mknn8ied8GCBXjrrbfw8ssvY9u2bbjnnntw3XXXYeXKlX15+ARB9BKaPk8QREoxe/ZstLa24pNPPsHkyZPh8Xjw5ZdfAhCiPRaLBZdeeineeustAEBjYyPKy8uxZs0anHHGGYr7vOOOO9DY2ChGdMrKynD//ffj/vvvF/dbU1ODUaNG4ZNPPoHD4UBBQQE+//xzjB8/XtzPT3/6U9jtdrzzzjvxfAkIgoghukQvgCAIojeccsop4v+1Wi0KCwsxYsQI8bbS0lIAQFNTk3jbiy++iNdffx0HDhxAV1cXnE4nTj31VACAzWbDkSNHcPrpp8v2O2bMGHi9XgDA7t27Ybfbce6558rW4nQ6MWrUqJgfI0EQ8YOEEEEQKY1er5f9znGc7DaO4wBAFDHvvfce7r//fjz//PMYP3488vLy8Nvf/hZr165V/ZwdHR0AgP/85z/o16+f7D6j0RjVcRAEkRhICBEEkVGsXr0aEyZMwM9+9jPxtj179oj/t1gsKC0txfr163H22WcDEFJjmzZtEqNGw4cPh9FoxIEDBzBp0qQ+XT9BELGFhBBBEBnFkCFD8NZbb+Gzzz5DdXU13n77baxfvx7V1dXiNj//+c+xYMECDB48GEOHDsULL7yA48ePi9GlvLw83H///bjnnnvg9XoxceJE2Gw2rF69GmazGTfccEOiDo8giAghIUQQREZxyy23YPPmzbjqqqvAcRyuueYa/OxnP5OV2M+bNw+NjY24/vrrodVqcfPNN+O8886DVqsVt3niiSdQXFyMBQsWoK6uDlarFaNHj8YvfvGLRBwWQRBRQlVjBEEQYfB6vRg2bBiuvPJKPPHEE4leDkEQMYQiQgRBEAHs378f//vf/zBp0iQ4HA786U9/wt69e3HttdcmemkEQcQYaqhIEAQRgEajwRtvvIHTTjsNZ555Jr7//nt8/vnnGDZsWKKXRhBEjKHUGEEQBEEQGQtFhAiCIAiCyFhICBEEQRAEkbGQECIIgiAIImMhIUQQBEEQRMZCQoggCIIgiIyFhBBBEARBEBkLCSGCIAiCIDIWEkIEQRAEQWQsJIQIgiAIgshY/h+6rpmmxGqdlQAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -429,17 +394,33 @@
     "\n",
     "ax.plot(energies)\n",
     "ax.scatter(\n",
-    "    selected_indices, selection_energies, marker=\"x\", color=\"red\", label=\"selection\"\n",
+    "    selected_indices[0], selection_energies, marker=\"x\", color=\"red\", label=\"selection\"\n",
     ")\n",
     "ax.set_ylabel(\"Energy / eV\")\n",
     "ax.set_xlabel(\"Image\")\n",
     "ax.legend()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!rm -rf project config_full.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "apax311",
+   "display_name": "new_defaults",
    "language": "python",
    "name": "python3"
   },
@@ -453,7 +434,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.10"
   }
  },
  "nbformat": 4,
diff --git a/tests/regression_tests/apax_config.yaml b/tests/regression_tests/apax_config.yaml
index 9021702c..71971c1a 100644
--- a/tests/regression_tests/apax_config.yaml
+++ b/tests/regression_tests/apax_config.yaml
@@ -10,7 +10,7 @@ data:
   n_train: 1000
   n_valid: 100
 
-  batch_size: 32
+  batch_size: 4
   valid_batch_size: 100
 
   shift_method: "per_element_regression_shift"
@@ -22,22 +22,22 @@ data:
 model:
   name: gmnn
   basis:
-    name: gaussian
-    n_basis: 7
+    name: bessel
+    n_basis: 16
     r_max: 6.5
-    r_min: 0.5
+
   n_radial: 5
-  nn: [512, 512]
+  nn: [256, 256]
 
   calc_stress: false
   empirical_corrections:
     - name: exponential
       r_max: 2.0
 
-  b_init: normal
+  b_init: zeros
   descriptor_dtype: fp32
   readout_dtype: fp32
-  scale_shift_dtype: fp32
+  scale_shift_dtype: fp64
 
 metrics:
   - name: energy
@@ -54,15 +54,15 @@ metrics:
 
 loss:
   - name: energy
-    atoms_exponent: 2
+    atoms_exponent: 1
     weight: 1.0
   - name: forces
     atoms_exponent: 1
-    weight: 8.0
-  - loss_type: cosine_sim
-    atoms_exponent: 1
-    name: forces
-    weight: 0.1
+    weight: 4.0
+  # - loss_type: cosine_sim
+  #   atoms_exponent: 1
+  #   name: forces
+  #   weight: 0.1
   # - loss_type: structures
   #   name: stress
   #   weight: 1.0
@@ -70,11 +70,13 @@ loss:
 optimizer:
   name: adam
   kwargs: {}
-  emb_lr: 0.02
-  nn_lr: 0.03
+  emb_lr: 0.01
+  nn_lr: 0.01
   scale_lr: 0.001
-  shift_lr: 0.05
+  shift_lr: 0.03
   zbl_lr: 0.001
+  schedule:
+    name: linear
 
 callbacks:
   - name: csv
diff --git a/tests/regression_tests/test_apax_training.py b/tests/regression_tests/test_apax_training.py
index 2615f78d..895eda9e 100644
--- a/tests/regression_tests/test_apax_training.py
+++ b/tests/regression_tests/test_apax_training.py
@@ -39,13 +39,14 @@ def test_regression_model_training(get_md22_stachyose, get_tmp_path):
     current_metrics = load_csv(working_dir / "test/log.csv")
 
     comparison_metrics = {
-        "val_energy_mae": 0.24696787788040334,
-        "val_forces_mae": 0.09672525137916232,
-        "val_forces_mse": 0.017160819058234304,
-        "val_loss": 0.45499257304743396,
+        "val_energy_mae": 0.075,
+        "val_forces_mae": 0.045,
+        "val_forces_mse": 0.004,
+        "val_loss": 0.045,
     }
 
     for key in comparison_metrics.keys():
-        assert (
-            abs((np.array(current_metrics[key])[-1] / comparison_metrics[key]) - 1) < 1e-3
-        )
+        print((np.array(current_metrics[key])[-1]))
+
+    for key in comparison_metrics.keys():
+        assert abs((np.array(current_metrics[key])[-1] - comparison_metrics[key])) < 0.01