From 95a997204639a02bab967699d2cb28817307b07f Mon Sep 17 00:00:00 2001 From: miketynes Date: Fri, 21 Aug 2026 19:24:57 +0000 Subject: [PATCH 01/25] add fairchem/uma support --- 3_cascade/run_reference_dynamics.py | 31 ++++++++++++---- cascade/calculator.py | 56 ++++++++++++++++++++++++++++- pyproject.toml | 7 ++++ 3 files changed, 86 insertions(+), 8 deletions(-) diff --git a/3_cascade/run_reference_dynamics.py b/3_cascade/run_reference_dynamics.py index 08baaf3..5716a8e 100644 --- a/3_cascade/run_reference_dynamics.py +++ b/3_cascade/run_reference_dynamics.py @@ -13,9 +13,7 @@ import os import warnings from concurrent.futures import as_completed -from functools import partial -from mace.calculators import mace_mp from parsl.config import Config from parsl.executors import HighThroughputExecutor from parsl.providers import LocalProvider @@ -41,11 +39,28 @@ def parse_args() -> argparse.Namespace: default=10, help='Number of steps to run per trajectory' ) + parser.add_argument( + '--calc-type', + type=str, + choices=['mace', 'fairchem'], + default='mace', + help='Which reference calculator family to use' + ) parser.add_argument( '--calc-model', type=str, default='medium', - help='MACE-MP model size for the reference calculator' + help='For --calc-type=mace, a MACE-MP model size (e.g. "medium") or path to a MACE ' + 'checkpoint. For --calc-type=fairchem, the path to a FairChem .pt checkpoint.' + ) + parser.add_argument( + '--calc-task', + type=str, + default=None, + help='FairChem task name selecting the model head (e.g. "omol", "omat", "oc20", ' + '"odac", "omc"), ignored for --calc-type=mace. Only needed for --calc-type=fairchem ' + 'if the checkpoint supports more than one task; single-task checkpoints infer it ' + 'automatically.' ) parser.add_argument( '--device', @@ -88,7 +103,9 @@ def run_reference_trajectory( run_id: str, db_url: str, target_length: int, + calc_type: str, calc_model: str, + calc_task: str | None, device: str, log_level: str, log_interval: int, @@ -104,9 +121,8 @@ def run_reference_trajectory( from cascade.utils import canonicalize from cascade.traj_config import get_dynamics_cls, resolve_dyn_kws, prepare_atoms_for_dynamics from cascade.model import AuditStatus - from mace.calculators import mace_mp - from functools import partial - calc_factory = partial(mace_mp, model=calc_model, device=device, default_dtype="float32") + from cascade.calculator import get_calc_factory + calc_factory = get_calc_factory(calc_type, calc_model, device, calc_task) is_cuda = torch.cuda.is_available() and 'cuda' in device logging.basicConfig(level=log_level) @@ -229,7 +245,8 @@ def main(): futures = [ pool.submit( run_reference_trajectory, - traj_id, cfg, run_id, args.db_url, args.target_length, args.calc_model, args.device, args.log_level, args.log_interval, + traj_id, cfg, run_id, args.db_url, args.target_length, + args.calc_type, args.calc_model, args.calc_task, args.device, args.log_level, args.log_interval, ) for traj_id, cfg in enumerate(init_configs) ] diff --git a/cascade/calculator.py b/cascade/calculator.py index ef087c9..3689e77 100644 --- a/cascade/calculator.py +++ b/cascade/calculator.py @@ -1,5 +1,6 @@ """Utilities for employing ASE calculators""" -from typing import List +from typing import Callable, List +from functools import partial from pathlib import Path from string import Template from hashlib import sha256 @@ -14,6 +15,59 @@ _file_dir = Path(__file__).parent / 'files' +def get_calc_factory( + calc_type: str, + calc_model: str, + device: str, + calc_task: str | None = None, +) -> Callable[[], Calculator]: + """Build a zero-argument factory for a reference MLFF calculator + + Imports for each ``calc_type`` are deferred until that branch runs, so + selecting one calculator type does not require the packages for the others + to be installed. + + Args: + calc_type: Which calculator family to use (``mace`` or ``fairchem``) + calc_model: For ``mace``, a MACE-MP model size (e.g. ``medium``) or path + to a MACE checkpoint. For ``fairchem``, the path to a FairChem + ``.pt`` checkpoint. + device: Device to run the calculator on (e.g. ``cpu``, ``cuda``) + calc_task: FairChem task name selecting the model head (e.g. ``omol``, + ``omat``, ``oc20``, ``odac``, ``omc``), ignored for ``mace``. Only + required for ``fairchem`` if the checkpoint supports more than one + task; single-task checkpoints infer it automatically. + Returns: + A zero-argument callable that returns a new Calculator instance + """ + # torch>=2.6 defaults to weights_only=True, which rejects both MACE's and FairChem's + # checkpoints. See https://github.com/ACEsuit/mace/issues/555. + os.environ.setdefault('TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD', '1') + + if calc_type == 'mace': + from mace.calculators import mace_mp + return partial(mace_mp, model=calc_model, device=device, default_dtype='float32') + elif calc_type == 'fairchem': + from fairchem.core.calculate.ase_calculator import FAIRChemCalculator + + def build_fairchem_calc(): + # FAIRChemCalculator only accepts bare "cpu"/"cuda" (unlike mace_mp), and + # resolves "cuda" via torch.cuda.current_device() - so an indexed device + # (e.g. "cuda:1") has to select the device explicitly first, or it'd silently + # fall back to whichever device is current (usually index 0). + if device.startswith('cuda:'): + import torch + torch.cuda.set_device(int(device.split(':', 1)[1])) + return FAIRChemCalculator.from_model_checkpoint( + name_or_path=calc_model, + task_name=calc_task, + device='cuda' if device.startswith('cuda') else device, + ) + return build_fairchem_calc + else: + raise ValueError(f'Unknown calc_type: {calc_type!r}') + + def create_run_hash(atoms: Atoms, **kwargs) -> str: """Generate a unique has for a certain simulation diff --git a/pyproject.toml b/pyproject.toml index 5cd67a9..59c5a5c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,6 +52,13 @@ mace = [ 'mace-torch', 'pytorch-ignite' ] +# fairchem-core requires e3nn>=0.5, but mace-torch requires e3nn==0.4.4. UMA/eSEN models +# (used via FAIRChemCalculator) don't actually depend on e3nn at runtime, so if installing +# alongside the mace extra, force e3nn back down afterwards: pip install e3nn==0.4.4 +# See https://github.com/ACEsuit/mace/issues/555 +fairchem = [ + 'fairchem-core', +] docs = [ 'sphinx', 'pydata-sphinx-theme', From 25222293c306e89e50a5ff18b56fe36f613d51f0 Mon Sep 17 00:00:00 2001 From: miketynes Date: Fri, 21 Aug 2026 22:21:12 +0000 Subject: [PATCH 02/25] remove gpu monitoring from reference dynamics --- 3_cascade/run_reference_dynamics.sh | 22 +++------------------- 1 file changed, 3 insertions(+), 19 deletions(-) diff --git a/3_cascade/run_reference_dynamics.sh b/3_cascade/run_reference_dynamics.sh index 61b1522..fd62493 100644 --- a/3_cascade/run_reference_dynamics.sh +++ b/3_cascade/run_reference_dynamics.sh @@ -8,28 +8,12 @@ conda activate cascade source "${SLURM_SUBMIT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/env_setup.sh" -JOB_TAG="${SLURM_JOB_ID:-$(date +%Y%m%d-%H%M%S)}" -nvidia-smi --query-gpu=timestamp,utilization.gpu,temperature.gpu,power.draw,memory.used \ - --format=csv -l 5 >> "gpu_mon.${JOB_TAG}.csv" & -GPU_MON_PID=$! -vmstat -SM -t 5 >> "vmstat.${JOB_TAG}.log" & -VMSTAT_PID=$! -# Postgres connection count over time - catches a session/connection leak in -# TrajectoryDB -(while true; do - echo "$(date +%s) $(ss -tn state established '( dport = :5432 or sport = :5432 )' | wc -l)" - sleep 5 -done) >> "pg_conns.${JOB_TAG}.log" & -PG_CONN_PID=$! - -trap 'kill $GPU_MON_PID $VMSTAT_PID $PG_CONN_PID 2>/dev/null' EXIT - python run_reference_dynamics.py \ - --init-config-json init_config_mof_crystalline_200_300K.json \ + --init-config-json init_config_mof_crystalline_1000K.json \ --target-length 10000 \ --log-interval 100 \ + --calc-type fairchem \ + --calc-model ../1_ml-potential/uma/uma_omat_ft_mofoff_r2scan.pt \ --device cuda:0 \ --log-level DEBUG \ --max-workers 1 > "reference_run.${JOB_TAG}.log" - -kill $GPU_MON_PID $VMSTAT_PID $PG_CONN_PID 2>/dev/null From 63b92365db9f4f7455216238d5c60ffd5df1ec2d Mon Sep 17 00:00:00 2001 From: miketynes Date: Fri, 21 Aug 2026 22:27:13 +0000 Subject: [PATCH 03/25] support fairchem in run_cascade_academy.py --- 3_cascade/run_cascade_academy.py | 25 ++++++++++++++-- cascade/agents/task.py | 3 +- cascade/calculator.py | 50 +++++++++++++++++--------------- 3 files changed, 51 insertions(+), 27 deletions(-) diff --git a/3_cascade/run_cascade_academy.py b/3_cascade/run_cascade_academy.py index 5484364..d05be8e 100644 --- a/3_cascade/run_cascade_academy.py +++ b/3_cascade/run_cascade_academy.py @@ -49,6 +49,7 @@ from cascade.learning.mace import MACEInterface from cascade.learning.finetuning import MultiHeadConfig from cascade.agents.db_orm import TrajectoryDB +from cascade.calculator import get_calc_factory from cascade.agents.task import ( random_audit, uq_threshold_audit, @@ -243,10 +244,28 @@ def parse_args() -> argparse.Namespace: help='Learner to use' ) parser.add_argument( - '--calc', + '--calc-type', type=str, + choices=['mace', 'fairchem'], default='mace', - help='Calculator to use' + help='Which reference calculator family the Labeler uses to compute ground-truth ' + 'energies/forces/stress for sampled frames' + ) + parser.add_argument( + '--calc-model', + type=str, + default='medium', + help='For --calc-type=mace, a MACE-MP model size (e.g. "medium") or path to a MACE ' + 'checkpoint. For --calc-type=fairchem, the path to a FairChem .pt checkpoint.' + ) + parser.add_argument( + '--calc-task', + type=str, + default=None, + help='FairChem task name selecting the model head (e.g. "omol", "omat", "oc20", ' + '"odac", "omc"), ignored for --calc-type=mace. Only needed for --calc-type=fairchem ' + 'if the checkpoint supports more than one task; single-task checkpoints infer it ' + 'automatically.' ) parser.add_argument( '--db-url', @@ -492,7 +511,7 @@ async def main(): db_url=args.db_url, executor=pool, label_task=label_frame, - calc_factory=partial(mace_mp, model='medium', device=args.device_label, default_dtype="float32"), + calc_factory=get_calc_factory(args.calc_type, args.calc_model, args.device_label, args.calc_task), error_fn=max_force_error, ) if use_controller: diff --git a/cascade/agents/task.py b/cascade/agents/task.py index c950731..d2429f8 100644 --- a/cascade/agents/task.py +++ b/cascade/agents/task.py @@ -319,11 +319,12 @@ def label_noop(spec: TrainingFrame, calc_factory: Callable[..., Calculator]) -> def label_frame(frame: TrainingFrame, calc_factory: Callable[..., Calculator]) -> TrainingFrame: """runs the specified calculator on the atoms""" + from ase.calculators.calculator import all_changes # required by some calcs (e.g. FairChemCalculator) from cascade.utils import canonicalize calc = calc_factory() atoms_labeled = frame.atoms.copy() atoms_labeled.calc = calc - calc.calculate(atoms_labeled) + calc.calculate(atoms_labeled, properties=calc.implemented_properties, system_changes=all_changes) frame.atoms_labeled = canonicalize(atoms_labeled) return frame diff --git a/cascade/calculator.py b/cascade/calculator.py index 3689e77..c46faaf 100644 --- a/cascade/calculator.py +++ b/cascade/calculator.py @@ -15,6 +15,29 @@ _file_dir = Path(__file__).parent / 'files' +def _build_mace_calc(calc_model: str, device: str) -> Calculator: + # See https://github.com/ACEsuit/mace/issues/555. + os.environ.setdefault('TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD', '1') + from mace.calculators import mace_mp + return mace_mp(model=calc_model, device=device, default_dtype='float32') + + +def _build_fairchem_calc(calc_model: str, calc_task: str | None, device: str) -> Calculator: + # See https://github.com/ACEsuit/mace/issues/555. + os.environ.setdefault('TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD', '1') + from fairchem.core.calculate.ase_calculator import FAIRChemCalculator + # FAIRChemCalculator only accepts bare "cpu"/"cuda" (unlike mace_mp), and resolves + # "cuda" via torch.cuda.current_device() + if device.startswith('cuda:'): + import torch + torch.cuda.set_device(int(device.split(':', 1)[1])) + return FAIRChemCalculator.from_model_checkpoint( + name_or_path=calc_model, + task_name=calc_task, + device='cuda' if device.startswith('cuda') else device, + ) + + def get_calc_factory( calc_type: str, calc_model: str, @@ -25,7 +48,8 @@ def get_calc_factory( Imports for each ``calc_type`` are deferred until that branch runs, so selecting one calculator type does not require the packages for the others - to be installed. + to be installed. The returned factory is a ``functools.partial`` of a + top-level function (not a closure), can be pickled for parsl Args: calc_type: Which calculator family to use (``mace`` or ``fairchem``) @@ -40,30 +64,10 @@ def get_calc_factory( Returns: A zero-argument callable that returns a new Calculator instance """ - # torch>=2.6 defaults to weights_only=True, which rejects both MACE's and FairChem's - # checkpoints. See https://github.com/ACEsuit/mace/issues/555. - os.environ.setdefault('TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD', '1') - if calc_type == 'mace': - from mace.calculators import mace_mp - return partial(mace_mp, model=calc_model, device=device, default_dtype='float32') + return partial(_build_mace_calc, calc_model, device) elif calc_type == 'fairchem': - from fairchem.core.calculate.ase_calculator import FAIRChemCalculator - - def build_fairchem_calc(): - # FAIRChemCalculator only accepts bare "cpu"/"cuda" (unlike mace_mp), and - # resolves "cuda" via torch.cuda.current_device() - so an indexed device - # (e.g. "cuda:1") has to select the device explicitly first, or it'd silently - # fall back to whichever device is current (usually index 0). - if device.startswith('cuda:'): - import torch - torch.cuda.set_device(int(device.split(':', 1)[1])) - return FAIRChemCalculator.from_model_checkpoint( - name_or_path=calc_model, - task_name=calc_task, - device='cuda' if device.startswith('cuda') else device, - ) - return build_fairchem_calc + return partial(_build_fairchem_calc, calc_model, calc_task, device) else: raise ValueError(f'Unknown calc_type: {calc_type!r}') From 1e60b8c373b5bda169bf4f68b385d98576827b67 Mon Sep 17 00:00:00 2001 From: miketynes Date: Fri, 21 Aug 2026 22:30:19 +0000 Subject: [PATCH 04/25] only pass threshold when relevant in auditor --- cascade/agents/agents.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cascade/agents/agents.py b/cascade/agents/agents.py index 11ff684..3bba11d 100644 --- a/cascade/agents/agents.py +++ b/cascade/agents/agents.py @@ -276,7 +276,8 @@ async def audit(self, chunk: Chunk) -> AuditResult: self.logger.info(f'Submitting audit of traj {chunk.traj_id} chunk {chunk.chunk_id} attempt {chunk.attempt_ix} to executor') audit_kws = {**self.config.audit_kws} - audit_kws['threshold'] = self.thresholds.get(chunk.traj_id, self.default_threshold) + if 'threshold' in self.config.audit_kws: + audit_kws['threshold'] = self.thresholds.get(chunk.traj_id, self.default_threshold) future = self.config.executor.submit( self.audit_task, @@ -436,6 +437,7 @@ async def sample_frames( sample_kws = dict(n_frames=n_frames, reason=audit_reason) if audit_threshold is not None: # omit: some strategies have defaults we dont want to override with None + sample_kws['threshold'] = audit_threshold future = self.config.executor.submit( self.config.sample_task, chunk, From ca8c33f54b795b8253b65268fe47b4757c8638c9 Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 24 Aug 2026 16:16:00 +0000 Subject: [PATCH 05/25] add evaluate calc, evaluate mace small against uma --- 3_cascade/evaluate_calculator.py | 141 ++++++++++ 3_cascade/evaluate_calculator.sh | 17 ++ 3_cascade/evaluate_calculator_results.ipynb | 294 ++++++++++++++++++++ 3 files changed, 452 insertions(+) create mode 100644 3_cascade/evaluate_calculator.py create mode 100644 3_cascade/evaluate_calculator.sh create mode 100644 3_cascade/evaluate_calculator_results.ipynb diff --git a/3_cascade/evaluate_calculator.py b/3_cascade/evaluate_calculator.py new file mode 100644 index 0000000..00a6ad7 --- /dev/null +++ b/3_cascade/evaluate_calculator.py @@ -0,0 +1,141 @@ +"""Evaluate a calculator's energy/forces/stress predictions against ground-truth trajectories +produced by another (reference) calculator, e.g. run_reference_dynamics.py. + +Reads frames already written to the DB, and writes the true and predicted values into an extxyz file. +""" +import argparse +import logging +import os + +from ase.calculators.calculator import all_changes +from ase.io import write + +from cascade.agents.db_orm import TrajectoryDB +from cascade.calculator import get_calc_factory + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + '--run-id', + type=str, + required=True, + help='Reference run (written by e.g. run_reference_dynamics.py) to evaluate the calculator against' + ) + parser.add_argument( + '--traj-id', + type=int, + nargs='+', + default=None, + help='Trajectory ids to evaluate (defaults to all trajectories in the run)' + ) + parser.add_argument( + '--calc-type', + type=str, + choices=['mace', 'fairchem'], + default='mace', + help='Which calculator family to evaluate' + ) + parser.add_argument( + '--calc-model', + type=str, + default='small', + help='For --calc-type=mace, a MACE-MP model size (e.g. "small") or path to a MACE ' + 'checkpoint. For --calc-type=fairchem, the path to a FairChem .pt checkpoint.' + ) + parser.add_argument( + '--calc-task', + type=str, + default=None, + help='FairChem task name selecting the model head (e.g. "omol", "omat", "oc20", ' + '"odac", "omc"), ignored for --calc-type=mace. Only needed for --calc-type=fairchem ' + 'if the checkpoint supports more than one task' + ) + parser.add_argument( + '--device', + type=str, + default='cpu', + help='Device for the evaluated calculator' + ) + parser.add_argument( + '--stride', + type=int, + default=1, + help='Evaluate every Nth frame of each trajectory' + ) + parser.add_argument( + '--output', + type=str, + required=True, + help='Path to write paired true/predicted results (extxyz, appended incrementally)' + ) + parser.add_argument( + '--db-url', + type=str, + default=os.environ.get('CASCADE_DB_URL'), + help='Database URL, e.g. postgresql://ase:pw@:5432/cascade ' + '(defaults to the CASCADE_DB_URL env var)' + ) + parser.add_argument( + '--log-level', + type=str, + default='INFO', + help='Logging level' + ) + return parser.parse_args() + + +def evaluate_frame(atoms_true, calc, run_id: str, traj_id: int, frame_index: int): + """Evaluate calc on a copy of atoms_true, returning an Atoms with both the true (already + attached to atoms_true.calc) and predicted energy/forces/stress stashed side by side.""" + atoms_pred = atoms_true.copy() + atoms_pred.calc = calc + calc.calculate(atoms_pred, properties=calc.implemented_properties, system_changes=all_changes) + + results_true = atoms_true.calc.results + results_pred = atoms_pred.calc.results + + out = atoms_true.copy() + out.info['run_id'] = run_id + out.info['traj_id'] = traj_id + out.info['frame_index'] = frame_index + out.info['energy_true'] = results_true['energy'] + out.info['energy_pred'] = results_pred['energy'] + out.new_array('forces_true', results_true['forces']) + out.new_array('forces_pred', results_pred['forces']) + if 'stress' in results_true and 'stress' in results_pred: + out.info['stress_true'] = results_true['stress'] + out.info['stress_pred'] = results_pred['stress'] + return out + + +def main(): + args = parse_args() + logging.basicConfig(level=args.log_level) + logger = logging.getLogger('evaluate_calculator') + + traj_db = TrajectoryDB(args.db_url) + traj_ids = args.traj_id + if traj_ids is None: + traj_ids = [t['traj_id'] for t in traj_db.list_trajectories_in_run(args.run_id)] + logger.info(f'No --traj-id given, evaluating all {len(traj_ids)} trajectories in run {args.run_id}') + + calc_factory = get_calc_factory(args.calc_type, args.calc_model, args.device, args.calc_task) + calc = calc_factory() + + n_written = 0 + for traj_id in traj_ids: + atoms_list = traj_db.get_trajectory_atoms(args.run_id, traj_id) + logger.info(f'Evaluating traj {traj_id}: {len(atoms_list)} frames, stride={args.stride}') + for frame_index in range(0, len(atoms_list), args.stride): + out = evaluate_frame(atoms_list[frame_index], calc, args.run_id, traj_id, frame_index) + write(args.output, out, format='extxyz', append=True) + n_written += 1 + if n_written % 100 == 0: + logger.info(f'Wrote {n_written} evaluated frames so far (traj {traj_id}, frame {frame_index})') + + logger.info(f'Done. Wrote {n_written} evaluated frames to {args.output}') + + +if __name__ == '__main__': + main() diff --git a/3_cascade/evaluate_calculator.sh b/3_cascade/evaluate_calculator.sh new file mode 100644 index 0000000..2c49324 --- /dev/null +++ b/3_cascade/evaluate_calculator.sh @@ -0,0 +1,17 @@ +#!/bin/bash +#SBATCH --partition=main +#SBATCH --gres=gpu:1 +#SBATCH --exclusive + +source /home/michael/miniconda3/etc/profile.d/conda.sh +conda activate cascade + +source "${SLURM_SUBMIT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/env_setup.sh" + +python evaluate_calculator.py \ + --run-id reference-2026.08.21-19:31:10-43722e \ + --calc-type mace \ + --calc-model small \ + --device cuda:0 \ + --output "eval_mace_small_vs_uma_omat.${SLURM_JOB_ID}.xyz" \ + --log-level DEBUG > "evaluate_calculator.${SLURM_JOB_ID}.log" 2>&1 diff --git a/3_cascade/evaluate_calculator_results.ipynb b/3_cascade/evaluate_calculator_results.ipynb new file mode 100644 index 0000000..72e4acf --- /dev/null +++ b/3_cascade/evaluate_calculator_results.ipynb @@ -0,0 +1,294 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7753ddf6", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from ase.io import iread\n", + "\n", + "input_file = 'eval_mace_small_vs_uma_omat.665.xyz'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d85d9844", + "metadata": {}, + "outputs": [], + "source": [ + "rows = []\n", + "for atoms in iread(input_file):\n", + " fe = np.abs(atoms.arrays['forces_true'] - atoms.arrays['forces_pred'])\n", + " se = np.abs(atoms.info['stress_true'] - atoms.info['stress_pred'])\n", + " rows.append({\n", + " 'traj_id': atoms.info['traj_id'],\n", + " 'frame_index': atoms.info['frame_index'],\n", + " 'n_atoms': len(atoms),\n", + " 'force_mae': fe.mean(),\n", + " 'force_rmse': np.sqrt((fe ** 2).mean()),\n", + " 'force_max_abs_error': fe.max(),\n", + " 'abs_energy_error_per_atom': abs(atoms.info['energy_true'] - atoms.info['energy_pred']) / len(atoms),\n", + " 'stress_mae': se.mean(),\n", + " 'stress_rmse': np.sqrt((se ** 2).mean()),\n", + " 'stress_max_abs_error': se.max(),\n", + " })\n", + "\n", + "df = pd.DataFrame(rows)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "23210d39", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
traj_idn_framesforce_mae_eV_per_Aforce_max_abs_error_eV_per_Aabs_energy_error_per_atom_eVstress_mae_eV_per_A3stress_max_abs_error_eV_per_A3
00100010.2668751.5100791.2201900.0115290.023226
11100010.2911761.9509970.8176230.0081080.016577
22100010.3689012.1220190.8156950.0096000.020008
\n", + "
" + ], + "text/plain": [ + " traj_id n_frames force_mae_eV_per_A force_max_abs_error_eV_per_A \\\n", + "0 0 10001 0.266875 1.510079 \n", + "1 1 10001 0.291176 1.950997 \n", + "2 2 10001 0.368901 2.122019 \n", + "\n", + " abs_energy_error_per_atom_eV stress_mae_eV_per_A3 \\\n", + "0 1.220190 0.011529 \n", + "1 0.817623 0.008108 \n", + "2 0.815695 0.009600 \n", + "\n", + " stress_max_abs_error_eV_per_A3 \n", + "0 0.023226 \n", + "1 0.016577 \n", + "2 0.020008 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "table = df.groupby('traj_id').agg(\n", + " n_frames=('frame_index', 'count'),\n", + " force_mae_eV_per_A=('force_mae', 'mean'),\n", + " force_max_abs_error_eV_per_A=('force_max_abs_error', 'mean'),\n", + " abs_energy_error_per_atom_eV=('abs_energy_error_per_atom', 'mean'),\n", + " stress_mae_eV_per_A3=('stress_mae', 'mean'),\n", + " stress_max_abs_error_eV_per_A3=('stress_max_abs_error', 'mean'),\n", + ").reset_index()\n", + "table" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b1131bcf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "for traj_id, group in df.groupby('traj_id'):\n", + " ax.hist(group['force_mae'], bins=50, alpha=0.5, label=f'traj {traj_id}')\n", + "ax.set_xlabel('force MAE (eV/A)')\n", + "ax.set_ylabel('count')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dd3eeecd-b964-4060-a006-de9159d16f81", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "for traj_id, group in df.groupby('traj_id'):\n", + " ax.hist(group['force_max_abs_error'], bins=50, alpha=0.5, label=f'traj {traj_id}')\n", + "ax.set_xlabel('max abs force error (eV/A)')\n", + "ax.set_ylabel('count')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5c0d3484", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "for traj_id, group in df.groupby('traj_id'):\n", + " ax.hist(group['stress_mae'], bins=50, alpha=0.5, label=f'traj {traj_id}')\n", + "ax.set_xlabel('stress MAE (eV/A^3)')\n", + "ax.set_ylabel('count')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fa80eb57-ee9f-4369-818e-ab6be1df6f44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd81PT/x1+52b3pooOy9957b1E2CIp74wAVB/pVfipuRUFBQRAQUZmWjZS9Zymr0NLSvefd9XZ+f+SSS+6SG91ono8HtM19knySSz6f9+c9CZIkSYiIiIiIiIiI/EuQNHQHRERERERERERqE1G4EREREREREflXIQo3IiIiIiIiIv8qROFGRERERERE5F+FKNyIiIiIiIiI/KsQhRsRERERERGRfxWicCMiIiIiIiLyr0IUbkRERERERET+VcgaugMNgdlsRk5ODnx9fUEQREN3R0RERERERMQFSJJEZWUlIiMjIZEI62f+k8JNTk4OoqOjG7obIiIiIiIiItUgMzMTUVFRgp//J4UbX19fANTN8fPza+DeiIiIiIiIiLhCRUUFoqOjmXlciP+kcEObovz8/EThRkRERERE5D7DmUuJ6FAsIiIiIiIi8q9CFG5ERERERERE/lWIwo2IiIiIiIjIv4r/pM+NiIiIiEj9YTabodfrG7obIvcBcrkcUqm0xscRhRsRERERkTpDr9cjLS0NZrO5obsicp8QEBCA8PDwGuWhE4UbEREREZE6gSRJ5ObmQiqVIjo62mHSNRERkiSh0WhQUFAAAIiIiKj2sUThRkRERESkTjAajdBoNIiMjISXl1dDd0fkPsDT0xMAUFBQgNDQ0GqbqEQxWkRERESkTjCZTAAAhULRwD0RuZ+gBWGDwVDtY4jCjYiIiIhInSLW8BNxh9p4XhrcLGUwGHDt2jWoVCq0adMGoaGhDtsnJSXh3r17nG1+fn4YPHhwXXZTRERERESkWmzatAmlpaV48cUXa/3YH374IaZMmYJOnTrV+rHrgvXr1yMgIACTJk2q0/M0qHCzadMmvPfeewgJCYFMJsOlS5fw9NNPY9myZYKS24oVK7Bz50706NGD2RYbGysKNyIiIiIitcLGjRuhUqnw3HPP1crxTp06haysLIfCjUqlwpo1a3D79m3ExMTg8ccfd7rY37NnD37//XcsXry4VvpZH3Tq1Anjxo3DkCFD4O/vX2fnaVDhhiRJnDt3DsHBwQCA8+fPo3fv3hg7dizGjx8vuN+AAQOwZcuW+uqmiIiIiMh/iBMnTqCoqKjWhJs5c+ZArVYLfl5ZWYl+/frBy8sL06dPx/79+7Fs2TKcO3fOYeXrDz74APPnz6+VvDD1Rbdu3dCmTRusXLkSixYtqrPzNKhwM2fOHM7fnTp1gkwmQ0lJicP9KisrkZCQAH9/f7Rv357xrhb592EwG5BYkIjOTTpDIRWdEkVEROqWHTt24OjRo9BqtXjqqacAAAsXLsSZM2dgNpvRoUMHbNu2DXK5HB9//DF2796N7du3AwD8/f3RvXt3zJo1iyNwpKWlobS0FCNHjuQ953fffYfCwkKkpKTA19cXr776Krp164YlS5bgp59+4t3nypUruHDhAvbt28dsW7t2LcxmM1q1aoWEhASUl5dj6tSpGDhwII4ePYr4+HgoFArMnTsX7du35xyvuLgY69evR2pqKqKjozFr1izExsYyn7tynfT5u3Tpgt27d0OlUmHixIkYMmQI51yzZ8/Gl19+WafCTYM7FBcWFmLXrl3YtGkTJk2ahMGDB2Pq1KkO9zl16hQ++OADzJw5E9HR0fjzzz8dttfpdKioqOD8E7k/+OzcZ3h8/+P48PSHDd0VERGR/wDR0dEICwtDcHAw+vbti759+8Lf3x9Hjx7F4sWL8dxzzyE0NBRdu3YFADRt2pRpFxYWhk8++QQPPvgg55inTp3CwYMHBc8ZHx+PiRMnwtfXFwCVpXf69OmIj48X3OfgwYNo164dgoKCmG1Hjx7FW2+9hYULF8LPzw+VlZUYMmQIHn30Ubz11luIjIxEVlYWevfujezsbGa/5ORkdOrUCRcuXEDr1q2Rnp6Orl274ty5c0wbV66TvkfPP/88vL29YTKZMGrUKOzZs4fTbtCgQUhNTcXdu3cFr6+mNLhDcWZmJlauXImioiKkpqbi3XffdaiJmTx5Mj7//HP4+fkBAD7++GM88sgj6NSpE9q1a8e7z9KlS/Hhh+LkeD9SoaMEUY1B08A9ERERqSkkSaLKYGqQc3vKpS5F4fTo0QNt27ZFUVERo7mh0el0OHr0KMdXpGvXroygAwBPPfUUoqKicO7cOfTu3dulvqWkpGDChAmcbXFxccjLy4NarYa3t7fdPrdu3UJcXJzddrlcjqNHjzLh1JcuXcKxY8eQnJwMpVIJADhz5gz+/PNPvPbaawCAl156CbNnz8ZXX33FHCcgIACLFi3C4cOH3bpOgiBw5MgRps9FRUVYs2YNx9WkefPmAICbN28yv9c2DS7cdO/eHbt27QJAfQkDBw5EQEAAHnvsMd72Y8aM4fz9zjvv4KuvvsLu3bsFhZu3334bCxYsYP6uqKhAdHR07VyASJ0S4UNlqIz0iWzgnoiINF50Jh0kkEAulTd0VxxSZTCh/fv7G+TcN5aMgZeiZlNe//79eZ1gDx06hCNHjqCgoAAmkwlyuRw3b950WbipqqpitDY09N9VVVW8wk1lZSV8fHzsttO+OzQtW7aEXC5nBBt6W1ZWFgBAo9Hg8OHDUCgUeO6550CSJEiSRFpaGq5cueL2dfbr14/T3zZt2uDvv//mHMfT0xNSqbROrSgNbpZi0717d/Tq1QsJCQku70MQBAICApCXlyfYRqlUws/Pj/NP5P6ABNnQXRARadQYzAYM/H0ghvw5BGZSrN9UlwQEBNhte/PNNzFnzhzo9Xp07twZffv2hYeHByorK10+rp+fH0pLSznbSkpKQBCEndBDExwcbLcPADvLh0Qi4d1GJ1gsLS2FyWRCx44d0bNnT/Tq1Qu9e/fGzJkzOZocV6/T9lxSqZQ5F01lZSVMJhMTTFQXNJjmxmQyQaVScaTgqqoqpKSkoF+/fsy2q1evoqysDIMHD4bZbEZFRQXnAaPz3nTv3r0+uy9STyQWJAIAzuWdc9JSROS/Sam2FFqTlvpn1MJL3njLHHjKpbixZIzzhnV0bldxNYkcSZL48ccfsXHjRsb/xGQy4ZVXXnGrbx07dsSNGzc4265fv46WLVtyNC5sunTpwlg9akJISAgUCgXi4uLszHA0tXWdNNevXwdBEBwzV23TYMKNwWBA3759MXPmTLRv3x5lZWX45ZdfIJFIMH/+fKbdd999hzNnzuDatWswmUzo27cvZsyYgQ4dOiAjIwNff/01hgwZgunTpzfUpYjUIZcKLgEAbpXcauCeiIg0Tjxl1pWyTNLgngYOIQiixqah+iAoKAjJyckut2drL7777jtoNO75CM6ePRsvv/wyUlNT0aJFCxQWFmLz5s14+umnBfcZO3YsXnzxRaSkpKBly5ZunY+NUqnE9OnT8cUXX2Dy5MkICwsDQOXdOX78OMaNG8e0rel10hw5cgS9evVymsenJjSYWcrDwwOnTp2Cl5cXtm/fjnPnzuGRRx7BrVu30LRpU6Zdly5dmDAyuVyOM2fOwMfHBzt27EBaWhq+/vprHDp0CHJ547Y1i4iIiNQFBKxaBtGMWztMnDgRp06dwpQpU/DUU0/h5s2bvO0IgsCiRYvwzDPPYMaMGRg2bBi+//57NGnSxK3zzZs3D+PHj0ffvn0xdepUdO/eHS1btsSbb74puE+zZs0wYcIErF+/3q1z8bF8+XI0a9YM7du3x5QpUzB+/Hh06tSJ8cupreuk2bhxI1544YUa99sRBEmS/7m3oaKiAv7+/igvLxf9bxo5PTb0gN6sBwAkzUtq4N6IiDQ+1AY1+m7qCwC4MPcClFJ+M0ZDoNVqkZaWhri4OHh4eDR0d9wiLS0N58+fR0VFBcaPH4+UlBSYzWYMHTrUru2VK1dw7do1BAcHY+jQodi9ezfat2/P5JJ58cUXkZeXh61btzo859mzZ5GcnIyYmBgMHjwYEolj/cPVq1cxevRo3L59G35+fjh27JhdHw8fPgy5XI6BAwcy2w4cOAA/Pz/07duXc7xLly7hxo0bCAkJQZ8+fRAYGOjWdfKd/+rVq0hLS2PMWbt27cKiRYuQmJgImYxfi+fouXF1/haFG1G4adSsSlyF5VeWY2qrqfig/wd1co4ybRkG/TEIAHBp7qVGH3EiIsImV5WL0VtHAwDOPHwG3nL7yJqG4n4WbmqTKVOmICIiAitWrKj1Y9ORwnUVUl3bJCQkIDQ0FB07dhRsUxvCTeM3for8p6mPasJlujLmdyNphByicCMiIlJzCgsL8cILL2D//v0Ok/jVBNv8OI2d4cOH18t5GlUouIhIQ8AWoP6DikyR+xwJYR3G2f43Ig2PUqnEQw89hKtXr6J///4N3Z3/FKJwI9Ko2XBjAwBg6x3HtuqaIE4IIvczbB+bxuRvI0Llr5kzZw5atGjR0F35zyEKNyKNmq6hXQEAI2JG1Nk52MKNmARN5H6mPsy4IiL3A6JwI9KoifSmyi40968fZzkxlFbkfkN8ZkVE7BGFG5FGgdao5fV3oQfuOl2Rsg4tThQi9xt6k575vcpY1YA9ERFpPIjCjUiDk6/OR6/feuHlwy/bfUZnJr6Qd6Fe+iI6FIvcb0gl1rIColn1/qBAU4CiqqKG7sa/GjEUXKTB+TuVqhh7JPOI3WeXCy4DsJZhqAtCvULxv37/AwECPnL7KrsiIo0ZP4WYq+t+wmAyoFBTCAAI8gjiRLuJ1B7iXRVpcPjq4ZRoSzBx+8R6Ob9SqsS01tMwtfVUzipYROR+QzSrNk6uXLmC06dPA+B+R7WhKT527BgyMjJqfJyacvr0aaSmpjZ0NxhE4UakwfFV+NptW3d9He5V3GuA3oiI3F+IqQxqn8uXL+PMmTO1drzVq1fjs88+c9ouOTkZ8fHxSExMdOm4t2/fxrRp0+Dj0/Aa58zMTMyYMQNmc+MwjYrCjUiD0ymkEwCgiae1CFvPsJ6cNpNaTKqz86sNavTf1B8DNw+ExlC9KrciIg0FO8O26DNWO6xatQpffvllrR2vW7duTBI/tqaa1uKQJIlnn30WPXv2xLfffovhw4fjgQcegE6nc3jcxYsX46mnnkJQUFCt9bW6TJ8+HZWVlfjrr78auisARJ8bkUaAl8wLPcJ6IEAZ0CDnL9eVo9JQCQDQGDXwkns1SD9ERKqD6ERcu1y/fh13795FZWUltmzZAgAYPHgwMjIyQJIk2rdvj7Nnz8JgMGDMmDG4desWrl27BgDw9/dHx44dERERwTlmjx49UFVFRbLxadp+//13rF+/HufPn0fHjh2RlZWF7t274+uvv8bbb7/N28+cnBxs374d169fZ7ZduHABJEmiQ4cOuHr1KsrLyzFw4EB4e3tDrVbj9OnTUCgU6NOnD5RKa8JHZ9eg0WiwZ88e9O7dGzExMcz2Q4cOwcvLC/369QNBEJg7dy5WrFiBmTNnunXP6wJRuBFpcKL9orFu7LoGO7/opyByP8NOkyAm8as5SUlJSE1NhU6nw+bNmwEAbdq0wfLly3H16lWo1WpER0ejXbt2GDNmDK5fv860KykpwdmzZ7FkyRIsXLiQOebq1auRlZWFHTt2AABaBFAZi6UE5eO3YcMGjBkzhikmGRUVhVmzZmHDhg2Cws3evXsRFhaG1q1bM9uWL1+Oy5cvo7y8HK1bt8bdu3eh0Wjw5ZdfYvHixWjZsiXu3LmDgIAAnD59milK6ewavLy8sH37dnz88cc4e/YsFAoF9u3bh0mTJuHo0aPM+YcPH44PP/wQJSUlDa5NEoUbkQbncsFlvH38bcT5x+HHkT8CAJJLkjlt4lPj8fHAj+u8L6JaX+R+g462IUDcN5FTGr1R8DMJQcBDLq3Vtl4K16e6WbNm4ciRIygqKmI0NzRXr17F2bNn0aNHD2bb1KlTMXXqVObvCxcuYODAgZgyZQri4uLsjm8iTSjXlUNCSODh5cEc98knn+S069y5M1asWAG9Xg+FQsFsL64qhsqgwqlzp9ChQwe749+5cweXLl1C27ZtodPp0KpVKzz77LO4cuUKWrRoAbVajbi4OGzevBmPPfaYy9fwww8/oGvXrnj77bfx1ltv4bHHHsO7776Lfv36Mft16tQJZrMZly5dwsiRI53e67pEFG5EGpwqYxWyVdnwlnsz2yr1lZw2dVl+gS3QiCp+EZG6p/37+wU/G9amCdY+3pv5u8f//YMqg4m3bZ+4IPzxrHVyHfjZYZSo9Xbt0j+tncrZgwYN4gg2NCqVComJiSgoKIDJZIKfnx8uXLjAL9yYTSiqKoKEkKCJF+VnWF5ejsDAQE674OBgmM1mVFRUICQkhNmuM+mg0qtQVFSEgIAAu+MPHToUbdu2BUAV7uzRowcIgmDqW3l7e6NLly64deuWW9fg7++PjRs3YujQoTh06BBatGiBxYsXc47h7+8PqVSKwsJCZ7eyzhGFG5EGJ6syCwBwu/Q2s00p4xYAbBfcrl76IpqoRO43RG1j/REZGWm3bceOHXjiiScQHR2NmJgYKJVKaLVaFBQU8B6DHmPMpBkmswlSiRRKpRIaDTeYQaVSAQBjOrLFy9sLqlKV3XZbc5BSqbSLpqL76O41DBgwAOPHj8fff/+Nc+fOQSrlps7QarUwmUyNInpLFG5EGhw+bUnfiL5YmbiS+bsuw11FgUbkfoaJuAGJcl05/JX+Ddwj59xYMkbwM4mN39DF94TNG7ZtTywaVrOOOYHPp+nFF1/E+++/j1dffZXZ1qRJE5eETjNphhRSNG/e3C5XTUZGBkJCQuwEhVJtKQAgPDYc/1z+pxpXYY+r13D06FHs2bMHrVq1wkcffYSdO3dyPk9PTwdA+Sg1NGIouEiDw5eh01aYuVJ4pV76Iq6CRe432KHFRrOwf0pjwkshE/zH9qGprbbu4uPj4zQMGwBMJhMKCgo4vi/Hjx9HUZF7pRXGjRuHXbt2MdoUs9mMrVu3Yvz48YL79BncBzdu3EBpaalb57LF1WsoKyvDo48+ioULF2LPnj1ISEjATz/9xGlz8uRJREdHc5ycGwpRcyPS4LgS4XEs61idnT/EMwQvd3sZBEEgxDPE+Q4iIo2III+Gz3Hyb6NHjx5Ys2YNfvrpJwQFBWHw4MG87aRSKcaPH49XX30VCxcuRGFhIb7++mt4eQmnk+DTFL/22mvYuHEjxo8fj9mzZ2Pv3r24d++enUMzm87dO6Njx47466+/8Mwzz7h/kW5ew/PPP4+QkBD83//9H+RyOZYtW4b58+dj6NChjDDzxx9/2DlGNxSicCPS4PCZnOqylpQtnjJPPN356Xo7n4hIXSGaWGuHmTNnQqVS4fTp06ioqECbNm3Qq1cvmEz2js2bNm3C8uXLkZCQgODgYOzatQsbN25Ey5YtOe2YRRzPVxQYGIhz585hxYoVOHz4MFq3bo1vvvkGsbGxDvv53nvv4cMPP8RTTz0FiUTC28e+ffva+e0MHDgQ4eHhLl/DjRs3YDAY8Ntvv0EulwMAnnjiCdy5cwfbtm3DW2+9hZs3b+LSpUvYtGmTwz7XFwT5H9TDV1RUwN/fH+Xl5fDzuz9CJ//N7E3bizePvQkASJqXBAD4+uLXWHttLacd/ZmIiAiXTr9SWb4PzzjcqLSPWq0WaWlpiIuLE3SMbWyU68pBkiR8Fb61Vmtu3rx5kEql+OWXX6AxaJBWngYAaBXYCgqpwsneXK4XUUn7CIJA++D2eO211/DYY4+hS5cutdLX6vLzzz/D29sbDz/8cI2P5ei5cXX+FjU3Ig1Or/BeALganC5NuC/q+Dhh23NNUelVmLtnLkiQWD9u/X3hkCkiQlNU5Z5/h4gwJEky0ZstAloICjdqgxp56jwopUpE+UYJHk+tVmPz5s3Ys2cPvvrqKwBUod6aEOARgDJtGVOu5ptvvqnR8WqLp59uXNpvUbgRaXDkEjk6BHcAAQIkSVLq23rSJxrNRozZOgYV+goAQIWuQhRuRO4rTGarGeI/qIivMxzlvFLpVdAatdAatQ6Fm8rKShw5cgSffPIJHnnkEQCAVCIFQRDid1XHiMKNSIPjr/TH5ombOdtsfQfqypcgsTCREWzq8jwiInUF+5kVyy/UDyaSP6mgLeHh4diwYYPd9mZ+zQBwI91cxUPqAR+Fj9vmrP8aYij4v4iiqiIklyQjX53f0F1xi/N55zF552TG7wYAY5OmSchIqJNz24ahi8KNyP2KXCJvVP42IvzoTXqoDWroTDreNBjOkBASSMSp2ymi5uZfxKi/RsFIUnku7ifnW5VehZSyFHjKPJlt5bpyTpvBUfyhmDUlUMlNeS6WXxAREalL9CY9CjQF8JB5INAj0PkONmiNWlToK6CQKeAP0YQuhCj+/YugBZv7DbVRDQBIKkqCzkQlzpJL5Zw2XZt0rZNz+ym53vai5kZE5L9Lfbz/9Dm0Ru19k3TxfkQUbho514quYc/dPbhTeqehu2LP7QPAuZ+BglvO27oIrTkZGj2Us73efAlE2UbkPsVgNoiRU/cZbGdwVynRlgCgqoOLCCMKN42crXe2YtHxRTiUcaihu2LPxbXAnteBzDM1OgzbfiwUQZBUVDdmNikhRc+wntbzi9KNyH2GlLCGK4uagNrDkbNvTWrd1VqUlDhUOUQUbho5O1J2AACOZh5t2I7wUUsvKVsrIxSFsDdtb62cy5Z8TT4u5F8AADze8XFE+thX/RURacw08WoChYSKnBHDi2sGAQIxfjGI9o12KNx4yanSBN5yb5eOq9frOVW4axOdTgeDwVAnx64LqqqqYDTWvRAuCjeNHHolllya3MA94eG2ReBIP1mjw7BXQbRZ6mL+xRod01XoySDYIxgLeizgODWLiIj8tyAIAr4KXyihhF6nF2znr/RHh5AOiPVzXB6BZsGCBZg1axYArnaYT1OsVqtdFlYqKirQvHlz3L5926X2jYGvv/4a8+bNq/PziMKNSM0pvFmj3dkCBS1s1Jc9mRYei7XFDRIpZTKbsDJxJc7nna/3c4v8e6C1n4czDzdwT+5/KvWVeP6l5zFnzhynbV31BVQqlfD0FF44aTQa/Pzzz+jevTt8fHyYbMbOWLp0KYYMGcKp6N3YefXVV7F3716cO3euTs8jCjf/ImjfkR5hPer3xDXUhLPDvM2gBIyOIR05bUbFjqrZSQTQGDXM7/P2zkOptrROziPEyZyTWHFlBZ7Y/0S9nlfk30O+Op+JMlx6bilSy1IbuEf3LyRJIrUoFeVV5TAYDVCpVFCpVDCZTNDpdNDpqPusMWhwM+8msiqzYDBw2/GxdOlSrF1L1crjM2Xt378f586dw88//4ymTZs67COdQd0b3li1ahWnIji7jwDs+mM2m2E2O17ECWmNXLlO2/Pzncvb2xszZ87Et99+67AfNUUUbv5FrB27FknzkrBu7Lp6O+dqfz88pVRBbxJW4TqDIAg092+OFv4tGBNVTRz2qsuVwiso0BTU6zk9pFRRuJYBLZ20FBHhxzYFREZFRgP15P6HBIk136/B33/8jT279yA8PBzh4eE4fvw4nn32WUydOhVz5sxBSEAIHhr5EMp15fjmm2+Ydj4+PujVqxdOnuSa6tlmKZlEZufPM3nyZPz888/o0cP5wpQeG4/8cwRGoxGDB1sXh88++yweeughTJ06FcHBwVAqlZgxYwbu3buHyZMnw9vbG35+fnjttdfsjrtixQrExsbC09MTEREReP/99zm+Ma5c57PPPotp06bhscceQ0hICLy8vDBlyhRUVFRw2k2YMAE7duyAXl/9ecMZonAjUiN+CvDDWakJ14uv1+g4Ox/aiR0P7WCSWv1Xopb+K9cpUnfYOhHT2s9GCUkCenXD/HPR2fq5hc9h8pzJmDhpIqOpGDp0KABg9+7d6NGjB67du4ZtR7YBAN58802mXVlZGaZNm4aHHnoIZWVlgueI8o1CrF8s5BK5YBshFFIFvOXeuHjuIrp27QqJhDuN79u3D2PHjkVeXh6uXLmCPXv2oFOnTnjooYdQUVGBo0eP4ocffsC+ffuYfVasWIGvvvoKW7ZsgcFgwJEjR/DXX3/hs88+Y9q4ep27du1C7969kZOTg9u3b+PKlSv44osvOG169eqFqqoqXLxYd76VYobiRk4L/xZILU/FyJiRTtuW68pRriuHl9wLwR7B0Jq0desgG9QCQaYqZEsk1UojTnMm9wy+u/Qd2gW1w3v93gMApjIvzemc07z7Xiu6hnDv8FpLOy8KGyL3O+He4Q3dBWEMGuCTBopIfCcHUDiObnIWbda5c2csWLAA2apsVGmr7D43m8148cUX8c033+DkyZOYMGGCXRu64KZCqhCsOu4IhVQBnUmH3OxchIaG2n3er18/pkJ3x44dMXjwYOh0OsaJt0ePHujTpw/OnDmDsWPHAqDMZkuWLEGnTp2g1WoRHR2NV199FV9//TXeffddt66zX79+eOGFFwAAMTExmDlzJk6f5o7fTZo0gUQiQVYWd5yvTUThphFjNBsZ+2qboDZO24/ZOgZqA5Xtd0yzMdifvh+7Ju9y2aPfbZr2gKT0OICahaCW6cqQVJQEpVTJ2camX2Q/u/1uFt/E7N2zAVS/3EQTzybV2q822HJ7C/5I/gMAkFKW0mD9EPl3UR1tgIhrtG3b1m5bSkoKXnvtNRw5cgQ6nQ4KhQIajQaZmZm8x1Ab1MhT58FH4QNfha/bfagyVqFcVw4zYQZpth934+LiOH/7+fnB29vbbhutcSkoKEB2djZeeuklvPzyy5x2SqV1THb1Om3P7+/vb6fdMZvNIEnSTutUm4jCTSOmTFeGSwWXAACz28522p4WbABgf/p+AMDmW5uxqPeiuukgQSBTTg2kNYpusryfF/IvoEBTgFCvUDtNUN+Ivna70femJoR6cVc+9ZUnJKsyCx+e/rBeziXy74atbZzUYhL8FH4OWjcwci9Kg9JQ567pIeT2guOsWbPQrl073L59GxEREQAojYVQLpd8DVXYWKVXwWg2VqsyOABERkXi4il7sw5fBJcrUV1bt27FuHHjBD939TpdOVd+fj5IkkR0dLTTttWlwX1u9Ho9zp8/j8OHDyM3N9fl/S5fvox9+/YJSsf/Bir0ViesPHVeA/ZEgNZjmF9z1LUzYNGh2WPjxjptKyNqXzavL7OUbWFQEZHawFvu3bhzNREEZRpqiH9ulHCRy+WCEUFsTCYTLl++jCeffJKZ8DMzM5GdnS24D3sBZTC5n3yPXkh26NEBV65cqXECv9DQUMTExGD37t2CbapznY44f/48fHx80L1792rt7woNKtxs2LABbdu2xauvvooPPvgAzZs3xwsvvOBw9VxZWYkhQ4ZgzJgx+Pjjj9GmTRt88MEH9dfpeoQdgRR/N75ax2gd2Lq2umPP5d+YX2uSI8ZZUisAuF1qn6Qq2q/mUr+JNKFLky41Po67VHe1JtI4oE0DjQG2kP/7rd9Roatw0FrEFaJio3Dj+g1kZGTwhj7TEUtSqRTt27fHTz/9hJycHCQmJmLWrFlOw61tIUmScdYlSRJ6vR4qlcphVuM+g/vA19cXBw4ccP8Cbfj444+xatUqfPHFF8jIyMDt27fx448/4sUXXwRQe9dJs3PnTsyYMQMyWd2Ngw0q3Mjlcly8eBEnT57E0aNHcfLkSfz444/Ys2eP4D6LFy9GdnY2kpOTcfz4cezatQsffvghjhw5Un8dbwCEHGqFaBNI+eiEeYXVRXcs1I6Wgy3MCgm2tG8Km1BPyqQUqAys9rnTytOQWJgIAJjccjJifGPcP0g1XnBb00GUT5T75xWpMZX6ymrtN+zPYRi4eSBHu9pQRPhEwEfuw/wtVMJExDkEQSDKNwovPP0Cunbpir59+zKh4B4eHvDwoFI30NoxH4UPNm3ahNzcXHTu3BkzZszAAw88gK5du0KhUPCeo11wO7ttd+7cYcKsy8vL8fnnnyM8PByzZwu7IyiUCrz88stYtWoVAGqBKVfKmT7SsPtN4+npyfGnmTt3LrZu3Yr4+Hh0794dkyZNwo0bN/Dee+8xbVy5Tr5zKRQKeHlZTYJlZWXYvn07Xn31VcFrqw0adPlIx/3TtGvXDjKZTDCEjiRJbNy4Ea+//joCA6kJbfjw4ejRowc2bNjAhOv9G7lZUs0swHWZLiY1AYijhAH24OoufJqbC3kXnO7no/DBmGZjanRumqY+TbFkwBL3d9z+PJB+HHjhNKDkcQ40myl1uI1K3FZDJUZp1T9bb2/FB6c/wOs9X8e8Du6lg6f9226X3EbP8J5OWtc97LxQt0puoZl/s4brzH2MhJDAX+kP/zB/bN26lfMZe34JUAYwwR6SThIcPszNDP3WW29x/tbr9YxTr4SQQC6Rw2A2MO9969atoVKp3O7vwoUL0a1bN1y+fBlNWjbBqx+/ahdAsm7dOrv9/vrrL7ttkyZNwqRJkwTP1alTJ6fXuXLlSrv9FixYgAULFjB/f//995g7dy46deokeK7aoMF14wUFBTh16hQqKirw66+/Yvjw4Zg6dSpv26ysLJSUlKBLF64ZoWvXrkhMTBQ8h23WRNuEQo0V9oDlrqPrw+0eRr4mH5HedRt2GWo0okAmQ/vg9tU+hkLKWuFYLtMVHyNvuTdmt53NJMKrDrQ5LVuVXT3nvsRN1M9r24AeNhOk2QSsHAR4BwPzuGZFuUSOdkHtcKvklijYNBAfnP4AAPDlhS/dFm5ofBQ1F6xrm7p+nlR6FZaeW4qxzcZiUNSgOj1XQ6A2qGEmzfCUeQqOBwRBuJRolCRJ5OTk4NSpU9xyDrW06PTw8MDNm9TC93oRlWusTFfWKJ9LGrY2qC5pcIfi7OxsrFu3Dj/99BOSkpIwatQojrqMTXk5ZeOmtTY0wcHBDhMmLV26FP7+/sy/uvTQritcGbA6BFP1RdoHt8e2O9vww5UfkFpet6nYa2MYHRU7iklJzqxkbHyF2CUaaG6X3sZj+x7DW8ffsvvMVdjlFl5KeAkl2pJqH8uOghtAwXUg7ZjdR15yLxRoCpjrzVZVzzFPpGHwlVNaupoI1rVFnjoPlQarec12IWQym5BVmYXMisxaiQZcmbgSf6f+jRcOvVDjYzU2zKQZ6eXpyKjIYEpa8KE1anGv4h6yKx2/t2lpaejatSvatGmD559/HgA15lTHkZiGDh+3jfQU4dLgmptu3bphx44dAIDExET0798fwcHBePzxx+3a0rY9jUbD2a5SqQQFIgB4++23OWqxioqK+0LAcTdfxeaJm5nfH9nzCPVLPSkFXC0gJ0SEdwQ0Bg2T1Mo2uZWUsE92RQ/U1fUxOJ1zGi8ftuZ1OJl9EjmqHAR5BFXrePYI3xOSJFGstYbPtw2yz58h0nihn/fGoHWzLX1i26fCqkKM20aF+F565BLkRM3y4ORpGmHkZi3hiv8fQPlqqfSUGampr3AtqObNm6OwsJCzrcpon/zPHeg0GUJjLjtf2H+ZBtfcsOnSpQt69uxpZ9ejiYmJgVQqtQv/zszMtEscxEapVMLPz4/z735AKbM+pI7Cnq8XXce9inucbVcKrwAAslR1lwESAAot3u45qpqFgm9/cDv2T9uPpj7UQGE7sJAgUa4rx2fnPsOtklsAgMzKTM5Pd1l2aZndtmqvbD14nil2NlSb49ZUGBSpOY93pBZQc9o5r/7MhiRJxpHYZG54511n/ltsDUR95XFyhNFsRJmurO7vXWUeoHKvVpyrwmpNaunReMo8uSZ5F5FL5bwmM1qjI0ZiUjSYcGMymVBayq3ArNFokJKSwqmKeuXKFSQkJACg7IvDhg3jOHqVlpbi0KFDDpMP3a9Eekcy0U4jYkfwtinQFGDW7lmYuH0iqoxVKNQUckJUMyszUVRVhO8vf48PTn1Qu4NbYBza6KiXvCarhVPZp/DE/ifwzcVvmG22PjeXCy7ju0vfYePNjYxWqqYCAp/NnAQJo9no+uD1QTn1r8Nk+89kFpMFIbFzKLa9voYoFPpfZ1DTQXil+ysYEjXErf3YhSq1JuFQ3YYi2COY8zfHd68WNE3RvjXTemdWZiK7Mrtuc3eZ9EBlLlCRDbiQpkJv0qNUW1qvmjgfhU+1BBFPqSc8ZB52Y4aUkEIqkYpjiYUGE/EMBgP69++PqVOnon379igrK8Mvv/wCuVzOSQG9fPlynDlzBteuXQNA+c8MGjQITz/9NPr164dVq1ahRYsWeOKJJxrqUuoMEiSa+TdDviYfnUL4PcvZGpsJ2yagsKrQrs3Dux9GrppKkDg2bixvtt9q0WwgJPkHmb66zMV1wJ2DlEDQaRoKqwpxPu88ZxVjW36hd3hvtAykKmfT/je2L3FySTLUBjW6h7mWGEpIOJr29zTkqnNxbNaxWlLx2p+HTlZIU+1ouPuImmRjrQt6hfdCr/Be7u/IetRrOtHXBrYLFltzNvs9qUk+Kpr+kf1xo/hGtXNoaQyUW0GZrsyhSadGuJmeIU+dh0p9JSK8I1xqzx7vTGZTtWpEVVcIqTJWoVRbCoIgmIgtAPBX+sNX4QuvWsjE/G+gwTQ3Hh4eOHPmDIKCgrB3715cvXoVTz/9NG7evMlkQAQon5wRI6xai549e+LChQvw9PTE/v378cADD+DEiRN2sfX3HfdOA8e/5ryUWqMWZ3PPAgAmNLcvwAZwXxA+wQYAI9gA/L4r1YYgcFNJCSRuJTTLSwJu7QIKkwFYB4qT2ScFHWuHRA2xG8RthZNp8dMwb988FGhcU0XzRXiRIJFangqNUYPkkmSXjiOIhx8w+E1g0MJq5cJpVGScBfa8CWirF2lYrivH4D8G18j5u7Y5nHEYbx59E38m/+nWfuyJrTGYF9n9GRU7CoEe3IALdh9rQ7jpFd4Lq0atwsKeC6u1Py0I1OkkzPleXIhqstzD+qyoXqYrs1vk1IRcdS4yKzMdOkL/l2jQZZS/vz/H0ZcPOkMimw4dOuC7776rq241DGst5QZ8woBulA8A2+G0qKqoWpWvbQWC2qqeDQCIGwKUHgHgZnkIuk88E4POSL2YD7Z8EBtvbmS2EwTBDED0YC208imsKnQpkmBx38V4q/db6LahG6trrNToZhciGj6wrJymr+OYpjQGDfSaInge/xxKEsDgNwCJ+/b1RsMvo6mfBAGM+8zt3Xem7ESlvhK77+7Gp4M+reXOVY8zuWewN30vSnWlmNFmhsv7cYSbRmYCiPCOqOPEnZQPT7muHDKJrFrO934KP5RqS2slP5UwhPWnCwKou98jW0g0k2ZI4fqikX5+9CY9dCad29rMoqoiAECZtsxlTdN/kUblUCwCoPAW8yutvgX4M/QCQJSv48y2HUI61E6/+Li4rnr7XVhD/TxKTZKcCAVagLEZbFLLUnE4g3I0p4uC2poEaBWtp9S12jpFVUUYuHmg4OduDTo2Go03jr2BQTsnYg9TjbfhHTlrRJzFL6Vpj2rt3hjzbvx+63cAlJDjDuznNb08vTa7VC3Y2tj1N9Y7zJpcGz53J7NPYsRfI/BywsvOG/P1oV7eBffOQfeJfX8ae9SRrRaO9hNsLGVBGhpRuGlshPInw7uUz18BO9w7HEnzkpA0L4n3c1sBoDa8/Bl4hJKaH5L/OL9c+wVn885ytkX6UAkK6cGdFohcVb3vSt3FqaQ+PHo4mvk1Y3KYOKqu/OX5L/HdJZb20GZ1KLG8WkxPnPhF1KpGrS6oofklzp+KZqxWeYvqcmkDkH5S8OPqmpTYz3pjMAHE+MU41KCwhZ/a8Hk6cI+qZUSXLXEX+v2snzIRpN27xwcd1l2pr0SkTyQifSId3it3i5N+8803eOeddwBQ2rXa8j0jSRKzZ8/GlStXmG21aepyh2XLlmHFihUNcm4+ROGmsRBlcWzkCykGcLf8brUOa6sBuVN2p1rH4eXeCeZXWiCoDrzlF/Kdl19QSpUYHDUYg6IGwUyaGSdkVwfNry5+xfzewr8Flg1fhgCPALQOao12Qe0EwzQr9ZX49cav+DnpZ5RK6FeIe5+PZB2hrsOT9gVzHK7bGEJ0XaOGEWr15aOSfwP4+yVg3XjhvlTzWvg0jc7IUeXUir+LK9B+ejShXqE4OO0gDkw9AA9ZzX0TaxrCTe9fqwstW9jCgxv3nSAIBHoEYs3yNXj//fcF2wUoA9zqTmpqKm7cuEF1jZAwuWrYpKen45133sGgQYPw22+/2X3Ox7p165Ceno6uXbsy2xoq99KDDz6Id999t9qVwmsbUbhpbLAGTlcmApVehQPpB3Ak8wjv58Ge3LDQ2s6oGmSpltsjrHrmCgCcF51+MbMqnefnkUlkeLHri3it+2ucgZKdJOt83nnMT5iPXFUu3yEYUstTGR+bdWPX4c8H/mRy7tjCnqQM9Hck8F1lyyyrZh7NTTO/ZswKsDEkg3PI3SPUz7Sj1dq93oU3FybO6go37FW3KyvwvWl7MWbrGHxw6oNqnc8VHF2LVCJFuHc4Inwah38GLWBVJ8dLfVBlrMLN2zcZYYQPd4X0BQsWYOnSpYKfx8fHY/jw4fDy8sKtW7fscrnxQZIkPv30U7z00ktu9aVaaEqAihyHWrBmzZph8ODBWL58ed33xwVE4aaxkHWe+lnpeBK2JaUsBQuPLsT8hPm8YanXiq5x/m7i1aTaXeSjNqash1o+xOTmoCfBZn7NBNsPaDoAAHVtM3fNxMKjC3m1PwDw0ZmPcCTzCDbc3GB3HFtB761jb6G4qhgDfh+AAb8P4JRmYMP2hQo00atY/sHOTG+3WT1G+kTCRJoYQaxWyz7UJWX3nLfhgU5ZYJtsss6gQ3N9HDjXVlOJpJAqGMHXUXJNmuWXqcF+e8p2l89BkiTulN5xyak9R5XDCT7gO1ZRVRGKqorqTXt0v2Imzfj8+8/x986/kXAkAb369cLAgQNx4cIFfPLJJ/i///s/bNiwAQ9OehBvPPMGAGDDhg0YOHAgBg4ciAkTJuC9995jSgXR7Ny5Exs2UGNQqbbUTms1ZMgQpKSkYPHixQ6z7QNW/7W0xDTcvXsXkydbAxl++uYnLPt0GX7++WfMmjUL48aNwy+//AKz2YxVq1Zh4sSJmDJlCvbu3cs55vr16x1eQ1VuMiZNm42ffvjeuq2qCpMmTcJP331BjQsGDaZPn45169Y1Ck1040k6IULhEQAAmLd3Hi4V8PvZCLHjwR1QSBXou6kvx5ekmV8zpFekA6i7FbRbK5n+84FT3wO9nmY2BSgDqKgDi3+AwxUxSf/gT5XOjpRqE9QGd8vv8kYVTG09Fb/dtKp/D9w7gIfbPcw4ZPJpU5JLkjEtfhrzt7OrZotcM+Jn4GbJTUxtNRWL+y7mZFYWymPU6Kjm80OH3ddeaQtXqRszGOPf5ULocHW0clvubMGS00swNHoovh/+vcO2WiM3kaDt+cp15Rj25zAAwIlZJzi5UVwhrTwN2+5sw7wO8xDiGVJjLWOVsQqEoQp6ohTgM2cTUkDOWnjo1fZtmLYSQO5p39agBQxV1m0C5n4ahVQBvUkPH7kPBgwbgGMHj6GyohLz35qPuIA4tGrVCsuXL8eff/6J4cOHY9Zjs6AMpISQkcNHonVLKudPSUkJfvzxRwwdOhQXL16ExGK2Tk1NRVYWpY1mL45o3MmaT2u6Tx49ic6dO8PLiwqpl0qkuJd6D/t27MOkSZPw2GOP4caNG3jqqafw008/oUWLFnjhhRdw+fJlTJw4EUlJSWjfnnovhw0bhubNmwteg6enBx6ZOgGPvPIm+g4ais6dO+O1115DcnIyfv/6LUqzI/dC//79kZeXh+vXr6Njx44uX1NdIAo3jYWQNkBRMuAbDgB2gg2fjdYWelU2Lm4cttzeAgDI1+Rj7di1GL9tPKqMVbVu/qi0vLwpZSloEdDCtZ1odTQr8dWOh3ZwmjjqJy240VEBKWUpHD8b9gRK3zeSJFGmLcP5/PPwlHliYNOBqNRXwha2kJRRkWE3Ga+/sZ7zNzN1KvmjgZijSRVMor6D9w7ivb71Uxm39iAAkEBk1+rtXd/5YLSWVadKOEXBtFbTsDl5M2a3ne3Woc2kmdG01ZUmhC7ImK/Od9rWmf+WxqgR/MwVpv09DXqzHsVVxfhk0Cdu72+LxqBBh1X8GdcBAK1GA3P+sv79RUuARyAAAMQOBB7fbf37206AhkeL9YHjCCK5RA69SQ+pRIqIqAgEhwZDKpWie9/unIjToKAgbNu2DbnaXMYJOSYmBjExVkf5MWPGIDQ0FMeOHcPQoUPtzkV/X54yz2pFZMklcihlSmSkZyAqyhotSwutkVGR+P333yGVSjF+/Hjs3LkTpaWl2LhxIwiCwPjx47FlyxbEx8czwk10dDSn3iLfNUx/YBT2nEjEww8/jPfeew+//PILTp06BW8vahzP15dD50tppFJTU0XhRoRGOPcLQEXy8MGeNPRmPYx6I8fnJKsyC0qpktmWrcpGt9BudsepFgEx6KjT4YqH0r3kgMGtgJajgBBqtXM86zg2J29GlyZd8EznZwDYJyQM8ghCrF8sLhdcZupmsWFPMmxBkHYyVhvUiL8bj8/Pfw4ASJqXJFh+gYYv6iDcO5zzd8Vb6Qj0CITJbIKEJO0m8eYGAyDzBFh1wkiQuFfJNc80tnwpdrSdQCVeDGre0D1xDZ3KaZMh0UPgr/RH91DXMlrTqAwqRmBw5XsbEjUEG29uRBNP103CdPScI/OsEAEW7S8f1Vnc6M3UhEWHzId7hTtq/q+mR88eUCgUkOqs452mSoO1v6zFkSNHUFBQAJPJBIPBgNTUVF7hhsZP6VetqCk6P5BWq+UkryVAgCAIdOraCVKptX+RkZFo3rw5Z2yKjIxEXp5V8NdqtVizZo3Ta/j+26/Qre8gzJ49Gx9//DF69uwJ5FwGABSZdCAJEhKJBFVVNSsOWhuIwk1joeg29bOc39O8Z3hPp4d4cMeDTIInNhO3T2R+51tp5qvzUa4vdz+deqvRILL+BuDmoGnSAZ6BgB/lt5CrzsWxrGMc/wXbXA09wnqgS5MuuFxwmcnWzJ5Y2JobjUHDrIhOZlOhwH+n/o2ZbWZyjsmnDXO2sv3p6k+cv6uMVfAyeeGB7Q8gzj8Oq0atYvp7Mf8iBmmqeAVWg4nrS3G16KrD8zYaqmmWorM9NybfooFNB2JgU+E8R0KwnxFX8kgt6r0Ii3ovcu8cNgkr3UFhkyyytmpL0fv2jeyLq0VXa2RKvfHsIQBA++B29h/aLpTeSBE+kO07/KolJYa+Cii2jKlhzr8jevxwFEatMWhgkpvsNL6zHp2FtFtpWLBgAWJiYqBUKjFz5sw6m+A1Rg2Kq4oREByAe3esiySm9ILNLSEIAnK53G4b+zl+8skncfXqVeFrkMgB0gSFhxe8vb1BkiQ6dLC/rxXlFTCbzQgLq9tEkq4gCjf1gM6kQ3p5OloHtnY+WOVcArrMtNvcI6wHTmSfQO/w3pwoA/bAxSfYANwJhV496kw6RgAYuWUkAGD/1P1M7hjXIHDZsnKgVbQukXkOSPoTCGsPtBnLvGQJmQlIK09jcqKwaRvUlnGOpq9ZKK18almqnTDIN6jz+X/wtVMb1FidtBpjmo3hbX8x/yJy1bmcMhf0NRHtHwK8YwGT0W6/+4o8y6Sh5i/x4Qw+E2Cd4uNcS3I+7zziU+PRPrg9ZrWdVa3T1JXG7XYpNTELRUGyYU9SA5sOrHW/JikhhYk0oWuTrsw5qiMU0hAEAVLuCU+5J6Dwdr6DK23s2hJWXxyF8zQVSqmS47skkdgvfGgn4AJNATN2ms1mHNh1APF/x2PUqFEAKEfb4mJhB2+aCn0F/JX+kEvkMJlNIAjCJfcDmi7duyB+azzzd7YqG2q9Gh4S4YhYkiTtBDiz2Yxt27bh77//Fr6GcMrE9M7rr6O8vByvv/46nn76afTt2xfsXPDJ15IhlUrRo0f1o2drCzFaqh545sAzmBY/Dbvu7qr2MabHT8fz/zyPpee44YTuDq4xfjHIqszCoM2D8PbxtzmfuV1LKbYf86ur9ZwAsFb/9n2nne0eavkQZ/v3l7/HvvR9nG3sa2drfVxd7fJNaHxRV99e/Bark1Zjevx0u/bmbzsB6+0rgq8YsQJHpx3C4IubgaOfAjpu1tjGEE3gFnSUVPoJx+0aC360L4Lws3Ah7wK2p2zH3rS9gm34YH93rrx/eeo8XCm4gswK5+G9NHSCPLa/jCu0DWprtzgQcrx3ldHNRkMukTMFdw1mAyr1lZygBXegk2P6K9xzbHYL+muRyAAeQcUZQSFBKMjjH9PYAoJEIoGXtxeSkijh32w2Y9GiRdDpnCd3rDJUQWfUwWg24lbJLdwpdS0HWaGGWmD0HNITlZWVuHz5skv7AUCOOge3S29zBByJRAIfHx/H16DXIGH/bixbtgwbNmzA0qVL0apVKzz+xOOc458+ehqDhw52y0G6rhCFm3qAdg6mnXxrgu0xnFXVtVUdEyAQnxqPKmMVI2yFelKyd5i3m6rEMyvda0+TuIn6+c//APALFLYZfNnQ/WaHviukCsT6xQLgNze1CmhlJ/Q4M0vRfkTJpcJCHwkC0UbKxMSe6L648AWGbBmBjX78q8b7TnNDJ5ns9ki1dq+N5HFuwXzXwvd5zTWqDMilgkvIUeXYmQqFYH93N4qFc6HQvHnsTTyy9xGM3y6cUNAWdxYt7Od6ddJqqAxcLapQmgRX+Xzw57j0yCXMbEtplM/lnkP/3/vj8X2PO9mzAWEu073FH31/xk0eh4y0DEwaMIkJBWeOyKpzBwCL/m8RFi9ejM6dOyM6OhpXr15F06auVzs3mA3IzcrF7HGzMXDgQBQWFmLlypUYOHAgXn/9dcH9AoIDMHv2bPzyyy/UcSzPL+0jxUeZtow5J5tvvvnG4TWUpF7Co489gUWvL8DAgQNRZijD+9+9j+PHj+OHdVTh2UgosXfrXsyfP9/la69LRLNUPeJSQbsmbdw6ZpBHEE7MOiFYI8k2gslgNtiHr9KpWNwe+Gqn/ALfytKVwT3GzxqhQILkLb8wJGoIjmYdxdDooXaDvq1w0zOsJ1oFtkKwRzCKtcXwlnvb9SVAGcA4KVPnBVMyjy/ygbkyG18n2xW0u+G59Q4tnEirN2TQeWFaBrSsrR45xgVBhf29jtk6Bt1Cu2H9uPUO9qBgP6+2zxQf1fEzcke4aRHQAuHe4S4Vr61OdE6pthSV+kr4KfwQ4BHAaFDp6D93od/POs25Q98+s4F692wXMmYzR6ND+/ip9CqEe4cjqHMQrt6+ioy7GTBrzWjVqhUWLlrImJIMJgOjZZ44fSJmTp6Ja7euITo8GtHNonH49GF0b2l1VDeZTIzfS4R3BNQGNaM9kRJSBAYH4rX3X7PTugUGciu827JkyRJ0796dKu0gB5557RkoZdzv+MMPP2QcjOnxa8knSxAZaHVBmDt3LiZOnIiUlBQEBwcjLi4Oly5dQkREBEiSRJrJgFUrP8OYEZOYfZrGNMXuI7vhVUCFuO/YdhDN45pj8oP2muyGQBRu6oHh0cORkJmAXhG9hBvFDgDunaQcbQHsm7oPh+4dwhcXvuA0e7DFg3a7OlI122or+GpUEVbpRpDkkmRczL+IWL9YJokess4DcZSAUZMKv3zp7M/nnXe6n4yQoVd4L6aOU76GCptlD5qOHDN3pVrNhO2D22Pt2LUAKKHJV+ELuZQajAZFDWK0b2zBBgDMBEDw5N3ZdmcbAOCmUkFfJI7NPIYqYxV8Fb52yewavZnKgSmxUZLPSl5Jki7VxnK1TpS75Req45czr8M8vH/qffSL6Oe8sc05jmcdx9TWU5m/Q71CsfOhnSBAwNcF/xNbfkz8Eb/f+h3PdH4G87vNt8ur4y608667Jje3kHtZfzebAClLuNFrqLQb3iGAPzfxqYSQWLO6ewNRQdZQ687tO0Nr0sJL5gWJXMIRWtUyNeI6xkEqkSJXlYu2ndrCLLOOQ3fv3mVCo6USKWQSGSPcECDg4emBHn17MPmgXCU6OhpHjx5lfIRiW8RSvkws2rSxXzC3adfGrp5dQEAAFf1koXt3Sjir0FXAIzwUzcJDIZNyn+W4lnGI6tgDIEl060Ni+ITxMJNmt3yH6oqG78F/AHauFWFoAYNq09SnKfpE9LFrFeTJdRas0FfgePZxwaPa2rXlUjlaBbQCYC3+RgsF9E8+LuRfwNJzS7EjZQdnu6+JeoEHRQ3C2dyziE+N59nbdejJIq0izWlbg9mA9/q+hyUDlkBr1HJC4GmOZR0DQDlbtwpsxfmMXT05tSyVUeuuH7ce8ZPj0dyfCnuO9BZ2siYBaCzfL9/kmMeEZJII9AhEpE8kJThJ5AjzCqvWZNMg0HXE0o5Va/d6N8N5uK8Jc7XWEUf7UUeXRY8Z1ZkkbGurySVyNPdvzuuo7wp09fTjWcLjjDt4ySjBwzaqq9ro1UBhskvh/wCASouGS80fgKEz6lBlrLKroeWv9EeYVxi85F6C3wt7H4VUgezsbHTq1AmXL1/G008/bdeeBMksxqq7wGnfvr3b0UnunIte5MlY+9BjZ7muHJB7oRJmyJsqoVKqqu2LVduIwk09QGsNHKph752AjgAuFiYyEj3fhGBbsC29PB3vnHhH8LAX8y9y/vZT+KFEW4LFfRZj2bBlnM8cDe60w3BKGTcsk2QJ8k8deArvnHgHKaUOQjd5mN12NmO2IFnCnRB01MalgkuYtGMSXj38Kude8d3nXXd3oX9kf04FddvqzkvOLEG+Oh8j/xqJkX+NZCLA+kT0wdoxa3n7EmMwQmI5jqMq4rYh1G2C2iDYM5iJImILWo2aouoVXqWT0tk+P3UGHU4cEFvjiua2+Ch80CaQWg3XldBGjxmuHD+rMosTqceHxqCB2qCukSkoW0V9hzWOEKtt5V/JXSrJX7GLz6aD54EkSaSUpeBu2V3cKrnFySKep87D3fK7qNRXOiyLQS9YvOXeCA4Oxrp165CWloa2bdsCoMx8bO2XKyU22HhZtFLVKaVDa55tNdAOoVOwsTZx/NM0xcioyGD+rKlmr7YQhZt64OC9gwDAlEAQ4s0mIXgsYxt+uPIDnv/ned7onC5NunD+th38praaykmoR4JE26C2zN9rktbg47MfY+31tegXyVV5O/KHOJpJFUwUmpzYA16exmr7J0kSC48sxIenP7Q2HrSQ+tmJuj6CIOAp84SH1IMZ1B05FNPXLLT6iPKNstvWPrg9lpxegl+u/cJss9W07EjZgeTSZORr8pGvyWfOU64rR0ZlBmyRSWQcu67jKC0ST+5/Ep1+7YRPzlJZXulwXwC1l1ixzqneZN41tCsA96spVx/HSTH5cEfwckf4qE6umsMZhwEAp3JOOW1ru1K2fS/KdeXos6kP+m7qy0TaVAfmvauhQEdPfo4cX92C9gdjm6I4E6zz/tLJ9Oi6TTQVrChHtUFNRTiZdJztjvDw8ECPHj3g7W0NZ3fFT8uVvtrWNaO3Oxo7aWpVKC+zHxsbA6JwUw/QIZQdgh0kkwqMQ4I39XJuvLkRJ7L5Q24v5F3g/G07kB3OPMwkuQMoZ8Zlw5YxPjG070i2Khsbb2wEYC0gaWurdQVaCZtUlMRso81eAJBRmYED9w5gy+0tVpUtnYuC5fi2/cHtOD/3PCO8OXr5bDVbN0tuMkUuJYSE0fqwNVEns0/ir9t/4ZuL3+Bc7jkA/DVe2PfzbvldAJT/z/9O/Y+37XeB/jjpSd23KoODpF0Kb5zLo85Lm+4afVZiPlxIiNYooCe30nTK54KHcXHjnB7mZvFNu4SSZtLMmEDryleK9vtwOGYIYPvusCfiGk1qtXSptEbUrdxYjqDHLSXLxCvwnQNg/BrByg5M5w5zlDGYFsrKtGXQmlg5cWxMVPQ9zlXl8prKaTxkHnbFe11BSkghl8rtzksvHFwp5urOeWkh1FDfJVRqiCjc1AM1yTZqi+0xbAerSn0lJ4dBjioHTTyb8K4WPjv/Ge8xXDkvAMAvCl0tuRDY6m72AMH2T2Da+EVRDtTBlKboeNZxvH70dfx28zdmsqBDFmlCPUOZNPnXi6/bdYX2M2ALDHQ1ZoA7kD554EnB62TfC1o44tPa0Of8OcAfnwdTgyXfSjTOYACU/tyBF5TWhq2OZvqdeR5I5ubzaRS0f4j6GdzKYTMh6OurN98bI0srx3ofzKQZp3NOo0xbhiFRQ/Bo+0c5KQXYXMq/hBm7ZmDIH0M42ws1hRyHcEdZbQFgQCTlgO+y/0xFLoILqPQD7fgy+DrBVvtQW/ecPo6tI2qDQzrR0rEu32g2Qk0QqPIMBLzdN+vQONKOsMcaXuHXsilQGQi5VA6ppcaeq/ODv9IfAcoAu+fJlf1pk5k7vn6ca7BcNzuRLAD4mhtftXlRuKkHaFWw7QqQQ6lzB1oAWHuN6/th+/IYzAbsSdvD2cYOE+dbmdDmGbcS8QFAh4eYSCEh2H4oRtIyCRirgJBWQFMqi2V6RTr2p+/Hp+c+xfP/PE8VubSxCXdu0hmDogYBACa3tA81pIUbE2lNj84OVWXO7QQ+nwRHeW6EaBdETUpj1RpeHwNbrRFTKHXNSOD3mUCZ6wnf6ovjnh545N5fSCt37VllQwukDt+BuoL1juxI2YFnDj6D6bumY0TsCLzR6w3BbLu0M7qJNDFmIsA6yUsICRafXIyxW8c69GVZ1HsRkuYlIfHRRNf6e30bcPcIgOpp9xw56tZE00Rfd4+wHmgX1A6PtOfPeWQmzTiSeUQwY3qtQ5uXDc6j3TQGDdJVWcg1VgKVucyzQX9/rjqVs7H97ukUEkLHY4RNgv5B/eJqfT61QY1CTaHdgtVX7os4/ziEeoUK7FkLWJyLaUtAoIfjUPWGRBRu6gHavLEzZafDdsPV1IQ3p90cwTaOEnQJwQ65HBgpnDbdUZ4MoVXBaU9KvcmerNmZjqWsyt+MWeruEeDiOqCAEj7YA+7JnJO8K+HDmYex4cYGwb6YWSuHywVUxs7OTToLXg/Av3qp7VUu0WkG0PdFu7wrvOdhq9LZ/gPVxaCtdi0oDhfWAjd24IXwUFypysOiY+7VSQLcdGC03Vdbhn/u/eNykj0AgA8reoQ1+dD+b3nqPFwtvIqlZ5cKph1gf0cfnfnI7nO6Oni+Jp/XxFltqsqQYcmJcjTrqNPm7H72COthN+HU9JmmJ1/aL2xk7Ej8+cCfeLPXm7ztt97ZivkJ8zFpxyTez2sdnaW0h8U0bYfDDMXUvaEjR6sj/BEEgRCvEBAEgWDPYM4C0jZyjY1Kr4LRbHT7+6GFqVKb682ozEBaeZpDX6bqRGZxtDQy/jxJYSYHZsAGQhRu6hG+h5j9kC0rKEJSk3F4pfsrLh/T3eiHaa2nuWSTtWVEzAgA1mzGAIConiAtgga7ivez/zyLL89/CUCguKWTnCkkSLvyCybS5DAZGjsDLn1PbUM5bXm287N224qrnNeEcURKaQqe3P8kApQBODzjMHpf/AM48gm1SqT7B5J/cNGzHEPdqafDR3kW8HEY8Mfcmh0n8zyw61XOplKdwCRSRzy+/3G8duQ1/Jj4o+s7caqXW+81W5V/ueAyNt3axDgS9wrn5qGiJzyAmtCZo/F8d44mqEJNIZJLkl3XjJJmXFNQE4q72tS+EX0dCvXVEXSGRg8FAIyIHg4cWAzy3M8wmA2CUT60T1u91ROjTd98mg+pguNbQ/vKVDHPQfVcBWyDEcK8wtA+uD3CvV2vmF6pr0SVsYoZw41mo0tCR03GKNr53B2tGr1AlRASQV+mCpYAWZ1K53WBKNzUI7YP7qabmzDirxE2an73Bp8Y3xiHn2+9s5Xzd6RPpF3+HLpsgSN1Ju2XoDVpcbeM0kThxDfM5wRBoGNwR+bvX2/8CoCbnZURbm7soH7uewuA/YBLgGDCHfnYdmcbzued52h4fBW+6BxCDer0YOFscOXTAP3fmf9zuA8fAaxVi86kw7m8cziTewbD/xyOn/wt/g823z3vJMOs/gnBFZItgoPhZcpZHLeqX88MgE3UCYXb1ePB9VFw1zRFCx/70/e7vhP7u2XdIwlryFtxZQV3F5uJju3My05NwLtIcfDevnnsTUyLn4YRf41w3m+gRqHrK66ssHPUdTfpoC3fDP0Glx+5jCnezYBT3+NCwrvovqE7pv09jbf94KjBAKyBFLbUeoI3b4sPkIfzekZ2WmEnPox8EATBMT3Zwvd879+/H3/99Rdv++osNtmsXbsWycnJzLXZanT4YGvUnWFN8mpixgN6f/qcBksTmUTm8N4AwM6dO3HqlPMowJoiCjf1CJP50sLSc0tRWFXIqLyvKhX4W6pHckmyywNAmHcY9k113QH1aNZRnMw5ydnGOHs6WDW0D2qPdkHtUKGvwMdnP4ZlB+ZzkiSdvjDslTC1E/8qwJUB5on9T+CVw1YN18O7H2ZWkomFichT52F32m6HxxDyZ6CT9rkaUVAmtV4324GaStBlZP5iQ99r2s7uI/dhma5ISvNiobiqGGdzz+JmMTfd/dncsxj651DG1MIhujf10ybpo9uwNGJjVNSqr39kf96mZtKMUzmneAdXdrX5gZsHYnXS6pr1yxmcScx678fEUZXdaed0NnQ0G0274Ha8/it8z6fEwVDqdvkFNyf/tkFtmQWKM6oTnaM1aVGqLYVaQ2kM9lqiOmlzuxD1nqWWb9gw6WFb+oQP+pnVGDUI9QrF5WOXcebAGUT4RDBtAjwCAFB+hJx0GySJEm0JsiqzBEPE4+Pj8dtvvwGg3gVau8EeN3OzcrHu13X4/vvvceyYa8kyT58+jffffx+xsdbv31GeGdpk6Y5DMS3AmEHYvFdWaM2Nt9zbztnYFn9/f8ydOxdabd3mwxGFm3pgSqspAKjaRXwYzAag+TDMiQzHu3kJeCnhJeybsg9Pd7LPaDkkaojdNndMU878foQww2yfoyTvKvOrp8yTd8VCT+IKicJeuLFpw5yLNNslH3RGYVUh40C85toa7Lq7y2FEw6GMQ+izyarBoiNAPGWeTHKsh/c8jNcOv8YJbXdGkZar7k23+E6AJLFnyh5snrAZuybvsougI0FSdXBodFat08X8i3jqwFNMdBvNW8ffQom2BAuOLLDvCC1keVECtcFkwJvH3sT2O9tdvhZLx5nfzJa+CgmF8anxePbgs5jy9xSnR112aZnTNjRjm40FAMxsM9PlfZDJ70czsflEJM1Lwq/jfrX7zDYTdYhnCDOh3SmzJohjP6+z287GT6N+quXCoASeK6PepeqEgh/KOMT5O8InApsnbsafE/+0W2C5wi/XfsHwv4bju3uUFlDlpMo282wLPCcuj1dmEyWcOIP5PljjiNwLjMnJka+WTZSPhJCgiVcTnDhwAnu37UWQh3Vx4CP3QbBnMDxlnnZ+TXmqPJTryu2SKdL3YOzYsZgxYwZzDlvTzddLvsaTU57E4cOHkZycjOnTp2PixIkwGh0HQrz33nt46aWX4OHBMsvXckQix/xo+e44321wK5gsf5fryp1+v0OHDkVgYCDWrl3rsF1NaRzGsX85Qi95tG80MiszMSp2FFBoNR9V6CoQ4ROBodFD8XPSz5x9bMMwy3XldrlvHMFOJEgLG/Q2R+aCE9kncDr3tF07D7MZWokEI2NH4ttL39rtRxfpdCcMXmVQuS3c2GIymxw6sdo6T9M2aDNpxsbxG9HpV6qa+j8Z/7jlA2XrI5HPKr8Q7RsNWBZMGRUZ8FP4QSaRWVf2JtZAxtJqCQ1WDs07NlWxD9w7gL1pe7E3bS8mt3KjsB1LyBqnUqNlk87oEMI/4R7OpCKKajtKploaAClLsBUwcdq+l7bP6PWi68z3eTLbqu1kC+l9IvrYJcOsMYQESnpR4GQVzIdthI5SqqyWkESz/jpVTPR8hWNNDc2ZnDMAYKchpvGQebiWxbboDhVZGdaR+33aUplD/WSnjyAIUMKNs4neDNs1/j8J/+DixYuoqqrCRx9RWvW5c+ciKSkJZrMZnTt3xt69e5GrysWsJ2bh0plLOH+SEqZ9/HzQrlM7dO9LaQbpIpZyuRxyuRwkSeJ26W2OP6CZNGPg8IF4+Z2X0SmsEySEBG+88QZat26N3377DfPmzePt+b3Ue0hISMD69dZir0f2H4GUkILoS+DYsWMoLy/HxIkT0aJFC6SkpOCPnX/AQBgwbfI0hMZx3RD0ej12796N1NRUREdHY9y4cfDz82MEsaunL2L7hU2A3BMmpQnN2zWnrtMvBqi0nj9JmYQBfQYgISEBKpUKo0aNQuvWXFP2nDlzsHLlSjz//PNOvp/qI2pu6hESJNZdW4cu67vgvZPvIcqHyqQboAwA7h7mbe9s2/Xi63j/1PvV6s/SQUsxZ7c1MsuRlz17ImWHRvMNHVNbTcWeyVQ4Or3K1Zl0TESJ7TpqTrs5HHX5sD+H4e/Uv129DF6uFV0T/OziXGHBSWfS4YHtD3C2dQrphB9HuubMKlh12UY71T2sO9oHt2cEG7VBDbDNeqzB704ppTWwFfgchgkXp3B+0hXpm/k1423+2bnP7NIMAACqrCamk56e+FGTwkxetjhyJMxR5XD+FuoHH15yL/gp/Nyb6GlBpUlbzn3NU+chISMBVwquOD0EO78R7VAPUOZlugTIjjs7sP3O9tqtcB3cgvlmXXEwzazMtCvEaouZNMNMmqsVDUQ74WZq8gCvEKtWUABnpURc/h5pE4g7UXJseF4PZ1XRSZLEvbJ70Og10Og1KKwohFarhclkwsY/NuKV117BqFGjcOPGDej11HhpMpmg0+mg0+lw985dLHhiAZa8sYRzXNosZTAb7AId9CY9eg/sDZnM+v7ExsYiMjISd+8KC5QnEk6gefPmiIy0ahwPxh/Ex29/jNGjR+PSpUvYtWsXOnXqhPfffx8TJkzAjVs3sHvrbgzvNxylpdZ3Ozc3F926dcOXX36JnJwcrFu3Du3bt8ft29Ys6mazCVqtDlqtFsm3kvHqE69S18kaIw7GH8Tbi97G6NGjcf78eRw6dAhdunTB6dOnOX0fOnQorl69ipwc7rhQm4iam3qAduotrirGnrQ9MJNm7EjZwTj28mk1Xj38qp16GQAGNx3M3WAzVvUJ74OzeWeZv1/q+hISMhNwo/iG3bFMZhOuFllNS+wyDbaczjltty1VLoNOYl8UtEVAC0T7RVu6Z92ep86D2qDGw3ExeK60HC+GD4LepGcciNlZP2lkhMzlHDVszucLVxUnQToUfmzLZJzPO48WAS1cOq/t4Mn+Zl9JeAUJmQl4vMPjWNBzAa4XWZMR9g7vDQS3oBIcVmRxNDdCETNRvlHCfg/l2Zw/HVZHv7sLG29SDshz2s3hTj4srQldQ0tIk+TIId3WudRZmD6bOL849I/sjxg/x87zHAQi8j468xETXk0XcKShayfRsN+ZMG9uYUL6Ph7JOoIjWUcwptkYQSd4t80EnabhYNkF4O5uXCm84rS5reO87fnKtGUY9AeVI2r35N3u3UfOcQG8mQocfRNI38v57HTOaaxOWo3/9fsfxsaNxdGso7zlXEiSRJm2jNEuOQyhN2oB0ggY+XNFMZiN1Pui9Lc65Rt1lNYHoH6SJnjKPJn3k9aM0bdKQkhgJs3wlnuj7+C+6NCtA8qKy/DMm88wmkqj2YiC/AKcvXIWzZs1R646FzqjDr0G9EKvAdZIu5cXvoyh3Yfi2eefRYfeXI2Zq3mLzp8/j/T0dPTta++UTVcUv3PzDkcjQi8uKisqcfnOZYSEUFr+du3aYdWqVUhOTka2MRtmsxlje4zFpk2b8OKLLwIA5s+fj169emHdunXM8Z5//nksXLgQm7dtBgD07t8Lc0Y/BHgG4nbpbTwx/wmM7zMe1x6ZBqKztZp5WWkZbiffRpMmlHl/6tSp+P7779Gvn1XDSff76tWrHOGsNhGFm3qge2h3XCq4hJ7hPbkJ9iwv1qrEVdjT1JolVWPU8Ao2ADVpj4gdgTx1Hjbc2GAXLcUWbGg+H/w5Ht79sN2Kis4bQ+PIycx2UjydcxrPRFkfyu0pVl8Oj1t7ccMjDO2bj+YIXybShM/Pfw4AWBnoj2flXhjyxxBICAm2TtqKUVtG8ZwY1Ur77mglfaXgCpMLxxWOZx/HqqurXGprq71g7pqHPxIyEwAAfyT/gQU9F/AP2LQw4cIK+4+Rq6H7dQIUrcbYf+hvX19LiJ+vWk2fdtqXJlaBN83iPyRkduoT3gcbbmxAp5BOTs/pjgbhcsFl/JPxD+WzJjQOqousUTOAVTgsvEnl+5Hb+8QMiR6CvWl77bY76yNJ2ofya4wahxF+QpzKPoUlZ5ZgSf8l6B3Rm9lOT4KuCIG2woxt39gOzbQGx2g2um3yIkECKf8Aavv6VM8cfAYA8MaxNxhfQb7xpMpYhYf3POzWeWuLsw/bj400SqkSVcYqh/fEZDahe5/u8AjxgNqghs6SBZsgCKSlpOHi6YsoKSoBaSbh6eWJC5cvYED3AYxpimps/VUhVcBD5mFnRiwsLMSsWbPwwAMPYNw4+xIhSqkSRrMRleWVCPALYLbT/kF9B/RlBBsA6NChA2QyGQICApBdlA2JRIKWbVoiPT0dAKDT6RAfH49Zs2bh008/ZZ7vsrIynDlzhtE06QkCt++k4Pj5q7hx7wYMBgM8vTxx9eYddGEJN30H9GUEGwDo1q0bdu/mBnf4+PhAKpWipMRNZ3s3EM1S9YCQgx39MKZXpOO4wjWJns6v8MrhV7D+xnp8dNY+uRibXHUuonyieFXFrqwKhdiXzo3QYhekXFKZhJnHqeKY7HpVJtLEqWRb6hcGlUGFCn0FXjr0Eu95nKW2F8LR5PnUgafsVumOcJTc0BZblXOswUCp8r25vlLXi69zVtzMs0ELkS5M/h5Jf8G/MBmep76z/9DXkm8jnJoc6fB9vuzCbEGQAMG9Xvo4AC5YEjays/Wy6RjSET+M+EEwuRvNJwM/cZio0han5UtOLQe+aAGc+p61E0u4FdAODI4ajOmtp3PKL1QZq3Cr5Jbd83O7xKqeT69Id+vd6RPeR/Cz3Wm7ka3K5ka86VQILqUyVPcI7eHyeWhshSy28HPw3kE8uvdR9NnUx/08NCQJbJwKv3v2Wlyaoqoil6IvGwqlRIZokxkRThx1hQgIDrDbtmHlBswYMQOnjpxCeVk5tFotCIJAeWk5b5oLmhDPECikCsanjCAIlJaUYvTo0YiMjMTvv//O2wfaKdzX3xflFfZ+d17e3O9fJpPBx4dKSUGX5vBQeMBgoMx9RUVF0Ov1IAgCKpUKarUaGo0GLVq0wAsvvMBcw4ZVG9BjwHAcOHAAlWWV0Ol0IAgCJWXl8GY5ZrOLhNLnp89Fo1arYTKZEBhYdxmORc1NPUD7q9jVd6pGOostt7fgf/3+x2tm4mPrna12uW6EyFfnu1w3Zlj0MGy7s81hm79T/0aIZwgivCOQq86FyWxC/8j+OHjvIIYqw0A0HwbkUNFb1Slx4AgzaYaH1IPX1OUu7oTy2g5mUyrVgMw+/4atM/DZvLNA9iWgjPadcGVisG+TWJiII5lH0EpbhfGsNkIJ1wDKsZ02xX176Vv8cu0XLOq1CHPbz+UNSxYyswR7BjMlMmy5Vmw1A75z4h3MbTdX0DHZFlqLuS99H2a0mWHf4MC7lp+Lgf7zHR6L3feJzSdiYvOJWHp2KTbd2gQAeGTPI0guTcbXQ7/mCFNsM6e7ZqZ3+76Ld/u+y/sZXZ6Ekxvkxk6Q6ccBfz/Xxgib7thGCbKFjCNZR3C1kDJFn8k9QwUzuIiRNGF0dCRGqDVo5tcSA5tav+tOIZ2QVJSEUbGjGMGPTwD0lHli3Zh1zN/tgtsxDrYtA1ty+05HY/o1ZaL+eCm8DZi0gHcobuqt/h/t6Am1SVtASkVrVlRmI0sqgRcBxBmNoG8eHfhAa1HcCYD44csf8P6X72PitIkAqBwwm1ZTz5PWqBWMpLNd7GoqNBg1dRS8vb2xd+9eOyGBaWcR1lu0boEtp7Yw230UPvBR+IA0ufd8BgYGQiqVYtiwYbzOy/RY9eOXP2LliuWY8+g8FGgKUKgpxO9rKAHMXTH2zh3Kj7Bjx45OWlYfUXNTD9B+EZtubuIMjM4c7xzhjkMmmx5hwitBR06J7BexdWBrp455APDuiXfx7MFnmZwQRtKaapwoSQNZVLsCDZsBTQdgdrvZdXZ8IWzNYWS3uUCf5wCjjbM232igtQg8oe2teWoAtAlqw3uuZ7N2oVNcDLo3s2oebhTfwOqk1fgnxeKQnZfEuy8bdnFGWgPHhJ1X2Qt2QpP7vrR96L+pP29oepGm5hFUgho0OnqJPYn4sDLFCmgQkkuS8c3FbzhRPbSQ/XeKA4f2GigkOv3aCZ1+7WRNhGmBM5lqipgouxPZJ9w6fofgDvYpG1hUd9ygyZXJcNDbC/EP7sSi3tYyHHH+cQAovytH+W8Ik4Gqhm355yX3glwih4fMA2bSDC+5l/WfVEn9k3lyt9v+A0m105YjyjcKHjIPRHo1se4v94GX3MuhwELXSqLHZB9fH2jUzktqmM1m6LQ6hAVSPln+Sn/s374fqkpqIWvrLyiTyBhhR21UM+UXKsor8PiUx+Hl5YW9e/cymhZHDBg+AKmpqYxT7r2Ke1DpVVAZVA4XM7Z4eXlh7Nix+Pbbb1FVZa1ibjabcfHiRSilSuY6vX39YCbN0Bq12LN9DyorKO1fuJvlF44dO4b27dsjOpq/aG1tIAo39Qi7kCPADS8FgFW5BUhqMtalY42Po9bldBSMqzgKsXa0IuWknwfp1somS0UlpDOZTcwqkgCgzHI9hJ0PR9E5AyIH1GgSYkMPfK7QuUlnJgX72GZj8Vj+QVw8+TlQksq00Rg1TNZdDrRJy+a66InDNjPwFS3laGxgfRfM/a1kCQJ/z0cz/2aCfWZrDeiotS5NulC+KhnCfgq2ZFZmotJQyZ9U0IYdKTtcPi6NoJmj5xPUzz7PWbeFsbVC3GSTNDeKb+CXa78wQv2gpoMYp+gBTQdwtAijY0ezjubeg1WqLUVGRQan0j1droQumMp12CdwS0n5ftCRco5g92dss7F2SRbZn3dp0oX53V/h71L/bQuLGgjCTmBkm6Ic5Zfiy3hN42rhSDvo8xFS67hE90/mAUit75Pe8rlGIqE+s0k8SpuVew/ojQunL+Dz9z7HRx99xPin2J1aIsFDsx/CopcX4dfPf8V7L7+HJW8tgZ+/cLZkOgy+TFsGtUENkiSx4MkFuHX9FgYMGIBly5bho48+wkcffWTnq6I1ahmft+atm2PIkCHYuHEj9xpIk6DPIZ292rZ8xMqVK6HVatG5c2csWLAAL7zwArp06YJ9+/ZBJpEx1/nsc8/hhddewCvPvoJP3/kU/gHUM6RhjUGuzA2//fYbnn3WvvxNbSKapeoZx7lJ3DiQpW2+Jr9G/WHjaMVHT7AAVfH6VvEtt49vIk04m0tNlgneXvg2aSsOSyRYPfoN/JbMb192RKxvLFLLU3k/IwgCa6/XTpIodyoz+yn8GD8h2i/p6YhQXLKZDL648IX9zvRqyyanh9D5CYkMsAnfp5+vTDnrGJfWI2zQywCAQKW9jXto1FB8c/EbAMDwmOHYk7aHit76sjXA87wKaZIcmRZts1fbmWhrhOXesgdV2wG29B5w8ltAal2N087t1l0IxPrFokBTgABlAPyV1smf/fzzCVkFmgKklKUgQBmAtkFtoTfpGefU1468ZreooAUO2rxMV02nOlL9NedXF7/CiNgRiPKJ4iaItCAlpAjyCEKJtoRJUOj0mEO+gok0YdLWsSjSV8DfZEa3Tb0Q5ROF+MnxAKzffb4mH/0i+uFQxiFO+LwjpBIpTGaTsDOvs1IkvuFAeSanHpuQ+Glgf6LwFrzXA0cMxE9//oTEC4lMKPjQsUNBmkm79/G9z9/D7AdnIykpCXFxcXjs9cewd8dedOzGNblIBJIfKqQKDB45GJ27d4ZUJuVk7rX1VbHVri9ZsgSPPPIIXnnlFZjM1j4aTAZGuz5lyhQoFNx7+8CUB9Au2qqxjYqKQmJiInbt2oUbN24gJCQEr7zyCtq0acOMZ4s/W4yxQyfg0s3z6Ni9I15d/CoSdiWgV4cWjNA4bNwwbv1BAAMGDIC/v/VdOnnyJPLy8vDUU0/x3o/aQhRu6plh0cPQJ6IPWgS0wNMHqKiCKJ8YbLhxCnlSGQ5InasTdSYdZ5JaPXo1njpQ8wfF0Yo0zj8OTX2aIluVjWJtMTxV/NmGHRHtG42RsSNx4N4B9KrSggAQYjYjUF09j3khwaZdUDu0C2rH+5krRPlEMdomgIr6qDS45nxJgrRLxW8gCJgdVAdmoPN5ZF8ECm4BoVSkUouAFvh++Pd2wifBMzAfy6LStt9UcgczZmXN8x1fyLdq0DirLhvBZoCmCie9PDGumX0EhzNss//WKswqldV3tmM3SQK/zwIKbmBkcASO+8nRKrAVclXcbLLn886jY4h1QhKKVOK7hysTV+Jw5mHICBm2TNqCh3Y+hNltZ+OdPu+4X+jQzdpS7YLaIdw7nDHbjd82HjPbzMTivovt2iqkCrcdfmUSGUwmEzr7NkNC8VWkKeSA2chJmRDtG41bJbcQ5x/nOEOxO9XTCSkV9eZIE2Q5Ew1tVlLTvnZ0+QUnAqPtd+Sv9MfIYSMxbsQ4JghiRtgMlGpL4ae018oMHjMYvUb0gp/CD/cq7uGRZx/hfF5UVIQmTZrwBkjIJDI8+tyjAKh0HI7K2NjuP3DQQLz99ttUPpwmwKiJlA8Vuxo5nRkZoPziiquKMWfuHLsinwqFAlOmTMGUKdwM4/Q5CYLA0OEj0Gu8tXTJ4889jmbqUty2CG5Tp0xFlC83UnPQoEEYNMjqn5WXl4f169fDy8v96EJ3EM1S9QA7bfzwmOGY024OJ+9HlioDc2PiMLtpOBbm8YeAs+m5sSenDo67hQirg9lsRnN/a6Xl6mQ8Zb9MJKhkfuc9lLhwZ0fNO8jiZslNxN+Nd2ufNoFWbQQdUUAzofkEl4+TWZGJgir7vDQfXqPCrWe1mcUkgLOHNdmwfFTO553H/IT5PIUebTCbQJZn8h6ZHvT5sjazQ3bpGjt87aok1BmZ2mL1BC1MTWoxib9BhsWkk8QqTJiawGpAAgWUhmRKcS6S5iVh2yR7Z3gJIcH5PMpx+E7ZHTT1aco8s2wzoq0ZaNmwZYz5yEgasSqRShvw+y33tZEAAEKC+SVlAIAoVsFOIaQSqV3NqD+S/2B+p5OFApRz/KpRq7DlgS0cbZQjfr/1O/r/3h8JxVedtiVAOI9ucxlaI+f0pAzeMkp740cvBEizvb8bjaYYyLnMSUJHE+UbhUifSE50p5fcC4EegVT5BRsNaK46F6XaUrvyC+Wl5XjjjTewa9cuPPjggzWOIOPTbj333HNo1676izlnsE1YBEiQJpuFbVALxjSuMqicXuPUqVMxZMiQWu+nLaJwU8eUaEs44be0gGCbRC7bJm/vdL92eLRc2OGY7ddgW6KhuqgNaofnO559HABl93XFoZiPN49RYcIXPD1wVy7HExFhOOPpvhbIGe4OIhqjdUW5cTzXhm27wnFESjmPLw2AbdlU+HSWKgtNfQUmLHafWTZzQY2a7Srw+nZAzZ/wj9fHxwL7WTqVc8puGw2d+KzKWGX3mTNqUu+GTicg6GPVzpJRusUw1glZ5xMwv9hqFtjP9K2SW7hbfpfRhiRkWIUlto/SkOghGB4znLPvsBiqH73CrYndhKCrjXO1cgR8Lf33ltV8desl92L8cII8gvDI3kcwLX6ayyZtOsEjQGnvZDzvltWXjmCisYR8rzxt/EFoPxc7J1i6nZnff4ShzJJJmlW0kiAISvNji5lHg6qx1xzrTXq7tA4BygBE+kTCV+ELuZQ/Is02Z41MQuWX2bNnD4aMGgK10X6MNbvyrlsgbPokNM65Y0p3Bu0L5UGSdkdVG9Scauwms4kzljYkonBTx7yc8DJHy/LX7b8w9I+hmL1bOJLHR+6D98MGY4jGtUnkVon7/i8AMC6Oa15wlFOGLfhczL/o8CXsU6VFC739asm2WvTroa6FnVeHzcmb3WqfWWnVeEyPn875rHVga3w99GuXjnPonr3m7a/sXIwLp7JzDogcILwzO9qHNWjRdvYzudyyB4TtwMaTXI2GnkTZGioa9iQ3NGooAGBeB/uQ0FsK4QRnVJdt+sOalGwnUnZBQmfIJXIoJArhGlNM4kP2JGjpS0RXQKZgnLSLJBJcKbjCG9FDkiQGWcKbR8aMREaFtfzCgKbW762pT1P0i6C+z/1p+7E/fT9/t1yYYB5s8SAAYEwzViJGpQ/TfdIF7UdmRaZdVm3bbNF8ZklXJ0B2lNpJL08Yefr0T8Y/AKjUE840yUqb54R2QJYRNsIr/T64kevKmXDg4WLiwjuld3Cr5Bbn2vPV+cioyHC4CAS4QnhQUBDeffddDB48GPcq7iG70j6/lkt1tmgcmKxcgTa/uZ3jyBFa7vftMOt0PSIKN3VMYmEi5+8dKTtQrHVug38z9x88GeFeJJS7DI7ilnJwlFmWjuqgsa0VxKazToenyuy1TmzfDgAgWWOko8in+sY20d2J7BP2A68AtskNg0wmHPTywhHL/fvs/GfYfXc3365Am7FAKG3usw7S+Wr+FXYT2yrrYR3xgIoaeKMM/BMCn6lA8Lv8oByYtYn5U+JE+cKpOF1yF/iiOZBAJZm0jbgRNs3Z08yvGSY0n4CuoU72sfWzAaz+K3O2AMPexbtdRuKRvY/gwR0P2u1eqivl5rbJs+a2ifCO4LRll194/ejrnHxKbC2GEJ423x1HMOw2FwcGUwUFb5fehjNKdfZmFXZUVIm2hAl3TyxIZDRvjt7h6lKsLcaklpT5UKgch85lc5WL7WgNjYc/I1gVago5JUxolJb3WGEb7SXQJ7YvjtqgRqW+EnqTHmqDWjB/DXuRyI60rI2khjoHVdLdGUNrVAuNsLmOEvvEoI2BBhduKisrcfz4cZw+fRqVlc6lycTEROzYsYPzLyEhwel+9xMqgwp7VfzOsrWJbRK+QA/Xs0U6Umk31xvQQa9H0jxujhVbNS/7FVk9ejXvsQT9LOqR/en78fLhl6u1b4lUip8C/VFl1jlvDLAyFDsffDY0nYR/MrJxKt2idSIkCDJR+0WCGvCPe3rgT18fh06e7EHXLoImzOpga2DtuuX2FsxPmI9dd3cx24ZEUXb0tkFtgRPfUr4Mx6ioMFsna3fMVKdyTmF7ynaOJoXDIUuRwkQeH5ecy4BORZmshrwJeFk1RuxyBzT0/TGTZod9tL2PFSyTCK1F4SuF8mj7R/FI+0fQKqAVdR5L8jj6Jw2dOJItpAjh7F6ya5OxNVY1ybPlCF855cPFq51TeKPKRgNHO79W23Qp90AVQSCNEAqBZmmrWAKPAUCGTAYVTC6Z2WmhsKiqCCq9yiWNi6N8MzKJrNrmfT7YCVidCTrunJe+p1rC4k9F2mqPGl8maqABo6VIksSCBQuwefNmtGrVChqNBqmpqfj+++8xd+5cwf1+/PFHxMfHo1cvqz07NjYWw4cPr49u35fQReFsYa9M3cXRqvTt0BAQJAlb90PbhFbsV+KrC1/xHqum1cFrA1uVf11xKucU+tP31SJwfH3ha07dLja+UgV86eRZWRcBg8ZaTdoygbwQTq2eZ1hKJtjmWgK4kwqdf+bX67/iqdjxlLBFSADSjAqpdVD78PSHAIDUslRMbE5lZm0T1AZfDfmKcsg+/xv3JDaPyzOdnxG4C7UF6+nSllOmHnAFuYFNB8JL5oXEwkSmAjhdVPNK4RWOo/Xlgss4n3cePcN6Irk0mZP4jzqbcHLOnuE9mWfojV5vcD6jQ8Hp/CMAALMZQSpKYzCoogzIuQJEdnXtskH5BAV5BGHX3V2YEDeBc83sftbED8oRDqOxeCZdemzSm/Tc0hG0b5cLCenS5HKQDrQaNHJChmijEVKSRK5MhkqJBJWkAR6omblHCEfamgjvCHjIPJjvniCI6uf6cRFvuTfUBrVbC1n2c2KAFIC9RsyDJKGtsQN57dKgwk1sbCzu3r0LT4tD6bJly/DEE09gyJAhDjMX9uvXD1u2bBH8/N+Or9z10GTAdRVkrjrXYfFMNiNjRzr0ayEJAm8dfwuhXqHMytGR5iapyHkm3X87RO5VIJ++D9TdcTlXz2pKuK/09QZBkvDTce3ebJ8iW5p4NrErMVGmKwO+5o/ACPMKYzR37OOGeIZgdDNLsrvQK5x9kgq53+8/9/7hhF07gnZk35e+D5NbTXZpH7usxKd/AI5+BsRYI4SmtZ6Gaa2n4bNzn3GcZgFK28E2KZzJPYMzuWewbNgypkI4e9HQLrgdzuedh7fcG7F+sZxjvdf3PbzT+x1eKwttwuDsk3IQyDgF+PqAyE0EfhpCmQhdRG1Q44/kP/BH8h8o0hShT4S1tpWrppHfbv6GL85/wfUFYhHqGYpRzaylG7o06YLEwkT0i+iHiwVUTh/evEfVyeHjrM9mE2QEyUlmKYTapEO2jJr22I7NdVUHq8pUxS2c6QClVMkxj2VXZqNcX44wrzDG5EtAWE9CP3sKqcJxIsUaoPMo42hugjyCAL3rtffqkwYzS0kkErz66quMYAMAs2fPhsFgQFKS44muoqICBw4cwNmzZ6FS1WYysNpBb9K75LBVnXwhANwSbGzhcyilSS4RTsLG1tRE+0bDy4Uojt13d3NU4ibSVrhpXJJ+fcKX4MxDbxFIovsAzYfZfW7Lm3kJ6BQXg16x1lDfcokUJEHA1ybChJ6Q+RBKyieEkEly993dGPHnCLx38j2rpiG4JQDYhchWB8HyIHzVuH3Z10sC+98GtGVAhTV/UXp5OlYmrsSRzCMu9+Fo1lFmdmE7OL/g2w5rei7GpvGbGH+iJp5NmHZyqRwyQoZBmweh06+dcKvkFgpLUpjoNI7PR3kWSix5Q0578vt1sHE0MX918SvOyptt5nWkfV13fR1MpAl70vbYfeZjNuPQgzvxVu+3mG3tg6mq0KFeoZy6d5cLLqNcV+7aAqu6w4FRC3+b592P7dMk4ITLNo+5uqjjw9F9dBSkUWWscvh5ma4MJEkyGYltkRASTk6cu+V3ca/iHvOeGM1GZKuyOQ7Q1dHWcdMMmEEQ9pq08GoWIq1LGtznhs3Ro5RKuG3btg7bnT17Fp9++ikeffRRxMTEYNOmTQ7b63Q6VFRUcP7VJWO2jkH/3/s7jRrYm77XbttYmYMCcSyGR1fPDOesQCXbRnwi+wRm75qNlNIUNA+w5rghSVI4csUBti+ybUjo/cYkPf89aBnQ0uF+BAh0D+1uv50ed3jSwgP2dYHOaKkVk5bOfNrBmnyLsEz4npZBn52QbnUS17+J7dxKO0638m/h8Br4yKykcvzsTdtrNT/whd4Cgqa2atHJEt02jJW0rmkPQKrEU+GheOTYAhRKqXvEHtpTylKw4soKJmHj6KBO8LX4LA2NHsrrt+At9+adICISlqJ3YRqaBzRn3g1amK/QV6BAU4AKTSGTP2jp2aXYc/gdZv9zuedYRyORqqBW3hc8PQA3Jl66EKcQU1tPZX53tEBh+0ixNT9U76z/07AnePbY8L+T/4PaoLaWnjAIR4Da+mW5jCP/ErknwIqQ0rOESPo3KSGpvmBlwZmPS0ZGBjLSuD5jRVVFSC5Jht6SZVxr1NpptwHuuMm+67TAmJKSgqKiIm44esFNFKjzUKYtQ3p5OrMPHckkWKeNRlsB6CpdujaAuq/3Uu+htLi0WnNDXdA4egEgMzMTL7/8Mp566ik0b95csN3UqVORnZ2NhIQEJCcn480338Tjjz+OGzeEq2QvXboU/v7+zL+6LNYFgJG0k4qSEOMb49a+xTyhgnzwRUjUlI/PfozBmwczEQLzE+bjWvE1fHr+U04ejo4hHbnp4l3EVnPzUKUaezKzMUHlOLSysZJG8K9WnIVCkiB5yy9k6u2/06YOkrgRtk6BEhlUlkR7eQruZzE+1md+2aVlnM9onxkAGN+cqlnWmyV8kQDypM59AehEdjqTDgiIpSKUplGFOG0HPHcqrTuHp/yC5e9EpQJXSm5yJjWa/536H7e50hctLOnum3g2QYyf/bvbKaQTM4mwJ50yiRSJV9cjtSyVmXTUBjVUehUG/D4AI/4agYFbrNq6SwWX8KXqJudvALiUfwmnVfegZt+vFsJavA03NuCt41YNCp+TMC2M0WY2+pmyTVbJhq1J+nLwl0iYngBvy/MWZTCi/9YxmLTDqgWiq76XaEvQM6wnAK6WyPbdZ0M/G0LRR+DbbjZbzVV+jhIdcr93I8tx24M0Q0mSCFD42WlfcrNykZkubMq1xZEGBgA+//xzfPm/L3k/Y/vZ5Obn4s6dO3ZlF4TIyclB//79OSUbAErA0euFrRoEQUCtV6NAU8CTwsFI1cIrTuFNcMiGTvCnIwicO3kObzzzBrfCfQPSKISb/Px8jB49Gp07d8by5csdth01ahSnYuqiRYvg4+NjV2CMzdtvv43y8nLmX2am6w9tTSBJEstHOL4eW867oIYGXCuo5y5qgxoqg4pZVdODU9+IvpxEdlqTFqll7kdzdQ6xag+8zWbMq6hEtNGEiEam0nQ1aV+SnP/1yVFXL8Q2V1+GCx5KHMw/B+RSKQQivCPgIfXAi11fxJIBS7g72E7Yt/fhlMXMe1pCDY5VFq2OIzMpO/Td6gxKTQIGAJ3jYjAqxnmmXA43/wZ+mwac+AaAe4kQhchWCQj+tAaQR4ChtVrpllpbQy25o5r6NLUL/71SZn2nhLRrJEnyam7WBPhhrr8UD+18iEkHoDPp8OuNX51cFZd5++bhmYwdKJaxhUlhU8Kl/EvC94XmwHsAqChMW8HWFfyV/gj0CEQvfyrCK1mpQKWhkvPc0BFS3UK7ce5P2yBKC89oB032UYNOTSW2PitmE5B3FbrCW4ymuchG+NbQ5zEbBX12/E1mtDQYEK7wo0LHWfz07U/4+sOvOVoL2gnXVjvmiqknNjYWzZo34/1MIVHg0J5DmDxkMnp07YFx48ahSZMm+O3n33jbs3n//fcxY8YMREVxSx4YBTRRdMZlH7kP0ivSUagptLcwsO9XaTpMOmFLBy3IV0okmPzwZKSnpOPwwcNO+10fNLhwU1BQgOHDhyMqKgo7duyAUuleaBxBEPD390dBAX9mVgBQKpXw8/Pj/KsPfBW+iPOPw6PtH631Y9du4UEutGqUnuhM13fAWMlVY7qaup1NhxBryQa1RAIDgOsKBZLc/M7rgj7hVtW7bU6bF7u+WKvnahXYine71mzA4xFhWBDWBPfyKeFm7di1eKfPO1hxZQV+viqcifqopwcnQ6stbN8nW9iV5emVPx32ut3X9YronEFeoMJ5dRgfN575/XoRj8awwKIBOce6PzfjORWo6fX6nAoVkuYlYd9Ubj4iAMivKsQVD+pZvF2SjBYBLezy25DgCjd9I/ri04Ii3FJYHTjZWqr2Qe0Fr6urD9fxmG0SHqGmtH8BJhNQmi54DNvqznzEZFvjFlcnrcZ3w7/Dlge2MIKHM7anbEe3Dd1wpOSaYBt2yQV2nh+OAKnXCJop3UKvhgEkUiRm3C6h8gDZmriDPINhBpBOmJFefpfX58dMEKiQSKBhVWsHgIK8ApQWlaKivAIFtwtw4cIFVFZWoii7COW55fCQeaA0pxR3blLCcGFeIa5duYZrV67hXuo9GFmLNVqjM3PmTMx/YT4nXJtNyq0UfL7yc2TlZCElJQVf/PAFPn33U5w5xk3c6ctyFC4vLcdvv/2GJ598ktmWnZGNrHuUmbWioBRpKWkczUxaahpys7j+bxJCgtzcXFy4cAEXLlzAnTu3OddQZdJBp9Xh2pVrqCivAFsbdjflLu4Um6AnCMhkMoyfOh5fffuVXabmhqBBM6cVFhZi+PDhiIyMxN9//81xLqa5cuUKSkpKMHz4cJjNZpSVlSEoyJo/ITExEenp6eje3X6V1VAopUroTDqEeoVCpVdVy5lyIuELsjIPu33qX8VHS/f0IG3OS8QOzT3Q0ZIkSdZKfoZUhRyzmtZ8RV8bsCekDeM3YNifVlNAdQQ5IXqF90KIZwiv5u3nfGt4cZa2GLEAPjj1Abbe2cp/MIN18l4V4I8hVfZ5N8KMRuTLZA59rfbfs2bYPZxJrbr2Zx3GEgDFUv71D12o0TYZHYPK4nR8fRswfW2NolHY1blP557mCMkAgM6zqGKj0SzfEJvJzJWze0iV0FqEhYsFF5GjyrF7dwkQnCiq0c1GY8KpP7HO37pgoms5DYgcAMKBucJk08fn/3me+T3EEuLvYzZzcg3ZQkeSOcJXVQg0sZrYpv5N+d0cnnFYcLJls/mW82zfbIHmjkUDtjN1J0ZEUKY40lAFqCiNuZdcBg3rfaP31Zl0/JXBSRMAVvSPRMrNklx2D55SKao4yhsCpEQGtUQCGLXUOQhwsh0XWLQ93vpyjtYvYW8CLp29BKPRiFdefAUSQoIffvgBP/zwA+7evYuqqiqUlpYitk0svvv1Oxw/dByb11L3qKKsAhVlFVj8+WKMnzIexVXFCPcOx2effYaMzAxs+HOD3eWZSBOeXfAsZ1v/0f0RERWBC6cvoN/gftYPpAomNP74oePw8fFBt27dmI9/+PwH3Lt7D/pKFXQGE/ILChHTLAarfliF559/HhqtBvl5+ejTvw9W/LYCJpgglUixd+9e/PDDDwCAkpJilJYU44dP3sbsh8aCIAgolAos+3gZTEYTVm9dA4mEQNLlJDwy4RFs37YdcRHUGNl/aH+s/3E9isqKEBlch8VyXcBt4cZsNuPMmTM4duwYsrIoCTE6OhqDBw9Gnz59BMu626LT6TBy5EgUFhbi3Xffxf791gG2W7duiI2lVjXLly/HmTNncO3aNZhMJvTv3x9TpkxBhw4dkJGRgW+//RYjR47E9OnThU5V77QJagO9SQ+FVIG3jr/F5M5wFV+TGUvNXjiuUtepcDOg6QCczD5pt53OLPrXbaoQ4SY/X3jLlABJDfxHs45ieIywQ3Oc3kBVDrbB1uv/+TD+DKY0kypVuCeXI9Gj7jU7p3NPM7/P28stPfD60ddr7Tz9I/u7lHXWzxKhwM4MbTuREawpe4Ka32+JHrKDPYQd1dnh3N1Du+NSwSW81OEJ4M4iSAWkguc6P4cPTn+A3uH2ifAA2JWCsP3ubQs9OsJpmQBmYmJ1VkCYKpcQKC+6CW9v+2ePJM0YqdbgH28vDIkeyhud5a/0R4uAFhgWPQyHMw/jWOYxhAuYkmUSGQrPfC/Y7SQ11zx+Ntc+6R8VUVg3UYWO7it78cKXG8kW+v3ZfGszp2r2jeIbeCDwAehZETseZhIlJCWIawwamEkz9CY9dCYdpAYppBIpdX65N2BQQ1NVSml8jDrANxwgjdAbtdASJjtnVzqxXpWxClVGHbR0UkaYIYUUHjwh0mob8+Ssx2ch+XoyyorLsPq31Yj2jQZBEPj6u69x/PhxrP1jLXoNt+ZZmzJnCqbMsTrzH913FK8/+zp69e+FJuHWwpsao4bXhMhXzqGooAhFBUVoGt2UU8eKXXIl6VISOnW2zyqfdCkJu/5cibFjp6C4ikTbtm0xcuRIHD58GH6t/FCUX4SJ/SZi3859GPUgFc7/xBNP4IknnqAOYKjCzo0r8fCL72Bovx7w9o8EQRD45PtPMGXoFKxbsRazHp+FRc8uwtS5UzFx1BBct+SJatepHYxGIy5dvITI0feJcGMwGLBixQosW7YM9+7dQ6tWrRAWRqmzDx48iLfffhvNmjXDK6+8ghdeeAFyueM4e71ej7i4OMTFxeGPP/7gfObj48MIN926dYO3NzXBy+VynDt3DqtXr8a+ffsQGBiI5cuXY9q0abVQgbb2+HnUzyBBwkPq4bZgQ7NYm4qd4Y4n/5oyqOkgjnDjq/Dl9c3QEQTKSK76+0LeBbt2NL21Wl7hZuGRhZy/na2mbwZG4o6xbiPb+KATutUFznwegkgJSggzPCyDtm0pCDb+EgWKTdzok8mVKtxUBiGIoFbAeZacHlUOitmxa5Mx5gWFD/BBOZomvANk2ldYpx1E2e+dbaVkNkOih3CcqLuHua5p5XPspXnt8GvQl6RgOWxrbXGfLnLQAuDAJ1gQ2gTnds8AYFusEtCZDZCzNBDsYpk0tEBAa2SOZB3BkfBQxLAcQNnZoOPLbwIergtyNPuaRAG6cmTLZby+RO5QIrDgzFZlc0tmWDCZTRjdbDQqdBXoGd4TC44scPlcuepcPNHxCZzIPsHR6sllHoCeelb1BIHH9j0meIxBTQfhh5E/MH8P3TkJVSZ7rSRAmf3+6PE2k+Nm/uH5vGPYxblU7h1PN/O/sI9lMBvQpVcXjmBD428y4nZBMUoKSxAcHgxPb08kXkzEyAkj3TofQCkQ/vfa/xAeGY6xD41lMj2TJIkK1ntcXFiMkGB7zVuvAb0waOJMGKUe8JQb0KdvH4Ck8sNdL7qOkLAQdOjSATeu3cCoB0fBYDIAMjNITQlyiipQkJ+HpuGh8PH2wplLSRjRjDKjNwlvgg+/+RALn1qI08dOQyaX4Y0P3wBK7wEy6v77BfhBIpEgM6d+/Fod4bJw07FjR0RGRuLjjz/G+PHjERAQwPm8tLQUe/bswerVq/Hjjz/i1i3HxRx9fX2xY8cOp+d98UWuv4Ofnx8WLHD9ZWsIHtjxAAo0Bfhj4h/OG/NQKZVgpxu+DtXFNvvvl0O+hFKq5LXFD5OH4LDBuvqOv2s/4dH00Orwh599+KptfSp2bakvQgbijaITnM8bQrBpSNgradKFMPlfIsfi2dsbkKxUMGHk4RZzRpSUay5ylJYgQBnADOK0/w0ttLSJHcYr3Gy5TSXRZOeIGdNsDP68/SdvKHxNkorRpjKA68Oi0quYgo35UinCb7KeZ9vaQTH9OCHBABX5ZK8NozCb9LyOohmVGehH9gOZdYGjUClkObTSfktHso7YCTbTWk9j7p0j6O+rq1YHpP0G8sEVeP6f5yEhJFgxYoVbizk6aZ0t7LpJbH5O+hkrE1eiT3gfvN3nbZfPQ0M73oZ6hcKHoMYxhcR671UuavddUViRIAG5ByoJF315BDR6tCuB0DkIEDCZTWgabe9Yf+nsJbz/yvsoKS5BWEQY5Ao51JVqFOXz56exhf1dFlYVYuFLC5F0KQlrd6yFp5enYPSRQqGAlmWKjvShNCXBocFAaQbUPiHIqioCoSAQFsjNc+Xl7YUqi3O9zqTDyX9244nn5qOwpBRNm0ZBKSVRoVIjN7+I8x4MHzcc/YcMxNGDh7F+13p4eHoAej0A6vs1Gowwm81Q1oO23RkuCzerVq3C0KFDBT8PDAzEnDlzMGfOHBw+3Di8pRsKvgq8DUmf8D68dW7YybYA4NmDlN1366StaB3QCu2D2+NG8Q08qFLDQ1cIeLo2oL5ZjWrfq8uFnRX/K5AgUULQ/gfOQ0GDpZ5IVlKDyu9+vni40upkbvvslVjyqwDAlFZWFTrKMjElbgKWXV0JwFr4c+21tZjTbDxahndDR70J1xTcaBQ+U0Wcfxw+GvARlRDtsoCfkAXaSTtPnYdyXTlCPEN4tQhsPhv0Gfo37S94jVyoz0KNRhTIZGgi9wNMes4e/SL7QSlVIqUshSmPsMdiBr5RdA0+nva1kZIKruDri1+jirDJ1yKRgXZbduRM+b/9X2NLHL8mykvmBY2Nhm2sxdxYrC1mSj5U6Cs4fkjOIAVeWyEB6a9kyhzNN2bwHp8lMJhIE3Nc/vILlJC7bsw6AFRm55vF1LPU1Lcp/BR+VGI6kgT01LUfmbQdKLckX/SPBmRKqItTkCGX26UY+H6Y1QzYxmBAso0FQSaQg8XRs5RZmclkkCYk9vfs3ZfexehJo/HKu68wbhlDOwyF2Sy8QJEQEkZzyDYBLpy/EPt37ceabWvQog2Va4q+j7Z9bBrbFGcOWR2OOWZGswGVlpQU7DB1T7knqgxVHGETAOY98xKmTxyBjxe9CEloW6DoNiK6jaYcsVnf4+0bt3H62EkEhQTh7z/+Rvc+lAZWTlIZovNyqMCT2Dius3xD4HK0lCPBxpZhw5xnV/03Q2dwLdUK5wiwfbjqElcHKRrCbAJWDkJsDiVwxBiMIHTVz4osBPvVTzaU1frxp7aa6rxRI0LJ0m54SPnXHSRJ4oNTH9hFTlVYHH+LpRIQJIkmNgvZq0XWiJkP+1N1oVCWAXzbEfKjlLmIne8mX5MPfNYMmi9bwsdmshbKvdPEqwkebPkg5Y8V3Zd7/kJupTHaHDrl7ymYFj8NzxwUrjVF+6LsTbNPeimIZUDurdVhQJNu8E6xNzE90v4RfDPsGwyOGmz3Wb5QdNntvUwkGZtmlizPMokMzfybWbdLravu03HCNfMA4PkuVofiQIsGjtbIsXOhsLVgfOHqtribKpM9iS4+sViw3Zx2c+y2xfnH4WI+ZQLKqMxg8hmZ6Ugwy08PmQc8ZB7Qm/TM754yT3jJvSyTvbUPXqpCeEmV1D+PQHjJveFp2UchVQBmM1Plmz6Wh8wDnlIl83uxthiFmkJUCkWXGbnbPTw8mIghlYN8MSaTCdkZ2RgwbAAj2CRfT0ZRAaW1ifblz6lGEAQifCIQ4RPB3O+PF32M/fH7sXrrarRu35ppW6LjzwnVa0AvJF1NgtoiAHvKKS2Pr5mERiJBuQNTNBsZZEjLyMLowX2pa5B54uqN28gr4Gqe9Do9Fj23COOnTMAPv/+AHZt34NxB6t2kxaqrF68iKCQI7Trwl26pT2o1WurYsWNYs2YNfv3VvdwO/1YcpRyXSWRMZsrGRurdg2iVnwQ0CQaU3nb1TEI8QwRTgrtDXeu1XK2p1RB0C+2GywWXOdt0ZgMIkgRJEJA1H8Z7j5NLk5noqXw/q/mQzhWUI5OBJAhEkNx1C2+emwzLqs+ysmNX+Ka56KHEGZsoRqG8KvGp8ViZuBKDogbhrfZPcD4TKp1A98sVJ+sjWUeg0quY5HPsyBoPWy2BLxWFt7SwGJj5HrCcSizHbpWrysWBewdwKOMQ7/n+SOYxK2srALm9yfi54J6Qxk5EeFQfTk4fb1ZaAS9CgemRwtGB09tMR/ew7jBd/RPfpvyBUqkUFzw98HCliqOhYDuYCkarsTD7RoDvbRNyKGYLNztTd/K2+aLP+xjbdrpd+3DvcFzIt/fHUxu14KkR7iB3Ef9mSKQAaeb23KRDICTIZy0IPKUK6FhlAkqqKAEhhOe7A4AAs5mJngKAFm1aYO/2vTh5+CSCg4MR04tf2yaVStG9T3es+GwFSJJESVEJln2yDDI51Rd6jGeH+Uf5RsFD6gGtUQuZRIaSqhJ88f4X+GvDX/i/b/4PBoMB165QC8ug4CAgmn9B0ad/b8TExGDnzp14+OGHkVKaQjknEwTnWoSgnbHlMjkG9OuN979aif/JPFGsvYV33n4TcrkMZgAeCm9Aq8VXH36FqqoqvP3JW/D28caLb76I1+e/gbEHf0d4eBgy5DIciD+AB2Y80Ch8YGuc5yYvLw+fffYZWrdujWHDhiElJaU2+nXfwlHFXt8h2M5W/UzTTcvvOFef5Jz4HACQaMk/k6RUYCArD4yzbJyu4mOuW/GmVlP889DHWL3XhwCBkTH2joadPSNAWgaFSfHTOOHoADXAKXISmb8Paax1kgZqtDgaOAUmy6qeHlxoJ1vaKRGwRsHBMkkqecwHQQp/7PfyxE2F6xrGrMosZFRmUBoWdnVjnuPzVXvfcGMDxm4d6zApHbtYq5SQYkTMCIyQBlAr97GfWhs2Gwh4BOC5sCZ45uyHKOXx87hXeQ9fXviSOd+k0N5QWJ7JkU0H8Z7fU8BnI/bwZxiSlYQ2QW0gZQ2rRtaqv9Sswy2l8P1cnbQaO1N2IkzmxUzUB729cFcu42QEH7tlLEb8OQJFVUXoGd7TaTi3iSUMsfM5CflBzWgzw+HxKKz3gT3m7b67mzcCEzKFzV72OI2Kk3kwflOcZ5b1rNHHkIBAhtx+7W7imXSlPKaqSTMmYfLDk7HmuzX438L/4ebNm2ga2xTRsfaamC9//hIt27bE8k+XY8+2PXjjwzcwbMwwBIUEQW1QgyRJjvZHQkiQr8lHalkqkkuS4avwRea9TLRu3xobft6AJa8vYf7F/2n1d7M185EElcR2xYoVzLamsU0R0SwaMlbb6GbRaNasGQCgylL+Ijw2HJFR1mim/1v1KSLbtcJ7n32LTZt/x1fvv4aRY4bCEBYKgEBqcioSLyTi0x8+hbfFdPvky09i8LBBWL72D5gJIDc7F+eOn8Pcp+e6VHuwrqmW5sZkMmHv3r1Ys2YNdu3aBaPRiJ9//hmTJk1CaGjdRvg0dtjaAuLKb4gMb4ocuJZKu7FAv/45lsEhwcsT98xWNX27oHac0Onq8pBKhVFqDZaEBOFSNSJKGpoK0gAm+Y8bCJVfuMdTfoFNtiobqy5TPgWeEjkkck/ASA2aZgJILdRAG059e8UWJ1JaWGIP6UtOL8H01tOZiWJWpQofh3DX1SX6crwe1gSucC73HHpH9Gbym1CmCJIqv+BB+YbYruToek5sViauRIW+Am8cfQNv9X6LUw+LD5lEhm+HfQv89ThAXgWfB+pZTw8YixIxODYKT5eVcybXRccWcdoSnkFobdDjmlKJKC+uAyZNW69IAPZaMJVEguRb2+DR7WGEbH4UtJoiXyqx5GkBhqY7zjhL1/yKCOoFDcu348GoSOCgNQ9KQRX1LpIkiSaeTeAj93GoSZVPXQPsfQQAZaJu5tcM6RXpvNWqdSYdclT2Gbbj/OM4kXtvnP0/rLy1CTse2iHorzKrohJHQ6gkiPTVaBys6Mv15awwcp5jGrX8GYcDYgBaM8iomUmYeJ4HPrfjAI8AQMVNXaBQKvDKu68AoJ6zNkFt4N2c37E3JCwEH375PxhZY/+I8VR+H5VeBRIkqqqq4GMJEiFAcOYJb7k3vvv1O84xm3g1scuazFcw+amnnsLevXtx+fJlKKIVeOGNFwAAUpIEvQR95d1X7HJDvf3x28wi1UgaERIWgve/eB9BUiUifJoChbfQahJVEb7SpEOLNi2w+QA335FEIsFHP36MJiYTtAAOxh/Ec68/h4ioCJfqUdU1bi097969i3fffRcxMTF49NFHER0djStXrgCgbvJ/XbAB7J2+lkWMdmv/y41gkqft/HPLqagPrUSC63prZAVbLV5d/EwmPFdWgRYGI5rr7y/hj+am3H3BxhHlAuGubPaYqSgawqS3CxGeJT2MCxbH372GQiDEarcv5qvltPnhGvTWSlJRkv3GQ0uo8gt3jwAEwcmCLATtP5JUlISfk4SzMdPoTXqsTFyJT/UZGB0dieVF57gNCIKT7O3nAH8MtESX8IWt77y3D9cs2kqhKfhLKb/v2SY/X0wL9sLEA49iC2kVUlWk+1rOZSXnUeqCWSFfk4+L+RcZZ2hBDtmU7XDgP1eqLcWOlB122/UmPQb4c6vHp5anMv3ggyCtmmiFxTzn6KoqHGTYZjDa+8yQAKPporUbGgGHfFvtUIjJhHDPUIdmHFoICPAIEGxjFqidpdfpcejQIZw5dgadulM5aWwrdQP2tdf4yFfb32czzNi+fTsnkR8AGAQe4DBv6j1kJ6K0c4C3ZJGmtWNyJyamQqkUKokEjz73KOY9Pw/BnsE1io6sLdwSblq2bIndu3dj6dKlyMnJwXfffYcOHTo43/E/BFu4CTCZ0VYZjOb+woVAGyOEzU9bapJtlqZCKoUBQKpcxtT9aazo8sc12LmFBj0NQYDUW02b23x84EXouJExRc79WGqDywWXMXfPXBy8d9C6kan3RFfjdv7MsLU77JUtu/wCG71JjxVXVuA3YwFyZTKsKj5v/fDaVt6if0VSKZLSMnBs1jGHfUkuS8WTHZ+0264WeCmus8xN7Cavm12PamJDl1+QkaRgIkWhOle2NEvnBhR8k3oNW8ZtQscQ+8zHQqahbFU2TpbzZ7kWylnDTj9IWnxPHE2TjoQHBosQYVsI1dbnKsyLX+toW8CzSCqFhsdBnA+2f1O0jSnQLHBlJcUlWPLhEjww/QFMnUsFONia9Sv1lXb+gWytDT0G8I0FQmOxUH/4YJuQSJMetloztQu+i1rW98GbZboBcEu4adeuHW7duoV9+/bh9OnTtTLJ/dtg35NmBgOyjSqUscJw64LQWi486W15mOvaJSxZocBDUZG44GKx0IbCpG24TJuOnKL1rNw1vgJhp80cacUsmp0pymlu94suMQAAN4tvIrEwkduAXjkf/xow6nnHCttBnu1UzE4sGKbgFxD4Kk0nFSZxz2/Db/6+LhmJjxdeFPSLsyXMaIS/yXr/pZbJYUDTAWidL1z2whGRlnfaz2wWdM4kCIJXy2KLp020z+SoCEzb+zBTQ66mCGWb3uTvax1D6OfTwZShNTrWXJZIJMjTlUFrqw0rTYOn7fNPSBDO80qYeML08yrtTaQSno76Kqy5u7zLuaa7UBP/vQyPDMeRo0fwyruvQCHgb8V2NuaDAAGzUcubYqCwqhC3S287NEsGKAOQq8rlCEwkSEa7wjEhkfa/ujvL56pyeSMK6xu3hJvr168jISEBnp6emDRpEtq0aYPPP/+8rvp239LMrxliDQZ8FxSAsVnbmHDIuqLEBRU2Hy38W/Bupwfq9ax6OWxcqWfjCk9H3B9mTK/YNQ3dBV7Yg85j5fwqfUEBNeUfRrMzwWO/3ce0k6VMYAHz1wN/oXUgJRzRPiAc6IHYoAZMOjsBnwCBrbetuXCa6Q0cR2JOoc9y+8lHiIf3WExtDhZeJVHdoTE4Flz63DmBnjK++B57Oum4kw5puet+cj+oXTA38EEI/F4d+HxPBM9by1EuFy1m9gIzJbjky1wYq0gSKEm121wulaDYoILOklQPAOQSGfUbT7f9eR4BmcT+/FU8QjJb80FP/kUaqwBxyw1H+5oiISS4U8ofqFOqLYXBZBAsjBvoEYgQzxCUaEtQoClgTFsao4YRqtiLDD1pYt4dWjtW4aKQz6YxKD7cfvP69++PNWvWIDc3F2+88Qa2bdsGAHjggQewZs0ah9W5/wsopArsfGgndmblYjNPlt66wFjNAWlI9BDe7fX1WDbeQO2GI9Lk+t33BDtKhGJ6BbVK94AEZoC3DAYAIJ0nooVF++AOGB07GkN9+U2qJEiXwrepxmYMjR7K2dQjrAenKOXvOXkQQmhVzMeE5hOYHgoxUl6EPpv6CH4OUNqXhddWOGxD84+3F9QsB2BSaXnvCWCTf/Uyje8LpxYeJVIpDALX4jS6yEKJVILOIZRz9ieF1gmaz6m7OpOSK/4iNJUOshMzmhuDhkngx8ZIJ0clzXbCjNFmQ546D1oejUh1ro/WENKZp+sbg9ngdIy3vS5aICNJklczxNbasWvLqSUS6G3b290z589dlek+09yw8fHxwdNPP40zZ84gKSkJLVu2xKJFixAREVGb/bsveXDzUHSNi7FXlTYyDqQf4N3en6e6dF3AiVwpdhwp5Ij3+r5X8840Egg3cvP8qPNiTJL0cBNroP6OkXryRoYwsJxKaU3DA80fwJAoSuCN9o1G7/DeGNeM39/FkSqdzuZqPYGZNx8LnS5+pFoDHweTzsGiK8zv7YJYycGy7POp7L67G7vv7hY8FptWga0EP3N3CmSXODAPfQsAlXTwtE2OIHaiREcUVFEmhM5agaRzcF3LkiaXM0kcQ43Wp4LPQdXWh6d/ZH+7NrbcLb8r+JkZzs1RdtgGLPhQuYFoTUKlKo/RrBjMRpAyD16h6Z4bvnyOgiRowcFRCgxX8soIUVvasghv69xL1z4r05XxCrGO/GLUNokObXtHmuveR7I2ND9uCTdC6aQ7duyIb775Bjk5Odi0aVONO3W/Q1gqIjetZV+Y2obvoQcAjWWgcOivUQuwH98/alBLa0abGfhu2HfOG94HZLuitrcQWpiMAsuk+qs/pS2gK4U7zicC4Lx9NFL83Xim0OuetD346OxHyJIS6M7zGL99nL/m0OI+i6lMu+wBmyTttAyvdH+F8SfKkslQ6XCApz77Or8QA5oOQIW+Ap+c/QSf732Kt/X14uvMatPRM9w7vDcGRA7gNc+muOnkTrLNHWd+ZH5tLeP6Cy1O+BHuMLVSJfiZq7lE2M/Cp8HCxU0B+0nFaSLMFP4EiDQakwZG0ghSQCPpzzenEJTHS4ZMhgyZDKRttm6z0aZfrk+EQuUX6hJnwgtdfkEukdcohJrtI8Z+6tlaGvo9DPXiugTEcJJ+UvfTx/LdeDbAPdNoqGtxVoDbEW7dyfDwcIwbNw4TJ07EmDFj4OfH9clQKBSYOXNmtTvzb0Bj0CDNkh/G0AiyNFYH2pmuhcGAdCGzRi3AHpJqcp7Myky8fPhlu+0v+nfCqoqbMFYjHPd+gGQJDHThxlyLsNPUKDwpXcx2XUumO/IRomUyXLIRPu0ciC3MbGt5/0vyqYglADCbcLWYW37hYv5FqAzUxH1LqcBTEaEI9ghiQtbZSQcvkZSJYq+PN0aBesd+v/U7ICAQG2/8DUip1X5HvV7w2Xqm8zOAugjfbBqDVJuFbJ5AsUkhIvximZDsmOJ0wJIjqInUA7eNlOP3P3FzsECz2qXj0bV6+EaQblotyKAWUEgVaBXYCndK7zg8Fvs9Y/vf8E26dPZn5m+BjL6ApfzCximAQK0sAFCZVLhZcRP+nv5Q+ylgJrjPZTlImE10AAMBrZbKZWMykii3dC+oOBMygNnXaCahN5GMVqjKBEglpEvjbYnB3twFACa9FmYH+2u1WpgN7mviI70jodfpHe5r0BlgNpihUChgNBuhN1Yvc71SoUSoIhSSsiwmRxmNn8IPJtKEKkMVzDBDr7X2SQoJ5IYqmC2ChFnhAa2RhJEkYZaYYQRh1cABALRguylJQNpFZxkkBmil7lsASJKERqNBQUEBAgICIK2BRsytN3jHjh2Ij4/HkiVLMGfOHAwaNAgTJ07ExIkT0aqVsIr3vwR7InVHLdqYuK1QIMSBacrbbIba1cq+DnA0mLgDEyFjQ2nhDRgVtRMR0ljoHtqdqa7+bWAAsz3YMkEkWxwdvc0mbBLw+cogq0DrKtQEgWVBAbztAOCHQP7PhIpDTvt7GoZED8H8nvOBXQsAkABpRgqPQ+Tl7FPM7zeUSoDleN8uuB1OZZ/iFMo86O0FtUHtNEP27yjHO0aq30sLizFiwDt4LXGZXbuikhQkXF2Lg4QagM27qvAG4LpQ/HTYQCjiJiGmOB3t05Yz29lTQpDUE6e8HJdLWKWRAxXZ+C7QH9eVSly2qa7sbTZjfW4B0Pt/gE8kfOXO/fpIvygA1PdldvLK+Sp84afwY/xL6KrrtnydX4hRI0YBWOr43CCxNX8roj2j4afygUYiEawKToCAtExKaWYqChmtpMRohARg/q4kSZSbzSi2THxSo5GqpVSDMcnPbEaFwP5SiRSyMhkKVO77k2oUGvgp/Dj7Bsi8UMbSsmiVWlTqKqGSqWAkjQ4Lr3L6RUhgYmmwCkCdw4MkOaHZACDzoe5dcVUxDCYDjB5GJtBFRkhBGnTM/YUXIKsoRLFUCh1BwMdsFvzOFBI5/AxaVEgknPB8tVwNtZJfkHSFgIAAhIcLlypxBbeEm/79+6N///5YunQpMjIyEB8fj127duGdd95BTEwMI+gMGjQIMjdXPv8WGoOXeE1Jk8vQvwqCqfdrQ7ABgACTCYW18Jyczz/Pu31THQs2zfR1q9myJdQzFItbTMMUi3Bz+P/ZO+swqc2ujd/J6Lobyy6Luy/ubi0VKFWkFOqFlvpXV+rCW6PuLrSlSmmxUrR4sSLLuvvuSOT7I5OZJJNkMrJG87suLnYymUxmJnme8xy5T4RnohzVyCXw8VffCYLGD4IQRBJFub/rt2Oi8VgZN7DxLTb8RSnn5mjlUdipRtxEJnvORia08eOpHxFZuB9QEK38M/9P/Jn/J57qNl+0/bOjn4nyQIY12rBdRkqgqPwo4qLScEeYE7/LGDYAkHfkOzyS8x3gWoRcnJSNz0q5PJ7pfRbgxPHPvMTWlOi84Wn07jJLJJwIAGxjhTv4X6qh6mSzsxxL7Q5UucJc30i8UzaCwKz2aSCOvoGv+l2E/sn93cauEqxg0hEuuEiFrITzu5yP9/95X/WYBAB8uQgAEE/TqhWbVVQVHjnxCDYWO3DUYsWTScrtIr674Dug5Cgaf7oNt6RzOSSf5xfCChbL07kcrVENDbixshp3uJ7/Kr8Av0aEY3VsLEwGE5wKMgBKRJAmXFpRhjdj5SUHkiOS8ebUN7H8m+V+HZfnq/O+wvJvPa+9O6YPnqw+6H78zLhnUFhdiDK6zK1SHSzhLIMGQTjp8dGPI9Yai0d/exQA95lK6r2NNRLAW9PfQcJPl7q/71l19fghUl6deV7HWbhiyxuYnS6Wy7hj6B0YkD4goHM3mUxBeWx4Ap5ZMjMzccMNN+CGG25AQ0MD1q1bh7Vr1+KKK65AfX09pk2bhs8+k2k8d5ZzNhg3PFLXJk9XhwPHQ1AKeX5dPSbXN+Di9OCS0JUG6abG2Gx1ZRwljSV4c91yIDIC8TQNK8O6JV/5EBXlmsekOSzRxnCUulbv30VFuo0bub5SwXK69gzsa66GGQCx6Ecg3Luk+ljlMcx1OH223TCe3Ch6zLCMKH/nlaIS/B4RjtuTxRPmlEQrMmkWZ1QSRe/KkfQeC0tEd7sDRy1mdN72NsZl9cOPFfvlXyzBTpDI/fcnGIv2Qng1s6ZwgObCUtNO+85H/DAmGt0dTlH1lRCaIHDGZALsFSBAoH9if5/HjOx/CXDMu5mxXFjKQTvcOSBC4q3xIkmLW1KS0I1i8VUVp+flS46CZmmYGwpwS0I71DgKFfezWq2AxQS6PheFLgeGuT4XJMuiysaikSTRpboC5vp69/OWulxQRCQKwxthMVhgV+r8rcCSvkvg3PAUCsPljU/STMJqtaJQ5bzVsBN20WtpKlP02E7a8ez+Z0Xfby+7nfNm+uC6/tfh1X3eeVxpFOUOUQPAlb9fiUhTpDsUXI96t3cukjChjuUMwh6WBCRU/gtrXS4KHdz1YamvQqE5Vvb9Xzz6JkhDlXtfnuToZO63bEFCMiuEh4fjvPPOwxtvvIG8vDysX78evXr1CsWh2xzC2GRSK08o9sVVVdWy2+Np/2PPclQYDOgRgqRlf0pRQ8m/zah1wfOjawVFSGwS/hfhwxj5hPjaOwGJq7vX+dxxQnhukzInuf/OzsrEnUkJnJaO0YLEcO/V+shG35NQRIy48ooAIZqU34mNwZPx8kmyZwzKn85isHiVvH525mccdQmt/cXUaDZsAGB1bDRmpqdgagyDdwXhwEjC/xXofUkJqNKwcj1VfUq2A7cXG7VrkRXVF8m2vqiwVSA7UvxbHDP6vnpGNnhKgn+IDEeNlhW5wQRacOjPoiOxMiEOjS6PcbgpUnTdsgTwqKs3mr+GzVU19Vg+aDmeSFDWNOL1l+Z0nePXsXmkSdmPVO8VPV78y2IvLbQhKlVyQi7pcYns9kIZj3idsw5TO3DtgIaleaQQXoz3/H3EXo79eZyOWYbTZfDY1cfo52XuP2HOXEvh16ywYMECbNqkLltOEAQGDx6MBx54IKgTa6sIL2TZSoA2gHTibCq+iorEeh85CFpoKeOmJSk3GkT9Y36J5CpnNP90EZyxUWYI3Xe3/oy4cuanyAhP+wUZD1GBhsowQuYTCT11L8XFoMyPCjMA2JCTh11X7FJUMQaAd2PlBSyVEObSCDVJJjsJpDTRIkdOoVmOjk4nzu10rmjbl+d+if5J3l4ftXYOu+pyZLcred8sDCOaZL/0URHZOSIdVbYqrzDmc/Fx+FJgMHasq8C/knBwoLIbn0aG4Uj5YU379ojv4f472g/tJem1X8H4NlzeUxBQlbJx39uazwMAfs3xyH8kWBMAADGkeJHGur5//qw3hfvvgZnx9Qws+UW+mrG58FuheNy4cejevTuefPJJFBfLN0zTAUiWVUxQa+3ww5Fib6kQvtcKjZ2n1Whq44ZpyGjS4wdKuWAV7G94yZkxFCUGA/5RkIQPGdtfAxorZZOAn/FRlgwAJ6u8lWqD1QXx9N9qeiv+bqIcxU2Uf0iAwIeHP/S5n5VhcePAG9EvzjM5z/1+LsJt3g00AwmrhysYFnaSFIlItqPUDYIT9fm44qcrAFa9Y1YCzaBRcA0YWSCCCey3rCdJ3PPV+V7bI2Q+k1C0crBGzwqgra9aoNx/xDvcqAWWZd3eoipG7NVdcvoLjMtMR54rPyvQs99etN33Tk2IX7PC7t27sWfPHkydOhVPPvkk2rdvjwsuuABr164F7Ycle7aTQtFIoWlP9nkbg58olRLsdrSyXlBNbdyQ4bm+d2oBhNVmyyqq/HrtgqPvYFJmumLSeILRO4Hw0dJyxSaOchhZFij5B7tzN2PlDvWqmkSFie+kjAoyL/6nRLxrLFKadBviOvjs5xMMWr8iUxCaJgBA/P2Bpv32Wi0wkSbM73KB+IlnuwFl4io2vydi0qT5mtAyQ+TU5HCijyrGSq7J6NbmDrdHwQDAppCjpIVjMga+sGiCz0H64tgX7m1/RIg1hm6srFI8vk+toBbgn9zN7t96SfkWr+eFOVRfNpPSfqjxe1YYMGAA/ve//6GwsBDvv/8+6urqMHv2bGRmZuKee+7ByZPKapX/BRLDEvFbfjF+zS3wvXMrpa2lRGfFZLX0KYSMTgHmIPFD+7waZdE3IQcbuDwCpdLkzvE9MLb9WIyyesoxhV2etdDV9Vmu3f6Qz32/yNeWrMmClU14FZLdaEMHp9MtRillVhSNQR8M0vR+gaD1/nH6KGn3+T47X9e033WpyZj4xUTU2GswX9CDLMdoBA5/Jz6mv3f/NZtgsmrrfL7TjwRTM5T7ml2Tmoyr0lIAeMKWSqXKUgb44XHh0ZLH84GKAdCUnptAqWwF7RGamoCXvBaLBZdeeinWrVuHkydPYsmSJXj11VfRpUuXUJ5fm+SKlAQM7pABaxvNuZnQ0LYu/BFpI1r6FEJGVYA5MLzREYoEbQDIjO2IaVnTsLCLJ4myjiBwmynd72PZGHXdjtm1dUhUuFeiJdu7x3UHAQJX9bkKsxXUe88zJuKJet/fY4ZVuSQ5mHuXDWWWttr7+Ln/I/tfxgeCXI48k9GdE+U+pp9hqTNhkahweoe35KjVem3HKosCSqm31PmhRiQfbgK8FXv9pVolUbq5PDcX1Wj7HQAgzUeI8GwgaH9+TU0Nfv31V/z888+orKxEz549fb/oLMdJAA6SQJazbVZLWYO8Gcc1s3HUPqp9s75fUxJoh/e3XZOWXAKuGvEK4eQvj32Je7bcg5PhURhKc+e0MjEeT1D5svvz3Fpeibk1tehhdyBNYyJthcHgJTrG0z15oPvvhdU1GNN+DCpsFWDAwKwwEf/QcwIujfX9PQ4UVIxIsQWRL9dc6/Rg34cFgDRxUrG/xs3Jk+uCPAsZ9n8KB7Q3BL4qTbth8qdSAUMTSnhEm7Unp8dbfOehKWH3IxftrvIK3zv5QWtcyAd0B7Msi40bN2LBggVIS0vDrbfeij59+uDPP//EoUOHQn2ObYqShhJN+gStmWCrpTaGoALKH8oby2W3X2/tgJcmviT73NlGnkuTKNeVBBir8htuycl1h7+m1KsLy1E/3Yn+teKBMDslW3H/RTW1OK+uHkcsZhxzJZN2jVD39mwJD8M1qfKJ5Wx8R89+rlyvans13jn4jmIugDHnL9X347m55wJN+/lL+yZe1PS229HD7oCVZTUbkIq4quactBNnas4g1hrr3+v/eCy495dw6+BbgYNf+1WMkReC3EZnnXJX+mC4sOuFiLFoC9sBQG9BRZa/jGi04dHScjxZUuZ7ZwDJYcqeS3+Rtl9oDfhl3OTl5eGxxx5D165dMX78eBw7dgwvvPACCgsL8dZbb2HkSN8dZM927JQnPnukqStRmohtYVbsbUPnfqLKW9ofAGyVOeid2LuZz6Zl4MM3O1w6N4McjKJXpsRgxK0VlVhZUoaOTvUw1jMJcXhDkliuJg8/Py0F77q8SKyr8/ANmd6dxcemjxE9VionZgVhkxNmMxqcDT5zGL5jtPXOqpbpih0s77ebgXMUDMZzo8TqxekBaKi2c1L4tKAYXxQUIddoktUz0Qr3LXKT0g3rb8Csb2bhkrXyuilKFGooaxbSxeGjtQBLA42VfiV3haJw4yaVhGAAQICeiSMVR7y23dB+quy+QxP7eTWY9Ye7kxNxb1KCbMHHgYXiFjUEgBntJwT8Xjy9YrrglaIS3FqhvV9dc+GXcdOhQwe88MILOPfcc3Hw4EFs27YNS5cuRWRk4B2dzzZYpu3HMt+Kjcb8dsH19WhO/t4h7515OwxYn6PetbipmGUKLobvL8NcvcD4aT+XYEQhrmTBCn9NVATGNtpwTn0D0p3+X6/7y5TF7fZaLVjvqiTJJ7mzWXniC6/9NuVv1vReeyvEGiSfHf1MFDoJpnN9wZFvRY8XCpJtA6UPqZxY+n2tuPIrMgDHebmBxNx2qbg8LQU3KXi7NDPgcsDEeVn/KuS8XcUN/hl8jyf6J9YW7qNku8ZRC9TkN2sKbgSjwe9AEIgJoCK4kWr0SkhOa5AXRx2cNgybCrfKPucPX8noCZ2oOoErel7hfvxoYryiITVWklagtEgCgAmpQzGm0YZOMouk1IiWnUP8urs++eQT5Ofn4/nnn0fv3v+NFbG/MD6SJ9sCviTxzZIBaphKk01fRIVA7Zg8uUHxuUe3Pxr08QPhB6f/TfaCgXX/zw1Yx83i1WwHm8cT935MNFbHRmNFciJyFVpshIz536DYURXwywdJjBeGZUQq4G8UleD/ygLLH/i/M995bQu0Wo2nfOvzmvcNZAK3kySOCkJ+wcDu/Qgo0q7CHAr2W9VD9m8cfAtI6y/qeN/UXFbv8B2KJwgkB2DcnKo+hdwasZSE0lu9KqMMHSrO//Z8/HraI+BXbDCgkbYhU8Yoea6kFJdXe5KTZ9Yp91d7+ejH+CQq0iss9ey4Z/He9MA0eEKFX8bNvHnzYBboYhQXF+Ovv7TFt/8rsIJkXPIs6jMlpLvEtdzNl6tZhX52/0szpbRNqcTQwl9pBxTCiQaDeIB6KS4W6yLCsS2EmkWDbN5G7u7ygzJ7aic6Rlw588LfL2BTnkcl/bPoKLzpp5owj7R9xnsx0TgZpNEwJTMdb2hUl40lAjcsg0l4FsHQijlrUvqGNdNK/NQmNGd66rI6Ox5MSvC530vFpQEdXyq0+EzVnoCOEywljSUYnz4aAHf9fHbyO65PmYTNYWGiwoQPfVzPjyfGY6/EaO2d2NunHlVTE9AdUllZiXPOOQepqamiPJvZs2fjzz//DNnJtUWEYalYV5x2eGNw1UO97Xbcln1bUMcIJQckF/KvEkErfxgmMyH6C9kKdSSam80+krj/tih03w6hcSPn8fuuILjxYHWddz7Vt/96wklvxka3OrFMpcovKRN6zGviM1FngN0O1BZi8S+LNe1/oLFpkm5bmhO0787v60+vw26rJaAw6FfHvxI9rm5B7/6GfG/BPqn2z/sxUfjCR6sMKa/GifPyzvnmHNy2sWXnrICMm9tvvx0AcOKEWBr9pptuwiOPPBL8WbVhhC5zPudhW1hw1UPJFI2FVOutwArGgfycQtNDf/ClkGom20Zy9Kf5wU8exQp9lpS0V+ggWxn4Iun0X7AEUSb6N+WdqKiW0Nwa0KpzE0irg1ASzbBAZQ5OVnPCq8lhyfjsnM+COmYXY2BeNCnN+c3cJNMCxiT5bW7euAL/l5SIR8rK0ceovfqpLVArUXfeY7XCHqRnkGIo/HL6l6COESwBfYIffvgBr776Kjp16iTaPmTIEGzerC1R8GyFbKq78ptrmujAwTO71vfKJxC05uP4mku09iLqjpY1gtoHUdZ7f1kFPoqOdHdOluLvZTlGQasoys8DbQuzYnmlfAJloBTUt131byHVbNO1gNDKb4c8IZPUiFS/1XQfLxWXHf9LBZ+UDXiLNzYluTKhGafCmDG/XSoOUqG9nluaEwotWNo6ARk3VVVViInhrFfhxFFTUwNDgCJkZwudojPRKwR5JEKUbrTWwrVVTXOza1U0TfSR6KdFPh0AKjV2WW4qghnQCQBPqXjBzlFJCpTDoORV8PMc91ktza6AoXjuzYTWd1999OMmPQ9fHDOZcIvAa9Ejvgdq7P4ZJwmTHwPZBL9wBMsiTu9X6BddGD37UEhA38aQIUPw9ddfA/AYNyzLYuXKlbrWDcuGXMQv3xp4TosavgTctPB2YTGCr9tQZpLgHAlHLO6VqYwJRVJyIkWjhGjZwfTm5OBEtdRu5tENjVjpEvdS6tkj5IDrGo4ziq+9Zb70QGR40kf3b2FlRiho6lCbL9pKBtic9mmix58f+xxXr7var2M8cPQDME30iZviV2zvdIpkEXia25DqZoxGL1NsSI95V3Eh+gfQO+tsJSDjZuXKlbjpppuwaNEisCyLu+++G9nZ2Xjvvffw6KMtU3rbWvj4xLe+d/KTy+imMW7WBZEIzCN3M10RAr0QHlqgUMuaq/BdpHe36vYh6JMyo75pQmv+8HsQv8ebsdGwqhgtLEFgjStJ8BINPWjKXbk7KdGZ6M56EnYfS4xHd7t6zss0DV6iYYLWBw1BdHQOhqaSjG8rxk0oKLJpU8P1FxtBBNyKRI08k0k2Ab2pfzOpSrEpMgWfXLoRcZLWDNLFhD8UGI2tUCe45QjIuBk1ahS2bt0KlmXRs2dPrFmzBj169MD27duRna0szf5fYOXuZ0J+zEHF8gq8TcnvZ/I07cffTEmC1ZCv0kF/2GAXi4rJ6WQ0qKzUtw+81+d7kCyLuBDo7fAYieYPzR43mVQ9IKdNRmx3VUZdVVWjWZBs3rE/cUGFWLOH9jGCztdgPAm1P77xszIjVISsnFpCu/9AU8KmprSZ0xv86csUCNV2ceieLDqI2r/fQ6XDsxDsGJ6KYVWBlZsDQBTD4L4ANZ/ORgK+u/v27Yv33nsPhw4dwuHDh/HRRx+hb9++oTw3HReh7DIcq3FSm5jp3YxyvEoYa0gLukMLFSqEAGhKxP4prwBLQ+htgsaBMhh1XSl2kpRVJuX5KcLj8ao2kLi7vBL3l/nWN/k6KhJPJIhVaH0lzc9PS/F53LMlKVjKS0UluFihW3lTQpxlmlr8p4lgGFUROSEX1dTiqgDz/5rbKHikrBzH1t0p2naqoSiovny3pCThsnYpst/XgVNnAj6uGt2iOgQl4tqUaDZuXnzxRTg0iLXZ7Xa8+OKLQZ2UjhglYbZAqApiRbRBJWxS1wSr4Os15nfsV8lxGpaVofravjY7kkK80o42R2MM7bvE/XQIVGaFlCkYeSTLiuTR91ksmFXfgIs0VLkVGbxd+Md8XI+swLgLRV5XW6Kfj5BdqOgoMYynB/g939RlnuYFT3PCGzcM1D2zQsJZFh0DbFrKNoHnRi2JP4ZmsFImF02p2lErNEGgXGaMLyNJXJsySrRtRJD6awAwM22Uoqp3lEm5FUlzoPmb3LBhAzp16oT77rsPO3bsEBk6drsdW7duxV133YWOHTvijz/+aJKT/a/yemzr1VVwh6UCHCBnKAwAW0/nYlK9tpsvmGFpTGNjyBOiK2wV2GxoPY3kGILAbwLD9IGkBHwaFYl7NPQFUjKYtCLVCwk1fUJcmRgsdc2UP3RKYhj/JJOLpoVthz4OasHTVPBXTSNJqi6qhDDp2egdoHFZrrEy0x/WqvwmLAGckilBDxaKINzhZyETOrTHz1XiJp7d7cqeY6EHTE2S44VjH+OTGG8j5qmxT+GDmR9oOeUmQ/Mv+s033+D999/H7t27MWLECISFhSExMREJCQkIDw/HmDFjcPDgQXz00UdYs2ZNE55y2+W2cvUJr69CaEeu8+/EEK6IpQqVWrm2shrBDouHZTQWHistRxSrvbtMMNOn8D2aKsG0NfJqXAy+a4Zclx8DnHS1cjDElYnBMjMjHa8G2A6iJdhpaV3qzjyBhOI/qDuGCyQVYFoJhZioP3zTAs2mT9vLEW+JdT9+V+U6FX79WiU5hAxMHojOsZ39fl0o8evKnjhxIiZOnIiqqir89ddfyM3NBUEQaN++PUaMGIHY2Fi/T6C2thZ79+6F0WhEnz59EBWlzZW1Z88eFBcXo3fv3sjIUA89NCcPDliOB/d6h+U+zS/EqrhY1deObLR5tTZQYn5NbVDVNUKOBBgeGWqzuW8CtXwPNeRCM/ckJWBWXb1m4yaYNdfLcbGYX12LCJZFP7sDO2RWPSMabJhVX497NfSfaSs0RSXK2cbcmlp8HRUJxs+QRW0TJSr/lzi7Moi8+SaqaY1+JSrsVZr2+yQ6uJDS3O/nYnrWdNw73HdBR1MR0F0YGxuLGTNm4Oqrr8bSpUsxY8YMvw0blmVxyy23oFu3brjnnntw0003ITMzEx9++KHq62prazFu3DhMmzYNjz32GLp3744HH3wwkI/RJDx98HXZ7VUGA7b6SBbzZwj12cXWDwKtGmkyNWb491346i0VRqobjI2uyWthvULsmKGRJdM9V0fMSAVV47ZKJyflt2EDaJ+YBxpaX7j58dGPB/X69sbg8ywOm01nvXHT2qkP0kCvtlfjs6PBtfIIlhZbYrAsiw4dOuDkyZPYtGkTdu3ahQcffBCLFy9Gbm6u4uvuvfde5Ofn4+jRo9i8eTPWrl2Lhx56CBs2bGi+k1eDlQ9tXJua7POlxyVeDDWxtVBWUAXKonYpsoNQzxAkVRKAqDOtKr52o9QnXf4m2BcjL6JHAnCoTHIbc7SVzbclzgug4seX8d4aeNaPzs5P+RAfVEJrQHUP3bwy/tEa8uLq64t97qNGHhW8IOO89DTZUPzZBAtC16RpYlrMuCFJEjfffDPCBE0lL730UjidThw4cED2NSzL4sMPP8RVV12FuDhu4Jk4cSIGDx6MDz5o2eQlAICtBvUapf7lyDGJb2hKZUI9qZCMFi8YwFYXlcjuE0rkzvDtwmJ8n1ugWjqu5bhab36Lj6RVaQWC1Pji32c7KV9pYQCwXabjNc+4Dt5l822db1tIe6apuVWmSWKoaa1eBy2DfU2x/Njb3FyXmoz0ACuflOjRTJVsWmkXRC85ObpqqGb+L9GqgsMbN24EAPTo0UP2+by8PFRUVKB///6i7QMGDMD+/fsVj2u321FTUyP61yTUBy7ABACr/FhVDndpC4QJkmDjaVqkOSCtVEmT3ExqZbqBlgkaWRaRLIssikJakCXWKRSNFwXfSXh1F6yoqMQ8iUhcFz9DRoclpcxuz41B/nzTKArJrbBcVkgoNXPU0LL695feraziKVhaq3GjpSrqfwW/N8OZaIMKsWvjSAglNfyls8TwyDcZ0UtibD1Y6lt3So0HdQE/EQEZN3l5oXfD5+bmYtmyZViyZIlXt3Ge6mrOjct7bXgSEhJQVVWleOyVK1ciJibG/a81JSDz3FpeiQw/jIFMisKQRpvIK2GWGDPSsWFyfYOor4pa+4WbK6o0nwsAzHeJ4C2orsEeixk7rRZUBVleGcGyiGYYtHcZLw0x/+K5+DhkSFZ0qUEaUb7CXxSIoDp2Nweh1sxRoqYJEpEPaah4CkWos7loDSHjs4HiNh6aEjZQZmT80E8JjJkrqmswtrFRUTNGC0fO0u7egRLQ7JOZmRnSkyguLsbUqVPRr18/vPTSS4r7mV0/XkOD2ONQV1cHi8oAeffdd6O6utr9Ty2nJygCFIKaXVuHy13eCDnXqdKqfKeksmdRdY2otLomQVyK5yAIfJFfpOmc5Kpp1NzEQvNgQbtULE5LCVh7Q8i1KUnIk4TgtoVZ8WZhsfucSADhQZRx+0qMPmQxt97l+H8AkmXxeYG267Y18GmQlSY6ZwfLKzw5VVJdIgCwC6aLBpJEEs1gYBBezFMmY5PrSrUlAjJu2rVrFzLvTUlJCSZOnIj27dtjzZo1qkZKZmYmDAaDl3GSm5uLjh07KrwKsFgsiI6OFv1rEsyB5SnstlpR7fJyGGRm0XvKtbkbKRCiFXyfoqOi5wuMRsQzDM7XkCxaJmPczFV5XTpFo5/NHnQoSkg9QcAuk7X/Z3gYGAAfFRThwbJy2AgCPYKIN/NjTEerfNL3zjArnPpqvMVgCAJ6rZpvJp+FatDJFNUmq/D62ew+cwGFeXxfR0ViXGY6fg0PXN7jw5hoOBUW2G8UBpco3hYJyLi59dZbcdNNN6G0NLgck9LSUkycOBHt2rXDd999J0ou5tm7dy9+/52LA1utVkyYMAFfffWV+/nKykqsX78eM2bMCOpcQkJYYNUV+Saju4XAUYHn5Yv8QrxbUIzhGkX25C5rYc7KZlc1ixbb/j4ZTZdPopWNNxqAEazPG9of5GTEeT6OjsLDCfFYmpaCQxYzZtUFNrC3c1LubtprBtymuN8+jfpDPP+1tgNKjA3RxHTPWaQx1FSMCjBPTmsT1ZaCaaMLi58j1Q2Vl+PEUgAVBkNAgnlaMLeQQ4dtQU9SQN/kM888gzVr1iA5ORnJyclo37696J8W7HY7Jk+ejNLSUixevBi//PIL1qxZgzVr1iAnJ8e930svvYRly5a5H69cuRK//fYbli5dirfffhvTp09H586dsXjx4kA+SmgxqOc9rD+TjziFgYS34oUVUgk0jcF+uCl/lNxMLIBvZUJDgV5uJSox8FyTEX9brT5LOIdoaLLWwZVj42tM4z8HAWBebR2e8yMhm+f8ujq3yjL53TLZfVYXlWCixlYQPGr5TDr+E4oQ59nOGaMJ/QNQG69uxYKOJUYjtsksels7+60Wn+HJY82YI7OwnXczW7WGlxfXBF/S39IElLH12GOPBf3GDocDHTt2RMeOHfHZZ2Kxn8jISHTo0AEAMHDgQEQIOhpnZ2dj165dWL16NX755Rece+65WLZsGawqpbrNRXldoerzR80mVLoGkm4NBhwL9xg6J83ePwXtpxLCkEa7KDnzlMkIYSZKP5sdJQaDl+z+kEYb5tTWYafViq9UvDNS5EoP1QynfjY7nispw68R4XhEpa/RCncys/LRHAThbuDIi/AJE6otDAM7SWJ5RRVejI9VOSsB9SXolzgL+8vE5bAjXYPAmrwCvBYbg5/1iVYzm9qA9s3ZQqWB9NvD2NR8ml+IS9IDa4nQlHzaYykuOfJGUMeIo2n3eN7WMLGsbA8qnniVflJa6c8YQTRBQ1KtBGTcLFq0KOg3joqK0tSD6oYbbvDa1rt3b6xatSrocwg1S3+7VvG5b10TI8/iYgvu6ugJXfCXQKbTiTMmE8JoIMVPd7G0Wqpe0nTuf8WlsjHZt116ON/7OWl/LUhO/sy1SnlXpokaAPyYW4CX42IwpkN73Fyh3mPrsYQ4TGxoVDXthBUp/Kc2uf7oZncg32SEHVx4SM24eSUuFkuratw3QphR3uOSzyYgy1mOf1qwnFSn+Ymn6TbTqmJLK/RwKE2SUTSjGoJ5pLRcNjQeKoI1bADt3cpDzcy6+qB7tinl5vB86sciV44rq2qworIqqGMES9ABvtLSUpSUNL1YXFvgePVJxefsBCFyrQ8zHMNsmQRd/pJ7rbjYa3KXZsKbGfFjtSF4Zl094hm5gkTgifg47LeY3Xk/waDUyiGDotyKy0oKrnwz0K4ayiHlfDp8MjZDeOTDWYi1gHiEmj/CYxGMfEVYOsGVbZ5pgk6+ZwOXVrdtN3YXhYT0QAybOTX+qzuHgmA7uDcFUzPTZbf7yi1pSsMmVMgVO/BIx2YpT5aUhfp0QkqwHql3YqPxamw0KIXxtDkIyLhhGAZPP/00EhMTkZycjJSUFCQmJuLpp58G8x/qrOwP8ySuWQdByJb95bgmzwbS2wCQ3hBvFJXgGUGeyW6JSzpMYzLXRzFROBGd6nfiXt+OHkkAXp9heGOjSN8B4FZpgEf19uW4GNnWEvz5/ukKZaidjlz5djjDwiox4IqMBlFoLo2isCEnD48LNCaE++8pUxaDVDqfaXX1TSJu15b4RMFj19q4skpewPPfEOY/+BPa1Tk7kat6BYAMVz5hMOrE3VuhEnGSzOd5JS4WNNty42JAxs0jjzyCJ598EnfddRc2b96MLVu24K677sKTTz6JRx55JNTneFaSbzSKhJ2kt8JBmfBHf5cGTqTLgBxkt2OaoBrltKR9g1wVhJJg3ScxkQjGLH2jqATLK6rwVEk5hjWKjZvz6sQrWYogvIT4AK70W3yuHto5KXwiCIPJXbiZlBM2ksRxwUTVQdL8sNBoRALDiL4F4bHmpU8QHVPoXVMybn6JjGgScTs1LmnihL/rKpu371Fz8U5saGQgptbVh+Q4Om2XSJWFvNLEWuPy9jAgkB6ggdOtmdTI/eGucvlUA0ah12JzEJBx88Ybb+Dzzz/HbbfdhtGjR2PUqFG47bbb8Pnnn+PNN98M9Tm2Ga7udrHmfVkAJYIJsaedu2B5Eb9pMqXEyTSNX8/kY92ZfABAFUki32jA8Fpu2r1RMiH5csQIy5VtLI05kjCZWuNOuXNbUl2DOIbx8gBJw1DJMKBLhHeSISsxbmJpBk+WlOHpkjL8kleAPg4Hrq+swuT6Biyu9qzAPerBntevySvARwVFSKNpr/jyPYnx7iRk8auAdie3KH5GfxxbLyhUbg0IoJpFjqYWintVUqaqIyajFSpW/9e9h83NLBUDV6mrNl+ZRoJFf5sdZobFXeUVuN6P/JS0pL5+nWdzoCQB0uZKwUtKSpCdne21ffDgwf/p/Jvrul2q+rwwz6OP3YHPBe7rTIozbj4uKMLGnDx0VFADTqNpRLoumGtTkzA9Ix2FiMPPufm4QHKzsfAYKHzZn3CCFpUr22q83rObxP2ptTHbUYkaZ50rxPZ6YTH62ux4JT8PZbXeIpArKioRyTC4wXWjh7MsZtY3YLrLCLs8LQWvxMVigM2OwQIjIdklHCi8jbKcFPopSPZ/FxUpKsMUfidMTb5oX769xQEmS/Hz+kMfQcju+QBK13VaB2/Ftj7j7/qq0HrbxrRB8bzWxCQVratckxGPlVVgd04uLq+pw2CbHQuq5UOmUpLydoXqFFXxlTckJELJuGlBafeAjJsePXrIduF+//330b1796BPqq3yT/W/qs8L4/3hLIuLXImHoxoacY5LhM4EIF5j3hJf9l0YVot0ivYKK22KH+PuyZPgWtWZFK41FpwQn5B/JAnGWgc7qS4F3/NkhM2OjwuL0d3hhFHmPDo5KWzJycO1CnkR+105Rb9EhIMAF7/OdDrdF/ERgVElNFi2nc4FoXEF8YNEK4g3ABk/bpVJ9Q0YqqAhIQxe1aokJDYVl7fBxN/udkdA+i1tkWB6aE3yU4vJF7zopz+T3H+NZSo9+BapGCsECzgAVJMEGggC30ZG4P0YbSHTja2wKu7KNG8dHaBlw1IBlYI/8sgjmDNnDr7//nsMHToUALB9+3asX79epB78X+O1o5+qPs93rw6juCnO5LJq841G1BGEWynXXwjXVC6dKhuKSFR36IMM5z9ut2EMw2BaXT1+kSkl9KWRMb+mFm8HsGKVa40wvNHm1RsLUK/4EkIAeLakDHaCcFeRORVCTREsi6uqa/Cm4NyVEv6kBh2fHN2fVK6EkzKvpg5nTPK3ltB7l+BnTwcDy4LWWH56V9xgPFG522v7RwEm/qZQVIs1Mgz0vmhNJFOUqggmzwslpdhtseD/khP9fg8nwXlXj4dYHM4hU9zQXFgZRrECszVQrFChplR9x1NtIPFLRDj+LzkRIxob8ZcfBouvMu5YmtbUAV7KpPoGrBd480Pxu7e5nJvzzjsPu3btQmJiIr7//nusXbsWSUlJ2LVrF84777xQn2ObYXOJurswjaLwQnEpnikTi/2dNptUBZV8otKG+NDRq/BRbq2ohYPSVFHpYxCR87ZoQe7s/qdVWE8G/uPempyI+e1ScdzlsRG+j/Q9kyQ9r/rbHLixssqn5o70GxF2VVfq4GsGK3MGYkyEBTuYXqr7CFlYXYO9p7U3fN0UFloxt5bs0EzA//YX/qLWFDYUaDFsAGBtRAQeCLAMOs9oPOv6u1ItKALnizSKQgOhPGb+oqJSftRsxoeuhYY/hs2U+gZs8zFXyBk2cg2ZpaxvAlX1lsy5CWjEeumll3DjjTfiww8/DPX5nDUMb2z0Cs9EMSwmCUI7mwXP77NYMMvPfkRXVVXjrdgY9CzpDeA4AODXM/kCbQkWqShHHCFOFJYm7gLAzPp61JAktkL+RgtjGMRqCJeVsd6u1cMhWkn2s9mx32rB+bVcbpH0ttE6DGY5nBhot2OQhtYW0pJz4UM+l+jC2jrcWFmFEoMR4SyDjk4Kn0fJlwOzWWOB2oOIMMZwvmmNLFYI1SmxtWCrX/u3ZqQ5XFLWncnHJe1SUd4KdV78JRij/6+wsFZl3Myoqw+6bUZrNm46OyjFFgr/ms2q8gIEPOF6f+hvs+NQAEKiR2ReM6G+AX80YZuYS6trEWFqOTX3gDw3K1asAK1n5qtCslyugBjx0HNKIAh3Sqb9gi+WV1ZjS04eEus8lUdpgt+lxuSAiRCvSCtJ0qvvUV+bXTGBWch6eqD774E2G37Mzffah0rsgThJudRRmRsrkJXyG0Ul+KCgCBe5qrryXN9fFclNahFyxld/LsnbACCBonFJTS2+zy9UNISk1Ux8ns9vrs8+UPA8vxqnACTRDHo7HO7vsUTBLXyc5YzbKmcJ4qzHVT6tGK15WGcjjT48ilMy04M2bPJNRgyy+e571pqpMpA40UT9is4JoPT9sdJy/Jybjy/z1dvStFXGNzaiTxA5UoGwMIQSEE1p2ADA5TW1MPnot9iUBGTc9OnTBzt37gz1uZxVEPCYMk+XlGFLTh6iJIl5Lxf7X1nWEJUleo8YhsExVr5ZqYNkMJ0U/05yK7uPC4sxvb4Bp1XUdxkAkwx73I972Z3IoGgUs7Gi/VLLd8ASzuUL8JVaUmVlAHg1gM8ezrIYYHfgT7qPaDufuhLtMgBEJbH7PgHADfzlRgOcPvw7sQpGO+n65gpkcmnUupdLMRGe15OE9gXCJpcrekSAnZ91fPO3TH+6NB8l31oawQLAowLRyKaiKdtE2APwoJgApFM08mVCckoNhNsS9QSBS2pqcWFtHR4M4PcVjoo3aCwFfzVEOk3NgVJ5eHMRkHGzcOFCXHLJJXjzzTexdetW7Nq1S/RPh1PZ5Rs71pIEYhjvepuBdgcsrgl5hMZBMrz2tNe2fFY++bCIjYfJqwZKmS0qTQ7tJIlqQYIZn5iaQlR57UvWciu1Z0rKMK+mFl/IrNw6OimRjo5cKwoljhm6iB7zPg0+J4hRG4gD9HL3dSUUHzN5r4wn+lEy257wGJByKstK8O7982oDF49TK00NFDll0rbG9ZVV+FnGCwnA3eU+kZK/j7SKKfKd7pXgc7mUjGstaK0IDASbn8ZNCkWhb8dM9O2YieUpSV7Pt9WGk0KOms0wAfg1IhwPSvKk5ARUhfSRhMTlFoBylJ0F31tzEVDOzc033wwAWLp0qezzLZlE1BopMSh/zWvzCrEjzIoZQSieVkG+AuY0nYHeEGupqA1RA2027FHprq7UE0qIkzUg3JUhX2ow4D455cr+lwFlx8Ci2L3JHyu7lyFPVLfOCrqCd3I4EcEweI+agoXGde59yl2hq9M+EjvlKrgAIIngcl4ImWRhuatduu354lKMbLThZJIFiADiGRMuqKvDMwlxqufDc0gSbuhud+DdwmKMyMrQ9HoAmF9dG/KkwfYUhdIWTDYOBakU7ZVwLkXatynT6cQlNXXqhrSAaB9hRV6tPNgMk6Zq9LnZz+7uraG+KYmi8FpRKa5JTW6Svlubwq0YZLejTiZsGsaykFMd6m2345DFghTJ9Vao8R7aEB6GuX4sBFsSqoXTpQK6BisrK1X/6QALqmtwdWU1OjiduEJldZdK05hdV49gIpMJktso3rVqyKG6wCBRv1G73p4rFveuyqpqj8urPOeu5VplQKK/jYtDVys1x2MZgCBExzP4YQ/HMRXiw7n+T6VpfJtfiI8Li9GeEH+WX12T+u4wKw4zmVBirMQLIzU65ZrlyZVmSqXVb0lJwmMJcaA6jgYAEAQBhx+rYb50fUSjDT/mFuD5klI0+lmqSTZBuqma4d5WKDQa/TIqBtls+CGvEPNrakVK12oIv/nxMh40fvI9GzwaADR/L01JqdGIbk4nfs/N97tdxuj43vitUb1HmJIKMSDvlc1utLmvMwYEMl1jRBTNaP6+SoxG9GiF7RfkSO92bou+f0DGzZIlSxAbG6v477+KMBnVwrK4qaoaa/MKERNEMuhKp7rqMQCkEfLx3nDYQPqoyLlJIEKVKDnPc6sprBAZq74nRwvhdJdqK4ddWMAaA4PAw+dPs8EerFhzJkHGBSzMD5LSkzyj+FwHhUTnalbZ4/GGTBw8SeacvouKRB3LHb+ccPg1AfDHeyIhDjMz2mFmRjomZsrnWinRFNNNWys+vkWm9H9mXb1fA+GYBk8IWa3cV4jw+P2bKAm1o5NqEq9NIPkxcu1jmoowH+MrAfi1kACADpEZSLZ4e1WF+jVqQ6tcbl6h0YgF1bW4s7wSnZ0Ot2r8/Joav66/FLpt3HPEvPda9P0DMm5++uknNOqJjV78r7hUNGGHgh1MDzzgXKi6TyIh9tzwZ9CPOIlGVhzOEN7i11RW4+pa5UFoAbtTrB2TORITXIPWcJXfP8/lYlX0LOz/DIhKE118y1WUPpXg8xPiad/Go9ahTXok/vE+prPm10jf7yqBLP5fNk8oTkktWo6HSjlvVTDufrXX9gtAAfiy6lp0bKZVZIaPnBWtxEmulR9zC5BFUX59r9vDLLglORFfR0ZoTpqUGuBqfdsCTRpPbaL8p5b3wajzhIZkXn+Nm3BzJAiZSp/XizyFEPwiTqmBptRDR4DFjPoGXFFTiwyKxv+VV2LfqTO4tqpG1bsvvTezHP8Nte5gCWisnDhxIr799ttQn0ubJ5Zh0MU12H8aFXhjw5scN7r/vt74LR4yqVvA0lRl3rWdYTmCIywXgtnPdAQAkfG1NjICYJQHRK/ht8csPF5ajkdLy/FsSRlOMqnup2iBkOAOV96KNE9ExPi7QJCewaOgzH/xxySaRjJFhTTcskGSWyBVcn63oBhS5N69r92B14pK8H5BEa4RaNRYCM/KOpWmMbu2Dhf7SEod3tjoLvHfY9EmZmcgxCt4q+vaVKrKUPsG3ywsxuYc715gH8dEKYceQ8zLAfbhWiTRB5J6mvgQLgHgU40ly9vCwvBbRDgeSErQPPFHCyolX4yPVdVv6WN3YKDNpirOKcd5dfVYHOL+UkurqvFgWYXvHSX4e0fOYAJvKeCrog0AcgSVoINTBvvcf0vuH0B0utd2obeU99z8diYfP0kS0r/JK/QyWOSqxmhwiyO172u/RMByo5/5Ty3GoTUt+vYBjUydO3fGggULcMUVV+Dxxx/HM888I/r3n6XbdLd2TW0Qg/5sw1/uv6cY/va5Py35GXk3bYrDiAo2CpvovtjLcBVGkX54lmpJUhRXLq1zIpJlcV5dPcrMvfErM8T9XDm82zKojs0x7dEgyAp+m56h+bx4vs4vwvrcAnTSoJkzo56Lufvq3XNMosnD94jqRHIT32C7HZGNYnf1UBmvxzGzCdemJuP+RHEVRaaJC2GlEZzR9FhZBe6VS7oWUEl6DBU5d7ccc9LvFz3u4XAinGXxclys7P4HVBSASXj3HeNRS0APJf8EqN9ynWSytzAsdp0+g+srq7CiolLU8K+3w6m5aoVHq6Ca1qPOqKvHsspqvF9YguUnumo+j5l19YhgWdxSWY2/T53RbKj54o3YGPwWwGT6uUrX+sdLy7y2VYXH+v0ePEoj7YyILPffpYJwnRZhufn1NLD3I03vH8GyaC9JEO7idHq1kpGKp34aHYlBHTNxV1KC5ppWI8s2WaLu5FCHEr9Qjzg0NQFlA27YsAG9evXCwYMHcfDgQa/nb7vttqBPrC1yR4wFjrLgr7yBpHZxN8DbcyO8qfaznbHAeTcAIJJohBlOANzAl0KrGwX7LGYMEJQsvrLxFJ51HTwtxoLi2lj3c8mukvBf6GwAJa7zUvguErt5bZpN/ql6LsGS5hp8svwMb/CJvMIEZX6iSqBolBsNqtLmJAAi+yqg7FcAXCIxADCk9slaTgTRF+9uPY1wQd60r8l1dm0dvlNQVX46Pk42h6g5+URlslRjh8D46m+zo7PTCQsLXCej+NxAED779kgp0ljlUupHLsyjCXH412TC7rBjmvZ/vKQM5womJhM4Qy1U/BPA9afG9LoG/J+kOnyvoww3V1Ric1gYdvvZiuZ9hWuDFXilhbqi3eO6Y1PeJtVjdi/1fb1LiwZ42rkWW1IvsDQU+W0kd7/9EhEuElGNpWn0szuwScaovLaquskaZ/7WxKJ+zU1A7oW9e/eq/vuvUmXy3JTTgyjtTiT8k9pnWPHPyLtLtzM9RdtXOK/Hjc7l7scDfeRZEADMgvsxifF8JoqiFMUDfeIKR0WZPYPSKvPLgR1LifNeRiiyBeSSop1G7nvjc4rk3uVflwfvpNkEdJ3q3k4YOQ8JIzE3eANpUafHsHry6mBPG+GZ74ge77NaUK5S3fFoWQVWlnivqAHgsMUsO9A2J0q9pd5xhcxiFPKu6gV5X7Pq6pHlpLDNasHCtGQ8KWl1oDXtv7MrqdSXdo0QGtq6a/8UGYHDZrNfE7xcE9xQ8q/ZjNcLvcOxQuSkLJTyuOTMwUbGiX0Wi9+GDQB8r/D5HWUe41AYBqx1+NYmMjiKfO7TVeH3N7uMmPckXb4nSCoxD7uMRpYgUCAoVa8yGHBhM5R7B9OBvi3QGuQIzhrYBs/k0FRJeJ9QE2BnxcMDLXk3PiS2y5AGL0hPpYeiZ8UFAV7XhSOM8NwM20tI5LCpXq/pF+eEwc6FbRT1GFwDTZdYLlQWRqmvfs8YvEu3N9D9VV+DgVcAl3/pfmhhWSRQtM/KtYESCf4/XZP6N/Qo9zbawYkm8mu7QhkNjRLhtvB4958HaG4SKKWrRPvzvV/ePXkPrvntGtFzfQNI9pVDSUl5VXEpCHB5Qv7ydEmZqOKuuVke3wljOrRXzP0RXuGPJ8ajjiTxv7hY/G214kPJ5KM14fqV4lLMr67B6iLtKtsEgC5Obd+vNMfCF/Or/VsMBUK2zY4PC5Qn/CEyrSveLCrBmrwCvC953SAFbaZA2wHI9coDgCjBvT5KYFj0sFyEQbUpqlVWRta352akgvDqYIX7VS1pX9rGoUZmIfJmYbFfPeZ8LbAPa/TINVfRQKgJ2LhZt24dLr30UgwbNsy9bdWqVaiqqgrFebVJ2GpP0mWojJu3qenuv9+kZuBuainudF4t2ieP9VYABQCClLuZPMaKXBnvOMnqQljuyBIscOVP+KvTMrxLT0cemyTqNwUAaTX7EBvGGTeK+QvFXChzf+l+AIDdoB4eq+4wTfR4F9MNpMI628ka8IBzIbLu+gGf7/HkHexGB5QbDWhQGAjLWc6LlKwg5iYUMKw/swQbcvLcjU6zZHJ+hLo9pn9/d/89eSD32/mjTjxAQ4NPLRgUglP8ipIJ4KLNcFK4uhkmVzlGNzTC5qdCVD1JKN6bctv5irzF1TUY3GjD1Lp6tKNo3FFRhXSKlukfJ48BrHuwfULBQxYIl1fXYliIjF81qgwkrmjnvZjhWRPpHdIMY1l0dlJokEzUFEGgP3GR5vcOZxhsO52L7adzlXeiOYNweUUVfszNx29n8vFIWQVg5XIBx7gq0KZlTcPtazbj76hi1Z5lZhljuZ/NjimC8J9oLOk52/3nKJlqNzPDYqhK7zLptXe/QPG4q8OBUQ2NeD4+1q/w7ENlFSGp3j3lo3FtayUg4+azzz7DnDlzkJSUhB07dri3OxwOPPXUUyE7ubYG2+hJDP0xRK7iY8jEe9QU9+N/LVfgBfMron2Mkh5FoxsawVCRoOrVExLlOtrOE2T4h7GsqIRyD9sB6DASf2csxBamLwBvPZnz7A8jzMJ5O3y5+ef3mg8AiPDhuanoJK6k2qtSln0/tQjv0Zwx9P1ej7HZk1DWtgGABIL73EoTXxQ8gxoJIIFh8EBZBaZjBebLVDvNr+HKpK80dQI2PO7e3j2uO9actwZPOCeI9jdRyqso4fAUH4w8v4/n64nW7ci9QmJEkQAclirV10gN7J1Wq+L3IFd1V+XydiVTNF4qrMGzkrLjS2q1tV8gWOCgq9Kt0Gh0t10JltLwdgG9zt9Jz5c6udTb1Ntux7AO7dG3YyauTU322v9A/VHR43SD8njZQJLYT/XE79RQxX0Ilx91Wn0DMigaKTTnz6ajxV4ilmVBWtRDbABAubRkzhW0O5F+A3uFn/niD5AawRl/7Vy5OO0Ei56JDQ2qXmO1b/e42YzuDgcOWSwo8kNpmQXwU26B5v3PNgIazR577DF8/vnnWLVqlWj7BRdcgA8++CAkJ9YWaYq+zWeYRHfCMAkWRsL7XVhJWdIrxaWoP343wMpNmJ59b/dRpRPOMPiMmux+XMwmAPZavPnLTljgvWLNtr2KfWwX5FRypaMlCjeiswvnjUqwcquTWsKMf5gOiufBSibdWKIeYw0HZPfNJj1x9gsNm91/V7pWYkoy5weZLADANoWYP1+1VsFGIg7chEYC2HZEftiPYRh8l1+I8SUWkAA25eRhY04eoutK0Tm2M2IlydzhtPKgtV9Q/j2h3rMq/O2MfD8kJZS8RSvjOU9bIHk18TSNkxoruILlzooqUXhhgcDY6VCThA65k3H5if7oXeNZ3UbITOJK0gFKomxGhsDPtqn418rggGRBEMi6eLfV4la6vtKPMIMcUY3KVVGXVXPXaQbhHeb6TCXEJOTh0nL8kZOH/WH+JXSTLLw8NkKY8P2ixx+mTVPYk2Mv21mULyjFRHD3k/S3PVrEfQdGFjCRJlTWU9DyqzUQnCdKGJY/ZjaJXrnZ4vlO/vy3DIzLeOE/9XuFxbilohJmhsXPkRGoU1k8HPARIvrO5RnbEB7mVjb2BQO4JSS0cHm1t6GuVizR2gnIuDl+/DjGjRsHwFP9AQDJyckoKfG/2/PZgvDCPyeIhGIhW5neGEtyA8Ecg3yGfzQhFYsC4FWI6E2qj2qpj6gpmEvswP+VVeD/yiowAHnA6rHYY70WVxjWifbNYZJR5ioHZ1w5KTvonl7HBADWNQhsynd9HmMDZjpWyu67jemJzQfFisQOVnkyHUYedv89mPAYOmtdnrSdYVbsZTp5va4PeRpXO25BN0l8mXdDr6MHAeAGz/7kCffz0mRuKYOqfgEBII5hEM8wIHM5T2e4U2xYEjJGK49wVXxveQV2ns7FVSd6I0JlJUjVe39GpTP9OCZwTSYTWFDNKPOWLBistwsM0WSHGQfrJuM1x6VYXGJFV1fSL8GyomaUBJSNGKVP0SdnMuaZf8b8dqm4Ok3shfDVZZ6HIggMJ7ncK2FiqZrCM1XbQ/WYUTSDq6uVdW2WuTSNclnvsNUWjYm7IxptnHI541/oq8ZPKYyEKPUeab7yAx2ut6uVGFTrGE7TZlqDBX/P/xu/b54qfaksyxu5vLe1Ag98I0mKxnWa9Iyfl7+5HU5XdRa/iEilaSyurvX6jX+lByPL9jEYB7e4MzMsqlQMQcDTniPXZNJscBz3Uz7hVhn1bmmaghpq41FLEJBxk5SUhH///ReA2Lj5/fff0aGD8gr8bKeDwKJWUq3UymDbq+hlexsAgVpwK2pCYSCsZgMLgQn1U3i+EpQD92MKkUxU4dLaOlxaW4fukTaggjM0lhh/Ujkyd54/MsNxnWM5/qR7yz4vzX7Ic3U3n21/BBfYH8I39ChsovsinBDHqi8z/g4lvqDGuf92CuoyhO80gBQbSzyRaEQnVwUELznPAniBuhDPUPMAcF4j4bG8e737oJ4TozPVeMJkb1EzUGVWnjyiaAaUy4gyArCyLN5Nq1Rtmmkv8dYNIsC6u0/L4a8Xgr/GQ2na/JhbgA8EXgVpWKmTwPhkASyuqkaWw4kX67a5tw8kjyOeZpBMUdhHd8e3eWLvhnJYCoiWWemmodqtXyVtkvinRm+XASz4DlYEWLzoEiV8I9ZbH4rH6MMXvOlMHtrJ5IhtZ3q43keZF+K1NWzlP62sUKVKrs8AP/OAiEELRI+d1QNEj08w2sJv0m/sJep8LHdcj/mGJ93b6EbfVZ5lbAz+pHvjbol3e5LKZF9p5zzWRZHxou28B0uqUeWs4UL782prVRuwDmkQ/8Y3NdyjuO9w2rMQ8qf3XG+7HSZw8hZCpBVeamySCn1e+pnm1zYFARk3V155Ja6++mrs3bsXBEGguLgY7733HpYuXYolS5aE+hzbDMJVnNJEUR/b3WvbSSYVO5luIo9COWLQAG519YcraXcDM0D2mAVIkN0uj+cceTEo3qgAuA7JPNPJvaJXXpl6SnAU8Sc8zHqMWsLgWt0QTtAgMcpwSLSv+eQ6FNfYkBQuToTmj8mCwB62K25x3oBX6PNxxujthVDiZdqTn7OJ6ef++2FX+4IVMqsTHkbg1BYOC5vpvogn5HMreMNTM65BjBIYv6fZFNEu9tLJosfjGxq9wpF0uHosnaW9z4sEtxIPq+2AcBnjO9mHJ0/KXzl5SKQZxTBPILSjKPwp0PGIMXj+tqUMEv0u+ywW3FJZje/zCxElMIISiRpsD7OixGjEUw3XI17yWZWGfAOAP8/k48+cXJHQ3GWG30ArvChK4yImimHhMeqBMYJJI0pSxj7S9VxkbZbi8cbXNyiKlA0jj3htU2v3oIbnnhTzTLH/jVtVMZpBCpPDJaF2g1W591zP3FFIcRCIECjE8zhhxLfMaByoCce+3CpkJYSDdSai/uQyxeNlN9rAutLvL6mtU/zuhikkCDPtBslu5z2GyUQVYlAHR9lETDs+ESsqqjDbVVkqV1FFsqxbWfzusgrsYx9SPPeMLp759w2H9saVfBuReMYz/sfQNHo7HCBcz0lz3qR4XY9bntP8/k1BQMbNfffdh0GDBiE7Oxs0TSM1NRWLFy/GvHnz/rMCfgCwx+pxA34X4d1MEQDCKr2FuSY6nsVFjgfdHoXljusx17ARk8jdAADCdVdUsxH4mJqAT6nxkiMQoiTbP9TKpAX3KV/RIxSoaydY2XtlkyR6EpT5QW8tzVXLbWV6uZ8zRnBGkCnqIKYbdsqexraT5bg9+3akGAeiIZdbtcW7clmkncwLndpKRE8yqaAEt5jQqzLSZsPfp87gSpm4Ms8L5lew3SX6xjcg/CM8DDQMou9CaNg5/O7nzh2nkvSsnOtZcYjAWZUteYX/E1NymLd0fCJN49GyCpTkXYfFMgOVUo+u+pPLUH9SOd9hE91P8Tl/+SQ6Cq/FebwZk6ztwTji0VgwFzU9LxYZGTsVQitqU24Yw+DaqmpMq6vH0nL5VemnUVH4vySPwa92PK3TOwtgi6ub/X6LRTTwvifRkMmgKC70QIchUaF6L0HFqKpgvQ2B7/IKfCajj5RZpUvDPDwpNI1/VcIegZhSPc3z3X8zjkQwFHffm1gCTLSyt6XOUoeHc63YlJMH0RkJKpgA4LyX/wQvNcTYlT1B7QtHYZJhD0a7FmVC7+EpkxGLqmowp6YOEyXfV4yZ89h0Oy2fD8i3iRhAnsDTptUAa4aJNcAETzm7WcaQioAD11bVYENOHi6rrYOVUC7NHpNyIZLDudDpUVq7wjVveFULfu9qgwElBgNQ0wcAZL2E/QXG2DFpVVXhPs3v3xQEZNwYjUa8/PLLKCwsxK+//oqff/4Z+fn5eOmll0D6iB2ezRjNnvCQQyF5TK5L92nr5fjQ9Jj78XjDPjxjWo23zM8CgDuBNY6ow/9RS3EX5SkFP85wk9j5jkcwwLYatzquxQ0qiXdgPRdgmMyNVMZ6Jha7ZOSut3sublLgZQEUBnmCRQdCvjLhlT9OICEsAf8euBh0HWcY8To6Jog9CDtOVfjWtQFQCXHuiPTTaTFDTrtuUJJlsayiCt/kF4IAi11MNxxj0rGOHoxGeFy/lIbcJhGuQSypnyeBskdYlfi8qVjsuHwH7GXjAXgqduRQEoYrqxPH5bvZHbCwwN1JCYjt8rBsybvyRE1CLV2+lI1VfM5fnkwQh0vuPfQ76k/cAao6G5ayQ2ivodWGEP765HNwIhkGQ212PFNajtUlT6CQjfd6jfR7IAD0Ushz2OdKBM3yEYUR/ko2glAceLvbHbi3vBKLczNgru+IEQpaKmrGg9w9SQD4RVI5k0DRIg2TRBnjJ9Zl8Eo9VL5GeSW1awBozL8U9aducoeeDC7vZyfrZDirOS81y5rgrBgDABhIt0MpwXmn5bwHJbEn0ciGuw2bb+mR2DPpI2DS/V77soJvLs0sP6Z8TY/BFNLT9maGK+9uWUUVXo2Nwbux0fgqOtLrOpkSuQq1Rx9Aer04PPN2YTEeLy1Dd4HoH//avgS3oOW/ebkcrN9d+j9Cg/buUyle+wHAa4cecV8cdax2rzIvnlgiKbjYYUiEzZ4BS0NH0cKXRygv4XXmlHLpe3MQlCWSlJSEKVOmYNq0aUhNVdZA+K9wmvUMgINzxvrc38F6Jq3RgtBNf+KEaL+FRi559xzDNkjZ7CrJBoAqROErZqw7nCWP5xKUegTqWCvqBAItuSaxOfCtoLTaauQunY1Mf7xDTcMRxiO0Zys6FywdBlvhBRgs00riMJOJohruwk+P9dyAc+33407nUuxkvRMpT8kIBkp5mrrY/fe9s3pidox8bo0WwlkWS6tr0NFJgQALCkZMczyJpc4VcLi8Q0eYDC8vk5TrHMvROEuovswNa84kTx4SZRcnhP+2YhzsDgPM8Vy1l1oV04pK+TAbLTF6eC9/JUmCNjXImmSNSnF/llDOwoW3p839Mj+X70Y5NWjB3zEH35c1yKUItZdIK5dvc35tPWZVEqLV53fme5FGeDeF/D1C/H2T4KpO1uQV4Pcz4omLv0dOW4AuDuVEzwaCwGMV9egT1R03ljeIJsYfR/7s/ptvc/EydR5YEIpeu69VjAc++dbKsgh3WsBQEUilaFhZFmA8vzwJltvmYnmlJzn5tvJKvFNY7A7pScuYpblQY1VyMzpJQkVUTX90i+0BxskZslakoM5OwUQScBvRLAlnbR/cV2TDiuLdqCzKASBugMljN9ciXxBap2DAi+uOALT375FbITxP+e+WYiKQIrguCMHeSu05Vl7YF91S4gBJA9B/mXYYYrPj3Dr5vk1/usZvPjl+W1gYdp7OxRyBAOq9Mo1LoxWqK8scZ1DSyBX11BPB9337i+kDqq4bsqwXI9GRJCpvB8SeJn+0u5qD/66bpQmZZ0hGo8M7LCDlZep82e3ScNBGl9t/n0yVzzf0aP9OjvC+GI+aOGNiNXUODlk8g4dUC0N4VnbXJPElPQ4PUQuxnfVURjkrR6Hu2H2Krt86WJERzw0C+VWewWYX2wOf0RNkXyOFkenKKZwIGh006DrfnaQfdC6Q3S6cy/nwFifDJg5PyZXEN7Aez85PzDA4+niMLlhcJabCQUFgHBidGZj83EYMfXy94jm/T01B/anrMa0sBv2qvD0Pchw3m9FIEO4E2D/DrG6F1hjXhGpXMm5IO4xR8q52ABhEnJLdrqVNk9DzJNcQ8GVLb0R0fQRhGe8A0BbuEHrwCJL7fWbW12NcVRjaC1afnUn5MmppBRTJct9TZyeFJIXQHQCsUFFqDmdZzLTRuLjji3jdfgkA4LWiUjw77llEGD2/4ZbwMKylh+Mg2wks5DtJ+yLJ1b6FABB+Yinqj9+NFY4bcL9zIUCKK8e6CQwyK+v5bCw4VWKeCIZF31hl7+njRQ3YeTrX7SEDgAtq69DOSYm8TyzDjS8DM2ORnc6NZz2TMjHxmQ349NTzMMVwoQzCWAfWkYSxDU4u78P1yx9QaHq5henj/jufTcC75CPAr/cpni8gNXQ4Dpw6A4oJRz9SkF/oulfVRC4HZMSiUyJ3btdbn3Bvt0A+hFTKcmkLPzDDMcn+NKa6vEPT6+rxF9UP2a7vbFijDRfLKL3XsOF4uqQM4yXNLkvsngUdYQi+hQPNGmBN+xpHySdw0Eh7NUOeWN/oLiywsCwybX56spsQ3bhpAjpXF2lyCdYpeFikxs0y54142Dkfix23u7dVuuLqDYIQiSYELRT4ySzClcAZSTTCKpisdzeIvU9V8KwWT/v0pHCXVqOM1g4LAgMztFVrAED7uDBcafxFtO0DerLXfryRcHF2Bp5ddwwvU57kYhsrH5S6wvCb6DFf5SEq+ZTcJoVsAvYynZHHJsmKm4UT3DH2Mx3xzEX9ce7/tuAgkwWWMABxWdxzRzxJn8KEXMrEqbA6KAZUHWd0Sks/FxjXIcyWhC9L78a5jidQf/ImsKwBVB2XrM7S8teVUFGVAfBJQREeKi3HMy7F3E4KvXJYZ4I774tHqDczgcnBwAb/wkUAV2a/O0dFdRbAW+1qQRrrYYzkRN/2KLQmoAQl+XLq1VMy0nFHxwZNDSylk9hGiQq3Es8oVCBlnJ6NcJaF0V4FFix+pbOxyHEHRl3+A6amjUBkozhcdI5hG64wrAMLwqvjfGwdd98NUlG75fmEmoBTbHsARnzHjML7tLeWjFBdu0pQPZkmCUGkURSGR17ufiw1Mq9Pi4WVZUXbHy6rwC95BZhXW4uYxlgAAEE6EdntQay8sB8+ung51py3Bm9MfxEltXaY4zyCsIytPSwp32Nuh3C8Hx2FkSTn2a4yyRuXvzJDkGX7CL1tbyESru/mhLiq8vmL+2Nab084x1Y4x+s4n1Hjve73Tk4KRpZFrtGIDIWw6IwXN6PByRmOR4w98RM9BACQQcovsIRe5s5EAUY32vDHmTw8WVqOTUxvt4dIKVn/INsR0+sbMKhCpsWOCzWvslUhZ+sxiUjlTrYb+AVdO9LjQfokvwgHTp3BpbV17pCaASwczacK4RPduAkhH9mjsKyiCvNK87wmvYWOO732r4H8KkT62mpE4m16BsrhyYf5kJ6MN6iZqJZJHlSFsYJ1xMLsDEec6wLPreQGUAJAgiC0RjBWnGY8g8FepjNeafc4XqQuwHPUXMW3uH68J7l5quNJr+eHkkfxwbYcfLtXmwhdtxRxLk0+m4DzDFu99ptBcoPjZ7u4CbNR4EFZzwwUVYUB3OrpIJsFgJsI3qOmINM1wQs1gE6y4gGklg3HAPIEJhn2yBo3OxjOyGBAoGtyJM5UNOAcx+N4a+IuoNN4AEDRv55kO6VWEoydm8j6y7RfiBNUbzH2dIAl3AaAEsKb3QjOE3FhXT2GuyZQZS0R7wFWuOf71ETsCfffw7BO0kuIqu+EQTYbLlBpGnhUkMQq7J1jE6SSSr/P1dQsd+NERe+UAOmnraLl25sAHhVaC2vgmqTKcC212/33PwU1KEEcV/nYfjCwsj0u2TrL6zWPmjhP1fVV1dh6OhekIxYAYGK475lP/j7JKC8yhG1ZvjPfg9PWy3B7sSB0brOLJk8CLN4rKMZt5ZWYKgkz5ZuMeCPvDvfjcknI46SZu7p6yPQh6uSk0LvQYyASBhsWvbMDNMOic2xnGEnva4dxxsIQfgrVBgP2Wi0+dW56E6dwzLIAP5rvxgiSD/GLf8kLBraHQVDhxVKxbq0ZHi6HTvxekQwDiiBQbTBgcXUD5tXU4i2ZRqJF1ZxRdbKsHjNchRS1Movc+Y67UAlPwUkngvMgcpWHwJfdtrjbLxQa5O8r/vtoF+O9kLEauG3Rdu/3/javABtz8jD8zHDR9ququHtOeu1fZvkehjBuPP0qKtItgirsp8e3sXjYeQWKLIErqIca3bgJIf0KDmFpdQ2MECfF/kYPlL05+YtajZGd5cu8+YErnfAdehFDou7E7Wj491Z33sUIwz8AOC8G3913kM2G8wx/ut3BP9JDcZTNgKH7dDxPXYStAjewlDCT58LPZVOwjh4sep6v7Fr+6V5NZ/z7EbEw5G6mm+yKRlq5RArKp2cZdrirwm53Xo2bHDdioeMunO8yki41/oHv6RHuX+mwIIdImvfAP6ZZ74yITXRfvE6dAwCwwikq+c6I90zmxfCs8s+wyV4q0/w7AdpCMYRAUIwwcIMs3SgOjZIA7iqvQJbDieUyIRSbYmkvC5YRD7LCENJj1OUIhteKSmCt6wBbwcV4r7AEC1Qq2oShUv4UnnbOw3zH3e7tEfAYgyxjwkrB+flSggW8jby/0REvUed5NawFPO0XxkUotwSZbfjL/fcbm08hEdW4yLAB+Odb1fPgk/ujWBaMuYr7m+TyYvgz/IIeL3rNAZfSNgDUwHO98WGWBQ1FeKy0HHNq63BOXb3IE2FhgUF2OxbW1HqNVl6l4NYbRY/rDNwrBroM5Yn1Dbg3MR7z01JwwGxGkVXsadpwtBQf7ziDu78+gD//le+1ZbByHq11EeGK/fN4EogamAkaSUS1rD5Qv/bcd0lIjVvJfTfTssfrtfzRCJbFRmc27iuvRH29d17gr4e8VZ9rEI7etrdE26QelbtMn3q9jue0wGDeKKhKrI7vB0x9DOzAie5ttD0JtqJz4HS1jpA2FO1ns6OTk0I8w2CtcxIATiJgY04ebnapykt/Z4Pg+xGarVaZ3LfbzB9jTmXrSbzRG2c2EYMEibTXOm9BBeutArvE8KPsax2CcuatJ8pl95lK7sJS44/oRubJPq+OAYzAEHjWORe1bBiWO29wX9x21owrHXdgFXUhHnLOxwPOhTjNpqGqrgEWOGCAsoX+7Dpxufsj1BVY4LgTU+xPYZz9OVzkeCCAc/bggMlLlRnwnpQmCyoehJSwcfieGYl/XF4bHhNBu1sdbDJ5vDXSgT6a4AxAA+HttxlrOIC/mF74iR6C/1EX4LOd3KpnvflWTPpmIFDENQ0VKhufZNuBpbylA0gzN+j/asrAY87LZL1/atAN4s9HgMXlNXX4Pr8QqTSN6e3boW/HTDwSn4IPqUl43jxY9jiEqRq0TVyKGynIlXGY1IW+LpbpvQUAF7m2j2q04YeSA2ApbgLq6HSiq8OBhIZY73MR/M13nb/d9DnON2xxbz/MZiDFFVZhabF39FfGU2b/vHMOttK9IEWYh1J/6nrspPrhGepi/MIM8drX7gp3EmHacp8AYBR5AE+bXgc+l8/34rHBgnpWHIYrCuO+s3UR4XiHmoZ4Qlw95IAJhxlO3JH3OB57VCzoWFc1FA+WVWBso02UWE6qJGuflCTyJprb406Z9i38qOCwJuPbqEjstVrwVWQsDjEdvfa9/9tD+GTHGVz+5nYAACW4XkmzeNH2E8P1lWIoeW/3jcY1ALiQ8DaGy/9jTRHuBpj786qx4rO9+GG/eEHpqBwhehxNNGLdLeJw/D5XKPSwxYwPXe1oJhi8y5xzKz33wbf0SADAq9Rsr3GpKxHImA3RWP/qBR3g2PQcTh/2iKk2nLwVzsrR7r5YrMRUESqdDxFoIQl1oO5LEi+muxJig40XN00TJOZfW1mNObV16OZ0YmA9957tFULczYneOLOJSBdox9AgUScj9iZc95cKSrB3Md0AQLZMlSeF4AYWX9U6cnQl8nDUusj9+AdmOPrZ38DvzEC3UuZxJgNH2UwsMf6Aa4xrEelSCR6z7WoctS7CzcavNL/fGTYFm5j+OM62Rw6bKlIO1grv3nWyBrwj6JQuJBzi8M0gmUotyhSFfDYBTxtfw4PGd0XPRcCGmyqrkOxkUFXhSWxOIKpF+w0k/3X/bZQYeTbWhHqE4TrnLfiBGY7Pd3EDUmeyEEaqARU5XGJuBOEZCLkYv/fEQpq41VSluRFv0OdgJyMUgNQS3JYmxoqfzXcppn4eY8EjWIq9jgEKh6EhHSrChNVYgsatG3Ly3IJkPHMUwkz3CibHZKLK/bcBwJf5RRiZ521sCaudfgv3eCZiCE+IKg0Vnm9TsjL/iR6KBtYCGyz4H30BLnPeixl2cesPPpHWWdMbjC0TfCsToQeGZxV9PgDg9xPK3iapAdWbzFHcl4f3Eg2yr0YP2ztoOHU9GgvmIMLuMYIfohbiO3okcpkkfEOPcm/nxwQaBry9KBtmo/i3u9dwLjqTD+MxnIM81uNBVLuitkoqGI8UVuOKmlqvSii+0a5TMC7VkARYRt1jduuUbljcxSNOZwjPAetaAEQb0tw91e3F3iE8khKHN1dSl+FR5+Wgr9kChyAB/Os93mFwZ+VI999XVVXDQDWi1k6hjPV8zz9EcAZVsdGInWwP7GG6yH6Gf0s81/ktzusxyf40PqQne6mYjyGVk/OlUDUeDzlf2UezBOC0wWwrh6XcuzSeMHDGOWNSFt271vo+d3yJd0cqLSEURWQJceUYzw1V1fi/0moQADJJzsvuPmoIupIHit44s4kQGi4sSNSzYfiV9h6s+9rexCDba5hp93SOXkVdiNH2F0TbpPQhTwMAuhPqCZlyCA0vgJtcWZBgQOBvl3XviOAGgmSiCqlEJYygkREfhpGCEJZW+hInMZv8Ez0J34O6EsPsL2Ou/X50s78nSvh71unJ/RlCinNO5DRoVvb9EQmoxUXGTVhk/FX03D9MB4ysZ7DgdE/YbVmC44iNMaFBI3T9A8AdzmtUP8dz323H3twq9BD8bn8xvUHKDESN+ZfDUTECDadvUD2mEGfVIDTkLAXAaYUIUbvZ7RQDZ+UwOCrFnZdpexKYxvZeRoIo6VbwnIVlES1JVvyDkvcI7UBf2e2ec/U+4z6C/COhoN/5ghysPuRpRDGMq5WC+BpgQWKgfTUuivlYUAUn/mwJNI3uTAT6JItF0HgDosLsqQIkXKGTBo0tUGLCTD7DjK9R52KmYyXCYMNMcjumkTtB2zJBVQ9BbsFSxNUnw3SGawdygO2EMY4XkeNSuR5MHvcYNyyJD/7KwYRnNoiOb0n6GeEd3sS74e3xNeuZ3NXUlklJWHK16Tl8HRnhlWc03GZDu7BkWCs7uLdxwv7qxriTYVFUKfitWKDh1I1wVvfDqCiPx5I0e3uyrbZ40XjbACvepGfhvk1a+vt5zmuYq0Lpwle24oxANVwaMRYubpRgQOIEmw6AEHniuXcUXwHSXMDbBEY/C0JUDPEDPRSD7Kvx92FurJvbWARb0TloyLkaUqTe4IsEHlSjQd7b2sPltXyhuBR7T51BikT7qNqVdO6UfCdm1wLngMvznWsyYYz9eW0lk02E3jgzhAhXaMfYDBSw8djvcseWIQZXO2/Fe9QU0WtqEY4KRKMUseho+xBZto9QjhjkscmipLNQInSTDrW9jBxX5RMLEodLLkNsfSIa864AACS4Eld7xAGb7/DEd/1RzX3E9A5WmV/G3caPAz7nBlixi+3hXsHxCFf8Uj6hJnpte2trLjJI+Wu0AInoZ38TD1BXAiDgdOkQOVnxBPkLnY1KNhK/0NkACEyyP+1+7jtmJHzx0bYcRIWJJwXa5i3KxVIxsBefB8aR7P2c5OuvP7kMjfnzYCu8CHSDK/9D0tST14i5ySHOl/BghL3oQtGWhpO3gDMQxG/4Q6TyZP6j5LlnBJUhQtY7PcaNXGLsQELseTsz/X3RNHFUUSGXRaXBAAdBgKUtXs/aYcaBYo+RFAPPJHiL4zpMbmhE539HY9cecdJllSt5/xTj+T06MlUAgCxKXseEccSJjKfM+HDZJHQhT1CX4gSbjljU43nzq3jK9Lr7OaczCWfOrEBFvVjiX1hyLCxx/+NoKU6ViSd5YxQXkjDH/YXySI83Q823ssB2Es4ajzYTYarBQZn8pe4OJxL3TsHEKs97EmDRy+DtRRWydn8BvvpbGK4hwNjbwVZwGaINwoR+8TU9o64eqcXZsj3ePtlxxmubGsLrKZT+BhYkaljPIkiaPyRUlwcAVAwHVcp5jklTlShBfpZhB6oRicLdawEAUYQNzsrRoBs8MiH1J5eh4cyVgENsNKkx2f4UGq/aKLoypUvDbg6ne0FxTOHeE/4Kuaz3mNac6I0zQ4hw0HLCgDH2F3Ge4xHRPg9QV7rF+86wwkmLcOuotCdKMZPchiGEd48YtffUinAgkL5+i3MUcs/cBqpWnDCczohduv4YNwNcXbTHGrS7Y9UQGmeXGP7QtJ8Q4bn/JinzpQW3ND+oSL+jSkRjiP0VXOu8GQBwgk3HdY7luMjurYgq5TSbik5JkZCuZBtzr4S9bBzqjt/l8xhyMPZ2oGoGSY4rr1P0FyNuZDpV0sGeLynn4K4Vur47Ggsu8nkeBIC0enFJNKvQxf0ek8fY5Va5YtKIctCNXP4I1ZDlFYDdp1AWToATJLSRpJf4IMt4v2YP2wV7mU54l5qKb5gx6GZ7T1Zvib8eDtg89y3vLSQVurpTdT1Ev0KNTT4XYZbrNxDmnfCvsxAUoiBvPPHwfdSOMemYYH8Wix23yYphStE6fmQS5bDle9oj1JAEvoiW7ybPgkAqPGXDUYQNhFFdc+VkKff5+Z5owhyvN7cIdJQEBvs5dfV4sKwCZmesKIctUCoMBsyxc/mAWhTR/UE45hyS5Pq9Tc3AV/QYbKD7I9v2Kh6grgQRdRgAYAjLdXtFhKj1c2Ps7UDXd/f6bYV5cuGS1VEpGwsmuY+7/cKTCXF4NTYalSTpHg+6CkJUcrIRDEugpnIUqIYs2Iu9G/c2N62iceaBAwfw5ZdforTUd+XPnj178OWXX4r+rVu3LpCPEXIepjw3/1Emw9WTSPgVs4hCg3vg/IOR18+4zvAdXjGvwheWh5vkPIWXta8SS56SGjuqGhzuXlKrqXPw8dJhPl6lzo0T5GPXvhC6eU2CG1+q+aM0cNsF2jt8kuh6Ly0TFgbXxGgRaAPxUDCKftufmGGqk8nF9vtwv3MhtjB9kBBpRre+4vAPS8XCUToDLBWreAwKBuSxichjE0WaQ4ooqAp3dSUm8gJglfXi3lCMU+4cCFDVg+Go5L4vqUItT2/b29jLeMI5DBUh28RTSi3C3BUtQhpO34Daw0+gMedarPr9X1GyrzZcAmxO7tgs5f29OWDC+Y5H8SC1yP1YDl5+YBh52L1tjzuMexo3C5qyMhQ/8RPYzXZzb6+1UaLrkvdYta9NcO0t/72aFcTgeEh3ng2JU2wafmfEnh1pYjJ/bn53tXchVYo+X5BXxYKAQWLsCT9zY/48xeMyLm+D0jXDCryoK0vLEc6yyGcTUaHlflCAreM8J980XIDdLDeRpxGe8Befd8JfQ7Psj+EDyltnS40oQY6ddFz6m+2GW53XYZHzTpS55D4cZZzXma6WD91+50pYPsUoe0fsMOEVajYGN3Jeyl6Ce4fvM8YLeJpAg4WnOqvQaMQrcbHYYo4HY08B0dAeCTSNL/ILkZQ/Gf0k2ltvUDPR0/4OnnIuAJ1zFV6r3Y73TLUkz5gAAIUgSURBVE8ADnWjvCnxP7MTXOPMsrIyUeNMkiRx3XXX+dU4848//sB9992HwsJCnDx5En/88QfGjx+v+prVq1dj7dq1GD7c4zLOzMzElClTVF7VPBxlM1HIxiONqJA1GkiwOGD1GH9KtndvgTqmLwJpqig8M6lglRJ72K4Y8PA6GHEDXqPOxSE2C2ODjKeSJAGzkYSD8i8pmj/netaCCMITXljtKsHmmWHYATl+ZIbiPHogdjLd3d+fmpFn9TGxaGE72xPbaa6KIzbMhEe2OfGhWVxy7gsHTBhtX+V7RxeWRI9Xi6rrii/pLPQgzuATM9fHjP/Em5l+klcq/x72kllgnfF4ppHLudrLdBL1KwNrAgiuUsleOhGOsqk+z3MT3Rdf02Pw/MUDUPJSrDvUKP1Fyurs6GSmcHNFJV6Ij4OzaiAA79DDt/QoNJKcIUKaqkA7E+CsyuZUbyl5b4MWYl1Jyz1JT77UCZd7vjisARPLG/GCS8jPWTUEpLEKdGMGnqcG4nnqInxx7QiEfboXrKBp20QH1zmZYEphKt2nYFj6XoR4er3J38+97e+4/7ZWfwpTzF7YyyagIvKIYs+1M72vxZt7G/Gw6T33NjNthMNA4T37bACe+2uWxPvHdSbnrm0jy4omdM7DqAC/WGG98+UAgBV8P1snfY2Xf9qJAiTiENMRsww7ZJoK+4YGCSOAQkHui7Aa87Ar/EaauMKCQ2xH3Ed1xHyj9rxDIWqVpjxUbT/UHc8ESUUA1h+8nv+JGYrz7A/jBKvcANQOM56iLkEamw+gVKSKLqUMMSiq9s7D2cr0hL1kJuwAOlluRDuiAn2i+oHXen3GeRG2MH2xn+3kNpQJsJho2AsAaLTZEWbW1vg41ARk3PCNMx988EHs3bsXDMOgf//+fveXqqysxMqVK9GxY0dkZGRoft3w4cPx5Zdf+nvazcIGuj/iiVpZgT7hALWX6YTfFTw3WkyGBtaCcMIukh3XinAVaFONtAPZtleRSFTjlKuslIIRB9lOms8TAK503I5nTa/iVud1ou27Tlf4bdgI31do2ADertov6bHuxGs7a8QQ+6sAuM9wlZNTe77UwLU5UHPPq1WtBcKm46WKIa+mwpa7CPfBiTA48Lf1WgCeyhapmW2Ok+/kDgBgrHCUT8C3ZBimmVfBDjPAGsA44sA5gkm3hL4l6Xcv48ZeNh6WxA2ibQucnEbNj/sLsdu5FO+auRymNcwoEIY6EIYGsHQ4aFfoYVxlJB6rvAWMIwlfmcoxx7BFlJRZJsxVc3VQdpQFv/hZRZ2PZcY1+MwyBxfbvasFlyVzuRSNBXNB1QwAJOE4luXajRwlvTtcs44kOMrE3gDh9exrETLIlZ/US6ESaxBxDP3IkzjMdMD2gnmwl04B60wAaawBog/JeuJYUwTMEFeB2WEEAQq/MdkQGjedGy2A637kr+nx9Q3YZ7VgUn0jjjVyHgaWVh9veG0bpTAWL7oXTsbjsh9sgCsp/QDbEe9RU7Cb6Sb7OjUI0jWOCLzA/QlPG4O3CouxJLY/6kuVQy3PXtQft37hXR7OM8j2mvu+y1JoJiyFpWJBA5hmfwJrzfeIvNQAgX2sNs8374k8ybYDwKUI8L92o6DB8+TnNiGqp/i1GQIdNf56LKoVJPXDgL2S8xBWw9bW1yEsWhymbi4CMm54+MaZgXLhhVzyYl6ef3X/1dXV+PHHHxETE4O+ffsiOrppEm/9ZRa5DUfYTKynByKP9U4CFZoDA8iT6EXkYCu8jRNfBgfAZdh3I/J9NMmUR5h8aPfRK7sMMaJO4UIuft27kaccfzADMci+GlJzSEnDxxdn2GR8S49EPpuI643fubdLjZt36WmoYKOxyvwSyhAja3DyN+9wQaiBg8BQ28swExTqENqVx4fbzmAWya2SuviheUGAwVIDt4p7j57GGRYqOCqHwhy3A87qATiX3I5V5pdEz19dVYM4hsGntf4byJEEf/75YOlI1J9Q1+BhGTMI0gFn1RCwzji8Q6z22qewxoYFwzMBlzwRxRoQ0fVJEKQTLG1G8fGr8btlEg7VR4GhuMnyENMRcwxb8LcgFCaUR1AL8/nLc9Q8vE3NQJ0tDP3MO9GTFHuN3KaiI97LsAGANJea7J9MX1zruBk1CIcVdoTDDjs4CQHx8VjRIzWqFdTOecYb9mKZcQ3eoaZhO9UTrJMzEhiXtlCPBu/z3Xy8DFsipyHf9jNOJkzAo0P74Ikj3MRWB6soEPRAUjReKeMq/orZONSwYfhfiacq8xW3caZupNlLJ8MYdQBUrbf+EAD311BnF7dB2Mz0k/FAasMQzv2OxsgjoKo5HaSDbBYywI0NQ2121JxeDulvUMJ6vIxqhg0AVCAaF9ofxLmGv/As5Tt3TchRNhMXOR7AGsv9yGXUxQzlaGDCQVJRWGWfi+vAldvzC22HRLjTXjINlmRPq5ux7Ek8BSAJXNUsANTZaah1/WFAYpz9OTSwVvwQLi9C2xwEZNzs2bMHH3zwAZ577jnR9hUrVmD+/PkYOFDeIxEqdu/ejRdeeAH5+fkoKCjAqlWrMH/+fMX97XY77IIS0poa5fr/YFhq/AEDyBPIdSQpGDdilGT373YuwZumZxQbawJcjsd2pgYlbKzf57mZ6YvrHctAglV0Y4eeUHooCCx3chU/6+mB+MrC3bC9yVOSaiUC+9mOWEcPcle6SHmRuhBFbJysF60EcaEtmxBwjOVW79uZnj729BAOO/7P9AkAYC09AgVQr4awF88GVdMPdGMHkMR2r+cH2e1IKYnEJ7T/+QoDCK6gIIGoBQgK5oQNAAg4ysYrvELQ7blqGCzmnwBSLPb48fYzsCaXga9xI8CCIDlDnDA4QCd0xw3VHdAo0LrhXfzCsv/19CB0PkOj3ujEcbt/3mRfVLmacs5wrMRp6+WIohnUGkiYaRKnXPkKprjtoBu9m9ymx3LGSxli8LNLlO6gZbFbQyrLJq4mFEZ9fYWlPqQnI5aow2ZaPkdjsYHrPH6F4Tc8RC0UvgsALqkaEIfDD9viYLNGY5R9FVBAAGsOIqond0OQxhrYis6BNZWr2jlpERdTTLE/jXMM23Cf6UPJ+at/DkfZZC8PlhCWtsJZ088rJ2ckeRCvmV7AYTYTFzvkE/vHd0/ChqPKeZ2M3ZO/cqNzGU4YuDnlAvtDsue9k+mGWYYdqGO1LTD/Zrvhb8p/zxLgMXSlw9Hknsn47bB6hTJhrAdprAUl8PxsapyMS4vyMYM5gncoQc8xwtNMd3F1Dfq48nS6CUKxWrzNfAUuyJZrghDQOy9btsztdRFy4YUX4pZbbgn6pNSYN28e8vLy8Ouvv+LQoUO45557cNVVV+HgwYOKr1m5ciViYmLc//wJgfmD0fWba03S5UWZpJxk22Gi4zl8xYyVfR4Anqfm4j5qsWyViS/qEI4fmeFYy4zwvXMrZzfbHZ9TnCxBpYwKdCZRgimGvzE0LB9GmfYCdpjxPj1NkzEaSo6z7dHP9joWOAOrjtIEawTd0AVgTSJvhrDsmgWBhAixB8iX4JoXBA1L0m+wJK0DCMZd1s44POE8T3sI7jdQktNPq/CExFIl98eUbnH4JP51vGB6yd2N/R16OvrZ3sADzkXu/UoRi731U3C8eqZ/n8MvuM8xz9V+oUONQNFaRkOEIIDJz2/02s4bNnLUCPoS+ZpQKBjxAjXXnRAreg+L0f0+JknlDWNPgaN8LMbUeby5fB4YywKnyxsgnNidtT3B2BNBN2TBKVD3zTdz+xxiOqCSjUIx4vGtQFiw1sTlsMh9N2pcOlQ8VpPGGpii98MYfkK0PQqNiCYa0A7K3uAxXZOwdExHr+31p26EvXQSHOXj3dtoGNxeEqXv/v+cS/AidSHOcTym9eMETBmi8QE1GWuYUaLtcwdrmcu48xcaRi9SF6BbXSwG2h2SsDs3Tkyvb8BiQRsUteosNci2pnOza9cuDBgwwGt7//79sXOnSrw+BEycOBHhAmXSW2+9FdHR0fjpp58UX3P33Xejurra/S8313/hOy1kxXMWvFZviLTTtU5g8JUZckYlPzCZDATO7a+cfNcS1CCy2TxnwgqzqY6nsNSxAgDQnijD4tHiAd9WwAkj2su8y6F5hN80QQonaAYpBs4rQdWLRfAAAKR6cjZfBQIAn9BinaIbx2VgQPV6nG/Y6l7JUjCiBhGoDXHoUI1uKZyn6yt6tPuaq1AI3fKwrKfcWSvCqq1gcrO23u2t98TD2NrDXjITtzdyOSZ/0b3cXs5qm7dn2Za3APUnV4Bz+hvAuBp68vzGDHaH14T34wkmsAXlJzukY7X893ChYTMA5S7cAPDI2n/wxmbvYg3G1p7LyZKIXhKEvLeEpxqReJ6ai9OSxrpNwVDiKOKJGpxgxGPY1hPyfbmE8HlMCPN0nx9EHsdEV3uaREELD0sSl4P4taU9KJbEWxSXZzRIoDklFDH1tZBvOdMmwLBUamoqtm/fjkmTJom2b9u2DYmJ2oWDQgFBEIiKilIVD7RYLLBYVIKEIcLmcCIS2iuQHAoVATr+kQwuFixNMAY8N5/NSaFvegy+kZFgbysIQy+NGvKyhPzMDMUmui92Mt1BwYhMQVLj079IlJ1r+6H2aFeAUS7h/pvtikvhqsaSeAPiI80ok/wUtqLZIAz1YB3cavg3ejAuMPyJKomy7wG2EwbbXkUlosCAhCFnCSyp38JeeCGWP/kK3nF97OZKxJZjSq8UHCuuw63O62Gh18KMLWgUhSZCc242mDHAthoEWC+ZA608cG4vRFtNqB1wNaL2vi4OQQjo6qo645voAkAy4d07ivtsns/HUDEgXU09/2E6uCdDQDwOEi59IWkXbp7ESAsuG5qBVb/7UP91XWuEq3LJfR5NcD3wjXbDCXuThae10ovMwSzDDi7cI7A53/9LPoFcDsIo9sTEE1zSdg/Cu+KwwZ6BPvYV7vxPg+Aer0YEhthegYVwKOZjut+nBT03ARk3ixYtwpVXXokXXngBY8eOBcuy2LRpE26++WYsXrw4pCe4e/duVFRUYMqUKWAYBhUVFSIDas+ePcjJyUF2drbKUZoHSyM3YfjSpOB5ibqgKU+nyVk9fzCu+WB3SI41pVcK1v2jrYpAyhgDF5KcRu7E85grem6wa8XRiT6NiWv/8XptW8IOM+5yLoEZTr/Vq50wuquSAKDRVyK6imEDAOWu3jv7GEluCQEYjTbALvboCHv4AMApNhW/0NnIlQlPlcMzYNINXdBw8lbu0IJGqIHqs4QCgyCPgC/drnBkwoq/FV4RGGZQ7kR3PkfHX06U1mHmi5txpHAsehJZOMxqlx4o1ZDPZyu4GNaU7+CoGIuZDvG1wIBEHWsFAwKkguYSz5xB6cir9B2yIi2c+jIh8QAeZ9MxA6GNGjhYA8wEjVMy6tnNDZ9bJlTT9hfGnozjTDq6kuJCFOGiiarrBmPkMVB1PUEJDGqhEVPJRnGeUg0GXwvaNoEZN/fccw8KCgpw0UUXgXH1IyFJEkuWLMF9992n+Tg5OTnYuXMnKiq42PrGjRtRVlaGXr16oVcvLlv+1VdfxbZt23Dw4EHQNI3Ro0dj9uzZ6N27N86cOYMXX3wR06ZNw9y5c9XeqlmIYrjVRA8iF79DXsthLT0M7YlSvE9NxTfM6OY8vZCTGu1/pZYSgRo2QuQqRgLRAWpO/NX5+ZRWDjH4w1f0GEwjd2ITo9zfSQ1hgqNIO4Yx4mDVZpAmwBCurNf0D5uFa5wrAnpPoGlW6lrZn1cFAOhJ5CC9OgxHa69GLtUJ1rQ13LkpeCf8JRKNeM38AgAgy/YRAvEI9UyLxofbzgAgvZRxlahgIxFP1OEo6zuUxDrj0Zi3SPa5WoTjb6IXEplypBnyUQ753lAA8E9hDTYf9x1iUeIjajKGk4fxDR26MZX3DrZkaIVnsCv5/nLjetxDXeXXa+tPXQ9jxHE4K4eDMH8DAGAFDbOOi/I25eUhPqMnuPWOtOj08ISZWy46EbDOzerVq/HQQw9h3759IAgC/fr181vn5tSpU/j0008BAHPmzMGBAwdw4MABzJs3z23cZGdnu0u9TSYTdu7ciXfeeQcbNmxAXFwc3njjDVxwQevwgPxCZ2MKuRtf0WMU97nRubwZz6jpWDCiQ4ta5UJucVyH643f4S7nUq/ndmiQoG9JzAb/RQxDgR1mLAwimZlvvjqAPAmwJtQdu9c1GRhA1faBOX4rnNXyDTMBzhU+w7ADOUwyvlZJnBdiFPjjW9K44StufrJwnrB61oLe1Dtw1vaCKeofUdVNMFjhUYE1gvZq4KqFe75RLrRQQijGFixZTC4yyVKQJrkQlwethg1dz1UbsYw4P6YY8ZjneCCwk1SEN268v4fkKAtKar3D4E2FJQghUcaWCYeN89h1Ibm8GwNBYwfTHUPJo9gjkFEgDPKJ30LJEH/OxWJsY8aN2WyGw+FAamqq3waNkPHjx/tUJL722mtFj6OiorBs2bKA37MpucZ5CyxwquqPkGBAgnG5AluJdRAANMMGHU99/uL+eGvLKRzMD640/xtmDL5xyBuUfzG9cbnjbpxkWlcyMQAM7hCHnmlRrpV103DooWlY/O5ObD8lX5kXKLymyCcUl3TMCsvJWfnVn5DuxBksN36NzXQfzcaNUBK/JXNupLg/LRUJxhEPltae3HyQyUIf8jRyGO9qPRPh0XIJtFolEPgE00j4V9kkh9GVq2G0hSa0wziSUffvbeLrrYmwuAQge5BnUMCIc0mb07ABgG5kaHMFk1El8Ex5ri1DGJfAbU7YBGeFcEz13G/pRBmKQyxs2hQEZNzExcWhtLQUSUn+Cwqd3RA+hdX2Wq5GNNGACfZn3aq/bZFIS1D6jwAAAoTfFSSB8GeAoZemZndOJXbnqK9og2XD0VIcL1FvWhgIp9g0dLO9J9+HyZVfQSg0kwSAcYb9AFz5UhoXggcYYVVXazJuuM9rL7oQ/k555zge93nclmIMeQB/04HpsgBc+KKdq5zfbEtCQ85SMM7g1WpZZ/MWrRj9CMO0FQiwiHbl7wg9hG5kLj07a4SFoNwaXVqgaAZGQ8vkxwX0rldddRUeeOABOPxuYqfD9yzpTjRNOXpzsTe3Kuiw1G+Hi9HgaNmBIyPed1NHf7g4u2k0lALlho//RkV909ynSg0mzfFcXydzwibF1wYycfOJj8JWC60Btf4+wVAh0G3SWoEZKKupWQCA1wT92QgfScD+4IQRdENnsM7Wv+L/L0DB4O6R1lXOKySjsD3A/jr62173S7HdQTd/yJ0noOX3+vXrsWPHDnz66afo0qULzGaxt2LLli0hObmzGTMo3zu1YsZ2Swo6LLV2f2FIziUx0oKyusDcxLkVwbvehXy2q+WM1h+XjcHMVZtb7P15WMbEtUxglFt7UAHIIPC5IImo9rGn/0zqkYz1R9SVXgHAQBKgGW7Sn2V/HEuNa/EMpdzlOhhqEIk59gc4wwBNm7vwCT0Rm5h+yGcTca1xbUiOKTTIqln19hCtGaqJv3st8PkxwVLNhiOGaMAhNgtz7fdjhmEn/idQwndUZcMcuwvOqiFer22E1e9AJdGCHtaAjJsZM2ZgxgzlJmI6zUfnpAicaIbQjpRrxnZCsUrcuU96dNC5NFoJ1LBpah6a3RsPfHdIdZ+hWfFIjDLjxwNFQb3XZcMy8feZ0Ie4lozuiDe3KFc9XTgoHV//LV75NeRcC0vSz7CXTld83dv0DFxg2IJvmZGK+0jhtV745MYrhmeGLF9pVJdEbD5e5nOledf0HnjsR648+xCbhZtdbUCaCjnF4abgNJvmFqM7waShM1mIg6IwYCAQWOa4ERFEI4rQcj2GAoXvHVXItvy5y6mvBwItSBZP6TMBjxwQF1x4PKotJ7UQKgIybh588MEQn8bZQZTFiFq7No/MUVfcsntKFI4W1/rYW55OiRFIiwlrduNmRKcEGA0k0mPDuGofmQmhKQybe2f1xKM/SBtctl6cGlyyBpJAh4TgV7W/HCzCx9tDM9FbjCTsrgouNcMGALb+Ky7tTY22oqgmHY256uWqh9kOGGRfjZoAlIV5D84j5/XBkcJa7ApB3tLDGjWQeMOmpZncMwW/HQ5ePkGOepcGChWCCe47P4zX1oZH7qDl87sKQmRg8fcOCRY/HJDznHP3Pcu2feOm7X+CVsRn1/ju1TTZ/hTmO+7CUZeYljCyY/Yj8Wpyz2TcMb07rKbm/wk/uXq4+2/Wj9wJkyG4QaItGTYA8LuGMMe8Ie0RE6bemV0L5UHk1VwyRJwndOd07eXzRTXi3kg3TOis+bVcl3Zt10R6bJi7Yoi/4k6V1YfEsAkFBpm+ZU3JmwtDL1p67yyuiatnUpcfWxaO6BDy926dqLdfaE54L9rJmOD6AfKVcBmE/Nhkit0DADBG+FCK1khz3xdCAp4Zv/jiC2RnZyMiIgIRERHIzs7GF198Ecpza3NsOq7c14TnX7a9u4wWAM4f6BFQ2nnvZIzpqi1Z8s2FQzC9TxpasmqEZVk4ae7WXzZJpo+QhAndk/HK5fLihpvvmIDkqKZvkdHUXD/eM7lvPaHcxI9nZt801Gv09qkxd7D2CgYpn+4U5wkFUwk3orP69bvlTuV+VWrkVzWiF3EaANyy8ROf9W5E6Q+hTCbn83Cai9yKhpAfs2capyfWlzwNQHkCvGFil5C/d2skyWUIxBOBedZDSQ6bjK/p0ciJCc6ofYk6D9uYnqI5SEhj/iVgHPGwlyiHlP3BbGxjXcFfeeUVLFiwAMOHD8fq1avx+uuvY/jw4ViwYAFeeeWVUJ9jm2GLnwqbU3uliF7z3b4CRUG37imemGtsuGel34KGsSgcdsVw37Luv/5TLDsJfH39SHy3r6DZtSOagr7p6r1WpBAgNMnO+4IKYVXCrH6BSxTEhSt7odJjw9A+rvkaXPoiOcqKlRe2TpkAX5wuD30o+tUNXKftd6hpyGMTsZYeLrvfmfIGTOh+9suA1Lq6she2Ak2XXWwPrHBeD3bkTUEd5xnqYlziuA9OhYwUqmYA6k/cAcYefAVgQoR//e9CTUDGzbPPPosPPvgAL730Eq644gpcfvnleOmll/D+++/j2WefDfU5thm2/OufcdM9NQqzBZ2q956pQqKC92JQh1j338IqpV9D0LbAX+a8ypX6CkNqURb5SW1UF3GseM+ZKq99cisaRM0btXqvAOCxC/qgUxKXsxJs2CsUjOjsX2zcbCQDdt0+c1F/999LxnRS2VM7z1/cP+Dy/B6pUXhLJUcnv6oRNmfgpf9bmT7ccUKUf7A7pxKVDa1bziJWwVhsioaE/Pj1ELUQo+0vogrySayPrP0Hfxz17aVuCq4ZF5rrXAtN7Yu7dKj8gpAkuOq9r68fiS7JYrHCsjr/rtdXFTzlzUFLhqSAAI2b3NxcTJvm3V122rRpyM1t2/otzcW4bkm4dWp3Uc5KQVUjflAoj+6YGIHn5nGTWSC6Jf+7dGBgJypDXqVLotv1OMpqVOwh0ilRfHO+/af35Lf8072ix/70mLEaDW4hwAiFcMptUwMXImsOvtydF9DrUqIteGfREHx57Qj0SY/Bx0uGBXwO143vjKtGd8TB/BokRVlw+TBu4F0wogNOPj5T0zEIgsDhQk8i+RMyXpG9uVUBn2MpYtHf9jrG258P+BhSDK2lh4gCVQ3yCodN321Z+fj78kJfiq8FI0ngpom+w9+ho2l7Sykt4hgWWH+kBP3bx+JfiQCnPyHspCgLVny+L6hzDIYaW+AtI0JBQMZNhw4d8NNPP3lt//HHH9Ghw38l2Sw4erXj4tusYHmgNl69/1cOZvZNQ6fECFF+hdDzo8T+B6f67VFQo7iGCx+5B1iVJc4H23ICeo/e7bR1ve6f4QkDKQ34zamQybCcQRBKsjvE4ZHz+3htP1JYiwk9kpGdxbnNM+IDD/m8uuEE3tpyCm9tOYX1h4vx2AV9cfqJWXj4vD6q3hghURajqGO23Pf+T0FwVXTViFR0qQdCS68u5fjmet8VRq3wtJscimFDooyuFV5wtQNRhMk9vdtjBMuDPmQipERajKBo//xJjUF4SuVYMUX7QtHmbDkBPyBA4+aOO+7AwoULce211+Ltt9/G22+/jWuuuQaLFi3CnXfeGepzPKvRWs5Z1eCE1WTA+lvHicIRL1w8AJvvUE/S7Pfgr5jynLbky5EBGEG1dkqx7JmvwACAab1TMGeQtsTX6b1996Lpmx6DLske17lcvsdtU7sFPaHKMaWXd3PEDgnhiA0ziQxWLWQlqBslby0agvnDvQ2moR3FuQDhfnbgzVQwhqTeAkpjsuzn146AUTDrfrrDuzQ9VA6Hy4Zl4uvrR+LxC9pmzowaWrwyJElgYo/QT7itnd05/vdIC7ai1AyqSRLGfeUYNjjEXhqGZbHhmO8KTJ6flys3cA6UPunKi06151qCgH71pUuX4rPPPsPBgwdx22234bbbbsOhQ4fw+eefY8mSJaE+xzZDeqz26otjRVwGvrCUliCUk7DqXO5IQjLwkSShacVeqeDeliKs8GkXY1XdVzjpNThoXCio/AKAv+6eKMoFmdorVTT5KdElORKZPiZ8ADiQz7nHz3ElwF4hYwDQDFBYrZywq6XKS/a9Ja75myZ2wfoV40CShCZ9GyEfL5VP3AQ4g40vFX9qjqfC4YYJndE/I1a0r7/D7xmFihvGX+tMQJTVs7KWK9MOVTjlgoHpGJQZ5+W295cgPmqTocm4URkr5PAnj601s/GYesg6SSZnMVAPwq/0YOSzCdjE9ENhtc33C0KMdKxnWFaT4u9bC7Nx+olZSIgMffWp2rV5rCj0PeyCQbNx88ILL7j/LioqwuzZs7FlyxZUVFSgoqICW7ZswezZs5viHNsMcr+7UnkzL/X+8HmecAMBwr0aH94pHje1cMml1Q9PAEEATsnqJi2GM/Z4e2ZM10QYNCT9WlTKB3ukRuHuGR4dltJau3sQYFlOFVgIzbJQW3StWn/c5/nIIdV3MZKkOwwjLa32RTsVo1iYUDhvSAa+uX4k7p3VEyumeCvXhspw8Ge+FxpcAGD08fuGwtvw4iUD0DmJ+14+3B5Y2JMnmMqwUDM0Kx73zuqp6FETQhAETpUpV0wJ7xEAmivyoq1GfBRE7lZTc7JUfQKV8wz7W8HIc7VzBcbYX4QNFi9DI1h6pPpWHJa+o83JYHAH341HhePdK5cPchdchAIDSaBbStN3ZA8Fmo2bW265xf13WlrrGRBaE3LXv1KiLW/0DMr0XKyZCeHuY8zsm4ZbpzaP9LoSU3uph4aE7l6SIFBa65nwN93uCZXxeQ0MC/yhsX/PmXJ5r4J08vzjaIl7EGABrxYE7209jaQmWMF8dZ04L+LbfZ4WBOcP8L+MUikZeEQncZhwYGYclozpJJsrEh9hxqKRWZjZ1/t3+/u+KZrPhfXDnZFbKf6dlCaBUV0ScPChabIra3+Z1jsV8S6vhRZPoBpqhqUvHpXJgwqGHacrsO1kBWJUyul5uiRHYmQXZW/Myp+OiB4LpSTUGNwhDtlZgXfunpcduN6SHKnRYu+xrytTTlT0QH41EgMaAwi3ou/EHtpK38/VkAP59Nx++PnmsT73k1usaDn+qxs8Anwz+6bh91vHY1w37/O/cFC61zaeuYPby44xBoLAghFZ8i+S7P7BVUN9nmtTotm4SU1NxW+//YbGRm4FYLPZFP/9Vwk3eSe75chM0uf2bycKRfB5LsM7JbjzQ6QrLa25KqHi3lk9cdeMHnjnSu8GajzxArc4SQDbTnri4cKwEj/hMSyL3u18r6L251V7uVTNBhL77p+K9xcPAy2cfFlOHwgAtp8sx7d7C0Svq250Ympv7/yYYHj4vN7onhqFNEHYbp6gG3ggHpSRXRLx4iUDsHr+YNH2ND8n3wdn98YFA72vFWG4yBf+hGr+97tYyVQpVPLnv+WItBhD4l0S9hK7KAjxQq0orbJ7pslvl5tItLL1hLZKwSiL0a8qnqxEbav3vukxQTU7lLv2gqFCWqrv49psVJAxoJjgkltjw7SFALsl+/ZqKCVF3za1m0jhW+5W0SJ38feZKmTd9YOoWkkawgbg1RNOyIhOCbJJ1D3TonHF8A44/cQs3DJZPblY7j2bE83GzZ133olp06YhPJybtMLCwhT//Vd5X8ZSlbO0/3fpQFG4YfX8wdh7/xRM652C2HDuJuLzLPiWDDP6+E6w5VETUtPCqksHunNlOskMisce5ZqmCidBtUmLFyY8WlSLFy4Z4PP9p/VO8bqxHTQDg4FAfIQZn0gSVT+7ejgm90zB/ef28jrW2G5JbjetVDMiUBaMyEKkxYi/7p7kHgBE33mAc8N5A9IxTZJIPaG7/2EcuQHQZCAVK9CkuWL+hKWiJAP1JQraHbwrW7oaVDIEUqItiuGR0U/+gSrXpBcTHpxQmDR3So6bJ8vnZZkUqvCCES9rcNCaSmhZ1r/k7Jl9U71+KznOH5jusxLryTniJG5+EuueEoVL39im/aQ0IBU19dXupUghN0appD7UvL75JACoeoqUPsEzvx5zh/KV8Ke6jxV8df5KHvxwoFB2kRMnuLZf3She2Dgoxl3VOTAzFtHW4NvKBINm4+bmm29GQUEB/vrrLwDA5s2bFf/9V5FeeLHhJqy6ZIBohb9cJoHVYjTAajLASJL4cMkwfLRkGK4dx1nwT87ti9n922G0HwmBWpOHpS79bimR+P7G0ThXkIfQISECb0n62PxyiOtg7W/iaUW9A1YjiX7tlb03u+6djNeuGCxrH/ADXYZA5ZYFi2GdEvDmwmxZ9duMuDAwLutG+HlDJb3v8Up5tqmtiPzBQBJI9ZHULcdohXCF9Ofik0ylvaXiJAZDepzydyVtFKuUVH+smMuVkI7NG4/Ji8HN7Jum6kHKreA8m6YgwlI906Kx+V/fYnTjuiVj610TvbZLvyceJb0lOe6a4d3Hq6TGJqqIlKOiwYHv9xWo7iMk0mJEQqRvo4sgCJ/etYuHiA3Yh2b3xpFHpsMp4x0JtSwCwCmaS8NVPP5WDGqlt8ZKoFobdz+U1dnx8VJ54/wvlbYsYvV5Ap0l+TJ+SRcIdq21Of0SOf39SAkiZby9fMj6dFm9bKJ2kusaaw36UX5VS6WkpGD48OF4/vnnMXr0aMV//1Wk1vrD5/UBQRCiTPtz+3vnK139wS70uO9nfLMnH5EWI0Z1SXRfxBcMbI9Vlw6E1RTYTSuUl186pqPoOWmJb7jZiL7tY7zyJib1FId18qu4iaVcoJZpNpCaVoZGA4kPFotv+ucv9gzkEWYjCILA9lPeJZ98OEI48Cu5oYWcKOMm1iNFnh4xvpIMX5eEh3ik3o91LoXoHTLnGyj8hHf+AOWYuBpGAykayGLDTaAZFv8Uikvi+XN+dt0xd57QghEdMF3iJZzdvx2OPDIdL6p43bSOuVoTM1kWiLAoX/P8YfZoEAW8cGA6ws0GrLp0oKg5LcuyPkNw3VIi8fOhQlz02l+K5yBF+v2pUSkjyEkQhM+JqLDKBocfVXlGklRNrOcpq7P79Aj9fLBIVBnJsCysJo+YppABQYYmpIsQluXyFP93mbwoqZKmlRY9MNXz8KNtCD8P1DTKC+4dLlSWpjAZSMwZ1B4XDuI8aNKfTC71QQnhPdk5OdLdB1Ar2R28206U1trx7K9HMf6ZDaqvbQW2TWCl4DfffHOIT+Ps4PEfxV2rI2UG53IZ+ewNLinzfUGotyrB5/NEWoy4Z1Yv2YuOdyv3V/GoCHnClayYlRiBxaM64o7p3UGSBOoc6uqZKa7VljT/Q+jer3cdgzeghNhdKwVhEqivbtg7TlXgpoldsWxSV7yzyJM/VGfnjKKM+DDRhHfZsEy8t3iooutYaYIQ/nZvL8rWVA2hBO8RC2aAeGi2J9n1poldZXU6hMKOZXUO3DChM8Z0lQ8TVTc6vZSkAc79DHgmj980tAOJ0LC6Lq21q/ah4r0LGTJepYuzxZ6ocd2TcODBaZjdv50orHGkqNZn8vTEHimot9Ne1+O6W8YqGmp9/KjOWb3ppNc2kiBworQeSVEWxRJuf68NG0Vr0mq59fN9Pg3Qaz/cja/3eLyT204qeyK0VPcoceSR6V7Vj7y+VLbCcdcpXH/tJdeJlmtQiLCCc/X8wTjyyHScfmKWrB4Xf00pGfz8tfvq5YPw7EX9Rcn+TprBxB7JmNEnjTPUBD/Z0Kx4RIcZNVXTAeKFxCVDMvDUXPlmmQAwoXsSdt4z2ecxcysbVFuo8GrrO097y0A0Ny3XsvMs5G+Jrodc3FWt4V0wzfDumO6prBKW2yZFWbB6/mC8cPEAAMA/D03H3vvFlTP8xBwegPrn/ef2wvXjuZJ1pYoMPlTBGzWk5K6/8eM97r8LXJPIORpLdH0pGR8vqUOkxYgVU7ohOdrzeyRGmjGtdwrmD++AHfdMcm9/eHZvjOuWhF5p0bh7Rg+vFZ90MrxqNOcN+7+ZHrHCiT1SNFVDKMG/RTCLH2Gy66VDM2QHWv53A+DyFpLYc6YStTI5H8eKvTsjp8VY8fbCIXh6bj885hLT2ykQWVs8yuMpFCqb1gu8bUpG4A8HChUrDQGAF0K+e2ZPPC0ZtJ+c28/L82EgCVEXex5fnhuzgcAhGRHIrilRqFYI/8aEmYJKdCYJTqKgtNaOaKsJby3Mxm8rxomaVZqNJC6RhIfUdLY6JUZo8qLwRQJ/yoThlKizKS9qOiQEXoZsNRlwMN/z3SdFWTDelYNGEAROPzELp5+YhWECMcvqRvnfJF6SB1Uv8fh+d+Mo1XMRhmhGd0l0e9LjZPKr+AWXUniPv3Zn9E3DkKx4vPKHJ3eloKoRN3z8N+755gAA4KSr3H/NDaPw2TXDQRDadbSE9zxBEKoVcwRBeKUpyJ2+muGbFGXR5B1sLnTjJoTUSfIP5KoO1CoRgtFS4LP5p/RKcU8kY7omItxsxLTeqZjsWvGEmQ3upGUpwcZJ+bCP1OBg3CsZz/HHShJJ+ZAWn4R2xbAOboOMR6jX8PaibCwe1VF18BzZOUFUsi2MVztpFqvnZ+PqsZ0RbTVhxz2TsOOeSe59MuLDcc24zlg8WhzKE4a2AK6qbN/9U93frxKZ8eHoqLFihU+YPhaEQJ0wMZGU5FHwyerCn/uj7TlYtf44Xtlwwqsp4rt/nsL8t3Z4vcfPy8ciLsKMi7Iz3HkmwmtIqIchVFM2C1bBShPAhYPSVaX2+fexmgy4SOKpASDyQHVzDepyE590LE6U5KUYDaSitoraJEMHoQ4o/E5OlNZhUs8UdEmOFE0cJEF4JS4r3b5x4SYYDSRe1tBEsV0s511Njw3T3PnbV3l/IMq1413vLTS0S2vtXkYKIPZA9msfI2swD8xU9iB9cNVQ9GsfK8oPum58Z1Gpv5PyfPnC30dNHFEpP2ZcN85AW7X+OJZ9ugdvCtqb8MducNBgWdYtt5EYaQZBcAa6dJ5RQjrXqF2Rvx8pwTO/HhVt+1OmEbTaDBEfbnYrqQ9yeXRbEt24CSHSBFv+HnhQUMWjlhCmNSwkx6guCfjfpQOxdEwn9EmPwZ77puC9K5V1BoZItCzaxVjRM015EPJHn0S6L59zJLwp5w5uLxqcpQYQSRKY1S9N5D4WJmpO7MFVR0nPOUXgnfl46XCRW1y4chEmohbX2vDbPyXYdbrSWwHah71HEIQmXZJNd0zwarOg9H3zxmEwq/9wQUiUIMQTn53ydisLpQekeSBKg6nc57YYPe8rNPhqBav7vfdPcTfmlOYB8ZAEgX9LvL1FPNLfadHILNHjNxZ4kuDVtHCkNkhZnQNfC3o7XTIkw8toiHat4qWhDiGbfCjpqiH0bAo/p3B8kcvHEP6GHy0Z5vZ+nifI3VKq/JJ7v/gIbfe8nHEpRNo89wGZqkYpvDdZWD2odL/cPLkbdt07GXfP6IG3Fg6RLXRQCz/yhrAwr/HO6T1ERpPQWCUIIOuuH5B11w84UVKn2G9Jydjkx73n1h3zaiTLG+B1dgoEQbgNFP7tGVZ8L6khfX9fIdiPtourUIdkeefcqCWbx0eYMb57En5cNgYftgIhSN24CSFSS5lPgJ0iuEHlFFF/uXks7pjeHTdMCFyRuENCBM7t3869Qo6LMHuFf4RI8xkKqm2IDlNeKZf66IMCePIulPI2hKuu2f3buSvCAE8ui/DeMRlIDPBzBcA39ZSDIAi3sTRRoOHwb0kd/u+bA7Jqxd1SotAnPRpXjsrCNeM6+axiUYNX1eVRagvhHtACfieuW/qLlwzACxcPgJEkXVUw3HN8lcMpmQRQOfxJRBzeyTMgjnvqD/ffwgkn3Gz0KvH1932ll7a0z5aBJNxeGPe1JbPulJYW90qLRjuB18vmZNz3ZQeXcRrl8i6qydsLtXj8RfjZhAbU5uMeg8nmZLBLIa/hjQXZGNUl0V2lyXvKaIb12YrAJgjX/Hyw0Oe5brhtvM9mlg9K8ma0CNHxFZ/ZWfFuI00trJYYacE14zojKcrirswTohQuEebMnNuvHYZ1jMeaG7gQlVBwVHivCscoJ8PikqEe426aQFNL6mXijTO1cVlaHck3vuSNHrmXjuoiFvrslhKJ00/M8ipCkX4FF2dn4N0rh8gqwkdbje4cSSFqlYB/nSwHQRDo1S4a4ebma3CqRMufwVmE1KjlO7imx4Zhz31TEGk1ympjdE+NQvcgElAD4Zs93uXKavHS9Ngwd1KlVDWXh3+59AbcdPsEFNXYvD6jsCeW8CZWXweqExtuUtW0+OP28ThcWIuxAndyvSu5WBpyArjV3NqbQtOAjnONn0JcuAmVDU6fMflgGh+ZjaRoxQ6o/75CpCs8f4T3hnVKwDuLhqBDQjgmPrvRvV1a/n/vrF6wmgy4YFA6dp+uxGOSZPwvd+cptka4d1ZPL+/gjD6puHN6D9EE+PV13CTlnjBkPsYFA9PR6KBxIL8aW0+UgyDE3lWS5Iz13fdOxqGCGix4e4fIcPn06uH4fFeuu/yfT3iNCTOhutGJS4dm4JMd/rXjiAkz4Z0rh+DDv3LwmIoK8sky+XBZ56QIfLevALtdOYD8zzf1+Y044cOg/VMgIvje4qGYK1MlBnBh5Xo7pSm5ddkne0SPGT8TM3qkRmHt/kK/lLOFrJ4/GJtkJAfeXpQtCt/2bR+Dz64Z4X6cq9B7TWgk/51TiVXrj6NzUgR+WzEOz687hl8OcUnNUi89byApGb6nn5ilKOJ4orQOfdK5StaPlw5DeZ0DBwuqcaq0HjdN7IpzX9ri3vdYcR1+PVSEqZJkZ6l0wcGCajw5tx8OPzwdnf7vR9Fzlw7NhNzySlrBOLRjfEgrRUOJ7rlpQoSXRlyEWVH0qyWQK3XOUUloXrfCkyDrq+GidDLMTAj3WlkD3Crnrhk98IlK40h/xzNfqpnJUVaM65Ykcr/LhWlCwXmu8mpe5pz3EvCr0gqFSq8fD3A6Qq9uONEk58Ujp2Mhx6KRWeiaHKnofpcyoUcyOkm8VFJxsphwEx45vw8GZcZh6dhOkEXhtz9/YLrbe8JDEASuG99ZFErITAhHZkK4KMdHSEZ8GDokRODumT3d50AShEiQkZ+ghF4a4Wcb3ikBz80b4H7Mz2d8QnOMD2XbT6/2vvbDzUZM6J6MtxYNQbJg9Sw8r8Qos2J7lMd/PIxln+zB32eqAHiMiTKZSs1ws0Ek4UAJvGXZWfE4/tgM2fd478oh+PLaEapeCP5elBZK+DsO8iXm0hCOLz69ejj+eXgapvVOlfX6TOyRohqKtwu8iyKDV/CRt7jyUk6U1oMgCIwR5BK2jwt357cBnB5Qdoc4XDDQW+JBSbdHjpGdE3Fu/3a4e0ZPvL4gG31l0hmu/mC31zapztHMvtziQe43HJgZ505mFmIkSdGitLUaNoBu3IQU6aQuzbFoTUitegBYu0/ZDS10MypNFj/s516vtXEkQRC4dhw3IV05KgvTe6d6JSNPdmnsCHNp1Dh/YDpumdwN628dp2l/oOk6Q794yUCcfmKWe/Lztztxkh8DXiB0SorAvOz2GNstCf8301tMjicm3IR1K8YF3EHdX8Z2S8KX145Q1HZSK0X1B+H9ylesHMivhtFAur0dwgRp/k85DwJ/T/C94viy6yk+Es37tY/BPw9P09QkV1h9aTUZFHM69uZWix7zSfdCj4nJQGDZpK64fnxnUXK/tK+UkiFCEITPAog0V3Iynws0Z1B7fHP9SNkKIzV+P8qFh+Q8q3LwhkKE2egetwKplRC+RviTEwSBWyZ3Q9/0GHfiM49w/DIbSFFRxHkD0vHldSPd4Z4rR2WhV1o0Ntw2HhtuH+//CQoQGlE8Ug+ZxUiK8j+f/uUosu76Aa9v8iyiJvdMwQ0TOmNqrxTZsGd0mBELRmTh9BOzcN85vnOnWhLduAkh30rKCQMV3msuvIwvjQNAmoJqLq8XMzSAxnsPnNsbr80f7DVg8qsNra0TYsJMWD65q1d+ixpa9D9CwU8HfOcwAMBTc/vBbCRxUxA5WHJIq7VYFnhqbn+8v3gorh7ryX9S+zZevmwQxnbjwjS+uFBmhaqF9xcPRXZWPIZ1jMcFA9Nx21Sxx2j0k38olvxq5YYJnUVq4cIkTaG4nyi5V+UGmdg9GXHhJneYhvfOfbrjjCiJV3odG0gC4WYjLhrsCcYq5SMJvQf+GOT8rsK8py7JUVgxpRtunNgV5wt+JznhSKl3Y5iMF1aOkhpxK4TM+HDVqiUlrnZ51bS2oHEboYIrORDjRuihEIZ0SAJYPrkrvr9pNCIkuSXC34hiGPRtH4ObJ3eVXTw8cG5v/Lh8DLISI9xzhVKTX2Givhx8lVKYYM6RemRIgsDEHilekgH7BC1IpvZKwe3TeoB0SSeonceTPx/xer41oefchBCp56apPAKhYoOrc3fWXT8A0K6rslVBPnzdirH49VAxLh8u318oEEZ1ScTHS4b5JWnvL8E21dPKZcMysf5ICbI7xGFKrxR3ibKUedkZuGBgesjDmNLBSlpVYjGSsFOMqmE4q1+aYi6MlKcv6o9Lh2X6VIMWIizjJUkCz7tWvs/8eky0X3mdXXa1qoZw4lk4MgvJUfJGujAcITR8d7k0fOQ8CK8pKFrTLOvON+rXPgbf3Tgawx7/zZ34bnQlWAm9oQ0OCmajt3dD+L52J41PJT3WeKQtCHgdGqENv3hUlvvvKb1SMLJzAraeKEeBTG+m6b1TRaq6UhkHJbafqsCNCs9tu3sSyuvtOJhfjTu/OuDevvmOCdh8vAyTe3kS/q8d2xljuiRpzkvkqzOFxQX/SLSKkjVUfy4e1RElNXZM6pns8eSR6h4rI+n5HcvqHOiYGIGbfYTKhfDjHH89pERbUFxjV63MAzhB1TFdE1Faa1f0cJ2paMAkQR6cG5FXyvtceKStILQUBbQkuucmhBhIQhQ7rWpUV89tbdT7UBj2RYeECCwd2ymkmfKJkRaM7JLYpB1mpW0omopJPVOw4bbx+HjpcFwzrjMmCMQWpTRFftZpSYf6fyU6OkcfnYHTT8zSPHn5wkASGJIVr8mDOX94B/RNj/HyfioRyE8mVKKWroSFlS3CAd4q2C+Q92RZeJXzPnq+pyUKKetl8L3MoBhW5FkQ8uoVg0QT0YfbcgCIjVnpwotfsMhVDEo1e07J5GIA3lVQjwk+p5TUGCt6t4vB3MEZ7tYfWQnhyIgPx2XDMkWGJ0kS6Ns+RjEcrkSBQFVamm8kVwkkxWoy4MHZvTGma5LmhZ/QWeJPLyfhe87sm+qu4uKllHz1lJo7uD0+uGoYPr16OCLMBnc4XwilUn3YNz0GyVEWkbq2tGlvgkZpgNaC7rkJISt/OowigSs2kKaHLYlQDfS/hFZxvVCQ1YzvpUT7uDC0iwnzqwdSU3PPrJ6obHCg1kbBEunbGPK3aSugHqYY3CEOW0+UY8GIDrAYDXjnyiGgaFak5TO7fxpWrT+umoQqpXNShNslyp/z0I7xePGSAa68GcL1nOc1SvPYp1cPx6VvbMN14zqjXWwYnr2oP57/7Ri2naxwGxx902PQu10M1t863u2R5REZN5LgY/+MWOzLrRIJZfJIxQq3yoi7AcCqSwZg+aQumPzcJgDe45/wPfnQHwHgxoldUWenNefV+WJ2/3bYdLxUFGJbMqYj3t162v34+5v864HILzZ8hbAJgsBTc/uhptGp2j5EifgIM1653OMFVCrSUCI23Iw990+VNawqG5QX23Lfh5dOTlDiFM2PbtyEEKGi4+r5gxXd3q2VedmBi8a1ZaIs3ATWro0Zo4Fy+7TuXmXiLc1fJ8tx5Ts70SM1SlPrCqW8LzVESaGS5wjJPtJVK8Dlqey8Z7Koc7MSY7omYvPxMrSLDcORQi5MwLdxiAkzeX3/KVEWZMaHgySgqBszvFMCTq2c5X6cHG3Fygv74er3d+FUWT3CTAbRPbzywr5Y+eNhd5PJgZlx7uqWtfsLRd2911w/EidK69Al2Tv0M6JTAj7fmYux3ZKw83QFXlFQOiYIAkmRAo+L5EsW5ix1vJsrPV40MgsPzu6NNxdmI1SsunQgKJoRNdEMxNAQEhdhxquXD/Kq0pMqWgNcWDlU8Mnz/oRglTxcwut//a3j3CEqrUaLtF8UQYiP2VVjXmRzoRs3IUT4Q2vpkN1a2HzHBKz7p1gkRqVGa+j4Gkq6pUZi8x0TWvo0mpwoixG1dgr92se29Kl4wVfqaamI2XzHBK9JRgvC61bq5ufzbHzlX2lV6hauuC8fnolfDhWpitcZDSTWrRgLg4YqJCm/uppFJkSaMX9Elnv7pUMzcXF2hjux9PNrRuDj7Wewav1xr0oXgiBkDRuAy7HZde9kTecVE27CB1cNhdlAuo2LbimROFZc56WKDmjr6h4Ict3BOySEI6e8QZR06w8z+nrnmo3rnoSDBTWKjTyDZfMdE1DV6AxJFEAo0irMq1NygkrzlHhxQ55vbxiF2S/96X6sxehvTtrODNzGsGtsbtYayIgP9+qhJMfoLonY8m8ZbprYPCXBzYXFaFDMXzibUCtlbmm0rh5Hdk4I+LeyGA349oZRYFjWKy+s1tViIqdcXsPJX/iJoaLegWiryWtiUDq/QLh3Vk88+sNhPDXHu+uztGLmsmGZuGyY/wn//hhcUoXyzPhw0Ayr2gi1OXhn0RA8t+5YUErwUib2SMHEHurl/sGQEGlRVcL2h97tYnDTxC5e1VJKxt71E7ogt7IB87IzML57steCIC0mDImRFrcooVyj6JZEN25CiHDOCLYJZWukc1IEtvxb1ionRx3fyOV3tBbUkh2FKCWzakUpMf3+c3phTJdEjFJphOgPnZMisSunEp2bwVW/ZEwnLByZ1apEQoW8uXBIS58CAE588aXLfDcPPZu5dWp399/b7p4Em5NGooI3Mj7CjNXzlcOFSVEW7Lp3Mp755She+uNf5FaGZmEQKlrn3dBGEQ7Pcol5bR2na1b0p9eQTuuB14ZpbYMQ4FFL9VXy2lTlp1aTATP6prm70gfLx0uHY9PtEzAuRJVnvmitho0SfAfu2wWTrU7zkhpjRVZihM/eYL74+u88AK2vIEX33IQQVqXU8mxgfLck/HSgECM7y/eW0mkbZCW0PsN7Wu8UfHP9SEVPR4/UKBwpqlXUk2ltmI0kMluxQnlL89Ds3rhtWveQGZM6OlJ046aJCKRUtbUztXcqpvRK8TvhUad1sPmOCSivdzRr6btWCIJQVa/9+eaxYBhWtZeRTtuBIAjdsDlLeOyCvrjy3Z0ixe/WAMH+BxMoampqEBMTg+rqakRHa9es8IXNSaPHfT8DAD5eMgwju4Qmfq+jo6Ojo9NaaXBQIRVvVUPr/N0qArUHDhzAl19+idJS77b0crAsi507d2Lt2rU4ffp0056cH1hNBnetfx+ZTq06Ojo6OjpnG81l2PhDi57RH3/8gfvuuw+FhYU4efIk/vjjD4wfP171NTU1NZg5cyZOnDiBHj16YMeOHbjlllvw6KOPNs9J++Cn5WPgpFu+7FFHR0dHR+e/SosaN5WVlVi5ciU6duyIjAxtAnL33nsviouLcfjwYcTGxmLjxo0YP348Jk6ciIkTJzbxGavz1M9HUFRjw/XjOysKYuno6Ojo6Og0LS0alrrwwgsxZswYzfuzLIsPP/wQV111FWJjYwEA48aNw5AhQ/Dhhx820VlqZ90/xfj673yU1Np976yjo6Ojo6PTJLS+QJkKeXl5qKysRL9+YiXOfv36Ye/evYqvs9vtsNs9BkdNTdPW4xOae8jq6Ojo6OjohJpWkVCslerqagBAXJy4ZDQhIQFVVVWKr1u5ciViYmLc/7SGwPzlP1d2pqOjo6Oj0wppU8aNxcLJRDc0iBVW6+rqYLUqNxa7++67UV1d7f6Xm5vbJOfHV9XrMjA6Ojo6OjotR5sKS2VkZMBoNOLMmTOi7WfOnEGnTp0UX2exWNyGUVPC9+yRNhjT0dHR0dHRaT5avedm9+7dWLduHQDAarViwoQJ+PLLL93Pl5eXY/369ZgxY0ZLnaIb2mXdkLrrRkdHR0dHp8VoUc9NTk4Odu7ciYqKCgDAxo0bUVZWhl69eqFXr14AgFdffRXbtm3DwYMHAQBPPPEExowZgyuvvBIjRozAG2+8gW7dumHx4sUt9jl4eONG99zo6Ojo6Oi0HC1q3Jw6dQqffvopAGDOnDk4cOAADhw4gHnz5rmNm+zsbJHE8qBBg7B79268/vrr2LhxI+bMmYMbbrihWcJOvvhx2Rg4GQYxYXrPFB0dHR0dnZZC7y0Vwt5SOjo6Ojo6Ok1Hm+otpaOjo6Ojo6MTKnTjRkdHR0dHR+esQjdudHR0dHR0dM4qdONGR0dHR0dH56xCN250dHR0dHR0zip040ZHR0dHR0fnrEI3bnR0dHR0dHTOKnTjRkdHR0dHR+esQjdudHR0dHR0dM4qdONGR0dHR0dH56xCN250dHR0dHR0zip040ZHR0dHR0fnrEI3bnR0dHR0dHTOKnTjRkdHR0dHR+esQjdudHR0dHR0dM4qdONGR0dHR0dH56xCN250dHR0dHR0zip040ZHR0dHR0fnrEI3bnR0dHR0dHTOKnTjRkdHR0dHR+esQjdudHR0dHR0dM4qdONGR0dHR0dH56xCN250dHR0dHR0zip040ZHR0dHR0fnrEI3bnR0dHR0dHTOKnTjRkdHR0dHR+esQjdudHR0dHR0dM4qdONGR0dHR0dH56zi/9u77/Aoij6A498rqSQ50giQhEBoCSWhI1XpTUAQBRFBRcCGqCjFVyyooGJDVBRR6R2kSJNeJbRAQguQEAgJ6T25XK7M+8fJwZlCgAtgnM/z8OjNzs7OzV32fjs7MyuDG0mSJEmSKhQZ3EiSJEmSVKHI4EaSJEmSpApFBjeSJEmSJFUoMriRJEmSJKlCkcGNJEmSJEkVigxuJEmSJEmqUGRwI0mSJElShSKDG0mSJEmSKhQZ3EiSJEmSVKHI4EaSJEmSpApFfb8rYDKZCAsLIykpiUaNGlGnTp1S8x89epSLFy9apVWuXJmePXuWZzUlSZIkSfqXuK/BTVZWFj179uTKlSs0aNCAgwcPMnbsWD799NMS95k7dy4bN26kXbt2ljR/f38Z3EiSJEmSBNzn4OZ///sf6enpnDlzBo1Gw/79++nQoQPdunWjS5cuJe7XunVrli1bdg9rKkmSJEnSv8V9G3MjhGDx4sWMHDkSjUYDQPv27WnVqhWLFi0qdd+MjAzWr1/Pnj17yMzMvAe1lSRJkiTp3+K+9dxcvXqVzMxMGjVqZJXeuHFjTpw4Ueq+J0+e5McffyQ+Pp7Y2FhmzpzJs88+W2J+nU6HTqezvM7Ozr6bqkuSJEmS9AC7bz03WVlZAHh4eFile3p6ltobM2TIEOLi4ti0aRMnT57kww8/ZNSoUURGRpa4z/Tp09FoNJZ//v7+NnkPkiRJkiQ9eO5bcOPg4ABAbm6uVXpubi6Ojo4l7vfII4/g5ORkef3666+j0WjYvHlziftMnjyZrKwsy7+4uLi7rL0kSZIkSQ+q+3ZbqkaNGqjVaq5cuWKVfvnyZQIDA2+rLFdXV1JSUkrc7uDgYAmm7jW9Sc9bu9/CQe3AZx0+Q6FQ3Jd6SJIkSdJ/xX3tuenSpQsrV660pKWmprJz50769OljSTty5AhbtmwBzGviJCcnW5Vz7NgxLl++TMuWLe9NxW9Dli6LeafmsTNuJ5svbSZkQQhjd4wlLvv2e44yCzJZfm45WoO2HGr672ESJr459g1/xv55v6siSZIkPaAUQghxvw5+4sQJ2rdvz4ABA2jTpg1z585FoVBw8OBBS0/LCy+8wKFDhzh16hR6vZ6QkBB69epFw4YNuXLlCrNmzaJdu3asXbsWlUpVpuNmZ2ej0WjIysrCzc2t3N5fz9U9ic+NL3bbm83fpLpLdboFdMNgMrA1ditzIuYw4+EZ1HCtwYIzC7iac5WJrSay7fI21kev51jSMQA+7/g5vWr1sirvWNIxFCho5tOs3N7Pg+CvhL8YvW00ANsGbcPV3pVKdpXuqkwhBFdzr+Ln4lekZy2jIAM7pR0u9i53dQxJkiTp7pX19/u+BjcA58+fZ+7cuSQlJdG4cWNeeuklKlW68WM1Z84cLly4wIwZMwDIy8tj/vz5hIeH4+7uTocOHejbt+9tHfNeBDfzT8/ni6Nf3PZ+j9d9nN1xu0krSCs1397Be3F3dMdgMnDo2iFe2v4SAAefOoirvWux+wghyu22WHJ+MoXGQvxc/WxSXqGxEHuVfZH0rbFbeWvPW1ZpdSrXYfmjyy35vz/xPWnaNLrW6MrHYR8zvvl4ugSUvG7S4rOL+fTwp7zb+l0GBw22pGsNWjqt6IRaqWbv4L0oFfJpJZIkSffTvya4uR/uRXDTeH7jcin3ZkEeQZxLP2eV9naLtxnecDhg/nEWQuCkdmLHlR18+NeHTGs/jQ5+He74mP/b/z/+iPmDMSFjGBMyBpVShRCCXmt6EZ8bz64nd+Hl5HVX7yvsWhijt41mfPPxDG84nCxdFiqFChd7F7Zf3s4bu98oss+geoOY0HICChS0XGy+Rent5E2KNgWVQsWJ4SdKPN7Nn9VzjZ7jzeZvAhCVHsWgDYMAcy9R1UpV7+p9SZIkSXenrL/f9/3ZUhWJEIIUbQoGk+GeHO+fgQ3AjKMzmHd6HgqFguR88/gke6U9haZCAF7e8TKr+q6inns9gNvqyUnMS2R99HoAZp+czbzT8xgWPIwuNbpYbr+dzzhvFdzEZMXg6eiJxkFjSdMatFzOvoyz2plUbSrNfJoxdsdYdl/dza4ndzF251hMwsSMozMYWHcg/db2Q+OgYV3/dSWOOVp1fhWrzq9iZKORlrQUrXmQuVEYuZBxgYuZF/Fz8aOxd8mB52+nfqNXzV58efRLQrxDLOmXsi5ZBTcnkk/g7eyNg8qBuJw4UrWpdK3RtczteT7jPI4qR2q41ShTfkmSJKnsZM+NDXtulp5byrSwacVu6+jXkb1X99rsWHdDpVChcdDQLaAb7z70bpHtESkRfPDXB7zV/C3a+rYltzCX7qu709irMQcTDt6y/INPHWROxBzic+PZdnkbAOHPhKNWmmPpKQemsPbiWgAUKHi75dt8fuTzYsuqU7kOFzMvFrvtTh0fdpzzmecJ9ggmMS+RHqt73HIfFzsXlvRZwrn0c/x26jfOpp8FwMPRg/SCdEu+ttXbMqDuAFZEreDLh79E46Dhx5M/YjAZCPUOpU31NozYPIJTaacAWPHoCoI9g236/iRJkioqeVuqFOUV3JR2K+rosKPsj9/P6dTT/Bz5M672rqzqu4r0gnSe2vjULcv+54+orUSOKLr44ag/R3Ho2iEAvun0DYvOLOJo0tG7Os7QoKE8Hfw0o7eNLnGQ9X/BgDoD+P3i75bXHo4e7H5yd7E9PjmFOagUKpztnO9lFa0k5iVyMuUk3QO639NlDPL1+aRoUwhwC7hnx7xXCgwFANgp7VhzcQ0tfFpQS1PrPtdKshWTMMnxeeVIBjeluNfBzc3jYIqTW5hLREoEYYlh/HrqVwC2D9rOorOLmHd6HgAnnjnB23vf5kLGBZb0WYKz2pkmC5vcdZ2fa/gc6QXpPFbnMVpUbUFOYQ5tl7a963LvJQeVAzqj7tYZH1Aejh78MeAPXO1dSdOmEXYtDD9XP17e8TJu9m6MbzEeZ7UzD1V7CK1BS1J+El8d/YqRjUfS0Ksh59LOEewZbOkZy9fno1AocFSZF8O8HpTkFObw2s7X6BrQlaeDny5T3Z7Y8ATn0s9ZBlvn6fNQK9U4qMp33ag3dr3B9ivbmdt9Lq2rtS7TPlqDFgUKHNUlLwKqM+qwV9rf8/Wmrp9md8ft5rVdr1GtUjWeb/Q8n4R9AsBPXX+irW/Rvzu9Sc+fsX/S3re91a3deymnMIfozGiaVGlik/Iq4o9/ZEok08KmoXHUEJ4Uzq89f8XPxe++fWYVmQxuSlFewU3LRS0pMBYUSS+ud6Qkv1/4ncDKgYR6h3Il+wr91/Wna42uzHjYPFvs5hlPnx/5nIVnFvJWi7fwqeRDJ/9OdFzWkXxD/h3Vv7N/Z3bG7byjfe+Ws9r5tus94+EZHE08yrhm43BSOzFx70T+vGy9/k3Y0DBaL7n1j+O2Qdv4/MjnlttoN7tXwdM/e3VKEuIVQkRqhFXakPpDaFm1JW2rt+XR3x/FKIyolWpa+LRgxsMzEELw7JZnOZ58HLD+ThYYCnBUO/JL5C98c/wbetXsxacdP0WpUFoC9hDvEGZ2mknf3/tS36M+83rOs90b/wchBCELzOOdnmnwDBNaTrDanq/PJ02bhr+bP/n6fLILs/Fy8qLn6p4A/NTtJ1adX8WYkDFUdqxs2S8pL4n+6/rTxLsJV3OvUltTmzx9HkOChtC6WmuuZF+haqWqeDp5WvaJzoxmS+wWBtcfbBlL9sauN3BzcOP9Nu+jQMHmS5tp7NUYf7fiH+sy48gMFpxZUCS9WqVqXMu7Znn9e7/f2R+/n/MZ50nXpXMg/oBlW133uqzpt6bENtOb9IzcOpLKDpWZ2WkmCoWC2KxY9CY9gZpAcgpzrNqiJCn5KUw9NJXB9QfT3rc9AB8c/IDVF1Yz5aEpPFn/SUveOwlSdlzZweR9k5ny0BT61r69Wa7/ZBImwpPDCfYIvq+9m1m6LNova18kXa1Q83P3n2lRtQUA66PXczXnKi+FvnRXwfXRxKNsjd3Kq01ftUnwlKXLQmvQ/msmTMjgphTlFdwM3zyc8ORwq7SeNXtaApM7kaXLwsXOBZWy6Bo+JmEiVZtKFecqlrQjiUeIy4nD09GTHH0O7au3JyI1gg6+HVgWtazEMUFlNSZkDKNCRpGty8YojHRb1c2ybfPAzZYf1pZVW/Jd5++4lHWJIRuH3LLchb0W8szmZyyvB9YdyJoLJZ/MW1VtxS89fimSvuTsEqYfng6Am70bB546QI9VPUjISyj1+JEjIknKS6Lrqq5Ftq3qu8oya6qsFCio7lL9nt+CC/YItowHuu7k8JPsuLKDN3e/aUk78cwJVEoVB+MPMmb7mCLlXB8LdD24USvUGMSNgfJNvJtYBoYXGAt4s/mbPNfouSLlCCGIy4ljVvgsXmryEoEa69XHMwsyydBlWG7LrIhawVfHviJPnweYg5u6letip7Lj0cBHAZiwZwKbY60ft9KlRhd2XNkB3LiF26xKM+b3mk9mQSYJeQnsjtvN7JOzy9SOP3X7ibbV2/L0xqctgaSbvRu9avViedRy4MZsvOumtZ9Gz5o9ydBlsPTcUgbWHciB+AOW3plbqedej/MZ50vcHjE8AoMwYDQZLb1TXx79ksvZl2lZtaVl3Nq2QdsQQtB9dXer/Zf2WUojL+sHFZ9IPkGqNpX10evZFbfL6vb33sF7cbN3s/QQ19LU4vd+v6NSqvjiyBesi17H8keXU92leol1vv79VylUZOmyLH9Hvi6+LOmzBA9H87MFo9KjOJ9xnkZejailqYXOqOPb49/SLaAbUelR1NLUwsXehUBNoOW9rzq/ig//+pBH/B9hVudZZWrj3MJcHv39UfrW7sv4FuNLzHc5+zK743YzuP5gy/EuZ1/mp5M/0aVGF7489iVjm47FXmnP67tfL7Ecbydv/hjwB4DlIuuHLj9Q170umbpMgjyCStz3o78+YsX5FdTS1GJcs3F8F/4dQgiis6IBeCroKd5p/Q5g/jvbHbebYM/g2w5S2i5pS44+p8SZrtGZ0VRxrmJZYkQIQa4+F1d7VyJSIvB28qaaS7XbOubdkMFNKcoruLnehQ/QsmpLprWfhqejJ3YqO5sd426ZhIlBGwZxIePCbe8bNjSsyBXSKzteYe/Vvfi6+LLl8S1EpUfh4eiBt7O3Jc8/b9c18W5C95rd+fXUrwysO5DmPs1pW72tVU/UsOBhXMy8yNzIuYwOGU1d97ok5yezPGo5Z9PO8r+H/oevi2+x9YxKj2LqoamMCRlDR7+O5OnzeGjJQ8Xm/bXHr7SsemN161RtKtPCpuGocmRDzAbAHPisPL+SqX9NBczjh0zCxLKoZQBUcarCa81e490D5sHZHo4efNL+E8uVb05hDpGpkYzZdiOIeKHxC8yNnHvrRreBH7r8wMs7XrZKu34b5NUdr7Ln6p4i+xTXO3Qr/+yhLDQWMnTjUKIyoorkMQkTS84u4bMjn1m2/drjV57f+nyJ5S/stZDjycf5+tjXZa7T9kHbeW7rc8Tl3P6q4K2rtSbsWtht71dexjUbx8zjMwF4ot4TeDt588PJH8q8v7uDO38O+pOXtr+Eg8qB9r7trdq/OKMaj+LnyJ8tryvZVWLboG2WW9fjmo2jvW97jiYe5Xjyceq61+WlUPOaWyX1aNzMx9mHUY1H8XHYx5a0bx75hkvZlyzv9Z9mdppJi6otaLe0nSWtZ82ePB38NGfTz9KzZk/cHd0xmoycTDnJ2fSzDA0aikKhoNXiVpYZl8X1qOuNemKzYxn15yjSCtJ4qNpDfNTuI/Ze3ctHhz4q9b3ciS8e/oIeNc0TGowmI4WmQpzUTuTr82/Z49zQsyHLHjWfgzZf2syEveYezlebvMr++P3Urlyby9mXebXpqzT3aQ5ATGYM/m7+qBQqDCYDHx/62NJb/E2nb+hSw7weWExWDFMOTKGTfydmHp9JTbeabBhgPh9O/WsqK8+vRKlQYhImwPw9GRo8FC8nL/RGfbn+5sngphTlFdz0XtObuJw45vec/0CvFJxekM659HNo9Vpmhs/kUtalW+7zXpv3eKLeE0XSE/MSmXd6Hk8HPV1it/zai2uZcmAKAMMbDOftlm+XeBydUVcu4zmaLWyG3qQHYM/gPWy5tAWtQcvzjZ4vtos4syCTV3e+yqOBjzIkaAhCCI4lHaOmpqbl6mbRmUXMPD6T77p8V6ZxIXMi5jArfBafdfiM3oG90Rq0fPTXR9TU1GRWeNmuPG3J18XXpj1LMzrOwEntxMXMiyTlJ7H03NIiefrV7sfYpmN5csOTZOgybHZs6cHh5+LH1dyr97saRTwV9JTVd/KbR76hrntdarjV4FjSMVzsXFhzYQ1Lzi2x2q9d9XYcSDjwz+JsZt/gfSTlJzFs0zAKjAXM7zkfb2dveq/pXeYynNROZX40z8N+Dxd7QQOw4bENJOQlWF2IXefj7EPTKk3ZErvllsd4pckrDKgzAJ9KPmWq0+2QwU0pyiu4eWT5I6QVpLGq7yrqe9S3WbnlLSYrhv5r+wPmK7MpD01B46CxrHr8W4/fLPeN74TRZLR0bb/S5BVeDH3xrut8uw5fO8zXx77mfw/9r0jX/N0wmAyWgby3IoQgKT+p2G7jhNwE+vzep8gaSa72rvSv3Z8hQUPYEL2BnyJ+skm9pQfDR+0+YtvlbQ/MMhH/NRoHDX889gcdlt/5wqZSyRb2WmizgejXyeCmFOUV3KTkp5Crz6W6S/Vyn00CQGE+XD4ANduDndNdF5evz7e67ZRZkEmBscAmA83mn57P3qt7+eLhL3B3dL/r8iqqo4lHeW7rjbEr/+w6n/rXVMKTw3mj+RvEZsXi5uDGltgtVoNPwTzGwSiMRcq/1eDox+s+zuoLq4ukd6nRBaMw8r/W/7MaZ9WyakuUKAlLfHBu39yp8c3H80fMH1a30W5leofpLDyzkDNpZ8qU/+BTB9kQvYGFZxYyouEIhgSZx6MdunYIlULFvNPz2Ht1L280f4Mr2VeK/Sz+7Zp4NyE+N95qvFJFcju9KBXdnsF7LOOqbEUGN6W4Vw/OtKlDs0GhNP+r3gz8msOK4XBmHWhqwKuHQWkHKjUIAUmnwbs+lHbv06iHS3sgfBG0GWsuU7rv3j/4vmUwdVlm2uUW5jJm+xjaVGtDTU1NWldtTWXHymyK2WQZBwTmxQvPpZ9j5vGZJGuTrW5Hft/le5r7NCchN4GB6wdalf9o4KNM7zDd8vrmMVSRIyLJKMig4/KOd/x+J7acaDX2I8AtgM41OtO/dn9GbxttWWm7JF88/AXdA7qjNWgt4xS+fPhLxu+5MWB0bNOxJd76W9V3FUZhpIFnA8A8HmhX3C6Wnl1qCdrUSjWTW00mITeBTF0mqy+sZnKryQwNHgqYe+Xe3vs2l7MvM7bpWLZd3saZtDNWA4Q7+Hbgh66lj5HRG/XkG/LROGjYEL2Bd/a/U2r+m3UL6Ma2y9ssA507+Xfim07fELogtNT97JX2bH58Mz9H/GwZR7b18a1lWtzyOme1Mx38OrA1dmuRbesfW89fCX8x/fB0arrVZE3/NeiNetZFr7NMcPisw2fU0tTiyT+eLLL/g+yf48Q6+3dmxsMzmLh3ItuvbC+XY6qV6hJXwV/aZ2mZ1k0rq7sN1G5npnBZyeCmFA98cGM0mIMUgIRw2DwR4spwZayyh8ZPwInF5tf1+8DgRaBUQtRm+HMKOHuAxh/sHM2B0vGbpqj2+Qpajiy+bFvJToCEE1C/FygUkHoRcq5Brb+7hU1GuD4zzGSEC3+Ciw/4NoOCLDixFFKjoMc0m/RWAZAWbQ4CK5fyKIScRFA7wr4vIOwn6PAWPDLRXKfoXVCnCzgU/8DS25W4+yPeubicIa0n0r3x3zPIhDC3F5i/H/p8c9votdDwsWKPbRImojOjic6MxtvZ2zKoEMxjmw7GHyTfkM/VnKuMChllmdZ7c/ByfcaMZbZe7AH67n+TWGO+1YDGfw4a3zZoG15OXiw+u5iFZxby1SNf8dnhz6wGKdd3r8+qfqsAuJBxgcVnFzM6ZLTV7JuC9BjWJ/5FR/9OdFtj/rFtWbUlGnsNojCX56p1IDRkOGReAScPcLjx9PY1F9bg5+JHq2qtzM1mMpJekE5kaiQdfDuQmJeIr6tvidOZV0StsAwivfkkff32oo+zzy2n9BpNRlRKFYl5iXg5eRV/C1MI8z8Akx7U5l5fkzAxJ2IOzao0wyAMjNk2psgA307+nUjTpvFi6ItWz4zTG/WolWoUCoXVYPji3DxRICo9CndHd6o4V2HLpS28vdc8Pm7TgE3ohZ6Xt79MfG48aoWa+b3m08CzAWHXwmhVrRV2Sjv6r+1PTFYMAMseXUawRzBKhRK9Uc8fMX/Qulprq8/3RPIJcvW5tPdtjxCCL45+YTVtfnKrydSpXIfJ+ybTzred1VIJNd1q0rJqS+q717cakAzQrEozmlZpSpvqbahWqRrjdr3GxUzzLKMeNXsUG4Rdt6T3EtIK0lh4ZiGHEw9bbRsdMppGno0ITwlHgYLXm70OQKGpsEhvfao21TJI+PH1j9Petz0nk08yqP4gDCYDcyLmlFiHm01oOYHozGjSCtJ4ofELhHqHkpCbUCT4fKXJK4xsNJJmi25/vKcCBUqF0qq39/G6jzOu2TjmRMxh0dlFt13mtPbT7nq6f3FkcFOKBzK4STxl7p2p2gi2TLrftTHrPAU6jAddNjjetJ6CEOYAKnwRaDNhxHpwqVJiMVYWDYKL26BGW2j1Aqz6+6onsBPE7DL/f5WGkHzaer8u78O1E+aeKgC/luBW/cbrblOhkrf5X0BbyEs1p1euYQ4K8tMhdj8EPQqp583BzKx/nAQ8apvfb/UmkH4Jgs1Tj0mPge9bg7HQOn+NNnDlL/P/NxsB/b61Ds6u02aCUg3XTpp/uNKiIeRJc71OLoffR0O3jyB0CGx9ByJXmvdzrwldP4SVI260QYP+sP0DOLve+hjBfaH9mxB3GLZMNLdhz+lw5RDsngajdkG1UDAUmNsBoN4/rszz0yFmFx9khrM62tyukU8fM5fn7AV7zVONo+ztmK/RMG7YTnx2Toesq4S1HMYLR81TngcE9mVqs/GweQJ41YN2r0HECgh6lFSloHJOKsZzG7Dza4kyJxGC+sCJJdDgMXD1gdwUWPIEuFaHqI2W6kWEPs7lkAHmE2ZiJPz490wcl6qQm2j+bIcs5q4JAQVZ5J1Zy1up+2nv/whPBw2FvTPAqIMu71nnz0mE3GTz5+X49/kkN9kccNo5Qfwx83txqwaxB8wBaa2OsOsT8AiEDa/dKMvZE147caOcmz8efT5OaicUCkXJ47eEgMJc838/9Yemw8ht+Bgz9kyiR5sJaDNiWHBlK2l5iVy2s6Nf7X580r74qepHEo9YeiWOPBWGo/2t15KJzYpl8r7JjGr4LJ1zc8wXUr7NIHIVnPsD6vWE9a9a7+TbwhyUqhzgsR/Y+0t7Jrso+TA1na4KVxi51dxOQtB4wY3nvf3Rfz0Bl8PAtzkmj0CMhbn8uHk0fjUeZkDzv2cHxh4ABMzrY379+C/oUs7xTeZJCqo2YtWFVZbyWvg0Z0qLCQR6mXvw4nPjef/A+0SkRqA1aAnxCmFx70Xm84D6pkAmP918saHxs/4c8lLNf6fBfTE4e6BWqi3rlOXH7GL+6QX8XhDHtfwk4MZir9eXH7jV2M38/DT0ei0T9rxJHZ+mvK0JhepNWL/pZTK8Anmk7gB0rlVYG72OhWcWEuwRzHONniNQE0gtTS0Grh/I5ezLvNfmPQbVHYRCocBgMpBTmFPs0IECQwGP/v4ombpMdjyxg1nhs1gVtZIJqalM9zLfetpm8KHq479B5eInl9iCDG5Kcb+DG5NJYBSCF+YdIeviIZ6sfJah2qIzS8riHf1IptkVXe/F5lo8D171MEWsQOtUlUrRmyybDB51Sak/lKpVfVE0fMwc9GTHw6V95h/j1mPg/BZYPqz862lDpioNUCaXbSzFPxV6NSDKWJ3GGaV0Tff89P4GshMumQOt9BjY/xWkmJcxSFSpeKuKF4Ozc+ibV/aFFU/Z27PJxZlXMrKodKenlUaPw6lSxpnU7AAOblZBj5XXT8GpVVCvF1zaC02G3ujNST4Lh36AHtMh4bi5RzSgHVTyMgd6CpU5GPvkNmZ4eAdDyk3rCtXsALH7yr5/cVqMNAfDXnXByR3sXczBzm+9iuYNHWoO1uOPmt9L4inQZd3yEHrghKMDjXWFOAphDnx7TDMH6zs/hlod0XabyoDNQwks1PND0k3jY+yczcF07c7mgPziDvMt8rrdzNtO3H2AKYDi+sRWuLoQp1YzJjMLl9K+Y4//Yv5881NLP1DIYOj8LtqoTThunmg+Zvs3zb3gzZ4xX3BmJ5BSqy1uUX/ioLKHC9ugSrD5Yuulg7BiBKRdMAe3GbHFH6fxE+DT0Dxc4PrFC5CiUvKbxo0+uXk09AiGFs+ZL8gCO5mD4IxYTF710R2eh5NPbfPFU9Ip8393TYNixtUV0el/5rqpHWHFM+D/kPmza9APvVcd7JR2oMuF6B3gWRd8zMEdF7ZB2I+QmwQGnXmYQ+sXzYG7my/GnVPJuHIQL5OJEw72eBpN+Bv+vl32xhnQFL9Ux92SwU0pyj24KciGxAjzlf3fV/GZl47z07o9uJiyyS0oICdPy8d2v5WpuFXGjtRWJNBUeZEwUxB7jCGkUJmVxkcAaKCIZb79Z3grzCe1OYY+qIN68fxF6yukE26P0CR7t1Watut08qu1xnNh57t7z5L0IPNtbu5BkW6LEVBSfKAh/fsZfVuiajIEw7YPUBfm2LbwVmOgd/EPRL4bMrgpRbkFN7pccxfzTVeeJtfqKHNKXx23OL8ZevCLsTcJwhMT5jEBfopkrglPjBRdrbgkPZRH+NbuO17Vj2WbqQXeZFBTkcQQ9S5A8Lb+RUwoeV61mffsFgKw3diUrqrw0gsuB3uNjSnAnu4q84/Qb4YePKo6xAWTL21V5h6UU6aafGsYwDj1GhoqL7PA0I12ylPk4Ey0qM7jqru8ai6DDrqv2WH/FvYKI4N1U2hjF8XryhV3XF6USysCPCvheHlXsdvjhScRpkB6qY5Y0jYZW/GXqQErjQ9zztF6ZeBEh1pU1d167aLb9YX+CfJw5P2/vyeSdCfyAzrjfHkn1HrYPKGhFMLBDYUu2ybHFXaVUPy98rV0j7xyBLzr2bRIGdyUotyCmz+nwMFv73j3KfpnGaXayFpTO74yFD9rYMagEJrWcOfnvTEsP3r7q66WRIGJtsrTnDEFkIG5TTorjzNEtYtIUy3G261iu7EpE/WjGazahbcii9+N7Rmg2s8w1XbihDeBykRLeX8ZG7DP1Jgx6g1oFOZbG2/rR1NTkchaY3tCldHohB0bTG14U70SvVAzy2iepeNCPnrU6LC3lKfGgIFbrycTqEhgiGoXh0zBfGc3i6OmenRURbLV2IIeKusnm4eZghhceGP8hDMF/GT3FR1Up4g2VWOBsTuHTMEkCXcCFddopLzEcmMnq3pdd97hGewVRqbpn+Ka8GSW/XcAfKh/hjwcKRR2PKveQhNlDInCnaoK8wJ2DQt+IQ8nS91d0BIhauNFFpUUWi6LotPwayviuSx8LO3hQj7tlKcpwJ59psaYUOKIjmX2H3NR+PKWfgwz1D9RS5nIZ/ohOCl0LLC3Xpn2iKkedRXxGFAx0zCQa8KTFKHBQ5HDLlNTq7xVyOAl9XoOmRqQIjRECX/cyOcZ9TYumqoTJfx5SHmW88IPN/IZpd5ItnDmHcNIrooq2GHgB7tviBNV2GtqTK5wIlQZwxS7G4MWny6czAGTeZDyawFxPOkTj7LRYyyYP4cX1Js5aQrke0N/vrX/jp3Gppww1eYr+x9v+f0oq6vCizShYZL+BXwVqXxvN5Nfjb1opzxFLad8XHVJRfZJFO4kCE+2G5ujQ81OUzM+Uf9CfWUcUSZ/S4AOoBNq6usW0FRxgffsFrLJ2IoXvM8QluZEP9VfnDQFEqqMKbZuucKRqz6dCEo2P4IiD0e2G5vRX3WQ06YAfjH14TnlJhYYu/Op+mdUCsFmY0s2G1sRJfz5oPJmfs5qiQtaBlZLxd2USWhGyQNs84QDlRQ6RM32vHE+hG/sS5/x9XrhyzzsfInWT07AO/8i+vDlDDjfFU9FNgdNDbneD7RkVGuaVXfCZDLR+vOD1Ddd4Bk2kq5pxIF0Vw6ZglFjxEuRRRVFJgIFF03VScGdt9XLaKs8w9OF7yAALY7Mt/uUh1U3BqwfMgUzTv8qDylOk4MzB0yNWGn/IZUo4HPDEFQY+cHe+nz9uX4wE+yWl/r+inPW5M9VUYW/TA3oq/oLR3TMNvRnu6kZX9v9UOTcs9bYlnBTXXKFEyYU9FaF0U11/LaPC/ClfhAbTQ+RKDw442geI/Wo7mMaKWMZpNqLGiNNlNF3VPbN9X1MdbD4jZ510TccxMLwdGanhHDE8ZUb28adNN8SsyEZ3JSi3IKbD8r+ELN04YKHIheAcyZ/hhS+SyaufPtUU1rWdKeKqyMKQKlUkFOgZ1PkNXo0rEpl5xs/rOl5hfx5OpEmNSqTnlvI0Llh+Lg5kJR9dw95tFcrKTSYl9Ue2NSXNeFFV7FtHuDO613r8swv5tkE855rybO/mXsWFJgQ3PlTf6c82oCP/ij7WJefnmnOmIXF3XKwvnP/uHIvX9r/yAlTbUYXvkkyRQfN2WGgn/IgB00NuYb5AYqd6nvj6mjH+pOl9cAJvMkk5e8ymynOkyg8SKDos1pcyedTuznMMAwmVtzZM1k61fdmV9TdrROiwkgr5TmOm+qiwx438jCitARb955AiUCBuK3eyevs0eNGPi6KfGooktlnaoxAiTcZtFRGcVrU5LLwoa4iHhUm0oQbT6u3s83YnNOiFtVIY4R6KwsN3YjHu9RjqTDiRh6PKE+ShhupQsMZUfOWdfRTpPC0aju/GXoW+/37p9aKs1RW5LDV1BIlwtKLC+BFFuPUq/nZ2Icrwgc7DBhQFvO3V9IIlqLqKq6SLlzprQqjseISs4yPkS7M58jr3wsNuRRgTwdlJMmiMl1Vx9htbMJxURdHCingHqzxVQw1Bqor0ghSXEGLA/tMIbfcZ6J6KdUUaRQKO1YbOxImgmmkiCEHZ4IVVzhpqk0BdlRXpHNaBNBEEU1jZQwf2c3jU/0QWinPcU7U4HPDrZ+fd2uC3sow1Jj41v470oULU/XDCVJe4WvDIHorw9BhxxZTKzzIoaoijVPC+lltbZSncUDPblMTq/RqpNFDdYQjpvrMsf+K8yY/NIo8mikvWvK0KJhNV9UxwkzB+CpSeUO9isn6FzgvzIODaymuMcfuK+oqzb8HrxaO5YLwJUr8c5ap+Pt7YM+y0W14KNATW5LBTSnKK7g59X4TGimsbwd8rh/MHGMf1Bh5X70A3zohLMprSZyhMnNHtMC3su1+SHJ1BirZq8grNDJz+3k6B/nQyNeN+EwtQVXN7zMsJo3Bcw4B4KBW4uvuRExKHp8/HkLn4Cp4VrKnQG/CQa0kX2/ExeFGb0l8ppaPNpzh5U61CfGrDMDF5BwKDYIG1d0wmgTxGVqGzj1E12Af5h2Mxc/diRcfrs3s3dF0rOdN78ZVmbgqgoSsok9Pf7p1DcZ1qUsVN0ee/e0wu2/68R7Q1Jd+TaqTkq1j74UUejSsyr4LKbzXt6GljoUGE31n7ScqKYdWNT1Y8WIbsgv0DJp9kGY13Pn4sUY8++sh9ken4+JgxycDGvHnmSQ2Rtx4MvPYznWYu+8SWr0Re5WSVzrVYVzXuhQaTAz68SARV83jmuxUCvRG6z+dSvYqGvlqqOLmSL7OwOTeQczeHUPrWh5MWG39nKaans7EppVtsK69Skmh0Rxsdmvgw+ynm6FWKXnn90iWhF0B4OvBobyx/GSJZQxvE8DhS+mcS7S+rz6kpT9qlYJFh8zlPNHcjyvp+STn6LiUWrQL/8snQtl3IYW1J8p+q7W+jyuvdK5D61oeFOiNVHay56mfD3HmWsm3G6prHIv9jtxKJXsVdmolmfn62973QVHF1YHknLt/Cr2Xiz32KiW1q7jg7mx/i+D8v6VvaHU23HF7CPwUqVwVXpTXaCQnCtDiYFW+b2Unvn2qCbN3R7P9rHntpwXPtyI+U8vkNbZfT8YWzk7tiZP97V+olEYGN6Uor+Dm2HstaK68wJjC19lqamVJv/5DOHd4C7o2sP2zNu6EySTQ6o2olAoSswqo6VXpnh4/v9BARr6+1OBObzShVChIzyvE27XsV4N5OgOVHG59C+vm40zfdI72dT3pHHTrz0dnMKJAgb3afIV8Kj6L8LhMhrWuUeq6J9engd7MZBIolQoenrGLy2n5fPRYI2p5ViIh07xwVt/Q6jjZq4hOycXLxQGNk/WijBsjrpGaq2N4mwBScws5djmD99efIilbx8CmvrzSuQ61vc2zhbK0eqasPcXeCyn0D63Oe30bolIWX1+TSbDjXDJJ2QVUcXXg3bWnmNgziMebm6e7puXqMAmISszh6OV0nm1bk8rO9qTnFbLqWBz9Qn2pqnEssS3i0vPp8uUe2tT2ZP7zrVh5NI6PN55lbOc6tK3tRXA1V3J0BkI++NNqvyEt/Vl25Mbt2OYB7vw8vAWXUvNoHnCjJ2TInL84fjkTNyc7UnN1DG1dg8pOdvywu2j3/NzhLdgYeY3fi+mhBHiyhR/TB4bw0PQdpOToCPB0ZvELrfFzt54affPnm5RdwLYzSRy4mEqdKi4cu5zBwei0EtvjZutfbUeAZyWOX8ngj5PXWH28bM9pqu/jSlSSOXhVKODiJ72tPt/ErAIG/HAAo0nwQodaTNt0rthyvFzsSc0tLHYbQPcGPswa2pRCgwmdwYS7sz0qpYIdZ5MYvfAYlZ3sSMsrun/Lmu6M6hDIyauZfL+r7LdJWgS481SrGrSp7UmB3kj/7w7QoLobWr2RtNxC4v/+W5nUK4hPNxf/nj5/PITUPB3PPBRAJXs1SqWCqMQcenxjfuzFH2Pb07C6G3qjIC1PR1U3R2bviebzLVG8/EhtKjvbsflUInWruBBczY1mNdwJ9a/M7N3RfLal+GMufqE1/u7O/HrgEqM6BuLioObAxVS6Bvug1RtxdVBzOiGbS2l5dA6qYrlI0xmMRCfncTA6FY2THQ/X98arkgPKvz9Lg9FEam6h1d9XSo6O9LxCrqTn41vZCS8Xe6q4OXIlLZ/wuAz6hlRnY+Q1xi69MZayTaAnvz7bkql/nOZyWj5T+zeisrMdy4/EseNsEi8+XJu0vEImr4nE0U7Jqhfb8uis/YT6V+b7oU1p/1nRMYKDW/gTVM2VuHQtozsGlnoOuFMyuClFeQU31z5uQDVDPE/qpnBYBPN4Mz+mDWyEg9q2katU8RiMJiLis2jiV9lyEqvoMvMLqeSgxk5V+i1MIQQZ+XrydAb8PZzZdS4ZBzslbWsXveV3nd5oIr/QiINaSbZWTxU380m2QG8kPlNLly/34KBWcurDHpbjG4wmVEpFiQFqWq4OoxBUcb2zE3Zcej4TV0fweDM/Gvtp8HFz5Ks/ozhzLZufh7fgYnIu17IK6Bta3Wq/QoOJmNRczl3L4bGm5um1W05dY8nhOD55rBH5hUbqVzUv4pil1eOgVmKnUpYYuN7sfFIOhy+lI4DY1Dze7lEfRzvz+epUfBZLD1+hZ6OqLD50BRdHNSqFgnFd61K9DD3OMSm5HIhOY8raUwD8OKwZPRuZb8OuOBrHxohrfDukKRpnc8BuMgmGzDnElfR83uhWl5wCAy90CCyx/OvScnV4VLJHoVAQl57P6YRsvF0dqOfjgt4osFcrrXqgbalAb+TDDafp1agaHet5k55XiLuz3S0Xd7yfohJzOH4lg76h1e+qXbLy9czdH8PF5Fweb+ZH9cpONKhe/kuryOCmFOUV3CRPrUMVUwpddDP4/MUnrK4kJUl6cBTXiyaVj+iUXKKTc+ne8O6fUSdJZf39Lp9w9j9qoMMcUjKymNC7kQxsJOkBJgObe6e2t4vl1qgk3SsyuLGhZjXcuerqQK8Qv1tnliRJkiSpXMjgxoa+farprTNJkiRJklSu7nwxEkmSJEmSpAeQDG4kSZIkSapQZHAjSZIkSVKFIoMbSZIkSZIqFBncSJIkSZJUocjgRpIkSZKkCkUGN5IkSZIkVSgyuJEkSZIkqUKRwY0kSZIkSRWKDG4kSZIkSapQZHAjSZIkSVKFIoMbSZIkSZIqFBncSJIkSZJUofwnnwouhAAgOzv7PtdEkiRJkqSyuv67ff13vCT/yeAmJycHAH9///tcE0mSJEmSbldOTg4ajabE7Qpxq/CnAjKZTCQkJODq6opCobBZudnZ2fj7+xMXF4ebm5vNypWsyXa+d2Rb3xuyne8N2c73Rnm2sxCCnJwcqlevjlJZ8sia/2TPjVKpxM/Pr9zKd3Nzk38494Bs53tHtvW9Idv53pDtfG+UVzuX1mNznRxQLEmSJElShSKDG0mSJEmSKhQZ3NiQg4MD77//Pg4ODve7KhWabOd7R7b1vSHb+d6Q7XxvPAjt/J8cUCxJkiRJUsUle24kSZIkSapQZHAjSZIkSVKFIoMbSZIkSZIqFBnc2NDZs2cJDw9Hr9ff76r8K6SmphIeHk5GRkaJebRaLceOHePixYvlnqeiu3DhAvv37yc3N7fINqPRSEREBJGRkZhMpmL3t1Weikyr1RIeHk5SUlKJeaKiojh+/Dg6na7c81REQghiYmI4duwYycnJJeaLi4vj6NGjpT5mx1Z5KorIyEjCwsJK3G4ymYiMjCQiIgKj0Xjf85RKSHctNjZWhISECC8vL1GzZk3h4+Mjdu3adb+r9cA6fPiweOSRR4SXl5do0qSJcHJyEiNGjBA6nc4q35o1a4RGoxF16tQRGo1GtG3bVqSkpJRLnoouJiZGuLu7C0AcOXLEatvx48dFQECA8PX1FVWrVhW1a9cWkZGR5ZKnIvv888+Fi4uLaNSokQgMDBQjR44Uer3esj0hIUE0b95cuLu7i8DAQOHp6Sk2bdpkVYat8lRUJ0+eFEFBQcLHx0c0a9ZMODs7i4EDB4r8/HxLHq1WKwYOHCicnJxEUFCQcHJyEt9++61VObbKU1H8+uuvokmTJsLd3V14enoWmyciIkLUrl1bVKtWTfj6+oqAgABx/Pjx+5bnVmRwYwPt27cXXbp0EYWFhUIIIcaPHy88PT1FVlbWfa7Zg2nx4sVi9+7dltfR0dHC29tbTJkyxZIWFxcnnJycxFdffSWEECInJ0eEhoaKJ554wuZ5KrrCwkLRunVrMXHixCLBTWFhoQgMDBQjRowQQghhMpnEE088IYKCgoTRaLRpnorsu+++E87OzmLfvn2WtHnz5onc3FzL6549e4q2bdsKrVYrhBDi/fffF25ublaBtq3yVFRt27YVPXr0sASNly9fFhqNRsyYMcOSZ9KkScLPz08kJCQIIYT4/fffBSAOHTpk8zwVxaRJk8SxY8fE119/XWxwYzQaRVBQkBg8eLAwmUxCCCGGDRsmAgMDLZ/FvcxTFjK4uUvnz58XgNi+fbslLTU1VajVarFw4cL7WLN/l2HDholOnTpZXn/++efC3d3d6ss8b948oVarRUZGhk3zVHRvv/22GDJkiIiMjCwS3Pz5558CEBcvXrSknThxQgCWH2pb5amo9Hq9qFKlipgwYUKJeeLj44VCoRBr1661pOXm5gonJycxe/Zsm+apyOrWrSveffddq7SGDRtatb2Pj4/44IMPrPI0atRIjBkzxuZ5KpqSgpu9e/cKQJw6dcqSFhUVJQCxbdu2e56nLOSYm7sUHh4OQPPmzS1pnp6eBAYGWrZJpTOZTBw/fpw6depY0sLDwwkJCUGtvvH4s1atWmEwGIiMjLRpnorszz//ZMWKFcyePbvY7eHh4Wg0GmrXrm1JCw0Nxd7e3vL9tVWeiioyMpLk5GT69u1LcnIyx48fLzKO7MSJEwghrM4TlSpVIjg42NI+tspTkU2dOpXffvuNX375he3btzNhwgTy8/N5+eWXAUhISCApKcmqfcD8N3+9fWyV578kPDwcBwcHGjZsaEmrV68ebm5uVueAe5WnLP6TD860pfT0dFQqVZEHeXl6epKenn6favXvMnXqVGJjY1mzZo0lLT09HU9PT6t8119fb1db5amokpKSePbZZ1m6dCmVK1fm6tWrRfIU1z5g/f21VZ6KKiEhAYBVq1axbNkyqlWrxrlz5xg2bBg//vgjKpXK0gbFfRdvbkNb5KnIOnfuTKtWrZg8eTJ+fn7ExMQwadIkatSoAdiuDf/r7fxP9/I8YatziQxu7pKdnR1GoxG9Xo+9vb0lXavVWr2Wivfjjz8yffp0Vq5cSf369S3pdnZ2FBQUWOXVarUAlna1VZ6KauzYsTRr1gyVSsX+/fu5dOkSACdPnsTV1ZX69esX2z5g/f21VZ6Kys7ODoBTp05x6dIlnJycOHv2LK1ataJRo0aMGzfOkqegoAAnJyfLvlqtFm9vb6ty7jZPRSWEoFevXgQEBHD16lXs7e2Ji4uz9MS+++67Vu1zs39+V22R57/kXp4nbHUukbel7lJAQABw4+rtuoSEBMvVhFS8n3/+mXHjxrFs2TL69etntS0gIID4+HirtOuvr7errfJUVO7u7mRmZjJp0iQmTZrE119/DcCsWbNYunQpYG6f1NRUCgsLLfvl5eWRlZVl1Ya2yFNR1axZE4ARI0ZYAo7g4GA6duzIvn37gBvnieK+ize3oS3yVFQJCQkcP36cUaNGWX7k/P396devH+vXr7e8ViqVpbaPrfL8lwQEBJCRkUF+fr4lTafTkZaWZvXdvFd5yqTMo3OkYuXm5opKlSqJmTNnWtIOHjwoABEWFnYfa/Zg+/nnn4W9vb1YvXp1sdvXrl0rFAqFiI2NtaRNmDBB+Pr6Wmbf2CrPf0VxA4pjYmKEQqEQ69ats6QtWbJEqFQqyywRW+WpyGrVqiWmT59ulRYaGipefPFFIYR5NpmHh4f45JNPLNsjIiIEIHbs2GHTPBVVfn6+UCqVYs6cOVbpvXr1Er1797a8bt++vdVsyNzcXOHq6iq+/PJLm+epaEoaUBwfHy9UKpVYvny5JW3NmjVCoVCIS5cu3fM8ZSGDGxv47LPPRKVKlcTs2bPFsmXLRO3atcWAAQPud7UeWEuXLhUKhUK8+eabYt++fZZ/x44ds+QxGo2iXbt2omnTpmL16tVixowZQq1Wi/nz59s8z39FccGNEEK89NJLomrVqmLBggXit99+E56enuLNN98slzwV1apVq4RGoxGzZs0SW7ZsEaNGjRLOzs7i9OnTljzff/+9cHR0FDNnzhQrVqwQwcHBonv37lbl2CpPRTVmzBjh5eUlZs+eLbZu3SrGjx8vFAqF1To/u3fvFnZ2dmLSpEli3bp1omvXrqJ27doiJyfH5nkqitOnT4t9+/aJ1157TWg0Gss5OS8vz5LnjTfeEF5eXuK3334TCxYsED4+PuLll1+2Kude5rkV+VRwG1m8eDHLly9Hp9PRuXNnXn/99fv6uPcH2bRp09i0aVOR9ICAABYvXmx5nZOTw4wZM/jrr79wc3NjxIgRRW5f2SrPf8GlS5d45pln+OWXX6zGNxmNRmbPns3GjRtRKBT069eP0aNHo1QqbZ6nItu+fTtz584lPT2devXq8frrr1vNAARYuXIlixcvJj8/n44dO/Lmm2/i7OxcLnkqIqPRyIIFC9i6dStpaWkEBATwwgsv8NBDD1nlO3DgAN9//z1JSUk0btyYSZMmUbVq1XLJUxFMnDiRAwcOFElfuHAhtWrVAsyzWufMmcP69esRQtCnTx9eeuklVCqVJf+9zHMrMriRJEmSJKlC+W9cUkmSJEmS9J8hgxtJkiRJkioUGdxIkiRJklShyOBGkiRJkqQKRQY3kiRJkiRVKDK4kSRJkiSpQpHBjSRJkiRJFYoMbiRJui1xcXGsX7/e6inu/warV68u8qygO7Fu3TquXLligxpJklReZHAjSVKZbd26lQYNGjB37lw2btx4v6tzW0aMGMGRI0fuupwxY8Zw8OBBG9RIkqTyor7fFZAk6d9j3rx5DB06lJ9++ul+V+W2DRo0CD8/v/tdDUmS7gEZ3EiSVCZr1qzh1KlTBAYGsmzZMurUqUOLFi1YtmwZnTp1Ii8vj5MnT1K/fn0aNGjAxo0bycnJQalU4uvrS9OmTYs8/+j6voWFhURGRuLh4WF5TtCFCxc4c+YMgYGBNG7cuEh9CgoKOHjwIFqtlsaNG1OjRo1S69+3b1+qVatW5NgGg4GIiAg8PDxo1aoVCoXCar+rV69y7Ngx/P39CQ0NLbbs0uqye/duhBB06tTJknb+/HnCw8MZOHAgdnZ2pdZbkqTbJ4MbSZLKZOPGjaSkpGA0Glm7di3dunWjRYsWPPXUU/Tq1Ytz587RtGlThg0bRoMGDdi2bRuJiYmYTCaioqLIyMhg/fr1NGnSxFLmU089RceOHUlISKB+/frs2bOHXr16UbNmTdatW0fdunXZtWsXkydP5t1337Xst3//fp544glq1KiBt7c3Bw8e5MUXX2TatGkl1n/EiBEsWrQIX19fy7F79+7N+fPnCQoK4tChQ7Rt25Z169ZZ9lm8eDEjR46kVatW6HQ67Ozs0Gq1VuXeqi4Gg4FevXqxa9cu2rdvT05ODr1796Z3794MHjzYFh+NJEn/dFvPEJck6T+tS5cuYuLEiVZpgGjXrp3QarWl7vvGG2+IRx55pMi+PXv2FHq9XgghxObNmwUg+vfvLwwGgxBCiJUrVwoHBweRl5cnhBAiOztbeHl5iYULF1rKiY2NFRqNRmzbtq3E41eqVEn8/vvvVsfu3r270Ol0QgghLl68KFQqldi7d68QQoj09HSh0WjErFmzLPtMnDhRAGLp0qW3VZfx48eLgIAAkZmZKYYPHy4aNmx4y/aSJOnOyZ4bSZLu2ujRo3F0dCySHhMTQ1RUFNnZ2bi4uHD48OEieZ5//nnUavOpqE2bNgCMHDkSlUplSdPpdFy5coWgoCA2bNhAXl4eDg4OrFy5EgAhBDVr1mTXrl107dq1zPUeOXIk9vb2ANSuXRt/f3+ioqLo0KEDW7duxWQy8eKLL1ryT5w4kc8++8zyuqx1mTZtGjt37qRDhw6cP3+ew4cPF9tekiTZhgxuJEm6azePZQEwmUyMGDGCdevW0apVKzw8PMjIyCA/P5+8vDwqVapkyevu7m75fwcHhxLTCgoKAIiNjUWtVrN69WqrYwYFBREQEHBb9fbw8LB67eDgYDnOlStX8PX1tQRe1+ul0Wgsr8taF3t7e6ZMmcLAgQN5+eWXCQkJua16SpJ0e2RwI0nSXfvnINzt27ezZs0aoqOjqVq1KgB//PEH27dvRwhxV8dyc3PDZDKxZMkSlMryW83C09OTjIwMqzSDwUBubu5t10Wr1fLuu+/SoEEDFi5cyPjx4wkMDCy3ukvSf51c50aSJJtLTEykcuXK+Pj4WNJWrVplk7K7d++OVqtl0aJFVumFhYWkpqba5BgAbdu2JTk5mUOHDlnS1q1bh9FovO26vPXWW+j1esLCwujYsSPPPPOMVTmSJNmW7LmRJMnmOnfuTE5ODsOHD6dTp07s3LnTZov+1atXj48++ohRo0Zx9OhRQkNDiY2NZdWqVcydOxcvLy+bHCc4OJjnn3+eAQMG8Pbbb6PT6fj+++8tt8nKWpdNmzbx888/c+DAAVxcXPj1118JCQnhk08+4b333rNJXSVJsiZ7biRJKrNOnToVWetl8ODBlltP1/n5+REWFoa3tzd79uwhNDSUbdu2MXjwYKt1Xf65r0qlYvDgwXh7e1vSHBwcGDx4sNU4nHfeeYfdu3djb2/Pvn37cHJyYsuWLbRr167Euv9zEb/i6t2nTx/q1atnef3TTz/xwQcfEBERQX5+Pjt37uTZZ5+1Gk9TWl1MJhNbt27l+++/p2XLlgBUqVKFRYsWceHChSK3vSRJsg2FuNsb4JIkSZIkSQ8Q2XMjSZIkSVKFIoMbSZIkSZIqFBncSJIkSZJUocjgRpIkSZKkCkUGN5IkSZIkVSgyuJEkSZIkqUKRwY0kSZIkSRWKDG4kSZIkSapQZHAjSZIkSVKFIoMbSZIkSZIqFBncSJIkSZJUocjgRpIkSZKkCuX/XDekXezKppUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj_ids = sorted(df['traj_id'].unique())\n", + "colors = plt.cm.tab10(range(len(traj_ids)))\n", + "\n", + "fig, ax = plt.subplots()\n", + "for color, traj_id in zip(colors, traj_ids):\n", + " group = df[df['traj_id'] == traj_id].sort_values('frame_index')\n", + " ax.plot(group['frame_index'], group['force_mae'], color=color, linestyle='-', label=f'traj {traj_id} (mean)')\n", + " ax.plot(group['frame_index'], group['force_max_abs_error'], color=color, linestyle='--', label=f'traj {traj_id} (max)')\n", + "\n", + "ax.set_xlabel('frame index')\n", + "ax.set_ylabel('force error (eV/A)')\n", + "ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34da25a4-b2a0-4ce0-8d34-ad7a4a0557ef", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a5a26bf5e18c1bff294e5d919beecea77a05812d Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 16:18:13 +0000 Subject: [PATCH 06/25] Mark trajectory failed and shut down DynamicsRunner on dynamics task exceptions An unhandled exception during dynamics execution (e.g. numpy.linalg.LinAlgError from ASE's MTK-NPT barostat) previously propagated out of the DynamicsRunner's run loop and crashed the agent, silently stalling the trajectory while the Slurm job kept reporting RUNNING. Now such failures are caught, logged, and recorded via mark_trajectory_failed before a clean agent shutdown. --- cascade/agents/agents.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/cascade/agents/agents.py b/cascade/agents/agents.py index 3bba11d..c18b6b0 100644 --- a/cascade/agents/agents.py +++ b/cascade/agents/agents.py @@ -140,8 +140,16 @@ async def run( # get future result wrapped_future = wrap_future(chunk_future) - await wrapped_future - chunk_atoms = wrapped_future.result() + try: + await wrapped_future + chunk_atoms = wrapped_future.result() + except Exception as exc: + reason = f"dynamics failed for chunk {spec.chunk_id} attempt {spec.attempt_index}: {exc!r}" + self.logger.error(f"Traj {self.config.traj_id} {reason}") + self._traj_db.mark_trajectory_failed(run_id=self.config.run_id, traj_id=self.config.traj_id, reason=reason) + self.done = True + self.agent_shutdown() + continue # write atoms # todo wrap this up frame_ids = [] From 739f69ed955ddbb74cf92da014b014dd9ba1c0c2 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 16:37:17 +0000 Subject: [PATCH 07/25] Add model-version coloring to MAD plot and a UQ-vs-error plot MAD-vs-timestep scatter now colors points by which model_version produced each frame (via a helper that mirrors get_trajectory_atoms's chunk iteration/dedup exactly). New "UQ vs error" section plots DBTrainingFrame.calibration_uq against calibration_error (the same pair the Controller uses for real threshold calibration), log-log, colored by model_version_sampled_from. --- 3_cascade/2_sanity_check_run.ipynb | 107 ++++++++++------------------- 1 file changed, 36 insertions(+), 71 deletions(-) diff --git a/3_cascade/2_sanity_check_run.ipynb b/3_cascade/2_sanity_check_run.ipynb index ac4a9d6..7eb87cd 100644 --- a/3_cascade/2_sanity_check_run.ipynb +++ b/3_cascade/2_sanity_check_run.ipynb @@ -11,21 +11,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "3634b4fb-cd44-4897-ae60-fb14f6b17aa6", "metadata": {}, "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from ase.db import connect\n", - "\n", - "from cascade.agents.db_orm import TrajectoryDB, DBTrajectoryFrame" - ] + "source": "%load_ext autoreload\n%autoreload 2\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom ase.db import connect\n\nfrom cascade.agents.db_orm import TrajectoryDB, DBTrajectoryFrame, DBTrainingFrame" }, { "cell_type": "code", @@ -801,66 +791,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "id": "e7c7fdfc", + "source": "def get_frame_model_versions(db, run_id, traj_id):\n \"\"\"Per-frame model_version, aligned with db.get_trajectory_atoms's frame ordering/dedup\"\"\"\n chunks = db.get_passed_chunks(run_id, traj_id)\n model_versions = []\n with db.session() as sess:\n for i, chunk in enumerate(chunks):\n frames = sess.query(DBTrajectoryFrame).filter_by(\n run_id=run_id,\n traj_id=traj_id,\n chunk_id=chunk['chunk_id'],\n attempt_index=chunk['attempt_index']\n ).order_by(DBTrajectoryFrame.frame_index).all()\n if i > 0:\n frames = frames[1:]\n model_versions.extend([chunk['model_version']] * len(frames))\n return np.array(model_versions)", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, "id": "55b02eea-a83c-42ad-9fc1-d26a078dbd69", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for traj_id in traj_ids: \n", - " traj = db.get_trajectory_atoms(last_run_id, traj_id)\n", - " r0 = traj[0].get_positions()\n", - " mad = np.zeros(len(traj))\n", - " for i, a in enumerate(traj):\n", - " mad[i] = np.mean(np.abs(a.get_positions() - r0))\n", - " plt.plot(mad)\n", - " t = np.arange(mad.shape[0])\n", - " plt.scatter(t, mad)\n", - " plt.xlabel('timestep')\n", - " plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n", - " plt.title(f'Traj {traj_id}')\n", - " plt.show()" - ] + "outputs": [], + "source": "for traj_id in traj_ids: \n traj = db.get_trajectory_atoms(last_run_id, traj_id)\n model_versions = get_frame_model_versions(db, last_run_id, traj_id)\n r0 = traj[0].get_positions()\n mad = np.zeros(len(traj))\n for i, a in enumerate(traj):\n mad[i] = np.mean(np.abs(a.get_positions() - r0))\n t = np.arange(mad.shape[0])\n plt.plot(t, mad, color='gray', alpha=0.3, zorder=1)\n sc = plt.scatter(t, mad, c=model_versions, cmap='viridis', zorder=2)\n plt.colorbar(sc, label='model_version')\n plt.xlabel('timestep')\n plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n plt.title(f'Traj {traj_id}')\n plt.show()" }, { "cell_type": "code", @@ -1607,6 +1550,28 @@ "I think we need a more interesting system before the UQ is helpful. Probably larger ensemble as well" ] }, + { + "cell_type": "markdown", + "id": "4dd6ce2e", + "source": "## UQ vs error", + "metadata": {} + }, + { + "cell_type": "code", + "id": "73d9efe1", + "source": "with db.session() as sess:\n calib_rows = sess.query(\n DBTrainingFrame.traj_id,\n DBTrainingFrame.chunk_id,\n DBTrainingFrame.model_version_sampled_from,\n DBTrainingFrame.calibration_uq,\n DBTrainingFrame.calibration_error,\n ).filter(\n DBTrainingFrame.run_id == last_run_id,\n DBTrainingFrame.calibration_error.isnot(None),\n ).all()\n\ncalib_df = pd.DataFrame(\n calib_rows,\n columns=['traj_id', 'chunk_id', 'model_version_sampled_from', 'calibration_uq', 'calibration_error']\n)\ncalib_df.head()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "id": "b021dfd9", + "source": "sc = plt.scatter(calib_df['calibration_uq'], calib_df['calibration_error'], c=calib_df['model_version_sampled_from'], cmap='viridis', alpha=0.7)\nplt.colorbar(sc, label='model_version_sampled_from')\nplt.xscale('log')\nplt.yscale('log')\nplt.xlabel('UQ at sample time (calibration_uq)')\nplt.ylabel('observed force error (calibration_error)')\nplt.title('UQ vs. observed error')\nplt.show()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, { "cell_type": "code", "execution_count": null, @@ -1637,4 +1602,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 4fe3f29cabc02cac1a02de825138eb19e48e9919 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 17:00:25 +0000 Subject: [PATCH 08/25] Use discrete per-model-version legends instead of a continuous colormap model_version is a small integer category, not a continuous quantity, so a viridis colorbar was misleading. Both the MAD plot and the UQ-vs-error plot now scatter one group per model_version with a proper legend. --- 3_cascade/2_sanity_check_run.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/3_cascade/2_sanity_check_run.ipynb b/3_cascade/2_sanity_check_run.ipynb index 7eb87cd..0c4f159 100644 --- a/3_cascade/2_sanity_check_run.ipynb +++ b/3_cascade/2_sanity_check_run.ipynb @@ -803,7 +803,7 @@ "id": "55b02eea-a83c-42ad-9fc1-d26a078dbd69", "metadata": {}, "outputs": [], - "source": "for traj_id in traj_ids: \n traj = db.get_trajectory_atoms(last_run_id, traj_id)\n model_versions = get_frame_model_versions(db, last_run_id, traj_id)\n r0 = traj[0].get_positions()\n mad = np.zeros(len(traj))\n for i, a in enumerate(traj):\n mad[i] = np.mean(np.abs(a.get_positions() - r0))\n t = np.arange(mad.shape[0])\n plt.plot(t, mad, color='gray', alpha=0.3, zorder=1)\n sc = plt.scatter(t, mad, c=model_versions, cmap='viridis', zorder=2)\n plt.colorbar(sc, label='model_version')\n plt.xlabel('timestep')\n plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n plt.title(f'Traj {traj_id}')\n plt.show()" + "source": "for traj_id in traj_ids: \n traj = db.get_trajectory_atoms(last_run_id, traj_id)\n model_versions = get_frame_model_versions(db, last_run_id, traj_id)\n r0 = traj[0].get_positions()\n mad = np.zeros(len(traj))\n for i, a in enumerate(traj):\n mad[i] = np.mean(np.abs(a.get_positions() - r0))\n t = np.arange(mad.shape[0])\n plt.plot(t, mad, color='gray', alpha=0.3, zorder=1)\n for mv in np.unique(model_versions):\n mask = model_versions == mv\n plt.scatter(t[mask], mad[mask], label=f'model_version {mv}', zorder=2)\n plt.legend()\n plt.xlabel('timestep')\n plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n plt.title(f'Traj {traj_id}')\n plt.show()" }, { "cell_type": "code", @@ -1567,7 +1567,7 @@ { "cell_type": "code", "id": "b021dfd9", - "source": "sc = plt.scatter(calib_df['calibration_uq'], calib_df['calibration_error'], c=calib_df['model_version_sampled_from'], cmap='viridis', alpha=0.7)\nplt.colorbar(sc, label='model_version_sampled_from')\nplt.xscale('log')\nplt.yscale('log')\nplt.xlabel('UQ at sample time (calibration_uq)')\nplt.ylabel('observed force error (calibration_error)')\nplt.title('UQ vs. observed error')\nplt.show()", + "source": "for mv in sorted(calib_df['model_version_sampled_from'].unique()):\n sub = calib_df[calib_df['model_version_sampled_from'] == mv]\n plt.scatter(sub['calibration_uq'], sub['calibration_error'], label=f'model_version {mv}', alpha=0.7)\nplt.legend()\nplt.xscale('log')\nplt.yscale('log')\nplt.xlabel('UQ at sample time (calibration_uq)')\nplt.ylabel('observed force error (calibration_error)')\nplt.title('UQ vs. observed error')\nplt.show()", "metadata": {}, "execution_count": null, "outputs": [] From 81862f04811c1f71b3c4fd0904c4ef4020153fd7 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 17:22:55 +0000 Subject: [PATCH 09/25] Add cell-volume start-vs-end plot per trajectory Pulls the first-ever frame and the last-ever recorded frame directly (not via get_trajectory_atoms, which only returns passed chunks) so a trajectory stuck on a failed/crashed final attempt still gets a real end-state comparison instead of silently falling back to its last passed chunk. --- 3_cascade/2_sanity_check_run.ipynb | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/3_cascade/2_sanity_check_run.ipynb b/3_cascade/2_sanity_check_run.ipynb index 0c4f159..1dc1cb1 100644 --- a/3_cascade/2_sanity_check_run.ipynb +++ b/3_cascade/2_sanity_check_run.ipynb @@ -1572,6 +1572,28 @@ "execution_count": null, "outputs": [] }, + { + "cell_type": "markdown", + "id": "63681bf1", + "source": "## cell size: start vs end", + "metadata": {} + }, + { + "cell_type": "code", + "id": "95c7fcc4", + "source": "def get_first_and_last_atoms(db, run_id, traj_id):\n \"\"\"First-ever frame, and last-ever recorded frame (from the last attempt that actually\n wrote frames, even if that chunk/attempt ultimately failed audit or never got audited).\"\"\"\n with db.session() as sess:\n first = sess.query(DBTrajectoryFrame).filter_by(run_id=run_id, traj_id=traj_id).order_by(\n DBTrajectoryFrame.chunk_id, DBTrajectoryFrame.attempt_index, DBTrajectoryFrame.frame_index\n ).first()\n last = sess.query(DBTrajectoryFrame).filter_by(run_id=run_id, traj_id=traj_id).order_by(\n DBTrajectoryFrame.chunk_id.desc(), DBTrajectoryFrame.attempt_index.desc(), DBTrajectoryFrame.frame_index.desc()\n ).first()\n first_atoms = db._deserialize_atoms(first.atoms_blob)\n last_atoms = db._deserialize_atoms(last.atoms_blob)\n return first_atoms, last_atoms\n\ncell_rows = []\nfor traj_id in traj_ids:\n first_atoms, last_atoms = get_first_and_last_atoms(db, last_run_id, traj_id)\n cell_rows.append({\n 'traj_id': traj_id,\n 'start_volume': first_atoms.get_volume(),\n 'end_volume': last_atoms.get_volume(),\n })\ncell_df = pd.DataFrame(cell_rows)\ncell_df", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "id": "051fb581", + "source": "x = np.arange(len(cell_df))\nwidth = 0.35\nplt.bar(x - width/2, cell_df['start_volume'], width, label='start')\nplt.bar(x + width/2, cell_df['end_volume'], width, label='end')\nplt.xticks(x, cell_df['traj_id'])\nplt.xlabel('traj_id')\nplt.ylabel('cell volume ($\\mathrm{\\AA}^3$)')\nplt.legend()\nplt.title('Cell volume: start vs. end')\nplt.show()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, { "cell_type": "code", "execution_count": null, From 232f51704f89ca06a04fca088a3c830929801159 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 18:17:13 +0000 Subject: [PATCH 10/25] Add notebook investigating ensemble member 2's training divergence No per-member bootstrap provenance is persisted (Trainer.train_model draws indices with an unseeded RNG, held only in memory), so this characterizes the round-1 training pool directly instead: every one of its 200 frames has a labeled-atoms min interatomic distance under 1 A (98.5% under 0.5 A), i.e. essentially collided structures. A Monte Carlo simulation of the actual bootstrap procedure on that real pool shows meaningfully uneven per-member exposure to the worst frames arises from resampling variance alone, even though every member draws from the same uniformly pathological pool. --- 3_cascade/3_ensemble_member_divergence.ipynb | 205 +++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 3_cascade/3_ensemble_member_divergence.ipynb diff --git a/3_cascade/3_ensemble_member_divergence.ipynb b/3_cascade/3_ensemble_member_divergence.ipynb new file mode 100644 index 0000000..5f4c2a9 --- /dev/null +++ b/3_cascade/3_ensemble_member_divergence.ipynb @@ -0,0 +1,205 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro-md", + "metadata": {}, + "source": [ + "# Ensemble member divergence\n", + "## Why did one bootstrapped member's training round diverge, and could bootstrap variance alone explain it?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "imports-cell", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from cascade.agents.db_orm import TrajectoryDB, DBTrainingFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db-cell", + "metadata": {}, + "outputs": [], + "source": [ + "db_url = 'postgresql://ase:pw@localhost:5432/cascade'\n", + "db = TrajectoryDB(db_url)\n", + "run_id = '2026.08.24-18:12:33-ffdfbd'\n", + "training_round = 1 # the round where member 2's loss diverged" + ] + }, + { + "cell_type": "markdown", + "id": "provenance-md", + "metadata": {}, + "source": [ + "## Per-member provenance\n", + "`Trainer.train_model` draws each member's bootstrap sample with an unseeded `np.random.default_rng()` and only ever holds the resulting indices in memory (`cascade/agents/agents.py`) -- they're never written to the DB or logs. So there is no way to recover which exact frames (with duplicates) went to which of the 4 members for this run. What follows instead: characterize the actual round's training pool, then simulate the real resampling procedure on that real pool to see how much per-member variance it produces on its own." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "pull-frames-cell", + "metadata": {}, + "outputs": [], + "source": [ + "def get_round_physical_metrics(db, run_id, training_round):\n", + " \"\"\"Physical-absurdity metrics per training frame, computed directly from the labeled\n", + " (reference) Atoms -- independent of any model prediction.\"\"\"\n", + " with db.session() as sess:\n", + " rows = sess.query(DBTrainingFrame).filter_by(run_id=run_id, training_round=training_round).all()\n", + " records = []\n", + " for tf in rows:\n", + " atoms_labeled = db._deserialize_atoms(tf.atoms_labeled_blob)\n", + " forces = atoms_labeled.calc.results['forces']\n", + " dists = atoms_labeled.get_all_distances(mic=True)\n", + " np.fill_diagonal(dists, np.inf)\n", + " records.append({\n", + " 'traj_id': tf.traj_id,\n", + " 'chunk_id': tf.chunk_id,\n", + " 'calibration_error': tf.calibration_error,\n", + " 'max_ref_force': float(np.linalg.norm(forces, axis=-1).max()),\n", + " 'cell_volume': atoms_labeled.get_volume(),\n", + " 'min_interatomic_dist': float(dists.min()),\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "pool_df = get_round_physical_metrics(db, run_id, training_round)\n", + "pool_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "describe-cell", + "metadata": {}, + "outputs": [], + "source": [ + "pool_df[['calibration_error', 'max_ref_force', 'cell_volume', 'min_interatomic_dist']].describe(\n", + " percentiles=[.05, .25, .5, .75, .9, .95, .99]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "collided-frac-cell", + "metadata": {}, + "outputs": [], + "source": [ + "for threshold in [1.0, 0.5, 0.2]:\n", + " frac = (pool_df['min_interatomic_dist'] < threshold).mean()\n", + " print(f'fraction of round-{training_round} frames with min interatomic distance < {threshold} A: {frac:.1%}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "hist-cell", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", + "axes[0].hist(pool_df['min_interatomic_dist'], bins=30)\n", + "axes[0].set_xlabel('min interatomic distance ($\\\\mathrm{\\\\AA}$)')\n", + "axes[0].set_ylabel('count')\n", + "axes[1].hist(pool_df['max_ref_force'], bins=30)\n", + "axes[1].set_xlabel('max reference force ($\\\\mathrm{eV/\\\\AA}$)')\n", + "axes[1].set_ylabel('count')\n", + "fig.suptitle(f'Round {training_round} training pool, n={len(pool_df)}')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "mc-md", + "metadata": {}, + "source": [ + "## Monte Carlo: does bootstrap variance alone explain one member drawing a worse hand than the others?\n", + "Simulates the actual resampling procedure (`bootstrap_fraction=1.0` -> sample-with-replacement, `n_sample == len(pool)`, see `cascade/agents/config.py` / `Trainer.train_model`) on the real round's `max_ref_force` values, many times, for 4 independent members per trial." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mc-sim-cell", + "metadata": {}, + "outputs": [], + "source": [ + "bootstrap_fraction = 1.0 # matches TrainerConfig default\n", + "n_members = 4\n", + "n_trials = 5000\n", + "\n", + "vals = pool_df['max_ref_force'].values\n", + "n_sample = int(len(vals) * bootstrap_fraction)\n", + "worst_idx = int(np.argmax(vals))\n", + "\n", + "rng = np.random.default_rng(0) # seeded only so this simulation itself is reproducible -- the real run's draw was not seeded and is not recoverable\n", + "draws = rng.integers(0, len(vals), size=(n_trials, n_members, n_sample))\n", + "\n", + "worst_frame_copies = (draws == worst_idx).sum(axis=2) # (n_trials, n_members): copies of the single worst frame each member happened to draw\n", + "exposure = (vals[draws] ** 2).sum(axis=2) # (n_trials, n_members): total force^2 \"gradient shock\" exposure per member's draw\n", + "\n", + "copy_spread = worst_frame_copies.max(axis=1) - worst_frame_copies.min(axis=1)\n", + "exposure_ratio = exposure.max(axis=1) / exposure.min(axis=1)\n", + "\n", + "print(f'worst single frame in the real pool: max_ref_force={vals[worst_idx]:.1f} eV/A')\n", + "print(f'P(most-exposed member draws >=2 more copies of it than least-exposed member): {(copy_spread >= 2).mean():.1%}')\n", + "print(f'P(most-exposed member draws >=3 more copies of it than least-exposed member): {(copy_spread >= 3).mean():.1%}')\n", + "print()\n", + "print('per-trial (max member exposure / min member exposure) ratio:')\n", + "print(pd.Series(exposure_ratio).describe())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mc-plot-cell", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", + "axes[0].hist(worst_frame_copies.flatten(), bins=np.arange(worst_frame_copies.max() + 2) - 0.5)\n", + "axes[0].set_xlabel('copies of the single worst frame in one member\\'s bootstrap draw')\n", + "axes[0].set_ylabel('count (across all simulated members)')\n", + "axes[1].hist(exposure_ratio, bins=30)\n", + "axes[1].set_xlabel('per-trial max/min member force$^2$ exposure ratio')\n", + "axes[1].set_ylabel('count (across trials)')\n", + "fig.suptitle('Bootstrap-variance simulation, 4 members x 5000 trials')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a0a724db5c3d005cc920d037181f4b3c160e9612 Mon Sep 17 00:00:00 2001 From: Michael Tynes Date: Tue, 25 Aug 2026 16:09:03 -0500 Subject: [PATCH 11/25] Trainer safety (#89) * Mark trajectory failed and shut down DynamicsRunner on dynamics task exceptions An unhandled exception during dynamics execution (e.g. numpy.linalg.LinAlgError from ASE's MTK-NPT barostat) previously propagated out of the DynamicsRunner's run loop and crashed the agent, silently stalling the trajectory while the Slurm job kept reporting RUNNING. Now such failures are caught, logged, and recorded via mark_trajectory_failed before a clean agent shutdown. * Add model-version coloring to MAD plot and a UQ-vs-error plot MAD-vs-timestep scatter now colors points by which model_version produced each frame (via a helper that mirrors get_trajectory_atoms's chunk iteration/dedup exactly). New "UQ vs error" section plots DBTrainingFrame.calibration_uq against calibration_error (the same pair the Controller uses for real threshold calibration), log-log, colored by model_version_sampled_from. * Use discrete per-model-version legends instead of a continuous colormap model_version is a small integer category, not a continuous quantity, so a viridis colorbar was misleading. Both the MAD plot and the UQ-vs-error plot now scatter one group per model_version with a proper legend. * Add cell-volume start-vs-end plot per trajectory Pulls the first-ever frame and the last-ever recorded frame directly (not via get_trajectory_atoms, which only returns passed chunks) so a trajectory stuck on a failed/crashed final attempt still gets a real end-state comparison instead of silently falling back to its last passed chunk. * Add notebook investigating ensemble member 2's training divergence No per-member bootstrap provenance is persisted (Trainer.train_model draws indices with an unseeded RNG, held only in memory), so this characterizes the round-1 training pool directly instead: every one of its 200 frames has a labeled-atoms min interatomic distance under 1 A (98.5% under 0.5 A), i.e. essentially collided structures. A Monte Carlo simulation of the actual bootstrap procedure on that real pool shows meaningfully uneven per-member exposure to the worst frames arises from resampling variance alone, even though every member draws from the same uniformly pathological pool. * Guard against undetected training-pool/ensemble divergence Default burn-in to 1 round so a real retrain (and real inter-member divergence) always happens before the UQ audit is load-bearing -- previously an ensemble of clone-initialized members had ~zero disagreement at model_version=0, so audits only ever caught anything by the unrelated random-fail perturbation. Filter physically-absurd frames (min interatomic distance below a configurable threshold) out of the training pool before they reach the trainer, and detect per-member training divergence (non-finite validation loss) with a retry-on-fresh-bootstrap loop instead of silently deploying diverged weights. Add gradient-norm clipping and a NaN/Inf loss guard in MACEInterface.train to keep a single bad batch from corrupting a member outright. --- 3_cascade/2_sanity_check_run.ipynb | 129 ++++++------ 3_cascade/3_ensemble_member_divergence.ipynb | 205 +++++++++++++++++++ 3_cascade/run_cascade_academy.py | 18 +- cascade/agents/agents.py | 87 ++++++-- cascade/agents/config.py | 6 + cascade/learning/mace.py | 14 +- 6 files changed, 368 insertions(+), 91 deletions(-) create mode 100644 3_cascade/3_ensemble_member_divergence.ipynb diff --git a/3_cascade/2_sanity_check_run.ipynb b/3_cascade/2_sanity_check_run.ipynb index ac4a9d6..1dc1cb1 100644 --- a/3_cascade/2_sanity_check_run.ipynb +++ b/3_cascade/2_sanity_check_run.ipynb @@ -11,21 +11,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "3634b4fb-cd44-4897-ae60-fb14f6b17aa6", "metadata": {}, "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from ase.db import connect\n", - "\n", - "from cascade.agents.db_orm import TrajectoryDB, DBTrajectoryFrame" - ] + "source": "%load_ext autoreload\n%autoreload 2\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom ase.db import connect\n\nfrom cascade.agents.db_orm import TrajectoryDB, DBTrajectoryFrame, DBTrainingFrame" }, { "cell_type": "code", @@ -801,66 +791,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "id": "e7c7fdfc", + "source": "def get_frame_model_versions(db, run_id, traj_id):\n \"\"\"Per-frame model_version, aligned with db.get_trajectory_atoms's frame ordering/dedup\"\"\"\n chunks = db.get_passed_chunks(run_id, traj_id)\n model_versions = []\n with db.session() as sess:\n for i, chunk in enumerate(chunks):\n frames = sess.query(DBTrajectoryFrame).filter_by(\n run_id=run_id,\n traj_id=traj_id,\n chunk_id=chunk['chunk_id'],\n attempt_index=chunk['attempt_index']\n ).order_by(DBTrajectoryFrame.frame_index).all()\n if i > 0:\n frames = frames[1:]\n model_versions.extend([chunk['model_version']] * len(frames))\n return np.array(model_versions)", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, "id": "55b02eea-a83c-42ad-9fc1-d26a078dbd69", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for traj_id in traj_ids: \n", - " traj = db.get_trajectory_atoms(last_run_id, traj_id)\n", - " r0 = traj[0].get_positions()\n", - " mad = np.zeros(len(traj))\n", - " for i, a in enumerate(traj):\n", - " mad[i] = np.mean(np.abs(a.get_positions() - r0))\n", - " plt.plot(mad)\n", - " t = np.arange(mad.shape[0])\n", - " plt.scatter(t, mad)\n", - " plt.xlabel('timestep')\n", - " plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n", - " plt.title(f'Traj {traj_id}')\n", - " plt.show()" - ] + "outputs": [], + "source": "for traj_id in traj_ids: \n traj = db.get_trajectory_atoms(last_run_id, traj_id)\n model_versions = get_frame_model_versions(db, last_run_id, traj_id)\n r0 = traj[0].get_positions()\n mad = np.zeros(len(traj))\n for i, a in enumerate(traj):\n mad[i] = np.mean(np.abs(a.get_positions() - r0))\n t = np.arange(mad.shape[0])\n plt.plot(t, mad, color='gray', alpha=0.3, zorder=1)\n for mv in np.unique(model_versions):\n mask = model_versions == mv\n plt.scatter(t[mask], mad[mask], label=f'model_version {mv}', zorder=2)\n plt.legend()\n plt.xlabel('timestep')\n plt.ylabel('$\\mathbf{mean} [|\\mathbf{r}_0 - \\mathbf{r}_t|]$')\n plt.title(f'Traj {traj_id}')\n plt.show()" }, { "cell_type": "code", @@ -1607,6 +1550,50 @@ "I think we need a more interesting system before the UQ is helpful. Probably larger ensemble as well" ] }, + { + "cell_type": "markdown", + "id": "4dd6ce2e", + "source": "## UQ vs error", + "metadata": {} + }, + { + "cell_type": "code", + "id": "73d9efe1", + "source": "with db.session() as sess:\n calib_rows = sess.query(\n DBTrainingFrame.traj_id,\n DBTrainingFrame.chunk_id,\n DBTrainingFrame.model_version_sampled_from,\n DBTrainingFrame.calibration_uq,\n DBTrainingFrame.calibration_error,\n ).filter(\n DBTrainingFrame.run_id == last_run_id,\n DBTrainingFrame.calibration_error.isnot(None),\n ).all()\n\ncalib_df = pd.DataFrame(\n calib_rows,\n columns=['traj_id', 'chunk_id', 'model_version_sampled_from', 'calibration_uq', 'calibration_error']\n)\ncalib_df.head()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "id": "b021dfd9", + "source": "for mv in sorted(calib_df['model_version_sampled_from'].unique()):\n sub = calib_df[calib_df['model_version_sampled_from'] == mv]\n plt.scatter(sub['calibration_uq'], sub['calibration_error'], label=f'model_version {mv}', alpha=0.7)\nplt.legend()\nplt.xscale('log')\nplt.yscale('log')\nplt.xlabel('UQ at sample time (calibration_uq)')\nplt.ylabel('observed force error (calibration_error)')\nplt.title('UQ vs. observed error')\nplt.show()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "63681bf1", + "source": "## cell size: start vs end", + "metadata": {} + }, + { + "cell_type": "code", + "id": "95c7fcc4", + "source": "def get_first_and_last_atoms(db, run_id, traj_id):\n \"\"\"First-ever frame, and last-ever recorded frame (from the last attempt that actually\n wrote frames, even if that chunk/attempt ultimately failed audit or never got audited).\"\"\"\n with db.session() as sess:\n first = sess.query(DBTrajectoryFrame).filter_by(run_id=run_id, traj_id=traj_id).order_by(\n DBTrajectoryFrame.chunk_id, DBTrajectoryFrame.attempt_index, DBTrajectoryFrame.frame_index\n ).first()\n last = sess.query(DBTrajectoryFrame).filter_by(run_id=run_id, traj_id=traj_id).order_by(\n DBTrajectoryFrame.chunk_id.desc(), DBTrajectoryFrame.attempt_index.desc(), DBTrajectoryFrame.frame_index.desc()\n ).first()\n first_atoms = db._deserialize_atoms(first.atoms_blob)\n last_atoms = db._deserialize_atoms(last.atoms_blob)\n return first_atoms, last_atoms\n\ncell_rows = []\nfor traj_id in traj_ids:\n first_atoms, last_atoms = get_first_and_last_atoms(db, last_run_id, traj_id)\n cell_rows.append({\n 'traj_id': traj_id,\n 'start_volume': first_atoms.get_volume(),\n 'end_volume': last_atoms.get_volume(),\n })\ncell_df = pd.DataFrame(cell_rows)\ncell_df", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "id": "051fb581", + "source": "x = np.arange(len(cell_df))\nwidth = 0.35\nplt.bar(x - width/2, cell_df['start_volume'], width, label='start')\nplt.bar(x + width/2, cell_df['end_volume'], width, label='end')\nplt.xticks(x, cell_df['traj_id'])\nplt.xlabel('traj_id')\nplt.ylabel('cell volume ($\\mathrm{\\AA}^3$)')\nplt.legend()\nplt.title('Cell volume: start vs. end')\nplt.show()", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, { "cell_type": "code", "execution_count": null, @@ -1637,4 +1624,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/3_cascade/3_ensemble_member_divergence.ipynb b/3_cascade/3_ensemble_member_divergence.ipynb new file mode 100644 index 0000000..5f4c2a9 --- /dev/null +++ b/3_cascade/3_ensemble_member_divergence.ipynb @@ -0,0 +1,205 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro-md", + "metadata": {}, + "source": [ + "# Ensemble member divergence\n", + "## Why did one bootstrapped member's training round diverge, and could bootstrap variance alone explain it?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "imports-cell", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from cascade.agents.db_orm import TrajectoryDB, DBTrainingFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db-cell", + "metadata": {}, + "outputs": [], + "source": [ + "db_url = 'postgresql://ase:pw@localhost:5432/cascade'\n", + "db = TrajectoryDB(db_url)\n", + "run_id = '2026.08.24-18:12:33-ffdfbd'\n", + "training_round = 1 # the round where member 2's loss diverged" + ] + }, + { + "cell_type": "markdown", + "id": "provenance-md", + "metadata": {}, + "source": [ + "## Per-member provenance\n", + "`Trainer.train_model` draws each member's bootstrap sample with an unseeded `np.random.default_rng()` and only ever holds the resulting indices in memory (`cascade/agents/agents.py`) -- they're never written to the DB or logs. So there is no way to recover which exact frames (with duplicates) went to which of the 4 members for this run. What follows instead: characterize the actual round's training pool, then simulate the real resampling procedure on that real pool to see how much per-member variance it produces on its own." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "pull-frames-cell", + "metadata": {}, + "outputs": [], + "source": [ + "def get_round_physical_metrics(db, run_id, training_round):\n", + " \"\"\"Physical-absurdity metrics per training frame, computed directly from the labeled\n", + " (reference) Atoms -- independent of any model prediction.\"\"\"\n", + " with db.session() as sess:\n", + " rows = sess.query(DBTrainingFrame).filter_by(run_id=run_id, training_round=training_round).all()\n", + " records = []\n", + " for tf in rows:\n", + " atoms_labeled = db._deserialize_atoms(tf.atoms_labeled_blob)\n", + " forces = atoms_labeled.calc.results['forces']\n", + " dists = atoms_labeled.get_all_distances(mic=True)\n", + " np.fill_diagonal(dists, np.inf)\n", + " records.append({\n", + " 'traj_id': tf.traj_id,\n", + " 'chunk_id': tf.chunk_id,\n", + " 'calibration_error': tf.calibration_error,\n", + " 'max_ref_force': float(np.linalg.norm(forces, axis=-1).max()),\n", + " 'cell_volume': atoms_labeled.get_volume(),\n", + " 'min_interatomic_dist': float(dists.min()),\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "pool_df = get_round_physical_metrics(db, run_id, training_round)\n", + "pool_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "describe-cell", + "metadata": {}, + "outputs": [], + "source": [ + "pool_df[['calibration_error', 'max_ref_force', 'cell_volume', 'min_interatomic_dist']].describe(\n", + " percentiles=[.05, .25, .5, .75, .9, .95, .99]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "collided-frac-cell", + "metadata": {}, + "outputs": [], + "source": [ + "for threshold in [1.0, 0.5, 0.2]:\n", + " frac = (pool_df['min_interatomic_dist'] < threshold).mean()\n", + " print(f'fraction of round-{training_round} frames with min interatomic distance < {threshold} A: {frac:.1%}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "hist-cell", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", + "axes[0].hist(pool_df['min_interatomic_dist'], bins=30)\n", + "axes[0].set_xlabel('min interatomic distance ($\\\\mathrm{\\\\AA}$)')\n", + "axes[0].set_ylabel('count')\n", + "axes[1].hist(pool_df['max_ref_force'], bins=30)\n", + "axes[1].set_xlabel('max reference force ($\\\\mathrm{eV/\\\\AA}$)')\n", + "axes[1].set_ylabel('count')\n", + "fig.suptitle(f'Round {training_round} training pool, n={len(pool_df)}')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "mc-md", + "metadata": {}, + "source": [ + "## Monte Carlo: does bootstrap variance alone explain one member drawing a worse hand than the others?\n", + "Simulates the actual resampling procedure (`bootstrap_fraction=1.0` -> sample-with-replacement, `n_sample == len(pool)`, see `cascade/agents/config.py` / `Trainer.train_model`) on the real round's `max_ref_force` values, many times, for 4 independent members per trial." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mc-sim-cell", + "metadata": {}, + "outputs": [], + "source": [ + "bootstrap_fraction = 1.0 # matches TrainerConfig default\n", + "n_members = 4\n", + "n_trials = 5000\n", + "\n", + "vals = pool_df['max_ref_force'].values\n", + "n_sample = int(len(vals) * bootstrap_fraction)\n", + "worst_idx = int(np.argmax(vals))\n", + "\n", + "rng = np.random.default_rng(0) # seeded only so this simulation itself is reproducible -- the real run's draw was not seeded and is not recoverable\n", + "draws = rng.integers(0, len(vals), size=(n_trials, n_members, n_sample))\n", + "\n", + "worst_frame_copies = (draws == worst_idx).sum(axis=2) # (n_trials, n_members): copies of the single worst frame each member happened to draw\n", + "exposure = (vals[draws] ** 2).sum(axis=2) # (n_trials, n_members): total force^2 \"gradient shock\" exposure per member's draw\n", + "\n", + "copy_spread = worst_frame_copies.max(axis=1) - worst_frame_copies.min(axis=1)\n", + "exposure_ratio = exposure.max(axis=1) / exposure.min(axis=1)\n", + "\n", + "print(f'worst single frame in the real pool: max_ref_force={vals[worst_idx]:.1f} eV/A')\n", + "print(f'P(most-exposed member draws >=2 more copies of it than least-exposed member): {(copy_spread >= 2).mean():.1%}')\n", + "print(f'P(most-exposed member draws >=3 more copies of it than least-exposed member): {(copy_spread >= 3).mean():.1%}')\n", + "print()\n", + "print('per-trial (max member exposure / min member exposure) ratio:')\n", + "print(pd.Series(exposure_ratio).describe())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mc-plot-cell", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", + "axes[0].hist(worst_frame_copies.flatten(), bins=np.arange(worst_frame_copies.max() + 2) - 0.5)\n", + "axes[0].set_xlabel('copies of the single worst frame in one member\\'s bootstrap draw')\n", + "axes[0].set_ylabel('count (across all simulated members)')\n", + "axes[1].hist(exposure_ratio, bins=30)\n", + "axes[1].set_xlabel('per-trial max/min member force$^2$ exposure ratio')\n", + "axes[1].set_ylabel('count (across trials)')\n", + "fig.suptitle('Bootstrap-variance simulation, 4 members x 5000 trials')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/3_cascade/run_cascade_academy.py b/3_cascade/run_cascade_academy.py index d05be8e..368b0a2 100644 --- a/3_cascade/run_cascade_academy.py +++ b/3_cascade/run_cascade_academy.py @@ -137,7 +137,7 @@ def parse_args() -> argparse.Namespace: parser.add_argument( '--burn-in-rounds', type=int, - default=0, + default=1, help='Force-fail (and sample) chunks with model_version below this count, ' 'so the ensemble gets some real disagreement before the audit is load-bearing' ) @@ -306,6 +306,20 @@ def parse_args() -> argparse.Namespace: parser.add_argument('--replay-frequency', default=1, type=int, help='How often to replay') parser.add_argument('--replay-lr-reduction', default=1, type=float, help='Factor by which to reduce LR during replay') parser.add_argument('--replay-batch-size', default=None, type=int, help='Batch size used during replay') + parser.add_argument( + '--min-interatomic-distance', + type=float, + default=0.5, + help='Training frames with a labeled-atoms minimum interatomic distance below this ' + '(Angstrom) are dropped before training' + ) + parser.add_argument( + '--max-training-retries', + type=int, + default=1, + help='If a member\'s training run diverges (non-finite validation loss), retry it with a ' + 'fresh bootstrap draw up to this many times before keeping its previous weights' + ) args = parser.parse_args() args.per_trajectory_threshold = bool(args.per_trajectory_threshold) @@ -537,6 +551,8 @@ async def main(): ), learner=learner, replay=replay, + min_interatomic_distance=args.min_interatomic_distance, + max_training_retries=args.max_training_retries, ) # launch all agents diff --git a/cascade/agents/agents.py b/cascade/agents/agents.py index 3bba11d..ef6c456 100644 --- a/cascade/agents/agents.py +++ b/cascade/agents/agents.py @@ -140,8 +140,16 @@ async def run( # get future result wrapped_future = wrap_future(chunk_future) - await wrapped_future - chunk_atoms = wrapped_future.result() + try: + await wrapped_future + chunk_atoms = wrapped_future.result() + except Exception as exc: + reason = f"dynamics failed for chunk {spec.chunk_id} attempt {spec.attempt_index}: {exc!r}" + self.logger.error(f"Traj {self.config.traj_id} {reason}") + self._traj_db.mark_trajectory_failed(run_id=self.config.run_id, traj_id=self.config.traj_id, reason=reason) + self.done = True + self.agent_shutdown() + continue # write atoms # todo wrap this up frame_ids = [] @@ -550,13 +558,63 @@ def __init__(self, config): self.config = config self.weights = deepcopy(config.weights) + def _filter_unphysical_frames(self, frames): + """Drop frames whose minimum interatomic distance is below a physically-plausible + threshold (e.g. from a collapsing/unstable cell), so training never sees collided + structures.""" + kept = [] + for atoms in frames: + dists = atoms.get_all_distances(mic=True) + np.fill_diagonal(dists, np.inf) + if dists.min() >= self.config.min_interatomic_distance: + kept.append(atoms) + n_dropped = len(frames) - len(kept) + if n_dropped: + self.logger.warning( + f'Dropped {n_dropped}/{len(frames)} training frames with min interatomic ' + f'distance < {self.config.min_interatomic_distance} A' + ) + return kept + + @staticmethod + def _training_diverged(log) -> bool: + """Whether a member's returned training log shows the run diverged (non-finite loss).""" + loss_col = 'total_loss_valid' if 'total_loss_valid' in log.columns else 'total_loss_train' + return not np.isfinite(log[loss_col].iloc[-1]) + + async def _train_member(self, member_index, member_weights, train_data, valid_data, n_sample, rng): + """Train one ensemble member, retrying with a fresh bootstrap draw if it diverges. + Falls back to this member's current weights (logging the diverged run for + observability) if it's still diverged after max_training_retries.""" + for attempt in range(self.config.max_training_retries + 1): + boot_idx = rng.integers(0, len(train_data), size=n_sample) + boot_data = [train_data[i] for i in boot_idx] + future = self.config.executor.submit( + self.config.training_task, + learner=self.config.learner, + weights=member_weights, + train_data=boot_data, + valid_data=valid_data, + train_kws=self.config.training_kws, + replay=self.config.replay, + ) + new_weights, log = await wrap_future(future) + if not self._training_diverged(log): + return new_weights, log + remaining = self.config.max_training_retries - attempt + self.logger.warning( + f'Member {member_index} training diverged on attempt {attempt + 1}/' + f'{self.config.max_training_retries + 1}' + + (f'; retrying ({remaining} attempt(s) left)' if remaining > 0 else '; keeping previous weights') + ) + return member_weights, log + @action async def train_model( self, training_round: int, ) -> list[bytes]: from sklearn.model_selection import train_test_split - import numpy as np self.logger.info(f'Fetching training data for training round {training_round}') train_data = self._traj_db.get_training_frames( @@ -567,6 +625,10 @@ async def train_model( self.logger.warning(f'No training frames found for round {training_round}, skipping training') return self.weights self.logger.info(f'Got {len(train_data)} training frames') + train_data = self._filter_unphysical_frames(train_data) + if not train_data: + self.logger.warning(f'All training frames for round {training_round} were filtered as unphysical, skipping training') + return self.weights train_data, valid_data = train_test_split(train_data, test_size=0.2) self.logger.info(f'Train size: {len(train_data)}, val size: {len(valid_data)}') @@ -574,21 +636,10 @@ async def train_model( n_sample = int(len(train_data) * self.config.bootstrap_fraction) self.logger.info(f'Submitting {len(self.weights)} bootstrapped training tasks') - futures = [] - for member_weights in self.weights: - boot_idx = rng.integers(0, len(train_data), size=n_sample) - boot_data = [train_data[i] for i in boot_idx] - future = self.config.executor.submit( - self.config.training_task, - learner=self.config.learner, - weights=member_weights, - train_data=boot_data, - valid_data=valid_data, - train_kws=self.config.training_kws, - replay=self.config.replay, - ) - futures.append(wrap_future(future)) - + futures = [ + self._train_member(member_index, member_weights, train_data, valid_data, n_sample, rng) + for member_index, member_weights in enumerate(self.weights) + ] results = await asyncio.gather(*futures) self.logger.info('Retrieving new weights') diff --git a/cascade/agents/config.py b/cascade/agents/config.py index 4fa199d..0554712 100644 --- a/cascade/agents/config.py +++ b/cascade/agents/config.py @@ -156,6 +156,12 @@ class TrainerConfig(CascadeAgentConfig): """Multi-head replay config (see cascade.learning.finetuning.MultiHeadConfig), passed through to learner.train to prevent catastrophic forgetting. Only meaningful for learners whose train() accepts a `replay` kwarg (currently MACEInterface).""" + min_interatomic_distance: float = 0.5 + """Training frames with a labeled-atoms minimum interatomic distance below this (Angstrom) are + dropped before training -- guards against training on unphysical/collided sampled structures""" + max_training_retries: int = 1 + """If a member's training run diverges (non-finite validation loss), retry it with a fresh + bootstrap draw up to this many times before giving up and keeping its previous weights""" @dataclass diff --git a/cascade/learning/mace.py b/cascade/learning/mace.py index 04ffc05..50423d9 100644 --- a/cascade/learning/mace.py +++ b/cascade/learning/mace.py @@ -218,7 +218,8 @@ def train(self, reset_weights: bool = False, patience: int | None = None, num_freeze: int | None = None, - replay: MultiHeadConfig | None = None + replay: MultiHeadConfig | None = None, + grad_clip_norm: float = 10., ) -> tuple[bytes, pd.DataFrame]: """Train a model @@ -238,6 +239,8 @@ def train(self, num_freeze: Number of layers to freeze. Starts from the top of the model (node embedding) See: `Radova et al. `_ replay: Settings for replaying an initial training set + grad_clip_norm: Max gradient norm for clipping; guards against a single bad batch + (e.g. an unstable/collided sampled structure) blowing up the model weights Returns: - model: Retrained model - history: Training history @@ -302,7 +305,16 @@ def train_step(engine, batch): compute_stress=True, ) loss = criterion(pred=y, ref=batch) + + if not torch.isfinite(loss): + logger.warning( + f'Non-finite loss ({loss.item()}) at epoch {engine.state.epoch - 1}; ' + 'skipping this batch\'s update' + ) + return float('nan') + loss.backward() + torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=grad_clip_norm) opt.step() # Get the training stats From d6b64d023222d1ce4befe0292fa6948830ba2154 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 21:20:29 +0000 Subject: [PATCH 12/25] add workers arg --- 3_cascade/run_cascade_academy.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/3_cascade/run_cascade_academy.py b/3_cascade/run_cascade_academy.py index d05be8e..1ced3ce 100644 --- a/3_cascade/run_cascade_academy.py +++ b/3_cascade/run_cascade_academy.py @@ -78,7 +78,13 @@ def parse_args() -> argparse.Namespace: '--log-level', type=str, default='INFO', - help='Logging levl' + help='Logging level' + ) + parser.add_argument( + '--max-workers', + type=int, + default=None, + help='Max workers in the executor pool' ) parser.add_argument( '--init-config-json', @@ -416,7 +422,7 @@ async def main(): # a new model while training is happening. can possibly do some math based on the retrain # logic to figure out the real max number of used workers # but this may not make as much sense once we distribute the workflow, so no worries for now - n_parsl_workers = len(initial_specs) + args.n_ensemble + n_parsl_workers = args.max_workers or len(initial_specs) + args.n_ensemble # only meaningful alongside the uq_threshold audit strategy, which is the # only audit_task that reads a 'threshold' kwarg use_controller = args.audit_task == 'uq_threshold' and args.target_ferr is not None From 755762de627f99c6eb6c8340c3cf6122f0317df0 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 21:22:08 +0000 Subject: [PATCH 13/25] fairchem cascade run --- 3_cascade/run_cascade_academy.sh | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/3_cascade/run_cascade_academy.sh b/3_cascade/run_cascade_academy.sh index b32d604..f15d7da 100644 --- a/3_cascade/run_cascade_academy.sh +++ b/3_cascade/run_cascade_academy.sh @@ -1,16 +1,30 @@ +#!/bin/bash +#SBATCH --partition=main +#SBATCH --gres=gpu:1 +#SBATCH --exclusive + + +source /home/michael/miniconda3/etc/profile.d/conda.sh +conda activate cascade + source "${SLURM_SUBMIT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/env_setup.sh" python run_cascade_academy.py \ - --init-config-json init_config_mof_crystalline_200_300K.json \ - --chunk-size 5 \ - --target-length 10 \ - --retrain-len 10 \ - --retrain-fraction 0.5 \ - --n-sample-frames 5 \ - --accept-rate .5 \ + --max-workers 1 \ + --init-config-json init_config_mof_crystalline_1000K.json \ + --chunk-size 1000 \ + --target-length 5000 \ + --retrain-len 10000000000 \ + --retrain-fraction 1 \ + --n-sample-frames 100 \ + --n-ensemble 4 \ --learner mace \ + --audit-task uq_threshold \ + --target-ferr 0.8 \ + --audit-random-fail-rate 0.25 \ + --calc-type fairchem \ + --calc-model ../1_ml-potential/uma/uma_omat_ft_mofoff_r2scan.pt \ --replay-dataset ./datasets/mace-mp/sampled_1000.traj \ --replay-batch-size 2 \ - --n-ensemble 4 \ --log-level DEBUG \ --device-train cuda:0 \ --device-label cuda:0 \ From 54be2e65bf70c000114c3212d92bb1a7b48d6bc9 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 25 Aug 2026 21:23:02 +0000 Subject: [PATCH 14/25] support ensembling in trainer testing scripts --- 3_cascade/benchmark_trainer.sh | 8 +- 3_cascade/scripts/benchmark_trainer.py | 242 ++++++++++++++++--------- 2 files changed, 162 insertions(+), 88 deletions(-) diff --git a/3_cascade/benchmark_trainer.sh b/3_cascade/benchmark_trainer.sh index 534c18d..2791663 100644 --- a/3_cascade/benchmark_trainer.sh +++ b/3_cascade/benchmark_trainer.sh @@ -6,7 +6,7 @@ source /home/michael/miniconda3/etc/profile.d/conda.sh conda activate cascade source "${SLURM_SUBMIT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/env_setup.sh" python scripts/benchmark_trainer.py \ - --run-id reference-2026.08.07-17:51:00-bd260f \ + --run-id reference-2026.08.21-19:31:10-43722e \ --max-frames 1000 \ --base-model small \ --batch-sizes 2 \ @@ -14,11 +14,13 @@ python scripts/benchmark_trainer.py \ --num-epochs 200 \ --patience 15 \ --device cuda:0 \ + --n-ensemble 4 \ + --max-workers 1 \ --replay-dataset ./datasets/mace-mp/sampled_1000.traj \ - --out-dir benchmark_trainer_out_batch_small_200 + --out-dir benchmark_trainer_out_batch_small_200_ensemble4 # python scripts/benchmark_trainer.py \ -# --run-id reference-2026.08.07-17:51:00-bd260f \ +# --run-id reference-2026.08.21-19:31:10-43722e \ # --max-frames 1000 \ # --base-model small \ # --batch-sizes 2 \ diff --git a/3_cascade/scripts/benchmark_trainer.py b/3_cascade/scripts/benchmark_trainer.py index b03f08b..12bc65a 100644 --- a/3_cascade/scripts/benchmark_trainer.py +++ b/3_cascade/scripts/benchmark_trainer.py @@ -2,13 +2,18 @@ """Benchmark MACE Trainer batch_size / num_epochs against real labeled data. Sweeps every combination of candidate batch_size x replay_batch_size (a 1x1 -grid when replay is off or only one of each is given). +grid when replay is off or only one of each is given). Each candidate trains +an ensemble of --n-ensemble members, routed through cascade.agents.task.train +(the same task cascade.agents.agents.Trainer.train_model submits in +production) via a Parsl executor, bootstrapping each member's training set +the same way Trainer.train_model does. -Records wall-clock time, peak GPU memory, and per-epoch train/valid loss ] +Records wall-clock time and per-epoch train/valid loss. Example: python scripts/benchmark_trainer.py --run-id my-reference-run \\ - --batch-sizes 4,8,16,32,64 --num-epochs 200 --patience 10 --device cuda + --batch-sizes 4,8,16,32,64 --num-epochs 200 --patience 10 --device cuda \\ + --n-ensemble 4 """ from __future__ import annotations @@ -18,21 +23,24 @@ import time from pathlib import Path +import numpy as np import torch from ase.io import read from mace.calculators import mace_mp +from parsl.concurrent import ParslPoolExecutor +from parsl.config import Config +from parsl.executors import HighThroughputExecutor +from parsl.providers import LocalProvider +from parsl.usage_tracking.levels import LEVEL_1 from sklearn.model_selection import train_test_split from cascade.agents.db_orm import TrajectoryDB +from cascade.agents.task import train as training_task from cascade.learning.finetuning import MultiHeadConfig from cascade.learning.mace import MACEInterface -PHASE_MEMORY_FIELDS = [ - 'peak_gpu_mb_train', 'peak_gpu_mb_valid', 'peak_gpu_mb_replay', - 'reserved_gpu_mb_train', 'reserved_gpu_mb_valid', 'reserved_gpu_mb_replay', -] -SUMMARY_FIELDS = ['batch_size', 'replay_batch_size', 'status', 'epochs_run', 'wall_clock_s', 'sec_per_epoch', - 'peak_gpu_mb', 'final_valid_loss', 'n_train', 'n_atoms_train'] + PHASE_MEMORY_FIELDS +SUMMARY_FIELDS = ['batch_size', 'replay_batch_size', 'member_index', 'status', 'epochs_run', + 'wall_clock_s', 'sec_per_epoch', 'final_valid_loss', 'n_train', 'n_atoms_train'] def parse_args() -> argparse.Namespace: @@ -90,7 +98,29 @@ def parse_args() -> argparse.Namespace: '--out-dir', type=str, default='benchmark_trainer_out', - help='Where summary.csv and per-batch-size epoch CSVs are written', + help='Where summary.csv and per-member epoch CSVs are written', + ) + parser.add_argument( + '--n-ensemble', + type=int, + default=1, + help='Ensemble members trained per (batch_size, replay_batch_size) candidate, each on an ' + 'independent bootstrap resample -- mirrors the bootstrap/submit/gather loop ' + 'cascade.agents.agents.Trainer.train_model uses in production', + ) + parser.add_argument( + '--max-workers', + type=int, + default=None, + help='Max concurrent Parsl training tasks (defaults to --n-ensemble, i.e. full concurrency, ' + 'matching production). Lower this if concurrent ensemble members OOM on a shared GPU.', + ) + parser.add_argument( + '--bootstrap-fraction', + type=float, + default=1.0, + help='Fraction of train_data resampled with replacement per ensemble member ' + "(matches TrainerConfig's default of 1.0)", ) parser.add_argument('--replay-dataset', default=None, help='Path to an ASE database containing data to replay during finetuning') parser.add_argument('--replay-downselect', default=None, type=int, help='Max number of entries to use from replay dataset') @@ -153,84 +183,104 @@ def _load_data(db: TrajectoryDB, run_id: str, traj_id: int | None, max_frames: i return atoms -def _read_completed_combos(summary_path: Path) -> set[tuple[int, str]]: +def _read_completed_combos(summary_path: Path) -> set[tuple[int, str, int]]: + """(batch_size, replay_batch_size_label, member_index) triples already recorded. + + Rows from a pre-ensemble summary.csv (no member_index column, e.g. an --out-dir reused + from before this script trained ensembles) are skipped rather than treated as a completed + member 0, since they weren't trained on a bootstrap resample and aren't a like-for-like + match for the new per-member semantics. + """ if not summary_path.exists(): return set() + completed = set() with open(summary_path, newline='') as f: - return {(int(row['batch_size']), row['replay_batch_size']) for row in csv.DictReader(f)} - - -def _run_candidate(learner: MACEInterface, weights: bytes, train_data: list, valid_data: list, - batch_size: int, args: argparse.Namespace, epoch_path: Path, is_cuda: bool, - replay: MultiHeadConfig | None, replay_label: str) -> dict: - """Train one (batch_size, replay_batch_size) combination, writing its per-epoch loss live to epoch_path.""" - tag = f'batch_size={batch_size} replay_batch_size={replay_label}' - epoch_writer = None - with open(epoch_path, 'w', newline='') as ef: - - def on_epoch(row: dict) -> None: - nonlocal epoch_writer - if epoch_writer is None: - epoch_writer = csv.DictWriter(ef, fieldnames=list(row)) - epoch_writer.writeheader() - epoch_writer.writerow(row) - ef.flush() - - if is_cuda: - torch.cuda.reset_peak_memory_stats(args.device) - t0 = time.perf_counter() - status = 'ok' - log = None - try: - _, log = learner.train( - weights, train_data, valid_data, - num_epochs=args.num_epochs, batch_size=batch_size, - device=args.device, patience=args.patience, - epoch_callback=on_epoch, replay=replay, - ) - except RuntimeError as e: - if not _is_oom(e): - raise - status = 'oom' - print(f'{tag}: OOM, recording partial progress and continuing') - wall_s = time.perf_counter() - t0 - - peak_mb = torch.cuda.max_memory_allocated(args.device) / 1e6 if is_cuda else 0.0 - - with open(epoch_path, newline='') as ef2: - epoch_rows = list(csv.DictReader(ef2)) + for row in csv.DictReader(f): + if not row.get('member_index'): + continue + completed.add((int(row['batch_size']), row['replay_batch_size'], int(row['member_index']))) + return completed + + +def _run_ensemble_candidate(pool: ParslPoolExecutor, learner: MACEInterface, init_ensemble_weights: list[bytes], + train_data: list, valid_data: list, batch_size: int, + replay: MultiHeadConfig | None, replay_label: str, args: argparse.Namespace, + out_dir: Path, completed_members: set[int]): + """Submit one bootstrapped training_task per not-yet-completed ensemble member for this + (batch_size, replay) candidate -- mirrors Trainer.train_model's bootstrap/submit/gather loop. + + Yields each member's result as soon as it's ready (rather than returning a fully-materialized + list), so the caller can write summary.csv rows incrementally -- otherwise a crash partway + through the ensemble would lose the summary row for every already-finished member too, even + though their epoch CSVs were already safely on disk. + """ + rng = np.random.default_rng() + n_sample = int(len(train_data) * args.bootstrap_fraction) + train_kws = dict(num_epochs=args.num_epochs, batch_size=batch_size, + device=args.device, patience=args.patience) + + pending = {} + for member_index, member_weights in enumerate(init_ensemble_weights): + if member_index in completed_members: + continue + boot_idx = rng.integers(0, len(train_data), size=n_sample) + boot_data = [train_data[i] for i in boot_idx] + future = pool.submit( + training_task, + learner=learner, + weights=member_weights, + train_data=boot_data, + valid_data=valid_data, + train_kws=train_kws, + replay=replay, + ) + pending[member_index] = { + 'future': future, + 't_submit': time.perf_counter(), + 'n_train': len(boot_data), + 'n_atoms_train': sum(len(a) for a in boot_data), + } + + for member_index, meta in pending.items(): + yield _collect_member_result(meta, member_index, batch_size, replay_label, out_dir) + + +def _collect_member_result(meta: dict, member_index: int, batch_size: int, replay_label: str, + out_dir: Path) -> dict: + tag = f'batch_size={batch_size} replay_batch_size={replay_label} member={member_index}' + status, log = 'ok', None + try: + _, log = meta['future'].result() + except Exception as e: + if not _is_oom(e): + raise + status = 'oom' + print(f'{tag}: OOM, recording partial result and continuing (other members unaffected)') + wall_s = time.perf_counter() - meta['t_submit'] if log is not None and len(log): + epoch_path = out_dir / f'bs{batch_size}_replay{replay_label}_member{member_index}_epochs.csv' + log.to_csv(epoch_path, index=False) epochs_run = int(log['epoch'].max()) + 1 last_epoch = log[log['epoch'] == log['epoch'].max()] valid_col = 'total_loss_valid' if 'total_loss_valid' in log.columns else None final_valid_loss = float(last_epoch[valid_col].mean()) if valid_col else '' else: epochs_run, final_valid_loss = 0, '' - if epoch_rows: - epochs_run = len(epoch_rows) - final_valid_loss = epoch_rows[-1].get('total_loss_valid', '') - result = { + return { 'batch_size': batch_size, 'replay_batch_size': replay_label, + 'member_index': member_index, 'status': status, 'epochs_run': epochs_run, - 'n_train': len(train_data), - 'n_atoms_train': sum(len(a) for a in train_data), + 'n_train': meta['n_train'], + 'n_atoms_train': meta['n_atoms_train'], 'wall_clock_s': round(wall_s, 2), 'sec_per_epoch': round(wall_s / epochs_run, 3) if epochs_run else '', - 'peak_gpu_mb': round(peak_mb, 1), 'final_valid_loss': final_valid_loss, } - for col in PHASE_MEMORY_FIELDS: - values = [float(r[col]) for r in epoch_rows if r.get(col)] - if values: - result[col] = round(max(values), 1) - - return result - def main() -> None: args = parse_args() @@ -248,16 +298,33 @@ def main() -> None: learner = MACEInterface() init_weights = learner.serialize_model(learner.get_model(mace_mp(args.base_model).models[0])) + init_ensemble_weights = [init_weights] * args.n_ensemble replay_variants = _build_replay_variants(args) batch_sizes = [int(b) for b in args.batch_sizes.split(',')] completed = _read_completed_combos(summary_path) - is_cuda = torch.cuda.is_available() and 'cuda' in args.device - print(f'Sweeping {len(batch_sizes)} batch_size x {len(replay_variants)} replay_batch_size = ' - f'{len(batch_sizes) * len(replay_variants)} combinations') + max_workers = args.max_workers or args.n_ensemble + + n_total = len(batch_sizes) * len(replay_variants) * args.n_ensemble + print(f'Sweeping {len(batch_sizes)} batch_size x {len(replay_variants)} replay_batch_size x ' + f'{args.n_ensemble} ensemble members = {n_total} training tasks ({max_workers} concurrent)') + + config = Config( + executors=[ + HighThroughputExecutor( + label='htex_local', + max_workers_per_node=max_workers, + provider=LocalProvider( + init_blocks=1, + max_blocks=1, + ), + ) + ], + usage_tracking=LEVEL_1, + ) write_header = not summary_path.exists() - with open(summary_path, 'a', newline='') as sf: + with ParslPoolExecutor(config=config) as pool, open(summary_path, 'a', newline='') as sf: summary_writer = csv.DictWriter(sf, fieldnames=SUMMARY_FIELDS) if write_header: summary_writer.writeheader() @@ -265,24 +332,29 @@ def main() -> None: for batch_size in batch_sizes: for replay, replay_label in replay_variants: - combo_key = (batch_size, replay_label) - if combo_key in completed: - print(f'batch_size={batch_size} replay_batch_size={replay_label}: already in {summary_path}, skipping') + completed_members = { + m for (bs, rl, m) in completed if bs == batch_size and rl == replay_label + } + if len(completed_members) == args.n_ensemble: + print(f'batch_size={batch_size} replay_batch_size={replay_label}: all ' + f'{args.n_ensemble} members already in {summary_path}, skipping') continue - print(f'batch_size={batch_size} replay_batch_size={replay_label}: starting') - epoch_path = out_dir / f'bs{batch_size}_replay{replay_label}_epochs.csv' - result = _run_candidate( - learner, init_weights, train_data, valid_data, batch_size, args, - epoch_path, is_cuda, replay, replay_label, + print(f'batch_size={batch_size} replay_batch_size={replay_label}: starting ' + f'({args.n_ensemble - len(completed_members)} of {args.n_ensemble} members)') + results = _run_ensemble_candidate( + pool, learner, init_ensemble_weights, train_data, valid_data, batch_size, + replay, replay_label, args, out_dir, completed_members, ) - summary_writer.writerow(result) - sf.flush() - print( - f"batch_size={batch_size} replay_batch_size={replay_label}: status={result['status']} " - f"epochs_run={result['epochs_run']} wall_s={result['wall_clock_s']} peak_gpu_mb={result['peak_gpu_mb']}" - ) + for result in results: + summary_writer.writerow(result) + sf.flush() + print( + f"batch_size={batch_size} replay_batch_size={replay_label} " + f"member={result['member_index']}: status={result['status']} " + f"epochs_run={result['epochs_run']} wall_s={result['wall_clock_s']}" + ) print(f'Done. Summary at {summary_path}') From c64f6d651cef76a77fcff043ead1cd90f993f0c3 Mon Sep 17 00:00:00 2001 From: Michael Tynes Date: Tue, 25 Aug 2026 16:45:19 -0500 Subject: [PATCH 15/25] Persist NPT/MTKNPT barostat/thermostat state across chunk boundaries (#91) * Persist NPT/MTKNPT barostat/thermostat state across chunk boundaries Every chunk of a trajectory ran as a separate executor task, and advance_dynamics constructed a brand-new ASE NPT/MTKNPT integrator each time. ASE zeroes the barostat/thermostat extended-system state (cell/barostat momenta, Nose-Hoover chain variables, or eta/zeta for classic NPT) unconditionally in __init__, and cascade never persisted or restored it, so the barostat/thermostat effectively restarted from rest at every chunk boundary even though atomic positions/momenta/cell carried over correctly. This produced a visible discontinuity in atomic motion rate at each chunk seam (e.g. every 1000 steps), independent of any model-version change. DynamicsRunner now carries the integrator's extended-system state across chunks (mirroring how self.atoms already carries over, including only advancing on a passed audit so a retried attempt reuses the same starting state), threaded through AdvanceSpec -> advance_dynamics -> back to the runner via new extract_dyn_state/restore_dyn_state helpers in traj_config.py. * Update task.py * Consolidate per-integrator dispatch in traj_config.py into a registry get_dynamics_cls, resolve_dyn_kws, prepare_atoms_for_dynamics, and the extract/restore_dyn_state pair each independently switched on which integrator (velocity-verlet/npt/mtknpt) was in play, via three different dispatch styles (if/elif on the config string, isinstance on the live ASE object). Replace all of it with one IntegratorSpec dataclass bundling a given integrator's ASE class, friendly-unit config schema, atom preprocessing, and state extract/restore, collected in a single INTEGRATORS registry. The five public functions become thin lookups against that registry; their signatures are unchanged so no call sites elsewhere need to change. * Update traj_config.py --- cascade/agents/agents.py | 5 +- cascade/agents/task.py | 10 ++- cascade/model.py | 3 + cascade/traj_config.py | 130 +++++++++++++++++++++++++++++++-------- 4 files changed, 121 insertions(+), 27 deletions(-) diff --git a/cascade/agents/agents.py b/cascade/agents/agents.py index ef6c456..8f0af7c 100644 --- a/cascade/agents/agents.py +++ b/cascade/agents/agents.py @@ -61,6 +61,7 @@ def __init__( # pull out variables that may change from config self.atoms = config.atoms.copy() + self.dyn_state: dict | None = None self.init_chunk_size = config.chunk_size self.chunk_size = config.chunk_size self.model_version = config.model_version @@ -92,6 +93,7 @@ async def run( traj_id=self.config.traj_id, chunk_id=self.chunk_ix, attempt_index=self.attempt, + dyn_state=self.dyn_state, ) self.logger.info(f"Running dynamics for traj {spec.traj_id} chunk {spec.chunk_id} attempt {spec.attempt_index} with {spec.steps} steps") @@ -142,7 +144,7 @@ async def run( wrapped_future = wrap_future(chunk_future) try: await wrapped_future - chunk_atoms = wrapped_future.result() + chunk_atoms, new_dyn_state = wrapped_future.result() except Exception as exc: reason = f"dynamics failed for chunk {spec.chunk_id} attempt {spec.attempt_index}: {exc!r}" self.logger.error(f"Traj {self.config.traj_id} {reason}") @@ -214,6 +216,7 @@ async def run( else: # audit passed but not done: use the new atoms to run a new chunk in next pass of while loop self.atoms = chunk_atoms[-1] + self.dyn_state = new_dyn_state self.chunk_ix += 1 self.attempt = 0 self.logger.info(f"Updating traj {self.config.traj_id} to chunk {self.chunk_ix} attempt {self.attempt}") diff --git a/cascade/agents/task.py b/cascade/agents/task.py index d2429f8..8c369db 100644 --- a/cascade/agents/task.py +++ b/cascade/agents/task.py @@ -12,6 +12,7 @@ from cascade.model import AuditResult, AuditStatus from cascade.utils import canonicalize +from cascade.traj_config import extract_dyn_state, restore_dyn_state from typing import TYPE_CHECKING if TYPE_CHECKING: @@ -162,7 +163,7 @@ def advance_dynamics( uq_hook: Callable[[Atoms], tuple[dict, dict]] | None = None, uq_kws: dict[str, object] | None = None, gpu_flush_interval: int = 10, -) -> list[Atoms]: +) -> tuple[list[Atoms], dict | None]: """Advance dynamics of a chunk of a trajectory Arguments: @@ -184,6 +185,9 @@ def advance_dynamics( gpu_flush_interval: how often to release PyTorch's CUDA caching allocator back to the driver. Without this NPT dynamics will cause memory leaks through neighbor list size changes + + Returns: + (traj, integrator_state) """ uq_kws = uq_kws or {} @@ -208,6 +212,7 @@ def advance_dynamics( logger.info('Creating dynamics class') dyn = dyn_cls(atoms, **dyn_kws) + restore_dyn_state(dyn, spec.dyn_state) frames = [] @@ -241,7 +246,8 @@ def write_frame(): flush_gpu_memory() os.remove(logfile) - return frames + new_dyn_state = extract_dyn_state(dyn) + return frames, new_dyn_state def ensemble_force_deviation_uq(atoms: Atoms) -> tuple[dict[str, np.ndarray], dict[str, float]]: diff --git a/cascade/model.py b/cascade/model.py index e0d4dab..a765c10 100644 --- a/cascade/model.py +++ b/cascade/model.py @@ -62,6 +62,9 @@ class AdvanceSpec: """Attempt index for this chunk""" steps: int """How many steps to run dynamics for""" + dyn_state: dict | None = None + """Integrator extended-system state (barostat/thermostat) carried over from + the previous chunk, or None to start from rest (e.g. at chunk 0)""" class AuditStatus(Enum): diff --git a/cascade/traj_config.py b/cascade/traj_config.py index edb09d4..f5555ea 100644 --- a/cascade/traj_config.py +++ b/cascade/traj_config.py @@ -10,6 +10,7 @@ import json import pathlib from dataclasses import dataclass, field +from typing import Callable import numpy as np from ase import Atoms, units @@ -27,7 +28,7 @@ class InitialTrajConfig: temperature_K: float | None = None """If set, initialize velocities via a Maxwell-Boltzmann distribution at this temperature""" dyn_cls: str = 'velocity-verlet' - """Dynamics integrator to use (see get_dynamics_cls)""" + """Dynamics integrator to use (see INTEGRATORS)""" dt_fs: float = 1.0 """Timestep in femtoseconds""" dyn_kws: dict = field(default_factory=dict) @@ -41,17 +42,6 @@ def load_initial_configs(path: str) -> list[InitialTrajConfig]: return [InitialTrajConfig(**entry) for entry in data] -def get_dynamics_cls(cls_name: str) -> type[ase.md.md.MolecularDynamics]: - if cls_name == 'velocity-verlet': - return VelocityVerlet - elif cls_name == 'npt': - return NPT - elif cls_name == 'mtknpt': - return MTKNPT - else: - raise ValueError(f'Unknown dynamics class: {cls_name}') - - @dataclass class NPTConfig: """Friendly-unit settings for ase.md.npt.NPT, converted in to_ase_kwargs()""" @@ -99,15 +89,6 @@ def to_ase_kwargs(self) -> dict: ) -def resolve_dyn_kws(cfg: InitialTrajConfig) -> dict: - """Build the real ASE dynamics-constructor kwargs for a trajectory config""" - if cfg.dyn_cls == 'npt': - return {'timestep': cfg.dt_fs * units.fs, **NPTConfig(**cfg.dyn_kws).to_ase_kwargs()} - elif cfg.dyn_cls == 'mtknpt': - return {'timestep': cfg.dt_fs * units.fs, **MTKNPTConfig(**cfg.dyn_kws).to_ase_kwargs()} - return {'timestep': cfg.dt_fs * units.fs, **cfg.dyn_kws} - - def _upper_triangular_cell(atoms: Atoms) -> Atoms: """Rigidly rotate a structure's cell + positions so the cell matrix becomes upper triangular, preserving all lengths, angles, and volume. @@ -141,8 +122,109 @@ def _upper_triangular_cell(atoms: Atoms) -> Atoms: return atoms +def _restore_npt_state(dyn: NPT, state: dict) -> None: + """Mirrors ASE's own read_from_trajectory restore pattern (construct normally, + setattr the get_data() fields, leave `initialized` unset so the next run() call's + own initialize() bootstrap derives h_past/q_past consistently from the restored + eta/zeta).""" + for k, v in state.items(): + setattr(dyn, k, v) + + +def _extract_mtknpt_state(dyn: MTKNPT) -> dict: + return { + 'p_g': dyn._p_g.copy(), + 'thermostat_eta': dyn._thermostat._eta.copy(), + 'thermostat_p_eta': dyn._thermostat._p_eta.copy(), + 'barostat_xi': dyn._barostat._xi.copy(), + 'barostat_p_xi': dyn._barostat._p_xi.copy(), + } + + +def _restore_mtknpt_state(dyn: MTKNPT, state: dict) -> None: + dyn._p_g = state['p_g'] + dyn._thermostat._eta = state['thermostat_eta'] + dyn._thermostat._p_eta = state['thermostat_p_eta'] + dyn._barostat._xi = state['barostat_xi'] + dyn._barostat._p_xi = state['barostat_p_xi'] + + +@dataclass(frozen=True) +class IntegratorSpec: + """Allows us to pass parameters and state across exchange and through pickle""" + ase_cls: type[ase.md.md.MolecularDynamics] + config_cls: type | None = None + extract_state: Callable[[ase.md.md.MolecularDynamics], dict | None] = staticmethod(lambda dyn: None) + restore_state: Callable[[ase.md.md.MolecularDynamics, dict], None] = staticmethod(lambda dyn, state: None) + prepare_atoms: Callable[[Atoms], Atoms] = staticmethod(lambda atoms: atoms) + + def to_ase_kwargs(self, cfg: InitialTrajConfig) -> dict: + kws = {'timestep': cfg.dt_fs * units.fs} + if self.config_cls is not None: + kws.update(self.config_cls(**cfg.dyn_kws).to_ase_kwargs()) + else: + kws.update(cfg.dyn_kws) + return kws + + +# SUPPORTED INTEGRATOR REGISTRY +INTEGRATORS: dict[str, IntegratorSpec] = { + 'velocity-verlet': IntegratorSpec(ase_cls=VelocityVerlet), + 'npt': IntegratorSpec( + ase_cls=NPT, + config_cls=NPTConfig, + extract_state=NPT.get_data, + restore_state=_restore_npt_state, + prepare_atoms=_upper_triangular_cell, + ), + 'mtknpt': IntegratorSpec( + ase_cls=MTKNPT, + config_cls=MTKNPTConfig, + extract_state=_extract_mtknpt_state, + restore_state=_restore_mtknpt_state, + ), +} + + +def _lookup(cls_name: str) -> IntegratorSpec: + try: + return INTEGRATORS[cls_name] + except KeyError: + raise ValueError( + f'Unknown dynamics class: {cls_name!r}. Supported: {sorted(INTEGRATORS)}' + ) from None + + +def get_dynamics_cls(cls_name: str) -> type[ase.md.md.MolecularDynamics]: + return _lookup(cls_name).ase_cls + + +def resolve_dyn_kws(cfg: InitialTrajConfig) -> dict: + """Build the real ASE dynamics-constructor kwargs for a trajectory config""" + return _lookup(cfg.dyn_cls).to_ase_kwargs(cfg) + + def prepare_atoms_for_dynamics(atoms: Atoms, cfg: InitialTrajConfig) -> Atoms: """Apply any structure preprocessing a trajectory's dynamics integrator requires""" - if cfg.dyn_cls == 'npt': - atoms = _upper_triangular_cell(atoms) - return atoms + return _lookup(cfg.dyn_cls).prepare_atoms(atoms) + + +def extract_dyn_state(dyn: ase.md.md.MolecularDynamics) -> dict | None: + """Snapshot the extended-system (barostat/thermostat) state of an NPT-family + integrator so it can be restored on the next chunk. Returns None for dynamics + classes with no such state (e.g. VelocityVerlet).""" + for spec in INTEGRATORS.values(): + if isinstance(dyn, spec.ase_cls): + return spec.extract_state(dyn) + return None + + +def restore_dyn_state(dyn: ase.md.md.MolecularDynamics, state: dict | None) -> None: + """Inverse of extract_dyn_state: re-inject a prior chunk's extended-system + state into a freshly constructed integrator, in place.""" + if state is None: + return + for spec in INTEGRATORS.values(): + if isinstance(dyn, spec.ase_cls): + spec.restore_state(dyn, state) + return From af2d3e0db58719faddec958a4d7f436dba4dd673 Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:15:54 +0000 Subject: [PATCH 16/25] add early stopping, audit reason --- cascade/agents/agents.py | 44 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/cascade/agents/agents.py b/cascade/agents/agents.py index 8f0af7c..2d7016c 100644 --- a/cascade/agents/agents.py +++ b/cascade/agents/agents.py @@ -113,6 +113,9 @@ async def run( attempt_index=spec.attempt_index, event_type=ChunkEventType.STARTED_DYNAMICS, ) + early_stop_threshold = None + if self.config.early_stop_enabled: + early_stop_threshold = await self.auditor.get_threshold(spec.traj_id) # submit dynamics for evaluation chunk_future = self.config.executor.submit( self.config.advance_dynamics_task, @@ -127,6 +130,9 @@ async def run( uq_hook=self.config.uq_hook, uq_kws=self.config.uq_kws, gpu_flush_interval=self.config.gpu_flush_interval, + early_stop_threshold=early_stop_threshold, + uq_field=self.config.uq_field, + catch_crashes=self.config.catch_crashes, ) #todo mt.2026.04.27 does this still need to be logged? @@ -153,6 +159,19 @@ async def run( self.agent_shutdown() continue + # chunk_atoms includes one leading frame duplicating the previous chunk's + # endpoint (see the self.timestep update below) -- n_frames counts real + # new steps, matching the pre-dynamics placeholder call above. + self._traj_db.add_chunk_attempt( + run_id=self.config.run_id, + traj_id=spec.traj_id, + chunk_id=spec.chunk_id, + model_version=self.model_version, + n_frames=len(chunk_atoms) - 1, + audit_status=AuditStatus.PENDING, + attempt_index=self.attempt, + ) + # write atoms # todo wrap this up frame_ids = [] for frame_index, _atoms in enumerate(chunk_atoms): @@ -174,6 +193,19 @@ async def run( attempt_index=spec.attempt_index, event_type=ChunkEventType.FINISHED_DYNAMICS, ) + if len(chunk_atoms) - 1 < spec.steps: + self.logger.warning( + f"Traj {self.config.traj_id} chunk {spec.chunk_id} attempt " + f"{spec.attempt_index} stopped early after {len(chunk_atoms) - 1}/{spec.steps} steps" + ) + self._traj_db.record_chunk_event( + run_id=self.config.run_id, + traj_id=spec.traj_id, + chunk_id=spec.chunk_id, + attempt_index=spec.attempt_index, + event_type=ChunkEventType.DYNAMICS_DIVERGED, + frame_id=frame_ids[-1], + ) # submit to auditor chunk = Chunk( @@ -205,7 +237,11 @@ async def run( if audit_result.status == AuditStatus.PASSED: self.logger.info(f"Audit status passed for traj {self.config.traj_id} chunk {self.chunk_ix} attempt {self.attempt}") - self.timestep += self.chunk_size + # chunk_atoms includes one leading frame duplicating the previous + # chunk's endpoint (ASE calls observers once before the first step of + # a freshly-constructed Dynamics object) -- len(chunk_atoms) - 1 is + # always the real number of new steps integrated. + self.timestep += len(chunk_atoms) - 1 self.logger.info(f"On timestep {self.timestep} of {self.config.n_steps}") self.done = self.timestep >= self.config.n_steps if self.done: @@ -281,6 +317,10 @@ async def receive_threshold(self, threshold: float, traj_id: int | None = None) self.thresholds[traj_id] = threshold self.logger.info(f"Received new audit threshold {threshold} for traj {traj_id}") + @action + async def get_threshold(self, traj_id: int | None = None) -> float | None: + return self.thresholds.get(traj_id, self.default_threshold) + @action async def audit(self, chunk: Chunk) -> AuditResult: """Submit a chunk for audit""" @@ -526,7 +566,7 @@ def _record_labeling_finished(self, frame: TrainingFrame) -> None: f"chunk={frame.chunk_id}, attempt={frame.attempt_index};" f"labled from chunk={labeled_count}, sampled from chunk:{frame.n_sampled_frames}" ) - if labeled_count == frame.n_sampled_frames-1: # recall the chunk stores an initial frame which wont get labeled + if labeled_count == frame.n_sampled_frames: # n_sampled_frames is already the real dispatched-batch size self._traj_db.record_chunk_event(**chunk_kws, event_type=ChunkEventType.FINISHED_LABELING) self.logger.info( f"Added training frame to database: traj={frame.traj_id}, " From 0bceb87a4b85cc55736ee90f44c4ffd84be81114 Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:16:21 +0000 Subject: [PATCH 17/25] early stopping in config --- cascade/agents/config.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/cascade/agents/config.py b/cascade/agents/config.py index 0554712..8a5877a 100644 --- a/cascade/agents/config.py +++ b/cascade/agents/config.py @@ -77,6 +77,18 @@ class DynamicsRunnerConfig(CascadeAgentConfig): max_audit_retries: int | None = None """Max consecutive audit failures a single chunk may accumulate before the trajectory is marked FAILED. None (default) means retry indefinitely""" + uq_field: str = 'uq_force_std_max' + """atoms.info key checked against the early-stop threshold each step""" + early_stop_enabled: bool = False + """If True, pull the Auditor's current threshold for this trajectory before each + chunk and stop dynamics the first step whose atoms.info[uq_field] crosses it, + instead of always running the full chunk_size steps""" + catch_crashes: bool = True + """If True (default), advance_dynamics also catches a hard crash (e.g. LinAlgError + from the NPT barostat) and treats it like a controlled early stop. If False, only + the UQ-threshold stop is caught; a hard crash fails the trajectory as before this + feature existed -- set False to test whether early_stop_enabled alone prevents a + crash, without this safety net masking the result.""" @dataclass From bd098c3b2d4acd9dd42d7ba6d1906c6d3d702fe6 Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:18:27 +0000 Subject: [PATCH 18/25] audit reason --- cascade/agents/db_orm.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/cascade/agents/db_orm.py b/cascade/agents/db_orm.py index a6233ed..b31f991 100644 --- a/cascade/agents/db_orm.py +++ b/cascade/agents/db_orm.py @@ -2080,6 +2080,8 @@ def list_trajectory_attempts(self, run_id: str, traj_id: int) -> list[dict]: - attempt_index: Attempt number for this chunk - n_frames: Number of frames in this attempt - audit_status: Audit status (PENDING, PASSED, or FAILED) + - audit_reason: Which mechanism produced audit_status (e.g. 'threshold', + 'burn_in', 'random_fail'); None while PENDING - model_version: Model version used for this attempt - created_at: When this attempt was created - updated_at: When this attempt was last updated @@ -2116,6 +2118,7 @@ def list_trajectory_attempts(self, run_id: str, traj_id: int) -> list[dict]: 'attempt_index': attempt.attempt_index, 'n_frames': attempt.n_frames, 'audit_status': status_str, + 'audit_reason': attempt.audit_reason, 'model_version': attempt.model_version, 'created_at': attempt.created_at, 'updated_at': attempt.updated_at From bca9ef362c85f4e5f8a24abca2c661023ebd7001 Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:19:03 +0000 Subject: [PATCH 19/25] add early stopping to task --- cascade/agents/task.py | 53 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/cascade/agents/task.py b/cascade/agents/task.py index 8c369db..d42ceb0 100644 --- a/cascade/agents/task.py +++ b/cascade/agents/task.py @@ -10,10 +10,12 @@ from mace.calculators import mace_mp import torch -from cascade.model import AuditResult, AuditStatus +from cascade.model import AuditResult, AuditStatus, TrajectoryDiverged from cascade.utils import canonicalize from cascade.traj_config import extract_dyn_state, restore_dyn_state +_module_logger = logging.getLogger(__name__) + from typing import TYPE_CHECKING if TYPE_CHECKING: from typing import Callable @@ -117,12 +119,17 @@ def boundary_uq_sample( field: str = 'uq_force_std_max', **kwargs ) -> list[TrainingFrame]: - """Frames clustered around the first frame that crossed threshold""" + """Frames leading up to and including the first frame that crossed threshold. + + Never selects frames after the crossing -- anything past the point divergence + started is likely nonsense and not useful training data. + """ values = np.array([a.info[field] for a in chunk.atoms]) crossings = np.flatnonzero(values >= threshold) n_sample = min(n_frames, len(chunk.atoms)) crossing_idx = int(crossings[0]) - indices = sorted(range(len(chunk.atoms)), key=lambda i: abs(i - crossing_idx))[:n_sample] + start = max(0, crossing_idx - n_sample + 1) + indices = list(range(start, crossing_idx + 1)) return _frames_from_indices(chunk, indices, n_sample) @@ -163,6 +170,9 @@ def advance_dynamics( uq_hook: Callable[[Atoms], tuple[dict, dict]] | None = None, uq_kws: dict[str, object] | None = None, gpu_flush_interval: int = 10, + early_stop_threshold: float | None = None, + uq_field: str = 'uq_force_std_max', + catch_crashes: bool = True, ) -> tuple[list[Atoms], dict | None]: """Advance dynamics of a chunk of a trajectory @@ -185,6 +195,16 @@ def advance_dynamics( gpu_flush_interval: how often to release PyTorch's CUDA caching allocator back to the driver. Without this NPT dynamics will cause memory leaks through neighbor list size changes + early_stop_threshold: if set, stop dynamics the first step whose + atoms.info[uq_field] >= this value, returning the frames captured so far + instead of running the full spec.steps. None disables early stopping. + uq_field: atoms.info key checked against early_stop_threshold each step + catch_crashes: if True (default), a hard crash (e.g. LinAlgError from the NPT + barostat) is also caught and treated like a controlled early stop. If + False, only a TrajectoryDiverged (UQ-threshold) stop is caught; a hard + crash propagates and fails the trajectory, same as before this feature + existed. Set False to test whether early_stop_threshold alone is + sufficient to prevent a crash, without the safety net masking it. Returns: (traj, integrator_state) @@ -238,11 +258,36 @@ def write_frame(): logger.info('writing frame to db') frames.append(canonical_atoms) + if early_stop_threshold is not None and uq_field in atoms.info: + uq_value = atoms.info[uq_field] + if uq_value >= early_stop_threshold: + logger.warning( + f'{uq_field}={uq_value:.4g} >= early-stop threshold ' + f'{early_stop_threshold:.4g} at frame {len(frames) - 1}; stopping chunk early' + ) + raise TrajectoryDiverged(f'{uq_field}={uq_value:.4g} >= threshold {early_stop_threshold:.4g}') + dyn.attach(write_frame) dyn.attach(flush_gpu_memory, interval=gpu_flush_interval) logger.info('Starting dynamics') - dyn.run(spec.steps, **run_kws) + try: + dyn.run(spec.steps, **run_kws) + except TrajectoryDiverged as exc: + # A controlled early stop: always caught. Returning the partial frames lets + # DynamicsRunner treat this as a short chunk through the normal pipeline + # instead of failing the whole trajectory. + msg = f'traj {spec.traj_id} chunk {spec.chunk_id} attempt {spec.attempt_index}: dynamics stopped early (TrajectoryDiverged): {exc}' + logger.warning(msg) + _module_logger.warning(msg) # per-attempt logfile below is deleted; this one isn't + except Exception as exc: + if not catch_crashes: + raise + # Hard crash (e.g. LinAlgError from the NPT barostat), caught only because + # catch_crashes=True -- treated the same as a controlled early stop. + msg = f'traj {spec.traj_id} chunk {spec.chunk_id} attempt {spec.attempt_index}: dynamics stopped early ({type(exc).__name__}): {exc}' + logger.warning(msg) + _module_logger.warning(msg) flush_gpu_memory() os.remove(logfile) From 423ec51a989280959017c4f948a45299aa80f9fb Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:19:55 +0000 Subject: [PATCH 20/25] early stopping, crash handling --- 3_cascade/run_cascade_academy.py | 59 ++++++++++++++++++++++++++++++-- 3_cascade/run_cascade_academy.sh | 5 +-- 2 files changed, 60 insertions(+), 4 deletions(-) diff --git a/3_cascade/run_cascade_academy.py b/3_cascade/run_cascade_academy.py index 99a5f5e..a3a604a 100644 --- a/3_cascade/run_cascade_academy.py +++ b/3_cascade/run_cascade_academy.py @@ -12,6 +12,7 @@ from typing import Callable import ase +import numpy as np from ase.io import read from ase.md.velocitydistribution import MaxwellBoltzmannDistribution @@ -105,6 +106,14 @@ def parse_args() -> argparse.Namespace: default=10, help='How often to release the CUDA caching allocator during dynamics' ) + parser.add_argument( + '--seed', + type=int, + default=None, + help='Seed numpy\'s global RNG before drawing each trajectory\'s initial ' + 'MaxwellBoltzmannDistribution velocities, for reproducible runs. ' + 'Unset (default) leaves velocities unseeded.' + ) parser.add_argument( '--target-length', type=int, @@ -188,6 +197,25 @@ def parse_args() -> argparse.Namespace: 'Only used with --audit-task uq_threshold; if unset, the threshold stays fixed ' 'at --audit-threshold for the whole run.' ) + parser.add_argument( + '--early-stop-on-uq-spike', + type=int, + default=1, + help='Stop a chunk\'s dynamics mid-integration the instant its UQ score crosses ' + 'the audit threshold, instead of always running the full --chunk-size steps. ' + 'Only meaningful with --audit-task uq_threshold. The resulting short chunk ' + 'still goes through the normal audit/sample/label/retrain/retry pipeline.' + ) + parser.add_argument( + '--catch-dynamics-crashes', + type=int, + default=1, + help='If 1 (default), a hard crash during dynamics (e.g. LinAlgError from the ' + 'NPT barostat) is also caught and treated like a controlled early stop. ' + 'If 0, only --early-stop-on-uq-spike stops are caught; a hard crash fails ' + 'the trajectory as before this feature existed -- set 0 to test whether ' + 'the UQ-based stop alone is enough to prevent a crash.' + ) parser.add_argument( '--calibration-history-length', type=int, @@ -249,6 +277,14 @@ def parse_args() -> argparse.Namespace: default='mace', help='Learner to use' ) + parser.add_argument( + '--init-weights-paths', + type=str, + default=None, + help='Comma-separated paths to pretrained checkpoints (learner.serialize_model bytes), ' + 'used as initial ensemble weights instead of a stock mace_mp("small") clone. ' + 'Supply 1 path or one per ensemble member.' + ) parser.add_argument( '--calc-type', type=str, @@ -329,6 +365,8 @@ def parse_args() -> argparse.Namespace: args = parser.parse_args() args.per_trajectory_threshold = bool(args.per_trajectory_threshold) + args.early_stop_on_uq_spike = bool(args.early_stop_on_uq_spike) + args.catch_dynamics_crashes = bool(args.catch_dynamics_crashes) return args @@ -380,8 +418,21 @@ async def main(): # read in initial model learner = get_learner(args.learner) - init_weights = learner.serialize_model(learner.get_model(mace_mp('small').models[0])) - init_ensemble_weights = [init_weights] * args.n_ensemble + if args.init_weights_paths is not None: + weight_paths = [pathlib.Path(p) for p in args.init_weights_paths.split(',')] + if len(weight_paths) == 1: + print(f'--init-weights-paths gave 1 path; cloning it for all {args.n_ensemble} ensemble members') + init_ensemble_weights = [weight_paths[0].read_bytes()] * args.n_ensemble + elif len(weight_paths) != args.n_ensemble: + raise ValueError( + f'--init-weights-paths gave {len(weight_paths)} paths but --n-ensemble={args.n_ensemble}; ' + 'supply either 1 path or one path per member' + ) + else: + init_ensemble_weights = [p.read_bytes() for p in weight_paths] + else: + init_weights = learner.serialize_model(learner.get_model(mace_mp('small').models[0])) + init_ensemble_weights = [init_weights] * args.n_ensemble # initialize database traj_db = TrajectoryDB(args.db_url) @@ -409,6 +460,8 @@ async def main(): a = prepare_atoms_for_dynamics(a, cfg) if cfg.temperature_K is not None: + if args.seed is not None: + np.random.seed(args.seed + i) MaxwellBoltzmannDistribution(a, temperature_K=cfg.temperature_K) # create trajectory entry in the database @@ -625,6 +678,8 @@ async def main(): uq_hook=ensemble_force_deviation_uq, gpu_flush_interval=args.gpu_flush_interval, max_audit_retries=args.max_audit_retries, + early_stop_enabled=(args.early_stop_on_uq_spike and args.audit_task == 'uq_threshold'), + catch_crashes=args.catch_dynamics_crashes, ) await manager.launch( DynamicsRunner, diff --git a/3_cascade/run_cascade_academy.sh b/3_cascade/run_cascade_academy.sh index f15d7da..6e5e7d1 100644 --- a/3_cascade/run_cascade_academy.sh +++ b/3_cascade/run_cascade_academy.sh @@ -11,13 +11,14 @@ source "${SLURM_SUBMIT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/env_setup.sh" python run_cascade_academy.py \ --max-workers 1 \ --init-config-json init_config_mof_crystalline_1000K.json \ - --chunk-size 1000 \ - --target-length 5000 \ + --chunk-size 200 \ + --target-length 600 \ --retrain-len 10000000000 \ --retrain-fraction 1 \ --n-sample-frames 100 \ --n-ensemble 4 \ --learner mace \ + --init-weights-paths /home/michael/repos/cascade/3_cascade/pretrained_mace_ensemble/member0_weights.pt,/home/michael/repos/cascade/3_cascade/pretrained_mace_ensemble/member1_weights.pt,/home/michael/repos/cascade/3_cascade/pretrained_mace_ensemble/member2_weights.pt,/home/michael/repos/cascade/3_cascade/pretrained_mace_ensemble/member3_weights.pt \ --audit-task uq_threshold \ --target-ferr 0.8 \ --audit-random-fail-rate 0.25 \ From d2147ddb0fca05e26e9ce3e08a152b04ef5a614e Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:23:28 +0000 Subject: [PATCH 21/25] add trajectory diverged to model --- cascade/model.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/cascade/model.py b/cascade/model.py index a765c10..93b7cdf 100644 --- a/cascade/model.py +++ b/cascade/model.py @@ -31,6 +31,13 @@ class AuditResult: reason: str | None = None """Which mechanism produced this result, e.g. 'threshold', 'burn_in', 'random_fail', 'random_accept'""" + +class TrajectoryDiverged(Exception): + """Raised from advance_dynamics's write_frame callback when a per-frame UQ score + crosses the calibrated threshold mid-chunk, or from a caught hard crash. The + triggering/last frame is already appended to `frames` before this is raised.""" + + @dataclass class TrainingFrame: atoms: Atoms @@ -85,6 +92,7 @@ class ChunkEventType(Enum): """Event types tracked for trajectory chunks""" STARTED_DYNAMICS = auto() FINISHED_DYNAMICS = auto() + DYNAMICS_DIVERGED = auto() STARTED_AUDIT = auto() AUDIT_PASSED = auto() AUDIT_FAILED = auto() From a8137677dbd63e0cf001d80d118096183bcba8ba Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:23:41 +0000 Subject: [PATCH 22/25] use REF_ keys --- cascade/learning/mace.py | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/cascade/learning/mace.py b/cascade/learning/mace.py index 50423d9..5546fd6 100644 --- a/cascade/learning/mace.py +++ b/cascade/learning/mace.py @@ -14,7 +14,7 @@ from ase.calculators.calculator import Calculator from ignite.engine import Engine, Events from mace.data import AtomicData -from mace.data.utils import config_from_atoms +from mace.data.utils import config_from_atoms, KeySpecification from mace.modules import WeightedHuberEnergyForcesStressLoss, ScaleShiftMACE from mace.tools import AtomicNumberTable from mace.tools.torch_geometric.dataloader import DataLoader @@ -30,6 +30,9 @@ MACEState = ScaleShiftMACE """Just the model, which we require being the MACE which includes scale shifting logic""" +_KEYSPEC = KeySpecification.from_defaults() +"""Key names MACE reads labels from (REF_energy/REF_forces/REF_stress)""" + def _update_offset_factors(model: ScaleShiftMACE, train_data: list[Atoms], train_loader: DataLoader, device: str): """Update the atomic energies and scale offset layers of a model @@ -42,10 +45,14 @@ def _update_offset_factors(model: ScaleShiftMACE, train_data: list[Atoms], train """ # Update the atomic energies using the data from all trajectories z_table = AtomicNumberTable(model.atomic_numbers.cpu().numpy().tolist()) - new_ae = model.atomic_energies_fn.atomic_energies.cpu().numpy() + raw_ae = model.atomic_energies_fn.atomic_energies.cpu().numpy() + has_head_dim = raw_ae.ndim == 2 # newer MACE models carry a size-1 head axis even when single-headed + new_ae = raw_ae[0].copy() if has_head_dim else raw_ae.copy() atomic_energies_dict = estimate_atomic_energies(train_data) for s, e in atomic_energies_dict.items(): new_ae[z_table.zs.index(data.atomic_numbers[s])] = e + if has_head_dim: + new_ae = new_ae[None, :] with torch.no_grad(): old_ae = model.atomic_energies_fn.atomic_energies model.atomic_energies_fn.atomic_energies = torch.from_numpy(new_ae).to(old_ae.dtype).to(old_ae.device) @@ -107,32 +114,32 @@ def atoms_to_loader(atoms: list[Atoms], batch_size: int, z_table: AtomicNumberTa """ def _prepare_atoms(my_atoms: Atoms): - """MACE expects the training outputs to be stored in `info` and `arrays`""" + """MACE reads training outputs from `info` and `arrays` under the keys in _KEYSPEC""" # Start with a copy of positions, which should be available always my_atoms.arrays.update({ 'positions': my_atoms.positions, }) if my_atoms.calc is None: - return my_atoms # No calc, no results + return my_atoms # No calc; labels are already under the REF_ keys, if present at all # Now make an info dictionary if one doesn't exist yet if my_atoms.info is None: my_atoms.info = {} - # Copy over all property data which exists + # Copy over all property data into REF_keys if 'energy' in my_atoms.calc.results: - my_atoms.info['energy'] = my_atoms.get_potential_energy() + my_atoms.info['REF_energy'] = my_atoms.get_potential_energy() if 'stress' in my_atoms.calc.results: - my_atoms.info['stress'] = my_atoms.get_stress() + my_atoms.info['REF_stress'] = my_atoms.get_stress() if 'forces' in my_atoms.calc.results: - my_atoms.arrays['forces'] = my_atoms.get_forces() + my_atoms.arrays['REF_forces'] = my_atoms.get_forces() return my_atoms - atoms = [config_from_atoms(_prepare_atoms(a)) for a in atoms] + atoms = [config_from_atoms(_prepare_atoms(a), key_specification=_KEYSPEC) for a in atoms] return DataLoader( [AtomicData.from_config(c, z_table=z_table, cutoff=r_max) for c in atoms], batch_size=batch_size, From 9bc99baee12e8f889261c414e4ac0ef97f1f515c Mon Sep 17 00:00:00 2001 From: miketynes Date: Mon, 31 Aug 2026 20:25:18 +0000 Subject: [PATCH 23/25] test REF_ keys --- tests/learning/test_mace.py | 62 +++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/tests/learning/test_mace.py b/tests/learning/test_mace.py index 9bcd962..f573e82 100644 --- a/tests/learning/test_mace.py +++ b/tests/learning/test_mace.py @@ -1,3 +1,4 @@ +from ase.calculators.singlepoint import SinglePointCalculator from mace.calculators import mace_mp from pytest import fixture, mark import numpy as np @@ -87,3 +88,64 @@ def test_replay(example_data, mace, epoch_frequency, num_downselect): _, log = mi.train(mace, example_data, example_data, 4, batch_size=2, patience=1, replay=replay) assert 'total_loss_replay' in log.columns assert log['total_loss_replay'].isna().sum() == (4 - 4 // epoch_frequency) # Ensure reply is skipped occasionally + + +def _labelled_frames() -> list: + """Two frames carrying distinctive, non-zero energy/forces/stress""" + from ase import Atoms + + frames = [] + for i, energy in enumerate([-11.5, -22.25]): + atoms = Atoms(symbols=['H', 'He'], positions=[[0., 0., 0.], [1.5, 0., 0.]], + cell=[6., 6., 6.], pbc=True) + forces = np.array([[0.3 + i, -0.4, 0.5], [-0.3 - i, 0.4, -0.5]]) + stress = np.array([0.11, 0.12, 0.13, 0.14, 0.15, 0.16]) * (i + 1) + atoms.calc = SinglePointCalculator(atoms, energy=energy, forces=forces, stress=stress) + frames.append(atoms) + return frames + + +def _first_batch(frames): + from cascade.learning.mace import atoms_to_loader + from mace.tools import AtomicNumberTable + + loader = atoms_to_loader(frames, batch_size=2, z_table=AtomicNumberTable([1, 2]), + r_max=4.0, shuffle=False, drop_last=False) + return next(iter(loader)).to_dict() + + +def test_atoms_to_loader_keeps_labels_from_calculator(): + """Style A: labels held by a SinglePointCalculator must reach the batch, not be zeroed""" + frames = _labelled_frames() + expected_e = [f.get_potential_energy() for f in frames] + expected_f = np.concatenate([f.get_forces() for f in frames]) + + batch = _first_batch(frames) + + assert not np.allclose(batch['energy'].numpy(), 0.), 'energies silently dropped to zero' + assert not np.allclose(batch['forces'].numpy(), 0.), 'forces silently dropped to zero' + assert not np.allclose(batch['stress'].numpy(), 0.), 'stresses silently dropped to zero' + assert np.allclose(batch['energy'].numpy(), expected_e) + assert np.allclose(batch['forces'].numpy(), expected_f) + + +def test_atoms_to_loader_keeps_labels_from_ref_keys(): + """Style B: labels already stored under MACE's REF_ keys, with no calculator attached""" + frames = [] + for f in _labelled_frames(): + bare = f.copy() + bare.info['REF_energy'] = f.get_potential_energy() + bare.info['REF_stress'] = f.get_stress() + bare.arrays['REF_forces'] = f.get_forces() + bare.calc = None + frames.append(bare) + + expected_e = [f.info['REF_energy'] for f in frames] + expected_f = np.concatenate([f.arrays['REF_forces'] for f in frames]) + + batch = _first_batch(frames) + + assert not np.allclose(batch['energy'].numpy(), 0.), 'energies silently dropped to zero' + assert not np.allclose(batch['forces'].numpy(), 0.), 'forces silently dropped to zero' + assert np.allclose(batch['energy'].numpy(), expected_e) + assert np.allclose(batch['forces'].numpy(), expected_f) From 1553f61d739463487716b6ee1ae5b934248dd215 Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 1 Sep 2026 16:48:25 +0000 Subject: [PATCH 24/25] add zero_grad, clipping, finite check to replay --- cascade/learning/mace.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/cascade/learning/mace.py b/cascade/learning/mace.py index 5546fd6..fad66be 100644 --- a/cascade/learning/mace.py +++ b/cascade/learning/mace.py @@ -398,6 +398,7 @@ def replay_process(engine: Engine): logger.info(f'Started replay for epoch {engine.state.epoch - 1}') for batch in replay_loader: + replay_opt.zero_grad() batch = batch.to(device) y = replay_model( batch.to_dict(), @@ -407,7 +408,16 @@ def replay_process(engine: Engine): compute_stress=True, ) loss = criterion(pred=y, ref=batch) + + if not torch.isfinite(loss): + logger.warning( + f'Non-finite replay loss ({loss.item()}) at epoch {engine.state.epoch - 1}; ' + 'skipping this batch\'s update' + ) + continue + loss.backward() + torch.nn.utils.clip_grad_norm_(replay_model.parameters(), max_norm=grad_clip_norm) replay_opt.step() detailed_loss = dict((f'{k}_replay', v) for k, v in get_loss_stats(batch, y).items()) From 98d3de8a276eea800e53cf2ede31e359c18112fc Mon Sep 17 00:00:00 2001 From: miketynes Date: Tue, 22 Sep 2026 18:35:05 +0000 Subject: [PATCH 25/25] save params from reference runs; save init configs --- 3_cascade/run_cascade_academy.py | 4 +++- 3_cascade/run_reference_dynamics.py | 8 ++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/3_cascade/run_cascade_academy.py b/3_cascade/run_cascade_academy.py index a3a604a..80cc7d2 100644 --- a/3_cascade/run_cascade_academy.py +++ b/3_cascade/run_cascade_academy.py @@ -412,7 +412,9 @@ async def main(): ) run_dir.mkdir(parents=True) - # Save the run parameters to disk + # Save the run parameters to disk, including the init config contents since the file may be edited later + with open(args.init_config_json) as f: + params["init_configs"] = json.load(f) (run_dir / "params.json").write_text(json.dumps(params)) logfile = run_dir / "runtime.log" diff --git a/3_cascade/run_reference_dynamics.py b/3_cascade/run_reference_dynamics.py index 5716a8e..31c38e3 100644 --- a/3_cascade/run_reference_dynamics.py +++ b/3_cascade/run_reference_dynamics.py @@ -11,6 +11,7 @@ import json import logging import os +import pathlib import warnings from concurrent.futures import as_completed @@ -225,6 +226,13 @@ def main(): init_configs = load_initial_configs(args.init_config_json) + # Save the init config contents, not just the path, since the file may be edited later + run_dir = pathlib.Path("run") / run_id + run_dir.mkdir(parents=True) + with open(args.init_config_json) as f: + params["init_configs"] = json.load(f) + (run_dir / "params.json").write_text(json.dumps(params, indent=2)) + max_workers = args.max_workers or len(init_configs) config = Config( executors=[