diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..acee5b558aa3abbebb95c3cc615157d1451d3f20 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.zst filter=lfs diff=lfs merge=lfs -text
*tfevents* filter=lfs diff=lfs merge=lfs -text
+weights/trained_model/decoder/tas/lt_1/epoch_18 filter=lfs diff=lfs merge=lfs -text
+weights/trained_model/encoder/epoch_96 filter=lfs diff=lfs merge=lfs -text
+weights/trained_model/processor/forecast_1/epoch_0 filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..c0f739e091f368b09c46154fed74bb05dfcb90a3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.pdf
+result/
+weight/*
+!weight/.gitkeep
+.pytest_cache/
+.ipynb_checkpoints/
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c6e485af03f87838348485de2b018f1fcf29035
--- /dev/null
+++ b/README.md
@@ -0,0 +1,204 @@
+---
+license: other
+language:
+- en
+- zh
+tags:
+- OneScience
+- Earth Science
+- Weather Forecasting
+- Medium-Range Weather Forecasting
+frameworks: PyTorch
+datasets:
+- OneScience/Aardvark-Weather
+---
+
+
+ Aardvark Weather
+
+
+# Model Overview
+
+Aardvark Weather is an end-to-end multimodal weather forecasting model that generates global gridded forecasts and station-level predictions through an observation encoder, a global forecast processor, and a station decoder.
+
+Paper: *End-to-end data-driven weather prediction*
+
+https://www.nature.com/articles/s41586-025-08897-0
+
+# Model Description
+
+This model package reuses the official code and weights to provide the following run pipeline:
+
+```text
+Official Multimodal Sample
+-> Encoder
+-> Day-1 Processor
+-> TAS Decoder
+-> 1-day global forecast and station 2-meter temperature
+```
+
+# Use Cases
+
+| Scenario | Description |
+| :---: | :--- |
+| Official Model Verification | Inspect official samples, configuration, and checkpoints. |
+| Global Weather Forecasting | Output a global 1.5° gridded state of 24 variables. |
+| Station Temperature Forecasting | Output 2-meter temperature at 8,719 stations. |
+
+# Usage
+
+## 1. OneCode
+
+[Click to experience intelligent one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Manual Installation & Usage
+
+**Hardware Requirements**
+
+- Inference with the official weights requires an NVIDIA GPU.
+- CPU can be used for resource and checkpoint inspection; running full inference on CPU is not recommended.
+
+### Download the Model Package
+
+```bash
+hf download --model OneScience-Group/Aardvark-Weather --local-dir ./Aardvark-Weather
+cd Aardvark-Weather
+```
+
+### Set Up the Runtime Environment
+
+**DCU Environment**
+
+```bash
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+pip install onescience[earth-dcu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+**GPU Environment**
+
+```bash
+conda create -n onescience311 python=3.11 -y libstdcxx-ng=12 libgcc-ng=12 gcc_linux-64=12 gxx_linux-64=12
+conda activate onescience311
+pip install onescience[earth-gpu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+If the environment lacks Aardvark dependencies, refer to `official-src/environment.yml` for additional installation. The current adaptation is compatible with the `Block` parameter of the newer `timm` package.
+
+### Data & Weights
+
+The model package already includes the resources required for 1-day temperature inference:
+
+```text
+weights/sample_data/sample_data_final.pkl
+weights/trained_model/encoder/epoch_96
+weights/trained_model/processor/forecast_1/epoch_0
+weights/trained_model/decoder/tas/lt_1/epoch_18
+official-src/data/grid_lon_lat/
+official-src/data/norm_factors/
+```
+
+To re-download from source:
+
+```text
+Official Code: https://github.com/anna-allen/aardvark-weather-public
+Official Weights: https://huggingface.co/datasets/av555/aardvark-weather
+```
+
+### Training
+
+The training entry point provides a complete pipeline with epochs, validation, early stopping, learning rate scheduling, best/latest checkpointing, and resumption. By default, the Encoder and Day-1 Processor are frozen and only the TAS Decoder is trained:
+
+```bash
+python scripts/train.py
+```
+
+Paper-style end-to-end joint fine-tuning:
+
+```bash
+python scripts/train.py --train-modules all --epochs 10 --train-steps 100
+```
+
+Resuming training:
+
+```bash
+python scripts/train.py --resume weight/training/last.pth
+```
+
+The default configuration resides in `conf/config.yaml`. `--data` can point to an official-schema pickle file or a directory containing multiple `.pkl` files; multiple files are partitioned into train and validation sets in a deterministic manner. `--batch-size` concatenates multiple tasks along the existing batch dimension of the official task. When only the single official sample is included, training and validation reuse the same task — this allows end-to-end validation of the training software pipeline but does not constitute an independent validation set, nor can it provide the data diversity required to reproduce paper-level accuracy.
+
+Training artifacts:
+
+```text
+weight/training/best.pth
+weight/training/last.pth
+weight/training/history.json
+weight/training/train.json
+```
+
+### Inference
+
+```bash
+python scripts/inference.py
+```
+
+Using weights obtained from training:
+
+```bash
+python scripts/inference.py --checkpoint weight/training/best.pth
+```
+
+Inference loads the official sample and the Day-1 `tas` weights by default. Results are saved to:
+
+```text
+result/inference_one_day.json
+result/prediction.pt
+result/target.pt
+```
+
+### Result Inspection
+
+```bash
+python scripts/result.py
+```
+
+Verified output shapes:
+
+```text
+initial_state: [1, 121, 240, 24]
+global_forecast: [1, 121, 240, 24]
+station_tas: [1, 8719]
+```
+
+Current results constitute a connectivity/end-to-end verification and do not reproduce the paper's RMSE/MAE metrics.
+
+The result script additionally produces `result/metrics.json` and `result/comparison.png`. The `normalized_mae` and `normalized_rmse` are computed in the normalized space of the official sample and should not be directly compared to the paper's physical-unit metrics.
+
+### Paper vs. Current Implementation I/O
+
+| Item | Paper | Current Package |
+| --- | --- | --- |
+| Input | Multimodal satellite, station, ship, and radiosonde observations | Bundled official sample pickle with a field structure consistent with the official Encoder |
+| Global State | `24 × 121 × 240`, 1.5° | Day-1 supported; output `[1,121,240,24]` |
+| Station Output | 2 m temperature and 10 m wind, up to Day-10 | Day-1 TAS only; `[1,8719]` |
+| Training | Staged pre-training followed by ~25,000 steps of end-to-end fine-tuning | Configurable full training loop; supports Decoder-only or full-model joint fine-tuning |
+| Evaluation | Grid-point weighted RMSE and station MAE in physical units | MAE/RMSE in normalized sample space |
+
+All commands should be run from the project root; `scripts/inference.py --root` converts to an absolute path. The official model internally depends on CUDA, so CPU is currently unavailable for inference. Training data must adhere to the official multimodal task dictionary schema; the current directory does not synthesize satellite or station observations — the bundled official sample serves as the default training-pipeline validator. The model package retains only official resources under `weights/` and does not carry local training artifacts under `weight/` or generated outputs under `result/`. Paper-level training still requires preparing observation data spanning the full date range and converting it into the same `.pkl` task contract.
+
+### Real Data
+
+Using real dates requires preparing ASCAT, AMSU-A/B, HIRS, IASI, GridSat, HadISD, ICOADS, IGRA, ERA5, topography, climatology, and their corresponding normalization statistics.
+
+# OneScience Official Information
+
+| Platform | OneScience Main Repository | Skills Repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citation & License
+
+- Official Code: https://github.com/anna-allen/aardvark-weather-public
+- This directory is an independent adaptation of the official Aardvark Weather model.
+- Code, weights, and data are subject to their respective official licenses and data terms.
diff --git a/conf/config.yaml b/conf/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..23e1d82de7c80328dfc9f99432b6d64eb665f00a
--- /dev/null
+++ b/conf/config.yaml
@@ -0,0 +1,14 @@
+training:
+ data: weights/sample_data/sample_data_final.pkl
+ output_dir: weight/training
+ epochs: 10
+ train_steps: 8
+ validation_steps: 2
+ validation_fraction: 0.2
+ batch_size: 1
+ learning_rate: 1.0e-5
+ weight_decay: 1.0e-6
+ gradient_clip: 1.0
+ patience: 3
+ seed: 2026
+ train_modules: decoder
diff --git a/configuration.json b/configuration.json
new file mode 100644
index 0000000000000000000000000000000000000000..766221f168ddb100df40e405ca13d51079bad666
--- /dev/null
+++ b/configuration.json
@@ -0,0 +1 @@
+{"framework":"Pytorch","task":"weather-forecasting","implementation":"official-one-day-tas-adapter"}
diff --git a/model/__init__.py b/model/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..558e54a6e19a9d1d38b2a3645e6c2551a2a5bc19
--- /dev/null
+++ b/model/__init__.py
@@ -0,0 +1 @@
+"""Aardvark-local adapters around the pinned official implementation."""
diff --git a/model/aardvark_adapter.py b/model/aardvark_adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..a60cbc1f06acc438eba797d162fa32776fffd300
--- /dev/null
+++ b/model/aardvark_adapter.py
@@ -0,0 +1,153 @@
+"""Thin, model-local wrapper for the official Aardvark Weather model."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import os
+import pickle
+import sys
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+
+TOP_LEVEL_KEYS = {"assimilation", "forecast", "downscaling", "y_target"}
+REQUIRED_ASSIMILATION_KEYS = {
+ "x_context_hadisd_current", "y_context_hadisd_current", "climatology_current",
+ "sat_x_current", "sat_current", "icoads_x_current", "icoads_current",
+ "igra_x_current", "igra_current", "amsua_current", "amsua_x_current",
+ "amsub_current", "amsub_x_current", "iasi_current", "iasi_x_current",
+ "ascat_current", "ascat_x_current", "hirs_current", "hirs_x_current",
+ "y_target_current", "era5_x_current",
+ "era5_elev_current", "era5_lonlat_current", "aux_time_current", "lt",
+ "y_target",
+}
+REQUIRED_FORECAST_KEYS = {"y_context", "y_target", "lt"}
+REQUIRED_DOWNSCALING_KEYS = {
+ "x_target", "alt_target", "y_target", "y_context", "x_context", "aux_time", "lt",
+}
+
+
+def sha256(path: Path) -> str:
+ digest = hashlib.sha256()
+ with path.open("rb") as handle:
+ for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+ digest.update(chunk)
+ return digest.hexdigest()
+
+
+def validate_sample(sample_path: Path) -> dict[str, Any]:
+ with sample_path.open("rb") as handle:
+ sample = pickle.load(handle)
+ if not isinstance(sample, dict) or set(sample) != TOP_LEVEL_KEYS:
+ raise ValueError(f"sample top-level keys mismatch: {list(sample) if isinstance(sample, dict) else type(sample)}")
+ expected = {
+ "assimilation": REQUIRED_ASSIMILATION_KEYS,
+ "forecast": REQUIRED_FORECAST_KEYS,
+ "downscaling": REQUIRED_DOWNSCALING_KEYS,
+ }
+ for name, keys in expected.items():
+ if not isinstance(sample[name], dict) or set(sample[name]) != keys:
+ raise ValueError(f"sample {name} keys mismatch: {list(sample[name])}")
+ if not isinstance(sample["y_target"], torch.Tensor) or sample["y_target"].ndim != 2:
+ raise ValueError("sample y_target must be a rank-2 torch.Tensor")
+ return {
+ "top_level_keys": sorted(sample),
+ "nested_keys": {name: sorted(value) for name, value in expected.items()},
+ "y_target_shape": list(sample["y_target"].shape),
+ "nan_counts": {
+ name: int(value.isnan().sum())
+ for name, value in sample["downscaling"].items()
+ if isinstance(value, torch.Tensor) and value.is_floating_point()
+ },
+ }
+
+
+def validate_checkpoint(path: Path) -> dict[str, Any]:
+ checkpoint = torch.load(path, map_location="cpu")
+ if not isinstance(checkpoint, dict) or "model_state_dict" not in checkpoint:
+ raise ValueError(f"checkpoint contract mismatch: {path}")
+ state = checkpoint["model_state_dict"]
+ if not isinstance(state, dict) or not state:
+ raise ValueError(f"empty model_state_dict: {path}")
+ return {"path": str(path), "key_count": len(state), "has_model_state_dict": True}
+
+
+def load_sample(sample_path: Path) -> dict[str, Any]:
+ with sample_path.open("rb") as handle:
+ return pickle.load(handle)
+
+
+def build_one_day_model(weights_root: Path, official_root: Path, device: str):
+ encoder = weights_root / "trained_model/encoder"
+ processor = weights_root / "trained_model/processor"
+ decoder = weights_root / "trained_model/decoder/tas"
+ sys.path.insert(0, str(official_root / "aardvark"))
+ _install_timm_compatibility()
+ official_e2e = importlib.import_module("e2e_model")
+ caller_dir = Path.cwd()
+ try:
+ os.chdir(official_root / "aardvark")
+ model = official_e2e.ConvCNPWeatherE2E(
+ device=device,
+ lead_time=1,
+ se_model_path=str(encoder),
+ forecast_model_path=str(processor),
+ sf_model_path=str(decoder) + "/",
+ return_gridded=True,
+ aux_data_path=str(official_root / "data") + "/",
+ )
+ finally:
+ os.chdir(caller_dir)
+ return model
+
+
+def run_one_day(sample_path: Path, weights_root: Path, official_root: Path, device: str) -> dict[str, Any]:
+ sample_report = validate_sample(sample_path)
+ encoder = weights_root / "trained_model/encoder"
+ processor = weights_root / "trained_model/processor"
+ decoder = weights_root / "trained_model/decoder/tas"
+ checkpoint_report = [
+ validate_checkpoint(encoder / "epoch_96"),
+ validate_checkpoint(processor / "forecast_1/epoch_0"),
+ validate_checkpoint(decoder / "lt_1/epoch_18"),
+ ]
+ sample = load_sample(sample_path)
+ model = build_one_day_model(weights_root, official_root, device)
+ model.eval()
+ with torch.inference_mode():
+ station, global_forecast, initial_state = model(sample)
+ for name, tensor in (("station_tas", station), ("global_forecast", global_forecast), ("initial_state", initial_state)):
+ if not isinstance(tensor, torch.Tensor) or not bool(torch.isfinite(tensor).all()):
+ raise ValueError(f"{name} contains non-finite values")
+ return {
+ "sample": sample_report,
+ "checkpoints": checkpoint_report,
+ "device": device,
+ "lead_time_days": 1,
+ "station_tas_shape": list(station.shape),
+ "global_forecast_shape": list(global_forecast.shape),
+ "initial_state_shape": list(initial_state.shape),
+ "finite_outputs": True,
+ }
+
+
+def _install_timm_compatibility() -> None:
+ """Bridge the old timm 0.6 Block constructor used by the official code."""
+ import timm.models.vision_transformer as vision_transformer
+
+ original = vision_transformer.Block
+ if getattr(original, "_aardvark_compat", False):
+ return
+
+ class AardvarkBlock(original):
+ _aardvark_compat = True
+
+ def __init__(self, *args: Any, drop: float = 0.0, **kwargs: Any) -> None:
+ kwargs.setdefault("proj_drop", drop)
+ super().__init__(*args, **kwargs)
+
+ vision_transformer.Block = AardvarkBlock
diff --git a/model/sample_dataset.py b/model/sample_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..21a311226531931cd1f2cb2972f7005b97749292
--- /dev/null
+++ b/model/sample_dataset.py
@@ -0,0 +1,76 @@
+"""Datasets for training Aardvark from official-schema pickle tasks."""
+
+from __future__ import annotations
+
+import copy
+import pickle
+import random
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+from .aardvark_adapter import validate_sample
+
+
+def discover_samples(path: Path) -> list[Path]:
+ path = path.resolve()
+ samples = sorted(path.glob("*.pkl")) if path.is_dir() else [path]
+ if not samples or any(not sample.is_file() for sample in samples):
+ raise FileNotFoundError(f"No Aardvark sample pickle found at {path}")
+ for sample in samples:
+ validate_sample(sample)
+ return samples
+
+
+def split_samples(samples: list[Path], validation_fraction: float, seed: int) -> tuple[list[Path], list[Path]]:
+ if not 0.0 < validation_fraction < 1.0:
+ raise ValueError("validation_fraction must be between 0 and 1")
+ if len(samples) == 1:
+ return samples, samples
+ shuffled = samples.copy()
+ random.Random(seed).shuffle(shuffled)
+ validation_count = max(1, round(len(shuffled) * validation_fraction))
+ validation_count = min(validation_count, len(shuffled) - 1)
+ return shuffled[validation_count:], shuffled[:validation_count]
+
+
+class AardvarkTaskDataset(Dataset):
+ """Repeat one or more already-batched official tasks for a fixed number of steps."""
+
+ def __init__(self, samples: list[Path], steps: int) -> None:
+ if steps < 1:
+ raise ValueError("steps must be at least 1")
+ self.tasks = [self._load(path) for path in samples]
+ self.steps = steps
+
+ @staticmethod
+ def _load(path: Path) -> dict[str, Any]:
+ with path.open("rb") as handle:
+ return pickle.load(handle)
+
+ def __len__(self) -> int:
+ return self.steps
+
+ def __getitem__(self, index: int) -> dict[str, Any]:
+ return copy.deepcopy(self.tasks[index % len(self.tasks)])
+
+
+def collate_tasks(items: list[Any]) -> Any:
+ """Concatenate the batch dimension already present in official task tensors."""
+ first = items[0]
+ if isinstance(first, torch.Tensor):
+ return torch.cat(items, dim=0)
+ if isinstance(first, np.ndarray):
+ return np.concatenate(items, axis=0)
+ if isinstance(first, dict):
+ return {key: collate_tasks([item[key] for item in items]) for key in first}
+ if isinstance(first, tuple):
+ return tuple(collate_tasks(list(values)) for values in zip(*items))
+ if isinstance(first, list):
+ return [collate_tasks(list(values)) for values in zip(*items)]
+ if all(item == first for item in items):
+ return first
+ raise TypeError(f"Cannot collate Aardvark values of type {type(first).__name__}")
diff --git a/official-src/LICENSE b/official-src/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0e259d42c996742e9e3cba14c677129b2c1b6311
--- /dev/null
+++ b/official-src/LICENSE
@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+ CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+ LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+ ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+ INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+ REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+ PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+ THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+ HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+ i. the right to reproduce, adapt, distribute, perform, display,
+ communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+ likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+ subject to the limitations in paragraph 4(a), below;
+ v. rights protecting the extraction, dissemination, use and reuse of data
+ in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+ European Parliament and of the Council of 11 March 1996 on the legal
+ protection of databases, and under any national implementation
+ thereof, including any amended or successor version of such
+ directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+ world based on applicable law or treaty, and any national
+ implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+ surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+ warranties of any kind concerning the Work, express, implied,
+ statutory or otherwise, including without limitation warranties of
+ title, merchantability, fitness for a particular purpose, non
+ infringement, or the absence of latent or other defects, accuracy, or
+ the present or absence of errors, whether or not discoverable, all to
+ the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+ that may apply to the Work or any use thereof, including without
+ limitation any person's Copyright and Related Rights in the Work.
+ Further, Affirmer disclaims responsibility for obtaining any necessary
+ consents, permissions or other rights required for any use of the
+ Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+ party to this document and has no duty or obligation with respect to
+ this CC0 or use of the Work.
diff --git a/official-src/README.md b/official-src/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..48fe70b42ba1f92f57a2b319b4453d37937cc7c3
--- /dev/null
+++ b/official-src/README.md
@@ -0,0 +1,71 @@
+# Aardvark Weather
+
+This repo contains code and weights used to run the Aardvark Weather model (https://www.nature.com/articles/s41586-025-08897-0). We provide sample data, model weights and code to demonstrate how the trained model is run to produce forecasts.
+
+## Model weights
+Weights for the trained model presented in the paper are provided at `https://huggingface.co/datasets/av555/aardvark-weather/tree/main/trained_model`.
+Within this folder there are weights for the encoder, decoder and processor and end to end finetuned weights for one day lead time.
+For the decoder and end-to-end, we provide weights for both temperature and wind speed.
+
+## Data
+Sample data is provided in `data/sample_data_final.pkl`. In addition we provide normalisation factors used to generate plots of predictions. For a visualisation of what is included in each timeslice of data passed to the model, see notebooks/data_demo.ipynb. For those interested in training their own end-to-end models, we have additionally prepared a machine learning ready dataset for the data sources utilised in the paper available at https://huggingface.co/datasets/av555/aardvark-weather.
+
+## Forecast notebooks
+Notebooks demonstrating producing a forecast using the trained models are included in the `notebooks/` folder.
+Aardvark produces multiple modalities of forecasts.
+The notebook `forecast_demo.ipynb` demonstrates loading the complete Aardvark Weather model, generating predictions from the sample data and provides visualisations of the output global gridded and station forecasts.
+The notebook `e2e_finetune_demo.ipynb` provides a demonstration of generating optimised station forecasts from the sample data using the end to end finetuned model.
+
+## Training
+Aardvark weather is trained in multiple stages.
+Scripts to train the model are included in `training/`.
+Training of the three main modules is handled in `train_module.py`, processor finetuning in `finetune.py` and end-to-end finetuning in `e2e_train.py`.
+
+__Please note:__ the commands and related scripts under the "Encoder," "Processor," and "Decoder" sections below cannot be executed as they depend on local data loading pipelines, setup for the specific training compute infrastructure. The purpose of these training and finetuning commands is to illustrate the salient points of the training process for the purposes of transperancy and for those interested in the details of the training process and not to provide an executable version.
+
+### Encoder
+To train the encoder, run
+```
+bash train_encoder.sh
+```
+
+### Processor
+To pre-train the processor, we use the code in
+```
+bash train_processor.sh
+```
+
+To finetune the processor, we use the code in
+```
+bash finetune.sh
+```
+
+### Decoder
+To train the decoder, we use the code in
+```
+bash train_decoder.sh
+```
+
+### End-to-end
+To tune the model end-to-end, we use the code in
+```
+bash train_e2e.sh
+```
+## FAQ
+
+#### Can I access the data the model was trained on?
+We provide a dataset with observational data from 2007-2019 at 24 hour resolution at https://huggingface.co/datasets/av555/aardvark-weather. We hope that this will allow others to develop their own end-to-end weather models and explore the vast design space of ML architectures for this task.
+
+#### Can I run the model in real time?
+Unfortunately the datasets used in this initial prototype are not available in real time. We are however in the process of building a fully operational system, Aardvark 2.0. Updates to this will be provided here.
+
+#### This model is at lower resolution than other AI models. Do you have any plans to improve on this?
+We are currently working on a new version of our model which runs at 0.25 degrees for a wider range of pressure levels.
+
+#### Will further versions of the model and dataset be provided?
+
+Yes, this project is ongoing and we aim to continue updating this dataset and model. Updates currently in progress include the development of a fully operational system with real time data feed, extension of current historical dataset to 2025 and inclusion of further instruments. If you would like to receive updates as new products become available please email av555@cam.ac.uk with subject line 'Aardvark updates'.
+
+#### Can this dataset be used commercially?
+
+The dataset is released under a non-commercial no-derivatives license. This is due to the lisencing inherited from the source datasets.
diff --git a/official-src/aardvark/architectures.py b/official-src/aardvark/architectures.py
new file mode 100644
index 0000000000000000000000000000000000000000..64d4f37f41b2c55af38932ee03cf6213460ac579
--- /dev/null
+++ b/official-src/aardvark/architectures.py
@@ -0,0 +1,37 @@
+import torch
+import torch.nn as nn
+
+from utils import *
+
+
+class MLP(nn.Module):
+ """
+ Multi-layer perceptron
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ h_channels=64,
+ h_layers=4,
+ ):
+
+ super().__init__()
+
+ def hidden_block(h_channels):
+ h = nn.Sequential(
+ nn.Linear(h_channels, h_channels),
+ nn.ReLU(),
+ )
+ return h
+
+ self.mlp = nn.Sequential(
+ nn.Linear(in_channels, h_channels),
+ nn.ReLU(),
+ *[hidden_block(h_channels) for _ in range(h_layers)],
+ nn.Linear(h_channels, out_channels)
+ )
+
+ def forward(self, x):
+ return self.mlp(x)
diff --git a/official-src/aardvark/data_shapes.py b/official-src/aardvark/data_shapes.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cb6015379136dc94ed411488e915689529ff49e
--- /dev/null
+++ b/official-src/aardvark/data_shapes.py
@@ -0,0 +1,31 @@
+"""
+Data is stored in memmaps for access speed. Here we give the shapes required to load these files
+"""
+
+CLIMATOLOGY_SHAPE = (4, 366, 24, 240, 121)
+
+ICOADS_Y_SHAPE = (33601, 5, 12000)
+ICOADS_X_SHAPE = (33601, 2, 12000)
+
+IGRA_Y_SHAPE = (33604, 24, 1375)
+IGRA_X_SHAPE = (1375, 2)
+
+AMSUA_Y_SHAPE = (21916, 180, 360, 13)
+AMSUB_Y_SHAPE = (21916, 360, 181, 12)
+ASCAT_Y_SHAPE = (21913, 360, 181, 17)
+HIRS_Y_SHAPE = (21913, 360, 181, 26)
+GRIDSAT_Y_SHAPE = (48211, 2, 514, 200)
+IASI_Y_SHAPE = (23373, 360, 181, 52)
+
+
+def get_hadisd_shape(mode):
+ """
+ Return the shape of the HadISD array depending on variable
+ """
+
+ if mode != "train":
+ dim_1 = 415
+ else:
+ var_dict = {"tas": 8719, "tds": 8617, "psl": 8016, "u": 8721, "v": 8721}
+ dim_1 = var_dict[var]
+ return (106652, dim_1)
diff --git a/official-src/aardvark/e2e_model.py b/official-src/aardvark/e2e_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..055a32a8b423cb52ff7b6a0780d9f975cbb2913d
--- /dev/null
+++ b/official-src/aardvark/e2e_model.py
@@ -0,0 +1,241 @@
+import pickle
+
+import torch
+import torch.nn as nn
+import numpy as np
+
+from models import ConvCNPWeather
+from misc_downscaling_functionality import ConvCNPWeatherOnToOff
+
+
+class ConvCNPWeatherE2E(nn.Module):
+ """
+ Complete Aardvark weather model. This chains together the trained encoder,
+ processor and decoder modules to create complete forecasts. It can be finetuned
+ end to end to optimise predictions for a specific variable and location.
+ """
+
+ def __init__(
+ self,
+ device,
+ lead_time,
+ se_model_path,
+ forecast_model_path,
+ sf_model_path,
+ return_gridded=False,
+ aux_data_path=None,
+ ):
+
+ super().__init__()
+
+ self.device = device
+ self.lead_time = lead_time
+ self.return_gridded = return_gridded
+
+ # Load encoder
+ self.se_model = self.load_se_model(se_model_path)
+
+ # Load processor
+ self.forecast_model = nn.ModuleList(
+ [
+ self.load_forecast_model(forecast_model_path, l + 1)
+ for l in range(lead_time)
+ ]
+ )
+
+ # Load decoder
+ self.sf_model = self.load_sf_model(sf_model_path, lead_time)
+ self.decoder = None
+
+ # Setup normalisation factors
+ self.forecast_input_means = (
+ self.to_tensor(np.load(aux_data_path + "norm_factors/mean_4u_1.npy"))
+ .unsqueeze(0)
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+ self.forecast_input_stds = (
+ self.to_tensor(np.load(aux_data_path + "norm_factors/std_4u_1.npy"))
+ .unsqueeze(0)
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+
+ self.forecast_pred_diff_means = (
+ self.to_tensor(np.load(aux_data_path + "norm_factors/mean_diff_4u_1.npy"))
+ .unsqueeze(0)
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+ self.forecast_pred_diff_stds = (
+ self.to_tensor(np.load(aux_data_path + "norm_factors/std_diff_4u_1.npy"))
+ .unsqueeze(0)
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+
+ def to_tensor(self, arr):
+ return torch.from_numpy(arr).float().to(self.device)
+
+ def load_se_model(self, se_model_path):
+ """
+ Load the trained encoder module
+ """
+
+ with open(se_model_path + "/config.pkl", "rb") as handle:
+ forecast_config = pickle.load(handle)
+
+ model = ConvCNPWeather(
+ in_channels=forecast_config["in_channels"],
+ out_channels=forecast_config["out_channels"],
+ int_channels=forecast_config["int_channels"],
+ device="cuda",
+ res=forecast_config["res"],
+ gnp=bool(0),
+ decoder=forecast_config["decoder"],
+ mode=forecast_config["mode"],
+ film=bool(0),
+ )
+
+ best_epoch = np.argmin(np.load("{}/losses_0.npy".format(se_model_path)))
+ state_dict = torch.load(
+ "{}/epoch_{}".format(se_model_path, best_epoch),
+ map_location="cuda",
+ )["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = model.to("cuda")
+ return model
+
+ def load_forecast_model(self, forecast_model_path, lead_time):
+ """
+ Load the trained processor module
+ """
+
+ with open(forecast_model_path + "/config.pkl", "rb") as handle:
+ forecast_config = pickle.load(handle)
+
+ model = ConvCNPWeather(
+ in_channels=forecast_config["in_channels"],
+ out_channels=forecast_config["out_channels"],
+ int_channels=forecast_config["int_channels"],
+ device="cuda",
+ res=forecast_config["res"],
+ gnp=bool(0),
+ decoder=forecast_config["decoder"],
+ mode=forecast_config["mode"],
+ film=False,
+ )
+ state_dict = torch.load(
+ f"{forecast_model_path}/forecast_{lead_time}/epoch_0",
+ map_location="cuda",
+ )["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = model.to("cuda")
+ return model
+
+ def load_sf_model(self, sf_model_path, lead_time):
+ """
+ Load the trained decoder module
+ """
+
+ with open(sf_model_path + "config.pkl", "rb") as handle:
+ config = pickle.load(handle)
+
+ model = ConvCNPWeatherOnToOff(
+ in_channels=config["in_channels"],
+ out_channels=config["out_channels"],
+ int_channels=config["int_channels"],
+ device="cuda",
+ res=config["res"],
+ decoder=config["decoder"],
+ mode=config["mode"],
+ film=False,
+ )
+
+ best_epoch = np.argmin(
+ np.load("{}/lt_{}/losses_0.npy".format(sf_model_path, lead_time))
+ )
+ full_state_dict = torch.load(
+ sf_model_path + f"/lt_{lead_time}/epoch_{best_epoch}", map_location="cuda"
+ )
+ state_dict = full_state_dict["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = model.to("cuda")
+ model.eval()
+
+ return model
+
+ def process_se_output(self, task, x):
+ """
+ Reshape and normalise encoder output for input to processor
+ """
+
+ task["forecast"]["y_context"][:, :24, ...] = x.permute(0, 3, 2, 1)
+ if self.return_gridded:
+ return task, x.permute(0, 3, 2, 1)
+ return task
+
+ def process_forecast_output(self, task, x, last=False):
+ """
+ Reshape and normalise processor output for input to decoder
+ """
+
+ base_context = task["forecast"]["y_context"][:, :-11, ...].permute(0, 2, 3, 1)
+
+ base_context = (
+ base_context * self.forecast_input_stds + self.forecast_input_means
+ ).permute(0, 3, 2, 1)
+
+ x = self.forecast_pred_diff_means + x * self.forecast_pred_diff_stds
+
+ unnorm_x = x + base_context.permute(0, 2, 3, 1)
+
+ forecast = unnorm_x
+
+ x = (unnorm_x - self.forecast_input_means) / self.forecast_input_stds
+
+ task["downscaling"]["y_context"][:, :24, ...] = x.permute(0, 3, 2, 1)
+ task["forecast"]["y_context"] = torch.cat(
+ [
+ x.permute(0, 3, 2, 1),
+ task["forecast"]["y_context"][:, 24:, ...],
+ ],
+ axis=1,
+ )
+ if self.return_gridded:
+ return task, forecast
+ return task
+
+ def forward(self, task, film_index=None):
+ """
+ Produce a forecast
+ """
+
+ # Generate initial state
+ x = self.se_model(task["assimilation"], film_index=None)
+ if self.return_gridded:
+ task, initial_state = self.process_se_output(task, x)
+ else:
+ task = self.process_se_output(task, x)
+
+ # Generate forecast
+ for lt in range(self.lead_time):
+ x = self.forecast_model[lt](task["forecast"], film_index=None)
+ if self.return_gridded:
+ task, forecast = self.process_forecast_output(task, x)
+ else:
+ task = self.process_forecast_output(task, x)
+
+ # Generate station forecast
+ x = self.sf_model(task["downscaling"], film_index=None)
+
+ if self.return_gridded:
+ initial_state = (
+ initial_state.permute(0, 3, 2, 1) * self.forecast_input_stds
+ + self.forecast_input_means
+ )
+ return x, forecast, initial_state
+ return x
diff --git a/official-src/aardvark/e2e_train.py b/official-src/aardvark/e2e_train.py
new file mode 100644
index 0000000000000000000000000000000000000000..704970a578437dd6639f609b832e5e5f2d50351e
--- /dev/null
+++ b/official-src/aardvark/e2e_train.py
@@ -0,0 +1,242 @@
+import os
+import sys
+import pickle
+import argparse
+
+import torch
+from torch.utils.data import DataLoader
+import torch.distributed as dist
+import torch.utils.data.distributed
+import torch.multiprocessing as mp
+from torch.utils.data.distributed import DistributedSampler
+from torch.distributed import init_process_group, destroy_process_group
+
+from misc_downscaling_functionality import DownscalingRmseLoss
+from e2e_model import *
+from loader import *
+from models import *
+from unet_wrap_padding import *
+from trainer import DDPTrainerE2E
+from loss_functions import WeightedRmseLoss, PressureWeightedRmseLoss, RmseLoss
+
+torch.set_float32_matmul_precision("medium")
+
+
+def ddp_setup(rank, world_size, master_port):
+ """
+ Setup DDP
+ """
+
+ os.environ["MASTER_ADDR"] = "localhost"
+ os.environ["MASTER_PORT"] = master_port
+ init_process_group(
+ backend="nccl",
+ rank=rank,
+ world_size=world_size,
+ )
+ torch.cuda.set_device(rank)
+
+
+def start_date(name):
+ """
+ Set split start dates
+ """
+
+ if name == "train":
+ return "2007-01-02"
+ elif name == "val":
+ return "2019-01-01"
+ elif name == "test":
+ return "2018-01-01"
+ else:
+ raise Exception(f"Unrecognised split name {name}")
+
+
+def end_date(name):
+ """
+ Set split end dates
+ """
+
+ if name == "train":
+ return "2017-12-31"
+ elif name == "val":
+ return "2019-11-01"
+ elif name == "test":
+ return "2018-12-21"
+ else:
+ raise Exception(f"Unrecognised split name {name}")
+
+
+def main(rank, world_size, output_dir, args):
+ """
+ Run end to end training
+ """
+
+ master_port = args.master_port
+ lead_time = args.lead_time
+ era5_mode = args.era5_mode
+ ddp_setup(rank, world_size, master_port)
+
+ # Setup loss function
+ if args.loss == "lw_rmse":
+ lf = WeightedRmseLoss(
+ args.res,
+ start_ind=0,
+ end_ind=24,
+ weight_per_variable=False,
+ )
+ elif args.loss == "lw_rmse_pressure_weighted":
+ lf = PressureWeightedRmseLoss(args.res, era5_mode)
+ elif args.loss == "rmse":
+ lf = RmseLoss()
+ elif args.loss == "downscaling_rmse":
+ lf = DownscalingRmseLoss()
+
+ # Instantiate model
+ model = ConvCNPWeatherE2E(
+ device="cuda",
+ lead_time=lead_time,
+ se_model_path=args.se_model_path,
+ forecast_model_path=args.forecast_model_path,
+ sf_model_path=args.sf_model_path,
+ )
+ dist.barrier()
+
+ # Instantiate loaders
+ train_dataset = WeatherDatasetE2E(
+ device="cuda",
+ hadisd_mode="train",
+ start_date="2007-01-02",
+ end_date="2017-12-31",
+ lead_time=lead_time,
+ era5_mode="4u",
+ mode="train",
+ res=args.res,
+ var_start=0,
+ var_end=24,
+ diff=bool(0),
+ two_frames=bool(0),
+ region=args.region,
+ hadisd_var=args.var,
+ max_steps_per_epoch=args.max_steps_per_epoch,
+ )
+
+ val_dataset = WeatherDatasetE2E(
+ device="cuda",
+ hadisd_mode="train",
+ start_date="2019-01-01",
+ end_date="2019-12-21",
+ lead_time=lead_time,
+ era5_mode="4u",
+ mode="train",
+ res=args.res,
+ var_start=0,
+ var_end=24,
+ diff=bool(0),
+ two_frames=bool(0),
+ region=args.region,
+ hadisd_var=args.var,
+ )
+
+ test_dataset = WeatherDatasetE2E(
+ device="cuda",
+ hadisd_mode="train",
+ start_date="2018-01-01",
+ end_date="2018-12-21",
+ lead_time=lead_time,
+ era5_mode="4u",
+ mode="train",
+ res=args.res,
+ var_start=0,
+ var_end=24,
+ diff=bool(0),
+ two_frames=bool(0),
+ region=args.region,
+ hadisd_var=args.var,
+ )
+
+ train_sampler = DistributedSampler(train_dataset)
+ val_sampler = DistributedSampler(val_dataset)
+ test_sampler = DistributedSampler(test_dataset)
+
+ train_loader = DataLoader(
+ train_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=train_sampler,
+ )
+
+ val_loader = DataLoader(
+ val_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=val_sampler,
+ )
+
+ test_loader = DataLoader(
+ test_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=test_sampler,
+ )
+
+ # Instantiate trainer
+ trainer = DDPTrainerE2E(
+ model,
+ rank,
+ train_loader,
+ val_loader,
+ lf,
+ output_dir,
+ args.lr,
+ train_sampler,
+ hadisd_variable_name=args.var,
+ weight_decay=args.weight_decay,
+ weights_path=None,
+ tune_film=0,
+ test_loader=test_loader,
+ )
+
+ # Train model
+ trainer.train(n_epochs=args.epoch)
+ destroy_process_group()
+
+
+if __name__ == "__main__":
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--output_dir")
+ parser.add_argument("--loss")
+ parser.add_argument("--batch_size", type=int, default=3)
+ parser.add_argument("--epoch", type=int, default=10)
+ parser.add_argument("--master_port", default="12345")
+ parser.add_argument("--lr", type=float, default=5e-5)
+ parser.add_argument("--lead_time", type=int)
+ parser.add_argument("--era5_mode", default="4u")
+ parser.add_argument("--sf_model_path")
+ parser.add_argument("--se_model_path")
+ parser.add_argument("--forecast_model_path")
+
+ parser.add_argument("--weight_decay", type=float, default=1e-6)
+ parser.add_argument("--max_steps_per_epoch", type=int)
+ parser.add_argument("--res", type=int, default=1)
+ parser.add_argument("--frequency", type=int, default=6)
+ parser.add_argument("--region", default="global")
+ parser.add_argument("--var", choices=["tas", "u", "v", "psl", "ws"])
+ args = parser.parse_args()
+
+ torch.device("cuda")
+
+ # Make results directory
+ output_dir = args.output_dir
+ try:
+ os.mkdir(output_dir)
+ except:
+ pass
+
+ # Save config
+ with open(output_dir + "/config.pkl", "wb") as f:
+ pickle.dump(vars(args), f)
+
+ world_size = torch.cuda.device_count()
+ mp.spawn(main, args=[world_size, output_dir, args], nprocs=world_size)
diff --git a/official-src/aardvark/finetune.py b/official-src/aardvark/finetune.py
new file mode 100644
index 0000000000000000000000000000000000000000..34bfb307eef55a29750c720bfa9dc76cb6ac6471
--- /dev/null
+++ b/official-src/aardvark/finetune.py
@@ -0,0 +1,431 @@
+"""
+NB: this script is for illustration purposes only and is not runnable as our
+full dataset is not provided as part of the submission due to size constraints.
+Many of the relevant paths to the data have been thus replaced by dummy paths.
+"""
+
+import os
+import argparse
+import pickle
+import subprocess
+from collections import OrderedDict
+
+import numpy as np
+from tqdm import tqdm
+import torch
+import torch.multiprocessing as mp
+import torch.utils.data.distributed
+from torch.utils.data import DataLoader, DistributedSampler
+from torch.distributed import init_process_group, destroy_process_group
+
+from loss_functions import WeightedRmseLoss, PressureWeightedRmseLoss, RmseLoss
+from trainer import DDPTrainer
+from loader import *
+from models import *
+from unet_wrap_padding import *
+
+torch.set_float32_matmul_precision("medium")
+
+weights = np.load(
+ "path_to_lat_weights/weights_lat_1.npy",
+).T[np.newaxis, ..., np.newaxis]
+
+
+def weighted_rmse_loss(target, output):
+ return np.sqrt(np.nanmean(((target - output) ** 2) * weights, axis=(0, 1, 2)))
+
+
+def unnorm_era5(x, mean, std):
+ x = x * std + mean
+ return x
+
+
+def norm_era5(x, mean, std):
+ x = (x - mean) / std
+ return x
+
+
+def ddp_setup(rank, world_size, master_port):
+ os.environ["MASTER_ADDR"] = "localhost"
+ os.environ["MASTER_PORT"] = master_port
+ init_process_group(backend="nccl", rank=rank, world_size=world_size)
+ torch.cuda.set_device(rank)
+
+
+def main(rank, world_size, output_dir, args):
+ """
+ Finetune the processor module for each leadtime
+ """
+
+ # Setup
+ master_port = args.master_port
+ lead_time = args.lead_time
+ quicklook_id = args.output_dir
+ era5_mode = args.era5_mode
+ ddp_setup(rank, world_size, master_port)
+
+ # Instantiate loss function
+ if args.loss == "lw_rmse":
+ lf = WeightedRmseLoss(args.res, weight_per_variable=False)
+ elif args.loss == "lw_rmse_pressure_weighted":
+ lf = PressureWeightedRmseLoss(args.res, args.era5_mode)
+ elif args.loss == "rmse":
+ lf = RmseLoss()
+
+ # Load the pre-trained model
+ with open(args.forecast_model_path + "/config.pkl", "rb") as handle:
+ forecast_config = pickle.load(handle)
+
+ model = ConvCNPWeather(
+ in_channels=forecast_config["in_channels"],
+ out_channels=forecast_config["out_channels"],
+ int_channels=forecast_config["int_channels"],
+ device="cuda",
+ res=forecast_config["res"],
+ gnp=bool(0),
+ decoder=forecast_config["decoder"],
+ mode=forecast_config["mode"],
+ film=bool(forecast_config["film"]),
+ )
+
+ try:
+ best_epoch = np.argmin(np.load(forecast_config["output_dir"] + "/losses_0.npy"))
+ checkpoint = torch.load(
+ forecast_config["output_dir"] + "/epoch_{}".format(best_epoch)
+ )
+
+ except:
+ best_epoch = np.argmin(
+ np.load("../results/" + forecast_config["output_dir"] + "/losses_0.npy")
+ )
+ checkpoint = torch.load(
+ "../results/"
+ + forecast_config["output_dir"]
+ + "/epoch_{}".format(best_epoch)
+ )
+
+ new_state_dict = OrderedDict()
+ for k, v in checkpoint["model_state_dict"].items():
+ name = k[7:] # remove `module.`
+ new_state_dict[name] = v
+
+ # Set the path to the prediction from the encoder
+ path_to_context = args.assimilation_model_path
+
+ # Finetune for each leadtime
+ for lead_time in range(1, 11):
+ print(f"Training lead time {lead_time}")
+
+ # Setup the model
+ model = ConvCNPWeather(
+ in_channels=forecast_config["in_channels"],
+ out_channels=forecast_config["out_channels"],
+ int_channels=forecast_config["int_channels"],
+ device="cuda",
+ res=forecast_config["res"],
+ gnp=bool(0),
+ decoder=forecast_config["decoder"],
+ mode=forecast_config["mode"],
+ film=bool(forecast_config["film"]),
+ )
+
+ model.load_state_dict(new_state_dict)
+
+ # Setup the loaders
+ if lead_time == 1:
+ path_to_context = args.assimilation_model_path
+ else:
+ path_to_context = f"{args.output_dir}/"
+
+ print(f"Loading context data from {path_to_context}...")
+ train_dataset = ForecastLoader(
+ device="cuda",
+ mode="train",
+ lead_time=lead_time,
+ era5_mode=args.era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ ic_path=path_to_context,
+ finetune_step=lead_time,
+ random_lt=False,
+ finetune_eval_every=250,
+ eval_steps=False,
+ )
+
+ val_dataset = ForecastLoader(
+ device="cuda",
+ mode="val",
+ lead_time=lead_time,
+ era5_mode=args.era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ ic_path=path_to_context,
+ finetune_step=lead_time,
+ )
+
+ test_dataset = ForecastLoader(
+ device="cuda",
+ mode="test",
+ lead_time=lead_time,
+ era5_mode=args.era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ ic_path=path_to_context,
+ finetune_step=lead_time,
+ )
+
+ train_sampler = DistributedSampler(train_dataset)
+ val_sampler = DistributedSampler(val_dataset)
+ test_sampler = DistributedSampler(test_dataset)
+
+ train_loader = DataLoader(
+ train_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=train_sampler,
+ )
+
+ val_loader = DataLoader(
+ val_dataset, batch_size=args.batch_size, shuffle=False, sampler=val_sampler
+ )
+
+ test_loader = DataLoader(
+ test_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=test_sampler,
+ )
+
+ # Setup output dir
+ try:
+ output_dir = f"{args.output_dir}/forecast_{lead_time}/"
+ os.mkdir(output_dir)
+ except:
+ pass
+
+ # Run the finetuning
+ trainer = DDPTrainer(
+ model,
+ rank,
+ train_loader,
+ val_loader,
+ lf,
+ output_dir,
+ args.lr,
+ train_sampler,
+ weight_decay=args.weight_decay,
+ tune_film=False,
+ )
+
+ # Finetune
+ n_epochs = args.finetune_epochs
+ trainer.train(n_epochs=n_epochs)
+
+ torch.distributed.barrier()
+
+ # Load the model just trained
+
+ best_epoch = np.argmin(
+ np.load(f"{args.output_dir}/forecast_{lead_time}/losses_0.npy")
+ )
+ checkpoint = torch.load(
+ f"{args.output_dir}/forecast_{lead_time}/epoch_{best_epoch}"
+ )
+
+ new_state_dict = OrderedDict()
+ for k, v in checkpoint["model_state_dict"].items():
+ name = k[7:]
+ new_state_dict[name] = v
+
+ model.load_state_dict(new_state_dict)
+ model.eval()
+
+ # Now need to make predictions using this model to create data to train on for the next leadtime
+
+ # Setup the output arrays
+ if rank == 0:
+ val_ic = np.memmap(
+ f"{args.output_dir}/ic_val_{lead_time}.mmap",
+ dtype="float32",
+ mode="w+",
+ shape=(len(val_dataset), 121, 240, 24),
+ )
+
+ test_ic = np.memmap(
+ f"{args.output_dir}/ic_test_{lead_time}.mmap",
+ dtype="float32",
+ mode="w+",
+ shape=(len(test_dataset), 121, 240, 24),
+ )
+
+ test_ic_target = np.memmap(
+ f"{args.output_dir}/ic_test_target_{lead_time}.mmap",
+ dtype="float32",
+ mode="w+",
+ shape=(len(test_dataset), 121, 240, 24),
+ )
+
+ train_ic = np.memmap(
+ f"{args.output_dir}/ic_train_{lead_time}.mmap",
+ dtype="float32",
+ mode="w+",
+ shape=(len(train_dataset), 121, 240, 24),
+ )
+
+ torch.distributed.barrier()
+ val_ic = np.memmap(
+ f"{args.output_dir}/ic_val_{lead_time}.mmap",
+ dtype="float32",
+ mode="r+",
+ shape=(len(val_dataset), 121, 240, 24),
+ )
+
+ train_ic = np.memmap(
+ f"{args.output_dir}/ic_train_{lead_time}.mmap",
+ dtype="float32",
+ mode="r+",
+ shape=(len(train_dataset), 121, 240, 24),
+ )
+
+ test_ic = np.memmap(
+ f"{args.output_dir}/ic_test_{lead_time}.mmap",
+ dtype="float32",
+ mode="r+",
+ shape=(len(test_dataset), 121, 240, 24),
+ )
+
+ test_ic_target = np.memmap(
+ f"{args.output_dir}/ic_test_target_{lead_time}.mmap",
+ dtype="float32",
+ mode="r+",
+ shape=(len(test_dataset), 121, 240, 24),
+ )
+
+ print(f"{args.output_dir}/ic_train_{lead_time}.mmap")
+ if lead_time > 1:
+ if rank == 0:
+ subprocess.run(
+ [
+ "rm",
+ f"{args.output_dir}/ic_train_{lead_time-1}.mmap",
+ ]
+ )
+
+ torch.distributed.barrier()
+
+ # Generate predictions on the test set
+ with tqdm(test_loader, unit="batch") as tepoch:
+ for count, batch in enumerate(tepoch):
+ inds = batch["target_index"].detach().cpu().numpy().astype(int)[:, 0]
+ out = model(batch, film_index=batch["lt"])
+
+ base_context = test_loader.dataset.unnorm_base_context(
+ batch["y_context"][:, :-11, ...]
+ ).permute(0, 3, 2, 1)
+ unnorm_pred = test_loader.dataset.unnorm_pred(out)
+ unnorm_target = test_loader.dataset.unnorm_pred(batch["y_target"])
+
+ unnorm_pred = unnorm_pred + base_context
+ unnorm_target = unnorm_target + base_context
+
+ test_ic[inds, ...] = unnorm_pred.detach().cpu()
+ test_ic_target[inds, ...] = unnorm_target.detach().cpu()
+
+ torch.distributed.barrier()
+
+ # Generate predictions on the validation set
+ with tqdm(val_loader, unit="batch") as tepoch:
+ for count, batch in enumerate(tepoch):
+ inds = batch["target_index"].detach().cpu().numpy().astype(int)[:, 0]
+ out = model(batch, film_index=batch["lt"])
+
+ base_context = val_loader.dataset.unnorm_base_context(
+ batch["y_context"][:, :-11, ...]
+ ).permute(0, 3, 2, 1)
+ unnorm_pred = val_loader.dataset.unnorm_pred(out)
+ unnorm_pred = unnorm_pred + base_context
+
+ val_ic[inds, ...] = unnorm_pred.detach().cpu()
+
+ torch.distributed.barrier()
+
+ # Generate predictions on the train set
+ with tqdm(train_loader, unit="batch") as tepoch:
+ for count, batch in enumerate(tepoch):
+ inds = batch["target_index"].detach().cpu().numpy().astype(int)[:, 0]
+ out = model(batch, film_index=batch["lt"])
+ base_context = val_loader.dataset.unnorm_base_context(
+ batch["y_context"][:, :-11, ...]
+ ).permute(0, 3, 2, 1)
+ unnorm_pred = val_loader.dataset.unnorm_pred(out)
+ unnorm_pred = unnorm_pred + base_context
+
+ train_ic[inds, ...] = unnorm_pred.detach().cpu()
+
+ torch.distributed.barrier()
+
+ print("Setting up next lead time...")
+ path_to_context = f"{args.output_dir}/"
+
+ # Set the initial model weights for the next leadtime to be the current trained weights
+ if lead_time > 1:
+ best_epoch = np.argmin(
+ np.load(f"{args.output_dir}/forecast_{lead_time}/losses_0.npy")
+ )
+ checkpoint = torch.load(
+ f"{args.output_dir}/forecast_{lead_time}/epoch_{best_epoch}"
+ )
+ new_state_dict = OrderedDict()
+ for k, v in checkpoint["model_state_dict"].items():
+ name = k[7:]
+ new_state_dict[name] = v
+
+ torch.cuda.empty_cache()
+
+ destroy_process_group()
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+
+ parser.add_argument("--output_dir")
+ parser.add_argument("--assimilation_model_path")
+ parser.add_argument("--forecast_model_path")
+
+ parser.add_argument("--loss", default="lw_rmse_pressure_weighted")
+ parser.add_argument("--batch_size", type=int, default=12)
+ parser.add_argument("--master_port", default="12345")
+ parser.add_argument("--lr", type=float, default=1e-4)
+ parser.add_argument("--lead_time", type=int, default=1)
+ parser.add_argument("--era5_mode", default="4u")
+ parser.add_argument("--weight_decay", type=float, default=1e-6)
+ parser.add_argument("--res", type=int, default=1)
+ parser.add_argument("--frequency", type=int, default=6)
+
+ parser.add_argument("--diff", type=int, default=1)
+ parser.add_argument("--start_ind", type=int, default=0)
+ parser.add_argument("--end_ind", type=int, default=24)
+ parser.add_argument("--finetune_epochs", type=int, default=5)
+
+ args = parser.parse_args()
+
+ device = torch.device("cuda")
+
+ # Setup results directory
+ output_dir = args.output_dir
+ try:
+ os.mkdir(output_dir)
+ except:
+ pass
+
+ # Save config
+ config = vars(args)
+
+ with open(output_dir + "/config.pkl", "wb") as f:
+ pickle.dump(config, f)
+
+ world_size = torch.cuda.device_count()
+ mp.spawn(main, args=[world_size, output_dir, args], nprocs=world_size)
diff --git a/official-src/aardvark/generate_initial_condition_single.py b/official-src/aardvark/generate_initial_condition_single.py
new file mode 100644
index 0000000000000000000000000000000000000000..842f41e8f6587be60900ecc7a5bc6a962cae778a
--- /dev/null
+++ b/official-src/aardvark/generate_initial_condition_single.py
@@ -0,0 +1,148 @@
+"""
+NB: this script is for illustration purposes only and is not runnable as our
+full dataset is not provided as part of the submission due to size constraints.
+Many of the relevant paths to the data have been thus replaced by dummy paths.
+"""
+
+import argparse
+import pickle
+
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import torch
+import torch.nn as nn
+import torch.utils.data.distributed
+from torch.utils.data import DataLoader
+
+from loader import WeatherDatasetAssimilation
+from models import *
+
+torch.set_float32_matmul_precision("medium")
+
+
+def unnorm(x, mean, std, diff=False, av_2019=None):
+
+ x = x * std + mean
+ if diff:
+ return x + av_2019.transpose(0, 3, 2, 1)
+ return x
+
+
+if __name__ == "__main__":
+
+ """
+ Generate encoder predictions to be used as finetuning data for the processor module
+ """
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--encoder_model_path")
+ args = parser.parse_args()
+
+ # Load experiment config
+ with open(args.encoder_model_path + "/config.pkl", "rb") as handle:
+ forecast_config = pickle.load(handle)
+
+ device = "cuda"
+
+ # Setup normalisation factors
+ era5_mean_spatial = None
+ means = np.load(
+ "aux_data_path/norm_factors/mean_{}_{}.npy".format(
+ forecast_config["era5_mode"], forecast_config["res"]
+ )
+ )[np.newaxis, np.newaxis, np.newaxis, :]
+ stds = np.load(
+ "aux_data_path/norm_factors/std_{}_{}.npy".format(
+ forecast_config["era5_mode"], forecast_config["res"]
+ )
+ )[np.newaxis, np.newaxis, np.newaxis, :]
+
+ # Specify dates to generate predictions for
+ labels = ["train", "test", "val"]
+ dates = [
+ ["2007-01-02", "2017-12-31"],
+ ["2018-01-01", "2018-12-31"],
+ ["2019-01-01", "2019-12-31"],
+ ]
+
+ # Iterate over loaders
+ for label, date in zip(labels, dates):
+
+ n_times = pd.date_range(date[0], date[1], freq="6H")
+
+ # Setup a memmap to write out to
+ ic = np.memmap(
+ "{}/ic_{}.mmap".format(args.encoder_model_path, label),
+ dtype="float32",
+ mode="w+",
+ shape=(len(n_times), 121, 240, 24),
+ )
+
+ var_group_preds = []
+ var_group_targets = []
+
+ # Setup loader
+ dataset = WeatherDatasetAssimilation(
+ device="cuda",
+ hadisd_mode="train",
+ start_date=date[0],
+ end_date=date[1],
+ lead_time=0,
+ era5_mode="4u",
+ res=1,
+ var_start=0,
+ var_end=24,
+ diff=False,
+ )
+
+ loader = DataLoader(dataset, batch_size=64, shuffle=False) # ,
+
+ # Instantiate and load model
+ model = ConvCNPWeather(
+ in_channels=forecast_config["in_channels"],
+ out_channels=forecast_config["out_channels"],
+ int_channels=forecast_config["int_channels"],
+ device="cuda",
+ res=forecast_config["res"],
+ gnp=bool(0),
+ decoder=forecast_config["decoder"],
+ mode=forecast_config["mode"],
+ film=bool(0),
+ )
+
+ best_epoch = np.argmin(
+ np.load("{}/losses_0.npy".format(args.encoder_model_path))
+ )
+ state_dict = torch.load(
+ "{}/epoch_{}".format(args.encoder_model_path, best_epoch),
+ map_location=device,
+ )["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = nn.DataParallel(model)
+ model = model.cuda()
+
+ model.eval()
+
+ # Generate predictions
+ total = []
+ target = []
+
+ sum_count = 0
+ with torch.no_grad():
+ with tqdm(loader, unit="batch") as tepoch:
+ for count, batch in enumerate(tepoch):
+
+ out = model(batch, film_index=batch["lt"]).detach().cpu().numpy()
+
+ out_unnorm = unnorm(
+ out,
+ means,
+ stds,
+ diff=False,
+ av_2019=era5_mean_spatial,
+ )
+
+ ic[sum_count : sum_count + out.shape[0], ...] = out_unnorm
+ sum_count += out.shape[0]
diff --git a/official-src/aardvark/loader.py b/official-src/aardvark/loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..f06e4dc8db8170541e2f7e6c35712731e2cc72c5
--- /dev/null
+++ b/official-src/aardvark/loader.py
@@ -0,0 +1,1825 @@
+import time as timelib
+from time import time
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+
+from loader_utils_new import *
+from data_shapes import *
+
+
+class WeatherDataset(Dataset):
+ """
+ Base weather dataset class
+ """
+
+ def __init__(
+ self,
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ lead_time,
+ era5_mode="train",
+ res=1,
+ filter_dates=None,
+ diff=None,
+ ):
+
+ super().__init__()
+
+ # Setup
+ self.device = device
+ self.mode = hadisd_mode
+ self.data_path = "path_to_data/"
+ self.aux_data_path = "path_to_auxiliary_data/"
+ self.start_date = start_date
+ self.end_date = end_date
+ self.lead_time = lead_time
+ self.era5_mode = era5_mode
+ self.res = res
+ self.filter_dates = filter_dates
+ self.diff = diff
+
+ # Date indexing
+ self.dates = pd.date_range(start_date, end_date, freq="6H")
+ if self.filter_dates == "start":
+ self.index = np.array([i for i, d in enumerate(self.dates) if d.month < 7])
+ elif self.filter_dates == "end":
+ self.index = np.array([i for i, d in enumerate(self.dates) if d.month >= 7])
+ else:
+ self.index = np.array(range(len(self.dates)))
+
+ # Load the input modalities
+ print("Loading IGRA")
+ self.load_igra()
+
+ print("Loading AMSU-A")
+ self.load_amsua()
+
+ print("Loading AMSU-B")
+ self.load_amsub()
+
+ print("Loading ICOADS")
+ self.load_icoads()
+
+ print("Loading IASI")
+ self.load_iasi()
+
+ print("Loading GEO")
+ self.load_sat_data()
+
+ print("Loading HADISD")
+ self.load_hadisd(self.mode)
+
+ print("Loading ASCAT")
+ self.load_ascat_data()
+ self.load_hirs_data()
+
+ # Load the ground truth data for training
+ print("Loading ERA5")
+ self.era5_sfc = [
+ self.load_era5(year)
+ for year in range(int(start_date[:4]), int(end_date[:4]) + 1)
+ ]
+
+ # Internal grid to longitude latitude correspondence
+ self.era5_x = [
+ self.to_tensor(
+ np.load(self.data_path + "era5/era5_x_{}.npy".format(self.res))
+ )
+ / LATLON_SCALE_FACTOR,
+ self.to_tensor(
+ np.load(self.data_path + "era5/era5_y_{}.npy".format(self.res))
+ )
+ / LATLON_SCALE_FACTOR,
+ ]
+
+ # Orography
+ self.era5_elev = self.to_tensor(
+ np.load(self.data_path + "era5/elev_vars_{}.npy".format(self.res))
+ )
+ self.era5_elev = torch.flip(self.era5_elev.permute(0, 2, 1), [-1])
+ xx, yy = torch.meshgrid(self.era5_x[0], self.era5_x[1])
+ self.era5_lonlat = torch.stack([xx, yy])
+
+ # Climatology
+ self.climatology = np.memmap(
+ self.data_path + "climatology_data.mmap",
+ dtype="float32",
+ mode="r",
+ shape=CLIMATOLOGY_SHAPE,
+ )
+
+ # Setup normalisation factors
+ if self.diff:
+ self.era5_mean_spatial = np.load(
+ self.aux_data_path + "era5_spatial_means.npy"
+ )[0, ...]
+ self.means = np.load(self.aux_data_path + "era5_avdiff_means.npy")[
+ :, np.newaxis, np.newaxis, ...
+ ]
+ self.stds = np.load(self.aux_data_path + "era5_avdiff_stds.npy")[
+ :, np.newaxis, np.newaxis, ...
+ ]
+ else:
+ self.means = np.load(
+ self.aux_data_path
+ + "norm_factors/mean_{}_{}.npy".format(self.era5_mode, self.res)
+ )[:, np.newaxis, np.newaxis, ...]
+ self.stds = np.load(
+ self.aux_data_path
+ + "norm_factors/std_{}_{}.npy".format(self.era5_mode, self.res)
+ )[:, np.newaxis, np.newaxis, ...]
+
+ def load_icoads(self):
+ """
+ Load the ICOADS data
+ """
+
+ self.icoads_y = np.memmap(
+ self.data_path + "icoads/1999_2021_icoads_y.mmap",
+ dtype="float32",
+ mode="r",
+ shape=ICOADS_Y_SHAPE,
+ )
+
+ self.icoads_x = (
+ np.memmap(
+ self.data_path + "icoads/1999_2021_icoads_x.mmap",
+ dtype="float32",
+ mode="r",
+ shape=ICOADS_X_SHAPE,
+ )
+ / LATLON_SCALE_FACTOR
+ )
+ self.icoads_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_icoads.npy")
+ )
+ self.icoads_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_icoads.npy")
+ )
+ self.icoads_means = self.to_tensor(
+ np.nanmean(self.icoads_y[-365 * 4 :, ...], axis=(0, 2))[:, np.newaxis]
+ )
+ self.icoads_stds = self.to_tensor(
+ np.nanstd(self.icoads_y[-365 * 4 :, ...], axis=(0, 2))[:, np.newaxis]
+ )
+ self.icoads_index_offset = ICOADS_OFFSETS[self.start_date]
+ return
+
+ def load_igra(self):
+ """
+ Load the IGRA data
+ """
+
+ self.igra_y = np.memmap(
+ self.data_path + "igra/1999_2021_igra_y.mmap",
+ dtype="float32",
+ mode="r",
+ shape=IGRA_Y_SHAPE,
+ )
+
+ self.igra_x = np.copy(
+ np.memmap(
+ self.data_path + "igra/1999_2021_igra_x.mmap",
+ dtype="float32",
+ mode="r",
+ shape=IGRA_X_SHAPE,
+ )
+ )
+ self.igra_x = self.igra_x / LATLON_SCALE_FACTOR
+
+ self.igra_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_igra.npy")
+ )
+ self.igra_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_igra.npy")
+ )
+
+ self.igra_index_offset = IGRA_OFFSETS[self.start_date]
+
+ return
+
+ def load_amsua(self):
+ """
+ Load the AMSU-A data
+ """
+
+ self.amsua_y = np.memmap(
+ self.data_path + "amsua/2007_2021_amsua.mmap",
+ dtype="float32",
+ mode="r",
+ shape=AMSUA_Y_SHAPE,
+ )
+ self.amsua_index_offset = AMSUA_OFFSETS[self.start_date]
+
+ xx = np.linspace(-180, 179, 360, dtype=np.float32)
+ xx = ((xx + 360) % 360) / LATLON_SCALE_FACTOR
+ yy = np.linspace(90, -90, 180, dtype=np.float32) / LATLON_SCALE_FACTOR
+ self.amsua_x = [xx, yy]
+
+ self.amsua_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_amsua.npy")
+ )
+ self.amsua_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_amsua.npy")
+ )
+
+ return
+
+ def load_amsub(self):
+ """
+ Load the AMSU-B data
+ """
+
+ self.amsub_y = np.memmap(
+ self.data_path + "amsub_mhs/2007_2021_amsub.mmap",
+ dtype="float32",
+ mode="r",
+ shape=AMSUB_Y_SHAPE,
+ )
+ self.amsub_index_offset = AMSUB_OFFSETS[self.start_date]
+
+ xx = np.linspace(0, 359, 360, dtype=np.float32)
+ xx = ((xx + 360) % 360) / LATLON_SCALE_FACTOR
+ yy = np.linspace(90, -90, 181, dtype=np.float32) / LATLON_SCALE_FACTOR
+ self.amsub_x = [xx, yy]
+
+ self.amsub_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_amsub.npy")
+ )
+ self.amsub_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_amsub.npy")
+ )
+
+ return
+
+ def load_ascat_data(self):
+ """
+ Load the ASCAT data
+ """
+
+ self.ascat_y = np.memmap(
+ self.data_path + "ascat/2007_2021_ascat.mmap",
+ dtype="float32",
+ mode="r",
+ shape=ASCAT_Y_SHAPE,
+ )
+ self.ascat_index_offset = ASCAT_OFFSETS[self.start_date]
+
+ xx = np.linspace(0, 359, 360, dtype=np.float32)
+ xx = ((xx + 360) % 360) / LATLON_SCALE_FACTOR
+ yy = np.linspace(-90, 90, 181, dtype=np.float32) / LATLON_SCALE_FACTOR
+ self.ascat_x = [xx, np.copy(yy[::-1])]
+
+ self.ascat_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_ascat.npy")
+ )
+ self.ascat_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_ascat.npy")
+ )
+
+ return
+
+ def load_hirs_data(self):
+ """
+ Load the HIRS data
+ """
+
+ self.hirs_y = np.memmap(
+ self.data_path + "hirs/2007_2021_hirs.mmap",
+ dtype="float32",
+ mode="r",
+ shape=HIRS_Y_SHAPE,
+ )
+ self.hirs_index_offset = ASCAT_OFFSETS[self.start_date]
+
+ xx = np.linspace(0, 359, 360, dtype=np.float32)
+ xx = ((xx + 360) % 360) / LATLON_SCALE_FACTOR
+ yy = np.linspace(-90, 90, 181, dtype=np.float32) / LATLON_SCALE_FACTOR
+ self.hirs_x = [xx, np.copy(yy[::-1])]
+
+ self.hirs_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/hirs_means.npy")
+ )
+ self.hirs_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/hirs_stds.npy")
+ )
+
+ return
+
+ def load_sat_data(self):
+ """
+ Load the GRIDSAT data
+ """
+
+ self.sat_y = np.memmap(
+ self.data_path + "gridsat/gridsat_data.mmap",
+ dtype="float32",
+ mode="r",
+ shape=GRIDSAT_Y_SHAPE,
+ )
+
+ xx = np.load(self.data_path + "gridsat/sat_x.npy") / LATLON_SCALE_FACTOR
+ yy = np.load(self.data_path + "gridsat/sat_y.npy") / LATLON_SCALE_FACTOR
+ self.sat_x = [xx, yy]
+ self.sat_index_offset = SAT_OFFSETS[self.start_date]
+
+ self.sat_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_sat.npy")
+ )
+ self.sat_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_sat.npy")
+ )
+
+ return
+
+ def load_iasi(self):
+ """
+ Load the IASI data
+ """
+
+ self.iasi = np.memmap(
+ self.data_path + "2007_2021_iasi_subset.mmap",
+ dtype="float32",
+ mode="r",
+ shape=IASI_Y_SHAPE,
+ )
+ self.iasi_index_offset = ASCAT_OFFSETS[self.start_date]
+
+ xx = np.linspace(0, 359, 360, dtype=np.float32)
+ xx = ((xx + 360) % 360) / LATLON_SCALE_FACTOR
+ yy = np.linspace(-90, 90, 181, dtype=np.float32) / LATLON_SCALE_FACTOR
+ self.iasi_x = [xx, np.copy(yy[::-1])]
+
+ self.iasi_means = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/mean_iasi.npy")
+ )
+ self.iasi_stds = self.to_tensor(
+ np.load(self.aux_data_path + "norm_factors/std_iasi.npy")
+ )
+
+ return
+
+ def load_hadisd(self, mode):
+ """
+ Load the HADISD data
+ """
+
+ self.hadisd_x = []
+ self.hadisd_alt = []
+ self.hadisd_y = []
+ hadisd_vars = ["tas", "tds", "psl", "u", "v"]
+ for var in hadisd_vars:
+ lon = lon_to_0_360(
+ np.load(
+ self.data_path + "hadisd_processed/{}_lon_{}.npy".format(var, mode)
+ )
+ )
+ lat = np.load(
+ self.data_path + "hadisd_processed/{}_lat_{}.npy".format(var, mode)
+ )
+ alt = np.load(
+ self.data_path + "hadisd_processed/{}_alt_{}.npy".format(var, mode)
+ )
+
+ vals = np.memmap(
+ self.data_path
+ + "hadisd_processed/{}_vals_{}.memmap".format(var, self.mode),
+ dtype="float32",
+ mode="r",
+ shape=get_hadisd_shape(mode),
+ )
+
+ self.hadisd_x.append(np.stack([lon, lat], axis=-1) / LATLON_SCALE_FACTOR)
+ self.hadisd_alt.append(alt)
+ self.hadisd_y.append(vals)
+
+ self.hadisd_index_offset = HADISD_OFFSETS[self.start_date]
+
+ self.hadisd_means = [
+ self.to_tensor(
+ np.load(
+ self.aux_data_path + "norm_factors/mean_hadisd_{}.npy".format(var)
+ )
+ )
+ for var in hadisd_vars
+ ]
+ self.hadisd_stds = [
+ self.to_tensor(
+ np.load(
+ self.aux_data_path + "norm_factors/std_hadisd_{}.npy".format(var)
+ )
+ )
+ for var in hadisd_vars
+ ]
+
+ return
+
+ def load_era5(self, year):
+ """
+ Load the ERA5 training data
+ """
+
+ if year % 4 == 0:
+ d = 366 * 4
+ else:
+ d = 365 * 4
+
+ if self.era5_mode == "sfc":
+ levels = 4
+ elif self.era5_mode == "13u":
+ levels = 69
+ else:
+ levels = 24
+
+ if self.res == 1:
+ x = 240
+ y = 121
+ elif self.res == 5:
+ x = 64
+ y = 32
+ mmap = np.memmap(
+ self.data_path
+ + "/era5/era5_{}_{}_6_{}.memmap".format(self.era5_mode, self.res, year),
+ dtype="float32",
+ mode="r",
+ shape=(d, levels, x, y),
+ )
+ return mmap
+
+ def norm_era5(self, x):
+
+ x = (x - self.means) / self.stds
+ return x
+
+ def unnorm_era5(self, x):
+
+ x = x * self.stds + self.means
+ return x
+
+ def norm_data(self, x, means, stds):
+ return (x - means) / stds
+
+ def norm_hadisd(self, x):
+ for i in range(5):
+ x[i] = (x[i] - self.hadisd_means[i]) / self.hadisd_stds[i]
+ return x
+
+ def __len__(self):
+ return self.index.shape[0] - 1 - 1
+
+ def to_tensor(self, arr):
+ return torch.from_numpy(arr).float().to(self.device)
+
+ def get_time_aux(self, current_date):
+ """
+ Return the auxiliary temporal channels given a date
+ """
+
+ doy = current_date.dayofyear
+ year = (current_date.year - 2007) / 15
+ time_of_day = current_date.hour
+ return np.array(
+ [
+ np.cos(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.sin(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.cos(np.pi * 2 * time_of_day / 24),
+ np.sin(np.pi * 2 * time_of_day / 24),
+ year,
+ ]
+ )
+
+
+class WeatherDatasetAssimilation(WeatherDataset):
+ """
+ Encoder training loader
+ """
+
+ def __init__(
+ self,
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ lead_time,
+ era5_mode="sfc",
+ res=1,
+ filter_dates=None,
+ var_start=0,
+ var_end=24,
+ diff=False,
+ two_frames=False,
+ ):
+
+ super().__init__(
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ lead_time,
+ era5_mode,
+ res=res,
+ filter_dates=filter_dates,
+ diff=diff,
+ )
+
+ # Setup
+
+ self.var_start = var_start
+ self.var_end = var_end
+ self.diff = diff
+ self.two_frames = two_frames
+
+ def load_era5_time(self, index):
+ """
+ ERA5 ground truth data loading
+ """
+
+ date = self.dates[index]
+ year = date.year
+ hour = date.hour
+ doy = (date.dayofyear - 1) * 4 + (hour // 6)
+
+ era5 = self.era5_sfc[year - int(self.start_date[:4])][doy, ...]
+ era5 = np.copy(era5)
+ if self.diff:
+ era5 = era5 - self.era5_mean_spatial
+ era5 = self.norm_era5(era5[np.newaxis, ...])[0, ...]
+ return era5
+
+ def load_year_end(self, year, doy):
+ data_1 = self.era5_sfc[year - int(self.start_date[:4])][doy : doy + 1, ...]
+ missing = self.lead_time - data_1.shape[0] + 1
+ data_2 = self.era5_sfc[year - int(self.start_date[:4]) + 1][:missing, ...]
+ data = np.concatenate([data_1, data_2])
+ return data
+
+ def load_era5_slice(self, index):
+ """
+ ERA5 ground truth data loading
+ """
+
+ date = self.dates[index]
+ year = date.year
+ doy = (date.dayofyear - 1) * 4
+
+ next_date = self.dates[index + 1]
+ next_year = next_date.year
+
+ if next_year != year:
+ era5 = self.load_year_end(year, doy)
+ else:
+ era5 = self.era5_sfc[year - int(self.start_date[:4])][doy : doy + 1, ...]
+
+ era5 = self.norm_era5(np.copy(era5))
+ return era5
+
+ def __getitem__(self, index):
+
+ if self.two_frames:
+ # Case 1: loading t=0 and t=-1
+ index = index + 1
+ current = self.get_index(index, "current")
+ prev = self.get_index(index - 1, "prev")
+ current["y_target"] = current["y_target_current"]
+
+ return {**current, **prev}
+ else:
+ # Case 2: loading t=0
+ current = self.get_index(index, "current")
+ current["y_target"] = current["y_target_current"]
+
+ return {**current}
+
+ def unnorm_pred(self, x):
+ dev = x.device
+ x = x.detach().cpu().numpy()
+
+ x = (
+ x
+ * self.stds[np.newaxis, ...].transpose(0, 2, 3, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ + self.means[np.newaxis, ...].transpose(0, 2, 3, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ )
+ if bool(self.diff):
+ x = (
+ x
+ + self.era5_mean_spatial[np.newaxis, ...].transpose(0, 3, 2, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ )
+ return torch.from_numpy(x).float().to(dev)
+
+ def get_index(self, index, prefix):
+ """
+ Load data for the relevant index respecting different offsets depending on the modality
+ """
+
+ index = self.index[index]
+ date = self.dates[index]
+
+ # ICOADS
+ icoads_x = self.icoads_x[index + self.icoads_index_offset, ...]
+ icoads_y = self.icoads_y[index + self.icoads_index_offset, ...]
+ icoads_x = [icoads_x[0, :], icoads_x[1, :]]
+ icoads_x = [self.to_tensor(i) for i in icoads_x]
+ icoads_y = self.to_tensor(icoads_y)
+ icoads_y = self.norm_data(icoads_y, self.icoads_means, self.icoads_stds)
+
+ # GRIDSAT
+ sat_y = self.sat_y[index + self.sat_index_offset, ...]
+ sat_x = [self.to_tensor(i) for i in self.sat_x]
+ sat_y = self.to_tensor(sat_y)
+ sat_y = self.norm_data(sat_y, self.sat_means, self.sat_stds)
+
+ # AMSU-A
+ amsua_y = self.to_tensor(self.amsua_y[index + self.amsua_index_offset, ...])
+ amsua_y[amsua_y < -998] = torch.nan
+ amsua_x = [self.to_tensor(i) for i in self.amsua_x]
+ amsua_y[amsua_y < -998] = np.nan
+ amsua_y = self.norm_data(amsua_y, self.amsua_means, self.amsua_stds)
+
+ # AMSU-B
+ amsub_y = self.to_tensor(self.amsub_y[index + self.amsub_index_offset, ...])
+ amsub_y[amsub_y < -998] = torch.nan
+ amsub_x = [self.to_tensor(i) for i in self.amsub_x]
+ amsub_y[amsub_y < -998] = np.nan
+ amsub_y = self.norm_data(amsub_y, self.amsub_means, self.amsub_stds)
+
+ # IASI
+ iasi_y = self.to_tensor(self.iasi[index + self.iasi_index_offset, ...])
+ iasi_x = [self.to_tensor(i) for i in self.iasi_x]
+ iasi_y = self.norm_data(iasi_y, self.iasi_means, self.iasi_stds)
+
+ # IGRA
+ igra_y = self.to_tensor(self.igra_y[index + self.igra_index_offset, ...])
+ igra_x = [self.igra_x[:, 0], self.igra_x[:, 1]]
+ igra_x = [self.to_tensor(i) for i in igra_x]
+ igra_y = self.norm_data(igra_y, self.igra_means, self.igra_stds)
+
+ # ASCAT
+ ascat_y = self.to_tensor(self.ascat_y[index + self.ascat_index_offset, ...])
+ ascat_x = [self.to_tensor(i) for i in self.ascat_x]
+ ascat_y[..., 4][ascat_y[..., 4] < -990] = np.nan
+ ascat_y = self.norm_data(ascat_y, self.ascat_means, self.ascat_stds)
+
+ # HIRS
+ hirs_y = self.to_tensor(self.hirs_y[index + self.hirs_index_offset, ...])
+ hirs_y[hirs_y < -998] = np.nan
+ hirs_x = [self.to_tensor(i) for i in self.hirs_x]
+ hirs_y = self.norm_data(hirs_y, self.hirs_means, self.hirs_stds)
+
+ # HadISD
+ x_context_hadisd = self.hadisd_x
+ y_context_hadisd = [
+ i[index + self.hadisd_index_offset, :] for i in self.hadisd_y
+ ]
+ x_context_hadisd = [self.to_tensor(i).permute(1, 0) for i in x_context_hadisd]
+ y_context_hadisd = [self.to_tensor(i) for i in y_context_hadisd]
+ y_context_hadisd = self.norm_hadisd(y_context_hadisd)
+
+ # ERA5
+ era5 = self.to_tensor(self.load_era5_time(index))
+ era5_target = era5.permute(2, 1, 0)
+ era5_x = self.era5_x
+
+ # AUxiliary variables
+ aux_time = self.to_tensor(self.get_time_aux(date))
+ climatology = self.climatology[date.hour // 6, date.dayofyear - 1, ...]
+
+ task = {
+ "x_context_hadisd_{}".format(prefix): x_context_hadisd,
+ "y_context_hadisd_{}".format(prefix): y_context_hadisd,
+ "climatology_{}".format(prefix): self.to_tensor(climatology),
+ "sat_x_{}".format(prefix): sat_x,
+ "sat_{}".format(prefix): sat_y,
+ "icoads_x_{}".format(prefix): icoads_x,
+ "icoads_{}".format(prefix): icoads_y,
+ "igra_x_{}".format(prefix): igra_x,
+ "igra_{}".format(prefix): igra_y,
+ "amsua_{}".format(prefix): amsua_y,
+ "amsua_x_{}".format(prefix): amsua_x,
+ "amsub_{}".format(prefix): amsub_y,
+ "amsub_x_{}".format(prefix): amsub_x,
+ "iasi_{}".format(prefix): iasi_y,
+ "iasi_x_{}".format(prefix): iasi_x,
+ "ascat_{}".format(prefix): ascat_y,
+ "ascat_x_{}".format(prefix): ascat_x,
+ "hirs_{}".format(prefix): hirs_y,
+ "hirs_x_{}".format(prefix): hirs_x,
+ "y_target_{}".format(prefix): era5_target[
+ ..., self.var_start : self.var_end
+ ],
+ "era5_x_{}".format(prefix): era5_x,
+ "era5_elev_{}".format(prefix): self.era5_elev,
+ "era5_lonlat_{}".format(prefix): self.era5_lonlat,
+ "aux_time_{}".format(prefix): aux_time,
+ "lt": torch.Tensor([self.var_start]),
+ }
+
+ return task
+
+
+class HadISDDataset(Dataset):
+ """
+ HadISD dataset for decoder training
+ """
+
+ def __init__(self, var, mode, device, start_date, end_date):
+ super().__init__()
+
+ # Setup
+ if not mode in ["train", "val", "test"]:
+ raise Exception(f"mode is {mode}. Must be train, val, or test.")
+
+ self.var = var
+ self.mode = mode
+ self.start_date = start_date
+ self.device = device
+ dates = pd.date_range(start_date, end_date, freq="6H")
+ self.index = np.array(range(len(dates)))
+
+ # Load the hadISD data
+ self.load_hadisd()
+
+ def load_hadisd(self):
+ """
+ Load the raw HadISD data
+ """
+
+ data_path = "path_to_data/"
+ aux_data_path = "path_to_auxiliary_data/"
+ var = self.var
+ mode = self.mode
+
+ vals = np.memmap(
+ data_path + f"hadisd_processed/{var}_vals_{mode}.memmap",
+ dtype="float32",
+ mode="r",
+ shape=get_hadisd_shape(mode),
+ )
+
+ lon = lon_to_0_360(
+ np.load(data_path + f"hadisd_processed/{var}_lon_{mode}.npy")
+ )
+ lat = np.load(data_path + f"hadisd_processed/{var}_lat_{mode}.npy")
+ self.hadisd_x = np.stack([lon, lat], axis=-1) / LATLON_SCALE_FACTOR
+ self.hadisd_alt = np.load(
+ data_path + f"hadisd_processed/{var}_alt_{mode}_final.npy"
+ )
+ self.hadisd_y = vals
+
+ self.hadisd_index_offset = HADISD_OFFSETS[self.start_date]
+ self.hadisd_means = self.to_tensor(
+ np.load(aux_data_path + f"norm_factors/mean_hadisd_{var}.npy")
+ )
+ self.hadisd_stds = self.to_tensor(
+ np.load(aux_data_path + f"norm_factors/std_hadisd_{var}.npy")
+ )
+ return
+
+ def norm_hadisd(self, x):
+ return (x - self.hadisd_means) / self.hadisd_stds
+
+ def unnorm_pred(self, x):
+ return self.hadisd_means + self.hadisd_stds * x
+
+ def __len__(self):
+ return self.index.shape[0] - 2
+
+ def to_tensor(self, arr):
+ return torch.from_numpy(np.array(arr)).float().to(self.device)
+
+ def __getitem__(self, index):
+ index = self.index[index]
+
+ # Get longitude-latitude locations
+ x_target = self.to_tensor(self.hadisd_x).permute(1, 0)
+
+ # Get altitude and normalise
+ m_alt = np.expand_dims(np.load("path_to_mean_alt.npy"), 1)
+ s_alt = np.expand_dims(np.load("path_to_std_alt.npy"), 1)
+ alt_target = self.to_tensor((self.hadisd_alt - m_alt) / s_alt)[:, :]
+
+ # Get observations
+ y_target = self.norm_hadisd(
+ self.to_tensor(self.hadisd_y[index + self.hadisd_index_offset, :])
+ )
+
+ assert x_target.shape[0] == 2
+ n_stations = x_target.shape[1]
+ assert alt_target.shape[1] == n_stations
+ assert y_target.shape[0] == n_stations
+
+ return {"x": x_target, "altitude": alt_target, "y": y_target}
+
+
+class AardvarkICDataset(Dataset):
+ """
+ Helper dataset to handle initial condition loading for decoder training
+ """
+
+ def __init__(self, device, start_date, end_date, lead_time=0):
+ super().__init__()
+
+ # Setup
+
+ if lead_time == 0:
+ # If leadtime is 0 load the output of the encoder
+ if start_date == "2007-01-02" and end_date == "2017-12-31":
+ ic_fname = "ic_train.mmap"
+ elif start_date == "2019-01-01" and end_date == "2019-12-01":
+ ic_fname = "ic_val.mmap"
+ elif start_date == "2018-01-01" and end_date == "2018-12-31":
+ ic_fname = "ic_test.mmap"
+ else:
+ print((start_date, end_date))
+ raise Exception("Invalid start and end date")
+
+ dates = pd.date_range(start_date, end_date, freq="6H")
+
+ self.data = np.memmap(
+ "path_to_encoder_predictions/" + ic_fname,
+ dtype="float32",
+ mode="r",
+ shape=(len(dates), 121, 240, 24), # shape of the output
+ )
+ else:
+ # if leadtime >0 load the forecast generated from the encoder prediction
+ if start_date == "2007-01-02" and end_date == "2017-12-31":
+ ic_fname = f"ic_train_{lead_time}.mmap"
+
+ elif start_date == "2019-01-01" and end_date == "2019-12-01":
+ ic_fname = f"ic_val_{lead_time}.mmap"
+ elif start_date == "2018-01-01" and end_date == "2018-12-31":
+ ic_fname = f"ic_test_{lead_time}.mmap"
+ else:
+ print((start_date, end_date))
+ raise Exception("Invalid start and end date.")
+
+ dates = pd.date_range(start_date, end_date, freq="6H")[(lead_time) * 4 :]
+ ic_shape = (len(dates), 121, 240, 24)
+
+ self.data = np.memmap(
+ self.data_path + "forecast_finetune/" + ic_fname,
+ dtype="float32",
+ mode="r",
+ shape=ic_shape,
+ )
+
+ self.device = device
+
+ # Normalisation
+ aux_data_path = "path_to_auxiliary_data/"
+ mean_factors_path = aux_data_path + f"norm_factors/mean_4u_1.npy"
+ std_factors_path = aux_data_path + f"norm_factors/std_4u_1.npy"
+ self.means = np.load(mean_factors_path)[:, np.newaxis, np.newaxis, ...]
+ self.stds = np.load(std_factors_path)[:, np.newaxis, np.newaxis, ...]
+
+ def __getitem__(self, index):
+ # Load Aardvark prediction and normalise
+ data_raw = np.transpose(np.copy(self.data[index, :, :, :]), (2, 1, 0))
+ data = (data_raw - self.means) / self.stds
+ return torch.from_numpy(data).to(self.device)
+
+
+class WeatherDatasetDownscaling(Dataset):
+ """
+ Main decoder training dataset. Uses AardvarkICDataset and HadISDDataset to
+ handle processor output and station data
+ """
+
+ def __init__(
+ self,
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ context_mode,
+ era5_mode="sfc",
+ res=1,
+ hadisd_var="tas",
+ lead_time=1,
+ ):
+ # The context mode determines whether we make use of ERA5 or our own ICs.
+ if not context_mode in ["era5", "aardvark"]:
+ raise Exception(
+ f"context_mode must be era5 or aardvark, got {context_mode}"
+ )
+
+ super().__init__()
+
+ # Setup
+ self.lead_time = lead_time
+
+ self.device = device
+ self.data_path = "path_to_data/"
+ self.aux_data_path = "path_to_auxiliary_data/"
+ self.start_date = start_date
+ self.end_date = end_date
+ self.era5_mode = era5_mode
+ self.res = res
+ self.context_mode = context_mode
+
+ self.dates = pd.date_range(start_date, end_date, freq="6H")
+ self.index = np.array(range(len(self.dates)))
+
+ # Load ERA5 data for pre-training
+ self.era5_sfc = [
+ self.load_era5(year)
+ for year in range(int(start_date[:4]), int(end_date[:4]) + 1)
+ ]
+
+ raw_era5_lon = np.load(self.data_path + f"era5/era5_x_{res}.npy")
+ raw_era5_lat = np.load(self.data_path + f"era5/era5_y_{res}.npy")
+ self.era5_x = [
+ self.to_tensor(raw_era5_lon) / LATLON_SCALE_FACTOR,
+ self.to_tensor(raw_era5_lat) / LATLON_SCALE_FACTOR,
+ ]
+
+ # Load orography
+ elev_path = self.data_path + f"era5/elev_vars_{res}.npy"
+ self.era5_elev = self.to_tensor(np.load(elev_path)).permute(0, 2, 1)
+
+ # Normalisation
+ mean_factors_path = (
+ self.aux_data_path + f"norm_factors/mean_{era5_mode}_{res}.npy"
+ )
+ std_factors_path = (
+ self.aux_data_path + f"norm_factors/std_{era5_mode}_{res}.npy"
+ )
+ self.means = np.load(mean_factors_path)[:, np.newaxis, np.newaxis, ...]
+ self.stds = np.load(std_factors_path)[:, np.newaxis, np.newaxis, ...]
+
+ # HadISD data
+ self.hadisd_data = HadISDDataset(
+ var=hadisd_var,
+ mode=hadisd_mode,
+ device=device,
+ start_date=start_date,
+ end_date=end_date,
+ )
+
+ if context_mode == "aardvark":
+ # Load the Aardvark encoder predictions
+ self.aardvark_data = AardvarkICDataset(
+ device, start_date, end_date, lead_time
+ )
+
+ def load_era5(self, year):
+ """
+ Load the raw ERA5 data
+ """
+
+ if year % 4 == 0:
+ d = 366 * 4
+ else:
+ d = 365 * 4
+
+ if self.era5_mode == "sfc":
+ levels = 4
+ elif self.era5_mode == "13u":
+ levels = 69
+ else:
+ levels = 24
+
+ if self.res == 1:
+ x = 240
+ y = 121
+ elif self.res == 5:
+ x = 64
+ y = 32
+ mmap = np.memmap(
+ self.data_path
+ + "era5/era5_{}_{}_6_{}.memmap".format(self.era5_mode, self.res, year),
+ dtype="float32",
+ mode="r",
+ shape=(d, levels, x, y),
+ )
+ return mmap
+
+ def norm_era5(self, x):
+ x = (x - self.means) / self.stds
+ return x
+
+ def unnorm_era5(self, x):
+ x = x * self.stds + self.means
+ return x
+
+ def unnorm_pred(self, x):
+ return self.hadisd_data.unnorm_pred(x)
+
+ def norm_data(self, x, means, stds):
+ return (x - means) / stds
+
+ def __len__(self):
+ return self.index.shape[0] - (self.lead_time) * 4
+
+ def to_tensor(self, arr):
+ return torch.from_numpy(np.array(arr)).float().to(self.device)
+
+ def get_time_aux(self, current_date):
+ """
+ Get auxiliary time variables for a given date
+ """
+
+ doy = current_date.dayofyear
+ year = (current_date.year - 2007) / 15
+ time_of_day = current_date.hour
+ return np.array(
+ [
+ np.cos(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.sin(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.cos(np.pi * 2 * time_of_day / 24),
+ np.sin(np.pi * 2 * time_of_day / 24),
+ year,
+ ]
+ )
+
+ def load_era5_time(self, index):
+ """
+ Load ERA5 training data
+ """
+
+ date = self.dates[index]
+ year = date.year
+ hour = date.hour
+ doy = (date.dayofyear - 1) * 4 + (hour // 6)
+
+ era5 = self.era5_sfc[year - int(self.start_date[:4])][doy, ...]
+ era5 = np.copy(era5)
+ era5 = self.norm_era5(era5[np.newaxis, ...])[0, ...]
+ return era5
+
+ def load_year_end(self, year, doy):
+ data_1 = self.era5_sfc[year - int(self.start_date[:4])][doy : doy + 1, ...]
+ missing = self.lead_time - data_1.shape[0] + 1
+ data_2 = self.era5_sfc[year - int(self.start_date[:4]) + 1][:missing, ...]
+ data = np.concatenate([data_1, data_2])
+ return data
+
+ def __getitem__(self, index):
+
+ index = self.index[index]
+ date = self.dates[index + 4 * self.lead_time]
+
+ # Get HadISD data
+ hadisd_slice = self.hadisd_data[index + 4 * self.lead_time]
+
+ # Get lon-lat
+ x_context = self.era5_x
+ n_lon = x_context[0].shape[0]
+ n_lat = x_context[1].shape[0]
+
+ # Get auxiliary time
+ aux_time = torch.reshape(self.to_tensor(self.get_time_aux(date)), (-1, 1, 1))
+
+ # Load the context (either aardvark or ERA5 for use in pre-training)
+ if self.context_mode == "era5":
+ y_context_obs = self.to_tensor(
+ self.load_era5_time(index + 4 * self.lead_time)
+ )
+
+ elif self.context_mode == "aardvark":
+ y_context_obs = self.aardvark_data[index]
+
+ else:
+ raise Exception
+
+ y_context = torch.cat(
+ [
+ y_context_obs,
+ self.era5_elev.permute(0, 2, 1),
+ aux_time.repeat(1, n_lon, n_lat),
+ ]
+ )
+
+ assert y_context.shape[1] == n_lon
+ assert y_context.shape[2] == n_lat
+
+ x = hadisd_slice["x"]
+ alt = hadisd_slice["altitude"]
+ y = hadisd_slice["y"]
+
+ return {
+ "x_target": x,
+ "alt_target": alt,
+ "y_target": y,
+ "y_context": y_context,
+ "x_context": x_context,
+ "aux_time": aux_time,
+ "lt": torch.Tensor([0]),
+ }
+
+
+class ForecasterDatasetDownscaling(Dataset):
+ """
+ Dataset to generate decoder predictions from pre-saved Aardvark forecasts
+ """
+
+ def __init__(
+ self,
+ start_date,
+ end_date,
+ lead_time,
+ hadisd_var,
+ mode,
+ device,
+ forecast_path,
+ region="global",
+ ):
+ super().__init__()
+
+ # Setup
+
+ if not mode in ["train", "val", "test"]:
+ raise Exception(f"Mode is {mode}. Must be either train, val, or test")
+
+ self.device = device
+ self.start_date = start_date
+ self.end_date = end_date
+ self.lead_time = lead_time
+ self.mode = mode
+ self.offset = np.timedelta64(lead_time, "D").astype("timedelta64[ns]")
+
+ self.dates = pd.date_range(start_date, end_date, freq="6H")[:-30]
+
+ # Normalisation
+ aux_data_path = "auxiliary_data_path/"
+ self.means = np.load(aux_data_path + "norm_factors/mean_4u_1.npy")
+ self.stds = np.load(aux_data_path + "norm_factors/std_4u_1.npy")
+
+ # Load auxiliary data
+ self.load_npy_file()
+ data_path = "data_path/"
+ res = "1"
+ raw_era5_lon = np.load(data_path + f"era5/era5_x_{res}.npy")
+ raw_era5_lat = np.load(data_path + f"era5/era5_y_{res}.npy")
+ self.era5_x = [
+ self.to_tensor(raw_era5_lon) / LATLON_SCALE_FACTOR,
+ self.to_tensor(raw_era5_lat) / LATLON_SCALE_FACTOR,
+ ]
+ elev_path = data_path + f"era5/elev_vars_{res}.npy"
+ self.era5_elev = self.to_tensor(np.load(elev_path)).permute(0, 2, 1)
+
+ # Load hadISD
+ self.hadisd_data = HadISDDataset(
+ var=hadisd_var,
+ mode="train",
+ device=device,
+ start_date=start_date,
+ end_date=end_date,
+ )
+
+ # Subset to region
+ self.region = region
+ if self.region != "global":
+ self.mask = np.load(
+ self.data_path + f"hadisd_processed/tas_mask_train_{region}.npy"
+ )
+
+ def date_range(self):
+ return np.arange(
+ start=np.datetime64(self.start_date).astype("datetime64[ns]"),
+ stop=np.datetime64(self.end_date).astype("datetime64[ns]"),
+ step=np.timedelta64(1, "D").astype("timedelta64[ns]"),
+ )
+
+ def load_npy_file(self):
+ """
+ Load the pre-saved Aardvark forecasts
+ """
+
+ dates = pd.date_range(self.start_date, self.end_date, freq="6H")
+
+ if self.mode == "train":
+ dates = dates[:-40] # Need 10 day offset at end of year
+
+ self.Y_context = np.memmap(
+ "path_to_forecasts/forecast_{}.mmap".format(self.mode),
+ dtype="float32",
+ mode="r",
+ shape=(len(dates), 121, 240, 24, 11),
+ )
+
+ return
+
+ def norm_era5(self, x):
+ return (x - self.means) / self.stds
+
+ def norm_hadisd(self, x):
+ return self.hadisd_data.norm_hadisd(x)
+
+ def unnorm_pred(self, x):
+ return self.hadisd_data.unnorm_pred(x)
+
+ def __len__(self):
+ return len(self.dates) - 40 # Need 10 day offset at end of year
+
+ def to_tensor(self, arr):
+ return torch.from_numpy(np.array(arr)).float().to(self.device)
+
+ def get_time_aux(self, index):
+ """
+ Get the auxiliary time variables
+ """
+
+ current_date = (self.dates + self.offset)[index]
+ doy = current_date.dayofyear
+ year = (current_date.year - 2007) / 15
+ time_of_day = current_date.hour
+ return np.array(
+ [
+ np.cos(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.sin(np.pi * 2 * doy / DAYS_IN_YEAR),
+ np.cos(np.pi * 2 * time_of_day / 24),
+ np.sin(np.pi * 2 * time_of_day / 24),
+ year,
+ ]
+ )
+
+ def __getitem__(self, index):
+
+ # Load target data
+ hadisd_slice = self.hadisd_data[index + 4 * self.lead_time]
+
+ x_context = self.era5_x
+ n_lon = x_context[0].shape[0]
+ n_lat = x_context[1].shape[0]
+
+ # Load auxiliary time
+ aux_time = torch.reshape(self.to_tensor(self.get_time_aux(index)), (-1, 1, 1))
+
+ # Load input
+ y_context = self.norm_era5(self.Y_context[index, ..., self.lead_time])
+ y_context = torch.cat(
+ [
+ self.to_tensor(y_context).permute(2, 1, 0),
+ self.era5_elev.permute(0, 2, 1),
+ aux_time.repeat(1, n_lon, n_lat),
+ ]
+ )
+
+ assert y_context.shape[1] == n_lon
+ assert y_context.shape[2] == n_lat
+
+ # Handle region masking
+ if self.region != "global":
+ hadisd_slice["y"][self.mask] = np.nan
+
+ return {
+ "x_target": hadisd_slice["x"],
+ "alt_target": hadisd_slice["altitude"],
+ "y_target": hadisd_slice["y"],
+ "y_context": y_context,
+ "x_context": x_context,
+ "aux_time": aux_time,
+ "lt": torch.Tensor([0]),
+ }
+
+
+class ForecastLoader(Dataset):
+ """
+ Loader for finetuning the processor module
+ """
+
+ def __init__(
+ self,
+ device,
+ mode,
+ lead_time,
+ era5_mode="sfc",
+ res=5,
+ frequency=24,
+ norm=True,
+ diff=False,
+ rollout=False,
+ random_lt=False,
+ u_only=False,
+ ic_path=None,
+ finetune_step=None,
+ finetune_eval_every=100,
+ eval_steps=False,
+ ):
+
+ super().__init__()
+
+ # Setup
+ self.device = device
+ self.mode = mode
+ self.data_path = "data_path/"
+
+ self.lead_time = lead_time
+ self.era5_mode = era5_mode
+ self.res = res
+ self.frequency = frequency
+ self.norm = norm
+ self.diff = diff
+ self.rollout = rollout
+ self.random_lt = random_lt
+ self.u_only = u_only
+ self.ic_path = ic_path
+
+ self.finetune_step = finetune_step
+ self.finetune_eval_every = finetune_eval_every
+ self.eval_steps = eval_steps
+
+ if self.frequency == 6:
+ self.lead_time = self.lead_time * 4
+ freq = "6H"
+
+ else:
+ freq = "1D"
+
+ if self.mode == "train":
+ self.dates = pd.date_range("1979-01-01", "2017-12-31", freq=freq)
+ elif self.mode == "tune":
+ self.dates = pd.date_range("2018-01-01", "2018-12-31", freq=freq)
+ elif self.mode == "test":
+ self.dates = pd.date_range("2018-01-01", "2018-12-31", freq=freq)
+ elif self.mode == "val":
+ self.dates = pd.date_range("2019-01-01", "2019-12-31", freq=freq)
+
+ # Load the predictions from the previous leadtime to be the new context set
+ if self.finetune_step is not None:
+
+ if self.mode == "train":
+ self.dates = pd.date_range("2007-01-02", "2017-12-31", freq=freq)
+ ic_shape = (
+ len(self.dates) - max(0, (self.finetune_step - 1) * 4),
+ 121,
+ 240,
+ 24,
+ )
+ elif self.mode == "val":
+ self.dates = pd.date_range("2019-01-01", "2019-12-31", freq=freq)
+ ic_shape = (
+ len(self.dates) - max(0, (self.finetune_step - 1) * 4),
+ 121,
+ 240,
+ 24,
+ )
+ elif self.mode == "test":
+ self.dates = pd.date_range("2018-01-01", "2018-12-31", freq=freq)
+ ic_shape = (
+ len(self.dates) - max(0, (self.finetune_step - 1) * 4),
+ 121,
+ 240,
+ 24,
+ )
+
+ if self.finetune_step > 1:
+ print(ic_shape)
+ self.ic = np.memmap(
+ self.ic_path
+ + "ic_{}_{}.mmap".format(self.mode, self.finetune_step - 1),
+ dtype="float32",
+ mode="r",
+ shape=ic_shape,
+ )
+ elif self.ic_path is not None:
+
+ self.ic = np.memmap(
+ self.ic_path + "ic_{}.mmap".format(self.mode),
+ dtype="float32",
+ mode="r",
+ shape=ic_shape,
+ )
+
+ elif self.ic_path is not None:
+ if self.mode == "train":
+ self.dates = pd.date_range("2007-01-02", "2017-12-31", freq=freq)
+ ic_shape = (len(self.dates), 121, 240, 24)
+
+ self.ic = np.memmap(
+ self.ic_path + "/ic_{}.mmap".format(self.mode),
+ dtype="float32",
+ mode="r",
+ shape=ic_shape,
+ )
+
+ # Orography
+ self.era5_elev = np.float32(
+ np.load(self.data_path + "era5/elev_vars_{}.npy".format(res))
+ )
+ elev_mean = self.era5_elev.mean(axis=(1, 2))[:, np.newaxis, np.newaxis]
+ elev_std = self.era5_elev.std(axis=(1, 2))[:, np.newaxis, np.newaxis]
+ self.era5_elev = (self.era5_elev - elev_mean) / elev_std
+
+ # ERA5 ground truth data for training
+ self.era5_sfc = [
+ self.load_era5(year)
+ for year in range(int(self.dates[0].year), int(self.dates[-1].year) + 1)
+ ]
+
+ # Noramalisation factors
+ self.means = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/mean_{}_{}.npy".format(self.era5_mode, self.res)
+ )
+ )
+ .unsqueeze(1)
+ .unsqueeze(1)
+ )
+ self.stds = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/std_{}_{}.npy".format(self.era5_mode, self.res)
+ )
+ )
+ .unsqueeze(1)
+ .unsqueeze(1)
+ )
+ self.diff_means = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/mean_diff_{}_{}.npy".format(
+ self.era5_mode, self.res
+ )
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+ self.diff_stds = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/std_diff_{}_{}.npy".format(self.era5_mode, self.res)
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+
+ self.diff_means_1 = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/mean_diff_{}_{}_6h.npy".format(
+ self.era5_mode, self.res
+ )
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+ self.diff_stds_1 = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/std_diff_{}_{}_6h.npy".format(
+ self.era5_mode, self.res
+ )
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+
+ self.diff_means_2 = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/mean_diff_{}_{}_12h.npy".format(
+ self.era5_mode, self.res
+ )
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+ self.diff_stds_2 = (
+ self.to_tensor(
+ np.load(
+ self.data_path
+ + "norm_factors/std_diff_{}_{}_12h.npy".format(
+ self.era5_mode, self.res
+ )
+ )
+ )
+ .unsqueeze(0)
+ .unsqueeze(0)
+ )
+
+ self.means_dict = {
+ 0: self.diff_means,
+ 2: self.diff_means_2,
+ 3: self.diff_means_1,
+ }
+
+ self.stds_dict = {0: self.diff_stds, 2: self.diff_stds_2, 3: self.diff_stds_1}
+
+ def __len__(self):
+ if np.logical_and(self.eval_steps, self.mode == "train"):
+ return self.finetune_eval_every * 12 * 4
+
+ return self.dates.shape[0] - self.lead_time
+
+ def to_tensor(self, arr):
+
+ return torch.from_numpy(arr).float().to(self.device)
+
+ def norm_era5(self, x):
+ x = (x - self.means) / self.stds
+ return x
+
+ def norm_era5_tendency(self, x, lt_offset):
+
+ x = (x - self.means_dict[lt_offset]) / self.stds_dict[lt_offset]
+ return x
+
+ def unnorm_pred(self, x):
+ x = x * self.diff_stds.unsqueeze(0) + self.diff_means.unsqueeze(0)
+ return x
+
+ def unnorm_base_context(self, x):
+ x = x * self.stds.unsqueeze(0) + self.means.unsqueeze(0)
+ return x
+
+ def load_era5(self, year):
+ """
+ Load ERA5 data for training
+ """
+
+ if year % 4 == 0:
+ d = 366
+ else:
+ d = 365
+
+ if self.frequency == 6:
+ d = d * 4
+
+ if self.era5_mode == "sfc":
+ levels = 4
+ elif self.era5_mode == "13u":
+ levels = 69
+ else:
+ levels = 24
+
+ if self.res == 1:
+ x = 240
+ y = 121
+ elif self.res == 5:
+ x = 64
+ y = 32
+
+ mmap = np.memmap(
+ self.data_path
+ + "era5/era5_{}_{}_{}_{}.memmap".format(
+ self.era5_mode, self.res, self.frequency, year
+ ),
+ dtype="float32",
+ mode="r",
+ shape=(d, levels, x, y),
+ )
+ return mmap
+
+ def load_era5_time(self, index):
+ """
+ Load ERA5 data for training
+ """
+ date = self.dates[index]
+ year = date.year
+ doy = date.dayofyear - 1
+ hour = date.hour
+ if self.frequency == 6:
+ era5 = self.era5_sfc[year - int(self.dates[0].year)][
+ doy * 4 + hour // 6, ...
+ ]
+ else:
+ era5 = self.era5_sfc[year - int(self.dates[0].year)][doy, ...]
+
+ return np.copy(era5)
+
+ def make_time_channels(self, index, x, y):
+ """
+ Make auxiliary time channels
+ """
+
+ date = self.dates[index]
+ hour = date.hour
+ doy = date.dayofyear - 1
+ if date.year % 4 == 0:
+ n_days = 366
+ else:
+ n_days = 365
+ hour_sin = np.sin(hour * np.pi / 12) * np.float32(np.ones((1, x, y)))
+ hour_cos = np.cos(hour * np.pi / 12) * np.float32(np.ones((1, x, y)))
+ doy_sin = np.sin(doy * 2 * np.pi / n_days) * np.float32(np.ones((1, x, y)))
+ doy_cos = np.cos(doy * 2 * np.pi / n_days) * np.float32(np.ones((1, x, y)))
+
+ return np.concatenate([hour_sin, hour_cos, doy_sin, doy_cos])
+
+ def __getitem__(self, index):
+
+ # Option to offset to random leadtime
+ lt_offset = 0
+ if self.random_lt:
+ lt_offset = np.random.choice([0, 2, 3])
+
+ # Load ground truth data
+ y_target = self.to_tensor(
+ self.load_era5_time(index + self.lead_time - lt_offset)
+ )
+
+ # Load either initial condition or ERA5 depending on task
+ if self.ic_path is not None:
+ era5_ts0 = self.ic[index].copy().transpose(2, 1, 0)
+
+ else:
+ era5_ts0 = self.load_era5_time(index)
+
+ # Auxiliary time
+ time = self.make_time_channels(index, era5_ts0.shape[1], era5_ts0.shape[2])
+ era5_ts0 = self.to_tensor(
+ np.concatenate([era5_ts0, self.era5_elev, time], axis=0)
+ )
+ y_context = era5_ts0.permute(0, 2, 1)[:, ...]
+
+ # Normalisation
+ if self.diff:
+ y_target = (y_target - era5_ts0[:24, ...]).permute(2, 1, 0)
+ y_target = self.norm_era5_tendency(y_target, lt_offset)
+ y_context[:24, ...] = self.norm_era5(y_context[:24, ...])
+
+ else:
+ if self.norm:
+ y_context[:24, ...] = self.norm_era5(y_context[:24, ...], lt_offset)
+ y_target = self.norm_era5(y_target, lt_offset)
+ y_target = y_target.permute(2, 1, 0)
+
+ if self.rollout:
+ # Option to return entire timeseries of target data
+ targets = []
+ for t in range(self.lead_time + 1):
+ t = self.to_tensor(self.load_era5_time(index + t))
+ targets.append(t.permute(2, 1, 0))
+ targets = torch.stack(targets, dim=-1)[..., ::4]
+
+ return {
+ "y_context": y_context.permute(0, 2, 1),
+ "y_target": y_target,
+ "targets": targets,
+ "lt": self.to_tensor(np.array([lt_offset])),
+ }
+
+ else:
+ return {
+ "y_context": y_context.permute(0, 2, 1),
+ "y_target": y_target[..., :],
+ "lt": self.to_tensor(np.array([lt_offset])),
+ "target_index": self.to_tensor(np.array([index])),
+ }
+
+
+class WeatherDatasetE2E(WeatherDataset):
+ """
+ Dataset for running Aardvark end-to-end
+ """
+
+ def __init__(
+ self,
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ lead_time,
+ mode,
+ hadisd_var,
+ max_steps_per_epoch=None,
+ era5_mode="sfc",
+ res=1,
+ filter_dates=None,
+ var_start=0,
+ var_end=24,
+ diff=False,
+ two_frames=False,
+ region="global",
+ ):
+
+ super().__init__(
+ device,
+ hadisd_mode,
+ start_date,
+ end_date,
+ lead_time,
+ era5_mode,
+ res=res,
+ filter_dates=filter_dates,
+ diff=diff,
+ )
+
+ # Setup
+ self.var_start = var_start
+ self.var_end = var_end
+ self.diff = diff
+ self.two_frames = two_frames
+ self.region = region
+ self.lead_time = lead_time
+ self.mode = mode
+ self.max_steps_per_epoch = max_steps_per_epoch
+
+ # Initialise encoder dataset
+ self.assimilation_dataset = WeatherDatasetAssimilation(
+ device="cuda",
+ hadisd_mode="train",
+ start_date=start_date,
+ end_date=end_date,
+ lead_time=0,
+ era5_mode="4u",
+ res=1,
+ var_start=0,
+ var_end=24,
+ diff=False,
+ two_frames=False,
+ )
+
+ # Initialise forecast dataset
+ self.forecast_dataset = ForecastLoader(
+ device="cuda",
+ mode=mode,
+ lead_time=lead_time,
+ era5_mode=era5_mode,
+ res=1,
+ frequency=6,
+ diff=True,
+ u_only=False,
+ random_lt=False,
+ )
+
+ # Initialise downscaling dataset
+ self.downscaling_dataset = ForecasterDatasetDownscaling(
+ start_date=start_date,
+ end_date=end_date,
+ lead_time=lead_time,
+ hadisd_var=hadisd_var,
+ mode=mode,
+ device=device,
+ forecast_path=None,
+ region=region,
+ )
+
+ def __len__(self):
+ if self.max_steps_per_epoch:
+ return self.max_steps_per_epoch
+ return len(self.downscaling_dataset) - 40 # Need 10 day offset at end of year
+
+ def __getitem__(self, index):
+
+ if self.max_steps_per_epoch:
+ index = np.random.choice(
+ np.arange(len(self.downscaling_dataset) - 40)
+ ) # Need 10 day offset at end of year
+
+ # Get data for each of the three datasets
+ assimilation = self.assimilation_dataset.__getitem__(index)
+ forecast = self.forecast_dataset.__getitem__(index)
+ downscaling = self.downscaling_dataset.__getitem__(index)
+
+ # Create task
+ task = {
+ "assimilation": assimilation,
+ "forecast": forecast,
+ "downscaling": downscaling,
+ "index": torch.tensor(index),
+ }
+
+ # Add y target to allow for end to end finetuning if needed
+ task["y_target"] = task["downscaling"]["y_target"]
+
+ return task
+
+ def unnorm_pred(self, x):
+
+ dev = x.device
+ x = x.detach().cpu().numpy()
+
+ x = (
+ x
+ * self.stds[np.newaxis, ...].transpose(0, 2, 3, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ + self.means[np.newaxis, ...].transpose(0, 2, 3, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ )
+ if bool(self.diff):
+ x = (
+ x
+ + self.era5_mean_spatial[np.newaxis, ...].transpose(0, 3, 2, 1)[
+ ..., self.var_start : self.var_end
+ ]
+ )
+ return torch.from_numpy(x).float().to(dev)
diff --git a/official-src/aardvark/loader_utils_new.py b/official-src/aardvark/loader_utils_new.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1d55d18404a9dd40751f1b7009c42ad91bcf446
--- /dev/null
+++ b/official-src/aardvark/loader_utils_new.py
@@ -0,0 +1,88 @@
+import numpy as np
+import torch
+import pandas as pd
+
+LATLON_SCALE_FACTOR = 360
+DAYS_IN_YEAR = 366
+
+DAILY_SCALE_FACTOR = {
+ "ERA5": 4,
+ "HADISD": 4,
+ "IR": 4,
+ "SOUNDER": 1,
+ "ICOADS": 1,
+}
+
+date_list = [
+ "1979-01-01",
+ "1999-01-01",
+ "1999-01-02",
+ "2002-01-02",
+ "2007-01-01",
+ "2007-01-02",
+ "2007-01-03",
+ "2013-01-02",
+ "2014-01-01",
+ "2017-01-02",
+ "2018-01-01",
+ "2019-01-01",
+ "2020-01-02",
+ "2020-01-01",
+ "2021-01-02",
+ "2021-01-01",
+]
+
+
+def generate_offsets(date_list, dates):
+ offsets = {}
+ for d in date_list:
+ try:
+ offsets[d] = np.where(dates == d)[0][0]
+ except:
+ offsets[d] = -1
+ return offsets
+
+
+IC_OFFSETS = generate_offsets(
+ date_list, pd.date_range("1999-01-02", "2021-12-31 18:00", freq="6H")
+)
+
+AMSUA_OFFSETS = generate_offsets(
+ date_list, pd.date_range("2007-01-01", "2021-12-31 18:00", freq="6H")
+)
+
+AMSUB_OFFSETS = generate_offsets(
+ date_list, pd.date_range("2007-01-01", "2021-12-31 18:00", freq="6H")
+)
+
+ASCAT_OFFSETS = generate_offsets(
+ date_list, pd.date_range("2007-01-01", "2021-12-31", freq="6H")
+)
+
+ATMS_OFFSETS = generate_offsets(
+ date_list, pd.date_range("2013-01-02", "2021-12-31", freq="1D")
+)
+
+ICOADS_OFFSETS = generate_offsets(
+ date_list, pd.date_range("1999-01-01 06:00", "2021-12-31", freq="6H")
+)
+
+IGRA_OFFSETS = generate_offsets(
+ date_list, pd.date_range("1999-01-01 00:00", "2021-12-31 18:00", freq="6H")
+)
+
+SAT_OFFSETS = generate_offsets(
+ date_list, pd.date_range("1990-01-01 00:00", "2021-12-31 18:00", freq="6H")
+)
+
+HADISD_OFFSETS = generate_offsets(
+ date_list, pd.date_range("1950-01-01 00:00", "2021-12-31 18:00", freq="6H")
+)
+
+
+def lon_to_0_360(x):
+ return (x + 360) % 360
+
+
+def lat_to_m90_90(x):
+ return torch.flip(x, [-1])
diff --git a/official-src/aardvark/loss_functions.py b/official-src/aardvark/loss_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e94347300fe16a0cc2d1f31400d252a6de2d49f
--- /dev/null
+++ b/official-src/aardvark/loss_functions.py
@@ -0,0 +1,166 @@
+import numpy as np
+import torch
+import torch.nn as nn
+
+
+class RmseLoss(nn.Module):
+ """
+ RMSE loss
+ """
+
+ def __init__(self, start_ind=0, end_ind=24):
+
+ super().__init__()
+ self.start_ind = start_ind
+ self.end_ind = end_ind
+
+ def forward(
+ self,
+ target,
+ output,
+ prev_step_output,
+ fix_sigma=False,
+ unwrap=False,
+ expand=False,
+ ):
+
+ squared_diff = ((target.to(output.device) - output) ** 2)[
+ ..., self.start_ind : self.end_ind
+ ]
+ return torch.mean(torch.sqrt(torch.nanmean(squared_diff, dim=(1, 2, 3))))
+
+
+class PressureWeightedRmseLoss(nn.Module):
+ """
+ Latitude weighted pressure weighted RMSE loss used in training the processor
+ """
+
+ def __init__(
+ self,
+ res,
+ era5_mode,
+ data_dir,
+ aux_data_dir,
+ weight_per_variable=False,
+ ):
+ super().__init__()
+
+ self.weights = torch.from_numpy(
+ np.load(aux_data_dir + "lat_weights/weights_lat_{}.npy".format(res)).T[
+ np.newaxis, ..., np.newaxis
+ ]
+ ).float()
+
+ self.weight_per_variable = weight_per_variable
+ self.variable_weights = torch.from_numpy(
+ np.load(aux_data_dir + "loss_weights.npy")[
+ np.newaxis, np.newaxis, np.newaxis, :
+ ]
+ ).float()
+
+ self.pressure_levels = (
+ torch.from_numpy(
+ np.load(
+ data_dir + "era5/era5_pressure_levels_{}.npy".format(era5_mode)
+ )[np.newaxis, np.newaxis, np.newaxis, :]
+ ).float()
+ / 1000
+ )
+
+ def forward(
+ self,
+ target,
+ output,
+ prev_step_output,
+ fix_sigma=False,
+ unwrap=False,
+ expand=False,
+ ):
+
+ squared_diff = (target.to(output.device) - output) ** 2
+
+ if not expand:
+ weighted_sqared_diff = (
+ squared_diff
+ * self.weights.to(target.device)
+ * self.pressure_levels.to(target.device)
+ )
+ return torch.mean(
+ torch.sqrt(torch.nanmean(weighted_sqared_diff, dim=(1, 2, 3)))
+ )
+
+ weighted_sqared_diff = squared_diff * self.weights.to(target.device)
+
+ if self.weight_per_variable:
+ weighted_sqared_diff = weighted_sqared_diff * self.variable_weights.to(
+ weighted_sqared_diff.device
+ )
+
+ return torch.mean(
+ torch.sqrt(torch.nanmean(weighted_sqared_diff, dim=(1, 2))), dim=0
+ )
+
+
+class WeightedRmseLoss(nn.Module):
+ """
+ Latitude weighted RMSE loss
+ """
+
+ def __init__(
+ self,
+ res,
+ data_dir,
+ aux_data_dir,
+ weight_per_variable=False,
+ start_ind=0,
+ end_ind=24,
+ ):
+
+ super().__init__()
+ self.start_ind = start_ind
+ self.end_ind = end_ind
+
+ self.weights = torch.from_numpy(
+ np.load(aux_data_dir + "lat_weights/weights_lat_{}.npy".format(res)).T[
+ np.newaxis, ..., np.newaxis
+ ]
+ ).float()
+
+ self.weight_per_variable = weight_per_variable
+ self.variable_weights = torch.from_numpy(
+ np.load(aux_data_dir + "loss_weights.npy")[
+ np.newaxis, np.newaxis, np.newaxis, start_ind:end_ind
+ ]
+ ).float()
+
+ def forward(
+ self,
+ target,
+ output,
+ prev_step_output,
+ fix_sigma=False,
+ unwrap=False,
+ expand=False,
+ ):
+ squared_diff = (target.to(output.device) - output) ** 2
+
+ if not expand:
+ weighted_sqared_diff = squared_diff * self.weights.to(target.device)
+
+ if self.weight_per_variable:
+ weighted_sqared_diff = weighted_sqared_diff * self.variable_weights.to(
+ weighted_sqared_diff.device
+ )
+
+ x = torch.nanmean(
+ torch.sqrt(torch.nanmean(weighted_sqared_diff, dim=(1, 2, 3)))
+ )
+
+ return x
+
+ weighted_sqared_diff = squared_diff * self.weights.to(target.device)
+ x = torch.mean(
+ torch.sqrt(torch.nanmean(weighted_sqared_diff, dim=(1, 2))), dim=0
+ )
+
+ return x
diff --git a/official-src/aardvark/misc_downscaling_functionality.py b/official-src/aardvark/misc_downscaling_functionality.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed65ed98dec9a167df3a98e19bc869ff6c4aa2a6
--- /dev/null
+++ b/official-src/aardvark/misc_downscaling_functionality.py
@@ -0,0 +1,273 @@
+import pickle
+
+import torch
+import numpy as np
+import torch.nn as nn
+
+from set_convs import convDeepSet
+from unet_wrap_padding import Unet
+from vit import *
+from models import *
+
+hadisd_publisher_shifts = {
+ "tas": 273.15,
+ "u": 0.0,
+ "v": 0.0,
+ "psl": 0.0,
+ "ws": 0.0,
+}
+
+hadisd_publisher_scales = {
+ "tas": 10,
+ "u": 10,
+ "v": 10,
+ "psl": 100,
+ "ws": 10.0,
+}
+
+
+def hadisd_normalisation_factors(var: str):
+ path = "/home/azureuser/aux_data/norm_factors/"
+ return {
+ "mean": np.load(path + f"mean_hadisd_{var}.npy"),
+ "std": np.load(path + f"std_hadisd_{var}.npy"),
+ }
+
+
+def unnormalise_hadisd_var(x, var):
+ factors = hadisd_normalisation_factors(var)
+ hadisd_shift = hadisd_publisher_shifts[var]
+ hadisd_scale = hadisd_publisher_scales[var]
+
+ return hadisd_shift + hadisd_scale * (factors["mean"] + factors["std"] * x)
+
+
+class DownscalingRmseLoss(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, target, output, prev_step, fix_sigma=None, expand=True):
+
+ target = torch.flatten(target.to(output.device))
+ output = torch.flatten(output)
+
+ tmp = torch.isnan(target)
+ clean_target = target[~tmp]
+ clean_output = output[~tmp]
+
+ return torch.mean((clean_target - clean_output) ** 2)
+
+
+class ConvCNPWeatherOnToOff(nn.Module):
+ """
+ ConvCNP for decoder
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ int_channels,
+ device,
+ res,
+ data_path="../data/",
+ mode="end_to_end",
+ decoder=None,
+ film=False,
+ ):
+
+ super().__init__()
+
+ # Setup
+ self.device = device
+
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.int_channels = int_channels
+ self.decoder = decoder
+ self.int_x = 256
+ self.int_y = 128
+ self.mode = mode
+ self.film = film
+
+ # Load lon-lat of internal discretisation
+ self.era5_x = (
+ torch.from_numpy(
+ np.load(data_path + "grid_lon_lat/era5_x_{}.npy".format(res))
+ ).float()
+ / 360
+ )
+ self.era5_y = (
+ torch.from_numpy(
+ np.load(data_path + "grid_lon_lat/era5_y_{}.npy".format(res))
+ ).float()
+ / 360
+ )
+
+ # Setup setconv
+ self.sc_out = convDeepSet(
+ 0.001, "OnToOff", density_channel=False, device=self.device
+ )
+
+ if self.mode not in ["downscaling", "end_to_end"]:
+ unet_out_channels = out_channels
+ else:
+ unet_out_channels = int_channels
+
+ # UNet backbone
+ if self.decoder == "base":
+ self.decoder_lr = Unet(
+ in_channels=in_channels,
+ out_channels=unet_out_channels,
+ div_factor=1,
+ film=film,
+ )
+
+ else:
+ raise Exception(f"Expected to use base decoder, but got {self.decoder}")
+
+ # Postprocessing MLP
+ self.mlp = DownscalingMLP(
+ in_channels=24 + 9,
+ out_channels=1,
+ h_channels=64,
+ h_layers=2,
+ )
+
+ def forward(self, task, film_index):
+
+ x = task["y_context"]
+ batch_size = x.shape[0]
+
+ # UNet backbone
+ x = self.decoder_lr(x, film_index=task["lt"])
+
+ # Transform to station predictions with setconv
+ num_channels = x.shape[3]
+ x = x.permute(0, 3, 1, 2)
+ assert list(x.shape) == [batch_size, num_channels, 240, 121]
+ x_target = task["x_target"]
+ num_stations = x_target.shape[2]
+
+ x = self.sc_out(
+ x_in=task["x_context"],
+ wt=x,
+ x_out=[x_target[:, 0, :], x_target[:, 1, :]],
+ )
+ assert x.shape[0] == batch_size
+ assert x.shape[2] == num_stations
+
+ # Concatenate auxiliary data at stations
+ alt_target = task["alt_target"]
+ assert torch.isnan(alt_target).sum() == 0
+ assert alt_target.shape[0] == batch_size
+ assert alt_target.shape[2] == num_stations
+
+ aux_time = task["aux_time"].squeeze(-1).repeat(1, 1, num_stations)
+ assert aux_time.shape[0] == batch_size
+ assert aux_time.shape[2] == num_stations
+
+ x = torch.cat([x, alt_target, x_target, aux_time], dim=1).permute(0, 2, 1)
+ assert x.shape[0] == batch_size
+ assert x.shape[1] == num_stations
+
+ tmp = self.mlp(x)
+ assert list(tmp.shape) == [batch_size, num_stations, 1]
+ y_hat = tmp.squeeze(-1)
+ assert list(y_hat.shape) == [batch_size, num_stations]
+ return y_hat
+
+
+class ResidualBlock(nn.Module):
+ def __init__(self, n_channels):
+ super().__init__()
+ self.block = nn.Sequential(nn.Linear(n_channels, n_channels), nn.ReLU())
+
+ def forward(self, x):
+ return self.block(x) + x
+
+
+class DownscalingMLP(nn.Module):
+ """
+ MLP for handling auxiliary data at station locations
+ """
+
+ def __init__(self, in_channels, out_channels, h_channels, h_layers):
+ super().__init__()
+
+ self.mlp = nn.Sequential(
+ nn.Linear(in_channels, h_channels),
+ *[ResidualBlock(h_channels) for _ in range(h_layers)],
+ nn.Linear(h_channels, out_channels),
+ )
+
+ def forward(self, x):
+ return self.mlp(x)
+
+
+def find_epoch(results_dir: str) -> int:
+ losses = np.load(results_dir + "losses_0.npy")
+ epoch = np.argmin(losses)
+
+ return epoch
+
+
+def load_config(results_dir: str) -> dict:
+ with open(results_dir + "config.pkl", "rb") as f:
+ return pickle.load(f)
+
+
+def load_model(results_dir, device, config_dir=None, epoch=None):
+ """
+ Load the ConvCNPWeatherOnToOff to generate forecasts
+ """
+
+ config_dir = config_dir or results_dir
+ config = load_config(config_dir)
+ epoch = epoch or find_epoch(results_dir)
+
+ model = ConvCNPWeatherOnToOff(
+ in_channels=config["in_channels"],
+ out_channels=config["out_channels"],
+ int_channels=config["int_channels"],
+ device=device,
+ res=config["res"],
+ decoder=config["decoder"],
+ mode=config["mode"],
+ film=False,
+ )
+
+ full_state_dict = torch.load(results_dir + f"epoch_{epoch}", map_location=device)
+ state_dict = full_state_dict["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = model.to(device)
+ model.eval()
+
+ return model
+
+
+def load_model_e2e(results_dir, lead_time, device):
+ """
+ Load the full E2E model to generate forecasts
+ """
+
+ config = load_config(results_dir)
+ epoch = find_epoch(results_dir)
+
+ model = ConvCNPWeatherE2E(
+ device="cuda",
+ lead_time=lead_time,
+ se_model_path="../results/assimilation/all_v4_vit_ps3",
+ forecast_model_path="../results/forecast/vit_fnl_randomlt_mlp",
+ sf_model_path="../results/downscaling_NEW",
+ )
+
+ full_state_dict = torch.load(results_dir + f"epoch_{epoch}", map_location=device)
+ state_dict = full_state_dict["model_state_dict"]
+ state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}
+ model.load_state_dict(state_dict)
+ model = model.to(device)
+ model.eval()
+
+ return model
diff --git a/official-src/aardvark/models.py b/official-src/aardvark/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..195f16afebd32b5d7170b2b87b4a0a71d5791962
--- /dev/null
+++ b/official-src/aardvark/models.py
@@ -0,0 +1,390 @@
+import sys
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from architectures import MLP
+from set_convs import convDeepSet
+from unet_wrap_padding import *
+from vit import *
+
+sys.path.append("../")
+
+
+class ConvCNPWeather(nn.Module):
+ """
+ ConvCNP class used for the encoder and processor modules
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ int_channels,
+ device,
+ res,
+ data_path="../data/",
+ gnp=False,
+ mode="assimilation",
+ decoder=None,
+ film=False,
+ two_frames=False,
+ ):
+
+ super().__init__()
+
+ self.device = device
+
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.int_channels = int_channels
+ self.decoder = decoder
+ self.int_x = 256
+ self.int_y = 128
+ self.data_path = data_path
+ self.mode = mode
+ self.film = film
+ self.two_frames = two_frames
+
+ N_SAT_VARS = 2
+ N_ICOADS_VARS = 5
+ N_HADISD_VARS = 5
+
+ # Load internal grid longitude-latitude locations
+ self.era5_x = (
+ torch.from_numpy(
+ np.load(self.data_path + "grid_lon_lat/era5_x_{}.npy".format(res))
+ ).float()
+ / 360
+ )
+ self.era5_y = (
+ torch.from_numpy(
+ np.load(self.data_path + "grid_lon_lat/era5_y_{}.npy".format(res))
+ ).float()
+ / 360
+ )
+
+ self.int_grid = [
+ (torch.linspace(0, 360, 240) / 360).float().cuda(),
+ (torch.linspace(-90, 90, 121) / 360).float().cuda(),
+ ]
+
+ self.int_grid = [self.int_grid[0].unsqueeze(0), self.int_grid[1].unsqueeze(0)]
+
+ # Create input setconvs for each data modality
+ self.ascat_setconvs = convDeepSet(
+ 0.001, "OnToOn", density_channel=True, device=self.device
+ )
+ self.amsua_setconvs = [
+ convDeepSet(0.001, "OnToOn", density_channel=True, device=self.device)
+ for _ in range(13)
+ ]
+ self.amsub_setconvs = [
+ convDeepSet(0.001, "OnToOn", density_channel=True, device=self.device)
+ for _ in range(12)
+ ]
+ self.hirs_setconvs = [
+ convDeepSet(0.001, "OnToOn", density_channel=True, device=self.device)
+ for _ in range(26)
+ ]
+
+ self.sat_setconvs = [
+ convDeepSet(0.001, "OnToOn", density_channel=True, device=self.device)
+ for _ in range(N_SAT_VARS)
+ ]
+ self.hadisd_setconvs = [
+ convDeepSet(0.001, "OffToOn", density_channel=True, device=self.device)
+ for _ in range(N_HADISD_VARS)
+ ]
+ self.icoads_setconvs = [
+ convDeepSet(0.001, "OffToOn", density_channel=True, device=self.device)
+ for _ in range(N_ICOADS_VARS)
+ ]
+ self.igra_setconvs = [
+ convDeepSet(0.001, "OffToOn", density_channel=True, device=self.device)
+ for _ in range(24)
+ ]
+
+ self.sc_out = convDeepSet(
+ 0.001, "OnToOff", density_channel=False, device=self.device
+ )
+
+ # Instantiate the decoder. Here decoder refers to decoder in a convCNP (i.e the ViT backbone)
+ if self.decoder == "vit":
+ self.decoder_lr = ViT(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ h_channels=512,
+ depth=16,
+ patch_size=5,
+ per_var_embedding=True,
+ img_size=[240, 121],
+ )
+
+ elif self.decoder == "vit_assimilation":
+ self.decoder_lr = ViT(
+ in_channels=256,
+ out_channels=out_channels,
+ h_channels=512,
+ depth=8,
+ patch_size=3,
+ per_var_embedding=False,
+ img_size=[256, 128],
+ )
+
+ self.mlp = MLP(
+ in_channels=out_channels,
+ out_channels=out_channels,
+ h_channels=128,
+ h_layers=4,
+ )
+ self.break_next = False
+
+ def encoder_hadisd(self, task, prefix):
+ """
+ Data preprocessing for HadISD
+ """
+
+ encodings = []
+ for channel in range(4):
+ encodings.append(
+ self.hadisd_setconvs[channel](
+ x_in=[
+ task["x_context_hadisd_{}".format(prefix)][channel][:, 0, :],
+ task["x_context_hadisd_{}".format(prefix)][channel][:, 1, :],
+ ],
+ wt=task["y_context_hadisd_{}".format(prefix)][channel].unsqueeze(1),
+ x_out=self.int_grid,
+ )
+ )
+ encodings = torch.cat(encodings, dim=1)
+ return encodings
+
+ def encoder_sat(self, task, prefix):
+ """
+ Data preprocessing for Gridsat
+ """
+
+ encodings = []
+ for channel in range(task["sat_{}".format(prefix)].shape[1]):
+ encodings.append(
+ self.sat_setconvs[channel](
+ x_in=task["sat_x_{}".format(prefix)],
+ wt=task["sat_{}".format(prefix)][:, channel : channel + 1, ...],
+ x_out=self.int_grid,
+ )
+ )
+ encodings = torch.cat(encodings, dim=1)
+ return encodings
+
+ def encoder_icoads(self, task, prefix):
+ """
+ Data preprocessing for ICOADS
+ """
+
+ encodings = []
+ for channel in range(5):
+ encodings.append(
+ self.icoads_setconvs[channel](
+ x_in=task["icoads_x_{}".format(prefix)],
+ wt=task["icoads_{}".format(prefix)][:, channel, :].unsqueeze(1),
+ x_out=self.int_grid,
+ )
+ )
+ encodings = torch.cat(encodings, dim=1)
+
+ return encodings
+
+ def encoder_amsua(self, task, prefix):
+ """
+ Data preprocessing for AMSU-A
+ """
+
+ encodings = []
+ task["amsua_{}".format(prefix)][..., -1] = np.nan
+ task["amsua_{}".format(prefix)][task["amsua_{}".format(prefix)] == 0] = np.nan
+ for i in range(13):
+ encodings.append(
+ self.amsua_setconvs[i](
+ x_in=task["amsua_x_{}".format(prefix)],
+ wt=task["amsua_{}".format(prefix)].permute(0, 3, 2, 1)[
+ :, i : i + 1, ...
+ ],
+ x_out=self.int_grid,
+ )
+ )
+
+ encodings = torch.cat(encodings, dim=1)
+ return encodings
+
+ def encoder_amsub(self, task, prefix):
+ """
+ Data preprocessing for AMSU-B
+ """
+
+ encodings = []
+ task["amsub_{}".format(prefix)][task["amsub_{}".format(prefix)] == 0] = np.nan
+ for i in range(12):
+ encodings.append(
+ self.amsua_setconvs[i](
+ x_in=task["amsub_x_{}".format(prefix)],
+ wt=task["amsub_{}".format(prefix)].permute(0, 3, 1, 2)[
+ :, i : i + 1, ...
+ ],
+ x_out=self.int_grid,
+ )
+ )
+
+ encodings = torch.cat(encodings, dim=1)
+ return encodings
+
+ def encoder_hirs(self, task, prefix):
+ """
+ Data preprocessing for HIRS
+ """
+
+ encodings = []
+
+ task["hirs_{}".format(prefix)][task["hirs_{}".format(prefix)] == 0] = np.nan
+ for i in range(26):
+ encodings.append(
+ self.hirs_setconvs[i](
+ x_in=task["hirs_x_{}".format(prefix)],
+ wt=task["hirs_{}".format(prefix)].permute(0, 3, 1, 2)[
+ :, i : i + 1, ...
+ ],
+ x_out=self.int_grid,
+ )
+ )
+
+ encodings = torch.cat(encodings, dim=1)
+ return encodings
+
+ def encoder_igra(self, task, prefix):
+ """
+ Data preprocessing for IGRA
+ """
+
+ encodings = []
+ for channel in range(24):
+ encodings.append(
+ self.igra_setconvs[channel](
+ x_in=task["igra_x_{}".format(prefix)],
+ wt=task["igra_{}".format(prefix)][:, channel, :].unsqueeze(1),
+ x_out=self.int_grid,
+ )
+ )
+ encodings = torch.cat(encodings, dim=1)
+
+ return encodings
+
+ def encoder_ascat(self, task, prefix):
+ """
+ Data preprocessing for ASCAT
+ """
+
+ task["ascat_{}".format(prefix)][
+ torch.isnan(task["ascat_{}".format(prefix)])
+ ] = 0
+ e = nn.functional.interpolate(
+ task["ascat_{}".format(prefix)].permute(0, 3, 1, 2), size=(240, 121)
+ )
+ e = torch.flip(e, dims=[-1])
+ return e
+
+ def encoder_iasi(self, task, prefix):
+ """
+ Data preprocessing for IASI
+ """
+
+ task["iasi_{}".format(prefix)][torch.isnan(task["iasi_{}".format(prefix)])] = 0
+ e = nn.functional.interpolate(
+ task["iasi_{}".format(prefix)].permute(0, 3, 1, 2), size=(240, 121)
+ )
+ e = torch.flip(e, dims=[-1])
+ return e
+
+ def forward(self, task, film_index):
+
+ # Setup input
+ if self.mode == "assimilation":
+
+ self.int_grid = [i.to(task["y_target"].device) for i in self.int_grid]
+ elev = nn.functional.interpolate(
+ torch.flip(task["era5_elev_current"].permute(0, 1, 3, 2), dims=[2]),
+ size=(self.int_grid[0].shape[1], self.int_grid[1].shape[1]),
+ )
+ elev = torch.flip(task["era5_elev_current"].permute(0, 1, 3, 2), dims=[2])
+
+ if not self.two_frames:
+ encodings = [
+ self.encoder_iasi(task, "current"),
+ self.encoder_ascat(task, "current"),
+ self.encoder_hadisd(task, "current"),
+ self.encoder_icoads(task, "current"),
+ self.encoder_sat(task, "current"),
+ self.encoder_amsua(task, "current"),
+ self.encoder_amsub(task, "current"),
+ self.encoder_igra(task, "current"),
+ self.encoder_hirs(task, "current"),
+ elev,
+ task["climatology_current"],
+ torch.ones_like(elev[:, :5, ...])
+ * task["aux_time_current"].unsqueeze(-1).unsqueeze(-1),
+ ]
+ else:
+ # Option to pass two timesteps (t=-1 and t=0) as input
+ encodings = [
+ self.encoder_iasi(task, "current"),
+ self.encoder_ascat(task, "current"),
+ self.encoder_hadisd(task, "current"),
+ self.encoder_icoads(task, "current"),
+ self.encoder_sat(task, "current"),
+ self.encoder_amsua(task, "current"),
+ self.encoder_amsub(task, "current"),
+ self.encoder_igra(task, "current"),
+ self.encoder_hirs(task, "current"),
+ self.encoder_iasi(task, "prev"),
+ self.encoder_ascat(task, "prev"),
+ self.encoder_hadisd(task, "prev"),
+ self.encoder_icoads(task, "prev"),
+ self.encoder_sat(task, "prev"),
+ self.encoder_amsua(task, "prev"),
+ self.encoder_amsub(task, "prev"),
+ self.encoder_igra(task, "prev"),
+ self.encoder_hirs(task, "prev"),
+ elev,
+ task["climatology_current"],
+ torch.ones_like(elev[:, :5, ...])
+ * task["aux_time_current"].unsqueeze(-1).unsqueeze(-1),
+ ]
+ x = torch.cat(encodings, dim=1)
+
+ else:
+ x = task["y_context"]
+
+ if x.shape[-1] > x.shape[-2]:
+ x = x.permute(0, 1, 3, 2)
+
+ # Run ViT backbone
+ if self.decoder == "vit":
+ x = self.decoder_lr(x, lead_times=task["lt"])
+ x = x.permute(0, 3, 1, 2)
+ else:
+ x = nn.functional.interpolate(x, size=(256, 128))
+ x = self.decoder_lr(x, film_index=(task["lt"] * 0) + 1)
+
+ # Process outputs
+
+ if np.logical_and(
+ self.mode == "assimilation", self.decoder == "vit_assimilation"
+ ):
+ x = nn.functional.interpolate(x.permute(0, 3, 1, 2), size=(240, 121))
+ return x.permute(0, 3, 2, 1)
+
+ elif self.mode == "forecast":
+ x = nn.functional.interpolate(x, size=(240, 121)).permute(0, 2, 3, 1)
+ return x.permute(0, 2, 1, 3)
+
+ return x
diff --git a/official-src/aardvark/set_convs.py b/official-src/aardvark/set_convs.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ab3478ff3678bde73e7628541046a9d96bb27dc
--- /dev/null
+++ b/official-src/aardvark/set_convs.py
@@ -0,0 +1,101 @@
+import torch
+import torch.nn as nn
+
+
+class convDeepSet(nn.Module):
+ """
+ ConvDeepSet used to translate ungridded observations to a gridded representation and
+ vice versa.
+ """
+
+ def __init__(
+ self,
+ init_ls,
+ mode,
+ device,
+ density_channel=True,
+ step=0.25,
+ grid=False,
+ ):
+ super().__init__()
+ self.init_ls = torch.nn.Parameter(torch.tensor([init_ls]))
+ self.grid = grid
+ self.step = step
+ self.density_channel = density_channel
+ self.mode = mode
+
+ self.init_ls.requires_grad = True
+ self.device = device
+
+ def compute_weights(self, x1, x2):
+
+ dists2 = self.pw_dists2(x1.unsqueeze(-1), x2.unsqueeze(-1))
+
+ d = torch.exp((-0.5 * dists2) / (self.init_ls.to(x1.device)) ** 2)
+ return d
+
+ def pw_dists2(self, a, b):
+
+ norms_a = torch.sum(a**2, axis=-1)[..., :, None]
+ norms_b = torch.sum(b**2, axis=-1)[..., None, :]
+
+ return norms_a + norms_b - 2 * torch.matmul(a, b.permute(0, 2, 1))
+
+ def forward(self, x_in, wt, x_out):
+
+ # Add a density channel
+ density_channel = torch.ones_like(wt[:, 0:1, ...])
+ density_channel[torch.isnan(wt[:, 0:1, ...])] = 0
+
+ wt = torch.cat([density_channel, wt], dim=1)
+ wt[torch.isnan(wt)] = 0
+
+ if self.mode == "OffToOn":
+ # Case 1: converting off-the-grid data to a gridded representation
+
+ in_lon_mask = ~torch.isnan(x_in[0])
+ in_lat_mask = ~torch.isnan(x_in[1])
+
+ x_in[0][~in_lon_mask] = 0
+ x_in[1][~in_lat_mask] = 0
+
+ ws = [self.compute_weights(xzi, xi) for xzi, xi in zip(x_in, x_out)]
+
+ ws[0] = ws[0] * in_lon_mask.unsqueeze(-1).int()
+ ws[1] = ws[1] * in_lat_mask.unsqueeze(-1).int()
+
+ ee = torch.einsum("...cw,...wx,...wy->...cxy", wt, ws[0], ws[1])
+
+ elif self.mode == "OnToOn":
+ # Case 2: converting between gridded representations
+
+ ws = [self.compute_weights(xzi, xi) for xzi, xi in zip(x_in, x_out)]
+ ee = torch.einsum("...cwh,...wx,...hy->...cxy", wt, ws[0], ws[1])
+
+ elif self.mode == "OnToOff":
+
+ # Case 3: converting a gridded representation to off-the-grid predictions
+ out_lon_mask = ~torch.isnan(x_out[0])
+ out_lat_mask = ~torch.isnan(x_out[1])
+ x_out[0][~out_lon_mask] = 0
+ x_out[1][~out_lat_mask] = 0
+
+ ws = [self.compute_weights(xzi, xi) for xzi, xi in zip(x_in, x_out)]
+
+ ws[0] = ws[0] * out_lon_mask.unsqueeze(-2).int()
+ ws[1] = ws[1] * out_lat_mask.unsqueeze(-2).int()
+
+ ee = torch.einsum("...cwh,...wx,...hx->...cx", wt, ws[0], ws[1])
+ if self.density_channel:
+ ee = torch.cat(
+ [
+ ee[:, 0:1, ...],
+ ee[:, 1:, ...] / torch.clamp(ee[:, 0:1, ...], min=1e-6, max=1e5),
+ ],
+ dim=1,
+ )
+
+ return ee
+ else:
+ ee = ee[:, 1:, ...] / torch.clamp(ee[:, 0:1, ...], min=1e-6, max=1e5)
+ return ee
diff --git a/official-src/aardvark/train_module.py b/official-src/aardvark/train_module.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3137f6008d3442f5405d055aa5a112730ccf4ca
--- /dev/null
+++ b/official-src/aardvark/train_module.py
@@ -0,0 +1,315 @@
+"""
+NB: this script is for illustration purposes only and is not runnable as our
+full dataset is not provided as part of the submission, due to size constraints.
+Many of the relevant paths to the data have been thus replaced by dummy paths.
+"""
+
+import os
+import sys
+import pickle
+import argparse
+
+import torch
+import torch.multiprocessing as mp
+from torch.utils.data import DataLoader
+import torch.utils.data.distributed
+from torch.utils.data.distributed import DistributedSampler
+from torch.distributed import init_process_group, destroy_process_group
+
+
+from trainer import DDPTrainer
+from loss_functions import WeightedRmseLoss, PressureWeightedRmseLoss, RmseLoss
+from misc_downscaling_functionality import ConvCNPWeatherOnToOff, DownscalingRmseLoss
+from loader import *
+from models import *
+from unet_wrap_padding import *
+
+
+sys.path.append("../npw/data")
+torch.set_float32_matmul_precision("medium")
+
+
+def ddp_setup(rank, world_size, master_port):
+ """
+ Args:
+ rank: Unique identifier of each process
+ world_size: Total number of processes
+ """
+
+ os.environ["MASTER_ADDR"] = "localhost"
+ os.environ["MASTER_PORT"] = master_port
+ init_process_group(backend="nccl", rank=rank, world_size=world_size)
+ torch.cuda.set_device(rank)
+
+
+def start_date(name):
+ if name == "train":
+ return "2007-01-02"
+ elif name == "val":
+ return "2019-01-01"
+ elif name == "test":
+ return "2018-01-01"
+ else:
+ raise Exception(f"Unrecognised split name {name}")
+
+
+def end_date(name):
+ if name == "train":
+ return "2017-12-31"
+ elif name == "val":
+ return "2019-11-01"
+ elif name == "test":
+ return "2018-12-21"
+ else:
+ raise Exception(f"Unrecognised split name {name}")
+
+
+def main(rank, world_size, output_dir, args):
+ """
+ Primary training script for the encoder, processor and decoder modules.
+ """
+
+ master_port = args.master_port
+ lead_time = args.lead_time
+ era5_mode = args.era5_mode
+ weights_dir = args.weights_dir
+ ddp_setup(rank, world_size, master_port)
+
+ # Instantiate loss function
+ if args.loss == "lw_rmse":
+ lf = WeightedRmseLoss(
+ args.res,
+ start_ind=args.start_ind,
+ end_ind=args.end_ind,
+ weight_per_variable=bool(args.weight_per_variable),
+ )
+ elif args.loss == "lw_rmse_pressure_weighted":
+ lf = PressureWeightedRmseLoss(args.res, era5_mode)
+ elif args.loss == "rmse":
+ lf = RmseLoss()
+ elif args.loss == "downscaling_rmse":
+ lf = DownscalingRmseLoss()
+
+ # Setup datasets
+
+ # Case 1: training encoder
+ if args.mode == "assimilation":
+ train_dataset = WeatherDatasetAssimilation(
+ device="cuda",
+ hadisd_mode="train",
+ start_date="2007-01-02",
+ end_date="2017-12-31",
+ lead_time=0,
+ era5_mode="4u",
+ res=args.res,
+ var_start=args.start_ind,
+ var_end=args.end_ind,
+ diff=bool(args.diff),
+ two_frames=bool(args.two_frames),
+ )
+ val_dataset = WeatherDatasetAssimilation(
+ device="cuda",
+ hadisd_mode="train",
+ start_date="2019-01-01",
+ end_date="2019-12-31",
+ lead_time=0,
+ era5_mode="4u",
+ res=args.res,
+ var_start=args.start_ind,
+ var_end=args.end_ind,
+ diff=bool(args.diff),
+ two_frames=bool(args.two_frames),
+ )
+
+ # Case 2: training processor
+ elif args.mode == "forecast":
+ if args.ic == "aardvark":
+ train_dataset = FineTuneForecastLoaderNew(
+ device="cuda",
+ mode="train",
+ lead_time=lead_time,
+ era5_mode=era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ aardvark_ic_path=args.aardvark_ic_path,
+ random_lt=True,
+ )
+ val_dataset = FineTuneForecastLoaderNew(
+ device="cuda",
+ mode="val",
+ lead_time=lead_time,
+ era5_mode=era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ aardvark_ic_path=args.aardvark_ic_path,
+ )
+ else:
+ train_dataset = ForecastLoader(
+ device="cuda",
+ mode="train",
+ lead_time=lead_time,
+ era5_mode=era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ u_only=False,
+ random_lt=False,
+ )
+ val_dataset = ForecastLoader(
+ device="cuda",
+ mode="val",
+ lead_time=lead_time,
+ era5_mode=era5_mode,
+ res=args.res,
+ frequency=args.frequency,
+ diff=bool(args.diff),
+ u_only=False,
+ random_lt=False,
+ )
+
+ # Case 3: training decoder
+ elif args.mode == "downscaling":
+
+ train_dataset = ForecasterDatasetDownscaling(
+ start_date="2007-01-02",
+ end_date="2017-12-31",
+ lead_time=args.lead_time,
+ hadisd_var=args.var,
+ mode="train",
+ device="cuda",
+ forecast_path=None,
+ )
+
+ val_dataset = ForecasterDatasetDownscaling(
+ start_date="2019-01-01",
+ end_date="2019-12-21",
+ lead_time=args.lead_time,
+ hadisd_var=args.var,
+ mode="train",
+ device="cuda",
+ forecast_path=None,
+ )
+
+ try:
+ os.mkdir(f"{output_dir}lt_{args.lead_time}")
+ except FileExistsError:
+ pass
+
+ output_dir = f"{output_dir}lt_{args.lead_time}/"
+
+ # Instantiate model
+
+ if args.mode == "downscaling":
+ model = ConvCNPWeatherOnToOff(
+ in_channels=args.in_channels,
+ out_channels=args.end_ind - args.start_ind,
+ int_channels=args.int_channels,
+ device="cuda",
+ res=args.res,
+ decoder=args.decoder,
+ mode=args.mode,
+ film=bool(args.film),
+ )
+ else:
+ model = ConvCNPWeather(
+ in_channels=args.in_channels,
+ out_channels=args.end_ind - args.start_ind,
+ int_channels=args.int_channels,
+ device="cuda",
+ res=args.res,
+ gnp=bool(0),
+ decoder=args.decoder,
+ mode=args.mode,
+ film=bool(args.film),
+ two_frames=bool(args.two_frames),
+ )
+
+ # Instantiate loaders
+ train_sampler = DistributedSampler(train_dataset)
+ val_sampler = DistributedSampler(val_dataset)
+
+ train_loader = DataLoader(
+ train_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=train_sampler,
+ )
+
+ val_loader = DataLoader(
+ val_dataset,
+ batch_size=args.batch_size,
+ shuffle=False,
+ sampler=val_sampler,
+ )
+
+ # Instantiate trainer
+
+ trainer = DDPTrainer(
+ model,
+ rank,
+ train_loader,
+ val_loader,
+ lf,
+ output_dir,
+ args.lr,
+ train_sampler,
+ weight_decay=args.weight_decay,
+ weights_path=weights_dir,
+ tune_film=args.film,
+ )
+
+ # Train model
+
+ trainer.train(n_epochs=args.epoch)
+ destroy_process_group()
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--output_dir")
+ parser.add_argument("--mode")
+ parser.add_argument("--weights_dir")
+ parser.add_argument("--in_channels", type=int)
+ parser.add_argument("--out_channels", type=int)
+ parser.add_argument("--int_channels", type=int)
+ parser.add_argument("--loss")
+ parser.add_argument("--ic")
+ parser.add_argument("--decoder")
+ parser.add_argument("--film")
+ parser.add_argument("--aardvark_ic_path")
+ parser.add_argument("--two_frames", type=int, default=0)
+ parser.add_argument("--weight_per_variable", type=int, default=0)
+ parser.add_argument("--batch_size", type=int, default=128)
+ parser.add_argument("--epoch", type=int, default=50)
+ parser.add_argument("--master_port", default="12345")
+ parser.add_argument("--lr", type=float, default=5e-4)
+ parser.add_argument("--lead_time", type=int)
+ parser.add_argument("--era5_mode", default="4u")
+ parser.add_argument("--weight_decay", type=float, default=1e-6)
+ parser.add_argument("--res", type=int, default=1)
+ parser.add_argument("--frequency", type=int, default=6)
+ parser.add_argument("--diff", type=int, default=1)
+ parser.add_argument("--start_ind", type=int, default=0)
+ parser.add_argument("--end_ind", type=int, default=24)
+ parser.add_argument("--downscaling_train_start_date", default="1979-01-01")
+ parser.add_argument("--downscaling_train_end_date", default="2017-12-31")
+ parser.add_argument("--downscaling_context", default="era5")
+ parser.add_argument("--downscaling_lead_time", type=int)
+ parser.add_argument("--var", default=None)
+ args = parser.parse_args()
+
+ torch.device("cuda")
+
+ # Create results directory
+ output_dir = args.output_dir
+ if not os.path.exists(output_dir):
+ os.mkdir(output_dir)
+
+ # Save config
+ with open(output_dir + "/config.pkl", "wb") as f:
+ pickle.dump(vars(args), f)
+
+ world_size = torch.cuda.device_count()
+ mp.spawn(main, args=[world_size, output_dir, args], nprocs=world_size)
diff --git a/official-src/aardvark/trainer.py b/official-src/aardvark/trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbf626f512871543add62f48b3db464f0c855957
--- /dev/null
+++ b/official-src/aardvark/trainer.py
@@ -0,0 +1,602 @@
+import sys
+import subprocess
+
+import numpy as np
+import torch
+from torch.nn.parallel import DistributedDataParallel as DDP
+from tqdm import tqdm
+
+from misc_downscaling_functionality import *
+from models import *
+from loss_functions import *
+
+sys.path.append("..")
+
+
+class DDPTrainer:
+ """
+ Main class for training models using DDP
+ """
+
+ def __init__(
+ self,
+ model,
+ rank,
+ train_loader,
+ val_loader,
+ loss_function,
+ save_path,
+ learning_rate,
+ sampler,
+ weight_decay,
+ test_loader=None,
+ weights_path=None,
+ tune_film=False,
+ ):
+ self.rank = rank
+ self.model = model
+ self.sampler = sampler
+ self.tune_film = tune_film
+ self.train_loader = train_loader
+ self.val_loader = val_loader
+ self.save_path = save_path
+ self.loss_function = loss_function
+ self.best_loss = 1000
+ self.test_loader = test_loader
+
+ self.model = self.model.to(rank)
+ self.model = DDP(self.model, device_ids=[rank], find_unused_parameters=True)
+
+ if self.model.module.decoder == "vit":
+ self.opt = torch.optim.AdamW(
+ model.parameters(),
+ lr=learning_rate,
+ betas=(0.9, 0.95),
+ weight_decay=1e-5,
+ )
+ self.scheduler = optim.lr_scheduler.CosineAnnealingLR(self.opt, 891 * 80)
+
+ else:
+ self.opt = torch.optim.Adam(
+ model.parameters(), lr=learning_rate, weight_decay=weight_decay
+ )
+
+ self.losses = []
+ self.train_losses = []
+ self.maes = []
+
+ def _unravel_to_numpy(self, x):
+ return x.view(-1).detach().cpu().numpy()
+
+ def eval_epoch(self, fix_sigma, epoch):
+
+ self.model.eval()
+
+ mae = []
+ lf = []
+ lf_unnorm = []
+
+ with torch.no_grad():
+ for count, task in enumerate(self.val_loader):
+
+ out = self.model(task, film_index=0)
+
+ prev_step = None
+
+ mae.append(
+ np.nanmean(
+ np.abs(
+ task["y_target"].detach().cpu()
+ - out[..., : task["y_target"].shape[-1]].detach().cpu()
+ )
+ )
+ )
+ l = (
+ self.loss_function(
+ task["y_target"], out, prev_step, fix_sigma=fix_sigma
+ )
+ .detach()
+ .item()
+ )
+ lf.append(l)
+
+ try:
+ ic = self.train_loader.dataset.unnorm_base_context(
+ task["y_context"][:, :-11, ...]
+ ).permute(0, 3, 2, 1)
+ unnorm_pred = self.train_loader.dataset.unnorm_pred(out)
+ unnorm_target = self.train_loader.dataset.unnorm_pred(
+ task["y_target"]
+ )
+
+ unnorm_pred = unnorm_pred + ic
+ unnorm_target = unnorm_target + ic
+
+ lu = (
+ self.loss_function(
+ unnorm_target,
+ unnorm_pred,
+ prev_step,
+ fix_sigma=fix_sigma,
+ expand=True,
+ )
+ .detach()
+ .cpu()
+ .numpy()
+ )
+
+ lf_unnorm.append(lu)
+
+ except:
+ pass
+
+ if self.test_loader is not None:
+ forecasts = []
+ targets = []
+ stations = []
+
+ for count, task in enumerate(self.test_loader):
+ out = self.model(task, film_index=0)
+ forecasts.append(unnormalise_hadisd_tas(out.detach().cpu().numpy()))
+ targets.append(
+ unnormalise_hadisd_tas(task["y_target"].detach().cpu().numpy())
+ )
+ stations.append(
+ task["downscaling"]["x_target"].detach().cpu().numpy() * 360
+ )
+
+ # Save the test outputs
+ np.save(
+ self.save_path + f"forecast_{self.rank}_{self.epoch}.npy",
+ np.concatenate(forecasts, axis=0),
+ )
+ np.save(
+ self.save_path + f"targets_{self.rank}_{self.epoch}.npy",
+ np.concatenate(targets, axis=0),
+ )
+ np.save(
+ self.save_path + f"stations_{self.rank}_{self.epoch}.npy",
+ np.concatenate(stations, axis=0),
+ )
+
+ log_loss = np.nanmean(np.array(lf))
+
+ if log_loss < self.best_loss:
+ np.save(
+ self.save_path + "unnorm_preds.npy",
+ self.train_loader.dataset.unnorm_pred(out).detach().cpu().numpy(),
+ )
+ np.save(
+ self.save_path + "unnorm_targets.npy",
+ self.train_loader.dataset.unnorm_pred(task["y_target"])
+ .detach()
+ .cpu()
+ .numpy(),
+ )
+ log_loss_unnorm = np.nanmean(np.stack(lf_unnorm), axis=0)
+
+ if np.logical_and(self.rank == 0, self.epoch % 5 == 0):
+
+ np.save(self.save_path + "preds_eval.npy", out.cpu().numpy())
+ np.save(
+ self.save_path + "y_target_eval.npy", task["y_target"].cpu().numpy()
+ )
+
+ return log_loss, log_loss_unnorm
+
+ def train(self, n_epochs=100):
+
+ torch.cuda.set_device(self.rank)
+ subprocess.run(["cp", "reproduce_training.sh", f"{self.save_path}"])
+
+ train_loss = []
+ ll = []
+
+ fix_sigma = False
+ prev_step = None
+
+ self.epoch = 0
+ epoch_loss, log_loss_unnorm = self.eval_epoch(fix_sigma, 0)
+ train_loss = np.mean(train_loss)
+
+ for epoch in range(n_epochs):
+ self.epoch = epoch
+
+ self.sampler.set_epoch(epoch)
+
+ self.model.train()
+ train_loss = []
+ with tqdm(self.train_loader, unit="batch") as tepoch:
+ for count, task in enumerate(tepoch):
+
+ out = self.model(task, film_index=0)
+
+ loss = self.loss_function(
+ task["y_target"], out, prev_step, fix_sigma=fix_sigma
+ )
+
+ loss.backward()
+ tepoch.set_postfix(loss=loss.item())
+ prev_step = out
+
+ self.opt.step()
+ self.opt.zero_grad()
+ train_loss.append(loss.item())
+ try:
+ if self.model.module.decoder == "vit":
+ if epoch > 20:
+ self.scheduler.step()
+ except:
+ pass
+
+ epoch_loss, log_loss_unnorm = self.eval_epoch(fix_sigma, epoch)
+ train_loss = np.mean(train_loss)
+ ll.append(log_loss_unnorm)
+
+ self.losses.append(epoch_loss)
+ self.train_losses.append(train_loss)
+ np.save(
+ self.save_path + "losses_{}.npy".format(self.rank),
+ np.array(self.losses),
+ )
+ np.save(
+ self.save_path + "train_losses_{}.npy".format(self.rank),
+ np.array(self.train_losses),
+ )
+ np.save(self.save_path + "rmse_{}.npy".format(self.rank), np.array(ll))
+
+ if epoch_loss < self.best_loss:
+ self.best_loss = epoch_loss
+
+ if self.rank == 0:
+ if self.model.module.decoder == "vit":
+ torch.save(
+ {
+ "epoch": epoch,
+ "model_state_dict": self.model.state_dict(),
+ "optimizer_state_dict": self.opt.state_dict(),
+ "scheduler_state_dict": self.scheduler.state_dict(),
+ "loss": epoch_loss,
+ },
+ self.save_path + "epoch_{}".format(epoch),
+ )
+ else:
+ torch.save(
+ {
+ "epoch": epoch,
+ "model_state_dict": self.model.state_dict(),
+ "optimizer_state_dict": self.opt.state_dict(),
+ "loss": epoch_loss,
+ },
+ self.save_path + "epoch_{}".format(epoch),
+ )
+
+ try:
+ np.save(
+ self.save_path + "preds_train.npy".format(epoch),
+ out.detach().cpu().numpy(),
+ )
+ np.save(
+ self.save_path + "y_target_train.npy".format(epoch),
+ task["y_target"].detach().cpu().numpy(),
+ )
+ except:
+ pass
+
+
+class DDPTrainerE2E:
+ """
+ Training class for E2E
+ """
+
+ def __init__(
+ self,
+ model,
+ rank,
+ train_loader,
+ val_loader,
+ loss_function,
+ save_path,
+ learning_rate,
+ sampler,
+ weight_decay,
+ hadisd_variable_name,
+ test_loader=None,
+ weights_path=None,
+ tune_film=False,
+ ):
+
+ self.rank = rank
+ self.model = model
+ self.sampler = sampler
+ self.tune_film = tune_film
+ self.train_loader = train_loader
+ self.val_loader = val_loader
+ self.save_path = save_path
+ self.loss_function = loss_function
+ self.best_loss = 1000
+ self.test_loader = test_loader
+ self.hadisd_variable_name = hadisd_variable_name
+
+ self.model = self.model.to(rank)
+ self.model = DDP(self.model, device_ids=[rank], find_unused_parameters=True)
+
+ if self.model.module.decoder == "vit":
+ self.opt = torch.optim.AdamW(
+ model.parameters(),
+ lr=learning_rate,
+ betas=(0.9, 0.95),
+ weight_decay=1e-5,
+ )
+ self.scheduler = optim.lr_scheduler.CosineAnnealingLR(self.opt, 891 * 80)
+ else:
+ self.opt = torch.optim.Adam(
+ model.parameters(), lr=learning_rate, weight_decay=weight_decay
+ )
+
+ self.losses = []
+ self.train_losses = []
+
+ self.maes = []
+
+ def _unravel_to_numpy(self, x):
+ return x.view(-1).detach().cpu().numpy()
+
+ def eval_epoch(self, fix_sigma, epoch):
+
+ self.model.eval()
+
+ mae = []
+ lf = []
+ lf_unnorm = []
+
+ with torch.no_grad():
+ forecasts = []
+ targets = []
+ stations = []
+ indices = []
+ for count, task in tqdm(enumerate(self.val_loader)):
+
+ out = self.model(task, film_index=0)
+ forecasts.append(
+ unnormalise_hadisd_var(
+ out.detach().cpu().numpy(), self.hadisd_variable_name
+ )
+ )
+ targets.append(
+ unnormalise_hadisd_var(
+ task["y_target"].detach().cpu().numpy(),
+ self.hadisd_variable_name,
+ )
+ )
+ stations.append(
+ task["downscaling"]["x_target"].detach().cpu().numpy() * 360
+ )
+ indices.append(task["index"])
+
+ prev_step = None
+
+ mae.append(
+ np.nanmean(
+ np.abs(
+ task["y_target"].detach().cpu()
+ - out[..., : task["y_target"].shape[-1]].detach().cpu()
+ )
+ )
+ )
+ l = (
+ self.loss_function(
+ task["y_target"], out, prev_step, fix_sigma=fix_sigma
+ )
+ .detach()
+ .item()
+ )
+ lf.append(l)
+
+ try:
+ ic = self.train_loader.dataset.unnorm_base_context(
+ task["y_context"][:, :-11, ...]
+ ).permute(0, 3, 2, 1)
+ unnorm_pred = self.train_loader.dataset.unnorm_pred(out)
+ unnorm_target = self.train_loader.dataset.unnorm_pred(
+ task["y_target"]
+ )
+
+ unnorm_pred = unnorm_pred + ic
+ unnorm_target = unnorm_target + ic
+
+ lu = (
+ self.loss_function(
+ unnorm_target,
+ unnorm_pred,
+ prev_step,
+ fix_sigma=fix_sigma,
+ expand=True,
+ )
+ .detach()
+ .cpu()
+ .numpy()
+ )
+
+ lf_unnorm.append(lu)
+
+ except:
+ pass
+
+ # Save the test outputs
+ np.save(
+ self.save_path + f"val_forecast_{self.rank}_{self.epoch}.npy",
+ np.concatenate(forecasts, axis=0),
+ )
+ np.save(
+ self.save_path + f"val_targets_{self.rank}_{self.epoch}.npy",
+ np.concatenate(targets, axis=0),
+ )
+ np.save(
+ self.save_path + f"val_stations_{self.rank}_{self.epoch}.npy",
+ np.concatenate(stations, axis=0),
+ )
+ np.save(
+ self.save_path + f"val_indices_{self.rank}_{self.epoch}.npy",
+ np.concatenate(indices, axis=0),
+ )
+
+ if self.test_loader is not None:
+ forecasts = []
+ targets = []
+ stations = []
+ indices = []
+
+ for count, task in enumerate(self.test_loader):
+ out = self.model(task, film_index=0)
+ forecasts.append(
+ unnormalise_hadisd_var(
+ out.detach().cpu().numpy(), self.hadisd_variable_name
+ )
+ )
+ targets.append(
+ unnormalise_hadisd_var(
+ task["y_target"].detach().cpu().numpy(),
+ self.hadisd_variable_name,
+ )
+ )
+ stations.append(
+ task["downscaling"]["x_target"].detach().cpu().numpy() * 360
+ )
+ indices.append(task["index"])
+
+ np.save(
+ self.save_path + f"test_forecast_{self.rank}_{self.epoch}.npy",
+ np.concatenate(forecasts, axis=0),
+ )
+ np.save(
+ self.save_path + f"test_targets_{self.rank}_{self.epoch}.npy",
+ np.concatenate(targets, axis=0),
+ )
+ np.save(
+ self.save_path + f"test_stations_{self.rank}_{self.epoch}.npy",
+ np.concatenate(stations, axis=0),
+ )
+ np.save(
+ self.save_path + f"test_indices_{self.rank}_{self.epoch}.npy",
+ np.concatenate(indices, axis=0),
+ )
+
+ log_loss = np.nanmean(np.array(lf))
+
+ if log_loss < self.best_loss:
+ np.save(
+ self.save_path + "unnorm_preds.npy",
+ self.train_loader.dataset.unnorm_pred(out).detach().cpu().numpy(),
+ )
+ np.save(
+ self.save_path + "unnorm_targets.npy",
+ self.train_loader.dataset.unnorm_pred(task["y_target"])
+ .detach()
+ .cpu()
+ .numpy(),
+ )
+ log_loss_unnorm = np.nanmean(np.stack(lf_unnorm), axis=0)
+
+ if np.logical_and(self.rank == 0, self.epoch % 5 == 0):
+
+ np.save(self.save_path + "preds_eval.npy", out.cpu().numpy())
+ np.save(
+ self.save_path + "y_target_eval.npy", task["y_target"].cpu().numpy()
+ )
+
+ return log_loss, log_loss_unnorm
+
+ def train(self, n_epochs=100):
+
+ torch.cuda.set_device(self.rank)
+ subprocess.run(["cp", "reproduce_training.sh", f"{self.save_path}"])
+
+ train_loss = []
+ ll = []
+
+ fix_sigma = False
+ prev_step = None
+
+ self.epoch = 0
+ epoch_loss, log_loss_unnorm = self.eval_epoch(fix_sigma, 0)
+ train_loss = np.mean(train_loss)
+
+ for epoch in range(n_epochs):
+ self.epoch = epoch
+ self.sampler.set_epoch(epoch)
+
+ epoch_loss, log_loss_unnorm = self.eval_epoch(fix_sigma, epoch)
+ train_loss = np.mean(train_loss)
+ ll.append(log_loss_unnorm)
+
+ self.losses.append(epoch_loss)
+ self.train_losses.append(train_loss)
+ np.save(
+ self.save_path + "losses_{}.npy".format(self.rank),
+ np.array(self.losses),
+ )
+ np.save(
+ self.save_path + "train_losses_{}.npy".format(self.rank),
+ np.array(self.train_losses),
+ )
+ np.save(self.save_path + "rmse_{}.npy".format(self.rank), np.array(ll))
+
+ if epoch_loss < self.best_loss:
+ self.best_loss = epoch_loss
+
+ if self.rank == 0:
+ if self.model.module.decoder == "vit":
+ torch.save(
+ {
+ "epoch": epoch,
+ "model_state_dict": self.model.state_dict(),
+ "optimizer_state_dict": self.opt.state_dict(),
+ "scheduler_state_dict": self.scheduler.state_dict(),
+ "loss": epoch_loss,
+ },
+ self.save_path + "epoch_{}".format(epoch),
+ )
+ else:
+ torch.save(
+ {
+ "epoch": epoch,
+ "model_state_dict": self.model.state_dict(),
+ "optimizer_state_dict": self.opt.state_dict(),
+ "loss": epoch_loss,
+ },
+ self.save_path + "epoch_{}".format(epoch),
+ )
+
+ try:
+ np.save(
+ self.save_path + "preds_train.npy".format(epoch),
+ out.detach().cpu().numpy(),
+ )
+ np.save(
+ self.save_path + "y_target_train.npy".format(epoch),
+ task["y_target"].detach().cpu().numpy(),
+ )
+ except:
+ pass
+
+ self.model.train()
+ train_loss = []
+ with tqdm(self.train_loader, unit="batch") as tepoch:
+ for count, task in tqdm(enumerate(tepoch)):
+ out = self.model(task, film_index=0)
+
+ loss = self.loss_function(
+ task["y_target"], out, prev_step, fix_sigma=fix_sigma
+ )
+
+ loss.backward()
+ tepoch.set_postfix(loss=loss.item())
+ prev_step = out
+
+ self.opt.step()
+ self.opt.zero_grad()
+ train_loss.append(loss.item())
+ if self.model.module.decoder == "vit":
+ if epoch > 20:
+ self.scheduler.step()
diff --git a/official-src/aardvark/unet_wrap_padding.py b/official-src/aardvark/unet_wrap_padding.py
new file mode 100644
index 0000000000000000000000000000000000000000..f601ffda5048af867ad95e0264ef2f0401769347
--- /dev/null
+++ b/official-src/aardvark/unet_wrap_padding.py
@@ -0,0 +1,310 @@
+import math
+
+import torch
+import torch.nn as nn
+
+
+def cylindrical_conv_pad(x, w_pad):
+ return torch.cat([x[..., -w_pad:], x, x[..., :w_pad]], axis=-1)
+
+
+class CylindricalConv2D(nn.Conv2d):
+ """
+ UNet with cylinderical boundary conditions
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int,
+ ):
+ super().__init__(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ )
+
+ assert self.kernel_size[0] % 2 == 1
+ assert self.kernel_size[1] % 2 == 1
+
+ self.h_pad = self.kernel_size[0] // 2
+ self.w_pad = self.kernel_size[1] // 2
+
+ def forward(self, x: torch.Tensor):
+ x = nn.functional.pad(x, (0, 0, self.h_pad, self.h_pad))
+ return super().forward(cylindrical_conv_pad(x, self.w_pad))
+
+
+class CylindricalConvTranspose2D(nn.ConvTranspose2d):
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int,
+ ):
+ super().__init__(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ )
+
+ assert self.kernel_size[0] % 2 == 1
+ assert self.kernel_size[1] % 2 == 1
+
+ self.sh, self.sw = self.stride
+ self.kh, self.kw = self.kernel_size
+
+ self.h_pad = math.ceil(((self.sh - 1) + 2 * (self.kh // 2)) / self.sh)
+ self.w_pad = math.ceil(((self.sw - 1) + 2 * (self.kw // 2)) / self.sw)
+
+ self.h0 = self.sh * self.h_pad - (self.sh - 1) + (self.kh // 2)
+ self.w0 = self.sw * self.w_pad - (self.sw - 1) + (self.kw // 2)
+
+ self._bias = nn.Parameter(10**-3 * torch.randn(out_channels))
+
+ def forward(self, x: torch.Tensor):
+
+ Nh = x.shape[2] * self.sh
+ Nw = x.shape[3] * self.sw
+
+ x = cylindrical_conv_pad(x, self.w_pad)
+ x = nn.functional.pad(x, (0, 0, self.h_pad, self.h_pad))
+
+ x = super().forward(x)
+
+ return x[:, :, self.h0 : self.h0 + Nh, self.w0 : self.w0 + Nw]
+
+
+class Down(nn.Module):
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ p=0,
+ film=False,
+ down=True,
+ attn=False,
+ ):
+
+ super().__init__()
+
+ self.film = film
+ self.attn = attn
+
+ self.conv_1 = CylindricalConv2D(
+ in_channels, out_channels, kernel_size=3, stride=1
+ )
+ if down:
+ self.conv_2 = CylindricalConv2D(
+ out_channels, out_channels, kernel_size=3, stride=2
+ )
+ else:
+ self.conv_2 = CylindricalConv2D(
+ out_channels, out_channels, kernel_size=3, stride=1
+ )
+
+ self.bn_1 = nn.BatchNorm2d(out_channels)
+ self.bn_2 = nn.BatchNorm2d(out_channels)
+
+ self.activation = nn.GELU()
+
+ if film:
+
+ self.gamma_1 = torch.nn.Parameter(
+ torch.ones(10, out_channels, 1, 1),
+ )
+ self.gamma_2 = torch.nn.Parameter(
+ torch.ones(10, out_channels, 1, 1),
+ )
+ self.beta_1 = torch.nn.Parameter(
+ torch.zeros(10, out_channels, 1, 1),
+ )
+ self.beta_2 = torch.nn.Parameter(
+ torch.zeros(10, out_channels, 1, 1),
+ )
+
+ if self.attn:
+ self.mha = AttentionBlock(n_channels=out_channels, n_heads=8)
+
+ def forward(self, xi, film_index=None):
+
+ film_index = film_index[:, 0].int()
+
+ x = self.conv_1(xi)
+ x = self.bn_1(x)
+ if self.film:
+ g1 = torch.index_select(self.gamma_1, 0, film_index)
+ b1 = torch.index_select(self.beta_1, 0, film_index)
+
+ x = g1 * x + b1
+
+ x = self.activation(x)
+ x = self.conv_2(x)
+ x = self.bn_2(x)
+ if self.film:
+ g2 = torch.index_select(self.gamma_2, 0, film_index)
+ b2 = torch.index_select(self.beta_2, 0, film_index)
+ x = g2 * x + b2
+ x = self.activation(x)
+
+ if self.attn:
+ x = self.mha(x)
+
+ return x
+
+
+class Up(nn.Module):
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ p,
+ bilinear=False,
+ film=False,
+ stride=2,
+ attn=False,
+ ):
+ super().__init__()
+
+ self.film = film
+
+ if bilinear:
+ self.up = nn.Upsample(
+ scale_factor=2,
+ mode="bilinear",
+ align_corners=True,
+ )
+ else:
+ self.up = CylindricalConvTranspose2D(
+ in_channels, out_channels, kernel_size=3, stride=stride
+ )
+
+ self.conv = Down(
+ out_channels,
+ out_channels,
+ p=0,
+ film=film,
+ down=False,
+ attn=attn,
+ )
+
+ def forward(self, x1, x2, film_index=None):
+ x1 = self.up(x1)
+ x1 = self.conv(x1, film_index=film_index)
+
+ if x1.shape[-1] != x2.shape[-1]:
+ x1 = x1[..., :, :-1]
+ if x1.shape[-2] != x2.shape[-2]:
+ x1 = x1[..., :-1, :]
+
+ return torch.cat([x2, x1], dim=1)
+
+
+class Unet(nn.Module):
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ div_factor=1,
+ p=0.0,
+ context=True,
+ film=False,
+ film_base=True,
+ ):
+ super(Unet, self).__init__()
+
+ self.n_channels = in_channels
+ self.bilinear = True
+ self.fp = nn.Softplus()
+ self.variances = nn.Parameter(torch.zeros([out_channels]))
+ self.context = context
+ self.film = film
+
+ m = 1
+
+ self.down1 = Down(
+ self.n_channels,
+ m * 128 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.down2 = Down(
+ m * 128 // div_factor,
+ m * 256 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.down3 = Down(
+ m * 256 // div_factor,
+ m * 512 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.down4 = Down(
+ m * 512 // div_factor,
+ m * 512 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.up1 = Up(
+ m * 512 // div_factor,
+ m * 512 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.up2 = Up(
+ m * 1024 // div_factor,
+ m * 256 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.up3 = Up(
+ m * 512 // div_factor,
+ m * 128 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+ self.up4 = Up(
+ m * 256 // div_factor,
+ m * 64 // div_factor,
+ p=0,
+ film=film,
+ attn=False,
+ )
+
+ self.out = nn.Conv2d(
+ m * 64 // div_factor + in_channels,
+ out_channels,
+ kernel_size=1,
+ bias=False,
+ )
+
+ def forward(self, x, film_index=None):
+
+ x1 = x.contiguous()
+ x2 = self.down1(x1, film_index=film_index)
+ x3 = self.down2(x2, film_index=film_index)
+ x4 = self.down3(x3, film_index=film_index)
+ x5 = self.down4(x4, film_index=film_index)
+ x = self.up1(x5, x4, film_index=film_index)
+ x = self.up2(x, x3, film_index=film_index)
+ x = self.up3(x, x2, film_index=film_index)
+ x = self.up4(x, x1, film_index=film_index)
+ x = self.out(x)
+
+ return x.permute(0, 2, 3, 1)
diff --git a/official-src/aardvark/utils.py b/official-src/aardvark/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..9db0e8e04cf71ab5280e74c61787d17f8adfe848
--- /dev/null
+++ b/official-src/aardvark/utils.py
@@ -0,0 +1,23 @@
+from collections import defaultdict
+import numpy as np
+from torch.nn.utils.rnn import pad_sequence
+
+
+def channels_to_2nd_dim(x):
+ return x.permute(*([0, x.dim() - 1] + list(range(1, x.dim() - 1))))
+
+
+def channels_to_final_dim(x):
+ return x.permute(*([0] + list(range(2, x.dim())) + [1]))
+
+
+def collate(tensor_list):
+ out_dict = defaultdict()
+ for k in tensor_list[0].keys():
+ out_dict[k] = [t[k] for t in tensor_list]
+ out_dict[k] = pad_sequence(
+ out_dict[k],
+ padding_value=np.nan,
+ batch_first=True,
+ )
+ return out_dict
diff --git a/official-src/aardvark/vit.py b/official-src/aardvark/vit.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f26c4f0c8a13d43586f09ca3d5063f9c0f645d3
--- /dev/null
+++ b/official-src/aardvark/vit.py
@@ -0,0 +1,298 @@
+"""
+This file is adapted from Nguyen, Tung, et al. "ClimaX: A foundation model
+for weather and climate." arXiv preprint arXiv:2301.10343 (2023).
+Code from this project is available at https://github.com/microsoft/ClimaX
+"""
+
+from functools import lru_cache
+
+import numpy as np
+import torch
+import torch.nn as nn
+from timm.models.vision_transformer import Block, PatchEmbed, trunc_normal_
+
+from architectures import MLP
+
+
+def get_2d_sincos_pos_embed(embed_dim, grid_size_h, grid_size_w, cls_token=False):
+
+ grid_h = np.arange(grid_size_h, dtype=np.float32)
+ grid_w = np.arange(grid_size_w, dtype=np.float32)
+ grid = np.meshgrid(grid_w, grid_h)
+ grid = np.stack(grid, axis=0)
+
+ grid = grid.reshape([2, 1, grid_size_h, grid_size_w])
+ pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+ if cls_token:
+ pos_embed = np.concatenate([np.zeros([1, embed_dim]), pos_embed], axis=0)
+ return pos_embed
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+ assert embed_dim % 2 == 0
+
+ emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])
+ emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])
+
+ emb = np.concatenate([emb_h, emb_w], axis=1)
+ return emb
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+ assert embed_dim % 2 == 0
+ omega = np.arange(embed_dim // 2, dtype=np.float32)
+ omega /= embed_dim / 2.0
+ omega = 1.0 / 10000**omega
+
+ pos = pos.reshape(-1)
+ out = np.einsum("m,d->md", pos, omega)
+
+ emb_sin = np.sin(out)
+ emb_cos = np.cos(out)
+
+ emb = np.concatenate([emb_sin, emb_cos], axis=1)
+ return emb
+
+
+def interpolate_pos_embed(model, checkpoint_model, new_size=(64, 128)):
+ if "net.pos_embed" in checkpoint_model:
+ pos_embed_checkpoint = checkpoint_model["net.pos_embed"]
+ embedding_size = pos_embed_checkpoint.shape[-1]
+ orig_num_patches = pos_embed_checkpoint.shape[-2]
+ patch_size = model.patch_size
+ w_h_ratio = 2
+ orig_h = int((orig_num_patches // w_h_ratio) ** 0.5)
+ orig_w = w_h_ratio * orig_h
+ orig_size = (orig_h, orig_w)
+ new_size = (new_size[0] // patch_size, new_size[1] // patch_size)
+
+ if orig_size[0] != new_size[0]:
+ print(
+ "Interpolate PEs from %dx%d to %dx%d"
+ % (orig_size[0], orig_size[1], new_size[0], new_size[1])
+ )
+ pos_tokens = pos_embed_checkpoint.reshape(
+ -1, orig_size[0], orig_size[1], embedding_size
+ ).permute(0, 3, 1, 2)
+ new_pos_tokens = torch.nn.functional.interpolate(
+ pos_tokens,
+ size=(new_size[0], new_size[1]),
+ mode="bicubic",
+ align_corners=False,
+ )
+ new_pos_tokens = new_pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
+ checkpoint_model["net.pos_embed"] = new_pos_tokens
+
+
+def interpolate_channel_embed(checkpoint_model, new_len):
+ if "net.channel_embed" in checkpoint_model:
+ channel_embed_checkpoint = checkpoint_model["net.channel_embed"]
+ old_len = channel_embed_checkpoint.shape[1]
+ if new_len <= old_len:
+ checkpoint_model["net.channel_embed"] = channel_embed_checkpoint[
+ :, :new_len
+ ]
+
+
+class ViT(nn.Module):
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ h_channels,
+ img_size=[256, 128],
+ patch_size=8,
+ depth=24,
+ decoder_depth=4,
+ num_heads=16,
+ mlp_ratio=4.0,
+ drop_path=0.0,
+ drop_rate=0.0,
+ per_var_embedding=True,
+ ):
+ super().__init__()
+
+ self.img_size = img_size
+ self.patch_size = patch_size
+ default_vars = [str(i) for i in range(in_channels)]
+ self.default_vars = default_vars
+ embed_dim = h_channels
+ self.per_var_embedding = per_var_embedding
+
+ if self.per_var_embedding:
+ self.token_embeds = nn.ModuleList(
+ [
+ PatchEmbed(img_size, patch_size, 1, embed_dim)
+ for i in range(len(default_vars))
+ ]
+ )
+ else:
+ self.token_embeds = nn.ModuleList(
+ [PatchEmbed(img_size, patch_size, in_channels, embed_dim)]
+ )
+ self.num_patches = self.token_embeds[0].num_patches
+
+ self.var_embed, self.var_map = self.create_var_embedding(embed_dim)
+ self.var_query = nn.Parameter(torch.zeros(1, 1, embed_dim), requires_grad=True)
+ self.var_agg = nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
+
+ self.pos_embed = nn.Parameter(
+ torch.zeros(1, self.num_patches, embed_dim), requires_grad=True
+ )
+ self.lead_time_embed = nn.Linear(1, embed_dim)
+
+ self.out_dim = out_channels
+ self.pos_drop = nn.Dropout(p=drop_rate)
+ dpr = [x.item() for x in torch.linspace(0, drop_path, depth)]
+ self.blocks = nn.ModuleList(
+ [
+ Block(
+ embed_dim,
+ num_heads,
+ mlp_ratio,
+ qkv_bias=True,
+ drop_path=dpr[i],
+ norm_layer=nn.LayerNorm,
+ drop=drop_rate,
+ )
+ for i in range(depth)
+ ]
+ )
+ self.norm = nn.LayerNorm(embed_dim)
+
+ self.head = nn.ModuleList()
+ for _ in range(decoder_depth):
+ self.head.append(nn.Linear(embed_dim, embed_dim))
+ self.head.append(nn.GELU())
+ self.head.append(nn.Linear(embed_dim, self.out_dim * patch_size**2))
+ self.head = nn.Sequential(*self.head)
+
+ self.initialize_weights()
+ if not self.per_var_embedding:
+ self.mlp = MLP(in_channels=277, out_channels=256)
+
+ def initialize_weights(self):
+ pos_embed = get_2d_sincos_pos_embed(
+ self.pos_embed.shape[-1],
+ int(self.img_size[0] / self.patch_size),
+ int(self.img_size[1] / self.patch_size),
+ cls_token=False,
+ )
+ self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+
+ var_embed = get_1d_sincos_pos_embed_from_grid(
+ self.var_embed.shape[-1], np.arange(len(self.default_vars))
+ )
+ self.var_embed.data.copy_(torch.from_numpy(var_embed).float().unsqueeze(0))
+
+ for i in range(len(self.token_embeds)):
+ w = self.token_embeds[i].proj.weight.data
+ trunc_normal_(w.view([w.shape[0], -1]), std=0.02)
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=0.02)
+ if m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+
+ def create_var_embedding(self, dim):
+ var_embed = nn.Parameter(
+ torch.zeros(1, len(self.default_vars), dim), requires_grad=True
+ )
+ var_map = {}
+ idx = 0
+ for var in self.default_vars:
+ var_map[var] = idx
+ idx += 1
+ return var_embed, var_map
+
+ @lru_cache(maxsize=None)
+ def get_var_ids(self, vars, device):
+ ids = np.array([self.var_map[var] for var in vars])
+ return torch.from_numpy(ids).to(device)
+
+ def get_var_emb(self, var_emb, vars):
+ ids = self.get_var_ids(vars, var_emb.device)
+ return var_emb[:, ids, :]
+
+ def unpatchify(self, x: torch.Tensor, h=None, w=None):
+ p = self.patch_size
+ c = self.out_dim
+ h = self.img_size[0] // p if h is None else h // p
+ w = self.img_size[1] // p if w is None else w // p
+ assert h * w == x.shape[1]
+
+ x = x.reshape(shape=(x.shape[0], h, w, p, p, c))
+ x = torch.einsum("nhwpqc->nchpwq", x)
+ imgs = x.reshape(shape=(x.shape[0], c, h * p, w * p))
+ return imgs
+
+ def aggregate_variables(self, x: torch.Tensor):
+ b, _, l, _ = x.shape
+ x = torch.einsum("bvld->blvd", x)
+ x = x.flatten(0, 1)
+
+ var_query = self.var_query.repeat_interleave(x.shape[0], dim=0)
+ x, _ = self.var_agg(var_query, x, x)
+ x = x.squeeze()
+
+ x = x.unflatten(dim=0, sizes=(b, l))
+ return x
+
+ def mlp_embedding(self, x):
+
+ return
+
+ def forward_encoder(self, x, lead_times, variables):
+
+ if isinstance(variables, list):
+ variables = tuple(variables)
+
+ if self.per_var_embedding:
+ embeds = []
+ var_ids = self.get_var_ids(variables, x.device)
+ for i in range(len(var_ids)):
+ id = var_ids[i]
+ embeds.append(self.token_embeds[id](x[:, i : i + 1]))
+ x = torch.stack(embeds, dim=1)
+
+ var_embed = self.get_var_emb(self.var_embed, variables)
+ x = x + var_embed.unsqueeze(2)
+
+ x = self.aggregate_variables(x)
+
+ else:
+ x = self.mlp(x.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
+ x = self.token_embeds[0](x)
+
+ x = x + self.pos_embed
+
+ lead_time_emb = self.lead_time_embed(lead_times.unsqueeze(-1))
+ lead_time_emb = lead_time_emb.unsqueeze(1)
+
+ x = x + lead_time_emb
+
+ x = self.pos_drop(x)
+
+ for blk in self.blocks:
+ x = blk(x)
+ x = self.norm(x)
+
+ return x
+
+ def forward(self, x, lead_times=None, film_index=None):
+
+ if lead_times is None:
+ lead_times = torch.ones(x.shape[0]).float().cuda().unsqueeze(-1)
+
+ out_transformers = self.forward_encoder(x, lead_times[:, 0], self.default_vars)
+ preds = self.head(out_transformers)
+ preds = self.unpatchify(preds)
+
+ return preds.permute(0, 2, 3, 1)
diff --git a/official-src/data/grid_lon_lat/era5_x_1.npy b/official-src/data/grid_lon_lat/era5_x_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..bcd12eafdf98ebc1a588ce2aeb1727173b92fe63
--- /dev/null
+++ b/official-src/data/grid_lon_lat/era5_x_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00907116398e8f25089efe261536bdc76937c3d17aa592914cb71852c18c92d9
+size 2048
diff --git a/official-src/data/grid_lon_lat/era5_y_1.npy b/official-src/data/grid_lon_lat/era5_y_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..2e313f4b63e2bff42e6fa7b89a9986764278ff6c
--- /dev/null
+++ b/official-src/data/grid_lon_lat/era5_y_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e09ac41c355484d2c361c8b4ff1dff34b104efcb7b6f1532a75ff422bd5dce35
+size 1096
diff --git a/official-src/data/norm_factors/mean_4u_1.npy b/official-src/data/norm_factors/mean_4u_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..5ff0105c38dd05906992978c505ad17890ad8a1e
--- /dev/null
+++ b/official-src/data/norm_factors/mean_4u_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40376a60ad7d920f9d1c2ab08f4f783aee2f2aa07f5c6ad6e00fadce5c134be1
+size 224
diff --git a/official-src/data/norm_factors/mean_diff_4u_1.npy b/official-src/data/norm_factors/mean_diff_4u_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..2eb326f4359af2ed5d4a749ab2c2b54582d6dd79
--- /dev/null
+++ b/official-src/data/norm_factors/mean_diff_4u_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79c0582e23a3a54afbc13c4249d5af7256c0b10f34da6bf8fd9e1c2daf2c2d06
+size 224
diff --git a/official-src/data/norm_factors/mean_hadisd_tas.npy b/official-src/data/norm_factors/mean_hadisd_tas.npy
new file mode 100644
index 0000000000000000000000000000000000000000..b8878e77c1055a94a33e38e71b80d8d6ae7889ab
--- /dev/null
+++ b/official-src/data/norm_factors/mean_hadisd_tas.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8048980d8fe7ec5f4ba74ae5c6bbadb59d2e846f4be12226e9b958e8a4b3a24e
+size 132
diff --git a/official-src/data/norm_factors/mean_hadisd_ws.npy b/official-src/data/norm_factors/mean_hadisd_ws.npy
new file mode 100644
index 0000000000000000000000000000000000000000..e2aeb062f6e11b0e1cb4c61fbe12b64c15502bb0
--- /dev/null
+++ b/official-src/data/norm_factors/mean_hadisd_ws.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c97ebf30fa59a35582fda96a16a4b98833aae0e8df7fe36db641944398cbe092
+size 136
diff --git a/official-src/data/norm_factors/std_4u_1.npy b/official-src/data/norm_factors/std_4u_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..f85814df9ff495b7735f78f9913b07c430c30bb6
--- /dev/null
+++ b/official-src/data/norm_factors/std_4u_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acad322c1b4ecdcf71d63f48272aaee0d4ab3a89b4ea490e968721b10621ca6d
+size 224
diff --git a/official-src/data/norm_factors/std_diff_4u_1.npy b/official-src/data/norm_factors/std_diff_4u_1.npy
new file mode 100644
index 0000000000000000000000000000000000000000..c02df603b4672f36ad5b7957d635a2af4564274c
--- /dev/null
+++ b/official-src/data/norm_factors/std_diff_4u_1.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50ee4e57a7d460f03b21b1261743fe1667a254e3019f3b3f8c829012d22d873a
+size 224
diff --git a/official-src/data/norm_factors/std_hadisd_tas.npy b/official-src/data/norm_factors/std_hadisd_tas.npy
new file mode 100644
index 0000000000000000000000000000000000000000..765bd868a876fe245854415e2b62eab9483c3d9b
--- /dev/null
+++ b/official-src/data/norm_factors/std_hadisd_tas.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ae2e4568519a0da1bcfdf795dbdccdca6f22feec1a83a18b6665ac1f9a045bc
+size 132
diff --git a/official-src/data/norm_factors/std_hadisd_ws.npy b/official-src/data/norm_factors/std_hadisd_ws.npy
new file mode 100644
index 0000000000000000000000000000000000000000..821e0eab3a59d05f02a838bae11a667d3a08f6e9
--- /dev/null
+++ b/official-src/data/norm_factors/std_hadisd_ws.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9181e9fdaff3adf74ccc2a3816690f367435dc945287ebea2728f0c2b8820bfe
+size 136
diff --git a/official-src/data/sample_data_final.pkl b/official-src/data/sample_data_final.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..cc974f3fd8db6caa9c81c6abc0ca2c59541fbc77
--- /dev/null
+++ b/official-src/data/sample_data_final.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:536459e078220d7a8e5f6d3caa3846c930c6b759dbb21660df73473cbaf01d0c
+size 53759995
diff --git a/official-src/environment.yml b/official-src/environment.yml
new file mode 100644
index 0000000000000000000000000000000000000000..58f7e852518db619e148b7de8e9aa465aa673f7a
--- /dev/null
+++ b/official-src/environment.yml
@@ -0,0 +1,328 @@
+name: npw
+channels:
+ - pytorch
+ - nvidia
+ - conda-forge
+ - defaults
+dependencies:
+ - _libgcc_mutex=0.1=conda_forge
+ - _openmp_mutex=4.5=2_gnu
+ - anyio=4.2.0=py38h06a4308_0
+ - argon2-cffi=21.3.0=pyhd3eb1b0_0
+ - argon2-cffi-bindings=21.2.0=py38h7f8727e_0
+ - asttokens=2.0.5=pyhd3eb1b0_0
+ - async-lru=2.0.4=py38h06a4308_0
+ - attrs=23.1.0=py38h06a4308_0
+ - babel=2.11.0=py38h06a4308_0
+ - backcall=0.2.0=pyhd3eb1b0_0
+ - beautifulsoup4=4.12.2=py38h06a4308_0
+ - blas=1.0=mkl
+ - bleach=4.1.0=pyhd3eb1b0_0
+ - blosc=1.21.5=hc2324a3_1
+ - bottleneck=1.3.7=py38ha9d4c09_0
+ - brotli=1.0.9=h5eee18b_7
+ - brotli-bin=1.0.9=h5eee18b_7
+ - brotli-python=1.0.9=py38h6a678d5_7
+ - bzip2=1.0.8=h5eee18b_5
+ - c-ares=1.19.1=h5eee18b_0
+ - ca-certificates=2024.6.2=hbcca054_0
+ - cartopy=0.21.1=py38h1176785_0
+ - certifi=2024.6.2=pyhd8ed1ab_0
+ - cffi=1.16.0=py38h5eee18b_0
+ - charset-normalizer=2.0.4=pyhd3eb1b0_0
+ - comm=0.2.1=py38h06a4308_0
+ - contourpy=1.0.5=py38hdb19cb5_0
+ - cuda-cudart=12.1.105=0
+ - cuda-cupti=12.1.105=0
+ - cuda-libraries=12.1.0=0
+ - cuda-nvrtc=12.1.105=0
+ - cuda-nvtx=12.1.105=0
+ - cuda-opencl=12.4.99=0
+ - cuda-runtime=12.1.0=0
+ - cycler=0.11.0=pyhd3eb1b0_0
+ - cyrus-sasl=2.1.28=h52b45da_1
+ - dbus=1.13.18=hb2f20db_0
+ - debugpy=1.6.7=py38h6a678d5_0
+ - decorator=5.1.1=pyhd3eb1b0_0
+ - defusedxml=0.7.1=pyhd3eb1b0_0
+ - eccodes=2.35.0=he84ddb8_0
+ - exceptiongroup=1.2.0=py38h06a4308_0
+ - executing=0.8.3=pyhd3eb1b0_0
+ - expat=2.5.0=h6a678d5_0
+ - ffmpeg=4.3=hf484d3e_0
+ - filelock=3.13.1=py38h06a4308_0
+ - findlibs=0.0.5=pyhd8ed1ab_0
+ - fontconfig=2.14.2=h14ed4e7_0
+ - fonttools=4.25.0=pyhd3eb1b0_0
+ - freeglut=3.4.0=h6a678d5_0
+ - freetype=2.12.1=h4a9f257_0
+ - geos=3.8.0=he6710b0_0
+ - glib=2.78.4=h6a678d5_0
+ - glib-tools=2.78.4=h6a678d5_0
+ - gmp=6.2.1=h295c915_3
+ - gmpy2=2.1.2=py38heeb90bb_0
+ - gnutls=3.6.15=he1e5248_0
+ - gst-plugins-base=1.14.1=h6a678d5_1
+ - gstreamer=1.14.1=h5eee18b_1
+ - hdf4=4.2.15=h9772cbc_5
+ - hdf5=1.14.3=nompi_h4f84152_100
+ - icu=73.2=h59595ed_0
+ - idna=3.4=py38h06a4308_0
+ - importlib-metadata=7.0.1=py38h06a4308_0
+ - importlib_metadata=7.0.1=hd3eb1b0_0
+ - importlib_resources=6.1.1=py38h06a4308_1
+ - intel-openmp=2023.1.0=hdb19cb5_46306
+ - ipykernel=6.28.0=py38h06a4308_0
+ - ipython=8.12.2=py38h06a4308_0
+ - jasper=4.2.4=he283c48_0
+ - jedi=0.18.1=py38h06a4308_1
+ - jinja2=3.1.3=py38h06a4308_0
+ - jpeg=9e=h5eee18b_1
+ - json5=0.9.6=pyhd3eb1b0_0
+ - jsonschema=4.19.2=py38h06a4308_0
+ - jsonschema-specifications=2023.7.1=py38h06a4308_0
+ - jupyter-lsp=2.2.0=py38h06a4308_0
+ - jupyter_client=8.6.0=py38h06a4308_0
+ - jupyter_core=5.5.0=py38h06a4308_0
+ - jupyter_events=0.8.0=py38h06a4308_0
+ - jupyter_server=2.10.0=py38h06a4308_0
+ - jupyter_server_terminals=0.4.4=py38h06a4308_1
+ - jupyterlab=4.0.11=py38h06a4308_0
+ - jupyterlab_pygments=0.1.2=py_0
+ - jupyterlab_server=2.25.1=py38h06a4308_0
+ - kiwisolver=1.4.4=py38h6a678d5_0
+ - krb5=1.20.1=h143b758_1
+ - lame=3.100=h7b6447c_0
+ - lcms2=2.12=h3be6417_0
+ - ld_impl_linux-64=2.38=h1181459_1
+ - lerc=3.0=h295c915_0
+ - libaec=1.1.3=h59595ed_0
+ - libbrotlicommon=1.0.9=h5eee18b_7
+ - libbrotlidec=1.0.9=h5eee18b_7
+ - libbrotlienc=1.0.9=h5eee18b_7
+ - libclang=14.0.6=default_hc6dbbc7_1
+ - libclang13=14.0.6=default_he11475f_1
+ - libcublas=12.1.0.26=0
+ - libcufft=11.0.2.4=0
+ - libcufile=1.9.0.20=0
+ - libcups=2.4.2=h2d74bed_1
+ - libcurand=10.3.5.119=0
+ - libcurl=8.5.0=h251f7ec_0
+ - libcusolver=11.4.4.55=0
+ - libcusparse=12.0.2.55=0
+ - libdeflate=1.17=h5eee18b_1
+ - libedit=3.1.20230828=h5eee18b_0
+ - libev=4.33=h7f8727e_1
+ - libffi=3.4.4=h6a678d5_0
+ - libgcc-ng=13.2.0=h77fa898_7
+ - libgfortran-ng=13.2.0=h69a702a_7
+ - libgfortran5=13.2.0=hca663fb_7
+ - libglib=2.78.4=hdc74915_0
+ - libglu=9.0.0=hac7e632_1003
+ - libgomp=13.2.0=h77fa898_7
+ - libiconv=1.17=hd590300_2
+ - libidn2=2.3.4=h5eee18b_0
+ - libjpeg-turbo=2.0.0=h9bf148f_0
+ - libllvm14=14.0.6=hdb19cb5_3
+ - libnetcdf=4.9.2=nompi_h9612171_113
+ - libnghttp2=1.57.0=h2d74bed_0
+ - libnpp=12.0.2.50=0
+ - libnvjitlink=12.1.105=0
+ - libnvjpeg=12.1.1.14=0
+ - libpng=1.6.43=h2797004_0
+ - libpq=12.17=hdbd6064_0
+ - libsodium=1.0.18=h7b6447c_0
+ - libssh2=1.10.0=hdbd6064_2
+ - libstdcxx-ng=13.2.0=hc0a3c3a_7
+ - libtasn1=4.19.0=h5eee18b_0
+ - libtiff=4.5.1=h6a678d5_0
+ - libunistring=0.9.10=h27cfd23_0
+ - libuuid=2.38.1=h0b41bf4_0
+ - libwebp-base=1.3.2=h5eee18b_0
+ - libxcb=1.15=h7f8727e_0
+ - libxkbcommon=1.7.0=h662e7e4_0
+ - libxml2=2.12.7=hc051c1a_1
+ - libzip=1.10.1=h2629f0a_3
+ - libzlib=1.2.13=h4ab18f5_6
+ - llvm-openmp=14.0.6=h9e868ea_0
+ - lz4-c=1.9.4=h6a678d5_0
+ - markupsafe=2.1.3=py38h5eee18b_0
+ - matplotlib=3.7.2=py38h06a4308_0
+ - matplotlib-base=3.7.2=py38h1128e8f_0
+ - matplotlib-inline=0.1.6=py38h06a4308_0
+ - mistune=2.0.4=py38h06a4308_0
+ - mkl=2023.1.0=h213fc3f_46344
+ - mkl-service=2.4.0=py38h5eee18b_1
+ - mkl_fft=1.3.8=py38h5eee18b_0
+ - mkl_random=1.2.4=py38hdb19cb5_0
+ - mpc=1.1.0=h10f8cd9_1
+ - mpfr=4.0.2=hb69a4c5_1
+ - mpmath=1.3.0=py38h06a4308_0
+ - munkres=1.1.4=py_0
+ - mysql=5.7.24=h721c034_2
+ - nbclient=0.8.0=py38h06a4308_0
+ - nbconvert=7.10.0=py38h06a4308_0
+ - nbformat=5.9.2=py38h06a4308_0
+ - ncurses=6.4=h6a678d5_0
+ - nest-asyncio=1.6.0=py38h06a4308_0
+ - nettle=3.7.3=hbbd107a_1
+ - networkx=3.1=py38h06a4308_0
+ - notebook-shim=0.2.3=py38h06a4308_0
+ - numexpr=2.8.4=py38hc78ab66_1
+ - numpy=1.24.3=py38hf6e8229_1
+ - numpy-base=1.24.3=py38h060ed82_1
+ - openh264=2.1.1=h4ff587b_0
+ - openjpeg=2.4.0=h3ad879b_0
+ - openssl=3.3.1=h4ab18f5_0
+ - overrides=7.4.0=py38h06a4308_0
+ - packaging=23.1=py38h06a4308_0
+ - pandas=2.0.3=py38h1128e8f_0
+ - pandocfilters=1.5.0=pyhd3eb1b0_0
+ - parso=0.8.3=pyhd3eb1b0_0
+ - pcre2=10.42=hebb0a14_0
+ - pexpect=4.8.0=pyhd3eb1b0_3
+ - pickleshare=0.7.5=pyhd3eb1b0_1003
+ - pillow=10.2.0=py38h5eee18b_0
+ - pip=23.3.1=py38h06a4308_0
+ - pkgutil-resolve-name=1.3.10=py38h06a4308_1
+ - platformdirs=3.10.0=py38h06a4308_0
+ - ply=3.11=py38_0
+ - pooch=1.7.0=py38h06a4308_0
+ - proj=8.2.1=ha227179_0
+ - prometheus_client=0.14.1=py38h06a4308_0
+ - prompt-toolkit=3.0.43=py38h06a4308_0
+ - psutil=5.9.0=py38h5eee18b_0
+ - ptyprocess=0.7.0=pyhd3eb1b0_2
+ - pure_eval=0.2.2=pyhd3eb1b0_0
+ - pycparser=2.21=pyhd3eb1b0_0
+ - pygments=2.15.1=py38h06a4308_1
+ - pyparsing=3.0.9=py38h06a4308_0
+ - pyproj=3.4.1=py38hb83c990_0
+ - pyqt=5.15.10=py38h6a678d5_0
+ - pyqt5-sip=12.13.0=py38h5eee18b_0
+ - pyshp=2.3.1=py38h06a4308_0
+ - pysocks=1.7.1=py38h06a4308_0
+ - python=3.8.18=h955ad1f_0
+ - python-dateutil=2.8.2=pyhd3eb1b0_0
+ - python-eccodes=1.7.0=py38he82f83a_2
+ - python-fastjsonschema=2.16.2=py38h06a4308_0
+ - python-json-logger=2.0.7=py38h06a4308_0
+ - python-tzdata=2023.3=pyhd3eb1b0_0
+ - python_abi=3.8=2_cp38
+ - pytorch=2.3.0=py3.8_cuda12.1_cudnn8.9.2_0
+ - pytorch-cuda=12.1=ha16c6d3_5
+ - pytorch-mutex=1.0=cuda
+ - pytz=2023.3.post1=py38h06a4308_0
+ - pyyaml=6.0.1=py38h5eee18b_0
+ - pyzmq=25.1.2=py38h6a678d5_0
+ - qt-main=5.15.2=h53bd1ea_10
+ - readline=8.2=h5eee18b_0
+ - referencing=0.30.2=py38h06a4308_0
+ - requests=2.31.0=py38h06a4308_1
+ - rfc3339-validator=0.1.4=py38h06a4308_0
+ - rfc3986-validator=0.1.1=py38h06a4308_0
+ - rpds-py=0.10.6=py38hb02cf49_0
+ - scipy=1.10.1=py38hf6e8229_1
+ - send2trash=1.8.2=py38h06a4308_0
+ - setuptools=68.2.2=py38h06a4308_0
+ - shapely=2.0.1=py38h0fbb895_0
+ - sip=6.7.12=py38h6a678d5_0
+ - six=1.16.0=pyhd3eb1b0_1
+ - snappy=1.2.0=hdb0a2a9_1
+ - sniffio=1.3.0=py38h06a4308_0
+ - soupsieve=2.5=py38h06a4308_0
+ - sqlite=3.41.2=h5eee18b_0
+ - stack_data=0.2.0=pyhd3eb1b0_0
+ - sympy=1.12=py38h06a4308_0
+ - tbb=2021.8.0=hdb19cb5_0
+ - terminado=0.17.1=py38h06a4308_0
+ - tinycss2=1.2.1=py38h06a4308_0
+ - tk=8.6.12=h1ccaba5_0
+ - tomli=2.0.1=py38h06a4308_0
+ - torchaudio=2.3.0=py38_cu121
+ - torchtriton=2.3.0=py38
+ - torchvision=0.18.0=py38_cu121
+ - tornado=6.3.3=py38h5eee18b_0
+ - tqdm=4.65.0=py38hb070fc8_0
+ - traitlets=5.7.1=py38h06a4308_0
+ - typing-extensions=4.9.0=py38h06a4308_1
+ - typing_extensions=4.9.0=py38h06a4308_1
+ - urllib3=2.1.0=py38h06a4308_1
+ - wcwidth=0.2.5=pyhd3eb1b0_0
+ - webencodings=0.5.1=py38_1
+ - websocket-client=0.58.0=py38h06a4308_4
+ - wheel=0.41.2=py38h06a4308_0
+ - xarray=2022.11.0=py38h06a4308_0
+ - xkeyboard-config=2.42=h4ab18f5_0
+ - xorg-kbproto=1.0.7=h7f98852_1002
+ - xorg-libx11=1.8.9=h8ee46fc_0
+ - xorg-libxau=1.0.11=hd590300_0
+ - xorg-libxext=1.3.4=h0b41bf4_2
+ - xorg-xextproto=7.3.0=h0b41bf4_1003
+ - xorg-xproto=7.0.31=h7f98852_1007
+ - xz=5.4.6=h5eee18b_0
+ - yaml=0.2.5=h7b6447c_0
+ - zeromq=4.3.5=h6a678d5_0
+ - zipp=3.17.0=py38h06a4308_0
+ - zlib=1.2.13=h4ab18f5_6
+ - zstd=1.5.5=hc292b87_0
+ - pip:
+ - aiohttp==3.9.3
+ - aiosignal==1.3.1
+ - appdirs==1.4.4
+ - asciitree==0.3.3
+ - async-timeout==4.0.3
+ - black==24.4.2
+ - cachetools==5.3.3
+ - cfgrib==0.9.12.0
+ - cftime==1.6.3
+ - click==8.1.7
+ - click-plugins==1.1.1
+ - cligj==0.7.2
+ - docker-pycreds==0.4.0
+ - eumdac==2.2.2
+ - fasteners==0.19
+ - fiona==1.9.6
+ - frozenlist==1.4.1
+ - fsspec==2024.3.1
+ - gcsfs==2024.3.1
+ - geographiclib==2.0
+ - geopandas==0.13.2
+ - geopy==2.4.1
+ - gitdb==4.0.11
+ - gitpython==3.1.42
+ - google-api-core==2.17.1
+ - google-auth==2.28.2
+ - google-auth-oauthlib==1.2.0
+ - google-cloud-core==2.4.1
+ - google-cloud-storage==2.16.0
+ - google-crc32c==1.5.0
+ - google-resumable-media==2.7.0
+ - googleapis-common-protos==1.63.0
+ - h5py==3.10.0
+ - huggingface-hub==0.22.2
+ - multidict==6.0.5
+ - mypy-extensions==1.0.0
+ - netcdf4==1.6.5
+ - numcodecs==0.12.1
+ - oauthlib==3.2.2
+ - pathspec==0.12.1
+ - plotly==5.20.0
+ - protobuf==4.25.3
+ - pyasn1==0.5.1
+ - pyasn1-modules==0.3.0
+ - ratelimiter==1.2.0.post0
+ - requests-oauthlib==1.4.0
+ - rsa==4.9
+ - safetensors==0.4.3
+ - scienceplots==2.1.1
+ - sentry-sdk==1.42.0
+ - setproctitle==1.3.3
+ - smmap==5.0.1
+ - tenacity==8.2.3
+ - timm==0.6.13
+ - tokenize-rt==5.2.0
+ - wandb==0.16.4
+ - yarl==1.9.4
+ - zarr==2.16.1
+prefix: /home/azureuser/miniconda3/envs/npw
diff --git a/official-src/notebooks/data_demo.ipynb b/official-src/notebooks/data_demo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..87aec56a3b2e42cf78152d29152af80a38666901
--- /dev/null
+++ b/official-src/notebooks/data_demo.ipynb
@@ -0,0 +1,386 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f329e4f1-6dd9-4f2e-b5b3-0e8454832eee",
+ "metadata": {},
+ "source": [
+ "# Dataset\n",
+ "This notebook provides an example of the data utilised to generate a forecast using Aardvark Weather. We explore a single timeslice containing all the observations required to generate a forecast. This sample data is the output of the loader `WeatherDatasetE2E` in `../aardvark/loaders.py`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "c17595b2-a624-440b-a2be-6af8d3802f87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import pickle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "bc8b869d-33d4-45e5-b3ef-15d4e521e3d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib\n",
+ "from matplotlib import pyplot as plt\n",
+ "\n",
+ "matplotlib.rcParams['mathtext.fontset'] = 'stix'\n",
+ "matplotlib.rcParams['font.family'] = 'STIXGeneral'\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6de4a11f-4677-4552-8630-6b395c27012e",
+ "metadata": {},
+ "source": [
+ "## Data\n",
+ "Open a sample of data required to produce a forecast."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0483c01d-2e08-469c-b914-42532cc3099b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open('../data/sample_data_final.pkl', 'rb') as fp:\n",
+ " data = pickle.load(fp)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83b7c966-fab5-47ce-a91c-d5419acaee40",
+ "metadata": {},
+ "source": [
+ "Multiple different datasets are utilised as input to create a forecast, each with multiple channels including observations and metadata. Example channels for each of these are plotted below. The plot_channel variable in each cell can be adjusted to visualise different channels. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "693aa212-c3ab-4eda-b07a-a6b262da627d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set up longitude and latitude for plotting\n",
+ "lon = np.linspace(0,359,360)\n",
+ "lat = np.linspace(90,-90,181)\n",
+ "\n",
+ "lon_1p5 = np.linspace(0,359,240)\n",
+ "lat_1p5 = np.linspace(90,-90,121)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42a2524f-108a-4ed7-bc89-2fb91638a7aa",
+ "metadata": {},
+ "source": [
+ "## Satellite\n",
+ "First visualise the satellite data from HIRS, AMSU-A, AMSU-B, IASI and ASCAT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1243f422-351a-458c-aaa9-4bf72a959678",
+ "metadata": {},
+ "source": [
+ "### HIRS"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0d750dcc-cfef-4ca5-8f14-a7bae45980f4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 11\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " data[\"assimilation\"][\"hirs_current\"][0,...,plot_channel].cpu().T, \n",
+ " levels=100,\n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised radiance') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"HIRS channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5c5e48e-3bab-461f-8425-9efa10c415e0",
+ "metadata": {},
+ "source": [
+ "### AMSU-A"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "79deb284-7ed8-47d2-9006-a13a06d2b835",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 8\n",
+ "p = plt.contourf(\n",
+ " lon, \n",
+ " lat[:-1],\n",
+ " data[\"assimilation\"][\"amsua_current\"][0,...,plot_channel].cpu(), \n",
+ " levels=100,\n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised radiance') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"AMSU-A channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b481a5c-97ad-4016-826d-93771531ad2d",
+ "metadata": {},
+ "source": [
+ "### AMSU-B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "466434e7-7296-4454-b14c-6ab40bfbe0d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 10\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " data[\"assimilation\"][\"amsub_current\"][0,...,plot_channel].T.cpu(), \n",
+ " levels=100,\n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised radiance') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"AMSU-A channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44de7c3f-6a25-47eb-bcfe-ab7bc82a1aac",
+ "metadata": {},
+ "source": [
+ "### IASI"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d5a5caf9-ecc4-403d-97ff-6c96dbc18f13",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 10\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " data[\"assimilation\"][\"iasi_current\"][0,...,plot_channel].T.cpu(), \n",
+ " levels=100,\n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised radiance') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"IASI channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ea0ac772-4150-4bfd-96de-004ac7b8b6b4",
+ "metadata": {},
+ "source": [
+ "### ASCAT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9981b9c6-2d88-47a1-b135-f70f1335df78",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 5\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " data[\"assimilation\"][\"ascat_current\"][0,...,plot_channel].T.cpu(), \n",
+ " levels=100,\n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised radiance') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"ASCAT channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b6849d1-c6fd-413f-a72e-3de111228a78",
+ "metadata": {},
+ "source": [
+ "## SYNOPS\n",
+ "We next visualise the SYNOPS data from land stations, marine platforms and radiosonde profiles"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c392b951-b446-4fde-aacb-02be7759bc97",
+ "metadata": {},
+ "source": [
+ "### HadISD"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "611eed9e-8c4a-4ac8-82f4-9969a6ef8eb7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = plt.figure()\n",
+ "plot_channel = 0\n",
+ "p = plt.scatter(\n",
+ " data[\"assimilation\"][\"x_context_hadisd_current\"][plot_channel][0,0,:].cpu(),\n",
+ " data[\"assimilation\"][\"x_context_hadisd_current\"][plot_channel][0,1,:].cpu(),\n",
+ " c = data[\"assimilation\"][\"y_context_hadisd_current\"][plot_channel][0].T.cpu(), \n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised value') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"HadISD channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b2ae8c40-28bd-49ad-8a2f-b9f7df706834",
+ "metadata": {},
+ "source": [
+ "### ICOADS"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1e425818-5a30-4641-abc7-08cfd4c6b4fe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_channel = 1\n",
+ "fig = plt.figure()\n",
+ "p = plt.scatter(\n",
+ " data[\"assimilation\"][\"icoads_x_current\"][0][0,:].cpu(),\n",
+ " data[\"assimilation\"][\"icoads_x_current\"][1][0,:].cpu(),\n",
+ " c = data[\"assimilation\"][\"icoads_current\"][0,plot_channel,:].T.cpu(), \n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised value') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"ICOADS channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "14d103a9-053c-4576-b17f-35ebae3fa44a",
+ "metadata": {},
+ "source": [
+ "### IGRA"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "11d5f5de-22ea-4d6e-a590-c1ce0a842a53",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_channel = 1\n",
+ "fig = plt.figure()\n",
+ "p = plt.scatter(\n",
+ " data[\"assimilation\"][\"igra_x_current\"][0][0,:].cpu(),\n",
+ " data[\"assimilation\"][\"igra_x_current\"][1][0,:].cpu(),\n",
+ " c = data[\"assimilation\"][\"igra_current\"][0,plot_channel,:].T.cpu(), \n",
+ " cmap=\"magma\")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label('Normalised value') \n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"IGRA channel {plot_channel}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2b893a77-4c30-4f18-a7fb-b007a676d849",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "521c93b6-babf-41fe-8dc6-c9a6eaef5b6f",
+ "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.8.18"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "ff379d8b57ea10bc9abbe40475203c855480f57b5b4821ba344a2e4e1a8a455a"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/official-src/notebooks/e2e_finetune_demo.ipynb b/official-src/notebooks/e2e_finetune_demo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0bd23ecbad1eff52bb3bbc194d426093eed81bd8
--- /dev/null
+++ b/official-src/notebooks/e2e_finetune_demo.ipynb
@@ -0,0 +1,258 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "017a4962-3877-41ad-b03d-ce50a3079037",
+ "metadata": {},
+ "source": [
+ "# End to end optimised forecast demo\n",
+ "Here we load the trained Aardvark Weather model and produce end-to-end finetuned forecasts at one day lead time for temperature and windspeed. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "50e8c3f2-072b-4ec6-9c97-3b5e1aac3331",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "sys.path.append(\"../aardvark\")\n",
+ "import numpy as np\n",
+ "import pickle\n",
+ "from e2e_model import *\n",
+ "from matplotlib import pyplot as plt\n",
+ "import matplotlib\n",
+ "matplotlib.rcParams['mathtext.fontset'] = 'stix'\n",
+ "matplotlib.rcParams['font.family'] = 'STIXGeneral'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "084e747e-f3f3-4536-91f3-7e9bde7266b5",
+ "metadata": {},
+ "source": [
+ "Check a GPU is available"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "4824826f-ab1d-426a-a950-2fc33a1b1c9c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "GPU is available.\n",
+ "GPU name: NVIDIA A100 80GB PCIe\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "\n",
+ "if torch.cuda.is_available():\n",
+ " print(\"GPU is available.\")\n",
+ " print(f\"GPU name: {torch.cuda.get_device_name(0)}\")\n",
+ "else:\n",
+ " print(\"GPU is not available, cannot produce forecast.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0b3efa68-bd05-4184-8947-f32b7c8409c1",
+ "metadata": {},
+ "source": [
+ "## Generate predictions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34becb06-8c0c-4df3-a6c2-3bb688e5303b",
+ "metadata": {},
+ "source": [
+ "Load the sample data (for a detailed analysis and visualisation of the contents of this dataset see data_demo.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "d86feadf-42e7-4527-a58e-9e2f7e04a4e5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open('../data/sample_data_final.pkl', 'rb') as fp:\n",
+ " data = pickle.load(fp)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3f9c07a6-6494-4bb1-90ea-09845a9700a0",
+ "metadata": {},
+ "source": [
+ "Load the end to end model. First select which varaible to generate station forecasts for."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "381349ab-027a-4a99-aded-199a69b769b3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "local_forecast_var = \"tas\" # Model weights included for windspeed (ws) and 2tm (tas)\n",
+ "\n",
+ "model = ConvCNPWeatherE2E(\n",
+ " device=\"cuda\",\n",
+ " lead_time=1,\n",
+ " se_model_path=\"../trained_models/encoder\",\n",
+ " forecast_model_path=\"../trained_models/processor\",\n",
+ " sf_model_path=f\"../trained_models/decoder/{local_forecast_var}/\",\n",
+ " return_gridded=False,\n",
+ " aux_data_path=\"../data/\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c7bdf661-d025-4d3c-a889-4bf757622259",
+ "metadata": {},
+ "source": [
+ "Load the trained weights"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "706c124f-c9a5-4c40-a9e5-b401cb32c3c8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "weights_path = f\"../trained_models/e2e_finetuned/{local_forecast_var}/\"\n",
+ "best_epoch = np.argmin(np.load(weights_path+\"losses_0.npy\"))\n",
+ "state_dict = torch.load(\n",
+ " f\"{weights_path}/epoch_{best_epoch}\", map_location=\"cuda\"\n",
+ ")[\"model_state_dict\"]\n",
+ "state_dict = {k[7:]: v for k, v in zip(state_dict.keys(), state_dict.values())}\n",
+ "model.load_state_dict(state_dict)\n",
+ "model = model.to(\"cuda\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "3cc40cf1-9cf8-450f-ad7b-df8ca4263550",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "station_forecast = model(data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "93705b33-26a0-4611-9cb5-a539d5ca7c53",
+ "metadata": {},
+ "source": [
+ "## Visualise model predictions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a609e1e1-6ded-4062-8d3f-9d7eb50f2e2d",
+ "metadata": {},
+ "source": [
+ "Plot the station forecasts"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "ace805a6-44d0-45cd-98fa-0155aff3fa01",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "STATION_LON_LAT_SF = 360\n",
+ "HADISD_SCALING_FACTOR = 10\n",
+ "# Factors to unnormalise predictions\n",
+ "mean = np.load(f\"../data/norm_factors/mean_hadisd_{local_forecast_var}.npy\")\n",
+ "std = np.load(f\"../data/norm_factors/std_hadisd_{local_forecast_var}.npy\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "09d5649c-3c96-4a32-b1b2-9790152085ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "station_forecast_unnorm = (\n",
+ " station_forecast.detach().cpu() * std + mean\n",
+ ") * HADISD_SCALING_FACTOR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "a39790cc-4faa-49c6-89e9-d3bdeb7d0fbf",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyIAAAHTCAYAAADbHKzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9edQl2VXeCf/OORFxp3fMObPmWag0goSFERgE2K22Jcugj6ZpYLm/zz0sA24bL9rLLJaBD7y87F5tMbUbsPFn47GxsBAzkkCAhgLNqkJVqjEzKyvnfKc7x3DO/v44EXHn932zcixVPGtlVeYd4p6IGzdiP3s/+9lKRIQKFSpUqFChQoUKFSpUuInQt3oBFSpUqFChQoUKFSpUePWhIiIVKlSoUKFChQoVKlS46aiISIUKFSpUqFChQoUKFW46KiJSoUKFChUqVKhQoUKFm46KiFSoUKFChQoVKlSoUOGmoyIiFSpUqFChQoUKFSpUuOmoiEiFChUqVKhQoUKFChVuOioiUqFChQoVKlSoUKFChZuOiohUqFChQoUKFSpUqFDhpqMiIhUqVKhQoUKFChUqVLjpqIhIhQoVKryCMBwOb/USKlSoUKFCheuCiohUqFChwisETz/9ND/3cz93q5dRoUKFChUqXBdURKRChQoVXgHY2trive99L71e71YvpUKFChUqVLguCG71AipUqFChwt74wAc+wOnTp/m93/s9tre3+eEf/mH+3b/7d/R6PYIg4LHHHuOXf/mXueOOOwD4lV/5Fc6dO4dSiv/z//w/+dCHPsSb3vSmW7sTFSpUqFChwhiUiMitXkSFChUqVNgb9957L3/zb/5NfvzHf5zf+I3f4L3vfS9xHKOU4l3vehdHjhzhl3/5lxkOh9x3332cP38egPe///08+OCDFRGpUKFChQq3FSppVoUKFSq8AvHa176WH/mRH0EpBcDy8jInT54EIE1Trly5wr/4F/8CgHe/+93cfffdt2ytFSpUqFChwjxURKRChQoVXoF48MEH+Uf/6B/xq7/6q/zsz/4sZ8+exTkHeFLyEz/xE3z/938/73znOzl37hwHDhy4xSuuUKFChQoVJlERkQoVKlR4BeLKlSu8/e1vZ3l5mb/zd/4O991338TzP/IjP8L73/9+nnjiCd74xjfyiU984hattEKFChUqVJiPiohUqFChwisESimKtr4f/dEfJY5j3vnOdwKU1RCAixcv8vjjj/Md3/EdPPXUU7z+9a/n//g//o9bsuYKFSpUqFBhESoiUqFChQqvEBw4cICnn36aNE15+umnefHFFzl//jzPPvssn/rUp7h48SKXLl1iMBjwi7/4i4CXab33ve/lxIkTt3j1FSpUqFChwiQqIlKhQoUKrxD87b/9t/nt3/5tvv3bv50f+IEfIAxD3vCGN/Af/sN/4Cd+4ic4d+4cP/VTPwXAL/zCL/CDP/iD/MIv/AJPPvkkP/mTP3mLV1+hQoUKFSpMorLvrVChQoUKFSpUqFChwk1HVRGpUKFChQoVKlSoUKHCTUdFRCpUqFChQoUKFSpUqHDTURGRChUqVKhQoUKFChUq3HRURKRChQoVKlSoUKFChVcQPv/5z/P2t7+dAwcO8K3f+q1cuXIFgJMnT/K//q//K7/0S7/E933f93H69OlbvNLdURGRChUqVKhQoUKFChVeIRgOh/zar/0aH/rQhzhz5gz9fp9//s//Oc453v3ud/Od3/md/M//8//M937v9/Jd3/Vdt3q5u6JyzapQoUKFChUqVKhQ4RWCixcvsr6+ThRFAPyDf/APCMOQr//6r+fbv/3babfbhGGItZaVlRX+6I/+iLe+9a23eNXzEdzqBdwKOOc4d+4cy8vLKKVu9XIqVKhQoUKFChUqTEFE6HQ6nDhxAq1vPxHPcDgkSZLrsi0RmYlJa7UatVpt5rVHjx4t/54kCRcuXOCf//N/zs/8zM9w//33E4YhAMYY7r//fj760Y9WROR2wrlz57jrrrtu9TIqVKhQoUKFChUq7IEzZ85w55133uplTGA4HHKwsUQfe122t7S0RLfbnXjsx37sx/jxH//xhe/5nd/5HX70R3+UK1eu8KUvfYmLFy+ysrIy8ZrV1VXOnj17XdZ4I/CqJCLLy8uAP7Gnv7AKFSpUqFChQoUKtx7tdpu77rqrjNtuJyRJQh/L93EH0TW2XCc4fqV7diYunVcNGcdf+St/hde85jX8yI/8CN/zPd/Du9/97rIaUsA5h3PumtZ3I/GqJCJF6WtlZaUiIhUqVKhQoUKFCrcxbmcZfYQmUtcoG8u7ta82Li2kV//6X/9rDh48yOHDh2m32xOv2dnZ4Y477ri29d1A3H6CuwoVKlSoUKFChQoVXgEwSl2XP9eCZrPJoUOH+KZv+iZOnjxJ4UOVpimnTp3im7/5m6/Hrt4QVESkQoUKFSpUqFChQoWXAa3AXOMffZU8ZGNjg9/8zd8sCccf//Ef873f+718wzd8AydOnOBjH/sYAH/yJ3/Cvffey9d+7dde792+bnhVSrMqVKhQoUKFChUqVHgl4uTJk/ytv/W3eOSRR3jve9/L0tIS//gf/2OUUnzwgx/kp37qp3jiiSd47LHH+MAHPnBbS9telXNE2u02q6ur7OzsVD0iFSpUqFChQoUKtyFu53itWNsPmHuoXWOPSCyOn7enb8v9vNGoKiIVKlSoUKFChQoVKrwMFPKqa9rG9VnKKxJVj0iFChUqVKhQoUKFChVuOqqKSIUKFSpUqFChQoUKLwPXw/XKcPv2cNxoVESkQoUKFSpUqFChQoWXgUqadW2opFkVKlSoUKFChQoVKlS46agqIhUqVKhQoUKFCtcRIkLmHNYKSkEYGPRtbKFa4eWjkmZdGyoiUqFChQoVKlSocJ2QWUtnkOCmpiPUo4BmFN7WMx0qXD0U1y4vejWfEZU0q0KFChUqVKhwW0NEEGe53UefZdax049nSAjAMMnoxcktWFWFCrcvqopIhQoVKlSoUOG2hKQJtreFDLv+AaXRzRV0aw2lb78W30GS7vp8nFoakcPoKg/8lYJKmnVtqIhIhQoVKlSoUOG2g0sG2M3zwFh1QRyut43rt9GtdXStgQprt2yN4xARkszu+bo4tTRr14+IiAjOCSjQSlXSr5uMyjXr2lARkQoVKlSoUKHCbQURwW5fZIKETLzA4bobuC4Q1AjWjqKC8GYucQbz5FjX8rq9ICKkaUZmJ8lPGAQEgakISYVXBCoiUuG2gMtSXNwDZ0EZdL2JDqKr2oaIIDYDBKUD1C0ofYuI3xebgQjKBJgwRKmqDF+hQoUK+4UkfX8/2A+ymGzzLMHBO1Hm1oU1+3XFulYZD/h7zTBO5vbMpKm/BwXGoLT2fypScsPgKyLXKs169aIiIhWuCyRLkDQGpVBRc98kQESw3W1PQsbghl1U1CBYPoBSChGHiwe4dOgD/CDC1JooE/jgP+5jhz0QV25DhXWC5spNIyTOWtJhD8ZvDDbDJkOCehNzi7N1FSpUqPBKgaRX2dTtLK6/g1k+eGMWtA8opYgCs6c8KwqvPezM7ILGfXFosWAhs2mxMIKojgmqkK/C7YfqrKxwTZAsxe5chGQw9qhCtdbQywf3zMLYfnuGhJTbTgbY3ja6vkTW2ZggGZIluGEX01pFrMXF/dn3p0PSTkq4fPCGkxERIR30WCQjyIZ9VHMJfRXNlSLOb67S/FaoUOEmQGyG6+/gBh1wDozxjeGN1ZtfYX4Z1zzX79xSIgLQrIWkmV0kKKMRBdelUT2bR3YKEjLzuJDFA6BRkZEbgKpH5NpQnZEVXjbEZtiNM3PK54L0tnA2w6wfW/x+cbhBd9fPcMMeLo0nSMg4bG8HUItvWs5i4x5BY3nXz3k5EBFcOsTFfSQrMk8GTABzpFg2SdD1xp7bdckAO+giRTZLG0y9ha61rpqQuCzFJQPEWlAKHdXRYa0iNhUqVJiAZCnZ5tnJ67nNcJ1N3KBDcOCOm+pSpWstXGfj6t40Lwi/yTBas9qq0x0mZHasQg80aiH18PqEXTPVEJGShCy6umfJEG2u/j5SYXdUrlnXhoqIvEIgWeozVckAUOhaA91cQZlbJ/dxva1dNbwy7CDpGiqsz38+TVjYiDjxwvkkZOwF7DYOyMV9uM5ERETI+jtIMiwfU4CIhcyCiWDqpu2yFNidiNhBBzvoTD7orK8cpQnB0vrCm4iIA5sBCtEGN+zixtYHYLMEqw3h0vot6aGpUKHC1UFEyKzDOn8dDI3BmOv/2822Lyy+nmcptn2FYO3odf/cRVBBiKovjWx794PbxM7XaM1qs451/ntTKAJzffs0FNN3T9k7lM1nsdzKPpoKFaZRnY2vALhBB7tzafKxLMZ1t1Arh1EIylkwAaq+fNMCTOm393yN67cxq/OJCPtxDrkeF24RROS63gRcMpggIQXKm4NNQNWn1r/7/rosnSUh4+9Oh7hkgKk1Jx93DtfbyqtL+Wcojehg/o3ZZmS9HcLl9duiwb9ChQrzkVlLf5hMXDniNMNoTbMe7bs5ei+4dAjZ7j0ZMuwi7tBNrYqY1cNY53zj+j6gm6s3eEVXB6P1DZsXYgIzIc/a75lwuw+EfCVCXwdp1qv5zlsRkdscksYzJASRvEogsHPBB5PkjymNXj2KXjpwY9dVrmEPuGzhU7faavFaMK8npUBJRlwGYxWrvW7gi3plJl4z7E0QEXGObOs82MkhWiIOlcWejBjDxG1KBEkHJB0gHXgteL5yXW9imrdAD16hQoUJWOfoDeeTA+sc/WFMq359ZJaSxvt+nZpKhNxIKKUx68eQNMYNOkjcX3xPMQG6uXLT1narEQbBBBHZL72oZFnXH5U069pQEZHbHG666iBS6mDL01apXJ1kQCxu+7zvB2it39jFKb03GdGLTzFlAlRY2/0mqDT7v8QuWELUuK4X31EVYc8XeqmDy/LjpEhd6vs95lgTi01H7xHnv1dtJvpNxj/XO45tQDrMKy+jXhkl4k8Jl4HL/BFUOv+Tny8zxEdwwx6SJgRrhyvL4QoVbiHiZPdrjHVeshUG116hUPsNgq7TdVRshnSuIN1c3hvWUMuHUK21mWu1UgoV1dFR3ffldbdw/e2JirqqtTArN7dac6uhlKJei4iTNK9yqPJOufBbUupVdYwqvDJQEZHbHDOZ9zzwn7nQKOUvzAUZ2bmIas5e1K8XlFKo5grS2971dbqxe4YqWFon3b40n9AoRbC0Ttbd3H0xJtylV0Vh6q3d309OLoZd3/eSJaANurWGuha3GHEoa8c6WARJY7I0xjSWZ9eVZaikP6v91QESRP47zr9PF/dw2xchi8tzQVD+WMwhEL5/xfnjrINdAwrJEmx7A609aVG11m0zubhChVcDRITU7t14nVp7fYhItLeJBkq97OuAOOcTMkr7BvgLz01WNuIMiXtIdxN99L6FSRClFGb5AHppLZfGCiqovep6HopkmHOOUOPvEQLi1Mg4ZQ6CqDIquRGoXLOuDa+uX+8rEmMhqQi7NqQVFxhR4CwS91D1pflbdQ7pbSG9TS/rMQGqdQDVWt93xkS31n1PwwISoOpLqGhBf0jxGhMQrh3FDjq4YWF/m0uEGst+IGBrHdvbmr+GqIluLmP7HSSd6tnQhqC1NnGTEptBFvsbYljPZ5SId/8aTvZnuKQPnSuYw/dOmAIopVBBhOyiqS6Ix+jvk7CDDiqI0Lk8zcV9VNydm9ESl6EyQULveGW3LyDtyzkx0WOkQvLv0pOW6c8tCY44T1jnwVmUTSAbUlLDzgbUmpi1Y6+6bJor+ovAE7MKFabgRLDWIcgN7QmYh+ul91dBiKq1kDnyUAEIakitRTroo43BhNG+rgViM2x3a7RdEVTc9T2N8zDs4LYuYA6c2H29St9UidjtBGcz0mF/psdSByFhrYEzhiyOmUxnKYJarZpldYNQEZFrQ0VEbnOoqDHmGrI/V4wSCy724izu0gte0jP2Wtk+j3Q30Efu35cblzIB5uCd2O2Lk9sCVHMVvXJ4z2347RiCpTWktUpBRMazNqbWQBmDHfbGsmAhpr6EysmEXlrzGaLciUuZABVE5XbEZridi8hgTOqmDXrpoJ+CPlzQJJ4l2I2XCI7cN/GwqbfIuvscuCWeIKi8KRxtEBNi4z468M2VhU3lvO9X4b8zkgGqc2W2eqQNaONJ1X6IgjiQcQIzelzZBfsU97Gb5zAH77xtMmqSpbhBp+ytUUHkZx7sJ7u7B5xzDJO0dCoC0FpRC0MC82q+ZVQoICIMkpR0ap6D0ZpmLULrl/87UUqVRe7dcD3JsVk94vvNxq7logxSXymln2IzrM2wSUxQa2CixRUSsZnf3vh9yGWLSUjxvvYl3Oph9C10hLxd4azN51XNeS5LyYCw3kSbAGcLia9GG3PbXLcrVJhGRURuc+jmKrYkIld5IVlwF3NbZ2eIQ4kswW28hJkKvBdBBRHBobuQNEayGFCoWvNlZc5V0ecwBzqI0EuzfRUT7zcBZk6JXpzFXj4109CNs7j2pZnXzyDpI8lgQr6gwxqmsTzf5aqQFYjzFYYxxxcFiHVom+LEQWvVV2mSARSGAyKjakfR92EzTBZPbGd8/wA/v2SPc2SsdjL7XN5/MrMFZ71cbdjBdTegvoxePYK6AbNZ9guXDDwBHoMkA2wyQJor6NZim+O9UDQCz3ymEwZxQqMWVWTkVQ4RoR9PzokoYJ2jOxyy1Khfk6tVLQgYprv3iUTXQZZVQGlNcOAEEvd9Y7hYJGgulHFm8QCldVnVnYYt+j/G4calqgvWAcjWeTh098vaj69kZHOcGsfhshTnLFqbanDhTUTVrH5t+Io5U8+dO8eJE7uXc1+J0FEdWT5YZsz3bEYbe5XM6bsQm0J/Z/cPjbveHeUq9MAqrN22fQSuszFLQq4SEvdmdNSm3vJSqbifDx/MBwZGddL2BjhB5RPnx7+v4u86HXo5mja5XnpKhpc3uKPM4koFYxUTbZhPMab2Ze6D3gRh5rzKElQ6pGyFFIHBDm6wg1o/gV5bPLDyRkGcxW4vJpCu387nuOhSL63z83M/5CROdj9XhnFCq1GvMoyvYljn5pKQAiKQpBn16OVn9aMwILEW5+b/pmvh7hO6nXOk1iICgdYE+yAtSilUvYWut7BpghvubpubJTHRHCIizs2Vee0X3irYvuqkoLthvyYpLk3Rteq43UwYroM061Xsqnxbi54vX75MFEV5mXr058knn0REePjhh8vHvud7vudWL/eGwbTWMAfuQDWWQAeLSUjeQ4JzqDRGXT6FO/UF3MXnR/KuPDDeC/v1bb/dIeKnvO/xIq662pRDmYCguUK4fJBw+QCm1kQpjQ5rOfnZXU7nelu+yrCQQOQEYT9a8KIZvewVEoj7sHUeLp+EK6eR7gbkU9Zn9mX6AZtB0geXol2aO3CluQuYIFvnrm7Y2HWCG47NSwH8yot+GY0o7QdD9tu4ZIBLBmS9bdKdy3veyJ1zE3KseRDY8zUVvrKRZHs3kifZPpz1doFSiqV6babqoZWiEYULSY7LK3qdQcwwyYjTjF6c0O4NJuxe94Lbpem5gNhsfp/KIovd3e5fxTaLv+zTUvhVgzw5pdKBr7Jn8VzVQzUnpMIrDbd1ReSDH/wgH/jAB3j00UcBSNOU97znPbz2ta/ld37nd/g7f+fv8La3vQ2A++7bn5TolQqfaT/m7Qvbl5FpJymVtyJnCSqbuoB3N3wAevBueNU1+O1j3snsiNrZl0RXd9xMrYnkVaxdEftAf3fInnIG/zIZkREUdC6j+jvlewVQ3U3obSOH7oHxCo+atX5USQ8ldibkl0I+pgNc+zJmgSHCzPKGHaR9xevEwxqsHEGFu5sZzN3ORICiyvWT7yOLtOXiSDubhKuHFrryuH3exJ2TV3d34asci6oU47ge8aBSikYtoh5JeW5qpXatxg3ilGwOURagFye0iPZVHbkmLLL+1gbJbd/n7YHkrxl3CNwN4qy3Ae5s+MRJEHob4KWDX1GzkLxt8QZ6zKVSA6I0rr4MwUiNoK6hN6nCy4O+DtKs6zWc9JWI25qI/NW/+lc5fvx4+e8Pf/jDfMu3fAsAP//zP8+73vUujhw5wt13v3q0pEop31RYSKyKkzefPVGQkLkX+Y0X4fjD7CfyVrX9BZe3P4q+k932d+p5EZ+NKwLe5upk0E6eCdy+gLQv+RtgvYVePwHNNbApsn0B1bnkhwWaAKIWzNVS7zNa2aNzVQGSO2WppXVk60IpwVNjr/G751AbLyLHH0E3V1AoTy7Sgc+m5T0pys3vGfFHKyc9w6633bxyxh8LZ6G+hDpwJ2rtmG+gdxY5/wz0RuRZADbOwMG74MBd/sGCQAf7tZicJCHl8bGpD4SKgGa87wZw8WChpfN+5Vav4ntGBYrUwO64nueI2megk1k7l4SMY5AkLAd7Gzp4WdTuSRKl9dzfjDIBBNHstHalkNqSdwgcs6IvEy3l71bDHlJfyRLc+WcmPyPJkI0zSOcK+vjDXzHSLte+jPR3Zu/r4tCDHVxjzR9vwMyZUVXhxuK6uGa9iu8ptzURGSchAL/+67/O3/gbf4NOp0Mcx/zoj/4oP/ADP8Df/tt/m5/92Z9dGETEcUwcj7Ko7XZ77uteSTDrx7EugzFpzMJm43G0r0BrfSIonEFj9RU99Xwcft7JKtLf3v2FQQ2yIWQp7Fzy/y/Q3cL2tjH3fw0qqvtmztNfmLoBDnDty7B8CAZt36SePyUu830WtSWYrh6YYNfp8yXChpdJzUEZEukAvXYU3VonO/vlhZtSAM6itcbkk4jtmSdx55+Do/chYQ2dDfeuwohvYnfP/Vm+iHwlgzZy9kkfDNz1OuTi8wvPN9k446tCw87oeJoI1k/A+on5QU7ovwP/j5ygOTv6fHH5QEdBoYFR9lW0wSkWEpEi27yXvKFqVn/1wjqH7KMiEt2CZuF4j+Z2ACdevrWb45bNUpI0K7Xbi64DhWuWiMt/vwpyt0LTWsPuzOnl0hqpL0M6RNkkV8bmjn95JUQvHdxzoKq7fGqW6BRIBrjLpzBHH9h1G68EiE2RBX2dBYnTSQ8XRJio9hVVCarw6sBtTUSm8Ud/9Ee8733vI4oi/uAP/oA0TfmFX/gF/t7f+3s8+OCD/G//2/82933/5J/8E37iJ37iJq/2xkIpjTl492gIn00hjXcPHAGGbfSR+3FZPGeyNhA10AfuuBFLviaIc8jWOVxvB6UNav04urW6r/fq5YPYQXuxRKvWQh+4E+luIC98zlc4ptHbwT7zGPo1b0defGLODTA3CCgkAs4CCsKwzMqpuIuYAMbkSKq5huxc2Hsf1o8hl07N3QcFsHIEvX4MpbTvg9izd0NBbwsOnED6bdy5Z/zDF0/C2hEIdtdye4mWb1xfWKlpX0Iun4LO5d2X0p2SsNkEuXIK4i4ce3iGjOj6Em58kGZBQsShswQ1moCST5Q3eSN//tr+Dq6xgp4jU1RKUQsDhrs0rEdBUDWqv4qR7rP3Iwpv/u11/9JCWBSvpsM+3cTilMGIoa7seEGxhA5ClA5wW+eRzpWRQ1YQoVaPoJYOYlYOYduzPXCq3kIUcwsuqrGKWj646/olGex9jevvYC88hz5873UfeOic8ImTG3z46Uu8tDMgMpq33r3Of/NVR7lj9drtw8chg933UwHYFBOGmNvUMOYrHdfFNetVfE95xRCRz372szz66KNE0ajsGIYhP/iDP8jFixf5j//xPy4kIv/wH/5DfuiHfqj8d7vd5q677rrha77RUEqhGsvo3EbVvfQliPe+SSqt0Yfvg0E7JzEJmNAPM2ys3nZBltu5RPbMp/JBhMrf0858CbV2lOChv7Bn9UYFEebQPditszMEQjVW0GvHUVrj+u1dmpl947ecfxbS+Q3/Yi0y6E2ShSG4IEIZg9gMNezD2jFvcdxcRS8d8CRpN3OAWgvdWEGOP4TbPDt5Aw5r6PUTqOZ8UiY2Q5LYBwn5IEbCaOI7dpdPUebWxMHWBVheQ/ZymbLZnkJ42ToHYnH9HpIlpSuPmprwK6VLGKByuUfnCiwfhqUDE9tUWqNXD+N2Lo0qMeJQ2XxrSyXWb1qbMoPots+jjtw/d//CIECY754VBsEtCTAr3Hw4a8nSGJdLnZTSBGGEs65syVt09itgbvR+g6FRuH3IxhaREJel9JMMlzdAWWUYoAiVJch3WJQiqvvZTnLxhdmEVpYgGy9BGqMP3IGKml6+af1kdV1rooLQG4kMu0h/xztkBSG6uQZRY8970L4duQZt3Pln0CceuW4yLeuEn//Y83zmzHZ5PUmt5U+ev8LHX9jg73/zQ7zu+Mp1+SxgZM++B4yuZoXcKlTSrGvDK+aO+uu//uu8613vmvvcX//rf533v//9C99bq9Wo1V4FmYLm6vwqxzgaPmBVSkFzFbMggL1d4Ho7ZE99YhSkjgW+sn2J7OlPErz2G/e8AKuojjlyv58JknpCo2pL5Q3RbV8iO/m4JzsmQEX51HWbIfEgv4kqlH0O3VqZnQVoLdKfnSkiLu+jKP4N0NtBVg4TvOYeL2E4cAf20sn5Ei0TYNbvyPehgTn2oJ/oniU+yx/O2sgqEyC1FrJzGaZ85yVLIR5AaxndWvePDaZdqPI+imhxI7lvKg3wKc3FgY/r7eDa2+Vr/P53IKwRHDjiI6I08WQJoZgUL0r5xtPNs5gpIiI2Re1cgs2zngyFNVRUK4nGxLEYvYliiKPPIGZI0kfV5ku0oiAgNIYst09VShEE5lXdUHg1kMKxzSb+PKkvvaKCpDQeYtP8N1Yo/sSRJkXVOXdxZJaLF7uZZpZadHNlMlEYkMW7D1pVLB6EmAwHZJgJAuXQxGji4s1ALQh9JXOX+420LyOtdZ90mTNzqEik8bLmEV3FuZQOke4map8DdvfCR565xGfObAOTVz4n/rz/mT9+jp/7jjdSD68P8VEm3F8n4XWu+lSocLPwijlzf+u3fouPfOQjc5+z1vLII4/c5BXdflArh5Ht87tnqVeOkLzwBMmffxK7ecE3ONeX/Oy9LMMNej4wdYIKA4Lj99H6xr9OePjWzGixZ7+8y/4I0r6CtK+gVg8jcR+JB6haA7VAdkOtNRF8SjIkffwPkenheIMuKozyAHns8XQD29vBHDo+Ue6XZOhJS5pb9hqDmGDxFOH2FezTn0Q9+pd8xeboA7juBtLbQgZdZNhH1RpeVjBV8VFBVDYmLoKKmvkU+jkQh/R7sHrE/3uey1QSe9Ji5suQlNJIo7mrHbSkCa69wDo5jck2L6GXVn3AagK/n0UWWcQTlO0LyNH7y+9M+m3sC5+BLB31fSQD6CtorsCC3o9iv1FjwUGWIpEgSR/pt/P9NejGMqq+jFKK8Bp1/iJy0wJwEfH9S8nAW3gHIbq+dNP6vYp9lUEbd+XMyHwAfMX1wB3oKVJ5O8Jl6YiEwGxVQwSjoOgCm/l68+uV3AKL5zAw6MQHxYtQr80/H0TEN7qrvc/5LLOY9pU9XyfdjbnX4muFqi/tHZyPJ63al5Fay5+H1/B7EBF+/6mLi58Hhpnjk6c2ecdD14f4EEajfVlwLVH1pauq+Egy8H0nLhupIaom95eNSpp1bXhFEJGTJ0+ytLTEwYNeN/qxj32M06dP8z/8D/8DSil+6Zd+iR/+4R++xau89VBBDY4+hFx4FhAkS3GDrpe6hDXSTpfkT38ehr18OJLDpRl0OrjMji52WqFDgzIad/k07f/yM2ACgqP3UH/9X6T2wOtuyv6IOGTzLHs5XtmzT5N++U9xl1/0mdgs80H8+jGCe1+PPnbf3GBQREg//6FZK2T/5AQJKZqXRQSVDcjOnUKvH0a3VhDnsDsbEw3ukq+Nen2BPlmQnUtIZwO1cghlAnRjhfTkEyUpEsC99Ax25RDha78BVd/fDV1EcFvnd3+Ry7xxwfox9IET2M2zsy9pb6GX1yCM8sb1XIgQRKhjD6OSPm5n8U3Z9hdrm0UE+m2vHy+qXVEdvbyOro9NcxbBvvA5zGveDs5in/v0zHDK8pvttz35W6iTnnRGc8nAGxNIQRYVKI2L+xBsYw7egdIGl8Z+0nTejKtrTXRj8Y1fRLDJEJvE5b7pIMLUGugb1OQuNiPbvjRRVZN0iBt00K210pTgun9uMsBdPu1/p876rKwJodaYbDa2KXL5FA5KMiLicBtncf0dT5xqTe8KHUaoxpIPjhb8bm8kuUuT2FfmFkirikrI9IxwJQ5tU7Q436dkNdYoTHhzA7xWvUZvGM8lI40ovC5N9AKTRHPR6/aYBC7J0PfmpbF34GquQXNvebAKa14BMK+Ju5R5ysgPMe7hLj7rv9faEnrt2MyA2v2gn1ou93avOGkFL1zpXTMRkbiP3bkI6dgx9KXoSXtjpdF79NSUbxeH23jJ9/aNP96+hFo54v+8igPilwut1DVXy1/N1fZXBBH54Ac/OCHLOnPmDH/37/5d/tN/+k+87W1v4/u+7/t4+9vffgtXePtAtdaQow8y/LPfxp573gfUucuLOBnFd05waT6MqvgDoEAHAVprsjhBGZ1LlGKyl56l+9KzdGsN1r7j+zEHjt7YnXFu7x6ENMaefNz/PctKy13JEmxvB/vS07B8kPD134iuL6HXj5QBpGycRTobOckYBRUzvQs2Kyd0l4+Jw144jTWB1zTPbYQXZDiARnN+0KoU7soZ9MohxGakX/gIMpgj72pvkHzhQ0Rv+W/3l7VKh9DfwxlOKdzWBd/gvn7cyyOmJVricO1NxIS4zJG88BSuuwNBSHj/66i9/uv9HJB0NtjwdsCzN2wppjXn/SIT/SrJELdxHtY8wSuRDPysgO6ml9UVRgBmTBNdnCfD3i62n+OvFZhxUpOclGjIYrKt8+jaEm4weSxdfwc3aGNWj/jBlRP7LaT9zkyvkcsSXJYQNpfRCzKyLu7jupv58dSoRgvdXNuFWI0+M9u5NF/aB7jetie61ykzLTbz30ka405/0f9Oi/PGZv5PGiOttRkHH9k4g7TWcJdOYU9+kfF+quLMK2uIOsDc9VrMiYeQ3jbu8ik/h0Yc1JfRh+9GLXBWe9n7JuI1+Xr3W6NA7seGr5C4FJPPAyqDX3Fk/TY0lnaVOV5vaK1ZbjawzpHk13ijta+W7OKopJQi0Jp4HzqgwGhfXZQ9ehJ3IeuyfQEZS2QIIL1tCOvoYw+gFs0DKjZ96B7chWcnq7JS/IZHFNF/H7kle1iDuIu79Dz6yP1XPx9qH+eaAsw1zvKQuI+9cnrBsw7f6a+h1sSsHtl3NcNtnZshIeVnti/5yvTS/khNhQrXC68IIvJ3/+7fnfj3d3/3d/Pd3/3dt2Yxtync9iWyjbOkLz6De+np8gZfzIVQRiEuQ1AorbHdAWivc3bj03YFXJJiRVBjQ68mbvbxgO3/532s/79/3BOdNEE3l1DXO9urzXwv+mKpIrhe26/B2olJvM5asl4flyTI5SvEp59DGY1uLlN7/duJXvcXyS684IOqiaBRIWbksuQD3zkkQxv/uM1g0EHC+sL9lyRB1Wezb2IdbvMcmYBLhki3kDGpyYwXAsMe9vwLBHe9Zq+jtid5G70ub8LVmuCrvp7s6T/zTlqowhYLMSHx2RexF8+M3pclpM9+gfS5L9L61u9Cy9ZUdlTNFLHEOdzOxkTQ4DOVA6g3UWNZY7d92Te0l8dT4bYvYs98eXLaslJef140votAMlycMd/DDnTyuCgYa1SefY1gdy6jDp6YyPzbop9oAdJBl2hpbWZ9dus8MkF4LNLbxvZ20OvHS0OKuUtJhvOd3sa31m9fMxGRNMGdexrZOj9BIOYOn8tnzDBdiXGW7KWnkJcW20uPXpthTz/urbeL87I4sYYd3JkvwaVTft+zJG9+MFBfQh+8ywedOxf9OhRIY7UMPAWFaF0mGFRU9zN1gv31EiqRcjnGJQRTJHDsl0s26KKCaFcScCNgtKYehTibYdOULEtAK0wQohdILsNaHTOIsUXWfRoiBEp8b0hzddbxbgoq70Ob2Uxva4KETCAd4i6dRB97aFeSqUyAPvGIz/B3rswlIeVrKao4qT8vRHCb5zDHHtx1/dOoh4YHDrZ4YbO38DJrBd5w4uVXIEUEu71HRRuBqE5w8M79b9em+e9ol9fsXEJaB6qqyFVCGXXNgyRfzcf8FUFEKiyGvfwi8ad/D7d9ERXWUPWWDyAlt3QJAky94ZueRcBlDM5f8kHcLvMSlFJgHZjJG5KzzldYBgkX/69/hN3xFzZVb7L0lm9k+Rv+W/ScoPvlQCmFPno/7uzTzJVnjZOIMbKS9vqk7c7US71rVCAw/NTvYbevoJOdOQGcTLpBzQtE5w0XTIdIpnNpytRN3mYTwbGIQO5k5YY93NbF+RchHUzY27gLL8B+iEhU9xbBcyoVo90U1PJIr6/COsGj34h0t5DtC/751hrxqS9jL7405/0+K9f/o19j+bv/d+hulgMNVWMJtXYH9nO/VxIHt3MFGfZ9VU6riUy5DPu5o9coAyr9Dmp5Lf8ohzv95IwkCxFk6F3KdpOtCZRN8IA/pns60cjCbO74MZBhH9VYypcjuRxrQfdyvmaXJRM2m7Z9xZOQolJTVic1KHBb51FhfaG2XdJBTsJ6PtBSGmqtyebVLEGce9kzBiRLsM88lpsfTLPMBfr1OZ8paYxcOHkVn6x8o7EaIyHjSPJzx2j/u3IWettIMvAGBsXnYrwkddhDwhoSNibWLHEfG/fRSwdQ2owGey5clu8fStMM47KFM3eKx1wy9JLDBRARbJrgbIr3bND5uZL636LWmKjuZWv7DFhEhHTYn+xVsX7oodKGsD7rTqWDkGaY0U3d6DQeu94pcdTjbe/MZdOJqsMMTIC4DDdolz1Xxbqme/JmEPf9d7vATKKAUhp98C4vsxx2F7awl2eOOP9HaT/ANRmirrJa9dcePcbP/Mnzc5/TCg61arzpjrWr2uYE0uHi+SjjiPveiXCf1ZB51fYZOF/t5Ab09XwlQxuFvkYiUkmzKrziYC+9yPBTvw2dDUB56Y/NcO1NX+kQjarVMc2lUROpCBDSuOME6dYmLo5xiQ/IxAnOWsTmNy2t0MagRNChQqwj7Q2RseqJyFh2e9in84kP0X/6cdb+yneSblxEhxGNh1+PWfbOXMmZ5+h9+g9JTj4F4giP30vzLd9E7eE3Lby5mhMPk7z4DJ0vfoH+6ReRLCNcX2fpofuxvS6DMy8h1hE267ROHEZpNUNCxhZMFscE9Rr2pafQq2uLD7CzMyRNrB/gV2rHjZmUXBVDvWyKRPW5A7mkyNpb64OmovcEfICsxiYVuwwYkRHZjViMQSmNOfEQ9vQTpeuXt+/VvpE/iCAI0Yfumnqf8uQkJyjOZgy/8EvYOC6DIR2YscBSkGTI4BO/idu+iOtuo+tNwoe+mujAXZgTD2NP/zlZZ5vk0iXfj5RDRyFhq4nOq26SxJNEZOxGLMOeP6Y2Q9LEEw9tvFuW1t7VLKr5x6YtLJVC1ZchbPhenVoLd+E5HzntUiHxgejeQbtLh+iCiLgs/85kIiPuRTyjqoFYC2HxOQ7p5n0yLmMi3C5kYtrg+juYlUPzF9FvozZeRMmYcWtvA2pLyPLhycraVUD6Oz54Udr3Uc0jIeWLF5ARl4H2gZJkCW5j75k5E9itsTg/D4vvWyk1+h2Nn0ui/L9FEG08CVlwvXHdTfTSIaxNfa/LgqoA4qCzTaCDPZuEBS/Ng/nBnbOWdNCjPLYiSDaZABFnyYY9VBoTNpfL67nYgqgY75aXkxebm2d4qPLaUm7PZqTdvFlZnE9U1ZuYsE7UaLIaJPTjhDTPZykckR0SZUMUOeGzCWJCVJ4gkNGnjc6S9qX8OzGo1eMol/oZQEr5ZInzyaR534brbmH2ICKQJ6yOPeinrA8nr/2ilG++L65ZpQw5v4bbBLg6IvKWu9f57958B//P58+ilTcGKPZ5vRHxv3/LQ9ckzRqXAe/52ri3/ybzRXO0Xu7rKlS4TqiIyCsMkiYMP/5+nx2H/EapfJUiywAFtTrB6oEyqzIKbJ0nIMM4z5IpTBQizpF0B5OZXCc4l/lAT4SsuyAIHsuWic2IXzrNxX/1z0bPa83SW/8SzXvuo/MH7/dBjc3I+jHx9hP0n3mSpa//Fuqv+VrcoEd46CjBgcO+KmEChi+e5Nz7f803juefY4cXGF64MBFwJls79M5epHnsINHKLtkc53tmTLO19+Tw4piLQDwYyTiKz81SPw14aiYGRcWjNqcy5FwuB7OjbTvrs/35HU2CyFe3tPY3auUDoiLzvh+oOx7Bnfwisj05TFCGPag1iN72nl0DKDfss/Nr/zdZeyQXKswNdBigw7zqozXZC18cvS8ZEn/2D0i+/Gla7/wfsae+xPD0bAbcJSlx2qa2tuLJiM0QcSPylv9fRHDxwFsjj5MT8FnTehMVNTyRqTfhwAn0obs9kdHaZ2K1QZz1DdWXXkAXskWlkSCa7xp2lRBxZL024yQkf8LPNykqMEojCFLz2eiiojPe3zH+fsF5SXjcBWaJiPS24cqp+e+NfYZYVo746s4+pWky6GBPfXGyEVjpvO9Bymrq/jDWb5Ufn31DG3StPqrsiBv1jU2RkPLTSu/cGDGGbPMy+sBxVJAnY/YjvUr6ntQpPeuclV+D9LCNsikS7U+OKjadO83cVy0mSchugaDYjCzuo5XGxv3Ja3ZORtxMIJtfYxR+qrk4VDrwFT3yINpl2HSIDWoES+uYMGI5l0va7hZuPMAXgXxmj9IaVOR7wvIgX7S/J02QOGeR7fOeGMBYdTIAZZBszjDezhWcNqi1Y3s3r2uDXjmCjK1TVN7HUqy5lBCOVx1fnpz4rz16nDffucZHn73Mma0BtUDzlrvX+Qv3rFMLZrcpaezvaUG4N3G4mnkn+5Xh4qve+3p1NRTx6mH0tU+0V1eXKPpKQkVEXiFwWULyuY/4Bs8xWYmfpG0RJ5jVAwR33IduLpO88CUfBBVZWOeIL1/Cxcnci1dQD0k6vsKhtC71juIctj8/Q1NWWZSvmLjMjrKSY9Km3mf+GPvcZxERku028XZ37EYAww/+GvzGf0WcYJMMZwWsRTcamCiv9KQZw+0hSTdBnKBDTX29SW1lkgT0L2ygjCJsLZCHKYVCYfs9L3doNPa0c5RBHzfo44qJyspLGHQUenveLIGwlpOKUeOuGIMOaqj1I6jMS7EkSydJSNl8XXwYPohKE2gUfTc+XDDH969ndqceR7YWyB/iAfbFJzHrxxa+v/3b/5bs8qyTFoBLM189iRYdN0H6Hfp//Gtk23McycqXCWm3R21tpXhbGbfqRm7X64Ts8nnf4C7ij3u9jsqdf7ysS+cN3crryoNwMiB3Fjn71OzQSHHodOinUU8FBxPncRaPsr5BBCYqAykd+myqy6tOamr7Kq9ilTUJsTDsYG2KWTvqq1w2r6LMc2iiICPzg1M/jHIXWVDcRbJ19OravsiDxH3s049NSBbFWWSMTAmU/rAqjPIenXkuU6okEeVcEWP27GcBIIzKSlN5DUOjAjObEJi7I470wjlwdlISZYLdJVfgv28dQH8LokZeQTFlAK6TPsp5zyxsiuSN7btuVYRs8yxBcxU91jdTSK+uBi6JceJmPk/mVHEnX2BBlD8ni/6w/Kny/Mxi7KCDbq2OPm84NSskJ83l5ys1Oj6LQt1FJFipxTIk55Cts7B93pOK+hIcvLP8zc2guUrxiymrM4UjnuQpgvHKkNLXJEG6Y7XB97zl7l1fI4OOdzAcH4JbW0IfOLHQtUvVmnkP4j4GGS46FvOQ2xfPSFzH0VjZ0ySgwiyU9n2417SNq5mN8xWGioi8ApBdfonhh//N7I1XKZzzWt7w8DH02mHU0jrJs58HJrOWtt+fS0KcdSTt3qTkCuvdssJ8mFcu23KpLfXGymh0EOQFGeVjjmhcDpEHVkr5CnhqSbo9kq1uvnT/nqLignMk3WFuQ4OvDKQx6JAszuicbSNjfpQ2tvQudEjaQ5bvWJ1oFEt2ev614ud5mHqINgZTi3wFSHI3qzDC1RooUajAoPJeDjsYeLKztILd3iBr76CNRpmivA8uTXFZRtBooLLMV0amg8VBD9dQ1N/wrT5wjvukT3wUV1ha2myXm42fOkxzxSdKVg8jAulzn/eSu2MPTDR4T7zTWdKnP7Vgu/lHn3oCec3bULUm2dYVep/5IwZPfQ5JE4L1Q7iNc6Vj2tz3pxm6Fi6O6cSRXTiNy6eTF71FSmu0GQUlLs1wmfVVkWJjUR2WDyI6YvjpD8+YELh4iG42MY288TjuI80V1ImH5ztSbV+YO7m+DMKyGDHBZLCkA3TUgI0X/WT24uGkh2iDa6z77GYe5Np4ap5KQTKZDFDLgG/YwZ3d9O5h5ZNqLGu7NyRLJpy/JE2w25dxw77Xzi+tolYOoLLhrs3u43AXni+JEZDL4SZtWhV40x48EZR44Id8msCfz+O/g/YG0lqBvBKhVw/hNveWZ6l6a3G1Q+t93bKVMVcpRivf6ZMNiD9vkv6E7GjilSK+GrAg0C7IrG9uN9j2ZUQcprUGML968bKh5pDBqa27DC27B7gu7uMay6PqzXSFZo/3L1zbLjK36Sqif0xK9zHE+XO9v407eDe6mIE0/gkmQNaOwfZ5Svtlv8HRGmwhh/XSS+nv7Msu+OVA+m3c5Tn9UHEXd+FZ9LEH57p2KaXQK0dwuzasK2+jfhUWxEop309z+eR88msC9NqtmRdW4dWNiojc5nBZxvAj/xZxNh/4Nn5TUKAV4UE/odrtbMDOhs9oTAW4ttuZufiIc8Q7HR+0REGZkdbBSGfvMkuWpBPOWqNmY8mv6XnQUjQ06lEAW1RNhle2Sba7eS+KlyCZekgQ+dcNNvtkg6wkG0orGgcaOOfonu9MkJBxpP2UwWaf5qEWKEW00kIHBpfkWdfUYocJ9UOr6DDPXBpDdOIezMr6RAax9+wzDF86g1ibE63JfgMVGMJWfVSCFcHGMUGzuTBjzaBL8unf8lKPYc8HdUXgkqWlNGtE8IKJ7WMzWD6IfekZ7LOfHW3XhISPfj3Ba942cxN1Wxd2HTTot+2wF09iidj8Tz/vZX35ueX16jnZDAMfJBSE03kjBB3Nd92Z/Axf4Yp3utjhKOtp6hG11VZJXMVaaDZ9lWX9GNHXvBOUovtf3jfXAhjA9fveNSeKwDnMobvQR+6dswRB2ns0xpKT3mToPy+qow/eido84ysYTAWgzqL7m6g7XotSGpfG6O6V0jlMoiYSNlGLgsosQeXB7WwAlsuOih6AzhZu2EM115ADd0xa+Y7Juez2ZbJzp0abAt8vdvks4Rv254IjIsjGS5QkRGSGhBQoq6HGgLW4XtsTn+kX2hTaG3DnoxBdRIc1pNZE4j4Twel4Nj28Tg5TIn4o5njDvM2b+RccDxEHO5c8+Vw+tHszNvhEizifbc+raCXZzNegin6EQiHb2fBDM69GgrNf7PU9u+npJ1NvB0DI2lcwYn12XuXmDnueQ4tI1C7kel4iJicho/VMYeNFXK2Jrs+Rqq7fAe3Lvjo5TpgKMjhWLQELZ7+ENFfhxFdd1+9DRHAbZ3Z7AW7zLObYQ3Of1q01X+FqX5rzrAJtMAdG1tUigts876/9iHfaO3B8lszXWugjD+Lal0Y2vkqhWgdQK4erasjLhDYKfY0Vkf2lV74yURGRmwi3c5nsxaeQZIBurmDueXSiTD8P6ZOf8D0FUtz8x540hmD9aO4eld8oRLz8wLlcc18Qikk5hIiQ9Ab5xTfXfRtfRRm/eDlrJ+19lUIHgX+PyNx7j7UpLklxia8wZIMYl1qy2CJ2sqqRGoXLhLTn50qMJGGCy3zjpcsWa6YB4vaQ2oqvdqT9IVGrMapeACgIm/Vyv6K7HyylP7bbxQ6HDM+dZXjhPDjBRMEMCQGQzJK0+0QrzTKwEWuR3TK0WiNXzni70Fzj7tIiCyrIVKOmEPvMVM2v19kMXnxqNoNlU9LH/wicJXx0aobOfqQvgMQDNj/4r73UZY7Tk9LKn0dANkxIu4NRw7lW1A+s0Dy8Pnmsx5DFCf1LmzPniB36Rtjm4XVMLYSoRvDg1xDc8TBq3evBk6c/kweri+EGA09EAH10/tBKxO15PCQZQneHgolLv40bdFDN5bkBscq3qwZtJOnDxedRjIanqXQAagvbXJ+9sYug8urMwnNGBNfdJn3+cRiOjkH21J8SvuYvEHzVX/T7GtR8VbTb9iRkXpYzTUi/9EmCu1+3YLAmuM4m9uzTyPYFdF5l81PadyezpXwNvHHA3F3JX3Hmz6G5QrZxvjROmNoYPjsRopu790IppX1iZrfMv3gjBcQh7Q1YPeSvL1ni+0TmVA7KoaXnn0c1l1CNFd+vtdtiClmWON8UrybpZ/mvUrbp4QYddH3Z2yxNxOLFWbQLrlLK9bKQxUg6RIZdFMpXfIt+CmWYWnSOfax9LzhL2buyG/HZPAsnHpldQdzz58ZM1WZEdGe22t9BLjyLOrEPR8L9YtiZSBTMRdz3gxwX9GQoE5K99CxqeR21tO5Jv3PIoIe58zVlldH126Sf/7DvF8tjACufh9Yq0Zv/8oTMDkBFdcyhu8v70YzBR4WrhpezX1vyRN2M3/VtioqI3ASIsySf+V0/ByG/4VqE9MlPEHzV1xEWgQUggy6uu+V17mtHsC8+mTcxj/oxyMv85vAdEOcyn7EmQAWIMaixoF8pjeQ3D2ctg8vbuHScYEBQizBRgChVynKy4VRGWgSbpt5Ra87Fy6UZ2TAe9XukGWIdST/1TjBjhMdljuGVIdlgzE0p1ITNEBMasnjvgLq+ViNshbjUlvuTbHeprS8TLfuyt6nXyouEXloFE9J+4gniCxdmBhWqvIF/IUSww4Sg6bW5asFx8B+mvYnAmM2wH5jmGB97LOMELM/i2iTx36kx3tZvQYNw+uQnCR78GtRYY7xaOjDzunmIL17wPRbTUKCD0UU17Q9JdqZ14sLwyg5pd8DqfSdmyIiIMLi8szguERhutmmeOEz0tvcQHL2rJIcA2bkX2CuwkbyipLRBLSL0e9xgJUuQ7na5Zu96lnm5V3sDaSyhl9fmNphK+1Ip+So/pWjYVYLpbeKWD08G3YWBxC5rct0d0qc+NSuJsRnplz6BZCnRG77JJxFWjpI+/+eLg1MRP4Pm3LMEd33VzNP24gvYZz5VXlecCfz+D3t+3bud34zIiI5qIzkmuUxs0BvJ6pSC7Ss+wF8ww8LvfOZ/G7u5DuXX0EWZfRHB9Ttl4G83zhE0V5AwQuEg6SFRa4KMFENN5cyXIRngcJjOJVg9vrCCoqLG2NkpuxMWr08t/2n7HWxZ7fMZbm8ooPYRy+/yWXtIs1B7510FUBPkXfKgWvlqnQ68Yxa7n8cT71+0LjWmjHcWxDLPbXAGU+5YJbKYmQNYOmXtgu4Gkg79gNbrANmP/S749c4hIi7uk37+wz7RMuzCsIvEA1x3B8lS7AtfzGWQ1r9fKR/I2lFlW3YuE//xfyR8/TsI7ppD2pT29vwVKtxiVETkJiD5wh96EgKTEgQge+oxVK2JOf4A6eMfHblhAdRbuGGv7KFwueOHCgLCex9B2lv+dXMv8BpnHTr319eNBi5NsWlK/8IWxZyRwu1EochISvteFRrvzT+nGqGNwTnn9f+umFkyknPYYYod+iAxizPSXppPdR+tUxTE2/GM5MqljngnprbiL86mNnmKihOyxNsMm8hgrcNkDpv6aotSCh1qZKON0r5pffxz43afjc/9Hjo0+aGbOnbK9z+YcPFPw8YpplEre2DAV0Z8P4T/fnTo3chIZt3GlNagGfXliIzuk+PHQwSyzLfN6KInZ2q9zmJf+jLBA28muXiO/pcfB2epLR+G7pUFN2CFaq2Sbm3lMzUmv+Oih0PlJgQzJGT8WAwTBle2aR6dJD82ycr+kHlQxssBk602G//+Z0Br6q/5apa/6V3YS2dIzp7EDWN0oHcne0qhTzy0cBaAUhpprS8c5OVyGZqIG5H6Mcigix320AeOeWnkePZwTLYkLpfeDUdORhLVQYcwRgzVPqwxs7PP7Ro4Zc98OncqE9TaERgs/n7ynSM79/wMEZF+25OQ/DWAn5hu8z6Pq5AaTFRR84Bpeg2I9ZVbbXYNliXu51VGlc/lmfz+fY9XH334Lh9AMqKsXkZocNsbxcLAZmRnvow+eBy9ctC/Ztj2uxxEPlHQ3UI2z4++0zTxc1BeespXUJqrqNXD/jeRJbBzGX34HlRzxc+wGN/P8X0r/p0l5XcvxbqKY5cH+gIjd7NF54nLUMMOpQPYmHEC+6EGypS1u7kkLl+DnjOgUfJmd5SCoA7ZcPITSxI179zNq+cz11uN4OVt83pP/Hpy++t5/STT0MGCYzeSxi38bfW2YO34blvP3y65xE+BXkCq9yvz0rP3GRHBPfNn6LwHrtx+rYGpNbDtTe9AZ9PRzKqChJDfj8f6D9PP/g7Zlz9B+KZvxRzevbm+wstDJc26NlRE5AZDBl3sqcd3fU365CdJn/6z0mGnfG+/g+22R8FpLouJ7noE6bUnMpDjsL0uyZVLSJJCGGJaS+hWC9nZoX9xO8/Ky8gKE7ylaOzQUZBXBBQ2ns3qaKPJhomXFwmji3qugbZxhh2mpIOUuB1P3BNELDrQaK1JOsnCvg+AuBPTONDAJqMbYhZnpP0xXXziSLopOtQsHWmiA0+6bGyxsQXVxjRqZIMhLrOkvQG98xuYKJdTLGiGtXEyV5o1D85a0p22NwIY31ZgCJr1mWmr45peZfRobssux8I/nzd7T09vV5pse5NL//c/of+lz5c3elMLOfwX3pQTqrFtK599jd7yToaf/IP5nzVWfckG83sExjHcbNM4enCkhReB2mJ5jQ4MQaM20Z+Dc8TPfB575sk84Z1n6FP/97BZny19BwGqsUT06NfvvsC147hLp7E7V/zMgrCGXj/iyct44DkH4iySpriXnvMPKI1eOYBZP1xqysup8dN692QIl1/0wWIjn+ezYImu38ZeOI3bvry7lKw4J12WVxkuQhDkgcguTcRjw8xcbxvp7eAunZ6MmycCGnIy4vdvInibk2F2SYwKfVDvujsLM+D7ki9kPsAS8K50qSd1ypgy6SFpguxc9kGnUogJUI1l1NEHUc1VOHeSifPeZrhLZ3CXX8oz+qnvRak3kSkiV1Ql09NPT+6nNp7I5AGz23gJfd8bCU88jEtzS3RnvRlF2fvi/P5MOxXNkckplyEqJ2naG2xIMVw1S1BxpxwiKIC23j5c6itlpUP26ABRCiSoeYOGMTJS7qXSqAWSPD/o0eWVC0AZTyCUr5SosIFeWvfnwM6lfEZHjjC3YZ6WWyoFzWXobuUrJK8ojlWJpiA2W+x02NhHZTQfFjlDWBb1+RWfKw7X3fISqOK9JvRDMBvLE/cL1Vjx+7BbJcZEMKfZXDZe8tWZOfcnEcGsHCDLq7ilrMtZShKSJkyTQentkHzi1wjf8t8S3DlbHalwbVCmcs26FlRE5AbDXnhh77JwMvD6zzFkwyGu1ysvoGXzd6OF3b4EyRC1MivByXpd4rMveUmUE9LNNln/XB7EeqmQUspnmpUfgCV5H4iqhbg4w82TROV3vyxJPQmZDpyLCgsw2PZyqyLQtIn1fR75W3SocekemWHx7zORAe3/Pk5CxuFSR/dSn+XjI6edoqE+2fIB2PDKDiowvvk6d+oqel+UnpI+CYh1qDl+8JO7LKjaMq4zm22XzJJ2+oTLjbnB14S+fh9I+0MGl7a8I5gI4VKD1rFD6HqNrV/7VbKdLcaznHaYcOnPvsjKQ/fSOn4kD1w1+o6HCR/5WvTyQWr3vYb+5z8+d20FJvqDFkCsw5x4COIuurFE+NCbyeKM9tPvKyth44TM1KPy3MgGsSe8SlM/tELaHxJvdvw26xGNQ37OSNofltWtbJiQ9gaYA8eI7n8bal7TarG2LCH9/Idxl89QnsQmwO5cQR84jl495AOki6fm7Jf1fQYTDzrczhVcb4fwjgdAa2xna1KCNDaUUpxDzjwJmR92aIMQtbSOXj1U9mzYzQtkzz8+Wt8iFBW4RYP8gsB/zry31lu47hbZlx9D2lcmd0kbX3UoPqO4XuUVuf1A4oH/kwwXkpBiH/ZD8KcrIMQDL60yATLoebcyN6ooosVXcy49jz5wB/ru1+JOPc5cN6vUWxGrRmuGhADeOnuetMZZ3PYl7xCWB8Lu5BfRxx7A1JqITZGNl3Dty7B0cLQv49uGfFDinHWJYJQjWFqf/NjOBq4/aYM9LmdSwy7SWAFtCBtLKK2xSez7y/BW48oE5feqgxBnM2y/gxRSprwyoZP+ZDXEWRi0PZF1DhXVUatHYOmgl9jVWzN9UAofiJPGvsphIlQQ5kHyENffQWyK0oEnjWEdGXR9oi2v+qPMXLKGCAQh0lyffQ5PdCWIJr+/Urasx45ccY6P3Yfqi4cnijjs5rlZExCb4nYuomyKWR77zrVBrR5Fthc7xBX9cNNwl08vfk9ORnRrFdfZ9Pvm3Gg/xhzv5iH9/IcwR+9b6LhYocKtQEVEbjBkn43Dxc3bJglZu+MvLHkTdJkJaS2hazVIhjhr0fEQaqMmbDsYMDh9ygfSIrk0qU5Qj+hf2UZiX06WIm+WB+sq70NwcQoTk7N9BWQ6kBZlIZjM7ts4o3uhTdqdvIE767CJzRVpPlsn4htNnXVkQ4uznhyZSKNDL8kQJ6S9FG00yw8/wObjLwCLpT4udWTDjLARooyicXAJpVVZ/fEyqQx04i/kOfHzAbJ3ACtvWFoxka0vCUp+I69Ffr13vcbr88uvcCxTnGufbZwSNK5tQNRws03n9OQNLd7u0Dt7ZaLPR2mFqYWl7MwNY7b//FnUiUc58M53e7vHsZt7/ZE3olfWcZ2diRvyRKVtH0EjQOMb/waSJH5QpLVs/Pp/pnd2s3QDM/WQ2mqLsJXP3Ugy+pe3SnmaiNA7vzEyM1AgTtg5dYHluw6zdOIg2TCmf2GLrJ+Tg4tbdJ58kuju+zn6vT9IsD478C/5wkewl84AgqrV0M3l0TGwCTJoo+YEIL7ZeZdqUJaSbV1GKfEZ7/KNANbbAYsggz4TgUGWItuXsN1tzIkHwFmyF54Yf/MIJhhVAbI8wJhKTBQoXawWkBF9+C7Sz/7uqGpijLcfLqo65fmeb8NaSjnMLqRinFi46crJHEiW7aM5dv6+ybDvs+Hj1r5Ko5qtPFvvJTNy5TRBoMjWjuQuQmq0D8X+h/XJKlguhxJxi+da5HDDHmZprfy3PfU46s7XYJ/5U0hjfzUZdGH9uJ9Pkx9DT0KimZk1E9uOe97FSSlv8dxvQ7xYeqcAXIquNdC1ZnlcgvHZKXOg82GRUqsjQQ23c8lXXMZhU9g6P1npSwbI5dPQvoJ+8K0LXZaUUt6Ge+axBiavAkiW4C6eRDbOjHrogtD3uy3q1Si+x7i7UBHA+h0wYZubV1emz2UVUE6WD+vQWJ3/mYD027s6EUp3E6kvTTSeq5Uj/l68c5HJqrRGHbgD3ZolUyICw+6eZF1FtVHFKL/GlsNxd4PNsGefJrj39bu/rsJVwVdErrFZnT2Ss1/BqIjIDYZemQ2OFiHtdHDDoe91CCazqnppGb26Dp1t7yQ1jLFpRnTkeFnV6J86WV7vStvcrQ7JdsfPsZAR+QBPEpTzEiFtjLfqHcQ+FmnWSwlTgeJzlFYTQYc4oX1mGztWSSkIwIiE+Ou9v9H7CodNJi+aLrUE9aDMnru898McHICk6EDv6qCV9j0RqS03xrZh8wSbH9I40bhu9PzAzgnOOYxWowCPPNsG1B5+I82v/csMP/dRn0l0Flf604+gtEZimUtERGRidssi2CSdISHOWpKd/kzcKk7IBgkBUUlGEEfnU3/CwXd918y2lQk4+N//IBv//n24Xqe8kEqu81ZKEdQjkk4fm6TlepVW6Cj0sz9QSK3Fc3/vbyJpiiiFqBA3GEwcDztM6Q+3aR5bRwWG3oWNyefjrCQh/oaaP+2E9slLdM5cYfnEgYlAoiA58ZmTbPz797H6htcjnQ1f+Tl6L/rACezpp3zWuLWCWZ60awZg0J1p2BfJDQYK2ckipMN8QJ4eqyTkZNRmPrO+KDuZJdgrZ8fmGozBBJ4wBaPfX+FiJWm8MEgprxfTkpCw5uclWC/fIAi9jGrsNT4hEXhiUivOzxSJR8Pvpl8/U91Ihvn+Lj5mkgz9tPTdME++pZTPqru8SlXzlUbVWFpAzoTg0DGy1irupWdGAVqtSfDA16DWj5I99QlYO4paPeJ/q1kCV84i557dXR5nLXbQRdcangB1NrDPfnqC2KhkgFx8AaKmP96H7kKC+t7EXsRL5wbt0g56P1BZMpdQT8NlGbJ9DsblRTpAt1aR6UA9t8Gdi7iPe+kpzL1v3PcaxyFpjH36kxN9VoAn6ruZGRSwqR8SOG8Ox8ph5PIpRiX4wu1rnITkvxHtZ9+o44/s+pmuv7PnPrl+G7N6eOwjFGrtKLJ80P/+XOaTQY3Va5/C7T8BFdXGDFf2UWNXyldSKlxXVD0i14aKiNxg6MN3oVqrvrls3oVCKcRa0k1fZvW2tRlBkVkRgSAiOnEvrrONTRNsnHhL3KTD8MJlbJKWsxoKy1woBgzmkqm8vyQPlcb69kbZOjfmkBWttPLljQV++fR0sT5KHN+b1tEluuc7fuihCNnQB5Y+a5VXRmJX9oUUFZuyT0RB0Bidjsooaqs1TGhIL58jbASopsKmruwv0aGmebBBfbWGMv45Beiaz7ja1JMQHeRBUz4bBObIsaa+k7Aejf1zTPsLxM9/ifpbvhXX73oSskC+Is75gG5e5i5/nLH9F8AOElyWobQmaNYYbrRntpv14l3vOWkvJksdw80BNrXo4DLqF3+B49/xXqJDk8Q4WD9M601/gfhLfzqhkRbxVQubpmUFYrw538YpNslyctIvgxqXZMguk3v7F7cLRjp2nGSChMzrNQ1qYdljIU5waTpB5NKtTeKzp4iWmoDFnn0GezKvNGiNXlkf7cM0nM/+S5b4uRn590aWekKiNKpW90Gns74Coo0PvOvN0fwBlX+JSpUVzWndeZm1FPEN0jIVkGiDXl6bWaJSqgy+Z+Ri0zBmoioSvukduBe+QJ6JKGUZE1WFKc29twcOUUGA7bR9lWC8amYCVOh7yUbHMZdfLnK80r7a6pJ4xmVr9MHzbTBV/pw+crdfR5bgrEXigbfONWE+4X1ye8Hhu1CPfJ3X9WuDWjmIUhqXDNH3vYlxi3MVRHD0HszqYexTj+0+gTpNfADYXPZuRYsGZiZ9SIBLFu5+gz+ORRA87Posuw6gterXt3MR2efwyUnsUYmyGW7rHHQ3ZysDLoPOhncBK87fLJklCVOfJzsXS/tZSQb+GANqaX1X9ynp72Cf/+ziypPSi6sd41hAkpTSSH0Zhm3KwYYLrvMArBzZVd4J7FklAxY6ZSkToMZkW7vBmxBEsEfCwQ56QG5yEhTT0vcXyC7sr6lQ4RahIiI3GEoporf+VeKP/eooABk9izhH2m6X7EBFEdH6Qe+6ZFPSzS2aDz2EmAC7c5msPyh19WIdg8vb2GFCFielHt8H+aMp4OMQ50bEIysy+aO1AuhaODH9ukBhxTtPfmEiw/IdK7TPbJP1Cm2y30Y6GGsyH8+qKk84nBVMOKZ7V1BfHzV6j1+QdaCorUZksWX9Xj9RfaIvRCk/zDAKyhtQ0ROic5lLOStFCiI29Rm1YDFJAVw8ZOvf/VOvA96H579Ls5mp8+WxzJENYuKt2cGNMhWVu9SS9vJGf60w4eT0c3FC50J3ogfHpZaz//k/c/G3fovX/dzP07z33nLb7d/5t6SnnmL6RFFaYZoNes+eAaVmzgetfL+R5w/5Z6lcGmZGFTeXZGUVy1fUHMPNjp+wnp8fxfPOestnP+9RoQKVN/D592WDBFMLJghzgcGFywwvbXD4a99IuLo0mZ1u7BFkKIUkwzLAlyzFdrYnA50u6ObS5LFOBkh3G7V8IL+5+wyrrxboPBM7sm3GppMyLvLAQ5vys9S0U870a8Oa37e93LeCAHRI9KZ3YA7fTfLC58vHp4O8IjCZJ/dyaYokg/zzxsi7zfzU9bCWV9LGtPczEhjlewvy3yHifLXIjM+myKtKuwWfeaZc0Lg4xu1cniR6QYhZO4QekyVJ5zJ26wJ66YCX85z/sk/GrB730teZfdZIvYl54I3I+ee9DfAu1REZdFFH7vV9FLtdC4ZdVG8LqbWg34YLz042bmsDq0eRbIh6GURk18DfZrizT42C1UXHOBmg1k8g6XDC3GA3SHfT905M90IUfTBRA33oLtTBOzyR7+9gn/mz3c9fm+1NQmBXiRvrx+Hczt7nFEBvE9c7gM6n3e+2LiD/bc8hy9elygFq6QCydX4hGZMs9fbaAHEf1Vrxr00GezfIi/h+vhyut0P2whdwG+dAgTl0F8FDb1noQlhhPqb7IF/WNlxVEalwA2EOnqD+ju8hfeox7Nln8pKwwfZ7ZL0eiELXQsKDRzFLy14DnUsnzNoGammN7IUncElKNohJuwOUVgwu73gSMswD01LW75vRxy9Izjkk9TIpP9vCTQTg4gSbN7KbWjR6LE39ELtxDfkYbGoZbPSJ28MRoQkUOE9EvIxHE9QNSTfxblZTULponvdrCRuhr5ZYIRkkuMSv1USmfK62FDHcHhI2I4K6GZELfOVGUpsH0Lm0Ks/0jZOQcsGC75opSI3zga/NxieeG8xU87rgED2aubII3nlK5cOj8vWMkRAbJ2XlQ0TIekPS3tBXfaIAUwuRLCPeGdC/0p34ClIgbAYEuc3xYGs43wjAObJul6d/7B/xpn/zb1FKkZ5+mvTUk+XnwlgwmgfOtZUmaXekjS6qPMVrvfGAn0Q/fcNXWhE0IrJhSjZIy3UlST5Lwyii5RoijqSXYJPZdZtI+6pYLybtxdTXmt7AYBriv/fNx7/Mka//6onhUOMSp3kQ50YkxGbYnU2mz3Ndm3K3KSVZ2g/+G6tSeAenKfKTk5AiEPeVg7wHrN7w8jAnqHA2qz+DINw1W132CbzmrQT3PJpLxIonp87V6X9PLDnBXTnnSVIQooKorPAVnyNxv2xQl3y/VFT3r8+TIrrWKM+N0fnlIHOIsuhDx5HO9p6BXDErx3V3cFsXZ1+Qpdgr5+HAMXRzJFOSYQfJybKv9NR3tVdVSsPKYQx+uJ7b2SC7fHYqiTL5O9nPLD/31Ce8lbP1RHLiqDsLW+dg7ejiDP4iBPPdl8pNX3gur8TsI1BO+gSH78Vqg3Su7Ply99KX5/dOFNWkLMa9uA2XT6OOPYC89OTeJDqNfeVx0bkpAlEdFSzuvVPNNSSs73u4Kxefw60dRx+4Y/KjnMNtvoSa6tMRpfP5HaNjumdVZZ9QK35+mJ6SkpZOhhvnR+uIBxAE6NYyrpgrki2u5Olj96NXDyMiPh559tMT30e2dYHs2c8QvP6bCB9403XZn1cDtNFzk7dXtY3p6virCBURuUlwcUx87iWyi5e9bWI+pNDUIx/krh3CHDiMWTsIKC/BOvMCKgyRfhfShGSn54NCEbIkJesNRiREgxJVBtTFjczLpFIfmE9D5dn5zI3cjSKNcz4AT/uDiZtrWbZXQN7/sfPiFi51eUP4mMyqPiaz0l42VfScTJOR6XuNqRuyQUbSmWp8Tx1pP6W+5hv0bSLYZIipGRrr9Ymblsts7npV9Hm4yWrI3C9JEO0DWhtPZa5ZILFy4m+a4VhgM6Z9U1r7YzWcKrWPZVDifE6Hyyy9c5MN6ORJU1GK3oVuSThNaMr3F9UmE3qytxDOMTh1is7jj7PyxjcyfPJTOCfY/nC0v0ph6iFBvTYhsSkb/scw6p1Rc4PIETGUueRIrBBvD3HIXBLij4mAcrkG15sZjCNo1b2blla41JJ0+iRbO9SWx7Tje9hyjldPXL/LTESp9YjMmGAmEztzTtgM6e1AYymfv5DLvNJkoucCQMIIoprXeieL5RiTn6f35bhmzz5L+MjbUGHkexSuvOQ/c8qMYN55bYc93MaFcp+LgY7zpFS+8XuIN31wkA59FSWIvLvVbr85cWQvPQfJ0Fvj1hdUhMKa73VxDrd9aff93ryAG7TQqwdRIuj6lMzUhHsH+0r5/bYpevUggTFk50+Pnht/XZZNkJRy13IZnhTGnCIQd3dv1ndujy6bKWiDWT+xuHq7eRZ6ObEunah2meOSE1y9dHDu7PRJqLmStHmQQRt57jP7c2uK6rl19BxZVXGc66u7r0wp5M7XwYtf3D+x2z6PUxqSHgw73oNQh/MlepLPiIpykm3C60ZEdHMZSYbYS2dQzWV/zATEGF/tmyIa0utg49jLR4uCyJw166P3Eb3lnQDYk4/PkJCxLZI98VFUrVFZ/Va4KaiIyE1A/Pzj9H7/P0wEcj4h74O7LE6p3X8Is+b1+8PTzyO9bfpnLxEdPkzNJiTdPiJCvNMFBf0LW2V/gbflFeJuXGrtG4cNKlLEnYEfSihMZDKduNK3Winvga21Biu4YUr/8jbkfRw6DMay/qMJ790LbW/TWzgd5TFiQUKU8tPTe5f7SDaW2SklGmMVm3z4YuGmNU1Cxg/ccHtI81CzDMRtbEm6KbXlsb4OrcdkQrmkZK8vSuGrIoGZOFa+tySYyAZPvE35wX9lMDAuKRPf80Pme3ZGkjkpq1NFX0/37JW5DexxJ2awNZyIj23srY0FIekk2KH1u6kVQT2YmIw+qgj5yk7ny0+x8sY3kl46R7LdmYy7RXyfSpwSrbZ8f4iMSIjSelSCFsEVPT/OzSUjYh1pLynXVj7upDwnx4mpDnQ+a8YbIpTfmgPRk+dQ8/gBTBSWgbTUhWilSbK1Tdiq+wpit4c9dxFlAsL1daKjxzGNUfZYRPxQw3ztkgxLaVVJpMC7PQUhylpkuJ1XNTUqqnt5UvFKGfW60N0pm969JeycgCZNfCCbZ/BdmqCCgEXTpZXSSGNpVwefiW3nCO5/E+nmuXyg4O6ZN0kT3OYo2BelcT3v5Ke0QdUbZV+MUgqMQTJdztcoH7fphEvb3M8S8ZWWZIhrb6CyBN1cGdmZK4WqNSF3ynL9zu7Sk2K7gx42HqIPHEWHY5r4wlBgPxi7BpjldezmJX9+TAfGUQPJ5+0o5eW2Muh5Mla8rPg+93IMS/r7kyUpg2qtolvrC4+xO/PnyGBnbK0WlVm/lkWN8/mAPRXVUWvHdrWf3ffQPvKC0X5eH0SoZj4LxBXn6lj1Kf+j9yEd0kGIO/4wnH9mPhkpqpNlZVxg4/To82BhhJQLRn3A31jelQxeLVRjGX3gOO7yS0h328utCknd8ronatN9Ylky6lFRCvPg13jjDmtRq4cJ7voq9NoRv5vOki4kISOkT/wR5o6HwWWkX/6UV3MoMHd+FeHDb9nzt/1qwnWZIyKVNKvCDYIbdOl96D/OZJMLZIMYXW+Q9oZQ75Ntb9L78pPoeoOtJ5+leWef6A0PMdxsE291GFzZRlKf3Q9bNUzeVJ12YyD2lRGtSHtD0q7/DCmD3uJCXpASL4nSYZ6xVKCCUaAMYDOLTb3drqmH5aC/LM2Id0bEZxw2tqXGv3epP/uaQsYwpmcVK354mghpNy0Dfh3o3EJ49CMN6gZtJh2tkl5CtOTlIDoKSqeq8YbcveHJ2DgZEK0IomCGOI1DlO+Z8AuekqAwIoBZnBDUx6Q3eZO2y6y3snW2vJgVzlFJN2GwOb85OW7HZINJ6YFYIUkTgqYnI1mcTZBAHWpsQWrPnwfxJDDrD0syETRraAxpd1g+72Vuk/MrBDCB9g5q5QLmHJuamSDC4EvZYh0uLqRvivqKNycYP26FLTOAZMJwa0B9vUHz6Do6nBxMWR5Xa4kvb/p5N8W2XEJ88QLxxQvUjh2nduw4ulbHtTeRLPGEwjlQmmyYgggmCsvPwGa+0jG+c9b6ORRJDM2lSQOIMUmIOLerXAJjkDTxwyrjPhKDBBGq1pgb3NS+7m8Qf+Z3kStnFm9TKdTKqEFWL60TfvVfIXvy44hL87hM+WBvKqCwvR1PnsRbGEtne7QvAL0d7+rVXB79BrWZnzneRfrll6nyQCvffr+D7XfKNQVH7vJuUGV1bZ9SG/DViF4b1g6O1qkUZENQa4vfJwJifRN3+ZBgVg9ir5ybffnORW/pu7zuJbDdrdkq3Pich92ahYc9fz6acGEWX7XWMatHFm8DcBefg8HO/OSLOH8Mwlk5lxqbYaLvfC02HXqHrdErAIHVI7AzRlaL33bx/+nfJAt3ZxL15qhCJ5I7vdnR54I/1+r766PRjRXk8L25i9YYZGz2Rvlib/HrCYb1lU9n/XfmG9f8d5df64sqlz5413UjIQWCR95GsvNbMOyVSQ/Az6zalYgrX/l43TcufIXsXJ4dLDkPcZ/kSx/HPvlJymOvFNnOFbInP0H0F/8GwfH7979TX8G4FUTkN37jN/jhH/5hzp8/z7d927fxL//lv+TAgQOcPHmSf/pP/ylf/dVfzcc//nF+8id/knvuueea1najURGRG4z4yU8hcyYei4jv7xgkiGvTP3uRaG2JxoFVJE3ZeuY06SBl4/PPcOC199G/sMlwq4OL/XTyaKVZWrT2zu9469ychOhAl1KrAirPSCe9FByoSBNEBmVGNxFdlMLJZwKMLds55wlGoIiWG2S9ZNLpSIR5tfyi12OU1BlVDfz7/LRfZ52X4QgjaZLyagLJxQ3KqLLqMR58Fm5KNrG+Z6Qxq7P3mVs92wtRPG/0fLcf53s2guYu2n0niB4ZBJSBukhejfLHR5yXfIWtRj7x3Gfae+evTFZU8vcOd2J6F3t4VYUqqwjFcZwmIePI+ll5YVRGYSJTVknO/Mq/xdQD3KBP0u5N9IAAJO0e4VLDO6cZA2k2Q0KA0nnMjAWy4mTCAMHGs2YIBXTNjKpnY+deuf28ByUKo3LfbWKxVgjqu0g8lJokISKMD+CMz50jPneOYH2dqBF46YOJ2Hnyywwu5t+F1phaRO3AMq1jhybMBmY+LqpNZlyn3Xx2C57DaL50KUu85K8x2SBv7n09qt4ifOgtJLsRERGC+94w8ZBeOUT4F/467vKL2NOPj5yAnEXyTH0xrwPwJGSBQ5frd9BKo5q5HGXRPdSmiFlcBVg4+yA/Ztn2FbQTzIrP/F9tFlYGXVg9MHmMnUWSvg/E561LKdSwO7tL8z5bG38cbYbdueIrRbtJAePB3va0m+fh0J34C/q0RK2OXt7dEt45N0ESpuEDaOfPr/EqRVhDNddGrzMB5oG3Ip0ryOY5JItRYcM3nrfWsV/8EFBUXKeJV35vYMpMIzc9mLv/SpUSwFmMXRvC+UNiF+7v8iHv6NXfHq1ter25UxfpcPR7FcBNket04KWIhTmAs9edhIBPHERf+y7SZz+FXDztibEaXYPHDS7yBz0pOnoP0Zu/dddtXw2Zz556jHGXQ28W4SujySf/K+ov/y3MHJe/CjcWL7zwAr/927/Nf/2v/5Wnn36a/+l/+p/4B//gH/CLv/iLvPvd7+ZnfuZneMc73sF9993Hd33Xd/HYY4/d6iXvioqI3GCkp5+a+3jWH5INkjJIXb7nGEE9Yvu5l+if32Cw2SubtLe//Dy9C1vYxBJEQUlAbJwRdwbeMjcP1otgc5KE+L87GTVLS+awWHSkCRt5s7NSvp8htaURkk0s6XBMfqUg66fYscCumBni/zH1mEjZMD7ZI+EDWZW/VomeVUwIXnIUaXRdE7Wm3H3K/6lcUhUQtOZIDrQnGbqQ34yTET0aRLRrw3k/Rof+2E/cWJ3zrk9J6jPaKl+YViiXE5DMYtOsDIbTTp9wqUltbYn2ixcn3LPAS8+2Tu6UfRVBw6AZs7QUH2yYmpnb/O/3Of9fqAkb4cTxFxxnf+XfEOZ2yTrUBLXR/Ba0Iul4icjSG99K+9OfGJHI4jtSjCR241CgA1NOZNeBQQcGG6ejGTAKwnow+v7KPgU9IlvFtnLyqAPvVNM4tIwOQ+J2DxOGmFowE5RMrEtk4rzyPVEWl2akvfMMjaJ2cJX2yT/HxSMpk1hL1h/grKV1/DALkVvfijg/R6WYrzM+Z2ORBEKb+SSkgLO+yhD4IXjmvjdi7n7Uv/XIPZi7H8W++KX5m77rq9BH75tdrlKYI/egD9+FbJ7HbZ7D9XdQWTyl0JM9bYJdvw31JsRDXNwH59BB4Ke0F9ecuI+ZbvSfWo9b0HgvgNu6RHLqGTCG8I4HCO9+aKKSui+4STmaUgrV30ZaeX/L+LaUQg07qHm9D9P2rEqPTAm08RWzeX1kM9tJPQFdvGDYOo8zEWpprXRiUyuH0a21hbK9EsMOsxfTSQj441K4ldVa6MP3zv6WlEKtHIaVyd+At7m280nIxAtdSUY86XTepW1u38Y+AnqRfb1sGmrtGFISken15udTMhyrgqlZElIgHfrnw5rvN7pB0Etr1N78l5G4jxv2sKefwF046cmP1ohSqOYKavUwur6EOf4AenWXa1W53XX2exAly3BJ6pUQRTO2+L5IBSSf+i0a3/I9L38nv0Jws5vVP/7xj/NzP/dzRFHEo48+yuOPP85/+S//hd///d/nueee4xu+4RsAeMc73sF73vMePv3pT/PWt771mtZ3I1ERkRuMebcDPzgw8UGLE+qH1ggaNbovXWJwYZOkmzsf5VKprS+dQqFKt6BskGLzLHUQajIlZEPrHYai2eyjiJAOsnKAoM77CFSgCGshymgfOOZBkYkMLnMk7Xhm6CAC2dCWQeuIcEy+zAf5lMGyS5y/hxiFMpSkwGuqmc2G59Udf7y8TKT8oevJ4K1+sEXj4FSj4LiUyjlw4JRDBab8bJQq54rsBy6fxWJyqVYxR0PlwbavzPjGeDI/FNHb9I5unkX1ZrjRJmn32Dl1uaxsmJpBrGPj6a0yoDE1jc0cWS53C2ojhzBB0JH2hHUKSqmyX6T8PgAU1Jdr5bENGgEmHPXEoEcSrKTTZ/nwEcKlZhmgiHP5rBiHzs0HXJJNfK6Ir1gorQkaBelrkg1Tkl6MCaYCSeUnPXtyU9j5jo6ZUoqgUZuYbSOZw9oEO0wIlxqjAY5+lcwbUisiuQRtjEQ7GFzYRBs9d66tixPaJ8+y/vCC0nYQ4NLEu9cUwZU2qGIIYDA1a2McZq9zT0FjhfB134haPzaaV4I/BuGbvw29epj0uc+O7FYby4QPfjXm/jfvIYnSqIN3oA+OXIIkGeAunUJdOuN7YvaAOIe9fG7iu7RJDFpjmi1/zqQJbtgvHa/Gq4WA17Uvkq2JjNZhLemLzyDxgPCOe3FbuzesT2BO9lwrsO1LPjnQWM4NCASd9lFzKjRKKeygm1dFlK+ijTmDzZMiLYRzCwmLb+ZWuJ0rfpK8fxQQ1OG70a//5r1jSFmQnJh5XU6aD9+LGZNk7QtxnzKA3/uD/Mucn61TOGJNv1dsil7Qazb52b39Eb4xqPoS0jowatyfXqG4CSnenjqydOj7WfY5H+RaoGpNTK2JecM7kEcz3PZFb3G8tO77qa52e/UWHDgBV17c87V2EOPi2IsdjCZsNXyyAXDOonfrIXo14TpIs8ilWe325OywWq1GrTbpEPd93/d9E/8+evQod999N4899hj3338/Yd4XZ4zh/vvv56Mf/WhFRF7NCO96iOzcqYnH0l7eAGwLIrJK2hsw3OzgrC0DSxXospqgA+1nNxQBuYIsyRhuxhTNyPMYuYiQ9NKS2GilfMDrBOW83EflTcDO2vzGim8WH7ME1kUlpaiUpF6m5YazTkou870PgmDjfIaIFBIhjRaNtTbPcvuppKLJM/2+glJkwwtpsI0tWZwRNPKqiPaBtskbs5POAJNb3eYL8f8fz56KIGmGBPmcEO3Jgh6/8ZU3oFlyBZ6M6NCMSIgeG5JYZv0EG48G7tk087NfknRirka5POfIhpbepR7D7VHfjbWOdMfirHfSceLv32HgHbO0VtSWQrQu5m0UG/XfQ9HbIlZ8nwfeAtlZR2CCCbmWJz2hl/Xlx8vUQrof//BkICdCtNYibNVHFSbnSLp9km3v/lX2VTAZmNXWl6ittuhfHE329RPvxyoYCnRkJvp0dBgQrbTmVvkA0u6AaLU11kQ/+72B78eantMy/hmmHmHnzCgZXtnG3ntirjxLstT3iUwjiLzTVpaV2fIZ7FYNKXbEZhNkYfLtiuCBN2Puf5OXICGoxvLLloqoqIFaOuA/eQ9P/Gm52wScw/Z7mJaXlUlvB8lSdKNVypskS7HdTtnrNXf7gBtMViayi2e8qUcxtHGPfVW1xgSBm0Ca979sXfDk6cDRsko1vRYZdNEmhObsOeB/93s4s42jmCc1USFWqMYyMugi7a0puVpO2i6/SPb4RzD3vRG1cnhxZaS2sqfzlr+sCvr4g6jG1Qezo+O0DyJSkE7nk13Sa/tAOqrhtbfOV1hEkKgOS2u7nBMC25dxtefRxx64qnNdH70fd6bvncumMU2G99yu//5uBhEZhzIBZsH14GpQ+5q/TPzhfzNJvqYgzuHisWqldaTtHuFKC2UMSmadFCtcO+66666Jf//Yj/0YP/7jP77rez73uc/xv/wv/wu/+7u/y8rK5O95dXWVs2fPXu9lXldUROQGo/7mb2bw6T+Y0A27zPqAKA/0tdH0L24R73RxmfMa3zxAV4EiqEU+yMqrD87Z3Po0D5ry6/O85JRNHGLFE4n8pdkg85Xl/KZaVBwkt+S1sS2DYaUnmb6zlsHW0EumcqjAy6r89PTR49kg883SZbJdo51A4OVAaiwQK7JgxvheCxNOyX4CykF3pqgKaFD4Hg7wMzWUVtQPLBE0aug841zIcYosmsvnpdjES9VULfQX1kKqNZW1LYMG8X93mR0Fylphk7QMypw4JB1pam2ckvYGPhs/8FbL2TAj7ae5Na2fm5INY/pXBqNeCHFkicM6KVtvFKAFssSitcKCH/DY8udHYcXs8u8ubIYz1RIbWwaxJVqOWDo2mrVg6uHkAEmtCBp178iWk2YTBV5+BuUsm9raMtqENJt1GofXSdo9b0c8JTcz9YiwWad/aWt03uiRBn62f2REKHU0KS0z9cgTk8AbCyQ7PWySUj+wSriyhImivPoxIO10kXwezLQEbhyeiM0nIn5/+5gDqxOPict19nPgHWyK82ZcvjIWeIvkng2Lgh7ls5d7QCmFar6cadxzkM9m0CbY3b51r0y4c7nTWH6LGfYYnnsJybN+xWyT6MgRdN3r7cd/d0opsvb23H6L9MwzBKt5Bj+szx1MWGDelPriM6SzPfpenMNuXkIvr0OtPrEW197CDboLg2MVhOXvf1EP2gSU9v03Aubht2Jaq6jVw7hLp8j+/E8Wvw9wmxc8eW+soO9989wp2ToIyKybqRyPrxnn4P43oWp7n19z0VhGTOgnq+8RtAteyqW08aQ9J+WSTEryRAR76UVMEMKU5XJ5Le5u+76jc0/jbIK587VXtWx156PI2Sdz+drEh4+/an/bWjv2inWO0o1lwjd8M+kX/yCv0s/+nrP2GGHTo4Re2hsQLrdAZGJe06sZWvnE4LVuA+DMmTMTZGK6GjKN8+fPk2UZ73nPe/jIRz5SVkMKOOcmDWVuQ7wyf0WvIOggZOnb/nu6v/8fRg+OZxIEXJaRtLvextV5y1wTBvnwvslsvVKCMprMJj6bn89WkNTlDc+TX6lLnY/1lCpP9CJgjTsJcTehthyhjfaBea7BzWKbr8Vn0U1osKmlfa7jSYqQW/v66sqEu5EIWWz9fJGxC5VvpDcopXGpIDiCWlD2AYzf0Jx1E1PTAcJWiKkVtp6F+so3wiujiVo1H1Ar5SfPBwYdhBMSn/L/ShHUI3Rkyonr085OhfypIClllnZMijSeuXfWlfKtchuhQYUG2xkiIgy2RyTOpY50kNK72GOwOcyrSMUpIqT55HJVriXPggfa3wAUfnij8zrsdJhNJCjnOZoVSDoJdq1O2PTSvPFqmjKG2vqSz16KgBXCZn2SDEQh0crYjAjliUW02iJcatI/vzFxLAoXswnMCZQmyBB5EJNZ7CBGteq0jh8iWm5OfE+1tWXQhqDZKNeogHC5RbjUYnjpCklnTtViCkoplDFzzSWmgxPxb/CZYTdmATr+mrkTosVr5otm090clBDMPY/uue6Zd4kgWxdw2xcAjT58J3pB5lZEkO2L2PPPeWvaWguaq94pabohdnJpe8LFMRqQNMUlibexnqqiJJcuESwvY1ZWylktEsdkgx6SzCeF49+PWlpHtdaQXGYyXgnQB45AlpJuXUYGXd/HkqagNXppFRWEk4Gks7idK15aF9VQUQPJEuzGeVS9hcwxowAw9381JohIH/9DyDKfFGBBOJv/jovjqrIYtXbEXxO3L4+IaxCiwlru5JTbP6eJf59zMOzgXvoS5t43zR4fcdgr5/1MqmjSPbCoKtgr5zAH74EjL4+I+N+83pNMi4ivNsQDJKrN9tlMbVPQ2DNPo9ePervZfLCv9HYgHkwUKuTiSdzKUfTK/qsSSik48Qhy6gtj1QDxVd8yVttfcK326dx1uyK9coFkZ5twaclL5vJrpzhH1uliBwM/i0tNfr/ivGRSaV3aPb/aoYwe9dC83G04//6VlZWZqsYiWGv56Z/+aX7u534OgOPHj/Pxj3984jU7Ozvccce1V9FuJKqz6Cag9tCb0MvrdD/yn3Hb+bTasUAqaffIesNSGtU4uITgs9DOFtO98wANIJfRLB/z0gdnvbTHpbYceFdk/gv9sh966P/uMjcRpMY7CUEjQIeatJcx2JjS0SMEtYDBVn/CYk4ZlQfC/gIW1PLekl5WkpDi2t5YrmHCQsrjpUJhM5wJPIv99EOaBTNWjTE1MyHlKKRiKtBES3Uv8cplTH6Ioq9e6Cgq518U79VRkFcB/Jp0HnQX+5NH/96tK++3UKiyCXsa5XvHMqIutSQ73dIFzBhD62CTuB2zdXKbtOebW+3QV2u8jFpIxf8Zb73RIqzUApQClxMWBZBB0k5G1Rwz6vOZq6NWiqVjSzQPNUurXHFjwxoVJQlRSuGyjKA2ZYUMhE1vCqCNwYxVlIrqU+PoOslWp5xxUxznoB6RdvpzZUmz58Lo7y7NqB9cJVxqeBlNvYEKfdOrZGlZqRnfYkEk60cOknT3N3htLpQiKgckqpFsQ+WfZ/CNu3afGnMTYB55K3rlMPbZTyP9nTkVBoVaP4Y5/uBVLdV1t0g/9yGku0l5NL4sqIN3EL3p28peDfBEKf3iH+IK960xeZEyAaa1jB2z7h1f277WkiRe2lEciwVSrqzTIet0yiBcR7MGBKOP1pgjdxM++nWolYPo1ppf+rBHdv45si99Amcz35uys4EM5xBQpXFbPug360e8RGhi4dY7h2kD9RXgrN9OGPmZJ/4TvTSssYw5dj/iLMEDb0IunfbzQ+bI9aTInow152fPfJrs9Jd8H1CRKGks5QYIeWAoyn9vUR3pd0aHv7uBxL3Zqkbch7iHvdRHL6+hl9agMFTodbCdLT9gc/siHLln/nHeA5KlSDe3HBfx8vYgnJHB+eugN2UhmW9KMP16QeE2L+C2L3uiWJyXYYTr7vggOKphDh6DU59HPfqXvN3xPqF0ACe+Cjn31IiMTMv3xqW981Bf3le18nbF4LMfZfiZj/jqexCicKSFec4wRkUBKgp88qBIOppREtAlKSoKCB/6mlu7I69yvO997+OHfuiHWFryPbJvf/vb+Wf/7J+V1440TTl16hTf/M3ffItXujsqInKTEB67h9X//ofY/Pfvw3T7uGSkSU07A3C+9yOoR2TDsfkcecRZuDOVRENrTKBJB+losnbdjHos8I5XRdDve00UNs7KwFPyXg6AdJASRAGD7dHArniY0d4ZMsybqbVWNBsBraZvcFaoXH1SkAchzSyq5jX+Tvx7TOCniyO5c1d+X0n7KcooXxUJ5gQe4iVcRS+DS61PQgfay80Cjalp3zSd96aU2RuX30CiYNJ6NicV4w32Kpd2KEDUaJBe4UQ2NiBiNItlLJB2zmGTFDuIS/mPAGk/RvIZLFmc0d8YMLgyYLA9HE0aF0itI86rH0ZBoBU15Xt1LJ7kaKWIM+tNC6AkaNY6AmN8s5xW5QRyUxtzCCuWrBUHHz7gJXkCNsnyYY1jEimtcdaV9sJajwiNDg06GHPXAoLmpKxGhSGSZCiBaHUpPy9cScbCpQaDjZ3ZpONU1m0aKjDU11cwjSZmZXXs+7ATA+vEOS/9KAYw5hnoaHWZwXBj4faLYzVPatU4PJpZgvZZ4BlDCG3KJEFpBWozT1xFPEksJERZgm6tEd77OoJj95F8/sO4iycnDoa+42GiN33L4v6GeeuP+yR/+utjge5YMmHzHMmnfpPo67+j3Gb65cdwl8+wqLlZRQ3MssIOexPDEc2dD2M3Lvh5GYvW4suVeU9VuC8tuVjrf0u59bIyxs9yGTeUEEf0urdjjt07udZ6C2Ui3yuTS+Fk3lyTfBuFrZzdvow5fMf8c6/Wwrzm6xBncWef8cH72HFQzVXM8QdIP//7kMWUyaKo4U0KemPDF7X2synmHYe4T/q538c89FZUWC/7aCYquOS3guZScVXyj3U3F8urCllZe873pMYINbks6uKL2O0rqFqd8M6Hdp2CLp0NZNChmARfPh5EpaWzUgpJYz8jR882p++JfNaHiOB67bwPKn+qD277MnrtMGr5AOa+r76qTat6C+59E3SuIL1tT6ZMCIP26LOLhvqZZI5GH3/46vblNoLLUoaf/n1/7240UWFIfPkKdjDE1CLC5SY2Tkh2ut6afux7C1p1glp+Xjih/ujX36K9uL3g77vXKM1yV/f+n/7pn+bhhx9ma2uLra0tXnjhBbIs48SJE3zsYx/jG7/xG/mTP/kT7r33Xr72a7/2mtZ2o1ERkZuIrX//PuzFM2itUaFBckeqeMdfYE0UknaH2Mz6oBovocIVGX4/XLDs3zCaYMyCFfKLv/MBv40dWZIhqZC5UcZbnJQN097ZyfcVDLOYbJj6z3E+QM7GdPW1mqHZCH2T8pj2wDlhe7NPkkqZ2ddAPdQY47WTzjrc0M3aCwtkcYZxpuwb8cdCEy1FZYCqjc7ncFlQlqgVellVbqcrQNiolUGLt2hNCaJ87kgxIX6sBO0yi3KCjsZuyHhHr2L3vDVwPkwqy8oZE6Xrjwhpd1Bav4pzJJ2YpOuzSza19DcGZH1f/UgSS5b4G2zmoG9HN3IFZIKfk6EVxUE2OemJQo3OK1rF928CVVrvTlQS8ERmPEqoLUe0X9xBrGBqhtpKjfqBBirQmFyOFTRq5Y3XH8NimGWEadR85ciN9OfZMPEmAa0WutEk3WmT5dWHYj1Bq0G83c2/B03r2EF6569M/Db8ehc74UQrLXSjjm4tla47KreQnNyQ8nKnLJ0I+oJGzX9vCwJiwWf5pglSuNxk5b4Tfm0FKSgyg2PbUkqNJkc7N6N/x+UkJ2/Ot2efJXzgzah6i9rXvQfX28ZtnvdZ+oN3jmxhrwLZ6T/Ps85zAj4RpLOBu/AC5sRD3hL07LMLSUj+JsyDX0OQO3/p9SPolcOoWoPhn/42yTOfXlgbUcpfr5D8uO5xjx1Vfsc+3VqygcXUIm8UoBTmjocwRxdl8WXq/7sh/4U7hwz7qMZsMG/ufRPaBISv+0vIHY+QnXnKS4S08tatWYy7+ALlsFSXldl7BX44X34eLJyXUi5HsM98Cr1yYOFvwF+/DQx6OK19I74IIg537lmyU3/uqxS6kG7uYoYgglo/DkB24TS9j77fS8MKhBH1r/5m6m/+plnSHQ9IH//ofFKVJb4ZvbmMOIsM+pAMkFqDPW2HKQjs5HZdvzNBQiae275M8vwXqB99cDSRfZ9QOoDVY6jVY+Vny5UXkSunJocYjmPpIPrIfaj61f8+bxcMP/eH5U8kWF0n7eyQ9QalLGuwsV0mDkdGA/7enrb7uHrm5bFOZitJr1Jcl4GGV0FEfvVXf5Uf+qEfmiCJzWaTCxcu8MEPfpCf+qmf4oknnuCxxx7jAx/4wK5JvtsBFRG5SUgvniG7OBpAFjRqpIVXvXgZUtr3k7JFJJdaOUzknaVsz5OTQjLlB49ZknZSPqYjTW21RlgPkUzI4gwXO69KD0YzGlzmsNZih16iVTY5p47+IGWY+ez8eIAchpp6LSgbskbVAOHKpR7WCelYYzVAHFvqTlhtan9jHm/mUpQZhLIakTpMw1dHwlZI0cg/0UOiGA3qAxgL5F0YEOZzRLRzIDU/+yPXuaLzKe257Krcj7xKghplGvXYD7eoeLhkUvNvkxQbJ7g0JRukxO0h6SDFJhk2c7jEkfQSkm5KOsjIUkvihNhJXv1QaLx8rSA+4308WnlCp7SiHvqqhXOutPCFnIBOVxM8g8qT8z7AN6G3UQ7qhtrheimTy/oJKghYvffwBLkC0MZ7x0ery9TWV3FxQtrpTmphnfMN3jogrDeIN2azr+FyE5tkZH1vKhA0aizddZR4q5NXGgTbT1jkPBQut1h95D5MrTYhaxFj5kpBJNfYT0hBBIJGRJZK3nswfnYL0R330nj919H51J+QblzE1CIaqzXqB1ZH50s4ZteKz9h7C25vS6ryY+fi+fM3RARJ/aRod+4kfPbDRA+/Bb28jm6tlTKjlwt79hl2D8IV9uwzmBMP4a6cnQn45sFtnqX+9v/XaB+SIYNP/AbJ05/x59bUuVeS/CSbzIDvsizf9L94LTZOUIGh9shbqL/try68qeoDJ4pF7LlfRS8c4B2bxoiIiHh5VMtX3pRSUG+hWyu43qY3YrCJD8K08edtEo+OpzZlA72Kap6M7EZCCuwy+HF8bZIMynNbwibu1J8jl05TnMvEfoikrjUXbkM1V9AH7yC7fJbOb/zLmfVJEtP7+G+TXniJ1tvfhVlZK5+zZ56c+B3OwGZ+JocJ/P8hn52ye9Nt2URfwgfG0u8sfA+Au3yO+PGPUvvav3ZVFcRpKKVQh+9BDt4Fgx2/lnrL//azNHfC223+yysD2YvPAP53N7xwHtvtltc1O0zKe5E3WEmxSVJW1lGge34CfbTS8j0/Uf1W7s6rEt/5nd/Jd37nd859bnl5mV/5lV8B4Pu///tv5rJeNioicpPQe+z3J/6dh97E7V6ZfdDakMUxdpiRJXmzd04UCsattPJWtoMMl08s14FBEOyOpXO2A6JYOt4C56sNpQwIH8QXTc1FlcVXWIRhYkmtw8nkGAYhz3BmjhQhjIL8mqTY2R6SOSFxMhNrOKCfOoJBSitvSkdBUAu8XIuiUqF9v4IardEXIvSErCpohgQ1bxupTZ6Zz4PEsNWgtr4y1vfgyoxgEYiPV0N8hjuXy0w/PtYDUPSJaGMQ8l4O50g7fW+1nFqyfkwWZyT9mOFm7CtKiSXpe9mctZ7YZbmMLdCg816Q4dRB0whLgaJWzGnB8zeXGwcUlrzlHBfr5XUqyvtYNGW/j87dzHD+phI0AurrNVzmyAYji+i1I+sUrmkwCiYFoX5wzZOQNCPtzM9KAth+HzsYzA0CdRhQP7RK71xuaawgatWpLY8CJREhafdwSUb90ComCv1n9oesPnJfHvTnMqeCCFjrdfdF7GYMjE2tFq2hcEiLE1pf91dofPU30fvcx+h/4ZO4XgezdojWW76R1hu/DhWGrHzdO0bn7/Ylki99HHvmyxN9BBPBojalnh9AiWCWVpA0QWzmnaMklzeM910NeiRPfJzkiY9Tf9tfI3rNdfB4T3cfQAijIYUiln1VDrpbyLCHqrewmxfo/c4v50HoKFNRXB/yDWOTFMn2JjkF9nR0UQpz12tpvP09u75ML62hj92PO/fsvj87/4Dyb6UhRd+f65IluJ3L2KcfmyVuzvpzMp2SgOU9fRKFvgpgzMgetjhORZO8HSNs++FPziJx7IkQCnvmqbHgvTjPrF+bNqiwNnFty3fS9zgoxeDPfn9kJ5zvfzZMyAbeTjf53Cfpfu4xag+/gbX/5r/DrKxjzz2792Kz1Aeppd97NkFExq+zE+sal9NpjcT76+2yJ59guH2J8OG3Yu57w76qL4ugtIbW+uSDwe4k6pUGcY50EIOMpNilIQr4YcuBKlUAZf+jAkkt3QsbLEdRPn+nwvVsVn81oiIiNwmuP2peFOfoXdjExf6i6y/+GYONHtnQkg0znBNsmnk7XJv3Voi/aYv1/RBlM7r1pEBphY5yJxMnpN1ZjbTLHCbQ2MSWciHJ11APDU6gN8ywApHyPQvLrZBaFOSy4qJ3ws8CMfmVa7fbUidxGMkIBRprtVFVxajSQng8+C/Jx1g2v36gUVZGiteLjKRcdpjQP3+FcKlBbX15QtfriRqlXbIyI+tgb09sSv2+uNwgIJc2iLVgR6psm6ZkXW/Hm3aGZMOUuBPTu9QvG/QH/ZTO9pC04En5ep0Iw0xI82SsyY9vgVpkOLRep5bPSknjjP72kCyvhBnl+3qUUojx8qrWkSb11TpKQzrISAcpteVa3hMEnnF6OVe0NGnnq4wCEa48cZqV+48SLfvMlg6DQkJP2htg6jVcmpYJV2XynhI35SOfNxpPS5xsPpm3eWSdeKc74TRWrkUpmscP+mFZOQkVEWrry9jBgKAeMR4w+u+/kMEoTwi08UGfyoemjZJ41A+to5MtaF9i5Rveyco3vHPR6To6b9aOUP/6byd54o+wz3/BN/sWk9PLF2nfTFxI1vKGdWV8VlxHNWyawGAOSci3M3zsN9ErBwhOPLDnmnaDaqwgnV36YJQqs/x6+eD+Al9xfvK6Cej93v+vzISPSyvLyoIIdpgurEioWtNn86ef36uCIUJ2aX8++LW3vpPBbzy3v6pIsa5ozBFOHK63A0lM/Ie/Ug6mRGufEZ8aQqkAUWrO5wkkKRJF3p2rdEfLK69B6M/Z/LyRQQ836CDiFgbRbtj30jDGgnfrt1le7sbWIfHAGzkEUS4bFG8rnSZQ95bE2ZlnJj4j6w/JZiyshfjZJ7h8/jSH/z//cPdqSPGOoioy/tiU9FLK9UrePzN2XRi7Hu8XbvsSsvkStr+Nec1f/IqoXlxPSJYy+PLnGW5uIb3hbCWdUUXZ1EJsLrtNOr3Sat07e/rkTvuFlzh4m0t+bhZ8cfTajoW+vR12bygqInKDkXXaXP7d36T7xadRg22aR1d9Nj0nIc46uhc6JIPEy6mSDDtwXt6T2rwfwGe6beqwiSOzuZxHRu5JklcxJL/211bmZ3B8ZcMy7CUMU8G6ERGxApnzbk2oUVWk3Usxg4zlVkQUacjAiiWLLWFkiAcLmkJzCPiKSZyheppWvrYJEpIHuePBkZdLQbQcjaol8y585U3Yz7dwztE8tOYfGxtyJ4hvwi5IiNHllNgREfLEhHIqusPmc0NslpF1BwCkvZi4PSRuJ95qWCkG7Zh0aLH5MUyckLrihutKCZamjONzQqIweQP95nZMM7FE+Dks4oTEOhLxjf+thqEeGsJQs3bvKvV1fyx9TxG+YpTDN9D54YfURsfW1AxBfdR0roxG4bBxisLbE+t8OGQ2GJJstwlbdcLmyHGp/G4L2VpqffZMBDWuyBFheHnb95QUrkGFBK74j/ZZSH+Mc2tjo31fwJhFNIzct8SN9RQEoR+Wl0+KFpflUhmZaE1wmxeIP/5+orf8NwT3vWH2PFoA+9LTnvTMC4qcA1GI0TNDCyeC9d2gNPETn7hmImLufi3Zlz62+AUiBHf5uQtq5ZCXIy3S3icxbtCFLGXwu//KZ7P3qLgopTCNyBtVpKOhfTowmINHqX/Dd9D9jX/lp9CPnCL2t3N7Tdsu1lBvYR56C/aZT+/xwrGAOBmATXDWTkr/kuGoYds5SIZIWCtthoEyYTEySCj0K9rvm7U5Oc5TEkGQH5cxu2ytobmEqTf8MQ9rs30ZSewHQ45VBMee9Q3sxXV0HDabdHMrPzOYGcTprJ1DQoqPcLhum+5jH6LebMFgsVxqUT+MJ1j++Jg7H8Y88DXY009gn/vcqHKitHffKhw2rmZOhwjpuRfQjSVcEhO+6dv2ntL+KoHtbLPxH38Wu3kRoDQjmQd/b1RYNbpex9udUUCQKwXS3pDn/v7f5IF/+q8mDEMqVLhaVETkBkFEePH/+mk2P/K7njDkN4/26cs0Dy95a97M0tvo4zJH2k+9i5WT8p7l+zkESR3WOdLyBqRGJMQXRHBjlQ2MXmyVmTk2rwzKp0Vyu1hH2Rei8u2mAoGC0CiWagYSSxJbf6+o+VNnvJl9NwydrwT0d2I6/ZS1Aw1M7uqllCKoT97cTT7bQ6EYbhW9BQG11dGwsaJyUlZJtCJo1glXmiUBGb8vF5l8XwnRmGiM4GiNDn3A4NIMSS3aGN+wnQ1I+0OyoQ9SbJzSPd8hG3qi0Dnb9X/Pv4NMHO3UkjgfcDeMoh7k9r8iZAUhyANxR05KrFBXghlmZA6sCEPnbwTNmmF9tYYOvEGBUtC/PGC4NWT1nhU/sNKNqkUqd88qZH061LmrlvZOZfVaLoHzTfwiklc9/GOF7G3p+OHSEGD8+xmXVSSdATZOKJobdWjQYeBduRSoMEDy2Ss6CrzZQUE8i/4LkTw5mktErCfg4VLD9wEZhQ4Cr8zKEl+NyYmJaS3nMpDCDc7LXWZJq9928rkPYU48NGFluyvSZD4JIV97kM/byKVgM5g7l2R8WQ577nmfabyGwMnc+Rrs2WeQ7UvMYz/6xEOoA8fzZSvCN34b6Z9+YHIpIj7zPq3LT2P/+9EyK7vKSX5ZZQyDkcuY/zDCe76K4NAJVr7775M89RmSF/4cyVLMoROYeEjy/BOz0qex90f37X9wXfjGd2Bf+OKuMyvKH34Q+Anrc3Ipc7+LNPa9SePnVj4VfIQiEM/PiZK4+OBa1xr+nCiqAQWJMIGvlGQpEgQTxMbF/QUkJP89Ai5N8h6J4se1GOa+N+buVqPX2uHuCSXE0f/8J2h95/+Ife6zC1/mKxmT57w6/iDmwHGUCdGH70IV/SuH7sK++OTkcYDyu1NRvbw+7AeSDBF88sDtXKb2F7999FmvUogIW7/2S9gtb0aw38ZlpRVihfrqMsnmWMKiqLQbSLe2OPOz/1/u+fs/ef0X/gqCl0VfW0XkWt//SkZFRG4QXvwXP83Gh3+n7M8o9JWNtYYvb4qQ9FPfxzHIkIxccuUdrMT5eREuc6Vta+LENzgrXxExIvSsD/Dz8A0RaEbzT2hnhc2NEQlxIvQyYfr2X/Ago3w8nzhho58RKmgaRT2373MC7T2qIePbLPJhRitCpcj6o0xdMS0dhc/Wq6kJ505IuwlpN8E0AmordUxkJu+3RhO06pgoXHixdWmGDgJMPfAyCHICAn4Oy5hsSOXZ3PraMkG9RvvUObI4Y+u5jTLo713skQ0z+pnjyiBlUNou+2bzQCvSvMQU6VyOBSTO94wESgi1KuVbqRNcKjRDQ6Q1Eb4hffn4EssnllBG5YMQM1zm/DBLkfI8K46ht/A1mGgsaNI5SQn8kEUdGB+05/00OIjWWtQPrHgplFI4a7FDOzPPBhGy3LLYWQfWIg50ZFBO+2nz4GVSY8dUnGBd5gdw5r0uOtC5La7fruAnvQeNGgIErSWUMd7hrdtFck2+yywikHbPoowhaPhZMuN9IvNPAkd26gnCR/ZpaVhvjTLl43p2rfOBc3mGWzEaAjglWdsbwritbLnUQZfk6c9hL58BpQnuepjogTfMnaitTED0te8ie/rPfENxEQyGNYL73oh54M0Tx8X8/9n78zhLrru+G3+fc2q5W9/unp59RiPNjHZZtiRv8oYXQths44AdiCEmEBIgkBBIID+eBJLngTws2YEkPAQSYp6EzWDM8gAGL9jGNt617zPSaNbe71rrOef3x6mqe2/37Z6WJdmSpj+vl9TTfetWnapbt875Lp/PZ24f9oY7yR/6pPts89T5Q0zxwACqHnJHWpooe7ngdWrw566Jf/3L3D9rTWq3v57a7a+vXs7XFklP3bvF2tm13dVe9KqpY5oGKSXh13wXyR/94pTgpqhWFP9teZ8IsbUikM5HRpTpxiBkA/KsMhUs31uapJKX/BCLtUXLVuCqIkLnVaBurUHWm1jlYQbdKUMt+B/KcwGklNtK7xLU8Y5cB4B39Y3kZx4sKok7kFhOY8S+axAXHsMO1je/bm1RJbSj361FCIV39Ys2bW86S2OVks0QQiBbc5je2mXHBlQttAC2t0b6mf+P8DVv39F7X6jIzp0mu/BE9ftOmxZNrkfty56sAl4oujFyixWWwb1fILlwlvDQ0Wd87M8XjPNZv+h96Cu3ercbiDwLyIdDVt7//1WcgXKdUputVYpPWZSR9lIsFpOaIvNusLlF544nksYGYy1DDbFxHiJ7itabzBgupabKrgcCt6AVYst5cTjMMIUM3yA39ArfDb9YV5RdBpbCz0K4xXM5WWcWetoSDzNCT9JPXOa+xHZrv1KC1vcEC3smM9Hj0rPlwrkKQsqBjUFHObZpsGa0kPDqoVu45gYdpaj6SOvc9fUDArcIV4Y8SkYkvVQifK9qKZqQwS3HFfqE8zOsfupUFYTozJD2MwaZ5uxgxPcxRZWKIoCSQNMTSASRFVXgV5OCmnIZyXICFQIavqyupd/wOfCSfUhPojNN2s0AS22uXlRGRDEWDUKgY+fs7BXqYy7TKlC+h8WCtthckw8isODP1F1VRElmTx7Fb9UxWheSxFm1kNC5KTL27rPRBZG8vAGEFE5FZYop4Thsrkf97RSBd9FzXAYiSOHG2I9dNnxBU9+7AAhUo4lOEpKVNWw6GQRn3T7h/Axeq4WOE0yeo8IQGQajm9Na0Bp9/tEdByJy/gC6t+reO34vKq/a78T5Kg9rx6RcVRHwbXeMuX2TLt9Aevo+hh/4jVFmXAiyU/cQf+pPaX39d6L2HNy0H+H5+Le8Fu+GV45MDWf2ILdocfGOvxikIvvCn7nFaH75xIIzqdxQ5THF5zZ2fdy951N/47c4U70t4M3vZ+Zr30Xvj99dtdcVOwDl0X7zd6Jmtn7/NKjmLOHrv4Xko789as8ce65cDiKob72tKZNL5vJqWNZsrnTlmVMaCgIoFNxKmrAVAllrYpPBqFpbPQwCRL05NVCcUIvLM/c5lp+5GFue+yHhG761el/jzq+he+4xRxLfSUZWech6C3vidvK7PjBxTUvvnPKalL/bJEE/+lnsja/cbAIotqjeCFl9f2St4ZIig+5k+2MZ9I9jIkC3mJXzmPVLyLkDlz+3FyiS0w9MXM+ycrzdd8Fai05Sl9Qrk0R6UpBGFJ+dyS3rH/tzDrzj7zyLZ7GLFzJ2A5FnAYvv/e0qCBFKuFYG4ZSh8jQnj3LinlsIm4KDYAoSsvCcJKaHcEIdvmDGQtrPiBLnm9DPNKtFBrxYx5JaiDIXmOg448BCHW9DhB5FGYPccDFxZHTc7snKVifcvgJZLAqFZZCDwWX3AyGoSdAY539hR22j2/G0FOALgSyqAVE/xfMVfqAKsrhT7xJC4Df9yYltSlTltwKEJ0n7KTrJEUoR5ALVqOE3Cs5ElldqYEKMXNUd6Xlsci8WTzYdeY5shaDVone+54SohKC7HpMmOZ3UfS7jbVfjV94CmSm8VTxBTUlUVcOCcsVRnmqUGeqBM8jb/6K9CCUYLg1JeinWwsJ1e5CBrKogpUJWfU+dZD3GWotfD1AN135lM7f4D1p1ZBCQDyKy/tC1kQ0TrLVIpVh7+AyNgwuOm2FccKzTzFU8cFWWPHVVI6uNG3Vxj6la4DK9hssuaIQQ1b7LVkSv7qSWXVfLaHGh6jXq+/ZWiykrJSaKkUHgguo8dwGmlFgB0lekq+sgBeGeebcTsyFa9jxMd9LHZDvIhaPoJ+7fHISUvfAW5ywt5IjLoNQoSPN9SLYn+AY3T2b89coFhn/+65MZ/TLLHA/o/9Gv0P7mf7rZFbxElqAXH8dcPOUWvmETdeR61NEbN1VT9LmHRr9cJitefTenvViSnoREBDW8E7dCMiD55PtIhEQdvhb/hleg5vZvemt48kV4f+efk9z3SbJzpwDwr7qe2i2vQDZmth3TVlAHriZ4zTeS/dX7ntL7RFjfvqJQYqdE6rJtr4BzBi9+8byRopYtOFBKOXL5xvYmISCsO9f3rbJNJfdE64Kf4iEaM4haC++aW5HX3OpaIwuoPQeYedt3M/yL9+Jljzsp7q0gJPUXvcIlPB7+tAt28gxTtk4ZXQRcrppk48FYBRHyJx/c5MQtZvdOP5ZUTia5/DWsuzYtnbsgWEpMZ4Mwg+dvbqcTAn3p8Ss6EKFUlxwvYhpbVcg3wlXYXcCn02zUxusV1fUynjEGcoO1ht7nP3VFByLPiI/I03z/8xm7gcizgP4jD1W8EJ04V3Ovpoh7CTrLSfsZJi9kRVM9asfKjZNpLRZq4UxIf3FIbiydRGOxNH1VBSG+cLyOzIIxmsi4fwM8sRpxct9k9mmQac7Fo4ySL4p2qeI9Ge73zFg8AYmu1lIIIJUw1K49zBurwMDYGmTDdykQ0Cwy87aIXJy6U45ueNRnQqyx5JFbUJYBCQKUL/FqfuV5UUL5imhpTNYxM0RxRrTUpX1sAX8mdGXlsdYLISV+s+YI2cq1Y5WTlsk1Ns1R/tYtXS5ICsliw/LKsGi3cgilk9tdLQwqy2e+xQV1s77zmJgNFaGSxJlrqTLWVVVGx3A/LZBhmd/fJO4kjj+kLdkwZ+Zoi3SYkl4c+ccIJajN1ghnQ4L5GrXZGbx64LgbcUI432bu+qsRnmL58w+RlYaDxf+cm4m7DsMLK0hfoXy/klUd+Wa4zNjEFRKiaoUzaY7NjeOBBNPbo5w2feJ8Jsq/AWk2BOk4IcLighrfo3X10erCZOvrZN2e+97kOTpKR7KSUuA3auSD2FV6ZmerzJ+1xhm8uRuh+PfOH/rqwNUjflbBoXER03iQANhC+ccr/EaKLKSQEtlsFcp5Yiy4cPvxrnkR/vWTztDx3R/bekDWOvnfR79AePMrN71seqtkn/vTwmCvGHcyQJ/6PObSafw7vqZaaJthF7M4atvYtqxZHX6b5g4Lcs8B/OO3kN394YlMbP7YF8gf+zzhq/8G/jWb23RUa5bGK7/6ssd/KlD7j7FtjUf5RSm4+D2oXd6k7akQqLeC0QjlOYnpCmPtTNOy/RQLR8+fcLqfwMbPRmusDLAHbibppwTrK8g9+yY28fYdof3270evXGTtD/9f0idPwcZQU0iE7zPzmq9Gn3kQ0191UtBZOjFOK6Tz26E4h7KCIbaQ4o16TOWACAHSc/fw2Llb5bk2zc7K5PfP88ELsON8ruJa2ctxtF7g8A4d2xQ0Ow7g2LxcQAjh+KuZSzYZ7dYkVpuqo0AGyhWHdZGAySBdX//SntRzDM+IfO/TfP/zGbuByLMAm2uMdW0nzoVcoFPjpHgtKKUcNyTNSQcZOi4elBaQUJuvoQInsRu2Q2wnYTZQGKCTuW294tltPcHxq2eZX6ijteX8+R6nznQ5vRLhKcGx+Xq165V09EAOitar8jVrRxyO0vNClwtQiiS3AS3c3/0N0bulCGyEk/ct27q8QoY1N46LInCtSrXQQ2iI1xOk7yohfm3kx4DFXbM0IWj6E2T2pDcluywEjb1NhLLoKKnGhBSoIHCeKePZvmLRq0Kf6NIa4dzOnHK7sZ4IQtyhBf1Ms5bpqiLiCWhKwUzgYayrhGgDouVx+NoZglZQOdxnicZIideoORf6JMEMU0xmqva9fKircnqyPnn+ynck16A9Qzg7ImbW5mewtkX9wAL5MCJaWnOtb0VAUco3Ck9VKioqDFxGbEq21xbBnWWUSZOqkAXVrv3NVbg2P1BNrsmjBJ1k1eJ8Y4++1YZkpYvJc/xGjWDPLGt3PYDRxnFeagGy5qOHCTpO3RiNrfgKQb1WfIckJk6Ie31sNiLJew3HH7JFdcUMOshCznY7yOZcwQUxCM/bLOG7EXmG9ZziV+nwWbvzzYjGHMl9Hyc/8wBojdxzkOCmV+Jf+xI2SrZmTzzAZn4Dm7bZGIhYa8nu/YtiAbh5jHbQIX/ss/g3vqr6fRxCedu3ZwmB8GvYfCzbHdSdKePsAv7xW53z+p//z+KA48Ga+3fy8d9DLRxGzuzZ9vyeCQjlQVDHJsPpgbHOq6DMZXtNYVK4uXXFFrwgm8SYaICNI2Sthqw3t2/52hjYCOFkdQsu04T87w74RBVXZxrGfDii1Q7Jeo+08yDYv6j+Xrvhxex9+3fitecn3qoWDrLwrT9A509/i+EXPj7x2XkL+5l/23eSP34P2QOfRLVnIYk2H78wd7Q+ripYBiLWIOoz2DQmf+Je9MXTYHJX7fLDKYR/XBVJFRW/Mdloa0HUW9D0IOq6gMXaUWWpGouFLMUsPoG96VU7bst7oSFd67jEnNr8vNW6eBYLwFq0MZikqIZkORhLslbwkqzjUZpiDSJ8hQx9ICvERXaxiy8Oz7tA5Pz58xw+fPjLPYxtERw8hElN4QruFuY61hhjSPsp+SAfVUxSt4Cz1hK0A1r7mxhtWDzbo9eJETjVKgXUAsVS8ZAQwMz+Bi999VF63YSH71/mzNkesbFV9vfUUsSlTsqh2RAlBYPckc1qctQzLIpJUEqXF5dFhiTSljIXZa1FIdAFl8ETjnDuChy2mj8K82+8av+CXGt0xX8QSClcO1gRFElAZIJ8qMlbGi/03ALTgvQkKpAMV2OkJ5yCGM5XJGyHeDVVKY3NXrNngjNRwbheV0TgpGzL140l6w7JA49ouUc2yKjNt7f8TK21DJf7DHqbJUyXk5ylsSCvqoILgbbFelRK5o+1md3res914rZXNZ9DLz9BONuoFv9CCEymnWqJsfQvdFi65zx5nJDHeaWIpXzF7PH91OYb07kKxe/x4irCV26h3xm4gMFTqNB3hHVbBBI4Po0svRKKypROc0yaOoLtKE5Ehb7rydtCoa1EPozJ+pOLFquNa73wRpUpl+1VeKGPCgNMlLigR7oKoekNYVC00mWTogL+TMO1h1mL1Zp8db06BxUGrt3MOsUz6SmsidEXHkVeO9kqsiWKlpPLBiElykCu0Sa8/atQB4+7X1+/Q+LsTrK4U2RZ7dqFbaVVwWIuPoa99qUIL9hMei98WLYLgupveidq71EnCyvEJjfr6KPvucw+LNkjnyW846u2GeczB3n0JvQjn3YtT3ZS8Q0sNk2qFjdrNORMmFRC8Z1ME7LFi4yHAWbQA7mKv+8AclqbnPIm24WkGgU8W8BlpbfmFE3jG9lyIT425nilQ9bbXIWIH76Hc//un7P3nd9H84ZbJo/t+cx9/bcy8/o3kzx2PzZP8fYfJTh6guz0vSSf/xAiCOByRoNZAnKSC2jiHvGf/vJEsGTSCNFsgx+4a1JVUER1LwohyFYuImsNhB+45ElYxzbmMNZCGm0OQsaPu/Qk+vF78Y7fuv2YX6Do/MWfkiyu0zw4P5FEAqrnpVM6G2vJSpwKYaWGOAU2c3Lrqhagr/BApDRGfrr7uFLxnA9ErLXccMMNPPKIc8t94xvfyAc/+EFOnz7Nz/zMz3DHHXfwsY99jJ/4iZ/g6quv/jKP1iF68kwl51YGG7YgZShfkQvHExHKcReMNgTtgKDtc+GxVTprSeU/4QsIQoEfeAyHGZkpgolWwMtfc5SlxQF/9bGzJNoSaYPEVTN86RbAcW44sxJVnIWwCBLkGIFRSIHH6AGVWqp2hpJInBW9/LWCc2FtSch22ynhfC4szosEIMEWXJTi3LHUPVmQ4cVEaxdANsjIhqMJxa/7WK2Kazi6vjp2zuVhy01Ktfl65UkyDdYYdJSQW1t9DtJTZIlm7eFLjmshoH31fvxmOPWBIITgrg8/vClTOszNRBDiTAoFdSlYCD0Eln1zNWpKoFdjVldjvLpHfU+dAy+9hn23Xl0FAzpJyXpDrDZOyctCtNojXu3T2Fcnj5zSl/IkwpPMHJlHhcIZBgb+RO/3Rpg0Z7i0BsaZVXmN2lj1ySLHAgKk84MQUpKsdtFxivC8yoHepBkIid+sY/IcnWbkUYLNHZndbzcIZ12FSafZpiBk4rPJNdYrKjPVf7IqdcvyWotCjthY0v6wCuQBwrkWzSN7XZUky6vJVEiJ32pUlR93qrYKgrIzD+LvMBARfojN4ultJNPPDO+6lxO86HU72v9GqL2H0ItPbsMFEKi9Rzb92fQKgvp22jjGYAcdxOw+xNwBqM9UwYsQAlmrY5Jo82JZedRe/TdQe506zkZyfbX7xSe2r+ZYi770+NavP8Pwr7uD/MFPYI2eDDDGOGg2HmKlwiQpJsvQcYLXnkGGoRvvoI9Ni0rkpmSHJlu8iH/wMHI8sJMKKoloAUqOVb7GgqGxz7jy4Jhy/TaSwau/gVuIFwaCFtBRMjUIKc/bRH3O/vt/iXfwGq76/h8m2HcA3VkluvvjZBfPOAW2k7cQ7j+AWTpFevEhklP3AQKbphDswDdibJwiqGFO3+36eTy/+B6BzZLRd1wVhqQbztnEQ2zUJx/0EGEdb36vWzivXiBfuoiamdm20dJaS/bgX12xgUhy/gwmSRleWiVoN/EaIwl8rEvk2fJnYSugC5+zLE4wyYZ7Ubp1TCkwopMMeRl+5QsdLun8NFWzdluznrv44z/+Y/7RP/pH3HnnnQAcP34cYwxvfetb+U//6T/xpje9iePHj/Mt3/ItfOITn/gyj9YhuXixKJ87RSyrnRJWtBKTDVOyohxaqwusdspIeZQzWBrSizL6roPLVS6kIMnBt5qBsSTa4knBsWvn0cby2U+exxgXhFgcj6xWtE0ttGtkuSGOXa+4xLVjyWotZav2aE9JgrHvQd1CYgw5glQbtHVBTCYFxlhy61qtcuOOKQFtXEtW6VtXyv+6LiCBERDlhrqS1NSk2krphSJwRH2/4SP9Uaa8fFgKIfDrPn7dK8weobbQuLwKiLHE64Mqex93E4aLkxP1Z3/3c9z6DXfQnK1VbUZlW9DdH36YM587Q23Mn0Tg1LCubfpE2pIURoaRNsz7CiUsB2frqPIiFNCJ5uSbX0rjwKgCI8rMfRiQdvpk/YhLn3+CpDNEhY7ELSVIzyOcq+M3A7CGfJggRArCqVapDQsEo53hoNWaoFW0bY0pW9mCIDt+7UyuIc5IO333QQpRVBEM2SAGa6ktzGLynKQzcIFJdZ0hWe2h4xR/plFNaBPjiZ0alwqchDCpKdroRg/zbBAhlEIFHirw8UKfPE5J1vuuOpLl1UJ5GCWkvSGzxw+7sReQoU+epE5aMZiUhAbIz5/e8n6ZGHNvFZtf3k16AkEd/5bXPrX3jCG85VUML53ZegMLwc1TVL+2kUKdwFgVyr/p1Y5TUu1COqUiox2xur2Ad+I2/OMvdoThy2InLTBfujYZWZ8hfO07SD76W4W4wWb1LGstNo5cG0uakycp0eIKTk48IJhpbmptmXy/IV9bQbXnEUohZ2adE/sWlUq8LaZeazBxH5gcYxmwmMgFTJQGm9a4IGSMMyIQdM8uFokuWcTObpFpx6qX/kydwWMP8ti/+mEOfs1XkT30GcaD2PTUfQglqR064L7//aKNb6d+B9op+YmwgQhrjqulZfWstkUFNl9dJu/3wBhkWMNb2IsMwirIMp3l4hkksVlMvrqIbM2Ogsgsg43eLmMQQmD7q+SrF/GmKM290CGDEDMcoNOcrDck6w1RYYBXD50CnjYVZ88ag86ce3rSGaBjPSa2Vdw7xnV4yJrED/yR5OYudvFF4jkfiPzCL/wCb3nLW9i/fz/Hjh0DXHDy6KOP8rrXuWzjm970Jt72trfx6U9/mpe//OVfzuECVA97m7sMvM406092WI/yQuVSIIWh1vBAQNJPyGPNepzTK770bc9NIIEnCYWT7y0sslDAgSMzXDzfJyuUssrHQFBUPF7ximPc9flzlVyvWzhbernGWBeQeBOu4waLoJvZihsicSpZoVQk2iAE5NZSV5JEWzLAGEuoBEFRDUmtRVqBKoKRypJrrINHa4PBUisWnam2jDeiKAl7Cl8Rt5DW1ZtL/oIuqhBeTVW+I1tBCIGxplAvg8HikN75PqWPhRcqcmv5wsNL3PvQ+7n+jqs4edtRgprP0vl17vvEKS48vsqMJ6kFqqouWWuLa+9keGuqvM6jBcvaIGVhvkatEbhroC0n3/wSGgfaU9uodOpMBWXgs/fmw2SDGJ1phks9kvWIWruG33StRkG74Uz+CnfzUoHMWtxkUUwoUkrwFX6j5iaeXJMOolGv75Rrp9ORdK9Ts7LOdbmIXFXgMby0znCp54KK0CNojRZe+TAZEdd9r5rYsn4CAsI5t7CbCCBNIeVb3JNkLjMnROSCwix393NJdJcCrx5SP7BAuGeWdK1TGDsaN+kORm10QkrCuRZeoarm9p9ik+iyxobp3R/islWGDfBvevXT6kn3T74Y/+wjZA9/bvLYRUWm/tq3oNoLm94nF46gH/3M9jsP6ojmiB/gHbsZsoTsvo8UCjvStR8pgXfty/Bf/PpNHJbtoA6dIH/83q2rIkKgDp3Y8f6eCXiHTyLf/L0M3/9riGw4kXl3WfeErNsjG0STwbN197LXqCGwbsFWBueBa20sF2F6OCBZWgalaN9xZxXwuGxzoWJlC16Tr53aFLgKVbmP5fMFn6LpuBO41hmrc4gGripTXFf3XJUVB8V5U6XEy+voQYS1xqnbSWfg6gxdTSWUggQvUOSry6x96E9pHl5gI/vEakN84RL1I2ML+J1+DZSPaM6MfQ8EVijQSaEKZkgXF12FpYAGskvn8Q8fxd93AL1yERsNRvsQApsmZBfPOY6ZO/HLDsVaS+83/yPekZM03/Q3XSBzhWDmZa9h7YN/5O6zQko6jxM3Z4jSiE9U90s2jInX42IOcYqeVQArnJmxUKAjDdp1LlzxeAbI6uxWRJ6b6PV6JEnCv/gX/4Lv//7v5x/8g3/Az/3cz/GJT3yCEydO4PvuC6CU4sSJE3zoQx96TgQizWuvY/3iRbIoJ16LGKxGrGYGha2qFtY400KLJY81Rhv6Buq+5OC+BvW6x2AlYpjkKCkZpHbk2VFwOrrrMUI48rhlRD5/1Z1Xc2FpQJxpYuMIaEPNJuNCX8Csr9DWsl6Qyd0atmilEtAsyMiZdS1XFpjzYGCcpG9DuaAjM45fUhIpM1vx34p9WRQw40sahTkSuEBm4zTiB4XBoDboQuXLFMRuayFPU+db0fJp72s51atg64yYa3vSDJecZO1gcVBVU6y2pJkhMS6aS+OMT330UT704UcKL5XRQj1ONQuhQmALjowozAldQCLHvEAAlBIcODJDfaxtTAjB2Y88iDWGhZuOkvYj8ijDqwdIT5APYlQtwGvWaBzYg9GatYcvkDy2jFSCsF2jtjBLONcatSdp4zxUygyhNsjQo7bQRkiJKXrKq0ykLYKUjQ7ZG6ACD5Pmo8VU7u5TaywXP3+GtDPZciWUYOZwm6AVELSbyKInH1wgUF+YBdsFYUceJ1Ngkoy0M8RrBKjQkcuBou3KZVm9WuA8YYQgH0ZknT4my6ntbVcO0dWxPUV935wjqlfjceeULz2Jf/T6La+B7q9hV84VYy0qeJdrzwobeFNUoZ4KhBA0Xv9NZIdPEN/zcczKeXfeR68jfPHr8I+cnPo+2ZxFLBzFrpxjqxWjuvqWTe2H3snbUVfdhD77IHbYhbCOOnIDsrE1b2or+De+kvz03ducnNwk4/qlgGzOUf+Kd9B9z88XiZGiSqA1UjkTzvEgpAzErTYML64gPEXQrCMLbwWpFKpeBwtZr08+GIIAE6dc+tM/cRLG7Rna153EazQmOCekMWbQcZXXRrNod7WIegM76KO7a9hoiCkW6TIMkb4/Gbi7jIPz+/HqdO9/GD2MRvc4RXXauEDIVRuFqzZK6UQupEAGHka7KqNbmMoJl2erDXowdFW0giNltN5USd0IsYHELwreR7baweaZEw/Zgl+WnT+L7a64QG/jftWIXI0Q7vPzt2nNtbaSsM3Pn6b3e7/IzDv+IfIKcVyfe9PXsf6R92OzFJNppE+V0LDWFgbKTikrXosKDt7IVgBGz1KTF4GsJ/DrHjrVCCWo79ssyX0loQr0n+Y+rlQ8pwORmZkZPvCBD5BlGb/4i7/ID/7gD3Lttddy6dIl2u3JCXJ2dpZz585N3U+SJCRjOv7d7mZ32mcStSNHyJOc9Sc69NOcQW7IjONeAGijySzsM5Y8ybEW+rllrqY4eGIP7QMtzLDwyNAWoSTaOBUcgSOKd9fjarKQuEk10obYwPs+cgpjYX+oCCUsbsHjE0IQFxUTQ9FLa0dzgwQyq5FjlQ0lYGisa6OysJS7ti1PQMuTtLyC1FtsL3HkdWktgRJo68wUPeFcxTM7ysGV4yjHogtifpZpkso3xVVyrLEk3ZThUkTYrhE0t/BTKDBc7JMX6mS1do3Ud4aSg1RzqZ/STzVI6CSafm4JZEHKF4K6EoRSInF+KJ4sW5rcT6UEw9xWlR8lIJQSXwo65/v0lKAxV6M1V6sm0PN/+TDrj14g7Y0W8+FcgwMvu5baTKP6fJT02HPDYZfljBOCdrNS+LLWkg/iqh1J+R6y4H+Ukrp6jNg63iaikwzpFzK7xfU0aTZZJVEKcA7PWZQQd1wVJemmlYfJOKy2dM91OPyyayYJ6GOfb31vmzxKKBfJZTBlUl0FnarmIQoJYIogyCSuumO0QYU+eZIh0hx/pu44Kr0hJjd4Tdc6ZPNC3aWYQPtJRm2hTdCeXBwln30/3uGTmwjX1lryRz5D9uAnC5njsfa67QIR5RO++m9s2t8XAyEEwfV3EFx/B9Y6zbmdVFn8W15LdtcHsJ2l0ViLn+roTaijN00/XlDDO3Hb0x632nOI8M63knzyD4rjjsmpCkntK/7mjtTKng2ohYO0vvbb6b//f2GGfbcYFgLZrBf3pUMZeFfvqwWj1kZbCCIMI/JhhD/bJpyfRShF1u0hfQ8VarJul5nrTrhghc2VRxHUMEmE7XehNeteDxuYOEKvrFUPYqFUtdDetLDH8d2SlSV0FDs+1FZtb0VyKGy3iJbXwbgWy1L5Lh/ESN+ruIvSHzNMjRP82RlM5J5XJs1QtXDrltig5sQtNg7BWmRYQ6dbByEl9DBBtieDhVFlRI5as/K8kKPdouXOWnQSF1l9jemvk973KWp3vGHb479QEOw9wFU/+C85+ws/hRn0MLl16tDWVcZMrsnTjKyfVXLoxjpLAZPrKgloklHlDgk2DQlnA/JIc/Dv/uCX9yR38bzGczoQKeH7Pv/wH/5DLl26xP/+3/+bl7/85VU1pIQp2jqm4ad+6qf4P//P//NLMVQAdLfH+pkuK3FGqi2RcSwJY4xb6BfbRXGOV0wOGjj5squY3dtg8Z4LDJaculHYDsmGGZ4nKLVhJfDIw6vcePNeHnlgBWMKl/QCwsIN7YCHu+mWVXQlCuNCRlWQcU6ah6sUajMirksB0rr2rKSoAnjCcVJ84RSi1lNNQzlzOVFMibmxeNKNyxQEknLKV1j8Yhxli1mWO6a+MZZelJMW/JfxsTV9Ra0d0tzfIO0lZHPZ1BYtR3TPyeNsosMlqPs8fmnAEyujQMACDSWpKUi1wZeCOV8V/iiCtjdqZxs/ziB3RH6Bux4NJScIrUZb+isRST9l4WjbqYHV1UQQApCsD3nyg/dw7CtfTDjXQhVBQv/cCtFih3CuTjjvzN10mhGv9ScWxDrJEMOE5sGFwivFQzVKNSCDTjJM0XLlNcKqYiGEwEqL8j10lpOsuwWak+R1mbFoue8+k9xMDUJK1OebU7OYSS9muNjD5NpxXrAMlwbkUUZtLkT5Y+/pOMU0L/Qd5cG4tjAnZGCRUVpdf5NmCK/IJJWVmzSv+uFtkQm1sWV4fgWTZNT3z1efoe0skz/5EP7VN0+MN7v7w+QPf9p9jqUaUukLIoTzf7AbeqMbbWqv/5YvqopwOTyV1ijhBfh3fA129Tz60mlHCK7PIA9d+yWRzAXwT96G2nuU7JHPoC894dqxDp/Ev+5lX7YgpBrbseuZ+/b/g/i+T9H9wO+gowSvFk5IkI7/eyIImYKs00V48wTtFvlwiM01fi1EKJ/6wa05CdZaJ4IQ9Z3KVFADY8gXL0ws0kUQbMuBs9aiGnWCdoO0s7XrurUWrTU2y/GbRbIC92woeXjl9gin3KcCrzgGyCBwi/7Mcc50kqDCUSUWUYRAQQ1xGRPKcdNS5CRfsGrDNcZVQXNdVG5GPk/RpVVUPSSYabjEShSh6vWxXIGbb/PBkKw7+ZyUniJ+4MoJRADqJ2/k5M/+N3qf+TjDxx4kX75E/NgDTr5aCmdUW6yh8kijE00WZeRJXvBE3EKlSmZJgUkMxhpq7Rq1I1d/mc/wy4td1aynh+dFIFLiG77hG3jPe97DoUOH+NjHJg2/Op0OR45sVpEB+NEf/VF+6Id+qPq92+1y1VVXPWvjTLsD1vppoWTlHoBZwfEo4QtYH2QsNHy0sRy+bi/7r13g7MdPMVgaIJXkyCuPMndyP53Hl7m65pFGKUtPrNNbiVjtpywu9mnPB1y8kDPrCXIDmbWkFh7qbuOQiwtCqnLrhiAEIGdkZggu+JE4E8O0aKcKRWFWSEFMR6ARaKhM6cp9ZdoFJDP+ZDlf41oHlBhVRpJUk+eaTpSR6ZFbeTkOpaRTwLKWuJNQmw3pPrlGY2+L2nx9YlJLOjGXHlgk7qZunL5iMcl46HyfXpQjxMiQUAg39rwYz2xxbuX+ypayCaUv69rScuvatdpFW9nGJYMAbGronO/R2tfAb/uEMyFSSYw2ZMOMtJ+SdBLu/pWPgHUu4ftvO4awLhQse9JNrolXp0u0WmNIe0N8U8MS49VDJ2uri2qa75P2h5VE73iVxFpLvNwhH05KFDspUUFacJm2WxTV5psTrxttWLrvPNHyYOKiiCJyayzUJ9pASpjcMLjYoXVknqQXkaxHmOIchBQEszWCVq3ijpRyzxjXx58MIkwpPVl4m/j1GvFKF3+mgVcvgwtBduruiUAkXzzjghAo2hfGqhHCcQKEKKJmUXy6tRa1N7zzsnyTLxWEEIiFI8iF6c/ELwXk7F7Cl33Nl+3420H4IfXbXoea38/y//45ku5oAT+uZKVqAX6zdlkxjLzTRczN4jUaZF333awdOrjt+8oFvxUSm8auQrLRqA8u3wIlBNLzHIdrm22cxK+rEgopK3U5gGCuRTDT2LS9LdQSVeiSPKrRwGQZJkmwuSbXQ1StjmzPQxZD2ERuRcQv9mvSBMr5oeQolNUMa0G5NsxkrUd+fqlKHknfo7ZvDqkkWT+q/msc3IOUEj0cOnU/pciznKzTq9pSx+cEk2vs6pIjzz+FAP/5DukHzL7qDcy+6g0ArH/k/Vx8938BcN4hFvJYk0c56TAlG2TorBA4sFT3gvQdTzKPc8yywa/7mOEQWjvz4nohwqk8Pr0quFBXrvHm8yoQ0Vpzww038IY3vIGf/dmfrR7yWZbx+OOP88Y3vnHq+8IwJAy3b915RtHeR6wNw9yQ2umd2pmFxcwQpBpfCA7dvJ/hYo943T2kr3r1MVpH58kHEb0oJT3bwcs0fpqjUs2e3KBPdTgkBOFsyLkoJ9KGAEEDiLUl3qb0LRlNNvnWm422L+fBovLhSUFTuQyYJwXCFkFFsW+Kf9uxf7tFOwRyxFVIC9Utv7B4jwvlKdVNMBuCkLoSNMf6MNN+xlq/Q20uxPMV/fN9/KZPWKhe9ZYGrJ0dLdhzY7mnm9Abj7Csc4sfFn9Lx47XyQwLgWQu8Ko2rXFE2vBwL62c7sGJDJxsBSwEo4eSL4ULtKzFZIbGvgYzB2cmOBtBM0D5isHFQXXRTKa5+JnTCCmYOdQiKFvVhrHLXuV6tGiREukpVOCj44R8GFVZ3eZV+wnaM4gwIE/SCWWpsr0rG0ROgneDHnzaT+lf6GO1EwkoZam3wsZ5fem+8wwu9YrqhOND6TjHaKeaJYDGXiexW/W2lzyWxNB5fIW8aNmSniCca9A4MOukfItgVPqeayvLDTpOiVa7mCx3FSVPVmpHOsvQWYa/0qF1dH95AbBxv7oW6f2fJLv7Q4hxFZ58ZHpXDJCiB8b9OneA8LVvf0basXbxpYPNU2Rrjrmv+1bW/+h/bWq3E1Li1YKpLT8bYXKNSWIXDBeQSo3a4raDoPoe62F/w35zpDHbLnKq9sZkay+NakyeVy3OSwTtJmG7OQrAqiDBBf1+o4bAuWfLMETVnPFqKc+r9h5ENGddEKVzrJ3O13PcgxSbpejUVWf9mc2tV+V3WgY+DEftcibLGZ5fntheRwnDCys0Dy04efE8J1ntOElzb/M4qoAkz0lP3Ud48sqU9AVov/IrWHrfr5OvrRYdCAaTGvI4d0FIUih+prpKKloLxBohwW+45WO8nuDNzX35TmQXz3s8pwORj370ozzxxBN867d+K0IIfumXfokf/uEf5lWvehWHDx/mox/9KF/xFV/BRz7yEa655hpe8YopcpZfBmSZITOWZAcL/LNRztGGT2uhydoTHfa87EWomTpxNKD7wDIrlzpkaY7Mcu4502F9kDMc2++cJ7mu6XNzO+Ce9ZiBLojrWAJg+7qIg77MOJ0Mb9ErbJyrugeVH4kSoiLMu/25YGK8TC6BGd95h0gB/dzxWWDEDRlHnJmJhX8oBa0pLT+12RBVTP4qVJjcEK9GZEnO2oXJNoXHBim9fKzPldHEl025BhpYTA2rWcrRDcog65nm7vWEjTmMbm74/HrMre2QAzUPXwnChpMbFsot4nVuWL/UR0hJox3ih+68wtmQ+RPzrD66OtqhLbgX53uu+rN3Fil1JbdYwRikFxR8jtgROD2P+ZtPEpSLDIBSplEbskHkfEuMqf42jmyQ0TvXKz7oovd8w3WqZJWLilI2SKkXYk5xN6J/oVtl0+K1uCI/CunaM7rne0TrMY2Fxojz5IlNiz+LxWQQrUUI36O+p+kyslE8Me6408ekOV7NByVd+0nJ6Sk+7+HiGvV9886QUUhkaw+6s8zg/b8Gw/XNxnTGOInQDZleIQTeidvxbnnNFZVZfb7DpDHDj/8x0b2frGRvw/37yYcxurtebadCr7pvdgJbtJCWCQYdDS/bblERqYtAY9ys0BrjeCuej+9trwyYDy9jMFhiU6lWEMw2i6z3xi83YC3Z0HFHSoUwmyZ49ULGWXmIRqEAaLRToZMKW3jMVJUYAKPJ15bJ+kNMmjuPH6ZwZ4r3hHMt0vXJwGwadJzSO7tE6/Degv+Wblbkm4Lorr+8ogMRGdY49sM/yemf/BHoxJjMcVadUqXj45nMOD5IMdG5HIyrXKX9HBUaVFK74n1ExDOgmvW0Vbeex3hOByJPPvkk//gf/2N+/dd/nTvvvJN3vetdvPa1Tpv/fe97Hz/5kz/JPffcwyc+8Qne+9737ojI+aXAnpfdxrBY3Y/RErZEN9MMu4YnP3+BYfcR9p6c58zFAafOd+llk1WBjftazw2f7iTsDyTXtQL+ajVmwxJ1KrR1/Ax3zbYf4aQFl5soSl6HEo7LoRkFFNoWpEQcsb5sukqNqFrUxoOfaYwDOdaqBY53sXFiUb7TQE+iImMeSYJmgBcqhp1J34fMWC7FObmdPJ4YC6C2Qm7hzDDjWMNDW3iol7Ccbq849UAv4UBd0VpoINRozGvrMY+f6WKqfmzYe7TN8RcfwA8Vjf0N1s+sg6FamFtjKxnjC391ikMv3dxuI33XP51HcRVYzN9ysprsh4trrD/8JNHSOsqX+I1g0/elbBMrj9m/1Ef6I4Uz6cmqsqFTTbQWkw2KLKyAoBVggfaxPVhrWb7/YnVrJd20CkJUKCcCDZ0YovWY+rxb3Ohs1PYkpUR4Yz3kuWG42CVZH+DXPedFUjzArbXoYQIS8iRzrQaDBOErvHqA8kePu/WHzzB/83FsnmHW1kje83MIbME3mXJHGA2pdlKpRUtN+NXfhbxML/wunluwWcL6b/8Ceun8xMLb9NZd6+nx64lOPQRcviVqHFUrkzYkqz0nAhHF1K8+jgzK75pwDu5FpcSkCSSOJyaCGibPSdfW8Yu2wbJ1Kuv28JsN7JTxlJyKvD9EeGqCYD/1/De0fXmNsKqCbAlTVEO1IM8TJyJBjNdq4R045ioRxmBjdy426ju/GS/ACkBrTDTERH1smrkkStGauW3bGlBbaBOvXF5cxmY5g4srTpnP7eCyn12+ePay+32hIzx4hKu+/0d55J//k0JBy6ATXSXAysSZkALlbUgOWYvODGnvKXosvQAhpdzWUHin+7hS8ZwORN75znfyzne+c+pr119/Pe9+97sB+L7v+74v5bAui/2vuqOSr91JIBJpywN/eDdrg4SDJ+a4+5EVVjsJ3UJyt2xDt2P73LgMXkwNcpCxEEqWEjPxeqgEyYayR2YtXnHjS9iU2S8hx36Ot1qV2DgWiUAIixUCiUAJdxxXPSk2si6AgeJhNuW42tqqIlIqb206cNHTWr0n1kRxhN/ySYYjyVoLrKVOqWzj+HdQtILiHB/pp6ynphAf2B65hXq75qogQmCs5fzigOEwR41NwNbC0tku/bWYF7/xavJhhpQSK8aCLuEkqq21zBxuTwRk0lNVEILFkW6NQfg+wUwTgNUHHmfl3tNuYe8pguaY1K+1ZMPMtWaHkng1Yv3xDknHuYgHMwFhO6haoUzuJqr+pcHkxbOQ9hyhfO74OsFMneHyoOhKEW5yw1Wtpi1A8mHOMB9S3zPi+JTtAuQgfVm1vVjtPkgda3Ss3fWpKZSvqskTqNR/wJIPE7TK8Ju1qjc/XXdtezJ9yF3HwgzSVZO2kAM1Tj5YXXPrbhDyPMTw8x/ZFISMQy+eYc/f/G5Wf+v/KbQIXMXisv3fQiClrKTPTZpDCuuf/wJ7XvFy8INN3hVevYmJhuj1JfBDsgvn0cN4FIhop/ym04z+2Ys0jxxAeN5kC6MxJIuOV+I1QrLu9MrIuLT3xLCl3NFD0CQ5MhQgBTpy3Ktg31EXWAGmt0a5I2MM0eNPkiyvVseTvsJvOyELay1ezb9soGCtRdV33lJtspyk03eJiaK9bDuCP/rK7ckfR+P6mxC1EJm5AERnI+GfymvLl0hfVtVlqy02t3i+Ih9mlT/JLnbxxeA5HYg8X5H2XWbIF5Ocgy0hBetxRiLhsdMdhLYkVlBpRZXr0WrxPj3AuZhoDoSOSFZON+1Q0JvSI6Yt5MbgSUmgREWq3wghRkGDoNDet7aQ7BWYghtiJioLjjvinNolDeXI4NZaIjPGISneI2HClFECUW5p+dMnEVNwS3Seu+N40hk5Fhco62cI3DZ5MQHP+JKXzYWcjXIuJF/cBHQh3vn72r6k3vCwwJnlIWdXY/IigCn9VFqlu7yFqJ9y4ZFVvDgv5BNBFhNpmW0VQiDH/FIcJ2RKSVwI0Jq0N0QnqQtCACwIJVh5dIXB4oBsmDvCYcGPkZ7c1LkRJRHxWkxjbx0zVgWqzYaFsspk/c3khsf+/DH0GA9Heo5D5Ply2yyoTg15rAnbAV5NuVK1seSJU3FBUC0y8rIK5kuUJ9GRRiCqYEX6isprwLoo3ubumnitGq39+6r2fVk6ZpdjM8YR9OXmHnNrLcLz8W94brSB7uKpIb7rL7cMQgAQEr10ntmv/za6f/y/nGqUse5Lu+VbnGKOFa5NaBx5p0v34UeZv/PVbtuNbUi1OmrvIUw0IO+5zH+y3nc+QcY6g1PAJCm900/it5qooi0qH0boKEIqr1ogIsUmWdyqZTbdzCGxmd7RIlJKQdLpO/lrJckHMfnKMvLQEUxvDTtwYzfGsP7AKeyGY5lMk6x08ZohXi0kj9Ppz66nA+vOUdbDHRHRrxQfkctBSMXhb/1Ozv7yf3HPz7HFhbUQtvwJXqBAgHLP3jzOkRJ6Dz9G+8brvjwn8BzAbmvW08NuIPIsIGy3oFCXulxFxFpLiGtvSjVY6yR+t8u6C4Fb2AkXBIy3bg21YWE25FLRmjRIRov9tucCh9y6xby2kOcGtQ35GDtqEcoLyd7yvELpgiVrBWUndWoMnnDeGyBo+xKv2H1k2NRmVrZKjZ+tAQba0lCORzLINctJTl1J5gO1ic8Ra40SMBt6hdFgYcBYLDhyYzkTZVyK9dQ2sKeDjZ9vKAX7A8VCy2e9l3JxJcZay6ySxMIy1K41bT0zpEYw7498V554aBUDrMU5SWEYuX825KqFOjXfZRKHi33qe+qsrccY6TE/L6jVJrP35WJneH6RaLU/6ukdZKzcfYk8NZhUY0uHZYogdwqxVvoCv+6jEz1ZofGdo304G5InmjzO0ZnG5hZpQXjS6dBb5zcjPadcdblGF53m1GYnifxhoDB1Q9xNqjYs6UtHoM9cH7NXU6NKiBTorPRWUSNlnuLoup/Qv7hC6/BeiugDoJCotIWyT+oI6mOZcCEEQvnU3vC3vmQyuLt45mB1jul3LrORRa8v0X7N19H/0G9X3x2Ta6TvTQYxRZJACIEMPaSUJFM4DcHCXkqlqo0QQiD8ANNbx+aFEafWxKvdzSR3C1lvQNrtk3YGJJ1+1YrlNWrOFNX3nGP2BoO1PM2waVaZgEpPVVWeZK2PUBKvEaKCLSqBwhkdZv2IYLYJAuLz51By5NVjraX78OObgpBx5IOEpB8htMWrhRNeJdOuTdLpO7Wm7eao6g2MHsYukzOVJ+KqQwLvwLOnnPl8w76vexu9++8l+oM/RajRpay1NwSLY9dSAF7NQ8eazl337QYiu4HIF43dQORZgFcLmT95DWuPnEYJLqtKFQhLvyKDCeLL9Pm6DZ0aU7NY3PUzQ2ItSkn8IuPvC6pFe8uTCOHI1BuRb9dqNPYMLwOGobZ4UjDUxnE3itcTY0iNpVWoIYXKcUmcMpcLfGZ9ScsrCO7G0M0tQ23RxhJrW/FbjLWcj80Y38XS1ZqhsezxZdVWVkJb6CQ58zWPzLj9CRw35J5uUnF2nimUl6WlBNe2fGpKoosgrZcZbG65tBKDdY7zUkBTQF0pugWnJtUGY8u1ji1Miy3zgWKQG3q54eJ6wnI35SVXt2mEHg88ssLyZ85jUk1mLEup5rqb9vPGN15Lqzk5aeSDiGi544KQOOfxuy4xjPKJylNdCcKihclYSz8zGGtp1j1aTdfbLsc4Lk7Pf3TtrbZIJQiaPuAXaleauJdUSitaW7S2VVCw8UL6dc9VMCj4MMY6VR5GQZVQgnAmIC8DIgEqUCNC5VjlyOYWr+5XfiZ20/0tSDsD1rpDZq45iKqFRX+iniC5OoUfUUwQwmnmv+lbkfNbe0Ps4jkMqUB5oLdh0QmBDFz7XvPQPjCGdL3n/CyyHC/csDArjP+kUsQr3U0VEQChvG0rDtZaRK1OMD9Hvr5e/nFCXnd82+HF1U0S2/kwJh/GjuO14VknA6/Yl1Odk2FQBVDVfrUh60XYpnVKYRtROLDrKK2Cn3S964wcpSRPUwbnF7HR9nwBay06SvHDgGStR+PA9IDeSQc7vo07/HQlrg1vGglTCIHNNaJ8Boy1swFgDPXbXrv9/l7AWLnvIT71L/8Na/c/TKgsLWHIVrtVkCYloARZ7HxGSpNMa63jjAgn5qA8iVDGBem72MUXid2751mCSTM8So8JqgX5hHETMMwNs4Fzti2xg9yP28fYz5YvsblBWadONf66LyAQjth+IPTY2/Txaj5+qNh79Tzn12MeuP8SWbo5AKoET4yt5jcLdDPj5HSLKou1ln5umCsy96Lw5oi1oZMZEmOoKUnTgFQe+IqVnibThR+IsaRlZo2iYjPlnJ1LvcUTLqAKpKBZtGbZYpyehdnA9VL3cmdMeFlpsC3gCyqPE21tVe2pfDKs5UyUc2s7dIuXYkyxtpsm+8PX7+fal1/FnsOuV7yz1Of8vedZPr1ClmqGg6zavuk5r5RIW3Jjue9cj8xYssy50u8NFbOe4mTT58nTq/zPJz/L3/n2lxIqycqjy6w/sYbJNV7do7mnxql7l0g3tKSVlSdjNYMMLg1zDFD3JbcsFIo241lFwUQQYgrjyXEIIRCeQJvJ5HFYc+0j5fZeTeE3/Akif4nh0tBJMoejx5MQAuUrdGqQ3ogYKKQoeDiuLcRqi9dwxHRjzEQQUim+UPbXW7qnL5APY2auOuD6yjON8NXYd9Vi8hwhBMFtb8I/fHK722UXz2EIIQivv43kwc9Rub1vhDWEN9yGiR2/SfgB4b4FbJqhkwRrKWRhAVyVI48SosU1sn40dZdiitrfJuQ5XmuG8PAhkgsXt+y/TbuDTUHIxLGkcByqMYwU9lxv/8bn0sQwBnFhpDoSgAAQ1laL0VL+W0jJ4qfuRng+NssJF3Zm5Fny3bJeROx1qS20NykZ6iSjd+bS6By0QXmKaRWO4k3u3IUqeC/FXJJr7Nj5GgwCSXDdS/CPXpnf5Y/9k3/Fg//jN/AKBcvcQiYENU+gis/dGPACid9wFTKdaEzunqdSCfLMkHYTpCcI6h6Nq6/s6pIQz4Ch4RWsvLgbiDxLSHs9wFY+IqaQR/SLey23ltS4CoAVkyXkutqOPu5grWs7yYVA5xppYUY5Ez4lJTUJZUt/SwlSa7llXwtT9+l1Yl79lTeS5Dlnz6zx+KnVqUEIFFWQKT3VFiZ4JWnB9/DGMtNrmWZ9zGOjoZyKVpoZGnWf41fPkgF3P7pWVTBgawK7JyAQk0FWYixJqpn1JUfqPkYbzsfuuLaQXjoYeijyCb+P7SBwbvFKuGDqYE2xx5ecHuabKiulutfpQcaJlnNATszmXvAbXn0NN776eEUCBGjvbTL7xusZ3LRO59Qi0TDj7OMdep0Eay1NJYm0ZpAbzhdeGuVez8aaOV/yonbIVXUPE+V85IOPcbgXVb4b5Ru6Z7sIvfW5X0w0/bGy3bE9deQYl6PipBSl43IR74UK6SussZV6VqmkEtQU1kKeaay2pKlGaYNSkvqeGl4pjbrFgiheT2gsyAlfBucvsNnHxKl9uUWWF3rVvp0B11iG1BatkiXfRkqMMQwvrOI369T2tB0/JLWuClKeb32G2uu+Cf/Q8S2v4S6eH2i87E0kD38BpsjVWguyvQf/2PXki2cKkRDhpMtroaucjWHxs/cjpbhstSNY2Lv161lCdv4J7NBl/n1f4h09RNbrk6yus1HTb5pz+qZ9Annkvo9CCZQ3alv0GrXLVhZ0kuHVR4IWg/PLpP2I2p420vOQBdE8iwoZXyEgcIaK3lPMjCdrPbL+EL/dRPke1hiyfuTEJeIUGZZCHNbNc9PaV4okSTqI8a65gdk3vIbkkbsxUR896KPXV0abegGN215H83Vv3rEi2gsJ9//Kr/Pgf/8NRyM0FitgpubTangT94kKFRZL2kudIAiAGFWXlRRYKTC5JR3mtG+96ct1Ss8J7LZmPT3sBiLPEiRiIgmfaU2OICncSUWhfyWxmA01kNIscLBFFt8WwY2Xa1LjgoCs4FO2PAFIrmn4PNR3k5EvBVfPNYg9ya1vfDHdToff/o3PkO1wYZ7bEcF8Yhw4TogSsuJHausqErG1E+M/WlfMNgMOXTNLo+6TJTn95YjualRl6UqYKYGPwAUhW00enczQ9nLODDV6Qxl+kLsWsl5upvqFjEMCM55kNlAcrilmi+z4aqq3be/qacvC617EgeMH+dgvv3/itbmDMxx7yREeuvcCOjfsOzjDvoPtUfXj4Bzx2gBr+1x70wKPPrBCr5PgCVxFaaydbnwE65nhnLXcdqTNvIAHlvtk2lSZy/E3uNYxs6lNUFtbBSFSQKAE7ZpCldwVa0YBgywqE6Gisa+BFyrXhrUeO8Uqa0kHKTIVWCWJeqM2FSnBDz28wk8FwAs9VFFh0amTJx5HFmWEM5OLP1m0SZUQQmBxQZEK1EhZayzg2xhQuQ1csCGswEronV0kKFR9BC6TigoIb30N4W1v2FWEeYHA23uI2W/4LtZ/9/+pglIos/Apg4ceQX3g92kcObDtfvJhTLLaxWuEBK3ppOdSzjc6c4bWjTduuodsnpGefgj0JKdCSIHfbiF8n+jSUqU8Zbdo15p67OKBbI3jUalQoXxv+kJ+A0ymsaEh7bvWzmi5Tx7lDC46/otXD6jvbRHM1Eb8KmvBWKwatUlOgxCCPEkImo2J4yUbJHqttZg0c1LB5b6K61kGHoiibdJCvNZnuNjBH97Nse//p9Re9KpqX7q37qR6pcI/fBwZ1nZ0DV+I+PRP/PsiCDFE2tII3fPYakuWO8VGf8Z3AWGUY7UlmPGxFtIoI0vHn6vup9GWc7//Jxx7+1u/TGe1i+c7dgORZwn1hTmGK2soAb4QIBSxsZs8PpQQxMZscu3eH3osp5qwyFD0clO0+7jXGxKua3pcyizLiaYuBZmxnI8189qyv+ZzpKY4G2tqUjJ39R4Ov/wGPvOxh3j47jNP6Vxy61q7pnQKsJoa9oey8gqJtCGUaqJaEkroITg0G6Iyw+KldXQ/w5eS9UTvSFLX30H2qgxCtjLIWgg8LibbT+RCwI0zAQtjGXsL7K/5eFLySD/dUnzgoYfOc/PXvXzyXKxl3Vp+5T98uPIOAThwZJavftutzC84M7HmwTmStQHWWo5eM8sDdy0CTLrAjyHwJG98yX6O7G24RYCFVx1oYrRl7UyHpOuCgJKzkhfVACkEnoBa3WN2rkYQehxJNekwIxACv+njNyYJpJW2PK41q31kBosl6aaFmpVAeu4a12ZrBK2A5cfWHJ9ECXzfBQjScwRzHWuaR0o3dVCBJGhKTO78RMrWkjzRhGMKueVnsfH6WmPxal71AepMo5OcsnVGBmpCo728H4x2+vgY0MOEPHJk+PD622i8/CtRCwcRavcR+UJDdOZxBueWUTUfVbRw6jjFFAIH63/yO4Rf9ZWUN6hlc4UzK9qj8mHiHNg3yMwKIdBxijWG3n33UjtyBG9mZiIYyVcubgpCxt/vN2rYhVmS1W7VDrUzTH5LVOjh1Xz3/dumClnCaM1gcR2TafrnO5tavfIopffkKo39M9T3Fl/QIqAzud6S8F4GZmlniFQeKpwu4VvyQ6ZV4svXsTBYXHeqenE6hQc2dv4zc6iZuW3P+UqATlOStQ6ruSEp1Cv3NwQ1S5UEssKiVzTCE9TnayhfkfRTkm6C1SNJ/VLZscTpX/3NKzoQ2a2IPD3szrLPEo59xZ2sPfo4vrFE2pAYW3ljjPtIAHRiTcuT+MXfBc4xfc6XVXvVkZpT0joXZbQ9RSDhicQFJi1PIoUgl5ZUG2JjeXyQsjdUzHmCRqiIjOAv/uRuzp26NH3Al4GxUJcw3LAujo1lkGtqyvEwImNpmJFTugRqocfLr51HSkEmJEfvOMbM/hZWG+7/35/HF47YDmwpI7zxmo3DWku3qHrILbYRQrjjSFeV2gqHax6XkpzlVDPvKzqZ5nycuxatUHFV3SM1lk622U9k6cll5o7uJZypk/QirLUsJTnD06ubjrN4vstv/4+/4m/9/Vcz066RCcFKNyH0Fa2GT73hsdpNt6zg/LXbD7B/rladm3MeN+hMM3uwxWrW4eJ6Qm+TUoLl6L4Ghw44t/VsmJN3E4QFGp5TnyonG2OxWIKGj7enThbnhDMBcTdBJ67lyho7KQHsS3SqCet+tYDxakWlopBYFlLQXxz5kAjpiOhBO6A+X2O4ErHRtGarRYlOtWsRU67NKhtOkoVt4cUgfIk/RsKddi+JRpvWa7+W2q2vuiLbNl4IMGlCdN9nyZYvIoMa9VvuwN87KS7Q/cs/B1zwMY1cjpRkq8tOEMNqhNy8sJZjvI+sH5FHCV4tKMz9LHmcYLXBb9WxacrS+/+U2dtvp3HyJEIUnjzry9uei7UWFYaE8zPkcUraGeA1attyRIw2DBaHmMwgJNTm63iN0YLfZPm2SlXgFkRBs8b66cVNQcg4hos9/FYNFXrVd9WaQmGs4HPoOCPpuGehV/PRSYyQgni9R31h1rVj2ckWSoB4tYv0FDrNJ8jz5XMg6UVk/Q3XQSlat96+7TW9kpEPIpZSp9pYk4KrWz6tQiRkk7JYbkn6GapuiXrphMJi8QakHc3z8dL29/ILHVLJHVUbL7ePKxW7gcizhJve/mY+88u/zmqqJ/gOWZGZrimq7IIQMLSGuhXsCSQNJR23QgrChofWlih2qifXNkMWk5xubgml4FDDp+lJHlqPWUs1edGipSRcinPn9eEpLj6xQtaNmPMkiXUKVU+Fvp0D0sI+X7C0YXW8khnaRlCXgshY1jNNoGTVznX94RZSCuaO72Xhuv1Y49Siehe6HAwUXjCa1K21rCQ5SztsGzPWcinRGGtpbUEKjbWhnztFr8ud85MTvhgZEjhY8B262jIvXevWjCcZaMOFeFTRETjezove8go+/msf4mKS08mcG4wqgiBPjDLycZTzsQ8+Qm+Y8dCDl6qW9f1zIYdqHoMteB1H5muoYcaTF/pgLI2ZkLBwPc9zQxTlaG2oBx6JyUnHAqbZVlAFIdF6wnB9NJnnHU3UTWjuqePX3OK+sadeJIZdNnO4HDmCuBTkSY5OdcG9cLyRPCmJrEXzoXQk81KNCijkOIvfi4pG3EnQmaG+UMOv+2TDDOmPCLPWWPJU4wWjR1aZGQW3ADPauD7/0lOh/FyEcCpjpBPBCIVCjDUG4Xns/e5/hbyccd0unrMY3vcZVn/3f2CT2ClkWUvnz36H+q2vYM83fgfSd599vnKZZIwx6EEfr10HBFbnCDXJafJnmsjAx6Sl5K4hG2wOEJRfmGSmKeuf/hReoJDNlrv3xl3OvcBNBEZPqHqV7u42y8Fawtnm1EDEWsvg0oC0NxlYDS4NiFYjZo/NITzH6wj9bfhZQlTH3Ek74uBih/bVC5OXL9fkac7g3Bppb3KsQgrCuRDpSaLFdbx6iNdwv5ff36w3QEiJTnPyYQpzLbx6UD0Hsn5MvLpZJhlj2Pe1V25W/nJ47COfJMd1N8z7kpa/vRJZNsy493wPi6BdV+wREBbPx7I7ovQsC/cubLmfXezictgNRJ4lnP7Qx1lJp/tWWCDWloVgpPaUaMNcqNgTKJa15arjsygp6HUTjAE1G5BmhvXVmKYnITccafkkxvJwL+FSolE4OVYlROViHgro9hMoqjGBBM8KZpRgMd3ZYr9EamEps7SUcK0+QuArwYG6x6wvCZXkiX7KSqwrKcWaL1mYCanvbbFw3X5Mpll64CKdM6ssXxxM3IClWeI0D5WsyM6XQZ3EEeMHRbXJm/I8tdbSKWRwd4oZTzLrSxSOezPIDWtjQdFK6qpX19Q9mkpyqOb4KbmFg9e4vvLg6v08PMwmWrG0dbLHvoC6KnqljeEznz0LQkzwZpfWExZJ2BOqiXa4uhIcq3vslYLOpQF7DrRotHzSXuYUoLoJyZgylgT2BIpEj87hwN66I2ivxcTdzdng0txP+YqwHTq+joFskBVkcRdAJL3EmRmORWFSjpx3BYAUqJqHFc6ZOYty7FjlxKv7qEA5Pod1E1/Q8vFqimyY4dc9TG7I4py0lxLMBBPZ06odQzg3YDeGKXyQAibV2HA8+zpqA1n4+m/aDUKex4hPPcjKb/zimMzf6HsQ3ftpVo1h79/6XgBEELpgZSsIWZj/1d13E8nyXQ8Tzs5QW5jFGsPwwgp5lE5IW2+EVw8nhBWCVoNs8QLh1SdcoCwEBDVEWJ+U0jUaOxxAnlYBdeWLEwbU980RLa9PVAwHi5uDkBImM3TOrDN3fB4KU8+g1UDnOWkvwmiDVJJgpoHfqlXfj3C2QbwyZcE/hjxKNxsoWkvvieWKMD/xmrHEazH1Pe6c88i1RCJHZqQIF9iVz4q0M0CGHkIqWq//ei78r191pLMykJMKrOHo3/9H1K+5MpWwdoKP/cx/AaDtK1rh5eWQpRA0PInEUjeWCEiNpuFJ1JgoDcDeV97xbA//OQ1xGdGKne7jSsVuIPIs4cEP/uWmIEQADSWY8VzVYxxtz2Nv6BEZS9MTnH98HYPzdpBFu5YUgmbDIx7m1H3JWmaoe865/Ju+8lpqszU++pFT9LoJuXEL9M7YIMYd158OMuCrjs9V82CgnAKRNZZ9MyFRlHHPSkRqoFZUO2av3oPJNec//QTx+hDrCRaOtcHC2sqQS8X24CpFobCMG8JvZHYYCqWuYpvcOiUyxWgRGmm74yBECbim4VNXEi9QXH3rIY5ctx/pCVbOr3P2iVU66xHnF4f045y1VHO4ERAqyZ4iyV7rDzjzVw/xP37itzcK8oyunQWv4NxUVamN6j3Fz770ecU738ynf/MPqWG4aSYgkAIJ7D08Q6MVkBZqVYNBNhGEjKPhSZqBQltoBYrh0pB4uOGKCmgfbNFcqANOrjEqhQR8iVKyCkLitaTqKXYmf6KqkhQCN9hiKFJJskFaOaGXMJkhzRK8ho9XHxnFpf2M+p4aOtPE686ToAw6jDZVC5g1Fp1blBKo0Cukedky01v+LYuLqogrnWAyTf26W9j71m+e/oHt4nmBzgfft/WL1hLd9xmyxfP4+w/TfMkr6X/mo5MViYntDWG7CYXj+OD8Mt3Hzk/dVPrK3X+ICd11VQsmeCNCSfxWHRMNiZ84RXj4KKLZns5BEhLRnIFBFzsYFH8a7dxv1vFqIWl/iElzjNakU5IK4zCZIR9m+M0AnWb0zq8UPKoR4rUB4XyT1iHn7SF3uDByRqBj37FBMjUIGb2hTDoEo4edHSUVrLZVEFK+JsIWx/75v0PVG7RvfyXLf/qH9O76LGBpveg29n71W6hffXxH4/1yIOt0Ofue3+fiH/8ZehDRvvkGjn3bO5i7/cVfsjGsPvYEAL6E2ZkQtpgvxpFbWE8NgTDUCgEdg1vHHAg9Zorgcd/rX/1sDv05j12OyNPDbiDyLGHpzIWJ3xUw46uqXUlbO2HK11CSzBhybeklBm1BCVtxHkxBmrRRjlSCKNYcnQloHWzzqjuP8YlPPMHDH37Mra8EUxWenilX8URb7r8wwCtajUIlaNc95poBElAaThxs8dCFPlkxodTmG/TOrZNHCbPH2kglq4z23mNt9q/H3P2FS2SpM9TzpEDa7R3mS6PEsmqwGOfM+i7IE0LQfQoEz32BIhTQ3tfkdX/zdoK6TzZIWH/0Iq0858YjM9jDLbgZTj2ySr66OaMad4e871//Fsl2k3Bx/TxxeaPLNIq55c1v4sm7H2TuidPOyVYIwppHcyasFHGstcRxRi1UKE/i+wrfd9fAGItJNXmx6IhWI/TYJO/XPdqHZ6jNBG4BYC3D5YhsODqHxkK9WgjlUV4FIdIRd1D+WCVECLAuALHW9YsLJVCB2qSKBZAXLVhSufeZ3JDHOdkgQ7RcllQIgRWAccdHKTCGkz/yI5x79y9DPtxWqaeEtRYTG/xa0a5lJfve/m3s+ao3V207u3j+QQ96pI8/vP1GUjK859PMfuU3MPv6r2XwuY9XrYEbt/P3HUKFviOSW0P39PQgBJzik8m0I777zsPCb9VGLVnCVUakp0gHQyeeECVk6x1aN02XPK0qdvUmdm0NAK8WTPBZhJKEsy0AOk/srD8/7sQuEEn0piCkRLI2QCcZzQPz9M6vjaTARVEtVZPfs8a+Jt0nV0FI2lfNIYQg7Uz3UxlHHucEGwxYjTaF47uYDESkpHnbq1F1p7RVO3qMo3/3H+zonJ8L6D38KJ/6W3+PdHWtut/6Dz/Kud/5fU5873dy7Q/9A879zh8yfPxJGieu4chbv3qTVPQzAZNmTlmz7nP/Yp8538OTsCfw8LYIOusSglCxnGjWxyasXm7p5Rl7A8mxA/Pse9XLnvHx7uLKwW4g8ixBNevVv+tKEEjnQK6ByLgFdl0aGsWD3RPO96OXO/6Ev6HPHYqFlBBI44z1LvYz5KkVPvvgIp3MVNnoZyrg2A6ZtSz4yrWWWUueGs7FEcuZZpAZWkXLwiDR9IqFee/cGq2DLddKk2qnupRpEBCEHi++bT9337/Cof1NhIDV1Zh4cTCV16GtI4yPx1saWM2cgeKCLy4r1TuOi4lmNTNcreE9v/pJWnWfeqDYO1vj0L7C3K9YIOi1rds6OjuowJhi/DUlUFIQFZ/5OISAEzccRC2e4jt++vt5/9/+YWQxhmbbafyX/2lt2DNfENdLo79iseAFCtnwQIQknQSTGYwpKklKkGtL52KfLKrRmK8Rr0XoVFf8jPp8HVuoS1lrKzUuKLgennALCGQVrIwvVIRwwYTyFaqmXPvIhnMdLUosQgk653pgLXmS4ysfEMy+9CWk584ipGTuFa/g0NvfTuv6Gxjc93nWPvphBotD2kdmuBxMptFJxsJb3sGBt79rl5T+AoCNL7/wRQhM4rYLDhzhwHf9MIvv/jnMsO9ae3CcjeDw1Rz4zh8i/bNfAVNm+C+/f5Pm+I2AtBuRDWK8oiJSPzg/usesaznSOiXct7W3iBuuAOUhZ/dgOiuoWuB4VlN4Y9tWH8aQ9lKitYjL+ablw5TO6YtVRbIcu8kNaFCBa+sRniSPNauPLJNHOY2FBn4zdO7ul4PdUL0Uzr176vfRgmw0d3SOzzWYLOMz3/59pOudiaDXapeUeeTnf5mH/+N/GwmEWMvd//THue4ffzc3/ND3PqNjCVoNhlHM/asRmbEsF/4gkoSjTZ+rm8HEOFJddmNYDtQUy6kek+l389hyarjuda9BBld2Ime3IvL0sBuIPEu46uUv4dKDj1GTYkvp2chYpHCBigFXEbHOzRs2L+igaFMRgkC5LPFi7AjR7sVn/jx84ZzCBYKGci7mSji/Em9snL3McE83Yc4TtH3FfOAhMk0vNzx6oc9165GTeMWSrCXE60lBgLZYA7pumLtmlje+aWZC27/XS/nLT56j000mxtXbEISMQwOLTyUKwVWsDswGXLUnYBC7B8KhvQ3mWj4XV4cc3OOCkfWLgy3brqy1lC4XGzcRjPgn86HHwZmARqFYkhvLmV7CA2sxmbHc9OIjvPVbXsb8QhNY4vz775rYV9mXXhp9VeaDYuzvwlU7GPuMTO6qJ3lRXkdbrNEoJYk6CSbTeIGq3HSlJ5xsqHWu5Uln9Bl4oarkQMv9l4GRyQwmd/9WnkT6CqEKf4SmT9YfLZysta7KUmRevbpH3HESyfX5gEAEHPzGb+S6H/4nRGfPE124QDA/T/PkcazWrD1ygaX7lkEKZg61tu2zFUJgtGXPN3wbB7/pW7bcbhfPL8iZWfB8yLdZkGuNvzDyBqlfexPHfvznGNz9KZKzjyOUR+Om2wiPX48QgmxmD2b1ggukAx+Gxb0vwG/WEEphc10R1IWSqMAnT/u0j1+FUJqguXVWW3g7m3prt74CvbZMdvYx6p5PvLg6IsgX3z1Vmy6XOw3DxQFhO3TtkNtBCPyGXxmVVrCuzUv6EpvkxHGGkAKdaDpPrBC0ajuah4ScDDpMpvEaWyxmraH98udn68+l93+I+MLFqa/pzGySHXbKSYZH/+N/xWY5N/6zf/iMjWWwus5wSoeBAc4MMoyFEzMuyZUay2O9mHZhWDs0EI451iMcTzTSlkc/dz9f/YyN8vmJXWf1p4fdQORZwqv/3jv57K/9rlvEb5N1HWpLTbovfqntXcJa58yeG1upLoF7zrd8SStUSAn1RJMa91DYSv72qaLks5TVmoOhR9E9Q9OTVSUEYDXJOV+oR63lloHOyaxljydJBSx1E+7+9BlOHm2S9rMqCDFFsNDYV2fmcGt07LHr1Wz6vPErjvEnf3aKONHkxhHIn2KccVlo4Hwn5cnPjSaNWiC547o93HhV27n6CkHUSza911rLULtxzfrOBHGoDWupZlC0YR1v+IRK0g4V+2dGrsXgDCyvaYfsrftc2jPDt37vV0zs36+7Cbp0uc/HyPPSV8yd2EttroHRlu4TK0hPMXfdfoQEHcVOeUYpBpcGrlVOCMJAEjb9KuiAsWBXW7I4Qycav+65ikag0AWJxwsVwhur2BmckECuSQcZtvhwrLWkEkAglFMUCxq+q64Yx/sod1H+TPsZUomiPcOSRjnh0WN86lu/i7VPf64aa/PEcYbnLmCGESDAwGBpSHN/YxtvAlssop75toddfPkgg5Dm7a9m8NmteR/C82m85JWb/ta64zW07njNpu39G15B+snfB2Dmqv2srPcJZ5vU9rartkOba/K0Qbo+xJ9x6nJzNxznwOtfyfDxx4kvXdry2V8GE5eD8Gv4R07gHzkBQFNrors+SfTw/WT9CGsstZmndj+ngxRV256sLKASjdgYWFjjFPTK97cONNFxTlx4ALkK5/bBUen7Y3HJKFW4tY8r4bmBCGZf8yaCfQen7+g5jpWPfwrhuaB1HMaMgpBS0txv+FUlGuDJ//k/CdoNjn/Pdz7tyu36mfMk2fatymeHGQdqHqup5uwwo5tqZjzDnkBV5HTGEqK+EEgFyw8+StztUWtfviK9i11Mw24g8izh+Ktfys1//XWc/dDHt9zGWqcCFWmLtJrYOvWszECKJTWOG2IopGGF45LM+4pIGx4oqgTjWj++YMtFevmIs8X+tiugW2CgLQrLrC+5GOd4UrA/VPjCPUjPxZpzUc7Gx1tq4XysOV+8IoAPfPocJ45cR1zIxZrSzbvuIWpb69pLKfB9yVUn5vjM3Yvk5lkp/ACgx2Vumz5f94rD1Avlqsqde0PG3VrLWqbZKEBWl4JG3ScWcGK+hpKCNNPsKeRnN56vFIKWL7nzW17qfh87zt4Te/nqH/lqmnta5EnOhbufJH5yEa8ecPItJ1xlwri2pqOvuQ6kIFpaJ1pcozbbpranjQp9Fu+5QNZJaNQUKnSVj7Iq5fofnIRmtBwhlcBr+IXjuSEvyelSuGyocbV5W0giW2OKAHN0XVzVBbdvDXlqSAYZfqicb8mUD7JajBT71knOA//yp6oJsET/sVPuOIwWLt2zPcKZwLm3j6sQFYub4XKE8MQV7az8QsXsV34D8cP3oHvrk8FIUTWcf+u3IWvTHdCnQV11E/mHfgtVC2kfO8Dw4gq1eZcs0VlOst7DpCOeRT6I8Fo16kf2F2pQ8dYSuUC6tkbj2FWb7utxiOYsYgN3SSqFJEcqVR3fVW0kZocqiFZbTG5Q/jYqcWK0QJ7qJWJH21hrqe9tMLg4IJwNnWlpplG+mnoNhBSocPSaqnsTLaVG20oVa/ZVb+DQd3zfjs7rOQlTzt6TsGZyTglmXGvqRt7SYz//X8n7fa7/4R94WsP44M/+l03z9DR8dnXUhtj2JE0l6OaOtxlKSbPwLCur8aUS55Xe4iqUetqqi+IKVm3cDUSeRbz4G/56FYhYa9HWZb/31BSelPQyzXKUk2pNXwp8WQQAheJVbovMlCgM/RBEhWFhTcJeX2IQE4T2QT5JKgP33o1Fv2044BMoeRclllNdPVZ3GhCU23W6KRTkap0b1rsJ6SXNNXPhtpO2lIIbrpnjM3cv4cnyse6uzzNUANqEziDjPR85w43H2tx+7R6Cog9tdm+d7vLoYR1puykIAfCU5PjBJjPlYh8XbJStSGYKU719eI72Qmvib6Ig3s/sb1eyule/6iT2zhOuz7hQDrPaQEEOB/AbNczcDNkwIVpcd2Oq+QSFepWqKfJkJKdbLtatsXgND4xrwShhc/f5eHWvqizo1ODVPFQg6S3FVSA33q41DVmi8QsS+jSI6jppvLFJb9o2QgpE8VPnhsX7l5k52KJ5oOEWQsaSdBPiboIUEmEEc3c+P9s8drE1VGuWA9/zL1j/s99leNcnoOjB9w8dY/ZN30D9xpc8pf0JKYn7KX6a4TXq1PbMuO9XlhMtrW9WujOGrDvk1O99lAv3/x46zlCBYv/NBzny0qsIZzYEv8YQnT1L49ix6c8+IVH7r9p0DDPoYvurJOtjsrpS4IUeGj1VEGIatnMi39H7cd5B4L6LQdOnm2k6pzu0DrbII421oMYy/NY65bssygnn66jaKCnjvIUEat9RZl90G6rZpP2K1xEePPy0xvnlxtxLb+PJX/+dzS+McWRcdWhDabjazvLEf383h77h65m5/tovehzLjz7xlLa31rKuLWsTmgYGmcDBmkfLU9VzOfQ9wpnWVru6IrDLEXl62A1EnkUcuOUGtLV0C6PBuVBy7Z46+5oBxlr6UcYhXyGw+FKQW7i3mzDQruzZLngY2jgpWydP6yRSYwNa2EoGuFzotjxFP88rudsyCBnnmJTtVspYthd9nI4vdgp75EyH61ohWhuWVyMybVw1yN96UVoiGMvelRWdQApyY5/xNq0Smbbce7rD+ZWIN7/yCL4nqbUC/FCRFdKHwy2ImScONWmOTbTjZ+fVPbJBvmkx4G/oKRdSblaDkq4/TmjrMiiilLJ143EL+Jh4pTdBbO1dWK8cjlWgnKeGHgUO1fwnxNbRnaOeoHOnbrP35n1kw4xzn7/ogpMy4GJzELJdoDn1UEJg2P495Wuzx2bxmx69C32Sbkr/Yp/exT5IqM/WyYYpUkr8lk/QmsWfnd3xOHbx/IGamWXhG7+D+a/7FnRnFRHW8Oa+eKO1+otfxeDj72dwbqn6W9IdbF4sjmH2UIsL97rtdaq5cNc5lh68xK1/83YaeyYJ18nKCsFMA9WegzEZXysk/jU3QeCCF2sNQkhs1Ce9+y9JVrqYbLRCVL7CqwcIkYEEHW8fjJQB/FYoW9WNNlOrIdZahN1Q5SieU3mcs/74Oo39rvqUxznKk1jhKjE60QwWBwwuDWkdbNHc30QoQdbP6J7rcvNPfS8Hv/arth3/8wmH3vzXefAn/y1ZtzdRqSvEBQGQgdz2ngK455/8KK/+g9/+osdx9atu59EPfGzb56mxlkKJGW2nm//WlWSoDYF0AjwA4jJj38UuLofdQORZgjGGT/zWH7GSuAqCAJLccvfiECGGzHuC5dTQ15YZT3Co5pMa53txqOZxdSugrgT3dxL6upxYnBKUMBYPyKTAWoMU0q1PLRghaHmS9dwU7VxTJgyg5Um01uwwgfaM4O7THa69dT+DfkauDYPcPeyyYY6d23pytNbSHUyGTBZBou2mSs8zDQusdlPufbzD7dc6BZyrblrgzH3L5IWR4Ua06h6t+vQe6TKTr0K1yVsjHWzgn4zzi4REtOdBCGxnZbQ/3yPvOK8Bay06TjG5oX3iKMHsDAhLtLTO2ul1MOWCgdECo1hAlNWairtRBEnSd74qpqyYWOv6tq9u07/QY+10x2U5iwpeXU3nRD3V0v1EcHQZJP2EwdLQtQp4pRu7q+hEq4VIgrKoTHHVt3/HUxrHLp5/kLU6snbkae+n8dI3MPjL91e/W2MmJHSnQsDckRlWTq8Xb4I8yXn4Tx7gtndOSpxK5WGGA8xwgAhCUNJVcnSO7qziHT6ObLaxeYZeOodeOgfWMry4OrEfa90CH1xQohO9Zbao3Hb1kVXaV7VJuinWWPyGT31PzfGziu9qOpxiSFi0coqNlY7cTiRWhotDVKDwmz5auZbPtJ+h09w9A7Wld65H71xv7NoJ5m770vlqfCmgajVe+is/x6f/9vegkwTK5FBp6rXDx+Lg0VNEZ89RP/rF3ddv+mffx5/9xM8jpyR3TEE63ziXSag6EOpSEiiBNs6rK9IWgeM/Bq2dtzy+ULFbEXl62A1EniX8wY//Oz7687+KxRkIlURzgWvROhs5uV1BocndT6lJuKEdcnImJMo1H18aEhcKRxJX3VBFwJELgWcsmRTUxu5fCdSUgLxInm/IRCsBtcLNXSpVtTB8KZBry4OXBszmpjLz09Zyz6OrvPHo9kS3Bx5dm/i9dMa+nBfHMwEL3P9Eh9tOzrlqkq84/uL97Pm27+X3v+/HnDP4GOaa/rYVACdpu/nvw8UeaWQI6mMSvELgXfsSvOMvQpQZ0iwhP30/+akvYMcyo1YbvFaDmYP7QRalc6loNtuc/KZ5Fr/wm247W2Y9R+PLS+dzY8mNJRWWPXsbeEqSxpkzKJSWtG+wmeXCykWstfSynMi4qp0Burm7x9qeINzQ8zp+TUypMLZNgBJrw+VouEIKskHmFME2FKeEArTA5BahLSYwHH7HOy6zx13swkE12/jX3ED+4N0AU6VzN8LaQq1u4o8wWOzTv9SjsbeJVJKL95xlZl+D7qlzePXQyfMK4fxB5loE2mAfvXv6QQQTgcZgscdwqY9X8/CbPl7N25TkcGNzyYSoE5MNMoYrixOvS1+y76YFGnvqpAMnVrHxOWYyQ9pPyWPHMfMKh+54PaqSB+XmOnWtYqUohbXWKf5NSTgJpdj/VW+gdujAptee75h/6W287s/eyxPv/g3OvfcPSReXnQGwKAjrO8y4rH7y0xx5+xcXiPi1EDw33298DveKSbTsnlBFx4SrekBmnJ2AEgJfOZNlJ5+fU1eSq44e+qLG9EKCkM+AatbTfP/zGbuByLOAqNvj/T/9iy6AKBbL+ViJe8aTnGx6SCkx1vlhLKc584HHyZmQ1STnE0vDCTK5wfE6Mus4Ix4WLcRGgRGshUBKfKGnOrvX5GSbUA3Y2hVjZxjf3+Ueqfdd7PPK+RqZdUHIqUFG2kvZ98gqt1w7X5zH2MRnLIsrEQ+dWp88phDPSkl4jy/ZHypqSpJby0qqWUo0UapZ7yZ01hOMhYVrDnPHN7+NG//iUzz4nj+cUEVRO3Ak3twT7upmwUveCI98pJqc/NvegDp8AoQsrq1F+CHedbch9+wj+cQfj/ahJPVDB12Vww8QYaNybpbNWW5411/j9Ps+hkkysihHZ5p+qoly41rcjKU1V+fItfPMzddZeWSFpQt9tB1lx8rgQQLdTBMVggrjAaG2sJxaQpmzJ1AVh2n8nHVhXjYNJaemk+Q0tI+3jfKcVAKdTVcwsGUEn4MVEBzYnTB38dTQ+oq3ED10t2uH3MFCQQgq89CNWHx0CXNuHTOI2H+gTtYbUptvI33lghwhsNoQLa6TrPWYufog0h9r2So4YEI4GfQSvXPrgGuDypMcr+aU7owefS+sdWpWSS8tAvfNXxiTGS7dvUQ4G4KxeHWPoOkjiypj0k0r3lgeOx8or+5Rnw/pLQ+rdtXyOihPIktGX9H24zXqkGXloKqopXniGm75yX9x2ev7fEX9yCFu/NEf5MYf/UEe+6//nYd/5j8V8ujuWah2kA23TzNpOLdvgeXzl/CEoFCAJyqDECjucbe2aHlOlCYx0Chk2qtqvhAoIANiY1l89HGyYYTfqG9x5F3sYnvsBiLPAu794w9jtN6U+Cn9RLqZa5tqe656MedLWl7AvrrHepLzl0vDbfefWxeUBNJWD5RJWG548fU88tATmGTM+6HcdmxRF3iC+IssK8jJXVVoKMFQ26lUA20hKUr4q6mu/v3hT19gvZdy+00LNIu2pizT3P/oGn9192IVyMmiirRR5fHpQgDXNn3mgpGaizSWmnT+KS1P8YW7llAS9s2GJI+f50Mvfy3e/B73YYwRquNsB5lTY6s2JwF4zQYv/vf/mrk3vJ7sxDVEH3sfoj2Luup6kN7oQluLNTkYjdp7FHXkWuz6KjIIXZXFZAg/RNQnyYP9M5d4/A8+RtZLnHO5NnQzlx0bZIbUws13HOLkzfuIugmPf+JJ+j3XhhJIlyUbn4wcL0fgYRmOfRClWpa2OIUzm7M39Ebk8jIowRFUy966CZ8c4LFuwiAz+N2EQ/P1LdV3nGTXdhfabWex4O3K9u7iqSE8cg02aCKSgfMKCX10sr30btxJUJ5Ab3iu3veXp4m05XVfcxyAYKbhPHamPERNphmcW2bmmknZ2rTTL0rdgniti80NWX/SeHBaNURnLnAw2kwNQiaO0U8JGj55lJNHOaUp6TTkUc5aLyHbcExrIc8MSopqkT3INLMvuZ1rvu4NnP3N9xIvLlE7sJ+j3/w3OPJNb3VByhWAk9/7nex97Z088JP/ju4996GznUk5z77k1qd13Ov/2mvp/O/fQ2pNP3PP2XKmKkMcbVyAobRBC0GtSBaJDckka52psgb6w5jH3/8XXPe2r3la43s+Y7c16+lhNxB5FvD4Jz8/USXY4yvmfIVXRCaZsaymmieiDAksBIoZJWj7kg9e7E/d50aUi72NZonuV8Erv/tv8/Y3vYb/++avrF6rtMALlIu7QE5XftoOWwUh4LxRjtY8FhNNNEWdZSnRtH3FajKZ4fnCgyvc9dAKC+0QpQTrnZgNm+xY7eup4nDNY9YftURlxvJgLyM2liOhcqVorbnz2ByNoHw4g11b4fiBBo8vDjHGPUzWhppDe7Y+lrWW9X6Kp3yue9c3077lBg5+3Vehaq71yj92A+pb/gn58rnJIKQ8qPRchSQZEN78MmpjmVo97GLPPlJEagZrNFZ5PPZbHySPMvI4BwGBL9lXnMdsblizlqWLfc4+uooZpnhCEEpBIEXFwynvHSkEnhQUb2eYOxnnxFiSokWrxHoOINhXm3zU9DNNJzNOYCFQNDxXHexmhpVEkxlL05Ok2qKbAaKXFLHe6AaIE00t2IHkoQAMBHu2+VB2sYstsPDN383Sr/wsyvcI2k2nmjUF1lqilYhmO6QxE2AtdJcGJIMcay1xbgjqHqceXkUIwYET+zh6MkBMzyaRRwk6TpGhS8wk6wPi1S46ych6UdUSWvrybIVxbw6T7yBJou1k0kCJqYmAEp6nthyDNhYhDAZBlBsWH3iY1//GL3L1u65sQ9HZW2/mzt/8ler3z33PD7DyFx+buq1QivaLb2Hmxuuf1jFf/X3fzhd+/X0YKWlLlxCdBgt0cuvaayeST5ZYmyrvFkqJxBksD5dWpu7rSoGQ4ukHIjvopHihYjcQeRbQXVyu1o6Hah4tNakK5QnYHypCJbgQ5yylmiWgGeZPSQEqs1RSvlWmAvBqNV78rW8jbM/wN/79j/HeH/oJbKEDLgVk1pIbkLgnSl1JrH1qJoFCgLCO/2JgpOalnezGpThnX6h4coqCy/k4Z85XTMsDWQurhYP3U4yNvmgI3Ocx/hk9NkiJjaWuBINigX3nNbPUg8nthBDMNn1edHyW/MgJxFXXoMKAPTM+a3/4B5uOVZI95xYWeMWv/wqtk9dMH5TOK9WczTsxiKiDKLw/Js4lz1z2Pyscn5ttBmeXGZ5fJhtklSKOEIJhZrjQT4m0JZAgeyl5sdD3hGAoBLOeRAhoOIEuR2rHtWMBpNqwmGhUcV9p6yph5a1kBTwZ5wjhAm5jLGeGI1U3gaUzyCqVlsokzZPUJFx10wHO3n8JgEbognljLVGqqYUete28EKrr5X7Uj+y2Zu3iqaNx8iaozWCzAdL3qO+dc9WIMc6INZbh8pBhUc0uRSFm9zfpLg24tJaQ4yoITxZtpk88usbdDZ/XvPlm5vdPlz/NhjEiyeicukj3cfc9CGZqlSEgQNgOiQr/h1Ia3VrwPFktbnSqC/ncHT7kLVXP7eWEJqy1+IEijae3pOXakhqDBaK1zs6Of4Xh1p/9ST7zt7+L/iOPTXJGpCTYu8Ct/+Zfb/nevNfn3O++l4vv+0PywYDG1cc4/E1/g31f+UakN7pPjr7sxbz1P/4rfv8H/iVxri/rK9LNDTOeU/TqFS2BnhypdLp1hKWuYOaqpy8OsYsrF7uByLOAfcePAdBSkpkpffBlxt0YO8E7fKK/2bX7crhUlAz2BpJmEfB87X/+ScLC5fSNP/CdsLrGZ/7D/8NSlDEYm4gUru/fl4KGJ8m1cT3/OziusJDjApCw4J0YQAnnBq9hahACrrXskY0KUWP4UgUgAHNHD2LWO3hyTPElNxWBL5CCxFhqvmT/Ng7GCvAuPsGr/+cv4M80sL1l0m/+a/QeepQLf/IhVj53HyBonjjB1d/+Tva+7lWombkt96eTaKKHGgBrEcM1xGAFGvPV34AiMhTYLIU0BuUj6k2QknR1nave+CIe/p3PFJsKloYZl4Zu4eALS5Rb+npUzZDAnO8mobYvofCrKTuhtHFKKxpoF8GAIOfJOJ9oyUtwrV1PDjPqUnAxMROdVLmxaCaDEFUQJZUSnH/gEp5wr6WpJmHUCRfFObQmDd+mweIM1g6/7esvu+0udjENe7/pO7j4Sz+LP9NAhT71/fOYNCfpDlk/tUzWz7DGSWN7Nc9VEYxTqJrd3+LhxZH30Pg6M4kyPvJ79/LX33k79dbm58vSF06RrE+26qbdGEQNVVQD6wt1hitDht2E/nqCLqoeQkCjHdKcDUkGKXm8tZrWJjzV5OwWwUpZjCnVG/0dKiwZrfnMf/hvLN/7ILMnruGO7/t26gvzT3FQzx/47Rle8eu/yrn3vJezv/W7xBcu4c/PceQb38rRv/UOgvm5qe/r3HMvn/+734Mda+9KF5dY//Rn2fPqO7n1P/wbZDB6Rt75Pd+GN9Pif73rH+9oXMNCHcuX0nmZjbVmaQRCumToNX/ttV/0ub8QsEtWf3rYDUSeBdz6lq/kT//vX2B2irOssZYLcU53Som8/zQkoJZTwyqGW1//cm755rcCcPau+/nAj/0b1j/8l5zppxhGk6DBBQuptnhF5t9TkhnlxpgYyxYcYCjeO+fJokWspFFDoCRZbi4730VfQtng7XDsjhfxjT/+D/mjr/rm6m+dsc9mmBu0hYOzk3K8ubHk2uArWZHTrdZkTz6C13Zfq6DhsXD7jSzcfiMGD2b2QFYsSAZL6OEyojmPnNm72XfD6E2Tu+gvI3tLWCEhjRDYCXNJg4Coh1o4VDky636X9oJCJguUn2Yv1VUQgrV0ckMy9oEJoKEkFoEU0CqCaVcJcZ/3sFA9KzkhQ214Isqrz11AxV8y1pIgOBdlSDnmB2NdEEJRTSsRSoHCoqoYa6w/2TpelC6CkWGqq1a5rWCtpXb4MPOvuGPb7Xaxi63QuOklBEeOkTz5OCr0QUh0mrPy0BI6covAsB2ixjhmVlqkJ/FqHieumeXU45urAY5LoTl130VueeXVG16zZFskbLJeQmctJl51alX99Zh4Q+LHWhh0EoadxCWLdiihvdHX6XIeQM4Nffv0kfMukRx/29dd9vgf+Ec/zr2/+psTf/vMv/2vXPM1b+Atv/5fnraD9XMVqlHn2LveybF3vXNH2w8vXuRz3/5dW6purX78k5z+r/+Nkz8wcqZf+avPcfpf/Gtun6/z8ZVo6vvGkRlD3ZObFA6FcM9oKQTWwKWHTnHolqfXOvZ8hpAKIZ/effl03/98xpUbgj2LuOYVtzF75CDBlIf/uSibGoTA068EGOCuv/g0f/JT/5lP/Opv89N3fD2dD3+cC1FWBSFmynFy6ySE+5kh1W7hXfMVM77k9rf+9anHmvMEubXkFTnZqS4NdhCEPJew+sR53vt//QLnrKrMCbOxSTUrrln5rO9EGX/1+Dp/cO8Sf/zACn903xJfONcjzjQH3ngn9fbm2N4CBAFkG0QIrMX2VzFrFya4DxvlgDEasXgKsXoOm6UI5SGsGQUhaUx2+n70I59D1ergOfng4cP3kz/5CGl3yN2/9CHATSCLw4zEGPq5pqcNDAGEHwABAABJREFUSUGcL8fQVLISNtgTeBgsFqd6Y4proo0h1oaBtgxzQ26c4+6s5zJnXlU9GbVyreW2Clqr6zIl9eoJKj7VJoL6WNUEYK2bVI7u02CtJRlk3Pmbv/yUvUx2sYsSQkoOf/+Pu2pgmpF2B3ROLVZBiN/wkWMcs/Knk+QVHLmqjdzSJwmefGR5w98saT/GZNMzNtZYek92SDoJ0XqyKQgZhylaeO0WC9bJEwUv2Cy7vdV7rXWV/XwLQ6qS15W7kic3/d2/te3h//z7//mmIKTE43/yYX7vG//e5c/hCsE93/cDl5X+Pfubv42OXJvu8sc/xcff/p0E0bCyE7gcEmNZSTSXEs1SktPPTdWWW/pPeULwqf8+/TPbxS52gt1A5FmAEIK/957/WixgRw+KSDsDw2cb7/vn/5b/9+/+CDXhFmy90kH7Mu/TQGRcObabaGI/4PO///6p264VrTxD7Vp0YuMWqM+nIATg/L0Pcdfv/xkXukPu66bc3Ym5NIW5v9hPWe6nfPjRNS50R6Zm2sLjKxEfemSNY9/0NdPPXwWFcccWC5G4h02G6CQi7SyTdpZcRcSJ7yMWT0HUdRt7AcILRiXyJCJ54NOYtUXUvqNV9nL40L1IoRECzn/iEdIoxQK9THMpdsTyvCAfRsYSFzwYbS1REWBoYxhqw3KsGeS2up/j3Mn25hZSYx3HKdWsZy6okYgi2B0pZIEgt1RKXeW1m7bA8YoJbjsflpHRIyyuR6SpngzmrMVoQ9RLsRYaRw9P3dcudrFTqEaThbd9GwAyUMgxfpJX97b3DVKSw4eaU18HqoV8eQ/nccbg/Nq24ylbObKdENCtM6Er9y+nEOSlJwga/ibSbGl+uvG7Wv4eb9FSbO1IBS8xBt8azv3Rn285xjxNue/d79n2PJ780F/SPXNu222uBGT9PsPTT1x2OxNFDB57DGstd///fhKrHdejriT+DmKRMhEH7nndzw0rqa6CEWstUsBwZft79QUPqZ6Z/65Q7AYizxKOv/J2bv/ub5tor9lKpeKZhsD5b6iCiwJfnNxtOny6DiPPfZhCm71UfEm2+IiGmeGTT3QwG66jwGXw5w7vo3Fo36SnipAYv47x61ipqurARlgEeX8N3VvBZjHoDJGngIWo66RDy+MFtYkFQXb2Ecgz5MwcomhZSM6eQnfXUUVv8KXPP8G5TsJKlPHAaoQt2quMdb3bQaGO5VceMxZfgJKSldTQG1vApMZJ9xpribUlNZamkswoSU0KFmYCDs7VaIUKTzgp56YnaXqShnLnn5b3ZHn+GxY4O0nWWTviVykLw0FG1EvJopwszokHKfHAZauFUltLvO1iF08Be77yLbRe8QaEEIRzdYTvpG13QuieaU8XnxAC2vN1dJqh45S1Ry/ROb24vRKWcZ4i4KqT26EcWlnNLD0+vMD9F7R8arMh4Uy4ScErzw1xnBMNM/JcY4wz4TPGkGeaYTfBjs1r49UTW5j3psbiC2eId/9//u/odLo7/Sf/9c9tex4l/uqnf2FH272QMXj0sZ1vLASdu+6j/8gpV4UvREX2h1/cwlfb0VpGFPLzx15+2xe1rxcMpHxm/rtCscsReRbx2v/j+zn9e39CvLqOyXMG+ZeOGFGqWmwh/76LpwgBZBuqWQ0lqt7rdmOSNG28EBs0RoTzMeK5tXqC22H90QJlYhmQZ4jB2kjARgiQo0WPzVLMetHSEdRI19eIHn4AjCU8ejU28EnXuxx87UnaLzvGXR87RdZZqVrNSuI5uIzEjCcJ5Ih5Ior/akqgpJNwjI0LPpLCyLAeKq66qs2+2RCbjLK6D57tcnY1JrcWa6xb/AC+cAuTQI4CCTt2rDlfVgaI234ewnmDhKGHlznPHmud98zEdkqx/42v2W3L2sUzhoPf9r0kf+2tPPHT/4z2kZTe2d6O3pdv8fy3Fo5eNUO01HEtWYME5Uks07kZ1lqi1cgZdlK2gu0szZQZS+iNWsgMlm4vJax51OseylMY44KP4TDHjAVD/pCq3bgMNsbFLYbayXG7JIHFFpXR8XNIV9dZ/cJ97HvF7ZvGtnzvQzs6h7VHH9/Rdi9k+O027ORjl5LmyRNc+vOPVP5PadGm13kaidHYWEyRDEIIXvn3rmw55l08PewuU59F1Bf28PY//jXaVx9hLdMThOAvBYbaZb0bW+jU72LnEExm7mc8OUEAXTu7RNIvJDSl74IQGKUjC1Ur9281mj+kx0T4YTRkifsphKuOVIMQEz3BNhlJdnbvv5+1j/4F9ePXMvuKVyGUoveFzxJfuMDCVXNc85KraOxrFwsHtw8lIBCCUAjaniQQrjojcVUeVfznCSrndQDpK44davKSG/bw4hv2EEpBdz2p+sUfvdDn3GpcENYdEV1bSO0oI6spzCmrRYpl1nf8kpIEf7me9kbDL4IQgZRyatHDas113/N3tt3PLnbxVBEePMJ1//ZXEX5IuCe87L0qhOD8+ekeUYevarPvYLPaLmj4ROvxxIK/hLUWkxn6FwfV3/zL+BeMV8Nt+YcCg0iTa8tgkLG8HLG4OGB5OaLfzyaCkLoSE5zHylMI9/TKCx5IWTHN7dacR7NFRaS1Q3nt9q5ULM0Tx1GNyyuQLbzuNahaDa/VJC2SSACr2dNvEy/ng5Nf9RV4weXVC1/IEEo9I/9dqditiDyLiLo9PvKrv8PdZxYZbnTmexYx/ng5F+XsDxSn8uka77t46ijbmMah04zP/fYHeOW7vhYbtjZL75Yo/2ZdOsvK4iuYDGHpCeitjLab2Qe1+rikP+gMK4qqSPHgGl5YIl3tMP+a1+HNzZN31ujf83mkr/DqTbxGDaEUUeQWAAJRVcr2zIUc2NtACMHaSkTWT5FCYIzr7dbAoGjB2hMoWu2Q6w426Qwy7j/TZbWfVnK9qnBg18YSKoHvK3JtSDODKiohBjeBKeFc6zWj9rbxa6rtiLBeolRzc4bsFi+CQ6+4nWv+5lt48Gf/M+naenFtLUIprDHc9tM/xr7XvnLHn+0udrFTCM/j5I//NI/+qx8h6wy3VJey1pLHOW0hsE2fYdEyWG/4XHPtPMdOzG16XzbMGZghYTusyOPWWuJOQu9sb8KY0FNO3W5aJ1cZc5QvieJvtuCD5TtwiPUFm1STKH4vWySlEAhclnxbfpdSzN543dTX7vzR7+O+LYjq43jdT/2zy25zJeCqb3snj//SL2/p8is8j1t+9v8GYOVzd0/4hC0lz8B6QAhqc23e8T//w9Pf1/MdzwTH44t8fxRFpGnK7Ozs0zv+lxG7gcizhKjT5d+89h1cfOCRy0obPpvo5Ibu80zJ6rkIZ9roEMqR07AppGxTY3jvf/wNjrz0Ro7c+fLtdzbergUQ9+GJe6h6LcptuovYYYBsjMzObJogPOfaLGpNrPJJVjv4c/MEe/dioz7RE48Szs+gAr/al0kzBp2oWDRAGCpe9dJD7Jmv0V2POf3wGnqQIYtAQjMpyJIBXqiYnQv5wiNr9CI3kYVCkFi3vTZQDyX1QLLWz0h07kquorxmhekhIJsN9r/oBqw2XLr3QVomQxtDpC05LjCZUbIKRmJtiYoJV0gBUhElmmajxbF3fAPHvuktPPmeP+DC+z+EiVPmbnsRx9/1DlrHr36qH/UudrFjNK69gRv//S9x4b2/wdIfOAPTSr63bF/KDEsPrVADTt5xEK/lIxAEG0xUy/emQxeo5LEmj4cVb8Nog47zTe7oQggaNY9BnJf6FsXf3c/xrUs1PK13bmDrbyP9Ox6MZMaJlngS6tJuarEUSnHsbV9Dbe+eqftqHTrA4Ve/jPMf/8yWYzn86pfR3L9vZwN/gePQ297Kpfd/gN4DDyOUIGgESE86Do/0eflv/L+oIMDkOQ/9/H+jMROglEBrixhMr0o9Fey9/gTf+Yf/g/r883cB/HyGMYZ3v/vd/NiP/Ri/9mu/xhve8AYATp8+zc/8zM9wxx138LGPfYyf+Imf4Oqrn9vz4G4g8izhj/6vn+PiA49+WYOQErtByDMD7XqGGOaGQLkM4PpYn23aj/n57/jX/PQDv7fznQoJ5x+eDELGkadYY5xCjrVuER4PIGwgpELLOgDhocPYaIDVGqlThO++2kYb+udWuOuDD7J6dg0pQErBV9x5hGbDp99NuOezF0m0y446AnuR4RRO9MDgkm6n1xNYTyYScKmxzM/4hEqCsUSZZq2fVRlUay3CgjGukpTlbgG0st5j5WNuwXHVHbeyfNe95OPtHkLQzTVNJWgpWQUhUAgLGFdhfPzPP8If//0f4a3/6xf4/7N33nFSFHkb/1Z1T9q8C0tYcgYBlQwqRsyKmBPmeGY9w+npqWc8w5lePXNOmLMiIkERFSWI5Jx32Rwndtf7R8/MzuzM7M7CLhLm4TMfdjpUV/d0V9cvPU/PC86k5wWN04PuCShfvJzFT7/M+i+mYHi8ZPfrRb+Lzqb32SdFKS2n0DKwt2tPt8uupdO5l7L46kvxFW5BmQq/N0DN1jqqi+us58jhYOHiEkaP7ZIwcgLgLosmCQkbHqZCJkjDkkKQ4dSpjtDyiXxOQ21XG4o6w3JM6VImlZudTM0WWOlYYKVx1irI0CKojKUkvWsnht17a6NtnPzVG7x/xJkU/jo/Zl3H0cM49Zu3kurL7o6KufOZe8nVGB4PjkxHUHPGj0Jhc9lw5GpU/f4raV06s+ye+8ht64jKAD64jYsFG6tYGpHi11wMvfRscrt1boGz2Q0gZQtERJpXKVFSUsIhhxzCxo0bw8tM02T8+PE88cQTHHroofTo0YMzzjiD2bNnb1/fWhmpt1IrwO/18sML74QZmVLYPRAyFdymipoYR6K2opqiVRto16NTQqVUBVT+sYRV//cyOYN60/OY4Y0eV9VUQH4XhM8SL0MZCE8NSmoIm6XGLJ0OMA2Upw4ZFCAsW7qJwrmrMX0BHJ5AOA2jS0EGTl1SsqGKtavLqfAaRN2pCjRhMWeZxE5CrMJyhd2h0TnLxZZSNz5lhMUNZfBaiZBnOLifYZr44ly2DXMXhg8cKlq3SYsIoNYAiZnQI6sMk5WffUvZslXk9evV6HXcE7Dpu5lMP+dKq8YmWBxdsWQFv9x4JxsnT+Pg155E2mxNtJLCtkB3udj7xTeilnmKS3FvLsSek828977g+389wuw5mxkzogClCGuLhOoxfDW+mLoQzSYxQjodoQckznMkhCDDZUVGLNulPiErxFanqDcYlGFaDoQWgKnq2w19N+wOdL8PZ34bep9/Ov0vPQd7TuPecyklp383icq1G/jhjoeoXr+ZrK6dOOjRO8hIRUIACNTWMu/y6zA8HmxOjbriuiiGNX+Nn7rSOgIP/5eqRUso/mZyDCVzlduPx28mTOlLBl/c/QTpbXIZedYJ23M6uwX+CmX1du3axSybPHkyK1euZOzYsQAceuihTJgwgTlz5jBiRBOZGn8hUoZIK6By81a81c3wNAiBzWGnz0GjsKenMf+jb1qvcykAkFXQnqrNRa3S9vTnP+S0B6+Nu04phenxsvT+JzBq6zC7tk2uUanhT89nyeSZ4K6l75i9cGWlo2cGi1yDERWjthqlFGVLN7HllxXh3Zevt3RIOue56JHtZNW8Imo9AYrcRrgGxSGtXHMjWNya6CUlgkXtZkCxqdgSaZRC4FOKkASLDBWdmxbPvBSCuiTeeCEWLa+pMExFui4RovEBWmiSlV98x8gIQ6R6y1bmvfY+G3+ei9A0eh8+lr3PmoAjK7PJPuyq8FfXMvPC6yxa18jJbPDvTVNmsPSFt9jrivP/mg7ugXDmt8GZ3waANdN+ojpgsHRVBSWlbgb3a0N+fjpKKYoKa1i7uoLaOj+HHt4du5AoQ6HZJLpLxwyY1BbXUbG5GqFLTH88F4H1HGc4dcpq/UGRWVBBd0JDY96KdKq46yIRMBWaSLyNEILahsKLUpC1z0DGf/H6NimhZ3fvwnFvPNXs/fYEbPn8awLV1SDAXe6LzwpgQnVhDcanX8T8bhvLPfywsgxUgmwJAULIWGHdBqgtLefls6+lrrySg688d5vPJ4VoVFVVRX13OBw4HI6k9p09ezY9e/bEFnQ2aZpGz549mTZtWsoQ2dNgT4vPF58IQgqunvw6fQ8cxeYlK1OGyA5AaxkhALPe/JJeowcz/MTDMA0j/CI2TRMMg6UPWEYIWEXuyWDS3x9n4ffzwttrNp38Hh0QQnDKOSMJ1NTgaNsGlIkKmBT9vtqqzch0YM+w41teRr+OGXRuk0Z5aR1+n0GFzzJC0jRBWgPPqAKqGxFKE4BhWhSdIUYxDUFQXLreqxt8BwZMk+aStASAZGKKQkr87vp0liUff8OH512PMgzrZSoEK76exrS7H+Psz1+l0/C9m9eRXQRrPvicgNuTWG1ZKZa+8AYD/nZeis74L0BdZVWYaEHV+vljbqEldgik65IMTZDl0ClaWUGPwe3QIrjXNZuG5tLx1QWw24IMcaq+HgXqn7miWj+1ESmjlpMhetsQfKaKqnmLhuWi8CtLkyreNiHV9PKI42kCpAl1RSXbZISk0DjK58y10niUGd8IESB0ibTF6tt4AyazVpY1Ksg+YNxYCgb34/vHX2pUyyaED/5+LyPOOoH0PblWRLRAsbqw9u/SpUvU4jvvvJO77rorqSaKiorIysqKWpadnc2mTTu3CGiKvrcVkNU+n+4j90k61KZMxYZ5izACAV449YqW6YQQODLStztcmELzoUyT1698gNeuvJ9185fhrXVTW1bFlhm/MP/6f1ERTkWCiiVrMf2NM5h43X4WTZsfZbQY/gCFyzeyZflGPnljNoEay7ARNgdVG0pQyiSrcxZp+elkdW9HflvLCDFNRW0w/aPWUKRpggxdQwZZrTyGRdPrb8IbBtZ8VxfWJMcqaK1fF1I/r58kNecK1jNp+QyzSWpU0x+gTX8rGlK0cCkfnnMtZiBQ79ELVvB6q2t467jzcZdVNK8zuwhK5i9ENJFqU7thM76Kyh3UoxQiUef1W4XlugxG/iwjpK1DI00TSCHI65hB7yEdYpTPlamo3lCN3W4VuAtdIjSLWAIsg6DWb7K52ofbb4ZpdYFgWhbh7aLaxYo+qvC3+jUhZXRDWduE9o+k1vaZis3BupTQJxBM08roUtAyFy6FuAin6zWACBqw8Wp71pTUNe4QEoLyjVs48YGbGXzcYUn1I+Dz89u7nyW17W6LFlRW37BhA5WVleHPrbc2XlcVCZvNFo6GhGCapuUE3YmRioi0Eo7917U8fdyFSW8//alXUaZiy6LlLdMBpTj46nOZ/MD/Wqa9FJoFpRS/fTSV3z6aGl52yvDO6Cr65WF4fGyeMY9Ohw1P6KX+7tUp+L0JWE6UYsOyzWzNG0ym4cfvU1SvL8KRaadmSzW+aj+B3zeTL8BUgoDfQEqBw6nTXhNkmlDuM6gIRL+dQuxajUGIeipjpSzPalgwCyBIwSsBt2FSZyZXM5WhRWu0GKqe7SdeJ5w52fQ+/ggAfvm/V+s5ShteKsPEU1XNgjc/YvQ1yT+buwo0mw3iJuxEI1Uj8tfA1SYPuxBRoqF5dg1dCMJ2R8CkcmstWfn1GhGmaVJbVIc904Y904bfHcDwGmDC2jIPphkdqQgXiGOlXiksx7nXtJ6j0LNk6fxYdN71NR7BgnnDDD931vZWH9N0S+vHMBUVfkvgtCFCyt0ZPbq24NVLIYTc4UMo+mpy4miIiK47ikRpTRMReKUoXLISZZpc/vHz/PjCO7x9+T8b3UXTdcrW7dwe910JWVlZMVGNZNGxY0d+/PHHqGWVlZV06rRza+/sNu7yzZs3/9VdiMLgYw/l7OcfCE4OmoBSFK9az/dPvNxix9//4jMYfc7JONITix45g/UFKewYJDIm1n81m8JZfwCEU4lCE8pqmces93+Mu18IUtcoWrWZzT8tYc3bn+Mpr6G2qBZftR9njpO83nm40u3WxEMTdOiYgWbTyJeSkggjJDSB8CuFLwlBQbA0BmzCMjhCdKB2KXBJy/MbWpeuRUy2GkFWAyMEgvojcXRZhKYhNY2jX3wY3WEJai37cqpVI0GCKblSLP/q+6Y7sguiYNxBqMb0gqQkf+RQbBmp5/6vQFZeFum6xVTllIIsXaALK1UrFD2sKXOz9vdCNizcGqbyrd5cg2mYSF2iOfVgcQcEDDPIBJ74wRIN/s7s0RXd5Qrr9ojgFiKoFaKC2iIhr7nAIqwwscRIPYZJXcCkJmDGGCGhff3K2vb3l97luxvvoXpTYctdxBToOP4Y9MzMuAOckPW00cpQmA0iylIm4aoQAqnrSCnZd8IRTfbHNA3S2+Q24wx2P4SK1bf3s704+OCDWbNmTfg39/v9rF27lkMOOWS7225N7PSGyGeffUa/fv3Iysri5JNPpqysDLAGvb59+4YH8IkTJ/7FPY3F2EvO5MFNP9N95D7xxe0aoKW8Cm17duWsZ+/jmfEX4/d4E2535C1/46J3niQjPz6vewrJQRNgl8EUJVH/UImID8CmSo81oW4IpVjz4XR+v+9VaspNZIdeaN0GYRt5PP6c7oA1cemepjM0x8GIXCd7Zzno4NAQQK+CdNJnfkrlbz9bk5caHxkdM8kfmE929xwcWQ5LBMW0uP3Lq324q3z4DJMqv0lAKbymiVdZeiiBYCjXULGpHJGQWF5Uj2npfITO1aLfDV6DECWvlOTaGs+hDU+O4gineU3wGya29HrF+h5HHMTpU96hxxEH1V9Kn590TdLGrtHWodPWrpER9OKGEPAmfiYSwQgE8FRV79Qh7k6HH0hWr+6JFXpNk4HXXLxjO5UCYD1HlYuWk6EJcuw6Lk2gS4nbhBrDKgi3S3AKcGoCd2EtK75fS8mK0nAbml3HmZ1pRUOAOk/TEcbQs+QQkO6w4Vu/EVu7NlSaAq+hsP5ZUUfLCUHcKEcI7qDToqEGiQrua0YvZP4Lb/Ha/hMoX7UuqeuUQtPQ09PZ93+Poae7mtzWHxTPDI3jHbOdjdL5S02j/2H7oQVpvrPa59P34NGNp3yaiuGnH5d0/3dLtGBqVnPQ8H00ZswYCgoK+OGHHwCYOXMm3bt3Z+TIkS1ymq2FndoQWb16NV9++SUfffQRr776KtOnT+eWWyxV1a+//pprrrmGOXPmMGfOHN5///2/uLfxkZnfhiP/8bdGk+SlptH/8AOSak9ojVvOUtfoMWpflk75geKVaxulEP78rsfYumIt+554ZJO55c2B0PecAsVI40MGUyxsMpTyUP/RBKzYatVxxJvcK6WoKSpHG3wAeu/hmO17U7yhGFtmOp27FTAwy05bu4YWnFjYJXR26ezXK5d9e+XiqXBTsbGamq212NPtCCnw1QXw1/kJeAKo4ATCME3qavzkpOkEpMSrTHymiWEGa0OUNSnxmIqtPiM8KQl72YKREjNiW4g+VyEiza96ZOgaeTYtoUcuU4stroyEITUGXnQWl636iau3zGPCe8/Scfg+4fU1mwrJwsAVzLcn2BenFOTYNHRhRVE6jxyS8BgNUbx0JR9d+HfuyxvMg+2H8FDBML697T/UlZYn3caOgtQ0Dnv/RdI7B3Pzg+OE0DQQgmH33EKXo3Zuz9juipJlq/CvXY9N1heWewwrslAbMEnXRax6uQkZHXPJH9yZDsO60X7frtSVVNevTrLwSmBFJVXwXeBbvwnNNKk1FJV+Fe5DraHwNYxyEDFeKYWUAo+hYl5ngQRdUYaJp7ySry//R1J9TSE55A4bwgFTPiVv9LCo5apBmp5pKLzVvrAWTZdcJ2n2xOOsaRgccdNlUcvG33tjVL1fFITgoCvOIa/rzp36szuiuLiYBx98EIA333yTpUuXIqXk008/5cUXX+Tpp5/mlVde4eOPP97pyUmESib/4i/C66+/zhlnnIHdbqVd3HXXXbz//vssWrSIY445huOPP55jjz2Wrl2bl4taVVVFdnY2lZWV25yL1xwYgQB3DzycktXrw2kjURCC679/my/ufJyVs+agGhFBzO/dneKVaxs93g3T32Xx5Jl8+/DzmI2lamCFFB0ZLjxV2y5stKfCLomZPJhBFpmGUEFvYeccJ2N65FipEBHqy35TMXNFGcf97z9sWriMH55/G09lNQI4ID8dTcXR0hDQtlMmVVtqwgw66W3SSM9xIqTAMEwqK73Uuf3kZdoRJvjdVhH3xhofqyu9Md4xPXgOdWZ9nYhdQqaUqCBFb2gfDYvy1y5lo/SeDWEqRbE3EKPF0tbeeMmakIL+Jx7NSW88EXf912dewbrJ0+PSToaKbssDJlf+MYU2vbs32c8Nv8zjtaPPwfD5w5M4sCb22V06cvH0D8honyT98g6E4fWx7rPJbPh6KoG6OnIH9KXPuaeR2YI5++6SMop/XwBC0G74Pjjz9uzUjKYw/7k3mH3LfYDFIOeJuEU7OTWcWvREz5njZMAJg9FsGtLpwNkmG81hRxkGFauKWP3lAmrqfGwu9TQ8VBSUUtgF6BGOphDTVV1E1XKimjCJZcQEdwyHOkMpWKH2klFpv2DOV7Qd0LvpDVNoFoomf8+yh5+kevnqer4BCVKXUQKYIvgj5552Kh++9AkVmwrDorNS01DK5PQn745Lxbto8gxeO/9GqgqLEZpEGSZS1znk6vM46aFbwxGU1sCOnq81B6G+bf3iebIaSYNPqq3aOtodd+lOeZ6tjZ26WP3cc6MfiPbt29O1a1eqq6vxer3cfvvtXHXVVVxxxRU8+eSTCSdCXq8Xb0Q6RkOe5taGputc++0bPD5uIsUr14YfehAIKZj4/AP0HD2Ew2+6lBUzf2m0reKVa+m8z15sWrgkLrXe/hedTp8DR7H42x+S6psyTby1bmwuB35381NW9lRYUY7Y+81Q1uQ8TZPoQmAqhds0qQtaJxsrPHz+51Z6tU2jbbodhaKoysea0jp8huKNi27BMAJhAY+2Dg2d2PoIAIdTp2pzTXhikdM+nbQsh8XrX+tj/foqlFJ0aONCKEXAbQCKlRUeNtXGFi0qBd7g2UXS8BpKUGsqNFHfjxArj19ZKVNg1YY446RWNYQUAqcmUUTnmcenEI245lLDmR1fB6RmUyFrv5mWMPIohJWPf+D1FydlhJimyQfnXofh9cUYNsowqNq4hcm33M/Jr/63ybZ2NDSHnZ6nHk/PU49v8bZ9VTX8fOu9rHz/i3A9irTp9D59AqPvvzVVf5IAxb/9EY4mRhohAmKMEICA288fb/5OnxOG0u2QfuFnQyFoPyKHzB7tmX3fp2Hx0PiwaHf1BsVZQghrTInaMj5CWiNSiKgxSBP16VnJejKLFy5NGSKtgLLf5lO9bHX0QhNMn4nSFJpdQ2gayjDodOJ4Bt55M/vcci1z3v2cBZ9Owe/20GXIXoy99Czye3WLe4yBRx7EAxtms+ibGWxdvgZnVgb7nHA4mUGNnD0dQtMSp8Q2o409FTu1IdIQc+fO5bLLLiMzM5OpU6fi9/t59tlnuf766+nduzfXXntt3P0eeOAB7r777h3c22i06daZuxZPYcFn34Uf/oKBfUHAl/c8xesX3oyQkrS8bOrKKhO2IzQrgnHMHdcw/anXqA1SkeZ06sC4v1/ModdeiBCCvgeN4pv7n06qb8owLSNEiObzrO6hSNMEuTYNl2ZRcXpMq94izSZJ06TlZRKWOng7TQ/XU5T6DEp8ARZvqalP3woaLBJQfr/1f/CTqcv6iUADqCB9o6FAt2ukZztRpqK2ysu6TVVIIejcPh27Q8NfZ00aK+sCCY0QSzUgUo/ZMhokoMl6A0QXIiq9KjQRChWVp2sSXdZvY01m6tu1DCeFLgUuYe0Xogh1yMSRFTMQYOBp8SfX5ctWJnXvtu2ZXFRg9dQfqVyfuGbLDBgs+vArjnrkdtLb7hk1VobXxzcnX0jJ/D+joramP8CKtz+icsVqjvnstRQrVxyYPh9CiJjUJ1uDSGLomTO9Bp3260u3QwZay3Ub2GzIoLhnWgcH/SceTM0bM6moTuRAqncoJIOw9E9s4DW2ZSFwSIW3GSVTmtOe/MYpJIXy3+ez+tlX467zm4ottT6KfSYBZYn4pnfogt/twZ6exv4Xnsb+F56W9LE0XWfvJCl9U0ihOdhlDJEtW7YQCASYMGFCeJnNZuPqq6+mqKiIt99+O6Ehcuutt3LDDTeEv1dVVcWIxuwIaDYbQ08+mqEnH03A5+P/jr2QZVNn1U/QTLNRIwQso2Hzn8u56ccPOfq2KyletR6pSfJ7dYsSj+o/7gDa9+tJ8ap18dPBGkDqGjmdOlCxsbDRupJGsRsZMjYBTk1adQVCEDAV3uAnxybp4LAendAkQheSDE3iMRQG1mQiyyajUrdsAvLtEolGmd/AVPVGiKJ+AqBURNE3CSYCEE7HMoHMLAd+tx9PpZfyWj8ZTp28TDs2u2Z5Yg2rrmNTjTVpkViF4aYCf/A3CxkhGlaaRrjQPHiH6ggr17yBiJoWcQ42KbAHDbHw/kqhSesahowShxR4TGtflxZsM5QCEuc+Epqk29hRdB0bv+hOcyYnIqo7k1OoLVq4LOxFTAQzEKB0xdo9xhBZ9eEXFP/+R9x1yjQp+mUus265j+7HH06nsaOQrZiusashu2dXhCYJNBAJjfwW+awLKeh++CAr599uR9js4TROw+PBqK6mTZd0Drn6INb+uoZFP6zG562/V63nO76WBFIQiJM/agb3a/j8JXIMyKAx4jcs8dHGoDsddDtoTBNbpdBcLLkvfkTWY5gsLPdEGb5lG7bw1c33M/f1D7nku3dw5exZ6T+tCinDNXnb1cYeil3izA3D4PHHH+epp56Ku/6EE06gsjLxBN7hcIS5mbeHo3l7oJTCXVmFP5gi9v2Tr7Ls+1nWy6WZk3dbcDKl2+10HNCb9n17xijYSim54vOXmhU67TZ8b1w5WdtcuJ6el7NN+zXaZttcnJnp5HTp2OJthzDwqAOjvjukIDNU3Bx8CWtSkK5LOndsSweHHlO8F/rbqVmRgBBNZ5jTXSnKfAE2ew28CtJ1i83JJqxJvxbJthXKghCw0R0vemEJD0L9REYK8FR4MU2FYSryMuyWMnPEOXj9Bj5ThelDVZCq11RhRtBwm35l9VkPXg+XtPQP6ovRo89bYLFeZQSJCuJtY0WALGpgTQjSpMAeEXEZfvGZnPDaY2R16mCdk66FiRn6HHMop0x6JuGkqP3wvXE0oewrNI2uhx/Y6DYh6C4HJMGQZXMlZ9jsDlj2+geNissoBUtfeZevT7yQ17oOZ+pFN+AuLduBPdx5MeCcU+LW/gWCbFVKqahny9Umg7S2mRY5iS0YSTACBCrLUHXVuIvLKJqzjOJ5K0m3GYw4pCuDhrcnM8uOxKrrSvhLmYq9Lj0HPc0FAstglAKhafQ7+0S6jRsbFRZplDlPCOyaSKzzAyAEXQ/ejw9OupjH8vfmiY5D+WDChSz96KukKMJTSIzqpSviLl9e6Y2JvoWEXYsWr+CLv/97B/RuD8JfxJq1u2CXMEQee+wxbrjhBjIyMgDw+aL1GAzDoF+/fn9F15qEz+3h6/uf5h+dR3N9zt5c7erPk0efx5RHno9b49EUpK4x5JRjktq2fZ8e/GvRFE559HZsrsY9xmbAYPCxh3DrnM8YevLR9d7pJNH34NHcNvcLbGnJeaaTwcizJ/Bo8Twer1rEA+t+Iq0lDZ3gbH/cDRdz5ZevctJDt2JPcyGx0q6gPi1JEIyQSIGoqMRjWnz58V6ihlJBwS8Tj2FS6TMo9frZ7AlQG1EcGopkCGEVe9uEwKFJnEEBwBACCra4A+FjmUqx0R2gyBvtgzS9Bkopymt8ZKfbrO0jJ+0CDEOFC8zDdJsRKVlW2lWoxkWQrknSdKvWRQpLOT20XTxk6LLJiUXkaiEsMUSXJhlz4emMf+oeBp92PFcumcbpH73Agbdfy2H338LlC77l1En/w5GZkbBdzW5n6A2XJj6wFAw49xTS2iVXXN73mEObzH3PLGhP+8H9k2pvd0Dtpi3h2qVECJE1eOo8LP/gS17rNYZ3Bh9C3R5ukGT37Mawm66I++yU+4xYx0bIsaTpljKyuxaztgplGlRvKqF43koCbi/eah/Fi0pY/8NGKheXkScF+Zl2VETEsmGbQ269mpG3X8v+115IXm4WTmWQ7XIw9JwTGXDcYfQ6ZD/6HXMILglZuggzfTUGh0wsOprdrTOrv5nGll/nY7o9GDU1rJ/6I1+ddx3P9xvLyi++S+4iphAHwbHcMPEaFvthjd+gOtBI5ZBhsODdz6kpLk24TQop7Ejs1KxZAI8//jg9e/akb9++gEXpO2fOHHr16sXZZ5+NEIILL7yQCy+8kAMOSI4Cd0exMPjcHp44fCKrZ8+NKngVUsZl9mkKQgo0u507FnxN+749m7Xv7Nc+4LXzb0zQriQtN4sHNvyMPWiw1JSWU7FxC9Km88ZFt7D21wUJ+6w77Pxnyxw+vPFefnq5ZWiU+xw4kmunvIlur88rnvPuZ7x05jWN7heaSMtQobihotIfnJnpdNp7AH0PGcN+558SVZznqanl7bOvYc23M3BQzxajQurEKtrTrwvLQDGIroGAkJfT+tsfh1XGUPWiYZEIPY4+s77f6ZpkYJYdpyYp8gSo8Ftr+mTYsAmBAWRl2PH6TarcftrnWfzymk0ig0nihs+kssJDYY2PMr9pMWMFr43FjGMV34cmSpqwIiDxEGbzpN7rqrAmLVpEeLnh3ip43jUNXpI9DhnDaZ+9ut2CTkopZt/xEAv+75X6iZwQqECAnhOOYtxzD6E5ks9T//D86/nz/S8T3vfHPnE3Iy49e7v6vCvhs8NPo3juwviq9REpfg1/eSkgx6Hh7NuH47//YI9N2VJK8dt/n2P6nbHpNF3TNFwRUW2lCToePYSNS7dg+AK075FHn1HdsTs0Sv9ci7e8BqQNodlACsqXb6VqQzSltCdgUO0zsWVl4sjJIn/4vgy45Gyye/dg8uGn4tm4OcowCjHL+ZUKR05DRkht8JmNF5GU1GsHhai/TRUMnol67ZHIiG8UBBzz0n/pf+oerkWxDfjmoPEU/rk85l2yrs6P37ScAmYwTbZhPdIFX75Gn3HJzZn+SuwKrFklU99qEdastoedvVOeZ2tjp34jvPfee9xwww1RXp20tDSeeeYZrrvuOt555x1Gjx7Nueeem7QRsiPx3aMvxBghQLOMEOulrTANA0d6Gpd/8kKzjRCA0eeezLo5fzD96deRulavPq1JHGkurvzi5bARApDRJpeMoFrqOS89xH9GnYDP7Y2bMz/h/puxuxz8/NpHze5XJOxpLrqP3pej/nEFA8YdEPPSG3HGePxuL69fegvE8fhk6BJ7RA2DUuDQJD6zfvJ7xtP3MvqcE+Me35mRjreomLSGxZpCgAqmTwnCBep1AZMAsaw1KsIICdWXNFwfzwgJba+UwiYF3pCGB4qNbgOXNKiJ2HGTO0D3NFswuCNwBz2rIZiGQuohA1Zit2vhzJpQMTxYueSRkQ4pRDC1Q6HiJHiEUsgj10gBNYYiDavvidh8QgQ+mt1Gbo9uHPV/99B5v+HxL0YzIYRgv3tvYa8LTmfpWx9Rs3ELrrZ59D1tPPn7Dmx2e8c/cz/e6lqWf/U9UteC45BAmSYH/uNKhl9yVov0e1dBn7NOSlgjYs01E5AMKOtZSV+7mvcGHczpi2e2iIrwrgYhBCP+fjmrps5iQwN2xBKPSec0GS5oL6z1s3bSL0hdMvzYQfQe3hUZpE3NG9AV0x+w6ssMk4rVJTFGCIBT13BoEm9ONifPmxJePmPiFXg3bkZERE1D71hNgC4lPtMIO19MZRWl26RVPxYJTYBUhCPoGor0IAtYwDSp9DdhhAAomPr3u+k9/gj0ZjgK9nQsfvEtNi1cHnddhiZY6zUixmBrJHdpFmMhWNkVKbQQRAvUiIg9b0wMYaePiLQGdoSFbZom/ygYSVVRyTa3ccQtl1NbWoEZCNBj9BBGnj0B53bQYyqlWPLdj8x4+nXWz12EPc3JsFOPZezlZ5MbzMtPhI1/LOHtv93O6p9+Dy/Lat+W4+/5O2MvOZMFn07hfxMu2ea+gTUwtunWmdvmfoErKz5NK0BVcSk3t4sWckrTLIaqeB47pawi8zpDcfey7xMackopHsnfh0BdXUw7moCOThvZNomJ5SEMGTxm0Mtf5TcxITxhDb0EahvkhieKhjSExzBRQLaukR5Me2o4uU/TBB2dOrlZDsprfBiGIj/XiQxNDGwSGawVMU2TNRtrwqleNYbl9bQH61okVm2LI7ivEZyEmBDT34aZXyFIIMsm4xowIfQ49jCOeis5Rre/GkopNs1ZwMJJn1NXVk5u9y7se+7J5LWgJseugkCdm08PO5XKlWuiHBKmSixoF4kePdth1tbR7tRTGH7vnitw5y4t55neB2D6o+u/eqXbECg2eYzw83bAGcPoNqggPNE3TRPT64vQixCsn7kKd7kHw+PHV1FDevsMpCbwVnupK65DaRrHrpmLEAJvWQWfDtgf0QRVdrXfmsQKLM0QS/NHkK1b+ZnKhIbVa5FpngorfTVEVawlPlQYx735FH1POLLpDVPAW1HJ2/3HYjZIUweo8BmsiMOMGEKaJsjKyuC2Db9g304v/o7ALhER+f4dsjK2MyJSU0fbQ8/cKc+ztbFTR0R2ZdSVV26zESJ1jfZ9ezLhvptiitC3B0II9jp8LHsdPrbZ+3beewA3z/qQwqUr2bpyHa7sTHqOGRoWMqppgRxwM2BQsno9s16cxLgbLk64XVZ+G3odMIJVP84BrBdfIiMEQlST4OzUsdFo0saffsNwu2PakUDPdDt2KTAU1Bn1RghYEYRMXeIKpk6ZwaiGQMRQ4jYHoV64GnmL1xmKVbV+egRrOUyh8HgDuJxWQb3hN1EKpC6QUtKlQzqFaypBCDQRpAwORmDa2HX0YHpFIBgB0oTAb5oIET3ZTDSHcWmiiXNVbJgys3kX4i+EEILOI/el88h9W6S9qnUb+eP5t1j5ydcE6ty0HdSfwZdOpOdx43Z69Vs9zcWxX7zBzCtvZcOUGZbSdjP2ry2pJN2uUfLue/xWXsbwpx9qtb7uzHC1yeWEt57i07OuCjLaWUbdBq9BG12EjZDcjlnYnTq/vz+HdKfElW6jTf9OuPIyUErhLOiEIzebgb16YPp8VK5YR+3mrZQuK6FqfSXKUOguHQSUz/+TvCGDKZw+q54ZqxGEIrIKK/U0VItQFbDSrkJjUiiCCyKC9Su+qGtTKFu6AlKGSFJY/dFXMYYsWGP5enfjHGZuQzHu0rN2CSNkV4GQGmI7i823d/9dGSlDpJVgS4ImVEgZ5VoWUmAGDNr16cE1k1+PMUKUUqz5ZR4/v/YhlVu2ktUhnzHnnUyP0UN32CSmQ//edOgfK0rVOwGtanOhgFkvvduoIQJw3J3X8sThEwGi2K0SQQjBkddf2Og2ZQkU69s4tHC9hMcwraJMYU0YwlnxQqApkwxdUmeYQfGxoMaHIKpGJNlfSgG5Ni0+BWcDrKvy0jfXiT8Ade4AdptG6PYxAyZmwDqwANo4NUo8Bk4BPixdkHyHDooosbUQdGlpmRhKNWlQ6TJiOhKXAlQQ8Plxl5bjCqb+7SnYPPs3PjvpYkskMTj53DTrVzbO/Jl+Z05g3DMP7PQpS842uRzx7rOUzF/EjxddT936jfgMMylLW0QwBJZ8M4WVz71G78vOa+Ue75zofcyhnDvrE35/5jVWfPYths9P/t4DED4fzPsTAH+1hy0/r6BdQSZKKbK75ePMtSLiGf37Iww/1avX4tlaiuHzB+8pSfu9C2g3uCPukjrKVpRQW1TDnDMv4rB5Myj5dR5m8DdobFxxRKSGCuqjylJAlm7do2HGvHB6l/UqC5awIYTAki1NDr898BQVc+aT2as77cYMp+3gAeQmENjb01G9fpOVYu2PNjrqDBX+3RJBAR2G79OKvdsDIeX2s17t5GN/ayJliLQSHOlp9DtsP1ZM/xkzDm0jWLUiF0/6P4pXrmPTwqXYXU72PuFwBh97aDjSEILh9/PKuX/nt3c/C9d4SF3jh+feZuipx3Dhm49HFXbvaLTv04Oczh2p2Lgl7vosu8agHCdZQQpYn1KsqfWzuqZBaFkpqgqbjiR1HTaYUeeexC9vfowRZLHSm2B3ye3cOAWwMwGveq7d0iFWCtL0+sEipGjuDTJoVQZMvCb1NJxKoQtLlLAimLYFyRkiztxscrxepGGEa4qkrluTDUEM45qpYEW5h04uGxpQWe3D6dRwOnQ0YfXV5zVxewPku3Rsdp0tVV40pcjUJSJYZBoSFxRYlLqhAkcpBLqILbqPh1Bxv4peGEVnXLly7R5liPjr3Hx55hUYHm9UjViI0nXZO5/QccS+DLrozL+qi0lDKcW8Ox7Evcl61nUpmmTTEoAzUl1PSlb976U91hAByB/Yl6Oevo+jnr4vvOzLc69h6/w/0YG8LBv5BVaKqtQ10jrkWEXH+e1AmZTOX4zp9dVHVUyFHqFvZMu0o9l1EAJvZS0f9hgOwbGqqaiICEZ5qwOW48UXjI44ZbTxEb2P9b8uCKdz6hJ8ZmKxxEhoSrF08kxMZsIzrwPgzMth4AlHoNdUE6itI7t/H3qecypZvXskc4l3WzjzcqLooJVS1AQUxb6mFF0s1JTG1hSlkMJfhZQh0oo4+rarWPb97LjrpKbReZ8BDD3lGGQSlvDHtz7E75M+BwgXmof+n/fh13zYsT2nP3FnC/V823DZB8/wnzEnxnhHu2XaGZhhDy83laLcayCVoluajXV10SHm7IL2CY/hrqrmnSv/xZy3P0WZJkKTmCiqAiY2YRWsx42OCEHnoYMb7X+PcWOxpbvw17qjltfTUkbyRFkvYx2F1ATFXssI0YITd0NR/9ZVimybJXYohVUC7jVCedcNuqlJNJuNy795g+yO7Zj/yiRWT/0RZZh0O3AUA08fz+d/u5VNcxbE7KsUbPUEyHdoODSB2x3A4zEi1gdTLWyS7m1ctEm38ceWGtJ0q2+1DQpBDFPhA1yalaKlCYHPtDLHE00oItnDIjdRBAXTgilt6U3UJO1uWPHRV3jLKxNvIATzn3mVgReesdOnaJX+/gfFP9fXikkhsAuFrxFbJNulR3vgTROzupriP5eSP2jPoUBuCh2G7c3KTydjl9C+c1Y4BdSe6UQGi4x9Xo0Vr39HoNZNen4a6TkOlKGQugwXIJevLmPLnE0A1PgNTOodAaFobQihyGXk6BZyPkiIIuSwNZICG4IQwhJFRaEhcOhQHQilgcY3RnQB7jj+Ok9ZBb+/8h5t7daYVjTzZ5Y9+xp7334DA66+qOkLupui50nHMOfuRwHwGiYravxx3yeJ0JRTLoVmIiVouF3Yc898B6D/oftx3isPo9lsCCmQmhamruw0uB9XffVKXCOktqyCtXMWsHnxirAQ4vSnX0+o0aBMxQ/PvUVtYxOdHYAeo4Zwy+yPycivV5p2aCJshCil2OoJ8P3WWuZWeFhV648xQgCKlq/mvev/ja8u2iD48+tp3NlpBLXfTmZ4+zRGdMygf64TVzBK4VfEUMMCIAV9jziQvJ6NFxjb09PY76YrYpaHxncFuA2TuoCJEfwthBAIpTCVIt+hke/QaevQyXdoVqSBEF+JVUxvE2CXkiybRo9uHclv0Kduo4Zw1Yz36Tx0EJkd2zH2tqs5b+okzp/+Pof8+0baDezLeVPe5rB//51g3Sga4JICp7SMhZqAwm2YMSkRXlOxxRNgY6WPVcV1VAW1SAwz1giJhNtQ4QnRoDPGJzRCbCKCeQtrghpK1ApRA5tY0Z7MPexFWPjzXERjLDVKUbFyLb6qmh3XqW3EpsnTYs7FGSlq1+AGybBr5Lji+7zeGDOeSUedTXmCtMg9DXtNPAldCjRN4sqw10/6hcBX52PepN+Z8a83WffTSkyvFxsG/io3gVoPvso6vBW1eGu8GH6D3N551BomHtNEE7EGhAqOWyEx05CzwCSoB2OqeqdKEM0xkYUQODVLk6iDQ+LQ4hshdtE02UGl37AYukwDDcUf9zzKxi+mNL7TboyMzgUMuOgsAgqWVvuSN0KEICM/j72OaH6daAqJITStRT57KlIRkVbGmPNOYdAxhzD71Q/Y/Ocy7Gku9j3xSPqPOyDGCKkqKubDmx5gzjufYQasSWJ+r24MPu5QAh5vo8cJeH0snzabIScd1Wrnkgx6jBrCI1vnsvGPxbxyzg2037IeZSo2uAOsqvXhjhT1S9CG4fMz7clXWffbQq777k1sDgeb/lzGp2dfQVeHoKzKR2RguXeOg2JPgMIaP34VEhWsf4HndC7gpGcfSKr/o2+8jIDXy+yHn8U0DaSmYSqTcp+izGdEpVdl6YJ8p47HhCybFmUoSiFI08BQgupAvdESCXdxGQVDBjJx0jPUlVeQ26WAtr27N9lH0x9g8/ezyLXrYb0SI5gmZqmiK6r9lnFhaapYzDehtCpdQFWdH79pDXx1CYwQ0zTDzDg+0/KGdj5wNO32Gci02x5EaFq41kHXJLka1JnR3o14hf9djjqkyXPc3WC9ZJqexjVXSLQloJRi48yfWfzWx9RsKiS9YzsGnDmBrofsF7dmJeDxxswohRCk6xZVtbNrB6Sm4d1USIZdw6HH8XcJEb4fN/88l3cOO52JP35MVpeC1jjFXQauNnl0GL4PlXOjI56+KjcL3p9HbYllqHbZuz0okzU/bSDgMRAS0vMz6DSiE450B45++QC0H1LAlkVFeCo9dBneg4yO2ZiGonhZEWtnryLgjs+uZNW3WT9Qp0P2p+LbHwDLYNBpnHErEqEIsU1Y9W6hcchQVr2JgKh3QiL4lTUGWbV61vg+99Z76Hzc4Un1Y1eEp7iUVW9/ROGM2SjTpN3oYfQ+91TSCqxo8ugHbmPp/CX4pvyUfKNKcfCV5zap5eP3epn7wdfM+/BrPFU1dBzYh7GXnkXBwL7bc0oppBAXKfrenYQmrbq4lAdHnkD5xi3hlCugXrQhCVz09hOMOPOEVuph8+Grc/PVoP35s7CKjU0weSTCxBce5ICLz+CNky+m6LuZ1Pni19ukOzQ21fmp85ukO+04UWS0a8PIS85izBXnNluVvXZrKUs/+oqaomKWPfEClb5Y/RSwqBBz7bGeDKWsqESpzwxHVEIv5YY489u3k9bS8NXW8crAQ/CWVWCTAkNZLDZ+M7oo1G/GFpY7ZDS7mNcwqTYUtjieUq+paHjGAsuIGXrBaex9yrHM+b9XWDfjZ5Rp0r5tDkZFJXqaTqeuWeTkuZBSUFvjo3BjNcWFteF2Cg4awwmfvpLU+e4uWPHRV0y+4PqE64WUtB3cn9NnfrwDe2U5ML4+/zpWfzk1bFiG/u962AEc//bT6BH6QgCr3/2En6++LWGbmtPBka/fw8+X/KvRsWtzlZcKjzUuCE1j8PmnMe7xu1vmxHZh/P7oc8y797/0G9KB9EwrKlJdUseW5RYzoSvbgV2XuMs9cffvdkA3sjtnW5okNV4CPug0pi+mP0DA48X0GyAEiz5fSOnK4vB+StXrC4WmBW3GjGDsi4/y7OBx+GvrsAnItCXvuXUFqcFtUlhjVERqlgoKJ9YaydGZ5wZrjEK0wg4pOPzLN2k3alij++2KKPzhZ2ZMvBLD44VgTZmQEqFJ9n/+UboEDbAHRoxn3W+Wtk8y7IwhlrOCQf245L2n6TgglnimbMNmHjv0LIpXrg2LL4fqUvsePDrUEAPGHcD+F51GVvv8ljrtuNgZ52shhPpW9ssXZG2HtAJAVU0teaOO2ynPs7WRSs3aSfD1ff9H+YYGRggkbYQAdBnSfNG25qCmpIzZr33A9GfeYPmMnxOmioVgT3NRbXPENUIcUpBlq9esSIRJ197Fom+mUzbzp4RGCECt16Bzhh3NZmP/ay7gPvcKbl33M4fdfk2zjRCA9HZtGHb5OfQ+8uAoI8SlS7pkO9grP42B7dLolO3A1oBe11SKQo9BkdcMRymsSEW9lzEEqWusnjw96X59d8VteMoqwt+Fqtf6iESsEWIJWUUaQvYgcUDk76iUwhPHCAm16Vcw95X3qNyyldM+fombyhZx/cbfoKqKvLYuBg1pj9OusW5RMYt/2si6BVvxV3hon+8Mt1G9bmPS57u7oOfxh5PRqWPC8LsyTYZeu306PNuCWf96mDVfT7P6EIxuhelkp/3E9Jvvjdmn6/gjsWVlQIJnN+D28OfrX9L/aovVLmY7AV7dFjZCQsdc/NZH4UjwnoxBF5+FkpKiDVXh57W6pC683pbACAmlQG76aT1L3vuTJR/+yYYf15HZtS2+mjo8ZVUE6ryY/gC+qrqwEaIJgqQUlqNBF1Y7plJsmvUrn4w5lsGnHBuOYnmCRdLJ+DCjmPOIn5qVbAwwRKbhD/5fEzD5csIF1BUVN73zLoS6wq3MOPsKDI8nbISANUaYAYMfL76BymUrAavo3C4FdpEcRXzo9yhcspJHxp5KxeaiqPWmafL0sRdQunZD+JhQX4+6fPrP1mfabD6741H+2XMsi6f8sL2nvOtDai3z2UORMkR2Ahh+P7NemoQZR7U8EonSNqSu0eegUXFpdVsCht/PpGvv5paCkbx2/o28e9W/+O/BZ/Cvvgez+ue5je673hstbZdlk4xq4+Lwjhkc1D6DIwoyGd02jUw9/rn56zw8dcwFlNXGCjc1hDIUht9Phzhenm3Fwtc/CKen5Dg1euU5yXZoaNIq5nToksx0O2nO+lD3Vq+BJ0HOrtHQGBGCgLfpcwPrJbLqi++sv6kvPk9vkPriDzLjhA+BFQ2JbCeUyuWS0R5Qg/iK6FH9EILZT9VHNHyV1WiaoEufXDatKGPVgq14qnxgWr+9GTDxVPjIskkk4MjKSOp8WwOeiip+vPV+Jp97DXMffwF/bV3TO7UANJuN8R+9iLNNbtRsLFRrMfymv9Hn5GN2SF9C8FZUsfCld6NYvCKhTJMlb31MXXFp1HI9zcX+zz8ak9eslArfk8s+ncbq2Qvpf+OF5O7dL7yNLS+bGlc6qzZXxBwv4PHi3QVqZFobjuxMRt5zCxUlbjavs+r+jIjaN09FrBEihUCXMliXFaTTDSi8lV4WvvwT66cts+q8pERz2HDmZTD07BFkZTqxSYkmJem6hkvXSNM1Mpw6aQ4dl4Ta8irWvPMxbdvlYZcCt5CW4KFq2hgJKMLbhYrV6xm0ggxcSVwTAfgNS5Q29HEbippaD9+ec00SLew6WPn6e5ZoZbx3SPDiLX/pbQB0I4AOjRJFxINpGNSWlfPccRfw3T8f4tub7uXH/zzD3Lc/YdPCZbEO0ThQpknA7eV/J1xMeQK2zBRSSAapGpG/ELXllUz/v9eY+exbeGsanxBJXUOz2zG8viiDRWoaGW3zOO/VR1qtn29edhuzX/2g/g0S0gJYvYHHDj2Lf/z6KZ0G9Yu7b4XbH/bUZNsk++WnW7nBEZOxNg6NTJtGdSJvqFJsdQdo72hcU8NvKpyZ6Qw/7bhmn2MiVKxZjzJNqz4iy9KGiex76G9TQK2p8AWsYvbGcqgNZTHKCCEw/QHa75tcJMvweKNErBRgl9YH6vn+DdPEQIRzuSNZU02lLDrNcP8lEjM8OQ4kUfRomIqiP5ZgBAJouo4jL4c2HdLZuqGS8iLrPg4Ec8ClJhDKUmJGKTJ0QfuRQ5I635aEUopPj51I4U+/hx30az+bzK93P8rgqy5g/3tuafU+5PXvzcTfvmHpOx+z6tPJ+GvdtN17AIMuPIP2TTC6tQY2zf4NI44ycyTMQICNP/xC35OijaSCw8Zy5Dfvsvipl9jwxbeo4MQloOrF7NZ8O5s1U36m7V49Eb17UrqpmPKlmxMeS3PYsWduX3rD7oJ9rjgfZ242v/zzQarmFuKKfIgbPKKhSEhCKCiav4nMLrm0G9IDzelEc9hxtsunan05/qpq0tqkWWQcxXVUrK0g4A3g1CQ2hw38JtU+A39ZBS5Nku504OzZjYzOHXEvXk7dpsSTUEsYVWEKiQwyd5mqnj3LYuOznDNNOUBCbwed+oxlv4L1P/9O0e8LaD9snyZa2DWwecqMhM4BsKKHmyZPp9PZp+LZXESaLkmDsNhuUzoi9Q3B2nmL8S9ZbmmWCYEyDHLtOuVJ0gArpQj4/Pzw3NuMv+fvyR13N4SQcrs1oHZ2DanWRMoQ2UEoXbeRn1/7kPKNhWS2a8NeRx7Ia+ffSOnajY0OOiEopRh55ng0u43Zr36A3+1Bs9noP+4Aznzm37Tt3qVV+r1lyUpmv/J+/D6ZJobfz1f3PMklk56Ou40zM4PqrZZHde9clzU5bfDSDCjY0kQNicIKzac1ojIuBZz7yiPY01yNttUcuNrmgRDkuur5+cN9Ugq3z2BNpZfahmxdDXQz4kFIiSM7k34TkiMYkHZb1HdTgVMXuA2FJqyweq1hTQQl1pveUniX4f564wkWChF+yScjPqawonOhgbNuSxF2p2Tziqqo1AulIBAwEVJg6AKv18QhBHndOyV1vi2JDw8+mbI/Fkdo3ddrvfz51MtoDgejb7+u1fvhyM5kn8vPZZ/Lz231YzWFZLyeQIxoWgh5e+/FAS88imkYfHbYKZT+uSw2lVQpShatwpSSam/iZ1xoGgPOOAHNZku4zZ6GfmeeSL8zT6R82So2fTuDRffEdzbJ0HPeyFjTft/OtBvaG0eOFY0UQlC+ZjPC8KDZJf46H/5aP4bXILMgA6WgenM1+E0ybQKbplHuCUZB/AFkVTUT3voQf1UN355zNYWzf4t7XCEl7Q7ej8z8XDZ89CU2EdQkiaibs0lrEo2KHX8E1rhuKCt9TBMCXVgEHKYKGb6KuY+9wNFv/l8zr/DOCdPf9HNp+P18eslNMSQpGbqOxzAp8RnJpWphkZvYI+Yg6RJMXVIZh4EyVO+DskgHFJYW0h9fTN2jDRFEC6RWiVRqVgqtBKUUn9z2ELf3GMuX/36Sn155j28efIZHDzyNkjUbEhohgiAFavBvZZjMevk9Zj77VjiVxzQMFn09jUcPPI2iFWtapf9z3v40zE0fD2bAYN6H38RQ7YYw9NRjEJokyybJscePaHgCZhJFdk1767sfegBDTz66iZaah71OOx6UIs0WXV+hTIXHE2BpmTvWCAnCCgIk6LOmIW06J7z5FLrTkVRfpKaR2bWeVciEcLGnUla6Quie8SlFjWFiAKGy9YCqT5+JalcKdOrvtaYggB4HjQmzvi1/7T22rqtKWM5kGiZ+T4BST4Atbj/f3vkYK7+ellSOeUugbNkqShcssvoeh+0JYMF/n9vj6hPa7bNX4wpzQbQfOqjR9VLT2OuSiVH57DHbmCa9jxsX93hC07BnpjPqxsub7vQeiNx+vRh09YX0vvAsIHZMsWovGv8dO47pgyM7I6wjUrpkLZtnLbXSfU3wlHkwvMEJsAqyAhZkYjgkpZ4AVV4jbDRopkHtxi2s+eI7nG1yGf/Vmxz45L3oQQeQ0HVEUPOk+3GHM+71Jzng2YeZsOgH9rrxCvL3HkBGuzycbfPI6tebDvsNp/OoITicdmyAU1qppDm6pINDwwwaIa7geyTDJkjTBRk2S3TRpUnWfjujJS/5X4p2o4c2SuUqNA1vdg5lfy6zvgd/09A94JCC3CQJBUKsZVGpvEExS9lgu+zg79HWrtHWodM+SFEPYCRwVqSQQjJIRURaGVMff4lvHngGqC8CDSPBRMzypAOq3htkeYDqU6ME9YVklZu38sThE/n38mktrq5eXVza5EvONAzqKqriRiIOuuIcpj/9OulG4hSQphTRARAypig8Ei6nnQlvPdV0O81Er6MtqtlQHUWIdcTwGxS5A1H89zZpFXgaKlSHYf1uVipBdN/3OvVYRv/9ctru1adZ/dn/7hv55oIbrD4pRW1w/Pealme0NkI/RMNKeagLKDRdRucRN4jYSGnpoTikaJKTXgrY74b6wuqS+X8S8JkJ57RCCByawKlZhaYBj5ePT72MtA75TJw6iexunZt1DZqL786/ttH1QgiUabL6i+/onWR0andAVtdO9DjqYNZ+OzN2bMKa8HTafwS5fXo22Vbv009g9SffsGnaj9G57cGo0+BrLmb4Hdcz69+PMfeZ1yw2oCDa7TuQo559kOxWiuruLhj6wD/J7NmNRfc9hvJ4kqbQtaXZyOySH64x9NV62PzjEjSHbjFrVVvq7J5aP+4qL2bAxJllB11S7TFiGK0ElmL6ikmf0ftEy/HT/5xT6H3q8az9/FvKl63Clp5G92PHkdO3/t5x5bdh8M1XMfjmqxL2tfiPJRTOmUfhjNkUzfoVWVmJwmIndOmWTlLovSkAmyawa1Dt92MGAk3S0u4K6HPBGSx/+Z2E681AgC2r6wk/VIO0NoHFVqYFaJKNzC5FkKTASuGtN2oFXdNslPoMqgMmbexakNCg/p6TQpChgS41eh+QHOvjbgshQGynX38nF7JtTaQiIq2IgM/H1/c2L1wssbw/mbokz6GRY9fIsgUni4KwQFwoYgKWIVC2bhPzPvqmBXtvIa9rJ8wmUsd0p4P0vOz4+3cp4Npv30BrQG1X6g3we2kd3xfWMKe0rkn2LKUUpz7/IGnO2NSNrLwsLv7tK+zpLZ9fLnUdR3YW1UFvYcAwKan2saHGj1KQb9fome1gaIcMhnTIYFjHTHrnOTGkYKvPoNBrUOgNhKMmQtMYctEZHPfSo802QgD6nXwsI/9xZfi7gWWghlLXgKBookCTViKSJgTeOEZvSLgsBCEELmmpIjeGI++9md7j6gWxvGXlTfZbKRXUAKg36mq3bOWVUcfjq27dAuXK5aub3EYIQemfS1u1HzsjDnvyHrK6FMTkJwspSe/YjiOe+09S7Uhd5/C3nmboP67Bmd8mvDy7V3fGPnkfI+78O1LTGHv3jVy+8ieOf/Mpjn7xEc756VPOnv4BbVqJaGN3ghCCvpeew/HLZ+MKaklAE5FXwJ6Thi2tPuq67L1ZoMCeZcdd5sY0FaUbq6nYUoOQgrQ8F/Z0O9nt0ukzKJ/eg/JxpVvjboji11RQPCeaqER3Ouh96vGMuP069r3+0igjJFnk7z2AwRedxeGvP8XEVb9wStEidMCpSXRhGSJSCOyaxKlrODSJS9PId2j8eM6VcQ3qXQ3Z/Xoz4qE7AKIiI6G/O599Ct7gmJmIMVEBGcGolCbqBW8j37J2CV2cGh0cGnZJ+Npa6XDW9p1dNjo59RgjJNyn4Dujz4i9W+jsd1EI2TKfPRR77pnvAKyePZfaCKrVZODQBJk2GVYpNpWiJhA5Waz/gOVt1wXYpGTehy1viIw+96RGeQGlrjF64onYnM6E2/QcPZQbl/+ASEtDKcWSSg8/FdexxW1N0Kv8jRfYCSnY/8JTGXreqVxXuIDjn7ybvY47jEETjuTM95/l2o2/k9ur+3acZePY64zxVPoV3oDJpkovNf6gUQEU5Dhpk2aLiurkOHTGdMigS4YVnQooKPMbVBkmbfp055B/37hd/Rlz2zVcuHQGPY89LNy+aZooFLqMVlC28qpBJEi6imTMAouBa2CWnbQ4hmFut85cPv09Drjxsqjl2Ulee5+pqDMV7uD/XlPhqarm1ydfTmr/bUHRT3MaTRmKRJu9B7RaP3ZWpLfP58yZHzH6n9eQ2bUTmt1ORqcOjLzlSs764WMyO3VoupEgNLudITf+jTMXzeC0+d9xxsLpnPzLV/SdeHLUPenIzqTPCUcy4PTx5A/e86759kJ3ODjytyn0vvx89KwMzGA9WCIYEYXHnio3/iAximbXMP0mlUW1+D0BEOCp9lGxuZriNRWsX1BE0cpyME0KuuVgCqs4PKAsT3ttaSVfnX453oqqbToPIxBg3qPP8umRZ/HpUWcx77HnY5gjNU0jI80Rpho3lVUPJxqmpwlBxfRZzL/xrm3qy86GPuefweFfvkXnY8dhy8pAz0in46EHcMj7L9L9FIuMJcRQlwhpmiDfrtHZqdPeqdPBqdPFpZNjk2Trgj7pdrLsOum6RoZNw6VZoqRpmuWMCj2zmbqVVp1r08gJbhd1t0nB+umzW+tSpLAHICVo2IrCMQu/msbTx14Qs1xSH90Ay6NlMSlBXpACKTQIuA0zrvKswPJ6RxUqChhx3qmc9NS/sSVZd5AMPr/rMb68+4nY89A00vJyuO33z8lLQhF53euT+PLaO/kjDv0kUJ+PpkCz6ZiGiVKK/S86jTOfvqfF086SRcXaDbw25gRs7rqoATjHpZPj0qMmWaZSbKn1s6XOh6mgsM4flanyz7lfNlvvxVNZzZLPvqW2qITMTu0ZMP4I7OlpmIEAz/U5gIqiUrymVWcTEvsSgE0IdBm/kDV4pcN/h2p3Ojo1nEFPWqHHT0kwEnTB95PolkB0sXz5Kj4fc2yTqSIb6vwxaV8CaNsxn2vW/Jz09WgOfr3udpa8/gHeRkY5FaTwubRsSdLpLimksDNh6/RZ/HbBNRbtawMITTDqthNwtclgzfeLKP9zNXaXjczOWZQsLmHr2gogNsUnJDjoM4P1ZXGOK6SkzaB+nDj5nRjhy0j4a2qpXr8R3ekks0dXNk79kcln/S2GCEHabBw56Vm6HLJ/eNn7vUZhVFXjayDa6pAClyZi6g4P+vZ9sndjA7eupIwneu6PP4JBMREk8VKfFXYhSNfr6x6DdCaYCtwRF1lE7VXPWGYqqPAb4d+jYNhgLv7x4208o8axSwgaLphBVub20dJXVdeQt89BO+V5tjZ2/YTKnRjxVEut6EUw/UVYarMEqU5DFIyRkyFfnEiBgKhUpvD2Cn57/UNqS8q44KPnW2xSddyd15HRNo+v7nkyzICFEAw44gDO+L97kjJCakrKmPb9r4mNEAjn/u5/8elkd2yPKzuTIScf1WqMYMkip3sXjn/pYSafVZ8SFXppb6ryIVC4bBqahF+31lEbMOOq3EpN47f3vkjaEFFKMeu/LzD9nscJ+HxIqWEaBl9mpHHEg7cx/KIz2Peyicy458lwOF4LGqa2iBSrSL5+TUSzloVqWgAyNBF1X+U7dKr8ltctMqe/IXL79iKzR1eq16yPe8+FRBJDRkik60MBJYXFBHy+VjE0/dW12DSJN2AEKUOj+xfyw3QaO6rFnhfD52P1J5NZ9taH1G4uJL2gA/0nnkyPE45E+4uM6RR2b7Q7eH/G/T6V1S+8wZbPJ+PZUoTQJJmD+lO9cCnrpy2i/6mj8VS58dX6sbtsGF4DX9AQiGeEuA0VFmNNZMcr06Rk4RKWT/qUvc4/PWb95llzmPfw02yd/XuYejy9SwF1GzZjFwItWPcXUBb9uun38/Upl3DmvG/J7BqsHRP1aaemWd8nn6nwBiAngtZd6BrrJ33C4N3YEElrm8depx7Lgrc/aXLb+L+bwKfAqaz5SCgtRgqBJ/gyCNWpRkleYV13DcuRmmXTqPAbCE2S3q7tdpzRboCWSK3ag1OzUoZIK6Jtjy70HjuSlT/8ClgPfbZNs+jvggh5nWoCZjjXt6kJkR7HYAm3Z5os/mIq62bPpft+w1rkPIQQHHLVeRx42VmsnfMH3ppaOvTvRV7X5GhY6yoqeWj/kylZtb7JbaWmYfgDjP/3Ddvb7RaFjMihN4Iv6dpqn1VEqQk83gDzKjz4Q3wCcdowDYOty5NnN/v5qVf47vaHovYH8NXU8cVVt6M7HYy4/lKWfPwN6xYsCXuvpIgOrUOwwDTObRVabpOWzkvkPpqwQvWRqYGJcPTkd3m3z35oIrqoH6xoX5nPCAtvNWxNmfD2aX/j3E9eavqiNBNpBe2tvHcpqGso9Bg8V00IjnijZYgOfJXVfHnShRTPXYiQEmWaVK1ez+aZP9Pu+Tc55qOXsG+n5yyFFOLBnpdD/1uupv8tV0ctr16xmh+OPAVnbgaO7DR8HqsoXdplmN2q4TPpM+updJuWpRAsfu39KENk8RsfMOu2B6GmOobVy7dxC05NRr3rdBS6JggohSkUM6+5nf7nnsYfz7xKeWllOA0pYIYKqq22DCHweQzaOSRSSpRh4inc2pzLtkti3AP/SMoQaQxeM5TKaxkehlIYREdB4k1FTKwx0yasd0fAMNn7rAnb1ZcU9mzsuSbYDsL4O68hw6bRxi7Js2vYgyxKoQsvhMAuBZlBur1Ag1z+eIXDWoLCsRCkrvP7Wy0fJtVsNnrtN4y9jjgwaSME4Lv/vkTxqnVNKseHsRNmC9qCjGBm0AgBa+KeFsyXXVbtCxshjcGZpKq4r87N9HufbHSbqXc8jNQ1Jkx6BhEsNAxTPje4P0JGSDz6WkHQWPCbVPuNqMm6DN6PzqxMfn7iJV4YdTxP9R3Lm8ecw+IPvwr/pvbsLNwmuANmWD0+oKDWUJYRIgTpukaOTZKpiWild2Dp19PZvGBxUtemOeh26niEqZBSkqFb+c2hokwdSNcEPQ/dD3t2y4TCf7jxLkqCVMEhVrvQ/8XzFjLr5nta5DgppJAsMvv05NBfp7B1WQVFP6+irsZH2YYq3KVuNL2eQAKCjjFDYSgVFBtMIkqoFLWbCgErGvjRMRP5/qp/YlTXGyGhVGKnFOFUIYty1moiPd1G23ZpdO2WTc9eOVT+/jtTL7qB4t//wAjqH3lNi5wjgFWrYihrPA4oRbE3RAYicewB3nlLiLZpNMYBYwbZN0PtqJC+UnA/hxSka9bHEWTUqifutJw6Nk2j45BB9D/hiG0/md0BkcW72/PZQ5EyRFoRC9//grfGX4hLQromydIl6boMpmGBIyKyYZcCu65FsRgB4Xz9SDQVMVGGQU1JWcudyHZAKcXMZ99CGckVDJuGQZ8DR7Vyr5qPDqOG4sjJtlLpAIewdE3K/SbFXoNcu8WvbmtiLNn3pOR0TlZN+SHMjJII1Vu2smH2XNb/+Fu0F6vBduHJQGJ+3XomK0OF0yDASn9ou1cfPjjzSr7/53/YunApVRsLWf/Dr3x8zrW8d8plGD4fW+b+iccwqQmYlPsMSr0G5T6DuoDCRKAIHSN4vwtJhiZxRbwpv775/qSuTUMopQjUueMyB+XtvRfdTj42XJOlS0la8Dl06hJnVgajHm8Z46CucCurP/464b2uDJOV739B3daSFjleCikkC2fbNhw8/TN6Xn0F+BVSF2xdU0nl5voxxorOW5P9htHURiEEaR3yMbw+3j/sNDbPmgNYzo+QEeKQIuwgkVhGicMmseuS3BwHLocOAYWvxo+73ItLhhwkCr9J+J0Z+Ta0WP+s//1K4TFMVMCgy6njW+CK7dzQ7LYmae81gWX4Jdgs5LiC6PRdXUCmbhkfetBwdEhBpm5R/Eaibb9eTPzi1ZQQqZQt89lDseeeeSujZMUaPrjgBjTToL1DJ9euk6ZJ0jRJrl0n22ZFR5whSlOlsAvI69UtikpTD3qRIqFj0fGlBQeIhj+i1CTC4+XPSZ9RvqbpdKjWgDJNlGkS8PmoKS5Nah8hJWl52Yw4c+d7kWgOO0P/fmlYNySA5e03ghNrTQiydElnly3m94rEgHH7JXU8d3lF0tst/uirRrdJ1s8Ssj9qAiamaTGZeRAYHi81hcWoCAMlNNle/e0Mntv3SN445FS8psKnLG9lyPAxw9UrwUlFyJMZXCqFCEeVNsxZkGRPg/3cVMisW+7llS7DeLnTEF7pMoyf/nEftZuLorYb9dT99L30HHS7LRwxkkDbIYM4YvIk0ru0jNL7ltm/N2lwK8Og6Je5jW6TQgqthZ4XnsWxC2eQN2Y0aAK/OxA24EO1Fw3RiHyTBaXofvQhzH3yJUr+WBJeHE67ChVEB9N5XGk20nMcOG2S9HRbjNdeAGkOnY55DpSyaipDz6wurTZCu0T2tyag6HjcEeTs27gA5+4AR3YmBUMHYYvjXNIFtHNodHHptAsyZrVzaDHvpYygQybTppGuWSKGeXZLNFI2cFyF/k6LYMwSQnDcS4/gystprdNMYQ9BqkaklfDrc28iFLSx69YAGvIOCWvCJwChS3QFUpjUGSBMxQmP3cnvz73J8m+mW4rmQpBGAIduQ8/LQWwtjvJiaErh0CV+08qh1YWVb7thykw2TJkJQK8jD+K4/z1ARof8Vj9v97IFVP/0Lb51K0ApbJ17MGifzvy5YGPjOwqwpzm56ouX4woj7gzY56oLmfbvJwi4PXGFokSwuq+DU2dtXSyjSdueXbG7kju3nCQL9HO6d2H9j7+haMBwEuxfJDtbUwgohVRgIDCAmpxchp9zJL89+0bCfYSCqnXRv60U9dSSoQhIqCheNOyn1QpOCe7aOgy/PynvWuXqdXx65Jl4yyvD2gGB2joWvfg2qz76ihMmv0NWj65Wf2w2ht57KwP//jeKZszG8HjJGdiX3MF7JXllkkSSKYVKKUzTZNWUH9jwyzykJul12AF0HjUkxdqVQqvDmd+WAye9gL+mlrXvfMzaSZ9Q8cdivAls6FybpNxvJkw91QSs+e//KPFHNxCqAQkRZOgSMnJdKGFRCuth9e/497wmJVKKuCQTuqC+Hk+BKUDPzWbY0//ZY56h0TdezqdnX41UVnTexLouHV16THquLqCNQ7Oi1IYizybJtWvhFCt/+H0R3EcpZHDcDrMrBuv+HFLgF5IOI/Ylf58WHkN3USghUdtZbL69++/KSBkirYSVU3/EhUIPU6jWpwAKgl4e06LLswuBIUDLzWLAUQez19GHsGXBYhZ9/A2+2jry+/Vi4ElH8eL+J1Kp61GiTaHBJpKJqyFWf/cjrx9xFhf9+BGOrMxWO+eqmV9SNfUTi/0hOCnzb1rLhBMG0KF9Ot99uyzhviPPPpETH7iZ3M4dW61/24O60nLmvvER/jQXddV12EKeuTg1F1IpMjSJP+RpDNZLHHb9RUkfr/uBo8ju2onKDZvjTnCFlLQf3J/cHl3wBFO4QrEHE8uosGG9WOoNgvjHCnlE/coyhu2aIO+k8ZRMn92oEWKdb5xlwf8tZXnrmxlkaIk5k6BxghDYbFrSysjTr7w1yggJN2cYeMoqmH7VbYz/8s2odY7cHLpOSC41blvQfuSQWKqZBhBSIjIyeHLgoVSs3Rg8X8X0e5+kYNjenDHpGbKaod2RQgrbCltGOn0umUifSyZSOH0Wk0++OGYbl2aJB7bTJGU+I4ZK3i6sWjlLWDV6X0NZTjEhrEozYdcoL3UDIKUgN7txinkBZDg0aj0GUtSnYYUmxJqIVg5vO2wfpH3PSRHqe8KRHHjPTcy842HswbBVti0YPQqmxIXfT0GjItsm6Xr4AQR+rNf9iGdgRqZqCeojT0IIdKlwde3M4a881lqntushxZq1XUgZIq0FpUjTZERhXv2q0N+aFOjKyqF3anDYk3eHB4CO++xFxwhvw5KPv6FibeNRBYP4xe3KMKhYvY55r7zH6GuTnww3B75Nay0jBCwapPDBrVFu9OiurF5dyuqV0fnxQpP0O3gMF7z+353Wk/XHB1/y/oU3BuknRbigM0eX0CAWYShFhd8AEfFwCYFDStIz05I+ppSS45++l7cmXARKhAuewbpmUtc59vG7ePukS6xlEb0IvVf8hHjfRUzEJISQ1zIQnEX4FOhpLn57s2myg1DxYsOfTUV0QikVTKkgQRTJakMCOfm5Sd0D5UtXUvRz4vQmZRgU/vQbFctXb5O687Yio3NHuh83jnVffR9X4VloGgWHHcCks6/GW10LgBmo11EonL+I144+h8t//aJFdYBSSKEpdDh4f9I7d6Rm45ao5S5Nhus82jp0fIZljAgRqVME8XgCA6qeJENqAh2B3aWjFASSFBlN0yXSVt92iLHQwHL4RD5lo/51ffNOejfAqOsvoc+xhzHvhbfZMH02cs3qsCHSsGbOqv8QZPq9VGgayjAaFUS0CWuOEhqTA6bF8GnPy+WkHz7GlpHeaueVwp6FPdcEa2X0PHg/bLJR5yhKQagWXQpBu17dEm676rsfwt7iLKdO7/w09uqYQe/8NLJd9fZkIn1KZSrmv/p+808kSdTMmd5osZUSgjFjLV0VqWkIabFE7HvikVz+SctpnrQ01v8yj0nnXIfh86NMFTYIMjUZnIDX91sFjZBQHUkozzaUsvXeJf9gZTMUaHuPG8t5X79Bx6HROc9dxwzjwqmT8FRVs/6HX2MeYhHsi5UOpcJpUpZkjYr6QH1Y3zoHqHP76r9sAwwFKuyIEzGey4YI/fTeraVsnjM/7jali5fz+UkX8fqAA/nk2HOC59J4P0oXJY7ANYZlr73He3sfwqttBvBqmwG82/8A/nw6OfX3Ax//N7n9e1lfIryRCMgb0Ae9axe81bVxDRXTMChdsYZfnniJ9VNmUrulKGabFFJoLexz85VR3wXEiAUKBC5N4mrgZNNEbFG0wjJG0p06Wel2qzjdpmHTBS5bPJdZLMwGYRaJxXTX8FhtB/ajzaD+SbW5uyGvb08Oe/h2xr/yaJRDKl60HiGo+GNxePyJR80sAKeMZefUhGWYthsyKGWENEQoIrK9nz0UqYhIK2Hk5RPZ9No7Ud5iU1mpWFKEJqkgIweCRgjbzYCBQNGvfTpt0u2YETmc7TIdlNX6WLa1NrHyFFBbVLz9J5YAvk1roBEvl1CKXgM6c823b7Bh3iJsTgeDjz2U/EaMr50BMx95DiEFKhB9brqEhjEGr2lR1+oC+vZtw4BB7cnJdREImKxaWcafi4r5/j//o/fBY5I+fvexo7j0h48oXbWW2qJSMju1J7ebJfT1zqmXh7erT4dSRMp+uE1Fll6vFRCq0wgh3i9m+JpW7I05cMM2VH1/kiFtDj0nvz71ChNefyJq3Y+33s/C/70es4/Cen4S2bCao/lRhRmX3cSaD76IWuYpLuW3fz3M5u9nccSH9VonfzzzKvMffwFPkIzB2SaXva+6kAnfTmL5pE9Z9uaH1G4pCgsa9jn9BJ7ce1xcIwQsAooMXbLwgSdZGFyW1b0L4158lPbD9272uaSQQnPQ4+TjWPzcG5QvXg4RtQEhhBwaiZ63LJukzBc9onTKcaJFFEkbfiP8jjINEyHjs/mFnCQNx91QWpZTE/hMK9rqapPDydNaz8m2q8CRm91kPaAAjDoPUpMJ39cKhccIkQsoZATdslKK2oWLMP1+5J7OlBWJVGrWdiFliLQS2vXvTUbnAtwbt2CiqA2YUcWANmGFnXVheaSd6S7y4iixh1AwfG8qvvySvDTr4Q95qkL/56bZ6NEmjbUldfEbEIKMju1b5uTiNa83PSgJ3cZeh49lr8PHtlo/WhKmabL0q+8xA9ETR2u4iB3y3YbCocGhh/emW888DMOkptqLz2fQq1cu/Qe05csv5uP3eJudetOmV3fa9OoetWzL3IVR30O1KOHiQizb1mea2KWMYsfZXkhBfX1HC2LNdz9EfV/69sdxjZAQTOIbI5rLScEBI5t17PVfTY0xQiKxefpPLHnpbQZcdBaTz7qCdV9/H7XeU1rOr3c/yqYffubYD19irwvOiGnDWxWfkjlDs3RWGkY0q9Zu4KPDT2fCN2/RcdTQZp1PCik0B7rTwZGfvMKPf7uFjcHnMFJ0sDEjBCxveZYO1YZJp775dO7dhpJfN1hGjVKYATPKUWb6TTSHFiPiG/ru9wSwS4G/QThVCKseUgId9x2APeDn/a7D0Bx2uhx/BAOuuIDcgf1a6KrsOkjv1BFXh3Z4mnA4mkqBYYSFIUXEOyMsRosVJXebCqkUrmDqhhACf3klhVN/oOCoQ1v1fFLYc7DnmmA7APtedSEminKfGcNI4ldQ6TepDZj4lWKviSdjbyTcOeDYQ+mQ5UiYwiSEoF2mHVsc3ZEQhlx42jadRzJw9d+38beUkLgGDGm147cGlGHEGCGQQDVdWbPygYM70LVHLuvXlPPlR4v57L1FfPPJUj58+w9mTVvD2LHd8NdUt0j/DI+3vk/Kos4F66HWhPWxB9Oiks3JTgYSotSNk4UV2re8/hm6JQbZUHelIf3tr/dFR0fiIeb3EIJBl56DPUnxyBDm3t+4gCTAwsefZ8X7n8cYIZHY9P0slrz2Xtx1eb26R9Fzg3Ut0yJe9DFQim/Pv67JvqWQwvbCmZfLuEnPc8SbT9Cxe06zU2a79WvLiTcdxgHnjCavU5sIBTxiHlTTUPjrAlG04KFt/e4Apt8M647EQ+eBffAsXU7lijX4AwaV1XX88dYnvHfACXx44ARm/O0Wfr/vCSpWrG7WOezK6HzUIQnXhd4LUE9qEvo7zF8YoW0G1tgUMMFtRNcolv02vwV7vetDCRFmztr2z86Znr4jkDJEWhF9zpxAHbLRgjBP8PnOHdS4B6du2fKYfN2GkEKQ5YwNcglNo22/nux73qlNdXmbkT7sQITdkYBGSYCmkTEy8SC5M0Kz2cjr1S3mnCwWqug3q8cw0YRgr73bs2pZCTOmrKKy3BO108Z1FUz9agWlP87Y5j7569z89vgLvDzwEOzV1WQHJ/Qy5CUMlSVQz98PluGbTMWH0KTFrJbI4KX5BghY6WouLVoNWFCvthxCp9HRXv+QYnNjUATZqHQr77zvmRMYcfu1ze5j9ep1TW5TV1jM3P883eR28x59ls2/zGPq9Xfx+TnXMP0f91OyeDkjLj0ringArJz3piZ8dVu2Urp422peUkihuSg4+gjG/fg9mX26hpc19dhnd8lmwCnDsGelWV71SN2hBGnHylQE3AH8bj+G1yDgDRDwxDFO4qB65RqUqagLmNQFNZ1CpBwVfy5l1aRP+eO/z/LRqGOY8bdbooghdlcMvuHyuGNJ1LgbsVqFo9rRESkz+FFYxosnoML1OmbAYMmTLzL5kJPY9E1ih8wehVSNyHZhm87c6/Xy4IMPctdddwEwb948Hn30UYwEuc97KvweHx5/ctdk+WdTGl1v+pMbRGMCIkLQ97jDOOfbtxuNuGwvtIws2p57PcLpCh83NOIJm522Z1+Nntf6OiYtjf2uODfuco9pEsWWBTgcGna7zq+z4otIKgU+b4CZT7y2TX3x1dTy4bHnMuuuR6nesBmwPFe6sMSosm0aaVJaKsQQk/LgDdJFJ4LQNDI7tuPIx+4MLog/9WhuDbvAUlYO9Te8PFjIrwnCkZHhV5zXvMYB3emkxwlHMfCSiZw082MOfvqBpGmAo9CEUjFY51K9flOT21Vv2My7407nj1cnseLTycx77g1eH3UcpXP/pMfBo2NES5NB8fzFSW2XQgotAc3lYuC9d4S/h9izEnk0ehzWD2nTMbx+agvLUAFfo9aLECCksOoVVNBYMUPjgsW0pZSKn0oqLSYYr0lUTZxdWs6NEHMUSiGA1e99xqcHncgvt97Pus+/3W2NkrSCDvS/PPqdVa87Fru9EPVaU5ZopMWIFkkBDODUJV5TRaX3VixZxo/nXsXqtz5snZNJYY/BNtWITJw4kT/++IPhw4cDMGTIEEpKSrjmmmt4+ummvYV7CirXbUh61lb859JG12cN7B+kQ2q8HSOgyMnJIK1dPrrTQcHQQex71QWktc1LstfbDkfnnnS8/j/U/fEL3jVLAYW9ax/S9xmDdCVPXbszYdRlZ7Psm+ms+O5HlGmGX4pupaEZBnbN8sJbTFWwbnUZRiMUUUrBqjlLcVdU4crJalZffv3P02yd/2cMqUGoiFAXlrBXuibxGGY4ciOoNwD8ynIbaoAzIw1/nTvUCL2PPoQjHruTzIIOODIz+PbGf1O5fnOT/QopHkM0A1cItiQm2jYpcLZtQ68jD4parjkdUSlo8ZA/ZBDjXv5vk8doCm322YutjdACA2T37UnJqqYjJ/XFtkbU/wtfeZfRt15N55FDmPP8W3gqqpI27FxtcpPbMIUUWghtx46m/63XsvQBK0VSE4IA1hgSqhlRChyZdtLbZVO9YSu+iho0l4M2QwZRscFNycK1CduXcRwUoe9KKUyR4KVnmlY6asRYaBNEif02bLdi6UqqVq5lyfNvkN6pA+MmPUfugL7NviY7O4bcdROa08mSZ17B9FrGYGMjcH1URIV1sESQltmMrN3BcmaFI+3Ba//7LffQ+dhx2HOyW+mMdgFEOF63q409FNsUERFCsGzZMvbeu57JZdCgQbz77rst1rHdAc0RDxRaNJ3h5lm/8tVZV/BSrzE823FfPjj2POocWfh9BobfiClqVUrh8QbANBG1dXjWb6Rm6QpWTPqM9/Ybz69J5L+3BKTDScaIg2hz2mW0Oe1yMkcfxpaV63n7itu5f/hxPDz2FL59+DlqSst3SH+2F5rNxjkfPc/g08fjExJfkEvdEwigOnfiwEfuoPOYoWTl5uDzGRQX1ljUxI3ANEyqkkg5ikTA62PhK5Niaigi4TUVHsPEE9zGCH4CWAKHkfeMARzzwkOc/e3bnP7ZK1y5fCYnT/ofmQWWmF7f4w7jysXTOGfK24x/8aGoCEPkeOmUgjRdYgtGNRxxRpSmBhkhrNSy0TdcGrOuzynHNbE3jPn3TU1ukwxG3HNLk9sMveN62u7duJqwasBc1hDznnmNg269ihvXzuaKuV9z5PMPNXlcadPpfMh+TW6XQgotjd5XX8x+n75Bh2MPR0tzoQuBlCI8Dkhdo+sJR1BXVI6vogZpt9F+7Cic7drQ94wDceZlIuLULoaMjUQQQqAH0y1DB7PnZDH8P1aUxiTaRGlINxvTHqCCkZDaLVv5evx5eHaR91BzIKRkn9uu5aRFMxn24O1JEIqo4Dw6TtQ6sl0hUIgYKnbT72fdh1+2RNd3XaRSs7YL2xQR6dnTEgmLvGH/97//kZub8thFIq9vT/L69qRseRPFckJQMGJfAKrWbeTbc6+mMCINI0OXZBRuBiEIEasKKbCn29BsFuuIMhVbyz1A8AURzEMPUYX+/tAz5PTqTt/Tx7foOZqmSfmGzShTkde1AF9JKetefYdNH36Gv6KSNX6N+WuLkLoWLvxe/dNcvnngaa799k267QK0pHPf/Zxf3/o4ZnnZuk28f/2/ueK7d+g+egj3dxxGSXFtUlEwV27zvEfVGzbjS8C45DVMqoI0lyEPJQRViENFiFgFdXpEupbhD1BXUYUzO4u0dm1j2hVS0nX/Efyxal04lcGKsgTPQbO8lR7DyiWWCGxSIImOiiSbyTXwnFNilh30+N1snP5TjNBaCP3PPon2I/ZJ8giNI3/o3gz71w38/u/40ZW9rriArkcdiiMvl0+PPDPuNmGV+kZy4LyVVWz5bQFdDhhJuwF9aDegD/Me/h9VjdSoDLrkbDS7vRlnk0IKLYe8EfuSF3xH1a7dQNG30zDcHjL79abduAPxbljD2ntvwvAGMKu9rH5vMnq6i5z+PRhywwlsmbWUtd/MxQhpFAXRVG2UZtMZ+79HcBcV4+rQjoJxB6I57Kx9/zOKfvsDguTgMom2omCa+Moq+POpFxl+V8s4MnY22LOz6H3OKSz89yMYbk/C7RIT4BCOfIWglEJFpGyBZYhWr2k6SpxCComwTYbIcccdx1lnncXWrVupqKhg2rRpzJs3jzfffLOl+7dLQwjBgXdezydnX934hkox9LKz8ZSW89lRZ1EZIWSWqUty7bHiT8pUeKt92NNtGIaiptaHtwnVuLmPPU+f045vEfFA0zSZ8cwbTHnkecrWWTnzHQryGZ2jg98HhklRnZ/5hdbkOZJ9Spkm7qoanjzqXO5f9xOO9J03bcvv8fLJDf+Ouy6UqvXpjfdy/exPOOeTF3n5iLMQjf0MUtJl9BCyCppHpaw54k9C/RFGSPgYIqRWbhVwekwrPUtHITSBJgTSYeeDc68L75PRIZ/D7v47Q86NNgaWfjmVr259IGqZiZXa5TMV/qhzVXhMcIgIkhwhCCiFrRGxS4BuRx2CMzs2gih1nbPnT2HaVf9k1cdfY3itiYwrvw1Db7ycvS87p9F2m4vB115Cp3EHMeeOBymZtxAU5A7sy/C7b6bdcMvgaT9yCCPvupFf73oktgEhwmlxjaFhutmp0z/g/YNPpmp1bH1Rn9OOZ7/7/rGtp5RCCi2K9O5d6HlpdB1C1e+z8VVb97QyFYbXwFtVQe2WedjSl9Dt+LF0O3oY66fMZ93Xv+OvSTwxjoSemU6X4w4Pfzd8PtZ+/BW23BxQpkV/38yatUgsfvYN9v3HNejNpFPfVaDZ7fQ440RWvf5eQv2ixpAoMy4SylTYM5vHULi7IcR8tb1t7KkQqrHYaCOora3liy++YN26dbRp04ajjjqKTp06tXT/WgVVVVVkZ2dTWVlJVlbz8vS3BfNfmcTk6+4M54k3xH7/uJID77iOuQ8/w28PPIUvmFojgM4uPaHhoACCxXzVfpPaxgyRIM5dOpP0Du227URCx1WKty6/jR+ffydq+cGdMslNtyGD+aU/b6xiS62/0XHs7OfuZ+ylZ21Xf1oTCz76mldPu6LJ7f7x53e079+LrUtW8M6pl1Mer44gWJx97lev0eOg5EUNwbrmb4w4hvIVa6IiLmW+gCVSGJ/1FYCagKX2brFUQaauWRWKcX6Yox/9F6OCBfpzXnqHz668HQCHiGZ2kjSuR+KUVrFj7r4DqSsph/JylNcXwxiFEAgpOXXqe7QbMih+YxEI+HxIXUc2YdjsCJQvW8ns2x6keN5ClIK2++xFnzMn8OXFTXhYheCSpTPCaXCR2DhjNvOeeBFfRRVZvbox6o7ryeq6a4yrKeyZUKbJokvOxKiuwvAb+GviC6J2PmIkbQb3wgwYVFcoKkskKx59JmG7QtPofsFZ7HWn9TyVzvuT78/+G56tJQhdt+pETBNTKdyGlRaarJMtksjjgKcfoPcZE5p30rsQ3EXFTDniNDxbS6KMEZXgvdEQkdMKFRRSbph9fNQPn5HdL7EO2vZgR8/XmoNQ34rXLCWrGan48duqJr9H/53yPFsb2yxomJ6ezumnnx7+XlhYyOuvv86558ZnGdqTse8Fp9P/pGOYefdjrPx6KtUbt4AQdNlvBCOuuYA+xxwGwLK3PsKImKilaY2PEgLC7u9krclk2bcaw/Lps2OMkP75Ltq1dUXl/Q7vns2CzTWsK4/v/RJSsuS7WTu1IVK5qRAhZewEugEqNm6hff9etBvQh6vmfcPXf7+H319612Jt0SRmwMCZk8WE5x5sthEC1gt25E1/Y/Il9ZNcM6jknngf68Xh0AT+gHWP2KVFJx0vaqOU4utb7scwTaq2lvDjf/5HqIDRALSIl7dJPS99WPAsaBQbCnwmZOhw2kcvkpbfhppNhXx28sWULVkRptlVhonudND/zAmsmzyd0oVL6TXhqEb1P/SdKD0pt19vjvnwxahlSil+efxFSpesjOuBFJpGz6MPiWuEAHQ+aAydt+H+SCGFvwo1fy7AqK5CmSqhEQKw8dtfcbXNIa2gLbl79yZ/r7EUfTuN6sXLY58VTaKlp9Hj4okA1G4uZMpJFxCotQR7VQTrlRQCl2ZFZyPHqIYICb7Wj5kWwcfazybv1oaIq30+475+h3l3PMimr75rtM6wIRq6qUXDwncp6XLc4a1mhKSwZyApQ2TOnDmMGjWqSW/DfvvtlzJEEsCZnckR//0XR/z3X+GJesPr6Sktj3rItWakUNkkoXTZhHDltyG94/ZFQwB+eO7tqJqPjll29i6o9wYYCuZtqmJNmafxcgmltilcvCOR2T6/SSMEIKtDPTWxZrNx3JP/5sBbrmDJZ9/ira6hTa/u9DvuMHTHtqcA9D99PFXrNzH73icAFeXRsgtwShlmqAooS4TKqxRakG7NGaS2jPccG8pK48Ln54u/3xNcqpCE2lP1dJhByl2tQbFpmHElmC6hZ2TgDNbCpBe0Z9jNVzLz9v+E6z3saU6U18eSV99DahpmIMAPN9/DfvfczKBLzt7m6/RXQgjBMS//l0lHnImvujbq/haaJKOgPYf9986k2ipduIQ1H36Bp7SCjK4F9D7zRDI6F7RW11NIYZvgXrMSpIyp/4iBEBTPXUa3jm3QOvVD6jqj3nqOuVfcTOmPP4OUliPLMEjrVMCwFx7D1akjAMteeptAXV3CsVgKQV7/PlSvWY/yesN6IiGYQarfhggoWDfzF7yV1TjipIbuLkgr6MD+Lz2OZ2sJW77/kdlX3waADA7fiSLqKvy3CtI3C6RdB8OKRnU94ShGPH7vjjmJnRktUWy+B6dmJWWIjBgxgltuuYXLL78cpRRPP/00J554YlQq1sqVK/n9999braO7ExIZdBldCvAtWRF2QxjNyJpzSkEVjURGpGDQJWdvm75CA2xetJw0u2TQ4LZ07ZhBjkvHqPPjLnXj9xr8sLqcrY14xiLRa//h292f1sRexx6KPSMNX01d3PVCCDoM7EuHgbE0kFmdOjDqby1rmI+86W/0PekYFr4yiRWff0vdirVk6jJstIZeHjqKLJuG24BKvxncJv69FzZC4sDEelkJAT5lUTfqSqHJ+ErgImisSKD7ceOQuk7A42XyFbey4N3Pw/enUwqE24NfWccXAcMyojxefrjpHvT0NPqfdWLLXLQdjLYD+jDxx0/47YkXWfz2x/hr3Thys9n7/NMYdvVFpOU3TqUd8Hj54W+3sO6zyeHoEUox/z9Ps89NV7DvzVe2SJ1XCim0BISug1IYCVKPw1CK6rVbkPldkXmWgWHPzWH0O89TtWQ5xTNmYfr85Ow7mLYHjIrS2ln78VeNe/KFID03iwkzfmP9V1NZ9uokqtasp25TIWYgENcICcFX6+aXf/+XAx9NzkGwK8PZri09zpjAyjc/oOS3BZiGgaQ+8iEEEUacQgX/SivowL7/+jtCmVSvXIOenk7n48aR2bP7X3IeOx1Shsh2IekaEdM0w3nZTz31FFdfHVuAPXLkSH799deW7WErYGfNOfzz+Tf46R/3EzBMQnJ5nVx6QkV1FUzJCv2APlNR5ovNwQdF54P245hJzyYsem4OXjvyJIa19yE1DSE1pC7RHBqGL8D8WeuZ9mdxk20IIbC5HDyw4WfS83K2u0+tiZn/9yofX3d37Ipg3cSlX7xC/yMO3OH9+vPld5l+/Z0xwoVKWR5Aj6nwK4XfDLFaEeP6UqphwXl8yIhdnVJgE4nVwENDyjkzPmDlpM9Y/Nr7mD5f+FhuwyRNCtxmrOFsE5YCe0ZBByb++T1SiyVq2JWglMLw+dHstqSNhx+v+Scr3/kkzHzXEKMfuZP+F5zRgr1MIYVth2fzRpZddwneKi+qiTpFzeVk2CdfIGTznuv3+u2Pt7Ss0W1yB/bnuBnR7IbL3/iAH669nYavxZh+OR2cv2LWHlN0XbtxM1OOm0jdlq0W5T/147ue5mLwrdeSPXAAAY+b3L36kp4glXRHYGedr0FEjci6lS1TI9Kt9055nq2NpN3jkcWhCxYsYNOmTeGIiFKKZ599ltLS0pbv4R6E/hNPYdlbH1OycAkqyLxT4TfJi8eaFZzsBUyFbtNRhoFdCvLTbIjOnakoKiXg9pDTuzuDLjmL/hNPRrPZtrlvNctXsuGdSZRO/4GulRWUVUmkrlkqrLrEmePAkeNi75GdGDyigNIKD38sLuHP5aVx07OkTeeyD5/d6Y0QgAOvOh+paXx5+yN4KqvCy7M7tefUp+/7S4wQd1k5M2+xQuINJ7gBpagKRDM3hchPGk6Fm0o6Cxm7kaKIoglm+pAC83fnX0ftlq3h9CQhBLYgc1ddggmLX1m1I2JLEVt/W0CHUUOb6OHODSEEejOM/9rNRY0aIQB/PPosfc89dZc30lLY9aGUwp7povMpE3Bv3Ej16k1ULV8bn8JcamTuM6TZRghATv/ebP35t4RREaFr5MaJSvc+60QW/N/LlCxbTcBUuA0zzLKlC3BqVjqr4fFSuWod+fsObHbfdkWkdy7g6GkfsfLVSax6+yO8peWkFXSg97mn0uvsk9F3YibLnRKpiMh2YZvydG666SaOPvpopJSkpaWxatUqKisreeONN1q6f41izZo1/Oc//2Ho0KH8+OOP3HPPPXTr1m2H9qEloae5OOjZ//DufuOtH0ZAbcBSkM2xa1E1IybgNazi4MOnfkTdOov2M2/oPjjy27Rov4omT2HRLXeE83eRAsNnInWNjI4Z2DMdaDYdZZqogInXF2DTpipKS2rJduq4vYGoIkHd4eD2BV/RoV+vFu1na+KAv53DqAtOY9mUmdSWlJPbtRO9Dx79l00Gl7/3eVjbIxJmhBESKh4PQal6wwIaFxoMmApPg2J4hxS4NIEK1qeYWHoZoeidJgSOIFuWTZPUbC6KmVALIfAGGjd/AsF0LW9ldaPb7Y7Y+O30JnVo6rYUUfbHEtomwTKWQgqtBeVzE1jxK9RVktWjgMxu7Wk/dgTe8ipWv/kZ7i0NIuOmQYeTYrWCkkG/C8+kaFbibAsVMOhzfmyUUGoavU6fwMa7HqWuwbjjV+APmKRpAqcmWyRbYFeCIzeHgddfxsDrL/uru7LLQwnRAvS9e2667TYZIv369WP+/Pl88803LF26lIyMDI444gi6d+/ewt1LDNM0GT9+PE888QSHHnooPXr04IwzzmD27Nk7rA+tgfmvvEed3wDTREqB31SU+GCdO0CmLnFIS+DQLiVIQe7A/mT37012/9ZhrfBsKWTxrf+yqBIBpEB36bhyHKS3z0DoEhD4azwIKXB7A3z81Upq66JZTezCmlz6lCC/V9ddyggJweZ0MOj4w5vecAegYtU6q8DbjDZGPIayakGUIpKrLGQ4RCKROeA3FXVxPI++oEhfQJnYhECPGHc1ARm6CBawW8c3jFixMaVUU5wK4T5kde8Sd12gzs36KTPwlFWQ2bUTnQ7eb7eJDgTq3E0qTgME3O4d1KMUUqiHCgQo/m4qmz/+GM+a1bQZMYiCcWOw52ZZcVLTxJ6dRZ+LT2HJE2/gr6oBTQPDoPP5F5E9ZNsinF2PP4JuJx7Nuk++jqYdD9akDbj8PNqNHBJ334xe3WKMkEjUGYrMdrnk7oLvpBRS2B2wzZXLUkqOOeYYjjnmGADcbjcffPABp5yybR6P5mLy5MmsXLmSsWPHAnDooYcyYcIE5syZw4gRI3ZIH1oafreHP156B5TCD/gbpK9UB0yqgTKfSSeXjs0UdDj8IJRpRhX2tSQ2vf8RKkIlWnNouHIcOLIcmKYJbgPdaUNzWLdSuk1j4mkDKSmt4+MvV2JG7CuxagD2v/j0hodJoZlwZGXETFatonOFBniiuN+bTsGq3za+ESIJKalbRoceQSSvCciOsEoaOnZCAohgyZekayIstJgIznZtye3bM6ZvC//3Gr8/8BT+mtrw8rQO7djvwdtoP2oojpzsXVqcLHdAnyZZ2oQmye7dYwf1KIUULJg+H4tuuoWKX38FIehx5jF0OHC4lUoZcjRIiXA40DRJ+0NGUzjjNzIHDabDhJPI2mffbT62kJIDnn2Y/GH7sOTZ16gNMu9l9erOwKsvotdZJyXcd8XkGfUqrxGQgC6t/6u2lvLWQScz9MrzGXD6+BQZRArNQyo1a7uwTYaIDNLsNcSoUaN2mCEye/ZsevbsiS1Y96BpGj179mTatGkxhojX68XrrVcyrqqqYmfE4nc+wfD6UJCwgDjHJsnQLI+pXwjmPvwMy9/9hIOee5gOo4e1WF9Mn4/iqd9T+Mkn6A6JMgVmwMSeZt0y0q6BodBd0XUnZsDEDJjkZTs594yBvPbOnxGMHAJdCEaedUKL9XNPRe8Tj+a3R54Nf1dK4QkaropowyPRdN+KZVnbhrbxJ/DEuzRh6YZI6zeMLJB3BY2Sxl7eGgotKHSpBw2aDATVAYU3jkHS/7TjY5YtfPoVfr7joahlplKUby7i83Outc7JptPv1OMYefOV5PTsmrA/Oys6HjSG9C4F1G4qjFsnIjSNrscehqtd27+gdynsyVj34ktUzJkDQN6Q/mR270jxrN8QUpLZpweOtrnhaJ7QbbQ7YASdrvpnix1fahoDLj+P/peeg3trCUJKnPltmjQa1v84J8YI0QXYZPQ4VvzHEr655CY2/zyXwx67K2WMpJA8hEhOHbKpNnYRBAIBPv/8cz788ENWr15NVVUVnTp1YujQoZx33nn079+/We1tkyHy6KOPctJJ9R4I0zSZPn067du335bmtglFRUUxzALZ2dls2rQpZtsHHniAu++Ow3q0k2HhGx8CJKRSzbVJ0rUItqLg4FqzqZCvJ1zA+CmTaDN4wHb3I1BdzcKrr6Vm2TIAhLRUjHRdx1frp2pjNXJNJWnt0sjqkoXNZSPgCVBXXIe/tp62V0/TOWhkAdN/2VzfuFJUbioiq31+w8Om0Ay0HdSfnscdzpqvplrqwgSL0YWIoX1ueDtpWC9iEWFQmABOJ57qWhrCISFd06KiIKH6ExNLmwSsKEdIvT2UomVgUfmGdo1m91Jk6gLTH83cJTSNUTdcGtUHX3UNc+5/MmpZPG0A0x9g6aTPWf3lVE77bhJ5u1i6hZCSg55/hMknXoDpDzTQIdFwtc9n5H23/YU9TGFPhOn1suWjjy0dISkwKstZ8b8361kwgKwBvel66rHoLqcVrVXJC+c1B0JK0jok1sOqWr2OZS++xfovpmB4fThr63BKEY7ACgjrLUWNR0HD/4+X3qHTmGEEqqopX7EGW3oavU44knZ7SCF7Cik0hmnTpnHHHXfQvXt3Bg4cyJgxY3A6nVRVVVFYWMhll13GPvvswyOPPII9SQHibTJErrjiChwNhNl69OjBsGHDwqlarQ2bzRaOhoRgmqaVLtQAt956KzfccEP4e1VVFV26xM8//ytRs2UrQFw1EF1YtSFxYZoow2DeQ08z7o3/2+5+rHjwP9SsWBG1LMyYJAW2NBveSi9V66uo3lhN24Ft8VZ4Y2a83ho/troAbdNtlNb6w6tTnqaWweEvPMzUK25l5cdfY0bOCBqBRv1LGMAmZb1R4vPi1SVeX/3kVxOQa9NjeLKEEGhYtSAKgSJEvRuxpQAbImFaWMgQStclFX4znD4x7qF/orxefr/9Qda+/zn+6mpsOdlIjyeqviQRJacyDHw1dUy58jZO/25Sk9dkZ0O7kUM47rv3WPDf51j36WSUYaCnp9Hn7JPZ+/pLU9GQFHY46tatw6itBQGOTDu+ikprRcSQU7V0FatfeZ8+l52N0OR2F+8mgr+mlmVPv8KW738AoOO4A+l/1UXoLidbZvzE92f9DRUwwka8LgTtnBrVfpNyv4kuoCHleSSklEy9/GZQIHUNZZrM/e9z2DPSUYaBIyeLfmdMYNClE8ko2HHO1xR2YvwFqVl/BVnTpEmTqKysZPr06eiNaNItWLCAf/7znzz44INoSdRvbpMhMmlS7Mt9wYIFFBYWbktz24SOHTvy448/Ri2rrKyMElkMweFwxBhOOyMyO3ekZnMhwoydVKZpstHBUxkG67/+Hl91zXZxoXuLiiiZNj0hc48QVrG6t9oLJihTUVtYi9AkpmGCsgypzaVuCks9mKbCDnRw6NQZCl9GOh32ap3C+j0NtjQXR736OBV3XMeMOx5hyaeTgfp6jBAi7yY94vaxSxFVSC6EIEMKIhMXs3Qtirq3IRzSal0XgjQ99h41myi6FkJgE5Y2SWaXjoy643o6De7PF2NPIFDnBsOwmLaKS7FLiY7CbShM1Yh4J9bzUPjrfEqXrKDNgD6N9mFnRO6Avhz8wqMY//cA/tpa7FmZLSJGmkIK24JQDaLu0EEE6bxt1jJlKks/RCnqNmymatkqsgb0RjjTrfVK4S0uwfR6cbZvh2zCS2p4PGx4+0PWv/Ue7o2b0TMz6HTS8XS74GxK5i3kp4uuh4hIYdm8hSx+7FlG/+8hZl1zO6bPH/3+Cv6daZN4TUUgrBJen5oaPk9AUyaY1hhm+gNhdkF/bR0CqCssZv5TL7P4tfc49v3nsWdmYM/OJL2RKE2oni/lhNs9ocT2G97N2f+vIGsqLy+nS5cunH560zW+++yzDz179mT27NkccMABTW6ftKBhJAoKCujXr1/Usry8PP7+97+z3377Nbe5bcKsWbM45phjqKioQAiB3+8nJyeH77//nlGjRjW6784qkLPwjQ/55m+3WgXDDfLmQ7UhTQ1kp/8xjYzOHbe5D1snf8uyu5pOY3OXuTG8BppDw55Zb+QppVixsYrK2lhqWaUUrg7tuPzPqdhczm3uYwqxqN5cyDP9DgqnF/iCL1yXJnEEDQ4VXO4zLb1chxZ/4Nvq8VMX3KaDQ2/0nkvTBFII0jURV7m9KYNBD01qgvuZdgderw8jWDBvpXpZtMChCIpfQV3ATEqI8ZjXHqfPiUc3vWEKKaSQEKbfzy/Hn4AuPOhOHSFjmd1Mn4lSkD2wLz3OnoAo6E/J78tY/exL1CyzIuxaRgadTzuJHpdfRNnPv1G3bgPpfXqSf+B+CCEI1Nbx61mXUPnHIqvR0ARe05AuJ+XFFY0Gfn2NEGAoZdXA1QZM0jQZTjW1UjwtB0fD8ShkrCRjQHQcM4wRt11Dp7H184+S+Yv48/9eYsNXUzF8frL79mTAJRPpe84pKcdCkthZ52tQ37eiLZu3u29VVVW071iQ1Hl+/fXXnHTSSVRVVWGz2TAMg6ysLKZPn96qZE3r168P/52Xl0dGRr3T2zRNNmzYsE1RmW16EqZOncqAAdG1CDU1NVGdam2MGTOGgoICfvjhBw488EBmzpxJ9+7dGTly5A7rQ0tjwGnHM/+FtylasAi738AXMdBbef+ND4ZKwbcXXM+Rrz2+HUqozbNLbenR6XHl1b64RghYg7lnawkLX/+AoZdN3Mb+1cNXU8umH38lUOemzcB+u1w9QEsis6ADg86awJ9vf4IyTWwCMnQtOuKBVe9hlwKfqRJG2No6dIp9Bj7TbPQFbNV+WOsj60eSha1B3YjXUATqPOG+quDH8mJCulYviigFOIL7+eIotIegp6WEuVJIYXshbTYKTj2Zsi8mWQVfQli1tcEHTymFtEsMr0Ggtg40Gxu+mMGKhx6PKsI1ampY98obrH3pdQxPBMW7y8WAO26kZtkKKhcujonIK8PAXVHd6OvJaMQIAasbOoIsmxZlREkhcEorhashcUayRghA4a/z+PyECzjy9Sfpcdw41n35HdMvuC7cf4DK5av5+aa72fjtDA59/UnkdogMp7AToQVTsxqSKcXL6GkOWVNLonv37uTm5nLHHXcwceLEqDm/lJKXXnqJCy+8sNlSHtt05aZMmRKzTNd1br755m1pbpsgpeTTTz/lxRdf5Omnn+aVV17h448/3qVDn7rDzmlfvMaA047Hrms4RL2GdW2g8UE2RNFaNGc+bw45guoNsUX7ySBr8OAmt1FKYfpNpE1G0QYrpVhXFFvs3LCjf7yyfXn7pmHwy31P8HKf/fny9MuZfMH1vD3yGD488izKV67ZrrZ3ZRzx+N30OvoQABy6hiQ2ghZKSbDJxNE1KQTtHTrdOyeX/xxqRQXpgwOm9b9SKqHprDUwQnymChe7hz6aqB+gDFVfE+LUJB2dOgUu69MlTSfHFjuU2TLS6Tx213VMpJDCzgQNL0KXSE1aD6gUCM3Sswo9x9Km4WiThz+tMysefsLasWHShbJcDCIiT9R0u1l02z2se+uDuGxxYIkPJoKRhD6RUiSsU7QYHaNTV8N9C45pATOYEtrQSAouMwMGpmky7ap/UldUwsxLb7REfiPSyEKd2DhlBktffqeJHqewq8ASNNz+D0CXLl3Izs4Ofx544IGY4zWHrKklYbPZmDJlCtdddx1t28bWKt522208+eSTcfZsHM2KiEyaNIlly5Yxc+ZMKioqotaVlJTw7rvv8tBDD8XfuRXQt29fXn/9dQCuvPLKHXbc1oQjK4NjX3iYg++9hZ/ue4I/Xn4XA2v8chuKNF3EeLJD42KIbcv0+vjq9Ms5/afPm318Z0EBefvvT9nPP0fl4dYfSxFwB1CmQnNoUX2p9QQIJKL8ikDV+s1NbtMYZt50D3++/E6Md6xwznw+GHcGp8/8iKyusbVCuztsLicnT/ofK76YwtdnX50wgBYqNDdMMzFloBC07VqAfehgVk2eEXcTk2Dus7CEN6N+DgUGVtRDE7FMcJGRGkv/JHFXtOCxfKYixy6j9gWLoSvHJrFJQbG3/p4dft3F2NJc8RtNIYUUkkbtssWUTrbeJ0KCiHByKAVKYD3wUpF/yrls/ur7uNodkZC6xAg0eMcE4kfTrePEb0sFx4+moBpEcEJmTaSBogVZB1Vwub9BG6GAiQ0VThWNMo+Uoq68gulX/APD62v0/Bc/9wYDLj1nl3aeptDy2LBhQ5SREa++uTlkTS2JI444gqFDE4uSOp1OKisrm91usyIi48ePZ+3atZSXl7NmzZqoj2mavPNOysJvKaS3b8u4J/5N3/FHoAuBTYpwbnzk0BYaRBvmy5ctXkFt4dZtOnbf22/D1aVLFDd22OvjN/FW1WuyKKUIeAP43QEqGyw3VHwPkiN323Mpy5at4s+XYo0QCLIlVVUz97Hnt7n9XR1CCLQkQ8QhT58/+GmY2jDg1ONpv1dfi3Nf1BsVkQgoSyOk4c8hsOpHHJrEJoRVGB9JqBVxX/kjhUwatKEJ0CTYpCU+VuM34mZnCCHI0CUumwZCMOTK8xlx4+VJXYcUUkihcRR98DYAUoulvbWWS4Qm0Bw2Nr34JFXTPyW9rQtbus2if28AIZqud2wImWD75MVag9srhd2ukZFmw+W0iu9DaaAKK1occn4kgl9Z7TTcxiYg2yapmvkTLml9j9trpahZt5FATV2SvU9hZ4ZSLfMByMrKivrEM0Q6duwYk8KViKypJZGbm9vkNkVFRc1ut1kREZfLxcsvv8yqVavo1WvPzcffURBC4NtaQpZNBsPCll0QUCBCnp1G9i+cs4Bexx/e7OPacnIY8vKLFH39DUWff46vpBSloHrVRgyfZfkopfC5AxiV9bS9mUAHh8Z6tz9aFwJLW0IPvkj6jj+y2X0KYek7nyA0LTrcHQFlGCx5+2MOfPiOPbYYsKm8Y6UUnmAEQ0S8KJWyCtntuk52lwKWfvAlhfP+jJoASGXVZwRUff1GZhxaaadWn1YYisBoQQ+iAqTLieH2hF/+Dd/W9UWi0ct9Csp9Brl2LXZiIgTdBvdj9CtPkt1j56PnTiGFXRGGu47qBb+Hn8V4aU2aQ8du1wn4AviKCpFSkVGQScDjx13ixlPhwWyQWtVcnhybTRLwxovSJ7d/Vq9ueDdsJDfLgR7B8GcqRWWNj/JqX/05J9Few8Nm6pL0iHaVUtilwI6VzRDPsBG2PfMdtbvBDDpdt7eNZHHwwQfz0EMPhe81v9/P2rVrOeSQQ7arD01hzZo11NbWkp6eHnf91q1bowrak8U21YgkMkJeeOGFbWkuhUZQumgZEsu7nGmTZOjSUram6bJyzb7thXCay0XBSScy5JWXGfX5p4z+4lNGvP0KHU84mrQe3dBzcjG8RrgThlKUewOsrfPHRGdCE1Z/0JIacc2F29yvZKI8hseLL44w3/bCDASa/fL8K1AwZhiaMzFdtSdOoXqobsSlSXRlUre1mMK5CyEY0Qp9QnuEcqntMnZiognL6Ijn8RRCIKVEdzoQjfCLSxFrhIRgYr3YY6AUaZnpKSMkhRRaEKbHIpAgghVPCIHUJZpNQ7NZWhvusjo8pW78dX4C7gD+Gh8qoHDmOnHmRLMkKhWk/G0GbDYdW1os22KygZU+Jx1F21wnWoOojhSCnAw7eVn1Y2Yzu4ZTCtKDDpnIaxT629kglCw0jQ5jR6E3Mk6nkEIiRJI1ATuMrOmYY47h2GOPZVlQ7DoSq1at4vjjj2f8+PHNbjdpQ2TYsGG89tprANx9991omhb1kVJy+eWpVIiWhu6wY2m91Q9k8QrqYiAFHUclzuXbFuQM2Zt9/nsfI998Dk9xWXi531RU+v+fvbMOk6S6v/7n3rL2cVt3hcV1cdfgGiQhkEAgJCHyS4i9cXcjhCgEkiBBggV3X1h83Xdnd9xaq+q+f1TrdPfMyqzS53kGdkpu3aop+eo5LhuSzpCRpKRSzL7wDEIt5fnWh0OwqWE48jA0y8IMl/bYNxXJvn5e/8nvuW3WYfylcTf+NmYvnrn2K/TswE3xViTEHh//cMkvtOO6RU6IxNMD0TIUugpSsUS2vA48J8XSJKYmMaVAlwJNSmSJMrBM5qMslCLV1YMRCSFLOCOC4aOccadEfFFKzLrhU8cVVFDBxkMPR5A+f4GorRyUBU0NpLzAVCko0CwN3edF/zPvhsEZEgCkZMz5Z3rHybwb0oQokVnTOfHFh2g59nDy6zzLlWxlIDRJ8+EHk1zoGU/lAiRVQQNtI9n/Bm+VyYSU3FZ4FOf5323lOOz+6Ss26lgV7PhQI/SzsdheZE1f+MIXiEQi7Lbbbuy///6cd955XHDBBey3335Mnz4dTdP4yle+ssnjbnRe8Ne//jVTp3rCYBnarrPPPju73nEc/vGPf2zyBCoYGhM/dBwLbr0L23WzOg0ZNqGhalinnn0KVvXIcG6nurpof/QhYsuWIg2Dgbb+bOpZKUWf7eIqxcBGhJFqZk/bornMuOB05v2ifOZNaBozLjh9RMqyEj293H/yRXS/vzirz+HE4iz6590svfMBTrz7LzTut+cWH2dr4OBvXEffqnUs+s+DCF1D2Q5C00g5LoM/o2b641vYe+SVEmgCjEGZE5FuQg2YGod//3pe+tJ3Nnl+QggO/+svee3rP6b19bcLIpClSrIGI9MoX/DidV3Gnn3qJs+lggoqKA+h69QeeSwdD9+HkF4/CKTfA8JjztIsA7BxkqWdEd2nIw0J8aHpcMdecBa7fferjD3vDFb96z9El6/EqKlm1Gkn0nj04UjD4LB//B57IErHa2+iUNTuuRuvXP89lv77nlw3eXbyXpHnrCsv4b3PfH5YQy3k1+kZSBWIwJa+KLktMtnkDDIOiSL3vlTKK0120sc/4EdfY/SRc4ecy+ZAKUXPm2+z7p4HSHZ24WtpYvRZpxGaMmnEj1VBDq4qvvU2Z4xNwbYma4pGo1iWxb333suf/vQn/vSnP/HAAw9g2zZTpkzhW9/6Fp/73OcKelp6e3s3Sl9lswQNu7q6ME2zoE6sra2NeDzO2LE7flnEjiyQMxid7y/m9sPOwE3ZWCItuJR2AuJO6VrWpv325EP3/W1E0r4djz/Cil/9NG2ICy8S5TjYcZv2hZ0MxFJEHa/sak28POMJgDR0DvjkpRz/gy9v0Zwev/arvPv3O4rC5kLTMMMhjzVr/JgtOgbAc5//Jgv+9i9Uiei7kJJAcyPnzn+sZFR/R4BSinUvzePdW+6ib00rweZG3rrjflLRWHYbTXjZEKVy91JG+Au8kgNvO+H1+aS3VUphI6jfazeiK1aR6MoxZfh8OrW1PlDQ0xHFtlW28TxjCFj1tZzx1pNIXWfdMy/x2Mc/T3R9OyiVTdMOZTMIPL2T7O+aRnj2dHb75v/R+uRzuKkUNbvPYvRJRw+r5LypSPUPsPjv/2bJzXcQbd2Ar6GOyReeydSPnIdZXeU9K5vRjLs5cFIplj34BK2vzkfqOuOOmsvouftVmHgqGFHY/X28f82lYCfTHCYC3W8i8jIjQgichE20fQAn5XiK6xnrSnhZk1hnLEdU4SpSAzleqlFnncoePy0MarjJJAOr1iI0SXDcmAK6+Hw4ySQvf/HbLP7Hnd7hNImyHay6Gub+5vtUTRzLi6d5itBKKZJJh1gsRSrlaSX5fDo+n0Z/zKazL+mReAxjGfnCQVL9Awigyadn+99K7SYBaRpM/ORlTLvkHEJjRg09+GbATSaZf931bPjf414fZaZXxXEYd/F5zPjKF8pevx0ZO7K9lpnbyrWtIyJoOG5U8w55ngC2bfOjH/2Iz3zmMwQ2Qp/rlltuYcqUKRx44IHDbrtZjsj3vvc9rr/++qLl55xzDrfffvumDrfNsSPf2KWw8tFnePiSa7FjcUSa0QPXxddYz9QPn8Xy+x8l0dtHeNxo9v7sJxh/3GEj8sLpe/tNFl7/+ZJ1Mh5blsOyN9aTSOtGrIoN7YgITeOIr17L4V/aMu/ddRxe+s4vmf/7v2HH4tnlTfvuwdG/+/6ICBsm+/q5dfpcnHhiyO2Ove33jDt+6zaIjSR+P+Mwelaty/5uCYGhFdLvuq7CJpcN0aUn+OVp1YhsJk5SmJEwLI0pezRS1xJioC/JwtfX09uZ+/sIvFppU5fs/sVr2P1zV2XXJXv6ePFrP2TRLXeQZgQeEn5NEDJ1Mjyb9YcdSLx3gM55byJ0jzlLpWysuloO/NPPaTho3y26bhnE2zt59EMX07t4eeFzIQS+2hpCY5rpeus9EILGg/dj+ic/wqhjDh+RYw9G62tv8t8LPslAaxvS8K6Fa9s0zJnJqf+6gfDozRU13XwMtG5g8R33E23rINjSyNSzT8FfX7vN51HByKP/vbdY8b0ve05IwERossjhVUqRituk+lOe89GfwM2j6E32JUnmNYVbY8dRs99+TP7UFVh1ufvESSRZ+MsbWfKXW0mlgxz+MaOYdvVlTPzI+WUd7YE161j1wGOk+geITJnImOOPQDNNUt09PHXocSjHoa8vQTxeOnMjdElf3EYJsIWGbTtFzzlKsdfVH6F26kSe/Ow3AKg3tWHfWRI44YUHCE+eMPSGm4l3vvYdVv/7P2XrWqdedw2Trtz8/szthR3ZXsvMbcWadSPiiIwf3bJDnmcGbW1tXHnllRx33HGceOKJjBs3rmB9V1cXzz//PH/96185//zzOeusszZq3E1yRP785z/zj3/8g+XLlxfJuHd0dNDT08Py5cs3drjthh35xi6HRE8fC/91Dxteewupa4w95lAmnnw02ghHe/Ox6JtfoXfeq2UFpgDWLOigs8OLsK+L20XKtIPxqbcepW7KhBGZX7K3n9VPv4gdj1M7cyr1s6ePyLgA7W++yz1HnDnkNkLX2OsLV7PXFz45Ysfd2nj9Dzfz0Ge/mf2Q+zWBJMeCBWljIl1KoAsI6h6/pZ1X0jU4a6EZkj0PH4cvYNDXFeft51fjOKpkurlh6gTOeO7eonv36au/zOJ/31uWES1zQF9dDUf+5nvEV6xC6Dp1B+/Py5/8Ij3vLSreV0qkaXDMI7cTmZZzULvnv8O73/oJ/UuWI02T5hOOYsb/fQo9OHSk55nLPsPqBx4rOo6goGzdW5Zmd5vz1c8y89qRrQfvXbGaWw76EHYsVpSxE5pG1YQxfPiF+7ZZM6xSipe/8wte/8UfQXkRaddxkVKy75euYe/PfaKSpdkFsPAzH8Xp7cQIlL6v9KAf3WdmA2FKKWJtfXQvb8vep/GuOHbMBiEITZ3C/ncUlnS7qRQvXPRJNjzzQsl6lUkfu5A9vlu+Dr37tddZ/c9/0/PGfITUqDt0LmMuOJfFv76Blf99lL6eeNl9lVJEESAkx938a9a/vYD5N/yd6IYOBNA8vonGpmp0TeAb1YJb28Dr/7yfQDyGmWYKzLwHXFWcHTn6v7dQv//I9m4CJNraeeqwE4d8d+qRMEc89z+0EnSwOzJ2ZHstM7dlq0fGEZk4Zsd2RMDLjPzgBz/gD3/4A52dnVRVVaFpGj09PQghOOuss/jGN75R5CMMhU0qpL/sssuQUvLggw9y0kknFawLBoMcdthhmzJcBZsAqyrM7h+/aJsdTzkOva+9MmTXsFKKSK0/64jUGJLWMg2LQgrmXHD6iDkhAGYkxKRTjhmx8fKxUQ6eq9CsrecIbg3s/pHzeOxL38dOeiURmRpmoYq1QBQKPd1oOZiOebBNOWpiNRJY/lorPesHCAgBuicOFncUtso5Lx3LVpHqH0CrLbx2y+/739BOCN7f/JQH/kHVlInZZWsffJzut98vvYPr4iZTvPbZr7Hb56+i/rCDeeO6r7Pq3/cUbLb0jzez7C+3cfAdf6LugH1KDhVdt55V9z9a0jEv1eOaOZc3v/Nzmo6YS+2cWUOe26bgjRtuxo7FS5YNKsehe8kKFt/9EDPOP23EjjkYruOw5onn6V60lLXPvsLS+x/NzSF9jVzX5eXv/AIzEtpq76+B5atY/ud/sPbeh3CiUYKTJzLh0vMZffapH1gK762F6kOOouuRu4v7s/CeTWnqhWx8QuBvCKMHTNrfWY3ruBhBw3NElCLR3kHH8y+x5va7GFi6HD0SwWxqYsNTz5edw9I/3crYM0+hdp89CpbH12/grS98jY7nXvKOrQl0S2fd3fey7u57mfTZa3n/3w8Oe46Ns6Zx0M+/ReM+cxh/wpHs+5nL6Xx3Ae9/6evEli0ntTZKSiliq9eC67LX4XvSsaaT2PsLs2XTAJr0qIHtvHenEQ4Ne/zNQfuzLw777rR7++h54y1qDxiZ7HAFH0zous5Xv/pVvvKVr/Dmm2+ycuVKEokEY8aMYc6cORtVtlU05qbu8JGPfIQLLrigSGTFdV3uvPNOzjnnnE2eRAU7HpTjDOmEQLpxXpfZxnmfJmk0oT3pFDbSC8GeF5/Fyb/85ojPM9Hdw6Lb7qbttfkIXWf0kXOZeNoJWxwJrp42ieCYFgZWryu7jXJdxh53xBYdZ1tDt0wuf+0h/rjPCdiJJArvw6mJXPAx04zuKs/Adl2FysuGZFit8u2Q2sYAC59bjTOICUfgZV3cPMPFVS7PffprHPW3XxWUEDqJocvgABr2mVPghACsvu/hIbVlcF06Xp3Pa5dfixYKEm/vKbmZsm2eP/tjnLjoRXRfMU1o5xtvl3ZCKL4e+RCaxuK/3Mb+P/82ruMQX9+G0DR8jfWbnSVYcPt/hzY8pGThXQ9sNUdk7XMv88QnvsjAmlaP1ch1vetA6Rr5V3/wG2Z95NwRz+B2vvoGL3/4E7iJZPZ69L67gDe/8A3W3f8I+/7pl8gtoDGvoBA1R51E9+P3Fgsamka6Yb0YQgiMoEWgIcLA+h40U/NEBBW4tsPrV1yTe37T755gtY9obyLXY5I/nqax7JbbCxyRzpde45VLrsLNe4coR5FMJtFtF91vsPTnv8o6yOUgDZ2mvXajcZ85uWW6zqrf/5HYylXpgdNzSo/V9fp8Er25crMiWnSRExyWWykb4W7EuxM27h1bweZhxyf2H1kIIdhjjz3YY489ht94GGxWuGjDhg386le/orOzM+v99/T08NRTT1UckV0E0jQxm1tItpY3xBGCSVdeTnNM47Uf/ZZ4ZzcBU2OsJogqQcpxGHfcERz1029QPX7kFT9XPfIUj33k014fR7o5eMm/7+WVb/6EE+74E7WzNp+hS0jJntd9gueu+3+l12sao486hJoZUzb7GNsL1ZPGcd2G+bx9y50885UfogaiXjM5KstelXEuHVWaLnqw/dy+rNtzQvLexiovy1IYJYW1Dz7GC5/9Ogf94tvZddUzptL5zvtl6UOElNRM95j7Eu2drH3gUZKdXfQuXDJsNBC8DI/TP4BuadgJp6SRo2ybRT+7gZnXf6b4+EOQEgzlTyjHoeO1N3n3F39g4R9vIdHWAUBk2mRmXnsF4885dZMdktTAMIrMrkuip2+TxiwawnFY9b+nWHrPw6T6B6iaPIEZl55DsrePB878GCpT+582yPKIhIo+yvHObta98BpjDj9oi+aUDyeR5LXL089/voGZ/nfbU8+x5Ia/MPXaj4/YMT/oMGrrCO62N9F3Xi+453WfWTJLko9Ak+eIZOEqUl3dQC57qNL04gD+kEm0t9hwVo5D38Kl2d+T3T28etk1ZY1xO2ZnVd8DQYP+tNMgAV2SpS1XSmHnS1ynEV21mvannilraSajSWzb8V5bacFXSU5HRKUJOFwpsLYSvXh45kZ864QgPG3n+17tDNgerFm7EjbLEbn22muZMWMGvb29zJ49GyEEb7zxBr/4xS9GeHoVbE80nno6q2+6oWxmRGgajad8CKO6hokXnc3yux9ixf2PYA9EqZk1jWmXnkf1tELawM4FS1j59IugFKMP2oeG3WcCYCeSrHr2ZZI9fdRMnUBjenk5dL2/mEcvutprhEx/PDKzjLd18uAZH+WcVx7GjGx+Knz6pefRv6aV+T+9wYvYuS5CSpTj0Ljfnhz5x59s9tjbG5phsMdHz2faqcfxj/1PItHdg+a4iLQzokuB7SqijsoyZ2Wg0v/Jtzl61hcbxuXeq5ndlvzjTiaf+yGa5noiTLOvuIhnri1f+61cl5W33oG9YgVtTz6PchyEJnFSwzshUgrMgIGTdHFSDloZlWaAdfc/UtIRaThgb6Rp4iaTxTsNg+iadbz1/V8VPEu9i5by0jVfom/pcnb/0rWbNF715Am0vf1eeadN16jdAic51t7Jg2dfQfv8d7LRaqFpzP/1n6iaPAHluCWjy0J4f99STN7J3v7Nnk8ptD74KMmOrvIbKMXyv9zGlKs/NqQTWcGmofb4M4i9+3rBMiGLG9cL1guBZhoeLXjKTd+2Oc9VKVXIspWGP2ySitvYqbx7TUrMqnD21zV33IOTxwRYCk7cQTM0ArVh+vu70JSLKYv1jnTl0vvafJx4IisK2/3qvLIvs5Tt0h91Clcr78xMqbIaJ1IKWk44GrNq69T+V83ZjdC0KfQvWQqlWB41jfrDD8HX3LRVjl9BBVuCzXJETj31VC677DLWrVvHa6+9ximnnILjOFx00UVcdNG262OoYOui8aQP0TvvVa9hPf+FLT0KpQmf/gJGtRfh0f0+plxwOlMuOL3kWNG2Th684vOseOzZnAWrFKMO2JuxR85l3g1/J55HAdu4xyxO+O13adpzdsnx3rnhb95HpBSjl+MQb+9k8e33MutjF27eyeN9PPf9ymeYcu6HWHjLnfQtW4lZFWHSmScx6vCDdggqROW6xNs6ELqOVVu9yZF1f30tZ9x/M/899xP0rVyDbhjoeLSw9VPGs99XP82LX/0h9vr23DEpVCIpdxWGC/AITWPRzXdkHZEpF5zOyocfZ8UDj5f8u5pSIKJRWh95KjsD4TrDc/4DVsDw2H4sDZQqKiHLh5sqzf5mVkWYcsk5LPzzbQUR+FKOWeGJCuy+EkZ4+hzf/dkNjD31eKo3gWxhzhUX8tinvlp2vbIddvvIuRs9XuG0FP+7+Bo60n032Wh1+v/DiXkqRcm/SdXkjW9e3Bj0vPE2QtdRdnm2vmR7B/H1bfhHbXsGsV0VvknTCe13KP2vPJNdptKse1q6R8R13FzGjLQuUcpGCIEdd/A1txBfs7Zw/1JlWEJg+g0UKZyMM+K6jD7txOw2Hc+9PGwZcUY8MTi6BZZ3YMjc+PnHAhhYtpwlf/oH066+LD330mM6jqKnJ1Hy3aOApAuWVFm9ld2/9Kkh57glEEIw52ff4+ULLsOJxgoyxELTMBvqmfX/tow2v4LyyGiqbekYH1RsliPyxhtv8JOf/ITLL7+cl156ia6uLhzH4YEHHhjp+VWwHSF0nSlf/RZtD9zHhv/eTWLdWhCSqn33p/nM8wjN3m2jxrHjCe445RI6FizxFuQ9cGtfeZ01L84r6CkxJcTffZ/7jj6H0YcewG6fvJQxxxRSEi//76MFH7pSWPHAo1vkiGRQPXUS+3/zC1s8zkjCtW3ev+FvLLjxFmLr1gNQNWsas6+9nAlnnbJJY9XNnMrFbzzCiv89xdrnXgEhGH3oAYw/5lCElEw/40T+e9pHWPPcq9l9Ms6IUqA2kwxJOQ69S3JGrdQ0jrjpZzxz5f+x7J6Hsh94CRjSq7X2jp0nHgaYlobruNh26Re5rkt8gZyqszQ1XKeMtQyEZ04tO+e9vvF5+pevYu2jT+fq2tM9EiWR76wOkVlccvPt7POD8o5FPpK9/egSGqaMp2vpSux8Ay5dY7/3tZfRtNfGPZ+D0fbam6x/cd5m7VsKQpM07DGbui0olSw5rr5xWY5KNmRkIYSg6eKrMeqb6HniAdxEFD1oYYT82W30tDNiD+QIFaIbeonsdxAt51zAKxd8NLttJhtSDkopDEvHSSURmkZg3GhGn3o8qZ4ehK4P64TkTZyWk08ggZ/OF14pv52rWPrnW7OOSM0+e5XcLBa3hzy0Ilfa2nTUoVTNKP9eGQmEp03hoLtvY/lNf2PNf/6LG4+jh0OMOe9MJnzskgJ65ApGFi5DC0xv7BgfVGyWI3LVVVfx7W9/m66uLr70pS9x6qmn8tJLL/Hxj1dqcXc1CF2n8UNn0PihM3BTKYSmbXQmwEkmWXj/47zzr/tY+/YCdEE2VQ1p9iXXMwglXpVJxJAY6ZS5QLH+mRdZ/8yLjDpqLkfd/NtsE/qw5TFK4cR2zcY813F45qOfZs3DTxZ8hHveX8TzV36R3kXLmLOJ0TepaUw88SgmnnhU8Tpd59T/3swLX/0h83/3V8CL8LkChOOmP7heGcIm+SRSYtZUZ39dds+DPPeJLyAdB2tQOZgQoJW575IJB9PSsHRIJV3ctFEjBFh+A3/IyEY7vbptgBLcmmnM/kZ5p1PzWRz+j9+x7snnWXrrXQysXou/uYna3Wfw/q9vwsno2ggBrosRDuHE4kPer8px6Hl/Udn1+Xjnxpt55Zs/xYnFvYZ3CUoKko5HuVw1cSz7fvbjzL7k7I0arxRW/u8phK4N6+hvDISmoVkmh//y21s81mA0HD6XpX/42xAHF4QmT8RqrB/xY3/QIaSk7uRzqTnudHruvhFnXXGWTEiBURXEsQVOymHUlR+hav+DWPb7mwqd92H8iMwzKzVBeOZUJp59PPM+fBGJ1lYAjPoGNL+OM4SOldAl0jIZdeZptL32Ll2aNiQtfWzNumx5VmD8WOoOPZjO518qyDQkEjaG5uksofBEEAc5VI7yjKzp114+9EmOEAJjRzPrm9cz8xtfwk0kkD5fhTa7gh0em+WIzJw5k1tvvTX7+w033MD111/PggULRmxiFex4kEaOFcWJRmm99z7W3XMfyfZ2zPp6Wk47leYPnYoWCLD4kae5+2OfJ9rWmY3SJgFdKCwpsg2C2ZekUvg1QdR2SSov5m1JgV+T6FKw9skXePUbP+LAH34NgNrdZrDh5dfLsqAITaN+z82LCO/oWH77fax56IniFemP4Ns//T1jTz6GmmH6bDYFQggO/u6XmHPVpSy47W56l6/Cqq1m6tmnUDVhLGsee4YXrvxCgWM0bMmU6zLxzJO9c3rgMZ6+7DqvMV5Q9PE0BEM2wyYTDsGwgWFqaIYEBFIrr25eLgA76eOXEJo0dAmRkJJRRx3CqKMOKVg+7WMXsuxf99D+0jwQ0HTogYw/+1T+u++xJDuHcJylxAgHhzwmwPt//Rcvfum72d8zRpEALE1w4Jc+xV5f+GT2nNc+/yrzf/sXVj32LMp1adpnDrtfeQmTPnTckMaJk0h6TbbDzqgM0oxIQkrGn3AEB3zts1vUr1IOdXP3JzR9CgOLl5UmK1CKyVdfVjHEtiLc7raSTgiaTnDqTKwxExC6991Qlh97/Ur63p5P/puhmDg8r0wl7/U+7uxTMDSb1X//e8F7JtXZgb/aR0ImCpTa82GGfez+i59i1tWhBQIIKVBDhaClZGDB+6z7z130vDYPUASaqoht6MZ1FK7tEDIKM22mLnGVYiDpZN8vCph46XnUbQXtkKEgpETz+4ffsIIRQZkq8U0e44OKzVJWL4VUKsXUqVMrgoYfACS7unjzyquJrljhLcjjLvWPG0fjJz7JzadfgVuGAlgXEBikymu7ilSZW7HakPg0iTRNznv/GayqCMvufojHL/tM+UkKwVkv3F/ULL8r4KHjzqVz/rtlI3pC05hyyTns96Ovb9N5rbznIV763P8j1dOL0DVc28HN3BulenmEQAYCjDn+CFY89ARyIIomgUF5FQEYpYQ6BsHn1zFMDd3UEENsr5RCSYNYVwyV8gwXX3MjM75wNeMu3Dgl2E3Ba1/+Dkv++q8CY9lN0yNnrsqMKy5i7299scDZz4ebSnHrrMNIDNGcbVZFuPD9Z9Esk3f+8k+evu6bWXIF8EqklOOy+1WX0DJnJu/88kb6V61FaBoN++3J3t/8IrW7zWDxnffz+OWfG/qk0nXvpe7Bvb94NZPPPAl/Yx2+vIzX1kBszTpePO9yoitWZaPsmZK5yddczvQvfqriiGxFDDx7H7HXnwblsV058RROIolSIE2LwKTJBKbPRNaNxvFXIzSN1bf9h6W/+0v2naBchVvQYJ3pq8BLXLoq6zRIXeKrtko+30opYp0J3GRhZqTu4H3Z4xc/wGpsAKD1kad44eLyIrRC02g6YDaqYw1oGmSe20wWx19F17sr01n74jkooD/hNbDX7bU7xz38z8o9uAXYke21zNwWrFhLeAvn1tfby/Txo3bI89zaGDG1J8MwOPzww0dquAp2YCz6/g+JrlpVaFym/x1bvZr3v/ntso3k4Kl4u0AmnuSqYifEkoKQLrFkLjLrJpO0vfw6Y449nAmnHc/UC85g0W3/SYtdpMtx0kbIAd/50i7phAD0Llw6ZFmBchy63124DWfkYdxpJzD6+CNZ/eDj9C1bgVkVwddUz/PXXE+qf6BoexOFiEVp/c8DCNdNU10OTYU7FHL0/i5SlGbxyTQVqmSCg2/7PdX77oXQdeRW7COY/vFLWHbrXTgJhXIcHFVcD/zeH29h/UvzOOaOm7Bqiyk+1z33ypBOCECyp5dl9zxEx+tv8d6Nt+CXCkc5pEjre6SNvaU33syy9KVxlMJxYdnjz7P88dOZdsHpHPD9r+CrqyHR1VOaGUtKpl9yDtHWDazMKw8Mjm5mny99ihkXjZwzp5Si86V5dL/xNsLQaTxiLqHJE7Lr/aNbOOzRu1j334dZ99//kerrJzx9CuMvOofIrI1v/q9g8+DGvedaKUWyZ6BAYNONx+h/7x0Gliym5tzL0UPeM9Z43BEsu+GvqAy1mgAjZGCFTaQmcR2XZF8SO2ajUAhNIDRwUwrXdkn0JfFVFetxCE2jdp/ZDKxqw02lqN5rDuM/ciF1BxYK+DUddQiRmdPoK0X7LQS6JT0nBHJOCOTeubEedEvHjhdnXzIaTIbmlUvu/Z0vVZyQDwAq9L1bho12RBzHQRvmYx0MDl9eUMHOjXhrKx1PPzMUlQg+uw9TKjLERKWoPFOuQtNE9t/5qDIkVYZWUIqTSdx1vfkeY449HCEEh/76uzQftC9v3/A3ut5dCELQPHc/5lzzMcYcc+jInPAOCM3vwx5KR0KIjSr12RrQfBbjz/AYbWLr23jkuHMR8Ti6yEX/BYW9QimliLsQ1IpLsmB4RqwMZPp+Uq4CrbiUK3MPKcfzdrrfeJO6uQdu8jluKkITx3H4v2/iuY98imh7Z9mmxK53FvD0FZ/j2Dv/XLQukccoVw4CeOnTX8W1bbxLIZAoDA0SrhcA8MlMgkqRciHfDFPA+7fdzZrnX+XQn32Txz/+eVzbKTTWpKBhr9046Dv/hxEMMLB2PT1Ll2MEA9TNmTWiDl3fwiW8csV19C9ckmXqQymajj2cvX/9fYw0Farmsxhz9ocYc/aHRuzYFWwctHAtoLCjiQInJAulUMkkPf/9J7WXXOuxYNXVMOHjl7Ds938FAaGmIFKT2edVSIEZMpG65lFzuwon5SB1cG2Fk3BwHRepDeoZc118TXXsd9vfh5yz0DTm/vNGnv/wlfS8/b7X8I4XwJGWydgT5zLw3tuFTkjhKaH7JHa8/DEMTTLho+fTsH/pRvcKdi1UWLO2DBvtiPz5z3/miiuuGHKbWGxoLu8KdnzE166l9d57GFi4CGma1Bx8MA3HHIMWCADQ9867QxYz2o7LhrYYESk9+itI61G4JPIcjvwRnLzxArrnhEAxtaIC3v3ljUz/2AWY1VUIKZl20VlMu+gsnKTHqLI1I9s7CsaffiKL/vLP8iJ+SjH2lOO27aRK4O0f/pr4hnZwXfSMqvqgbVylSDjKo+YdInDopssgykUXhSDr2ApN4NqeoaLSZR6ZD4XUJEbAQLmKgcWLWXvXPeiRMHVzD9qqNdUNB+zNya8+wp27H47T2+8JSIrMuXnXRTkOrU+9QNe7C6kZxDAVHj9m2GPowmNTK+jTSZ+7JcF1vBK3DJtPuVb0vpVrmP/rP3HGE3fy5m/+wpK77seJJwiNG83sj13I7Cs+jO73lOeDo5oIjhp5bYLYuvU8e/ol2BntkbzMzIbHn+XFC6/kkHtvrjBibWdYs/Zj4MWHceK5HqhMNlxlSSNc7M42UquXYY71stTNF56NHa6i8+9/QojMdgLlKhJ9yey+UpMoqTAMzylx+70shJsq4YgIgeb3Y/f3o2wHvSpS9n3ha2rgyP/dTtuzL7Hu4Sdw4nGqZ89g7Nmn8uYnrijrhAAkehPEu8sToQghCDQ3sM/3rh/m6lVQQQWwCY7I5z73OW6++WZ0vfQuSileeeUV/vKXv4zY5CrYtmi99x6W/uxnudpvIeh64XlW/eXPzP75LwhMmDAkY5bjuCxb0UsyVWhuagIihka/7RBLp0ck6ZpeV9Hv5NoVbeXikw5ho9jAEIATT/D+jTejmwb9y1ZiVEUYd8ZJ1O21+whdhR0f0z9+MUv+cSdOQhWVaAlNIzCqifFnnLSdZufBjsZY/u970F0XTXpN4ynXLUo/CwTVZu6eUkplFd3zUU7hPQOfP9dboRkaTtIpqDvXTA0rlGZcc1ycpEPHk0/R8eRTAEi/nwlXXMa4j1y81Uop+patJNXbjyUF+qCGfEcp4o4CKVn7+LNFjkj9XrtRPX0KPYuWliyXkjLNWFYiSJBxRkyZLtFSHsNWWSjFhlfnk+of4Ijffo8jfvu9rJjntsLSm27B7u0v6Wwrx6Fr3pusf+wZmo87YpvNqYJiaOEazBn7knj+cSAdGbadgkiTwvN6B157Hn3MJNodizg67rTpaXbrXNY70Z8sovLNPCeaoaF8LnbcKRkLcxI2nfPe4Yn9vBJx36gWxl1yIS2nnUT7I4/R89ZbCCGo3m9fL7jms6jbbw9M1UN86QIQ7cTeeXXI+zwVSxHrGCbgKiUNhx2005VkxVcuIfb+fJTj4hs3Gf/MPXYIraydARX63i3DRjsiVVVVjB8/vqwjkkqlWLJkyYhNrIJti55581j6058Cnkhe/0CKlO1i6JKQ6OLdz13H3rfeRmSPOTn9hEFo74wXOSGQ+5AENUnCcXABXRP0JB0Sgz4oMVexImbToqDOLBHtVIq3f/w7dE16vSHAwhv+RsuxR3DwjT9BDwZwEknW/+8JoitWY1RHaD7x6F2KQz08cRxH/vuPPH3Jp0h2dedKC2yb0MRxHPnPP6AHti9jSqx1A7ptI/MM7sFOSIm+dIQQSKUQwislykDhNbdrmvA0QDJjaALL0tANmc16CCHQfTp2ms5TMzWscNoJcV2cEorqbizG0l/9lnV33omvqZ7I7rvTfPrpBCZM2MIrkXeMZAqfFHmZEJW9JgLwSUE8k9UYBCEEh/z8Wzxw+qVgU+CMWJpEpB24chBCoGdUrDdirkLTWP3EczTtt6f3+wgbJPG2dtY98Cip7l6C48fQfMLRWSVrgFX/vrd8xg9Ak6y+878VR2QHgG/3ufQ9/3hJJyQfyVXLGOjvJyL7CCNY+eDdAAifH3PWbijdwHlnIanVq0vur5RCs3TsuJNmxsvBTjrY0RSp1TmRxPjadSz8wU9Z/PNfols52vkNDz3Mit//nlHHHUDs/fnexsILlvS99DThGgO708SOFjPdDZUJycJ1mXDxecNvt4PA7uth/V9+TmLZwrTukQDXQa+pp+mjn8UaO3F7T3GHhxfg2fIxPqjYaEfkN7/5DaeddtqQ2zz44INbPKEKtg/W3HYrSEl3V4yVq/uQmqCxMYCuCXp7YugdK3nu5LPwtbTgnzyVgUULEHlPnlKKro14Sfs0waTTT2TJ/Y+RUOUNjXVxm7AuMcuwHynXLQghtD72NC9/5qtMOO0E3vriN0l193oOk+vy9vXfY9InLmHGlz+9y0R4Gg/chzPefIKV9z1M+6tvInWNliPn0nLUITvEOfa+uzBL0ZyByOPzFdllxX9fkdYjESqXQbEsjaBfR+A5IkophPQoelFkG18VitpDD6XvtRdRjsJJOl4pllJIQ6LiCl+VhUwbMnbcJhW1s1HY2JpW7K4OBhYvYd2ddzH+4x9n1PnnlWWz2hQk129AT2vklMtIGEpRv3fp7F7TgXtz8n9v4eUvf4foW+96THLpy9ebsIf9kik8goiNirwJMSI6IkVzcBze+fbPWHbTLV6WRZNeGU0kzB4/+npWMTvV0zv0QI5Lcpjm/Qq2DcymUchgGKevt+w96Js4mdpjTgI1kK0JNGK9hM+7mMBJH0L6vFK/OiA2fz5tP/8Z9tq1BWNkmLQ0v4HUZbYsz0mmsKPpxvES2UI3YeMK0Ezvd91vEKqTdD77XK4ETJcYIQvdZ4BrUzU2QufijlxDfRr2EFolGQQnT6B6J8nQK9tm3e++S2pD+lrnXT+7p5O1v/sOY7/4Q/SaihZPBVsPG+2IDOeEAJx44olbNJkKtg+U69L96qt0d8VYtLSbseMijBkTxnVcEj0JknHvy5Fcv55U24Y077uGZoA0dHBdXATORtA+GFKw/J6H6E0Nb+R0Jh2afcW3aCnXRLkua+99iM77H8ktS0dUlW2z5Hd/BqWY+dXrhj3uzgLNZzHxnA8x8Zwdo0l3YOkykm1tGLW1tD74aNF6TYhsP9BwRQseNaYg4bpYpkZ1tR/lujhJFylFboRBdodAMP36L7Lga1+j7713cVMOUpMIXWAGDcy0U5Kh/5S6xAyaRDtjuOlsnmu7aMK7d5bfcAMrbvozzWecxrjLPoqxBbSKa+9/BAVDl0UB1TPLK5AnV61GLFpMcFDpoqFJHLu8i6GUwkHgXdXhn1Nl2zTuu8ew220q3vn2z1h649+yBmvG2bH7+nntqi+S7OphwqXnERjdzMDyVWXHEZpGYCP6ZirY+hCaTvjg4+l68F8l1xt1DdQee7KXdchbHjj3YtSkmQXBCOkkqZ/cRP1P/x8b/noLbU+8gJssZKfa+4ZfkGxvo/+99xC6Qf+KNbQ/+eyQGTQn6aClM+yh5iCpgcKgmWu7JLpjuCEXM+ixd/lrg0Q7ojnjfCMDPMGJ4zdqux0BA2++TKq1dAYK10UlE/Q8/RB1p120bSe2k8HLbm9ZTmNL99+ZMWL0vRXseOhd08riR5/BSaZo2XM2o/edU/DS71uxmgW33EH3giV0Leuisy9BQ6OfMWPCgBf9SfYlkbpE9+meCFT+w6IZVB+wL/ENbbT1Jul9t92jLpQCnywtJicROKiSTFr5EIBdTiejzD6GlOVV9JRHWzrpykux6uuGPngFm4SeN+az5Ge/oD9P0DTa4xkFuqXlmsYTDnbSyfoOQ9VQZ2gwbQWNYWtYRhGpS3S/htQlr15wATgOynE9h0NAoM6PHbPRLA0tT2fEdbxSrUCtn/4NA+kce+HYbirBmn/dTufzL7DnH2/MsjVtKuIb2gs+Nrou8fkNdN0rK0smHeKxFMtuuZ1Zn72yaP/1jzzJ/Gu/7EWFTYnQMuqP4E9CvK+8IyKEYNJ5p7P3F6/myfM/TtuCpQWlbwXbapLg6BbGHH1IyfXx1g0k2juxmurxNWx8pDS+oZ1lN91SdH1l+m8khODdr32P5X/8O9V77c7AytVlOS2V4zDuwjOJr2vFiUaxmpvQK6yN2w2hg4+l/7VnSxq1wTl74WmD5Az5pJIweVbuXa4U4WgruuORTZsqStVFJ1MzdTTLbrkHN5lMbyaILlvCmAsvRJzuBUdfvfQTQ5fxQTbz4a/z4w4RBEv1J9AsHU2T1Ow1i9qm6fTMex2Aqn32xv3PY/S8/R6GT6Jb6W+iq7ATDnYshUJSs++eG3XNdgT0v/FiWZ0nAFyX/lefqzgiw6DEZ2OzxvigouKI7IJIRmPcf+3XefO2ewpqyZv3mMlZf/05DTOmMP/nf+DV7/wCAJFmJDKAZHecng39mJrHUqLlGZJSk2ia5glQ2S7KSZHo6ePpFxbT39qWbYqNuYo+oMbQCoTohBA4Q+hfgKegPdpv0GBpaOnxHAVJhKcPQWmdCY+FSAz5NCvHYd39jzLh0p2nfndHR/frr/PW1dcWN1C7KQJ1fmSe82oFTayETW93PM3EWl4pPdO0Xl9l4TM1T627jPdqBA0Mv57NdLixWHZcqUvMkIlruxgBA6EXOshCCm+5FBh+nVTULvB0s/TRjkts1WpW3PQnpnzusxt1bZRS9L37HrHVazAiYXzNjVm72h8wCATNgmugpR2Tlf/6T5EjYkejzPvkFxFSoPu9yK5maJ7GghCYAQM0WbY8cs4Xr2aPL14DwIlP3MXbP/8D837+R+xUYamJ0CRGKMTxt/y2iIGua96bvPvdn9Px/CuZi0PjkXOZ9dXriAyRxclg3f2PFN0nGcrl/L9JdOVqBlaswtfYQKKto6SR2XzsISz58U/oX+Dp5QjDoOmkE5j8qasw6yqBhm0NISWhg4+h666/Fq3zT5iMkN69pByHxKI3iaETMBagNI1U42RE3SiioVG5nZSi54+/oev++8l/IIVQrLjxD7Te/zD+SdNIdfUQXblmo/WHdP/wJo8TS6GFLFCKcZcXMoUqK0ziR0sQMnfPCinQfRq6pZGMuow97/ThJ7KDwB3oH7a5wU1U2FAr2LqoOCK7GJRS/PuCa1jy6DNFH/31by/kz0efz0lfu5ZXv/1zJF6plMxLOTtKsWFtPy3NoTxjTuCv82PkMRM5KYdET4LoO29jd3dnj52dB9CVcqgzcw5FPrOEKSCZ9/6rqfExbVINcnUvKq/hXQiPYUiXkqQrcMpEvjaGn0RoklT38HoMFWwclFIs/vFPvfss/2/vKgyfnl2Wb2RqpkZVrZ/+ngTOEGkxIQThkIE/fc8JyJIT5EPzaQTq/ZhBg2h74QfTqvLTvPc4upauw4nZRU5I/tx0n44RMEhFbaRepgTDdWm97z4mXfNJpFUsqJaPnvlvsuC7PyC6dFluroEAvpCJk3QIBM2C4+f+rdD6OnFicbQ0RS7Aunsfxo3HMYLeK1u3dC+LkM482kkHQ0pqIxbRuE0y5Sk7G7rEZ2hUNdWz4Ee/ZuWtd5Ls6ESPhNn/yg+j6htYeOf99C5diT8cYPxJx7Dbp68gPDbPKATan3+FF86/ovCdohRtT73AM89fwIRLzyPV3Y00TZqOPYLGow4totb1+rZkthwrk5Uq1yeU6upi9Bknsfbeh7LlOUZNNS1HHUjXc88UWJ4qlaL1vw/Q9fIr7HvLXzBrdx1yip0FwT0OpPv+f6ISgwQ20jS7ynWJvfIYKt6PKQSkMyS+FfNxQnVEDzwb5feyjalli3HWrCY0YzrRxTnhQeUqYh1x+te+A6+9R9YDcV3veUhrEQ2+pzI9YSiG/Vg4KQekxDd+ctG6zqef9t4Pg4x3j15eUT174k6VcTeaRhFfvnBIgVy9rnEbzmjnREXQcMtQcUR2Max49mUW/++pkuuU4xDv6WPeD3+DhJKN4BLAVkSjNuEqCzNk4KvxFW+nS/x1flRHjFERg6UlVGYVEHMUIV3gAsm8Jy2gSZLpmvb99hvFrFkNrHl1Lf1D1Ln7fCbReGnhLCXlsN8YZTsExo4eYosKNgUDCxcSXbI0+7tSCuV42TJPT6+0gakZGuE6P73t0bLfP92Q+PL6gxRpo1sT2cyI0AT102rRfTrx7kLjR5oazfuMQ2heCcXgt7xm6iAldiKFm3IQeE2smpksNmJ0iRk0SMVsnFicRHs7/tHl76Ped97ljSuvKYrkO9EokVo/qbjXHF/OAAdofeBhRp+V68vrfW8BMl3jLnWJNKRXYia85n1dCHRLx1QKn+2Vmyk3rSKv4P3v/gwnmYT0s2P39rHy7/9Gj4SYfe4pbHi4D7unl9j/7ufNt15j/EcvYfR5Z2WznG9c93XvuSvKfDmolGL5n24BTUMIWHXbXYSmTmL/W27AP6o5u2lg/JiCBnghSjshWSiXmj1msft3vkzvgsVIwyAwdhQvnJy+LoMjuY5DYkMby264ienXf7H8uBVsFUjTou7cj9P+j994C9L3SqptA2ZTC6ll76Hini6MRzWdu5fkQCeBF/5N7PBLCKoEjG2g7mvXY+Di9Paw7o672fDAw8S64jnWu7Tzkb0PFCgH7yMmcn1gQLY/ZKNSJ8Ibu+qw47OaKEJKoitW0v3Kq+V3E4LYipX0L15CaEqxE7MjInLgUfS98PjQ28w9dhvNZieG2nLWrA9ybVbFEdmFEO/q5tHPf3vIbaTrkOzuQeA5CZYmyY9bZgyP/v4kLTPqEDLXOJwRh8vfzl/jI9jaj18TWY2QfKRMk4Rr4w4yBHUpCOuSsdNqmTWrATvh0N/aX/5hdF3ceAJ/XS2xjq4CI09oHjVj9R6z6H3rvbL1wlrAz/qHH2Xlzf/E19LE6HNOo+HwuTsEy9TOiHjresCLUsZ7EyT6kqAgWO8f0sBUSqEZEr/fIJGwsQc1K5g+HX/QyGUrAgZVE2rpXtyGjsd0pVyonliFZmWYcwr/5uHR1QhNeo6PqeMkbI8a2NQxI36ibf3YA8UlB7qlF+kY6JZXAmWFTVLRVIHwoXIc+t5+E7unB7OhgeCMWSz91W+9e9B1MQI6ZsBA6BLluCQHbK/cMD5ETbsQdL38aoEjovl82TIm3adj+Axc18VOFtKlCiE8R0WX2DEb13ZxkranZjj47+A4CDvG2n/fWbA8sa6Vhd/7EQPLljP9y5+n88XXiK4o3TjuGXvpEIDjZKcysHQFL174cQ5/9C5kml665cSj0cMh7L7+7FyHgtA0oivXEFu9hoH3PSHVjieeQCWLgx5ZOA6t9/6XKdddi+YrDqBUsHURmLUXTZ+4nt4n/+tR4ypFdOH7WC2jsdd6QYuSDrhSaANd6GvfZ13jTBwvJIZAUSVTNJ9+ElrAz4Jf3AyQZs3KZT7ygyBeZl6Aq5CWgW4IpK6BUqSiKcyQmTuuFF4AwtBQCpykjTQkkYMPo/s/N6JiaUFNKaF61ND9FGn0L1y00zgi1rhJRA49gd5nHipeKQTWhGlEDjxim8+rgg8WKo7ILoJ4Rxf3HH8+7e8vG3I7DehI5kc1XYKaoDbdk+Eq70PhplxivQksv17aYJCe6q3QBMLUUQqsdLlV/mvajIRwOzoLdnWVIuV63FvJqM2aVb3UBPVhIwJC05hy8TkkojGW3nIHqb5+hCYZfcKRjD32YLqeeRq3I4gdT5HoiuNmDFwhkBpgJ1j/6FOeau6bGq0PPELdoQexzx9/UTFaNgN2NIpru/S3RbOMU7ARBqYQCDwWKyEErqs8R1V4TojIIzowIz7GHDTe613w6WyYvxbdp4MU+Gt8uWMNOmagIZz9txkOkOxLIHUNX02Q3tVduCW0RACsKotULOVFXZXXFJ5fqmUEDOyebszaWjqeeIzVf7qBVGfu/jYbm+hbsAKUS7DB7zk26T4QpQv8poYVMuhd219wzQZdoCJjp/HYI1jx579BOvMB6Z6ZEs9MJkig+3USvYmyfL2aqWWdm1JYc9u/aT7peAaWryy5XpYrrRKAcogvX8Eju81l7PlnMPHyS/CPGcWcH36deVf/nzf/IXqE0hvQ9cIzbLjvPznGomF6zADcRIJkZyf+UaOG3baCkYc1bjINl3waZadQqRSYFm7napRjFzgO3r2rshoeCoGzfgVO42wAtA2r8L36EKxdTC9gCcGEE2az+qkFRRlFIQRoIIXMCpnqQYvZ3/kKyfYONjzyOAMLF5HoS2KGLECh+3TMsC+7v1LK0xyqq8ZdvaDg/lSOA52rmXj8TNa+sAQtzVpnx22SA8mC51CaOUdnZ0DdGRdjNDbT/dh9ON0dgKftEjn4GGqOPwuhbzl1+a4OF4W7hSmNLd1/Z0bFEdlF8NI3f0rv8tVoQ9zMpiguXaoyNRp9Or60saWUIuko4rbr1cqmm/vy+z+EEOB64nA4kMrrBTBRWZFCoWmM3ncPjFSSVU++gOs4JN1CDYU1q3pYvbKH6mqLMa6XKSkH5br4GuqYedmFzPnadfS+u4D2p5+l/cF7WHPTfJRSGAENI6Dhr/UR3RAl3pXArIngZJryMtmS9P87nnuJ9771Y3b73tc25jJ/4DGwbDlLfvUbOp97wSOD1SWhpiB2zCbRm8BJubiuyhqpZSHBilgo1/uYZ7Z3bTcb7QRo3mcMwtAQQGhUFVLX6Fy0AX9NYdbF8OtelmRSYzobIrIlfEbQhzQ8nYBkf6KsE5KBGTaRVYJkf7KgvAMAIWi9819E9tqH5T/9YdG+ybYN+KotXMczajyGKy3rXClX4Rou1ROqUI5COS6pmE20I5Zrxnddqvfdu2Dcmn32wGppwe1rB9LN/IMykEKKAsfJdVzsuF02+6JbJQRD88fTNNbeeTdVBxxYZoNiJyRDjJQVsYzHWXnzv1lz13858N9/YcwZJ2GEg7z7vV8wsGBxQZZ1MKywnnPyNsIByYceqDBobW8I3cgZsXVj0/61d88P1qgRmgRdQzhpEdJ1Swk9eFNB+Vb2/a3K9xUJTSANSdWYCFKXrP79LwHwT5rMtD//gdD0mQwseI/lP/5/mL7cfrn9JUbQKnKShRBE23rpXtSaFUf1BBY1rIhFtD2Kk3QQhkHN/vuOyPXbVhBCUHXIcUQOPoZUeys4Lnp9I9LYuRyq7Qk1AqVZH2D2Xio1KbsAkr39LPqXp0Ts10r/STU8JyT/5Vrv0xkXMgn4dfSATqAxQPXEKpqm1TBmSjWaJnEdlY0wlWoCxIVIsPCFlTFvlOOw3yc+zGm3/pZpZ56ITbGGQubhi8VSRAM6mJKUUiRdhZ2ucc9H8/FHYkdjzL/uel4862LW3fZ33Giu1CP/J9gUZPRpR+HGo0PSE67+990kOyviaMOh9cGHeOXcC+l89jmkVAjpRcU1XWKGDCKjw1gRk1QsNSTdrlea5fU3+Gt82WZzI6BjBk38dQHqDtiD/W76KWbQLNQeaAwxZu4kIuNqCsb014cYf/QsqibWAyrrhAhNEmisoW7meDTLINE9PAOMshVGwMAImll2r7zJ0/n4oyz/xU/KnRzgMWAJKdCstBOSpqiVutezkjlfaUqsKovq8RHMkAFSoIdDNJ98QsGwQgj2/Usxk1UGUhcYQR1pyOzxpC6xwiaa6TX0h1pCBJuCXmmKoKC0peSpOA4DS5fReORctIC/aH3WgNMEul/HCBrpPhutaBx7IMrr13wRpRRNxxzOEY/dxd43/MQr2yoxB92nIzW5yQ4IUlK93z4Y1VWbtl8FWxVSSjD9uCm7pFCmclxU0iYVrAHlEnjq395+lg9XCexYAjuepGvRhiEbAbPvlkGZvtiyZSz62v8RXbaE0OzdqT1gf4SURfe/VV+V/X5oPgt/fQ2BpjrMSJh450DBttnvoYBAfQCkYPS5Z22R1tD2hJASs3EUZsuYihNSwTZFxRHZBdC3YnWWZ92UgsCgKK4uwBqk62FIwdhaH/46H/5aH+FRIayIiWZoaIaG7tfRdOlFecpogmRQXWUV2BIZRe19r7iQycccihEMcNKff4ZvdEvRvpom2GN2AwfOasAXtUnGnazP4OI5Lo5SICVjz/kQvlHNvHb5Nay//xE0I83lPgQFbP/813BTQ6vhKtum8+V5Q27zQUd8Qxvvf+2boFRJytXMvwO1fi/q7xQ7kZnfk2kV5MzvmuFFFX1VPqywiRQw9qIPQ2ogF2IfBN1f+KGsntKCNLQi8TNfTQShaRghf7qxeyPVwhWYAQNZ7t4fYpwsHW/aIC/FDpWhGjb8HvWwGTKpGhfBXxtkz9/+HD0YKBo3NHkiTccfXeKAOVrSwXPVLZ3ImDBm2MTw6xgBnWBjgMiY8PDNkVKgh8PogQDTPvOJotWZiLAZNL2+FM1zgqShoQeMQgfDcRhYvJSu9HMmhGDUqcez399/h1nvMVwJTfP2kZLA6IaN42PNvwYBHTNkEJ44mujSJRu/bwXbBNq4mUNTAymFi47ZuoTqadNoOvMCGk87l4bjTqJ6/wMx6+pJ9sW9jEjGuR8EIYRHljH43lEuynFY/Zc/AhB9/81i5qt0T5kCAk11hEY1YIQDGEE/vtowE0/cj5aDZxbdlxlnpHbv2Uz+9Kc269pUsHMjw5q1pT8fVFRKs3YB6IHC/oZqQ2K6ip6Ui08TTA4aLBtIFRgeExv82aa9zP+NgIHhN7IveCflYMdsHNv1jIwyLDeGLgkGDPoHUl4kyTI54WffYPoxh7Dod38h2dGJbZj0rFxbsJ8QcMDezYR8Gqvnt5U9P0dB0+EHMeeHX6fj+ZfoeskzZnS/XpRCLxzf43cfrmcBGFYQ64OON6/5jMceU8IJyYdSCitioZkauiFJ5t130pAYfp1ob4K+df2ER4UhvzRH08BxGHPxRdQdeQR9LzxKOWtZM3R0n4kdT2LVhLDCQZxBDqfuM70mVbx+pkwpkRrCAtd8RpqVSkM5LpqpFTXCbwyEJko6INnMiMhQmqYzjsrbJzzKT/S914i+9xp6pIrquYdj1jVk9x/3kY/Q+VSaFS/dJ66lqUmLja+8+YjCuUhdolneuZV9PlxF0wkeY86Uaz6Gk0iw6Jd/9JrcNQ2pk+1XGTy+Ul4Nvh3LcwylpOft96g9YJ/soobDDuLolx+h7fFn6F+8DC0YoPm4I3njE1dj93QPdYmzYxoBAyPg5XyFJul89kk6n3qMmkMPZ/IXvrzT1ezvqlCJEho3QiDCNQghcPq78a95j6a9DkCfOoPEiiUMvPdmlg5YKOVl3XyF5YepqI0dzT37UsurQc57BjRdkFz+HguvvRSnr9/7pukSqWsIQ0caOnY0Qbi+JvtNzWmFeMermtiMPZCgbX6OLTCznb+5AWlUTKoPIiqlWVuGylOzk0IpRWLlEqLvvIZSiqpRdQys60AKAQhMDSK6xK8JJKAL4WUWAE0KqiNenWumlMOKWN6/84wSqUusiEWyP5kuzxJpw7+8ISo0jTkXnYm+bDn/2+9b3odGk8QSxUw3zY1B6mr9tC3t9o4nvFIfgRcdcNwMTavEP24Mms9i6W9vyh1rYy+WFEOHG4Sgas7sjR3tAwd7YICBJUtLl+YNghCeMGCmkdyKWLiOm63fFprGqFFNxN1q0BTBhghOdwfKtglNn07zWWdStcceAPinzwF1S9lj+esjDLR2UTWhGaFruAOFFL5GKJB1VIWUmOEgZniAeGe0aCwz7CM0qhrdlzNa7UQKx+7ESW66oFc2WityTdkFzokms6UhSilcO63M7Cja7r0Doeko12XdP/5M/UmnM+riyxFSEpw6hbrDD6fjmWe8jGXK9errByHXDFxmfsITcsySaQ0ugdI0/KNH0Xj8MdntZ3z+aiZ+5ALW3vcw8Q3tbLjvPlJdpUsaM1HifLpllCrpFEhdp+m4I2k67sjsMv+4McTWrClfmiUl4dkzCU0aS++Lz+SW523f9ezTLDNNJn/hy+UvRAXbDG5Pe8HvxpQ56FPmIH1e9k/ZKVIrFqBpktii9+h/81WcZK6UKxVP4a8LEOvoz44hpMAMGWiGJNHjVQUEG4ME6rxSQifpkIrZGH49++zZ3Z1olhdwyPasOEncRAoj5EPoOgNr2nAdh/41nQy0dqNsB81nUTVlFMFRtbS/vbyIRl45Q2feK6iggtKoOCI7IZJt61j/xx/h9HSilGLBc8uJrusoMswFkHDTFIiGZEO6Sbc2nDMGpC49ZeqAgdTyGmodF4REMzwNBQA7YZPs93QXCuaTchjIlNs4DlUSlvzhb95KpVCuiym8OkAXsuroIb9OPG4T645j6bJAhVsDDE2QtF1cx2X9ky8A0L9kefa4Tmr4SLXruISmTmFg8dKSWQ+hadQfcUhFX2QIrPvPfWyUElgagzMAmszrGXBd3IEedv/xNwnP3n3IcYy6JgK770f07dcKm1ZJG/eaJDyuIVt2lT89qyqULbXIwF9XRbJ3gERP1NMbSMOM+KmaUF90fM3UqZrQSNfCVlJRL5or9LQzobxsRkm1dyHSgod5vVV5pSSZqGkBFbarCvty84ya9vv/g7QsWs6/FICpX/8a4vs/oP3RR1Eb744XT1PXGHXGsXQ89wqJ1vUI3ROhVI5DeNpUdv/lj4vY5Kz6WiZ+9AKSXd2s+fvfhxw/8zfKf+4ajji45HZ9b79JdNFChG5Qtd/+jDrrDDqfe6H84K7LmAvPZ8Pt5R1VlKLjsUdw21fh9HSiBYJUzT2S2qNPRq+uKb9fBVsFwgqQSeOZex6GPn564btCNzAmzULZSfreeBUnnijQ/dAtnYbZo+ld3UnPsjynRnkBNc3nUfT6a3P3rDQklmZmgwHS0NB8Xo8U7uCnR3mU0evacFM2sfZ+BtZ3k+hJpBnu+uld4bFKGUELqecFHKQkNGPWVrhqFewMqLBmbRkqjshOBruvm3W//DpuMoEQgr72Ada9twEowWCTjrbGXUFEF3SnIOl6Bn4GRsDAX12YhvZqzg3McAChSZxkimRPFJGmTE30JbBjdnb8zg1RagImPbEkc7/yaTb87k9F85ZCUGVIoo5CpvdbvaqPNav7qDY1mnzp0opBdfSmLknYbracJr8uOBW18ddSlnlHKUUqqtj/5l/yysUfJ7pqTWFmRAr8Y0ez+w++sWl/hA8Y+hYsyP57WMpVvMbpIbfRNPreeH1YRwSg/pyPsSHaj+rdgFldDcol0d1Dsr0TqWkYwVwTtWYa2LEEQtfQ/cXK59LQiUwc5ZUILd2QpXcOj0n3KJR6flCEx9bStbg1p86cPU+JcpVXuqWyOwEw9urrWPuHnwJer4xMl3ZkNDUG3+d2fOhoatt9d9L4obPRAkE0y2L6//sG4664nM6nn6HrxRfoe+uNIfcvBSElVm01Bz94Nx3PPE/P/LcQukbtgftTtfeew1LrbhKkpPnEYwiMHVOwOLpsKYu/9y3iq1Z6FL1Kwe8UNXMPo/aQgz1nZPCxhKD2oAMIT5/CyjWrhz30wJKlmAEDNzpA+7230/X4g0y4/gdYo8du2jlUsEUwp+yBvWYhetMYjAkzSm4jhCS2Yhl22gkp1YcWGVNLvDtKdH1fAQW2ls5wdC7pwoqYBOqD2bJFqWsYYT9Sk9lglxcAcHGTNv7mWlDgxJOkBuJITRJoriLYUk3He+voX9NdMM/UQMLLxoTN7Dep/oSTR+xaVbBzoVKatWWoOCI7GbofvSfrhACseLPVK4EoExn1tlM4SMb6DVrjdlbRXEhBuDmU3TZjZIbGNmBFgggpssucpE3PsvUkugc8gyzhRYVTAyn0aIrx1RbUBTAXL8w2zucj6SoSrlcllZuX9/B1JRxcpRg9iH0r4+gYmkbToR6FaPW+e7H+gUfSE4aBDVGCTYECAznzobHjNhM//VkC40Zz8L23sfLWO1j9r/+QaGvHaqxn7HlnMvbCszEiYSooDz3v+igvUTakQ6L7hn+tqBICeyWRjFEzcxIkmrJ/15AQYAWhZRa9//s34GUrNJ+J6BPoPrPs/DTToG7WRKqnjmX964twE6msJkApCCEwghZG0MRJ2sVjCuH1kaSzjWZDI+Ou/jTV+x2A3b6ODXf8I9sXksmMFF2LdI/IUFCpFL3zXqHmkCOyy/yjRzP6gvNp+tCpzLvgXJxodJNYppRtE541O50VPJT6Iw7d6H2NmmqvfGrVmrJfUCEEKO98aw/Yh91/9M2C9Yn1rbz3hc9484bCsqoXniU0ezfGXXYpa/51O06/x1ikBYOMPucsJl51BdHlQ2sm5U40n/XMxRnoZ9WvvsvkH/x+o/rHKhgZaPUt6EE/+tjpKNctKSSrbJveR+9FGgZmTTUgSPX24sZzZZdKKULN1fSv7sn+rhxVIEQa70pgxxyqxkU8Uoigr2TPFkIQHNtIsruf6Ibugmy/NDQCDdXUzWzBjiaJdxWWdCpX4aRcdJ/OhM98AauxaQSuUgUVfPCwyzgiSinWrVvHqF1cxGrgtecKXqT9HQNlnZAMVJqRwdQEYwIGKVchDQ1/jY9YT9xrzk2/pCPjG/BV55yTbHOroVEzbRSd768m2RtDtzT61vUT64jn5uM4dDz9LIZPIzVIu6AzkVFdLj3XnqRLneVgDSqnEUIgUUz66AUATLri0pwjAjgJh/61/ZgRCzOUFsizFY4ymPz5zzPmrA8BYFRFmHzVZUy+6rIhr1UFxYjMmsnavL+J63jMWYOdPyEEVpXlNYsOZVg7DqFZuxUsUnbKEzwzcyKFKhEl9dqDYHtlfwUGRDIK696l6vizGfjfrdn1vpoIjl0iuyAEeiiI9FmecwGMO7aWvqWrSfb0DZ/lMfWiksT0sCAETaefQfVBhxKavXvWwGo880LcVIr2+27P27gYGxsJc2PFvS0AejDIzB/+hPf+7/M4AwPZSLKSlO+NkhI9EqH2sMM27uCDIIRg/Ecu4v1v/aDcBghdp/mEoxh95qnUHbx/0TVuvfP28s6T69L/1puMvuBiJlxxGQOLlwKK4ORJ2XIxX8sohKYNSzQhB/fQuC7JdWuIvvcWwVlzNvaUK9hCpN56ynPGA5GSTghAfPF7hGdMwz9uQvZv68YGSHZ00Pf+AtxEkkTPAPZADH+dDyfpEu+Oo1yVJWDIBNDcpMtAe5RQY5BkfwxfTajoeGYkiN0Xp39NR9E6N+XQv7aDYEstkfF1RY4IgEJnxk9/TXDq9C2/QBXstHCVwt3ClMaW7r8zY4d2RHp7e7nqqqu4//77qa2t5fvf/z7nnXdedv0tt9zCxRdfnP39qaee2uUdEWUXZhuGiubmI98EqG0OEajzo1mFyspClwQaq4uPqXLRpvDYBjreWemNWOa50Q0NO5FHw6sU/aVq6dMIaIKgLoimXKIpF10K/LrE0HJsQFXTJwNQNWc2Ez/+EZbd+Nfs/q6tiHfGibXHiMyZzayvfp6affYo+7GrYOOhXJeupx8ftNC75kIKkN7fVSnw11j4qn2eiF450UApsZqaiezlMSclVy4g9urjpFYv9laHqvBN3Q3N0HF72iAZQxiW179QMAcFiQGkoSMCYVTME6yUhl7QvC2kRGgSLRRE6HqRk2vVRkj19lMO0vCaXH21YaIpBzdZwsmREjceJbz7HgWLhRC0nP8Rao86niX/94my2iqlsiSlYLWU72MKz5zJXjffSttDD9L5/HO4qRShGTMYWLyEvvnzPScoc3ypIU2Dmd/9HtLYfNXk0eecQe8777H2znuyjGfe+BI9FGTvP/2OyKzSJTgA7Y/9b+gMjqbR8cSjVO29D5HZM4tW6+EwtYcdScdTT0CZDJsQoJUSbpSS6OL3Ko7INoJKRHHWLMJLoydQykUMouZWroNlOuhz9kVImQ1uKNdB+oI4SZtV9z6WDQjoPh3dB1bEJNGbzJZICuE1JJoRL8PupJvdXdvJsuhloAcsuhcOXd4Xa+shPKF0tkO5bsUJqQDH9X62dIwPKnZoR+R73/seF1xwAf/3f//Hj370Iy6++GL2339/Jk6cCMCTTz7JK6+8AoDP52O33XYbarhdAsK0cOOxrEHVPKWOJe1e2cJQNLamoYHrejz7zUGkLrLN6Rn4asIFHotyXVKxBE48x3gldQ0z4ifRE8Vf6yPWWchUlDmeZurYCc9oG4qwqsaQmIP8BdtV9CUdggZYuiQwYaynMZDGtC9eS2jaZJbd+Ff6F3p6AVZLExM/djHjLzm/YNsKtgytt/6JgbfnIQ1JsDEEQhBtH8CJ20UN1pmSLM3ScB0XZQ/6w0uJHgoz5evfRkhJ/O0X6X/89lymIM24xYal2OQxcCbjYFhIf7DoHnc3LCd47AX0//fPgEKgIK39oQf8XmO4EKCVftWZkXARq5pZFcII+bGj8azxHhljER5dR6ytl+6l6wqdcKVQqWJWuAysxhZqjjiB7icfKlkyJjWZbuou8yUSArOhkeCsYZr7q6oYdd75jDrv/NzUbJu2Rx5h3X/uIrZyJZrPR/3RR9Ny1tn4tjBoI6Rk5je/QuOxR7L6tjvoW7AIPRCg6cRjGX3OGVgNxQQA2Xkp5WVvhoLjYPf2DrnJ2Ms/Qd/b80l2dJR0aqyINcR7sRKo2FZQsX4yD427fjl6w5iibURvG3ptjqo617MokVW1rPnfzQVZyfxsrBUxiXcnPDprS0OzNAyfnmXGAnCSdtYRMSNBrJowumXSvN9Mkv0x+te0EWvrKZqXazsF38B8GLW1m34xKqigggLssI5IKpVi1qxZnHLKKQDcdNNN3HHHHbz66qtMnDiRF154gRUrVtDV1cWRRx6JPjhiuosiuNfB9L3wWPb3lmkNLJu3BjfllK2Ln3T2KURqI6y//2FIROle1oPQBP5aH8H6QJaTPdAQSbP7pDUOVDFTkms7+Bsi6bp2r6zLtQsNAKFpnvJ2OrWeoXUf7I8ENIEpyztQAykHQ5dMuPT8guVCCEafcQqjTj+ZVFc3ynEw62orGZARRrJtPR0P3k3V+FpqpuayCdUTarDjNhveasVJO5tSF9nIc5YaNuXiJB2Uq9D8ARpPP5vGk09FD0eIvv400Wfu8Q6UNhSsmupshL7ojkglUJqGsAYpfNtJhJPEqKlBxfoK18mcIZPPvpMPoUkCzQ1E13qED6FxzWiWQbytmJZWCEGgsQo0QffCQk0c/8QpZa8jQPMlVxFfuZTE8sWoEve8ETBI9iUKMxcA0qP5HfvJz23W/S10ncYTT6TxxBM3ed+NGl8I6g+dS/2hczd5P6O+nlR7e/mNNA2zaei6e7Oujtm/+j1r/nEz7Y88hJvWqtADFoYlymeMXZfg7D03ac4VbAGsnECnu2Elbn93YYmWcpHKLv2MCkH3W+9i9xU7rq6jsGM2bjrrIdIlo07CwUk4aKbEDHk9Y3Y0ge43CTTV4qsOF2QojaCP2unj6Au20bu8teg4qf7igBtC0HzqqZt6JSrYBVEpzdoy7LCWm2EYXHLJJdnffT4fVVVVjBs3DoA33niDDRs2cPzxxzNlyhTmzftgKGPXnHgO0vJlX6K+iJ8jP34w+5+3N1MOnoTl0zGEp7BuCKiZNJ5p532IzsceR6QSWW9AOYpoW4zOJV04KZfqaS2YkYDH6pPWXZCGjq86hK82UvSBCDRVoYBQc7CgvAu8TMrkKy+l4dADvbGEIGzKIuMroJV2QPIhm5sZd/F5JdcJITBra7Aa6itOyFZA59OP4asLIc3ikibdp9Oyz2iELtH9OtXjqtAMDal7ujQi3cRthkysiMXUb32P0Rddihbw033Hr3NOSGZMXUfz+8o6pQAqESssbxIC17aJPfHPYicELxugXNe7d4cY19dYS2BsC+EpEzCrQiR7vFItaeiYVSF89dVYdRFP5EwIAnURtDxldyE1ao8+fshrKYRgwld/TOMFlyMMb9/suQhPlbzmkEOoOmCuxx6VRnj3vZjy7Z8SGiYbsjOi8cRTC861CI5Dw/EnDTuOUVPLhGs+zd6338Oet/yLfe68j3GXfay8EyIl/mmz8E+aupkzr2BTIf0hZOP4tKPtYs97BNXjidgq5XolmPlMcqkkbmwANzaAcmz6FizOPsOapeOrDSE0nVh7jNRACifh4iZdnLiDHbW9jKxSOEmXZFpoV7kK13bxVXvkG6UYucJjGjAjOacpg2j7oPeLEFgtLTSfdvpIXqYKdlK4SuFs4c8H2RHZadIIq1evZvTo0RxwwAEAXHXVVVx11VUsWLCASy+9lFNOOYUlS5bg9/uL9k0kEiTyVF17h0n378jQfAFGfe4HtP7u2+gima0vr9I1Fj+xCJXKKSULIYiuWsO8j38aTZclSxdcW2EEfZgBX7a2vkiF2dCwIgESPbkSMAUYAYtkXxJftY9oR070TRo6k6+8jBlVERLtnSS7uknaDv886RJind3Z5lJ9uNp4IQjPmY1mVZSRtwcSi95Elilzy9RhN8xsAGdQNk56fQ8ZEczw3vsTnOmVTfY/fjtO29qi8TSrPNMVQiBMn5fZyINyXey1QzMnuakUUtcRyLLOiNA0QrvvhbN2CW4iiZtMYYQDGCG/l5EQEhBolg8jnCLe3kPNlFG0v7MKlMu4T30eo6p6yHl4pyGoPeYUao85hdiSBfS8+BRObzd6dQ1VBx+Fb7zXB+UM9JPq7kIPh9Ejw4+7s6L59DPpeOox4qtXl3w3NZ56GsHJQ2ea8iFNE7PeK+2pO+lMEutW0/PMY56zk3FIlcJsHs3Ya740YuexJYgvX0TvC4+T2rAOGQwT3mcuwTn7IsqUEu7MMPc4kvijf0dYfmR1PaxfhtOxGiV1pGkhgyFwHZzezixBRQbVsyfT+/5C/LVBjKBFvDtK/9oy33EFTtzxMrTSIzRxAwopBamBxJCMf8pVBJtrSfbmNaYLQf+awpKtmgMOYMqX/q+AUbCCCirYPOw0b7vf//733HjjjUXLp0+fzr333suMGTN48sknObFECcL3v/99vvnNbxYt31mhB0P4qgK4USdbxrHk6SUMdAwU1T9puGiSsk2hzXuNItQSQQ+Wj0YLIdLUqNECikSpa2l6UwM6Y9ljT/viZzCqIoAngGbVe3W0H378Xzz62W+y7LFnvbr6YTQphCbRQ8XRqQq2DZyuDUP+jYQQWGEfie6BouiiUgqpaUTmHsXoj13jUUD3dZNc/GZpmqhyx/AFEIEwRcVargOhOtS6lRtxIg7o5SPvel1Ldjvlumh+CyMcQOhm9lwg3fiu6/gaPMekat8DaDz9HILTN13IzD95Ov7JpZtctWAILVjM8LOrQQsGmfmTX7Lyxt/T+eTjqDTbmR6pouWc82g+61wAkuvX0Pf8Y8QWvwuAf9puRA4+BqOhuezYQkpGXf5pqg85mq4nHybZuhYtFKbq4MOJ7HdISYX3bQnlurTd/mf6nn80z1GSRN96BXPUOEZd/VW0UGS7znGkIavqMabtjcBrVC/Ibuq6R63c1VYkXgpe1rJm5njsPs/56FvVPfTB0oKjmUyInbAx/QZuKpV9Vzkpm9iGrqzTYVYFCTTWeAGIfASricyuxz9pGpG99ycyaxa+0bs2KU4FmwZXbXlp1VC9tLs6tpsjsm7dOvbaa6+y68877zx++ctfAvDEE08wZ84c9t1335LbNjY2ctBBB9HTU9xoBvDlL3+Z6667Lvt7b28vY8fuvGJW8QWv4w7kokF2wmbd2+uKmzAATZNljUl/XYBQcxjdZ+Y1Bgp0vw+pa17EOZZAOV6WRaYF4zLIOCVCeI3vZkMTUz7zSUafcUrJeVdPHMfZd/+JnpVr6FywhPd++ns6X3+rLP2msh3GnnD0xl6WCkYarjOkowjk+jAGQaTLoXyjRmX7Pux1y8py1brJVNGxhBVABqtKH1fTPeNlY+C6ObG8wdANz9FJeWx0Wm0TJi5Czyu9yi8ZUQppWughPxOvqAhhbimMSBWTP/8lxn38KuIrVyAMg8DkqVnhx77XnqX9nzd6jmo6mJJqW0fvc4/Q+OGrCe6xf9mxhRAEZ+5OcOaOV9bW89SDnhMCuSBR2gBPtq6m9a+/ZPQ1X9tOsxt5KOViv/OMRyZBsZ6HslO4TrKkEwJg9/Tg9Hs023Y8SbK3RM/G4GM6CjQ8lr+kA34j+y6Kd/XRtWBVwTsh0d1P/6o2wuMbAdDCEVou/gTVc4/YvJOu4AODCmvWlmG7OSItLS20thY3hQ3G+++/z9KlS/nYxz4GgG3baJpWZLQ4jsP06aUjjJZlYVnFSss7KxJL3y1oao129jNm90ZqRkcQmmCgM8b6RZ30ru9HymJ2LI+OFyJjIiQH4jgpBz3ow19fjVlVmGo2IyFS0Rg9i9fQs2IDTixtsFk6yYEclfA+f76Bmv332ahejapxo6kaN5pgJMTDp15cchuhaUSmTGD0cYdv8vWpYGQgfX6cvuTQzsgQUSB/QzVi5et0/3kB6AayprHstm4yiZuyEXru2fYyIUMcurO4xKskhEAEQijbgUShFoAM13hRU8MEy48+aTfc3vb0bqUbZ5VSGJVM3YjCiFRh7FZIpZtct8pzQgbLFqcN9w3/+C1jRo/HqN+5hOSU49D92H3lN3Bd4oveIbFmBdbo8dtuYlsRqqsV7ARIHWEYORY71wUnhXBd3Fg/CInQ89Y7DspOElvbCsJTQk90lafbLgcn4aKEIDx7N+x4lK4FK0sG7pTr0reyjTFXfZ6qAw8tpg2voIIKRhw7dIdva2srv/vd75g7dy7vv/8+b775Jt///vexbZsf/ehHLFvm1Ye/9957WJY1ZIZll4JjZz/MdjyBSCVomlqHFTIx/QbVLWFmHDGB0bPqCQaLX6RCE9ROqUbTPTYQN2mjFFjVXimASDeYZwyx7sXr6Hx/ddYJAXASNpou0Xw61fsfSO2B+21yw3jjAXtzyA0/QpqGZyxqWvbFH5kygaNvv6lsj0IFWx+hfQ8dunlcqZK0lppl0LjPNKonj/ISEYkoaqAHe/WiIZvGE51d2ZI9DLPgflKu4zWrR3u9n1i/F1g1fUOfhKaD1MBVaLWNaI1jkNUNaDVN6M3j0UJexkUIgT52KigHIYsDHfkQ6Xu1nC7IxiDVvp7Oe29h9XeuZdU3rqT1d99mYN7zXnP9FsLp6aT/pUfpfepeovOfx00MHz3eEdH73CND3i8AvZmswk6E5Po1OH3dQ28kJNH33tgW09kmcNtXetlHf8D7f5oNjgwTnm6A1BC+IOim9wxKzdvWF8zS5LopB9d28NUFadxzPKMOmkLjnuOxqosDA0VU30qj8dzLGFjfPaTgqnJdUu2tFSekgo1GhjVrS38+qNhhn7R4PM7JJ5/MvHnz+PWvf51d/rWvfQ3Xdbnvvvv48Y9/zJVXXkkkEuHWW2/djrPdtjBaxpNY7JU0ZXjPM2qyXm2si3IhVGVh98Rx88XlBNRNqUX3e0JtwVF1aKZOeExTyRKuWHsPne+tIJNRH7xeNyW1cw/a7HOZeObJjDriYJbcdjdd77yPtCzGnngUo44+tOKEbGfUnHg2PU/cDxTfFyodpbYHOyJCUDd7gqffQaEdKQCpabillM/xWK6StkZg+hzc9bkmdOXYRZkMlItIJdCqG3A2rCpcJyVadT1auMozZsAzxpWL0A0v4irSLG55L38ZqsbVNlbgT5BaOh9z8p4buX0O8WULaPvLz7zzSjseydXL6Lj9j0TfnUf9BVdtlhaOch16H7md6LxnvYstJKSXRY47l8CczX9OtwdiC98eWvDQdYkteGvbTWikUEZ8sQCCoc99J4OyU1nq7VJsVWg60irtTCilCE6aQnTpcgZWraF6ymgCjdVpp93LklRPbiDW0U/7O6uJtXkZE6EXvrPCex6AOWYCyYHS75/cZBV9r79Mw+kXbP4JV/CBQob5akvH+KBih3VEfD4fr732Wtn1zzzzzDaczY4F/+4H0f/cA6R6B7KGlFLK41LP0PMqRbApRLApRM+KHnpXeQ6Lr8qHEfCMLX9DFZqpo1kmur+4dM1NOax++h1i7fFsP4hmSoyggWamDSUp6X/7DRpO+tBmn49VW8Osqz+62ftXsHWgmRYDMR9+vR9pFGYJlKvSjFRe74XreI6JrzY8LMtZRl8mpy7j/V9rHEPVGVciLT9ubzupeQ97Ds9gJyQP0k0ip+1NasX73nZSYrSMRxhmwXyl5UsbdiKPMlZ4iuAZNq5EDGkJtNomnN5ORBmDUaU1SdwVb8MmOiJuMkHbzb9C2anCcqP0v2PvvEbfC48SOWRoOuBS6H3kDqLz0u9FBShv/iqVpOf+W5C+AL5pe5QfYEfDLvphNhpaEKaFSibKb+S6WOM3njFsR4cwLUglPAc7nW3PBDNwHS/Ln4H0yCC8Bn6ymdGG447D9/oruP3d6UEFbjKVFQK1Ij5GHzSFVDRB+ztrSHQXvjcG5j3H4k9fiHBdjLAPZbs4SbukkOhQAqUVVFDByGKHLs2qoDRkMEzVyZfiJHIvS9d2C9LN+eVV1ROqCTZ5LDy+Wh8KMKsCaD4T5bi4jlPAhgUeo8ii/7xI/5rugnVO0iXelcCOpz8crkt0yaKtdq4VbF8Ep0yjc0kn3Us7iHUMkIomcVI2yrYRiLQja2AETDRLx6oKDVmylLkntUgtevM4ZKgavXkcoaPPpfrsa5CZqGm4DhGIFNF4ZmFY4A9528R6MZrHoDePwxgzGWkOUtOW0ivPSmsYpK0bMExvuZSIQAgZCCE0iTFxJr7dD0IfM7mswJrQDU/xfRMRfesVVCw6pJHd99wjm1z25fR1E319qOCMoO+pe7eonGxbwzdl1tA6I1Lin7rpjGXbG9LyETnoqCI66twGEr2+Cf/U2dt2YlsRwrC8Uqe8kt8c3bf0HBHdQPiDSH8Q6Q8gAkHPgcnAcVCxvqwT4yTSTkha9yqjF2QEfbTsN4namc3o/rRAqiawavxpAo7MMyzRAyZysN6MlASmztwWl6WCXQQuGeasLfjZ3iexHVFxRHZS+GbshTlhBpArkykHpRRV47xaeF+Vn/CYek+0KV2P78STdLy7BDue6wFZ/+oSoutLs5ABJHqSWQdle1NhVrD10HTqaeA42LEUoJCax2Y22HEFj2453tUzbJ+DR/lsYtVVE9r3ECInXYxv9gFeyVQGykWbvHeJMhYBmTpykdO9EWk2q4I+JU1H+IJIXxDpCyD9IYTpQzZPyho4wvIhghHQDZTUQbNA94HhR2sajzG5BOOSFQDT8uraNxHJVUs952cION0duAPFAo1DIb7gjSHr3kFht7fidG7YpHG3JyKHHDt0eZJShA8+ZttNaARRe/J5WOMnFa+QEunz0/yxz+0yIq1KKYTtZX+KmPFEuorQMJGWr/CchQDdQvjDoOnYPZ25+8FVOW0YKdECPoxQAM00sox94VF11M8aRbClimBTCCkLRXUz/9Z8RiE7uOtSc/TwQpoVVJCB46oR+fmgYoctzapgeATn7E/03TdKGoX5yChhBxqChEbXluz1cJM23YtWUjVpND3L1jGwtpXw6BB2wiHZl8RJFJep2HEbI2RRfeAhI3peFew4CM2YyagLPsz6u/6FETRxHbeAyCAfQgjcpE2ydwBfzRAaCJqGlALVvQG7pw178TzM/U5CHzsTt3s99tL5uO2rSu9rWrn+jlJwXZSUnmFj+oozAFJDda71mmGD4VwZiOY5JkpqKMOfjdKKah1Z14bbsc5zbPxBMCyE6yBqmlGJGMkFr5Jc/AYqEUNGajFn7Icxcbdsf0rh8TfOuNzUHhE3EfeolId5F7iJ2JDrdyRYoydQd/ZldNzx55zWBmSpmBvO/wRm486p5yAtH6Ou+Tp9LzxOz3OPYndsQPoDhPc7lKrDTkCvrtveUxw5JAa8/qyhCCCMwmCWkhpoJulmGYRhYYwNobdtQKAQPj+J1avQfQZGOFgwthNPEO/oQgkHISXhUdUAuLbX6K5cJ/ucZLIrmqnjpFxwXZou/Bi+cRNH+ipUUEEFZVBxRHZihPc7hI57b8Xt27joaWR8LXY8hZN00AwNPWAUvMBT/TFWPzEP5Sq0dFUzZQoAAGTASURBVLra0ARm0CDRkyDeXVjT7NoKaZjUHX/yyJ1UBTscxl52Oc7q90isXobUhjek4x29+GoiSNNEmF7WwE0kUKm0YF0gj+kq7SgkX74ft2s9buvSwuikFJDvA2vGkAaNB4Ew0hmPoghsWsnA8nkGrRAgDa+lwhfxWkgS/WntEQ3XH0Gbug+oV7JjKaW8yHXTRPr+82vUQB+ZdIQT6yPWupzkotcJHntRkUK2b+pu9L/w2BBTFxgtY5H+4DDnWAi9tmH45mYh0Kp2LgM3cuCRWGMn0vvsI8QXe7Tl/mm7E5l7DGbLzqsFBSANk6rDTqDqsBO291S2LlIbofmRR5SipA666ZVRkXmyFELZBGfsDiicRBy3awN6wF/0jEvLxN/cQHTtevwNVdjxJKm+GEK4SF0DPI0sN5VjnxS6TmjmbtSdcDrBWTtRH1UFOwTUCLBe7UxlsyONiiOyE0NaPkZ98npW//wbOLGhI52pgSTRtihdC3OlGUbQpHpSPf66IMp1ibb15CKqmTra9EveqrJwkg6paK6pUJoGk77+Pcz68voQFewasLvbEYOcECMSyJIc2ANxUv3ePSh0DbOhDqnrOVXycAg3mSTVP4D0labcddYt9uq989/HZgBs2+vtyNDqZrIKmdKMjCGSLlEcjnZTCOH1h2Rq9KWGskLIRB+4Nkq5iFQShUIkBhBWELdxPLR5Ku5ejBbirz6CivZTUBOVPl9nzRIS8x7Dt19h07l/+hz0ukbsrvbSjoNSRA7f9LIQ39Q5CF8AFS/T2C8k1tTd0YJDa7PsiLBGT6DhvCu29zQq2FwMWYrouRpZJwS8TEheSabAY91SyTjCMDxWyFQSIxwuyUCWeUeYkTDJ3n7McAAj5MceiBPr6PWe0bRAr5tIIqQktPcBtHzsuqKxKqhgY+Ao72dLx/igouKI7OTwTZjC+G/9huVfuwY3HvMYsHymZzQqcJJJYl1RupZ1F7GDpAaStL21lrpZzeDYRNuiJHuTOEkHBFhhE3+9H93yDEozYhY4IlO+/m1CM3adhsoKSkMphdPfh2bqKMdF85mExjYi9ZyWhq82gpNMEV3fRf2+s7OlRQU12YaBWVNd2gDPZDDyFgnTh9AkKhBCRfsRgTDCF/CyGnYK7FSeTnPaiBGifBNwBrqRrT/HSaKEQNhxlJOC+AAkoqiMsrrdj4r2okUacNrI9WLZrleuVf6qkXjvZay9jirofRFS0vDRz7Hhjz/E6enMCZOmS4+qjj6N4JwDhp5/CQjdoPqkD9P1n5vSh89nrpAIX4DI0Wdu8rgVVLDF8FeB0HIsbnhZD4UEocAXQek+b00qjpf9cBGO7ZVo2QkECe85ch0ECqOqBhWuQsUGPBpsQCUTuH3dqPiA14cWCuLaKaSu4SZt9KCPoKEz0NqBwCvJyjD4BWfvvd0uTwUVfNBRcUR2ARhVNYz65JfYcNOPPTpV0gagAM0y6V+3fsi0X/+aLuyYTaKnsPQq1hkn1hWnanwEK2yhW7nbxWpqonr//bfOCVWw4yHDdGPohMY1IeQg5htAGjo1syYjdb1sDwmAGqTfAZTspxD+AKRSXj9HTaPHbiWER/2bZtPKHsXwGtVVKlk0ThF8QZDpe1loKM1ESw7gRvs8Y6eqobAMK5XA7W4FfwSiPaBc3Ew2Zqh0eiqB07UBvWF0wWKjrpGW675HdP5LRN9+BTcRx2wZR2j/I7ao3Mg3fU9qz/8UfU/fR2pNWodFSHwz9iR8xOm7Vt9BBTsEVKwPt30VKhlDGBayfiwiUFWwjZASakejOlaSDDaQCjV6uiGujeZ6NNZZTR8z6PWTxPtA6qhUHC0Z9Z5DJ0d5rRwbFU9nYDPljz4N3R/E6evG7dqA0KQX+HBSiKDASaRI9g9ghAKk+qLpfTVkqIrQ3gdvs2tWwa6HkRAkrAgaVrDTI7V6CZqp52peNa/+XaUcrLCP1EACqyatISLASTrEu+M4cYdoexRll3kIFPSs6KV+Zl1Bf8DkL35hI2r1K9gVIIRA8/vAsameNhazphqZjiTa0ShOLJ7dbnDjaJkBSxjwg37XPGVlpXtGh8hnvHFylL4iEEZE6rNZB+W6nup6vL/0sQ3LM1wydL5CIpTrHcO00mxchcw6yrCQ4VpwOnBVmi40WFV6/BKnWgrStAjtdxih/Q7bqHE2FtaE6VgTpuP0duHGo2jhGqS/WCiuggq2BEopnBVvodYvJRMOUIC7bjGibizapL0KGbCqW0hoPmzd7zkeroPupp/jzEOSpteWiT4ve6IUMjngvRlcp0AzK+OE5CPLghWuRiXjuP29GC3jcNrWopJxpKljhoO4SZtUXzTLrjX62q9XmB8r2CKMBOvV1mbNam1tpbm5easeY3NRcUR2ASjH8RpglULzmRiRAFpa2VophTR1NCP3EgfQAgZSCnpX95V3QrIH8LIjVtgEKQlOnVrJhnzAoAX91EwZgxkJZRtLla5h+SycZJJEe6dnYGwMK1QJ61zZKaSZ3zuS0xgQYhBNbrq0S4SqkVUNqGTMcz6k8JitdA2lXBQl2LUC4bTBQ7ZUBNfxjp/WMCmerkBJDeHzQ58E3cScsjepxW8OfZ6mD1m9ffqntEgNWqRmuxy7gl0f7tqFaScEBgcRVMcqHN1En5CjvnZd13NCwCNNcOzsXq7QUUICCukkka7rPf3KQbhOOhuSJ3iY0RaSEmH60kEFPDp62/bY68LVqFQCt7crp0ViJ9GEyIn3CoE1fgpm087JvFZBBRuDZcuW8ZWvfIXW1lYef/zxgnW/+MUviEajDAwMUFdXx3XXbZ8+qYojsgvA6e3CjfajB31Y1YWCcq7t0Lu8Nft7vmGmWRpV4yJ0LekelgI4FU0BAquhgRnf/U4lG/IBQ82sqRhWXtmfchGOCyikFPjqa0j29OHaNtIYmtlKIIolLxzbq/XONKQ7Tu4+LkUXLCX4gjgdaxGmH4JVSDue6xnxBVGGBZpXV058ADSJ0DJOTd4MnJRX1uW6XlO8nfTWC8/pyJSNCcuPMHzgD6OPmoLWOBanbU1aJLEY1uyDCrVRNhFO+xqSC19BdawFFDJSjz5tP7TmiZXnr4LtBuU6uOuGFrFVG5aixkxHpHutEqk8R0IpBC5KaDiy8PlwdD9O2MIcaEM6pcVMleuArnvPI6QdEYkCpG6gDBM10IsKRrysqnJRmoFIJVCJGFqayQ+liMw9djOvQgUV5LAjl2YppaitrWXt2rUFy2+//Xbuuusunn76aQDmzp3LrFmzOOGEbc/iV3FEdgF4pSYCs8qj/Mw3UqKtXbipYmaRzHbSkFhVFvGu4SgWdcZefiWNJ52EHgqN1NQr2Amg4gOYPp2s8e46BQ3nnjEg8dVU4SQSYAxjfEtZSMmbOU6sH+EPQbrmWyUTnmOiaQVZFAWoRAJWLcwbU0NV16GFqlGGD4I1BY3vBCJeE3oqjlAqraiu40idHj1Mv27REF2N3x4oaIDHTqI0A0x/lv1Hn32oN+RRFzDwwE24vZ2546TLzvTxM7H2PGLo61AGSikSL9+PveT1gt4Zp78bZ90SRHUT/iMuQPgqJVcVbHuovo7CDEXJjRSqZwOibgzgZUTykVQiGxQodqolyWADVu9aXKl5pBK6D+yEFyTQdIRuIBDZdwVCpLMoHnED4WrEQG96lURaflQ6W6v6Bzwa6OlzCM6pZPYr2HLsyKxZkyZNor6+vmj5T37yE0499dTs76eccgq//vWvt4sjsmtIt37AIcNVmNXVJdfF2rqH3d9XZQ27zfhPfIJR555bcUI+gHA61pB1QpQqyXqVMSU00xhaz0J6HP5y1NTidUqhon0QqkWOmY6INHiGeCqZzY4ox0bFoumsRR5cB7erDRfhKZ9naH3T2RuiPZ66s+t4P6kEsaTNEms8G4x6aqLr8KUGCs4ldwFSkErvG4wg/R4FrgxGCJ1+Nb6DP4TWOA5ZVY8+ZhqBYz5M4OgLSgsabgRS7z5f5IR49fEKlIvqWkfswRtxY5umvl5BBSOCEpS5w21XEByzFTHKOSFkgw6ubqEizShfFcofgUAVROoRwRqwgigrkGPK83bM6zeRyHBNwZhZbSHTT/Uxp9H0kc9ssnBoBRXsCkgmk8ybN4/p06dnl02bNo0nnnhiu8ynkhHZBSCEwKitQ0W7ita59tAiZ0IIhDZ0mYf0+2g+rSJaWAHDiuYppTxDXjMKmsrJRC+lBCeOdcCp2IteIbXoNUiktS98IYxp+6JP2SdroDg9G7BfewhhmF4zbGyAosZ2vLIprWUC+MN5jfDK08WJ92XLp0S63twRgpU1M1BIgtF2Qqmeocud7KRHBTp9buFxDQtr5v5YM0cmsqoch+R7LyDyKYhLlH6peD+xB27Ef8LlyI1snK+ggpGA8Ec2bsO87QxcUnaSpJJ0xGBMuDSzHgBKYcR7vBiC0EG4HqGEkN67JRDxghZCgpuCRCyreaWUSpeNpiAYgT7vm5gRRhS+AFaoBt/RZ23JJaigggKMZGlWb29vwXLLsrCs4YPFm4KOjg5s2yYSyT2jVVVVxGIxurq6qKnZtv2FFUdkF4E5fiqJ914uWq77TZKp8ml0pVRWN6SEfYc0Tfb49c8wIhv58algl4OsbSF7g5Tph8jA6++wPcchUzaR0clQCpJxZP0YhJQY0w9An7ofKtoDCEQwUmiAA1pVI7Zh4fZ1IQIhKEXPq+noLRPTxxM5p0MIlJtC5M/ZsQHF+sg0T8dAKZq6F4A5XC+HQtkJjODWfQ7c7vWQiOaxgA0RfU7GSLzyAP4jLtiqc6qggnwIXxBR1YDqaafkRwMBgTAiWI2bSuD0dSLsBCbQ4/oBX3HWMX9vO+ElNjQrHVTQwLURbob+W/O0gJRCJga8pvXMvkJ4z7VuIUh629l5LHtS81TbK6hgBOG6CncLWa8y+48dW0jh/o1vfIP/9//+3xaNPRhGunzayCujzpRPDi6j3BaoOCK7CPxzDib5/itFy4PNtSR7y6gt4724490JhExHk9L3oB4KMuqcMxlz/jn4WnZMyrcdCSoZR8X6QDd3uQi19IfRxkzDWb1g43ZQCjeeNqbTbDikElnhMXOvY7KbCikRoaGjL9rkfbDfegLV3V7SiNAitTkhQ9dJGyPp8fNr2V2vud4VkqgRAQX+WEeaRnT4pnLRMHHYbbYYeY5HSe0fqSEsf456ODlA6p2nEP4IsmG8RzNcQQVbGdqEPbHffTodGMi/TwVoGvrkfVB2EqerUPQzigEIko7C1EqXZulOIidKmimttD2NKyV1T3ldKWS8F1BFTk02M5J2VgqgFFrT+C059Qoq2KpYtWpVQaaiXDZk3bp17LXXXmXHOe+88/jlL39Zcl1dXR2maRZkX3p6evD5fNTVbXu9qYojsotAbxyDPnYaqVULC17MvvoIVluIRFehrkLGyEn0JkjFPeNH6jrKcWg8/lhmfuf/IfXK7TEcVKyP5DvP4q5ZmIvEVzVgzDwYrXnSdp7dyMHc61jifZ24Xa2QodcsAa80wst84DpZOl9PxdjAnHs2WmjTjGWtZTLO4ldR/V3e2IOMFxGKILQ0BWhGeHGwgeO64NokrTB94bFp00kRim7wqHuHYaFSSqGPnj7kNiMBWdXg9dFkekKyEMhIbbZBXZg+hK57mgq97ajeDtz1SxH149KlbZX2vwq2HoQviL7bEbhrF+K2rfQcaCER9WPQRk1H+ILYnWvL7t+XdKkPFH9fhOukH+G85zGd0VCIrBOCa4ObKvse8p5/ry8kEwARQuDaKbTxu23eSVdQQRm4I9CsnkmoRCKRAkekHFpaWmhtbR12u1IQQnDYYYexZMmS7LKFCxdyxBFHbNZ4W4qKpbkLIXLSpfQ9chuppW/nIsJCULv7VBKyhq4XnkclPHYsaZpUHXQ4+riZbHjwf6S6uvCPHUPLGadRs/++FXrQjYCK9RF/6javxyEv8qZ62ki+eA/G3sejj5u1HWc4chCmD9+RF5J8+1ns918sZJZKQ6WdBBGMgD+CCFZ5asuGhWwcv9m0s0IIjH1PIvnkP3LXOeNwmD6E9AzyjNp7oaMisg3qCX8NAzUTCSR66MckpnSsWJfXAJ9PHVzivJSQWSrSrQlh+tAnzsFeNh+Rd4Vldb13rkKAYYKmeerUmRKuVNLTQ2lfiWP50cdVjK0Kti6E6UebsAdy/ByvH0zTsw6wspMFhBJeU7lGQDgklUbUhv6kS8iUWV0iAOGmSsQavACP0sxchlU5Q5Z3QTr4YZio+EA2QGLue2KWbKKCCkYKOzJ9L5Qut/roRz/KTTfdxOc+9zkAHnroIa699tqtNoehUHFEdiEIwyRy0qU4XRtILn0blUqi1TZhTt4doem0fCxFsnUdCLCaR2cZQ1pOPnE7z3znRPLd54qckHyk5j+G1jIFYewaNclCM7D2OBKtbhTJ5+/2GJzy10uJuf8p6BNG3giWgQja5L1xlryeo+wEr2+EdFnWYCfCsb0f10EJSV/tFELJbgxS1MXXsdYajWYnEIAb7UcGI56DlU8VrJTnyJRi+dpKsPY+FrdjDaq3w3PsAhGP6tRxUGnRRr2qDmmY2cymEAI3mcDt78Zdtxg1eoZH611BBVsZQoiikknl5JUYaqZHqS01Ii50RwEUnXGHpONSbUn0TI5SaChN87KpmQGkjvJXewQYGRg+XKWQicJM/+B5qUyWWtPR9zoeraqYxrSCCnZlPP3009xzzz2sWbOGu+66i1NPPRXDMLjwwgtZvnw5X//613EchxNOOIFzzjlnu8yx8qXaBaHVNOLf56ii5VI38I0Ztx1mtOtBpRK4qxeUdUIAj51pzYICheFdAfqY6WinfQp72Vs465d7ddcNY9En7eHpgGyt407bH5SLs/RNLyMghCdEqAaVimX+Jk4qy9yV8NcCCtNNIJQilOphrJtCSc0LuDo2bn8PwvKBaSGERLkOKplAxaPokW2nkC5MH/7jLyMx/wlU+0oytKSipglR3YCQwlOcTpMHiIwzYphokVqcng5UbzuiptLbVcH2QbYkU7dQht9z5h0bQ0CTpbE+ITClos6SSJFzppEStADKSUI6SIDuK3EAgRuqRyHQEqVprL0+ET/67nuhNVS+exVsPThK4WxhRmNL9y+Hww47jPnz55dcd/3112+VY24qKo5IBRVsBlS8f1gGKYREDXRvk/lsawgrgDHjAIwZB2y7YwqBMeMg9Il7YK9dhLN2Mcq2PapOlW7oy9R1pJ2TTMbANvzITDlHel3AiZIydVRKZdXiVWwAFRvIHNAbL13isU1hp6Cr1St10U3kpD3BMNCi3dliZCFEui8md05K8xSnh703K6hga0I3UZrhlVPZ8Rx9LhAihWUZXtmmKMxAZv+tmV5fl3IyKwrHT/+ugjWoRD+iBHuXqGrCnLzfyJ/bLgCl3Eof2QhiJFmzPoioOCIVVLAZEPrG8HorMEaW/7uCtBM0cQ+MiXt4rDzrFniCgxn6XiHAdXNiZ4q0DkFavEzIrFGk+wM4qaS32WAGoExdrW5utjjh5iK16j3PmZASEapG9bahabKgMUdJr08kyximPFYwYfkQgV2Lua2CnQtCCDADCDuR61fM+78hlVdmWA6u62mIpPcuv6XAtQIejW/+ccL1iLqxZff6IEIlYzhrFuCuX5bu6TGQTRPRRk9HmP7tPb0KPsCoOCIVVLAZEP4QorYF1dlKaS59vJKl0dO26bw+aNBqWnD62qG/w8si6GbWgRCA0g1I2ljRTqLh0dhIdDeOsiIoZSNcB70hCKSb0uMDuN1tORpdKZET9tim56QSUdTq9xGa5t1ZA93Q34WDQISrkWbauRUeVaoyfFlBN4FXry98wW065woqyIdSCuxkEamFUpBAI6V0pO3i00QhQURakBDX9vYTntaPGsIhUWY43cuVdtzrxiG3YonozggVHyD15mNewCbzvXJSuGsX4batxJhzFMJXuWabC4ctZ80aQjFql0clN1dBBZsJY+bBlHVCAG3sTGSwepvN54MKOXY3qGmBZMyj9VQuZIo1pAZCommSuoHV6HYMAKEcpFvIvCOEQPiCaI3jEIGIt2+kAb1l8jY7F+W6JF9/BCVABMJo1Q3IqnpkVR0iEEIN9KIydKZKgW1DIpY5AY8pyF/JhlSwfaGcFIM1PmJKY53rp9310WNrdCWhNaYYSKXfoWlaXuGWEuD16HhLvm0FKMOPCtagNU2pOCElYC9+pdAJycLTeLIXFWuQVbDxyLBmbenPBxUVR6SCCjYTWsM4zP1OzjHGCEkmZqeNm4Wx5zHld65gxCCEQGuZDmNmQiruiUsq19M1EAIVrIFANUI5OWO9pLGTLinRNM/wHzMTY7cjttl5KNfFfudpiPejhWsRhuU5VU7KYxHSNGQwjEolvXPI7Og6WedECIGoGbXN5lxBBaWg3ML4bkxpdLgWgxWIFNCTyjgjCqFy2cwshMj9DIYQaIEIeu0ojLrRuwxD4UhCxfpQPRsoHzRTqN42VLS3zPoKKti6qJRmVVDBFkAbPQ1f8ySctYs8wT3dRBs1dZdTV98ZoEUacaUBq99B9Xeh7CRuVQNYYYQd9XpDhEC4KlsyUljwodJxV6//Qhs1dZvp6Sjlkpr/GG7HGk8pnlypSdbRTVMJCw1IJVGGmZtfKukpSfurYBMFIyuoYOSRT4EN3a5ZtDwfvSlFUNgl9YkKBsp7agE0K4CWFvmsoDTcjSRMcQe60QLDC+lVUIwdmTVrZ0DFEamggi2E0HT0sTO39zQqAGSoBjXtIFTPety2FQjdRIm8F7xmQsprbFWZDFbGmM/UomfogPs7YBtlF5zW5ai+dmSk2rO1XNcTLkxDZDI5muaJL6b1UbKaKspF+cPIUbMqYqQVbH8ImXbrFSkkzjDFF14+RA29VYbFLg3NF0BWmqyHxcayY2UolyvYdLiuwqmwZm02Ko5IBRVUsEtBSA1RMwpZMwp71TveQqVQuIDEBbTBTghkGbYQGko5XpZhG0Aphbv6bYQvkHMi/EGwAh5bl+tAIopwvHIyoXlK8jh2objjqFkljYl85eoKKtgWkJrmCRA6SYbXQPegBmU7Sg8s0X0BhG5W7umNhKhqyGPVK7eRRFRtO62kCirIR8URqaCCCnZZKDPg6YDYSZThI6EkQg+g2QOld8hGXaXXrL4t5tjdmmYIShtW1U2eMGR+qt4fhlg/RHs8JyStPp11MoLVyDwnRLkOqmM1qnM1pOIgNKhqRDaMR1gVRq0Kti6E1BC6gQI0u3Q/VhF0C+z4kJtohoWsUKJvEoRuIlum4q5dUHYb2TIFoVf6azYXzghkRLZ0/50ZFUekggoq2GUhAhHc3vb0L5KYESJod+SED8tApRm0tgXcthWec2H4EHWjvL4QKJ6fP+T1iMT7yTAIZaLCsnFibu6Ojbt8HsTyFKeVA92tuD3rkRP2QlTY3CrYytCtACmnD1030ZOKdD6v5LZSCHw+H6mBRKEDXgCBZpZQWa9gWGjjd0clY6j2leT6bLz/i/qxaOPnbN8J7uSoOCJbhoojUkEFFeyykFYAlfKirK40sHVPYX0oJySzTm7FzIGyUx7Dl9RwdQuaJkGwBhXvRQ5VnuIPQ7zf+3c6YyObpyAjDbmxNywrdEJya0Ap3FVvIafPrSgrV7BVITUNIxDGTsSoVjbtKQll2tHrQxZSSsxghFS0D+UOKiMSAiMQrvQxbCaElBjT/397dx4fVXU+fvxz7qzZycaeCIiAiAjol0UQcamggkur4r5QtdrWDVutC2q/Wv0VrYJabdVWa61+675hEbEsiqgoi4hsQhK2BMi+TWa59/z+GDIQyExClplJ8rxfr3lB7r1z5+Tkzsx9zvKcsVi9B2HtyUP76lBON0b3/hgpktxCxJYEIkKITks53BjabDD0yTLsaMsXduR6/Yrsqh2GgOi6GgLb16FLdkBmDmT0hgPGZuuENMxAHcpf1/jEXcNA2xwQ8EJiN2xHHBtc86T++ZaJLtsZuRABH1QWN3hdIdqDYbPhTEzGYVnYfH5KPX78B6z8ZjcUmUkuklyO4AZl4EhKQ5t+rMD+OVGG3SFzQtqAkZIhgUc7MK3W92iYEabwdHYSiAghOi2lFCohBV1bgUJjD3ioc6TgCtRGfJ6R2vY36dpTjf/7RcEV4DP7BB/1+wAMe3AuhyMB7daYfg+Grxp10JoMKIXKPKLxTG2+uv2rwoel0HVVMjlVRI0yDBIcNnpqP96AxtQKh8OO2xUM9v0+L2b9XBKlsNvt2FwJEnyIDkGGZrWOBCIirmmtoaYcq3RXsBXY4cbI7INKlHU6RPOozBx0bQWGv45Eqqh0Z+P3lWM3vYf0igR7Q9ong0xg68rgf9xJwZ6QfeuCaA04Exsu2qYUOBKwHG6MmlKU5d9XQI1KzsTWd0iYX7aZN25ygyeiKOD1YHo9ADj2PfD78QV8DTK/AaA1Ab8fM2DidLslGBGik5NARLQJrTW6qhirZEewVdbhxEjvjUrr0eJxvdqyMPNXQ8UeDpxgZxZvC6ZnPWKYjHMXTVIONyq9D5TtxGF3keAtpzy5Dyk1e3AFqhsEI5Zhx9FncDBtbhvS3lrwVGLYHWh3cjDgMf3BYMSZ0PjK0fvSCVuJ3TCq9waDELsLW8+B4W/OnAnBh88TqTSolKw2+s2EiMz0e0NByIGCvYC2sIkjtLYI+H04nJIlS8Q36RFpHQlERKuFAoaq4v0b68CqKoGEfGwDTkDZHYd9Xmvn+n1BCOzPLx/8V5ftwnK6sfUe1Kqyi67BSO+F5avFqCknyRHAafnxOJOpdaXhMOuwWz7sTifurJx2eX2zZPv+4MblxvBUovx1gIZaA8udipWQdmjKYKVA2dE2J4a2sHXvF7GFWCmFyu6H3rk+3BGQmIZKkBWURfvTWjcahADBtS2a6O0wAwHsDlkzRMQ3WdCwdaQ5WbSaVbS5YRByIE8V5vbvD/ucOuBDF++IfMzeguAq00I0g+o+AFt6b2x+Dw5fFSlWLWmBKpJ0HYnpPdotCAGgbHdo2JeBRvk9qH1LuCltYXjKsZfvCC5SeDCtwZ2CrceRKFvTAb3q1guV3a/+p4Y73ckYuce27ncRorm0PjQDVr2DVkoPf4que4MmRFcgPSKiVbQZQBdvj3xQ5V60txblSmz+eatKaHKVXctEV5cFV44VoglKKUjvBWndsXsqg5O6HW5wJbV/i6sVCAYdiSnBshxcNoIZr2zVezHTeh1ccIzENNTBY+nDUEqhehyJ7tYTXboL7atFGXZUWg9IyZTWZREfGs/kK0SHY+o2GJrVhQNuCUREq+jaCtBN553T1aWHFYgQrhXtkBN34Zx3okWUYYOk9Oi+qM0OZiDiEEUF4PcE544c1PNhcxz+qsfKlYTqddRhP0+INlM/96mxmyxtgYp8C6KUksBZxD2ZI9I6EoiIKDm8N9mBayNEPC4hpSWFiUhrjeX3YQaCk4mVYWBzujCa2SItxMFUZg56b37TxwEq4AuuFbKPYXe0+eR5IaJBqeBq6I3NE1HsG7ZlBVABL8oKDkvUdhfa7gLDhs0h64cI0dl1qDkiWmt27doV62KIA6iElGalAlWJ3Q7/vIlphO+7V5CadXi9LM2gLRNfTRUBryc47MwysQJ+/LXVBOo8Ml5ZtIjKPiI4Ofdwn2ezY09IbocSCREdNqe78WGFWqN81di8VSjTh9JW8OH3YHjKsaGxSeOP6ADqe0Ra++iq4v5d/sorr3DFFVeEfl6yZAm9e/cGYM6cOdTW1lJTU0NmZiYzZ86MVTG7LGV3orr1QpeFCxAVJKW1qOfC1m845qavggvAHdyj4nBiyxl22OeMRGuN31MTdriX6feGekeEOByGYcCRJ6B3rkMdHFwfEMhrFLiSMBwubA4nymaXFmHRoSmlsDtdWFU1aF9tcJiWYQ+mmTaD6+MceIWH/l9bBgmJyEQSEe8ClsbWykAiIIFI/Fq8eDErVqwAwO12M2xY8ObzjTfe4O2332bp0qUAjB8/nqFDhzJlypSYlbWrMvoMxqyrAk/VoTsdLmy5w1t0XuVKwjbkRKzd+ejSfRmFbA5UVl+M7P6oFoybjyTYAxJ5zonp82JIOknRAsr0NT5eXgdn7WqlUCmZOFMzYlI+IdqDVVeDta+hKvSpafnRfiL3EmqNrqtFSY+gEJ1aXAciy5cvp6CggLKyMk455RTs9v3Ffeyxx5g2bVro56lTp/LUU09JIBIDyubANnA0unQXVum+BQ3tDoyMPqiMvi1aQyR0boc7uIp03yFords1ALACTacC1toKuwCXEOFoTyW6aHOkI1BJGais3KiVSYj2pi0Tq6zw0O3QrKGKlr8O46BARGuN9nuxPFVo049SBoY7CeVOkgVuRUzIZPXWiet37erVq9mzZw+TJ09m4MCBrFy5EgCfz8fKlSsZPHhw6NhBgwaxaNGiRs/j9XqprKxs8BBtSxk2jKwc7IPGYR92CvYhEzC6929VEHLIa8jNv+igdGnkNXEASO8jN1KiU9G1lRxuopJIrICfQOlOzNJdaE8V+L1ofx1mVQmB0l2yrpSICasN5ofIgoZx6sYbb2TNmjWsX7+enj17MnXqVDweDyUlJQQCAVJT92dWSktLw+PxUFZWdsh5HnnkEdLS0kKPnJx2XLhMdFjK1ozMRPXpKIVoJh3wQV11+P2AVgZU7EbvGzMvRGdg1VU3mrpXQXAuXhPJPwyHG9i3Qnt1KWbxNvB72feuCZ7DMoPnMQMEKvZIQhEhOpi4DkTqDR48mPfff5+6ujoWL16MwxFsZa//F8DaN7bfamSM/1133UVFRUXosX17EwvwiS7JsDuaDDIMuxNL60avMyEaZTXeSqsBbbMHF1V0uNB1lVi7NmAWb5OWXdHhaa2hrpF5g/UsM/LnrTJQ7mBWRMtTiVV9aCPj/hfb93kc8AUDfyGiyNS6TR5dVczmiBQWFjJy5Miw+6dPn87cuXNDP3fv3p1x48ZRUVFBZmYmTqezwRCriooK3G43mZmZh5zL5XLhckmmIxGZUgpHQhL+2kNbrzUQMByYJuDxAmAYCrfDgcMuazyICGxhkirYHGDYDr0Z81Rg+T0YPQbK+iGi4/JUogJetDPMbYa29iUgaWS/UtjSslHKCK7rFCkICZ0vOHdP+zzgkO97ET0yR6R1YhaI9OrVi6KiosN6jmmaDB48GKUUEydOZMuWLaF9mzZtYtKkSW1cStHVGDY7zqRUTJ8XM+Dbl2rShg/7ISOdLUtT6/WRoB04HXGd90HEkLLZ0UkZUFMa2qaVavwGrF7Ah64qRqX1iEIJhWgHvloIeMGZGGzJOSjgDg7PMsFwgelHB7yAQrkSMVKzMfYFEzrgDfaeNEkjqX6F6HjidmhWIBBg9uzZ5OXlAbB+/XpcLleoF+Waa65h3rx5oePnz5/PjBkzYlJW0bkow8DuTsCVnIYrpRuW3RVxuqXH55dxyV2Y1hrTNDFNM+yQPZWZE1w7oZ5hb3J8vD4gcBGiw1E2FKDq9k1Y13r/NV//r98DdZXg9+xb0NCEuiqsvXlob23wmMNsKVYx6A0xLYs6n4+aujpq67z4/AH5TuhCZEHD1onbZlzTNPnggw949NFHueGGG0hNTeXVV18N7b/00kvJz8/nvvvuwzRNpkyZwoUXXhjDEovOSGuNL9B0a5wvYOKSXpEuRWtNIBAgYDa8PgzDwOFwYBzQAqwcLug7FF28DWrLm5f0QOaJiI4sqRvsBWWZwWve7kLbnYAKzpsK+IKLGh44aV0p6ns1zJJt2HoMPIzMi8FeRrVvgnu0+Px+vP4D36sa07Lw+v0kul3YjLht7xVtRIZmtU7c3jm5XC4+++yziMfcfffdUSqN6KqsZrZqyeT1rkVrjc/vb/TvblkWXq8Xt8vVIOW0crhRvQahA/5gOl9v+ExaQHD+iBAdlLI70SnZULUXhYZAHSpQF9pvORNBmygOSPAb+rwNXvu6tgIjJRPlStzfQxL2BQ3sad2jmuY9YJoHBSENeeq8JCW4JfW8EBFIqC5EBM39ApEvmq5FNyNzWiDMApnK7sBIzW7yNVRSeovKJkS8UN37Q1LGIduDCxoeEKQf8AgeEEzJa3lrALClZkcMzFVCCvbMPih7mMQQ7cQXIQiBfUlOzObMbxEdmaktTKuVD911GzPjtkdEiHhgKIXNMDCbuOmUzFldS3NuLgKm2SDFeAOuJHAlh+8VMWyolKxWlFCI2FPKCPYC1tWgq4vB9IPdFUzgUFXc6NTyUA+Jtur/h7LZsWf2xaouw/JU7d/uSsKWnB6TeSFa6ya/FwACpoWM2u3crDYYmtWVFzSUt4cQTXA77dTUhc9Nb7cZMg64i2nuRFStdaO9ZUopjKwjsMp2BsfPH8jhxsjMRdmaOzZeiPim3Ekod1LoZ3P3j5GPBzQa5Uzcv81mx5aWjZGaFcyiZRgoJZ+7QnR0EogI0QS7zUaiy0mt99BgxG4zSHRFdziAiL22GLKnDANbZg46rSe6LtjKq5wJDW6+hOiULKtZiXaNpG6HbFNNpb6OEqUUhlJNziOURqrOz7Q0hkxWb7HYv5uF6AAcdhupNjf+gBn64nHYbfIl00XZbDbMJoZn2W3NG66n7A5U8qHj6IXotJwJwTVGwtDsS+4Q572CToedOp8/4jEybLfzC1igWhlIBLruFBEJRIRoLqWULFwogODcIcMwIk5Yt9vlWhGiMUZyJtbBQxIPoACjAyzmabfZsNussHPGElxOSWQiRBPkm1IIIQ5TMCh14Pf7D5mwaiiFw+GQGxAhwlCuRFRKNrpqb+MHJKWDOyW6hWoBpRRup4OAacMfCGDuG3Jmt9tw2O3SY95FyNCs1pFARAghWkAphdPpDKXy1ezvKRFCRGZ064nldKMri4MrrEMwo1ZKFiopvcME8kopHHabDMHqwiQQaR0JRIQQohWUUtiaOR9ECLGfkdgNEruhrWCqXiWLeArR5UggIoQQQoiYUdKLKDow6RFpHQlEhBBCCCEA07KoqgtQFzBRQILDRrLbgdFBhoqJ6JMFDVtHAhEhhBBCdHm1vgC7Kz0ceEtY4wtQWuulZ2oibocMHROirUkgIoQQQoguzRcwKar0NLrP0lBUWUtOejI2Q3pGREOmpVu9jogMzRJCCCGE6AC01nj9Aaq9/uBNoAKX3Uayy4nN1rL5JhV1kRcmtDRU1fnpluhs0flF56W1RrcykNBaAhEhhBBCiLjmD5iU1tTR4L5PQ63PxOP3kJrgJNF5+Cuy13oDTR/jC0ggIkQbk0BECCGEEHHPb1oUV9eF3a81VHp8OAzjsNf10DTdIt2cY0TXY1m61ZPNu/JkdcmZJ4QQQoi4V1HrbfIYraHa6zvsc7uaEbg05xjR9Wit2+TRVUkgIoQQQoi4FjAt/KbVjCM1NV6TQLOO3S8toekhV6nuwx/yJYSITAIRIYQQQsS1wwksvKZm095qqpqYgH6gBIctYqCRmeTCKT0iohHa0m3y6KpkjogQQggh4oo3YFJRF8yK5bLbcNuamzZXEbAstIZtZR4GZBkkNGP9D6UUmUku3A4bFR4f3kAw8Elw2EhLcJLolNsl0TiZI9I68s4SQgghRFywtGZnhYdyT8PeDAUkOwxc9kgDOTSmhsABnSfF1V5y0hOb9dpKKZJdDpJdjtCYfSUrqgvRriQQEUI0UBcwyS/z4AtYpLrs5HRLkEW8hBBRsauRIARAA1V+CxS4Gl0rJJjTqtrbcAhXZV0ArfVhBxQSgIjm0lbw0dpztLXKykpuvPFG5s2bR0ZGBo888gjTp08P7Z8zZw61tbXU1NSQmZnJzJkz274QzSCBiBACCGb+WLGjnDWFlfhMi90VdZTX+qio8JJmszEwO4kxA7MYPTAzLr+kd1XUsXJnOZV1AZKdNkb27UZOt4RYF0sI0Uy+gEVZI0HIgeoCGqcRDCyCAUYwU5apocprSYJdEXVtkfWqPbJmPfzww1xyySXceeedzJ49myuuuILRo0fTv39/3njjDd5++22WLl0KwPjx4xk6dChTpkxp83I0RQIRIQQAX28vZ3VhJSXVXtZsL6em1s+OgnL8/mBTzX8V/PWTzRzVM4U/XzuaPhnNG+7Q3iyt+ceX+XydX0aCy47bZUcpWF5QxvBeqVw4og926dERIu5VhplcbmnNtjIPW0trqfIGcNoMBmcnMSQ7Cbth4DM14YbYO2wqLhtOhGhPfr+foUOHMnXqVABeeOEF3nzzTb755hv69+/PY489xrRp00LHT506laeeekoCESHay4bdVcxbV0RBaS2JThsTj8zi1EHZuJsxibEr8PhN1hRWUl0XYOW2Mvx+i215ZZjm/m/3+gabrXuqufrPX/DuHZNIcsX2I2T9jnLufGUl6/LLQtt6ZCcxfEg26d0SWFtYSbLLxrRjesWwlEKI5jAbaRW2LM2X28rYXb1/bZC6gMXaoirW7a5m/BEZZCWFT72bGWGfEG0hHierOxwOrrzyytDPbrebtLQ0cnNz8fl8rFy5kt/85jeh/YMGDeLBBx9s0zI0lwQiolPTWvP8F/m8tWYXNqUwtUYBq3ZU8NrKHTx67jB6prpjXcyY21paiwbyS6pBQ3mpp0EQciDT0hSWefjw2x1MP7FfVMt5oO8Kyrj4scX4Ag0H1+4pruHTZbVMGpdLVkYiXxWUc9pR3Ul0StApRDyq8Pj5dmc528pq8ZkWPVPc9E1z47AZbC6paRCE1LN08PP9y+1lnDmoe6Pz2BKdNtITJRAR7ast0u/WP7+ysrLBdpfLhcvlatW5AXbs2EGfPn0YM2YMhYWFBAIBUlNTQ/vT0tLweDyUlZWRnp7e6tc7HLKOiOjUFmzYw1trdgH7W9vqPy6Kq73MmvcDVivHZpqWZmtJDf/9cS//2bCbz/NK2F1V16FWSq0LmBgKdld60UBFeV2Tz5m3cmf7FyyCe/75Lf6AxcHVrHWwdWnFmkK01phas6WkJjaFFEJEtHpXBU9+vpVleaVsK6+jqMrH6l2VLNhUTLnHx5aS2rDP1YA3YFFnmg1S9NoNRfdkF0dkJGLIsCzRgeTk5JCWlhZ6PPLII21y3meffZbnnnsOCPaWHPgvgGVZDf6NJukREW1uR2ktr36Rz8ff7cLjMxnQPZnpY4/grBF9opp9SWvNv1fuCLvf2pdnfuX2ck7IbVkLgMdv8unmvVR6A6Ft5R4/28o99EtPYOwRGR3iizDFacfS+7uHrSYWD9NAZW3zFwtraz9sL+eHHRURj6mq9lFaXkdmekIzV2QWQkTT9nIP768ranSfz7RYlleGr4mWZkNBaa2f0bkZmFZw0rDNkHkhIoraYkHCfc/fvn17g56KcL0hhYWFjBw5Muzppk+fzty5cwFYtGgRw4cP54QTTgAgMzMTp9PZoPeloqICt9tNZmZm636PFpBARLSpVQWl3Pj3FfhNC3PfG+uHnRXMevM7Fq4r4k+XjsLeaOrFtlda62NnReSWfZuhWLWj5YHI53klVB0QhMD+Hpf8Mg9p7iqO6Zl66BPjTP+MRD7LLyXJZafaG8DpsuOJEGjYDMWAHslRLGFD+Xuqm3VcdY2PzPQEesvwOyHizhf5pRiKsBPNmwpC6tU39gQbuiQAEdFlaY1q5QiI+pEZqampDQKRcHr16kVRUeNB/IE2bNjA1q1b+fnPfw5AIBDAZrMxceJEtmzZEjpu06ZNTJo0qWWFbyUZmiXajNdvcts/v8UXMENBCOz/klm6fg+vLMuPWnma2whutrAlo7TWx94aX8R0kRv2VLd66Fc0OGwG4/tlkLsvE1Z6RuS0t6aluSiG80NSEhxNHwQ4HQY53RJkHpAQcWhLSU3YIKSes4kV1S0NR2YltWGphOgcioqKeOaZZxg/fjwbNmzgu+++Cw31uuaaa5g3b17o2Pnz5zNjxoyYlFN6RESbWfh9EeURWtE18OoXeVw5oT9GFIZoZSY5yUh0UBqhTKalObqRHouAaVHp8ZPgtJHgbPxtUlTlRUHEQMRrWlR4/B1iwuSQ7GSuPCGHOUt+RGtNcoWT6qpDJ4kCnD86hzEDo9+FW2/0UVl0S3JSXtN4+QAcdoMjeqVy4XG9o1gyIURzNacRKD3Bye5qb6P7lIKsRCcD4iSVeEdhWZqvthTz9ZYSTK0ZkZvOxCHdozZaobPRug0mq7dxg2VdXR1nn302K1eu5KmnngptnzVrFkopLr30UvLz87nvvvswTZMpU6Zw4YUXtmkZmksCEdFm1m4vx24oAhHekHsqvZRUe8mOQgu1zVCcN7w3L35Z0GiwYChIS3Awvn9GaFtFrY/nPtnM68vzqfIEUAomDe3BjZMHM/yIhsO3mvvB0ZFmJxyVncyc84/l9VW7+MRlJ29HJWUltaEMWt3T3Fw9aQBXnDQgpmOwXQ4bN089mv/995qwx5w5JpfbJg2kWzN7T4QQ0dUr1U1hZV3YxhwFDOmezODuySzdWhIaxlXfANTN7eCSkX1lPshh2Flay00vf8PWPdWh9ZVe/iyP7qku5l5xAkf3SYtxCTuetsya1VbcbjfffvttxGPuvvvuNn3NlpJARLSZ5vZyRHPC+gUj+vBDUSVf5peFVuCFYBDistv4/ZlHh1qBymt8XDLnM7YV14Ra6rQODin7bP0e/nztGE4+pkfo3FlJriZX8bUbijR3x3qbOWw2Ljshh0uO70tlXQC0przah1KKvpmJUf37RXLlpCPxeE2e+GAdphWcoGpaGptS/OqsIdx09tEd8galzm9S6zNJddulhVJ0amNy03nn+8Kw+5WCUX26keK2M7RHCt/uKGdvtRen3WBo9xSG9kiR98hhqPUG+PnzX7K3KtjDdGCjYXGVl+v/9hVv3jKRHmlu6nwB5q/Yyo69lWQkuzlzzEDSU2SIq2h7HesOqYMrrajmpfc+580FK6iurWP4oBx+ceEpTBg1qEPeMB3sxKOyePWL/LD7FXBkj2TSo7jAlM1Q3DflaBZv3ssH3xexrayWBIeNSUdlce6xvemesj8jxdx56xsEIfVMK7j2yG//+S2fPTgZ1740kd2TnaS57VTWBcIGJAOzgiv/dkSGUqHehG5xOLRMKcUNUwYzfUI/5n2zg90VdXRPc3PW8X3JTGl93vVo27i7ipe/LOCLrSVoIMFh4+xhPbl8zBHSqyM6pWE9U8gvrWHVrsoGw1yNfY1G5w3rRcq+hpzuyS7OHNIDy9J89v1Olq8qYLXTzk+OP4JeGTJHpDk+Wr2LojAJXCwNNd4Ar39VQG+35q7nF1FZ6ws18Nz5/CJu/un/8JuLxnSK+5W2ZFmgWr2gYRsVpgOSQCRK1m3ZyRnXzaakfP/k5R+37eb1j7/m15eczp9+e0mHf3OfeFQ2/bKS2F5a2+jYXw1cM/HIqP+eNkNx2uDunDa4e9hjar0B3vl6W9gxyxqo9PhZsGYX007IAYI3wif1z+STzXvxBaxDgpHuSU6G95Ju7vaWnuzi8klHxroYrfJNQSm/e/d7LK1D15HHb/L26p0s21LCny8eSYasEC06GaUUU4f2pH9mEl9vK6Ow0ovNCA4RHZubTp+0hkkzVmwq4tdP/ZcdxdUYSqG15p4Xl3HRyUfxh2sm4A4zn08Efby2MOK8RkvDa4vWs3VTQWhb/XeiP2Dxp9e/wlCK2y8a0/6F7UC01q2e49GR1h1ra/KujQK/P8C0Xz1BaUVNgwxKgX1pnZ5+bSHHDc7hqnNPilUR24RhKJ6++n+47oWvKCz3hIZC1beoXDvpSM4aEZ8ThwvLPNT5IzdJ2G2KzYVVDbaluh2cPaQHm4tryCutwWdaJDvtDMxKpn9G/AxjEvHLb1o8+J8NwTUQDtpnadhTVcdzn2/ld5OHxKR8Xc2mgiKWfrMBy9KMG3EUxx7VN9ZF6tSUUgzrmcqwJtKcb9heysUPzcMX2LfwWv0CtVrz+pLNVHsC/PXW09u9vB1ZdZ0/4nBirTXbCwobDGM+2JNvr+Das0eQltTxep1FfJJAJAo+WLKaHbtLw+5XSvHYS/O58pwJHb5XpG9GIm/fOpGPv9vFgrWF1HgDHNUzhQtG5zKkd/z2DridtiaP0RoSGjnO7bBxbK9Uju0V/+uFiPjz8boiKjwRMrtpWLhhD786eWBomIpoe8VlVcyY9QLzl60F9k+InjBqEC8/fD19e2REfL5oX3PfWYnftBpNh25pzYdfbeX7/GKG9cuKQek6hiO7p7CpqCpsz7/l8+H3hs9ECME0/R+v2MpFk45ujyJ2SNoKPlp7jq5KvtWiYMk3G7DbbARMs9H9Wms25hdSUl5NVnpKlEvX9hKcNs47IYfz9g1hqvf12i288NYSfti6i24piVw0eTQXnjGaBHfsh5z0Tk9gUK9UNhdVhm0JMi3N6cN7RbdgolP7Jq+UP/5nPYbDFrERImBpiio9pLg7/udDPPL6/Ez+xaP8sHVXaFv9x8CXa37klBn/j2/+7wHSUiRNbCx4/SbzvsqLmO7XblO8u+xHCUQi+NmYHD5cvTPs/nD3KAcylKKsytOWxerwLEu3wRyRrjs0q2POou1gtNbNWuy1s44R1Fozc/arTLjyD7zy4Rd8vXYrC79cx7X3/51RF90XsbcoWpRS/GrK4LBBiKEUpxzTg6Ok10O0kdJqL7f9ayUBs3nve5e96V470TKvf/w1azfvwGxkFdSAabG9sIQX3/0sBiXrXEzTYkNeIT9s2YnPH2j282o8/matOVJa1fhEbBE08ogMLh53BHDoLYkCxg/p2eQ5LK3J7R6/oxtEx9NpAhGtNbt27Wr6wBg4ccRRBALhWxqUUgzom90pekMa89wbi3n6tYXA/nkx9dF/wa5ifnrrk3ERhE0e0Zt7f3YsNkNhqGDq3fo86+MGZ/HolcfHuIQd0849ZTzx8nzumvsGf35tIcVlVU0/qRPwmxYfrt7Jz//+NWc+voRL//IFr35ZQLU3eAP27sqd1AVMAn4rYm+IAvp2SyAnPfJq96LlXvngi4jpxy2t+cd7n0exRJ2LZVk8/vJ8+k+5neE/vYcRF8wi9ye38ftn321WQJKa5CSpiWGJWkNOd2koasqdU4dyz7nH0Cdj/+dJVoqLmyYP5tnrTuTEY/qGnduogPQUN6eN6hedwnYQ9euItPbRVcX10Kxbb72VuXPnNth24YUX8vrrrwPwyiuvcMUVV4T2LVmyhN69428y9PmnHU+PzFSKyxofm6m15tYrJnf4+SGNsSyLx/7xn7CT3wKmxeoN2/h85SZOOn5w9At4kMsnDmDKiN68u2I7+XuqSXY7OGtUH47N7dYp/z7tybIs7nnqLZ54eT4ANsPANC3uePzf/P5XP+U3V58Z4xK2H48vwM3/WsnqbeWha7+kysucjzfy+tfbeO7q/+HLH4uD7wmt8ftM7A6j0WtMA1ePO0Kuv3a0u7SiyaERe8sqo1SazkVrzfUPvMg/P1jWYKJ0aUUNjzz/Ad+sy+OdOTdjj9DjZ7cZTD95MP/45Ifw8xu05qKTB7Vx6aMjYFqs2FZGXmktdkMxKqcbA7OS2+W1lFJcOOYILhidS1FFHZal6dktIRR8PDRjIlPvfgOvP9Cgrg0V/Cx67IbTcDqkd/ZA8bigYUcSt4GI3+/HNE02bNiAyxXMzvDnP/+ZYcOGhY5ZvHgxK1asAIKrSB64L564nA7enXsLk294jJrautCb22YL3phdec54rr9gUmwL2U7ydxVTsKs44jF2m8HCL9fFRSACkJXq5trTjop1MTq8h557nz+99J/Qz5YV7BW0AiZ3z32DtOQEruuk1/2Tn2zmu+3lwP4AvP5rpqiijnvf+q7Bl7y31o9KdGB32hr0DirgV5MGcvqQ/QtpirY3oE82G/OKMMMk8zeU4ojeMvegJRav2MDLHyxrdJ+lNR8vW8vrC77m0rPGRTzPzeeN5D8r8tlT3jA9vNYapRQnHJFMqrvj3SCv313F44s2U1kXwGYEUxK/tWYXR/dIYeYpA0l1t88aQkopenU7tJd1aL9sPnz4Qu5/6TM+W7s9tH1Ibhb3XD5eekNEm4vbQMTn8/Hwww+TkrJ/uNJXX33FHXfcAcDy5cspKCigrKyMU045Bbs9bn8VAI4/pj/fvfUQz725mDcWfE1NrZdj9y1oePbE4zpta6fZjPHvSqnQkK2OZvGK9Tz96kK+/G4LDoeNqRNH8KtLTmdI/649qb2y2tMgCGnM7599h6vPnYDDEd/v3cNVXefn/VU7CdfAZVqaVdvKmXZcb9buKA8dV1frx/AGsDtsqH0pm0b2SePCUZI+tr1dfd5EPly6Jux+S2uu/enJUSxR5/HCW0uw24ywn/GGoXjujcVNBiLZ3RL54MHzuOmpT/hi/e7Qd6YV8FFbspP5m/Zy0uYfWPzi3XTrIEkFdpR7+MOCDaEVzg8MsDbuqeLhTzby8NnHRBw22B6G9svmjQd+yo69lewsriIjJYGBfdI77X1Ka1lao1o5vLyxbHBdRdzeASQlNVwpdc+ePQBkZ2cDsHr1avbs2cPkyZPJzc3l7bffZtSoUY2ey+v14vV6Qz9XVsami71393Qe+OX5PPDL82Py+rHQr3cmmWnJlFRUhz3GHzAZc2zHW5DugWfe4eHnP2jwJfu3t5fw93eW8n+P/pJpk0bGuISx8/EXa/F4w6ekBdhTWsWX322Jm56wtrKxqApfE4G1AnqlJwS/2A/4ArJMjc/cP2b+ivH926uY4gBnTzyOyeOP5ZMvvj/khsBmGJxwTD8uPTvyjbJo3Ia8XREbmixLs7mgqFnn6p6WwKovP6e8pBpld6Eti4C3JrR/Y34R98x9kz/fe2Wryx0NH3xfGFw/qJF7UEtDXkktq3dWMCqnW9TLBtA3O5W+2TLvpikyNKt1Osxk9ffff5+zzz479PONN97ImjVrWL9+PT179mTq1Kl4PI2nlHvkkUdIS0sLPXJycho9TrQ9h8PODdNPxQjTkmIzDPr2SOesk4ZHuWSt89Fna3j4+Q8AGnzJBkyLgGly6Z3PUlRcEavixVxldfPSO1bWdL40kF9tKASCQ0aq9u5h26pv2Pz5YrZ+uYyS/DxMf3BRsW6JDn5//jAMRYPJofX/v37SkYw5MjMWv0KXY7MZvPn4r7n5sp+QeEA6cZfDzjXnn8R//vIbXM72GSLT2aWnJjXZkp6W3LxEDAu++J7tRaUE/D78nqoGQQgEs3K9/MGyZn/+xJLWmi/ySsP2nEJwXsby/JLoFUqIGIjbHpGDvffee/zxj388ZPvgwYN5//33GTJkCIsXL+bMMw+dAHvXXXcxc+bM0M+VlZUSjETR735+Nl+v3cony7/HMFRoUqjNMEhOdPHWE5EnKsajJ//1SXDydSNjyrUO9vL8/Z2l3H3dtBiULvaOym06DSTAwNzONfchYFo8//5qVFYGhT+spbKoMLTPjwdPZQV7ftyIYbNx1fwPMRRMGDWYEePH8PEX69i5aSPe6gq6JSdQkFnF9qMzyOkpC+lFg8vpYPbtFzPrhnNZub4Ay9KMGJJLempS008WYV185hg++3Zj2P2Gobj07BObda7VGwsiDvOC4JowP27bzaih/Q63qK1mWZrlBaV8umkvuyrqcNgMjs9J44zB3emd1jDY0pome04tDR5/xxy23JVo3QY9IjI0K/oKCwsZOTL80JXp06eHMmbV1NSQl5fH0KFDGz22e/fujBs3joqKxlugXS5XaMK7iL7gZP2befWj5fzl9UVsLthNSpKbi88ayy+nn9Yhb7SWr94cdmIrBL+Qlq3aFMUSxZeTjh/EgL7Z5O8qbjQbkc0wGDN8AIP7da65NMvW7WJPWQ2U7G0QhMC+LxrLwrIsrEBw+JVpaZZ8s4ElK37A9HlCwa2n1sPj/5jPX/79X/7zl9sZ3QGHLnZUKUkJnHzCkFgXo9O45KxxzH7xI3YUlR4SQNhsBukpiVx3QfPm37icjmbdsDmd0b+1MS3NX5blsXJnBfumeOG3TJbllfJFfhm3TBzAMT33D3MyDEV2kpO9NeFXMjcU9Ep1t3/hRatoS7d6QcKuPDQrZoFIr169KCpq3rjQjz/+mNNPPz3iMaZpMnhw5xpr3pk4HHauOvckrjr3pFgXpU0YRtOjGptzTGellOJv//tzpvziMQJYDYI2m80g0eXk6Xs6xjjuw7GrpBqtNZWFOxpsrw9CDlY/ZEVjYNidmIH9NyWmZVFT5+X8W55k6/zHZGiQ6JCSElwsfP5OLpj5FKs3bMNuC34uBkyLfr2zeOuJm+iR2bwF8s6cMJzfPfF6xGP69shg6IDop/H/7+a9rNwZbAw98JbS0qC05pnP8/jTucNwH5D69oyje/DqN9sJdwtqaTh1UHb7FVqIONAh7pTee+89pk3bP8QlEAgwe/Zs8vLyAFi/fj0ulytiD4sQbemU0UeHvlAbo5Ti1NFHR7FE8Wf8yEEseeluThs7lPoh4oahOGfSSJa9MothAztfNqjMFDdWwI+2wi9g2hilFMp2aKBhWZq9ZVW8/em3bVVEIaIut1cmX716P4v+/jvuum4ad/58Kh89ezvr3n2YoUf2afZ5jh7Qm7NOGo4tQiPPnTPOjnojkNaahZv2ht8P1AUsviwoa7B98pDuDMhKIlxSrAtH9JEekQ5Aa90mj64q7ueImKbJ559/zgsvvNBg2wcffMCjjz7KDTfcQGpqKq+++moMSym6mlsvn8yHS1Y3us8wFEluF1edOyG6hYpDo4b248M/z2RvaSXF5dX0yEwlI619FuqKBycfl0NKooND1o63rNB6B+EopUAZoBv2nDjsNr5YtZlLzhwb8bUty2Lhlz/w5oKvqaj2MDC3BzPOn8iROd1b+NuIptR5/byx4GuWfrsRrTUTRg7iosmjSUyQocAHU0oxfuQgxo9s3aKD//jD9Zx/y1w+X7UZuy04lNFmBOeN/Paas7j+wkltU+DD4PGbFEcYYgXBYVb5pbUNtrnsNu6bPIQ31+xk4ca9ePzBBozeqW7OP643E4+UtWs6Asma1TpxH4jYbDa2bNnSYJvL5eKzzz6LUYmEgIknDGbOnZdx2x//hVKqQcpPh93GG4//ulPfcB+u7IxUsjM6fxpIl8PGvZdP4FcPbQ71iph+L9o0MezOJp4dXlPrCJRV1nDOr5/gq7Vb992caQxD8dhLH3H/jed32aQJ7WnV+gKm/foJ9pRWhnpHX35/Gb+b8zrvPXkrY4bLvJ72kJaSyMIX7mTR1+v59/yvKK/yMKBvNlefd1LM1m8KlxXyQIqG2fHquR02Lj8hl4tG9KW4xovdMMhOdsqaHaLLiPtARIh4de6po5j94jx27SkPbVOA1xfg/j+/zehjB5CcKN3qXc1VZxzDJ18czzsLv8YyA1i+OlBGkzcWWluH9IZAMAPbKU0M87v0jmf55od8YH866frFRB945h1ye2Vy+dTmZSYSTdtTWsnkXzxKVU0d0DCFd3lVLWfd+CfWvP0QfXt0vEQcHYFhGJw29hhOG3tMrIsCBIOJAZmJ5JXWNromCICpYVjPlMZ3Ak67cUhmLdExWJYmYh7m5p6ji+oQc0SEiEdX3v1X9pQ0XByz/qPkm3X5/PZP/45+oURc+Mes6Zw7aTiWb99CqtrCMgNhxwFrrbECjS8A2bdHBlMnjgj7Wqs2FPDpVz9ghkkFqhQ88sIHcT8Gubyqlk+Wf8+CL76nNMICqPHgb28vobLa02jmPMvS1Nb5eO7NxdEvmIiZM4/uETYIMRRkJzsZ3rt5k/JFx6Its00eXZUEIkK0wPc/7uCzbzeFzWdvWhb//OBzyiprGt0vOjebzeDlB64Avf/LxfJ7Qz0e9UFB6F8zgDYbD0TuuX5axHV2Plq6BluExAlaw+aC3eTtDD+ZNpZqPV5+/fDL5Jx2K2f/8nGm/upxcn9yGzc++A+qa+tiXbxGvbPw20NWYD+QaVm8vfCbKJZIxNqovt248Lhgtq76EVj1faDdEhzMPHlgo0OzhOjqZGiWEC2wfPWPTR7j85usWl/AqWMaX/9GdHbqoF4IjenzoAw7ymYHpdDawgz4Gx2SVS+nZ+TV1b3+AIZSNNWe9t5/V1JcXo3b5WDqxBGMPPqI5v8q7cTvD3DOTXP4fNWmBkMTfH6Tl95dyg9bdvDJ83fidDT/q8rnD7Dkmw2hCfsjBue2eblr6yJPTAbwNOMY0blMOboHx/VJY8mWYnaUe3DZDUb26cbo3HScdmn37azaokejK/eISCAiRAs0dx6hTDjsuux2G8ce1Zd1P+5s0HqurQDaCjTrHE6HjaNyu/Ppl+sAOP6Y/nRLSWxwzHGDcvEHmv4Su/OJ13HYbWitefAv73HyCUP492O/jGlShbc//ZalYVbdNi3N8jVbeP3jr5s1v0VrzTP/9ykP/vU9Siv290QeNziXv8y6iuOP6d9m5R4xJJetO/aE7RG12wyOa4cASMS/XqluLh7Z+VKTi/C0ZbVBIBK+MaqzkxBdiBY4+YSm1whJcDk54Zh+7V8YEbduvuwnYYfwKBXMthMuI5ahYEDf7gz/6b2ceeOfOPPGP5Fz2q3c9PA/qfV4Q8dNmzSC7PSUiJm16vf4A2bo5vnzVZs456Y5WDH8AnzxnaURy20Yir+/vaRZ53r0xY+4bfarDYIQgO83b+fUa//Imo3bWlXWA91w0alhgxAITl6/4aJT2+z1hBCis5JARIgWOOqIHkwZf2zYsfmGUlx3wcmkJEkWlK7simnjQ635B95w220GNsPg+d/PYNARPVHQYNFHgKREN5sKivD69/eeeP0Bnn9rMefcNAf/vu1Oh53XZv8Sh90edpHNxkIh07T4eu1WPv3qh9b/oi1UUFgSMVuMZWkKCkuaPE9JeTW/f/bdRveZlsbnCzDr6bdaWsxDTBg1iNuvPhNo+HetT+P6y4tP4yfj4iOjkxCifWnTbJNHVyWBiBAt9PcHr+WYI/dNTtx3M1K/4u/p447hDzdfELOyifhgGAYv/H4GLz98PaOHDSDB5aBbSiKXnjWO5f+6jyumjWf5v+7jqbuv4IRj+pPbK5MTRxzFdRdMoqqmrtGbdMvSLP12Y4PV1ieeMJgvX72Pi88ci8sZHHHbKzst4grUEAyI3lywom1/6cPQPSM14hoMSkGPzKYzDb2x4OuIPRSmZfHxsrXsKa0Me8zhevjmC3j54esZPigntG3okX342//+nCfuuJT1BXv5aPkmvvh+W8SyCSE6Nq3bIGuW7rqBiMwREaKFstJTWPbPWbyxYAX/fH8Zu0sr6Nc7mxnnT+TsicdFzGQkug7DMLj4zLFcHGZl9KQEF9dfeArXX3hKaNvp1/4Rw1BhewtshuJvby9h+pQxoW3HHNmHvz94LX/735/jD5horUkZ84uIZbMsTWWNpwW/Vdu46pwJLF8TIfGDDh7TlF17y7HbjIhzZbSGouIKurfRwppKqdDftdbjRRP8W67ctIvTbnuJ77bsDh3bIz2Je688mUtOH94mry2EEJ2FBCJCtILL6eDyqSfKYnGiTRUUFkccsmRamoJdjQ9ZUkqFskz1yu5G4d7ysOdRSnHUET1bVdbWuOSssTz56idszC88ZB0Um81gYG4PLp/W9HurZ2Za2HVUDtRWQcjBEhNcAKz+sYhpv/sX/oPKsrushpvmfoTHG2DG2aPapQxCiNiQrFmtI022QggRZ7pnpEXMuKaUontm0zfVN1x0SsTJ4Ja2uOa8k1pUxraQ4Hay8Pk7+EkjK2SfOvpoFj5/B0n7bvIjueCM/4n4e9oMg9PHHkPPrPZdUO7+v/+XgGmFDSLvf3ER1R5J6ytEZyILGraO9IgIIUScueqc8Xzz/dbwB2jNVeeMb/I8N192Bu98+i1rN+1osAq4UsGhSv/7q5/Rv092WxS5xbLSU3j/6dv4cdtuPtuXynf8qEEMOoyemu4Zqdx13TQe/Mt7h+wzDIXdZvDQTT9rszI3ZseeCpatjZyZy+P1M2/5Rqafemy7lkUIIToKCUSEECLOXDb1RJ56bSE/btvd6JClQbk9uPSscU2eJynBxacv3MmDf3mPF95eGlqpfHC/Xvzu2qnNOke0DMztwcDcHi1+/r3Xn0Oi28nDz39AVc3+FdmPyu3J8w9cw6ih/dqglOEVlVY3eYzdZrCruKpdyyGEiC4ZmtU6EogIIUScqQ8grrn3eT5Zvq7BvlNHH82LD10XmpfQlJSkBGbffjG//9VP2VZUgtvpILdXZqdbbFMpxe1Xnckvp5/Gp1/9EFxZPac7o48dEJXfNbtbUpPHBEyrWccJIToOWdCwdSQQEUKIONQ9I5V5z9zOxvxClq3cDMD4UUcxuF+vFp0vwe1s8XM7kgS3k6knj4j66x7RsxsnDO7Nyk2FYRexdDpsTDtxcJRLJoQQ8UsCESGEiGOD+/XqEgFEZ3D/Nadw3t2vYqAaDUbuuGQCacnuGJRMCNFeLMuEVvaIWDI0SwgRD7TWfL5yE5sLdpOaksAZ44aRmiyrswvREYw7JofXfz+dW5/6D9v3VIS2Jyc4+e0l4/nleaNjWDohWqbW4+XjL76nrKKGfn2yOPmEIbJO1gFkjkjrSCAiRJxYtmoTP7/vb2zdsTe0LcHl5DfXnMk9103DaGKVbCFE7J08oh/fPn8DX6zbRkFROenJCUwa2Z9EtyPWRRPisGitefJfn/C/z75LVe3+BBB9e2Tw7KyrmDxesr+J1pNARIg4sPKHfKb84jH8ZsNWEY/Xx4N/eQ9PnY+Hb7kwRqUTQhwOw1BMOPYIJhx7RKyLIkSLPf7yfO6a88Yh23fuKeO8m+fyn7/czqT/OToGJYsv0iPSOtLEKkQcmPX02xEXQnvi5Y/ZtacsyqUSQgjRFVVU1fL7Z95tdJ/WGo3mrrmHBildkmmiW/nAlEBECBEje0orWfjl9w0WnDuYRvP6x19HsVRCCCG6qvcWraTO5w+737I0367LZ1NBURRLJTojCUSEiLHisirCZPsMsRkGe0oro1MgIYQQXdqe0qpmTUjfK99LaG2Ghme1+KG7bo+IzBERIsZ6ZqVhGCrssCwA07To2yMjiqUSQgjRVfXpkY5pNr3IXu/u6VEoTXzTltXq9L1deUFD6RERIsYy0pI5Z9LIiK1PNpvB9CljolgqIYQQXdW5k0aSnOgKu99mGJw0ahD9+2RHsVSiM5JARIg48Ptf/ZRElxNbmBS9D/zyfDK7JUe5VEIIIbqixAQXj91+SaP7DENhtxvMnjk9yqWKT60eltUGWbc6MglEhIgDRw/ozeKX7mbM8AENtnfPSOHpu6/gt9ecFaOSCSGE6Ipm/HQiL/3hOvocNPzquMG5fPrCnRx/TP8YlSy+aMtqk0dXJXNEhIgTxx7Vl8Uv3s2GvEJ+3Lab1KQExh13JA6HvE2FEEJE36VnjWP65DF8tXYLJeXV9OuTzbFH9Y11sUQnInc4QsSZIf17MaR/r1gXQwghhMBmMzhxxFGxLkbc0pbZBpPVu+7QLAlEhBBCCCGEaAEJRFpH5ogIIYQQQgghok56RIQQQgghhGgByzJR0iPSYhKICCGEEEII0QLatEC1MhBpxuKRnZUMzRJCCCGEEEJEnfSICCGEEEII0QJat8FkdS1Ds4QQQgghhBCHQVtm64dmyRwRIYQQQgghRGegtebOO+/kjTfeoK6ujj/84Q/MmDEjtH/OnDnU1tZSU1NDZmYmM2fOjEk5JRARQgghhBCiBeK1R+Rf//oX5557LrNnz+add97hoosuYvr06SQlJfHGG2/w9ttvs3TpUgDGjx/P0KFDmTJlSpuXoykyWV0IIYQQQogW0JbZJo+2NnHiRMaPHw/AlClTsNlsaK0BeOyxxzjjjDNCx06dOpWnnnqqzcvQHF2yR6T+D1FZWRnjkgghhBBCiMbU36fV37fFJdNPq0tn+oFD70tdLhcul6tFp8zNzQ39/8MPP+TJJ58kOTkZn8/HypUr+c1vfhPaP2jQIB588MEWvU5rdclApKqqCoCcnJwYl0QIIYQQQkRSVVVFWlparIvRgNPppGfPnhT98HqbnC85OfmQ+9L777+fBx54oMXnLC4u5tFHH2Xu3LlcdtllzJgxg5KSEgKBAKmpqaHj0tLS8Hg8lJWVkZ6e3uLXa4kuGYj07t2b7du3k5KSglKq3V+vsrKSnJwctm/f3uAPL5omddcyUm8tI/XWMlJvLSd11zJSby3T0epNa01VVRW9e/eOdVEO4Xa7ycvLw+fztcn5tNaH3JO2tDekXlZWFrNmzWLs2LHMmDGDE088kXPPPRcAh8MROs6yrAb/RlOXDEQMw6Bv375Rf93U1NQO8caPR1J3LSP11jJSby0j9dZyUnctI/XWMh2p3uKtJ+RAbrcbt9sd9dctLCxk5MiRYfdPnz6duXPnAsGelvPPP5/Vq1ezcuVKZsyYgdPpbDAMrKKiArfbTWZmZruX/WBdMhARQgghhBCiI+rVqxdFRUWH9Zzs7GxcLhdKKSZOnMiWLVtC+zZt2sSkSZPauJTNI1mzhBBCCCGE6EQWLlzI9u3bgeCwryVLloTWEbnmmmuYN29e6Nj58+c3WGMkmqRHJApcLhf3339/q8f6dUVSdy0j9dYyUm8tI/XWclJ3LSP11jJSb13Hyy+/zIcffsi1115Lnz59ePDBB+nZsycAl156Kfn5+dx3332YpsmUKVO48MILY1JOpeM6J5oQQgghhBCiM5KhWUIIIYQQQoiok0BECCGEEEIIEXUSiIi4tWvXrlgXIe55PB4qKipiXYwOp6l6k2tPRJtccyKa5HoT8UICkXaWl5fHDTfcwHPPPceVV15JQUFBrIsUt7TWDBo0CKUUSikuv/xyQOqwMZZl8dJLLzFo0CBWrVoV2h6prqQew9dbuGsPpN4A3n//fQYPHkxqaio/+9nPKC0tBeR6a45wdSfXXGSrVq1iwoQJZGRkcPrpp1NcXAzINdeUcPUm15uIW1q0G9M09bBhw/Snn36qtdZ6wYIFeuzYsTEuVfyaN2+efuqpp/SKFSv0ihUrdHFxsdRhGLt379b5+fka0IsWLdJaR77epB6DGqs3rRu/9rSWetNa6y1btujrr79ef//99/qtt97SGRkZ+tprr5XrrRnC1Z3Wcs1F4vF49D333KNramp0dXW1HjdunL7rrrvkmmtCuHrTWq43Eb8kEGlHH330kXa73drn82mttQ4EAjoxMVF//fXXMS5ZfDrzzDP1M888owsKCkLbpA4jO/CGOlJdST02dHAg0ti1p7Vcf1pr/Y9//EN7vd7Qz/fff78eOnSoXG/NEK7utJZrLpKioqIG9XbHHXfoe+65R665JoSrN63lehPxS4ZmtaPly5czYMAAHA4HADabjQEDBrBo0aIYlyz+VFVV4fV6uffee+nfvz833XQTWmupw8MQqa6kHsMLd+2BvIcBrrzySpxOZ+jnHj16kJubK9dbM4SrO7nmIuvRo0eo3nw+H0VFRdx2221yzTUhXL3J9SbimQQi7Wj37t2kpqY22JaWlsbOnTtjVKL4lZKSwqeffkpRURFz5szh2Wef5cknn5Q6PAyR6krqMbxw1x7Ie7gxK1eu5Be/+IVcby1QX3dyzTXPRx99xNixY1m0aBHr1q2Ta66ZDq43ud5EPJNApB05HI5QK0M9y7KwLCtGJYp/DoeDm266id/97ne8+uqrUoeHIVJdST027eBrr36b1Nt+hYWFBAIBzjvvPLneDtOBdVdPrrnIJk+ezJtvvsmJJ57I5ZdfLtdcMx1cb/XkehPxSAKRdtSrVy8qKysbbKuoqKBPnz4xKlHHce6551JRUSF1eBgi1ZXUY/PVX3sg7+EDmabJnDlzeOqppwC53g7HwXV3MLnmGlc/TOjvf/87e/fuJTs7W665Zji43vbu3dtgv1xvIp5IINKOJk2aRF5eXmgspt/vJz8/n1NOOSXGJYt/pmkyePBgqcPDEKmupB6br/7aA3kPH+iJJ55g5syZJCcnAzBhwgS53prp4Lrz+XwN9ss1F1liYiJZWVnyGXeY6ustPT29wXa53kQ8kUCkHY0bN47evXvz2WefAbB06VL69evH6NGjY1yy+PPZZ5/xyiuvhD4Mn3vuOX77299KHUZwcNd5pLqSetzv4HoLd+2BvIfrzZkzh0GDBlFWVsaGDRv46KOPqKiokOutGRqru0ceeUSuuQhKSkr44IMPQvWzZMkSrrjiCk466SS55iIIV2/Lly+X603ELXusC9CZGYbBe++9x0MPPcTatWtZvnw577zzDkqpWBct7mzfvp1bb72V1157jbFjx3LllVcyYcIEAKnDRuzdu5fnn38egFdeeYWePXsyZMiQsHWllJJ6pPF6i3TtyXsYXn/9dWbOnBm6iYFgS2tRUZFcb00IV3fPPPOMXHMR5OXlce211zJ48GAuuOACkpOT+cMf/hDxupJrLny9vfbaa3K9ibil9IGfkEIIIYQQQggRBTI0SwghhBBCCBF1EogIIYQQQgghok4CESGEEEIIIUTUSSAihBBCCCGEiDoJRIQQQgghhBBRJ4GIEEIIIYQQIuokEBFCCCGEEEJEnQQiQgghDlFTU8PatWtjXQwhhBCdmAQiQgjRTt5991369u1LSkoKf/3rX/H7/e3+mr/+9a957LHHWnWOvLw8TjnlFP70pz+1UamEEEKIQ0kgIoQQ7eS8885j0qRJHHfccfziF7/A4XC0+2uee+65nHrqqaGfFyxYwI4dOw7rHP379+ess85q66IJIYQQDUggIoQQ7chut2O326P2ej/5yU8YNWoUADt37uSaa64hEAhE7fWFEEKI5oret6MQQogGPB4PDz/8MDk5OXz11Vf07t2bBx54gMLCQh544AGSkpIwDIM333yT0047jZdeegmAqqoqHnroIdLT03nwwQfp3bs3N954I7fccguffvope/fu5bLLLuOrr75i165dPP3005x99tmsXr2amTNnorUmPz+f66+/nt69e4fO+9xzz7Fx40Zyc3NZunQpubm5obI+9thjlJSUsGTJEq655hquu+66GNSYEEKIzkQCESGEiJHbb7+d0aNHc/XVV3PdddcxZswYkpOTufPOO8nKymLhwoXMnz+fe+65hz59+jBr1iyOPPJIHnnkEXJycvj1r39NRUUF8+fPZ+bMmWzYsIHHH3+cnj17ctlll/HTn/4UCM4b6devH/3792fmzJkA9OvXjxNPPJH8/HwAli1bxltvvcXHH38MwPfffx+a0/Lvf/+bnj178pvf/IZly5Zx8sknM3ny5AaBihBCCHG4ZGiWEELEgGVZvPjii4wZMwYApRRXX301L7zwAgBut5thw4aRlZVFVlYWPXv2ZOfOnQCsWrUK0zQBGD9+PIYR/CgfMmQIY8eObVF55s6dy+TJk0M/9+nTJ/T/F198kTVr1vD//t//47///S+TJk1i+/btLXodIYQQop70iAghRAwUFxdTV1dHbW1taFu/fv3YtWtXo8crpbAsC4CxY8cyb948brnlFioqKjjvvPNaXZ7169c3mOR+oIKCAubMmcOQIUMAmDVrVqtfTwghhJAeESGEiIGysjIMw2Dz5s2hbV6vlwEDBjT53HvvvZfs7Gwef/xxLMvi7rvvblEZtNah/ycnJ7Nx48ZGj8vMzGTx4sUNtq1cubJFrymEEELUk0BECCHakd/vb3DDX7/tnnvu4dZbb+Vvf/tbaPuiRYu46aabAEK9H/Xqh2IBPP3005x11lmcccYZjBo1ioqKitA+y7IaPDcxMZGSkhJ2795Neno6SinWrFlDTU0NK1asoKamBoCpU6fyyiuvUFBQAMCWLVsoLi7G7/dzzjnnMGvWLBYsWEBRURH3339/VDOBCSGE6Jzkm0QIIdrJRx99xNKlSykpKeGqq64iISGB2tpalixZwtFHH83DDz/MHXfcwU033USvXr3Izs7muuuuo6ioiEWLFlFRUcHGjRvJy8ujsLCQd999l/Hjx5OcnMzdd99NSUkJtbW12O123nnnHfr168fixYvZs2cPq1evZsSIEVxyySVcfvnlzJ49m2nTpvHb3/6WU089ldNPP51TTz2V7777js2bN3P77beTl5fHmDFjGDduHH379sVms7Fu3TpuueUWNm/ezEUXXURWVhazZ89m+PDhsa5eIYQQHZzSBzfVCSGEiFsej4fbbruNp59+GrvdjtaavXv38n//93/cfPPNsS6eEEII0WwyNEsIITqQBQsWsHz5ciorK0PbVq1axYQJE2JYKiGEEOLwSSAihBAdSP3K6YMHD2bUqFFcfPHFZGRkhFZTF0IIIToKGZolhBBCCCGEiDrpERFCCCGEEEJEnQQiQgghhBBCiKiTQEQIIYQQQggRdRKICCGEEEIIIaJOAhEhhBBCCCFE1EkgIoQQQgghhIg6CUSEEEIIIYQQUSeBiBBCCCGEECLqJBARQgghhBBCRN3/B2/D31mcqX55AAAAAElFTkSuQmCC",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=(10, 5))\n",
+ "plot_channel = 10\n",
+ "p = plt.scatter(\n",
+ " data[\"downscaling\"][\"x_target\"][0, 0, :].detach().cpu() * STATION_LON_LAT_SF,\n",
+ " data[\"downscaling\"][\"x_target\"][0, 1, :].detach().cpu() * STATION_LON_LAT_SF,\n",
+ " c=station_forecast_unnorm[0, :],\n",
+ " vmax=30,\n",
+ " vmin=-30,\n",
+ " cmap=\"RdBu_r\",\n",
+ ")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label(\"(C)\")\n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"{local_forecast_var}\")\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.8.18"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "ff379d8b57ea10bc9abbe40475203c855480f57b5b4821ba344a2e4e1a8a455a"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/official-src/notebooks/forecast_demo.ipynb b/official-src/notebooks/forecast_demo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c24a7bb5754044f03f4345a12c12ec28c0858ee6
--- /dev/null
+++ b/official-src/notebooks/forecast_demo.ipynb
@@ -0,0 +1,430 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "d670ad72-3bd2-4429-88a5-3259c2e075c4",
+ "metadata": {},
+ "source": [
+ "# Forecast demo\n",
+ "Here we load the trained Aardvark Weather model and produce a global and station forecast using the sample data. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "9d765b5c-01c2-4387-8831-1d04e7e8507c",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "sys.path.append(\"../aardvark\")\n",
+ "\n",
+ "import pickle\n",
+ "import numpy as np\n",
+ "from e2e_model import *\n",
+ "\n",
+ "import matplotlib\n",
+ "from matplotlib import pyplot as plt\n",
+ "\n",
+ "matplotlib.rcParams[\"mathtext.fontset\"] = \"stix\"\n",
+ "matplotlib.rcParams[\"font.family\"] = \"STIXGeneral\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0d8e88e-2e86-4cd6-ac9f-e0c10c764f58",
+ "metadata": {},
+ "source": [
+ "Check a GPU is available"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "f73fff82-7d89-42c2-8054-27e8728a3cb7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "GPU is available.\n",
+ "GPU name: NVIDIA A100 80GB PCIe\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "\n",
+ "if torch.cuda.is_available():\n",
+ " print(\"GPU is available.\")\n",
+ " print(f\"GPU name: {torch.cuda.get_device_name(0)}\")\n",
+ "else:\n",
+ " print(\"GPU is not available, cannot produce forecast.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21766183-e62f-4da2-9fcc-84a9a57a9b53",
+ "metadata": {},
+ "source": [
+ "## Generate predictions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "339189b9-7a27-48e8-854e-3b88077fd330",
+ "metadata": {},
+ "source": [
+ "Load the sample data (for a detailed analysis and visualisation of the contents of this dataset see data_demo.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "ee888d7c-797c-4803-a535-80dfc7878853",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"../data/sample_data_final.pkl\", \"rb\") as fp:\n",
+ " data = pickle.load(fp)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0491848-b485-467e-9506-3722d43c4905",
+ "metadata": {},
+ "source": [
+ "Load the model to generate predictions at one day leadtime. First select which varaible to generate station forecasts for."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "c9cec0c7-55b5-4763-978d-40d55508b2f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "local_forecast_var = \"tas\" # Model weights included for windspeed (ws) and 2tm (tas)\n",
+ "\n",
+ "model = ConvCNPWeatherE2E(\n",
+ " device=\"cuda\",\n",
+ " lead_time=1,\n",
+ " se_model_path=\"../trained_models/encoder\",\n",
+ " forecast_model_path=\"../trained_models/processor\",\n",
+ " sf_model_path=f\"../trained_models/decoder/{local_forecast_var}/\",\n",
+ " return_gridded=True,\n",
+ " aux_data_path=\"../data/\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac6b232c-5c42-4fa6-8983-94906f7c454d",
+ "metadata": {},
+ "source": [
+ "Run the model to generate a forecast the sample data. This outputs the station forecast, gridded forevast and initial state"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "id": "51a9ef80-7171-457a-a424-68aafab8ac5f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "station_forecast, global_forecast, initial_state = model(data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa208496-7c2a-4015-b84b-781a958d9004",
+ "metadata": {},
+ "source": [
+ "## Visualise model predictions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c64e1ec-030e-46b8-bc78-8eee75f4b61a",
+ "metadata": {},
+ "source": [
+ "First look at the gridded forecasts. Visualise several variables"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "id": "3866c828-715b-44a0-a4b0-a7fb8964644c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "vars = [\n",
+ " \"u10\",\n",
+ " \"v10\",\n",
+ " \"t2m\",\n",
+ " \"mslp\",\n",
+ " \"z200\",\n",
+ " \"z500\",\n",
+ " \"z700\",\n",
+ " \"z850\",\n",
+ " \"q200\",\n",
+ " \"q500\",\n",
+ " \"q700\",\n",
+ " \"q850\",\n",
+ " \"t200\",\n",
+ " \"t500\",\n",
+ " \"t700\",\n",
+ " \"t850\",\n",
+ " \"u200\",\n",
+ " \"u500\",\n",
+ " \"u700\",\n",
+ " \"u850\",\n",
+ " \"v200\",\n",
+ " \"v500\",\n",
+ " \"v700\",\n",
+ " \"v850\",\n",
+ "]\n",
+ "\n",
+ "var_index_mapping = {k: v for v, k in enumerate(vars)}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "id": "a89589bd-fb59-4252-9bdb-89abac15a8a6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lon = np.linspace(0, 359, 240)\n",
+ "lat = np.linspace(-90, 90, 121)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bdbc4769-9257-4e0d-a7f8-6cc4d40adfda",
+ "metadata": {},
+ "source": [
+ "Select the variable and data to plot. To plot another variable simply change the variable argument below. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "id": "2ce0bfa1-d030-47cb-b984-0d693470bc22",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "variable = \"u10\"\n",
+ "var_index = var_index_mapping[variable]\n",
+ "initial_state_var = initial_state[0, ..., var_index].detach().cpu().numpy()\n",
+ "global_forecast_var = global_forecast[0, ..., var_index].detach().cpu().numpy()\n",
+ "colorscale_mag = np.max(np.abs(initial_state_var))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11a213c2-87a0-4cd2-8dbd-996e981842a7",
+ "metadata": {},
+ "source": [
+ "Plot the initial state"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "id": "aaf8b2f7-400a-4fb7-a33f-41940a62f986",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=(10, 5))\n",
+ "plot_channel = 10\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " initial_state_var,\n",
+ " levels=100,\n",
+ " vmax=colorscale_mag,\n",
+ " vmin=-colorscale_mag,\n",
+ " cmap=\"RdBu_r\",\n",
+ ")\n",
+ "cbar = fig.colorbar(p)\n",
+ "# cbar.set_label('(m/s)')\n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"{variable} initial state\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a879ce44-a843-4f39-a3e5-a80b5013d4be",
+ "metadata": {},
+ "source": [
+ "Plot the prediction at one day leadtime"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "id": "e2e3f8ec-d831-45cd-a12c-189c45567112",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=(10, 5))\n",
+ "plot_channel = 10\n",
+ "p = plt.contourf(\n",
+ " lon,\n",
+ " lat,\n",
+ " global_forecast_var,\n",
+ " levels=100,\n",
+ " vmax=colorscale_mag,\n",
+ " vmin=-colorscale_mag,\n",
+ " cmap=\"RdBu_r\",\n",
+ ")\n",
+ "cbar = fig.colorbar(p)\n",
+ "# cbar.set_label('(m/s)')\n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"{variable} forecast\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f0e149ea-e7d1-41af-8eb0-d9935d294f5c",
+ "metadata": {},
+ "source": [
+ "The model also returns the station forecasts for T2M"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "id": "c415e8eb-a4af-44ba-8ab3-c660a60b8198",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "STATION_LON_LAT_SF = 360\n",
+ "HADISD_SCALING_FACTOR = 10\n",
+ "# Factors to unnormalise predictions\n",
+ "mean = np.load(f\"../data/norm_factors/mean_hadisd_{local_forecast_var}.npy\")\n",
+ "std = np.load(f\"../data/norm_factors/std_hadisd_{local_forecast_var}.npy\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "id": "3983250f-34cb-41dd-8d48-afc030eee6b7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "station_forecast = (\n",
+ " station_forecast.detach().cpu() * std + mean\n",
+ ") * HADISD_SCALING_FACTOR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "id": "340e02ff-4da0-4432-b271-809e23eab614",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=(10, 5))\n",
+ "plot_channel = 10\n",
+ "p = plt.scatter(\n",
+ " data[\"downscaling\"][\"x_target\"][0, 0, :].detach().cpu() * STATION_LON_LAT_SF,\n",
+ " data[\"downscaling\"][\"x_target\"][0, 1, :].detach().cpu() * STATION_LON_LAT_SF,\n",
+ " c=station_forecast[0, :],\n",
+ " vmax=30,\n",
+ " vmin=-30,\n",
+ " cmap=\"RdBu_r\",\n",
+ ")\n",
+ "cbar = fig.colorbar(p)\n",
+ "cbar.set_label(\"(C)\")\n",
+ "plt.xlabel(\"Longitude\")\n",
+ "plt.ylabel(\"Latitude\")\n",
+ "plt.title(f\"{local_forecast_var}\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66f773d3-0cd6-4157-bcae-3c6848ced0d5",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75278e35-26b2-4865-8f23-7235473b698f",
+ "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.8.18"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "ff379d8b57ea10bc9abbe40475203c855480f57b5b4821ba344a2e4e1a8a455a"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/official-src/training/downscaling_run_pipeline.sh b/official-src/training/downscaling_run_pipeline.sh
new file mode 100644
index 0000000000000000000000000000000000000000..33dfe39e7782e19dfc60188d1e270d34401e3591
--- /dev/null
+++ b/official-src/training/downscaling_run_pipeline.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+python3 train_module.py \
+ --output_dir $3 \
+ --master_port 22348 \
+ --decoder base \
+ --loss downscaling_rmse \
+ --diff 0 \
+ --in_channels 36 \
+ --out_channels 1 \
+ --int_channels 24 \
+ --mode downscaling \
+ --lr 5e-4 \
+ --batch_size 64 \
+ --start_ind 0 \
+ --end_ind 24 \
+ --epoch 20 \
+ --weight_decay 1e-6 \
+ --downscaling_context aardvark \
+ --downscaling_train_start_date 2007-01-02 \
+ --downscaling_train_end_date 2017-12-31 \
+ --lead_time $1 \
+ --var $2
\ No newline at end of file
diff --git a/official-src/training/finetune.sh b/official-src/training/finetune.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2f00f3e546c65aa5f61d896bbc197217a3e3cda1
--- /dev/null
+++ b/official-src/training/finetune.sh
@@ -0,0 +1,9 @@
+python3 ../aardvark/generate_initial_condition_single.py \
+ --assimilation_model_path ENCODER_PATH
+
+python3 ../aardvark/finetune.py \
+ --assimilation_model_path ENCODER_PATH \
+ --forecast_model_path FORECAST_PATH \
+ --output_dir FINETUNE_PATH \
+ --lr 5e-5 \
+ --finetune_epochs 1
\ No newline at end of file
diff --git a/official-src/training/test/config.pkl b/official-src/training/test/config.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..25ec9eb0f1ecc87cf1b45982c07ba087e988f55b
--- /dev/null
+++ b/official-src/training/test/config.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:565f5a5ba9b564b2a63bcb30d20bd2f74045ef537ebf12a594a49eed577a5ace
+size 387
diff --git a/official-src/training/train_decoder.sh b/official-src/training/train_decoder.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ea1d0b5d3100aaa97a17833f2b7782a2cde1d871
--- /dev/null
+++ b/official-src/training/train_decoder.sh
@@ -0,0 +1,43 @@
+python3 ../aardvark/train_module.py \
+ --output_dir DECODER/TAS \
+ --master_port 22348 \
+ --decoder base \
+ --loss downscaling_rmse \
+ --diff 0 \
+ --in_channels 36 \
+ --out_channels 1 \
+ --int_channels 24 \
+ --mode downscaling \
+ --lr 5e-4 \
+ --batch_size 64 \
+ --start_ind 0 \
+ --end_ind 24 \
+ --epoch 20 \
+ --weight_decay 1e-6 \
+ --downscaling_context aardvark \
+ --downscaling_train_start_date 2007-01-02 \
+ --downscaling_train_end_date 2017-12-31 \
+ --lead_time 4 \
+ --var tas
+
+python3 ../aardvark/train_module.py \
+ --output_dir DECODER/WS \
+ --master_port 22348 \
+ --decoder base \
+ --loss downscaling_rmse \
+ --diff 0 \
+ --in_channels 36 \
+ --out_channels 1 \
+ --int_channels 24 \
+ --mode downscaling \
+ --lr 5e-4 \
+ --batch_size 64 \
+ --start_ind 0 \
+ --end_ind 24 \
+ --epoch 20 \
+ --weight_decay 1e-6 \
+ --downscaling_context aardvark \
+ --downscaling_train_start_date 2007-01-02 \
+ --downscaling_train_end_date 2017-12-31 \
+ --lead_time 4 \
+ --var ws
\ No newline at end of file
diff --git a/official-src/training/train_e2e.sh b/official-src/training/train_e2e.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0e940db12dbd75007e00fea22b171b372a14c345
--- /dev/null
+++ b/official-src/training/train_e2e.sh
@@ -0,0 +1,21 @@
+# Command for training with wind speed variable (ws)
+python3 ../aardvark/e2e_train.py \
+ --output_dir E2E/WS \
+ --loss downscaling_rmse \
+ --region global \
+ --lead_time 1 \
+ --sf_model_path DECODER_PATH \
+ --se_model_path ENCODER_PATH \
+ --forecast_model_path PROCESSOR_PATH \
+ --var ws
+
+# Command for training with temperature variable (tas)
+python3 ../aardvark/e2e_train.py \
+ --output_dir E2E/TAS \
+ --loss downscaling_rmse \
+ --region global \
+ --lead_time 1 \
+ --sf_model_path DECODER_PATH \
+ --se_model_path ENCODER_PATH \
+ --forecast_model_path PROCESSOR_PATH \
+ --var tas
\ No newline at end of file
diff --git a/official-src/training/train_encoder.sh b/official-src/training/train_encoder.sh
new file mode 100644
index 0000000000000000000000000000000000000000..278e4b70ccd700f53c2c88ae47556ca34cafd1e8
--- /dev/null
+++ b/official-src/training/train_encoder.sh
@@ -0,0 +1,16 @@
+python3 ../aardvark/train_module.py \
+ --output_dir ENCODER_PATH \
+ --master_port 12348 \
+ --decoder vit_assimilation \
+ --loss lw_rmse \
+ --diff 0 \
+ --in_channels 277 \
+ --out_channels 24 \
+ --int_channels 24 \
+ --mode assimilation \
+ --lr 5e-4 \
+ --batch_size 6 \
+ --start_ind 0 \
+ --end_ind 24 \
+ --epoch 100 \
+ --weight_per_variable 1
diff --git a/official-src/training/train_processor.sh b/official-src/training/train_processor.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e59ffe2a0ee903caf0b13963744255418752e94e
--- /dev/null
+++ b/official-src/training/train_processor.sh
@@ -0,0 +1,17 @@
+python3 ../aardvark/train_module.py \
+ --output_dir FORECAST_PATH/ \
+ --lead_time 1 \
+ --loss lw_rmse_pressure_weighted \
+ --diff 1 \
+ --mode forecast \
+ --in_channels 35 \
+ --out_channels 24 \
+ --int_channels 24 \
+ --decoder vit \
+ --ic era5 \
+ --film 0 \
+ --epoch 200 \
+ --weight_per_variable 0 \
+ --batch_size 24 \
+ --lr 5e-4 \
+ --era5_mode 4u
\ No newline at end of file
diff --git a/scripts/inference.py b/scripts/inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2127e0a205d5544a3159781f7fc935bab5b27fb
--- /dev/null
+++ b/scripts/inference.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+"""Run the one-day tas forecast through the official Aardvark modules."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+import copy
+import torch
+
+from model.aardvark_adapter import build_one_day_model, load_sample
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--root", type=Path, default=ROOT)
+ parser.add_argument("--device", default="cuda")
+ parser.add_argument("--checkpoint", type=Path, help="Optional checkpoint produced by scripts/train.py")
+ parser.add_argument("--output", type=Path, default=ROOT / "result" / "inference_one_day.json")
+ args = parser.parse_args()
+ root = args.root.resolve()
+ sample_path = root / "weights/sample_data/sample_data_final.pkl"
+ sample = load_sample(sample_path)
+ model = build_one_day_model(root / "weights", root / "official-src", args.device)
+ if args.checkpoint:
+ tuned = args.checkpoint.resolve()
+ payload = torch.load(tuned, map_location=args.device, weights_only=False)
+ target_model = model if payload["train_modules"] == "all" else model.sf_model
+ target_model.load_state_dict(payload["model"])
+ model.eval()
+ target = sample["y_target"].cpu()
+ with torch.inference_mode():
+ station, global_forecast, initial_state = model(copy.deepcopy(sample))
+ result_dir = root / "result"
+ result_dir.mkdir(parents=True, exist_ok=True)
+ torch.save(station.cpu(), result_dir / "prediction.pt")
+ torch.save(target, result_dir / "target.pt")
+ report = {
+ "device": args.device,
+ "lead_time_days": 1,
+ "station_tas_shape": list(station.shape),
+ "global_forecast_shape": list(global_forecast.shape),
+ "initial_state_shape": list(initial_state.shape),
+ "finite_outputs": bool(torch.isfinite(station).all()),
+ "weights": str(tuned) if args.checkpoint else "official",
+ }
+ args.output.parent.mkdir(parents=True, exist_ok=True)
+ args.output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+ print(json.dumps(report, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/result.py b/scripts/result.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c5c558bf615c03f0385e60f4b30841e1bdce00e
--- /dev/null
+++ b/scripts/result.py
@@ -0,0 +1,38 @@
+"""Show the saved Aardvark one-day inference summary."""
+
+import json
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import torch
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+if __name__ == "__main__":
+ result_dir = ROOT / "result"
+ prediction = torch.load(result_dir / "prediction.pt", map_location="cpu", weights_only=True)
+ target = torch.load(result_dir / "target.pt", map_location="cpu", weights_only=True)
+ valid = torch.isfinite(target)
+ rmse = torch.sqrt(torch.mean((prediction[valid] - target[valid]) ** 2))
+ mae = torch.mean((prediction[valid] - target[valid]).abs())
+ metrics = {
+ "normalized_rmse": float(rmse),
+ "normalized_mae": float(mae),
+ "valid_stations": int(valid.sum()),
+ "note": "Normalized sample-space metrics; not paper-comparable physical-unit scores.",
+ }
+ (result_dir / "metrics.json").write_text(json.dumps(metrics, indent=2) + "\n")
+ indices = torch.where(valid[0])[0][:300]
+ plt.figure(figsize=(10, 4))
+ plt.plot(target[0, indices], label="Target", linewidth=1)
+ plt.plot(prediction[0, indices], label="Prediction", linewidth=1)
+ plt.title(f"Aardvark station temperature (RMSE={rmse:.4f})")
+ plt.legend()
+ plt.tight_layout()
+ plt.savefig(result_dir / "comparison.png", dpi=150)
+ plt.close()
+ print(json.dumps(metrics, indent=2))
diff --git a/scripts/train.py b/scripts/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fcd97141eb64d6ebc09489f7cdb27f6b55081dc
--- /dev/null
+++ b/scripts/train.py
@@ -0,0 +1,216 @@
+"""Train the official Aardvark Day-1 TAS model on official-schema tasks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+from torch.utils.data import DataLoader
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from model.aardvark_adapter import build_one_day_model
+from model.sample_dataset import AardvarkTaskDataset, collate_tasks, discover_samples, split_samples
+
+
+def parse_args() -> argparse.Namespace:
+ pre_parser = argparse.ArgumentParser(add_help=False)
+ pre_parser.add_argument("--config", type=Path, default=ROOT / "conf" / "config.yaml")
+ known, _ = pre_parser.parse_known_args()
+ config = yaml.safe_load(known.config.read_text())["training"]
+
+ parser = argparse.ArgumentParser(description=__doc__, parents=[pre_parser])
+ parser.add_argument("--data", type=Path, default=ROOT / config["data"])
+ parser.add_argument("--output-dir", type=Path, default=ROOT / config["output_dir"])
+ parser.add_argument("--epochs", type=int, default=config["epochs"])
+ parser.add_argument("--train-steps", type=int, default=config["train_steps"])
+ parser.add_argument("--validation-steps", type=int, default=config["validation_steps"])
+ parser.add_argument("--validation-fraction", type=float, default=config["validation_fraction"])
+ parser.add_argument("--batch-size", type=int, default=config["batch_size"])
+ parser.add_argument("--learning-rate", type=float, default=config["learning_rate"])
+ parser.add_argument("--weight-decay", type=float, default=config["weight_decay"])
+ parser.add_argument("--gradient-clip", type=float, default=config["gradient_clip"])
+ parser.add_argument("--patience", type=int, default=config["patience"])
+ parser.add_argument("--seed", type=int, default=config["seed"])
+ parser.add_argument("--train-modules", choices=("decoder", "all"), default=config["train_modules"])
+ parser.add_argument("--resume", type=Path)
+ return parser.parse_args()
+
+
+def masked_metrics(prediction: torch.Tensor, target: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, int]:
+ valid = torch.isfinite(target)
+ count = int(valid.sum())
+ if count == 0:
+ raise RuntimeError("Aardvark task has no finite station targets")
+ error = prediction[valid] - target[valid]
+ return torch.sqrt(error.square().mean()), error.abs().mean(), count
+
+
+def configure_trainable_parameters(model: torch.nn.Module, train_modules: str) -> list[torch.nn.Parameter]:
+ for parameter in model.parameters():
+ parameter.requires_grad_(train_modules == "all")
+ if train_modules == "decoder":
+ for parameter in model.sf_model.parameters():
+ parameter.requires_grad_(True)
+ parameters = [parameter for parameter in model.parameters() if parameter.requires_grad]
+ if not parameters:
+ raise RuntimeError("No trainable parameters selected")
+ return parameters
+
+
+def checkpoint_payload(model, optimizer, scheduler, args, epoch, best_validation_rmse, history):
+ model_state = model.state_dict() if args.train_modules == "all" else model.sf_model.state_dict()
+ return {
+ "model": model_state,
+ "optimizer": optimizer.state_dict(),
+ "scheduler": scheduler.state_dict(),
+ "epoch": epoch,
+ "best_validation_rmse": best_validation_rmse,
+ "history": history,
+ "train_modules": args.train_modules,
+ "config": {key: str(value) if isinstance(value, Path) else value for key, value in vars(args).items()},
+ "torch_rng_state": torch.get_rng_state(),
+ "numpy_rng_state": np.random.get_state(),
+ "python_rng_state": random.getstate(),
+ }
+
+
+def main() -> None:
+ args = parse_args()
+ if not torch.cuda.is_available():
+ raise RuntimeError("The official Aardvark model requires CUDA")
+ if min(args.epochs, args.train_steps, args.validation_steps, args.batch_size) < 1:
+ raise ValueError("epochs, steps and batch_size must be at least 1")
+
+ random.seed(args.seed)
+ np.random.seed(args.seed)
+ torch.manual_seed(args.seed)
+ torch.cuda.manual_seed_all(args.seed)
+ args.output_dir.mkdir(parents=True, exist_ok=True)
+
+ samples = discover_samples(args.data)
+ train_samples, validation_samples = split_samples(samples, args.validation_fraction, args.seed)
+ train_loader = DataLoader(
+ AardvarkTaskDataset(train_samples, args.train_steps * args.batch_size),
+ batch_size=args.batch_size,
+ shuffle=True,
+ collate_fn=collate_tasks,
+ )
+ validation_loader = DataLoader(
+ AardvarkTaskDataset(validation_samples, args.validation_steps * args.batch_size),
+ batch_size=args.batch_size,
+ collate_fn=collate_tasks,
+ )
+
+ model = build_one_day_model(ROOT / "weights", ROOT / "official-src", "cuda")
+ model.return_gridded = False
+ parameters = configure_trainable_parameters(model, args.train_modules)
+ optimizer = torch.optim.AdamW(parameters, lr=args.learning_rate, weight_decay=args.weight_decay)
+ scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+ optimizer,
+ mode="min",
+ factor=0.5,
+ patience=max(1, args.patience // 2),
+ )
+
+ start_epoch = 0
+ best_validation_rmse = math.inf
+ history: list[dict[str, float | int]] = []
+ if args.resume:
+ payload = torch.load(args.resume, map_location="cuda", weights_only=False)
+ if payload["train_modules"] != args.train_modules:
+ raise ValueError("--train-modules must match the resumed checkpoint")
+ target_model = model if args.train_modules == "all" else model.sf_model
+ target_model.load_state_dict(payload["model"])
+ optimizer.load_state_dict(payload["optimizer"])
+ scheduler.load_state_dict(payload["scheduler"])
+ start_epoch = int(payload["epoch"]) + 1
+ best_validation_rmse = float(payload["best_validation_rmse"])
+ history = payload["history"]
+ torch.set_rng_state(payload["torch_rng_state"])
+ np.random.set_state(payload["numpy_rng_state"])
+ random.setstate(payload["python_rng_state"])
+
+ epochs_without_improvement = 0
+ last_path = args.output_dir / "last.pth"
+ best_path = args.output_dir / "best.pth"
+ for epoch in range(start_epoch, args.epochs):
+ model.train()
+ if args.train_modules == "decoder":
+ model.se_model.eval()
+ model.forecast_model.eval()
+ model.sf_model.train()
+ train_rmse = []
+ train_mae = []
+ for task in train_loader:
+ optimizer.zero_grad(set_to_none=True)
+ prediction = model(task)
+ target = task["y_target"].to(prediction.device)
+ rmse, mae, _ = masked_metrics(prediction, target)
+ rmse.backward()
+ torch.nn.utils.clip_grad_norm_(parameters, args.gradient_clip)
+ optimizer.step()
+ train_rmse.append(float(rmse.detach()))
+ train_mae.append(float(mae.detach()))
+
+ model.eval()
+ validation_rmse = []
+ validation_mae = []
+ valid_stations = 0
+ with torch.inference_mode():
+ for task in validation_loader:
+ prediction = model(task)
+ rmse, mae, valid_stations = masked_metrics(prediction, task["y_target"].to(prediction.device))
+ validation_rmse.append(float(rmse))
+ validation_mae.append(float(mae))
+
+ record = {
+ "epoch": epoch,
+ "train_rmse": float(np.mean(train_rmse)),
+ "train_mae": float(np.mean(train_mae)),
+ "validation_rmse": float(np.mean(validation_rmse)),
+ "validation_mae": float(np.mean(validation_mae)),
+ "learning_rate": optimizer.param_groups[0]["lr"],
+ "valid_stations": valid_stations,
+ }
+ history.append(record)
+ scheduler.step(record["validation_rmse"])
+ improved = record["validation_rmse"] < best_validation_rmse
+ if improved:
+ best_validation_rmse = record["validation_rmse"]
+ epochs_without_improvement = 0
+ else:
+ epochs_without_improvement += 1
+ payload = checkpoint_payload(model, optimizer, scheduler, args, epoch, best_validation_rmse, history)
+ torch.save(payload, last_path)
+ if improved:
+ torch.save(payload, best_path)
+ (args.output_dir / "history.json").write_text(json.dumps(history, indent=2) + "\n")
+ print(json.dumps(record, sort_keys=True))
+ if epochs_without_improvement >= args.patience:
+ break
+
+ report = {
+ "status": "completed",
+ "epochs_completed": len(history),
+ "train_modules": args.train_modules,
+ "train_samples": [str(path) for path in train_samples],
+ "validation_samples": [str(path) for path in validation_samples],
+ "best_validation_rmse": best_validation_rmse,
+ "best_checkpoint": str(best_path),
+ "last_checkpoint": str(last_path),
+ }
+ (args.output_dir / "train.json").write_text(json.dumps(report, indent=2) + "\n")
+ print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/weight/.gitkeep b/weight/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/weights/sample_data/sample_data_final.pkl b/weights/sample_data/sample_data_final.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..cc974f3fd8db6caa9c81c6abc0ca2c59541fbc77
--- /dev/null
+++ b/weights/sample_data/sample_data_final.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:536459e078220d7a8e5f6d3caa3846c930c6b759dbb21660df73473cbaf01d0c
+size 53759995
diff --git a/weights/trained_model/decoder/tas/config.pkl b/weights/trained_model/decoder/tas/config.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..3947fe4cda01687e9c83450d9fe73f9f929e1518
--- /dev/null
+++ b/weights/trained_model/decoder/tas/config.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63abd7e4f6e644632c86574a82ab7788840a5fbec8ed6b058b9c75e7382df2ea
+size 584
diff --git a/weights/trained_model/decoder/tas/lt_1/epoch_18 b/weights/trained_model/decoder/tas/lt_1/epoch_18
new file mode 100644
index 0000000000000000000000000000000000000000..b7c57bf0862fa0c250423bf9947da046c852a843
--- /dev/null
+++ b/weights/trained_model/decoder/tas/lt_1/epoch_18
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:323b63b0340d89f2ab0e68e088a97111c016e8fcd98bb86f9510c06a0ffbff4a
+size 253144569
diff --git a/weights/trained_model/decoder/tas/lt_1/losses_0.npy b/weights/trained_model/decoder/tas/lt_1/losses_0.npy
new file mode 100644
index 0000000000000000000000000000000000000000..75671f4877e45f43be127cb5285f84e94a23836b
--- /dev/null
+++ b/weights/trained_model/decoder/tas/lt_1/losses_0.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63e00e580c332ef3e3a5319d2c23d6d5254ae3700d6c798ce8d4ea14e1ac58da
+size 288
diff --git a/weights/trained_model/encoder/config.pkl b/weights/trained_model/encoder/config.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..92c78bf2a6f26976e360e16a7495449dbb052813
--- /dev/null
+++ b/weights/trained_model/encoder/config.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f4f6005c8eb953ec34e916b8ea343c41d67cd159c979ee9b2576ed1ac097ae6
+size 509
diff --git a/weights/trained_model/encoder/epoch_96 b/weights/trained_model/encoder/epoch_96
new file mode 100644
index 0000000000000000000000000000000000000000..687b42b59fd8b66b1c1da2ffb46dbc60b56e6dec
--- /dev/null
+++ b/weights/trained_model/encoder/epoch_96
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:040de0d4f387fa8ae63410b3246017f05a5f7c7a4cfb0b8e3a6d205a155e163a
+size 358482350
diff --git a/weights/trained_model/encoder/losses_0.npy b/weights/trained_model/encoder/losses_0.npy
new file mode 100644
index 0000000000000000000000000000000000000000..3c1f9a460ef0f70f8621d149aa35f387ad13ef97
--- /dev/null
+++ b/weights/trained_model/encoder/losses_0.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:327a30a39d6a822c90eeddc6a2c4531d09ecf6f3ab89bbc99043493909c9d103
+size 936
diff --git a/weights/trained_model/processor/config.pkl b/weights/trained_model/processor/config.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..3e8eb39468395052d091a3775d2a97ddfc0c57ca
--- /dev/null
+++ b/weights/trained_model/processor/config.pkl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b43c571963deafe9a66ed72000aaf421fee0beada9c703abc3049270866bde4
+size 444
diff --git a/weights/trained_model/processor/forecast_1/epoch_0 b/weights/trained_model/processor/forecast_1/epoch_0
new file mode 100644
index 0000000000000000000000000000000000000000..ce6136b99ab75cf291166c24329a0d36d4710be7
--- /dev/null
+++ b/weights/trained_model/processor/forecast_1/epoch_0
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be4a7572bb0dee6631d097dd72e20b6d4f0052d2526bb0a065d37d122b8194d8
+size 647732624
diff --git a/weights/trained_model/processor/forecast_1/losses_0.npy b/weights/trained_model/processor/forecast_1/losses_0.npy
new file mode 100644
index 0000000000000000000000000000000000000000..6223131ab44691731383f9b1808daedf804d3195
--- /dev/null
+++ b/weights/trained_model/processor/forecast_1/losses_0.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6e4224f3b1a6b974d86f37e08f06d1628e2dbbb5e01480deda1d33924c46edf
+size 136